![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vm_page.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / vm|
Return to vm_page.h CVS log | Up to [GnuMach] / Gnu-Mach / vm |
1.1 root 1: /*
2: * Mach Operating System
3: * Copyright (c) 1993-1988 Carnegie Mellon University
4: * All Rights Reserved.
5: *
6: * Permission to use, copy, modify and distribute this software and its
7: * documentation is hereby granted, provided that both the copyright
8: * notice and this permission notice appear in all copies of the
9: * software, derivative works or modified versions, and any portions
10: * thereof, and that both notices appear in supporting documentation.
11: *
12: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
13: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
14: * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
15: *
16: * Carnegie Mellon requests users of this software to return to
17: *
18: * Software Distribution Coordinator or [email protected]
19: * School of Computer Science
20: * Carnegie Mellon University
21: * Pittsburgh PA 15213-3890
22: *
23: * any improvements or extensions that they make and grant Carnegie Mellon
24: * the rights to redistribute these changes.
25: */
26: /*
27: * File: vm/vm_page.h
28: * Author: Avadis Tevanian, Jr., Michael Wayne Young
29: * Date: 1985
30: *
31: * Resident memory system definitions.
32: */
33:
34: #ifndef _VM_VM_PAGE_H_
35: #define _VM_VM_PAGE_H_
36:
37: #include <mach_vm_debug.h>
38:
39: #include <mach/boolean.h>
40: #include <mach/vm_prot.h>
41: #include <mach/vm_param.h>
42: #include <vm/vm_object.h>
43: #include <kern/queue.h>
44: #include <kern/lock.h>
45: #include <kern/zalloc.h>
46:
47: #include <kern/macro_help.h>
48: #include <kern/sched_prim.h> /* definitions of wait/wakeup */
49:
50: #if MACH_VM_DEBUG
51: #include <mach_debug/hash_info.h>
52: #endif
53:
54: /*
55: * Management of resident (logical) pages.
56: *
57: * A small structure is kept for each resident
58: * page, indexed by page number. Each structure
59: * is an element of several lists:
60: *
61: * A hash table bucket used to quickly
62: * perform object/offset lookups
63: *
64: * A list of all pages for a given object,
65: * so they can be quickly deactivated at
66: * time of deallocation.
67: *
68: * An ordered list of pages due for pageout.
69: *
70: * In addition, the structure contains the object
71: * and offset to which this page belongs (for pageout),
72: * and sundry status bits.
73: *
74: * Fields in this structure are locked either by the lock on the
75: * object that the page belongs to (O) or by the lock on the page
76: * queues (P). [Some fields require that both locks be held to
77: * change that field; holding either lock is sufficient to read.]
78: */
79:
80: struct vm_page {
81: queue_chain_t pageq; /* queue info for FIFO
82: * queue or free list (P) */
83: queue_chain_t listq; /* all pages in same object (O) */
84: struct vm_page *next; /* VP bucket link (O) */
85:
86: vm_object_t object; /* which object am I in (O,P) */
87: vm_offset_t offset; /* offset into that object (O,P) */
88:
89: unsigned int wire_count:16, /* how many wired down maps use me?
90: (O&P) */
91: /* boolean_t */ inactive:1, /* page is in inactive list (P) */
92: active:1, /* page is in active list (P) */
93: laundry:1, /* page is being cleaned now (P)*/
94: free:1, /* page is on free list (P) */
95: reference:1, /* page has been used (P) */
1.1.1.2 ! root 96: external:1, /* page considered external (P) */
! 97: extcounted:1, /* page counted in ext counts (P) */
1.1 root 98: :0; /* (force to 'long' boundary) */
99: #ifdef ns32000
100: int pad; /* extra space for ns32000 bit ops */
101: #endif /* ns32000 */
102:
103: unsigned int
104: /* boolean_t */ busy:1, /* page is in transit (O) */
105: wanted:1, /* someone is waiting for page (O) */
106: tabled:1, /* page is in VP table (O) */
107: fictitious:1, /* Physical page doesn't exist (O) */
108: private:1, /* Page should not be returned to
109: * the free list (O) */
110: absent:1, /* Data has been requested, but is
111: * not yet available (O) */
112: error:1, /* Data manager was unable to provide
113: * data due to error (O) */
114: dirty:1, /* Page must be cleaned (O) */
115: precious:1, /* Page is precious; data must be
116: * returned even if clean (O) */
117: overwriting:1, /* Request to unlock has been made
118: * without having data. (O)
119: * [See vm_object_overwrite] */
120: :0;
121:
122: vm_offset_t phys_addr; /* Physical address of page, passed
123: * to pmap_enter (read-only) */
124: vm_prot_t page_lock; /* Uses prohibited by data manager (O) */
125: vm_prot_t unlock_request; /* Outstanding unlock request (O) */
126: };
127:
128: typedef struct vm_page *vm_page_t;
129:
130: #define VM_PAGE_NULL ((vm_page_t) 0)
131:
132: /*
133: * For debugging, this macro can be defined to perform
134: * some useful check on a page structure.
135: */
136:
137: #define VM_PAGE_CHECK(mem)
138:
139: /*
140: * Each pageable resident page falls into one of three lists:
141: *
142: * free
143: * Available for allocation now.
144: * inactive
145: * Not referenced in any map, but still has an
146: * object/offset-page mapping, and may be dirty.
147: * This is the list of pages that should be
148: * paged out next.
149: * active
150: * A list of pages which have been placed in
151: * at least one physical map. This list is
152: * ordered, in LRU-like fashion.
153: */
154:
155: extern
156: vm_page_t vm_page_queue_free; /* memory free queue */
157: extern
158: vm_page_t vm_page_queue_fictitious; /* fictitious free queue */
159: extern
160: queue_head_t vm_page_queue_active; /* active memory queue */
161: extern
162: queue_head_t vm_page_queue_inactive; /* inactive memory queue */
163:
164: extern
165: vm_offset_t first_phys_addr; /* physical address for first_page */
166: extern
167: vm_offset_t last_phys_addr; /* physical address for last_page */
168:
169: extern
170: int vm_page_free_count; /* How many pages are free? */
171: extern
172: int vm_page_fictitious_count;/* How many fictitious pages are free? */
173: extern
174: int vm_page_active_count; /* How many pages are active? */
175: extern
176: int vm_page_inactive_count; /* How many pages are inactive? */
177: extern
178: int vm_page_wire_count; /* How many pages are wired? */
179: extern
180: int vm_page_free_target; /* How many do we want free? */
181: extern
182: int vm_page_free_min; /* When to wakeup pageout */
183: extern
184: int vm_page_inactive_target;/* How many do we want inactive? */
185: extern
186: int vm_page_free_reserved; /* How many pages reserved to do pageout */
187: extern
188: int vm_page_laundry_count; /* How many pages being laundered? */
1.1.1.2 ! root 189: extern
! 190: int vm_page_external_limit; /* Max number of pages for external objects */
! 191:
! 192: /* Only objects marked with the extcounted bit are included in this total.
! 193: Pages which we scan for possible pageout, but which are not actually
! 194: dirty, don't get considered against the external page limits any more
! 195: in this way. */
! 196: extern
! 197: int vm_page_external_count; /* How many pages for external objects? */
! 198:
! 199:
1.1 root 200:
201: decl_simple_lock_data(extern,vm_page_queue_lock)/* lock on active and inactive
202: page queues */
203: decl_simple_lock_data(extern,vm_page_queue_free_lock)
204: /* lock on free page queue */
205:
206: extern unsigned int vm_page_free_wanted;
207: /* how many threads are waiting for memory */
208:
209: extern vm_offset_t vm_page_fictitious_addr;
210: /* (fake) phys_addr of fictitious pages */
211:
212: extern void vm_page_bootstrap(
213: vm_offset_t *startp,
214: vm_offset_t *endp);
215: extern void vm_page_module_init(void);
216:
217: extern void vm_page_create(
218: vm_offset_t start,
219: vm_offset_t end);
220: extern vm_page_t vm_page_lookup(
221: vm_object_t object,
222: vm_offset_t offset);
223: extern vm_page_t vm_page_grab_fictitious(void);
224: extern void vm_page_release_fictitious(vm_page_t);
1.1.1.2 ! root 225: extern boolean_t vm_page_convert(vm_page_t, boolean_t);
1.1 root 226: extern void vm_page_more_fictitious(void);
1.1.1.2 ! root 227: extern vm_page_t vm_page_grab(boolean_t);
! 228: extern void vm_page_release(vm_page_t, boolean_t);
1.1 root 229: extern void vm_page_wait(void (*)(void));
230: extern vm_page_t vm_page_alloc(
231: vm_object_t object,
232: vm_offset_t offset);
233: extern void vm_page_init(
234: vm_page_t mem,
235: vm_offset_t phys_addr);
236: extern void vm_page_free(vm_page_t);
237: extern void vm_page_activate(vm_page_t);
238: extern void vm_page_deactivate(vm_page_t);
239: extern void vm_page_rename(
240: vm_page_t mem,
241: vm_object_t new_object,
242: vm_offset_t new_offset);
243: extern void vm_page_insert(
244: vm_page_t mem,
245: vm_object_t object,
246: vm_offset_t offset);
247: extern void vm_page_remove(
248: vm_page_t mem);
249:
250: extern void vm_page_zero_fill(vm_page_t);
251: extern void vm_page_copy(vm_page_t src_m, vm_page_t dest_m);
252:
253: extern void vm_page_wire(vm_page_t);
254: extern void vm_page_unwire(vm_page_t);
255:
256: extern void vm_set_page_size(void);
257:
258: #if MACH_VM_DEBUG
259: extern unsigned int vm_page_info(
260: hash_info_bucket_t *info,
261: unsigned int count);
262: #endif
263:
264: /*
265: * Functions implemented as macros
266: */
267:
268: #define PAGE_ASSERT_WAIT(m, interruptible) \
269: MACRO_BEGIN \
270: (m)->wanted = TRUE; \
271: assert_wait((event_t) (m), (interruptible)); \
272: MACRO_END
273:
274: #define PAGE_WAKEUP_DONE(m) \
275: MACRO_BEGIN \
276: (m)->busy = FALSE; \
277: if ((m)->wanted) { \
278: (m)->wanted = FALSE; \
279: thread_wakeup(((event_t) m)); \
280: } \
281: MACRO_END
282:
283: #define PAGE_WAKEUP(m) \
284: MACRO_BEGIN \
285: if ((m)->wanted) { \
286: (m)->wanted = FALSE; \
287: thread_wakeup((event_t) (m)); \
288: } \
289: MACRO_END
290:
291: #define VM_PAGE_FREE(p) \
292: MACRO_BEGIN \
293: vm_page_lock_queues(); \
294: vm_page_free(p); \
295: vm_page_unlock_queues(); \
296: MACRO_END
297:
298: /*
299: * Macro to be used in place of pmap_enter()
300: */
301:
302: #define PMAP_ENTER(pmap, virtual_address, page, protection, wired) \
303: MACRO_BEGIN \
304: pmap_enter( \
305: (pmap), \
306: (virtual_address), \
307: (page)->phys_addr, \
308: (protection) & ~(page)->page_lock, \
309: (wired) \
310: ); \
311: MACRO_END
312:
313: #define VM_PAGE_WAIT(continuation) vm_page_wait(continuation)
314:
315: #define vm_page_lock_queues() simple_lock(&vm_page_queue_lock)
316: #define vm_page_unlock_queues() simple_unlock(&vm_page_queue_lock)
317:
318: #define VM_PAGE_QUEUES_REMOVE(mem) \
319: MACRO_BEGIN \
320: if (mem->active) { \
321: queue_remove(&vm_page_queue_active, \
322: mem, vm_page_t, pageq); \
323: mem->active = FALSE; \
324: vm_page_active_count--; \
325: } \
326: \
327: if (mem->inactive) { \
328: queue_remove(&vm_page_queue_inactive, \
329: mem, vm_page_t, pageq); \
330: mem->inactive = FALSE; \
331: vm_page_inactive_count--; \
332: } \
333: MACRO_END
334:
335: #endif /* _VM_VM_PAGE_H_ */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.