X-Git-Url: https://git.saurik.com/apple/xnu.git/blobdiff_plain/de355530ae67247cbd0da700edb3a2a1dae884c2..4d15aeb193b2c68f1d38666c317f8d3734f5f083:/osfmk/ipc/ipc_space.h diff --git a/osfmk/ipc/ipc_space.h b/osfmk/ipc/ipc_space.h index 6ac534951..60662c8ee 100644 --- a/osfmk/ipc/ipc_space.h +++ b/osfmk/ipc/ipc_space.h @@ -1,23 +1,29 @@ /* - * Copyright (c) 2000 Apple Computer, Inc. All rights reserved. + * Copyright (c) 2000-2016 Apple Computer, Inc. All rights reserved. * - * @APPLE_LICENSE_HEADER_START@ + * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ * - * The contents of this file constitute Original Code as defined in and - * are subject to the Apple Public Source License Version 1.1 (the - * "License"). You may not use this file except in compliance with the - * License. Please obtain a copy of the License at - * http://www.apple.com/publicsource and read it before using this file. + * 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. * - * This Original Code and all software distributed under the License are - * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * 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 OR NON-INFRINGEMENT. Please see the - * License for the specific language governing rights and limitations - * under the License. + * 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_LICENSE_HEADER_END@ + * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ */ /* * @OSF_COPYRIGHT@ @@ -47,6 +53,12 @@ * any improvements or extensions that they make and grant Carnegie Mellon * the rights to redistribute these changes. */ +/* + * NOTICE: This file was modified by McAfee Research in 2004 to introduce + * support for mandatory and extensible security protections. This notice + * is included in support of clause 2.2 (b) of the Apple Public License, + * Version 2.0. + */ /* */ /* @@ -70,113 +82,132 @@ #ifdef __APPLE_API_PRIVATE #ifdef MACH_KERNEL_PRIVATE -#include #include #include -#include +#include #include #include #include -#include #include +#include + /* * Every task has a space of IPC capabilities. * IPC operations like send and receive use this space. * IPC kernel calls manipulate the space of the target task. * * Every space has a non-NULL is_table with is_table_size entries. - * A space may have a NULL is_tree. is_tree_small records the - * number of entries in the tree that, if the table were to grow - * to the next larger size, would move from the tree to the table. - * - * is_growing marks when the table is in the process of growing. - * When the table is growing, it can't be freed or grown by another - * thread, because of krealloc/kmem_realloc's requirements. * + * Only one thread can be growing the space at a time. Others + * that need it grown wait for the first. We do almost all the + * work with the space unlocked, so lookups proceed pretty much + * unaffected while the grow operation is underway. */ typedef natural_t ipc_space_refs_t; +#define IS_REFS_MAX 0x0fffffff +#define IS_INACTIVE 0x40000000 /* space is inactive */ +#define IS_GROWING 0x20000000 /* space is growing */ struct ipc_space { - decl_mutex_data(,is_ref_lock_data) - ipc_space_refs_t is_references; - - decl_mutex_data(,is_lock_data) - boolean_t is_active; /* is the space alive? */ - boolean_t is_growing; /* is the space growing? */ - ipc_entry_t is_table; /* an array of entries */ + lck_spin_t is_lock_data; + ipc_space_refs_t is_bits; /* holds refs, active, growing */ ipc_entry_num_t is_table_size; /* current size of table */ + ipc_entry_num_t is_table_free; /* count of free elements */ + ipc_entry_t is_table; /* an array of entries */ + task_t is_task; /* associated task */ struct ipc_table_size *is_table_next; /* info for larger table */ - struct ipc_splay_tree is_tree; /* a splay tree of entries */ - ipc_entry_num_t is_tree_total; /* number of entries in the tree */ - ipc_entry_num_t is_tree_small; /* # of small entries in the tree */ - ipc_entry_num_t is_tree_hash; /* # of hashed entries in the tree */ - boolean_t is_fast; /* for is_fast_space() */ + ipc_entry_num_t is_low_mod; /* lowest modified entry during growth */ + ipc_entry_num_t is_high_mod; /* highest modified entry during growth */ + int is_node_id; /* HOST_LOCAL_NODE, or remote node if proxy space */ }; #define IS_NULL ((ipc_space_t) 0) +#define IS_INSPECT_NULL ((ipc_space_inspect_t) 0) + +#define is_active(is) (((is)->is_bits & IS_INACTIVE) != IS_INACTIVE) + +static inline void +is_mark_inactive(ipc_space_t is) +{ + assert(is_active(is)); + OSBitOrAtomic(IS_INACTIVE, &is->is_bits); +} + +#define is_growing(is) (((is)->is_bits & IS_GROWING) == IS_GROWING) + +static inline void +is_start_growing(ipc_space_t is) +{ + assert(!is_growing(is)); + OSBitOrAtomic(IS_GROWING, &is->is_bits); +} + +static inline void +is_done_growing(ipc_space_t is) +{ + assert(is_growing(is)); + OSBitAndAtomic(~IS_GROWING, &is->is_bits); +} extern zone_t ipc_space_zone; #define is_alloc() ((ipc_space_t) zalloc(ipc_space_zone)) -#define is_free(is) zfree(ipc_space_zone, (vm_offset_t) (is)) +#define is_free(is) zfree(ipc_space_zone, (is)) extern ipc_space_t ipc_space_kernel; extern ipc_space_t ipc_space_reply; #if DIPC extern ipc_space_t ipc_space_remote; #endif /* DIPC */ -#if DIPC || MACH_KDB +#if DIPC extern ipc_space_t default_pager_space; -#endif /* DIPC || MACH_KDB */ - -#define is_fast_space(is) ((is)->is_fast) - -#define is_ref_lock_init(is) mutex_init(&(is)->is_ref_lock_data, \ - ETAP_IPC_IS_REF) - -#define ipc_space_reference_macro(is) \ -MACRO_BEGIN \ - mutex_lock(&(is)->is_ref_lock_data); \ - assert((is)->is_references > 0); \ - (is)->is_references++; \ - mutex_unlock(&(is)->is_ref_lock_data); \ -MACRO_END - -#define ipc_space_release_macro(is) \ -MACRO_BEGIN \ - ipc_space_refs_t _refs; \ - \ - mutex_lock(&(is)->is_ref_lock_data); \ - assert((is)->is_references > 0); \ - _refs = --(is)->is_references; \ - mutex_unlock(&(is)->is_ref_lock_data); \ - \ - if (_refs == 0) \ - is_free(is); \ -MACRO_END - -#define is_lock_init(is) mutex_init(&(is)->is_lock_data, ETAP_IPC_IS) - -#define is_read_lock(is) mutex_lock(&(is)->is_lock_data) -#define is_read_unlock(is) mutex_unlock(&(is)->is_lock_data) -#define is_read_sleep(is) thread_sleep_mutex((event_t)(is), \ - &(is)->is_lock_data, \ - THREAD_UNINT) - -#define is_write_lock(is) mutex_lock(&(is)->is_lock_data) -#define is_write_lock_try(is) mutex_try(&(is)->is_lock_data) -#define is_write_unlock(is) mutex_unlock(&(is)->is_lock_data) -#define is_write_sleep(is) thread_sleep_mutex((event_t)(is), \ - &(is)->is_lock_data, \ - THREAD_UNINT) - -#define is_reference(is) ipc_space_reference(is) -#define is_release(is) ipc_space_release(is) - -#define is_write_to_read_lock(is) +#endif /* DIPC */ +extern lck_grp_t ipc_lck_grp; +extern lck_attr_t ipc_lck_attr; + +#define is_lock_init(is) lck_spin_init(&(is)->is_lock_data, &ipc_lck_grp, &ipc_lck_attr) +#define is_lock_destroy(is) lck_spin_destroy(&(is)->is_lock_data, &ipc_lck_grp) + +#define is_read_lock(is) lck_spin_lock(&(is)->is_lock_data) +#define is_read_unlock(is) lck_spin_unlock(&(is)->is_lock_data) +#define is_read_sleep(is) lck_spin_sleep(&(is)->is_lock_data, \ + LCK_SLEEP_DEFAULT, \ + (event_t)(is), \ + THREAD_UNINT) + +#define is_write_lock(is) lck_spin_lock(&(is)->is_lock_data) +#define is_write_lock_try(is) lck_spin_try_lock(&(is)->is_lock_data) +#define is_write_unlock(is) lck_spin_unlock(&(is)->is_lock_data) +#define is_write_sleep(is) lck_spin_sleep(&(is)->is_lock_data, \ + LCK_SLEEP_DEFAULT, \ + (event_t)(is), \ + THREAD_UNINT) + +#define is_refs(is) ((is)->is_bits & IS_REFS_MAX) + +static inline void +is_reference(ipc_space_t is) +{ + assert(is_refs(is) > 0 && is_refs(is) < IS_REFS_MAX); + OSIncrementAtomic(&(is->is_bits)); +} + + +static inline void +is_release(ipc_space_t is) { + assert(is_refs(is) > 0); + + /* If we just removed the last reference count */ + if ( 1 == (OSDecrementAtomic(&(is->is_bits)) & IS_REFS_MAX)) { + assert(!is_active(is)); + is_lock_destroy(is); + is_free(is); + } +} + #define current_space_fast() (current_task_fast()->itk_space) #define current_space() (current_space_fast()) @@ -190,7 +221,11 @@ extern kern_return_t ipc_space_create( ipc_space_t *spacep); /* Mark a space as dead and cleans up the entries*/ -extern void ipc_space_destroy( +extern void ipc_space_terminate( + ipc_space_t space); + +/* Clean up the entries - but leave the space alive */ +extern void ipc_space_clean( ipc_space_t space); #endif /* MACH_KERNEL_PRIVATE */