linux - 重启后过时的 PID 文件

Question

重启后如何处理陈旧的 pidfile？我想我不能相信文件中的数字，因为另一个进程可能已经用相同的 PID 取代了它的位置。

我可以/应该确保 pidfile 不会在重新启动后继续存在吗？当具有该 pid 的进程正在运行时，检测过时 pidfile 的正确方法是什么，该文件可能会或可能不会从先前的引导中遗留下来？

Answer 1

通常，pidfiles 被写入/var/run/or /run/（在许多系统上，有一个符号链接 from /var/runto/run所以它们是相同的）。有关更多信息，请参阅文件系统层次标准。并且该/run/目录应该在启动时尽早清除（即因为它被挂载为tmpfs），所以它不会在重新启动时存活。另请参阅Linux Standard Base 4.1规范。

因此，您不应该关心过时的 pidfile。这不应该发生，如果发生，可能是因为系统管理员把事情搞砸了。如果该 pidfile 已经存在，我会以某种错误消息退出。

Answer 2

/proc/PID/cmdine如果这是您自己的守护进程，您可以通过扫描或发送信号以使用该 PID 进行处理来检测陈旧的 PID 文件。

对于一个简单的扫描示例，/proc我展示了我的解决方案：

#define PROC_BASE "/proc"

#include <stdio.h>      // printf, fopen, ...
#include <unistd.h>     // getpid
#include <stdio.h>      // perror
#include <sys/types.h>  // opendir
#include <dirent.h>     // opendir
#include <sys/stat.h>   // stat
#include <fcntl.h>      // fcntl
#include <stdlib.h>     // exit
#include <string.h>     // memset

/**
 * read process name from /proc/PID/cmdline
 * @param pid - PID of interesting process
 * @return filename or NULL if not found
 *      don't use this function twice for different names without copying
 *      its returning by strdup, because `name` contains in static array
 */
char *readname(pid_t pid){
    static char name[256];
    char *pp = name, byte, path[256];
    FILE *file;
    int cntr = 0;
    size_t sz;
    snprintf (path, 255, PROC_BASE "/%d/cmdline", pid);
    file = fopen(path, "r");
    if(!file) return NULL; // there's no such file
    do{ // read basename
        sz = fread(&byte, 1, 1, file);
        if(sz != 1) break;
        if(byte != '/') *pp++ = byte;
        else{
            pp = name;
            cntr = 0;
        }
    }while(byte && cntr++ < 255);
    name[cntr] = 0;
    fclose(file);
    return name;
}

void iffound_default(pid_t pid){
    fprintf(stderr, "\nFound running process (pid=%d), exit.\n", pid);
    exit(0);
}

/**
 * check wether there is a same running process
 * exit if there is a running process or error
 * Checking have 3 steps:
 *      1) lock executable file
 *      2) check pidfile (if you run a copy?)
 *      3) check /proc for executables with the same name (no/wrong pidfile)
 * @param argv - argument of main() or NULL for non-locking, call this function before getopt()
 * @param pidfilename - name of pidfile or NULL if none
 * @param iffound - action to run if file found or NULL for exit(0)
 */
void check4running(char **argv, char *pidfilename, void (*iffound)(pid_t pid)){
    DIR *dir;
    FILE *pidfile, *fself;
    struct dirent *de;
    struct stat s_buf;
    pid_t pid = 0, self;
    struct flock fl;
    char *name, *myname;
    if(!iffound) iffound = iffound_default;
    if(argv){ // block self
        fself = fopen(argv[0], "r"); // open self binary to lock
        memset(&fl, 0, sizeof(struct flock));
        fl.l_type = F_WRLCK;
        if(fcntl(fileno(fself), F_GETLK, &fl) == -1){ // check locking
            perror("fcntl");
            exit(1);
        }
        if(fl.l_type != F_UNLCK){ // file is locking - exit
            printf("Found locker, PID = %d!\n", fl.l_pid);
            exit(1);
        }
        fl.l_type = F_RDLCK;
        if(fcntl(fileno(fself), F_SETLKW, &fl) == -1){
            perror("fcntl");
            exit(1);
        }
    }
    self = getpid(); // get self PID
    if(!(dir = opendir(PROC_BASE))){ // open /proc directory
        perror(PROC_BASE);
        exit(1);
    }
    if(!(name = readname(self))){ // error reading self name
        perror("Can't read self name");
        exit(1);
    }
    myname = strdup(name);
    if(pidfilename && stat(pidfilename, &s_buf) == 0){ // pidfile exists
        pidfile = fopen(pidfilename, "r");
        if(pidfile){
            fscanf(pidfile, "%d", &pid); // read PID of (possibly) running process
            fclose(pidfile);
            if((name = readname(pid)) && strncmp(name, myname, 255) == 0)
                iffound(pid);
        }
    }
    // There is no pidfile or it consists a wrong record
    while((de = readdir(dir))){ // scan /proc
        if(!(pid = (pid_t)atoi(de->d_name)) || pid == self) // pass non-PID files and self
            continue;
        if((name = readname(pid)) && strncmp(name, myname, 255) == 0)
            iffound(pid);
    }
    closedir(dir);
    if(pidfilename){
        pidfile = fopen(pidfilename, "w");
        fprintf(pidfile, "%d\n", self); // write self PID to pidfile
        fclose(pidfile);
    }
}

如果您运行 function check4running，您将能够保证您的守护进程是单一的：第一个阻塞是锁定自我可执行文件，如果这是不可能的，它会扫描/proc/并检查 pidfile（如果存在）。