2013-09-17 15:21:20 +00:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2013 SUSE. All rights reserved.
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public
|
|
|
|
* License v2 as published by the Free Software Foundation.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public
|
|
|
|
* License along with this program; if not, write to the
|
|
|
|
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
|
|
* Boston, MA 021110-1307, USA.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "kerncompat.h"
|
2022-09-15 11:59:39 +00:00
|
|
|
#include <sys/stat.h>
|
2020-10-29 23:17:36 +00:00
|
|
|
#include <sys/sysmacros.h>
|
2013-09-17 15:21:22 +00:00
|
|
|
#include <getopt.h>
|
2022-09-15 11:59:39 +00:00
|
|
|
#include <errno.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include "kernel-lib/list.h"
|
2020-08-18 13:56:04 +00:00
|
|
|
#include "kernel-shared/ctree.h"
|
2020-08-18 13:56:04 +00:00
|
|
|
#include "kernel-shared/volumes.h"
|
2020-08-18 13:56:04 +00:00
|
|
|
#include "kernel-shared/transaction.h"
|
2020-08-18 13:56:04 +00:00
|
|
|
#include "kernel-shared/disk-io.h"
|
2022-09-15 11:59:39 +00:00
|
|
|
#include "kernel-shared/extent_io.h"
|
|
|
|
#include "common/messages.h"
|
2019-06-19 23:46:21 +00:00
|
|
|
#include "common/utils.h"
|
2019-06-19 23:46:21 +00:00
|
|
|
#include "common/help.h"
|
2021-04-29 17:52:15 +00:00
|
|
|
#include "common/open-utils.h"
|
2022-09-14 15:06:52 +00:00
|
|
|
#include "cmds/commands.h"
|
|
|
|
#include "cmds/rescue.h"
|
2013-09-17 15:21:20 +00:00
|
|
|
|
|
|
|
static const char * const rescue_cmd_group_usage[] = {
|
|
|
|
"btrfs rescue <command> [options] <path>",
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2015-09-14 21:27:19 +00:00
|
|
|
static const char * const cmd_rescue_chunk_recover_usage[] = {
|
2013-09-17 15:21:22 +00:00
|
|
|
"btrfs rescue chunk-recover [options] <device>",
|
|
|
|
"Recover the chunk tree by scanning the devices one by one.",
|
|
|
|
"",
|
2020-06-29 14:57:54 +00:00
|
|
|
"-y Assume an answer of `yes' to all questions",
|
|
|
|
"-h Help",
|
2020-06-26 20:20:56 +00:00
|
|
|
"-v deprecated, alias for global -v option",
|
2019-11-25 10:39:10 +00:00
|
|
|
HELPINFO_INSERT_GLOBALS,
|
|
|
|
HELPINFO_INSERT_VERBOSE,
|
2013-09-17 15:21:22 +00:00
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2018-03-07 02:24:46 +00:00
|
|
|
static int cmd_rescue_chunk_recover(const struct cmd_struct *cmd,
|
|
|
|
int argc, char *argv[])
|
2013-09-17 15:21:22 +00:00
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
char *file;
|
2022-10-05 18:02:13 +00:00
|
|
|
bool yes = false;
|
2019-11-25 10:39:10 +00:00
|
|
|
|
|
|
|
/* If verbose is unset, set it to 0 */
|
|
|
|
if (bconf.verbose == BTRFS_BCONF_UNSET)
|
|
|
|
bconf.verbose = BTRFS_BCONF_QUIET;
|
2013-09-17 15:21:22 +00:00
|
|
|
|
2018-06-20 00:38:38 +00:00
|
|
|
optind = 0;
|
2013-09-17 15:21:22 +00:00
|
|
|
while (1) {
|
|
|
|
int c = getopt(argc, argv, "yvh");
|
|
|
|
if (c < 0)
|
|
|
|
break;
|
|
|
|
switch (c) {
|
|
|
|
case 'y':
|
2022-10-05 18:02:13 +00:00
|
|
|
yes = true;
|
2013-09-17 15:21:22 +00:00
|
|
|
break;
|
|
|
|
case 'v':
|
2019-11-25 10:39:10 +00:00
|
|
|
bconf.verbose++;
|
2013-09-17 15:21:22 +00:00
|
|
|
break;
|
|
|
|
default:
|
2018-03-07 02:54:38 +00:00
|
|
|
usage_unknown_option(cmd, argv);
|
2013-09-17 15:21:22 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-03-09 13:29:29 +00:00
|
|
|
if (check_argc_exact(argc - optind, 1))
|
2019-03-04 13:49:15 +00:00
|
|
|
return 1;
|
2013-09-17 15:21:22 +00:00
|
|
|
|
|
|
|
file = argv[optind];
|
|
|
|
|
|
|
|
ret = check_mounted(file);
|
2014-02-20 02:49:03 +00:00
|
|
|
if (ret < 0) {
|
2018-10-25 12:10:54 +00:00
|
|
|
errno = -ret;
|
|
|
|
error("could not check mount status: %m");
|
2014-02-20 02:49:03 +00:00
|
|
|
return 1;
|
|
|
|
} else if (ret) {
|
2016-01-11 10:01:47 +00:00
|
|
|
error("the device is busy");
|
2014-02-20 02:49:03 +00:00
|
|
|
return 1;
|
2013-09-17 15:21:22 +00:00
|
|
|
}
|
|
|
|
|
2019-11-25 10:39:10 +00:00
|
|
|
ret = btrfs_recover_chunk_tree(file, yes);
|
2013-09-17 15:21:22 +00:00
|
|
|
if (!ret) {
|
2022-10-04 14:50:09 +00:00
|
|
|
pr_verbose(LOG_DEFAULT, "Chunk tree recovered successfully\n");
|
2013-09-17 15:21:22 +00:00
|
|
|
} else if (ret > 0) {
|
|
|
|
ret = 0;
|
2022-10-04 14:50:09 +00:00
|
|
|
pr_verbose(LOG_DEFAULT, "Chunk tree recovery aborted\n");
|
2013-09-17 15:21:22 +00:00
|
|
|
} else {
|
2022-10-04 14:50:09 +00:00
|
|
|
pr_verbose(LOG_DEFAULT, "Chunk tree recovery failed\n");
|
2013-09-17 15:21:22 +00:00
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
2018-03-07 02:07:03 +00:00
|
|
|
static DEFINE_SIMPLE_COMMAND(rescue_chunk_recover, "chunk-recover");
|
2013-09-17 15:21:22 +00:00
|
|
|
|
2016-01-11 13:31:20 +00:00
|
|
|
static const char * const cmd_rescue_super_recover_usage[] = {
|
|
|
|
"btrfs rescue super-recover [options] <device>",
|
|
|
|
"Recover bad superblocks from good copies",
|
|
|
|
"",
|
2020-06-29 14:57:54 +00:00
|
|
|
"-y Assume an answer of `yes' to all questions",
|
2020-06-26 20:20:56 +00:00
|
|
|
"-v deprecated, alias for global -v option",
|
2019-11-25 10:39:11 +00:00
|
|
|
HELPINFO_INSERT_GLOBALS,
|
|
|
|
HELPINFO_INSERT_VERBOSE,
|
2016-01-11 13:31:20 +00:00
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2013-09-21 08:34:18 +00:00
|
|
|
/*
|
|
|
|
* return codes:
|
|
|
|
* 0 : All superblocks are valid, no need to recover
|
|
|
|
* 1 : Usage or syntax error
|
|
|
|
* 2 : Recover all bad superblocks successfully
|
2018-11-26 17:01:42 +00:00
|
|
|
* 3 : Fail to Recover bad superblocks
|
2013-09-21 08:34:18 +00:00
|
|
|
* 4 : Abort to recover bad superblocks
|
|
|
|
*/
|
2018-03-07 02:24:46 +00:00
|
|
|
static int cmd_rescue_super_recover(const struct cmd_struct *cmd,
|
|
|
|
int argc, char **argv)
|
2013-09-21 08:34:18 +00:00
|
|
|
{
|
|
|
|
int ret;
|
2022-10-05 18:02:13 +00:00
|
|
|
bool yes = false;
|
2013-09-21 08:34:18 +00:00
|
|
|
char *dname;
|
|
|
|
|
2018-06-20 00:38:38 +00:00
|
|
|
optind = 0;
|
2013-09-21 08:34:18 +00:00
|
|
|
while (1) {
|
|
|
|
int c = getopt(argc, argv, "vy");
|
|
|
|
if (c < 0)
|
|
|
|
break;
|
|
|
|
switch (c) {
|
|
|
|
case 'v':
|
2019-11-25 10:39:11 +00:00
|
|
|
bconf_be_verbose();
|
2013-09-21 08:34:18 +00:00
|
|
|
break;
|
|
|
|
case 'y':
|
2022-10-05 18:02:13 +00:00
|
|
|
yes = true;
|
2013-09-21 08:34:18 +00:00
|
|
|
break;
|
|
|
|
default:
|
2018-03-07 02:54:38 +00:00
|
|
|
usage_unknown_option(cmd, argv);
|
2013-09-21 08:34:18 +00:00
|
|
|
}
|
|
|
|
}
|
2016-03-09 13:29:29 +00:00
|
|
|
if (check_argc_exact(argc - optind, 1))
|
2019-03-04 13:49:15 +00:00
|
|
|
return 1;
|
2013-09-21 08:34:18 +00:00
|
|
|
|
|
|
|
dname = argv[optind];
|
|
|
|
ret = check_mounted(dname);
|
2014-02-20 02:49:03 +00:00
|
|
|
if (ret < 0) {
|
2018-10-25 12:10:54 +00:00
|
|
|
errno = -ret;
|
|
|
|
error("could not check mount status: %m");
|
2014-02-20 02:49:03 +00:00
|
|
|
return 1;
|
|
|
|
} else if (ret) {
|
2016-01-11 10:01:47 +00:00
|
|
|
error("the device is busy");
|
2013-09-21 08:34:18 +00:00
|
|
|
return 1;
|
|
|
|
}
|
2019-11-25 10:39:11 +00:00
|
|
|
ret = btrfs_recover_superblocks(dname, yes);
|
2013-09-21 08:34:18 +00:00
|
|
|
return ret;
|
|
|
|
}
|
2018-03-07 02:07:03 +00:00
|
|
|
static DEFINE_SIMPLE_COMMAND(rescue_super_recover, "super-recover");
|
2013-09-21 08:34:18 +00:00
|
|
|
|
2015-09-14 21:27:19 +00:00
|
|
|
static const char * const cmd_rescue_zero_log_usage[] = {
|
2013-11-13 17:55:12 +00:00
|
|
|
"btrfs rescue zero-log <device>",
|
|
|
|
"Clear the tree log. Usable if it's corrupted and prevents mount.",
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2018-03-07 02:24:46 +00:00
|
|
|
static int cmd_rescue_zero_log(const struct cmd_struct *cmd,
|
|
|
|
int argc, char **argv)
|
2013-11-13 17:55:12 +00:00
|
|
|
{
|
|
|
|
struct btrfs_root *root;
|
|
|
|
struct btrfs_super_block *sb;
|
|
|
|
char *devname;
|
|
|
|
int ret;
|
|
|
|
|
2018-03-07 02:42:01 +00:00
|
|
|
clean_args_no_options(cmd, argc, argv);
|
2016-03-01 15:02:08 +00:00
|
|
|
|
2013-11-13 17:55:12 +00:00
|
|
|
if (check_argc_exact(argc, 2))
|
2019-03-04 13:49:15 +00:00
|
|
|
return 1;
|
2013-11-13 17:55:12 +00:00
|
|
|
|
|
|
|
devname = argv[optind];
|
|
|
|
ret = check_mounted(devname);
|
|
|
|
if (ret < 0) {
|
2018-10-25 12:10:54 +00:00
|
|
|
errno = -ret;
|
|
|
|
error("could not check mount status: %m");
|
2013-11-13 17:55:12 +00:00
|
|
|
goto out;
|
|
|
|
} else if (ret) {
|
2016-01-11 10:01:47 +00:00
|
|
|
error("%s is currently mounted", devname);
|
2013-11-13 17:55:12 +00:00
|
|
|
ret = -EBUSY;
|
2017-10-17 09:13:12 +00:00
|
|
|
goto out;
|
2013-11-13 17:55:12 +00:00
|
|
|
}
|
|
|
|
|
btrfs-progs: rescue/zero-log: Manually write all supers to handle extent tree error more gracefully
[BUG]
Even "btrfs rescue zero-log" only reset btrfs_super_block::log_root and
btrfs_super_block::log_root_level, we still use trasction to write all
super blocks for all devices.
This means we can't handle things like corrupted extent tree:
checksum verify failed on 2172747776 found 000000B6 wanted 00000000
checksum verify failed on 2172747776 found 000000B6 wanted 00000000
bad tree block 2172747776, bytenr mismatch, want=2172747776, have=0
WARNING: could not setup extent tree, skipping it
Clearing log on /dev/nvme/btrfs, previous log_root 0, level 0
ERROR: Corrupted fs, no valid METADATA block group found
ERROR: attempt to start transaction over already running one
[CAUSE]
Because we have extra check in transaction code to ensure we have valid
METADATA block groups.
In fact we don't really need transaction at all.
[FIX]
Instead of commit transaction, we can just call write_all_supers()
manually, so we can still handle multi-device fs while avoid above
error.
Also, add OPEN_CTREE_NO_BLOCK_GROUPS open ctree flag to make it more
robust.
Link: https://lore.kernel.org/linux-btrfs/CAKbQEqG35D_=8raTFH75-yCYoqH2OvpPEmpj2dxgo+PTc=cfhA@mail.gmail.com/
Reported-by: Christian Pernegger <pernegger@gmail.com>
Signed-off-by: Qu Wenruo <wqu@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>
2019-11-11 07:50:59 +00:00
|
|
|
root = open_ctree(devname, 0, OPEN_CTREE_WRITES | OPEN_CTREE_PARTIAL |
|
|
|
|
OPEN_CTREE_NO_BLOCK_GROUPS);
|
2013-11-13 17:55:12 +00:00
|
|
|
if (!root) {
|
2016-01-11 10:01:47 +00:00
|
|
|
error("could not open ctree");
|
2013-11-13 17:55:12 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
sb = root->fs_info->super_copy;
|
2022-10-04 14:50:09 +00:00
|
|
|
pr_verbose(LOG_DEFAULT, "Clearing log on %s, previous log_root %llu, level %u\n",
|
2022-09-27 23:13:00 +00:00
|
|
|
devname, btrfs_super_log_root(sb),
|
2013-11-13 17:55:12 +00:00
|
|
|
(unsigned)btrfs_super_log_root_level(sb));
|
|
|
|
btrfs_set_super_log_root(sb, 0);
|
|
|
|
btrfs_set_super_log_root_level(sb, 0);
|
btrfs-progs: rescue/zero-log: Manually write all supers to handle extent tree error more gracefully
[BUG]
Even "btrfs rescue zero-log" only reset btrfs_super_block::log_root and
btrfs_super_block::log_root_level, we still use trasction to write all
super blocks for all devices.
This means we can't handle things like corrupted extent tree:
checksum verify failed on 2172747776 found 000000B6 wanted 00000000
checksum verify failed on 2172747776 found 000000B6 wanted 00000000
bad tree block 2172747776, bytenr mismatch, want=2172747776, have=0
WARNING: could not setup extent tree, skipping it
Clearing log on /dev/nvme/btrfs, previous log_root 0, level 0
ERROR: Corrupted fs, no valid METADATA block group found
ERROR: attempt to start transaction over already running one
[CAUSE]
Because we have extra check in transaction code to ensure we have valid
METADATA block groups.
In fact we don't really need transaction at all.
[FIX]
Instead of commit transaction, we can just call write_all_supers()
manually, so we can still handle multi-device fs while avoid above
error.
Also, add OPEN_CTREE_NO_BLOCK_GROUPS open ctree flag to make it more
robust.
Link: https://lore.kernel.org/linux-btrfs/CAKbQEqG35D_=8raTFH75-yCYoqH2OvpPEmpj2dxgo+PTc=cfhA@mail.gmail.com/
Reported-by: Christian Pernegger <pernegger@gmail.com>
Signed-off-by: Qu Wenruo <wqu@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>
2019-11-11 07:50:59 +00:00
|
|
|
ret = write_all_supers(root->fs_info);
|
|
|
|
if (ret < 0) {
|
|
|
|
errno = -ret;
|
|
|
|
error("failed to write dev supers: %m");
|
|
|
|
}
|
2013-11-13 17:55:12 +00:00
|
|
|
close_ctree(root);
|
|
|
|
out:
|
|
|
|
return !!ret;
|
|
|
|
}
|
2018-03-07 02:07:03 +00:00
|
|
|
static DEFINE_SIMPLE_COMMAND(rescue_zero_log, "zero-log");
|
2013-11-13 17:55:12 +00:00
|
|
|
|
2017-10-17 07:45:50 +00:00
|
|
|
static const char * const cmd_rescue_fix_device_size_usage[] = {
|
|
|
|
"btrfs rescue fix-device-size <device>",
|
|
|
|
"Re-align device and super block sizes. Usable if newer kernel refuse to mount it due to mismatch super size",
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2018-03-07 02:24:46 +00:00
|
|
|
static int cmd_rescue_fix_device_size(const struct cmd_struct *cmd,
|
|
|
|
int argc, char **argv)
|
2017-10-17 07:45:50 +00:00
|
|
|
{
|
|
|
|
struct btrfs_fs_info *fs_info;
|
2021-02-18 00:27:21 +00:00
|
|
|
struct open_ctree_flags ocf = { 0 };
|
2017-10-17 07:45:50 +00:00
|
|
|
char *devname;
|
|
|
|
int ret;
|
|
|
|
|
2018-03-07 02:42:01 +00:00
|
|
|
clean_args_no_options(cmd, argc, argv);
|
2017-10-17 07:45:50 +00:00
|
|
|
|
|
|
|
if (check_argc_exact(argc, 2))
|
2019-03-04 13:49:15 +00:00
|
|
|
return 1;
|
2017-10-17 07:45:50 +00:00
|
|
|
|
|
|
|
devname = argv[optind];
|
|
|
|
ret = check_mounted(devname);
|
|
|
|
if (ret < 0) {
|
2018-10-25 12:10:54 +00:00
|
|
|
errno = -ret;
|
|
|
|
error("could not check mount status: %m");
|
2017-10-17 07:45:50 +00:00
|
|
|
goto out;
|
|
|
|
} else if (ret) {
|
|
|
|
error("%s is currently mounted", devname);
|
|
|
|
ret = -EBUSY;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2021-02-18 00:27:21 +00:00
|
|
|
ocf.filename = devname;
|
|
|
|
ocf.flags = OPEN_CTREE_WRITES | OPEN_CTREE_PARTIAL;
|
|
|
|
fs_info = open_ctree_fs_info(&ocf);
|
2017-10-17 07:45:50 +00:00
|
|
|
if (!fs_info) {
|
|
|
|
error("could not open btrfs");
|
|
|
|
ret = -EIO;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = btrfs_fix_device_and_super_size(fs_info);
|
|
|
|
if (ret > 0)
|
|
|
|
ret = 0;
|
|
|
|
close_ctree(fs_info->tree_root);
|
|
|
|
out:
|
|
|
|
return !!ret;
|
|
|
|
}
|
2018-03-07 02:07:03 +00:00
|
|
|
static DEFINE_SIMPLE_COMMAND(rescue_fix_device_size, "fix-device-size");
|
2017-10-17 07:45:50 +00:00
|
|
|
|
2020-10-29 23:17:36 +00:00
|
|
|
static const char * const cmd_rescue_create_control_device_usage[] = {
|
|
|
|
"btrfs rescue create-control-device",
|
|
|
|
"Create /dev/btrfs-control (see 'CONTROL DEVICE' in btrfs(5))",
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
static int cmd_rescue_create_control_device(const struct cmd_struct *cmd,
|
|
|
|
int argc, char **argv)
|
|
|
|
{
|
|
|
|
dev_t device;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (check_argc_exact(argc, 1))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
device = makedev(10, 234);
|
|
|
|
|
|
|
|
ret = mknod("/dev/btrfs-control", S_IFCHR | S_IRUSR | S_IWUSR, device);
|
|
|
|
if (ret) {
|
|
|
|
error("could not create /dev/btrfs-control: %m");
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
}
|
|
|
|
static DEFINE_SIMPLE_COMMAND(rescue_create_control_device, "create-control-device");
|
|
|
|
|
2021-11-11 08:14:33 +00:00
|
|
|
static int clear_uuid_tree(struct btrfs_fs_info *fs_info)
|
|
|
|
{
|
|
|
|
struct btrfs_root *uuid_root = fs_info->uuid_root;
|
|
|
|
struct btrfs_trans_handle *trans;
|
|
|
|
struct btrfs_path path = {};
|
|
|
|
struct btrfs_key key = {};
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (!uuid_root)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
fs_info->uuid_root = NULL;
|
|
|
|
trans = btrfs_start_transaction(fs_info->tree_root, 0);
|
|
|
|
if (IS_ERR(trans))
|
|
|
|
return PTR_ERR(trans);
|
|
|
|
|
|
|
|
while (1) {
|
|
|
|
int nr;
|
|
|
|
|
|
|
|
ret = btrfs_search_slot(trans, uuid_root, &key, &path, -1, 1);
|
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
|
|
|
ASSERT(ret > 0);
|
|
|
|
ASSERT(path.slots[0] == 0);
|
|
|
|
|
|
|
|
nr = btrfs_header_nritems(path.nodes[0]);
|
|
|
|
if (nr == 0) {
|
|
|
|
btrfs_release_path(&path);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = btrfs_del_items(trans, uuid_root, &path, 0, nr);
|
|
|
|
btrfs_release_path(&path);
|
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
ret = btrfs_del_root(trans, fs_info->tree_root, &uuid_root->root_key);
|
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
|
|
|
list_del(&uuid_root->dirty_list);
|
|
|
|
ret = clean_tree_block(uuid_root->node);
|
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
|
|
|
ret = btrfs_free_tree_block(trans, uuid_root, uuid_root->node, 0, 1);
|
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
|
|
|
free_extent_buffer(uuid_root->node);
|
|
|
|
free_extent_buffer(uuid_root->commit_root);
|
|
|
|
kfree(uuid_root);
|
|
|
|
out:
|
|
|
|
if (ret < 0)
|
|
|
|
btrfs_abort_transaction(trans, ret);
|
|
|
|
else
|
|
|
|
ret = btrfs_commit_transaction(trans, fs_info->tree_root);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const char * const cmd_rescue_clear_uuid_tree_usage[] = {
|
|
|
|
"btrfs rescue clear-uuid-tree",
|
|
|
|
"Delete uuid tree so that kernel can rebuild it at mount time",
|
|
|
|
NULL,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int cmd_rescue_clear_uuid_tree(const struct cmd_struct *cmd,
|
|
|
|
int argc, char **argv)
|
|
|
|
{
|
|
|
|
struct btrfs_fs_info *fs_info;
|
|
|
|
struct open_ctree_flags ocf = {};
|
|
|
|
char *devname;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
clean_args_no_options(cmd, argc, argv);
|
|
|
|
if (check_argc_exact(argc, 2))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
devname = argv[optind];
|
|
|
|
ret = check_mounted(devname);
|
|
|
|
if (ret < 0) {
|
|
|
|
errno = -ret;
|
|
|
|
error("could not check mount status: %m");
|
|
|
|
goto out;
|
|
|
|
} else if (ret) {
|
|
|
|
error("%s is currently mounted", devname);
|
|
|
|
ret = -EBUSY;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
ocf.filename = devname;
|
|
|
|
ocf.flags = OPEN_CTREE_WRITES | OPEN_CTREE_PARTIAL;
|
|
|
|
fs_info = open_ctree_fs_info(&ocf);
|
|
|
|
if (!fs_info) {
|
|
|
|
error("could not open btrfs");
|
|
|
|
ret = -EIO;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = clear_uuid_tree(fs_info);
|
|
|
|
close_ctree(fs_info->tree_root);
|
|
|
|
out:
|
|
|
|
return !!ret;
|
|
|
|
}
|
|
|
|
static DEFINE_SIMPLE_COMMAND(rescue_clear_uuid_tree, "clear-uuid-tree");
|
|
|
|
|
2015-06-09 12:22:05 +00:00
|
|
|
static const char rescue_cmd_group_info[] =
|
|
|
|
"toolbox for specific rescue operations";
|
|
|
|
|
2018-03-07 02:07:03 +00:00
|
|
|
static const struct cmd_group rescue_cmd_group = {
|
2015-06-09 12:22:05 +00:00
|
|
|
rescue_cmd_group_usage, rescue_cmd_group_info, {
|
2018-03-07 02:07:03 +00:00
|
|
|
&cmd_struct_rescue_chunk_recover,
|
|
|
|
&cmd_struct_rescue_super_recover,
|
|
|
|
&cmd_struct_rescue_zero_log,
|
|
|
|
&cmd_struct_rescue_fix_device_size,
|
2020-10-29 23:17:36 +00:00
|
|
|
&cmd_struct_rescue_create_control_device,
|
2021-11-11 08:14:33 +00:00
|
|
|
&cmd_struct_rescue_clear_uuid_tree,
|
2018-03-07 02:07:03 +00:00
|
|
|
NULL
|
2013-09-17 15:21:20 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2018-03-07 02:07:03 +00:00
|
|
|
DEFINE_GROUP_COMMAND_TOKEN(rescue);
|