在《LINUX下动态链接库的创建与应 用》一文中,我介绍了LINUX动态链接库的基本知识.其要点是:用户根据实际情况需要,利用dlopen,dlsym,dlclose等动态链接库操作 函数,装入指定的动态链接库中指定的函数,然后加以执行.程序中使用很少的动态函数时,这样的做法尚可.如果程序需要调用大量的动态函数,那么采用这样的 编程手段将是非常繁复的,所以我们必须使用一种更为聪明的办法,以减少代码量,提高工作效率.这就是现在我要举例介绍的《LINUX动态链接库高级应 用》.
 
注:本文举的例子类似上篇文章,只是文件的内容已做相应修改,裁减了不少.示例程序ady.c和两个动态函数的源程序getdate.c与gettime.c仅修改了头文件的名字,其内容不再列出.本文使用头文件为adatetime.h.

 
要想高效地应用LINUX动态链接库(尤其是用户自己编写的),需要做以下工作:
 
一、编写合格的动态链接库头文件
 
C语言的头文件,可供一个或多个程序引用,里面一般定义程序所需的常量,自定义类型及函数原型说明等.其中的函数原型说明,则供编译器检查语法,用于排除引用参数时类型不一致的错误.只有编写合格的动态链接库头文件,程序员才能正确使用动态链接库内的函数.

 
动态链接库头文件要采用C语言标准格式,其中的动态函数原型定义,不必象上文介绍的那样用(*动态函数名)的描述形式.请看下面的例子:(每行开始的数字为所在行行号,为笔者添加,供注解使用)

 
1 /* adatetime.h : 纵横软件制作中心雨亦奇(zhsoft@371.net)编写, 2002-03-06. */
2 
3 #ifndef __DATETIME_H
4 
5 #define __DATETIME_H
6 
7 /* 日期结构 */
8 typedef struct
9 {
10 int year;
11 int mon;
12 int day;
13 }DATETYPE;
14 
15 /* 时间结构 */
16 typedef struct
17 {
18 char hour;
19 char min;
20 char sec;
21 }TIMETYPE;
22 
23 int getdate(DATETYPE *d); /* 取当前日期 */
24 int gettime(TIMETYPE *t); /* 取当前时间 */
25 
26 #endif
27 

 
注:与上文的datetime.h文件比较,从该头文件第23,24行可以看到,动态函数getdate,gettime的原型定义改变了,不再使用(*getdate),(*gettime)的格式了(这种格式使用较为罗嗦).

 
二、正确编译与命名动态链接库

 
为了让GCC编译器生成动态链接库,编译时须加选项-shared.(这点须牢记)

 
LINUX系统中,为了让动态链接库能被系统中其它程序共享,其名字应符合“lib*.so*”这种格式.如果某个动态链接库不符合此格式,则LINUX的动态链接库自动装入程序(ld.so)将搜索不到此链接库,其它程序也无法共享之.

 
格式中,第一个*通常表示为简写的库名,第二个*通常表示为该库的版本号.如:在我的系统中,基本C动态链接库的名字为 libc.so.6,线程 pthread动态链接库的名字为libpthread.so.0等等.本文例子所生成的动态链接库的名字为libmy.so,虽没有版本号,但也符合所 要求的格式.

 
生成该动态链接库的维护文件makefile-lib内容如下:

 
1 # makefile : 纵横软件制作中心雨亦奇编写, 2002-03-07.
2 
3 all : libmy.so
4 
5 SRC = getdate.c gettime.c
6 
7 TGT = $(SRC:.c=.o)
8 
9 $(SRC) : adatetime.h
10 @touch $@
11 
12 %.o : %.c
13 cc -c $?
14 
15 # 动态链接库(libmy.so)生成
16 libmy.so : $(TGT)
17 cc -s -shared -o $@ $(TGT)
18 

 
运行命令:

 
$ make -f makefile-lib
$

 
即生成libmy.so库.

 
注: 维护文件中,第17行用-shared选项以生成动态链接库,用-s选项以去掉目标文件中的符号表,从而减小文件长度.

 
三、共享动态链接库

 
3.1 动态链接库配置文件

 
为了让动态链接库为系统所使用,需要维护动态链接库的配置文件--/etc/ld.so.conf.此文件内,存放着可被LINUX共享 的动态链接库所在目录的名字(系统目录/lib,/usr/lib除外),各个目录名间以空白字符(空格,换行等)或冒号或逗号分隔.一般的LINUX发 行版中,此文件均含一个共享目录/usr/X11R6/lib,为X window窗口系统的动态链接库所在的目录.

 
下面看看我的系统中此文件的内容如何:

 
# cat /etc/ld.so.conf
/usr/X11R6/lib
/usr/zzz/lib
#

 
由上可以看出,该动态库配置文件中,增加了一个/usr/zzz/lib目录.这是我自己新建的共享库目录,下面存放我新开发的可供系统共享的动态链接库.

 
3.2 动态链接库管理命令

 
为了让动态链接库为系统所共享,还需运行动态链接库的管理命令--ldconfig.此执行程序存放在/sbin目录下.

 
ldconfig命令的用途,主要是在默认搜寻目录(/lib和/usr/lib)以及动态库配置文件/etc/ld.so.conf内 所列的目录下,搜索出可共享的动态链接库(格式如前介绍,lib*.so*),进而创建出动态装入程序(ld.so)所需的连接和缓存文件.缓存文件默认 为 /etc/ld.so.cache,此文件保存已排好序的动态链接库名字列表.

 
ldconfig通常在系统启动时运行,而当用户安装了一个新的动态链接库时,就需要手工运行这个命令.

 
ldconfig命令行用法如下:

 
ldconfig [-v|--verbose] [-n] [-N] [-X] [-f CONF] [-C CACHE] [-r ROOT] [-l] [-p|--print-cache] [-c FORMAT] [--format=FORMAT] [-V] [-?|--help|--usage] path...

 
ldconfig可用的选项说明如下:

 
(1) -v或--verbose : 用此选项时,ldconfig将显示正在扫描的目录及搜索到的动态链接库,还有它所创建的连接的名字.

 
(2) -n : 用此选项时,ldconfig仅扫描命令行指定的目录,不扫描默认目录(/lib,/usr/lib),也不扫描配置文件/etc/ld.so.conf所列的目录.

 
(3) -N : 此选项指示ldconfig不重建缓存文件(/etc/ld.so.cache).若未用-X选项,ldconfig照常更新文件的连接.

 
(4) -X : 此选项指示ldconfig不更新文件的连接.若未用-N选项,则缓存文件正常更新.

 
(5) -f CONF : 此选项指定动态链接库的配置文件为CONF,系统默认为/etc/ld.so.conf.

 
(6) -C CACHE : 此选项指定生成的缓存文件为CACHE,系统默认的是/etc/ld.so.cache,此文件存放已排好序的可共享的动态链接库的列表.

 
(7) -r ROOT : 此选项改变应用程序的根目录为ROOT(是调用chroot函数实现的).选择此项时,系统默认的配置文件/etc/ld.so.conf,实际对应的为 ROOT/etc/ld.so.conf.如用-r /usr/zzz时,打开配置文件/etc/ld.so.conf时,实际打开的是/usr/zzz/etc/ld.so.conf文件.用此选项,可以 大大增加动态链接库管理的灵活性.

 
(8) -l : 通常情况下,ldconfig搜索动态链接库时将自动建立动态链接库的连接.选择此项时,将进入专家模式,需要手工设置连接.一般用户不用此项.

 
(9) -p或--print-cache : 此选项指示ldconfig打印出当前缓存文件所保存的所有共享库的名字.

 
(10) -c FORMAT 或 --format=FORMAT : 此选项用于指定缓存文件所使用的格式,共有三种:old(老格式),new(新格式)和compat(兼容格式,此为默认格式).

 
(11) -V : 此选项打印出ldconfig的版本信息,而后退出.

 
(12) -? 或 --help 或 --usage : 这三个选项作用相同,都是让ldconfig打印出其帮助信息,而后退出.

 
举三个例子:

 
例1:

 
# ldconfig -p
793 libs found in cache `/etc/ld.so.cache'
libzvt.so.2 (libc6) => /usr/lib/libzvt.so.2
libzvt.so (libc6) => /usr/lib/libzvt.so
libz.so.1.1.3 (libc6) => /usr/lib/libz.so.1.1.3
libz.so.1 (libc6) => /lib/libz.so.1
......
#

 
注: 有时候用户想知道系统中有哪些动态链接库,或者想知道系统中有没有某个动态链接库,这时,可用-p选项让ldconfig输出缓存文件中的动态链接库列 表,从而查询得到.例子中,ldconfig命令的输出结果第1行表明在缓存文件/etc/ld.so.cache中找到793个共享库,第2行开始便是 一系列共享库的名字及其全名(绝对路径).因为实际输出结果太多,为节省篇幅,以......表示省略的部分.

 
例2:

 
# ldconfig -v
/lib:
liby.so.1 -> liby.so.1
libnss_wins.so -> libnss_wins.so
......
/usr/lib:
libjscript.so.2 -> libjscript.so.2.0.0
libkspell.so.2 -> libkspell.so.2.0.0
......
/usr/X11R6/lib:
libmej-0.8.10.so -> libmej-0.8.10.so
libXaw3d.so.7 -> libXaw3d.so.7.0
......
#

 
注: ldconfig命令在运行正常的情况下,默认不输出什么东西.本例中用了-v选项,以使ldconfig在运行时输出正在扫描的目录及搜索到的共享库, 用户可以清楚地看到运行的结果.执行结束后,ldconfig将刷新缓存文件/etc/ld.so.cache.

 
例3:

 
# ldconfig /usr/zhsoft/lib
#

 
注: 当用户在某个目录下面创建或拷贝了一个动态链接库,若想使其被系统共享,可以执行一下"ldconfig 目录名"这个命令.此命令的功能在于让ldconfig将指定目录下的动态链接库被系统共享起来,意即:在缓存文件/etc/ld.so.cache中追 加进指定目录下的共享库.本例让系统共享了/usr/zhsoft/lib目录下的动态链接库.需要说明的是,如果此目录不在/lib,/usr/lib 及/etc/ld.so.conf文件所列的目录里面,则再度运行ldconfig时,此目录下的动态链接库可能不被系统共享了.

3.3 动态链接库如何共享
 
了解了以上知识,我们可以采用以下三种方法来共享动态链接库:(注:均须在超级用户状态下操作,以我的动态链接库libmy.so共享过程为例)

 
(1)拷贝动态链接库到系统共享目录下,或在系统共享目录下为该动态链接库建立个连接(硬连接或符号连接均可,常用符号连接).这里说的 系统共享目录,指的是LINUX动态链接库存放的目录,它包含/lib,/usr/lib以及/etc/ld.so.conf文件内所列的一系列目录.

 
# cp libmy.so /lib
# ldconfig
#

 
或:

 
# ln -s `pwd`/libmy.so /lib
# ldconfig
#

 
(2)将动态链接库所在目录名追加到动态链接库配置文件/etc/ld.so.conf中.

 
# pwd >> /etc/ld.so.conf
# ldconfig
#

 
(3)利用动态链接库管理命令ldconfig,强制其搜索指定目录,并更新缓存文件,便于动态装入.

 
# ldconfig `pwd`
#

 
需要说明的是,这种操作方法虽然有效,但效果是暂时的,供程序测试还可以,一旦再度运行ldconfig,则缓存文件内容可能改变,所需 的动态链接库可能不被系统共享了.与之相比较,前两种方法是可靠的方法,值得业已定型的动态链接库共享时采用.前两种方法还有一个特点,即最后一条命令都 是 ldconfig,也即均需要更新一下缓存文件,以确保动态链接库的共享生效.

 
四、含有动态函数的程序的编译

 
4.1 防止编译因未指定动态链接库而出错

 
当一个程序使用动态函数时,编译该程序时就必须指定含所用动态函数的动态链接库,否则编译将会出错退出.如本文示例程序ady.c的编译(未明确引用动态链接库libmy.so):

 
# cc -o ady ady.c
/tmp/ccL4FsJp.o: In function `main':
/tmp/ccL4FsJp.o(.text+0x43): undefined reference to `gettime'
collect2: ld returned 1 exit status
#

 
注: 因为ady.c所含的动态函数getdate,gettime不在系统函数库中,所以连接时出错.

 
4.2 编译时引用动态链接库的几种方式

 
(1)当所用的动态链接库在系统目录(/lib,/usr/lib)下时,可用编译选项-l来引用.即:

 
# cc -lmy -o ady ady.c
#

 
注:编译时用-l选项引用动态链接库时,库名须使用其缩写形式.本例的my,表示引用libmy.so库.若引用光标库libncurses.so,须用-lncurses.注意,-l选项与参数之间不能有空格,否则会出错.

 
(2)当所用的动态链接库在系统目录(/lib,/usr/lib)以外的目录时,须用编译选项-L来指定动态链接库所在的目录(供编译器查找用),同时用-l选项指定缩写的动态链接库名.即:

 
# cc -L/usr/zzz/lib -lmy -o ady ady.c
#

 
(3)直接引用所需的动态链接库.即:

 
# cc -o ady ady.c libmy.so
#

 
或

 
# cc -o ady ady.c /lib/libmy.so
#

 
等等.其中,动态链接库的库名可以采用相对路径形式(文件名不以/开头),也可采用绝对路径形式(文件名以/开头).

 
五、动态链接程序的运行与检查

 
5.1 运行

 
编译连接好含动态函数的程序后,就可以运行它了.动态链接程序因为共享了系统中的动态链接库,所以其空间占用很小.但这并不意味功能的减少,它的执行与静态连接的程序执行,效果完全相同.在命令提示符下键入程序名及相关参数后回车即可,如下例:

 
$ ady
动态链接库高级应用示范
当前日期: 2002-03-11
当前时间: 19:39:06
$

 
5.2 检查

 
检查什么?检查动态链接程序究竟需要哪些共享库,系统中是否已有这些库,没有的话,用户好想办法把这些库装上.

 
怎么检查呢?这里,告诉你一个实用程序--ldd,这个程序就是专门用来检查动态链接程序依赖哪些共享库的.

 
ldd命令行用法如下:

 
ldd [--version] [-v|--verbose] [-d|--data-relocs] [-r|--function-relocs] [--help] FILE...

 
各选项说明如下:

 
(1) --version : 此选项用于打印出ldd的版本号.

 
(2) -v 或 --verbose : 此选项指示ldd输出关于所依赖的动态链接库的尽可能详细的信息.

 
(3) -d 或 --data-relocs : 此选项执行重定位,并且显示不存在的函数.

 
(4) -r 或 --function-relocs : 此选项执行数据对象与函数的重定位,同时报告不存在的对象.

 
(5) --help : 此选项用于打印出ldd的帮助信息.

 
注: 上述选项中,常用-v(或--verbose)选项.

 
ldd的命令行参数为FILE...,即一个或多个文件名(动态链接程序或动态链接库).

 
例1:

 
$ ldd ady
libmy.so => ./libmy.so (0x40026000)
libc.so.6 => /lib/libc.so.6 (0x40028000)
/lib/ld-linux.so.2 => /lib/ld-linux.so.2 (0x40000000)
$

 
注: 每行=>前面的,为动态链接程序所需的动态链接库的名字,而=>后面的,则是运行时系统实际调用的动态链接库的名字,所需的动态链接库在系统 中不存在时,=>后面将显示"not found",括号所括的数字为虚拟的执行地址.本例列出ady所需的三个动态链接库,其中libmy.so为自己新建的动态链接库,而 libc.so.6与/lib/ld-linux.so.2均为系统的动态链接库,前一个为基本C库,后一个动态装入库(用于动态链接库的装入及运行).

 
例2:

 
$ ldd -v ady
libmy.so => ./libmy.so (0x40026000)
libc.so.6 => /lib/libc.so.6 (0x40028000)
/lib/ld-linux.so.2 => /lib/ld-linux.so.2 (0x40000000)

 
Version information:
./ady:
libc.so.6 (GLIBC_2.1.3) => /lib/libc.so.6
libc.so.6 (GLIBC_2.0) => /lib/libc.so.6
./libmy.so:
libc.so.6 (GLIBC_2.1.3) => /lib/libc.so.6
libc.so.6 (GLIBC_2.0) => /lib/libc.so.6
/lib/libc.so.6:
ld-linux.so.2 (GLIBC_2.1.1) => /lib/ld-linux.so.2
ld-linux.so.2 (GLIBC_2.2.3) => /lib/ld-linux.so.2
ld-linux.so.2 (GLIBC_2.1) => /lib/ld-linux.so.2
ld-linux.so.2 (GLIBC_2.2) => /lib/ld-linux.so.2
ld-linux.so.2 (GLIBC_2.0) => /lib/ld-linux.so.2
$

 
注:本例用-v选项以显示尽可能多的信息,所以例中除列出ady所需要的动态链接库外,还列出了程序所需动态链接库版本方面的信息.

 
小结: 在LINUX动态链接库的高级应用中,关键有两点,一是如何让动态链接库为LINUX系统所共享,二是编译连接程序时如何做.让动态链接库为系统所共享, 主要是用ldconfig管理命令,维护好系统共享库的缓存文件/etc/ld.so.cache.编译连接时如何做?注意连接上所用的动态链接库就可以 了.LINUX动态链接库的高级应用,用一用就明白:其实,就是这么简单!
点击这里下载示例程序。

Trackback: http://tb.donews.net/TrackBack.aspx?PostId=75642

　　动态链接库是一种通用的软件组件技术，是多种操作系统中提供基本服务的方式。比如Win32内核就是3个DLL文件构成。这种技术在Linux操作系统下也有对应的实现，就是Linux标准对象Standard Ojbect，对应的文件扩展名为.so。

　　下面通过一个简单的例子开始介绍Linux标准对象。

　　我们的标准对象文件含有一个函数，不需要声明export导出符号，只需要编译器设置即可。如下：

　　#include

　　#include

　　void show() {

　　printf("Standard Object by gashero\n");

　　}

　　保存为myso.c文件，按照如下编译：

　　$ gcc -fPIC -shared -o libmyso.so myso.c

　　执行生成一个libmyso.so文件，按照Linux标准对象的命名惯例，应该在库名称之前加上"lib"前缀，尽管不是必须的。编译开关-fPIC代表函数符号可以重定向，-shared代表编译结果是一个标准对象。

　　不同于Win32DLL，Linux标准对象中的所有函数都是直接导出的，都可以被调用程序所访问。下面我们编写调用程序：

　　#include

　　int main() {

　　printf("Invoke my so\n");

　　show();

　　return 0;

　　}

　　保存为invoke.c，按照如下gcc开关编译：

　　$ gcc -o test invoke.c ./libmyso.so

　　编译生成test可执行文件。如上编译条件的最后一条需要是所调用的标准对象文件名，注意必须含有路径。如果只是使用libmyso.so，则必须确保这个文件在可访问的PATH下面。本例所使用的文件名"./libmyso.so"是当前路径下的，使用了相对路径。

　　如下测试结果：

　　$ ./test

　　Invoke my so

　　Standard Object by gashero

gcc 编译选项,自己翻译的.

-o 设定输出文件名
-c 只编译,不连接.
-E 只做预编译.
-pipe 在多个编译过程之间使用管道.
--version 显示版本.
-static 静态连接.
-ansi C 模式下支持所有 ISO C90 标准的 C 程序, C++ 模式下去除对 GNU C++ 扩展的支持(GNU扩展会与 ISO C++ 冲突)
-std= 确定编译语言的标准,目前只在编译 C 和 C++ 时有效 -fno-asm 不将 "asm" "inline" "typeof" 作为关键字,可以用他们做变量名等. -funsigned-char 将"char"的数据类型设为"unsigned",即无符号.
-fsigned-char 正好相反,将"char"设为"signed".
-fsyntax-only 只检查语法错误,不做其他任何事.
-pedantic 显示所有的 ISO C 和 ISO C++ 的警告,并且拒绝所有使用禁止扩展的程序
-Wall 显示所有警告
-g 将编译时的调试信息保存到本地文件中( stabs,COFF,XCOFF,DWARF)
-ggdb 为 GDB 产生调试信息,包含 GDB 的扩展.
-ggdb(level) 设定产生何种等级的调试信息, level 为 1-3, 1 最少,3 最多.
-ftime-reprot 统计编译消耗的时间并显示报告.
-fmem-report 显示所有的静态内存分配.
-ftest-coverages 为 gcov工具产生数据文件.
gcc 编译选项,翻译出来用起来方便.

VC编译选项（转载）- -
Tag： 编程                                          
/***********************************************************************************************/
VC编译选项 csdnb3a [原作]

关键字 VC编译选项 出处
-优化-
/O1 最小化空间 minimize space
/Op[-] 改善浮点数一致性 improve floating-pt consistency
/O2 最大化速度 maximize speed
/Os 优选代码空间 favor code space
/Oa 假设没有别名 assume no aliasing
/Ot 优选代码速度 favor code speed
/Ob 内联展开（默认 n=0） inline expansion (default n=0)
/Ow 假设交叉函数别名 assume cross-function aliasing
/Od 禁用优化（默认值） disable optimizations (default)
/Ox 最大化选项。(/Ogityb2 /Gs) maximum opts. (/Ogityb1 /Gs)
/Og 启用全局优化 enable global optimization
/Oy[-] 启用框架指针省略 enable frame pointer omission
/Oi 启用内建函数 enable intrinsic functions

-代码生成-
/G3 为 80386 进行优化 optimize for 80386
/G4 为 80486 进行优化 optimize for 80486
/GR[-] 启用 C++ RTTI enable C++ RTTI
/G5 为 Pentium 进行优化 optimize for Pentium
/G6 为 Pentium Pro 进行优化 optimize for Pentium Pro
/GX[-] 启用 C++ 异常处理（与 /EHsc 相同） enable C++ EH (same as /EHsc)
/EHs 启用同步 C++ 异常处理 enable synchronous C++ EH
/GD 为 Windows DLL 进行优化 optimize for Windows DLL
/GB 为混合模型进行优化（默认） optimize for blended model (default)
/EHa 启用异步 C++ 异常处理 enable asynchronous C++ EH
/Gd __cdecl 调用约定 __cdecl calling convention
/EHc extern“C”默认为 nothrow extern "C" defaults to nothrow
/Gr __fastcall 调用约定 __fastcall calling convention
/Gi[-] 启用增量编译 enable incremental compilation
/Gz __stdcall 调用约定 __stdcall calling convention
/Gm[-] 启用最小重新生成 enable minimal rebuild
/GA 为 Windows 应用程序进行优化 optimize for Windows Application
/Gf 启用字符串池 enable string pooling
/QIfdiv[-] 启用 Pentium FDIV 修复 enable Pentium FDIV fix
/GF 启用只读字符串池 enable read-only string pooling
/QI0f[-] 启用 Pentium 0x0f 修复 enable Pentium 0x0f fix
/Gy 分隔链接器函数 separate functions for linker
/GZ 启用运行时调试检查 enable runtime debug checks
/Gh 启用钩子函数调用 enable hook function call
/Ge 对所有函数强制堆栈检查 force stack checking for all funcs
/Gs[num] 禁用堆栈检查调用 disable stack checking calls

-输出文件-
/Fa[file] 命名程序集列表文件 name assembly listing file
/Fo 命名对象文件 name object file
/FA[sc] 配置程序集列表 configure assembly listing
/Fp 命名预编译头文件 name precompiled header file
/Fd[file] 命名 .PDB 文件 name .PDB file
/Fr[file] 命名源浏览器文件 name source browser file
/Fe 命名可执行文件 name executable file
/FR[file] 命名扩展 .SBR 文件 name extended .SBR file
/Fm[file] 命名映射文件 name map file

-预处理器-
/FI 命名强制包含文件 name forced include file
/C 不吸取注释 don't strip comments
/U 移除预定义宏 remove predefined macro
/D{=|#} 定义宏 define macro
/u 移除所有预定义宏 remove all predefined macros
/E 将预处理定向到标准输出 preprocess to stdout
/I 添加到包含文件的搜索路径 add to include search path
/EP 将预处理定向到标准输出，不要带行号 preprocess to stdout, no #line
/X 忽略“标准位置” ignore "standard places"
/P 预处理到文件 preprocess to file

-语言-
/Zi 启用调试信息 enable debugging information
/Zl 忽略 .OBJ 中的默认库名 omit default library name in .OBJ
/ZI 启用调试信息的“编辑并继续”功能 enable Edit and Continue debug info
/Zg 生成函数原型 generate function prototypes
/Z7 启用旧式调试信息 enable old-style debug info
/Zs 只进行语法检查 syntax check only
/Zd 仅要行号调试信息 line number debugging info only
/vd{0|1} 禁用/启用 vtordisp disable/enable vtordisp
/Zp[n] 在 n 字节边界上包装结构 pack structs on n-byte boundary
/vm 指向成员的指针类型 type of pointers to members
/Za 禁用扩展（暗指 /Op） disable extensions (implies /Op)
/noBool 禁用“bool”关键字 disable "bool" keyword
/Ze 启用扩展（默认） enable extensions (default)

- 杂项 -
/?, /help 打印此帮助消息 print this help message
/c 只编译，不链接 compile only, no link
/W 设置警告等级（默认 n=1） set warning level (default n=1)
/H 最大化外部名称长度 max external name length
/J 默认 char 类型是 unsigned default char type is unsigned
/nologo 取消显示版权消息 suppress copyright message
/WX 将警告视为错误 treat warnings as errors
/Tc 将文件编译为 .c compile file as .c
/Yc[file] 创建 .PCH 文件 create .PCH file
/Tp 将文件编译为 .cpp compile file as .cpp
/Yd 将调试信息放在每个 .OBJ 中 put debug info in every .OBJ
/TC 将所有文件编译为 .c compile all files as .c
/TP 将所有文件编译为 .cpp compile all files as .cpp
/Yu[file] 使用 .PCH 文件 use .PCH file
/V 设置版本字符串 set version string
/YX[file] 自动的 .PCH 文件 automatic .PCH
/w 禁用所有警告 disable all warnings
/Zm 最大内存分配（默认为 %） max memory alloc (% of default)

-链接-
/MD 与 MSVCRT.LIB 链接 link with MSVCRT.LIB
/MDd 与 MSVCRTD.LIB 调试库链接 link with MSVCRTD.LIB debug lib
/ML 与 LIBC.LIB 链接 link with LIBC.LIB
/MLd 与 LIBCD.LIB 调试库链接 link with LIBCD.LIB debug lib
/MT 与 LIBCMT.LIB 链接 link with LIBCMT.LIB
/MTd 与 LIBCMTD.LIB 调试库链接 link with LIBCMTD.LIB debug lib
/LD 创建 .DLL Create .DLL
/F 设置堆栈大小 set stack size
/LDd 创建 .DLL 调试库 Create .DLL debug libary
/link [链接器选项和库] [linker options and libraries]

qmake是用来为不同的平台的开发项目创建makefile的Trolltech开发一个易于使用的工具。qmake简化了makefile的生成，所以为了创建一个makefile只需要一个只有几行信息的文件。qmake可以供任何一个软件项目使用，而不用管它是不是用Qt写的，尽管它包含了为支持Qt开发所拥有的额外的特征。

qmake基于一个项目文件这样的信息来生成makefile。项目文件可以由开发者生成。项目文件通常很简单，但是如果需要它是非常完善的。不用修改项目文件，qmake也可以为为Microsoft Visual Studio生成项目。

qmake的概念

QMAKESPEC环境变量

举例来说，如果你在Windows下使用Microsoft Visual Studio，然后你需要把QMAKESPEC环境变量设置为win32-msvc。如果你在Solaris上使用gcc，你需要把QMAKESPEC环境变量设置为solaris-g++。

在qt/mkspecs中的每一个目录里面，都有一个包含了平台和编译器特定信息的qmake.conf文件。这些设置适用于你要使用qmake的任何项目，请不要修改它，除非你是一个专家。例如，假如你所有的应用程序都必须和一个特定的库连接，你可以把这个信息添加到相应的qmake.conf文件中。

项目(.pro)文件

一个项目文件是用来告诉qmake关于为这个应用程序创建makefile所需要的细节。例如，一个源文件和头文件的列表、任何应用程序特定配置、例如一个必需要连接的额外库、或者一个额外的包含路径，都应该放到项目文件中。

“#”注释

你可以为项目文件添加注释。注释由“#”符号开始，一直到这一行的结束。

模板

模板变量告诉qmake为这个应用程序生成哪种makefile。下面是可供使用的选择：

• app - 建立一个应用程序的makefile。这是默认值，所以如果模板没有被指定，这个将被使用。

• lib - 建立一个库的makefile。

• vcapp - 建立一个应用程序的Visual Studio项目文件。

• vclib - 建立一个库的Visual Studio项目文件。

• subdirs - 这是一个特殊的模板，它可以创建一个能够进入特定目录并且为一个项目文件生成makefile并且为它调用make的makefile。

“app”模板

“app”模板告诉qmake为建立一个应用程序生成一个makefile。当使用这个模板时，下面这些qmake系统变量是被承认的。你应该在你的.pro文件中使用它们来为你的应用程序指定特定信息。

• HEADERS - 应用程序中的所有头文件的列表。

• SOURCES - 应用程序中的所有源文件的列表。

• FORMS - 应用程序中的所有.ui文件（由Qt设计器生成）的列表。

• LEXSOURCES - 应用程序中的所有lex源文件的列表。

• YACCSOURCES - 应用程序中的所有yacc源文件的列表。

• TARGET - 可执行应用程序的名称。默认值为项目文件的名称。（如果需要扩展名，会被自动加上。）

• DESTDIR - 放置可执行程序目标的目录。

• DEFINES - 应用程序所需的额外的预处理程序定义的列表。

• INCLUDEPATH - 应用程序所需的额外的包含路径的列表。

• DEPENDPATH - 应用程序所依赖的搜索路径。

• VPATH - 寻找补充文件的搜索路径。

• DEF_FILE - 只有Windows需要：应用程序所要连接的.def文件。

• RC_FILE - 只有Windows需要：应用程序的资源文件。

• RES_FILE - 只有Windows需要：应用程序所要连接的资源文件。

你只需要使用那些你已经有值的系统变量，例如，如果你不需要任何额外的INCLUDEPATH，那么你就不需要指定它，qmake会为所需的提供默认值。例如，一个实例项目文件也许就像这样：

TEMPLATE = app
DESTDIR  = c:\helloapp
HEADERS += hello.h
SOURCES += hello.cpp 
SOURCES += main.cpp
DEFINES += QT_DLL
CONFIG  += qt warn_on release

如果条目是单值的，比如template或者目的目录，我们是用“=”，但如果是多值条目，我们使用“+=”来为这个类型添加现有的条目。使用“=”会用新值替换原有的值，例如，如果我们写了DEFINES=QT_DLL，其它所有的定义都将被删除。

“lib”模板

“lib”模板告诉qmake为建立一个库而生成makefile。当使用这个模板时，除了“app”模板中提到系统变量，还有一个VERSION是被支持的。你需要在为库指定特定信息的.pro文件中使用它们。

• VERSION - 目标库的版本号，比如，2.3.1。

“subdirs”模板

“subdirs”模板告诉qmake生成一个makefile，它可以进入到特定子目录并为这个目录中的项目文件生成makefile并且为它调用make。

在这个模板中只有一个系统变量SUBDIRS可以被识别。这个变量中包含了所要处理的含有项目文件的子目录的列表。这个项目文件的名称是和子目录同名的，这样qmake就可以发现它。例如，如果子目里是“myapp”，那么在这个目录中的项目文件应该被叫做myapp.pro。

CONFIG变量

配置变量指定了编译器所要使用的选项和所需要被连接的库。配置变量中可以添加任何东西，但只有下面这些选项可以被qmake识别。

下面这些选项控制着使用哪些编译器标志：

• release - 应用程序将以release模式连编。如果“debug”被指定，它将被忽略。

• debug - 应用程序将以debug模式连编。

• warn_on - 编译器会输出尽可能多的警告信息。如果“warn_off”被指定，它将被忽略。

• warn_off - 编译器会输出尽可能少的警告信息。

下面这些选项定义了所要连编的库/应用程序的类型：

• qt - 应用程序是一个Qt应用程序，并且Qt库将会被连接。

• thread - 应用程序是一个多线程应用程序。

• x11 - 应用程序是一个X11应用程序或库。

• windows - 只用于“app”模板：应用程序是一个Windows下的窗口应用程序。

• console - 只用于“app”模板：应用程序是一个Windows下的控制台应用程序。

• dll - 只用于“lib”模板：库是一个共享库（dll）。

• staticlib - 只用于“lib”模板：库是一个静态库。

• plugin - 只用于“lib”模板：库是一个插件，这将会使dll选项生效。

例如，如果你的应用程序使用Qt库，并且你想把它连编为一个可调试的多线程的应用程序，你的项目文件应该会有下面这行：

    CONFIG += qt thread debug

注意，你必须使用“+=”，不要使用“=”，否则qmake就不能正确使用连编Qt的设置了，比如没法获得所编译的Qt库的类型了。

1,用Qt designer创建 BaseClass.ui 文件 和 BaseClass.ui.h （如有必要）。

2,由.ui文件生成相应的 .h 和 .cpp 文件：
uic -o BaseClass.h BaseClass.ui
uic -o BaseClass.cpp -i(-impl) BaseClass.h BaseClass.ui

3,生成子类的 .h 和 .cpp 文件（如有必要）：
uic -o SubClass.h -subdecl SubClassBaseClassBaseClass.ui
uic -o SubClass.cpp -subimpl SubclassSubClass.h BaseClass.ui

4,生成moc文件：
moc -o moc_BaseClass.cpp BaseClass.h
moc -o moc_SubClass.cpp SubClass.h

5,生成项目文件.pro：
qmake -o Project.pro -project
如不指定文件名，则文件名默认为当前目录的名字。

6,生成Makefile
qmake

7,编译链接：make

注：Linux Redhat 9.0, Qt3.3。绿色可根据实际项目自行更改。

参见：
Integrating Qt Designer Files Into Your Project

http://docsrv.caldera.com:8457/en/QtTutorial/chap5_4.html 

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=933964

关键词：QtE ARM9 GUI SBC-2410X

引言

近 年来，由于ARM(Advanced RISC Machines)在性能、功耗、成本和体积上的优势，使得它在嵌入式系统中的发展如日中天，它在工业控制、航空航天、军事领域、消费电子、智能家电和视 频监控等方面都发挥了重大的作用。很多人都迫切地想学习ARM，以笔者的经验，从最基本的LED控制学起，是一个不错的选择。

如 果不熟悉Linux，可能对QtE的概念知之甚少，它是挪威Trolltech公司为各种系统设计的图形用户界面工具包，采用c++语言编程。QtE的优 点有：跨平台，可以方便的连接数据库，可以将程序与Java集成等。其实，QtE在一些高端的移动手持设备中早已深入人心，Troll—tech公司在 QtE的基础上开发了一个应用环境Qtopia，目前已有很多公司采用Qtopia来开发他们的主流PDA。当然，Qt也有它的缺点，既不能提供IDE (集成开发环境)，但这个缺点在强大的Linux下显得微不足道。使用gcc／g++，加上Qt的开发工具：Qt Designer，tmake／qmake，UIC等，开发可视化程序将变得十分容易。

要学习ARM，选择一款好的开发板是必不 可少的。SBC一2410X是广州友善之臂公司设计的一款基于ARM9的开发板，操作系统是韩国的mizi-linux。SBC-2410X不同于 uClinux，它的接口丰富，且支持MMU、QtE2．3．7，同时提供了控制LED的命令行方式。

1 系统需求

◇完全安装RedHat9．0。
◇在Linux下建立QtE编译环境。
◇开发板上已经加载LED设备驱动程序。

注意：你所建立的QtE版本必须与开发板所支持的版本一致。

2 程序设计

在Linux 下，用系统自带的Qt Designer来编写程序。Qt Designer是一个优秀的可视化开发工具，用它来设计十分容易。它的界面类似于Delphi，但使用C++语言编写应用程序。Qt程序设计里的一个亮 点就是SignaI-_Slot机制，它有点类似于VC++里的消息机制。当一个组件发出Signal时，其他一个组件或多个组件可以通过Slot接收发 来的SignaI，组件本身也可以接收自己的Signal，这样处理一个事件将变得非常容易。Qt Designer的优点不仅在于它可以十分方便的设计图形用户界面，还表现在可以用连接工具很容易的把Signals和Slots连接起来。用户自己设计 的程序添加在**．ui．h中。

打开Qt Deslgner，选择File／new C++Project，命名为led．pro并保存。接着选择File／new-Dialog，并在此设计自己的用户界面。最后选择File／new C++Main—File，系统自动生成一个main．cpp文件。图形用户界面如图1所示，Initlalize按钮主要完成LED设备的打开，定时器 的关闭和其他一些初始化工作；Begim按钮则针对LED Display Mode的开始；Exit按钮为退出应用程序。左面的组合框包括4个RadioButton，对应4个LED的亮或灭；右面的组合框包括6个 RadioButton(对应不同的闪烁模式和闪烁快慢)和1个LCDNumber(用来显示闪烁的时间间隔)。本程序建立的Signal—S1ot连接 有许多，下面对几个重要的连接和函数进行说明。

(1)connect(initPushButton．SIGNAL(clicked())，this．SLOT(initial()))

当Initialize 按钮按下时，LedForm对话框接收此信号，并执行initial()函数。Linux操作系统把所有的设备都看成文件，因此对设备的操作控制可以通过 open()、ioctl()等函数实现。在initial()函数中就是调用了open()函数来打开LED设备的。

(2)connect(okPushButton，SIGNAL(clicked())，this，SLOT(modeSel()))

当Begin 按钮按下时，LedForm对话框接收此信号，并执行modeSel()函数。在modeSel()函数中开启定时器，并创建另外一个连接用来循环显示 LED。在命令行方式中，LED的循环显示要用到死循环，并用键盘中断来控制循环；而在Qt或其他可视化语言中，则要用到定时器来控制循环。

(3)函数open()

在中声明，含义为打开设备文件。打开成功返回0；失败返回一1。

(4)函数ioctl()

在中声明，控制I／O端口。例如：
Int fd=open(”／dev／leds”，0)；
ioctl(fd，0，3)； ／／让LED4灭

(5)函数select()

在中声明，含义为经过多长时间访问一次设备。

3 程序移植与运行

要想使程序运行在开发板的Qtopia中，则必须在建立的QtE环境下编译，并设置好环境变量。终端进入所建立的QtE目录后，环境变量或运行环境变量和脚本设置如下：

export QTDIR=$PWD／qt
export QPEDlR=$PWD／qtopia
export TMAKEDIR=$PWD／tmake
export TMAKEPATH=$TMAKEDIR／lib／qws／linux-armg++
export PATH=$QTDIR／bin：$QPEDIR／bin：$TMAKEDIR／
bin：$PATH

值得注意的一点是：用Linux自带的Qt Designer创建的工程文件只适用于qmake，而笔者建立的QtE环境只能用tmake来生成makefile，因此需要修改led．pro文件，让它适用于tmake，修改如下：

TEMPLATE =app
CoNFIG +=qtopia warn_on release
SoURCES +=main．epp
INTERFACES =led．ui
TARGET =led

以上的工作做完后，就可以编译了。编译成功后生成可执行的二进制文件led，然而要使程序运行在开发板上的qtopia桌面上，还需要一个桌面文件led．desktop和自定义的一个图标led．png。桌面文件如下：

[Desktop Entry]
Comment=a LED Control Program
Exee=led
Icon=led
Type=Application
Name=LED Control

然 后，把led复制到SBC-2410X下／opt／qtopia／bin目录下，led．png复制到／opt／qtopia／pics目录下，led． desktop复制到／0pt／qtopia／apps／Applications目录下。最后，用ehmod a+X led改变文件led的权限，重新启动系统，便可看到led．png的图标显示在qtopia桌面上，点击此图标就可运行程序了。

4 部分源程序及注释

由于源程序代码比较长，这里就不全部列出了，仅给出重要部分的代码及注释，以供读者参考。

(1) 程序的初始化
int fd： ／／LED设备文件句柄
int type=1； ／／默认方式为计数器
double period=0．2； ／／默认时间间隔
QTimer*t=new QTimer(Q″timer″)；／／创建定时器
void LedForm：：initial(){
fd=open(″／dev／leds″，0)； ／／打开LED设备
／／其他一些初始化语句
一>stop()； ／／关闭定时器
～

(2) LED显示方式的设置
void LedForm：：push-leds(void){
static unsigned step；
unsigned led—bitmap；
inti；
switch(type){
case 0： ／／方式0：跑马灯
if(step>=14){step=0；}
if(step<7){led_bitmap=1<else{led_bitmap=1<<(14一step)；}
break；
case 1： ／／方式1：计数器
if(step>255){step=0；)
Ied_bitmap=step!
break；
case 2： ／／方式2：停止
led_bitmap=0：
break;
step十十;
for(i=0；i<8；l++){
ioctl(fd，led_bitmap＆1，i)；
led_bitmap>>=1；
}
}

(3) LED设备的读取及调用LED显示程序
void LedForm：：ledDisplay(){
fd_set rds；
struct timeval step；
FD_ZERO(&rds)；
step．tv_sec=period；
step．tv_usec=(pefiod—step．W_sec)*1000000L；
select(fd，&rds，NULL，NULL，&step)；
push_leds()；
}

(4)循环显示的实现
void LedForm：：modeSel(){
t-->start(O)；／／启动定时器，并立即发出Signal- timeout()
connect(t，SIGNAL(timeout())，this．SLOT(1edDisplay()))；
}

结 语

随 着通信行业的迅猛发展，移动手持设备必将成为人们工作、学习和生活的主流，用Qt设计移动手持设备的GUI有着得天独厚的优势。目前，Qt应用于全世界上 百个软件开发项目中。在我国，Qt的发展也有星星之火可以燎原之势。本文通过一个最基础的小程序向读者演示了怎样使用Qt开发应用程序，以及怎样建立Qt 与ARM的联系，希望对读者学习ARM和Qt起到一定的帮助作用。

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<pthread.h>
 
pthread_key_t key;
 
void echomsg(int t)
{
 printf("destructor excuted in thread %d,param=%d\n",pthread_self(),t);   
 
}

void child()
{
 int tid;
 
 tid = pthread_self(); 
   printf("thread %d enter\n",tid);
 sleep(1);
   pthread_setspecific(key,(void *)tid);
   printf("thread %d returns %d\n",tid,pthread_getspecific(key));
 sleep(1);
}

int main(int argc,char** argv)
{
  int * status;
  int gc;
  char command[64]="./clu";
  char comarg[64]="";
  argv[1]=comarg;
  while(1)
    {
      if((gc=getchar())=='g')
 {
   if(fork()==0)
     {
       if(execve(command,argv,0)==-1)
  {
    printf("process error is %s\n",strerror(errno));
  }
       printf("process is ok\n");
     }
 }
      if(gc=='k')
 {
   printf("to be continue\n");
 }
      if(gc=='e')
 {
   return 1;
 }
    }
 }

功能是这样的，启动以后会从键盘接受字符，如果是g就运行预先指定好的程序（在这里是一个叫clu的程序），如果是k就打印to be continue，如果是e就退出
下面是这个叫clu的程序的代码
#include <stdio.h>
#include <time.h>

int main()
{
  long begin=0;
  long end=24000;
  long finish=0;
  long loop1,loop2;
  time_t flag;
  time_t nowtime1,nowtime2;
  if((flag=time(&nowtime1))==-1)exit(1);
  for(loop1=begin;loop1<end;loop1++)
    {
      for(loop2=begin;loop2<end;loop2++)
 {
   if((loop1%2)==0)
     {
       if((loop2%2)==0)
  {
    if(finish>65535)
      finish=0;
    finish+=((loop1/2+loop2/2)%2)%2;
  }
     }
 }
    }
  if((flag=time(&nowtime2))==-1)exit(1);
  printf("%ld\n",finish);
  printf("proccess time %ldsec\n",nowtime2-nowtime1);
}
这个程序本身没有任何意义，只是纯粹的延误一下时间，输出一下运行的时间，便于测试，在我的AMD2500+上，大概是5秒，你可以试试哦^_^

要测试这个程序，可以在程序运行时输入g，但是这个计算不会马上结束，在屏幕还没有输出的时候再输入k，就会先输出k的内容，后台clu的结果出来后才输出到屏幕，也就是clu在后台运行了

……
/* Type of a signal handler.   */
typedef void (*__sighandler_t)(int);

……
#ifdef __KERNEL__
struct old_sigaction {
          __sighandler_t sa_handler;
         old_sigset_t sa_mask;
         unsigned long sa_flags;
         void (*sa_restorer)(void);
};

struct sigaction {
         __sighandler_t sa_handler;
        unsigned long sa_flags;
        void (*sa_restorer)(void);
        sigset_t sa_mask;   /* mask last for extensibility */
};

struct k_sigaction {
        struct sigaction sa;
};

#else
/* Here we must cater to libcs that poke about in kernel headers.   */

struct sigaction {
          union {
                  __sighandler_t _sa_handler;
                  void (*_sa_sigaction)(int, struct siginfo *, void *);
          } _u;
          sigset_t sa_mask;
          unsigned long sa_flags;
          void (*sa_restorer)(void);
};

#define sa_handler   _u._sa_handler
#define sa_sigaction _u._sa_sigaction

#endif /* __KERNEL__ */

sa_handler的原型是一个参数为int，返回类型为void的函数指针。参数即为信号值，所以信号不能传递除信号值之外的任何信息;

sa_sigaction的原型是一个带三个参数，类型分别为int，struct siginfo *，void *,返回类型为void的函数指针。第一个参数为信号值;第二个参数是一个指向struct siginfo结构的指针，此结构中包含信号携带的数据值;第三个参数没有使用。

sa_mask指定在信号处理程序执行过程中，哪些信号应当被阻塞。默认当前信号本身被阻塞。

sa_flags包含了许多标志位，比较重要的一个是SA_SIGINFO，当设定了该标志位时，表示信号附带的参数可以传递到信号处理函数中。即 使sa_sigaction指定信号处理函数，如果不设置SA_SIGINFO，信号处理函数同样不能得到信号传递过来的数据，在信号处理函数中对这些信 息的访问都将导致段错误。

sa_restorer已过时，POSIX不支持它，不应再使用。

        因此，当你的信号需要接收附加信息的时候，你必须给sa_sigaction赋信号处理函数指针，同时还要给sa_flags赋SA_SIGINFO,类似下面的代码：
     #include <signal.h>
     ……
     void sig_handler_with_arg(int sig,siginfo_t *sig_info,void *unused){……}
    
     int main(int argc,char **argv)
     {
              struct sigaction sig_act;
              ……
              sigemptyset(&sig_act.sa_mask);
              sig_act.sa_sigaction=sig_handler_with_arg;
              sig_act.sa_flags=SA_SIGINFO;
  
               ……
     }
        如果你的应用程序只需要接收信号，而不需要接收额外信息，那你需要的设置的是sa_handler,而不是sa_sigaction,你的程序可能类似下面的代码：
     #include <signal.h>
     ……
     void sig_handler(int sig){……}
    
     int main(int argc,char **argv)
     {
              struct sigaction sig_act;
              ……
              sigemptyset(&sig_act.sa_mask);
              sig_act.sa_handler=sig_handler;
              sig_act.sa_flags=0;
  
               ……
      }

      如果需要更详细说明，请参阅sigaction的man手册。

void signal_rec(int signum, siginfo_t *info, void *myop)
{
 printf("receive signal %d\n", signum);
 sleep(5); 
}

int main(int argc,char **argv)
{
 struct sigaction act;
 int sig,i;
 
 sigemptyset(&act.sa_mask);
 act.sa_flags = SA_SIGINFO;
 act.sa_sigaction = signal_rec;
 
 for(i=1; i<argc; i++){ //argv[0]为调用程序名
  sig = atoi(argv[i]);
  if(sigaction(sig, &act, NULL) <0){
   printf("install signal error\n");
  } 
 }
 
 while(1){
  sleep(2);
  printf("wait for the signal\n");
 }
}
用法：
将文件保存为test.c，执行make test，编译生成test文件。
./test 36 39&
命令的意思是注册信号36,39。命令结果会返回pid，假设为2625。
通过另外一个终端向2625进程发送信号。例如:kill -s 36 2625
则我们可以看到signal_rec函数被执行了。
当我们发送40信号，我们会发送程序终止了，这是因为对于实时信号，默认的操作是终止。
关于信号：
 Linux 支持的信号分为可靠信号和不可靠信号。此处的可靠与不可靠不是指系统是不是可靠的可靠，而是对于可靠信息来说，每一次信号发实都每被加到信号链中，所以是 可靠的；而对于不可靠信号来说，如果进程之前已经接收到该信号，则不会被加到信号链中，因此对于此次发送的信号来说，对于该进程来说是不知道的，所就是说 信号丢失了，因此是不可靠的。
 不可靠信号主要是在早期信号机制上的信号。一般来说，信号值小于SIGRTMIN的信号为不可靠信号，不可靠信号又称为非实时信号。可靠信号又称为实时信号。实时信号是SIGRTMIN和SIGRTMAX间的所有信号。
 我们可以通过kill -l查看SIGRTMIN和SIGRTMAX的值。在Debian系统和Redhat上面，一般SIGRTMIN=33,SIGRTMAX=64。
 Linux既支持新的信号安装函数sigation以及信号发送函数sigqueue，又支持早期的signal信号安装函数和kill信号发送函数。
 信号的可靠与不可靠只与信号值有关，与信号的发送和安装函数无关，也就是说在Linux下即使使用sigaction和sigqueue也不可能将不可靠信号变为可靠信号。
信号发送函数主要有以下几个：kill,raise,sigqueue,alarm,settimer,abort。
信号安装函数主要有signal和sigaction。sigaction主要用于与sigqueue系统调用配合使用，主要用于实时信号处理。
信号集操作主要有以下几个函数：sigemptyset,sigfillset,sigaddset,sigdelset,sigismember。
信号的阻塞的未决主要有以下几个函数：sigprocmask,sigsuspend,sigpending。
最后以一个读串口设备时用到的信号处理作为结尾(在上次的初始化串口设备中已经出现过)：
在读取设备数据或者进行网络应用的时候，为了防止程序进入死锁，我们需要设置超时操作，即比如我们读串口设备，尝试一定时间后仍然没有响应，则可能设备没有正常工作。那么在超时以后我们需要退出，否则程序就锁住了。
我们现在使用SIGALRM信号来进行这个处理(这种方式并不是最好的办法)：
我们假设有一个标记是否超时的全局变量caught_alrm，默认为0，为1时则表示超时。
static volatile sig_atomic_t caught_alrm;
static void sig_alrm(int signo){//信号处理函数，设置超时全局变量为1。
        caught_alrm = 1;
        return;
}
int a_function{
 ……
    if(signal(SIGALRM, sig_alrm) == SIG_ERR){
     syslog(LOG_ERR,"signal error in function:%s",__FUNCTION__);
        return -1;
    }
    caught_alrm = 0;
    alarm(expalarm);
    do{
     //do something
     //if the work is finished,call alarm(0) to clean the timer.
    }while(caught_alrm == 0);
}
注：
1、本文为整理以前的工作笔记，如果您要转载，请注意来源为尔雅，作者覃士国。如果您有任何问题欢迎交流：shiguo.qin@gmail.com
2、 此文仅仅是一则笔记，如果您正在寻找关于Linux信号编程方面的资料，可以参考郑彦兴的一篇文章:http://www- 128.ibm.com/developerworks/cn/linux/l-ipc/part2/index1.html。此文详细描述了很多关于信 号处理中的结构等内容，是学习信号编程的一篇不错的教程式文章。

wait的函数原型是：
　　
　　#include /* 提供类型pid_t的定义 */
　　#include
　　 pid_t wait(int *status)
　　
　　进程一旦调用了wait，就立即阻塞自己，由wait自动分析是否当前进程的某个子进程已经退出，如果让它找到了这样一个已经变成僵尸的子进程， wait就会收集这个子进程的信息，并把它彻底销毁后返回；如果没有找到这样一个子进程，wait就会一直阻塞在这里，直到有一个出现为止。
　　
　　参数status用来保存被收集进程退出时的一些状态，它是一个指向int类型的指针。但如果我们对这个子进程是如何死掉的毫不在意，只想把这个僵尸进程消灭掉，（事实上绝大多数情况下，我们都会这样想），我们就可以设定这个参数为NULL，就象下面这样：
　　
　　pid = wait(NULL);
　　
　　如果成功，wait会返回被收集的子进程的进程ID，如果调用进程没有子进程，调用就会失败，此时wait返回-1，同时errno被置为ECHILD。
　

waitpid的函数原型是：

　　简介
　　waitpid系统调用在Linux函数库中的原型是：
　　
　　#include /* 提供类型pid_t的定义 */
　　#include
　　pid_t waitpid(pid_t pid,int *status,int options)

从本质上讲，系统调用waitpid和wait的作用是完全相同的，但waitpid多出了两个可由用户控制的参数pid和options，从而为我们编程提供了另一种更灵活的方式。下面我们就来详细介绍一下这两个参数：
　　
　　● pid
　　
　　从参数的名字pid和类型pid_t中就可以看出，这里需要的是一个进程ID。但当pid取不同的值时，在这里有不同的意义。
　　
　　pid>0时，只等待进程ID等于pid的子进程，不管其它已经有多少子进程运行结束退出了，只要指定的子进程还没有结束，waitpid就会一直等下去。
　　
　　pid=-1时，等待任何一个子进程退出，没有任何限制，此时waitpid和wait的作用一模一样。
　　
　　pid=0时，等待同一个进程组中的任何子进程，如果子进程已经加入了别的进程组，waitpid不会对它做任何理睬。
　　
　　pid<-1时，等待一个指定进程组中的任何子进程，这个进程组的ID等于pid的绝对值。

　　● options

　　options提供了一些额外的选项来控制waitpid，目前在Linux中只支持WNOHANG和WUNTRACED两个选项，这是两个常数，可以用"|"运算符把它们连接起来使用，比如：

　　ret=waitpid(-1,NULL,WNOHANG | WUNTRACED);

　　如果我们不想使用它们，也可以把options设为0，如：

　　ret=waitpid(-1,NULL,0);
　　
　　如果使用了WNOHANG参数调用waitpid，即使没有子进程退出，它也会立即返回，不会像wait那样永远等下去。
　　
　　而WUNTRACED参数，由于涉及到一些跟踪调试方面的知识，加之极少用到，这里就不多费笔墨了，有兴趣的读者可以自行查阅相关材料。
　　
　　看到这里，聪明的读者可能已经看出端倪了--wait不就是经过包装的waitpid吗？没错，察看<内核源码目录>/include/unistd.h文件349-352行就会发现以下程序段：
　　
　　static inline pid_t wait(int * wait_stat)
　　{
　　 return waitpid(-1,wait_stat,0);
　　}
　　

　　返回值和错误
　　
　　waitpid的返回值比wait稍微复杂一些，一共有3种情况：
　　
　　● 当正常返回的时候，waitpid返回收集到的子进程的进程ID；
　　
　　● 如果设置了选项WNOHANG，而调用中waitpid发现没有已退出的子进程可收集，则返回0；
　　
　　● 如果调用中出错，则返回-1，这时errno会被设置成相应的值以指示错误所在；
　　
　　当pid所指示的子进程不存在，或此进程存在，但不是调用进程的子进程，waitpid就会出错返回，这时errno被设置为ECHILD

其它：

调用 wait＆waitpid 来处理终止的子进程：

pid_t wait(int* statloc);
pid_t waitpid(pid_t pid, int*statloc, int options);

两个函数都返回两个值：函数的返回值和终止的子进程ID，而子进程终止的状态则是通过statloc指针返回的。

     wait＆waitpid 的区别是显而易见的，wait等待第一个终止的子进程，而waitpid则可以指定等待特定的子进程。这样的区别可能会在下面这种情况时表现得更加明显：
         当同时有5个客户连上服务器，也就是说有五个子进程分别对应了5个客户，此时，五个客户几乎在同时请求终止，这样一来，几乎同时，五个FIN发向服务器， 同样的，五个SIGCHLD信号到达服务器，然而，UNIX的信号往往是不会排队的，显然这样一来，信号处理函数将只会执行一次，残留剩余四个子进程作为 僵尸进程驻留在内核空间。此时，正确的解决办法是利用waitpid(-1, &stat, WNOHANG)防止留下僵尸进程。其中的pid为－1表明等待第一个终止的子进程，而WNOHANG选择项通知内核在没有已终止进程项时不要阻塞。

wait＆waitpid 区别

       waitpid提供了wait函数不能实现的3个功能:

• waitpid等待特定的子进程, 而wait则返回任一终止状态的子进程;
• waitpid提供了一个wait的非阻塞版本;
• waitpid支持作业控制(以WUNTRACED选项).

这两个函数返回的子进程状态都保存在statloc指针中, 用以下3个宏可以检查该状态:

• WIFEXITED(status): 若为正常终止, 则为真. 此时可执行

• WEXITSTATUS(status): 取子进程传送给exit或_exit参数的低8位.

• WIFSIGNALED(status): 若为异常终止, 则为真. 此时可执行

• WTERMSIG(status):   取使子进程终止的信号编号.

• WIFSTOPPED(status): 若为当前暂停子进程, 则为真. 此时可执行

    if(fork()>0) /* 如果是父进程 */

       wait(NULL);    /* 收集僵尸进程 */
}

    大家看完代码后，就会觉得这个代码正是我刚才讲的进程一生是怎么样的，进程死后，一定要为他收尸，否则他就会编程僵尸进程。下面就让我们来看看未能把死去的进程收尸会变成什么样子？

/**********************************僵尸进程******zombie.c*****************************************************/

#include <sys/types.h>
#include <unistd.h>
main()
{

       fork(); /*开始创建一个子进程*/

    if(fork>0) /* 如果是父进程 */

       sleep(30);    /* 休眠30秒，这段时间里，父进程什么也干不了 */
       wait(NULL);    /* 收起僵尸进程 */

   /*因为父进程死了，子进程也得一起陪葬，那么我们就让父进程睡眠30秒，在这30秒内我们就可以看到僵尸进程。
     30秒过后，父进程醒来后就得死，所以到那时子进程也就死去。*/
}

/********************************************************************************************/

    为了让大家更清楚的看到僵尸进程我们把这个僵尸进程代码编译，然后执行，
#gcc -o zombie zombie.c

编译成功后我们开始执行这个程序因为代码里的sleep(30)是让父进程睡眠30秒，如果我们在前台执行我们这个程序，那么就不能执行其他shell命令了，所以这里我们在执行的命令后面加一个& 代表后台运行的意思。
#./zomber &

好了，我们在30秒内执行查看进程命令来看看我们这个zombie进程是什么样的？
#ps -aux |grep zombie

这个命令是显示有关zombie的所有信息。具体操作请看图（2）。

    看到这里后，聪明的朋友会问，既然子进程是由父进程创造出来的，那么如果一个父程序执行完退出后，子进程不管是不是僵尸进程也直接就退出了，因为父进程死 了嘛。那么这也不会造成多大危害啊？如果大家这么认为那可就错了，当我们刚才用ps命令观察进程的执行状态时，看到某些进程的状态栏为defunct，这 就是所谓的“僵尸”进程。“僵尸”进程是一个早已死亡的进程，但在进程表（processs table）中仍占了一个位置（slot）。由于进程表的容量是有限的，所以，defunct进程不仅占用系统的内存资源，影响系统的性能，而且如果其数 目太多，还会导致系统瘫痪，具体请看下面的代码：
/***********************************无限创建子进程********************************************/

#include <sys/types.h>
#include <unistd.h>
main()
{
       for (;;)  /*制作一个死循环*/
      
         fork(); /*开始创建一个子进程*/

}

/********************************************************************************************/

懂C语言的朋友会知道for(;;)是一个死循环。那么这仅有2行代码的程序就可以把你的linux瞬间死机，因为他的作用是无限制的在内存里增加新的子进程，一个系统根据内存的容量会分配进程的最大限制，一旦同时运行的进程数超符合，那么你的机器必然会死机。
   我这里分别用了2个用户进行测试过，一个是普通权限的用户，一个是Root用户，测试结果是“任何用户只要执行这个程序都会让机器死掉”。原因就是默认的 Linux系统没有对普通用户的使用最大进程进行限制。所以这样对系统造成很大一个威胁，那么我们如何避免普通用户非法执行过多资源或进程导致系统拖死， 所以我们的给除了Root的用户做一下限制。

对普通用户进行限制：

第1步：首先进到Linux终端用vi编辑/etc/security /limits.conf文件，在里面加入：

　　* hard core 0
　　* hard rss 5000
　　* hard nproc 20
 
  这里的* 代表除了Root的所有用户，(* hard core 0) 是禁止core files“core 0”，(* hard rss 5000) 是限制内存使用为5MB“rss  5000”, (* hard nproc 20 )是限制进程数为“nproc 50“。大家可以根据自己系统内存大小进行合理配置。

第2步：用vi编辑/etc/pam.d/login文件，然后加上下面这行保存退出就可以。

　　session required /lib/security/pam_limits.so

    好了，现在我们已经对普通用户限制了进程和内存使用极限，修改完配置以后大家可以用Root和普通用户分别进行测试，结果当然是普通用户执行完我们刚才做的程序不会死机了。

    一个系统的安全性不取决与打不打补丁，虽然打补丁很重要，但是对系统做出相应的配置也是相当重要的。

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

在fork ()/execve()过程中，假设子进程结束时父进程仍存在，而父进程fork()之前既没安装SIGCHLD信号处理函数调用waitpid()等待 子进程结束，又没有显式忽略该信号，则子进程成为僵尸进程，无法正常结束，此时即使是root身份kill -9也不能杀死僵尸进程。补救办法是杀死僵尸进程的父进程(僵尸进程的父进程必然存在)，僵尸进程成为"孤儿进程"，过继给1号进程init，init始 终会负责清理僵尸进程。  

===========================================
在Linux中可以用
ps auwx  
发现僵尸进程

a all w/ tty, including other users 所有窗口和终端，包括其他用户的进程
u user-oriented 面向用户(用户友好)
-w,w wide output 宽格式输出
x processes w/o controlling ttys  

在僵尸进程后面 会标注




ps axf  
看进程树，以树形方式现实进程列表


ps axm  
会把线程列出来,在linux下进程和线程是统一的，是轻量级进程的两种方式。

ps axu  
显示进程的详细状态
===========================================
killall
kill -15
kill -9
一般都不能杀掉 defunct进程
用了kill -15,kill -9以后 之后反而会多出更多的僵尸进程

kill -kill pid
fuser -k pid  


可以考虑杀死他的parent process，
kill -9 他的parent process
===========================================
一个已经终止,但是其父进程尚未对其进行善后处理（获取终止子进程的有关信息、释放它仍占用的资源）的进程被称为僵死进程(Zombie Process)。

避免zombie的方法：
1)在SVR4中，如果调用signal或sigset将SIGCHLD的配置设置为忽略,则不会产生僵死子进程。另外,使用SVR4版的sigaction,则可设置SA_NOCLDWAIT标志以避免子进程僵死。

Linux中也可使用这个，在一个程序的开始调用这个函数

signal(SIGCHLD,SIG_IGN);  
  




2)调用fork两次。程序8 - 5 实现了这一点。
3)用waitpid等待子进程返回.  

===========================================

zombie进程是僵死进程。防止它的办法，一是用wait,waitpid之类的函数获得

进程的终止状态，以释放资源。另一个是fork两次  
===========================================
defunct进程只是在process table里还有一个记录，其他的资源没有占用，除非你的系统的process个数的限制已经快超过了，zombie进程不会有更多的坏处。
可能唯一的方法就是reboot系统可以消除zombie进程。
===========================================


任何程序都有僵尸状态，它占用一点内存资源(也就是进程表里还有一个记录)，仅仅是表象而已不必害怕。如果程序有问题有机会遇见，解决大批量僵尸简单有效的办法是重起。kill是无任何效果的


fork与zombie/defunct"

在Unix 下的一些进程的运作方式。当一个进程死亡时,它并不是完全的消失了。进程终止,它不再运行,但是还有一些残留的小东西等待父进程收回。这些残留的东西包括 子进程的返回值和其他的一些东西。当父进程 fork() 一个子进程后,它必须用 wait() 或者 waitpid() 等待子进程退出。正是这个 wait() 动作来让子进程的残留物消失。

自然的，在上述规则之外有个例外:父进程可以忽略 SIGCLD 软中断而不必要 wait()。可以这样做到(在支持它的系统上,比如Linux):

main()
{
signal(SIGCLD, SIG_IGN); /* now I don't have to wait()! */
.
.
fork();
fork();
fork(); /* Rabbits, rabbits, rabbits! */

｝

现在，子进程死亡时父进程没有 wait()，通常用 ps 可以看到它被显示为“”。它将永远保持这样 直到 父进程 wait()，或者按以下方法处理。

这 里是你必须知道的另一个规则:当父进程在它wait()子进程之前死亡了(假定它没有忽略 SIGCLD),子进程将把 init(pid 1)进程作为它的父进程。如果子进程工作得很好并能够控制，这并不是问题。但如果子进程已经是 defunct，我们就有了一点小麻烦。看，原先的父进程不可能再 wait()，因为它已经消亡了。这样，init 怎么知道 wait() 这些 zombie 进程。

答案：不可预料的。在一些系统上，init周期性的破坏掉它所有的defunct进程。在另外一些系统中,它干 脆拒绝成为任何defunct进程的父进程，而是马上毁灭它们。如果你使用上述系统的一种,可以写一个简单的循环，用属于init的defunct进程填 满进程表。这大概不会令你的系统管理员很高兴吧?

你的任务：确定你的父进程不要忽略 SIGCLD，也不要 wait() 它 fork() 的所有进程。不过，你也未必 要 总是这样做（比如，你要起一个 daemon 或是别的什么东西）,但是你必须小心编程，如果你是一个 fork() 的新手。另外，也不要在心理上有任何束缚。

总结：
子进程成为 defunct 直到父进程 wait()，除非父进程忽略了 SIGCLD 。
更进一步，父进程没有 wait() 就消亡（仍假设父进程没有忽略 SIGCLD ）的子进程（活动的或者 defunct）成为 init 的子进程，init 用重手法处理它们。

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝