xref: /titanic_50/usr/src/cmd/sgs/include/rtld.h (revision 42ed7838f131b8f58d6c95db1c7e3a6a3e6ea7e4)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 #ifndef	_RTLD_H
27 #define	_RTLD_H
28 
29 /*
30  * Global include file for the runtime linker.
31  */
32 #include <sys/mman.h>
33 #include <time.h>
34 #include <sgs.h>
35 #include <thread.h>
36 #include <synch.h>
37 #include <link.h>
38 #include <sys/avl.h>
39 #include <alist.h>
40 #include <libc_int.h>
41 
42 #ifdef	_SYSCALL32
43 #include <inttypes.h>
44 #endif
45 
46 #ifdef	__cplusplus
47 extern "C" {
48 #endif
49 
50 /*
51  * We use rtld_ino_t instead of ino_t so that we can get
52  * access to large inode values from 32-bit code.
53  */
54 #ifdef _LP64
55 typedef ino_t		rtld_ino_t;
56 #else
57 typedef ino64_t		rtld_ino_t;
58 #endif
59 
60 typedef struct rt_map	Rt_map;
61 typedef struct slookup	Slookup;
62 
63 /*
64  * A binding descriptor.  Establishes the binding relationship between two
65  * objects, the caller (originator) and the dependency (destination).
66  *
67  * Every relationship between two objects is tracked by a binding descriptor.
68  * This descriptor is referenced from a link-map's DEPENDS and CALLERS lists.
69  * Note, Aplist's are diagramed to fully expose the allocations required to
70  * establish the data structure relationships.
71  *
72  *                                  Bnd_desc
73  *                                 ----------
74  *                    ------------| b_caller |
75  *                   |            | b_depend | ----------
76  *                   |            |          |           |
77  *      Rt_map       |             ----------            |       Rt_map
78  *    ----------     |                ^ ^                |     ----------
79  *   |          | <--                 | |                 --> |          |
80  *   |          |        --------     | |                     |          |
81  *   | DEPENDS  | ----> |        |    | |     --------        |          |
82  *   |          |       |        |    | |    |        | <---- | CALLERS  |
83  *   |          |       |        | ---  |    |        |       |          |
84  *   |          |       |        |       --- |        |       |          |
85  *   |          |        --------            |        |       |          |
86  *    ----------          Aplist              --------         ----------
87  *                                             Aplist
88  */
89 typedef struct {
90 	Rt_map		*b_caller;	/* caller (originator) of a binding */
91 	Rt_map		*b_depend;	/* dependency (destination) of a */
92 					/*	binding */
93 	uint_t		b_flags;	/* relationship of caller to the */
94 					/*	dependency */
95 } Bnd_desc;
96 
97 #define	BND_NEEDED	0x0001		/* caller NEEDED the dependency */
98 #define	BND_REFER	0x0002		/* caller relocation references the */
99 					/*	dependency */
100 #define	BND_FILTER	0x0004		/* binding identifies filter, used */
101 					/*	for diagnostics only */
102 /*
103  * Private structure for communication between rtld_db and rtld.
104  *
105  * We must bump the version number when ever an update in one of the
106  * structures/fields that rtld_db reads is updated.  This hopefully permits
107  * rtld_db implementations of the future to recognize core files produced on
108  * older systems and deal with these core files accordingly.
109  *
110  * As of version 'R_RTLDDB_VERSION <= 2' the following fields were valid for
111  * core file examination (basically the public Link_map):
112  *
113  *		ADDR()
114  *		NAME()
115  *		DYN()
116  *		NEXT()
117  *		PREV()
118  *
119  * Valid fields for R_RTLDDB_VERSION3
120  *
121  *		PATHNAME()
122  *		PADSTART()
123  *		PADIMLEN()
124  *		MSIZE()
125  *		FLAGS()
126  *		FLAGS1()
127  *
128  * Valid fields for R_RTLDDB_VERSION4
129  *
130  *		TLSMODID()
131  *
132  * Valid fields for R_RTLDDB_VERSION5
133  *
134  *		Added rtld_flags & FLG_RT_RELOCED to stable flags range
135  *
136  * Valid fields for R_RTLDDB_VERSION6
137  *
138  *		rtd_dynlmlst converted from a List to APlist
139  */
140 #define	R_RTLDDB_VERSION1	1	/* base version level - used for core */
141 					/*	file examination */
142 #define	R_RTLDDB_VERSION2	2	/* minor revision - not relevant for */
143 					/*	core files */
144 #define	R_RTLDDB_VERSION3	3
145 #define	R_RTLDDB_VERSION4	4
146 #define	R_RTLDDB_VERSION5	5
147 #define	R_RTLDDB_VERSION6	6
148 #define	R_RTLDDB_VERSION	R_RTLDDB_VERSION6	/* current version */
149 
150 typedef struct rtld_db_priv {
151 	struct r_debug	rtd_rdebug;	/* original r_debug structure */
152 	Word		rtd_version;	/* version no. */
153 	size_t		rtd_objpad;	/* padding around mmap()ed objects */
154 	APlist		**rtd_dynlmlst;	/* pointer to dynlm_list pointer */
155 } Rtld_db_priv;
156 
157 #ifdef _SYSCALL32
158 typedef struct rtld_db_priv32 {
159 	struct r_debug32 rtd_rdebug;	/* original r_debug structure */
160 	Elf32_Word	rtd_version;	/* version no. */
161 	Elf32_Word	rtd_objpad;	/* padding around mmap()ed objects */
162 	Elf32_Addr	rtd_dynlmlst;	/* pointer to dynlm_list */
163 } Rtld_db_priv32;
164 #endif	/* _SYSCALL32 */
165 
166 /*
167  * External function definitions.  ld.so.1 must convey information to libc in
168  * regards to threading.  libc also provides routines for atexit() and message
169  * localization.  libc provides the necessary interfaces via its RTLDINFO
170  * structure and/or later _ld_libc() calls.
171  *
172  * These external functions are maintained for each link-map list, and used
173  * where appropriate.  The functions are associated with the object that
174  * provided them, so that should the object be deleted (say, from an alternative
175  * link-map), the functions can be removed.
176  */
177 typedef struct {
178 	Rt_map	*lc_lmp;			/* function provider */
179 	union {
180 		int		(*lc_func)();	/* external function pointer */
181 		uintptr_t	lc_val;		/* external value */
182 		char    	*lc_ptr;	/* external character pointer */
183 	} lc_un;
184 } Lc_desc;
185 
186 /*
187  * Link map list definition.  Link-maps are used to describe each loaded object.
188  * Lists of these link-maps describe the various namespaces within a process.
189  * The process executable and its dependencies are maintained on the lml_main
190  * list.  The runtime linker, and its dependencies are maintained on the
191  * lml_rtld list.  Additional lists can be created (see dlmopen()) for such
192  * things as auditors and their dependencies.
193  *
194  * Each link-map list maintains an Alist of one, or more, linked lists of
195  * link-maps.  For backward compatibility, the lm_head/lm_tail elements are
196  * initialized to the first linked-list of link-maps:
197  *
198  *      Lm_list
199  *    ----------
200  *   | lm_tail  | ------------------------------------
201  *   | lm_head  | --------------------                |
202  *   |          |                     |     Rt_map    |     Rt_map
203  *   |          |                     |     ------    |     ------
204  *   |          |          Alist       --> |      |   |--> |      |
205  *   |          |        ---------    |    |      | --     |      |
206  *   | lm_lists | ----> |         |   |    |      |    --> |      |
207  *   |          |       |---------|   |    |      |   |    |      |
208  *   |          |       | lc_head | --      ------    |     ------
209  *   |          |       | lc_tail | ------------------
210  *   |          |       |---------|
211  *    ----------        | lc_head |
212  *                      | lc_tail |
213  *                      |---------|
214  *
215  * Multiple link-map lists exist to support the addition of lazy loaded
216  * families, filtee families, and dlopen() families.  The intent of these
217  * lists is to insure that a family of objects that are to be loaded are
218  * fully relocatable, and hence usable, before they become part of the main
219  * (al_data[0]) link-map control list.  This main link-map control list is
220  * the only list in existence when control is transferred to user code.
221  *
222  * During process initialization, the dynamic executable and its non-lazy
223  * dependencies are maintained on al_data[0].  If a new object is loaded, then
224  * this object is added to the next available control list [1], typically
225  * al_data[1].  Any dependencies of this object that have not already been
226  * loaded are added to the same control list.  Once all of the objects on the
227  * new control list have been successfully relocated, the objects are moved from
228  * the new control list to the highest control list to which objects of the new
229  * control list bound to, typically al_data[1] to al_data[0].
230  *
231  * Each loading scenario can be broken down as follows:
232  *
233  *  setup() - only the initial link-map control list is used:
234  *   i.	  create al_data[0]
235  *   ii.  add new link-map for main on al_data[0]
236  *   iii. analyze al_data[0] to add all non-lazy dependencies
237  *   iv.  relocate al_data[0] dependencies.
238  *
239  *  dlopen() - the initiator can only be the initial link-map control list:
240  *   i.   create al_data[1] from caller al_data[0]
241  *   ii.  add new link-map for the dlopen'ed object on al_data[1]
242  *   iii. analyze al_data[1] to add all non-lazy dependencies
243  *   iv.  relocate al_data[1] dependencies, and move to al_data[0].
244  *
245  *  filtee and lazy loading processing - the initiator can be any link-map
246  *  control list that is being relocated:
247  *   i.   create al_data[y] from caller al_data[x]
248  *   ii.  add new link-map for the new object on al_data[y]
249  *   iii. analyze al_data[y] to add all non-lazy dependencies
250  *   iv.  relocate al_data[y] dependencies, and move to al_data[x].
251  *
252  * This Alist therefore maintains a stack of link-map control lists.  The newest
253  * link-map control list can locate symbols within any of the former lists,
254  * however, control is not passed to a former list until the newest lists
255  * processing is complete.  Thus, objects can't bind to new objects until they
256  * have been fully analyzed and relocated.
257  *
258  * [1]  Note, additional link-map control list creation occurs after the head
259  * link-map object (typically the dynamic executable) has been relocated.  This
260  * staging is required to satisfy the binding requirements of copy relocations.
261  * Copy relocations, effectively, transfer the bindings of the copied data
262  * (say _iob in libc.so.1) to the copy location (_iob in the application).
263  * Thus an object that might bind to the original copy data must be redirected
264  * to the copy reference.  As the knowledge of a copy relocation having taken
265  * place is only known after relocating the application, link-map control list
266  * additions are suspended until after this relocation has completed.
267  */
268 typedef struct {
269 	Rt_map		*lc_head;
270 	Rt_map		*lc_tail;
271 	APlist		*lc_now;	/* pending promoted bind-now objects */
272 	uint_t		lc_flags;
273 } Lm_cntl;
274 
275 #define	LMC_FLG_ANALYZING	0x01	/* control list is being analyzed */
276 #define	LMC_FLG_RELOCATING	0x02	/* control list is being relocated */
277 #define	LMC_FLG_REANALYZE	0x04	/* repeat analysis (established when */
278 					/*	interposers are added */
279 
280 struct lm_list {
281 	/*
282 	 * BEGIN: Exposed to rtld_db - don't move, don't delete
283 	 */
284 	Rt_map		*lm_head;	/* linked list pointers to active */
285 	Rt_map		*lm_tail;	/*	link-map list */
286 	APlist		*lm_handle;	/* not used by rtld_db - but spacing */
287 					/*	is required for flags */
288 	Word		lm_flags;
289 	/*
290 	 * END: Exposed to rtld_db - don't move, don't delete
291 	 */
292 	Alist		*lm_rti;	/* list of RTLDINFO tables */
293 	Audit_list	*lm_alp;	/* audit list descriptor */
294 	avl_tree_t	*lm_fpavl;	/* avl tree of objects loaded */
295 	Alist		*lm_lists;	/* active and pending link-map lists */
296 	char		***lm_environ;	/* pointer to environment array */
297 	Word		lm_tflags;	/* transferable flags */
298 	uint_t		lm_obj;		/* total number of objs on link-map */
299 	uint_t		lm_init;	/* new obj since last init processing */
300 	uint_t		lm_lazy;	/* number of objects with pending */
301 					/*	lazy dependencies */
302 	uint_t		lm_tls;		/* new obj that require TLS */
303 	uint_t		lm_lmid;	/* unique link-map list identifier, */
304 	char		*lm_lmidstr;	/* and associated diagnostic string */
305 	APlist		*lm_actaudit;	/* list of pending audit activity */
306 	Lc_desc		lm_lcs[CI_MAX];	/* external libc functions */
307 };
308 
309 #ifdef	_SYSCALL32
310 struct lm_list32 {
311 	/*
312 	 * BEGIN: Exposed to rtld_db - don't move, don't delete
313 	 */
314 	Elf32_Addr	lm_head;
315 	Elf32_Addr	lm_tail;
316 	Elf32_Addr	lm_handle;
317 	Elf32_Word	lm_flags;
318 	/*
319 	 * END: Exposed to rtld_db - don't move, don't delete
320 	 */
321 	Elf32_Addr	lm_rti;
322 	Elf32_Addr	lm_fpavl;
323 	Elf32_Addr	lm_lists;
324 	Elf32_Addr	lm_environ;
325 	Elf32_Word	lm_tflags;
326 	uint_t		lm_obj;
327 	uint_t		lm_init;
328 	uint_t		lm_lazy;
329 	uint_t		lm_tls;
330 	uint_t		lm_lmid;
331 	Elf32_Addr	lm_lmidstr;
332 	Elf32_Addr	lm_actaudit;
333 	Elf32_Addr	lm_lcs[CI_MAX];
334 };
335 #endif /* _SYSCALL32 */
336 
337 /*
338  * Possible Link_map list flags (Lm_list.lm_flags)
339  */
340 /*
341  * BEGIN: Exposed to rtld_db - don't move, don't delete
342  */
343 #define	LML_FLG_BASELM		0x00000001	/* primary link-map */
344 #define	LML_FLG_RTLDLM		0x00000002	/* rtld link-map */
345 /*
346  * END: Exposed to rtld_db - don't move, don't delete
347  */
348 #define	LML_FLG_NOAUDIT		0x00000004	/* symbol auditing disabled */
349 #define	LML_FLG_PLTREL		0x00000008	/* deferred plt relocation */
350 						/* 	initialization */
351 						/*	(ld.so.1 only) */
352 #define	LML_FLG_HOLDLOCK	0x00000010	/* hold the rtld mutex lock */
353 #define	LML_FLG_ENVIRON		0x00000020	/* environ var initialized */
354 #define	LML_FLG_INTRPOSE	0x00000040	/* interposing objs on list */
355 #define	LML_FLG_LOCAUDIT	0x00000080	/* local auditors exists for */
356 						/*	this link-map list */
357 #define	LML_FLG_LOADAVAIL	0x00000100	/* load anything available */
358 #define	LML_FLG_IGNRELERR	0x00000200	/* ignore relocation errors - */
359 						/*	internal for crle(1) */
360 #define	LML_FLG_DBNOTIF		0x00000400	/* binding activity going on */
361 #define	LML_FLG_STARTREL	0x00000800	/* relocation started */
362 #define	LML_FLG_ATEXIT		0x00001000	/* atexit processing */
363 #define	LML_FLG_OBJADDED	0x00002000	/* object(s) added */
364 #define	LML_FLG_OBJDELETED	0x00004000	/* object(s) deleted */
365 #define	LML_FLG_OBJREEVAL	0x00008000	/* existing object(s) needs */
366 						/*	tsort reevaluation */
367 #define	LML_FLG_INTRPOSETSORT	0x00020000	/* interpose tsorting done */
368 #define	LML_FLG_AUDITNOTIFY	0x00040000	/* audit consistent required */
369 #define	LML_FLG_GROUPSEXIST	0x00080000	/* local groups exist */
370 
371 #define	LML_FLG_TRC_LDDSTUB	0x00100000	/* identify lddstub */
372 #define	LML_FLG_TRC_ENABLE	0x00200000	/* tracing enabled (ldd) */
373 #define	LML_FLG_TRC_WARN	0x00400000	/* print warnings for undefs */
374 #define	LML_FLG_TRC_VERBOSE	0x00800000	/* verbose (versioning) trace */
375 #define	LML_FLG_TRC_SEARCH	0x01000000	/* trace search paths */
376 #define	LML_FLG_TRC_UNREF	0x02000000	/* trace unreferenced */
377 						/*	dependencies */
378 #define	LML_FLG_TRC_UNUSED	0x04000000	/* trace unused dependencies */
379 #define	LML_FLG_TRC_INIT	0x08000000	/* print .init order */
380 #define	LML_FLG_TRC_NOUNRESWEAK	0x10000000	/* unresolved weak references */
381 						/*	are not allowed */
382 #define	LML_FLG_TRC_NOPAREXT	0x20000000	/* unresolved PARENT/EXTERN */
383 						/*	references are not */
384 						/*	allowed */
385 #define	LML_MSK_TRC		0xfff00000	/* tracing mask */
386 
387 /*
388  * Possible Link_map transferable flags (Lm_list.lm_tflags), i.e., link-map
389  * list flags that can be propagated to any new link-map list created.
390  */
391 #define	LML_TFLG_NOLAZYLD	0x00000001	/* lazy loading disabled */
392 #define	LML_TFLG_NODIRECT	0x00000002	/* direct bindings disabled */
393 
394 #define	LML_TFLG_LOADFLTR	0x00000008	/* trigger filtee loading */
395 
396 #define	LML_TFLG_AUD_PREINIT	0x00001000	/* preinit (audit) exists */
397 #define	LML_TFLG_AUD_OBJSEARCH	0x00002000	/* objsearch (audit) exists */
398 #define	LML_TFLG_AUD_OBJOPEN	0x00004000	/* objopen (audit) exists */
399 #define	LML_TFLG_AUD_OBJFILTER	0x00008000	/* objfilter (audit) exists */
400 #define	LML_TFLG_AUD_OBJCLOSE	0x00010000	/* objclose (audit) exists */
401 #define	LML_TFLG_AUD_SYMBIND	0x00020000	/* symbind (audit) exists */
402 #define	LML_TFLG_AUD_PLTENTER	0x00040000	/* pltenter (audit) exists */
403 #define	LML_TFLG_AUD_PLTEXIT	0x00080000	/* pltexit (audit) exists */
404 #define	LML_TFLG_AUD_ACTIVITY	0x00100000	/* activity (audit) exists */
405 
406 /*
407  * NOTE: Each auditing module establishes a set of audit flags, AFLAGS(), that
408  * define the auditing interfaces the module offers.  These auditing flags are
409  * the LML_TFLG_AUD_ flags defined above.  Global auditors result in setting
410  * the lm_tflags too.  Local auditors only use the AFLAGS().  All tests for
411  * auditing inspect the lm_tflags and AFLAGS() for a specific auditing
412  * interface, and thus use the same flag to test for both types of auditors.
413  */
414 #define	LML_TFLG_AUD_MASK	0x0ffff000	/* audit interfaces mask */
415 
416 /*
417  * Define a Group Handle.
418  *
419  * The capability of ld.so.1 to associate a group of objects, look for symbols
420  * within that group, ensure that groups are isolated from one another (with
421  * regard to relocations), and to unload a group, centers around a handle.
422  *
423  * Dependencies can be added to an existing handle as the dependencies are
424  * lazily loaded.  The core dependencies on the handle are the ldd(1) list of
425  * the referenced object.
426  *
427  * Handles can be created from:
428  *
429  *  -	a dlopen() request.  This associates a caller to a reference object,
430  * 	and the referenced objects dependencies.  This group of objects can
431  *	then be inspected for symbols (dlsym()).
432  *  -	a filtering request.  This associates a filter (caller) to a referenced
433  *	object (filtee).  The redirection of filter symbols to their filtee
434  *	counterpart is essentially a dlsym() using the filtee's handle.
435  *
436  * The handle created for these events is referred to as a public handle.  This
437  * handle tracks the referenced object, all of the dependencies of the
438  * referenced object, and the caller (parent).
439  *
440  * Presently, an object may have two handles, one requested with RTLD_FIRST
441  * and one without.
442  *
443  * A handle may be referenced by any number of callers (parents).  A reference
444  * count tracks the number.  A dlclose() operation drops the reference count,
445  * and when the count is zero, the handle is used to determine the family of
446  * objects to unload.  As bindings may occur to objects on the handle from
447  * other handles, it may not be possible to remove a complete family of objects
448  * or the handle itself.  Handles in this state are moved to an orphan list.
449  * A handle on the orphan list is taken off the orphan list if the associated
450  * object is reopened.  Otherwise, the handle remains on the orphan list for
451  * the duration of the process.  The orphan list is inspected any time objects
452  * are unloaded, to determine if the orphaned objects can also be unloaded.
453  *
454  * Handles can also be created for internal uses:
455  *
456  *  -	to promote objects to RTLD_NOW.
457  *  -	to establish families for symbol binding fallback, required when lazy
458  *	loadable objects are still pending.
459  *
460  * The handle created for these events is referred to as a private handle.  This
461  * handle does not need to track the caller (parent), and because of this, does
462  * not need to be considered during dlclose() operations, as the handle can not
463  * be referenced by callers outside of the referenced objects family.
464  *
465  * Note, a private handle is essentially a subset of a public handle.  Should
466  * an internal operation require a private handle, and a public handle already
467  * exist, the public handle can be used.  Should an external operation require
468  * a public handle, and a private handle exist, the private handle is promoted
469  * to a public handle.  Any handle that gets created will remain in existence
470  * for the life time of the referenced object.
471  *
472  * Objects can be dlopened using RTLD_NOW.  This attribute requires that all
473  * relocations of the object, and its dependencies are processed immediately,
474  * before return to the caller.  Typically, an object is loaded without
475  * RTLD_NOW, and procedure linkage relocations are satisfied when their
476  * associated function is first called.  If an object is already loaded, and an
477  * RTLD_NOW request is made, then the object, and its dependencies, most undergo
478  * additional relocation processing.   This promotion from lazy binding to
479  * immediate binding is carried out using handles, as the handle defines the
480  * dependencies that must be processed.
481  *
482  * To ensure that objects within a lazy loadable environment can be relocated,
483  * no matter whether the objects have their dependencies described completely,
484  * a symbol lookup fallback is employed.  Any pending lazy loadable objects are
485  * loaded, and a handle established to search the object and it's dependencies
486  * for the required symbol.
487  *
488  * A group handle (and its associated group descriptors), is referenced from
489  * a link-map's HANDLES and GROUPS lists.  Note, Aplist's are diagramed to
490  * fully expose the allocations required to establish the data structure
491  * relationships.
492  *
493  *                                  Grp_desc
494  *                                   Alist
495  *                                 -----------
496  *                            --> |           |
497  *                           |    |-----------|
498  *                           |    | gd_depend | ---------
499  *                           |    |           |          |
500  *                           |    |-----------|          |
501  *                   --------|--- | gd_depend |          |
502  *                  |        |    | (parent)  |          |
503  *                  |        |    |-----------|          |
504  *                  |        |    | gd_depend |          |
505  *                  |        |    |           |          |
506  *                  |        |    |           |          |
507  *                  |        |     -----------           |
508  *                  |        |                           |
509  *                  |        |      Grp_hdl              |
510  *                  |        |    -----------            |
511  *                  |         -- | gh_depends |          |
512  *                  |  --------- | gh_ownlmp  |          |
513  *                  | |          |            |          |
514  *                  | |          |            |          |
515  *                  | |          |            |          |
516  *      Rt_map      | |           ------------           |       Rt_map
517  *    ----------    | |               ^ ^                |     ----------
518  *   |          | <-  |               | |                 --> |          |
519  *   |          | <---   --------     | |                     |          |
520  *   | HANDLES  | ----> |        |    | |     --------        |          |
521  *   |          |       |        |    | |    |        | <---- |  GROUPS  |
522  *   |          |       |        | ---  |    |        |       |          |
523  *   |          |       |        |       --- |        |       |          |
524  *   |          |        --------            |        |       |          |
525  *    ----------          Aplist              --------         ----------
526  *                                             Aplist
527  */
528 typedef struct {
529 	Alist		*gh_depends;	/* handle dependency list */
530 	Rt_map		*gh_ownlmp;	/* handle owners link-map */
531 	Lm_list		*gh_ownlml;	/* handle owners link-map list */
532 	uint_t		gh_refcnt;	/* handle reference count */
533 	uint_t		gh_flags;	/* handle flags (GPH_ values) */
534 } Grp_hdl;
535 
536 /*
537  * Define the two categories of handle.
538  */
539 #define	GPH_PUBLIC	0x0001		/* handle returned to caller(s) */
540 #define	GPH_PRIVATE	0x0002		/* handle used internally */
541 
542 /*
543  * Define any flags that affects how the handle is used.
544  */
545 #define	GPH_ZERO	0x0010		/* special handle for dlopen(0) */
546 #define	GPH_LDSO	0x0020		/* special handle for ld.so.1 */
547 #define	GPH_FIRST	0x0040		/* dlsym() can only use originating */
548 					/*	dependency */
549 #define	GPH_FILTEE	0x0080		/* handle identifies a filtee, used */
550 					/*	for diagnostics only */
551 /*
552  * Define any state that is associated with the handle.
553  */
554 #define	GPH_INITIAL	0x0100		/* handle is initialized */
555 
556 /*
557  * Define a Group Descriptor.
558  *
559  * Each dependency associated with a group handle is maintained by a group
560  * descriptor.  The descriptor defines the associated dependency together with
561  * flags that indicate how the dependency can be used.
562  */
563 typedef struct {
564 	Rt_map		*gd_depend;	/* dependency */
565 	uint_t		gd_flags;	/* dependency flags (GPD_ values) */
566 } Grp_desc;
567 
568 #define	GPD_DLSYM	0x0001		/* dependency available to dlsym() */
569 #define	GPD_RELOC	0x0002		/* dependency available to satisfy */
570 					/*	relocation binding */
571 #define	GPD_ADDEPS	0x0004		/* dependencies of this dependency */
572 					/*	should be added to handle */
573 #define	GPD_PARENT	0x0008		/* dependency is a parent */
574 #define	GPD_FILTER	0x0010		/* dependency is our filter */
575 #define	GPD_REMOVE	0x0100		/* descriptor is a candidate for */
576 					/*	removal from the group */
577 
578 /*
579  * Define threading structures.  For compatibility with libthread (T1_VERSION 1
580  * and TI_VERSION 2) our locking structure is sufficient to hold a mutex or a
581  * readers/writers lock.
582  */
583 typedef struct {
584 	union {
585 		mutex_t		l_mutex;
586 		rwlock_t	l_rwlock;
587 	} u;
588 } Rt_lock;
589 
590 typedef	cond_t	Rt_cond;
591 
592 /*
593  * Define a dynamic section information descriptor.  This parallels the entries
594  * in the .dynamic section and holds auxiliary information to implement lazy
595  * loading and filtee processing.
596  */
597 typedef struct {
598 	uint_t	di_flags;
599 	void	*di_info;
600 } Dyninfo;
601 
602 #define	FLG_DI_STDFLTR	0x00001		/* .dynamic entry for DT_FILTER */
603 #define	FLG_DI_AUXFLTR	0x00002		/* .dynamic entry for DT_AUXILIARY */
604 #define	FLG_DI_SYMFLTR	0x00004		/* .dynamic entry for DT_SYMFILTER */
605 					/*	and DT_SYMAUXILIARY */
606 #define	MSK_DI_FILTER	0x0000f		/* mask for all filter possibilities */
607 
608 #define	FLG_DI_POSFLAG1	0x00010		/* .dynamic entry for DT_POSFLAG_1 */
609 #define	FLG_DI_NEEDED	0x00020		/* .dynamic entry for DT_NEEDED */
610 #define	FLG_DI_LAZY	0x00100		/* lazy needed entry - preceded by */
611 					/*    DF_P1_LAZYLOAD (DT_POSFLAG_1) */
612 #define	FLG_DI_GROUP	0x00200		/* group needed entry - preceded by */
613 					/*    DF_P1_GROUPPERM (DT_POSFLAG_1) */
614 
615 #define	FLG_DI_LDD_DONE	0x01000		/* entry has been processed (ldd) */
616 #define	FLG_DI_LAZYFAIL	0x02000		/* the lazy loading of this entry */
617 					/*    failed */
618 /*
619  * Data structure to track AVL tree of pathnames.  This structure provides the
620  * basis of both the "not-found" node tree, and the "full-path" node tree.  Both
621  * of these trees persist for the life of a process, although the "not-found"
622  * tree may be moved aside during a dlopen() or dlsym() fall back operation.
623  */
624 typedef struct {
625 	const char	*pn_name;	/* path name */
626 	avl_node_t	pn_avl;		/* avl book-keeping (see SGSOFFSETOF) */
627 	uint_t		pn_hash;	/* path name hash value */
628 } PathNode;
629 
630 /*
631  * Data structure to track AVL tree for full path names of objects that are
632  * loaded into memory.
633  */
634 typedef struct {
635 	PathNode	fpn_node;	/* path node */
636 	Rt_map		*fpn_lmp;	/* object link-map */
637 } FullPathNode;
638 
639 /*
640  * A given link-map can hold either a supplier or receiver copy
641  * relocation list, but not both. This union is used to overlap
642  * the space used for the two lists.
643  */
644 typedef union {
645 	Alist	*rtc_r;		/* receiver list (Rel_copy) */
646 	APlist	*rtc_s;		/* supplier list (Rt_map *) */
647 } Rt_map_copy;
648 
649 
650 /*
651  * Link-map definition.
652  */
653 struct rt_map {
654 	/*
655 	 * BEGIN: Exposed to rtld_db - don't move, don't delete
656 	 */
657 	Link_map	rt_public;	/* public data */
658 	const char	*rt_pathname;	/* full pathname of loaded object */
659 	ulong_t		rt_padstart;	/* start of image (including padding) */
660 	ulong_t		rt_padimlen;	/* size of image (including padding */
661 	ulong_t		rt_msize;	/* total memory reservation range */
662 	uint_t		rt_flags;	/* state flags, see FLG below */
663 	uint_t		rt_flags1;	/* state flags1, see FL1 below */
664 	ulong_t		rt_tlsmodid;	/* TLS module id */
665 	/*
666 	 * END: Exposed to rtld_db - don't move, don't delete
667 	 */
668 	APlist		*rt_alias;	/* list of linked file names */
669 	APlist		*rt_fpnode;	/* list of FullpathNode AVL nodes */
670 	char		*rt_runpath;	/* LD_RUN_PATH and its equivalent */
671 	Alist		*rt_runlist;	/*	Pdesc structures */
672 	APlist		*rt_depends;	/* list of dependencies */
673 	APlist		*rt_callers;	/* list of callers */
674 	APlist		*rt_handles;	/* dlopen handles */
675 	APlist		*rt_groups;	/* groups we're a member of */
676 	struct fct	*rt_fct;	/* file class table for this object */
677 	void		*rt_priv;	/* private data, object type specific */
678 	Lm_list		*rt_list;	/* link map list we belong to */
679 	uint_t		rt_objfltrndx;	/* object filtees .dynamic index */
680 	uint_t		rt_symsfltrcnt;	/* number of standard symbol filtees */
681 	uint_t		rt_symafltrcnt;	/* number of auxiliary symbol filtees */
682 	int		rt_mode;	/* usage mode, see RTLD mode flags */
683 	int		rt_sortval;	/* temporary buffer to traverse graph */
684 	uint_t		rt_cycgroup;	/* cyclic group */
685 	dev_t		rt_stdev;	/* device id and inode number for .so */
686 	rtld_ino_t	rt_stino;	/*	multiple inclusion checks */
687 	const char	*rt_origname;	/* original pathname of loaded object */
688 	size_t		rt_dirsz;	/*	and its size */
689 	size_t		rt_lmsize;	/* size of the link-map allocation */
690 	Rt_map_copy	rt_copy;	/* list of copy relocations */
691 	Audit_desc	*rt_auditors;	/* audit descriptor array */
692 	Audit_info	*rt_audinfo;	/* audit information descriptor */
693 	Syminfo		*rt_syminfo;	/* elf .syminfo section - here */
694 					/*	because it is checked in */
695 					/*	common code */
696 	Addr		*rt_initarray;	/* .initarray table */
697 	Addr		*rt_finiarray;	/* .finiarray table */
698 	Addr		*rt_preinitarray; /* .preinitarray table */
699 	mmapobj_result_t *rt_mmaps;	/* array of mapping information */
700 	uint_t		rt_mmapcnt;	/*	and associated number */
701 	uint_t		rt_initarraysz;	/* size of .initarray table */
702 	uint_t		rt_finiarraysz;	/* size of .finiarray table */
703 	uint_t		rt_preinitarraysz; /* size of .preinitarray table */
704 	Dyninfo		*rt_dyninfo;	/* .dynamic information descriptors */
705 	uint_t		rt_dyninfocnt;	/* count of dyninfo entries */
706 	uint_t		rt_relacount;	/* no. of RELATIVE relocations */
707 	uint_t		rt_idx;		/* hold index within linkmap list */
708 	uint_t		rt_lazy;	/* number of lazy dependencies */
709 					/*	pending */
710 	Xword		rt_hwcap;	/* hardware capabilities */
711 	Xword		rt_sfcap;	/* software capabilities */
712 	uint_t		rt_cntl;	/* link-map control list we belong to */
713 	uint_t		rt_aflags;	/* auditor flags, see LML_TFLG_AUD_ */
714 					/* address of _init */
715 	void		(*rt_init)(void);
716 					/* address of _fini */
717 	void		(*rt_fini)(void);
718 					/* link map symbol interpreter */
719 	Sym		*(*rt_symintp)(Slookup *, Rt_map **, uint_t *, int *);
720 };
721 
722 #ifdef _SYSCALL32
723 /*
724  * Structure to allow 64-bit rtld_db to read 32-bit processes out of procfs.
725  */
726 typedef union {
727 	uint32_t	rtc_r;
728 	uint32_t	rtc_s;
729 } Rt_map_copy32;
730 
731 typedef struct rt_map32 {
732 	/*
733 	 * BEGIN: Exposed to rtld_db - don't move, don't delete
734 	 */
735 	Link_map32	rt_public;
736 	uint32_t	rt_pathname;
737 	uint32_t	rt_padstart;
738 	uint32_t	rt_padimlen;
739 	uint32_t	rt_msize;
740 	uint32_t	rt_flags;
741 	uint32_t	rt_flags1;
742 	uint32_t	rt_tlsmodid;
743 	/*
744 	 * END: Exposed to rtld_db - don't move, don't delete
745 	 */
746 	uint32_t	rt_alias;
747 	uint32_t	rt_fpnode;
748 	uint32_t	rt_runpath;
749 	uint32_t	rt_runlist;
750 	uint32_t	rt_depends;
751 	uint32_t	rt_callers;
752 	uint32_t	rt_handles;
753 	uint32_t	rt_groups;
754 	uint32_t	rt_fct;
755 	uint32_t	rt_priv;
756 	uint32_t 	rt_list;
757 	uint32_t 	rt_objfltrndx;
758 	uint32_t 	rt_symsfltrcnt;
759 	uint32_t 	rt_symafltrcnt;
760 	int32_t		rt_mode;
761 	int32_t		rt_sortval;
762 	uint32_t	rt_cycgroup;
763 	uint32_t	rt_stdev;
764 	uint32_t	rt_stino;
765 	uint32_t	rt_origname;
766 	uint32_t	rt_dirsz;
767 	Rt_map_copy32	rt_copy;
768 	uint32_t 	rt_auditors;
769 	uint32_t 	rt_audinfo;
770 	uint32_t	rt_syminfo;
771 	uint32_t	rt_initarray;
772 	uint32_t	rt_finiarray;
773 	uint32_t	rt_preinitarray;
774 	uint32_t	rt_mmaps;
775 	uint32_t	rt_mmapcnt;
776 	uint32_t	rt_initarraysz;
777 	uint32_t	rt_finiarraysz;
778 	uint32_t	rt_preinitarraysz;
779 	uint32_t 	rt_dyninfo;
780 	uint32_t 	rt_dyninfocnt;
781 	uint32_t	rt_relacount;
782 	uint32_t	rt_idx;
783 	uint32_t	rt_lazy;
784 	uint32_t	rt_hwcap;
785 	uint32_t	rt_sfcap;
786 	uint32_t	rt_cntl;
787 	uint32_t	rt_aflags;
788 	uint32_t 	rt_init;
789 	uint32_t	rt_fini;
790 	uint32_t	rt_symintp;
791 } Rt_map32;
792 
793 #endif	/* _SYSCALL32 */
794 
795 /*
796  * Link map state flags.
797  */
798 /*
799  * BEGIN: Exposed to rtld_db - don't move, don't delete
800  */
801 #define	FLG_RT_ISMAIN	0x00000001	/* object represents main executable */
802 #define	FLG_RT_IMGALLOC	0x00000002	/* image is allocated (not mmap'ed) */
803 	/*
804 	 * Available for r_debug version >= R_RTLDDB_VERSION5
805 	 */
806 #define	FLG_RT_RELOCED	0x00000004	/* object has been relocated */
807 /*
808  * END: Exposed to rtld_db - don't move, don't delete
809  */
810 #define	FLG_RT_SETGROUP	0x00000008	/* group establishment required */
811 #define	FLG_RT_HWCAP	0x00000010	/* process $HWCAP expansion */
812 #define	FLG_RT_OBJECT	0x00000020	/* object processing (ie. .o's) */
813 #define	FLG_RT_NEWLOAD	0x00000040	/* object is newly loaded */
814 #define	FLG_RT_NODUMP	0x00000080	/* object can't be dldump(3x)'ed */
815 #define	FLG_RT_DELETE	0x00000100	/* object can be deleted */
816 #define	FLG_RT_ANALYZED	0x00000200	/* object has been analyzed */
817 #define	FLG_RT_INITDONE	0x00000400	/* objects .init has been completed */
818 #define	FLG_RT_TRANS	0x00000800	/* object is acting as a translator */
819 #define	FLG_RT_FIXED	0x00001000	/* image location is fixed */
820 #define	FLG_RT_PRELOAD	0x00002000	/* object was preloaded */
821 #define	FLG_RT_ALTER	0x00004000	/* alternative object used */
822 #define	FLG_RT_LOADFLTR	0x00008000	/* trigger filtee loading */
823 #define	FLG_RT_AUDIT	0x00010000	/* object is an auditor */
824 #define	FLG_RT_MODESET	0x00020000	/* MODE() has been initialized */
825 #define	FLG_RT_ANALZING	0x00040000	/* object is being analyzed */
826 #define	FLG_RT_INITFRST 0x00080000	/* execute .init first */
827 #define	FLG_RT_NOOPEN	0x00100000	/* dlopen() not allowed */
828 #define	FLG_RT_FINICLCT	0x00200000	/* fini has been collected (tsort) */
829 #define	FLG_RT_INITCALL	0x00400000	/* objects .init has been called */
830 #define	FLG_RT_OBJINTPO	0x00800000	/* object is a global interposer */
831 #define	FLG_RT_SYMINTPO	0x01000000	/* object contains symbol interposer */
832 #define	MSK_RT_INTPOSE	0x01800000	/* mask for all interposer */
833 					/*	possibilities */
834 #define	FLG_RT_MOVE	0x02000000	/* object needs move operation */
835 #define	FLG_RT_RELOCING	0x04000000	/* object is being relocated */
836 #define	FLG_RT_REGSYMS	0x08000000	/* object has DT_REGISTER entries */
837 #define	FLG_RT_INITCLCT	0x10000000	/* init has been collected (tsort) */
838 #define	FLG_RT_PUBHDL	0x20000000	/* generate a handle for this object */
839 #define	FLG_RT_PRIHDL	0x40000000	/*	either public or private */
840 
841 #define	FL1_RT_COPYTOOK	0x00000001	/* copy relocation taken */
842 
843 #define	FL1_RT_CONFSET	0x00000004	/* object was loaded by crle(1) */
844 #define	FL1_RT_NODEFLIB	0x00000008	/* ignore default library search */
845 #define	FL1_RT_ENDFILTE	0x00000010	/* filtee terminates filters search */
846 #define	FL1_RT_DISPREL	0x00000020	/* object has *disp* relocation */
847 #define	FL1_RT_DTFLAGS	0x00000040	/* DT_FLAGS element exists */
848 
849 #define	FL1_RT_LDDSTUB	0x00000100	/* identify lddstub */
850 #define	FL1_RT_NOINIFIN	0x00000200	/* no .init or .fini exists */
851 #define	FL1_RT_USED	0x00000400	/* symbol referenced from this object */
852 #define	FL1_RT_SYMBOLIC	0x00000800	/* DF_SYMBOLIC was set - use */
853 					/*	symbolic sym resolution */
854 #define	FL1_RT_OBJSFLTR	0x00001000	/* object is acting as a standard */
855 #define	FL1_RT_OBJAFLTR	0x00002000	/*	or auxiliary filter */
856 #define	FL1_RT_SYMSFLTR	0x00004000	/* symbol is acting as a standard */
857 #define	FL1_RT_SYMAFLTR	0x00008000	/*	or auxiliary filter */
858 #define	MSK_RT_FILTER	0x0000f000	/* mask for all filter possibilities */
859 
860 #define	FL1_RT_TLSADD	0x00010000	/* objects TLS has been registered */
861 #define	FL1_RT_TLSSTAT	0x00020000	/* object requires static TLS */
862 #define	FL1_RT_DIRECT	0x00040000	/* object has DIRECT bindings enabled */
863 #define	FL1_RT_GLOBAUD	0x00080000	/* establish global auditing */
864 
865 /*
866  * Flags for the tls_modactivity() routine
867  */
868 #define	TM_FLG_MODADD	0x01		/* call tls_modadd() interface */
869 #define	TM_FLG_MODREM	0x02		/* call tls_modrem() interface */
870 
871 /*
872  * Macros for getting to exposed, link_map data (R_RTLDDB_VERSION <= 2).
873  */
874 #define	ADDR(X)		((X)->rt_public.l_addr)
875 #define	NAME(X)		((X)->rt_public.l_name)
876 #define	DYN(X)		((X)->rt_public.l_ld)
877 #define	NEXT(X)		((X)->rt_public.l_next)
878 #define	PREV(X)		((X)->rt_public.l_prev)
879 #define	REFNAME(X)	((X)->rt_public.l_refname)
880 
881 /*
882  * An Rt_map starts with a Link_map, followed by other information.
883  * ld.so.1 allocates Rt_map structures, and then casts them to Link_map,
884  * and back, depending on context.
885  *
886  * On some platforms, Rt_map can have a higher alignment requirement
887  * than Link_map. On such platforms, the cast from Link_map to Rt_map will
888  * draw an E_BAD_PTR_CAST_ALIGN warning from lint. Since we allocate
889  * the memory as the higher alignment Rt_map, we know that this is a safe
890  * conversion. The LINKMAP_TO_RTMAP macro is used to handle the conversion
891  * in a manner that satisfies lint.
892  */
893 #ifdef lint
894 #define	LINKMAP_TO_RTMAP(X)	(Rt_map *)(void *)(X)
895 #else
896 #define	LINKMAP_TO_RTMAP(X)	(Rt_map *)(X)
897 #endif
898 
899 /*
900  * Convenience macros for the common case of using
901  * NEXT()/PREV() and casting the result to (Rt_map *)
902  */
903 #define	NEXT_RT_MAP(X)	LINKMAP_TO_RTMAP(NEXT(X))
904 #define	PREV_RT_MAP(X)	LINKMAP_TO_RTMAP(PREV(X))
905 
906 /*
907  * Macros for getting to exposed, link_map data (R_RTLDDB_VERSION3).
908  */
909 #define	PATHNAME(X)	((X)->rt_pathname)
910 #define	PADSTART(X)	((X)->rt_padstart)
911 #define	PADIMLEN(X)	((X)->rt_padimlen)
912 #define	MSIZE(X)	((X)->rt_msize)
913 #define	FLAGS(X)	((X)->rt_flags)
914 #define	FLAGS1(X)	((X)->rt_flags1)
915 
916 /*
917  * Macros for getting to exposed, link_map data (R_RTLDDB_VERSION4).
918  */
919 #define	TLSMODID(X)	((X)->rt_tlsmodid)
920 
921 /*
922  * Macros for getting to unexposed, link-map data.
923  */
924 #define	LMSIZE(X)	((X)->rt_lmsize)
925 #define	AFLAGS(X)	((X)->rt_aflags)
926 #define	ALIAS(X)	((X)->rt_alias)
927 #define	FPNODE(X)	((X)->rt_fpnode)
928 #define	INIT(X)		((X)->rt_init)
929 #define	FINI(X)		((X)->rt_fini)
930 #define	RPATH(X)	((X)->rt_runpath)
931 #define	RLIST(X)	((X)->rt_runlist)
932 #define	DEPENDS(X)	((X)->rt_depends)
933 #define	CALLERS(X)	((X)->rt_callers)
934 #define	HANDLES(X)	((X)->rt_handles)
935 #define	GROUPS(X)	((X)->rt_groups)
936 #define	FCT(X)		((X)->rt_fct)
937 #define	SYMINTP(X)	((X)->rt_symintp)
938 #define	LIST(X)		((X)->rt_list)
939 #define	OBJFLTRNDX(X)	((X)->rt_objfltrndx)
940 #define	SYMSFLTRCNT(X)	((X)->rt_symsfltrcnt)
941 #define	SYMAFLTRCNT(X)	((X)->rt_symafltrcnt)
942 #define	MODE(X)		((X)->rt_mode)
943 #define	SORTVAL(X)	((X)->rt_sortval)
944 #define	CYCGROUP(X)	((X)->rt_cycgroup)
945 #define	STDEV(X)	((X)->rt_stdev)
946 #define	STINO(X)	((X)->rt_stino)
947 #define	ORIGNAME(X)	((X)->rt_origname)
948 #define	DIRSZ(X)	((X)->rt_dirsz)
949 #define	COPY_R(X)	((X)->rt_copy.rtc_r)
950 #define	COPY_S(X)	((X)->rt_copy.rtc_s)
951 #define	AUDITORS(X)	((X)->rt_auditors)
952 #define	AUDINFO(X)	((X)->rt_audinfo)
953 #define	SYMINFO(X)	((X)->rt_syminfo)
954 #define	INITARRAY(X)	((X)->rt_initarray)
955 #define	FINIARRAY(X)	((X)->rt_finiarray)
956 #define	PREINITARRAY(X)	((X)->rt_preinitarray)
957 #define	MMAPS(X)	((X)->rt_mmaps)
958 #define	MMAPCNT(X)	((X)->rt_mmapcnt)
959 #define	INITARRAYSZ(X)	((X)->rt_initarraysz)
960 #define	FINIARRAYSZ(X)	((X)->rt_finiarraysz)
961 #define	PREINITARRAYSZ(X) ((X)->rt_preinitarraysz)
962 #define	DYNINFO(X)	((X)->rt_dyninfo)
963 #define	DYNINFOCNT(X)	((X)->rt_dyninfocnt)
964 #define	RELACOUNT(X)	((X)->rt_relacount)
965 #define	IDX(X)		((X)->rt_idx)
966 #define	LAZY(X)		((X)->rt_lazy)
967 #define	CNTL(X)		((X)->rt_cntl)
968 #define	HWCAP(X)	((X)->rt_hwcap)
969 #define	SFCAP(X)	((X)->rt_sfcap)
970 
971 /*
972  * Flags for tsorting.
973  */
974 #define	RT_SORT_FWD	0x01		/* topological sort (.fini) */
975 #define	RT_SORT_REV	0x02		/* reverse topological sort (.init) */
976 #define	RT_SORT_DELETE	0x10		/* process FLG_RT_DELETE objects */
977 					/*	only (called via dlclose()) */
978 #define	RT_SORT_INTPOSE	0x20		/* process interposer objects */
979 
980 /*
981  * Flags for lookup_sym (and hence find_sym) routines.
982  */
983 #define	LKUP_DEFT	0x0000		/* simple lookup request */
984 #define	LKUP_SPEC	0x0001		/* special ELF lookup (allows address */
985 					/*	resolutions to plt[] entries) */
986 #define	LKUP_LDOT	0x0002		/* indicates the original A_OUT */
987 					/*	symbol had a leading `.' */
988 #define	LKUP_FIRST	0x0004		/* lookup symbol in first link map */
989 					/*	only */
990 #define	LKUP_COPY	0x0008		/* lookup symbol for a COPY reloc, do */
991 					/*	not bind to symbol at head */
992 #define	LKUP_STDRELOC	0x0010		/* lookup originates from a standard */
993 					/*	relocation (elf_reloc()) */
994 #define	LKUP_SELF	0x0020		/* lookup symbol in ourself - undef */
995 					/*	is valid */
996 #define	LKUP_WEAK	0x0040		/* relocation reference is weak */
997 #define	LKUP_NEXT	0x0080		/* request originates from RTLD_NEXT */
998 #define	LKUP_NODESCENT	0x0100		/* don't descend through dependencies */
999 #define	LKUP_NOFALLBACK	0x0200		/* don't fall back to loading */
1000 					/*	pending lazy dependencies */
1001 #define	LKUP_DIRECT	0x0400		/* direct binding request */
1002 #define	LKUP_SYMNDX	0x0800		/* establish symbol index */
1003 #define	LKUP_SINGLETON	0x1000		/* search for a singleton symbol */
1004 #define	LKUP_STANDARD	0x2000		/* standard lookup - originated from */
1005 					/* 	head link-map element */
1006 #define	LKUP_WORLD	0x4000		/* ensure world lookup */
1007 
1008 /*
1009  * For the runtime linker to perform a symbol search, a number of data items
1010  * related to the search are required.  An Slookup data structure is used to
1011  * convey this data to lookup_sym(), and in special cases, to other core
1012  * routines that provide the implementation details for lookup_sym()
1013  *
1014  * The symbol name (sl_name), the caller (sl_cmap), and the link-map from which
1015  * to start the search (sl_imap) are fundamental to the symbol search.  The
1016  * initial search link-map might get modified by the core routines that provide
1017  * the implementation details for lookup_sym().  This modification accommodates
1018  * requirements such as processing a handle, direct binding and interposition.
1019  * The association between the caller and the potential destination also
1020  * determines whether the destination is a candidate to search.
1021  *
1022  * The lookup identifier (sl_id) is used to identify a runtime linker operation.
1023  * Within this operation, any lazy loads that fail are not re-examined.  This
1024  * technique keeps the overhead of processing a failed lazy load to a minimum.
1025  *
1026  * Symbol searches that originate from a relocation record are accompanied by
1027  * the relocation index (sl_rsymndx), the symbol reference (sl_rsym) and
1028  * possibly the relocation type (sl_rtype).  This data provides for determining
1029  * lazy loading, direct binding, and special symbol processing requirements
1030  * such as copy relocations and singleton lookup.
1031  *
1032  * The symbols hash value is computed by lookup_sym, and propagated throughout
1033  * the search engine.  Note, occasionally the Slookup data is passed to a core
1034  * routine that provides the implementation details for lookup_sym(), ie.
1035  * elf_find_sym(), in which case the caller must initialize the hash value.
1036  *
1037  * The symbols binding information is established by lookup_sym() when the
1038  * symbols relocation type is supplied.  Weak bindings allow relocations to
1039  * be set to zero should a symbol lookup fail.
1040  *
1041  * The flags allow the caller to control aspects of the search, including the
1042  * interpretation of copy relocations, etc.  Note, a number of flag settings
1043  * are established in lookup_sym() from attributes of the symbol reference.
1044  */
1045 struct slookup {
1046 	const char	*sl_name;	/* symbol name */
1047 	Rt_map		*sl_cmap;	/* callers link-map */
1048 	Rt_map		*sl_imap;	/* initial link-map to search */
1049 	ulong_t		sl_id;		/* identifier for this lookup */
1050 	ulong_t		sl_hash;	/* symbol hash value */
1051 	ulong_t		sl_rsymndx;	/* referencing reloc symndx */
1052 	Sym		*sl_rsym;	/* referencing symbol */
1053 	uchar_t		sl_rtype;	/* relocation type associate with */
1054 					/*    symbol */
1055 	uchar_t		sl_bind;	/* symbols binding (returned) */
1056 	uint_t		sl_flags;	/* lookup flags */
1057 };
1058 
1059 #define	SLOOKUP_INIT(sl, name, cmap, imap, id, hash, rsymndx, rsym, rtype, \
1060     flags) \
1061 	(void) (sl.sl_name = (name), sl.sl_cmap = (cmap), sl.sl_imap = (imap), \
1062 	    sl.sl_id = (id), sl.sl_hash = (hash), sl.sl_rsymndx = (rsymndx), \
1063 	    sl.sl_rsym = (rsym), sl.sl_rtype = (rtype), sl.sl_bind = 0, \
1064 	    sl.sl_flags = (flags))
1065 
1066 /*
1067  * Define a number of .plt lookup outcomes, for use in binding diagnostics.
1068  */
1069 typedef	enum {
1070 	PLT_T_NONE = 0,
1071 	PLT_T_21D,
1072 	PLT_T_24D,
1073 	PLT_T_U32,
1074 	PLT_T_U44,
1075 	PLT_T_FULL,
1076 	PLT_T_FAR,
1077 	PLT_T_NUM			/* Must be last */
1078 } Pltbindtype;
1079 
1080 /*
1081  * Prototypes.
1082  */
1083 extern ulong_t		ld_entry_cnt;	/* counter bumped on each entry to */
1084 					/*    ld.so.1. */
1085 extern Lm_list		lml_main;	/* main's link map list */
1086 extern Lm_list		lml_rtld;	/* rtld's link map list */
1087 extern Lm_list		*lml_list[];
1088 
1089 extern Pltbindtype	elf_plt_write(uintptr_t, uintptr_t, void *, uintptr_t,
1090 			    Xword);
1091 extern Rt_map		*is_so_loaded(Lm_list *, const char *, int *);
1092 extern Sym		*lookup_sym(Slookup *, Rt_map **, uint_t *, int *);
1093 extern int		rt_dldump(Rt_map *, const char *, int, Addr);
1094 
1095 #ifdef	__cplusplus
1096 }
1097 #endif
1098 
1099 #endif /* _RTLD_H */
1100