![[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] / Gnu-Mach / kern|
Return to zalloc.c CVS log | Up to [GnuMach] / Gnu-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");
454: }
455: }
456:
457: if (zone->type & ZONE_PAGEABLE)
458: zone->doing_alloc = TRUE;
459: zone_unlock(zone);
460:
461: if (zone->type & ZONE_PAGEABLE) {
462: if (kmem_alloc_pageable(zone_map, &addr,
463: zone->alloc_size)
464: != KERN_SUCCESS)
465: panic("zalloc");
466: zcram(zone, addr, zone->alloc_size);
467: zone_lock(zone);
468: zone->doing_alloc = FALSE;
469: /* XXX check before doing this */
470: thread_wakeup((event_t)&zone->doing_alloc);
471:
472: REMOVE_FROM_ZONE(zone, addr, vm_offset_t);
473: } else if (zone->type & ZONE_COLLECTABLE) {
474: if (kmem_alloc_wired(zone_map,
475: &addr, zone->alloc_size)
476: != KERN_SUCCESS)
477: panic("zalloc");
478: zone_page_init(addr, zone->alloc_size,
479: ZONE_PAGE_USED);
480: zcram(zone, addr, zone->alloc_size);
481: zone_lock(zone);
482: REMOVE_FROM_ZONE(zone, addr, vm_offset_t);
483: } else {
484: addr = zget_space(zone->elem_size);
485: if (addr == 0)
486: panic("zalloc");
487:
488: zone_lock(zone);
489: zone_count_up(zone);
490: zone->cur_size += zone->elem_size;
491: zone_unlock(zone);
492: zone_page_alloc(addr, zone->elem_size);
493: return(addr);
494: }
495: }
496: }
497:
498: zone_unlock(zone);
499: return(addr);
500: }
501:
502:
503: /*
504: * zget returns an element from the specified zone
505: * and immediately returns nothing if there is nothing there.
506: *
507: * This form should be used when you can not block (like when
508: * processing an interrupt).
509: */
510: vm_offset_t zget(zone_t zone)
511: {
512: register vm_offset_t addr;
513:
514: if (zone == ZONE_NULL)
515: panic ("zalloc: null zone");
516:
517: zone_lock(zone);
518: REMOVE_FROM_ZONE(zone, addr, vm_offset_t);
519: zone_unlock(zone);
520:
521: return(addr);
522: }
523:
524: boolean_t zone_check = FALSE;
525:
526: void zfree(zone_t zone, vm_offset_t elem)
527: {
528: zone_lock(zone);
529: if (zone_check) {
530: vm_offset_t this;
531:
532: /* check the zone's consistency */
533:
534: for (this = zone->free_elements;
535: this != 0;
536: this = * (vm_offset_t *) this)
537: if (this == elem)
538: panic("zfree");
539: }
540: ADD_TO_ZONE(zone, elem);
541: zone_unlock(zone);
542: }
543:
544: /*
545: * Zone garbage collection subroutines
546: *
547: * These routines have in common the modification of entries in the
548: * zone_page_table. The latter contains one entry for every page
549: * in the zone_map.
550: *
551: * For each page table entry in the given range:
552: *
553: * zone_page_in_use - decrements in_free_list
554: * zone_page_free - increments in_free_list
555: * zone_page_init - initializes in_free_list and alloc_count
556: * zone_page_alloc - increments alloc_count
557: * zone_page_dealloc - decrements alloc_count
558: * zone_add_free_page_list - adds the page to the free list
559: *
560: * Two counts are maintained for each page, the in_free_list count and
561: * alloc_count. The alloc_count is how many zone elements have been
562: * allocated from a page. (Note that the page could contain elements
563: * that span page boundaries. The count includes these elements so
564: * one element may be counted in two pages.) In_free_list is a count
565: * of how many zone elements are currently free. If in_free_list is
566: * equal to alloc_count then the page is eligible for garbage
567: * collection.
568: *
569: * Alloc_count and in_free_list are initialized to the correct values
570: * for a particular zone when a page is zcram'ed into a zone. Subsequent
571: * gets and frees of zone elements will call zone_page_in_use and
572: * zone_page_free which modify the in_free_list count. When the zones
573: * garbage collector runs it will walk through a zones free element list,
574: * remove the elements that reside on collectable pages, and use
575: * zone_add_free_page_list to create a list of pages to be collected.
576: */
577:
578: void zone_page_in_use(addr, size)
579: vm_offset_t addr;
580: vm_size_t size;
581: {
582: int i, j;
583: if ((addr < zone_map_min_address) ||
584: (addr+size > zone_map_max_address)) return;
585: i = atop(addr-zone_map_min_address);
586: j = atop((addr+size-1) - zone_map_min_address);
587: lock_zone_page_table();
588: for (; i <= j; i++) {
589: zone_page_table[i].in_free_list--;
590: }
591: unlock_zone_page_table();
592: }
593:
594: void zone_page_free(addr, size)
595: vm_offset_t addr;
596: vm_size_t size;
597: {
598: int i, j;
599: if ((addr < zone_map_min_address) ||
600: (addr+size > zone_map_max_address)) return;
601: i = atop(addr-zone_map_min_address);
602: j = atop((addr+size-1) - zone_map_min_address);
603: lock_zone_page_table();
604: for (; i <= j; i++) {
605: /* Set in_free_list to (ZONE_PAGE_USED + 1) if
606: * it was previously set to ZONE_PAGE_UNUSED.
607: */
608: if (zone_page_table[i].in_free_list == ZONE_PAGE_UNUSED) {
609: zone_page_table[i].in_free_list = 1;
610: } else {
611: zone_page_table[i].in_free_list++;
612: }
613: }
614: unlock_zone_page_table();
615: }
616:
617: void zone_page_init(addr, size, value)
618:
619: vm_offset_t addr;
620: vm_size_t size;
621: int value;
622: {
623: int i, j;
624: if ((addr < zone_map_min_address) ||
625: (addr+size > zone_map_max_address)) return;
626: i = atop(addr-zone_map_min_address);
627: j = atop((addr+size-1) - zone_map_min_address);
628: lock_zone_page_table();
629: for (; i <= j; i++) {
630: zone_page_table[i].alloc_count = value;
631: zone_page_table[i].in_free_list = 0;
632: }
633: unlock_zone_page_table();
634: }
635:
636: void zone_page_alloc(addr, size)
637: vm_offset_t addr;
638: vm_size_t size;
639: {
640: int i, j;
641: if ((addr < zone_map_min_address) ||
642: (addr+size > zone_map_max_address)) return;
643: i = atop(addr-zone_map_min_address);
644: j = atop((addr+size-1) - zone_map_min_address);
645: lock_zone_page_table();
646: for (; i <= j; i++) {
647: /* Set alloc_count to (ZONE_PAGE_USED + 1) if
648: * it was previously set to ZONE_PAGE_UNUSED.
649: */
650: if (zone_page_table[i].alloc_count == ZONE_PAGE_UNUSED) {
651: zone_page_table[i].alloc_count = 1;
652: } else {
653: zone_page_table[i].alloc_count++;
654: }
655: }
656: unlock_zone_page_table();
657: }
658:
659: void zone_page_dealloc(addr, size)
660: vm_offset_t addr;
661: vm_size_t size;
662: {
663: int i, j;
664: if ((addr < zone_map_min_address) ||
665: (addr+size > zone_map_max_address)) return;
666: i = atop(addr-zone_map_min_address);
667: j = atop((addr+size-1) - zone_map_min_address);
668: lock_zone_page_table();
669: for (; i <= j; i++) {
670: zone_page_table[i].alloc_count--;
671: }
672: unlock_zone_page_table();
673: }
674:
675: void
676: zone_add_free_page_list(free_list, addr, size)
677: struct zone_page_table_entry **free_list;
678: vm_offset_t addr;
679: vm_size_t size;
680: {
681: int i, j;
682: if ((addr < zone_map_min_address) ||
683: (addr+size > zone_map_max_address)) return;
684: i = atop(addr-zone_map_min_address);
685: j = atop((addr+size-1) - zone_map_min_address);
686: lock_zone_page_table();
687: for (; i <= j; i++) {
688: if (zone_page_table[i].alloc_count == 0) {
689: zone_page_table[i].next = *free_list;
690: *free_list = &zone_page_table[i];
691: zone_page_table[i].alloc_count = ZONE_PAGE_UNUSED;
692: zone_page_table[i].in_free_list = 0;
693: }
694: }
695: unlock_zone_page_table();
696: }
697:
698:
699: /* This is used for walking through a zone's free element list.
700: */
701: struct zone_free_entry {
702: struct zone_free_entry * next;
703: };
704:
705:
706: /* Zone garbage collection
707: *
708: * zone_gc will walk through all the free elements in all the
709: * zones that are marked collectable looking for reclaimable
710: * pages. zone_gc is called by consider_zone_gc when the system
711: * begins to run out of memory.
712: */
713: static void zone_gc()
714: {
715: int max_zones;
716: zone_t z;
717: int i;
718: register spl_t s;
719: struct zone_page_table_entry *freep;
720: struct zone_page_table_entry *zone_free_page_list;
721:
722: simple_lock(&all_zones_lock);
723: max_zones = num_zones;
724: z = first_zone;
725: simple_unlock(&all_zones_lock);
726:
727: zone_free_page_list = (struct zone_page_table_entry *) 0;
728:
729: for (i = 0; i < max_zones; i++) {
730: struct zone_free_entry * last;
731: struct zone_free_entry * elt;
732: assert(z != ZONE_NULL);
733: /* run this at splhigh so that interupt routines that use zones
734: can not interupt while their zone is locked */
735: s=splhigh();
736: zone_lock(z);
737:
738: if ((z->type & (ZONE_PAGEABLE|ZONE_COLLECTABLE)) == ZONE_COLLECTABLE) {
739:
740: /* Count the free elements in each page. This loop
741: * requires that all in_free_list entries are zero.
742: */
743: elt = (struct zone_free_entry *)(z->free_elements);
744: while ((elt != (struct zone_free_entry *)0)) {
745: zone_page_free((vm_offset_t)elt, z->elem_size);
746: elt = elt->next;
747: }
748:
749: /* Now determine which elements should be removed
750: * from the free list and, after all the elements
751: * on a page have been removed, add the element's
752: * page to a list of pages to be freed.
753: */
754: elt = (struct zone_free_entry *)(z->free_elements);
755: last = elt;
756: while ((elt != (struct zone_free_entry *)0)) {
757: if (((vm_offset_t)elt>=zone_map_min_address)&&
758: ((vm_offset_t)elt<=zone_map_max_address)&&
759: (zone_page(elt)->in_free_list ==
760: zone_page(elt)->alloc_count)) {
761:
762: z->cur_size -= z->elem_size;
763: zone_page_in_use((vm_offset_t)elt, z->elem_size);
764: zone_page_dealloc((vm_offset_t)elt, z->elem_size);
765: if (zone_page(elt)->alloc_count == 0 ||
766: zone_page(elt+(z->elem_size-1))->alloc_count==0) {
767: zone_add_free_page_list(
768: &zone_free_page_list,
769: (vm_offset_t)elt, z->elem_size);
770: }
771:
772:
773: if (elt == last) {
774: elt = elt->next;
775: z->free_elements =(vm_offset_t)elt;
776: last = elt;
777: } else {
778: last->next = elt->next;
779: elt = elt->next;
780: }
781: } else {
782: /* This element is not eligible for collection
783: * so clear in_free_list in preparation for a
784: * subsequent garbage collection pass.
785: */
786: if (((vm_offset_t)elt>=zone_map_min_address)&&
787: ((vm_offset_t)elt<=zone_map_max_address)) {
788: zone_page(elt)->in_free_list = 0;
789: }
790: last = elt;
791: elt = elt->next;
792: }
793: }
794: }
795: zone_unlock(z);
796: splx(s);
797: simple_lock(&all_zones_lock);
798: z = z->next_zone;
799: simple_unlock(&all_zones_lock);
800: }
801:
802: for (freep = zone_free_page_list; freep != 0; freep = freep->next) {
803: vm_offset_t free_addr;
804:
805: free_addr = zone_map_min_address +
806: PAGE_SIZE * (freep - zone_page_table);
807: kmem_free(zone_map, free_addr, PAGE_SIZE);
808: }
809: }
810:
811: boolean_t zone_gc_allowed = TRUE;
812: unsigned zone_gc_last_tick = 0;
813: unsigned zone_gc_max_rate = 0; /* in ticks */
814:
815: /*
816: * consider_zone_gc:
817: *
818: * Called by the pageout daemon when the system needs more free pages.
819: */
820:
821: void
822: consider_zone_gc()
823: {
824: /*
825: * By default, don't attempt zone GC more frequently
826: * than once a second.
827: */
828:
829: if (zone_gc_max_rate == 0)
830: zone_gc_max_rate = hz;
831:
832: if (zone_gc_allowed &&
833: (sched_tick > (zone_gc_last_tick + zone_gc_max_rate))) {
834: zone_gc_last_tick = sched_tick;
835: zone_gc();
836: }
837: }
838:
839: #if MACH_DEBUG
840: kern_return_t host_zone_info(host, namesp, namesCntp, infop, infoCntp)
841: host_t host;
842: zone_name_array_t *namesp;
843: unsigned int *namesCntp;
844: zone_info_array_t *infop;
845: unsigned int *infoCntp;
846: {
847: zone_name_t *names;
848: vm_offset_t names_addr;
849: vm_size_t names_size = 0; /*'=0' to quiet gcc warnings */
850: zone_info_t *info;
851: vm_offset_t info_addr;
852: vm_size_t info_size = 0; /*'=0' to quiet gcc warnings */
853: unsigned int max_zones, i;
854: zone_t z;
855: kern_return_t kr;
856:
857: if (host == HOST_NULL)
858: return KERN_INVALID_HOST;
859:
860: /*
861: * We assume that zones aren't freed once allocated.
862: * We won't pick up any zones that are allocated later.
863: */
864:
865: simple_lock(&all_zones_lock);
866: max_zones = num_zones;
867: z = first_zone;
868: simple_unlock(&all_zones_lock);
869:
870: if (max_zones <= *namesCntp) {
871: /* use in-line memory */
872:
873: names = *namesp;
874: } else {
875: names_size = round_page(max_zones * sizeof *names);
876: kr = kmem_alloc_pageable(ipc_kernel_map,
877: &names_addr, names_size);
878: if (kr != KERN_SUCCESS)
879: return kr;
880:
881: names = (zone_name_t *) names_addr;
882: }
883:
884: if (max_zones <= *infoCntp) {
885: /* use in-line memory */
886:
887: info = *infop;
888: } else {
889: info_size = round_page(max_zones * sizeof *info);
890: kr = kmem_alloc_pageable(ipc_kernel_map,
891: &info_addr, info_size);
892: if (kr != KERN_SUCCESS) {
893: if (names != *namesp)
894: kmem_free(ipc_kernel_map,
895: names_addr, names_size);
896: return kr;
897: }
898:
899: info = (zone_info_t *) info_addr;
900: }
901:
902: for (i = 0; i < max_zones; i++) {
903: zone_name_t *zn = &names[i];
904: zone_info_t *zi = &info[i];
905: struct zone zcopy;
906:
907: assert(z != ZONE_NULL);
908:
909: zone_lock(z);
910: zcopy = *z;
911: zone_unlock(z);
912:
913: simple_lock(&all_zones_lock);
914: z = z->next_zone;
915: simple_unlock(&all_zones_lock);
916:
917: /* assuming here the name data is static */
918: (void) strncpy(zn->zn_name, zcopy.zone_name,
919: sizeof zn->zn_name);
920:
921: #ifdef ZONE_COUNT
922: zi->zi_count = zcopy.count;
923: #else
924: zi->zi_count = 0;
925: #endif
926: zi->zi_cur_size = zcopy.cur_size;
927: zi->zi_max_size = zcopy.max_size;
928: zi->zi_elem_size = zcopy.elem_size;
929: zi->zi_alloc_size = zcopy.alloc_size;
930: zi->zi_pageable = (zcopy.type & ZONE_PAGEABLE) != 0;
931: zi->zi_exhaustible = (zcopy.type & ZONE_EXHAUSTIBLE) != 0;
932: zi->zi_collectable = (zcopy.type & ZONE_COLLECTABLE) != 0;
933: }
934:
935: if (names != *namesp) {
936: vm_size_t used;
937: vm_map_copy_t copy;
938:
939: used = max_zones * sizeof *names;
940:
941: if (used != names_size)
942: bzero((char *) (names_addr + used), names_size - used);
943:
944: kr = vm_map_copyin(ipc_kernel_map, names_addr, names_size,
945: TRUE, ©);
946: assert(kr == KERN_SUCCESS);
947:
948: *namesp = (zone_name_t *) copy;
949: }
950: *namesCntp = max_zones;
951:
952: if (info != *infop) {
953: vm_size_t used;
954: vm_map_copy_t copy;
955:
956: used = max_zones * sizeof *info;
957:
958: if (used != info_size)
959: bzero((char *) (info_addr + used), info_size - used);
960:
961: kr = vm_map_copyin(ipc_kernel_map, info_addr, info_size,
962: TRUE, ©);
963: assert(kr == KERN_SUCCESS);
964:
965: *infop = (zone_info_t *) copy;
966: }
967: *infoCntp = max_zones;
968:
969: return KERN_SUCCESS;
970: }
971: #endif MACH_DEBUG
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.