![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vm_policy.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_policy.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: * Copyright (c) 1992 NeXT, Inc.
27: *
28: * History:
29: *
30: * 14-Dec-92: Brian Pinkerton at NeXT
31: * Created
32: */
33: #import <sys/types.h>
34: #import <sys/param.h>
35:
36: #import <mach/mach_types.h>
37: #import <mach/vm_param.h>
38: #import <mach/boolean.h>
39: #import <mach/kern_return.h>
40: #import <mach/vm_policy.h>
41:
42: #import <vm/vm_object.h>
43: #import <vm/vm_map.h>
44: #import <vm/vm_page.h>
45: #import <vm/vnode_pager.h>
46:
47: #import <kern/task.h>
48: #import <kern/kalloc.h>
49:
50:
51: /*
52: * Returns the given page to the HEAD of the free list,
53: * disassociating it with any VM object.
54: *
55: * Object and page must be locked prior to entry.
56: */
57: static void
58: vm_page_free_head(mem)
59: register vm_page_t mem;
60: {
61: vm_page_remove(mem);
62: if (mem->free)
63: return;
64:
65: if (mem->active) {
66: queue_remove(&vm_page_queue_active, mem, vm_page_t, pageq);
67: mem->active = FALSE;
68: vm_page_active_count--;
69: }
70:
71: if (mem->inactive) {
72: queue_remove(&vm_page_queue_inactive, mem, vm_page_t, pageq);
73: mem->inactive = FALSE;
74: vm_page_inactive_count--;
75: }
76:
77: if (!mem->fictitious) {
78: int spl;
79:
80: spl = splimp();
81: simple_lock(&vm_page_queue_free_lock);
82: queue_enter_first(&vm_page_queue_free, mem, vm_page_t, pageq);
83: mem->free = TRUE;
84: vm_page_free_count++;
85: simple_unlock(&vm_page_queue_free_lock);
86: splx(spl);
87: }
88: }
89:
90:
91: /*
92: * Do something with a particular page. This function is the locus for all
93: * policy decisions.
94: */
95: void
96: vm_policy_apply(vm_object_t object, vm_page_t m, int when)
97: {
98: boolean_t shared = FALSE;
99:
100: /*
101: * Determine whether an object is "shared". It is shared if it has
102: * more than two references, and it's backed by something that's not
103: * the swapfile.
104: *
105: * Note: this is a pretty bogus definition of shared. The ref count
106: * on the object could easily be high even if only one task has this
107: * object mapped. This is OK, though, because we're making a
108: * conservative decision. Someone can always turn on the shared
109: * flag if they want to be really aggressive.
110: */
111: if (object->ref_count > 2) {
112: if (object->pager && !object->pager->is_device) {
113: vnode_pager_t pager = (vnode_pager_t) object->pager;
114: shared = !pager->vs_swapfile;
115: }
116: }
117:
118: if (!(when & VM_DEACTIVATE_SHARED) && shared)
119: return;
120:
121: vm_page_lock_queues();
122:
123: switch (when) {
124: /*
125: * Make this page as cold as possible. That means that we
126: * try to free the page.
127: */
128: case VM_DEACTIVATE_NOW:
129: if (m->clean && !pmap_is_modified(VM_PAGE_TO_PHYS(m)))
130: vm_page_free_head(m);
131: else {
132: if (m->active)
133: vm_page_deactivate(m);
134: }
135: pmap_remove_all(VM_PAGE_TO_PHYS(m));
136: break;
137:
138: /*
139: * a little warmer.
140: */
141: case VM_DEACTIVATE_SOON:
142: if (m->active)
143: vm_page_deactivate(m);
144: break;
145: default:
146: break;
147: }
148:
149: vm_page_unlock_queues();
150: }
151:
152:
153: /*
154: * Deactivate active pages in this object and all shadow objects over the
155: * specified address range.
156: *
157: * If we encounter an error, we'll attempt to push the rest of the pages,
158: * and return an error for the whole object.
159: *
160: * If we encounter a locked page, then we'll skip it...
161: */
162: static void
163: deactivate_object(vm_object_t object, vm_offset_t start, vm_offset_t end, int temperature)
164: {
165: vm_object_t shadow;
166: vm_page_t page;
167: vm_size_t size;
168: int flags;
169:
170: if (object == VM_OBJECT_NULL)
171: return;
172:
173: vm_object_lock(object);
174:
175: for (page = (vm_page_t) queue_first(&object->memq);
176: !queue_end(&object->memq, (queue_entry_t) page);
177: page = (vm_page_t) queue_next(&page->listq))
178: {
179: /*
180: * If this page isn't actually referenced from this
181: * entry, then forget it.
182: */
183: if (page->offset < start || page->offset >= end)
184: continue;
185:
186: vm_policy_apply(object, page, temperature);
187: }
188:
189: /*
190: * Recurse over shadow objects.
191: */
192: size = end - start;
193: if ((object->size > 0) && (end - start > object->size))
194: size = object->size;
195: start += object->shadow_offset;
196: end = start + size;
197:
198: deactivate_object(object->shadow, start, end, temperature);
199:
200: vm_object_unlock(object);
201: thread_wakeup(object);
202: }
203:
204:
205: /*
206: * Push a range of pages in a map.
207: */
208: static void
209: deactivate_range(vm_map_t map, vm_offset_t start, vm_offset_t end, int temp)
210: {
211: vm_map_entry_t entry;
212: vm_object_t object;
213: vm_offset_t tend;
214: int offset;
215:
216: vm_map_lock_read(map);
217:
218: /*
219: * Push all the pages in this map.
220: */
221: for (entry = vm_map_first_entry(map);
222: entry != vm_map_to_entry(map);
223: entry = entry->vme_next)
224: {
225: /*
226: * Recurse over sub-maps.
227: */
228: if (entry->is_a_map || entry->is_sub_map) {
229: vm_map_t sub_map;
230: sub_map = entry->object.sub_map;
231: deactivate_range(sub_map, start, end, temp);
232: continue;
233: }
234: if (entry->vme_start > end || entry->vme_end <= start)
235: continue;
236:
237: /*
238: * Push the pages we can see in this object chain.
239: */
240: if (entry->vme_start > start)
241: start = entry->vme_start;
242:
243: if (entry->vme_end < end)
244: tend = entry->vme_end;
245: else
246: tend = end;
247:
248: object = entry->object.vm_object;
249: offset = entry->offset + start - entry->vme_start;
250: deactivate_object(object, offset, offset + tend - start, temp);
251: }
252: vm_map_unlock(map);
253: }
254:
255:
256: /*
257: * Push a range of pages in a map.
258: */
259: static void
260: set_policy(vm_map_t map, vm_offset_t start, vm_offset_t end, int policy)
261: {
262: vm_map_entry_t entry;
263: vm_object_t object;
264: vm_offset_t tend;
265: int offset;
266:
267: vm_map_lock_read(map);
268:
269: /*
270: * Push all the pages in this map.
271: */
272: for (entry = vm_map_first_entry(map);
273: entry != vm_map_to_entry(map);
274: entry = entry->vme_next)
275: {
276: /*
277: * Recurse over sub-maps.
278: */
279: if (entry->is_a_map || entry->is_sub_map) {
280: vm_map_t sub_map;
281: sub_map = entry->object.sub_map;
282: set_policy(sub_map, start, end, policy);
283: continue;
284: }
285: if (entry->vme_start > end || entry->vme_end <= start)
286: continue;
287:
288: /*
289: * Set the policy on the object
290: */
291: object = entry->object.vm_object;
292: while (object != VM_OBJECT_NULL) {
293: object->policy = policy;
294: object = object->shadow;
295: }
296: }
297: vm_map_unlock(map);
298: }
299:
300:
301: /*
302: * Set the policy on a range of pages. We'd really like to do this on a
303: * per-object basis... maybe this should only be applied to pagers?
304: */
305: kern_return_t
306: vm_set_policy(vm_map_t map, vm_address_t addr, vm_size_t size, int policy)
307: {
308: if (!map)
309: return KERN_FAILURE;
310:
311: if (size == 0)
312: size = map->max_offset - map->min_offset;
313:
314: if (addr == 0)
315: addr = map->min_offset;
316:
317: set_policy(map, addr, addr + size, policy);
318: return KERN_SUCCESS;
319: }
320:
321:
322: /*
323: * Fault a range of pages with a single disk transfer. Bypass all the normal
324: * vm_fault crap.
325: */
326: kern_return_t
327: vm_fault_range(vm_map_t map, vm_address_t addr, vm_size_t size)
328: {
329: return KERN_INVALID_ARGUMENT;
330: }
331:
332:
333: /*
334: * Deactivate a range of pages.
335: */
336: kern_return_t
337: vm_deactivate(vm_map_t map, vm_address_t addr, vm_size_t size, int temperature)
338: {
339: if (!map)
340: return KERN_FAILURE;
341:
342: if (size == 0)
343: size = map->max_offset - map->min_offset;
344:
345: if (addr == 0)
346: addr = map->min_offset;
347:
348: deactivate_range(map, addr, size, temperature);
349: return KERN_SUCCESS;
350: }
351:
352:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.