Ubuntu Manpage: This manual page is part of the POSIX Programmer's Manual. The Linux implementation of

Provided by: manpages-posix-dev_2013a-1_all

PROLOG

       This  manual  page  is part of the POSIX Programmer's Manual.  The Linux implementation of
       this interface may differ (consult the corresponding Linux  manual  page  for  details  of
       Linux behavior), or the interface may not be implemented on Linux.

NAME

       dlopen — open a symbol table handle

SYNOPSIS

       #include <dlfcn.h>

       void *dlopen(const char *file, int mode);

DESCRIPTION

The dlopen() function shall make the symbols (function identifiers and data object
identifiers) in the executable object file specified by file available to the calling
program.

The class of executable object files eligible for this operation and the manner of their
construction are implementation-defined, though typically such files are shared libraries
or programs.

Implementations may permit the construction of embedded dependencies in executable object
files. In such cases, a dlopen() operation shall load those dependencies in addition to
the executable object file specified by file. Implementations may also impose specific
constraints on the construction of programs that can employ dlopen() and its related
services.

A successful dlopen() shall return a symbol table handle which the caller may use on
subsequent calls to dlsym() and dlclose().

The value of this symbol table handle should not be interpreted in any way by the caller.

The file argument is used to construct a pathname to the executable object file. If file
contains a <slash> character, the file argument is used as the pathname for the file.
Otherwise, file is used in an implementation-defined manner to yield a pathname.

If file is a null pointer, dlopen() shall return a global symbol table handle for the
currently running process image. This symbol table handle shall provide access to the
symbols from an ordered set of executable object files consisting of the original program
image file, any executable object files loaded at program start-up as specified by that
process file (for example, shared libraries), and the set of executable object files
loaded using dlopen() operations with the RTLD_GLOBAL flag. As the latter set of
executable object files can change during execution, the set of symbols made available by
this symbol table handle can also change dynamically.

Only a single copy of an executable object file shall be brought into the address space,
even if dlopen() is invoked multiple times in reference to the executable object file, and
even if different pathnames are used to reference the executable object file.

The mode parameter describes how dlopen() shall operate upon file with respect to the
processing of relocations and the scope of visibility of the symbols provided within file.
When an executable object file is brought into the address space of a process, it may
contain references to symbols whose addresses are not known until the executable object
file is loaded.

These references shall be relocated before the symbols can be accessed. The mode parameter
governs when these relocations take place and may have the following values:

RTLD_LAZY Relocations shall be performed at an implementation-defined time, ranging from
the time of the dlopen() call until the first reference to a given symbol
occurs. Specifying RTLD_LAZY should improve performance on implementations
supporting dynamic symbol binding since a process might not reference all of
the symbols in an executable object file. And, for systems supporting dynamic
symbol resolution for normal process execution, this behavior mimics the
normal handling of process execution.

RTLD_NOW All necessary relocations shall be performed when the executable object file
is first loaded. This may waste some processing if relocations are performed
for symbols that are never referenced. This behavior may be useful for
applications that need to know that all symbols referenced during execution
will be available before dlopen() returns.

Any executable object file loaded by dlopen() that requires relocations against global
symbols can reference the symbols in the original process image file, any executable
object files loaded at program start-up, from the initial process image itself, from any
other executable object file included in the same dlopen() invocation, and any executable
object files that were loaded in any dlopen() invocation and which specified the
RTLD_GLOBAL flag. To determine the scope of visibility for the symbols loaded with a
dlopen() invocation, the mode parameter should be a bitwise-inclusive OR with one of the
following values:

RTLD_GLOBAL The executable object file's symbols shall be made available for relocation
processing of any other executable object file. In addition, symbol lookup
using dlopen(NULL,mode) and an associated dlsym() allows executable object
files loaded with this mode to be searched.

RTLD_LOCAL The executable object file's symbols shall not be made available for
relocation processing of any other executable object file.

If neither RTLD_GLOBAL nor RTLD_LOCAL is specified, the default behavior is unspecified.

If an executable object file is specified in multiple dlopen() invocations, mode is
interpreted at each invocation.

If RTLD_NOW has been specified, all relocations shall have been completed rendering
further RTLD_NOW operations redundant and any further RTLD_LAZY operations irrelevant.

If RTLD_GLOBAL has been specified, the executable object file shall maintain the
RTLD_GLOBAL status regardless of any previous or future specification of RTLD_LOCAL, as
long as the executable object file remains in the address space (see dlclose()).

Symbols introduced into the process image through calls to dlopen() may be used in
relocation activities. Symbols so introduced may duplicate symbols already defined by the
program or previous dlopen() operations. To resolve the ambiguities such a situation might
present, the resolution of a symbol reference to symbol definition is based on a symbol
resolution order. Two such resolution orders are defined: load order and dependency order.
Load order establishes an ordering among symbol definitions, such that the first
definition loaded (including definitions from the process image file and any dependent
executable object files loaded with it) has priority over executable object files added
later (by dlopen()). Load ordering is used in relocation processing. Dependency ordering
uses a breadth-first order starting with a given executable object file, then all of its
dependencies, then any dependents of those, iterating until all dependencies are
satisfied. With the exception of the global symbol table handle obtained via a dlopen()
operation with a null pointer as the file argument, dependency ordering is used by the
dlsym() function. Load ordering is used in dlsym() operations upon the global symbol table
handle.

When an executable object file is first made accessible via dlopen(), it and its dependent
executable object files are added in dependency order. Once all the executable object
files are added, relocations are performed using load order. Note that if an executable
object file or its dependencies had been previously loaded, the load and dependency orders
may yield different resolutions.

The symbols introduced by dlopen() operations and available through dlsym() are at a
minimum those which are exported as identifiers of global scope by the executable object
file. Typically, such identifiers shall be those that were specified in (for example) C
source code as having extern linkage. The precise manner in which an implementation
constructs the set of exported symbols for an executable object file is implementation-
defined.

RETURN VALUE

       Upon successful completion, dlopen() shall return a symbol table handle. If file cannot be
       found,  cannot  be  opened  for  reading,  is not of an appropriate executable object file
       format for processing by dlopen(), or if an error occurs during  the  process  of  loading
       file  or  relocating  its  symbolic references, dlopen() shall return a null pointer. More
       detailed diagnostic information shall be available through dlerror().

ERRORS

       No errors are defined.

       The following sections are informative.

EXAMPLES

       Refer to dlsym().

APPLICATION USAGE

       None.

RATIONALE

       None.

FUTURE DIRECTIONS

       None.

COPYRIGHT

       Portions of this text are reprinted and  reproduced  in  electronic  form  from  IEEE  Std
       1003.1,  2013  Edition,  Standard  for Information Technology -- Portable Operating System
       Interface (POSIX), The Open Group Base Specifications Issue 7, Copyright (C) 2013  by  the
       Institute  of  Electrical  and  Electronics  Engineers,  Inc and The Open Group.  (This is
       POSIX.1-2008 with the  2013  Technical  Corrigendum  1  applied.)  In  the  event  of  any
       discrepancy  between  this  version and the original IEEE and The Open Group Standard, the
       original IEEE and The Open Group Standard is the referee document. The  original  Standard
       can be obtained online at http://www.unix.org/online.html .

       Any  typographical  or  formatting errors that appear in this page are most likely to have
       been introduced during the conversion of the source files to man page  format.  To  report
       such errors, see https://www.kernel.org/doc/man-pages/reporting_bugs.html .