/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright (c) 1988 AT&T * All Rights Reserved * * Copyright (c) 1990, 2010, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 2012, Joyent, Inc. All rights reserved. */ /* * Programmatic interface to the run_time linker. */ #include <sys/debug.h> #include <stdio.h> #include <string.h> #include <dlfcn.h> #include <synch.h> #include <limits.h> #include <debug.h> #include <conv.h> #include "_rtld.h" #include "_audit.h" #include "_elf.h" #include "_inline_gen.h" #include "msg.h" /* * Determine who called us - given a pc determine in which object it resides. * * For dlopen() the link map of the caller must be passed to load_so() so that * the appropriate search rules (4.x or 5.0) are used to locate any * dependencies. Also, if we've been called from a 4.x module it may be * necessary to fix the specified pathname so that it conforms with the 5.0 elf * rules. * * For dlsym() the link map of the caller is used to determine RTLD_NEXT * requests, together with requests based off of a dlopen(0). * For dladdr() this routines provides a generic means of scanning all loaded * segments. */ Rt_map * _caller(caddr_t cpc, int flags) { Lm_list *lml; Aliste idx1; for (APLIST_TRAVERSE(dynlm_list, idx1, lml)) { Aliste idx2; Lm_cntl *lmc; for (ALIST_TRAVERSE(lml->lm_lists, idx2, lmc)) { Rt_map *lmp; for (lmp = lmc->lc_head; lmp; lmp = NEXT_RT_MAP(lmp)) { if (find_segment(cpc, lmp)) return (lmp); } } } /* * No mapping can be determined. If asked for a default, assume this * is from the executable. */ if (flags & CL_EXECDEF) return ((Rt_map *)lml_main.lm_head); return (0); } #pragma weak _dlerror = dlerror /* * External entry for dlerror(3C). Returns a pointer to the string describing * the last occurring error. The last occurring error is cleared. */ char * dlerror() { char *error; Rt_map *clmp; int entry; entry = enter(0); clmp = _caller(caller(), CL_EXECDEF); DBG_CALL(Dbg_dl_dlerror(clmp, lasterr)); error = lasterr; lasterr = NULL; if (entry) leave(LIST(clmp), 0); return (error); } /* * Add a dependency as a group descriptor to a group handle. Returns 0 on * failure. On success, returns the group descriptor, and if alep is non-NULL * the *alep is set to ALE_EXISTS if the dependency already exists, or to * ALE_CREATE if the dependency is newly created. */ Grp_desc * hdl_add(Grp_hdl *ghp, Rt_map *lmp, uint_t dflags, int *alep) { Grp_desc *gdp; Aliste idx; int ale = ALE_CREATE; uint_t oflags; /* * Make sure this dependency hasn't already been recorded. */ for (ALIST_TRAVERSE(ghp->gh_depends, idx, gdp)) { if (gdp->gd_depend == lmp) { ale = ALE_EXISTS; break; } } if (ale == ALE_CREATE) { Grp_desc gd; /* * Create a new handle descriptor. */ gd.gd_depend = lmp; gd.gd_flags = 0; /* * Indicate this object is a part of this handles group. */ if (aplist_append(&GROUPS(lmp), ghp, AL_CNT_GROUPS) == NULL) return (NULL); /* * Append the new dependency to this handle. */ if ((gdp = alist_append(&ghp->gh_depends, &gd, sizeof (Grp_desc), AL_CNT_DEPENDS)) == NULL) return (NULL); } oflags = gdp->gd_flags; gdp->gd_flags |= dflags; if (DBG_ENABLED) { if (ale == ALE_CREATE) { DBG_CALL(Dbg_file_hdl_action(ghp, lmp, DBG_DEP_ADD, gdp->gd_flags)); } else if (gdp->gd_flags != oflags) { DBG_CALL(Dbg_file_hdl_action(ghp, lmp, DBG_DEP_UPDATE, gdp->gd_flags)); } } if (alep) *alep = ale; return (gdp); } /* * Create a handle. * * rlmp - represents the reference link-map for which the handle is being * created. * clmp - represents the caller who is requesting the handle. * hflags - provide group handle flags (GPH_*) that affect the use of the * handle, such as dlopen(0), or use or use of RTLD_FIRST. * rdflags - provide group dependency flags for the reference link-map rlmp, * such as whether the dependency can be used for dlsym(), can be * relocated against, or whether this objects dependencies should * be processed. * cdflags - provide group dependency flags for the caller. */ Grp_hdl * hdl_create(Lm_list *lml, Rt_map *rlmp, Rt_map *clmp, uint_t hflags, uint_t rdflags, uint_t cdflags) { Grp_hdl *ghp = NULL, *aghp; APlist **alpp; Aliste idx; /* * For dlopen(0) the handle is maintained as part of the link-map list, * otherwise the handle is associated with the reference link-map. */ if (hflags & GPH_ZERO) alpp = &(lml->lm_handle); else alpp = &(HANDLES(rlmp)); /* * Objects can contain multiple handles depending on the handle flags * supplied. Most RTLD flags pertain to the object itself and the * bindings that it can achieve. Multiple handles for these flags * don't make sense. But if the flag determines how the handle might * be used, then multiple handles may exist. Presently this only makes * sense for RTLD_FIRST. Determine if an appropriate handle already * exists. */ for (APLIST_TRAVERSE(*alpp, idx, aghp)) { if ((aghp->gh_flags & GPH_FIRST) == (hflags & GPH_FIRST)) { ghp = aghp; break; } } if (ghp == NULL) { uint_t ndx; /* * If this is the first request for this handle, allocate and * initialize a new handle. */ DBG_CALL(Dbg_file_hdl_title(DBG_HDL_CREATE)); if ((ghp = malloc(sizeof (Grp_hdl))) == NULL) return (NULL); /* * Associate the handle with the link-map list or the reference * link-map as appropriate. */ if (aplist_append(alpp, ghp, AL_CNT_GROUPS) == NULL) { free(ghp); return (NULL); } /* * Record the existence of this handle for future verification. */ /* LINTED */ ndx = (uintptr_t)ghp % HDLIST_SZ; if (aplist_append(&hdl_alp[ndx], ghp, AL_CNT_HANDLES) == NULL) { (void) aplist_delete_value(*alpp, ghp); free(ghp); return (NULL); } ghp->gh_depends = NULL; ghp->gh_refcnt = 1; ghp->gh_flags = hflags; /* * A dlopen(0) handle is identified by the GPH_ZERO flag, the * head of the link-map list is defined as the owner. There is * no need to maintain a list of dependencies, for when this * handle is used (for dlsym()) a dynamic search through the * entire link-map list provides for searching all objects with * GLOBAL visibility. */ if (hflags & GPH_ZERO) { ghp->gh_ownlmp = lml->lm_head; ghp->gh_ownlml = lml; } else { ghp->gh_ownlmp = rlmp; ghp->gh_ownlml = LIST(rlmp); if (hdl_add(ghp, rlmp, rdflags, NULL) == NULL) return (NULL); /* * If this new handle is a private handle, there's no * need to track the caller, so we're done. */ if (hflags & GPH_PRIVATE) return (ghp); /* * If this new handle is public, and isn't a special * handle representing ld.so.1, indicate that a local * group now exists. This state allows singleton * searches to be optimized. */ if ((hflags & GPH_LDSO) == 0) LIST(rlmp)->lm_flags |= LML_FLG_GROUPSEXIST; } } else { /* * If a handle already exists, bump its reference count. * * If the previous reference count was 0, then this is a handle * that an earlier call to dlclose() was unable to remove. Such * handles are put on the orphan list. As this handle is back * in use, it must be removed from the orphan list. * * Note, handles associated with a link-map list itself (i.e. * dlopen(0)) can have a reference count of 0. However, these * handles are never deleted, and therefore are never moved to * the orphan list. */ if ((ghp->gh_refcnt++ == 0) && ((ghp->gh_flags & GPH_ZERO) == 0)) { uint_t ndx; /* LINTED */ ndx = (uintptr_t)ghp % HDLIST_SZ; (void) aplist_delete_value(hdl_alp[HDLIST_ORP], ghp); (void) aplist_append(&hdl_alp[ndx], ghp, AL_CNT_HANDLES); if (DBG_ENABLED) { Aliste idx; Grp_desc *gdp; DBG_CALL(Dbg_file_hdl_title(DBG_HDL_REINST)); for (ALIST_TRAVERSE(ghp->gh_depends, idx, gdp)) DBG_CALL(Dbg_file_hdl_action(ghp, gdp->gd_depend, DBG_DEP_REINST, 0)); } } /* * If we've been asked to create a private handle, there's no * need to track the caller. */ if (hflags & GPH_PRIVATE) { /* * Negate the reference count increment. */ ghp->gh_refcnt--; return (ghp); } else { /* * If a private handle already exists, promote this * handle to public by initializing both the reference * count and the handle flags. */ if (ghp->gh_flags & GPH_PRIVATE) { ghp->gh_refcnt = 1; ghp->gh_flags &= ~GPH_PRIVATE; ghp->gh_flags |= hflags; } } } /* * Keep track of the parent (caller). As this object can be referenced * by different parents, this processing is carried out every time a * handle is requested. */ if (clmp && (hdl_add(ghp, clmp, cdflags, NULL) == NULL)) return (NULL); return (ghp); } /* * Initialize a handle that has been created for an object that is already * loaded. The handle is initialized with the present dependencies of that * object. Once this initialization has occurred, any new objects that might * be loaded as dependencies (lazy-loading) are added to the handle as each new * object is loaded. */ int hdl_initialize(Grp_hdl *ghp, Rt_map *nlmp, int mode, int promote) { Aliste idx; Grp_desc *gdp; /* * If the handle has already been initialized, and the initial object's * mode hasn't been promoted, there's no need to recompute the modes of * any dependencies. If the object we've added has just been opened, * the objects dependencies will not yet have been processed. These * dependencies will be added on later calls to load_one(). Otherwise, * this object already exists, so add all of its dependencies to the * handle were operating on. */ if (((ghp->gh_flags & GPH_INITIAL) && (promote == 0)) || ((FLAGS(nlmp) & FLG_RT_ANALYZED) == 0)) { ghp->gh_flags |= GPH_INITIAL; return (1); } DBG_CALL(Dbg_file_hdl_title(DBG_HDL_ADD)); for (ALIST_TRAVERSE(ghp->gh_depends, idx, gdp)) { Rt_map *lmp = gdp->gd_depend; Aliste idx1; Bnd_desc *bdp; /* * If this dependency doesn't indicate that its dependencies * should be added to a handle, ignore it. This case identifies * a parent of a dlopen(RTLD_PARENT) request. */ if ((gdp->gd_flags & GPD_ADDEPS) == 0) continue; for (APLIST_TRAVERSE(DEPENDS(lmp), idx1, bdp)) { Rt_map *dlmp = bdp->b_depend; if ((bdp->b_flags & BND_NEEDED) == 0) continue; if (hdl_add(ghp, dlmp, (GPD_DLSYM | GPD_RELOC | GPD_ADDEPS), NULL) == NULL) return (0); (void) update_mode(dlmp, MODE(dlmp), mode); } } ghp->gh_flags |= GPH_INITIAL; return (1); } /* * Sanity check a program-provided handle. */ static int hdl_validate(Grp_hdl *ghp) { Aliste idx; Grp_hdl *lghp; uint_t ndx; /* LINTED */ ndx = (uintptr_t)ghp % HDLIST_SZ; for (APLIST_TRAVERSE(hdl_alp[ndx], idx, lghp)) { if ((lghp == ghp) && (ghp->gh_refcnt != 0)) return (1); } return (0); } /* * Core dlclose activity. */ int dlclose_core(Grp_hdl *ghp, Rt_map *clmp, Lm_list *lml) { int error; Rt_map *lmp; /* * If we're already at atexit() there's no point processing further, * all objects have already been tsorted for fini processing. */ if (rtld_flags & RT_FL_ATEXIT) return (0); /* * Diagnose what we're up to. */ if (ghp->gh_flags & GPH_ZERO) { DBG_CALL(Dbg_dl_dlclose(clmp, MSG_ORIG(MSG_STR_ZERO), DBG_DLCLOSE_IGNORE)); } else { DBG_CALL(Dbg_dl_dlclose(clmp, NAME(ghp->gh_ownlmp), DBG_DLCLOSE_NULL)); } /* * Decrement reference count of this object. */ if (--(ghp->gh_refcnt)) return (0); /* * If this handle is special (dlopen(0)), then leave it around - it * has little overhead. */ if (ghp->gh_flags & GPH_ZERO) return (0); /* * If this handle is associated with an object that is not on the base * link-map control list, or it has not yet been relocated, then this * handle must have originated from an auditors interaction, or some * permutation of RTLD_CONFGEN use (crle(1), moe(1), etc.). User code * can only execute and bind to relocated objects on the base link-map * control list. Outside of RTLD_CONFGEN use, a non-relocated object, * or an object on a non-base link-map control list, is in the process * of being loaded, and therefore we do not attempt to remove the * handle. */ if (((lmp = ghp->gh_ownlmp) != NULL) && ((MODE(lmp) & RTLD_CONFGEN) == 0) && ((CNTL(lmp) != ALIST_OFF_DATA) || ((FLAGS(lmp) & FLG_RT_RELOCED) == 0))) return (0); /* * This handle is no longer being referenced, remove it. If this handle * is part of an alternative link-map list, determine if the whole list * can be removed also. */ error = remove_hdl(ghp, clmp, NULL); if ((lml->lm_flags & (LML_FLG_BASELM | LML_FLG_RTLDLM)) == 0) remove_lml(lml); return (error); } /* * Internal dlclose activity. Called from user level or directly for internal * error cleanup. */ int dlclose_intn(Grp_hdl *ghp, Rt_map *clmp) { Rt_map *nlmp = NULL; Lm_list *olml = NULL; int error; /* * Although we're deleting object(s) it's quite possible that additional * objects get loaded from running the .fini section(s) of the objects * being deleted. These objects will have been added to the same * link-map list as those objects being deleted. Remember this list * for later investigation. */ olml = ghp->gh_ownlml; error = dlclose_core(ghp, clmp, olml); /* * Determine whether the original link-map list still exists. In the * case of a dlclose of an alternative (dlmopen) link-map the whole * list may have been removed. */ if (olml) { Aliste idx; Lm_list *lml; for (APLIST_TRAVERSE(dynlm_list, idx, lml)) { if (olml == lml) { nlmp = olml->lm_head; break; } } } load_completion(nlmp); return (error); } /* * Argument checking for dlclose. Only called via external entry. */ static int dlclose_check(void *handle, Rt_map *clmp) { Grp_hdl *ghp = (Grp_hdl *)handle; if (hdl_validate(ghp) == 0) { Conv_inv_buf_t inv_buf; (void) conv_invalid_val(&inv_buf, EC_NATPTR(ghp), 0); DBG_CALL(Dbg_dl_dlclose(clmp, inv_buf.buf, DBG_DLCLOSE_NULL)); eprintf(LIST(clmp), ERR_FATAL, MSG_INTL(MSG_ARG_INVHNDL), EC_NATPTR(handle)); return (1); } return (dlclose_intn(ghp, clmp)); } #pragma weak _dlclose = dlclose /* * External entry for dlclose(3C). Returns 0 for success, non-zero otherwise. */ int dlclose(void *handle) { int error, entry; Rt_map *clmp; entry = enter(0); clmp = _caller(caller(), CL_EXECDEF); error = dlclose_check(handle, clmp); if (entry) leave(LIST(clmp), 0); return (error); } static uint_t lmid = 0; /* * The addition of new link-map lists is assumed to be in small quantities. * Here, we assign a unique link-map id for diagnostic use. Simply update the * running link-map count until we max out. */ int newlmid(Lm_list *lml) { char buffer[MSG_LMID_ALT_SIZE + 12]; if (lmid == UINT_MAX) { lml->lm_lmid = UINT_MAX; (void) strncpy(buffer, MSG_ORIG(MSG_LMID_MAXED), MSG_LMID_ALT_SIZE + 12); } else { lml->lm_lmid = lmid++; (void) snprintf(buffer, MSG_LMID_ALT_SIZE + 12, MSG_ORIG(MSG_LMID_FMT), MSG_ORIG(MSG_LMID_ALT), lml->lm_lmid); } if ((lml->lm_lmidstr = strdup(buffer)) == NULL) return (0); return (1); } /* * Core dlopen activity. */ static Grp_hdl * dlmopen_core(Lm_list *lml, Lm_list *olml, const char *path, int mode, Rt_map *clmp, uint_t flags, uint_t orig, int *in_nfavl) { Alist *palp = NULL; Rt_map *nlmp; Grp_hdl *ghp; Aliste olmco, nlmco; DBG_CALL(Dbg_dl_dlopen(clmp, (path ? path : MSG_ORIG(MSG_STR_ZERO)), in_nfavl, mode)); /* * Having diagnosed the originally defined modes, assign any defaults * or corrections. */ if (((mode & (RTLD_GROUP | RTLD_WORLD)) == 0) && ((mode & RTLD_NOLOAD) == 0)) mode |= (RTLD_GROUP | RTLD_WORLD); if ((mode & RTLD_NOW) && (rtld_flags2 & RT_FL2_BINDLAZY)) { mode &= ~RTLD_NOW; mode |= RTLD_LAZY; } /* * If the path specified is null then we're operating on global * objects. Associate a dummy handle with the link-map list. */ if (path == NULL) { Grp_hdl *ghp; uint_t hflags, rdflags, cdflags; int promote = 0; /* * Establish any flags for the handle (Grp_hdl). * * - This is a dummy, public, handle (0) that provides for a * dynamic search of all global objects within the process. * - Use of the RTLD_FIRST mode indicates that only the first * dependency on the handle (the referenced object) can be * used to satisfy dlsym() requests. */ hflags = (GPH_PUBLIC | GPH_ZERO); if (mode & RTLD_FIRST) hflags |= GPH_FIRST; /* * Establish the flags for the referenced dependency descriptor * (Grp_desc). * * - The referenced object is available for dlsym(). * - The referenced object is available to relocate against. * - The referenced object should have it's dependencies * added to this handle. */ rdflags = (GPD_DLSYM | GPD_RELOC | GPD_ADDEPS); /* * Establish the flags for this callers dependency descriptor * (Grp_desc). * * - The explicit creation of a handle creates a descriptor * for the referenced object and the parent (caller). * - Use of the RTLD_PARENT flag indicates that the parent * can be relocated against. */ cdflags = GPD_PARENT; if (mode & RTLD_PARENT) cdflags |= GPD_RELOC; if ((ghp = hdl_create(lml, 0, clmp, hflags, rdflags, cdflags)) == NULL) return (NULL); /* * Traverse the main link-map control list, updating the mode * of any objects as necessary. Call the relocation engine if * this mode promotes the existing state of any relocations. * crle()'s first pass loads all objects necessary for building * a configuration file, however none of them are relocated. * crle()'s second pass relocates objects in preparation for * dldump()'ing using dlopen(0, RTLD_NOW). */ if ((mode & (RTLD_NOW | RTLD_CONFGEN)) == RTLD_CONFGEN) return (ghp); for (nlmp = lml->lm_head; nlmp; nlmp = NEXT_RT_MAP(nlmp)) { if (((MODE(nlmp) & RTLD_GLOBAL) == 0) || (FLAGS(nlmp) & FLG_RT_DELETE)) continue; if (update_mode(nlmp, MODE(nlmp), mode)) promote = 1; } if (promote) (void) relocate_lmc(lml, ALIST_OFF_DATA, clmp, lml->lm_head, in_nfavl); return (ghp); } /* * Fix the pathname. If this object expands to multiple paths (ie. * $ISALIST or $HWCAP have been used), then make sure the user has also * furnished the RTLD_FIRST flag. As yet, we don't support opening * more than one object at a time, so enforcing the RTLD_FIRST flag * provides flexibility should we be able to support dlopening more * than one object in the future. */ if (LM_FIX_NAME(clmp)(path, clmp, &palp, AL_CNT_NEEDED, orig) == 0) return (NULL); if ((palp->al_arritems > 1) && ((mode & RTLD_FIRST) == 0)) { remove_alist(&palp, 1); eprintf(lml, ERR_FATAL, MSG_INTL(MSG_ARG_ILLMODE_5)); return (NULL); } /* * Establish a link-map control list for this request, and load the * associated object. */ if ((nlmco = create_cntl(lml, 1)) == 0) { remove_alist(&palp, 1); return (NULL); } olmco = nlmco; nlmp = load_one(lml, nlmco, palp, clmp, mode, (flags | FLG_RT_PUBHDL), &ghp, in_nfavl); /* * Remove any expanded pathname infrastructure, and if the dependency * couldn't be loaded, cleanup. */ remove_alist(&palp, 1); if (nlmp == NULL) { remove_cntl(lml, olmco); return (NULL); } /* * If loading an auditor was requested, and the auditor already existed, * then the link-map returned will be to the original auditor. The new * link-map list that was initially created, and the associated link-map * control list are no longer needed. As the auditor is already loaded, * we're probably done, but fall through in case additional relocations * would be triggered by the mode of the caller. */ if ((flags & FLG_RT_AUDIT) && (LIST(nlmp) != lml)) { remove_cntl(lml, olmco); lml = LIST(nlmp); olmco = 0; nlmco = ALIST_OFF_DATA; } /* * Finish processing the objects associated with this request. */ if (((nlmp = analyze_lmc(lml, nlmco, nlmp, clmp, in_nfavl)) == NULL) || (relocate_lmc(lml, nlmco, clmp, nlmp, in_nfavl) == 0)) { ghp = NULL; nlmp = NULL; } /* * If the dlopen has failed, clean up any objects that might have been * loaded successfully on this new link-map control list. */ if (olmco && (nlmp == NULL)) remove_lmc(lml, clmp, olmco, path); /* * Finally, remove any temporary link-map control list. Note, if this * operation successfully established a new link-map list, then a base * link-map control list will have been created, which must remain. */ if (olmco && ((nlmp == NULL) || (olml != (Lm_list *)LM_ID_NEWLM))) remove_cntl(lml, olmco); return (ghp); } /* * dlopen() and dlsym() operations are the means by which a process can * test for the existence of required dependencies. If the necessary * dependencies don't exist, then associated functionality can't be used. * However, the lack of dependencies can be fixed, and the dlopen() and * dlsym() requests can be repeated. As we use a "not-found" AVL tree to * cache any failed full path loads, secondary dlopen() and dlsym() requests * will fail, even if the dependencies have been installed. * * dlopen() and dlsym() retry any failures by removing the "not-found" AVL * tree. Should any dependencies be found, their names are added to the * FullPath AVL tree. This routine removes any new "not-found" AVL tree, * so that the dlopen() or dlsym() can replace the original "not-found" tree. */ inline static void nfavl_remove(avl_tree_t *avlt) { PathNode *pnp; void *cookie = NULL; if (avlt) { while ((pnp = avl_destroy_nodes(avlt, &cookie)) != NULL) free(pnp); avl_destroy(avlt); free(avlt); } } /* * Internal dlopen() activity. Called from user level or directly for internal * opens that require a handle. */ Grp_hdl * dlmopen_intn(Lm_list *lml, const char *path, int mode, Rt_map *clmp, uint_t flags, uint_t orig) { Lm_list *olml = lml; Rt_map *dlmp = NULL; Grp_hdl *ghp; int in_nfavl = 0; /* * Check for magic link-map list values: * * LM_ID_BASE: Operate on the PRIMARY (executables) link map * LM_ID_LDSO: Operation on ld.so.1's link map * LM_ID_NEWLM: Create a new link-map. */ if (lml == (Lm_list *)LM_ID_NEWLM) { if ((lml = calloc(1, sizeof (Lm_list))) == NULL) return (NULL); /* * Establish the new link-map flags from the callers and those * explicitly provided. */ lml->lm_tflags = LIST(clmp)->lm_tflags; if (flags & FLG_RT_AUDIT) { /* * Unset any auditing flags - an auditor shouldn't be * audited. Insure all audit dependencies are loaded. */ lml->lm_tflags &= ~LML_TFLG_AUD_MASK; lml->lm_tflags |= (LML_TFLG_NOLAZYLD | LML_TFLG_LOADFLTR | LML_TFLG_NOAUDIT); } if (aplist_append(&dynlm_list, lml, AL_CNT_DYNLIST) == NULL) { free(lml); return (NULL); } if (newlmid(lml) == 0) { (void) aplist_delete_value(dynlm_list, lml); free(lml); return (NULL); } } else if ((uintptr_t)lml < LM_ID_NUM) { if ((uintptr_t)lml == LM_ID_BASE) lml = &lml_main; else if ((uintptr_t)lml == LM_ID_LDSO) lml = &lml_rtld; } /* * Open the required object on the associated link-map list. */ ghp = dlmopen_core(lml, olml, path, mode, clmp, flags, orig, &in_nfavl); /* * If the object could not be found it is possible that the "not-found" * AVL tree had indicated that the file does not exist. In case the * file system has changed since this "not-found" recording was made, * retry the dlopen() with a clean "not-found" AVL tree. */ if ((ghp == NULL) && in_nfavl) { avl_tree_t *oavlt = nfavl; nfavl = NULL; ghp = dlmopen_core(lml, olml, path, mode, clmp, flags, orig, NULL); /* * If the file is found, then its full path name will have been * registered in the FullPath AVL tree. Remove any new * "not-found" AVL information, and restore the former AVL tree. */ nfavl_remove(nfavl); nfavl = oavlt; } /* * Establish the new link-map from which .init processing will begin. * Ignore .init firing when constructing a configuration file (crle(1)). */ if (ghp && ((mode & RTLD_CONFGEN) == 0)) dlmp = ghp->gh_ownlmp; /* * If loading an auditor was requested, and the auditor already existed, * then the link-map returned will be to the original auditor. Remove * the link-map control list that was created for this request. */ if (dlmp && (flags & FLG_RT_AUDIT) && (LIST(dlmp) != lml)) { remove_lml(lml); lml = LIST(dlmp); } /* * If this load failed, remove any alternative link-map list. */ if ((ghp == NULL) && ((lml->lm_flags & (LML_FLG_BASELM | LML_FLG_RTLDLM)) == 0)) { remove_lml(lml); lml = NULL; } /* * Finish this load request. If objects were loaded, .init processing * is computed. Finally, the debuggers are informed of the link-map * lists being stable. */ load_completion(dlmp); return (ghp); } /* * Argument checking for dlopen. Only called via external entry. */ static Grp_hdl * dlmopen_check(Lm_list *lml, const char *path, int mode, Rt_map *clmp) { /* * Verify that a valid pathname has been supplied. */ if (path && (*path == '\0')) { eprintf(lml, ERR_FATAL, MSG_INTL(MSG_ARG_ILLPATH)); return (0); } /* * Historically we've always verified the mode is either RTLD_NOW or * RTLD_LAZY. RTLD_NOLOAD is valid by itself. Use of LM_ID_NEWLM * requires a specific pathname, and use of RTLD_PARENT is meaningless. */ if ((mode & (RTLD_NOW | RTLD_LAZY | RTLD_NOLOAD)) == 0) { eprintf(lml, ERR_FATAL, MSG_INTL(MSG_ARG_ILLMODE_1)); return (0); } if ((mode & (RTLD_NOW | RTLD_LAZY)) == (RTLD_NOW | RTLD_LAZY)) { eprintf(lml, ERR_FATAL, MSG_INTL(MSG_ARG_ILLMODE_2)); return (0); } if ((lml == (Lm_list *)LM_ID_NEWLM) && (path == NULL)) { eprintf(lml, ERR_FATAL, MSG_INTL(MSG_ARG_ILLMODE_3)); return (0); } if ((lml == (Lm_list *)LM_ID_NEWLM) && (mode & RTLD_PARENT)) { eprintf(lml, ERR_FATAL, MSG_INTL(MSG_ARG_ILLMODE_4)); return (0); } return (dlmopen_intn(lml, path, mode, clmp, 0, 0)); } #pragma weak _dlopen = dlopen /* * External entry for dlopen(3C). On success, returns a pointer (handle) to * the structure containing information about the newly added object, ie. can * be used by dlsym(). On failure, returns a null pointer. */ void * dlopen(const char *path, int mode) { int entry; Rt_map *clmp; Grp_hdl *ghp; Lm_list *lml; entry = enter(0); clmp = _caller(caller(), CL_EXECDEF); lml = LIST(clmp); ghp = dlmopen_check(lml, path, mode, clmp); if (entry) leave(lml, 0); return ((void *)ghp); } #pragma weak _dlmopen = dlmopen /* * External entry for dlmopen(3C). */ void * dlmopen(Lmid_t lmid, const char *path, int mode) { int entry; Rt_map *clmp; Grp_hdl *ghp; entry = enter(0); clmp = _caller(caller(), CL_EXECDEF); ghp = dlmopen_check((Lm_list *)lmid, path, mode, clmp); if (entry) leave(LIST(clmp), 0); return ((void *)ghp); } /* * Handle processing for dlsym. */ int dlsym_handle(Grp_hdl *ghp, Slookup *slp, Sresult *srp, uint_t *binfo, int *in_nfavl) { Rt_map *nlmp, * lmp = ghp->gh_ownlmp; Rt_map *clmp = slp->sl_cmap; const char *name = slp->sl_name; Slookup sl = *slp; sl.sl_flags = (LKUP_FIRST | LKUP_DLSYM | LKUP_SPEC); /* * Continue processing a dlsym request. Lookup the required symbol in * each link-map specified by the handle. * * To leverage off of lazy loading, dlsym() requests can result in two * passes. The first descends the link-maps of any objects already in * the address space. If the symbol isn't located, and lazy * dependencies still exist, then a second pass is made to load these * dependencies if applicable. This model means that in the case where * a symbol exists in more than one object, the one located may not be * constant - this is the standard issue with lazy loading. In addition, * attempting to locate a symbol that doesn't exist will result in the * loading of all lazy dependencies on the given handle, which can * defeat some of the advantages of lazy loading (look out JVM). */ if (ghp->gh_flags & GPH_ZERO) { Lm_list *lml; uint_t lazy = 0; /* * If this symbol lookup is triggered from a dlopen(0) handle, * traverse the present link-map list looking for promiscuous * entries. */ for (nlmp = lmp; nlmp; nlmp = NEXT_RT_MAP(nlmp)) { /* * If this handle indicates we're only to look in the * first object check whether we're done. */ if ((nlmp != lmp) && (ghp->gh_flags & GPH_FIRST)) return (0); if (!(MODE(nlmp) & RTLD_GLOBAL)) continue; if ((FLAGS(nlmp) & FLG_RT_DELETE) && ((FLAGS(clmp) & FLG_RT_DELETE) == 0)) continue; sl.sl_imap = nlmp; if (LM_LOOKUP_SYM(clmp)(&sl, srp, binfo, in_nfavl)) return (1); /* * Keep track of any global pending lazy loads. */ lazy += LAZY(nlmp); } /* * If we're unable to locate the symbol and this link-map list * still has pending lazy dependencies, start loading them in an * attempt to exhaust the search. Note that as we're already * traversing a dynamic linked list of link-maps there's no * need for elf_lazy_find_sym() to descend the link-maps itself. */ lml = LIST(lmp); if (lazy) { DBG_CALL(Dbg_syms_lazy_rescan(lml, name)); sl.sl_flags |= LKUP_NODESCENT; for (nlmp = lmp; nlmp; nlmp = NEXT_RT_MAP(nlmp)) { if (!(MODE(nlmp) & RTLD_GLOBAL) || !LAZY(nlmp)) continue; if ((FLAGS(nlmp) & FLG_RT_DELETE) && ((FLAGS(clmp) & FLG_RT_DELETE) == 0)) continue; sl.sl_imap = nlmp; if (elf_lazy_find_sym(&sl, srp, binfo, in_nfavl)) return (1); } } } else { /* * Traverse the dlopen() handle searching all presently loaded * link-maps. */ Grp_desc *gdp; Aliste idx; uint_t lazy = 0; for (ALIST_TRAVERSE(ghp->gh_depends, idx, gdp)) { nlmp = gdp->gd_depend; if ((gdp->gd_flags & GPD_DLSYM) == 0) continue; sl.sl_imap = nlmp; if (LM_LOOKUP_SYM(clmp)(&sl, srp, binfo, in_nfavl)) return (1); if (ghp->gh_flags & GPH_FIRST) return (0); /* * Keep track of any pending lazy loads associated * with this handle. */ lazy += LAZY(nlmp); } /* * If we're unable to locate the symbol and this handle still * has pending lazy dependencies, start loading the lazy * dependencies, in an attempt to exhaust the search. */ if (lazy) { DBG_CALL(Dbg_syms_lazy_rescan(LIST(lmp), name)); for (ALIST_TRAVERSE(ghp->gh_depends, idx, gdp)) { nlmp = gdp->gd_depend; if (((gdp->gd_flags & GPD_DLSYM) == 0) || (LAZY(nlmp) == 0)) continue; sl.sl_imap = nlmp; if (elf_lazy_find_sym(&sl, srp, binfo, in_nfavl)) return (1); } } } return (0); } /* * Determine whether a symbol resides in a caller. This may be a reference, * which is associated with a specific dependency. */ inline static Sym * sym_lookup_in_caller(Rt_map *clmp, Slookup *slp, Sresult *srp, uint_t *binfo) { if (THIS_IS_ELF(clmp) && SYMINTP(clmp)(slp, srp, binfo, NULL)) { Sym *sym = srp->sr_sym; slp->sl_rsymndx = (((ulong_t)sym - (ulong_t)SYMTAB(clmp)) / SYMENT(clmp)); slp->sl_rsym = sym; return (sym); } return (NULL); } /* * Core dlsym activity. Selects symbol lookup method from handle. */ static void * dlsym_core(void *handle, const char *name, Rt_map *clmp, Rt_map **dlmp, int *in_nfavl) { Sym *sym; int ret = 0; Syminfo *sip; Slookup sl; Sresult sr; uint_t binfo; /* * Initialize the symbol lookup data structure. * * Standard relocations are evaluated using the symbol index of the * associated relocation symbol. This index provides for loading * any lazy dependency and establishing a direct binding if necessary. * If a dlsym() operation originates from an object that contains a * symbol table entry for the same name, then we need to establish the * symbol index so that any dependency requirements can be triggered. * * Therefore, the first symbol lookup that is carried out is for the * symbol name within the calling object. If this symbol exists, the * symbols index is computed, added to the Slookup data, and thus used * to seed the real symbol lookup. */ SLOOKUP_INIT(sl, name, clmp, clmp, ld_entry_cnt, elf_hash(name), 0, 0, 0, LKUP_SYMNDX); SRESULT_INIT(sr, name); sym = sym_lookup_in_caller(clmp, &sl, &sr, &binfo); SRESULT_INIT(sr, name); if (sym && (ELF_ST_VISIBILITY(sym->st_other) == STV_SINGLETON)) { Rt_map *hlmp = LIST(clmp)->lm_head; /* * If a symbol reference is known, and that reference indicates * that the symbol is a singleton, then the search for the * symbol must follow the default search path. */ DBG_CALL(Dbg_dl_dlsym(clmp, name, in_nfavl, 0, DBG_DLSYM_SINGLETON)); sl.sl_imap = hlmp; if (handle == RTLD_PROBE) sl.sl_flags = LKUP_NOFALLBACK; else sl.sl_flags = LKUP_SPEC; ret = LM_LOOKUP_SYM(clmp)(&sl, &sr, &binfo, in_nfavl); } else if (handle == RTLD_NEXT) { Rt_map *nlmp; /* * If this handle is RTLD_NEXT determine whether a lazy load * from the caller might provide the next object. This mimics * the lazy loading initialization normally carried out by * lookup_sym(), however here, we must do this up-front, as * lookup_sym() will be used to inspect the next object. */ if ((sl.sl_rsymndx) && ((sip = SYMINFO(clmp)) != NULL)) { /* LINTED */ sip = (Syminfo *)((char *)sip + (sl.sl_rsymndx * SYMINENT(clmp))); if ((sip->si_flags & SYMINFO_FLG_DIRECT) && (sip->si_boundto < SYMINFO_BT_LOWRESERVE)) (void) elf_lazy_load(clmp, &sl, sip->si_boundto, name, 0, NULL, in_nfavl); /* * Clear the symbol index, so as not to confuse * lookup_sym() of the next object. */ sl.sl_rsymndx = 0; sl.sl_rsym = NULL; } /* * If the handle is RTLD_NEXT, start searching in the next link * map from the callers. Determine permissions from the * present link map. Indicate to lookup_sym() that we're on an * RTLD_NEXT request so that it will use the callers link map to * start any possible lazy dependency loading. */ sl.sl_imap = nlmp = NEXT_RT_MAP(clmp); DBG_CALL(Dbg_dl_dlsym(clmp, name, in_nfavl, (nlmp ? NAME(nlmp) : MSG_INTL(MSG_STR_NULL)), DBG_DLSYM_NEXT)); if (nlmp == NULL) return (0); sl.sl_flags = LKUP_NEXT; ret = LM_LOOKUP_SYM(clmp)(&sl, &sr, &binfo, in_nfavl); } else if (handle == RTLD_SELF) { /* * If the handle is RTLD_SELF start searching from the caller. */ DBG_CALL(Dbg_dl_dlsym(clmp, name, in_nfavl, NAME(clmp), DBG_DLSYM_SELF)); sl.sl_imap = clmp; sl.sl_flags = (LKUP_SPEC | LKUP_SELF); ret = LM_LOOKUP_SYM(clmp)(&sl, &sr, &binfo, in_nfavl); } else if (handle == RTLD_DEFAULT) { Rt_map *hlmp = LIST(clmp)->lm_head; /* * If the handle is RTLD_DEFAULT mimic the standard symbol * lookup as would be triggered by a relocation. */ DBG_CALL(Dbg_dl_dlsym(clmp, name, in_nfavl, 0, DBG_DLSYM_DEFAULT)); sl.sl_imap = hlmp; sl.sl_flags = LKUP_SPEC; ret = LM_LOOKUP_SYM(clmp)(&sl, &sr, &binfo, in_nfavl); } else if (handle == RTLD_PROBE) { Rt_map *hlmp = LIST(clmp)->lm_head; /* * If the handle is RTLD_PROBE, mimic the standard symbol * lookup as would be triggered by a relocation, however do * not fall back to a lazy loading rescan if the symbol can't be * found within the currently loaded objects. Note, a lazy * loaded dependency required by the caller might still get * loaded to satisfy this request, but no exhaustive lazy load * rescan is carried out. */ DBG_CALL(Dbg_dl_dlsym(clmp, name, in_nfavl, 0, DBG_DLSYM_PROBE)); sl.sl_imap = hlmp; sl.sl_flags = LKUP_NOFALLBACK; ret = LM_LOOKUP_SYM(clmp)(&sl, &sr, &binfo, in_nfavl); } else { Grp_hdl *ghp = (Grp_hdl *)handle; /* * Look in the shared object specified by the handle and in all * of its dependencies. */ DBG_CALL(Dbg_dl_dlsym(clmp, name, in_nfavl, NAME(ghp->gh_ownlmp), DBG_DLSYM_DEF)); ret = LM_DLSYM(clmp)(ghp, &sl, &sr, &binfo, in_nfavl); } if (ret && ((sym = sr.sr_sym) != NULL)) { Lm_list *lml = LIST(clmp); Addr addr = sym->st_value; *dlmp = sr.sr_dmap; if (!(FLAGS(*dlmp) & FLG_RT_FIXED)) addr += ADDR(*dlmp); /* * Indicate that the defining object is now used. */ if (*dlmp != clmp) FLAGS1(*dlmp) |= FL1_RT_USED; DBG_CALL(Dbg_bind_global(clmp, 0, 0, (Xword)-1, PLT_T_NONE, *dlmp, addr, sym->st_value, sr.sr_name, binfo)); if ((lml->lm_tflags | AFLAGS(clmp) | AFLAGS(*dlmp)) & LML_TFLG_AUD_SYMBIND) { uint_t sb_flags = LA_SYMB_DLSYM; /* LINTED */ uint_t symndx = (uint_t)(((Xword)sym - (Xword)SYMTAB(*dlmp)) / SYMENT(*dlmp)); addr = audit_symbind(clmp, *dlmp, sym, symndx, addr, &sb_flags); } return ((void *)addr); } return (NULL); } /* * Internal dlsym activity. Called from user level or directly for internal * symbol lookup. */ void * dlsym_intn(void *handle, const char *name, Rt_map *clmp, Rt_map **dlmp) { Rt_map *llmp = NULL; void *error; Aliste idx; Grp_desc *gdp; int in_nfavl = 0; /* * While looking for symbols it's quite possible that additional objects * get loaded from lazy loading. These objects will have been added to * the same link-map list as those objects on the handle. Remember this * list for later investigation. */ if ((handle == RTLD_NEXT) || (handle == RTLD_DEFAULT) || (handle == RTLD_SELF) || (handle == RTLD_PROBE)) llmp = LIST(clmp)->lm_tail; else { Grp_hdl *ghp = (Grp_hdl *)handle; if (ghp->gh_ownlmp) llmp = LIST(ghp->gh_ownlmp)->lm_tail; else { for (ALIST_TRAVERSE(ghp->gh_depends, idx, gdp)) { if ((llmp = LIST(gdp->gd_depend)->lm_tail) != NULL) break; } } } error = dlsym_core(handle, name, clmp, dlmp, &in_nfavl); /* * If the symbol could not be found it is possible that the "not-found" * AVL tree had indicated that a required file does not exist. In case * the file system has changed since this "not-found" recording was * made, retry the dlsym() with a clean "not-found" AVL tree. */ if ((error == NULL) && in_nfavl) { avl_tree_t *oavlt = nfavl; nfavl = NULL; error = dlsym_core(handle, name, clmp, dlmp, NULL); /* * If the symbol is found, then any file that was loaded will * have had its full path name registered in the FullPath AVL * tree. Remove any new "not-found" AVL information, and * restore the former AVL tree. */ nfavl_remove(nfavl); nfavl = oavlt; } if (error == NULL) { /* * Cache the error message, as Java tends to fall through this * code many times. */ if (nosym_str == NULL) nosym_str = MSG_INTL(MSG_GEN_NOSYM); eprintf(LIST(clmp), ERR_FATAL, nosym_str, name); } load_completion(llmp); return (error); } /* * Argument checking for dlsym. Only called via external entry. */ static void * dlsym_check(void *handle, const char *name, Rt_map *clmp, Rt_map **dlmp) { /* * Verify the arguments. */ if (name == NULL) { eprintf(LIST(clmp), ERR_FATAL, MSG_INTL(MSG_ARG_ILLSYM)); return (NULL); } if ((handle != RTLD_NEXT) && (handle != RTLD_DEFAULT) && (handle != RTLD_SELF) && (handle != RTLD_PROBE) && (hdl_validate((Grp_hdl *)handle) == 0)) { eprintf(LIST(clmp), ERR_FATAL, MSG_INTL(MSG_ARG_INVHNDL), EC_NATPTR(handle)); return (NULL); } return (dlsym_intn(handle, name, clmp, dlmp)); } #pragma weak _dlsym = dlsym /* * External entry for dlsym(). On success, returns the address of the specified * symbol. On error returns a null. */ void * dlsym(void *handle, const char *name) { int entry; Rt_map *clmp, *dlmp = NULL; void *addr; entry = enter(0); clmp = _caller(caller(), CL_EXECDEF); addr = dlsym_check(handle, name, clmp, &dlmp); if (entry) { if (dlmp) is_dep_init(dlmp, clmp); leave(LIST(clmp), 0); } return (addr); } /* * Core dladdr activity. */ static void dladdr_core(Rt_map *almp, void *addr, Dl_info_t *dlip, void **info, int flags) { /* * Set up generic information and any defaults. */ dlip->dli_fname = PATHNAME(almp); dlip->dli_fbase = (void *)ADDR(almp); dlip->dli_sname = NULL; dlip->dli_saddr = NULL; /* * Determine the nearest symbol to this address. */ LM_DLADDR(almp)((ulong_t)addr, almp, dlip, info, flags); } #pragma weak _dladdr = dladdr /* * External entry for dladdr(3C) and dladdr1(3C). Returns an information * structure that reflects the symbol closest to the address specified. */ int dladdr(void *addr, Dl_info_t *dlip) { int entry, ret; Rt_map *clmp, *almp; Lm_list *clml; entry = enter(0); clmp = _caller(caller(), CL_EXECDEF); clml = LIST(clmp); DBG_CALL(Dbg_dl_dladdr(clmp, addr)); /* * Use our calling technique to determine what object is associated * with the supplied address. If a caller can't be determined, * indicate the failure. */ if ((almp = _caller(addr, CL_NONE)) == NULL) { eprintf(clml, ERR_FATAL, MSG_INTL(MSG_ARG_INVADDR), EC_NATPTR(addr)); ret = 0; } else { dladdr_core(almp, addr, dlip, 0, 0); ret = 1; } if (entry) leave(clml, 0); return (ret); } #pragma weak _dladdr1 = dladdr1 int dladdr1(void *addr, Dl_info_t *dlip, void **info, int flags) { int entry, ret = 1; Rt_map *clmp, *almp; Lm_list *clml; entry = enter(0); clmp = _caller(caller(), CL_EXECDEF); clml = LIST(clmp); DBG_CALL(Dbg_dl_dladdr(clmp, addr)); /* * Validate any flags. */ if (flags) { int request; if (((request = (flags & RTLD_DL_MASK)) != RTLD_DL_SYMENT) && (request != RTLD_DL_LINKMAP)) { eprintf(clml, ERR_FATAL, MSG_INTL(MSG_ARG_ILLFLAGS), flags); ret = 0; } else if (info == NULL) { eprintf(clml, ERR_FATAL, MSG_INTL(MSG_ARG_ILLINFO), flags); ret = 0; } } /* * Use our calling technique to determine what object is associated * with the supplied address. If a caller can't be determined, * indicate the failure. */ if (ret) { if ((almp = _caller(addr, CL_NONE)) == NULL) { eprintf(clml, ERR_FATAL, MSG_INTL(MSG_ARG_INVADDR), EC_NATPTR(addr)); ret = 0; } else dladdr_core(almp, addr, dlip, info, flags); } if (entry) leave(clml, 0); return (ret); } /* * Core dldump activity. */ static int dldump_core(Rt_map *clmp, Rt_map *lmp, const char *ipath, const char *opath, int flags) { Lm_list *lml = LIST(clmp); Addr addr = 0; /* * Verify any arguments first. */ if ((opath == NULL) || (opath[0] == '\0') || ((lmp == NULL) && (ipath[0] == '\0'))) { eprintf(lml, ERR_FATAL, MSG_INTL(MSG_ARG_ILLPATH)); return (1); } /* * If an input file is specified make sure its one of our dependencies * on the main link-map list. Note, this has really all evolved for * crle(), which uses libcrle.so on an alternative link-map to trigger * dumping objects from the main link-map list. If we ever want to * dump objects from alternative link-maps, this model is going to * have to be revisited. */ if (lmp == NULL) { if ((lmp = is_so_loaded(&lml_main, ipath, NULL)) == NULL) { eprintf(lml, ERR_FATAL, MSG_INTL(MSG_GEN_NOFILE), ipath); return (1); } if (FLAGS(lmp) & FLG_RT_ALTER) { eprintf(lml, ERR_FATAL, MSG_INTL(MSG_GEN_ALTER), ipath); return (1); } if (FLAGS(lmp) & FLG_RT_NODUMP) { eprintf(lml, ERR_FATAL, MSG_INTL(MSG_GEN_NODUMP), ipath); return (1); } } /* * If the object being dump'ed isn't fixed identify its mapping. */ if (!(FLAGS(lmp) & FLG_RT_FIXED)) addr = ADDR(lmp); /* * As rt_dldump() will effectively lazy load the necessary support * libraries, make sure ld.so.1 is initialized for plt relocations. */ if (elf_rtld_load() == 0) return (0); /* * Dump the required image. */ return (rt_dldump(lmp, opath, flags, addr)); } #pragma weak _dldump = dldump /* * External entry for dldump(3c). Returns 0 on success, non-zero otherwise. */ int dldump(const char *ipath, const char *opath, int flags) { int error, entry; Rt_map *clmp, *lmp; entry = enter(0); clmp = _caller(caller(), CL_EXECDEF); if (ipath) { lmp = NULL; } else { lmp = lml_main.lm_head; ipath = NAME(lmp); } DBG_CALL(Dbg_dl_dldump(clmp, ipath, opath, flags)); error = dldump_core(clmp, lmp, ipath, opath, flags); if (entry) leave(LIST(clmp), 0); return (error); } /* * get_linkmap_id() translates Lm_list * pointers to the Link_map id as used by * the rtld_db and dlmopen() interfaces. It checks to see if the Link_map is * one of the primary ones and if so returns it's special token: * LM_ID_BASE * LM_ID_LDSO * * If it's not one of the primary link_map id's it will instead returns a * pointer to the Lm_list structure which uniquely identifies the Link_map. */ Lmid_t get_linkmap_id(Lm_list *lml) { if (lml->lm_flags & LML_FLG_BASELM) return (LM_ID_BASE); if (lml->lm_flags & LML_FLG_RTLDLM) return (LM_ID_LDSO); return ((Lmid_t)lml); } /* * Set a new deferred dependency name. */ static int set_def_need(Lm_list *lml, Dyninfo *dyip, const char *name) { /* * If this dependency has already been established, then this dlinfo() * call is too late. */ if (dyip->di_info) { eprintf(lml, ERR_FATAL, MSG_INTL(MSG_DEF_DEPLOADED), dyip->di_name); return (-1); } /* * Assign the new dependency name. */ DBG_CALL(Dbg_file_deferred(lml, dyip->di_name, name)); dyip->di_flags |= FLG_DI_DEF_DONE; dyip->di_name = name; return (0); } /* * Extract information for a dlopen() handle. */ static int dlinfo_core(void *handle, int request, void *p, Rt_map *clmp) { Conv_inv_buf_t inv_buf; char *handlename; Lm_list *lml = LIST(clmp); Rt_map *lmp = NULL; /* * Determine whether a handle is provided. A handle isn't needed for * all operations, but it is validated here for the initial diagnostic. */ if (handle == RTLD_SELF) { lmp = clmp; } else { Grp_hdl *ghp = (Grp_hdl *)handle; if (hdl_validate(ghp)) lmp = ghp->gh_ownlmp; } if (lmp) { handlename = NAME(lmp); } else { (void) conv_invalid_val(&inv_buf, EC_NATPTR(handle), 0); handlename = inv_buf.buf; } DBG_CALL(Dbg_dl_dlinfo(clmp, handlename, request, p)); /* * Validate the request and return buffer. */ if ((request > RTLD_DI_MAX) || (p == NULL)) { eprintf(lml, ERR_FATAL, MSG_INTL(MSG_ARG_ILLVAL)); return (-1); } /* * Return configuration cache name and address. */ if (request == RTLD_DI_CONFIGADDR) { Dl_info_t *dlip = (Dl_info_t *)p; if ((config->c_name == NULL) || (config->c_bgn == 0) || (config->c_end == 0)) { eprintf(lml, ERR_FATAL, MSG_INTL(MSG_ARG_NOCONFIG)); return (-1); } dlip->dli_fname = config->c_name; dlip->dli_fbase = (void *)config->c_bgn; return (0); } /* * Return profiled object name (used by ldprof audit library). */ if (request == RTLD_DI_PROFILENAME) { if (profile_name == NULL) { eprintf(lml, ERR_FATAL, MSG_INTL(MSG_ARG_NOPROFNAME)); return (-1); } *(const char **)p = profile_name; return (0); } if (request == RTLD_DI_PROFILEOUT) { /* * If a profile destination directory hasn't been specified * provide a default. */ if (profile_out == NULL) profile_out = MSG_ORIG(MSG_PTH_VARTMP); *(const char **)p = profile_out; return (0); } /* * Obtain or establish a termination signal. */ if (request == RTLD_DI_GETSIGNAL) { *(int *)p = killsig; return (0); } if (request == RTLD_DI_SETSIGNAL) { sigset_t set; int sig = *(int *)p; /* * Determine whether the signal is in range. */ (void) sigfillset(&set); if (sigismember(&set, sig) != 1) { eprintf(lml, ERR_FATAL, MSG_INTL(MSG_ARG_INVSIG), sig); return (-1); } killsig = sig; return (0); } /* * For any other request a link-map is required. Verify the handle. */ if (lmp == NULL) { eprintf(lml, ERR_FATAL, MSG_INTL(MSG_ARG_INVHNDL), EC_NATPTR(handle)); return (-1); } /* * Obtain the process arguments, environment and auxv. Note, as the * environment can be modified by the user (putenv(3c)), reinitialize * the environment pointer on each request. */ if (request == RTLD_DI_ARGSINFO) { Dl_argsinfo_t *aip = (Dl_argsinfo_t *)p; Lm_list *lml = LIST(lmp); *aip = argsinfo; if (lml->lm_flags & LML_FLG_ENVIRON) aip->dla_envp = *(lml->lm_environ); return (0); } /* * Return Lmid_t of the Link-Map list that the specified object is * loaded on. */ if (request == RTLD_DI_LMID) { *(Lmid_t *)p = get_linkmap_id(LIST(lmp)); return (0); } /* * Return a pointer to the Link-Map structure associated with the * specified object. */ if (request == RTLD_DI_LINKMAP) { *(Link_map **)p = (Link_map *)lmp; return (0); } /* * Return search path information, or the size of the buffer required * to store the information. */ if ((request == RTLD_DI_SERINFO) || (request == RTLD_DI_SERINFOSIZE)) { Spath_desc sd = { search_rules, NULL, 0 }; Pdesc *pdp; Dl_serinfo_t *info; Dl_serpath_t *path; char *strs; size_t size = sizeof (Dl_serinfo_t); uint_t cnt = 0; info = (Dl_serinfo_t *)p; path = &info->dls_serpath[0]; strs = (char *)&info->dls_serpath[info->dls_cnt]; /* * Traverse search path entries for this object. */ while ((pdp = get_next_dir(&sd, lmp, 0)) != NULL) { size_t _size; if (pdp->pd_pname == NULL) continue; /* * If configuration information exists, it's possible * this path has been identified as non-existent, if so * ignore it. */ if (pdp->pd_info) { Rtc_obj *dobj = (Rtc_obj *)pdp->pd_info; if (dobj->co_flags & RTC_OBJ_NOEXIST) continue; } /* * Keep track of search path count and total info size. */ if (cnt++) size += sizeof (Dl_serpath_t); _size = pdp->pd_plen + 1; size += _size; if (request == RTLD_DI_SERINFOSIZE) continue; /* * If we're filling in search path information, confirm * there's sufficient space. */ if (size > info->dls_size) { eprintf(lml, ERR_FATAL, MSG_INTL(MSG_ARG_SERSIZE), EC_OFF(info->dls_size)); return (-1); } if (cnt > info->dls_cnt) { eprintf(lml, ERR_FATAL, MSG_INTL(MSG_ARG_SERCNT), info->dls_cnt); return (-1); } /* * Append the path to the information buffer. */ (void) strcpy(strs, pdp->pd_pname); path->dls_name = strs; path->dls_flags = (pdp->pd_flags & LA_SER_MASK); strs = strs + _size; path++; } /* * If we're here to size the search buffer fill it in. */ if (request == RTLD_DI_SERINFOSIZE) { info->dls_size = size; info->dls_cnt = cnt; } return (0); } /* * Return the origin of the object associated with this link-map. * Basically return the dirname(1) of the objects fullpath. */ if (request == RTLD_DI_ORIGIN) { char *str = (char *)p; (void) strncpy(str, ORIGNAME(lmp), DIRSZ(lmp)); str += DIRSZ(lmp); *str = '\0'; return (0); } /* * Return the number of object mappings, or the mapping information for * this object. */ if (request == RTLD_DI_MMAPCNT) { uint_t *cnt = (uint_t *)p; *cnt = MMAPCNT(lmp); return (0); } if (request == RTLD_DI_MMAPS) { Dl_mapinfo_t *mip = (Dl_mapinfo_t *)p; if (mip->dlm_acnt && mip->dlm_maps) { uint_t cnt = 0; while ((cnt < mip->dlm_acnt) && (cnt < MMAPCNT(lmp))) { mip->dlm_maps[cnt] = MMAPS(lmp)[cnt]; cnt++; } mip->dlm_rcnt = cnt; } return (0); } /* * Assign a new dependency name to a deferred dependency. */ if ((request == RTLD_DI_DEFERRED) || (request == RTLD_DI_DEFERRED_SYM)) { Dl_definfo_t *dfip = (Dl_definfo_t *)p; Dyninfo *dyip; const char *dname, *rname; /* * Verify the names. */ if ((dfip->dld_refname == NULL) || (dfip->dld_depname == NULL)) { eprintf(LIST(clmp), ERR_FATAL, MSG_INTL(MSG_ARG_ILLNAME)); return (-1); } dname = dfip->dld_depname; rname = dfip->dld_refname; /* * A deferred dependency can be determined by referencing a * symbol family member that is associated to the dependency, * or by looking for the dependency by its name. */ if (request == RTLD_DI_DEFERRED_SYM) { Slookup sl; Sresult sr; uint_t binfo; Syminfo *sip; /* * Lookup the symbol in the associated object. */ SLOOKUP_INIT(sl, rname, lmp, lmp, ld_entry_cnt, elf_hash(rname), 0, 0, 0, LKUP_SYMNDX); SRESULT_INIT(sr, rname); if (sym_lookup_in_caller(clmp, &sl, &sr, &binfo) == NULL) { eprintf(LIST(clmp), ERR_FATAL, MSG_INTL(MSG_DEF_NOSYMFOUND), rname); return (-1); } /* * Use the symbols index to reference the Syminfo entry * and thus find the associated dependency. */ if (sl.sl_rsymndx && ((sip = SYMINFO(clmp)) != NULL)) { /* LINTED */ sip = (Syminfo *)((char *)sip + (sl.sl_rsymndx * SYMINENT(lmp))); if ((sip->si_flags & SYMINFO_FLG_DEFERRED) && (sip->si_boundto < SYMINFO_BT_LOWRESERVE) && ((dyip = DYNINFO(lmp)) != NULL)) { dyip += sip->si_boundto; if (!(dyip->di_flags & FLG_DI_IGNORE)) return (set_def_need(lml, dyip, dname)); } } /* * No deferred symbol found. */ eprintf(LIST(clmp), ERR_FATAL, MSG_INTL(MSG_DEF_NOSYMFOUND), rname); return (-1); } else { Dyn *dyn; /* * Using the target objects dependency information, find * the associated deferred dependency. */ for (dyn = DYN(lmp), dyip = DYNINFO(lmp); !(dyip->di_flags & FLG_DI_IGNORE); dyn++, dyip++) { const char *oname; if ((dyip->di_flags & FLG_DI_DEFERRED) == 0) continue; if (strcmp(rname, dyip->di_name) == 0) return (set_def_need(lml, dyip, dname)); /* * If this dependency name has been changed by * a previous dlinfo(), check the original * dynamic entry string. The user might be * attempting to re-change an entry using the * original name as the reference. */ if ((dyip->di_flags & FLG_DI_DEF_DONE) == 0) continue; oname = STRTAB(lmp) + dyn->d_un.d_val; if (strcmp(rname, oname) == 0) return (set_def_need(lml, dyip, dname)); } /* * No deferred dependency found. */ eprintf(lml, ERR_FATAL, MSG_INTL(MSG_DEF_NODEPFOUND), rname); return (-1); } } return (0); } #pragma weak _dlinfo = dlinfo /* * External entry for dlinfo(3C). */ int dlinfo(void *handle, int request, void *p) { int error, entry; Rt_map *clmp; entry = enter(0); clmp = _caller(caller(), CL_EXECDEF); error = dlinfo_core(handle, request, p, clmp); if (entry) leave(LIST(clmp), 0); return (error); } /* * GNU defined function to iterate through the program headers for all * currently loaded dynamic objects. The caller supplies a callback function * which is called for each object. * * entry: * callback - Callback function to call. The arguments to the callback * function are: * info - Address of dl_phdr_info structure * size - sizeof (struct dl_phdr_info) * data - Caller supplied value. * data - Value supplied by caller, which is passed to callback without * examination. * * exit: * callback is called for each dynamic ELF object in the process address * space, halting when a non-zero value is returned, or when the last * object has been processed. The return value from the last call * to callback is returned. * * note: * The Linux implementation has added additional fields to the * dl_phdr_info structure over time. The callback function is * supposed to use the size field to determine which fields are * present, and to avoid attempts to access non-existent fields. * We have added those fields that are compatible with Solaris, and * which are used by GNU C++ (g++) runtime exception handling support. * * note: * We issue a callback for every ELF object mapped into the process * address space at the time this routine is entered. These callbacks * are arbitrary functions that can do anything, including possibly * causing new objects to be mapped into the process, or unmapped. * This complicates matters: * * - Adding new objects can cause the alists to be reallocated * or for contents to move. This can happen explicitly via * dlopen(), or implicitly via lazy loading. One might consider * simply banning dlopen from a callback, but lazy loading must * be allowed, in which case there's no reason to ban dlopen(). * * - Removing objects can leave us holding references to freed * memory that must not be accessed, and can cause the list * items to move in a way that would cause us to miss reporting * one, or double report others. * * - We cannot allocate memory to build a separate data structure, * because the interface to dl_iterate_phdr() does not have a * way to communicate allocation errors back to the caller. * Even if we could, it would be difficult to do so efficiently. * * - It is possible for dl_iterate_phdr() to be called recursively * from a callback, and there is no way for us to detect or manage * this effectively, particularly as the user might use longjmp() * to skip past us on return. Hence, we must be reentrant * (stateless), further precluding the option of building a * separate data structure. * * Despite these constraints, we are able to traverse the link-map * lists safely: * * - Once interposer (preload) objects have been processed at * startup, we know that new objects are always placed at the * end of the list. Hence, if we are reading a list when that * happens, the new object will not alter the part of the list * that we've already processed. * * - The alist _TRAVERSE macros recalculate the address of the * current item from scratch on each iteration, rather than * incrementing a pointer. Hence, alist additions that occur * in mid-traverse will not cause confusion. * * There is one limitation: We cannot continue operation if an object * is removed from the process from within a callback. We detect when * this happens and return immediately with a -1 return value. * * note: * As currently implemented, if a callback causes an object to be loaded, * that object may or may not be reported by the current invocation of * dl_iterate_phdr(), based on whether or not we have already processed * the link-map list that receives it. If we want to prevent this, it * can be done efficiently by associating the current value of cnt_map * with each new Rt_map entered into the system. Then this function can * use that to detect and skip new objects that enter the system in * mid-iteration. However, the Linux documentation is ambiguous on whether * this is necessary, and it does not appear to matter in practice. * We have therefore chosen not to do so at this time. */ int dl_iterate_phdr(int (*callback)(struct dl_phdr_info *, size_t, void *), void *data) { struct dl_phdr_info info; u_longlong_t l_cnt_map = cnt_map; u_longlong_t l_cnt_unmap = cnt_unmap; Lm_list *lml, *clml; Lm_cntl *lmc; Rt_map *lmp, *clmp; Aliste idx1, idx2; Ehdr *ehdr; int ret = 0; int entry; entry = enter(0); clmp = _caller(caller(), CL_EXECDEF); clml = LIST(clmp); DBG_CALL(Dbg_dl_iphdr_enter(clmp, cnt_map, cnt_unmap)); /* Issue a callback for each ELF object in the process */ for (APLIST_TRAVERSE(dynlm_list, idx1, lml)) { for (ALIST_TRAVERSE(lml->lm_lists, idx2, lmc)) { for (lmp = lmc->lc_head; lmp; lmp = NEXT_RT_MAP(lmp)) { #if defined(_sparc) && !defined(_LP64) /* * On 32-bit sparc, the possibility exists that * this object is not ELF. */ if (THIS_IS_NOT_ELF(lmp)) continue; #endif /* Prepare the object information structure */ ehdr = (Ehdr *) ADDR(lmp); info.dlpi_addr = (ehdr->e_type == ET_EXEC) ? 0 : ADDR(lmp); info.dlpi_name = lmp->rt_pathname; info.dlpi_phdr = (Phdr *) (ADDR(lmp) + ehdr->e_phoff); info.dlpi_phnum = ehdr->e_phnum; info.dlpi_adds = cnt_map; info.dlpi_subs = cnt_unmap; /* Issue the callback */ DBG_CALL(Dbg_dl_iphdr_callback(clml, &info)); leave(clml, thr_flg_reenter); ret = (* callback)(&info, sizeof (info), data); (void) enter(thr_flg_reenter); /* Return immediately on non-zero result */ if (ret != 0) goto done; /* Adapt to object mapping changes */ if ((cnt_map == l_cnt_map) && (cnt_unmap == l_cnt_unmap)) continue; DBG_CALL(Dbg_dl_iphdr_mapchange(clml, cnt_map, cnt_unmap)); /* Stop if an object was unmapped */ if (cnt_unmap == l_cnt_unmap) { l_cnt_map = cnt_map; continue; } ret = -1; DBG_CALL(Dbg_dl_iphdr_unmap_ret(clml)); goto done; } } } done: if (entry) leave(LIST(clmp), 0); return (ret); }
