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