btrfs_list_columns[i].need_print = 1;
}
-static void root_lookup_init(struct root_lookup *tree)
-{
- tree->root.rb_node = NULL;
-}
-
static int comp_entry_with_rootid(struct root_info *entry1,
struct root_info *entry2,
int is_descending)
int i, ret = 0;
if (!set || !set->ncomps)
- goto comp_rootid;
+ return comp_entry_with_rootid(entry1, entry2, 0);
for (i = 0; i < set->ncomps; i++) {
if (!set->comps[i].comp_func)
rootid_compared = 1;
}
- if (!rootid_compared) {
-comp_rootid:
+ if (!rootid_compared)
ret = comp_entry_with_rootid(entry1, entry2, 0);
- }
return ret;
}
static int update_root(struct root_lookup *root_lookup,
u64 root_id, u64 ref_tree, u64 root_offset, u64 flags,
u64 dir_id, char *name, int name_len, u64 ogen, u64 gen,
- time_t ot, void *uuid, void *puuid, void *ruuid)
+ time_t otime, u8 *uuid, u8 *puuid, u8 *ruuid)
{
struct root_info *ri;
ri->ogen = ogen;
if (!ri->ogen && root_offset)
ri->ogen = root_offset;
- if (ot)
- ri->otime = ot;
+ if (otime)
+ ri->otime = otime;
if (uuid)
memcpy(&ri->uuid, uuid, BTRFS_UUID_SIZE);
if (puuid)
* name_len: the length of name
* ogen: the original generation of the root
* gen: the current generation of the root
- * ot: the original time(create time) of the root
+ * otime: the original time (creation time) of the root
* uuid: uuid of the root
* puuid: uuid of the root parent if any
* ruuid: uuid of the received subvol, if any
static int add_root(struct root_lookup *root_lookup,
u64 root_id, u64 ref_tree, u64 root_offset, u64 flags,
u64 dir_id, char *name, int name_len, u64 ogen, u64 gen,
- time_t ot, void *uuid, void *puuid, void *ruuid)
+ time_t otime, u8 *uuid, u8 *puuid, u8 *ruuid)
{
struct root_info *ri;
int ret;
ret = update_root(root_lookup, root_id, ref_tree, root_offset, flags,
- dir_id, name, name_len, ogen, gen, ot,
+ dir_id, name, name_len, ogen, gen, otime,
uuid, puuid, ruuid);
if (!ret)
return 0;
ri->ogen = ogen;
if (!ri->ogen && root_offset)
ri->ogen = root_offset;
- if (ot)
- ri->otime = ot;
+ if (otime)
+ ri->otime = otime;
if (uuid)
memcpy(&ri->uuid, uuid, BTRFS_UUID_SIZE);
memcpy(&ri->ruuid, ruuid, BTRFS_UUID_SIZE);
ret = root_tree_insert(root_lookup, ri);
- if (ret) {
- error("failed to insert tree %llu",
- (unsigned long long)root_id);
+ if (ret < 0) {
+ error("failed to insert subvolume %llu to tree: %s",
+ (unsigned long long)root_id, strerror(-ret));
exit(1);
}
return 0;
}
+/*
+ * Simplified add_root for back references, omits the uuid and original info
+ * parameters, root offset and flags.
+ */
+static int add_root_backref(struct root_lookup *root_lookup, u64 root_id,
+ u64 ref_tree, u64 dir_id, char *name, int name_len)
+{
+ return add_root(root_lookup, root_id, ref_tree, 0, 0, dir_id, name,
+ name_len, 0, 0, 0, NULL, NULL, NULL);
+}
+
+
static void free_root_info(struct rb_node *node)
{
struct root_info *ri;
u64 ogen;
u64 flags;
int i;
- time_t t;
- u8 uuid[BTRFS_UUID_SIZE];
- u8 puuid[BTRFS_UUID_SIZE];
- u8 ruuid[BTRFS_UUID_SIZE];
- root_lookup_init(root_lookup);
+ root_lookup->root.rb_node = NULL;
memset(&args, 0, sizeof(args));
sk->tree_id = BTRFS_ROOT_TREE_OBJECTID;
/* Search both live and deleted subvolumes */
sk->min_type = BTRFS_ROOT_ITEM_KEY;
sk->max_type = BTRFS_ROOT_BACKREF_KEY;
- sk->min_objectid = BTRFS_FIRST_FREE_OBJECTID;
+ sk->min_objectid = BTRFS_FS_TREE_OBJECTID;
sk->max_objectid = BTRFS_LAST_FREE_OBJECTID;
sk->max_offset = (u64)-1;
sk->max_transid = (u64)-1;
name = (char *)(ref + 1);
dir_id = btrfs_stack_root_ref_dirid(ref);
- add_root(root_lookup, sh.objectid, sh.offset,
- 0, 0, dir_id, name, name_len, 0, 0, 0,
- NULL, NULL, NULL);
- } else if (sh.type == BTRFS_ROOT_ITEM_KEY) {
+ add_root_backref(root_lookup, sh.objectid,
+ sh.offset, dir_id, name,
+ name_len);
+ } else if (sh.type == BTRFS_ROOT_ITEM_KEY &&
+ (sh.objectid >= BTRFS_FIRST_FREE_OBJECTID ||
+ sh.objectid == BTRFS_FS_TREE_OBJECTID)) {
+ time_t otime;
+ u8 uuid[BTRFS_UUID_SIZE];
+ u8 puuid[BTRFS_UUID_SIZE];
+ u8 ruuid[BTRFS_UUID_SIZE];
+
ri = (struct btrfs_root_item *)(args.buf + off);
gen = btrfs_root_generation(ri);
flags = btrfs_root_flags(ri);
if(sh.len >
sizeof(struct btrfs_root_item_v0)) {
- t = btrfs_stack_timespec_sec(&ri->otime);
+ otime = btrfs_stack_timespec_sec(&ri->otime);
ogen = btrfs_root_otransid(ri);
memcpy(uuid, ri->uuid, BTRFS_UUID_SIZE);
memcpy(puuid, ri->parent_uuid, BTRFS_UUID_SIZE);
memcpy(ruuid, ri->received_uuid, BTRFS_UUID_SIZE);
} else {
- t = 0;
+ otime = 0;
ogen = 0;
memset(uuid, 0, BTRFS_UUID_SIZE);
memset(puuid, 0, BTRFS_UUID_SIZE);
add_root(root_lookup, sh.objectid, 0,
sh.offset, flags, 0, NULL, 0, ogen,
- gen, t, uuid, puuid, ruuid);
+ gen, otime, uuid, puuid, ruuid);
}
off += sh.len;
struct root_info *entry;
int ret;
- root_lookup_init(sort_tree);
+ sort_tree->root.rb_node = NULL;
n = rb_last(&all_subvols->root);
while (n) {
ret = resolve_root(all_subvols, entry, top_id);
if (ret == -ENOENT) {
- entry->full_path = strdup("DELETED");
- entry->deleted = 1;
+ if (entry->root_id != BTRFS_FS_TREE_OBJECTID) {
+ entry->full_path = strdup("DELETED");
+ entry->deleted = 1;
+ } else {
+ /*
+ * The full path is not supposed to be printed,
+ * but we don't want to print an empty string,
+ * in case it appears somewhere.
+ */
+ entry->full_path = strdup("TOPLEVEL");
+ entry->deleted = 0;
+ }
}
ret = filter_root(entry, filter_set);
if (ret)
strcpy(uuidparse, "-");
else
uuid_unparse(subv->uuid, uuidparse);
- printf("%s", uuidparse);
+ printf("%-36s", uuidparse);
break;
case BTRFS_LIST_PUUID:
if (uuid_is_null(subv->puuid))
strcpy(uuidparse, "-");
else
uuid_unparse(subv->puuid, uuidparse);
- printf("%s", uuidparse);
+ printf("%-36s", uuidparse);
break;
case BTRFS_LIST_RUUID:
if (uuid_is_null(subv->ruuid))
strcpy(uuidparse, "-");
else
uuid_unparse(subv->ruuid, uuidparse);
- printf("%s", uuidparse);
+ printf("%-36s", uuidparse);
break;
case BTRFS_LIST_PATH:
BUG_ON(!subv->full_path);
n = rb_first(&sorted_tree->root);
while (n) {
entry = rb_entry(n, struct root_info, sort_node);
+
+ /* The toplevel subvolume is not listed by default */
+ if (entry->root_id == BTRFS_FS_TREE_OBJECTID)
+ goto next;
+
switch (layout) {
case BTRFS_LIST_LAYOUT_DEFAULT:
print_one_subvol_info_default(entry);
print_one_subvol_info_raw(entry, raw_prefix);
break;
}
+next:
n = rb_next(n);
}
}
return strdup(s);
}
+int btrfs_get_toplevel_subvol(int fd, struct root_info *the_ri)
+{
+ int ret;
+ struct root_lookup rl;
+ struct rb_node *rbn;
+ struct root_info *ri;
+ u64 root_id;
+
+ ret = btrfs_list_get_path_rootid(fd, &root_id);
+ if (ret)
+ return ret;
+
+ ret = btrfs_list_subvols(fd, &rl);
+ if (ret)
+ return ret;
+
+ rbn = rb_first(&rl.root);
+ ri = rb_entry(rbn, struct root_info, rb_node);
+
+ if (ri->root_id != BTRFS_FS_TREE_OBJECTID)
+ return -ENOENT;
+
+ memcpy(the_ri, ri, offsetof(struct root_info, path));
+ the_ri->path = strdup_or_null("/");
+ the_ri->name = strdup_or_null("<FS_TREE>");
+ the_ri->full_path = strdup_or_null("/");
+ rb_free_nodes(&rl.root, free_root_info);
+
+ return ret;
+}
+
int btrfs_get_subvol(int fd, struct root_info *the_ri)
{
int ret, rr;
rbn = rb_next(rbn);
continue;
}
- if (!comp_entry_with_rootid(the_ri, ri, 0)) {
+
+ if (!comp_entry_with_rootid(the_ri, ri, 0) ||
+ !uuid_compare(the_ri->uuid, ri->uuid)) {
memcpy(the_ri, ri, offsetof(struct root_info, path));
the_ri->path = strdup_or_null(ri->path);
the_ri->name = strdup_or_null(ri->name);