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