On Tue, 9 Oct 2012 18:05:51 +0200, Alex Lyakas wrote:
> Hi Miao,
> I have some trouble with this code.
>
> The problem that I see is after subvolume deletion. What happens is
> that __list_subvol_search() is called at the point, at which ROOT_ITEM
> still exists in the root tree, but ROOT_BACKREF does not exist
> anymore. I think this is because btrfs_ioctl_snap_destroy() calls
> btrfs_unlink_subvol(), which calls btrfs_del_root_ref(), which deletes
> ROOT_BACKREF, but ROOT_ITEM still exists until transaction is
> committed.
>
> So what happens is that we end up with struct root_info that has
> ref_tree==0 (and dir_id==0).
> So later, when __list_subvol_fill_paths() is called, it fails to
> perform BTRFS_IOC_INO_LOOKUP because of ref_tree==0. As a result,
> subvol_uuid_search_init fails and everything stops.
>
> Previously, before your change, root_info was not added until we see
> ROOT_BACKREF in the tree.
The old code still has the similar problem if we delete the subvolume completely
between __list_subvol_search() and __list_subvol_fill_paths().
> How do you think this should be fixed?
Yes, I think it should be fixed. We can filter the deleted subvolume.
>
> Also, is there a way to issue a subvolume deletion and make sure that
> it was deleted? I see that btrfs_ioctl_snap_destroy() calls
no ROOT_BACKREF already tells us that the subvolume has been deleted, I think.
> end_transaction() but not commit_transaction(). Moreover, there is no
> way for the caller to know the transid, otherwise we could issue
> BTRFS_IOC_WAIT_SYNC.
we can get the transid by btrfs_ioctl_start_sync()
Thanks
Miao
>
> Thanks,
> Alex.
>
>
>
> On Tue, Sep 18, 2012 at 1:06 PM, Miao Xie <miaox@xxxxxxxxxxxxxx> wrote:
>> The current code of list_subvols() has very bad scalability, if we want to
>> add new filter conditions or new sort methods, we have to modify lots of code.
>>
>> Beside that, the most code of list_snapshots() is similar to list_subvols(),
>>
>> So I restructure list_subvols(), and split the subvolume filter function,
>> the subvolume sort function and the output function from list_subvols().
>> In order to implement it, we defined some importtant structures:
>> struct btrfs_list_filter {
>> btrfs_list_filter_func filter_func;
>> void *data;
>> };
>>
>> struct btrfs_list_comparer {
>> btrfs_list_comp_func comp_func;
>> int is_descending;
>> };
>>
>> struct {
>> char *name;
>> char *column_name;
>> int need_print;
>> } btrfs_list_columns[];
>>
>> If we want to add a new filter condition, we can choose a suitable filter
>> function, or implement a new filter function[1], and add it into a set of
>> the filters, and then pass the filter set into list_subvols(). We also can
>> mix several filters (just add those filters into the set, and pass the set
>> into list_subvols()) if the users specify two or more filter conditions.
>>
>> The subvolume sort function is similar to the subvolume filter function. The
>> differentiation is the order of comparers in the array which is passed into
>> list_subvols() show us the priority of the sort methods.
>>
>> The output function is different with the above two functions, we define a
>> array to manage all the columns that can be outputed, and use a member variant
>> (->need_print) to control the output of the relative column. Some columns are
>> outputed by default. But we can change it according to the requirement of the
>> users.
>>
>> After appling this patch, we needn't implement a independent list_snapshots()
>> function, just pass a filter function which is used to identify the snapshot
>> into list_subvols().
>>
>> [1]: If we implement new filter functions or compare functions, we must add
>> them into the array all_filter_funcs or the array all_comp_funcs, and modify
>> the relative enum variants(btrfs_list_filter_enum, btrfs_list_comp_enum).
>>
>> Signed-off-by: Miao Xie <miaox@xxxxxxxxxxxxxx>
>> ---
>> Changelog v3 -> v4:
>> - add the filter set and comparer set which are used to manage the filters and
>> comparers. And the memory space of these two set are allocated dynamically,
>> in this way, the users can specify lots of filters and comparers, not be limited
>> by the size of the array.
>>
>> Changelog v1 -> v3:
>> - new patch.
>> ---
>> btrfs-list.c | 1004 ++++++++++++++++++++++++++++++++----------------------
>> btrfs-list.h | 73 ++++-
>> cmds-inspect.c | 2 +-
>> cmds-subvolume.c | 59 +++-
>> send-utils.c | 3 +-
>> 5 files changed, 712 insertions(+), 429 deletions(-)
>>
>> diff --git a/btrfs-list.c b/btrfs-list.c
>> index ed28021..bace903 100644
>> --- a/btrfs-list.c
>> +++ b/btrfs-list.c
>> @@ -37,6 +37,9 @@
>> #include <uuid/uuid.h>
>> #include "btrfs-list.h"
>>
>> +#define BTRFS_LIST_NFILTERS_INCREASE (2 * BTRFS_LIST_FILTER_MAX)
>> +#define BTRFS_LIST_NCOMPS_INCREASE (2 * BTRFS_LIST_COMP_MAX)
>> +
>> /* we store all the roots we find in an rbtree so that we can
>> * search for them later.
>> */
>> @@ -49,19 +52,28 @@ struct root_lookup {
>> */
>> struct root_info {
>> struct rb_node rb_node;
>> + struct rb_node sort_node;
>>
>> /* this root's id */
>> u64 root_id;
>>
>> + /* equal the offset of the root's key */
>> + u64 root_offset;
>> +
>> /* the id of the root that references this one */
>> u64 ref_tree;
>>
>> /* the dir id we're in from ref_tree */
>> u64 dir_id;
>>
>> + u64 top_id;
>> +
>> /* generation when the root is created or last updated */
>> u64 gen;
>>
>> + /* creation generation of this root in sec*/
>> + u64 ogen;
>> +
>> /* creation time of this root in sec*/
>> time_t otime;
>>
>> @@ -73,35 +85,254 @@ struct root_info {
>> char *path;
>>
>> /* the name of this root in the directory it lives in */
>> - char name[];
>> + char *name;
>> +
>> + char *full_path;
>> };
>>
>> +struct {
>> + char *name;
>> + char *column_name;
>> + int need_print;
>> +} btrfs_list_columns[] = {
>> + {
>> + .name = "ID",
>> + .column_name = "ID",
>> + .need_print = 1,
>> + },
>> + {
>> + .name = "gen",
>> + .column_name = "Gen",
>> + .need_print = 1,
>> + },
>> + {
>> + .name = "cgen",
>> + .column_name = "CGen",
>> + .need_print = 0,
>> + },
>> + {
>> + .name = "parent",
>> + .column_name = "Parent",
>> + .need_print = 0,
>> + },
>> + {
>> + .name = "top level",
>> + .column_name = "Top Level",
>> + .need_print = 1,
>> + },
>> + {
>> + .name = "otime",
>> + .column_name = "OTime",
>> + .need_print = 0,
>> + },
>> + {
>> + .name = "uuid",
>> + .column_name = "UUID",
>> + .need_print = 0,
>> + },
>> + {
>> + .name = "path",
>> + .column_name = "Path",
>> + .need_print = 1,
>> + },
>> + {
>> + .name = NULL,
>> + .column_name = NULL,
>> + .need_print = 0,
>> + },
>> +};
>> +
>> +static btrfs_list_filter_func all_filter_funcs[];
>> +static btrfs_list_comp_func all_comp_funcs[];
>> +
>> +void btrfs_list_setup_print_column(enum btrfs_list_column_enum column)
>> +{
>> + int i;
>> +
>> + BUG_ON(column < 0 || column > BTRFS_LIST_ALL);
>> +
>> + if (column < BTRFS_LIST_ALL) {
>> + btrfs_list_columns[column].need_print = 1;
>> + return;
>> + }
>> +
>> + for (i = 0; i < BTRFS_LIST_ALL; i++)
>> + 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(struct root_info *entry, u64 root_id, u64 ref_tree)
>> +static int comp_entry_with_rootid(struct root_info *entry1,
>> + struct root_info *entry2,
>> + int is_descending)
>> {
>> - if (entry->root_id > root_id)
>> - return 1;
>> - if (entry->root_id < root_id)
>> - return -1;
>> - if (entry->ref_tree > ref_tree)
>> - return 1;
>> - if (entry->ref_tree < ref_tree)
>> - return -1;
>> + int ret;
>> +
>> + if (entry1->root_id > entry2->root_id)
>> + ret = 1;
>> + else if (entry1->root_id < entry2->root_id)
>> + ret = -1;
>> + else
>> + ret = 0;
>> +
>> + return is_descending ? -ret : ret;
>> +}
>> +
>> +static int comp_entry_with_gen(struct root_info *entry1,
>> + struct root_info *entry2,
>> + int is_descending)
>> +{
>> + int ret;
>> +
>> + if (entry1->gen > entry2->gen)
>> + ret = 1;
>> + else if (entry1->gen < entry2->gen)
>> + ret = -1;
>> + else
>> + ret = 0;
>> +
>> + return is_descending ? -ret : ret;
>> +}
>> +
>> +static int comp_entry_with_ogen(struct root_info *entry1,
>> + struct root_info *entry2,
>> + int is_descending)
>> +{
>> + int ret;
>> +
>> + if (entry1->ogen > entry2->ogen)
>> + ret = 1;
>> + else if (entry1->ogen < entry2->ogen)
>> + ret = -1;
>> + else
>> + ret = 0;
>> +
>> + return is_descending ? -ret : ret;
>> +}
>> +
>> +static btrfs_list_comp_func all_comp_funcs[] = {
>> + [BTRFS_LIST_COMP_ROOTID] = comp_entry_with_rootid,
>> + [BTRFS_LIST_COMP_OGEN] = comp_entry_with_ogen,
>> + [BTRFS_LIST_COMP_GEN] = comp_entry_with_gen,
>> +};
>> +
>> +struct btrfs_list_comparer_set *btrfs_list_alloc_comparer_set(void)
>> +{
>> + struct btrfs_list_comparer_set *set;
>> + int size;
>> +
>> + size = sizeof(struct btrfs_list_comparer_set) +
>> + BTRFS_LIST_NCOMPS_INCREASE * sizeof(struct btrfs_list_comparer);
>> + set = malloc(size);
>> + if (!set) {
>> + fprintf(stderr, "memory allocation failed\n");
>> + exit(1);
>> + }
>> +
>> + memset(set, 0, size);
>> + set->total = BTRFS_LIST_NCOMPS_INCREASE;
>> +
>> + return set;
>> +}
>> +
>> +void btrfs_list_free_comparer_set(struct btrfs_list_comparer_set *comp_set)
>> +{
>> + free(comp_set);
>> +}
>> +
>> +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);
>> +
>> + if (set->ncomps == set->total) {
>> + size = set->total + BTRFS_LIST_NCOMPS_INCREASE;
>> + size = sizeof(*set) + size * sizeof(struct btrfs_list_comparer);
>> + set = realloc(set, size);
>> + if (!set) {
>> + fprintf(stderr, "memory allocation failed\n");
>> + exit(1);
>> + }
>> +
>> + memset(&set->comps[set->total], 0,
>> + BTRFS_LIST_NCOMPS_INCREASE *
>> + sizeof(struct btrfs_list_comparer));
>> + set->total += BTRFS_LIST_NCOMPS_INCREASE;
>> + *comp_set = set;
>> + }
>> +
>> + BUG_ON(set->comps[set->ncomps].comp_func);
>> +
>> + set->comps[set->ncomps].comp_func = all_comp_funcs[comparer];
>> + set->comps[set->ncomps].is_descending = is_descending;
>> + set->ncomps++;
>> return 0;
>> }
>>
>> -static int comp_entry_with_gen(struct root_info *entry, u64 root_id,
>> - u64 ref_tree, u64 gen)
>> +static int sort_comp(struct root_info *entry1, struct root_info *entry2,
>> + struct btrfs_list_comparer_set *set)
>> {
>> - if (entry->gen < gen)
>> - return 1;
>> - if (entry->gen > gen)
>> - return -1;
>> - return comp_entry(entry, root_id, ref_tree);
>> + int rootid_compared = 0;
>> + int i, ret = 0;
>> +
>> + if (!set || !set->ncomps)
>> + goto comp_rootid;
>> +
>> + for (i = 0; i < set->ncomps; i++) {
>> + if (!set->comps[i].comp_func)
>> + break;
>> +
>> + ret = set->comps[i].comp_func(entry1, entry2,
>> + set->comps[i].is_descending);
>> + if (ret)
>> + return ret;
>> +
>> + if (set->comps[i].comp_func == comp_entry_with_rootid)
>> + rootid_compared = 1;
>> + }
>> +
>> + if (!rootid_compared) {
>> +comp_rootid:
>> + ret = comp_entry_with_rootid(entry1, entry2, 0);
>> + }
>> +
>> + return ret;
>> +}
>> +
>> +static int sort_tree_insert(struct root_lookup *sort_tree,
>> + struct root_info *ins,
>> + struct btrfs_list_comparer_set *comp_set)
>> +{
>> + struct rb_node **p = &sort_tree->root.rb_node;
>> + struct rb_node *parent = NULL;
>> + struct root_info *curr;
>> + int ret;
>> +
>> + while (*p) {
>> + parent = *p;
>> + curr = rb_entry(parent, struct root_info, sort_node);
>> +
>> + ret = sort_comp(ins, curr, comp_set);
>> + if (ret < 0)
>> + p = &(*p)->rb_left;
>> + else if (ret > 0)
>> + p = &(*p)->rb_right;
>> + else
>> + return -EEXIST;
>> + }
>> +
>> + rb_link_node(&ins->sort_node, parent, p);
>> + rb_insert_color(&ins->sort_node, &sort_tree->root);
>> + return 0;
>> }
>>
>> /*
>> @@ -109,118 +340,165 @@ static int comp_entry_with_gen(struct root_info *entry, u64 root_id,
>> * if one is already there. Both root_id and ref_tree are used
>> * as the key
>> */
>> -static struct rb_node *tree_insert(struct rb_root *root, u64 root_id,
>> - u64 ref_tree, u64 *gen, struct rb_node *node)
>> +static int root_tree_insert(struct root_lookup *root_tree,
>> + struct root_info *ins)
>> {
>> - struct rb_node ** p = &root->rb_node;
>> + struct rb_node **p = &root_tree->root.rb_node;
>> struct rb_node * parent = NULL;
>> - struct root_info *entry;
>> - int comp;
>> + struct root_info *curr;
>> + int ret;
>>
>> while(*p) {
>> parent = *p;
>> - entry = rb_entry(parent, struct root_info, rb_node);
>> + curr = rb_entry(parent, struct root_info, rb_node);
>>
>> - if (!gen)
>> - comp = comp_entry(entry, root_id, ref_tree);
>> - else
>> - comp = comp_entry_with_gen(entry, root_id, ref_tree,
>> - *gen);
>> -
>> - if (comp < 0)
>> + ret = comp_entry_with_rootid(ins, curr, 0);
>> + if (ret < 0)
>> p = &(*p)->rb_left;
>> - else if (comp > 0)
>> + else if (ret > 0)
>> p = &(*p)->rb_right;
>> else
>> - return parent;
>> + return -EEXIST;
>> }
>>
>> - entry = rb_entry(parent, struct root_info, rb_node);
>> - rb_link_node(node, parent, p);
>> - rb_insert_color(node, root);
>> - return NULL;
>> + rb_link_node(&ins->rb_node, parent, p);
>> + rb_insert_color(&ins->rb_node, &root_tree->root);
>> + return 0;
>> }
>>
>> /*
>> * find a given root id in the tree. We return the smallest one,
>> * rb_next can be used to move forward looking for more if required
>> */
>> -static struct root_info *tree_search(struct rb_root *root, u64 root_id)
>> +static struct root_info *root_tree_search(struct root_lookup *root_tree,
>> + u64 root_id)
>> {
>> - struct rb_node * n = root->rb_node;
>> + struct rb_node *n = root_tree->root.rb_node;
>> struct root_info *entry;
>> + struct root_info tmp;
>> + int ret;
>> +
>> + tmp.root_id = root_id;
>>
>> while(n) {
>> entry = rb_entry(n, struct root_info, rb_node);
>>
>> - if (entry->root_id < root_id)
>> + ret = comp_entry_with_rootid(&tmp, entry, 0);
>> + if (ret < 0)
>> n = n->rb_left;
>> - else if (entry->root_id > root_id)
>> + else if (ret > 0)
>> n = n->rb_right;
>> - else {
>> - struct root_info *prev;
>> - struct rb_node *prev_n;
>> - while (1) {
>> - prev_n = rb_prev(n);
>> - if (!prev_n)
>> - break;
>> - prev = rb_entry(prev_n, struct root_info,
>> - rb_node);
>> - if (prev->root_id != root_id)
>> - break;
>> - entry = prev;
>> - n = prev_n;
>> - }
>> + else
>> return entry;
>> - }
>> }
>> return NULL;
>> }
>>
>> +static int update_root(struct root_lookup *root_lookup,
>> + u64 root_id, u64 ref_tree, u64 root_offset, u64 dir_id,
>> + char *name, int name_len, u64 ogen, u64 gen, time_t ot,
>> + void *uuid)
>> +{
>> + struct root_info *ri;
>> +
>> + ri = root_tree_search(root_lookup, root_id);
>> + if (!ri || ri->root_id != root_id)
>> + return -ENOENT;
>> + if (name && name_len > 0) {
>> + if (ri->name)
>> + free(ri->name);
>> +
>> + ri->name = malloc(name_len + 1);
>> + if (!ri->name) {
>> + fprintf(stderr, "memory allocation failed\n");
>> + exit(1);
>> + }
>> + strncpy(ri->name, name, name_len);
>> + ri->name[name_len] = 0;
>> + }
>> + if (ref_tree)
>> + ri->ref_tree = ref_tree;
>> + if (root_offset)
>> + ri->root_offset = root_offset;
>> + if (dir_id)
>> + ri->dir_id = dir_id;
>> + if (gen)
>> + ri->gen = gen;
>> + if (ogen)
>> + ri->ogen = ogen;
>> + if (!ri->ogen && root_offset)
>> + ri->ogen = root_offset;
>> + if (ot)
>> + ri->otime = ot;
>> + if (uuid)
>> + memcpy(&ri->uuid, uuid, BTRFS_UUID_SIZE);
>> +
>> + return 0;
>> +}
>> +
>> /*
>> - * this allocates a new root in the lookup tree.
>> - *
>> - * root_id should be the object id of the root
>> - *
>> - * ref_tree is the objectid of the referring root.
>> - *
>> - * dir_id is the directory in ref_tree where this root_id can be found.
>> - *
>> - * name is the name of root_id in that directory
>> - *
>> - * name_len is the length of name
>> + * add_root - update the existed root, or allocate a new root and insert it
>> + * into the lookup tree.
>> + * root_id: object id of the root
>> + * ref_tree: object id of the referring root.
>> + * root_offset: offset value of the root'key
>> + * dir_id: inode id of the directory in ref_tree where this root can be found.
>> + * name: the name of root_id in that directory
>> + * 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
>> + * uuid: uuid of the root
>> */
>> static int add_root(struct root_lookup *root_lookup,
>> - u64 root_id, u64 ref_tree, u64 dir_id, char *name,
>> - int name_len, u64 *gen, time_t ot, void *uuid)
>> + u64 root_id, u64 ref_tree, u64 root_offset, u64 dir_id,
>> + char *name, int name_len, u64 ogen, u64 gen, time_t ot,
>> + void *uuid)
>> {
>> struct root_info *ri;
>> - struct rb_node *ret;
>> - ri = malloc(sizeof(*ri) + name_len + 1);
>> + int ret;
>> +
>> + ret = update_root(root_lookup, root_id, ref_tree, root_offset, dir_id,
>> + name, name_len, ogen, gen, ot, uuid);
>> + if (!ret)
>> + return 0;
>> +
>> + ri = malloc(sizeof(*ri));
>> if (!ri) {
>> printf("memory allocation failed\n");
>> exit(1);
>> }
>> - memset(ri, 0, sizeof(*ri) + name_len + 1);
>> - ri->path = NULL;
>> - ri->dir_id = dir_id;
>> + memset(ri, 0, sizeof(*ri));
>> ri->root_id = root_id;
>> - ri->ref_tree = ref_tree;
>> - if (name)
>> +
>> + if (name && name_len > 0) {
>> + ri->name = malloc(name_len + 1);
>> + if (!ri->name) {
>> + fprintf(stderr, "memory allocation failed\n");
>> + exit(1);
>> + }
>> strncpy(ri->name, name, name_len);
>> - if (name_len > 0)
>> ri->name[name_len] = 0;
>> + }
>> + if (ref_tree)
>> + ri->ref_tree = ref_tree;
>> + if (dir_id)
>> + ri->dir_id = dir_id;
>> + if (root_offset)
>> + ri->root_offset = root_offset;
>> if (gen)
>> - ri->gen = *gen;
>> - ri->otime = ot;
>> + ri->gen = gen;
>> + if (ogen)
>> + ri->ogen = ogen;
>> + if (!ri->ogen && root_offset)
>> + ri->ogen = root_offset;
>> + if (ot)
>> + ri->otime = ot;
>>
>> if (uuid)
>> memcpy(&ri->uuid, uuid, BTRFS_UUID_SIZE);
>> - else
>> - memset(&ri->uuid, 0, BTRFS_UUID_SIZE);
>>
>> - ret = tree_insert(&root_lookup->root, root_id, ref_tree, gen,
>> - &ri->rb_node);
>> + ret = root_tree_insert(root_lookup, ri);
>> if (ret) {
>> printf("failed to insert tree %llu\n", (unsigned long long)root_id);
>> exit(1);
>> @@ -228,24 +506,33 @@ static int add_root(struct root_lookup *root_lookup,
>> return 0;
>> }
>>
>> -static int update_root(struct root_lookup *root_lookup, u64 root_id, u64 gen,
>> - time_t ot, void *uuid)
>> +void __free_root_info(struct root_info *ri)
>> {
>> - struct root_info *ri;
>> + if (ri->name)
>> + free(ri->name);
>>
>> - ri = tree_search(&root_lookup->root, root_id);
>> - if (!ri || ri->root_id != root_id) {
>> - fprintf(stderr, "could not find subvol %llu\n", root_id);
>> - return -ENOENT;
>> - }
>> - ri->gen = gen;
>> - ri->otime = ot;
>> - if (uuid)
>> - memcpy(&ri->uuid, uuid, BTRFS_UUID_SIZE);
>> - else
>> - memset(&ri->uuid, 0, BTRFS_UUID_SIZE);
>> + if (ri->path)
>> + free(ri->path);
>>
>> - return 0;
>> + if (ri->full_path)
>> + free(ri->full_path);
>> +
>> + free(ri);
>> +}
>> +
>> +void __free_all_subvolumn(struct root_lookup *root_tree)
>> +{
>> + struct root_info *entry;
>> + struct rb_node *n;
>> +
>> + n = rb_first(&root_tree->root);
>> + while (n) {
>> + entry = rb_entry(n, struct root_info, rb_node);
>> + rb_erase(n, &root_tree->root);
>> + __free_root_info(entry);
>> +
>> + n = rb_first(&root_tree->root);
>> + }
>> }
>>
>> /*
>> @@ -255,8 +542,7 @@ static int update_root(struct root_lookup *root_lookup, u64 root_id, u64 gen,
>> * This can't be called until all the root_info->path fields are filled
>> * in by lookup_ino_path
>> */
>> -static int resolve_root(struct root_lookup *rl, struct root_info *ri,
>> - u64 *parent_id, u64 *top_id, char **path)
>> +static int resolve_root(struct root_lookup *rl, struct root_info *ri)
>> {
>> char *full_path = NULL;
>> int len = 0;
>> @@ -266,7 +552,6 @@ static int resolve_root(struct root_lookup *rl, struct root_info *ri,
>> * we go backwards from the root_info object and add pathnames
>> * from parent directories as we go.
>> */
>> - *parent_id = 0;
>> found = ri;
>> while (1) {
>> char *tmp;
>> @@ -275,6 +560,10 @@ static int resolve_root(struct root_lookup *rl, struct root_info *ri,
>>
>> /* room for / and for null */
>> tmp = malloc(add_len + 2 + len);
>> + if (!tmp) {
>> + perror("malloc failed");
>> + exit(1);
>> + }
>> if (full_path) {
>> memcpy(tmp + add_len + 1, full_path, len);
>> tmp[add_len] = '/';
>> @@ -289,13 +578,10 @@ static int resolve_root(struct root_lookup *rl, struct root_info *ri,
>> }
>>
>> next = found->ref_tree;
>> - /* record the first parent */
>> - if (*parent_id == 0)
>> - *parent_id = next;
>>
>> /* if the ref_tree refers to ourselves, we're at the top */
>> if (next == found->root_id) {
>> - *top_id = next;
>> + ri->top_id = next;
>> break;
>> }
>>
>> @@ -303,14 +589,14 @@ static int resolve_root(struct root_lookup *rl, struct root_info *ri,
>> * if the ref_tree wasn't in our tree of roots, we're
>> * at the top
>> */
>> - found = tree_search(&rl->root, next);
>> + found = root_tree_search(rl, next);
>> if (!found) {
>> - *top_id = next;
>> + ri->top_id = next;
>> break;
>> }
>> }
>>
>> - *path = full_path;
>> + ri->full_path = full_path;
>>
>> return 0;
>> }
>> @@ -608,7 +894,7 @@ build:
>> return full;
>> }
>>
>> -static int get_default_subvolid(int fd, u64 *default_id)
>> +int btrfs_list_get_default_subvolume(int fd, u64 *default_id)
>> {
>> struct btrfs_ioctl_search_args args;
>> struct btrfs_ioctl_search_key *sk = &args.key;
>> @@ -674,10 +960,9 @@ static int __list_subvol_search(int fd, struct root_lookup *root_lookup)
>> int name_len;
>> char *name;
>> u64 dir_id;
>> - u8 type;
>> u64 gen = 0;
>> + u64 ogen;
>> int i;
>> - int get_gen = 0;
>> time_t t;
>> u8 uuid[BTRFS_UUID_SIZE];
>>
>> @@ -692,7 +977,7 @@ static int __list_subvol_search(int fd, struct root_lookup *root_lookup)
>> * only send back this type of key now.
>> */
>> sk->max_type = BTRFS_ROOT_BACKREF_KEY;
>> - sk->min_type = BTRFS_ROOT_BACKREF_KEY;
>> + sk->min_type = BTRFS_ROOT_ITEM_KEY;
>>
>> sk->min_objectid = BTRFS_FIRST_FREE_OBJECTID;
>>
>> @@ -704,7 +989,6 @@ static int __list_subvol_search(int fd, struct root_lookup *root_lookup)
>> sk->max_offset = (u64)-1;
>> sk->max_transid = (u64)-1;
>>
>> -again:
>> /* just a big number, doesn't matter much */
>> sk->nr_items = 4096;
>>
>> @@ -726,28 +1010,32 @@ again:
>> sh = (struct btrfs_ioctl_search_header *)(args.buf +
>> off);
>> off += sizeof(*sh);
>> - if (!get_gen && sh->type == BTRFS_ROOT_BACKREF_KEY) {
>> + if (sh->type == BTRFS_ROOT_BACKREF_KEY) {
>> ref = (struct btrfs_root_ref *)(args.buf + off);
>> name_len = btrfs_stack_root_ref_name_len(ref);
>> name = (char *)(ref + 1);
>> dir_id = btrfs_stack_root_ref_dirid(ref);
>>
>> add_root(root_lookup, sh->objectid, sh->offset,
>> - dir_id, name, name_len, NULL, 0, NULL);
>> - } else if (get_gen && sh->type == BTRFS_ROOT_ITEM_KEY) {
>> + 0, dir_id, name, name_len, 0, 0, 0,
>> + NULL);
>> + } else if (sh->type == BTRFS_ROOT_ITEM_KEY) {
>> ri = (struct btrfs_root_item *)(args.buf + off);
>> gen = btrfs_root_generation(ri);
>> if(sh->len >
>> sizeof(struct btrfs_root_item_v0)) {
>> t = ri->otime.sec;
>> + ogen = btrfs_root_otransid(ri);
>> memcpy(uuid, ri->uuid, BTRFS_UUID_SIZE);
>> } else {
>> t = 0;
>> + ogen = 0;
>> memset(uuid, 0, BTRFS_UUID_SIZE);
>> }
>>
>> - update_root(root_lookup, sh->objectid, gen, t,
>> - uuid);
>> + add_root(root_lookup, sh->objectid, 0,
>> + sh->offset, 0, NULL, 0, ogen, gen, t,
>> + uuid);
>> }
>>
>> off += sh->len;
>> @@ -761,129 +1049,139 @@ again:
>> sk->min_offset = sh->offset;
>> }
>> sk->nr_items = 4096;
>> - /* this iteration is done, step forward one root for the next
>> - * ioctl
>> - */
>> - if (get_gen)
>> - type = BTRFS_ROOT_ITEM_KEY;
>> + sk->min_offset++;
>> + if (!sk->min_offset) /* overflow */
>> + sk->min_type++;
>> else
>> - type = BTRFS_ROOT_BACKREF_KEY;
>> + continue;
>>
>> - if (sk->min_type < type) {
>> - sk->min_type = type;
>> - sk->min_offset = 0;
>> - } else if (sk->min_objectid < BTRFS_LAST_FREE_OBJECTID) {
>> + if (sk->min_type > BTRFS_ROOT_BACKREF_KEY) {
>> + sk->min_type = BTRFS_ROOT_ITEM_KEY;
>> sk->min_objectid++;
>> - sk->min_type = type;
>> - sk->min_offset = 0;
>> } else
>> + continue;
>> +
>> + if (sk->min_objectid > sk->max_objectid)
>> break;
>> }
>>
>> - if (!get_gen) {
>> - memset(&args, 0, sizeof(args));
>> + return 0;
>> +}
>>
>> - sk->tree_id = 1;
>> - sk->max_type = BTRFS_ROOT_ITEM_KEY;
>> - sk->min_type = BTRFS_ROOT_ITEM_KEY;
>> +static int filter_by_rootid(struct root_info *ri, void *arg)
>> +{
>> + u64 default_root_id = *((u64 *)arg);
>>
>> - sk->min_objectid = BTRFS_FIRST_FREE_OBJECTID;
>> + return ri->root_id == default_root_id;
>> +}
>>
>> - sk->max_objectid = BTRFS_LAST_FREE_OBJECTID;
>> - sk->max_offset = (u64)-1;
>> - sk->max_transid = (u64)-1;
>> +static int filter_snapshot(struct root_info *ri, void *arg)
>> +{
>> + return !!ri->root_offset;
>> +}
>> +
>> +static btrfs_list_filter_func all_filter_funcs[] = {
>> + [BTRFS_LIST_FILTER_ROOTID] = filter_by_rootid,
>> + [BTRFS_LIST_FILTER_SNAPSHOT_ONLY] = filter_snapshot,
>> +};
>>
>> - get_gen = 1;
>> - goto again;
>> +struct btrfs_list_filter_set *btrfs_list_alloc_filter_set(void)
>> +{
>> + struct btrfs_list_filter_set *set;
>> + int size;
>> +
>> + size = sizeof(struct btrfs_list_filter_set) +
>> + BTRFS_LIST_NFILTERS_INCREASE * sizeof(struct btrfs_list_filter);
>> + set = malloc(size);
>> + if (!set) {
>> + fprintf(stderr, "memory allocation failed\n");
>> + exit(1);
>> }
>> - return 0;
>> +
>> + memset(set, 0, size);
>> + set->total = BTRFS_LIST_NFILTERS_INCREASE;
>> +
>> + return set;
>> }
>>
>> -static int __list_snapshot_search(int fd, struct root_lookup *root_lookup)
>> +void btrfs_list_free_filter_set(struct btrfs_list_filter_set *filter_set)
>> {
>> - int ret;
>> - struct btrfs_ioctl_search_args args;
>> - struct btrfs_ioctl_search_key *sk = &args.key;
>> - struct btrfs_ioctl_search_header *sh;
>> - unsigned long off = 0;
>> - u64 gen = 0;
>> - int i;
>> -
>> - root_lookup_init(root_lookup);
>> - memset(&args, 0, sizeof(args));
>> + free(filter_set);
>> +}
>>
>> - sk->tree_id = 1;
>> - sk->max_type = BTRFS_ROOT_ITEM_KEY;
>> - sk->min_type = BTRFS_ROOT_ITEM_KEY;
>> - sk->min_objectid = BTRFS_FIRST_FREE_OBJECTID;
>> - sk->max_objectid = BTRFS_LAST_FREE_OBJECTID;
>> - sk->max_offset = (u64)-1;
>> - sk->max_transid = (u64)-1;
>> - sk->nr_items = 4096;
>> +int btrfs_list_setup_filter(struct btrfs_list_filter_set **filter_set,
>> + enum btrfs_list_filter_enum filter, void *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);
>> +
>> + if (set->nfilters == set->total) {
>> + size = set->total + BTRFS_LIST_NFILTERS_INCREASE;
>> + size = sizeof(*set) + size * sizeof(struct btrfs_list_filter);
>> + set = realloc(set, size);
>> + if (!set) {
>> + fprintf(stderr, "memory allocation failed\n");
>> + exit(1);
>> + }
>>
>> - while (1) {
>> - 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;
>> + memset(&set->filters[set->total], 0,
>> + BTRFS_LIST_NFILTERS_INCREASE *
>> + sizeof(struct btrfs_list_filter));
>> + set->total += BTRFS_LIST_NFILTERS_INCREASE;
>> + *filter_set = set;
>> + }
>>
>> - off = 0;
>> + BUG_ON(set->filters[set->nfilters].filter_func);
>>
>> - /*
>> - * for each item, pull the key out of the header and then
>> - * read the root_ref item it contains
>> - */
>> - for (i = 0; i < sk->nr_items; i++) {
>> - struct btrfs_root_item *item;
>> - time_t t;
>> - u8 uuid[BTRFS_UUID_SIZE];
>> + set->filters[set->nfilters].filter_func = all_filter_funcs[filter];
>> + set->filters[set->nfilters].data = data;
>> + set->nfilters++;
>> + return 0;
>> +}
>>
>> - sh = (struct btrfs_ioctl_search_header *)(args.buf +
>> - off);
>> - off += sizeof(*sh);
>> - if (sh->type == BTRFS_ROOT_ITEM_KEY && sh->offset) {
>> - item = (struct btrfs_root_item *)(args.buf + off);
>> - if(sh->len >
>> - sizeof(struct btrfs_root_item_v0)) {
>> - t = item->otime.sec;
>> - memcpy(uuid, item->uuid,
>> - BTRFS_UUID_SIZE);
>> - } else {
>> - t = 0;
>> - memset(uuid, 0, BTRFS_UUID_SIZE);
>> - }
>> - gen = sh->offset;
>> +static int filter_root(struct root_info *ri,
>> + struct btrfs_list_filter_set *set)
>> +{
>> + int i, ret;
>>
>> - add_root(root_lookup, sh->objectid, 0,
>> - 0, NULL, 0, &gen, t, uuid);
>> - }
>> - off += sh->len;
>> + if (!set || !set->nfilters)
>> + return 1;
>>
>> - /*
>> - * 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;
>> - /* this iteration is done, step forward one root for the next
>> - * ioctl
>> - */
>> - if (sk->min_type < BTRFS_ROOT_ITEM_KEY) {
>> - sk->min_type = BTRFS_ROOT_ITEM_KEY;
>> - sk->min_offset = 0;
>> - } else if (sk->min_objectid < BTRFS_LAST_FREE_OBJECTID) {
>> - sk->min_objectid++;
>> - sk->min_type = BTRFS_ROOT_ITEM_KEY;
>> - sk->min_offset = 0;
>> - } else
>> + for (i = 0; i < set->nfilters; i++) {
>> + if (!set->filters[i].filter_func)
>> break;
>> + ret = set->filters[i].filter_func(ri, set->filters[i].data);
>> + if (!ret)
>> + return 0;
>> + }
>> + return 1;
>> +}
>> +
>> +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)
>> +{
>> + struct rb_node *n;
>> + struct root_info *entry;
>> + int ret;
>> +
>> + root_lookup_init(sort_tree);
>> +
>> + n = rb_last(&all_subvols->root);
>> + while (n) {
>> + entry = rb_entry(n, struct root_info, rb_node);
>> +
>> + resolve_root(all_subvols, entry);
>> + ret = filter_root(entry, filter_set);
>> + if (ret)
>> + sort_tree_insert(sort_tree, entry, comp_set);
>> + n = rb_prev(n);
>> }
>> - return 0;
>> }
>>
>> static int __list_subvol_fill_paths(int fd, struct root_lookup *root_lookup)
>> @@ -904,128 +1202,91 @@ static int __list_subvol_fill_paths(int fd, struct root_lookup *root_lookup)
>> return 0;
>> }
>>
>> -int list_subvols(int fd, int print_parent, int get_default, int print_uuid)
>> +static void print_subvolume_column(struct root_info *subv,
>> + enum btrfs_list_column_enum column)
>> {
>> - struct root_lookup root_lookup;
>> - struct rb_node *n;
>> - u64 default_id;
>> - int ret;
>> + char tstr[256];
>> char uuidparse[37];
>>
>> - if (get_default) {
>> - ret = get_default_subvolid(fd, &default_id);
>> - if (ret) {
>> - fprintf(stderr, "ERROR: can't perform the search - %s\n",
>> - strerror(errno));
>> - return ret;
>> - }
>> - if (default_id == 0) {
>> - fprintf(stderr, "ERROR: 'default' dir item not found\n");
>> - return ret;
>> - }
>> -
>> - /* no need to resolve roots if FS_TREE is default */
>> - if (default_id == BTRFS_FS_TREE_OBJECTID) {
>> - printf("ID 5 (FS_TREE)\n");
>> - return ret;
>> - }
>> - }
>> -
>> - ret = __list_subvol_search(fd, &root_lookup);
>> - if (ret) {
>> - fprintf(stderr, "ERROR: can't perform the search - %s\n",
>> - strerror(errno));
>> - return ret;
>> + BUG_ON(column >= BTRFS_LIST_ALL || column < 0);
>> +
>> + switch (column) {
>> + case BTRFS_LIST_OBJECTID:
>> + printf("%llu", subv->root_id);
>> + break;
>> + case BTRFS_LIST_GENERATION:
>> + printf("%llu", subv->gen);
>> + break;
>> + case BTRFS_LIST_OGENERATION:
>> + printf("%llu", subv->ogen);
>> + break;
>> + case BTRFS_LIST_PARENT:
>> + printf("%llu", subv->ref_tree);
>> + break;
>> + case BTRFS_LIST_TOP_LEVEL:
>> + printf("%llu", subv->top_id);
>> + break;
>> + case BTRFS_LIST_OTIME:
>> + if (subv->otime)
>> + strftime(tstr, 256, "%Y-%m-%d %X",
>> + localtime(&subv->otime));
>> + else
>> + strcpy(tstr, "-");
>> + printf("%s", tstr);
>> + break;
>> + case BTRFS_LIST_UUID:
>> + if (uuid_is_null(subv->uuid))
>> + strcpy(uuidparse, "-");
>> + else
>> + uuid_unparse(subv->uuid, uuidparse);
>> + printf("%s", uuidparse);
>> + break;
>> + case BTRFS_LIST_PATH:
>> + BUG_ON(!subv->full_path);
>> + printf("%s", subv->full_path);
>> + break;
>> + default:
>> + break;
>> }
>> +}
>>
>> - /*
>> - * 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);
>> - if (ret < 0)
>> - return ret;
>> -
>> - /* now that we have all the subvol-relative paths filled in,
>> - * we have to string the subvols together so that we can get
>> - * a path all the way back to the FS root
>> - */
>> - n = rb_last(&root_lookup.root);
>> - while (n) {
>> - struct root_info *entry;
>> - u64 level;
>> - u64 parent_id;
>> - char *path;
>> +static void print_single_volume_info_default(struct root_info *subv)
>> +{
>> + int i;
>>
>> - entry = rb_entry(n, struct root_info, rb_node);
>> - if (get_default && entry->root_id != default_id) {
>> - n = rb_prev(n);
>> + for (i = 0; i < BTRFS_LIST_ALL; i++) {
>> + if (!btrfs_list_columns[i].need_print)
>> continue;
>> - }
>>
>> - resolve_root(&root_lookup, entry, &parent_id, &level, &path);
>> - if (print_parent) {
>> - if (print_uuid) {
>> - if (uuid_is_null(entry->uuid))
>> - strcpy(uuidparse, "-");
>> - else
>> - uuid_unparse(entry->uuid, uuidparse);
>> - printf("ID %llu gen %llu parent %llu top level %llu"
>> - " uuid %s path %s\n",
>> - (unsigned long long)entry->root_id,
>> - (unsigned long long)entry->gen,
>> - (unsigned long long)parent_id,
>> - (unsigned long long)level,
>> - uuidparse, path);
>> - } else {
>> - printf("ID %llu gen %llu parent %llu top level"
>> - " %llu path %s\n",
>> - (unsigned long long)entry->root_id,
>> - (unsigned long long)entry->gen,
>> - (unsigned long long)parent_id,
>> - (unsigned long long)level, path);
>> - }
>> - } else {
>> - if (print_uuid) {
>> - if (uuid_is_null(entry->uuid))
>> - strcpy(uuidparse, "-");
>> - else
>> - uuid_unparse(entry->uuid, uuidparse);
>> - printf("ID %llu gen %llu top level %llu"
>> - " uuid %s path %s\n",
>> - (unsigned long long)entry->root_id,
>> - (unsigned long long)entry->gen,
>> - (unsigned long long)level,
>> - uuidparse, path);
>> - } else {
>> - printf("ID %llu gen %llu top level %llu path %s\n",
>> - (unsigned long long)entry->root_id,
>> - (unsigned long long)entry->gen,
>> - (unsigned long long)level, path);
>> - }
>> - }
>> + printf("%s ", btrfs_list_columns[i].name);
>> + print_subvolume_column(subv, i);
>>
>> - free(path);
>> - n = rb_prev(n);
>> + if (i != BTRFS_LIST_PATH)
>> + printf(" ");
>> }
>> + printf("\n");
>> +}
>>
>> - return ret;
>> +static void print_all_volume_info_default(struct root_lookup *sorted_tree)
>> +{
>> + struct rb_node *n;
>> + struct root_info *entry;
>> +
>> + n = rb_first(&sorted_tree->root);
>> + while (n) {
>> + entry = rb_entry(n, struct root_info, sort_node);
>> + print_single_volume_info_default(entry);
>> + n = rb_next(n);
>> + }
>> }
>>
>> -int list_snapshots(int fd, int print_parent, int order, int print_uuid)
>> +int btrfs_list_subvols(int fd, struct btrfs_list_filter_set *filter_set,
>> + struct btrfs_list_comparer_set *comp_set)
>> {
>> struct root_lookup root_lookup;
>> - struct root_lookup root_lookup_snap;
>> - struct rb_node *n;
>> + struct root_lookup root_sort;
>> int ret;
>>
>> - ret = __list_snapshot_search(fd, &root_lookup_snap);
>> - if (ret) {
>> - fprintf(stderr, "ERROR: can't perform the search - %s\n",
>> - strerror(errno));
>> - return ret;
>> - }
>> -
>> ret = __list_subvol_search(fd, &root_lookup);
>> if (ret) {
>> fprintf(stderr, "ERROR: can't perform the search - %s\n",
>> @@ -1041,86 +1302,11 @@ int list_snapshots(int fd, int print_parent, int order, int print_uuid)
>> if (ret < 0)
>> return ret;
>>
>> - /* now that we have all the subvol-relative paths filled in,
>> - * we have to string the subvols together so that we can get
>> - * a path all the way back to the FS root
>> - */
>> - if (!order)
>> - n = rb_last(&root_lookup_snap.root);
>> - else
>> - n = rb_first(&root_lookup_snap.root);
>> - while (n) {
>> - struct root_info *entry_snap;
>> - struct root_info *entry;
>> - u64 level;
>> - u64 parent_id;
>> - char *path;
>> - time_t t;
>> - char tstr[256];
>> - char uuidparse[37];
>> -
>> - entry_snap = rb_entry(n, struct root_info, rb_node);
>> - entry = tree_search(&root_lookup.root, entry_snap->root_id);
>> -
>> - resolve_root(&root_lookup, entry, &parent_id, &level, &path);
>> - t = entry->otime;
>> - if(t)
>> - strftime(tstr,256,"%Y-%m-%d %X",localtime(&t));
>> - else
>> - strcpy(tstr,"-");
>> - if (print_parent) {
>> - if (print_uuid) {
>> - if (uuid_is_null(entry->uuid))
>> - strcpy(uuidparse, "-");
>> - else
>> - uuid_unparse(entry->uuid, uuidparse);
>> - printf("ID %llu gen %llu cgen %llu parent %llu"
>> - " top level %llu otime %s uuid %s path %s\n",
>> - (unsigned long long)entry->root_id,
>> - (unsigned long long)entry->gen,
>> - (unsigned long long)entry_snap->gen,
>> - (unsigned long long)parent_id,
>> - (unsigned long long)level,
>> - tstr, uuidparse, path);
>> - } else {
>> - printf("ID %llu gen %llu cgen %llu parent %llu"
>> - " top level %llu otime %s path %s\n",
>> - (unsigned long long)entry->root_id,
>> - (unsigned long long)entry->gen,
>> - (unsigned long long)entry_snap->gen,
>> - (unsigned long long)parent_id,
>> - (unsigned long long)level, tstr, path);
>> - }
>> - } else {
>> - if (print_uuid) {
>> - if (uuid_is_null(entry->uuid))
>> - strcpy(uuidparse, "-");
>> - else
>> - uuid_unparse(entry->uuid, uuidparse);
>> - printf("ID %llu gen %llu cgen %llu top level %llu "
>> - "otime %s uuid %s path %s\n",
>> - (unsigned long long)entry->root_id,
>> - (unsigned long long)entry->gen,
>> - (unsigned long long)entry_snap->gen,
>> - (unsigned long long)level,
>> - tstr, uuidparse, path);
>> - } else {
>> - printf("ID %llu gen %llu cgen %llu top level %llu "
>> - "otime %s path %s\n",
>> - (unsigned long long)entry->root_id,
>> - (unsigned long long)entry->gen,
>> - (unsigned long long)entry_snap->gen,
>> - (unsigned long long)level, tstr, path);
>> - }
>> - }
>> -
>> - free(path);
>> - if (!order)
>> - n = rb_prev(n);
>> - else
>> - n = rb_next(n);
>> - }
>> + __filter_and_sort_subvol(&root_lookup, &root_sort, filter_set,
>> + comp_set);
>>
>> + print_all_volume_info_default(&root_sort);
>> + __free_all_subvolumn(&root_lookup);
>> return ret;
>> }
>>
>> @@ -1203,7 +1389,7 @@ static int print_one_extent(int fd, struct btrfs_ioctl_search_header *sh,
>> return 0;
>> }
>>
>> -int find_updated_files(int fd, u64 root_id, u64 oldest_gen)
>> +int btrfs_list_find_updated_files(int fd, u64 root_id, u64 oldest_gen)
>> {
>> int ret;
>> struct btrfs_ioctl_search_args args;
>> @@ -1304,7 +1490,7 @@ int find_updated_files(int fd, u64 root_id, u64 oldest_gen)
>> return ret;
>> }
>>
>> -char *path_for_root(int fd, u64 root)
>> +char *btrfs_list_path_for_root(int fd, u64 root)
>> {
>> struct root_lookup root_lookup;
>> struct rb_node *n;
>> @@ -1322,19 +1508,17 @@ char *path_for_root(int fd, u64 root)
>> n = rb_last(&root_lookup.root);
>> while (n) {
>> struct root_info *entry;
>> - u64 parent_id;
>> - u64 level;
>> - char *path;
>>
>> entry = rb_entry(n, struct root_info, rb_node);
>> - resolve_root(&root_lookup, entry, &parent_id, &level, &path);
>> - if (entry->root_id == root)
>> - ret_path = path;
>> - else
>> - free(path);
>> + resolve_root(&root_lookup, entry);
>> + if (entry->root_id == root) {
>> + ret_path = entry->full_path;
>> + entry->full_path = NULL;
>> + }
>>
>> n = rb_prev(n);
>> }
>> + __free_all_subvolumn(&root_lookup);
>>
>> return ret_path;
>> }
>> diff --git a/btrfs-list.h b/btrfs-list.h
>> index b4a7f30..ca3eb7b 100644
>> --- a/btrfs-list.h
>> +++ b/btrfs-list.h
>> @@ -16,7 +16,72 @@
>> * Boston, MA 021110-1307, USA.
>> */
>>
>> -int list_subvols(int fd, int print_parent, int get_default, int print_uuid);
>> -int list_snapshots(int fd, int print_parent, int order, int print_uuid);
>> -int find_updated_files(int fd, u64 root_id, u64 oldest_gen);
>> -char *path_for_root(int fd, u64 root);
>> +struct root_info;
>> +
>> +typedef int (*btrfs_list_filter_func)(struct root_info *, void *);
>> +typedef int (*btrfs_list_comp_func)(struct root_info *, struct root_info *,
>> + int);
>> +
>> +struct btrfs_list_filter {
>> + btrfs_list_filter_func filter_func;
>> + void *data;
>> +};
>> +
>> +struct btrfs_list_comparer {
>> + btrfs_list_comp_func comp_func;
>> + int is_descending;
>> +};
>> +
>> +struct btrfs_list_filter_set {
>> + int total;
>> + int nfilters;
>> + struct btrfs_list_filter filters[0];
>> +};
>> +
>> +struct btrfs_list_comparer_set {
>> + int total;
>> + int ncomps;
>> + struct btrfs_list_comparer comps[0];
>> +};
>> +
>> +enum btrfs_list_column_enum {
>> + BTRFS_LIST_OBJECTID,
>> + BTRFS_LIST_GENERATION,
>> + BTRFS_LIST_OGENERATION,
>> + BTRFS_LIST_PARENT,
>> + BTRFS_LIST_TOP_LEVEL,
>> + BTRFS_LIST_OTIME,
>> + BTRFS_LIST_UUID,
>> + BTRFS_LIST_PATH,
>> + BTRFS_LIST_ALL,
>> +};
>> +
>> +enum btrfs_list_filter_enum {
>> + BTRFS_LIST_FILTER_ROOTID,
>> + BTRFS_LIST_FILTER_SNAPSHOT_ONLY,
>> + BTRFS_LIST_FILTER_MAX,
>> +};
>> +
>> +enum btrfs_list_comp_enum {
>> + BTRFS_LIST_COMP_ROOTID,
>> + BTRFS_LIST_COMP_OGEN,
>> + BTRFS_LIST_COMP_GEN,
>> + BTRFS_LIST_COMP_MAX,
>> +};
>> +
>> +void btrfs_list_setup_print_column(enum btrfs_list_column_enum column);
>> +struct btrfs_list_filter_set *btrfs_list_alloc_filter_set(void);
>> +void btrfs_list_free_filter_set(struct btrfs_list_filter_set *filter_set);
>> +int btrfs_list_setup_filter(struct btrfs_list_filter_set **filter_set,
>> + enum btrfs_list_filter_enum filter, void *data);
>> +struct btrfs_list_comparer_set *btrfs_list_alloc_comparer_set(void);
>> +void btrfs_list_free_comparer_set(struct btrfs_list_comparer_set *comp_set);
>> +int btrfs_list_setup_comparer(struct btrfs_list_comparer_set **comp_set,
>> + enum btrfs_list_comp_enum comparer,
>> + int is_descending);
>> +
>> +int btrfs_list_subvols(int fd, struct btrfs_list_filter_set *filter_set,
>> + struct btrfs_list_comparer_set *comp_set);
>> +int btrfs_list_find_updated_files(int fd, u64 root_id, u64 oldest_gen);
>> +int btrfs_list_get_default_subvolume(int fd, u64 *default_id);
>> +char *btrfs_list_path_for_root(int fd, u64 root);
>> diff --git a/cmds-inspect.c b/cmds-inspect.c
>> index f943ed9..376fab2 100644
>> --- a/cmds-inspect.c
>> +++ b/cmds-inspect.c
>> @@ -194,7 +194,7 @@ static int cmd_logical_resolve(int argc, char **argv)
>> char *name;
>>
>> if (getpath) {
>> - name = path_for_root(fd, root);
>> + name = btrfs_list_path_for_root(fd, root);
>> if (IS_ERR(name))
>> return PTR_ERR(name);
>> if (!name) {
>> diff --git a/cmds-subvolume.c b/cmds-subvolume.c
>> index cd4b5a7..b1cf2bd 100644
>> --- a/cmds-subvolume.c
>> +++ b/cmds-subvolume.c
>> @@ -28,6 +28,7 @@
>> #include "ioctl.h"
>> #include "qgroup.h"
>>
>> +#include "ctree.h"
>> #include "commands.h"
>> #include "btrfs-list.h"
>>
>> @@ -270,13 +271,15 @@ static const char * const cmd_subvol_list_usage[] = {
>>
>> static int cmd_subvol_list(int argc, char **argv)
>> {
>> + struct btrfs_list_filter_set *filter_set;
>> + struct btrfs_list_comparer_set *comparer_set;
>> int fd;
>> int ret;
>> - int print_parent = 0;
>> - int print_snap_only = 0;
>> - int order = 0;
>> + int order;
>> char *subvol;
>> - int print_uuid = 0;
>> +
>> + filter_set = btrfs_list_alloc_filter_set();
>> + comparer_set = btrfs_list_alloc_comparer_set();
>>
>> optind = 1;
>> while(1) {
>> @@ -286,14 +289,21 @@ static int cmd_subvol_list(int argc, char **argv)
>>
>> switch(c) {
>> case 'p':
>> - print_parent = 1;
>> + btrfs_list_setup_print_column(BTRFS_LIST_PARENT);
>> break;
>> case 's':
>> - print_snap_only = 1;
>> order = atoi(optarg);
>> + btrfs_list_setup_filter(&filter_set,
>> + BTRFS_LIST_FILTER_SNAPSHOT_ONLY,
>> + NULL);
>> + btrfs_list_setup_comparer(&comparer_set,
>> + BTRFS_LIST_COMP_OGEN,
>> + !order);
>> + btrfs_list_setup_print_column(BTRFS_LIST_OGENERATION);
>> + btrfs_list_setup_print_column(BTRFS_LIST_OTIME);
>> break;
>> case 'u':
>> - print_uuid =1;
>> + btrfs_list_setup_print_column(BTRFS_LIST_UUID);
>> break;
>> default:
>> usage(cmd_subvol_list_usage);
>> @@ -320,10 +330,8 @@ static int cmd_subvol_list(int argc, char **argv)
>> fprintf(stderr, "ERROR: can't access '%s'\n", subvol);
>> return 12;
>> }
>> - if (!print_snap_only)
>> - ret = list_subvols(fd, print_parent, 0, print_uuid);
>> - else
>> - ret = list_snapshots(fd, print_parent, order, print_uuid);
>> +
>> + ret = btrfs_list_subvols(fd, filter_set, comparer_set);
>> if (ret)
>> return 19;
>> return 0;
>> @@ -483,6 +491,8 @@ static int cmd_subvol_get_default(int argc, char **argv)
>> int fd;
>> int ret;
>> char *subvol;
>> + struct btrfs_list_filter_set *filter_set;
>> + u64 default_id;
>>
>> if (check_argc_exact(argc, 2))
>> usage(cmd_subvol_get_default_usage);
>> @@ -504,7 +514,30 @@ static int cmd_subvol_get_default(int argc, char **argv)
>> fprintf(stderr, "ERROR: can't access '%s'\n", subvol);
>> return 12;
>> }
>> - ret = list_subvols(fd, 0, 1, 0);
>> +
>> + ret = btrfs_list_get_default_subvolume(fd, &default_id);
>> + if (ret) {
>> + fprintf(stderr, "ERROR: can't perform the search - %s\n",
>> + strerror(errno));
>> + return ret;
>> + }
>> +
>> + if (default_id == 0) {
>> + fprintf(stderr, "ERROR: 'default' dir item not found\n");
>> + return ret;
>> + }
>> +
>> + /* no need to resolve roots if FS_TREE is default */
>> + if (default_id == BTRFS_FS_TREE_OBJECTID) {
>> + printf("ID 5 (FS_TREE)\n");
>> + return ret;
>> + }
>> +
>> + filter_set = btrfs_list_alloc_filter_set();
>> + btrfs_list_setup_filter(&filter_set, BTRFS_LIST_FILTER_ROOTID,
>> + (void *)&default_id);
>> +
>> + ret = btrfs_list_subvols(fd, filter_set, NULL);
>> if (ret)
>> return 19;
>> return 0;
>> @@ -585,7 +618,7 @@ static int cmd_find_new(int argc, char **argv)
>> fprintf(stderr, "ERROR: can't access '%s'\n", subvol);
>> return 12;
>> }
>> - ret = find_updated_files(fd, 0, last_gen);
>> + ret = btrfs_list_find_updated_files(fd, 0, last_gen);
>> if (ret)
>> return 19;
>> return 0;
>> diff --git a/send-utils.c b/send-utils.c
>> index 096fa02..fcde5c2 100644
>> --- a/send-utils.c
>> +++ b/send-utils.c
>> @@ -244,7 +244,8 @@ int subvol_uuid_search_init(int mnt_fd, struct subvol_uuid_search *s)
>> if (!root_item_valid)
>> goto skip;
>>
>> - path = path_for_root(mnt_fd, sh->objectid);
>> + path = btrfs_list_path_for_root(mnt_fd,
>> + sh->objectid);
>> if (!path)
>> path = strdup("");
>> if (IS_ERR(path)) {
>> --
>> 1.7.6.5
>>
>> --
>> To unsubscribe from this list: send the line "unsubscribe linux-btrfs" in
>> the body of a message to majordomo@xxxxxxxxxxxxxxx
>> More majordomo info at http://vger.kernel.org/majordomo-info.html
>
--
To unsubscribe from this list: send the line "unsubscribe linux-btrfs" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at http://vger.kernel.org/majordomo-info.html
