[apple/xnu.git] / libsa / dgraph.h

#ifndef __DGRAPH_H__
#define __DGRAPH_H__

#ifdef __cplusplus
extern "C" {
#endif

#ifdef KERNEL
#include <libsa/stdlib.h>
#include <IOKit/IOLib.h>
#else
#include <stdlib.h>
#include <mach/mach.h>
#endif /* KERNEL */

typedef struct dgraph_entry_t {

    char is_kernel_component; // means that name is a CFBundleIdentifier!!!
    char is_symbol_set; 
    char opaques;
    char opaque_link;

    // What we have to start from
    char * name;   // filename if user space, bundleid if kernel or kernel comp.

    void * object;         // In kernel we keep track of the object file
    size_t object_length;  //    we don't own this, however; it's just a ref
#ifdef KERNEL
    bool   object_is_kmem; // Only used when mapping a file!
#endif /* KERNEL */

   /* If is_kernel_component is true then the do_load field is cleared and
    * the kmod_id field gets set.
    */

    // Immediate dependencies of this entry
    unsigned int dependencies_capacity;
    unsigned int num_dependencies;
    struct dgraph_entry_t ** dependencies;

    // These are filled in when the entry is created, and are written into
    // the kmod linked image at load time.
    char * expected_kmod_name;
    char * expected_kmod_vers;

    bool is_mapped;  // kld_file_map() has been called for this entry

    // For tracking already-loaded kmods or for doing symbol generation only
    int do_load;   // actually loading
    vm_address_t loaded_address;  // address loaded at or being faked at for symbol generation
#ifndef KERNEL
    char * link_output_file;
    bool link_output_file_alloc;
#endif
    struct mach_header * linked_image;
    vm_size_t	 linked_image_length;

    vm_address_t symbols;
    vm_size_t	 symbols_length;
    vm_address_t symbols_malloc;

    // for loading into kernel
    vm_address_t  kernel_alloc_address;
    unsigned long kernel_alloc_size;
    vm_address_t  kernel_load_address;
    unsigned long kernel_load_size;
    unsigned long kernel_hdr_size;
    unsigned long kernel_hdr_pad;
    int need_cleanup;  // true if load failed with kernel memory allocated
    kmod_t kmod_id;    // the id assigned by the kernel to a loaded kmod

} dgraph_entry_t;

typedef struct {
    unsigned int      capacity;
    unsigned int      length;
    dgraph_entry_t ** graph;
    dgraph_entry_t ** load_order;
    dgraph_entry_t  * root;
    char	      have_loaded_symbols;
    char	      has_symbol_sets;
    char	      has_opaque_links;
    vm_address_t      opaque_base_image;
    vm_size_t	      opaque_base_length;
} dgraph_t;

typedef enum {
    dgraph_error = -1,
    dgraph_invalid = 0,
    dgraph_valid = 1
} dgraph_error_t;


dgraph_error_t dgraph_init(dgraph_t * dgraph);

#ifndef KERNEL
/**********
 * Initialize a dependency graph passed in. Returns nonzero on success, zero
 * on failure.
 *
 *     dependency_graph: a pointer to the dgraph to initialize.
 *     argc: the number of arguments in argv
 *     argv: an array of strings defining the dependency graph. This is a
 *         series of dependency lists, delimited by "-d" (except before
 *         the first list, naturally). Each list has as its first entry
 *         the dependent, followed by any number of DIRECT dependencies.
 *         The lists may be given in any order, but the first item in each
 *         list must be the dependent. Also, there can only be one root
 *         item (an item with no dependents upon it), and it must not be
 *         a kernel component.
 */
dgraph_error_t dgraph_init_with_arglist(
    dgraph_t * dgraph,
    int expect_addresses,
    const char * dependency_delimiter,
    const char * kernel_dependency_delimiter,
    int argc,
    char * argv[]);
#endif /* not KERNEL */

void dgraph_free(
    dgraph_t * dgraph,
    int free_graph);

dgraph_entry_t * dgraph_find_root(dgraph_t * dgraph);

int dgraph_establish_load_order(dgraph_t * dgraph);

#ifndef KERNEL
void dgraph_print(dgraph_t * dgraph);
#endif /* not kernel */
void dgraph_log(dgraph_t * depgraph);


/*****
 * These functions are useful for hand-building a dgraph.
 */
dgraph_entry_t * dgraph_find_dependent(dgraph_t * dgraph, const char * name);

dgraph_entry_t * dgraph_add_dependent(
    dgraph_t * dgraph,
    const char * name,
#ifdef KERNEL
    void * object,
    size_t object_length,
    bool   object_is_kmem,
#endif /* KERNEL */
    const char * expected_kmod_name,
    const char * expected_kmod_vers,
    vm_address_t load_address,
    char is_kernel_component);

dgraph_entry_t * dgraph_add_dependency(
    dgraph_t * dgraph,
    dgraph_entry_t * current_dependent,
    const char * name,
#ifdef KERNEL
    void * object,
    size_t object_length,
    bool   object_is_kmem,
#endif /* KERNEL */
    const char * expected_kmod_name,
    const char * expected_kmod_vers,
    vm_address_t load_address,
    char is_kernel_component);

#ifdef __cplusplus
}
#endif

#endif /* __DGRAPH_H__ */
Commit	Line	Data
55e303ae A	1	#ifndef __DGRAPH_H__
	2	#define __DGRAPH_H__
	3
	4	#ifdef __cplusplus
	5	extern "C" {
	6	#endif
	7
	8	#ifdef KERNEL
	9	#include <libsa/stdlib.h>
	10	#include <IOKit/IOLib.h>
	11	#else
	12	#include <stdlib.h>
	13	#include <mach/mach.h>
	14	#endif /* KERNEL */
	15
	16	typedef struct dgraph_entry_t {
	17
	18	char is_kernel_component; // means that name is a CFBundleIdentifier!!!
	19	char is_symbol_set;
	20	char opaques;
	21	char opaque_link;
	22
	23	// What we have to start from
	24	char * name; // filename if user space, bundleid if kernel or kernel comp.
	25
	26	void * object; // In kernel we keep track of the object file
	27	size_t object_length; // we don't own this, however; it's just a ref
	28	#ifdef KERNEL
	29	bool object_is_kmem; // Only used when mapping a file!
	30	#endif /* KERNEL */
	31
	32	/* If is_kernel_component is true then the do_load field is cleared and
	33	* the kmod_id field gets set.
	34	*/
	35
	36	// Immediate dependencies of this entry
	37	unsigned int dependencies_capacity;
	38	unsigned int num_dependencies;
	39	struct dgraph_entry_t ** dependencies;
	40
	41	// These are filled in when the entry is created, and are written into
	42	// the kmod linked image at load time.
	43	char * expected_kmod_name;
	44	char * expected_kmod_vers;
	45
	46	bool is_mapped; // kld_file_map() has been called for this entry
	47
	48	// For tracking already-loaded kmods or for doing symbol generation only
	49	int do_load; // actually loading
	50	vm_address_t loaded_address; // address loaded at or being faked at for symbol generation
	51	#ifndef KERNEL
	52	char * link_output_file;
	53	bool link_output_file_alloc;
	54	#endif
	55	struct mach_header * linked_image;
	56	vm_size_t linked_image_length;
	57
	58	vm_address_t symbols;
	59	vm_size_t symbols_length;
	60	vm_address_t symbols_malloc;
	61
	62	// for loading into kernel
	63	vm_address_t kernel_alloc_address;
	64	unsigned long kernel_alloc_size;
65	vm_address_t kernel_load_address;
66	unsigned long kernel_load_size;
67	unsigned long kernel_hdr_size;
68	unsigned long kernel_hdr_pad;
69	int need_cleanup; // true if load failed with kernel memory allocated
70	kmod_t kmod_id; // the id assigned by the kernel to a loaded kmod
71
72	} dgraph_entry_t;
73
74	typedef struct {
75	unsigned int capacity;
76	unsigned int length;
77	dgraph_entry_t ** graph;
78	dgraph_entry_t ** load_order;
79	dgraph_entry_t * root;
80	char have_loaded_symbols;
81	char has_symbol_sets;
82	char has_opaque_links;
83	vm_address_t opaque_base_image;
84	vm_size_t opaque_base_length;
85	} dgraph_t;
86
87	typedef enum {
88	dgraph_error = -1,
89	dgraph_invalid = 0,
90	dgraph_valid = 1
91	} dgraph_error_t;
92
93
94	dgraph_error_t dgraph_init(dgraph_t * dgraph);
95
96	#ifndef KERNEL
97	/**********
98	* Initialize a dependency graph passed in. Returns nonzero on success, zero
99	* on failure.
100	*
101	* dependency_graph: a pointer to the dgraph to initialize.
102	* argc: the number of arguments in argv
103	* argv: an array of strings defining the dependency graph. This is a
104	* series of dependency lists, delimited by "-d" (except before
105	* the first list, naturally). Each list has as its first entry
106	* the dependent, followed by any number of DIRECT dependencies.
107	* The lists may be given in any order, but the first item in each
108	* list must be the dependent. Also, there can only be one root
109	* item (an item with no dependents upon it), and it must not be
110	* a kernel component.
111	*/
112	dgraph_error_t dgraph_init_with_arglist(
113	dgraph_t * dgraph,
114	int expect_addresses,
115	const char * dependency_delimiter,
116	const char * kernel_dependency_delimiter,
117	int argc,
118	char * argv[]);
119	#endif /* not KERNEL */
120
121	void dgraph_free(
122	dgraph_t * dgraph,
123	int free_graph);
124
125	dgraph_entry_t * dgraph_find_root(dgraph_t * dgraph);
126
127	int dgraph_establish_load_order(dgraph_t * dgraph);
128
129	#ifndef KERNEL
130	void dgraph_print(dgraph_t * dgraph);
131	#endif /* not kernel */
132	void dgraph_log(dgraph_t * depgraph);
133
134
135	/*****
136	* These functions are useful for hand-building a dgraph.
137	*/
138	dgraph_entry_t * dgraph_find_dependent(dgraph_t * dgraph, const char * name);
139
140	dgraph_entry_t * dgraph_add_dependent(
141	dgraph_t * dgraph,
142	const char * name,
143	#ifdef KERNEL
144	void * object,
145	size_t object_length,
146	bool object_is_kmem,
147	#endif /* KERNEL */
148	const char * expected_kmod_name,
149	const char * expected_kmod_vers,
150	vm_address_t load_address,
151	char is_kernel_component);
152
153	dgraph_entry_t * dgraph_add_dependency(
154	dgraph_t * dgraph,
155	dgraph_entry_t * current_dependent,
156	const char * name,
157	#ifdef KERNEL
158	void * object,
159	size_t object_length,
160	bool object_is_kmem,
161	#endif /* KERNEL */
162	const char * expected_kmod_name,
163	const char * expected_kmod_vers,
164	vm_address_t load_address,
165	char is_kernel_component);
166
167	#ifdef __cplusplus
168	}
169	#endif
170
171	#endif /* __DGRAPH_H__ */