xref: /titanic_51/usr/src/cmd/sgs/rtld/common/dlfcns.c (revision 37714ae43602c675f9dc59b070bfdf9fa702872c)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 /*
28  *	Copyright (c) 1988 AT&T
29  *	  All Rights Reserved
30  */
31 
32 /*
33  * Programmatic interface to the run_time linker.
34  */
35 
36 #include	<sys/debug.h>
37 #include	<stdio.h>
38 #include	<string.h>
39 #include	<dlfcn.h>
40 #include	<synch.h>
41 #include	<limits.h>
42 #include	<debug.h>
43 #include	"_rtld.h"
44 #include	"_audit.h"
45 #include	"_elf.h"
46 #include	"_inline.h"
47 #include	"msg.h"
48 
49 /*
50  * Determine who called us - given a pc determine in which object it resides.
51  *
52  * For dlopen() the link map of the caller must be passed to load_so() so that
53  * the appropriate search rules (4.x or 5.0) are used to locate any
54  * dependencies.  Also, if we've been called from a 4.x module it may be
55  * necessary to fix the specified pathname so that it conforms with the 5.0 elf
56  * rules.
57  *
58  * For dlsym() the link map of the caller is used to determine RTLD_NEXT
59  * requests, together with requests based off of a dlopen(0).
60  * For dladdr() this routines provides a generic means of scanning all loaded
61  * segments.
62  */
63 Rt_map *
64 _caller(caddr_t cpc, int flags)
65 {
66 	Lm_list	*lml;
67 	Aliste	idx1;
68 
69 	for (APLIST_TRAVERSE(dynlm_list, idx1, lml)) {
70 		Aliste	idx2;
71 		Lm_cntl	*lmc;
72 
73 		for (ALIST_TRAVERSE(lml->lm_lists, idx2, lmc)) {
74 			Rt_map	*lmp;
75 
76 			for (lmp = lmc->lc_head; lmp;
77 			    lmp = NEXT_RT_MAP(lmp)) {
78 
79 				if (find_segment(cpc, lmp))
80 					return (lmp);
81 			}
82 		}
83 	}
84 
85 	/*
86 	 * No mapping can be determined.  If asked for a default, assume this
87 	 * is from the executable.
88 	 */
89 	if (flags & CL_EXECDEF)
90 		return ((Rt_map *)lml_main.lm_head);
91 
92 	return (0);
93 }
94 
95 #pragma weak _dlerror = dlerror
96 
97 /*
98  * External entry for dlerror(3dl).  Returns a pointer to the string describing
99  * the last occurring error.  The last occurring error is cleared.
100  */
101 char *
102 dlerror()
103 {
104 	char	*error;
105 	Rt_map	*clmp;
106 	int	entry;
107 
108 	entry = enter(0);
109 
110 	clmp = _caller(caller(), CL_EXECDEF);
111 
112 	error = lasterr;
113 	lasterr = NULL;
114 
115 	if (entry)
116 		leave(LIST(clmp), 0);
117 	return (error);
118 }
119 
120 /*
121  * Add a dependency as a group descriptor to a group handle.  Returns 0 on
122  * failure.  On success, returns the group descriptor, and if alep is non-NULL
123  * the *alep is set to ALE_EXISTS if the dependency already exists, or to
124  * ALE_CREATE if the dependency is newly created.
125  */
126 Grp_desc *
127 hdl_add(Grp_hdl *ghp, Rt_map *lmp, uint_t dflags, int *alep)
128 {
129 	Grp_desc	*gdp;
130 	Aliste		idx;
131 	int		ale = ALE_CREATE;
132 	uint_t		oflags;
133 
134 	/*
135 	 * Make sure this dependency hasn't already been recorded.
136 	 */
137 	for (ALIST_TRAVERSE(ghp->gh_depends, idx, gdp)) {
138 		if (gdp->gd_depend == lmp) {
139 			ale = ALE_EXISTS;
140 			break;
141 		}
142 	}
143 
144 	if (ale == ALE_CREATE) {
145 		Grp_desc	gd;
146 
147 		/*
148 		 * Create a new handle descriptor.
149 		 */
150 		gd.gd_depend = lmp;
151 		gd.gd_flags = 0;
152 
153 		/*
154 		 * Indicate this object is a part of this handles group.
155 		 */
156 		if (aplist_append(&GROUPS(lmp), ghp, AL_CNT_GROUPS) == NULL)
157 			return (NULL);
158 
159 		/*
160 		 * Append the new dependency to this handle.
161 		 */
162 		if ((gdp = alist_append(&ghp->gh_depends, &gd,
163 		    sizeof (Grp_desc), AL_CNT_DEPENDS)) == NULL)
164 			return (NULL);
165 	}
166 
167 	oflags = gdp->gd_flags;
168 	gdp->gd_flags |= dflags;
169 
170 	if (DBG_ENABLED) {
171 		if (ale == ALE_CREATE)
172 			DBG_CALL(Dbg_file_hdl_action(ghp, lmp, DBG_DEP_ADD,
173 			    gdp->gd_flags));
174 		else if (gdp->gd_flags != oflags)
175 			DBG_CALL(Dbg_file_hdl_action(ghp, lmp, DBG_DEP_UPDATE,
176 			    gdp->gd_flags));
177 	}
178 
179 	if (alep)
180 		*alep = ale;
181 	return (gdp);
182 }
183 
184 /*
185  * Create a handle.
186  *
187  *   rlmp -	represents the reference link-map for which the handle is being
188  *		created.
189  *   clmp -	represents the caller who is requesting the handle.
190  *   hflags -	provide group handle flags (GPH_*) that affect the use of the
191  *		handle, such as dlopen(0), or use or use of RTLD_FIRST.
192  *   rdflags -	provide group dependency flags for the reference link-map rlmp,
193  *		such as whether the dependency can be used for dlsym(), can be
194  *		relocated against, or whether this objects dependencies should
195  *		be processed.
196  *   cdflags -	provide group dependency flags for the caller.
197  */
198 Grp_hdl *
199 hdl_create(Lm_list *lml, Rt_map *rlmp, Rt_map *clmp, uint_t hflags,
200     uint_t rdflags, uint_t cdflags)
201 {
202 	Grp_hdl	*ghp = NULL, *aghp;
203 	APlist	**alpp;
204 	Aliste	idx;
205 
206 	/*
207 	 * For dlopen(0) the handle is maintained as part of the link-map list,
208 	 * otherwise the handle is associated with the reference link-map.
209 	 */
210 	if (hflags & GPH_ZERO)
211 		alpp = &(lml->lm_handle);
212 	else
213 		alpp = &(HANDLES(rlmp));
214 
215 	/*
216 	 * Objects can contain multiple handles depending on the handle flags
217 	 * supplied.  Most RTLD flags pertain to the object itself and the
218 	 * bindings that it can achieve.  Multiple handles for these flags
219 	 * don't make sense.  But if the flag determines how the handle might
220 	 * be used, then multiple handles may exist.  Presently this only makes
221 	 * sense for RTLD_FIRST.  Determine if an appropriate handle already
222 	 * exists.
223 	 */
224 	for (APLIST_TRAVERSE(*alpp, idx, aghp)) {
225 		if ((aghp->gh_flags & GPH_FIRST) == (hflags & GPH_FIRST)) {
226 			ghp = aghp;
227 			break;
228 		}
229 	}
230 
231 	if (ghp == NULL) {
232 		uint_t	ndx;
233 
234 		/*
235 		 * If this is the first request for this handle, allocate and
236 		 * initialize a new handle.
237 		 */
238 		DBG_CALL(Dbg_file_hdl_title(DBG_HDL_CREATE));
239 
240 		if ((ghp = malloc(sizeof (Grp_hdl))) == NULL)
241 			return (NULL);
242 
243 		/*
244 		 * Associate the handle with the link-map list or the reference
245 		 * link-map as appropriate.
246 		 */
247 		if (aplist_append(alpp, ghp, AL_CNT_GROUPS) == NULL) {
248 			free(ghp);
249 			return (NULL);
250 		}
251 
252 		/*
253 		 * Record the existence of this handle for future verification.
254 		 */
255 		/* LINTED */
256 		ndx = (uintptr_t)ghp % HDLIST_SZ;
257 
258 		if (aplist_append(&hdl_alp[ndx], ghp, AL_CNT_HANDLES) == NULL) {
259 			(void) aplist_delete_value(*alpp, ghp);
260 			free(ghp);
261 			return (NULL);
262 		}
263 
264 		ghp->gh_depends = NULL;
265 		ghp->gh_refcnt = 1;
266 		ghp->gh_flags = hflags;
267 
268 		/*
269 		 * A dlopen(0) handle is identified by the GPH_ZERO flag, the
270 		 * head of the link-map list is defined as the owner.  There is
271 		 * no need to maintain a list of dependencies, for when this
272 		 * handle is used (for dlsym()) a dynamic search through the
273 		 * entire link-map list provides for searching all objects with
274 		 * GLOBAL visibility.
275 		 */
276 		if (hflags & GPH_ZERO) {
277 			ghp->gh_ownlmp = lml->lm_head;
278 			ghp->gh_ownlml = lml;
279 		} else {
280 			ghp->gh_ownlmp = rlmp;
281 			ghp->gh_ownlml = LIST(rlmp);
282 
283 			if (hdl_add(ghp, rlmp, rdflags, NULL) == NULL)
284 				return (NULL);
285 
286 			/*
287 			 * If this new handle is a private handle, there's no
288 			 * need to track the caller, so we're done.
289 			 */
290 			if (hflags & GPH_PRIVATE)
291 				return (ghp);
292 
293 			/*
294 			 * If this new handle is public, and isn't a special
295 			 * handle representing ld.so.1, indicate that a local
296 			 * group now exists.  This state allows singleton
297 			 * searches to be optimized.
298 			 */
299 			if ((hflags & GPH_LDSO) == 0)
300 				LIST(rlmp)->lm_flags |= LML_FLG_GROUPSEXIST;
301 		}
302 	} else {
303 		/*
304 		 * If a handle already exists, bump its reference count.
305 		 *
306 		 * If the previous reference count was 0, then this is a handle
307 		 * that an earlier call to dlclose() was unable to remove.  Such
308 		 * handles are put on the orphan list.  As this handle is back
309 		 * in use, it must be removed from the orphan list.
310 		 *
311 		 * Note, handles associated with a link-map list itself (i.e.
312 		 * dlopen(0)) can have a reference count of 0.  However, these
313 		 * handles are never deleted, and therefore are never moved to
314 		 * the orphan list.
315 		 */
316 		if ((ghp->gh_refcnt++ == 0) &&
317 		    ((ghp->gh_flags & GPH_ZERO) == 0)) {
318 			uint_t	ndx;
319 
320 			/* LINTED */
321 			ndx = (uintptr_t)ghp % HDLIST_SZ;
322 
323 			(void) aplist_delete_value(hdl_alp[HDLIST_ORP], ghp);
324 			(void) aplist_append(&hdl_alp[ndx], ghp,
325 			    AL_CNT_HANDLES);
326 
327 			if (DBG_ENABLED) {
328 				Aliste		idx;
329 				Grp_desc	*gdp;
330 
331 				DBG_CALL(Dbg_file_hdl_title(DBG_HDL_REINST));
332 				for (ALIST_TRAVERSE(ghp->gh_depends, idx, gdp))
333 					DBG_CALL(Dbg_file_hdl_action(ghp,
334 					    gdp->gd_depend, DBG_DEP_REINST, 0));
335 			}
336 		}
337 
338 		/*
339 		 * If we've been asked to create a private handle, there's no
340 		 * need to track the caller.
341 		 */
342 		if (hflags & GPH_PRIVATE) {
343 			/*
344 			 * Negate the reference count increment.
345 			 */
346 			ghp->gh_refcnt--;
347 			return (ghp);
348 		} else {
349 			/*
350 			 * If a private handle already exists, promote this
351 			 * handle to public by initializing both the reference
352 			 * count and the handle flags.
353 			 */
354 			if (ghp->gh_flags & GPH_PRIVATE) {
355 				ghp->gh_refcnt = 1;
356 				ghp->gh_flags &= ~GPH_PRIVATE;
357 				ghp->gh_flags |= hflags;
358 			}
359 		}
360 	}
361 
362 	/*
363 	 * Keep track of the parent (caller).  As this object can be referenced
364 	 * by different parents, this processing is carried out every time a
365 	 * handle is requested.
366 	 */
367 	if (clmp && (hdl_add(ghp, clmp, cdflags, NULL) == NULL))
368 		return (NULL);
369 
370 	return (ghp);
371 }
372 
373 /*
374  * Initialize a handle that has been created for an object that is already
375  * loaded.  The handle is initialized with the present dependencies of that
376  * object.  Once this initialization has occurred, any new objects that might
377  * be loaded as dependencies (lazy-loading) are added to the handle as each new
378  * object is loaded.
379  */
380 int
381 hdl_initialize(Grp_hdl *ghp, Rt_map *nlmp, int mode, int promote)
382 {
383 	Aliste		idx;
384 	Grp_desc	*gdp;
385 
386 	/*
387 	 * If the handle has already been initialized, and the initial object's
388 	 * mode hasn't been promoted, there's no need to recompute the modes of
389 	 * any dependencies.  If the object we've added has just been opened,
390 	 * the objects dependencies will not yet have been processed.  These
391 	 * dependencies will be added on later calls to load_one().  Otherwise,
392 	 * this object already exists, so add all of its dependencies to the
393 	 * handle were operating on.
394 	 */
395 	if (((ghp->gh_flags & GPH_INITIAL) && (promote == 0)) ||
396 	    ((FLAGS(nlmp) & FLG_RT_ANALYZED) == 0)) {
397 		ghp->gh_flags |= GPH_INITIAL;
398 		return (1);
399 	}
400 
401 	DBG_CALL(Dbg_file_hdl_title(DBG_HDL_ADD));
402 	for (ALIST_TRAVERSE(ghp->gh_depends, idx, gdp)) {
403 		Rt_map		*lmp = gdp->gd_depend;
404 		Aliste		idx1;
405 		Bnd_desc	*bdp;
406 
407 		/*
408 		 * If this dependency doesn't indicate that its dependencies
409 		 * should be added to a handle, ignore it.  This case identifies
410 		 * a parent of a dlopen(RTLD_PARENT) request.
411 		 */
412 		if ((gdp->gd_flags & GPD_ADDEPS) == 0)
413 			continue;
414 
415 		for (APLIST_TRAVERSE(DEPENDS(lmp), idx1, bdp)) {
416 			Rt_map	*dlmp = bdp->b_depend;
417 
418 			if ((bdp->b_flags & BND_NEEDED) == 0)
419 				continue;
420 
421 			if (hdl_add(ghp, dlmp,
422 			    (GPD_DLSYM | GPD_RELOC | GPD_ADDEPS), NULL) == NULL)
423 				return (0);
424 
425 			(void) update_mode(dlmp, MODE(dlmp), mode);
426 		}
427 	}
428 	ghp->gh_flags |= GPH_INITIAL;
429 	return (1);
430 }
431 
432 /*
433  * Sanity check a program-provided handle.
434  */
435 static int
436 hdl_validate(Grp_hdl *ghp)
437 {
438 	Aliste		idx;
439 	Grp_hdl		*lghp;
440 	uint_t		ndx;
441 
442 	/* LINTED */
443 	ndx = (uintptr_t)ghp % HDLIST_SZ;
444 
445 	for (APLIST_TRAVERSE(hdl_alp[ndx], idx, lghp)) {
446 		if ((lghp == ghp) && (ghp->gh_refcnt != 0))
447 			return (1);
448 	}
449 	return (0);
450 }
451 
452 /*
453  * Core dlclose activity.
454  */
455 int
456 dlclose_core(Grp_hdl *ghp, Rt_map *clmp, Lm_list *lml)
457 {
458 	int	error;
459 
460 	/*
461 	 * If we're already at atexit() there's no point processing further,
462 	 * all objects have already been tsorted for fini processing.
463 	 */
464 	if (rtld_flags & RT_FL_ATEXIT)
465 		return (0);
466 
467 	/*
468 	 * Diagnose what we're up to.
469 	 */
470 	if (ghp->gh_flags & GPH_ZERO) {
471 		DBG_CALL(Dbg_file_dlclose(LIST(clmp), MSG_ORIG(MSG_STR_ZERO),
472 		    DBG_DLCLOSE_IGNORE));
473 	} else {
474 		DBG_CALL(Dbg_file_dlclose(LIST(clmp), NAME(ghp->gh_ownlmp),
475 		    DBG_DLCLOSE_NULL));
476 	}
477 
478 	/*
479 	 * Decrement reference count of this object.
480 	 */
481 	if (--(ghp->gh_refcnt))
482 		return (0);
483 
484 	/*
485 	 * If this handle is special (dlopen(0)), then leave it around - it
486 	 * has little overhead.
487 	 */
488 	if (ghp->gh_flags & GPH_ZERO)
489 		return (0);
490 
491 	/*
492 	 * This handle is no longer being referenced, remove it.  If this handle
493 	 * is part of an alternative link-map list, determine if the whole list
494 	 * can be removed also.
495 	 */
496 	error = remove_hdl(ghp, clmp, NULL);
497 
498 	if ((lml->lm_flags & (LML_FLG_BASELM | LML_FLG_RTLDLM)) == 0)
499 		remove_lml(lml);
500 
501 	return (error);
502 }
503 
504 /*
505  * Internal dlclose activity.  Called from user level or directly for internal
506  * error cleanup.
507  */
508 int
509 dlclose_intn(Grp_hdl *ghp, Rt_map *clmp)
510 {
511 	Rt_map	*nlmp = NULL;
512 	Lm_list	*olml = NULL;
513 	int	error;
514 
515 	/*
516 	 * Although we're deleting object(s) it's quite possible that additional
517 	 * objects get loaded from running the .fini section(s) of the objects
518 	 * being deleted.  These objects will have been added to the same
519 	 * link-map list as those objects being deleted.  Remember this list
520 	 * for later investigation.
521 	 */
522 	olml = ghp->gh_ownlml;
523 
524 	error = dlclose_core(ghp, clmp, olml);
525 
526 	/*
527 	 * Determine whether the original link-map list still exists.  In the
528 	 * case of a dlclose of an alternative (dlmopen) link-map the whole
529 	 * list may have been removed.
530 	 */
531 	if (olml) {
532 		Aliste	idx;
533 		Lm_list	*lml;
534 
535 		for (APLIST_TRAVERSE(dynlm_list, idx, lml)) {
536 			if (olml == lml) {
537 				nlmp = olml->lm_head;
538 				break;
539 			}
540 		}
541 	}
542 	load_completion(nlmp);
543 	return (error);
544 }
545 
546 /*
547  * Argument checking for dlclose.  Only called via external entry.
548  */
549 static int
550 dlclose_check(void *handle, Rt_map *clmp)
551 {
552 	Grp_hdl	*ghp = (Grp_hdl *)handle;
553 
554 	if (hdl_validate(ghp) == 0) {
555 		eprintf(LIST(clmp), ERR_FATAL, MSG_INTL(MSG_ARG_INVHNDL),
556 		    EC_NATPTR(handle));
557 		return (1);
558 	}
559 	return (dlclose_intn(ghp, clmp));
560 }
561 
562 #pragma weak _dlclose = dlclose
563 
564 /*
565  * External entry for dlclose(3dl).  Returns 0 for success, non-zero otherwise.
566  */
567 int
568 dlclose(void *handle)
569 {
570 	int		error, entry;
571 	Rt_map		*clmp;
572 
573 	entry = enter(0);
574 
575 	clmp = _caller(caller(), CL_EXECDEF);
576 
577 	error = dlclose_check(handle, clmp);
578 
579 	if (entry)
580 		leave(LIST(clmp), 0);
581 	return (error);
582 }
583 
584 static uint_t	lmid = 0;
585 
586 /*
587  * The addition of new link-map lists is assumed to be in small quantities.
588  * Here, we assign a unique link-map id for diagnostic use.  Simply update the
589  * running link-map count until we max out.
590  */
591 int
592 newlmid(Lm_list *lml)
593 {
594 	char	buffer[MSG_LMID_ALT_SIZE + 12];
595 
596 	if (lmid == UINT_MAX) {
597 		lml->lm_lmid = UINT_MAX;
598 		(void) strncpy(buffer, MSG_ORIG(MSG_LMID_MAXED),
599 		    MSG_LMID_ALT_SIZE + 12);
600 	} else {
601 		lml->lm_lmid = lmid++;
602 		(void) snprintf(buffer, MSG_LMID_ALT_SIZE + 12,
603 		    MSG_ORIG(MSG_LMID_FMT), MSG_ORIG(MSG_LMID_ALT),
604 		    lml->lm_lmid);
605 	}
606 	if ((lml->lm_lmidstr = strdup(buffer)) == NULL)
607 		return (0);
608 
609 	return (1);
610 }
611 
612 /*
613  * Core dlopen activity.
614  */
615 static Grp_hdl *
616 dlmopen_core(Lm_list *lml, Lm_list *olml, const char *path, int mode,
617     Rt_map *clmp, uint_t flags, uint_t orig, int *in_nfavl)
618 {
619 	Alist		*palp = NULL;
620 	Rt_map		*nlmp;
621 	Grp_hdl		*ghp;
622 	Aliste		olmco, nlmco;
623 
624 	DBG_CALL(Dbg_file_dlopen(clmp,
625 	    (path ? path : MSG_ORIG(MSG_STR_ZERO)), in_nfavl, mode));
626 
627 	/*
628 	 * Having diagnosed the originally defined modes, assign any defaults
629 	 * or corrections.
630 	 */
631 	if (((mode & (RTLD_GROUP | RTLD_WORLD)) == 0) &&
632 	    ((mode & RTLD_NOLOAD) == 0))
633 		mode |= (RTLD_GROUP | RTLD_WORLD);
634 	if ((mode & RTLD_NOW) && (rtld_flags2 & RT_FL2_BINDLAZY)) {
635 		mode &= ~RTLD_NOW;
636 		mode |= RTLD_LAZY;
637 	}
638 
639 	/*
640 	 * If the path specified is null then we're operating on global
641 	 * objects.  Associate a dummy handle with the link-map list.
642 	 */
643 	if (path == NULL) {
644 		Grp_hdl *ghp;
645 		uint_t	hflags, rdflags, cdflags;
646 		int	promote = 0;
647 
648 		/*
649 		 * Establish any flags for the handle (Grp_hdl).
650 		 *
651 		 *  -	This is a dummy, public, handle (0) that provides for a
652 		 *	dynamic	search of all global objects within the process.
653 		 *  -   Use of the RTLD_FIRST mode indicates that only the first
654 		 *	dependency on the handle (the referenced object) can be
655 		 *	used to satisfy dlsym() requests.
656 		 */
657 		hflags = (GPH_PUBLIC | GPH_ZERO);
658 		if (mode & RTLD_FIRST)
659 			hflags |= GPH_FIRST;
660 
661 		/*
662 		 * Establish the flags for the referenced dependency descriptor
663 		 * (Grp_desc).
664 		 *
665 		 *  -	The referenced object is available for dlsym().
666 		 *  -	The referenced object is available to relocate against.
667 		 *  -	The referenced object should have it's dependencies
668 		 *	added to this handle.
669 		 */
670 		rdflags = (GPD_DLSYM | GPD_RELOC | GPD_ADDEPS);
671 
672 		/*
673 		 * Establish the flags for this callers dependency descriptor
674 		 * (Grp_desc).
675 		 *
676 		 *  -	The explicit creation of a handle creates a descriptor
677 		 *	for the referenced object and the parent (caller).
678 		 *  -	Use of the RTLD_PARENT flag indicates that the parent
679 		 *	can be relocated against.
680 		 */
681 		cdflags = GPD_PARENT;
682 		if (mode & RTLD_PARENT)
683 			cdflags |= GPD_RELOC;
684 
685 		if ((ghp = hdl_create(lml, 0, clmp, hflags, rdflags,
686 		    cdflags)) == NULL)
687 			return (NULL);
688 
689 		/*
690 		 * Traverse the main link-map control list, updating the mode
691 		 * of any objects as necessary.  Call the relocation engine if
692 		 * this mode promotes the existing state of any relocations.
693 		 * crle()'s first pass loads all objects necessary for building
694 		 * a configuration file, however none of them are relocated.
695 		 * crle()'s second pass relocates objects in preparation for
696 		 * dldump()'ing using dlopen(0, RTLD_NOW).
697 		 */
698 		if ((mode & (RTLD_NOW | RTLD_CONFGEN)) == RTLD_CONFGEN)
699 			return (ghp);
700 
701 		for (nlmp = lml->lm_head; nlmp; nlmp = NEXT_RT_MAP(nlmp)) {
702 			if (((MODE(nlmp) & RTLD_GLOBAL) == 0) ||
703 			    (FLAGS(nlmp) & FLG_RT_DELETE))
704 				continue;
705 
706 			if (update_mode(nlmp, MODE(nlmp), mode))
707 				promote = 1;
708 		}
709 		if (promote)
710 			(void) relocate_lmc(lml, ALIST_OFF_DATA, clmp,
711 			    lml->lm_head, in_nfavl);
712 
713 		return (ghp);
714 	}
715 
716 	/*
717 	 * Fix the pathname.  If this object expands to multiple paths (ie.
718 	 * $ISALIST or $HWCAP have been used), then make sure the user has also
719 	 * furnished the RTLD_FIRST flag.  As yet, we don't support opening
720 	 * more than one object at a time, so enforcing the RTLD_FIRST flag
721 	 * provides flexibility should we be able to support dlopening more
722 	 * than one object in the future.
723 	 */
724 	if (LM_FIX_NAME(clmp)(path, clmp, &palp, AL_CNT_NEEDED, orig) == NULL)
725 		return (NULL);
726 
727 	if ((palp->al_arritems > 1) && ((mode & RTLD_FIRST) == 0)) {
728 		remove_plist(&palp, 1);
729 		eprintf(lml, ERR_FATAL, MSG_INTL(MSG_ARG_ILLMODE_5));
730 		return (NULL);
731 	}
732 
733 	/*
734 	 * Establish a link-map control list for this request, and load the
735 	 * associated object.
736 	 */
737 	if ((nlmco = create_cntl(lml, 1)) == NULL) {
738 		remove_plist(&palp, 1);
739 		return (NULL);
740 	}
741 	olmco = nlmco;
742 
743 	nlmp = load_one(lml, nlmco, palp, clmp, mode, (flags | FLG_RT_PUBHDL),
744 	    &ghp, in_nfavl);
745 
746 	/*
747 	 * Remove any expanded pathname infrastructure, and if the dependency
748 	 * couldn't be loaded, cleanup.
749 	 */
750 	remove_plist(&palp, 1);
751 	if (nlmp == NULL) {
752 		remove_cntl(lml, olmco);
753 		return (NULL);
754 	}
755 
756 	/*
757 	 * If loading an auditor was requested, and the auditor already existed,
758 	 * then the link-map returned will be to the original auditor.  The new
759 	 * link-map list that was initially created, and the associated link-map
760 	 * control list are no longer needed.  As the auditor is already loaded,
761 	 * we're probably done, but fall through in case additional relocations
762 	 * would be triggered by the mode of the caller.
763 	 */
764 	if ((flags & FLG_RT_AUDIT) && (LIST(nlmp) != lml)) {
765 		remove_cntl(lml, olmco);
766 		lml = LIST(nlmp);
767 		olmco = 0;
768 		nlmco = ALIST_OFF_DATA;
769 	}
770 
771 	/*
772 	 * Finish processing the objects associated with this request.
773 	 */
774 	if (((nlmp = analyze_lmc(lml, nlmco, nlmp, in_nfavl)) == NULL) ||
775 	    (relocate_lmc(lml, nlmco, clmp, nlmp, in_nfavl) == 0)) {
776 		ghp = NULL;
777 		nlmp = NULL;
778 	}
779 
780 	/*
781 	 * If the dlopen has failed, clean up any objects that might have been
782 	 * loaded successfully on this new link-map control list.
783 	 */
784 	if (olmco && (nlmp == NULL))
785 		remove_lmc(lml, clmp, olmco, path);
786 
787 	/*
788 	 * Finally, remove any temporary link-map control list.  Note, if this
789 	 * operation successfully established a new link-map list, then a base
790 	 * link-map control list will have been created, which must remain.
791 	 */
792 	if (olmco && ((nlmp == NULL) || (olml != (Lm_list *)LM_ID_NEWLM)))
793 		remove_cntl(lml, olmco);
794 
795 	return (ghp);
796 }
797 
798 /*
799  * dlopen() and dlsym() operations are the means by which a process can
800  * test for the existence of required dependencies.  If the necessary
801  * dependencies don't exist, then associated functionality can't be used.
802  * However, the lack of dependencies can be fixed, and the dlopen() and
803  * dlsym() requests can be repeated.  As we use a "not-found" AVL tree to
804  * cache any failed full path loads, secondary dlopen() and dlsym() requests
805  * will fail, even if the dependencies have been installed.
806  *
807  * dlopen() and dlsym() retry any failures by removing the "not-found" AVL
808  * tree.  Should any dependencies be found, their names are added to the
809  * FullPath AVL tree.  This routine removes any new "not-found" AVL tree,
810  * so that the dlopen() or dlsym() can replace the original "not-found" tree.
811  */
812 inline static void
813 nfavl_remove(avl_tree_t *avlt)
814 {
815 	PathNode	*pnp;
816 	void		*cookie = NULL;
817 
818 	if (avlt) {
819 		while ((pnp = avl_destroy_nodes(avlt, &cookie)) != NULL)
820 			free(pnp);
821 
822 		avl_destroy(avlt);
823 		free(avlt);
824 	}
825 }
826 
827 /*
828  * Internal dlopen() activity.  Called from user level or directly for internal
829  * opens that require a handle.
830  */
831 Grp_hdl *
832 dlmopen_intn(Lm_list *lml, const char *path, int mode, Rt_map *clmp,
833     uint_t flags, uint_t orig)
834 {
835 	Lm_list	*olml = lml;
836 	Rt_map	*dlmp = NULL;
837 	Grp_hdl	*ghp;
838 	int	in_nfavl = 0;
839 
840 	/*
841 	 * Check for magic link-map list values:
842 	 *
843 	 *  LM_ID_BASE:		Operate on the PRIMARY (executables) link map
844 	 *  LM_ID_LDSO:		Operation on ld.so.1's link map
845 	 *  LM_ID_NEWLM: 	Create a new link-map.
846 	 */
847 	if (lml == (Lm_list *)LM_ID_NEWLM) {
848 		if ((lml = calloc(sizeof (Lm_list), 1)) == NULL)
849 			return (NULL);
850 
851 		/*
852 		 * Establish the new link-map flags from the callers and those
853 		 * explicitly provided.
854 		 */
855 		lml->lm_tflags = LIST(clmp)->lm_tflags;
856 		if (flags & FLG_RT_AUDIT) {
857 			/*
858 			 * Unset any auditing flags - an auditor shouldn't be
859 			 * audited.  Insure all audit dependencies are loaded.
860 			 */
861 			lml->lm_tflags &= ~LML_TFLG_AUD_MASK;
862 			lml->lm_tflags |=
863 			    (LML_TFLG_NOLAZYLD | LML_TFLG_LOADFLTR);
864 			lml->lm_flags |= LML_FLG_NOAUDIT;
865 		}
866 
867 		if (aplist_append(&dynlm_list, lml, AL_CNT_DYNLIST) == NULL) {
868 			free(lml);
869 			return (NULL);
870 		}
871 		if (newlmid(lml) == 0) {
872 			(void) aplist_delete_value(dynlm_list, lml);
873 			free(lml);
874 			return (NULL);
875 		}
876 	} else if ((uintptr_t)lml < LM_ID_NUM) {
877 		if ((uintptr_t)lml == LM_ID_BASE)
878 			lml = &lml_main;
879 		else if ((uintptr_t)lml == LM_ID_LDSO)
880 			lml = &lml_rtld;
881 	}
882 
883 	/*
884 	 * Open the required object on the associated link-map list.
885 	 */
886 	ghp = dlmopen_core(lml, olml, path, mode, clmp, flags, orig, &in_nfavl);
887 
888 	/*
889 	 * If the object could not be found it is possible that the "not-found"
890 	 * AVL tree had indicated that the file does not exist.  In case the
891 	 * file system has changed since this "not-found" recording was made,
892 	 * retry the dlopen() with a clean "not-found" AVL tree.
893 	 */
894 	if ((ghp == NULL) && in_nfavl) {
895 		avl_tree_t	*oavlt = nfavl;
896 
897 		nfavl = NULL;
898 		ghp = dlmopen_core(lml, olml, path, mode, clmp, flags, orig,
899 		    NULL);
900 
901 		/*
902 		 * If the file is found, then its full path name will have been
903 		 * registered in the FullPath AVL tree.  Remove any new
904 		 * "not-found" AVL information, and restore the former AVL tree.
905 		 */
906 		nfavl_remove(nfavl);
907 		nfavl = oavlt;
908 	}
909 
910 	/*
911 	 * Establish the new link-map from which .init processing will begin.
912 	 * Ignore .init firing when constructing a configuration file (crle(1)).
913 	 */
914 	if (ghp && ((mode & RTLD_CONFGEN) == 0))
915 		dlmp = ghp->gh_ownlmp;
916 
917 	/*
918 	 * If loading an auditor was requested, and the auditor already existed,
919 	 * then the link-map returned will be to the original auditor.  Remove
920 	 * the link-map control list that was created for this request.
921 	 */
922 	if (dlmp && (flags & FLG_RT_AUDIT) && (LIST(dlmp) != lml)) {
923 		remove_lml(lml);
924 		lml = LIST(dlmp);
925 	}
926 
927 	/*
928 	 * If this load failed, remove any alternative link-map list.
929 	 */
930 	if ((ghp == NULL) &&
931 	    ((lml->lm_flags & (LML_FLG_BASELM | LML_FLG_RTLDLM)) == 0)) {
932 		remove_lml(lml);
933 		lml = NULL;
934 	}
935 
936 	/*
937 	 * Finish this load request.  If objects were loaded, .init processing
938 	 * is computed.  Finally, the debuggers are informed of the link-map
939 	 * lists being stable.
940 	 */
941 	load_completion(dlmp);
942 
943 	return (ghp);
944 }
945 
946 /*
947  * Argument checking for dlopen.  Only called via external entry.
948  */
949 static Grp_hdl *
950 dlmopen_check(Lm_list *lml, const char *path, int mode, Rt_map *clmp)
951 {
952 	/*
953 	 * Verify that a valid pathname has been supplied.
954 	 */
955 	if (path && (*path == '\0')) {
956 		eprintf(lml, ERR_FATAL, MSG_INTL(MSG_ARG_ILLPATH));
957 		return (0);
958 	}
959 
960 	/*
961 	 * Historically we've always verified the mode is either RTLD_NOW or
962 	 * RTLD_LAZY.  RTLD_NOLOAD is valid by itself.  Use of LM_ID_NEWLM
963 	 * requires a specific pathname, and use of RTLD_PARENT is meaningless.
964 	 */
965 	if ((mode & (RTLD_NOW | RTLD_LAZY | RTLD_NOLOAD)) == 0) {
966 		eprintf(lml, ERR_FATAL, MSG_INTL(MSG_ARG_ILLMODE_1));
967 		return (0);
968 	}
969 	if ((mode & (RTLD_NOW | RTLD_LAZY)) == (RTLD_NOW | RTLD_LAZY)) {
970 		eprintf(lml, ERR_FATAL, MSG_INTL(MSG_ARG_ILLMODE_2));
971 		return (0);
972 	}
973 	if ((lml == (Lm_list *)LM_ID_NEWLM) && (path == NULL)) {
974 		eprintf(lml, ERR_FATAL, MSG_INTL(MSG_ARG_ILLMODE_3));
975 		return (0);
976 	}
977 	if ((lml == (Lm_list *)LM_ID_NEWLM) && (mode & RTLD_PARENT)) {
978 		eprintf(lml, ERR_FATAL, MSG_INTL(MSG_ARG_ILLMODE_4));
979 		return (0);
980 	}
981 
982 	return (dlmopen_intn(lml, path, mode, clmp, 0, 0));
983 }
984 
985 #pragma weak _dlopen = dlopen
986 
987 /*
988  * External entry for dlopen(3dl).  On success, returns a pointer (handle) to
989  * the structure containing information about the newly added object, ie. can
990  * be used by dlsym(). On failure, returns a null pointer.
991  */
992 void *
993 dlopen(const char *path, int mode)
994 {
995 	int	entry;
996 	Rt_map	*clmp;
997 	Grp_hdl	*ghp;
998 	Lm_list	*lml;
999 
1000 	entry = enter(0);
1001 
1002 	clmp = _caller(caller(), CL_EXECDEF);
1003 	lml = LIST(clmp);
1004 
1005 	ghp = dlmopen_check(lml, path, mode, clmp);
1006 
1007 	if (entry)
1008 		leave(lml, 0);
1009 	return ((void *)ghp);
1010 }
1011 
1012 #pragma weak _dlmopen = dlmopen
1013 
1014 /*
1015  * External entry for dlmopen(3dl).
1016  */
1017 void *
1018 dlmopen(Lmid_t lmid, const char *path, int mode)
1019 {
1020 	int	entry;
1021 	Rt_map	*clmp;
1022 	Grp_hdl	*ghp;
1023 
1024 	entry = enter(0);
1025 
1026 	clmp = _caller(caller(), CL_EXECDEF);
1027 
1028 	ghp = dlmopen_check((Lm_list *)lmid, path, mode, clmp);
1029 
1030 	if (entry)
1031 		leave(LIST(clmp), 0);
1032 	return ((void *)ghp);
1033 }
1034 
1035 /*
1036  * Handle processing for dlsym.
1037  */
1038 Sym *
1039 dlsym_handle(Grp_hdl *ghp, Slookup *slp, Rt_map **_lmp, uint_t *binfo,
1040     int *in_nfavl)
1041 {
1042 	Rt_map		*nlmp, * lmp = ghp->gh_ownlmp;
1043 	Rt_map		*clmp = slp->sl_cmap;
1044 	const char	*name = slp->sl_name;
1045 	Sym		*sym = NULL;
1046 	Slookup		sl = *slp;
1047 
1048 	sl.sl_flags = (LKUP_FIRST | LKUP_SPEC);
1049 
1050 	/*
1051 	 * Continue processing a dlsym request.  Lookup the required symbol in
1052 	 * each link-map specified by the handle.
1053 	 *
1054 	 * To leverage off of lazy loading, dlsym() requests can result in two
1055 	 * passes.  The first descends the link-maps of any objects already in
1056 	 * the address space.  If the symbol isn't located, and lazy
1057 	 * dependencies still exist, then a second pass is made to load these
1058 	 * dependencies if applicable.  This model means that in the case where
1059 	 * a symbol exists in more than one object, the one located may not be
1060 	 * constant - this is the standard issue with lazy loading. In addition,
1061 	 * attempting to locate a symbol that doesn't exist will result in the
1062 	 * loading of all lazy dependencies on the given handle, which can
1063 	 * defeat some of the advantages of lazy loading (look out JVM).
1064 	 */
1065 	if (ghp->gh_flags & GPH_ZERO) {
1066 		Lm_list	*lml;
1067 		uint_t	lazy = 0;
1068 
1069 		/*
1070 		 * If this symbol lookup is triggered from a dlopen(0) handle,
1071 		 * traverse the present link-map list looking for promiscuous
1072 		 * entries.
1073 		 */
1074 		for (nlmp = lmp; nlmp; nlmp = NEXT_RT_MAP(nlmp)) {
1075 			/*
1076 			 * If this handle indicates we're only to look in the
1077 			 * first object check whether we're done.
1078 			 */
1079 			if ((nlmp != lmp) && (ghp->gh_flags & GPH_FIRST))
1080 				return (NULL);
1081 
1082 			if (!(MODE(nlmp) & RTLD_GLOBAL))
1083 				continue;
1084 			if ((FLAGS(nlmp) & FLG_RT_DELETE) &&
1085 			    ((FLAGS(clmp) & FLG_RT_DELETE) == 0))
1086 				continue;
1087 
1088 			sl.sl_imap = nlmp;
1089 			if (sym = LM_LOOKUP_SYM(clmp)(&sl, _lmp, binfo,
1090 			    in_nfavl))
1091 				return (sym);
1092 
1093 			/*
1094 			 * Keep track of any global pending lazy loads.
1095 			 */
1096 			lazy += LAZY(nlmp);
1097 		}
1098 
1099 		/*
1100 		 * If we're unable to locate the symbol and this link-map list
1101 		 * still has pending lazy dependencies, start loading them in an
1102 		 * attempt to exhaust the search.  Note that as we're already
1103 		 * traversing a dynamic linked list of link-maps there's no
1104 		 * need for elf_lazy_find_sym() to descend the link-maps itself.
1105 		 */
1106 		lml = LIST(lmp);
1107 		if (lazy) {
1108 			DBG_CALL(Dbg_syms_lazy_rescan(lml, name));
1109 
1110 			sl.sl_flags |= LKUP_NODESCENT;
1111 
1112 			for (nlmp = lmp; nlmp; nlmp = NEXT_RT_MAP(nlmp)) {
1113 
1114 				if (!(MODE(nlmp) & RTLD_GLOBAL) || !LAZY(nlmp))
1115 					continue;
1116 				if ((FLAGS(nlmp) & FLG_RT_DELETE) &&
1117 				    ((FLAGS(clmp) & FLG_RT_DELETE) == 0))
1118 					continue;
1119 
1120 				sl.sl_imap = nlmp;
1121 				if (sym = elf_lazy_find_sym(&sl, _lmp, binfo,
1122 				    in_nfavl))
1123 					return (sym);
1124 			}
1125 		}
1126 	} else {
1127 		/*
1128 		 * Traverse the dlopen() handle searching all presently loaded
1129 		 * link-maps.
1130 		 */
1131 		Grp_desc	*gdp;
1132 		Aliste		idx;
1133 		uint_t		lazy = 0;
1134 
1135 		for (ALIST_TRAVERSE(ghp->gh_depends, idx, gdp)) {
1136 			nlmp = gdp->gd_depend;
1137 
1138 			if ((gdp->gd_flags & GPD_DLSYM) == 0)
1139 				continue;
1140 
1141 			sl.sl_imap = nlmp;
1142 			if (sym = LM_LOOKUP_SYM(clmp)(&sl, _lmp, binfo,
1143 			    in_nfavl))
1144 				return (sym);
1145 
1146 			if (ghp->gh_flags & GPH_FIRST)
1147 				return (NULL);
1148 
1149 			/*
1150 			 * Keep track of any pending lazy loads associated
1151 			 * with this handle.
1152 			 */
1153 			lazy += LAZY(nlmp);
1154 		}
1155 
1156 		/*
1157 		 * If we're unable to locate the symbol and this handle still
1158 		 * has pending lazy dependencies, start loading the lazy
1159 		 * dependencies, in an attempt to exhaust the search.
1160 		 */
1161 		if (lazy) {
1162 			DBG_CALL(Dbg_syms_lazy_rescan(LIST(lmp), name));
1163 
1164 			for (ALIST_TRAVERSE(ghp->gh_depends, idx, gdp)) {
1165 				nlmp = gdp->gd_depend;
1166 
1167 				if (((gdp->gd_flags & GPD_DLSYM) == 0) ||
1168 				    (LAZY(nlmp) == 0))
1169 					continue;
1170 
1171 				sl.sl_imap = nlmp;
1172 				if (sym = elf_lazy_find_sym(&sl, _lmp,
1173 				    binfo, in_nfavl))
1174 					return (sym);
1175 			}
1176 		}
1177 	}
1178 	return (NULL);
1179 }
1180 
1181 /*
1182  * Core dlsym activity.  Selects symbol lookup method from handle.
1183  */
1184 void *
1185 dlsym_core(void *handle, const char *name, Rt_map *clmp, Rt_map **dlmp,
1186     int *in_nfavl)
1187 {
1188 	Sym		*sym = NULL;
1189 	Syminfo		*sip;
1190 	Slookup		sl;
1191 	uint_t		binfo;
1192 
1193 	/*
1194 	 * Initialize the symbol lookup data structure.
1195 	 *
1196 	 * Standard relocations are evaluated using the symbol index of the
1197 	 * associated relocation symbol.  This index provides for loading
1198 	 * any lazy dependency and establishing a direct binding if necessary.
1199 	 * If a dlsym() operation originates from an object that contains a
1200 	 * symbol table entry for the same name, then we need to establish the
1201 	 * symbol index so that any dependency requirements can be triggered.
1202 	 *
1203 	 * Therefore, the first symbol lookup that is carried out is for the
1204 	 * symbol name within the calling object.  If this symbol exists, the
1205 	 * symbols index is computed, added to the Slookup data, and thus used
1206 	 * to seed the real symbol lookup.
1207 	 */
1208 	SLOOKUP_INIT(sl, name, clmp, clmp, ld_entry_cnt, elf_hash(name),
1209 	    0, 0, 0, LKUP_SYMNDX);
1210 
1211 	if (THIS_IS_ELF(clmp) &&
1212 	    ((sym = SYMINTP(clmp)(&sl, 0, 0, NULL)) != NULL)) {
1213 		sl.sl_rsymndx = (((ulong_t)sym -
1214 		    (ulong_t)SYMTAB(clmp)) / SYMENT(clmp));
1215 		sl.sl_rsym = sym;
1216 	}
1217 
1218 	if (sym && (ELF_ST_VISIBILITY(sym->st_other) == STV_SINGLETON)) {
1219 		Rt_map	*hlmp = LIST(clmp)->lm_head;
1220 
1221 		/*
1222 		 * If a symbol reference is known, and that reference indicates
1223 		 * that the symbol is a singleton, then the search for the
1224 		 * symbol must follow the default search path.
1225 		 */
1226 		DBG_CALL(Dbg_syms_dlsym(clmp, name, in_nfavl, 0,
1227 		    DBG_DLSYM_SINGLETON));
1228 
1229 		sl.sl_imap = hlmp;
1230 		sl.sl_flags = LKUP_SPEC;
1231 		if (handle == RTLD_PROBE)
1232 			sl.sl_flags |= LKUP_NOFALLBACK;
1233 		sym = LM_LOOKUP_SYM(clmp)(&sl, dlmp, &binfo, in_nfavl);
1234 
1235 	} else if (handle == RTLD_NEXT) {
1236 		Rt_map	*nlmp;
1237 
1238 		/*
1239 		 * If this handle is RTLD_NEXT determine whether a lazy load
1240 		 * from the caller might provide the next object.  This mimics
1241 		 * the lazy loading initialization normally carried out by
1242 		 * lookup_sym(), however here, we must do this up-front, as
1243 		 * lookup_sym() will be used to inspect the next object.
1244 		 */
1245 		if ((sl.sl_rsymndx) && ((sip = SYMINFO(clmp)) != NULL)) {
1246 			/* LINTED */
1247 			sip = (Syminfo *)((char *)sip +
1248 			    (sl.sl_rsymndx * SYMINENT(clmp)));
1249 
1250 			if ((sip->si_flags & SYMINFO_FLG_DIRECT) &&
1251 			    (sip->si_boundto < SYMINFO_BT_LOWRESERVE))
1252 				(void) elf_lazy_load(clmp, &sl,
1253 				    sip->si_boundto, name, 0, NULL, in_nfavl);
1254 
1255 			/*
1256 			 * Clear the symbol index, so as not to confuse
1257 			 * lookup_sym() of the next object.
1258 			 */
1259 			sl.sl_rsymndx = 0;
1260 			sl.sl_rsym = NULL;
1261 		}
1262 
1263 		/*
1264 		 * If the handle is RTLD_NEXT start searching in the next link
1265 		 * map from the callers.  Determine permissions from the
1266 		 * present link map.  Indicate to lookup_sym() that we're on an
1267 		 * RTLD_NEXT request so that it will use the callers link map to
1268 		 * start any possible lazy dependency loading.
1269 		 */
1270 		sl.sl_imap = nlmp = NEXT_RT_MAP(clmp);
1271 
1272 		DBG_CALL(Dbg_syms_dlsym(clmp, name, in_nfavl,
1273 		    (nlmp ? NAME(nlmp) : MSG_INTL(MSG_STR_NULL)),
1274 		    DBG_DLSYM_NEXT));
1275 
1276 		if (nlmp == NULL)
1277 			return (0);
1278 
1279 		sl.sl_flags = LKUP_NEXT;
1280 		sym = LM_LOOKUP_SYM(clmp)(&sl, dlmp, &binfo, in_nfavl);
1281 
1282 	} else if (handle == RTLD_SELF) {
1283 		/*
1284 		 * If the handle is RTLD_SELF start searching from the caller.
1285 		 */
1286 		DBG_CALL(Dbg_syms_dlsym(clmp, name, in_nfavl, NAME(clmp),
1287 		    DBG_DLSYM_SELF));
1288 
1289 		sl.sl_imap = clmp;
1290 		sl.sl_flags = (LKUP_SPEC | LKUP_SELF);
1291 		sym = LM_LOOKUP_SYM(clmp)(&sl, dlmp, &binfo, in_nfavl);
1292 
1293 	} else if (handle == RTLD_DEFAULT) {
1294 		Rt_map	*hlmp = LIST(clmp)->lm_head;
1295 
1296 		/*
1297 		 * If the handle is RTLD_DEFAULT mimic the standard symbol
1298 		 * lookup as would be triggered by a relocation.
1299 		 */
1300 		DBG_CALL(Dbg_syms_dlsym(clmp, name, in_nfavl, 0,
1301 		    DBG_DLSYM_DEFAULT));
1302 
1303 		sl.sl_imap = hlmp;
1304 		sl.sl_flags = LKUP_SPEC;
1305 		sym = LM_LOOKUP_SYM(clmp)(&sl, dlmp, &binfo, in_nfavl);
1306 
1307 	} else if (handle == RTLD_PROBE) {
1308 		Rt_map	*hlmp = LIST(clmp)->lm_head;
1309 
1310 		/*
1311 		 * If the handle is RTLD_PROBE, mimic the standard symbol
1312 		 * lookup as would be triggered by a relocation, however do
1313 		 * not fall back to a lazy loading rescan if the symbol can't be
1314 		 * found within the currently loaded objects.  Note, a lazy
1315 		 * loaded dependency required by the caller might still get
1316 		 * loaded to satisfy this request, but no exhaustive lazy load
1317 		 * rescan is carried out.
1318 		 */
1319 		DBG_CALL(Dbg_syms_dlsym(clmp, name, in_nfavl, 0,
1320 		    DBG_DLSYM_PROBE));
1321 
1322 		sl.sl_imap = hlmp;
1323 		sl.sl_flags = (LKUP_SPEC | LKUP_NOFALLBACK);
1324 		sym = LM_LOOKUP_SYM(clmp)(&sl, dlmp, &binfo, in_nfavl);
1325 
1326 	} else {
1327 		Grp_hdl *ghp = (Grp_hdl *)handle;
1328 
1329 		/*
1330 		 * Look in the shared object specified by the handle and in all
1331 		 * of its dependencies.
1332 		 */
1333 		DBG_CALL(Dbg_syms_dlsym(clmp, name, in_nfavl,
1334 		    NAME(ghp->gh_ownlmp), DBG_DLSYM_DEF));
1335 
1336 		sym = LM_DLSYM(clmp)(ghp, &sl, dlmp, &binfo, in_nfavl);
1337 	}
1338 
1339 	if (sym) {
1340 		Lm_list	*lml = LIST(clmp);
1341 		Addr	addr = sym->st_value;
1342 
1343 		if (!(FLAGS(*dlmp) & FLG_RT_FIXED))
1344 			addr += ADDR(*dlmp);
1345 
1346 		/*
1347 		 * Indicate that the defining object is now used.
1348 		 */
1349 		if (*dlmp != clmp)
1350 			FLAGS1(*dlmp) |= FL1_RT_USED;
1351 
1352 		DBG_CALL(Dbg_bind_global(clmp, 0, 0, (Xword)-1, PLT_T_NONE,
1353 		    *dlmp, addr, sym->st_value, name, binfo));
1354 
1355 		if ((lml->lm_tflags | AFLAGS(clmp)) & LML_TFLG_AUD_SYMBIND) {
1356 			uint_t	sb_flags = LA_SYMB_DLSYM;
1357 			/* LINTED */
1358 			uint_t	symndx = (uint_t)(((Xword)sym -
1359 			    (Xword)SYMTAB(*dlmp)) / SYMENT(*dlmp));
1360 			addr = audit_symbind(clmp, *dlmp, sym, symndx, addr,
1361 			    &sb_flags);
1362 		}
1363 		return ((void *)addr);
1364 	} else
1365 		return (0);
1366 }
1367 
1368 /*
1369  * Internal dlsym activity.  Called from user level or directly for internal
1370  * symbol lookup.
1371  */
1372 void *
1373 dlsym_intn(void *handle, const char *name, Rt_map *clmp, Rt_map **dlmp)
1374 {
1375 	Rt_map		*llmp = NULL;
1376 	void		*error;
1377 	Aliste		idx;
1378 	Grp_desc	*gdp;
1379 	int		in_nfavl = 0;
1380 
1381 	/*
1382 	 * While looking for symbols it's quite possible that additional objects
1383 	 * get loaded from lazy loading.  These objects will have been added to
1384 	 * the same link-map list as those objects on the handle.  Remember this
1385 	 * list for later investigation.
1386 	 */
1387 	if ((handle == RTLD_NEXT) || (handle == RTLD_DEFAULT) ||
1388 	    (handle == RTLD_SELF) || (handle == RTLD_PROBE))
1389 		llmp = LIST(clmp)->lm_tail;
1390 	else {
1391 		Grp_hdl	*ghp = (Grp_hdl *)handle;
1392 
1393 		if (ghp->gh_ownlmp)
1394 			llmp = LIST(ghp->gh_ownlmp)->lm_tail;
1395 		else {
1396 			for (ALIST_TRAVERSE(ghp->gh_depends, idx, gdp)) {
1397 				if ((llmp =
1398 				    LIST(gdp->gd_depend)->lm_tail) != NULL)
1399 					break;
1400 			}
1401 		}
1402 	}
1403 
1404 	error = dlsym_core(handle, name, clmp, dlmp, &in_nfavl);
1405 
1406 	/*
1407 	 * If the symbol could not be found it is possible that the "not-found"
1408 	 * AVL tree had indicated that a required file does not exist.  In case
1409 	 * the file system has changed since this "not-found" recording was
1410 	 * made, retry the dlsym() with a clean "not-found" AVL tree.
1411 	 */
1412 	if ((error == NULL) && in_nfavl) {
1413 		avl_tree_t	*oavlt = nfavl;
1414 
1415 		nfavl = NULL;
1416 		error = dlsym_core(handle, name, clmp, dlmp, NULL);
1417 
1418 		/*
1419 		 * If the symbol is found, then any file that was loaded will
1420 		 * have had its full path name registered in the FullPath AVL
1421 		 * tree.  Remove any new "not-found" AVL information, and
1422 		 * restore the former AVL tree.
1423 		 */
1424 		nfavl_remove(nfavl);
1425 		nfavl = oavlt;
1426 	}
1427 
1428 	if (error == NULL) {
1429 		/*
1430 		 * Cache the error message, as Java tends to fall through this
1431 		 * code many times.
1432 		 */
1433 		if (nosym_str == NULL)
1434 			nosym_str = MSG_INTL(MSG_GEN_NOSYM);
1435 		eprintf(LIST(clmp), ERR_FATAL, nosym_str, name);
1436 	}
1437 
1438 	load_completion(llmp);
1439 	return (error);
1440 }
1441 
1442 /*
1443  * Argument checking for dlsym.  Only called via external entry.
1444  */
1445 static void *
1446 dlsym_check(void *handle, const char *name, Rt_map *clmp, Rt_map **dlmp)
1447 {
1448 	/*
1449 	 * Verify the arguments.
1450 	 */
1451 	if (name == NULL) {
1452 		eprintf(LIST(clmp), ERR_FATAL, MSG_INTL(MSG_ARG_ILLSYM));
1453 		return (NULL);
1454 	}
1455 	if ((handle != RTLD_NEXT) && (handle != RTLD_DEFAULT) &&
1456 	    (handle != RTLD_SELF) && (handle != RTLD_PROBE) &&
1457 	    (hdl_validate((Grp_hdl *)handle) == 0)) {
1458 		eprintf(LIST(clmp), ERR_FATAL, MSG_INTL(MSG_ARG_INVHNDL),
1459 		    EC_NATPTR(handle));
1460 		return (NULL);
1461 	}
1462 	return (dlsym_intn(handle, name, clmp, dlmp));
1463 }
1464 
1465 
1466 #pragma weak _dlsym = dlsym
1467 
1468 /*
1469  * External entry for dlsym().  On success, returns the address of the specified
1470  * symbol.  On error returns a null.
1471  */
1472 void *
1473 dlsym(void *handle, const char *name)
1474 {
1475 	int	entry;
1476 	Rt_map	*clmp, *dlmp = NULL;
1477 	void	*addr;
1478 
1479 	entry = enter(0);
1480 
1481 	clmp = _caller(caller(), CL_EXECDEF);
1482 
1483 	addr = dlsym_check(handle, name, clmp, &dlmp);
1484 
1485 	if (entry) {
1486 		if (dlmp)
1487 			is_dep_init(dlmp, clmp);
1488 		leave(LIST(clmp), 0);
1489 	}
1490 	return (addr);
1491 }
1492 
1493 /*
1494  * Core dladdr activity.
1495  */
1496 static void
1497 dladdr_core(Rt_map *clmp, void *addr, Dl_info_t *dlip, void **info, int flags)
1498 {
1499 	/*
1500 	 * Set up generic information and any defaults.
1501 	 */
1502 	dlip->dli_fname = PATHNAME(clmp);
1503 
1504 	dlip->dli_fbase = (void *)ADDR(clmp);
1505 	dlip->dli_sname = NULL;
1506 	dlip->dli_saddr = NULL;
1507 
1508 	/*
1509 	 * Determine the nearest symbol to this address.
1510 	 */
1511 	LM_DLADDR(clmp)((ulong_t)addr, clmp, dlip, info, flags);
1512 }
1513 
1514 #pragma weak _dladdr = dladdr
1515 
1516 /*
1517  * External entry for dladdr(3dl) and dladdr1(3dl).  Returns an information
1518  * structure that reflects the symbol closest to the address specified.
1519  */
1520 int
1521 dladdr(void *addr, Dl_info_t *dlip)
1522 {
1523 	int	entry, error;
1524 	Rt_map	*clmp;
1525 
1526 	entry = enter(0);
1527 
1528 	/*
1529 	 * Use our calling technique to determine what object is associated
1530 	 * with the supplied address.  If a caller can't be determined,
1531 	 * indicate the failure.
1532 	 */
1533 	if ((clmp = _caller(addr, CL_NONE)) == NULL) {
1534 		eprintf(0, ERR_FATAL, MSG_INTL(MSG_ARG_INVADDR),
1535 		    EC_NATPTR(addr));
1536 		error = 0;
1537 	} else {
1538 		dladdr_core(clmp, addr, dlip, 0, 0);
1539 		error = 1;
1540 	}
1541 
1542 	if (entry)
1543 		leave(0, 0);
1544 	return (error);
1545 }
1546 
1547 #pragma weak _dladdr1 = dladdr1
1548 
1549 int
1550 dladdr1(void *addr, Dl_info_t *dlip, void **info, int flags)
1551 {
1552 	int	entry, error = 0;
1553 	Rt_map	*clmp;
1554 
1555 	/*
1556 	 * Validate any flags.
1557 	 */
1558 	if (flags) {
1559 		int	request;
1560 
1561 		if (((request = (flags & RTLD_DL_MASK)) != RTLD_DL_SYMENT) &&
1562 		    (request != RTLD_DL_LINKMAP)) {
1563 			eprintf(0, ERR_FATAL, MSG_INTL(MSG_ARG_ILLFLAGS),
1564 			    flags);
1565 			return (0);
1566 		}
1567 		if (info == NULL) {
1568 			eprintf(0, ERR_FATAL, MSG_INTL(MSG_ARG_ILLINFO), flags);
1569 			return (0);
1570 		}
1571 	}
1572 
1573 	entry = enter(0);
1574 
1575 	/*
1576 	 * Use our calling technique to determine what object is associated
1577 	 * with the supplied address.  If a caller can't be determined,
1578 	 * indicate the failure.
1579 	 */
1580 	if ((clmp = _caller(addr, CL_NONE)) == NULL) {
1581 		eprintf(0, ERR_FATAL, MSG_INTL(MSG_ARG_INVADDR),
1582 		    EC_NATPTR(addr));
1583 		error = 0;
1584 	} else {
1585 		dladdr_core(clmp, addr, dlip, info, flags);
1586 		error = 1;
1587 	}
1588 
1589 	if (entry)
1590 		leave(0, 0);
1591 	return (error);
1592 }
1593 
1594 /*
1595  * Core dldump activity.
1596  */
1597 static int
1598 dldump_core(Lm_list *lml, const char *ipath, const char *opath, int flags)
1599 {
1600 	Addr	addr = 0;
1601 	Rt_map	*lmp;
1602 
1603 	/*
1604 	 * Verify any arguments first.
1605 	 */
1606 	if ((!opath || (*opath == '\0')) || (ipath && (*ipath == '\0'))) {
1607 		eprintf(lml, ERR_FATAL, MSG_INTL(MSG_ARG_ILLPATH));
1608 		return (1);
1609 	}
1610 
1611 	/*
1612 	 * If an input file is specified make sure its one of our dependencies
1613 	 * on the main link-map list.  Note, this has really all evolved for
1614 	 * crle(), which uses libcrle.so on an alternative link-map to trigger
1615 	 * dumping objects from the main link-map list.   If we ever want to
1616 	 * dump objects from alternative link-maps, this model is going to
1617 	 * have to be revisited.
1618 	 */
1619 	if (ipath) {
1620 		if ((lmp = is_so_loaded(&lml_main, ipath, NULL)) == NULL) {
1621 			eprintf(lml, ERR_FATAL, MSG_INTL(MSG_GEN_NOFILE),
1622 			    ipath);
1623 			return (1);
1624 		}
1625 		if (FLAGS(lmp) & FLG_RT_ALTER) {
1626 			eprintf(lml, ERR_FATAL, MSG_INTL(MSG_GEN_ALTER), ipath);
1627 			return (1);
1628 		}
1629 		if (FLAGS(lmp) & FLG_RT_NODUMP) {
1630 			eprintf(lml, ERR_FATAL, MSG_INTL(MSG_GEN_NODUMP),
1631 			    ipath);
1632 			return (1);
1633 		}
1634 	} else
1635 		lmp = lml_main.lm_head;
1636 
1637 
1638 	DBG_CALL(Dbg_file_dldump(lmp, opath, flags));
1639 
1640 	/*
1641 	 * If the object being dump'ed isn't fixed identify its mapping.
1642 	 */
1643 	if (!(FLAGS(lmp) & FLG_RT_FIXED))
1644 		addr = ADDR(lmp);
1645 
1646 	/*
1647 	 * As rt_dldump() will effectively lazy load the necessary support
1648 	 * libraries, make sure ld.so.1 is initialized for plt relocations.
1649 	 */
1650 	if (elf_rtld_load() == 0)
1651 		return (0);
1652 
1653 	/*
1654 	 * Dump the required image.
1655 	 */
1656 	return (rt_dldump(lmp, opath, flags, addr));
1657 }
1658 
1659 #pragma weak _dldump = dldump
1660 
1661 /*
1662  * External entry for dldump(3c).  Returns 0 on success, non-zero otherwise.
1663  */
1664 int
1665 dldump(const char *ipath, const char *opath, int flags)
1666 {
1667 	int	error, entry;
1668 	Rt_map	*clmp;
1669 
1670 	entry = enter(0);
1671 
1672 	clmp = _caller(caller(), CL_EXECDEF);
1673 
1674 	error = dldump_core(LIST(clmp), ipath, opath, flags);
1675 
1676 	if (entry)
1677 		leave(LIST(clmp), 0);
1678 	return (error);
1679 }
1680 
1681 /*
1682  * get_linkmap_id() translates Lm_list * pointers to the Link_map id as used by
1683  * the rtld_db and dlmopen() interfaces.  It checks to see if the Link_map is
1684  * one of the primary ones and if so returns it's special token:
1685  *		LM_ID_BASE
1686  *		LM_ID_LDSO
1687  *
1688  * If it's not one of the primary link_map id's it will instead returns a
1689  * pointer to the Lm_list structure which uniquely identifies the Link_map.
1690  */
1691 Lmid_t
1692 get_linkmap_id(Lm_list *lml)
1693 {
1694 	if (lml->lm_flags & LML_FLG_BASELM)
1695 		return (LM_ID_BASE);
1696 	if (lml->lm_flags & LML_FLG_RTLDLM)
1697 		return (LM_ID_LDSO);
1698 
1699 	return ((Lmid_t)lml);
1700 }
1701 
1702 /*
1703  * Extract information for a dlopen() handle.
1704  */
1705 static int
1706 dlinfo_core(void *handle, int request, void *p, Rt_map *clmp)
1707 {
1708 	Lm_list	*lml = LIST(clmp);
1709 	Rt_map	*lmp;
1710 
1711 	if ((request > RTLD_DI_MAX) || (p == NULL)) {
1712 		eprintf(lml, ERR_FATAL, MSG_INTL(MSG_ARG_ILLVAL));
1713 		return (-1);
1714 	}
1715 
1716 	/*
1717 	 * Return configuration cache name and address.
1718 	 */
1719 	if (request == RTLD_DI_CONFIGADDR) {
1720 		Dl_info_t	*dlip = (Dl_info_t *)p;
1721 
1722 		if ((config->c_name == NULL) || (config->c_bgn == 0) ||
1723 		    (config->c_end == 0)) {
1724 			eprintf(lml, ERR_FATAL, MSG_INTL(MSG_ARG_NOCONFIG));
1725 			return (-1);
1726 		}
1727 		dlip->dli_fname = config->c_name;
1728 		dlip->dli_fbase = (void *)config->c_bgn;
1729 		return (0);
1730 	}
1731 
1732 	/*
1733 	 * Return profiled object name (used by ldprof audit library).
1734 	 */
1735 	if (request == RTLD_DI_PROFILENAME) {
1736 		if (profile_name == NULL) {
1737 			eprintf(lml, ERR_FATAL, MSG_INTL(MSG_ARG_NOPROFNAME));
1738 			return (-1);
1739 		}
1740 
1741 		*(const char **)p = profile_name;
1742 		return (0);
1743 	}
1744 	if (request == RTLD_DI_PROFILEOUT) {
1745 		/*
1746 		 * If a profile destination directory hasn't been specified
1747 		 * provide a default.
1748 		 */
1749 		if (profile_out == NULL)
1750 			profile_out = MSG_ORIG(MSG_PTH_VARTMP);
1751 
1752 		*(const char **)p = profile_out;
1753 		return (0);
1754 	}
1755 
1756 	/*
1757 	 * Obtain or establish a termination signal.
1758 	 */
1759 	if (request == RTLD_DI_GETSIGNAL) {
1760 		*(int *)p = killsig;
1761 		return (0);
1762 	}
1763 
1764 	if (request == RTLD_DI_SETSIGNAL) {
1765 		sigset_t	set;
1766 		int		sig = *(int *)p;
1767 
1768 		/*
1769 		 * Determine whether the signal is in range.
1770 		 */
1771 		(void) sigfillset(&set);
1772 		if (sigismember(&set, sig) != 1) {
1773 			eprintf(lml, ERR_FATAL, MSG_INTL(MSG_ARG_INVSIG), sig);
1774 			return (-1);
1775 		}
1776 
1777 		killsig = sig;
1778 		return (0);
1779 	}
1780 
1781 	/*
1782 	 * For any other request a link-map is required.  Verify the handle.
1783 	 */
1784 	if (handle == RTLD_SELF)
1785 		lmp = clmp;
1786 	else {
1787 		Grp_hdl	*ghp = (Grp_hdl *)handle;
1788 
1789 		if (!hdl_validate(ghp)) {
1790 			eprintf(lml, ERR_FATAL, MSG_INTL(MSG_ARG_INVHNDL),
1791 			    EC_NATPTR(handle));
1792 			return (-1);
1793 		}
1794 		lmp = ghp->gh_ownlmp;
1795 	}
1796 
1797 	/*
1798 	 * Obtain the process arguments, environment and auxv.  Note, as the
1799 	 * environment can be modified by the user (putenv(3c)), reinitialize
1800 	 * the environment pointer on each request.
1801 	 */
1802 	if (request == RTLD_DI_ARGSINFO) {
1803 		Dl_argsinfo_t	*aip = (Dl_argsinfo_t *)p;
1804 		Lm_list		*lml = LIST(lmp);
1805 
1806 		*aip = argsinfo;
1807 		if (lml->lm_flags & LML_FLG_ENVIRON)
1808 			aip->dla_envp = *(lml->lm_environ);
1809 
1810 		return (0);
1811 	}
1812 
1813 	/*
1814 	 * Return Lmid_t of the Link-Map list that the specified object is
1815 	 * loaded on.
1816 	 */
1817 	if (request == RTLD_DI_LMID) {
1818 		*(Lmid_t *)p = get_linkmap_id(LIST(lmp));
1819 		return (0);
1820 	}
1821 
1822 	/*
1823 	 * Return a pointer to the Link-Map structure associated with the
1824 	 * specified object.
1825 	 */
1826 	if (request == RTLD_DI_LINKMAP) {
1827 		*(Link_map **)p = (Link_map *)lmp;
1828 		return (0);
1829 	}
1830 
1831 	/*
1832 	 * Return search path information, or the size of the buffer required
1833 	 * to store the information.
1834 	 */
1835 	if ((request == RTLD_DI_SERINFO) || (request == RTLD_DI_SERINFOSIZE)) {
1836 		Spath_desc	sd = { search_rules, NULL, 0 };
1837 		Pdesc		*pdp;
1838 		Dl_serinfo_t	*info;
1839 		Dl_serpath_t	*path;
1840 		char		*strs;
1841 		size_t		size = sizeof (Dl_serinfo_t);
1842 		uint_t		cnt = 0;
1843 
1844 		info = (Dl_serinfo_t *)p;
1845 		path = &info->dls_serpath[0];
1846 		strs = (char *)&info->dls_serpath[info->dls_cnt];
1847 
1848 		/*
1849 		 * Traverse search path entries for this object.
1850 		 */
1851 		while ((pdp = get_next_dir(&sd, lmp, 0)) != NULL) {
1852 			size_t	_size;
1853 
1854 			if (pdp->pd_pname == NULL)
1855 				continue;
1856 
1857 			/*
1858 			 * If configuration information exists, it's possible
1859 			 * this path has been identified as non-existent, if so
1860 			 * ignore it.
1861 			 */
1862 			if (pdp->pd_info) {
1863 				Rtc_obj	*dobj = (Rtc_obj *)pdp->pd_info;
1864 				if (dobj->co_flags & RTC_OBJ_NOEXIST)
1865 					continue;
1866 			}
1867 
1868 			/*
1869 			 * Keep track of search path count and total info size.
1870 			 */
1871 			if (cnt++)
1872 				size += sizeof (Dl_serpath_t);
1873 			_size = pdp->pd_plen + 1;
1874 			size += _size;
1875 
1876 			if (request == RTLD_DI_SERINFOSIZE)
1877 				continue;
1878 
1879 			/*
1880 			 * If we're filling in search path information, confirm
1881 			 * there's sufficient space.
1882 			 */
1883 			if (size > info->dls_size) {
1884 				eprintf(lml, ERR_FATAL,
1885 				    MSG_INTL(MSG_ARG_SERSIZE),
1886 				    EC_OFF(info->dls_size));
1887 				return (-1);
1888 			}
1889 			if (cnt > info->dls_cnt) {
1890 				eprintf(lml, ERR_FATAL,
1891 				    MSG_INTL(MSG_ARG_SERCNT), info->dls_cnt);
1892 				return (-1);
1893 			}
1894 
1895 			/*
1896 			 * Append the path to the information buffer.
1897 			 */
1898 			(void) strcpy(strs, pdp->pd_pname);
1899 			path->dls_name = strs;
1900 			path->dls_flags = pdp->pd_flags;
1901 
1902 			strs = strs + _size;
1903 			path++;
1904 		}
1905 
1906 		/*
1907 		 * If we're here to size the search buffer fill it in.
1908 		 */
1909 		if (request == RTLD_DI_SERINFOSIZE) {
1910 			info->dls_size = size;
1911 			info->dls_cnt = cnt;
1912 		}
1913 
1914 		return (0);
1915 	}
1916 
1917 	/*
1918 	 * Return the origin of the object associated with this link-map.
1919 	 * Basically return the dirname(1) of the objects fullpath.
1920 	 */
1921 	if (request == RTLD_DI_ORIGIN) {
1922 		char	*str = (char *)p;
1923 
1924 		(void) strncpy(str, ORIGNAME(lmp), DIRSZ(lmp));
1925 		str += DIRSZ(lmp);
1926 		*str = '\0';
1927 
1928 		return (0);
1929 	}
1930 
1931 	/*
1932 	 * Return the number of object mappings, or the mapping information for
1933 	 * this object.
1934 	 */
1935 	if (request == RTLD_DI_MMAPCNT) {
1936 		uint_t	*cnt = (uint_t *)p;
1937 
1938 		*cnt = MMAPCNT(lmp);
1939 		return (0);
1940 	}
1941 	if (request == RTLD_DI_MMAPS) {
1942 		Dl_mapinfo_t	*mip = (Dl_mapinfo_t *)p;
1943 
1944 		if (mip->dlm_acnt && mip->dlm_maps) {
1945 			uint_t	cnt = 0;
1946 
1947 			while ((cnt < mip->dlm_acnt) && (cnt < MMAPCNT(lmp))) {
1948 				mip->dlm_maps[cnt] = MMAPS(lmp)[cnt];
1949 				cnt++;
1950 			}
1951 			mip->dlm_rcnt = cnt;
1952 		}
1953 		return (0);
1954 	}
1955 
1956 	return (0);
1957 }
1958 
1959 #pragma weak _dlinfo = dlinfo
1960 
1961 /*
1962  * External entry for dlinfo(3dl).
1963  */
1964 int
1965 dlinfo(void *handle, int request, void *p)
1966 {
1967 	int	error, entry;
1968 	Rt_map	*clmp;
1969 
1970 	entry = enter(0);
1971 
1972 	clmp = _caller(caller(), CL_EXECDEF);
1973 
1974 	error = dlinfo_core(handle, request, p, clmp);
1975 
1976 	if (entry)
1977 		leave(LIST(clmp), 0);
1978 	return (error);
1979 }
1980