dlfcns.c revision 7c478bd95313f5f23a4c958a745db2134aa03244
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (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
* 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 2005 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
/*
* Programmatic interface to the run_time linker.
*/
#include "_synonyms.h"
#include <string.h>
#include <dlfcn.h>
#include <synch.h>
#include "debug.h"
#include "_rtld.h"
#include "_audit.h"
#include "_elf.h"
#include "msg.h"
#include <stdio.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 *
{
/*
* Traverse this objects mappings testing
* whether the pc falls within its range.
*/
return (lmp);
}
}
}
}
/*
* No mapping can be determined. If asked for a default, assume this
* is from the executable.
*/
if (flags & CL_EXECDEF)
return (0);
}
/*
* External entry for dlerror(3dl). Returns a pointer to the string describing
* the last occurring error. The last occurring error is cleared.
*/
char *
_dlerror()
{
char *error;
int entry;
lasterr = (char *)0;
if (entry)
return (error);
}
/*
* Add a dependency as a group descriptor to a group handle. Returns 0 on
* failure, ALE_EXISTS if the dependency already exists, or ALE_CREATE if it
* is newly created.
*/
int
{
int found = ALE_CREATE;
/*
* Make sure this dependency hasn't already been recorded.
*/
found = ALE_EXISTS;
break;
}
}
if (found == ALE_CREATE) {
/*
* Create a new handle descriptor.
*/
/*
* Indicate this object is a part of this handles group.
*/
sizeof (Grp_hdl *), AL_CNT_GROUPS) == 0)
return (0);
/*
* Append the new dependency to this handle.
*/
sizeof (Grp_desc), AL_CNT_DEPENDS)) == 0)
return (0);
}
if (found == ALE_CREATE)
return (found);
}
/*
* Allocate a handle and record its existence on the handle list for future
* verification.
*/
Grp_hdl *
{
return (0);
/* LINTED */
return (0);
}
return (ghp);
}
/*
* Create a handle.
*/
Grp_hdl *
{
/*
* For dlopen(0) the handle is maintained as part of the link-map list,
* otherwise it is associated with the referenced link-map.
*/
else
/*
* Objects can contain multiple handles depending on the 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.
*/
break;
}
}
if (ghp == 0) {
/*
* If this is the first dlopen() request for this handle
* allocate and initialize a new handle.
*/
return (0);
AL_CNT_GROUPS) == 0)
return (0);
/*
* Indicate that this object has been referenced. In truth a
* reference hasn't yet occurred, it's a dlsym() that makes the
* reference. However, we assume that anyone performing a
* dlopen() will eventually call dlsym(), plus this makes for a
* better diagnostic location rather than having to call
* unused() after every dlsym() operation.
*/
if (nlmp)
/*
* 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.
*/
} else {
/*
* As an optimization, a handle for ld.so.1 itself
* (required for libdl's filtering mechanism) shouldn't
* search any dependencies of ld.so.1. Omitting
* GDP_ADDEPS prevents the addition of any ld.so.1
* dependencies to this handle.
*/
hflags |= GPD_ADDEPS;
return (0);
}
} else {
/*
* If a handle already exists bump its reference count. If it's
* count was 0 then this handle previously existed but could not
* be removed as part of a dlclose(). Remove this handle from
* the orphan list as it's once again in use. Note that handles
* associated with the link-map list itself (dlopen(0)) were
* never deleted or removed to the orphan list.
*/
/* LINTED */
if (dbg_mask) {
}
}
/*
* Once a handle is referenced, remove any stick bit.
*/
}
/*
* If dlopen(..., RTLD_PARENT) add the caller to dependency list so that
* it becomes part of this group. As we could be opened by different
* parents this test is carried out every time a handle is requested.
* Note that a parent doesn't provide symbols via dlsym() so it also
* isn't necessary to add its dependencies to the handle.
*/
if (flags & GPH_PARENT) {
return (0);
}
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
{
/*
* 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.
*/
return (1);
}
/*
* 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.
*/
continue;
continue;
else {
/*
* Something failed. Remove the new handle.
*/
return (0);
}
}
}
return (1);
}
/*
* Sanity check a program-provided handle.
*/
static int
{
/* LINTED */
return (1);
return (0);
}
/*
* Core dlclose activity.
*/
int
{
/*
* 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) != 0)
return (0);
/*
* Diagnose what we're up to.
*/
} else {
const char *owner;
/*
* Determine if we've an owner for this handle.
*/
else
}
/*
* Decrement reference count of this object.
*/
return (0);
/*
* If this handle is special (dlopen(0)), then leave it around - it
* has little overhead.
*/
return (0);
/*
* This handle is no longer being referenced, remove it.
*/
}
/*
* Internal dlclose activity. Called from user level or directly for internal
* error cleanup.
*/
int
{
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.
*/
else {
break;
}
}
/*
* 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) {
break;
}
}
}
return (error);
}
/*
* Argument checking for dlclose. Only called via external entry.
*/
static int
{
if (!hdl_validate(ghp)) {
return (1);
}
}
/*
* External entry for dlclose(3dl). Returns 0 for success, non-zero otherwise.
*/
int
{
dbg_mask = 0;
}
if (lmflags & LML_FLG_RTLDLM)
if (entry)
return (error);
}
/*
* Core dlopen activity.
*/
static Grp_hdl *
{
/*
* 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.
*/
return (0);
/*
* Establish the new link-map flags from the callers and those
* explicitly provided.
*/
if (flags & FLG_RT_AUDIT) {
/*
* Unset any auditing flags - an auditor shouldn't be
* audited. Insure all audit dependencies are loaded.
*/
}
return (0);
}
}
/*
* If the path specified is null then we're operating on global
* objects. Associate a dummy handle with the link-map list.
*/
if (path == 0) {
int promote = 0;
if (mode & RTLD_PARENT)
hflags |= GPH_PARENT;
if (mode & RTLD_FIRST)
return (0);
/*
* 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).
*/
return (ghp);
continue;
promote = 1;
}
if (promote)
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.
*/
return (0);
((mode & RTLD_FIRST) == 0)) {
return (0);
}
/*
* Create a new link-map control list for this request, and load the
* associated object.
*/
AL_CNT_LMLISTS)) == 0) {
return (0);
}
/*
* Remove any expanded pathname infrastructure, and if the dependency
* couldn't be loaded, cleanup.
*/
if (nlmp == 0) {
return (0);
}
/*
* 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.
*/
olmco = 0;
}
/*
* Finish processing the objects associated with this request.
*/
}
return (0);
}
/*
* After a successful load, any objects collected on the new link-map
* control list will have been moved to the callers link-map control
* list. This control list can now be deleted.
*/
if (olmco)
return (ghp);
}
/*
* Internal dlopen() activity. Called from user level or directly for internal
* opens that require a handle.
*/
Grp_hdl *
{
/*
* Determine the link-map that has just been loaded.
*/
/*
* Establish the new link-map from which .init processing will
* begin. Ignore .init firing when constructing a configuration
* file (crle(1)).
*/
if ((mode & RTLD_CONFGEN) == 0)
}
/*
* Return the number of objects loaded if required. This is used to
* trigger used() processing on return from a dlopen().
*/
return (ghp);
}
/*
* Argument checking for dlopen. Only called via external entry.
*/
static Grp_hdl *
int *loaded)
{
/*
* Verify that a valid pathname has been supplied.
*/
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.
*/
return (0);
}
return (0);
}
return (0);
}
return (0);
}
}
/*
* External entry for dlopen(3dl). 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 *
{
dbg_mask = 0;
}
if (lmflags & LML_FLG_RTLDLM)
if (entry)
return ((void *)ghp);
}
/*
* External entry for dlmopen(3dl).
*/
void *
{
dbg_mask = 0;
}
if (lmflags & LML_FLG_RTLDLM)
if (entry)
return ((void *)ghp);
}
/*
* Handle processing for dlsym.
*/
Sym *
{
/*
* 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 symbols 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 this symbol lookup is triggered from a dlopen(0) handle,
* traverse the present link-map list looking for promiscuous
* entries.
*/
/*
* If this handle indicates we're only to look in the
* first object check whether we're done.
*/
return ((Sym *)0);
continue;
continue;
return (sym);
}
/*
* If we're unable to locate the symbol and this link-map 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.
*/
continue;
continue;
return (sym);
}
}
} else {
/*
* Traverse the dlopen() handle for the presently loaded
* link-maps.
*/
continue;
return (sym);
return ((Sym *)0);
}
/*
* If we're unable to locate the symbol and this link-map still
* has pending lazy dependencies, start loading them in an
* attempt to exhaust the search.
*/
continue;
return (sym);
}
}
}
return ((Sym *)0);
}
/*
* Core dlsym activity. Selects symbol lookup method from handle.
*/
void *
{
sl.sl_rsymndx = 0;
/*
* 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.
*/
if (nlmp == 0)
return (0);
/*
* If the handle is RTLD_SELF start searching from the caller.
*/
/*
* If the handle is RTLD_DEFAULT or RTLD_PROBE, mimic the
* symbol lookup that would be triggered by a relocation.
* Determine if a specific object is registered to offer this
* symbol from any Syminfo information. If a registered object
* is defined, it will be loaded, and directly bound to if
* necessary via LM_LOOKUP_SYM(). Otherwise a serial symbol
* search is carried out where permissions are determined from
* the callers link map.
* RTLD_PROBE is more optimal than RTLD_DEFAULT, as no fall back
* loading of pending lazy dependencies occurs.
*/
DBG_DLSYM_PROBE)));
sym = 0;
else {
/*
* If the symbol is defined within the caller as an
* UNDEF (DBG_BINFO_FOUND isn't set), then determine
* the associated syminfo index and continue the search.
*/
if (((sym =
((binfo & DBG_BINFO_FOUND) == 0)) {
sl.sl_rsymndx =
sym = 0;
}
}
if (sym == 0) {
if (handle == RTLD_PROBE)
}
} else {
/*
* Look in the shared object specified by the handle and in all
* of its dependencies.
*/
}
if (sym) {
/* LINTED */
&sb_flags);
}
return ((void *)addr);
} else
return (0);
}
/*
* Internal dlsym activity. Called from user level or directly for internal
* symbol lookup.
*/
void *
{
void * error;
/*
* 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.
*/
else {
else {
break;
}
}
}
/*
* Cache the error message, as Java tends to fall through this
* code many times.
*/
if (nosym_str == 0)
}
return (error);
}
/*
* Argument checking for dlsym. Only called via external entry.
*/
static void *
{
/*
* Verify the arguments.
*/
if (name == 0) {
return (0);
}
return (0);
}
}
/*
* External entry for dlsym(). On success, returns the address of the specified
* symbol. On error returns a null.
*/
void *
{
int entry;
void *addr;
dbg_mask = 0;
}
if (dlmp)
if (lmflags & LML_FLG_RTLDLM)
if (entry)
return (addr);
}
/*
* Core dladdr activity.
*/
static void
{
/*
* Set up generic information and any defaults.
*/
/*
* Determine the nearest symbol to this address.
*/
}
/*
* External entry for dladdr(3dl) and dladdr1(3dl). Returns an information
* structure that reflects the symbol closest to the address specified.
*/
int
{
/*
* Use our calling technique to determine what object is associated
* with the supplied address. If a caller can't be determined,
* indicate the failure.
*/
error = 0;
} else {
dbg_mask = 0;
}
if (lmflags & LML_FLG_RTLDLM)
error = 1;
}
if (entry)
leave(0);
return (error);
}
int
{
/*
* Validate any flags.
*/
if (flags) {
int request;
(request != RTLD_DL_LINKMAP)) {
return (0);
}
if (info == 0) {
return (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.
*/
error = 0;
} else {
dbg_mask = 0;
}
if (lmflags & LML_FLG_RTLDLM)
error = 1;
}
if (entry)
leave(0);
return (error);
}
/*
* Core dldump activity.
*/
static int
{
/*
* Verify any arguments first.
*/
return (1);
}
/*
* If an input file is specified make sure its one of our dependencies.
*/
if (ipath) {
if (lmp == 0) {
return (1);
}
return (1);
}
return (1);
}
} else
/*
* If the object being dump'ed isn't fixed identify its mapping.
*/
/*
* 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.
*/
}
/*
* External entry for dldump(3dl). Returns 0 on success, non-zero otherwise.
*/
int
{
dbg_mask = 0;
}
if (lmflags & LML_FLG_RTLDLM)
if (entry)
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.
*/
{
return (LM_ID_BASE);
return (LM_ID_LDSO);
}
/*
* Extract information for a dlopen() handle. The valid request are:
*/
static int
{
if ((request > RTLD_DI_MAX) || (p == 0)) {
return (-1);
}
/*
* Return configuration cache name and address.
*/
if (request == RTLD_DI_CONFIGADDR) {
return (-1);
}
return (0);
}
/*
* Return profiled object name (used by ldprof audit library).
*/
if (request == RTLD_DI_PROFILENAME) {
if (profile_name == 0) {
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 == 0)
*(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) {
int sig = *(int *)p;
/*
* Determine whether the signal is in range.
*/
(void) sigfillset(&set);
return (-1);
}
return (0);
}
/*
* For any other request a link-map is required. Verify the handle.
*/
else {
if (!hdl_validate(ghp)) {
return (-1);
}
}
/*
* Return Lmid_t of the Link-Map list that the specified object is
* loaded on.
*/
if (request == RTLD_DI_LMID) {
return (0);
}
/*
* Return a pointer to the Link-Map structure associated with the
* specified object.
*/
if (request == RTLD_DI_LINKMAP) {
return (0);
}
/*
* Return search path information, or the size of the buffer required
* to store the information.
*/
char *strs;
info = (Dl_serinfo *)p;
/*
* Traverse search path entries for this object.
*/
continue;
/*
* If configuration information exists, it's possible
* this path has been identified as non-existent, if so
* ignore it.
*/
continue;
}
/*
* Keep track of search path count and total info size.
*/
if (cnt++)
size += sizeof (Dl_serpath);
if (request == RTLD_DI_SERINFOSIZE)
continue;
/*
* If we're filling in search path information, confirm
* there's sufficient space.
*/
return (-1);
}
return (-1);
}
/*
* Append the path to the information buffer.
*/
path++;
}
/*
* If we're here to size the search buffer fill it in.
*/
if (request == RTLD_DI_SERINFOSIZE) {
}
}
/*
* 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;
} else {
str = (char *)p;
*str++ = '.';
}
*str = '\0';
return (0);
}
return (0);
}
/*
* External entry for dlinfo(3dl).
*/
int
{
dbg_mask = 0;
}
if (lmflags & LML_FLG_RTLDLM)
if (entry)
return (error);
}