如何让 linux 程序自启动

本文转自 http://oss.org.cn/ossdocs/gnu/linux1/tutorial4.html 

           && http://hi.baidu.com/zhxust/item/4a3455803da082ceee083d22 

           && http://baike.baidu.com/view/6235780.htm 

           && http://blog.csdn.net/dodolzg/article/details/6148974

           && http://blog.csdn.net/lanmanck/article/details/4568911

          windows下我们可以通过书写服务程序或把程序加入启动项来实现程序的自启动。linux下大致上也是如此，大致的步骤是：

          1. 实现一个daemon程序

          2.把此程序加入启动配置

1. daemon程序的书写

1.1 fork程序

        linux操作系统下通常处理并行的方法通常是多进程与多线程。由于linux下进程开销比windows下要小很多，一般情况下使用多进程方式。

        生成多个进程方法就是使用fork()函数。通常情况下，fork()及signal经常运用在daemon守护神这一类常驻程序，另外像a4c.tty/yact/chdrv这些中文终端机程序也有用到，一般如Mozilla/Apache/Squid等大程序几乎都一定会用到。  

       而对于多线程，虽然在linux下的程序写作，对thread的功能需求并非很大，但thread在现代的作业系统中，几乎都已经存在了。pthread是Linux上的thread函数库，如果您要在Linux下撰写多线程序，例如MP3播放程序，熟悉pthread的用法是必要的。 
       pthread及signal都可以用一大章来讨论。在这里，我只谈及最简单及常用的技巧，当您熟悉这些基本技巧的运用後，再找一些专门深入探讨pthread及signal程序写作的书籍来研究。这些进阶的写法，用到的机会较少，将层次分明，学习速度应该会比较快。  

1.1.1程序分歧fork() 
       fork()会产生一个与父程序相同的子程序，唯一不同之处在於其process id(pid)。  fork是编写daemon程序的第一步。
       如果我们要撰写守护神程序，或是例如网路伺服器，需要多个行程来同时提供多个连线，可以利用fork()来产生多个相同的行程。  

       函数宣告 

  pid_t fork(void);      pid_t vfork(void);  

       返回值:   
              -1 : 失败。  
              0  : 子程序。  
              >0 : 将子程序的process id传回给父程序。  

       在Linux下fork()及vfork()是相同的东西。  

       范例一: fork.c 
       在这个范例中，我们示范fork()的标准用法。  

#include <stdio.h>   #include <stdlib.h>  #include <unistd.h>   int main(void)    {         pid_t pid;           printf("hello\n");          pid = fork();         switch (pid)        {                  case -1:                      printf("failure!\n");               break;                case  0:                      printf("I am child!\n");               break;                default:                      printf("my child is %d\n",pid);               break;        }            for (;;)        {               /* do something here */        }         return 0;}  

       编译:  

gcc -o ex1 fork.c  

       执行:  

./ex1 &

       执行结果: 

hello    my child is 8650    I am child!  

       我们可以见到，使用fork()，可将一个程序分岐成两个。在分歧之前的程序码只执行一次。  
       检验行程: 

ps | grep ex1   8649  p0 R    0:40 ./ex1  8650  p0 R    0:40 ./ex1  

       8649是父程序的pid，8650则为子程序的pid。您会需要用到"kill all ex1"来杀掉两个行程。  

1.2 daemon程序

       范例二: daemon.c  
       Daemon程序是一直运行的服务端程序，又称为守护进程。通常在系统后台运行，没有控制终端不与前台交互，Daemon程序一般作为系统服务使用。Daemon是长时间运行的进程，通常在系统启动后就运行，在系统关闭时才结束。一般说Daemon程序在后台运行，是因为它没有控制终端，无法和前台的用户交互。Daemon程序一般都作为服务程序使用，等待客户端程序与它通信。我们也把运行的Daemon程序称作守护进程。
       在UNIX中，我们一般都利用fork()，来实作所谓的"守护神程序"，也就是DOS中所谓的"常驻程序"。一般的技巧是将父程序结束，而子程序便成为"守护神"。
       这个范例中，示范一般标准的daemon写法。  

#include <stdio.h>     #include <stdlib.h>    #include <unistd.h>    int main(void)  {         pid_t pid;           pid = fork();           if (pid>0)        {                printf("daemon on duty!\n");                   exit(0);            }       else if (pid<0)       {                printf("Can't fork!\n");                exit(-1);         }            for (;;)       {                printf("I am the daemon!\n");                sleep(3);                /* do something your own here */          }    } 

       编译: 

gcc -o ex2 daemon.c  

       执行: 

./ex2  

       执行结果:  

daemon on duty!  I am the daemon!   

       接下来每三秒钟，都会出现一个"I am the daemon!"的讯息，这表示您的程序已经"长驻"在系统中了。  
  
       检验行程:   

ps | grep ex2    8753  p0 S    0:00 ./ex2     

       注意到在范例一中，我们下的指令为"./ex1 &"，而在范例二中为"./ex2"，没有"&"符号。 

       归纳一下，Daemon程序的实现方法:
　　编写Daemon程序有一些基本的规则，以避免不必要的麻烦。
　　1、首先是程序运行后调用fork，并让父进程退出。子进程获得一个新的进程ID，但继承了父进程的进程组ID。
　　2、调用setsid创建一个新的session，使自己成为新session和新进程组的leader，并使进程没有控制终端(tty)。
　　3、改变当前工作目录至根目录，以免影响可加载文件系统。或者也可以改变到某些特定的目录。
　　4、设置文件创建mask为0，避免创建文件时权限的影响。
　　5、关闭不需要的打开文件描述符。因为Daemon程序在后台执行，不需要于终端交互，通常就关闭STDIN、STDOUT和STDERR。其它根据实际情况处理。
　　另一个问题是Daemon程序不能和终端交互，也就无法使用printf方法输出信息了。我们可以使用syslog机制来实现信息的输出，方便程序的调试。在使用syslog前需要首先启动syslogd程序，关于syslogd程序的使用请参考它的man page，或相关文档，我们就不在这里讨论了。

       范例三: daemontest.c  

       这个例子主要看子进程环境的设置。

　　Daemon程序的另外例子：
　　 编译运行环境为Redhat Linux 8.0。
　　新建一个daemontest.c程序，文件内容如下：

#include <unistd.h>#include <sys/types.h>#include <sys/stat.h>#include <stdlib.h>#include <stdio.h>#include <syslog.h>#include <signal.h>int daemon_init(void){　　pid_t pid;　　if((pid = fork()) < 0)　　　　return(-1);　　else if(pid != 0)/* parent exit */　　　　exit(0); 　　/* child continues */　　setsid(); /* become session leader */　　chdir("/");/* change working directory */　　umask(0);/* clear file mode creation mask */　　close(0);/* close stdin */　　close(1);/* close stdout */　　close(2);/* close stderr */　　return(0);}void sig_term(int signo){　　if(signo == SIGTERM)/* catched signal sent by kill(1) command */　　{　　　　syslog(LOG_INFO, "program terminated.");　　　　closelog(); exit(0);　　}}int main(void){ 　　if(daemon_init() == -1)　　{　　　　printf("can't fork self\n"); exit(0); 　　}　　openlog("daemontest", LOG_PID, LOG_USER);　　syslog(LOG_INFO, "program started.");　　signal(SIGTERM, sig_term); /* arrange to catch the signal */　　while(1)　　{ 　　　　sleep(1);  /* put your main program here */ 　　}　　return(0);}

　　使用如下命令编译该程序： 

gcc -Wall -o daemontest daemontest.c

      编译完成后生成名为daemontest的程序，执行

./daemontest

　　使用ps axj 命令可以显示系统中已运行的daemon程序的信息，包括进程ID、session ID、控制终端等内容。
　　部分显示内容：

PPID PID PGID SID TTY TPGID STAT UID TIME COMMAND1098 1101 1101 1074 pts/1 1101 S 0 0:00 -bash 1 1581 777 777 ? -1 S 500 0:13 gedit 1 1650 1650 1650 ? -1 S 500 0:00 ./daemontest 794 1654 1654 794 pts/0 1654 R 500 0:00

　　ps axj 从中可以看到daemontest程序运行的进程号为1650。
　　我们再来看看/var/log/messages文件中的信息： Apr 7 22:00:32 localhost

daemontest[1650]: program started.

　　我们再使用kill 1650命令来杀死这个进程，/var/log/messages文件中就会有如下的信息：

Apr 7 22:11:10 localhost daemontest[1650]: program terminated.

　　使用ps axj命令检查，发现系统中daemontest进程已经没有了。

　　范例三: lock.c  
　　许多的时候，我们希望"守护神"在系统中只有一个，这时候会需要用到pid lock的技巧。如果您注意到/var/run目录中的内容，您会发现到有许多的*.pid档，观看其内容都是一些数字，这些数字其实就是该行程的pid。  
　　可以通过发信号对进程进行控制。下面程序是一个父进程创建一个驻留子进程，我们可以通过发信号来控制这个驻留进程。

#include <stdio.h>#include <stdlib.h>#include <unistd.h>#include <signal.h>#define LOCK_FILE "/var/run/lock.pid"void quit(int signo){　　printf("Receive signal %d\n",signo);　　unlink(LOCK_FILE);　　exit(1);}void main(){　　FILE *fp;　　pid_t pid;　　struct sigaction act;　　if(access(LOCK_FILE,R_OK)==0)　　{　　　　printf("Existing copy of this daemon!\n");　　　　exit(1);　　}　　pid = fork();　　if(pid > 0)　　{　　　　printf("daemon on duty!\n");　　　　fp = fopen(LOCK_FILE,"wt");　　　　fprintf(fp,"%d",pid);　　　　fclose(fp);　　　　exit(0);　　}　　else if(pid < 0)　　{　　　　printf("Can't fork!\n");　　　　exit(-1);　　}　　act.sa_handler = quit;　　act.sa_flags = 0;　　sigemptyset(&act.sa_mask);　　sigaction(SIGTERM,&act,NULL);　　sigaction(SIGHUP,&act,NULL);　　sigaction(SIGINT,&act,NULL);　　sigaction(SIGQUIT,&act,NULL);　　sigaction(SIGUSR1,&act,NULL);　　sigaction(SIGUSR2,&act,NULL);　　for(;;)　　{　　　　printf("I am the daemon!\n");　　　　sleep(3);　　}}

　　运行之后，在另外一个Shell窗口输入命令如下：

#PID=$(cat /var/run/lock.pid)#kill -TERM $PID

　　这样就可以终止驻留进程了。sigaction(SIGTERM,&act,NULL)函数将信号与相应响应程序关联起来，驻留进程接收到信号TERM后，就会调用信号响应程序act.sa_handler，由于前面已经赋值了，act.sa_handler = quit，即响应程序是前面的子函数quit()，这样就构成了信号控制进程的整个过程。从程序中可以看到，也可以发送HUP、INT、QUIT、USR1、USR2等信号。 

1.3 附注 

　　信号的定义 

　　在/usr/include/signum.h中有各种信号的定义  

#define SIGHUP          1       /* Hangup (POSIX).  */    #define SIGINT          2       /* Interrupt (ANSI).  */     #define SIGQUIT         3       /* Quit (POSIX).  */    #define SIGILL          4       /* Illegal instruction (ANSI).  */    #define SIGTRAP         5       /* Trace trap (POSIX).  */    #define SIGABRT         6       /* Abort (ANSI).  */    #define SIGIOT          6       /* IOT trap (4.2 BSD).  */     #define SIGBUS          7       /* BUS error (4.2 BSD).  */     #define SIGFPE          8       /* Floating-point exception (ANSI).  */    #define SIGKILL         9       /* Kill, unblockable (POSIX).  */     #define SIGUSR1         10      /* User-defined signal 1 (POSIX).  */    #define SIGSEGV         11      /* Segmentation violation (ANSI).  */   #define SIGUSR2         12      /* User-defined signal 2 (POSIX).  */   #define SIGPIPE         13      /* Broken pipe (POSIX).  */   #define SIGALRM         14      /* Alarm clock (POSIX).  */    #define SIGTERM         15      /* Termination (ANSI).  */    #define SIGSTKFLT       16      /* ??? */    #define SIGCLD          SIGCHLD /* Same as SIGCHLD (System V).  */    #define SIGCHLD         17      /* Child status has changed (POSIX).  */     #define SIGCONT         18      /* Continue (POSIX).  */  #define SIGSTOP         19      /* Stop, unblockable (POSIX).  */  #define SIGTSTP         20      /* Keyboard stop (POSIX).  */  #define SIGTTIN         21      /* Background read from tty (POSIX). */  #define SIGTTOU         22      /* Background write to tty (POSIX).  */  #define SIGURG          23      /* Urgent condition on socket (4.2 BSD).  */  #define SIGXCPU         24      /* CPU limit exceeded (4.2 BSD).  */  #define SIGXFSZ         25      /* File size limit exceeded (4.2 BSD).  */  #define SIGVTALRM       26      /* Virtual alarm clock (4.2 BSD).  */   #define SIGPROF         27      /* Profiling alarm clock (4.2 BSD). */  #define SIGWINCH        28      /* Window size change (4.3 BSD, Sun). */  #define SIGPOLL         SIGIO   /* Pollable event occurred (System V).  */  #define SIGIO           29      /* I/O now possible (4.2 BSD).  */  #define SIGPWR          30      /* Power failure restart (System V).  */  #define SIGUNUSED       31  

函数宣告: 

Signal Operators           int sigemptyset(sigset_t *set);         int sigfillset(sigset_t *set);         int sigaddset(sigset_t *set, int signum);         int sigdelset(sigset_t *set, int signum);         int sigismember(const sigset_t *set, int signum);    Signal Handling Functions            int sigaction(int signum,  const  struct  sigaction  *act,struct sigaction *oldact);         int  sigprocmask(int  how,  const  sigset_t *set, sigset_t *oldset);         int sigpending(sigset_t *set);         int sigsuspend(const sigset_t *mask);     Structure Signal Action    struct sigaction {         void (*sa_handler)(int);         sigset_t sa_mask;         int sa_flags;        void (*sa_restorer)(void);  }  

linux信号机制之sigaction结构体浅析,signal 函数,信号捕捉 

见 http://blog.csdn.net/lanmanck/article/details/4568911

2. linux添加开机启动项

此处也可以看鸟哥的私房菜: http://linux.vbird.org/linux_basic/0560daemons.php

使用chkconfig命令可以查看在不同启动级别下课自动启动的服务（或是程序），命令格式如下：

chkconfig --list

可能输出如下：

openvpn    0：关闭 1：开启 ...... 6：关闭 （0-6 为启动级别 ; 关闭/开启为相应级别下该服务的自动启动选项）

如果希望对自动启动选项做出改变，命令格式为：

chkconfig --level x name on/offz.B. chkconfig --level 5 openvpn off

以上的命令可以查询系统可提供的服务，如果希望开机时启动某一程序，可采用以下方法：
在~/.bash_profile文件最后一行添加所希望启动的软件名。如：“synergyc 192.168.0.154” 则在开机时自动运行synergyc并与192.168.0.154连接。
以上内容为我个人配置，但是发现了一个问题：FC12在登陆后才完成系统启动，也就是说在进入用户登陆界面的时候synergyc还未能启动。所以，(也许)synergyc不适合被安装在用作无键鼠客户机的linux系统中。
 
在Red Hat Linux中自动运行程序
1．开机启动时自动运行程序
Linux加载后, 它将初始化硬件和设备驱动, 然后运行第一个进程init。init根据配置文件继续引导过程，启动其它进程。通常情况下，修改放置在 /etc/rc或 /etc/rc.d 或 /etc/rc?.d 目录下的脚本文件，可以使init自动启动其它程序。例如：编辑 /etc/rc.d/rc.local 文件，在文件最末加上一行"xinit"或"startx"，可以在开机启动后直接进入X－Window。

2．登录时自动运行程序
用户登录时，bash首先自动执行系统管理员建立的全局登录script ：/etc/profile。然后bash在用户起始目录下按顺序查找三个特殊文件中的一个：/.bash_profile、/.bash_login、 /.profile，但只执行最先找到的一个。
因此，只需根据实际需要在上述文件中加入命令就可以实现用户登录时自动运行某些程序（类似于DOS下的Autoexec.bat）。

3．退出登录时自动运行程序
退出登录时，bash自动执行个人的退出登录脚本/.bash_logout。例如，在/.bash_logout中加入命令"tar －cvzf c.source.tgz ＊.c"，则在每次退出登录时自动执行 "tar" 命令备份 ＊.c 文件。

4．定期自动运行程序
Linux有一个称为crond的守护程序，主要功能是周期性地检查 /var/spool/cron目录下的一组命令文件的内容，并在设定的时间执行这些文件中的命令。用户可以通过crontab 命令来建立、修改、删除这些命令文件。
例如，建立文件crondFile，内容为"00 9 23 Jan ＊ HappyBirthday"，运行"crontab cronFile"命令后，每当元月23日上午9:00系统自动执行"HappyBirthday"的程序（"＊"表示不管当天是星期几）。

5．定时自动运行程序一次
定时执行命令at 与crond 类似（但它只执行一次）：命令在给定的时间执行，但不自动重复。at命令的一般格式为：at [ －f file ] time ，在指定的时间执行file文件中所给出的所有命令。也可直接从键盘输入命令：

＄ at 12:00at>mailto Roger －s ″Have a lunch″ < plan.txtat>Ctr－DJob 1 at 2000－11－09 12:00

2000－11－09 12:00时候自动发一标题为"Have a lunch"，内容为plan.txt文件内容的邮件给Roger。

#!/bin/bashRESTART="........" #里面写相应服务代码START="......."STOP=".........."case "$1" inrestart)$RESTARTecho "......";;start)$STARTecho "......";;STOP)$STOPecho "......";;*)echo "Usage: $0 {restart | start | stop}"exit 1esacexit 1

脚本写完要修改一下权限 chmod u+x test.sh
首先，linux随机启动的服务程序都在/etc/init.d这个文件夹里，里面的文件全部都是脚本文件（脚本程序简单的说就是把要运行的程序写到一个文件里让系统能够按顺序执行，类似windows下的autorun.dat文件），另外在/etc这个文件夹里还有诸如名为rc1.d, rc2.d一直到rc6.d的文件夹，这些都是linux不同的runlevel，我们一般进入的X windows多用户的运行级别是第5级，也就是rc5.d，在这个文件夹下的脚本文件就是运行第5级时要随机启动的服务程序。需要注意的是，在每个rc (1-6).d文件夹下的文件其实都是/etc/init.d文件夹下的文件的一个软连接（类似windows中的快捷方式），也就是说，在 /etc/init.d文件夹下是全部的服务程序，而每个rc(1-6).d只链接它自己启动需要的相应的服务程序！

要启动scim(某一程序)，我们首先要知道scim程序在哪里，用locate命令可以找到，scim在/usr/bin/scim这里，其中usr表示是属于用户的，bin在linux里表示可以执行的程序。这样，我就可以编写一个脚本程序，把它放到/etc/init.d里，然后在rc5.d里做一个相应的软链接就可以了。
这个脚本其实很简单，就两行：

#!/bin/bash/usr/bin/scim

第一行是声明用什么终端运行这个脚本，第二行就是要运行的命令。
还需要注意的一点是，在rc5.d里，每个链接的名字都是以S或者K开头的，S开头的表示是系统启动是要随机启动的，K开头的是不随机启动的。这样，你就可以知道，如果我要哪个服务随机启动，就把它名字第一个字母K改成S就可以了，当然，把S改成K后，这个服务就不能随机启动了。因此，我这个链接还要起名为SXXX，这样系统才能让它随机启动。

添加自启动脚本
首先把自己的脚本放到/etc/init.d中,，然后执行如下指令：

update-rc.d a start 90 2 3 4 5 . stop 90 0 1 6 .

其中a就是你的脚本，注意有两个点。
a脚本范例。

#!/bin/sh# Source function library.if [ -f /etc/init.d/functions ]; then    . /etc/init.d/functionselse    . /lib/lsb/init-functionsfiMOD=/a.kostart() {        echo -n $"insert a kernel module: "        /sbin/insmod $MOD        echo}stop() {        echo -n $"remove a kernel module: "        /sbin/rmmod a -f        echo}[ -f $MOD ] || exit 0# See how we were called.case "$1" in  start)    start        ;;  stop)    stop        ;;  restart|reload)    stop    start    ;;  *)  echo $"Usage: $0 {start|stop|restart|reload}"  

update-rc.d命令，是用来自动的升级System V类型初始化脚本，简单的讲就是，哪些东西是你想要系统在引导初始化的时候运行的，哪些是希望在关机或重启时停止的，可以用它来帮你设置。这些脚本的连接位于/etc/rcn.d/LnName,对应脚本位于/etc/init.d/Script-name.
1、设置指定启动顺序、指定运行级别的启动项：

update-rc.d ＜service＞ start ＜order＞ ＜runlevels＞

2、设置在指定运行级中，按指定顺序停止：

update-rc.d ＜service＞ stop ＜order＞ ＜runlevels＞

3、从所有的运行级别中删除指定的启动项：

update-rc.d -f ＜script-name＞ remove

例如：
update-rc.d script-name start 90 1 2 3 4 5 . stop 52 0 6 .
start 90 1 2 3 4 5 . : 表示在1、2、3、4、5这五个运行级别中，按先后顺序，由小到大，第90个开始运行这个脚本。
stop 52 0 6 . ：表示在0、6这两个运行级别中，按照先后顺序，由小到大，第52个停止这个脚本的运行。

如果在 /etc/init.d 中加入一个 script，还须要制作相关的 link

在 /etc/rc*.d 中。K 开头是 kill , S 开头是 start , 数字顺序代表启动的顺序。(SysV)
update-rc.d 可以帮你的忙。

例：
在 /etc/init.d 中建立一个叫作 zope 的 script , 然后
update-rc.d zope defaults
就会产生以下链結::

        Adding system startup for /etc/init.d/zope ...        /etc/rc0.d/K20zope -> ../init.d/zope        /etc/rc1.d/K20zope -> ../init.d/zope        /etc/rc6.d/K20zope -> ../init.d/zope        /etc/rc2.d/S20zope -> ../init.d/zope        /etc/rc3.d/S20zope -> ../init.d/zope        /etc/rc4.d/S20zope -> ../init.d/zope        /etc/rc5.d/S20zope -> ../init.d/zope

其他进阶使用方式请 man update-rc.d