Commit | Line | Data |
---|---|---|
15637ed4 RG |
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 | * | |
78ed81a3 | 36 | * from: @(#)vm_map.h 7.3 (Berkeley) 4/21/91 |
37 | * $Id$ | |
38 | */ | |
39 | ||
40 | /* | |
15637ed4 RG |
41 | * Copyright (c) 1987, 1990 Carnegie-Mellon University. |
42 | * All rights reserved. | |
43 | * | |
44 | * Authors: Avadis Tevanian, Jr., Michael Wayne Young | |
45 | * | |
46 | * Permission to use, copy, modify and distribute this software and | |
47 | * its documentation is hereby granted, provided that both the copyright | |
48 | * notice and this permission notice appear in all copies of the | |
49 | * software, derivative works or modified versions, and any portions | |
50 | * thereof, and that both notices appear in supporting documentation. | |
51 | * | |
52 | * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" | |
53 | * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND | |
54 | * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. | |
55 | * | |
56 | * Carnegie Mellon requests users of this software to return to | |
57 | * | |
58 | * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU | |
59 | * School of Computer Science | |
60 | * Carnegie Mellon University | |
61 | * Pittsburgh PA 15213-3890 | |
62 | * | |
63 | * any improvements or extensions that they make and grant Carnegie the | |
64 | * rights to redistribute these changes. | |
65 | * | |
15637ed4 RG |
66 | */ |
67 | ||
68 | /* | |
69 | * Virtual memory map module definitions. | |
70 | */ | |
71 | ||
72 | #ifndef _VM_MAP_ | |
73 | #define _VM_MAP_ | |
74 | ||
75 | /* | |
76 | * Types defined: | |
77 | * | |
78 | * vm_map_t the high-level address map data structure. | |
79 | * vm_map_entry_t an entry in an address map. | |
80 | * vm_map_version_t a timestamp of a map, for use with vm_map_lookup | |
81 | */ | |
82 | ||
83 | /* | |
84 | * Objects which live in maps may be either VM objects, or | |
85 | * another map (called a "sharing map") which denotes read-write | |
86 | * sharing with other maps. | |
87 | */ | |
88 | ||
89 | union vm_map_object { | |
90 | struct vm_object *vm_object; /* object object */ | |
91 | struct vm_map *share_map; /* share map */ | |
92 | struct vm_map *sub_map; /* belongs to another map */ | |
93 | }; | |
94 | ||
95 | typedef union vm_map_object vm_map_object_t; | |
96 | ||
97 | /* | |
98 | * Address map entries consist of start and end addresses, | |
99 | * a VM object (or sharing map) and offset into that object, | |
100 | * and user-exported inheritance and protection information. | |
101 | * Also included is control information for virtual copy operations. | |
102 | */ | |
103 | struct vm_map_entry { | |
104 | struct vm_map_entry *prev; /* previous entry */ | |
105 | struct vm_map_entry *next; /* next entry */ | |
106 | vm_offset_t start; /* start address */ | |
107 | vm_offset_t end; /* end address */ | |
108 | union vm_map_object object; /* object I point to */ | |
109 | vm_offset_t offset; /* offset into object */ | |
110 | boolean_t is_a_map; /* Is "object" a map? */ | |
111 | boolean_t is_sub_map; /* Is "object" a submap? */ | |
112 | /* Only in sharing maps: */ | |
113 | boolean_t copy_on_write; /* is data copy-on-write */ | |
114 | boolean_t needs_copy; /* does object need to be copied */ | |
115 | /* Only in task maps: */ | |
116 | vm_prot_t protection; /* protection code */ | |
117 | vm_prot_t max_protection; /* maximum protection */ | |
118 | vm_inherit_t inheritance; /* inheritance */ | |
119 | int wired_count; /* can be paged if = 0 */ | |
120 | }; | |
121 | ||
122 | typedef struct vm_map_entry *vm_map_entry_t; | |
123 | ||
124 | /* | |
125 | * Maps are doubly-linked lists of map entries, kept sorted | |
126 | * by address. A single hint is provided to start | |
127 | * searches again from the last successful search, | |
128 | * insertion, or removal. | |
129 | */ | |
130 | struct vm_map { | |
131 | struct pmap * pmap; /* Physical map */ | |
132 | lock_data_t lock; /* Lock for map data */ | |
133 | struct vm_map_entry header; /* List of entries */ | |
134 | int nentries; /* Number of entries */ | |
135 | vm_size_t size; /* virtual size */ | |
136 | boolean_t is_main_map; /* Am I a main map? */ | |
137 | int ref_count; /* Reference count */ | |
138 | simple_lock_data_t ref_lock; /* Lock for ref_count field */ | |
139 | vm_map_entry_t hint; /* hint for quick lookups */ | |
140 | simple_lock_data_t hint_lock; /* lock for hint storage */ | |
141 | vm_map_entry_t first_free; /* First free space hint */ | |
142 | boolean_t entries_pageable; /* map entries pageable?? */ | |
143 | unsigned int timestamp; /* Version number */ | |
144 | #define min_offset header.start | |
145 | #define max_offset header.end | |
146 | }; | |
147 | ||
148 | typedef struct vm_map *vm_map_t; | |
149 | ||
150 | /* | |
151 | * Map versions are used to validate a previous lookup attempt. | |
152 | * | |
153 | * Since lookup operations may involve both a main map and | |
154 | * a sharing map, it is necessary to have a timestamp from each. | |
155 | * [If the main map timestamp has changed, the share_map and | |
156 | * associated timestamp are no longer valid; the map version | |
157 | * does not include a reference for the imbedded share_map.] | |
158 | */ | |
159 | typedef struct { | |
160 | int main_timestamp; | |
161 | vm_map_t share_map; | |
162 | int share_timestamp; | |
163 | } vm_map_version_t; | |
164 | ||
165 | /* | |
166 | * Macros: vm_map_lock, etc. | |
167 | * Function: | |
168 | * Perform locking on the data portion of a map. | |
169 | */ | |
170 | ||
171 | #define vm_map_lock(map) { lock_write(&(map)->lock); (map)->timestamp++; } | |
172 | #define vm_map_unlock(map) lock_write_done(&(map)->lock) | |
173 | #define vm_map_lock_read(map) lock_read(&(map)->lock) | |
174 | #define vm_map_unlock_read(map) lock_read_done(&(map)->lock) | |
175 | ||
176 | /* | |
177 | * Exported procedures that operate on vm_map_t. | |
178 | */ | |
179 | ||
180 | void vm_map_init(); | |
181 | vm_map_t vm_map_create(); | |
182 | void vm_map_deallocate(); | |
183 | void vm_map_reference(); | |
184 | int vm_map_find(); | |
185 | int vm_map_remove(); | |
186 | int vm_map_lookup(); | |
187 | void vm_map_lookup_done(); | |
188 | int vm_map_protect(); | |
189 | int vm_map_inherit(); | |
190 | int vm_map_copy(); | |
191 | void vm_map_print(); | |
192 | void vm_map_copy_entry(); | |
193 | boolean_t vm_map_verify(); | |
194 | void vm_map_verify_done(); | |
195 | ||
196 | /* | |
197 | * Functions implemented as macros | |
198 | */ | |
199 | #define vm_map_min(map) ((map)->min_offset) | |
200 | #define vm_map_max(map) ((map)->max_offset) | |
201 | #define vm_map_pmap(map) ((map)->pmap) | |
202 | ||
203 | /* XXX: number of kernel maps and entries to statically allocate */ | |
204 | #define MAX_KMAP 10 | |
205 | ||
206 | #ifdef OMIT | |
207 | #define MAX_KMAPENT 500 | |
208 | #else /* !OMIT*/ | |
209 | #define MAX_KMAPENT 1000 /* 15 Aug 92*/ | |
210 | #endif /* !OMIT*/ | |
211 | ||
212 | #endif _VM_MAP_ |