Fully synchronize sys/boot from FreeBSD-5.x, but add / to the module path
[dragonfly.git] / sys / sys / linker.h
1 /*-
2  * Copyright (c) 1997 Doug Rabson
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24  * SUCH DAMAGE.
25  *
26  * $FreeBSD: src/sys/sys/linker.h,v 1.17.2.1 2002/03/11 01:13:53 dd Exp $
27  * $DragonFly: src/sys/sys/linker.h,v 1.4 2003/11/10 06:12:17 dillon Exp $
28  */
29
30 #ifndef _SYS_LINKER_H_
31 #define _SYS_LINKER_H_
32
33 #ifdef _KERNEL
34
35 #include <machine/elf.h>
36
37 #ifdef MALLOC_DECLARE
38 MALLOC_DECLARE(M_LINKER);
39 #endif
40
41 /*
42  * Object representing a file which has been loaded by the linker.
43  */
44 typedef struct linker_file* linker_file_t;
45 typedef TAILQ_HEAD(, linker_file) linker_file_list_t;
46
47 typedef caddr_t linker_sym_t;           /* opaque symbol */
48 typedef c_caddr_t c_linker_sym_t;       /* const opaque symbol */
49
50 /*
51  * expanded out linker_sym_t
52  */
53 typedef struct linker_symval {
54     const char*         name;
55     caddr_t             value;
56     size_t              size;
57 } linker_symval_t;
58
59 struct linker_file_ops {
60     /*
61      * Lookup a symbol in the file's symbol table.  If the symbol is
62      * not found then return ENOENT, otherwise zero.  If the symbol
63      * found is a common symbol, return with *address set to zero and
64      * *size set to the size of the common space required.  Otherwise
65      * set *address the value of the symbol.
66      */
67     int                 (*lookup_symbol)(linker_file_t, const char* name,
68                                          c_linker_sym_t* sym);
69
70     int                 (*symbol_values)(linker_file_t, c_linker_sym_t,
71                                          linker_symval_t*);
72
73     int                 (*search_symbol)(linker_file_t, caddr_t value,
74                                          c_linker_sym_t* sym, long* diffp);
75
76     /*
77      * Unload a file, releasing dependancies and freeing storage.
78      */
79     void                (*unload)(linker_file_t);
80
81     int                 (*lookup_set)(linker_file_t, const char *name,
82                                         void ***firstp, void ***lastp, int *countp);
83 };
84
85 struct common_symbol {
86     STAILQ_ENTRY(common_symbol) link;
87     char*               name;
88     caddr_t             address;
89 };
90
91 struct linker_file {
92     int                 refs;           /* reference count */
93     int                 userrefs;       /* kldload(2) count */
94     int                 flags;
95 #define LINKER_FILE_LINKED      0x1     /* file has been fully linked */
96     TAILQ_ENTRY(linker_file) link;      /* list of all loaded files */
97     char*               filename;       /* file which was loaded */
98     int                 id;             /* unique id */
99     caddr_t             address;        /* load address */
100     size_t              size;           /* size of file */
101     int                 ndeps;          /* number of dependancies */
102     linker_file_t*      deps;           /* list of dependancies */
103     STAILQ_HEAD(, common_symbol) common; /* list of common symbols */
104     TAILQ_HEAD(, module) modules;       /* modules in this file */
105     void*               priv;           /* implementation data */
106
107     struct linker_file_ops* ops;
108 };
109
110 /*
111  * Object implementing a class of file (a.out, elf, etc.)
112  */
113 typedef struct linker_class *linker_class_t;
114 typedef TAILQ_HEAD(, linker_class) linker_class_list_t;
115
116 struct linker_class_ops {
117     /* 
118      * Load a file, returning the new linker_file_t in *result.  If
119      * the class does not recognise the file type, zero should be
120      * returned, without modifying *result.  If the file is
121      * recognised, the file should be loaded, *result set to the new
122      * file and zero returned.  If some other error is detected an
123      * appropriate errno should be returned.
124      */
125     int         (*load_file)(const char* filename, linker_file_t* result);
126 };
127
128 struct linker_class {
129     TAILQ_ENTRY(linker_class) link;     /* list of all file classes */
130     const char*         desc;           /* description (e.g. "a.out") */
131     void*               priv;           /* implementation data */
132
133     struct linker_class_ops *ops;
134 };
135
136 /*
137  * The file which is currently loading.  Used to register modules with
138  * the files which contain them.
139  */
140 extern linker_file_t    linker_current_file;
141
142 /*
143  * The "file" for the kernel.
144  */
145 extern linker_file_t    linker_kernel_file;
146
147 /*
148  * Add a new file class to the linker.
149  */
150 int linker_add_class(const char* _desc, void* _priv,
151                      struct linker_class_ops* _ops);
152
153 /*
154  * Load a file, trying each file class until one succeeds.
155  */
156 int linker_load_file(const char* _filename, linker_file_t* _result);
157
158 /*
159  * Find a currently loaded file given its filename.
160  */
161 linker_file_t linker_find_file_by_name(const char* _filename);
162
163 /*
164  * Find a currently loaded file given its file id.
165  */
166 linker_file_t linker_find_file_by_id(int _fileid);
167
168 /*
169  * Called from a class handler when a file is laoded.
170  */
171 linker_file_t linker_make_file(const char* _filename, void* _priv,
172                                struct linker_file_ops* _ops);
173
174 /*
175  * Unload a file, freeing up memory.
176  */
177 int linker_file_unload(linker_file_t _file);
178
179 /*
180  * Add a dependancy to a file.
181  */
182 int linker_file_add_dependancy(linker_file_t _file, linker_file_t _dep);
183
184 /*
185  * Lookup a symbol in a file.  If deps is TRUE, look in dependancies
186  * if not found in file.  The symbol's value is returned in the
187  * caddr_t.  An error is returned, 0 if no error occured.
188  */
189 int linker_file_lookup_symbol(linker_file_t _file, const char* _name, 
190                             int _deps, caddr_t *);
191
192
193 /*
194  * Lookup a linker set in a file.  Return pointers to the first entry,
195  * last + 1, and count of entries.  Use: for (p = start; p < stop; p++) {}
196  * void *start is really: "struct yoursetmember ***start;"
197  */
198 int linker_file_lookup_set(linker_file_t _file, const char *_name,
199                             void *_start, void *_stop, int *_count);
200
201 /*
202  * Search the linker path for the module.  Return the full pathname in
203  * a malloc'ed buffer.
204  */
205 char *linker_search_path(const char *_filename);
206
207 /*
208  * DDB Helpers, tuned specifically for ddb/db_kld.c
209  */
210 int linker_ddb_lookup(const char *_symstr, c_linker_sym_t *_sym);
211 int linker_ddb_search_symbol(caddr_t _value, c_linker_sym_t *_sym,
212                              long *_diffp);
213 int linker_ddb_symbol_values(c_linker_sym_t _sym, linker_symval_t *_symval);
214
215
216 #endif  /* _KERNEL */
217
218 /*
219  * Module information subtypes
220  */
221 #define MODINFO_END             0x0000          /* End of list */
222 #define MODINFO_NAME            0x0001          /* Name of module (string) */
223 #define MODINFO_TYPE            0x0002          /* Type of module (string) */
224 #define MODINFO_ADDR            0x0003          /* Loaded address */
225 #define MODINFO_SIZE            0x0004          /* Size of module */
226 #define MODINFO_EMPTY           0x0005          /* Has been deleted */
227 #define MODINFO_ARGS            0x0006          /* Parameters string */
228 #define MODINFO_METADATA        0x8000          /* Module-specfic */
229
230 #define MODINFOMD_AOUTEXEC      0x0001          /* a.out exec header */
231 #define MODINFOMD_ELFHDR        0x0002          /* ELF header */
232 #define MODINFOMD_SSYM          0x0003          /* start of symbols */
233 #define MODINFOMD_ESYM          0x0004          /* end of symbols */
234 #define MODINFOMD_DYNAMIC       0x0005          /* _DYNAMIC pointer */
235 #define MODINFOMD_ENVP          0x0006          /* (from 5.x) envp[] */
236 #define MODINFOMD_HOWTO         0x0007          /* (from 5.x) boothowto */
237 #define MODINFOMD_KERNEND       0x0008          /* (from 5.x) kernend */
238 #define MODINFOMD_NOCOPY        0x8000          /* don't copy this metadata to the kernel */
239
240 #define MODINFOMD_DEPLIST       (0x4001 | MODINFOMD_NOCOPY)     /* depends on */
241
242 #ifdef _KERNEL
243 #define MD_FETCH(mdp, info, type) ({ \
244         type *__p; \
245         __p = (type *)preload_search_info((mdp), MODINFO_METADATA | (info)); \
246         __p ? *__p : 0; \
247 })
248 #endif
249
250 #define LINKER_HINTS_VERSION    1               /* linker.hints file version */
251
252 #ifdef _KERNEL
253
254 /*
255  * Module lookup
256  */
257 extern caddr_t          preload_metadata;
258 extern caddr_t          preload_search_by_name(const char *_name);
259 extern caddr_t          preload_search_by_type(const char *_type);
260 extern caddr_t          preload_search_next_name(caddr_t _base);
261 extern caddr_t          preload_search_info(caddr_t _mod, int _inf);
262 extern void             preload_delete_name(const char *_name);
263 extern void             preload_bootstrap_relocate(vm_offset_t _offset);
264
265 #ifdef KLD_DEBUG
266
267 extern int kld_debug;
268 #define KLD_DEBUG_FILE  1       /* file load/unload */
269 #define KLD_DEBUG_SYM   2       /* symbol lookup */
270
271 #define KLD_DPF(cat, args)                                      \
272         do {                                                    \
273                 if (kld_debug & KLD_DEBUG_##cat) printf args;   \
274         } while (0)
275
276 #else
277
278 #define KLD_DPF(cat, args)
279
280 #endif
281
282 /* Support functions */
283 int     elf_reloc(linker_file_t _lf, const void *_rel, int _type,
284                   const char *_sym);
285 /* values for type */
286 #define ELF_RELOC_REL   1
287 #define ELF_RELOC_RELA  2
288
289 #endif /* _KERNEL */
290
291 struct kld_file_stat {
292     int         version;        /* set to sizeof(linker_file_stat) */
293     char        name[MAXPATHLEN];
294     int         refs;
295     int         id;
296     caddr_t     address;        /* load address */
297     size_t      size;           /* size in bytes */
298 };
299
300 struct kld_sym_lookup {
301     int         version;        /* set to sizeof(struct kld_sym_lookup) */
302     char        *symname;       /* Symbol name we are looking up */
303     u_long      symvalue;
304     size_t      symsize;
305 };
306 #define KLDSYM_LOOKUP   1
307
308 #ifndef _KERNEL
309
310 #include <sys/cdefs.h>
311
312 __BEGIN_DECLS
313 int     kldload(const char* _file);
314 int     kldunload(int _fileid);
315 int     kldfind(const char* _file);
316 int     kldnext(int _fileid);
317 int     kldstat(int _fileid, struct kld_file_stat* _stat);
318 int     kldfirstmod(int _fileid);
319 int     kldsym(int _fileid, int _cmd, void *_data);
320 __END_DECLS
321
322 #endif
323
324 #endif /* !_SYS_LINKER_H_ */