namei.c 44.2 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
/*
 * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README
 *
 * Trivial changes by Alan Cox to remove EHASHCOLLISION for compatibility
 *
 * Trivial Changes:
 * Rights granted to Hans Reiser to redistribute under other terms providing
 * he accepts all liability including but not limited to patent, fitness
 * for purpose, and direct or indirect claims arising from failure to perform.
 *
 * NO WARRANTY
 */

#include <linux/time.h>
#include <linux/bitops.h>
16
#include <linux/slab.h>
17
#include "reiserfs.h"
18
#include "acl.h"
19
#include "xattr.h"
Linus Torvalds's avatar
Linus Torvalds committed
20 21
#include <linux/quotaops.h>

22
#define INC_DIR_INODE_NLINK(i) if (i->i_nlink != 1) { inc_nlink(i); if (i->i_nlink >= REISERFS_LINK_MAX) set_nlink(i, 1); }
23
#define DEC_DIR_INODE_NLINK(i) if (i->i_nlink != 1) drop_nlink(i);
Linus Torvalds's avatar
Linus Torvalds committed
24 25 26

// directory item contains array of entry headers. This performs
// binary search through that array
27
static int bin_search_in_dir_item(struct reiserfs_dir_entry *de, loff_t off)
Linus Torvalds's avatar
Linus Torvalds committed
28
{
29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48
	struct item_head *ih = de->de_ih;
	struct reiserfs_de_head *deh = de->de_deh;
	int rbound, lbound, j;

	lbound = 0;
	rbound = I_ENTRY_COUNT(ih) - 1;

	for (j = (rbound + lbound) / 2; lbound <= rbound;
	     j = (rbound + lbound) / 2) {
		if (off < deh_offset(deh + j)) {
			rbound = j - 1;
			continue;
		}
		if (off > deh_offset(deh + j)) {
			lbound = j + 1;
			continue;
		}
		// this is not name found, but matched third key component
		de->de_entry_num = j;
		return NAME_FOUND;
Linus Torvalds's avatar
Linus Torvalds committed
49 50
	}

51 52
	de->de_entry_num = lbound;
	return NAME_NOT_FOUND;
Linus Torvalds's avatar
Linus Torvalds committed
53 54 55
}

// comment?  maybe something like set de to point to what the path points to?
56
static inline void set_de_item_location(struct reiserfs_dir_entry *de,
57
					struct treepath *path)
Linus Torvalds's avatar
Linus Torvalds committed
58
{
59 60 61 62 63
	de->de_bh = get_last_bh(path);
	de->de_ih = get_ih(path);
	de->de_deh = B_I_DEH(de->de_bh, de->de_ih);
	de->de_item_num = PATH_LAST_POSITION(path);
}
Linus Torvalds's avatar
Linus Torvalds committed
64 65

// de_bh, de_ih, de_deh (points to first element of array), de_item_num is set
66
inline void set_de_name_and_namelen(struct reiserfs_dir_entry *de)
Linus Torvalds's avatar
Linus Torvalds committed
67
{
68
	struct reiserfs_de_head *deh = de->de_deh + de->de_entry_num;
Linus Torvalds's avatar
Linus Torvalds committed
69

70
	BUG_ON(de->de_entry_num >= ih_entry_count(de->de_ih));
Linus Torvalds's avatar
Linus Torvalds committed
71

72 73 74 75 76
	de->de_entrylen = entry_length(de->de_bh, de->de_ih, de->de_entry_num);
	de->de_namelen = de->de_entrylen - (de_with_sd(deh) ? SD_SIZE : 0);
	de->de_name = B_I_PITEM(de->de_bh, de->de_ih) + deh_location(deh);
	if (de->de_name[de->de_namelen - 1] == 0)
		de->de_namelen = strlen(de->de_name);
Linus Torvalds's avatar
Linus Torvalds committed
77 78 79
}

// what entry points to
80
static inline void set_de_object_key(struct reiserfs_dir_entry *de)
Linus Torvalds's avatar
Linus Torvalds committed
81
{
82
	BUG_ON(de->de_entry_num >= ih_entry_count(de->de_ih));
83 84
	de->de_dir_id = deh_dir_id(&(de->de_deh[de->de_entry_num]));
	de->de_objectid = deh_objectid(&(de->de_deh[de->de_entry_num]));
Linus Torvalds's avatar
Linus Torvalds committed
85 86
}

87
static inline void store_de_entry_key(struct reiserfs_dir_entry *de)
Linus Torvalds's avatar
Linus Torvalds committed
88
{
89 90
	struct reiserfs_de_head *deh = de->de_deh + de->de_entry_num;

91
	BUG_ON(de->de_entry_num >= ih_entry_count(de->de_ih));
92 93 94 95 96 97 98 99 100

	/* store key of the found entry */
	de->de_entry_key.version = KEY_FORMAT_3_5;
	de->de_entry_key.on_disk_key.k_dir_id =
	    le32_to_cpu(de->de_ih->ih_key.k_dir_id);
	de->de_entry_key.on_disk_key.k_objectid =
	    le32_to_cpu(de->de_ih->ih_key.k_objectid);
	set_cpu_key_k_offset(&(de->de_entry_key), deh_offset(deh));
	set_cpu_key_k_type(&(de->de_entry_key), TYPE_DIRENTRY);
Linus Torvalds's avatar
Linus Torvalds committed
101 102 103 104 105 106 107 108 109
}

/* We assign a key to each directory item, and place multiple entries
in a single directory item.  A directory item has a key equal to the
key of the first directory entry in it.

This function first calls search_by_key, then, if item whose first
entry matches is not found it looks for the entry inside directory
item found by search_by_key. Fills the path to the entry, and to the
110
entry position in the item
Linus Torvalds's avatar
Linus Torvalds committed
111 112 113 114

*/

/* The function is NOT SCHEDULE-SAFE! */
115
int search_by_entry_key(struct super_block *sb, const struct cpu_key *key,
116
			struct treepath *path, struct reiserfs_dir_entry *de)
Linus Torvalds's avatar
Linus Torvalds committed
117
{
118 119 120 121 122 123
	int retval;

	retval = search_item(sb, key, path);
	switch (retval) {
	case ITEM_NOT_FOUND:
		if (!PATH_LAST_POSITION(path)) {
124 125
			reiserfs_error(sb, "vs-7000", "search_by_key "
				       "returned item position == 0");
126 127 128 129 130 131 132 133 134 135 136 137 138
			pathrelse(path);
			return IO_ERROR;
		}
		PATH_LAST_POSITION(path)--;

	case ITEM_FOUND:
		break;

	case IO_ERROR:
		return retval;

	default:
		pathrelse(path);
139
		reiserfs_error(sb, "vs-7002", "no path to here");
140
		return IO_ERROR;
Linus Torvalds's avatar
Linus Torvalds committed
141 142
	}

143
	set_de_item_location(de, path);
Linus Torvalds's avatar
Linus Torvalds committed
144 145

#ifdef CONFIG_REISERFS_CHECK
146 147 148
	if (!is_direntry_le_ih(de->de_ih) ||
	    COMP_SHORT_KEYS(&(de->de_ih->ih_key), key)) {
		print_block(de->de_bh, 0, -1, -1);
149 150 151
		reiserfs_panic(sb, "vs-7005", "found item %h is not directory "
			       "item or does not belong to the same directory "
			       "as key %K", de->de_ih, key);
152 153 154 155 156 157 158 159 160 161 162 163 164
	}
#endif				/* CONFIG_REISERFS_CHECK */

	/* binary search in directory item by third componen t of the
	   key. sets de->de_entry_num of de */
	retval = bin_search_in_dir_item(de, cpu_key_k_offset(key));
	path->pos_in_item = de->de_entry_num;
	if (retval != NAME_NOT_FOUND) {
		// ugly, but rename needs de_bh, de_deh, de_name, de_namelen, de_objectid set
		set_de_name_and_namelen(de);
		set_de_object_key(de);
	}
	return retval;
Linus Torvalds's avatar
Linus Torvalds committed
165 166 167 168 169 170 171 172 173
}

/* Keyed 32-bit hash function using TEA in a Davis-Meyer function */

/* The third component is hashed, and you can choose from more than
   one hash function.  Per directory hashes are not yet implemented
   but are thought about. This function should be moved to hashes.c
   Jedi, please do so.  -Hans */

174 175
static __u32 get_third_component(struct super_block *s,
				 const char *name, int len)
Linus Torvalds's avatar
Linus Torvalds committed
176
{
177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192
	__u32 res;

	if (!len || (len == 1 && name[0] == '.'))
		return DOT_OFFSET;
	if (len == 2 && name[0] == '.' && name[1] == '.')
		return DOT_DOT_OFFSET;

	res = REISERFS_SB(s)->s_hash_function(name, len);

	// take bits from 7-th to 30-th including both bounds
	res = GET_HASH_VALUE(res);
	if (res == 0)
		// needed to have no names before "." and ".." those have hash
		// value == 0 and generation conters 1 and 2 accordingly
		res = 128;
	return res + MAX_GENERATION_NUMBER;
Linus Torvalds's avatar
Linus Torvalds committed
193 194
}

195 196
static int reiserfs_match(struct reiserfs_dir_entry *de,
			  const char *name, int namelen)
Linus Torvalds's avatar
Linus Torvalds committed
197
{
198
	int retval = NAME_NOT_FOUND;
Linus Torvalds's avatar
Linus Torvalds committed
199

200 201 202 203 204
	if ((namelen == de->de_namelen) &&
	    !memcmp(de->de_name, name, de->de_namelen))
		retval =
		    (de_visible(de->de_deh + de->de_entry_num) ? NAME_FOUND :
		     NAME_FOUND_INVISIBLE);
Linus Torvalds's avatar
Linus Torvalds committed
205

206
	return retval;
Linus Torvalds's avatar
Linus Torvalds committed
207 208 209 210 211 212
}

/* de's de_bh, de_ih, de_deh, de_item_num, de_entry_num are set already */

				/* used when hash collisions exist */

213 214 215
static int linear_search_in_dir_item(struct cpu_key *key,
				     struct reiserfs_dir_entry *de,
				     const char *name, int namelen)
Linus Torvalds's avatar
Linus Torvalds committed
216
{
217 218 219
	struct reiserfs_de_head *deh = de->de_deh;
	int retval;
	int i;
Linus Torvalds's avatar
Linus Torvalds committed
220

221
	i = de->de_entry_num;
Linus Torvalds's avatar
Linus Torvalds committed
222

223 224 225 226 227
	if (i == I_ENTRY_COUNT(de->de_ih) ||
	    GET_HASH_VALUE(deh_offset(deh + i)) !=
	    GET_HASH_VALUE(cpu_key_k_offset(key))) {
		i--;
	}
Linus Torvalds's avatar
Linus Torvalds committed
228

229 230
	RFALSE(de->de_deh != B_I_DEH(de->de_bh, de->de_ih),
	       "vs-7010: array of entry headers not found");
Linus Torvalds's avatar
Linus Torvalds committed
231

232
	deh += i;
Linus Torvalds's avatar
Linus Torvalds committed
233

234 235 236 237 238 239 240 241 242 243
	for (; i >= 0; i--, deh--) {
		if (GET_HASH_VALUE(deh_offset(deh)) !=
		    GET_HASH_VALUE(cpu_key_k_offset(key))) {
			// hash value does not match, no need to check whole name
			return NAME_NOT_FOUND;
		}

		/* mark, that this generation number is used */
		if (de->de_gen_number_bit_string)
			set_bit(GET_GENERATION_NUMBER(deh_offset(deh)),
244
				de->de_gen_number_bit_string);
Linus Torvalds's avatar
Linus Torvalds committed
245

246 247 248
		// calculate pointer to name and namelen
		de->de_entry_num = i;
		set_de_name_and_namelen(de);
Linus Torvalds's avatar
Linus Torvalds committed
249

250 251 252
		if ((retval =
		     reiserfs_match(de, name, namelen)) != NAME_NOT_FOUND) {
			// de's de_name, de_namelen, de_recordlen are set. Fill the rest:
Linus Torvalds's avatar
Linus Torvalds committed
253

254 255
			// key of pointed object
			set_de_object_key(de);
Linus Torvalds's avatar
Linus Torvalds committed
256

257
			store_de_entry_key(de);
Linus Torvalds's avatar
Linus Torvalds committed
258

259 260 261
			// retval can be NAME_FOUND or NAME_FOUND_INVISIBLE
			return retval;
		}
Linus Torvalds's avatar
Linus Torvalds committed
262 263
	}

264 265 266 267 268 269 270 271 272
	if (GET_GENERATION_NUMBER(le_ih_k_offset(de->de_ih)) == 0)
		/* we have reached left most entry in the node. In common we
		   have to go to the left neighbor, but if generation counter
		   is 0 already, we know for sure, that there is no name with
		   the same hash value */
		// FIXME: this work correctly only because hash value can not
		// be 0. Btw, in case of Yura's hash it is probably possible,
		// so, this is a bug
		return NAME_NOT_FOUND;
Linus Torvalds's avatar
Linus Torvalds committed
273

274 275
	RFALSE(de->de_item_num,
	       "vs-7015: two diritems of the same directory in one node?");
Linus Torvalds's avatar
Linus Torvalds committed
276

277 278
	return GOTO_PREVIOUS_ITEM;
}
Linus Torvalds's avatar
Linus Torvalds committed
279 280 281

// may return NAME_FOUND, NAME_FOUND_INVISIBLE, NAME_NOT_FOUND
// FIXME: should add something like IOERROR
282
static int reiserfs_find_entry(struct inode *dir, const char *name, int namelen,
283
			       struct treepath *path_to_entry,
284
			       struct reiserfs_dir_entry *de)
Linus Torvalds's avatar
Linus Torvalds committed
285
{
286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301
	struct cpu_key key_to_search;
	int retval;

	if (namelen > REISERFS_MAX_NAME(dir->i_sb->s_blocksize))
		return NAME_NOT_FOUND;

	/* we will search for this key in the tree */
	make_cpu_key(&key_to_search, dir,
		     get_third_component(dir->i_sb, name, namelen),
		     TYPE_DIRENTRY, 3);

	while (1) {
		retval =
		    search_by_entry_key(dir->i_sb, &key_to_search,
					path_to_entry, de);
		if (retval == IO_ERROR) {
302
			reiserfs_error(dir->i_sb, "zam-7001", "io error");
303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321
			return IO_ERROR;
		}

		/* compare names for all entries having given hash value */
		retval =
		    linear_search_in_dir_item(&key_to_search, de, name,
					      namelen);
		if (retval != GOTO_PREVIOUS_ITEM) {
			/* there is no need to scan directory anymore. Given entry found or does not exist */
			path_to_entry->pos_in_item = de->de_entry_num;
			return retval;
		}

		/* there is left neighboring item of this directory and given entry can be there */
		set_cpu_key_k_offset(&key_to_search,
				     le_ih_k_offset(de->de_ih) - 1);
		pathrelse(path_to_entry);

	}			/* while (1) */
Linus Torvalds's avatar
Linus Torvalds committed
322 323
}

324
static struct dentry *reiserfs_lookup(struct inode *dir, struct dentry *dentry,
325
				      unsigned int flags)
Linus Torvalds's avatar
Linus Torvalds committed
326
{
327
	int retval;
328
	int lock_depth;
329 330 331 332 333 334 335
	struct inode *inode = NULL;
	struct reiserfs_dir_entry de;
	INITIALIZE_PATH(path_to_entry);

	if (REISERFS_MAX_NAME(dir->i_sb->s_blocksize) < dentry->d_name.len)
		return ERR_PTR(-ENAMETOOLONG);

336 337 338 339 340 341 342
	/*
	 * Might be called with or without the write lock, must be careful
	 * to not recursively hold it in case we want to release the lock
	 * before rescheduling.
	 */
	lock_depth = reiserfs_write_lock_once(dir->i_sb);

343 344 345 346 347 348
	de.de_gen_number_bit_string = NULL;
	retval =
	    reiserfs_find_entry(dir, dentry->d_name.name, dentry->d_name.len,
				&path_to_entry, &de);
	pathrelse(&path_to_entry);
	if (retval == NAME_FOUND) {
349 350
		inode = reiserfs_iget(dir->i_sb,
				      (struct cpu_key *)&(de.de_dir_id));
351
		if (!inode || IS_ERR(inode)) {
352
			reiserfs_write_unlock_once(dir->i_sb, lock_depth);
353 354 355
			return ERR_PTR(-EACCES);
		}

356 357 358 359
		/* Propagate the private flag so we know we're
		 * in the priv tree */
		if (IS_PRIVATE(dir))
			inode->i_flags |= S_PRIVATE;
360
	}
361
	reiserfs_write_unlock_once(dir->i_sb, lock_depth);
362 363
	if (retval == IO_ERROR) {
		return ERR_PTR(-EIO);
Linus Torvalds's avatar
Linus Torvalds committed
364 365
	}

366
	return d_splice_alias(inode, dentry);
367
}
Linus Torvalds's avatar
Linus Torvalds committed
368

369
/*
Linus Torvalds's avatar
Linus Torvalds committed
370 371 372 373 374
** looks up the dentry of the parent directory for child.
** taken from ext2_get_parent
*/
struct dentry *reiserfs_get_parent(struct dentry *child)
{
375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393
	int retval;
	struct inode *inode = NULL;
	struct reiserfs_dir_entry de;
	INITIALIZE_PATH(path_to_entry);
	struct inode *dir = child->d_inode;

	if (dir->i_nlink == 0) {
		return ERR_PTR(-ENOENT);
	}
	de.de_gen_number_bit_string = NULL;

	reiserfs_write_lock(dir->i_sb);
	retval = reiserfs_find_entry(dir, "..", 2, &path_to_entry, &de);
	pathrelse(&path_to_entry);
	if (retval != NAME_FOUND) {
		reiserfs_write_unlock(dir->i_sb);
		return ERR_PTR(-ENOENT);
	}
	inode = reiserfs_iget(dir->i_sb, (struct cpu_key *)&(de.de_dir_id));
Linus Torvalds's avatar
Linus Torvalds committed
394 395
	reiserfs_write_unlock(dir->i_sb);

396
	return d_obtain_alias(inode);
397
}
Linus Torvalds's avatar
Linus Torvalds committed
398

399
/* add entry to the directory (entry can be hidden).
Linus Torvalds's avatar
Linus Torvalds committed
400 401 402 403 404

insert definition of when hidden directories are used here -Hans

 Does not mark dir   inode dirty, do it after successesfull call to it */

405 406 407
static int reiserfs_add_entry(struct reiserfs_transaction_handle *th,
			      struct inode *dir, const char *name, int namelen,
			      struct inode *inode, int visible)
Linus Torvalds's avatar
Linus Torvalds committed
408
{
409 410 411 412
	struct cpu_key entry_key;
	struct reiserfs_de_head *deh;
	INITIALIZE_PATH(path);
	struct reiserfs_dir_entry de;
413
	DECLARE_BITMAP(bit_string, MAX_GENERATION_NUMBER + 1);
414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437
	int gen_number;
	char small_buf[32 + DEH_SIZE];	/* 48 bytes now and we avoid kmalloc
					   if we create file with short name */
	char *buffer;
	int buflen, paste_size;
	int retval;

	BUG_ON(!th->t_trans_id);

	/* cannot allow items to be added into a busy deleted directory */
	if (!namelen)
		return -EINVAL;

	if (namelen > REISERFS_MAX_NAME(dir->i_sb->s_blocksize))
		return -ENAMETOOLONG;

	/* each entry has unique key. compose it */
	make_cpu_key(&entry_key, dir,
		     get_third_component(dir->i_sb, name, namelen),
		     TYPE_DIRENTRY, 3);

	/* get memory for composing the entry */
	buflen = DEH_SIZE + ROUND_UP(namelen);
	if (buflen > sizeof(small_buf)) {
438
		buffer = kmalloc(buflen, GFP_NOFS);
439
		if (!buffer)
440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467
			return -ENOMEM;
	} else
		buffer = small_buf;

	paste_size =
	    (get_inode_sd_version(dir) ==
	     STAT_DATA_V1) ? (DEH_SIZE + namelen) : buflen;

	/* fill buffer : directory entry head, name[, dir objectid | , stat data | ,stat data, dir objectid ] */
	deh = (struct reiserfs_de_head *)buffer;
	deh->deh_location = 0;	/* JDM Endian safe if 0 */
	put_deh_offset(deh, cpu_key_k_offset(&entry_key));
	deh->deh_state = 0;	/* JDM Endian safe if 0 */
	/* put key (ino analog) to de */
	deh->deh_dir_id = INODE_PKEY(inode)->k_dir_id;	/* safe: k_dir_id is le */
	deh->deh_objectid = INODE_PKEY(inode)->k_objectid;	/* safe: k_objectid is le */

	/* copy name */
	memcpy((char *)(deh + 1), name, namelen);
	/* padd by 0s to the 4 byte boundary */
	padd_item((char *)(deh + 1), ROUND_UP(namelen), namelen);

	/* entry is ready to be pasted into tree, set 'visibility' and 'stat data in entry' attributes */
	mark_de_without_sd(deh);
	visible ? mark_de_visible(deh) : mark_de_hidden(deh);

	/* find the proper place for the new entry */
	memset(bit_string, 0, sizeof(bit_string));
468
	de.de_gen_number_bit_string = bit_string;
469 470 471
	retval = reiserfs_find_entry(dir, name, namelen, &path, &de);
	if (retval != NAME_NOT_FOUND) {
		if (buffer != small_buf)
472
			kfree(buffer);
473 474 475 476 477 478 479
		pathrelse(&path);

		if (retval == IO_ERROR) {
			return -EIO;
		}

		if (retval != NAME_FOUND) {
480 481 482
			reiserfs_error(dir->i_sb, "zam-7002",
				       "reiserfs_find_entry() returned "
				       "unexpected value (%d)", retval);
483 484 485 486
		}

		return -EEXIST;
	}
Linus Torvalds's avatar
Linus Torvalds committed
487

488
	gen_number =
489
	    find_first_zero_bit(bit_string,
490 491 492
				MAX_GENERATION_NUMBER + 1);
	if (gen_number > MAX_GENERATION_NUMBER) {
		/* there is no free generation number */
493 494 495
		reiserfs_warning(dir->i_sb, "reiserfs-7010",
				 "Congratulations! we have got hash function "
				 "screwed up");
496
		if (buffer != small_buf)
497
			kfree(buffer);
498 499 500 501 502 503 504 505 506 507 508 509 510
		pathrelse(&path);
		return -EBUSY;
	}
	/* adjust offset of directory enrty */
	put_deh_offset(deh, SET_GENERATION_NUMBER(deh_offset(deh), gen_number));
	set_cpu_key_k_offset(&entry_key, deh_offset(deh));

	/* update max-hash-collisions counter in reiserfs_sb_info */
	PROC_INFO_MAX(th->t_super, max_hash_collisions, gen_number);

	if (gen_number != 0) {	/* we need to re-search for the insertion point */
		if (search_by_entry_key(dir->i_sb, &entry_key, &path, &de) !=
		    NAME_NOT_FOUND) {
511 512 513
			reiserfs_warning(dir->i_sb, "vs-7032",
					 "entry with this key (%K) already "
					 "exists", &entry_key);
514 515

			if (buffer != small_buf)
516
				kfree(buffer);
517 518 519
			pathrelse(&path);
			return -EBUSY;
		}
Linus Torvalds's avatar
Linus Torvalds committed
520 521
	}

522 523 524 525 526
	/* perform the insertion of the entry that we have prepared */
	retval =
	    reiserfs_paste_into_item(th, &path, &entry_key, dir, buffer,
				     paste_size);
	if (buffer != small_buf)
527
		kfree(buffer);
528 529 530
	if (retval) {
		reiserfs_check_path(&path);
		return retval;
Linus Torvalds's avatar
Linus Torvalds committed
531 532
	}

533 534 535 536 537
	dir->i_size += paste_size;
	dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
	if (!S_ISDIR(inode->i_mode) && visible)
		// reiserfs_mkdir or reiserfs_rename will do that by itself
		reiserfs_update_sd(th, dir);
Linus Torvalds's avatar
Linus Torvalds committed
538

539 540
	reiserfs_check_path(&path);
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
541 542 543 544 545 546 547
}

/* quota utility function, call if you've had to abort after calling
** new_inode_init, and have not called reiserfs_new_inode yet.
** This should only be called on inodes that do not have stat data
** inserted into the tree yet.
*/
548 549
static int drop_new_inode(struct inode *inode)
{
550
	dquot_drop(inode);
551 552 553 554
	make_bad_inode(inode);
	inode->i_flags |= S_NOQUOTA;
	iput(inode);
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
555 556
}

557
/* utility function that does setup for reiserfs_new_inode.
558
** dquot_initialize needs lots of credits so it's better to have it
Linus Torvalds's avatar
Linus Torvalds committed
559 560 561
** outside of a transaction, so we had to pull some bits of
** reiserfs_new_inode out into this func.
*/
Al Viro's avatar
Al Viro committed
562
static int new_inode_init(struct inode *inode, struct inode *dir, umode_t mode)
563
{
564 565 566
	/* Make inode invalid - just in case we are going to drop it before
	 * the initialization happens */
	INODE_PKEY(inode)->k_objectid = 0;
567 568 569 570
	/* the quota init calls have to know who to charge the quota to, so
	 ** we have to set uid and gid here
	 */
	inode_init_owner(inode, dir, mode);
571
	dquot_initialize(inode);
572
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
573 574
}

Al Viro's avatar
Al Viro committed
575
static int reiserfs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
576
			   struct nameidata *nd)
Linus Torvalds's avatar
Linus Torvalds committed
577
{
578 579 580 581 582 583 584 585
	int retval;
	struct inode *inode;
	/* We need blocks for transaction + (user+group)*(quotas for new inode + update of quota for directory owner) */
	int jbegin_count =
	    JOURNAL_PER_BALANCE_CNT * 2 +
	    2 * (REISERFS_QUOTA_INIT_BLOCKS(dir->i_sb) +
		 REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb));
	struct reiserfs_transaction_handle th;
586
	struct reiserfs_security_handle security;
587

588
	dquot_initialize(dir);
589

590 591 592 593
	if (!(inode = new_inode(dir->i_sb))) {
		return -ENOMEM;
	}
	new_inode_init(inode, dir, mode);
Linus Torvalds's avatar
Linus Torvalds committed
594

595
	jbegin_count += reiserfs_cache_default_acl(dir);
596
	retval = reiserfs_security_init(dir, inode, &dentry->d_name, &security);
597 598 599 600 601
	if (retval < 0) {
		drop_new_inode(inode);
		return retval;
	}
	jbegin_count += retval;
602
	reiserfs_write_lock(dir->i_sb);
Linus Torvalds's avatar
Linus Torvalds committed
603

604 605 606 607 608 609 610 611
	retval = journal_begin(&th, dir->i_sb, jbegin_count);
	if (retval) {
		drop_new_inode(inode);
		goto out_failed;
	}

	retval =
	    reiserfs_new_inode(&th, dir, mode, NULL, 0 /*i_size */ , dentry,
612
			       inode, &security);
613 614 615 616 617 618 619 620 621 622 623 624
	if (retval)
		goto out_failed;

	inode->i_op = &reiserfs_file_inode_operations;
	inode->i_fop = &reiserfs_file_operations;
	inode->i_mapping->a_ops = &reiserfs_address_space_operations;

	retval =
	    reiserfs_add_entry(&th, dir, dentry->d_name.name,
			       dentry->d_name.len, inode, 1 /*visible */ );
	if (retval) {
		int err;
625
		drop_nlink(inode);
626 627 628 629
		reiserfs_update_sd(&th, inode);
		err = journal_end(&th, dir->i_sb, jbegin_count);
		if (err)
			retval = err;
Al Viro's avatar
Al Viro committed
630
		unlock_new_inode(inode);
631 632 633 634 635
		iput(inode);
		goto out_failed;
	}
	reiserfs_update_inode_transaction(inode);
	reiserfs_update_inode_transaction(dir);
Linus Torvalds's avatar
Linus Torvalds committed
636

637
	d_instantiate(dentry, inode);
Al Viro's avatar
Al Viro committed
638
	unlock_new_inode(inode);
639
	retval = journal_end(&th, dir->i_sb, jbegin_count);
Linus Torvalds's avatar
Linus Torvalds committed
640

641 642 643 644
      out_failed:
	reiserfs_write_unlock(dir->i_sb);
	return retval;
}
Linus Torvalds's avatar
Linus Torvalds committed
645

Al Viro's avatar
Al Viro committed
646
static int reiserfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode,
647 648 649 650 651
			  dev_t rdev)
{
	int retval;
	struct inode *inode;
	struct reiserfs_transaction_handle th;
652
	struct reiserfs_security_handle security;
653 654 655 656 657 658 659 660 661
	/* We need blocks for transaction + (user+group)*(quotas for new inode + update of quota for directory owner) */
	int jbegin_count =
	    JOURNAL_PER_BALANCE_CNT * 3 +
	    2 * (REISERFS_QUOTA_INIT_BLOCKS(dir->i_sb) +
		 REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb));

	if (!new_valid_dev(rdev))
		return -EINVAL;

662
	dquot_initialize(dir);
663

664 665 666 667
	if (!(inode = new_inode(dir->i_sb))) {
		return -ENOMEM;
	}
	new_inode_init(inode, dir, mode);
Linus Torvalds's avatar
Linus Torvalds committed
668

669
	jbegin_count += reiserfs_cache_default_acl(dir);
670
	retval = reiserfs_security_init(dir, inode, &dentry->d_name, &security);
671 672 673 674 675
	if (retval < 0) {
		drop_new_inode(inode);
		return retval;
	}
	jbegin_count += retval;
676
	reiserfs_write_lock(dir->i_sb);
Linus Torvalds's avatar
Linus Torvalds committed
677

678 679 680 681 682
	retval = journal_begin(&th, dir->i_sb, jbegin_count);
	if (retval) {
		drop_new_inode(inode);
		goto out_failed;
	}
Linus Torvalds's avatar
Linus Torvalds committed
683

684 685
	retval =
	    reiserfs_new_inode(&th, dir, mode, NULL, 0 /*i_size */ , dentry,
686
			       inode, &security);
687 688 689
	if (retval) {
		goto out_failed;
	}
Linus Torvalds's avatar
Linus Torvalds committed
690

691 692 693 694 695 696 697 698 699 700 701 702 703 704
	inode->i_op = &reiserfs_special_inode_operations;
	init_special_inode(inode, inode->i_mode, rdev);

	//FIXME: needed for block and char devices only
	reiserfs_update_sd(&th, inode);

	reiserfs_update_inode_transaction(inode);
	reiserfs_update_inode_transaction(dir);

	retval =
	    reiserfs_add_entry(&th, dir, dentry->d_name.name,
			       dentry->d_name.len, inode, 1 /*visible */ );
	if (retval) {
		int err;
705
		drop_nlink(inode);
706 707 708 709
		reiserfs_update_sd(&th, inode);
		err = journal_end(&th, dir->i_sb, jbegin_count);
		if (err)
			retval = err;
Al Viro's avatar
Al Viro committed
710
		unlock_new_inode(inode);
711 712 713
		iput(inode);
		goto out_failed;
	}
Linus Torvalds's avatar
Linus Torvalds committed
714

715
	d_instantiate(dentry, inode);
Al Viro's avatar
Al Viro committed
716
	unlock_new_inode(inode);
717
	retval = journal_end(&th, dir->i_sb, jbegin_count);
Linus Torvalds's avatar
Linus Torvalds committed
718

719 720 721
      out_failed:
	reiserfs_write_unlock(dir->i_sb);
	return retval;
Linus Torvalds's avatar
Linus Torvalds committed
722 723
}

724
static int reiserfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
Linus Torvalds's avatar
Linus Torvalds committed
725
{
726 727 728
	int retval;
	struct inode *inode;
	struct reiserfs_transaction_handle th;
729
	struct reiserfs_security_handle security;
730
	int lock_depth;
731 732 733 734 735
	/* We need blocks for transaction + (user+group)*(quotas for new inode + update of quota for directory owner) */
	int jbegin_count =
	    JOURNAL_PER_BALANCE_CNT * 3 +
	    2 * (REISERFS_QUOTA_INIT_BLOCKS(dir->i_sb) +
		 REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb));
Linus Torvalds's avatar
Linus Torvalds committed
736

737
	dquot_initialize(dir);
738

Linus Torvalds's avatar
Linus Torvalds committed
739
#ifdef DISPLACE_NEW_PACKING_LOCALITIES
740 741
	/* set flag that new packing locality created and new blocks for the content     * of that directory are not displaced yet */
	REISERFS_I(dir)->new_packing_locality = 1;
Linus Torvalds's avatar
Linus Torvalds committed
742
#endif
743 744 745 746 747 748
	mode = S_IFDIR | mode;
	if (!(inode = new_inode(dir->i_sb))) {
		return -ENOMEM;
	}
	new_inode_init(inode, dir, mode);

749
	jbegin_count += reiserfs_cache_default_acl(dir);
750
	retval = reiserfs_security_init(dir, inode, &dentry->d_name, &security);
751 752 753 754 755
	if (retval < 0) {
		drop_new_inode(inode);
		return retval;
	}
	jbegin_count += retval;
756
	lock_depth = reiserfs_write_lock_once(dir->i_sb);
757 758 759 760 761 762

	retval = journal_begin(&th, dir->i_sb, jbegin_count);
	if (retval) {
		drop_new_inode(inode);
		goto out_failed;
	}
Linus Torvalds's avatar
Linus Torvalds committed
763

764 765 766 767 768 769 770 771
	/* inc the link count now, so another writer doesn't overflow it while
	 ** we sleep later on.
	 */
	INC_DIR_INODE_NLINK(dir)

	    retval = reiserfs_new_inode(&th, dir, mode, NULL /*symlink */ ,
					old_format_only(dir->i_sb) ?
					EMPTY_DIR_SIZE_V1 : EMPTY_DIR_SIZE,
772
					dentry, inode, &security);
773
	if (retval) {
Al Viro's avatar
Al Viro committed
774
		DEC_DIR_INODE_NLINK(dir)
775 776 777 778 779 780 781 782 783 784 785 786 787 788 789
		goto out_failed;
	}

	reiserfs_update_inode_transaction(inode);
	reiserfs_update_inode_transaction(dir);

	inode->i_op = &reiserfs_dir_inode_operations;
	inode->i_fop = &reiserfs_dir_operations;

	// note, _this_ add_entry will not update dir's stat data
	retval =
	    reiserfs_add_entry(&th, dir, dentry->d_name.name,
			       dentry->d_name.len, inode, 1 /*visible */ );
	if (retval) {
		int err;
790
		clear_nlink(inode);
791 792 793 794 795
		DEC_DIR_INODE_NLINK(dir);
		reiserfs_update_sd(&th, inode);
		err = journal_end(&th, dir->i_sb, jbegin_count);
		if (err)
			retval = err;
Al Viro's avatar
Al Viro committed
796
		unlock_new_inode(inode);
797 798 799 800 801 802 803
		iput(inode);
		goto out_failed;
	}
	// the above add_entry did not update dir's stat data
	reiserfs_update_sd(&th, dir);

	d_instantiate(dentry, inode);
Al Viro's avatar
Al Viro committed
804
	unlock_new_inode(inode);
805
	retval = journal_end(&th, dir->i_sb, jbegin_count);
806 807
out_failed:
	reiserfs_write_unlock_once(dir->i_sb, lock_depth);
808
	return retval;
Linus Torvalds's avatar
Linus Torvalds committed
809 810
}

811
static inline int reiserfs_empty_dir(struct inode *inode)
Linus Torvalds's avatar
Linus Torvalds committed
812
{
813 814
	/* we can cheat because an old format dir cannot have
	 ** EMPTY_DIR_SIZE, and a new format dir cannot have
815
	 ** EMPTY_DIR_SIZE_V1.  So, if the inode is either size,
816 817 818 819 820 821 822
	 ** regardless of disk format version, the directory is empty.
	 */
	if (inode->i_size != EMPTY_DIR_SIZE &&
	    inode->i_size != EMPTY_DIR_SIZE_V1) {
		return 0;
	}
	return 1;
Linus Torvalds's avatar
Linus Torvalds committed
823 824
}

825
static int reiserfs_rmdir(struct inode *dir, struct dentry *dentry)
Linus Torvalds's avatar
Linus Torvalds committed
826
{
827 828 829 830 831 832 833 834 835 836 837 838 839 840 841
	int retval, err;
	struct inode *inode;
	struct reiserfs_transaction_handle th;
	int jbegin_count;
	INITIALIZE_PATH(path);
	struct reiserfs_dir_entry de;

	/* we will be doing 2 balancings and update 2 stat data, we change quotas
	 * of the owner of the directory and of the owner of the parent directory.
	 * The quota structure is possibly deleted only on last iput => outside
	 * of this transaction */
	jbegin_count =
	    JOURNAL_PER_BALANCE_CNT * 2 + 2 +
	    4 * REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb);

842
	dquot_initialize(dir);
843

844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882
	reiserfs_write_lock(dir->i_sb);
	retval = journal_begin(&th, dir->i_sb, jbegin_count);
	if (retval)
		goto out_rmdir;

	de.de_gen_number_bit_string = NULL;
	if ((retval =
	     reiserfs_find_entry(dir, dentry->d_name.name, dentry->d_name.len,
				 &path, &de)) == NAME_NOT_FOUND) {
		retval = -ENOENT;
		goto end_rmdir;
	} else if (retval == IO_ERROR) {
		retval = -EIO;
		goto end_rmdir;
	}

	inode = dentry->d_inode;

	reiserfs_update_inode_transaction(inode);
	reiserfs_update_inode_transaction(dir);

	if (de.de_objectid != inode->i_ino) {
		// FIXME: compare key of an object and a key found in the
		// entry
		retval = -EIO;
		goto end_rmdir;
	}
	if (!reiserfs_empty_dir(inode)) {
		retval = -ENOTEMPTY;
		goto end_rmdir;
	}

	/* cut entry from dir directory */
	retval = reiserfs_cut_from_item(&th, &path, &(de.de_entry_key), dir, NULL,	/* page */
					0 /*new file size - not used here */ );
	if (retval < 0)
		goto end_rmdir;

	if (inode->i_nlink != 2 && inode->i_nlink != 1)
883 884 885
		reiserfs_error(inode->i_sb, "reiserfs-7040",
			       "empty directory has nlink != 2 (%d)",
			       inode->i_nlink);
886

887
	clear_nlink(inode);
888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911
	inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME_SEC;
	reiserfs_update_sd(&th, inode);

	DEC_DIR_INODE_NLINK(dir)
	    dir->i_size -= (DEH_SIZE + de.de_entrylen);
	reiserfs_update_sd(&th, dir);

	/* prevent empty directory from getting lost */
	add_save_link(&th, inode, 0 /* not truncate */ );

	retval = journal_end(&th, dir->i_sb, jbegin_count);
	reiserfs_check_path(&path);
      out_rmdir:
	reiserfs_write_unlock(dir->i_sb);
	return retval;

      end_rmdir:
	/* we must release path, because we did not call
	   reiserfs_cut_from_item, or reiserfs_cut_from_item does not
	   release path if operation was not complete */
	pathrelse(&path);
	err = journal_end(&th, dir->i_sb, jbegin_count);
	reiserfs_write_unlock(dir->i_sb);
	return err ? err : retval;
Linus Torvalds's avatar
Linus Torvalds committed
912 913
}

914
static int reiserfs_unlink(struct inode *dir, struct dentry *dentry)
Linus Torvalds's avatar
Linus Torvalds committed
915
{
916 917 918 919 920 921 922
	int retval, err;
	struct inode *inode;
	struct reiserfs_dir_entry de;
	INITIALIZE_PATH(path);
	struct reiserfs_transaction_handle th;
	int jbegin_count;
	unsigned long savelink;
923
	int depth;
924

925
	dquot_initialize(dir);
926

927 928 929 930 931 932 933 934 935 936
	inode = dentry->d_inode;

	/* in this transaction we can be doing at max two balancings and update
	 * two stat datas, we change quotas of the owner of the directory and of
	 * the owner of the parent directory. The quota structure is possibly
	 * deleted only on iput => outside of this transaction */
	jbegin_count =
	    JOURNAL_PER_BALANCE_CNT * 2 + 2 +
	    4 * REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb);

937
	depth = reiserfs_write_lock_once(dir->i_sb);
938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963
	retval = journal_begin(&th, dir->i_sb, jbegin_count);
	if (retval)
		goto out_unlink;

	de.de_gen_number_bit_string = NULL;
	if ((retval =
	     reiserfs_find_entry(dir, dentry->d_name.name, dentry->d_name.len,
				 &path, &de)) == NAME_NOT_FOUND) {
		retval = -ENOENT;
		goto end_unlink;
	} else if (retval == IO_ERROR) {
		retval = -EIO;
		goto end_unlink;
	}

	reiserfs_update_inode_transaction(inode);
	reiserfs_update_inode_transaction(dir);

	if (de.de_objectid != inode->i_ino) {
		// FIXME: compare key of an object and a key found in the
		// entry
		retval = -EIO;
		goto end_unlink;
	}

	if (!inode->i_nlink) {
964 965 966
		reiserfs_warning(inode->i_sb, "reiserfs-7042",
				 "deleting nonexistent file (%lu), %d",
				 inode->i_ino, inode->i_nlink);
967
		set_nlink(inode, 1);
968 969
	}

970
	drop_nlink(inode);
971 972 973 974 975 976 977 978 979 980 981

	/*
	 * we schedule before doing the add_save_link call, save the link
	 * count so we don't race
	 */
	savelink = inode->i_nlink;

	retval =
	    reiserfs_cut_from_item(&th, &path, &(de.de_entry_key), dir, NULL,
				   0);
	if (retval < 0) {
982
		inc_nlink(inode);
983 984 985 986 987 988 989 990 991 992 993 994 995 996 997
		goto end_unlink;
	}
	inode->i_ctime = CURRENT_TIME_SEC;
	reiserfs_update_sd(&th, inode);

	dir->i_size -= (de.de_entrylen + DEH_SIZE);
	dir->i_ctime = dir->i_mtime = CURRENT_TIME_SEC;
	reiserfs_update_sd(&th, dir);

	if (!savelink)
		/* prevent file from getting lost */
		add_save_link(&th, inode, 0 /* not truncate */ );

	retval = journal_end(&th, dir->i_sb, jbegin_count);
	reiserfs_check_path(&path);
998
	reiserfs_write_unlock_once(dir->i_sb, depth);
999 1000 1001 1002 1003 1004
	return retval;

      end_unlink:
	pathrelse(&path);
	err = journal_end(&th, dir->i_sb, jbegin_count);
	reiserfs_check_path(&path);
Linus Torvalds's avatar
Linus Torvalds committed
1005
	if (err)
1006 1007
		retval = err;
      out_unlink:
1008
	reiserfs_write_unlock_once(dir->i_sb, depth);
1009
	return retval;
Linus Torvalds's avatar
Linus Torvalds committed
1010 1011
}

1012 1013
static int reiserfs_symlink(struct inode *parent_dir,
			    struct dentry *dentry, const char *symname)
Linus Torvalds's avatar
Linus Torvalds committed
1014
{
1015 1016 1017 1018 1019
	int retval;
	struct inode *inode;
	char *name;
	int item_len;
	struct reiserfs_transaction_handle th;
1020
	struct reiserfs_security_handle security;
1021 1022 1023 1024 1025 1026 1027
	int mode = S_IFLNK | S_IRWXUGO;
	/* We need blocks for transaction + (user+group)*(quotas for new inode + update of quota for directory owner) */
	int jbegin_count =
	    JOURNAL_PER_BALANCE_CNT * 3 +
	    2 * (REISERFS_QUOTA_INIT_BLOCKS(parent_dir->i_sb) +
		 REISERFS_QUOTA_TRANS_BLOCKS(parent_dir->i_sb));

1028
	dquot_initialize(parent_dir);
1029

1030 1031 1032 1033 1034
	if (!(inode = new_inode(parent_dir->i_sb))) {
		return -ENOMEM;
	}
	new_inode_init(inode, parent_dir, mode);

1035 1036
	retval = reiserfs_security_init(parent_dir, inode, &dentry->d_name,
					&security);
1037 1038 1039 1040 1041 1042
	if (retval < 0) {
		drop_new_inode(inode);
		return retval;
	}
	jbegin_count += retval;

1043 1044 1045 1046 1047 1048 1049 1050
	reiserfs_write_lock(parent_dir->i_sb);
	item_len = ROUND_UP(strlen(symname));
	if (item_len > MAX_DIRECT_ITEM_LEN(parent_dir->i_sb->s_blocksize)) {
		retval = -ENAMETOOLONG;
		drop_new_inode(inode);
		goto out_failed;
	}

1051
	name = kmalloc(item_len, GFP_NOFS);
1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062
	if (!name) {
		drop_new_inode(inode);
		retval = -ENOMEM;
		goto out_failed;
	}
	memcpy(name, symname, strlen(symname));
	padd_item(name, item_len, strlen(symname));

	retval = journal_begin(&th, parent_dir->i_sb, jbegin_count);
	if (retval) {
		drop_new_inode(inode);
1063
		kfree(name);
1064 1065 1066 1067 1068
		goto out_failed;
	}

	retval =
	    reiserfs_new_inode(&th, parent_dir, mode, name, strlen(symname),
1069
			       dentry, inode, &security);
1070
	kfree(name);
1071 1072 1073
	if (retval) {		/* reiserfs_new_inode iputs for us */
		goto out_failed;
	}
Linus Torvalds's avatar
Linus Torvalds committed
1074

1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088
	reiserfs_update_inode_transaction(inode);
	reiserfs_update_inode_transaction(parent_dir);

	inode->i_op = &reiserfs_symlink_inode_operations;
	inode->i_mapping->a_ops = &reiserfs_address_space_operations;

	// must be sure this inode is written with this transaction
	//
	//reiserfs_update_sd (&th, inode, READ_BLOCKS);

	retval = reiserfs_add_entry(&th, parent_dir, dentry->d_name.name,
				    dentry->d_name.len, inode, 1 /*visible */ );
	if (retval) {
		int err;
1089
		drop_nlink(inode);
1090 1091 1092 1093
		reiserfs_update_sd(&th, inode);
		err = journal_end(&th, parent_dir->i_sb, jbegin_count);
		if (err)
			retval = err;
Al Viro's avatar
Al Viro committed
1094
		unlock_new_inode(inode);
1095 1096 1097
		iput(inode);
		goto out_failed;
	}
Linus Torvalds's avatar
Linus Torvalds committed
1098

1099
	d_instantiate(dentry, inode);
Al Viro's avatar
Al Viro committed
1100
	unlock_new_inode(inode);
1101 1102 1103 1104
	retval = journal_end(&th, parent_dir->i_sb, jbegin_count);
      out_failed:
	reiserfs_write_unlock(parent_dir->i_sb);
	return retval;
Linus Torvalds's avatar
Linus Torvalds committed
1105 1106
}

1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117
static int reiserfs_link(struct dentry *old_dentry, struct inode *dir,
			 struct dentry *dentry)
{
	int retval;
	struct inode *inode = old_dentry->d_inode;
	struct reiserfs_transaction_handle th;
	/* We need blocks for transaction + update of quotas for the owners of the directory */
	int jbegin_count =
	    JOURNAL_PER_BALANCE_CNT * 3 +
	    2 * REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb);

1118
	dquot_initialize(dir);
1119

1120 1121 1122 1123 1124 1125 1126 1127
	reiserfs_write_lock(dir->i_sb);
	if (inode->i_nlink >= REISERFS_LINK_MAX) {
		//FIXME: sd_nlink is 32 bit for new files
		reiserfs_write_unlock(dir->i_sb);
		return -EMLINK;
	}

	/* inc before scheduling so reiserfs_unlink knows we are here */
1128
	inc_nlink(inode);
1129 1130 1131

	retval = journal_begin(&th, dir->i_sb, jbegin_count);
	if (retval) {
1132
		drop_nlink(inode);
1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146
		reiserfs_write_unlock(dir->i_sb);
		return retval;
	}

	/* create new entry */
	retval =
	    reiserfs_add_entry(&th, dir, dentry->d_name.name,
			       dentry->d_name.len, inode, 1 /*visible */ );

	reiserfs_update_inode_transaction(inode);
	reiserfs_update_inode_transaction(dir);

	if (retval) {
		int err;
1147
		drop_nlink(inode);
1148 1149 1150 1151 1152 1153 1154 1155
		err = journal_end(&th, dir->i_sb, jbegin_count);
		reiserfs_write_unlock(dir->i_sb);
		return err ? err : retval;
	}

	inode->i_ctime = CURRENT_TIME_SEC;
	reiserfs_update_sd(&th, inode);

Al Viro's avatar
Al Viro committed
1156
	ihold(inode);
1157 1158 1159 1160 1161
	d_instantiate(dentry, inode);
	retval = journal_end(&th, dir->i_sb, jbegin_count);
	reiserfs_write_unlock(dir->i_sb);
	return retval;
}
Linus Torvalds's avatar
Linus Torvalds committed
1162

1163
/* de contains information pointing to an entry which */
1164 1165
static int de_still_valid(const char *name, int len,
			  struct reiserfs_dir_entry *de)
Linus Torvalds's avatar
Linus Torvalds committed
1166
{
1167 1168 1169 1170 1171 1172 1173 1174
	struct reiserfs_dir_entry tmp = *de;

	// recalculate pointer to name and name length
	set_de_name_and_namelen(&tmp);
	// FIXME: could check more
	if (tmp.de_namelen != len || memcmp(name, de->de_name, len))
		return 0;
	return 1;
Linus Torvalds's avatar
Linus Torvalds committed
1175 1176
}

1177 1178 1179
static int entry_points_to_object(const char *name, int len,
				  struct reiserfs_dir_entry *de,
				  struct inode *inode)
Linus Torvalds's avatar
Linus Torvalds committed
1180
{
1181 1182 1183 1184 1185
	if (!de_still_valid(name, len, de))
		return 0;

	if (inode) {
		if (!de_visible(de->de_deh + de->de_entry_num))
1186 1187
			reiserfs_panic(inode->i_sb, "vs-7042",
				       "entry must be visible");
1188 1189
		return (de->de_objectid == inode->i_ino) ? 1 : 0;
	}
Linus Torvalds's avatar
Linus Torvalds committed
1190

1191 1192
	/* this must be added hidden entry */
	if (de_visible(de->de_deh + de->de_entry_num))
1193
		reiserfs_panic(NULL, "vs-7043", "entry must be visible");
Linus Torvalds's avatar
Linus Torvalds committed
1194

1195
	return 1;
Linus Torvalds's avatar
Linus Torvalds committed
1196 1197 1198
}

/* sets key of objectid the entry has to point to */
1199 1200
static void set_ino_in_dir_entry(struct reiserfs_dir_entry *de,
				 struct reiserfs_key *key)
Linus Torvalds's avatar
Linus Torvalds committed
1201
{
1202 1203 1204
	/* JDM These operations are endian safe - both are le */
	de->de_deh[de->de_entry_num].deh_dir_id = key->k_dir_id;
	de->de_deh[de->de_entry_num].deh_objectid = key->k_objectid;
Linus Torvalds's avatar
Linus Torvalds committed
1205 1206
}

1207
/*
Linus Torvalds's avatar
Linus Torvalds committed
1208 1209
 * process, that is going to call fix_nodes/do_balance must hold only
 * one path. If it holds 2 or more, it can get into endless waiting in
1210
 * get_empty_nodes or its clones
Linus Torvalds's avatar
Linus Torvalds committed
1211
 */
1212 1213
static int reiserfs_rename(struct inode *old_dir, struct dentry *old_dentry,
			   struct inode *new_dir, struct dentry *new_dentry)
Linus Torvalds's avatar
Linus Torvalds committed
1214
{
1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239
	int retval;
	INITIALIZE_PATH(old_entry_path);
	INITIALIZE_PATH(new_entry_path);
	INITIALIZE_PATH(dot_dot_entry_path);
	struct item_head new_entry_ih, old_entry_ih, dot_dot_ih;
	struct reiserfs_dir_entry old_de, new_de, dot_dot_de;
	struct inode *old_inode, *new_dentry_inode;
	struct reiserfs_transaction_handle th;
	int jbegin_count;
	umode_t old_inode_mode;
	unsigned long savelink = 1;
	struct timespec ctime;

	/* three balancings: (1) old name removal, (2) new name insertion
	   and (3) maybe "save" link insertion
	   stat data updates: (1) old directory,
	   (2) new directory and (3) maybe old object stat data (when it is
	   directory) and (4) maybe stat data of object to which new entry
	   pointed initially and (5) maybe block containing ".." of
	   renamed directory
	   quota updates: two parent directories */
	jbegin_count =
	    JOURNAL_PER_BALANCE_CNT * 3 + 5 +
	    4 * REISERFS_QUOTA_TRANS_BLOCKS(old_dir->i_sb);

1240 1241
	dquot_initialize(old_dir);
	dquot_initialize(new_dir);
1242

1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255
	old_inode = old_dentry->d_inode;
	new_dentry_inode = new_dentry->d_inode;

	// make sure, that oldname still exists and points to an object we
	// are going to rename
	old_de.de_gen_number_bit_string = NULL;
	reiserfs_write_lock(old_dir->i_sb);
	retval =
	    reiserfs_find_entry(old_dir, old_dentry->d_name.name,
				old_dentry->d_name.len, &old_entry_path,
				&old_de);
	pathrelse(&old_entry_path);
	if (retval == IO_ERROR) {
Linus Torvalds's avatar
Linus Torvalds committed
1256
		reiserfs_write_unlock(old_dir->i_sb);
1257
		return -EIO;
Linus Torvalds's avatar
Linus Torvalds committed
1258
	}
1259 1260 1261 1262

	if (retval != NAME_FOUND || old_de.de_objectid != old_inode->i_ino) {
		reiserfs_write_unlock(old_dir->i_sb);
		return -ENOENT;
Linus Torvalds's avatar
Linus Torvalds committed
1263 1264
	}

1265 1266
	old_inode_mode = old_inode->i_mode;
	if (S_ISDIR(old_inode_mode)) {
1267
		// make sure, that directory being renamed has correct ".."
1268 1269 1270 1271 1272 1273 1274 1275 1276 1277
		// and that its new parent directory has not too many links
		// already

		if (new_dentry_inode) {
			if (!reiserfs_empty_dir(new_dentry_inode)) {
				reiserfs_write_unlock(old_dir->i_sb);
				return -ENOTEMPTY;
			}
		}

1278 1279
		/* directory is renamed, its parent directory will be changed,
		 ** so find ".." entry
1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295
		 */
		dot_dot_de.de_gen_number_bit_string = NULL;
		retval =
		    reiserfs_find_entry(old_inode, "..", 2, &dot_dot_entry_path,
					&dot_dot_de);
		pathrelse(&dot_dot_entry_path);
		if (retval != NAME_FOUND) {
			reiserfs_write_unlock(old_dir->i_sb);
			return -EIO;
		}

		/* inode number of .. must equal old_dir->i_ino */
		if (dot_dot_de.de_objectid != old_dir->i_ino) {
			reiserfs_write_unlock(old_dir->i_sb);
			return -EIO;
		}
Linus Torvalds's avatar
Linus Torvalds committed
1296
	}
1297 1298 1299 1300 1301

	retval = journal_begin(&th, old_dir->i_sb, jbegin_count);
	if (retval) {
		reiserfs_write_unlock(old_dir->i_sb);
		return retval;
Linus Torvalds's avatar
Linus Torvalds committed
1302
	}
1303 1304 1305 1306 1307 1308 1309

	/* add new entry (or find the existing one) */
	retval =
	    reiserfs_add_entry(&th, new_dir, new_dentry->d_name.name,
			       new_dentry->d_name.len, old_inode, 0);
	if (retval == -EEXIST) {
		if (!new_dentry_inode) {
1310 1311
			reiserfs_panic(old_dir->i_sb, "vs-7050",
				       "new entry is found, new inode == 0");
1312 1313 1314 1315 1316
		}
	} else if (retval) {
		int err = journal_end(&th, old_dir->i_sb, jbegin_count);
		reiserfs_write_unlock(old_dir->i_sb);
		return err ? err : retval;
Linus Torvalds's avatar
Linus Torvalds committed
1317 1318
	}

1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388
	reiserfs_update_inode_transaction(old_dir);
	reiserfs_update_inode_transaction(new_dir);

	/* this makes it so an fsync on an open fd for the old name will
	 ** commit the rename operation
	 */
	reiserfs_update_inode_transaction(old_inode);

	if (new_dentry_inode)
		reiserfs_update_inode_transaction(new_dentry_inode);

	while (1) {
		// look for old name using corresponding entry key (found by reiserfs_find_entry)
		if ((retval =
		     search_by_entry_key(new_dir->i_sb, &old_de.de_entry_key,
					 &old_entry_path,
					 &old_de)) != NAME_FOUND) {
			pathrelse(&old_entry_path);
			journal_end(&th, old_dir->i_sb, jbegin_count);
			reiserfs_write_unlock(old_dir->i_sb);
			return -EIO;
		}

		copy_item_head(&old_entry_ih, get_ih(&old_entry_path));

		reiserfs_prepare_for_journal(old_inode->i_sb, old_de.de_bh, 1);

		// look for new name by reiserfs_find_entry
		new_de.de_gen_number_bit_string = NULL;
		retval =
		    reiserfs_find_entry(new_dir, new_dentry->d_name.name,
					new_dentry->d_name.len, &new_entry_path,
					&new_de);
		// reiserfs_add_entry should not return IO_ERROR, because it is called with essentially same parameters from
		// reiserfs_add_entry above, and we'll catch any i/o errors before we get here.
		if (retval != NAME_FOUND_INVISIBLE && retval != NAME_FOUND) {
			pathrelse(&new_entry_path);
			pathrelse(&old_entry_path);
			journal_end(&th, old_dir->i_sb, jbegin_count);
			reiserfs_write_unlock(old_dir->i_sb);
			return -EIO;
		}

		copy_item_head(&new_entry_ih, get_ih(&new_entry_path));

		reiserfs_prepare_for_journal(old_inode->i_sb, new_de.de_bh, 1);

		if (S_ISDIR(old_inode->i_mode)) {
			if ((retval =
			     search_by_entry_key(new_dir->i_sb,
						 &dot_dot_de.de_entry_key,
						 &dot_dot_entry_path,
						 &dot_dot_de)) != NAME_FOUND) {
				pathrelse(&dot_dot_entry_path);
				pathrelse(&new_entry_path);
				pathrelse(&old_entry_path);
				journal_end(&th, old_dir->i_sb, jbegin_count);
				reiserfs_write_unlock(old_dir->i_sb);
				return -EIO;
			}
			copy_item_head(&dot_dot_ih,
				       get_ih(&dot_dot_entry_path));
			// node containing ".." gets into transaction
			reiserfs_prepare_for_journal(old_inode->i_sb,
						     dot_dot_de.de_bh, 1);
		}
		/* we should check seals here, not do
		   this stuff, yes? Then, having
		   gathered everything into RAM we
		   should lock the buffers, yes?  -Hans */
1389 1390 1391
		/* probably.  our rename needs to hold more
		 ** than one path at once.  The seals would
		 ** have to be written to deal with multi-path
1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438
		 ** issues -chris
		 */
		/* sanity checking before doing the rename - avoid races many
		 ** of the above checks could have scheduled.  We have to be
		 ** sure our items haven't been shifted by another process.
		 */
		if (item_moved(&new_entry_ih, &new_entry_path) ||
		    !entry_points_to_object(new_dentry->d_name.name,
					    new_dentry->d_name.len,
					    &new_de, new_dentry_inode) ||
		    item_moved(&old_entry_ih, &old_entry_path) ||
		    !entry_points_to_object(old_dentry->d_name.name,
					    old_dentry->d_name.len,
					    &old_de, old_inode)) {
			reiserfs_restore_prepared_buffer(old_inode->i_sb,
							 new_de.de_bh);
			reiserfs_restore_prepared_buffer(old_inode->i_sb,
							 old_de.de_bh);
			if (S_ISDIR(old_inode_mode))
				reiserfs_restore_prepared_buffer(old_inode->
								 i_sb,
								 dot_dot_de.
								 de_bh);
			continue;
		}
		if (S_ISDIR(old_inode_mode)) {
			if (item_moved(&dot_dot_ih, &dot_dot_entry_path) ||
			    !entry_points_to_object("..", 2, &dot_dot_de,
						    old_dir)) {
				reiserfs_restore_prepared_buffer(old_inode->
								 i_sb,
								 old_de.de_bh);
				reiserfs_restore_prepared_buffer(old_inode->
								 i_sb,
								 new_de.de_bh);
				reiserfs_restore_prepared_buffer(old_inode->
								 i_sb,
								 dot_dot_de.
								 de_bh);
				continue;
			}
		}

		RFALSE(S_ISDIR(old_inode_mode) &&
		       !buffer_journal_prepared(dot_dot_de.de_bh), "");

		break;
Linus Torvalds's avatar
Linus Torvalds committed
1439 1440
	}

1441 1442
	/* ok, all the changes can be done in one fell swoop when we
	   have claimed all the buffers needed. */
Linus Torvalds's avatar
Linus Torvalds committed
1443

1444 1445 1446
	mark_de_visible(new_de.de_deh + new_de.de_entry_num);
	set_ino_in_dir_entry(&new_de, INODE_PKEY(old_inode));
	journal_mark_dirty(&th, old_dir->i_sb, new_de.de_bh);
Linus Torvalds's avatar
Linus Torvalds committed
1447

1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459
	mark_de_hidden(old_de.de_deh + old_de.de_entry_num);
	journal_mark_dirty(&th, old_dir->i_sb, old_de.de_bh);
	ctime = CURRENT_TIME_SEC;
	old_dir->i_ctime = old_dir->i_mtime = ctime;
	new_dir->i_ctime = new_dir->i_mtime = ctime;
	/* thanks to Alex Adriaanse <alex_a@caltech.edu> for patch which adds ctime update of
	   renamed object */
	old_inode->i_ctime = ctime;

	if (new_dentry_inode) {
		// adjust link number of the victim
		if (S_ISDIR(new_dentry_inode->i_mode)) {
1460
			clear_nlink(new_dentry_inode);
1461
		} else {
1462
			drop_nlink(new_dentry_inode);
1463 1464 1465
		}
		new_dentry_inode->i_ctime = ctime;
		savelink = new_dentry_inode->i_nlink;
Linus Torvalds's avatar
Linus Torvalds committed
1466
	}
1467

Linus Torvalds's avatar
Linus Torvalds committed
1468
	if (S_ISDIR(old_inode_mode)) {
1469
		/* adjust ".." of renamed directory */
1470 1471 1472 1473 1474 1475 1476 1477 1478 1479
		set_ino_in_dir_entry(&dot_dot_de, INODE_PKEY(new_dir));
		journal_mark_dirty(&th, new_dir->i_sb, dot_dot_de.de_bh);

		if (!new_dentry_inode)
			/* there (in new_dir) was no directory, so it got new link
			   (".."  of renamed directory) */
			INC_DIR_INODE_NLINK(new_dir);

		/* old directory lost one link - ".. " of renamed directory */
		DEC_DIR_INODE_NLINK(old_dir);
Linus Torvalds's avatar
Linus Torvalds committed
1480
	}
1481 1482 1483
	// looks like in 2.3.99pre3 brelse is atomic. so we can use pathrelse
	pathrelse(&new_entry_path);
	pathrelse(&dot_dot_entry_path);
Linus Torvalds's avatar
Linus Torvalds committed
1484

1485 1486 1487 1488 1489 1490
	// FIXME: this reiserfs_cut_from_item's return value may screw up
	// anybody, but it will panic if will not be able to find the
	// entry. This needs one more clean up
	if (reiserfs_cut_from_item
	    (&th, &old_entry_path, &(old_de.de_entry_key), old_dir, NULL,
	     0) < 0)
1491 1492
		reiserfs_error(old_dir->i_sb, "vs-7060",
			       "couldn't not cut old name. Fsck later?");
1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504

	old_dir->i_size -= DEH_SIZE + old_de.de_entrylen;

	reiserfs_update_sd(&th, old_dir);
	reiserfs_update_sd(&th, new_dir);
	reiserfs_update_sd(&th, old_inode);

	if (new_dentry_inode) {
		if (savelink == 0)
			add_save_link(&th, new_dentry_inode,
				      0 /* not truncate */ );
		reiserfs_update_sd(&th, new_dentry_inode);
Linus Torvalds's avatar
Linus Torvalds committed
1505
	}
1506 1507 1508 1509

	retval = journal_end(&th, old_dir->i_sb, jbegin_count);
	reiserfs_write_unlock(old_dir->i_sb);
	return retval;
Linus Torvalds's avatar
Linus Torvalds committed
1510 1511 1512 1513 1514
}

/*
 * directories can handle most operations...
 */
1515
const struct inode_operations reiserfs_dir_inode_operations = {
1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531
	//&reiserfs_dir_operations,   /* default_file_ops */
	.create = reiserfs_create,
	.lookup = reiserfs_lookup,
	.link = reiserfs_link,
	.unlink = reiserfs_unlink,
	.symlink = reiserfs_symlink,
	.mkdir = reiserfs_mkdir,
	.rmdir = reiserfs_rmdir,
	.mknod = reiserfs_mknod,
	.rename = reiserfs_rename,
	.setattr = reiserfs_setattr,
	.setxattr = reiserfs_setxattr,
	.getxattr = reiserfs_getxattr,
	.listxattr = reiserfs_listxattr,
	.removexattr = reiserfs_removexattr,
	.permission = reiserfs_permission,
1532
	.get_acl = reiserfs_get_acl,
Linus Torvalds's avatar
Linus Torvalds committed
1533 1534 1535 1536 1537 1538
};

/*
 * symlink operations.. same as page_symlink_inode_operations, with xattr
 * stuff added
 */
1539
const struct inode_operations reiserfs_symlink_inode_operations = {
1540 1541 1542 1543 1544 1545 1546 1547 1548
	.readlink = generic_readlink,
	.follow_link = page_follow_link_light,
	.put_link = page_put_link,
	.setattr = reiserfs_setattr,
	.setxattr = reiserfs_setxattr,
	.getxattr = reiserfs_getxattr,
	.listxattr = reiserfs_listxattr,
	.removexattr = reiserfs_removexattr,
	.permission = reiserfs_permission,
1549
	.get_acl = reiserfs_get_acl,
Linus Torvalds's avatar
Linus Torvalds committed
1550 1551 1552 1553 1554 1555

};

/*
 * special file operations.. just xattr/acl stuff
 */
1556
const struct inode_operations reiserfs_special_inode_operations = {
1557 1558 1559 1560 1561