home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / bsd_srcs / sys / vm / vm_map.h < prev    next >
Encoding:
C/C++ Source or Header  |  1991-04-21  |  7.1 KB  |  205 lines
  1. /* 
  2.  * Copyright (c) 1991 Regents of the University of California.
  3.  * All rights reserved.
  4.  *
  5.  * This code is derived from software contributed to Berkeley by
  6.  * The Mach Operating System project at Carnegie-Mellon University.
  7.  *
  8.  * Redistribution and use in source and binary forms, with or without
  9.  * modification, are permitted provided that the following conditions
  10.  * are met:
  11.  * 1. Redistributions of source code must retain the above copyright
  12.  *    notice, this list of conditions and the following disclaimer.
  13.  * 2. Redistributions in binary form must reproduce the above copyright
  14.  *    notice, this list of conditions and the following disclaimer in the
  15.  *    documentation and/or other materials provided with the distribution.
  16.  * 3. All advertising materials mentioning features or use of this software
  17.  *    must display the following acknowledgement:
  18.  *    This product includes software developed by the University of
  19.  *    California, Berkeley and its contributors.
  20.  * 4. Neither the name of the University nor the names of its contributors
  21.  *    may be used to endorse or promote products derived from this software
  22.  *    without specific prior written permission.
  23.  *
  24.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  25.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  26.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  27.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  28.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  29.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  30.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  31.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  32.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  33.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  34.  * SUCH DAMAGE.
  35.  *
  36.  *    @(#)vm_map.h    7.3 (Berkeley) 4/21/91
  37.  *
  38.  *
  39.  * Copyright (c) 1987, 1990 Carnegie-Mellon University.
  40.  * All rights reserved.
  41.  *
  42.  * Authors: Avadis Tevanian, Jr., Michael Wayne Young
  43.  * 
  44.  * Permission to use, copy, modify and distribute this software and
  45.  * its documentation is hereby granted, provided that both the copyright
  46.  * notice and this permission notice appear in all copies of the
  47.  * software, derivative works or modified versions, and any portions
  48.  * thereof, and that both notices appear in supporting documentation.
  49.  * 
  50.  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" 
  51.  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND 
  52.  * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
  53.  * 
  54.  * Carnegie Mellon requests users of this software to return to
  55.  *
  56.  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
  57.  *  School of Computer Science
  58.  *  Carnegie Mellon University
  59.  *  Pittsburgh PA 15213-3890
  60.  *
  61.  * any improvements or extensions that they make and grant Carnegie the
  62.  * rights to redistribute these changes.
  63.  */
  64.  
  65. /*
  66.  *    Virtual memory map module definitions.
  67.  */
  68.  
  69. #ifndef    _VM_MAP_
  70. #define    _VM_MAP_
  71.  
  72. /*
  73.  *    Types defined:
  74.  *
  75.  *    vm_map_t        the high-level address map data structure.
  76.  *    vm_map_entry_t        an entry in an address map.
  77.  *    vm_map_version_t    a timestamp of a map, for use with vm_map_lookup
  78.  */
  79.  
  80. /*
  81.  *    Objects which live in maps may be either VM objects, or
  82.  *    another map (called a "sharing map") which denotes read-write
  83.  *    sharing with other maps.
  84.  */
  85.  
  86. union vm_map_object {
  87.     struct vm_object    *vm_object;    /* object object */
  88.     struct vm_map        *share_map;    /* share map */
  89.     struct vm_map        *sub_map;    /* belongs to another map */
  90. };
  91.  
  92. typedef union vm_map_object    vm_map_object_t;
  93.  
  94. /*
  95.  *    Address map entries consist of start and end addresses,
  96.  *    a VM object (or sharing map) and offset into that object,
  97.  *    and user-exported inheritance and protection information.
  98.  *    Also included is control information for virtual copy operations.
  99.  */
  100. struct vm_map_entry {
  101.     struct vm_map_entry    *prev;        /* previous entry */
  102.     struct vm_map_entry    *next;        /* next entry */
  103.     vm_offset_t        start;        /* start address */
  104.     vm_offset_t        end;        /* end address */
  105.     union vm_map_object    object;        /* object I point to */
  106.     vm_offset_t        offset;        /* offset into object */
  107.     boolean_t        is_a_map;    /* Is "object" a map? */
  108.     boolean_t        is_sub_map;    /* Is "object" a submap? */
  109.         /* Only in sharing maps: */
  110.     boolean_t        copy_on_write;    /* is data copy-on-write */
  111.     boolean_t        needs_copy;    /* does object need to be copied */
  112.         /* Only in task maps: */
  113.     vm_prot_t        protection;    /* protection code */
  114.     vm_prot_t        max_protection;    /* maximum protection */
  115.     vm_inherit_t        inheritance;    /* inheritance */
  116.     int            wired_count;    /* can be paged if = 0 */
  117. };
  118.  
  119. typedef struct vm_map_entry    *vm_map_entry_t;
  120.  
  121. /*
  122.  *    Maps are doubly-linked lists of map entries, kept sorted
  123.  *    by address.  A single hint is provided to start
  124.  *    searches again from the last successful search,
  125.  *    insertion, or removal.
  126.  */
  127. struct vm_map {
  128.     struct pmap *        pmap;        /* Physical map */
  129.     lock_data_t        lock;        /* Lock for map data */
  130.     struct vm_map_entry    header;        /* List of entries */
  131.     int            nentries;    /* Number of entries */
  132.     vm_size_t        size;        /* virtual size */
  133.     boolean_t        is_main_map;    /* Am I a main map? */
  134.     int            ref_count;    /* Reference count */
  135.     simple_lock_data_t    ref_lock;    /* Lock for ref_count field */
  136.     vm_map_entry_t        hint;        /* hint for quick lookups */
  137.     simple_lock_data_t    hint_lock;    /* lock for hint storage */
  138.     vm_map_entry_t        first_free;    /* First free space hint */
  139.     boolean_t        entries_pageable; /* map entries pageable?? */
  140.     unsigned int        timestamp;    /* Version number */
  141. #define    min_offset        header.start
  142. #define max_offset        header.end
  143. };
  144.  
  145. typedef    struct vm_map    *vm_map_t;
  146.  
  147. /*
  148.  *    Map versions are used to validate a previous lookup attempt.
  149.  *
  150.  *    Since lookup operations may involve both a main map and
  151.  *    a sharing map, it is necessary to have a timestamp from each.
  152.  *    [If the main map timestamp has changed, the share_map and
  153.  *    associated timestamp are no longer valid; the map version
  154.  *    does not include a reference for the imbedded share_map.]
  155.  */
  156. typedef struct {
  157.     int        main_timestamp;
  158.     vm_map_t    share_map;
  159.     int        share_timestamp;
  160. } vm_map_version_t;
  161.  
  162. /*
  163.  *    Macros:        vm_map_lock, etc.
  164.  *    Function:
  165.  *        Perform locking on the data portion of a map.
  166.  */
  167.  
  168. #define        vm_map_lock(map)    { lock_write(&(map)->lock); (map)->timestamp++; }
  169. #define        vm_map_unlock(map)    lock_write_done(&(map)->lock)
  170. #define        vm_map_lock_read(map)    lock_read(&(map)->lock)
  171. #define        vm_map_unlock_read(map)    lock_read_done(&(map)->lock)
  172.  
  173. /*
  174.  *    Exported procedures that operate on vm_map_t.
  175.  */
  176.  
  177. void        vm_map_init();
  178. vm_map_t    vm_map_create();
  179. void        vm_map_deallocate();
  180. void        vm_map_reference();
  181. int        vm_map_find();
  182. int        vm_map_remove();
  183. int        vm_map_lookup();
  184. void        vm_map_lookup_done();
  185. int        vm_map_protect();
  186. int        vm_map_inherit();
  187. int        vm_map_copy();
  188. void        vm_map_print();
  189. void        vm_map_copy_entry();
  190. boolean_t    vm_map_verify();
  191. void        vm_map_verify_done();
  192.  
  193. /*
  194.  *    Functions implemented as macros
  195.  */
  196. #define        vm_map_min(map)        ((map)->min_offset)
  197. #define        vm_map_max(map)        ((map)->max_offset)
  198. #define        vm_map_pmap(map)    ((map)->pmap)
  199.  
  200. /* XXX: number of kernel maps and entries to statically allocate */
  201. #define MAX_KMAP    10
  202. #define    MAX_KMAPENT    500
  203.  
  204. #endif    _VM_MAP_
  205.