/* * Copyright (c) 2024 Apple 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 * 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 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. * Please see the License for the specific language governing rights and * limitations under the License. * * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ */ #ifndef _VM_UNSAFE_TYPES_H_ #define _VM_UNSAFE_TYPES_H_ #include /* * Macro to generate a wrapped "struct" that preserves ABI, * but prevents direct manipulation of the type. * * The transparent union is needed because of arm64 which for "Composite" * arguments passed on the stack will align them to 8 byte boundaries as per * spec: * * If the argument is an alignment adjusted type its value is passed as * a copy of the actual value. The copy will have an alignment defined as * follows: * * - For a Fundamental Data Type, the alignment is the natural alignment * of that type, after any promotions. * - For a Composite Type, the alignment of the copy will have 8-byte * alignment if its natural alignment is ≤ 8 and 16-byte alignment * if its natural alignment is ≥ 16. */ #if defined(__cplusplus) #define VM_GENERATE_UNSAFE_WRAPPER(_safe_type, _unsafe_type) \ typedef _safe_type _unsafe_type #else #define VM_GENERATE_UNSAFE_WRAPPER(_safe_type, _unsafe_type) \ typedef union { _safe_type UNSAFE; } _unsafe_type \ __attribute__((transparent_union)); \ _Static_assert(sizeof(_safe_type) == sizeof(_unsafe_type), \ "Size mismatch between unsafe and safe versions of a type") #endif VM_GENERATE_UNSAFE_WRAPPER(uint64_t, vm_addr_struct_t); VM_GENERATE_UNSAFE_WRAPPER(uint64_t, vm_size_struct_t); VM_GENERATE_UNSAFE_WRAPPER(uint32_t, vm32_addr_struct_t); VM_GENERATE_UNSAFE_WRAPPER(uint32_t, vm32_size_struct_t); /* * Macros used to create a struct-wrapped type (called "unsafe" type) * around a standard VM type. */ #if VM_UNSAFE_TYPES #if defined(__cplusplus) /* * C++ doesn't support transparent_unions which fortunately isn't something * we need, as files who need to see unsafe types as structs are all C code */ #error "Can't turn on unsafe types in C++" #endif /* * For defining a custom unsafe type that doesn't directly follow the * transparent union model, and needs to be properly typedef'd outside of * the VM subsystem. */ #define VM_DEFINE_UNSAFE_TYPE(_safe_type, _unsafe_type, _unsafe_contents) \ typedef _unsafe_contents _unsafe_type; \ _Static_assert( \ ( \ sizeof(_unsafe_type) \ == sizeof(_safe_type)) \ && ( \ _Alignof(_unsafe_type) \ == _Alignof(_safe_type)), \ "Unsafe type should be compatible with corresponding safe type.") #define VM_GENERATE_UNSAFE_TYPE(_safe_type, _unsafe_type) \ VM_GENERATE_UNSAFE_WRAPPER(_safe_type, _unsafe_type) #define VM_GENERATE_UNSAFE_BSD_TYPE(_safe_type, _unsafe_type) \ VM_GENERATE_UNSAFE_WRAPPER(_safe_type, _unsafe_type) /* * Don't use this variant directly. Use VM_GENERATE_UNSAFE_ADDR or * VM_GENERATE_UNSAFE_SIZE. */ #define VM_GENERATE_UNSAFE_EXT(_safe_type, _unsafe_type, variant, size) \ typedef vm ## size ## _ ## variant ## _struct_t _unsafe_type; \ _Static_assert(sizeof(_safe_type) == sizeof(_unsafe_type), \ "Size mismatch between unsafe and safe versions of a type") \ #define VM_GENERATE_UNSAFE_BSD_EXT(_safe_type, _unsafe_type, variant, size) \ typedef vm ## size ## _ ## variant ## _struct_t _unsafe_type; \ _Static_assert(sizeof(_safe_type) == sizeof(_unsafe_type), \ "Size mismatch between unsafe and safe versions of a type") /* * Use these variants for addresses and sizes as some types of addr/size * are unsigned longs while others are unsigned long longs. Compiler * is unhappy about conversions between unsafe pointers of the two. */ #define VM_GENERATE_UNSAFE_ADDR(_safe_type, _unsafe_type) \ VM_GENERATE_UNSAFE_EXT(_safe_type, _unsafe_type, addr, ) #define VM_GENERATE_UNSAFE_SIZE(_safe_type, _unsafe_type) \ VM_GENERATE_UNSAFE_EXT(_safe_type, _unsafe_type, size, ) #define VM_GENERATE_UNSAFE_BSD_ADDR(_safe_type, _unsafe_type) \ VM_GENERATE_UNSAFE_EXT(_safe_type, _unsafe_type, addr, ) #define VM_GENERATE_UNSAFE_BSD_SIZE(_safe_type, _unsafe_type) \ VM_GENERATE_UNSAFE_EXT(_safe_type, _unsafe_type, size, ) #define VM_GENERATE_UNSAFE_ADDR32(_safe_type, _unsafe_type) \ VM_GENERATE_UNSAFE_EXT(_safe_type, _unsafe_type, addr, 32) #define VM_GENERATE_UNSAFE_SIZE32(_safe_type, _unsafe_type) \ VM_GENERATE_UNSAFE_EXT(_safe_type, _unsafe_type, size, 32) #else /* VM_UNSAFE_TYPES */ #define VM_DEFINE_UNSAFE_TYPE(_safe_type, _unsafe_type, _unsafe_contents) \ typedef _safe_type _unsafe_type #define VM_GENERATE_UNSAFE_TYPE(_safe_type, _unsafe_type) \ VM_DEFINE_UNSAFE_TYPE(_safe_type, _unsafe_type, ) #define VM_GENERATE_UNSAFE_ADDR(_safe_type, _unsafe_type) \ VM_GENERATE_UNSAFE_TYPE(_safe_type, _unsafe_type) #define VM_GENERATE_UNSAFE_SIZE(_safe_type, _unsafe_type) \ VM_GENERATE_UNSAFE_TYPE(_safe_type, _unsafe_type) #define VM_GENERATE_UNSAFE_ADDR32(_safe_type, _unsafe_type) \ VM_GENERATE_UNSAFE_TYPE(_safe_type, _unsafe_type) #define VM_GENERATE_UNSAFE_SIZE32(_safe_type, _unsafe_type) \ VM_GENERATE_UNSAFE_TYPE(_safe_type, _unsafe_type) #endif /* VM_UNSAFE_TYPES */ VM_GENERATE_UNSAFE_ADDR(mach_vm_address_t, mach_vm_address_ut); VM_GENERATE_UNSAFE_ADDR(mach_vm_offset_t, mach_vm_offset_ut); VM_GENERATE_UNSAFE_SIZE(mach_vm_size_t, mach_vm_size_ut); VM_GENERATE_UNSAFE_ADDR(vm_address_t, vm_address_ut); VM_GENERATE_UNSAFE_ADDR(vm_offset_t, vm_offset_ut); VM_GENERATE_UNSAFE_SIZE(vm_size_t, vm_size_ut); VM_GENERATE_UNSAFE_ADDR(vm_map_address_t, vm_map_address_ut); VM_GENERATE_UNSAFE_ADDR(vm_map_offset_t, vm_map_offset_ut); VM_GENERATE_UNSAFE_SIZE(vm_map_size_t, vm_map_size_ut); VM_GENERATE_UNSAFE_ADDR(memory_object_offset_t, memory_object_offset_ut); VM_GENERATE_UNSAFE_SIZE(memory_object_size_t, memory_object_size_ut); VM_GENERATE_UNSAFE_ADDR(vm_object_offset_t, vm_object_offset_ut); VM_GENERATE_UNSAFE_SIZE(vm_object_size_t, vm_object_size_ut); VM_GENERATE_UNSAFE_ADDR(pointer_t, pointer_ut); #ifdef MACH_KERNEL_PRIVATE VM_GENERATE_UNSAFE_ADDR32(vm32_address_t, vm32_address_ut); VM_GENERATE_UNSAFE_ADDR32(vm32_offset_t, vm32_offset_ut); VM_GENERATE_UNSAFE_SIZE32(vm32_size_t, vm32_size_ut); #endif /* MACH_KERNEL_PRIVATE */ VM_GENERATE_UNSAFE_TYPE(vm_prot_t, vm_prot_ut); VM_GENERATE_UNSAFE_TYPE(vm_inherit_t, vm_inherit_ut); VM_GENERATE_UNSAFE_TYPE(vm_behavior_t, vm_behavior_ut); #if VM_UNSAFE_TYPES VM_GENERATE_UNSAFE_BSD_ADDR(caddr_t, caddr_ut); VM_GENERATE_UNSAFE_BSD_ADDR(user_addr_t, user_addr_ut); VM_GENERATE_UNSAFE_BSD_SIZE(size_t, size_ut); VM_GENERATE_UNSAFE_BSD_SIZE(user_size_t, user_size_ut); #endif /* VM_UNSAFE_TYPES */ VM_DEFINE_UNSAFE_TYPE(struct mach_vm_range, mach_vm_range_ut, struct { mach_vm_offset_ut min_address_u; mach_vm_offset_ut max_address_u; }); #pragma pack(1) VM_DEFINE_UNSAFE_TYPE(mach_vm_range_recipe_v1_t, mach_vm_range_recipe_v1_ut, struct { mach_vm_range_flags_t flags: 48; mach_vm_range_tag_t range_tag: 8; uint8_t vm_tag: 8; mach_vm_range_ut range_u; }); #pragma pack() #endif /* _VM_UNSAFE_TYPES_H_ */