2 * Copyright (C) 2012 STRATO. All rights reserved.
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public
6 * License v2 as published by the Free Software Foundation.
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 * General Public License for more details.
13 * You should have received a copy of the GNU General Public
14 * License along with this program; if not, write to the
15 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
16 * Boston, MA 021110-1307, USA.
24 #include <sys/ioctl.h>
32 #include "kerncompat.h"
42 static int print_replace_status(int fd
, const char *path
, int once
);
43 static char *time2string(char *buf
, size_t s
, __u64 t
);
44 static char *progress2string(char *buf
, size_t s
, int progress_1000
);
47 static const char *replace_dev_result2string(__u64 result
)
50 case BTRFS_IOCTL_DEV_REPLACE_RESULT_NO_ERROR
:
52 case BTRFS_IOCTL_DEV_REPLACE_RESULT_NOT_STARTED
:
54 case BTRFS_IOCTL_DEV_REPLACE_RESULT_ALREADY_STARTED
:
55 return "already started";
57 return "<illegal result value>";
61 static const char * const replace_cmd_group_usage
[] = {
62 "btrfs replace <command> [<args>]",
66 static int is_numerical(const char *str
)
68 if (!(*str
>= '0' && *str
<= '9'))
70 while (*str
>= '0' && *str
<= '9')
77 static int dev_replace_cancel_fd
= -1;
78 static void dev_replace_sigint_handler(int signal
)
81 struct btrfs_ioctl_dev_replace_args args
= {0};
83 args
.cmd
= BTRFS_IOCTL_DEV_REPLACE_CMD_CANCEL
;
84 ret
= ioctl(dev_replace_cancel_fd
, BTRFS_IOC_DEV_REPLACE
, &args
);
86 perror("Device replace cancel failed");
89 static int dev_replace_handle_sigint(int fd
)
91 struct sigaction sa
= {
92 .sa_handler
= fd
== -1 ? SIG_DFL
: dev_replace_sigint_handler
95 dev_replace_cancel_fd
= fd
;
96 return sigaction(SIGINT
, &sa
, NULL
);
99 static const char *const cmd_start_replace_usage
[] = {
100 "btrfs replace start [-Bfr] <srcdev>|<devid> <targetdev> <mount_point>",
101 "Replace device of a btrfs filesystem.",
102 "On a live filesystem, duplicate the data to the target device which",
103 "is currently stored on the source device. If the source device is not",
104 "available anymore, or if the -r option is set, the data is built",
105 "only using the RAID redundancy mechanisms. After completion of the",
106 "operation, the source device is removed from the filesystem.",
107 "If the <srcdev> is a numerical value, it is assumed to be the device id",
108 "of the filesystem which is mounted at <mount_point>, otherwise it is",
109 "the path to the source device. If the source device is disconnected,",
110 "from the system, you have to use the <devid> parameter format.",
111 "The <targetdev> needs to be same size or larger than the <srcdev>.",
113 "-r only read from <srcdev> if no other zero-defect mirror exists",
114 " (enable this if your drive has lots of read errors, the access",
115 " would be very slow)",
116 "-f force using and overwriting <targetdev> even if it looks like",
117 " containing a valid btrfs filesystem. A valid filesystem is",
118 " assumed if a btrfs superblock is found which contains a",
119 " correct checksum. Devices which are currently mounted are",
120 " never allowed to be used as the <targetdev>",
121 "-B do not background",
125 static int cmd_start_replace(int argc
, char **argv
)
127 struct btrfs_ioctl_dev_replace_args start_args
= {0};
128 struct btrfs_ioctl_dev_replace_args status_args
= {0};
138 int avoid_reading_from_srcdev
= 0;
139 int force_using_targetdev
= 0;
141 u64 dstdev_block_count
;
142 int do_not_background
= 0;
144 DIR *dirstream
= NULL
;
145 char estr
[100]; /* check test_dev_for_mkfs() for error string size*/
147 while ((c
= getopt(argc
, argv
, "Brf")) != -1) {
150 do_not_background
= 1;
153 avoid_reading_from_srcdev
= 1;
156 force_using_targetdev
= 1;
160 usage(cmd_start_replace_usage
);
164 start_args
.start
.cont_reading_from_srcdev_mode
=
165 avoid_reading_from_srcdev
?
166 BTRFS_IOCTL_DEV_REPLACE_CONT_READING_FROM_SRCDEV_MODE_AVOID
:
167 BTRFS_IOCTL_DEV_REPLACE_CONT_READING_FROM_SRCDEV_MODE_ALWAYS
;
168 if (check_argc_exact(argc
- optind
, 3))
169 usage(cmd_start_replace_usage
);
170 path
= argv
[optind
+ 2];
172 fdmnt
= open_path_or_dev_mnt(path
, &dirstream
);
177 "ERROR: '%s' is not a mounted btrfs device\n",
180 fprintf(stderr
, "ERROR: can't access '%s': %s\n",
181 path
, strerror(errno
));
182 goto leave_with_error
;
185 /* check for possible errors before backgrounding */
186 status_args
.cmd
= BTRFS_IOCTL_DEV_REPLACE_CMD_STATUS
;
187 status_args
.result
= BTRFS_IOCTL_DEV_REPLACE_RESULT_NO_RESULT
;
188 ret
= ioctl(fdmnt
, BTRFS_IOC_DEV_REPLACE
, &status_args
);
191 "ERROR: ioctl(DEV_REPLACE_STATUS) failed on \"%s\": %s",
192 path
, strerror(errno
));
193 if (status_args
.result
!= BTRFS_IOCTL_DEV_REPLACE_RESULT_NO_RESULT
)
194 fprintf(stderr
, ", %s\n",
195 replace_dev_result2string(status_args
.result
));
197 fprintf(stderr
, "\n");
198 goto leave_with_error
;
201 if (status_args
.result
!= BTRFS_IOCTL_DEV_REPLACE_RESULT_NO_ERROR
) {
203 "ERROR: ioctl(DEV_REPLACE_STATUS) on \"%s\" returns error: %s\n",
204 path
, replace_dev_result2string(status_args
.result
));
205 goto leave_with_error
;
208 if (status_args
.status
.replace_state
==
209 BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED
) {
211 "ERROR: btrfs replace on \"%s\" already started!\n",
213 goto leave_with_error
;
216 srcdev
= argv
[optind
];
217 dstdev
= canonicalize_path(argv
[optind
+ 1]);
220 "ERROR: Could not canonicalize path '%s': %s\n",
221 argv
[optind
+ 1], strerror(errno
));
222 goto leave_with_error
;
225 if (is_numerical(srcdev
)) {
226 struct btrfs_ioctl_fs_info_args fi_args
;
227 struct btrfs_ioctl_dev_info_args
*di_args
= NULL
;
229 start_args
.start
.srcdevid
= arg_strtou64(srcdev
);
231 ret
= get_fs_info(path
, &fi_args
, &di_args
);
233 fprintf(stderr
, "ERROR: getting dev info for devstats failed: "
234 "%s\n", strerror(-ret
));
236 goto leave_with_error
;
238 if (!fi_args
.num_devices
) {
239 fprintf(stderr
, "ERROR: no devices found\n");
241 goto leave_with_error
;
244 for (i
= 0; i
< fi_args
.num_devices
; i
++)
245 if (start_args
.start
.srcdevid
== di_args
[i
].devid
)
248 if (i
== fi_args
.num_devices
) {
249 fprintf(stderr
, "Error: '%s' is not a valid devid for filesystem '%s'\n",
251 goto leave_with_error
;
254 fdsrcdev
= open(srcdev
, O_RDWR
);
256 fprintf(stderr
, "Error: Unable to open device '%s'\n",
258 fprintf(stderr
, "\tTry using the devid instead of the path\n");
259 goto leave_with_error
;
261 ret
= fstat(fdsrcdev
, &st
);
263 fprintf(stderr
, "Error: Unable to stat '%s'\n", srcdev
);
264 goto leave_with_error
;
266 if (!S_ISBLK(st
.st_mode
)) {
267 fprintf(stderr
, "Error: '%s' is not a block device\n",
269 goto leave_with_error
;
271 strncpy((char *)start_args
.start
.srcdev_name
, srcdev
,
272 BTRFS_DEVICE_PATH_NAME_MAX
);
275 start_args
.start
.srcdevid
= 0;
278 ret
= test_dev_for_mkfs(dstdev
, force_using_targetdev
, estr
);
280 fprintf(stderr
, "%s", estr
);
281 goto leave_with_error
;
283 fddstdev
= open(dstdev
, O_RDWR
);
285 fprintf(stderr
, "Unable to open %s\n", dstdev
);
286 goto leave_with_error
;
288 strncpy((char *)start_args
.start
.tgtdev_name
, dstdev
,
289 BTRFS_DEVICE_PATH_NAME_MAX
);
290 ret
= btrfs_prepare_device(fddstdev
, dstdev
, 1, &dstdev_block_count
, 0,
293 goto leave_with_error
;
300 dev_replace_handle_sigint(fdmnt
);
301 if (!do_not_background
) {
302 if (daemon(0, 0) < 0) {
303 fprintf(stderr
, "ERROR, backgrounding failed: %s\n",
305 goto leave_with_error
;
309 start_args
.cmd
= BTRFS_IOCTL_DEV_REPLACE_CMD_START
;
310 start_args
.result
= BTRFS_IOCTL_DEV_REPLACE_RESULT_NO_RESULT
;
311 ret
= ioctl(fdmnt
, BTRFS_IOC_DEV_REPLACE
, &start_args
);
312 if (do_not_background
) {
315 "ERROR: ioctl(DEV_REPLACE_START) failed on \"%s\": %s",
316 path
, strerror(errno
));
317 if (start_args
.result
!= BTRFS_IOCTL_DEV_REPLACE_RESULT_NO_RESULT
)
318 fprintf(stderr
, ", %s\n",
319 replace_dev_result2string(start_args
.result
));
321 fprintf(stderr
, "\n");
323 if (errno
== EOPNOTSUPP
)
325 "WARNING: dev_replace does not yet handle RAID5/6\n");
327 goto leave_with_error
;
330 if (start_args
.result
!=
331 BTRFS_IOCTL_DEV_REPLACE_RESULT_NO_ERROR
) {
333 "ERROR: ioctl(DEV_REPLACE_START) on \"%s\" returns error: %s\n",
335 replace_dev_result2string(start_args
.result
));
336 goto leave_with_error
;
339 close_file_or_dir(fdmnt
, dirstream
);
354 static const char *const cmd_status_replace_usage
[] = {
355 "btrfs replace status [-1] <mount_point>",
356 "Print status and progress information of a running device replace",
359 "-1 print once instead of print continuously until the replace",
360 " operation finishes (or is canceled)",
364 static int cmd_status_replace(int argc
, char **argv
)
372 DIR *dirstream
= NULL
;
374 while ((c
= getopt(argc
, argv
, "1")) != -1) {
381 usage(cmd_status_replace_usage
);
385 if (check_argc_exact(argc
- optind
, 1))
386 usage(cmd_status_replace_usage
);
389 fd
= open_file_or_dir(path
, &dirstream
);
392 fprintf(stderr
, "ERROR: can't access \"%s\": %s\n",
397 ret
= print_replace_status(fd
, path
, once
);
398 close_file_or_dir(fd
, dirstream
);
402 static int print_replace_status(int fd
, const char *path
, int once
)
404 struct btrfs_ioctl_dev_replace_args args
= {0};
405 struct btrfs_ioctl_dev_replace_status_params
*status
;
407 int prevent_loop
= 0;
415 args
.cmd
= BTRFS_IOCTL_DEV_REPLACE_CMD_STATUS
;
416 args
.result
= BTRFS_IOCTL_DEV_REPLACE_RESULT_NO_RESULT
;
417 ret
= ioctl(fd
, BTRFS_IOC_DEV_REPLACE
, &args
);
419 fprintf(stderr
, "ERROR: ioctl(DEV_REPLACE_STATUS) failed on \"%s\": %s",
420 path
, strerror(errno
));
421 if (args
.result
!= BTRFS_IOCTL_DEV_REPLACE_RESULT_NO_RESULT
)
422 fprintf(stderr
, ", %s\n",
423 replace_dev_result2string(args
.result
));
425 fprintf(stderr
, "\n");
429 status
= &args
.status
;
430 if (args
.result
!= BTRFS_IOCTL_DEV_REPLACE_RESULT_NO_ERROR
) {
431 fprintf(stderr
, "ERROR: ioctl(DEV_REPLACE_STATUS) on \"%s\" returns error: %s\n",
433 replace_dev_result2string(args
.result
));
439 switch (status
->replace_state
) {
440 case BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED
:
443 progress2string(string3
,
445 status
->progress_1000
));
447 case BTRFS_IOCTL_DEV_REPLACE_STATE_FINISHED
:
449 printf("Started on %s, finished on %s",
450 time2string(string1
, sizeof(string1
),
451 status
->time_started
),
452 time2string(string2
, sizeof(string2
),
453 status
->time_stopped
));
455 case BTRFS_IOCTL_DEV_REPLACE_STATE_CANCELED
:
457 printf("Started on %s, canceled on %s at %s",
458 time2string(string1
, sizeof(string1
),
459 status
->time_started
),
460 time2string(string2
, sizeof(string2
),
461 status
->time_stopped
),
462 progress2string(string3
, sizeof(string3
),
463 status
->progress_1000
));
465 case BTRFS_IOCTL_DEV_REPLACE_STATE_SUSPENDED
:
467 printf("Started on %s, suspended on %s at %s",
468 time2string(string1
, sizeof(string1
),
469 status
->time_started
),
470 time2string(string2
, sizeof(string2
),
471 status
->time_stopped
),
472 progress2string(string3
, sizeof(string3
),
473 status
->progress_1000
));
475 case BTRFS_IOCTL_DEV_REPLACE_STATE_NEVER_STARTED
:
478 printf("Never started");
483 "Unknown btrfs dev replace status:%llu",
484 status
->replace_state
);
491 ", %llu write errs, %llu uncorr. read errs",
492 (unsigned long long)status
->num_write_errors
,
494 status
->num_uncorrectable_read_errors
);
495 if (once
|| prevent_loop
|| ret
) {
502 while (num_chars
> 0) {
512 time2string(char *buf
, size_t s
, __u64 t
)
517 t_time_t
= (time_t)t
;
518 assert((__u64
)t_time_t
== t
);
519 localtime_r(&t_time_t
, &t_tm
);
520 strftime(buf
, s
, "%e.%b %T", &t_tm
);
525 progress2string(char *buf
, size_t s
, int progress_1000
)
527 snprintf(buf
, s
, "%d.%01d%%", progress_1000
/ 10, progress_1000
% 10);
533 static const char *const cmd_cancel_replace_usage
[] = {
534 "btrfs replace cancel <mount_point>",
535 "Cancel a running device replace operation.",
539 static int cmd_cancel_replace(int argc
, char **argv
)
541 struct btrfs_ioctl_dev_replace_args args
= {0};
547 DIR *dirstream
= NULL
;
549 while ((c
= getopt(argc
, argv
, "")) != -1) {
553 usage(cmd_cancel_replace_usage
);
557 if (check_argc_exact(argc
- optind
, 1))
558 usage(cmd_cancel_replace_usage
);
561 fd
= open_file_or_dir(path
, &dirstream
);
563 fprintf(stderr
, "ERROR: can't access \"%s\": %s\n",
564 path
, strerror(errno
));
568 args
.cmd
= BTRFS_IOCTL_DEV_REPLACE_CMD_CANCEL
;
569 args
.result
= BTRFS_IOCTL_DEV_REPLACE_RESULT_NO_RESULT
;
570 ret
= ioctl(fd
, BTRFS_IOC_DEV_REPLACE
, &args
);
572 close_file_or_dir(fd
, dirstream
);
574 fprintf(stderr
, "ERROR: ioctl(DEV_REPLACE_CANCEL) failed on \"%s\": %s",
576 if (args
.result
!= BTRFS_IOCTL_DEV_REPLACE_RESULT_NO_RESULT
)
577 fprintf(stderr
, ", %s\n",
578 replace_dev_result2string(args
.result
));
580 fprintf(stderr
, "\n");
583 if (args
.result
== BTRFS_IOCTL_DEV_REPLACE_RESULT_NOT_STARTED
) {
584 printf("INFO: ioctl(DEV_REPLACE_CANCEL)\"%s\": %s\n",
585 path
, replace_dev_result2string(args
.result
));
591 const struct cmd_group replace_cmd_group
= {
592 replace_cmd_group_usage
, NULL
, {
593 { "start", cmd_start_replace
, cmd_start_replace_usage
, NULL
,
595 { "status", cmd_status_replace
, cmd_status_replace_usage
, NULL
,
597 { "cancel", cmd_cancel_replace
, cmd_cancel_replace_usage
, NULL
,
603 int cmd_replace(int argc
, char **argv
)
605 return handle_command_group(&replace_cmd_group
, argc
, argv
);