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