![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vm_map.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / vm|
Return to vm_map.c CVS log | Up to [Net/2] / Net2 / vm |
1.1 root 1: /*
2: * Copyright (c) 1991 Regents of the University of California.
3: * All rights reserved.
4: *
5: * This code is derived from software contributed to Berkeley by
6: * The Mach Operating System project at Carnegie-Mellon University.
7: *
8: * Redistribution and use in source and binary forms, with or without
9: * modification, are permitted provided that the following conditions
10: * are met:
11: * 1. Redistributions of source code must retain the above copyright
12: * notice, this list of conditions and the following disclaimer.
13: * 2. Redistributions in binary form must reproduce the above copyright
14: * notice, this list of conditions and the following disclaimer in the
15: * documentation and/or other materials provided with the distribution.
16: * 3. All advertising materials mentioning features or use of this software
17: * must display the following acknowledgement:
18: * This product includes software developed by the University of
19: * California, Berkeley and its contributors.
20: * 4. Neither the name of the University nor the names of its contributors
21: * may be used to endorse or promote products derived from this software
22: * without specific prior written permission.
23: *
24: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34: * SUCH DAMAGE.
35: *
36: * @(#)vm_map.c 7.3 (Berkeley) 4/21/91
37: *
38: *
39: * Copyright (c) 1987, 1990 Carnegie-Mellon University.
40: * All rights reserved.
41: *
42: * Authors: Avadis Tevanian, Jr., Michael Wayne Young
43: *
44: * Permission to use, copy, modify and distribute this software and
45: * its documentation is hereby granted, provided that both the copyright
46: * notice and this permission notice appear in all copies of the
47: * software, derivative works or modified versions, and any portions
48: * thereof, and that both notices appear in supporting documentation.
49: *
50: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
51: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
52: * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
53: *
54: * Carnegie Mellon requests users of this software to return to
55: *
56: * Software Distribution Coordinator or [email protected]
57: * School of Computer Science
58: * Carnegie Mellon University
59: * Pittsburgh PA 15213-3890
60: *
61: * any improvements or extensions that they make and grant Carnegie the
62: * rights to redistribute these changes.
63: */
64:
65: /*
66: * Virtual memory mapping module.
67: */
68:
69: #include "param.h"
70: #include "malloc.h"
71: #include "vm.h"
72: #include "vm_page.h"
73: #include "vm_object.h"
74:
75: /*
76: * Virtual memory maps provide for the mapping, protection,
77: * and sharing of virtual memory objects. In addition,
78: * this module provides for an efficient virtual copy of
79: * memory from one map to another.
80: *
81: * Synchronization is required prior to most operations.
82: *
83: * Maps consist of an ordered doubly-linked list of simple
84: * entries; a single hint is used to speed up lookups.
85: *
86: * In order to properly represent the sharing of virtual
87: * memory regions among maps, the map structure is bi-level.
88: * Top-level ("address") maps refer to regions of sharable
89: * virtual memory. These regions are implemented as
90: * ("sharing") maps, which then refer to the actual virtual
91: * memory objects. When two address maps "share" memory,
92: * their top-level maps both have references to the same
93: * sharing map. When memory is virtual-copied from one
94: * address map to another, the references in the sharing
95: * maps are actually copied -- no copying occurs at the
96: * virtual memory object level.
97: *
98: * Since portions of maps are specified by start/end addreses,
99: * which may not align with existing map entries, all
100: * routines merely "clip" entries to these start/end values.
101: * [That is, an entry is split into two, bordering at a
102: * start or end value.] Note that these clippings may not
103: * always be necessary (as the two resulting entries are then
104: * not changed); however, the clipping is done for convenience.
105: * No attempt is currently made to "glue back together" two
106: * abutting entries.
107: *
108: * As mentioned above, virtual copy operations are performed
109: * by copying VM object references from one sharing map to
110: * another, and then marking both regions as copy-on-write.
111: * It is important to note that only one writeable reference
112: * to a VM object region exists in any map -- this means that
113: * shadow object creation can be delayed until a write operation
114: * occurs.
115: */
116:
117: /*
118: * vm_map_startup:
119: *
120: * Initialize the vm_map module. Must be called before
121: * any other vm_map routines.
122: *
123: * Map and entry structures are allocated from the general
124: * purpose memory pool with some exceptions:
125: *
126: * - The kernel map and kmem submap are allocated statically.
127: * - Kernel map entries are allocated out of a static pool.
128: *
129: * These restrictions are necessary since malloc() uses the
130: * maps and requires map entries.
131: */
132:
133: vm_offset_t kentry_data;
134: vm_size_t kentry_data_size;
135: vm_map_entry_t kentry_free;
136: vm_map_t kmap_free;
137:
138: void vm_map_startup()
139: {
140: register int i;
141: register vm_map_entry_t mep;
142: vm_map_t mp;
143:
144: /*
145: * Static map structures for allocation before initialization of
146: * kernel map or kmem map. vm_map_create knows how to deal with them.
147: */
148: kmap_free = mp = (vm_map_t) kentry_data;
149: i = MAX_KMAP;
150: while (--i > 0) {
151: mp->header.next = (vm_map_entry_t) (mp + 1);
152: mp++;
153: }
154: mp++->header.next = NULL;
155:
156: /*
157: * Form a free list of statically allocated kernel map entries
158: * with the rest.
159: */
160: kentry_free = mep = (vm_map_entry_t) mp;
161: i = (kentry_data_size - MAX_KMAP * sizeof *mp) / sizeof *mep;
162: while (--i > 0) {
163: mep->next = mep + 1;
164: mep++;
165: }
166: mep->next = NULL;
167: }
168:
169: /*
170: * Allocate a vmspace structure, including a vm_map and pmap,
171: * and initialize those structures. The refcnt is set to 1.
172: * The remaining fields must be initialized by the caller.
173: */
174: struct vmspace *
175: vmspace_alloc(min, max, pageable)
176: vm_offset_t min, max;
177: int pageable;
178: {
179: register struct vmspace *vm;
180:
181: MALLOC(vm, struct vmspace *, sizeof(struct vmspace), M_VMMAP, M_WAITOK);
182: bzero(vm, (caddr_t) &vm->vm_startcopy - (caddr_t) vm);
183: vm_map_init(&vm->vm_map, min, max, pageable);
184: pmap_pinit(&vm->vm_pmap);
185: vm->vm_map.pmap = &vm->vm_pmap; /* XXX */
186: vm->vm_refcnt = 1;
187: return (vm);
188: }
189:
190: void
191: vmspace_free(vm)
192: register struct vmspace *vm;
193: {
194:
195: if (--vm->vm_refcnt == 0) {
196: /*
197: * Lock the map, to wait out all other references to it.
198: * Delete all of the mappings and pages they hold,
199: * then call the pmap module to reclaim anything left.
200: */
201: vm_map_lock(&vm->vm_map);
202: (void) vm_map_delete(&vm->vm_map, vm->vm_map.min_offset,
203: vm->vm_map.max_offset);
204: pmap_release(&vm->vm_pmap);
205: FREE(vm, M_VMMAP);
206: }
207: }
208:
209: /*
210: * vm_map_create:
211: *
212: * Creates and returns a new empty VM map with
213: * the given physical map structure, and having
214: * the given lower and upper address bounds.
215: */
216: vm_map_t vm_map_create(pmap, min, max, pageable)
217: pmap_t pmap;
218: vm_offset_t min, max;
219: boolean_t pageable;
220: {
221: register vm_map_t result;
222: extern vm_map_t kernel_map, kmem_map;
223:
224: if (kmem_map == NULL) {
225: result = kmap_free;
226: kmap_free = (vm_map_t) result->header.next;
227: if (result == NULL)
228: panic("vm_map_create: out of maps");
229: } else
230: MALLOC(result, vm_map_t, sizeof(struct vm_map),
231: M_VMMAP, M_WAITOK);
232:
233: vm_map_init(result, min, max, pageable);
234: result->pmap = pmap;
235: return(result);
236: }
237:
238: /*
239: * Initialize an existing vm_map structure
240: * such as that in the vmspace structure.
241: * The pmap is set elsewhere.
242: */
243: void
244: vm_map_init(map, min, max, pageable)
245: register struct vm_map *map;
246: vm_offset_t min, max;
247: boolean_t pageable;
248: {
249: map->header.next = map->header.prev = &map->header;
250: map->nentries = 0;
251: map->size = 0;
252: map->ref_count = 1;
253: map->is_main_map = TRUE;
254: map->min_offset = min;
255: map->max_offset = max;
256: map->entries_pageable = pageable;
257: map->first_free = &map->header;
258: map->hint = &map->header;
259: map->timestamp = 0;
260: lock_init(&map->lock, TRUE);
261: simple_lock_init(&map->ref_lock);
262: simple_lock_init(&map->hint_lock);
263: }
264:
265: /*
266: * vm_map_entry_create: [ internal use only ]
267: *
268: * Allocates a VM map entry for insertion.
269: * No entry fields are filled in. This routine is
270: */
271: vm_map_entry_t vm_map_entry_create(map)
272: vm_map_t map;
273: {
274: vm_map_entry_t entry;
275: extern vm_map_t kernel_map, kmem_map, mb_map;
276:
277: if (map == kernel_map || map == kmem_map || map == mb_map) {
278: if (entry = kentry_free)
279: kentry_free = kentry_free->next;
280: } else
281: MALLOC(entry, vm_map_entry_t, sizeof(struct vm_map_entry),
282: M_VMMAPENT, M_WAITOK);
283: if (entry == NULL)
284: panic("vm_map_entry_create: out of map entries");
285:
286: return(entry);
287: }
288:
289: /*
290: * vm_map_entry_dispose: [ internal use only ]
291: *
292: * Inverse of vm_map_entry_create.
293: */
294: void vm_map_entry_dispose(map, entry)
295: vm_map_t map;
296: vm_map_entry_t entry;
297: {
298: extern vm_map_t kernel_map, kmem_map, mb_map;
299:
300: if (map == kernel_map || map == kmem_map || map == mb_map) {
301: entry->next = kentry_free;
302: kentry_free = entry;
303: } else
304: FREE(entry, M_VMMAPENT);
305: }
306:
307: /*
308: * vm_map_entry_{un,}link:
309: *
310: * Insert/remove entries from maps.
311: */
312: #define vm_map_entry_link(map, after_where, entry) \
313: { \
314: (map)->nentries++; \
315: (entry)->prev = (after_where); \
316: (entry)->next = (after_where)->next; \
317: (entry)->prev->next = (entry); \
318: (entry)->next->prev = (entry); \
319: }
320: #define vm_map_entry_unlink(map, entry) \
321: { \
322: (map)->nentries--; \
323: (entry)->next->prev = (entry)->prev; \
324: (entry)->prev->next = (entry)->next; \
325: }
326:
327: /*
328: * vm_map_reference:
329: *
330: * Creates another valid reference to the given map.
331: *
332: */
333: void vm_map_reference(map)
334: register vm_map_t map;
335: {
336: if (map == NULL)
337: return;
338:
339: simple_lock(&map->ref_lock);
340: map->ref_count++;
341: simple_unlock(&map->ref_lock);
342: }
343:
344: /*
345: * vm_map_deallocate:
346: *
347: * Removes a reference from the specified map,
348: * destroying it if no references remain.
349: * The map should not be locked.
350: */
351: void vm_map_deallocate(map)
352: register vm_map_t map;
353: {
354: register int c;
355:
356: if (map == NULL)
357: return;
358:
359: simple_lock(&map->ref_lock);
360: c = --map->ref_count;
361: simple_unlock(&map->ref_lock);
362:
363: if (c > 0) {
364: return;
365: }
366:
367: /*
368: * Lock the map, to wait out all other references
369: * to it.
370: */
371:
372: vm_map_lock(map);
373:
374: (void) vm_map_delete(map, map->min_offset, map->max_offset);
375:
376: pmap_destroy(map->pmap);
377:
378: FREE(map, M_VMMAP);
379: }
380:
381: /*
382: * vm_map_insert: [ internal use only ]
383: *
384: * Inserts the given whole VM object into the target
385: * map at the specified address range. The object's
386: * size should match that of the address range.
387: *
388: * Requires that the map be locked, and leaves it so.
389: */
390: vm_map_insert(map, object, offset, start, end)
391: vm_map_t map;
392: vm_object_t object;
393: vm_offset_t offset;
394: vm_offset_t start;
395: vm_offset_t end;
396: {
397: register vm_map_entry_t new_entry;
398: register vm_map_entry_t prev_entry;
399: vm_map_entry_t temp_entry;
400:
401: /*
402: * Check that the start and end points are not bogus.
403: */
404:
405: if ((start < map->min_offset) || (end > map->max_offset) ||
406: (start >= end))
407: return(KERN_INVALID_ADDRESS);
408:
409: /*
410: * Find the entry prior to the proposed
411: * starting address; if it's part of an
412: * existing entry, this range is bogus.
413: */
414:
415: if (vm_map_lookup_entry(map, start, &temp_entry))
416: return(KERN_NO_SPACE);
417:
418: prev_entry = temp_entry;
419:
420: /*
421: * Assert that the next entry doesn't overlap the
422: * end point.
423: */
424:
425: if ((prev_entry->next != &map->header) &&
426: (prev_entry->next->start < end))
427: return(KERN_NO_SPACE);
428:
429: /*
430: * See if we can avoid creating a new entry by
431: * extending one of our neighbors.
432: */
433:
434: if (object == NULL) {
435: if ((prev_entry != &map->header) &&
436: (prev_entry->end == start) &&
437: (map->is_main_map) &&
438: (prev_entry->is_a_map == FALSE) &&
439: (prev_entry->is_sub_map == FALSE) &&
440: (prev_entry->inheritance == VM_INHERIT_DEFAULT) &&
441: (prev_entry->protection == VM_PROT_DEFAULT) &&
442: (prev_entry->max_protection == VM_PROT_DEFAULT) &&
443: (prev_entry->wired_count == 0)) {
444:
445: if (vm_object_coalesce(prev_entry->object.vm_object,
446: NULL,
447: prev_entry->offset,
448: (vm_offset_t) 0,
449: (vm_size_t)(prev_entry->end
450: - prev_entry->start),
451: (vm_size_t)(end - prev_entry->end))) {
452: /*
453: * Coalesced the two objects - can extend
454: * the previous map entry to include the
455: * new range.
456: */
457: map->size += (end - prev_entry->end);
458: prev_entry->end = end;
459: return(KERN_SUCCESS);
460: }
461: }
462: }
463:
464: /*
465: * Create a new entry
466: */
467:
468: new_entry = vm_map_entry_create(map);
469: new_entry->start = start;
470: new_entry->end = end;
471:
472: new_entry->is_a_map = FALSE;
473: new_entry->is_sub_map = FALSE;
474: new_entry->object.vm_object = object;
475: new_entry->offset = offset;
476:
477: new_entry->copy_on_write = FALSE;
478: new_entry->needs_copy = FALSE;
479:
480: if (map->is_main_map) {
481: new_entry->inheritance = VM_INHERIT_DEFAULT;
482: new_entry->protection = VM_PROT_DEFAULT;
483: new_entry->max_protection = VM_PROT_DEFAULT;
484: new_entry->wired_count = 0;
485: }
486:
487: /*
488: * Insert the new entry into the list
489: */
490:
491: vm_map_entry_link(map, prev_entry, new_entry);
492: map->size += new_entry->end - new_entry->start;
493:
494: /*
495: * Update the free space hint
496: */
497:
498: if ((map->first_free == prev_entry) && (prev_entry->end >= new_entry->start))
499: map->first_free = new_entry;
500:
501: return(KERN_SUCCESS);
502: }
503:
504: /*
505: * SAVE_HINT:
506: *
507: * Saves the specified entry as the hint for
508: * future lookups. Performs necessary interlocks.
509: */
510: #define SAVE_HINT(map,value) \
511: simple_lock(&(map)->hint_lock); \
512: (map)->hint = (value); \
513: simple_unlock(&(map)->hint_lock);
514:
515: /*
516: * vm_map_lookup_entry: [ internal use only ]
517: *
518: * Finds the map entry containing (or
519: * immediately preceding) the specified address
520: * in the given map; the entry is returned
521: * in the "entry" parameter. The boolean
522: * result indicates whether the address is
523: * actually contained in the map.
524: */
525: boolean_t vm_map_lookup_entry(map, address, entry)
526: register vm_map_t map;
527: register vm_offset_t address;
528: vm_map_entry_t *entry; /* OUT */
529: {
530: register vm_map_entry_t cur;
531: register vm_map_entry_t last;
532:
533: /*
534: * Start looking either from the head of the
535: * list, or from the hint.
536: */
537:
538: simple_lock(&map->hint_lock);
539: cur = map->hint;
540: simple_unlock(&map->hint_lock);
541:
542: if (cur == &map->header)
543: cur = cur->next;
544:
545: if (address >= cur->start) {
546: /*
547: * Go from hint to end of list.
548: *
549: * But first, make a quick check to see if
550: * we are already looking at the entry we
551: * want (which is usually the case).
552: * Note also that we don't need to save the hint
553: * here... it is the same hint (unless we are
554: * at the header, in which case the hint didn't
555: * buy us anything anyway).
556: */
557: last = &map->header;
558: if ((cur != last) && (cur->end > address)) {
559: *entry = cur;
560: return(TRUE);
561: }
562: }
563: else {
564: /*
565: * Go from start to hint, *inclusively*
566: */
567: last = cur->next;
568: cur = map->header.next;
569: }
570:
571: /*
572: * Search linearly
573: */
574:
575: while (cur != last) {
576: if (cur->end > address) {
577: if (address >= cur->start) {
578: /*
579: * Save this lookup for future
580: * hints, and return
581: */
582:
583: *entry = cur;
584: SAVE_HINT(map, cur);
585: return(TRUE);
586: }
587: break;
588: }
589: cur = cur->next;
590: }
591: *entry = cur->prev;
592: SAVE_HINT(map, *entry);
593: return(FALSE);
594: }
595:
596: /*
597: * vm_map_find finds an unallocated region in the target address
598: * map with the given length. The search is defined to be
599: * first-fit from the specified address; the region found is
600: * returned in the same parameter.
601: *
602: */
603: vm_map_find(map, object, offset, addr, length, find_space)
604: vm_map_t map;
605: vm_object_t object;
606: vm_offset_t offset;
607: vm_offset_t *addr; /* IN/OUT */
608: vm_size_t length;
609: boolean_t find_space;
610: {
611: register vm_map_entry_t entry;
612: register vm_offset_t start;
613: register vm_offset_t end;
614: int result;
615:
616: start = *addr;
617:
618: vm_map_lock(map);
619:
620: if (find_space) {
621: /*
622: * Calculate the first possible address.
623: */
624:
625: if (start < map->min_offset)
626: start = map->min_offset;
627: if (start > map->max_offset) {
628: vm_map_unlock(map);
629: return (KERN_NO_SPACE);
630: }
631:
632: /*
633: * Look for the first possible address;
634: * if there's already something at this
635: * address, we have to start after it.
636: */
637:
638: if (start == map->min_offset) {
639: if ((entry = map->first_free) != &map->header)
640: start = entry->end;
641: } else {
642: vm_map_entry_t tmp_entry;
643: if (vm_map_lookup_entry(map, start, &tmp_entry))
644: start = tmp_entry->end;
645: entry = tmp_entry;
646: }
647:
648: /*
649: * In any case, the "entry" always precedes
650: * the proposed new region throughout the
651: * loop:
652: */
653:
654: while (TRUE) {
655: register vm_map_entry_t next;
656:
657: /*
658: * Find the end of the proposed new region.
659: * Be sure we didn't go beyond the end, or
660: * wrap around the address.
661: */
662:
663: end = start + length;
664:
665: if ((end > map->max_offset) || (end < start)) {
666: vm_map_unlock(map);
667: return (KERN_NO_SPACE);
668: }
669:
670: /*
671: * If there are no more entries, we must win.
672: */
673:
674: next = entry->next;
675: if (next == &map->header)
676: break;
677:
678: /*
679: * If there is another entry, it must be
680: * after the end of the potential new region.
681: */
682:
683: if (next->start >= end)
684: break;
685:
686: /*
687: * Didn't fit -- move to the next entry.
688: */
689:
690: entry = next;
691: start = entry->end;
692: }
693: *addr = start;
694:
695: SAVE_HINT(map, entry);
696: }
697:
698: result = vm_map_insert(map, object, offset, start, start + length);
699:
700: vm_map_unlock(map);
701: return(result);
702: }
703:
704: /*
705: * vm_map_simplify_entry: [ internal use only ]
706: *
707: * Simplify the given map entry by:
708: * removing extra sharing maps
709: * [XXX maybe later] merging with a neighbor
710: */
711: void vm_map_simplify_entry(map, entry)
712: vm_map_t map;
713: vm_map_entry_t entry;
714: {
715: #ifdef lint
716: map++;
717: #endif lint
718:
719: /*
720: * If this entry corresponds to a sharing map, then
721: * see if we can remove the level of indirection.
722: * If it's not a sharing map, then it points to
723: * a VM object, so see if we can merge with either
724: * of our neighbors.
725: */
726:
727: if (entry->is_sub_map)
728: return;
729: if (entry->is_a_map) {
730: #if 0
731: vm_map_t my_share_map;
732: int count;
733:
734: my_share_map = entry->object.share_map;
735: simple_lock(&my_share_map->ref_lock);
736: count = my_share_map->ref_count;
737: simple_unlock(&my_share_map->ref_lock);
738:
739: if (count == 1) {
740: /* Can move the region from
741: * entry->start to entry->end (+ entry->offset)
742: * in my_share_map into place of entry.
743: * Later.
744: */
745: }
746: #endif 0
747: }
748: else {
749: /*
750: * Try to merge with our neighbors.
751: *
752: * Conditions for merge are:
753: *
754: * 1. entries are adjacent.
755: * 2. both entries point to objects
756: * with null pagers.
757: *
758: * If a merge is possible, we replace the two
759: * entries with a single entry, then merge
760: * the two objects into a single object.
761: *
762: * Now, all that is left to do is write the
763: * code!
764: */
765: }
766: }
767:
768: /*
769: * vm_map_clip_start: [ internal use only ]
770: *
771: * Asserts that the given entry begins at or after
772: * the specified address; if necessary,
773: * it splits the entry into two.
774: */
775: #define vm_map_clip_start(map, entry, startaddr) \
776: { \
777: if (startaddr > entry->start) \
778: _vm_map_clip_start(map, entry, startaddr); \
779: }
780:
781: /*
782: * This routine is called only when it is known that
783: * the entry must be split.
784: */
785: void _vm_map_clip_start(map, entry, start)
786: register vm_map_t map;
787: register vm_map_entry_t entry;
788: register vm_offset_t start;
789: {
790: register vm_map_entry_t new_entry;
791:
792: /*
793: * See if we can simplify this entry first
794: */
795:
796: vm_map_simplify_entry(map, entry);
797:
798: /*
799: * Split off the front portion --
800: * note that we must insert the new
801: * entry BEFORE this one, so that
802: * this entry has the specified starting
803: * address.
804: */
805:
806: new_entry = vm_map_entry_create(map);
807: *new_entry = *entry;
808:
809: new_entry->end = start;
810: entry->offset += (start - entry->start);
811: entry->start = start;
812:
813: vm_map_entry_link(map, entry->prev, new_entry);
814:
815: if (entry->is_a_map || entry->is_sub_map)
816: vm_map_reference(new_entry->object.share_map);
817: else
818: vm_object_reference(new_entry->object.vm_object);
819: }
820:
821: /*
822: * vm_map_clip_end: [ internal use only ]
823: *
824: * Asserts that the given entry ends at or before
825: * the specified address; if necessary,
826: * it splits the entry into two.
827: */
828:
829: void _vm_map_clip_end();
830: #define vm_map_clip_end(map, entry, endaddr) \
831: { \
832: if (endaddr < entry->end) \
833: _vm_map_clip_end(map, entry, endaddr); \
834: }
835:
836: /*
837: * This routine is called only when it is known that
838: * the entry must be split.
839: */
840: void _vm_map_clip_end(map, entry, end)
841: register vm_map_t map;
842: register vm_map_entry_t entry;
843: register vm_offset_t end;
844: {
845: register vm_map_entry_t new_entry;
846:
847: /*
848: * Create a new entry and insert it
849: * AFTER the specified entry
850: */
851:
852: new_entry = vm_map_entry_create(map);
853: *new_entry = *entry;
854:
855: new_entry->start = entry->end = end;
856: new_entry->offset += (end - entry->start);
857:
858: vm_map_entry_link(map, entry, new_entry);
859:
860: if (entry->is_a_map || entry->is_sub_map)
861: vm_map_reference(new_entry->object.share_map);
862: else
863: vm_object_reference(new_entry->object.vm_object);
864: }
865:
866: /*
867: * VM_MAP_RANGE_CHECK: [ internal use only ]
868: *
869: * Asserts that the starting and ending region
870: * addresses fall within the valid range of the map.
871: */
872: #define VM_MAP_RANGE_CHECK(map, start, end) \
873: { \
874: if (start < vm_map_min(map)) \
875: start = vm_map_min(map); \
876: if (end > vm_map_max(map)) \
877: end = vm_map_max(map); \
878: if (start > end) \
879: start = end; \
880: }
881:
882: /*
883: * vm_map_submap: [ kernel use only ]
884: *
885: * Mark the given range as handled by a subordinate map.
886: *
887: * This range must have been created with vm_map_find,
888: * and no other operations may have been performed on this
889: * range prior to calling vm_map_submap.
890: *
891: * Only a limited number of operations can be performed
892: * within this rage after calling vm_map_submap:
893: * vm_fault
894: * [Don't try vm_map_copy!]
895: *
896: * To remove a submapping, one must first remove the
897: * range from the superior map, and then destroy the
898: * submap (if desired). [Better yet, don't try it.]
899: */
900: vm_map_submap(map, start, end, submap)
901: register vm_map_t map;
902: register vm_offset_t start;
903: register vm_offset_t end;
904: vm_map_t submap;
905: {
906: vm_map_entry_t entry;
907: register int result = KERN_INVALID_ARGUMENT;
908:
909: vm_map_lock(map);
910:
911: VM_MAP_RANGE_CHECK(map, start, end);
912:
913: if (vm_map_lookup_entry(map, start, &entry)) {
914: vm_map_clip_start(map, entry, start);
915: }
916: else
917: entry = entry->next;
918:
919: vm_map_clip_end(map, entry, end);
920:
921: if ((entry->start == start) && (entry->end == end) &&
922: (!entry->is_a_map) &&
923: (entry->object.vm_object == NULL) &&
924: (!entry->copy_on_write)) {
925: entry->is_a_map = FALSE;
926: entry->is_sub_map = TRUE;
927: vm_map_reference(entry->object.sub_map = submap);
928: result = KERN_SUCCESS;
929: }
930: vm_map_unlock(map);
931:
932: return(result);
933: }
934:
935: /*
936: * vm_map_protect:
937: *
938: * Sets the protection of the specified address
939: * region in the target map. If "set_max" is
940: * specified, the maximum protection is to be set;
941: * otherwise, only the current protection is affected.
942: */
943: vm_map_protect(map, start, end, new_prot, set_max)
944: register vm_map_t map;
945: register vm_offset_t start;
946: register vm_offset_t end;
947: register vm_prot_t new_prot;
948: register boolean_t set_max;
949: {
950: register vm_map_entry_t current;
951: vm_map_entry_t entry;
952:
953: vm_map_lock(map);
954:
955: VM_MAP_RANGE_CHECK(map, start, end);
956:
957: if (vm_map_lookup_entry(map, start, &entry)) {
958: vm_map_clip_start(map, entry, start);
959: }
960: else
961: entry = entry->next;
962:
963: /*
964: * Make a first pass to check for protection
965: * violations.
966: */
967:
968: current = entry;
969: while ((current != &map->header) && (current->start < end)) {
970: if (current->is_sub_map)
971: return(KERN_INVALID_ARGUMENT);
972: if ((new_prot & current->max_protection) != new_prot) {
973: vm_map_unlock(map);
974: return(KERN_PROTECTION_FAILURE);
975: }
976:
977: current = current->next;
978: }
979:
980: /*
981: * Go back and fix up protections.
982: * [Note that clipping is not necessary the second time.]
983: */
984:
985: current = entry;
986:
987: while ((current != &map->header) && (current->start < end)) {
988: vm_prot_t old_prot;
989:
990: vm_map_clip_end(map, current, end);
991:
992: old_prot = current->protection;
993: if (set_max)
994: current->protection =
995: (current->max_protection = new_prot) &
996: old_prot;
997: else
998: current->protection = new_prot;
999:
1000: /*
1001: * Update physical map if necessary.
1002: * Worry about copy-on-write here -- CHECK THIS XXX
1003: */
1004:
1005: if (current->protection != old_prot) {
1006:
1007: #define MASK(entry) ((entry)->copy_on_write ? ~VM_PROT_WRITE : \
1008: VM_PROT_ALL)
1009: #define max(a,b) ((a) > (b) ? (a) : (b))
1010:
1011: if (current->is_a_map) {
1012: vm_map_entry_t share_entry;
1013: vm_offset_t share_end;
1014:
1015: vm_map_lock(current->object.share_map);
1016: (void) vm_map_lookup_entry(
1017: current->object.share_map,
1018: current->offset,
1019: &share_entry);
1020: share_end = current->offset +
1021: (current->end - current->start);
1022: while ((share_entry !=
1023: ¤t->object.share_map->header) &&
1024: (share_entry->start < share_end)) {
1025:
1026: pmap_protect(map->pmap,
1027: (max(share_entry->start,
1028: current->offset) -
1029: current->offset +
1030: current->start),
1031: min(share_entry->end,
1032: share_end) -
1033: current->offset +
1034: current->start,
1035: current->protection &
1036: MASK(share_entry));
1037:
1038: share_entry = share_entry->next;
1039: }
1040: vm_map_unlock(current->object.share_map);
1041: }
1042: else
1043: pmap_protect(map->pmap, current->start,
1044: current->end,
1045: current->protection & MASK(entry));
1046: #undef max
1047: #undef MASK
1048: }
1049: current = current->next;
1050: }
1051:
1052: vm_map_unlock(map);
1053: return(KERN_SUCCESS);
1054: }
1055:
1056: /*
1057: * vm_map_inherit:
1058: *
1059: * Sets the inheritance of the specified address
1060: * range in the target map. Inheritance
1061: * affects how the map will be shared with
1062: * child maps at the time of vm_map_fork.
1063: */
1064: vm_map_inherit(map, start, end, new_inheritance)
1065: register vm_map_t map;
1066: register vm_offset_t start;
1067: register vm_offset_t end;
1068: register vm_inherit_t new_inheritance;
1069: {
1070: register vm_map_entry_t entry;
1071: vm_map_entry_t temp_entry;
1072:
1073: switch (new_inheritance) {
1074: case VM_INHERIT_NONE:
1075: case VM_INHERIT_COPY:
1076: case VM_INHERIT_SHARE:
1077: break;
1078: default:
1079: return(KERN_INVALID_ARGUMENT);
1080: }
1081:
1082: vm_map_lock(map);
1083:
1084: VM_MAP_RANGE_CHECK(map, start, end);
1085:
1086: if (vm_map_lookup_entry(map, start, &temp_entry)) {
1087: entry = temp_entry;
1088: vm_map_clip_start(map, entry, start);
1089: }
1090: else
1091: entry = temp_entry->next;
1092:
1093: while ((entry != &map->header) && (entry->start < end)) {
1094: vm_map_clip_end(map, entry, end);
1095:
1096: entry->inheritance = new_inheritance;
1097:
1098: entry = entry->next;
1099: }
1100:
1101: vm_map_unlock(map);
1102: return(KERN_SUCCESS);
1103: }
1104:
1105: /*
1106: * vm_map_pageable:
1107: *
1108: * Sets the pageability of the specified address
1109: * range in the target map. Regions specified
1110: * as not pageable require locked-down physical
1111: * memory and physical page maps.
1112: *
1113: * The map must not be locked, but a reference
1114: * must remain to the map throughout the call.
1115: */
1116: vm_map_pageable(map, start, end, new_pageable)
1117: register vm_map_t map;
1118: register vm_offset_t start;
1119: register vm_offset_t end;
1120: register boolean_t new_pageable;
1121: {
1122: register vm_map_entry_t entry;
1123: vm_map_entry_t temp_entry;
1124:
1125: vm_map_lock(map);
1126:
1127: VM_MAP_RANGE_CHECK(map, start, end);
1128:
1129: /*
1130: * Only one pageability change may take place at one
1131: * time, since vm_fault assumes it will be called
1132: * only once for each wiring/unwiring. Therefore, we
1133: * have to make sure we're actually changing the pageability
1134: * for the entire region. We do so before making any changes.
1135: */
1136:
1137: if (vm_map_lookup_entry(map, start, &temp_entry)) {
1138: entry = temp_entry;
1139: vm_map_clip_start(map, entry, start);
1140: }
1141: else
1142: entry = temp_entry->next;
1143: temp_entry = entry;
1144:
1145: /*
1146: * Actions are rather different for wiring and unwiring,
1147: * so we have two separate cases.
1148: */
1149:
1150: if (new_pageable) {
1151:
1152: /*
1153: * Unwiring. First ensure that the range to be
1154: * unwired is really wired down.
1155: */
1156: while ((entry != &map->header) && (entry->start < end)) {
1157:
1158: if (entry->wired_count == 0) {
1159: vm_map_unlock(map);
1160: return(KERN_INVALID_ARGUMENT);
1161: }
1162: entry = entry->next;
1163: }
1164:
1165: /*
1166: * Now decrement the wiring count for each region.
1167: * If a region becomes completely unwired,
1168: * unwire its physical pages and mappings.
1169: */
1170: lock_set_recursive(&map->lock);
1171:
1172: entry = temp_entry;
1173: while ((entry != &map->header) && (entry->start < end)) {
1174: vm_map_clip_end(map, entry, end);
1175:
1176: entry->wired_count--;
1177: if (entry->wired_count == 0)
1178: vm_fault_unwire(map, entry->start, entry->end);
1179:
1180: entry = entry->next;
1181: }
1182: lock_clear_recursive(&map->lock);
1183: }
1184:
1185: else {
1186: /*
1187: * Wiring. We must do this in two passes:
1188: *
1189: * 1. Holding the write lock, we increment the
1190: * wiring count. For any area that is not already
1191: * wired, we create any shadow objects that need
1192: * to be created.
1193: *
1194: * 2. We downgrade to a read lock, and call
1195: * vm_fault_wire to fault in the pages for any
1196: * newly wired area (wired_count is 1).
1197: *
1198: * Downgrading to a read lock for vm_fault_wire avoids
1199: * a possible deadlock with another thread that may have
1200: * faulted on one of the pages to be wired (it would mark
1201: * the page busy, blocking us, then in turn block on the
1202: * map lock that we hold). Because of problems in the
1203: * recursive lock package, we cannot upgrade to a write
1204: * lock in vm_map_lookup. Thus, any actions that require
1205: * the write lock must be done beforehand. Because we
1206: * keep the read lock on the map, the copy-on-write status
1207: * of the entries we modify here cannot change.
1208: */
1209:
1210: /*
1211: * Pass 1.
1212: */
1213: entry = temp_entry;
1214: while ((entry != &map->header) && (entry->start < end)) {
1215: vm_map_clip_end(map, entry, end);
1216:
1217: entry->wired_count++;
1218: if (entry->wired_count == 1) {
1219:
1220: /*
1221: * Perform actions of vm_map_lookup that need
1222: * the write lock on the map: create a shadow
1223: * object for a copy-on-write region, or an
1224: * object for a zero-fill region.
1225: *
1226: * We don't have to do this for entries that
1227: * point to sharing maps, because we won't hold
1228: * the lock on the sharing map.
1229: */
1230: if (!entry->is_a_map) {
1231: if (entry->needs_copy &&
1232: ((entry->protection & VM_PROT_WRITE) != 0)) {
1233:
1234: vm_object_shadow(&entry->object.vm_object,
1235: &entry->offset,
1236: (vm_size_t)(entry->end
1237: - entry->start));
1238: entry->needs_copy = FALSE;
1239: }
1240: else if (entry->object.vm_object == NULL) {
1241: entry->object.vm_object =
1242: vm_object_allocate((vm_size_t)(entry->end
1243: - entry->start));
1244: entry->offset = (vm_offset_t)0;
1245: }
1246: }
1247: }
1248:
1249: entry = entry->next;
1250: }
1251:
1252: /*
1253: * Pass 2.
1254: */
1255:
1256: /*
1257: * HACK HACK HACK HACK
1258: *
1259: * If we are wiring in the kernel map or a submap of it,
1260: * unlock the map to avoid deadlocks. We trust that the
1261: * kernel threads are well-behaved, and therefore will
1262: * not do anything destructive to this region of the map
1263: * while we have it unlocked. We cannot trust user threads
1264: * to do the same.
1265: *
1266: * HACK HACK HACK HACK
1267: */
1268: if (vm_map_pmap(map) == kernel_pmap) {
1269: vm_map_unlock(map); /* trust me ... */
1270: }
1271: else {
1272: lock_set_recursive(&map->lock);
1273: lock_write_to_read(&map->lock);
1274: }
1275:
1276: entry = temp_entry;
1277: while (entry != &map->header && entry->start < end) {
1278: if (entry->wired_count == 1) {
1279: vm_fault_wire(map, entry->start, entry->end);
1280: }
1281: entry = entry->next;
1282: }
1283:
1284: if (vm_map_pmap(map) == kernel_pmap) {
1285: vm_map_lock(map);
1286: }
1287: else {
1288: lock_clear_recursive(&map->lock);
1289: }
1290: }
1291:
1292: vm_map_unlock(map);
1293:
1294: return(KERN_SUCCESS);
1295: }
1296:
1297: /*
1298: * vm_map_entry_unwire: [ internal use only ]
1299: *
1300: * Make the region specified by this entry pageable.
1301: *
1302: * The map in question should be locked.
1303: * [This is the reason for this routine's existence.]
1304: */
1305: void vm_map_entry_unwire(map, entry)
1306: vm_map_t map;
1307: register vm_map_entry_t entry;
1308: {
1309: vm_fault_unwire(map, entry->start, entry->end);
1310: entry->wired_count = 0;
1311: }
1312:
1313: /*
1314: * vm_map_entry_delete: [ internal use only ]
1315: *
1316: * Deallocate the given entry from the target map.
1317: */
1318: void vm_map_entry_delete(map, entry)
1319: register vm_map_t map;
1320: register vm_map_entry_t entry;
1321: {
1322: if (entry->wired_count != 0)
1323: vm_map_entry_unwire(map, entry);
1324:
1325: vm_map_entry_unlink(map, entry);
1326: map->size -= entry->end - entry->start;
1327:
1328: if (entry->is_a_map || entry->is_sub_map)
1329: vm_map_deallocate(entry->object.share_map);
1330: else
1331: vm_object_deallocate(entry->object.vm_object);
1332:
1333: vm_map_entry_dispose(map, entry);
1334: }
1335:
1336: /*
1337: * vm_map_delete: [ internal use only ]
1338: *
1339: * Deallocates the given address range from the target
1340: * map.
1341: *
1342: * When called with a sharing map, removes pages from
1343: * that region from all physical maps.
1344: */
1345: vm_map_delete(map, start, end)
1346: register vm_map_t map;
1347: vm_offset_t start;
1348: register vm_offset_t end;
1349: {
1350: register vm_map_entry_t entry;
1351: vm_map_entry_t first_entry;
1352:
1353: /*
1354: * Find the start of the region, and clip it
1355: */
1356:
1357: if (!vm_map_lookup_entry(map, start, &first_entry))
1358: entry = first_entry->next;
1359: else {
1360: entry = first_entry;
1361: vm_map_clip_start(map, entry, start);
1362:
1363: /*
1364: * Fix the lookup hint now, rather than each
1365: * time though the loop.
1366: */
1367:
1368: SAVE_HINT(map, entry->prev);
1369: }
1370:
1371: /*
1372: * Save the free space hint
1373: */
1374:
1375: if (map->first_free->start >= start)
1376: map->first_free = entry->prev;
1377:
1378: /*
1379: * Step through all entries in this region
1380: */
1381:
1382: while ((entry != &map->header) && (entry->start < end)) {
1383: vm_map_entry_t next;
1384: register vm_offset_t s, e;
1385: register vm_object_t object;
1386:
1387: vm_map_clip_end(map, entry, end);
1388:
1389: next = entry->next;
1390: s = entry->start;
1391: e = entry->end;
1392:
1393: /*
1394: * Unwire before removing addresses from the pmap;
1395: * otherwise, unwiring will put the entries back in
1396: * the pmap.
1397: */
1398:
1399: object = entry->object.vm_object;
1400: if (entry->wired_count != 0)
1401: vm_map_entry_unwire(map, entry);
1402:
1403: /*
1404: * If this is a sharing map, we must remove
1405: * *all* references to this data, since we can't
1406: * find all of the physical maps which are sharing
1407: * it.
1408: */
1409:
1410: if (object == kernel_object || object == kmem_object)
1411: vm_object_page_remove(object, entry->offset,
1412: entry->offset + (e - s));
1413: else if (!map->is_main_map)
1414: vm_object_pmap_remove(object,
1415: entry->offset,
1416: entry->offset + (e - s));
1417: else
1418: pmap_remove(map->pmap, s, e);
1419:
1420: /*
1421: * Delete the entry (which may delete the object)
1422: * only after removing all pmap entries pointing
1423: * to its pages. (Otherwise, its page frames may
1424: * be reallocated, and any modify bits will be
1425: * set in the wrong object!)
1426: */
1427:
1428: vm_map_entry_delete(map, entry);
1429: entry = next;
1430: }
1431: return(KERN_SUCCESS);
1432: }
1433:
1434: /*
1435: * vm_map_remove:
1436: *
1437: * Remove the given address range from the target map.
1438: * This is the exported form of vm_map_delete.
1439: */
1440: vm_map_remove(map, start, end)
1441: register vm_map_t map;
1442: register vm_offset_t start;
1443: register vm_offset_t end;
1444: {
1445: register int result;
1446:
1447: vm_map_lock(map);
1448: VM_MAP_RANGE_CHECK(map, start, end);
1449: result = vm_map_delete(map, start, end);
1450: vm_map_unlock(map);
1451:
1452: return(result);
1453: }
1454:
1455: /*
1456: * vm_map_check_protection:
1457: *
1458: * Assert that the target map allows the specified
1459: * privilege on the entire address region given.
1460: * The entire region must be allocated.
1461: */
1462: boolean_t vm_map_check_protection(map, start, end, protection)
1463: register vm_map_t map;
1464: register vm_offset_t start;
1465: register vm_offset_t end;
1466: register vm_prot_t protection;
1467: {
1468: register vm_map_entry_t entry;
1469: vm_map_entry_t tmp_entry;
1470:
1471: if (!vm_map_lookup_entry(map, start, &tmp_entry)) {
1472: return(FALSE);
1473: }
1474:
1475: entry = tmp_entry;
1476:
1477: while (start < end) {
1478: if (entry == &map->header) {
1479: return(FALSE);
1480: }
1481:
1482: /*
1483: * No holes allowed!
1484: */
1485:
1486: if (start < entry->start) {
1487: return(FALSE);
1488: }
1489:
1490: /*
1491: * Check protection associated with entry.
1492: */
1493:
1494: if ((entry->protection & protection) != protection) {
1495: return(FALSE);
1496: }
1497:
1498: /* go to next entry */
1499:
1500: start = entry->end;
1501: entry = entry->next;
1502: }
1503: return(TRUE);
1504: }
1505:
1506: /*
1507: * vm_map_copy_entry:
1508: *
1509: * Copies the contents of the source entry to the destination
1510: * entry. The entries *must* be aligned properly.
1511: */
1512: void vm_map_copy_entry(src_map, dst_map, src_entry, dst_entry)
1513: vm_map_t src_map, dst_map;
1514: register vm_map_entry_t src_entry, dst_entry;
1515: {
1516: vm_object_t temp_object;
1517:
1518: if (src_entry->is_sub_map || dst_entry->is_sub_map)
1519: return;
1520:
1521: if (dst_entry->object.vm_object != NULL &&
1522: !dst_entry->object.vm_object->internal)
1523: printf("vm_map_copy_entry: copying over permanent data!\n");
1524:
1525: /*
1526: * If our destination map was wired down,
1527: * unwire it now.
1528: */
1529:
1530: if (dst_entry->wired_count != 0)
1531: vm_map_entry_unwire(dst_map, dst_entry);
1532:
1533: /*
1534: * If we're dealing with a sharing map, we
1535: * must remove the destination pages from
1536: * all maps (since we cannot know which maps
1537: * this sharing map belongs in).
1538: */
1539:
1540: if (dst_map->is_main_map)
1541: pmap_remove(dst_map->pmap, dst_entry->start, dst_entry->end);
1542: else
1543: vm_object_pmap_remove(dst_entry->object.vm_object,
1544: dst_entry->offset,
1545: dst_entry->offset +
1546: (dst_entry->end - dst_entry->start));
1547:
1548: if (src_entry->wired_count == 0) {
1549:
1550: boolean_t src_needs_copy;
1551:
1552: /*
1553: * If the source entry is marked needs_copy,
1554: * it is already write-protected.
1555: */
1556: if (!src_entry->needs_copy) {
1557:
1558: boolean_t su;
1559:
1560: /*
1561: * If the source entry has only one mapping,
1562: * we can just protect the virtual address
1563: * range.
1564: */
1565: if (!(su = src_map->is_main_map)) {
1566: simple_lock(&src_map->ref_lock);
1567: su = (src_map->ref_count == 1);
1568: simple_unlock(&src_map->ref_lock);
1569: }
1570:
1571: if (su) {
1572: pmap_protect(src_map->pmap,
1573: src_entry->start,
1574: src_entry->end,
1575: src_entry->protection & ~VM_PROT_WRITE);
1576: }
1577: else {
1578: vm_object_pmap_copy(src_entry->object.vm_object,
1579: src_entry->offset,
1580: src_entry->offset + (src_entry->end
1581: -src_entry->start));
1582: }
1583: }
1584:
1585: /*
1586: * Make a copy of the object.
1587: */
1588: temp_object = dst_entry->object.vm_object;
1589: vm_object_copy(src_entry->object.vm_object,
1590: src_entry->offset,
1591: (vm_size_t)(src_entry->end -
1592: src_entry->start),
1593: &dst_entry->object.vm_object,
1594: &dst_entry->offset,
1595: &src_needs_copy);
1596: /*
1597: * If we didn't get a copy-object now, mark the
1598: * source map entry so that a shadow will be created
1599: * to hold its changed pages.
1600: */
1601: if (src_needs_copy)
1602: src_entry->needs_copy = TRUE;
1603:
1604: /*
1605: * The destination always needs to have a shadow
1606: * created.
1607: */
1608: dst_entry->needs_copy = TRUE;
1609:
1610: /*
1611: * Mark the entries copy-on-write, so that write-enabling
1612: * the entry won't make copy-on-write pages writable.
1613: */
1614: src_entry->copy_on_write = TRUE;
1615: dst_entry->copy_on_write = TRUE;
1616: /*
1617: * Get rid of the old object.
1618: */
1619: vm_object_deallocate(temp_object);
1620:
1621: pmap_copy(dst_map->pmap, src_map->pmap, dst_entry->start,
1622: dst_entry->end - dst_entry->start, src_entry->start);
1623: }
1624: else {
1625: /*
1626: * Of course, wired down pages can't be set copy-on-write.
1627: * Cause wired pages to be copied into the new
1628: * map by simulating faults (the new pages are
1629: * pageable)
1630: */
1631: vm_fault_copy_entry(dst_map, src_map, dst_entry, src_entry);
1632: }
1633: }
1634:
1635: /*
1636: * vm_map_copy:
1637: *
1638: * Perform a virtual memory copy from the source
1639: * address map/range to the destination map/range.
1640: *
1641: * If src_destroy or dst_alloc is requested,
1642: * the source and destination regions should be
1643: * disjoint, not only in the top-level map, but
1644: * in the sharing maps as well. [The best way
1645: * to guarantee this is to use a new intermediate
1646: * map to make copies. This also reduces map
1647: * fragmentation.]
1648: */
1649: vm_map_copy(dst_map, src_map,
1650: dst_addr, len, src_addr,
1651: dst_alloc, src_destroy)
1652: vm_map_t dst_map;
1653: vm_map_t src_map;
1654: vm_offset_t dst_addr;
1655: vm_size_t len;
1656: vm_offset_t src_addr;
1657: boolean_t dst_alloc;
1658: boolean_t src_destroy;
1659: {
1660: register
1661: vm_map_entry_t src_entry;
1662: register
1663: vm_map_entry_t dst_entry;
1664: vm_map_entry_t tmp_entry;
1665: vm_offset_t src_start;
1666: vm_offset_t src_end;
1667: vm_offset_t dst_start;
1668: vm_offset_t dst_end;
1669: vm_offset_t src_clip;
1670: vm_offset_t dst_clip;
1671: int result;
1672: boolean_t old_src_destroy;
1673:
1674: /*
1675: * XXX While we figure out why src_destroy screws up,
1676: * we'll do it by explicitly vm_map_delete'ing at the end.
1677: */
1678:
1679: old_src_destroy = src_destroy;
1680: src_destroy = FALSE;
1681:
1682: /*
1683: * Compute start and end of region in both maps
1684: */
1685:
1686: src_start = src_addr;
1687: src_end = src_start + len;
1688: dst_start = dst_addr;
1689: dst_end = dst_start + len;
1690:
1691: /*
1692: * Check that the region can exist in both source
1693: * and destination.
1694: */
1695:
1696: if ((dst_end < dst_start) || (src_end < src_start))
1697: return(KERN_NO_SPACE);
1698:
1699: /*
1700: * Lock the maps in question -- we avoid deadlock
1701: * by ordering lock acquisition by map value
1702: */
1703:
1704: if (src_map == dst_map) {
1705: vm_map_lock(src_map);
1706: }
1707: else if ((int) src_map < (int) dst_map) {
1708: vm_map_lock(src_map);
1709: vm_map_lock(dst_map);
1710: } else {
1711: vm_map_lock(dst_map);
1712: vm_map_lock(src_map);
1713: }
1714:
1715: result = KERN_SUCCESS;
1716:
1717: /*
1718: * Check protections... source must be completely readable and
1719: * destination must be completely writable. [Note that if we're
1720: * allocating the destination region, we don't have to worry
1721: * about protection, but instead about whether the region
1722: * exists.]
1723: */
1724:
1725: if (src_map->is_main_map && dst_map->is_main_map) {
1726: if (!vm_map_check_protection(src_map, src_start, src_end,
1727: VM_PROT_READ)) {
1728: result = KERN_PROTECTION_FAILURE;
1729: goto Return;
1730: }
1731:
1732: if (dst_alloc) {
1733: /* XXX Consider making this a vm_map_find instead */
1734: if ((result = vm_map_insert(dst_map, NULL,
1735: (vm_offset_t) 0, dst_start, dst_end)) != KERN_SUCCESS)
1736: goto Return;
1737: }
1738: else if (!vm_map_check_protection(dst_map, dst_start, dst_end,
1739: VM_PROT_WRITE)) {
1740: result = KERN_PROTECTION_FAILURE;
1741: goto Return;
1742: }
1743: }
1744:
1745: /*
1746: * Find the start entries and clip.
1747: *
1748: * Note that checking protection asserts that the
1749: * lookup cannot fail.
1750: *
1751: * Also note that we wait to do the second lookup
1752: * until we have done the first clip, as the clip
1753: * may affect which entry we get!
1754: */
1755:
1756: (void) vm_map_lookup_entry(src_map, src_addr, &tmp_entry);
1757: src_entry = tmp_entry;
1758: vm_map_clip_start(src_map, src_entry, src_start);
1759:
1760: (void) vm_map_lookup_entry(dst_map, dst_addr, &tmp_entry);
1761: dst_entry = tmp_entry;
1762: vm_map_clip_start(dst_map, dst_entry, dst_start);
1763:
1764: /*
1765: * If both source and destination entries are the same,
1766: * retry the first lookup, as it may have changed.
1767: */
1768:
1769: if (src_entry == dst_entry) {
1770: (void) vm_map_lookup_entry(src_map, src_addr, &tmp_entry);
1771: src_entry = tmp_entry;
1772: }
1773:
1774: /*
1775: * If source and destination entries are still the same,
1776: * a null copy is being performed.
1777: */
1778:
1779: if (src_entry == dst_entry)
1780: goto Return;
1781:
1782: /*
1783: * Go through entries until we get to the end of the
1784: * region.
1785: */
1786:
1787: while (src_start < src_end) {
1788: /*
1789: * Clip the entries to the endpoint of the entire region.
1790: */
1791:
1792: vm_map_clip_end(src_map, src_entry, src_end);
1793: vm_map_clip_end(dst_map, dst_entry, dst_end);
1794:
1795: /*
1796: * Clip each entry to the endpoint of the other entry.
1797: */
1798:
1799: src_clip = src_entry->start + (dst_entry->end - dst_entry->start);
1800: vm_map_clip_end(src_map, src_entry, src_clip);
1801:
1802: dst_clip = dst_entry->start + (src_entry->end - src_entry->start);
1803: vm_map_clip_end(dst_map, dst_entry, dst_clip);
1804:
1805: /*
1806: * Both entries now match in size and relative endpoints.
1807: *
1808: * If both entries refer to a VM object, we can
1809: * deal with them now.
1810: */
1811:
1812: if (!src_entry->is_a_map && !dst_entry->is_a_map) {
1813: vm_map_copy_entry(src_map, dst_map, src_entry,
1814: dst_entry);
1815: }
1816: else {
1817: register vm_map_t new_dst_map;
1818: vm_offset_t new_dst_start;
1819: vm_size_t new_size;
1820: vm_map_t new_src_map;
1821: vm_offset_t new_src_start;
1822:
1823: /*
1824: * We have to follow at least one sharing map.
1825: */
1826:
1827: new_size = (dst_entry->end - dst_entry->start);
1828:
1829: if (src_entry->is_a_map) {
1830: new_src_map = src_entry->object.share_map;
1831: new_src_start = src_entry->offset;
1832: }
1833: else {
1834: new_src_map = src_map;
1835: new_src_start = src_entry->start;
1836: lock_set_recursive(&src_map->lock);
1837: }
1838:
1839: if (dst_entry->is_a_map) {
1840: vm_offset_t new_dst_end;
1841:
1842: new_dst_map = dst_entry->object.share_map;
1843: new_dst_start = dst_entry->offset;
1844:
1845: /*
1846: * Since the destination sharing entries
1847: * will be merely deallocated, we can
1848: * do that now, and replace the region
1849: * with a null object. [This prevents
1850: * splitting the source map to match
1851: * the form of the destination map.]
1852: * Note that we can only do so if the
1853: * source and destination do not overlap.
1854: */
1855:
1856: new_dst_end = new_dst_start + new_size;
1857:
1858: if (new_dst_map != new_src_map) {
1859: vm_map_lock(new_dst_map);
1860: (void) vm_map_delete(new_dst_map,
1861: new_dst_start,
1862: new_dst_end);
1863: (void) vm_map_insert(new_dst_map,
1864: NULL,
1865: (vm_offset_t) 0,
1866: new_dst_start,
1867: new_dst_end);
1868: vm_map_unlock(new_dst_map);
1869: }
1870: }
1871: else {
1872: new_dst_map = dst_map;
1873: new_dst_start = dst_entry->start;
1874: lock_set_recursive(&dst_map->lock);
1875: }
1876:
1877: /*
1878: * Recursively copy the sharing map.
1879: */
1880:
1881: (void) vm_map_copy(new_dst_map, new_src_map,
1882: new_dst_start, new_size, new_src_start,
1883: FALSE, FALSE);
1884:
1885: if (dst_map == new_dst_map)
1886: lock_clear_recursive(&dst_map->lock);
1887: if (src_map == new_src_map)
1888: lock_clear_recursive(&src_map->lock);
1889: }
1890:
1891: /*
1892: * Update variables for next pass through the loop.
1893: */
1894:
1895: src_start = src_entry->end;
1896: src_entry = src_entry->next;
1897: dst_start = dst_entry->end;
1898: dst_entry = dst_entry->next;
1899:
1900: /*
1901: * If the source is to be destroyed, here is the
1902: * place to do it.
1903: */
1904:
1905: if (src_destroy && src_map->is_main_map &&
1906: dst_map->is_main_map)
1907: vm_map_entry_delete(src_map, src_entry->prev);
1908: }
1909:
1910: /*
1911: * Update the physical maps as appropriate
1912: */
1913:
1914: if (src_map->is_main_map && dst_map->is_main_map) {
1915: if (src_destroy)
1916: pmap_remove(src_map->pmap, src_addr, src_addr + len);
1917: }
1918:
1919: /*
1920: * Unlock the maps
1921: */
1922:
1923: Return: ;
1924:
1925: if (old_src_destroy)
1926: vm_map_delete(src_map, src_addr, src_addr + len);
1927:
1928: vm_map_unlock(src_map);
1929: if (src_map != dst_map)
1930: vm_map_unlock(dst_map);
1931:
1932: return(result);
1933: }
1934:
1935: /*
1936: * vmspace_fork:
1937: * Create a new process vmspace structure and vm_map
1938: * based on those of an existing process. The new map
1939: * is based on the old map, according to the inheritance
1940: * values on the regions in that map.
1941: *
1942: * The source map must not be locked.
1943: */
1944: struct vmspace *
1945: vmspace_fork(vm1)
1946: register struct vmspace *vm1;
1947: {
1948: register struct vmspace *vm2;
1949: vm_map_t old_map = &vm1->vm_map;
1950: vm_map_t new_map;
1951: vm_map_entry_t old_entry;
1952: vm_map_entry_t new_entry;
1953: pmap_t new_pmap;
1954:
1955: vm_map_lock(old_map);
1956:
1957: vm2 = vmspace_alloc(old_map->min_offset, old_map->max_offset,
1958: old_map->entries_pageable);
1959: bcopy(&vm1->vm_startcopy, &vm2->vm_startcopy,
1960: (caddr_t) (vm1 + 1) - (caddr_t) &vm1->vm_startcopy);
1961: new_pmap = &vm2->vm_pmap; /* XXX */
1962: new_map = &vm2->vm_map; /* XXX */
1963:
1964: old_entry = old_map->header.next;
1965:
1966: while (old_entry != &old_map->header) {
1967: if (old_entry->is_sub_map)
1968: panic("vm_map_fork: encountered a submap");
1969:
1970: switch (old_entry->inheritance) {
1971: case VM_INHERIT_NONE:
1972: break;
1973:
1974: case VM_INHERIT_SHARE:
1975: /*
1976: * If we don't already have a sharing map:
1977: */
1978:
1979: if (!old_entry->is_a_map) {
1980: vm_map_t new_share_map;
1981: vm_map_entry_t new_share_entry;
1982:
1983: /*
1984: * Create a new sharing map
1985: */
1986:
1987: new_share_map = vm_map_create(NULL,
1988: old_entry->start,
1989: old_entry->end,
1990: TRUE);
1991: new_share_map->is_main_map = FALSE;
1992:
1993: /*
1994: * Create the only sharing entry from the
1995: * old task map entry.
1996: */
1997:
1998: new_share_entry =
1999: vm_map_entry_create(new_share_map);
2000: *new_share_entry = *old_entry;
2001:
2002: /*
2003: * Insert the entry into the new sharing
2004: * map
2005: */
2006:
2007: vm_map_entry_link(new_share_map,
2008: new_share_map->header.prev,
2009: new_share_entry);
2010:
2011: /*
2012: * Fix up the task map entry to refer
2013: * to the sharing map now.
2014: */
2015:
2016: old_entry->is_a_map = TRUE;
2017: old_entry->object.share_map = new_share_map;
2018: old_entry->offset = old_entry->start;
2019: }
2020:
2021: /*
2022: * Clone the entry, referencing the sharing map.
2023: */
2024:
2025: new_entry = vm_map_entry_create(new_map);
2026: *new_entry = *old_entry;
2027: vm_map_reference(new_entry->object.share_map);
2028:
2029: /*
2030: * Insert the entry into the new map -- we
2031: * know we're inserting at the end of the new
2032: * map.
2033: */
2034:
2035: vm_map_entry_link(new_map, new_map->header.prev,
2036: new_entry);
2037:
2038: /*
2039: * Update the physical map
2040: */
2041:
2042: pmap_copy(new_map->pmap, old_map->pmap,
2043: new_entry->start,
2044: (old_entry->end - old_entry->start),
2045: old_entry->start);
2046: break;
2047:
2048: case VM_INHERIT_COPY:
2049: /*
2050: * Clone the entry and link into the map.
2051: */
2052:
2053: new_entry = vm_map_entry_create(new_map);
2054: *new_entry = *old_entry;
2055: new_entry->wired_count = 0;
2056: new_entry->object.vm_object = NULL;
2057: new_entry->is_a_map = FALSE;
2058: vm_map_entry_link(new_map, new_map->header.prev,
2059: new_entry);
2060: if (old_entry->is_a_map) {
2061: int check;
2062:
2063: check = vm_map_copy(new_map,
2064: old_entry->object.share_map,
2065: new_entry->start,
2066: (vm_size_t)(new_entry->end -
2067: new_entry->start),
2068: old_entry->offset,
2069: FALSE, FALSE);
2070: if (check != KERN_SUCCESS)
2071: printf("vm_map_fork: copy in share_map region failed\n");
2072: }
2073: else {
2074: vm_map_copy_entry(old_map, new_map, old_entry,
2075: new_entry);
2076: }
2077: break;
2078: }
2079: old_entry = old_entry->next;
2080: }
2081:
2082: new_map->size = old_map->size;
2083: vm_map_unlock(old_map);
2084:
2085: return(vm2);
2086: }
2087:
2088: /*
2089: * vm_map_lookup:
2090: *
2091: * Finds the VM object, offset, and
2092: * protection for a given virtual address in the
2093: * specified map, assuming a page fault of the
2094: * type specified.
2095: *
2096: * Leaves the map in question locked for read; return
2097: * values are guaranteed until a vm_map_lookup_done
2098: * call is performed. Note that the map argument
2099: * is in/out; the returned map must be used in
2100: * the call to vm_map_lookup_done.
2101: *
2102: * A handle (out_entry) is returned for use in
2103: * vm_map_lookup_done, to make that fast.
2104: *
2105: * If a lookup is requested with "write protection"
2106: * specified, the map may be changed to perform virtual
2107: * copying operations, although the data referenced will
2108: * remain the same.
2109: */
2110: vm_map_lookup(var_map, vaddr, fault_type, out_entry,
2111: object, offset, out_prot, wired, single_use)
2112: vm_map_t *var_map; /* IN/OUT */
2113: register vm_offset_t vaddr;
2114: register vm_prot_t fault_type;
2115:
2116: vm_map_entry_t *out_entry; /* OUT */
2117: vm_object_t *object; /* OUT */
2118: vm_offset_t *offset; /* OUT */
2119: vm_prot_t *out_prot; /* OUT */
2120: boolean_t *wired; /* OUT */
2121: boolean_t *single_use; /* OUT */
2122: {
2123: vm_map_t share_map;
2124: vm_offset_t share_offset;
2125: register vm_map_entry_t entry;
2126: register vm_map_t map = *var_map;
2127: register vm_prot_t prot;
2128: register boolean_t su;
2129:
2130: RetryLookup: ;
2131:
2132: /*
2133: * Lookup the faulting address.
2134: */
2135:
2136: vm_map_lock_read(map);
2137:
2138: #define RETURN(why) \
2139: { \
2140: vm_map_unlock_read(map); \
2141: return(why); \
2142: }
2143:
2144: /*
2145: * If the map has an interesting hint, try it before calling
2146: * full blown lookup routine.
2147: */
2148:
2149: simple_lock(&map->hint_lock);
2150: entry = map->hint;
2151: simple_unlock(&map->hint_lock);
2152:
2153: *out_entry = entry;
2154:
2155: if ((entry == &map->header) ||
2156: (vaddr < entry->start) || (vaddr >= entry->end)) {
2157: vm_map_entry_t tmp_entry;
2158:
2159: /*
2160: * Entry was either not a valid hint, or the vaddr
2161: * was not contained in the entry, so do a full lookup.
2162: */
2163: if (!vm_map_lookup_entry(map, vaddr, &tmp_entry))
2164: RETURN(KERN_INVALID_ADDRESS);
2165:
2166: entry = tmp_entry;
2167: *out_entry = entry;
2168: }
2169:
2170: /*
2171: * Handle submaps.
2172: */
2173:
2174: if (entry->is_sub_map) {
2175: vm_map_t old_map = map;
2176:
2177: *var_map = map = entry->object.sub_map;
2178: vm_map_unlock_read(old_map);
2179: goto RetryLookup;
2180: }
2181:
2182: /*
2183: * Check whether this task is allowed to have
2184: * this page.
2185: */
2186:
2187: prot = entry->protection;
2188: if ((fault_type & (prot)) != fault_type)
2189: RETURN(KERN_PROTECTION_FAILURE);
2190:
2191: /*
2192: * If this page is not pageable, we have to get
2193: * it for all possible accesses.
2194: */
2195:
2196: if (*wired = (entry->wired_count != 0))
2197: prot = fault_type = entry->protection;
2198:
2199: /*
2200: * If we don't already have a VM object, track
2201: * it down.
2202: */
2203:
2204: if (su = !entry->is_a_map) {
2205: share_map = map;
2206: share_offset = vaddr;
2207: }
2208: else {
2209: vm_map_entry_t share_entry;
2210:
2211: /*
2212: * Compute the sharing map, and offset into it.
2213: */
2214:
2215: share_map = entry->object.share_map;
2216: share_offset = (vaddr - entry->start) + entry->offset;
2217:
2218: /*
2219: * Look for the backing store object and offset
2220: */
2221:
2222: vm_map_lock_read(share_map);
2223:
2224: if (!vm_map_lookup_entry(share_map, share_offset,
2225: &share_entry)) {
2226: vm_map_unlock_read(share_map);
2227: RETURN(KERN_INVALID_ADDRESS);
2228: }
2229: entry = share_entry;
2230: }
2231:
2232: /*
2233: * If the entry was copy-on-write, we either ...
2234: */
2235:
2236: if (entry->needs_copy) {
2237: /*
2238: * If we want to write the page, we may as well
2239: * handle that now since we've got the sharing
2240: * map locked.
2241: *
2242: * If we don't need to write the page, we just
2243: * demote the permissions allowed.
2244: */
2245:
2246: if (fault_type & VM_PROT_WRITE) {
2247: /*
2248: * Make a new object, and place it in the
2249: * object chain. Note that no new references
2250: * have appeared -- one just moved from the
2251: * share map to the new object.
2252: */
2253:
2254: if (lock_read_to_write(&share_map->lock)) {
2255: if (share_map != map)
2256: vm_map_unlock_read(map);
2257: goto RetryLookup;
2258: }
2259:
2260: vm_object_shadow(
2261: &entry->object.vm_object,
2262: &entry->offset,
2263: (vm_size_t) (entry->end - entry->start));
2264:
2265: entry->needs_copy = FALSE;
2266:
2267: lock_write_to_read(&share_map->lock);
2268: }
2269: else {
2270: /*
2271: * We're attempting to read a copy-on-write
2272: * page -- don't allow writes.
2273: */
2274:
2275: prot &= (~VM_PROT_WRITE);
2276: }
2277: }
2278:
2279: /*
2280: * Create an object if necessary.
2281: */
2282: if (entry->object.vm_object == NULL) {
2283:
2284: if (lock_read_to_write(&share_map->lock)) {
2285: if (share_map != map)
2286: vm_map_unlock_read(map);
2287: goto RetryLookup;
2288: }
2289:
2290: entry->object.vm_object = vm_object_allocate(
2291: (vm_size_t)(entry->end - entry->start));
2292: entry->offset = 0;
2293: lock_write_to_read(&share_map->lock);
2294: }
2295:
2296: /*
2297: * Return the object/offset from this entry. If the entry
2298: * was copy-on-write or empty, it has been fixed up.
2299: */
2300:
2301: *offset = (share_offset - entry->start) + entry->offset;
2302: *object = entry->object.vm_object;
2303:
2304: /*
2305: * Return whether this is the only map sharing this data.
2306: */
2307:
2308: if (!su) {
2309: simple_lock(&share_map->ref_lock);
2310: su = (share_map->ref_count == 1);
2311: simple_unlock(&share_map->ref_lock);
2312: }
2313:
2314: *out_prot = prot;
2315: *single_use = su;
2316:
2317: return(KERN_SUCCESS);
2318:
2319: #undef RETURN
2320: }
2321:
2322: /*
2323: * vm_map_lookup_done:
2324: *
2325: * Releases locks acquired by a vm_map_lookup
2326: * (according to the handle returned by that lookup).
2327: */
2328:
2329: void vm_map_lookup_done(map, entry)
2330: register vm_map_t map;
2331: vm_map_entry_t entry;
2332: {
2333: /*
2334: * If this entry references a map, unlock it first.
2335: */
2336:
2337: if (entry->is_a_map)
2338: vm_map_unlock_read(entry->object.share_map);
2339:
2340: /*
2341: * Unlock the main-level map
2342: */
2343:
2344: vm_map_unlock_read(map);
2345: }
2346:
2347: /*
2348: * Routine: vm_map_simplify
2349: * Purpose:
2350: * Attempt to simplify the map representation in
2351: * the vicinity of the given starting address.
2352: * Note:
2353: * This routine is intended primarily to keep the
2354: * kernel maps more compact -- they generally don't
2355: * benefit from the "expand a map entry" technology
2356: * at allocation time because the adjacent entry
2357: * is often wired down.
2358: */
2359: void vm_map_simplify(map, start)
2360: vm_map_t map;
2361: vm_offset_t start;
2362: {
2363: vm_map_entry_t this_entry;
2364: vm_map_entry_t prev_entry;
2365:
2366: vm_map_lock(map);
2367: if (
2368: (vm_map_lookup_entry(map, start, &this_entry)) &&
2369: ((prev_entry = this_entry->prev) != &map->header) &&
2370:
2371: (prev_entry->end == start) &&
2372: (map->is_main_map) &&
2373:
2374: (prev_entry->is_a_map == FALSE) &&
2375: (prev_entry->is_sub_map == FALSE) &&
2376:
2377: (this_entry->is_a_map == FALSE) &&
2378: (this_entry->is_sub_map == FALSE) &&
2379:
2380: (prev_entry->inheritance == this_entry->inheritance) &&
2381: (prev_entry->protection == this_entry->protection) &&
2382: (prev_entry->max_protection == this_entry->max_protection) &&
2383: (prev_entry->wired_count == this_entry->wired_count) &&
2384:
2385: (prev_entry->copy_on_write == this_entry->copy_on_write) &&
2386: (prev_entry->needs_copy == this_entry->needs_copy) &&
2387:
2388: (prev_entry->object.vm_object == this_entry->object.vm_object) &&
2389: ((prev_entry->offset + (prev_entry->end - prev_entry->start))
2390: == this_entry->offset)
2391: ) {
2392: if (map->first_free == this_entry)
2393: map->first_free = prev_entry;
2394:
2395: SAVE_HINT(map, prev_entry);
2396: vm_map_entry_unlink(map, this_entry);
2397: prev_entry->end = this_entry->end;
2398: vm_object_deallocate(this_entry->object.vm_object);
2399: vm_map_entry_dispose(map, this_entry);
2400: }
2401: vm_map_unlock(map);
2402: }
2403:
2404: /*
2405: * vm_map_print: [ debug ]
2406: */
2407: void vm_map_print(map, full)
2408: register vm_map_t map;
2409: boolean_t full;
2410: {
2411: register vm_map_entry_t entry;
2412: extern int indent;
2413:
2414: iprintf("%s map 0x%x: pmap=0x%x,ref=%d,nentries=%d,version=%d\n",
2415: (map->is_main_map ? "Task" : "Share"),
2416: (int) map, (int) (map->pmap), map->ref_count, map->nentries,
2417: map->timestamp);
2418:
2419: if (!full && indent)
2420: return;
2421:
2422: indent += 2;
2423: for (entry = map->header.next; entry != &map->header;
2424: entry = entry->next) {
2425: iprintf("map entry 0x%x: start=0x%x, end=0x%x, ",
2426: (int) entry, (int) entry->start, (int) entry->end);
2427: if (map->is_main_map) {
2428: static char *inheritance_name[4] =
2429: { "share", "copy", "none", "donate_copy"};
2430: printf("prot=%x/%x/%s, ",
2431: entry->protection,
2432: entry->max_protection,
2433: inheritance_name[entry->inheritance]);
2434: if (entry->wired_count != 0)
2435: printf("wired, ");
2436: }
2437:
2438: if (entry->is_a_map || entry->is_sub_map) {
2439: printf("share=0x%x, offset=0x%x\n",
2440: (int) entry->object.share_map,
2441: (int) entry->offset);
2442: if ((entry->prev == &map->header) ||
2443: (!entry->prev->is_a_map) ||
2444: (entry->prev->object.share_map !=
2445: entry->object.share_map)) {
2446: indent += 2;
2447: vm_map_print(entry->object.share_map, full);
2448: indent -= 2;
2449: }
2450:
2451: }
2452: else {
2453: printf("object=0x%x, offset=0x%x",
2454: (int) entry->object.vm_object,
2455: (int) entry->offset);
2456: if (entry->copy_on_write)
2457: printf(", copy (%s)",
2458: entry->needs_copy ? "needed" : "done");
2459: printf("\n");
2460:
2461: if ((entry->prev == &map->header) ||
2462: (entry->prev->is_a_map) ||
2463: (entry->prev->object.vm_object !=
2464: entry->object.vm_object)) {
2465: indent += 2;
2466: vm_object_print(entry->object.vm_object, full);
2467: indent -= 2;
2468: }
2469: }
2470: }
2471: indent -= 2;
2472: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.