UNIX高级环境编程读书笔记（chapter13）

最新推荐文章于 2020-05-19 16:04:52 发布
最新推荐文章于 2020-05-19 16:04:52 发布
阅读量449 收藏
点赞数
分类专栏： UNIX环境高级编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fly_lhw/article/details/21604423
版权

第十三章    守护进程



        守护进程也称精灵进程是生存期较长的一种进程，它们常常在系统自举时启动，关闭时才终止，因为它们没有控制终端，所以说它们是在后台运行的。

        系统进程依赖于操作系统实现。父进程ID为0的进程通常是内核进程，它们作为系统自举过程的一部分而启动。

一、编程规则

       在编写守护进程程序时需遵循一些基本规则，以便防止产生并不需要的交互作用：

       (1)首先要做的是调用umask将文件模式创建屏蔽字设置为0。由继承得来的文件模式创建屏蔽字可能会拒绝设置          某些权限。

       (2)调用fork，然后使父进程退出。

       (3)调用setsid以创建一个新会话。

       (4)将当前工作目录更改为新目录。

       (5)关闭不在需要的文件描述符。

       (6)


实例:初始化一个守护进程

#include "apue.h"
#include <syslog.h>
#include <fcntl.h>
#include <sys/resource.h>


void
daemonize(const char *cmd)
{
    int i, fd0, fd1, fd2;
    pid_t pid;
    struct rlimit rl;
    struct sigaction sa;
    umask(0);

    if (getrlimit(RLIMIT_NOFILE, &rl) < 0)
    {
        err_quit("%s: can't get file limit", cmd);
    }

    if ((pid == fork()) < 0)
    {
        err_quit("%s: can't fork",cmd);
    }
    else if(pid != 0)
    {
        exit(0);
    }
    setsid();

    sa.sa_handler = SIG_IGN;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags  = 0;
    if (sigaction(SIGHUP, &sa, NULL) < 0)
    {
        err_quit("%s: can't ignore SIGHUP");
    }

    if ((pid = fork()) < 0)
    {
        err_quit("%s: can't fork", cmd);
    }
    else if (pid != 0)
    {
        exit(0);
    }

    if (rl.rlim_max == RLIM_INFINITY)
    {
        rl.rlim_max = 1024;
    }

    for (i = 0; i < rl.rlim_max; i++)
    {
        close(i);
    }

    fd0 = open("/dev/null", O_RDWR);
    fd1 = dup(0);
    fd2 = dup(0);

    openlog(cmd, LOG_CONS, LOG_DAEMON);

    if (fd0 != 0 || fd1 != 1 || fd2 != 2)
    {
        syslog(LOG_ERR, "unexpected file descriptors %d %d %d", fd0, fd1, fd2);
        exit(1);
    }
}


二、出错记录

        有三种方法产生日志消息：

        (1)内核例程可以调用log函数。

        (2)大多数用户进程(守护进程)调用syslog(3)函数以产生日志信息。

        (3)在此主机上的一个用户进程，或通过TCP/IP网络链接到此主机的其它主机上的一个用户进程可将日志消息发向UDP端口514.

         void openlog(const char *ident, int option, int facility);

         void syslog(int priority , const char *format, ...);

         void closelog(void);

         int setlogmask(int maskpri);

       调用openlog是可选择的。如果不调用openlog，则在第一次调用syslog时， 自动调用openlog。调用closelog也是可选择的——它只是关闭曾被用于与syslog守护进程通信的描述符。

       调用syslog产生一个日志消息。

       setlogmask函数用于设置进程的记录优先级屏蔽字。

三、单实例守护进程

       为了正常运作，某些守护进程实现为单实例的，也就是在任一时刻只运行该守护进程的一个副本。

       文件锁和记录锁机制是一种方法的基础，该方法用来保护一个守护进程只有一个副本在运行。

       文件锁个记录锁提供了一种方便的互斥机制。如果守护进程在整个文件上得到一把写锁，那么在该守护进程终止时，这把锁将被自动删除，这就简化了复原所需的处理，去除了对以前守护进程实例需要进行清理的有关操作。

实例：保证只运行某个守护进程的一个副本

#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <syslog.h>
#include <string.h>
#include <errno.h>
#include <stdio.h>
#include <sys/stat.h>

#define LOCKFILE "/var/run/daemon.pid"
#define LOCKMODE (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)

extern int lockfile(int);

int already_running(void)
{
    int fd;
    char buf[16];

    fd = open(LOCKFILE, O_RDWR | O_CREAT, LOCKMODE);
    if (fd < 0)
    {
        syslog(LOG_ERR, "can't open %s: %s", LOCKFILE, strerror(errno));
        exit(1);
    }

    if (lockfile(fd) < 0)
    {
        if (errno == EACCES || errno == EAGAIN)
        {
            close(fd);
            return(1);
        }
        syslog(LOG_ERR, "can't lock %s: %s",LOCKFILE, strerror(errno));
        exit(1);
    }
    ftruncate(fd, 0);
    sprintf(buf, "%ld", (long)getpid());
    write(fd, buf, strlen(buf) + 1);
    return(0);
}


四、守护进程的惯例

        1.若守护进程使用锁文件，那么该文件通常存放在/var/run目录中。

        2.若守护进程支持配置选项，那么配置文件通常放在/etc目录中。

        3.守护进程可用命令行启动，但通常它们是由系统初始化脚本之一(/etc/rc* 或 /etc/init.d/*)启动的。

        4.若一守护进程有一配置文件,那么当该守护进程启动时,它读改文件,但在此后一般就不会再查看它.

实例:守护进程重读配置文件

#include "apue.h"
#include <pthread.h>
#include <syslog.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <string.h>
#include <errno.h>
#include <stdio.h>
#include <sys/stat.h>


#define LOCKFILE "/var/run/daemon.pid"
#define LOCKMODE (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)

extern int lockfile(int);
static int already_running(void);

sigset_t mask;

void
reread(void)
{
}

void *
thr_fn(void *arg)
{
    int err,signo;

    err = sigwait(&mask, &signo);
    for (;;)
    {
        if (err != 0)
        {
            syslog(LOG_ERR, "sigwait failed");
            exit(1);
        }

        switch (signo)
        {
            case SIGHUP:
                syslog(LOG_INFO, "Re-reading configuratttion file");
                reread();
                break;

            case SIGTERM:
                syslog(LOG_INFO, "got SIGTERM; exiting");
                exit(0);

            default:
                syslog(LOG_INFO, "unexpected signal %d\n", signo);
        }
    }
    return(0);
}

int
main(int argc, char *argv[])
{
    int                 err;
    pthread_t           tid;
    char                *cmd;
    struct sigaction    sa;

    if (cmd = strrchr(argv[0], '/') == NULL)
    {
        cmd = argv[0];
    }
    else
    {
        cmd++;
    }

    daemonize(cmd);


    if (alreadyrunning())
    {
        syslog(LOG_ERR, "daemon already running");
        exit(1);
    }

    sa.sa_handler = SIG_DFL;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = 0;
    if (sigaction(SIGHUP, &sa, NULL) < 0)
    {
        err_quit("%s: can't reatore SIGHUP default");
    }
    sigfillset(&mask);
    if ((err = pthread_sigmask(SIG_BLOCK, &mask, NULL)) != 0)
    {
        err_exit(err, "SIG_BLOCK error");
    }

    err = pthread_create(&tid, NULL, thr_fn, 0);
    if (err != 0)
    {
        err_exit(err, "can't create thread");
    }

    exit(0);
}



int already_running(void)
{
    int fd;
    char buf[16];

    fd = open(LOCKFILE, O_RDWR | O_CREAT, LOCKMODE);
    if (fd < 0)
    {
        syslog(LOG_ERR, "can't open %s: %s", LOCKFILE, strerror(errno));
        exit(1);
    }

    if (lockfile(fd) < 0)
    {
        if (errno == EACCES || errno == EAGAIN)
        {
            close(fd);
            return(1);
        }
        syslog(LOG_ERR, "can't lock %s: %s",LOCKFILE, strerror(errno));
        exit(1);
    }
    ftruncate(fd, 0);
    sprintf(buf, "%ld", (long)getpid());
    write(fd, buf, strlen(buf) + 1);
    return(0);
}

实例：守护进程重读配置文件的另一种实现


#include "apue.h"
#include <pthread.h>
#include <syslog.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <string.h>
#include <errno.h>
#include <stdio.h>
#include <sys/stat.h>


extern int lockfile(int);
static int already_running(void);


void
reread(void)
{
}

void
sigterm(int signo)
{
    syslog(LOG_INFO, "got SIGTERM; exiting");
    exit(0);
}

void
sighup(int signo)
{
    syslog(LOG_INFO, "Re-reading configuration file");
    reread();
}

int
main(int argc, char *argv[])
{
    char                *cmd;
    struct sigaction    sa;

    if (cmd = strrchr(argv[0], '/') == NULL)
    {
        cmd = argv[0];
    }
    else
    {
        cmd++;
    }

    daemonize(cmd);
    if (alreadyrunning())
    {
        syslog(LOG_ERR, "daemon already running");
        exit(1);
    }

    sa.sa_handler = sigterm;
    sigemptyset(&sa.sa_mask);
    sigaddset(&sa.sa_mask, SIGHUP);
    sa.sa_flags = 0;
    if (sigaction(SIGTERM, &sa, NULL) < 0)
    {
        err_quit(LOG_ERR, "can't catch  SIGTERM: %s", strerron(errno));
        exit(1);
    }

    sa.sa_handler = sighup;
    sigemptyset(&sa.sa_mask);
    sigaddset(&sa.sa_mask, SIGTERM);
    sa.sa_flags = 0;
    if (sigaction(SIGHUP, &sa, NULL) < 0)
    {
        err_quit(LOG_ERR, "can't catch  SIGHUP: %s", strerron(errno));
        exit(1);
    }

    exit(0);
}

int already_running(void)
{
    int fd;
    char buf[16];

    fd = open(LOCKFILE, O_RDWR | O_CREAT, LOCKMODE);
    if (fd < 0)
    {
        syslog(LOG_ERR, "can't open %s: %s", LOCKFILE, strerror(errno));
        exit(1);
    }

    if (lockfile(fd) < 0)
    {
        if (errno == EACCES || errno == EAGAIN)
        {
            close(fd);
            return(1);
        }
        syslog(LOG_ERR, "can't lock %s: %s",LOCKFILE, strerror(errno));
        exit(1);
    }
    ftruncate(fd, 0);
    sprintf(buf, "%ld", (long)getpid());
    write(fd, buf, strlen(buf) + 1);
    return(0);
}

fly_lhw
关注
专栏目录
守护进程重读配置文件示例
博观约取
09-24 2801
守护进程重读配置文件示例      重读APUE，对守护进程有了更加深刻的理解，特别是相应的编程规则和应用场景。对于为什么要fork两次，日志设施的用法，信号的处理方法都有了更加清晰的认识。通常的应用场景是，守护进程在收到一个SIGHUP信号的时候重新读取配置文件，而不需要停止。下面是运行APUE书中这个实例的过程。      首先主要代码为（reread.c）： #incl
UNIX高级环境编程读书笔记（chapter5）
fly_lhw的专栏
03-11 425
5.9 二进制IO 下列两个函数执行二进制IO操作：fread(),fwrite(). (1)读或写一个二进制数组; (2)读或写一个结构; 返回:读或写的对象数 5.10 定位流 有三种方法定位标准IO流 (1)ftell和fseek函数 (2)ftello和fseeko函数 (3)fgetpos和fsetpos函数 5.11 格式化IO 5.11.1  格
读书笔记《高级UNIX环境编程》
xsj的专栏
04-07 395
主要记录了阅读《高级UNIX环境编程》的过程中，发现的知识点。
UNIX高级环境编程读书笔记（chapter14）
fly_lhw的专栏
03-26 697
第十四章  高级IO 一、引言        本章内容包括非阻塞IO、记录锁、系统V流机制、I/O多路转接(select 和 poll函数)、readv和writev函数以及存储映射I\O，这些都称为高级I/O。 二、非阻塞I/O        非阻塞I/O使我们可以调用open、read和write这样的I/O操作，并使这些操作不会永远阻塞。如果这种操作不能完成，则调用立即出错返回，表示
UNIX高级环境编程读书笔记（chapter10）
fly_lhw的专栏
03-16 690
chapter 10  信号 信号就是软件中断。
UNIX高级环境编程读书笔记（chapter12）
fly_lhw的专栏
03-19 458
第十二章  线程控制 一、线程限制         与其它的系统限制一样，这些线程也可以通过sysconf函数进行查询。         与sysconf报告的其它限制一样，这些限制的使用是为了增强应用程序在不同的操作系统实现之间的可移植性。 二、线程属性 实例：以分离状态创建的线程 #include "apue.h" #include int makethre
UNIX高级环境编程读书笔记（chapter11）
fly_lhw的专栏
03-19 373
第11章 线程 典型的UNIX进程可以看成只有一个控制线程：一个进程在同一时刻只做一件事情。有了多个控制线程以后，在程序设计时可以把线程设计成在同一时刻能够做不止一件事情，每个线程处理各自独立的任务。 (1)通过为每种事件类型的处理分配单独的线程,能够简化处理异步事件的代码。 (2)多个进程必需使用操作系统提供的复杂机制才能实现内存和文件描述符的共享。 (3)有些问题可以通过将其分解从而改
UNIX高级环境编程读书笔记（chapter7）
fly_lhw的专栏
03-11 516
7.1 main函数 C程序总是从main函数开始执行。 7.2 进程终止 有8种方式是进程终止 (1)从main返回 (2)调用exit() (3)调用_exit或_Exit (4)最后一个线程从启动例程返回 (5)最后一个线程调用pthread_exit 异常终止有三种方式: (6)调用abort (7)接到一个信号并终止 (8)最后一个线程对取消请求做
UNIX高级环境编程读书笔记（chapter9）
fly_lhw的专栏
03-13 509
chapter 9 进程关系    当系统自举时，内核创建进程ID为1的进程，Init进程。Init进程使系统进入多用户状态。Init进程读文件/etc/ttys，对每一个允许登陆的终端设备，Init调用一次fork，它所生成的子进程则执行getty程序。 getty为终端设备调用open函数，以读写方式将终端打开。一旦设备被打开，则文件描述符0、1、2就被设置到该设备。然后getty输出“
《Unix高级环境编程》 读书笔记（1）（ch0~ch2）
vingstar的专栏
08-14 1424
《Unix高级环境编程》 读书笔记 Reading Notes (使用的是2005年的英文第二版） "One of the essential classics of UNIX programming." —Eric S. Raymond, author of The Art of UNIX Programming Forward by Dennis Ritchie：
Unix网络编程学习笔记课后题（Chapter 4）
Ethan95的博客
12-09 611
4.1 如何辨别&lt;netinet/in.h&gt;中定义的INADDR_是主机序还是网络序。 less /usr/include/netinet/in.h 可以发现是按小端序存储的，Linux的主机序就是小端序。 还有个想法，可以用htonl()去转换，看结果是不是相等。 4.2 在connect调用返回成功后调用getsockname查看本地地址和端口号 len=sizeof(clia...
Unix网络编程学习笔记课后题（Chapter 6）
Ethan95的博客
12-11 429
6.1 在/usr/include/x86_64-linux-gnu/sys/select.h中查看fd_set的定义 /* fd_set for select and pselect. */ typedef struct { /* XPG4.2 requires this member name. Otherwise avoid the name from the ...
Unix网络编程学习笔记课后题（Chapter 3）
Ethan95的博客
12-08 759
3.1 因为不同类型的套接字长度不同。IPV4和IPV6套接字长度固定，但Unix域结构和数据链路结构是可变长度的，需要一个参数记录结果的大小，直接传就是值传递了，需要传一个指针，以实现引用传递。 3.2 void指针只能用来传参数，不能对void类型指针加减和解引用 3.3 匆匆忙忙按自己的理解写了下， 也不知道对不对。。先这样吧 #include "../lib/unp.h" #include...
TCP/IP网络编程笔记Chapter I -8进程与僵尸进程2
shi_xiao_xuan的博客
05-19 217
TCP/IP网络编程笔记Chapter I -8进程与僵尸进程21.信号与signal()函数2.信号与sigaction()函数3.利用信号处理技术消灭僵尸进程 在上一篇中，我们知道了进程的创建以及销毁方法，但是还有一个问题困扰着我们：子进程究竟什么时候终止，调用waitpid()函数后需要无休止的等待吗？ 子进程终止时识别的主体是操作系统，能不能让操作系统告诉父进程子进程终止了，让父进程暂时先处理子进程再继续工作呢？当然是可以的，我们引入信号处理机制。此时的信号是在特定事件发生时由操作系统向进程发送的消
UNIX高级环境编程读书笔记（chapter8）
fly_lhw的专栏
03-11 564
第八章 进程控制 每个进程都有一个非负整型表示唯一的进程ID.虽然是唯一的,但是进程ID可以重用,当一个进程终止后,其进程ID就可以再次使用了.ID为0的进程通常是调度进程,常常是交换进程,是内核的一部分,也被称为系统进程.进程ID1通常是init进程,在自举过程结束时内核调用. 8.1.由fork创建的新进程被称为子进程.fork函数被调用一次单返回两次.两次返回的唯一区别是子进程的返回值是
UNIX高级环境编程读书笔记（chapter1-3）
fly_lhw的专栏
03-11 526
UNIX： 程序的执行实例被称为进程； UNIX 环境高级编程： 1.调用open函数可以打开或创建一个文件. 2.可以调用creat函数创建一个新文件. 3.close函数关闭一个打开的文件. 4.lseek函数:每个打开的文件都有一个与其相关联的"当前文件偏移量".他通常是一个非负整数          Ex1:测试能否对标准输入设置偏移量: #include "ap
UNIX高级环境编程读书笔记（chapter4）
fly_lhw的专栏
03-11 474
Chapter 4  文件和目录 4.0.给定一个pathname   (1)stat函数返回一个与此命名有关的信息结构.   (2)fstat函数获得已在描述符filedes上打开的文件的有关信息.            (3)lstat函数类似于stat,但是当命名的文件是一个符号链接时,lstat返回该符号链接的有关信息,而不是由该符号链接引用的文件的信息. 4.1文件类型 (1
逆变器PQ控制模型、逆变器并网模型（Simulink） 直流侧电压650V～2000V均可 交流测电压为380V 有功功率和无功
最新发布
10-10
逆变器PQ控制模型、逆变器并网模型（Simulink） 直流侧电压650V～2000V均可 交流测电压为380V 有功功率和无功功率可达10kW或10kVar，甚至更高
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值