![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pmap_private.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / machdep / i386|
Return to pmap_private.h CVS log | Up to [Apple Darwin 0.x] / kernel / machdep / i386 |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24:
25: /*
26: * Copyright (c) 1992 NeXT Computer, Inc.
27: *
28: * Intel386 Family: Private definitions for pmap.
29: *
30: * HISTORY
31: *
32: * 10 April 1992 ? at NeXT
33: * Created.
34: */
35:
36: /*
37: * For each managed physical page, there is a list of all currently
38: * valid virtual mappings of that page.
39: */
40: typedef struct pv_entry {
41: struct pv_entry * next; /* next pv_entry */
42: pmap_t pmap; /* pmap where mapping lies */
43: vm_offset_t va; /* virtual address for mapping */
44: } pv_head_t, *pv_entry_t;
45:
46: #define PV_ENTRY_NULL ((pv_entry_t) 0)
47:
48: zone_t pv_entry_zone; /* zone of pv_entry structures */
49:
50: /*
51: * First and last physical addresses that we maintain any information
52: * for. Initialized to zero so that pmap operations done before
53: * pmap_init won't touch any non-existent structures.
54: */
55: vm_offset_t vm_first_phys = (vm_offset_t) 0;
56: vm_offset_t vm_last_phys = (vm_offset_t) 0;
57: #define managed_page(pa) \
58: ((pa) >= vm_first_phys && (pa) < vm_last_phys)
59: boolean_t pmap_initialized = FALSE;/* Has pmap_init completed? */
60:
61: /*
62: * Page descriptor -
63: * Maintained for each managed page.
64: */
65: typedef struct pg_desc {
66: pv_head_t pv_list; /* head of pv list for page */
67: struct pg_exten * pg_exten; /* page extension for page */
68: unsigned int page_attrib :8, /* page attributes: */
69: #define PG_DIRTY 0x01 /* page has been modified */
70: #define PG_REFER 0x02 /* page has been referenced */
71: :0;
72: } pg_desc_t;
73:
74: #define PG_DESC_NULL ((pg_desc_t *) 0)
75:
76: pg_desc_t *pg_desc_tbl;
77: unsigned int pg_first_phys;
78:
79: #define pg_desc(pa) \
80: (&pg_desc_tbl[phys_to_pfn((unsigned int)(pa) - \
81: pg_first_phys) >> (ptes_per_vm_page - 1)])
82:
83: #define pg_desc_pvh(pd) (&(pd)->pv_list)
84:
85: /*
86: * Page extension -
87: * Contains information for pages used
88: * as page tables or page directories.
89: * NB: the 'links' field *must* be first.
90: */
91: typedef struct pg_exten {
92: queue_chain_t links; /* active/free queue links */
93: struct pg_desc * pg_desc; /* page descriptor for page */
94: unsigned int phys; /* physical address of page */
95: struct pmap * pmap; /* PT: which address map */
96: vm_offset_t offset; /* PT: what offset in map */
97: unsigned int alloc_count :16, /* PT: mappings, PD: pg dirs */
98: wired_count :16; /* PT: wired mappings */
99: unsigned int alloc_bmap :8, /* PD: alloc map */
100: unrefd_age :8, /* PT: # aging ticks */
101: :0;
102: } pg_exten_t;
103:
104: #define PG_EXTEN_NULL ((pg_exten_t *) 0)
105:
106: zone_t pg_exten_zone;
107:
108: /*
109: * A queue of free page tables is
110: * maintained which is emptied by
111: * pmap_update(). This strategy is
112: * used for two reasons. First, it is
113: * inconvenient to actually free the pages
114: * at the point in the code where it would
115: * be necessary. Secondly, keeping easily
116: * available spare page tables around makes
117: * pmap expansions quicker.
118: */
119: queue_head_t pt_active_queue, pt_free_queue;
120: int pt_active_count, pt_free_count;
121: int pt_alloc_count;
122:
123: static __inline__
124: void
125: pt_active_add(
126: pg_exten_t *pe
127: )
128: {
129: enqueue_tail(&pt_active_queue, (queue_entry_t)pe);
130: pt_active_count++;
131: }
132:
133: static __inline__
134: void
135: pt_active_remove(
136: pg_exten_t *pe
137: )
138: {
139: remqueue(&pt_active_queue, (queue_entry_t)pe);
140: pt_active_count--;
141: }
142:
143: static __inline__
144: pg_exten_t *
145: pt_free_obtain(
146: void
147: )
148: {
149: pg_exten_t *pe;
150:
151: if (((queue_entry_t)pe = dequeue_head(&pt_free_queue)))
152: pt_free_count--;
153:
154: return (pe);
155: }
156:
157: static __inline__
158: void
159: pt_free_add(
160: pg_exten_t *pe
161: )
162: {
163: enqueue_tail(&pt_free_queue, (queue_entry_t)pe);
164: pt_free_count++;
165: }
166:
167: /*
168: * A queue of pages that contain free
169: * page directories is maintained. This
170: * is also emptied by pmap_update() (if
171: * possible). This added complexity is
172: * needed to avoid wasting memory when
173: * running with a large MI page size.
174: */
175: queue_head_t pd_free_queue;
176: int pd_free_count;
177: int pd_alloc_count;
178:
179: static __inline__
180: pg_exten_t *
181: pd_free_obtain(
182: void
183: )
184: {
185: if (queue_empty(&pd_free_queue))
186: return (0);
187:
188: return ((pg_exten_t *) queue_first(&pd_free_queue));
189: }
190:
191: static __inline__
192: void
193: pd_free_add(
194: pg_exten_t *pe
195: )
196: {
197: enqueue_head(&pd_free_queue, (queue_entry_t)pe);
198: pd_free_count++;
199: }
200:
201: static __inline__
202: void
203: pd_free_remove(
204: pg_exten_t *pe
205: )
206: {
207: remqueue(&pd_free_queue, (queue_entry_t)pe);
208: pd_free_count--;
209: }
210:
211: /*
212: * A section is defined to be the amount
213: * of address space mapped by a single
214: * page table.
215: */
216:
217: /*
218: * Machine dependent sections.
219: */
220: #define I386_SECTBYTES ((I386_PGBYTES / sizeof (pt_entry_t)) * \
221: I386_PGBYTES)
222: #define i386_round_section(x) ((((unsigned int)(x)) + I386_SECTBYTES - 1) & \
223: ~(I386_SECTBYTES - 1))
224: #define i386_trunc_section(x) (((unsigned int)(x)) & ~(I386_SECTBYTES - 1))
225:
226: /*
227: * Machine independent sections.
228: */
229: #define SECTION_SIZE ((PAGE_SIZE / sizeof (pt_entry_t)) * \
230: I386_PGBYTES)
231: vm_offset_t section_size;
232: #define round_section(x) ((((unsigned int)(x)) + section_size - 1) & \
233: ~(section_size - 1))
234: #define trunc_section(x) (((unsigned int)(x)) & ~(section_size - 1))
235:
236: /*
237: * Locking and TLB invalidation
238: */
239:
240: /*
241: * Locking Protocols:
242: *
243: * There are two structures in the pmap module that need locking:
244: * the pmaps themselves, and the per-page pv_lists (which are locked
245: * by locking the pv_lock_table entry that corresponds to the pv_head
246: * for the list in question.) Most routines want to lock a pmap and
247: * then do operations in it that require pv_list locking -- however
248: * pmap_remove_all and pmap_copy_on_write operate on a physical page
249: * basis and want to do the locking in the reverse order, i.e. lock
250: * a pv_list and then go through all the pmaps referenced by that list.
251: * To protect against deadlock between these two cases, the pmap_lock
252: * is used. There are three different locking protocols as a result:
253: *
254: * 1. pmap operations only (pmap_extract, pmap_access, ...) Lock only
255: * the pmap.
256: *
257: * 2. pmap-based operations (pmap_enter, pmap_remove, ...) Get a read
258: * lock on the pmap_lock (shared read), then lock the pmap
259: * and finally the pv_lists as needed [i.e. pmap lock before
260: * pv_list lock.]
261: *
262: * 3. pv_list-based operations (pmap_remove_all, pmap_copy_on_write, ...)
263: * Get a write lock on the pmap_lock (exclusive write); this
264: * also guaranteees exclusive access to the pv_lists. Lock the
265: * pmaps as needed.
266: *
267: * At no time may any routine hold more than one pmap lock or more than
268: * one pv_list lock. Because interrupt level routines can allocate
269: * mbufs and cause pmap_enter's, the pmap_lock and the lock on the
270: * kernel_pmap can only be held at splvm.
271: *
272: * The dev_addr list is protected by using a write lock on the
273: * pmap_lock. Lookups are expected to be cheap.
274: */
275:
276: #define SPLVM(spl) { spl = splvm(); }
277: #define SPLX(spl) { splx(spl); }
278:
279: #define PMAP_READ_LOCK(pmap, spl) SPLVM(spl)
280: #define PMAP_WRITE_LOCK(spl) SPLVM(spl)
281: #define PMAP_READ_UNLOCK(pmap, spl) SPLX(spl)
282: #define PMAP_WRITE_UNLOCK(spl) SPLX(spl)
283: #define PMAP_WRITE_TO_READ_LOCK(pmap)
284:
285: #define LOCK_PVH(index)
286: #define UNLOCK_PVH(index)
287:
288: #define PMAP_UPDATE_TLBS(pmap, s, e) \
289: pmap_update_tlbs((pmap), (s), (e))
290:
291: struct {
292: int total;
293: int single;
294: } tlb_stat;
295:
296: /*
297: * Kernel pmap is statically
298: * allocated.
299: */
300: struct pmap kernel_pmap_store;
301: pmap_t kernel_pmap;
302:
303: /*
304: * Zone to allocate new
305: * pmaps from.
306: */
307: zone_t pmap_zone;
308:
309: int ptes_per_vm_page;
310:
311: static void pmap_expand(
312: pmap_t pmap,
313: vm_offset_t va);
314: static void pmap_allocate_mapping(
315: pmap_t pmap,
316: vm_offset_t va,
317: boolean_t wired);
318: static void pmap_deallocate_mappings(
319: pmap_t pmap,
320: vm_offset_t va,
321: int count,
322: int unwire_count,
323: boolean_t free_table);
324: static void pmap_wire_mapping(
325: pmap_t pmap,
326: vm_offset_t va);
327: static void pmap_unwire_mapping(
328: pmap_t pmap,
329: vm_offset_t va);
330: static void pmap_remove_range(
331: pmap_t pmap,
332: vm_offset_t start,
333: vm_offset_t end,
334: boolean_t free_table);
335: static void pmap_clear_page_attrib(
336: vm_offset_t pa,
337: int attrib);
338: static boolean_t pmap_check_page_attrib(
339: vm_offset_t pa,
340: int attrib);
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.