![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to zalloc.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / OSKit-Mach / kern|
Return to zalloc.c CVS log | Up to [GnuMach] / OSKit-Mach / kern |
1.1 ! root 1: /* ! 2: * Mach Operating System ! 3: * Copyright (c) 1993-1987 Carnegie Mellon University. ! 4: * Copyright (c) 1993,1994 The University of Utah and ! 5: * the Computer Systems Laboratory (CSL). ! 6: * All rights reserved. ! 7: * ! 8: * Permission to use, copy, modify and distribute this software and its ! 9: * documentation is hereby granted, provided that both the copyright ! 10: * notice and this permission notice appear in all copies of the ! 11: * software, derivative works or modified versions, and any portions ! 12: * thereof, and that both notices appear in supporting documentation. ! 13: * ! 14: * CARNEGIE MELLON, THE UNIVERSITY OF UTAH AND CSL ALLOW FREE USE OF ! 15: * THIS SOFTWARE IN ITS "AS IS" CONDITION, AND DISCLAIM ANY LIABILITY ! 16: * OF ANY KIND FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF ! 17: * THIS SOFTWARE. ! 18: * ! 19: * Carnegie Mellon requests users of this software to return to ! 20: * ! 21: * Software Distribution Coordinator or [email protected] ! 22: * School of Computer Science ! 23: * Carnegie Mellon University ! 24: * Pittsburgh PA 15213-3890 ! 25: * ! 26: * any improvements or extensions that they make and grant Carnegie Mellon ! 27: * the rights to redistribute these changes. ! 28: */ ! 29: /* ! 30: * File: kern/zalloc.c ! 31: * Author: Avadis Tevanian, Jr. ! 32: * ! 33: * Zone-based memory allocator. A zone is a collection of fixed size ! 34: * data blocks for which quick allocation/deallocation is possible. ! 35: */ ! 36: ! 37: #include <kern/macro_help.h> ! 38: #include <kern/sched.h> ! 39: #include <kern/time_out.h> ! 40: #include <kern/zalloc.h> ! 41: #include <mach/vm_param.h> ! 42: #include <vm/vm_kern.h> ! 43: #include <machine/machspl.h> ! 44: ! 45: #include <mach_debug.h> ! 46: #if MACH_DEBUG ! 47: #include <mach/kern_return.h> ! 48: #include <mach/machine/vm_types.h> ! 49: #include <mach_debug/zone_info.h> ! 50: #include <kern/host.h> ! 51: #include <vm/vm_map.h> ! 52: #include <vm/vm_user.h> ! 53: #include <vm/vm_kern.h> ! 54: #endif ! 55: ! 56: #define ADD_TO_ZONE(zone, element) \ ! 57: MACRO_BEGIN \ ! 58: *((vm_offset_t *)(element)) = (zone)->free_elements; \ ! 59: (zone)->free_elements = (vm_offset_t) (element); \ ! 60: zone_count_down(zone); \ ! 61: MACRO_END ! 62: ! 63: #define REMOVE_FROM_ZONE(zone, ret, type) \ ! 64: MACRO_BEGIN \ ! 65: (ret) = (type) (zone)->free_elements; \ ! 66: if ((ret) != (type) 0) { \ ! 67: zone_count_up(zone); \ ! 68: (zone)->free_elements = *((vm_offset_t *)(ret)); \ ! 69: } \ ! 70: MACRO_END ! 71: ! 72: /* ! 73: * Support for garbage collection of unused zone pages: ! 74: */ ! 75: ! 76: struct zone_page_table_entry { ! 77: struct zone_page_table_entry *next; ! 78: short in_free_list; ! 79: short alloc_count; ! 80: }; ! 81: ! 82: extern struct zone_page_table_entry * zone_page_table; ! 83: extern vm_offset_t zone_map_min_address; ! 84: ! 85: #define lock_zone_page_table() simple_lock(&zone_page_table_lock) ! 86: #define unlock_zone_page_table() simple_unlock(&zone_page_table_lock) ! 87: ! 88: #define zone_page(addr) \ ! 89: (&(zone_page_table[(atop(((vm_offset_t)addr) - zone_map_min_address))])) ! 90: ! 91: ! 92: extern void zone_page_alloc(); ! 93: extern void zone_page_dealloc(); ! 94: extern void zone_page_in_use(); ! 95: extern void zone_page_free(); ! 96: ! 97: zone_t zone_zone; /* this is the zone containing other zones */ ! 98: ! 99: boolean_t zone_ignore_overflow = TRUE; ! 100: ! 101: vm_map_t zone_map = VM_MAP_NULL; ! 102: vm_size_t zone_map_size = 12 * 1024 * 1024; ! 103: ! 104: /* ! 105: * The VM system gives us an initial chunk of memory. ! 106: * It has to be big enough to allocate the zone_zone ! 107: * and some initial kernel data structures, like kernel maps. ! 108: * It is advantageous to make it bigger than really necessary, ! 109: * because this memory is more efficient than normal kernel ! 110: * virtual memory. (It doesn't have vm_page structures backing it ! 111: * and it may have other machine-dependent advantages.) ! 112: * So for best performance, zdata_size should approximate ! 113: * the amount of memory you expect the zone system to consume. ! 114: */ ! 115: ! 116: vm_offset_t zdata; ! 117: vm_size_t zdata_size = 420 * 1024; ! 118: ! 119: #define zone_lock(zone) \ ! 120: MACRO_BEGIN \ ! 121: if (zone->type & ZONE_PAGEABLE) { \ ! 122: lock_write(&zone->complex_lock); \ ! 123: } else { \ ! 124: simple_lock(&zone->lock); \ ! 125: } \ ! 126: MACRO_END ! 127: ! 128: #define zone_unlock(zone) \ ! 129: MACRO_BEGIN \ ! 130: if (zone->type & ZONE_PAGEABLE) { \ ! 131: lock_done(&zone->complex_lock); \ ! 132: } else { \ ! 133: simple_unlock(&zone->lock); \ ! 134: } \ ! 135: MACRO_END ! 136: ! 137: #define zone_lock_init(zone) \ ! 138: MACRO_BEGIN \ ! 139: if (zone->type & ZONE_PAGEABLE) { \ ! 140: lock_init(&zone->complex_lock, TRUE); \ ! 141: } else { \ ! 142: simple_lock_init(&zone->lock); \ ! 143: } \ ! 144: MACRO_END ! 145: ! 146: static vm_offset_t zget_space(); ! 147: ! 148: decl_simple_lock_data(,zget_space_lock) ! 149: vm_offset_t zalloc_next_space; ! 150: vm_offset_t zalloc_end_of_space; ! 151: vm_size_t zalloc_wasted_space; ! 152: ! 153: /* ! 154: * Garbage collection map information ! 155: */ ! 156: decl_simple_lock_data(,zone_page_table_lock) ! 157: struct zone_page_table_entry * zone_page_table; ! 158: vm_offset_t zone_map_min_address; ! 159: vm_offset_t zone_map_max_address; ! 160: int zone_pages; ! 161: ! 162: extern void zone_page_init(); ! 163: ! 164: #define ZONE_PAGE_USED 0 ! 165: #define ZONE_PAGE_UNUSED -1 ! 166: ! 167: ! 168: /* ! 169: * Protects first_zone, last_zone, num_zones, ! 170: * and the next_zone field of zones. ! 171: */ ! 172: decl_simple_lock_data(,all_zones_lock) ! 173: zone_t first_zone; ! 174: zone_t *last_zone; ! 175: int num_zones; ! 176: ! 177: /* ! 178: * zinit initializes a new zone. The zone data structures themselves ! 179: * are stored in a zone, which is initially a static structure that ! 180: * is initialized by zone_init. ! 181: */ ! 182: zone_t zinit(size, max, alloc, memtype, name) ! 183: vm_size_t size; /* the size of an element */ ! 184: vm_size_t max; /* maximum memory to use */ ! 185: vm_size_t alloc; /* allocation size */ ! 186: unsigned int memtype; /* flags specifying type of memory */ ! 187: char *name; /* a name for the zone */ ! 188: { ! 189: register zone_t z; ! 190: ! 191: if (zone_zone == ZONE_NULL) ! 192: z = (zone_t) zget_space(sizeof(struct zone)); ! 193: else ! 194: z = (zone_t) zalloc(zone_zone); ! 195: if (z == ZONE_NULL) ! 196: panic("zinit"); ! 197: ! 198: if (alloc == 0) ! 199: alloc = PAGE_SIZE; ! 200: ! 201: if (size == 0) ! 202: size = sizeof(z->free_elements); ! 203: /* ! 204: * Round off all the parameters appropriately. ! 205: */ ! 206: ! 207: if ((max = round_page(max)) < (alloc = round_page(alloc))) ! 208: max = alloc; ! 209: ! 210: z->free_elements = 0; ! 211: z->cur_size = 0; ! 212: z->max_size = max; ! 213: z->elem_size = ((size-1) + sizeof(z->free_elements)) - ! 214: ((size-1) % sizeof(z->free_elements)); ! 215: ! 216: z->alloc_size = alloc; ! 217: z->type = memtype; ! 218: z->zone_name = name; ! 219: #ifdef ZONE_COUNT ! 220: z->count = 0; ! 221: #endif ! 222: z->doing_alloc = FALSE; ! 223: zone_lock_init(z); ! 224: ! 225: /* ! 226: * Add the zone to the all-zones list. ! 227: */ ! 228: ! 229: z->next_zone = ZONE_NULL; ! 230: simple_lock(&all_zones_lock); ! 231: *last_zone = z; ! 232: last_zone = &z->next_zone; ! 233: num_zones++; ! 234: simple_unlock(&all_zones_lock); ! 235: ! 236: return(z); ! 237: } ! 238: ! 239: /* ! 240: * Cram the given memory into the specified zone. ! 241: */ ! 242: void zcram(zone_t zone, vm_offset_t newmem, vm_size_t size) ! 243: { ! 244: register vm_size_t elem_size; ! 245: ! 246: if (newmem == (vm_offset_t) 0) { ! 247: panic("zcram - memory at zero"); ! 248: } ! 249: elem_size = zone->elem_size; ! 250: ! 251: zone_lock(zone); ! 252: while (size >= elem_size) { ! 253: ADD_TO_ZONE(zone, newmem); ! 254: zone_page_alloc(newmem, elem_size); ! 255: zone_count_up(zone); /* compensate for ADD_TO_ZONE */ ! 256: size -= elem_size; ! 257: newmem += elem_size; ! 258: zone->cur_size += elem_size; ! 259: } ! 260: zone_unlock(zone); ! 261: } ! 262: ! 263: /* ! 264: * Contiguous space allocator for non-paged zones. Allocates "size" amount ! 265: * of memory from zone_map. ! 266: */ ! 267: ! 268: static vm_offset_t zget_space(vm_offset_t size) ! 269: { ! 270: vm_offset_t new_space = 0; ! 271: vm_offset_t result; ! 272: vm_size_t space_to_add = 0; /*'=0' to quiet gcc warnings */ ! 273: ! 274: simple_lock(&zget_space_lock); ! 275: while ((zalloc_next_space + size) > zalloc_end_of_space) { ! 276: /* ! 277: * Add at least one page to allocation area. ! 278: */ ! 279: ! 280: space_to_add = round_page(size); ! 281: ! 282: if (new_space == 0) { ! 283: /* ! 284: * Memory cannot be wired down while holding ! 285: * any locks that the pageout daemon might ! 286: * need to free up pages. [Making the zget_space ! 287: * lock a complex lock does not help in this ! 288: * regard.] ! 289: * ! 290: * Unlock and allocate memory. Because several ! 291: * threads might try to do this at once, don't ! 292: * use the memory before checking for available ! 293: * space again. ! 294: */ ! 295: ! 296: simple_unlock(&zget_space_lock); ! 297: ! 298: if (kmem_alloc_wired(zone_map, ! 299: &new_space, space_to_add) ! 300: != KERN_SUCCESS) ! 301: return(0); ! 302: zone_page_init(new_space, space_to_add, ! 303: ZONE_PAGE_USED); ! 304: simple_lock(&zget_space_lock); ! 305: continue; ! 306: } ! 307: ! 308: ! 309: /* ! 310: * Memory was allocated in a previous iteration. ! 311: * ! 312: * Check whether the new region is contiguous ! 313: * with the old one. ! 314: */ ! 315: ! 316: if (new_space != zalloc_end_of_space) { ! 317: /* ! 318: * Throw away the remainder of the ! 319: * old space, and start a new one. ! 320: */ ! 321: zalloc_wasted_space += ! 322: zalloc_end_of_space - zalloc_next_space; ! 323: zalloc_next_space = new_space; ! 324: } ! 325: ! 326: zalloc_end_of_space = new_space + space_to_add; ! 327: ! 328: new_space = 0; ! 329: } ! 330: result = zalloc_next_space; ! 331: zalloc_next_space += size; ! 332: simple_unlock(&zget_space_lock); ! 333: ! 334: if (new_space != 0) ! 335: kmem_free(zone_map, new_space, space_to_add); ! 336: ! 337: return(result); ! 338: } ! 339: ! 340: ! 341: /* ! 342: * Initialize the "zone of zones" which uses fixed memory allocated ! 343: * earlier in memory initialization. zone_bootstrap is called ! 344: * before zone_init. ! 345: */ ! 346: void zone_bootstrap() ! 347: { ! 348: simple_lock_init(&all_zones_lock); ! 349: first_zone = ZONE_NULL; ! 350: last_zone = &first_zone; ! 351: num_zones = 0; ! 352: ! 353: simple_lock_init(&zget_space_lock); ! 354: zalloc_next_space = zdata; ! 355: zalloc_end_of_space = zdata + zdata_size; ! 356: zalloc_wasted_space = 0; ! 357: ! 358: zone_zone = ZONE_NULL; ! 359: zone_zone = zinit(sizeof(struct zone), 128 * sizeof(struct zone), ! 360: sizeof(struct zone), 0, "zones"); ! 361: } ! 362: ! 363: void zone_init() ! 364: { ! 365: vm_offset_t zone_min; ! 366: vm_offset_t zone_max; ! 367: ! 368: vm_size_t zone_table_size; ! 369: ! 370: zone_map = kmem_suballoc(kernel_map, &zone_min, &zone_max, ! 371: zone_map_size, FALSE); ! 372: ! 373: /* ! 374: * Setup garbage collection information: ! 375: */ ! 376: ! 377: zone_table_size = atop(zone_max - zone_min) * ! 378: sizeof(struct zone_page_table_entry); ! 379: if (kmem_alloc_wired(zone_map, (vm_offset_t *) &zone_page_table, ! 380: zone_table_size) != KERN_SUCCESS) ! 381: panic("zone_init"); ! 382: zone_min = (vm_offset_t)zone_page_table + round_page(zone_table_size); ! 383: zone_pages = atop(zone_max - zone_min); ! 384: zone_map_min_address = zone_min; ! 385: zone_map_max_address = zone_max; ! 386: simple_lock_init(&zone_page_table_lock); ! 387: zone_page_init(zone_min, zone_max - zone_min, ZONE_PAGE_UNUSED); ! 388: } ! 389: ! 390: ! 391: /* ! 392: * zalloc returns an element from the specified zone. ! 393: */ ! 394: vm_offset_t zalloc(zone_t zone) ! 395: { ! 396: vm_offset_t addr; ! 397: ! 398: if (zone == ZONE_NULL) ! 399: panic ("zalloc: null zone"); ! 400: ! 401: check_simple_locks(); ! 402: ! 403: zone_lock(zone); ! 404: REMOVE_FROM_ZONE(zone, addr, vm_offset_t); ! 405: while (addr == 0) { ! 406: /* ! 407: * If nothing was there, try to get more ! 408: */ ! 409: if (zone->doing_alloc) { ! 410: /* ! 411: * Someone is allocating memory for this zone. ! 412: * Wait for it to show up, then try again. ! 413: */ ! 414: assert_wait((event_t)&zone->doing_alloc, TRUE); ! 415: /* XXX say wakeup needed */ ! 416: zone_unlock(zone); ! 417: thread_block((void (*)()) 0); ! 418: zone_lock(zone); ! 419: } ! 420: else { ! 421: if ((zone->cur_size + (zone->type & ZONE_PAGEABLE ? ! 422: zone->alloc_size : zone->elem_size)) > ! 423: zone->max_size) { ! 424: if (zone->type & ZONE_EXHAUSTIBLE) ! 425: break; ! 426: /* ! 427: * Printf calls logwakeup, which calls ! 428: * select_wakeup which will do a zfree ! 429: * (which tries to take the select_zone ! 430: * lock... Hang. Release the lock now ! 431: * so it can be taken again later. ! 432: * NOTE: this used to be specific to ! 433: * the select_zone, but for ! 434: * cleanliness, we just unlock all ! 435: * zones before this. ! 436: */ ! 437: if (!(zone->type & ZONE_FIXED)) { ! 438: /* ! 439: * We're willing to overflow certain ! 440: * zones, but not without complaining. ! 441: * ! 442: * This is best used in conjunction ! 443: * with the collecatable flag. What we ! 444: * want is an assurance we can get the ! 445: * memory back, assuming there's no ! 446: * leak. ! 447: */ ! 448: zone->max_size += (zone->max_size >> 1); ! 449: } else if (!zone_ignore_overflow) { ! 450: zone_unlock(zone); ! 451: printf("zone \"%s\" empty.\n", ! 452: zone->zone_name); ! 453: panic("zalloc: zone %s exhausted", ! 454: zone->zone_name); ! 455: } ! 456: } ! 457: ! 458: if (zone->type & ZONE_PAGEABLE) ! 459: zone->doing_alloc = TRUE; ! 460: zone_unlock(zone); ! 461: ! 462: if (zone->type & ZONE_PAGEABLE) { ! 463: if (kmem_alloc_pageable(zone_map, &addr, ! 464: zone->alloc_size) ! 465: != KERN_SUCCESS) ! 466: panic("zalloc: zone %s exhausted", ! 467: zone->zone_name); ! 468: zcram(zone, addr, zone->alloc_size); ! 469: zone_lock(zone); ! 470: zone->doing_alloc = FALSE; ! 471: /* XXX check before doing this */ ! 472: thread_wakeup((event_t)&zone->doing_alloc); ! 473: ! 474: REMOVE_FROM_ZONE(zone, addr, vm_offset_t); ! 475: } else if (zone->type & ZONE_COLLECTABLE) { ! 476: if (kmem_alloc_wired(zone_map, ! 477: &addr, zone->alloc_size) ! 478: != KERN_SUCCESS) ! 479: panic("zalloc: zone %s exhausted", ! 480: zone->zone_name); ! 481: zone_page_init(addr, zone->alloc_size, ! 482: ZONE_PAGE_USED); ! 483: zcram(zone, addr, zone->alloc_size); ! 484: zone_lock(zone); ! 485: REMOVE_FROM_ZONE(zone, addr, vm_offset_t); ! 486: } else { ! 487: addr = zget_space(zone->elem_size); ! 488: if (addr == 0) ! 489: panic("zalloc: zone %s exhausted", ! 490: zone->zone_name); ! 491: ! 492: zone_lock(zone); ! 493: zone_count_up(zone); ! 494: zone->cur_size += zone->elem_size; ! 495: zone_unlock(zone); ! 496: zone_page_alloc(addr, zone->elem_size); ! 497: return(addr); ! 498: } ! 499: } ! 500: } ! 501: ! 502: zone_unlock(zone); ! 503: return(addr); ! 504: } ! 505: ! 506: ! 507: /* ! 508: * zget returns an element from the specified zone ! 509: * and immediately returns nothing if there is nothing there. ! 510: * ! 511: * This form should be used when you can not block (like when ! 512: * processing an interrupt). ! 513: */ ! 514: vm_offset_t zget(zone_t zone) ! 515: { ! 516: register vm_offset_t addr; ! 517: ! 518: if (zone == ZONE_NULL) ! 519: panic ("zalloc: null zone"); ! 520: ! 521: zone_lock(zone); ! 522: REMOVE_FROM_ZONE(zone, addr, vm_offset_t); ! 523: zone_unlock(zone); ! 524: ! 525: return(addr); ! 526: } ! 527: ! 528: boolean_t zone_check = FALSE; ! 529: ! 530: void zfree(zone_t zone, vm_offset_t elem) ! 531: { ! 532: zone_lock(zone); ! 533: if (zone_check) { ! 534: vm_offset_t this; ! 535: ! 536: /* check the zone's consistency */ ! 537: ! 538: for (this = zone->free_elements; ! 539: this != 0; ! 540: this = * (vm_offset_t *) this) ! 541: if (this == elem) ! 542: panic("zfree"); ! 543: } ! 544: ADD_TO_ZONE(zone, elem); ! 545: zone_unlock(zone); ! 546: } ! 547: ! 548: /* ! 549: * Zone garbage collection subroutines ! 550: * ! 551: * These routines have in common the modification of entries in the ! 552: * zone_page_table. The latter contains one entry for every page ! 553: * in the zone_map. ! 554: * ! 555: * For each page table entry in the given range: ! 556: * ! 557: * zone_page_in_use - decrements in_free_list ! 558: * zone_page_free - increments in_free_list ! 559: * zone_page_init - initializes in_free_list and alloc_count ! 560: * zone_page_alloc - increments alloc_count ! 561: * zone_page_dealloc - decrements alloc_count ! 562: * zone_add_free_page_list - adds the page to the free list ! 563: * ! 564: * Two counts are maintained for each page, the in_free_list count and ! 565: * alloc_count. The alloc_count is how many zone elements have been ! 566: * allocated from a page. (Note that the page could contain elements ! 567: * that span page boundaries. The count includes these elements so ! 568: * one element may be counted in two pages.) In_free_list is a count ! 569: * of how many zone elements are currently free. If in_free_list is ! 570: * equal to alloc_count then the page is eligible for garbage ! 571: * collection. ! 572: * ! 573: * Alloc_count and in_free_list are initialized to the correct values ! 574: * for a particular zone when a page is zcram'ed into a zone. Subsequent ! 575: * gets and frees of zone elements will call zone_page_in_use and ! 576: * zone_page_free which modify the in_free_list count. When the zones ! 577: * garbage collector runs it will walk through a zones free element list, ! 578: * remove the elements that reside on collectable pages, and use ! 579: * zone_add_free_page_list to create a list of pages to be collected. ! 580: */ ! 581: ! 582: void zone_page_in_use(addr, size) ! 583: vm_offset_t addr; ! 584: vm_size_t size; ! 585: { ! 586: int i, j; ! 587: if ((addr < zone_map_min_address) || ! 588: (addr+size > zone_map_max_address)) return; ! 589: i = atop(addr-zone_map_min_address); ! 590: j = atop((addr+size-1) - zone_map_min_address); ! 591: lock_zone_page_table(); ! 592: for (; i <= j; i++) { ! 593: zone_page_table[i].in_free_list--; ! 594: } ! 595: unlock_zone_page_table(); ! 596: } ! 597: ! 598: void zone_page_free(addr, size) ! 599: vm_offset_t addr; ! 600: vm_size_t size; ! 601: { ! 602: int i, j; ! 603: if ((addr < zone_map_min_address) || ! 604: (addr+size > zone_map_max_address)) return; ! 605: i = atop(addr-zone_map_min_address); ! 606: j = atop((addr+size-1) - zone_map_min_address); ! 607: lock_zone_page_table(); ! 608: for (; i <= j; i++) { ! 609: /* Set in_free_list to (ZONE_PAGE_USED + 1) if ! 610: * it was previously set to ZONE_PAGE_UNUSED. ! 611: */ ! 612: if (zone_page_table[i].in_free_list == ZONE_PAGE_UNUSED) { ! 613: zone_page_table[i].in_free_list = 1; ! 614: } else { ! 615: zone_page_table[i].in_free_list++; ! 616: } ! 617: } ! 618: unlock_zone_page_table(); ! 619: } ! 620: ! 621: void zone_page_init(addr, size, value) ! 622: ! 623: vm_offset_t addr; ! 624: vm_size_t size; ! 625: int value; ! 626: { ! 627: int i, j; ! 628: if ((addr < zone_map_min_address) || ! 629: (addr+size > zone_map_max_address)) return; ! 630: i = atop(addr-zone_map_min_address); ! 631: j = atop((addr+size-1) - zone_map_min_address); ! 632: lock_zone_page_table(); ! 633: for (; i <= j; i++) { ! 634: zone_page_table[i].alloc_count = value; ! 635: zone_page_table[i].in_free_list = 0; ! 636: } ! 637: unlock_zone_page_table(); ! 638: } ! 639: ! 640: void zone_page_alloc(addr, size) ! 641: vm_offset_t addr; ! 642: vm_size_t size; ! 643: { ! 644: int i, j; ! 645: if ((addr < zone_map_min_address) || ! 646: (addr+size > zone_map_max_address)) return; ! 647: i = atop(addr-zone_map_min_address); ! 648: j = atop((addr+size-1) - zone_map_min_address); ! 649: lock_zone_page_table(); ! 650: for (; i <= j; i++) { ! 651: /* Set alloc_count to (ZONE_PAGE_USED + 1) if ! 652: * it was previously set to ZONE_PAGE_UNUSED. ! 653: */ ! 654: if (zone_page_table[i].alloc_count == ZONE_PAGE_UNUSED) { ! 655: zone_page_table[i].alloc_count = 1; ! 656: } else { ! 657: zone_page_table[i].alloc_count++; ! 658: } ! 659: } ! 660: unlock_zone_page_table(); ! 661: } ! 662: ! 663: void zone_page_dealloc(addr, size) ! 664: vm_offset_t addr; ! 665: vm_size_t size; ! 666: { ! 667: int i, j; ! 668: if ((addr < zone_map_min_address) || ! 669: (addr+size > zone_map_max_address)) return; ! 670: i = atop(addr-zone_map_min_address); ! 671: j = atop((addr+size-1) - zone_map_min_address); ! 672: lock_zone_page_table(); ! 673: for (; i <= j; i++) { ! 674: zone_page_table[i].alloc_count--; ! 675: } ! 676: unlock_zone_page_table(); ! 677: } ! 678: ! 679: void ! 680: zone_add_free_page_list(free_list, addr, size) ! 681: struct zone_page_table_entry **free_list; ! 682: vm_offset_t addr; ! 683: vm_size_t size; ! 684: { ! 685: int i, j; ! 686: if ((addr < zone_map_min_address) || ! 687: (addr+size > zone_map_max_address)) return; ! 688: i = atop(addr-zone_map_min_address); ! 689: j = atop((addr+size-1) - zone_map_min_address); ! 690: lock_zone_page_table(); ! 691: for (; i <= j; i++) { ! 692: if (zone_page_table[i].alloc_count == 0) { ! 693: zone_page_table[i].next = *free_list; ! 694: *free_list = &zone_page_table[i]; ! 695: zone_page_table[i].alloc_count = ZONE_PAGE_UNUSED; ! 696: zone_page_table[i].in_free_list = 0; ! 697: } ! 698: } ! 699: unlock_zone_page_table(); ! 700: } ! 701: ! 702: ! 703: /* This is used for walking through a zone's free element list. ! 704: */ ! 705: struct zone_free_entry { ! 706: struct zone_free_entry * next; ! 707: }; ! 708: ! 709: ! 710: /* Zone garbage collection ! 711: * ! 712: * zone_gc will walk through all the free elements in all the ! 713: * zones that are marked collectable looking for reclaimable ! 714: * pages. zone_gc is called by consider_zone_gc when the system ! 715: * begins to run out of memory. ! 716: */ ! 717: static void zone_gc() ! 718: { ! 719: int max_zones; ! 720: zone_t z; ! 721: int i; ! 722: register spl_t s; ! 723: struct zone_page_table_entry *freep; ! 724: struct zone_page_table_entry *zone_free_page_list; ! 725: ! 726: simple_lock(&all_zones_lock); ! 727: max_zones = num_zones; ! 728: z = first_zone; ! 729: simple_unlock(&all_zones_lock); ! 730: ! 731: zone_free_page_list = (struct zone_page_table_entry *) 0; ! 732: ! 733: for (i = 0; i < max_zones; i++) { ! 734: struct zone_free_entry * last; ! 735: struct zone_free_entry * elt; ! 736: assert(z != ZONE_NULL); ! 737: /* run this at splhigh so that interupt routines that use zones ! 738: can not interupt while their zone is locked */ ! 739: s=splhigh(); ! 740: zone_lock(z); ! 741: ! 742: if ((z->type & (ZONE_PAGEABLE|ZONE_COLLECTABLE)) == ZONE_COLLECTABLE) { ! 743: ! 744: /* Count the free elements in each page. This loop ! 745: * requires that all in_free_list entries are zero. ! 746: */ ! 747: elt = (struct zone_free_entry *)(z->free_elements); ! 748: while ((elt != (struct zone_free_entry *)0)) { ! 749: zone_page_free((vm_offset_t)elt, z->elem_size); ! 750: elt = elt->next; ! 751: } ! 752: ! 753: /* Now determine which elements should be removed ! 754: * from the free list and, after all the elements ! 755: * on a page have been removed, add the element's ! 756: * page to a list of pages to be freed. ! 757: */ ! 758: elt = (struct zone_free_entry *)(z->free_elements); ! 759: last = elt; ! 760: while ((elt != (struct zone_free_entry *)0)) { ! 761: if (((vm_offset_t)elt>=zone_map_min_address)&& ! 762: ((vm_offset_t)elt<=zone_map_max_address)&& ! 763: (zone_page(elt)->in_free_list == ! 764: zone_page(elt)->alloc_count)) { ! 765: ! 766: z->cur_size -= z->elem_size; ! 767: zone_page_in_use((vm_offset_t)elt, z->elem_size); ! 768: zone_page_dealloc((vm_offset_t)elt, z->elem_size); ! 769: if (zone_page(elt)->alloc_count == 0 || ! 770: zone_page(elt+(z->elem_size-1))->alloc_count==0) { ! 771: zone_add_free_page_list( ! 772: &zone_free_page_list, ! 773: (vm_offset_t)elt, z->elem_size); ! 774: } ! 775: ! 776: ! 777: if (elt == last) { ! 778: elt = elt->next; ! 779: z->free_elements =(vm_offset_t)elt; ! 780: last = elt; ! 781: } else { ! 782: last->next = elt->next; ! 783: elt = elt->next; ! 784: } ! 785: } else { ! 786: /* This element is not eligible for collection ! 787: * so clear in_free_list in preparation for a ! 788: * subsequent garbage collection pass. ! 789: */ ! 790: if (((vm_offset_t)elt>=zone_map_min_address)&& ! 791: ((vm_offset_t)elt<=zone_map_max_address)) { ! 792: zone_page(elt)->in_free_list = 0; ! 793: } ! 794: last = elt; ! 795: elt = elt->next; ! 796: } ! 797: } ! 798: } ! 799: zone_unlock(z); ! 800: splx(s); ! 801: simple_lock(&all_zones_lock); ! 802: z = z->next_zone; ! 803: simple_unlock(&all_zones_lock); ! 804: } ! 805: ! 806: for (freep = zone_free_page_list; freep != 0; freep = freep->next) { ! 807: vm_offset_t free_addr; ! 808: ! 809: free_addr = zone_map_min_address + ! 810: PAGE_SIZE * (freep - zone_page_table); ! 811: kmem_free(zone_map, free_addr, PAGE_SIZE); ! 812: } ! 813: } ! 814: ! 815: boolean_t zone_gc_allowed = TRUE; ! 816: unsigned zone_gc_last_tick = 0; ! 817: unsigned zone_gc_max_rate = 0; /* in ticks */ ! 818: ! 819: /* ! 820: * consider_zone_gc: ! 821: * ! 822: * Called by the pageout daemon when the system needs more free pages. ! 823: */ ! 824: ! 825: void ! 826: consider_zone_gc() ! 827: { ! 828: /* ! 829: * By default, don't attempt zone GC more frequently ! 830: * than once a second. ! 831: */ ! 832: ! 833: if (zone_gc_max_rate == 0) ! 834: zone_gc_max_rate = hz; ! 835: ! 836: if (zone_gc_allowed && ! 837: (sched_tick > (zone_gc_last_tick + zone_gc_max_rate))) { ! 838: zone_gc_last_tick = sched_tick; ! 839: zone_gc(); ! 840: } ! 841: } ! 842: ! 843: #if MACH_DEBUG ! 844: kern_return_t host_zone_info(host, namesp, namesCntp, infop, infoCntp) ! 845: host_t host; ! 846: zone_name_array_t *namesp; ! 847: unsigned int *namesCntp; ! 848: zone_info_array_t *infop; ! 849: unsigned int *infoCntp; ! 850: { ! 851: zone_name_t *names; ! 852: vm_offset_t names_addr; ! 853: vm_size_t names_size = 0; /*'=0' to quiet gcc warnings */ ! 854: zone_info_t *info; ! 855: vm_offset_t info_addr; ! 856: vm_size_t info_size = 0; /*'=0' to quiet gcc warnings */ ! 857: unsigned int max_zones, i; ! 858: zone_t z; ! 859: kern_return_t kr; ! 860: ! 861: if (host == HOST_NULL) ! 862: return KERN_INVALID_HOST; ! 863: ! 864: /* ! 865: * We assume that zones aren't freed once allocated. ! 866: * We won't pick up any zones that are allocated later. ! 867: */ ! 868: ! 869: simple_lock(&all_zones_lock); ! 870: max_zones = num_zones; ! 871: z = first_zone; ! 872: simple_unlock(&all_zones_lock); ! 873: ! 874: if (max_zones <= *namesCntp) { ! 875: /* use in-line memory */ ! 876: ! 877: names = *namesp; ! 878: } else { ! 879: names_size = round_page(max_zones * sizeof *names); ! 880: kr = kmem_alloc_pageable(ipc_kernel_map, ! 881: &names_addr, names_size); ! 882: if (kr != KERN_SUCCESS) ! 883: return kr; ! 884: ! 885: names = (zone_name_t *) names_addr; ! 886: } ! 887: ! 888: if (max_zones <= *infoCntp) { ! 889: /* use in-line memory */ ! 890: ! 891: info = *infop; ! 892: } else { ! 893: info_size = round_page(max_zones * sizeof *info); ! 894: kr = kmem_alloc_pageable(ipc_kernel_map, ! 895: &info_addr, info_size); ! 896: if (kr != KERN_SUCCESS) { ! 897: if (names != *namesp) ! 898: kmem_free(ipc_kernel_map, ! 899: names_addr, names_size); ! 900: return kr; ! 901: } ! 902: ! 903: info = (zone_info_t *) info_addr; ! 904: } ! 905: ! 906: for (i = 0; i < max_zones; i++) { ! 907: zone_name_t *zn = &names[i]; ! 908: zone_info_t *zi = &info[i]; ! 909: struct zone zcopy; ! 910: ! 911: assert(z != ZONE_NULL); ! 912: ! 913: zone_lock(z); ! 914: zcopy = *z; ! 915: zone_unlock(z); ! 916: ! 917: simple_lock(&all_zones_lock); ! 918: z = z->next_zone; ! 919: simple_unlock(&all_zones_lock); ! 920: ! 921: /* assuming here the name data is static */ ! 922: (void) strncpy(zn->zn_name, zcopy.zone_name, ! 923: sizeof zn->zn_name); ! 924: ! 925: #ifdef ZONE_COUNT ! 926: zi->zi_count = zcopy.count; ! 927: #else ! 928: zi->zi_count = 0; ! 929: #endif ! 930: zi->zi_cur_size = zcopy.cur_size; ! 931: zi->zi_max_size = zcopy.max_size; ! 932: zi->zi_elem_size = zcopy.elem_size; ! 933: zi->zi_alloc_size = zcopy.alloc_size; ! 934: zi->zi_pageable = (zcopy.type & ZONE_PAGEABLE) != 0; ! 935: zi->zi_exhaustible = (zcopy.type & ZONE_EXHAUSTIBLE) != 0; ! 936: zi->zi_collectable = (zcopy.type & ZONE_COLLECTABLE) != 0; ! 937: } ! 938: ! 939: if (names != *namesp) { ! 940: vm_size_t used; ! 941: vm_map_copy_t copy; ! 942: ! 943: used = max_zones * sizeof *names; ! 944: ! 945: if (used != names_size) ! 946: bzero((char *) (names_addr + used), names_size - used); ! 947: ! 948: kr = vm_map_copyin(ipc_kernel_map, names_addr, names_size, ! 949: TRUE, ©); ! 950: assert(kr == KERN_SUCCESS); ! 951: ! 952: *namesp = (zone_name_t *) copy; ! 953: } ! 954: *namesCntp = max_zones; ! 955: ! 956: if (info != *infop) { ! 957: vm_size_t used; ! 958: vm_map_copy_t copy; ! 959: ! 960: used = max_zones * sizeof *info; ! 961: ! 962: if (used != info_size) ! 963: bzero((char *) (info_addr + used), info_size - used); ! 964: ! 965: kr = vm_map_copyin(ipc_kernel_map, info_addr, info_size, ! 966: TRUE, ©); ! 967: assert(kr == KERN_SUCCESS); ! 968: ! 969: *infop = (zone_info_t *) copy; ! 970: } ! 971: *infoCntp = max_zones; ! 972: ! 973: return KERN_SUCCESS; ! 974: } ! 975: #endif /* MACH_DEBUG */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.