Linux pstree(英文全称：display a tree of processes）) 命令将所有进程以树状图显示，树状图将会以 pid (如果有指定) 或是以 init 这个基本进程为根 (root)，如果有指定使用者 id，则树状图会只显示该使用者所拥有的进程。
使用权限：所有使用者。
首先，我们需要问题分解一下：
- 得到命令行的参数，根据要求设置标志变量的数值；
- 得到系统中所有进程的编号 (每个进程都会有唯一的编号) 保存到列表里；
- 对列表里的每个编号，得到它的的父亲是谁；
- 在内存中把树建好，按命令行参数要求排序；
- 把树打印到终端上。
因为人的脑容量有限，通常解决问题的办法就是把比较复杂的问题分解成小问题，再把小问题继续分解下去。而在学校里所做的训练就是建立问题分解的思路和培养解决问题的能力。
预备工作
由于在实验中会反复编译运行这个程序，所以编译和测试自动化非常重要。
这里我写了一个脚本利用inotufy命令自动化这个过程：
Inotify 一种强大的、细粒度的、异步文件系统监控机制，它满足各种各样的文件监控需要，可以监控文件系统的访问属性、读写属性、权限属性、删除创建、移动等操作，也就是可以监控文件发生的一切变化。
inotify-tools 是一个C库和一组命令行的工作，提供Linux下inotify的简单接口。inotify-tools安装后会得到inotifywait和inotifywatch这两条命令：
下载inotufy：
在Ubuntu系统下使用命令：
sudo apt-get install inotify-tools
其他Linux发行版安装方法可以参见：https://github.com/rvoicilas/inotify-tools/wiki#wiki-getting
inotifywait使用：
语法：inotifywait [-hcmrq] [-e ] [-t ] [–format ] [–timefmt ] [ … ]
-m:一直监控指定的目录，接收到一个事情而不退出，无限期地执行。默认的行为是接收到一个事情后立即退出。
@:排除不需要监视的文件，可以是相对路径，也可以是绝对路径。
-o, –outfile :输出事情到一个文件而不是标准输出。
-s, –syslog:输出错误信息到系统日志
-d, –daemon:跟–monitor一样，除了是在后台运行，需要指定–outfile把事情输出到一个文件。也意味着使用了–syslog。
–exclude :正则匹配需要排除的文件，大小写敏感。
–excludei :正则匹配需要排除的文件，忽略大小写。
-t , –timeout :设置超时时间，如果为0，则无限期地执行下去。
-r:递归监控所监控目录的子目录。
-q:指定一次，不会输出详细信息，指定二次，除了致命错误，不会输出任何信息。
–timefmt:指定时间格式。
–format:
%w 表示发生事件的目录
%f 表示发生事件的文件
%e 表示发生的事件
%Xe 事件以“X”分隔
%T 使用由–timefmt定义的时间格式
-e:指定监控事件项
示例1：
实现对 /data/web 目录进行监控，监控文件删除，修改，创建和权限相关事件，并且要求将监控信息写入 /var/log/web_watch.log。要求日志条目要清晰明了，能突显文件路径、事件名和时间。
# cat web_watch.sh
#!/bin/bash
inotifywait -mrq --timefmt '%y/%m/%d %H:%M' --format '%T %w%f %e' --event delete,modify,create,attrib /data/web | while read date time file event
do
case $event in
MODIFY|CREATE|MOVE|MODIFY,ISDIR|CREATE,ISDIR|MODIFY,ISDIR)
echo $event'-'$file'-'$date'-'$time >> /var/log/web_watch.log
;;
MOVED_FROM|MOVED_FROM,ISDIR|DELETE|DELETE,ISDIR)
echo $event'-'$file'-'$date'-'$time /var/log/web_watch.log
;;
esac
done
inotify 优点：
1）监控文件系统事件变化，通过同步工具实现实时数据同步。
inotify 缺点
1）并发如果大于200个文件（10-100k），同步就会有延迟
2）我们前面写的脚本，每次都是全部推送一次，但确实是增量的。也可以只同步变化的文件，不变化的不理。
3）监控到事件后，调用rsync同步是单进程的，而sersync为多进程同步。既然有了inotify-tools，为什么还要开发sersync？
serysync功能多：（inotify+rsync命令）
1）支持通过配置文件管理
2）真正的守护进程socket
3）可以对失败文件定时重传（定时任务功能）
4）第三方的HTTP接口（例如：更新cdn缓存）
5）默认多进程rsync同步
在了解inotigy命令相关知识后，就可以利用脚本auto_test.sh每次在文件改动以后自动运行所有测试，代码如下：
#!/bin/bash
projectDir=/home/acs/os_test
while inotifywait $projectDir --timefmt '%d/%m/%y %H:%M' --format "%T %f %e" -e MODIFY --exclude '^.*.swp$'
do
cd $projectDir && gcc test.c -o test1 && ./test1
done
运行这个脚本就可以了：
./auto_test.sh
step 1: 得到命令行的参数，根据要求设置标志变量的数值
在c语言主函数中，int argc, char *argv[]就是从命令行获取的参数，这是操作系统与 C 程序之间的约定。其中argc是参数的个数，argv是参数字符串。
这里我们使用getopt()函数来处理命令行参数：
getopt()函数的出处是unistd.h头文件，可以参考这篇博客Linux下getopt()函数的简单使用
代码：
int main(int argc, char *argv[]) {
int ch;
while((ch = getopt(argc, argv, "pnv")) != -1)
{
printf("optind: %d\n", optind);
switch(ch){
case 'p':
printf("HAVE option: -p \n\n");
break;
case 'n':
printf("HAVE option: -n \n\n");
break;
case 'v':
printf("HAVE option: -v \n\n");
break;
case '?':
printf("Unknown option: %c\n",(char)optopt);
break;
}
}
assert(!argv[argc]);
return 0;
}
step 2: 得到系统中进程的编号
Everything is a file，进程信息当然也可以是 “一切” 的一部分
首先我们要知道的是在Linux中，所有进程的信息都以文件的形式存储在/proc目录中，在/proc中存在由数字命名的文件夹，这些数字就是相应进程的pid，进入各个进程的目录中（如进入1号进程的目录中），有一个stat文件，该文件中第四列即为其父进程的pid。
输入命令:cd /proc && ls可以发现查看这些文件夹
1号进程的stat文件信息：
思路：
这里我用一个结构体数组先将每一个进程的ppid和pid存起来，打印出来查看一下效果
代码：
#include <stdio.h>
#include <assert.h>
#include <unistd.h>
#include <dirent.h>
#include <string.h>
#include <stdlib.h>
#define PATH "/proc"
#define BUFFSIZE_INFO 50
// pid ppid
struct pinfo{
int pid;
int ppid;
}processInfos[500];
int number_process = 0;// 进程个数
int getPpid(char *filename);
void setPid_Ppid();
int main(int argc, char *argv[]) {
setPid_Ppid();
for(int i = 0;i<number_process;i++){
// printf("%d %d \n",processInfos[i].pid,processInfos[i].ppid);
}
int ch;
while((ch = getopt(argc, argv, "pnv")) != -1)
{
printf("optind: %d\n", optind);
switch(ch){
case 'p':
printf("HAVE option: -p \n\n");
break;
case 'n':
printf("HAVE option: -n \n\n");
break;
case 'v':
printf("HAVE option: -v \n\n");
break;
case '?':
printf("Unknown option: %c\n",(char)optopt);
break;
}
}
assert(!argv[argc]);
return 0;
}
int getPpid(char* filename){
int ppid = -100;
char *right=NULL;
FILE *fp = fopen(filename,"r");
char info[BUFFSIZE_INFO+1];
info[BUFFSIZE_INFO] = '\0';
if(fp==NULL){
fprintf(stderr,"open file %s error!\n", filename);
return -1;
}
if(fgets(info,BUFFSIZE_INFO,fp)==NULL){
puts("fgets error!");
exit(0);
}
right=strrchr(info,')');
if(right == NULL){
printf("cannot find )\n");
}
right+=3;
sscanf(right, "%d", &ppid);
return ppid;
}
void setPid_Ppid(){
DIR * dir_ptr; // 目录中的句柄
struct dirent * direntp; //文件结构体
int pid,ppid;
char process_path[51] = "/proc/";
char stat[6] = "/stat";
char pidStr[20];
dir_ptr = opendir(PATH); //打开目录，并返回句柄
if(dir_ptr==NULL){
fprintf(stderr,"can not open /proc\n");
exit(0);
}
while(direntp = readdir(dir_ptr)){ //读取句柄，返回dirent结构体
// printf("%s %d\n",direntp->d_name,atoi(direntp->d_name));
pid = atoi(direntp->d_name);
if(pid){
//拼接字符串process_path
//examples: /proc/pid/stat
//itoa(pid,pidStr,10);
processInfos[number_process].pid = pid;
sprintf(pidStr,"%d",pid);
strcat(process_path,pidStr);
strcat(process_path,stat);
int ppid = getPpid(process_path); // 返回-1表示出错
if(~ppid){
processInfos[number_process++].ppid = ppid;
}else{
number_process++;
}
// 重置process_path
process_path[6] = 0;
}
}
}
打印结果：
step 3: 根据进程编号及父进程编号建树
在获得进程编号的基础上，我们还需要得到每一个进程的name，因此增加一段获取pname的代码：
// 获取pname
char ch[100];
strcpy(ch, "/proc/");
strcat(ch, pidStr);
strcat(ch, "/status");
FILE* fp = fopen(ch,"r");
char pname[100];
while((fscanf(fp, "%s", ch)) != EOF) {
if(strcmp(ch, "Name:") == 0){
fscanf(fp, "%s", pname);
break;
}
}
printf("%s\n",pname);
首先，我们需要构建一颗多叉树，保存进程的父子节点信息，以及相应的操作函数：
int build_tree(const char* path, process* head, int dep) {
const int size = 1024;
FILE* fp;
char ch[size];
strcpy(ch, "/proc/");
strcat(ch, path);
strcat(ch, "/status");
fp = fopen(ch, "r");
char pid[size], ppid[size], name[size];
while((fscanf(fp, "%s", ch)) != EOF) {
if (strcmp(ch, "Pid:") == 0) {
fscanf(fp, "%s", pid);
}
if (strcmp(ch, "PPid:") == 0) {
fscanf(fp, "%s", ppid);
}
if (strcmp(ch, "Name:") == 0) {
fscanf(fp, "%s", name);
}
}
ch[0] = 0;
if (dep) strcpy(ch, "{");
strcat(ch, name);
if (dep) strcat(ch, "}");
insert(head, create_p(ch, pid), ppid);
fclose(fp);
return 0;
}
step 4: 打印信息
int print_tree(process* head, int len, int* buf, int flag) {
if (head == NULL) return -1;
while (head) {
printf("%s", head->pname);
if (flag) printf("(%s)", head->pid);
if (head->son) {
if(!head->son->bro) printf("\u2500\u2500\u2500");
else printf("\u2500\u252c\u2500");
int size = strlen(head->pname) + len + 3 + (flag * (strlen(head->pid) + 2));
if (head->son->bro) buf[size - 2] = 1;
print_tree(head->son, size, buf, flag);
}
head = head->bro;
if (head) {
printf("\n");
if (!head->bro) buf[len - 2] = 0;
for (int i = 0; i < len - 2; ++ i)-
if (buf[i]) printf("\u2502");
else printf(" ");
if (!head->bro) printf("\u2514\u2500");
else printf("\u251c\u2500");
}
}
return 0;
}
完整代码：
#include <stdio.h>
#include <assert.h>
#include <unistd.h>
#include <dirent.h>
#include <string.h>
#include <stdlib.h>
#define PATH "/proc"
#define BUFFSIZE_INFO 50
typedef struct process {
char *pname;
char *pid;
struct process *bro;
struct process *son;
}process;
process* create_p(const char*,const char*);
int insert(process*, process*,const char*);
int print_tree(process*, int, int*, int);
void listdir(const char*,const int father, process** head,int dep,int flag);
int number_process = 0;// 进程个数
int getPpid(char *filename);
void create_print_pro(int op); //创建树
process* create_p(const char*, const char*);
int build_tree(const char*, process*, int dep);
int main(int argc, char *argv[]) {
int ch;
while((ch = getopt(argc, argv, "pnv")) != -1)
{
printf("optind: %d\n", optind);
switch(ch){
case 'p':
printf("HAVE option: -p \n\n");
create_print_pro(1);
break;
case 'n':
printf("HAVE option: -n \n\n");
create_print_pro(2);
break;
case 'v':
printf("HAVE option: -v \n\n");
create_print_pro(3);
break;
case '?':
printf("Unknown option: %c\n",(char)optopt);
break;
}
}
assert(!argv[argc]);
return 0;
}
void create_print_pro(int op){
process** head = (process**)malloc(sizeof(process*));
char buff[1024] = {0};
listdir(buff," ",head,0,op);
printf("\n");
int buf[1024] = {0};
int state_n = 0;
if(op == 2)state_n = 1;
print_tree((*head), 0, buf, state_n);
printf("\n");
}
void listdir(const char* path, int father, process** head,int dep,int flag){
DIR * dir_ptr; // 目录中的句柄
struct dirent * direntp; //文件结构体
int pid,ppid;
dir_ptr = opendir(PATH); //打开目录，并返回句柄
if(dir_ptr==NULL){
fprintf(stderr,"can not open /proc\n");
exit(0);
}
if(!dep) *head = create_p("", "0"); // 初始化
while(direntp = readdir(dir_ptr)){ //读取句柄，返回dirent结构体
// printf("%s %d\n",direntp->d_name,atoi(direntp->d_name));
pid = atoi(direntp->d_name);
if(pid){
if(dep == 1 && pid != father)continue;
build_tree(direntp->d_name, *head,dep);
if(0 == dep && flag){
char buf[1024];
strcpy(buf, "/proc/");
strcat(buf, direntp->d_name);
strcat(buf, "/task");
listdir(buf, pid, head, 1, flag);
}
}
}
closedir(dir_ptr);
}
int build_tree(const char* path, process* head, int dep) {
const int size = 1024;
FILE* fp;
char ch[size];
strcpy(ch, "/proc/");
strcat(ch, path);
strcat(ch, "/status");
fp = fopen(ch, "r");
char pid[size], ppid[size], name[size];
while((fscanf(fp, "%s", ch)) != EOF) {
if (strcmp(ch, "Pid:") == 0) {
fscanf(fp, "%s", pid);
}
if (strcmp(ch, "PPid:") == 0) {
fscanf(fp, "%s", ppid);
}
if (strcmp(ch, "Name:") == 0) {
fscanf(fp, "%s", name);
}
}
ch[0] = 0;
if (dep) strcpy(ch, "{");
strcat(ch, name);
if (dep) strcat(ch, "}");
insert(head, create_p(ch, pid), ppid);
fclose(fp);
return 0;
}
void check_memory(void* p) {
if (p == NULL) {
perror("malloc error");
exit(0);
}
}
process* create_p(const char* pname, const char* pid) {
process* p = (process*)malloc(sizeof(process));
check_memory(p);
p->pname = (char*)malloc(sizeof(char) * (strlen(pname) + 1));
p->pid = (char*)malloc(sizeof(char) * (strlen(pid) + 1));
check_memory(p->pname);
check_memory(p->pid);
strcpy(p->pname, pname);
strcpy(p->pid, pid);
p->bro = NULL;
p->son = NULL;
return p;
}
// tools
int cmp(const char* a, const char *b) {
int tempa = atoi(a), tempb = atoi(b);
if (a == b) return 0;
if (a > b) return 1;
return -1;
}
void insert_node(process* head, process* node) {
/*help insert node function*/
process* cur = head->bro;
process* prv = head;
while (cur) {
int state = strcmp(head->pname, node->pname);
if ( 1 == state ||
(0 == state && -1 == cmp(head->pid, node->pname))
) {
prv->bro = node;
node->bro = cur;
return;
}
prv = cur;
cur = cur->bro;
}
prv->bro = node;
return;
}
int insert(process* head, process* node, const char* fpid) {
if (node == NULL) return -1;
if (head == NULL) return -1;
while (head) {
if (0 == strcmp(head->pid, fpid)) {
if (head->son)
insert_node(head->son, node);
else
head->son = node;
return 0;
} else {
if (0 == insert(head->son, node, fpid))
return 0;
}
head = head->bro;
}
return -1;
}
int print_tree(process* head, int len, int* buf, int flag) {
if (head == NULL) return -1;
while (head) {
printf("%s", head->pname);
if (flag) printf("(%s)", head->pid);
if (head->son) {
if(!head->son->bro) printf("\u2500\u2500\u2500");
else printf("\u2500\u252c\u2500");
int size = strlen(head->pname) + len + 3 + (flag * (strlen(head->pid) + 2));
if (head->son->bro) buf[size - 2] = 1;
print_tree(head->son, size, buf, flag);
}
head = head->bro;
if (head) {
printf("\n");
if (!head->bro) buf[len - 2] = 0;
for (int i = 0; i < len - 2; ++ i)
if (buf[i]) printf("\u2502");
else printf(" ");
if (!head->bro) printf("\u2514\u2500");
else printf("\u251c\u2500");
}
}
return 0;
}
346
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
