?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
btrfs-progs: check: Remove ext_ref param from walk_down_tree
[btrfs-progs-unstable/devel.git] / cmds-subvolume.c
blob45363a5ab3f80cb2a04fa6a1af153498094884da
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 <inttypes.h>
18 #include <stdio.h>
19 #include <stdlib.h>
20 #include <string.h>
21 #include <unistd.h>
22 #include <sys/ioctl.h>
23 #include <errno.h>
24 #include <sys/stat.h>
25 #include <sys/vfs.h>
26 #include <libgen.h>
27 #include <limits.h>
28 #include <getopt.h>
29 #include <uuid/uuid.h>
30 #include <linux/magic.h>
31
32 #include <btrfsutil.h>
33
34 #include "kerncompat.h"
35 #include "ioctl.h"
36 #include "qgroup.h"
37
38 #include "ctree.h"
39 #include "commands.h"
40 #include "utils.h"
41 #include "btrfs-list.h"
42 #include "utils.h"
43 #include "help.h"
44
45 static int wait_for_subvolume_cleaning(int fd, size_t count, uint64_t *ids,
46 int sleep_interval)
47 {
48 size_t i;
49 enum btrfs_util_error err;
50
51 while (1) {
52 int clean = 1;
53
54 for (i = 0; i < count; i++) {
55 if (!ids[i])
56 continue;
57 err = btrfs_util_subvolume_info_fd(fd, ids[i], NULL);
58 if (err == BTRFS_UTIL_ERROR_SUBVOLUME_NOT_FOUND) {
59 printf("Subvolume id %" PRIu64 " is gone\n",
60 ids[i]);
61 ids[i] = 0;
62 } else if (err) {
63 error_btrfs_util(err);
64 return -errno;
65 } else {
66 clean = 0;
67 }
68 }
69 if (clean)
70 break;
71 sleep(sleep_interval);
72 }
73
74 return 0;
75 }
76
77 static const char * const subvolume_cmd_group_usage[] = {
78 "btrfs subvolume <command> <args>",
79 NULL
80 };
81
82 static const char * const cmd_subvol_create_usage[] = {
83 "btrfs subvolume create [-i <qgroupid>] [<dest>/]<name>",
84 "Create a subvolume",
85 "Create a subvolume <name> in <dest>. If <dest> is not given",
86 "subvolume <name> will be created in the current directory.",
87 "",
88 "-i <qgroupid> add the newly created subvolume to a qgroup. This",
89 " option can be given multiple times.",
90 NULL
91 };
92
93 static int cmd_subvol_create(int argc, char **argv)
94 {
95 int retval, res, len;
96 int fddst = -1;
97 char *dupname = NULL;
98 char *dupdir = NULL;
99 char *newname;
100 char *dstdir;
101 char *dst;
102 struct btrfs_qgroup_inherit *inherit = NULL;
103 DIR *dirstream = NULL;
104
105 while (1) {
106 int c = getopt(argc, argv, "c:i:");
107 if (c < 0)
108 break;
109
110 switch (c) {
111 case 'c':
112 res = qgroup_inherit_add_copy(&inherit, optarg, 0);
113 if (res) {
114 retval = res;
115 goto out;
116 }
117 break;
118 case 'i':
119 res = qgroup_inherit_add_group(&inherit, optarg);
120 if (res) {
121 retval = res;
122 goto out;
123 }
124 break;
125 default:
126 usage(cmd_subvol_create_usage);
127 }
128 }
129
130 if (check_argc_exact(argc - optind, 1))
131 usage(cmd_subvol_create_usage);
132
133 dst = argv[optind];
134
135 retval = 1; /* failure */
136 res = test_isdir(dst);
137 if (res < 0 && res != -ENOENT) {
138 error("cannot access %s: %s", dst, strerror(-res));
139 goto out;
140 }
141 if (res >= 0) {
142 error("target path already exists: %s", dst);
143 goto out;
144 }
145
146 dupname = strdup(dst);
147 newname = basename(dupname);
148 dupdir = strdup(dst);
149 dstdir = dirname(dupdir);
150
151 if (!test_issubvolname(newname)) {
152 error("invalid subvolume name: %s", newname);
153 goto out;
154 }
155
156 len = strlen(newname);
157 if (len == 0 || len >= BTRFS_VOL_NAME_MAX) {
158 error("subvolume name too long: %s", newname);
159 goto out;
160 }
161
162 fddst = btrfs_open_dir(dstdir, &dirstream, 1);
163 if (fddst < 0)
164 goto out;
165
166 printf("Create subvolume '%s/%s'\n", dstdir, newname);
167 if (inherit) {
168 struct btrfs_ioctl_vol_args_v2 args;
169
170 memset(&args, 0, sizeof(args));
171 strncpy_null(args.name, newname);
172 args.flags |= BTRFS_SUBVOL_QGROUP_INHERIT;
173 args.size = qgroup_inherit_size(inherit);
174 args.qgroup_inherit = inherit;
175
176 res = ioctl(fddst, BTRFS_IOC_SUBVOL_CREATE_V2, &args);
177 } else {
178 struct btrfs_ioctl_vol_args args;
179
180 memset(&args, 0, sizeof(args));
181 strncpy_null(args.name, newname);
182
183 res = ioctl(fddst, BTRFS_IOC_SUBVOL_CREATE, &args);
184 }
185
186 if (res < 0) {
187 error("cannot create subvolume: %m");
188 goto out;
189 }
190
191 retval = 0; /* success */
192 out:
193 close_file_or_dir(fddst, dirstream);
194 free(inherit);
195 free(dupname);
196 free(dupdir);
197
198 return retval;
199 }
200
201 static int wait_for_commit(int fd)
202 {
203 enum btrfs_util_error err;
204 uint64_t transid;
205
206 err = btrfs_util_start_sync_fd(fd, &transid);
207 if (err)
208 return -1;
209
210 err = btrfs_util_wait_sync_fd(fd, transid);
211 if (err)
212 return -1;
213
214 return 0;
215 }
216
217 static const char * const cmd_subvol_delete_usage[] = {
218 "btrfs subvolume delete [options] <subvolume> [<subvolume>...]",
219 "Delete subvolume(s)",
220 "Delete subvolumes from the filesystem. The corresponding directory",
221 "is removed instantly but the data blocks are removed later.",
222 "The deletion does not involve full commit by default due to",
223 "performance reasons (as a consequence, the subvolume may appear again",
224 "after a crash). Use one of the --commit options to wait until the",
225 "operation is safely stored on the media.",
226 "",
227 "-c|--commit-after wait for transaction commit at the end of the operation",
228 "-C|--commit-each wait for transaction commit after deleting each subvolume",
229 "-v|--verbose verbose output of operations",
230 NULL
231 };
232
233 static int cmd_subvol_delete(int argc, char **argv)
234 {
235 int res, ret = 0;
236 int cnt;
237 int fd = -1;
238 char *dname, *vname, *cpath;
239 char *dupdname = NULL;
240 char *dupvname = NULL;
241 char *path;
242 DIR *dirstream = NULL;
243 int verbose = 0;
244 int commit_mode = 0;
245 u8 fsid[BTRFS_FSID_SIZE];
246 char uuidbuf[BTRFS_UUID_UNPARSED_SIZE];
247 struct seen_fsid *seen_fsid_hash[SEEN_FSID_HASH_SIZE] = { NULL, };
248 enum { COMMIT_AFTER = 1, COMMIT_EACH = 2 };
249 enum btrfs_util_error err;
250
251 while (1) {
252 int c;
253 static const struct option long_options[] = {
254 {"commit-after", no_argument, NULL, 'c'},
255 {"commit-each", no_argument, NULL, 'C'},
256 {"verbose", no_argument, NULL, 'v'},
257 {NULL, 0, NULL, 0}
258 };
259
260 c = getopt_long(argc, argv, "cCv", long_options, NULL);
261 if (c < 0)
262 break;
263
264 switch(c) {
265 case 'c':
266 commit_mode = COMMIT_AFTER;
267 break;
268 case 'C':
269 commit_mode = COMMIT_EACH;
270 break;
271 case 'v':
272 verbose++;
273 break;
274 default:
275 usage(cmd_subvol_delete_usage);
276 }
277 }
278
279 if (check_argc_min(argc - optind, 1))
280 usage(cmd_subvol_delete_usage);
281
282 if (verbose > 0) {
283 printf("Transaction commit: %s\n",
284 !commit_mode ? "none (default)" :
285 commit_mode == COMMIT_AFTER ? "at the end" : "after each");
286 }
287
288 cnt = optind;
289
290 again:
291 path = argv[cnt];
292
293 err = btrfs_util_is_subvolume(path);
294 if (err) {
295 error_btrfs_util(err);
296 ret = 1;
297 goto out;
298 }
299
300 cpath = realpath(path, NULL);
301 if (!cpath) {
302 ret = errno;
303 error("cannot find real path for '%s': %m", path);
304 goto out;
305 }
306 dupdname = strdup(cpath);
307 dname = dirname(dupdname);
308 dupvname = strdup(cpath);
309 vname = basename(dupvname);
310 free(cpath);
311
312 fd = btrfs_open_dir(dname, &dirstream, 1);
313 if (fd < 0) {
314 ret = 1;
315 goto out;
316 }
317
318 printf("Delete subvolume (%s): '%s/%s'\n",
319 commit_mode == COMMIT_EACH || (commit_mode == COMMIT_AFTER && cnt + 1 == argc)
320 ? "commit" : "no-commit", dname, vname);
321
322 err = btrfs_util_delete_subvolume_fd(fd, vname, 0);
323 if (err) {
324 error_btrfs_util(err);
325 ret = 1;
326 goto out;
327 }
328
329 if (commit_mode == COMMIT_EACH) {
330 res = wait_for_commit(fd);
331 if (res < 0) {
332 error("unable to wait for commit after '%s': %m", path);
333 ret = 1;
334 }
335 } else if (commit_mode == COMMIT_AFTER) {
336 res = get_fsid(dname, fsid, 0);
337 if (res < 0) {
338 error("unable to get fsid for '%s': %s",
339 path, strerror(-res));
340 error(
341 "delete succeeded but commit may not be done in the end");
342 ret = 1;
343 goto out;
344 }
345
346 if (add_seen_fsid(fsid, seen_fsid_hash, fd, dirstream) == 0) {
347 if (verbose > 0) {
348 uuid_unparse(fsid, uuidbuf);
349 printf(" new fs is found for '%s', fsid: %s\n",
350 path, uuidbuf);
351 }
352 /*
353 * This is the first time a subvolume on this
354 * filesystem is deleted, keep fd in order to issue
355 * SYNC ioctl in the end
356 */
357 goto keep_fd;
358 }
359 }
360
361 out:
362 close_file_or_dir(fd, dirstream);
363 keep_fd:
364 fd = -1;
365 dirstream = NULL;
366 free(dupdname);
367 free(dupvname);
368 dupdname = NULL;
369 dupvname = NULL;
370 cnt++;
371 if (cnt < argc)
372 goto again;
373
374 if (commit_mode == COMMIT_AFTER) {
375 int slot;
376
377 /*
378 * Traverse seen_fsid_hash and issue SYNC ioctl on each
379 * filesystem
380 */
381 for (slot = 0; slot < SEEN_FSID_HASH_SIZE; slot++) {
382 struct seen_fsid *seen = seen_fsid_hash[slot];
383
384 while (seen) {
385 res = wait_for_commit(seen->fd);
386 if (res < 0) {
387 uuid_unparse(seen->fsid, uuidbuf);
388 error(
389 "unable to do final sync after deletion: %m, fsid: %s",
390 uuidbuf);
391 ret = 1;
392 } else if (verbose > 0) {
393 uuid_unparse(seen->fsid, uuidbuf);
394 printf("final sync is done for fsid: %s\n",
395 uuidbuf);
396 }
397 seen = seen->next;
398 }
399 }
400 /* fd will also be closed in free_seen_fsid */
401 free_seen_fsid(seen_fsid_hash);
402 }
403
404 return ret;
405 }
406
407 /*
408 * Naming of options:
409 * - uppercase for filters and sort options
410 * - lowercase for enabling specific items in the output
411 */
412 static const char * const cmd_subvol_list_usage[] = {
413 "btrfs subvolume list [options] <path>",
414 "List subvolumes and snapshots in the filesystem.",
415 "",
416 "Path filtering:",
417 "-o print only subvolumes below specified path",
418 "-a print all the subvolumes in the filesystem and",
419 " distinguish absolute and relative path with respect",
420 " to the given <path>",
421 "",
422 "Field selection:",
423 "-p print parent ID",
424 "-c print the ogeneration of the subvolume",
425 "-g print the generation of the subvolume",
426 "-u print the uuid of subvolumes (and snapshots)",
427 "-q print the parent uuid of the snapshots",
428 "-R print the uuid of the received snapshots",
429 "",
430 "Type filtering:",
431 "-s list only snapshots",
432 "-r list readonly subvolumes (including snapshots)",
433 "-d list deleted subvolumes that are not yet cleaned",
434 "",
435 "Other:",
436 "-t print the result as a table",
437 "",
438 "Sorting:",
439 "-G [+|-]value",
440 " filter the subvolumes by generation",
441 " (+value: >= value; -value: <= value; value: = value)",
442 "-C [+|-]value",
443 " filter the subvolumes by ogeneration",
444 " (+value: >= value; -value: <= value; value: = value)",
445 "--sort=gen,ogen,rootid,path",
446 " list the subvolume in order of gen, ogen, rootid or path",
447 " you also can add '+' or '-' in front of each items.",
448 " (+:ascending, -:descending, ascending default)",
449 NULL,
450 };
451
452 static int cmd_subvol_list(int argc, char **argv)
453 {
454 struct btrfs_list_filter_set *filter_set;
455 struct btrfs_list_comparer_set *comparer_set;
456 u64 flags = 0;
457 int fd = -1;
458 u64 top_id;
459 int ret = -1, uerr = 0;
460 char *subvol;
461 int is_list_all = 0;
462 int is_only_in_path = 0;
463 DIR *dirstream = NULL;
464 enum btrfs_list_layout layout = BTRFS_LIST_LAYOUT_DEFAULT;
465
466 filter_set = btrfs_list_alloc_filter_set();
467 comparer_set = btrfs_list_alloc_comparer_set();
468
469 while(1) {
470 int c;
471 static const struct option long_options[] = {
472 {"sort", required_argument, NULL, 'S'},
473 {NULL, 0, NULL, 0}
474 };
475
476 c = getopt_long(argc, argv,
477 "acdgopqsurRG:C:t", long_options, NULL);
478 if (c < 0)
479 break;
480
481 switch(c) {
482 case 'p':
483 btrfs_list_setup_print_column(BTRFS_LIST_PARENT);
484 break;
485 case 'a':
486 is_list_all = 1;
487 break;
488 case 'c':
489 btrfs_list_setup_print_column(BTRFS_LIST_OGENERATION);
490 break;
491 case 'd':
492 btrfs_list_setup_filter(&filter_set,
493 BTRFS_LIST_FILTER_DELETED,
494 0);
495 break;
496 case 'g':
497 btrfs_list_setup_print_column(BTRFS_LIST_GENERATION);
498 break;
499 case 'o':
500 is_only_in_path = 1;
501 break;
502 case 't':
503 layout = BTRFS_LIST_LAYOUT_TABLE;
504 break;
505 case 's':
506 btrfs_list_setup_filter(&filter_set,
507 BTRFS_LIST_FILTER_SNAPSHOT_ONLY,
508 0);
509 btrfs_list_setup_print_column(BTRFS_LIST_OGENERATION);
510 btrfs_list_setup_print_column(BTRFS_LIST_OTIME);
511 break;
512 case 'u':
513 btrfs_list_setup_print_column(BTRFS_LIST_UUID);
514 break;
515 case 'q':
516 btrfs_list_setup_print_column(BTRFS_LIST_PUUID);
517 break;
518 case 'R':
519 btrfs_list_setup_print_column(BTRFS_LIST_RUUID);
520 break;
521 case 'r':
522 flags |= BTRFS_ROOT_SUBVOL_RDONLY;
523 break;
524 case 'G':
525 btrfs_list_setup_print_column(BTRFS_LIST_GENERATION);
526 ret = btrfs_list_parse_filter_string(optarg,
527 &filter_set,
528 BTRFS_LIST_FILTER_GEN);
529 if (ret) {
530 uerr = 1;
531 goto out;
532 }
533 break;
534
535 case 'C':
536 btrfs_list_setup_print_column(BTRFS_LIST_OGENERATION);
537 ret = btrfs_list_parse_filter_string(optarg,
538 &filter_set,
539 BTRFS_LIST_FILTER_CGEN);
540 if (ret) {
541 uerr = 1;
542 goto out;
543 }
544 break;
545 case 'S':
546 ret = btrfs_list_parse_sort_string(optarg,
547 &comparer_set);
548 if (ret) {
549 uerr = 1;
550 goto out;
551 }
552 break;
553
554 default:
555 uerr = 1;
556 goto out;
557 }
558 }
559
560 if (check_argc_exact(argc - optind, 1)) {
561 uerr = 1;
562 goto out;
563 }
564
565 subvol = argv[optind];
566 fd = btrfs_open_dir(subvol, &dirstream, 1);
567 if (fd < 0) {
568 ret = -1;
569 error("can't access '%s'", subvol);
570 goto out;
571 }
572
573 if (flags)
574 btrfs_list_setup_filter(&filter_set, BTRFS_LIST_FILTER_FLAGS,
575 flags);
576
577 ret = btrfs_list_get_path_rootid(fd, &top_id);
578 if (ret)
579 goto out;
580
581 if (is_list_all)
582 btrfs_list_setup_filter(&filter_set,
583 BTRFS_LIST_FILTER_FULL_PATH,
584 top_id);
585 else if (is_only_in_path)
586 btrfs_list_setup_filter(&filter_set,
587 BTRFS_LIST_FILTER_TOPID_EQUAL,
588 top_id);
589
590 /* by default we shall print the following columns*/
591 btrfs_list_setup_print_column(BTRFS_LIST_OBJECTID);
592 btrfs_list_setup_print_column(BTRFS_LIST_GENERATION);
593 btrfs_list_setup_print_column(BTRFS_LIST_TOP_LEVEL);
594 btrfs_list_setup_print_column(BTRFS_LIST_PATH);
595
596 ret = btrfs_list_subvols_print(fd, filter_set, comparer_set,
597 layout, !is_list_all && !is_only_in_path, NULL);
598
599 out:
600 close_file_or_dir(fd, dirstream);
601 if (filter_set)
602 free(filter_set);
603 if (comparer_set)
604 free(comparer_set);
605 if (uerr)
606 usage(cmd_subvol_list_usage);
607 return !!ret;
608 }
609
610 static const char * const cmd_subvol_snapshot_usage[] = {
611 "btrfs subvolume snapshot [-r] [-i <qgroupid>] <source> <dest>|[<dest>/]<name>",
612 "Create a snapshot of the subvolume",
613 "Create a writable/readonly snapshot of the subvolume <source> with",
614 "the name <name> in the <dest> directory. If only <dest> is given,",
615 "the subvolume will be named the basename of <source>.",
616 "",
617 "-r create a readonly snapshot",
618 "-i <qgroupid> add the newly created snapshot to a qgroup. This",
619 " option can be given multiple times.",
620 NULL
621 };
622
623 static int cmd_subvol_snapshot(int argc, char **argv)
624 {
625 char *subvol, *dst;
626 int res, retval;
627 int fd = -1, fddst = -1;
628 int len, readonly = 0;
629 char *dupname = NULL;
630 char *dupdir = NULL;
631 char *newname;
632 char *dstdir;
633 enum btrfs_util_error err;
634 struct btrfs_ioctl_vol_args_v2 args;
635 struct btrfs_qgroup_inherit *inherit = NULL;
636 DIR *dirstream1 = NULL, *dirstream2 = NULL;
637
638 memset(&args, 0, sizeof(args));
639 while (1) {
640 int c = getopt(argc, argv, "c:i:r");
641 if (c < 0)
642 break;
643
644 switch (c) {
645 case 'c':
646 res = qgroup_inherit_add_copy(&inherit, optarg, 0);
647 if (res) {
648 retval = res;
649 goto out;
650 }
651 break;
652 case 'i':
653 res = qgroup_inherit_add_group(&inherit, optarg);
654 if (res) {
655 retval = res;
656 goto out;
657 }
658 break;
659 case 'r':
660 readonly = 1;
661 break;
662 case 'x':
663 res = qgroup_inherit_add_copy(&inherit, optarg, 1);
664 if (res) {
665 retval = res;
666 goto out;
667 }
668 break;
669 default:
670 usage(cmd_subvol_snapshot_usage);
671 }
672 }
673
674 if (check_argc_exact(argc - optind, 2))
675 usage(cmd_subvol_snapshot_usage);
676
677 subvol = argv[optind];
678 dst = argv[optind + 1];
679
680 retval = 1; /* failure */
681 err = btrfs_util_is_subvolume(subvol);
682 if (err) {
683 error_btrfs_util(err);
684 goto out;
685 }
686
687 res = test_isdir(dst);
688 if (res < 0 && res != -ENOENT) {
689 error("cannot access %s: %s", dst, strerror(-res));
690 goto out;
691 }
692 if (res == 0) {
693 error("'%s' exists and it is not a directory", dst);
694 goto out;
695 }
696
697 if (res > 0) {
698 dupname = strdup(subvol);
699 newname = basename(dupname);
700 dstdir = dst;
701 } else {
702 dupname = strdup(dst);
703 newname = basename(dupname);
704 dupdir = strdup(dst);
705 dstdir = dirname(dupdir);
706 }
707
708 if (!test_issubvolname(newname)) {
709 error("invalid snapshot name '%s'", newname);
710 goto out;
711 }
712
713 len = strlen(newname);
714 if (len == 0 || len >= BTRFS_VOL_NAME_MAX) {
715 error("snapshot name too long '%s'", newname);
716 goto out;
717 }
718
719 fddst = btrfs_open_dir(dstdir, &dirstream1, 1);
720 if (fddst < 0)
721 goto out;
722
723 fd = btrfs_open_dir(subvol, &dirstream2, 1);
724 if (fd < 0)
725 goto out;
726
727 if (readonly) {
728 args.flags |= BTRFS_SUBVOL_RDONLY;
729 printf("Create a readonly snapshot of '%s' in '%s/%s'\n",
730 subvol, dstdir, newname);
731 } else {
732 printf("Create a snapshot of '%s' in '%s/%s'\n",
733 subvol, dstdir, newname);
734 }
735
736 args.fd = fd;
737 if (inherit) {
738 args.flags |= BTRFS_SUBVOL_QGROUP_INHERIT;
739 args.size = qgroup_inherit_size(inherit);
740 args.qgroup_inherit = inherit;
741 }
742 strncpy_null(args.name, newname);
743
744 res = ioctl(fddst, BTRFS_IOC_SNAP_CREATE_V2, &args);
745
746 if (res < 0) {
747 error("cannot snapshot '%s': %m", subvol);
748 goto out;
749 }
750
751 retval = 0; /* success */
752
753 out:
754 close_file_or_dir(fddst, dirstream1);
755 close_file_or_dir(fd, dirstream2);
756 free(inherit);
757 free(dupname);
758 free(dupdir);
759
760 return retval;
761 }
762
763 static const char * const cmd_subvol_get_default_usage[] = {
764 "btrfs subvolume get-default <path>",
765 "Get the default subvolume of a filesystem",
766 NULL
767 };
768
769 static int cmd_subvol_get_default(int argc, char **argv)
770 {
771 int fd = -1;
772 int ret = 1;
773 uint64_t default_id;
774 DIR *dirstream = NULL;
775 enum btrfs_util_error err;
776 struct btrfs_util_subvolume_info subvol;
777 char *path;
778
779 clean_args_no_options(argc, argv, cmd_subvol_get_default_usage);
780
781 if (check_argc_exact(argc - optind, 1))
782 usage(cmd_subvol_get_default_usage);
783
784 fd = btrfs_open_dir(argv[1], &dirstream, 1);
785 if (fd < 0)
786 return 1;
787
788 err = btrfs_util_get_default_subvolume_fd(fd, &default_id);
789 if (err) {
790 error_btrfs_util(err);
791 goto out;
792 }
793
794 /* no need to resolve roots if FS_TREE is default */
795 if (default_id == BTRFS_FS_TREE_OBJECTID) {
796 printf("ID 5 (FS_TREE)\n");
797 ret = 0;
798 goto out;
799 }
800
801 err = btrfs_util_subvolume_info_fd(fd, default_id, &subvol);
802 if (err) {
803 error_btrfs_util(err);
804 goto out;
805 }
806
807 err = btrfs_util_subvolume_path_fd(fd, default_id, &path);
808 if (err) {
809 error_btrfs_util(err);
810 goto out;
811 }
812
813 printf("ID %" PRIu64 " gen %" PRIu64 " top level %" PRIu64 " path %s\n",
814 subvol.id, subvol.generation, subvol.parent_id, path);
815
816 free(path);
817
818 ret = 0;
819 out:
820 close_file_or_dir(fd, dirstream);
821 return ret;
822 }
823
824 static const char * const cmd_subvol_set_default_usage[] = {
825 "btrfs subvolume set-default <subvolume>\n"
826 "btrfs subvolume set-default <subvolid> <path>",
827 "Set the default subvolume of the filesystem mounted as default.",
828 "The subvolume can be specified by its path,",
829 "or the pair of subvolume id and path to the filesystem.",
830 NULL
831 };
832
833 static int cmd_subvol_set_default(int argc, char **argv)
834 {
835 u64 objectid;
836 char *path;
837 enum btrfs_util_error err;
838
839 clean_args_no_options(argc, argv, cmd_subvol_set_default_usage);
840
841 if (check_argc_min(argc - optind, 1) ||
842 check_argc_max(argc - optind, 2))
843 usage(cmd_subvol_set_default_usage);
844
845 if (argc - optind == 1) {
846 /* path to the subvolume is specified */
847 objectid = 0;
848 path = argv[optind];
849 } else {
850 /* subvol id and path to the filesystem are specified */
851 objectid = arg_strtou64(argv[optind]);
852 path = argv[optind + 1];
853 }
854
855 err = btrfs_util_set_default_subvolume(path, objectid);
856 if (err) {
857 error_btrfs_util(err);
858 return 1;
859 }
860 return 0;
861 }
862
863 static const char * const cmd_subvol_find_new_usage[] = {
864 "btrfs subvolume find-new <path> <lastgen>",
865 "List the recently modified files in a filesystem",
866 NULL
867 };
868
869 static int cmd_subvol_find_new(int argc, char **argv)
870 {
871 int fd;
872 int ret;
873 char *subvol;
874 u64 last_gen;
875 DIR *dirstream = NULL;
876 enum btrfs_util_error err;
877
878 clean_args_no_options(argc, argv, cmd_subvol_find_new_usage);
879
880 if (check_argc_exact(argc - optind, 2))
881 usage(cmd_subvol_find_new_usage);
882
883 subvol = argv[optind];
884 last_gen = arg_strtou64(argv[optind + 1]);
885
886 err = btrfs_util_is_subvolume(subvol);
887 if (err) {
888 error_btrfs_util(err);
889 return 1;
890 }
891
892 fd = btrfs_open_dir(subvol, &dirstream, 1);
893 if (fd < 0)
894 return 1;
895
896 err = btrfs_util_sync_fd(fd);
897 if (err) {
898 error_btrfs_util(err);
899 close_file_or_dir(fd, dirstream);
900 return 1;
901 }
902
903 ret = btrfs_list_find_updated_files(fd, 0, last_gen);
904 close_file_or_dir(fd, dirstream);
905 return !!ret;
906 }
907
908 static const char * const cmd_subvol_show_usage[] = {
909 "btrfs subvolume show [options] <subvol-path>|<mnt>",
910 "Show more information about the subvolume",
911 "-r|--rootid rootid of the subvolume",
912 "-u|--uuid uuid of the subvolume",
913 "",
914 "If no option is specified, <subvol-path> will be shown, otherwise",
915 "the rootid or uuid are resolved relative to the <mnt> path.",
916 NULL
917 };
918
919 static int cmd_subvol_show(int argc, char **argv)
920 {
921 char tstr[256];
922 char uuidparse[BTRFS_UUID_UNPARSED_SIZE];
923 char *fullpath = NULL;
924 int fd = -1;
925 int ret = 1;
926 DIR *dirstream1 = NULL;
927 int by_rootid = 0;
928 int by_uuid = 0;
929 u64 rootid_arg = 0;
930 u8 uuid_arg[BTRFS_UUID_SIZE];
931 struct btrfs_util_subvolume_iterator *iter;
932 struct btrfs_util_subvolume_info subvol;
933 char *subvol_path = NULL;
934 enum btrfs_util_error err;
935
936 while (1) {
937 int c;
938 static const struct option long_options[] = {
939 { "rootid", required_argument, NULL, 'r'},
940 { "uuid", required_argument, NULL, 'u'},
941 { NULL, 0, NULL, 0 }
942 };
943
944 c = getopt_long(argc, argv, "r:u:", long_options, NULL);
945 if (c < 0)
946 break;
947
948 switch (c) {
949 case 'r':
950 rootid_arg = arg_strtou64(optarg);
951 by_rootid = 1;
952 break;
953 case 'u':
954 uuid_parse(optarg, uuid_arg);
955 by_uuid = 1;
956 break;
957 default:
958 usage(cmd_subvol_show_usage);
959 }
960 }
961
962 if (check_argc_exact(argc - optind, 1))
963 usage(cmd_subvol_show_usage);
964
965 if (by_rootid && by_uuid) {
966 error(
967 "options --rootid and --uuid cannot be used at the same time");
968 usage(cmd_subvol_show_usage);
969 }
970
971 fullpath = realpath(argv[optind], NULL);
972 if (!fullpath) {
973 error("cannot find real path for '%s': %m", argv[optind]);
974 goto out;
975 }
976
977 fd = open_file_or_dir(fullpath, &dirstream1);
978 if (fd < 0) {
979 error("can't access '%s'", fullpath);
980 goto out;
981 }
982
983 if (by_uuid) {
984 err = btrfs_util_create_subvolume_iterator_fd(fd,
985 BTRFS_FS_TREE_OBJECTID,
986 0, &iter);
987 if (err) {
988 error_btrfs_util(err);
989 goto out;
990 }
991
992 for (;;) {
993 err = btrfs_util_subvolume_iterator_next_info(iter,
994 &subvol_path,
995 &subvol);
996 if (err == BTRFS_UTIL_ERROR_STOP_ITERATION) {
997 uuid_unparse(uuid_arg, uuidparse);
998 error("can't find uuid '%s' on '%s'", uuidparse,
999 fullpath);
1000 btrfs_util_destroy_subvolume_iterator(iter);
1001 goto out;
1002 } else if (err) {
1003 error_btrfs_util(err);
1004 btrfs_util_destroy_subvolume_iterator(iter);
1005 goto out;
1006 }
1007
1008 if (uuid_compare(subvol.uuid, uuid_arg) == 0)
1009 break;
1010
1011 free(subvol_path);
1012 }
1013 btrfs_util_destroy_subvolume_iterator(iter);
1014 } else {
1015 /*
1016 * If !by_rootid, rootid_arg = 0, which means find the
1017 * subvolume ID of the fd and use that.
1018 */
1019 err = btrfs_util_subvolume_info_fd(fd, rootid_arg, &subvol);
1020 if (err) {
1021 error_btrfs_util(err);
1022 goto out;
1023 }
1024
1025 err = btrfs_util_subvolume_path_fd(fd, subvol.id, &subvol_path);
1026 if (err) {
1027 error_btrfs_util(err);
1028 goto out;
1029 }
1030
1031 }
1032
1033 /* print the info */
1034 printf("%s\n", subvol.id == BTRFS_FS_TREE_OBJECTID ? "/" : subvol_path);
1035 printf("\tName: \t\t\t%s\n",
1036 (subvol.id == BTRFS_FS_TREE_OBJECTID ? "<FS_TREE>" :
1037 basename(subvol_path)));
1038
1039 if (uuid_is_null(subvol.uuid))
1040 strcpy(uuidparse, "-");
1041 else
1042 uuid_unparse(subvol.uuid, uuidparse);
1043 printf("\tUUID: \t\t\t%s\n", uuidparse);
1044
1045 if (uuid_is_null(subvol.parent_uuid))
1046 strcpy(uuidparse, "-");
1047 else
1048 uuid_unparse(subvol.parent_uuid, uuidparse);
1049 printf("\tParent UUID: \t\t%s\n", uuidparse);
1050
1051 if (uuid_is_null(subvol.received_uuid))
1052 strcpy(uuidparse, "-");
1053 else
1054 uuid_unparse(subvol.received_uuid, uuidparse);
1055 printf("\tReceived UUID: \t\t%s\n", uuidparse);
1056
1057 if (subvol.otime.tv_sec) {
1058 struct tm tm;
1059
1060 localtime_r(&subvol.otime.tv_sec, &tm);
1061 strftime(tstr, 256, "%Y-%m-%d %X %z", &tm);
1062 } else
1063 strcpy(tstr, "-");
1064 printf("\tCreation time: \t\t%s\n", tstr);
1065
1066 printf("\tSubvolume ID: \t\t%" PRIu64 "\n", subvol.id);
1067 printf("\tGeneration: \t\t%" PRIu64 "\n", subvol.generation);
1068 printf("\tGen at creation: \t%" PRIu64 "\n", subvol.otransid);
1069 printf("\tParent ID: \t\t%" PRIu64 "\n", subvol.parent_id);
1070 printf("\tTop level ID: \t\t%" PRIu64 "\n", subvol.parent_id);
1071
1072 if (subvol.flags & BTRFS_ROOT_SUBVOL_RDONLY)
1073 printf("\tFlags: \t\t\treadonly\n");
1074 else
1075 printf("\tFlags: \t\t\t-\n");
1076
1077 /* print the snapshots of the given subvol if any*/
1078 printf("\tSnapshot(s):\n");
1079
1080 err = btrfs_util_create_subvolume_iterator_fd(fd,
1081 BTRFS_FS_TREE_OBJECTID, 0,
1082 &iter);
1083
1084 for (;;) {
1085 struct btrfs_util_subvolume_info subvol2;
1086 char *path;
1087
1088 err = btrfs_util_subvolume_iterator_next_info(iter, &path, &subvol2);
1089 if (err == BTRFS_UTIL_ERROR_STOP_ITERATION) {
1090 break;
1091 } else if (err) {
1092 error_btrfs_util(err);
1093 btrfs_util_destroy_subvolume_iterator(iter);
1094 goto out;
1095 }
1096
1097 if (uuid_compare(subvol2.parent_uuid, subvol.uuid) == 0)
1098 printf("\t\t\t\t%s\n", path);
1099
1100 free(path);
1101 }
1102 btrfs_util_destroy_subvolume_iterator(iter);
1103
1104 ret = 0;
1105 out:
1106 free(subvol_path);
1107 close_file_or_dir(fd, dirstream1);
1108 free(fullpath);
1109 return !!ret;
1110 }
1111
1112 static const char * const cmd_subvol_sync_usage[] = {
1113 "btrfs subvolume sync <path> [<subvol-id>...]",
1114 "Wait until given subvolume(s) are completely removed from the filesystem.",
1115 "Wait until given subvolume(s) are completely removed from the filesystem",
1116 "after deletion.",
1117 "If no subvolume id is given, wait until all current deletion requests",
1118 "are completed, but do not wait for subvolumes deleted meanwhile.",
1119 "The status of subvolume ids is checked periodically.",
1120 "",
1121 "-s <N> sleep N seconds between checks (default: 1)",
1122 NULL
1123 };
1124
1125 static int cmd_subvol_sync(int argc, char **argv)
1126 {
1127 int fd = -1;
1128 int ret = 1;
1129 DIR *dirstream = NULL;
1130 uint64_t *ids = NULL;
1131 size_t id_count, i;
1132 int sleep_interval = 1;
1133 enum btrfs_util_error err;
1134
1135 while (1) {
1136 int c = getopt(argc, argv, "s:");
1137
1138 if (c < 0)
1139 break;
1140
1141 switch (c) {
1142 case 's':
1143 sleep_interval = atoi(optarg);
1144 if (sleep_interval < 1) {
1145 error("invalid sleep interval %s", optarg);
1146 ret = 1;
1147 goto out;
1148 }
1149 break;
1150 default:
1151 usage(cmd_subvol_sync_usage);
1152 }
1153 }
1154
1155 if (check_argc_min(argc - optind, 1))
1156 usage(cmd_subvol_sync_usage);
1157
1158 fd = btrfs_open_dir(argv[optind], &dirstream, 1);
1159 if (fd < 0) {
1160 ret = 1;
1161 goto out;
1162 }
1163 optind++;
1164
1165 id_count = argc - optind;
1166 if (!id_count) {
1167 err = btrfs_util_deleted_subvolumes_fd(fd, &ids, &id_count);
1168 if (err) {
1169 error_btrfs_util(err);
1170 ret = 1;
1171 goto out;
1172 }
1173 if (id_count == 0) {
1174 ret = 0;
1175 goto out;
1176 }
1177 } else {
1178 ids = malloc(id_count * sizeof(uint64_t));
1179 if (!ids) {
1180 error("not enough memory");
1181 ret = 1;
1182 goto out;
1183 }
1184
1185 for (i = 0; i < id_count; i++) {
1186 u64 id;
1187 const char *arg;
1188
1189 arg = argv[optind + i];
1190 errno = 0;
1191 id = strtoull(arg, NULL, 10);
1192 if (errno) {
1193 error("unrecognized subvolume id %s", arg);
1194 ret = 1;
1195 goto out;
1196 }
1197 if (id < BTRFS_FIRST_FREE_OBJECTID ||
1198 id > BTRFS_LAST_FREE_OBJECTID) {
1199 error("subvolume id %s out of range", arg);
1200 ret = 1;
1201 goto out;
1202 }
1203 ids[i] = id;
1204 }
1205 }
1206
1207 ret = wait_for_subvolume_cleaning(fd, id_count, ids, sleep_interval);
1208
1209 out:
1210 free(ids);
1211 close_file_or_dir(fd, dirstream);
1212
1213 return !!ret;
1214 }
1215
1216 static const char subvolume_cmd_group_info[] =
1217 "manage subvolumes: create, delete, list, etc";
1218
1219 const struct cmd_group subvolume_cmd_group = {
1220 subvolume_cmd_group_usage, subvolume_cmd_group_info, {
1221 { "create", cmd_subvol_create, cmd_subvol_create_usage, NULL, 0 },
1222 { "delete", cmd_subvol_delete, cmd_subvol_delete_usage, NULL, 0 },
1223 { "list", cmd_subvol_list, cmd_subvol_list_usage, NULL, 0 },
1224 { "snapshot", cmd_subvol_snapshot, cmd_subvol_snapshot_usage,
1225 NULL, 0 },
1226 { "get-default", cmd_subvol_get_default,
1227 cmd_subvol_get_default_usage, NULL, 0 },
1228 { "set-default", cmd_subvol_set_default,
1229 cmd_subvol_set_default_usage, NULL, 0 },
1230 { "find-new", cmd_subvol_find_new, cmd_subvol_find_new_usage,
1231 NULL, 0 },
1232 { "show", cmd_subvol_show, cmd_subvol_show_usage, NULL, 0 },
1233 { "sync", cmd_subvol_sync, cmd_subvol_sync_usage, NULL, 0 },
1234 NULL_CMD_STRUCT
1235 }
1236 };
1237
1238 int cmd_subvolume(int argc, char **argv)
1239 {
1240 return handle_command_group(&subvolume_cmd_group, argc, argv);
1241 }
(deprecated) Btrfs progs developments and patch integration