shared-libraries

Windows provides the resource file for version information for an application and DLL. The resource file includes information like version, copyright and manufacturer. We have an shared library and like to add version information. How can we do it on Linux with a shared library? The short version is that you do this via the soname of the library. Read chapter 3 at http://tldp.org/HOWTO/Program-Library-HOWTO/shared-libraries.html as well as chapter 3.3 ABI Versioning at http://www.akkadia.org/drepper/dsohowto.pdf Linux uses the following strategy - you (the system maintainer) provide symlinks

I am running Linux, and I would like to be able to make parallel function calls into a shared library (.so) which is unfortunately not threadsafe (I am guessing it has global datastructures). For performance reasons, I do not want to simply wrap the function calls in a mutex. What I would like to do is to spawn, say 4 threads, and also load 4 copies of the same library into the process memory. Each thread then makes the function calls into its own copy of the library. Unfortunately, dlopen does not allow me to load more one instance of any library. Does anyone know of any method which will

This question already has an answer here: Hierarchical ldd(1) 4 answers I need a tool to show all the shared library dependencies in some graphical way, not just with ldd on each .so . For MS Windows Dependency Walker works. Is there anything for Linux? . Try binscan or ELF Library Viewer 来源： https://stackoverflow.com/questions/6977298/dependency-walker-equivalent-for-linux

Is there a way for a shared library to be "notified" when it is loaded? In other words, let's say I use dlopen on a shared library, is there a function that is automatically called (if present) on the shared library (e.g. main?) Libraries should export initialization and cleanup routines using the gcc __attribute__((constructor)) and __attribute__((destructor)) function attributes. See the gcc info pages for information on these. Constructor routines are executed before dlopen returns (or before main() is started if the library is loaded at load time). Destructor routines are executed before

Is there a difference between setting the JVM argument -Djava.library.path=/path at JVM start and setting the Linux environment variable export LD_LIBRARY_PATH=/path before the JVM is started? What are the advantages/disadvantages of the two approaches? The first form -Djava.library.path=/path will be handled in java bytecode level, System.loadLibrary will call Runtime.loadLibary , then will call java/lang/ClassLoader.loadLibrary . In the function call ClassLoader.loadLibrary , the system property java.library.path will be checked to get the full path of the library and pass this full path to

Does anyone know why a library initialized within dlopen() would initialize a static variable owned by the main program. Both the main program and shared library have a copy of the static variable, but for some reason the shared library re-initializes the main program's copy of the static variable and destructs it, causing a segfault when the main program attempts to destruct it. Is this a case of bad name mangling in the symbol table? This is a case where the runtime linker only wants a single active copy of a symbol in a process. If both a shared object and the executable have a copy of the