![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vm_kern.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 vm_kern.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) 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/vm_kern.c ! 52: * Author: Avadis Tevanian, Jr., Michael Wayne Young ! 53: * Date: 1985 ! 54: * ! 55: * Kernel memory management. ! 56: */ ! 57: ! 58: #include <mach/kern_return.h> ! 59: #include <mach/vm_param.h> ! 60: #include <kern/assert.h> ! 61: #include <kern/lock.h> ! 62: #include <kern/thread.h> ! 63: #include <vm/vm_fault.h> ! 64: #include <vm/vm_kern.h> ! 65: #include <vm/vm_map.h> ! 66: #include <vm/vm_object.h> ! 67: #include <vm/vm_page.h> ! 68: #include <vm/vm_pageout.h> ! 69: ! 70: vm_map_t kernel_map; ! 71: ! 72: static boolean_t kmem_alloc_pages( ! 73: vm_object_t object, ! 74: vm_offset_t offset, ! 75: vm_offset_t start, ! 76: vm_offset_t end, ! 77: boolean_t canblock); ! 78: void kmem_remap_pages( ! 79: vm_object_t object, ! 80: vm_offset_t offset, ! 81: vm_offset_t start, ! 82: vm_offset_t end); ! 83: ! 84: /* ! 85: * Allocate wired-down memory in the kernel's address map ! 86: * or a submap. ! 87: */ ! 88: static ! 89: kern_return_t ! 90: kmem_alloc_prim( ! 91: vm_map_t map, ! 92: vm_offset_t *addrp, ! 93: vm_size_t size, ! 94: vm_object_t object, ! 95: boolean_t canblock ! 96: ) ! 97: { ! 98: kern_return_t result; ! 99: vm_offset_t addr, offset = 0; ! 100: vm_map_entry_t entry; ! 101: ! 102: size = round_page(size); ! 103: vm_map_lock(map); ! 104: if (result = vm_map_find_entry(map, &addr, size, (vm_offset_t) 0, ! 105: (object != kernel_object)? ! 106: VM_OBJECT_NULL : object, &entry) ! 107: != KERN_SUCCESS) { ! 108: vm_map_unlock(map); ! 109: if (object != kernel_object) ! 110: vm_object_deallocate(object); ! 111: return (result); ! 112: } ! 113: ! 114: if (object == kernel_object) ! 115: offset = addr - VM_MIN_KERNEL_ADDRESS; ! 116: ! 117: if (entry->object.vm_object == VM_OBJECT_NULL) { ! 118: if (object == kernel_object) ! 119: vm_object_reference(kernel_object); ! 120: ! 121: entry->object.vm_object = object; ! 122: entry->offset = offset; ! 123: } ! 124: ! 125: /* ! 126: * Since we have not given out this address yet, ! 127: * it is safe to unlock the map. ! 128: */ ! 129: vm_map_unlock(map); ! 130: ! 131: if (!kmem_alloc_pages(object, offset, addr, addr + size, canblock)) { ! 132: vm_map_remove(map, addr, addr + size); ! 133: ! 134: return (KERN_RESOURCE_SHORTAGE); ! 135: } ! 136: ! 137: *addrp = addr; ! 138: ! 139: return (KERN_SUCCESS); ! 140: } ! 141: ! 142: kern_return_t ! 143: kmem_alloc( ! 144: vm_map_t map, ! 145: vm_offset_t *addrp, ! 146: vm_size_t size) ! 147: { ! 148: vm_object_t object = vm_object_allocate(size); ! 149: ! 150: return kmem_alloc_prim(map, addrp, size, object, TRUE); ! 151: } ! 152: ! 153: /* ! 154: * kmem_realloc: ! 155: * ! 156: * Reallocate wired-down memory in the kernel's address map ! 157: * or a submap. ! 158: * This can only be used on regions allocated with kmem_alloc. ! 159: * ! 160: * If successful, the pages in the old region are mapped twice. ! 161: * The old region is unchanged. Use kmem_free to get rid of it. ! 162: */ ! 163: kern_return_t kmem_realloc( ! 164: vm_map_t map, ! 165: vm_offset_t oldaddr, ! 166: vm_size_t oldsize, ! 167: vm_offset_t *newaddrp, ! 168: vm_size_t newsize) ! 169: { ! 170: vm_offset_t oldmin, oldmax; ! 171: vm_offset_t newaddr; ! 172: vm_object_t object; ! 173: vm_map_entry_t oldentry, newentry; ! 174: kern_return_t kr; ! 175: ! 176: oldmin = trunc_page(oldaddr); ! 177: oldmax = round_page(oldaddr + oldsize); ! 178: oldsize = oldmax - oldmin; ! 179: newsize = round_page(newsize); ! 180: ! 181: /* ! 182: * Find space for the new region. ! 183: */ ! 184: ! 185: vm_map_lock(map); ! 186: kr = vm_map_find_entry(map, &newaddr, newsize, (vm_offset_t) 0, ! 187: VM_OBJECT_NULL, &newentry); ! 188: if (kr != KERN_SUCCESS) { ! 189: vm_map_unlock(map); ! 190: return kr; ! 191: } ! 192: ! 193: /* ! 194: * Find the VM object backing the old region. ! 195: */ ! 196: ! 197: if (!vm_map_lookup_entry(map, oldmin, &oldentry)) ! 198: panic("kmem_realloc"); ! 199: object = oldentry->object.vm_object; ! 200: ! 201: /* ! 202: * Increase the size of the object and ! 203: * fill in the new region. ! 204: */ ! 205: ! 206: vm_object_reference(object); ! 207: vm_object_lock(object); ! 208: if (object->size != oldsize) ! 209: panic("kmem_realloc"); ! 210: object->size = newsize; ! 211: vm_object_unlock(object); ! 212: ! 213: newentry->object.vm_object = object; ! 214: newentry->offset = 0; ! 215: ! 216: /* ! 217: * Since we have not given out this address yet, ! 218: * it is safe to unlock the map. We are trusting ! 219: * that nobody will play with either region. ! 220: */ ! 221: ! 222: vm_map_unlock(map); ! 223: ! 224: /* ! 225: * Remap the pages in the old region and ! 226: * allocate more pages for the new region. ! 227: */ ! 228: ! 229: kmem_remap_pages(object, 0, ! 230: newaddr, newaddr + oldsize); ! 231: (void) kmem_alloc_pages(object, oldsize, ! 232: newaddr + oldsize, newaddr + newsize, TRUE); ! 233: ! 234: *newaddrp = newaddr; ! 235: return KERN_SUCCESS; ! 236: } ! 237: ! 238: kern_return_t ! 239: kmem_alloc_wired( ! 240: vm_map_t map, ! 241: vm_offset_t *addrp, ! 242: vm_size_t size) ! 243: { ! 244: return kmem_alloc_prim(map, addrp, size, kernel_object, TRUE); ! 245: } ! 246: ! 247: ! 248: /* ! 249: * kmem_alloc_pageable: ! 250: * ! 251: * Allocate pageable memory to the kernel's address map. ! 252: * map must be "kernel_map" below. ! 253: */ ! 254: ! 255: kern_return_t ! 256: kmem_alloc_pageable( ! 257: vm_map_t map, ! 258: vm_offset_t *addrp, ! 259: vm_size_t size) ! 260: { ! 261: vm_offset_t addr; ! 262: kern_return_t kr; ! 263: ! 264: addr = vm_map_min(map); ! 265: kr = vm_map_find(map, VM_OBJECT_NULL, (vm_offset_t) 0, ! 266: &addr, round_page(size), TRUE); ! 267: if (kr != KERN_SUCCESS) ! 268: return kr; ! 269: ! 270: *addrp = addr; ! 271: return KERN_SUCCESS; ! 272: } ! 273: ! 274: /* ! 275: * kmem_free: ! 276: * ! 277: * Release a region of kernel virtual memory allocated ! 278: * with kmem_alloc, and return the physical pages ! 279: * associated with that region. ! 280: */ ! 281: void ! 282: kmem_free( ! 283: vm_map_t map, ! 284: vm_offset_t addr, ! 285: vm_size_t size) ! 286: { ! 287: (void) vm_map_remove(map, trunc_page(addr), round_page(addr + size)); ! 288: } ! 289: ! 290: /* ! 291: * Allocate new wired pages in an object. ! 292: * The object is assumed to be mapped into the kernel map or ! 293: * a submap. ! 294: */ ! 295: static ! 296: boolean_t ! 297: kmem_alloc_pages( ! 298: vm_object_t object, ! 299: vm_offset_t offset, ! 300: vm_offset_t start, ! 301: vm_offset_t end, ! 302: boolean_t canblock) ! 303: { ! 304: /* ! 305: * Mark the pmap region as not pageable. ! 306: */ ! 307: pmap_pageable(kernel_pmap, start, end, FALSE); ! 308: ! 309: while (start < end) { ! 310: register vm_page_t mem; ! 311: ! 312: vm_object_lock(object); ! 313: ! 314: /* ! 315: * Allocate a page ! 316: */ ! 317: while ((mem = vm_page_alloc(object, offset)) == VM_PAGE_NULL) { ! 318: vm_object_unlock(object); ! 319: if (!canblock) ! 320: return FALSE; ! 321: VM_WAIT; ! 322: vm_object_lock(object); ! 323: } ! 324: ! 325: /* ! 326: * Wire it down ! 327: */ ! 328: vm_page_lock_queues(); ! 329: vm_page_wire(mem); ! 330: vm_page_unlock_queues(); ! 331: vm_object_unlock(object); ! 332: ! 333: vm_page_zero_fill(mem); ! 334: ! 335: /* ! 336: * Enter it in the kernel pmap ! 337: */ ! 338: PMAP_ENTER(kernel_pmap, start, mem, ! 339: VM_PROT_DEFAULT, TRUE); ! 340: ! 341: vm_object_lock(object); ! 342: PAGE_WAKEUP(mem); ! 343: vm_object_unlock(object); ! 344: ! 345: start += PAGE_SIZE; ! 346: offset += PAGE_SIZE; ! 347: } ! 348: ! 349: return TRUE; ! 350: } ! 351: ! 352: /* ! 353: * Remap wired pages in an object into a new region. ! 354: * The object is assumed to be mapped into the kernel map or ! 355: * a submap. ! 356: */ ! 357: void ! 358: kmem_remap_pages( ! 359: vm_object_t object, ! 360: vm_offset_t offset, ! 361: vm_offset_t start, ! 362: vm_offset_t end) ! 363: { ! 364: /* ! 365: * Mark the pmap region as not pageable. ! 366: */ ! 367: pmap_pageable(kernel_pmap, start, end, FALSE); ! 368: ! 369: while (start < end) { ! 370: register vm_page_t mem; ! 371: ! 372: vm_object_lock(object); ! 373: ! 374: /* ! 375: * Find a page ! 376: */ ! 377: if ((mem = vm_page_lookup(object, offset)) == VM_PAGE_NULL) ! 378: panic("kmem_remap_pages"); ! 379: ! 380: /* ! 381: * Wire it down (again) ! 382: */ ! 383: vm_page_lock_queues(); ! 384: vm_page_wire(mem); ! 385: vm_page_unlock_queues(); ! 386: vm_object_unlock(object); ! 387: ! 388: /* ! 389: * Enter it in the kernel pmap. The page isn't busy, ! 390: * but this shouldn't be a problem because it is wired. ! 391: */ ! 392: PMAP_ENTER(kernel_pmap, start, mem, ! 393: VM_PROT_DEFAULT, TRUE); ! 394: ! 395: start += PAGE_SIZE; ! 396: offset += PAGE_SIZE; ! 397: } ! 398: } ! 399: ! 400: /* ! 401: * kmem_suballoc: ! 402: * ! 403: * Allocates a map to manage a subrange ! 404: * of the kernel virtual address space. ! 405: * ! 406: * Arguments are as follows: ! 407: * ! 408: * parent Map to take range from ! 409: * size Size of range to find ! 410: * min, max Returned endpoints of map ! 411: * pageable Can the region be paged ! 412: */ ! 413: vm_map_t ! 414: kmem_suballoc( ! 415: vm_map_t parent, ! 416: vm_offset_t *min, ! 417: vm_offset_t *max, ! 418: vm_size_t size, ! 419: boolean_t pageable) ! 420: { ! 421: vm_map_t map; ! 422: vm_offset_t addr; ! 423: kern_return_t kr; ! 424: ! 425: size = round_page(size); ! 426: ! 427: /* ! 428: * Need reference on submap object because it is internal ! 429: * to the vm_system. vm_object_enter will never be called ! 430: * on it (usual source of reference for vm_map_enter). ! 431: */ ! 432: vm_object_reference(vm_submap_object); ! 433: ! 434: addr = (vm_offset_t) vm_map_min(parent); ! 435: kr = vm_map_find(parent, vm_submap_object, (vm_offset_t) 0, ! 436: &addr, size, TRUE); ! 437: if (kr != KERN_SUCCESS) ! 438: panic("kmem_suballoc 1"); ! 439: ! 440: pmap_reference(vm_map_pmap(parent)); ! 441: map = vm_map_create(vm_map_pmap(parent), addr, addr + size, pageable); ! 442: if (map == VM_MAP_NULL) ! 443: panic("kmem_suballoc 2"); ! 444: ! 445: kr = vm_map_submap(parent, addr, addr + size, map); ! 446: if (kr != KERN_SUCCESS) ! 447: panic("kmem_suballoc 3"); ! 448: ! 449: *min = addr; ! 450: *max = addr + size; ! 451: return map; ! 452: } ! 453: ! 454: /* ! 455: * kmem_init: ! 456: * ! 457: * Initialize the kernel's virtual memory map, taking ! 458: * into account all memory allocated up to this time. ! 459: */ ! 460: void kmem_init( ! 461: vm_offset_t start, ! 462: vm_offset_t end) ! 463: { ! 464: kernel_map = vm_map_create(pmap_kernel(), ! 465: VM_MIN_KERNEL_ADDRESS, end, ! 466: FALSE); ! 467: ! 468: /* ! 469: * Reserve virtual memory allocated up to this time. ! 470: */ ! 471: ! 472: if (start != VM_MIN_KERNEL_ADDRESS) { ! 473: vm_offset_t addr = VM_MIN_KERNEL_ADDRESS; ! 474: (void) vm_map_find(kernel_map, VM_OBJECT_NULL, (vm_offset_t) 0, ! 475: &addr, (start - VM_MIN_KERNEL_ADDRESS), ! 476: FALSE); ! 477: } ! 478: } ! 479: ! 480: /* ! 481: * Routine: copyinmap ! 482: * Purpose: ! 483: * Like copyin, except that fromaddr is an address ! 484: * in the specified VM map. This implementation ! 485: * is incomplete; it handles the current user map ! 486: * and the kernel map/submaps. ! 487: */ ! 488: ! 489: int copyinmap(map, fromaddr, toaddr, length) ! 490: vm_map_t map; ! 491: char *fromaddr, *toaddr; ! 492: int length; ! 493: { ! 494: if (vm_map_pmap(map) == kernel_pmap) { ! 495: /* assume a correct copy */ ! 496: bcopy(fromaddr, toaddr, length); ! 497: return 0; ! 498: } ! 499: ! 500: if (current_map() == map) ! 501: return copyin( fromaddr, toaddr, length); ! 502: ! 503: return 1; ! 504: } ! 505: ! 506: /* ! 507: * Routine: copyoutmap ! 508: * Purpose: ! 509: * Like copyout, except that toaddr is an address ! 510: * in the specified VM map. This implementation ! 511: * is incomplete; it handles the current user map ! 512: * and the kernel map/submaps. ! 513: */ ! 514: ! 515: int copyoutmap(map, fromaddr, toaddr, length) ! 516: vm_map_t map; ! 517: char *fromaddr, *toaddr; ! 518: int length; ! 519: { ! 520: if (vm_map_pmap(map) == kernel_pmap) { ! 521: /* assume a correct copy */ ! 522: bcopy(fromaddr, toaddr, length); ! 523: return 0; ! 524: } ! 525: ! 526: if (current_map() == map) ! 527: return copyout(fromaddr, toaddr, length); ! 528: ! 529: return 1; ! 530: } ! 531: ! 532: /* ! 533: * Allocate wired-down memory in the kernel's address map ! 534: * or a submap. ! 535: */ ! 536: kern_return_t ! 537: kmem_alloc_zone(map, addrp, size, canblock) ! 538: vm_map_t map; ! 539: vm_offset_t *addrp; ! 540: register vm_size_t size; ! 541: boolean_t canblock; ! 542: { ! 543: return kmem_alloc_prim(map, addrp, size, kernel_object, canblock); ! 544: } ! 545: ! 546: /* ! 547: * Special hack for allocation in mb_map. Can never wait for pages ! 548: * (or anything else) in mb_map. ! 549: */ ! 550: vm_offset_t kmem_mb_alloc(map, size) ! 551: register vm_map_t map; ! 552: vm_size_t size; ! 553: { ! 554: vm_object_t object; ! 555: register vm_map_entry_t entry; ! 556: vm_offset_t addr; ! 557: register int npgs; ! 558: register vm_page_t m; ! 559: register vm_offset_t vaddr, offset, cur_off; ! 560: ! 561: /* ! 562: * Only do this on the mb_map. ! 563: */ ! 564: if (map != mb_map) ! 565: panic("You fool!"); ! 566: ! 567: size = round_page(size); ! 568: ! 569: vm_map_lock(map); ! 570: entry = vm_map_first_entry(map); ! 571: if (entry == vm_map_to_entry(map)) { ! 572: /* ! 573: * Map is empty. Do things normally the first time... ! 574: * this will allocate the entry and the object to use. ! 575: */ ! 576: vm_map_unlock(map); ! 577: addr = vm_map_min(map); ! 578: if (vm_map_find(map, VM_OBJECT_NULL, (vm_offset_t) 0, ! 579: &addr, size, TRUE) != KERN_SUCCESS) ! 580: return (0); ! 581: (void) vm_map_pageable(map, addr, addr + size, FALSE); ! 582: ! 583: return(addr); ! 584: } ! 585: /* ! 586: * Map already has an entry. We must be extending it. ! 587: */ ! 588: if (!(entry == vm_map_last_entry(map) && ! 589: entry->is_a_map == FALSE && ! 590: entry->vme_start == vm_map_min(map) && ! 591: entry->max_protection == VM_PROT_ALL && ! 592: entry->protection == VM_PROT_DEFAULT && ! 593: entry->inheritance == VM_INHERIT_DEFAULT && ! 594: entry->wired_count != 0)) { ! 595: /* ! 596: * Someone's not playing by the rules... ! 597: */ ! 598: panic("mb_map abused even more than usual"); ! 599: } ! 600: ! 601: /* ! 602: * Make sure there's enough room in map to extend entry. ! 603: */ ! 604: ! 605: if (vm_map_max(map) - size < entry->vme_end) { ! 606: vm_map_unlock(map); ! 607: return(0); ! 608: } ! 609: ! 610: /* ! 611: * extend the entry ! 612: */ ! 613: object = entry->object.vm_object; ! 614: offset = (entry->vme_end - entry->vme_start) + entry->offset; ! 615: addr = entry->vme_end; ! 616: entry->vme_end += size; ! 617: ! 618: /* ! 619: * Since we may not have enough memory, and we may not ! 620: * block, we first allocate all the memory up front, pulling ! 621: * it off the active queue to prevent pageout. We then can ! 622: * either enter the pages, or free whatever we tried to get. ! 623: */ ! 624: ! 625: vm_object_lock(object); ! 626: cur_off = offset; ! 627: npgs = atop(size); ! 628: while (npgs) { ! 629: m = vm_page_alloc_sequential(object, cur_off, FALSE); ! 630: if (m == VM_PAGE_NULL) { ! 631: /* ! 632: * Not enough pages, and we can't ! 633: * wait, so free everything up. ! 634: */ ! 635: while (cur_off > offset) { ! 636: cur_off -= PAGE_SIZE; ! 637: m = vm_page_lookup(object, cur_off); ! 638: /* ! 639: * Don't have to lock the queues here ! 640: * because we know that the pages are ! 641: * not on any queues. ! 642: */ ! 643: vm_page_free(m); ! 644: } ! 645: vm_object_unlock(object); ! 646: ! 647: /* ! 648: * Shrink the map entry back to its old size. ! 649: */ ! 650: entry->vme_end -= size; ! 651: vm_map_unlock(map); ! 652: return(0); ! 653: } ! 654: ! 655: /* ! 656: * We want zero-filled memory ! 657: */ ! 658: ! 659: vm_page_zero_fill(m); ! 660: ! 661: /* ! 662: * Since no other process can see these pages, we don't ! 663: * have to bother with the busy bit. ! 664: */ ! 665: ! 666: m->busy = FALSE; ! 667: ! 668: npgs--; ! 669: cur_off += PAGE_SIZE; ! 670: } ! 671: ! 672: vm_object_unlock(object); ! 673: ! 674: /* ! 675: * Map entry is already marked non-pageable. ! 676: * Loop thru pages, entering them in the pmap. ! 677: * (We can't add them to the wired count without ! 678: * wrapping the vm_page_queue_lock in splimp...) ! 679: */ ! 680: vaddr = addr; ! 681: cur_off = offset; ! 682: while (vaddr < entry->vme_end) { ! 683: vm_object_lock(object); ! 684: m = vm_page_lookup(object, cur_off); ! 685: vm_page_wire(m); ! 686: vm_object_unlock(object); ! 687: pmap_enter(map->pmap, vaddr, VM_PAGE_TO_PHYS(m), ! 688: entry->protection, TRUE); ! 689: vaddr += PAGE_SIZE; ! 690: cur_off += PAGE_SIZE; ! 691: } ! 692: vm_map_unlock(map); ! 693: ! 694: return(addr); ! 695: } ! 696: ! 697: /* ! 698: * kmem_alloc_wait ! 699: * ! 700: * Allocates pageable memory from a sub-map of the kernel. If the submap ! 701: * has no room, the caller sleeps waiting for more memory in the submap. ! 702: * ! 703: */ ! 704: vm_offset_t kmem_alloc_wait(map, size) ! 705: vm_map_t map; ! 706: vm_size_t size; ! 707: { ! 708: vm_offset_t addr; ! 709: kern_return_t result; ! 710: ! 711: size = round_page(size); ! 712: ! 713: do { ! 714: /* ! 715: * To make this work for more than one map, ! 716: * use the map's lock to lock out sleepers/wakers. ! 717: * Unfortunately, vm_map_find also grabs the map lock. ! 718: */ ! 719: vm_map_lock(map); ! 720: lock_set_recursive(&map->lock); ! 721: ! 722: addr = vm_map_min(map); ! 723: result = vm_map_find(map, VM_OBJECT_NULL, (vm_offset_t) 0, ! 724: &addr, size, TRUE); ! 725: ! 726: lock_clear_recursive(&map->lock); ! 727: if (result != KERN_SUCCESS) { ! 728: ! 729: if ( (vm_map_max(map) - vm_map_min(map)) < size ) { ! 730: vm_map_unlock(map); ! 731: return(0); ! 732: } ! 733: ! 734: assert_wait(map, TRUE); ! 735: vm_map_unlock(map); ! 736: thread_block(); ! 737: } ! 738: else { ! 739: vm_map_unlock(map); ! 740: } ! 741: ! 742: } while (result != KERN_SUCCESS); ! 743: ! 744: return(addr); ! 745: } ! 746: ! 747: /* ! 748: * kmem_free_wakeup ! 749: * ! 750: * Returns memory to a submap of the kernel, and wakes up any threads ! 751: * waiting for memory in that map. ! 752: */ ! 753: void kmem_free_wakeup(map, addr, size) ! 754: vm_map_t map; ! 755: vm_offset_t addr; ! 756: vm_size_t size; ! 757: { ! 758: vm_map_lock(map); ! 759: (void) vm_map_delete(map, trunc_page(addr), round_page(addr + size)); ! 760: thread_wakeup(map); ! 761: vm_map_unlock(map); ! 762: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.