Commit 62e2749e authored by Chris Mason's avatar Chris Mason Committed by David Woodhouse
Browse files

Btrfs: 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

Signed-off-by: default avatarChris Mason <chris.mason@oracle.com>
parent a1516c89

fs/btrfs/Makefile

+1 −1
Original line number Diff line number Diff line
@@ -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 \

fs/btrfs/TODO

+1 −0
Original line number Diff line number Diff line
@@ -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

fs/btrfs/ctree.c

+34 −17
Original line number Diff line number Diff line
@@ -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;

}

fs/btrfs/ctree.h

+127 −55
Original line number Diff line number Diff line
@@ -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,

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,

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,

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);

fs/btrfs/dir-item.c

0 → 100644
+102 −0
Original line number Diff line number Diff line 
#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;

}