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