[linux-2.6-block.git] / fs / btrfs / dir-item.c

#include <linux/module.h>
#include "ctree.h"
#include "disk-io.h"
#include "hash.h"
#include "transaction.h"

int insert_with_overflow(struct btrfs_trans_handle *trans, struct btrfs_root
			    *root, struct btrfs_path *path, struct btrfs_key
			    *cpu_key, u32 data_size)
{
	int overflow;
	int ret;

	ret = btrfs_insert_empty_item(trans, root, path, cpu_key, data_size);
	overflow = btrfs_key_overflow(cpu_key);

	while(ret == -EEXIST && overflow < BTRFS_KEY_OVERFLOW_MAX) {
		overflow++;
		btrfs_set_key_overflow(cpu_key, overflow);
		btrfs_release_path(root, path);
		ret = btrfs_insert_empty_item(trans, root, path, cpu_key,
					      data_size);
	}
	return ret;
}

int btrfs_insert_dir_item(struct btrfs_trans_handle *trans, struct btrfs_root
			  *root, const 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;
	btrfs_set_key_type(&key, BTRFS_DIR_ITEM_KEY);
	ret = btrfs_name_hash(name, name_len, &key.offset);
	BUG_ON(ret);
	path = btrfs_alloc_path();
	btrfs_init_path(path);
	data_size = sizeof(*dir_item) + name_len;
	ret = insert_with_overflow(trans, root, path, &key, data_size);
	if (ret)
		goto out;

	dir_item = btrfs_item_ptr(btrfs_buffer_leaf(path->nodes[0]),
				  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);
	btrfs_set_dir_name_len(dir_item, name_len);
	name_ptr = (char *)(dir_item + 1);
	btrfs_memcpy(root, path->nodes[0]->b_data, name_ptr, name, name_len);
	btrfs_mark_buffer_dirty(path->nodes[0]);
	btrfs_release_path(root, path);

	btrfs_set_key_type(&key, BTRFS_DIR_INDEX_KEY);
	key.offset = objectid;
	ret = insert_with_overflow(trans, root, path, &key, data_size);
	// FIXME clear the dirindex bit
	if (ret)
		goto out;

	dir_item = btrfs_item_ptr(btrfs_buffer_leaf(path->nodes[0]),
				  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);
	btrfs_set_dir_name_len(dir_item, name_len);
	name_ptr = (char *)(dir_item + 1);
	btrfs_memcpy(root, path->nodes[0]->b_data, name_ptr, name, name_len);
	btrfs_mark_buffer_dirty(path->nodes[0]);
out:
	btrfs_release_path(root, path);
	btrfs_free_path(path);
	return ret;
}

int btrfs_lookup_dir_item(struct btrfs_trans_handle *trans, struct btrfs_root
			  *root, struct btrfs_path *path, u64 dir,
			  const char *name, int name_len, int mod)
{
	int ret;
	struct btrfs_key key;
	int ins_len = mod < 0 ? -1 : 0;
	int cow = mod != 0;
	struct btrfs_disk_key *found_key;
	struct btrfs_leaf *leaf;
	u32 overflow;

	key.objectid = dir;
	key.flags = 0;
	btrfs_set_key_type(&key, BTRFS_DIR_ITEM_KEY);
	btrfs_set_key_overflow(&key, BTRFS_KEY_OVERFLOW_MAX - 1);
	ret = btrfs_name_hash(name, name_len, &key.offset);
	BUG_ON(ret);
	while(1) {
		ret = btrfs_search_slot(trans, root, &key, path, ins_len, cow);
		if (ret < 0)
			return ret;
		if (ret > 0) {
			if (path->slots[0] == 0)
				return 1;
			path->slots[0]--;
		}
		leaf = btrfs_buffer_leaf(path->nodes[0]);
		found_key = &leaf->items[path->slots[0]].key;

		if (btrfs_disk_key_objectid(found_key) != dir ||
		    btrfs_disk_key_type(found_key) != BTRFS_DIR_ITEM_KEY ||
		    btrfs_disk_key_offset(found_key) != key.offset)
			return 1;

		if (btrfs_match_dir_item_name(root, path, name, name_len))
			return 0;

		overflow = btrfs_disk_key_overflow(found_key);
		if (overflow == 0)
			return 1;
		btrfs_set_key_overflow(&key, overflow - 1);
		btrfs_release_path(root, path);
	}
	return 1;
}

int btrfs_lookup_dir_index_item(struct btrfs_trans_handle *trans,
				struct btrfs_root *root,
				struct btrfs_path *path, u64 dir,
				u64 objectid, int mod)
{
	int ret;
	struct btrfs_key key;
	int ins_len = mod < 0 ? -1 : 0;
	int cow = mod != 0;
	struct btrfs_disk_key *found_key;
	struct btrfs_leaf *leaf;

	key.objectid = dir;
	key.flags = 0;
	btrfs_set_key_type(&key, BTRFS_DIR_INDEX_KEY);
	btrfs_set_key_overflow(&key, BTRFS_KEY_OVERFLOW_MAX - 1);
	key.offset = objectid;
	ret = btrfs_search_slot(trans, root, &key, path, ins_len, cow);
	if (ret < 0)
		return ret;
	if (ret > 0) {
		if (path->slots[0] == 0)
			return 1;
		path->slots[0]--;
	}
	leaf = btrfs_buffer_leaf(path->nodes[0]);
	found_key = &leaf->items[path->slots[0]].key;

	if (btrfs_disk_key_objectid(found_key) != dir ||
	    btrfs_disk_key_type(found_key) != BTRFS_DIR_INDEX_KEY)
		return 1;
	if (btrfs_disk_key_offset(found_key) == objectid)
		return 0;
	return 1;
}

int btrfs_match_dir_item_name(struct btrfs_root *root,
			      struct btrfs_path *path,
			      const char *name, int name_len)
{
	struct btrfs_dir_item *dir_item;
	char *name_ptr;

	dir_item = btrfs_item_ptr(btrfs_buffer_leaf(path->nodes[0]),
				  path->slots[0],
				  struct btrfs_dir_item);
	if (btrfs_dir_name_len(dir_item) != name_len)
		return 0;
	name_ptr = (char *)(dir_item + 1);
	if (memcmp(name_ptr, name, name_len))
		return 0;
	return 1;
}
Commit	Line	Data
2e635a27	1	#include <linux/module.h>
62e2749e CM	2	#include "ctree.h"
	3	#include "disk-io.h"
	4	#include "hash.h"
e089f05c	5	#include "transaction.h"
62e2749e	6
7fcde0e3 CM	7	int insert_with_overflow(struct btrfs_trans_handle *trans, struct btrfs_root
	8	root, struct btrfs_path path, struct btrfs_key
	9	*cpu_key, u32 data_size)
	10	{
	11	int overflow;
	12	int ret;
	13
	14	ret = btrfs_insert_empty_item(trans, root, path, cpu_key, data_size);
	15	overflow = btrfs_key_overflow(cpu_key);
	16
	17	while(ret == -EEXIST && overflow < BTRFS_KEY_OVERFLOW_MAX) {
	18	overflow++;
	19	btrfs_set_key_overflow(cpu_key, overflow);
	20	btrfs_release_path(root, path);
	21	ret = btrfs_insert_empty_item(trans, root, path, cpu_key,
	22	data_size);
	23	}
	24	return ret;
	25	}
	26
e089f05c	27	int btrfs_insert_dir_item(struct btrfs_trans_handle *trans, struct btrfs_root
d5719762	28	root, const char name, int name_len, u64 dir, u64
e089f05c	29	objectid, u8 type)
62e2749e CM	30	{
62e2749e CM	31	int ret = 0;
5caf2a00	32	struct btrfs_path *path;
62e2749e CM	33	struct btrfs_dir_item *dir_item;
	34	char *name_ptr;
	35	struct btrfs_key key;
	36	u32 data_size;
	37
	38	key.objectid = dir;
	39	key.flags = 0;
1d4f6404	40	btrfs_set_key_type(&key, BTRFS_DIR_ITEM_KEY);
e20d96d6	41	ret = btrfs_name_hash(name, name_len, &key.offset);
62e2749e	42	BUG_ON(ret);
5caf2a00 CM	43	path = btrfs_alloc_path();
5caf2a00 CM	44	btrfs_init_path(path);
62e2749e	45	data_size = sizeof(*dir_item) + name_len;
7fcde0e3	46	ret = insert_with_overflow(trans, root, path, &key, data_size);
62e2749e CM	47	if (ret)
	48	goto out;
	49
5caf2a00 CM	50	dir_item = btrfs_item_ptr(btrfs_buffer_leaf(path->nodes[0]),
5caf2a00 CM	51	path->slots[0],
62e2749e CM	52	struct btrfs_dir_item);
	53	btrfs_set_dir_objectid(dir_item, objectid);
	54	btrfs_set_dir_type(dir_item, type);
	55	btrfs_set_dir_flags(dir_item, 0);
a8a2ee0c	56	btrfs_set_dir_name_len(dir_item, name_len);
62e2749e	57	name_ptr = (char *)(dir_item + 1);
5caf2a00 CM	58	btrfs_memcpy(root, path->nodes[0]->b_data, name_ptr, name, name_len);
5caf2a00 CM	59	btrfs_mark_buffer_dirty(path->nodes[0]);
bae45de0 CM	60	btrfs_release_path(root, path);
	61
	62	btrfs_set_key_type(&key, BTRFS_DIR_INDEX_KEY);
	63	key.offset = objectid;
7fcde0e3	64	ret = insert_with_overflow(trans, root, path, &key, data_size);
bae45de0 CM	65	// FIXME clear the dirindex bit
	66	if (ret)
	67	goto out;
	68
	69	dir_item = btrfs_item_ptr(btrfs_buffer_leaf(path->nodes[0]),
	70	path->slots[0],
	71	struct btrfs_dir_item);
	72	btrfs_set_dir_objectid(dir_item, objectid);
	73	btrfs_set_dir_type(dir_item, type);
	74	btrfs_set_dir_flags(dir_item, 0);
	75	btrfs_set_dir_name_len(dir_item, name_len);
	76	name_ptr = (char *)(dir_item + 1);
	77	btrfs_memcpy(root, path->nodes[0]->b_data, name_ptr, name, name_len);
	78	btrfs_mark_buffer_dirty(path->nodes[0]);
62e2749e	79	out:
5caf2a00 CM	80	btrfs_release_path(root, path);
5caf2a00 CM	81	btrfs_free_path(path);
62e2749e CM	82	return ret;
	83	}
	84
e089f05c	85	int btrfs_lookup_dir_item(struct btrfs_trans_handle *trans, struct btrfs_root
e20d96d6 CM	86	root, struct btrfs_path path, u64 dir,
e20d96d6 CM	87	const char *name, int name_len, int mod)
62e2749e	88	{
1d4f6404	89	int ret;
62e2749e	90	struct btrfs_key key;
1d4f6404 CM	91	int ins_len = mod < 0 ? -1 : 0;
1d4f6404 CM	92	int cow = mod != 0;
7fcde0e3 CM	93	struct btrfs_disk_key *found_key;
7fcde0e3 CM	94	struct btrfs_leaf *leaf;
5be6f7f1	95	u32 overflow;
62e2749e CM	96
	97	key.objectid = dir;
	98	key.flags = 0;
1d4f6404	99	btrfs_set_key_type(&key, BTRFS_DIR_ITEM_KEY);
7fcde0e3	100	btrfs_set_key_overflow(&key, BTRFS_KEY_OVERFLOW_MAX - 1);
62e2749e CM	101	ret = btrfs_name_hash(name, name_len, &key.offset);
62e2749e CM	102	BUG_ON(ret);
7fcde0e3 CM	103	while(1) {
	104	ret = btrfs_search_slot(trans, root, &key, path, ins_len, cow);
	105	if (ret < 0)
	106	return ret;
	107	if (ret > 0) {
	108	if (path->slots[0] == 0)
	109	return 1;
	110	path->slots[0]--;
	111	}
	112	leaf = btrfs_buffer_leaf(path->nodes[0]);
	113	found_key = &leaf->items[path->slots[0]].key;
	114
	115	if (btrfs_disk_key_objectid(found_key) != dir \|\|
	116	btrfs_disk_key_type(found_key) != BTRFS_DIR_ITEM_KEY \|\|
	117	btrfs_disk_key_offset(found_key) != key.offset)
	118	return 1;
	119
	120	if (btrfs_match_dir_item_name(root, path, name, name_len))
	121	return 0;
	122
5be6f7f1 CM	123	overflow = btrfs_disk_key_overflow(found_key);
5be6f7f1 CM	124	if (overflow == 0)
7fcde0e3	125	return 1;
5be6f7f1	126	btrfs_set_key_overflow(&key, overflow - 1);
7fcde0e3 CM	127	btrfs_release_path(root, path);
	128	}
	129	return 1;
62e2749e CM	130	}
62e2749e CM	131
5f26f772 CM	132	int btrfs_lookup_dir_index_item(struct btrfs_trans_handle *trans,
	133	struct btrfs_root *root,
	134	struct btrfs_path *path, u64 dir,
	135	u64 objectid, int mod)
	136	{
	137	int ret;
	138	struct btrfs_key key;
	139	int ins_len = mod < 0 ? -1 : 0;
	140	int cow = mod != 0;
7fcde0e3 CM	141	struct btrfs_disk_key *found_key;
7fcde0e3 CM	142	struct btrfs_leaf *leaf;
5f26f772 CM	143
	144	key.objectid = dir;
	145	key.flags = 0;
	146	btrfs_set_key_type(&key, BTRFS_DIR_INDEX_KEY);
7fcde0e3	147	btrfs_set_key_overflow(&key, BTRFS_KEY_OVERFLOW_MAX - 1);
5f26f772 CM	148	key.offset = objectid;
5f26f772 CM	149	ret = btrfs_search_slot(trans, root, &key, path, ins_len, cow);
7fcde0e3 CM	150	if (ret < 0)
	151	return ret;
	152	if (ret > 0) {
	153	if (path->slots[0] == 0)
	154	return 1;
	155	path->slots[0]--;
	156	}
	157	leaf = btrfs_buffer_leaf(path->nodes[0]);
	158	found_key = &leaf->items[path->slots[0]].key;
	159
	160	if (btrfs_disk_key_objectid(found_key) != dir \|\|
	161	btrfs_disk_key_type(found_key) != BTRFS_DIR_INDEX_KEY)
	162	return 1;
	163	if (btrfs_disk_key_offset(found_key) == objectid)
	164	return 0;
	165	return 1;
5f26f772 CM	166	}
5f26f772 CM	167
e089f05c	168	int btrfs_match_dir_item_name(struct btrfs_root *root,
7f5c1516 CM	169	struct btrfs_path *path,
7f5c1516 CM	170	const char *name, int name_len)
62e2749e	171	{
62e2749e CM	172	struct btrfs_dir_item *dir_item;
62e2749e CM	173	char *name_ptr;
a8a2ee0c	174
e20d96d6 CM	175	dir_item = btrfs_item_ptr(btrfs_buffer_leaf(path->nodes[0]),
e20d96d6 CM	176	path->slots[0],
1d4f6404	177	struct btrfs_dir_item);
a8a2ee0c CM	178	if (btrfs_dir_name_len(dir_item) != name_len)
a8a2ee0c CM	179	return 0;
62e2749e	180	name_ptr = (char *)(dir_item + 1);
a8a2ee0c	181	if (memcmp(name_ptr, name, name_len))
1d4f6404	182	return 0;
1d4f6404	183	return 1;
62e2749e	184	}