forked from Mirrors/btrfs-progs
directory testing code and dir item fixes
Chris Mason
David Woodhouse
parent
5180a0b352
commit
e89de2d271
5
Makefile
5
Makefile
|
|
@ -1,4 +1,3 @@
|
|||
|
||||
CC=gcc
|
||||
CFLAGS = -g -Wall
|
||||
headers = radix-tree.h ctree.h disk-io.h kerncompat.h print-tree.h list.h
|
||||
|
|
@ -15,7 +14,7 @@ check=sparse $(CHECKFLAGS)
|
|||
$(check) $<
|
||||
$(CC) $(CFLAGS) -c $<
|
||||
|
||||
all: tester debug-tree quick-test
|
||||
all: tester debug-tree quick-test dir-test
|
||||
|
||||
debug-tree: $(objects) debug-tree.o
|
||||
gcc $(CFLAGS) -o debug-tree $(objects) debug-tree.o
|
||||
|
|
@ -23,6 +22,8 @@ debug-tree: $(objects) debug-tree.o
|
|||
tester: $(objects) random-test.o
|
||||
gcc $(CFLAGS) -o tester $(objects) random-test.o
|
||||
|
||||
dir-test: $(objects) dir-test.o
|
||||
gcc $(CFLAGS) -o dir-test $(objects) dir-test.o
|
||||
quick-test: $(objects) quick-test.o
|
||||
gcc $(CFLAGS) -o quick-test $(objects) quick-test.o
|
||||
|
||||
|
|
|
|||
72
ctree.h
72
ctree.h
|
|
@ -180,37 +180,6 @@ struct btrfs_root {
|
|||
#define BTRFS_EXTENT_ITEM_KEY 4
|
||||
#define BTRFS_STRING_ITEM_KEY 5
|
||||
|
||||
static inline u64 btrfs_dir_objectid(struct btrfs_dir_item *d)
|
||||
{
|
||||
return le64_to_cpu(d->objectid);
|
||||
}
|
||||
|
||||
static inline void btrfs_set_dir_objectid(struct btrfs_dir_item *d, u64 val)
|
||||
{
|
||||
d->objectid = cpu_to_le64(val);
|
||||
}
|
||||
|
||||
static inline u16 btrfs_dir_flags(struct btrfs_dir_item *d)
|
||||
{
|
||||
return le16_to_cpu(d->flags);
|
||||
}
|
||||
|
||||
static inline void btrfs_set_dir_flags(struct btrfs_dir_item *d, u16 val)
|
||||
{
|
||||
d->flags = cpu_to_le16(val);
|
||||
}
|
||||
|
||||
static inline u8 btrfs_dir_type(struct btrfs_dir_item *d)
|
||||
{
|
||||
return d->type;
|
||||
}
|
||||
|
||||
static inline void btrfs_set_dir_type(struct btrfs_dir_item *d, u8 val)
|
||||
{
|
||||
d->type = val;
|
||||
}
|
||||
|
||||
|
||||
static inline u64 btrfs_extent_owner(struct btrfs_extent_item *ei)
|
||||
{
|
||||
return le64_to_cpu(ei->owner);
|
||||
|
|
@ -267,6 +236,41 @@ static inline void btrfs_set_item_size(struct btrfs_item *item, u16 val)
|
|||
item->size = cpu_to_le16(val);
|
||||
}
|
||||
|
||||
static inline u64 btrfs_dir_objectid(struct btrfs_dir_item *d)
|
||||
{
|
||||
return le64_to_cpu(d->objectid);
|
||||
}
|
||||
|
||||
static inline void btrfs_set_dir_objectid(struct btrfs_dir_item *d, u64 val)
|
||||
{
|
||||
d->objectid = cpu_to_le64(val);
|
||||
}
|
||||
|
||||
static inline u16 btrfs_dir_flags(struct btrfs_dir_item *d)
|
||||
{
|
||||
return le16_to_cpu(d->flags);
|
||||
}
|
||||
|
||||
static inline void btrfs_set_dir_flags(struct btrfs_dir_item *d, u16 val)
|
||||
{
|
||||
d->flags = cpu_to_le16(val);
|
||||
}
|
||||
|
||||
static inline u8 btrfs_dir_type(struct btrfs_dir_item *d)
|
||||
{
|
||||
return d->type;
|
||||
}
|
||||
|
||||
static inline void btrfs_set_dir_type(struct btrfs_dir_item *d, u8 val)
|
||||
{
|
||||
d->type = val;
|
||||
}
|
||||
|
||||
static inline u32 btrfs_dir_name_len(struct btrfs_item *i)
|
||||
{
|
||||
return btrfs_item_size(i) - sizeof(struct btrfs_dir_item);
|
||||
}
|
||||
|
||||
static inline void btrfs_disk_key_to_cpu(struct btrfs_key *cpu,
|
||||
struct btrfs_disk_key *disk)
|
||||
{
|
||||
|
|
@ -506,4 +510,10 @@ int btrfs_update_root(struct btrfs_root *root, struct btrfs_key *key,
|
|||
struct btrfs_root_item *item);
|
||||
int btrfs_find_last_root(struct btrfs_root *root, u64 objectid,
|
||||
struct btrfs_root_item *item, struct btrfs_key *key);
|
||||
int btrfs_insert_dir_item(struct btrfs_root *root, char *name, int name_len,
|
||||
u64 dir, u64 objectid, u8 type);
|
||||
int btrfs_lookup_dir_item(struct btrfs_root *root, struct btrfs_path *path,
|
||||
u64 dir, char *name, int name_len, int mod);
|
||||
int btrfs_match_dir_item_name(struct btrfs_root *root, struct btrfs_path *path,
|
||||
char *name, int name_len);
|
||||
#endif
|
||||
|
|
|
|||
58
dir-item.c
58
dir-item.c
|
|
@ -18,6 +18,7 @@ int btrfs_insert_dir_item(struct btrfs_root *root, char *name, int name_len,
|
|||
|
||||
key.objectid = dir;
|
||||
key.flags = 0;
|
||||
btrfs_set_key_type(&key, BTRFS_DIR_ITEM_KEY);
|
||||
ret = btrfs_name_hash(name, name_len, &key.offset);
|
||||
BUG_ON(ret);
|
||||
btrfs_init_path(&path);
|
||||
|
|
@ -38,65 +39,40 @@ out:
|
|||
return ret;
|
||||
}
|
||||
|
||||
int btrfs_del_dir_item(struct btrfs_root *root, u64 dir, char *name,
|
||||
int name_len)
|
||||
int btrfs_lookup_dir_item(struct btrfs_root *root, struct btrfs_path *path,
|
||||
u64 dir, char *name, int name_len, int mod)
|
||||
{
|
||||
int ret = 0;
|
||||
struct btrfs_path path;
|
||||
int ret;
|
||||
struct btrfs_key key;
|
||||
int ins_len = mod < 0 ? -1 : 0;
|
||||
int cow = mod != 0;
|
||||
|
||||
key.objectid = dir;
|
||||
key.flags = 0;
|
||||
btrfs_set_key_type(&key, BTRFS_DIR_ITEM_KEY);
|
||||
ret = btrfs_name_hash(name, name_len, &key.offset);
|
||||
BUG_ON(ret);
|
||||
btrfs_init_path(&path);
|
||||
ret = btrfs_search_slot(root, &key, &path, 0, 1);
|
||||
if (ret)
|
||||
goto out;
|
||||
ret = btrfs_del_item(root, &path);
|
||||
out:
|
||||
btrfs_release_path(root, &path);
|
||||
ret = btrfs_search_slot(root, &key, path, ins_len, cow);
|
||||
return ret;
|
||||
}
|
||||
|
||||
int btrfs_lookup_dir_item(struct btrfs_root *root, u64 dir, char *name,
|
||||
int name_len, u64 *objectid)
|
||||
int btrfs_match_dir_item_name(struct btrfs_root *root, struct btrfs_path *path,
|
||||
char *name, int name_len)
|
||||
{
|
||||
int ret = 0;
|
||||
struct btrfs_path path;
|
||||
struct btrfs_item *item;
|
||||
struct btrfs_dir_item *dir_item;
|
||||
char *name_ptr;
|
||||
struct btrfs_key key;
|
||||
u32 item_len;
|
||||
struct btrfs_item *item;
|
||||
|
||||
key.objectid = dir;
|
||||
key.flags = 0;
|
||||
ret = btrfs_name_hash(name, name_len, &key.offset);
|
||||
BUG_ON(ret);
|
||||
btrfs_init_path(&path);
|
||||
ret = btrfs_search_slot(root, &key, &path, 0, 0);
|
||||
if (ret)
|
||||
goto out;
|
||||
|
||||
dir_item = btrfs_item_ptr(&path.nodes[0]->leaf, path.slots[0],
|
||||
struct btrfs_dir_item);
|
||||
|
||||
item = path.nodes[0]->leaf.items + path.slots[0];
|
||||
item = path->nodes[0]->leaf.items + path->slots[0];
|
||||
item_len = btrfs_item_size(item);
|
||||
if (item_len != name_len + sizeof(struct btrfs_dir_item)) {
|
||||
BUG();
|
||||
ret = 1;
|
||||
goto out;
|
||||
return 0;
|
||||
}
|
||||
dir_item = btrfs_item_ptr(&path->nodes[0]->leaf, path->slots[0],
|
||||
struct btrfs_dir_item);
|
||||
name_ptr = (char *)(dir_item + 1);
|
||||
if (memcmp(name_ptr, name, name_len)) {
|
||||
BUG();
|
||||
ret = 1;
|
||||
goto out;
|
||||
return 0;
|
||||
}
|
||||
*objectid = btrfs_dir_objectid(dir_item);
|
||||
out:
|
||||
btrfs_release_path(root, &path);
|
||||
return ret;
|
||||
return 1;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -0,0 +1,404 @@
|
|||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <signal.h>
|
||||
#include <unistd.h>
|
||||
#include "kerncompat.h"
|
||||
#include "radix-tree.h"
|
||||
#include "ctree.h"
|
||||
#include "disk-io.h"
|
||||
#include "print-tree.h"
|
||||
#include "hash.h"
|
||||
|
||||
int keep_running = 1;
|
||||
struct btrfs_super_block super;
|
||||
static u64 dir_oid = 44556;
|
||||
static u64 file_oid = 33778;
|
||||
|
||||
static int find_num(struct radix_tree_root *root, unsigned long *num_ret,
|
||||
int exists)
|
||||
{
|
||||
unsigned long num = rand();
|
||||
unsigned long res[2];
|
||||
int ret;
|
||||
|
||||
again:
|
||||
ret = radix_tree_gang_lookup(root, (void **)res, num, 2);
|
||||
if (exists) {
|
||||
if (ret == 0)
|
||||
return -1;
|
||||
num = res[0];
|
||||
} else if (ret != 0 && num == res[0]) {
|
||||
num++;
|
||||
if (ret > 1 && num == res[1]) {
|
||||
num++;
|
||||
goto again;
|
||||
}
|
||||
}
|
||||
*num_ret = num;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ins_one(struct btrfs_root *root, struct radix_tree_root *radix)
|
||||
{
|
||||
int ret;
|
||||
char buf[128];
|
||||
unsigned long oid;
|
||||
struct btrfs_path path;
|
||||
|
||||
find_num(radix, &oid, 0);
|
||||
sprintf(buf, "str-%lu", oid);
|
||||
|
||||
ret = btrfs_insert_dir_item(root, buf, strlen(buf), dir_oid, file_oid,
|
||||
1);
|
||||
if (ret)
|
||||
goto error;
|
||||
|
||||
radix_tree_preload(GFP_KERNEL);
|
||||
ret = radix_tree_insert(radix, oid, (void *)oid);
|
||||
radix_tree_preload_end();
|
||||
if (ret)
|
||||
goto error;
|
||||
return ret;
|
||||
error:
|
||||
if (ret != -EEXIST)
|
||||
goto fatal;
|
||||
|
||||
/*
|
||||
* if we got an EEXIST, it may be due to hash collision, double
|
||||
* check
|
||||
*/
|
||||
btrfs_init_path(&path);
|
||||
ret = btrfs_lookup_dir_item(root, &path, dir_oid, buf, strlen(buf), 0);
|
||||
if (ret)
|
||||
goto fatal_release;
|
||||
if (!btrfs_match_dir_item_name(root, &path, buf, strlen(buf))) {
|
||||
struct btrfs_dir_item *di;
|
||||
char *found;
|
||||
u32 found_len;
|
||||
u64 myhash;
|
||||
u64 foundhash;
|
||||
|
||||
di = btrfs_item_ptr(&path.nodes[0]->leaf, path.slots[0],
|
||||
struct btrfs_dir_item);
|
||||
found = (char *)(di + 1);
|
||||
found_len = btrfs_dir_name_len(path.nodes[0]->leaf.items +
|
||||
path.slots[0]);
|
||||
btrfs_name_hash(buf, strlen(buf), &myhash);
|
||||
btrfs_name_hash(found, found_len, &foundhash);
|
||||
if (myhash != foundhash)
|
||||
goto fatal_release;
|
||||
btrfs_release_path(root, &path);
|
||||
return 0;
|
||||
}
|
||||
fatal_release:
|
||||
btrfs_release_path(root, &path);
|
||||
fatal:
|
||||
printf("failed to insert %lu ret %d\n", oid, ret);
|
||||
return -1;
|
||||
}
|
||||
|
||||
static int insert_dup(struct btrfs_root *root, struct radix_tree_root *radix)
|
||||
{
|
||||
int ret;
|
||||
char buf[128];
|
||||
unsigned long oid;
|
||||
|
||||
ret = find_num(radix, &oid, 1);
|
||||
if (ret < 0)
|
||||
return 0;
|
||||
sprintf(buf, "str-%lu", oid);
|
||||
|
||||
ret = btrfs_insert_dir_item(root, buf, strlen(buf), dir_oid, file_oid,
|
||||
1);
|
||||
if (ret != -EEXIST) {
|
||||
printf("insert on %s gave us %d\n", buf, ret);
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int del_one(struct btrfs_root *root, struct radix_tree_root *radix)
|
||||
{
|
||||
int ret;
|
||||
char buf[128];
|
||||
unsigned long oid;
|
||||
struct btrfs_path path;
|
||||
unsigned long *ptr;
|
||||
|
||||
ret = find_num(radix, &oid, 1);
|
||||
if (ret < 0)
|
||||
return 0;
|
||||
sprintf(buf, "str-%lu", oid);
|
||||
btrfs_init_path(&path);
|
||||
ret = btrfs_lookup_dir_item(root, &path, dir_oid, buf, strlen(buf), -1);
|
||||
if (ret)
|
||||
goto out_release;
|
||||
ret = btrfs_del_item(root, &path);
|
||||
if (ret)
|
||||
goto out_release;
|
||||
btrfs_release_path(root, &path);
|
||||
ptr = radix_tree_delete(radix, oid);
|
||||
if (!ptr) {
|
||||
ret = -5555;
|
||||
goto out;
|
||||
}
|
||||
return 0;
|
||||
out_release:
|
||||
btrfs_release_path(root, &path);
|
||||
out:
|
||||
printf("failed to delete %lu %d\n", oid, ret);
|
||||
return -1;
|
||||
}
|
||||
|
||||
static int lookup_item(struct btrfs_root *root, struct radix_tree_root *radix)
|
||||
{
|
||||
struct btrfs_path path;
|
||||
char buf[128];
|
||||
int ret;
|
||||
unsigned long oid;
|
||||
|
||||
ret = find_num(radix, &oid, 1);
|
||||
if (ret < 0)
|
||||
return 0;
|
||||
sprintf(buf, "str-%lu", oid);
|
||||
btrfs_init_path(&path);
|
||||
ret = btrfs_lookup_dir_item(root, &path, dir_oid, buf, strlen(buf), 0);
|
||||
btrfs_release_path(root, &path);
|
||||
if (ret) {
|
||||
printf("unable to find key %lu\n", oid);
|
||||
return -1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int lookup_enoent(struct btrfs_root *root, struct radix_tree_root *radix)
|
||||
{
|
||||
struct btrfs_path path;
|
||||
char buf[128];
|
||||
int ret;
|
||||
unsigned long oid;
|
||||
|
||||
ret = find_num(radix, &oid, 0);
|
||||
if (ret < 0)
|
||||
return 0;
|
||||
sprintf(buf, "str-%lu", oid);
|
||||
btrfs_init_path(&path);
|
||||
ret = btrfs_lookup_dir_item(root, &path, dir_oid, buf, strlen(buf), 0);
|
||||
btrfs_release_path(root, &path);
|
||||
if (!ret) {
|
||||
printf("able to find key that should not exist %lu\n", oid);
|
||||
return -1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int empty_tree(struct btrfs_root *root, struct radix_tree_root *radix,
|
||||
int nr)
|
||||
{
|
||||
struct btrfs_path path;
|
||||
struct btrfs_key key;
|
||||
unsigned long found = 0;
|
||||
u32 found_len;
|
||||
int ret;
|
||||
int slot;
|
||||
int *ptr;
|
||||
int count = 0;
|
||||
char buf[128];
|
||||
struct btrfs_dir_item *di;
|
||||
|
||||
key.offset = (u64)-1;
|
||||
key.flags = 0;
|
||||
btrfs_set_key_type(&key, BTRFS_DIR_ITEM_KEY);
|
||||
key.objectid = dir_oid;
|
||||
while(nr-- >= 0) {
|
||||
btrfs_init_path(&path);
|
||||
ret = btrfs_search_slot(root, &key, &path, -1, 1);
|
||||
if (ret < 0) {
|
||||
btrfs_release_path(root, &path);
|
||||
return ret;
|
||||
}
|
||||
if (ret != 0) {
|
||||
if (path.slots[0] == 0) {
|
||||
btrfs_release_path(root, &path);
|
||||
break;
|
||||
}
|
||||
path.slots[0] -= 1;
|
||||
}
|
||||
slot = path.slots[0];
|
||||
di = btrfs_item_ptr(&path.nodes[0]->leaf, slot,
|
||||
struct btrfs_dir_item);
|
||||
found_len = btrfs_dir_name_len(path.nodes[0]->leaf.items +
|
||||
slot);
|
||||
memcpy(buf, (char *)(di + 1), found_len);
|
||||
BUG_ON(found_len > 128);
|
||||
buf[found_len] = '\0';
|
||||
found = atoi(buf + 4);
|
||||
ret = btrfs_del_item(root, &path);
|
||||
count++;
|
||||
if (ret) {
|
||||
fprintf(stderr,
|
||||
"failed to remove %lu from tree\n",
|
||||
found);
|
||||
return -1;
|
||||
}
|
||||
btrfs_release_path(root, &path);
|
||||
ptr = radix_tree_delete(radix, found);
|
||||
if (!ptr)
|
||||
goto error;
|
||||
if (!keep_running)
|
||||
break;
|
||||
}
|
||||
return 0;
|
||||
error:
|
||||
fprintf(stderr, "failed to delete from the radix %lu\n", found);
|
||||
return -1;
|
||||
}
|
||||
|
||||
static int fill_tree(struct btrfs_root *root, struct radix_tree_root *radix,
|
||||
int count)
|
||||
{
|
||||
int i;
|
||||
int ret = 0;
|
||||
for (i = 0; i < count; i++) {
|
||||
ret = ins_one(root, radix);
|
||||
if (ret) {
|
||||
fprintf(stderr, "fill failed\n");
|
||||
goto out;
|
||||
}
|
||||
if (i % 1000 == 0) {
|
||||
ret = btrfs_commit_transaction(root, &super);
|
||||
if (ret) {
|
||||
fprintf(stderr, "fill commit failed\n");
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
if (i && i % 10000 == 0) {
|
||||
printf("bigfill %d\n", i);
|
||||
}
|
||||
if (!keep_running)
|
||||
break;
|
||||
}
|
||||
out:
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int bulk_op(struct btrfs_root *root, struct radix_tree_root *radix)
|
||||
{
|
||||
int ret;
|
||||
int nr = rand() % 5000;
|
||||
static int run_nr = 0;
|
||||
|
||||
/* do the bulk op much less frequently */
|
||||
if (run_nr++ % 100)
|
||||
return 0;
|
||||
ret = empty_tree(root, radix, nr);
|
||||
if (ret)
|
||||
return ret;
|
||||
ret = fill_tree(root, radix, nr);
|
||||
if (ret)
|
||||
return ret;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
int (*ops[])(struct btrfs_root *root, struct radix_tree_root *radix) =
|
||||
{ ins_one, insert_dup, del_one, lookup_item,
|
||||
lookup_enoent, bulk_op };
|
||||
|
||||
void sigstopper(int ignored)
|
||||
{
|
||||
keep_running = 0;
|
||||
fprintf(stderr, "caught exit signal, stopping\n");
|
||||
}
|
||||
|
||||
int print_usage(void)
|
||||
{
|
||||
printf("usage: tester [-ih] [-c count] [-f count]\n");
|
||||
printf("\t -c count -- iteration count after filling\n");
|
||||
printf("\t -f count -- run this many random inserts before starting\n");
|
||||
printf("\t -i -- only do initial fill\n");
|
||||
printf("\t -h -- this help text\n");
|
||||
exit(1);
|
||||
}
|
||||
int main(int ac, char **av)
|
||||
{
|
||||
RADIX_TREE(radix, GFP_KERNEL);
|
||||
struct btrfs_root *root;
|
||||
int i;
|
||||
int ret;
|
||||
int count;
|
||||
int op;
|
||||
int iterations = 20000;
|
||||
int init_fill_count = 800000;
|
||||
int err = 0;
|
||||
int initial_only = 0;
|
||||
radix_tree_init();
|
||||
|
||||
printf("removing old tree\n");
|
||||
unlink("dbfile");
|
||||
root = open_ctree("dbfile", &super);
|
||||
|
||||
signal(SIGTERM, sigstopper);
|
||||
signal(SIGINT, sigstopper);
|
||||
|
||||
for (i = 1 ; i < ac ; i++) {
|
||||
if (strcmp(av[i], "-i") == 0) {
|
||||
initial_only = 1;
|
||||
} else if (strcmp(av[i], "-c") == 0) {
|
||||
iterations = atoi(av[i+1]);
|
||||
i++;
|
||||
} else if (strcmp(av[i], "-f") == 0) {
|
||||
init_fill_count = atoi(av[i+1]);
|
||||
i++;
|
||||
} else {
|
||||
print_usage();
|
||||
}
|
||||
}
|
||||
printf("initial fill\n");
|
||||
ret = fill_tree(root, &radix, init_fill_count);
|
||||
printf("starting run\n");
|
||||
if (ret) {
|
||||
err = ret;
|
||||
goto out;
|
||||
}
|
||||
if (initial_only == 1) {
|
||||
goto out;
|
||||
}
|
||||
for (i = 0; i < iterations; i++) {
|
||||
op = rand() % ARRAY_SIZE(ops);
|
||||
count = rand() % 128;
|
||||
if (i % 2000 == 0) {
|
||||
printf("%d\n", i);
|
||||
fflush(stdout);
|
||||
}
|
||||
if (i && i % 5000 == 0) {
|
||||
printf("open & close, root level %d nritems %d\n",
|
||||
btrfs_header_level(&root->node->node.header),
|
||||
btrfs_header_nritems(&root->node->node.header));
|
||||
close_ctree(root, &super);
|
||||
root = open_ctree("dbfile", &super);
|
||||
}
|
||||
while(count--) {
|
||||
ret = ops[op](root, &radix);
|
||||
if (ret) {
|
||||
fprintf(stderr, "op %d failed %d:%d\n",
|
||||
op, i, iterations);
|
||||
btrfs_print_tree(root, root->node);
|
||||
fprintf(stderr, "op %d failed %d:%d\n",
|
||||
op, i, iterations);
|
||||
err = ret;
|
||||
goto out;
|
||||
}
|
||||
if (ops[op] == bulk_op)
|
||||
break;
|
||||
if (keep_running == 0) {
|
||||
err = 0;
|
||||
goto out;
|
||||
}
|
||||
}
|
||||
}
|
||||
out:
|
||||
close_ctree(root, &super);
|
||||
return err;
|
||||
}
|
||||
|
||||
12
print-tree.c
12
print-tree.c
|
|
@ -12,7 +12,10 @@ void btrfs_print_leaf(struct btrfs_root *root, struct btrfs_leaf *l)
|
|||
struct btrfs_item *item;
|
||||
struct btrfs_extent_item *ei;
|
||||
struct btrfs_root_item *ri;
|
||||
struct btrfs_dir_item *di;
|
||||
u32 type;
|
||||
u32 namelen;
|
||||
|
||||
printf("leaf %Lu total ptrs %d free space %d\n",
|
||||
btrfs_header_blocknr(&l->header), nr,
|
||||
btrfs_leaf_free_space(root, l));
|
||||
|
|
@ -31,6 +34,15 @@ void btrfs_print_leaf(struct btrfs_root *root, struct btrfs_leaf *l)
|
|||
case BTRFS_INODE_ITEM_KEY:
|
||||
break;
|
||||
case BTRFS_DIR_ITEM_KEY:
|
||||
namelen = btrfs_item_size(l->items + i) - sizeof(*di);
|
||||
di = btrfs_item_ptr(l, i, struct btrfs_dir_item);
|
||||
printf("\t\tdir oid %Lu flags %u type %u\n",
|
||||
btrfs_dir_objectid(di),
|
||||
btrfs_dir_flags(di),
|
||||
btrfs_dir_type(di));
|
||||
printf("\t\tname %.*s\n",
|
||||
namelen, (char *)(di + 1));
|
||||
|
||||
break;
|
||||
case BTRFS_ROOT_ITEM_KEY:
|
||||
ri = btrfs_item_ptr(l, i, struct btrfs_root_item);
|
||||
|
|
|
|||
Loading…
Reference in New Issue