Provided by: manpages-posix-dev_2013a-2_all bug

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.

SEE ALSO

       dlclose(), dlerror(), dlsym()

       The Base Definitions volume of POSIX.1‐2008, <dlfcn.h>

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 .