marko10_000
/
btrfs-progs
forked from Mirrors/btrfs-progs
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Use a chunk of the key flags to record the item type. 

Add (untested and simple) directory item code
Fix comp_keys to use the new key ordering
Add btrfs_insert_empty_item
master
Chris Mason 2007-03-15 12:56:47 -04:00 committed by David Woodhouse
parent c8afca944b
commit da99898c78
14 changed files with 435 additions and 109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Makefile
View File

@ -3,7 +3,7 @@ CC=gcc
CFLAGS = -g -Wall
headers = radix-tree.h ctree.h disk-io.h kerncompat.h print-tree.h list.h
objects = ctree.o disk-io.o radix-tree.o mkfs.o extent-tree.o print-tree.o \
root-tree.o
root-tree.o dir-item.o hash.o
# if you don't have sparse installed, use ls instead
CHECKFLAGS=-D__linux__ -Dlinux -D__STDC__ -Dunix -D__unix__ -Wbitwise \

1
TODO
View File

@ -8,6 +8,7 @@
* Add block mapping tree (simple dm layer)
* Add simple tree locking (semaphore per tree)
* Make allocator smarter
* Do actual block accounting
* Port into the kernel
* Add virtual filesystems, mountable snapshots
* Get rid of struct ctree_path, limiting tree levels held at one time

51
ctree.c
View File

@ -107,14 +107,14 @@ static int comp_keys(struct btrfs_disk_key *disk, struct btrfs_key *k2)
return 1;
if (k1.objectid < k2->objectid)
return -1;
if (k1.flags > k2->flags)
return 1;
if (k1.flags < k2->flags)
return -1;
if (k1.offset > k2->offset)
return 1;
if (k1.offset < k2->offset)
return -1;
if (k1.flags > k2->flags)
return 1;
if (k1.flags < k2->flags)
return -1;
return 0;
}
@ -1122,8 +1122,8 @@ static int split_leaf(struct btrfs_root *root, struct btrfs_path *path,
* Given a key and some data, insert an item into the tree.
* This does all the path init required, making room in the tree if needed.
*/
int btrfs_insert_item(struct btrfs_root *root, struct btrfs_key *cpu_key,
void *data, int data_size)
int btrfs_insert_empty_item(struct btrfs_root *root, struct btrfs_path *path,
struct btrfs_key *cpu_key, u32 data_size)
{
int ret = 0;
int slot;
@ -1132,7 +1132,6 @@ int btrfs_insert_item(struct btrfs_root *root, struct btrfs_key *cpu_key,
struct btrfs_buffer *leaf_buf;
u32 nritems;
unsigned int data_end;
struct btrfs_path path;
struct btrfs_disk_key disk_key;
btrfs_cpu_key_to_disk(&disk_key, cpu_key);
@ -1140,17 +1139,16 @@ int btrfs_insert_item(struct btrfs_root *root, struct btrfs_key *cpu_key,
/* create a root if there isn't one */
if (!root->node)
BUG();
btrfs_init_path(&path);
ret = btrfs_search_slot(root, cpu_key, &path, data_size, 1);
ret = btrfs_search_slot(root, cpu_key, path, data_size, 1);
if (ret == 0) {
btrfs_release_path(root, &path);
btrfs_release_path(root, path);
return -EEXIST;
}
if (ret < 0)
goto out;
slot_orig = path.slots[0];
leaf_buf = path.nodes[0];
slot_orig = path->slots[0];
leaf_buf = path->nodes[0];
leaf = &leaf_buf->leaf;
nritems = btrfs_header_nritems(&leaf->header);
@ -1160,7 +1158,7 @@ int btrfs_insert_item(struct btrfs_root *root, struct btrfs_key *cpu_key,
sizeof(struct btrfs_item) + data_size)
BUG();
slot = path.slots[0];
slot = path->slots[0];
BUG_ON(slot < 0);
if (slot != nritems) {
int i;
@ -1186,23 +1184,42 @@ int btrfs_insert_item(struct btrfs_root *root, struct btrfs_key *cpu_key,
data_end, old_data - data_end);
data_end = old_data;
}
/* copy the new data in */
/* setup the item for the new data */
memcpy(&leaf->items[slot].key, &disk_key,
sizeof(struct btrfs_disk_key));
btrfs_set_item_offset(leaf->items + slot, data_end - data_size);
btrfs_set_item_size(leaf->items + slot, data_size);
memcpy(btrfs_leaf_data(leaf) + data_end - data_size, data, data_size);
btrfs_set_header_nritems(&leaf->header, nritems + 1);
ret = 0;
if (slot == 0)
ret = fixup_low_keys(root, &path, &disk_key, 1);
ret = fixup_low_keys(root, path, &disk_key, 1);
BUG_ON(list_empty(&leaf_buf->dirty));
if (btrfs_leaf_free_space(root, leaf) < 0)
BUG();
check_leaf(root, &path, 0);
check_leaf(root, path, 0);
out:
return ret;
}
/*
* Given a key and some data, insert an item into the tree.
* This does all the path init required, making room in the tree if needed.
*/
int btrfs_insert_item(struct btrfs_root *root, struct btrfs_key *cpu_key,
void *data, u32 data_size)
{
int ret = 0;
struct btrfs_path path;
u8 *ptr;
btrfs_init_path(&path);
ret = btrfs_insert_empty_item(root, &path, cpu_key, data_size);
if (!ret) {
ptr = btrfs_item_ptr(&path.nodes[0]->leaf, path.slots[0], u8);
memcpy(ptr, data, data_size);
}
btrfs_release_path(root, &path);
return ret;
}

182
ctree.h
View File

@ -58,39 +58,6 @@ struct btrfs_header {
#define BTRFS_LEAF_DATA_SIZE(r) (__BTRFS_LEAF_DATA_SIZE(r->blocksize))
struct btrfs_buffer;
struct btrfs_root_item {
__le64 blocknr;
__le32 flags;
__le64 block_limit;
__le64 blocks_used;
__le32 refs;
};
/*
* in ram representation of the tree. extent_root is used for all allocations
* and for the extent tree extent_root root. current_insert is used
* only for the extent tree.
*/
struct btrfs_root {
struct btrfs_buffer *node;
struct btrfs_buffer *commit_root;
struct btrfs_root *extent_root;
struct btrfs_root *tree_root;
struct btrfs_key current_insert;
struct btrfs_key last_insert;
int fp;
struct radix_tree_root cache_radix;
struct radix_tree_root pinned_radix;
struct list_head trans;
struct list_head cache;
int cache_size;
int ref_cows;
struct btrfs_root_item root_item;
struct btrfs_key root_key;
u32 blocksize;
};
/*
* the super block basically lists the main trees of the FS
* it currently lacks any block count etc etc
@ -108,8 +75,7 @@ struct btrfs_super_block {
} __attribute__ ((__packed__));
/*
* A leaf is full of items. The exact type of item is defined by
* the key flags parameter. offset and size tell us where to find
* A leaf is full of items. offset and size tell us where to find
* the item in the leaf (relative to the start of the data area)
*/
struct btrfs_item {
@ -144,15 +110,6 @@ struct btrfs_node {
struct btrfs_key_ptr ptrs[];
} __attribute__ ((__packed__));
/*
* items in the extent btree are used to record the objectid of the
* owner of the block and the number of references
*/
struct btrfs_extent_item {
__le32 refs;
__le64 owner;
} __attribute__ ((__packed__));
/*
* btrfs_paths remember the path taken from the root down to the leaf.
* level 0 is always the leaf, and nodes[1...BTRFS_MAX_LEVEL] will point
@ -166,6 +123,94 @@ struct btrfs_path {
int slots[BTRFS_MAX_LEVEL];
};
/*
* items in the extent btree are used to record the objectid of the
* owner of the block and the number of references
*/
struct btrfs_extent_item {
__le32 refs;
__le64 owner;
} __attribute__ ((__packed__));
struct btrfs_dir_item {
__le64 objectid;
__le16 flags;
u8 type;
} __attribute__ ((__packed__));
struct btrfs_root_item {
__le64 blocknr;
__le32 flags;
__le64 block_limit;
__le64 blocks_used;
__le32 refs;
};
/*
* in ram representation of the tree. extent_root is used for all allocations
* and for the extent tree extent_root root. current_insert is used
* only for the extent tree.
*/
struct btrfs_root {
struct btrfs_buffer *node;
struct btrfs_buffer *commit_root;
struct btrfs_root *extent_root;
struct btrfs_root *tree_root;
struct btrfs_key current_insert;
struct btrfs_key last_insert;
int fp;
struct radix_tree_root cache_radix;
struct radix_tree_root pinned_radix;
struct list_head trans;
struct list_head cache;
int cache_size;
int ref_cows;
struct btrfs_root_item root_item;
struct btrfs_key root_key;
u32 blocksize;
};
/* the lower bits in the key flags defines the item type */
#define BTRFS_KEY_TYPE_MAX 256
#define BTRFS_KEY_TYPE_MASK (BTRFS_KEY_TYPE_MAX - 1)
#define BTRFS_INODE_ITEM_KEY 1
#define BTRFS_DIR_ITEM_KEY 2
#define BTRFS_ROOT_ITEM_KEY 3
#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);
@ -238,39 +283,65 @@ static inline void btrfs_cpu_key_to_disk(struct btrfs_disk_key *disk,
disk->objectid = cpu_to_le64(cpu->objectid);
}
static inline u64 btrfs_key_objectid(struct btrfs_disk_key *disk)
static inline u64 btrfs_disk_key_objectid(struct btrfs_disk_key *disk)
{
return le64_to_cpu(disk->objectid);
}
static inline void btrfs_set_key_objectid(struct btrfs_disk_key *disk,
u64 val)
static inline void btrfs_set_disk_key_objectid(struct btrfs_disk_key *disk,
u64 val)
{
disk->objectid = cpu_to_le64(val);
}
static inline u64 btrfs_key_offset(struct btrfs_disk_key *disk)
static inline u64 btrfs_disk_key_offset(struct btrfs_disk_key *disk)
{
return le64_to_cpu(disk->offset);
}
static inline void btrfs_set_key_offset(struct btrfs_disk_key *disk,
u64 val)
static inline void btrfs_set_disk_key_offset(struct btrfs_disk_key *disk,
u64 val)
{
disk->offset = cpu_to_le64(val);
}
static inline u32 btrfs_key_flags(struct btrfs_disk_key *disk)
static inline u32 btrfs_disk_key_flags(struct btrfs_disk_key *disk)
{
return le32_to_cpu(disk->flags);
}
static inline void btrfs_set_key_flags(struct btrfs_disk_key *disk,
u32 val)
static inline void btrfs_set_disk_key_flags(struct btrfs_disk_key *disk,
u32 val)
{
disk->flags = cpu_to_le32(val);
}
static inline u32 btrfs_key_type(struct btrfs_key *key)
{
return key->flags & BTRFS_KEY_TYPE_MASK;
}
static inline u32 btrfs_disk_key_type(struct btrfs_disk_key *key)
{
return le32_to_cpu(key->flags) & BTRFS_KEY_TYPE_MASK;
}
static inline void btrfs_set_key_type(struct btrfs_key *key, u32 type)
{
BUG_ON(type >= BTRFS_KEY_TYPE_MAX);
key->flags = (key->flags & ~((u64)BTRFS_KEY_TYPE_MASK)) | type;
}
static inline void btrfs_set_disk_key_type(struct btrfs_disk_key *key, u32 type)
{
u32 flags = btrfs_disk_key_flags(key);
BUG_ON(type >= BTRFS_KEY_TYPE_MAX);
flags = (flags & ~((u64)BTRFS_KEY_TYPE_MASK)) | type;
btrfs_set_disk_key_flags(key, flags);
}
static inline u64 btrfs_header_blocknr(struct btrfs_header *h)
{
return le64_to_cpu(h->blocknr);
@ -407,7 +478,6 @@ static inline u8 *btrfs_leaf_data(struct btrfs_leaf *l)
{
return (u8 *)l->items;
}
/* helper function to cast into the data area of the leaf. */
#define btrfs_item_ptr(leaf, slot, type) \
((type *)(btrfs_leaf_data(leaf) + \
@ -422,7 +492,9 @@ void btrfs_release_path(struct btrfs_root *root, struct btrfs_path *p);
void btrfs_init_path(struct btrfs_path *p);
int btrfs_del_item(struct btrfs_root *root, struct btrfs_path *path);
int btrfs_insert_item(struct btrfs_root *root, struct btrfs_key *key,
void *data, int data_size);
void *data, u32 data_size);
int btrfs_insert_empty_item(struct btrfs_root *root, struct btrfs_path *path,
struct btrfs_key *cpu_key, u32 data_size);
int btrfs_next_leaf(struct btrfs_root *root, struct btrfs_path *path);
int btrfs_leaf_free_space(struct btrfs_root *root, struct btrfs_leaf *leaf);
int btrfs_drop_snapshot(struct btrfs_root *root, struct btrfs_buffer *snap);

102
dir-item.c 100644
View File

@ -0,0 +1,102 @@
#include <stdio.h>
#include <stdlib.h>
#include "kerncompat.h"
#include "radix-tree.h"
#include "ctree.h"
#include "disk-io.h"
#include "hash.h"
int btrfs_insert_dir_item(struct btrfs_root *root, char *name, int name_len,
u64 dir, u64 objectid, u8 type)
{
int ret = 0;
struct btrfs_path path;
struct btrfs_dir_item *dir_item;
char *name_ptr;
struct btrfs_key key;
u32 data_size;
key.objectid = dir;
key.flags = 0;
ret = btrfs_name_hash(name, name_len, &key.offset);
BUG_ON(ret);
btrfs_init_path(&path);
data_size = sizeof(*dir_item) + name_len;
ret = btrfs_insert_empty_item(root, &path, &key, data_size);
if (ret)
goto out;
dir_item = btrfs_item_ptr(&path.nodes[0]->leaf, path.slots[0],
struct btrfs_dir_item);
btrfs_set_dir_objectid(dir_item, objectid);
btrfs_set_dir_type(dir_item, type);
btrfs_set_dir_flags(dir_item, 0);
name_ptr = (char *)(dir_item + 1);
memcpy(name_ptr, name, name_len);
out:
btrfs_release_path(root, &path);
return ret;
}
int btrfs_del_dir_item(struct btrfs_root *root, u64 dir, char *name,
int name_len)
{
int ret = 0;
struct btrfs_path path;
struct btrfs_key key;
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, 1);
if (ret)
goto out;
ret = btrfs_del_item(root, &path);
out:
btrfs_release_path(root, &path);
return ret;
}
int btrfs_lookup_dir_item(struct btrfs_root *root, u64 dir, char *name,
int name_len, u64 *objectid)
{
int ret = 0;
struct btrfs_path path;
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_len = btrfs_item_size(item);
if (item_len != name_len + sizeof(struct btrfs_dir_item)) {
BUG();
ret = 1;
goto out;
}
name_ptr = (char *)(dir_item + 1);
if (memcmp(name_ptr, name, name_len)) {
BUG();
ret = 1;
goto out;
}
*objectid = btrfs_dir_objectid(dir_item);
out:
btrfs_release_path(root, &path);
return ret;
}

17
extent-tree.c
View File

@ -35,6 +35,7 @@ static int inc_block_ref(struct btrfs_root *root, u64 blocknr)
btrfs_init_path(&path);
key.objectid = blocknr;
key.flags = 0;
btrfs_set_key_type(&key, BTRFS_EXTENT_ITEM_KEY);
key.offset = 1;
ret = btrfs_search_slot(root->extent_root, &key, &path, 0, 1);
if (ret != 0)
@ -61,8 +62,9 @@ static int lookup_block_ref(struct btrfs_root *root, u64 blocknr, u32 *refs)
struct btrfs_extent_item *item;
btrfs_init_path(&path);
key.objectid = blocknr;
key.flags = 0;
key.offset = 1;
key.flags = 0;
btrfs_set_key_type(&key, BTRFS_EXTENT_ITEM_KEY);
ret = btrfs_search_slot(root->extent_root, &key, &path, 0, 0);
if (ret != 0)
BUG();
@ -123,6 +125,7 @@ static int finish_current_insert(struct btrfs_root *extent_root)
btrfs_header_parentid(&extent_root->node->node.header));
ins.offset = 1;
ins.flags = 0;
btrfs_set_key_type(&ins, BTRFS_EXTENT_ITEM_KEY);
for (i = 0; i < extent_root->current_insert.flags; i++) {
ins.objectid = extent_root->current_insert.objectid + i;
@ -149,6 +152,7 @@ static int __free_extent(struct btrfs_root *root, u64 blocknr, u64 num_blocks)
key.objectid = blocknr;
key.flags = 0;
btrfs_set_key_type(&key, BTRFS_EXTENT_ITEM_KEY);
key.offset = num_blocks;
find_free_extent(root, 0, 0, (u64)-1, &ins);
@ -228,7 +232,6 @@ static int run_pending(struct btrfs_root *extent_root)
*/
int btrfs_free_extent(struct btrfs_root *root, u64 blocknr, u64 num_blocks)
{
struct btrfs_key key;
struct btrfs_root *extent_root = root->extent_root;
struct btrfs_buffer *t;
int pending_ret;
@ -240,9 +243,6 @@ int btrfs_free_extent(struct btrfs_root *root, u64 blocknr, u64 num_blocks)
CTREE_EXTENT_PENDING_DEL);
return 0;
}
key.objectid = blocknr;
key.flags = 0;
key.offset = num_blocks;
ret = __free_extent(root, blocknr, num_blocks);
pending_ret = run_pending(root->extent_root);
return ret ? ret : pending_ret;
@ -252,7 +252,7 @@ int btrfs_free_extent(struct btrfs_root *root, u64 blocknr, u64 num_blocks)
* walks the btree of allocated extents and find a hole of a given size.
* The key ins is changed to record the hole:
* ins->objectid == block start
* ins->flags = 0
* ins->flags = BTRFS_EXTENT_ITEM_KEY
* ins->offset == number of blocks
* Any available blocks before search_start are skipped.
*/
@ -275,11 +275,14 @@ static int find_free_extent(struct btrfs_root *orig_root, u64 num_blocks,
total_needed += (btrfs_header_level(&root->node->node.header) + 1) * 3;
if (root->last_insert.objectid > search_start)
search_start = root->last_insert.objectid;
ins->flags = 0;
btrfs_set_key_type(ins, BTRFS_EXTENT_ITEM_KEY);
check_failed:
btrfs_init_path(&path);
ins->objectid = search_start;
ins->offset = 0;
ins->flags = 0;
start_found = 0;
ret = btrfs_search_slot(root, ins, &path, 0, 0);
if (ret < 0)

86
hash.c 100644
View File

@ -0,0 +1,86 @@
/*
* Original copy from:
* linux/fs/ext3/hash.c
*
* Copyright (C) 2002 by Theodore Ts'o
*
* This file is released under the GPL v2.
*
* This file may be redistributed under the terms of the GNU Public
* License.
*/
#include "kerncompat.h"
#define DELTA 0x9E3779B9
static void TEA_transform(__u32 buf[2], __u32 const in[])
{
__u32 sum = 0;
__u32 b0 = buf[0], b1 = buf[1];
__u32 a = in[0], b = in[1], c = in[2], d = in[3];
int n = 16;
do {
sum += DELTA;
b0 += ((b1 << 4)+a) ^ (b1+sum) ^ ((b1 >> 5)+b);
b1 += ((b0 << 4)+c) ^ (b0+sum) ^ ((b0 >> 5)+d);
} while(--n);
buf[0] += b0;
buf[1] += b1;
}
static void str2hashbuf(const char *msg, int len, __u32 *buf, int num)
{
__u32 pad, val;
int i;
pad = (__u32)len | ((__u32)len << 8);
pad |= pad << 16;
val = pad;
if (len > num*4)
len = num * 4;
for (i=0; i < len; i++) {
if ((i % 4) == 0)
val = pad;
val = msg[i] + (val << 8);
if ((i % 4) == 3) {
*buf++ = val;
val = pad;
num--;
}
}
if (--num >= 0)
*buf++ = val;
while (--num >= 0)
*buf++ = pad;
}
int btrfs_name_hash(const char *name, int len, u64 *hash_result)
{
__u32 hash;
__u32 minor_hash = 0;
const char *p;
__u32 in[8], buf[2];
/* Initialize the default seed for the hash checksum functions */
buf[0] = 0x67452301;
buf[1] = 0xefcdab89;
buf[2] = 0x98badcfe;
buf[3] = 0x10325476;
p = name;
while (len > 0) {
str2hashbuf(p, len, in, 4);
TEA_transform(buf, in);
len -= 16;
p += 16;
}
hash = buf[0];
minor_hash = buf[1];
*hash_result = buf[0];
*hash_result <<= 32;
*hash_result |= buf[1];
return 0;
}

23
hasher.c 100644
View File

@ -0,0 +1,23 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "kerncompat.h"
#include "hash.h"
int main() {
u64 result;
int ret;
char line[255];
char *p;
while(1) {
p = fgets(line, 255, stdin);
if (!p)
break;
if (strlen(line) == 0)
continue;
ret = btrfs_name_hash(line, strlen(line), &result);
BUG_ON(ret);
printf("hash returns %Lu\n", result);
}
return 0;
}

1
kerncompat.h
View File

@ -21,6 +21,7 @@
#endif
typedef unsigned int u32;
typedef u32 __u32;
typedef unsigned long long u64;
typedef unsigned char u8;
typedef unsigned short u16;

28
mkfs.c
View File

@ -50,9 +50,10 @@ int mkfs(int fd, u64 num_blocks, u32 blocksize)
itemoff = __BTRFS_LEAF_DATA_SIZE(blocksize) - sizeof(root_item);
btrfs_set_item_offset(&item, itemoff);
btrfs_set_item_size(&item, sizeof(root_item));
btrfs_set_key_objectid(&item.key, BTRFS_EXTENT_TREE_OBJECTID);
btrfs_set_key_offset(&item.key, 0);
btrfs_set_key_flags(&item.key, 0);
btrfs_set_disk_key_objectid(&item.key, BTRFS_EXTENT_TREE_OBJECTID);
btrfs_set_disk_key_offset(&item.key, 0);
btrfs_set_disk_key_flags(&item.key, 0);
btrfs_set_disk_key_type(&item.key, BTRFS_ROOT_ITEM_KEY);
memcpy(empty_leaf->items, &item, sizeof(item));
memcpy(btrfs_leaf_data(empty_leaf) + itemoff,
&root_item, sizeof(root_item));
@ -60,7 +61,7 @@ int mkfs(int fd, u64 num_blocks, u32 blocksize)
btrfs_set_root_blocknr(&root_item, start_block + 3);
itemoff = itemoff - sizeof(root_item);
btrfs_set_item_offset(&item, itemoff);
btrfs_set_key_objectid(&item.key, BTRFS_FS_TREE_OBJECTID);
btrfs_set_disk_key_objectid(&item.key, BTRFS_FS_TREE_OBJECTID);
memcpy(empty_leaf->items + 1, &item, sizeof(item));
memcpy(btrfs_leaf_data(empty_leaf) + itemoff,
&root_item, sizeof(root_item));
@ -73,9 +74,10 @@ int mkfs(int fd, u64 num_blocks, u32 blocksize)
btrfs_set_header_nritems(&empty_leaf->header, 4);
/* item1, reserve blocks 0-16 */
btrfs_set_key_objectid(&item.key, 0);
btrfs_set_key_offset(&item.key, start_block + 1);
btrfs_set_key_flags(&item.key, 0);
btrfs_set_disk_key_objectid(&item.key, 0);
btrfs_set_disk_key_offset(&item.key, start_block + 1);
btrfs_set_disk_key_flags(&item.key, 0);
btrfs_set_disk_key_type(&item.key, BTRFS_EXTENT_ITEM_KEY);
itemoff = __BTRFS_LEAF_DATA_SIZE(blocksize) -
sizeof(struct btrfs_extent_item);
btrfs_set_item_offset(&item, itemoff);
@ -87,8 +89,8 @@ int mkfs(int fd, u64 num_blocks, u32 blocksize)
&extent_item, btrfs_item_size(&item));
/* item2, give block 17 to the root */
btrfs_set_key_objectid(&item.key, start_block + 1);
btrfs_set_key_offset(&item.key, 1);
btrfs_set_disk_key_objectid(&item.key, start_block + 1);
btrfs_set_disk_key_offset(&item.key, 1);
itemoff = itemoff - sizeof(struct btrfs_extent_item);
btrfs_set_item_offset(&item, itemoff);
btrfs_set_extent_owner(&extent_item, BTRFS_ROOT_TREE_OBJECTID);
@ -97,8 +99,8 @@ int mkfs(int fd, u64 num_blocks, u32 blocksize)
&extent_item, btrfs_item_size(&item));
/* item3, give block 18 to the extent root */
btrfs_set_key_objectid(&item.key, start_block + 2);
btrfs_set_key_offset(&item.key, 1);
btrfs_set_disk_key_objectid(&item.key, start_block + 2);
btrfs_set_disk_key_offset(&item.key, 1);
itemoff = itemoff - sizeof(struct btrfs_extent_item);
btrfs_set_item_offset(&item, itemoff);
btrfs_set_extent_owner(&extent_item, BTRFS_EXTENT_TREE_OBJECTID);
@ -107,8 +109,8 @@ int mkfs(int fd, u64 num_blocks, u32 blocksize)
&extent_item, btrfs_item_size(&item));
/* item4, give block 19 to the FS root */
btrfs_set_key_objectid(&item.key, start_block + 3);
btrfs_set_key_offset(&item.key, 1);
btrfs_set_disk_key_objectid(&item.key, start_block + 3);
btrfs_set_disk_key_offset(&item.key, 1);
itemoff = itemoff - sizeof(struct btrfs_extent_item);
btrfs_set_item_offset(&item, itemoff);
btrfs_set_extent_owner(&extent_item, BTRFS_FS_TREE_OBJECTID);

36
print-tree.c
View File

@ -12,27 +12,41 @@ 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;
u32 type;
printf("leaf %Lu total ptrs %d free space %d\n",
btrfs_header_blocknr(&l->header), nr,
btrfs_leaf_free_space(root, l));
fflush(stdout);
for (i = 0 ; i < nr ; i++) {
item = l->items + i;
type = btrfs_disk_key_type(&item->key);
printf("\titem %d key (%Lu %Lu %u) itemoff %d itemsize %d\n",
i,
btrfs_key_objectid(&item->key),
btrfs_key_offset(&item->key),
btrfs_key_flags(&item->key),
btrfs_disk_key_objectid(&item->key),
btrfs_disk_key_offset(&item->key),
btrfs_disk_key_flags(&item->key),
btrfs_item_offset(item),
btrfs_item_size(item));
printf("\t\titem data %.*s\n", btrfs_item_size(item),
btrfs_leaf_data(l) + btrfs_item_offset(item));
ei = btrfs_item_ptr(l, i, struct btrfs_extent_item);
printf("\t\textent data refs %u owner %Lu\n",
btrfs_extent_refs(ei), btrfs_extent_owner(ei));
ri = btrfs_item_ptr(l, i, struct btrfs_root_item);
printf("\t\troot data blocknr %Lu refs %u\n",
btrfs_root_blocknr(ri), btrfs_root_refs(ri));
switch (type) {
case BTRFS_INODE_ITEM_KEY:
break;
case BTRFS_DIR_ITEM_KEY:
break;
case BTRFS_ROOT_ITEM_KEY:
ri = btrfs_item_ptr(l, i, struct btrfs_root_item);
printf("\t\troot data blocknr %Lu refs %u\n",
btrfs_root_blocknr(ri), btrfs_root_refs(ri));
break;
case BTRFS_EXTENT_ITEM_KEY:
ei = btrfs_item_ptr(l, i, struct btrfs_extent_item);
printf("\t\textent data refs %u owner %Lu\n",
btrfs_extent_refs(ei), btrfs_extent_owner(ei));
break;
case BTRFS_STRING_ITEM_KEY:
printf("\t\titem data %.*s\n", btrfs_item_size(item),
btrfs_leaf_data(l) + btrfs_item_offset(item));
break;
};
fflush(stdout);
}
}

3
quick-test.c
View File

@ -30,6 +30,8 @@ int main(int ac, char **av) {
root = open_ctree("dbfile", &super);
srand(55);
ins.flags = 0;
btrfs_set_key_type(&ins, BTRFS_STRING_ITEM_KEY);
for (i = 0; i < run_size; i++) {
buf = malloc(64);
num = next_key(i, max_key);
@ -39,7 +41,6 @@ int main(int ac, char **av) {
fprintf(stderr, "insert %d:%d\n", num, i);
ins.objectid = num;
ins.offset = 0;
ins.flags = 0;
ret = btrfs_insert_item(root, &ins, buf, strlen(buf));
if (!ret)
tree_size++;

10
random-test.c
View File

@ -18,6 +18,7 @@ static int setup_key(struct radix_tree_root *root, struct btrfs_key *key,
int ret;
key->flags = 0;
btrfs_set_key_type(key, BTRFS_STRING_ITEM_KEY);
key->offset = 0;
again:
ret = radix_tree_gang_lookup(root, (void **)res, num, 2);
@ -157,6 +158,7 @@ static int empty_tree(struct btrfs_root *root, struct radix_tree_root *radix,
key.offset = 0;
key.flags = 0;
btrfs_set_key_type(&key, BTRFS_STRING_ITEM_KEY);
key.objectid = (unsigned long)-1;
while(nr-- >= 0) {
btrfs_init_path(&path);
@ -173,7 +175,8 @@ static int empty_tree(struct btrfs_root *root, struct radix_tree_root *radix,
path.slots[0] -= 1;
}
slot = path.slots[0];
found=btrfs_key_objectid(&path.nodes[0]->leaf.items[slot].key);
found = btrfs_disk_key_objectid(
&path.nodes[0]->leaf.items[slot].key);
ret = btrfs_del_item(root, &path);
count++;
if (ret) {
@ -257,6 +260,7 @@ static int fill_radix(struct btrfs_root *root, struct radix_tree_root *radix)
key.offset = 0;
key.flags = 0;
btrfs_set_key_type(&key, BTRFS_STRING_ITEM_KEY);
key.objectid = (unsigned long)-1;
while(1) {
btrfs_init_path(&path);
@ -274,8 +278,8 @@ static int fill_radix(struct btrfs_root *root, struct radix_tree_root *radix)
slot -= 1;
}
for (i = slot; i >= 0; i--) {
found = btrfs_key_objectid(&path.nodes[0]->
leaf.items[i].key);
found = btrfs_disk_key_objectid(&path.nodes[0]->
leaf.items[i].key);
radix_tree_preload(GFP_KERNEL);
ret = radix_tree_insert(radix, found, (void *)found);
if (ret) {

2
root-tree.c
View File

@ -27,7 +27,7 @@ int btrfs_find_last_root(struct btrfs_root *root, u64 objectid,
l = &path.nodes[0]->leaf;
BUG_ON(path.slots[0] == 0);
slot = path.slots[0] - 1;
if (btrfs_key_objectid(&l->items[slot].key) != objectid) {
if (btrfs_disk_key_objectid(&l->items[slot].key) != objectid) {
ret = 1;
goto out;
}