LCOM1920-T02G10

/*        $NetBSD: uvm_fault_i.h,v 1.28 2012/02/19 00:05:56 rmind Exp $        */

/*

 * Copyright (c) 1997 Charles D. Cranor and Washington University.

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR

 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES

 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.

 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,

 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT

 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 *

 * from: Id: uvm_fault_i.h,v 1.1.6.1 1997/12/08 16:07:12 chuck Exp

 */

#ifndef _UVM_UVM_FAULT_I_H_

#define _UVM_UVM_FAULT_I_H_

/*

 * uvm_fault_i.h: fault inline functions

 */

/*

 * uvmfault_unlockmaps: unlock the maps

 */

static inline void

uvmfault_unlockmaps(struct uvm_faultinfo *ufi, bool write_locked)

{

        /*

         * ufi can be NULL when this isn't really a fault,

         * but merely paging in anon data.

         */

        if (ufi == NULL) {

                return;

        }

        if (write_locked) {

                vm_map_unlock(ufi->map);

        } else {

                vm_map_unlock_read(ufi->map);

        }

}

/*

 * uvmfault_unlockall: unlock everything passed in.

 *

 * => maps must be read-locked (not write-locked).

 */

static inline void

uvmfault_unlockall(struct uvm_faultinfo *ufi, struct vm_amap *amap,

    struct uvm_object *uobj)

{

        if (uobj)

                mutex_exit(uobj->vmobjlock);

        if (amap)

                amap_unlock(amap);

        uvmfault_unlockmaps(ufi, false);

}

/*

 * uvmfault_lookup: lookup a virtual address in a map

 *

 * => caller must provide a uvm_faultinfo structure with the IN

 *        params properly filled in

 * => we will lookup the map entry (handling submaps) as we go

 * => if the lookup is a success we will return with the maps locked

 * => if "write_lock" is true, we write_lock the map, otherwise we only

 *        get a read lock.

 * => note that submaps can only appear in the kernel and they are

 *        required to use the same virtual addresses as the map they

 *        are referenced by (thus address translation between the main

 *        map and the submap is unnecessary).

 */

static inline bool

uvmfault_lookup(struct uvm_faultinfo *ufi, bool write_lock)

{

        struct vm_map *tmpmap;

        /*

         * init ufi values for lookup.

         */

        ufi->map = ufi->orig_map;

        ufi->size = ufi->orig_size;

        /*

         * keep going down levels until we are done.   note that there can

         * only be two levels so we won't loop very long.

         */

        for (;;) {

                /*

                 * lock map

                 */

                if (write_lock) {

                        vm_map_lock(ufi->map);

                } else {

                        vm_map_lock_read(ufi->map);

                }

                /*

                 * lookup

                 */

                if (!uvm_map_lookup_entry(ufi->map, ufi->orig_rvaddr,

                    &ufi->entry)) {

                        uvmfault_unlockmaps(ufi, write_lock);

                        return(false);

                }

                /*

                 * reduce size if necessary

                 */

                if (ufi->entry->end - ufi->orig_rvaddr < ufi->size)

                        ufi->size = ufi->entry->end - ufi->orig_rvaddr;

                /*

                 * submap?    replace map with the submap and lookup again.

                 * note: VAs in submaps must match VAs in main map.

                 */

                if (UVM_ET_ISSUBMAP(ufi->entry)) {

                        tmpmap = ufi->entry->object.sub_map;

                        if (write_lock) {

                                vm_map_unlock(ufi->map);

                        } else {

                                vm_map_unlock_read(ufi->map);

                        }

                        ufi->map = tmpmap;

                        continue;

                }

                /*

                 * got it!

                 */

                ufi->mapv = ufi->map->timestamp;

                return(true);

        }        /* while loop */

        /*NOTREACHED*/

}

/*

 * uvmfault_relock: attempt to relock the same version of the map

 *

 * => fault data structures should be unlocked before calling.

 * => if a success (true) maps will be locked after call.

 */

static inline bool

uvmfault_relock(struct uvm_faultinfo *ufi)

{

        /*

         * ufi can be NULL when this isn't really a fault,

         * but merely paging in anon data.

         */

        if (ufi == NULL) {

                return true;

        }

        uvmexp.fltrelck++;

        /*

         * relock map.   fail if version mismatch (in which case nothing

         * gets locked).

         */

        vm_map_lock_read(ufi->map);

        if (ufi->mapv != ufi->map->timestamp) {

                vm_map_unlock_read(ufi->map);

                return(false);

        }

        uvmexp.fltrelckok++;

        return(true);

}

#endif /* _UVM_UVM_FAULT_I_H_ */