![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vm_object.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_object.h CVS log | Up to [GnuMach] / Gnu-Mach / vm |
1.1.1.2 root 1: /*
1.1 root 2: * Mach Operating System
3: * Copyright (c) 1993-1987 Carnegie Mellon University
4: * All Rights Reserved.
1.1.1.2 root 5: *
1.1 root 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.
1.1.1.2 root 11: *
1.1 root 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.
1.1.1.2 root 15: *
1.1 root 16: * Carnegie Mellon requests users of this software to return to
1.1.1.2 root 17: *
1.1 root 18: * Software Distribution Coordinator or [email protected]
19: * School of Computer Science
20: * Carnegie Mellon University
21: * Pittsburgh PA 15213-3890
1.1.1.2 root 22: *
1.1 root 23: * any improvements or extensions that they make and grant Carnegie Mellon
24: * the rights to redistribute these changes.
25: */
26: /*
27: * File: vm_object.h
28: * Author: Avadis Tevanian, Jr., Michael Wayne Young
29: * Date: 1985
30: *
31: * Virtual memory object module definitions.
32: */
33:
34: #ifndef _VM_VM_OBJECT_H_
35: #define _VM_VM_OBJECT_H_
36:
1.1.1.3 root 37: #include <sys/types.h>
1.1 root 38: #include <mach/kern_return.h>
39: #include <mach/boolean.h>
40: #include <mach/memory_object.h>
41: #include <mach/port.h>
42: #include <mach/vm_prot.h>
43: #include <mach/machine/vm_types.h>
44: #include <kern/queue.h>
45: #include <kern/lock.h>
46: #include <kern/assert.h>
1.1.1.3 root 47: #include <kern/debug.h>
1.1.1.5 root 48: #include <kern/macros.h>
1.1 root 49: #include <vm/pmap.h>
1.1.1.3 root 50: #include <ipc/ipc_types.h>
1.1 root 51:
52: #if MACH_PAGEMAP
53: #include <vm/vm_external.h>
54: #endif /* MACH_PAGEMAP */
55:
56: typedef struct ipc_port * pager_request_t;
57: #define PAGER_REQUEST_NULL ((pager_request_t) 0)
58:
59: /*
60: * We use "struct ipc_port *" instead of "ipc_port_t"
61: * to avoid include file circularities.
62: */
63:
64: struct vm_object {
1.1.1.6 root 65: queue_head_t memq; /* Resident memory */
1.1 root 66: decl_simple_lock_data(, Lock) /* Synchronization */
67: #if VM_OBJECT_DEBUG
68: thread_t LockHolder; /* Thread holding Lock */
1.1.1.2 root 69: #endif /* VM_OBJECT_DEBUG */
1.1 root 70: vm_size_t size; /* Object size (only valid
71: * if internal)
72: */
73:
1.1.1.3 root 74: int ref_count; /* Number of references */
1.1.1.6 root 75: unsigned long resident_page_count;
1.1 root 76: /* number of resident pages */
77:
78: struct vm_object *copy; /* Object that should receive
79: * a copy of my changed pages
80: */
81: struct vm_object *shadow; /* My shadow */
82: vm_offset_t shadow_offset; /* Offset into shadow */
83:
84: struct ipc_port *pager; /* Where to get data */
85: vm_offset_t paging_offset; /* Offset into memory object */
86: pager_request_t pager_request; /* Where data comes back */
87: struct ipc_port *pager_name; /* How to identify region */
88:
89: memory_object_copy_strategy_t
90: copy_strategy; /* How to handle data copy */
91:
92: unsigned int
93: absent_count; /* The number of pages that
94: * have been requested but
95: * not filled. That is, the
96: * number of pages for which
97: * the "absent" attribute is
98: * asserted.
99: */
100:
101: unsigned int /* boolean_t array */
102: all_wanted; /* Bit array of "want to be
103: * awakened" notations. See
104: * VM_OBJECT_EVENT_* items
105: * below
106: */
107:
108: unsigned int
109: paging_in_progress:16,
110: /* The memory object ports are
111: * being used (e.g., for pagein
112: * or pageout) -- don't change any
113: * of these fields (i.e., don't
114: * collapse, destroy or terminate)
115: */
1.1.1.6 root 116: /* boolean_t */ used_for_pageout:1,/* The object carries data sent to
117: * a memory manager, which signals
118: * it's done by releasing memory.
119: * This flag prevents coalescing so
120: * that unmapping memory immediately
121: * results in object termination.
122: */
1.1 root 123: /* boolean_t */ pager_created:1,/* Has pager ever been created? */
124: /* boolean_t */ pager_initialized:1,/* Are fields ready to use? */
125: /* boolean_t */ pager_ready:1, /* Will manager take requests? */
126:
127: /* boolean_t */ can_persist:1, /* The kernel may keep the data
128: * for this object (and rights to
129: * the memory object) after all
130: * address map references are
131: * deallocated?
132: */
133: /* boolean_t */ internal:1, /* Created by the kernel (and
134: * therefore, managed by the
135: * default memory manger)
136: */
137: /* boolean_t */ temporary:1, /* Permanent objects may be changed
138: * externally by the memory manager,
139: * and changes made in memory must
140: * be reflected back to the memory
141: * manager. Temporary objects lack
142: * both of these characteristics.
143: */
144: /* boolean_t */ alive:1, /* Not yet terminated (debug) */
145: /* boolean_t */ lock_in_progress : 1,
146: /* Is a multi-page lock
147: * request in progress?
148: */
149: /* boolean_t */ lock_restart : 1,
150: /* Should lock request in
151: * progress restart search?
152: */
153: /* boolean_t */ use_shared_copy : 1,/* Use shared (i.e.,
154: * delayed) copy on write */
1.1.1.6 root 155: /* boolean_t */ shadowed: 1, /* Shadow may exist */
1.1 root 156:
1.1.1.6 root 157: /* boolean_t */ cached: 1; /* Object is cached */
1.1 root 158: queue_chain_t cached_list; /* Attachment point for the list
159: * of objects cached as a result
160: * of their can_persist value
161: */
162: vm_offset_t last_alloc; /* last allocation offset */
163: #if MACH_PAGEMAP
164: vm_external_t existence_info;
165: #endif /* MACH_PAGEMAP */
166: };
167:
168: extern
169: vm_object_t kernel_object; /* the single kernel object */
170:
171: /*
172: * Declare procedures that operate on VM objects.
173: */
174:
175: extern void vm_object_bootstrap(void);
176: extern void vm_object_init(void);
1.1.1.6 root 177: extern void vm_object_collect(vm_object_t);
1.1 root 178: extern void vm_object_terminate(vm_object_t);
179: extern vm_object_t vm_object_allocate(vm_size_t);
180: extern void vm_object_reference(vm_object_t);
181: extern void vm_object_deallocate(vm_object_t);
182: extern void vm_object_pmap_protect(
183: vm_object_t object,
184: vm_offset_t offset,
185: vm_size_t size,
186: pmap_t pmap,
187: vm_offset_t pmap_start,
188: vm_prot_t prot);
189: extern void vm_object_pmap_remove(
190: vm_object_t object,
191: vm_offset_t start,
192: vm_offset_t end);
193: extern void vm_object_page_remove(
194: vm_object_t object,
195: vm_offset_t start,
196: vm_offset_t end);
197: extern void vm_object_shadow(
198: vm_object_t *object, /* in/out */
199: vm_offset_t *offset, /* in/out */
200: vm_size_t length);
201: extern void vm_object_collapse(vm_object_t);
202: extern vm_object_t vm_object_lookup(struct ipc_port *);
203: extern vm_object_t vm_object_lookup_name(struct ipc_port *);
204: extern struct ipc_port *vm_object_name(vm_object_t);
205: extern void vm_object_remove(vm_object_t);
206:
207: extern boolean_t vm_object_copy_temporary(
208: vm_object_t *_object, /* in/out */
209: vm_offset_t *_offset, /* in/out */
210: boolean_t *_src_needs_copy, /* out */
211: boolean_t *_dst_needs_copy); /* out */
212: extern kern_return_t vm_object_copy_strategically(
213: vm_object_t src_object,
214: vm_offset_t src_offset,
215: vm_size_t size,
216: vm_object_t *dst_object, /* out */
217: vm_offset_t *dst_offset, /* out */
218: boolean_t *dst_needs_copy); /* out */
219: extern kern_return_t vm_object_copy_slowly(
220: vm_object_t src_object,
221: vm_offset_t src_offset,
222: vm_size_t size,
223: boolean_t interruptible,
224: vm_object_t *_result_object); /* out */
225:
226: extern vm_object_t vm_object_enter(
227: struct ipc_port *pager,
228: vm_size_t size,
229: boolean_t internal);
230: extern void vm_object_pager_create(
231: vm_object_t object);
232: extern void vm_object_destroy(
233: struct ipc_port *pager);
234:
1.1.1.2 root 235: extern void vm_object_page_map(
236: vm_object_t,
237: vm_offset_t,
238: vm_size_t,
1.1 root 239: vm_offset_t (*)(void *, vm_offset_t),
240: void *);
241:
242: extern vm_object_t vm_object_request_object(struct ipc_port *);
243:
1.1.1.3 root 244: extern boolean_t vm_object_coalesce(
245: vm_object_t prev_object,
246: vm_object_t next_object,
247: vm_offset_t prev_offset,
248: vm_offset_t next_offset,
249: vm_size_t prev_size,
250: vm_size_t next_size);
251:
252: extern void vm_object_pager_wakeup(ipc_port_t pager);
253:
1.1.1.4 root 254: void memory_object_release(
255: ipc_port_t pager,
256: pager_request_t pager_request,
257: ipc_port_t pager_name);
258:
259: void vm_object_deactivate_pages(vm_object_t);
260:
261: vm_object_t vm_object_copy_delayed(
262: vm_object_t src_object);
263:
1.1 root 264: /*
265: * Event waiting handling
266: */
267:
268: #define VM_OBJECT_EVENT_INITIALIZED 0
269: #define VM_OBJECT_EVENT_PAGER_READY 1
270: #define VM_OBJECT_EVENT_PAGING_IN_PROGRESS 2
271: #define VM_OBJECT_EVENT_ABSENT_COUNT 3
272: #define VM_OBJECT_EVENT_LOCK_IN_PROGRESS 4
273:
274: #define vm_object_wait(object, event, interruptible) \
275: MACRO_BEGIN \
276: (object)->all_wanted |= 1 << (event); \
277: vm_object_sleep(((vm_offset_t) object) + (event), \
278: (object), \
279: (interruptible)); \
280: MACRO_END
281:
282: #define vm_object_assert_wait(object, event, interruptible) \
283: MACRO_BEGIN \
284: (object)->all_wanted |= 1 << (event); \
285: assert_wait((event_t)(((vm_offset_t) object) + (event)), (interruptible)); \
286: MACRO_END
287:
288: #define vm_object_wakeup(object, event) \
289: MACRO_BEGIN \
290: if ((object)->all_wanted & (1 << (event))) \
291: thread_wakeup((event_t)(((vm_offset_t) object) + (event))); \
292: (object)->all_wanted &= ~(1 << (event)); \
293: MACRO_END
294:
295: /*
296: * Routines implemented as macros
297: */
298:
1.1.1.6 root 299: #define vm_object_collectable(object) \
300: (((object)->ref_count == 0) \
301: && ((object)->resident_page_count == 0))
302:
1.1 root 303: #define vm_object_paging_begin(object) \
304: ((object)->paging_in_progress++)
305:
306: #define vm_object_paging_end(object) \
307: MACRO_BEGIN \
308: assert((object)->paging_in_progress != 0); \
309: if (--(object)->paging_in_progress == 0) { \
310: vm_object_wakeup(object, \
311: VM_OBJECT_EVENT_PAGING_IN_PROGRESS); \
312: } \
313: MACRO_END
314:
315: #define vm_object_paging_wait(object, interruptible) \
316: MACRO_BEGIN \
317: while ((object)->paging_in_progress != 0) { \
318: vm_object_wait( (object), \
319: VM_OBJECT_EVENT_PAGING_IN_PROGRESS, \
320: (interruptible)); \
321: vm_object_lock(object); \
322: \
323: /*XXX if ((interruptible) && */ \
324: /*XXX (current_thread()->wait_result != THREAD_AWAKENED))*/ \
325: /*XXX break; */ \
326: } \
327: MACRO_END
328:
329: #define vm_object_absent_assert_wait(object, interruptible) \
330: MACRO_BEGIN \
331: vm_object_assert_wait( (object), \
332: VM_OBJECT_EVENT_ABSENT_COUNT, \
333: (interruptible)); \
334: MACRO_END
335:
336:
337: #define vm_object_absent_release(object) \
338: MACRO_BEGIN \
339: (object)->absent_count--; \
340: vm_object_wakeup((object), \
341: VM_OBJECT_EVENT_ABSENT_COUNT); \
342: MACRO_END
343:
344: /*
345: * Object locking macros (with and without debugging)
346: */
347:
348: #if VM_OBJECT_DEBUG
349: #define vm_object_lock_init(object) \
350: MACRO_BEGIN \
351: simple_lock_init(&(object)->Lock); \
352: (object)->LockHolder = 0; \
353: MACRO_END
354: #define vm_object_lock(object) \
355: MACRO_BEGIN \
356: simple_lock(&(object)->Lock); \
357: (object)->LockHolder = current_thread(); \
358: MACRO_END
359: #define vm_object_unlock(object) \
360: MACRO_BEGIN \
361: if ((object)->LockHolder != current_thread()) \
362: panic("vm_object_unlock 0x%x", (object)); \
363: (object)->LockHolder = 0; \
364: simple_unlock(&(object)->Lock); \
365: MACRO_END
366: #define vm_object_lock_try(object) \
367: (simple_lock_try(&(object)->Lock) \
368: ? ( ((object)->LockHolder = current_thread()) , TRUE) \
369: : FALSE)
370: #define vm_object_sleep(event, object, interruptible) \
371: MACRO_BEGIN \
372: if ((object)->LockHolder != current_thread()) \
373: panic("vm_object_sleep %#x", (object)); \
374: (object)->LockHolder = 0; \
375: thread_sleep((event_t)(event), simple_lock_addr((object)->Lock), \
376: (interruptible)); \
377: MACRO_END
378: #define vm_object_lock_taken(object) \
379: ((object)->LockHolder == current_thread())
380: #else /* VM_OBJECT_DEBUG */
381: #define vm_object_lock_init(object) simple_lock_init(&(object)->Lock)
382: #define vm_object_lock(object) simple_lock(&(object)->Lock)
383: #define vm_object_unlock(object) simple_unlock(&(object)->Lock)
384: #define vm_object_lock_try(object) simple_lock_try(&(object)->Lock)
385: #define vm_object_sleep(event, object, interruptible) \
386: thread_sleep((event_t)(event), simple_lock_addr((object)->Lock), \
387: (interruptible))
388: #define vm_object_lock_taken(object) simple_lock_taken(&(object)->Lock)
389: #endif /* VM_OBJECT_DEBUG */
390:
1.1.1.3 root 391: /*
392: * Page cache accounting.
393: *
1.1.1.7 ! root 394: * The page queues must be locked when changing these counters.
1.1.1.3 root 395: */
1.1.1.7 ! root 396: extern int vm_object_external_count;
! 397: extern int vm_object_external_pages;
1.1.1.3 root 398:
1.1 root 399: #endif /* _VM_VM_OBJECT_H_ */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.