Changeset 3621 in MondoRescue for branches/3.3/mindi-busybox/e2fsprogs/fsck.c

Timestamp:

Dec 20, 2016, 4:07:32 PM (7 years ago)

Author:

Bruno Cornec

Message:

New 3?3 banch for incorporation of latest busybox 1.25. Changing minor version to handle potential incompatibilities.

Location:

branches/3.3

Files:

• . (copied) (copied from branches/3.2 )
• mindi-busybox/e2fsprogs/fsck.c (modified) (49 diffs)

branches/3.3/mindi-busybox/e2fsprogs/fsck.c

@@ -34 +34 @@
  * It doesn't guess filesystem types from on-disk format.
  */
+//config:config FSCK
+//config:   bool "fsck"
+//config:   default y
+//config:   help
+//config:     fsck is used to check and optionally repair one or more filesystems.
+//config:     In actuality, fsck is simply a front-end for the various file system
+//config:     checkers (fsck.fstype) available under Linux.
+
+//applet:IF_FSCK(APPLET(fsck, BB_DIR_SBIN, BB_SUID_DROP))
+
+//kbuild:lib-$(CONFIG_FSCK) += fsck.o
 
 //usage:#define fsck_trivial_usage
-//usage:       "[-ANPRTV] [-C FD] [-t FSTYPE] [FS_OPTS] [BLOCKDEV]..."
+//usage:       "[-ANPRTV] [-t FSTYPE] [FS_OPTS] [BLOCKDEV]..."
 //usage:#define fsck_full_usage "\n\n"
 //usage:       "Check and repair filesystems\n"
@@ -45 +56 @@
 //usage:     "\n    -T  Don't show title on startup"
 //usage:     "\n    -V  Verbose"
-//usage:     "\n    -C n    Write status information to specified filedescriptor"
+//DO_PROGRESS_INDICATOR is off:
+////usage:     "\n  -C FD   Write status information to specified file descriptor"
 //usage:     "\n    -t TYPE List of filesystem types to check"
 
 #include "libbb.h"
+#include "common_bufsiz.h"
 
 /* "progress indicator" code is somewhat buggy and ext[23] specific.
@@ -126 +139 @@
 #define BASE_MD "/dev/md"
 
-static char **args;
-static int num_args;
-static int verbose;
+struct globals {
+    char **args;
+    int num_args;
+    int verbose;
 
 #define FS_TYPE_FLAG_NORMAL 0
 #define FS_TYPE_FLAG_OPT    1
 #define FS_TYPE_FLAG_NEGOPT 2
-static char **fs_type_list;
-static uint8_t *fs_type_flag;
-static smallint fs_type_negated;
-
-static smallint noexecute;
-static smallint serialize;
-static smallint skip_root;
-/* static smallint like_mount; */
-static smallint parallel_root;
-static smallint force_all_parallel;
+    char **fs_type_list;
+    uint8_t *fs_type_flag;
+    smallint fs_type_negated;
+
+    smallint noexecute;
+    smallint serialize;
+    smallint skip_root;
+    /* smallint like_mount; */
+    smallint parallel_root;
+    smallint force_all_parallel;
+    smallint kill_sent;
 
 #if DO_PROGRESS_INDICATOR
-static smallint progress;
-static int progress_fd;
-#endif
-
-static int num_running;
-static int max_running;
-static char *fstype;
-static struct fs_info *filesys_info;
-static struct fs_info *filesys_last;
-static struct fsck_instance *instance_list;
+    smallint progress;
+    int progress_fd;
+#endif
+
+    int num_running;
+    int max_running;
+    char *fstype;
+    struct fs_info *filesys_info;
+    struct fs_info *filesys_last;
+    struct fsck_instance *instance_list;
+} FIX_ALIASING;
+#define G (*(struct globals*)bb_common_bufsiz1)
+#define INIT_G() do { \
+    setup_common_bufsiz(); \
+    BUILD_BUG_ON(sizeof(G) > COMMON_BUFSIZE); \
+} while (0)
 
 /*
@@ -200 +221 @@
 
     /* Handle DAC 960 devices */
-    if (strncmp(cp, "rd/", 3) == 0) {
+    if (is_prefixed_with(cp, "rd/")) {
         cp += 3;
         if (cp[0] != 'c' || !isdigit(cp[1])
@@ -225 +246 @@
     /* Now let's handle devfs (ugh) names */
     len = 0;
-    if (strncmp(cp, "ide/", 4) == 0)
+    if (is_prefixed_with(cp, "ide/"))
         len = 4;
-    if (strncmp(cp, "scsi/", 5) == 0)
+    if (is_prefixed_with(cp, "scsi/"))
         len = 5;
     if (len) {
@@ -238 +259 @@
          */
         for (hier = devfs_hier; *hier; hier++) {
-            len = strlen(*hier);
-            if (strncmp(cp, *hier, len) != 0)
+            cp = is_prefixed_with(cp, *hier);
+            if (!cp)
                 goto errout;
-            cp += len;
-            while (*cp != '/' && *cp != 0) {
+            while (*cp != '/' && *cp != '\0') {
                 if (!isdigit(*cp))
                     goto errout;
                 cp++;
             }
+//FIXME: what if *cp = '\0' now? cp++ moves past it!!!
             cp++;
         }
-        cp[-1] = 0;
+        cp[-1] = '\0';
         return str;
     }
 
     /* Now handle devfs /dev/disc or /dev/disk names */
-    disk = 0;
-    if (strncmp(cp, "discs/", 6) == 0)
+    disk = NULL;
+    if (is_prefixed_with(cp, "discs/"))
         disk = "disc";
-    else if (strncmp(cp, "disks/", 6) == 0)
+    else if (is_prefixed_with(cp, "disks/"))
         disk = "disk";
     if (disk) {
         cp += 6;
-        if (strncmp(cp, disk, 4) != 0)
+        cp = is_prefixed_with(cp, disk);
+        if (!cp)
             goto errout;
-        cp += 4;
-        while (*cp != '/' && *cp != 0) {
+        while (*cp != '/' && *cp != '\0') {
             if (!isdigit(*cp))
                 goto errout;
             cp++;
         }
-        *cp = 0;
+        *cp = '\0';
         return str;
     }
@@ -303 +324 @@
     /*fs->next = NULL; */
 
-    if (!filesys_info)
-        filesys_info = fs;
+    if (!G.filesys_info)
+        G.filesys_info = fs;
     else
-        filesys_last->next = fs;
-    filesys_last = fs;
+        G.filesys_last->next = fs;
+    G.filesys_last = fs;
 
     return fs;
@@ -317 +338 @@
     FILE *fstab;
     struct mntent mte;
+    char buf[1024];
 
     fstab = setmntent(filename, "r");
@@ -325 +347 @@
 
     // Loop through entries
-    while (getmntent_r(fstab, &mte, bb_common_bufsiz1, COMMON_BUFSIZE)) {
-        //bb_info_msg("CREATE[%s][%s][%s][%s][%d]", mte.mnt_fsname, mte.mnt_dir,
+    while (getmntent_r(fstab, &mte, buf, sizeof(buf))) {
+        //bb_error_msg("CREATE[%s][%s][%s][%s][%d]", mte.mnt_fsname, mte.mnt_dir,
         //  mte.mnt_type, mte.mnt_opts,
         //  mte.mnt_passno);
@@ -341 +363 @@
     struct fs_info *fs;
 
-    for (fs = filesys_info; fs; fs = fs->next) {
+    for (fs = G.filesys_info; fs; fs = fs->next) {
         if (strcmp(filesys, fs->device) == 0
          || (fs->mountpt && strcmp(filesys, fs->mountpt) == 0)
@@ -356 +378 @@
     struct fsck_instance *inst;
 
-    for (inst = instance_list; inst; inst = inst->next) {
+    for (inst = G.instance_list; inst; inst = inst->next) {
         if (inst->flags & FLAG_DONE)
             continue;
@@ -372 +394 @@
 static void kill_all_if_got_signal(void)
 {
-    static smallint kill_sent;
-
     struct fsck_instance *inst;
 
-    if (!bb_got_signal || kill_sent)
+    if (!bb_got_signal || G.kill_sent)
         return;
 
-    for (inst = instance_list; inst; inst = inst->next) {
+    for (inst = G.instance_list; inst; inst = inst->next) {
         if (inst->flags & FLAG_DONE)
             continue;
         kill(inst->pid, SIGTERM);
     }
-    kill_sent = 1;
+    G.kill_sent = 1;
 }
 
@@ -399 +419 @@
     pid_t pid;
 
-    if (!instance_list)
+    if (!G.instance_list)
         return -1;
-    /* if (noexecute) { already returned -1; } */
+    /* if (G.noexecute) { already returned -1; } */
 
     while (1) {
@@ -419 +439 @@
         }
         prev = NULL;
-        inst = instance_list;
+        inst = G.instance_list;
         do {
             if (inst->pid == pid)
@@ -429 +449 @@
  child_died:
 
-    if (WIFEXITED(status))
-        status = WEXITSTATUS(status);
-    else if (WIFSIGNALED(status)) {
+    status = WEXITSTATUS(status);
+    if (WIFSIGNALED(status)) {
         sig = WTERMSIG(status);
         status = EXIT_UNCORRECTED;
@@ -440 +459 @@
             status = EXIT_ERROR;
         }
-    } else {
-        printf("%s %s: status is %x, should never happen\n",
-            inst->prog, inst->device, status);
-        status = EXIT_ERROR;
     }
 
@@ -449 +464 @@
     if (progress && (inst->flags & FLAG_PROGRESS) && !progress_active()) {
         struct fsck_instance *inst2;
-        for (inst2 = instance_list; inst2; inst2 = inst2->next) {
+        for (inst2 = G.instance_list; inst2; inst2 = inst2->next) {
             if (inst2->flags & FLAG_DONE)
                 continue;
@@ -476 +491 @@
         prev->next = inst->next;
     else
-        instance_list = inst->next;
-    if (verbose > 1)
+        G.instance_list = inst->next;
+    if (G.verbose > 1)
         printf("Finished with %s (exit status %d)\n",
             inst->device, status);
-    num_running--;
+    G.num_running--;
     free_instance(inst);
 
@@ -516 +531 @@
     pid_t pid;
 
-    args[0] = xasprintf("fsck.%s", type);
+    G.args[0] = xasprintf("fsck.%s", type);
 
 #if DO_PROGRESS_INDICATOR
@@ -523 +538 @@
          || strcmp(type, "ext3") == 0
         ) {
-            args[XXX] = xasprintf("-C%d", progress_fd); /* 1 */
+            G.args[XXX] = xasprintf("-C%d", progress_fd); /* 1 */
             inst->flags |= FLAG_PROGRESS;
         }
@@ -529 +544 @@
 #endif
 
-    args[num_args - 2] = (char*)device;
-    /* args[num_args - 1] = NULL; - already is */
-
-    if (verbose || noexecute) {
-        printf("[%s (%d) -- %s]", args[0], num_running,
+    G.args[G.num_args - 2] = (char*)device;
+    /* G.args[G.num_args - 1] = NULL; - already is */
+
+    if (G.verbose || G.noexecute) {
+        printf("[%s (%d) -- %s]", G.args[0], G.num_running,
                     mntpt ? mntpt : device);
-        for (i = 0; args[i]; i++)
-            printf(" %s", args[i]);
+        for (i = 0; G.args[i]; i++)
+            printf(" %s", G.args[i]);
         bb_putchar('\n');
     }
@@ -542 +557 @@
     /* Fork and execute the correct program. */
     pid = -1;
-    if (!noexecute) {
-        pid = spawn(args);
+    if (!G.noexecute) {
+        pid = spawn(G.args);
         if (pid < 0)
-            bb_simple_perror_msg(args[0]);
+            bb_simple_perror_msg(G.args[0]);
     }
 
 #if DO_PROGRESS_INDICATOR
-    free(args[XXX]);
+    free(G.args[XXX]);
 #endif
 
     /* No child, so don't record an instance */
     if (pid <= 0) {
-        free(args[0]);
+        free(G.args[0]);
         return;
     }
@@ -560 +575 @@
     inst = xzalloc(sizeof(*inst));
     inst->pid = pid;
-    inst->prog = args[0];
+    inst->prog = G.args[0];
     inst->device = xstrdup(device);
     inst->base_device = base_device(device);
@@ -569 +584 @@
     /* Add to the list of running fsck's.
      * (was adding to the end, but adding to the front is simpler...) */
-    inst->next = instance_list;
-    instance_list = inst;
+    inst->next = G.instance_list;
+    G.instance_list = inst;
 }
 
@@ -589 +604 @@
     if (strcmp(fs->type, "auto") != 0) {
         type = fs->type;
-        if (verbose > 2)
-            bb_info_msg("using filesystem type '%s' %s",
+        if (G.verbose > 2)
+            printf("using filesystem type '%s' %s\n",
                     type, "from fstab");
-    } else if (fstype
-     && (fstype[0] != 'n' || fstype[1] != 'o') /* != "no" */
-     && strncmp(fstype, "opts=", 5) != 0
-     && strncmp(fstype, "loop", 4) != 0
-     && !strchr(fstype, ',')
+    } else if (G.fstype
+     && (G.fstype[0] != 'n' || G.fstype[1] != 'o') /* != "no" */
+     && !is_prefixed_with(G.fstype, "opts=")
+     && !is_prefixed_with(G.fstype, "loop")
+     && !strchr(G.fstype, ',')
     ) {
-        type = fstype;
-        if (verbose > 2)
-            bb_info_msg("using filesystem type '%s' %s",
+        type = G.fstype;
+        if (G.verbose > 2)
+            printf("using filesystem type '%s' %s\n",
                     type, "from -t");
     } else {
         type = "auto";
-        if (verbose > 2)
-            bb_info_msg("using filesystem type '%s' %s",
+        if (G.verbose > 2)
+            printf("using filesystem type '%s' %s\n",
                     type, "(default)");
     }
 
-    num_running++;
+    G.num_running++;
     execute(type, fs->device, fs->mountpt /*, interactive */);
 }
@@ -622 +637 @@
     char *base;
 
-    if (force_all_parallel)
+    if (G.force_all_parallel)
         return 0;
 
 #ifdef BASE_MD
     /* Don't check a soft raid disk with any other disk */
-    if (instance_list
-     && (!strncmp(instance_list->device, BASE_MD, sizeof(BASE_MD)-1)
-         || !strncmp(device, BASE_MD, sizeof(BASE_MD)-1))
+    if (G.instance_list
+     && (is_prefixed_with(G.instance_list->device, BASE_MD)
+         || is_prefixed_with(device, BASE_MD))
     ) {
         return 1;
@@ -641 +656 @@
      */
     if (!base)
-        return (instance_list != NULL);
-
-    for (inst = instance_list; inst; inst = inst->next) {
+        return (G.instance_list != NULL);
+
+    for (inst = G.instance_list; inst; inst = inst->next) {
         if (!inst->base_device || !strcmp(base, inst->base_device)) {
             free(base);
@@ -688 +703 @@
     char *cp;
 
-    if (!fs_type_list)
+    if (!G.fs_type_list)
         return 1;
 
@@ -695 +710 @@
     n = 0;
     while (1) {
-        cp = fs_type_list[n];
+        cp = G.fs_type_list[n];
         if (!cp)
             break;
-        switch (fs_type_flag[n]) {
+        switch (G.fs_type_flag[n]) {
         case FS_TYPE_FLAG_NORMAL:
             checked_type++;
@@ -718 +733 @@
         return 1;
 
-    return (fs_type_negated ? !ret : ret);
+    return (G.fs_type_negated ? !ret : ret);
 }
 
@@ -754 +769 @@
     int passno;
 
-    if (verbose)
+    if (G.verbose)
         puts("Checking all filesystems");
 
@@ -762 +777 @@
      * filesystem types (done as a side-effect of calling ignore()).
      */
-    for (fs = filesys_info; fs; fs = fs->next)
+    for (fs = G.filesys_info; fs; fs = fs->next)
         if (ignore(fs))
             fs->flags |= FLAG_DONE;
@@ -769 +784 @@
      * Find and check the root filesystem.
      */
-    if (!parallel_root) {
-        for (fs = filesys_info; fs; fs = fs->next) {
+    if (!G.parallel_root) {
+        for (fs = G.filesys_info; fs; fs = fs->next) {
             if (LONE_CHAR(fs->mountpt, '/')) {
-                if (!skip_root && !ignore(fs)) {
+                if (!G.skip_root && !ignore(fs)) {
                     fsck_device(fs /*, 1*/);
                     status |= wait_many(FLAG_WAIT_ALL);
@@ -788 +803 @@
      * "Skip root" will skip _all_ root entries.
      */
-    if (skip_root)
-        for (fs = filesys_info; fs; fs = fs->next)
+    if (G.skip_root)
+        for (fs = G.filesys_info; fs; fs = fs->next)
             if (LONE_CHAR(fs->mountpt, '/'))
                 fs->flags |= FLAG_DONE;
@@ -799 +814 @@
         pass_done = 1;
 
-        for (fs = filesys_info; fs; fs = fs->next) {
+        for (fs = G.filesys_info; fs; fs = fs->next) {
             if (bb_got_signal)
                 break;
@@ -825 +840 @@
              * Spawn off the fsck process
              */
-            fsck_device(fs /*, serialize*/);
+            fsck_device(fs /*, G.serialize*/);
             fs->flags |= FLAG_DONE;
 
@@ -833 +848 @@
              * at one time, apply that limit.
              */
-            if (serialize
-             || (max_running && (num_running >= max_running))
+            if (G.serialize
+             || (G.num_running >= G.max_running)
             ) {
                 pass_done = 0;
@@ -842 +857 @@
         if (bb_got_signal)
             break;
-        if (verbose > 1)
+        if (G.verbose > 1)
             printf("--waiting-- (pass %d)\n", passno);
         status |= wait_many(pass_done ? FLAG_WAIT_ALL :
                 FLAG_WAIT_ATLEAST_ONE);
         if (pass_done) {
-            if (verbose > 1)
+            if (G.verbose > 1)
                 puts("----------------------------------");
             passno++;
@@ -875 +890 @@
     }
 
-    fs_type_list = xzalloc(num * sizeof(fs_type_list[0]));
-    fs_type_flag = xzalloc(num * sizeof(fs_type_flag[0]));
-    fs_type_negated = -1; /* not yet known is it negated or not */
+    G.fs_type_list = xzalloc(num * sizeof(G.fs_type_list[0]));
+    G.fs_type_flag = xzalloc(num * sizeof(G.fs_type_flag[0]));
+    G.fs_type_negated = -1; /* not yet known is it negated or not */
 
     num = 0;
@@ -896 +911 @@
             /* loop is really short-hand for opts=loop */
             goto loop_special_case;
-        if (strncmp(s, "opts=", 5) == 0) {
+        if (is_prefixed_with(s, "opts=")) {
             s += 5;
  loop_special_case:
-            fs_type_flag[num] = negate ? FS_TYPE_FLAG_NEGOPT : FS_TYPE_FLAG_OPT;
+            G.fs_type_flag[num] = negate ? FS_TYPE_FLAG_NEGOPT : FS_TYPE_FLAG_OPT;
         } else {
-            if (fs_type_negated == -1)
-                fs_type_negated = negate;
-            if (fs_type_negated != negate)
+            if (G.fs_type_negated == -1)
+                G.fs_type_negated = negate;
+            if (G.fs_type_negated != negate)
                 bb_error_msg_and_die(
 "either all or none of the filesystem types passed to -t must be prefixed "
 "with 'no' or '!'");
         }
-        comma = strchr(s, ',');
-        fs_type_list[num++] = comma ? xstrndup(s, comma-s) : xstrdup(s);
-        if (!comma)
+        comma = strchrnul(s, ',');
+        G.fs_type_list[num++] = xstrndup(s, comma-s);
+        if (*comma == '\0')
             break;
         s = comma + 1;
@@ -918 +933 @@
 static char **new_args(void)
 {
-    args = xrealloc_vector(args, 2, num_args);
-    return &args[num_args++];
+    G.args = xrealloc_vector(G.args, 2, G.num_args);
+    return &G.args[G.num_args++];
 }
 
@@ -936 +951 @@
     smallint notitle;
 
+    INIT_G();
+
     /* we want wait() to be interruptible */
     signal_no_SA_RESTART_empty_mask(SIGINT, record_signo);
@@ -945 +962 @@
     devices = NULL;
     num_devices = 0;
-    new_args(); /* args[0] = NULL, will be replaced by fsck.<type> */
-    /* instance_list = NULL; - in bss, so already zeroed */
+    new_args(); /* G.args[0] = NULL, will be replaced by fsck.<type> */
+    /* G.instance_list = NULL; - in bss, so already zeroed */
 
     while (*++argv) {
@@ -995 +1012 @@
 #endif
             case 'V':
-                verbose++;
+                G.verbose++;
                 break;
             case 'N':
-                noexecute = 1;
+                G.noexecute = 1;
                 break;
             case 'R':
-                skip_root = 1;
+                G.skip_root = 1;
                 break;
             case 'T':
@@ -1010 +1027 @@
                 break; */
             case 'P':
-                parallel_root = 1;
+                G.parallel_root = 1;
                 break;
             case 's':
-                serialize = 1;
+                G.serialize = 1;
                 break;
             case 't':
-                if (fstype)
+                if (G.fstype)
                     bb_show_usage();
                 if (arg[++j])
@@ -1024 +1041 @@
                 else
                     bb_show_usage();
-                fstype = xstrdup(tmp);
-                compile_fs_type(fstype);
+                G.fstype = xstrdup(tmp);
+                compile_fs_type(G.fstype);
                 goto next_arg;
             case '?':
@@ -1046 +1063 @@
     }
     if (getenv("FSCK_FORCE_ALL_PARALLEL"))
-        force_all_parallel = 1;
+        G.force_all_parallel = 1;
     tmp = getenv("FSCK_MAX_INST");
+    G.max_running = INT_MAX;
     if (tmp)
-        max_running = xatoi(tmp);
-    new_args(); /* args[num_args - 2] will be replaced by <device> */
-    new_args(); /* args[num_args - 1] is the last, NULL element */
+        G.max_running = xatoi(tmp);
+    new_args(); /* G.args[G.num_args - 2] will be replaced by <device> */
+    new_args(); /* G.args[G.num_args - 1] is the last, NULL element */
 
     if (!notitle)
@@ -1063 +1081 @@
     load_fs_info(fstab);
 
-    /*interactive = (num_devices == 1) | serialize;*/
+    /*interactive = (num_devices == 1) | G.serialize;*/
 
     if (num_devices == 0)
-        /*interactive =*/ serialize = doall = 1;
+        /*interactive =*/ G.serialize = doall = 1;
     if (doall)
         return check_all();
@@ -1082 +1100 @@
         fsck_device(fs /*, interactive */);
 
-        if (serialize
-         || (max_running && (num_running >= max_running))
+        if (G.serialize
+         || (G.num_running >= G.max_running)
         ) {
             int exit_status = wait_one(0);
             if (exit_status >= 0)
                 status |= exit_status;
-            if (verbose > 1)
+            if (G.verbose > 1)
                 puts("----------------------------------");
         }