Linux下通过进程名获得进程号

因为存在多进程和线程，Linux下同一个进程名有可能有多个进程号。下面的程序可以一次获得同一进程名的所有进程号。

注意下面代码的局限性：如果允许程序带参数的话，使用该代码恐怕就起作用了，例如./myprocess -o filename -p port ， 不信的可以自己写个代码试试。

process.h

[cpp]  view plain copy

1. #ifndef __PROCESS_H__  
2. #define __PROCESS_H__  
3. char *basename(const char *path);  
4. int get_pid_by_name(const char* process_name, pid_t pid_list[], int list_size);  
5. int is_process_exist(const char* process_name);  
6.   
7. #endif /* __PROCESS_H__ */  

process.c (使用/proc/pid/exe 查找进程名有时候会有问题，比如busybox中的命令，查到的是busybox）

修改为使用/proc/pid/cmdline来查找。

[cpp]  view plain copy

1. #include <stdio.h>  
2. #include <stdlib.h>  
3. #include <unistd.h>  
4. #include <string.h>  
5. #include <sys/types.h>  
6. #include <dirent.h>  
7. #include <ctype.h>  
8. #include <errno.h>  
9. char *basename(const char *path)  
10. {  
11.     register const char *s;  
12.     register const char *p;  
13.   
14.     p = s = path;  
15.   
16.     while (*s) {  
17.         if (*s++ == '/') {  
18.             p = s;  
19.         }  
20.     }  
21.   
22.     return (char *) p;  
23. }  
24.   
25. /* find all pid of process by name, only compare base name of pid_name 
26.   * pid_list: caller malloc pid_t array 
27.   * list_size: the size of pid_list 
28.   * RETURN: 
29.   *        < 0: error number 
30.   *        >=0: how many pid found, pid_list will store the founded pid 
31.   */  
32. int get_pid_by_name(const char* process_name, pid_t pid_list[], int list_size)  
33. {  
34. #define  MAX_BUF_SIZE       256  
35.   
36.     DIR *dir;  
37.     struct dirent *next;  
38.     int count=0;  
39.     pid_t pid;  
40.     FILE *fp;  
41.     char *base_pname = NULL;  
42.     char *base_fname = NULL;  
43.     char cmdline[MAX_BUF_SIZE];  
44.     char path[MAX_BUF_SIZE];  
45.   
46.     if(process_name == NULL || pid_list == NULL)  
47.         return -EINVAL;  
48.   
49.     base_pname = basename(process_name);  
50.     if(strlen(base_pname) <= 0)  
51.         return -EINVAL;  
52.   
53.     dir = opendir("/proc");  
54.     if (!dir)  
55.     {  
56.         return -EIO;  
57.     }  
58.     while ((next = readdir(dir)) != NULL) {  
59.         /* skip non-number */  
60.         if (!isdigit(*next->d_name))  
61.             continue;  
62.   
63.         pid = strtol(next->d_name, NULL, 0);  
64.         sprintf(path, "/proc/%u/cmdline", pid);  
65.         fp = fopen(path, "r");  
66.         if(fp == NULL)  
67.             continue;  
68.   
69.         memset(cmdline, 0, sizeof(cmdline));  
70.         if(fread(cmdline, MAX_BUF_SIZE - 1, 1, fp) < 0){   
71.             fclose(fp);  
72.             continue;  
73.         }  
74.         fclose(fp);  
75.         base_fname = basename(cmdline);  
76.   
77.         if (strcmp(base_fname, base_pname) == 0 )  
78.         {  
79.             if(count >= list_size){  
80.                 break;  
81.             }else{  
82.                 pid_list[count] = pid;  
83.                 count++;  
84.             }  
85.         }  
86.     }  
87.     closedir(dir) ;  
88.     return count;  
89. }  
90.   
91. /* If process is existed, return true */  
92. int is_process_exist(const char* process_name)  
93. {  
94.     pid_t pid;  
95.   
96.     return (get_pid_by_name(process_name, &pid, 1) > 0);  
97. }  

main.c

[cpp]  view plain copy

1. #include <stdlib.h>  
2. #include <stdio.h>  
3. #include "process.h"  
4.   
5. #define MAX_PID_NUM     32  
6. int main(int argc, char* argv[])  
7. {  
8.   char* process;  
9.   int ret = 0;  
10.   int n;  
11.   pid_t pid[MAX_PID_NUM];  
12.   
13.   if(argc < 2)  
14.     process = argv[0];  
15.   else  
16.     process = argv[1];  
17.   
18.   ret = get_pid_by_name(process, pid, MAX_PID_NUM);  
19.   printf("process '%s' is existed? (%d): %c\n", process, ret, (ret > 0)?'y':'n');  
20.   for(n=0;n<ret;n++){  
21.     printf("%u\n", pid[n]);  
22.   }  
23.   return ret;  
24. }  

Makefile:

[plain]  view plain copy

1. PROG=check_process  
2. OBJS=process.o main.o  
3. #CFLAGS = -g -ggdb  
4.   
5. all:$(PROG)  
6.   
7. check_process:$(OBJS)  
8.     $(CC) -o $@ $^ $(LDFLAGS)  
9.   
10. %.o:%.c  
11.     $(CC) -c -o $@ $(CFLAGS) $<  
12.   
13. clean:  
14.     rm -rf $(PROG) *.o