osfmk/vm/vm_shared_memory_server.h

   1 /*
   2  * Copyright (c) 2000-2004 Apple Computer, Inc. All rights reserved.
   3  *
   4  * @APPLE_LICENSE_OSREFERENCE_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
  10  * License may not be used to create, or enable the creation or
  11  * redistribution of, unlawful or unlicensed copies of an Apple operating
  12  * system, or to circumvent, violate, or enable the circumvention or
  13  * violation of, any terms of an Apple operating system software license
  14  * agreement.
  15  *
  16  * Please obtain a copy of the License at
  17  * http://www.opensource.apple.com/apsl/ and read it before using this
  18  * file.
  19  *
  20  * The Original Code and all software distributed under the License are
  21  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  22  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  23  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  24  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  25  * Please see the License for the specific language governing rights and
  26  * limitations under the License.
  27  *
  28  * @APPLE_LICENSE_OSREFERENCE_HEADER_END@
  29  */
  30 /*
  31  *
  32  *      File: vm/vm_shared_memory_server.h
  33  *
  34  *      protos and struct definitions for shared library
  35  *      server and interface
  36  */
  37
  38 #ifndef _VM_SHARED_MEMORY_SERVER_H_
  39 #define _VM_SHARED_MEMORY_SERVER_H_
  40
  41 #ifdef  KERNEL_PRIVATE
  42
  43 #include <mach/vm_prot.h>
  44 #include <mach/mach_types.h>
  45 #include <mach/shared_memory_server.h>
  46
  47 #include <kern/kern_types.h>
  48 #include <kern/macro_help.h>
  49
  50 #if DEBUG
  51 extern int shared_region_debug;
  52 #define SHARED_REGION_DEBUG(args)               \
  53         MACRO_BEGIN                             \
  54         if (shared_region_debug) {              \
  55                 kprintf args;                   \
  56         }                                       \
  57         MACRO_END
  58 #else /* DEBUG */
  59 #define SHARED_REGION_DEBUG(args)
  60 #endif /* DEBUG */
  61
  62 extern int shared_region_trace_level;
  63 #define SHARED_REGION_TRACE_NONE        0       /* no trace */
  64 #define SHARED_REGION_TRACE_ERROR       1       /* trace abnormal events */
  65 #define SHARED_REGION_TRACE_CONFLICT    2       /* trace library conflicts */
  66 #define SHARED_REGION_TRACE_INFO        3       /* trace all events */
  67 #define SHARED_REGION_TRACE(level, args)                \
  68         MACRO_BEGIN                                     \
  69         if (level <= shared_region_trace_level) {       \
  70                 printf args;                            \
  71         }                                               \
  72         MACRO_END
  73
  74 struct shared_region_task_mappings {
  75         mach_port_t             text_region;
  76         vm_size_t               text_size;
  77         mach_port_t             data_region;
  78         vm_size_t               data_size;
  79         vm_offset_t             region_mappings;
  80         vm_offset_t             client_base;
  81         vm_offset_t             alternate_base;
  82         vm_offset_t             alternate_next;
  83         unsigned int            fs_base;
  84         unsigned int            system;
  85         int                     flags;
  86         vm_offset_t             self;
  87 };
  88
  89 #define SHARED_REGION_SYSTEM    0x1 // Default env for system and fs_root
  90 #define SHARED_REGION_FULL      0x2 // Shared regions are full
  91 #define SHARED_REGION_STALE     0x4 // Indicates no longer in default list
  92 #define SHARED_REGION_STANDALONE 0x10 // Shared region is not shared !
  93
  94
  95 /* defines for default environment, and co-resident systems */
  96
  97 #define ENV_DEFAULT_ROOT        0
  98
  99 typedef struct shared_region_task_mappings *shared_region_task_mappings_t;
 100 typedef struct shared_region_mapping *shared_region_mapping_t;
 101
 102 #ifdef MACH_KERNEL_PRIVATE
 103
 104 #include <kern/queue.h>
 105 #include <vm/vm_object.h>
 106 #include <vm/memory_object.h>
 107
 108 extern vm_offset_t     shared_file_mapping_array;
 109
 110 struct loaded_mapping {
 111         vm_offset_t     mapping_offset;
 112         vm_size_t       size;
 113         vm_offset_t     file_offset;
 114         vm_prot_t       protection;  /* read/write/execute/COW/ZF */
 115
 116         struct loaded_mapping *next;
 117 };
 118
 119 typedef struct loaded_mapping loaded_mapping_t;
 120
 121 struct load_struct {
 122         queue_chain_t           links;
 123         shared_region_mapping_t regions_instance;
 124         int                     depth;
 125         int                     file_object;
 126         vm_offset_t             base_address;
 127         int                     mapping_cnt;
 128         loaded_mapping_t        *mappings;
 129         vm_offset_t             file_offset; // start of file we mapped in
 130 };
 131
 132 typedef struct load_struct load_struct_t;
 133 typedef struct load_struct *load_struct_ptr_t;
 134
 135 struct load_file_ele {
 136         union {
 137                 sf_mapping_t    mapping;
 138                 load_struct_t   element;
 139         } u;
 140 };
 141
 142 struct shared_file_info {
 143         mutex_t         lock;   /* lock for the structure */
 144         queue_head_t    *hash;  /* for later perf enhance */
 145         int             hash_size;
 146         boolean_t       hash_init;
 147 };
 148
 149 typedef struct shared_file_info shared_file_info_t;
 150
 151 struct shared_region_object_chain {
 152         shared_region_mapping_t object_chain_region;
 153         int                     depth;
 154         struct shared_region_object_chain *next;
 155 };
 156 typedef struct shared_region_object_chain *shared_region_object_chain_t;
 157
 158 /* address space shared region descriptor */
 159 struct shared_region_mapping {
 160         decl_mutex_data(,       Lock)   /* Synchronization */
 161         unsigned int            ref_count;
 162         unsigned int            fs_base;
 163         unsigned int            system;
 164         mach_port_t             text_region;
 165         vm_size_t               text_size;
 166         mach_port_t             data_region;
 167         vm_size_t               data_size;
 168         vm_offset_t             region_mappings;
 169         vm_offset_t             client_base;
 170         vm_offset_t             alternate_base;
 171         vm_offset_t             alternate_next;
 172         int                     flags;
 173         int                     depth;
 174         shared_region_mapping_t default_env_list;
 175         shared_region_object_chain_t object_chain;
 176         shared_region_mapping_t self;
 177         shared_region_mapping_t next;
 178 };
 179
 180 #define shared_region_mapping_lock_init(object)   \
 181                         mutex_init(&(object)->Lock, 0)
 182 #define shared_region_mapping_lock(object)        mutex_lock(&(object)->Lock)
 183 #define shared_region_mapping_unlock(object)      mutex_unlock(&(object)->Lock)
 184
 185 #else  /* !MACH_KERNEL_PRIVATE */
 186
 187 struct shared_region_mapping ;
 188
 189 #endif /* MACH_KERNEL_PRIVATE */
 190
 191 #define load_file_hash(file_object, size) \
 192                 ((((natural_t)file_object) & 0xffffff) % size)
 193
 194 extern kern_return_t map_shared_file(
 195         int                             map_cnt,
 196         struct shared_file_mapping_np   *mappings,
 197         memory_object_control_t         file_control,
 198         memory_object_size_t            file_size,
 199         shared_region_task_mappings_t   sm_info,
 200         mach_vm_offset_t                base_offset,
 201         mach_vm_offset_t                *slide_p);
 202
 203 extern kern_return_t shared_region_cleanup(
 204         unsigned int                    range_count,
 205         struct shared_region_range_np   *ranges,
 206         shared_region_task_mappings_t   sm_info);
 207
 208 extern kern_return_t shared_region_mapping_info(
 209                                 shared_region_mapping_t shared_region,
 210                                 mach_port_t             *text_region,
 211                                 vm_size_t               *text_size,
 212                                 mach_port_t             *data_region,
 213                                 vm_size_t               *data_size,
 214                                 vm_offset_t             *region_mappings,
 215                                 vm_offset_t             *client_base,
 216                                 vm_offset_t             *alternate_base,
 217                                 vm_offset_t             *alternate_next,
 218                                 unsigned int            *fs_base,
 219                                 unsigned int            *system,
 220                                 int                     *flags,
 221                                 shared_region_mapping_t *next);
 222
 223 extern kern_return_t shared_region_mapping_create(
 224                                 mach_port_t             text_region,
 225                                 vm_size_t               text_size,
 226                                 mach_port_t             data_region,
 227                                 vm_size_t               data_size,
 228                                 vm_offset_t             region_mappings,
 229                                 vm_offset_t             client_base,
 230                                 shared_region_mapping_t *shared_region,
 231                                 vm_offset_t             alt_base,
 232                                 vm_offset_t             alt_next,
 233                                 int                     fs_base,
 234                                 int                     system);
 235
 236 extern kern_return_t shared_region_mapping_ref(
 237                                 shared_region_mapping_t shared_region);
 238
 239 extern kern_return_t shared_region_mapping_dealloc(
 240                                 shared_region_mapping_t shared_region);
 241
 242 extern kern_return_t shared_region_object_chain_attach(
 243                                 shared_region_mapping_t target_region,
 244                                 shared_region_mapping_t object_chain);
 245
 246 extern void shared_region_object_chain_detached(
 247         shared_region_mapping_t target_region);
 248
 249 extern kern_return_t vm_get_shared_region(
 250                                 task_t  task,
 251                                 shared_region_mapping_t *shared_region);
 252
 253 extern kern_return_t vm_set_shared_region(
 254                                 task_t  task,
 255                                 shared_region_mapping_t shared_region);
 256
 257 extern shared_region_mapping_t update_default_shared_region(
 258                                 shared_region_mapping_t new_system_region);
 259
 260 extern shared_region_mapping_t lookup_default_shared_region(
 261                                 unsigned int fs_base,
 262                                 unsigned int system);
 263
 264 extern void remove_default_shared_region(
 265                                 shared_region_mapping_t system_region);
 266
 267 __private_extern__ void remove_default_shared_region_lock(
 268                                 shared_region_mapping_t system_region,
 269                                 int need_sfh_lock,
 270                                 int need_drl_lock);
 271
 272 __private_extern__ struct load_struct *lsf_remove_regions_mappings_lock(
 273                                 shared_region_mapping_t region,
 274                                 shared_region_task_mappings_t   sm_info,
 275                                 int need_lock);
 276
 277 extern unsigned int lsf_mapping_pool_gauge(void);
 278
 279 extern kern_return_t shared_file_create_system_region(
 280         shared_region_mapping_t *shared_region,
 281         int                     fs_base,
 282         int                     system);
 283
 284 extern void remove_all_shared_regions(void);
 285
 286 extern void shared_file_boot_time_init(
 287                 unsigned int fs_base,
 288                 unsigned int system);
 289
 290 extern struct load_struct *lsf_remove_regions_mappings(
 291         shared_region_mapping_t region,
 292         shared_region_task_mappings_t   sm_info);
 293
 294 extern void mach_memory_entry_port_release(ipc_port_t port);
 295 extern void mach_destroy_memory_entry(ipc_port_t port);
 296
 297 extern kern_return_t mach_memory_entry_purgable_control(
 298         ipc_port_t      entry_port,
 299         vm_purgable_t   control,
 300         int             *state);
 301
 302 extern kern_return_t mach_memory_entry_page_op(
 303         ipc_port_t              entry_port,
 304         vm_object_offset_t      offset,
 305         int                     ops,
 306         ppnum_t                 *phys_entry,
 307         int                     *flags);
 308
 309 extern kern_return_t mach_memory_entry_range_op(
 310         ipc_port_t              entry_port,
 311         vm_object_offset_t      offset_beg,
 312         vm_object_offset_t      offset_end,
 313         int                     ops,
 314         int                     *range);
 315
 316 #endif /* KERNEL_PRIVATE */
 317
 318 #endif  /* _VM_SHARED_MEMORY_SERVER_H_ */