C 编程获取正在运行的程序进程号

1227阅读　0评论2011-10-17　linuxonee
分类：

程序实现思想：
Linux 系统的进程号是保存在 /proc 目录下的，一个在 linux 系统上运行的程序，只要是在运行状态下，就必然会在 /proc 目录下写入一批文件，其文件写入的方式如下：

/proc/<进程ID>/文件组

这里面的文件组是指一批文件，不是指一个文件，大致的文件名信息如下：
  1. dr-xr-xr-x 2 work work 0 09-21 00:51 attr
  2. -r-------- 1 work work 0 09-21 00:51 auxv
  3. -r--r--r-- 1 work work 0 09-21 00:51 cmdline
  4. -rw-r--r-- 1 work work 0 09-21 00:51 coredump_filter
  5. -r--r--r-- 1 work work 0 09-21 00:51 cpuset
  6. lrwxrwxrwx 1 work work 0 09-21 00:51 cwd -> /home/work/tmp
  7. -r-------- 1 work work 0 09-21 00:51 environ
  8. lrwxrwxrwx 1 work work 0 09-21 00:51 exe -> /home/work/tmp/tt
  9. dr-x------ 2 work work 0 09-21 00:51 fd
  10. dr-x------ 2 work work 0 09-21 00:51 fdinfo
  11. -r-------- 1 work work 0 09-21 00:51 io
  12. -r--r--r-- 1 work work 0 09-21 00:51 limits
  13. -rw-r--r-- 1 work work 0 09-21 00:51 loginuid
  14. -r--r--r-- 1 work work 0 09-21 00:51 maps
  15. -rw------- 1 work work 0 09-21 00:51 mem
  16. -r--r--r-- 1 work work 0 09-21 00:51 mounts
  17. -r-------- 1 work work 0 09-21 00:51 mountstats
  18. -r--r--r-- 1 work work 0 09-21 00:51 numa_maps
  19. -rw-r--r-- 1 work work 0 09-21 00:51 oom_adj
  20. -r--r--r-- 1 work work 0 09-21 00:51 oom_score
  21. lrwxrwxrwx 1 work work 0 09-21 00:51 root -> /
  22. -r--r--r-- 1 work work 0 09-21 00:51 schedstat
  23. -r--r--r-- 1 work work 0 09-21 00:51 smaps
  24. -r--r--r-- 1 work work 0 09-21 00:51 stat
  25. -r--r--r-- 1 work work 0 09-21 00:51 statm
  26. -r--r--r-- 1 work work 0 09-21 00:51 status
  27. dr-xr-xr-x 3 work work 0 09-21 00:51 task
  28. -r--r--r-- 1 work work 0 09-21 00:51 wchan
比如，我们运行了一个程序 tt ，假设其进程号为 31673 ，则在 /proc 目录下会形成 /proc/31673/ 的目录，且在其目录下存在上述的文件组。这个里面，我们需要的文件为 status ，该文件保存的是 tt 当前运行得状态，我们来看看这个文件的内容：

  1. Name: tt
  2. State: S (sleeping)
  3. SleepAVG: 98%
  4. Tgid: 31673
  5. Pid: 31673
  6. PPid: 7977
  7. TracerPid: 0
  8. Uid: 500 500 500 500
  9. Gid: 500 500 500 500
  10. FDSize: 256
  11. Groups: 500
  12. VmPeak: 3828 kB
  13. VmSize: 3664 kB
  14. VmLck: 0 kB
  15. VmHWM: 300 kB
  16. VmRSS: 300 kB
  17. VmData: 44 kB
  18. VmStk: 88 kB
  19. VmExe: 4 kB
  20. VmLib: 1448 kB
  21. VmPTE: 32 kB
  22. StaBrk: 09e04000 kB
  23. Brk: 09e04000 kB
  24. StaStk: 7ffff0e895d0 kB
  25. Threads: 1
  26. SigQ: 0/8192
  27. SigPnd: 0000000000000000
  28. ShdPnd: 0000000000000000
  29. SigBlk: 0000000000000000
  30. SigIgn: 0000000000000000
  31. SigCgt: 0000000000000000
  32. CapInh: 0000000000000000
  33. CapPrm: 0000000000000000
  34. CapEff: 0000000000000000
  35. Cpus_allowed: 00000000,00000000,00000000,00000000,00000000,00000000,00000000,ffffffff
  36. Mems_allowed: 00000000,00000001
我们发现，这个文件的第一行就是文件名，有了这个东西，那我们就有了获取当前正在运行的特定程序的进程号的办法了。
基本的解决思路是——我们通过遍历 /proc 目录下所有用数字作为目录名的子目录，依次打开这些目录下的 status 文件，获取其中的第一行内容，并从中获取对应的 Name 节的信息，与我们传入的需要查询的程序名字进行比较，如果一致，则该目录的数字就是该程序的进程号。

  1. /* find_pid_by_name()
  2.  *
  3.  * This finds the pid of the specified process.
  4.  * Currently, it's implemented by rummaging through
  5.  * the proc filesystem.
  6.  * Returns a list of all matching PIDs
  7.  */

  9. #include <unistd.h>
  10. #include <sys/types.h>
  11. #include <sys/stat.h>
  12. #include <unistd.h>
  13. #include <dirent.h>
  14. #include <string.h>
  15. #include <stdlib.h>
  16. #include <stdio.h>

  18. #define READ_BUF_SIZE 1024


  21. long* find_pid_by_name( char* pidName)
  22. {
  23.         DIR *dir;
  24.         struct dirent *next;
  25.         long* pidList=NULL;
  26.         int i=0;


  29.         dir = opendir("/proc");
  30.         if (!dir)
  31.         {
  32.                 //perror_msg_and_die("Cannot open /proc");
  33.                 fprintf(stderr, "Cannot open /proc\n");
  34.                 return pidList;
  35.         }

  37.         while ((next = readdir(dir)) != NULL)
  38.         {
  39.                 FILE *status;
  40.                 char filename[READ_BUF_SIZE];
  41.                 char buffer[READ_BUF_SIZE];
  42.                 char name[READ_BUF_SIZE];

  44.                 /* Must skip ".." since that is outside /proc */
  45.                 if (strcmp(next->d_name, "..") == 0)
  46.                         continue;

  48.                 /* If it isn't a number, we don't want it */
  49.                 if (!isdigit(*next->d_name))
  50.                         continue;
  51.                 sprintf(filename, "/proc/%s/status", next->d_name);

  53.                 if (! (status = fopen(filename, "r")) )
  54.                 {
  55.                         continue;
  56.                 }

  58.                 //Read first line in /proc/?pid?/status

  60.                 if (fgets(buffer, READ_BUF_SIZE-1, status) == NULL)
  61.                 {
  62.                         fclose(status);
  63.                         continue;
  64.                 }

  66.                 fclose(status);

  68.                 // Buffer should contain a string like "Name: binary_name"a

  70.                 sscanf(buffer, "%*s %s", name);

  72.                 if ( name != NULL && name[0] != '\0')
  73.                 {
  74.                         if (strcmp(name, pidName) == 0)
  75.                         {
  76.                                 pidList=realloc( pidList, sizeof(long) * (i+2));
  77.                                 pidList[i++]=strtol(next->d_name, NULL, 0);
  78.                         }

  80.                 }

  82.         }

  84.         if (pidList)
  85.         {
  86.                 pidList[i]=0;
  87.         }
  88.         return pidList;
  89. }



  93. int main ( int argc , char **argv)
  94. {
  95.         long *pid_t=NULL;
  96.         if ( argc != 2 )
  97.         {
  98.                 fprintf(stdout,"Usage %s \n",argv[0]);
  99.                 return 0;
  100.         }

  102.         pid_t = find_pid_by_name( argv[1]);

  104.         while ( pid_t != 0 && *pid_t != 0)
  105.         {
  106.                 fprintf(stdout,"\n%s is [ %d]\n",argv[1],*pid_t);
  107.                 pid_t++;
  108.         }
  109.         return 0;
  110. }

这段程序中特别需要注意的是：

main 函数中的 while(pid_t != 0 && *pid_t != 0) 这一行，开始的时候俺没有注意，一直报段错误，仔细观察后发现，不仅需要判断这个指针的值是否是等于 0 ， 同时还得判断这个指针本身是否等于 0 ，否则会出现查询的程序根本就没有运行时出现段错误，或者是查询的程序运行了，也会出现段错误的情况。

出现段错误是由于 pid_t 指针的值是空值，传给 fprintf 函数时会出现段错误。

==============================================

此程序在需要限制某些程序在特定的时间内只能一次运行的情况下很有好处，这种情况多数出现在金融系统、保险系统、收费系统等核心业务领域，通常在日终账务处理时，绝对不允许在同一个时间内连续两次运行扎帐程序，否则会造成业务数据紊乱。

因此，我们可以在程序运行得时候，首先获取自身的进程号 pid （用 getpid（）函数获取），然后通过上述的程序代码，获取当前程序的进程号，如果存在两个，则退出当前的程序，从而保证在一个特定的时间内，扎帐程序只有一个运行。

上一篇：linux下find命令实例
下一篇：GNU/Wget 使用手册