?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Btrfs progs v4.17.1
[btrfs-progs-unstable/devel.git] / cmds-filesystem.c
blob06c8311bdfe33a50b1720a557b9496fac5d9379d
1 /*
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.
5 *
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.
10 *
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.
15 */
16
17 #include <stdio.h>
18 #include <stdlib.h>
19 #include <string.h>
20 #include <unistd.h>
21 #include <sys/ioctl.h>
22 #include <errno.h>
23 #include <uuid/uuid.h>
24 #include <ctype.h>
25 #include <fcntl.h>
26 #include <ftw.h>
27 #include <mntent.h>
28 #include <linux/limits.h>
29 #include <getopt.h>
30
31 #include <btrfsutil.h>
32
33 #include "kerncompat.h"
34 #include "ctree.h"
35 #include "utils.h"
36 #include "volumes.h"
37 #include "commands.h"
38 #include "cmds-fi-usage.h"
39 #include "list_sort.h"
40 #include "disk-io.h"
41 #include "help.h"
42
43 /*
44 * for btrfs fi show, we maintain a hash of fsids we've already printed.
45 * This way we don't print dups if a given FS is mounted more than once.
46 */
47 static struct seen_fsid *seen_fsid_hash[SEEN_FSID_HASH_SIZE] = {NULL,};
48
49 static const char * const filesystem_cmd_group_usage[] = {
50 "btrfs filesystem [<group>] <command> [<args>]",
51 NULL
52 };
53
54 static const char * const cmd_filesystem_df_usage[] = {
55 "btrfs filesystem df [options] <path>",
56 "Show space usage information for a mount point",
57 HELPINFO_UNITS_SHORT_LONG,
58 NULL
59 };
60
61 static int get_df(int fd, struct btrfs_ioctl_space_args **sargs_ret)
62 {
63 u64 count = 0;
64 int ret;
65 struct btrfs_ioctl_space_args *sargs;
66
67 sargs = malloc(sizeof(struct btrfs_ioctl_space_args));
68 if (!sargs)
69 return -ENOMEM;
70
71 sargs->space_slots = 0;
72 sargs->total_spaces = 0;
73
74 ret = ioctl(fd, BTRFS_IOC_SPACE_INFO, sargs);
75 if (ret < 0) {
76 error("cannot get space info: %m");
77 free(sargs);
78 return -errno;
79 }
80 /* This really should never happen */
81 if (!sargs->total_spaces) {
82 free(sargs);
83 return -ENOENT;
84 }
85 count = sargs->total_spaces;
86 free(sargs);
87
88 sargs = malloc(sizeof(struct btrfs_ioctl_space_args) +
89 (count * sizeof(struct btrfs_ioctl_space_info)));
90 if (!sargs)
91 return -ENOMEM;
92
93 sargs->space_slots = count;
94 sargs->total_spaces = 0;
95 ret = ioctl(fd, BTRFS_IOC_SPACE_INFO, sargs);
96 if (ret < 0) {
97 error("cannot get space info with %llu slots: %m",
98 count);
99 free(sargs);
100 return -errno;
101 }
102 *sargs_ret = sargs;
103 return 0;
104 }
105
106 static void print_df(struct btrfs_ioctl_space_args *sargs, unsigned unit_mode)
107 {
108 u64 i;
109 struct btrfs_ioctl_space_info *sp = sargs->spaces;
110
111 for (i = 0; i < sargs->total_spaces; i++, sp++) {
112 printf("%s, %s: total=%s, used=%s\n",
113 btrfs_group_type_str(sp->flags),
114 btrfs_group_profile_str(sp->flags),
115 pretty_size_mode(sp->total_bytes, unit_mode),
116 pretty_size_mode(sp->used_bytes, unit_mode));
117 }
118 }
119
120 static int cmd_filesystem_df(int argc, char **argv)
121 {
122 struct btrfs_ioctl_space_args *sargs = NULL;
123 int ret;
124 int fd;
125 char *path;
126 DIR *dirstream = NULL;
127 unsigned unit_mode;
128
129 unit_mode = get_unit_mode_from_arg(&argc, argv, 1);
130
131 clean_args_no_options(argc, argv, cmd_filesystem_df_usage);
132
133 if (check_argc_exact(argc - optind, 1))
134 usage(cmd_filesystem_df_usage);
135
136 path = argv[optind];
137
138 fd = btrfs_open_dir(path, &dirstream, 1);
139 if (fd < 0)
140 return 1;
141
142 ret = get_df(fd, &sargs);
143
144 if (ret == 0) {
145 print_df(sargs, unit_mode);
146 free(sargs);
147 } else {
148 error("get_df failed %s", strerror(-ret));
149 }
150
151 close_file_or_dir(fd, dirstream);
152 return !!ret;
153 }
154
155 static int match_search_item_kernel(u8 *fsid, char *mnt, char *label,
156 char *search)
157 {
158 char uuidbuf[BTRFS_UUID_UNPARSED_SIZE];
159 int search_len = strlen(search);
160
161 search_len = min(search_len, BTRFS_UUID_UNPARSED_SIZE);
162 uuid_unparse(fsid, uuidbuf);
163 if (!strncmp(uuidbuf, search, search_len))
164 return 1;
165
166 if (*label && strcmp(label, search) == 0)
167 return 1;
168
169 if (strcmp(mnt, search) == 0)
170 return 1;
171
172 return 0;
173 }
174
175 static int uuid_search(struct btrfs_fs_devices *fs_devices, const char *search)
176 {
177 char uuidbuf[BTRFS_UUID_UNPARSED_SIZE];
178 struct btrfs_device *device;
179 int search_len = strlen(search);
180
181 search_len = min(search_len, BTRFS_UUID_UNPARSED_SIZE);
182 uuid_unparse(fs_devices->fsid, uuidbuf);
183 if (!strncmp(uuidbuf, search, search_len))
184 return 1;
185
186 list_for_each_entry(device, &fs_devices->devices, dev_list) {
187 if ((device->label && strcmp(device->label, search) == 0) ||
188 strcmp(device->name, search) == 0)
189 return 1;
190 }
191 return 0;
192 }
193
194 /*
195 * Sort devices by devid, ascending
196 */
197 static int cmp_device_id(void *priv, struct list_head *a,
198 struct list_head *b)
199 {
200 const struct btrfs_device *da = list_entry(a, struct btrfs_device,
201 dev_list);
202 const struct btrfs_device *db = list_entry(b, struct btrfs_device,
203 dev_list);
204
205 return da->devid < db->devid ? -1 :
206 da->devid > db->devid ? 1 : 0;
207 }
208
209 static void splice_device_list(struct list_head *seed_devices,
210 struct list_head *all_devices)
211 {
212 struct btrfs_device *in_all, *next_all;
213 struct btrfs_device *in_seed, *next_seed;
214
215 list_for_each_entry_safe(in_all, next_all, all_devices, dev_list) {
216 list_for_each_entry_safe(in_seed, next_seed, seed_devices,
217 dev_list) {
218 if (in_all->devid == in_seed->devid) {
219 /*
220 * When do dev replace in a sprout fs
221 * to a dev in its seed fs, the replacing
222 * dev will reside in the sprout fs and
223 * the replaced dev will still exist
224 * in the seed fs.
225 * So pick the latest one when showing
226 * the sprout fs.
227 */
228 if (in_all->generation
229 < in_seed->generation) {
230 list_del(&in_all->dev_list);
231 free(in_all);
232 } else if (in_all->generation
233 > in_seed->generation) {
234 list_del(&in_seed->dev_list);
235 free(in_seed);
236 }
237 break;
238 }
239 }
240 }
241
242 list_splice(seed_devices, all_devices);
243 }
244
245 static void print_devices(struct btrfs_fs_devices *fs_devices,
246 u64 *devs_found, unsigned unit_mode)
247 {
248 struct btrfs_device *device;
249 struct btrfs_fs_devices *cur_fs;
250 struct list_head *all_devices;
251
252 all_devices = &fs_devices->devices;
253 cur_fs = fs_devices->seed;
254 /* add all devices of seed fs to the fs to be printed */
255 while (cur_fs) {
256 splice_device_list(&cur_fs->devices, all_devices);
257 cur_fs = cur_fs->seed;
258 }
259
260 list_sort(NULL, all_devices, cmp_device_id);
261 list_for_each_entry(device, all_devices, dev_list) {
262 printf("\tdevid %4llu size %s used %s path %s\n",
263 (unsigned long long)device->devid,
264 pretty_size_mode(device->total_bytes, unit_mode),
265 pretty_size_mode(device->bytes_used, unit_mode),
266 device->name);
267
268 (*devs_found)++;
269 }
270 }
271
272 static void print_one_uuid(struct btrfs_fs_devices *fs_devices,
273 unsigned unit_mode)
274 {
275 char uuidbuf[BTRFS_UUID_UNPARSED_SIZE];
276 struct btrfs_device *device;
277 u64 devs_found = 0;
278 u64 total;
279
280 if (add_seen_fsid(fs_devices->fsid, seen_fsid_hash, -1, NULL))
281 return;
282
283 uuid_unparse(fs_devices->fsid, uuidbuf);
284 device = list_entry(fs_devices->devices.next, struct btrfs_device,
285 dev_list);
286 if (device->label && device->label[0])
287 printf("Label: '%s' ", device->label);
288 else
289 printf("Label: none ");
290
291 total = device->total_devs;
292 printf(" uuid: %s\n\tTotal devices %llu FS bytes used %s\n", uuidbuf,
293 (unsigned long long)total,
294 pretty_size_mode(device->super_bytes_used, unit_mode));
295
296 print_devices(fs_devices, &devs_found, unit_mode);
297
298 if (devs_found < total) {
299 printf("\t*** Some devices missing\n");
300 }
301 printf("\n");
302 }
303
304 /* adds up all the used spaces as reported by the space info ioctl
305 */
306 static u64 calc_used_bytes(struct btrfs_ioctl_space_args *si)
307 {
308 u64 ret = 0;
309 int i;
310 for (i = 0; i < si->total_spaces; i++)
311 ret += si->spaces[i].used_bytes;
312 return ret;
313 }
314
315 static int print_one_fs(struct btrfs_ioctl_fs_info_args *fs_info,
316 struct btrfs_ioctl_dev_info_args *dev_info,
317 struct btrfs_ioctl_space_args *space_info,
318 char *label, unsigned unit_mode)
319 {
320 int i;
321 int fd;
322 int missing = 0;
323 char uuidbuf[BTRFS_UUID_UNPARSED_SIZE];
324 struct btrfs_ioctl_dev_info_args *tmp_dev_info;
325 int ret;
326
327 ret = add_seen_fsid(fs_info->fsid, seen_fsid_hash, -1, NULL);
328 if (ret == -EEXIST)
329 return 0;
330 else if (ret)
331 return ret;
332
333 uuid_unparse(fs_info->fsid, uuidbuf);
334 if (label && *label)
335 printf("Label: '%s' ", label);
336 else
337 printf("Label: none ");
338
339 printf(" uuid: %s\n\tTotal devices %llu FS bytes used %s\n", uuidbuf,
340 fs_info->num_devices,
341 pretty_size_mode(calc_used_bytes(space_info),
342 unit_mode));
343
344 for (i = 0; i < fs_info->num_devices; i++) {
345 char *canonical_path;
346
347 tmp_dev_info = (struct btrfs_ioctl_dev_info_args *)&dev_info[i];
348
349 /* Add check for missing devices even mounted */
350 fd = open((char *)tmp_dev_info->path, O_RDONLY);
351 if (fd < 0) {
352 missing = 1;
353 continue;
354 }
355 close(fd);
356 canonical_path = canonicalize_path((char *)tmp_dev_info->path);
357 printf("\tdevid %4llu size %s used %s path %s\n",
358 tmp_dev_info->devid,
359 pretty_size_mode(tmp_dev_info->total_bytes, unit_mode),
360 pretty_size_mode(tmp_dev_info->bytes_used, unit_mode),
361 canonical_path);
362
363 free(canonical_path);
364 }
365
366 if (missing)
367 printf("\t*** Some devices missing\n");
368 printf("\n");
369 return 0;
370 }
371
372 static int btrfs_scan_kernel(void *search, unsigned unit_mode)
373 {
374 int ret = 0, fd;
375 int found = 0;
376 FILE *f;
377 struct mntent *mnt;
378 struct btrfs_ioctl_fs_info_args fs_info_arg;
379 struct btrfs_ioctl_dev_info_args *dev_info_arg = NULL;
380 struct btrfs_ioctl_space_args *space_info_arg = NULL;
381 char label[BTRFS_LABEL_SIZE];
382
383 f = setmntent("/proc/self/mounts", "r");
384 if (f == NULL)
385 return 1;
386
387 memset(label, 0, sizeof(label));
388 while ((mnt = getmntent(f)) != NULL) {
389 free(dev_info_arg);
390 dev_info_arg = NULL;
391 if (strcmp(mnt->mnt_type, "btrfs"))
392 continue;
393 ret = get_fs_info(mnt->mnt_dir, &fs_info_arg,
394 &dev_info_arg);
395 if (ret)
396 goto out;
397
398 /* skip all fs already shown as mounted fs */
399 if (is_seen_fsid(fs_info_arg.fsid, seen_fsid_hash))
400 continue;
401
402 ret = get_label_mounted(mnt->mnt_dir, label);
403 /* provide backward kernel compatibility */
404 if (ret == -ENOTTY)
405 ret = get_label_unmounted(
406 (const char *)dev_info_arg->path, label);
407
408 if (ret)
409 goto out;
410
411 if (search && !match_search_item_kernel(fs_info_arg.fsid,
412 mnt->mnt_dir, label, search)) {
413 continue;
414 }
415
416 fd = open(mnt->mnt_dir, O_RDONLY);
417 if ((fd != -1) && !get_df(fd, &space_info_arg)) {
418 print_one_fs(&fs_info_arg, dev_info_arg,
419 space_info_arg, label, unit_mode);
420 free(space_info_arg);
421 memset(label, 0, sizeof(label));
422 found = 1;
423 }
424 if (fd != -1)
425 close(fd);
426 }
427
428 out:
429 free(dev_info_arg);
430 endmntent(f);
431 return !found;
432 }
433
434 static void free_fs_devices(struct btrfs_fs_devices *fs_devices)
435 {
436 struct btrfs_fs_devices *cur_seed, *next_seed;
437 struct btrfs_device *device;
438
439 while (!list_empty(&fs_devices->devices)) {
440 device = list_entry(fs_devices->devices.next,
441 struct btrfs_device, dev_list);
442 list_del(&device->dev_list);
443
444 free(device->name);
445 free(device->label);
446 free(device);
447 }
448
449 /* free seed fs chain */
450 cur_seed = fs_devices->seed;
451 fs_devices->seed = NULL;
452 while (cur_seed) {
453 next_seed = cur_seed->seed;
454 free(cur_seed);
455
456 cur_seed = next_seed;
457 }
458
459 list_del(&fs_devices->list);
460 free(fs_devices);
461 }
462
463 static int copy_device(struct btrfs_device *dst,
464 struct btrfs_device *src)
465 {
466 dst->devid = src->devid;
467 memcpy(dst->uuid, src->uuid, BTRFS_UUID_SIZE);
468 if (src->name == NULL)
469 dst->name = NULL;
470 else {
471 dst->name = strdup(src->name);
472 if (!dst->name)
473 return -ENOMEM;
474 }
475 if (src->label == NULL)
476 dst->label = NULL;
477 else {
478 dst->label = strdup(src->label);
479 if (!dst->label) {
480 free(dst->name);
481 return -ENOMEM;
482 }
483 }
484 dst->total_devs = src->total_devs;
485 dst->super_bytes_used = src->super_bytes_used;
486 dst->total_bytes = src->total_bytes;
487 dst->bytes_used = src->bytes_used;
488 dst->generation = src->generation;
489
490 return 0;
491 }
492
493 static int copy_fs_devices(struct btrfs_fs_devices *dst,
494 struct btrfs_fs_devices *src)
495 {
496 struct btrfs_device *cur_dev, *dev_copy;
497 int ret = 0;
498
499 memcpy(dst->fsid, src->fsid, BTRFS_FSID_SIZE);
500 INIT_LIST_HEAD(&dst->devices);
501 dst->seed = NULL;
502
503 list_for_each_entry(cur_dev, &src->devices, dev_list) {
504 dev_copy = malloc(sizeof(*dev_copy));
505 if (!dev_copy) {
506 ret = -ENOMEM;
507 break;
508 }
509
510 ret = copy_device(dev_copy, cur_dev);
511 if (ret) {
512 free(dev_copy);
513 break;
514 }
515
516 list_add(&dev_copy->dev_list, &dst->devices);
517 dev_copy->fs_devices = dst;
518 }
519
520 return ret;
521 }
522
523 static int find_and_copy_seed(struct btrfs_fs_devices *seed,
524 struct btrfs_fs_devices *copy,
525 struct list_head *fs_uuids) {
526 struct btrfs_fs_devices *cur_fs;
527
528 list_for_each_entry(cur_fs, fs_uuids, list)
529 if (!memcmp(seed->fsid, cur_fs->fsid, BTRFS_FSID_SIZE))
530 return copy_fs_devices(copy, cur_fs);
531
532 return 1;
533 }
534
535 static int has_seed_devices(struct btrfs_fs_devices *fs_devices)
536 {
537 struct btrfs_device *device;
538 int dev_cnt_total, dev_cnt = 0;
539
540 device = list_first_entry(&fs_devices->devices, struct btrfs_device,
541 dev_list);
542
543 dev_cnt_total = device->total_devs;
544
545 list_for_each_entry(device, &fs_devices->devices, dev_list)
546 dev_cnt++;
547
548 return dev_cnt_total != dev_cnt;
549 }
550
551 static int search_umounted_fs_uuids(struct list_head *all_uuids,
552 char *search, int *found)
553 {
554 struct btrfs_fs_devices *cur_fs, *fs_copy;
555 struct list_head *fs_uuids;
556 int ret = 0;
557
558 fs_uuids = btrfs_scanned_uuids();
559
560 /*
561 * The fs_uuids list is global, and open_ctree_* will
562 * modify it, make a private copy here
563 */
564 list_for_each_entry(cur_fs, fs_uuids, list) {
565 /* don't bother handle all fs, if search target specified */
566 if (search) {
567 if (uuid_search(cur_fs, search) == 0)
568 continue;
569 if (found)
570 *found = 1;
571 }
572
573 /* skip all fs already shown as mounted fs */
574 if (is_seen_fsid(cur_fs->fsid, seen_fsid_hash))
575 continue;
576
577 fs_copy = calloc(1, sizeof(*fs_copy));
578 if (!fs_copy) {
579 ret = -ENOMEM;
580 goto out;
581 }
582
583 ret = copy_fs_devices(fs_copy, cur_fs);
584 if (ret) {
585 free(fs_copy);
586 goto out;
587 }
588
589 list_add(&fs_copy->list, all_uuids);
590 }
591
592 out:
593 return ret;
594 }
595
596 static int map_seed_devices(struct list_head *all_uuids)
597 {
598 struct btrfs_fs_devices *cur_fs, *cur_seed;
599 struct btrfs_fs_devices *seed_copy;
600 struct btrfs_fs_devices *opened_fs;
601 struct btrfs_device *device;
602 struct btrfs_fs_info *fs_info;
603 struct list_head *fs_uuids;
604 int ret = 0;
605
606 fs_uuids = btrfs_scanned_uuids();
607
608 list_for_each_entry(cur_fs, all_uuids, list) {
609 device = list_first_entry(&cur_fs->devices,
610 struct btrfs_device, dev_list);
611 if (!device)
612 continue;
613
614 /* skip fs without seeds */
615 if (!has_seed_devices(cur_fs))
616 continue;
617
618 /*
619 * open_ctree_* detects seed/sprout mapping
620 */
621 fs_info = open_ctree_fs_info(device->name, 0, 0, 0,
622 OPEN_CTREE_PARTIAL);
623 if (!fs_info)
624 continue;
625
626 /*
627 * copy the seed chain under the opened fs
628 */
629 opened_fs = fs_info->fs_devices;
630 cur_seed = cur_fs;
631 while (opened_fs->seed) {
632 seed_copy = malloc(sizeof(*seed_copy));
633 if (!seed_copy) {
634 ret = -ENOMEM;
635 goto fail_out;
636 }
637 ret = find_and_copy_seed(opened_fs->seed, seed_copy,
638 fs_uuids);
639 if (ret) {
640 free(seed_copy);
641 goto fail_out;
642 }
643
644 cur_seed->seed = seed_copy;
645
646 opened_fs = opened_fs->seed;
647 cur_seed = cur_seed->seed;
648 }
649
650 close_ctree(fs_info->chunk_root);
651 }
652
653 out:
654 return ret;
655 fail_out:
656 close_ctree(fs_info->chunk_root);
657 goto out;
658 }
659
660 static const char * const cmd_filesystem_show_usage[] = {
661 "btrfs filesystem show [options] [<path>|<uuid>|<device>|label]",
662 "Show the structure of a filesystem",
663 "-d|--all-devices show only disks under /dev containing btrfs filesystem",
664 "-m|--mounted show only mounted btrfs",
665 HELPINFO_UNITS_LONG,
666 "If no argument is given, structure of all present filesystems is shown.",
667 NULL
668 };
669
670 static int cmd_filesystem_show(int argc, char **argv)
671 {
672 LIST_HEAD(all_uuids);
673 struct btrfs_fs_devices *fs_devices;
674 char *search = NULL;
675 int ret;
676 /* default, search both kernel and udev */
677 int where = -1;
678 int type = 0;
679 char mp[PATH_MAX];
680 char path[PATH_MAX];
681 u8 fsid[BTRFS_FSID_SIZE];
682 char uuid_buf[BTRFS_UUID_UNPARSED_SIZE];
683 unsigned unit_mode;
684 int found = 0;
685
686 unit_mode = get_unit_mode_from_arg(&argc, argv, 0);
687
688 optind = 0;
689 while (1) {
690 int c;
691 static const struct option long_options[] = {
692 { "all-devices", no_argument, NULL, 'd'},
693 { "mounted", no_argument, NULL, 'm'},
694 { NULL, 0, NULL, 0 }
695 };
696
697 c = getopt_long(argc, argv, "dm", long_options, NULL);
698 if (c < 0)
699 break;
700 switch (c) {
701 case 'd':
702 where = BTRFS_SCAN_LBLKID;
703 break;
704 case 'm':
705 where = BTRFS_SCAN_MOUNTED;
706 break;
707 default:
708 usage(cmd_filesystem_show_usage);
709 }
710 }
711
712 if (check_argc_max(argc, optind + 1))
713 usage(cmd_filesystem_show_usage);
714
715 if (argc > optind) {
716 search = argv[optind];
717 if (*search == 0)
718 usage(cmd_filesystem_show_usage);
719 type = check_arg_type(search);
720
721 /*
722 * For search is a device:
723 * realpath do /dev/mapper/XX => /dev/dm-X
724 * which is required by BTRFS_SCAN_DEV
725 * For search is a mountpoint:
726 * realpath do /mnt/btrfs/ => /mnt/btrfs
727 * which shall be recognized by btrfs_scan_kernel()
728 */
729 if (realpath(search, path))
730 search = path;
731
732 /*
733 * Needs special handling if input arg is block dev And if
734 * input arg is mount-point just print it right away
735 */
736 if (type == BTRFS_ARG_BLKDEV && where != BTRFS_SCAN_LBLKID) {
737 ret = get_btrfs_mount(search, mp, sizeof(mp));
738 if (!ret) {
739 /* given block dev is mounted */
740 search = mp;
741 type = BTRFS_ARG_MNTPOINT;
742 } else {
743 ret = dev_to_fsid(search, fsid);
744 if (ret) {
745 error("no btrfs on %s", search);
746 return 1;
747 }
748 uuid_unparse(fsid, uuid_buf);
749 search = uuid_buf;
750 type = BTRFS_ARG_UUID;
751 goto devs_only;
752 }
753 }
754 }
755
756 if (where == BTRFS_SCAN_LBLKID)
757 goto devs_only;
758
759 /* show mounted btrfs */
760 ret = btrfs_scan_kernel(search, unit_mode);
761 if (search && !ret) {
762 /* since search is found we are done */
763 goto out;
764 }
765
766 /* shows mounted only */
767 if (where == BTRFS_SCAN_MOUNTED)
768 goto out;
769
770 devs_only:
771 ret = btrfs_scan_devices();
772
773 if (ret) {
774 error("blkid device scan returned %d", ret);
775 return 1;
776 }
777
778 ret = search_umounted_fs_uuids(&all_uuids, search, &found);
779 if (ret < 0) {
780 error("searching target device returned error %d", ret);
781 return 1;
782 }
783
784 /*
785 * The seed/sprout mapping are not detected yet,
786 * do mapping build for all umounted fs
787 */
788 ret = map_seed_devices(&all_uuids);
789 if (ret) {
790 error("mapping seed devices returned error %d", ret);
791 return 1;
792 }
793
794 list_for_each_entry(fs_devices, &all_uuids, list)
795 print_one_uuid(fs_devices, unit_mode);
796
797 if (search && !found) {
798 error("not a valid btrfs filesystem: %s", search);
799 ret = 1;
800 }
801 while (!list_empty(&all_uuids)) {
802 fs_devices = list_entry(all_uuids.next,
803 struct btrfs_fs_devices, list);
804 free_fs_devices(fs_devices);
805 }
806 out:
807 free_seen_fsid(seen_fsid_hash);
808 return ret;
809 }
810
811 static const char * const cmd_filesystem_sync_usage[] = {
812 "btrfs filesystem sync <path>",
813 "Force a sync on a filesystem",
814 NULL
815 };
816
817 static int cmd_filesystem_sync(int argc, char **argv)
818 {
819 enum btrfs_util_error err;
820
821 clean_args_no_options(argc, argv, cmd_filesystem_sync_usage);
822
823 if (check_argc_exact(argc - optind, 1))
824 usage(cmd_filesystem_sync_usage);
825
826 err = btrfs_util_sync(argv[optind]);
827 if (err) {
828 error_btrfs_util(err);
829 return 1;
830 }
831
832 return 0;
833 }
834
835 static int parse_compress_type(char *s)
836 {
837 if (strcmp(optarg, "zlib") == 0)
838 return BTRFS_COMPRESS_ZLIB;
839 else if (strcmp(optarg, "lzo") == 0)
840 return BTRFS_COMPRESS_LZO;
841 else if (strcmp(optarg, "zstd") == 0)
842 return BTRFS_COMPRESS_ZSTD;
843 else {
844 error("unknown compression type %s", s);
845 exit(1);
846 };
847 }
848
849 static const char * const cmd_filesystem_defrag_usage[] = {
850 "btrfs filesystem defragment [options] <file>|<dir> [<file>|<dir>...]",
851 "Defragment a file or a directory",
852 "",
853 "-v be verbose",
854 "-r defragment files recursively",
855 "-c[zlib,lzo,zstd] compress the file while defragmenting",
856 "-f flush data to disk immediately after defragmenting",
857 "-s start defragment only from byte onward",
858 "-l len defragment only up to len bytes",
859 "-t size target extent size hint (default: 32M)",
860 "",
861 "Warning: most Linux kernels will break up the ref-links of COW data",
862 "(e.g., files copied with 'cp --reflink', snapshots) which may cause",
863 "considerable increase of space usage. See btrfs-filesystem(8) for",
864 "more information.",
865 NULL
866 };
867
868 static struct btrfs_ioctl_defrag_range_args defrag_global_range;
869 static int defrag_global_verbose;
870 static int defrag_global_errors;
871 static int defrag_callback(const char *fpath, const struct stat *sb,
872 int typeflag, struct FTW *ftwbuf)
873 {
874 int ret = 0;
875 int fd = 0;
876
877 if ((typeflag == FTW_F) && S_ISREG(sb->st_mode)) {
878 if (defrag_global_verbose)
879 printf("%s\n", fpath);
880 fd = open(fpath, O_RDWR);
881 if (fd < 0) {
882 goto error;
883 }
884 ret = ioctl(fd, BTRFS_IOC_DEFRAG_RANGE, &defrag_global_range);
885 close(fd);
886 if (ret && errno == ENOTTY) {
887 error(
888 "defrag range ioctl not supported in this kernel version, 2.6.33 and newer is required");
889 defrag_global_errors++;
890 return ENOTTY;
891 }
892 if (ret) {
893 goto error;
894 }
895 }
896 return 0;
897
898 error:
899 error("defrag failed on %s: %m", fpath);
900 defrag_global_errors++;
901 return 0;
902 }
903
904 static int cmd_filesystem_defrag(int argc, char **argv)
905 {
906 int fd;
907 int flush = 0;
908 u64 start = 0;
909 u64 len = (u64)-1;
910 u64 thresh;
911 int i;
912 int recursive = 0;
913 int ret = 0;
914 int compress_type = BTRFS_COMPRESS_NONE;
915 DIR *dirstream;
916
917 /*
918 * Kernel has a different default (256K) that is supposed to be safe,
919 * but it does not defragment very well. The 32M will likely lead to
920 * better results and is independent of the kernel default. We have to
921 * use the v2 defrag ioctl.
922 */
923 thresh = SZ_32M;
924
925 defrag_global_errors = 0;
926 defrag_global_verbose = 0;
927 defrag_global_errors = 0;
928 optind = 0;
929 while(1) {
930 int c = getopt(argc, argv, "vrc::fs:l:t:");
931 if (c < 0)
932 break;
933
934 switch(c) {
935 case 'c':
936 compress_type = BTRFS_COMPRESS_ZLIB;
937 if (optarg)
938 compress_type = parse_compress_type(optarg);
939 break;
940 case 'f':
941 flush = 1;
942 break;
943 case 'v':
944 defrag_global_verbose = 1;
945 break;
946 case 's':
947 start = parse_size(optarg);
948 break;
949 case 'l':
950 len = parse_size(optarg);
951 break;
952 case 't':
953 thresh = parse_size(optarg);
954 if (thresh > (u32)-1) {
955 warning(
956 "target extent size %llu too big, trimmed to %u",
957 thresh, (u32)-1);
958 thresh = (u32)-1;
959 }
960 break;
961 case 'r':
962 recursive = 1;
963 break;
964 default:
965 usage(cmd_filesystem_defrag_usage);
966 }
967 }
968
969 if (check_argc_min(argc - optind, 1))
970 usage(cmd_filesystem_defrag_usage);
971
972 memset(&defrag_global_range, 0, sizeof(defrag_global_range));
973 defrag_global_range.start = start;
974 defrag_global_range.len = len;
975 defrag_global_range.extent_thresh = (u32)thresh;
976 if (compress_type) {
977 defrag_global_range.flags |= BTRFS_DEFRAG_RANGE_COMPRESS;
978 defrag_global_range.compress_type = compress_type;
979 }
980 if (flush)
981 defrag_global_range.flags |= BTRFS_DEFRAG_RANGE_START_IO;
982
983 /*
984 * Look for directory arguments and warn if the recursive mode is not
985 * requested, as this is not implemented as recursive defragmentation
986 * in kernel. The stat errors are silent here as we check them below.
987 */
988 if (!recursive) {
989 int found = 0;
990
991 for (i = optind; i < argc; i++) {
992 struct stat st;
993
994 if (stat(argv[i], &st))
995 continue;
996
997 if (S_ISDIR(st.st_mode)) {
998 warning(
999 "directory specified but recursive mode not requested: %s",
1000 argv[i]);
1001 found = 1;
1002 }
1003 }
1004 if (found) {
1005 warning(
1006 "a directory passed to the defrag ioctl will not process the files\n"
1007 "recursively but will defragment the subvolume tree and the extent tree.\n"
1008 "If this is not intended, please use option -r .");
1009 }
1010 }
1011
1012 for (i = optind; i < argc; i++) {
1013 struct stat st;
1014 int defrag_err = 0;
1015
1016 dirstream = NULL;
1017 fd = open_file_or_dir(argv[i], &dirstream);
1018 if (fd < 0) {
1019 error("cannot open %s: %m", argv[i]);
1020 ret = -errno;
1021 goto next;
1022 }
1023
1024 ret = fstat(fd, &st);
1025 if (ret) {
1026 error("failed to stat %s: %m", argv[i]);
1027 ret = -errno;
1028 goto next;
1029 }
1030 if (!(S_ISDIR(st.st_mode) || S_ISREG(st.st_mode))) {
1031 error("%s is not a directory or a regular file",
1032 argv[i]);
1033 ret = -EINVAL;
1034 goto next;
1035 }
1036 if (recursive && S_ISDIR(st.st_mode)) {
1037 ret = nftw(argv[i], defrag_callback, 10,
1038 FTW_MOUNT | FTW_PHYS);
1039 if (ret == ENOTTY)
1040 exit(1);
1041 /* errors are handled in the callback */
1042 ret = 0;
1043 } else {
1044 if (defrag_global_verbose)
1045 printf("%s\n", argv[i]);
1046 ret = ioctl(fd, BTRFS_IOC_DEFRAG_RANGE,
1047 &defrag_global_range);
1048 defrag_err = errno;
1049 if (ret && defrag_err == ENOTTY) {
1050 error(
1051 "defrag range ioctl not supported in this kernel version, 2.6.33 and newer is required");
1052 defrag_global_errors++;
1053 close_file_or_dir(fd, dirstream);
1054 break;
1055 }
1056 if (ret) {
1057 error("defrag failed on %s: %s", argv[i],
1058 strerror(defrag_err));
1059 goto next;
1060 }
1061 }
1062 next:
1063 if (ret)
1064 defrag_global_errors++;
1065 close_file_or_dir(fd, dirstream);
1066 }
1067
1068 if (defrag_global_errors)
1069 fprintf(stderr, "total %d failures\n", defrag_global_errors);
1070
1071 return !!defrag_global_errors;
1072 }
1073
1074 static const char * const cmd_filesystem_resize_usage[] = {
1075 "btrfs filesystem resize [devid:][+/-]<newsize>[kKmMgGtTpPeE]|[devid:]max <path>",
1076 "Resize a filesystem",
1077 "If 'max' is passed, the filesystem will occupy all available space",
1078 "on the device 'devid'.",
1079 "[kK] means KiB, which denotes 1KiB = 1024B, 1MiB = 1024KiB, etc.",
1080 NULL
1081 };
1082
1083 static int cmd_filesystem_resize(int argc, char **argv)
1084 {
1085 struct btrfs_ioctl_vol_args args;
1086 int fd, res, len, e;
1087 char *amount, *path;
1088 DIR *dirstream = NULL;
1089 struct stat st;
1090
1091 clean_args_no_options_relaxed(argc, argv);
1092
1093 if (check_argc_exact(argc - optind, 2))
1094 usage(cmd_filesystem_resize_usage);
1095
1096 amount = argv[optind];
1097 path = argv[optind + 1];
1098
1099 len = strlen(amount);
1100 if (len == 0 || len >= BTRFS_VOL_NAME_MAX) {
1101 error("resize value too long (%s)", amount);
1102 return 1;
1103 }
1104
1105 res = stat(path, &st);
1106 if (res < 0) {
1107 error("resize: cannot stat %s: %m", path);
1108 return 1;
1109 }
1110 if (!S_ISDIR(st.st_mode)) {
1111 error("resize works on mounted filesystems and accepts only\n"
1112 "directories as argument. Passing file containing a btrfs image\n"
1113 "would resize the underlying filesystem instead of the image.\n");
1114 return 1;
1115 }
1116
1117 fd = btrfs_open_dir(path, &dirstream, 1);
1118 if (fd < 0)
1119 return 1;
1120
1121 printf("Resize '%s' of '%s'\n", path, amount);
1122 memset(&args, 0, sizeof(args));
1123 strncpy_null(args.name, amount);
1124 res = ioctl(fd, BTRFS_IOC_RESIZE, &args);
1125 e = errno;
1126 close_file_or_dir(fd, dirstream);
1127 if( res < 0 ){
1128 switch (e) {
1129 case EFBIG:
1130 error("unable to resize '%s': no enough free space",
1131 path);
1132 break;
1133 default:
1134 error("unable to resize '%s': %m", path);
1135 break;
1136 }
1137 return 1;
1138 } else if (res > 0) {
1139 const char *err_str = btrfs_err_str(res);
1140
1141 if (err_str) {
1142 error("resizing of '%s' failed: %s", path, err_str);
1143 } else {
1144 error("resizing of '%s' failed: unknown error %d",
1145 path, res);
1146 }
1147 return 1;
1148 }
1149 return 0;
1150 }
1151
1152 static const char * const cmd_filesystem_label_usage[] = {
1153 "btrfs filesystem label [<device>|<mount_point>] [<newlabel>]",
1154 "Get or change the label of a filesystem",
1155 "With one argument, get the label of filesystem on <device>.",
1156 "If <newlabel> is passed, set the filesystem label to <newlabel>.",
1157 NULL
1158 };
1159
1160 static int cmd_filesystem_label(int argc, char **argv)
1161 {
1162 clean_args_no_options(argc, argv, cmd_filesystem_label_usage);
1163
1164 if (check_argc_min(argc - optind, 1) ||
1165 check_argc_max(argc - optind, 2))
1166 usage(cmd_filesystem_label_usage);
1167
1168 if (argc - optind > 1) {
1169 return set_label(argv[optind], argv[optind + 1]);
1170 } else {
1171 char label[BTRFS_LABEL_SIZE];
1172 int ret;
1173
1174 ret = get_label(argv[optind], label);
1175 if (!ret)
1176 fprintf(stdout, "%s\n", label);
1177
1178 return ret;
1179 }
1180 }
1181
1182 static const char filesystem_cmd_group_info[] =
1183 "overall filesystem tasks and information";
1184
1185 const struct cmd_group filesystem_cmd_group = {
1186 filesystem_cmd_group_usage, filesystem_cmd_group_info, {
1187 { "df", cmd_filesystem_df, cmd_filesystem_df_usage, NULL, 0 },
1188 { "du", cmd_filesystem_du, cmd_filesystem_du_usage, NULL, 0 },
1189 { "show", cmd_filesystem_show, cmd_filesystem_show_usage, NULL,
1190 0 },
1191 { "sync", cmd_filesystem_sync, cmd_filesystem_sync_usage, NULL,
1192 0 },
1193 { "defragment", cmd_filesystem_defrag,
1194 cmd_filesystem_defrag_usage, NULL, 0 },
1195 { "balance", cmd_balance, NULL, &balance_cmd_group,
1196 CMD_HIDDEN },
1197 { "resize", cmd_filesystem_resize, cmd_filesystem_resize_usage,
1198 NULL, 0 },
1199 { "label", cmd_filesystem_label, cmd_filesystem_label_usage,
1200 NULL, 0 },
1201 { "usage", cmd_filesystem_usage,
1202 cmd_filesystem_usage_usage, NULL, 0 },
1203
1204 NULL_CMD_STRUCT
1205 }
1206 };
1207
1208 int cmd_filesystem(int argc, char **argv)
1209 {
1210 return handle_command_group(&filesystem_cmd_group, argc, argv);
1211 }
(deprecated) Btrfs progs developments and patch integration