xnu-792.22.5.tar.gz

[apple/xnu.git] / osfmk / vm / vm_map.h

diff --git a/osfmk/vm/vm_map.h b/osfmk/vm/vm_map.h
index fd0422f45b4726947e58911947c16c98478a72ba..1b6c8fd6781b7db1e6692ff2919e53b2e10f39ce 100644 (file)
--- a/osfmk/vm/vm_map.h
+++ b/osfmk/vm/vm_map.h
@@ -1,16 +1,19 @@
 /*
 /*

- * Copyright (c) 2000-2002 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 2000-2005 Apple Computer, Inc. All rights reserved.

  *
  *

- * @APPLE_LICENSE_HEADER_START@
- * 
- * Copyright (c) 1999-2003 Apple Computer, Inc.  All Rights Reserved.
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_START@

  * 
  * This file contains Original Code and/or Modifications of Original Code
  * as defined in and that are subject to the Apple Public Source License
  * Version 2.0 (the 'License'). You may not use this file except in
  * 
  * This file contains Original Code and/or Modifications of Original Code
  * as defined in and that are subject to the Apple Public Source License
  * Version 2.0 (the 'License'). You may not use this file except in

- * compliance with the License. Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this
- * file.
+ * compliance with the License. The rights granted to you under the License
+ * may not be used to create, or enable the creation or redistribution of,
+ * unlawful or unlicensed copies of an Apple operating system, or to
+ * circumvent, violate, or enable the circumvention or violation of, any
+ * terms of an Apple operating system software license agreement.
+ * 
+ * Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this file.

  * 
  * The Original Code and all software distributed under the License are
  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  * 
  * The Original Code and all software distributed under the License are
  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER


@@ -20,7 +23,7 @@
  * Please see the License for the specific language governing rights and
  * limitations under the License.
  * 
  * Please see the License for the specific language governing rights and
  * limitations under the License.
  * 

- * @APPLE_LICENSE_HEADER_END@
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_END@

  */
 /*
  * @OSF_COPYRIGHT@
  */
 /*
  * @OSF_COPYRIGHT@


@@ -74,24 +77,22 @@
 #include <mach/vm_prot.h>
 #include <mach/vm_inherit.h>
 #include <mach/vm_behavior.h>
 #include <mach/vm_prot.h>
 #include <mach/vm_inherit.h>
 #include <mach/vm_behavior.h>

+#include <mach/vm_param.h>

 #include <vm/pmap.h>
 
 #include <vm/pmap.h>
 

-#include <sys/appleapiopts.h>
+#ifdef KERNEL_PRIVATE

 
 

-#ifdef __APPLE_API_PRIVATE
+#include <sys/cdefs.h>

 
 

-#ifndef MACH_KERNEL_PRIVATE
-
-#ifdef __APPLE_API_OBSOLETE
-extern void     kernel_vm_map_reference(vm_map_t map);
-#endif /* __APPLE_API_OBSOLETE */
+__BEGIN_DECLS

 
 extern void    vm_map_reference(vm_map_t       map);
 extern vm_map_t current_map(void);
 
 
 extern void    vm_map_reference(vm_map_t       map);
 extern vm_map_t current_map(void);
 

-#else /* MACH_KERNEL_PRIVATE */
+__END_DECLS
+
+#ifdef MACH_KERNEL_PRIVATE

 
 

-#include <cpus.h>

 #include <task_swapper.h>
 #include <mach_assert.h>
 
 #include <task_swapper.h>
 #include <mach_assert.h>
 


@@ -101,9 +102,9 @@ extern vm_map_t current_map(void);
 #include <kern/zalloc.h>
 #include <kern/macro_help.h>
 
 #include <kern/zalloc.h>
 #include <kern/macro_help.h>
 

-#include <kern/thread_act.h>
+#include <kern/thread.h>

 
 

-#define current_map_fast()     (current_act_fast()->map)
+#define current_map_fast()     (current_thread()->map)

 #define        current_map()           (current_map_fast())
 
 /*
 #define        current_map()           (current_map_fast())
 
 /*


@@ -116,6 +117,7 @@ extern vm_map_t current_map(void);
  *                              used for inter-map copy operations
  */
 typedef struct vm_map_entry    *vm_map_entry_t;
  *                              used for inter-map copy operations
  */
 typedef struct vm_map_entry    *vm_map_entry_t;

+#define VM_MAP_ENTRY_NULL      ((vm_map_entry_t) 0)

 
 
 /*
 
 
 /*


@@ -126,11 +128,11 @@ typedef struct vm_map_entry       *vm_map_entry_t;
  *             memory object or a sub map (of the kernel map).
  */
 typedef union vm_map_object {
  *             memory object or a sub map (of the kernel map).
  */
 typedef union vm_map_object {

-       struct vm_object        *vm_object;     /* object object */
-       struct vm_map           *sub_map;       /* belongs to another map */
+       vm_object_t             vm_object;      /* object object */
+       vm_map_t                sub_map;        /* belongs to another map */

 } vm_map_object_t;
 
 } vm_map_object_t;
 

-#define named_entry_lock_init(object)   mutex_init(&(object)->Lock, ETAP_VM_OBJ)
+#define named_entry_lock_init(object)   mutex_init(&(object)->Lock, 0)

 #define named_entry_lock(object)          mutex_lock(&(object)->Lock)
 #define named_entry_unlock(object)        mutex_unlock(&(object)->Lock)   
 
 #define named_entry_lock(object)          mutex_lock(&(object)->Lock)
 #define named_entry_unlock(object)        mutex_unlock(&(object)->Lock)   
 


@@ -154,18 +156,19 @@ typedef union vm_map_object {
 
 struct vm_named_entry {
        decl_mutex_data(,       Lock)           /* Synchronization */
 
 struct vm_named_entry {
        decl_mutex_data(,       Lock)           /* Synchronization */

-       vm_object_t             object;         /* object I point to */
-       vm_object_offset_t      offset;         /* offset into object */

        union {
        union {

-               memory_object_t         pager;  /* amo pager port */
-               vm_map_t                map;    /* map backing submap */
+               vm_object_t     object;         /* object I point to */
+               memory_object_t pager;          /* amo pager port */
+               vm_map_t        map;            /* map backing submap */

        } backing;
        } backing;

-       unsigned int            size;           /* size of region */
-       unsigned int            protection;     /* access permissions */
+       vm_object_offset_t      offset;         /* offset into object */
+       vm_object_size_t        size;           /* size of region */
+       vm_prot_t               protection;     /* access permissions */

        int                     ref_count;      /* Number of references */
        int                     ref_count;      /* Number of references */

-       unsigned int
-       /* boolean_t */         internal:1,     /* is an internal object */
-       /* boolean_t */         is_sub_map:1;   /* is object is a submap? */
+       unsigned int                            /* Is backing.xxx : */
+       /* boolean_t */         internal:1,     /* ... an internal object */
+       /* boolean_t */         is_sub_map:1,   /* ... a submap? */
+       /* boolean_t */         is_pager:1;     /* ... a pager port */

 };
 
 /*
 };
 
 /*


@@ -184,8 +187,8 @@ struct vm_named_entry {
 struct vm_map_links {
        struct vm_map_entry     *prev;          /* previous entry */
        struct vm_map_entry     *next;          /* next entry */
 struct vm_map_links {
        struct vm_map_entry     *prev;          /* previous entry */
        struct vm_map_entry     *next;          /* next entry */

-       vm_offset_t             start;          /* start address */
-       vm_offset_t             end;            /* end address */
+       vm_map_offset_t         start;          /* start address */
+       vm_map_offset_t         end;            /* end address */

 };
 
 struct vm_map_entry {
 };
 
 struct vm_map_entry {


@@ -208,8 +211,9 @@ struct vm_map_entry {
        /* vm_prot_t */         protection:3,   /* protection code */
        /* vm_prot_t */         max_protection:3,/* maximum protection */
        /* vm_inherit_t */      inheritance:2,  /* inheritance */
        /* vm_prot_t */         protection:3,   /* protection code */
        /* vm_prot_t */         max_protection:3,/* maximum protection */
        /* vm_inherit_t */      inheritance:2,  /* inheritance */

-       /* nested pmap */       use_pmap:1,     /* nested pmaps */
-       /* user alias */        alias:8;
+       /* boolean_t */         use_pmap:1,     /* nested pmaps */
+       /* unsigned char */     alias:8,        /* user alias */
+       /* unsigned char */     pad:8;          /* available bits */

        unsigned short          wired_count;    /* can be paged if = 0 */
        unsigned short          user_wired_count; /* for vm_wire */
 };
        unsigned short          wired_count;    /* can be paged if = 0 */
        unsigned short          user_wired_count; /* for vm_wire */
 };


@@ -256,7 +260,7 @@ struct vm_map {
 #define min_offset             hdr.links.start /* start of range */
 #define max_offset             hdr.links.end   /* end of range */
        pmap_t                  pmap;           /* Physical map */
 #define min_offset             hdr.links.start /* start of range */
 #define max_offset             hdr.links.end   /* end of range */
        pmap_t                  pmap;           /* Physical map */

-       vm_size_t               size;           /* virtual size */
+       vm_map_size_t           size;           /* virtual size */

        int                     ref_count;      /* Reference count */
 #if    TASK_SWAPPER
        int                     res_count;      /* Residence count (swap) */
        int                     ref_count;      /* Reference count */
 #if    TASK_SWAPPER
        int                     res_count;      /* Residence count (swap) */


@@ -325,52 +329,14 @@ typedef struct vm_map_version {
  *             entry onto which the other entries that represent
  *             the region are chained.
  *
  *             entry onto which the other entries that represent
  *             the region are chained.
  *

- *             The second format is a single vm object.  This is used
- *             primarily in the pageout path.  The third format is a
- *             list of vm pages.  An optional continuation provides
- *             a hook to be called to obtain more of the memory,
- *             or perform other operations.  The continuation takes 3
- *             arguments, a saved arg buffer, a pointer to a new vm_map_copy
- *             (returned) and an abort flag (abort if TRUE).
- */
-
-#define VM_MAP_COPY_PAGE_LIST_MAX      20
-#define        VM_MAP_COPY_PAGE_LIST_MAX_SIZE  (VM_MAP_COPY_PAGE_LIST_MAX * PAGE_SIZE)
-
-
-/*
- *     Options for vm_map_copyin_page_list.
- */
-
-#define        VM_MAP_COPYIN_OPT_VM_PROT               0x7
-#define        VM_MAP_COPYIN_OPT_SRC_DESTROY           0x8
-#define        VM_MAP_COPYIN_OPT_STEAL_PAGES           0x10
-#define        VM_MAP_COPYIN_OPT_PMAP_ENTER            0x20
-#define        VM_MAP_COPYIN_OPT_NO_ZERO_FILL          0x40
-
-/*
- *     Continuation structures for vm_map_copyin_page_list.
- */
-typedef        struct {
-       vm_map_t        map;
-       vm_offset_t     src_addr;
-       vm_size_t       src_len;
-       vm_offset_t     destroy_addr;
-       vm_size_t       destroy_len;
-       int             options;
-}  vm_map_copyin_args_data_t, *vm_map_copyin_args_t;
-
-#define        VM_MAP_COPYIN_ARGS_NULL ((vm_map_copyin_args_t) 0)
-
-
-/* vm_map_copy_cont_t is a type definition/prototype
- * for the cont function pointer in vm_map_copy structure.
+ *             The second format is a single vm object.  This was used
+ *             primarily in the pageout path - but is not currently used
+ *             except for placeholder copy objects (see vm_map_copy_copy()).
+ *
+ *             The third format is a kernel buffer copy object - for data
+ *             small enough that physical copies were the most efficient
+ *             method.

  */
  */

-typedef kern_return_t (*vm_map_copy_cont_t)(
-                               vm_map_copyin_args_t,
-                               vm_map_copy_t *);
-
-#define        VM_MAP_COPY_CONT_NULL   ((vm_map_copy_cont_t) 0)

 
 struct vm_map_copy {
        int                     type;
 
 struct vm_map_copy {
        int                     type;


@@ -378,20 +344,12 @@ struct vm_map_copy {
 #define VM_MAP_COPY_OBJECT             2
 #define VM_MAP_COPY_KERNEL_BUFFER      3
        vm_object_offset_t      offset;
 #define VM_MAP_COPY_OBJECT             2
 #define VM_MAP_COPY_KERNEL_BUFFER      3
        vm_object_offset_t      offset;

-       vm_size_t               size;
+       vm_map_size_t           size;

        union {
            struct vm_map_header        hdr;    /* ENTRY_LIST */
        union {
            struct vm_map_header        hdr;    /* ENTRY_LIST */

-           struct {                            /* OBJECT */
-               vm_object_t             object;
-               vm_size_t               index;  /* record progress as pages
-                                                * are moved from object to
-                                                * page list; must be zero
-                                                * when first invoking
-                                                * vm_map_object_to_page_list
-                                                */
-           } c_o;
-           struct {                            /* KERNEL_BUFFER */
-               vm_offset_t             kdata;
+           vm_object_t                 object; /* OBJECT */
+           struct {                            
+               void                    *kdata;       /* KERNEL_BUFFER */

                vm_size_t               kalloc_size;  /* size of this copy_t */
            } c_k;
        } c_u;
                vm_size_t               kalloc_size;  /* size of this copy_t */
            } c_k;
        } c_u;


@@ -400,8 +358,7 @@ struct vm_map_copy {
 
 #define cpy_hdr                        c_u.hdr
 
 
 #define cpy_hdr                        c_u.hdr
 

-#define cpy_object             c_u.c_o.object
-#define        cpy_index               c_u.c_o.index
+#define cpy_object             c_u.object

 
 #define cpy_kdata              c_u.c_k.kdata
 #define cpy_kalloc_size                c_u.c_k.kalloc_size
 
 #define cpy_kdata              c_u.c_k.kdata
 #define cpy_kalloc_size                c_u.c_k.kalloc_size


@@ -428,7 +385,7 @@ struct vm_map_copy {
 
 #define vm_map_lock_init(map)                                          \
        ((map)->timestamp = 0 ,                                         \
 
 #define vm_map_lock_init(map)                                          \
        ((map)->timestamp = 0 ,                                         \

-       lock_init(&(map)->lock, TRUE, ETAP_VM_MAP, ETAP_VM_MAP_I))
+       lock_init(&(map)->lock, TRUE, 0, 0))

 
 #define vm_map_lock(map)               lock_write(&(map)->lock)
 #define vm_map_unlock(map)                                             \
 
 #define vm_map_lock(map)               lock_write(&(map)->lock)
 #define vm_map_unlock(map)                                             \


@@ -439,8 +396,6 @@ struct vm_map_copy {
                ((map)->timestamp++ ,   lock_write_to_read(&(map)->lock))
 #define vm_map_lock_read_to_write(map) lock_read_to_write(&(map)->lock)
 
                ((map)->timestamp++ ,   lock_write_to_read(&(map)->lock))
 #define vm_map_lock_read_to_write(map) lock_read_to_write(&(map)->lock)
 

-extern zone_t          vm_map_copy_zone; /* zone for vm_map_copy structures */
-

 /*
  *     Exported procedures that operate on vm_map_t.
  */
 /*
  *     Exported procedures that operate on vm_map_t.
  */


@@ -451,50 +406,45 @@ extern void               vm_map_init(void);
 /* Allocate a range in the specified virtual address map and
  * return the entry allocated for that range. */
 extern kern_return_t vm_map_find_space(
 /* Allocate a range in the specified virtual address map and
  * return the entry allocated for that range. */
 extern kern_return_t vm_map_find_space(

-                               vm_map_t        map,
-                               vm_offset_t     *address,       /* OUT */
-                               vm_size_t       size,
-                               vm_offset_t     mask,
-                               vm_map_entry_t  *o_entry);      /* OUT */
+                               vm_map_t                map,
+                               vm_map_address_t        *address,       /* OUT */
+                               vm_map_size_t           size,
+                               vm_map_offset_t         mask,
+                               int                     flags,
+                               vm_map_entry_t          *o_entry);      /* OUT */

 
 /* Lookup map entry containing or the specified address in the given map */
 extern boolean_t       vm_map_lookup_entry(
 
 /* Lookup map entry containing or the specified address in the given map */
 extern boolean_t       vm_map_lookup_entry(

-                               vm_map_t        map,
-                               vm_offset_t     address,
-                               vm_map_entry_t  *entry);        /* OUT */
+                               vm_map_t                map,
+                               vm_map_address_t        address,
+                               vm_map_entry_t          *entry);        /* OUT */

 
 /* Find the VM object, offset, and protection for a given virtual address
  * in the specified map, assuming a page fault of the  type specified. */
 extern kern_return_t   vm_map_lookup_locked(
 
 /* Find the VM object, offset, and protection for a given virtual address
  * in the specified map, assuming a page fault of the  type specified. */
 extern kern_return_t   vm_map_lookup_locked(

-                               vm_map_t        *var_map,       /* IN/OUT */
-                               vm_offset_t     vaddr,
-                               vm_prot_t       fault_type,
-                               vm_map_version_t *out_version,  /* OUT */
-                               vm_object_t     *object,        /* OUT */
-                               vm_object_offset_t *offset,     /* OUT */
-                               vm_prot_t       *out_prot,      /* OUT */
-                               boolean_t       *wired,         /* OUT */
-                               int             *behavior,      /* OUT */
-                               vm_object_offset_t *lo_offset,  /* OUT */
-                               vm_object_offset_t *hi_offset,  /* OUT */
-                               vm_map_t        *pmap_map);     /* OUT */
+                               vm_map_t                *var_map,       /* IN/OUT */
+                               vm_map_address_t        vaddr,
+                               vm_prot_t               fault_type,
+                               vm_map_version_t        *out_version,   /* OUT */
+                               vm_object_t             *object,        /* OUT */
+                               vm_object_offset_t      *offset,        /* OUT */
+                               vm_prot_t               *out_prot,      /* OUT */
+                               boolean_t               *wired,         /* OUT */
+                               int                     *behavior,      /* OUT */
+                               vm_map_offset_t         *lo_offset,     /* OUT */
+                               vm_map_offset_t         *hi_offset,     /* OUT */
+                               vm_map_t                *real_map);     /* OUT */

 
 /* Verifies that the map has not changed since the given version. */
 extern boolean_t       vm_map_verify(
 
 /* Verifies that the map has not changed since the given version. */
 extern boolean_t       vm_map_verify(

-                               vm_map_t         map,
-                               vm_map_version_t *version);     /* REF */
-
-/* Split a vm_map_entry into 2 entries */
-extern void            _vm_map_clip_start(
-                               struct vm_map_header    *map_header,
-                               vm_map_entry_t          entry,
-                               vm_offset_t             start);
+                               vm_map_t                map,
+                               vm_map_version_t        *version);      /* REF */

 
 extern vm_map_entry_t  vm_map_entry_insert(
                                vm_map_t                map,
                                vm_map_entry_t          insp_entry,
 
 extern vm_map_entry_t  vm_map_entry_insert(
                                vm_map_t                map,
                                vm_map_entry_t          insp_entry,

-                               vm_offset_t             start,
-                               vm_offset_t             end,
+                               vm_map_offset_t         start,
+                               vm_map_offset_t         end,

                                vm_object_t             object,
                                vm_object_offset_t      offset,
                                boolean_t               needs_copy,
                                vm_object_t             object,
                                vm_object_offset_t      offset,
                                boolean_t               needs_copy,


@@ -506,52 +456,15 @@ extern vm_map_entry_t     vm_map_entry_insert(
                                vm_inherit_t            inheritance,
                                unsigned                wired_count);
 
                                vm_inherit_t            inheritance,
                                unsigned                wired_count);
 

-extern kern_return_t   vm_remap_extract(
-                               vm_map_t        map,
-                               vm_offset_t     addr,
-                               vm_size_t       size,
-                               boolean_t       copy,
-                               struct vm_map_header *map_header,
-                               vm_prot_t       *cur_protection,
-                               vm_prot_t       *max_protection,
-                               vm_inherit_t    inheritance,
-                               boolean_t       pageable);
-
-extern kern_return_t   vm_remap_range_allocate(
-                               vm_map_t        map,
-                               vm_offset_t     *address,
-                               vm_size_t       size,
-                               vm_offset_t     mask,
-                               boolean_t       anywhere,
-                               vm_map_entry_t  *map_entry);
-
-extern kern_return_t   vm_remap_extract(
-                               vm_map_t        map,
-                               vm_offset_t     addr,
-                               vm_size_t       size,
-                               boolean_t       copy,
-                               struct vm_map_header *map_header,
-                               vm_prot_t       *cur_protection,
-                               vm_prot_t       *max_protection,
-                               vm_inherit_t    inheritance,
-                               boolean_t       pageable);
-
-extern kern_return_t   vm_remap_range_allocate(
-                               vm_map_t        map,
-                               vm_offset_t     *address,
-                               vm_size_t       size,
-                               vm_offset_t     mask,
-                               boolean_t       anywhere,
-                               vm_map_entry_t  *map_entry);

 
 /*
  *     Functions implemented as macros
  */
 
 /*
  *     Functions implemented as macros
  */

-#define                vm_map_min(map)         ((map)->min_offset)
+#define                vm_map_min(map) ((map)->min_offset)

                                                /* Lowest valid address in
                                                 * a map */
 
                                                /* Lowest valid address in
                                                 * a map */
 

-#define                vm_map_max(map)         ((map)->max_offset)
+#define                vm_map_max(map) ((map)->max_offset)

                                                /* Highest valid address */
 
 #define                vm_map_pmap(map)        ((map)->pmap)
                                                /* Highest valid address */
 
 #define                vm_map_pmap(map)        ((map)->pmap)


@@ -584,9 +497,9 @@ extern void         vm_map_reference_swap(
 
 #else  /* MACH_ASSERT */
 
 
 #else  /* MACH_ASSERT */
 

-#define vm_map_reference(map)                  \
+#define vm_map_reference(map)          \

 MACRO_BEGIN                                    \
 MACRO_BEGIN                                    \

-       vm_map_t Map = (map);                   \
+       vm_map_t Map = (map);           \

        if (Map) {                              \
                mutex_lock(&Map->s_lock);       \
                Map->res_count++;               \
        if (Map) {                              \
                mutex_lock(&Map->s_lock);       \
                Map->res_count++;               \


@@ -597,9 +510,9 @@ MACRO_END
 
 #define vm_map_res_reference(map)              \
 MACRO_BEGIN                                    \
 
 #define vm_map_res_reference(map)              \
 MACRO_BEGIN                                    \

-       vm_map_t Lmap = (map);                  \
+       vm_map_t Lmap = (map);          \

        if (Lmap->res_count == 0) {             \
        if (Lmap->res_count == 0) {             \

-               mutex_unlock(&Lmap->s_lock);    \
+               mutex_unlock(&Lmap->s_lock);\

                vm_map_lock(Lmap);              \
                vm_map_swapin(Lmap);            \
                mutex_lock(&Lmap->s_lock);      \
                vm_map_lock(Lmap);              \
                vm_map_swapin(Lmap);            \
                mutex_lock(&Lmap->s_lock);      \


@@ -611,8 +524,8 @@ MACRO_END
 
 #define vm_map_res_deallocate(map)             \
 MACRO_BEGIN                                    \
 
 #define vm_map_res_deallocate(map)             \
 MACRO_BEGIN                                    \

-       vm_map_t Map = (map);                   \
-       if (--Map->res_count == 0) {            \
+       vm_map_t Map = (map);           \
+       if (--Map->res_count == 0) {    \

                mutex_unlock(&Map->s_lock);     \
                vm_map_lock(Map);               \
                vm_map_swapout(Map);            \
                mutex_unlock(&Map->s_lock);     \
                vm_map_lock(Map);               \
                vm_map_swapout(Map);            \


@@ -670,10 +583,11 @@ extern vm_object_t        vm_submap_object;
                         &(map)->lock, interruptible))
 
 
                         &(map)->lock, interruptible))
 
 

-#define vm_map_entry_wakeup(map)        thread_wakeup((event_t)(&(map)->hdr))
+#define vm_map_entry_wakeup(map)        \
+       thread_wakeup((event_t)(&(map)->hdr))

 
 
 
 

-#define        vm_map_ref_fast(map)                            \
+#define        vm_map_ref_fast(map)                    \

        MACRO_BEGIN                                     \
        mutex_lock(&map->s_lock);                       \
        map->ref_count++;                               \
        MACRO_BEGIN                                     \
        mutex_lock(&map->s_lock);                       \
        map->ref_count++;                               \


@@ -681,12 +595,12 @@ extern vm_object_t        vm_submap_object;
        mutex_unlock(&map->s_lock);                     \
        MACRO_END
 
        mutex_unlock(&map->s_lock);                     \
        MACRO_END
 

-#define        vm_map_dealloc_fast(map)                        \
+#define        vm_map_dealloc_fast(map)                \

        MACRO_BEGIN                                     \
        MACRO_BEGIN                                     \

-       register int c;                                 \
+       register int c;                         \

                                                        \
        mutex_lock(&map->s_lock);                       \
                                                        \
        mutex_lock(&map->s_lock);                       \

-       c = --map->ref_count;                           \
+       c = --map->ref_count;                   \

        if (c > 0)                                      \
                vm_map_res_deallocate(map);             \
        mutex_unlock(&map->s_lock);                     \
        if (c > 0)                                      \
                vm_map_res_deallocate(map);             \
        mutex_unlock(&map->s_lock);                     \


@@ -696,28 +610,16 @@ extern vm_object_t        vm_submap_object;
 
 
 /* simplify map entries */
 
 
 /* simplify map entries */

+extern void            vm_map_simplify_entry(
+       vm_map_t        map,
+       vm_map_entry_t  this_entry);

 extern void            vm_map_simplify(
 extern void            vm_map_simplify(

-                               vm_map_t        map,
-                               vm_offset_t     start);
-
-/* Steal all the pages from a vm_map_copy page_list */
-extern void            vm_map_copy_steal_pages(
-                               vm_map_copy_t   copy);
-
-/* Discard a copy without using it */
-extern void            vm_map_copy_discard(
-                               vm_map_copy_t   copy);
+                               vm_map_t                map,
+                               vm_map_offset_t         start);

 
 /* Move the information in a map copy object to a new map copy object */
 extern vm_map_copy_t   vm_map_copy_copy(
 
 /* Move the information in a map copy object to a new map copy object */
 extern vm_map_copy_t   vm_map_copy_copy(

-                               vm_map_copy_t   copy);
-
-/* Overwrite existing memory with a copy */
-extern kern_return_t   vm_map_copy_overwrite(
-                               vm_map_t        dst_map,
-                               vm_offset_t     dst_addr,
-                               vm_map_copy_t   copy,
-                               int             interruptible);
+                               vm_map_copy_t           copy);

 
 /* Create a copy object from an object. */
 extern kern_return_t   vm_map_copyin_object(
 
 /* Create a copy object from an object. */
 extern kern_return_t   vm_map_copyin_object(


@@ -726,22 +628,12 @@ extern kern_return_t      vm_map_copyin_object(
                                vm_object_size_t        size,
                                vm_map_copy_t           *copy_result); /* OUT */
 
                                vm_object_size_t        size,
                                vm_map_copy_t           *copy_result); /* OUT */
 

-extern vm_map_t                vm_map_switch(
-                               vm_map_t        map);
-
-extern int             vm_map_copy_cont_is_valid(
-                               vm_map_copy_t   copy);
-
-
-#define VM_MAP_ENTRY_NULL      ((vm_map_entry_t) 0)
-
-

 /* Enter a mapping */
 extern kern_return_t   vm_map_enter(
                                vm_map_t                map,
 /* Enter a mapping */
 extern kern_return_t   vm_map_enter(
                                vm_map_t                map,

-                               vm_offset_t             *address,
-                               vm_size_t               size,
-                               vm_offset_t             mask,
+                               vm_map_offset_t         *address,
+                               vm_map_size_t           size,
+                               vm_map_offset_t         mask,

                                int                     flags,
                                vm_object_t             object,
                                vm_object_offset_t      offset,
                                int                     flags,
                                vm_object_t             object,
                                vm_object_offset_t      offset,


@@ -750,123 +642,235 @@ extern kern_return_t    vm_map_enter(
                                vm_prot_t               max_protection,
                                vm_inherit_t            inheritance);
 
                                vm_prot_t               max_protection,
                                vm_inherit_t            inheritance);
 

+/* XXX should go away - replaced with regular enter of contig object */
+extern  kern_return_t  vm_map_enter_cpm(
+                               vm_map_t                map,
+                               vm_map_address_t        *addr,
+                               vm_map_size_t           size,
+                               int                     flags);
+
+extern kern_return_t vm_map_remap(
+                               vm_map_t                target_map,
+                               vm_map_offset_t         *address,
+                               vm_map_size_t           size,
+                               vm_map_offset_t         mask,
+                               boolean_t               anywhere,
+                               vm_map_t                src_map,
+                               vm_map_offset_t         memory_address,
+                               boolean_t               copy,
+                               vm_prot_t               *cur_protection,
+                               vm_prot_t               *max_protection,
+                               vm_inherit_t            inheritance);
+
+
+/*
+ * Read and write from a kernel buffer to a specified map.
+ */

 extern kern_return_t   vm_map_write_user(
 extern kern_return_t   vm_map_write_user(

-                               vm_map_t        map,
-                               vm_offset_t     src_addr,
-                               vm_offset_t     dst_addr,
-                               vm_size_t       size);
+                               vm_map_t                map,
+                               void                    *src_p,
+                               vm_map_offset_t         dst_addr,
+                               vm_size_t               size);

 
 extern kern_return_t   vm_map_read_user(
 
 extern kern_return_t   vm_map_read_user(

-                               vm_map_t        map,
-                               vm_offset_t     src_addr,
-                               vm_offset_t     dst_addr,
-                               vm_size_t       size);
+                               vm_map_t                map,
+                               vm_map_offset_t         src_addr,
+                               void                    *dst_p,
+                               vm_size_t               size);

 
 /* Create a new task map using an existing task map as a template. */
 extern vm_map_t                vm_map_fork(
 
 /* Create a new task map using an existing task map as a template. */
 extern vm_map_t                vm_map_fork(

-                               vm_map_t        old_map);
+                               vm_map_t                old_map);

 
 /* Change inheritance */
 extern kern_return_t   vm_map_inherit(
 
 /* Change inheritance */
 extern kern_return_t   vm_map_inherit(

-                               vm_map_t        map,
-                               vm_offset_t     start,
-                               vm_offset_t     end,
-                               vm_inherit_t    new_inheritance);
+                               vm_map_t                map,
+                               vm_map_offset_t         start,
+                               vm_map_offset_t         end,
+                               vm_inherit_t            new_inheritance);

 
 /* Add or remove machine-dependent attributes from map regions */
 extern kern_return_t   vm_map_machine_attribute(
 
 /* Add or remove machine-dependent attributes from map regions */
 extern kern_return_t   vm_map_machine_attribute(

-                               vm_map_t        map,
-                               vm_offset_t     address,
-                               vm_size_t       size,
+                               vm_map_t                map,
+                               vm_map_offset_t         start,
+                               vm_map_offset_t         end,

                                vm_machine_attribute_t  attribute,
                                vm_machine_attribute_val_t* value); /* IN/OUT */
                                vm_machine_attribute_t  attribute,
                                vm_machine_attribute_val_t* value); /* IN/OUT */

+
+extern kern_return_t   vm_map_msync(
+                               vm_map_t                map,
+                               vm_map_address_t        address,
+                               vm_map_size_t           size,
+                               vm_sync_t               sync_flags);
+

 /* Set paging behavior */
 extern kern_return_t   vm_map_behavior_set(
 /* Set paging behavior */
 extern kern_return_t   vm_map_behavior_set(

-                               vm_map_t        map,
-                               vm_offset_t     start,
-                               vm_offset_t     end,
-                               vm_behavior_t   new_behavior);
+                               vm_map_t                map,
+                               vm_map_offset_t         start,
+                               vm_map_offset_t         end,
+                               vm_behavior_t           new_behavior);
+
+extern kern_return_t vm_map_purgable_control(
+                               vm_map_t                map,
+                               vm_map_offset_t         address,
+                               vm_purgable_t           control,
+                               int                     *state);
+
+extern kern_return_t vm_map_region(
+                               vm_map_t                 map,
+                               vm_map_offset_t         *address,
+                               vm_map_size_t           *size,
+                               vm_region_flavor_t       flavor,
+                               vm_region_info_t         info,
+                               mach_msg_type_number_t  *count,
+                               mach_port_t             *object_name);
+
+extern kern_return_t vm_map_region_recurse_64(
+                               vm_map_t                 map,
+                               vm_map_offset_t         *address,
+                               vm_map_size_t           *size,
+                               natural_t               *nesting_depth,
+                               vm_region_submap_info_64_t info,
+                               mach_msg_type_number_t  *count);
+
+extern kern_return_t vm_map_page_info(
+                               vm_map_t                map,
+                               vm_map_offset_t         offset,
+                               int                     *disposition,
+                               int                     *ref_count);

 
 extern kern_return_t   vm_map_submap(
 
 extern kern_return_t   vm_map_submap(

-                               vm_map_t        map,
-                               vm_offset_t     start,
-                               vm_offset_t     end,
-                               vm_map_t        submap,
-                               vm_offset_t     offset,
-                               boolean_t       use_pmap);
+                               vm_map_t                map,
+                               vm_map_offset_t         start,
+                               vm_map_offset_t         end,
+                               vm_map_t                submap,
+                               vm_map_offset_t         offset,
+                               boolean_t               use_pmap);
+
+extern void vm_map_submap_pmap_clean(
+       vm_map_t        map,
+       vm_map_offset_t start,
+       vm_map_offset_t end,
+       vm_map_t        sub_map,
+       vm_map_offset_t offset);
+
+/* Convert from a map entry port to a map */
+extern vm_map_t convert_port_entry_to_map(
+       ipc_port_t      port);
+
+/* Convert from a port to a vm_object */
+extern vm_object_t convert_port_entry_to_object(
+       ipc_port_t      port);

 
 
 #endif /* MACH_KERNEL_PRIVATE */
 
 
 
 #endif /* MACH_KERNEL_PRIVATE */
 

+__BEGIN_DECLS
+

 /* Create an empty map */
 extern vm_map_t                vm_map_create(
 /* Create an empty map */
 extern vm_map_t                vm_map_create(

-                               pmap_t          pmap,
-                               vm_offset_t     min,
-                               vm_offset_t     max,
-                               boolean_t       pageable);
+                               pmap_t                  pmap,
+                               vm_map_offset_t         min_off,
+                               vm_map_offset_t         max_off,
+                               boolean_t               pageable);

 
 /* Get rid of a map */
 extern void            vm_map_destroy(
 
 /* Get rid of a map */
 extern void            vm_map_destroy(

-                               vm_map_t        map);
+                               vm_map_t                map);

 /* Lose a reference */
 extern void            vm_map_deallocate(
 /* Lose a reference */
 extern void            vm_map_deallocate(

-                               vm_map_t        map);
+                               vm_map_t                map);
+
+extern vm_map_t                vm_map_switch(
+                               vm_map_t                map);

 
 /* Change protection */
 extern kern_return_t   vm_map_protect(
 
 /* Change protection */
 extern kern_return_t   vm_map_protect(

-                               vm_map_t        map,
-                               vm_offset_t     start,
-                               vm_offset_t     end,
-                               vm_prot_t       new_prot,
-                               boolean_t       set_max);
+                               vm_map_t                map,
+                               vm_map_offset_t         start,
+                               vm_map_offset_t         end,
+                               vm_prot_t               new_prot,
+                               boolean_t               set_max);
+
+/* Check protection */
+extern boolean_t vm_map_check_protection(
+                               vm_map_t                map,
+                               vm_map_offset_t         start,
+                               vm_map_offset_t         end,
+                               vm_prot_t               protection);

 
 /* wire down a region */
 extern kern_return_t   vm_map_wire(
 
 /* wire down a region */
 extern kern_return_t   vm_map_wire(

-                               vm_map_t        map,
-                               vm_offset_t     start,
-                               vm_offset_t     end,
-                               vm_prot_t       access_type,
-                               boolean_t       user_wire);
+                               vm_map_t                map,
+                               vm_map_offset_t         start,
+                               vm_map_offset_t         end,
+                               vm_prot_t               access_type,
+                               boolean_t               user_wire);

 
 /* unwire a region */
 extern kern_return_t   vm_map_unwire(
 
 /* unwire a region */
 extern kern_return_t   vm_map_unwire(

-                               vm_map_t        map,
-                               vm_offset_t     start,
-                               vm_offset_t     end,
-                               boolean_t       user_wire);
+                               vm_map_t                map,
+                               vm_map_offset_t         start,
+                               vm_map_offset_t         end,
+                               boolean_t               user_wire);

 
 /* Deallocate a region */
 extern kern_return_t   vm_map_remove(
 
 /* Deallocate a region */
 extern kern_return_t   vm_map_remove(

-                               vm_map_t        map,
-                               vm_offset_t     start,
-                               vm_offset_t     end,
-                               boolean_t       flags);
+                               vm_map_t                map,
+                               vm_map_offset_t         start,
+                               vm_map_offset_t         end,
+                               boolean_t               flags);
+
+/* Discard a copy without using it */
+extern void            vm_map_copy_discard(
+                               vm_map_copy_t           copy);
+
+/* Overwrite existing memory with a copy */
+extern kern_return_t   vm_map_copy_overwrite(
+                               vm_map_t                dst_map,
+                               vm_map_address_t        dst_addr,
+                               vm_map_copy_t           copy,
+                               int                     interruptible);

 
 /* Place a copy into a map */
 extern kern_return_t   vm_map_copyout(
 
 /* Place a copy into a map */
 extern kern_return_t   vm_map_copyout(

-                               vm_map_t        dst_map,
-                               vm_offset_t     *dst_addr,      /* OUT */
-                               vm_map_copy_t   copy);
+                               vm_map_t                dst_map,
+                               vm_map_address_t        *dst_addr,      /* OUT */
+                               vm_map_copy_t           copy);

 
 extern kern_return_t   vm_map_copyin_common(
 
 extern kern_return_t   vm_map_copyin_common(

-                               vm_map_t        src_map,
-                               vm_offset_t     src_addr,
-                               vm_size_t       len,
-                               boolean_t       src_destroy,
-                               boolean_t       src_volatile,
-                               vm_map_copy_t   *copy_result,   /* OUT */
-                               boolean_t       use_maxprot);
+                               vm_map_t                src_map,
+                               vm_map_address_t        src_addr,
+                               vm_map_size_t           len,
+                               boolean_t               src_destroy,
+                               boolean_t               src_volatile,
+                               vm_map_copy_t           *copy_result,   /* OUT */
+                               boolean_t               use_maxprot);

 
 

-extern kern_return_t vm_region_clone(
-                               ipc_port_t      src_region,
-                               ipc_port_t      dst_region);
+extern void            vm_map_disable_NX(
+                               vm_map_t                map);

 
 

-extern kern_return_t vm_map_region_replace(
-                               vm_map_t        target_map,
-                               ipc_port_t      old_region,
-                               ipc_port_t      new_region,
-                               vm_offset_t     start,  
-                               vm_offset_t     end);
+extern void            vm_map_set_64bit(
+                               vm_map_t                map);
+
+extern void            vm_map_set_32bit(
+                               vm_map_t                map);
+
+extern boolean_t       vm_map_has_4GB_pagezero(
+                               vm_map_t                map);
+
+extern void            vm_map_set_4GB_pagezero(
+                               vm_map_t                map);
+
+extern void            vm_map_clear_4GB_pagezero(
+                               vm_map_t                map);
+
+extern kern_return_t   vm_map_raise_min_offset(
+       vm_map_t        map,
+       vm_map_offset_t new_min_offset);
+
+extern vm_map_offset_t vm_compute_max_offset(
+                               unsigned                is64);

 
 /*
  *     Macros to invoke vm_map_copyin_common.  vm_map_copyin is the
 
 /*
  *     Macros to invoke vm_map_copyin_common.  vm_map_copyin is the


@@ -886,6 +890,12 @@ extern kern_return_t vm_map_region_replace(
                vm_map_copyin_common(src_map, src_addr, len, src_destroy, \
                                        FALSE, copy_result, TRUE)
 
                vm_map_copyin_common(src_map, src_addr, len, src_destroy, \
                                        FALSE, copy_result, TRUE)
 

+/*
+ * Macros for rounding and truncation of vm_map offsets and sizes
+ */
+#define vm_map_round_page(x) (((vm_map_offset_t)(x) + PAGE_MASK) & ~((signed)PAGE_MASK))
+#define vm_map_trunc_page(x) ((vm_map_offset_t)(x) & ~((signed)PAGE_MASK))     
+

 /*
  * Flags for vm_map_remove() and vm_map_delete()
  */
 /*
  * Flags for vm_map_remove() and vm_map_delete()
  */


@@ -893,8 +903,34 @@ extern kern_return_t vm_map_region_replace(
 #define        VM_MAP_REMOVE_KUNWIRE           0x1
 #define        VM_MAP_REMOVE_INTERRUPTIBLE     0x2
 #define        VM_MAP_REMOVE_WAIT_FOR_KWIRE    0x4
 #define        VM_MAP_REMOVE_KUNWIRE           0x1
 #define        VM_MAP_REMOVE_INTERRUPTIBLE     0x2
 #define        VM_MAP_REMOVE_WAIT_FOR_KWIRE    0x4

+#define VM_MAP_REMOVE_SAVE_ENTRIES     0x8
+
+/* Support for shared regions */
+extern kern_return_t vm_region_clone(
+                               ipc_port_t              src_region,
+                               ipc_port_t              dst_region);

 
 

-#endif  /* __APPLE_API_PRIVATE */
+extern kern_return_t vm_map_region_replace(
+                               vm_map_t                target_map,
+                               ipc_port_t              old_region,
+                               ipc_port_t              new_region,
+                               vm_map_offset_t         start,  
+                               vm_map_offset_t         end);
+
+/* Support for UPLs from vm_maps */
+
+extern kern_return_t vm_map_get_upl(
+                               vm_map_t                target_map,
+                               vm_map_offset_t         map_offset,
+                               vm_size_t               *size,
+                               upl_t                   *upl,
+                               upl_page_info_array_t   page_info,
+                               mach_msg_type_number_t  *page_infoCnt,
+                               integer_t               *flags,
+                               integer_t               force_data_sync);
+
+__END_DECLS
+
+#endif /* KERNEL_PRIVATE */

  
 #endif /* _VM_VM_MAP_H_ */
  
 #endif /* _VM_VM_MAP_H_ */

-