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

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

static 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,
						   const char *name,
						   int name_len)
{
	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) {
		struct btrfs_dir_item *di;
		di = btrfs_match_dir_item_name(root, path, name, name_len);
		if (di)
			return ERR_PTR(-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;
	int ret2 = 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,
					name, name_len);
	if (IS_ERR(dir_item)) {
		ret = PTR_ERR(dir_item);
		if (ret == -EEXIST)
			goto second_insert;
		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]);

second_insert:
	/* 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,
					name, name_len);
	if (IS_ERR(dir_item)) {
		ret2 = 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);
	if (ret)
		return ret;
	if (ret2)
		return ret2;
	return 0;
}

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