我自己写的ps命令 －－－采用遍历/proc目录的方法(OS Linux--2.4.20-8smp)

duanjigang

前几天在帖子上看了别人写的一个ps命令（http://bbs.chinaunix.net/viewthr ... &extra=page%3D1），觉得挺不错的，可是自己对内核几乎不懂，翻了翻《情景分析》，对/proc目录下的东东有了点了解，便想些个ps命令试试，忙了近3天终于成了，这个办法实在有点傻，不过也算一种方法，希望能与大家分享，高人多提意见！！！！

1. 
   
2. /********************MyPS.c*******************************/
   
3. /**********/         OS Linux--2.4.20-8smp        /*****************/
   
4. 此伪PS命令是采用遍历/proc目录的方法
   
5. */
   
6. #define MAX_NAME 128
   
7. #include <sys/types.h>
   
8. #include <dirent.h>
   
9. #include <stdlib.h>
   
10. #include <stdio.h>
    
11. #include <string.h>
    
12. #include <unistd.h>
    
13. /*
    
14. 自己定义的进程结构体，信息不太全
    
15. */
    
16. typedef struct Proc_entry
    
17. {
    
18.         char name[MAX_NAME];//进程名(不是路径，路径在'cmdline'文件里面)
    
19.         char status;//状态
    
20.         int pid;//进程ID
    
21.         int Ppid;//父进程ID
    
22.         struct Proc_entry * next;//链向下一个进程节点的指针
    
23. }* Proc_entry_list;
    
24. //获得进程列表，仅仅含有ID信息
    
25. Proc_entry_list GetProcList(char* dir);
    
26. //填充进程列表
    
27. void FillProcList(Proc_entry_list L);
    
28. //初始化一个进程节点
    
29. void initProcEntry(Proc_entry_list L);
    
30. //检验是否是一个有效的进程节点
    
31. int checkProcEntry(Proc_entry_list L);
    
32. //填充一个进程节点，之后含有所有定义的信息
    
33. int FillProcInfo(Proc_entry_list pro,char * dir);
    
34. //判断这个目录名是否是数字组成的
    
35. int IsDigit(char *);
    
36. //释放进程链表的空间
    
37. int FreeProcList(Proc_entry_list root);
    
38. //打印进程列表，类似于PS命令
    
39. void PrintProcList(Proc_entry_list);
    
40. /****************************************************************/
    
41. int main(int argc, char * argv[])
    
42. {
    
43.         Proc_entry_list PROCESS = NULL;
    
44.         PROCESS = GetProcList("/proc");
    
45.         FillProcList(PROCESS);
    
46.         PrintProcList(PROCESS);
    
47.         FreeProcList(PROCESS);       
    
48.         exit(0);
    
49. }
    
50. // scanning directory '/proc' and  getting a process list,for each process we just have its name/pid
    
51. // then we will poll its detailed information from files under the directory named by the process' id.  
    
52. Proc_entry_list GetProcList(char* dir)
    
53. {
    
54.     DIR * dp;
    
55.         struct dirent * dirp;
    
56.     Proc_entry_list head = NULL,p = NULL;
    
57.         // try to open the directory
    
58.         if( (dp = opendir(dir))== NULL)
    
59.         {
    
60.                 printf("%s%s\n", "Can not open directory ", dir);
    
61.                 return NULL;   
    
62.         }
    
63.         // read all the directories or files under the dir
    
64.         while ((dirp = readdir(dp)) != NULL)
    
65.         {
    
66.                 // judging whether the directory name is composed by digitals,if so,we will
    
67.                 // check whether there are files under the directory ,these files includes
    
68.                 //all detailed information about the process
    
69.                 if((IsDigit(dirp->d_name) == 0))
    
70.                 {
    
71.                         Proc_entry_list s = (Proc_entry_list)malloc(sizeof(struct Proc_entry));
    
72.                        
    
73.                         if(s == NULL)
    
74.                         {
    
75.                                 perror("malloc error\n");
    
76.                                 //释放以前申请到的空间
    
77.                                 return NULL;
    
78.                         }
    
79.                         initProcEntry(s);
    
80.                         s->pid = atoi(dirp->d_name);
    
81.                         if(head == NULL)
    
82.                         {
    
83.                                 head = p = s;
    
84.                         }
    
85.                         else
    
86.                         {
    
87.                                 p->next = s;
    
88.                                 p = p->next;
    
89.                         }
    
90.                         p->next = NULL;
    
91.                 }//end if IsDigit
    
92.         }//end while
    
93.         closedir(dp);
    
94.         return head;
    
95. }
    
96. int IsDigit(char*a)
    
97. {
    
98.         int size,i;
    
99.         size = strlen(a);
    
100.         if(size == 0) return -1;
     
101.         for(i = 0; i< size; i++)
     
102.                 if(a[i] <'0' || a[i] > '9') return -1;
     
103.                 return 0;
     
104. }
     
105. 
     
106. int FillProcInfo(Proc_entry_list root,char * dir)
     
107. {
     
108.    
     
109.         FILE * fp;
     
110.         char buff[MAX_NAME];
     
111.         char name[MAX_NAME];
     
112.         chdir(dir);
     
113.         fp =fopen("status","r");
     
114.         if(fp == NULL)
     
115.         {
     
116.                 perror("open file status fail\n");
     
117.                 return -1;
     
118.         }
     
119.         while(fgets(buff,MAX_NAME-1,fp))
     
120.         {
     
121.                 if(strstr(buff,"Name:"))
     
122.                 {
     
123.                         sscanf(buff,"%s %s",name,root->name);
     
124.                 }else
     
125.                        
     
126.                         if(strstr(buff,"PPid:"))
     
127.                         {
     
128.                                 sscanf(buff,"%s %d",name,&(root->Ppid));
     
129.                         }else
     
130.                                 if(strstr(buff,"State:"))
     
131.                                 {
     
132.                                         sscanf(buff,"%s %c",name,&(root->status));
     
133.                                 }
     
134.                                 memset(buff,MAX_NAME,0);
     
135.                                 memset(name,0,MAX_NAME);
     
136.         }
     
137.     fclose(fp);
     
138.         return checkProcEntry(root);
     
139. }
     
140. 
     
141. void PrintProcList(Proc_entry_list root)
     
142. {
     
143.         Proc_entry_list p = root;
     
144.         int n =0;
     
145.         printf("*******name\tpid\tppid\tstatus***********\n");
     
146.         while(p!=NULL)
     
147.         {
     
148.                 if(checkProcEntry(p)==0)
     
149.                         printf("%d->\t%s   %d  %d  %c\n",++n,p->name,p->pid,p->Ppid,p->status);
     
150.                 p=p->next;
     
151.         }
     
152. }
     
153. /******************************/
     
154. void initProcEntry(Proc_entry_list L)
     
155. {
     
156.         memset(L->name,0,MAX_NAME);
     
157.         L->pid = L->Ppid = -1;
     
158.         L->status = '0';
     
159. }
     
160. int checkProcEntry(Proc_entry_list L)
     
161. {
     
162.         if(strlen(L->name)==0 || L->pid == -1 || L->Ppid == -1 || L->status == '0')
     
163.                 return -1;
     
164.         return 0;
     
165. }
     
166. /**************************************/
     
167. void FillProcList(Proc_entry_list L)
     
168. {
     
169.     char dir[20],data[10];
     
170.         Proc_entry_list p = L;
     
171.         while(p != NULL)
     
172.         {
     
173.                 memset(dir,0,20);
     
174.                 memset(data,0,10);
     
175.                 strcat(dir,"/proc/");
     
176.                 sprintf(data,"%d/",p->pid);
     
177.                 strcat(dir,data);
     
178.                 if(FillProcInfo(p,dir)<0)
     
179.                         initProcEntry(p);
     
180.                 p = p->next;
     
181.         }
     
182. }
     
183. int FreeProcList(Proc_entry_list root)
     
184. {
     
185.         Proc_entry_list p = root;
     
186.         if(root == NULL) return 0;
     
187.         if(root->next == NULL)
     
188.     {
     
189.                 free(root);
     
190.                 return 0;
     
191.     }
     
192.         p = p->next;
     
193.         while(p != NULL)
     
194.         {
     
195.                 free(root);
     
196.                 root = p;
     
197.                 p = p->next;
     
198.         }
     
199.         free(root);
     
200.         return 0;
     
201. }
     
202. /********************MyPS.c*************************/
     

复制代码

#gcc MyPS.c -o MyPS
# chmod u+x MyPS
#./MyPS
你就可以看到所有进程了。

[ 本帖最后由 duanjigang 于 2006-4-12 08:56 编辑 ]

richardhesidu

我也来贴一个:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <dirent.h>

#include <sys/types.h>

#define NAME_SIZE 20
#define BUF_SIZE 50

struct proc_list{
        pid_t pid;
        pid_t ppid;
        char name[NAME_SIZE];
        char status;
        struct proc_list *next;
};

struct proc_list *inport_list(char *);
void show_info(struct proc_list *);
int read_info(char *,struct proc_list *);
void free_list(struct proc_list *);
int is_num(char *);

int main()
{
        struct proc_list *head = inport_list("/proc");
        if(head==NULL){
                printf("inport list failed !\n");       
        }       
        show_info(head);
        free_list(head);
        return 0;
}

struct proc_list *inport_list(char *dir){
        DIR *dsptr;
        struct dirent *dptr;
        struct proc_list *head=NULL,*ptr=NULL;
        if((dsptr=opendir(dir))==NULL){
                printf("Error open the dir %s\n",dir);
                exit(-1);               
        }
       
        // read all the dir and file under directory "dir" ;
        while((dptr=readdir(dsptr))!=NULL){
                if(is_num(dptr->d_name)==0){ // determine if the d_name is a number ;
                       
                        // request some memeory , some = sizeof(struct proc_list) ;
                        struct proc_list *item = (struct proc_list *)malloc(sizeof(struct proc_list));
               
                        if(item==NULL){
                                printf("memory allocate error !\n");
                                // must do some free() work here !
                                free_list(head);
                                exit(-1);
                        }
               
                        memset(item,0,sizeof(struct proc_list));
                       
                        // link the item to proc_list list ;
                        if(head==NULL)
                                        head=ptr=item;
                        else{
                                ptr->next=item;
                                ptr=ptr->next;                       
                        }
               
                        item->pid = atoi(dptr->d_name);
                       
                        if(read_info(dptr->d_name,item)!=0){ // determine if read error occurred ;
                                // must do some free() work here ;
                                free_list(head);
                                exit(-1);                       
                        }                       
                }
        }
        closedir(dsptr);
        return head;
}

int read_info(char *d_name,struct proc_list *item){
        char dir[20];
        char name[NAME_SIZE];
        char buffer[BUF_SIZE];
        FILE *fptr;
       
        sprintf(dir,"%s%s","/proc/",d_name);
        chdir(dir);
       
        fptr=fopen("status","r");
        if(fptr==NULL){
                printf("Error reading %s%s\n",dir,"status");
                return -1;
        }
       
        while(fgets(buffer,BUF_SIZE-1,fptr))
    {
             if(strstr(buffer,"Name:")){
                sscanf(buffer,"%s%s",name,item->name);
                }else if(strstr(buffer,"PPid:")){
                sscanf(buffer,"%s%d",name,&(item->ppid));
        }else if(strstr(buffer,"State:")){
            sscanf(buffer,"%s %c",name,&(item->status));
        }
        }
        fclose(fptr);
        return 0;
}

void free_list(struct proc_list *head){
        struct proc_list *ptr;
        while(head!=NULL){
                ptr=head;
                head=head->next;
                free(ptr);
        }
}

void show_info(struct proc_list *head){
        struct proc_list *ptr;
        printf("pid\tppid\tstatus\tname\n");
        for(ptr=head;ptr!=NULL;ptr=ptr->next)
                printf("%d\t%d\t%c\t%s\n",ptr->pid,ptr->ppid,ptr->status,ptr->name);
}

int is_num(char *d_name){
        int i,size;
        size = strlen(d_name);
        if(size==0) return -1;
       
        // determine if the dir name is number ;
        for(i=0;i<size;i++)
                if(d_name[i]<'0' || d_name[i]>'9') return -1;
        return 0;
}

duanjigang

老兄，怪了哦，咱俩的程序好像是双胞胎啊，太象了吧！！！

richardhesidu

在你的基础上改的. 修改了一些我个人认为可以改进的地方.

duanjigang

好吧，刚才我还火着呢，反正都是学习，算了吧，这几天我觉得自己考虑的还算周到，不过肯定还有许多遗漏，修该吧！！