![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vm_map.h 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_map.h 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,1987 Carnegie Mellon University
28: * All Rights Reserved.
29: *
30: * Permission to use, copy, modify and distribute this software and its
31: * documentation is hereby granted, provided that both the copyright
32: * notice and this permission notice appear in all copies of the
33: * software, derivative works or modified versions, and any portions
34: * thereof, and that both notices appear in supporting documentation.
35: *
36: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
37: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
38: * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
39: *
40: * Carnegie Mellon requests users of this software to return to
41: *
42: * Software Distribution Coordinator or [email protected]
43: * School of Computer Science
44: * Carnegie Mellon University
45: * Pittsburgh PA 15213-3890
46: *
47: * any improvements or extensions that they make and grant Carnegie Mellon
48: * the rights to redistribute these changes.
49: */
50: /*
51: */
52:
53: /*
54: * File: vm/vm_map.h
55: * Author: Avadis Tevanian, Jr., Michael Wayne Young
56: * Date: 1985
57: *
58: * Virtual memory map module definitions.
59: *
60: * Contributors:
61: * avie, dlb, mwyoung
62: */
63:
64: #ifndef _VM_VM_MAP_H_
65: #define _VM_VM_MAP_H_
66:
67: #include <mach/mach_types.h>
68: #include <mach/kern_return.h>
69: #include <mach/boolean.h>
70: #include <mach/vm_types.h>
71: #include <mach/vm_prot.h>
72: #include <mach/vm_inherit.h>
73: #include <mach/vm_behavior.h>
74: #include <vm/pmap.h>
75:
76: typedef struct vm_map_entry *vm_map_entry_t;
77:
78: #ifndef MACH_KERNEL_PRIVATE
79:
80: struct vm_map_entry {};
81:
82: extern void vm_map_reference(vm_map_t map);
83: extern vm_map_t current_map(void);
84:
85: #else /* MACH_KERNEL_PRIVATE */
86:
87: #include <dipc.h>
88: #include <cpus.h>
89: #include <task_swapper.h>
90: #include <mach_assert.h>
91: #include <vm/vm_object.h>
92: #include <vm/vm_page.h>
93: #include <kern/lock.h>
94: #include <kern/zalloc.h>
95: #include <kern/macro_help.h>
96: #include <kern/thread_act.h>
97:
98: #define current_map_fast() (current_act_fast()->map)
99: #define current_map() (current_map_fast())
100:
101: /*
102: * Types defined:
103: *
104: * vm_map_t the high-level address map data structure.
105: * vm_map_entry_t an entry in an address map.
106: * vm_map_version_t a timestamp of a map, for use with vm_map_lookup
107: * vm_map_copy_t represents memory copied from an address map,
108: * used for inter-map copy operations
109: */
110:
111: /*
112: * Type: vm_map_object_t [internal use only]
113: *
114: * Description:
115: * The target of an address mapping, either a virtual
116: * memory object or a sub map (of the kernel map).
117: */
118: typedef union vm_map_object {
119: struct vm_object *vm_object; /* object object */
120: struct vm_map *sub_map; /* belongs to another map */
121: } vm_map_object_t;
122:
123: #define named_entry_lock_init(object) mutex_init(&(object)->Lock, ETAP_VM_OBJ)
124: #define named_entry_lock(object) mutex_lock(&(object)->Lock)
125: #define named_entry_unlock(object) mutex_unlock(&(object)->Lock)
126:
127: /*
128: * Type: vm_named_entry_t [internal use only]
129: *
130: * Description:
131: * Description of a mapping to a memory cache object.
132: *
133: * Implementation:
134: * While the handle to this object is used as a means to map
135: * and pass around the right to map regions backed by pagers
136: * of all sorts, the named_entry itself is only manipulated
137: * by the kernel. Named entries hold information on the
138: * right to map a region of a cached object. Namely,
139: * the target cache object, the beginning and ending of the
140: * region to be mapped, and the permissions, (read, write)
141: * with which it can be mapped.
142: *
143: */
144:
145: struct vm_named_entry {
146: decl_mutex_data(, Lock) /* Synchronization */
147: vm_object_t object; /* object I point to */
148: vm_offset_t offset; /* offset into object */
149: union {
150: ipc_port_t pager; /* amo pager port */
151: vm_map_t map; /* map backing submap */
152: } backing;
153: unsigned int size; /* size of region */
154: unsigned int protection; /* access permissions */
155: int ref_count; /* Number of references */
156: unsigned int
157: /* boolean_t */ internal:1, /* is an internal object */
158: /* boolean_t */ is_sub_map:1; /* is object is a submap? */
159: };
160:
161: typedef struct vm_named_entry *vm_named_entry_t;
162:
163:
164: /*
165: * Type: vm_map_entry_t [internal use only]
166: *
167: * Description:
168: * A single mapping within an address map.
169: *
170: * Implementation:
171: * Address map entries consist of start and end addresses,
172: * a VM object (or sub map) and offset into that object,
173: * and user-exported inheritance and protection information.
174: * Control information for virtual copy operations is also
175: * stored in the address map entry.
176: */
177: struct vm_map_links {
178: struct vm_map_entry *prev; /* previous entry */
179: struct vm_map_entry *next; /* next entry */
180: vm_offset_t start; /* start address */
181: vm_offset_t end; /* end address */
182: };
183:
184: struct vm_map_entry {
185: struct vm_map_links links; /* links to other entries */
186: #define vme_prev links.prev
187: #define vme_next links.next
188: #define vme_start links.start
189: #define vme_end links.end
190: union vm_map_object object; /* object I point to */
191: vm_offset_t offset; /* offset into object */
192: unsigned int
193: /* boolean_t */ is_shared:1, /* region is shared */
194: /* boolean_t */ is_sub_map:1, /* Is "object" a submap? */
195: /* boolean_t */ in_transition:1, /* Entry being changed */
196: /* boolean_t */ needs_wakeup:1, /* Waiters on in_transition */
197: /* vm_behavior_t */ behavior:2, /* user paging behavior hint */
198: /* behavior is not defined for submap type */
199: /* boolean_t */ needs_copy:1, /* object need to be copied? */
200: /* Only in task maps: */
201: /* vm_prot_t */ protection:3, /* protection code */
202: /* vm_prot_t */ max_protection:3,/* maximum protection */
203: /* vm_inherit_t */ inheritance:2, /* inheritance */
204: /* pad */ pad1:1,
205: /* user alias */ alias:8;
206: unsigned short wired_count; /* can be paged if = 0 */
207: unsigned short user_wired_count; /* for vm_wire */
208: };
209:
210: /*
211: * wired_counts are unsigned short. This value is used to safeguard
212: * against any mishaps due to runaway user programs.
213: */
214: #define MAX_WIRE_COUNT 65535
215:
216:
217:
218: /*
219: * Type: struct vm_map_header
220: *
221: * Description:
222: * Header for a vm_map and a vm_map_copy.
223: */
224: struct vm_map_header {
225: struct vm_map_links links; /* first, last, min, max */
226: int nentries; /* Number of entries */
227: boolean_t entries_pageable;
228: /* are map entries pageable? */
229: };
230:
231: /*
232: * Type: vm_map_t [exported; contents invisible]
233: *
234: * Description:
235: * An address map -- a directory relating valid
236: * regions of a task's address space to the corresponding
237: * virtual memory objects.
238: *
239: * Implementation:
240: * Maps are doubly-linked lists of map entries, sorted
241: * by address. One hint is used to start
242: * searches again from the last successful search,
243: * insertion, or removal. Another hint is used to
244: * quickly find free space.
245: */
246: struct vm_map {
247: lock_t lock; /* uni- and smp-lock */
248: struct vm_map_header hdr; /* Map entry header */
249: #define min_offset hdr.links.start /* start of range */
250: #define max_offset hdr.links.end /* end of range */
251: pmap_t pmap; /* Physical map */
252: vm_size_t size; /* virtual size */
253: int ref_count; /* Reference count */
254: #if TASK_SWAPPER
255: int res_count; /* Residence count (swap) */
256: int sw_state; /* Swap state */
257: #endif /* TASK_SWAPPER */
258: decl_mutex_data(, s_lock) /* Lock ref, res, hint fields */
259: vm_map_entry_t hint; /* hint for quick lookups */
260: vm_map_entry_t first_free; /* First free space hint */
261: boolean_t wait_for_space; /* Should callers wait
262: for space? */
263: boolean_t wiring_required;/* All memory wired? */
264: boolean_t no_zero_fill; /* No zero fill absent pages */
265: unsigned int timestamp; /* Version number */
266: } ;
267:
268: #define vm_map_to_entry(map) ((struct vm_map_entry *) &(map)->hdr.links)
269: #define vm_map_first_entry(map) ((map)->hdr.links.next)
270: #define vm_map_last_entry(map) ((map)->hdr.links.prev)
271:
272: #if TASK_SWAPPER
273: /*
274: * VM map swap states. There are no transition states.
275: */
276: #define MAP_SW_IN 1 /* map is swapped in; residence count > 0 */
277: #define MAP_SW_OUT 2 /* map is out (res_count == 0 */
278: #endif /* TASK_SWAPPER */
279:
280: /*
281: * Type: vm_map_version_t [exported; contents invisible]
282: *
283: * Description:
284: * Map versions may be used to quickly validate a previous
285: * lookup operation.
286: *
287: * Usage note:
288: * Because they are bulky objects, map versions are usually
289: * passed by reference.
290: *
291: * Implementation:
292: * Just a timestamp for the main map.
293: */
294: typedef struct vm_map_version {
295: unsigned int main_timestamp;
296: } vm_map_version_t;
297:
298: /*
299: * Type: vm_map_copy_t [exported; contents invisible]
300: *
301: * Description:
302: * A map copy object represents a region of virtual memory
303: * that has been copied from an address map but is still
304: * in transit.
305: *
306: * A map copy object may only be used by a single thread
307: * at a time.
308: *
309: * Implementation:
310: * There are three formats for map copy objects.
311: * The first is very similar to the main
312: * address map in structure, and as a result, some
313: * of the internal maintenance functions/macros can
314: * be used with either address maps or map copy objects.
315: *
316: * The map copy object contains a header links
317: * entry onto which the other entries that represent
318: * the region are chained.
319: *
320: * The second format is a single vm object. This is used
321: * primarily in the pageout path. The third format is a
322: * list of vm pages. An optional continuation provides
323: * a hook to be called to obtain more of the memory,
324: * or perform other operations. The continuation takes 3
325: * arguments, a saved arg buffer, a pointer to a new vm_map_copy
326: * (returned) and an abort flag (abort if TRUE).
327: */
328:
329: #define VM_MAP_COPY_PAGE_LIST_MAX 20
330: #define VM_MAP_COPY_PAGE_LIST_MAX_SIZE (VM_MAP_COPY_PAGE_LIST_MAX * PAGE_SIZE)
331:
332:
333: /*
334: * Options for vm_map_copyin_page_list.
335: */
336:
337: #define VM_MAP_COPYIN_OPT_VM_PROT 0x7
338: #define VM_MAP_COPYIN_OPT_SRC_DESTROY 0x8
339: #define VM_MAP_COPYIN_OPT_STEAL_PAGES 0x10
340: #define VM_MAP_COPYIN_OPT_PMAP_ENTER 0x20
341: #define VM_MAP_COPYIN_OPT_NO_ZERO_FILL 0x40
342:
343: /*
344: * Continuation structures for vm_map_copyin_page_list.
345: */
346: typedef struct {
347: vm_map_t map;
348: vm_offset_t src_addr;
349: vm_size_t src_len;
350: vm_offset_t destroy_addr;
351: vm_size_t destroy_len;
352: int options;
353: } vm_map_copyin_args_data_t, *vm_map_copyin_args_t;
354:
355: #define VM_MAP_COPYIN_ARGS_NULL ((vm_map_copyin_args_t) 0)
356:
357:
358: /* vm_map_copy_cont_t is a type definition/prototype
359: * for the cont function pointer in vm_map_copy structure.
360: */
361: typedef kern_return_t (*vm_map_copy_cont_t)(
362: vm_map_copyin_args_t,
363: vm_map_copy_t *);
364:
365: #define VM_MAP_COPY_CONT_NULL ((vm_map_copy_cont_t) 0)
366:
367: struct vm_map_copy {
368: int type;
369: #define VM_MAP_COPY_ENTRY_LIST 1
370: #define VM_MAP_COPY_OBJECT 2
371: #define VM_MAP_COPY_PAGE_LIST 3
372: #define VM_MAP_COPY_KERNEL_BUFFER 4
373: vm_offset_t offset;
374: vm_size_t size;
375: union {
376: struct vm_map_header hdr; /* ENTRY_LIST */
377: struct { /* OBJECT */
378: vm_object_t object;
379: vm_size_t index; /* record progress as pages
380: * are moved from object to
381: * page list; must be zero
382: * when first invoking
383: * vm_map_object_to_page_list
384: */
385: } c_o;
386: struct { /* PAGE_LIST */
387: int npages;
388: boolean_t page_loose;
389: vm_map_copy_cont_t cont;
390: vm_map_copyin_args_t cont_args;
391: vm_page_t page_list[VM_MAP_COPY_PAGE_LIST_MAX];
392: } c_p;
393: struct { /* KERNEL_BUFFER */
394: vm_offset_t kdata;
395: vm_size_t kalloc_size; /* size of this copy_t */
396: } c_k;
397: } c_u;
398: };
399:
400:
401: #define cpy_hdr c_u.hdr
402:
403: #define cpy_object c_u.c_o.object
404: #define cpy_index c_u.c_o.index
405:
406: #define cpy_page_list c_u.c_p.page_list
407: #define cpy_npages c_u.c_p.npages
408: #define cpy_page_loose c_u.c_p.page_loose
409: #define cpy_cont c_u.c_p.cont
410: #define cpy_cont_args c_u.c_p.cont_args
411:
412: #define cpy_kdata c_u.c_k.kdata
413: #define cpy_kalloc_size c_u.c_k.kalloc_size
414:
415:
416: /*
417: * Useful macros for entry list copy objects
418: */
419:
420: #define vm_map_copy_to_entry(copy) \
421: ((struct vm_map_entry *) &(copy)->cpy_hdr.links)
422: #define vm_map_copy_first_entry(copy) \
423: ((copy)->cpy_hdr.links.next)
424: #define vm_map_copy_last_entry(copy) \
425: ((copy)->cpy_hdr.links.prev)
426:
427: /*
428: * Continuation macros for page list copy objects
429: */
430:
431: #define vm_map_copy_invoke_cont(old_copy, new_copy, result) \
432: MACRO_BEGIN \
433: assert(vm_map_copy_cont_is_valid(old_copy)); \
434: vm_map_copy_page_discard(old_copy); \
435: *result = (*((old_copy)->cpy_cont))((old_copy)->cpy_cont_args, \
436: new_copy); \
437: (old_copy)->cpy_cont = VM_MAP_COPY_CONT_NULL; \
438: MACRO_END
439:
440: #define vm_map_copy_invoke_extend_cont(old_copy, new_copy, result) \
441: MACRO_BEGIN \
442: assert(vm_map_copy_cont_is_valid(old_copy)); \
443: *result = (*((old_copy)->cpy_cont))((old_copy)->cpy_cont_args, \
444: new_copy); \
445: (old_copy)->cpy_cont = VM_MAP_COPY_CONT_NULL; \
446: MACRO_END
447:
448: #define vm_map_copy_abort_cont(old_copy) \
449: MACRO_BEGIN \
450: assert(vm_map_copy_cont_is_valid(old_copy)); \
451: vm_map_copy_page_discard(old_copy); \
452: (*((old_copy)->cpy_cont))((old_copy)->cpy_cont_args, \
453: (vm_map_copy_t *) 0); \
454: (old_copy)->cpy_cont = VM_MAP_COPY_CONT_NULL; \
455: (old_copy)->cpy_cont_args = VM_MAP_COPYIN_ARGS_NULL; \
456: MACRO_END
457:
458: #define vm_map_copy_has_cont(copy) \
459: (((copy)->cpy_cont) != VM_MAP_COPY_CONT_NULL)
460:
461: /*
462: * Macro to determine number of pages in a page-list copy chain.
463: */
464:
465: #define vm_map_copy_page_count(copy) \
466: (round_page(((copy)->offset - trunc_page((copy)->offset)) + (copy)->size) \
467: / PAGE_SIZE)
468:
469: /*
470: * Macros: vm_map_lock, etc. [internal use only]
471: * Description:
472: * Perform locking on the data portion of a map.
473: * When multiple maps are to be locked, order by map address.
474: * (See vm_map.c::vm_remap())
475: */
476:
477: #define vm_map_lock_init(map) \
478: MACRO_BEGIN \
479: lock_init(&(map)->lock, TRUE, ETAP_VM_MAP, ETAP_VM_MAP_I); \
480: (map)->timestamp = 0; \
481: MACRO_END
482: #define vm_map_lock(map) \
483: MACRO_BEGIN \
484: lock_write(&(map)->lock); \
485: (map)->timestamp++; \
486: MACRO_END
487:
488: #define vm_map_unlock(map) lock_write_done(&(map)->lock)
489: #define vm_map_lock_read(map) lock_read(&(map)->lock)
490: #define vm_map_unlock_read(map) lock_read_done(&(map)->lock)
491: #define vm_map_lock_write_to_read(map) \
492: lock_write_to_read(&(map)->lock)
493: #define vm_map_lock_read_to_write(map) \
494: (lock_read_to_write(&(map)->lock) || (((map)->timestamp++), 0))
495:
496: extern zone_t vm_map_copy_zone; /* zone for vm_map_copy structures */
497:
498: /*
499: * Exported procedures that operate on vm_map_t.
500: */
501:
502: /* Initialize the module */
503: extern void vm_map_init(void);
504:
505: /* Allocate a range in the specified virtual address map and
506: * return the entry allocated for that range. */
507: extern kern_return_t vm_map_find_space(
508: vm_map_t map,
509: vm_offset_t *address, /* OUT */
510: vm_size_t size,
511: vm_offset_t mask,
512: vm_map_entry_t *o_entry); /* OUT */
513:
514: /* Lookup map entry containing or the specified address in the given map */
515: extern boolean_t vm_map_lookup_entry(
516: vm_map_t map,
517: vm_offset_t address,
518: vm_map_entry_t *entry); /* OUT */
519:
520: /* A version of vm_map_copy_discard that can be called
521: * as a continuation from a vm_map_copy page list. */
522: extern kern_return_t vm_map_copy_discard_cont(
523: vm_map_copyin_args_t cont_args,
524: vm_map_copy_t *copy_result);/* OUT */
525:
526: /* Find the VM object, offset, and protection for a given virtual address
527: * in the specified map, assuming a page fault of the type specified. */
528: extern kern_return_t vm_map_lookup_locked(
529: vm_map_t *var_map, /* IN/OUT */
530: vm_offset_t vaddr,
531: vm_prot_t fault_type,
532: vm_map_version_t *out_version, /* OUT */
533: vm_object_t *object, /* OUT */
534: vm_offset_t *offset, /* OUT */
535: vm_prot_t *out_prot, /* OUT */
536: boolean_t *wired, /* OUT */
537: int *behavior, /* OUT */
538: vm_offset_t *lo_offset, /* OUT */
539: vm_offset_t *hi_offset); /* OUT */
540:
541: /* Verifies that the map has not changed since the given version. */
542: extern boolean_t vm_map_verify(
543: vm_map_t map,
544: vm_map_version_t *version); /* REF */
545:
546: /* Split a vm_map_entry into 2 entries */
547: extern void _vm_map_clip_start(
548: struct vm_map_header *map_header,
549: vm_map_entry_t entry,
550: vm_offset_t start);
551:
552: extern vm_map_entry_t vm_map_entry_insert(
553: vm_map_t map,
554: vm_map_entry_t insp_entry,
555: vm_offset_t start,
556: vm_offset_t end,
557: vm_object_t object,
558: vm_offset_t offset,
559: boolean_t needs_copy,
560: boolean_t is_shared,
561: boolean_t in_transition,
562: vm_prot_t cur_protection,
563: vm_prot_t max_protection,
564: vm_behavior_t behavior,
565: vm_inherit_t inheritance,
566: unsigned wired_count);
567:
568: extern kern_return_t vm_remap_extract(
569: vm_map_t map,
570: vm_offset_t addr,
571: vm_size_t size,
572: boolean_t copy,
573: struct vm_map_header *map_header,
574: vm_prot_t *cur_protection,
575: vm_prot_t *max_protection,
576: vm_inherit_t inheritance,
577: boolean_t pageable);
578:
579: extern kern_return_t vm_remap_range_allocate(
580: vm_map_t map,
581: vm_offset_t *address,
582: vm_size_t size,
583: vm_offset_t mask,
584: boolean_t anywhere,
585: vm_map_entry_t *map_entry);
586:
587: extern kern_return_t vm_remap_extract(
588: vm_map_t map,
589: vm_offset_t addr,
590: vm_size_t size,
591: boolean_t copy,
592: struct vm_map_header *map_header,
593: vm_prot_t *cur_protection,
594: vm_prot_t *max_protection,
595: vm_inherit_t inheritance,
596: boolean_t pageable);
597:
598: extern kern_return_t vm_remap_range_allocate(
599: vm_map_t map,
600: vm_offset_t *address,
601: vm_size_t size,
602: vm_offset_t mask,
603: boolean_t anywhere,
604: vm_map_entry_t *map_entry);
605:
606: /*
607: * Functions implemented as macros
608: */
609: #define vm_map_min(map) ((map)->min_offset)
610: /* Lowest valid address in
611: * a map */
612:
613: #define vm_map_max(map) ((map)->max_offset)
614: /* Highest valid address */
615:
616: #define vm_map_pmap(map) ((map)->pmap)
617: /* Physical map associated
618: * with this address map */
619:
620: #define vm_map_verify_done(map, version) vm_map_unlock_read(map)
621: /* Operation that required
622: * a verified lookup is
623: * now complete */
624:
625: /*
626: * Macros/functions for map residence counts and swapin/out of vm maps
627: */
628: #if TASK_SWAPPER
629:
630: #if MACH_ASSERT
631: /* Gain a reference to an existing map */
632: extern void vm_map_reference(
633: vm_map_t map);
634: /* Lose a residence count */
635: extern void vm_map_res_deallocate(
636: vm_map_t map);
637: /* Gain a residence count on a map */
638: extern void vm_map_res_reference(
639: vm_map_t map);
640: /* Gain reference & residence counts to possibly swapped-out map */
641: extern void vm_map_reference_swap(
642: vm_map_t map);
643:
644: #else /* MACH_ASSERT */
645:
646: #define vm_map_reference(map) \
647: MACRO_BEGIN \
648: vm_map_t Map = (map); \
649: if (Map) { \
650: mutex_lock(&Map->s_lock); \
651: Map->res_count++; \
652: Map->ref_count++; \
653: mutex_unlock(&Map->s_lock); \
654: } \
655: MACRO_END
656:
657: #define vm_map_res_reference(map) \
658: MACRO_BEGIN \
659: vm_map_t Lmap = (map); \
660: if (Lmap->res_count == 0) { \
661: mutex_unlock(&Lmap->s_lock); \
662: vm_map_lock(Lmap); \
663: vm_map_swapin(Lmap); \
664: mutex_lock(&Lmap->s_lock); \
665: ++Lmap->res_count; \
666: vm_map_unlock(Lmap); \
667: } else \
668: ++Lmap->res_count; \
669: MACRO_END
670:
671: #define vm_map_res_deallocate(map) \
672: MACRO_BEGIN \
673: vm_map_t Map = (map); \
674: if (--Map->res_count == 0) { \
675: mutex_unlock(&Map->s_lock); \
676: vm_map_lock(Map); \
677: vm_map_swapout(Map); \
678: vm_map_unlock(Map); \
679: mutex_lock(&Map->s_lock); \
680: } \
681: MACRO_END
682:
683: #define vm_map_reference_swap(map) \
684: MACRO_BEGIN \
685: vm_map_t Map = (map); \
686: mutex_lock(&Map->s_lock); \
687: ++Map->ref_count; \
688: vm_map_res_reference(Map); \
689: mutex_unlock(&Map->s_lock); \
690: MACRO_END
691: #endif /* MACH_ASSERT */
692:
693: extern void vm_map_swapin(
694: vm_map_t map);
695:
696: extern void vm_map_swapout(
697: vm_map_t map);
698:
699: #else /* TASK_SWAPPER */
700:
701: #define vm_map_reference(map) \
702: MACRO_BEGIN \
703: vm_map_t Map = (map); \
704: if (Map) { \
705: mutex_lock(&Map->s_lock); \
706: Map->ref_count++; \
707: mutex_unlock(&Map->s_lock); \
708: } \
709: MACRO_END
710:
711: #define vm_map_reference_swap(map) vm_map_reference(map)
712: #define vm_map_res_reference(map)
713: #define vm_map_res_deallocate(map)
714:
715: #endif /* TASK_SWAPPER */
716:
717: /*
718: * Submap object. Must be used to create memory to be put
719: * in a submap by vm_map_submap.
720: */
721: extern vm_object_t vm_submap_object;
722:
723: /*
724: * Wait and wakeup macros for in_transition map entries.
725: */
726: #define vm_map_entry_wait(map, interruptible) \
727: MACRO_BEGIN \
728: assert_wait((event_t)&(map)->hdr, interruptible); \
729: vm_map_unlock(map); \
730: thread_block((void (*)(void))0); \
731: MACRO_END
732:
733: #define vm_map_entry_wakeup(map) thread_wakeup((event_t)(&(map)->hdr))
734:
735:
736:
737: #define vm_map_ref_fast(map) \
738: MACRO_BEGIN \
739: mutex_lock(&map->s_lock); \
740: map->ref_count++; \
741: vm_map_res_reference(map); \
742: mutex_unlock(&map->s_lock); \
743: MACRO_END
744:
745: #define vm_map_dealloc_fast(map) \
746: MACRO_BEGIN \
747: register int c; \
748: \
749: mutex_lock(&map->s_lock); \
750: c = --map->ref_count; \
751: if (c > 0) \
752: vm_map_res_deallocate(map); \
753: mutex_unlock(&map->s_lock); \
754: if (c == 0) \
755: vm_map_destroy(map); \
756: MACRO_END
757:
758: #if DIPC
759: extern void vm_map_entry_reset(
760: struct vm_map_header *header_map);
761:
762: extern vm_map_copy_t vm_map_entry_list_from_object(
763: vm_object_t object,
764: vm_offset_t offset,
765: vm_size_t size,
766: boolean_t pageable);
767: #endif
768:
769: /* simplify map entries */
770: extern void vm_map_simplify(
771: vm_map_t map,
772: vm_offset_t start);
773:
774: /* Steal all the pages from a vm_map_copy page_list */
775: extern void vm_map_copy_steal_pages(
776: vm_map_copy_t copy);
777:
778: /* Discard a copy without using it */
779: extern void vm_map_copy_discard(
780: vm_map_copy_t copy);
781:
782: /* Move the information in a map copy object to a new map copy object */
783: extern vm_map_copy_t vm_map_copy_copy(
784: vm_map_copy_t copy);
785:
786: /* Overwrite existing memory with a copy */
787: extern kern_return_t vm_map_copy_overwrite(
788: vm_map_t dst_map,
789: vm_offset_t dst_addr,
790: vm_map_copy_t copy,
791: boolean_t interruptible);
792:
793: /* Version of vm_map_copyout() for page list vm map copies. */
794: extern kern_return_t vm_map_copyout_page_list(
795: vm_map_t dst_map,
796: vm_offset_t *dst_addr, /* OUT */
797: vm_map_copy_t copy);
798:
799: /* Get rid of the pages in a page_list copy. */
800: extern void vm_map_copy_page_discard(
801: vm_map_copy_t copy);
802:
803: /* Create a copy object from an object. */
804: extern kern_return_t vm_map_copyin_object(
805: vm_object_t object,
806: vm_offset_t offset,
807: vm_size_t size,
808: vm_map_copy_t *copy_result); /* OUT */
809:
810:
811: /* Make a copy of a region */
812: #if DIPC
813: /*
814: * For DIPC only, src_volatile=TRUE means that the user promises not
815: * to modify data in transit. Kernel may then avoid copy-on-write
816: * handling.
817: *
818: * For non-DIPC kernel configurations, the src_volatile parameter
819: * is visible (even though it has no effect) to avoid ifdef'ing
820: * the interface. The use of src_volatile has no effect in a
821: * non-DIPC kernel.
822: */
823: #endif /* DIPC */
824: /* Make a copy of a region using a page list copy */
825: extern kern_return_t vm_map_copyin_page_list(
826: vm_map_t src_map,
827: vm_offset_t src_addr,
828: vm_size_t len,
829: int options,
830: vm_map_copy_t *copy_result, /* OUT */
831: boolean_t is_cont);
832:
833: #if DIPC
834: extern kern_return_t vm_map_convert_to_page_list(
835: vm_map_copy_t *caller_copy);
836:
837: extern kern_return_t vm_map_object_to_page_list_cont(
838: vm_map_copy_t cont_args,
839: vm_map_copy_t *copy_result); /* OUT */
840:
841: extern kern_return_t vm_map_object_to_page_list(
842: vm_map_copy_t *caller_copy);
843:
844: extern kern_return_t vm_map_convert_from_page_list(
845: vm_map_copy_t copy);
846:
847: extern kern_return_t vm_map_object_to_entry_list(
848: vm_map_copy_t copy);
849:
850:
851: extern kern_return_t vm_map_convert_to_entry_list(
852: vm_map_copy_t copy,
853: boolean_t pageable);
854:
855: extern vm_map_copy_t vm_map_copy_overwrite_recv(
856: vm_map_t map,
857: vm_offset_t addr,
858: vm_size_t size);
859:
860: extern kern_return_t vm_map_copy_overwrite_recv_done(
861: vm_map_t map,
862: vm_map_copy_t copy);
863: #endif /* DIPC */
864:
865:
866: extern vm_map_t vm_map_switch(
867: vm_map_t map);
868:
869: extern int vm_map_copy_cont_is_valid(
870: vm_map_copy_t copy);
871:
872:
873:
874: #if DIPC
875: /*
876: * Caller promises not to modify data in transit. Kernel may then
877: * avoid copy-on-write handling.
878: *
879: * N.B. When src_destroy=TRUE, turning on src_volatile=TRUE has
880: * no effect.
881: */
882: #define vm_map_copyin_volatile(src_map,src_addr,len,src_destroy,copy_result) \
883: vm_map_copyin_common(src_map, src_addr, len, src_destroy, \
884: TRUE, copy_result, FALSE)
885: #endif /* DIPC */
886:
887: #endif /* !MACH_KERNEL_PRIVATE */
888:
889: /* Get rid of a map */
890: extern void vm_map_destroy(
891: vm_map_t map);
892: /* Lose a reference */
893: extern void vm_map_deallocate(
894: vm_map_t map);
895:
896: /* Create an empty map */
897: extern vm_map_t vm_map_create(
898: pmap_t pmap,
899: vm_offset_t min,
900: vm_offset_t max,
901: boolean_t pageable);
902:
903:
904: /* Enter a mapping */
905: extern kern_return_t vm_map_enter(
906: vm_map_t map,
907: vm_offset_t *address,
908: vm_size_t size,
909: vm_offset_t mask,
910: int flags,
911: vm_object_t object,
912: vm_offset_t offset,
913: boolean_t needs_copy,
914: vm_prot_t cur_protection,
915: vm_prot_t max_protection,
916: vm_inherit_t inheritance);
917:
918: extern kern_return_t vm_map_write_user(
919: vm_map_t map,
920: vm_offset_t src_addr,
921: vm_offset_t dst_addr,
922: vm_size_t size);
923:
924: extern kern_return_t vm_map_read_user(
925: vm_map_t map,
926: vm_offset_t src_addr,
927: vm_offset_t dst_addr,
928: vm_size_t size);
929:
930: /* Create a new task map using an existing task map as a template. */
931: extern vm_map_t vm_map_fork(
932: vm_map_t old_map);
933:
934: /* Change protection */
935: extern kern_return_t vm_map_protect(
936: vm_map_t map,
937: vm_offset_t start,
938: vm_offset_t end,
939: vm_prot_t new_prot,
940: boolean_t set_max);
941:
942: /* Change inheritance */
943: extern kern_return_t vm_map_inherit(
944: vm_map_t map,
945: vm_offset_t start,
946: vm_offset_t end,
947: vm_inherit_t new_inheritance);
948:
949: /* wire down a region */
950: extern kern_return_t vm_map_wire(
951: vm_map_t map,
952: vm_offset_t start,
953: vm_offset_t end,
954: vm_prot_t access_type,
955: boolean_t user_wire);
956:
957: /* unwire a region */
958: extern kern_return_t vm_map_unwire(
959: vm_map_t map,
960: vm_offset_t start,
961: vm_offset_t end,
962: boolean_t user_wire);
963:
964: /* Deallocate a region */
965: extern kern_return_t vm_map_remove(
966: vm_map_t map,
967: vm_offset_t start,
968: vm_offset_t end,
969: boolean_t flags);
970:
971: /* Place a copy into a map */
972: extern kern_return_t vm_map_copyout(
973: vm_map_t dst_map,
974: vm_offset_t *dst_addr, /* OUT */
975: vm_map_copy_t copy);
976:
977:
978: /* Add or remove machine-dependent attributes from map regions */
979: extern kern_return_t vm_map_machine_attribute(
980: vm_map_t map,
981: vm_offset_t address,
982: vm_size_t size,
983: vm_machine_attribute_t attribute,
984: vm_machine_attribute_val_t* value); /* IN/OUT */
985: /* Set paging behavior */
986: extern kern_return_t vm_map_behavior_set(
987: vm_map_t map,
988: vm_offset_t start,
989: vm_offset_t end,
990: vm_behavior_t new_behavior);
991:
992: extern kern_return_t vm_map_copyin_common(
993: vm_map_t src_map,
994: vm_offset_t src_addr,
995: vm_size_t len,
996: boolean_t src_destroy,
997: boolean_t src_volatile,
998: vm_map_copy_t *copy_result, /* OUT */
999: boolean_t use_maxprot);
1000:
1001: /*
1002: * Macros to invoke vm_map_copyin_common. vm_map_copyin is the
1003: * usual form; it handles a copyin based on the current protection
1004: * (current protection == VM_PROT_NONE) is a failure.
1005: * vm_map_copyin_maxprot handles a copyin based on maximum possible
1006: * access. The difference is that a region with no current access
1007: * BUT possible maximum access is rejected by vm_map_copyin(), but
1008: * returned by vm_map_copyin_maxprot.
1009: */
1010: #define vm_map_copyin(src_map, src_addr, len, src_destroy, copy_result) \
1011: vm_map_copyin_common(src_map, src_addr, len, src_destroy, \
1012: FALSE, copy_result, FALSE)
1013:
1014: #define vm_map_copyin_maxprot(src_map, \
1015: src_addr, len, src_destroy, copy_result) \
1016: vm_map_copyin_common(src_map, src_addr, len, src_destroy, \
1017: FALSE, copy_result, TRUE)
1018:
1019: #define VM_MAP_ENTRY_NULL ((vm_map_entry_t) 0)
1020:
1021: /*
1022: * Flags for vm_map_remove() and vm_map_delete()
1023: */
1024: #define VM_MAP_NO_FLAGS 0x0
1025: #define VM_MAP_REMOVE_KUNWIRE 0x1
1026: #define VM_MAP_REMOVE_INTERRUPTIBLE 0x2
1027: #define VM_MAP_REMOVE_WAIT_FOR_KWIRE 0x4
1028:
1029: #endif /* _VM_VM_MAP_H_ */
1030:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.