osfmk/ipc/ipc_voucher.h

   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 #ifndef _IPC_IPC_VOUCHER_H_
  29 #define _IPC_IPC_VOUCHER_H_
  30
  31 #include <mach/mach_types.h>
  32 #include <mach/mach_voucher_types.h>
  33 #include <mach/boolean.h>
  34 #include <ipc/ipc_types.h>
  35
  36 #ifdef MACH_KERNEL_PRIVATE
  37
  38 #include <kern/queue.h>
  39 #include <kern/locks.h>
  40 #include <kern/simple_lock.h>
  41
  42 /* locking */
  43 extern lck_grp_t        ipc_lck_grp;
  44 extern lck_attr_t       ipc_lck_attr;
  45
  46 extern void ipc_voucher_init(void);
  47
  48 /* some shorthand for longer types */
  49 typedef mach_voucher_attr_value_handle_t        iv_value_handle_t;
  50 typedef mach_voucher_attr_value_reference_t     iv_value_refs_t;
  51
  52 typedef natural_t               iv_refs_t;
  53
  54 typedef natural_t               iv_index_t;
  55 #define IV_UNUSED_VALINDEX      ((iv_index_t) 0)
  56 #define IV_UNUSED_KEYINDEX      ((iv_index_t) ~0)
  57
  58 typedef iv_index_t              *iv_entry_t;
  59 #define IVE_NULL                ((iv_entry_t) 0)
  60
  61 #define IV_ENTRIES_INLINE MACH_VOUCHER_ATTR_KEY_NUM_WELL_KNOWN
  62
  63 /*
  64  * IPC Voucher
  65  *
  66  * Vouchers are a reference counted immutable (once-created) set of
  67  * indexes to particular resource manager attribute values
  68  * (which themselves are reference counted).
  69  */
  70 struct ipc_voucher {
  71         iv_index_t              iv_hash;        /* checksum hash */
  72         iv_index_t              iv_sum;         /* checksum of values */
  73         iv_refs_t               iv_refs;        /* reference count */
  74         iv_index_t              iv_table_size;  /* size of the voucher table */
  75         iv_index_t              iv_inline_table[IV_ENTRIES_INLINE];
  76         iv_entry_t              iv_table;       /* table of voucher attr entries */
  77         ipc_port_t              iv_port;        /* port representing the voucher */
  78         queue_chain_t           iv_hash_link;   /* link on hash chain */
  79 };
  80
  81 #define IV_NULL         IPC_VOUCHER_NULL
  82
  83
  84 /*
  85  * Voucher Attribute Cache Control Object
  86  *
  87  * This is where the Voucher system stores its caches/references to
  88  * returned resource manager attribute values.  Each value only appears
  89  * once in the table.  If a value is returned more than once by the
  90  * resource manager, the voucher system will increase the reference
  91  * on the previous value.
  92  *
  93  * The voucher itself contains one entry per key, that indexes into
  94  * this table.
  95  *
  96  * A voucher that does not have an explicit index for a given key
  97  * is assumed to have a reference on slot zero - which is where the
  98  * voucher system stores the default value for the given attribute
  99  * (specified at the time of resource manager registration).
 100  *
 101  * The ivace_releasing field limits the entry to a single concurrent
 102  * return. Without it, a previous release's reply might still be
 103  * working its way back to the voucher code, and a subsequent get-
 104  * value could return the same value as was previously returned.  If
 105  * the resource manager already knew that, it would return a failure
 106  * on the return, and all is well.  We just treat the additional made
 107  * references on the value as we normally would.  However, if the resource
 108  * manager accepted the return, and the get-value response raced the
 109  * release's reply, the newly made references will look like an extension
 110  * of the old value's cache lifetime, rather than a new one.  Dropping
 111  * that new lifetime's references to zero would result in a second
 112  * release callback to the resource manager - this time with the wrong
 113  * "made" reference count.  We avoid the race with this flag.
 114  */
 115
 116 struct ivac_entry_s {
 117         iv_value_handle_t       ivace_value;
 118         iv_value_refs_t         ivace_layered:1,     /* layered effective entry */
 119                                 ivace_releasing:1,   /* release in progress */
 120                                 ivace_free:1,        /* on freelist */
 121                                 ivace_persist:1,     /* Persist the entry, don't count made refs */
 122                                 ivace_refs:28;       /* reference count */
 123         union {
 124                 iv_value_refs_t ivaceu_made;         /* made count (non-layered) */
 125                 iv_index_t      ivaceu_layer;        /* next effective layer (layered) */
 126         } ivace_u;
 127         iv_index_t              ivace_next;          /* hash or freelist */
 128         iv_index_t              ivace_index;         /* hash head (independent) */
 129 };
 130 typedef struct ivac_entry_s       ivac_entry;
 131 typedef ivac_entry              *ivac_entry_t;
 132
 133 #define ivace_made              ivace_u.ivaceu_made
 134 #define ivace_layer             ivace_u.ivaceu_layer
 135
 136 #define IVACE_NULL              ((ivac_entry_t) 0);
 137
 138 #define IVACE_REFS_MAX          ((1 << 28) - 1)
 139
 140 #define IVAC_ENTRIES_MIN        512
 141 #define IVAC_ENTRIES_MAX        524288
 142
 143 struct ipc_voucher_attr_control {
 144         iv_refs_t               ivac_refs;
 145         boolean_t               ivac_is_growing;        /* is the table being grown */
 146         ivac_entry_t            ivac_table;             /* table of voucher attr value entries */
 147         iv_index_t              ivac_table_size;        /* size of the attr value table */
 148         iv_index_t              ivac_init_table_size;   /* size of the attr value table */
 149         iv_index_t              ivac_freelist;          /* index of the first free element */
 150         ipc_port_t              ivac_port;              /* port for accessing the cache control  */
 151         lck_spin_t              ivac_lock_data;
 152         iv_index_t              ivac_key_index;         /* key index for this value */
 153 };
 154 typedef ipc_voucher_attr_control_t iv_attr_control_t;
 155
 156 #define IVAC_NULL                  IPC_VOUCHER_ATTR_CONTROL_NULL
 157
 158 extern ipc_voucher_attr_control_t  ivac_alloc(iv_index_t);
 159 extern void ipc_voucher_receive_postprocessing(ipc_kmsg_t kmsg, mach_msg_option_t option);
 160 extern void ipc_voucher_send_preprocessing(ipc_kmsg_t kmsg);
 161
 162 #define ivac_lock_init(ivac) \
 163         lck_spin_init(&(ivac)->ivac_lock_data, &ipc_lck_grp, &ipc_lck_attr)
 164 #define ivac_lock_destroy(ivac) \
 165         lck_spin_destroy(&(ivac)->ivac_lock_data, &ipc_lck_grp)
 166 #define ivac_lock(ivac) \
 167         lck_spin_lock(&(ivac)->ivac_lock_data)
 168 #define ivac_lock_try(ivac) \
 169         lck_spin_try_lock(&(ivac)->ivac_lock_data)
 170 #define ivac_unlock(ivac) \
 171         lck_spin_unlock(&(ivac)->ivac_lock_data)
 172 #define ivac_sleep(ivac) lck_spin_sleep(&(ivac)->ivac_lock_data,        \
 173                                         LCK_SLEEP_DEFAULT,              \
 174                                         (event_t)(ivac),                \
 175                                         THREAD_UNINT)
 176 #define ivac_wakeup(ivac) thread_wakeup((event_t)(ivac))
 177
 178 extern void ivac_dealloc(ipc_voucher_attr_control_t ivac);
 179
 180 static inline void
 181 ivac_reference(ipc_voucher_attr_control_t ivac)
 182 {
 183         (void)hw_atomic_add(&ivac->ivac_refs, 1);
 184 }
 185
 186 static inline void
 187 ivac_release(ipc_voucher_attr_control_t ivac)
 188 {
 189         iv_refs_t refs;
 190
 191         if (IVAC_NULL == ivac)
 192                 return;
 193
 194         refs = hw_atomic_sub(&ivac->ivac_refs, 1);
 195         if (refs == 0)
 196                 ivac_dealloc(ivac);
 197 }
 198
 199 #define IVAM_NULL IPC_VOUCHER_ATTR_MANAGER_NULL
 200
 201 /*
 202  * IPC voucher Resource Manager table element
 203  *
 204  * Information Associated with a specific registration of
 205  * a voucher resource manager.
 206  *
 207  * NOTE: For now, this table is indexed directly by the key.  In the future,
 208  * it will have to be growable and sparse by key.  When that is implemented
 209  * the index will be independent from the key (but there will be a hash to
 210  * find the index by key).
 211  */
 212 typedef struct ipc_voucher_global_table_element {
 213         ipc_voucher_attr_manager_t      ivgte_manager;
 214         ipc_voucher_attr_control_t      ivgte_control;
 215         mach_voucher_attr_key_t         ivgte_key;
 216 } ipc_voucher_global_table_element;
 217
 218 typedef ipc_voucher_global_table_element *ipc_voucher_global_table_element_t;
 219
 220 #endif /* MACH_KERNEL_PRIVATE */
 221
 222 /*
 223  * IPC voucher attribute recipe
 224  *
 225  * In-kernel recipe format with an ipc_voucher_t pointer for the previous
 226  * voucher reference.
 227  */
 228 #pragma pack(1)
 229 typedef struct ipc_voucher_attr_recipe_data {
 230         mach_voucher_attr_key_t                 key;
 231         mach_voucher_attr_recipe_command_t      command;
 232         ipc_voucher_t                           previous_voucher;
 233         mach_voucher_attr_content_size_t        content_size;
 234         uint8_t                                 content[];
 235 } ipc_voucher_attr_recipe_data_t;
 236 typedef ipc_voucher_attr_recipe_data_t *ipc_voucher_attr_recipe_t;
 237 typedef mach_msg_type_number_t ipc_voucher_attr_recipe_size_t;
 238
 239 typedef uint8_t *ipc_voucher_attr_raw_recipe_t;
 240 typedef ipc_voucher_attr_raw_recipe_t ipc_voucher_attr_raw_recipe_array_t;
 241 typedef mach_msg_type_number_t ipc_voucher_attr_raw_recipe_size_t;
 242 typedef mach_msg_type_number_t ipc_voucher_attr_raw_recipe_array_size_t;
 243
 244 #pragma pack()
 245
 246 /*
 247  * In-kernel Resource Manager Definition
 248  *
 249  * In-kernel resource managers are defined by a v-table like structure for
 250  * the three callouts supported by a resource manager (and release function).
 251  *
 252  * There is a single in-kernel resource manager that represents all the
 253  * outside kernel managers (and reflects the calls through MIG to user-space).
 254  */
 255
 256 typedef kern_return_t (*ipc_voucher_attr_manager_release_value_t)(ipc_voucher_attr_manager_t,
 257                                                                   mach_voucher_attr_key_t,
 258                                                                   mach_voucher_attr_value_handle_t,
 259                                                                   mach_voucher_attr_value_reference_t);
 260
 261 typedef kern_return_t (*ipc_voucher_attr_manager_get_value_t)(ipc_voucher_attr_manager_t,
 262                                                               mach_voucher_attr_key_t,
 263                                                               mach_voucher_attr_recipe_command_t,
 264                                                               mach_voucher_attr_value_handle_array_t,
 265                                                               mach_voucher_attr_value_handle_array_size_t,
 266                                                               mach_voucher_attr_content_t,
 267                                                               mach_voucher_attr_content_size_t,
 268                                                               mach_voucher_attr_value_handle_t *,
 269                                                               mach_voucher_attr_value_flags_t *,
 270                                                               ipc_voucher_t *);
 271
 272 typedef kern_return_t (*ipc_voucher_attr_manager_extract_content_t)(ipc_voucher_attr_manager_t,
 273                                                                     mach_voucher_attr_key_t,
 274                                                                     mach_voucher_attr_value_handle_array_t,
 275                                                                     mach_voucher_attr_value_handle_array_size_t,
 276                                                                     mach_voucher_attr_recipe_command_t *,
 277                                                                     mach_voucher_attr_content_t,
 278                                                                     mach_voucher_attr_content_size_t *);
 279
 280 typedef kern_return_t (*ipc_voucher_attr_manager_command_t)(ipc_voucher_attr_manager_t,
 281                                                             mach_voucher_attr_key_t,
 282                                                             mach_voucher_attr_value_handle_array_t,
 283                                                             mach_voucher_attr_value_handle_array_size_t,
 284                                                             mach_voucher_attr_command_t,
 285                                                             mach_voucher_attr_content_t,
 286                                                             mach_voucher_attr_content_size_t,
 287                                                             mach_voucher_attr_content_t,
 288                                                             mach_voucher_attr_content_size_t *);
 289
 290 typedef void (*ipc_voucher_attr_manager_release_t)(ipc_voucher_attr_manager_t);
 291
 292 typedef uint32_t ipc_voucher_attr_manager_flags;
 293
 294 struct ipc_voucher_attr_manager {
 295         ipc_voucher_attr_manager_release_value_t        ivam_release_value;
 296         ipc_voucher_attr_manager_get_value_t            ivam_get_value;
 297         ipc_voucher_attr_manager_extract_content_t      ivam_extract_content;
 298         ipc_voucher_attr_manager_command_t              ivam_command;
 299         ipc_voucher_attr_manager_release_t              ivam_release;
 300         ipc_voucher_attr_manager_flags                  ivam_flags;
 301 };
 302
 303 #define IVAM_FLAGS_NONE                              0
 304 #define IVAM_FLAGS_SUPPORT_SEND_PREPROCESS         0x1
 305 #define IVAM_FLAGS_SUPPORT_RECEIVE_POSTPROCESS     0x2
 306
 307 __BEGIN_DECLS
 308
 309 /* DEBUG/TRACE Convert from a port to a voucher */
 310 extern uintptr_t unsafe_convert_port_to_voucher(
 311         ipc_port_t              port);
 312
 313 /* Convert from a port to a voucher */
 314 extern ipc_voucher_t convert_port_to_voucher(
 315         ipc_port_t              port);
 316
 317 /* Convert from a port name to an ipc_voucher */
 318 extern ipc_voucher_t convert_port_name_to_voucher(
 319         mach_port_name_t        name);
 320
 321 /* add a reference to the specified voucher */
 322 extern void ipc_voucher_reference(
 323         ipc_voucher_t           voucher);
 324
 325 /* drop the voucher reference picked up above */
 326 extern void ipc_voucher_release(
 327         ipc_voucher_t           voucher);
 328
 329 /* deliver voucher notifications */
 330 extern void ipc_voucher_notify(
 331         mach_msg_header_t       *msg);
 332
 333 /* Convert from a voucher to a port */
 334 extern ipc_port_t convert_voucher_to_port(
 335         ipc_voucher_t           voucher);
 336
 337 /* convert from a voucher attribute control to a port */
 338 extern ipc_port_t convert_voucher_attr_control_to_port(
 339         ipc_voucher_attr_control_t      control);
 340
 341 /* add a reference to the specified voucher */
 342 extern void ipc_voucher_attr_control_reference(
 343         ipc_voucher_attr_control_t      control);
 344
 345 /* drop the reference picked up above */
 346 extern void ipc_voucher_attr_control_release(
 347         ipc_voucher_attr_control_t      control);
 348
 349 /* deliver voucher control notifications */
 350 extern void ipc_voucher_attr_control_notify(
 351         mach_msg_header_t       *msg);
 352
 353 /* convert from a port to a voucher attribute control */
 354 extern ipc_voucher_attr_control_t convert_port_to_voucher_attr_control(
 355         ipc_port_t              port);
 356
 357 /*
 358  * In-kernel equivalents to the user syscalls
 359  */
 360 extern kern_return_t
 361 ipc_create_mach_voucher(
 362         ipc_voucher_attr_raw_recipe_array_t             recipes,
 363         ipc_voucher_attr_raw_recipe_array_size_t        recipe_size,
 364         ipc_voucher_t                                   *new_voucher);
 365
 366 extern kern_return_t
 367 ipc_voucher_attr_control_create_mach_voucher(
 368         ipc_voucher_attr_control_t                      control,
 369         ipc_voucher_attr_raw_recipe_array_t             recipes,
 370         ipc_voucher_attr_raw_recipe_array_size_t        recipe_size,
 371         ipc_voucher_t                                   *new_voucher);
 372
 373 extern kern_return_t
 374 ipc_register_well_known_mach_voucher_attr_manager(
 375         ipc_voucher_attr_manager_t              manager,
 376         mach_voucher_attr_value_handle_t        default_value,
 377         mach_voucher_attr_key_t                 key,
 378         ipc_voucher_attr_control_t              *control);
 379
 380
 381 extern kern_return_t
 382 ipc_register_mach_voucher_attr_manager(
 383         ipc_voucher_attr_manager_t              manager,
 384         mach_voucher_attr_value_handle_t        default_value,
 385         mach_voucher_attr_key_t                 *key,
 386         ipc_voucher_attr_control_t              *control);
 387
 388 __END_DECLS
 389
 390 #endif  /* _IPC_IPC_VOUCHER_H_ */