![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vm_user.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / osfmk / vm|
Return to vm_user.c CVS log | Up to [Apple XNU] / XNU / osfmk / vm |
1.1 root 1: /*
2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /*
23: * @OSF_COPYRIGHT@
24: */
25: /*
26: * Mach Operating System
27: * Copyright (c) 1991,1990,1989,1988 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: */
52: /*
53: * File: vm/vm_user.c
54: * Author: Avadis Tevanian, Jr., Michael Wayne Young
55: *
56: * User-exported virtual memory functions.
57: */
58: #ifdef MACH_BSD
59: /* remove after component interface available */
60: extern int vnode_pager_workaround;
61: #endif
62:
63: #include <vm_cpm.h>
64: #include <mach/boolean.h>
65: #include <mach/kern_return.h>
66: #include <mach/mach_types.h> /* to get vm_address_t */
67: #include <mach/memory_object.h>
68: #include <mach/std_types.h> /* to get pointer_t */
69: #include <mach/vm_attributes.h>
70: #include <mach/vm_param.h>
71: #include <mach/vm_statistics.h>
72: #include <mach/vm_task_server.h>
73: #include <mach/mach_syscalls.h>
74: #include <mach/shared_memory_server.h>
75:
76: #include <kern/host.h>
77: #include <kern/task.h>
78: #include <kern/misc_protos.h>
79: #include <vm/vm_map.h>
80: #include <vm/vm_object.h>
81: #include <vm/vm_page.h>
82: #include <vm/memory_object.h>
83: #include <vm/vm_pageout.h>
84:
85:
86:
87: vm_size_t upl_offset_to_pagelist = 0;
88:
89: #if VM_CPM
90: #include <vm/cpm.h>
91: #endif /* VM_CPM */
92:
93: ipc_port_t dynamic_pager_control_port=NULL;
94:
95: /*
96: * vm_allocate allocates "zero fill" memory in the specfied
97: * map.
98: */
99: kern_return_t
100: vm_allocate(
101: register vm_map_t map,
102: register vm_offset_t *addr,
103: register vm_size_t size,
104: int flags)
105: {
106: kern_return_t result;
107: boolean_t anywhere = VM_FLAGS_ANYWHERE & flags;
108:
109: if (map == VM_MAP_NULL)
110: return(KERN_INVALID_ARGUMENT);
111: if (size == 0) {
112: *addr = 0;
113: return(KERN_SUCCESS);
114: }
115:
116: if (anywhere)
117: *addr = vm_map_min(map);
118: else
119: *addr = trunc_page(*addr);
120: size = round_page(size);
121:
122: result = vm_map_enter(
123: map,
124: addr,
125: size,
126: (vm_offset_t)0,
127: flags,
128: VM_OBJECT_NULL,
129: (vm_offset_t)0,
130: FALSE,
131: VM_PROT_DEFAULT,
132: VM_PROT_ALL,
133: VM_INHERIT_DEFAULT);
134:
135: return(result);
136: }
137:
138: /*
139: * vm_deallocate deallocates the specified range of addresses in the
140: * specified address map.
141: */
142: kern_return_t
143: vm_deallocate(
144: register vm_map_t map,
145: vm_offset_t start,
146: vm_size_t size)
147: {
148: if (map == VM_MAP_NULL)
149: return(KERN_INVALID_ARGUMENT);
150:
151: if (size == (vm_offset_t) 0)
152: return(KERN_SUCCESS);
153:
154: return(vm_map_remove(map, trunc_page(start),
155: round_page(start+size), VM_MAP_NO_FLAGS));
156: }
157:
158: /*
159: * vm_inherit sets the inheritance of the specified range in the
160: * specified map.
161: */
162: kern_return_t
163: vm_inherit(
164: register vm_map_t map,
165: vm_offset_t start,
166: vm_size_t size,
167: vm_inherit_t new_inheritance)
168: {
169: if (map == VM_MAP_NULL)
170: return(KERN_INVALID_ARGUMENT);
171:
172: if (new_inheritance > VM_INHERIT_LAST_VALID)
173: return(KERN_INVALID_ARGUMENT);
174:
175: return(vm_map_inherit(map,
176: trunc_page(start),
177: round_page(start+size),
178: new_inheritance));
179: }
180:
181: /*
182: * vm_protect sets the protection of the specified range in the
183: * specified map.
184: */
185:
186: kern_return_t
187: vm_protect(
188: register vm_map_t map,
189: vm_offset_t start,
190: vm_size_t size,
191: boolean_t set_maximum,
192: vm_prot_t new_protection)
193: {
194: if ((map == VM_MAP_NULL) || (new_protection & ~VM_PROT_ALL))
195: return(KERN_INVALID_ARGUMENT);
196:
197: return(vm_map_protect(map,
198: trunc_page(start),
199: round_page(start+size),
200: new_protection,
201: set_maximum));
202: }
203:
204: /*
205: * Handle machine-specific attributes for a mapping, such
206: * as cachability, migrability, etc.
207: */
208: kern_return_t
209: vm_machine_attribute(
210: vm_map_t map,
211: vm_address_t address,
212: vm_size_t size,
213: vm_machine_attribute_t attribute,
214: vm_machine_attribute_val_t* value) /* IN/OUT */
215: {
216: if (map == VM_MAP_NULL)
217: return(KERN_INVALID_ARGUMENT);
218:
219: return vm_map_machine_attribute(map, address, size, attribute, value);
220: }
221:
222: kern_return_t
223: vm_read(
224: vm_map_t map,
225: vm_address_t address,
226: vm_size_t size,
227: pointer_t *data,
228: mach_msg_type_number_t *data_size)
229: {
230: kern_return_t error;
231: vm_map_copy_t ipc_address;
232:
233: if (map == VM_MAP_NULL)
234: return(KERN_INVALID_ARGUMENT);
235:
236: if ((error = vm_map_copyin(map,
237: address,
238: size,
239: FALSE, /* src_destroy */
240: &ipc_address)) == KERN_SUCCESS) {
241: *data = (pointer_t) ipc_address;
242: *data_size = size;
243: }
244: return(error);
245: }
246:
247: kern_return_t
248: vm_read_list(
249: vm_map_t map,
250: vm_read_entry_t data_list,
251: mach_msg_type_number_t count)
252: {
253: mach_msg_type_number_t i;
254: kern_return_t error;
255: vm_map_copy_t ipc_address;
256:
257: if (map == VM_MAP_NULL)
258: return(KERN_INVALID_ARGUMENT);
259:
260: for(i=0; i<count; i++) {
261: error = vm_map_copyin(map,
262: data_list[i].address,
263: data_list[i].size,
264: FALSE, /* src_destroy */
265: &ipc_address);
266: if(error != KERN_SUCCESS) {
267: data_list[i].address = (vm_address_t)0;
268: data_list[i].size = (vm_size_t)0;
269: break;
270: }
271: if(data_list[i].size != 0) {
272: error = vm_map_copyout(current_task()->map,
273: &(data_list[i].address),
274: (vm_map_copy_t) ipc_address);
275: if(error != KERN_SUCCESS) {
276: data_list[i].address = (vm_address_t)0;
277: data_list[i].size = (vm_size_t)0;
278: break;
279: }
280: }
281: }
282: return(error);
283: }
284:
285: /*
286: * This routine reads from the specified map and overwrites part of the current
287: * activation's map. In making an assumption that the current thread is local,
288: * it is no longer cluster-safe without a fully supportive local proxy thread/
289: * task (but we don't support cluster's anymore so this is moot).
290: */
291:
292: #define VM_OVERWRITE_SMALL 512
293:
294: kern_return_t
295: vm_read_overwrite(
296: vm_map_t map,
297: vm_address_t address,
298: vm_size_t size,
299: vm_address_t data,
300: vm_size_t *data_size)
301: {
302: struct {
303: long align;
304: char buf[VM_OVERWRITE_SMALL];
305: } inbuf;
306: vm_map_t oldmap;
307: kern_return_t error = KERN_SUCCESS;
308: vm_map_copy_t copy;
309:
310: if (map == VM_MAP_NULL)
311: return(KERN_INVALID_ARGUMENT);
312:
313: if (size <= VM_OVERWRITE_SMALL) {
314: if(vm_map_read_user(map, (vm_offset_t)address,
315: (vm_offset_t)&inbuf, size)) {
316: error = KERN_INVALID_ADDRESS;
317: } else {
318: if(vm_map_write_user(current_map(),
319: (vm_offset_t)&inbuf, (vm_offset_t)data, size))
320: error = KERN_INVALID_ADDRESS;
321: }
322: }
323: else {
324: if ((error = vm_map_copyin(map,
325: address,
326: size,
327: FALSE, /* src_destroy */
328: ©)) == KERN_SUCCESS) {
329: if ((error = vm_map_copy_overwrite(
330: current_act()->map,
331: data,
332: copy,
333: FALSE)) == KERN_SUCCESS) {
334: }
335: else {
336: vm_map_copy_discard(copy);
337: }
338: }
339: }
340: *data_size = size;
341: return(error);
342: }
343:
344:
345:
346:
347: /*ARGSUSED*/
348: kern_return_t
349: vm_write(
350: vm_map_t map,
351: vm_address_t address,
352: vm_offset_t data,
353: mach_msg_type_number_t size)
354: {
355: if (map == VM_MAP_NULL)
356: return KERN_INVALID_ARGUMENT;
357:
358: return vm_map_copy_overwrite(map, address, (vm_map_copy_t) data,
359: FALSE /* interruptible XXX */);
360: }
361:
362: kern_return_t
363: vm_copy(
364: vm_map_t map,
365: vm_address_t source_address,
366: vm_size_t size,
367: vm_address_t dest_address)
368: {
369: vm_map_copy_t copy;
370: kern_return_t kr;
371:
372: if (map == VM_MAP_NULL)
373: return KERN_INVALID_ARGUMENT;
374:
375: kr = vm_map_copyin(map, source_address, size,
376: FALSE, ©);
377: if (kr != KERN_SUCCESS)
378: return kr;
379:
380: kr = vm_map_copy_overwrite(map, dest_address, copy,
381: FALSE /* interruptible XXX */);
382: if (kr != KERN_SUCCESS) {
383: vm_map_copy_discard(copy);
384: return kr;
385: }
386:
387: return KERN_SUCCESS;
388: }
389:
390: /*
391: * Routine: vm_map
392: */
393: kern_return_t
394: vm_map(
395: vm_map_t target_map,
396: vm_offset_t *address,
397: vm_size_t size,
398: vm_offset_t mask,
399: int flags,
400: ipc_port_t port,
401: vm_offset_t offset,
402: boolean_t copy,
403: vm_prot_t cur_protection,
404: vm_prot_t max_protection,
405: vm_inherit_t inheritance)
406: {
407: register
408: vm_object_t object;
409: vm_prot_t prot;
410: kern_return_t result;
411:
412: /*
413: * Check arguments for validity
414: */
415: if ((target_map == VM_MAP_NULL) ||
416: (cur_protection & ~VM_PROT_ALL) ||
417: (max_protection & ~VM_PROT_ALL) ||
418: (inheritance > VM_INHERIT_LAST_VALID) ||
419: size == 0)
420: return(KERN_INVALID_ARGUMENT);
421:
422: /*
423: * Find the vm object (if any) corresponding to this port.
424: */
425: if (!IP_VALID(port)) {
426: object = VM_OBJECT_NULL;
427: offset = 0;
428: copy = FALSE;
429: } else if (ip_kotype(port) == IKOT_NAMED_ENTRY) {
430: vm_named_entry_t named_entry;
431:
432: named_entry = (vm_named_entry_t)port->ip_kobject;
433: /* a few checks to make sure user is obeying rules */
434: if(size == 0)
435: size = named_entry->size;
436: if((named_entry->protection & max_protection) != max_protection)
437: return(KERN_INVALID_RIGHT);
438: if((named_entry->protection & cur_protection) != cur_protection)
439: return(KERN_INVALID_RIGHT);
440: if(named_entry->size < (offset + size))
441: return(KERN_INVALID_ARGUMENT);
442:
443: /* the callers parameter offset is defined to be the */
444: /* offset from beginning of named entry offset in object */
445: offset = offset + named_entry->offset;
446:
447: named_entry_lock(named_entry);
448: if(named_entry->is_sub_map) {
449: vm_map_entry_t map_entry;
450:
451: named_entry_unlock(named_entry);
452: *address = trunc_page(*address);
453: size = round_page(size);
454: vm_object_reference(vm_submap_object);
455: if ((result = vm_map_enter(target_map,
456: address, size, mask, flags,
457: vm_submap_object, 0,
458: FALSE,
459: cur_protection, max_protection, inheritance
460: )) != KERN_SUCCESS) {
461: vm_object_deallocate(vm_submap_object);
462: } else {
463: vm_map_submap(target_map, *address,
464: (*address) + size,
465: named_entry->backing.map,
466: offset);
467: if(copy) {
468: if(vm_map_lookup_entry(
469: target_map, *address, &map_entry)) {
470: map_entry->needs_copy = TRUE;
471: }
472: }
473: }
474: return(result);
475:
476: } else if(named_entry->object) {
477: /* This is the case where we are going to map */
478: /* an already mapped object. If the object is */
479: /* not ready it is internal. An external */
480: /* object cannot be mapped until it is ready */
481: /* we can therefore avoid the ready check */
482: /* in this case. */
483: copy = FALSE;
484: named_entry_unlock(named_entry);
485: vm_object_reference(named_entry->object);
486: object = named_entry->object;
487: } else {
488: object = vm_object_enter(named_entry->backing.pager,
489: named_entry->size,
490: named_entry->internal,
491: FALSE);
492: if (object == VM_OBJECT_NULL) {
493: named_entry_unlock(named_entry);
494: return(KERN_INVALID_OBJECT);
495: }
496: named_entry->object = object;
497: named_entry_unlock(named_entry);
498: /* create an extra reference for the named entry */
499: vm_object_reference(named_entry->object);
500: /* wait for object (if any) to be ready */
501: if (object != VM_OBJECT_NULL) {
502: vm_object_lock(object);
503: while (!object->pager_ready) {
504: vm_object_wait(object,
505: VM_OBJECT_EVENT_PAGER_READY,
506: THREAD_UNINT);
507: vm_object_lock(object);
508: }
509: vm_object_unlock(object);
510: }
511: }
512: } else {
513: if ((object = vm_object_enter(port, size, FALSE, FALSE))
514: == VM_OBJECT_NULL)
515: return(KERN_INVALID_OBJECT);
516:
517: /* wait for object (if any) to be ready */
518: if (object != VM_OBJECT_NULL) {
519: vm_object_lock(object);
520: while (!object->pager_ready) {
521: vm_object_wait(object,
522: VM_OBJECT_EVENT_PAGER_READY,
523: THREAD_UNINT);
524: vm_object_lock(object);
525: }
526: vm_object_unlock(object);
527: }
528: }
529:
530: *address = trunc_page(*address);
531: size = round_page(size);
532:
533: /*
534: * Perform the copy if requested
535: */
536:
537: if (copy) {
538: vm_object_t new_object;
539: vm_offset_t new_offset;
540:
541: result = vm_object_copy_strategically(object, offset, size,
542: &new_object, &new_offset,
543: ©);
544:
545:
546: if (result == KERN_MEMORY_RESTART_COPY) {
547: boolean_t success;
548: boolean_t src_needs_copy;
549:
550: /*
551: * XXX
552: * We currently ignore src_needs_copy.
553: * This really is the issue of how to make
554: * MEMORY_OBJECT_COPY_SYMMETRIC safe for
555: * non-kernel users to use. Solution forthcoming.
556: * In the meantime, since we don't allow non-kernel
557: * memory managers to specify symmetric copy,
558: * we won't run into problems here.
559: */
560: new_object = object;
561: new_offset = offset;
562: success = vm_object_copy_quickly(&new_object,
563: new_offset, size,
564: &src_needs_copy,
565: ©);
566: assert(success);
567: result = KERN_SUCCESS;
568: }
569: /*
570: * Throw away the reference to the
571: * original object, as it won't be mapped.
572: */
573:
574: vm_object_deallocate(object);
575:
576: if (result != KERN_SUCCESS)
577: return (result);
578:
579: object = new_object;
580: offset = new_offset;
581: }
582:
583: if ((result = vm_map_enter(target_map,
584: address, size, mask, flags,
585: object, offset,
586: copy,
587: cur_protection, max_protection, inheritance
588: )) != KERN_SUCCESS)
589: vm_object_deallocate(object);
590: return(result);
591: }
592:
593:
594: /*
595: * NOTE: this routine (and this file) will no longer require mach_host_server.h
596: * when vm_wire is changed to use ledgers.
597: */
598: #include <mach/mach_host_server.h>
599: /*
600: * Specify that the range of the virtual address space
601: * of the target task must not cause page faults for
602: * the indicated accesses.
603: *
604: * [ To unwire the pages, specify VM_PROT_NONE. ]
605: */
606: kern_return_t
607: vm_wire(
608: host_t host,
609: register vm_map_t map,
610: vm_offset_t start,
611: vm_size_t size,
612: vm_prot_t access)
613: {
614: kern_return_t rc;
615:
616: if (host == HOST_NULL)
617: return KERN_INVALID_HOST;
618:
619: if (map == VM_MAP_NULL)
620: return KERN_INVALID_TASK;
621:
622: if (access & ~VM_PROT_ALL)
623: return KERN_INVALID_ARGUMENT;
624:
625: if (access != VM_PROT_NONE) {
626: rc = vm_map_wire(map, trunc_page(start),
627: round_page(start+size), access, TRUE);
628: } else {
629: rc = vm_map_unwire(map, trunc_page(start),
630: round_page(start+size), TRUE);
631: }
632: return rc;
633: }
634:
635: /*
636: * vm_msync
637: *
638: * Synchronises the memory range specified with its backing store
639: * image by either flushing or cleaning the contents to the appropriate
640: * memory manager engaging in a memory object synchronize dialog with
641: * the manager. The client doesn't return until the manager issues
642: * m_o_s_completed message. MIG Magically converts user task parameter
643: * to the task's address map.
644: *
645: * interpretation of sync_flags
646: * VM_SYNC_INVALIDATE - discard pages, only return precious
647: * pages to manager.
648: *
649: * VM_SYNC_INVALIDATE & (VM_SYNC_SYNCHRONOUS | VM_SYNC_ASYNCHRONOUS)
650: * - discard pages, write dirty or precious
651: * pages back to memory manager.
652: *
653: * VM_SYNC_SYNCHRONOUS | VM_SYNC_ASYNCHRONOUS
654: * - write dirty or precious pages back to
655: * the memory manager.
656: *
657: * NOTE
658: * The memory object attributes have not yet been implemented, this
659: * function will have to deal with the invalidate attribute
660: *
661: * RETURNS
662: * KERN_INVALID_TASK Bad task parameter
663: * KERN_INVALID_ARGUMENT both sync and async were specified.
664: * KERN_SUCCESS The usual.
665: */
666:
667: kern_return_t
668: vm_msync(
669: vm_map_t map,
670: vm_address_t address,
671: vm_size_t size,
672: vm_sync_t sync_flags)
673: {
674: msync_req_t msr;
675: msync_req_t new_msr;
676: queue_chain_t req_q; /* queue of requests for this msync */
677: vm_map_entry_t entry;
678: vm_size_t amount_left;
679: vm_offset_t offset;
680: boolean_t do_sync_req;
681: boolean_t modifiable;
682:
683:
684: if ((sync_flags & VM_SYNC_ASYNCHRONOUS) &&
685: (sync_flags & VM_SYNC_SYNCHRONOUS))
686: return(KERN_INVALID_ARGUMENT);
687:
688: /*
689: * align address and size on page boundaries
690: */
691: size = round_page(address + size) - trunc_page(address);
692: address = trunc_page(address);
693:
694: if (map == VM_MAP_NULL)
695: return(KERN_INVALID_TASK);
696:
697: if (size == 0)
698: return(KERN_SUCCESS);
699:
700: queue_init(&req_q);
701: amount_left = size;
702:
703: while (amount_left > 0) {
704: vm_size_t flush_size;
705: vm_object_t object;
706:
707: vm_map_lock(map);
708: if (!vm_map_lookup_entry(map, address, &entry)) {
709: vm_size_t skip;
710:
711: /*
712: * hole in the address map.
713: */
714:
715: /*
716: * Check for empty map.
717: */
718: if (entry == vm_map_to_entry(map) &&
719: entry->vme_next == entry) {
720: vm_map_unlock(map);
721: break;
722: }
723: /*
724: * Check that we don't wrap and that
725: * we have at least one real map entry.
726: */
727: if ((map->hdr.nentries == 0) ||
728: (entry->vme_next->vme_start < address)) {
729: vm_map_unlock(map);
730: break;
731: }
732: /*
733: * Move up to the next entry if needed
734: */
735: skip = (entry->vme_next->vme_start - address);
736: if (skip >= amount_left)
737: amount_left = 0;
738: else
739: amount_left -= skip;
740: address = entry->vme_next->vme_start;
741: vm_map_unlock(map);
742: continue;
743: }
744:
745: offset = address - entry->vme_start;
746:
747: /*
748: * do we have more to flush than is contained in this
749: * entry ?
750: */
751: if (amount_left + entry->vme_start + offset > entry->vme_end) {
752: flush_size = entry->vme_end -
753: (entry->vme_start + offset);
754: } else {
755: flush_size = amount_left;
756: }
757: amount_left -= flush_size;
758: address += flush_size;
759:
760: object = entry->object.vm_object;
761:
762: /*
763: * We can't sync this object if the object has not been
764: * created yet
765: */
766: if (object == VM_OBJECT_NULL) {
767: vm_map_unlock(map);
768: continue;
769: }
770: offset += entry->offset;
771: modifiable = (entry->protection & VM_PROT_WRITE)
772: != VM_PROT_NONE;
773:
774: vm_object_lock(object);
775:
776: if (sync_flags & VM_SYNC_KILLPAGES) {
777: if (object->ref_count == 1 && !object->shadow && !entry->needs_copy)
778: memory_object_kill_pages(object, offset, flush_size);
779:
780: vm_object_unlock(object);
781: vm_map_unlock(map);
782: continue;
783: }
784: /*
785: * We can't sync this object if there isn't a pager.
786: * Don't bother to sync internal objects, since there can't
787: * be any "permanent" storage for these objects anyway.
788: */
789: if ((object->pager == IP_NULL) || (object->internal) ||
790: (object->private)) {
791: vm_object_unlock(object);
792: vm_map_unlock(map);
793: continue;
794: }
795: /*
796: * keep reference on the object until syncing is done
797: */
798: assert(object->ref_count > 0);
799: object->ref_count++;
800: vm_object_res_reference(object);
801: vm_object_unlock(object);
802:
803: vm_map_unlock(map);
804:
805: do_sync_req = memory_object_sync(object,
806: offset,
807: flush_size,
808: sync_flags & VM_SYNC_INVALIDATE,
809: (modifiable &&
810: (sync_flags & VM_SYNC_SYNCHRONOUS ||
811: sync_flags & VM_SYNC_ASYNCHRONOUS)));
812:
813: /*
814: * only send a m_o_s if we returned pages or if the entry
815: * is writable (ie dirty pages may have already been sent back)
816: */
817: if (!do_sync_req && !modifiable) {
818: vm_object_deallocate(object);
819: continue;
820: }
821: msync_req_alloc(new_msr);
822:
823: vm_object_lock(object);
824: offset += object->paging_offset;
825:
826: new_msr->offset = offset;
827: new_msr->length = flush_size;
828: new_msr->object = object;
829: new_msr->flag = VM_MSYNC_SYNCHRONIZING;
830: re_iterate:
831: queue_iterate(&object->msr_q, msr, msync_req_t, msr_q) {
832: /*
833: * need to check for overlapping entry, if found, wait
834: * on overlapping msr to be done, then reiterate
835: */
836: msr_lock(msr);
837: if (msr->flag == VM_MSYNC_SYNCHRONIZING &&
838: ((offset >= msr->offset &&
839: offset < (msr->offset + msr->length)) ||
840: (msr->offset >= offset &&
841: msr->offset < (offset + flush_size))))
842: {
843: assert_wait((event_t) msr,THREAD_INTERRUPTIBLE);
844: msr_unlock(msr);
845: vm_object_unlock(object);
846: thread_block((void (*)(void))0);
847: if (current_act()->handlers)
848: act_execute_returnhandlers();
849: vm_object_lock(object);
850: goto re_iterate;
851: }
852: msr_unlock(msr);
853: }/* queue_iterate */
854:
855: queue_enter(&object->msr_q, new_msr, msync_req_t, msr_q);
856: vm_object_unlock(object);
857:
858: queue_enter(&req_q, new_msr, msync_req_t, req_q);
859:
860: #ifdef MACH_BSD
861: if(((rpc_subsystem_t)pager_mux_hash_lookup(object->pager)) ==
862: ((rpc_subsystem_t) &vnode_pager_workaround)) {
863: (void) vnode_pager_synchronize(
864: object->pager,
865: object->pager_request,
866: offset,
867: flush_size,
868: sync_flags);
869: } else {
870: (void) memory_object_synchronize(
871: object->pager,
872: object->pager_request,
873: offset,
874: flush_size,
875: sync_flags);
876: }
877: #else
878: (void) memory_object_synchronize(
879: object->pager,
880: object->pager_request,
881: offset,
882: flush_size,
883: sync_flags);
884: #endif
885: }/* while */
886:
887: /*
888: * wait for memory_object_sychronize_completed messages from pager(s)
889: */
890:
891: while (!queue_empty(&req_q)) {
892: msr = (msync_req_t)queue_first(&req_q);
893: msr_lock(msr);
894: while(msr->flag != VM_MSYNC_DONE) {
895: assert_wait((event_t) msr, THREAD_INTERRUPTIBLE);
896: msr_unlock(msr);
897: thread_block((void (*)(void))0);
898: if (current_act()->handlers)
899: act_execute_returnhandlers();
900: msr_lock(msr);
901: }/* while */
902: queue_remove(&req_q, msr, msync_req_t, req_q);
903: msr_unlock(msr);
904: vm_object_deallocate(msr->object);
905: msync_req_free(msr);
906: }/* queue_iterate */
907:
908: return(KERN_SUCCESS);
909: }/* vm_msync */
910:
911:
912: /*
913: * task_wire
914: *
915: * Set or clear the map's wiring_required flag. This flag, if set,
916: * will cause all future virtual memory allocation to allocate
917: * user wired memory. Unwiring pages wired down as a result of
918: * this routine is done with the vm_wire interface.
919: */
920: kern_return_t
921: task_wire(
922: vm_map_t map,
923: boolean_t must_wire)
924: {
925: if (map == VM_MAP_NULL)
926: return(KERN_INVALID_ARGUMENT);
927:
928: if (must_wire)
929: map->wiring_required = TRUE;
930: else
931: map->wiring_required = FALSE;
932:
933: return(KERN_SUCCESS);
934: }
935:
936: /*
937: * vm_behavior_set sets the paging behavior attribute for the
938: * specified range in the specified map. This routine will fail
939: * with KERN_INVALID_ADDRESS if any address in [start,start+size)
940: * is not a valid allocated or reserved memory region.
941: */
942: kern_return_t
943: vm_behavior_set(
944: vm_map_t map,
945: vm_offset_t start,
946: vm_size_t size,
947: vm_behavior_t new_behavior)
948: {
949: if (map == VM_MAP_NULL)
950: return(KERN_INVALID_ARGUMENT);
951:
952: return(vm_map_behavior_set(map, trunc_page(start),
953: round_page(start+size), new_behavior));
954: }
955:
956: #if VM_CPM
957: /*
958: * Control whether the kernel will permit use of
959: * vm_allocate_cpm at all.
960: */
961: unsigned int vm_allocate_cpm_enabled = 1;
962:
963: /*
964: * Ordinarily, the right to allocate CPM is restricted
965: * to privileged applications (those that can gain access
966: * to the host port). Set this variable to zero if you
967: * want to let any application allocate CPM.
968: */
969: unsigned int vm_allocate_cpm_privileged = 0;
970:
971: /*
972: * Allocate memory in the specified map, with the caveat that
973: * the memory is physically contiguous. This call may fail
974: * if the system can't find sufficient contiguous memory.
975: * This call may cause or lead to heart-stopping amounts of
976: * paging activity.
977: *
978: * Memory obtained from this call should be freed in the
979: * normal way, viz., via vm_deallocate.
980: */
981: kern_return_t
982: vm_allocate_cpm(
983: host_t host,
984: register vm_map_t map,
985: register vm_offset_t *addr,
986: register vm_size_t size,
987: int flags)
988: {
989: vm_object_t cpm_obj;
990: pmap_t pmap;
991: vm_page_t m, pages;
992: kern_return_t kr;
993: vm_offset_t va, start, end, offset;
994: #if MACH_ASSERT
995: extern vm_offset_t avail_start, avail_end;
996: vm_offset_t prev_addr;
997: #endif /* MACH_ASSERT */
998:
999: boolean_t anywhere = VM_FLAGS_ANYWHERE & flags;
1000:
1001: if (!vm_allocate_cpm_enabled)
1002: return KERN_FAILURE;
1003:
1004: if (vm_allocate_cpm_privileged && host == HOST_NULL)
1005: return KERN_INVALID_HOST;
1006:
1007: if (map == VM_MAP_NULL)
1008: return KERN_INVALID_ARGUMENT;
1009:
1010: if (size == 0) {
1011: *addr = 0;
1012: return KERN_SUCCESS;
1013: }
1014:
1015: if (anywhere)
1016: *addr = vm_map_min(map);
1017: else
1018: *addr = trunc_page(*addr);
1019: size = round_page(size);
1020:
1021: if ((kr = cpm_allocate(size, &pages, TRUE)) != KERN_SUCCESS)
1022: return kr;
1023:
1024: cpm_obj = vm_object_allocate(size);
1025: assert(cpm_obj != VM_OBJECT_NULL);
1026: assert(cpm_obj->internal);
1027: assert(cpm_obj->size == size);
1028: assert(cpm_obj->can_persist == FALSE);
1029: assert(cpm_obj->pager_created == FALSE);
1030: assert(cpm_obj->pageout == FALSE);
1031: assert(cpm_obj->shadow == VM_OBJECT_NULL);
1032:
1033: /*
1034: * Insert pages into object.
1035: */
1036:
1037: vm_object_lock(cpm_obj);
1038: for (offset = 0; offset < size; offset += PAGE_SIZE) {
1039: m = pages;
1040: pages = NEXT_PAGE(m);
1041:
1042: assert(!m->gobbled);
1043: assert(!m->wanted);
1044: assert(!m->pageout);
1045: assert(!m->tabled);
1046: assert(m->busy);
1047: assert(m->phys_addr>=avail_start && m->phys_addr<=avail_end);
1048:
1049: m->busy = FALSE;
1050: vm_page_insert(m, cpm_obj, offset);
1051: }
1052: assert(cpm_obj->resident_page_count == size / PAGE_SIZE);
1053: vm_object_unlock(cpm_obj);
1054:
1055: /*
1056: * Hang onto a reference on the object in case a
1057: * multi-threaded application for some reason decides
1058: * to deallocate the portion of the address space into
1059: * which we will insert this object.
1060: *
1061: * Unfortunately, we must insert the object now before
1062: * we can talk to the pmap module about which addresses
1063: * must be wired down. Hence, the race with a multi-
1064: * threaded app.
1065: */
1066: vm_object_reference(cpm_obj);
1067:
1068: /*
1069: * Insert object into map.
1070: */
1071:
1072: kr = vm_map_enter(
1073: map,
1074: addr,
1075: size,
1076: (vm_offset_t)0,
1077: flags,
1078: cpm_obj,
1079: (vm_offset_t)0,
1080: FALSE,
1081: VM_PROT_ALL,
1082: VM_PROT_ALL,
1083: VM_INHERIT_DEFAULT);
1084:
1085: if (kr != KERN_SUCCESS) {
1086: /*
1087: * A CPM object doesn't have can_persist set,
1088: * so all we have to do is deallocate it to
1089: * free up these pages.
1090: */
1091: assert(cpm_obj->pager_created == FALSE);
1092: assert(cpm_obj->can_persist == FALSE);
1093: assert(cpm_obj->pageout == FALSE);
1094: assert(cpm_obj->shadow == VM_OBJECT_NULL);
1095: vm_object_deallocate(cpm_obj); /* kill acquired ref */
1096: vm_object_deallocate(cpm_obj); /* kill creation ref */
1097: }
1098:
1099: /*
1100: * Inform the physical mapping system that the
1101: * range of addresses may not fault, so that
1102: * page tables and such can be locked down as well.
1103: */
1104: start = *addr;
1105: end = start + size;
1106: pmap = vm_map_pmap(map);
1107: pmap_pageable(pmap, start, end, FALSE);
1108:
1109: /*
1110: * Enter each page into the pmap, to avoid faults.
1111: * Note that this loop could be coded more efficiently,
1112: * if the need arose, rather than looking up each page
1113: * again.
1114: */
1115: for (offset = 0, va = start; offset < size;
1116: va += PAGE_SIZE, offset += PAGE_SIZE) {
1117: vm_object_lock(cpm_obj);
1118: m = vm_page_lookup(cpm_obj, offset);
1119: vm_object_unlock(cpm_obj);
1120: assert(m != VM_PAGE_NULL);
1121: PMAP_ENTER(pmap, va, m, VM_PROT_ALL, TRUE);
1122: }
1123:
1124: #if MACH_ASSERT
1125: /*
1126: * Verify ordering in address space.
1127: */
1128: for (offset = 0; offset < size; offset += PAGE_SIZE) {
1129: vm_object_lock(cpm_obj);
1130: m = vm_page_lookup(cpm_obj, offset);
1131: vm_object_unlock(cpm_obj);
1132: if (m == VM_PAGE_NULL)
1133: panic("vm_allocate_cpm: obj 0x%x off 0x%x no page",
1134: cpm_obj, offset);
1135: assert(m->tabled);
1136: assert(!m->busy);
1137: assert(!m->wanted);
1138: assert(!m->fictitious);
1139: assert(!m->private);
1140: assert(!m->absent);
1141: assert(!m->error);
1142: assert(!m->cleaning);
1143: assert(!m->precious);
1144: assert(!m->clustered);
1145: if (offset != 0) {
1146: if (m->phys_addr != prev_addr + PAGE_SIZE) {
1147: printf("start 0x%x end 0x%x va 0x%x\n",
1148: start, end, va);
1149: printf("obj 0x%x off 0x%x\n", cpm_obj, offset);
1150: printf("m 0x%x prev_address 0x%x\n", m,
1151: prev_addr);
1152: panic("vm_allocate_cpm: pages not contig!");
1153: }
1154: }
1155: prev_addr = m->phys_addr;
1156: }
1157: #endif /* MACH_ASSERT */
1158:
1159: vm_object_deallocate(cpm_obj); /* kill extra ref */
1160:
1161: return kr;
1162: }
1163:
1164:
1165: #else /* VM_CPM */
1166:
1167: /*
1168: * Interface is defined in all cases, but unless the kernel
1169: * is built explicitly for this option, the interface does
1170: * nothing.
1171: */
1172:
1173: kern_return_t
1174: vm_allocate_cpm(
1175: host_t host,
1176: register vm_map_t map,
1177: register vm_offset_t *addr,
1178: register vm_size_t size,
1179: int flags)
1180: {
1181: return KERN_FAILURE;
1182: }
1183:
1184: /*
1185: */
1186: kern_return_t
1187: mach_memory_object_memory_entry(
1188: host_t host,
1189: boolean_t internal,
1190: vm_size_t size,
1191: vm_prot_t permission,
1192: ipc_port_t pager,
1193: ipc_port_t *entry_handle)
1194: {
1195: vm_named_entry_t user_object;
1196: ipc_port_t user_handle;
1197: ipc_port_t previous;
1198: kern_return_t kr;
1199:
1200: if (host == HOST_NULL)
1201: return(KERN_INVALID_HOST);
1202:
1203: user_object = (vm_named_entry_t)
1204: kalloc(sizeof (struct vm_named_entry));
1205: if(user_object == NULL)
1206: return KERN_FAILURE;
1207: named_entry_lock_init(user_object);
1208: user_handle = ipc_port_alloc_kernel();
1209: ip_lock(user_handle);
1210:
1211: /* make a sonce right */
1212: user_handle->ip_sorights++;
1213: ip_reference(user_handle);
1214:
1215: user_handle->ip_destination = IP_NULL;
1216: user_handle->ip_receiver_name = MACH_PORT_NULL;
1217: user_handle->ip_receiver = ipc_space_kernel;
1218:
1219: /* make a send right */
1220: user_handle->ip_mscount++;
1221: user_handle->ip_srights++;
1222: ip_reference(user_handle);
1223:
1224: ipc_port_nsrequest(user_handle, 1, user_handle, &previous);
1225: /* nsrequest unlocks user_handle */
1226:
1227: user_object->object = NULL;
1228: user_object->size = size;
1229: user_object->offset = 0;
1230: user_object->backing.pager = pager;
1231: user_object->protection = permission;
1232: user_object->internal = internal;
1233: user_object->is_sub_map = FALSE;
1234: user_object->ref_count = 1;
1235:
1236: ipc_kobject_set(user_handle, (ipc_kobject_t) user_object,
1237: IKOT_NAMED_ENTRY);
1238: *entry_handle = user_handle;
1239: return KERN_SUCCESS;
1240: }
1241:
1242:
1243:
1244: /*
1245: */
1246:
1247: kern_return_t
1248: mach_make_memory_entry(
1249: vm_map_t target_map,
1250: vm_size_t *size,
1251: vm_offset_t offset,
1252: vm_prot_t permission,
1253: ipc_port_t *object_handle,
1254: ipc_port_t parent_entry)
1255: {
1256: vm_map_version_t version;
1257: vm_named_entry_t user_object;
1258: ipc_port_t user_handle;
1259: ipc_port_t previous;
1260: kern_return_t kr;
1261:
1262: /* needed for call to vm_map_lookup_locked */
1263: boolean_t wired;
1264: vm_offset_t obj_off;
1265: vm_prot_t prot;
1266: vm_offset_t lo_offset, hi_offset;
1267: vm_behavior_t behavior;
1268: vm_object_t object;
1269:
1270: /* needed for direct map entry manipulation */
1271: vm_map_entry_t map_entry;
1272: vm_map_t local_map;
1273: vm_size_t mappable_size;
1274:
1275:
1276: user_object = (vm_named_entry_t)
1277: kalloc(sizeof (struct vm_named_entry));
1278: if(user_object == NULL)
1279: return KERN_FAILURE;
1280: named_entry_lock_init(user_object);
1281: user_handle = ipc_port_alloc_kernel();
1282: ip_lock(user_handle);
1283:
1284: /* make a sonce right */
1285: user_handle->ip_sorights++;
1286: ip_reference(user_handle);
1287:
1288: user_handle->ip_destination = IP_NULL;
1289: user_handle->ip_receiver_name = MACH_PORT_NULL;
1290: user_handle->ip_receiver = ipc_space_kernel;
1291:
1292: /* make a send right */
1293: user_handle->ip_mscount++;
1294: user_handle->ip_srights++;
1295: ip_reference(user_handle);
1296:
1297: ipc_port_nsrequest(user_handle, 1, user_handle, &previous);
1298: /* nsrequest unlocks user_handle */
1299:
1300: user_object->backing.pager = NULL;
1301: user_object->ref_count = 1;
1302:
1303: if(parent_entry == NULL) {
1304: /* Create a named object based on address range within the task map */
1305: /* Go find the object at given address */
1306:
1307: permission &= VM_PROT_ALL;
1308: vm_map_lock_read(target_map);
1309:
1310: /* get the object associated with the target address */
1311: /* note we check the permission of the range against */
1312: /* that requested by the caller */
1313:
1314: kr = vm_map_lookup_locked(&target_map, offset,
1315: permission, &version,
1316: &object, &obj_off, &prot, &wired, &behavior,
1317: &lo_offset, &hi_offset);
1318: if (kr != KERN_SUCCESS) {
1319: vm_map_unlock_read(target_map);
1320: goto make_mem_done;
1321: }
1322: if ((prot & permission) != permission) {
1323: kr = KERN_INVALID_RIGHT;
1324: vm_object_unlock(object);
1325: vm_map_unlock_read(target_map);
1326: goto make_mem_done;
1327: }
1328:
1329: /* We have an object, now check to see if this object */
1330: /* is suitable. If not, create a shadow and share that */
1331:
1332: local_map = target_map;
1333: redo_lookup:
1334: while(TRUE) {
1335: if(!vm_map_lookup_entry(local_map, offset, &map_entry)) {
1336: kr = KERN_INVALID_ARGUMENT;
1337: vm_object_unlock(object);
1338: vm_map_unlock_read(target_map);
1339: goto make_mem_done;
1340: }
1341: if(!(map_entry->is_sub_map)) {
1342: if(map_entry->object.vm_object != object) {
1343: kr = KERN_INVALID_ARGUMENT;
1344: vm_object_unlock(object);
1345: vm_map_unlock_read(target_map);
1346: goto make_mem_done;
1347: }
1348: break;
1349: } else {
1350: local_map = map_entry->object.sub_map;
1351: vm_map_lock_read(local_map);
1352: vm_map_unlock_read(target_map);
1353: target_map = local_map;
1354: }
1355: }
1356: if(((map_entry->max_protection) & permission) != permission) {
1357: kr = KERN_INVALID_RIGHT;
1358: vm_object_unlock(object);
1359: vm_map_unlock_read(target_map);
1360: goto make_mem_done;
1361: }
1362: if(object->internal) {
1363: /* vm_map_lookup_locked will create a shadow if */
1364: /* needs_copy is set but does not check for the */
1365: /* other two conditions shown. It is important to */
1366: /* set up an object which will not be pulled from */
1367: /* under us. */
1368:
1369: if (map_entry->needs_copy || object->shadowed ||
1370: (object->size > ((vm_size_t)map_entry->vme_end -
1371: map_entry->vme_start))) {
1372: if (vm_map_lock_read_to_write(target_map)) {
1373: vm_map_lock_read(target_map);
1374: goto redo_lookup;
1375: }
1376:
1377:
1378: /* create a shadow object */
1379:
1380: vm_object_shadow(&map_entry->object.vm_object,
1381: &map_entry->offset,
1382: (map_entry->vme_end
1383: - map_entry->vme_start));
1384: map_entry->needs_copy = FALSE;
1385: vm_object_unlock(object);
1386: object = map_entry->object.vm_object;
1387: vm_object_lock(object);
1388: object->size = map_entry->vme_end
1389: - map_entry->vme_start;
1390: obj_off = (offset - map_entry->vme_start) +
1391: map_entry->offset;
1392: lo_offset = map_entry->offset;
1393: hi_offset = (map_entry->vme_end -
1394: map_entry->vme_start) +
1395: map_entry->offset;
1396:
1397: vm_map_lock_write_to_read(target_map);
1398:
1399: }
1400: }
1401:
1402: /* note: in the future we can (if necessary) allow for */
1403: /* memory object lists, this will better support */
1404: /* fragmentation, but is it necessary? The user should */
1405: /* be encouraged to create address space oriented */
1406: /* shared objects from CLEAN memory regions which have */
1407: /* a known and defined history. i.e. no inheritence */
1408: /* share, make this call before making the region the */
1409: /* target of ipc's, etc. The code above, protecting */
1410: /* against delayed copy, etc. is mostly defensive. */
1411:
1412:
1413:
1414: object->true_share = TRUE;
1415: user_object->object = object;
1416: user_object->internal = object->internal;
1417: user_object->is_sub_map = FALSE;
1418: user_object->offset = obj_off;
1419: user_object->protection = permission;
1420:
1421: /* the size of mapped entry that overlaps with our region */
1422: /* which is targeted for share. */
1423: /* (entry_end - entry_start) - */
1424: /* offset of our beg addr within entry */
1425: /* it corresponds to this: */
1426:
1427: mappable_size = hi_offset - obj_off;
1428: if(*size > mappable_size)
1429: *size = mappable_size;
1430:
1431: user_object->size = *size;
1432:
1433: /* user_object pager and internal fields are not used */
1434: /* when the object field is filled in. */
1435:
1436: object->ref_count++; /* we now point to this object, hold on */
1437: vm_object_res_reference(object);
1438: vm_object_unlock(object);
1439: ipc_kobject_set(user_handle, (ipc_kobject_t) user_object,
1440: IKOT_NAMED_ENTRY);
1441: *size = user_object->size;
1442: *object_handle = user_handle;
1443: vm_map_unlock_read(target_map);
1444: return KERN_SUCCESS;
1445: } else {
1446:
1447: vm_named_entry_t parent_object;
1448:
1449: /* The new object will be base on an existing named object */
1450: if(ip_kotype(parent_entry) != IKOT_NAMED_ENTRY) {
1451: kr = KERN_INVALID_ARGUMENT;
1452: goto make_mem_done;
1453: }
1454: parent_object = (vm_named_entry_t)parent_entry->ip_kobject;
1455: if(permission & parent_object->protection != permission) {
1456: kr = KERN_INVALID_ARGUMENT;
1457: goto make_mem_done;
1458: }
1459: if((offset + *size) > parent_object->size) {
1460: kr = KERN_INVALID_ARGUMENT;
1461: goto make_mem_done;
1462: }
1463:
1464: user_object->object = parent_object->object;
1465: user_object->size = *size;
1466: user_object->offset = parent_object->offset + offset;
1467: user_object->protection = permission;
1468: if(parent_object->is_sub_map) {
1469: user_object->backing.map = parent_object->backing.map;
1470: vm_map_lock(user_object->backing.map);
1471: user_object->backing.map->ref_count++;
1472: vm_map_unlock(user_object->backing.map);
1473: }
1474: else {
1475: user_object->backing.pager = parent_object->backing.pager;
1476: }
1477: user_object->internal = parent_object->internal;
1478: user_object->is_sub_map = parent_object->is_sub_map;
1479:
1480: if(parent_object->object != NULL) {
1481: /* we now point to this object, hold on */
1482: vm_object_reference(parent_object->object);
1483: vm_object_lock(parent_object->object);
1484: parent_object->object->true_share = TRUE;
1485: vm_object_unlock(parent_object->object);
1486: }
1487: ipc_kobject_set(user_handle, (ipc_kobject_t) user_object,
1488: IKOT_NAMED_ENTRY);
1489: *object_handle = user_handle;
1490: return KERN_SUCCESS;
1491: }
1492:
1493:
1494:
1495: make_mem_done:
1496: ipc_port_dealloc_kernel(user_handle);
1497: kfree((vm_offset_t)user_object, sizeof (struct vm_named_entry));
1498: return kr;
1499: }
1500:
1501: /*
1502: */
1503:
1504: kern_return_t
1505: vm_region_object_create(
1506: vm_map_t target_map,
1507: vm_size_t size,
1508: ipc_port_t *object_handle)
1509: {
1510: vm_named_entry_t user_object;
1511: ipc_port_t user_handle;
1512: kern_return_t kr;
1513:
1514: pmap_t new_pmap = pmap_create((vm_size_t) 0);
1515: ipc_port_t previous;
1516: vm_map_t new_map;
1517:
1518: if(new_pmap == PMAP_NULL)
1519: return KERN_FAILURE;
1520: user_object = (vm_named_entry_t)
1521: kalloc(sizeof (struct vm_named_entry));
1522: if(user_object == NULL) {
1523: pmap_destroy(new_pmap);
1524: return KERN_FAILURE;
1525: }
1526: named_entry_lock_init(user_object);
1527: user_handle = ipc_port_alloc_kernel();
1528:
1529:
1530: ip_lock(user_handle);
1531:
1532: /* make a sonce right */
1533: user_handle->ip_sorights++;
1534: ip_reference(user_handle);
1535:
1536: user_handle->ip_destination = IP_NULL;
1537: user_handle->ip_receiver_name = MACH_PORT_NULL;
1538: user_handle->ip_receiver = ipc_space_kernel;
1539:
1540: /* make a send right */
1541: user_handle->ip_mscount++;
1542: user_handle->ip_srights++;
1543: ip_reference(user_handle);
1544:
1545: ipc_port_nsrequest(user_handle, 1, user_handle, &previous);
1546: /* nsrequest unlocks user_handle */
1547:
1548: /* Create a named object based on a submap of specified size */
1549:
1550: new_map = vm_map_create(new_pmap, 0, size, TRUE);
1551: user_object->backing.map = new_map;
1552:
1553:
1554: user_object->object = VM_OBJECT_NULL;
1555: user_object->internal = TRUE;
1556: user_object->is_sub_map = TRUE;
1557: user_object->offset = 0;
1558: user_object->protection = VM_PROT_ALL;
1559: user_object->size = size;
1560: user_object->ref_count = 1;
1561:
1562: ipc_kobject_set(user_handle, (ipc_kobject_t) user_object,
1563: IKOT_NAMED_ENTRY);
1564: *object_handle = user_handle;
1565: return KERN_SUCCESS;
1566:
1567: }
1568:
1569: void
1570: mach_destroy_memory_entry(
1571: ipc_port_t port)
1572: {
1573: vm_named_entry_t named_entry;
1574: #if MACH_ASSERT
1575: assert(ip_kotype(port) == IKOT_NAMED_ENTRY);
1576: #endif /* MACH_ASSERT */
1577: named_entry = (vm_named_entry_t)port->ip_kobject;
1578: mutex_lock(&(named_entry)->Lock);
1579: named_entry->ref_count-=1;
1580: if(named_entry->ref_count == 0) {
1581: if(named_entry->object) {
1582: /* release the memory object we've been pointing to */
1583: vm_object_deallocate(named_entry->object);
1584: }
1585: if(named_entry->is_sub_map) {
1586: vm_map_deallocate(named_entry->backing.map);
1587: }
1588: kfree((vm_offset_t)port->ip_kobject,
1589: sizeof (struct vm_named_entry));
1590: } else
1591: mutex_unlock(&(named_entry)->Lock);
1592: }
1593:
1594:
1595: kern_return_t
1596: vm_map_page_query(
1597: vm_map_t target_map,
1598: vm_offset_t offset,
1599: int *disposition,
1600: int *ref_count)
1601: {
1602: vm_map_entry_t map_entry;
1603: vm_object_t object;
1604: vm_page_t m;
1605:
1606: restart_page_query:
1607: *disposition = 0;
1608: *ref_count = 0;
1609: vm_map_lock(target_map);
1610: if(!vm_map_lookup_entry(target_map, offset, &map_entry)) {
1611: vm_map_unlock(target_map);
1612: return KERN_FAILURE;
1613: }
1614: offset -= map_entry->vme_start; /* adjust to offset within entry */
1615: offset += map_entry->offset; /* adjust to target object offset */
1616: if(map_entry->object.vm_object != VM_OBJECT_NULL) {
1617: if(!map_entry->is_sub_map) {
1618: object = map_entry->object.vm_object;
1619: } else {
1620: vm_map_unlock(target_map);
1621: target_map = map_entry->object.sub_map;
1622: goto restart_page_query;
1623: }
1624: } else {
1625: vm_map_unlock(target_map);
1626: return KERN_FAILURE;
1627: }
1628: vm_object_lock(object);
1629: vm_map_unlock(target_map);
1630: while(TRUE) {
1631: m = vm_page_lookup(object, offset);
1632: if (m != VM_PAGE_NULL) {
1633: *disposition |= VM_PAGE_QUERY_PAGE_PRESENT;
1634: break;
1635: } else {
1636: if(object->shadow) {
1637: offset += object->shadow_offset;
1638: vm_object_unlock(object);
1639: object = object->shadow;
1640: vm_object_lock(object);
1641: continue;
1642: }
1643: vm_object_unlock(object);
1644: return KERN_FAILURE;
1645: }
1646: }
1647:
1648: /* The ref_count is not strictly accurate, it measures the number */
1649: /* of entities holding a ref on the object, they may not be mapping */
1650: /* the object or may not be mapping the section holding the */
1651: /* target page but its still a ball park number and though an over- */
1652: /* count, it picks up the copy-on-write cases */
1653:
1654: /* We could also get a picture of page sharing from pmap_attributes */
1655: /* but this would under count as only faulted-in mappings would */
1656: /* show up. */
1657:
1658: *ref_count = object->ref_count;
1659:
1660: if (m->fictitious) {
1661: *disposition |= VM_PAGE_QUERY_PAGE_FICTITIOUS;
1662: vm_object_unlock(object);
1663: return KERN_SUCCESS;
1664: }
1665:
1666: if (m->dirty)
1667: *disposition |= VM_PAGE_QUERY_PAGE_DIRTY;
1668: else if(pmap_is_modified(m->phys_addr))
1669: *disposition |= VM_PAGE_QUERY_PAGE_DIRTY;
1670:
1671: if (m->reference)
1672: *disposition |= VM_PAGE_QUERY_PAGE_REF;
1673: else if(pmap_is_referenced(m->phys_addr))
1674: *disposition |= VM_PAGE_QUERY_PAGE_REF;
1675:
1676: vm_object_unlock(object);
1677: return KERN_SUCCESS;
1678:
1679: }
1680:
1681: kern_return_t
1682: set_dp_control_port(
1683: host_t host,
1684: ipc_port_t control_port)
1685: {
1686: if (host == HOST_NULL)
1687: return (KERN_INVALID_HOST);
1688: dynamic_pager_control_port = control_port;
1689: return KERN_SUCCESS;
1690: }
1691:
1692: kern_return_t
1693: get_dp_control_port(
1694: host_t host,
1695: ipc_port_t *control_port)
1696: {
1697: if (host == HOST_NULL)
1698: return (KERN_INVALID_HOST);
1699: *control_port = dynamic_pager_control_port;
1700: return KERN_SUCCESS;
1701:
1702: }
1703:
1704: void
1705: mach_destroy_upl(
1706: ipc_port_t port)
1707: {
1708: upl_t upl;
1709: #if MACH_ASSERT
1710: assert(ip_kotype(port) == IKOT_NAMED_ENTRY);
1711: #endif /* MACH_ASSERT */
1712: upl = (upl_t)port->ip_kobject;
1713: mutex_lock(&(upl)->Lock);
1714: upl->ref_count-=1;
1715: if(upl->ref_count == 0) {
1716: mutex_unlock(&(upl)->Lock);
1717: upl_abort(upl, UPL_ABORT_ERROR);
1718: } else
1719: mutex_unlock(&(upl)->Lock);
1720: }
1721:
1722: kern_return_t
1723: vm_object_upl_request(
1724: vm_object_t object,
1725: vm_object_offset_t offset,
1726: vm_size_t size,
1727: ipc_port_t *upl,
1728: upl_page_info_t *page_list,
1729: mach_msg_type_number_t *count,
1730: int cntrl_flags)
1731: {
1732: upl_t upl_object;
1733: ipc_port_t upl_port;
1734: ipc_port_t previous;
1735: upl_page_info_t *pl;
1736: kern_return_t kr;
1737:
1738: pl = page_list;
1739: kr = vm_fault_list_request(object, offset, size, &upl_object,
1740: &pl, *count, cntrl_flags);
1741:
1742:
1743: if(kr != KERN_SUCCESS) {
1744: *upl = MACH_PORT_NULL;
1745: return KERN_FAILURE;
1746: }
1747:
1748: upl_port = ipc_port_alloc_kernel();
1749:
1750:
1751: ip_lock(upl_port);
1752:
1753: /* make a sonce right */
1754: upl_port->ip_sorights++;
1755: ip_reference(upl_port);
1756:
1757: upl_port->ip_destination = IP_NULL;
1758: upl_port->ip_receiver_name = MACH_PORT_NULL;
1759: upl_port->ip_receiver = ipc_space_kernel;
1760:
1761: /* make a send right */
1762: upl_port->ip_mscount++;
1763: upl_port->ip_srights++;
1764: ip_reference(upl_port);
1765:
1766: ipc_port_nsrequest(upl_port, 1, upl_port, &previous);
1767: /* nsrequest unlocks user_handle */
1768:
1769: /* Create a named object based on a submap of specified size */
1770:
1771:
1772: ipc_kobject_set(upl_port, (ipc_kobject_t) upl_object, IKOT_UPL);
1773: *upl = upl_port;
1774: return KERN_SUCCESS;
1775: }
1776:
1777: kern_return_t
1778: vm_pager_upl_request(
1779: vm_object_t object,
1780: vm_object_offset_t offset,
1781: vm_size_t size,
1782: vm_size_t super_size,
1783: ipc_port_t *upl,
1784: upl_page_info_t *page_list,
1785: mach_msg_type_number_t *count,
1786: int cntrl_flags)
1787: {
1788: upl_t upl_object;
1789: ipc_port_t upl_port;
1790: ipc_port_t previous;
1791: upl_page_info_t *pl;
1792: kern_return_t kr;
1793:
1794: pl = page_list;
1795: kr = upl_system_list_request(object, offset, size, super_size,
1796: &upl_object, &pl, *count, cntrl_flags);
1797:
1798: if(kr != KERN_SUCCESS) {
1799: *upl = MACH_PORT_NULL;
1800: return KERN_FAILURE;
1801: }
1802:
1803:
1804: upl_port = ipc_port_alloc_kernel();
1805:
1806:
1807: ip_lock(upl_port);
1808:
1809: /* make a sonce right */
1810: upl_port->ip_sorights++;
1811: ip_reference(upl_port);
1812:
1813: upl_port->ip_destination = IP_NULL;
1814: upl_port->ip_receiver_name = MACH_PORT_NULL;
1815: upl_port->ip_receiver = ipc_space_kernel;
1816:
1817: /* make a send right */
1818: upl_port->ip_mscount++;
1819: upl_port->ip_srights++;
1820: ip_reference(upl_port);
1821:
1822: ipc_port_nsrequest(upl_port, 1, upl_port, &previous);
1823: /* nsrequest unlocks user_handle */
1824:
1825: /* Create a named object based on a submap of specified size */
1826:
1827:
1828: ipc_kobject_set(upl_port, (ipc_kobject_t) upl_object, IKOT_UPL);
1829: *upl = upl_port;
1830: return KERN_SUCCESS;
1831: }
1832:
1833: kern_return_t
1834: vm_upl_map(
1835: vm_map_t map,
1836: ipc_port_t upl_port,
1837: vm_offset_t *dst_addr)
1838: {
1839: upl_t upl;
1840: kern_return_t kr;
1841:
1842: if (!IP_VALID(upl_port)) {
1843: return KERN_INVALID_ARGUMENT;
1844: } else if (ip_kotype(upl_port) == IKOT_UPL) {
1845: upl_lock(upl);
1846: upl = (upl_t)upl_port->ip_kobject;
1847: kr = upl_map(map, upl, dst_addr);
1848: upl_unlock(upl);
1849: return kr;
1850: } else {
1851: return KERN_FAILURE;
1852: }
1853: }
1854:
1855:
1856: kern_return_t
1857: vm_upl_unmap(
1858: vm_map_t map,
1859: ipc_port_t upl_port)
1860: {
1861: upl_t upl;
1862: kern_return_t kr;
1863:
1864: if (!IP_VALID(upl_port)) {
1865: return KERN_INVALID_ARGUMENT;
1866: } else if (ip_kotype(upl_port) == IKOT_UPL) {
1867: upl_lock(upl);
1868: upl = (upl_t)upl_port->ip_kobject;
1869: kr = upl_un_map(map, upl);
1870: upl_unlock(upl);
1871: return kr;
1872: } else {
1873: return KERN_FAILURE;
1874: }
1875: }
1876:
1877: kern_return_t
1878: vm_upl_commit(
1879: upl_t upl,
1880: upl_page_list_ptr_t page_list,
1881: mach_msg_type_number_t count)
1882: {
1883: kern_return_t kr;
1884: upl_lock(upl);
1885: if(count) {
1886: kr = upl_commit(upl, (upl_page_info_t *)page_list);
1887: } else {
1888: kr = upl_commit(upl, (upl_page_info_t *) NULL);
1889: }
1890: upl_unlock(upl);
1891: return kr;
1892: }
1893:
1894: kern_return_t
1895: vm_upl_commit_range(
1896: upl_t upl,
1897: vm_offset_t offset,
1898: vm_size_t size,
1899: upl_page_list_ptr_t page_list,
1900: boolean_t free_on_empty,
1901: mach_msg_type_number_t count)
1902: {
1903: kern_return_t kr;
1904: upl_lock(upl);
1905: if(count) {
1906: kr = upl_commit_range(upl, offset, size, free_on_empty,
1907: (upl_page_info_t *)page_list);
1908: } else {
1909: kr = upl_commit_range(upl, offset, size, free_on_empty,
1910: (upl_page_info_t *) NULL);
1911: }
1912: upl_unlock(upl);
1913: return kr;
1914: }
1915:
1916: kern_return_t
1917: vm_upl_abort_range(
1918: upl_t upl,
1919: vm_offset_t offset,
1920: vm_size_t size,
1921: int abort_flags)
1922: {
1923: kern_return_t kr;
1924: upl_lock(upl);
1925: kr = upl_abort_range(upl, offset, size, abort_flags);
1926: upl_unlock(upl);
1927: return kr;
1928: }
1929:
1930: kern_return_t
1931: vm_upl_abort(
1932: upl_t upl,
1933: int abort_type)
1934: {
1935: kern_return_t kr;
1936: upl_lock(upl);
1937: kr = upl_abort(upl, abort_type);
1938: upl_unlock(upl);
1939: return kr;
1940: }
1941:
1942: #endif /* VM_CPM */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.