libsyscall/mach/mach_vm.c

   1 /*
   2  * Copyright (c) 2011 Apple 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 /*
  30  * Make sure we don't accidentally include the external definitions of
  31  * the routines we're interposing on below.
  32  */
  33 #define _vm_map_user_
  34 #define _mach_vm_user_
  35 #include <mach/mach.h>
  36 #include <mach/mach_traps.h>
  37 #undef _vm_map_user_
  38 #include <mach/vm_map_internal.h>
  39 #undef _mach_vm_user_
  40 #include <mach/mach_vm_internal.h>
  41
  42 #include "stack_logging_internal.h"
  43
  44 malloc_logger_t *__syscall_logger = NULL;   // This may get set by Libc's malloc stack logging initialization code.
  45
  46 kern_return_t
  47 mach_vm_allocate(
  48         mach_port_name_t target,
  49         mach_vm_address_t *address,
  50         mach_vm_size_t size,
  51         int flags)
  52 {
  53         kern_return_t rv;
  54
  55         rv = _kernelrpc_mach_vm_allocate_trap(target, address, size, flags);
  56
  57         if (rv == MACH_SEND_INVALID_DEST) {
  58                 rv = _kernelrpc_mach_vm_allocate(target, address, size, flags);
  59         }
  60
  61         if (__syscall_logger && rv == KERN_SUCCESS && !(flags & VM_MAKE_TAG(VM_MEMORY_STACK))) {
  62                 int userTagFlags = flags & VM_FLAGS_ALIAS_MASK;
  63                 __syscall_logger(stack_logging_type_vm_allocate | userTagFlags, (uintptr_t)target, (uintptr_t)size, 0, (uintptr_t)*address, 0);
  64         }
  65
  66         return rv;
  67 }
  68
  69 kern_return_t
  70 mach_vm_deallocate(
  71         mach_port_name_t target,
  72         mach_vm_address_t address,
  73         mach_vm_size_t size)
  74 {
  75         kern_return_t rv;
  76
  77         if (__syscall_logger) {
  78                 __syscall_logger(stack_logging_type_vm_deallocate, (uintptr_t)target, (uintptr_t)address, (uintptr_t)size, 0, 0);
  79         }
  80
  81         rv = _kernelrpc_mach_vm_deallocate_trap(target, address, size);
  82
  83         if (rv == MACH_SEND_INVALID_DEST) {
  84                 rv = _kernelrpc_mach_vm_deallocate(target, address, size);
  85         }
  86
  87         return rv;
  88 }
  89
  90 kern_return_t
  91 mach_vm_protect(
  92         mach_port_name_t task,
  93         mach_vm_address_t address,
  94         mach_vm_size_t size,
  95         boolean_t set_maximum,
  96         vm_prot_t new_protection)
  97 {
  98         kern_return_t rv;
  99
 100         rv = _kernelrpc_mach_vm_protect_trap(task, address, size, set_maximum,
 101             new_protection);
 102
 103         if (rv == MACH_SEND_INVALID_DEST) {
 104                 rv = _kernelrpc_mach_vm_protect(task, address, size,
 105                     set_maximum, new_protection);
 106         }
 107
 108         return rv;
 109 }
 110
 111 kern_return_t
 112 vm_allocate(
 113         mach_port_name_t task,
 114         vm_address_t *address,
 115         vm_size_t size,
 116         int flags)
 117 {
 118         kern_return_t rv;
 119         mach_vm_address_t mach_addr;
 120
 121         mach_addr = (mach_vm_address_t)*address;
 122         rv = mach_vm_allocate(task, &mach_addr, size, flags);
 123 #if defined(__LP64__)
 124         *address = mach_addr;
 125 #else
 126         *address = (vm_address_t)(mach_addr & ((vm_address_t)-1));
 127 #endif
 128
 129         return rv;
 130 }
 131
 132 kern_return_t
 133 vm_deallocate(
 134         mach_port_name_t task,
 135         vm_address_t address,
 136         vm_size_t size)
 137 {
 138         kern_return_t rv;
 139
 140         rv = mach_vm_deallocate(task, address, size);
 141
 142         return rv;
 143 }
 144
 145 kern_return_t
 146 vm_protect(
 147         mach_port_name_t task,
 148         vm_address_t address,
 149         vm_size_t size,
 150         boolean_t set_maximum,
 151         vm_prot_t new_protection)
 152 {
 153         kern_return_t rv;
 154
 155         rv = mach_vm_protect(task, address, size, set_maximum, new_protection);
 156
 157         return rv;
 158 }
 159
 160 kern_return_t
 161 mach_vm_map(
 162         mach_port_name_t target,
 163         mach_vm_address_t *address,
 164         mach_vm_size_t size,
 165         mach_vm_offset_t mask,
 166         int flags,
 167         mem_entry_name_port_t object,
 168         memory_object_offset_t offset,
 169         boolean_t copy,
 170         vm_prot_t cur_protection,
 171         vm_prot_t max_protection,
 172         vm_inherit_t inheritance)
 173 {
 174         kern_return_t rv = MACH_SEND_INVALID_DEST;
 175
 176         if (object == MEMORY_OBJECT_NULL && max_protection == VM_PROT_ALL &&
 177             inheritance == VM_INHERIT_DEFAULT) {
 178                 rv = _kernelrpc_mach_vm_map_trap(target, address, size, mask, flags,
 179                     cur_protection);
 180         }
 181
 182         if (rv == MACH_SEND_INVALID_DEST) {
 183                 rv = _kernelrpc_mach_vm_map(target, address, size, mask, flags, object,
 184                     offset, copy, cur_protection, max_protection, inheritance);
 185         }
 186
 187         if (__syscall_logger && rv == KERN_SUCCESS && !(flags & VM_MAKE_TAG(VM_MEMORY_STACK))) {
 188                 int eventTypeFlags = stack_logging_type_vm_allocate | stack_logging_type_mapped_file_or_shared_mem;
 189                 int userTagFlags = flags & VM_FLAGS_ALIAS_MASK;
 190                 __syscall_logger(eventTypeFlags | userTagFlags, (uintptr_t)target, (uintptr_t)size, 0, (uintptr_t)*address, 0);
 191         }
 192
 193         return rv;
 194 }
 195
 196 kern_return_t
 197 mach_vm_remap(
 198         mach_port_name_t target,
 199         mach_vm_address_t *address,
 200         mach_vm_size_t size,
 201         mach_vm_offset_t mask,
 202         int flags,
 203         mach_port_name_t src_task,
 204         mach_vm_address_t src_address,
 205         boolean_t copy,
 206         vm_prot_t *cur_protection,
 207         vm_prot_t *max_protection,
 208         vm_inherit_t inheritance)
 209 {
 210         kern_return_t rv;
 211
 212         rv = _kernelrpc_mach_vm_remap(target, address, size, mask, flags,
 213             src_task, src_address, copy, cur_protection, max_protection,
 214             inheritance);
 215
 216         if (__syscall_logger && rv == KERN_SUCCESS) {
 217                 int eventTypeFlags = stack_logging_type_vm_allocate | stack_logging_type_mapped_file_or_shared_mem;
 218                 int userTagFlags = flags & VM_FLAGS_ALIAS_MASK;
 219                 __syscall_logger(eventTypeFlags | userTagFlags, (uintptr_t)target, (uintptr_t)size, 0, (uintptr_t)*address, 0);
 220         }
 221
 222         return rv;
 223 }
 224
 225 kern_return_t
 226 mach_vm_read(
 227         mach_port_name_t target,
 228         mach_vm_address_t address,
 229         mach_vm_size_t size,
 230         vm_offset_t *data,
 231         mach_msg_type_number_t *dataCnt)
 232 {
 233         kern_return_t rv;
 234
 235         rv = _kernelrpc_mach_vm_read(target, address, size, data, dataCnt);
 236
 237         if (__syscall_logger && rv == KERN_SUCCESS) {
 238                 int eventTypeFlags = stack_logging_type_vm_allocate | stack_logging_type_mapped_file_or_shared_mem;
 239                 // The target argument is the remote task from which data is being read,
 240                 // so pass mach_task_self() as the destination task receiving the allocation.
 241                 __syscall_logger(eventTypeFlags, (uintptr_t)mach_task_self(), (uintptr_t)*dataCnt, 0, *data, 0);
 242         }
 243
 244         return rv;
 245 }
 246
 247 kern_return_t
 248 vm_map(
 249         mach_port_name_t target,
 250         vm_address_t *address,
 251         vm_size_t size,
 252         vm_offset_t mask,
 253         int flags,
 254         mem_entry_name_port_t object,
 255         vm_offset_t offset,
 256         boolean_t copy,
 257         vm_prot_t cur_protection,
 258         vm_prot_t max_protection,
 259         vm_inherit_t inheritance)
 260 {
 261         kern_return_t rv;
 262
 263         rv = _kernelrpc_vm_map(target, address, size, mask, flags, object,
 264             offset, copy, cur_protection, max_protection, inheritance);
 265
 266         if (__syscall_logger && rv == KERN_SUCCESS) {
 267                 int eventTypeFlags = stack_logging_type_vm_allocate | stack_logging_type_mapped_file_or_shared_mem;
 268                 int userTagFlags = flags & VM_FLAGS_ALIAS_MASK;
 269                 __syscall_logger(eventTypeFlags | userTagFlags, (uintptr_t)target, (uintptr_t)size, 0, (uintptr_t)*address, 0);
 270         }
 271
 272         return rv;
 273 }
 274
 275 kern_return_t
 276 vm_remap(
 277         mach_port_name_t target,
 278         vm_address_t *address,
 279         vm_size_t size,
 280         vm_offset_t mask,
 281         int flags,
 282         mach_port_name_t src_task,
 283         vm_address_t src_address,
 284         boolean_t copy,
 285         vm_prot_t *cur_protection,
 286         vm_prot_t *max_protection,
 287         vm_inherit_t inheritance)
 288 {
 289         kern_return_t rv;
 290
 291         rv = _kernelrpc_vm_remap(target, address, size, mask, flags,
 292             src_task, src_address, copy, cur_protection, max_protection,
 293             inheritance);
 294
 295         if (__syscall_logger) {
 296                 int eventTypeFlags = stack_logging_type_vm_allocate | stack_logging_type_mapped_file_or_shared_mem;
 297                 int userTagFlags = flags & VM_FLAGS_ALIAS_MASK;
 298                 __syscall_logger(eventTypeFlags | userTagFlags, (uintptr_t)target, (uintptr_t)size, 0, (uintptr_t)*address, 0);
 299         }
 300
 301         return rv;
 302 }
 303
 304 kern_return_t
 305 vm_read(
 306         mach_port_name_t target,
 307         vm_address_t address,
 308         vm_size_t size,
 309         vm_offset_t *data,
 310         mach_msg_type_number_t *dataCnt)
 311 {
 312         kern_return_t rv;
 313
 314         rv = _kernelrpc_vm_read(target, address, size, data, dataCnt);
 315
 316         if (__syscall_logger && rv == KERN_SUCCESS) {
 317                 int eventTypeFlags = stack_logging_type_vm_allocate | stack_logging_type_mapped_file_or_shared_mem;
 318                 // The target argument is the remote task from which data is being read,
 319                 // so pass mach_task_self() as the destination task receiving the allocation.
 320                 __syscall_logger(eventTypeFlags, (uintptr_t)mach_task_self(), (uintptr_t)*dataCnt, 0, *data, 0);
 321         }
 322
 323         return rv;
 324 }
 325
 326 kern_return_t
 327 mach_vm_purgable_control(
 328         mach_port_name_t        target,
 329         mach_vm_offset_t        address,
 330         vm_purgable_t           control,
 331         int                     *state)
 332 {
 333         kern_return_t rv;
 334
 335         rv = _kernelrpc_mach_vm_purgable_control_trap(target, address, control, state);
 336
 337         if (rv == MACH_SEND_INVALID_DEST) {
 338                 rv = _kernelrpc_mach_vm_purgable_control(target, address, control, state);
 339         }
 340
 341         return rv;
 342 }
 343
 344 kern_return_t
 345 vm_purgable_control(
 346         mach_port_name_t        task,
 347         vm_offset_t             address,
 348         vm_purgable_t           control,
 349         int                     *state)
 350 {
 351         return mach_vm_purgable_control(task,
 352                    (mach_vm_offset_t) address,
 353                    control,
 354                    state);
 355 }