UNIX环境高级编程-进程环境

相关函数列表

1. //退出函数  
2. #include <stdlib.h>  
3. void exit(int status);  
4. void _Exit(int status);  
5. #include <unistd.h>  
6. void _exit(int status);  
7.   
8. //按照ISO C的规定，一个进程可以登记多至32个函数，这些函数将由exit自动  
9. //调用。我们称这些函数为终止处理程序(exit handler)，并调用atexit函数来  
10. //登记这些函数，这个函数起始就是注册退出钩子函数，退出程序时执行一些自定义的函数  
11. //执行的顺序和注册的顺序正好相关，相同的函数可以注册多次  
12. #include <stdlib.h>  
13. int atexit(void (*func)(void));  
14.   
15. //环境表  
16. int main(int argc, char *argv[], char *envp[]);  
17.   
18. //动态分配空间的函数  
19. #include <stdlib.h>  
20. void *malloc(size_t size);  
21. void *calloc(size_t nobj, size_t size);  
22. void *realloc(void *ptr, size_t newsize);  
23. void free(void *ptr);  
24.   
25.   
26. //获取环境变量值  
27. #include <stdlib.h>  
28. char *getenv(const char *name);  
29.   
30. //putenv设置name=value  
31. //setenv将name设置为value，如果rewrite非0则先删除之前的定义否则不删  
32. //unsetenv删除name定义  
33. #include <stdlib.h>  
34. int putenv(char *str);  
35. int setenv(const char *name, const char *value, int rewrite);  
36. int unsetenv(const char *name);  
37.   
38.   
39. //C语言中goto是不能跨越函数的，而执行这种功能是由setjmp和longjmp完成  
40. #include <setjmp.h>  
41. int setjmp(jmp_buf env);  
42. void longjmp(jmp_buf env, int val);  
43.   
44.   
45. //每个进程都有一组资源限制，可以用下列函数设置和获取  
46. #include <sys/resource.h>  
47. int getrlimit(int resource, struct rlimit *rlptr);  
48. int setrlimit(int resource, const struct rlimit *rlptr);  
49.   
50. //rlimit结构体如下  
51. struct rlimit {  
52.     rlim_t rlim_cur;    //soft limit  
53.     rlim_t rlim_max;    //hard limit  
54. };  

 

 

进程终止，有8种方式，其中5钟是正常终止

1) 从main返回

2) 调用exit

3) 调用_exit或_Exit

4) 最后一个现场从其启动列程返回

5) 从最后一个线程调用pthread_exit

异常终止

1) 调用abort

2) 接到一个信号

3) 最后一个线程对取消请求作出响应

 

1999 ISO C扩展要求编译器要求main必须声明为返回整型

当内核执行C程序时，在调用main前先调用一个特殊的启动例程。可执行文件将此例程指定为程序的起始地址--这是由连接编辑器设置的，而连接编辑器则由C编译器调用。启动例程从内核取得命令行参数和环境变量值，然后喂按上述方式调用main函数做好安排。

一个C程序是如何启动和终止的

 

函数sbrk()用来实现系统扩充(或缩小)进程的堆

但是大多数malloc和free的实现都不见效进程的存储空间，释放的空间可供以后再分配，但将它们保持在

malloc池中而不繁华给内核。

大多数实现所分配的存储空间比所要求的要稍大一些，额外的空间用来记录管理信息--分配块的长度，指向

下一个分配块的指针等。这就意味着如果超过一个已分配区的尾端或者在已分配区起始位置之前进行写操作，则会改写另一块管理记录信息。这种类型的错误是在灾难性的单不会很快暴露出来。

 

 

替代的存储空间分配程序

1) libmalloc

2) vmalloc

3) quick-fit

4) jemalloc

5) TCMalloc

6) 函数alloca

 

Single UNIX Specification定义的环境变量

变量	说明
COLUMNS	终端宽度
DATEMSK	getdate模板文件路径名
HOME	home起始目录
LANG	本地名
LC_ALL	本地名
LC_COLLATE	本地排序名
LC_CTYPE	本地字符分类名
LC_MESSAGES	本地消息名
LC_MONETARY	本地货币编辑名
LC_NUMERIC	本地数字编辑名
LC_TIME	本地日期/时间格式名
LINES	终端高度
LOGNAME	登陆名
MSGVERB	fmtmsg处理的消息组成部分
NLSPATH	消息类模板序列
PATH	搜索可执行文件的路径前缀列表
PWD	当前工作目录的绝对路径名
SHELL	用户首选的shell名
TERM	终端类型
TMPDIR	在其中创建临时文件的目录路径名
TZ	时区信息

 

 

在更改资源限制时，必须遵守下列三条规则(使用ulimit命令获取和设置)

1) 任何一个进程都可将一个软限制值更改为小于或等于其硬限制值

2) 任何一个进程都可降低其硬限制值，但它必须大于或等于其软限制值，这种降低对普通用户是不可逆的

3) 只有超级用户进程可以提高硬限制值

限制	说明
RLIMIT_AS	进程总的可用存储空间的最大长度(字节)，这影响到sbrk函数和mmap函数
RLIMIT_CORE	core文件的最大字节数，若其值为0则组织创建core文件
RLIMIT_CPU	CPU时间的最大量值(秒)，当超过此软限制时，向该进程发送SIGXCPU信号
RLIMIT_DATA	数据段的最大字节长度
RLIMIT_FSIZE	可以创建的文件的最大字节长度，当超过此软限制时，则向该进程发送SIGXFSZ信号
RLIMIT_MEMLOCK	一个进程使用mlock能够锁定在存储空间中的最大字节长度
RLIMIT_MSGQUEUE	进程为POSIX消息队列可分配的最大存储字节数
RLIMIT_NICE	为了影响进程的调度优先级，nice值可设置的最大限制
RLIMIT_NOFILE	每个进程能打开的最多文件数，更改此限制将影响到sysconf函数在参数 _SC_OPEN_MAX中的返回值
RLIMIT_NPROC	每个实际用户ID可拥有的最大子进程数，更改此限制将影响到sysconf函数在参数 _SC_CHILD_MAXZ中的返回值
RLIMIT_NPTS	用户可用时打开的伪终端的最大数量
RLIMIT_RSS	最大驻内存集字节长度(resident set size in bytes RSS）如果可用的物理存储器非常 少，则内核将从进程处取回超过RSS的部分
RLIMIT_SBSIZE	在任意给定时刻，一个用户可以占用的套接字缓冲区的最大长度(字节)
RLIMIT_SIGPENDING	一个进程可排队的信号最大数量，这个限制是sigqueue函数实施的
RLIMIT_STACK	栈的最大字节长度
RLIMIT_SWAP	用户可消耗的交换空间的最大字节数
RLIMIT_VMEM	这是RLIMIT_AS的同义词
RLIMIT_INFINITY	指定了一个无限量的限制

 

 

 

atexit函数使用过程

1. #include <stdio.h>  
2. #include <unistd.h>  
3. #include <stdlib.h>  
4. static void my_exit1(void) {  
5.         printf("first exit handler\n");  
6. }  
7.   
8. static void my_exit2(void) {  
9.         printf("second exit handler\n");  
10. }  
11.   
12. int main(int argc, char *argv[]) {  
13.         if(atexit(my_exit2) != 0) {  
14.                 printf("can't register my_exit2");  
15.         }  
16.         if(atexit(my_exit1) != 0) {  
17.                 printf("can't register my_exit1");  
18.         }  
19.         if(atexit(my_exit1) != 0) {  
20.                 printf("can't register my_exit1");  
21.         }  
22.         printf("main is done\n");  
23.         return 0;  
24. }  

 

 

gcc关闭共享库

1. gcc -static hello.c  
2. 关闭后可以发现目标文件明显比之前大了很多  

 

 

 

假设一个函数程序如下

这个程序调用顺序是main --> do_line --> cmd_add --> get_token

如果在get_token()函数中发生了错误，函数需要跳回main中，此时我们不得不坚持返回值然后一个个返回

1. #include <stdio.h>  
2. #include <stdlib.h>  
3. #include <setjmp.h>  
4. #define TOK_ADD 5  
5. #define MAXLINE 1024  
6. char *tok_ptr;  
7.   
8. int get_token(void) {  
9.         //fetch next token from line pointed to by tok_ptr  
10. }  
11.   
12. void cmd_add(void) {  
13.         int token;  
14.         token = get_token();  
15.         //rest of processing for this command  
16. }  
17.   
18. void do_line(char *ptr) {  
19.         int cmd;  
20.         tok_ptr = ptr;  
21.         while((cmd=get_token()) > 0) {  
22.                 switch(cmd) {  
23.                         case TOK_ADD:  
24.                             cmd_add();  
25.                             break;  
26.                 }  
27.         }  
28. }  
29.   
30.   
31. int main(int argc, char *argv[]) {  
32.         char line[MAXLINE];  
33.         if(fgets(line,MAXLINE,stdin) != NULL) {  
34.                 do_line(line);  
35.         }  
36.   
37.         return 0;  
38. }  

 

用setjmp和longjmp函数可以跳过函数返回

这里需要定义个全局的jmp_buf结构体，也就是setjmp()函数的env

longjmp可以对应多个setjmp()函数，通过第二个参数val区分，比如cmd_add对应1，而get_token对应2

这样就可以知道是哪个函数返回的了

1. #include <stdio.h>  
2. #include <stdlib.h>  
3. #include <setjmp.h>  
4. #define TOK_ADD 5  
5. #define MAXLINE 1024  
6. char *tok_ptr;  
7. jmp_buf jmpbuffer;  
8.   
9. int get_token(void) {  
10.         //fetch next token from line pointed to by tok_ptr  
11. }  
12.   
13. void cmd_add(void) {  
14.         int token;  
15.         token = get_token();  
16.         if(token < 0) {  
17.                 longjmp(jmpbuffer,1);  
18.         }  
19. }  
20.   
21. void do_line(char *ptr) {  
22.         int cmd;  
23.         tok_ptr = ptr;  
24.         while((cmd=get_token()) > 0) {  
25.                 switch(cmd) {  
26.                         case TOK_ADD:  
27.                             cmd_add();  
28.                             break;  
29.                 }  
30.         }  
31. }  
32.   
33. int main(int argc, char *argv[]) {  
34.         char line[MAXLINE];  
35.         if(setjmp(jmpbuffer) != 0) {  
36.                 printf("setjmp error\r\n");  
37.         }  
38.         if(fgets(line,MAXLINE,stdin) != NULL) {  
39.                 do_line(line);  
40.         }  
41.   
42.         return 0;  
43. }  

 

 

执行跳转后各种类型的变量情况

自动，静态，寄存器，全局，易变 的变量是否会随着函数的回滚而回滚

目前测试是不会，所有变量都没有回滚，书中说到对于全部优化情况下，寄存器变量，易变变量会回滚

1. #include <stdio.h>  
2. #include <stdlib.h>  
3. #include <setjmp.h>  
4.   
5. static jmp_buf jmpbuffer;  
6. static int globval;  
7.   
8. static void f2(void) {  
9.         longjmp(jmpbuffer, 1);  
10. }  
11.   
12. static void f1(int i, int j, int k, int m) {  
13.         printf("int f1()\n");  
14.         printf("globval=%d, atuoval=%d, regival=%d, valaval=%d, statval=%d\n",globval,i,j,k,m);  
15. }  
16.   
17. int main(int argc, char *argv[]) {  
18.         int autoval;  
19.         register int regival;  
20.         volatile int volaval;  
21.         static int statval;  
22.   
23.         globval = 1;  
24.         autoval = 2;  
25.         regival = 3;  
26.         volaval = 4;  
27.         statval = 5;  
28.   
29.         if(setjmp(jmpbuffer) != 0) {  
30.                 printf("after jmp\n");  
31.                 printf("globval=%d, atuoval=%d, regival=%d, valaval=%d, statval=%d\n",globval,autoval,regival,volaval,statval);  
32.                 exit(0);  
33.         }  
34.         globval = 95;  
35.         autoval = 96;  
36.         regival = 97;  
37.         volaval = 98;  
38.         statval = 99;  
39.         f1(autoval, regival, volaval, statval);  
40.         exit(0);  
41. }  

 

 

自动变量需要注意返回值

这里的函数open_data返回值的内容是当前函数栈中的，所以返回了就没有了，应当定义成静态的或者通过

malloc函数动态申请的

1. #include <stdio.h>  
2. #include <fcntl.h>  
3. #include <stdlib.h>  
4. #include <unistd.h>  
5. #include <sys/stat.h>  
6. #define BUFSIZE 1024  
7. FILE *open_data(void) {  
8.         FILE *fp;  
9.         char databuf[BUFSIZE];  
10.         if((fp=fopen("datafile","r")) == NULL) {  
11.                 return(NULL);  
12.         }  
13.         if(setvbuf(fp,databuf,_IOLBF,BUFSIZE) != 0) {  
14.                 return (NULL);  
15.         }  
16.         return fp;  
17. }  
18.   
19. int main(int argc, char *argv[]) {  
20.         FILE *fp = open_data();  
21. }  

 

 

获取当前系统的各种软限制和硬限制

1. #include <stdio.h>  
2. #include <sys/resource.h>  
3. #define doit(name) pr_limits(#name, name);  
4.   
5. static void pr_limits(char *name, int resource) {  
6.         struct rlimit limit;  
7.         unsigned long long lim;  
8.         if(getrlimit(resource, &limit) < 0) {  
9.                 printf("getrlimit error for %s,",name);  
10.         }  
11.         printf("%-14s  ",name);  
12.   
13.         if(limit.rlim_cur == RLIM_INFINITY) {  
14.                 printf(" (infinite) ");  
15.         } else {  
16.                 printf("%10lld ",lim);  
17.         }  
18.   
19.         if(limit.rlim_max == RLIM_INFINITY) {  
20.                 printf(" (infinite) ");  
21.         } else {  
22.                 printf("%10lld",lim);  
23.         }  
24.         putchar((int)'\n');  
25. }  
26.   
27. int main(int argc, char *argv[]) {  
28. #ifdef RLIMIT_AS  
29.         doit(RLIMIT_AS);  
30. #endif  
31.   
32.         doit(RLIMIT_CORE);  
33.         doit(RLIMIT_CPU);  
34.         doit(RLIMIT_DATA);  
35.         doit(RLIMIT_FSIZE);  
36.   
37. #ifdef  RLIMIT_MEMLOCK  
38.         doit(RLIMIT_MEMLOCK);  
39. #endif  
40.   
41. #ifdef RLIMIT_MSGQUEUE  
42.         doit(RLIMIT_MSGQUEUE);  
43. #endif  
44.   
45. #ifdef RLIMIT_NICE  
46.         doit(RLIMIT_NICE);  
47. #endif  
48.   
49.         doit(RLIMIT_NOFILE);  
50.   
51. #ifdef RLIMIT_nproc  
52.         doit(RLIMIT_NPROC);  
53. #endif  
54.   
55. #ifdef RLIMIT_RSS  
56.         doit(RLIMIT_RSS);  
57. #endif  
58.   
59. #ifdef RLIMIT_SBSIZE  
60.         doit(RLIMIT_SBSIZE);  
61. #endif  
62.   
63. #ifdef RLIMIT_SIGPENDING  
64.         doit(RLIMIT_SIGPENDING);  
65. #endif  
66.   
67.         doit(RLIMIT_STACK);  
68.   
69. #ifdef RLIMIT_SWAP  
70.         doit(RLIMIT_SWAP);  
71. #endif  
72.   
73. #ifdef RLIMIT_VMEM  
74.         doit(RLIMIT_VMEM);  
75. #endif  
76.         return 0;  
77. }  

 

 

 

参考

Linux下C程序进程地址空间布局

gcc 编译共享库

c程序是如何启动和终止