From: Alex Lyakas <alex@zadarastorage.com>
To: miaox@cn.fujitsu.com
Cc: linux-btrfs@vger.kernel.org
Subject: Re: [PATCH V4 5/7] Btrfs-progs: restructure list_subvolumes
Date: Wed, 10 Oct 2012 21:45:31 +0200 [thread overview]
Message-ID: <CAOcd+r115os7M+MFHoVzMBE4WhyBG+2=EFjwPqNPwPsvVBNOvg@mail.gmail.com> (raw)
In-Reply-To: <5074D9A3.2070405@cn.fujitsu.com>
Hi Miao,
you are absolutely right, it could have happened with the old code as well.
On Wed, Oct 10, 2012 at 4:12 AM, Miao Xie <miaox@cn.fujitsu.com> wrote:
> 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.
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);
+ }
+}
+
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-10 19:45 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 [this message]
2012-10-15 4:06 ` Miao Xie
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='CAOcd+r115os7M+MFHoVzMBE4WhyBG+2=EFjwPqNPwPsvVBNOvg@mail.gmail.com' \
--to=alex@zadarastorage.com \
--cc=linux-btrfs@vger.kernel.org \
--cc=miaox@cn.fujitsu.com \
/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).