重启后陈旧的PID文件

Question

重启后如何处理陈旧的pid文件？我认为我不能相信文件中的数字，因为另一个进程可能已经采用了相同的PID。

可以/我应该确保pidfiles在重新启动后无法存活吗？什么时候检测一个陈旧的pid文件的正确方法，可能会或可能不会从以前的引导中遗留下来，当一个使用该pid的进程正在运行时？

Answer 1

通常，PID文件被写入/var/run/或/run/（在许多系统没有从/var/run到/run一个符号，使他们都是一样的）。有关更多信息，请参阅Filesystem Hierarchy Standard。并且该/run/目录应该在启动时被提前清除（即因为它被挂载为tmpfs），所以它不会在重新启动后存活。另见Linux Standard Base 4.1规范。

因此，你不应该关心陈旧的pidfiles。这不应该发生，如果这样做可能是因为系统管理员糟糕的东西搞砸了。如果该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); 
    } 
} 

如果你运行功能check4running，你就可以保证你的守护进程是单：第一阻挡被锁定自我可执行的，如果这是不可能的，它扫描/proc/并检查pidfile（如果存在）。