mirror of
https://github.com/kdave/btrfs-progs
synced 2024-12-09 08:00:13 +00:00
e4df433b8a
As btrfs is specific to Linux, %m can be used instead of strerror(errno) in format strings. This has some size reduction benefits for embedded systems. glibc, musl, and uclibc-ng all support %m as a modifier to printf. A quick glance at the BIONIC libc source indicates that it has support for %m as well. BSDs and Windows do not but I do believe them to be beyond the scope of btrfs-progs. Compiled sizes on Ubuntu 16.04: Before: 3916512 btrfs 233688 libbtrfs.so.0.1 4899 bcp 2367672 btrfs-convert 2208488 btrfs-corrupt-block 13302 btrfs-debugfs 2152160 btrfs-debug-tree 2136024 btrfs-find-root 2287592 btrfs-image 2144600 btrfs-map-logical 2130760 btrfs-select-super 2152608 btrfstune 2131760 btrfs-zero-log 2277752 mkfs.btrfs 9166 show-blocks After: 3908744 btrfs 233256 libbtrfs.so.0.1 4899 bcp 2366560 btrfs-convert 2207432 btrfs-corrupt-block 13302 btrfs-debugfs 2151104 btrfs-debug-tree 2134968 btrfs-find-root 2281864 btrfs-image 2143536 btrfs-map-logical 2129704 btrfs-select-super 2151552 btrfstune 2130696 btrfs-zero-log 2276272 mkfs.btrfs 9166 show-blocks Total savings: 23928 (24 kilo)bytes Signed-off-by: Rosen Penev <rosenp@gmail.com> Signed-off-by: David Sterba <dsterba@suse.com>
561 lines
15 KiB
C
561 lines
15 KiB
C
/*
|
|
* Copyright (C) 2012 STRATO. 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 <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
#include <fcntl.h>
|
|
#include <sys/ioctl.h>
|
|
#include <errno.h>
|
|
#include <sys/stat.h>
|
|
#include <time.h>
|
|
#include <assert.h>
|
|
#include <inttypes.h>
|
|
#include <sys/wait.h>
|
|
|
|
#include "kerncompat.h"
|
|
#include "ctree.h"
|
|
#include "ioctl.h"
|
|
#include "utils.h"
|
|
#include "volumes.h"
|
|
#include "disk-io.h"
|
|
|
|
#include "commands.h"
|
|
#include "help.h"
|
|
#include "mkfs/common.h"
|
|
|
|
static int print_replace_status(int fd, const char *path, int once);
|
|
static char *time2string(char *buf, size_t s, __u64 t);
|
|
static char *progress2string(char *buf, size_t s, int progress_1000);
|
|
|
|
|
|
static const char *replace_dev_result2string(__u64 result)
|
|
{
|
|
switch (result) {
|
|
case BTRFS_IOCTL_DEV_REPLACE_RESULT_NO_ERROR:
|
|
return "no error";
|
|
case BTRFS_IOCTL_DEV_REPLACE_RESULT_NOT_STARTED:
|
|
return "not started";
|
|
case BTRFS_IOCTL_DEV_REPLACE_RESULT_ALREADY_STARTED:
|
|
return "already started";
|
|
case BTRFS_IOCTL_DEV_REPLACE_RESULT_SCRUB_INPROGRESS:
|
|
return "scrub is in progress";
|
|
default:
|
|
return "<illegal result value>";
|
|
}
|
|
}
|
|
|
|
static const char * const replace_cmd_group_usage[] = {
|
|
"btrfs replace <command> [<args>]",
|
|
NULL
|
|
};
|
|
|
|
static int dev_replace_cancel_fd = -1;
|
|
static void dev_replace_sigint_handler(int signal)
|
|
{
|
|
int ret;
|
|
struct btrfs_ioctl_dev_replace_args args = {0};
|
|
|
|
args.cmd = BTRFS_IOCTL_DEV_REPLACE_CMD_CANCEL;
|
|
ret = ioctl(dev_replace_cancel_fd, BTRFS_IOC_DEV_REPLACE, &args);
|
|
if (ret < 0)
|
|
perror("Device replace cancel failed");
|
|
}
|
|
|
|
static int dev_replace_handle_sigint(int fd)
|
|
{
|
|
struct sigaction sa = {
|
|
.sa_handler = fd == -1 ? SIG_DFL : dev_replace_sigint_handler
|
|
};
|
|
|
|
dev_replace_cancel_fd = fd;
|
|
return sigaction(SIGINT, &sa, NULL);
|
|
}
|
|
|
|
static const char *const cmd_replace_start_usage[] = {
|
|
"btrfs replace start [-Bfr] <srcdev>|<devid> <targetdev> <mount_point>",
|
|
"Replace device of a btrfs filesystem.",
|
|
"On a live filesystem, duplicate the data to the target device which",
|
|
"is currently stored on the source device. If the source device is not",
|
|
"available anymore, or if the -r option is set, the data is built",
|
|
"only using the RAID redundancy mechanisms. After completion of the",
|
|
"operation, the source device is removed from the filesystem.",
|
|
"If the <srcdev> is a numerical value, it is assumed to be the device id",
|
|
"of the filesystem which is mounted at <mount_point>, otherwise it is",
|
|
"the path to the source device. If the source device is disconnected,",
|
|
"from the system, you have to use the <devid> parameter format.",
|
|
"The <targetdev> needs to be same size or larger than the <srcdev>.",
|
|
"",
|
|
"-r only read from <srcdev> if no other zero-defect mirror exists",
|
|
" (enable this if your drive has lots of read errors, the access",
|
|
" would be very slow)",
|
|
"-f force using and overwriting <targetdev> even if it looks like",
|
|
" containing a valid btrfs filesystem. A valid filesystem is",
|
|
" assumed if a btrfs superblock is found which contains a",
|
|
" correct checksum. Devices which are currently mounted are",
|
|
" never allowed to be used as the <targetdev>",
|
|
"-B do not background",
|
|
NULL
|
|
};
|
|
|
|
static int cmd_replace_start(int argc, char **argv)
|
|
{
|
|
struct btrfs_ioctl_dev_replace_args start_args = {0};
|
|
struct btrfs_ioctl_dev_replace_args status_args = {0};
|
|
int ret;
|
|
int i;
|
|
int c;
|
|
int fdmnt = -1;
|
|
int fddstdev = -1;
|
|
char *path;
|
|
char *srcdev;
|
|
char *dstdev = NULL;
|
|
int avoid_reading_from_srcdev = 0;
|
|
int force_using_targetdev = 0;
|
|
u64 dstdev_block_count;
|
|
int do_not_background = 0;
|
|
DIR *dirstream = NULL;
|
|
u64 srcdev_size;
|
|
u64 dstdev_size;
|
|
|
|
while ((c = getopt(argc, argv, "Brf")) != -1) {
|
|
switch (c) {
|
|
case 'B':
|
|
do_not_background = 1;
|
|
break;
|
|
case 'r':
|
|
avoid_reading_from_srcdev = 1;
|
|
break;
|
|
case 'f':
|
|
force_using_targetdev = 1;
|
|
break;
|
|
case '?':
|
|
default:
|
|
usage(cmd_replace_start_usage);
|
|
}
|
|
}
|
|
|
|
start_args.start.cont_reading_from_srcdev_mode =
|
|
avoid_reading_from_srcdev ?
|
|
BTRFS_IOCTL_DEV_REPLACE_CONT_READING_FROM_SRCDEV_MODE_AVOID :
|
|
BTRFS_IOCTL_DEV_REPLACE_CONT_READING_FROM_SRCDEV_MODE_ALWAYS;
|
|
if (check_argc_exact(argc - optind, 3))
|
|
usage(cmd_replace_start_usage);
|
|
path = argv[optind + 2];
|
|
|
|
fdmnt = open_path_or_dev_mnt(path, &dirstream, 1);
|
|
if (fdmnt < 0)
|
|
goto leave_with_error;
|
|
|
|
/* check for possible errors before backgrounding */
|
|
status_args.cmd = BTRFS_IOCTL_DEV_REPLACE_CMD_STATUS;
|
|
status_args.result = BTRFS_IOCTL_DEV_REPLACE_RESULT_NO_RESULT;
|
|
ret = ioctl(fdmnt, BTRFS_IOC_DEV_REPLACE, &status_args);
|
|
if (ret < 0) {
|
|
fprintf(stderr,
|
|
"ERROR: ioctl(DEV_REPLACE_STATUS) failed on \"%s\": %m",
|
|
path);
|
|
if (status_args.result != BTRFS_IOCTL_DEV_REPLACE_RESULT_NO_RESULT)
|
|
fprintf(stderr, ", %s\n",
|
|
replace_dev_result2string(status_args.result));
|
|
else
|
|
fprintf(stderr, "\n");
|
|
goto leave_with_error;
|
|
}
|
|
|
|
if (status_args.result != BTRFS_IOCTL_DEV_REPLACE_RESULT_NO_ERROR) {
|
|
error("ioctl(DEV_REPLACE_STATUS) on '%s' returns error: %s",
|
|
path, replace_dev_result2string(status_args.result));
|
|
goto leave_with_error;
|
|
}
|
|
|
|
if (status_args.status.replace_state ==
|
|
BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED) {
|
|
error("device replace on '%s' already started", path);
|
|
goto leave_with_error;
|
|
}
|
|
|
|
srcdev = argv[optind];
|
|
dstdev = canonicalize_path(argv[optind + 1]);
|
|
if (!dstdev) {
|
|
error("cannot canonicalize path '%s': %m",
|
|
argv[optind + 1]);
|
|
goto leave_with_error;
|
|
}
|
|
|
|
if (string_is_numerical(srcdev)) {
|
|
struct btrfs_ioctl_fs_info_args fi_args;
|
|
struct btrfs_ioctl_dev_info_args *di_args = NULL;
|
|
|
|
start_args.start.srcdevid = arg_strtou64(srcdev);
|
|
|
|
ret = get_fs_info(path, &fi_args, &di_args);
|
|
if (ret) {
|
|
error("failed to get device info: %s", strerror(-ret));
|
|
free(di_args);
|
|
goto leave_with_error;
|
|
}
|
|
if (!fi_args.num_devices) {
|
|
error("no devices found");
|
|
free(di_args);
|
|
goto leave_with_error;
|
|
}
|
|
|
|
for (i = 0; i < fi_args.num_devices; i++)
|
|
if (start_args.start.srcdevid == di_args[i].devid)
|
|
break;
|
|
srcdev_size = di_args[i].total_bytes;
|
|
free(di_args);
|
|
if (i == fi_args.num_devices) {
|
|
error("'%s' is not a valid devid for filesystem '%s'",
|
|
srcdev, path);
|
|
goto leave_with_error;
|
|
}
|
|
} else if (is_block_device(srcdev) > 0) {
|
|
strncpy((char *)start_args.start.srcdev_name, srcdev,
|
|
BTRFS_DEVICE_PATH_NAME_MAX);
|
|
start_args.start.srcdevid = 0;
|
|
srcdev_size = get_partition_size(srcdev);
|
|
} else {
|
|
error("source device must be a block device or a devid");
|
|
goto leave_with_error;
|
|
}
|
|
|
|
ret = test_dev_for_mkfs(dstdev, force_using_targetdev);
|
|
if (ret)
|
|
goto leave_with_error;
|
|
|
|
dstdev_size = get_partition_size(dstdev);
|
|
if (srcdev_size > dstdev_size) {
|
|
error("target device smaller than source device (required %llu bytes)",
|
|
srcdev_size);
|
|
goto leave_with_error;
|
|
}
|
|
|
|
fddstdev = open(dstdev, O_RDWR);
|
|
if (fddstdev < 0) {
|
|
error("unable to open %s: %m", dstdev);
|
|
goto leave_with_error;
|
|
}
|
|
strncpy((char *)start_args.start.tgtdev_name, dstdev,
|
|
BTRFS_DEVICE_PATH_NAME_MAX);
|
|
ret = btrfs_prepare_device(fddstdev, dstdev, &dstdev_block_count, 0,
|
|
PREP_DEVICE_ZERO_END | PREP_DEVICE_VERBOSE);
|
|
if (ret)
|
|
goto leave_with_error;
|
|
|
|
close(fddstdev);
|
|
fddstdev = -1;
|
|
free(dstdev);
|
|
dstdev = NULL;
|
|
|
|
dev_replace_handle_sigint(fdmnt);
|
|
if (!do_not_background) {
|
|
if (daemon(0, 0) < 0) {
|
|
error("backgrounding failed: %m");
|
|
goto leave_with_error;
|
|
}
|
|
}
|
|
|
|
start_args.cmd = BTRFS_IOCTL_DEV_REPLACE_CMD_START;
|
|
start_args.result = BTRFS_IOCTL_DEV_REPLACE_RESULT_NO_RESULT;
|
|
ret = ioctl(fdmnt, BTRFS_IOC_DEV_REPLACE, &start_args);
|
|
if (do_not_background) {
|
|
if (ret < 0) {
|
|
fprintf(stderr,
|
|
"ERROR: ioctl(DEV_REPLACE_START) failed on \"%s\": %m",
|
|
path);
|
|
if (start_args.result != BTRFS_IOCTL_DEV_REPLACE_RESULT_NO_RESULT)
|
|
fprintf(stderr, ", %s\n",
|
|
replace_dev_result2string(start_args.result));
|
|
else
|
|
fprintf(stderr, "\n");
|
|
|
|
if (errno == EOPNOTSUPP)
|
|
warning("device replace of RAID5/6 not supported with this kernel");
|
|
|
|
goto leave_with_error;
|
|
}
|
|
|
|
if (start_args.result !=
|
|
BTRFS_IOCTL_DEV_REPLACE_RESULT_NO_ERROR) {
|
|
error("ioctl(DEV_REPLACE_START) on '%s' returns error: %s",
|
|
path,
|
|
replace_dev_result2string(start_args.result));
|
|
goto leave_with_error;
|
|
}
|
|
}
|
|
close_file_or_dir(fdmnt, dirstream);
|
|
return 0;
|
|
|
|
leave_with_error:
|
|
if (dstdev)
|
|
free(dstdev);
|
|
if (fdmnt != -1)
|
|
close(fdmnt);
|
|
if (fddstdev != -1)
|
|
close(fddstdev);
|
|
return 1;
|
|
}
|
|
|
|
static const char *const cmd_replace_status_usage[] = {
|
|
"btrfs replace status [-1] <mount_point>",
|
|
"Print status and progress information of a running device replace",
|
|
"operation",
|
|
"",
|
|
"-1 print once instead of print continuously until the replace",
|
|
" operation finishes (or is canceled)",
|
|
NULL
|
|
};
|
|
|
|
static int cmd_replace_status(int argc, char **argv)
|
|
{
|
|
int fd;
|
|
int c;
|
|
char *path;
|
|
int once = 0;
|
|
int ret;
|
|
DIR *dirstream = NULL;
|
|
|
|
while ((c = getopt(argc, argv, "1")) != -1) {
|
|
switch (c) {
|
|
case '1':
|
|
once = 1;
|
|
break;
|
|
case '?':
|
|
default:
|
|
usage(cmd_replace_status_usage);
|
|
}
|
|
}
|
|
|
|
if (check_argc_exact(argc - optind, 1))
|
|
usage(cmd_replace_status_usage);
|
|
|
|
path = argv[optind];
|
|
fd = btrfs_open_dir(path, &dirstream, 1);
|
|
if (fd < 0)
|
|
return 1;
|
|
|
|
ret = print_replace_status(fd, path, once);
|
|
close_file_or_dir(fd, dirstream);
|
|
return !!ret;
|
|
}
|
|
|
|
static int print_replace_status(int fd, const char *path, int once)
|
|
{
|
|
struct btrfs_ioctl_dev_replace_args args = {0};
|
|
struct btrfs_ioctl_dev_replace_status_params *status;
|
|
int ret;
|
|
int prevent_loop = 0;
|
|
int skip_stats;
|
|
int num_chars;
|
|
char string1[80];
|
|
char string2[80];
|
|
char string3[80];
|
|
|
|
for (;;) {
|
|
args.cmd = BTRFS_IOCTL_DEV_REPLACE_CMD_STATUS;
|
|
args.result = BTRFS_IOCTL_DEV_REPLACE_RESULT_NO_RESULT;
|
|
ret = ioctl(fd, BTRFS_IOC_DEV_REPLACE, &args);
|
|
if (ret < 0) {
|
|
fprintf(stderr, "ERROR: ioctl(DEV_REPLACE_STATUS) failed on \"%s\": %m",
|
|
path);
|
|
if (args.result != BTRFS_IOCTL_DEV_REPLACE_RESULT_NO_RESULT)
|
|
fprintf(stderr, ", %s\n",
|
|
replace_dev_result2string(args.result));
|
|
else
|
|
fprintf(stderr, "\n");
|
|
return ret;
|
|
}
|
|
|
|
if (args.result != BTRFS_IOCTL_DEV_REPLACE_RESULT_NO_ERROR) {
|
|
error("ioctl(DEV_REPLACE_STATUS) on '%s' returns error: %s",
|
|
path,
|
|
replace_dev_result2string(args.result));
|
|
return -1;
|
|
}
|
|
|
|
status = &args.status;
|
|
|
|
skip_stats = 0;
|
|
num_chars = 0;
|
|
switch (status->replace_state) {
|
|
case BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED:
|
|
num_chars =
|
|
printf("%s done",
|
|
progress2string(string3,
|
|
sizeof(string3),
|
|
status->progress_1000));
|
|
break;
|
|
case BTRFS_IOCTL_DEV_REPLACE_STATE_FINISHED:
|
|
prevent_loop = 1;
|
|
printf("Started on %s, finished on %s",
|
|
time2string(string1, sizeof(string1),
|
|
status->time_started),
|
|
time2string(string2, sizeof(string2),
|
|
status->time_stopped));
|
|
break;
|
|
case BTRFS_IOCTL_DEV_REPLACE_STATE_CANCELED:
|
|
prevent_loop = 1;
|
|
printf("Started on %s, canceled on %s at %s",
|
|
time2string(string1, sizeof(string1),
|
|
status->time_started),
|
|
time2string(string2, sizeof(string2),
|
|
status->time_stopped),
|
|
progress2string(string3, sizeof(string3),
|
|
status->progress_1000));
|
|
break;
|
|
case BTRFS_IOCTL_DEV_REPLACE_STATE_SUSPENDED:
|
|
prevent_loop = 1;
|
|
printf("Started on %s, suspended on %s at %s",
|
|
time2string(string1, sizeof(string1),
|
|
status->time_started),
|
|
time2string(string2, sizeof(string2),
|
|
status->time_stopped),
|
|
progress2string(string3, sizeof(string3),
|
|
status->progress_1000));
|
|
break;
|
|
case BTRFS_IOCTL_DEV_REPLACE_STATE_NEVER_STARTED:
|
|
prevent_loop = 1;
|
|
skip_stats = 1;
|
|
printf("Never started");
|
|
break;
|
|
default:
|
|
error("unknown status from ioctl DEV_REPLACE_STATUS on '%s': %llu",
|
|
path, status->replace_state);
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (!skip_stats)
|
|
num_chars += printf(
|
|
", %llu write errs, %llu uncorr. read errs",
|
|
(unsigned long long)status->num_write_errors,
|
|
(unsigned long long)
|
|
status->num_uncorrectable_read_errors);
|
|
if (once || prevent_loop) {
|
|
printf("\n");
|
|
break;
|
|
}
|
|
|
|
fflush(stdout);
|
|
sleep(1);
|
|
while (num_chars > 0) {
|
|
putchar('\b');
|
|
num_chars--;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static char *
|
|
time2string(char *buf, size_t s, __u64 t)
|
|
{
|
|
struct tm t_tm;
|
|
time_t t_time_t;
|
|
|
|
t_time_t = (time_t)t;
|
|
assert((__u64)t_time_t == t);
|
|
localtime_r(&t_time_t, &t_tm);
|
|
strftime(buf, s, "%e.%b %T", &t_tm);
|
|
return buf;
|
|
}
|
|
|
|
static char *
|
|
progress2string(char *buf, size_t s, int progress_1000)
|
|
{
|
|
snprintf(buf, s, "%d.%01d%%", progress_1000 / 10, progress_1000 % 10);
|
|
assert(s > 0);
|
|
buf[s - 1] = '\0';
|
|
return buf;
|
|
}
|
|
|
|
static const char *const cmd_replace_cancel_usage[] = {
|
|
"btrfs replace cancel <mount_point>",
|
|
"Cancel a running device replace operation.",
|
|
NULL
|
|
};
|
|
|
|
static int cmd_replace_cancel(int argc, char **argv)
|
|
{
|
|
struct btrfs_ioctl_dev_replace_args args = {0};
|
|
int ret;
|
|
int c;
|
|
int fd;
|
|
char *path;
|
|
DIR *dirstream = NULL;
|
|
|
|
while ((c = getopt(argc, argv, "")) != -1) {
|
|
switch (c) {
|
|
case '?':
|
|
default:
|
|
usage(cmd_replace_cancel_usage);
|
|
}
|
|
}
|
|
|
|
if (check_argc_exact(argc - optind, 1))
|
|
usage(cmd_replace_cancel_usage);
|
|
|
|
path = argv[optind];
|
|
fd = btrfs_open_dir(path, &dirstream, 1);
|
|
if (fd < 0)
|
|
return 1;
|
|
|
|
args.cmd = BTRFS_IOCTL_DEV_REPLACE_CMD_CANCEL;
|
|
args.result = BTRFS_IOCTL_DEV_REPLACE_RESULT_NO_RESULT;
|
|
ret = ioctl(fd, BTRFS_IOC_DEV_REPLACE, &args);
|
|
close_file_or_dir(fd, dirstream);
|
|
if (ret < 0) {
|
|
fprintf(stderr, "ERROR: ioctl(DEV_REPLACE_CANCEL) failed on \"%s\": %m",
|
|
path);
|
|
if (args.result != BTRFS_IOCTL_DEV_REPLACE_RESULT_NO_RESULT)
|
|
fprintf(stderr, ", %s\n",
|
|
replace_dev_result2string(args.result));
|
|
else
|
|
fprintf(stderr, "\n");
|
|
return 1;
|
|
}
|
|
if (args.result == BTRFS_IOCTL_DEV_REPLACE_RESULT_NOT_STARTED) {
|
|
printf("INFO: ioctl(DEV_REPLACE_CANCEL)\"%s\": %s\n",
|
|
path, replace_dev_result2string(args.result));
|
|
return 2;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static const char replace_cmd_group_info[] =
|
|
"replace a device in the filesystem";
|
|
|
|
const struct cmd_group replace_cmd_group = {
|
|
replace_cmd_group_usage, replace_cmd_group_info, {
|
|
{ "start", cmd_replace_start, cmd_replace_start_usage, NULL,
|
|
0 },
|
|
{ "status", cmd_replace_status, cmd_replace_status_usage, NULL,
|
|
0 },
|
|
{ "cancel", cmd_replace_cancel, cmd_replace_cancel_usage, NULL,
|
|
0 },
|
|
NULL_CMD_STRUCT
|
|
}
|
|
};
|
|
|
|
int cmd_replace(int argc, char **argv)
|
|
{
|
|
return handle_command_group(&replace_cmd_group, argc, argv);
|
|
}
|