52303327c07d0513217b4d710e4a997f053bee1e
[kopensolaris-gnu/glibc.git] / sysdeps / generic / ldsodefs.h
1 /* Run-time dynamic linker data structures for loaded ELF shared objects.
2    Copyright (C) 1995-1999, 2000, 2001, 2002 Free Software Foundation, Inc.
3    This file is part of the GNU C Library.
4
5    The GNU C Library is free software; you can redistribute it and/or
6    modify it under the terms of the GNU Lesser General Public
7    License as published by the Free Software Foundation; either
8    version 2.1 of the License, or (at your option) any later version.
9
10    The GNU C Library is distributed in the hope that it will be useful,
11    but WITHOUT ANY WARRANTY; without even the implied warranty of
12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13    Lesser General Public License for more details.
14
15    You should have received a copy of the GNU Lesser General Public
16    License along with the GNU C Library; if not, write to the Free
17    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
18    02111-1307 USA.  */
19
20 #ifndef _LDSODEFS_H
21 #define _LDSODEFS_H     1
22
23 #include <features.h>
24
25 #define __need_size_t
26 #define __need_NULL
27 #include <stddef.h>
28 #include <string.h>
29
30 #include <elf.h>
31 #include <dlfcn.h>
32 #include <sys/mman.h>
33 #include <link.h>
34 #include <dl-lookupcfg.h>
35 #include <bits/libc-lock.h>
36
37 __BEGIN_DECLS
38
39 /* We use this macro to refer to ELF types independent of the native wordsize.
40    `ElfW(TYPE)' is used in place of `Elf32_TYPE' or `Elf64_TYPE'.  */
41 #define ELFW(type)      _ElfW (ELF, __ELF_NATIVE_CLASS, type)
42
43 /* All references to the value of l_info[DT_PLTGOT],
44   l_info[DT_STRTAB], l_info[DT_SYMTAB], l_info[DT_RELA],
45   l_info[DT_REL], l_info[DT_JMPREL], and l_info[VERSYMIDX (DT_VERSYM)]
46   have to be accessed via the D_PTR macro.  The macro is needed since for
47   most architectures the entry is already relocated - but for some not
48   and we need to relocate at access time.  */
49 #ifdef DL_RO_DYN_SECTION
50 # define D_PTR(map,i) (map->i->d_un.d_ptr + map->l_addr)
51 #else
52 # define D_PTR(map,i) map->i->d_un.d_ptr
53 #endif
54
55 /* On some platforms more information than just the address of the symbol
56    is needed from the lookup functions.  In this case we return the whole
57    link map.  */
58 #ifdef DL_LOOKUP_RETURNS_MAP
59 typedef struct link_map *lookup_t;
60 # define LOOKUP_VALUE(map) map
61 # define LOOKUP_VALUE_ADDRESS(map) (map ? map->l_addr : 0)
62 #else
63 typedef ElfW(Addr) lookup_t;
64 # define LOOKUP_VALUE(map) map->l_addr
65 # define LOOKUP_VALUE_ADDRESS(address) address
66 #endif
67
68 /* on some architectures a pointer to a function is not just a pointer
69    to the actual code of the function but rather an architecture
70    specific descriptor. */
71 #ifndef ELF_FUNCTION_PTR_IS_SPECIAL
72 # define DL_SYMBOL_ADDRESS(map, ref) \
73  (void *) (LOOKUP_VALUE_ADDRESS (map) + ref->st_value)
74 # define DL_LOOKUP_ADDRESS(addr) ((ElfW(Addr)) (addr))
75 # define DL_DT_INIT_ADDRESS(map, start) (start)
76 # define DL_DT_FINI_ADDRESS(map, start) (start)
77 #endif
78
79 /* Unmap a loaded object, called by _dl_close (). */
80 #ifndef DL_UNMAP_IS_SPECIAL
81 # define DL_UNMAP(map) \
82  __munmap ((void *) (map)->l_map_start,                                       \
83            (map)->l_map_end - (map)->l_map_start)
84 #endif
85
86 /* By default we do not need special support to initialize DSOs loaded
87    by statically linked binaries.  */
88 #ifndef DL_STATIC_INIT
89 # define DL_STATIC_INIT(map)
90 #endif
91
92 /* Reloc type classes as returned by elf_machine_type_class().
93    ELF_RTYPE_CLASS_PLT means this reloc should not be satisfied by
94    some PLT symbol, ELF_RTYPE_CLASS_COPY means this reloc should not be
95    satisfied by any symbol in the executable.  */
96 #define ELF_RTYPE_CLASS_PLT 1
97 #define ELF_RTYPE_CLASS_COPY 2
98
99 /* ELF uses the PF_x macros to specify the segment permissions, mmap
100    uses PROT_xxx.  In most cases the three macros have the values 1, 2,
101    and 3 but not in a matching order.  The following macros allows
102    converting from the PF_x values to PROT_xxx values.  */
103 #define PF_TO_PROT \
104   ((PROT_READ << (PF_R * 4))                                                  \
105    | (PROT_WRITE << (PF_W * 4))                                               \
106    | (PROT_EXEC << (PF_X * 4))                                                \
107    | ((PROT_READ | PROT_WRITE) << ((PF_R | PF_W) * 4))                        \
108    | ((PROT_READ | PROT_EXEC) << ((PF_R | PF_X) * 4))                         \
109    | ((PROT_WRITE | PROT_EXEC) << (PF_W | PF_X) * 4)                          \
110    | ((PROT_READ | PROT_WRITE | PROT_EXEC) << ((PF_R | PF_W | PF_X) * 4)))
111
112
113 /* For the version handling we need an array with only names and their
114    hash values.  */
115 struct r_found_version
116   {
117     const char *name;
118     ElfW(Word) hash;
119
120     int hidden;
121     const char *filename;
122   };
123
124 /* We want to cache information about the searches for shared objects.  */
125
126 enum r_dir_status { unknown, nonexisting, existing };
127
128 struct r_search_path_elem
129   {
130     /* This link is only used in the `all_dirs' member of `r_search_path'.  */
131     struct r_search_path_elem *next;
132
133     /* Strings saying where the definition came from.  */
134     const char *what;
135     const char *where;
136
137     /* Basename for this search path element.  The string must end with
138        a slash character.  */
139     const char *dirname;
140     size_t dirnamelen;
141
142     enum r_dir_status status[0];
143   };
144
145 struct r_strlenpair
146   {
147     const char *str;
148     size_t len;
149   };
150
151
152 /* A data structure for a simple single linked list of strings.  */
153 struct libname_list
154   {
155     const char *name;           /* Name requested (before search).  */
156     struct libname_list *next;  /* Link to next name for this object.  */
157     int dont_free;              /* Flag whether this element should be freed
158                                    if the object is not entirely unloaded.  */
159   };
160
161
162 /* Test whether given NAME matches any of the names of the given object.  */
163 static __inline int
164 __attribute__ ((unused))
165 _dl_name_match_p (const char *__name, struct link_map *__map)
166 {
167   int __found = strcmp (__name, __map->l_name) == 0;
168   struct libname_list *__runp = __map->l_libname;
169
170   while (! __found && __runp != NULL)
171     if (strcmp (__name, __runp->name) == 0)
172       __found = 1;
173     else
174       __runp = __runp->next;
175
176   return __found;
177 }
178
179 /* Function used as argument for `_dl_receive_error' function.  The
180    arguments are the error code, error string, and the objname the
181    error occurred in.  */
182 typedef void (*receiver_fct) (int, const char *, const char *);
183 \f
184 /* Internal functions of the run-time dynamic linker.
185    These can be accessed if you link again the dynamic linker
186    as a shared library, as in `-lld' or `/lib/ld.so' explicitly;
187    but are not normally of interest to user programs.
188
189    The `-ldl' library functions in <dlfcn.h> provide a simple
190    user interface to run-time dynamic linking.  */
191
192
193 #ifndef SHARED
194 # define EXTERN extern
195 # define GL(name) _##name
196 #else
197 # define EXTERN
198 # define GL(name) _rtld_global._##name
199 struct rtld_global
200 {
201 #endif
202   /* Don't change the order of the following elements.  'dl_loaded'
203      must remain the first element.  Forever.  */
204
205   /* And a pointer to the map for the main map.  */
206   EXTERN struct link_map *_dl_loaded;
207   /* Number of object in the _dl_loaded list.  */
208   EXTERN unsigned int _dl_nloaded;
209   /* Array representing global scope.  */
210   EXTERN struct r_scope_elem *_dl_global_scope[2];
211   /* Direct pointer to the searchlist of the main object.  */
212   EXTERN struct r_scope_elem *_dl_main_searchlist;
213   /* Copy of the content of `_dl_main_searchlist'.  */
214   EXTERN struct r_scope_elem _dl_initial_searchlist;
215   /* This is zero at program start to signal that the global scope map is
216      allocated by rtld.  Later it keeps the size of the map.  It might be
217      reset if in _dl_close if the last global object is removed.  */
218   EXTERN size_t _dl_global_scope_alloc;
219
220   /* If nonzero the appropriate debug information is printed.  */
221   EXTERN int _dl_debug_mask;
222 #define DL_DEBUG_LIBS       (1 << 0)
223 #define DL_DEBUG_IMPCALLS   (1 << 1)
224 #define DL_DEBUG_BINDINGS   (1 << 2)
225 #define DL_DEBUG_SYMBOLS    (1 << 3)
226 #define DL_DEBUG_VERSIONS   (1 << 4)
227 #define DL_DEBUG_RELOC      (1 << 5)
228 #define DL_DEBUG_FILES      (1 << 6)
229 #define DL_DEBUG_STATISTICS (1 << 7)
230 /* This one is used only internally.  */
231 #define DL_DEBUG_HELP       (1 << 8)
232 #define DL_DEBUG_PRELINK    (1 << 9)
233
234   /* Cached value of `getpagesize ()'.  */
235   EXTERN size_t _dl_pagesize;
236
237   /* OS version.  */
238   EXTERN unsigned int _dl_osversion;
239   /* Platform name.  */
240   EXTERN const char *_dl_platform;
241   EXTERN size_t _dl_platformlen;
242
243 #ifndef MAP_ANON
244   /* File descriptor referring to the zero-fill device.  */
245   EXTERN int _dl_zerofd;
246 #endif
247
248   /* CLK_TCK as reported by the kernel.  */
249   EXTERN int _dl_clktck;
250
251   /* If nonzero print warnings messages.  */
252   EXTERN int _dl_verbose;
253
254   /* Nonzero if runtime lookups should not update the .got/.plt.  */
255   EXTERN int _dl_bind_not;
256
257   /* The object to be initialized first.  */
258   EXTERN struct link_map *_dl_initfirst;
259
260   /* Name of the shared object to be profiled (if any).  */
261   EXTERN const char *_dl_profile;
262   /* Map of shared object to be profiled.  */
263   EXTERN struct link_map *_dl_profile_map;
264   /* Filename of the output file.  */
265   EXTERN const char *_dl_profile_output;
266   /* Map of shared object to be prelink traced.  */
267   EXTERN struct link_map *_dl_trace_prelink_map;
268   /* Name of the object we want to trace the prelinking.  */
269   EXTERN const char *_dl_trace_prelink;
270
271   /* Expect cache ID.  */
272   EXTERN int _dl_correct_cache_id;
273
274   /* Counters for the number of relocations performed.  */
275   EXTERN unsigned long int _dl_num_relocations;
276   EXTERN unsigned long int _dl_num_cache_relocations;
277
278   /* Mask for hardware capabilities that are available.  */
279   EXTERN unsigned long int _dl_hwcap;
280
281   /* Mask for important hardware capabilities we honour. */
282   EXTERN unsigned long int _dl_hwcap_mask;
283
284   /* Names of shared object for which the RPATH should be ignored.  */
285   EXTERN const char *_dl_inhibit_rpath;
286
287   /* Location of the binary.  */
288   EXTERN const char *_dl_origin_path;
289
290   /* List of search directories.  */
291   EXTERN struct r_search_path_elem *_dl_all_dirs;
292   EXTERN struct r_search_path_elem *_dl_init_all_dirs;
293
294   /* Structure describing the dynamic linker itself.  */
295   EXTERN struct link_map _dl_rtld_map;
296 #ifdef SHARED
297 };
298 extern struct rtld_global _rtld_global;
299 #endif
300 #undef EXTERN
301
302 /* Parameters passed to the dynamic linker.  */
303 extern int _dl_argc;
304 extern char **_dl_argv;
305
306 /* Do we do lazy relocations?  */
307 extern int _dl_lazy;
308
309 /* The array with message we print as a last resort.  */
310 extern const char _dl_out_of_memory[];
311
312 /* File descriptor to write debug messages to.  */
313 extern int _dl_debug_fd;
314
315 /* Nonzero if references should be treated as weak during runtime
316    linking.
317
318    XXX Once we can set the default for this variable to zero move it
319    into _rtld_global.  */
320 extern int _dl_dynamic_weak;
321
322
323 /* OS-dependent function to open the zero-fill device.  */
324 extern int _dl_sysdep_open_zero_fill (void); /* dl-sysdep.c */
325
326
327 /* During the program run we must not modify the global data of
328    loaded shared object simultanously in two threads.  Therefore we
329    protect `_dl_open' and `_dl_close' in dl-close.c.
330
331    This must be a recursive lock since the initializer function of
332    the loaded object might as well require a call to this function.
333    At this time it is not anymore a problem to modify the tables.  */
334 __libc_lock_define_recursive (extern, _dl_load_lock)
335
336
337 /* Write message on the debug file descriptor.  The parameters are
338    interpreted as for a `printf' call.  All the lines start with a
339    tag showing the PID.  */
340 extern void _dl_debug_printf (const char *fmt, ...)
341      __attribute__ ((__format__ (__printf__, 1, 2)));
342
343 /* Write message on the debug file descriptor.  The parameters are
344    interpreted as for a `printf' call.  All the lines buf the first
345    start with a tag showing the PID.  */
346 extern void _dl_debug_printf_c (const char *fmt, ...)
347      __attribute__ ((__format__ (__printf__, 1, 2)));
348
349
350 /* Write a message on the specified descriptor FD.  The parameters are
351    interpreted as for a `printf' call.  */
352 extern void _dl_dprintf (int fd, const char *fmt, ...)
353      __attribute__ ((__format__ (__printf__, 2, 3)));
354
355 /* Write a message on the specified descriptor standard output.  The
356    parameters are interpreted as for a `printf' call.  */
357 #define _dl_printf(fmt, args...) \
358   _dl_dprintf (STDOUT_FILENO, fmt, ##args)
359
360 /* Write a message on the specified descriptor standard error.  The
361    parameters are interpreted as for a `printf' call.  */
362 #define _dl_error_printf(fmt, args...) \
363   _dl_dprintf (STDERR_FILENO, fmt, ##args)
364
365 /* Write a message on the specified descriptor standard error and exit
366    the program.  The parameters are interpreted as for a `printf' call.  */
367 #define _dl_fatal_printf(fmt, args...) \
368   do                                                                          \
369     {                                                                         \
370       _dl_dprintf (STDERR_FILENO, fmt, ##args);                               \
371       _exit (127);                                                            \
372     }                                                                         \
373   while (1)
374
375
376 /* This function is called by all the internal dynamic linker functions
377    when they encounter an error.  ERRCODE is either an `errno' code or
378    zero; OBJECT is the name of the problematical shared object, or null if
379    it is a general problem; ERRSTRING is a string describing the specific
380    problem.  */
381 extern void _dl_signal_error (int errcode, const char *object,
382                               const char *occurred, const char *errstring)
383      internal_function
384      __attribute__ ((__noreturn__));
385
386 /* Like _dl_signal_error, but may return when called in the context of
387    _dl_receive_error.  */
388 extern void _dl_signal_cerror (int errcode, const char *object,
389                                const char *occation, const char *errstring)
390      internal_function;
391
392 /* Call OPERATE, receiving errors from `dl_signal_cerror'.  Unlike
393    `_dl_catch_error' the operation is resumed after the OPERATE
394    function returns.
395    ARGS is passed as argument to OPERATE.  */
396 extern void _dl_receive_error (receiver_fct fct, void (*operate) (void *),
397                                void *args)
398      internal_function;
399
400
401 /* Open the shared object NAME and map in its segments.
402    LOADER's DT_RPATH is used in searching for NAME.
403    If the object is already opened, returns its existing map.
404    For preloaded shared objects PRELOADED is set to a non-zero
405    value to allow additional security checks.  */
406 extern struct link_map *_dl_map_object (struct link_map *loader,
407                                         const char *name, int preloaded,
408                                         int type, int trace_mode, int mode)
409      internal_function;
410
411 /* Call _dl_map_object on the dependencies of MAP, and set up
412    MAP->l_searchlist.  PRELOADS points to a vector of NPRELOADS previously
413    loaded objects that will be inserted into MAP->l_searchlist after MAP
414    but before its dependencies.  */
415 extern void _dl_map_object_deps (struct link_map *map,
416                                  struct link_map **preloads,
417                                  unsigned int npreloads, int trace_mode)
418      internal_function;
419
420 /* Cache the locations of MAP's hash table.  */
421 extern void _dl_setup_hash (struct link_map *map) internal_function;
422
423
424 /* Search loaded objects' symbol tables for a definition of the symbol
425    referred to by UNDEF.  *SYM is the symbol table entry containing the
426    reference; it is replaced with the defining symbol, and the base load
427    address of the defining object is returned.  SYMBOL_SCOPE is a
428    null-terminated list of object scopes to search; each object's
429    l_searchlist (i.e. the segment of the dependency tree starting at that
430    object) is searched in turn.  REFERENCE_NAME should name the object
431    containing the reference; it is used in error messages.
432    TYPE_CLASS describes the type of symbol we are looking for.  */
433 extern lookup_t _dl_lookup_symbol (const char *undef,
434                                    struct link_map *undef_map,
435                                    const ElfW(Sym) **sym,
436                                    struct r_scope_elem *symbol_scope[],
437                                    int type_class, int explicit)
438      internal_function;
439
440 /* Lookup versioned symbol.  */
441 extern lookup_t _dl_lookup_versioned_symbol (const char *undef,
442                                              struct link_map *undef_map,
443                                              const ElfW(Sym) **sym,
444                                              struct r_scope_elem *symbol_scope[],
445                                              const struct r_found_version *version,
446                                              int type_class, int explicit)
447      internal_function;
448
449 /* For handling RTLD_NEXT we must be able to skip shared objects.  */
450 extern lookup_t _dl_lookup_symbol_skip (const char *undef,
451                                         struct link_map *undef_map,
452                                         const ElfW(Sym) **sym,
453                                         struct r_scope_elem *symbol_scope[],
454                                         struct link_map *skip_this)
455      internal_function;
456
457 /* For handling RTLD_NEXT with versioned symbols we must be able to
458    skip shared objects.  */
459 extern lookup_t _dl_lookup_versioned_symbol_skip (const char *undef,
460                                                   struct link_map *undef_map,
461                                                   const ElfW(Sym) **sym,
462                                                   struct r_scope_elem *symbol_scope[],
463                                                   const struct r_found_version *version,
464                                                   struct link_map *skip_this)
465      internal_function;
466
467 /* Look up symbol NAME in MAP's scope and return its run-time address.  */
468 extern ElfW(Addr) _dl_symbol_value (struct link_map *map, const char *name)
469      internal_function;
470
471 /* Allocate a `struct link_map' for a new object being loaded,
472    and enter it into the _dl_main_map list.  */
473 extern struct link_map *_dl_new_object (char *realname, const char *libname,
474                                         int type, struct link_map *loader)
475      internal_function;
476
477 /* Relocate the given object (if it hasn't already been).
478    SCOPE is passed to _dl_lookup_symbol in symbol lookups.
479    If LAZY is nonzero, don't relocate its PLT.  */
480 extern void _dl_relocate_object (struct link_map *map,
481                                  struct r_scope_elem *scope[],
482                                  int lazy, int consider_profiling);
483
484 /* Call _dl_signal_error with a message about an unhandled reloc type.
485    TYPE is the result of ELFW(R_TYPE) (r_info), i.e. an R_<CPU>_* value.
486    PLT is nonzero if this was a PLT reloc; it just affects the message.  */
487 extern void _dl_reloc_bad_type (struct link_map *map,
488                                 unsigned int type, int plt)
489      internal_function __attribute__ ((__noreturn__));
490
491 /* Resolve conflicts if prelinking.  */
492 extern void _dl_resolve_conflicts (struct link_map *l,
493                                    ElfW(Rela) *conflict,
494                                    ElfW(Rela) *conflictend);
495
496 /* Check the version dependencies of all objects available through
497    MAP.  If VERBOSE print some more diagnostics.  */
498 extern int _dl_check_all_versions (struct link_map *map, int verbose,
499                                    int trace_mode)
500      internal_function;
501
502 /* Check the version dependencies for MAP.  If VERBOSE print some more
503    diagnostics.  */
504 extern int _dl_check_map_versions (struct link_map *map, int verbose,
505                                    int trace_mode)
506      internal_function;
507
508 /* Initialize the object in SCOPE by calling the constructors with
509    ARGC, ARGV, and ENV as the parameters.  */
510 extern void _dl_init (struct link_map *main_map, int argc, char **argv,
511                       char **env) internal_function;
512
513 /* Call the finalizer functions of all shared objects whose
514    initializer functions have completed.  */
515 extern void _dl_fini (void) internal_function;
516
517 /* The dynamic linker calls this function before and having changing
518    any shared object mappings.  The `r_state' member of `struct r_debug'
519    says what change is taking place.  This function's address is
520    the value of the `r_brk' member.  */
521 extern void _dl_debug_state (void);
522
523 /* Initialize `struct r_debug' if it has not already been done.  The
524    argument is the run-time load address of the dynamic linker, to be put
525    in the `r_ldbase' member.  Returns the address of the structure.  */
526 extern struct r_debug *_dl_debug_initialize (ElfW(Addr) ldbase)
527      internal_function;
528
529 /* Initialize the basic data structure for the search paths.  */
530 extern void _dl_init_paths (const char *library_path) internal_function;
531
532 /* Gather the information needed to install the profiling tables and start
533    the timers.  */
534 extern void _dl_start_profile (struct link_map *map, const char *output_dir)
535      internal_function;
536
537 /* The actual functions used to keep book on the calls.  */
538 extern void _dl_mcount (ElfW(Addr) frompc, ElfW(Addr) selfpc);
539
540 /* This function is simply a wrapper around the _dl_mcount function
541    which does not require a FROMPC parameter since this is the
542    calling function.  */
543 extern void _dl_mcount_wrapper (void *selfpc);
544
545 /* Show the members of the auxiliary array passed up from the kernel.  */
546 extern void _dl_show_auxv (void) internal_function;
547
548 /* Return all environment variables starting with `LD_', one after the
549    other.  */
550 extern char *_dl_next_ld_env_entry (char ***position) internal_function;
551
552 /* Return an array with the names of the important hardware capabilities.  */
553 extern const struct r_strlenpair *_dl_important_hwcaps (const char *platform,
554                                                         size_t paltform_len,
555                                                         size_t *sz,
556                                                         size_t *max_capstrlen)
557      internal_function;
558
559 /* Look up NAME in ld.so.cache and return the file name stored there,
560    or null if none is found.  */
561 extern const char *_dl_load_cache_lookup (const char *name)
562      internal_function;
563
564 /* If the system does not support MAP_COPY we cannot leave the file open
565    all the time since this would create problems when the file is replaced.
566    Therefore we provide this function to close the file and open it again
567    once needed.  */
568 extern void _dl_unload_cache (void);
569
570 /* System-dependent function to read a file's whole contents in the
571    most convenient manner available.  *SIZEP gets the size of the
572    file.  On error MAP_FAILED is returned.  */
573 extern void *_dl_sysdep_read_whole_file (const char *file, size_t *sizep,
574                                          int prot)
575      internal_function;
576
577 /* System-specific function to do initial startup for the dynamic linker.
578    After this, file access calls and getenv must work.  This is responsible
579    for setting __libc_enable_secure if we need to be secure (e.g. setuid),
580    and for setting _dl_argc and _dl_argv, and then calling _dl_main.  */
581 extern ElfW(Addr) _dl_sysdep_start (void **start_argptr,
582                                     void (*dl_main) (const ElfW(Phdr) *phdr,
583                                                      ElfW(Word) phnum,
584                                                      ElfW(Addr) *user_entry));
585
586 extern void _dl_sysdep_start_cleanup (void)
587      internal_function;
588
589
590 __END_DECLS
591
592 #endif /* ldsodefs.h */