linux中动态链接库的搜索顺序
linux动态链接库全局变量共享问题DLL共享数据段
linux动态链接库全局变量共享问题DLL共享数据段注意：本⽂中的⼤部分是阅读《程序员的⾃我修养》作 者：俞甲⼦，⽯凡，潘爱民的读书笔记。
推荐⼤家看看这本书。
⼀，动态链接操作系统将把程序依赖的⽬标⽂件全部加载到内存，如果依赖关系满⾜，则系统开始进⾏链接。
链接与静态链接相似，即进⾏符号解析、地址重定位。
例如程序program1和program2都依赖于lib.o，⽽在运⾏program1的时候，lib.o已经被加载，那么在运⾏program2的时候，系统不需要加载lib.o，⽽只是将program2和lib.o进⾏链接。
这样不仅仅节省内存，还减少了内存物理页⾯的换⼊换出，增加CPU缓存命中。
动态链接的另外⼀个特点是程序运⾏时可以动态选择加载各种程序模块。
这个优点即⼈们制作程序的插件（Plug-in）。
例如⼀个公司制定的产品，并制定了接⼝。
其他公司按照这些借⼝编写符合要求的动态链接库，程序可以动态载⼊这些开发的模块，程序运⾏时动态的链接，拓展程序的功能。
动态链接也增加了程序兼容性，⽐如不同操作系统的库都提供了printf，在该库之上的代码，可以跨不同操作系统。
⼆，动态链接的实现动态链接使⽤的物件，理论上是可以是⽬标⽂件的，但是实际上动态连接库与⽬标⽂件稍有差别。
动态链接涉及运⾏时链接，需要操作系统⽀持，⼀些存储管理，共享内存、进程线程机制，在动态链接下，也会与静态链接不同。
Linux下，ELF动态链接⽂件称作DSO（动态共享对象），Windows下，⼀般DLL。
Linux下常⽤C语⾔运⾏库glibc，其动态链接库形式版本在/lib⽬录下的libc.so。
程序加载时，动态链接器将所有动态连接库装载到进程地址空间，将程序中未决议符号绑定到相应的动态链接库，进⾏重定位⼯作。
由于每次加载需要动态的链接，所以性能有损失，采取延迟绑定（Lazy Binding）可以对其进⾏优化。
三，⼀个例⼦Program1.c:#include "Lib.h"int main(){foobar(1);return 0;}Program2.c:#include "Lib.h"int main(){foobar(2);return 0;}Lib.h:#ifndef LIB_H#define LIB_Hvoid foobar(int i);#endiflib.c:#include <stdio.h>void foobar(int i){printf("Printing from Lib.so %d/n",i);sleep(-1);}使⽤如下编译 gcc -fPIC -shared -o Lib.so Lib.c编译链接program1和program2：gcc -o Program1 Program1.c ./Lib.sogcc -o Program2 Program2.c ./Lib.so在静态链接器链接program1和program2的过程中，它必须知道foobar这个函数的性质。
ld-linux.so 原理
ld-linux.so 原理
ld-linux.so是Linux系统中的动态链接器，它的主要作用是
在程序运行时加载动态链接库，并解析程序所需的符号。
动态链接
器的工作原理涉及到动态链接库的加载、符号解析、重定位等方面。
首先，当一个程序启动时，操作系统会加载可执行文件到内存中，并调用动态链接器ld-linux.so来处理动态链接库的加载。
动
态链接器会根据可执行文件中的动态链接库依赖信息，找到这些动
态链接库的位置，并将它们加载到内存中。
其次，动态链接器会进行符号解析，即找到程序中调用的函数
或变量对应的地址。
这个过程涉及到符号表的查找和匹配，确保程
序能够正确调用动态链接库中的函数和变量。
另外，动态链接器还会进行重定位操作，将动态链接库中的地
址引用重定位到正确的地址上，以确保程序能够正确地访问动态链
接库中的函数和变量。
总的来说，ld-linux.so的原理就是在程序运行时负责加载动
态链接库，并进行符号解析和重定位操作，以确保程序能够正常地
调用动态链接库中的函数和变量。
这样可以实现代码的共享和复用，提高程序的灵活性和可维护性。
Linux 使用搜索功能
Linux 使用搜索功能
在使用Linux系统过程中，用户有时需要使用系统中的某一个文件，但这个文件可能并不容易找到，这时就需要使用系统中的搜索文件功能。
具体操作如下：（1）在系统面板中，执行【位置】|【搜索文件】命令，桌面上将会弹出【搜索文件】对话框，如图59所示。
（2）在【搜索文件】对话框中，主要分为搜索区与搜索结果显示区两部分。
当用户搜索文件时先在【名称包含】文本框中输入想要搜索的文件名或扩展名等，如图60所示。
图59 执行【搜索文件】命令图60 【搜索文件】对话框
（3）在【搜索文件夹】下拉列表框中选择搜索范围。
如果用户知道的搜索范围较详细，可单击【搜索文件夹】下拉列表框中的【其它】选项，会弹出【浏览】对话框，如图61所示。
（4）在【浏览】对话框中可以打开更深层的目录，选好要搜索的具体范围后单击【打开】按钮，系统会回到【搜索文件夹】对话框，这样便缩小了搜索范围，提高搜索效率，如图62所示。
图61 【搜索文件夹】列表框图62 【浏览】对话框
（5）当用户可对要寻找的文件名称记忆并不准确，但对于该文件的一些其他特征如文件大小、修改时间和文件所属用户等记得比较清楚时，可以通过单击【选择更多选项】和【添加】按钮来对这些特征加以约束，【删除】按钮用于删除不需要的约束条件，如图63所示。
最后，通过单击【查找】按钮，对所需要的文件进行搜索，如图64所示。
图63 选择更多选项图64 搜索文件。
动态库依赖动态库，静态库依赖静态库，顺序
动态库依赖动态库，静态库依赖静态库，顺序静态库依赖静态库，有顺序的问题，否则undefined reference⾄于动态链接，链接器会对依赖进⾏整理，避免这个问题。
动态库就不存在依赖顺序的问题。
如果库是相互独⽴的，则顺序不重要。
如果不是相互独⽴，那么必须对它们进⾏排序对于⽇常命令⾏编译命令，⼀般从左到右分别是可执⾏⽂件 ——> ⾼级库 ——> 底层库，避免循环依赖；越是底层的库，越是往后⾯写，可以参考下述命令通式：g++ ... obj($?) -l(上层逻辑lib) -l(中间封装lib) -l(基础lib) -l(系统lib) -o $@静态库有顺序问题，并且要把⾃⼰的库所依赖的所有的第三⽅库都要显⽰的指定出来。
动态库⽆顺序问题，并且只需要显⽰的连接⾃⼰的动态库，⾃⼰的动态库依赖的第三⽅的动态库⽆需显⽰指定，⾃⼰会从rpath中⾃动连接第三⽅的动态库。
但必须把第三⽅库依赖的所有的库，包括路径都拷贝出来。
例如使⽤libevent.so, 此时需要把下⾯这⼀堆⽂件都拷贝出来：lrwxrwxrwx. 1 root root 21 Mar 25 15:18 deps/so/libevent-2.1.so.7 -> libevent-2.1.so.7.0.1-rwxr-xr-x. 1 root root 386024 Mar 25 15:18 deps/so/libevent-2.1.so.7.0.1lrwxrwxrwx. 1 root root 26 Mar 25 15:17 deps/so/libevent_core-2.1.so.7 -> libevent_core-2.1.so.7.0.1-rwxr-xr-x. 1 root root 241936 Mar 25 15:17 deps/so/libevent_core-2.1.so.7.0.1lrwxrwxrwx. 1 root root 26 Mar 25 15:17 deps/so/libevent_core.so -> libevent_core-2.1.so.7.0.1lrwxrwxrwx. 1 root root 21 Mar 25 15:18 deps/so/libevent.so -> libevent-2.1.so.7.0.1把第三⽅静态库链接到⾃⼰的.so动态库，编译第三⽅静态库的时候需要加 -fPIC这个参数。
linux动态库调用方法
linux动态库调用方法Linux动态库调用方法动态库是一种程序库，它在程序运行时才会被加载和链接，相对于静态库来说，动态库更加灵活和高效。
在Linux系统中，动态库的调用方法有多种，本文将介绍其中的一些常用方法。
1. 静态调用静态调用是指在编译链接阶段将动态库的代码完全复制到可执行文件中，使得可执行文件不再依赖于动态库。
在Linux系统中，静态调用需要使用静态库文件（以.a为后缀），可以通过在编译命令中添加-l参数来指定静态库文件的路径。
例如：```gcc main.c -L/path/to/lib -lmylib -o main```其中，/path/to/lib是动态库所在的路径，mylib是动态库的名称，main是生成的可执行文件名。
2. 动态调用动态调用是指在程序运行时动态加载和链接动态库。
在Linux系统中，动态调用需要使用动态库文件（以.so为后缀），可以通过以下几种方法进行动态调用。
（1）dlopen/dlsymdlopen和dlsym是Linux系统提供的动态库加载和符号查找函数。
dlopen函数用于加载动态库，dlsym函数用于查找动态库中的符号。
可以通过以下代码进行调用：```c#include <dlfcn.h>void* handle = dlopen("/path/to/libmylib.so", RTLD_LAZY);if (handle == NULL) {printf("Failed to load library: %s\n", dlerror());return -1;}void (*function)() = dlsym(handle, "my_function");if (function == NULL) {printf("Failed to find symbol: %s\n", dlerror());dlclose(handle);return -1;}function();dlclose(handle);```其中，/path/to/libmylib.so是动态库所在的路径，my_function 是动态库中的函数名。
linux系统配置路径
linux系统配置路径Linux系统配置路径在Linux系统中，路径是用来指定文件或目录位置的一种方式。
正确配置路径对于用户操作和系统运行非常重要。
本文将介绍Linux 系统中的配置路径。
1. 用户路径在Linux系统中，每个用户都有一个家目录。
用户的家目录路径通常为"/home/用户名"，其中"用户名"是用户的实际名称。
用户可以在家目录下创建自己的文件和目录，这些文件和目录对其他用户可能是不可见的。
2. 系统路径系统路径用于存放系统级别的文件和目录。
以下是一些常见的系统路径：- /bin：存放系统可执行命令（二进制文件）的目录。
这些命令对于系统的正常运行是必需的，并且对所有用户都可用。
- /sbin：类似于/bin目录，但这些命令通常只对系统管理员可见，用于系统管理和维护。
- /usr/bin：存放大多数用户安装的软件和应用程序的目录。
这些命令通常只对安装了它们的用户可见。
- /usr/sbin：类似于/usr/bin目录，但这些命令通常只对系统管理员可见，用于系统管理和维护。
- /usr/local/bin：存放用户自己编译安装的软件和应用程序的目录。
这些命令只对安装了它们的用户可见。
- /etc：存放系统配置文件的目录。
这些文件包含了系统的各种配置信息，如网络配置、用户配置等。
- /var：存放可变数据的目录，如日志文件、缓存文件等。
3. 环境变量环境变量是一种存储在操作系统中的值，可以在系统中的不同进程之间共享。
环境变量可以用来配置系统中的路径信息。
以下是一些常见的环境变量：- PATH：用于指定命令的搜索路径。
当用户输入一个命令时，系统会按照PATH环境变量中指定的路径顺序去查找命令的可执行文件。
- LD_LIBRARY_PATH：用于指定动态链接库的搜索路径。
当程序需要加载动态链接库时，系统会按照LD_LIBRARY_PATH环境变量中指定的路径顺序去查找动态链接库。
Linux下C语言函数库概述
总体概述，C语言的函数库可以有三种使用的形式：静态、共享和动态。
其中静态库的代码在编译时就已连接到开发人员开发的应用程序中。
而共享库只是在程序开始运行时才载入，在编译时, 只是简单地指定需要使用的库函数就可以了。
动态库则是共享库的另一种变化形式，它也是在程序运行时载入，但与共享库不同的是, 使用的库函数不是在程序运行开始，而是在程序中的语句需要使用该函数时才载入，动态库可以在程序运行期间释放动态库所占用的内存，腾出空间供其它程序使用。
由于共享库和动态库并没有在程序中包括库函数的内容，只是包含了对库函数的引用，因此代码的规模比较小。
Linux下的库文件分为共享库和静态库两大类，它们两者的差别仅在程序执行时所需的代码是在运行时动态加载的，还是在编译时静态加载的。
静态函数库：每次当应用程序和静态连接的函数库一起编译时，任何引用的库函数中的代码都会被直接包含进最终的二进制程序。
共享函数库：包含每个库函数的单一全局版本，它在所有应用程序之间共享。
这一过程背后所涉及的机制相当复杂，但主要依靠的是现代计算机的虚拟内存能力，它允许包含库函数的物理内存安全地在多个独立用户程序之间共享。
区分库类型最好的方法是看它们的文件后缀，通常共享库以.so(Shared Object的缩写)结尾，静态链接库通常以.a结尾(Archive的缩写)。
在终端缺省情况下，共享库通常为绿色，而静态库为黑色。
已经开发的大多数库都采取共享库的方式，Linux系统中目前可执行文件的标准格式为ELF（Executable and Linkable Format）格式。
ELF格式的可执行文件使得共享库能够比较容易地实现：.a的是为了支持较老的a.out格式的可执行文件，静态库文件, 可以用ar 命令生成。
.so的是支持elf格式的可执行文件的库，动态库文件，编译时加上指定的选项即可生成。
在linux系统中可用的库都存放在/usr/lib和/lib目录中。
linux下用gcc生成静态库和动态库
linux下用gcc生成静态库和动态库我们通常把一些公用函数制作成函数库，供其它程序使用。
函数库分为静态库和动态库两种。
静态库在程序编译时会被连接到目标代码中，程序运行时将不再需要该静态库。
动态库在程序编译时并不会被连接到目标代码中，而是在程序运行是才被载入，因此在程序运行时还需要动态库存在。
本文主要通过举例来说明在Linux中如何创建静态库和动态库，以及使用它们。
在创建函数库前，我们先来准备举例用的源程序，并将函数库的源程序编译成.o 文件。
第1步：编辑得到举例的程序--hello.h、hello.c和main.c；hello.c(见程序2)是函数库的源程序，其中包含公用函数hello，该函数将在屏幕上输出"Hello XXX!"。
hello.h(见程序1)为该函数库的头文件。
main.c(见程序3)为测试库文件的主程序，在主程序中调用了公用函数hello。
#ifndef HELLO_H#define HELLO_Hvoid hello(const char *name);#endif //HELLO_H程序1: hello.h#include <stdio.h>void hello(const char *name){printf("Hello %s!\n", name);}程序2: hello.c#include "hello.h"int main(){hello("everyone");return 0;}程序3: main.c第2步：将hello.c编译成.o文件；无论静态库，还是动态库，都是由.o文件创建的。
因此，我们必须将源程序hello.c通过gcc先编译成.o文件。
在系统提示符下键入以下命令得到hello.o文件。
# gcc -c hello.c#我们运行ls命令看看是否生存了hello.o文件。
动态链接库及静态链接库（windows下的.dll.lib和linux下的.so.a）
动态链接库及静态链接库（window s下的.dll .lib和li nux下的.so .a）库有动态与静态两种，动态通常用.so为后缀，静态用.a为后缀。
例如：libhel lo.so libhel lo.a 为了在同一系统中使用不同版本的库，可以在库文件名后加上版本号为后缀,例如：libhel lo.so.1.0,由于程序连接默认以.so为文件后缀名。
所以为了使用这些库，通常使用建立符号连接的方式。
ln -s libhel lo.so.1.0 libhel lo.so.1ln -s libhel lo.so.1 libhel lo.so使用库当要使用静态的程序库时，连接器会找出程序所需的函数，然后将它们拷贝到执行文件，由于这种拷贝是完整的，所以一旦连接成功，静态程序库也就不再需要了。
然而，对动态库而言，就不是这样。
动态库会在执行程序内留下一个标记…指明当程序执行时，首先必须载入这个库。
由于动态库节省空间，linux下进行连接的缺省操作是首先连接动态库，也就是说，如果同时存在静态和动态库，不特别指定的话，将与动态库相连接。
现在假设有一个叫hel lo的程序开发包，它提供一个静态库lib hello.a 一个动态库l ibhel lo.so,一个头文件h ello.h,头文件中提供sayhe llo()这个函数/* hello.h */void sayhel lo();另外还有一些说明文档。
这一个典型的程序开发包结构1.与动态库连接linux默认的就是与动态库连接，下面这段程序testl ib.c使用hel lo库中的sayhe llo()函数/*testli b.c*/#includ e#includ eint main(){sayhel lo();return 0;}使用如下命令进行编译$gcc -c testli b.c -o testli b.o用如下命令连接：$gcc testli b.o -lhello -o testli b在连接时要注意，假设libh ello.o 和libhe llo.a都在缺省的库搜索路径下/usr/lib下，如果在其它位置要加上-L参数与与静态库连接麻烦一些，主要是参数问题。
动态链接库及静态链接库(windows下的.dll .lib和linux下的.so .a)
动态链接库及静态链接库（windows下的.dll .lib和linux下的.so .a）库有动态与静态两种，动态通常用.so为后缀，静态用.a为后缀。
例如：libhello.so libhello.a 为了在同一系统中使用不同版本的库，可以在库文件名后加上版本号为后缀,例如：libhello.so.1.0,由于程序连接默认以.so为文件后缀名。
所以为了使用这些库，通常使用建立符号连接的方式。
ln -s libhello.so.1.0 libhello.so.1ln -s libhello.so.1 libhello.so使用库当要使用静态的程序库时，连接器会找出程序所需的函数，然后将它们拷贝到执行文件，由于这种拷贝是完整的，所以一旦连接成功，静态程序库也就不再需要了。
然而，对动态库而言，就不是这样。
动态库会在执行程序内留下一个标记…指明当程序执行时，首先必须载入这个库。
由于动态库节省空间，linux下进行连接的缺省操作是首先连接动态库，也就是说，如果同时存在静态和动态库，不特别指定的话，将与动态库相连接。
现在假设有一个叫hello的程序开发包，它提供一个静态库libhello.a 一个动态库libhello.so,一个头文件hello.h,头文件中提供sayhello()这个函数/* hello.h */void sayhello();另外还有一些说明文档。
这一个典型的程序开发包结构1.与动态库连接linux默认的就是与动态库连接，下面这段程序testlib.c使用hello库中的sayhello()函数/*testlib.c*/#include#includeint main(){sayhello();return 0;}使用如下命令进行编译$gcc -c testlib.c -o testlib.o用如下命令连接：$gcc testlib.o -lhello -o testlib在连接时要注意，假设libhello.o 和libhello.a都在缺省的库搜索路径下/usr/lib下，如果在其它位置要加上-L参数与与静态库连接麻烦一些，主要是参数问题。
linux eclipse 动态链接库 使用方法
在Linux Eclipse中，使用动态链接库的方法如下：
1. 创建动态链接库：
* 创建一个新的C++项目，选择Shared Library -> Empty Project，输入工程名，点击finish，完成工程的创建。
* 在h文件中，将要用到这个库的函数声明放到一个.h文件中，如果需要在其他工程中使用这个库，只需要将这个.h文件加载到工程中。
* 编写代码，封装动态链接库。
在Linux下，只需要直接把要封的函数的声明放到一个.h文件中。
* 生成动态链接库，编译代码，成功后在Debug目录下会生成.so 文件。
2. 使用动态链接库：
* 创建一个新的C++项目，选择Executable -> Empty Project，工程名为libxxx。
* 编写所需代码，并将相应的.h文件放到工程目录下并加载到工程中。
* 加入动态链接库libxxx.so。
右键工程Properties -> C/C++
Build -> Settings，在右边找到库的名称xxx变为a，库的路径就写这个库所在的路径。
* 修改环境变量。
具体操作步骤可能因不同的操作系统或编译器而有所不同，建议查阅相关文档或教程以获取更详细的信息。
Linux命令高级技巧使用ldd命令进行动态链接库依赖查看
Linux命令高级技巧使用ldd命令进行动态链接库依赖查看在Linux系统中，ldd命令是一种非常有用的工具，它可以帮助我们查看可执行文件或共享库文件所依赖的动态链接库。
在本文中，我们将探讨ldd命令的用法和一些高级技巧。
一、ldd命令简介ldd是Linux系统中的一个工具，用于打印可执行文件或共享库文件所依赖的动态链接库。
该命令可以帮助我们了解一个程序在运行时所需要的动态链接库文件，便于分析和解决依赖问题。
二、ldd命令的基本用法要使用ldd命令，只需在终端中输入ldd，后跟要查看依赖的可执行文件或共享库文件的路径。
例如，我们要查看一个可执行文件的依赖关系，可以使用以下命令：$ ldd /path/to/executable-file命令执行后，ldd将会列出该可执行文件所依赖的全部动态链接库文件的路径。
对于每个链接库文件，ldd还会显示其版本号和一些其他信息。
三、查看共享库的加载地址除了显示依赖的动态链接库文件路径外，ldd还可以显示动态链接库的加载地址。
加载地址是操作系统在运行时将二进制文件加载到内存中的地址。
在某些情况下，了解共享库的加载地址可以帮助我们调试和优化程序。
要查看共享库的加载地址，可以使用-l选项加上可执行文件或共享库文件的路径：$ ldd -l /path/to/executable-file命令执行后，ldd将会列出可执行文件或共享库文件的详细信息，包括加载地址。
四、使用ldd分析共享库依赖问题在开发和部署过程中，我们经常会遇到共享库缺失或不匹配的问题。
使用ldd命令可以帮助我们分析共享库的依赖关系，从而解决这些问题。
假设我们的程序无法启动，并显示缺少某个共享库文件。
我们可以使用ldd命令查看该程序所依赖的动态链接库文件，以确定缺失的共享库以及其路径。
例如：$ ldd /path/to/executable-file命令执行后，ldd将会列出该程序所依赖的动态链接库文件的路径。
Linux的so文件到底是干嘛的？浅析Linux的动态链接库
Linux的so⽂件到底是⼲嘛的？浅析Linux的动态链接库我们分析了Hello World是如何编译的，即使⼀个⾮常简单的程序，也需要依赖C标准库和系统库，链接其实就是把其他第三⽅库和⾃⼰源代码⽣成的⼆进制⽬标⽂件融合在⼀起的过程。
经过链接之后，那些第三⽅库中定义的函数就能被调⽤执⾏了。
早期的⼀些操作系统⼀般使⽤静态链接的⽅式，现在基本上都在使⽤动态链接的⽅式。
静态链接和动态链接虽然静态链接和动态链接都能⽣成可执⾏⽂件，但两者的代价差异很⼤。
下⾯这张图可以很形象地演⽰了动态链接和静态链接的区别：左侧的⼈就像是⼀个动态链接的可执⾏⽂件，右侧的海象是⼀个静态链接的可执⾏⽂件。
⽐起⼈，海象臃肿得多，那是因为静态链接在链接的时候，就把所依赖的第三⽅库函数都打包到了⼀起，导致最终的可执⾏⽂件⾮常⼤。
⽽动态链接在链接的时候并不将那些库⽂件直接拿过来，⽽是在运⾏时，发现⽤到某些库中的某些函数时，再从这些第三⽅库中读取⾃⼰所需的⽅法。
我们把编译后但是还未链接的⼆进制机器码⽂件称为⽬标⽂件（Object File），那些第三⽅库是其他⼈编译打包好的⽬标⽂件，这些库⾥⾯包含了⼀些函数，我们可以直接调⽤⽽不⽤⾃⼰动⼿写⼀遍。
在编译构建⾃⼰的可执⾏⽂件时，使⽤静态链接的⽅式，其实就是将所需的静态库与⽬标⽂件打包到⼀起。
最终的可执⾏⽂件除了有⾃⼰的程序外，还包含了这些第三⽅的静态库，可执⾏⽂件⽐较臃肿。
相⽐⽽⾔，动态链接不将所有的第三⽅库都打包到最终的可执⾏⽂件上，⽽是只记录⽤到了哪些动态链接库，在运⾏时才将那些第三⽅库装载（Load）进来。
装载是指将磁盘上的程序和数据加载到内存上。
例如下图中的Program 1，系统⾸先加载Program 1，发现它依赖libx.so后才去加载libx.so。
所以，静态链接就像GIF图中的海象，把所需的东西都带在了⾝上。
动态链接只把精简后的内容带在⾃⼰⾝上，需要什么，运⾏的时候再去拿。
linux 程序执行加载so 原理
linux 程序执行加载so 原理Linux 程序执行加载SO原理在Linux操作系统中，动态链接库（Shared Object，简称SO）是一种可重用的代码库，它可以在程序运行时动态加载和链接。
本文将介绍Linux程序执行加载SO的原理。
在Linux中，程序的执行主要经过以下几个步骤：1. 程序启动：当用户在终端输入执行程序的命令时，Linux内核会创建一个新的进程来运行该程序。
2. 可执行文件加载：内核从硬盘中读取程序的可执行文件，并将其加载到进程的虚拟内存中。
3. 解析器执行：内核调用程序的解析器（通常是/bin/bash或/bin/sh），解析器负责读取程序的可执行文件头部信息，并根据信息确定程序的入口地址。
4. 动态链接库加载：如果程序使用了动态链接库，解析器会在执行过程中需要加载这些库。
它会遍历可执行文件的动态链接库段（.dynamic section），根据其中的信息加载依赖的SO。
5. SO加载过程：对于要加载的SO，解析器会按照以下步骤进行处理：a. 解析器会根据可执行文件中的动态链接表（Dynsym）中的信息，找到SO 中的符号引用。
b. 解析器通过动态链接表中的偏移地址，在SO中定位到对应的符号定义。
c. 如果找到了符号定义，解析器将其地址更新到程序的全局符号表（GOT）中，这样程序就能够访问到SO中定义的函数或变量。
d. 如果未找到符号定义，解析器将尝试在其他已加载的SO中查找该符号定义。
e. 如果依旧未找到，解析器会抛出链接错误。
6. 程序执行：经过SO加载的步骤后，解析器将控制权交给程序的入口地址，程序开始执行。
需要注意的是，SO的加载是在程序运行时动态进行的，这使得程序可以在运行过程中动态加载和卸载所需的库，从而提供了更大的灵活性和可重用性。
总结：Linux程序执行加载SO的过程涉及可执行文件的加载、解析器执行和动态链接库的加载等环节。
SO的加载通过解析器解析可执行文件的动态链接表，根据符号引用在SO中定位到符号定义，并将其地址更新到程序的全局符号表中。
linux动态库（.so）搜索路径（目录）设置方法
linux动态库（.so）搜索路径（⽬录）设置⽅法在Linux 中，动态库的搜索路径除了默认的搜索路径外，还可通过三种⽅法来指定：⽅法⼀：在配置⽂件/etc/ld.so.conf中指定动态库搜索路径；⽅法⼆：通过环境变量LD_LIBRARY_PATH指定动态库搜索路径；⽅法三：在编译⽬标代码时指定该程序的动态库搜索路径。
众所周知，Linux动态库的默认搜索路径是/lib和/usr/lib。
动态库被创建后，⼀般都复制到这两个⽬录中。
当程序执⾏时需要某动态库，并且该动态库还未加载到内存中，则系统会⾃动到这两个默认搜索路径中去查找相应的动态库⽂件，然后加载该⽂件到内存中，这样程序就可以使⽤该动态库中的函数，以及该动态库的其它资源了。
在Linux 中，动态库的搜索路径除了默认的搜索路径外，还可以通过以下三种⽅法来指定。
⽅法⼀：在配置⽂件/etc/ld.so.conf中指定动态库搜索路径。
vi /etc/ld.so.conf添加 lib⽬录ldconfig⽅法⼆：通过环境变量LD_LIBRARY_PATH指定动态库搜索路径。
export LD_LIBRARY_PATH=”LD_LIBRARY_PATH:/opt/”⽅法三：在编译⽬标代码时指定该程序的动态库搜索路径。
还可以在编译⽬标代码时指定程序的动态库搜索路径。
通过gcc 的参数”-Wl,-rpath,”指定其中⽅法三可以避免安装部署的⿇烦⽅法三⽰例假设main.cpp,hello.h,hello.cpp,其中main.cpp调⽤了hello类中的⽅法1 ⽣成hello.sog++ -shared hello.cpp -o libhello.so2 编译main.cpp,并链接,并指定运⾏时libhello.so的位置 g++ main.cpp -lhello -L./ -Wl,-rpath=./ -o main值得⼀提的是,如果采⽤带版本号的库,例如libhello.so.2链接命令可使⽤g++ main.cpp libhello.so.2 -L./ -Wl,-rpath=./ -o main2)加⼊第⼆个so库g++ main.cpp -L./second/ -Wl,-rpath=./second/ -lsecond -L./hello/ -Wl,-rpath=./hello/ -lhello -o mainps,遇到过⼀个奇怪的问题,就是假设libhello.so还⽤到了libother.so,由于在/etc/ld.so.conf⾥配置错误了libother.so的⽬录路径,导致⼀直产⽣undefined reference to错误,但是在⼯程⾥对libother⽬录路径配置是正确的,有可能于查找路径顺序有关。
Linux命令行中的文件排序技巧
Linux命令行中的文件排序技巧在Linux操作系统中，命令行是一种强大而有效的工具，可用于完成各种任务。
文件排序是命令行中经常使用的一个操作，它可以帮助用户按照特定的条件对文件进行排序，以便更好地管理和查找文件。
本文将介绍几种常用的Linux命令行中的文件排序技巧。
1. 按文件名排序按文件名排序是最常见的文件排序方式之一。
在Linux中，可以使用ls命令对文件进行排序。
ls命令的常用选项包括：- -l：以长格式显示文件信息，包括文件权限、所有者、大小、创建日期等。
- -t：按修改时间排序，最新修改的文件会显示在前面。
- -r：以相反的顺序显示文件。
- -s：按文件大小排序，文件大小由大到小。
- -h：以人类可读的方式显示文件大小。
例如，要按文件名排序并显示文件的详细信息，可以使用命令：ls -l。
如果要以相反的顺序显示文件名，可以使用命令：ls -r。
2. 按文件大小排序除了按文件名排序外，还可以按文件大小对文件进行排序。
在Linux中，可以使用du命令来查看文件或目录的大小，并使用sort命令对结果进行排序。
sort命令的常用选项包括：- -n：按数值大小排序。
- -r：以相反的顺序显示结果。
- -h：以人类可读的方式显示结果。
例如，要按文件大小排序并显示文件的详细信息，可以使用命令：du -h | sort -n。
如果要以相反的顺序显示文件大小，可以使用命令：du-h | sort -n -r。
3. 按文件类型排序在Linux中，文件类型是根据文件扩展名或文件头来确定的。
有时候，我们希望按照文件类型对文件进行排序。
在Linux中，可以使用file命令来查看文件的类型，并使用grep命令过滤出所需文件类型，并使用sort命令对结果进行排序。
例如，要按文件类型排序并显示文件的详细信息，可以使用命令：file * | grep "类型" | sort。
其中，"类型"是指所需的文件类型，如"文本"、"图像"等。
Linux命令高级技巧使用ldd查看程序依赖库
Linux命令高级技巧使用ldd查看程序依赖库在Linux系统中，ldd命令是一个非常方便的工具，可以用于查看一个可执行程序或者共享库所依赖的动态链接库。
ldd命令可以帮助我们解决程序运行时可能遇到的依赖问题，以及查找出程序所需要的依赖库。
ldd命令的基本用法如下：```ldd [option] <file>```其中，option为可选参数，file为要查看依赖库的文件名。
下面我们来了解一些ldd命令的高级技巧：1. 查看可执行程序或共享库的依赖库要查看一个可执行程序或共享库所依赖的动态链接库，只需要在命令行中输入ldd命令，后接要查看的文件名即可。
例如，要查看可执行程序"example"所依赖的库，可以使用以下命令：```ldd example```ldd命令将输出被查看文件所依赖的动态链接库的路径。
2. 递归查看依赖库的依赖关系有时候我们不仅需要查看一个程序所依赖的库，还需要查看这些库所依赖的其他库。
ldd命令提供了--recursive选项，可以递归查看依赖库的依赖关系。
例如，要递归查看程序"example"所依赖的所有库，可以使用以下命令：```ldd --recursive example```ldd命令将输出被查看文件以及其直接或间接依赖的所有库的路径。
3. 查看依赖库的符号版本信息有时候，我们需要了解一个依赖库的符号版本信息，以确保程序的正确链接。
ldd命令提供了--version选项，可以查看依赖库的版本号。
例如，要查看共享库"libexample.so"的版本号，可以使用以下命令：```ldd --version libexample.so```ldd命令将输出被查看库的版本号。
4. 查找缺失的依赖库在运行一个程序时，有时会遇到缺失依赖库的情况。
ldd命令可以帮助我们查找缺失的依赖库。
例如，要查找可执行程序"example"运行所需的缺失的依赖库，可以使用以下命令：```ldd --verbose example```ldd命令将输出缺失的依赖库的路径，并提供详细的错误信息。
【linux】程序找不到动态库.so的解决办法查看.so动态库信息.so动态库加载顺序
【linux】程序找不到动态库.so的解决办法查看.so动态库信息.so动态库加载顺序⽬录找不到.so解决⽅法Linux 动态库的默认搜索路径是 /lib 和 /usr/lib，除了默认的搜索路径外，还可以通过以下⼏种⽅法来指定。
⽅法⼀：添加环境变量添加环境变量三种⽅式1. 添加当前⽤户当前终端的环境变量（临时）export LD_LIBRARY_PATH=/home/czd/... #.so file path2. 添加当前⽤户的环境变量修改~/.bashrc⽂件，在其末尾，添加环境变量vim ~/.bashrcexport LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/home/czd/... #.so file path使其⽣效，source ~/.bashrc如不能⽣效，请重启3. 添加所有⽤户的环境变量修改profile⽂件，在其末尾添加环境变量vim /etc/profileexport LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/home/czd/... #.so file path使其⽣效source /etc/profile如不能⽣效，请重启⽅法⼆：复制so⽂件到lib路径linux系统的so库⼀般存储与“/usr/lib/”路径中，可将动态库复制到该路径中。
sudo cp liblibtest.so /usr/lib/即时⽣效⽅法三：（推荐）添加ldconfig寻找路径步骤1. 编辑链接配置⽂件vim /etc/ld.so.conf，确认内容是否为如下，不是则修改为如下：include /etc/ld.so.conf.d/*.conf步骤2. 进⼊/etc/ld.so.conf.d⽬录内，创建*.conf⽂件,⽂件名随意，扩展名必须为.confcd /etc/ld.so.conf/vim libmy.conf步骤4. 在⽂件内部，添加so的路径，保存并退出/home/czd/eclipse-workspacee/calllib/Debug步骤5. 执⾏命令时期⽣效sudo ldconfig程序在运⾏时寻找so库就会到添加的⽬录中寻找。
linux找不到动态链接库.so文件的解决方法
linux找不到动态链接库.so⽂件的解决⽅法
如果使⽤⾃⼰⼿动⽣成的动态链接库.so⽂件，但是这个.so⽂件，没有加⼊库⽂件搜索路劲中，程序运⾏时可能会出现找不到动态链接库的情形。
可以通过ldd命名来查看可执⾏⽂件依赖的动态链接库，如下(其中D为可执⾏程序)：
其中的libjson_linux-gcc-4.6_libmt.so cannot found。
解决这个问题：
(1)在系统中查找这个⽂件(当然要保证系统中已经有这个.so⽂件，只是查找路径没有设置正确⽽已)：
sudo find / -name libjson_linux-gcc-4.6_libmt.so
结果：/home/liu/Desktop/jsoncpp-src-0.5.0/libs/linux-gcc-4.6/libjson_linux-gcc-4.6_libmt.so
(2)将.so⽂件路径的⽬录添加到/etc/ld.so.conf
sudo vim /etc/ld.so.conf
⽂件末尾新添加⼀⾏，/home/liu/Desktop/jsoncpp-src-0.5.0/libs/linux-gcc-4.6
(3)使得修改⽣效
sudo /sbin/ldconfig
这样就不会有那个找不对.so⽂件的错误啦。
linux 头文件、库文件查找顺序
linux 头文件、库文件查找顺序默认分类 2009-11-14 01:24:28 阅读126 评论0 字号：大中小linux 头文件、库文件查找顺序2009-11-03 12:36Include的header文件,连结数据库，系统定义，总共有下列来源指定gcc去那找。
当初在编译时指定的(在~gcc/gcc/collect2.c:locatelib()写在specs内的后来用-D -I -L指定的gcc环境变量设定(编译的时候)ld.so的环境变量(这是run time的时候）一、头文件gcc 在编译时如何去寻找所需要的头文件：※所以header file的搜寻会从-I开始※然后找gcc的环境变量C_INCLUDE_PATH,CPLUS_INCLUDE_PATH,OBJC_INCLUDE_PATH ※再找内定目录/usr/include/usr/local/include/usr/lib/gcc-lib/i386-linux/2.95.2/include/usr/lib/gcc-lib/i386-linux/2.95.2/../../../../include/g -3/usr/lib/gcc-lib/i386-linux/2.95.2/../../../../i386-linux/include库文件但是如果装gcc的时候，是有给定的prefix的话，那么就是/usr/includeprefix/includeprefix/xxx-xxx-xxx-gnulibc/includeprefix/lib/gcc-lib/xxxx-xxx-xxx-gnulibc/2.8.1/include二、库文件cos()等函式库的选项要多加 -lm编译的时候:※gcc会去找-L※再找gcc的环境变量LIBRARY_PATH※再找内定目录 /lib /usr/lib /usr/local/lib 这是当初compile gcc时写在程序内的三、运行时动态库的搜索路径1、在配置文件/etc/ld.so.conf中指定动态库搜索路径2、通过环境变量LD_LIBRARY_PATH指定动态库搜索路径（当通过该环境变量指定多个动态库搜索路径时，路径之间用冒号"："分隔）3、在编译目标代码时指定该程序的动态库搜索路径（还可以在编译目标代码时指定程序的动态库搜索路径。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
1.首先查看程序文件的.dynamic 段是否包含了一个叫DT_RPATH的项（它是一个以冒号分隔的库文件搜索目录列表）。
怎么设置这个选项？
需要在编译连接程序的时候使用-Wl,-rpath选项，假设一个程序test需要使用liblib.so库，如下所示进行编译连接：
g++ -o test -L. -llib -Wl,rpath=./ test.cpp
这样就可以使用/work/lib/下的库文件了,运行程序后系统会自动到环境变量LD_LIBRARY_PATH指定的路径中查找其所需的库。
系统查找动态库的顺序
系统先找LD_LIBRARY_PATH下的库再找/lib and /usr/lib等路径下的库,还有/etc/ld.so.conf里指定的路径(如果ld.so.conf存在),man ldconfig for more information
环境变量LD_LIBRARY_PATH用来指定查找共享库时除了默认路径之外的其他路径。(该路径在默认路径之前查找)
移植程序时的经常碰到需要使用一些特定的动态库，而这些编译好的动态库放在我们自己建立的目录里，这时我们可以设置LD_LIBRARY_PATH。
例：export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/work/lib/
如果在链接时使用了"-R"和"-L"选项，则相关动态库的路径将保存在ELF文件中，于
是以后的运行中不再需要设置环境变量去定位动态库。比如，有一个
/usr/local/lib/libfoo.so，而你的bar程序需要这个libfoo.so，编译、链接时最好
这样 ：gcc -Wall -pipe -O3 -o bar -R/usr/local/lib -L/usr/local/lib bar.c -lfoo
这样在执行test程序时，test便会先到./即当前目录下查找所需要的动态库liblib.so
2.查找是否存在环境变量 LD_LIBRARY_PATH（它是一个以冒号分隔的库文件搜索目录列表）。
怎么设置这个选项？当然是设置linux下的环境变量就可以了，搜索顺序目录排在前面的优先。
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:./
linux中动态链接库的搜索顺序
在接手一个很古老的程序时，发现其所使用的动态库都实在是太陈旧了，正式运行环境中部署的库都是相适应的，而目前的开发测试环境中均是部署的新的升级版本。为了能在这些环境下开发测试，程序得能在自定义的路径里来搜索。因此在这里复习一下linux中程序对动态链接库的搜索顺序，如下所述：
4.查找默认路径/lib和/usr/lib,
如果经过了以上的步骤仍然查找失败，则将报错并退出相关程序。
对于前三个步骤来说，我们均是可以进行设置调整的，其中第三个步骤中的设置需要root权限才能进行，且会影响所有的程序。当使用第一、第二中的方法进行了设置调整后，我们便可以使多种版本的库共存在同一环境下进行测试，同名也无所谓。
当然，这种方法是对当前登录生效的。如果想开机即有效，跟其它环境变量的设置也是一样，需要修改一些配置文件。
3.查看库高速缓存文件 /etc/ld.so.conf ，它包含了库名和路径的一个对应列表，如果库名存在，连接器项？可以直接编辑ld.so.conf加入需要查找的路径，也可以在/etc/ld.so.conf.d目录下的己有文件中加入路径，或者在该目录下新建一个文件（名字为*.conf即可），再把需要的路径加入到该文件中。最后执行ldconfig即可生效。
********************************************************************************************************************************************************************
[url=http://infomax/bbs/misc.php?action=viewratings&tid=111&pid=228][/url]
使Linux启动之后就加载LD_LIBRARY_PATH的路径
/etc/rc.d/rc.local文件中加入export LD_LIBRARY_PATH="xxxxx" 即可