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) {
- printf("failed to insert tree %llu\n", (unsigned long long)root_id);
+ if (ret < 0) {
+ error("failed to insert subvolume %llu to tree: %s",
+ (unsigned long long)root_id, strerror(-ret));
exit(1);
}
return 0;
}
+/*
+ * 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;
ri->ref_tree = 0;
return -ENOENT;
}
- fprintf(stderr, "ERROR: Failed to lookup path for root %llu - %s\n",
- (unsigned long long)ri->ref_tree,
- strerror(errno));
+ error("failed to lookup path for root %llu: %m",
+ (unsigned long long)ri->ref_tree);
return ret;
}
/* this ioctl fills in ino_args->treeid */
ret = ioctl(fd, BTRFS_IOC_INO_LOOKUP, &ino_args);
if (ret < 0) {
- fprintf(stderr, "ERROR: Failed to lookup path for dirid %llu - %s\n",
- (unsigned long long)BTRFS_FIRST_FREE_OBJECTID,
- strerror(errno));
+ error("failed to lookup path for dirid %llu: %m",
+ (unsigned long long)BTRFS_FIRST_FREE_OBJECTID);
return 0;
}
while (1) {
ret = ioctl(fd, BTRFS_IOC_TREE_SEARCH, &args);
if (ret < 0) {
- fprintf(stderr, "ERROR: can't perform the search - %s\n",
- strerror(errno));
+ error("can't perform the search: %m");
return 0;
}
/* the ioctl returns the number of item it found in nr_items */
ret = ioctl(fd, BTRFS_IOC_INO_LOOKUP, &args);
if (ret < 0) {
- fprintf(stderr, "ERROR: Failed to lookup path for dirid %llu - %s\n",
- (unsigned long long)dirid, strerror(errno));
+ error("failed to lookup path for dirid %llu: %m",
+ (unsigned long long)dirid);
return ERR_PTR(ret);
}
ret = ioctl(fd, BTRFS_IOC_TREE_SEARCH, &args);
if (ret < 0) {
- fprintf(stderr, "ERROR: can't perform the search - %s\n",
- strerror(errno));
+ error("can't perform the search: %m");
return NULL;
}
/* the ioctl returns the number of item it found in nr_items */
struct btrfs_ioctl_search_header sh;
struct btrfs_root_ref *ref;
struct btrfs_root_item *ri;
- unsigned long off = 0;
+ unsigned long off;
int name_len;
char *name;
u64 dir_id;
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;
-
- /*
- * set the min and max to backref keys. The search will
- * only send back this type of key now.
- */
- sk->max_type = BTRFS_ROOT_BACKREF_KEY;
+ /* Search both live and deleted subvolumes */
sk->min_type = BTRFS_ROOT_ITEM_KEY;
-
- sk->min_objectid = BTRFS_FIRST_FREE_OBJECTID;
-
- /*
- * set all the other params to the max, we'll take any objectid
- * and any trans
- */
+ sk->max_type = BTRFS_ROOT_BACKREF_KEY;
+ sk->min_objectid = BTRFS_FS_TREE_OBJECTID;
sk->max_objectid = BTRFS_LAST_FREE_OBJECTID;
sk->max_offset = (u64)-1;
sk->max_transid = (u64)-1;
- /* just a big number, doesn't matter much */
- sk->nr_items = 4096;
-
while(1) {
+ sk->nr_items = 4096;
ret = ioctl(fd, BTRFS_IOC_TREE_SEARCH, &args);
if (ret < 0)
return ret;
- /* the ioctl returns the number of item it found in nr_items */
if (sk->nr_items == 0)
break;
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;
- /*
- * record the mins in sk so we can make sure the
- * next search doesn't repeat this root
- */
sk->min_objectid = sh.objectid;
sk->min_type = sh.type;
sk->min_offset = sh.offset;
}
- sk->nr_items = 4096;
sk->min_offset++;
- if (!sk->min_offset) /* overflow */
+ if (!sk->min_offset)
sk->min_type++;
else
continue;
return set;
}
-int btrfs_list_setup_filter(struct btrfs_list_filter_set **filter_set,
+/*
+ * Setup list filters. Exit if there's not enough memory, as we can't continue
+ * without the structures set up properly.
+ */
+void btrfs_list_setup_filter(struct btrfs_list_filter_set **filter_set,
enum btrfs_list_filter_enum filter, u64 data)
{
struct btrfs_list_filter_set *set = *filter_set;
set->filters[set->nfilters].filter_func = all_filter_funcs[filter];
set->filters[set->nfilters].data = data;
set->nfilters++;
- return 0;
}
static int filter_root(struct root_info *ri,
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);
}
}
-static void print_single_volume_info_raw(struct root_info *subv,
+static void print_one_subvol_info_raw(struct root_info *subv,
const char *raw_prefix)
{
int i;
printf("\n");
}
-static void print_single_volume_info_table(struct root_info *subv)
+static void print_one_subvol_info_table(struct root_info *subv)
{
int i;
printf("\n");
}
-static void print_single_volume_info_default(struct root_info *subv)
+static void print_one_subvol_info_default(struct root_info *subv)
{
int i;
printf("\n");
}
-static void print_all_volume_info_tab_head(void)
+static void print_all_subvol_info_tab_head(void)
{
int i;
int len;
}
}
-static void print_all_volume_info(struct root_lookup *sorted_tree,
+static void print_all_subvol_info(struct root_lookup *sorted_tree,
enum btrfs_list_layout layout, const char *raw_prefix)
{
struct rb_node *n;
struct root_info *entry;
if (layout == BTRFS_LIST_LAYOUT_TABLE)
- print_all_volume_info_tab_head();
+ print_all_subvol_info_tab_head();
n = rb_first(&sorted_tree->root);
while (n) {
entry = rb_entry(n, struct root_info, sort_node);
+
+ /* The toplevel subvolume is not listed by default */
+ if (entry->root_id == BTRFS_FS_TREE_OBJECTID)
+ goto next;
+
switch (layout) {
case BTRFS_LIST_LAYOUT_DEFAULT:
- print_single_volume_info_default(entry);
+ print_one_subvol_info_default(entry);
break;
case BTRFS_LIST_LAYOUT_TABLE:
- print_single_volume_info_table(entry);
+ print_one_subvol_info_table(entry);
break;
case BTRFS_LIST_LAYOUT_RAW:
- print_single_volume_info_raw(entry, raw_prefix);
+ print_one_subvol_info_raw(entry, raw_prefix);
break;
}
+next:
n = rb_next(n);
}
}
ret = list_subvol_search(fd, root_lookup);
if (ret) {
- fprintf(stderr, "ERROR: can't perform the search - %s\n",
- strerror(errno));
+ error("can't perform the search: %m");
return ret;
}
filter_and_sort_subvol(&root_lookup, &root_sort, filter_set,
comp_set, top_id);
- print_all_volume_info(&root_sort, layout, raw_prefix);
+ print_all_subvol_info(&root_sort, layout, raw_prefix);
rb_free_nodes(&root_lookup.root, free_root_info);
return 0;
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);
disk_offset = 0;
len = btrfs_stack_file_extent_ram_bytes(item);
} else {
- printf("unhandled extent type %d for inode %llu "
- "file offset %llu gen %llu\n",
+ error(
+ "unhandled extent type %d for inode %llu file offset %llu gen %llu",
type,
(unsigned long long)btrfs_search_header_objectid(sh),
(unsigned long long)btrfs_search_header_offset(sh),
while(1) {
ret = ioctl(fd, BTRFS_IOC_TREE_SEARCH, &args);
if (ret < 0) {
- fprintf(stderr, "ERROR: can't perform the search - %s\n",
- strerror(errno));
+ error("can't perform the search: %m");
break;
}
/* the ioctl returns the number of item it found in nr_items */
ret = lookup_path_rootid(fd, treeid);
if (ret < 0)
- error("cannot resolve rootid for path: %s",
- strerror(errno));
+ error("cannot resolve rootid for path: %m");
return ret;
}