![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vm_resident.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_resident.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) 1993-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_page.c
52: * Author: Avadis Tevanian, Jr., Michael Wayne Young
53: *
54: * Resident memory management module.
55: */
56:
57: #import <mach/features.h>
58:
59: #include <mach/vm_prot.h>
60: #include <kern/counters.h>
61: #include <kern/sched_prim.h>
62: #include <kern/task.h>
63: #include <kern/thread.h>
64: #include <mach/vm_statistics.h>
65: #include <kern/xpr.h>
66: #include <kern/zalloc.h>
67: #include <vm/pmap.h>
68: #include <vm/vm_map.h>
69: #include <vm/vm_page.h>
70: #include <vm/vm_pageout.h>
71:
72: #include <mach/vm_policy.h>
73:
74: /*
75: * Associated with eacn page of user-allocatable memory is a
76: * page structure.
77: */
78:
79: /*
80: * These variables record the values returned by vm_page_bootstrap,
81: * for debugging purposes. The implementation of pmap_steal_memory
82: * and pmap_startup here also uses them internally.
83: */
84:
85: vm_offset_t virtual_space_start;
86: vm_offset_t virtual_space_end;
87:
88: /*
89: * The vm_page_lookup() routine, which provides for fast
90: * (virtual memory object, offset) to page lookup, employs
91: * the following hash table. The vm_page_{insert,remove}
92: * routines install and remove associations in the table.
93: * [This table is often called the virtual-to-physical,
94: * or VP, table.]
95: */
96: typedef struct {
97: decl_simple_lock_data(,lock)
98: vm_page_t pages;
99: } vm_page_bucket_t;
100:
101: vm_page_bucket_t *vm_page_buckets; /* Array of buckets */
102: unsigned int vm_page_bucket_count = 0; /* How big is array? */
103: unsigned int vm_page_hash_mask; /* Mask for hash function */
104:
105: /*
106: * The virtual page size is currently implemented as a runtime
107: * variable, but is constant once initialized using vm_set_page_size.
108: * This initialization must be done in the machine-dependent
109: * bootstrap sequence, before calling other machine-independent
110: * initializations.
111: *
112: * All references to the virtual page size outside this
113: * module must use the PAGE_SIZE constant.
114: */
115: vm_size_t page_size = 0;
116: vm_size_t page_mask;
117: int page_shift;
118:
119: vm_offset_t map_data;
120: vm_size_t map_data_size;
121:
122: vm_offset_t kentry_data;
123: vm_size_t kentry_data_size;
124:
125: extern vm_offset_t zdata;
126: extern vm_size_t zdata_size;
127:
128: queue_head_t vm_page_queue_free;
129: queue_head_t vm_page_queue_active;
130: queue_head_t vm_page_queue_inactive;
131: simple_lock_data_t vm_page_queue_lock;
132: simple_lock_data_t vm_page_queue_free_lock;
133:
134: vm_page_t vm_page_array;
135: long first_page;
136: long last_page;
137: vm_offset_t first_phys_addr;
138: vm_offset_t last_phys_addr;
139:
140: int vm_page_free_count;
141: int vm_page_active_count;
142: int vm_page_inactive_count;
143: int vm_page_wire_count;
144:
145: /*
146: * Several page replacement parameters are also
147: * shared with this module, so that page allocation
148: * (done here in vm_page_alloc) can trigger the
149: * pageout daemon.
150: */
151: int vm_page_free_target = 0;
152: int vm_page_free_min = 0;
153: int vm_page_inactive_target = 0;
154: int vm_page_free_reserved = 0;
155: int vm_page_laundry_count = 0;
156:
157: struct vm_page vm_page_template;
158:
159: #if SHOW_SPACE
160: extern int show_space;
161: #endif SHOW_SPACE
162:
163: /*
164: * vm_set_page_size:
165: *
166: * Sets the page size, perhaps based upon the memory
167: * size. Must be called before any use of page-size
168: * dependent functions.
169: *
170: * Sets page_shift and page_mask from page_size.
171: */
172: void vm_set_page_size(void)
173: {
174: page_mask = page_size - 1;
175:
176: if ((page_mask & page_size) != 0)
177: panic("vm_set_page_size: page size not a power of two");
178:
179: for (page_shift = 0; ; page_shift++)
180: if ((1 << page_shift) == page_size)
181: break;
182: }
183:
184: /*
185: * vm_page_startup:
186: *
187: * Initializes the resident memory module.
188: *
189: * Allocates memory for the page cells, and
190: * for the object/offset-to-page hash table headers.
191: * Each page cell is initialized and placed on the free list.
192: */
193:
194: #if SHOW_SPACE
195: #define PALLOC(name, type, num) \
196: MACRO_BEGIN \
197: (type *)(name) = (type *) \
198: vm_alloc_from_regions((num) * sizeof(type), \
199: __alignof__(type)); \
200: bzero((name), (num) * sizeof(type)); \
201: if (show_space) { \
202: printf(#name " = %d (0x%x) bytes @%x," \
203: " %d cells of %d bytes\n", \
204: (num)*sizeof(type), (num)*sizeof(type), name, \
205: num, sizeof(type)); \
206: } \
207: MACRO_END
208:
209: #define PALLOC_SIZE(name, size, type, num) \
210: MACRO_BEGIN \
211: (size) = (num) * sizeof(type); \
212: (type *)(name) = (type *) \
213: vm_alloc_from_regions((size), \
214: __alignof__(type)); \
215: bzero((name), (size)); \
216: if (show_space) { \
217: printf(#name " = %d (0x%x) bytes @%x," \
218: " %d cells of %d bytes\n", \
219: (size), (size), name, \
220: num, sizeof(type)); \
221: } \
222: MACRO_END
223:
224: #define PALLOC_PAGES(name, type, size) \
225: MACRO_BEGIN \
226: (size) = round_page(size); \
227: (type *)(name) = (type *) \
228: vm_alloc_from_regions((size), PAGE_SIZE); \
229: bzero((name), (size)); \
230: if (show_space) { \
231: printf(#name " = %d (0x%x) bytes @%x," \
232: " %d pages of %d bytes\n", \
233: (size), (size), name, \
234: (size) / PAGE_SIZE, PAGE_SIZE); \
235: } \
236: MACRO_END
237: #else SHOW_SPACE
238: #define PALLOC(name, type, num) \
239: MACRO_BEGIN \
240: (type *)(name) = (type *) \
241: vm_alloc_from_regions((num) * sizeof(type), \
242: __alignof__(type)); \
243: bzero((name), (num) * sizeof(type)); \
244: MACRO_END
245:
246: #define PALLOC_SIZE(name, size, type, num) \
247: MACRO_BEGIN \
248: (size) = (num) * sizeof(type); \
249: (type *)(name) = (type *) \
250: vm_alloc_from_regions((size), \
251: __alignof__(type)); \
252: bzero((name), (size)); \
253: MACRO_END
254:
255: #define PALLOC_PAGES(name, type, size) \
256: MACRO_BEGIN \
257: (size) = round_page(size); \
258: (type *)(name) = (type *) \
259: vm_alloc_from_regions((size), PAGE_SIZE); \
260: bzero((name), (size)); \
261: MACRO_END
262: #endif SHOW_SPACE
263:
264: vm_offset_t vm_page_startup(mem_region, num_regions, vavail)
265: mem_region_t mem_region;
266: int num_regions;
267: vm_offset_t vavail;
268: {
269: int mem_size;
270: mem_region_t rp;
271: vm_page_t m;
272: queue_t bucket;
273: int i;
274: vm_offset_t pa;
275: extern vm_offset_t virtual_avail;
276:
277: /*
278: * Initialize the vm_page template.
279: */
280:
281: m = &vm_page_template;
282: m->object = VM_OBJECT_NULL; /* reset later */
283: m->offset = 0; /* reset later */
284: m->wire_count = 0;
285:
286: #if OLD_VM_CODE
287: m->clean = TRUE;
288: m->nfspagereq = FALSE;
289: m->copy_on_write = FALSE;
290: m->asyncrw = FALSE;
291: #endif
292: m->inactive = FALSE;
293: m->active = FALSE;
294: m->laundry = FALSE;
295: m->free = FALSE;
296:
297: m->busy = TRUE;
298: m->wanted = FALSE;
299: m->tabled = FALSE;
300: m->fictitious = FALSE;
301: m->private = FALSE;
302: m->absent = FALSE;
303: m->error = FALSE;
304: m->dirty = FALSE;
305: m->precious = FALSE;
306: m->reference = FALSE;
307:
308: m->phys_addr = 0; /* reset later */
309:
310: m->page_lock = VM_PROT_NONE;
311: m->unlock_request = VM_PROT_NONE;
312:
313: /*
314: * Initialize the locks
315: */
316:
317: simple_lock_init(&vm_page_queue_free_lock);
318: simple_lock_init(&vm_page_queue_lock);
319:
320: /*
321: * Initialize the queue headers for the free queue,
322: * the active queue and the inactive queue.
323: */
324:
325: queue_init(&vm_page_queue_free);
326: queue_init(&vm_page_queue_active);
327: queue_init(&vm_page_queue_inactive);
328:
329: /*
330: * Allocate (and initialize) the virtual-to-physical
331: * table hash buckets.
332: *
333: * The number of buckets should be a power of two to
334: * get a good hash function. The following computation
335: * chooses the first power of two that is greater
336: * than the number of physical pages in the system.
337: */
338: mem_size = 0;
339: for (rp = mem_region; rp < &mem_region[num_regions]; rp += 1) {
340: mem_size += trunc_page(rp->last_phys_addr)
341: - round_page(rp->first_phys_addr);
342: }
343:
344: if (vm_page_bucket_count == 0) {
345: vm_page_bucket_count = 1;
346: while (vm_page_bucket_count < atop(mem_size))
347: vm_page_bucket_count <<= 1;
348: }
349:
350: vm_page_hash_mask = vm_page_bucket_count - 1;
351:
352: if (vm_page_hash_mask & vm_page_bucket_count)
353: printf("vm_page_bootstrap: WARNING -- strange page hash\n");
354:
355: PALLOC(vm_page_buckets, vm_page_bucket_t, vm_page_bucket_count);
356:
357: for (i = 0; i < vm_page_bucket_count; i++) {
358: register vm_page_bucket_t *bucket = &vm_page_buckets[i];
359:
360: bucket->pages = VM_PAGE_NULL;
361: simple_lock_init(&bucket->lock);
362: }
363:
364: /*
365: * Steal pages for some zones that cannot be
366: * dynamically allocated.
367: */
368: #if 1
369: zdata_size = 8*PAGE_SIZE;
370: PALLOC_PAGES(zdata, void, zdata_size);
371: #else
372: PALLOC_SIZE(zdata, zdata_size, struct zone, 40);
373: #endif
374: PALLOC_SIZE(map_data, map_data_size, struct vm_map, 10);
375:
376: /*
377: * Allow 2048 kernel map entries... this should be plenty
378: * since people shouldn't be cluttering up the kernel
379: * map (they should use their own maps).
380: */
381: PALLOC_SIZE(kentry_data, kentry_data_size, struct vm_map_entry, 2048);
382:
383: /*
384: * First make a pass over each region and allocate
385: * vm_page_arrays. Later go back and size the pages in the
386: * region (since some of the region may have been taken
387: * by the vm_page_array).
388: */
389: for (rp = mem_region; rp < &mem_region[num_regions]; rp += 1) {
390: ASSERT(rp->first_phys_addr <= rp->last_phys_addr);
391: PALLOC(rp->vm_page_array, struct vm_page,
392: atop(trunc_page(rp->last_phys_addr) -
393: round_page(rp->first_phys_addr)));
394: }
395: vm_page_free_count = 0;
396: for (rp = mem_region; rp < &mem_region[num_regions]; rp += 1) {
397: rp->first_phys_addr = round_page(rp->first_phys_addr);
398: rp->last_phys_addr = trunc_page(rp->last_phys_addr);
399: rp->first_page = atop(rp->first_phys_addr);
400: rp->last_page = atop(rp->last_phys_addr);
401: rp->num_pages = rp->last_page - rp->first_page;
402: ASSERT((int)rp->num_pages >= 0);
403: vm_page_free_count += rp->num_pages;
404:
405: m = rp->vm_page_array;
406: pa = rp->first_phys_addr;
407:
408: for (i = 0; i < rp->num_pages; i += 1) {
409: m->phys_addr = pa;
410: queue_enter(&vm_page_queue_free, m, vm_page_t, pageq);
411: m->free = TRUE;
412: m++;
413: pa += page_size;
414: }
415: }
416:
417: /*
418: * Initialize vm_pages_needed lock here - don't wait for pageout
419: * daemon XXX
420: */
421: simple_lock_init(&vm_pages_needed_lock);
422:
423: return(virtual_avail);
424: }
425:
426: /*
427: * vm_page_hash:
428: *
429: * Distributes the object/offset key pair among hash buckets.
430: *
431: * NOTE: To get a good hash function, the bucket count should
432: * be a power of two.
433: */
434: #define vm_page_hash(object, offset) \
435: (((unsigned int)(vm_offset_t)object + (unsigned int)atop(offset)) \
436: & vm_page_hash_mask)
437:
438: /*
439: * vm_page_insert: [ internal use only ]
440: *
441: * Inserts the given mem entry into the object/object-page
442: * table and object list.
443: *
444: * The object and page must be locked.
445: */
446:
447: void vm_page_insert(
448: register vm_page_t mem,
449: register vm_object_t object,
450: register vm_offset_t offset)
451: {
452: register vm_page_bucket_t *bucket;
453:
454: VM_PAGE_CHECK(mem);
455:
456: if (mem->tabled)
457: panic("vm_page_insert");
458:
459: /*
460: * Record the object/offset pair in this page
461: */
462:
463: mem->object = object;
464: mem->offset = offset;
465:
466: /*
467: * Insert it into the object_object/offset hash table
468: */
469:
470: bucket = &vm_page_buckets[vm_page_hash(object, offset)];
471: {
472: int spl = splimp();
473:
474: simple_lock(&bucket->lock);
475: mem->next = bucket->pages;
476: bucket->pages = mem;
477: simple_unlock(&bucket->lock);
478: (void) splx(spl);
479: }
480:
481: /*
482: * Now link into the object's list of backed pages.
483: */
484:
485: queue_enter(&object->memq, mem, vm_page_t, listq);
486: mem->tabled = TRUE;
487:
488: /*
489: * Show that the object has one more resident page.
490: */
491:
492: object->resident_page_count++;
493: }
494:
495: /*
496: * vm_page_remove: [ internal use only ]
497: *
498: * Removes the given mem entry from the object/offset-page
499: * table and the object page list.
500: *
501: * The object and page must be locked.
502: */
503:
504: void vm_page_remove(
505: register vm_page_t mem)
506: {
507: register vm_page_bucket_t *bucket;
508: register vm_page_t this;
509:
510: assert(mem->tabled);
511: VM_PAGE_CHECK(mem);
512:
513: if (!mem->tabled)
514: return;
515:
516: /*
517: * Remove from the object_object/offset hash table
518: */
519:
520: bucket = &vm_page_buckets[vm_page_hash(mem->object, mem->offset)];
521: {
522: int spl = splimp();
523:
524: simple_lock(&bucket->lock);
525: if ((this = bucket->pages) == mem) {
526: /* optimize for common case */
527:
528: bucket->pages = mem->next;
529: } else {
530: register vm_page_t *prev;
531:
532: for (prev = &this->next;
533: (this = *prev) != mem;
534: prev = &this->next)
535: continue;
536: *prev = this->next;
537: }
538: simple_unlock(&bucket->lock);
539: splx(spl);
540: }
541:
542: /*
543: * Now remove from the object's list of backed pages.
544: */
545:
546: queue_remove(&mem->object->memq, mem, vm_page_t, listq);
547:
548: /*
549: * And show that the object has one fewer resident
550: * page.
551: */
552:
553: mem->object->resident_page_count--;
554:
555: mem->tabled = FALSE;
556: }
557:
558: /*
559: * vm_page_lookup:
560: *
561: * Returns the page associated with the object/offset
562: * pair specified; if none is found, VM_PAGE_NULL is returned.
563: *
564: * The object must be locked. No side effects.
565: */
566:
567: vm_page_t vm_page_lookup(
568: register vm_object_t object,
569: register vm_offset_t offset)
570: {
571: register vm_page_t mem;
572: register vm_page_bucket_t *bucket;
573:
574: /*
575: * Search the hash table for this object/offset pair
576: */
577:
578: bucket = &vm_page_buckets[vm_page_hash(object, offset)];
579:
580: {
581: int spl = splimp();
582:
583: simple_lock(&bucket->lock);
584: for (mem = bucket->pages; mem != VM_PAGE_NULL; mem = mem->next) {
585: VM_PAGE_CHECK(mem);
586: if ((mem->object == object) && (mem->offset == offset))
587: break;
588: }
589: simple_unlock(&bucket->lock);
590: splx(spl);
591: }
592: return mem;
593: }
594:
595: /*
596: * vm_page_rename:
597: *
598: * Move the given memory entry from its
599: * current object to the specified target object/offset.
600: *
601: * The object must be locked.
602: */
603: void vm_page_rename(
604: register vm_page_t mem,
605: register vm_object_t new_object,
606: vm_offset_t new_offset)
607: {
608: /*
609: * Changes to mem->object require the page lock because
610: * the pageout daemon uses that lock to get the object.
611: */
612:
613: vm_page_lock_queues();
614: vm_page_remove(mem);
615: vm_page_insert(mem, new_object, new_offset);
616: vm_page_unlock_queues();
617: }
618:
619: /*
620: * vm_page_init:
621: *
622: * Initialize the given vm_page, entering it into
623: * the VP table at the given (object, offset),
624: * and noting its physical address.
625: *
626: * Implemented using a template set up in vm_page_startup.
627: * All fields except those passed as arguments are static.
628: */
629: void vm_page_init(mem, object, offset, phys_addr)
630: vm_page_t mem;
631: vm_object_t object;
632: vm_offset_t offset;
633: vm_offset_t phys_addr;
634: {
635: #define vm_page_init(page, object, offset, pa) { \
636: register \
637: vm_offset_t a = (pa); \
638: *(page) = vm_page_template; \
639: (page)->phys_addr = a; \
640: vm_page_insert((page), (object), (offset)); \
641: }
642:
643: vm_page_init(mem, object, offset, phys_addr);
644: }
645:
646: /*
647: * vm_page_alloc_sequential:
648: *
649: * vm_page_alloc: is a macro calling
650: * vm_page_alloc_sequential(object,offset,TRUE)
651: *
652: * Allocate and return a memory cell associated
653: * with this VM object/offset pair. Don't perform sequential
654: * access checks if called from ICS.
655: *
656: * Object must be locked.
657: */
658: vm_page_t vm_page_alloc_sequential(object, offset, sequential_unmap)
659: vm_object_t object;
660: vm_offset_t offset;
661: boolean_t sequential_unmap;
662: {
663: register vm_page_t mem;
664: int spl;
665:
666: spl = splimp();
667: simple_lock(&vm_page_queue_free_lock);
668:
669: if (queue_empty(&vm_page_queue_free)) {
670: simple_unlock(&vm_page_queue_free_lock);
671: splx(spl);
672: return(VM_PAGE_NULL);
673: }
674:
675: if ((vm_page_free_count < vm_page_free_reserved) &&
676: !current_thread()->vm_privilege) {
677: simple_unlock(&vm_page_queue_free_lock);
678: splx(spl);
679: return(VM_PAGE_NULL);
680: }
681:
682: queue_remove_first(&vm_page_queue_free, mem, vm_page_t, pageq);
683: mem->free = FALSE;
684:
685: vm_page_free_count--;
686: simple_unlock(&vm_page_queue_free_lock);
687: splx(spl);
688:
689: vm_page_remove(mem); /* in case it is still in hash table */
690:
691: vm_page_init(mem, object, offset, mem->phys_addr);
692:
693: /*
694: * Decide if we should poke the pageout daemon.
695: * We do this if the free count is less than the low
696: * water mark, or if the free count is less than the high
697: * water mark (but above the low water mark) and the inactive
698: * count is less than its target.
699: *
700: * We don't have the counts locked ... if they change a little,
701: * it doesn't really matter.
702: */
703:
704: if ((vm_page_free_count < vm_page_free_min) ||
705: ((vm_page_free_count < vm_page_free_target) &&
706: (vm_page_inactive_count < vm_page_inactive_target))){
707: thread_wakeup(&vm_pages_needed);
708: }
709:
710: /*
711: * Detect sequential access and inactivate previous page
712: */
713: if (object->policy & VM_POLICY_SEQUENTIAL && sequential_unmap &&
714: (abs(offset - object->last_alloc) == PAGE_SIZE)) {
715: vm_page_t last_mem;
716:
717: last_mem = vm_page_lookup(object, object->last_alloc);
718: if (last_mem != VM_PAGE_NULL) {
719: int when;
720:
721: switch (object->policy) {
722: case VM_POLICY_SEQ_DEACTIVATE:
723: when = VM_DEACTIVATE_SOON;
724: break;
725: case VM_POLICY_SEQ_FREE:
726: default:
727: when = VM_DEACTIVATE_NOW;
728: break;
729: }
730: vm_policy_apply(object, last_mem, when);
731: }
732: }
733: // else if (object->policy & VM_SEQUENTIAL && sequential_unmap)
734: // object->policy = VM_RANDOM;
735:
736: object->last_alloc = offset;
737: return(mem);
738: }
739:
740: /*
741: * vm_page_free:
742: *
743: * Returns the given page to the free list,
744: * disassociating it with any VM object.
745: *
746: * Object and page must be locked prior to entry.
747: */
748: void vm_page_free(mem)
749: register vm_page_t mem;
750: {
751: vm_page_remove(mem);
752: if (!mem->free) {
753: vm_page_addfree(mem);
754: }
755: }
756:
757: void vm_page_addfree(mem)
758: register vm_page_t mem;
759: {
760: if (mem->active) {
761: queue_remove(&vm_page_queue_active, mem, vm_page_t, pageq);
762: mem->active = FALSE;
763: vm_page_active_count--;
764: }
765:
766: if (mem->inactive) {
767: queue_remove(&vm_page_queue_inactive, mem, vm_page_t, pageq);
768: mem->inactive = FALSE;
769: vm_page_inactive_count--;
770: }
771:
772: if (!mem->fictitious) {
773: int spl;
774:
775: spl = splimp();
776: simple_lock(&vm_page_queue_free_lock);
777: queue_enter(&vm_page_queue_free, mem, vm_page_t, pageq);
778: mem->free = TRUE;
779: vm_page_free_count++;
780: simple_unlock(&vm_page_queue_free_lock);
781: splx(spl);
782: }
783: }
784:
785: /*
786: * vm_page_wire:
787: *
788: * Mark this page as wired down by yet
789: * another map, removing it from paging queues
790: * as necessary.
791: *
792: * The page queues must be locked.
793: */
794: void vm_page_wire(mem)
795: register vm_page_t mem;
796: {
797: VM_PAGE_CHECK(mem);
798:
799: if (mem->wire_count == 0) {
800: if (mem->active) {
801: queue_remove(&vm_page_queue_active, mem, vm_page_t,
802: pageq);
803: vm_page_active_count--;
804: mem->active = FALSE;
805: }
806: if (mem->inactive) {
807: queue_remove(&vm_page_queue_inactive, mem, vm_page_t,
808: pageq);
809: vm_page_inactive_count--;
810: mem->inactive = FALSE;
811: }
812: if (mem->free) {
813: queue_remove(&vm_page_queue_free, mem, vm_page_t,
814: pageq);
815: vm_page_free_count--;
816: mem->free = FALSE;
817: }
818: vm_page_wire_count++;
819: }
820: mem->wire_count++;
821: }
822:
823: /*
824: * vm_page_unwire:
825: *
826: * Release one wiring of this page, potentially
827: * enabling it to be paged again.
828: *
829: * The page queues must be locked.
830: */
831: void vm_page_unwire(mem)
832: register vm_page_t mem;
833: {
834: VM_PAGE_CHECK(mem);
835:
836: if (--mem->wire_count == 0) {
837: queue_enter(&vm_page_queue_active, mem, vm_page_t, pageq);
838: vm_page_active_count++;
839: mem->active = TRUE;
840: vm_page_wire_count--;
841: }
842: }
843:
844: /*
845: * _vm_page_deactivate:
846: *
847: * Internal routine to Returns the given page to the inactive list,
848: * Page is put at the head of the inactive list if age is TRUE.
849: * indicating that no physical maps have access
850: * to this page. [Used by the physical mapping system.]
851: *
852: * The page queues must be locked.
853: */
854: static void _vm_page_deactivate(m, age)
855: register vm_page_t m;
856: register boolean_t age;
857: {
858: VM_PAGE_CHECK(m);
859:
860: /*
861: * Only move active pages -- ignore locked or already
862: * inactive ones.
863: */
864:
865: if (m->active) {
866: pmap_clear_reference(VM_PAGE_TO_PHYS(m));
867: queue_remove(&vm_page_queue_active, m, vm_page_t, pageq);
868: if (age)
869: queue_enter_first(&vm_page_queue_inactive, m, vm_page_t, pageq);
870: else
871: queue_enter(&vm_page_queue_inactive, m, vm_page_t, pageq);
872: m->active = FALSE;
873: m->inactive = TRUE;
874: vm_page_active_count--;
875: vm_page_inactive_count++;
876: if (m->clean && pmap_is_modified(VM_PAGE_TO_PHYS(m)))
877: m->clean = FALSE;
878: m->laundry = !m->clean;
879: }
880: }
881:
882: /*
883: * vm_page_deactivate:
884: *
885: * Returns the given page to the inactive list,
886: * indicating that no physical maps have access
887: * to this page. [Used by the physical mapping system.]
888: *
889: * The page queues must be locked.
890: */
891: void vm_page_deactivate(m)
892: register vm_page_t m;
893: {
894: _vm_page_deactivate(m, FALSE);
895: }
896:
897: /*
898: * vm_page_deactivate_first:
899: *
900: * Returns the given page to the head of inactive list,
901: * indicating that no physical maps have access
902: * to this page. [Used by the physical mapping system.]
903: *
904: * The page queues must be locked.
905: */
906: void vm_page_deactivate_first(m)
907: register vm_page_t m;
908: {
909: _vm_page_deactivate(m, FALSE);
910: }
911:
912: /*
913: * vm_page_activate:
914: *
915: * Put the specified page on the active list (if appropriate).
916: *
917: * The page queues must be locked.
918: */
919:
920: void vm_page_activate(m)
921: register vm_page_t m;
922: {
923: VM_PAGE_CHECK(m);
924:
925:
926: if (m->inactive) {
927: queue_remove(&vm_page_queue_inactive, m, vm_page_t,
928: pageq);
929: vm_page_inactive_count--;
930: m->inactive = FALSE;
931: }
932: if (m->free) {
933: queue_remove(&vm_page_queue_free, m, vm_page_t,
934: pageq);
935: vm_page_free_count--;
936: m->free = FALSE;
937: }
938: if (m->wire_count == 0) {
939: if (m->active)
940: panic("vm_page_activate: already active");
941:
942: queue_enter(&vm_page_queue_active, m, vm_page_t, pageq);
943: m->active = TRUE;
944: vm_page_active_count++;
945: }
946: }
947:
948: /*
949: * vm_page_zero_fill:
950: *
951: * Zero-fill the specified page.
952: * Written as a standard pagein routine, to
953: * be used by the zero-fill object.
954: */
955:
956: boolean_t vm_page_zero_fill(m)
957: vm_page_t m;
958: {
959: VM_PAGE_CHECK(m);
960:
961: pmap_zero_page(VM_PAGE_TO_PHYS(m));
962: return(TRUE);
963: }
964:
965: /*
966: * vm_page_copy:
967: *
968: * Copy one page to another
969: */
970:
971: void vm_page_copy(src_m, dest_m)
972: vm_page_t src_m;
973: vm_page_t dest_m;
974: {
975: VM_PAGE_CHECK(src_m);
976: VM_PAGE_CHECK(dest_m);
977:
978: pmap_copy_page(VM_PAGE_TO_PHYS(src_m), VM_PAGE_TO_PHYS(dest_m));
979: }
980:
981:
982: /*
983: * vm_page_to_phys:
984: *
985: * return the physical page, this routine is here so that
986: * loadable drivers like macfs do not have to deref vm_page_t
987: * directly.
988: */
989:
990: vm_offset_t
991: vm_page_to_phys(m)
992: vm_page_t m;
993: {
994: return(VM_PAGE_TO_PHYS(m));
995: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.