52 files changed, 1265 insertions, 736 deletions
diff --git a/Makefile.custom b/Makefile.custom
index e2f6d1c2f..36170de8a 100644
--- a/Makefile.custom
+++ b/Makefile.custom
@@ -156,12 +156,12 @@ docs/busybox.pod: $(srctree)/docs/busybox_header.pod \
 docs/BusyBox.txt: docs/busybox.pod
        $(disp_doc)
        $(Q)-mkdir -p docs
-        $(Q)-pod2text $< > $@
+        $(Q)-pod2text --quotes=none $< > $@
 docs/busybox.1: docs/busybox.pod
        $(disp_doc)
        $(Q)-mkdir -p docs
-        $(Q)-pod2man --center=busybox --release="version $(KERNELVERSION)" $< > $@
+        $(Q)-pod2man --quotes=none --center=busybox --release="version $(KERNELVERSION)" $< > $@
 docs/BusyBox.html: docs/busybox.net/BusyBox.html
        $(disp_doc)
diff --git a/NOFORK_NOEXEC.lst b/NOFORK_NOEXEC.lst
index 055f9fb24..a000de45b 100644
--- a/NOFORK_NOEXEC.lst
+++ b/NOFORK_NOEXEC.lst
@@ -336,6 +336,7 @@ setuidgid - noexec. spawner
 sha1sum - noexec. runner
 sha256sum - noexec. runner
 sha3sum - noexec. runner
+sha384sum - noexec. runner
 sha512sum - noexec. runner
 showkey - interactive, longterm
 shred - runner
diff --git a/applets/usage_pod.c b/applets/usage_pod.c
index 9e6d3f0ee..2c177be90 100644
--- a/applets/usage_pod.c
+++ b/applets/usage_pod.c
@@ -67,30 +67,37 @@ int main(void)
                }
                if (col == 0) {
                        col = 6;
-                        printf("\t");
                } else {
                        printf(", ");
                }
-                printf("%s", usage_array[i].aname);
+                if (usage_array[i].usage[0] != NOUSAGE_STR[0]) {
+                        /*
+                         * If the applet usage string will be included in the final document
+                         * optimistically link to its header (which is just the applet name).
+                         */
+                        printf("L<C<%1$s>|/\"%1$s\">", usage_array[i].aname);
+                } else {
+                        /* Without a usage string, just output the applet name with no link. */
+                        printf("C<%s>", usage_array[i].aname);
+                }
                col += len2;
        }
        printf("\n\n");
        printf("=head1 COMMAND DESCRIPTIONS\n\n");
-        printf("=over 4\n\n");
        for (i = 0; i < num_messages; i++) {
                if (usage_array[i].aname[0] >= 'a' && usage_array[i].aname[0] <= 'z'
                 && usage_array[i].usage[0] != NOUSAGE_STR[0]
                ) {
-                        printf("=item B<%s>\n\n", usage_array[i].aname);
+                        /* This is the heading that will be linked from the command list. */
+                        printf("=head2 %s\n\n", usage_array[i].aname);
                        if (usage_array[i].usage[0])
                                printf("%s %s\n\n", usage_array[i].aname, usage_array[i].usage);
                        else
                                printf("%s\n\n", usage_array[i].aname);
                }
        }
-        printf("=back\n\n");
        return 0;
 }
diff --git a/configs/mingw64a_defconfig b/configs/mingw64a_defconfig
index f23dab438..d17737721 100644
--- a/configs/mingw64a_defconfig
+++ b/configs/mingw64a_defconfig
@@ -121,7 +121,7 @@ CONFIG_FEATURE_BUFFERS_USE_MALLOC=y
 # CONFIG_FEATURE_BUFFERS_GO_ON_STACK is not set
 # CONFIG_FEATURE_BUFFERS_GO_IN_BSS is not set
 CONFIG_PASSWORD_MINLEN=6
-# CONFIG_FEATURE_USE_CNG_API is not set
+CONFIG_FEATURE_USE_CNG_API=y
 CONFIG_MD5_SMALL=1
 CONFIG_SHA1_SMALL=3
 # CONFIG_SHA1_HWACCEL is not set
diff --git a/coreutils/date.c b/coreutils/date.c
index 3a89b6caf..ef482af1b 100644
--- a/coreutils/date.c
+++ b/coreutils/date.c
@@ -289,7 +289,7 @@ int date_main(int argc UNUSED_PARAM, char **argv)
                /* if setting time, set it */
                if ((opt & OPT_SET) && clock_settime(CLOCK_REALTIME, &ts) < 0) {
-                        bb_simple_perror_msg("can't set date");
+                        bb_simple_perror_msg_and_die("can't set date");
                }
        }
diff --git a/coreutils/ls.c b/coreutils/ls.c
index 5d2e96a1e..2153554e8 100644
--- a/coreutils/ls.c
+++ b/coreutils/ls.c
@@ -129,6 +129,8 @@
 //usage:     "\n        -F      Append indicator (one of */=@|) to names"
 //usage:        )
 //usage:     "\n        -l      Long format"
+////usage:     "\n      -g      Long format without group column"
+////TODO: support -G too ("suppress owner column", GNUism)
 //usage:     "\n        -i      List inode numbers"
 //usage:     "\n        -n      List numeric UIDs and GIDs instead of names"
 //usage:     "\n        -s      List allocated blocks"
@@ -162,6 +164,8 @@
 //usage:        IF_FEATURE_LS_WIDTH(
 //usage:     "\n        -w N    Format N columns wide"
 //usage:        )
+////usage:     "\n      -Q      Double-quote names"
+////usage:     "\n      -q      Replace unprintable chars with '?'"
 //usage:        IF_FEATURE_LS_COLOR(
 //usage:     "\n        --color[={always,never,auto}]"
 //usage:        )
@@ -199,27 +203,47 @@ SPLIT_SUBDIR    = 2,
 /* -Cadi1l  Std options, busybox always supports */
 /* -gnsxA   Std options, busybox always supports */
-/* -Q       GNU option, busybox always supports */
+/* -Q       GNU option, busybox always supports:  */
-/* -k       Std option, busybox always supports (by ignoring) */
+/*          -Q, --quote-name                     */
-/*          It means "for -s, show sizes in kbytes" */
+/*          enclose entry names in double quotes */
-/*          Seems to only affect "POSIXLY_CORRECT=1 ls -sk" */
-/*          since otherwise -s shows kbytes anyway */
 /* -LHRctur Std options, busybox optionally supports */
 /* -Fp      Std options, busybox optionally supports */
 /* -SXvhTw  GNU options, busybox optionally supports */
 /* -T WIDTH Ignored (we don't use tabs on output) */
 /* -Z       SELinux mandated option, busybox optionally supports */
+/* -q       Std option, busybox always supports: */
+/*      https://pubs.opengroup.org/onlinepubs/9699919799/utilities/ls.html: */
+/*      Force each instance of non-printable filename characters and        */
+/*      <tab> characters to be written as the <question-mark> ('?')         */
+/*      character. Implementations may provide this option by default       */
+/*      if the output is to a terminal device.                              */
+/* -k       Std option, busybox always supports (by ignoring) */
+/*          It means "for -s, show sizes in kbytes" */
+/*          Seems to only affect "POSIXLY_CORRECT=1 ls -sk" */
+/*          since otherwise -s shows kbytes anyway */
 #define ls_options \
-        "Cadi1lgnsxAk"       /* 12 opts, total 12 */ \
+        "Cadi1lgnsxA"        /* 11 opts, total 11 */ \
-        IF_FEATURE_LS_FILETYPES("Fp")    /* 2, 14 */ \
+        IF_FEATURE_LS_FILETYPES("Fp")    /* 2, 13 */ \
-        IF_FEATURE_LS_RECURSIVE("R")     /* 1, 15 */ \
+        IF_FEATURE_LS_RECURSIVE("R")     /* 1, 14 */ \
-        IF_SELINUX("Z")                  /* 1, 16 */ \
+        IF_SELINUX("Z")                  /* 1, 15 */ \
-        "Q"                              /* 1, 17 */ \
+        "Q"                              /* 1, 16 */ \
-        IF_FEATURE_LS_TIMESTAMPS("ctu")  /* 3, 20 */ \
+        IF_FEATURE_LS_TIMESTAMPS("ctu")  /* 3, 19 */ \
-        IF_FEATURE_LS_SORTFILES("SXrv")  /* 4, 24 */ \
+        IF_FEATURE_LS_SORTFILES("SXrv")  /* 4, 23 */ \
-        IF_FEATURE_LS_FOLLOWLINKS("LH")  /* 2, 26 */ \
+        IF_FEATURE_LS_FOLLOWLINKS("LH")  /* 2, 25 */ \
-        IF_FEATURE_HUMAN_READABLE("h")   /* 1, 27 */ \
+        IF_FEATURE_HUMAN_READABLE("h")   /* 1, 26 */ \
-        IF_FEATURE_LS_WIDTH("T:w:")      /* 2, 29 */
+        IF_FEATURE_LS_WIDTH("T:w:")      /* 2, 28 */ \
+        IF_LONG_OPTS("\xff")             /* 1, 29 */ \
+        IF_LONG_OPTS("\xfe")             /* 1, 30 */ \
+        IF_LONG_OPTS("\xfd")             /* 1, 31 */ \
+        "qk"                             /* 2, 33 */
+#if ENABLE_LONG_OPTS
+static const char ls_longopts[] ALIGN1 =
+        "full-time\0" No_argument "\xff"
+        "group-directories-first\0" No_argument "\xfe"
+        IF_FEATURE_LS_COLOR("color\0" Optional_argument "\xfd")
+;
+#endif
 enum {
        OPT_C = (1 << 0),
@@ -233,29 +257,31 @@ enum {
        OPT_s = (1 << 8),
        OPT_x = (1 << 9),
        OPT_A = (1 << 10),
-        //OPT_k = (1 << 11),
-        OPTBIT_F = 12,
+        OPTBIT_F = 11,
-        OPTBIT_p, /* 13 */
+        OPTBIT_p, /* 12 */
        OPTBIT_R = OPTBIT_F + 2 * ENABLE_FEATURE_LS_FILETYPES,
        OPTBIT_Z = OPTBIT_R + 1 * ENABLE_FEATURE_LS_RECURSIVE,
        OPTBIT_Q = OPTBIT_Z + 1 * ENABLE_SELINUX,
-        OPTBIT_c, /* 17 */
+        OPTBIT_c, /* 16 */
-        OPTBIT_t, /* 18 */
+        OPTBIT_t, /* 17 */
-        OPTBIT_u, /* 19 */
+        OPTBIT_u, /* 18 */
        OPTBIT_S = OPTBIT_c + 3 * ENABLE_FEATURE_LS_TIMESTAMPS,
-        OPTBIT_X, /* 21 */
+        OPTBIT_X, /* 20 */
-        OPTBIT_r, /* 22 */
+        OPTBIT_r, /* 21 */
-        OPTBIT_v, /* 23 */
+        OPTBIT_v, /* 22 */
        OPTBIT_L = OPTBIT_S + 4 * ENABLE_FEATURE_LS_SORTFILES,
-        OPTBIT_H, /* 25 */
+        OPTBIT_H, /* 24 */
        OPTBIT_h = OPTBIT_L + 2 * ENABLE_FEATURE_LS_FOLLOWLINKS,
        OPTBIT_T = OPTBIT_h + 1 * ENABLE_FEATURE_HUMAN_READABLE,
-        OPTBIT_w, /* 28 */
+        OPTBIT_w, /* 27 */
        OPTBIT_full_time = OPTBIT_T + 2 * ENABLE_FEATURE_LS_WIDTH,
        OPTBIT_dirs_first,
-        OPTBIT_color, /* 31 */
+        OPTBIT_color, /* 30 */
-        /* with long opts, we use all 32 bits */
+        OPTBIT_q = OPTBIT_color + 1, /* 31 */
+        OPTBIT_k = OPTBIT_q + 1, /* 32 */
+        /* with all options enabled, we use all 32 bits and even one extra bit! */
+        /* this works because -k is ignored, and getopt32 allows such "ignore" options past 31th bit */
        OPT_F = (1 << OPTBIT_F) * ENABLE_FEATURE_LS_FILETYPES,
        OPT_p = (1 << OPTBIT_p) * ENABLE_FEATURE_LS_FILETYPES,
@@ -277,6 +303,8 @@ enum {
        OPT_full_time  = (1 << OPTBIT_full_time ) * ENABLE_LONG_OPTS,
        OPT_dirs_first = (1 << OPTBIT_dirs_first) * ENABLE_LONG_OPTS,
        OPT_color      = (1 << OPTBIT_color     ) * ENABLE_FEATURE_LS_COLOR,
+        OPT_q = (1 << OPTBIT_q),
+        //-k is ignored: OPT_k = (1 << OPTBIT_k),
 };
 /*
@@ -333,6 +361,7 @@ struct globals {
 #endif
        smallint exit_code;
        smallint show_dirname;
+        smallint tty_out;
 #if ENABLE_FEATURE_LS_WIDTH
        unsigned terminal_width;
 # define G_terminal_width (G.terminal_width)
@@ -353,16 +382,21 @@ struct globals {
        setup_common_bufsiz(); \
        /* we have to zero it out because of NOEXEC */ \
        memset(&G, 0, sizeof(G)); \
-        IF_FEATURE_LS_WIDTH(G_terminal_width = TERMINAL_WIDTH;) \
+        IF_FEATURE_LS_WIDTH(G_terminal_width = ~0U;) \
        IF_FEATURE_LS_TIMESTAMPS(time(&G.current_time_t);) \
 } while (0)
 #define ESC "\033"
+static int G_isatty(void)
+{
+        if (!G.tty_out) /* not known yet? */
+                G.tty_out = isatty(STDOUT_FILENO) + 1;
+        return (G.tty_out == 2);
+}
 /*** Output code ***/
 /* FYI type values: 1:fifo 2:char 4:dir 6:blk 8:file 10:link 12:socket
 * (various wacky OSes: 13:Sun door 14:BSD whiteout 5:XENIX named file
 *  3/7:multiplexed char/block device)
@@ -425,56 +459,93 @@ static char append_char(mode_t mode)
 }
 #endif
+/* Return the number of used columns.
+ * Note that only columnar output uses return value.
+ * -l and -1 modes don't care.
+ * coreutils 7.2 also supports:
+ * ls -b (--escape) = octal escapes (although it doesn't look like working)
+ * ls -N (--literal) = not escape at all
+ */
 static unsigned calc_name_len(const char *name)
 {
        unsigned len;
        uni_stat_t uni_stat;
-        // TODO: quote tab as \t, etc, if -Q
+        if (!(option_mask32 & (OPT_q|OPT_Q)))
-        name = printable_string2(&uni_stat, name);
+                return strlen(name);
        if (!(option_mask32 & OPT_Q)) {
+                /* the most likely branch: "ls" to tty (it auto-enables -q behavior) */
+                printable_string2(&uni_stat, name);
                return uni_stat.unicode_width;
        }
-        len = 2 + uni_stat.unicode_width;
+        len = 2 + strlen(name);
        while (*name) {
+                unsigned char ch = (unsigned char)*name;
+                if (ch < ' ' || ch > 0x7e) {
+                        ch -= 7;
+                        if (ch <= 6) {
+                                /* quote chars 7..13 as \a,b,t,n,v,f,r */
+                                goto two;
+                        }
+                        /* other chars <32 or >126 as \ooo octal */
+                        len += 3;
+                        goto next;
+                }
                if (*name == '"' || *name == '\\') {
+ two:
                        len++;
                }
+ next:
                name++;
        }
        return len;
 }
-/* Return the number of used columns.
- * Note that only columnar output uses return value.
- * -l and -1 modes don't care.
- * coreutils 7.2 also supports:
- * ls -b (--escape) = octal escapes (although it doesn't look like working)
- * ls -N (--literal) = not escape at all
- */
 static unsigned print_name(const char *name)
 {
        unsigned len;
        uni_stat_t uni_stat;
-        // TODO: quote tab as \t, etc, if -Q
+        if (!(option_mask32 & (OPT_q|OPT_Q))) {
-        name = printable_string2(&uni_stat, name);
+                fputs_stdout(name);
+                return strlen(name);
+        }
        if (!(option_mask32 & OPT_Q)) {
+                /* the most likely branch: "ls" to tty (it auto-enables -q behavior) */
+                name = printable_string2(&uni_stat, name);
                fputs_stdout(name);
                return uni_stat.unicode_width;
        }
-        len = 2 + uni_stat.unicode_width;
+        len = 2 + strlen(name);
        putchar('"');
        while (*name) {
-                if (*name == '"' || *name == '\\') {
+                unsigned char ch = (unsigned char)*name;
+                if (ch < ' ' || ch > 0x7e) {
                        putchar('\\');
+                        ch -= 7;
+                        if (ch <= 6) {
+                                /* quote chars 7..13 as \a,b,t,n,v,f,r */
+                                ch = c_escape_conv_str07[1 + 3 * ch];
+                                goto two;
+                        }
+                        /* other chars <32 or >126 as \ooo octal */
+                        ch = (unsigned char)*name;
+                        putchar('0' + (ch>>6));
+                        putchar('0' + ((ch>>3) & 7));
+                        ch = '0' + (ch & 7);
+                        len += 3;
+                        goto put_ch;
+                }
+                if (ch == '"' || ch == '\\') {
+                        putchar('\\');
+ two:
                        len++;
                }
-                putchar(*name);
+ put_ch:
+                putchar(ch);
                name++;
        }
        putchar('"');
@@ -660,7 +731,7 @@ static void display_files(struct dnode **dn, unsigned nfiles)
        unsigned i, ncols, nrows, row, nc;
        unsigned column;
        unsigned nexttab;
-        unsigned column_width = 0; /* used only by coulmnal output */
+        unsigned column_width = 0; /* used only by columnar output */
        if (option_mask32 & (OPT_l|OPT_1)) {
                ncols = 1;
@@ -709,6 +780,11 @@ static void display_files(struct dnode **dn, unsigned nfiles)
                                }
                                nexttab = column + column_width;
                                column += display_single(dn[i]);
+                        } else {
+                                /* if -w999999999, ncols can be very large */
+                                //bb_error_msg(" col:%u ncol:%u i:%i", nc, ncols, i); sleep1();
+                                /* without "break", we loop millions of times here */
+                                break;
                        }
                }
                putchar('\n');
@@ -1155,25 +1231,11 @@ int ls_main(int argc UNUSED_PARAM, char **argv)
        /* need to initialize since --color has _an optional_ argument */
        const char *color_opt = color_str; /* "always" */
 #endif
-#if ENABLE_LONG_OPTS
-        static const char ls_longopts[] ALIGN1 =
-                "full-time\0" No_argument "\xff"
-                "group-directories-first\0" No_argument "\xfe"
-                IF_FEATURE_LS_COLOR("color\0" Optional_argument "\xfd")
-        ;
-#endif
        INIT_G();
        init_unicode();
-#if ENABLE_FEATURE_LS_WIDTH
-        /* obtain the terminal width */
-        G_terminal_width = get_terminal_width(STDIN_FILENO);
-        /* go one less... */
-        G_terminal_width--;
-#endif
        /* process options */
        opt = getopt32long(argv, "^"
                ls_options
@@ -1211,6 +1273,29 @@ int ls_main(int argc UNUSED_PARAM, char **argv)
        exit(0);
 #endif
+        /* ftpd secret backdoor? */
+        if (ENABLE_FTPD && applet_name[0] == 'f') {
+                /* dirs first are much nicer */
+                opt = option_mask32 |= OPT_dirs_first;
+                /* don't show SEcontext */
+                IF_SELINUX(opt = option_mask32 &= ~OPT_Z;)
+                /* do not query stdout about size and tty-ness */
+                IF_FEATURE_LS_WIDTH(G_terminal_width = INT_MAX;)
+                G.tty_out = 1; /* not a tty */
+                goto skip_if_ftpd;
+        }
+#if ENABLE_FEATURE_LS_WIDTH
+        if ((int)G_terminal_width < 0) {
+                /* obtain the terminal width */
+                G_terminal_width = get_terminal_width(STDIN_FILENO);
+                /* go one less... */
+                G_terminal_width--;
+        }
+        if (G_terminal_width == 0) /* -w0 */
+                G_terminal_width = INT_MAX; /* "infinite" */
+#endif
 #if ENABLE_SELINUX
        if (opt & OPT_Z) {
                if (!is_selinux_enabled())
@@ -1229,7 +1314,7 @@ int ls_main(int argc UNUSED_PARAM, char **argv)
 # endif
                /* LS_COLORS is unset, or (not empty && not "none") ? */
                if (!p || (p[0] && strcmp(p, "none") != 0)) {
-                        if (isatty(STDOUT_FILENO)) {
+                        if (G_isatty()) {
                                /* check isatty() last because it's expensive (syscall) */
                                G_show_color = 1;
                        }
@@ -1238,23 +1323,28 @@ int ls_main(int argc UNUSED_PARAM, char **argv)
        if (opt & OPT_color) {
                if (color_opt[0] == 'n')
                        G_show_color = 0;
-                else switch (index_in_substrings(color_str, color_opt)) {
+                else if (!G_show_color) {
-                case 3:
+                /* if() is not needed, but avoids extra isatty() if G_show_color is already set */
-                case 4:
+                        /* Check --color=COLOR_OPT and maybe set show_color=1 */
-                case 5:
+                        switch (index_in_substrings(color_str, color_opt)) {
-                        if (!is_TERM_dumb() && isatty(STDOUT_FILENO)) {
+                        case 3: // auto
-                case 0:
+                        case 4: // tty
-                case 1:
+                        case 5: // if-tty
-                case 2:
+                                if (!is_TERM_dumb() && G_isatty()) {
-                                G_show_color = 1;
+                        case 0: // always
+                        case 1: // yes
+                        case 2: // force
+                                        G_show_color = 1;
+                                }
                        }
                }
        }
 #endif
+ skip_if_ftpd:
        /* sort out which command line options take precedence */
        if (ENABLE_FEATURE_LS_RECURSIVE && (opt & OPT_d))
-                option_mask32 &= ~OPT_R;        /* no recurse if listing only dir */
+                opt = option_mask32 &= ~OPT_R;  /* no recurse if listing only dir */
        if (!(opt & OPT_l)) { /* not -l? */
                if (ENABLE_FEATURE_LS_TIMESTAMPS && ENABLE_FEATURE_LS_SORTFILES) {
                        /* when to sort by time? -t[cu] sorts by time even with -l */
@@ -1262,19 +1352,17 @@ int ls_main(int argc UNUSED_PARAM, char **argv)
                        /* without -l, bare -c or -u enable sort too */
                        /* (with -l, bare -c or -u just select which time to show) */
                        if (opt & (OPT_c|OPT_u)) {
-                                option_mask32 |= OPT_t;
+                                opt = option_mask32 |= OPT_t;
                        }
                }
        }
        /* choose a display format if one was not already specified by an option */
-        if (!(option_mask32 & (OPT_l|OPT_1|OPT_x|OPT_C)))
+        if (!(opt & (OPT_l|OPT_1|OPT_x|OPT_C)))
-                option_mask32 |= (isatty(STDOUT_FILENO) ? OPT_C : OPT_1);
+                opt = option_mask32 |= (G_isatty() ? OPT_C : OPT_1);
-        if (ENABLE_FTPD && applet_name[0] == 'f') {
+        if (!(opt & OPT_q) && G_isatty())
-                /* ftpd secret backdoor. dirs first are much nicer */
+                opt = option_mask32 |= OPT_q;
-                option_mask32 |= OPT_dirs_first;
-        }
 #if ENABLE_FEATURE_EXTRA_FILE_DATA
        /* Enable accurate link counts for directories */
diff --git a/coreutils/md5_sha1_sum.c b/coreutils/md5_sha1_sum.c
index 978d328f1..4506aeb56 100644
--- a/coreutils/md5_sha1_sum.c
+++ b/coreutils/md5_sha1_sum.c
@@ -23,6 +23,12 @@
 //config:       help
 //config:       Compute and check SHA256 message digest
 //config:
+//config:config SHA384SUM
+//config:       bool "sha384sum (7.3 kb)"
+//config:       default y
+//config:       help
+//config:       Compute and check SHA384 message digest
+//config:
 //config:config SHA512SUM
 //config:       bool "sha512sum (7.3 kb)"
 //config:       default y
@@ -35,13 +41,13 @@
 //config:       help
 //config:       Compute and check SHA3 message digest
 //config:
-//config:comment "Common options for md5sum, sha1sum, sha256sum, sha512sum, sha3sum"
+//config:comment "Common options for md5sum, sha1sum, sha256sum, ..., sha3sum"
-//config:       depends on MD5SUM || SHA1SUM || SHA256SUM || SHA512SUM || SHA3SUM
+//config:       depends on MD5SUM || SHA1SUM || SHA256SUM || SHA384SUM || SHA512SUM || SHA3SUM
 //config:
 //config:config FEATURE_MD5_SHA1_SUM_CHECK
 //config:       bool "Enable -c, -s and -w options"
 //config:       default y
-//config:       depends on MD5SUM || SHA1SUM || SHA256SUM || SHA512SUM || SHA3SUM
+//config:       depends on MD5SUM || SHA1SUM || SHA256SUM || SHA384SUM || SHA512SUM || SHA3SUM
 //config:       help
 //config:       Enabling the -c options allows files to be checked
 //config:       against pre-calculated hash values.
@@ -51,11 +57,13 @@
 //applet:IF_SHA1SUM(APPLET_NOEXEC(sha1sum, md5_sha1_sum, BB_DIR_USR_BIN, BB_SUID_DROP, sha1sum))
 //applet:IF_SHA3SUM(APPLET_NOEXEC(sha3sum, md5_sha1_sum, BB_DIR_USR_BIN, BB_SUID_DROP, sha3sum))
 //applet:IF_SHA256SUM(APPLET_NOEXEC(sha256sum, md5_sha1_sum, BB_DIR_USR_BIN, BB_SUID_DROP, sha256sum))
+//applet:IF_SHA384SUM(APPLET_NOEXEC(sha384sum, md5_sha1_sum, BB_DIR_USR_BIN, BB_SUID_DROP, sha384sum))
 //applet:IF_SHA512SUM(APPLET_NOEXEC(sha512sum, md5_sha1_sum, BB_DIR_USR_BIN, BB_SUID_DROP, sha512sum))
 //kbuild:lib-$(CONFIG_MD5SUM)    += md5_sha1_sum.o
 //kbuild:lib-$(CONFIG_SHA1SUM)   += md5_sha1_sum.o
 //kbuild:lib-$(CONFIG_SHA256SUM) += md5_sha1_sum.o
+//kbuild:lib-$(CONFIG_SHA384SUM) += md5_sha1_sum.o
 //kbuild:lib-$(CONFIG_SHA512SUM) += md5_sha1_sum.o
 //kbuild:lib-$(CONFIG_SHA3SUM)   += md5_sha1_sum.o
@@ -99,6 +107,16 @@
 //usage:     "\n        -w      Warn about improperly formatted checksum lines"
 //usage:        )
 //usage:
+//usage:#define sha384sum_trivial_usage
+//usage:        IF_FEATURE_MD5_SHA1_SUM_CHECK("[-c[sw]] ")"[FILE]..."
+//usage:#define sha384sum_full_usage "\n\n"
+//usage:       "Print" IF_FEATURE_MD5_SHA1_SUM_CHECK(" or check") " SHA384 checksums"
+//usage:        IF_FEATURE_MD5_SHA1_SUM_CHECK( "\n"
+//usage:     "\n        -c      Check sums against list in FILEs"
+//usage:     "\n        -s      Don't output anything, status code shows success"
+//usage:     "\n        -w      Warn about improperly formatted checksum lines"
+//usage:        )
+//usage:
 //usage:#define sha512sum_trivial_usage
 //usage:        IF_FEATURE_MD5_SHA1_SUM_CHECK("[-c[sw]] ")"[FILE]..."
 //usage:#define sha512sum_full_usage "\n\n"
@@ -130,11 +148,12 @@
 enum {
        /* 4th letter of applet_name is... */
-        HASH_MD5 = 's', /* "md5>s<um" */
+        HASH_MD5    = 's', /* "md5>s<um" */
-        HASH_SHA1 = '1',
+        HASH_SHA1   = '1',
        HASH_SHA256 = '2',
-        HASH_SHA3 = '3',
+        HASH_SHA3   = '3',
        HASH_SHA512 = '5',
+        /* unfortunately, sha384sum has the same '3' as sha3 */
 };
 #define FLAG_SILENT  1
@@ -158,10 +177,11 @@ static unsigned char *hash_bin_to_hex(unsigned char *hash_value,
 #endif
 static uint8_t *hash_file(unsigned char *in_buf, const char *filename, unsigned sha3_width)
 {
-        int src_fd, hash_len, count;
+        int src_fd, count;
        union _ctx_ {
                sha3_ctx_t sha3;
                sha512_ctx_t sha512;
+                sha384_ctx_t sha384;
                sha256_ctx_t sha256;
                sha1_ctx_t sha1;
                md5_ctx_t md5;
@@ -183,25 +203,31 @@ static uint8_t *hash_file(unsigned char *in_buf, const char *filename, unsigned
                md5_begin(&context.md5);
                update = (void*)md5_hash;
                final = (void*)md5_end;
-                hash_len = 16;
        }
        else if (ENABLE_SHA1SUM && hash_algo == HASH_SHA1) {
                sha1_begin(&context.sha1);
                update = (void*)sha1_hash;
                final = (void*)sha1_end;
-                hash_len = 20;
        }
        else if (ENABLE_SHA256SUM && hash_algo == HASH_SHA256) {
                sha256_begin(&context.sha256);
                update = (void*)sha256_hash;
                final = (void*)sha256_end;
-                hash_len = 32;
+        }
+        else if (ENABLE_SHA384SUM
+         && (ENABLE_SHA3SUM
+                ? (applet_name[4] == '8') /* check for "sha384", but do not match "sha3" */
+                : (hash_algo == '3') /* applet_name = "sha3sum" is not possible */
+                )
+        ) {
+                sha384_begin(&context.sha384);
+                update = (void*)sha384_hash;
+                final = (void*)sha384_end;
        }
        else if (ENABLE_SHA512SUM && hash_algo == HASH_SHA512) {
                sha512_begin(&context.sha512);
                update = (void*)sha512_hash;
                final = (void*)sha512_end;
-                hash_len = 64;
        }
 #if ENABLE_SHA3SUM
        else if (ENABLE_SHA3SUM && hash_algo == HASH_SHA3) {
@@ -219,9 +245,7 @@ static uint8_t *hash_file(unsigned char *in_buf, const char *filename, unsigned
                ) {
                        bb_error_msg_and_die("bad -a%u", sha3_width);
                }
-                sha3_width /= 4;
+                context.sha3.input_block_bytes = 1600/8 - sha3_width/4;
-                context.sha3.input_block_bytes = 1600/8 - sha3_width;
-                hash_len = sha3_width/2;
        }
 #endif
        else {
@@ -236,7 +260,7 @@ static uint8_t *hash_file(unsigned char *in_buf, const char *filename, unsigned
                if (count < 0)
                        bb_perror_msg("can't read '%s'", filename);
                else /* count == 0 */ {
-                        final(&context, in_buf);
+                        unsigned hash_len = final(&context, in_buf);
                        hash_value = hash_bin_to_hex(in_buf, hash_len);
                }
        }
@@ -262,14 +286,14 @@ int md5_sha1_sum_main(int argc UNUSED_PARAM, char **argv)
                /* -b "binary", -t "text" are ignored (shaNNNsum compat) */
                /* -s and -w require -c */
 #if ENABLE_SHA3SUM
-                if (applet_name[3] == HASH_SHA3)
+                if (applet_name[3] == HASH_SHA3 && (!ENABLE_SHA384SUM || applet_name[4] != '8'))
                        flags = getopt32(argv, "^" "scwbta:+" "\0" "s?c:w?c", &sha3_width);
                else
 #endif
                        flags = getopt32(argv, "^" "scwbt" "\0" "s?c:w?c");
        } else {
 #if ENABLE_SHA3SUM
-                if (applet_name[3] == HASH_SHA3)
+                if (applet_name[3] == HASH_SHA3 && (!ENABLE_SHA384SUM || applet_name[4] != '8'))
                        getopt32(argv, "a:+", &sha3_width);
                else
 #endif
diff --git a/e2fsprogs/fsck.c b/e2fsprogs/fsck.c
index fd4ea737c..f7e93497d 100644
--- a/e2fsprogs/fsck.c
+++ b/e2fsprogs/fsck.c
@@ -423,13 +423,11 @@ static int wait_one(int flags)
        /* if (G.noexecute) { already returned -1; } */
        while (1) {
-                pid = waitpid(-1, &status, flags);
+                pid = safe_waitpid(-1, &status, flags);
                kill_all_if_got_signal();
                if (pid == 0) /* flags == WNOHANG and no children exited */
                        return -1;
                if (pid < 0) {
-                        if (errno == EINTR)
-                                continue;
                        if (errno == ECHILD) { /* paranoia */
                                bb_simple_error_msg("wait: no more children");
                                return -1;
diff --git a/include/libbb.h b/include/libbb.h
index 8dc4e4992..60037ed3d 100644
--- a/include/libbb.h
+++ b/include/libbb.h
@@ -1224,6 +1224,22 @@ char *bin2hex(char *dst, const char *src, int count) FAST_FUNC;
 /* Reverse */
 char* hex2bin(char *dst, const char *src, int count) FAST_FUNC;
+/* Returns strlen as a bonus */
+//size_t replace_char(char *s, char what, char with) FAST_FUNC;
+static inline size_t replace_char(char *str, char from, char to)
+{
+        char *p = str;
+        while (*p) {
+                if (*p == from)
+                        *p = to;
+                p++;
+        }
+        return p - str;
+}
+extern const char c_escape_conv_str00[];
+#define c_escape_conv_str07 (c_escape_conv_str00+3)
 void FAST_FUNC xorbuf_3(void *dst, const void *src1, const void *src2, unsigned count);
 void FAST_FUNC xorbuf(void* buf, const void* mask, unsigned count);
 void FAST_FUNC xorbuf16_aligned_long(void* buf, const void* mask);
@@ -2225,33 +2241,6 @@ enum { COMM_LEN = 16 };
 # endif
 #endif
-struct smaprec {
-        unsigned long mapped_rw;
-        unsigned long mapped_ro;
-        unsigned long shared_clean;
-        unsigned long shared_dirty;
-        unsigned long private_clean;
-        unsigned long private_dirty;
-        unsigned long stack;
-        unsigned long smap_pss, smap_swap;
-        unsigned long smap_size;
-        // For mixed 32/64 userspace, 32-bit pmap still needs
-        // 64-bit field here to correctly show 64-bit processes:
-        unsigned long long smap_start;
-        // (strictly speaking, other fields need to be wider too,
-        // but they are in kbytes, not bytes, and they hold sizes,
-        // not start addresses, sizes tend to be less than 4 terabytes)
-        char smap_mode[5];
-        char *smap_name;
-};
-#if !ENABLE_PMAP
-#define procps_read_smaps(pid, total, cb, data) \
-        procps_read_smaps(pid, total)
-#endif
-int FAST_FUNC procps_read_smaps(pid_t pid, struct smaprec *total,
-                void (*cb)(struct smaprec *, void *), void *data);
 typedef struct procps_status_t {
 #if !ENABLE_PLATFORM_MINGW32
        DIR *dir;
@@ -2287,7 +2276,13 @@ typedef struct procps_status_t {
 #endif
        unsigned tty_major,tty_minor;
 #if ENABLE_FEATURE_TOPMEM
-        struct smaprec smaps;
+        unsigned long mapped_rw;
+        unsigned long mapped_ro;
+        unsigned long shared_clean;
+        unsigned long shared_dirty;
+        unsigned long private_clean;
+        unsigned long private_dirty;
+        unsigned long stack;
 #endif
        char state[4];
        /* basename of executable in exec(2), read from /proc/N/stat
@@ -2336,11 +2331,15 @@ void free_procps_scan(procps_status_t* sp) FAST_FUNC;
 procps_status_t* procps_scan(procps_status_t* sp, int flags) FAST_FUNC;
 /* Format cmdline (up to col chars) into char buf[size] */
 /* Puts [comm] if cmdline is empty (-> process is a kernel thread) */
-void read_cmdline(char *buf, int size, unsigned pid, const char *comm) FAST_FUNC;
+int read_cmdline(char *buf, int size, unsigned pid, const char *comm) FAST_FUNC;
 pid_t *find_pid_by_name(const char* procName) FAST_FUNC;
 pid_t *pidlist_reverse(pid_t *pidList) FAST_FUNC;
 int starts_with_cpu(const char *str) FAST_FUNC;
 unsigned get_cpu_count(void) FAST_FUNC;
+/* Some internals reused by pmap: */
+unsigned long FAST_FUNC fast_strtoul_10(char **endptr);
+unsigned long long FAST_FUNC fast_strtoull_16(char **endptr);
+char* FAST_FUNC skip_fields(char *str, int count);
 /* Use strict=1 if you process input from untrusted source:
@@ -2375,8 +2374,9 @@ enum {
        MD5_OUTSIZE    = 16,
        SHA1_OUTSIZE   = 20,
        SHA256_OUTSIZE = 32,
+        SHA384_OUTSIZE = 48,
        SHA512_OUTSIZE = 64,
-        SHA3_OUTSIZE   = 28,
+        //SHA3-224_OUTSIZE = 28,
        /* size of input block */
        SHA2_INSIZE     = 64,
 };
@@ -2390,6 +2390,7 @@ struct bcrypt_hash_ctx_t {
 typedef struct bcrypt_hash_ctx_t md5_ctx_t;
 typedef struct bcrypt_hash_ctx_t sha1_ctx_t;
 typedef struct bcrypt_hash_ctx_t sha256_ctx_t;
+typedef struct bcrypt_hash_ctx_t sha384_ctx_t;
 typedef struct bcrypt_hash_ctx_t sha512_ctx_t;
 typedef struct sha3_ctx_t {
        uint64_t state[25];
@@ -2399,16 +2400,19 @@ typedef struct sha3_ctx_t {
 void md5_begin(struct bcrypt_hash_ctx_t *ctx) FAST_FUNC;
 void sha1_begin(struct bcrypt_hash_ctx_t *ctx) FAST_FUNC;
 void sha256_begin(struct bcrypt_hash_ctx_t *ctx) FAST_FUNC;
+void sha384_begin(struct bcrypt_hash_ctx_t *ctx) FAST_FUNC;
 void sha512_begin(struct bcrypt_hash_ctx_t *ctx) FAST_FUNC;
 void generic_hash(struct bcrypt_hash_ctx_t *ctx, const void *buffer, size_t len) FAST_FUNC;
 unsigned generic_end(struct bcrypt_hash_ctx_t *ctx, void *resbuf) FAST_FUNC;
 # define md5_hash generic_hash
 # define sha1_hash generic_hash
 # define sha256_hash generic_hash
+# define sha384_hash generic_hash
 # define sha512_hash generic_hash
 # define md5_end generic_end
 # define sha1_end generic_end
 # define sha256_end generic_end
+# define sha384_end generic_end
 # define sha512_end generic_end
 #else
 typedef struct md5_ctx_t {
@@ -2424,6 +2428,7 @@ typedef struct sha512_ctx_t {
        uint64_t hash[8];
        uint8_t wbuffer[128]; /* always correctly aligned for uint64_t */
 } sha512_ctx_t;
+typedef struct sha512_ctx_t sha384_ctx_t;
 typedef struct sha3_ctx_t {
        uint64_t state[25];
        unsigned bytes_queued;
@@ -2441,6 +2446,9 @@ void sha256_begin(sha256_ctx_t *ctx) FAST_FUNC;
 void sha512_begin(sha512_ctx_t *ctx) FAST_FUNC;
 void sha512_hash(sha512_ctx_t *ctx, const void *buffer, size_t len) FAST_FUNC;
 unsigned sha512_end(sha512_ctx_t *ctx, void *resbuf) FAST_FUNC;
+void sha384_begin(sha384_ctx_t *ctx) FAST_FUNC;
+#define sha384_hash sha512_hash
+unsigned sha384_end(sha384_ctx_t *ctx, void *resbuf) FAST_FUNC;
 #endif
 void sha3_begin(sha3_ctx_t *ctx) FAST_FUNC;
 void sha3_hash(sha3_ctx_t *ctx, const void *buffer, size_t len) FAST_FUNC;
diff --git a/include/platform.h b/include/platform.h
index 5795a0cf3..0b88f990b 100644
--- a/include/platform.h
+++ b/include/platform.h
@@ -208,7 +208,7 @@
 #elif defined(BYTE_ORDER) && BYTE_ORDER == LITTLE_ENDIAN
 # define BB_BIG_ENDIAN 0
 # define BB_LITTLE_ENDIAN 1
-#elif defined(__386__)
+#elif defined(__i386__)
 # define BB_BIG_ENDIAN 0
 # define BB_LITTLE_ENDIAN 1
 #else
diff --git a/init/init.c b/init/init.c
index 797e0a0eb..294be9952 100644
--- a/init/init.c
+++ b/init/init.c
@@ -1201,7 +1201,7 @@ int init_main(int argc UNUSED_PARAM, char **argv)
                        int status;
                        struct init_action *a;
-                        wpid = waitpid(-1, &status, WNOHANG);
+                        wpid = wait_any_nohang(&status);
                        if (wpid <= 0)
                                break;
diff --git a/libbb/c_escape.c b/libbb/c_escape.c
new file mode 100644
index 000000000..6c109f2e0
--- /dev/null
+++ b/libbb/c_escape.c
@@ -0,0 +1,20 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * Copyright (C) 2025 by Denys Vlasenko <vda.linux@googlemail.com>
+ *
+ * Licensed under GPLv2, see file LICENSE in this source tree.
+ */
+//kbuild:lib-y += c_escape.o
+#include "libbb.h"
+const char c_escape_conv_str00[] ALIGN1 =
+        "\\""0""\0" // [0]:00
+        "\\""a""\0" // [1]:07
+        "\\""b""\0" // [2]:08
+        "\\""t""\0" // [3]:09
+        "\\""n""\0" // [4]:0a
+        "\\""v""\0" // [5]:0b
+        "\\""f""\0" // [6]:0c
+        "\\""r"     // [7]:0d
+        ;
diff --git a/libbb/concat_path_file.c b/libbb/concat_path_file.c
index 3afb0e3a4..96fcd4a1d 100644
--- a/libbb/concat_path_file.c
+++ b/libbb/concat_path_file.c
@@ -17,6 +17,7 @@
 char* FAST_FUNC concat_path_file(const char *path, const char *filename)
 {
+#if 0
        char *lc;
        if (!path)
@@ -31,4 +32,78 @@ char* FAST_FUNC concat_path_file(const char *path, const char *filename)
                filename++;
 #endif
        return xasprintf("%s%s%s", path, (lc==NULL ? "/" : ""), filename);
+#else
+/* ^^^^^^^^^^^ timing of xasprintf-based code above:
+ * real 7.074s
+ * user 0.156s <<<
+ * sys  6.394s
+ *      "rm -rf" of a Linux kernel tree from tmpfs (run time still dominated by in-kernel work, though)
+ * real 6.989s
+ * user 0.055s <<< 3 times less CPU used
+ * sys  6.450s
+ * vvvvvvvvvvv timing of open-coded malloc+memcpy code below (+59 bytes):
+ */
+        char *buf, *p;
+        size_t n1, n2, n3;
+        while (*filename == '/')
+                filename++;
+        if (!path || !path[0])
+                return xstrdup(filename);
+        n1 = strlen(path);
+        n2 = (path[n1 - 1] != '/'); /* 1: "path has no trailing slash" */
+        n3 = strlen(filename) + 1;
+        buf = xmalloc(n1 + n2 + n3);
+        p = mempcpy(buf, path, n1);
+        if (n2)
+                *p++ = '/';
+        memcpy(p, filename, n3);
+        return buf;
+#endif
 }
+/* If second component comes from struct dirent,
+ * it's possible to eliminate one strlen() by using name length
+ * provided by kernel in struct dirent. See below.
+ * However, the win seems to be insignificant.
+ */
+#if 0
+/* Extract d_namlen from struct dirent */
+static size_t get_d_namlen(const struct dirent *de)
+{
+#if defined(_DIRENT_HAVE_D_NAMLEN)
+        return de->d_namlen;
+#elif defined(_DIRENT_HAVE_D_RECLEN)
+        const size_t prefix_sz = offsetof(struct dirent, d_name);
+        return de->d_reclen - prefix_sz;
+#else
+        return strlen(de->d_name);
+#endif
+}
+char* FAST_FUNC concat_path_dirent(const char *path, const struct dirent *de)
+{
+        char *buf, *p;
+        size_t n1, n2, n3;
+        if (!path || !path[0])
+                return xstrdup(de->d_name);
+        n1 = strlen(path);
+        n2 = (path[n1 - 1] != '/');
+        n3 = get_d_namlen(de) + 1;
+        buf = xmalloc(n1 + n2 + n3);
+        p = mempcpy(buf, path, n1);
+        if (n2)
+                *p++ = '/';
+        memcpy(p, de->d_name, n3);
+        return buf;
+}
+#endif
diff --git a/libbb/dump.c b/libbb/dump.c
index b2abe85af..3dc53d55f 100644
--- a/libbb/dump.c
+++ b/libbb/dump.c
@@ -514,37 +514,52 @@ static void bpad(PR *pr)
                continue;
 }
-static const char conv_str[] ALIGN1 =
-        "\0"  "\\""0""\0"
-        "\007""\\""a""\0"
-        "\b"  "\\""b""\0"
-        "\f"  "\\""f""\0"
-        "\n"  "\\""n""\0"
-        "\r"  "\\""r""\0"
-        "\t"  "\\""t""\0"
-        "\v"  "\\""v""\0"
-        ;
 static void conv_c(PR *pr, unsigned char *p)
 {
-        const char *str = conv_str;
+        const char *str;
+        unsigned char ch;
-        do {
-                if (*p == *str) {
+        ch = *p;
-                        ++str;
+        if (ch == 0 || (ch -= 6, (signed char)ch > 0 && ch <= 7)) {
-                        goto strpr; /* map e.g. '\n' to "\\n" */
+                /* map chars 0,7..13 to "\0","\{a,b,t,n,v,f,r}" */
-                }
+                str = c_escape_conv_str00 + 3 * ch;
-                str += 4;
+                goto strpr;
-        } while (*str);
+        }
        if (isprint_asciionly(*p)) {
                *pr->cchar = 'c';
                printf(pr->fmt, *p);
        } else {
+#if defined(__i386__) || defined(__x86_64__)
+                /* Abuse partial register operations */
+                uint32_t buf;
+                unsigned n = *p;
+                asm (           //00000000 00000000 00000000 aabbbccc
+"\n             shll $10,%%eax" //00000000 000000aa bbbccc00 00000000
+"\n             shrw $5,%%ax"   //00000000 000000aa 00000bbb ccc00000
+"\n             shrb $5,%%al"   //00000000 000000aa 00000bbb 00000ccc
+"\n             shll $8,%%eax"  //000000aa 00000bbb 00000ccc 00000000
+"\n             bswapl %%eax"   //00000000 00000ccc 00000bbb 000000aa
+"\n             addl $0x303030,%%eax"
+"\n"            : "=a" (n)
+                : "0" (n)
+                );
+                buf = n;
+                str = (void*)&buf;
+#elif 1
                char buf[4];
                /* gcc-8.0.1 needs lots of casts to shut up */
                sprintf(buf, "%03o", (unsigned)(uint8_t)*p);
                str = buf;
+#else // use faster version? +20 bytes of code relative to sprintf() method
+                char buf[4];
+                buf[3] = '\0';
+                ch = *p;
+                buf[2] = '0' + (ch & 7); ch >>= 3;
+                buf[1] = '0' + (ch & 7); ch >>= 3;
+                buf[0] = '0' + ch;
+                str = buf;
+#endif
 strpr:
                *pr->cchar = 's';
                printf(pr->fmt, str);
diff --git a/libbb/getopt32.c b/libbb/getopt32.c
index 76d29d5eb..9247588d9 100644
--- a/libbb/getopt32.c
+++ b/libbb/getopt32.c
@@ -530,6 +530,7 @@ vgetopt32(char **argv, const char *applet_opts, const char *applet_long_options,
         * "fake" short options, like this one:
         * wget $'-\203' "Test: test" http://kernel.org/
         * (supposed to act as --header, but doesn't) */
+ next_opt:
 #if ENABLE_LONG_OPTS
        while ((c = getopt_long(argc, argv, applet_opts,
                        long_options, NULL)) != -1) {
@@ -544,8 +545,16 @@ vgetopt32(char **argv, const char *applet_opts, const char *applet_long_options,
                         * but we construct long opts so that flag
                         * is always NULL (see above) */
                        if (on_off->opt_char == '\0' /* && c != '\0' */) {
-                                /* c is probably '?' - "bad option" */
+                                /* We reached the end of complementary[] and did not find -c */
-                                goto error;
+                                if (c == '?') /* getopt says: "bad option, or option has no required argument" */
+                                        goto error;
+                                /* if there were options beyond 32 bits (example: ls),
+                                 * they got no complementary[] slot, and no result bit.
+                                 * IOW: they must be "accept but ignore" options.
+                                 * For them, we end up here.
+                                 */
+                                //bb_error_msg("ignored option '%c', skipping", c);
+                                goto next_opt;
                        }
                }
                if (flags & on_off->incongruously)
diff --git a/libbb/hash_md5_sha.c b/libbb/hash_md5_sha.c
index 22dd890bf..fd56d831b 100644
--- a/libbb/hash_md5_sha.c
+++ b/libbb/hash_md5_sha.c
@@ -11,7 +11,7 @@
 #define STR1(s) #s
 #define STR(s) STR1(s)
-#define NEED_SHA512 (ENABLE_SHA512SUM || ENABLE_USE_BB_CRYPT_SHA)
+#define NEED_SHA512 (ENABLE_SHA512SUM || ENABLE_SHA384SUM || ENABLE_USE_BB_CRYPT_SHA)
 #if ENABLE_FEATURE_USE_CNG_API
 # include <windows.h>
@@ -21,6 +21,7 @@
 # define BCRYPT_MD5_ALG_HANDLE    ((BCRYPT_ALG_HANDLE) 0x00000021)
 # define BCRYPT_SHA1_ALG_HANDLE   ((BCRYPT_ALG_HANDLE) 0x00000031)
 # define BCRYPT_SHA256_ALG_HANDLE ((BCRYPT_ALG_HANDLE) 0x00000041)
+# define BCRYPT_SHA384_ALG_HANDLE ((BCRYPT_ALG_HANDLE) 0x00000051)
 # define BCRYPT_SHA512_ALG_HANDLE ((BCRYPT_ALG_HANDLE) 0x00000061)
 /* Initialize structure containing state of computation.
@@ -61,9 +62,18 @@ void FAST_FUNC sha256_begin(sha256_ctx_t *ctx)
        generic_init(ctx, BCRYPT_SHA256_ALG_HANDLE);
 }
-#if NEED_SHA512
+#if ENABLE_SHA384SUM
 /* Initialize structure containing state of computation.
   (FIPS 180-2:5.3.3)  */
+void FAST_FUNC sha384_begin(sha384_ctx_t *ctx)
+{
+        generic_init(ctx, BCRYPT_SHA384_ALG_HANDLE);
+}
+#endif /* ENABLE_SHA384SUM */
+#if NEED_SHA512
+/* Initialize structure containing state of computation.
+   (FIPS 180-2:5.3.4)  */
 void FAST_FUNC sha512_begin(sha512_ctx_t *ctx)
 {
        generic_init(ctx, BCRYPT_SHA512_ALG_HANDLE);
@@ -1109,7 +1119,7 @@ static const sha_K_int sha_K[] ALIGN8 = {
        K(0x84c87814a1f0ab72ULL), K(0x8cc702081a6439ecULL),
        K(0x90befffa23631e28ULL), K(0xa4506cebde82bde9ULL),
        K(0xbef9a3f7b2c67915ULL), K(0xc67178f2e372532bULL),
-#if NEED_SHA512  /* [64]+ are used for sha512 only */
+#if NEED_SHA512  /* [64]+ are used for sha384 and sha512 only */
        K(0xca273eceea26619cULL), K(0xd186b8c721c0c207ULL),
        K(0xeada7dd6cde0eb1eULL), K(0xf57d4f7fee6ed178ULL),
        K(0x06f067aa72176fbaULL), K(0x0a637dc5a2c898a6ULL),
@@ -1306,11 +1316,20 @@ static const uint32_t init512_lo[] ALIGN4 = {
        0x137e2179,
 };
 #endif /* NEED_SHA512 */
+#if ENABLE_SHA384SUM
-// Note: SHA-384 is identical to SHA-512, except that initial hash values are
+static const uint64_t init384[] ALIGN8 = {
-// 0xcbbb9d5dc1059ed8, 0x629a292a367cd507, 0x9159015a3070dd17, 0x152fecd8f70e5939,
+        0,
-// 0x67332667ffc00b31, 0x8eb44a8768581511, 0xdb0c2e0d64f98fa7, 0x47b5481dbefa4fa4,
+        0,
-// and the output is constructed by omitting last two 64-bit words of it.
+        0xcbbb9d5dc1059ed8,
+        0x629a292a367cd507,
+        0x9159015a3070dd17,
+        0x152fecd8f70e5939,
+        0x67332667ffc00b31,
+        0x8eb44a8768581511,
+        0xdb0c2e0d64f98fa7,
+        0x47b5481dbefa4fa4,
+};
+#endif
 /* Initialize structure containing state of computation.
   (FIPS 180-2:5.3.2)  */
@@ -1332,9 +1351,19 @@ void FAST_FUNC sha256_begin(sha256_ctx_t *ctx)
 #endif
 }
-#if NEED_SHA512
+#if ENABLE_SHA384SUM
 /* Initialize structure containing state of computation.
   (FIPS 180-2:5.3.3)  */
+void FAST_FUNC sha384_begin(sha512_ctx_t *ctx)
+{
+        memcpy(&ctx->total64, init384, sizeof(init384));
+        /*ctx->total64[0] = ctx->total64[1] = 0; - already done */
+}
+#endif
+#if NEED_SHA512
+/* Initialize structure containing state of computation.
+   (FIPS 180-2:5.3.4)  */
 void FAST_FUNC sha512_begin(sha512_ctx_t *ctx)
 {
        int i;
@@ -1409,7 +1438,7 @@ unsigned FAST_FUNC sha1_end(sha1_ctx_t *ctx, void *resbuf)
 }
 #if NEED_SHA512
-unsigned FAST_FUNC sha512_end(sha512_ctx_t *ctx, void *resbuf)
+static unsigned FAST_FUNC sha512384_end(sha512_ctx_t *ctx, void *resbuf, unsigned outsize)
 {
        unsigned bufpos = ctx->total64[0] & 127;
@@ -1440,12 +1469,22 @@ unsigned FAST_FUNC sha512_end(sha512_ctx_t *ctx, void *resbuf)
                for (i = 0; i < ARRAY_SIZE(ctx->hash); ++i)
                        ctx->hash[i] = SWAP_BE64(ctx->hash[i]);
        }
-        memcpy(resbuf, ctx->hash, sizeof(ctx->hash));
+        memcpy(resbuf, ctx->hash, outsize);
-        return sizeof(ctx->hash);
+        return outsize;
+}
+unsigned FAST_FUNC sha512_end(sha384_ctx_t *ctx, void *resbuf)
+{
+        return sha512384_end(ctx, resbuf, SHA512_OUTSIZE);
 }
 #endif /* NEED_SHA512 */
-#endif /* !ENABLE_FEATURE_USE_CNG_API */
+#if ENABLE_SHA384SUM
+unsigned FAST_FUNC sha384_end(sha384_ctx_t *ctx, void *resbuf)
+{
+        return sha512384_end(ctx, resbuf, SHA384_OUTSIZE);
+}
+#endif
+#endif /* !ENABLE_FEATURE_USE_CNG_API */
 /*
 * The Keccak sponge function, designed by Guido Bertoni, Joan Daemen,
@@ -1982,6 +2021,8 @@ void FAST_FUNC sha3_hash(sha3_ctx_t *ctx, const void *buffer, size_t len)
 unsigned FAST_FUNC sha3_end(sha3_ctx_t *ctx, void *resbuf)
 {
+        unsigned hash_len;
        /* Padding */
        uint8_t *buf = (uint8_t*)ctx->state;
        /*
@@ -2004,6 +2045,7 @@ unsigned FAST_FUNC sha3_end(sha3_ctx_t *ctx, void *resbuf)
        sha3_process_block72(ctx->state);
        /* Output */
-        memcpy(resbuf, ctx->state, 64);
+        hash_len = (1600/8 - ctx->input_block_bytes) / 2;
-        return 64;
+        memcpy(resbuf, ctx->state, hash_len);
+        return hash_len;
 }
diff --git a/libbb/lineedit.c b/libbb/lineedit.c
index c8a0f37fe..77207a427 100644
--- a/libbb/lineedit.c
+++ b/libbb/lineedit.c
@@ -1754,7 +1754,7 @@ void FAST_FUNC save_history(line_input_t *st)
        FILE *fp;
        /* bash compat: HISTFILE="" disables history saving */
-        if (!st || !st->hist_file || !state->hist_file[0])
+        if (!st || !st->hist_file || !st->hist_file[0])
                return;
        if (st->cnt_history <= st->cnt_history_in_file)
                return; /* no new entries were added */
diff --git a/libbb/procps.c b/libbb/procps.c
index 8c9cac125..c751100bc 100644
--- a/libbb/procps.c
+++ b/libbb/procps.c
@@ -110,7 +110,7 @@ void FAST_FUNC free_procps_scan(procps_status_t* sp)
 }
 #if ENABLE_FEATURE_TOPMEM || ENABLE_PMAP
-static unsigned long long fast_strtoull_16(char **endptr)
+unsigned long long FAST_FUNC fast_strtoull_16(char **endptr)
 {
        unsigned char c;
        char *str = *endptr;
@@ -131,7 +131,7 @@ static unsigned long long fast_strtoull_16(char **endptr)
 #if ENABLE_FEATURE_FAST_TOP || ENABLE_FEATURE_TOPMEM || ENABLE_PMAP
 /* We cut a lot of corners here for speed */
-static unsigned long fast_strtoul_10(char **endptr)
+unsigned long FAST_FUNC fast_strtoul_10(char **endptr)
 {
        unsigned char c;
        char *str = *endptr;
@@ -144,6 +144,24 @@ static unsigned long fast_strtoul_10(char **endptr)
        *endptr = str + 1; /* We skip trailing space! */
        return n;
 }
+# if LONG_MAX < LLONG_MAX
+/* For VSZ, which can be very large */
+static unsigned long long fast_strtoull_10(char **endptr)
+{
+        unsigned char c;
+        char *str = *endptr;
+        unsigned long long n = *str - '0';
+        /* Need to stop on both ' ' and '\n' */
+        while ((c = *++str) > ' ')
+                n = n*10 + (c - '0');
+        *endptr = str + 1; /* We skip trailing space! */
+        return n;
+}
+# else
+#  define fast_strtoull_10(endptr) fast_strtoul_10(endptr)
+# endif
 # if ENABLE_FEATURE_FAST_TOP
 static long fast_strtol_10(char **endptr)
@@ -156,7 +174,7 @@ static long fast_strtol_10(char **endptr)
 }
 # endif
-static char *skip_fields(char *str, int count)
+char* FAST_FUNC skip_fields(char *str, int count)
 {
        do {
                while (*str++ != ' ')
@@ -167,35 +185,25 @@ static char *skip_fields(char *str, int count)
 }
 #endif
-#if ENABLE_FEATURE_TOPMEM || ENABLE_PMAP
+#if ENABLE_FEATURE_TOPMEM
-static char* skip_whitespace_if_prefixed_with(char *buf, const char *prefix)
+static NOINLINE void procps_read_smaps(pid_t pid, procps_status_t *sp)
 {
-        char *tp = is_prefixed_with(buf, prefix);
+        // There is A LOT of /proc/PID/smaps data on a big system.
-        if (tp) {
+        // Optimize this for speed, makes "top -m" faster.
-                tp = skip_whitespace(tp);
+//TODO large speedup:
-        }
+//read /proc/PID/smaps_rollup (cumulative stats of all mappings, much faster)
-        return tp;
+//and  /proc/PID/maps         to get mapped_ro and mapped_rw (IOW: VSZ,VSZRW)
-}
-int FAST_FUNC procps_read_smaps(pid_t pid, struct smaprec *total,
-                void (*cb)(struct smaprec *, void *), void *data)
-{
        FILE *file;
-        struct smaprec currec;
        char filename[sizeof("/proc/%u/smaps") + sizeof(int)*3];
        char buf[PROCPS_BUFSIZE];
-#if !ENABLE_PMAP
-        void (*cb)(struct smaprec *, void *) = NULL;
-        void *data = NULL;
-#endif
        sprintf(filename, "/proc/%u/smaps", (int)pid);
        file = fopen_for_read(filename);
        if (!file)
-                return 1;
+                return;
-        memset(&currec, 0, sizeof(currec));
        while (fgets(buf, PROCPS_BUFSIZE, file)) {
                // Each mapping datum has this form:
                // f7d29000-f7d39000 rw-s FILEOFS M:m INODE FILENAME
@@ -203,80 +211,53 @@ int FAST_FUNC procps_read_smaps(pid_t pid, struct smaprec *total,
                // Rss:                 nnn kB
                // .....
-                char *tp, *p;
+                char *tp;
+                if (buf[0] == 'S' || buf[0] == 'P') {
 #define SCAN(S, X) \
-                if ((tp = skip_whitespace_if_prefixed_with(buf, S)) != NULL) { \
+                        if (memcmp(buf, S, sizeof(S)-1) == 0) { \
-                        total->X += currec.X = fast_strtoul_10(&tp); \
+                                tp = skip_whitespace(buf + sizeof(S)-1); \
-                        continue;                                    \
+                                sp->X += fast_strtoul_10(&tp); \
-                }
+                                continue; \
-                if (cb) {
+                        }
-                        SCAN("Pss:"  , smap_pss     );
+                        SCAN("Private_Dirty:", private_dirty)
-                        SCAN("Swap:" , smap_swap    );
+                        SCAN("Private_Clean:", private_clean)
-                }
+                        SCAN("Shared_Dirty:" , shared_dirty )
-                SCAN("Private_Dirty:", private_dirty);
+                        SCAN("Shared_Clean:" , shared_clean )
-                SCAN("Private_Clean:", private_clean);
-                SCAN("Shared_Dirty:" , shared_dirty );
-                SCAN("Shared_Clean:" , shared_clean );
 #undef SCAN
+                }
                tp = strchr(buf, '-');
                if (tp) {
                        // We reached next mapping - the line of this form:
                        // f7d29000-f7d39000 rw-s FILEOFS M:m INODE FILENAME
-                        if (cb) {
+                        char *rwx;
-                                /* If we have a previous record, there's nothing more
+                        unsigned long sz;
-                                 * for it, call the callback and clear currec
-                                 */
-                                if (currec.smap_size)
-                                        cb(&currec, data);
-                                free(currec.smap_name);
-                        }
-                        memset(&currec, 0, sizeof(currec));
                        *tp = ' ';
                        tp = buf;
-                        currec.smap_start = fast_strtoull_16(&tp);
+                        sz = fast_strtoull_16(&tp); // start
-                        currec.smap_size = (fast_strtoull_16(&tp) - currec.smap_start) >> 10;
+                        sz = (fast_strtoull_16(&tp) - sz) >> 10; // end - start
+                        // tp -> "rw-s" string
-                        strncpy(currec.smap_mode, tp, sizeof(currec.smap_mode)-1);
+                        rwx = tp;
                        // skipping "rw-s FILEOFS M:m INODE "
                        tp = skip_whitespace(skip_fields(tp, 4));
-                        // filter out /dev/something (something != zero)
+                        // if not a device memory mapped...
-                        if (!is_prefixed_with(tp, "/dev/") || strcmp(tp, "/dev/zero\n") == 0) {
+                        if (memcmp(tp, "/dev/", 5) != 0    // not "/dev/something"
-                                if (currec.smap_mode[1] == 'w') {
+                         || strcmp(tp + 5, "zero\n") == 0  // or is "/dev/zero" (which isn't a device)
-                                        currec.mapped_rw = currec.smap_size;
+                        ) {
-                                        total->mapped_rw += currec.smap_size;
+                                if (rwx[1] == 'w')
-                                } else if (currec.smap_mode[1] == '-') {
+                                        sp->mapped_rw += sz;
-                                        currec.mapped_ro = currec.smap_size;
+                                else if (rwx[0] == 'r' || rwx[2] == 'x')
-                                        total->mapped_ro += currec.smap_size;
+                                        sp->mapped_ro += sz;
-                                }
+                                // else: seen "---p" mappings (mmap guard gaps?),
+                                // do NOT account these as VSZ, they aren't really
                        }
                        if (strcmp(tp, "[stack]\n") == 0)
-                                total->stack += currec.smap_size;
+                                sp->stack += sz;
-                        if (cb) {
-                                p = skip_non_whitespace(tp);
-                                if (p == tp) {
-                                        currec.smap_name = xstrdup("  [ anon ]");
-                                } else {
-                                        *p = '\0';
-                                        currec.smap_name = xstrdup(tp);
-                                }
-                        }
-                        total->smap_size += currec.smap_size;
                }
        }
        fclose(file);
-        if (cb) {
-                if (currec.smap_size)
-                        cb(&currec, data);
-                free(currec.smap_name);
-        }
-        return 0;
 }
 #endif
@@ -371,7 +352,8 @@ procps_status_t* FAST_FUNC procps_scan(procps_status_t* sp, int flags)
                        char *cp, *comm1;
                        int tty;
 #if !ENABLE_FEATURE_FAST_TOP
-                        unsigned long vsz, rss;
+                        unsigned long long vsz;
+                        unsigned long rss;
 #endif
                        /* see proc(5) for some details on this */
                        strcpy(filename_tail, "stat");
@@ -397,7 +379,7 @@ procps_status_t* FAST_FUNC procps_scan(procps_status_t* sp, int flags)
                                "%ld "                 /* nice */
                                "%*s %*s "             /* timeout, it_real_value */
                                "%lu "                 /* start_time */
-                                "%lu "                 /* vsize */
+                                "%llu "                /* vsize - can be very large */
                                "%lu "                 /* rss */
 # if ENABLE_FEATURE_TOP_SMP_PROCESS
                                "%*s %*s %*s %*s %*s %*s " /*rss_rlim, start_code, end_code, start_stack, kstk_esp, kstk_eip */
@@ -450,7 +432,7 @@ procps_status_t* FAST_FUNC procps_scan(procps_status_t* sp, int flags)
                        cp = skip_fields(cp, 2); /* timeout, it_real_value */
                        sp->start_time = fast_strtoul_10(&cp);
                        /* vsz is in bytes and we want kb */
-                        sp->vsz = fast_strtoul_10(&cp) >> 10;
+                        sp->vsz = fast_strtoull_10(&cp) >> 10;
                        /* vsz is in bytes but rss is in *PAGES*! Can you believe that? */
                        sp->rss = fast_strtoul_10(&cp) << sp->shift_pages_to_kb;
 # if ENABLE_FEATURE_TOP_SMP_PROCESS
@@ -484,7 +466,7 @@ procps_status_t* FAST_FUNC procps_scan(procps_status_t* sp, int flags)
 #if ENABLE_FEATURE_TOPMEM
                if (flags & PSSCAN_SMAPS)
-                        procps_read_smaps(pid, &sp->smaps, NULL, NULL);
+                        procps_read_smaps(pid, sp);
 #endif /* TOPMEM */
 #if ENABLE_FEATURE_PS_ADDITIONAL_COLUMNS
                if (flags & PSSCAN_RUIDGID) {
@@ -567,36 +549,45 @@ procps_status_t* FAST_FUNC procps_scan(procps_status_t* sp, int flags)
        return sp;
 }
-void FAST_FUNC read_cmdline(char *buf, int col, unsigned pid, const char *comm)
+int FAST_FUNC read_cmdline(char *buf, int col, unsigned pid, const char *comm)
 {
        int sz;
        char filename[sizeof("/proc/%u/cmdline") + sizeof(int)*3];
        sprintf(filename, "/proc/%u/cmdline", pid);
        sz = open_read_close(filename, buf, col - 1);
+        if (sz < 0)
+                return sz;
        if (sz > 0) {
-                const char *base;
+                const char *program_basename;
                int comm_len;
                buf[sz] = '\0';
                while (--sz >= 0 && buf[sz] == '\0')
                        continue;
-                /* Prevent basename("process foo/bar") = "bar" */
-                strchrnul(buf, ' ')[0] = '\0';
+                /* Find "program" in "[-][/PATH/TO/]program" */
-                base = bb_basename(buf); /* before we replace argv0's NUL with space */
+                strchrnul(buf, ' ')[0] = '\0'; /* prevent basename("program foo/bar") = "bar" */
+                program_basename = bb_basename(buf[0] == '-' ? buf + 1 : buf);
+                /* ^^^ note: must do it *before* replacing argv0's NUL with space */
+                /* Prevent stuff like this:
+                 *  echo 'sleep 999; exit' >`printf '\ec'`; sh ?c
+                 * messing up top and ps output (or worse).
+                 * This also replaces NULs with spaces, converting
+                 * list of NUL-strings into one string.
+                 */
                while (sz >= 0) {
                        if ((unsigned char)(buf[sz]) < ' ')
                                buf[sz] = ' ';
                        sz--;
                }
-                if (base[0] == '-') /* "-sh" (login shell)? */
-                        base++;
                /* If comm differs from argv0, prepend "{comm} ".
                 * It allows to see thread names set by prctl(PR_SET_NAME).
                 */
                if (!comm)
-                        return;
+                        return 0;
                comm_len = strlen(comm);
                /* Why compare up to comm_len, not COMM_LEN-1?
                 * Well, some processes rewrite argv, and use _spaces_ there
@@ -604,19 +595,20 @@ void FAST_FUNC read_cmdline(char *buf, int col, unsigned pid, const char *comm)
                 * I prefer to still treat argv0 "process foo bar"
                 * as 'equal' to comm "process".
                 */
-                if (strncmp(base, comm, comm_len) != 0) {
+                if (strncmp(program_basename, comm, comm_len) != 0) {
                        comm_len += 3;
                        if (col > comm_len)
                                memmove(buf + comm_len, buf, col - comm_len);
                        snprintf(buf, col, "{%s}", comm);
                        if (col <= comm_len)
-                                return;
+                                return 0;
                        buf[comm_len - 1] = ' ';
                        buf[col - 1] = '\0';
                }
        } else {
                snprintf(buf, col, "[%s]", comm ? comm : "?");
        }
+        return 0;
 }
 #endif  /* ENABLE_PLATFORM_MINGW32 */
diff --git a/libbb/replace.c b/libbb/replace.c
index 6183d3e6f..bc26b04cc 100644
--- a/libbb/replace.c
+++ b/libbb/replace.c
@@ -46,3 +46,17 @@ char* FAST_FUNC xmalloc_substitute_string(const char *src, int count, const char
        //dbg_msg("subst9:'%s'", buf);
        return buf;
 }
+#if 0 /* inlined in libbb.h */
+/* Returns strlen as a bonus */
+size_t FAST_FUNC replace_char(char *str, char from, char to)
+{
+        char *p = str;
+        while (*p) {
+                if (*p == from)
+                        *p = to;
+                p++;
+        }
+        return p - str;
+}
+#endif
diff --git a/libbb/yescrypt/alg-sha256.c b/libbb/yescrypt/alg-sha256.c
index 20e8d1ee4..dc748c968 100644
--- a/libbb/yescrypt/alg-sha256.c
+++ b/libbb/yescrypt/alg-sha256.c
@@ -47,9 +47,12 @@ PBKDF2_SHA256(const uint8_t *passwd, size_t passwdlen,
        /* Iterate through the blocks. */
        for (i = 0; dkLen != 0; ) {
-                uint64_t U[32 / 8];
+                long U[32 / sizeof(long)];
-                uint64_t T[32 / 8];
+                long T[32 / sizeof(long)];
-                uint64_t j;
+// Do not make these ^^ uint64_t[]. Keep them long[].
+// Even though the XORing loop below is optimized out,
+// gcc is not smart enough to realize that 64-bit alignment of the stack
+// is no longer useful, and generates ~50 more bytes of code on i386...
                uint32_t ivec;
                size_t clen;
                int k;
@@ -64,13 +67,15 @@ PBKDF2_SHA256(const uint8_t *passwd, size_t passwdlen,
 //does libbb need a non-vararg version with just one (buf,len)?
                if (c > 1) {
+//in yescrypt, c is always 1, so this if() branch is optimized out
+                        uint64_t j;
                        /* T_i = U_1 ... */
                        memcpy(U, T, 32);
                        for (j = 2; j <= c; j++) {
                                /* Compute U_j. */
                                hmac_peek_hash(&Phctx, (void*)U, U, 32, NULL);
                                /* ... xor U_j ... */
-                                for (k = 0; k < 32 / 8; k++)
+                                for (k = 0; k < 32 / sizeof(long); k++)
                                        T[k] ^= U[k];
                                //TODO: xorbuf32_aligned_long(T, U);
                        }
diff --git a/miscutils/crond.c b/miscutils/crond.c
index 96131cae4..6a384fdfb 100644
--- a/miscutils/crond.c
+++ b/miscutils/crond.c
@@ -989,7 +989,7 @@ static int check_completions(void)
                        if (line->cl_pid <= 0)
                                continue;
-                        r = waitpid(line->cl_pid, NULL, WNOHANG);
+                        r = safe_waitpid(line->cl_pid, NULL, WNOHANG);
                        if (r < 0 || r == line->cl_pid) {
                                process_finished_job(file->cf_username, line);
                                if (line->cl_pid == 0) {
@@ -1001,6 +1001,14 @@ static int check_completions(void)
                        /* else: r == 0: "process is still running" */
                        file->cf_has_running = 1;
                }
+                /* Reap any other children we don't actively track.
+                 * Reportedly, some people run crond as init process!
+                 * Thus, we need to reap orphans, like init does.
+                 */
+                while (wait_any_nohang(NULL) > 0)
+                        continue;
 //FIXME: if !file->cf_has_running && file->deleted: delete it!
 //otherwise deleted entries will stay forever, right?
                num_still_running += file->cf_has_running;
diff --git a/modutils/modprobe-small.c b/modutils/modprobe-small.c
index 77e42e3fb..31a215a29 100644
--- a/modutils/modprobe-small.c
+++ b/modutils/modprobe-small.c
@@ -186,15 +186,6 @@ static char* find_keyword(char *ptr, size_t len, const char *word)
        return NULL;
 }
-static void replace(char *s, char what, char with)
-{
-        while (*s) {
-                if (what == *s)
-                        *s = with;
-                ++s;
-        }
-}
 static char *filename2modname(const char *filename, char *modname)
 {
        int i;
@@ -230,7 +221,7 @@ static char* str_2_list(const char *str)
        dst[len] = '\0';
        memcpy(dst, str, len);
 //TODO: protect against 2+ spaces: "word  word"
-        replace(dst, ' ', '\0');
+        replace_char(dst, ' ', '\0');
        return dst;
 }
@@ -369,14 +360,14 @@ static int parse_module(module_info *info, const char *pathname)
        }
        bksp(); /* remove last ' ' */
        info->aliases = copy_stringbuf();
-        replace(info->aliases, '-', '_');
+        replace_char(info->aliases, '-', '_');
        /* "dependency1 depandency2" */
        reset_stringbuf();
        ptr = find_keyword(module_image, len, "depends=");
        if (ptr && *ptr) {
-                replace(ptr, ',', ' ');
+                replace_char(ptr, ',', ' ');
-                replace(ptr, '-', '_');
+                replace_char(ptr, '-', '_');
                dbg2_error_msg("dep:'%s'", ptr);
                append(ptr);
        }
@@ -707,7 +698,7 @@ static int process_module(char *name, const char *cmdline_options)
        dbg1_error_msg("process_module('%s','%s')", name, cmdline_options);
-        replace(name, '-', '_');
+        replace_char(name, '-', '_');
        dbg1_error_msg("already_loaded:%d is_remove:%d", already_loaded(name), is_remove);
@@ -735,7 +726,7 @@ static int process_module(char *name, const char *cmdline_options)
                char *opt_filename = xasprintf("/etc/modules/%s", name);
                options = xmalloc_open_read_close(opt_filename, NULL);
                if (options)
-                        replace(options, '\n', ' ');
+                        replace_char(options, '\n', ' ');
 #if ENABLE_FEATURE_CMDLINE_MODULE_OPTIONS
                if (cmdline_options) {
                        /* NB: cmdline_options always have one leading ' '
diff --git a/modutils/modprobe.c b/modutils/modprobe.c
index 543f53e99..f890abe53 100644
--- a/modutils/modprobe.c
+++ b/modutils/modprobe.c
@@ -579,7 +579,7 @@ int modprobe_main(int argc UNUSED_PARAM, char **argv)
                parser_t *p = config_open2(CONFIG_DEFAULT_DEPMOD_FILE, xfopen_for_read);
                for (i = 0; argv[i]; i++)
-                        replace(argv[i], '-', '_');
+                        replace_char(argv[i], '-', '_');
                while (config_read(p, tokens, 2, 1, "# \t", PARSE_NORMAL)) {
                        colon = last_char_is(tokens[0], ':');
diff --git a/modutils/modutils.c b/modutils/modutils.c
index cbff20961..862f71f57 100644
--- a/modutils/modutils.c
+++ b/modutils/modutils.c
@@ -69,15 +69,6 @@ void FAST_FUNC moddb_free(module_db *db)
        }
 }
-void FAST_FUNC replace(char *s, char what, char with)
-{
-        while (*s) {
-                if (what == *s)
-                        *s = with;
-                ++s;
-        }
-}
 int FAST_FUNC string_to_llist(char *string, llist_t **llist, const char *delim)
 {
        char *tok;
diff --git a/modutils/modutils.h b/modutils/modutils.h
index 4a702e97c..9b05116d1 100644
--- a/modutils/modutils.h
+++ b/modutils/modutils.h
@@ -47,7 +47,6 @@ module_entry *moddb_get(module_db *db, const char *s) FAST_FUNC;
 module_entry *moddb_get_or_create(module_db *db, const char *s) FAST_FUNC;
 void moddb_free(module_db *db) FAST_FUNC;
-void replace(char *s, char what, char with) FAST_FUNC;
 int string_to_llist(char *string, llist_t **llist, const char *delim) FAST_FUNC;
 char *filename2modname(const char *filename, char *modname) FAST_FUNC;
 #if ENABLE_FEATURE_CMDLINE_MODULE_OPTIONS
diff --git a/networking/ftpd.c b/networking/ftpd.c
index 0d6a289c7..c3125410e 100644
--- a/networking/ftpd.c
+++ b/networking/ftpd.c
@@ -190,54 +190,39 @@ struct globals {
 } while (0)
+/* escape_text("pfx:", str, (0xff << 8) + '\r')
+ * Duplicate 0xff, append \r ^^^^^^^^^^^^^^^^^^
+ */
 static char *
 escape_text(const char *prepend, const char *str, unsigned escapee)
 {
-        unsigned retlen, remainlen, chunklen;
+        char *ret, *p;
-        char *ret, *found;
        char append;
        append = (char)escapee;
        escapee >>= 8;
-        remainlen = strlen(str);
+        ret = xmalloc(strlen(prepend) + strlen(str) * 2 + 1 + 1);
-        retlen = strlen(prepend);
+        p = stpcpy(ret, prepend);
-        ret = xmalloc(retlen + remainlen * 2 + 1 + 1);
-        strcpy(ret, prepend);
        for (;;) {
-                found = strchrnul(str, escapee);
+                char *found = strchrnul(str, escapee);
-                chunklen = found - str + 1;
-                /* Copy chunk up to and including escapee (or NUL) to ret */
+                /* Copy up to and including escapee (or NUL) */
-                memcpy(ret + retlen, str, chunklen);
+                p = mempcpy(p, str, found - str + 1);
-                retlen += chunklen;
                if (*found == '\0') {
                        /* It wasn't escapee, it was NUL! */
-                        ret[retlen - 1] = append; /* replace NUL */
-                        ret[retlen] = '\0'; /* add NUL */
                        break;
                }
-                ret[retlen++] = escapee; /* duplicate escapee */
                str = found + 1;
+                *p++ = escapee; /* duplicate escapee */
        }
+        p[-1] = append; /* replace NUL */
+        *p = '\0'; /* add NUL */
        return ret;
 }
-/* Returns strlen as a bonus */
-static unsigned
-replace_char(char *str, char from, char to)
-{
-        char *p = str;
-        while (*p) {
-                if (*p == from)
-                        *p = to;
-                p++;
-        }
-        return p - str;
-}
 static void
 verbose_log(const char *str)
 {
diff --git a/procps/pmap.c b/procps/pmap.c
index 49f7688d9..3069856a4 100644
--- a/procps/pmap.c
+++ b/procps/pmap.c
@@ -29,10 +29,14 @@
 #if ULLONG_MAX == 0xffffffff
 # define TABS "\t"
+# define SIZEWIDTHx "7"
+# define SIZEWIDTH  "9"
 # define AFMTLL "8"
 # define DASHES ""
 #else
 # define TABS "\t\t"
+# define SIZEWIDTHx "15"
+# define SIZEWIDTH  "17"
 # define AFMTLL "16"
 # define DASHES "--------"
 #endif
@@ -42,49 +46,145 @@ enum {
        OPT_q = 1 << 1,
 };
-static void print_smaprec(struct smaprec *currec, void *data)
+struct smaprec {
-{
+        // For mixed 32/64 userspace, 32-bit pmap still needs
-        unsigned opt = (uintptr_t)data;
+        // 64-bit field here to correctly show 64-bit processes:
+        unsigned long long smap_start;
+        // Make size wider too:
+        // I've seen 1203765248 kb large "---p" mapping in a browser,
+        // this cuts close to 4 terabytes.
+        unsigned long long smap_size;
+        // (strictly speaking, other fields need to be wider too,
+        // but they are in kbytes, not bytes, and they hold sizes,
+        // not start addresses, sizes tend to be less than 4 terabytes)
+        unsigned long private_dirty;
+        unsigned long smap_pss, smap_swap;
+        char smap_mode[5];
+        char *smap_name;
+};
+// How long the filenames and command lines we want to handle?
+#define PMAP_BUFSZ 4096
+static void print_smaprec(struct smaprec *currec)
+{
        printf("%0" AFMTLL "llx ", currec->smap_start);
-        if (opt & OPT_x)
+        if (option_mask32 & OPT_x)
-                printf("%7lu %7lu %7lu %7lu ",
+                printf("%7llu %7lu %7lu %7lu ",
                        currec->smap_size,
                        currec->smap_pss,
                        currec->private_dirty,
                        currec->smap_swap);
        else
-                printf("%7luK", currec->smap_size);
+                printf("%7lluK", currec->smap_size);
-        printf(" %.4s  %s\n", currec->smap_mode, currec->smap_name);
+        printf(" %.4s  %s\n", currec->smap_mode, currec->smap_name ? : "  [ anon ]");
+}
+/* libbb's procps_read_smaps() looks somewhat similar,
+ * but the collected information is sufficiently different
+ * that merging them into one function is not a good idea
+ * (unless you feel masochistic today).
+ */
+static int read_smaps(pid_t pid, char buf[PMAP_BUFSZ], struct smaprec *total)
+{
+        FILE *file;
+        struct smaprec currec;
+        char filename[sizeof("/proc/%u/smaps") + sizeof(int)*3];
+        sprintf(filename, "/proc/%u/smaps", (int)pid);
+        file = fopen_for_read(filename);
+        if (!file)
+                return 1;
+        memset(&currec, 0, sizeof(currec));
+        while (fgets(buf, PMAP_BUFSZ, file)) {
+                // Each mapping datum has this form:
+                // f7d29000-f7d39000 rw-s FILEOFS M:m INODE FILENAME
+                // Size:                nnn kB
+                // Rss:                 nnn kB
+                // .....
+                char *tp, *p;
+                if (buf[0] == 'S' || buf[0] == 'P') {
+#define SCAN(S, X) \
+                        if (memcmp(buf, S, sizeof(S)-1) == 0) { \
+                                tp = skip_whitespace(buf + sizeof(S)-1); \
+                                total->X += currec.X = fast_strtoul_10(&tp); \
+                                continue; \
+                        }
+                        SCAN("Pss:"          , smap_pss     );
+                        SCAN("Swap:"         , smap_swap    );
+                        SCAN("Private_Dirty:", private_dirty);
+#undef SCAN
+                }
+                tp = strchr(buf, '-');
+                if (tp) {
+                        // We reached next mapping - the line of this form:
+                        // f7d29000-f7d39000 rw-s FILEOFS M:m INODE FILENAME
+                        // If we have a previous record, there's nothing more
+                        // for it, print and clear currec
+                        if (currec.smap_size)
+                                print_smaprec(&currec);
+                        free(currec.smap_name);
+                        memset(&currec, 0, sizeof(currec));
+                        *tp = ' ';
+                        tp = buf;
+                        currec.smap_start = fast_strtoull_16(&tp);
+                        currec.smap_size = (fast_strtoull_16(&tp) - currec.smap_start) >> 10;
+                        strncpy(currec.smap_mode, tp, sizeof(currec.smap_mode)-1);
+                        // skipping "rw-s FILEOFS M:m INODE "
+                        tp = skip_fields(tp, 4);
+                        tp = skip_whitespace(tp); // there may be many spaces, can't just "tp++"
+                        p = strchrnul(tp, '\n');
+                        if (p != tp) {
+                                currec.smap_name = xstrndup(tp, p - tp);
+                        }
+                        total->smap_size += currec.smap_size;
+                }
+        } // while (got line)
+        fclose(file);
+        if (currec.smap_size)
+                print_smaprec(&currec);
+        free(currec.smap_name);
+        return 0;
 }
 static int procps_get_maps(pid_t pid, unsigned opt)
 {
        struct smaprec total;
        int ret;
-        char buf[256];
+        char buf[PMAP_BUFSZ];
+        ret = read_cmdline(buf, sizeof(buf), pid, NULL);
+        if (ret < 0)
+                return ret;
-        read_cmdline(buf, sizeof(buf), pid, NULL);
        printf("%u: %s\n", (int)pid, buf);
        if (!(opt & OPT_q) && (opt & OPT_x))
                puts("Address" TABS "  Kbytes     PSS   Dirty    Swap  Mode  Mapping");
        memset(&total, 0, sizeof(total));
+        ret = read_smaps(pid, buf, &total);
-        ret = procps_read_smaps(pid, &total, print_smaprec, (void*)(uintptr_t)opt);
        if (ret)
                return ret;
        if (!(opt & OPT_q)) {
                if (opt & OPT_x)
                        printf("--------" DASHES "  ------  ------  ------  ------\n"
-                                "total" TABS " %7lu %7lu %7lu %7lu\n",
+                                "total kB %"SIZEWIDTHx"llu %7lu %7lu %7lu\n",
                                total.smap_size, total.smap_pss, total.private_dirty, total.smap_swap);
                else
-                        printf("mapped: %luK\n", total.smap_size);
+                        printf(" total %"SIZEWIDTH"lluK\n", total.smap_size);
        }
        return 0;
diff --git a/procps/top.c b/procps/top.c
index 09d31c673..96b3e2d4e 100644
--- a/procps/top.c
+++ b/procps/top.c
@@ -117,10 +117,15 @@
 #include "libbb.h"
-#define ESC "\033"
+#define ESC     "\033"
+#define HOME    ESC"[H"
+#define CLREOS  ESC"[J"
+#define CLREOL  ESC"[K"
+#define REVERSE ESC"[7m"
+#define NORMAL  ESC"[m"
 typedef struct top_status_t {
-        unsigned long vsz;
+        unsigned long memsize;
 #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
        unsigned long ticks;
        unsigned pcpu; /* delta of ticks */
@@ -161,13 +166,16 @@ struct globals {
        top_status_t *top;
        int ntop;
        smallint inverted;
+        smallint not_first_line;
 #if ENABLE_FEATURE_TOPMEM
        smallint sort_field;
 #endif
 #if ENABLE_FEATURE_TOP_SMP_CPU
        smallint smp_cpu_info; /* one/many cpu info lines? */
 #endif
-        unsigned lines;  /* screen height */
+        int lines_remaining;
+        unsigned lines;     /* screen height */
+        unsigned scr_width; /* width, clamped <= LINE_BUF_SIZE-2 */
 #if ENABLE_FEATURE_TOP_INTERACTIVE
        struct termios initial_settings;
        int scroll_ofs;
@@ -212,7 +220,6 @@ struct globals {
 #define cpu_prev_jif     (G.cpu_prev_jif      )
 #define num_cpus         (G.num_cpus          )
 #define total_pcpu       (G.total_pcpu        )
-#define line_buf         (G.line_buf          )
 #define INIT_G() do { \
        SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
        BUILD_BUG_ON(LINE_BUF_SIZE <= 80); \
@@ -241,8 +248,8 @@ static int pid_sort(top_status_t *P, top_status_t *Q)
 static int mem_sort(top_status_t *P, top_status_t *Q)
 {
        /* We want to avoid unsigned->signed and truncation errors */
-        if (Q->vsz < P->vsz) return -1;
+        if (Q->memsize < P->memsize) return -1;
-        return Q->vsz != P->vsz; /* 0 if ==, 1 if > */
+        return Q->memsize != P->memsize; /* 0 if ==, 1 if > */
 }
@@ -283,9 +290,9 @@ static NOINLINE int read_cpu_jiffy(FILE *fp, jiffy_counts_t *p_jif)
 #endif
        int ret;
-        if (!fgets(line_buf, LINE_BUF_SIZE, fp) || line_buf[0] != 'c' /* not "cpu" */)
+        if (!fgets(G.line_buf, LINE_BUF_SIZE, fp) || G.line_buf[0] != 'c' /* not "cpu" */)
                return 0;
-        ret = sscanf(line_buf, fmt,
+        ret = sscanf(G.line_buf, fmt,
                        &p_jif->usr, &p_jif->nic, &p_jif->sys, &p_jif->idle,
                        &p_jif->iowait, &p_jif->irq, &p_jif->softirq,
                        &p_jif->steal);
@@ -362,7 +369,7 @@ static void do_stats(void)
        get_jiffy_counts();
        total_pcpu = 0;
-        /* total_vsz = 0; */
+        /* total_memsize = 0; */
        new_hist = xmalloc(sizeof(new_hist[0]) * ntop);
        /*
         * Make a pass through the data to get stats.
@@ -394,7 +401,7 @@ static void do_stats(void)
                        i = (i+1) % prev_hist_count;
                        /* hist_iterations++; */
                } while (i != last_i);
-                /* total_vsz += cur->vsz; */
+                /* total_memsize += cur->memsize; */
        }
        /*
@@ -407,6 +414,38 @@ static void do_stats(void)
 #endif /* FEATURE_TOP_CPU_USAGE_PERCENTAGE */
+static void print_line_buf(void)
+{
+        const char *fmt;
+        G.lines_remaining--;
+        fmt = OPT_BATCH_MODE ? "\n""%.*s" : "\n""%.*s"CLREOL;
+        if (!G.not_first_line) {
+                G.not_first_line = 1;
+                /* Go to top */
+                fmt = OPT_BATCH_MODE ? "%.*s" : HOME"%.*s"CLREOL;
+        }
+        printf(fmt, G.scr_width - 1, G.line_buf);
+}
+static void print_line_bold(void)
+{
+        G.lines_remaining--;
+//we never print first line in bold
+//      if (!G.not_first_line) {
+//              printf(OPT_BATCH_MODE ? "%.*s" : HOME"%.*s"CLREOL, G.scr_width - 1, G.line_buf);
+//              G.not_first_line = 1;
+//      } else {
+                printf(OPT_BATCH_MODE ? "\n""%.*s" : "\n"REVERSE"%.*s"NORMAL CLREOL, G.scr_width - 1, G.line_buf);
+//      }
+}
+static void print_end(void)
+{
+        fputs_stdout(OPT_BATCH_MODE ? "\n" : CLREOS"\r");
+        G.not_first_line = 0; /* next print will be "first line" (will clear the screen) */
+}
 #if ENABLE_FEATURE_TOP_CPU_GLOBAL_PERCENTS && ENABLE_FEATURE_TOP_DECIMALS
 /* formats 7 char string (8 with terminating NUL) */
 static char *fmt_100percent_8(char pbuf[8], unsigned value, unsigned total)
@@ -433,7 +472,7 @@ static char *fmt_100percent_8(char pbuf[8], unsigned value, unsigned total)
 #endif
 #if ENABLE_FEATURE_TOP_CPU_GLOBAL_PERCENTS
-static void display_cpus(int scr_width, char *scrbuf, int *lines_rem_p)
+static void display_cpus(void)
 {
        /*
         * xxx% = (cur_jif.xxx - prev_jif.xxx) / (cur_jif.total - prev_jif.total) * 100%
@@ -469,8 +508,8 @@ static void display_cpus(int scr_width, char *scrbuf, int *lines_rem_p)
 # else
        /* Loop thru CPU(s) */
        n_cpu_lines = smp_cpu_info ? num_cpus : 1;
-        if (n_cpu_lines > *lines_rem_p)
+        if (n_cpu_lines > G.lines_remaining)
-                n_cpu_lines = *lines_rem_p;
+                n_cpu_lines = G.lines_remaining;
        for (i = 0; i < n_cpu_lines; i++) {
                p_jif = &cpu_jif[i];
@@ -488,7 +527,7 @@ static void display_cpus(int scr_width, char *scrbuf, int *lines_rem_p)
                        CALC_STAT(softirq);
                        /*CALC_STAT(steal);*/
-                        snprintf(scrbuf, scr_width,
+                        sprintf(G.line_buf,
                                /* Barely fits in 79 chars when in "decimals" mode. */
 # if ENABLE_FEATURE_TOP_SMP_CPU
                                "CPU%s:"FMT"usr"FMT"sys"FMT"nic"FMT"idle"FMT"io"FMT"irq"FMT"sirq",
@@ -501,16 +540,15 @@ static void display_cpus(int scr_width, char *scrbuf, int *lines_rem_p)
                                /*, SHOW_STAT(steal) - what is this 'steal' thing? */
                                /* I doubt anyone wants to know it */
                        );
-                        puts(scrbuf);
+                        print_line_buf();
                }
        }
 # undef SHOW_STAT
 # undef CALC_STAT
 # undef FMT
-        *lines_rem_p -= i;
 }
 #else  /* !ENABLE_FEATURE_TOP_CPU_GLOBAL_PERCENTS */
-# define display_cpus(scr_width, scrbuf, lines_rem) ((void)0)
+# define display_cpus() ((void)0)
 #endif
 enum {
@@ -564,52 +602,55 @@ static void parse_meminfo(unsigned long meminfo[MI_MAX])
        fclose(f);
 }
-static unsigned long display_header(int scr_width, int *lines_rem_p)
+static void cmdline_to_line_buf_and_print(unsigned offset, unsigned pid, const char *comm)
+{
+        int width = G.scr_width - offset;
+        if (width > 1) /* wider than to fit just the NUL? */
+                read_cmdline(G.line_buf + offset, width, pid, comm);
+//TODO: read_cmdline() sanitizes control chars, but not chars above 0x7e
+        print_line_buf();
+}
+static unsigned long display_header(void)
 {
-        char scrbuf[100]; /* [80] was a bit too low on 8Gb ram box */
        char *buf;
        unsigned long meminfo[MI_MAX];
        parse_meminfo(meminfo);
        /* Output memory info */
-        if (scr_width > (int)sizeof(scrbuf))
+        sprintf(G.line_buf,
-                scr_width = sizeof(scrbuf);
-        snprintf(scrbuf, scr_width,
                "Mem: %luK used, %luK free, %luK shrd, %luK buff, %luK cached",
                meminfo[MI_MEMTOTAL] - meminfo[MI_MEMFREE],
                meminfo[MI_MEMFREE],
                meminfo[MI_MEMSHARED] + meminfo[MI_SHMEM],
                meminfo[MI_BUFFERS],
                meminfo[MI_CACHED]);
-        /* Go to top & clear to the end of screen */
+        print_line_buf();
-        printf(OPT_BATCH_MODE ? "%s\n" : ESC"[H" ESC"[J" "%s\n", scrbuf);
-        (*lines_rem_p)--;
        /* Display CPU time split as percentage of total time.
         * This displays either a cumulative line or one line per CPU.
         */
-        display_cpus(scr_width, scrbuf, lines_rem_p);
+        display_cpus();
        /* Read load average as a string */
-        buf = stpcpy(scrbuf, "Load average: ");
+        buf = stpcpy(G.line_buf, "Load average: ");
-        open_read_close("loadavg", buf, sizeof(scrbuf) - sizeof("Load average: "));
+        open_read_close("loadavg", buf, sizeof(G.line_buf) - sizeof("Load average: "));
-        scrbuf[scr_width - 1] = '\0';
+        G.line_buf[sizeof(G.line_buf) - 1] = '\0'; /* paranoia */
        strchrnul(buf, '\n')[0] = '\0';
-        puts(scrbuf);
+        print_line_buf();
-        (*lines_rem_p)--;
        return meminfo[MI_MEMTOTAL];
 }
-static NOINLINE void display_process_list(int lines_rem, int scr_width)
+static NOINLINE void display_process_list(void)
 {
        enum {
                BITS_PER_INT = sizeof(int) * 8
        };
        top_status_t *s;
-        unsigned long total_memory = display_header(scr_width, &lines_rem); /* or use total_vsz? */
+        unsigned long total_memory = display_header();
        /* xxx_shift and xxx_scale variables allow us to replace
         * expensive divides with multiply and shift */
        unsigned pmem_shift, pmem_scale, pmem_half;
@@ -621,7 +662,7 @@ static NOINLINE void display_process_list(int lines_rem, int scr_width)
 #if ENABLE_FEATURE_TOP_DECIMALS
 # define UPSCALE 1000
-typedef struct { unsigned quot, rem; } bb_div_t;
+        typedef struct { unsigned quot, rem; } bb_div_t;
 /* Used to have "div_t name = div((val), 10)" here
 * (IOW: intended to use libc-compatible way to divide and use
 * both result and remainder, but musl does not inline div()...)
@@ -629,28 +670,34 @@ typedef struct { unsigned quot, rem; } bb_div_t;
 */
 # define CALC_STAT(name, val) bb_div_t name = { (val) / 10, (val) % 10 }
 # define SHOW_STAT(name) name.quot, '0'+name.rem
+# define SANITIZE(name)  if (name.quot > 99) name.quot = 99, name.rem = (unsigned char)('+' - '0')
 # define FMT "%3u.%c"
 #else
 # define UPSCALE 100
 # define CALC_STAT(name, val) unsigned name = (val)
+# define SANITIZE(name)  if (name > 99) name = 99
 # define SHOW_STAT(name) name
 # define FMT "%4u%%"
 #endif
-        /* what info of the processes is shown */
+        strcpy(G.line_buf, "  PID  PPID USER     STAT   RSS %RSS"
-        printf(OPT_BATCH_MODE ? "%.*s" : ESC"[7m" "%.*s" ESC"[m", scr_width,
-                "  PID  PPID USER     STAT   VSZ %VSZ"
                IF_FEATURE_TOP_SMP_PROCESS(" CPU")
                IF_FEATURE_TOP_CPU_USAGE_PERCENTAGE(" %CPU")
                " COMMAND");
-        lines_rem--;
+        print_line_bold();
-        /*
+        /* %RSS = s->memsize / MemTotal * 100%
-         * %VSZ = s->vsz/MemTotal
+         * Calculate this with multiply and shift. Example:
+         * shift = 12
+         * scale = 100 * 0x1000 / total_memory
+         * percent_mem = (size_mem * scale) >> shift
+         *            ~= (size_mem >> shift) * scale
+         *            ~= (size_mem >> shift) * 100 * (1 << shift) / total_memory
+         *            ~= size_mem * 100 / total_memory
         */
        pmem_shift = BITS_PER_INT-11;
        pmem_scale = UPSCALE*(1U<<(BITS_PER_INT-11)) / total_memory;
-        /* s->vsz is in kb. we want (s->vsz * pmem_scale) to never overflow */
+        /* s->memsize is in kb. we want (s->memsize * pmem_scale) to never overflow */
        while (pmem_scale >= 512) {
                pmem_scale /= 4;
                pmem_shift -= 2;
@@ -689,25 +736,29 @@ typedef struct { unsigned quot, rem; } bb_div_t;
        pcpu_half = (1U << pcpu_shift) / (ENABLE_FEATURE_TOP_DECIMALS ? 20 : 2);
        /* printf(" pmem_scale=%u pcpu_scale=%u ", pmem_scale, pcpu_scale); */
 #endif
+        if (G.lines_remaining > ntop - G_scroll_ofs)
+                G.lines_remaining = ntop - G_scroll_ofs;
        /* Ok, all preliminary data is ready, go through the list */
-        scr_width += 2; /* account for leading '\n' and trailing NUL */
-        if (lines_rem > ntop - G_scroll_ofs)
-                lines_rem = ntop - G_scroll_ofs;
        s = top + G_scroll_ofs;
-        while (--lines_rem >= 0) {
+        while (G.lines_remaining > 0) {
                int n;
                char *ppu;
                char ppubuf[sizeof(int)*3 * 2 + 12];
-                char vsz_str_buf[8];
+                char memsize_str_buf[8];
                unsigned col;
-                CALC_STAT(pmem, (s->vsz*pmem_scale + pmem_half) >> pmem_shift);
+                CALC_STAT(pmem, (s->memsize*pmem_scale + pmem_half) >> pmem_shift);
 #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
                CALC_STAT(pcpu, (s->pcpu*pcpu_scale + pcpu_half) >> pcpu_shift);
 #endif
+                /* VSZ can be much larger than total memory
+                 * (seen values close to 2Tbyte), don't try to display
+                 * "uses 12345.6% of MemTotal" (won't fit the column)
+                 */
+                SANITIZE(pmem);
-                smart_ulltoa5(s->vsz, vsz_str_buf, " mgtpezy");
+                smart_ulltoa5(s->memsize, memsize_str_buf, " mgtpezy");
                /* PID PPID USER STAT VSZ %VSZ [%CPU] COMMAND */
                n = sprintf(ppubuf, "%5u %5u %-8.8s", s->pid, s->ppid, get_cached_username(s->uid));
                ppu = ppubuf;
@@ -736,27 +787,23 @@ typedef struct { unsigned quot, rem; } bb_div_t;
                        ppu[6+6+8] = '\0'; /* truncate USER */
                }
 shortened:
-                col = snprintf(line_buf, scr_width,
+                col = sprintf(G.line_buf,
-                                "\n" "%s %s  %.5s" FMT
+                                "%s %s  %.5s" FMT
                                IF_FEATURE_TOP_SMP_PROCESS(" %3d")
                                IF_FEATURE_TOP_CPU_USAGE_PERCENTAGE(FMT)
                                " ",
                                ppu,
-                                s->state, vsz_str_buf,
+                                s->state, memsize_str_buf,
                                SHOW_STAT(pmem)
                                IF_FEATURE_TOP_SMP_PROCESS(, s->last_seen_on_cpu)
                                IF_FEATURE_TOP_CPU_USAGE_PERCENTAGE(, SHOW_STAT(pcpu))
                );
-                if ((int)(scr_width - col) > 1)
+                cmdline_to_line_buf_and_print(col, s->pid, s->comm);
-                        read_cmdline(line_buf + col, scr_width - col, s->pid, s->comm);
-                fputs_stdout(line_buf);
                /* printf(" %d/%d %lld/%lld", s->pcpu, total_pcpu,
                        cur_jif.busy - prev_jif.busy, cur_jif.total - prev_jif.total); */
                s++;
        }
        /* printf(" %d", hist_iterations); */
-        bb_putchar(OPT_BATCH_MODE ? '\n' : '\r');
-        fflush_all();
 }
 #undef UPSCALE
 #undef SHOW_STAT
@@ -828,36 +875,34 @@ static int topmem_sort(char *a, char *b)
 }
 /* display header info (meminfo / loadavg) */
-static void display_topmem_header(int scr_width, int *lines_rem_p)
+static void display_topmem_header(void)
 {
        unsigned long meminfo[MI_MAX];
        parse_meminfo(meminfo);
-        snprintf(line_buf, LINE_BUF_SIZE,
+        sprintf(G.line_buf,
                "Mem total:%lu anon:%lu map:%lu free:%lu",
                meminfo[MI_MEMTOTAL],
                meminfo[MI_ANONPAGES],
                meminfo[MI_MAPPED],
                meminfo[MI_MEMFREE]);
-        printf(OPT_BATCH_MODE ? "%.*s\n" : ESC"[H" ESC"[J" "%.*s\n", scr_width, line_buf);
+        print_line_buf();
-        snprintf(line_buf, LINE_BUF_SIZE,
+        sprintf(G.line_buf,
                " slab:%lu buf:%lu cache:%lu dirty:%lu write:%lu",
                meminfo[MI_SLAB],
                meminfo[MI_BUFFERS],
                meminfo[MI_CACHED],
                meminfo[MI_DIRTY],
                meminfo[MI_WRITEBACK]);
-        printf("%.*s\n", scr_width, line_buf);
+        print_line_buf();
-        snprintf(line_buf, LINE_BUF_SIZE,
+        sprintf(G.line_buf,
                "Swap total:%lu free:%lu", // TODO: % used?
                meminfo[MI_SWAPTOTAL],
                meminfo[MI_SWAPFREE]);
-        printf("%.*s\n", scr_width, line_buf);
+        print_line_buf();
-        (*lines_rem_p) -= 3;
 }
 /* see http://en.wikipedia.org/wiki/Tera */
@@ -870,75 +915,57 @@ static void ulltoa4_and_space(unsigned long long ul, char buf[5])
        smart_ulltoa4(ul, buf, " mgtpezy")[0] = ' ';
 }
-static NOINLINE void display_topmem_process_list(int lines_rem, int scr_width)
+static NOINLINE void display_topmem_process_list(void)
 {
-#define HDR_STR "  PID   VSZ VSZRW   RSS (SHR) DIRTY (SHR) STACK"
-#define MIN_WIDTH sizeof(HDR_STR)
        const topmem_status_t *s = topmem + G_scroll_ofs;
        char *cp, ch;
-        display_topmem_header(scr_width, &lines_rem);
+        display_topmem_header();
-        strcpy(line_buf, HDR_STR " COMMAND");
+        strcpy(G.line_buf, "  PID   VSZ VSZRW   RSS (SHR) DIRTY (SHR) STACK COMMAND");
        /* Mark the ^FIELD^ we sort by */
-        cp = &line_buf[5 + sort_field * 6];
+        cp = &G.line_buf[5 + sort_field * 6];
        ch = "^_"[inverted];
        cp[6] = ch;
        do *cp++ = ch; while (*cp == ' ');
+        print_line_bold();
-        printf(OPT_BATCH_MODE ? "%.*s" : ESC"[7m" "%.*s" ESC"[m", scr_width, line_buf);
+        if (G.lines_remaining > ntop - G_scroll_ofs)
-        lines_rem--;
+                G.lines_remaining = ntop - G_scroll_ofs;
+        while (G.lines_remaining > 0) {
-        if (lines_rem > ntop - G_scroll_ofs)
-                lines_rem = ntop - G_scroll_ofs;
-        while (--lines_rem >= 0) {
                /* PID VSZ VSZRW RSS (SHR) DIRTY (SHR) COMMAND */
-                int n = sprintf(line_buf, "%5u ", s->pid);
+                int n = sprintf(G.line_buf, "%5u ", s->pid);
                if (n > 7) {
                        /* PID is 7 chars long (up to 4194304) */
-                        ulltoa4_and_space(s->vsz  , &line_buf[8]);
+                        ulltoa4_and_space(s->vsz  , &G.line_buf[8]);
-                        ulltoa4_and_space(s->vszrw, &line_buf[8+5]);
+                        ulltoa4_and_space(s->vszrw, &G.line_buf[8+5]);
                        /* the next field (RSS) starts at 8+10 = 3*6 */
                } else {
                        if (n == 7) /* PID is 6 chars long */
-                                ulltoa4_and_space(s->vsz, &line_buf[7]);
+                                ulltoa4_and_space(s->vsz, &G.line_buf[7]);
                                /* the next field (VSZRW) starts at 7+5 = 2*6 */
                        else /* PID is 5 chars or less */
-                                ulltoa5_and_space(s->vsz, &line_buf[6]);
+                                ulltoa5_and_space(s->vsz, &G.line_buf[6]);
-                        ulltoa5_and_space(s->vszrw, &line_buf[2*6]);
+                        ulltoa5_and_space(s->vszrw, &G.line_buf[2*6]);
-                }
-                ulltoa5_and_space(s->rss     , &line_buf[3*6]);
-                ulltoa5_and_space(s->rss_sh  , &line_buf[4*6]);
-                ulltoa5_and_space(s->dirty   , &line_buf[5*6]);
-                ulltoa5_and_space(s->dirty_sh, &line_buf[6*6]);
-                ulltoa5_and_space(s->stack   , &line_buf[7*6]);
-                line_buf[8*6] = '\0';
-                if (scr_width > (int)MIN_WIDTH) {
-                        read_cmdline(&line_buf[8*6], scr_width - MIN_WIDTH, s->pid, s->comm);
                }
-                printf("\n""%.*s", scr_width, line_buf);
+                ulltoa5_and_space(s->rss     , &G.line_buf[3*6]);
+                ulltoa5_and_space(s->rss_sh  , &G.line_buf[4*6]);
+                ulltoa5_and_space(s->dirty   , &G.line_buf[5*6]);
+                ulltoa5_and_space(s->dirty_sh, &G.line_buf[6*6]);
+                ulltoa5_and_space(s->stack   , &G.line_buf[7*6]);
+                G.line_buf[8*6] = '\0';
+                cmdline_to_line_buf_and_print(8*6, s->pid, s->comm);
                s++;
        }
-        bb_putchar(OPT_BATCH_MODE ? '\n' : '\r');
-        fflush_all();
-#undef HDR_STR
-#undef MIN_WIDTH
 }
-#else
+#endif /* end TOPMEM support */
-void display_topmem_process_list(int lines_rem, int scr_width);
-int topmem_sort(char *a, char *b);
-#endif /* TOPMEM */
-/*
- * end TOPMEM support
- */
 enum {
        TOP_MASK = 0
                | PSSCAN_PID
                | PSSCAN_PPID
-                | PSSCAN_VSZ
+                | PSSCAN_RSS
                | PSSCAN_STIME
                | PSSCAN_UTIME
                | PSSCAN_STATE
@@ -950,7 +977,7 @@ enum {
                | PSSCAN_SMAPS
                | PSSCAN_COMM,
        EXIT_MASK = 0,
-        NO_RESCAN_MASK = (unsigned)-1,
+        ONLY_REDRAW = (unsigned)-1,
 };
 #if ENABLE_FEATURE_TOP_INTERACTIVE
@@ -963,15 +990,22 @@ static unsigned handle_input(unsigned scan_mask, duration_t interval)
        }
        while (1) {
-                int32_t c;
+                int32_t c, cc;
                c = safe_read_key(STDIN_FILENO, G.kbd_input, interval * 1000);
-                if (c == -1 && errno != EAGAIN) {
+                if (c == -1) {
-                        /* error/EOF */
+                        if (errno != EAGAIN)
-                        option_mask32 |= OPT_EOF;
+                                /* error/EOF */
+                                option_mask32 |= OPT_EOF;
+                        /* else: timeout - rescan and refresh */
                        break;
                }
                interval = 0;
+                /* "continue" statements below return to do one additional
+                 * quick attempt to read a key. This prevents
+                 * long sequence of e.g. "nnnnnnnnnnnnnnnnnnnnnnnnnn"
+                 * to cause lots of rescans.
+                 */
                if (c == initial_settings.c_cc[VINTR])
                        return EXIT_MASK;
@@ -1005,9 +1039,10 @@ static unsigned handle_input(unsigned scan_mask, duration_t interval)
                                G_scroll_ofs = ntop - 1;
                        if (G_scroll_ofs < 0)
                                G_scroll_ofs = 0;
-                        return NO_RESCAN_MASK;
+                        return ONLY_REDRAW;
                }
+                cc = c;
                c |= 0x20; /* lowercase */
                if (c == 'q')
                        return EXIT_MASK;
@@ -1055,9 +1090,17 @@ static unsigned handle_input(unsigned scan_mask, duration_t interval)
                        continue;
                }
 #  if ENABLE_FEATURE_TOPMEM
+                if (cc == 'S') {
+                        if (--sort_field < 0)
+                                sort_field = NUM_SORT_FIELD - 1;
+                        if (--sort_field < 0)
+                                sort_field = NUM_SORT_FIELD - 1;
+                }
                if (c == 's') {
-                        scan_mask = TOPMEM_MASK;
                        sort_field = (sort_field + 1) % NUM_SORT_FIELD;
+                        if (scan_mask == TOPMEM_MASK)
+                                return ONLY_REDRAW;
+                        scan_mask = TOPMEM_MASK;
                        free(prev_hist);
                        prev_hist = NULL;
                        prev_hist_count = 0;
@@ -1066,7 +1109,7 @@ static unsigned handle_input(unsigned scan_mask, duration_t interval)
 #  endif
                if (c == 'r') {
                        inverted ^= 1;
-                        continue;
+                        return ONLY_REDRAW;
                }
 #  if ENABLE_FEATURE_TOP_SMP_CPU
                /* procps-2.0.18 uses 'C', 3.2.7 uses '1' */
@@ -1088,8 +1131,8 @@ static unsigned handle_input(unsigned scan_mask, duration_t interval)
                }
 #  endif
 # endif
-                break; /* unknown key -> force refresh */
+                /* Unknown key. Eat remaining buffered input (if any) */
-        }
+        } /* while (1) */
        return scan_mask;
 }
@@ -1155,7 +1198,7 @@ int top_main(int argc UNUSED_PARAM, char **argv)
 {
        duration_t interval;
        int iterations;
-        unsigned col;
+        unsigned opt;
        char *str_interval, *str_iterations;
        unsigned scan_mask = TOP_MASK;
@@ -1172,13 +1215,13 @@ int top_main(int argc UNUSED_PARAM, char **argv)
        /* all args are options; -n NUM */
        make_all_argv_opts(argv); /* options can be specified w/o dash */
-        col = getopt32(argv, "d:n:bHm", &str_interval, &str_iterations);
+        opt = getopt32(argv, "d:n:bHm", &str_interval, &str_iterations);
        /* NB: -m and -H are accepted even if not configured */
 #if ENABLE_FEATURE_TOPMEM
-        if (col & OPT_m) /* -m (busybox specific) */
+        if (opt & OPT_m) /* -m (busybox specific) */
                scan_mask = TOPMEM_MASK;
 #endif
-        if (col & OPT_d) {
+        if (opt & OPT_d) {
                /* work around for "-d 1" -> "-d -1" done by make_all_argv_opts() */
                if (str_interval[0] == '-')
                        str_interval++;
@@ -1187,18 +1230,17 @@ int top_main(int argc UNUSED_PARAM, char **argv)
                if (interval > INT_MAX / 1000)
                        interval = INT_MAX / 1000;
        }
-        if (col & OPT_n) {
+        if (opt & OPT_n) {
                if (str_iterations[0] == '-')
                        str_iterations++;
                iterations = xatou(str_iterations);
        }
 #if ENABLE_FEATURE_SHOW_THREADS
-        if (col & OPT_H) {
+        if (opt & OPT_H) {
                scan_mask |= PSSCAN_TASKS;
        }
 #endif
-        /* change to /proc */
        xchdir("/proc");
 #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
@@ -1226,23 +1268,22 @@ int top_main(int argc UNUSED_PARAM, char **argv)
 #endif
        while (scan_mask != EXIT_MASK) {
-                IF_FEATURE_TOP_INTERACTIVE(unsigned new_mask;)
+                IF_FEATURE_TOP_INTERACTIVE(unsigned new_mask = scan_mask;)
                procps_status_t *p = NULL;
-                if (OPT_BATCH_MODE) {
+                G.lines = INT_MAX;
-                        G.lines = INT_MAX;
+                G.scr_width = LINE_BUF_SIZE - 2; /* +2 bytes for '\n', NUL */
-                        col = LINE_BUF_SIZE - 2; /* +2 bytes for '\n', NUL */
+                if (!OPT_BATCH_MODE) {
-                } else {
                        G.lines = 24; /* default */
-                        col = 79;
+                        G.scr_width = 80;
                        /* We output to stdout, we need size of stdout (not stdin)! */
-                        get_terminal_width_height(STDOUT_FILENO, &col, &G.lines);
+                        get_terminal_width_height(STDOUT_FILENO, &G.scr_width, &G.lines);
-                        if (G.lines < 5 || col < 10) {
+                        if (G.lines < 5 || G.scr_width < 10) {
                                sleep_for_duration(interval);
                                continue;
                        }
-                        if (col > LINE_BUF_SIZE - 2)
+                        if (G.scr_width > LINE_BUF_SIZE - 2)
-                                col = LINE_BUF_SIZE - 2;
+                                G.scr_width = LINE_BUF_SIZE - 2;
                }
                /* read process IDs & status for all the processes */
@@ -1255,7 +1296,7 @@ int top_main(int argc UNUSED_PARAM, char **argv)
                                top = xrealloc_vector(top, 6, ntop++);
                                top[n].pid = p->pid;
                                top[n].ppid = p->ppid;
-                                top[n].vsz = p->vsz;
+                                top[n].memsize = p->rss;
 #if ENABLE_FEATURE_TOP_CPU_USAGE_PERCENTAGE
                                top[n].ticks = p->stime + p->utime;
 #endif
@@ -1268,20 +1309,20 @@ int top_main(int argc UNUSED_PARAM, char **argv)
                        }
 #if ENABLE_FEATURE_TOPMEM
                        else { /* TOPMEM */
-                                if (!(p->smaps.mapped_ro | p->smaps.mapped_rw))
+                                if (!(p->mapped_ro | p->mapped_rw))
                                        continue; /* kernel threads are ignored */
                                n = ntop;
                                /* No bug here - top and topmem are the same */
                                top = xrealloc_vector(topmem, 6, ntop++);
                                strcpy(topmem[n].comm, p->comm);
                                topmem[n].pid      = p->pid;
-                                topmem[n].vsz      = p->smaps.mapped_rw + p->smaps.mapped_ro;
+                                topmem[n].vsz      = p->mapped_rw + p->mapped_ro;
-                                topmem[n].vszrw    = p->smaps.mapped_rw;
+                                topmem[n].vszrw    = p->mapped_rw;
-                                topmem[n].rss_sh   = p->smaps.shared_clean + p->smaps.shared_dirty;
+                                topmem[n].rss_sh   = p->shared_clean + p->shared_dirty;
-                                topmem[n].rss      = p->smaps.private_clean + p->smaps.private_dirty + topmem[n].rss_sh;
+                                topmem[n].rss      = p->private_clean + p->private_dirty + topmem[n].rss_sh;
-                                topmem[n].dirty    = p->smaps.private_dirty + p->smaps.shared_dirty;
+                                topmem[n].dirty    = p->private_dirty + p->shared_dirty;
-                                topmem[n].dirty_sh = p->smaps.shared_dirty;
+                                topmem[n].dirty_sh = p->shared_dirty;
-                                topmem[n].stack    = p->smaps.stack;
+                                topmem[n].stack    = p->stack;
                        }
 #endif
                } /* end of "while we read /proc" */
@@ -1310,30 +1351,40 @@ int top_main(int argc UNUSED_PARAM, char **argv)
                        qsort(topmem, ntop, sizeof(topmem_status_t), (void*)topmem_sort);
                }
 #endif
- IF_FEATURE_TOP_INTERACTIVE(display:)
+ IF_FEATURE_TOP_INTERACTIVE(redraw:)
+                G.lines_remaining = G.lines;
                IF_FEATURE_TOPMEM(if (scan_mask != TOPMEM_MASK)) {
-                        display_process_list(G.lines, col);
+                        display_process_list();
                }
 #if ENABLE_FEATURE_TOPMEM
                else { /* TOPMEM */
-                        display_topmem_process_list(G.lines, col);
+                        display_topmem_process_list();
                }
 #endif
+                print_end();
+                fflush_all();
                if (iterations >= 0 && !--iterations)
                        break;
 #if !ENABLE_FEATURE_TOP_INTERACTIVE
                clearmems();
                sleep_for_duration(interval);
 #else
-                new_mask = handle_input(scan_mask, interval);
+                new_mask = handle_input(scan_mask,
-                if (new_mask == NO_RESCAN_MASK)
+                        /* After "redraw with no rescan", have one
-                        goto display;
+                         * key timeout shorter that normal
+                         * (IOW: rescan sooner):
+                         */
+                        (new_mask == ONLY_REDRAW ? 1 : interval)
+                );
+                if (new_mask == ONLY_REDRAW)
+                        goto redraw;
                scan_mask = new_mask;
                clearmems();
 #endif
        } /* end of "while (not Q)" */
-        bb_putchar('\n');
+        if (!OPT_BATCH_MODE)
+                bb_putchar('\n');
 #if ENABLE_FEATURE_TOP_INTERACTIVE
        reset_term();
 #endif
diff --git a/shell/ash.c b/shell/ash.c
index 0038aa1e9..605215e41 100644
--- a/shell/ash.c
+++ b/shell/ash.c
@@ -461,7 +461,7 @@ static void forkshell_print(FILE *fp0, struct forkshell *fs, const char **notes)
 /* ============ Shell options */
-/* If you add/change options hare, update --help text too */
+/* If you add/change options here, update --help text too */
 static const char *const optletters_optnames[] ALIGN_PTR = {
        "e"   "errexit",
        "f"   "noglob",
@@ -1822,7 +1822,6 @@ struct stackmark {
        size_t stacknleft;
 };
 struct globals_memstack {
        struct stack_block *g_stackp; // = &stackbase;
        char *g_stacknxt; // = stackbase.space;
@@ -1845,7 +1844,6 @@ extern struct globals_memstack *BB_GLOBAL_CONST ash_ptr_to_globals_memstack;
        sstrend = stackbase.space + MINSIZE; \
 } while (0)
 #define stackblock()     ((void *)g_stacknxt)
 #define stackblocksize() g_stacknleft
@@ -2362,7 +2360,6 @@ struct localvar {
 # define VIMPORT        0x400   /* variable was imported from environment */
 #endif
 /* Need to be before varinit_data[] */
 #if ENABLE_LOCALE_SUPPORT
 static void FAST_FUNC
@@ -3582,7 +3579,6 @@ pwdcmd(int argc UNUSED_PARAM, char **argv UNUSED_PARAM)
 /* ============ ... */
 #define IBUFSIZ (ENABLE_FEATURE_EDITING ? CONFIG_FEATURE_EDITING_MAX_LEN : 1024)
 /* Syntax classes */
@@ -3989,13 +3985,11 @@ struct alias {
        int flag;
 };
 static struct alias **atab; // [ATABSIZE];
 #define INIT_G_alias() do { \
        atab = xzalloc(ATABSIZE * sizeof(atab[0])); \
 } while (0)
 static struct alias **
 __lookupalias(const char *name)
 {
@@ -4177,7 +4171,6 @@ unaliascmd(int argc UNUSED_PARAM, char **argv UNUSED_PARAM)
 #endif /* ASH_ALIAS */
 /* Mode argument to forkshell.  Don't change FORK_FG or FORK_BG. */
 #define FORK_FG    0
 #define FORK_BG    1
@@ -6194,7 +6187,6 @@ stoppedjobs(void)
 }
 #endif
 /*
 * Code for dealing with input/output redirection.
 */
@@ -9904,7 +9896,6 @@ commandcmd(int argc UNUSED_PARAM, char **argv UNUSED_PARAM)
 }
 #endif
 /*static int funcblocksize;     // size of structures in function */
 /*static int funcstringsize;    // size of strings in node */
 static void *funcblock;         /* block to allocate function from */
@@ -11920,7 +11911,6 @@ goodname(const char *p)
        return endofname(p)[0] == '\0';
 }
 /*
 * Search for a command.  This is called before we fork so that the
 * location of the command will be available in the parent as well as
@@ -14773,7 +14763,6 @@ parseheredoc(void)
        }
 }
 static const char *
 expandstr(const char *ps, int syntax_type)
 {
@@ -15403,7 +15392,6 @@ find_command(char *name, struct cmdentry *entry, int act, const char *path)
        entry->u = cmdp->param;
 }
 /*
 * The trap builtin.
 */
@@ -16170,7 +16158,6 @@ init(void)
        }
 }
 //usage:#define ash_trivial_usage
 //usage:        "[-il] [-|+Cabefmnuvx] [-|+o OPT]... [-c 'SCRIPT' [ARG0 ARGS] | FILE ARGS | -s ARGS]"
 ////////        comes from ^^^^^^^^^^optletters
diff --git a/shell/hush.c b/shell/hush.c
index d1f687f9d..09ab6ebc0 100644
--- a/shell/hush.c
+++ b/shell/hush.c
@@ -392,6 +392,8 @@
 /* Build knobs */
 #define LEAK_HUNTING 0
+#define LEAK_PRINTF(...) fdprintf(__VA_ARGS__)
+//#define LEAK_PRINTF(...) do { if (ptr_to_globals && G.root_pid == getpid()) fdprintf(__VA_ARGS__); } while (0)
 #define BUILD_AS_NOMMU 0
 /* Enable/disable sanity checks. Ok to enable in production,
 * only adds a bit of bloat. Set to >1 to get non-production level verbosity.
@@ -930,6 +932,12 @@ struct globals {
 # define G_flag_return_in_progress 0
 #endif
        smallint exiting; /* used to prevent EXIT trap recursion */
+#if !BB_MMU
+        smallint reexeced_on_NOMMU;
+# define G_reexeced_on_NOMMU (G.reexeced_on_NOMMU)
+#else
+# define G_reexeced_on_NOMMU 0
+#endif
        /* These support $? */
        smalluint last_exitcode;
        smalluint expand_exitcode;
@@ -1352,30 +1360,67 @@ static void debug_print_strings(const char *prefix, char **vv)
 static void *xxmalloc(int lineno, size_t size)
 {
        void *ptr = xmalloc((size + 0xff) & ~0xff);
-        fdprintf(2, "line %d: malloc %p\n", lineno, ptr);
+        LEAK_PRINTF(2, "line %d: malloc %p\n", lineno, ptr);
+        return ptr;
+}
+static void *xxzalloc(int lineno, size_t size)
+{
+        void *ptr = xzalloc((size + 0xff) & ~0xff);
+        LEAK_PRINTF(2, "line %d: zalloc %p\n", lineno, ptr);
        return ptr;
 }
 static void *xxrealloc(int lineno, void *ptr, size_t size)
 {
+        char *p = ptr;
        ptr = xrealloc(ptr, (size + 0xff) & ~0xff);
-        fdprintf(2, "line %d: realloc %p\n", lineno, ptr);
+        if (p != ptr)
+                LEAK_PRINTF(2, "line %d: realloc %p\n", lineno, ptr);
+        return ptr;
+}
+static void *xxrealloc_getcwd_or_warn(int lineno, char *ptr)
+{
+        char *p = ptr;
+        ptr = xrealloc_getcwd_or_warn(ptr);
+        if (p != ptr)
+                LEAK_PRINTF(2, "line %d: xrealloc_getcwd_or_warn %p\n", lineno, ptr);
        return ptr;
 }
 static char *xxstrdup(int lineno, const char *str)
 {
        char *ptr = xstrdup(str);
-        fdprintf(2, "line %d: strdup %p\n", lineno, ptr);
+        LEAK_PRINTF(2, "line %d: strdup %p\n", lineno, ptr);
+        return ptr;
+}
+static char *xxstrndup(int lineno, const char *str, size_t n)
+{
+        char *ptr = xstrndup(str, n);
+        LEAK_PRINTF(2, "line %d: strndup %p\n", lineno, ptr);
+        return ptr;
+}
+static char *xxasprintf(int lineno, const char *f, ...)
+{
+        char *ptr;
+        va_list args;
+        va_start(args, f);
+        if (vasprintf(&ptr, f, args) < 0)
+                bb_die_memory_exhausted();
+        va_end(args);
+        LEAK_PRINTF(2, "line %d: xasprintf %p\n", lineno, ptr);
        return ptr;
 }
 static void xxfree(void *ptr)
 {
-        fdprintf(2, "free %p\n", ptr);
+        LEAK_PRINTF(2, "free %p\n", ptr);
        free(ptr);
 }
-# define xmalloc(s)     xxmalloc(__LINE__, s)
+# define xmalloc(s)        xxmalloc(__LINE__, s)
-# define xrealloc(p, s) xxrealloc(__LINE__, p, s)
+# define xzalloc(s)        xxzalloc(__LINE__, s)
-# define xstrdup(s)     xxstrdup(__LINE__, s)
+# define xrealloc(p, s)    xxrealloc(__LINE__, p, s)
-# define free(p)        xxfree(p)
+# define xrealloc_getcwd_or_warn(p) xxrealloc_getcwd_or_warn(__LINE__, p)
+# define xstrdup(s)        xxstrdup(__LINE__, s)
+# define xstrndup(s, n)    xxstrndup(__LINE__, s, n)
+# define xasprintf(f, ...) xxasprintf(__LINE__, f, __VA_ARGS__)
+# define free(p)           xxfree(p)
 #endif
 /*
@@ -1929,7 +1974,7 @@ static void restore_G_args(save_arg_t *sv, char **argv)
 * "trap - SIGxxx":
 *    if sig is in special_sig_mask, set handler back to:
 *        record_pending_signo, or to IGN if it's a tty stop signal
- *    if sig is in fatal_sig_mask, set handler back to sigexit.
+ *    if sig is in fatal_sig_mask, set handler back to restore_ttypgrp_and_killsig_or__exit.
 *    else: set handler back to SIG_DFL
 * "trap 'cmd' SIGxxx":
 *    set handler to record_pending_signo.
@@ -2002,19 +2047,6 @@ static sighandler_t install_sighandler(int sig, sighandler_t handler)
        return old_sa.sa_handler;
 }
-static void hush_exit(int exitcode) NORETURN;
-static void restore_ttypgrp_and__exit(void) NORETURN;
-static void restore_ttypgrp_and__exit(void)
-{
-        /* xfunc has failed! die die die */
-        /* no EXIT traps, this is an escape hatch! */
-        G.exiting = 1;
-        hush_exit(xfunc_error_retval);
-}
-#if ENABLE_HUSH_JOB
 /* Needed only on some libc:
 * It was observed that on exit(), fgetc'ed buffered data
 * gets "unwound" via lseek(fd, -NUM, SEEK_CUR).
@@ -2028,26 +2060,20 @@ static void restore_ttypgrp_and__exit(void)
 * and in `cmd` handling.
 * If set as die_func(), this makes xfunc_die() exit via _exit(), not exit():
 */
-static void fflush_and__exit(void) NORETURN;
+static NORETURN void fflush_and__exit(void)
-static void fflush_and__exit(void)
 {
        fflush_all();
        _exit(xfunc_error_retval);
 }
-/* After [v]fork, in child: do not restore tty pgrp on xfunc death */
+#if ENABLE_HUSH_JOB
-# define disable_restore_tty_pgrp_on_exit() (die_func = fflush_and__exit)
-/* After [v]fork, in parent: restore tty pgrp on xfunc death */
-# define enable_restore_tty_pgrp_on_exit()  (die_func = restore_ttypgrp_and__exit)
 /* Restores tty foreground process group, and exits.
 * May be called as signal handler for fatal signal
 * (will resend signal to itself, producing correct exit state)
 * or called directly with -EXITCODE.
 * We also call it if xfunc is exiting.
 */
-static void sigexit(int sig) NORETURN;
+static NORETURN void restore_ttypgrp_and_killsig_or__exit(int sig)
-static void sigexit(int sig)
 {
        /* Careful: we can end up here after [v]fork. Do not restore
         * tty pgrp then, only top-level shell process does that */
@@ -2065,6 +2091,19 @@ static void sigexit(int sig)
        kill_myself_with_sig(sig); /* does not return */
 }
+static NORETURN void fflush_restore_ttypgrp_and__exit(void)
+{
+        /* xfunc has failed! die die die */
+        fflush_all();
+        restore_ttypgrp_and_killsig_or__exit(- xfunc_error_retval);
+}
+/* After [v]fork, in child: do not restore tty pgrp on xfunc death */
+# define disable_restore_tty_pgrp_on_exit() (die_func = fflush_and__exit)
+/* After [v]fork, in parent: restore tty pgrp on xfunc death */
+# define enable_restore_tty_pgrp_on_exit()  (die_func = fflush_restore_ttypgrp_and__exit)
 #else
 # define disable_restore_tty_pgrp_on_exit() ((void)0)
@@ -2081,7 +2120,7 @@ static sighandler_t pick_sighandler(unsigned sig)
 #if ENABLE_HUSH_JOB
                /* is sig fatal? */
                if (G_fatal_sig_mask & sigmask)
-                        handler = sigexit;
+                        handler = restore_ttypgrp_and_killsig_or__exit;
                else
 #endif
                /* sig has special handling? */
@@ -2101,11 +2140,15 @@ static sighandler_t pick_sighandler(unsigned sig)
 static const char* FAST_FUNC get_local_var_value(const char *name);
-/* Restores tty foreground process group, and exits. */
+/* Self-explanatory.
-static void hush_exit(int exitcode)
+ * Restores tty foreground process group too.
+ */
+static NORETURN void save_history_run_exit_trap_and_exit(int exitcode)
 {
 #if ENABLE_FEATURE_EDITING_SAVE_ON_EXIT
-        if (G.line_input_state) {
+        if (G.line_input_state
+         && getpid() == G.root_pid /* exits in subshells do not save history */
+        ) {
                const char *hp;
 # if ENABLE_FEATURE_SH_HISTFILESIZE
 // in bash:
@@ -2155,7 +2198,7 @@ static void hush_exit(int exitcode)
        fflush_all();
 #if ENABLE_HUSH_JOB
-        sigexit(- (exitcode & 0xff));
+        restore_ttypgrp_and_killsig_or__exit(- (exitcode & 0xff));
 #else
        _exit(exitcode);
 #endif
@@ -2240,7 +2283,7 @@ static int check_and_run_traps(void)
                                }
                        }
                        /* this restores tty pgrp, then kills us with SIGHUP */
-                        sigexit(SIGHUP);
+                        restore_ttypgrp_and_killsig_or__exit(SIGHUP);
                }
 #endif
 #if ENABLE_HUSH_FAST
@@ -7389,11 +7432,6 @@ static void switch_off_special_sigs(unsigned mask)
 }
 #if BB_MMU
-/* never called */
-void re_execute_shell(char ***to_free, const char *s,
-                char *g_argv0, char **g_argv,
-                char **builtin_argv) NORETURN;
 static void reset_traps_to_defaults(void)
 {
        /* This function is always called in a child shell
@@ -7443,10 +7481,8 @@ static void reset_traps_to_defaults(void)
 #else /* !BB_MMU */
-static void re_execute_shell(char ***to_free, const char *s,
+static NORETURN void re_execute_shell(
-                char *g_argv0, char **g_argv,
+                char * *volatile * to_free, const char *s,
-                char **builtin_argv) NORETURN;
-static void re_execute_shell(char ***to_free, const char *s,
                char *g_argv0, char **g_argv,
                char **builtin_argv)
 {
@@ -7676,7 +7712,13 @@ static int generate_stream_from_string(const char *s, pid_t *pid_p)
        pid_t pid;
        int channel[2];
 # if !BB_MMU
-        char **to_free = NULL;
+        /* _volatile_ pointer to "char*".
+         * Or else compiler can peek from inside re_execute_shell()
+         * and see that this pointer is a local var (i.e. not globally visible),
+         * and decide to optimize out the store to it. Yes,
+         * it was seen in the wild.
+         */
+        char * *volatile to_free = NULL;
 # endif
        xpipe(channel);
@@ -7823,7 +7865,7 @@ static void setup_heredoc(struct redir_struct *redir)
        const char *heredoc = redir->rd_filename;
        char *expanded;
 #if !BB_MMU
-        char **to_free;
+        char * *volatile to_free;
 #endif
        expanded = NULL;
@@ -8298,7 +8340,7 @@ static const struct built_in_command *find_builtin(const char *name)
        return find_builtin_helper(name, bltins2, &bltins2[ARRAY_SIZE(bltins2)]);
 }
-#if ENABLE_HUSH_JOB && ENABLE_FEATURE_TAB_COMPLETION
+#if ENABLE_HUSH_INTERACTIVE && ENABLE_FEATURE_TAB_COMPLETION
 static const char * FAST_FUNC hush_command_name(int i)
 {
        if (/*i >= 0 && */ i < ARRAY_SIZE(bltins1)) {
@@ -8464,10 +8506,8 @@ static void unset_func(const char *name)
 #define exec_function(to_free, funcp, argv) \
        exec_function(funcp, argv)
 # endif
-static void exec_function(char ***to_free,
+static NORETURN void exec_function(
-                const struct function *funcp,
+                char * *volatile *to_free,
-                char **argv) NORETURN;
-static void exec_function(char ***to_free,
                const struct function *funcp,
                char **argv)
 {
@@ -8563,10 +8603,8 @@ static int run_function(const struct function *funcp, char **argv)
 #define exec_builtin(to_free, x, argv) \
        exec_builtin(to_free, argv)
 #endif
-static void exec_builtin(char ***to_free,
+static NORETURN void exec_builtin(
-                const struct built_in_command *x,
+                char * *volatile *to_free,
-                char **argv) NORETURN;
-static void exec_builtin(char ***to_free,
                const struct built_in_command *x,
                char **argv)
 {
@@ -8589,8 +8627,7 @@ static void exec_builtin(char ***to_free,
 #endif
 }
-static void execvp_or_die(char **argv) NORETURN;
+static NORETURN void execvp_or_die(char **argv)
-static void execvp_or_die(char **argv)
 {
        int e;
        debug_printf_exec("execing '%s'\n", argv[0]);
@@ -8711,10 +8748,8 @@ static void if_command_vV_print_and_exit(char opt_vV, char *cmd, const char *exp
 * The at_exit handlers apparently confuse the calling process,
 * in particular stdin handling. Not sure why? -- because of vfork! (vda)
 */
-static void pseudo_exec_argv(nommu_save_t *nommu_save,
+static NORETURN NOINLINE void pseudo_exec_argv(
-                char **argv, int assignment_cnt,
+                volatile nommu_save_t *nommu_save,
-                char **argv_expanded) NORETURN;
-static NOINLINE void pseudo_exec_argv(nommu_save_t *nommu_save,
                char **argv, int assignment_cnt,
                char **argv_expanded)
 {
@@ -8740,7 +8775,8 @@ static NOINLINE void pseudo_exec_argv(nommu_save_t *nommu_save,
 #if BB_MMU
        G.shadowed_vars_pp = NULL; /* "don't save, free them instead" */
 #else
-        G.shadowed_vars_pp = &nommu_save->old_vars;
+        /* cast away volatility */
+        G.shadowed_vars_pp = (struct variable **)&nommu_save->old_vars;
        G.var_nest_level++;
 #endif
        set_vars_and_save_old(new_env);
@@ -8867,10 +8903,8 @@ static NOINLINE void pseudo_exec_argv(nommu_save_t *nommu_save,
 /* Called after [v]fork() in run_pipe
 */
-static void pseudo_exec(nommu_save_t *nommu_save,
+static NORETURN void pseudo_exec(
-                struct command *command,
+                volatile nommu_save_t *nommu_save,
-                char **argv_expanded) NORETURN;
-static void pseudo_exec(nommu_save_t *nommu_save,
                struct command *command,
                char **argv_expanded)
 {
@@ -9755,8 +9789,7 @@ static NOINLINE int run_pipe(struct pipe *pi)
                        /* Stores to nommu_save list of env vars putenv'ed
                         * (NOMMU, on MMU we don't need that) */
-                        /* cast away volatility... */
+                        pseudo_exec(&nommu_save, command, argv_expanded);
-                        pseudo_exec((nommu_save_t*) &nommu_save, command, argv_expanded);
                        /* pseudo_exec() does not return */
                }
@@ -10144,7 +10177,7 @@ static int run_list(struct pipe *pi)
                if (rcode != 0 && G.o_opt[OPT_O_ERREXIT]) {
                        debug_printf_exec("ERREXIT:1 errexit_depth:%d\n", G.errexit_depth);
                        if (G.errexit_depth == 0)
-                                hush_exit(rcode);
+                                save_history_run_exit_trap_and_exit(rcode);
                }
                G.errexit_depth = sv_errexit_depth;
@@ -10218,6 +10251,53 @@ static int run_and_free_list(struct pipe *pi)
 /*
 * Initialization and main
 */
+#if ENABLE_HUSH_INTERACTIVE && ENABLE_FEATURE_EDITING
+static void init_line_editing(void)
+{
+        G.line_input_state = new_line_input_t(FOR_SHELL);
+# if ENABLE_FEATURE_TAB_COMPLETION
+        G.line_input_state->get_exe_name = hush_command_name;
+# endif
+# if EDITING_HAS_sh_get_var
+        G.line_input_state->sh_get_var = get_local_var_value;
+# endif
+# if ENABLE_HUSH_SAVEHISTORY && MAX_HISTORY > 0
+        {
+                const char *hp = get_local_var_value("HISTFILE");
+                if (!hp) {
+                        hp = get_local_var_value("HOME");
+                        if (hp) {
+                                hp = concat_path_file(hp, ".hush_history");
+                                /* Make HISTFILE set on exit (else history won't be saved) */
+                                set_local_var_from_halves("HISTFILE", hp);
+                        }
+                } else {
+                        hp = xstrdup(hp);
+                }
+                if (hp) {
+                        G.line_input_state->hist_file = hp;
+                }
+#  if ENABLE_FEATURE_SH_HISTFILESIZE
+                hp = get_local_var_value("HISTSIZE");
+                /* Using HISTFILESIZE above to limit max_history would be WRONG:
+                 * users may set HISTFILESIZE=0 in their profile scripts
+                 * to prevent _saving_ of history files, but still want to have
+                 * non-zero history limit for in-memory list.
+                 */
+// in bash, runtime history size is controlled by HISTSIZE (0=no history),
+// HISTFILESIZE controls on-disk history file size (in lines, 0=no history):
+                G.line_input_state->max_history = size_from_HISTFILESIZE(hp);
+// HISTFILESIZE: "The shell sets the default value to the value of HISTSIZE after reading any startup files."
+// HISTSIZE: "The shell sets the default value to 500 after reading any startup files."
+// (meaning: if the value wasn't set after startup files, the default value is set as described above)
+#  endif
+        }
+# endif
+}
+#else
+# define init_line_editing() ((void)0)
+#endif
 static void install_sighandlers(unsigned mask)
 {
        sighandler_t old_handler;
@@ -10356,7 +10436,6 @@ static int set_mode(int state, char mode, const char *o_opt)
 int hush_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 int hush_main(int argc, char **argv)
 {
-        pid_t cached_getpid;
        enum {
                OPT_login = (1 << 0),
        };
@@ -10369,6 +10448,11 @@ int hush_main(int argc, char **argv)
        struct variable *shell_ver;
        INIT_G();
+#if ENABLE_HUSH_JOB
+        die_func = fflush_restore_ttypgrp_and__exit;
+#else
+        die_func = fflush_and__exit;
+#endif
        if (EXIT_SUCCESS != 0) /* if EXIT_SUCCESS == 0, it is already done */
                G.last_exitcode = EXIT_SUCCESS;
 #if !BB_MMU
@@ -10384,9 +10468,6 @@ int hush_main(int argc, char **argv)
                _exit(0);
        }
        G.argv0_for_re_execing = argv[0];
-        if (G.argv0_for_re_execing[0] == '-')
-                /* reexeced hush should never be a login shell */
-                G.argv0_for_re_execing++;
 #endif
 #if ENABLE_HUSH_TRAP
 # if ENABLE_HUSH_FUNCTIONS
@@ -10399,9 +10480,8 @@ int hush_main(int argc, char **argv)
        G.count_SIGCHLD++; /* ensure it is != G.handled_SIGCHLD */
 #endif
-        cached_getpid = getpid();   /* for tcsetpgrp() during init */
+        G.root_pid = getpid();   /* for $PID  (NOMMU can override via -$HEXPID:HEXPPID:...) */
-        G.root_pid = cached_getpid; /* for $PID  (NOMMU can override via -$HEXPID:HEXPPID:...) */
+        G.root_ppid = getppid(); /* for $PPID (NOMMU can override) */
-        G.root_ppid = getppid();    /* for $PPID (NOMMU can override) */
        /* Deal with HUSH_VERSION */
        debug_printf_env("unsetenv '%s'\n", "HUSH_VERSION");
@@ -10484,27 +10564,24 @@ int hush_main(int argc, char **argv)
         * PS4='+ '
         */
+        /* Shell is non-interactive at first. We need to call
+         * install_special_sighandlers() if we are going to execute "sh <script>",
+         * "sh -c <cmds>" or login shell's /etc/profile and friends.
+         * If we later decide that we are interactive, we run
+         * install_special_sighandlers() in order to intercept more signals.
+         */
+        install_special_sighandlers();
 #if NUM_SCRIPTS > 0
        if (argc < 0) {
                char *script = get_script_content(-argc - 1);
                G.global_argv = argv;
                G.global_argc = string_array_len(argv);
-                //install_special_sighandlers(); - needed?
                parse_and_run_string(script);
                goto final_return;
        }
 #endif
-        /* Initialize some more globals to non-zero values */
-        die_func = restore_ttypgrp_and__exit;
-        /* Shell is non-interactive at first. We need to call
-         * install_special_sighandlers() if we are going to execute "sh <script>",
-         * "sh -c <cmds>" or login shell's /etc/profile and friends.
-         * If we later decide that we are interactive, we run install_special_sighandlers()
-         * in order to intercept (more) signals.
-         */
        /* Parse options */
        /* http://www.opengroup.org/onlinepubs/9699919799/utilities/sh.html */
        flags = (argv[0] && argv[0][0] == '-') ? OPT_login : 0;
@@ -10568,6 +10645,7 @@ int hush_main(int argc, char **argv)
                case '$': {
                        unsigned long long empty_trap_mask;
+                        G.reexeced_on_NOMMU = 1;
                        G.root_pid = bb_strtou(optarg, &optarg, 16);
                        optarg++;
                        G.root_ppid = bb_strtou(optarg, &optarg, 16);
@@ -10581,7 +10659,6 @@ int hush_main(int argc, char **argv)
                        empty_trap_mask = bb_strtoull(optarg, &optarg, 16);
                        if (empty_trap_mask != 0) {
                                IF_HUSH_TRAP(int sig;)
-                                install_special_sighandlers();
 # if ENABLE_HUSH_TRAP
                                G_traps = xzalloc(sizeof(G_traps[0]) * NSIG);
                                for (sig = 1; sig < NSIG; sig++) {
@@ -10647,7 +10724,9 @@ int hush_main(int argc, char **argv)
        G.global_argv[0] = argv[0];
        /* If we are login shell... */
-        if (flags & OPT_login) {
+        if (!G_reexeced_on_NOMMU /* reexeced hush should never be a login shell */
+         && (flags & OPT_login)
+        ) {
                const char *hp = NULL;
                HFILE *input;
@@ -10655,7 +10734,6 @@ int hush_main(int argc, char **argv)
                input = hfopen("/etc/profile");
 run_profile:
                if (input != NULL) {
-                        install_special_sighandlers();
                        parse_and_run_file(input);
                        hfclose(input);
                }
@@ -10692,8 +10770,6 @@ int hush_main(int argc, char **argv)
                 */
                char *script;
-                install_special_sighandlers();
                G.global_argc--;
                G.global_argv++;
 #if !BB_MMU
@@ -10744,7 +10820,6 @@ int hush_main(int argc, char **argv)
                        bb_simple_perror_msg_and_die(G.global_argv[0]);
                }
                xfunc_error_retval = 1;
-                install_special_sighandlers();
                parse_and_run_file(input);
 #if ENABLE_FEATURE_CLEAN_UP
                hfclose(input);
@@ -10760,138 +10835,86 @@ int hush_main(int argc, char **argv)
        /* A shell is interactive if the '-i' flag was given,
         * or if all of the following conditions are met:
-         *    no -c command
+         *    not -c 'CMD'
-         *    no arguments remaining or the -s flag given
+         *    not running a script (no arguments remaining, or -s flag given)
         *    standard input is a terminal
         *    standard output is a terminal
         * Refer to Posix.2, the description of the 'sh' utility.
         */
-#if ENABLE_HUSH_JOB
+#if ENABLE_HUSH_INTERACTIVE
-        if (isatty(STDIN_FILENO) && isatty(STDOUT_FILENO)) {
+        if (!G_reexeced_on_NOMMU
-                G_saved_tty_pgrp = tcgetpgrp(STDIN_FILENO);
+         && isatty(STDIN_FILENO) && isatty(STDOUT_FILENO)
-                debug_printf("saved_tty_pgrp:%d\n", G_saved_tty_pgrp);
+        ) {
-                if (G_saved_tty_pgrp < 0)
+                /* Try to dup stdin to high fd#, >= 255 */
-                        G_saved_tty_pgrp = 0;
-                /* try to dup stdin to high fd#, >= 255 */
                G_interactive_fd = dup_CLOEXEC(STDIN_FILENO, 254);
                if (G_interactive_fd < 0) {
-                        /* try to dup to any fd */
+                        /* Try to dup to any fd */
                        G_interactive_fd = dup_CLOEXEC(STDIN_FILENO, -1);
-                        if (G_interactive_fd < 0) {
+                        if (G_interactive_fd < 0)
-                                /* give up */
+                                /* Give up */
                                G_interactive_fd = 0;
-                                G_saved_tty_pgrp = 0;
-                        }
                }
-        }
+                debug_printf("interactive_fd:%d\n", G_interactive_fd);
-        debug_printf("interactive_fd:%d\n", G_interactive_fd);
+                if (G_interactive_fd) {
-        if (G_interactive_fd) {
+// TODO? bash:
-                if (G_saved_tty_pgrp) {
+// if interactive but not a login shell, sources ~/.bashrc
-                        /* If we were run as 'hush &', sleep until we are
+// (--norc turns this off, --rcfile <file> overrides)
-                         * in the foreground (tty pgrp == our pgrp).
+# if ENABLE_HUSH_JOB
-                         * If we get started under a job aware app (like bash),
+                        /* Can we do job control? */
-                         * make sure we are now in charge so we don't fight over
+                        G_saved_tty_pgrp = tcgetpgrp(G_interactive_fd);
-                         * who gets the foreground */
+                        debug_printf("saved_tty_pgrp:%d\n", G_saved_tty_pgrp);
-                        while (1) {
+                        if (G_saved_tty_pgrp < 0)
-                                pid_t shell_pgrp = getpgrp();
+                                G_saved_tty_pgrp = 0; /* no */
-                                G_saved_tty_pgrp = tcgetpgrp(G_interactive_fd);
+                        if (G_saved_tty_pgrp) {
-                                if (G_saved_tty_pgrp == shell_pgrp)
+                                /* If we were run as 'hush &', sleep until we are
-                                        break;
+                                 * in the foreground (tty pgrp == our pgrp).
-                                /* send TTIN to ourself (should stop us) */
+                                 * If we get started under a job aware app (like bash),
-                                kill(- shell_pgrp, SIGTTIN);
+                                 * make sure we are now in charge so we don't fight over
+                                 * who gets the foreground */
+                                while (1) {
+                                        pid_t shell_pgrp = getpgrp();
+                                        if (G_saved_tty_pgrp == shell_pgrp) {
+/* Often both pgrps here are set to our pid - but not always!
+ * Example: sh -c 'echo $$; hush; echo FIN'
+ * Here, the parent shell is not interactive, so it does NOT set up
+ * a separate process group for its children, and we (hush) initially
+ * run in parent's process group (until we set up our own a few lines down).
+ */
+                                                //bb_error_msg("process groups tty:%d hush:%d", G_saved_tty_pgrp, shell_pgrp);
+                                                break;
+                                        }
+                                        /* Send TTIN to ourself (should stop us) */
+                                        kill(- shell_pgrp, SIGTTIN);
+                                        G_saved_tty_pgrp = tcgetpgrp(G_interactive_fd);
+                                }
                        }
-                }
-                /* Install more signal handlers */
-                install_special_sighandlers();
-                if (G_saved_tty_pgrp) {
-                        /* Set other signals to restore saved_tty_pgrp */
-                        install_fatal_sighandlers();
-                        /* Put ourselves in our own process group
-                         * (bash, too, does this only if ctty is available) */
-                        bb_setpgrp(); /* is the same as setpgid(our_pid, our_pid); */
-                        /* Grab control of the terminal */
-                        tcsetpgrp(G_interactive_fd, cached_getpid);
-                }
-                enable_restore_tty_pgrp_on_exit();
-# if ENABLE_FEATURE_EDITING
-                G.line_input_state = new_line_input_t(FOR_SHELL);
-#  if ENABLE_FEATURE_TAB_COMPLETION
-                G.line_input_state->get_exe_name = hush_command_name;
-#  endif
-#  if EDITING_HAS_sh_get_var
-                G.line_input_state->sh_get_var = get_local_var_value;
-#  endif
 # endif
-# if ENABLE_HUSH_SAVEHISTORY && MAX_HISTORY > 0
+                        /* Install more signal handlers */
-                {
+                        install_special_sighandlers();
-                        const char *hp = get_local_var_value("HISTFILE");
+# if ENABLE_HUSH_JOB
-                        if (!hp) {
+                        if (G_saved_tty_pgrp) {
-                                hp = get_local_var_value("HOME");
+                                /* Set fatal signals to restore saved_tty_pgrp */
-                                if (hp) {
+                                install_fatal_sighandlers();
-                                        hp = concat_path_file(hp, ".hush_history");
+                                /* (The if() is an optimization: can avoid two redundant syscalls) */
-                                        /* Make HISTFILE set on exit (else history won't be saved) */
+                                if (G_saved_tty_pgrp != G.root_pid) {
-                                        set_local_var_from_halves("HISTFILE", hp);
+                                        /* Put ourselves in our own process group
+                                         * (bash, too, does this only if ctty is available) */
+                                        bb_setpgrp(); /* is the same as setpgid(our_pid, our_pid); */
+                                        /* Grab control of the terminal */
+                                        tcsetpgrp(G_interactive_fd, G.root_pid);
                                }
-                        } else {
-                                hp = xstrdup(hp);
                        }
-                        if (hp) {
-                                G.line_input_state->hist_file = hp;
-                        }
-#  if ENABLE_FEATURE_SH_HISTFILESIZE
-                        hp = get_local_var_value("HISTSIZE");
-                        /* Using HISTFILESIZE above to limit max_history would be WRONG:
-                         * users may set HISTFILESIZE=0 in their profile scripts
-                         * to prevent _saving_ of history files, but still want to have
-                         * non-zero history limit for in-memory list.
-                         */
-// in bash, runtime history size is controlled by HISTSIZE (0=no history),
-// HISTFILESIZE controls on-disk history file size (in lines, 0=no history):
-                        G.line_input_state->max_history = size_from_HISTFILESIZE(hp);
-// HISTFILESIZE: "The shell sets the default value to the value of HISTSIZE after reading any startup files."
-// HISTSIZE: "The shell sets the default value to 500 after reading any startup files."
-// (meaning: if the value wasn't set after startup files, the default value is set as described above)
-#  endif
-                }
 # endif
-        } else {
+# if ENABLE_FEATURE_EDITING_FANCY_PROMPT
-                install_special_sighandlers();
+                        /* Set (but not export) PS1/2 unless already set */
-        }
+                        if (!get_local_var_value("PS1"))
-#elif ENABLE_HUSH_INTERACTIVE
+                                set_local_var_from_halves("PS1", "\\w \\$ ");
-        /* No job control compiled in, only prompt/line editing */
+                        if (!get_local_var_value("PS2"))
-        if (isatty(STDIN_FILENO) && isatty(STDOUT_FILENO)) {
+                                set_local_var_from_halves("PS2", "> ");
-                G_interactive_fd = dup_CLOEXEC(STDIN_FILENO, 254);
+# endif
-                if (G_interactive_fd < 0) {
+                        init_line_editing();
-                        /* try to dup to any fd */
-                        G_interactive_fd = dup_CLOEXEC(STDIN_FILENO, -1);
-                        if (G_interactive_fd < 0)
-                                /* give up */
-                                G_interactive_fd = 0;
-                }
-        }
-        install_special_sighandlers();
-#else
-        /* We have interactiveness code disabled */
-        install_special_sighandlers();
-#endif
-        /* bash:
-         * if interactive but not a login shell, sources ~/.bashrc
-         * (--norc turns this off, --rcfile <file> overrides)
-         */
-        if (G_interactive_fd) {
+# if !ENABLE_FEATURE_SH_EXTRA_QUIET
-#if ENABLE_HUSH_INTERACTIVE && ENABLE_FEATURE_EDITING_FANCY_PROMPT
-                /* Set (but not export) PS1/2 unless already set */
-                if (!get_local_var_value("PS1"))
-                        set_local_var_from_halves("PS1", "\\w \\$ ");
-                if (!get_local_var_value("PS2"))
-                        set_local_var_from_halves("PS2", "> ");
-#endif
-                if (!ENABLE_FEATURE_SH_EXTRA_QUIET) {
                        /* note: ash and hush share this string */
                        printf("\n\n%s %s\n"
                                IF_HUSH_HELP("Enter 'help' for a list of built-in commands.\n")
@@ -10899,13 +10922,15 @@ int hush_main(int argc, char **argv)
                                bb_banner,
                                "hush - the humble shell"
                        );
-                }
+# endif
-        }
+                } /* if become interactive */
+        } /* if on tty */
+#endif /* if INTERACTIVE is allowed by build config */
        parse_and_run_file(hfopen(NULL)); /* stdin */
 final_return:
-        hush_exit(G.last_exitcode);
+        save_history_run_exit_trap_and_exit(G.last_exitcode);
 }
 /*
@@ -11091,19 +11116,19 @@ static int FAST_FUNC builtin_exit(char **argv)
         * TODO: we can use G.exiting = -1 as indicator "last cmd was exit"
         */
-        /* note: EXIT trap is run by hush_exit */
+        /* note: EXIT trap is run by save_history_run_exit_trap_and_exit */
        argv = skip_dash_dash(argv);
        if (argv[0] == NULL) {
 #if ENABLE_HUSH_TRAP
                if (G.pre_trap_exitcode >= 0) /* "exit" in trap uses $? from before the trap */
-                        hush_exit(G.pre_trap_exitcode);
+                        save_history_run_exit_trap_and_exit(G.pre_trap_exitcode);
 #endif
-                hush_exit(G.last_exitcode);
+                save_history_run_exit_trap_and_exit(G.last_exitcode);
        }
        /* mimic bash: exit 123abc == exit 255 + error msg */
        xfunc_error_retval = 255;
        /* bash: exit -2 == exit 254, no error msg */
-        hush_exit(xatoi(argv[0]) & 0xff);
+        save_history_run_exit_trap_and_exit(xatoi(argv[0]) & 0xff);
 }
 #if ENABLE_HUSH_TYPE
diff --git a/shell/hush_leaktool.sh b/shell/hush_leaktool.sh
index ca35ec144..3edd3df61 100755
--- a/shell/hush_leaktool.sh
+++ b/shell/hush_leaktool.sh
@@ -7,7 +7,7 @@ freelist=`grep 'free 0x' "$output" | cut -d' ' -f2 | sort | uniq | xargs`
 grep -v free "$output" >"$output.leaked"
-i=8
+i=16
 list=
 for freed in $freelist; do
    list="$list -e $freed"
@@ -15,7 +15,7 @@ for freed in $freelist; do
    echo Dropping $list
    grep -F -v $list <"$output.leaked" >"$output.temp"
    mv "$output.temp" "$output.leaked"
-    i=8
+    i=16
    list=
 done
 if test "$list"; then
@@ -23,3 +23,17 @@ if test "$list"; then
    grep -F -v $list <"$output.leaked" >"$output.temp"
    mv "$output.temp" "$output.leaked"
 fi
+# All remaining allocations are on addresses which were never freed.
+# * Sort them by line, grouping together allocations which allocated the same address.
+#       A leaky allocation will give many different addresses (because it's never freed,
+#       the address can not be reused).
+# * Remove the address (field #4).
+# * Count the allocations per every unique source line and alloc type.
+# * Show largest counts on top.
+cat output.leaked \
+        | sort -u \
+        | cut -d' ' -f1-3 \
+        | uniq -c \
+        | sort -rn \
+>output.leaked.counted_uniq_alloc_address
diff --git a/shell/hush_test/hush-misc/sig_exitcode.tests b/shell/hush_test/hush-misc/sig_exitcode.tests
index 7879dc854..67b4500f4 100755
--- a/shell/hush_test/hush-misc/sig_exitcode.tests
+++ b/shell/hush_test/hush-misc/sig_exitcode.tests
@@ -1,3 +1,6 @@
+# If job control is disabled, skip the test
+test "`type jobs`" = "jobs is a shell builtin" || exit 77
 exec 2>&1
 $THIS_SH -c 'kill -9 $$'
diff --git a/shell/hush_test/hush-misc/wait1.tests b/shell/hush_test/hush-misc/wait1.tests
index f9cf6d48c..54120319b 100755
--- a/shell/hush_test/hush-misc/wait1.tests
+++ b/shell/hush_test/hush-misc/wait1.tests
@@ -1,3 +1,6 @@
+# If job control is disabled, skip the test
+test "`type jobs`" = "jobs is a shell builtin" || exit 77
 sleep 2 & sleep 1 & wait $!
 echo $?
 jobs
diff --git a/shell/hush_test/hush-misc/wait2.tests b/shell/hush_test/hush-misc/wait2.tests
index be20f95a5..60f382c9f 100755
--- a/shell/hush_test/hush-misc/wait2.tests
+++ b/shell/hush_test/hush-misc/wait2.tests
@@ -1,3 +1,6 @@
+# If job control is disabled, skip the test
+test "`type jobs`" = "jobs is a shell builtin" || exit 77
 sleep 3 & sleep 2 & sleep 1
 wait $!
 echo $?
diff --git a/shell/hush_test/hush-misc/wait3.tests b/shell/hush_test/hush-misc/wait3.tests
index ac541c3fc..aceed1126 100755
--- a/shell/hush_test/hush-misc/wait3.tests
+++ b/shell/hush_test/hush-misc/wait3.tests
@@ -1,3 +1,6 @@
+# If job control is disabled, skip the test
+test "`type jobs`" = "jobs is a shell builtin" || exit 77
 sleep 2 & (sleep 1;exit 3) & wait $!
 echo $?
 jobs
diff --git a/shell/hush_test/hush-misc/wait4.tests b/shell/hush_test/hush-misc/wait4.tests
index cc34059ac..c979a38b6 100755
--- a/shell/hush_test/hush-misc/wait4.tests
+++ b/shell/hush_test/hush-misc/wait4.tests
@@ -1,2 +1,5 @@
+# If job control is disabled, skip the test
+test "`type jobs`" = "jobs is a shell builtin" || exit 77
 sleep 1 | (sleep 1;exit 3) & wait %1
 echo Three:$?
diff --git a/shell/hush_test/hush-misc/wait5.tests b/shell/hush_test/hush-misc/wait5.tests
index 1b4762d89..e0ac8c251 100755
--- a/shell/hush_test/hush-misc/wait5.tests
+++ b/shell/hush_test/hush-misc/wait5.tests
@@ -1,3 +1,6 @@
+# If job control is disabled, skip the test
+test "`type jobs`" = "jobs is a shell builtin" || exit 77
 sleep 0 | (sleep 0;exit 3) &
 sleep 1
 echo Zero:$?
diff --git a/shell/hush_test/hush-misc/wait6.tests b/shell/hush_test/hush-misc/wait6.tests
index c23713199..c09002ab0 100755
--- a/shell/hush_test/hush-misc/wait6.tests
+++ b/shell/hush_test/hush-misc/wait6.tests
@@ -1,3 +1,6 @@
+# If job control is disabled, skip the test
+test "`type jobs`" = "jobs is a shell builtin" || exit 77
 # In bash, "wait $!" extracts correct exitcode even if bg task has already exited
 # It prints 0, then 3:
 (sleep 0; exit 3) & sleep 1
diff --git a/shell/hush_test/hush-signals/catch.tests b/shell/hush_test/hush-signals/catch.tests
index d2a21d17e..4b1a08e8f 100755
--- a/shell/hush_test/hush-signals/catch.tests
+++ b/shell/hush_test/hush-signals/catch.tests
@@ -1,3 +1,6 @@
+# If job control is disabled, skip the test ("User defined signal 2" text not emitted)
+test "`type jobs`" = "jobs is a shell builtin" || exit 77
 # avoid ugly warnings about signals not being caught
 trap ":" USR1 USR2
diff --git a/shell/hush_test/hush-signals/signal1.tests b/shell/hush_test/hush-signals/signal1.tests
index 61943467a..c83fa1254 100755
--- a/shell/hush_test/hush-signals/signal1.tests
+++ b/shell/hush_test/hush-signals/signal1.tests
@@ -1,3 +1,6 @@
+# If job control is disabled, skip the test
+test "`type jobs`" = "jobs is a shell builtin" || exit 77
 trap "echo got signal" USR1
 for try in 1 2 3 4 5; do
diff --git a/shell/hush_test/hush-signals/signal8.tests b/shell/hush_test/hush-signals/signal8.tests
index 731af7477..cd5790164 100755
--- a/shell/hush_test/hush-signals/signal8.tests
+++ b/shell/hush_test/hush-signals/signal8.tests
@@ -1,3 +1,6 @@
+# If job control is disabled, skip the test
+test "`type jobs`" = "jobs is a shell builtin" || exit 77
 "$THIS_SH" -c '
 exit_func() {
    echo "Removing traps"
diff --git a/shell/hush_test/hush-signals/signal_read2.tests b/shell/hush_test/hush-signals/signal_read2.tests
index eab5b9b5b..11accd5ab 100755
--- a/shell/hush_test/hush-signals/signal_read2.tests
+++ b/shell/hush_test/hush-signals/signal_read2.tests
@@ -1,3 +1,6 @@
+# If job control is disabled, skip the test ("Hangup" not emitted)
+test "`type jobs`" = "jobs is a shell builtin" || exit 77
 $THIS_SH -c '
 (sleep 1; kill -HUP $$) &
 while true; do
diff --git a/shell/hush_test/hush-signals/subshell.tests b/shell/hush_test/hush-signals/subshell.tests
index d877f2b82..856c922d3 100755
--- a/shell/hush_test/hush-signals/subshell.tests
+++ b/shell/hush_test/hush-signals/subshell.tests
@@ -1,5 +1,8 @@
 # Non-empty traps should be reset in subshell
+# If job control is disabled, skip the test ("Terminated" text not emitted)
+test "`type jobs`" = "jobs is a shell builtin" || exit 77
 # HUP is special in interactive shells
 trap '' HUP
 # QUIT is always special
diff --git a/shell/hush_test/run-all b/shell/hush_test/run-all
index 7345fee43..ff29ca0b1 100755
--- a/shell/hush_test/run-all
+++ b/shell/hush_test/run-all
@@ -67,9 +67,12 @@ do_test()
 #               echo Running test: "$x"
                echo -n "$1/$x:"
                (
-                        "$THIS_SH" "./$x" 2>&1 | \
+                        "$THIS_SH" "./$x" >"$name.xx" 2>&1
-                                grep -va "^hush: using fallback suid method$" >"$name.xx"
                        r=$?
+                        # filter !FEATURE_SUID_CONFIG_QUIET message
+                        sed -i \
+                                -e "/^hush: using fallback suid method$/d" \
+                                "$name.xx"
                        # filter C library differences
                        sed -i \
                                -e "/: invalid option /s:'::g" \
diff --git a/testsuite/hexdump.tests b/testsuite/hexdump.tests
index b2f6a2201..d2c0a5dc8 100755
--- a/testsuite/hexdump.tests
+++ b/testsuite/hexdump.tests
@@ -56,6 +56,16 @@ testing "hexdump -e %3_u" \
 " \
        "" "$input"
+testing "hexdump -e %3_c" \
+        "hexdump -e '16/1 \" %3_c\" \"\n\"'" \
+'  \\0 001 002 003 004 005 006  \\a  \\b  \\t  \\n  \\v  \\f  \\r 016 017
+ 020 021 022 023 024 025 026 027 030 031 032 033 034 035 036 037
+   p   q   r   s   t   u   v   w   x   y   z   {   |   }   ~ 177
+ 200 201 202 203 204 205 206 207 210 211 212 213 214 215 216 217
+ 360 361 362 363 364 365 366 367 370 371 372 373 374 375 376 377
+' \
+        "" "$input"
 testing "hexdump -e /1 %d" \
        "hexdump -e '16/1 \" %4d\" \"\n\"'" \
        "\
diff --git a/testsuite/ls.tests b/testsuite/ls.tests
index 9309d366b..a95911034 100755
--- a/testsuite/ls.tests
+++ b/testsuite/ls.tests
@@ -19,7 +19,7 @@ test x"$CONFIG_UNICODE_SUPPORT" = x"y" \
 && test x"$CONFIG_LAST_SUPPORTED_WCHAR" = x"767" \
 && test x"$CONFIG_FEATURE_LS_SORTFILES" = x"y" \
 && testing "ls unicode test with codepoints limited to 767" \
-"(cd ls.testdir && sh ../ls.mk_uni_tests) && ls -1 ls.testdir" \
+"(cd ls.testdir && sh ../ls.mk_uni_tests) && ls -1q ls.testdir" \
 '0001_1__Some_correct_UTF-8_text___________________________________________|
 0002_2__Boundary_condition_test_cases_____________________________________|
 0003_2.1__First_possible_sequence_of_a_certain_length_____________________|
@@ -138,7 +138,7 @@ test x"$CONFIG_UNICODE_SUPPORT" = x"y" \
 && test x"$CONFIG_SUBST_WCHAR" = x"63" \
 && test x"$CONFIG_LAST_SUPPORTED_WCHAR" = x"0" \
 && testing "ls unicode test with unlimited codepoints" \
-"(cd ls.testdir && sh ../ls.mk_uni_tests) && ls -1 ls.testdir" \
+"(cd ls.testdir && sh ../ls.mk_uni_tests) && ls -1q ls.testdir" \
 '0001_1__Some_correct_UTF-8_text___________________________________________|
 0002_2__Boundary_condition_test_cases_____________________________________|
 0003_2.1__First_possible_sequence_of_a_certain_length_____________________|
@@ -262,6 +262,28 @@ test x"$CONFIG_FEATURE_LS_SORTFILES" = x"y" \
 "A\nB\nA\nB\nA\nB\n" \
 "" ""
+rm -rf ls.testdir 2>/dev/null
+mkdir ls.testdir || exit 1
+touch "`printf "ls.testdir/\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f_\x7f\x80\xfe\xff_\x22_\x27_\x5c"`"
+sq="'"
+# testing "test name" "command" "expected result" "file input" "stdin"
+testing "ls -q" \
+'ls -q ls.testdir' \
+'???????????????????????????????_????_"_'$sq'_\\''\n' \
+"" ""
+testing "ls -Q" \
+'ls -Q ls.testdir' \
+'"\\001\\002\\003\\004\\005\\006\\a\\b\\t\\n\\v\\f\\r\\016\\017\\020\\021\\022\\023\\024\\025\\026\\027\\030\\031\\032\\033\\034\\035\\036\\037_\\177\\200\\376\\377_\\"_'$sq'_\\\\"\n' \
+"" ""
+testing "ls -qQ" \
+'ls -qQ ls.testdir' \
+'"\\001\\002\\003\\004\\005\\006\\a\\b\\t\\n\\v\\f\\r\\016\\017\\020\\021\\022\\023\\024\\025\\026\\027\\030\\031\\032\\033\\034\\035\\036\\037_\\177\\200\\376\\377_\\"_'$sq'_\\\\"\n' \
+"" ""
 # Clean up
 rm -rf ls.testdir 2>/dev/null
diff --git a/testsuite/md5sum.tests b/testsuite/md5sum.tests
index cca26dc64..a6d2b7ffb 100755
--- a/testsuite/md5sum.tests
+++ b/testsuite/md5sum.tests
@@ -9,6 +9,7 @@
 # efe30c482e0b687e0cca0612f42ca29b
 # d41337e834377140ae7f98460d71d908598ef04f
 # 8e1d3ed57ebc130f0f72508446559eeae06451ae6d61b1e8ce46370cfb8963c3
+# c01420bb6613d4bd00396a82033e59e81486cbb045ae0dd2b4c3332e581b3ce09fb1946d6e283acec685778ff205d485
 # fe413e0f177324d1353893ca0772ceba83fd41512ba63895a0eebb703ef9feac2fb4e92b2cb430b3bda41b46b0cb4ea8307190a5cc795157cfb680a9cd635d0f
 if ! test "$1"; then
@@ -31,9 +32,9 @@ text=`yes "$text" | head -c 9999`
 result=`(
 n=0
 while test $n -le 999; do
-        echo "$text" | head -c $n | "$sum"
+        echo "$text" | head -c $n | $sum
        n=$(($n+1))
-done | "$sum"
+done | $sum
 )`
 if test x"$result" != x"$expected  -"; then
        echo "FAIL: $sum (r:$result exp:$expected)"
@@ -44,7 +45,7 @@ fi
 # GNU compat: -c EMPTY must fail (exitcode 1)!
 >EMPTY
-if "$sum" -c EMPTY 2>/dev/null; then
+if $sum -c EMPTY 2>/dev/null; then
        echo "FAIL: $sum -c EMPTY"
        : $((FAILCOUNT++))
 else
diff --git a/testsuite/sha384sum.tests b/testsuite/sha384sum.tests
new file mode 100755
index 000000000..f1449d195
--- /dev/null
+++ b/testsuite/sha384sum.tests
@@ -0,0 +1,3 @@
+#!/bin/sh
+. ./md5sum.tests sha384sum c01420bb6613d4bd00396a82033e59e81486cbb045ae0dd2b4c3332e581b3ce09fb1946d6e283acec685778ff205d485
diff --git a/testsuite/sha3sum.tests b/testsuite/sha3sum.tests
index 2cd8e3bf2..631141735 100755
--- a/testsuite/sha3sum.tests
+++ b/testsuite/sha3sum.tests
@@ -1,3 +1,7 @@
 #!/bin/sh
-. ./md5sum.tests sha3sum 11659f09370139f8ef384f4a6260947fafa6e4fcd87a1ef3f35410e9
+   (. ./md5sum.tests sha3sum         11659f09370139f8ef384f4a6260947fafa6e4fcd87a1ef3f35410e9) \
+&& (. ./md5sum.tests "sha3sum -a224" 11659f09370139f8ef384f4a6260947fafa6e4fcd87a1ef3f35410e9) \
+&& (. ./md5sum.tests "sha3sum -a256" 6f69c8d36a9a579a943d878dab38c179d2a9dde12b244aa8840002c0f3d5bb73) \
+&& (. ./md5sum.tests "sha3sum -a384" 303913449042257996a869e0378323193b4f58d90eea801b12186a3d65640bd3403d3404c63527424ec43dff842c0cd0) \
+&& (. ./md5sum.tests "sha3sum -a512" e14814dccc2fef967af74eb6710885b35dfe660a362c0609b642404987d24a13dac66ad037e6affa5c42631110231655fcf4c972b1457ac49fb83af8113fc51f)
diff --git a/util-linux/lspci.c b/util-linux/lspci.c
index b38b46be3..25be23a01 100644
--- a/util-linux/lspci.c
+++ b/util-linux/lspci.c
@@ -47,7 +47,7 @@ static int FAST_FUNC fileAction(struct recursive_state *state UNUSED_PARAM,
        int pci_class = 0, pci_vid = 0, pci_did = 0;
        int pci_subsys_vid = 0, pci_subsys_did = 0;
-        char *uevent_filename = concat_path_file(fileName, "/uevent");
+        char *uevent_filename = concat_path_file(fileName, "uevent");
        parser = config_open2(uevent_filename, fopen_for_read);
        free(uevent_filename);
diff --git a/util-linux/lsusb.c b/util-linux/lsusb.c
index 0a9e505f4..f7d0de32d 100644
--- a/util-linux/lsusb.c
+++ b/util-linux/lsusb.c
@@ -50,7 +50,7 @@ static int FAST_FUNC fileAction(struct recursive_state *state UNUSED_PARAM,
        char *tokens[4];
        char *busnum = NULL, *devnum = NULL;
        int product_vid = 0, product_did = 0;
-        char *uevent_filename = concat_path_file(fileName, "/uevent");
+        char *uevent_filename = concat_path_file(fileName, "uevent");
        parser = config_open2(uevent_filename, fopen_for_read);
        free(uevent_filename);
diff --git a/win32/process.c b/win32/process.c
index 33f45ee42..0d120936e 100644
--- a/win32/process.c
+++ b/win32/process.c
@@ -795,7 +795,7 @@ UNUSED_PARAM
        return sp;
 }
-void FAST_FUNC read_cmdline(char *buf, int col, unsigned pid, const char *comm)
+int FAST_FUNC read_cmdline(char *buf, int col, unsigned pid, const char *comm)
 {
        const char *str, *cmdline;
@@ -807,6 +807,7 @@ void FAST_FUNC read_cmdline(char *buf, int col, unsigned pid, const char *comm)
        else
                cmdline = comm;
        safe_strncpy(buf, cmdline, col);
+        return 0;
 }
 /**