Btrfs-progs: set return value to 0 if subvolume get-default successfully
[platform/upstream/btrfs-progs.git] / cmds-subvolume.c
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 const char * const subvolume_cmd_group_usage[] = {
40         "btrfs subvolume <command> <args>",
41         NULL
42 };
43
44 /*
45  * test if path is a directory
46  * this function return
47  * 0-> path exists but it is not a directory
48  * 1-> path exists and it is  a directory
49  * -1 -> path is unaccessible
50  */
51 static int test_isdir(char *path)
52 {
53         struct stat     st;
54         int             res;
55
56         res = stat(path, &st);
57         if(res < 0 )
58                 return -1;
59
60         return S_ISDIR(st.st_mode);
61 }
62
63 static const char * const cmd_subvol_create_usage[] = {
64         "btrfs subvolume create [-i <qgroupid>] [<dest>/]<name>",
65         "Create a subvolume",
66         "Create a subvolume <name> in <dest>.  If <dest> is not given",
67         "subvolume <name> will be created in the current directory.",
68         "",
69         "-i <qgroupid>  add the newly created subvolume to a qgroup. This",
70         "               option can be given multiple times.",
71         NULL
72 };
73
74 static int cmd_subvol_create(int argc, char **argv)
75 {
76         int     retval, res, len;
77         int     fddst = -1;
78         char    *dupname = NULL;
79         char    *dupdir = NULL;
80         char    *newname;
81         char    *dstdir;
82         char    *dst;
83         struct btrfs_qgroup_inherit *inherit = NULL;
84         DIR     *dirstream = NULL;
85
86         optind = 1;
87         while (1) {
88                 int c = getopt(argc, argv, "c:i:");
89                 if (c < 0)
90                         break;
91
92                 switch (c) {
93                 case 'c':
94                         res = qgroup_inherit_add_copy(&inherit, optarg, 0);
95                         if (res) {
96                                 retval = res;
97                                 goto out;
98                         }
99                         break;
100                 case 'i':
101                         res = qgroup_inherit_add_group(&inherit, optarg);
102                         if (res) {
103                                 retval = res;
104                                 goto out;
105                         }
106                         break;
107                 default:
108                         usage(cmd_subvol_create_usage);
109                 }
110         }
111
112         if (check_argc_exact(argc - optind, 1))
113                 usage(cmd_subvol_create_usage);
114
115         dst = argv[optind];
116
117         retval = 1;     /* failure */
118         res = test_isdir(dst);
119         if (res >= 0) {
120                 fprintf(stderr, "ERROR: '%s' exists\n", dst);
121                 goto out;
122         }
123
124         dupname = strdup(dst);
125         newname = basename(dupname);
126         dupdir = strdup(dst);
127         dstdir = dirname(dupdir);
128
129         if (!strcmp(newname, ".") || !strcmp(newname, "..") ||
130              strchr(newname, '/') ){
131                 fprintf(stderr, "ERROR: uncorrect subvolume name ('%s')\n",
132                         newname);
133                 goto out;
134         }
135
136         len = strlen(newname);
137         if (len == 0 || len >= BTRFS_VOL_NAME_MAX) {
138                 fprintf(stderr, "ERROR: subvolume name too long ('%s)\n",
139                         newname);
140                 goto out;
141         }
142
143         fddst = open_file_or_dir(dstdir, &dirstream);
144         if (fddst < 0) {
145                 fprintf(stderr, "ERROR: can't access to '%s'\n", dstdir);
146                 goto out;
147         }
148
149         printf("Create subvolume '%s/%s'\n", dstdir, newname);
150         if (inherit) {
151                 struct btrfs_ioctl_vol_args_v2  args;
152
153                 memset(&args, 0, sizeof(args));
154                 strncpy_null(args.name, newname);
155                 args.flags |= BTRFS_SUBVOL_QGROUP_INHERIT;
156                 args.size = qgroup_inherit_size(inherit);
157                 args.qgroup_inherit = inherit;
158
159                 res = ioctl(fddst, BTRFS_IOC_SUBVOL_CREATE_V2, &args);
160         } else {
161                 struct btrfs_ioctl_vol_args     args;
162
163                 memset(&args, 0, sizeof(args));
164                 strncpy_null(args.name, newname);
165
166                 res = ioctl(fddst, BTRFS_IOC_SUBVOL_CREATE, &args);
167         }
168
169         if (res < 0) {
170                 fprintf(stderr, "ERROR: cannot create subvolume - %s\n",
171                         strerror(errno));
172                 goto out;
173         }
174
175         retval = 0;     /* success */
176 out:
177         close_file_or_dir(fddst, dirstream);
178         free(inherit);
179         free(dupname);
180         free(dupdir);
181
182         return retval;
183 }
184
185 /*
186  * test if path is a subvolume:
187  * this function return
188  * 0-> path exists but it is not a subvolume
189  * 1-> path exists and it is  a subvolume
190  * -1 -> path is unaccessible
191  */
192 int test_issubvolume(char *path)
193 {
194         struct stat     st;
195         int             res;
196
197         res = stat(path, &st);
198         if(res < 0 )
199                 return -1;
200
201         return (st.st_ino == 256) && S_ISDIR(st.st_mode);
202 }
203
204 static const char * const cmd_subvol_delete_usage[] = {
205         "btrfs subvolume delete <subvolume> [<subvolume>...]",
206         "Delete subvolume(s)",
207         NULL
208 };
209
210 static int cmd_subvol_delete(int argc, char **argv)
211 {
212         int     res, fd, len, e, cnt = 1, ret = 0;
213         struct btrfs_ioctl_vol_args     args;
214         char    *dname, *vname, *cpath;
215         char    *dupdname = NULL;
216         char    *dupvname = NULL;
217         char    *path;
218         DIR     *dirstream = NULL;
219
220         if (argc < 2)
221                 usage(cmd_subvol_delete_usage);
222
223 again:
224         path = argv[cnt];
225
226         res = test_issubvolume(path);
227         if (res < 0) {
228                 fprintf(stderr, "ERROR: error accessing '%s'\n", path);
229                 ret = 1;
230                 goto out;
231         }
232         if (!res) {
233                 fprintf(stderr, "ERROR: '%s' is not a subvolume\n", path);
234                 ret = 1;
235                 goto out;
236         }
237
238         cpath = realpath(path, NULL);
239         if (!cpath) {
240                 ret = errno;
241                 fprintf(stderr, "ERROR: finding real path for '%s': %s\n",
242                         path, strerror(errno));
243                 goto out;
244         }
245         dupdname = strdup(cpath);
246         dname = dirname(dupdname);
247         dupvname = strdup(cpath);
248         vname = basename(dupvname);
249         free(cpath);
250
251         if (!strcmp(vname, ".") || !strcmp(vname, "..") ||
252              strchr(vname, '/')) {
253                 fprintf(stderr, "ERROR: incorrect subvolume name ('%s')\n",
254                         vname);
255                 ret = 1;
256                 goto out;
257         }
258
259         len = strlen(vname);
260         if (len == 0 || len >= BTRFS_VOL_NAME_MAX) {
261                 fprintf(stderr, "ERROR: snapshot name too long ('%s)\n",
262                         vname);
263                 ret = 1;
264                 goto out;
265         }
266
267         fd = open_file_or_dir(dname, &dirstream);
268         if (fd < 0) {
269                 fprintf(stderr, "ERROR: can't access to '%s'\n", dname);
270                 ret = 1;
271                 goto out;
272         }
273
274         printf("Delete subvolume '%s/%s'\n", dname, vname);
275         strncpy_null(args.name, vname);
276         res = ioctl(fd, BTRFS_IOC_SNAP_DESTROY, &args);
277         e = errno;
278
279         close_file_or_dir(fd, dirstream);
280
281         if(res < 0 ){
282                 fprintf( stderr, "ERROR: cannot delete '%s/%s' - %s\n",
283                         dname, vname, strerror(e));
284                 ret = 1;
285                 goto out;
286         }
287
288 out:
289         free(dupdname);
290         free(dupvname);
291         cnt++;
292         if (cnt < argc)
293                 goto again;
294
295         return ret;
296 }
297
298 /*
299  * Naming of options:
300  * - uppercase for filters and sort options
301  * - lowercase for enabling specific items in the output
302  */
303 static const char * const cmd_subvol_list_usage[] = {
304         "btrfs subvolume list [options] [-G [+|-]value] [-C [+|-]value] "
305         "[--sort=gen,ogen,rootid,path] <path>",
306         "List subvolumes (and snapshots)",
307         "",
308         "-p           print parent ID",
309         "-a           print all the subvolumes in the filesystem and",
310         "             distinguish absolute and relative path with respect",
311         "             to the given <path>",
312         "-c           print the ogeneration of the subvolume",
313         "-g           print the generation of the subvolume",
314         "-o           print only subvolumes bellow specified path",
315         "-u           print the uuid of subvolumes (and snapshots)",
316         "-q           print the parent uuid of the snapshots",
317         "-t           print the result as a table",
318         "-s           list snapshots only in the filesystem",
319         "-r           list readonly subvolumes (including snapshots)",
320         "-d           list deleted subvolumes that are not yet cleaned",
321         "-G [+|-]value",
322         "             filter the subvolumes by generation",
323         "             (+value: >= value; -value: <= value; value: = value)",
324         "-C [+|-]value",
325         "             filter the subvolumes by ogeneration",
326         "             (+value: >= value; -value: <= value; value: = value)",
327         "--sort=gen,ogen,rootid,path",
328         "             list the subvolume in order of gen, ogen, rootid or path",
329         "             you also can add '+' or '-' in front of each items.",
330         "             (+:ascending, -:descending, ascending default)",
331         NULL,
332 };
333
334 static int cmd_subvol_list(int argc, char **argv)
335 {
336         struct btrfs_list_filter_set *filter_set;
337         struct btrfs_list_comparer_set *comparer_set;
338         u64 flags = 0;
339         int fd = -1;
340         u64 top_id;
341         int ret = -1, uerr = 0;
342         int c;
343         char *subvol;
344         int is_tab_result = 0;
345         int is_list_all = 0;
346         int is_only_in_path = 0;
347         struct option long_options[] = {
348                 {"sort", 1, NULL, 'S'},
349                 {NULL, 0, NULL, 0}
350         };
351         DIR *dirstream = NULL;
352
353         filter_set = btrfs_list_alloc_filter_set();
354         comparer_set = btrfs_list_alloc_comparer_set();
355
356         optind = 1;
357         while(1) {
358                 c = getopt_long(argc, argv,
359                                     "acdgopqsurG:C:t", long_options, NULL);
360                 if (c < 0)
361                         break;
362
363                 switch(c) {
364                 case 'p':
365                         btrfs_list_setup_print_column(BTRFS_LIST_PARENT);
366                         break;
367                 case 'a':
368                         is_list_all = 1;
369                         break;
370                 case 'c':
371                         btrfs_list_setup_print_column(BTRFS_LIST_OGENERATION);
372                         break;
373                 case 'd':
374                         btrfs_list_setup_filter(&filter_set,
375                                                 BTRFS_LIST_FILTER_DELETED,
376                                                 0);
377                         break;
378                 case 'g':
379                         btrfs_list_setup_print_column(BTRFS_LIST_GENERATION);
380                         break;
381                 case 'o':
382                         is_only_in_path = 1;
383                         break;
384                 case 't':
385                         is_tab_result = 1;
386                         break;
387                 case 's':
388                         btrfs_list_setup_filter(&filter_set,
389                                                 BTRFS_LIST_FILTER_SNAPSHOT_ONLY,
390                                                 0);
391                         btrfs_list_setup_print_column(BTRFS_LIST_OGENERATION);
392                         btrfs_list_setup_print_column(BTRFS_LIST_OTIME);
393                         break;
394                 case 'u':
395                         btrfs_list_setup_print_column(BTRFS_LIST_UUID);
396                         break;
397                 case 'q':
398                         btrfs_list_setup_print_column(BTRFS_LIST_PUUID);
399                         break;
400                 case 'r':
401                         flags |= BTRFS_ROOT_SUBVOL_RDONLY;
402                         break;
403                 case 'G':
404                         btrfs_list_setup_print_column(BTRFS_LIST_GENERATION);
405                         ret = btrfs_list_parse_filter_string(optarg,
406                                                         &filter_set,
407                                                         BTRFS_LIST_FILTER_GEN);
408                         if (ret) {
409                                 uerr = 1;
410                                 goto out;
411                         }
412                         break;
413
414                 case 'C':
415                         btrfs_list_setup_print_column(BTRFS_LIST_OGENERATION);
416                         ret = btrfs_list_parse_filter_string(optarg,
417                                                         &filter_set,
418                                                         BTRFS_LIST_FILTER_CGEN);
419                         if (ret) {
420                                 uerr = 1;
421                                 goto out;
422                         }
423                         break;
424                 case 'S':
425                         ret = btrfs_list_parse_sort_string(optarg,
426                                                            &comparer_set);
427                         if (ret) {
428                                 uerr = 1;
429                                 goto out;
430                         }
431                         break;
432
433                 default:
434                         uerr = 1;
435                         goto out;
436                 }
437         }
438
439         if (flags)
440                 btrfs_list_setup_filter(&filter_set, BTRFS_LIST_FILTER_FLAGS,
441                                         flags);
442
443         if (check_argc_exact(argc - optind, 1)) {
444                 uerr = 1;
445                 goto out;
446         }
447
448         subvol = argv[optind];
449         fd = open_file_or_dir(subvol, &dirstream);
450         if (fd < 0) {
451                 ret = -1;
452                 fprintf(stderr, "ERROR: can't access '%s'\n", subvol);
453                 goto out;
454         }
455
456         ret = btrfs_list_get_path_rootid(fd, &top_id);
457         if (ret) {
458                 fprintf(stderr, "ERROR: can't get rootid for '%s'\n", subvol);
459                 goto out;
460         }
461
462         if (is_list_all)
463                 btrfs_list_setup_filter(&filter_set,
464                                         BTRFS_LIST_FILTER_FULL_PATH,
465                                         top_id);
466         else if (is_only_in_path)
467                 btrfs_list_setup_filter(&filter_set,
468                                         BTRFS_LIST_FILTER_TOPID_EQUAL,
469                                         top_id);
470
471         /* by default we shall print the following columns*/
472         btrfs_list_setup_print_column(BTRFS_LIST_OBJECTID);
473         btrfs_list_setup_print_column(BTRFS_LIST_GENERATION);
474         btrfs_list_setup_print_column(BTRFS_LIST_TOP_LEVEL);
475         btrfs_list_setup_print_column(BTRFS_LIST_PATH);
476
477         if (is_tab_result)
478                 ret = btrfs_list_subvols_print(fd, filter_set, comparer_set,
479                                 BTRFS_LIST_LAYOUT_TABLE,
480                                 !is_list_all && !is_only_in_path, NULL);
481         else
482                 ret = btrfs_list_subvols_print(fd, filter_set, comparer_set,
483                                 BTRFS_LIST_LAYOUT_DEFAULT,
484                                 !is_list_all && !is_only_in_path, NULL);
485
486 out:
487         close_file_or_dir(fd, dirstream);
488         if (filter_set)
489                 btrfs_list_free_filter_set(filter_set);
490         if (comparer_set)
491                 btrfs_list_free_comparer_set(comparer_set);
492         if (uerr)
493                 usage(cmd_subvol_list_usage);
494         return !!ret;
495 }
496
497 static const char * const cmd_snapshot_usage[] = {
498         "btrfs subvolume snapshot [-r] <source> <dest>|[<dest>/]<name>",
499         "btrfs subvolume snapshot [-r] [-i <qgroupid>] <source> <dest>|[<dest>/]<name>",
500         "Create a snapshot of the subvolume",
501         "Create a writable/readonly snapshot of the subvolume <source> with",
502         "the name <name> in the <dest> directory.  If only <dest> is given,",
503         "the subvolume will be named the basename of <source>.",
504         "",
505         "-r             create a readonly snapshot",
506         "-i <qgroupid>  add the newly created snapshot to a qgroup. This",
507         "               option can be given multiple times.",
508         NULL
509 };
510
511 static int cmd_snapshot(int argc, char **argv)
512 {
513         char    *subvol, *dst;
514         int     res, retval;
515         int     fd = -1, fddst = -1;
516         int     len, readonly = 0;
517         char    *dupname = NULL;
518         char    *dupdir = NULL;
519         char    *newname;
520         char    *dstdir;
521         struct btrfs_ioctl_vol_args_v2  args;
522         struct btrfs_qgroup_inherit *inherit = NULL;
523         DIR *dirstream1 = NULL, *dirstream2 = NULL;
524
525         optind = 1;
526         memset(&args, 0, sizeof(args));
527         while (1) {
528                 int c = getopt(argc, argv, "c:i:r");
529                 if (c < 0)
530                         break;
531
532                 switch (c) {
533                 case 'c':
534                         res = qgroup_inherit_add_copy(&inherit, optarg, 0);
535                         if (res) {
536                                 retval = res;
537                                 goto out;
538                         }
539                         break;
540                 case 'i':
541                         res = qgroup_inherit_add_group(&inherit, optarg);
542                         if (res) {
543                                 retval = res;
544                                 goto out;
545                         }
546                         break;
547                 case 'r':
548                         readonly = 1;
549                         break;
550                 case 'x':
551                         res = qgroup_inherit_add_copy(&inherit, optarg, 1);
552                         if (res) {
553                                 retval = res;
554                                 goto out;
555                         }
556                         break;
557                 default:
558                         usage(cmd_snapshot_usage);
559                 }
560         }
561
562         if (check_argc_exact(argc - optind, 2))
563                 usage(cmd_snapshot_usage);
564
565         subvol = argv[optind];
566         dst = argv[optind + 1];
567
568         retval = 1;     /* failure */
569         res = test_issubvolume(subvol);
570         if (res < 0) {
571                 fprintf(stderr, "ERROR: error accessing '%s'\n", subvol);
572                 goto out;
573         }
574         if (!res) {
575                 fprintf(stderr, "ERROR: '%s' is not a subvolume\n", subvol);
576                 goto out;
577         }
578
579         res = test_isdir(dst);
580         if (res == 0) {
581                 fprintf(stderr, "ERROR: '%s' exists and it is not a directory\n", dst);
582                 goto out;
583         }
584
585         if (res > 0) {
586                 dupname = strdup(subvol);
587                 newname = basename(dupname);
588                 dstdir = dst;
589         } else {
590                 dupname = strdup(dst);
591                 newname = basename(dupname);
592                 dupdir = strdup(dst);
593                 dstdir = dirname(dupdir);
594         }
595
596         if (!strcmp(newname, ".") || !strcmp(newname, "..") ||
597              strchr(newname, '/') ){
598                 fprintf(stderr, "ERROR: incorrect snapshot name ('%s')\n",
599                         newname);
600                 goto out;
601         }
602
603         len = strlen(newname);
604         if (len == 0 || len >= BTRFS_VOL_NAME_MAX) {
605                 fprintf(stderr, "ERROR: snapshot name too long ('%s)\n",
606                         newname);
607                 goto out;
608         }
609
610         fddst = open_file_or_dir(dstdir, &dirstream1);
611         if (fddst < 0) {
612                 fprintf(stderr, "ERROR: can't access to '%s'\n", dstdir);
613                 goto out;
614         }
615
616         fd = open_file_or_dir(subvol, &dirstream2);
617         if (fd < 0) {
618                 fprintf(stderr, "ERROR: can't access to '%s'\n", dstdir);
619                 goto out;
620         }
621
622         if (readonly) {
623                 args.flags |= BTRFS_SUBVOL_RDONLY;
624                 printf("Create a readonly snapshot of '%s' in '%s/%s'\n",
625                        subvol, dstdir, newname);
626         } else {
627                 printf("Create a snapshot of '%s' in '%s/%s'\n",
628                        subvol, dstdir, newname);
629         }
630
631         args.fd = fd;
632         if (inherit) {
633                 args.flags |= BTRFS_SUBVOL_QGROUP_INHERIT;
634                 args.size = qgroup_inherit_size(inherit);
635                 args.qgroup_inherit = inherit;
636         }
637         strncpy_null(args.name, newname);
638
639         res = ioctl(fddst, BTRFS_IOC_SNAP_CREATE_V2, &args);
640
641         if (res < 0) {
642                 fprintf( stderr, "ERROR: cannot snapshot '%s' - %s\n",
643                         subvol, strerror(errno));
644                 goto out;
645         }
646
647         retval = 0;     /* success */
648
649 out:
650         close_file_or_dir(fddst, dirstream1);
651         close_file_or_dir(fd, dirstream2);
652         free(inherit);
653         free(dupname);
654         free(dupdir);
655
656         return retval;
657 }
658
659 static const char * const cmd_subvol_get_default_usage[] = {
660         "btrfs subvolume get-default <path>",
661         "Get the default subvolume of a filesystem",
662         NULL
663 };
664
665 static int cmd_subvol_get_default(int argc, char **argv)
666 {
667         int fd = -1;
668         int ret;
669         char *subvol;
670         struct btrfs_list_filter_set *filter_set;
671         u64 default_id;
672         DIR *dirstream = NULL;
673
674         if (check_argc_exact(argc, 2))
675                 usage(cmd_subvol_get_default_usage);
676
677         subvol = argv[1];
678         fd = open_file_or_dir(subvol, &dirstream);
679         if (fd < 0) {
680                 fprintf(stderr, "ERROR: can't access '%s'\n", subvol);
681                 return 1;
682         }
683
684         ret = btrfs_list_get_default_subvolume(fd, &default_id);
685         if (ret) {
686                 fprintf(stderr, "ERROR: can't perform the search - %s\n",
687                         strerror(errno));
688                 goto out;
689         }
690
691         ret = 1;
692         if (default_id == 0) {
693                 fprintf(stderr, "ERROR: 'default' dir item not found\n");
694                 goto out;
695         }
696
697         /* no need to resolve roots if FS_TREE is default */
698         if (default_id == BTRFS_FS_TREE_OBJECTID) {
699                 printf("ID 5 (FS_TREE)\n");
700                 ret = 0;
701                 goto out;
702         }
703
704         filter_set = btrfs_list_alloc_filter_set();
705         btrfs_list_setup_filter(&filter_set, BTRFS_LIST_FILTER_ROOTID,
706                                 default_id);
707
708         /* by default we shall print the following columns*/
709         btrfs_list_setup_print_column(BTRFS_LIST_OBJECTID);
710         btrfs_list_setup_print_column(BTRFS_LIST_GENERATION);
711         btrfs_list_setup_print_column(BTRFS_LIST_TOP_LEVEL);
712         btrfs_list_setup_print_column(BTRFS_LIST_PATH);
713
714         ret = btrfs_list_subvols_print(fd, filter_set, NULL,
715                 BTRFS_LIST_LAYOUT_DEFAULT, 1, NULL);
716
717         if (filter_set)
718                 btrfs_list_free_filter_set(filter_set);
719 out:
720         close_file_or_dir(fd, dirstream);
721         return !!ret;
722 }
723
724 static const char * const cmd_subvol_set_default_usage[] = {
725         "btrfs subvolume set-default <subvolid> <path>",
726         "Set the default subvolume of a filesystem",
727         NULL
728 };
729
730 static int cmd_subvol_set_default(int argc, char **argv)
731 {
732         int     ret=0, fd, e;
733         u64     objectid;
734         char    *path;
735         char    *subvolid;
736         DIR     *dirstream = NULL;
737
738         if (check_argc_exact(argc, 3))
739                 usage(cmd_subvol_set_default_usage);
740
741         subvolid = argv[1];
742         path = argv[2];
743
744         objectid = (unsigned long long)strtoll(subvolid, NULL, 0);
745         if (errno == ERANGE) {
746                 fprintf(stderr, "ERROR: invalid tree id (%s)\n", subvolid);
747                 return 1;
748         }
749
750         fd = open_file_or_dir(path, &dirstream);
751         if (fd < 0) {
752                 fprintf(stderr, "ERROR: can't access to '%s'\n", path);
753                 return 1;
754         }
755
756         ret = ioctl(fd, BTRFS_IOC_DEFAULT_SUBVOL, &objectid);
757         e = errno;
758         close_file_or_dir(fd, dirstream);
759         if (ret < 0) {
760                 fprintf(stderr, "ERROR: unable to set a new default subvolume - %s\n",
761                         strerror(e));
762                 return 1;
763         }
764         return 0;
765 }
766
767 static const char * const cmd_find_new_usage[] = {
768         "btrfs subvolume find-new <path> <lastgen>",
769         "List the recently modified files in a filesystem",
770         NULL
771 };
772
773 static int cmd_find_new(int argc, char **argv)
774 {
775         int fd;
776         int ret;
777         char *subvol;
778         u64 last_gen;
779         DIR *dirstream = NULL;
780
781         if (check_argc_exact(argc, 3))
782                 usage(cmd_find_new_usage);
783
784         subvol = argv[1];
785         last_gen = atoll(argv[2]);
786
787         ret = test_issubvolume(subvol);
788         if (ret < 0) {
789                 fprintf(stderr, "ERROR: error accessing '%s'\n", subvol);
790                 return 1;
791         }
792         if (!ret) {
793                 fprintf(stderr, "ERROR: '%s' is not a subvolume\n", subvol);
794                 return 1;
795         }
796
797         fd = open_file_or_dir(subvol, &dirstream);
798         if (fd < 0) {
799                 fprintf(stderr, "ERROR: can't access '%s'\n", subvol);
800                 return 1;
801         }
802
803         ret = ioctl(fd, BTRFS_IOC_SYNC);
804         if (ret < 0) {
805                 fprintf(stderr, "ERROR: unable to fs-syncing '%s' - %s\n",
806                         subvol, strerror(errno));
807                 close_file_or_dir(fd, dirstream);
808                 return 1;
809         }
810
811         ret = btrfs_list_find_updated_files(fd, 0, last_gen);
812         close_file_or_dir(fd, dirstream);
813         return !!ret;
814 }
815
816 static const char * const cmd_subvol_show_usage[] = {
817         "btrfs subvolume show <subvol-path>",
818         "Show more information of the subvolume",
819         NULL
820 };
821
822 static int cmd_subvol_show(int argc, char **argv)
823 {
824         struct root_info get_ri;
825         struct btrfs_list_filter_set *filter_set;
826         char tstr[256];
827         char uuidparse[37];
828         char *fullpath = NULL, *svpath = NULL, *mnt = NULL;
829         char raw_prefix[] = "\t\t\t\t";
830         u64 sv_id, mntid;
831         int fd = -1, mntfd = -1;
832         int ret = 1;
833         DIR *dirstream1 = NULL, *dirstream2 = NULL;
834
835         if (check_argc_exact(argc, 2))
836                 usage(cmd_subvol_show_usage);
837
838         fullpath = realpath(argv[1], NULL);
839         if (!fullpath) {
840                 fprintf(stderr, "ERROR: finding real path for '%s', %s\n",
841                         argv[1], strerror(errno));
842                 goto out;
843         }
844
845         ret = test_issubvolume(fullpath);
846         if (ret < 0) {
847                 fprintf(stderr, "ERROR: error accessing '%s'\n", fullpath);
848                 goto out;
849         }
850         if (!ret) {
851                 fprintf(stderr, "ERROR: '%s' is not a subvolume\n", fullpath);
852                 goto out;
853         }
854
855         ret = find_mount_root(fullpath, &mnt);
856         if (ret < 0) {
857                 fprintf(stderr, "ERROR: find_mount_root failed on %s: "
858                                 "%s\n", fullpath, strerror(-ret));
859                 goto out;
860         }
861         ret = 1;
862         svpath = get_subvol_name(mnt, fullpath);
863
864         fd = open_file_or_dir(fullpath, &dirstream1);
865         if (fd < 0) {
866                 fprintf(stderr, "ERROR: can't access '%s'\n", fullpath);
867                 goto out;
868         }
869
870         ret = btrfs_list_get_path_rootid(fd, &sv_id);
871         if (ret) {
872                 fprintf(stderr, "ERROR: can't get rootid for '%s'\n",
873                         fullpath);
874                 goto out;
875         }
876
877         mntfd = open_file_or_dir(mnt, &dirstream2);
878         if (mntfd < 0) {
879                 fprintf(stderr, "ERROR: can't access '%s'\n", mnt);
880                 goto out;
881         }
882
883         ret = btrfs_list_get_path_rootid(mntfd, &mntid);
884         if (ret) {
885                 fprintf(stderr, "ERROR: can't get rootid for '%s'\n", mnt);
886                 goto out;
887         }
888
889         if (sv_id == BTRFS_FS_TREE_OBJECTID) {
890                 printf("%s is btrfs root\n", fullpath);
891                 goto out;
892         }
893
894         memset(&get_ri, 0, sizeof(get_ri));
895         get_ri.root_id = sv_id;
896
897         if (btrfs_get_subvol(mntfd, &get_ri)) {
898                 fprintf(stderr, "ERROR: can't find '%s'\n",
899                         svpath);
900                 goto out;
901         }
902
903         ret = 0;
904         /* print the info */
905         printf("%s\n", fullpath);
906         printf("\tName: \t\t\t%s\n", get_ri.name);
907
908         if (uuid_is_null(get_ri.uuid))
909                 strcpy(uuidparse, "-");
910         else
911                 uuid_unparse(get_ri.uuid, uuidparse);
912         printf("\tuuid: \t\t\t%s\n", uuidparse);
913
914         if (uuid_is_null(get_ri.puuid))
915                 strcpy(uuidparse, "-");
916         else
917                 uuid_unparse(get_ri.puuid, uuidparse);
918         printf("\tParent uuid: \t\t%s\n", uuidparse);
919
920         if (get_ri.otime) {
921                 struct tm tm;
922
923                 localtime_r(&get_ri.otime, &tm);
924                 strftime(tstr, 256, "%Y-%m-%d %X", &tm);
925         } else
926                 strcpy(tstr, "-");
927         printf("\tCreation time: \t\t%s\n", tstr);
928
929         printf("\tObject ID: \t\t%llu\n", get_ri.root_id);
930         printf("\tGeneration (Gen): \t%llu\n", get_ri.gen);
931         printf("\tGen at creation: \t%llu\n", get_ri.ogen);
932         printf("\tParent: \t\t%llu\n", get_ri.ref_tree);
933         printf("\tTop Level: \t\t%llu\n", get_ri.top_id);
934
935         if (get_ri.flags & BTRFS_ROOT_SUBVOL_RDONLY)
936                 printf("\tFlags: \t\t\treadonly\n");
937         else
938                 printf("\tFlags: \t\t\t-\n");
939
940         /* print the snapshots of the given subvol if any*/
941         printf("\tSnapshot(s):\n");
942         filter_set = btrfs_list_alloc_filter_set();
943         btrfs_list_setup_filter(&filter_set, BTRFS_LIST_FILTER_BY_PARENT,
944                                 (u64)(unsigned long)get_ri.uuid);
945         btrfs_list_setup_print_column(BTRFS_LIST_PATH);
946         btrfs_list_subvols_print(fd, filter_set, NULL, BTRFS_LIST_LAYOUT_RAW,
947                         1, raw_prefix);
948
949         /* clean up */
950         if (get_ri.path)
951                 free(get_ri.path);
952         if (get_ri.name)
953                 free(get_ri.name);
954         if (get_ri.full_path)
955                 free(get_ri.full_path);
956         if (filter_set)
957                 btrfs_list_free_filter_set(filter_set);
958
959 out:
960         close_file_or_dir(fd, dirstream1);
961         close_file_or_dir(mntfd, dirstream2);
962         if (mnt)
963                 free(mnt);
964         if (fullpath)
965                 free(fullpath);
966         return !!ret;
967 }
968
969 const struct cmd_group subvolume_cmd_group = {
970         subvolume_cmd_group_usage, NULL, {
971                 { "create", cmd_subvol_create, cmd_subvol_create_usage, NULL, 0 },
972                 { "delete", cmd_subvol_delete, cmd_subvol_delete_usage, NULL, 0 },
973                 { "list", cmd_subvol_list, cmd_subvol_list_usage, NULL, 0 },
974                 { "snapshot", cmd_snapshot, cmd_snapshot_usage, NULL, 0 },
975                 { "get-default", cmd_subvol_get_default,
976                         cmd_subvol_get_default_usage, NULL, 0 },
977                 { "set-default", cmd_subvol_set_default,
978                         cmd_subvol_set_default_usage, NULL, 0 },
979                 { "find-new", cmd_find_new, cmd_find_new_usage, NULL, 0 },
980                 { "show", cmd_subvol_show, cmd_subvol_show_usage, NULL, 0 },
981                 NULL_CMD_STRUCT
982         }
983 };
984
985 int cmd_subvolume(int argc, char **argv)
986 {
987         return handle_command_group(&subvolume_cmd_group, argc, argv);
988 }