osfmk/mach/vm32_map.defs

   1 /*
   2  * Copyright (c) 2000-2004 Apple Computer, Inc. All rights reserved.
   3  *
   4  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. The rights granted to you under the License
  10  * may not be used to create, or enable the creation or redistribution of,
  11  * unlawful or unlicensed copies of an Apple operating system, or to
  12  * circumvent, violate, or enable the circumvention or violation of, any
  13  * terms of an Apple operating system software license agreement.
  14  *
  15  * Please obtain a copy of the License at
  16  * http://www.opensource.apple.com/apsl/ and read it before using this file.
  17  *
  18  * The Original Code and all software distributed under the License are
  19  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  20  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  21  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  23  * Please see the License for the specific language governing rights and
  24  * limitations under the License.
  25  *
  26  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  27  */
  28 /*
  29  * @OSF_FREE_COPYRIGHT@
  30  */
  31 /*
  32  * Mach Operating System
  33  * Copyright (c) 1991,1990,1989 Carnegie Mellon University
  34  * All Rights Reserved.
  35  *
  36  * Permission to use, copy, modify and distribute this software and its
  37  * documentation is hereby granted, provided that both the copyright
  38  * notice and this permission notice appear in all copies of the
  39  * software, derivative works or modified versions, and any portions
  40  * thereof, and that both notices appear in supporting documentation.
  41  *
  42  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
  43  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
  44  * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
  45  *
  46  * Carnegie Mellon requests users of this software to return to
  47  *
  48  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
  49  *  School of Computer Science
  50  *  Carnegie Mellon University
  51  *  Pittsburgh PA 15213-3890
  52  *
  53  * any improvements or extensions that they make and grant Carnegie Mellon
  54  * the rights to redistribute these changes.
  55  */
  56 /*
  57  */
  58 /*
  59  *      File:   mach/vm_map.defs
  60  *
  61  *      Exported kernel VM calls for 32-bit client tasks.
  62  */
  63
  64 subsystem
  65 #if     KERNEL_SERVER
  66           KernelServer
  67 #endif  /* KERNEL_SERVER */
  68           map 3800;
  69
  70 serverprefix vm32_;
  71
  72 #include <mach/std_types.defs>
  73 #include <mach/mach_types.defs>
  74 #include <mach_debug/mach_debug_types.defs>
  75
  76 #if VM32_SUPPORT
  77
  78 /* See vm_map.defs for more information */
  79
  80 routine region(
  81                 target_task     : vm_map_t;
  82         inout   address         : vm32_address_t;
  83         out     size            : vm32_size_t;
  84                 flavor          : vm_region_flavor_t;
  85         out     info            : vm_region_info_t, CountInOut;
  86         out     object_name     : memory_object_name_t =
  87                                         MACH_MSG_TYPE_MOVE_SEND
  88                                         ctype: mach_port_t);
  89
  90 routine allocate(
  91                 target_task     : vm_task_entry_t;
  92         inout   address         : vm32_address_t;
  93                 size            : vm32_size_t;
  94                 flags           : int);
  95
  96 routine deallocate(
  97                 target_task     : vm_task_entry_t;
  98                 address         : vm32_address_t;
  99                 size            : vm32_size_t);
 100
 101 routine protect(
 102                 target_task     : vm_task_entry_t;
 103                 address         : vm32_address_t;
 104                 size            : vm32_size_t;
 105                 set_maximum     : boolean_t;
 106                 new_protection  : vm_prot_t);
 107
 108 routine inherit(
 109                 target_task     : vm_task_entry_t;
 110                 address         : vm32_address_t;
 111                 size            : vm32_size_t;
 112                 new_inheritance : vm_inherit_t);
 113
 114 routine read(
 115                 target_task     : vm_map_t;
 116                 address         : vm32_address_t;
 117                 size            : vm32_size_t;
 118         out     data            : pointer_t);
 119
 120 routine read_list(
 121                 target_task     : vm_map_t;
 122         inout   data_list       : vm32_read_entry_t;
 123                 count           : natural_t);
 124
 125 routine write(
 126                 target_task     : vm_map_t;
 127                 address         : vm32_address_t;
 128                 data            : pointer_t);
 129
 130 routine copy(
 131                 target_task     : vm_map_t;
 132                 source_address  : vm32_address_t;
 133                 size            : vm32_size_t;
 134                 dest_address    : vm32_address_t);
 135
 136 routine read_overwrite(
 137                 target_task     : vm_map_t;
 138                 address         : vm32_address_t;
 139                 size            : vm32_size_t;
 140                 data            : vm32_address_t;
 141         out     outsize         : vm32_size_t);
 142
 143
 144 routine msync(
 145                 target_task     : vm_map_t;
 146                 address         : vm32_address_t;
 147                 size            : vm32_size_t;
 148                 sync_flags      : vm_sync_t );
 149
 150 routine behavior_set(
 151                 target_task     : vm_map_t;
 152                 address         : vm32_address_t;
 153                 size            : vm32_size_t;
 154                 new_behavior    : vm_behavior_t);
 155
 156 routine map(
 157                 target_task     : vm_task_entry_t;
 158         inout   address         : vm32_address_t;
 159                 size            : vm32_size_t;
 160                 mask            : vm32_address_t;
 161                 flags           : int;
 162                 object          : mem_entry_name_port_t;
 163                 offset          : vm32_offset_t;
 164                 copy            : boolean_t;
 165                 cur_protection  : vm_prot_t;
 166                 max_protection  : vm_prot_t;
 167                 inheritance     : vm_inherit_t);
 168
 169 routine machine_attribute(
 170                 target_task     : vm_map_t;
 171                 address         : vm32_address_t;
 172                 size            : vm32_size_t;
 173                 attribute       : vm_machine_attribute_t;
 174         inout   value           : vm_machine_attribute_val_t);
 175
 176 routine remap(
 177                 target_task     : vm_map_t;
 178         inout   target_address  : vm32_address_t;
 179                 size            : vm32_size_t;
 180                 mask            : vm32_address_t;
 181                 anywhere        : boolean_t;
 182                 src_task        : vm_map_t;
 183                 src_address     : vm32_address_t;
 184                 copy            : boolean_t;
 185         out     cur_protection  : vm_prot_t;
 186         out     max_protection  : vm_prot_t;
 187                 inheritance     : vm_inherit_t);
 188
 189 routine _task_wire(
 190                 target_task     : vm_map_t;
 191                 must_wire       : boolean_t);
 192
 193 routine make_memory_entry(
 194                 target_task     :vm_map_t;
 195         inout   size            :vm32_size_t;
 196                 offset          :vm32_offset_t;
 197                 permission      :vm_prot_t;
 198         out     object_handle   :mem_entry_name_port_move_send_t;
 199                 parent_entry    :mem_entry_name_port_t);
 200
 201 routine map_page_query(
 202                 target_map      :vm_map_t;
 203                 offset          :vm32_offset_t;
 204         out     disposition     :integer_t;
 205         out     ref_count       :integer_t);
 206
 207 routine region_info(
 208                 task            : vm_map_t;
 209                 address         : vm32_address_t;
 210         out     region          : vm_info_region_t;
 211         out     objects         : vm_info_object_array_t);
 212
 213 routine mapped_pages_info(
 214                 task            : vm_map_t;
 215         out     pages           : page_address_array_t);
 216
 217 skip; /* was vm_region_object_create */
 218
 219 routine region_recurse(
 220                 target_task     : vm_map_t;
 221         inout   address         : vm32_address_t;
 222         out     size            : vm32_size_t;
 223         inout   nesting_depth   : natural_t;
 224         out     info            : vm_region_recurse_info_t,CountInOut);
 225
 226 routine region_recurse_64(
 227                 target_task     : vm_map_t;
 228         inout   address         : vm32_address_t;
 229         out     size            : vm32_size_t;
 230         inout   nesting_depth   : natural_t;
 231         out     info            : vm_region_recurse_info_t,CountInOut);
 232
 233 routine region_info_64(
 234                 task            : vm_map_t;
 235                 address         : vm32_address_t;
 236         out     region          : vm_info_region_64_t;
 237         out     objects         : vm_info_object_array_t);
 238
 239 routine region_64(
 240                 target_task     : vm_map_t;
 241         inout   address         : vm32_address_t;
 242         out     size            : vm32_size_t;
 243                 flavor          : vm_region_flavor_t;
 244         out     info            : vm_region_info_t, CountInOut;
 245         out     object_name     : memory_object_name_t =
 246                                         MACH_MSG_TYPE_MOVE_SEND
 247                                         ctype: mach_port_t);
 248
 249 routine make_memory_entry_64(
 250                 target_task     :vm_map_t;
 251         inout   size            :memory_object_size_t;
 252                 offset          :memory_object_offset_t;
 253                 permission      :vm_prot_t;
 254         out     object_handle   :mach_port_move_send_t;
 255                 parent_entry    :mem_entry_name_port_t);
 256
 257
 258
 259 routine map_64(
 260                 target_task     : vm_task_entry_t;
 261         inout   address         : vm32_address_t;
 262                 size            : vm32_size_t;
 263                 mask            : vm32_address_t;
 264                 flags           : int;
 265                 object          : mem_entry_name_port_t;
 266                 offset          : memory_object_offset_t;
 267                 copy            : boolean_t;
 268                 cur_protection  : vm_prot_t;
 269                 max_protection  : vm_prot_t;
 270                 inheritance     : vm_inherit_t);
 271
 272 skip; /* was vm_map_get_upl */
 273 skip; /* was vm_upl_map */
 274 skip; /* was vm_upl_unmap */
 275
 276 routine purgable_control(
 277                 target_task     : vm_map_t;
 278                 address         : vm32_address_t;
 279                 control         : vm_purgable_t;
 280         inout   state           : int);
 281
 282 #endif /* VM32_SUPPORT */
 283
 284 /* vim: set ft=c : */