From: Miao Xie <miaox@cn.fujitsu.com>
To: Alex Lyakas <alex@zadarastorage.com>
Cc: linux-btrfs@vger.kernel.org
Subject: Re: [PATCH V4 5/7] Btrfs-progs: restructure list_subvolumes
Date: Mon, 15 Oct 2012 12:06:19 +0800 [thread overview]
Message-ID: <507B8BBB.1030700@cn.fujitsu.com> (raw)
In-Reply-To: <CAOcd+r115os7M+MFHoVzMBE4WhyBG+2=EFjwPqNPwPsvVBNOvg@mail.gmail.com>
On Wed, 10 Oct 2012 21:45:31 +0200, Alex Lyakas wrote:
>>> 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.
>
> Something like this?
>
> diff --git a/btrfs-list.c b/btrfs-list.c
> index e5f0f96..5fd262c 100644
> --- a/btrfs-list.c
> +++ b/btrfs-list.c
> @@ -1004,6 +1004,23 @@ out:
> return 0;
> }
>
> +static void __drop_deleting_roots(struct root_lookup *root_lookup)
> +{
> + struct rb_node *n;
> +
> +again:
> + n = rb_first(&root_lookup->root);
> + while (n) {
> + struct root_info *entry = rb_entry(n, struct
> root_info, rb_node);
> + if (!entry->ref_tree) {
> + rb_erase(n, &root_lookup->root);
> + free(entry);
> + goto again;
> + }
> + n = rb_next(n);
> + }
> +}
It is better that we do it in lookup_ino_path(), or we can not avoid the problem
that I said above.(delete the subvolume completely between __list_subvol_search() and
__list_subvol_fill_paths().)
Thanks
Miao
> static int __list_subvol_search(int fd, struct root_lookup *root_lookup)
> {
> int ret;
> @@ -1123,6 +1140,8 @@ static int __list_subvol_search(int fd, struct
> root_lookup *root_lookup)
> break;
> }
>
> + __drop_deleting_roots(root_lookup);
> +
> return 0;
> }
>
>
>
>
>
>
>
>
>>
>>>
>>> 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@cn.fujitsu.com> 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@cn.fujitsu.com>
>>>> ---
>>>> 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@vger.kernel.org
>>>> More majordomo info at http://vger.kernel.org/majordomo-info.html
>>>
>>
>>
>
> Alex.
>
next prev parent reply other threads:[~2012-10-15 4:06 UTC|newest]
Thread overview: 31+ messages / expand[flat|nested] mbox.gz Atom feed top
2012-09-18 10:35 [PATCH V4 0/7 ] Btrfs-progs: enhance btrfs subvol list only to show read-only snapshots Miao Xie
2012-09-18 10:50 ` [PATCH V4 1/7] Btrfs-progs: move the function declarations to a new head file Miao Xie
2012-09-18 10:52 ` [PATCH V4 2/7] Btrfs-progs: fix compile warning of implicit declaration of "list_snapshots" Miao Xie
2012-09-18 10:55 ` [PATCH V4 3/7] Btrfs-progs: fix wrong usage of btrfs subvolume list command Miao Xie
2012-09-18 10:59 ` [PATCH V4 4/7] Btrfs-progs: fix wrong way to check if the root item contains otime and uuid Miao Xie
2012-09-19 1:55 ` Anand Jain
2012-09-19 2:58 ` Miao Xie
2012-09-18 11:06 ` [PATCH V4 5/7] Btrfs-progs: restructure list_subvolumes Miao Xie
2012-09-20 12:09 ` David Sterba
2012-10-09 16:05 ` Alex Lyakas
2012-10-10 2:12 ` Miao Xie
2012-10-10 19:45 ` Alex Lyakas
2012-10-15 4:06 ` Miao Xie [this message]
2012-09-18 11:09 ` [PATCH V4 6/7] Btrfs-progs: enhance btrfs subvol list only to show read-only snapshots Miao Xie
2012-09-18 15:11 ` Martin Steigerwald
2012-09-18 11:12 ` [PATCH V4 7/7] Btrfs-progs: update the manpage entries for the btrfs subvolume list Miao Xie
2012-09-28 12:55 ` [PATCH] Btrfs-progs: make btrfs_list_setup_filter to modify a set filter Anand jain
2012-10-03 0:03 ` [PATCH V4 0/7 ] Btrfs-progs: enhance btrfs subvol list only to show read-only snapshots Chris Mason
2012-10-09 6:01 ` Miao Xie
2012-10-09 15:57 ` David Sterba
2012-10-04 10:12 ` [PATCH] Btrfs-progs: add parent uuid for snapshots Anand jain
2012-10-04 12:00 ` Dong Robin
2012-10-05 2:27 ` Anand Jain
2012-10-05 2:25 ` [PATCH] Btrfs-progs: Corrections and additions to the btrfs man page Anand jain
2012-10-05 2:25 ` [PATCH] Btrfs-progs: Update btrfs man page for -P option Anand jain
2012-10-05 2:25 ` [PATCH V2] Btrfs-progs: add parent uuid for snapshots Anand jain
2012-10-09 15:44 ` David Sterba
2012-10-16 7:00 ` [PATCH V3] " Anand jain
2012-10-16 7:00 ` [PATCH] Btrfs-progs: make use of column_name Anand jain
2012-10-16 7:00 ` [PATCH] Btrfs-progs: update man page for -u and -q option in subvol list Anand jain
2012-10-16 7:03 ` [PATCH V2] Btrfs-progs: add parent uuid for snapshots Anand Jain
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=507B8BBB.1030700@cn.fujitsu.com \
--to=miaox@cn.fujitsu.com \
--cc=alex@zadarastorage.com \
--cc=linux-btrfs@vger.kernel.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).