btrfs-progs: fix type mismatch in backtrace dumping functions

[platform/upstream/btrfs-progs.git] / cmds-rescue.c

diff --git a/cmds-rescue.c b/cmds-rescue.c
index 6419367..f597997 100644 (file)
--- a/cmds-rescue.c
+++ b/cmds-rescue.c
@@ -33,7 +33,7 @@ static const char * const rescue_cmd_group_usage[] = {
 int btrfs_recover_chunk_tree(char *path, int verbose, int yes);
 int btrfs_recover_superblocks(char *path, int verbose, int yes);
 
-const char * const cmd_chunk_recover_usage[] = {
+static const char * const cmd_rescue_chunk_recover_usage[] = {
        "btrfs rescue chunk-recover [options] <device>",
        "Recover the chunk tree by scanning the devices one by one.",
        "",
@@ -43,16 +43,7 @@ const char * const cmd_chunk_recover_usage[] = {
        NULL
 };
 
-const char * const cmd_super_recover_usage[] = {
-       "btrfs rescue super-recover [options] <device>",
-       "Recover bad superblocks from good copies",
-       "",
-       "-y     Assume an answer of `yes' to all questions",
-       "-v     Verbose mode",
-       NULL
-};
-
-int cmd_chunk_recover(int argc, char *argv[])
+static int cmd_rescue_chunk_recover(int argc, char *argv[])
 {
        int ret = 0;
        char *file;
@@ -72,38 +63,45 @@ int cmd_chunk_recover(int argc, char *argv[])
                        break;
                case 'h':
                default:
-                       usage(cmd_chunk_recover_usage);
+                       usage(cmd_rescue_chunk_recover_usage);
                }
        }
 
-       argc = argc - optind;
-       if (check_argc_exact(argc, 1))
-               usage(cmd_chunk_recover_usage);
+       if (check_argc_exact(argc - optind, 1))
+               usage(cmd_rescue_chunk_recover_usage);
 
        file = argv[optind];
 
        ret = check_mounted(file);
        if (ret < 0) {
-               fprintf(stderr, "Could not check mount status: %s\n",
-                       strerror(-ret));
+               error("could not check mount status: %s", strerror(-ret));
                return 1;
        } else if (ret) {
-               fprintf(stderr, "the device is busy\n");
+               error("the device is busy");
                return 1;
        }
 
        ret = btrfs_recover_chunk_tree(file, verbose, yes);
        if (!ret) {
-               fprintf(stdout, "Recover the chunk tree successfully.\n");
+               fprintf(stdout, "Chunk tree recovered successfully\n");
        } else if (ret > 0) {
                ret = 0;
-               fprintf(stdout, "Abort to rebuild the on-disk chunk tree.\n");
+               fprintf(stdout, "Chunk tree recovery aborted\n");
        } else {
-               fprintf(stdout, "Fail to recover the chunk tree.\n");
+               fprintf(stdout, "Chunk tree recovery failed\n");
        }
        return ret;
 }
 
+static const char * const cmd_rescue_super_recover_usage[] = {
+       "btrfs rescue super-recover [options] <device>",
+       "Recover bad superblocks from good copies",
+       "",
+       "-y     Assume an answer of `yes' to all questions",
+       "-v     Verbose mode",
+       NULL
+};
+
 /*
  * return codes:
  *   0 : All superblocks are valid, no need to recover
@@ -112,7 +110,7 @@ int cmd_chunk_recover(int argc, char *argv[])
  *   3 : Fail to Recover bad supeblocks
  *   4 : Abort to recover bad superblocks
  */
-int cmd_super_recover(int argc, char **argv)
+static int cmd_rescue_super_recover(int argc, char **argv)
 {
        int ret;
        int verbose = 0;
@@ -131,35 +129,33 @@ int cmd_super_recover(int argc, char **argv)
                        yes = 1;
                        break;
                default:
-                       usage(cmd_super_recover_usage);
+                       usage(cmd_rescue_super_recover_usage);
                }
        }
-       argc = argc - optind;
-       if (check_argc_exact(argc, 1))
-               usage(cmd_super_recover_usage);
+       if (check_argc_exact(argc - optind, 1))
+               usage(cmd_rescue_super_recover_usage);
 
        dname = argv[optind];
        ret = check_mounted(dname);
        if (ret < 0) {
-               fprintf(stderr, "Could not check mount status: %s\n",
-                       strerror(-ret));
+               error("could not check mount status: %s", strerror(-ret));
                return 1;
        } else if (ret) {
-               fprintf(stderr, "the device is busy\n");
+               error("the device is busy");
                return 1;
        }
        ret = btrfs_recover_superblocks(dname, verbose, yes);
        return ret;
 }
 
-const char * const cmd_rescue_zero_log_usage[] = {
+static const char * const cmd_rescue_zero_log_usage[] = {
        "btrfs rescue zero-log <device>",
        "Clear the tree log. Usable if it's corrupted and prevents mount.",
        "",
        NULL
 };
 
-int cmd_rescue_zero_log(int argc, char **argv)
+static int cmd_rescue_zero_log(int argc, char **argv)
 {
        struct btrfs_root *root;
        struct btrfs_trans_handle *trans;
@@ -167,22 +163,24 @@ int cmd_rescue_zero_log(int argc, char **argv)
        char *devname;
        int ret;
 
+       clean_args_no_options(argc, argv, cmd_rescue_zero_log_usage);
+
        if (check_argc_exact(argc, 2))
                usage(cmd_rescue_zero_log_usage);
 
        devname = argv[optind];
        ret = check_mounted(devname);
        if (ret < 0) {
-               fprintf(stderr, "Could not check mount status: %s\n", strerror(-ret));
+               error("could not check mount status: %s", strerror(-ret));
                goto out;
        } else if (ret) {
-               fprintf(stderr, "%s is currently mounted. Aborting.\n", devname);
+               error("%s is currently mounted", devname);
                ret = -EBUSY;
        }
 
        root = open_ctree(devname, 0, OPEN_CTREE_WRITES | OPEN_CTREE_PARTIAL);
        if (!root) {
-               fprintf(stderr, "Could not open ctree\n");
+               error("could not open ctree");
                return 1;
        }
 
@@ -201,10 +199,15 @@ out:
        return !!ret;
 }
 
+static const char rescue_cmd_group_info[] =
+"toolbox for specific rescue operations";
+
 const struct cmd_group rescue_cmd_group = {
-       rescue_cmd_group_usage, NULL, {
-               { "chunk-recover", cmd_chunk_recover, cmd_chunk_recover_usage, NULL, 0},
-               { "super-recover", cmd_super_recover, cmd_super_recover_usage, NULL, 0},
+       rescue_cmd_group_usage, rescue_cmd_group_info, {
+               { "chunk-recover", cmd_rescue_chunk_recover,
+                       cmd_rescue_chunk_recover_usage, NULL, 0},
+               { "super-recover", cmd_rescue_super_recover,
+                       cmd_rescue_super_recover_usage, NULL, 0},
                { "zero-log", cmd_rescue_zero_log, cmd_rescue_zero_log_usage, NULL, 0},
                NULL_CMD_STRUCT
        }