Our Gallery where we can share our knowledge: Create static library, shared library

1. Static library

1.1. Example code files

/* mod1.c */

#include stdio.h

#include unistd.h

int test1[250000] = { 1, 2, 3 };

#ifndef VERSION

#define VERSION ""

#endif

void

x1(void) { 

    printf("Called mod1-x1 " VERSION "\n"); 

    sleep(10);

    printf("exiting x1\n");

} 

/* mod2.c */

#include stdio.h

#include unistd.h

int test2[100000] = { 1, 2, 3 };

#ifndef VERSION

#define VERSION ""

#endif

void

x2(void) { 

    printf("Called mod2-x2 " VERSION "\n"); 

    sleep(10);

    printf("exiting x2\n");

} 

/* mod3.c */

#include stdio.h

#include unistd.h

int test3[10000] = { 1, 2, 3 };

#ifndef VERSION

#define VERSION ""

#endif

void

x3(void) { 

    printf("Called mod3-x3 " VERSION "\n"); 

    sleep(10);

    printf("exiting x3\n");

} 

/*#* prog.c */

#include stdio.h 

#include stdlib.h

void x1(void);

void x2(void);

int

main(int argc, char *argv[])

{

    x1();

    x2();

    exit(EXIT_SUCCESS);

} /* main */

1.2. Simple way of building a program:

$ cc -c -g prog.c mod1.c mod2.c mod3.c
$ cc -o prog_nolib prog.o mod1.o mod2.o mod3.o

1.3. Use static library

Compile object file:

$ cc -c mod1.c mod2.c mod3.c

Create library “libtest.a” :

$ ar -cvq libtest.a mod1.c mod2.c mod3.c

List file in library:

$ ar -t libtest.a

Linking executable file with library:

$ cc –o prog prog.c libtest.a
Or
$ cc –o prog prog.c –L/path/to/library-directory –lctest

1.4. Disvantages:

Disk space is wasted wasted storing multiple copies of object modules.
Memory is wasted when several different programs using the same modules execute at the same time, because each program holds hold separate copies of the object modules in virtual memory.
Programs must be relinked in order to see changes to object modules.

2. Shared library

2.1. Concept and Advantages

Create single copy of all object modules, which is shared by all applications at run-time

Advantages:

- Programs do not need to be relinked to see changes in library code(Because object modules are not copied into executable files)
- Programs are smaller: disk space and virtual memory requirements are reduced.

2.2. Create and using a shared library

Create the object modules using -fPIC:

$ gcc -fPIC -g -c -Wall mod1.c mod2.c mod3.c

-fPIC (Position Independent Code) causes compiler to generate code that can be loaded anywhere in virtual memory at run-time.

Create the shared library:

$ gcc -shared -o libfoo.so mod1.o mod2.o mod3.o

Link program against library :

$ gcc -g -Wall -o prog prog.c libfoo.so

or:

$ gcc -g -Wall -o prog prog.c -L. –lfoo

Execute the program

$ ./prog

./prog: error in loading shared libraries: libfoo.so: cannot open shared object file: No such file or directory - We need to give the dynamic linker information on how to find our shared library at run-time

- Dynamic linker searches these directories before looking in standard library directories.

$ LD_LIBRARY_PATH=. ./prog

Called mod1-x1

exiting x1

Called mod2-x2

exiting x2

2.3. The shared library soname

In the earlier example, we embedded the actual name (the real name) of the shared library in an executable file.
It is possible to create an alias, called the soname, which will be embedded in an executable file instead of the real name.
At run-time, the dynamic linker will use the soname when searching for the library

The purpose of the soname is to provide a level of indirection: At run-time, executable can use a version of the shared library that is different (but compatible) from that against which it was linked

Specify soname when creating shared library

$ gcc -fPIC -c -Wall -g mod1.c mod2.c mod3.c
$ gcc -shared -Wl,-soname,libbar.so -o libfoo.so mod1.o mod2.o mod3.o
-Wl,-soname,libbar.so instructs linker to mark the shared library libfoo.so with the soname libbar.so.

Create executable:

$ gcc -g -Wall -o prog prog.c libfoo.so
Linker detects that libfoo.so contains the soname libbar.so and embeds the latter name inside the executable.

Run the program:

$ LD_LIBRARY_PATH=. ./prog
./prog: error in loading shared libraries: libbar.so: cannot open shared object file: No such file or directory
Dynamic linker cannot find anything named libbar.so.

Create a symbolic link from the soname to the real name of the library

$ ln -s libfoo.so libbar.so
$ LD_LIBRARY_PATH=. ./prog
Called mod1-x1
Called mod2-x2

At run-time this link can point to a version of the library which is different from the version against which linking was performed.

fig 1. Steps required in building a shared library, linking a program against it, and creating the required soname symbolic link.

fig 2. The steps that occur as the program is executed

2.4. Shared library versions and naming

If a new version of a shared library is compatible with an existing library, we can make a new minor version of the library.

If a new version of a shared library is incompatible with an existing library, we must make a new major version of the library.

2.5. Creating shared libraries using standard naming conventions

Create the shared library with real name libdemo.so.1.0.1 and soname libdemo.so.1.

$ gcc -fPIC -g -c -Wall mod1.c mod2.c mod3.c

$ gcc -shared -Wl,-soname,libdemo.so.1 -o libdemo.so.1.0.1 mod1.o mod2.o mod3.o

Create symbolic links for the soname and linker name:

$ ln -s libdemo.so.1.0.1 libdemo.so.1

$ ln -s libdemo.so.1 libdemo.so

Build executable using the linker name:

$ gcc -g -Wall -o ./prog prog.c -L. -ldemo

Run the program as usual:

$ LD_LIBRARY_PATH=. ./prog

Called mod1-x1

Called mod2-x2

2.6. Installing shared libraries

Production applications should not require the user to set LD_LIBRARY_PATH
We can install a shared library in one of the standard library directories

- /usr/lib/ - directory in which most standard library directories:
- /lib - directory containing libraries
- /usr/local/lib - non-standard or experimental libraries should be install here

After installation, symbolic links for soname and linker name must be created, as relative links in the same directory.
Example install in /usr/lib

$ mv libdemo.so.1.0.1 /usr/lib
cd /usr/lib
ln -s libdemo.so.1.0.1 libdemo.so.1
ln -s lindemo.so.1 libdemo.so

2.7. Upgrading Shared libraries

Example - upgrading a shared library with a new minor version (1.0.2)

$ gcc -fPIC -g -c -Wall mod1.c mod2.c mod3.c
$ gcc -shared -Wl,-soname,libdemo.so.1 -o libdemo.so.1.0.2 mod1.o mod2.o mod3.o
$ mv libdemo.so.1.0.2 /usr/lib
$ ldconfig -v | grep libdemo
libdemo.so.1 -> libdemo.so.1.0.2 (changed)

Assuming the linker name was already correctly set up, we do not need to modify it.
Then upgrading to a new major version (2.0.1):

$ gcc -fPIC -g -c -Wall mod1.c mod2.c mod3.c
$ gcc -shared -Wl,-soname,libdemo.so.2 -o libdemo.so.2.0.1 mod1.o mod2.o mod3.o

                $ mv libdemo.so.2.0.1 /usr/lib

                $ ldconfig -v | grep libdemo

                          libdemo.so.1 -> libdemo.so.1.0.2

                          libdemo.so.2 -> libdemo.so.2.0.1 (changed)

                $ cd /usr/lib

                $ ln -sf libdemo.so.2 libdemo.so


ldconfig automatically creates a soname symbolic link, but we must manually update the linker name symbolic link.


2.8. Dynamically Loaded Libraries
The dlopen API allows a program to :

Open a shared library at run time
search for function( or variable ) by name in lobrary
and the call the function ( or access the variable)


dlopen API:

Four key functions: dlopen(), dlerror(), dlsym(), and dlclose().



void *dlopen(const char *filename, int flag);

dlopen() opens library, and increments the library's count of open references.

If filename contains a slash (/), dlopen() interprets it as an (absolute or relative) pathname...


otherwise it employs the usual library search rules. 


The flag argument is a bit mask that must include one of the following:

              - RTLD_LAZY: symbol referenced by library should be resolved only as code is executed. 
              - RTLD_NOW: all symbols references should be resolved before dlopen() completes

dlopen() returns a handle that is used to refer to the library in later calls, or NULL if an error occurred (e.g., library couldn't be found).


const char *dlerror(void);

dlerror() returns a pointer to a message string after an error return from dlopen(), dlsym(), or dlclose().

Returns NULL if no error has occurred since last call to dlerror().



void *dlsym(void *handle, char *symbol);

dlsym() searches a library to find a symbol (e.g., a function) and return its address.

For a function, we can dereference this pointer to call the function. 


Returns NULL if symbol could not be found. 


Complication: the value of a symbol may be NULL (0), which is indistinguishable from "symbol not found". To differentiate the two possibilities, call dlerror() beforehand.


int dlclose(void *handle);

dlclose() decrements the count of open references to the library.

If reference count falls to zero, library is unloaded. 



Example- dynload.c

#define _GNU_SOURCE

/*#}*/

#include <stdio.h>

#include <stdlib.h>

#include <dlfcn.h

int

main(int argc, char *argv[])

{

    void *libHandle;  /* Handle for shared library */

    void (*funcp)(void); /* Pointer to function with no args */

    char *err;

    if (argc != 3) {  /* Check command line arguments */

        fprintf(stderr, "Usage: %s lib-path func-name\n", argv[0]);

        exit(EXIT_FAILURE);

    } /* if */

    /* Load the shared library and get a handle for later use */

    libHandle = dlopen(argv[1], RTLD_LAZY);

    if (libHandle == NULL) {

 fprintf(stderr, "Error on dlopen: %s\n", dlerror());

 exit(EXIT_FAILURE);

    } /* if */

    /* Get a pointer to named function inside library */

    (void) dlerror();    /* Clear dlerror() */

    funcp = dlsym(libHandle, argv[2]);

    err = dlerror();     

    if (err != NULL) {  /* Non-NULL from dlerror() means we got error */

 fprintf(stderr, "Error on dlsym: %s\n", err);

 exit(EXIT_FAILURE);

    } /* if */

/*#{{*/

    {

 Dl_info dli;

 dladdr(funcp, &dli);

 printf("Lib name = %s\n", dli.dli_fname);

 printf("Load address = 0x%lx\n", (long) dli.dli_fbase);

 printf("Name of nearest sym = %s\n", dli.dli_sname);

 printf("Load address = 0x%lx\n", (long) dli.dli_saddr);

    }

/*#}*/

    /* If the function address is non-NULL try calling it */

    if (funcp == NULL)

 printf("%s is NULL\n", argv[2]);

    else

        (*funcp)();

    /* And close the library */

    dlclose(libHandle);

    exit(EXIT_SUCCESS);

} /* main */

<span style="font-family: "arial" , "helvetica" , sans-serif;">

</span>

Compile and run this program:

Reference:

http://man7.org/conf/lca2006/shared_libraries/index.html

Our Gallery where we can share our knowledge

Translate

Chủ Nhật, 4 tháng 12, 2016

Create static library, shared library