分类：Linux

• 基础使用

gcc -fPIC -c a.c
gcc -fPIC -c b.c
gcc -shared -Wl -o libmyab.so ao b.o
// -fPIC 表示位置无关代码，动态库是运行时加载，PIC表示库放到内存任何地址上运行都行，用的是相对地址，而不是绝对地址
// -c 只编译，生成.o文件，不进行链接

• 高阶使用

gcc -share -Wl,-soname, libmyab.so.1 -o libmyab.so.1.0.1 a.o b.o
gcc -share -Wl,-soname, your_soname -o library_name(real_name) file_list library_list

• 基本概念

按照共享库的命名惯例，每个共享库有三个文件名：real name, soname和linker name，这三个name 有什么区别呢？

一般真正的库文件的名字叫real name, 包含了完整的共享库版本号。
soname 是一个符号链接的名字，只包含共享库的主版本号，主版本号一致即可保证库函数的接口一致，因此应用程序的.dynamic段只记录共享库的soname，只要soname一致，这个共享库就可以用。表示库函数接口没有大的变化。如libmyab.so.1和libmyab.so.2是两个主版本号不同的libmyab,有些应用依赖于libmyab.so.1，有些应用依赖于libmyab.so.2，但是对于依赖libmyab.so.1的应用程序来说，真正的库文件不管是libmyab.so.1.10还是libmyab.so.1.11都可以用。所以使用共享库可以很方便地升级库文件而不需要重新编译应用程序，这是静态库所没有的优点。注意libc的版本编号有一点特殊，libc-2.8.90.so的主版本号是6而不是2或是2.8

linker name 仅在编译链接时使用，gcc的-L选项应该指定linker name所在的目录。有的linker name是库文件的一个符号链接，有的linker name是一段链接脚本。

举例说：上面libxml2.so 这个就是linker name，linkxml2.so.2，这个是soname, 标识了主版本号，libxml2.so.2.9.2这个是real name, 给出了完整的版本号

共享库加载：

在所有基于GNUglibc的系统中，在启动一个ELF二进制执行程序时，一个特殊的程序“程序装载器”会被自动装载并运行。在linux中，这个程序装载器就是/lib/ld-linux.so.X(X是版本号)。它会查找并装载应用程序所依赖的所有共享库。被搜索的目录保存在/etc/ld.so.conf文件中。如果程序的每次启动，都要去搜索一番，性能上会有所消耗。linux系统已经考虑到这一点。对共享库采用缓存管理，ldconfig就是实现这一功能的工具，其缺省读取/etc/ld.so.conf文件，对所有的共享库按照一定规范建立符号连接，然后将信息写入/etc/ld.so.cache。/etc/ld.so.cache的存在大大地加快了程序的启动速度

下面我们用一个例子【编译一个加减乘除的运算so】来详细说明下共享库(so->shared object)的编译过程：

//我的目录结构：
|-- add.c
|-- cmath.h
|-- dive.c
|-- main.c
|-- mul.c
|-- sub.c

//我的程序代码
//add.c
int add(int a, int b) {
	return a+b;
}

//sub.c
int sub(int a, int b) {
	return a-b;
}

//mul.c
int mul(int a, int b) {
	return a*b;
}

//dive.c
int dive(int a, int b) {
	return a/b;
}

//cmath.h
#ifndef CMATH_H_
#define CMATH_H_
int add(int a, int b);
int sub(int a, int b);
int mul(int a, int b);
int dive(int a, int b);
#endif

//main.c
#include <stdio.h>
#include "cmath.h"

int main(void) {
	printf("%d", add(3,4));
	return 0;
}

• 编译产生.o文件

gcc -fPIC -c *.c

//执行后的目录结构，会产生四个.0文件
|-- add.c
|-- add.o
|-- cmath.h
|-- dive.c
|-- dive.o
|-- main.c
|-- main.o
|-- mul.c
|-- mul.o
|-- sub.c
`-- sub.o

• 将.o编译生成共享库

gcc -shared -Wl,-soname,libmym.so.1 -o libmysm.so.1.10 *.o

//执行完的目录结构，会产生一个libmym.so.1.10
|-- add.c
|-- add.o
|-- app
|-- cmath.h
|-- dive.c
|-- dive.o
|-- libmysm.so.1.10
|-- main.c
|-- main.o
|-- mul.c
|-- mul.o
|-- sub.c
`-- sub.o

• 将main,c 和 libmym.so.1.10一起编译，生成app程序

gcc main.c libmysm.so.1.10 -o app

• 我们来执行下./app

./app: error while loading shared libraries: libmym.so.1: cannot open shared object file: No such file or directory

说找不到so，我们接着ldd查看下app所依赖的so

[root@VM_16_5_centos src]# ldd app 
	linux-vdso.so.1 =>  (0x00007ffccebeb000)
	libmym.so.1 => not found
	libc.so.6 => /usr/lib64/libc.so.6 (0x00007f9d5bcf7000)
	/lib64/ld-linux-x86-64.so.2 (0x00007f9d5c0c4000)

这个时候我们来聊到一个文件 /etc/ld.so.conf

include ld.so.conf.d/*.conf
/usr/local/lib64
/usr/local/lib
/usr/lib
/usr/lib64
/root/ccode/src

ld.so.conf 存放的是一个so搜索目录的文件列表，可以简单理解成类似path环境，这里面存放的so的环境path

由于是自定义的so. 我们的libmym.so.1.10存放在/root/ccode/src下，所以我们把这个路径加到ld.so.conf里

然后用下列命令更新下共享库路径：

ldconfig -v

再次运行下app程序

[root@VM_16_5_centos src]# ldd app 
	linux-vdso.so.1 =>  (0x00007ffcae9e1000)
	libmym.so.1 => /root/ccode/src/libmym.so.1 (0x00007f8390595000)
	libc.so.6 => /usr/lib64/libc.so.6 (0x00007f83901c8000)
	/lib64/ld-linux-x86-64.so.2 (0x00007f8390797000)
[root@VM_16_5_centos src]# ./app 
7[root@VM_16_5_centos src]# 

一个进程，包括代码、数据和分析给进程的资源。fork()函数通过系统调用创建一个与原来进程几乎完全相同的进程，也就是两个进程可以做完全相同的事，但如果初始参数或传入变量不同，两个进程也可以做不同的事。

一个进程调用fork函数后，系统先给新的进程分配资源，例如存储数据和代码的空间。然后把原来进程的所有值都复制到新的进程中，只有少数值与原来进程不同，相当于克隆了一个自己。

看一个简单的例子：

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

int main(int ac, char *av[]) {
	pid_t pid;
	int count = 0;

	printf("current process id = %d\n", getpid());

	if ((pid = fork()) < 0) {
		printf("异常退出");
		exit(1);
	} else if (pid == 0) {
		printf("pid:%d\n", pid);
		count++;
		printf("count:%d\n", count);
		printf("进入子进程，当前进程currentPid =%d, 父进程id: %d\n", getpid(), getppid());
	} else {
		sleep(3); //如果没有这一句，父进程会先跑完，然后子进程的父进程号就不是我们的预期了，而可能是-1
		printf("pid:%d\n", pid);
		count++;
		printf("count:%d\n", count);
		printf("我是父进程，当前进程currentPid=%d, 子进程id: %d\n", getpid(), pid);
	}
	return 0;
}

在语句pid = fork()之前，只有一个进程在执行这段代码，但是在这条语句之后，就变成了两个进程在执行了，这两个进程几乎完全相同，将要执行的下一条语句是”else if (pid == 0)”

两个进程的pid 不同，fork调用一次，却能返回两次，有三种不同的返回值：

• 父进程中，fork返回新创建子进程的进程id.
• 在子进程中，fork返回0
• 如果出现错误，fork返回一个负值

fork出错可能有两种原因：

• 当前的进程数已经达到系统规定的上限，这是errno的值被设置EAGAIN
• 系统内存不足，这是errno的值被设置为ENOMEM

创建新进程后，系统中出现两个基本完全相同的进程。这两个进程执行没有固定的先后顺序，哪个进程先执行要看系统的进程调度策略，所以上述代码中，父进程中给了sleep，否则父进程先于子进程结束，子进程里获取的父进程号无法符合预期的父进程号，而是得到-1

进程调用fork，当控制转移到内核中的fork代码后，内核做：

• 分配新的内存块和内核数据结构
• 复制原来的进程到新的进程
• 向运行进程集添加新的进程
• 将控制返回给两个进程

exec函数族

#include <unistd.h>

int execl(const char *path, const char *arg, ...);
int execle(const char *path, const char *arg, ..., char *const envp[]);
int execv(const char *path, char *const argv[]);
int execve(const char *path, char *const argv[], char *const envp[]);

int execlp(const char *file, const char *arg, ...);
int execvp(const char *file, char *const argv[]);

exec函数族的功能是根据指定的文件名找到可执行文件执行它并用它来取代调用进程的内容，即取代原调用进程的数据段、代码段和堆栈段。

当exec函数正常执行时，原调用进程的内容除了pid是保留的，其他的全部被新进程替换了。且除非exec函数调用失败，否则exec函数后的所有代码都不会再被执行。

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>

main() {
	char *arglist[3];
	arglist[0] = "ls";
	arglist[1] = "-l";
	arglist[2] = NULL;
	printf("*** About to exec ls -l\n");
	execvp("ls", arglist);
	printf("*** ls is done bye\n");
}

结果就是执行ls -l命令，并且不会打印 ls is done bye这一行，因为execvp后面的所有代码都不会再被执行。

那通过exec 的学习，其实会想到shell，shell本身是一个程序或是一个进程，然后当我们执行某个指令后，他会将原进程用新进程替代。下面我们来用execvp实现一个简单shell程序：

#include <stdio.h>
#include <signal.h>
#include <string.h>
#include <stdlib.h>

#define MAXARGS 20
#define ARGLEN 100

int main() {
	char *arglist[MAXARGS + 1];
	int numargs;
	char argbuf[ARGLEN];
	char *makestring();

	numargs = 0;
	while (numargs < MAXARGS) {
		printf("Arg[%d]?", numargs);
		if (fgets(argbuf, ARGLEN, stdin) && *argbuf != '\n') {
			arglist[numargs++] = makestring(argbuf);
		} else {
			if (numargs > 0) {
				arglist[numargs] = NULL;
				execute(arglist);
				numargs = 0;
			}
		}
	}
	return 0;
}

int execute(char *arglist[]) {
	execvp(arglist[0], arglist);
	perror("execvp failed");
	exit(1);
}

char * makestring(char *buf) {
	void *cp = NULL;
	buf[strlen(buf) - 1] = '\0';
	cp = malloc(strlen(buf) + 1);
	if (cp == NULL) {
		fprintf(stderr, "no memory\n");
		exit(1);
	}
	strcpy(cp, buf);
	return cp;
}

//执行结果
[root@VM_16_5_centos ccode]# ./psh1
Arg[0]?netstat
Arg[1]?-an
Arg[2]?
Active Internet connections (servers and established)
Proto Recv-Q Send-Q Local Address           Foreign Address         State      
tcp        0      0 0.0.0.0:111             0.0.0.0:*               LISTEN     
tcp        0      0 0.0.0.0:80              0.0.0.0:*               LISTEN     
tcp        0      0 127.0.0.1:8089          0.0.0.0:*               LISTEN     
tcp        0      0 0.0.0.0:443             0.0.0.0:*               LISTEN     
tcp        0      0 0.0.0.0:36000           0.0.0.0:*               LISTEN     
tcp        0      0 127.0.0.1:45930         127.0.0.1:3306          TIME_WAIT 
tcp        0      0 127.0.0.1:45898         127.0.0.1:3306          TIME_WAIT 

以上就是fork和exec函数族里execvp的应用，exec函数族里还有其他几个函数，用法也类似，带p的，就是PATH, 带v的就是参数接受一个数组。功能和用法大体相同。