| /* |
| * pstree.c - display process tree |
| * |
| * Copyright (C) 1993-2002 Werner Almesberger |
| * Copyright (C) 2002-2009 Craig Small |
| * Copyright (C) 2010 Lauri Kasanen |
| * |
| * Based on pstree (PSmisc) 22.13. |
| * |
| * Licensed under GPLv2, see file LICENSE in this source tree. |
| */ |
| |
| //config:config PSTREE |
| //config: bool "pstree" |
| //config: default y |
| //config: help |
| //config: Display a tree of processes. |
| |
| //applet:IF_PSTREE(APPLET(pstree, BB_DIR_USR_BIN, BB_SUID_DROP)) |
| |
| //kbuild:lib-$(CONFIG_PSTREE) += pstree.o |
| |
| //usage:#define pstree_trivial_usage |
| //usage: "[-p] [PID|USER]" |
| //usage:#define pstree_full_usage "\n\n" |
| //usage: "Display process tree, optionally start from USER or PID\n" |
| //usage: "\n -p Show pids" |
| |
| #include "libbb.h" |
| |
| #define PROC_BASE "/proc" |
| |
| #define OPT_PID (1 << 0) |
| |
| struct child; |
| |
| #ifdef ENABLE_FEATURE_SHOW_THREADS |
| /* For threads, we add {...} around the comm, so we need two extra bytes */ |
| # define COMM_DISP_LEN (COMM_LEN + 2) |
| #else |
| # define COMM_DISP_LEN COMM_LEN |
| #endif |
| |
| typedef struct proc { |
| char comm[COMM_DISP_LEN + 1]; |
| // char flags; - unused, delete? |
| pid_t pid; |
| uid_t uid; |
| struct child *children; |
| struct proc *parent; |
| struct proc *next; |
| } PROC; |
| |
| /* For flags above */ |
| //#define PFLAG_THREAD 0x01 |
| |
| typedef struct child { |
| PROC *child; |
| struct child *next; |
| } CHILD; |
| |
| #define empty_2 " " |
| #define branch_2 "|-" |
| #define vert_2 "| " |
| #define last_2 "`-" |
| #define single_3 "---" |
| #define first_3 "-+-" |
| |
| struct globals { |
| /* 0-based. IOW: the number of chars we printed on current line */ |
| unsigned cur_x; |
| unsigned output_width; |
| |
| /* The buffers will be dynamically increased in size as needed */ |
| unsigned capacity; |
| unsigned *width; |
| uint8_t *more; |
| |
| PROC *list; |
| |
| smallint dumped; /* used by dump_by_user */ |
| }; |
| #define G (*ptr_to_globals) |
| #define INIT_G() do { \ |
| SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \ |
| } while (0) |
| |
| |
| /* |
| * Allocates additional buffer space for width and more as needed. |
| * The first call will allocate the first buffer. |
| * |
| * bufindex the index that will be used after the call to this function. |
| */ |
| static void ensure_buffer_capacity(int bufindex) |
| { |
| if (bufindex >= G.capacity) { |
| G.capacity += 0x100; |
| G.width = xrealloc(G.width, G.capacity * sizeof(G.width[0])); |
| G.more = xrealloc(G.more, G.capacity * sizeof(G.more[0])); |
| } |
| } |
| |
| /* NB: this function is never called with "bad" chars |
| * (control chars or chars >= 0x7f) |
| */ |
| static void out_char(char c) |
| { |
| G.cur_x++; |
| if (G.cur_x > G.output_width) |
| return; |
| if (G.cur_x == G.output_width) |
| c = '+'; |
| putchar(c); |
| } |
| |
| /* NB: this function is never called with "bad" chars |
| * (control chars or chars >= 0x7f) |
| */ |
| static void out_string(const char *str) |
| { |
| while (*str) |
| out_char(*str++); |
| } |
| |
| static void out_newline(void) |
| { |
| putchar('\n'); |
| G.cur_x = 0; |
| } |
| |
| static PROC *find_proc(pid_t pid) |
| { |
| PROC *walk; |
| |
| for (walk = G.list; walk; walk = walk->next) |
| if (walk->pid == pid) |
| break; |
| |
| return walk; |
| } |
| |
| static PROC *new_proc(const char *comm, pid_t pid, uid_t uid) |
| { |
| PROC *new = xzalloc(sizeof(*new)); |
| |
| strcpy(new->comm, comm); |
| new->pid = pid; |
| new->uid = uid; |
| new->next = G.list; |
| |
| G.list = new; |
| return G.list; |
| } |
| |
| static void add_child(PROC *parent, PROC *child) |
| { |
| CHILD *new, **walk; |
| int cmp; |
| |
| new = xmalloc(sizeof(*new)); |
| |
| new->child = child; |
| for (walk = &parent->children; *walk; walk = &(*walk)->next) { |
| cmp = strcmp((*walk)->child->comm, child->comm); |
| if (cmp > 0) |
| break; |
| if (cmp == 0 && (*walk)->child->uid > child->uid) |
| break; |
| } |
| new->next = *walk; |
| *walk = new; |
| } |
| |
| static void add_proc(const char *comm, pid_t pid, pid_t ppid, |
| uid_t uid /*, char isthread*/) |
| { |
| PROC *this, *parent; |
| |
| this = find_proc(pid); |
| if (!this) |
| this = new_proc(comm, pid, uid); |
| else { |
| strcpy(this->comm, comm); |
| this->uid = uid; |
| } |
| |
| if (pid == ppid) |
| ppid = 0; |
| // if (isthread) |
| // this->flags |= PFLAG_THREAD; |
| |
| parent = find_proc(ppid); |
| if (!parent) |
| parent = new_proc("?", ppid, 0); |
| |
| add_child(parent, this); |
| this->parent = parent; |
| } |
| |
| static int tree_equal(const PROC *a, const PROC *b) |
| { |
| const CHILD *walk_a, *walk_b; |
| |
| if (strcmp(a->comm, b->comm) != 0) |
| return 0; |
| if ((option_mask32 /*& OPT_PID*/) && a->pid != b->pid) |
| return 0; |
| |
| for (walk_a = a->children, walk_b = b->children; |
| walk_a && walk_b; |
| walk_a = walk_a->next, walk_b = walk_b->next |
| ) { |
| if (!tree_equal(walk_a->child, walk_b->child)) |
| return 0; |
| } |
| |
| return !(walk_a || walk_b); |
| } |
| |
| static int out_args(const char *mystr) |
| { |
| const char *here; |
| int strcount = 0; |
| char tmpstr[5]; |
| |
| for (here = mystr; *here; here++) { |
| if (*here == '\\') { |
| out_string("\\\\"); |
| strcount += 2; |
| } else if (*here >= ' ' && *here < 0x7f) { |
| out_char(*here); |
| strcount++; |
| } else { |
| sprintf(tmpstr, "\\%03o", (unsigned char) *here); |
| out_string(tmpstr); |
| strcount += 4; |
| } |
| } |
| |
| return strcount; |
| } |
| |
| static void |
| dump_tree(PROC *current, int level, int rep, int leaf, int last, int closing) |
| { |
| CHILD *walk, *next, **scan; |
| int lvl, i, add, offset, count, comm_len, first; |
| char tmp[sizeof(int)*3 + 4]; |
| |
| if (!current) |
| return; |
| |
| if (!leaf) { |
| for (lvl = 0; lvl < level; lvl++) { |
| i = G.width[lvl] + 1; |
| while (--i >= 0) |
| out_char(' '); |
| |
| if (lvl == level - 1) { |
| if (last) { |
| out_string(last_2); |
| } else { |
| out_string(branch_2); |
| } |
| } else { |
| if (G.more[lvl + 1]) { |
| out_string(vert_2); |
| } else { |
| out_string(empty_2); |
| } |
| } |
| } |
| } |
| |
| add = 0; |
| if (rep > 1) { |
| add += sprintf(tmp, "%d*[", rep); |
| out_string(tmp); |
| } |
| comm_len = out_args(current->comm); |
| if (option_mask32 /*& OPT_PID*/) { |
| comm_len += sprintf(tmp, "(%d)", (int)current->pid); |
| out_string(tmp); |
| } |
| offset = G.cur_x; |
| |
| if (!current->children) { |
| while (closing--) |
| out_char(']'); |
| out_newline(); |
| } |
| ensure_buffer_capacity(level); |
| G.more[level] = !last; |
| |
| G.width[level] = comm_len + G.cur_x - offset + add; |
| if (G.cur_x >= G.output_width) { |
| //out_string(first_3); - why? it won't print anything |
| //out_char('+'); |
| out_newline(); |
| return; |
| } |
| |
| first = 1; |
| for (walk = current->children; walk; walk = next) { |
| count = 0; |
| next = walk->next; |
| scan = &walk->next; |
| while (*scan) { |
| if (!tree_equal(walk->child, (*scan)->child)) |
| scan = &(*scan)->next; |
| else { |
| if (next == *scan) |
| next = (*scan)->next; |
| count++; |
| *scan = (*scan)->next; |
| } |
| } |
| if (first) { |
| out_string(next ? first_3 : single_3); |
| first = 0; |
| } |
| |
| dump_tree(walk->child, level + 1, count + 1, |
| walk == current->children, !next, |
| closing + (count ? 1 : 0)); |
| } |
| } |
| |
| static void dump_by_user(PROC *current, uid_t uid) |
| { |
| const CHILD *walk; |
| |
| if (!current) |
| return; |
| |
| if (current->uid == uid) { |
| if (G.dumped) |
| putchar('\n'); |
| dump_tree(current, 0, 1, 1, 1, 0); |
| G.dumped = 1; |
| return; |
| } |
| for (walk = current->children; walk; walk = walk->next) |
| dump_by_user(walk->child, uid); |
| } |
| |
| #if ENABLE_FEATURE_SHOW_THREADS |
| static void handle_thread(const char *comm, pid_t pid, pid_t ppid, uid_t uid) |
| { |
| char threadname[COMM_DISP_LEN + 1]; |
| sprintf(threadname, "{%.*s}", (int)sizeof(threadname) - 3, comm); |
| add_proc(threadname, pid, ppid, uid/*, 1*/); |
| } |
| #endif |
| |
| static void mread_proc(void) |
| { |
| procps_status_t *p = NULL; |
| pid_t parent = 0; |
| int flags = PSSCAN_COMM | PSSCAN_PID | PSSCAN_PPID | PSSCAN_UIDGID | PSSCAN_TASKS; |
| |
| while ((p = procps_scan(p, flags)) != NULL) { |
| #if ENABLE_FEATURE_SHOW_THREADS |
| if (p->pid != p->main_thread_pid) |
| handle_thread(p->comm, p->pid, parent, p->uid); |
| else |
| #endif |
| { |
| add_proc(p->comm, p->pid, p->ppid, p->uid/*, 0*/); |
| parent = p->pid; |
| } |
| } |
| } |
| |
| int pstree_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE; |
| int pstree_main(int argc UNUSED_PARAM, char **argv) |
| { |
| pid_t pid = 1; |
| long uid = 0; |
| |
| INIT_G(); |
| |
| G.output_width = get_terminal_width(0); |
| |
| opt_complementary = "?1"; |
| getopt32(argv, "p"); |
| argv += optind; |
| |
| if (argv[0]) { |
| if (argv[0][0] >= '0' && argv[0][0] <= '9') { |
| pid = xatoi(argv[0]); |
| } else { |
| uid = xuname2uid(argv[0]); |
| } |
| } |
| |
| mread_proc(); |
| |
| if (!uid) |
| dump_tree(find_proc(pid), 0, 1, 1, 1, 0); |
| else { |
| dump_by_user(find_proc(1), uid); |
| if (!G.dumped) { |
| bb_error_msg_and_die("no processes found"); |
| } |
| } |
| |
| if (ENABLE_FEATURE_CLEAN_UP) { |
| free(G.width); |
| free(G.more); |
| } |
| return 0; |
| } |