linux - 再起動後の古い PID ファイル

Question

再起動後に古い pidfile を処理するにはどうすればよいですか? 別のプロセスが同じ PID で代わりになった可能性があるため、ファイル内の番号を信頼できないと考えています。

再起動しても pidfile が生き残らないようにすることはできますか? そのpidを持つプロセスが実行されているときに、以前のブートから残っている場合と残っていない場合がある古いpidfileを検出する適切な方法は何ですか?

Answer 1

これが独自のデーモンである場合は、スキャンする/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);
    }
}

関数を実行するcheck4runningと、デーモンが単一であることを保証できます。最初のブロックは自己実行可能ファイルのロックです。これが不可能な場合は、/proc/pidfile（存在する場合）をスキャンしてチェックします。