2 * This program is free software; you can redistribute it and/or
3 * modify it under the terms of the GNU General Public
4 * License v2 as published by the Free Software Foundation.
6 * This program is distributed in the hope that it will be useful,
7 * but WITHOUT ANY WARRANTY; without even the implied warranty of
8 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
9 * General Public License for more details.
11 * You should have received a copy of the GNU General Public
12 * License along with this program; if not, write to the
13 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
14 * Boston, MA 021110-1307, USA.
22 #include <sys/ioctl.h>
27 #include "kerncompat.h"
32 #include "cmds-fi-usage.h"
36 static const char * const device_cmd_group_usage
[] = {
37 "btrfs device <command> [<args>]",
41 static const char * const cmd_device_add_usage
[] = {
42 "btrfs device add [options] <device> [<device>...] <path>",
43 "Add a device to a filesystem",
44 "-K|--nodiscard do not perform whole device TRIM",
45 "-f|--force force overwrite existing filesystem on the disk",
49 static int cmd_device_add(int argc
, char **argv
)
52 int i
, fdmnt
, ret
= 0;
53 DIR *dirstream
= NULL
;
60 static const struct option long_options
[] = {
61 { "nodiscard", optional_argument
, NULL
, 'K'},
62 { "force", no_argument
, NULL
, 'f'},
66 c
= getopt_long(argc
, argv
, "Kf", long_options
, NULL
);
77 usage(cmd_device_add_usage
);
81 if (check_argc_min(argc
- optind
, 2))
82 usage(cmd_device_add_usage
);
85 mntpnt
= argv
[last_dev
];
87 fdmnt
= btrfs_open_dir(mntpnt
, &dirstream
, 1);
91 for (i
= optind
; i
< last_dev
; i
++){
92 struct btrfs_ioctl_vol_args ioctl_args
;
94 u64 dev_block_count
= 0;
97 res
= test_dev_for_mkfs(argv
[i
], force
);
103 devfd
= open(argv
[i
], O_RDWR
);
105 error("unable to open device '%s'", argv
[i
]);
110 res
= btrfs_prepare_device(devfd
, argv
[i
], 1, &dev_block_count
,
118 path
= canonicalize_path(argv
[i
]);
120 error("could not canonicalize pathname '%s': %s",
121 argv
[i
], strerror(errno
));
126 memset(&ioctl_args
, 0, sizeof(ioctl_args
));
127 strncpy_null(ioctl_args
.name
, path
);
128 res
= ioctl(fdmnt
, BTRFS_IOC_ADD_DEV
, &ioctl_args
);
130 error("error adding device '%s': %s",
131 path
, strerror(errno
));
138 close_file_or_dir(fdmnt
, dirstream
);
142 static int _cmd_device_remove(int argc
, char **argv
,
143 const char * const *usagestr
)
146 int i
, fdmnt
, ret
= 0;
147 DIR *dirstream
= NULL
;
149 clean_args_no_options(argc
, argv
, usagestr
);
151 if (check_argc_min(argc
- optind
, 2))
154 mntpnt
= argv
[argc
- 1];
156 fdmnt
= btrfs_open_dir(mntpnt
, &dirstream
, 1);
160 for(i
= optind
; i
< argc
- 1; i
++) {
161 struct btrfs_ioctl_vol_args arg
;
162 struct btrfs_ioctl_vol_args_v2 argv2
= {0};
166 if (string_is_numerical(argv
[i
])) {
167 argv2
.devid
= arg_strtou64(argv
[i
]);
168 argv2
.flags
= BTRFS_DEVICE_SPEC_BY_ID
;
170 } else if (is_block_device(argv
[i
]) == 1 ||
171 strcmp(argv
[i
], "missing") == 0) {
172 strncpy_null(argv2
.name
, argv
[i
]);
174 error("not a block device: %s", argv
[i
]);
180 * Positive values are from BTRFS_ERROR_DEV_*,
181 * otherwise it's a generic error, one of errnos
183 res
= ioctl(fdmnt
, BTRFS_IOC_RM_DEV_V2
, &argv2
);
186 * If BTRFS_IOC_RM_DEV_V2 is not supported we get ENOTTY and if
187 * argv2.flags includes a flag which kernel doesn't understand then
188 * we shall get EOPNOTSUPP
190 if (res
< 0 && (errno
== ENOTTY
|| errno
== EOPNOTSUPP
)) {
192 error("device delete by id failed: %s",
197 memset(&arg
, 0, sizeof(arg
));
198 strncpy_null(arg
.name
, argv
[i
]);
199 res
= ioctl(fdmnt
, BTRFS_IOC_RM_DEV
, &arg
);
206 msg
= btrfs_err_str(res
);
208 msg
= strerror(errno
);
210 error("error removing devid %llu: %s",
211 (unsigned long long)argv2
.devid
, msg
);
213 error("error removing device '%s': %s",
220 close_file_or_dir(fdmnt
, dirstream
);
224 static const char * const cmd_device_remove_usage
[] = {
225 "btrfs device remove <device>|<devid> [<device>|<devid>...] <path>",
226 "Remove a device from a filesystem",
230 static int cmd_device_remove(int argc
, char **argv
)
232 return _cmd_device_remove(argc
, argv
, cmd_device_remove_usage
);
235 static const char * const cmd_device_delete_usage
[] = {
236 "btrfs device delete <device>|<devid> [<device>|<devid>...] <path>",
237 "Remove a device from a filesystem",
241 static int cmd_device_delete(int argc
, char **argv
)
243 return _cmd_device_remove(argc
, argv
, cmd_device_delete_usage
);
246 static const char * const cmd_device_scan_usage
[] = {
247 "btrfs device scan [(-d|--all-devices)|<device> [<device>...]]",
248 "Scan devices for a btrfs filesystem",
249 " -d|--all-devices (deprecated)",
253 static int cmd_device_scan(int argc
, char **argv
)
263 static const struct option long_options
[] = {
264 { "all-devices", no_argument
, NULL
, 'd'},
268 c
= getopt_long(argc
, argv
, "d", long_options
, NULL
);
276 usage(cmd_device_scan_usage
);
281 if (all
&& check_argc_max(argc
- optind
, 1))
282 usage(cmd_device_scan_usage
);
284 if (all
|| argc
- optind
== 0) {
285 printf("Scanning for Btrfs filesystems\n");
286 ret
= btrfs_scan_lblkid();
287 error_on(ret
, "error %d while scanning", ret
);
288 ret
= btrfs_register_all_devices();
289 error_on(ret
, "there are %d errors while registering devices", ret
);
293 for( i
= devstart
; i
< argc
; i
++ ){
296 if (is_block_device(argv
[i
]) != 1) {
297 error("not a block device: %s", argv
[i
]);
301 path
= canonicalize_path(argv
[i
]);
303 error("could not canonicalize path '%s': %s",
304 argv
[i
], strerror(errno
));
308 printf("Scanning for Btrfs filesystems in '%s'\n", path
);
309 if (btrfs_register_one_device(path
) != 0) {
321 static const char * const cmd_device_ready_usage
[] = {
322 "btrfs device ready <device>",
323 "Check device to see if it has all of its devices in cache for mounting",
327 static int cmd_device_ready(int argc
, char **argv
)
329 struct btrfs_ioctl_vol_args args
;
334 clean_args_no_options(argc
, argv
, cmd_device_ready_usage
);
336 if (check_argc_exact(argc
- optind
, 1))
337 usage(cmd_device_ready_usage
);
339 fd
= open("/dev/btrfs-control", O_RDWR
);
341 perror("failed to open /dev/btrfs-control");
345 path
= canonicalize_path(argv
[optind
]);
347 error("could not canonicalize pathname '%s': %s",
348 argv
[optind
], strerror(errno
));
353 if (is_block_device(path
) != 1) {
354 error("not a block device: %s", path
);
359 memset(&args
, 0, sizeof(args
));
360 strncpy_null(args
.name
, path
);
361 ret
= ioctl(fd
, BTRFS_IOC_DEVICES_READY
, &args
);
363 error("unable to determine if device '%s' is ready for mount: %s",
364 path
, strerror(errno
));
374 static const char * const cmd_device_stats_usage
[] = {
375 "btrfs device stats [-z] <path>|<device>",
376 "Show current device IO stats.",
378 "-z show current stats and reset values to zero",
382 static int cmd_device_stats(int argc
, char **argv
)
385 struct btrfs_ioctl_fs_info_args fi_args
;
386 struct btrfs_ioctl_dev_info_args
*di_args
= NULL
;
393 DIR *dirstream
= NULL
;
396 while ((c
= getopt(argc
, argv
, "z")) != -1) {
399 flags
= BTRFS_DEV_STATS_RESET
;
403 usage(cmd_device_stats_usage
);
407 if (check_argc_exact(argc
- optind
, 1))
408 usage(cmd_device_stats_usage
);
410 dev_path
= argv
[optind
];
412 fdmnt
= open_path_or_dev_mnt(dev_path
, &dirstream
, 1);
416 ret
= get_fs_info(dev_path
, &fi_args
, &di_args
);
418 error("getting dev info for devstats failed: %s",
423 if (!fi_args
.num_devices
) {
424 error("no devices found");
429 for (i
= 0; i
< fi_args
.num_devices
; i
++) {
430 struct btrfs_ioctl_get_dev_stats args
= {0};
431 __u8 path
[BTRFS_DEVICE_PATH_NAME_MAX
+ 1];
433 strncpy((char *)path
, (char *)di_args
[i
].path
,
434 BTRFS_DEVICE_PATH_NAME_MAX
);
435 path
[BTRFS_DEVICE_PATH_NAME_MAX
] = '\0';
437 args
.devid
= di_args
[i
].devid
;
438 args
.nr_items
= BTRFS_DEV_STAT_VALUES_MAX
;
441 if (ioctl(fdmnt
, BTRFS_IOC_GET_DEV_STATS
, &args
) < 0) {
442 error("DEV_STATS ioctl failed on %s: %s",
443 path
, strerror(errno
));
446 char *canonical_path
;
448 canonical_path
= canonicalize_path((char *)path
);
450 /* No path when device is missing. */
451 if (!canonical_path
) {
452 canonical_path
= malloc(32);
453 if (!canonical_path
) {
454 error("not enough memory for path buffer");
457 snprintf(canonical_path
, 32,
458 "devid:%llu", args
.devid
);
461 if (args
.nr_items
>= BTRFS_DEV_STAT_WRITE_ERRS
+ 1)
462 printf("[%s].write_io_errs %llu\n",
464 (unsigned long long) args
.values
[
465 BTRFS_DEV_STAT_WRITE_ERRS
]);
466 if (args
.nr_items
>= BTRFS_DEV_STAT_READ_ERRS
+ 1)
467 printf("[%s].read_io_errs %llu\n",
469 (unsigned long long) args
.values
[
470 BTRFS_DEV_STAT_READ_ERRS
]);
471 if (args
.nr_items
>= BTRFS_DEV_STAT_FLUSH_ERRS
+ 1)
472 printf("[%s].flush_io_errs %llu\n",
474 (unsigned long long) args
.values
[
475 BTRFS_DEV_STAT_FLUSH_ERRS
]);
476 if (args
.nr_items
>= BTRFS_DEV_STAT_CORRUPTION_ERRS
+ 1)
477 printf("[%s].corruption_errs %llu\n",
479 (unsigned long long) args
.values
[
480 BTRFS_DEV_STAT_CORRUPTION_ERRS
]);
481 if (args
.nr_items
>= BTRFS_DEV_STAT_GENERATION_ERRS
+ 1)
482 printf("[%s].generation_errs %llu\n",
484 (unsigned long long) args
.values
[
485 BTRFS_DEV_STAT_GENERATION_ERRS
]);
487 free(canonical_path
);
493 close_file_or_dir(fdmnt
, dirstream
);
498 static const char * const cmd_device_usage_usage
[] = {
499 "btrfs device usage [options] <path> [<path>..]",
500 "Show detailed information about internal allocations in devices.",
501 HELPINFO_UNITS_SHORT_LONG
,
505 static int _cmd_device_usage(int fd
, char *path
, unsigned unit_mode
)
509 struct chunk_info
*chunkinfo
= NULL
;
510 struct device_info
*devinfo
= NULL
;
514 ret
= load_chunk_and_device_info(fd
, &chunkinfo
, &chunkcount
, &devinfo
,
519 for (i
= 0; i
< devcount
; i
++) {
520 printf("%s, ID: %llu\n", devinfo
[i
].path
, devinfo
[i
].devid
);
521 print_device_sizes(fd
, &devinfo
[i
], unit_mode
);
522 print_device_chunks(fd
, &devinfo
[i
], chunkinfo
, chunkcount
,
534 static int cmd_device_usage(int argc
, char **argv
)
540 unit_mode
= get_unit_mode_from_arg(&argc
, argv
, 1);
542 clean_args_no_options(argc
, argv
, cmd_device_usage_usage
);
544 if (check_argc_min(argc
- optind
, 1))
545 usage(cmd_device_usage_usage
);
547 for (i
= optind
; i
< argc
; i
++) {
549 DIR *dirstream
= NULL
;
554 fd
= btrfs_open_dir(argv
[i
], &dirstream
, 1);
560 ret
= _cmd_device_usage(fd
, argv
[i
], unit_mode
);
561 close_file_or_dir(fd
, dirstream
);
570 static const char device_cmd_group_info
[] =
571 "manage and query devices in the filesystem";
573 const struct cmd_group device_cmd_group
= {
574 device_cmd_group_usage
, device_cmd_group_info
, {
575 { "add", cmd_device_add
, cmd_device_add_usage
, NULL
, 0 },
576 { "delete", cmd_device_delete
, cmd_device_delete_usage
, NULL
,
578 { "remove", cmd_device_remove
, cmd_device_remove_usage
, NULL
, 0 },
579 { "scan", cmd_device_scan
, cmd_device_scan_usage
, NULL
, 0 },
580 { "ready", cmd_device_ready
, cmd_device_ready_usage
, NULL
, 0 },
581 { "stats", cmd_device_stats
, cmd_device_stats_usage
, NULL
, 0 },
582 { "usage", cmd_device_usage
,
583 cmd_device_usage_usage
, NULL
, 0 },
588 int cmd_device(int argc
, char **argv
)
590 return handle_command_group(&device_cmd_group
, argc
, argv
);