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 \
* 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
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;
}
* 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;
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);
/* 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);
sizeof(struct btrfs_item) + data_size)
BUG();
- slot = path.slots[0];
+ slot = path->slots[0];
BUG_ON(slot < 0);
if (slot != nritems) {
int i;
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;
}
#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
} __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 {
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
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);
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);
{
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) + \
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);
--- /dev/null
+#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;
+}
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)
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();
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;
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);
*/
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;
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;
* 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.
*/
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)
--- /dev/null
+/*
+ * 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;
+}
--- /dev/null
+#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;
+}
#endif
typedef unsigned int u32;
+typedef u32 __u32;
typedef unsigned long long u64;
typedef unsigned char u8;
typedef unsigned short u16;
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));
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));
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);
&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);
&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);
&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);
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);
}
}
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);
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++;
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);
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);
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) {
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);
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) {
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;
}
projects / linux.git / commitdiff