[mirror_ubuntu-artful-kernel.git] / fs / btrfs / dir-item.c

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

struct btrfs_dir_item *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 ret;
	char *ptr;
	struct btrfs_item *item;
	struct btrfs_leaf *leaf;

	ret = btrfs_insert_empty_item(trans, root, path, cpu_key, data_size);
	if (ret == -EEXIST) {
		ret = btrfs_extend_item(trans, root, path, data_size);
		WARN_ON(ret > 0);
		if (ret)
			return ERR_PTR(ret);
	}
	WARN_ON(ret > 0);
	leaf = btrfs_buffer_leaf(path->nodes[0]);
	item = leaf->items + path->slots[0];
	ptr = btrfs_item_ptr(leaf, path->slots[0], char);
	BUG_ON(data_size > btrfs_item_size(item));
	ptr += btrfs_item_size(item) - data_size;
	return (struct btrfs_dir_item *)ptr;
}

int btrfs_insert_dir_item(struct btrfs_trans_handle *trans, struct btrfs_root
			  *root, const char *name, int name_len, u64 dir,
			  struct btrfs_key *location, 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;
	dir_item = insert_with_overflow(trans, root, path, &key, data_size);
	if (IS_ERR(dir_item)) {
		ret = PTR_ERR(dir_item);
		goto out;
	}

	btrfs_cpu_key_to_disk(&dir_item->location, location);
	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]);

	/* FIXME, use some real flag for selecting the extra index */
	if (root == root->fs_info->tree_root) {
		ret = 0;
		goto out;
	}

	btrfs_release_path(root, path);

	btrfs_set_key_type(&key, BTRFS_DIR_INDEX_KEY);
	key.offset = location->objectid;
	dir_item = insert_with_overflow(trans, root, path, &key, data_size);
	if (IS_ERR(dir_item)) {
		ret = PTR_ERR(dir_item);
		goto out;
	}
	btrfs_cpu_key_to_disk(&dir_item->location, location);
	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_free_path(path);
	return ret;
}

struct btrfs_dir_item *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;

	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);
	ret = btrfs_search_slot(trans, root, &key, path, ins_len, cow);
	if (ret < 0)
		return ERR_PTR(ret);
	if (ret > 0) {
		if (path->slots[0] == 0)
			return NULL;
		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 NULL;

	return btrfs_match_dir_item_name(root, path, name, name_len);
}

struct btrfs_dir_item *
btrfs_lookup_dir_index_item(struct btrfs_trans_handle *trans,
			    struct btrfs_root *root,
			    struct btrfs_path *path, u64 dir,
			    u64 objectid, 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;

	key.objectid = dir;
	key.flags = 0;
	btrfs_set_key_type(&key, BTRFS_DIR_INDEX_KEY);
	key.offset = objectid;

	ret = btrfs_search_slot(trans, root, &key, path, ins_len, cow);
	if (ret < 0)
		return ERR_PTR(ret);
	if (ret > 0)
		return ERR_PTR(-ENOENT);
	return btrfs_match_dir_item_name(root, path, name, name_len);
}

struct btrfs_dir_item *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;
	u32 total_len;
	u32 cur = 0;
	u32 this_len;
	struct btrfs_leaf *leaf;

	leaf = btrfs_buffer_leaf(path->nodes[0]);
	dir_item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_dir_item);
	total_len = btrfs_item_size(leaf->items + path->slots[0]);
	while(cur < total_len) {
		this_len = sizeof(*dir_item) + btrfs_dir_name_len(dir_item);
		name_ptr = (char *)(dir_item + 1);

		if (btrfs_dir_name_len(dir_item) == name_len &&
		    memcmp(name_ptr, name, name_len) == 0)
			return dir_item;

		cur += this_len;
		dir_item = (struct btrfs_dir_item *)((char *)dir_item +
						     this_len);
	}
	return NULL;
}

int btrfs_delete_one_dir_name(struct btrfs_trans_handle *trans,
			      struct btrfs_root *root,
			      struct btrfs_path *path,
			      struct btrfs_dir_item *di)
{

	struct btrfs_leaf *leaf;
	u32 sub_item_len;
	u32 item_len;
	int ret;

	leaf = btrfs_buffer_leaf(path->nodes[0]);
	sub_item_len = sizeof(*di) + btrfs_dir_name_len(di);
	item_len = btrfs_item_size(leaf->items + path->slots[0]);
	if (sub_item_len == btrfs_item_size(leaf->items + path->slots[0])) {
		ret = btrfs_del_item(trans, root, path);
		BUG_ON(ret);
	} else {
		char *ptr = (char *)di;
		char *start = btrfs_item_ptr(leaf, path->slots[0], char);
		btrfs_memmove(root, leaf, ptr, ptr + sub_item_len,
			item_len - (ptr + sub_item_len - start));
		ret = btrfs_truncate_item(trans, root, path,
					  item_len - sub_item_len);
		BUG_ON(ret);
	}
	return 0;
}
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
7e38180e CM	7	struct btrfs_dir_item insert_with_overflow(struct btrfs_trans_handle trans,
	8	struct btrfs_root *root,
	9	struct btrfs_path *path,
	10	struct btrfs_key *cpu_key,
	11	u32 data_size)
7fcde0e3	12	{
7fcde0e3	13	int ret;
7e38180e CM	14	char *ptr;
	15	struct btrfs_item *item;
	16	struct btrfs_leaf *leaf;
7fcde0e3 CM	17
7fcde0e3 CM	18	ret = btrfs_insert_empty_item(trans, root, path, cpu_key, data_size);
7e38180e CM	19	if (ret == -EEXIST) {
	20	ret = btrfs_extend_item(trans, root, path, data_size);
	21	WARN_ON(ret > 0);
	22	if (ret)
	23	return ERR_PTR(ret);
7fcde0e3	24	}
7e38180e CM	25	WARN_ON(ret > 0);
	26	leaf = btrfs_buffer_leaf(path->nodes[0]);
	27	item = leaf->items + path->slots[0];
	28	ptr = btrfs_item_ptr(leaf, path->slots[0], char);
	29	BUG_ON(data_size > btrfs_item_size(item));
	30	ptr += btrfs_item_size(item) - data_size;
	31	return (struct btrfs_dir_item *)ptr;
7fcde0e3 CM	32	}
7fcde0e3 CM	33
e089f05c	34	int btrfs_insert_dir_item(struct btrfs_trans_handle *trans, struct btrfs_root
d6e4a428 CM	35	root, const char name, int name_len, u64 dir,
d6e4a428 CM	36	struct btrfs_key *location, u8 type)
62e2749e CM	37	{
62e2749e CM	38	int ret = 0;
5caf2a00	39	struct btrfs_path *path;
62e2749e CM	40	struct btrfs_dir_item *dir_item;
	41	char *name_ptr;
	42	struct btrfs_key key;
	43	u32 data_size;
	44
	45	key.objectid = dir;
	46	key.flags = 0;
1d4f6404	47	btrfs_set_key_type(&key, BTRFS_DIR_ITEM_KEY);
e20d96d6	48	ret = btrfs_name_hash(name, name_len, &key.offset);
62e2749e	49	BUG_ON(ret);
5caf2a00 CM	50	path = btrfs_alloc_path();
5caf2a00 CM	51	btrfs_init_path(path);
62e2749e	52	data_size = sizeof(*dir_item) + name_len;
7e38180e CM	53	dir_item = insert_with_overflow(trans, root, path, &key, data_size);
	54	if (IS_ERR(dir_item)) {
	55	ret = PTR_ERR(dir_item);
62e2749e	56	goto out;
7e38180e	57	}
62e2749e	58
d6e4a428	59	btrfs_cpu_key_to_disk(&dir_item->location, location);
62e2749e CM	60	btrfs_set_dir_type(dir_item, type);
62e2749e CM	61	btrfs_set_dir_flags(dir_item, 0);
a8a2ee0c	62	btrfs_set_dir_name_len(dir_item, name_len);
62e2749e	63	name_ptr = (char *)(dir_item + 1);
c5739bba CM	64
	65	btrfs_memcpy(root, path->nodes[0]->b_data, name_ptr, name, name_len);
	66	btrfs_mark_buffer_dirty(path->nodes[0]);
7e38180e CM	67
	68	/* FIXME, use some real flag for selecting the extra index */
	69	if (root == root->fs_info->tree_root) {
	70	ret = 0;
	71	goto out;
	72	}
	73
5caf2a00	74	btrfs_release_path(root, path);
7e38180e CM	75
	76	btrfs_set_key_type(&key, BTRFS_DIR_INDEX_KEY);
	77	key.offset = location->objectid;
	78	dir_item = insert_with_overflow(trans, root, path, &key, data_size);
	79	if (IS_ERR(dir_item)) {
	80	ret = PTR_ERR(dir_item);
	81	goto out;
	82	}
	83	btrfs_cpu_key_to_disk(&dir_item->location, location);
	84	btrfs_set_dir_type(dir_item, type);
	85	btrfs_set_dir_flags(dir_item, 0);
	86	btrfs_set_dir_name_len(dir_item, name_len);
	87	name_ptr = (char *)(dir_item + 1);
	88	btrfs_memcpy(root, path->nodes[0]->b_data, name_ptr, name, name_len);
	89	btrfs_mark_buffer_dirty(path->nodes[0]);
	90	out:
5caf2a00	91	btrfs_free_path(path);
62e2749e CM	92	return ret;
	93	}
	94
7e38180e CM	95	struct btrfs_dir_item btrfs_lookup_dir_item(struct btrfs_trans_handle trans,
	96	struct btrfs_root *root,
	97	struct btrfs_path *path, u64 dir,
	98	const char *name, int name_len,
	99	int mod)
62e2749e	100	{
1d4f6404	101	int ret;
62e2749e	102	struct btrfs_key key;
1d4f6404 CM	103	int ins_len = mod < 0 ? -1 : 0;
1d4f6404 CM	104	int cow = mod != 0;
7fcde0e3 CM	105	struct btrfs_disk_key *found_key;
7fcde0e3 CM	106	struct btrfs_leaf *leaf;
62e2749e CM	107
	108	key.objectid = dir;
	109	key.flags = 0;
1d4f6404	110	btrfs_set_key_type(&key, BTRFS_DIR_ITEM_KEY);
62e2749e CM	111	ret = btrfs_name_hash(name, name_len, &key.offset);
62e2749e CM	112	BUG_ON(ret);
7e38180e CM	113	ret = btrfs_search_slot(trans, root, &key, path, ins_len, cow);
	114	if (ret < 0)
	115	return ERR_PTR(ret);
	116	if (ret > 0) {
	117	if (path->slots[0] == 0)
	118	return NULL;
	119	path->slots[0]--;
7fcde0e3	120	}
7e38180e CM	121	leaf = btrfs_buffer_leaf(path->nodes[0]);
	122	found_key = &leaf->items[path->slots[0]].key;
	123
	124	if (btrfs_disk_key_objectid(found_key) != dir \|\|
	125	btrfs_disk_key_type(found_key) != BTRFS_DIR_ITEM_KEY \|\|
	126	btrfs_disk_key_offset(found_key) != key.offset)
	127	return NULL;
	128
	129	return btrfs_match_dir_item_name(root, path, name, name_len);
62e2749e CM	130	}
62e2749e CM	131
7e38180e CM	132	struct btrfs_dir_item *
	133	btrfs_lookup_dir_index_item(struct btrfs_trans_handle *trans,
	134	struct btrfs_root *root,
	135	struct btrfs_path *path, u64 dir,
	136	u64 objectid, const char *name, int name_len,
	137	int mod)
	138	{
	139	int ret;
	140	struct btrfs_key key;
	141	int ins_len = mod < 0 ? -1 : 0;
	142	int cow = mod != 0;
	143
	144	key.objectid = dir;
	145	key.flags = 0;
	146	btrfs_set_key_type(&key, BTRFS_DIR_INDEX_KEY);
	147	key.offset = objectid;
	148
	149	ret = btrfs_search_slot(trans, root, &key, path, ins_len, cow);
	150	if (ret < 0)
	151	return ERR_PTR(ret);
	152	if (ret > 0)
	153	return ERR_PTR(-ENOENT);
	154	return btrfs_match_dir_item_name(root, path, name, name_len);
	155	}
	156
	157	struct btrfs_dir_item btrfs_match_dir_item_name(struct btrfs_root root,
7f5c1516 CM	158	struct btrfs_path *path,
7f5c1516 CM	159	const char *name, int name_len)
62e2749e	160	{
62e2749e CM	161	struct btrfs_dir_item *dir_item;
62e2749e CM	162	char *name_ptr;
7e38180e CM	163	u32 total_len;
	164	u32 cur = 0;
	165	u32 this_len;
	166	struct btrfs_leaf *leaf;
a8a2ee0c	167
7e38180e CM	168	leaf = btrfs_buffer_leaf(path->nodes[0]);
	169	dir_item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_dir_item);
	170	total_len = btrfs_item_size(leaf->items + path->slots[0]);
	171	while(cur < total_len) {
	172	this_len = sizeof(*dir_item) + btrfs_dir_name_len(dir_item);
	173	name_ptr = (char *)(dir_item + 1);
	174
	175	if (btrfs_dir_name_len(dir_item) == name_len &&
	176	memcmp(name_ptr, name, name_len) == 0)
	177	return dir_item;
	178
	179	cur += this_len;
	180	dir_item = (struct btrfs_dir_item )((char )dir_item +
	181	this_len);
	182	}
	183	return NULL;
62e2749e	184	}
7e38180e CM	185
	186	int btrfs_delete_one_dir_name(struct btrfs_trans_handle *trans,
	187	struct btrfs_root *root,
	188	struct btrfs_path *path,
	189	struct btrfs_dir_item *di)
	190	{
	191
	192	struct btrfs_leaf *leaf;
	193	u32 sub_item_len;
	194	u32 item_len;
	195	int ret;
	196
	197	leaf = btrfs_buffer_leaf(path->nodes[0]);
	198	sub_item_len = sizeof(*di) + btrfs_dir_name_len(di);
	199	item_len = btrfs_item_size(leaf->items + path->slots[0]);
	200	if (sub_item_len == btrfs_item_size(leaf->items + path->slots[0])) {
	201	ret = btrfs_del_item(trans, root, path);
	202	BUG_ON(ret);
	203	} else {
	204	char ptr = (char )di;
	205	char *start = btrfs_item_ptr(leaf, path->slots[0], char);
	206	btrfs_memmove(root, leaf, ptr, ptr + sub_item_len,
	207	item_len - (ptr + sub_item_len - start));
	208	ret = btrfs_truncate_item(trans, root, path,
	209	item_len - sub_item_len);
	210	BUG_ON(ret);
	211	}
	212	return 0;
	213	}
	214