osfmk/vm/vm_shared_memory_server.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 /*
  29  *
  30  *      File: vm/vm_shared_memory_server.h
  31  *
  32  *      protos and struct definitions for shared library
  33  *      server and interface
  34  */
  35
  36 #ifndef _VM_SHARED_MEMORY_SERVER_H_
  37 #define _VM_SHARED_MEMORY_SERVER_H_
  38
  39 #ifdef  KERNEL_PRIVATE
  40
  41 #include <mach/vm_prot.h>
  42 #include <mach/mach_types.h>
  43 #include <mach/shared_memory_server.h>
  44
  45 #include <kern/kern_types.h>
  46
  47 #if DEBUG
  48 extern int shared_region_debug;
  49 #define SHARED_REGION_DEBUG(args)               \
  50         MACRO_BEGIN                             \
  51         if (shared_region_debug) {              \
  52                 kprintf args;                   \
  53         }                                       \
  54         MACRO_END
  55 #else /* DEBUG */
  56 #define SHARED_REGION_DEBUG(args)
  57 #endif /* DEBUG */
  58
  59 extern mach_port_t      shared_text_region_handle;
  60 extern mach_port_t      shared_data_region_handle;
  61
  62 struct shared_region_task_mappings {
  63         mach_port_t             text_region;
  64         vm_size_t               text_size;
  65         mach_port_t             data_region;
  66         vm_size_t               data_size;
  67         vm_offset_t             region_mappings;
  68         vm_offset_t             client_base;
  69         vm_offset_t             alternate_base;
  70         vm_offset_t             alternate_next;
  71         unsigned int            fs_base;
  72         unsigned int            system;
  73         int                     flags;
  74         vm_offset_t             self;
  75 };
  76
  77 #define SHARED_REGION_SYSTEM    0x1 // Default env for system and fs_root
  78 #define SHARED_REGION_FULL      0x2 // Shared regions are full
  79 #define SHARED_REGION_STALE     0x4 // Indicates no longer in default list
  80 #define SHARED_REGION_STANDALONE 0x10 // Shared region is not shared !
  81
  82
  83 /* defines for default environment, and co-resident systems */
  84
  85 #define ENV_DEFAULT_ROOT        0
  86
  87 typedef struct shared_region_task_mappings *shared_region_task_mappings_t;
  88 typedef struct shared_region_mapping *shared_region_mapping_t;
  89
  90 #ifdef MACH_KERNEL_PRIVATE
  91
  92 #include <kern/queue.h>
  93 #include <vm/vm_object.h>
  94 #include <vm/memory_object.h>
  95
  96 extern vm_offset_t     shared_file_mapping_array;
  97
  98 struct loaded_mapping {
  99         vm_offset_t     mapping_offset;
 100         vm_size_t       size;
 101         vm_offset_t     file_offset;
 102         vm_prot_t       protection;  /* read/write/execute/COW/ZF */
 103
 104         struct loaded_mapping *next;
 105 };
 106
 107 typedef struct loaded_mapping loaded_mapping_t;
 108
 109 struct load_struct {
 110         queue_chain_t           links;
 111         shared_region_mapping_t regions_instance;
 112         int                     depth;
 113         int                     file_object;
 114         vm_offset_t             base_address;
 115         int                     mapping_cnt;
 116         loaded_mapping_t        *mappings;
 117         vm_offset_t             file_offset; // start of file we mapped in
 118 };
 119
 120 typedef struct load_struct load_struct_t;
 121 typedef struct load_struct *load_struct_ptr_t;
 122
 123 struct load_file_ele {
 124         union {
 125                 sf_mapping_t    mapping;
 126                 load_struct_t   element;
 127         } u;
 128 };
 129
 130 struct shared_file_info {
 131         mutex_t         lock;   /* lock for the structure */
 132         queue_head_t    *hash;  /* for later perf enhance */
 133         int             hash_size;
 134         boolean_t       hash_init;
 135 };
 136
 137 typedef struct shared_file_info shared_file_info_t;
 138
 139 struct shared_region_object_chain {
 140         shared_region_mapping_t object_chain_region;
 141         int                     depth;
 142         struct shared_region_object_chain *next;
 143 };
 144 typedef struct shared_region_object_chain *shared_region_object_chain_t;
 145
 146 /* address space shared region descriptor */
 147 struct shared_region_mapping {
 148         decl_mutex_data(,       Lock)   /* Synchronization */
 149         int                     ref_count;
 150         unsigned int            fs_base;
 151         unsigned int            system;
 152         mach_port_t             text_region;
 153         vm_size_t               text_size;
 154         mach_port_t             data_region;
 155         vm_size_t               data_size;
 156         vm_offset_t             region_mappings;
 157         vm_offset_t             client_base;
 158         vm_offset_t             alternate_base;
 159         vm_offset_t             alternate_next;
 160         int                     flags;
 161         int                     depth;
 162         shared_region_mapping_t default_env_list;
 163         shared_region_object_chain_t object_chain;
 164         shared_region_mapping_t self;
 165         shared_region_mapping_t next;
 166 };
 167
 168 #define shared_region_mapping_lock_init(object)   \
 169                         mutex_init(&(object)->Lock, 0)
 170 #define shared_region_mapping_lock(object)        mutex_lock(&(object)->Lock)
 171 #define shared_region_mapping_unlock(object)      mutex_unlock(&(object)->Lock)
 172
 173 #else  /* !MACH_KERNEL_PRIVATE */
 174
 175 struct shared_region_mapping ;
 176
 177 #endif /* MACH_KERNEL_PRIVATE */
 178
 179 #define load_file_hash(file_object, size) \
 180                 ((((natural_t)file_object) & 0xffffff) % size)
 181
 182 extern kern_return_t map_shared_file(
 183         int                             map_cnt,
 184         struct shared_file_mapping_np   *mappings,
 185         memory_object_control_t         file_control,
 186         memory_object_size_t            file_size,
 187         shared_region_task_mappings_t   sm_info,
 188         mach_vm_offset_t                base_offset,
 189         mach_vm_offset_t                *slide_p);
 190
 191 extern kern_return_t shared_region_cleanup(
 192         unsigned int                    range_count,
 193         struct shared_region_range_np   *ranges,
 194         shared_region_task_mappings_t   sm_info);
 195
 196 extern kern_return_t shared_region_mapping_info(
 197                                 shared_region_mapping_t shared_region,
 198                                 mach_port_t             *text_region,
 199                                 vm_size_t               *text_size,
 200                                 mach_port_t             *data_region,
 201                                 vm_size_t               *data_size,
 202                                 vm_offset_t             *region_mappings,
 203                                 vm_offset_t             *client_base,
 204                                 vm_offset_t             *alternate_base,
 205                                 vm_offset_t             *alternate_next,
 206                                 unsigned int            *fs_base,
 207                                 unsigned int            *system,
 208                                 int                     *flags,
 209                                 shared_region_mapping_t *next);
 210
 211 extern kern_return_t shared_region_mapping_create(
 212                                 mach_port_t             text_region,
 213                                 vm_size_t               text_size,
 214                                 mach_port_t             data_region,
 215                                 vm_size_t               data_size,
 216                                 vm_offset_t             region_mappings,
 217                                 vm_offset_t             client_base,
 218                                 shared_region_mapping_t *shared_region,
 219                                 vm_offset_t             alt_base,
 220                                 vm_offset_t             alt_next);
 221
 222 extern kern_return_t shared_region_mapping_ref(
 223                                 shared_region_mapping_t shared_region);
 224
 225 extern kern_return_t shared_region_mapping_dealloc(
 226                                 shared_region_mapping_t shared_region);
 227
 228 extern kern_return_t shared_region_object_chain_attach(
 229                                 shared_region_mapping_t target_region,
 230                                 shared_region_mapping_t object_chain);
 231
 232 extern void shared_region_object_chain_detached(
 233         shared_region_mapping_t target_region);
 234
 235 extern kern_return_t vm_get_shared_region(
 236                                 task_t  task,
 237                                 shared_region_mapping_t *shared_region);
 238
 239 extern kern_return_t vm_set_shared_region(
 240                                 task_t  task,
 241                                 shared_region_mapping_t shared_region);
 242
 243 extern shared_region_mapping_t update_default_shared_region(
 244                                 shared_region_mapping_t new_system_region);
 245
 246 extern shared_region_mapping_t lookup_default_shared_region(
 247                                 unsigned int fs_base,
 248                                 unsigned int system);
 249
 250 extern void remove_default_shared_region(
 251                                 shared_region_mapping_t system_region);
 252
 253 __private_extern__ void remove_default_shared_region_lock(
 254                                 shared_region_mapping_t system_region,
 255                                 int need_sfh_lock,
 256                                 int need_drl_lock);
 257
 258 __private_extern__ struct load_struct *lsf_remove_regions_mappings_lock(
 259                                 shared_region_mapping_t region,
 260                                 shared_region_task_mappings_t   sm_info,
 261                                 int need_lock);
 262
 263 extern unsigned int lsf_mapping_pool_gauge(void);
 264
 265 extern kern_return_t shared_file_create_system_region(
 266         shared_region_mapping_t *shared_region);
 267
 268 extern void remove_all_shared_regions(void);
 269
 270 extern void shared_file_boot_time_init(
 271                 unsigned int fs_base,
 272                 unsigned int system);
 273
 274 extern struct load_struct *lsf_remove_regions_mappings(
 275         shared_region_mapping_t region,
 276         shared_region_task_mappings_t   sm_info);
 277
 278 extern void mach_memory_entry_port_release(ipc_port_t port);
 279 extern void mach_destroy_memory_entry(ipc_port_t port);
 280
 281 extern kern_return_t mach_memory_entry_purgable_control(
 282         ipc_port_t      entry_port,
 283         vm_purgable_t   control,
 284         int             *state);
 285
 286 #endif /* KERNEL_PRIVATE */
 287
 288 #endif  /* _VM_SHARED_MEMORY_SERVER_H_ */