X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=btrfs-list.c;h=e01c58991dad9e16f46ec00fcc2546b73642a612;hb=6cedd688115d85e6f14a43f7653378749ef31624;hp=7529e11e852ede34a23e310b1a1fa9a7c65c53d7;hpb=c47a831cd653fa4ef4979ae7007e60037eddcb37;p=platform%2Fupstream%2Fbtrfs-progs.git diff --git a/btrfs-list.c b/btrfs-list.c index 7529e11..e01c589 100644 --- a/btrfs-list.c +++ b/btrfs-list.c @@ -113,7 +113,7 @@ void btrfs_list_setup_print_column(enum btrfs_list_column_enum column) { int i; - BUG_ON(column < 0 || column > BTRFS_LIST_ALL); + ASSERT(0 <= column && column <= BTRFS_LIST_ALL); if (column < BTRFS_LIST_ALL) { btrfs_list_columns[column].need_print = 1; @@ -124,11 +124,6 @@ void btrfs_list_setup_print_column(enum btrfs_list_column_enum column) btrfs_list_columns[i].need_print = 1; } -static void root_lookup_init(struct root_lookup *tree) -{ - tree->root.rb_node = NULL; -} - static int comp_entry_with_rootid(struct root_info *entry1, struct root_info *entry2, int is_descending) @@ -237,20 +232,15 @@ struct btrfs_list_comparer_set *btrfs_list_alloc_comparer_set(void) return set; } -void btrfs_list_free_comparer_set(struct btrfs_list_comparer_set *comp_set) -{ - free(comp_set); -} - static int btrfs_list_setup_comparer(struct btrfs_list_comparer_set **comp_set, enum btrfs_list_comp_enum comparer, int is_descending) { struct btrfs_list_comparer_set *set = *comp_set; int size; - BUG_ON(!set); - BUG_ON(comparer >= BTRFS_LIST_COMP_MAX); - BUG_ON(set->ncomps > set->total); + ASSERT(set != NULL); + ASSERT(comparer < BTRFS_LIST_COMP_MAX); + ASSERT(set->ncomps <= set->total); if (set->ncomps == set->total) { void *tmp; @@ -272,7 +262,7 @@ static int btrfs_list_setup_comparer(struct btrfs_list_comparer_set **comp_set, *comp_set = set; } - BUG_ON(set->comps[set->ncomps].comp_func); + ASSERT(set->comps[set->ncomps].comp_func == NULL); set->comps[set->ncomps].comp_func = all_comp_funcs[comparer]; set->comps[set->ncomps].is_descending = is_descending; @@ -287,7 +277,7 @@ static int sort_comp(struct root_info *entry1, struct root_info *entry2, int i, ret = 0; if (!set || !set->ncomps) - goto comp_rootid; + return comp_entry_with_rootid(entry1, entry2, 0); for (i = 0; i < set->ncomps; i++) { if (!set->comps[i].comp_func) @@ -302,10 +292,8 @@ static int sort_comp(struct root_info *entry1, struct root_info *entry2, rootid_compared = 1; } - if (!rootid_compared) { -comp_rootid: + if (!rootid_compared) ret = comp_entry_with_rootid(entry1, entry2, 0); - } return ret; } @@ -399,7 +387,7 @@ static struct root_info *root_tree_search(struct root_lookup *root_tree, static int update_root(struct root_lookup *root_lookup, u64 root_id, u64 ref_tree, u64 root_offset, u64 flags, u64 dir_id, char *name, int name_len, u64 ogen, u64 gen, - time_t ot, void *uuid, void *puuid, void *ruuid) + time_t otime, u8 *uuid, u8 *puuid, u8 *ruuid) { struct root_info *ri; @@ -431,8 +419,8 @@ static int update_root(struct root_lookup *root_lookup, ri->ogen = ogen; if (!ri->ogen && root_offset) ri->ogen = root_offset; - if (ot) - ri->otime = ot; + if (otime) + ri->otime = otime; if (uuid) memcpy(&ri->uuid, uuid, BTRFS_UUID_SIZE); if (puuid) @@ -454,7 +442,7 @@ static int update_root(struct root_lookup *root_lookup, * name_len: the length of name * ogen: the original generation of the root * gen: the current generation of the root - * ot: the original time(create time) of the root + * otime: the original time (creation time) of the root * uuid: uuid of the root * puuid: uuid of the root parent if any * ruuid: uuid of the received subvol, if any @@ -462,13 +450,13 @@ static int update_root(struct root_lookup *root_lookup, static int add_root(struct root_lookup *root_lookup, u64 root_id, u64 ref_tree, u64 root_offset, u64 flags, u64 dir_id, char *name, int name_len, u64 ogen, u64 gen, - time_t ot, void *uuid, void *puuid, void *ruuid) + time_t otime, u8 *uuid, u8 *puuid, u8 *ruuid) { struct root_info *ri; int ret; ret = update_root(root_lookup, root_id, ref_tree, root_offset, flags, - dir_id, name, name_len, ogen, gen, ot, + dir_id, name, name_len, ogen, gen, otime, uuid, puuid, ruuid); if (!ret) return 0; @@ -503,8 +491,8 @@ static int add_root(struct root_lookup *root_lookup, ri->ogen = ogen; if (!ri->ogen && root_offset) ri->ogen = root_offset; - if (ot) - ri->otime = ot; + if (otime) + ri->otime = otime; if (uuid) memcpy(&ri->uuid, uuid, BTRFS_UUID_SIZE); @@ -516,14 +504,27 @@ static int add_root(struct root_lookup *root_lookup, memcpy(&ri->ruuid, ruuid, BTRFS_UUID_SIZE); ret = root_tree_insert(root_lookup, ri); - if (ret) { - printf("failed to insert tree %llu\n", (unsigned long long)root_id); + if (ret < 0) { + error("failed to insert subvolume %llu to tree: %s", + (unsigned long long)root_id, strerror(-ret)); exit(1); } return 0; } -static void __free_root_info(struct rb_node *node) +/* + * Simplified add_root for back references, omits the uuid and original info + * parameters, root offset and flags. + */ +static int add_root_backref(struct root_lookup *root_lookup, u64 root_id, + u64 ref_tree, u64 dir_id, char *name, int name_len) +{ + return add_root(root_lookup, root_id, ref_tree, 0, 0, dir_id, name, + name_len, 0, 0, 0, NULL, NULL, NULL); +} + + +static void free_root_info(struct rb_node *node) { struct root_info *ri; @@ -534,11 +535,6 @@ static void __free_root_info(struct rb_node *node) free(ri); } -static inline void __free_all_subvolumn(struct root_lookup *root_tree) -{ - rb_free_nodes(&root_tree->root, __free_root_info); -} - /* * for a given root_info, search through the root_lookup tree to construct * the full path name to it. @@ -564,7 +560,7 @@ static int resolve_root(struct root_lookup *rl, struct root_info *ri, int add_len; /* - * ref_tree = 0 indicates the subvolumes + * ref_tree = 0 indicates the subvolume * has been deleted. */ if (!found->ref_tree) { @@ -630,7 +626,7 @@ static int resolve_root(struct root_lookup *rl, struct root_info *ri, static int lookup_ino_path(int fd, struct root_info *ri) { struct btrfs_ioctl_ino_lookup_args args; - int ret, e; + int ret; if (ri->path) return 0; @@ -643,15 +639,13 @@ static int lookup_ino_path(int fd, struct root_info *ri) args.objectid = ri->dir_id; ret = ioctl(fd, BTRFS_IOC_INO_LOOKUP, &args); - e = errno; - if (ret) { - if (e == ENOENT) { + if (ret < 0) { + if (errno == ENOENT) { ri->ref_tree = 0; return -ENOENT; } - fprintf(stderr, "ERROR: Failed to lookup path for root %llu - %s\n", - (unsigned long long)ri->ref_tree, - strerror(e)); + error("failed to lookup path for root %llu: %m", + (unsigned long long)ri->ref_tree); return ret; } @@ -679,7 +673,7 @@ static int lookup_ino_path(int fd, struct root_info *ri) } /* finding the generation for a given path is a two step process. - * First we use the inode loookup routine to find out the root id + * First we use the inode lookup routine to find out the root id * * Then we use the tree search ioctl to scan all the root items for a * given root id and spit out the latest generation we can find @@ -694,24 +688,21 @@ static u64 find_root_gen(int fd) unsigned long off = 0; u64 max_found = 0; int i; - int e; memset(&ino_args, 0, sizeof(ino_args)); ino_args.objectid = BTRFS_FIRST_FREE_OBJECTID; /* this ioctl fills in ino_args->treeid */ ret = ioctl(fd, BTRFS_IOC_INO_LOOKUP, &ino_args); - e = errno; - if (ret) { - fprintf(stderr, "ERROR: Failed to lookup path for dirid %llu - %s\n", - (unsigned long long)BTRFS_FIRST_FREE_OBJECTID, - strerror(e)); + if (ret < 0) { + error("failed to lookup path for dirid %llu: %m", + (unsigned long long)BTRFS_FIRST_FREE_OBJECTID); return 0; } memset(&args, 0, sizeof(args)); - sk->tree_id = 1; + sk->tree_id = BTRFS_ROOT_TREE_OBJECTID; /* * there may be more than one ROOT_ITEM key if there are @@ -728,10 +719,8 @@ static u64 find_root_gen(int fd) while (1) { ret = ioctl(fd, BTRFS_IOC_TREE_SEARCH, &args); - e = errno; if (ret < 0) { - fprintf(stderr, "ERROR: can't perform the search - %s\n", - strerror(e)); + error("can't perform the search: %m"); return 0; } /* the ioctl returns the number of item it found in nr_items */ @@ -785,16 +774,14 @@ static char *__ino_resolve(int fd, u64 dirid) struct btrfs_ioctl_ino_lookup_args args; int ret; char *full; - int e; memset(&args, 0, sizeof(args)); args.objectid = dirid; ret = ioctl(fd, BTRFS_IOC_INO_LOOKUP, &args); - e = errno; - if (ret) { - fprintf(stderr, "ERROR: Failed to lookup path for dirid %llu - %s\n", - (unsigned long long)dirid, strerror(e) ); + if (ret < 0) { + error("failed to lookup path for dirid %llu: %m", + (unsigned long long)dirid); return ERR_PTR(ret); } @@ -819,9 +806,10 @@ static char *__ino_resolve(int fd, u64 dirid) * simple string builder, returning a new string with both * dirid and name */ -static char *build_name(char *dirid, char *name) +static char *build_name(const char *dirid, const char *name) { char *full; + if (!dirid) return strdup(name); @@ -852,7 +840,6 @@ static char *ino_resolve(int fd, u64 ino, u64 *cache_dirid, char **cache_name) struct btrfs_ioctl_search_header *sh; unsigned long off = 0; int namelen; - int e; memset(&args, 0, sizeof(args)); @@ -871,10 +858,8 @@ static char *ino_resolve(int fd, u64 ino, u64 *cache_dirid, char **cache_name) sk->nr_items = 1; ret = ioctl(fd, BTRFS_IOC_TREE_SEARCH, &args); - e = errno; if (ret < 0) { - fprintf(stderr, "ERROR: can't perform the search - %s\n", - strerror(e)); + error("can't perform the search: %m"); return NULL; } /* the ioctl returns the number of item it found in nr_items */ @@ -884,9 +869,9 @@ static char *ino_resolve(int fd, u64 ino, u64 *cache_dirid, char **cache_name) off = 0; sh = (struct btrfs_ioctl_search_header *)(args.buf + off); - if (sh->type == BTRFS_INODE_REF_KEY) { + if (btrfs_search_header_type(sh) == BTRFS_INODE_REF_KEY) { struct btrfs_inode_ref *ref; - dirid = sh->offset; + dirid = btrfs_search_header_offset(sh); ref = (struct btrfs_inode_ref *)(sh + 1); namelen = btrfs_stack_inode_ref_name_len(ref); @@ -933,7 +918,7 @@ int btrfs_list_get_default_subvolume(int fd, u64 *default_id) * search for a dir item with a name 'default' in the tree of * tree roots, it should point us to a default root */ - sk->tree_id = 1; + sk->tree_id = BTRFS_ROOT_TREE_OBJECTID; /* don't worry about ancient format and request only one item */ sk->nr_items = 1; @@ -955,7 +940,7 @@ int btrfs_list_get_default_subvolume(int fd, u64 *default_id) sh = (struct btrfs_ioctl_search_header *)args.buf; - if (sh->type == BTRFS_DIR_ITEM_KEY) { + if (btrfs_search_header_type(sh) == BTRFS_DIR_ITEM_KEY) { struct btrfs_dir_item *di; int name_len; char *name; @@ -973,7 +958,7 @@ out: return 0; } -static int __list_subvol_search(int fd, struct root_lookup *root_lookup) +static int list_subvol_search(int fd, struct root_lookup *root_lookup) { int ret; struct btrfs_ioctl_search_args args; @@ -981,7 +966,7 @@ static int __list_subvol_search(int fd, struct root_lookup *root_lookup) struct btrfs_ioctl_search_header sh; struct btrfs_root_ref *ref; struct btrfs_root_item *ri; - unsigned long off = 0; + unsigned long off; int name_len; char *name; u64 dir_id; @@ -989,42 +974,24 @@ static int __list_subvol_search(int fd, struct root_lookup *root_lookup) u64 ogen; u64 flags; int i; - time_t t; - u8 uuid[BTRFS_UUID_SIZE]; - u8 puuid[BTRFS_UUID_SIZE]; - u8 ruuid[BTRFS_UUID_SIZE]; - root_lookup_init(root_lookup); + root_lookup->root.rb_node = NULL; memset(&args, 0, sizeof(args)); - /* search in the tree of tree roots */ - sk->tree_id = 1; - - /* - * set the min and max to backref keys. The search will - * only send back this type of key now. - */ - sk->max_type = BTRFS_ROOT_BACKREF_KEY; + sk->tree_id = BTRFS_ROOT_TREE_OBJECTID; + /* Search both live and deleted subvolumes */ sk->min_type = BTRFS_ROOT_ITEM_KEY; - - sk->min_objectid = BTRFS_FIRST_FREE_OBJECTID; - - /* - * set all the other params to the max, we'll take any objectid - * and any trans - */ + sk->max_type = BTRFS_ROOT_BACKREF_KEY; + sk->min_objectid = BTRFS_FS_TREE_OBJECTID; sk->max_objectid = BTRFS_LAST_FREE_OBJECTID; sk->max_offset = (u64)-1; sk->max_transid = (u64)-1; - /* just a big number, doesn't matter much */ - sk->nr_items = 4096; - while(1) { + sk->nr_items = 4096; ret = ioctl(fd, BTRFS_IOC_TREE_SEARCH, &args); if (ret < 0) return ret; - /* the ioctl returns the number of item it found in nr_items */ if (sk->nr_items == 0) break; @@ -1043,22 +1010,29 @@ static int __list_subvol_search(int fd, struct root_lookup *root_lookup) name = (char *)(ref + 1); dir_id = btrfs_stack_root_ref_dirid(ref); - add_root(root_lookup, sh.objectid, sh.offset, - 0, 0, dir_id, name, name_len, 0, 0, 0, - NULL, NULL, NULL); - } else if (sh.type == BTRFS_ROOT_ITEM_KEY) { + add_root_backref(root_lookup, sh.objectid, + sh.offset, dir_id, name, + name_len); + } else if (sh.type == BTRFS_ROOT_ITEM_KEY && + (sh.objectid >= BTRFS_FIRST_FREE_OBJECTID || + sh.objectid == BTRFS_FS_TREE_OBJECTID)) { + time_t otime; + u8 uuid[BTRFS_UUID_SIZE]; + u8 puuid[BTRFS_UUID_SIZE]; + u8 ruuid[BTRFS_UUID_SIZE]; + ri = (struct btrfs_root_item *)(args.buf + off); gen = btrfs_root_generation(ri); flags = btrfs_root_flags(ri); if(sh.len > sizeof(struct btrfs_root_item_v0)) { - t = btrfs_stack_timespec_sec(&ri->otime); + otime = btrfs_stack_timespec_sec(&ri->otime); ogen = btrfs_root_otransid(ri); memcpy(uuid, ri->uuid, BTRFS_UUID_SIZE); memcpy(puuid, ri->parent_uuid, BTRFS_UUID_SIZE); memcpy(ruuid, ri->received_uuid, BTRFS_UUID_SIZE); } else { - t = 0; + otime = 0; ogen = 0; memset(uuid, 0, BTRFS_UUID_SIZE); memset(puuid, 0, BTRFS_UUID_SIZE); @@ -1067,22 +1041,17 @@ static int __list_subvol_search(int fd, struct root_lookup *root_lookup) add_root(root_lookup, sh.objectid, 0, sh.offset, flags, 0, NULL, 0, ogen, - gen, t, uuid, puuid, ruuid); + gen, otime, uuid, puuid, ruuid); } off += sh.len; - /* - * record the mins in sk so we can make sure the - * next search doesn't repeat this root - */ sk->min_objectid = sh.objectid; sk->min_type = sh.type; sk->min_offset = sh.offset; } - sk->nr_items = 4096; sk->min_offset++; - if (!sk->min_offset) /* overflow */ + if (!sk->min_offset) sk->min_type++; else continue; @@ -1217,20 +1186,19 @@ struct btrfs_list_filter_set *btrfs_list_alloc_filter_set(void) return set; } -void btrfs_list_free_filter_set(struct btrfs_list_filter_set *filter_set) -{ - free(filter_set); -} - -int btrfs_list_setup_filter(struct btrfs_list_filter_set **filter_set, +/* + * Setup list filters. Exit if there's not enough memory, as we can't continue + * without the structures set up properly. + */ +void btrfs_list_setup_filter(struct btrfs_list_filter_set **filter_set, enum btrfs_list_filter_enum filter, u64 data) { struct btrfs_list_filter_set *set = *filter_set; int size; - BUG_ON(!set); - BUG_ON(filter >= BTRFS_LIST_FILTER_MAX); - BUG_ON(set->nfilters > set->total); + ASSERT(set != NULL); + ASSERT(filter < BTRFS_LIST_FILTER_MAX); + ASSERT(set->nfilters <= set->total); if (set->nfilters == set->total) { void *tmp; @@ -1252,7 +1220,7 @@ int btrfs_list_setup_filter(struct btrfs_list_filter_set **filter_set, *filter_set = set; } - BUG_ON(set->filters[set->nfilters].filter_func); + ASSERT(set->filters[set->nfilters].filter_func == NULL); if (filter == BTRFS_LIST_FILTER_DELETED) set->only_deleted = 1; @@ -1260,7 +1228,6 @@ int btrfs_list_setup_filter(struct btrfs_list_filter_set **filter_set, set->filters[set->nfilters].filter_func = all_filter_funcs[filter]; set->filters[set->nfilters].data = data; set->nfilters++; - return 0; } static int filter_root(struct root_info *ri, @@ -1287,7 +1254,7 @@ static int filter_root(struct root_info *ri, return 1; } -static void __filter_and_sort_subvol(struct root_lookup *all_subvols, +static void filter_and_sort_subvol(struct root_lookup *all_subvols, struct root_lookup *sort_tree, struct btrfs_list_filter_set *filter_set, struct btrfs_list_comparer_set *comp_set, @@ -1297,7 +1264,7 @@ static void __filter_and_sort_subvol(struct root_lookup *all_subvols, struct root_info *entry; int ret; - root_lookup_init(sort_tree); + sort_tree->root.rb_node = NULL; n = rb_last(&all_subvols->root); while (n) { @@ -1305,8 +1272,18 @@ static void __filter_and_sort_subvol(struct root_lookup *all_subvols, ret = resolve_root(all_subvols, entry, top_id); if (ret == -ENOENT) { - entry->full_path = strdup("DELETED"); - entry->deleted = 1; + if (entry->root_id != BTRFS_FS_TREE_OBJECTID) { + entry->full_path = strdup("DELETED"); + entry->deleted = 1; + } else { + /* + * The full path is not supposed to be printed, + * but we don't want to print an empty string, + * in case it appears somewhere. + */ + entry->full_path = strdup("TOPLEVEL"); + entry->deleted = 0; + } } ret = filter_root(entry, filter_set); if (ret) @@ -1315,7 +1292,7 @@ static void __filter_and_sort_subvol(struct root_lookup *all_subvols, } } -static int __list_subvol_fill_paths(int fd, struct root_lookup *root_lookup) +static int list_subvol_fill_paths(int fd, struct root_lookup *root_lookup) { struct rb_node *n; @@ -1339,7 +1316,7 @@ static void print_subvolume_column(struct root_info *subv, char tstr[256]; char uuidparse[BTRFS_UUID_UNPARSED_SIZE]; - BUG_ON(column >= BTRFS_LIST_ALL || column < 0); + ASSERT(0 <= column && column < BTRFS_LIST_ALL); switch (column) { case BTRFS_LIST_OBJECTID: @@ -1372,21 +1349,21 @@ static void print_subvolume_column(struct root_info *subv, strcpy(uuidparse, "-"); else uuid_unparse(subv->uuid, uuidparse); - printf("%s", uuidparse); + printf("%-36s", uuidparse); break; case BTRFS_LIST_PUUID: if (uuid_is_null(subv->puuid)) strcpy(uuidparse, "-"); else uuid_unparse(subv->puuid, uuidparse); - printf("%s", uuidparse); + printf("%-36s", uuidparse); break; case BTRFS_LIST_RUUID: if (uuid_is_null(subv->ruuid)) strcpy(uuidparse, "-"); else uuid_unparse(subv->ruuid, uuidparse); - printf("%s", uuidparse); + printf("%-36s", uuidparse); break; case BTRFS_LIST_PATH: BUG_ON(!subv->full_path); @@ -1397,7 +1374,8 @@ static void print_subvolume_column(struct root_info *subv, } } -static void print_single_volume_info_raw(struct root_info *subv, char *raw_prefix) +static void print_one_subvol_info_raw(struct root_info *subv, + const char *raw_prefix) { int i; @@ -1413,7 +1391,7 @@ static void print_single_volume_info_raw(struct root_info *subv, char *raw_prefi printf("\n"); } -static void print_single_volume_info_table(struct root_info *subv) +static void print_one_subvol_info_table(struct root_info *subv) { int i; @@ -1432,7 +1410,7 @@ static void print_single_volume_info_table(struct root_info *subv) printf("\n"); } -static void print_single_volume_info_default(struct root_info *subv) +static void print_one_subvol_info_default(struct root_info *subv) { int i; @@ -1449,7 +1427,7 @@ static void print_single_volume_info_default(struct root_info *subv) printf("\n"); } -static void print_all_volume_info_tab_head(void) +static void print_all_subvol_info_tab_head(void) { int i; int len; @@ -1478,29 +1456,35 @@ static void print_all_volume_info_tab_head(void) } } -static void print_all_volume_info(struct root_lookup *sorted_tree, - int layout, char *raw_prefix) +static void print_all_subvol_info(struct root_lookup *sorted_tree, + enum btrfs_list_layout layout, const char *raw_prefix) { struct rb_node *n; struct root_info *entry; if (layout == BTRFS_LIST_LAYOUT_TABLE) - print_all_volume_info_tab_head(); + print_all_subvol_info_tab_head(); n = rb_first(&sorted_tree->root); while (n) { entry = rb_entry(n, struct root_info, sort_node); + + /* The toplevel subvolume is not listed by default */ + if (entry->root_id == BTRFS_FS_TREE_OBJECTID) + goto next; + switch (layout) { case BTRFS_LIST_LAYOUT_DEFAULT: - print_single_volume_info_default(entry); + print_one_subvol_info_default(entry); break; case BTRFS_LIST_LAYOUT_TABLE: - print_single_volume_info_table(entry); + print_one_subvol_info_table(entry); break; case BTRFS_LIST_LAYOUT_RAW: - print_single_volume_info_raw(entry, raw_prefix); + print_one_subvol_info_raw(entry, raw_prefix); break; } +next: n = rb_next(n); } } @@ -1509,10 +1493,9 @@ static int btrfs_list_subvols(int fd, struct root_lookup *root_lookup) { int ret; - ret = __list_subvol_search(fd, root_lookup); + ret = list_subvol_search(fd, root_lookup); if (ret) { - fprintf(stderr, "ERROR: can't perform the search - %s\n", - strerror(errno)); + error("can't perform the search: %m"); return ret; } @@ -1520,13 +1503,14 @@ static int btrfs_list_subvols(int fd, struct root_lookup *root_lookup) * now we have an rbtree full of root_info objects, but we need to fill * in their path names within the subvol that is referencing each one. */ - ret = __list_subvol_fill_paths(fd, root_lookup); + ret = list_subvol_fill_paths(fd, root_lookup); return ret; } int btrfs_list_subvols_print(int fd, struct btrfs_list_filter_set *filter_set, struct btrfs_list_comparer_set *comp_set, - int layout, int full_path, char *raw_prefix) + enum btrfs_list_layout layout, int full_path, + const char *raw_prefix) { struct root_lookup root_lookup; struct root_lookup root_sort; @@ -1541,11 +1525,11 @@ int btrfs_list_subvols_print(int fd, struct btrfs_list_filter_set *filter_set, ret = btrfs_list_subvols(fd, &root_lookup); if (ret) return ret; - __filter_and_sort_subvol(&root_lookup, &root_sort, filter_set, + filter_and_sort_subvol(&root_lookup, &root_sort, filter_set, comp_set, top_id); - print_all_volume_info(&root_sort, layout, raw_prefix); - __free_all_subvolumn(&root_lookup); + print_all_subvol_info(&root_sort, layout, raw_prefix); + rb_free_nodes(&root_lookup.root, free_root_info); return 0; } @@ -1557,6 +1541,37 @@ static char *strdup_or_null(const char *s) return strdup(s); } +int btrfs_get_toplevel_subvol(int fd, struct root_info *the_ri) +{ + int ret; + struct root_lookup rl; + struct rb_node *rbn; + struct root_info *ri; + u64 root_id; + + ret = btrfs_list_get_path_rootid(fd, &root_id); + if (ret) + return ret; + + ret = btrfs_list_subvols(fd, &rl); + if (ret) + return ret; + + rbn = rb_first(&rl.root); + ri = rb_entry(rbn, struct root_info, rb_node); + + if (ri->root_id != BTRFS_FS_TREE_OBJECTID) + return -ENOENT; + + memcpy(the_ri, ri, offsetof(struct root_info, path)); + the_ri->path = strdup_or_null("/"); + the_ri->name = strdup_or_null(""); + the_ri->full_path = strdup_or_null("/"); + rb_free_nodes(&rl.root, free_root_info); + + return ret; +} + int btrfs_get_subvol(int fd, struct root_info *the_ri) { int ret, rr; @@ -1582,7 +1597,9 @@ int btrfs_get_subvol(int fd, struct root_info *the_ri) rbn = rb_next(rbn); continue; } - if (!comp_entry_with_rootid(the_ri, ri, 0)) { + + if (!comp_entry_with_rootid(the_ri, ri, 0) || + !uuid_compare(the_ri->uuid, ri->uuid)) { memcpy(the_ri, ri, offsetof(struct root_info, path)); the_ri->path = strdup_or_null(ri->path); the_ri->name = strdup_or_null(ri->name); @@ -1592,7 +1609,7 @@ int btrfs_get_subvol(int fd, struct root_info *the_ri) } rbn = rb_next(rbn); } - __free_all_subvolumn(&rl); + rb_free_nodes(&rl.root, free_root_info); return ret; } @@ -1610,17 +1627,18 @@ static int print_one_extent(int fd, struct btrfs_ioctl_search_header *sh, int flags = 0; char *name = NULL; - if (sh->objectid == *cache_ino) { + if (btrfs_search_header_objectid(sh) == *cache_ino) { name = *cache_full_name; } else if (*cache_full_name) { free(*cache_full_name); *cache_full_name = NULL; } if (!name) { - name = ino_resolve(fd, sh->objectid, cache_dirid, + name = ino_resolve(fd, btrfs_search_header_objectid(sh), + cache_dirid, cache_dir_name); *cache_full_name = name; - *cache_ino = sh->objectid; + *cache_ino = btrfs_search_header_objectid(sh); } if (!name) return -EIO; @@ -1638,19 +1656,19 @@ static int print_one_extent(int fd, struct btrfs_ioctl_search_header *sh, disk_offset = 0; len = btrfs_stack_file_extent_ram_bytes(item); } else { - printf("unhandled extent type %d for inode %llu " - "file offset %llu gen %llu\n", + error( + "unhandled extent type %d for inode %llu file offset %llu gen %llu", type, - (unsigned long long)sh->objectid, - (unsigned long long)sh->offset, + (unsigned long long)btrfs_search_header_objectid(sh), + (unsigned long long)btrfs_search_header_offset(sh), (unsigned long long)found_gen); return -EIO; } printf("inode %llu file offset %llu len %llu disk start %llu " "offset %llu gen %llu flags ", - (unsigned long long)sh->objectid, - (unsigned long long)sh->offset, + (unsigned long long)btrfs_search_header_objectid(sh), + (unsigned long long)btrfs_search_header_offset(sh), (unsigned long long)len, (unsigned long long)disk_start, (unsigned long long)disk_offset, @@ -1686,7 +1704,6 @@ int btrfs_list_find_updated_files(int fd, u64 root_id, u64 oldest_gen) u64 found_gen; u64 max_found = 0; int i; - int e; u64 cache_dirid = 0; u64 cache_ino = 0; char *cache_dir_name = NULL; @@ -1713,10 +1730,8 @@ int btrfs_list_find_updated_files(int fd, u64 root_id, u64 oldest_gen) max_found = find_root_gen(fd); while(1) { ret = ioctl(fd, BTRFS_IOC_TREE_SEARCH, &args); - e = errno; if (ret < 0) { - fprintf(stderr, "ERROR: can't perform the search - %s\n", - strerror(e)); + error("can't perform the search: %m"); break; } /* the ioctl returns the number of item it found in nr_items */ @@ -1787,11 +1802,11 @@ char *btrfs_list_path_for_root(int fd, u64 root) if (ret) return ERR_PTR(ret); - ret = __list_subvol_search(fd, &root_lookup); + ret = list_subvol_search(fd, &root_lookup); if (ret < 0) return ERR_PTR(ret); - ret = __list_subvol_fill_paths(fd, &root_lookup); + ret = list_subvol_fill_paths(fd, &root_lookup); if (ret < 0) return ERR_PTR(ret); @@ -1812,7 +1827,7 @@ char *btrfs_list_path_for_root(int fd, u64 root) n = rb_prev(n); } - __free_all_subvolumn(&root_lookup); + rb_free_nodes(&root_lookup.root, free_root_info); return ret_path; } @@ -1906,19 +1921,11 @@ int btrfs_list_parse_filter_string(char *opt_arg, int btrfs_list_get_path_rootid(int fd, u64 *treeid) { - int ret; - struct btrfs_ioctl_ino_lookup_args args; + int ret; - memset(&args, 0, sizeof(args)); - args.objectid = BTRFS_FIRST_FREE_OBJECTID; + ret = lookup_path_rootid(fd, treeid); + if (ret < 0) + error("cannot resolve rootid for path: %m"); - ret = ioctl(fd, BTRFS_IOC_INO_LOOKUP, &args); - if (ret < 0) { - fprintf(stderr, - "ERROR: can't perform the search - %s\n", - strerror(errno)); - return ret; - } - *treeid = args.treeid; - return 0; + return ret; }