When the application starts, the dynamic linker looks at the DT_NEEDED field to find the required libraries. This field contains the soname of the library, so the next step is for the dynamic linker to walk through all the libraries in its search path looking for it.

This process conceptually involves two steps. Firstly the dynamic linker needs to search through all the libraries to find those that implement the given soname. Secondly the file names for the minor revisions need to be compared to find the latest version, which is then ready to be loaded.

We mentioned previously that there is a symbolic link setup by ldconfig between the library soname and the latest minor revision. Thus the dynamic linker should need to only follow that link to find the correct file to load, rather than having to open all possible libraries and decide which one to go with each time the application is required.

Since file system access is so slow, ldconfig also creates a cache of libraries installed in the system. This cache is simply a list of sonames of libraries available to the dynamic linker and a pointer to the major version link on disk, saving the dynamic linker having to read entire directories full of files to locate the correct link. You can analyse this with /sbin/ldconfig -p; it actually lives in the file /etc/ldconfig.so.cache. If the library is not found in the cache the dynamic linker will fall back to the slower option of walking the file system, thus it is important to re-run ldconfig when new libraries are installed.

It is often very useful for a programmer to be able to override a symbol in a library; that is to subvert the normal symbol with a different definition.

We mentioned that the order that libraries is searched is given by the order of the DT_NEEDED fields within the library. However, it is possible to insert libraries as the last libraries to be searched; this means that any symbols within them will be found as the final reference.

This is done via an environment variable called LD_PRELOAD which specifies libraries that the linker should load last.

 1 |$ cat override.c
   |#define _GNU_SOURCE 1
   |#include <stdio.h>
   |#include <stdlib.h>
 5 |#include <unistd.h>
   |#include <sys/types.h>
   |#include <dlfcn.h>
   | 
   |pid_t getpid(void)
10 |{
   |        pid_t (*orig_getpid)(void) = dlsym(RTLD_NEXT, "getpid");
   |        printf("Calling GETPID\n");
   | 
   |        return orig_getpid();
15 |}
   | 
   |$ cat test.c
   |#include <stdio.h>
   |#include <stdlib.h>
20 |#include <unistd.h>
   | 
   |int main(void)
   |{
   |        printf("%d\n", getpid());
25 |}
   | 
   |$ gcc -shared -fPIC -o liboverride.so override.c -ldl
   |$ gcc -o test test.c
   |$ LD_PRELOAD=./liboverride.so ./test
30 |Calling GETPID
   |15187

In the above example we override the getpid function to print out a small statement when it is called. We use the dlysm function provided by libc with an argument telling it to continue on and find the next symbol called getpid.

We have seen how we can override a function in another library by preloading another shared library with the same symbol defined. The symbol that gets resolved as the final one is the last one in the order that the dynamic loader loads the libraries.

Libraries are loaded in the order they are specified in the DT_NEEDED flag of the binary. This in turn is decided from the order that libraries are passed in on the command line when the object is built. When symbols are to be located, the dynamic linker starts at the last loaded library and works backwards until the symbol is found.

Some shared libraries, however, need a way to override this behaviour. They need to say to the dynamic linker "look first inside me for these symbols, rather than working backwards from the last loaded library". Libraries can set the DT_SYMBOLIC flag in their dynamic section header to get this behaviour (this is usually set by passing the -Bsymbolic flag on the static linkers command line when building the shared library).

What this flag is doing is controlling symbol visibility. The symbols in the library can not be overridden so could be considered private to the library that is being loaded.

However, this loses a lot of granularity since the library is either flagged for this behaviour, or it is not. A better system would allow us to make some symbols private and some symbols public.

That better system comes from symbol versioning. With symbol versioning we specify some extra input to the static linker to give it some more information about the symbols in our shared library.

 1 |$ cat Makefile
   |all: test testsym
   | 
   |clean:
 5 |        rm -f *.so test testsym
   | 
   |liboverride.so : override.c
   |        $(CC) -shared -fPIC -o liboverride.so override.c
   | 
10 |libtest.so : libtest.c
   |        $(CC) -shared -fPIC -o libtest.so libtest.c
   | 
   |libtestsym.so : libtest.c
   |        $(CC) -shared -fPIC -Wl,-Bsymbolic -o libtestsym.so libtest.c
15 | 
   |test : test.c libtest.so liboverride.so
   |        $(CC) -L. -ltest -o test test.c
   | 
   |testsym : test.c libtestsym.so liboverride.so
20 |        $(CC) -L. -ltestsym -o testsym test.c
   | 
   |$ cat libtest.c
   |#include <stdio.h>
   | 
25 |int foo(void) {
   |        printf("libtest foo called\n");
   |        return 1;
   |}
   | 
30 |int test_foo(void)
   |{
   |        return foo();
   |}
   | 
35 |$ cat override.c
   |#include <stdio.h>
   | 
   |int foo(void)
   |{
40 |        printf("override foo called\n");
   |        return 0;
   |}
   | 
   |$ cat test.c
45 |#include <stdio.h>
   | 
   |int main(void)
   |{
   |        printf("%d\n", test_foo());
50 |}
   | 
   |$ cat Versions
   |{global: test_foo;  local: *; };
   | 
55 |$ gcc -shared -fPIC -Wl,-version-script=Versions -o libtestver.so libtest.c
   | 
   |$ gcc -L. -ltestver -o testver test.c
   | 
   |$ LD_LIBRARY_PATH=. LD_PRELOAD=./liboverride.so ./testver
60 |libtest foo called
   | 
   |100000574 l     F .text	00000054              foo
   |000005c8 g     F .text	00000038              test_foo

In the simplest case as above, we simply state if the symbol is global or local. Thus in the case above the foo function is most likely a support function for test_foo; whilst we are happy for the overall functionality of the test_foo function to be overridden, if we do use the shared library version it needs to have unaltered access nobody should modify the support function.

This allows us to keep our namespace better organised. Many libraries might want to implement something that could be named like a common function like read or write; however if they all did the actual version given to the program might be completely wrong. By specifying symbols as local only the developer can be sure that nothing will conflict with that internal name, and conversely the name he chose will not influence any other program.

An extension of this scheme is symbol versioning. With this you can specify multiple versions of the same symbol in the same library. The static linker appends some version information after the symbol name (something like @VER) describing what version the symbol is given.

If the developer implements a function that has the same name but possibly a binary or programatically different implementation he can increase the version number. When new applications are built against the shared library, they will pick up the latest version of the symbol. However, applications built against earlier versions of the same library will be requesting older versions (e.g. will have older @VER strings in the symbol name they request) and thus get the original implementation. XXX : example