Linux shared objects path

Shared libraries with GCC on Linux

Libraries are an indispensable tool for any programmer. They are pre-existing code that is compiled and ready for you to use. They often provide generic functionality, like linked lists or binary trees that can hold any data, or specific functionality like an interface to a database server such as MySQL.

Most larger software projects will contain several components, some of which you may find use for later on in some other project, or that you just want to separate out for organizational purposes. When you have a reusable or logically distinct set of functions, it is helpful to build a library from it so that you do not have to copy the source code into your current project and recompile it all the time — and so you can keep different modules of your program disjoint and change one without affecting others. Once it is been written and tested, you can safely reuse it over and over again, saving the time and hassle of building it into your project every time.

Building static libraries is fairly simple, and since we rarely get questions on them, I will not cover them. I will stick with shared libraries, which seem to be more confusing for most people.

Before we get started, it might help to get a quick rundown of everything that happens from source code to running program:

1. C Preprocessor: This stage processes all the preprocessor directives. Basically, any line that starts with a #, such as #define and #include.
2. Compilation Proper: Once the source file has been preprocessed, the result is then compiled. Since many people refer to the entire build process as compilation, this stage is often referred to as compilation proper. This stage turns a .c file into an .o (object) file.
3. Linking: Here is where all of the object files and any libraries are linked together to make your final program. Note that for static libraries, the actual library is placed in your final program, while for shared libraries, only a reference to the library is placed inside. Now you have a complete program that is ready to run. You launch it from the shell, and the program is handed off to the loader.
4. Loading: This stage happens when your program starts up. Your program is scanned for references to shared libraries. Any references found are resolved and the libraries are mapped into your program.

Steps 3 and 4 are where the magic (and confusion) happens with shared libraries.

Now, on to our (very simple) example.

foo.h defines the interface to our library, a single function, foo(). foo.c contains the implementation of that function, and main.c is a driver program that uses our library.

For the purposes of this example, everything will happen in /home/username/foo

Step 1: Compiling with Position Independent Code

We need to compile our library source code into position-independent code (PIC): 1

Step 2: Creating a shared library from an object file

Now we need to actually turn this object file into a shared library. We will call it libfoo.so:

Step 3: Linking with a shared library

As you can see, that was actually pretty easy. We have a shared library. Let us compile our main.c and link it with libfoo. We will call our final program test. Note that the -lfoo option is not looking for foo.o, but libfoo.so. GCC assumes that all libraries start with lib and end with .so or .a (.so is for shared object or shared libraries, and .a is for archive, or statically linked libraries).

Telling GCC where to find the shared library

Uh-oh! The linker does not know where to find libfoo. GCC has a list of places it looks by default, but our directory is not in that list. 2 We need to tell GCC where to find libfoo.so. We will do that with the -L option. In this example, we will use the current directory, /home/username/foo:

Step 4: Making the library available at runtime

Good, no errors. Now let us run our program:

Oh no! The loader cannot find the shared library. 3 We did not install it in a standard location, so we need to give the loader a little help. We have a couple of options: we can use the environment variable LD_LIBRARY_PATH for this, or rpath. Let us take a look first at LD_LIBRARY_PATH:

Using LD_LIBRARY_PATH

There is nothing in there. Let us fix that by prepending our working directory to the existing LD_LIBRARY_PATH:

What happened? Our directory is in LD_LIBRARY_PATH, but we did not export it. In Linux, if you do not export the changes to an environment variable, they will not be inherited by the child processes. The loader and our test program did not inherit the changes we made. Thankfully, the fix is easy:

Good, it worked! LD_LIBRARY_PATH is great for quick tests and for systems on which you do not have admin privileges. As a downside, however, exporting the LD_LIBRARY_PATH variable means it may cause problems with other programs you run that also rely on LD_LIBRARY_PATH if you do not reset it to its previous state when you are done.

Using rpath

Now let s try rpath (first we will clear LD_LIBRARY_PATH to ensure it is rpath that is finding our library). Rpath, or the run path, is a way of embedding the location of shared libraries in the executable itself, instead of relying on default locations or environment variables. We do this during the linking stage. Notice the lengthy “-Wl,-rpath=/home/username/foo” option. The -Wl portion sends comma-separated options to the linker, so we tell it to send the -rpath option to the linker with our working directory.

Excellent, it worked. The rpath method is great because each program gets to list its shared library locations independently, so there are no issues with different programs looking in the wrong paths like there were for LD_LIBRARY_PATH.

rpath vs. LD_LIBRARY_PATH

There are a few downsides to rpath, however. First, it requires that shared libraries be installed in a fixed location so that all users of your program will have access to those libraries in those locations. That means less flexibility in system configuration. Second, if that library refers to a NFS mount or other network drive, you may experience undesirable delays — or worse — on program startup.

Using ldconfig to modify ld.so

What if we want to install our library so everybody on the system can use it? For that, you will need admin privileges. You will need this for two reasons: first, to put the library in a standard location, probably /usr/lib or /usr/local/lib, which normal users do not have write access to. Second, you will need to modify the ld.so config file and cache. As root, do the following:

Now the file is in a standard location, with correct permissions, readable by everybody. We need to tell the loader it is available for use, so let us update the cache:

That should create a link to our shared library and update the cache so it is available for immediate use. Let us double check:

Now our library is installed. Before we test it, we have to clean up a few things:

Clear our LD_LIBRARY_PATH once more, just in case:

Re-link our executable. Notice we do not need the -L option since our library is stored in a default location and we are not using the rpath option:

Let us make sure we are using the /usr/lib instance of our library using ldd:

Good, now let us run it:

That about wraps it up. We have covered how to build a shared library, how to link with it, and how to resolve the most common loader issues with shared libraries — as well as the positives and negatives of different approaches.

1. It looks in the DT_RPATH section of the executable, unless there is a DT_RUNPATH section.
2. It looks in LD_LIBRARY_PATH. This is skipped if the executable is setuid/setgid for security reasons.
3. It looks in the DT_RUNPATH section of the executable unless the setuid/setgid bits are set (for security reasons).
4. It looks in the cache file /etc/ld/so/cache (disabled with the -z nodeflib linker option).
5. It looks in the default directories /lib then /usr/lib (disabled with the -z nodeflib linker option).

What is position independent code? PIC is code that works no matter where in memory it is placed. Because several different programs can all use one instance of your shared library, the library cannot store things at fixed addresses, since the location of that library in memory will vary from program to program. ↩

GCC first searches for libraries in /usr/local/lib, then in /usr/lib. Following that, it searches for libraries in the directories specified by the -L parameter, in the order specified on the command line. ↩

Источник

C: создание и применение shared library в Linux

Библиотека — это файл, содержащий скопилированный код из нескольких объектных файлов в один файл библиотеки, который может содержать функции используемые другими программами.

Библиотеки могут быть статичными (static) и динамическими или разделяемыми (dynamic, shared).

Ниже — краткий пример создания и применения shared library на C в Linux.

Доступ к общей библиотеке может осуществляться по нескольким именам:

• имя, используемое «линкером» /usr/bin/ld (linker name), в виде слова lib + имя библиотеки + расширение .so , например — libpthread.so
• Полное имя (fully qualified name или soname), в виде lib + name + .so + версия (например — libpthread.so.1 )
• реальное имя — полное имя файла, содержащего версию библиотеки, в виде lib + имя + .so + версия + минорная версия и опционально — версия релиза (например — libpthread.so.1.1 )

Версия для общей бибилиотеки меняется в случае, когда изменения в коде этой бибилиотеки делают её несовместимой с предыдущими версиями, например — если из библиотеки была убрана какая-то функция ( libpthread.so.1 )

Минорная версия меняется, если изменения не затронули совметимость библиотеки, например — какой-то фикс в одной из функций. В таком случае версия останется прежней, а изменится только минорная часть ( libpthread.so.1.1 ).

Такое соглашение об именах версий библиотек позволяет существование разных версий одной библиотеки в одной системе.

Программа, которая будет линковаться с этой бибилиотекой, не будет привязана к определённому файлу с последней версией библиотеки. Вместо этого, после установки последней версии — все связанные программы будут использовать её.

Создание библиотеки

Создадим простой файл libhello.c с одной функцией:

Создаём заголовочный файл библиотеки libhello.h с прототипом функции:

Приступаем к сборке библиотеки.

Создаём объектный файл, указав опцию PIC (Position Independent Code), Warning ( -Wall — warning all), -g для добавления дебаг-информации и -c — что бы создать только файл библиотеки, без вызова линкера:

Проверяем — теперь у нас имеется объектный файл .o :

Источник

Static, Shared Dynamic and Loadable Linux Libraries

This tutorial discusses the philosophy behind libraries and the creation and use of C/C++ library «shared components» and «plug-ins». The various technologies and methodologies used and insight to their appropriate application, is also discussed. In this tutorial, all libraries are created using the GNU Linux compiler.

Related YoLinux Tutorials:

Libraries employ a software design also known as «shared components» or «archive libraries», which groups together multiple compiled object code files into a single file known as a library. Typically C functions/C++ classes and methods which can be shared by more than one application are broken out of the application’s source code, compiled and bundled into a library. The C standard libraries and C++ STL are examples of shared components which can be linked with your code. The benefit is that each and every object file need not be stated when linking because the developer can reference the library collective. This simplifies the multiple use and sharing of software components between applications. It also allows application vendors a way to simply release an API to interface with an application. Components which are large can be created for dynamic use, thus the library can remain separate from the executable reducing it’s size and thus less disk space is used for the application. The library components are then called by various applications for use when needed.

Benefits include:

• Component reuse: update one library, shared resource takes up less disk space.
• Version management: Linux libraries can cohabitate old and new versions on a single system.
• Component Specialization: niche and specialized developers can focus on their core competency on a single library. Simplifies testing and verification.

There are two Linux C/C++ library types which can be created:

1. Static libraries (.a): Library of object code which is linked with, and becomes part of the application.
2. Dynamically linked shared object libraries (.so): There is only one form of this library but it can be used in two ways.
   1. Dynamically linked at run time. The libraries must be available during compile/link phase. The shared objects are not included into the executable component but are tied to the execution.
   2. Dynamically loaded/unloaded and linked during execution (i.e. browser plug-in) using the dynamic linking loader system functions.

Library naming conventions:

Consider the following compile and link command: gcc src-file.c -lm -lpthread
The libraries referenced in this example for inclusion during linking are the math library («m») and the thread library («pthread»). They are found in /usr/lib/libm.a and /usr/lib/libpthread.a.

Note: The GNU compiler now has the command line option «-pthread» while older versions of the compiler specify the pthread library explicitly with «-lpthread». Thus now you are more likely to see gcc src-file.c -lm -pthread

How to generate a static library (object code archive file):

• Compile: cc -Wall -c ctest1.c ctest2.c
  Compiler options:
  • -Wall: include warnings. See man page for warnings specified.
• Create library «libctest.a»: ar -cvq libctest.a ctest1.o ctest2.o
• List files in library: ar -t libctest.a
• Linking with the library:
  • cc -o executable-name prog.c libctest.a
  • cc -o executable-name prog.c -L/path/to/library-directory -lctest
• Example files:
  • ctest1.c
  • ctest2.c
  • prog.c

Historical note: After creating the library it was once necessary to run the command: ranlib ctest.a. This created a symbol table within the archive. Ranlib is now embedded into the «ar» command.

Note for MS/Windows developers: The Linux/Unix «.a» library is conceptually the same as the Visual C++ static «.lib» libraries.

How to generate a shared object: (Dynamically linked object library file.) Note that this is a two step process.

1. Create object code
2. Create library
3. Optional: create default version using a symbolic link.

Library creation example: This creates the library libctest.so.1.0 and symbolic links to it.

It is also valid to cascade the linkage: If you look at the libraries in /lib/ and /usr/lib/ you will find both methodologies present. Linux developers are not consistent. What is important is that the symbolic links eventually point to an actual library.

• -Wall: include warnings. See man page for warnings specified.
• -fPIC: Compiler directive to output position independent code, a characteristic required by shared libraries. Also see «-fpic».
• -shared: Produce a shared object which can then be linked with other objects to form an executable.
• -Wl,options: Pass options to linker.
  In this example the options to be passed on to the linker are: «-soname libctest.so.1«. The name passed with the «-o» option is passed to gcc.
• Option -o: Output of operation. In this case the name of the shared object to be output will be «libctest.so.1.0«

• The link to /opt/lib/libctest.so allows the naming convention for the compile flag -lctest to work.
• The link to /opt/lib/libctest.so.1 allows the run time binding to work. See dependency below.

Compile main program and link with shared object library:

Compiling for run-time linking with a dynamically linked libctest.so.1.0: Use: Where the name of the library is libctest.so. (This is why you must create the symbolic links or you will get the error «/usr/bin/ld: cannot find -lctest».)
The libraries will NOT be included in the executable but will be dynamically linked during run-time execution.

The shared library dependencies of the executable can be listed with the command: ldd name-of-executable

Example: ldd prog [Potential Pitfall] : Unresolved errors within a shared library may cause an error when the library is loaded. Example:

Error message at run-time:

The first three libraries show that there is a path resolution. The last two are problematic.

The fix is to resolve dependencies of the last two libraries when linking the library libname-of-lib.so:

• Add the unresolved library path in /etc/ld.so.conf.d/name-of-lib-x86_64.conf and/or /etc/ld.so.conf.d/name-of-lib-i686.conf
  Reload the library cache (/etc/ld.so.cache) with the command: sudo ldconfig
  or
• Add library and path explicitly to the compiler/linker command: -lname-of-lib -L/path/to/lib
  or
• Add the library path to the environment variable to fix run-time dependency:
  export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/path/to/lib

• Set path: export LD_LIBRARY_PATH=/opt/lib:$LD_LIBRARY_PATH
• Run: prog

Example with code:

Using the example code above for ctest1.c, ctest2.c and prog.c

1. Compile the library functions: gcc -Wall -fPIC -c ctest1.c ctest2.c
2. Generate the shared library: gcc -shared -Wl,-soname,libctest.so.1 -o libctest.so.1.0 ctest1.o ctest2.o
   This generates the library libctest.so.1.0
3. Move to lib/ directory:
   • sudo mv libctest.so.1.0 /opt/lib
   • sudo ln -sf /opt/lib/libctest.so.1.0 /opt/lib/libctest.so.1
   • sudo ln -sf /opt/lib/libctest.so.1 /opt/lib/libctest.so

   Compile program for use with a shared library: gcc -Wall -L/opt/lib prog.c -lctest -o prog
   [Potential Pitfall] : If the symbolic links are not created (above), you will get the following error: The reference to the library name -lctest refers to /opt/lib/libctest.so

4. Configure the library path (see below and choose one of three mechanisms).
   In this example we set the environment variable: export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/opt/lib
5. Run the program: ./prog
   [Potential Pitfall] : You get the following error if the library path is not set:

• gcc — GNU C compiler
• ld — The GNU Linker
• ldd — List library dependencies
• ldconfig — configure dynamic linker run time bindings (update cache /etc/ld.so.cache)

In order for an executable to find the required libraries to link with during run time, one must configure the system so that the libraries can be found. Methods available: (Do at least one of the following)

Add library directories to be included during dynamic linking to the file /etc/ld.so.conf

Add the library path to this file and then execute the command (as root) ldconfig to configure the linker run-time bindings.
You can use the «-f file-name» flag to reference another configuration file if you are developing for different environments.
See man page for command ldconfig.

Add specified directory to library cache: (as root)
ldconfig -n /opt/lib
Where /opt/lib is the directory containing your library libctest.so
(When developing and just adding your current directory: ldconfig -n . Link with -L.)

This will NOT permanently configure the system to include this directory. The information will be lost upon system reboot.

Specify the environment variable LD_LIBRARY_PATH to point to the directory paths containing the shared object library. This will specify to the run time loader that the library paths will be used during execution to resolve dependencies.
(Linux/Solaris: LD_LIBRARY_PATH, SGI: LD_LIBRARYN32_PATH, AIX: LIBPATH, Mac OS X: DYLD_LIBRARY_PATH, HP-UX: SHLIB_PATH)

Example (bash shell): export LD_LIBRARY_PATH=/opt/lib:$LD_LIBRARY_PATH or add to your

This instructs the run time loader to look in the path described by the environment variable LD_LIBRARY_PATH, to resolve shared libraries. This will include the path /opt/lib.

Library paths used should conform to the «Linux Standard Base» directory structure.

ar: list object files in archive library

This will list all of the object files held in the archive library: Also see: Man page for ar

nm: list symbols: object files, archive library and shared library

The command «nm» lists symbols contained in object files:

The command «nm» lists symbols contained in the archive library:

Object symbols in static archive libraries are categorized using the source and object file hierarchy of the library:

The command «nm» lists symbols contained in the object file or shared library.

Use the command nm -D libctest.so.1.0
(or nm --dynamic libctest.so.1.0)

Note that other platforms (Cygwin) may not respond to «-D». Try nm -gC libctest.so.1.0

Also see: Man page for nm

Symbol Type	Description
A	The symbol’s value is absolute, and will not be changed by further linking.
B	Un-initialized data section
D	Initialized data section
T	Normal code section
U	Undefined symbol used but not defined. Dependency on another library.
W	Doubly defined symbol. If found, allow definition in another library to resolve dependency.

Also see: objdump man page

readelf: list symbols in shared library

The command «readelf» command to list symbols contained in a shared library:

Use the command readelf -s /usr/lib64/libjpeg.so

Also see: readelf man page

Library versions should be specified for shared objects if the function interfaces are expected to change (C++ public/protected class definitions), more or fewer functions are included in the library, the function prototype changes (return data type (int, const int, . ) or argument list changes) or data type changes (object definitions: class data members, inheritance, virtual functions, . ).

The library version can be specified when the shared object library is created. If the library is expected to be updated, then a library version should be specified. This is especially important for shared object libraries which are dynamically linked. This also avoids the Microsoft «DLL hell» problem of conflicting libraries where a system upgrade which changes a standard library breaks an older application expecting an older version of the the shared object function.

Versioning occurs with the GNU C/C++ libraries as well. This often make binaries compiled with one version of the GNU tools incompatible with binaries compiled with other versions unless those versions also reside on the system. Multiple versions of the same library can reside on the same system due to versioning. The version of the library is included in the symbol name so the linker knows which version to link with.

One can look at the symbol version used: nm csub1.o

No version is specified in object code by default.

There is one GNU C/C++ compiler flag that explicitly deals with symbol versioning. Specify the version script to use at compile time with the flag: --version-script=your-version-script-file
Note: This is only useful when creating shared libraries. It is assumed that the programmer knows which libraries to link with when static linking. Run-time linking allows opportunity for library incompatibility.

GNU/Linux, see examples of version scripts here: sysdeps/unix/sysv/linux/Versions

Some symbols may also get version strings from assembler code which appears in glibc headers files. Look at include/libc-symbols.h.

Example: nm /lib/libc.so.6 | more

Note the use of a version script.

Library referencing a versioned library: nm /lib/libutil-2.2.5.so

These libraries are dynamically loaded / unloaded and linked during execution. Useful for creating a «plug-in» architecture.

Prototype include file for the library: ctest.h

Load and unload the library libctest.so (created above), dynamically:

gcc -rdynamic -o progdl progdl.c -ldl

• dlopen("/opt/lib/libctest.so", RTLD_LAZY);
  Open shared library named «libctest.so«.
  The second argument indicates the binding. See include file dlfcn.h.
  Returns NULL if it fails.
  Options:
  • RTLD_LAZY: If specified, Linux is not concerned about unresolved symbols until they are referenced.
  • RTLD_NOW: All unresolved symbols resolved when dlopen() is called.
  • RTLD_GLOBAL: Make symbol libraries visible.
• dlsym(lib_handle, "ctest1");
  Returns address to the function which has been loaded with the shared library..
  Returns NULL if it fails.
  Note: When using C++ functions, first use nm to find the «mangled» symbol name or use the extern "C" construct to avoid name mangling.
  i.e. extern "C" void function-name();

Object code location: Object code archive libraries can be located with either the executable or the loadable library. Object code routines used by both should not be duplicated in each. This is especially true for code which use static variables such as singleton classes. A static variable is global and thus can only be represented once. Including it twice will provide unexpected results. The programmer can specify that specific object code be linked with the executable by using linker commands which are passed on by the compiler.

Use the «-Wl» gcc/g++ compiler flag to pass command line arguments on to the GNU «ld» linker.

Example makefile statement: g++ -rdynamic -o appexe $(OBJ) $(LINKFLAGS) -Wl,--whole-archive -L -laa -Wl,--no-whole-archive $(LIBS)

• —whole-archive: This linker directive specifies that the libraries listed following this directive (in this case AA_libs) shall be included in the resulting output even though there may not be any calls requiring its presence. This option is used to specify libraries which the loadable libraries will require at run time.
• -no-whole-archive: This needs to be specified whether you list additional object files or not. The gcc/g++ compiler will add its own list of archive libraries and you would not want all the object code in the archive library linked in if not needed. It toggles the behavior back to normal for the rest of the archive libraries.

• dlopen() — gain access to an executable object file
• dclose() — close a dlopen object
• dlsym() — obtain the address of a symbol from a dlopen object
• dlvsym() — Programming interface to dynamic linking loader.
• dlerror() — get diagnostic information

C++ and name mangling:

When running the above «C» examples with the «C++» compiler one will quickly find that «C++» function names get mangled and thus will not work unless the function definitions are protected with extern "C"<>.

Note that the following are not equivalent:

The following are equivalent:

Dynamic loading of C++ classes:

The dynamic library loading routines enable the programmer to load «C» functions. In C++ we would like to load class member functions. In fact the entire class may be in the library and we may want to load and have access to the entire object and all of its member functions. Do this by passing a «C» class factory function which instantiates the class.

The class «.h» file:

The class «.cpp» file:

Main executable which calls the loadable libraries:

Pitfalls:

• The new/delete of the C++ class should both be provided by the executable or the library but not split. This is so that there is no surprise if one overloads new/delete in one or the other.

The Microsoft Windows equivalent to the Linux / Unix shared object («.so») is the «.dll». The Microsoft Windows DLL file usually has the extension «.dll», but may also use the extension «.ocx». On the old 16 bit windows, the dynamically linked libraries were also named with the «.exe» suffix. «Executing» the DLL will load it into memory.

The Visual C++ .NET IDE wizard will create a DLL framework through the GUI, and generates a «.def» file. This «module definition file» lists the functions to be exported. When exporting C++ functions, the C++ mangled names are used. Using the Visual C++ compiler to generate a «.map» file will allow you to discover the C++ mangled name to use in the «.def» file. The «SECTIONS» label in the «.def» file will define the portions which are «shared». Unfortunately the generation of DLLs are tightly coupled to the Microsoft IDE, so much so that I would not recommend trying to create one without it.

The Microsoft Windows C++ equivalent functions to libdl are the following functions:

• ::LoadLibrary() — dlopen()
• ::GetProcAddress() — dlsym()
• ::FreeLibrary() — dlclose()

[Potential Pitfall] : Microsoft Visual C++ .NET compilers do not allow the linking control that the GNU linker «ld» allows (i.e. —whole-archive, -no-whole-archive). All symbols need to be resolved by the VC++ compiler for both the loadable library and the application executable individually and thus it can cause duplication of libraries when the library is loaded. This is especially bad when using static variables (i.e. used in singleton patterns) as you will get two memory locations for the static variable, one used by the loadable library and the other used by the program executable. This breaks the whole static variable concept and the singleton pattern. Thus you can not use a static variable which is referenced by by both the loadable library and the application executable as they will be unique and different. To use a unique static variable, you must pass a pointer to that static variable to the other module so that each module (main executable and DLL library) can use the same instantiation. On MS/Windows you can use shared memory or a memory mapped file so that the main executable and DLL library can share a pointer to an address they both will use.

Cross platform (Linux and MS/Windows) C++ code snippet:

Источник