Static Shared Library

1
Static Shared Library
2
Non-shared v.s. Shared Library

• A library is a collection of pre-written function
  calls.
• Using existing libraries can save a programmer a
  lot of time. (e.g., the printf() in the C
  library)
• However, if a library is not shared among many
  programs, but instead a copy is included in every
  program that uses it, the size of each linked
  program will be large.
• Also, a lot of disk and memory space will be
  wasted by these programs that uses non-shared
  libraries.
• This motivates the concept of shared library.

3
How Does It Work?

• At link time, the linker searches through
  libraries to find modules that resolve undefined
  external symbols.
• Rather than copying the contents of the module
  into the output file, the linker makes a note of
  what library the module come from and puts a list
  of the libraries in the executable.
• When the program is loaded , startup code finds
  those libraries and maps them into the programs
  address space before the program starts.
• Standard operating system file-mapping semantics
  automatically share pages that are mapped
  read-only or copy-on-write.

4
(No Transcript)
5
An Example Program

• include ltmath.hgt
• main()
• printf("exponential value d\n", exp(-1))

6
Its Shared Library Usage Information

• Program Header
• PHDR off 0x00000034 vaddr 0x08048034 paddr
  
• 0x08048034 align 22
• filesz 0x000000c0 memsz 0x000000c0 flags
  r-x
• DYNAMIC off 0x000005f4 vaddr 0x080495f4
  paddr
• 0x080495f4 align 22
• filesz 0x00000078 memsz 0x00000078 flags
  rw-
• Dynamic Section
• NEEDED libm.so.2
• NEEDED libc.so.4

7
Linking Shared Libraries

• The most difficult aspect of static shared
  libraries is address space management.
• Each shared library occupies a fixed piece of
  address space in each program in which it is
  used.
• Different libraries have to use non-overlapping
  addresses if they can be used in the same
  program.
• Assigning address space to libraries is a black
  art.
• On one hand, you want to leave some space in
  between them to allow version updates.
• On the other hand, you like to put popular
  libraries as close together as possible to
  minimize the number of page tables needed.

8
Address Space Allocation Example

• shieyuan3 ldd a.out
• a.out
• libm.so.2 gt /usr/lib/libm.so.2
  (0x28065000)
• libc.so.4 gt /usr/lib/libc.so.4
  (0x28080000)

9
Address Space Management

• Generally both the code and the data addresses
  for each library are explicitly defined, with the
  data area starting on a page boundary a page or
  two after the end of the code.
• This makes it possible to create minor version
  updates, because updates frequently do not change
  the data layout, but just add or change code.

10
Techniques for Minor Updates

• Each individual shared library exports symbols,
  both code and data, and usually also imports
  symbols if the library depends on other
  libraries.
• To allow library updates, we need a method to
  update a library without changing the addresses
  of exported symbols.
• For code addresses, rather than exporting the
  address of each routine, the library contains a
  table of jump instructions that jump to all of
  the routines, with the addresses of the jump
  instructions exported as the addresses of the
  routines.
• The performance cost is one extra jump. Normally
  this is acceptable.

11
Techniques for Minor Updates

• For exported data, the situation is more
  difficult, because there is no easy way to add a
  level of indirection like to one for code
  addresses.
• In practice, however, exported data tend to be
  tables (e.g., the File structure for the C
  library) of known size or a single word value
  like errno.
• We can collect these data and place them at the
  beginning of the data section to precede any
  anonymous data that are part of individual
  routines.

12
Binding Time

• Shared libraries raise binding time issues that
  do not apply to conventionally linked program.
• A program that uses a shared library depends on
  having that shared library available when the
  program is run.
• One kind of error occurs when the required
  libraries are not present.
• In such a case, there is no much we can do. An
  error message is usually printed.

13
Binding Time (contd)

• What will happen if the library is present but
  the library has changed since the program was
  linked?
• With static shared libraries, symbols are still
  bound to addresses at link time, but library code
  is not bound to the executable code until run
  time.
• A static shared library cannot change very much
  without breaking the programs that it is bound
  to.
• If we change the addresses of routine and data in
  the new version of library, then the program will
  crash.

14
Binding Time (contd)

• A static shared library can sometimes be updated
  without breaking the program that uses it, if the
  updates can be made in a way that does not move
  any address in the library.
• This permits minor version updates, typically for
  small bug fixes.
• Larger changes unavoidably change program
  addresses, which means that a system needs
  multiple versions of the library.
• E.g., libc.so.4

15
Structure of Shared Library

• The shared library is an executable format file.
• The jump table is considered to be text, because
  it is executable code.