[apple/xnu.git] / osfmk / vm / vm_shared_memory_server.h

/*
 * Copyright (c) 2000-2004 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_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 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.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */
/*
 *
 *	File: vm/vm_shared_memory_server.h
 *
 * 	protos and struct definitions for shared library
 *	server and interface
 */

#ifndef _VM_SHARED_MEMORY_SERVER_H_
#define _VM_SHARED_MEMORY_SERVER_H_

#ifdef	KERNEL_PRIVATE

#include <mach/vm_prot.h>
#include <mach/mach_types.h>
#include <mach/shared_memory_server.h>

#include <kern/kern_types.h>
#include <kern/macro_help.h>

#if DEBUG
extern int shared_region_debug;
#define SHARED_REGION_DEBUG(args)		\
	MACRO_BEGIN				\
	if (shared_region_debug) {		\
		kprintf args;			\
	}					\
	MACRO_END
#else /* DEBUG */
#define SHARED_REGION_DEBUG(args)
#endif /* DEBUG */

extern int shared_region_trace_level;
#define SHARED_REGION_TRACE_NONE	0	/* no trace */
#define SHARED_REGION_TRACE_ERROR	1	/* trace abnormal events */
#define SHARED_REGION_TRACE_CONFLICT	2	/* trace library conflicts */
#define SHARED_REGION_TRACE_INFO	3	/* trace all events */
#define SHARED_REGION_TRACE(level, args)		\
	MACRO_BEGIN					\
	if (level <= shared_region_trace_level) {	\
		printf args;				\
	}						\
	MACRO_END

struct shared_region_task_mappings {
	mach_port_t		text_region;
	vm_size_t		text_size;
	mach_port_t		data_region;
	vm_size_t		data_size;
	vm_offset_t		region_mappings;
	vm_offset_t		client_base;
	vm_offset_t		alternate_base;
	vm_offset_t		alternate_next;
	unsigned int		fs_base;
	unsigned int		system;
	int			flags;
	vm_offset_t		self;
};

#define SHARED_REGION_SYSTEM	0x1 // Default env for system and fs_root
#define SHARED_REGION_FULL	0x2 // Shared regions are full
#define SHARED_REGION_STALE 	0x4 // Indicates no longer in default list
#define SHARED_REGION_STANDALONE 0x10 // Shared region is not shared !


/* defines for default environment, and co-resident systems */

#define ENV_DEFAULT_ROOT	0

typedef	struct shared_region_task_mappings *shared_region_task_mappings_t;
typedef struct shared_region_mapping *shared_region_mapping_t;

#ifdef MACH_KERNEL_PRIVATE

#include <kern/queue.h>
#include <vm/vm_object.h>
#include <vm/memory_object.h>

extern vm_offset_t     shared_file_mapping_array;

struct loaded_mapping {
	vm_offset_t	mapping_offset;
	vm_size_t	size;
	vm_offset_t	file_offset;
	vm_prot_t	protection;  /* read/write/execute/COW/ZF */
	
	struct loaded_mapping *next;
};

typedef struct loaded_mapping loaded_mapping_t;

struct load_struct {
	queue_chain_t   	links;  
	shared_region_mapping_t	regions_instance;
	int			depth;
	int			file_object;
	vm_offset_t		base_address;
	int			mapping_cnt;
	loaded_mapping_t	*mappings;
        vm_offset_t             file_offset; // start of file we mapped in
};

typedef struct load_struct load_struct_t;
typedef struct load_struct *load_struct_ptr_t;

struct load_file_ele {
	union {
		sf_mapping_t	mapping;
		load_struct_t	element;
	} u;
};

struct shared_file_info {
	mutex_t	    	lock;   /* lock for the structure */
	queue_head_t	*hash;  /* for later perf enhance */
	int		hash_size;
	boolean_t	hash_init;
};

typedef struct shared_file_info shared_file_info_t;

struct shared_region_object_chain {
	shared_region_mapping_t	object_chain_region;
	int			depth;
	struct shared_region_object_chain *next;
};
typedef struct shared_region_object_chain *shared_region_object_chain_t;

/* address space shared region descriptor */
struct shared_region_mapping {
        decl_mutex_data(,       Lock)   /* Synchronization */
	unsigned int		ref_count;
	unsigned int		fs_base;
	unsigned int		system;
	mach_port_t		text_region;
	vm_size_t		text_size;
	mach_port_t		data_region;
	vm_size_t		data_size;
	vm_offset_t		region_mappings;
	vm_offset_t		client_base;
	vm_offset_t		alternate_base;
	vm_offset_t		alternate_next;
	int			flags;
	int			depth;
	shared_region_mapping_t default_env_list;
	shared_region_object_chain_t object_chain;
	shared_region_mapping_t self;
	shared_region_mapping_t next;
};

#define shared_region_mapping_lock_init(object)   \
			mutex_init(&(object)->Lock, 0)
#define shared_region_mapping_lock(object)        mutex_lock(&(object)->Lock)
#define shared_region_mapping_unlock(object)      mutex_unlock(&(object)->Lock)

#else  /* !MACH_KERNEL_PRIVATE */

struct shared_region_mapping ;

#endif /* MACH_KERNEL_PRIVATE */

#define load_file_hash(file_object, size) \
		((((natural_t)file_object) & 0xffffff) % size)

extern kern_return_t copyin_shared_file(
				vm_offset_t     	mapped_file,
				vm_size_t       	mapped_file_size,
				vm_offset_t     	*base_address,
				int             	map_cnt,
				sf_mapping_t    	*mappings,
				memory_object_control_t		file_control,
				shared_region_task_mappings_t	shared_region,
				int             	*flags);

extern kern_return_t map_shared_file(
	int 				map_cnt,
	struct shared_file_mapping_np 	*mappings,
	memory_object_control_t		file_control,
	memory_object_size_t		file_size,
	shared_region_task_mappings_t	sm_info,
	mach_vm_offset_t		base_offset,
	mach_vm_offset_t		*slide_p);

extern kern_return_t shared_region_cleanup(
	unsigned int			range_count,
	struct shared_region_range_np	*ranges,
	shared_region_task_mappings_t	sm_info);

extern kern_return_t shared_region_mapping_info(
				shared_region_mapping_t	shared_region,
				mach_port_t		*text_region,
				vm_size_t		*text_size,
				mach_port_t		*data_region,
				vm_size_t		*data_size,
				vm_offset_t		*region_mappings,
				vm_offset_t		*client_base,
				vm_offset_t		*alternate_base,
				vm_offset_t		*alternate_next,
				unsigned int		*fs_base,
				unsigned int		*system,
				int			*flags,
				shared_region_mapping_t	*next);

extern kern_return_t shared_region_mapping_create(
				mach_port_t		text_region,
				vm_size_t		text_size,
				mach_port_t		data_region,
				vm_size_t		data_size,
				vm_offset_t		region_mappings,
				vm_offset_t		client_base,
				shared_region_mapping_t	*shared_region,
				vm_offset_t		alt_base,
				vm_offset_t		alt_next,
				int			fs_base,
				int			system);

extern kern_return_t shared_region_mapping_ref(
				shared_region_mapping_t	shared_region);

extern kern_return_t shared_region_mapping_dealloc(
				shared_region_mapping_t	shared_region);

extern kern_return_t shared_region_object_chain_attach(
				shared_region_mapping_t	target_region,
				shared_region_mapping_t	object_chain);

extern void shared_region_object_chain_detached(
	shared_region_mapping_t	target_region);

extern kern_return_t vm_get_shared_region(
				task_t	task,
				shared_region_mapping_t	*shared_region);

extern kern_return_t vm_set_shared_region(
				task_t	task,
				shared_region_mapping_t	shared_region);

extern shared_region_mapping_t update_default_shared_region(
				shared_region_mapping_t new_system_region);

extern shared_region_mapping_t lookup_default_shared_region(
				unsigned int fs_base,
				unsigned int system);

extern void remove_default_shared_region(
				shared_region_mapping_t system_region);

__private_extern__ void remove_default_shared_region_lock(
				shared_region_mapping_t system_region,
				int need_sfh_lock,
				int need_drl_lock);

__private_extern__ struct load_struct *lsf_remove_regions_mappings_lock(
				shared_region_mapping_t	region,
				shared_region_task_mappings_t	sm_info,
				int need_lock);

extern unsigned int lsf_mapping_pool_gauge(void);

extern kern_return_t shared_file_create_system_region(
	shared_region_mapping_t	*shared_region,
	int			fs_base,
	int			system);

extern void remove_all_shared_regions(void);

extern void shared_file_boot_time_init(
		unsigned int fs_base, 
		unsigned int system);

extern struct load_struct *lsf_remove_regions_mappings(
	shared_region_mapping_t	region,
	shared_region_task_mappings_t	sm_info);

extern kern_return_t shared_region_mapping_set_alt_next(
		shared_region_mapping_t	shared_region,
		vm_offset_t		alt_next);

extern void mach_memory_entry_port_release(ipc_port_t port);
extern void mach_destroy_memory_entry(ipc_port_t port);

extern kern_return_t mach_memory_entry_purgable_control(
	ipc_port_t	entry_port,
	vm_purgable_t	control,
	int		*state);

extern kern_return_t mach_memory_entry_page_op(
	ipc_port_t		entry_port,
	vm_object_offset_t	offset,
	int			ops,
	ppnum_t			*phys_entry,
	int			*flags);

extern kern_return_t mach_memory_entry_range_op(
	ipc_port_t		entry_port,
	vm_object_offset_t	offset_beg,
	vm_object_offset_t	offset_end,
	int                     ops,
	int                     *range);

#endif /* KERNEL_PRIVATE */

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