461eed902752fae8c0e5d3f590385f3733365012
[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 = -1;
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 1;
642         }
643         if (!ret) {
644                 fprintf(stderr, "ERROR: '%s' is not a subvolume\n", subvol);
645                 return 1;
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 1;
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                 goto out;
659         }
660
661         ret = 1;
662         if (default_id == 0) {
663                 fprintf(stderr, "ERROR: 'default' dir item not found\n");
664                 goto out;
665         }
666
667         /* no need to resolve roots if FS_TREE is default */
668         if (default_id == BTRFS_FS_TREE_OBJECTID) {
669                 printf("ID 5 (FS_TREE)\n");
670                 goto out;
671         }
672
673         filter_set = btrfs_list_alloc_filter_set();
674         btrfs_list_setup_filter(&filter_set, BTRFS_LIST_FILTER_ROOTID,
675                                 default_id);
676
677         /* by default we shall print the following columns*/
678         btrfs_list_setup_print_column(BTRFS_LIST_OBJECTID);
679         btrfs_list_setup_print_column(BTRFS_LIST_GENERATION);
680         btrfs_list_setup_print_column(BTRFS_LIST_TOP_LEVEL);
681         btrfs_list_setup_print_column(BTRFS_LIST_PATH);
682
683         ret = btrfs_list_subvols_print(fd, filter_set, NULL,
684                 BTRFS_LIST_LAYOUT_DEFAULT, 1, NULL);
685
686         if (filter_set)
687                 btrfs_list_free_filter_set(filter_set);
688 out:
689         if (fd != -1)
690                 close(fd);
691         if (ret)
692                 return 1;
693         return 0;
694 }
695
696 static const char * const cmd_subvol_set_default_usage[] = {
697         "btrfs subvolume set-default <subvolid> <path>",
698         "Set the default subvolume of a filesystem",
699         NULL
700 };
701
702 static int cmd_subvol_set_default(int argc, char **argv)
703 {
704         int     ret=0, fd, e;
705         u64     objectid;
706         char    *path;
707         char    *subvolid;
708
709         if (check_argc_exact(argc, 3))
710                 usage(cmd_subvol_set_default_usage);
711
712         subvolid = argv[1];
713         path = argv[2];
714
715         objectid = (unsigned long long)strtoll(subvolid, NULL, 0);
716         if (errno == ERANGE) {
717                 fprintf(stderr, "ERROR: invalid tree id (%s)\n", subvolid);
718                 return 1;
719         }
720
721         fd = open_file_or_dir(path);
722         if (fd < 0) {
723                 fprintf(stderr, "ERROR: can't access to '%s'\n", path);
724                 return 1;
725         }
726
727         ret = ioctl(fd, BTRFS_IOC_DEFAULT_SUBVOL, &objectid);
728         e = errno;
729         close(fd);
730         if (ret < 0) {
731                 fprintf(stderr, "ERROR: unable to set a new default subvolume - %s\n",
732                         strerror(e));
733                 return 1;
734         }
735         return 0;
736 }
737
738 static const char * const cmd_find_new_usage[] = {
739         "btrfs subvolume find-new <path> <lastgen>",
740         "List the recently modified files in a filesystem",
741         NULL
742 };
743
744 static int cmd_find_new(int argc, char **argv)
745 {
746         int fd;
747         int ret;
748         char *subvol;
749         u64 last_gen;
750
751         if (check_argc_exact(argc, 3))
752                 usage(cmd_find_new_usage);
753
754         subvol = argv[1];
755         last_gen = atoll(argv[2]);
756
757         ret = test_issubvolume(subvol);
758         if (ret < 0) {
759                 fprintf(stderr, "ERROR: error accessing '%s'\n", subvol);
760                 return 12;
761         }
762         if (!ret) {
763                 fprintf(stderr, "ERROR: '%s' is not a subvolume\n", subvol);
764                 return 13;
765         }
766
767         fd = open_file_or_dir(subvol);
768         if (fd < 0) {
769                 fprintf(stderr, "ERROR: can't access '%s'\n", subvol);
770                 return 12;
771         }
772         ret = btrfs_list_find_updated_files(fd, 0, last_gen);
773         close(fd);
774         if (ret)
775                 return 19;
776         return 0;
777 }
778
779 static const char * const cmd_subvol_show_usage[] = {
780         "btrfs subvolume show <subvol-path>",
781         "Show more information of the subvolume",
782         NULL
783 };
784
785 static int cmd_subvol_show(int argc, char **argv)
786 {
787         struct root_info get_ri;
788         struct btrfs_list_filter_set *filter_set;
789         char tstr[256];
790         char uuidparse[37];
791         char *fullpath = NULL, *svpath = NULL, *mnt = NULL;
792         char raw_prefix[] = "\t\t\t\t";
793         u64 sv_id, mntid;
794         int fd = -1, mntfd = -1;
795         int ret = -1;
796
797         if (check_argc_exact(argc, 2))
798                 usage(cmd_subvol_show_usage);
799
800         fullpath = realpath(argv[1], 0);
801         if (!fullpath) {
802                 fprintf(stderr, "ERROR: finding real path for '%s', %s\n",
803                         argv[1], strerror(errno));
804                 goto out;
805         }
806
807         ret = test_issubvolume(fullpath);
808         if (ret < 0) {
809                 fprintf(stderr, "ERROR: error accessing '%s'\n", fullpath);
810                 goto out;
811         }
812         if (!ret) {
813                 fprintf(stderr, "ERROR: '%s' is not a subvolume\n", fullpath);
814                 ret = -1;
815                 goto out;
816         }
817
818         ret = find_mount_root(fullpath, &mnt);
819         if (ret < 0) {
820                 fprintf(stderr, "ERROR: find_mount_root failed on %s: "
821                                 "%s\n", fullpath, strerror(-ret));
822                 goto out;
823         }
824         ret = -1;
825         svpath = get_subvol_name(mnt, fullpath);
826
827         fd = open_file_or_dir(fullpath);
828         if (fd < 0) {
829                 fprintf(stderr, "ERROR: can't access '%s'\n", fullpath);
830                 goto out;
831         }
832
833         ret = btrfs_list_get_path_rootid(fd, &sv_id);
834         if (ret) {
835                 fprintf(stderr, "ERROR: can't get rootid for '%s'\n",
836                         fullpath);
837                 goto out;
838         }
839
840         mntfd = open_file_or_dir(mnt);
841         if (mntfd < 0) {
842                 fprintf(stderr, "ERROR: can't access '%s'\n", mnt);
843                 goto out;
844         }
845
846         ret = btrfs_list_get_path_rootid(mntfd, &mntid);
847         if (ret) {
848                 fprintf(stderr, "ERROR: can't get rootid for '%s'\n", mnt);
849                 goto out;
850         }
851
852         if (sv_id == BTRFS_FS_TREE_OBJECTID) {
853                 printf("%s is btrfs root\n", fullpath);
854                 goto out;
855         }
856
857         memset(&get_ri, 0, sizeof(get_ri));
858         get_ri.root_id = sv_id;
859
860         if (btrfs_get_subvol(mntfd, &get_ri)) {
861                 fprintf(stderr, "ERROR: can't find '%s'\n",
862                         svpath);
863                 goto out;
864         }
865
866         ret = 0;
867         /* print the info */
868         printf("%s\n", fullpath);
869         printf("\tName: \t\t\t%s\n", get_ri.name);
870
871         if (uuid_is_null(get_ri.uuid))
872                 strcpy(uuidparse, "-");
873         else
874                 uuid_unparse(get_ri.uuid, uuidparse);
875         printf("\tuuid: \t\t\t%s\n", uuidparse);
876
877         if (uuid_is_null(get_ri.puuid))
878                 strcpy(uuidparse, "-");
879         else
880                 uuid_unparse(get_ri.puuid, uuidparse);
881         printf("\tParent uuid: \t\t%s\n", uuidparse);
882
883         if (get_ri.otime)
884                 strftime(tstr, 256, "%Y-%m-%d %X",
885                          localtime(&get_ri.otime));
886         else
887                 strcpy(tstr, "-");
888         printf("\tCreation time: \t\t%s\n", tstr);
889
890         printf("\tObject ID: \t\t%llu\n", get_ri.root_id);
891         printf("\tGeneration (Gen): \t%llu\n", get_ri.gen);
892         printf("\tGen at creation: \t%llu\n", get_ri.ogen);
893         printf("\tParent: \t\t%llu\n", get_ri.ref_tree);
894         printf("\tTop Level: \t\t%llu\n", get_ri.top_id);
895
896         if (get_ri.flags & BTRFS_ROOT_SUBVOL_RDONLY)
897                 printf("\tFlags: \t\t\treadonly\n");
898         else
899                 printf("\tFlags: \t\t\t-\n");
900
901         /* print the snapshots of the given subvol if any*/
902         printf("\tSnapshot(s):\n");
903         filter_set = btrfs_list_alloc_filter_set();
904         btrfs_list_setup_filter(&filter_set, BTRFS_LIST_FILTER_BY_PARENT,
905                                 (u64)get_ri.uuid);
906         btrfs_list_setup_print_column(BTRFS_LIST_PATH);
907         btrfs_list_subvols_print(fd, filter_set, NULL, BTRFS_LIST_LAYOUT_RAW,
908                         1, raw_prefix);
909
910         /* clean up */
911         if (get_ri.path)
912                 free(get_ri.path);
913         if (get_ri.name)
914                 free(get_ri.name);
915         if (get_ri.full_path)
916                 free(get_ri.full_path);
917         if (filter_set)
918                 btrfs_list_free_filter_set(filter_set);
919
920 out:
921         if (mntfd >= 0)
922                 close(mntfd);
923         if (fd >= 0)
924                 close(fd);
925         if (mnt)
926                 free(mnt);
927         if (fullpath)
928                 free(fullpath);
929
930         return ret;
931 }
932
933 const struct cmd_group subvolume_cmd_group = {
934         subvolume_cmd_group_usage, NULL, {
935                 { "create", cmd_subvol_create, cmd_subvol_create_usage, NULL, 0 },
936                 { "delete", cmd_subvol_delete, cmd_subvol_delete_usage, NULL, 0 },
937                 { "list", cmd_subvol_list, cmd_subvol_list_usage, NULL, 0 },
938                 { "snapshot", cmd_snapshot, cmd_snapshot_usage, NULL, 0 },
939                 { "get-default", cmd_subvol_get_default,
940                         cmd_subvol_get_default_usage, NULL, 0 },
941                 { "set-default", cmd_subvol_set_default,
942                         cmd_subvol_set_default_usage, NULL, 0 },
943                 { "find-new", cmd_find_new, cmd_find_new_usage, NULL, 0 },
944                 { "show", cmd_subvol_show, cmd_subvol_show_usage, NULL, 0 },
945                 { 0, 0, 0, 0, 0 }
946         }
947 };
948
949 int cmd_subvolume(int argc, char **argv)
950 {
951         return handle_command_group(&subvolume_cmd_group, argc, argv);
952 }