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