![[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 [Apple XNU] / XNU / osfmk / vm|
Return to vm_object.h CVS log | Up to [Apple XNU] / XNU / osfmk / vm |
1.1 ! root 1: /* ! 2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved. ! 3: * ! 4: * @APPLE_LICENSE_HEADER_START@ ! 5: * ! 6: * The contents of this file constitute Original Code as defined in and ! 7: * are subject to the Apple Public Source License Version 1.1 (the ! 8: * "License"). You may not use this file except in compliance with the ! 9: * License. Please obtain a copy of the License at ! 10: * http://www.apple.com/publicsource and read it before using this file. ! 11: * ! 12: * This Original Code and all software distributed under the License are ! 13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER ! 14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, ! 15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, ! 16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the ! 17: * License for the specific language governing rights and limitations ! 18: * under the License. ! 19: * ! 20: * @APPLE_LICENSE_HEADER_END@ ! 21: */ ! 22: /* ! 23: * @OSF_COPYRIGHT@ ! 24: */ ! 25: /* ! 26: * Mach Operating System ! 27: * Copyright (c) 1991,1990,1989,1988,1987 Carnegie Mellon University ! 28: * All Rights Reserved. ! 29: * ! 30: * Permission to use, copy, modify and distribute this software and its ! 31: * documentation is hereby granted, provided that both the copyright ! 32: * notice and this permission notice appear in all copies of the ! 33: * software, derivative works or modified versions, and any portions ! 34: * thereof, and that both notices appear in supporting documentation. ! 35: * ! 36: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" ! 37: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR ! 38: * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. ! 39: * ! 40: * Carnegie Mellon requests users of this software to return to ! 41: * ! 42: * Software Distribution Coordinator or [email protected] ! 43: * School of Computer Science ! 44: * Carnegie Mellon University ! 45: * Pittsburgh PA 15213-3890 ! 46: * ! 47: * any improvements or extensions that they make and grant Carnegie Mellon ! 48: * the rights to redistribute these changes. ! 49: */ ! 50: /* ! 51: */ ! 52: /* ! 53: * File: vm_object.h ! 54: * Author: Avadis Tevanian, Jr., Michael Wayne Young ! 55: * Date: 1985 ! 56: * ! 57: * Virtual memory object module definitions. ! 58: */ ! 59: ! 60: #ifndef _VM_VM_OBJECT_H_ ! 61: #define _VM_VM_OBJECT_H_ ! 62: ! 63: #include <mach_pagemap.h> ! 64: #include <task_swapper.h> ! 65: ! 66: #include <mach/kern_return.h> ! 67: #include <mach/boolean.h> ! 68: #include <mach/memory_object_types.h> ! 69: #include <mach/port.h> ! 70: #include <mach/vm_prot.h> ! 71: #include <mach/machine/vm_types.h> ! 72: #include <kern/queue.h> ! 73: #include <kern/lock.h> ! 74: #include <kern/assert.h> ! 75: #include <kern/macro_help.h> ! 76: #include <ipc/ipc_types.h> ! 77: #include <vm/pmap.h> ! 78: #include <kern/misc_protos.h> ! 79: ! 80: #if MACH_PAGEMAP ! 81: #include <vm/vm_external.h> ! 82: #endif /* MACH_PAGEMAP */ ! 83: ! 84: typedef struct ipc_port * pager_request_t; ! 85: #define PAGER_REQUEST_NULL ((pager_request_t) 0) ! 86: ! 87: /* ! 88: * Types defined: ! 89: * ! 90: * vm_object_t Virtual memory object. ! 91: * ! 92: * We use "struct ipc_port *" instead of "ipc_port_t" ! 93: * to avoid include file circularities. ! 94: */ ! 95: ! 96: struct vm_object { ! 97: queue_head_t memq; /* Resident memory */ ! 98: decl_mutex_data(, Lock) /* Synchronization */ ! 99: ! 100: vm_size_t size; /* Object size (only valid ! 101: * if internal) ! 102: */ ! 103: vm_size_t frozen_size; /* How much has been marked ! 104: * copy-on-write (only ! 105: * valid if copy_symmetric) ! 106: */ ! 107: int ref_count; /* Number of references */ ! 108: #if TASK_SWAPPER ! 109: int res_count; /* Residency references (swap)*/ ! 110: #endif /* TASK_SWAPPER */ ! 111: unsigned int resident_page_count; ! 112: /* number of resident pages */ ! 113: ! 114: struct vm_object *copy; /* Object that should receive ! 115: * a copy of my changed pages, ! 116: * for copy_delay, or just the ! 117: * temporary object that ! 118: * shadows this object, for ! 119: * copy_call. ! 120: */ ! 121: struct vm_object *shadow; /* My shadow */ ! 122: vm_offset_t shadow_offset; /* Offset into shadow */ ! 123: ! 124: struct ipc_port *pager; /* Where to get data */ ! 125: vm_offset_t paging_offset; /* Offset into memory object */ ! 126: pager_request_t pager_request; /* Where data comes back */ ! 127: ! 128: memory_object_copy_strategy_t ! 129: copy_strategy; /* How to handle data copy */ ! 130: ! 131: unsigned int absent_count; /* The number of pages that ! 132: * have been requested but ! 133: * not filled. That is, the ! 134: * number of pages for which ! 135: * the "absent" attribute is ! 136: * asserted. ! 137: */ ! 138: ! 139: unsigned int paging_in_progress; ! 140: /* The memory object ports are ! 141: * being used (e.g., for pagein ! 142: * or pageout) -- don't change ! 143: * any of these fields (i.e., ! 144: * don't collapse, destroy or ! 145: * terminate) ! 146: */ ! 147: unsigned int ! 148: /* boolean_t array */ all_wanted:11, /* Bit array of "want to be ! 149: * awakened" notations. See ! 150: * VM_OBJECT_EVENT_* items ! 151: * below */ ! 152: /* boolean_t */ pager_created:1, /* Has pager been created? */ ! 153: /* boolean_t */ pager_initialized:1, /* Are fields ready to use? */ ! 154: /* boolean_t */ pager_ready:1, /* Will pager take requests? */ ! 155: ! 156: /* boolean_t */ pager_trusted:1,/* The pager for this object ! 157: * is trusted. This is true for ! 158: * all internal objects (backed ! 159: * by the default pager) ! 160: */ ! 161: /* boolean_t */ can_persist:1, /* The kernel may keep the data ! 162: * for this object (and rights ! 163: * to the memory object) after ! 164: * all address map references ! 165: * are deallocated? ! 166: */ ! 167: /* boolean_t */ internal:1, /* Created by the kernel (and ! 168: * therefore, managed by the ! 169: * default memory manger) ! 170: */ ! 171: /* boolean_t */ temporary:1, /* Permanent objects may be ! 172: * changed externally by the ! 173: * memory manager, and changes ! 174: * made in memory must be ! 175: * reflected back to the memory ! 176: * manager. Temporary objects ! 177: * lack both of these ! 178: * characteristics. ! 179: */ ! 180: /* boolean_t */ private:1, /* magic device_pager object, ! 181: * holds private pages only */ ! 182: /* boolean_t */ pageout:1, /* pageout object. contains ! 183: * private pages that refer to ! 184: * a real memory object. */ ! 185: /* boolean_t */ alive:1, /* Not yet terminated */ ! 186: ! 187: /* boolean_t */ lock_in_progress:1, ! 188: /* Is a multi-page lock ! 189: * request in progress? ! 190: */ ! 191: /* boolean_t */ lock_restart:1, ! 192: /* Should lock request in ! 193: * progress restart search? ! 194: */ ! 195: /* boolean_t */ shadowed:1, /* Shadow may exist */ ! 196: /* boolean_t */ silent_overwrite:1, ! 197: /* Allow full page overwrite ! 198: * without data_request if ! 199: * page is absent */ ! 200: /* boolean_t */ advisory_pageout:1, ! 201: /* Instead of sending page ! 202: * via OOL, just notify ! 203: * pager that the kernel ! 204: * wants to discard it, page ! 205: * remains in object */ ! 206: /* boolean_t */ true_share:1; ! 207: /* This object is mapped ! 208: * in more than one place ! 209: * and hence cannot be ! 210: * coalesced */ ! 211: ! 212: ! 213: queue_chain_t cached_list; /* Attachment point for the ! 214: * list of objects cached as a ! 215: * result of their can_persist ! 216: * value ! 217: */ ! 218: ! 219: queue_head_t msr_q; /* memory object synchronise ! 220: request queue */ ! 221: ! 222: vm_offset_t last_alloc; /* last allocation offset */ ! 223: vm_size_t cluster_size; /* size of paging cluster */ ! 224: #if MACH_PAGEMAP ! 225: vm_external_map_t existence_map; /* bitmap of pages written to ! 226: * backing storage */ ! 227: #endif /* MACH_PAGEMAP */ ! 228: #if MACH_ASSERT ! 229: struct vm_object *paging_object; /* object which pages to be ! 230: * swapped out are temporary ! 231: * put in current object ! 232: */ ! 233: #endif ! 234: }; ! 235: ! 236: extern ! 237: vm_object_t kernel_object; /* the single kernel object */ ! 238: ! 239: int vm_object_absent_max; /* maximum number of absent pages ! 240: at a time for each object */ ! 241: ! 242: # define VM_MSYNC_INITIALIZED 0 ! 243: # define VM_MSYNC_SYNCHRONIZING 1 ! 244: # define VM_MSYNC_DONE 2 ! 245: ! 246: struct msync_req { ! 247: queue_chain_t msr_q; /* object request queue */ ! 248: queue_chain_t req_q; /* vm_msync request queue */ ! 249: unsigned int flag; ! 250: vm_offset_t offset; ! 251: vm_offset_t length; ! 252: vm_object_t object; /* back pointer */ ! 253: decl_mutex_data(, msync_req_lock) /* Lock for this structure */ ! 254: }; ! 255: ! 256: typedef struct msync_req *msync_req_t; ! 257: #define MSYNC_REQ_NULL ((msync_req_t) 0) ! 258: ! 259: /* ! 260: * Macros to allocate and free msync_reqs ! 261: */ ! 262: #define msync_req_alloc(msr) \ ! 263: MACRO_BEGIN \ ! 264: (msr) = (msync_req_t)kalloc(sizeof(struct msync_req)); \ ! 265: mutex_init(&(msr)->msync_req_lock, ETAP_VM_MSYNC); \ ! 266: msr->flag = VM_MSYNC_INITIALIZED; \ ! 267: MACRO_END ! 268: ! 269: #define msync_req_free(msr) \ ! 270: (kfree((vm_offset_t)(msr), sizeof(struct msync_req))) ! 271: ! 272: #define msr_lock(msr) mutex_lock(&(msr)->msync_req_lock) ! 273: #define msr_unlock(msr) mutex_unlock(&(msr)->msync_req_lock) ! 274: ! 275: /* ! 276: * Declare procedures that operate on VM objects. ! 277: */ ! 278: ! 279: extern void vm_object_bootstrap(void); ! 280: ! 281: extern void vm_object_init(void); ! 282: ! 283: extern vm_object_t vm_object_allocate( ! 284: vm_size_t size); ! 285: ! 286: #if MACH_ASSERT ! 287: extern void vm_object_reference( ! 288: vm_object_t object); ! 289: #else /* MACH_ASSERT */ ! 290: #define vm_object_reference(object) \ ! 291: MACRO_BEGIN \ ! 292: vm_object_t Object = (object); \ ! 293: if (Object) { \ ! 294: vm_object_lock(Object); \ ! 295: Object->ref_count++; \ ! 296: vm_object_res_reference(Object); \ ! 297: vm_object_unlock(Object); \ ! 298: } \ ! 299: MACRO_END ! 300: #endif /* MACH_ASSERT */ ! 301: ! 302: extern void vm_object_deallocate( ! 303: vm_object_t object); ! 304: ! 305: extern void vm_object_pmap_protect( ! 306: vm_object_t object, ! 307: vm_offset_t offset, ! 308: vm_offset_t size, ! 309: pmap_t pmap, ! 310: vm_offset_t pmap_start, ! 311: vm_prot_t prot); ! 312: ! 313: extern void vm_object_page_remove( ! 314: vm_object_t object, ! 315: vm_offset_t start, ! 316: vm_offset_t end); ! 317: ! 318: extern boolean_t vm_object_coalesce( ! 319: vm_object_t prev_object, ! 320: vm_object_t next_object, ! 321: vm_offset_t prev_offset, ! 322: vm_offset_t next_offset, ! 323: vm_size_t prev_size, ! 324: vm_size_t next_size); ! 325: ! 326: extern boolean_t vm_object_shadow( ! 327: vm_object_t *object, ! 328: vm_offset_t *offset, ! 329: vm_size_t length); ! 330: ! 331: extern void vm_object_collapse( ! 332: vm_object_t object); ! 333: ! 334: extern vm_object_t vm_object_lookup( ! 335: ipc_port_t port); ! 336: ! 337: extern ipc_port_t vm_object_name( ! 338: vm_object_t object); ! 339: ! 340: extern boolean_t vm_object_copy_quickly( ! 341: vm_object_t *_object, ! 342: vm_offset_t src_offset, ! 343: vm_size_t size, ! 344: boolean_t *_src_needs_copy, ! 345: boolean_t *_dst_needs_copy); ! 346: ! 347: extern kern_return_t vm_object_copy_strategically( ! 348: vm_object_t src_object, ! 349: vm_offset_t src_offset, ! 350: vm_size_t size, ! 351: vm_object_t *dst_object, ! 352: vm_offset_t *dst_offset, ! 353: boolean_t *dst_needs_copy); ! 354: ! 355: extern kern_return_t vm_object_copy_slowly( ! 356: vm_object_t src_object, ! 357: vm_offset_t src_offset, ! 358: vm_size_t size, ! 359: boolean_t interruptible, ! 360: vm_object_t *_result_object); ! 361: ! 362: extern void vm_object_pager_create( ! 363: vm_object_t object); ! 364: ! 365: extern void vm_object_destroy( ! 366: ipc_port_t pager); ! 367: ! 368: extern void vm_object_pager_wakeup( ! 369: ipc_port_t pager); ! 370: ! 371: extern void vm_object_page_map( ! 372: vm_object_t object, ! 373: vm_offset_t offset, ! 374: vm_size_t size, ! 375: vm_offset_t (*map_fn) ! 376: (void *, vm_offset_t), ! 377: void *map_fn_data); ! 378: ! 379: #if TASK_SWAPPER ! 380: ! 381: extern void vm_object_res_reference( ! 382: vm_object_t object); ! 383: extern void vm_object_res_deallocate( ! 384: vm_object_t object); ! 385: #define VM_OBJ_RES_INCR(object) (object)->res_count++ ! 386: #define VM_OBJ_RES_DECR(object) (object)->res_count-- ! 387: ! 388: #else /* TASK_SWAPPER */ ! 389: ! 390: #define VM_OBJ_RES_INCR(object) ! 391: #define VM_OBJ_RES_DECR(object) ! 392: #define vm_object_res_reference(object) ! 393: #define vm_object_res_deallocate(object) ! 394: ! 395: #endif /* TASK_SWAPPER */ ! 396: ! 397: extern vm_object_t vm_object_enter( ! 398: ipc_port_t pager, ! 399: vm_size_t size, ! 400: boolean_t internal, ! 401: boolean_t init); ! 402: ! 403: ! 404: extern vm_object_t vm_object_copy_delayed( ! 405: vm_object_t src_object, ! 406: vm_offset_t src_offset, ! 407: vm_size_t size); ! 408: ! 409: ! 410: /* ! 411: * Event waiting handling ! 412: */ ! 413: ! 414: #define VM_OBJECT_EVENT_INITIALIZED 0 ! 415: #define VM_OBJECT_EVENT_PAGER_READY 1 ! 416: #define VM_OBJECT_EVENT_PAGING_IN_PROGRESS 2 ! 417: #define VM_OBJECT_EVENT_ABSENT_COUNT 3 ! 418: #define VM_OBJECT_EVENT_LOCK_IN_PROGRESS 4 ! 419: #define VM_OBJECT_EVENT_UNCACHING 5 ! 420: #define VM_OBJECT_EVENT_COPY_CALL 6 ! 421: #define VM_OBJECT_EVENT_CACHING 7 ! 422: ! 423: #define vm_object_assert_wait(object, event, interruptible) \ ! 424: MACRO_BEGIN \ ! 425: (object)->all_wanted |= 1 << (event); \ ! 426: assert_wait((event_t)((vm_offset_t)(object)+(event)),(interruptible)); \ ! 427: MACRO_END ! 428: ! 429: #define vm_object_wait(object, event, interruptible) \ ! 430: MACRO_BEGIN \ ! 431: vm_object_assert_wait((object),(event),(interruptible)); \ ! 432: vm_object_unlock(object); \ ! 433: thread_block((void (*)(void)) 0); \ ! 434: MACRO_END ! 435: ! 436: #define vm_object_wakeup(object, event) \ ! 437: MACRO_BEGIN \ ! 438: if ((object)->all_wanted & (1 << (event))) \ ! 439: thread_wakeup((event_t)((vm_offset_t)(object) + (event))); \ ! 440: (object)->all_wanted &= ~(1 << (event)); \ ! 441: MACRO_END ! 442: ! 443: #define vm_object_set_wanted(object, event) \ ! 444: MACRO_BEGIN \ ! 445: ((object)->all_wanted |= (1 << (event))); \ ! 446: MACRO_END ! 447: ! 448: #define vm_object_wanted(object, event) \ ! 449: ((object)->all_wanted & (1 << (event))) ! 450: ! 451: /* ! 452: * Routines implemented as macros ! 453: */ ! 454: ! 455: #define vm_object_paging_begin(object) \ ! 456: MACRO_BEGIN \ ! 457: (object)->paging_in_progress++; \ ! 458: MACRO_END ! 459: ! 460: #define vm_object_paging_end(object) \ ! 461: MACRO_BEGIN \ ! 462: assert((object)->paging_in_progress != 0); \ ! 463: if (--(object)->paging_in_progress == 0) { \ ! 464: vm_object_wakeup(object, \ ! 465: VM_OBJECT_EVENT_PAGING_IN_PROGRESS); \ ! 466: } \ ! 467: MACRO_END ! 468: ! 469: #define vm_object_paging_wait(object, interruptible) \ ! 470: MACRO_BEGIN \ ! 471: while ((object)->paging_in_progress != 0) { \ ! 472: vm_object_wait( (object), \ ! 473: VM_OBJECT_EVENT_PAGING_IN_PROGRESS, \ ! 474: (interruptible)); \ ! 475: vm_object_lock(object); \ ! 476: \ ! 477: /*XXX if ((interruptible) && */ \ ! 478: /*XXX (current_thread()->wait_result != THREAD_AWAKENED))*/ \ ! 479: /*XXX break; */ \ ! 480: } \ ! 481: MACRO_END ! 482: ! 483: #define vm_object_absent_assert_wait(object, interruptible) \ ! 484: MACRO_BEGIN \ ! 485: vm_object_assert_wait( (object), \ ! 486: VM_OBJECT_EVENT_ABSENT_COUNT, \ ! 487: (interruptible)); \ ! 488: MACRO_END ! 489: ! 490: ! 491: #define vm_object_absent_release(object) \ ! 492: MACRO_BEGIN \ ! 493: (object)->absent_count--; \ ! 494: vm_object_wakeup((object), \ ! 495: VM_OBJECT_EVENT_ABSENT_COUNT); \ ! 496: MACRO_END ! 497: ! 498: /* ! 499: * Object locking macros ! 500: */ ! 501: ! 502: #define vm_object_lock_init(object) mutex_init(&(object)->Lock, ETAP_VM_OBJ) ! 503: #define vm_object_lock(object) mutex_lock(&(object)->Lock) ! 504: #define vm_object_unlock(object) mutex_unlock(&(object)->Lock) ! 505: #define vm_object_lock_try(object) mutex_try(&(object)->Lock) ! 506: ! 507: #endif /* _VM_VM_OBJECT_H_ */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.