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