![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to memory_object.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / vm|
Return to memory_object.c CVS log | Up to [Apple Darwin 0.x] / kernel / vm |
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: * Mach Operating System ! 27: * Copyright (c) 1992,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: * File: vm/memory_object.c ! 52: * Author: Michael Wayne Young ! 53: * ! 54: * External memory management interface control functions. ! 55: */ ! 56: ! 57: /* ! 58: * Interface dependencies: ! 59: */ ! 60: ! 61: #include <mach/std_types.h> /* For pointer_t */ ! 62: #include <mach/mach_types.h> ! 63: ! 64: #include <mach/kern_return.h> ! 65: #include <vm/vm_object.h> ! 66: #include <mach/memory_object.h> ! 67: #include <mach/memory_object_user.h> ! 68: #include <mach/memory_object_default.h> ! 69: #include <mach/boolean.h> ! 70: #include <mach/vm_prot.h> ! 71: #include <mach/message.h> ! 72: ! 73: /* ! 74: * Implementation dependencies: ! 75: */ ! 76: #include <vm/memory_object.h> ! 77: #include <vm/vm_page.h> ! 78: #include <vm/vm_pageout.h> ! 79: #include <vm/pmap.h> /* For copy_to_phys, pmap_clear_modify */ ! 80: #include <kern/thread.h> /* For current_thread() */ ! 81: #include <kern/host.h> ! 82: #include <vm/vm_kern.h> /* For kernel_map, vm_move */ ! 83: #include <vm/vm_map.h> /* For vm_map_pageable */ ! 84: #include <ipc/ipc_port.h> ! 85: ! 86: #include <norma_vm.h> ! 87: #include <norma_ipc.h> ! 88: #if NORMA_VM ! 89: #include <norma/xmm_server_rename.h> ! 90: #endif NORMA_VM ! 91: #include <mach_pagemap.h> ! 92: #if MACH_PAGEMAP ! 93: #include <vm/vm_external.h> ! 94: #endif MACH_PAGEMAP ! 95: ! 96: typedef int memory_object_lock_result_t; /* moved from below */ ! 97: ! 98: ! 99: ipc_port_t memory_manager_default = IP_NULL; ! 100: decl_simple_lock_data(,memory_manager_default_lock) ! 101: ! 102: /* ! 103: * Important note: ! 104: * All of these routines gain a reference to the ! 105: * object (first argument) as part of the automatic ! 106: * argument conversion. Explicit deallocation is necessary. ! 107: */ ! 108: ! 109: #if !NORMA_VM ! 110: /* ! 111: * If successful, destroys the map copy object. ! 112: */ ! 113: kern_return_t memory_object_data_provided(object, offset, data, data_cnt, ! 114: lock_value) ! 115: vm_object_t object; ! 116: vm_offset_t offset; ! 117: pointer_t data; ! 118: unsigned int data_cnt; ! 119: vm_prot_t lock_value; ! 120: { ! 121: return memory_object_data_supply(object, offset, (vm_map_copy_t) data, ! 122: data_cnt, lock_value, FALSE, IP_NULL, ! 123: 0); ! 124: } ! 125: #endif !NORMA_VM ! 126: ! 127: ! 128: kern_return_t memory_object_data_supply(object, offset, data_copy, data_cnt, ! 129: lock_value, precious, reply_to, reply_to_type) ! 130: register ! 131: vm_object_t object; ! 132: register ! 133: vm_offset_t offset; ! 134: vm_map_copy_t data_copy; ! 135: unsigned int data_cnt; ! 136: vm_prot_t lock_value; ! 137: boolean_t precious; ! 138: ipc_port_t reply_to; ! 139: mach_msg_type_name_t reply_to_type; ! 140: { ! 141: kern_return_t result = KERN_SUCCESS; ! 142: vm_offset_t error_offset = 0; ! 143: register ! 144: vm_page_t m; ! 145: register ! 146: vm_page_t data_m; ! 147: vm_size_t original_length; ! 148: vm_offset_t original_offset; ! 149: vm_page_t *page_list; ! 150: boolean_t was_absent; ! 151: vm_map_copy_t orig_copy = data_copy; ! 152: ! 153: /* ! 154: * Look for bogus arguments ! 155: */ ! 156: ! 157: if (object == VM_OBJECT_NULL) { ! 158: return(KERN_INVALID_ARGUMENT); ! 159: } ! 160: ! 161: if (lock_value & ~VM_PROT_ALL) { ! 162: vm_object_deallocate(object); ! 163: return(KERN_INVALID_ARGUMENT); ! 164: } ! 165: ! 166: if ((data_cnt % PAGE_SIZE) != 0) { ! 167: vm_object_deallocate(object); ! 168: return(KERN_INVALID_ARGUMENT); ! 169: } ! 170: ! 171: /* ! 172: * Adjust the offset from the memory object to the offset ! 173: * within the vm_object. ! 174: */ ! 175: ! 176: original_length = data_cnt; ! 177: original_offset = offset; ! 178: ! 179: assert(data_copy->type == VM_MAP_COPY_PAGE_LIST); ! 180: page_list = &data_copy->cpy_page_list[0]; ! 181: ! 182: vm_object_lock(object); ! 183: vm_object_paging_begin(object); ! 184: offset -= object->paging_offset; ! 185: ! 186: /* ! 187: * Loop over copy stealing pages for pagein. ! 188: */ ! 189: ! 190: for (; data_cnt > 0 ; data_cnt -= PAGE_SIZE, offset += PAGE_SIZE) { ! 191: ! 192: assert(data_copy->cpy_npages > 0); ! 193: data_m = *page_list; ! 194: ! 195: if (data_m == VM_PAGE_NULL || data_m->tabled || ! 196: data_m->error || data_m->absent || data_m->fictitious) { ! 197: ! 198: panic("Data_supply: bad page"); ! 199: } ! 200: ! 201: /* ! 202: * Look up target page and check its state. ! 203: */ ! 204: ! 205: retry_lookup: ! 206: m = vm_page_lookup(object,offset); ! 207: if (m == VM_PAGE_NULL) { ! 208: was_absent = FALSE; ! 209: } ! 210: else { ! 211: if (m->absent && m->busy) { ! 212: ! 213: /* ! 214: * Page was requested. Free the busy ! 215: * page waiting for it. Insertion ! 216: * of new page happens below. ! 217: */ ! 218: ! 219: VM_PAGE_FREE(m); ! 220: was_absent = TRUE; ! 221: } ! 222: else { ! 223: ! 224: /* ! 225: * Have to wait for page that is busy and ! 226: * not absent. This is probably going to ! 227: * be an error, but go back and check. ! 228: */ ! 229: if (m->busy) { ! 230: PAGE_ASSERT_WAIT(m, FALSE); ! 231: vm_object_unlock(object); ! 232: thread_block((void (*)()) 0); ! 233: vm_object_lock(object); ! 234: goto retry_lookup; ! 235: } ! 236: ! 237: /* ! 238: * Page already present; error. ! 239: * This is an error if data is precious. ! 240: */ ! 241: result = KERN_MEMORY_PRESENT; ! 242: error_offset = offset + object->paging_offset; ! 243: ! 244: break; ! 245: } ! 246: } ! 247: ! 248: /* ! 249: * Ok to pagein page. Target object now has no page ! 250: * at offset. Set the page parameters, then drop ! 251: * in new page and set up pageout state. Object is ! 252: * still locked here. ! 253: * ! 254: * Must clear busy bit in page before inserting it. ! 255: * Ok to skip wakeup logic because nobody else ! 256: * can possibly know about this page. ! 257: */ ! 258: ! 259: data_m->busy = FALSE; ! 260: data_m->dirty = FALSE; ! 261: pmap_clear_modify(data_m->phys_addr); ! 262: ! 263: data_m->page_lock = lock_value; ! 264: data_m->unlock_request = VM_PROT_NONE; ! 265: data_m->precious = precious; ! 266: ! 267: vm_page_lock_queues(); ! 268: vm_page_insert(data_m, object, offset); ! 269: ! 270: if (was_absent) ! 271: vm_page_activate(data_m); ! 272: else ! 273: vm_page_deactivate(data_m); ! 274: ! 275: vm_page_unlock_queues(); ! 276: ! 277: /* ! 278: * Null out this page list entry, and advance to next ! 279: * page. ! 280: */ ! 281: ! 282: *page_list++ = VM_PAGE_NULL; ! 283: ! 284: if (--(data_copy->cpy_npages) == 0 && ! 285: vm_map_copy_has_cont(data_copy)) { ! 286: vm_map_copy_t new_copy; ! 287: ! 288: vm_object_unlock(object); ! 289: ! 290: vm_map_copy_invoke_cont(data_copy, &new_copy, &result); ! 291: ! 292: if (result == KERN_SUCCESS) { ! 293: ! 294: /* ! 295: * Consume on success requires that ! 296: * we keep the original vm_map_copy ! 297: * around in case something fails. ! 298: * Free the old copy if it's not the original ! 299: */ ! 300: if (data_copy != orig_copy) { ! 301: vm_map_copy_discard(data_copy); ! 302: } ! 303: ! 304: if ((data_copy = new_copy) != VM_MAP_COPY_NULL) ! 305: page_list = &data_copy->cpy_page_list[0]; ! 306: ! 307: vm_object_lock(object); ! 308: } ! 309: else { ! 310: vm_object_lock(object); ! 311: error_offset = offset + object->paging_offset + ! 312: PAGE_SIZE; ! 313: break; ! 314: } ! 315: } ! 316: } ! 317: ! 318: /* ! 319: * Send reply if one was requested. ! 320: */ ! 321: vm_object_paging_end(object); ! 322: vm_object_unlock(object); ! 323: ! 324: if (vm_map_copy_has_cont(data_copy)) ! 325: vm_map_copy_abort_cont(data_copy); ! 326: ! 327: if (IP_VALID(reply_to)) { ! 328: memory_object_supply_completed( ! 329: reply_to, reply_to_type, ! 330: object->pager_request, ! 331: original_offset, ! 332: original_length, ! 333: result, ! 334: error_offset); ! 335: } ! 336: ! 337: vm_object_deallocate(object); ! 338: ! 339: /* ! 340: * Consume on success: The final data copy must be ! 341: * be discarded if it is not the original. The original ! 342: * gets discarded only if this routine succeeds. ! 343: */ ! 344: if (data_copy != orig_copy) ! 345: vm_map_copy_discard(data_copy); ! 346: if (result == KERN_SUCCESS) ! 347: vm_map_copy_discard(orig_copy); ! 348: ! 349: ! 350: return(result); ! 351: } ! 352: ! 353: kern_return_t memory_object_data_error(object, offset, size, error_value) ! 354: vm_object_t object; ! 355: vm_offset_t offset; ! 356: vm_size_t size; ! 357: kern_return_t error_value; ! 358: { ! 359: if (object == VM_OBJECT_NULL) ! 360: return(KERN_INVALID_ARGUMENT); ! 361: ! 362: if (size != round_page(size)) ! 363: return(KERN_INVALID_ARGUMENT); ! 364: ! 365: #ifdef lint ! 366: /* Error value is ignored at this time */ ! 367: error_value++; ! 368: #endif ! 369: ! 370: vm_object_lock(object); ! 371: offset -= object->paging_offset; ! 372: ! 373: while (size != 0) { ! 374: register vm_page_t m; ! 375: ! 376: m = vm_page_lookup(object, offset); ! 377: if ((m != VM_PAGE_NULL) && m->busy && m->absent) { ! 378: m->error = TRUE; ! 379: m->absent = FALSE; ! 380: vm_object_absent_release(object); ! 381: ! 382: PAGE_WAKEUP_DONE(m); ! 383: ! 384: vm_page_lock_queues(); ! 385: vm_page_activate(m); ! 386: vm_page_unlock_queues(); ! 387: } ! 388: ! 389: size -= PAGE_SIZE; ! 390: offset += PAGE_SIZE; ! 391: } ! 392: vm_object_unlock(object); ! 393: ! 394: vm_object_deallocate(object); ! 395: return(KERN_SUCCESS); ! 396: } ! 397: ! 398: kern_return_t memory_object_data_unavailable(object, offset, size) ! 399: vm_object_t object; ! 400: vm_offset_t offset; ! 401: vm_size_t size; ! 402: { ! 403: #if MACH_PAGEMAP ! 404: vm_external_t existence_info = VM_EXTERNAL_NULL; ! 405: #endif MACH_PAGEMAP ! 406: ! 407: if (object == VM_OBJECT_NULL) ! 408: return(KERN_INVALID_ARGUMENT); ! 409: ! 410: if (size != round_page(size)) ! 411: return(KERN_INVALID_ARGUMENT); ! 412: ! 413: #if MACH_PAGEMAP ! 414: if ((offset == 0) && (size > VM_EXTERNAL_LARGE_SIZE) && ! 415: (object->existence_info == VM_EXTERNAL_NULL)) { ! 416: existence_info = vm_external_create(VM_EXTERNAL_SMALL_SIZE); ! 417: } ! 418: #endif MACH_PAGEMAP ! 419: ! 420: vm_object_lock(object); ! 421: #if MACH_PAGEMAP ! 422: if (existence_info != VM_EXTERNAL_NULL) { ! 423: object->existence_info = existence_info; ! 424: } ! 425: if ((offset == 0) && (size > VM_EXTERNAL_LARGE_SIZE)) { ! 426: vm_object_unlock(object); ! 427: vm_object_deallocate(object); ! 428: return(KERN_SUCCESS); ! 429: } ! 430: #endif MACH_PAGEMAP ! 431: offset -= object->paging_offset; ! 432: ! 433: while (size != 0) { ! 434: register vm_page_t m; ! 435: ! 436: /* ! 437: * We're looking for pages that are both busy and ! 438: * absent (waiting to be filled), converting them ! 439: * to just absent. ! 440: * ! 441: * Pages that are just busy can be ignored entirely. ! 442: */ ! 443: ! 444: m = vm_page_lookup(object, offset); ! 445: if ((m != VM_PAGE_NULL) && m->busy && m->absent) { ! 446: PAGE_WAKEUP_DONE(m); ! 447: ! 448: vm_page_lock_queues(); ! 449: vm_page_activate(m); ! 450: vm_page_unlock_queues(); ! 451: } ! 452: size -= PAGE_SIZE; ! 453: offset += PAGE_SIZE; ! 454: } ! 455: ! 456: vm_object_unlock(object); ! 457: ! 458: vm_object_deallocate(object); ! 459: return(KERN_SUCCESS); ! 460: } ! 461: ! 462: /* ! 463: * Routine: memory_object_lock_page ! 464: * ! 465: * Description: ! 466: * Perform the appropriate lock operations on the ! 467: * given page. See the description of ! 468: * "memory_object_lock_request" for the meanings ! 469: * of the arguments. ! 470: * ! 471: * Returns an indication that the operation ! 472: * completed, blocked, or that the page must ! 473: * be cleaned. ! 474: */ ! 475: ! 476: #define MEMORY_OBJECT_LOCK_RESULT_DONE 0 ! 477: #define MEMORY_OBJECT_LOCK_RESULT_MUST_BLOCK 1 ! 478: #define MEMORY_OBJECT_LOCK_RESULT_MUST_CLEAN 2 ! 479: #define MEMORY_OBJECT_LOCK_RESULT_MUST_RETURN 3 ! 480: ! 481: memory_object_lock_result_t memory_object_lock_page(m, should_return, ! 482: should_flush, prot) ! 483: vm_page_t m; ! 484: memory_object_return_t should_return; ! 485: boolean_t should_flush; ! 486: vm_prot_t prot; ! 487: { ! 488: /* ! 489: * Don't worry about pages for which the kernel ! 490: * does not have any data. ! 491: */ ! 492: ! 493: if (m->absent) ! 494: return(MEMORY_OBJECT_LOCK_RESULT_DONE); ! 495: ! 496: /* ! 497: * If we cannot change access to the page, ! 498: * either because a mapping is in progress ! 499: * (busy page) or because a mapping has been ! 500: * wired, then give up. ! 501: */ ! 502: ! 503: if (m->busy) ! 504: return(MEMORY_OBJECT_LOCK_RESULT_MUST_BLOCK); ! 505: ! 506: assert(!m->fictitious); ! 507: ! 508: if (m->wire_count != 0) { ! 509: /* ! 510: * If no change would take place ! 511: * anyway, return successfully. ! 512: * ! 513: * No change means: ! 514: * Not flushing AND ! 515: * No change to page lock [2 checks] AND ! 516: * Don't need to send page to manager ! 517: * ! 518: * Don't need to send page to manager means: ! 519: * No clean or return request OR ( ! 520: * Page is not dirty [2 checks] AND ( ! 521: * Page is not precious OR ! 522: * No request to return precious pages )) ! 523: * ! 524: * Now isn't that straightforward and obvious ?? ;-) ! 525: * ! 526: * XXX This doesn't handle sending a copy of a wired ! 527: * XXX page to the pager, but that will require some ! 528: * XXX significant surgery. ! 529: */ ! 530: ! 531: if (!should_flush && ! 532: ((m->page_lock == prot) || (prot == VM_PROT_NO_CHANGE)) && ! 533: ((should_return == MEMORY_OBJECT_RETURN_NONE) || ! 534: (!m->dirty && !pmap_is_modified(m->phys_addr) && ! 535: (!m->precious || ! 536: should_return != MEMORY_OBJECT_RETURN_ALL)))) { ! 537: /* ! 538: * Restart page unlock requests, ! 539: * even though no change took place. ! 540: * [Memory managers may be expecting ! 541: * to see new requests.] ! 542: */ ! 543: m->unlock_request = VM_PROT_NONE; ! 544: PAGE_WAKEUP(m); ! 545: ! 546: return(MEMORY_OBJECT_LOCK_RESULT_DONE); ! 547: } ! 548: ! 549: return(MEMORY_OBJECT_LOCK_RESULT_MUST_BLOCK); ! 550: } ! 551: ! 552: /* ! 553: * If the page is to be flushed, allow ! 554: * that to be done as part of the protection. ! 555: */ ! 556: ! 557: if (should_flush) ! 558: prot = VM_PROT_ALL; ! 559: ! 560: /* ! 561: * Set the page lock. ! 562: * ! 563: * If we are decreasing permission, do it now; ! 564: * let the fault handler take care of increases ! 565: * (pmap_page_protect may not increase protection). ! 566: */ ! 567: ! 568: if (prot != VM_PROT_NO_CHANGE) { ! 569: if ((m->page_lock ^ prot) & prot) { ! 570: pmap_page_protect(m->phys_addr, VM_PROT_ALL & ~prot); ! 571: } ! 572: m->page_lock = prot; ! 573: ! 574: /* ! 575: * Restart any past unlock requests, even if no ! 576: * change resulted. If the manager explicitly ! 577: * requested no protection change, then it is assumed ! 578: * to be remembering past requests. ! 579: */ ! 580: ! 581: m->unlock_request = VM_PROT_NONE; ! 582: PAGE_WAKEUP(m); ! 583: } ! 584: ! 585: /* ! 586: * Handle cleaning. ! 587: */ ! 588: ! 589: if (should_return != MEMORY_OBJECT_RETURN_NONE) { ! 590: /* ! 591: * Check whether the page is dirty. If ! 592: * write permission has not been removed, ! 593: * this may have unpredictable results. ! 594: */ ! 595: ! 596: if (!m->dirty) ! 597: m->dirty = pmap_is_modified(m->phys_addr); ! 598: ! 599: if (m->dirty || (m->precious && ! 600: should_return == MEMORY_OBJECT_RETURN_ALL)) { ! 601: /* ! 602: * If we weren't planning ! 603: * to flush the page anyway, ! 604: * we may need to remove the ! 605: * page from the pageout ! 606: * system and from physical ! 607: * maps now. ! 608: */ ! 609: ! 610: vm_page_lock_queues(); ! 611: VM_PAGE_QUEUES_REMOVE(m); ! 612: vm_page_unlock_queues(); ! 613: ! 614: if (!should_flush) ! 615: pmap_page_protect(m->phys_addr, ! 616: VM_PROT_NONE); ! 617: ! 618: /* ! 619: * Cleaning a page will cause ! 620: * it to be flushed. ! 621: */ ! 622: ! 623: if (m->dirty) ! 624: return(MEMORY_OBJECT_LOCK_RESULT_MUST_CLEAN); ! 625: else ! 626: return(MEMORY_OBJECT_LOCK_RESULT_MUST_RETURN); ! 627: } ! 628: } ! 629: ! 630: /* ! 631: * Handle flushing ! 632: */ ! 633: ! 634: if (should_flush) { ! 635: VM_PAGE_FREE(m); ! 636: } else { ! 637: extern boolean_t vm_page_deactivate_hint; ! 638: ! 639: /* ! 640: * XXX Make clean but not flush a paging hint, ! 641: * and deactivate the pages. This is a hack ! 642: * because it overloads flush/clean with ! 643: * implementation-dependent meaning. This only ! 644: * happens to pages that are already clean. ! 645: */ ! 646: ! 647: if (vm_page_deactivate_hint && ! 648: (should_return != MEMORY_OBJECT_RETURN_NONE)) { ! 649: vm_page_lock_queues(); ! 650: vm_page_deactivate(m); ! 651: vm_page_unlock_queues(); ! 652: } ! 653: } ! 654: ! 655: return(MEMORY_OBJECT_LOCK_RESULT_DONE); ! 656: } ! 657: ! 658: /* ! 659: * Routine: memory_object_lock_request [user interface] ! 660: * ! 661: * Description: ! 662: * Control use of the data associated with the given ! 663: * memory object. For each page in the given range, ! 664: * perform the following operations, in order: ! 665: * 1) restrict access to the page (disallow ! 666: * forms specified by "prot"); ! 667: * 2) return data to the manager (if "should_return" ! 668: * is RETURN_DIRTY and the page is dirty, or ! 669: * "should_return" is RETURN_ALL and the page ! 670: * is either dirty or precious); and, ! 671: * 3) flush the cached copy (if "should_flush" ! 672: * is asserted). ! 673: * The set of pages is defined by a starting offset ! 674: * ("offset") and size ("size"). Only pages with the ! 675: * same page alignment as the starting offset are ! 676: * considered. ! 677: * ! 678: * A single acknowledgement is sent (to the "reply_to" ! 679: * port) when these actions are complete. If successful, ! 680: * the naked send right for reply_to is consumed. ! 681: */ ! 682: ! 683: kern_return_t ! 684: memory_object_lock_request(object, offset, size, ! 685: should_return, should_flush, prot, ! 686: reply_to, reply_to_type) ! 687: register vm_object_t object; ! 688: register vm_offset_t offset; ! 689: register vm_size_t size; ! 690: memory_object_return_t should_return; ! 691: boolean_t should_flush; ! 692: vm_prot_t prot; ! 693: ipc_port_t reply_to; ! 694: mach_msg_type_name_t reply_to_type; ! 695: { ! 696: register vm_page_t m; ! 697: vm_offset_t original_offset = offset; ! 698: vm_size_t original_size = size; ! 699: vm_offset_t paging_offset = 0; ! 700: vm_object_t new_object = VM_OBJECT_NULL; ! 701: vm_offset_t new_offset = 0; ! 702: vm_offset_t last_offset = offset; ! 703: int page_lock_result; ! 704: int pageout_action = 0; /* '=0' to quiet lint */ ! 705: ! 706: #define DATA_WRITE_MAX 32 ! 707: vm_page_t holding_pages[DATA_WRITE_MAX]; ! 708: ! 709: /* ! 710: * Check for bogus arguments. ! 711: */ ! 712: if (object == VM_OBJECT_NULL || ! 713: ((prot & ~VM_PROT_ALL) != 0 && prot != VM_PROT_NO_CHANGE)) ! 714: return (KERN_INVALID_ARGUMENT); ! 715: ! 716: size = round_page(size); ! 717: ! 718: /* ! 719: * Lock the object, and acquire a paging reference to ! 720: * prevent the memory_object and control ports from ! 721: * being destroyed. ! 722: */ ! 723: ! 724: vm_object_lock(object); ! 725: vm_object_paging_begin(object); ! 726: offset -= object->paging_offset; ! 727: ! 728: /* ! 729: * To avoid blocking while scanning for pages, save ! 730: * dirty pages to be cleaned all at once. ! 731: * ! 732: * XXXO A similar strategy could be used to limit the ! 733: * number of times that a scan must be restarted for ! 734: * other reasons. Those pages that would require blocking ! 735: * could be temporarily collected in another list, or ! 736: * their offsets could be recorded in a small array. ! 737: */ ! 738: ! 739: /* ! 740: * XXX NOTE: May want to consider converting this to a page list ! 741: * XXX vm_map_copy interface. Need to understand object ! 742: * XXX coalescing implications before doing so. ! 743: */ ! 744: ! 745: #define PAGEOUT_PAGES \ ! 746: MACRO_BEGIN \ ! 747: vm_map_copy_t copy; \ ! 748: register int i; \ ! 749: register vm_page_t hp; \ ! 750: \ ! 751: vm_object_unlock(object); \ ! 752: \ ! 753: (void) vm_map_copyin_object(new_object, 0, new_offset, ©); \ ! 754: \ ! 755: if (object->use_old_pageout) { \ ! 756: assert(pageout_action == MEMORY_OBJECT_LOCK_RESULT_MUST_CLEAN); \ ! 757: (void) memory_object_data_write( \ ! 758: object->pager, \ ! 759: object->pager_request, \ ! 760: paging_offset, \ ! 761: (pointer_t) copy, \ ! 762: new_offset); \ ! 763: } \ ! 764: else { \ ! 765: (void) memory_object_data_return( \ ! 766: object->pager, \ ! 767: object->pager_request, \ ! 768: paging_offset, \ ! 769: (pointer_t) copy, \ ! 770: new_offset, \ ! 771: (pageout_action == MEMORY_OBJECT_LOCK_RESULT_MUST_CLEAN), \ ! 772: !should_flush); \ ! 773: } \ ! 774: \ ! 775: vm_object_lock(object); \ ! 776: \ ! 777: for (i = 0; i < atop(new_offset); i++) { \ ! 778: hp = holding_pages[i]; \ ! 779: if (hp != VM_PAGE_NULL) \ ! 780: VM_PAGE_FREE(hp); \ ! 781: } \ ! 782: \ ! 783: new_object = VM_OBJECT_NULL; \ ! 784: MACRO_END ! 785: ! 786: for (; ! 787: size != 0; ! 788: size -= PAGE_SIZE, offset += PAGE_SIZE) ! 789: { ! 790: /* ! 791: * Limit the number of pages to be cleaned at once. ! 792: */ ! 793: if (new_object != VM_OBJECT_NULL && ! 794: new_offset >= PAGE_SIZE * DATA_WRITE_MAX) ! 795: { ! 796: PAGEOUT_PAGES; ! 797: } ! 798: ! 799: while ((m = vm_page_lookup(object, offset)) != VM_PAGE_NULL) { ! 800: switch ((page_lock_result = memory_object_lock_page(m, ! 801: should_return, ! 802: should_flush, ! 803: prot))) ! 804: { ! 805: case MEMORY_OBJECT_LOCK_RESULT_DONE: ! 806: /* ! 807: * End of a cluster of dirty pages. ! 808: */ ! 809: if (new_object != VM_OBJECT_NULL) { ! 810: PAGEOUT_PAGES; ! 811: continue; ! 812: } ! 813: break; ! 814: ! 815: case MEMORY_OBJECT_LOCK_RESULT_MUST_BLOCK: ! 816: /* ! 817: * Since it is necessary to block, ! 818: * clean any dirty pages now. ! 819: */ ! 820: if (new_object != VM_OBJECT_NULL) { ! 821: PAGEOUT_PAGES; ! 822: continue; ! 823: } ! 824: ! 825: PAGE_ASSERT_WAIT(m, FALSE); ! 826: vm_object_unlock(object); ! 827: thread_block((void (*)()) 0); ! 828: vm_object_lock(object); ! 829: continue; ! 830: ! 831: case MEMORY_OBJECT_LOCK_RESULT_MUST_CLEAN: ! 832: case MEMORY_OBJECT_LOCK_RESULT_MUST_RETURN: ! 833: /* ! 834: * The clean and return cases are similar. ! 835: * ! 836: * Mark the page busy since we unlock the ! 837: * object below. ! 838: */ ! 839: m->busy = TRUE; ! 840: ! 841: /* ! 842: * if this would form a discontiguous block, ! 843: * clean the old pages and start anew. ! 844: * ! 845: * NOTE: The first time through here, new_object ! 846: * is null, hiding the fact that pageout_action ! 847: * is not initialized. ! 848: */ ! 849: if (new_object != VM_OBJECT_NULL && ! 850: (last_offset != offset || ! 851: pageout_action != page_lock_result)) { ! 852: PAGEOUT_PAGES; ! 853: } ! 854: ! 855: vm_object_unlock(object); ! 856: ! 857: /* ! 858: * If we have not already allocated an object ! 859: * for a range of pages to be written, do so ! 860: * now. ! 861: */ ! 862: if (new_object == VM_OBJECT_NULL) { ! 863: new_object = vm_object_allocate(original_size); ! 864: new_offset = 0; ! 865: paging_offset = m->offset + ! 866: object->paging_offset; ! 867: pageout_action = page_lock_result; ! 868: } ! 869: ! 870: /* ! 871: * Move or copy the dirty page into the ! 872: * new object. ! 873: */ ! 874: m = vm_pageout_setup(m, ! 875: m->offset + object->paging_offset, ! 876: new_object, ! 877: new_offset, ! 878: should_flush); ! 879: ! 880: /* ! 881: * Save the holding page if there is one. ! 882: */ ! 883: holding_pages[atop(new_offset)] = m; ! 884: new_offset += PAGE_SIZE; ! 885: last_offset = offset + PAGE_SIZE; ! 886: ! 887: vm_object_lock(object); ! 888: break; ! 889: } ! 890: break; ! 891: } ! 892: } ! 893: ! 894: /* ! 895: * We have completed the scan for applicable pages. ! 896: * Clean any pages that have been saved. ! 897: */ ! 898: if (new_object != VM_OBJECT_NULL) { ! 899: PAGEOUT_PAGES; ! 900: } ! 901: ! 902: if (IP_VALID(reply_to)) { ! 903: vm_object_unlock(object); ! 904: ! 905: /* consumes our naked send-once/send right for reply_to */ ! 906: (void) memory_object_lock_completed(reply_to, reply_to_type, ! 907: object->pager_request, original_offset, original_size); ! 908: ! 909: vm_object_lock(object); ! 910: } ! 911: ! 912: vm_object_paging_end(object); ! 913: vm_object_unlock(object); ! 914: vm_object_deallocate(object); ! 915: ! 916: return (KERN_SUCCESS); ! 917: } ! 918: ! 919: #if !NORMA_VM ! 920: /* ! 921: * Old version of memory_object_lock_request. ! 922: */ ! 923: kern_return_t ! 924: xxx_memory_object_lock_request(object, offset, size, ! 925: should_clean, should_flush, prot, ! 926: reply_to, reply_to_type) ! 927: register vm_object_t object; ! 928: register vm_offset_t offset; ! 929: register vm_size_t size; ! 930: boolean_t should_clean; ! 931: boolean_t should_flush; ! 932: vm_prot_t prot; ! 933: ipc_port_t reply_to; ! 934: mach_msg_type_name_t reply_to_type; ! 935: { ! 936: register int should_return; ! 937: ! 938: if (should_clean) ! 939: should_return = MEMORY_OBJECT_RETURN_DIRTY; ! 940: else ! 941: should_return = MEMORY_OBJECT_RETURN_NONE; ! 942: ! 943: return(memory_object_lock_request(object,offset,size, ! 944: should_return, should_flush, prot, ! 945: reply_to, reply_to_type)); ! 946: } ! 947: #endif !NORMA_VM ! 948: ! 949: kern_return_t ! 950: memory_object_set_attributes_common(object, object_ready, may_cache, ! 951: copy_strategy, use_old_pageout) ! 952: vm_object_t object; ! 953: boolean_t object_ready; ! 954: boolean_t may_cache; ! 955: memory_object_copy_strategy_t copy_strategy; ! 956: boolean_t use_old_pageout; ! 957: { ! 958: if (object == VM_OBJECT_NULL) ! 959: return(KERN_INVALID_ARGUMENT); ! 960: ! 961: /* ! 962: * Verify the attributes of importance ! 963: */ ! 964: ! 965: switch(copy_strategy) { ! 966: case MEMORY_OBJECT_COPY_NONE: ! 967: case MEMORY_OBJECT_COPY_CALL: ! 968: case MEMORY_OBJECT_COPY_DELAY: ! 969: case MEMORY_OBJECT_COPY_TEMPORARY: ! 970: break; ! 971: default: ! 972: vm_object_deallocate(object); ! 973: return(KERN_INVALID_ARGUMENT); ! 974: } ! 975: ! 976: if (object_ready) ! 977: object_ready = TRUE; ! 978: if (may_cache) ! 979: may_cache = TRUE; ! 980: ! 981: vm_object_lock(object); ! 982: ! 983: /* ! 984: * Wake up anyone waiting for the ready attribute ! 985: * to become asserted. ! 986: */ ! 987: ! 988: if (object_ready && !object->pager_ready) { ! 989: object->use_old_pageout = use_old_pageout; ! 990: vm_object_wakeup(object, VM_OBJECT_EVENT_PAGER_READY); ! 991: } ! 992: ! 993: /* ! 994: * Copy the attributes ! 995: */ ! 996: ! 997: object->can_persist = may_cache; ! 998: object->pager_ready = object_ready; ! 999: if (copy_strategy == MEMORY_OBJECT_COPY_TEMPORARY) { ! 1000: object->temporary = TRUE; ! 1001: } else { ! 1002: object->copy_strategy = copy_strategy; ! 1003: } ! 1004: ! 1005: vm_object_unlock(object); ! 1006: ! 1007: vm_object_deallocate(object); ! 1008: ! 1009: return(KERN_SUCCESS); ! 1010: } ! 1011: ! 1012: #if !NORMA_VM ! 1013: ! 1014: /* ! 1015: * XXX rpd claims that reply_to could be obviated in favor of a client ! 1016: * XXX stub that made change_attributes an RPC. Need investigation. ! 1017: */ ! 1018: ! 1019: kern_return_t memory_object_change_attributes(object, may_cache, ! 1020: copy_strategy, reply_to, reply_to_type) ! 1021: vm_object_t object; ! 1022: boolean_t may_cache; ! 1023: memory_object_copy_strategy_t copy_strategy; ! 1024: ipc_port_t reply_to; ! 1025: mach_msg_type_name_t reply_to_type; ! 1026: { ! 1027: kern_return_t result; ! 1028: ! 1029: /* ! 1030: * Do the work and throw away our object reference. It ! 1031: * is important that the object reference be deallocated ! 1032: * BEFORE sending the reply. The whole point of the reply ! 1033: * is that it shows up after the terminate message that ! 1034: * may be generated by setting the object uncacheable. ! 1035: * ! 1036: * XXX may_cache may become a tri-valued variable to handle ! 1037: * XXX uncache if not in use. ! 1038: */ ! 1039: result = memory_object_set_attributes_common(object, TRUE, ! 1040: may_cache, copy_strategy, ! 1041: FALSE); ! 1042: ! 1043: if (IP_VALID(reply_to)) { ! 1044: ! 1045: /* consumes our naked send-once/send right for reply_to */ ! 1046: (void) memory_object_change_completed(reply_to, reply_to_type, ! 1047: may_cache, copy_strategy); ! 1048: ! 1049: } ! 1050: ! 1051: return(result); ! 1052: } ! 1053: ! 1054: kern_return_t ! 1055: memory_object_set_attributes(object, object_ready, may_cache, copy_strategy) ! 1056: vm_object_t object; ! 1057: boolean_t object_ready; ! 1058: boolean_t may_cache; ! 1059: memory_object_copy_strategy_t copy_strategy; ! 1060: { ! 1061: return memory_object_set_attributes_common(object, object_ready, ! 1062: may_cache, copy_strategy, ! 1063: TRUE); ! 1064: } ! 1065: ! 1066: kern_return_t memory_object_ready(object, may_cache, copy_strategy) ! 1067: vm_object_t object; ! 1068: boolean_t may_cache; ! 1069: memory_object_copy_strategy_t copy_strategy; ! 1070: { ! 1071: return memory_object_set_attributes_common(object, TRUE, ! 1072: may_cache, copy_strategy, ! 1073: FALSE); ! 1074: } ! 1075: #endif !NORMA_VM ! 1076: ! 1077: kern_return_t memory_object_get_attributes(object, object_ready, ! 1078: may_cache, copy_strategy) ! 1079: vm_object_t object; ! 1080: boolean_t *object_ready; ! 1081: boolean_t *may_cache; ! 1082: memory_object_copy_strategy_t *copy_strategy; ! 1083: { ! 1084: if (object == VM_OBJECT_NULL) ! 1085: return(KERN_INVALID_ARGUMENT); ! 1086: ! 1087: vm_object_lock(object); ! 1088: *may_cache = object->can_persist; ! 1089: *object_ready = object->pager_ready; ! 1090: *copy_strategy = object->copy_strategy; ! 1091: vm_object_unlock(object); ! 1092: ! 1093: vm_object_deallocate(object); ! 1094: ! 1095: return(KERN_SUCCESS); ! 1096: } ! 1097: ! 1098: /* ! 1099: * If successful, consumes the supplied naked send right. ! 1100: */ ! 1101: kern_return_t vm_set_default_memory_manager(host, default_manager) ! 1102: host_t host; ! 1103: ipc_port_t *default_manager; ! 1104: { ! 1105: ipc_port_t current_manager; ! 1106: ipc_port_t new_manager; ! 1107: ipc_port_t returned_manager; ! 1108: ! 1109: if (host == HOST_NULL) ! 1110: return(KERN_INVALID_HOST); ! 1111: ! 1112: new_manager = *default_manager; ! 1113: simple_lock(&memory_manager_default_lock); ! 1114: current_manager = memory_manager_default; ! 1115: ! 1116: if (new_manager == IP_NULL) { ! 1117: /* ! 1118: * Retrieve the current value. ! 1119: */ ! 1120: ! 1121: returned_manager = ipc_port_copy_send(current_manager); ! 1122: } else { ! 1123: /* ! 1124: * Retrieve the current value, ! 1125: * and replace it with the supplied value. ! 1126: * We consume the supplied naked send right. ! 1127: */ ! 1128: ! 1129: returned_manager = current_manager; ! 1130: memory_manager_default = new_manager; ! 1131: ! 1132: /* ! 1133: * In case anyone's been waiting for a memory ! 1134: * manager to be established, wake them up. ! 1135: */ ! 1136: ! 1137: thread_wakeup((event_t) &memory_manager_default); ! 1138: } ! 1139: ! 1140: simple_unlock(&memory_manager_default_lock); ! 1141: ! 1142: *default_manager = returned_manager; ! 1143: return(KERN_SUCCESS); ! 1144: } ! 1145: ! 1146: /* ! 1147: * Routine: memory_manager_default_reference ! 1148: * Purpose: ! 1149: * Returns a naked send right for the default ! 1150: * memory manager. The returned right is always ! 1151: * valid (not IP_NULL or IP_DEAD). ! 1152: */ ! 1153: ! 1154: ipc_port_t memory_manager_default_reference() ! 1155: { ! 1156: ipc_port_t current_manager; ! 1157: ! 1158: simple_lock(&memory_manager_default_lock); ! 1159: ! 1160: while (current_manager = ipc_port_copy_send(memory_manager_default), ! 1161: !IP_VALID(current_manager)) { ! 1162: thread_sleep((event_t) &memory_manager_default, ! 1163: simple_lock_addr(memory_manager_default_lock), ! 1164: FALSE); ! 1165: simple_lock(&memory_manager_default_lock); ! 1166: } ! 1167: ! 1168: simple_unlock(&memory_manager_default_lock); ! 1169: ! 1170: return current_manager; ! 1171: } ! 1172: ! 1173: /* ! 1174: * Routine: memory_manager_default_port ! 1175: * Purpose: ! 1176: * Returns true if the receiver for the port ! 1177: * is the default memory manager. ! 1178: * ! 1179: * This is a hack to let ds_read_done ! 1180: * know when it should keep memory wired. ! 1181: */ ! 1182: ! 1183: boolean_t memory_manager_default_port(port) ! 1184: ipc_port_t port; ! 1185: { ! 1186: ipc_port_t current; ! 1187: boolean_t result; ! 1188: ! 1189: simple_lock(&memory_manager_default_lock); ! 1190: current = memory_manager_default; ! 1191: if (IP_VALID(current)) { ! 1192: /* ! 1193: * There is no point in bothering to lock ! 1194: * both ports, which would be painful to do. ! 1195: * If the receive rights are moving around, ! 1196: * we might be inaccurate. ! 1197: */ ! 1198: ! 1199: result = port->ip_receiver == current->ip_receiver; ! 1200: } else ! 1201: result = FALSE; ! 1202: simple_unlock(&memory_manager_default_lock); ! 1203: ! 1204: return result; ! 1205: } ! 1206: ! 1207: void memory_manager_default_init() ! 1208: { ! 1209: memory_manager_default = IP_NULL; ! 1210: simple_lock_init(&memory_manager_default_lock); ! 1211: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.