Katyusha's blog

1
#include <stdio.h>
2
#include <stdlib.h>
3
#include <dirent.h>
4
#include <ctype.h>
5
#include <string.h>
6
#include <unistd.h>
7
#include <sys/types.h>
8
#include <getopt.h>
9

10
static int read_comm(pid_t pid, char *buf, size_t n) {
11
    char path[64];
12
    snprintf(path, sizeof(path), "/proc/%d/comm", pid);
13
    FILE *f = fopen(path, "r");
14
    if (!f) return -1;
15
    if (!fgets(buf, (int)n, f)) { fclose(f); return -1; }
16
    buf[strcspn(buf, "\n")] = 0;
17
    fclose(f);
18
    return 0;
19
}
20

21
static int get_ppid_from_stat(pid_t pid, pid_t *ppid_out) {
22
    char path[64], line[4096];
23
    snprintf(path, sizeof(path), "/proc/%d/stat", pid);
24
    FILE *f = fopen(path, "r");
25
    if (!f) return -1;
26
    if (!fgets(line, sizeof(line), f)) { fclose(f); return -1; }
27
    fclose(f);
28

29
    int id, ppid;
30
    char comm[256], state;
31
    if (sscanf(line, "%d (%255[^)]) %c %d", &id, comm, &state, &ppid) != 4) return -1;
32
    *ppid_out = (pid_t)ppid;
33
    return 0;
34
}
35

36
void Version() {
37
    printf("------my_pstree------\n");
38
    printf("Version 1.0 generated by Katyusha & Codex\n");
39
}
40

41

42
#define MAXN 300005
43
struct process {
44
    pid_t pid, ppid;
45
    char *s;
46
};
47
typedef struct process process;
48
process p[MAXN];
49

50
int head[MAXN], ecnt;
51
struct edge {
52
    int to, nxt;
53
};
54
typedef struct edge edge;
55
edge E[MAXN];
56

57
void add(int u, int v) {
58
    E[++ecnt].to = v;
59
    E[ecnt].nxt = head[u];
60
    head[u] = ecnt;
61
}
62

63
int print_pid = 0, version = 0, print_sort = 0;
64

65
int cmp(process *x, process *y) {
66
    if (print_sort) {
67
        return (*x).pid < (*y).pid;
68
    }
69
    else {
70
        int c = strcmp((*x).s, (*y).s);
71
        if (c < 0) return 1;
72
        if (c > 0) return 0;
73
        return (*x).pid < (*y).pid;
74
    }
75
}
76

77
void swap(int *x, int *y) {
78
    int t = *x;
79
    *x = *y;
80
    *y = t;
81
}
82

83
void dfs(int u, int gap) {
84
    for (int i = 1; i <= gap; i++) putchar(' ');
85
    char buf[256], _buf[256];
86
    if (u != 0) {
87
        snprintf(_buf, sizeof(_buf), "(%d)", u);
88
        snprintf(buf, sizeof(buf), "%s%s", p[u].s, (print_pid)? _buf : "");
89
        printf("%s\n", buf);
90
    }
91
    int _gap = (u != 0) ? (gap + 3 + strlen(buf)) : 0;
92
    int cid[1024], cnt = 0;
93

94
    for (int i = head[u]; i ; i = E[i].nxt) {
95
        int v = E[i].to;
96
        cid[cnt++] = v;
97
    }
98
    while (1){
99
        int flag = 0;
100
        for (int i = 1; i < cnt; i++) {
101
            if (cmp(&p[cid[i]], &p[cid[i - 1]])) {
102
                swap(&cid[i - 1], &cid[i]);
103
                flag = 1;
104
            }
105
        }
106
        if (!flag) break;
107
    }
108
    for (int i = 0; i < cnt; i++) {
109
        dfs(cid[i], _gap);
110
    }
111
}
112

113
int main(int argc, char *argv[]) {
114

115
    int opt;
116

117
    static struct option option_long[] = {
118
        {"show-pids", no_argument, 0, 'p'},
119
        {"numeric-sort", no_argument, 0, 'n'},
120
        {"version", no_argument, 0, 'V'},
121
        {0, 0, 0, 0}
122
    };
123

124
    while ((opt = getopt_long(argc, argv, "pnV", option_long, NULL)) != -1) {
125
        switch (opt) {
126
            case 'p':
127
                print_pid = 1;
128
                break;
129
            case 'V':
130
                version = 1;
131
                break;
132
            case 'n':
133
                print_sort = 1;
134
                break;
135
            default:
136
                return 1;
137
        }
138
    }
139

140
    if (version) {
141
        Version();
142
        return 0;
143
    }
144

145
    DIR *d = opendir("/proc");
146
    if (!d) {
147
        perror("opendir /proc");
148
        return 1;
149
    }
150
    struct dirent *de;
151
    while ((de = readdir(d)) != NULL) {
152
        if (!isdigit((unsigned char)de->d_name[0])) continue;
153
        pid_t pid = (pid_t)atoi(de->d_name);
154
        p[pid].s = (char *)malloc(256 * sizeof(char));
155
        p[pid].pid = pid;
156
        int ret1 = read_comm(pid, p[pid].s, 256);
157
        int ret2 = get_ppid_from_stat(pid, &p[pid].ppid);
158
        if (ret1 == -1 || ret2 == -1) continue;
159
        add(p[pid].ppid, pid);
160
    }
161

162
    dfs(0, 0);
163
    for (int i = 0; i < MAXN; i++) free(p[i].s);
164
    closedir(d);
165
}