dir-item.c 12.8 KB
Newer Older
C
Chris Mason 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
/*
 * Copyright (C) 2007 Oracle.  All rights reserved.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public
 * License v2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public
 * License along with this program; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 021110-1307, USA.
 */

19 20 21
#include "ctree.h"
#include "disk-io.h"
#include "hash.h"
22
#include "transaction.h"
23

C
Chris Mason 已提交
24 25 26 27 28 29 30 31
/*
 * insert a name into a directory, doing overflow properly if there is a hash
 * collision.  data_size indicates how big the item inserted should be.  On
 * success a struct btrfs_dir_item pointer is returned, otherwise it is
 * an ERR_PTR.
 *
 * The name is not copied into the dir item, you have to do that yourself.
 */
C
Chris Mason 已提交
32 33 34 35 36
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,
C
Chris Mason 已提交
37 38 39
						   u32 data_size,
						   const char *name,
						   int name_len)
40 41
{
	int ret;
42 43
	char *ptr;
	struct btrfs_item *item;
44
	struct extent_buffer *leaf;
45 46

	ret = btrfs_insert_empty_item(trans, root, path, cpu_key, data_size);
47
	if (ret == -EEXIST) {
C
Chris Mason 已提交
48 49 50 51
		struct btrfs_dir_item *di;
		di = btrfs_match_dir_item_name(root, path, name, name_len);
		if (di)
			return ERR_PTR(-EEXIST);
52 53
		btrfs_extend_item(trans, root, path, data_size);
	} else if (ret < 0)
54
		return ERR_PTR(ret);
55
	WARN_ON(ret > 0);
56 57
	leaf = path->nodes[0];
	item = btrfs_item_nr(leaf, path->slots[0]);
58
	ptr = btrfs_item_ptr(leaf, path->slots[0], char);
59 60
	BUG_ON(data_size > btrfs_item_size(leaf, item));
	ptr += btrfs_item_size(leaf, item) - data_size;
61
	return (struct btrfs_dir_item *)ptr;
62 63
}

C
Chris Mason 已提交
64 65 66 67
/*
 * xattrs work a lot like directories, this inserts an xattr item
 * into the tree
 */
J
Josef Bacik 已提交
68
int btrfs_insert_xattr_item(struct btrfs_trans_handle *trans,
69 70 71 72
			    struct btrfs_root *root,
			    struct btrfs_path *path, u64 objectid,
			    const char *name, u16 name_len,
			    const void *data, u16 data_len)
J
Josef Bacik 已提交
73 74 75 76 77 78 79 80 81
{
	int ret = 0;
	struct btrfs_dir_item *dir_item;
	unsigned long name_ptr, data_ptr;
	struct btrfs_key key, location;
	struct btrfs_disk_key disk_key;
	struct extent_buffer *leaf;
	u32 data_size;

82 83 84
	BUG_ON(name_len + data_len > BTRFS_MAX_XATTR_SIZE(root));

	key.objectid = objectid;
J
Josef Bacik 已提交
85
	btrfs_set_key_type(&key, BTRFS_XATTR_ITEM_KEY);
D
David Miller 已提交
86
	key.offset = btrfs_name_hash(name, name_len);
J
Josef Bacik 已提交
87 88 89 90

	data_size = sizeof(*dir_item) + name_len + data_len;
	dir_item = insert_with_overflow(trans, root, path, &key, data_size,
					name, name_len);
91 92
	if (IS_ERR(dir_item))
		return PTR_ERR(dir_item);
J
Josef Bacik 已提交
93 94 95 96 97 98 99
	memset(&location, 0, sizeof(location));

	leaf = path->nodes[0];
	btrfs_cpu_key_to_disk(&disk_key, &location);
	btrfs_set_dir_item_key(leaf, dir_item, &disk_key);
	btrfs_set_dir_type(leaf, dir_item, BTRFS_FT_XATTR);
	btrfs_set_dir_name_len(leaf, dir_item, name_len);
100
	btrfs_set_dir_transid(leaf, dir_item, trans->transid);
J
Josef Bacik 已提交
101 102 103 104 105 106 107 108 109 110 111
	btrfs_set_dir_data_len(leaf, dir_item, data_len);
	name_ptr = (unsigned long)(dir_item + 1);
	data_ptr = (unsigned long)((char *)name_ptr + name_len);

	write_extent_buffer(leaf, name, name_ptr, name_len);
	write_extent_buffer(leaf, data, data_ptr, data_len);
	btrfs_mark_buffer_dirty(path->nodes[0]);

	return ret;
}

C
Chris Mason 已提交
112 113 114 115 116 117
/*
 * insert a directory item in the tree, doing all the magic for
 * both indexes. 'dir' indicates which objectid to insert it into,
 * 'location' is the key to stuff into the directory item, 'type' is the
 * type of the inode we're pointing to, and 'index' is the sequence number
 * to use for the second index (if one is created).
118
 * Will return 0 or -ENOMEM
C
Chris Mason 已提交
119
 */
120
int btrfs_insert_dir_item(struct btrfs_trans_handle *trans, struct btrfs_root
121 122 123
			  *root, const char *name, int name_len,
			  struct inode *dir, struct btrfs_key *location,
			  u8 type, u64 index)
124 125
{
	int ret = 0;
C
Chris Mason 已提交
126
	int ret2 = 0;
127
	struct btrfs_path *path;
128
	struct btrfs_dir_item *dir_item;
129 130
	struct extent_buffer *leaf;
	unsigned long name_ptr;
131
	struct btrfs_key key;
132
	struct btrfs_disk_key disk_key;
133 134
	u32 data_size;

135
	key.objectid = btrfs_ino(dir);
136
	btrfs_set_key_type(&key, BTRFS_DIR_ITEM_KEY);
D
David Miller 已提交
137
	key.offset = btrfs_name_hash(name, name_len);
138

139
	path = btrfs_alloc_path();
140 141
	if (!path)
		return -ENOMEM;
142 143
	path->leave_spinning = 1;

144 145
	btrfs_cpu_key_to_disk(&disk_key, location);

146
	data_size = sizeof(*dir_item) + name_len;
C
Chris Mason 已提交
147 148
	dir_item = insert_with_overflow(trans, root, path, &key, data_size,
					name, name_len);
149 150
	if (IS_ERR(dir_item)) {
		ret = PTR_ERR(dir_item);
C
Chris Mason 已提交
151 152
		if (ret == -EEXIST)
			goto second_insert;
153
		goto out_free;
154
	}
155

156 157 158
	leaf = path->nodes[0];
	btrfs_set_dir_item_key(leaf, dir_item, &disk_key);
	btrfs_set_dir_type(leaf, dir_item, type);
J
Josef Bacik 已提交
159
	btrfs_set_dir_data_len(leaf, dir_item, 0);
160
	btrfs_set_dir_name_len(leaf, dir_item, name_len);
161
	btrfs_set_dir_transid(leaf, dir_item, trans->transid);
162
	name_ptr = (unsigned long)(dir_item + 1);
C
Chris Mason 已提交
163

164 165
	write_extent_buffer(leaf, name, name_ptr, name_len);
	btrfs_mark_buffer_dirty(leaf);
166

C
Chris Mason 已提交
167
second_insert:
168 169 170
	/* FIXME, use some real flag for selecting the extra index */
	if (root == root->fs_info->tree_root) {
		ret = 0;
171
		goto out_free;
172
	}
173
	btrfs_release_path(path);
174

175 176
	ret2 = btrfs_insert_delayed_dir_index(trans, root, name, name_len, dir,
					      &disk_key, type, index);
177
out_free:
178
	btrfs_free_path(path);
C
Chris Mason 已提交
179 180 181 182 183
	if (ret)
		return ret;
	if (ret2)
		return ret2;
	return 0;
184 185
}

C
Chris Mason 已提交
186 187 188 189 190
/*
 * lookup a directory item based on name.  'dir' is the objectid
 * we're searching in, and 'mod' tells us if you plan on deleting the
 * item (use mod < 0) or changing the options (use mod > 0)
 */
191 192 193 194 195
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)
196
{
197
	int ret;
198
	struct btrfs_key key;
199 200
	int ins_len = mod < 0 ? -1 : 0;
	int cow = mod != 0;
201 202

	key.objectid = dir;
203
	btrfs_set_key_type(&key, BTRFS_DIR_ITEM_KEY);
204

D
David Miller 已提交
205
	key.offset = btrfs_name_hash(name, name_len);
206

207 208 209
	ret = btrfs_search_slot(trans, root, &key, path, ins_len, cow);
	if (ret < 0)
		return ERR_PTR(ret);
210
	if (ret > 0)
211 212 213
		return NULL;

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

C
Chris Mason 已提交
216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274
int btrfs_check_dir_item_collision(struct btrfs_root *root, u64 dir,
				   const char *name, int name_len)
{
	int ret;
	struct btrfs_key key;
	struct btrfs_dir_item *di;
	int data_size;
	struct extent_buffer *leaf;
	int slot;
	struct btrfs_path *path;


	path = btrfs_alloc_path();
	if (!path)
		return -ENOMEM;

	key.objectid = dir;
	btrfs_set_key_type(&key, BTRFS_DIR_ITEM_KEY);
	key.offset = btrfs_name_hash(name, name_len);

	ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);

	/* return back any errors */
	if (ret < 0)
		goto out;

	/* nothing found, we're safe */
	if (ret > 0) {
		ret = 0;
		goto out;
	}

	/* we found an item, look for our name in the item */
	di = btrfs_match_dir_item_name(root, path, name, name_len);
	if (di) {
		/* our exact name was found */
		ret = -EEXIST;
		goto out;
	}

	/*
	 * see if there is room in the item to insert this
	 * name
	 */
	data_size = sizeof(*di) + name_len + sizeof(struct btrfs_item);
	leaf = path->nodes[0];
	slot = path->slots[0];
	if (data_size + btrfs_item_size_nr(leaf, slot) +
	    sizeof(struct btrfs_item) > BTRFS_LEAF_DATA_SIZE(root)) {
		ret = -EOVERFLOW;
	} else {
		/* plenty of insertion room */
		ret = 0;
	}
out:
	btrfs_free_path(path);
	return ret;
}

C
Chris Mason 已提交
275 276 277 278 279 280 281 282
/*
 * lookup a directory item based on index.  'dir' is the objectid
 * we're searching in, and 'mod' tells us if you plan on deleting the
 * item (use mod < 0) or changing the options (use mod > 0)
 *
 * The name is used to make sure the index really points to the name you were
 * looking for.
 */
283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306
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;
	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);
}

307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353
struct btrfs_dir_item *
btrfs_search_dir_index_item(struct btrfs_root *root,
			    struct btrfs_path *path, u64 dirid,
			    const char *name, int name_len)
{
	struct extent_buffer *leaf;
	struct btrfs_dir_item *di;
	struct btrfs_key key;
	u32 nritems;
	int ret;

	key.objectid = dirid;
	key.type = BTRFS_DIR_INDEX_KEY;
	key.offset = 0;

	ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
	if (ret < 0)
		return ERR_PTR(ret);

	leaf = path->nodes[0];
	nritems = btrfs_header_nritems(leaf);

	while (1) {
		if (path->slots[0] >= nritems) {
			ret = btrfs_next_leaf(root, path);
			if (ret < 0)
				return ERR_PTR(ret);
			if (ret > 0)
				break;
			leaf = path->nodes[0];
			nritems = btrfs_header_nritems(leaf);
			continue;
		}

		btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
		if (key.objectid != dirid || key.type != BTRFS_DIR_INDEX_KEY)
			break;

		di = btrfs_match_dir_item_name(root, path, name, name_len);
		if (di)
			return di;

		path->slots[0]++;
	}
	return NULL;
}

J
Josef Bacik 已提交
354 355 356 357 358 359 360 361 362 363 364 365 366
struct btrfs_dir_item *btrfs_lookup_xattr(struct btrfs_trans_handle *trans,
					  struct btrfs_root *root,
					  struct btrfs_path *path, u64 dir,
					  const char *name, u16 name_len,
					  int mod)
{
	int ret;
	struct btrfs_key key;
	int ins_len = mod < 0 ? -1 : 0;
	int cow = mod != 0;

	key.objectid = dir;
	btrfs_set_key_type(&key, BTRFS_XATTR_ITEM_KEY);
D
David Miller 已提交
367
	key.offset = btrfs_name_hash(name, name_len);
J
Josef Bacik 已提交
368 369 370
	ret = btrfs_search_slot(trans, root, &key, path, ins_len, cow);
	if (ret < 0)
		return ERR_PTR(ret);
371
	if (ret > 0)
J
Josef Bacik 已提交
372 373 374 375 376
		return NULL;

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

C
Chris Mason 已提交
377 378 379 380 381
/*
 * helper function to look at the directory item pointed to by 'path'
 * this walks through all the entries in a dir item and finds one
 * for a specific name.
 */
382
struct btrfs_dir_item *btrfs_match_dir_item_name(struct btrfs_root *root,
383 384
			      struct btrfs_path *path,
			      const char *name, int name_len)
385 386
{
	struct btrfs_dir_item *dir_item;
387
	unsigned long name_ptr;
388 389 390
	u32 total_len;
	u32 cur = 0;
	u32 this_len;
391
	struct extent_buffer *leaf;
392

393
	leaf = path->nodes[0];
394
	dir_item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_dir_item);
395 396 397
	if (verify_dir_item(root, leaf, dir_item))
		return NULL;

398
	total_len = btrfs_item_size_nr(leaf, path->slots[0]);
C
Chris Mason 已提交
399
	while (cur < total_len) {
400
		this_len = sizeof(*dir_item) +
J
Josef Bacik 已提交
401 402
			btrfs_dir_name_len(leaf, dir_item) +
			btrfs_dir_data_len(leaf, dir_item);
403
		name_ptr = (unsigned long)(dir_item + 1);
404

405 406
		if (btrfs_dir_name_len(leaf, dir_item) == name_len &&
		    memcmp_extent_buffer(leaf, name, name_ptr, name_len) == 0)
407 408 409 410 411 412 413
			return dir_item;

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

C
Chris Mason 已提交
416 417 418 419
/*
 * given a pointer into a directory item, delete it.  This
 * handles items that have more than one entry in them.
 */
420 421 422 423 424 425
int btrfs_delete_one_dir_name(struct btrfs_trans_handle *trans,
			      struct btrfs_root *root,
			      struct btrfs_path *path,
			      struct btrfs_dir_item *di)
{

426
	struct extent_buffer *leaf;
427 428
	u32 sub_item_len;
	u32 item_len;
429
	int ret = 0;
430

431
	leaf = path->nodes[0];
J
Josef Bacik 已提交
432 433
	sub_item_len = sizeof(*di) + btrfs_dir_name_len(leaf, di) +
		btrfs_dir_data_len(leaf, di);
434 435
	item_len = btrfs_item_size_nr(leaf, path->slots[0]);
	if (sub_item_len == item_len) {
436 437
		ret = btrfs_del_item(trans, root, path);
	} else {
438 439 440 441 442 443
		/* MARKER */
		unsigned long ptr = (unsigned long)di;
		unsigned long start;

		start = btrfs_item_ptr_offset(leaf, path->slots[0]);
		memmove_extent_buffer(leaf, ptr, ptr + sub_item_len,
444
			item_len - (ptr + sub_item_len - start));
445
		btrfs_truncate_item(root, path, item_len - sub_item_len, 1);
446
	}
447
	return ret;
448
}
449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466

int verify_dir_item(struct btrfs_root *root,
		    struct extent_buffer *leaf,
		    struct btrfs_dir_item *dir_item)
{
	u16 namelen = BTRFS_NAME_LEN;
	u8 type = btrfs_dir_type(leaf, dir_item);

	if (type >= BTRFS_FT_MAX) {
		printk(KERN_CRIT "btrfs: invalid dir item type: %d\n",
		       (int)type);
		return 1;
	}

	if (type == BTRFS_FT_XATTR)
		namelen = XATTR_NAME_MAX;

	if (btrfs_dir_name_len(leaf, dir_item) > namelen) {
467
		printk(KERN_CRIT "btrfs: invalid dir item name len: %u\n",
468 469 470 471 472 473 474 475 476 477 478 479 480
		       (unsigned)btrfs_dir_data_len(leaf, dir_item));
		return 1;
	}

	/* BTRFS_MAX_XATTR_SIZE is the same for all dir items */
	if (btrfs_dir_data_len(leaf, dir_item) > BTRFS_MAX_XATTR_SIZE(root)) {
		printk(KERN_CRIT "btrfs: invalid dir item data len: %u\n",
		       (unsigned)btrfs_dir_data_len(leaf, dir_item));
		return 1;
	}

	return 0;
}