Merge branch 'busybox' into merge

5 files changed, 131 insertions, 64 deletions

diff --git a/miscutils/Config.src b/miscutils/Config.src
index 1b2a3ae9a..d69abf1a2 100644
--- a/miscutils/Config.src
+++ b/miscutils/Config.src
@@ -499,22 +499,6 @@ config STRINGS
           strings prints the printable character sequences for each file
           specified.
 
-config TASKSET
-        bool "taskset"
-        default n  # doesn't build on some non-x86 targets (m68k)
-        help
-          Retrieve or set a processes's CPU affinity.
-          This requires sched_{g,s}etaffinity support in your libc.
-
-config FEATURE_TASKSET_FANCY
-        bool "Fancy output"
-        default y
-        depends on TASKSET
-        help
-          Add code for fancy output. This merely silences a compiler-warning
-          and adds about 135 Bytes. May be needed for machines with alot
-          of CPUs.
-
 config TIME
         bool "time"
         default y
diff --git a/miscutils/Kbuild.src b/miscutils/Kbuild.src
index 8eaa82de9..7b449e6e8 100644
--- a/miscutils/Kbuild.src
+++ b/miscutils/Kbuild.src
@@ -39,7 +39,6 @@ lib-$(CONFIG_RUNLEVEL)    += runlevel.o
 lib-$(CONFIG_RX)          += rx.o
 lib-$(CONFIG_SETSID)      += setsid.o
 lib-$(CONFIG_STRINGS)     += strings.o
-lib-$(CONFIG_TASKSET)     += taskset.o
 lib-$(CONFIG_TIME)        += time.o
 lib-$(CONFIG_TIMEOUT)     += timeout.o
 lib-$(CONFIG_TTYSIZE)     += ttysize.o
diff --git a/miscutils/less.c b/miscutils/less.c
index d84df469c..554e54687 100644
--- a/miscutils/less.c
+++ b/miscutils/less.c
@@ -414,10 +414,10 @@ static void read_lines(void)
         char *current_line, *p;
         int w = width;
         char last_terminated = terminated;
+        time_t last_time = 0;
+        int retry_EAGAIN = 2;
 #if ENABLE_FEATURE_LESS_REGEXP
         unsigned old_max_fline = max_fline;
-        time_t last_time = 0;
-        int had_progress = 2;
 #endif
 
         /* (careful: max_fline can be -1) */
@@ -427,17 +427,14 @@ static void read_lines(void)
         if (option_mask32 & FLAG_N)
                 w -= 8;
 
- IF_FEATURE_LESS_REGEXP(again0:)
-
         p = current_line = ((char*)xmalloc(w + 4)) + 4;
-        max_fline += last_terminated;
         if (!last_terminated) {
                 const char *cp = flines[max_fline];
-                strcpy(p, cp);
-                p += strlen(current_line);
-                free(MEMPTR(flines[max_fline]));
+                p = stpcpy(p, cp);
+                free(MEMPTR(cp));
                 /* last_line_pos is still valid from previous read_lines() */
         } else {
+                max_fline++;
                 last_line_pos = 0;
         }
 
@@ -448,15 +445,29 @@ static void read_lines(void)
                         char c;
                         /* if no unprocessed chars left, eat more */
                         if (readpos >= readeof) {
-                                errno = 0;
-                                ndelay_on(0);
-                                eof_error = safe_read(STDIN_FILENO, readbuf, sizeof(readbuf));
-                                ndelay_off(0);
+                                int flags = ndelay_on(0);
+
+                                while (1) {
+                                        time_t t;
+
+                                        errno = 0;
+                                        eof_error = safe_read(STDIN_FILENO, readbuf, sizeof(readbuf));
+                                        if (errno != EAGAIN)
+                                                break;
+                                        t = time(NULL);
+                                        if (t != last_time) {
+                                                last_time = t;
+                                                if (--retry_EAGAIN < 0)
+                                                        break;
+                                        }
+                                        sched_yield();
+                                }
+                                fcntl(0, F_SETFL, flags); /* ndelay_off(0) */
                                 readpos = 0;
                                 readeof = eof_error;
                                 if (eof_error <= 0)
                                         goto reached_eof;
-                                IF_FEATURE_LESS_REGEXP(had_progress = 1;)
+                                retry_EAGAIN = 1;
                         }
                         c = readbuf[readpos];
                         /* backspace? [needed for manpages] */
@@ -491,6 +502,11 @@ static void read_lines(void)
                         *p++ = c;
                         *p = '\0';
                 } /* end of "read chars until we have a line" loop */
+#if 0
+//BUG: also triggers on this:
+// { printf "\nfoo\n"; sleep 1; printf "\nbar\n"; } | less
+// (resulting in lost empty line between "foo" and "bar" lines)
+// the "terminated" logic needs fixing (or explaining)
                 /* Corner case: linewrap with only "" wrapping to next line */
                 /* Looks ugly on screen, so we do not store this empty line */
                 if (!last_terminated && !current_line[0]) {
@@ -498,6 +514,7 @@ static void read_lines(void)
                         max_lineno++;
                         continue;
                 }
+#endif
  reached_eof:
                 last_terminated = terminated;
                 flines = xrealloc_vector(flines, 8, max_fline);
@@ -528,24 +545,7 @@ static void read_lines(void)
 #endif
                 }
                 if (eof_error <= 0) {
-#if !ENABLE_FEATURE_LESS_REGEXP
                         break;
-#else
-                        if (wanted_match < num_matches) {
-                                break;
-                        } /* else: goto_match() called us */
-                        if (errno == EAGAIN) {
-                                time_t t = time(NULL);
-                                if (t != last_time) {
-                                        last_time = t;
-                                        if (--had_progress < 0)
-                                                break;
-                                }
-                                sched_yield();
-                                goto again0;
-                        }
-                        break;
-#endif
                 }
                 max_fline++;
                 current_line = ((char*)xmalloc(w + 4)) + 4;
@@ -802,11 +802,18 @@ static void buffer_print(void)
         unsigned i;
 
         move_cursor(0, 0);
-        for (i = 0; i <= max_displayed_line; i++)
+        for (i = 0; i <= max_displayed_line; i++) {
                 if (pattern_valid)
                         print_found(buffer[i]);
                 else
                         print_ascii(buffer[i]);
+        }
+        if ((option_mask32 & FLAG_E)
+         && eof_error <= 0
+         && (max_fline - cur_fline) <= max_displayed_line
+        ) {
+                less_exit(EXIT_SUCCESS);
+        }
         status_print();
 }
 
diff --git a/miscutils/taskset.c b/miscutils/taskset.c
index 4a9e3230d..2646e1dab 100644
--- a/miscutils/taskset.c
+++ b/miscutils/taskset.c
@@ -6,6 +6,25 @@
  * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  */
 
+//config:config TASKSET
+//config:       bool "taskset"
+//config:       default n  # doesn't build on some non-x86 targets (m68k)
+//config:       help
+//config:         Retrieve or set a processes's CPU affinity.
+//config:         This requires sched_{g,s}etaffinity support in your libc.
+//config:
+//config:config FEATURE_TASKSET_FANCY
+//config:       bool "Fancy output"
+//config:       default y
+//config:       depends on TASKSET
+//config:       help
+//config:         Add code for fancy output. This merely silences a compiler-warning
+//config:         and adds about 135 Bytes. May be needed for machines with alot
+//config:         of CPUs.
+
+//applet:IF_TASKSET(APPLET(taskset, BB_DIR_USR_BIN, BB_SUID_DROP))
+//kbuild:lib-$(CONFIG_TASKSET) += taskset.o
+
 //usage:#define taskset_trivial_usage
 //usage:       "[-p] [MASK] [PID | PROG ARGS]"
 //usage:#define taskset_full_usage "\n\n"
@@ -22,6 +41,11 @@
 //usage:       "pid 6671's new affinity mask: 1\n"
 //usage:       "$ taskset -p 1\n"
 //usage:       "pid 1's current affinity mask: 3\n"
+/*
+ Not yet implemented:
+ * -a/--all-tasks (affect all threads)
+ * -c/--cpu-list  (specify CPUs via "1,3,5-7")
+ */
 
 #include <sched.h>
 #include "libbb.h"
@@ -128,17 +152,65 @@ int taskset_main(int argc UNUSED_PARAM, char **argv)
                 current_new += 8; /* "new" */
         }
 
-        { /* Affinity was specified, translate it into cpu_set_t */
+        /* Affinity was specified, translate it into cpu_set_t */
+        CPU_ZERO(&mask);
+        if (!ENABLE_FEATURE_TASKSET_FANCY) {
                 unsigned i;
+                unsigned long long m;
+
                 /* Do not allow zero mask: */
-                unsigned long long m = xstrtoull_range(aff, 0, 1, ULLONG_MAX);
-                enum { CNT_BIT = CPU_SETSIZE < sizeof(m)*8 ? CPU_SETSIZE : sizeof(m)*8 };
+                m = xstrtoull_range(aff, 0, 1, ULLONG_MAX);
+                i = 0;
+                do {
+                        if (m & 1)
+                                CPU_SET(i, &mask);
+                        i++;
+                        m >>= 1;
+                } while (m != 0);
+        } else {
+                unsigned i;
+                char *last_byte;
+                char *bin;
+                uint8_t bit_in_byte;
+
+                /* Cheap way to get "long enough" buffer */
+                bin = xstrdup(aff);
+
+                if (aff[0] != '0' || (aff[1]|0x20) != 'x') {
+/* TODO: decimal/octal masks are still limited to 2^64 */
+                        unsigned long long m = xstrtoull_range(aff, 0, 1, ULLONG_MAX);
+                        bin += strlen(bin);
+                        last_byte = bin - 1;
+                        while (m) {
+                                *--bin = m & 0xff;
+                                m >>= 8;
+                        }
+                } else {
+                        /* aff is "0x.....", we accept very long masks in this form */
+                        last_byte = hex2bin(bin, aff + 2, INT_MAX);
+                        if (!last_byte) {
+ bad_aff:
+                                bb_error_msg_and_die("bad affinity '%s'", aff);
+                        }
+                        last_byte--; /* now points to the last byte */
+                }
 
-                CPU_ZERO(&mask);
-                for (i = 0; i < CNT_BIT; i++) {
-                        unsigned long long bit = (1ULL << i);
-                        if (bit & m)
+                i = 0;
+                bit_in_byte = 1;
+                while (last_byte >= bin) {
+                        if (bit_in_byte & *last_byte) {
+                                if (i >= CPU_SETSIZE)
+                                        goto bad_aff;
                                 CPU_SET(i, &mask);
+                                //bb_error_msg("bit %d set", i);
+                        }
+                        i++;
+                        /* bit_in_byte is uint8_t! & 0xff is implied */
+                        bit_in_byte = (bit_in_byte << 1);
+                        if (!bit_in_byte) {
+                                bit_in_byte = 1;
+                                last_byte--;
+                        }
                 }
         }
 
diff --git a/miscutils/ubi_tools.c b/miscutils/ubi_tools.c
index b71393532..6c09fe534 100644
--- a/miscutils/ubi_tools.c
+++ b/miscutils/ubi_tools.c
@@ -125,12 +125,24 @@ int ubi_tools_main(int argc UNUSED_PARAM, char **argv)
         strcpy(path, "/sys/class/ubi/ubi");
         memset(&req_structs, 0, sizeof(req_structs));
 
+#define OPTION_m  (1 << 0)
+#define OPTION_d  (1 << 1)
+#define OPTION_n  (1 << 2)
+#define OPTION_N  (1 << 3)
+#define OPTION_s  (1 << 4)
+#define OPTION_a  (1 << 5)
+#define OPTION_t  (1 << 6)
         if (do_mkvol) {
                 opt_complementary = "-1:d+:n+:a+";
                 opts = getopt32(argv, "md:n:N:s:a:t:",
                                 &dev_num, &vol_id,
                                 &vol_name, &size_bytes_str, &alignment, &type
                         );
+        } else
+        if (do_update) {
+                opt_complementary = "-1";
+                opts = getopt32(argv, "s:at", &size_bytes_str);
+                opts *= OPTION_s;
         } else {
                 opt_complementary = "-1:m+:d+:n+:a+";
                 opts = getopt32(argv, "m:d:n:N:s:a:t:",
@@ -138,13 +150,6 @@ int ubi_tools_main(int argc UNUSED_PARAM, char **argv)
                                 &vol_name, &size_bytes_str, &alignment, &type
                 );
         }
-#define OPTION_m  (1 << 0)
-#define OPTION_d  (1 << 1)
-#define OPTION_n  (1 << 2)
-#define OPTION_N  (1 << 3)
-#define OPTION_s  (1 << 4)
-#define OPTION_a  (1 << 5)
-#define OPTION_t  (1 << 6)
 
         if (opts & OPTION_s)
                 size_bytes = xatoull_sfx(size_bytes_str, size_suffixes);
@@ -302,9 +307,9 @@ int ubi_tools_main(int argc UNUSED_PARAM, char **argv)
                         if (!(opts & OPTION_s)) {
                                 if (!*argv)
                                         bb_show_usage();
-                                xstat(*argv, &st);
-                                size_bytes = st.st_size;
                                 xmove_fd(xopen(*argv, O_RDONLY), STDIN_FILENO);
+                                xfstat(STDIN_FILENO, &st, *argv);
+                                size_bytes = st.st_size;
                         }
 
                         bytes64 = size_bytes;