9 files changed, 514 insertions, 97 deletions

diff --git a/procps/Config.src b/procps/Config.src
index 1ff6dfd30..cf664eeb2 100644
--- a/procps/Config.src
+++ b/procps/Config.src
@@ -46,12 +46,6 @@ config KILLALL5
         default y
         depends on KILL
 
-config NMETER
-        bool "nmeter"
-        default y
-        help
-          Prints selected system stats continuously, one line per update.
-
 config PGREP
         bool "pgrep"
         default y
@@ -192,11 +186,12 @@ config FEATURE_TOPMEM
           Enable 's' in top (gives lots of memory info).
 
 config FEATURE_SHOW_THREADS
-        bool "Support for showing threads in ps/top"
+        bool "Support for showing threads in ps/pstree/top"
         default y
-        depends on PS || TOP
+        depends on PS || TOP || PSTREE
         help
-          Enables ps -T option and 'h' command in top
+          Enables the ps -T option, showing of threads in pstree,
+          and 'h' command in top.
 
 config UPTIME
         bool "uptime"
diff --git a/procps/Kbuild.src b/procps/Kbuild.src
index 791d65670..89b1cc094 100644
--- a/procps/Kbuild.src
+++ b/procps/Kbuild.src
@@ -11,7 +11,6 @@ lib-$(CONFIG_FREE)	+= free.o
 lib-$(CONFIG_FUSER)     += fuser.o
 lib-$(CONFIG_KILL)      += kill.o
 lib-$(CONFIG_ASH)       += kill.o  # used for built-in kill by ash
-lib-$(CONFIG_NMETER)    += nmeter.o
 lib-$(CONFIG_PGREP)     += pgrep.o
 lib-$(CONFIG_PKILL)     += pgrep.o
 lib-$(CONFIG_PIDOF)     += pidof.o
diff --git a/procps/iostat.c b/procps/iostat.c
index 5d829861e..a9ff13a05 100644
--- a/procps/iostat.c
+++ b/procps/iostat.c
@@ -18,14 +18,14 @@
 //config:         Report CPU and I/O statistics
 
 #include "libbb.h"
-#include <sys/utsname.h>        /* Need struct utsname */
+#include <sys/utsname.h>  /* Need struct utsname */
 
 //#define debug(fmt, ...) fprintf(stderr, fmt, ## __VA_ARGS__)
 #define debug(fmt, ...) ((void)0)
 
-#define MAX_DEVICE_NAME         12
-#define CURRENT                         0
-#define LAST                            1
+#define MAX_DEVICE_NAME 12
+#define CURRENT          0
+#define LAST             1
 
 #if 1
 typedef unsigned long long cputime_t;
@@ -327,7 +327,7 @@ static void do_disk_statistics(cputime_t itv)
         int i = 0;
         char buf[128];
         unsigned major, minor;
-        unsigned long wr_ops, dummy;    /* %*lu for suppres the conversion wouldn't work */
+        unsigned long wr_ops, dummy; /* %*lu for suppress the conversion wouldn't work */
         unsigned long long rd_sec_or_wr_ops;
         unsigned long long rd_sec_or_dummy, wr_sec_or_dummy, wr_sec;
         struct stats_dev sd;
diff --git a/procps/mpstat.c b/procps/mpstat.c
index f1a0b00b8..25efedf62 100644
--- a/procps/mpstat.c
+++ b/procps/mpstat.c
@@ -18,7 +18,7 @@
 //config:         Per-processor statistics
 
 #include "libbb.h"
-#include <sys/utsname.h>        /* struct utsname */
+#include <sys/utsname.h>  /* struct utsname */
 
 //#define debug(fmt, ...) fprintf(stderr, fmt, ## __VA_ARGS__)
 #define debug(fmt, ...) ((void)0)
@@ -634,7 +634,7 @@ static void get_irqs_from_interrupts(const char *fname,
         while (irq < irqs_per_cpu) {
                 /* Number of interrupts per CPU has changed */
                 ic = &per_cpu_stats[current][irq];
-                ic->irq_name[0] = '\0'; /* False interrupt */
+                ic->irq_name[0] = '\0'; /* False interrupt */
                 irq++;
         }
 }
@@ -820,7 +820,7 @@ static int get_irqcpu_nr(const char *f, int max_irqs)
         unsigned irq;
 
         fp = fopen_for_read(f);
-        if (!fp)                /* No interrupts file */
+        if (!fp)  /* No interrupts file */
                 return 0;
 
         linelen = INTERRUPTS_LINE + 16 * G.cpu_nr;
@@ -858,10 +858,10 @@ int mpstat_main(int UNUSED_PARAM argc, char **argv)
         char *opt_set_cpu;
         int i, opt;
         enum {
-                OPT_ALL    = 1 << 0,    /* -A */
-                OPT_INTS   = 1 << 1,    /* -I */
-                OPT_SETCPU = 1 << 2,    /* -P */
-                OPT_UTIL   = 1 << 3,    /* -u */
+                OPT_ALL    = 1 << 0, /* -A */
+                OPT_INTS   = 1 << 1, /* -I */
+                OPT_SETCPU = 1 << 2, /* -P */
+                OPT_UTIL   = 1 << 3, /* -u */
         };
 
         /* Dont buffer data if redirected to a pipe */
diff --git a/procps/nmeter.c b/procps/nmeter.c
index 7836a90d5..ac019eb53 100644
--- a/procps/nmeter.c
+++ b/procps/nmeter.c
@@ -6,6 +6,40 @@
  * Contact me: vda.linux@googlemail.com
  */
 
+//config:config NMETER
+//config:       bool "nmeter"
+//config:       default y
+//config:       help
+//config:         Prints selected system stats continuously, one line per update.
+
+//applet:IF_NMETER(APPLET(nmeter, _BB_DIR_USR_BIN, _BB_SUID_DROP))
+
+//kbuild:lib-$(CONFIG_NMETER) += nmeter.o
+
+//usage:#define nmeter_trivial_usage
+//usage:       "[-d MSEC] FORMAT_STRING"
+//usage:#define nmeter_full_usage "\n\n"
+//usage:       "Monitor system in real time"
+//usage:     "\n"
+//usage:     "\n -d MSEC        Milliseconds between updates (default:1000)"
+//usage:     "\n"
+//usage:     "\nFormat specifiers:"
+//usage:     "\n %Nc or %[cN]   Monitor CPU. N - bar size (default:10)"
+//usage:     "\n                (displays: S:system U:user N:niced D:iowait I:irq i:softirq)"
+//usage:     "\n %[niface]      Monitor network interface 'iface'"
+//usage:     "\n %m             Monitor allocated memory"
+//usage:     "\n %[mf]          Monitor free memory"
+//usage:     "\n %[mt]          Monitor total memory"
+//usage:     "\n %s             Monitor allocated swap"
+//usage:     "\n %f             Monitor number of used file descriptors"
+//usage:     "\n %Ni            Monitor total/specific IRQ rate"
+//usage:     "\n %x             Monitor context switch rate"
+//usage:     "\n %p             Monitor forks"
+//usage:     "\n %[pn]          Monitor # of processes"
+//usage:     "\n %b             Monitor block io"
+//usage:     "\n %Nt            Show time (with N decimal points)"
+//usage:     "\n %r             Print <cr> instead of <lf> at EOL"
+
 //TODO:
 // simplify code
 // /proc/locks
@@ -769,6 +803,7 @@ static void FAST_FUNC collect_info(s_stat *s)
 
 typedef s_stat* init_func(const char *param);
 
+// Deprecated %NNNd is to be removed, -d MSEC supersedes it
 static const char options[] ALIGN1 = "ncmsfixptbdr";
 static init_func *const init_functions[] = {
         init_if,
@@ -792,23 +827,28 @@ int nmeter_main(int argc UNUSED_PARAM, char **argv)
         s_stat *first = NULL;
         s_stat *last = NULL;
         s_stat *s;
+        char *opt_d;
         char *cur, *prev;
 
         INIT_G();
 
         xchdir("/proc");
 
-        if (!argv[1])
-                bb_show_usage();
-
         if (open_read_close("version", buf, sizeof(buf)-1) > 0) {
                 buf[sizeof(buf)-1] = '\0';
                 is26 = (strstr(buf, " 2.4.") == NULL);
         }
 
-        // Can use argv[1] directly, but this will mess up
+        if (getopt32(argv, "d:", &opt_d))
+                init_delay(opt_d);
+        argv += optind;
+
+        if (!argv[0])
+                bb_show_usage();
+
+        // Can use argv[0] directly, but this will mess up
         // parameters as seen by e.g. ps. Making a copy...
-        cur = xstrdup(argv[1]);
+        cur = xstrdup(argv[0]);
         while (1) {
                 char *param, *p;
                 prev = cur;
diff --git a/procps/powertop.c b/procps/powertop.c
index 250da817b..2f977a03b 100644
--- a/procps/powertop.c
+++ b/procps/powertop.c
@@ -169,7 +169,7 @@ static void read_cstate_counts(ullong *usage, ullong *duration)
                 if (len < 3 || len > BIG_SYSNAME_LEN)
                         continue;
 
-                sprintf(buf, "/proc/acpi/processor/%s/power", d->d_name);
+                sprintf(buf, "%s/%s/power", "/proc/acpi/processor", d->d_name);
                 fp = fopen_for_read(buf);
                 if (!fp)
                         continue;
@@ -321,31 +321,18 @@ static void process_irq_counts(void)
                 /*  0:  143646045  153901007   IO-APIC-edge      timer
                  *   ^
                  */
+                *p = '\0';
                 /* Deal with non-maskable interrupts -- make up fake numbers */
-                nr = -1;
-                if (buf[0] != ' ' && !isdigit(buf[0])) {
-//TODO: optimize
-                        if (strncmp(buf, "NMI:", 4) == 0)
-                                nr = 20000;
-                        if (strncmp(buf, "RES:", 4) == 0)
-                                nr = 20001;
-                        if (strncmp(buf, "CAL:", 4) == 0)
-                                nr = 20002;
-                        if (strncmp(buf, "TLB:", 4) == 0)
-                                nr = 20003;
-                        if (strncmp(buf, "TRM:", 4) == 0)
-                                nr = 20004;
-                        if (strncmp(buf, "THR:", 4) == 0)
-                                nr = 20005;
-                        if (strncmp(buf, "SPU:", 4) == 0)
-                                nr = 20006;
+                nr = index_in_strings("NMI\0RES\0CAL\0TLB\0TRM\0THR\0SPU\0", buf);
+                if (nr >= 0) {
+                        nr += 20000;
                 } else {
                         /* bb_strtou doesn't eat leading spaces, using strtoul */
+                        errno = 0;
                         nr = strtoul(buf, NULL, 10);
+                        if (errno)
+                                continue;
                 }
-                if (nr == -1)
-                        continue;
-
                 p++;
                 /*  0:  143646045  153901007   IO-APIC-edge      timer
                  *    ^
@@ -412,6 +399,7 @@ static NOINLINE int process_timer_stats(void)
         buf[0] = '\0';
         totalticks = 0;
 
+        n = 0;
         fp = NULL;
         if (!G.cant_enable_timer_stats)
                 fp = fopen_for_read("/proc/timer_stats");
@@ -430,33 +418,41 @@ static NOINLINE int process_timer_stats(void)
                 while (fgets(buf, sizeof(buf), fp)) {
                         const char *count, *process, *func;
                         char *p;
-                        int cnt;
+                        int idx;
+                        unsigned cnt;
 
                         count = skip_whitespace(buf);
                         p = strchr(count, ',');
                         if (!p)
                                 continue;
                         *p++ = '\0';
-                        if (strcmp(strchrnul(count, ' '), " total events") == 0)
+                        cnt = bb_strtou(count, NULL, 10);
+                        if (strcmp(skip_non_whitespace(count), " total events") == 0) {
+#if ENABLE_FEATURE_POWERTOP_PROCIRQ
+                                n = cnt / G.total_cpus;
+                                if (n > 0 && n < G.interrupt_0) {
+                                        sprintf(line, "    <interrupt> : %s", "extra timer interrupt");
+                                        save_line(line, G.interrupt_0 - n);
+                                }
+#endif
                                 break;
-                        p = skip_whitespace(p); /* points to pid */
-
-/* Find char ' ', then eat remaining spaces */
-#define ADVANCE(p) do {           \
-        (p) = strchr((p), ' ');   \
-        if (!(p))                 \
-                continue;         \
-        *(p) = '\0';              \
-        (p)++;                    \
-        (p) = skip_whitespace(p); \
-} while (0)
-                        /* Get process name */
-                        ADVANCE(p);
-                        process = p;
-                        /* Get function */
-                        ADVANCE(p);
+                        }
+                        if (strchr(count, 'D'))
+                                continue; /* deferred */
+                        p = skip_whitespace(p); /* points to pid now */
+                        process = NULL;
+ get_func_name:
+                        p = strchr(p, ' ');
+                        if (!p)
+                                continue;
+                        *p++ = '\0';
+                        p = skip_whitespace(p);
+                        if (process == NULL) {
+                                process = p;
+                                goto get_func_name;
+                        }
                         func = p;
-#undef ADVANCE
+
                         //if (strcmp(process, "swapper") == 0
                         // && strcmp(func, "hrtimer_start_range_ns (tick_sched_timer)\n") == 0
                         //) {
@@ -471,45 +467,26 @@ static NOINLINE int process_timer_stats(void)
                         //if (strcmp(process, "powertop") == 0)
                         //      continue;
 
-                        if (strcmp(process, "insmod") == 0)
-                                process = "[kernel module]";
-                        if (strcmp(process, "modprobe") == 0)
-                                process = "[kernel module]";
-                        if (strcmp(process, "swapper") == 0)
-                                process = "<kernel core>";
+                        idx = index_in_strings("insmod\0modprobe\0swapper\0", process);
+                        if (idx != -1) {
+                                process = idx < 2 ? "[kernel module]" : "<kernel core>";
+                        }
 
                         strchrnul(p, '\n')[0] = '\0';
 
-                        {
-                                char *tmp;
-                                cnt = bb_strtoull(count, &tmp, 10);
-                                p = tmp;
-                        }
-                        while (*p != '\0') {
-                                if (*p++ == 'D') /* deferred */
-                                        goto skip;
-                        }
+                        // 46D\01136\0kondemand/1\0do_dbs_timer (delayed_work_timer_fn)
+                        // ^          ^            ^
+                        // count      process      func
 
                         //if (strchr(process, '['))
                                 sprintf(line, "%15.15s : %s", process, func);
                         //else
                         //      sprintf(line, "%s", process);
                         save_line(line, cnt);
- skip: ;
                 }
                 fclose(fp);
         }
 
-        n = 0;
-#if ENABLE_FEATURE_POWERTOP_PROCIRQ
-        if (strstr(buf, "total events")) {
-                n = bb_strtoull(buf, NULL, 10) / G.total_cpus;
-                if (n > 0 && n < G.interrupt_0) {
-                        sprintf(line, "    <interrupt> : %s", "extra timer interrupt");
-                        save_line(line, G.interrupt_0 - n);
-                }
-        }
-#endif
         return n;
 }
 
@@ -566,7 +543,7 @@ static NOINLINE void print_intel_cstates(void)
                 if (!isdigit(d->d_name[3]))
                         continue;
 
-                len = sprintf(fname, "/sys/devices/system/cpu/%s/cpuidle", d->d_name);
+                len = sprintf(fname, "%s/%s/cpuidle", "/sys/devices/system/cpu", d->d_name);
                 dir = opendir(fname);
                 if (!dir)
                         continue;
@@ -635,7 +612,7 @@ static NOINLINE void print_intel_cstates(void)
         bb_putchar('\n');
 }
 #else
-# define print_intel_cstates(void) ((void)0)
+# define print_intel_cstates() ((void)0)
 #endif
 
 static void show_timerstats(void)
diff --git a/procps/pstree.c b/procps/pstree.c
new file mode 100644
index 000000000..180d0939a
--- /dev/null
+++ b/procps/pstree.c
@@ -0,0 +1,406 @@
+/*
+ * 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:     "\nOptions:"
+//usage:     "\n        -p      Show pids"
+
+#include "libbb.h"
+
+#define PROC_BASE "/proc"
+
+#define OPT_PID  (1 << 0)
+
+struct child;
+
+typedef struct proc {
+        char comm[COMM_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);
+}
+
+static void handle_thread(const char *comm, pid_t pid, pid_t ppid, uid_t uid)
+{
+        char threadname[COMM_LEN + 2];
+        sprintf(threadname, "{%.*s}", COMM_LEN - 2, comm);
+        add_proc(threadname, pid, ppid, uid/*, 1*/);
+}
+
+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();
+
+        get_terminal_width_height(0, &G.output_width, NULL);
+
+        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;
+}
diff --git a/procps/smemcap.c b/procps/smemcap.c
index 196c91f54..200df6795 100644
--- a/procps/smemcap.c
+++ b/procps/smemcap.c
@@ -20,7 +20,7 @@
 //config:         a memory usage statistic tool.
 
 #include "libbb.h"
-#include "unarchive.h"
+#include "archive.h"
 
 struct fileblock {
         struct fileblock *next;
diff --git a/procps/sysctl.c b/procps/sysctl.c
index 20b372c54..aba966e7f 100644
--- a/procps/sysctl.c
+++ b/procps/sysctl.c
@@ -91,7 +91,7 @@ static int sysctl_act_on_setting(char *setting)
                         retval = EXIT_FAILURE;
                         goto end;
                 }
-                value = cptr + 1;       /* point to the value in name=value */
+                value = cptr + 1;  /* point to the value in name=value */
                 if (setting == cptr || !*value) {
                         bb_error_msg("error: malformed setting '%s'", outname);
                         retval = EXIT_FAILURE;