xref: /openbmc/linux/fs/reiserfs/namei.c (revision 6dfcd296)
1 /*
2  * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README
3  *
4  * Trivial changes by Alan Cox to remove EHASHCOLLISION for compatibility
5  *
6  * Trivial Changes:
7  * Rights granted to Hans Reiser to redistribute under other terms providing
8  * he accepts all liability including but not limited to patent, fitness
9  * for purpose, and direct or indirect claims arising from failure to perform.
10  *
11  * NO WARRANTY
12  */
13 
14 #include <linux/time.h>
15 #include <linux/bitops.h>
16 #include <linux/slab.h>
17 #include "reiserfs.h"
18 #include "acl.h"
19 #include "xattr.h"
20 #include <linux/quotaops.h>
21 
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);
24 
25 /*
26  * directory item contains array of entry headers. This performs
27  * binary search through that array
28  */
29 static int bin_search_in_dir_item(struct reiserfs_dir_entry *de, loff_t off)
30 {
31 	struct item_head *ih = de->de_ih;
32 	struct reiserfs_de_head *deh = de->de_deh;
33 	int rbound, lbound, j;
34 
35 	lbound = 0;
36 	rbound = ih_entry_count(ih) - 1;
37 
38 	for (j = (rbound + lbound) / 2; lbound <= rbound;
39 	     j = (rbound + lbound) / 2) {
40 		if (off < deh_offset(deh + j)) {
41 			rbound = j - 1;
42 			continue;
43 		}
44 		if (off > deh_offset(deh + j)) {
45 			lbound = j + 1;
46 			continue;
47 		}
48 		/* this is not name found, but matched third key component */
49 		de->de_entry_num = j;
50 		return NAME_FOUND;
51 	}
52 
53 	de->de_entry_num = lbound;
54 	return NAME_NOT_FOUND;
55 }
56 
57 /*
58  * comment?  maybe something like set de to point to what the path points to?
59  */
60 static inline void set_de_item_location(struct reiserfs_dir_entry *de,
61 					struct treepath *path)
62 {
63 	de->de_bh = get_last_bh(path);
64 	de->de_ih = tp_item_head(path);
65 	de->de_deh = B_I_DEH(de->de_bh, de->de_ih);
66 	de->de_item_num = PATH_LAST_POSITION(path);
67 }
68 
69 /*
70  * de_bh, de_ih, de_deh (points to first element of array), de_item_num is set
71  */
72 inline void set_de_name_and_namelen(struct reiserfs_dir_entry *de)
73 {
74 	struct reiserfs_de_head *deh = de->de_deh + de->de_entry_num;
75 
76 	BUG_ON(de->de_entry_num >= ih_entry_count(de->de_ih));
77 
78 	de->de_entrylen = entry_length(de->de_bh, de->de_ih, de->de_entry_num);
79 	de->de_namelen = de->de_entrylen - (de_with_sd(deh) ? SD_SIZE : 0);
80 	de->de_name = ih_item_body(de->de_bh, de->de_ih) + deh_location(deh);
81 	if (de->de_name[de->de_namelen - 1] == 0)
82 		de->de_namelen = strlen(de->de_name);
83 }
84 
85 /* what entry points to */
86 static inline void set_de_object_key(struct reiserfs_dir_entry *de)
87 {
88 	BUG_ON(de->de_entry_num >= ih_entry_count(de->de_ih));
89 	de->de_dir_id = deh_dir_id(&de->de_deh[de->de_entry_num]);
90 	de->de_objectid = deh_objectid(&de->de_deh[de->de_entry_num]);
91 }
92 
93 static inline void store_de_entry_key(struct reiserfs_dir_entry *de)
94 {
95 	struct reiserfs_de_head *deh = de->de_deh + de->de_entry_num;
96 
97 	BUG_ON(de->de_entry_num >= ih_entry_count(de->de_ih));
98 
99 	/* store key of the found entry */
100 	de->de_entry_key.version = KEY_FORMAT_3_5;
101 	de->de_entry_key.on_disk_key.k_dir_id =
102 	    le32_to_cpu(de->de_ih->ih_key.k_dir_id);
103 	de->de_entry_key.on_disk_key.k_objectid =
104 	    le32_to_cpu(de->de_ih->ih_key.k_objectid);
105 	set_cpu_key_k_offset(&de->de_entry_key, deh_offset(deh));
106 	set_cpu_key_k_type(&de->de_entry_key, TYPE_DIRENTRY);
107 }
108 
109 /*
110  * We assign a key to each directory item, and place multiple entries in a
111  * single directory item.  A directory item has a key equal to the key of
112  * the first directory entry in it.
113 
114  * This function first calls search_by_key, then, if item whose first entry
115  * matches is not found it looks for the entry inside directory item found
116  * by search_by_key. Fills the path to the entry, and to the entry position
117  * in the item
118  */
119 /* The function is NOT SCHEDULE-SAFE! */
120 int search_by_entry_key(struct super_block *sb, const struct cpu_key *key,
121 			struct treepath *path, struct reiserfs_dir_entry *de)
122 {
123 	int retval;
124 
125 	retval = search_item(sb, key, path);
126 	switch (retval) {
127 	case ITEM_NOT_FOUND:
128 		if (!PATH_LAST_POSITION(path)) {
129 			reiserfs_error(sb, "vs-7000", "search_by_key "
130 				       "returned item position == 0");
131 			pathrelse(path);
132 			return IO_ERROR;
133 		}
134 		PATH_LAST_POSITION(path)--;
135 
136 	case ITEM_FOUND:
137 		break;
138 
139 	case IO_ERROR:
140 		return retval;
141 
142 	default:
143 		pathrelse(path);
144 		reiserfs_error(sb, "vs-7002", "no path to here");
145 		return IO_ERROR;
146 	}
147 
148 	set_de_item_location(de, path);
149 
150 #ifdef CONFIG_REISERFS_CHECK
151 	if (!is_direntry_le_ih(de->de_ih) ||
152 	    COMP_SHORT_KEYS(&de->de_ih->ih_key, key)) {
153 		print_block(de->de_bh, 0, -1, -1);
154 		reiserfs_panic(sb, "vs-7005", "found item %h is not directory "
155 			       "item or does not belong to the same directory "
156 			       "as key %K", de->de_ih, key);
157 	}
158 #endif				/* CONFIG_REISERFS_CHECK */
159 
160 	/*
161 	 * binary search in directory item by third component of the
162 	 * key. sets de->de_entry_num of de
163 	 */
164 	retval = bin_search_in_dir_item(de, cpu_key_k_offset(key));
165 	path->pos_in_item = de->de_entry_num;
166 	if (retval != NAME_NOT_FOUND) {
167 		/*
168 		 * ugly, but rename needs de_bh, de_deh, de_name,
169 		 * de_namelen, de_objectid set
170 		 */
171 		set_de_name_and_namelen(de);
172 		set_de_object_key(de);
173 	}
174 	return retval;
175 }
176 
177 /* Keyed 32-bit hash function using TEA in a Davis-Meyer function */
178 
179 /*
180  * The third component is hashed, and you can choose from more than
181  * one hash function.  Per directory hashes are not yet implemented
182  * but are thought about. This function should be moved to hashes.c
183  * Jedi, please do so.  -Hans
184  */
185 static __u32 get_third_component(struct super_block *s,
186 				 const char *name, int len)
187 {
188 	__u32 res;
189 
190 	if (!len || (len == 1 && name[0] == '.'))
191 		return DOT_OFFSET;
192 	if (len == 2 && name[0] == '.' && name[1] == '.')
193 		return DOT_DOT_OFFSET;
194 
195 	res = REISERFS_SB(s)->s_hash_function(name, len);
196 
197 	/* take bits from 7-th to 30-th including both bounds */
198 	res = GET_HASH_VALUE(res);
199 	if (res == 0)
200 		/*
201 		 * needed to have no names before "." and ".." those have hash
202 		 * value == 0 and generation conters 1 and 2 accordingly
203 		 */
204 		res = 128;
205 	return res + MAX_GENERATION_NUMBER;
206 }
207 
208 static int reiserfs_match(struct reiserfs_dir_entry *de,
209 			  const char *name, int namelen)
210 {
211 	int retval = NAME_NOT_FOUND;
212 
213 	if ((namelen == de->de_namelen) &&
214 	    !memcmp(de->de_name, name, de->de_namelen))
215 		retval =
216 		    (de_visible(de->de_deh + de->de_entry_num) ? NAME_FOUND :
217 		     NAME_FOUND_INVISIBLE);
218 
219 	return retval;
220 }
221 
222 /* de's de_bh, de_ih, de_deh, de_item_num, de_entry_num are set already */
223 
224 /* used when hash collisions exist */
225 
226 static int linear_search_in_dir_item(struct cpu_key *key,
227 				     struct reiserfs_dir_entry *de,
228 				     const char *name, int namelen)
229 {
230 	struct reiserfs_de_head *deh = de->de_deh;
231 	int retval;
232 	int i;
233 
234 	i = de->de_entry_num;
235 
236 	if (i == ih_entry_count(de->de_ih) ||
237 	    GET_HASH_VALUE(deh_offset(deh + i)) !=
238 	    GET_HASH_VALUE(cpu_key_k_offset(key))) {
239 		i--;
240 	}
241 
242 	RFALSE(de->de_deh != B_I_DEH(de->de_bh, de->de_ih),
243 	       "vs-7010: array of entry headers not found");
244 
245 	deh += i;
246 
247 	for (; i >= 0; i--, deh--) {
248 		/* hash value does not match, no need to check whole name */
249 		if (GET_HASH_VALUE(deh_offset(deh)) !=
250 		    GET_HASH_VALUE(cpu_key_k_offset(key))) {
251 			return NAME_NOT_FOUND;
252 		}
253 
254 		/* mark that this generation number is used */
255 		if (de->de_gen_number_bit_string)
256 			set_bit(GET_GENERATION_NUMBER(deh_offset(deh)),
257 				de->de_gen_number_bit_string);
258 
259 		/* calculate pointer to name and namelen */
260 		de->de_entry_num = i;
261 		set_de_name_and_namelen(de);
262 
263 		/*
264 		 * de's de_name, de_namelen, de_recordlen are set.
265 		 * Fill the rest.
266 		 */
267 		if ((retval =
268 		     reiserfs_match(de, name, namelen)) != NAME_NOT_FOUND) {
269 
270 			/* key of pointed object */
271 			set_de_object_key(de);
272 
273 			store_de_entry_key(de);
274 
275 			/* retval can be NAME_FOUND or NAME_FOUND_INVISIBLE */
276 			return retval;
277 		}
278 	}
279 
280 	if (GET_GENERATION_NUMBER(le_ih_k_offset(de->de_ih)) == 0)
281 		/*
282 		 * we have reached left most entry in the node. In common we
283 		 * have to go to the left neighbor, but if generation counter
284 		 * is 0 already, we know for sure, that there is no name with
285 		 * the same hash value
286 		 */
287 		/*
288 		 * FIXME: this work correctly only because hash value can not
289 		 *  be 0. Btw, in case of Yura's hash it is probably possible,
290 		 * so, this is a bug
291 		 */
292 		return NAME_NOT_FOUND;
293 
294 	RFALSE(de->de_item_num,
295 	       "vs-7015: two diritems of the same directory in one node?");
296 
297 	return GOTO_PREVIOUS_ITEM;
298 }
299 
300 /*
301  * may return NAME_FOUND, NAME_FOUND_INVISIBLE, NAME_NOT_FOUND
302  * FIXME: should add something like IOERROR
303  */
304 static int reiserfs_find_entry(struct inode *dir, const char *name, int namelen,
305 			       struct treepath *path_to_entry,
306 			       struct reiserfs_dir_entry *de)
307 {
308 	struct cpu_key key_to_search;
309 	int retval;
310 
311 	if (namelen > REISERFS_MAX_NAME(dir->i_sb->s_blocksize))
312 		return NAME_NOT_FOUND;
313 
314 	/* we will search for this key in the tree */
315 	make_cpu_key(&key_to_search, dir,
316 		     get_third_component(dir->i_sb, name, namelen),
317 		     TYPE_DIRENTRY, 3);
318 
319 	while (1) {
320 		retval =
321 		    search_by_entry_key(dir->i_sb, &key_to_search,
322 					path_to_entry, de);
323 		if (retval == IO_ERROR) {
324 			reiserfs_error(dir->i_sb, "zam-7001", "io error");
325 			return IO_ERROR;
326 		}
327 
328 		/* compare names for all entries having given hash value */
329 		retval =
330 		    linear_search_in_dir_item(&key_to_search, de, name,
331 					      namelen);
332 		/*
333 		 * there is no need to scan directory anymore.
334 		 * Given entry found or does not exist
335 		 */
336 		if (retval != GOTO_PREVIOUS_ITEM) {
337 			path_to_entry->pos_in_item = de->de_entry_num;
338 			return retval;
339 		}
340 
341 		/*
342 		 * there is left neighboring item of this directory
343 		 * and given entry can be there
344 		 */
345 		set_cpu_key_k_offset(&key_to_search,
346 				     le_ih_k_offset(de->de_ih) - 1);
347 		pathrelse(path_to_entry);
348 
349 	}			/* while (1) */
350 }
351 
352 static struct dentry *reiserfs_lookup(struct inode *dir, struct dentry *dentry,
353 				      unsigned int flags)
354 {
355 	int retval;
356 	struct inode *inode = NULL;
357 	struct reiserfs_dir_entry de;
358 	INITIALIZE_PATH(path_to_entry);
359 
360 	if (REISERFS_MAX_NAME(dir->i_sb->s_blocksize) < dentry->d_name.len)
361 		return ERR_PTR(-ENAMETOOLONG);
362 
363 	reiserfs_write_lock(dir->i_sb);
364 
365 	de.de_gen_number_bit_string = NULL;
366 	retval =
367 	    reiserfs_find_entry(dir, dentry->d_name.name, dentry->d_name.len,
368 				&path_to_entry, &de);
369 	pathrelse(&path_to_entry);
370 	if (retval == NAME_FOUND) {
371 		inode = reiserfs_iget(dir->i_sb,
372 				      (struct cpu_key *)&de.de_dir_id);
373 		if (!inode || IS_ERR(inode)) {
374 			reiserfs_write_unlock(dir->i_sb);
375 			return ERR_PTR(-EACCES);
376 		}
377 
378 		/*
379 		 * Propagate the private flag so we know we're
380 		 * in the priv tree
381 		 */
382 		if (IS_PRIVATE(dir))
383 			inode->i_flags |= S_PRIVATE;
384 	}
385 	reiserfs_write_unlock(dir->i_sb);
386 	if (retval == IO_ERROR) {
387 		return ERR_PTR(-EIO);
388 	}
389 
390 	return d_splice_alias(inode, dentry);
391 }
392 
393 /*
394  * looks up the dentry of the parent directory for child.
395  * taken from ext2_get_parent
396  */
397 struct dentry *reiserfs_get_parent(struct dentry *child)
398 {
399 	int retval;
400 	struct inode *inode = NULL;
401 	struct reiserfs_dir_entry de;
402 	INITIALIZE_PATH(path_to_entry);
403 	struct inode *dir = d_inode(child);
404 
405 	if (dir->i_nlink == 0) {
406 		return ERR_PTR(-ENOENT);
407 	}
408 	de.de_gen_number_bit_string = NULL;
409 
410 	reiserfs_write_lock(dir->i_sb);
411 	retval = reiserfs_find_entry(dir, "..", 2, &path_to_entry, &de);
412 	pathrelse(&path_to_entry);
413 	if (retval != NAME_FOUND) {
414 		reiserfs_write_unlock(dir->i_sb);
415 		return ERR_PTR(-ENOENT);
416 	}
417 	inode = reiserfs_iget(dir->i_sb, (struct cpu_key *)&de.de_dir_id);
418 	reiserfs_write_unlock(dir->i_sb);
419 
420 	return d_obtain_alias(inode);
421 }
422 
423 /* add entry to the directory (entry can be hidden).
424 
425 insert definition of when hidden directories are used here -Hans
426 
427  Does not mark dir   inode dirty, do it after successesfull call to it */
428 
429 static int reiserfs_add_entry(struct reiserfs_transaction_handle *th,
430 			      struct inode *dir, const char *name, int namelen,
431 			      struct inode *inode, int visible)
432 {
433 	struct cpu_key entry_key;
434 	struct reiserfs_de_head *deh;
435 	INITIALIZE_PATH(path);
436 	struct reiserfs_dir_entry de;
437 	DECLARE_BITMAP(bit_string, MAX_GENERATION_NUMBER + 1);
438 	int gen_number;
439 
440 	/*
441 	 * 48 bytes now and we avoid kmalloc if we
442 	 * create file with short name
443 	 */
444 	char small_buf[32 + DEH_SIZE];
445 
446 	char *buffer;
447 	int buflen, paste_size;
448 	int retval;
449 
450 	BUG_ON(!th->t_trans_id);
451 
452 	/* cannot allow items to be added into a busy deleted directory */
453 	if (!namelen)
454 		return -EINVAL;
455 
456 	if (namelen > REISERFS_MAX_NAME(dir->i_sb->s_blocksize))
457 		return -ENAMETOOLONG;
458 
459 	/* each entry has unique key. compose it */
460 	make_cpu_key(&entry_key, dir,
461 		     get_third_component(dir->i_sb, name, namelen),
462 		     TYPE_DIRENTRY, 3);
463 
464 	/* get memory for composing the entry */
465 	buflen = DEH_SIZE + ROUND_UP(namelen);
466 	if (buflen > sizeof(small_buf)) {
467 		buffer = kmalloc(buflen, GFP_NOFS);
468 		if (!buffer)
469 			return -ENOMEM;
470 	} else
471 		buffer = small_buf;
472 
473 	paste_size =
474 	    (get_inode_sd_version(dir) ==
475 	     STAT_DATA_V1) ? (DEH_SIZE + namelen) : buflen;
476 
477 	/*
478 	 * fill buffer : directory entry head, name[, dir objectid | ,
479 	 * stat data | ,stat data, dir objectid ]
480 	 */
481 	deh = (struct reiserfs_de_head *)buffer;
482 	deh->deh_location = 0;	/* JDM Endian safe if 0 */
483 	put_deh_offset(deh, cpu_key_k_offset(&entry_key));
484 	deh->deh_state = 0;	/* JDM Endian safe if 0 */
485 	/* put key (ino analog) to de */
486 
487 	/* safe: k_dir_id is le */
488 	deh->deh_dir_id = INODE_PKEY(inode)->k_dir_id;
489 	/* safe: k_objectid is le */
490 	deh->deh_objectid = INODE_PKEY(inode)->k_objectid;
491 
492 	/* copy name */
493 	memcpy((char *)(deh + 1), name, namelen);
494 	/* padd by 0s to the 4 byte boundary */
495 	padd_item((char *)(deh + 1), ROUND_UP(namelen), namelen);
496 
497 	/*
498 	 * entry is ready to be pasted into tree, set 'visibility'
499 	 * and 'stat data in entry' attributes
500 	 */
501 	mark_de_without_sd(deh);
502 	visible ? mark_de_visible(deh) : mark_de_hidden(deh);
503 
504 	/* find the proper place for the new entry */
505 	memset(bit_string, 0, sizeof(bit_string));
506 	de.de_gen_number_bit_string = bit_string;
507 	retval = reiserfs_find_entry(dir, name, namelen, &path, &de);
508 	if (retval != NAME_NOT_FOUND) {
509 		if (buffer != small_buf)
510 			kfree(buffer);
511 		pathrelse(&path);
512 
513 		if (retval == IO_ERROR) {
514 			return -EIO;
515 		}
516 
517 		if (retval != NAME_FOUND) {
518 			reiserfs_error(dir->i_sb, "zam-7002",
519 				       "reiserfs_find_entry() returned "
520 				       "unexpected value (%d)", retval);
521 		}
522 
523 		return -EEXIST;
524 	}
525 
526 	gen_number =
527 	    find_first_zero_bit(bit_string,
528 				MAX_GENERATION_NUMBER + 1);
529 	if (gen_number > MAX_GENERATION_NUMBER) {
530 		/* there is no free generation number */
531 		reiserfs_warning(dir->i_sb, "reiserfs-7010",
532 				 "Congratulations! we have got hash function "
533 				 "screwed up");
534 		if (buffer != small_buf)
535 			kfree(buffer);
536 		pathrelse(&path);
537 		return -EBUSY;
538 	}
539 	/* adjust offset of directory enrty */
540 	put_deh_offset(deh, SET_GENERATION_NUMBER(deh_offset(deh), gen_number));
541 	set_cpu_key_k_offset(&entry_key, deh_offset(deh));
542 
543 	/* update max-hash-collisions counter in reiserfs_sb_info */
544 	PROC_INFO_MAX(th->t_super, max_hash_collisions, gen_number);
545 
546 	/* we need to re-search for the insertion point */
547 	if (gen_number != 0) {
548 		if (search_by_entry_key(dir->i_sb, &entry_key, &path, &de) !=
549 		    NAME_NOT_FOUND) {
550 			reiserfs_warning(dir->i_sb, "vs-7032",
551 					 "entry with this key (%K) already "
552 					 "exists", &entry_key);
553 
554 			if (buffer != small_buf)
555 				kfree(buffer);
556 			pathrelse(&path);
557 			return -EBUSY;
558 		}
559 	}
560 
561 	/* perform the insertion of the entry that we have prepared */
562 	retval =
563 	    reiserfs_paste_into_item(th, &path, &entry_key, dir, buffer,
564 				     paste_size);
565 	if (buffer != small_buf)
566 		kfree(buffer);
567 	if (retval) {
568 		reiserfs_check_path(&path);
569 		return retval;
570 	}
571 
572 	dir->i_size += paste_size;
573 	dir->i_mtime = dir->i_ctime = current_time(dir);
574 	if (!S_ISDIR(inode->i_mode) && visible)
575 		/* reiserfs_mkdir or reiserfs_rename will do that by itself */
576 		reiserfs_update_sd(th, dir);
577 
578 	reiserfs_check_path(&path);
579 	return 0;
580 }
581 
582 /*
583  * quota utility function, call if you've had to abort after calling
584  * new_inode_init, and have not called reiserfs_new_inode yet.
585  * This should only be called on inodes that do not have stat data
586  * inserted into the tree yet.
587  */
588 static int drop_new_inode(struct inode *inode)
589 {
590 	dquot_drop(inode);
591 	make_bad_inode(inode);
592 	inode->i_flags |= S_NOQUOTA;
593 	iput(inode);
594 	return 0;
595 }
596 
597 /*
598  * utility function that does setup for reiserfs_new_inode.
599  * dquot_initialize needs lots of credits so it's better to have it
600  * outside of a transaction, so we had to pull some bits of
601  * reiserfs_new_inode out into this func.
602  */
603 static int new_inode_init(struct inode *inode, struct inode *dir, umode_t mode)
604 {
605 	/*
606 	 * Make inode invalid - just in case we are going to drop it before
607 	 * the initialization happens
608 	 */
609 	INODE_PKEY(inode)->k_objectid = 0;
610 
611 	/*
612 	 * the quota init calls have to know who to charge the quota to, so
613 	 * we have to set uid and gid here
614 	 */
615 	inode_init_owner(inode, dir, mode);
616 	return dquot_initialize(inode);
617 }
618 
619 static int reiserfs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
620 			   bool excl)
621 {
622 	int retval;
623 	struct inode *inode;
624 	/*
625 	 * We need blocks for transaction + (user+group)*(quotas
626 	 * for new inode + update of quota for directory owner)
627 	 */
628 	int jbegin_count =
629 	    JOURNAL_PER_BALANCE_CNT * 2 +
630 	    2 * (REISERFS_QUOTA_INIT_BLOCKS(dir->i_sb) +
631 		 REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb));
632 	struct reiserfs_transaction_handle th;
633 	struct reiserfs_security_handle security;
634 
635 	retval = dquot_initialize(dir);
636 	if (retval)
637 		return retval;
638 
639 	if (!(inode = new_inode(dir->i_sb))) {
640 		return -ENOMEM;
641 	}
642 	retval = new_inode_init(inode, dir, mode);
643 	if (retval) {
644 		drop_new_inode(inode);
645 		return retval;
646 	}
647 
648 	jbegin_count += reiserfs_cache_default_acl(dir);
649 	retval = reiserfs_security_init(dir, inode, &dentry->d_name, &security);
650 	if (retval < 0) {
651 		drop_new_inode(inode);
652 		return retval;
653 	}
654 	jbegin_count += retval;
655 	reiserfs_write_lock(dir->i_sb);
656 
657 	retval = journal_begin(&th, dir->i_sb, jbegin_count);
658 	if (retval) {
659 		drop_new_inode(inode);
660 		goto out_failed;
661 	}
662 
663 	retval =
664 	    reiserfs_new_inode(&th, dir, mode, NULL, 0 /*i_size */ , dentry,
665 			       inode, &security);
666 	if (retval)
667 		goto out_failed;
668 
669 	inode->i_op = &reiserfs_file_inode_operations;
670 	inode->i_fop = &reiserfs_file_operations;
671 	inode->i_mapping->a_ops = &reiserfs_address_space_operations;
672 
673 	retval =
674 	    reiserfs_add_entry(&th, dir, dentry->d_name.name,
675 			       dentry->d_name.len, inode, 1 /*visible */ );
676 	if (retval) {
677 		int err;
678 		drop_nlink(inode);
679 		reiserfs_update_sd(&th, inode);
680 		err = journal_end(&th);
681 		if (err)
682 			retval = err;
683 		unlock_new_inode(inode);
684 		iput(inode);
685 		goto out_failed;
686 	}
687 	reiserfs_update_inode_transaction(inode);
688 	reiserfs_update_inode_transaction(dir);
689 
690 	unlock_new_inode(inode);
691 	d_instantiate(dentry, inode);
692 	retval = journal_end(&th);
693 
694 out_failed:
695 	reiserfs_write_unlock(dir->i_sb);
696 	return retval;
697 }
698 
699 static int reiserfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode,
700 			  dev_t rdev)
701 {
702 	int retval;
703 	struct inode *inode;
704 	struct reiserfs_transaction_handle th;
705 	struct reiserfs_security_handle security;
706 	/*
707 	 * We need blocks for transaction + (user+group)*(quotas
708 	 * for new inode + update of quota for directory owner)
709 	 */
710 	int jbegin_count =
711 	    JOURNAL_PER_BALANCE_CNT * 3 +
712 	    2 * (REISERFS_QUOTA_INIT_BLOCKS(dir->i_sb) +
713 		 REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb));
714 
715 	retval = dquot_initialize(dir);
716 	if (retval)
717 		return retval;
718 
719 	if (!(inode = new_inode(dir->i_sb))) {
720 		return -ENOMEM;
721 	}
722 	retval = new_inode_init(inode, dir, mode);
723 	if (retval) {
724 		drop_new_inode(inode);
725 		return retval;
726 	}
727 
728 	jbegin_count += reiserfs_cache_default_acl(dir);
729 	retval = reiserfs_security_init(dir, inode, &dentry->d_name, &security);
730 	if (retval < 0) {
731 		drop_new_inode(inode);
732 		return retval;
733 	}
734 	jbegin_count += retval;
735 	reiserfs_write_lock(dir->i_sb);
736 
737 	retval = journal_begin(&th, dir->i_sb, jbegin_count);
738 	if (retval) {
739 		drop_new_inode(inode);
740 		goto out_failed;
741 	}
742 
743 	retval =
744 	    reiserfs_new_inode(&th, dir, mode, NULL, 0 /*i_size */ , dentry,
745 			       inode, &security);
746 	if (retval) {
747 		goto out_failed;
748 	}
749 
750 	inode->i_op = &reiserfs_special_inode_operations;
751 	init_special_inode(inode, inode->i_mode, rdev);
752 
753 	/* FIXME: needed for block and char devices only */
754 	reiserfs_update_sd(&th, inode);
755 
756 	reiserfs_update_inode_transaction(inode);
757 	reiserfs_update_inode_transaction(dir);
758 
759 	retval =
760 	    reiserfs_add_entry(&th, dir, dentry->d_name.name,
761 			       dentry->d_name.len, inode, 1 /*visible */ );
762 	if (retval) {
763 		int err;
764 		drop_nlink(inode);
765 		reiserfs_update_sd(&th, inode);
766 		err = journal_end(&th);
767 		if (err)
768 			retval = err;
769 		unlock_new_inode(inode);
770 		iput(inode);
771 		goto out_failed;
772 	}
773 
774 	unlock_new_inode(inode);
775 	d_instantiate(dentry, inode);
776 	retval = journal_end(&th);
777 
778 out_failed:
779 	reiserfs_write_unlock(dir->i_sb);
780 	return retval;
781 }
782 
783 static int reiserfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
784 {
785 	int retval;
786 	struct inode *inode;
787 	struct reiserfs_transaction_handle th;
788 	struct reiserfs_security_handle security;
789 	/*
790 	 * We need blocks for transaction + (user+group)*(quotas
791 	 * for new inode + update of quota for directory owner)
792 	 */
793 	int jbegin_count =
794 	    JOURNAL_PER_BALANCE_CNT * 3 +
795 	    2 * (REISERFS_QUOTA_INIT_BLOCKS(dir->i_sb) +
796 		 REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb));
797 
798 	retval = dquot_initialize(dir);
799 	if (retval)
800 		return retval;
801 
802 #ifdef DISPLACE_NEW_PACKING_LOCALITIES
803 	/*
804 	 * set flag that new packing locality created and new blocks
805 	 * for the content of that directory are not displaced yet
806 	 */
807 	REISERFS_I(dir)->new_packing_locality = 1;
808 #endif
809 	mode = S_IFDIR | mode;
810 	if (!(inode = new_inode(dir->i_sb))) {
811 		return -ENOMEM;
812 	}
813 	retval = new_inode_init(inode, dir, mode);
814 	if (retval) {
815 		drop_new_inode(inode);
816 		return retval;
817 	}
818 
819 	jbegin_count += reiserfs_cache_default_acl(dir);
820 	retval = reiserfs_security_init(dir, inode, &dentry->d_name, &security);
821 	if (retval < 0) {
822 		drop_new_inode(inode);
823 		return retval;
824 	}
825 	jbegin_count += retval;
826 	reiserfs_write_lock(dir->i_sb);
827 
828 	retval = journal_begin(&th, dir->i_sb, jbegin_count);
829 	if (retval) {
830 		drop_new_inode(inode);
831 		goto out_failed;
832 	}
833 
834 	/*
835 	 * inc the link count now, so another writer doesn't overflow
836 	 * it while we sleep later on.
837 	 */
838 	INC_DIR_INODE_NLINK(dir)
839 
840 	    retval = reiserfs_new_inode(&th, dir, mode, NULL /*symlink */ ,
841 					old_format_only(dir->i_sb) ?
842 					EMPTY_DIR_SIZE_V1 : EMPTY_DIR_SIZE,
843 					dentry, inode, &security);
844 	if (retval) {
845 		DEC_DIR_INODE_NLINK(dir)
846 		goto out_failed;
847 	}
848 
849 	reiserfs_update_inode_transaction(inode);
850 	reiserfs_update_inode_transaction(dir);
851 
852 	inode->i_op = &reiserfs_dir_inode_operations;
853 	inode->i_fop = &reiserfs_dir_operations;
854 
855 	/* note, _this_ add_entry will not update dir's stat data */
856 	retval =
857 	    reiserfs_add_entry(&th, dir, dentry->d_name.name,
858 			       dentry->d_name.len, inode, 1 /*visible */ );
859 	if (retval) {
860 		int err;
861 		clear_nlink(inode);
862 		DEC_DIR_INODE_NLINK(dir);
863 		reiserfs_update_sd(&th, inode);
864 		err = journal_end(&th);
865 		if (err)
866 			retval = err;
867 		unlock_new_inode(inode);
868 		iput(inode);
869 		goto out_failed;
870 	}
871 	/* the above add_entry did not update dir's stat data */
872 	reiserfs_update_sd(&th, dir);
873 
874 	unlock_new_inode(inode);
875 	d_instantiate(dentry, inode);
876 	retval = journal_end(&th);
877 out_failed:
878 	reiserfs_write_unlock(dir->i_sb);
879 	return retval;
880 }
881 
882 static inline int reiserfs_empty_dir(struct inode *inode)
883 {
884 	/*
885 	 * we can cheat because an old format dir cannot have
886 	 * EMPTY_DIR_SIZE, and a new format dir cannot have
887 	 * EMPTY_DIR_SIZE_V1.  So, if the inode is either size,
888 	 * regardless of disk format version, the directory is empty.
889 	 */
890 	if (inode->i_size != EMPTY_DIR_SIZE &&
891 	    inode->i_size != EMPTY_DIR_SIZE_V1) {
892 		return 0;
893 	}
894 	return 1;
895 }
896 
897 static int reiserfs_rmdir(struct inode *dir, struct dentry *dentry)
898 {
899 	int retval, err;
900 	struct inode *inode;
901 	struct reiserfs_transaction_handle th;
902 	int jbegin_count;
903 	INITIALIZE_PATH(path);
904 	struct reiserfs_dir_entry de;
905 
906 	/*
907 	 * we will be doing 2 balancings and update 2 stat data, we
908 	 * change quotas of the owner of the directory and of the owner
909 	 * of the parent directory.  The quota structure is possibly
910 	 * deleted only on last iput => outside of this transaction
911 	 */
912 	jbegin_count =
913 	    JOURNAL_PER_BALANCE_CNT * 2 + 2 +
914 	    4 * REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb);
915 
916 	retval = dquot_initialize(dir);
917 	if (retval)
918 		return retval;
919 
920 	reiserfs_write_lock(dir->i_sb);
921 	retval = journal_begin(&th, dir->i_sb, jbegin_count);
922 	if (retval)
923 		goto out_rmdir;
924 
925 	de.de_gen_number_bit_string = NULL;
926 	if ((retval =
927 	     reiserfs_find_entry(dir, dentry->d_name.name, dentry->d_name.len,
928 				 &path, &de)) == NAME_NOT_FOUND) {
929 		retval = -ENOENT;
930 		goto end_rmdir;
931 	} else if (retval == IO_ERROR) {
932 		retval = -EIO;
933 		goto end_rmdir;
934 	}
935 
936 	inode = d_inode(dentry);
937 
938 	reiserfs_update_inode_transaction(inode);
939 	reiserfs_update_inode_transaction(dir);
940 
941 	if (de.de_objectid != inode->i_ino) {
942 		/*
943 		 * FIXME: compare key of an object and a key found in the entry
944 		 */
945 		retval = -EIO;
946 		goto end_rmdir;
947 	}
948 	if (!reiserfs_empty_dir(inode)) {
949 		retval = -ENOTEMPTY;
950 		goto end_rmdir;
951 	}
952 
953 	/* cut entry from dir directory */
954 	retval = reiserfs_cut_from_item(&th, &path, &de.de_entry_key,
955 					dir, NULL,	/* page */
956 					0 /*new file size - not used here */ );
957 	if (retval < 0)
958 		goto end_rmdir;
959 
960 	if (inode->i_nlink != 2 && inode->i_nlink != 1)
961 		reiserfs_error(inode->i_sb, "reiserfs-7040",
962 			       "empty directory has nlink != 2 (%d)",
963 			       inode->i_nlink);
964 
965 	clear_nlink(inode);
966 	inode->i_ctime = dir->i_ctime = dir->i_mtime = current_time(dir);
967 	reiserfs_update_sd(&th, inode);
968 
969 	DEC_DIR_INODE_NLINK(dir)
970 	    dir->i_size -= (DEH_SIZE + de.de_entrylen);
971 	reiserfs_update_sd(&th, dir);
972 
973 	/* prevent empty directory from getting lost */
974 	add_save_link(&th, inode, 0 /* not truncate */ );
975 
976 	retval = journal_end(&th);
977 	reiserfs_check_path(&path);
978 out_rmdir:
979 	reiserfs_write_unlock(dir->i_sb);
980 	return retval;
981 
982 end_rmdir:
983 	/*
984 	 * we must release path, because we did not call
985 	 * reiserfs_cut_from_item, or reiserfs_cut_from_item does not
986 	 * release path if operation was not complete
987 	 */
988 	pathrelse(&path);
989 	err = journal_end(&th);
990 	reiserfs_write_unlock(dir->i_sb);
991 	return err ? err : retval;
992 }
993 
994 static int reiserfs_unlink(struct inode *dir, struct dentry *dentry)
995 {
996 	int retval, err;
997 	struct inode *inode;
998 	struct reiserfs_dir_entry de;
999 	INITIALIZE_PATH(path);
1000 	struct reiserfs_transaction_handle th;
1001 	int jbegin_count;
1002 	unsigned long savelink;
1003 
1004 	retval = dquot_initialize(dir);
1005 	if (retval)
1006 		return retval;
1007 
1008 	inode = d_inode(dentry);
1009 
1010 	/*
1011 	 * in this transaction we can be doing at max two balancings and
1012 	 * update two stat datas, we change quotas of the owner of the
1013 	 * directory and of the owner of the parent directory. The quota
1014 	 * structure is possibly deleted only on iput => outside of
1015 	 * this transaction
1016 	 */
1017 	jbegin_count =
1018 	    JOURNAL_PER_BALANCE_CNT * 2 + 2 +
1019 	    4 * REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb);
1020 
1021 	reiserfs_write_lock(dir->i_sb);
1022 	retval = journal_begin(&th, dir->i_sb, jbegin_count);
1023 	if (retval)
1024 		goto out_unlink;
1025 
1026 	de.de_gen_number_bit_string = NULL;
1027 	if ((retval =
1028 	     reiserfs_find_entry(dir, dentry->d_name.name, dentry->d_name.len,
1029 				 &path, &de)) == NAME_NOT_FOUND) {
1030 		retval = -ENOENT;
1031 		goto end_unlink;
1032 	} else if (retval == IO_ERROR) {
1033 		retval = -EIO;
1034 		goto end_unlink;
1035 	}
1036 
1037 	reiserfs_update_inode_transaction(inode);
1038 	reiserfs_update_inode_transaction(dir);
1039 
1040 	if (de.de_objectid != inode->i_ino) {
1041 		/*
1042 		 * FIXME: compare key of an object and a key found in the entry
1043 		 */
1044 		retval = -EIO;
1045 		goto end_unlink;
1046 	}
1047 
1048 	if (!inode->i_nlink) {
1049 		reiserfs_warning(inode->i_sb, "reiserfs-7042",
1050 				 "deleting nonexistent file (%lu), %d",
1051 				 inode->i_ino, inode->i_nlink);
1052 		set_nlink(inode, 1);
1053 	}
1054 
1055 	drop_nlink(inode);
1056 
1057 	/*
1058 	 * we schedule before doing the add_save_link call, save the link
1059 	 * count so we don't race
1060 	 */
1061 	savelink = inode->i_nlink;
1062 
1063 	retval =
1064 	    reiserfs_cut_from_item(&th, &path, &de.de_entry_key, dir, NULL,
1065 				   0);
1066 	if (retval < 0) {
1067 		inc_nlink(inode);
1068 		goto end_unlink;
1069 	}
1070 	inode->i_ctime = current_time(inode);
1071 	reiserfs_update_sd(&th, inode);
1072 
1073 	dir->i_size -= (de.de_entrylen + DEH_SIZE);
1074 	dir->i_ctime = dir->i_mtime = current_time(dir);
1075 	reiserfs_update_sd(&th, dir);
1076 
1077 	if (!savelink)
1078 		/* prevent file from getting lost */
1079 		add_save_link(&th, inode, 0 /* not truncate */ );
1080 
1081 	retval = journal_end(&th);
1082 	reiserfs_check_path(&path);
1083 	reiserfs_write_unlock(dir->i_sb);
1084 	return retval;
1085 
1086 end_unlink:
1087 	pathrelse(&path);
1088 	err = journal_end(&th);
1089 	reiserfs_check_path(&path);
1090 	if (err)
1091 		retval = err;
1092 out_unlink:
1093 	reiserfs_write_unlock(dir->i_sb);
1094 	return retval;
1095 }
1096 
1097 static int reiserfs_symlink(struct inode *parent_dir,
1098 			    struct dentry *dentry, const char *symname)
1099 {
1100 	int retval;
1101 	struct inode *inode;
1102 	char *name;
1103 	int item_len;
1104 	struct reiserfs_transaction_handle th;
1105 	struct reiserfs_security_handle security;
1106 	int mode = S_IFLNK | S_IRWXUGO;
1107 	/*
1108 	 * We need blocks for transaction + (user+group)*(quotas for
1109 	 * new inode + update of quota for directory owner)
1110 	 */
1111 	int jbegin_count =
1112 	    JOURNAL_PER_BALANCE_CNT * 3 +
1113 	    2 * (REISERFS_QUOTA_INIT_BLOCKS(parent_dir->i_sb) +
1114 		 REISERFS_QUOTA_TRANS_BLOCKS(parent_dir->i_sb));
1115 
1116 	retval = dquot_initialize(parent_dir);
1117 	if (retval)
1118 		return retval;
1119 
1120 	if (!(inode = new_inode(parent_dir->i_sb))) {
1121 		return -ENOMEM;
1122 	}
1123 	retval = new_inode_init(inode, parent_dir, mode);
1124 	if (retval) {
1125 		drop_new_inode(inode);
1126 		return retval;
1127 	}
1128 
1129 	retval = reiserfs_security_init(parent_dir, inode, &dentry->d_name,
1130 					&security);
1131 	if (retval < 0) {
1132 		drop_new_inode(inode);
1133 		return retval;
1134 	}
1135 	jbegin_count += retval;
1136 
1137 	reiserfs_write_lock(parent_dir->i_sb);
1138 	item_len = ROUND_UP(strlen(symname));
1139 	if (item_len > MAX_DIRECT_ITEM_LEN(parent_dir->i_sb->s_blocksize)) {
1140 		retval = -ENAMETOOLONG;
1141 		drop_new_inode(inode);
1142 		goto out_failed;
1143 	}
1144 
1145 	name = kmalloc(item_len, GFP_NOFS);
1146 	if (!name) {
1147 		drop_new_inode(inode);
1148 		retval = -ENOMEM;
1149 		goto out_failed;
1150 	}
1151 	memcpy(name, symname, strlen(symname));
1152 	padd_item(name, item_len, strlen(symname));
1153 
1154 	retval = journal_begin(&th, parent_dir->i_sb, jbegin_count);
1155 	if (retval) {
1156 		drop_new_inode(inode);
1157 		kfree(name);
1158 		goto out_failed;
1159 	}
1160 
1161 	retval =
1162 	    reiserfs_new_inode(&th, parent_dir, mode, name, strlen(symname),
1163 			       dentry, inode, &security);
1164 	kfree(name);
1165 	if (retval) {		/* reiserfs_new_inode iputs for us */
1166 		goto out_failed;
1167 	}
1168 
1169 	reiserfs_update_inode_transaction(inode);
1170 	reiserfs_update_inode_transaction(parent_dir);
1171 
1172 	inode->i_op = &reiserfs_symlink_inode_operations;
1173 	inode_nohighmem(inode);
1174 	inode->i_mapping->a_ops = &reiserfs_address_space_operations;
1175 
1176 	retval = reiserfs_add_entry(&th, parent_dir, dentry->d_name.name,
1177 				    dentry->d_name.len, inode, 1 /*visible */ );
1178 	if (retval) {
1179 		int err;
1180 		drop_nlink(inode);
1181 		reiserfs_update_sd(&th, inode);
1182 		err = journal_end(&th);
1183 		if (err)
1184 			retval = err;
1185 		unlock_new_inode(inode);
1186 		iput(inode);
1187 		goto out_failed;
1188 	}
1189 
1190 	unlock_new_inode(inode);
1191 	d_instantiate(dentry, inode);
1192 	retval = journal_end(&th);
1193 out_failed:
1194 	reiserfs_write_unlock(parent_dir->i_sb);
1195 	return retval;
1196 }
1197 
1198 static int reiserfs_link(struct dentry *old_dentry, struct inode *dir,
1199 			 struct dentry *dentry)
1200 {
1201 	int retval;
1202 	struct inode *inode = d_inode(old_dentry);
1203 	struct reiserfs_transaction_handle th;
1204 	/*
1205 	 * We need blocks for transaction + update of quotas for
1206 	 * the owners of the directory
1207 	 */
1208 	int jbegin_count =
1209 	    JOURNAL_PER_BALANCE_CNT * 3 +
1210 	    2 * REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb);
1211 
1212 	retval = dquot_initialize(dir);
1213 	if (retval)
1214 		return retval;
1215 
1216 	reiserfs_write_lock(dir->i_sb);
1217 	if (inode->i_nlink >= REISERFS_LINK_MAX) {
1218 		/* FIXME: sd_nlink is 32 bit for new files */
1219 		reiserfs_write_unlock(dir->i_sb);
1220 		return -EMLINK;
1221 	}
1222 
1223 	/* inc before scheduling so reiserfs_unlink knows we are here */
1224 	inc_nlink(inode);
1225 
1226 	retval = journal_begin(&th, dir->i_sb, jbegin_count);
1227 	if (retval) {
1228 		drop_nlink(inode);
1229 		reiserfs_write_unlock(dir->i_sb);
1230 		return retval;
1231 	}
1232 
1233 	/* create new entry */
1234 	retval =
1235 	    reiserfs_add_entry(&th, dir, dentry->d_name.name,
1236 			       dentry->d_name.len, inode, 1 /*visible */ );
1237 
1238 	reiserfs_update_inode_transaction(inode);
1239 	reiserfs_update_inode_transaction(dir);
1240 
1241 	if (retval) {
1242 		int err;
1243 		drop_nlink(inode);
1244 		err = journal_end(&th);
1245 		reiserfs_write_unlock(dir->i_sb);
1246 		return err ? err : retval;
1247 	}
1248 
1249 	inode->i_ctime = current_time(inode);
1250 	reiserfs_update_sd(&th, inode);
1251 
1252 	ihold(inode);
1253 	d_instantiate(dentry, inode);
1254 	retval = journal_end(&th);
1255 	reiserfs_write_unlock(dir->i_sb);
1256 	return retval;
1257 }
1258 
1259 /* de contains information pointing to an entry which */
1260 static int de_still_valid(const char *name, int len,
1261 			  struct reiserfs_dir_entry *de)
1262 {
1263 	struct reiserfs_dir_entry tmp = *de;
1264 
1265 	/* recalculate pointer to name and name length */
1266 	set_de_name_and_namelen(&tmp);
1267 	/* FIXME: could check more */
1268 	if (tmp.de_namelen != len || memcmp(name, de->de_name, len))
1269 		return 0;
1270 	return 1;
1271 }
1272 
1273 static int entry_points_to_object(const char *name, int len,
1274 				  struct reiserfs_dir_entry *de,
1275 				  struct inode *inode)
1276 {
1277 	if (!de_still_valid(name, len, de))
1278 		return 0;
1279 
1280 	if (inode) {
1281 		if (!de_visible(de->de_deh + de->de_entry_num))
1282 			reiserfs_panic(inode->i_sb, "vs-7042",
1283 				       "entry must be visible");
1284 		return (de->de_objectid == inode->i_ino) ? 1 : 0;
1285 	}
1286 
1287 	/* this must be added hidden entry */
1288 	if (de_visible(de->de_deh + de->de_entry_num))
1289 		reiserfs_panic(NULL, "vs-7043", "entry must be visible");
1290 
1291 	return 1;
1292 }
1293 
1294 /* sets key of objectid the entry has to point to */
1295 static void set_ino_in_dir_entry(struct reiserfs_dir_entry *de,
1296 				 struct reiserfs_key *key)
1297 {
1298 	/* JDM These operations are endian safe - both are le */
1299 	de->de_deh[de->de_entry_num].deh_dir_id = key->k_dir_id;
1300 	de->de_deh[de->de_entry_num].deh_objectid = key->k_objectid;
1301 }
1302 
1303 /*
1304  * process, that is going to call fix_nodes/do_balance must hold only
1305  * one path. If it holds 2 or more, it can get into endless waiting in
1306  * get_empty_nodes or its clones
1307  */
1308 static int reiserfs_rename(struct inode *old_dir, struct dentry *old_dentry,
1309 			   struct inode *new_dir, struct dentry *new_dentry,
1310 			   unsigned int flags)
1311 {
1312 	int retval;
1313 	INITIALIZE_PATH(old_entry_path);
1314 	INITIALIZE_PATH(new_entry_path);
1315 	INITIALIZE_PATH(dot_dot_entry_path);
1316 	struct item_head new_entry_ih, old_entry_ih, dot_dot_ih;
1317 	struct reiserfs_dir_entry old_de, new_de, dot_dot_de;
1318 	struct inode *old_inode, *new_dentry_inode;
1319 	struct reiserfs_transaction_handle th;
1320 	int jbegin_count;
1321 	umode_t old_inode_mode;
1322 	unsigned long savelink = 1;
1323 	struct timespec ctime;
1324 
1325 	if (flags & ~RENAME_NOREPLACE)
1326 		return -EINVAL;
1327 
1328 	/*
1329 	 * three balancings: (1) old name removal, (2) new name insertion
1330 	 * and (3) maybe "save" link insertion
1331 	 * stat data updates: (1) old directory,
1332 	 * (2) new directory and (3) maybe old object stat data (when it is
1333 	 * directory) and (4) maybe stat data of object to which new entry
1334 	 * pointed initially and (5) maybe block containing ".." of
1335 	 * renamed directory
1336 	 * quota updates: two parent directories
1337 	 */
1338 	jbegin_count =
1339 	    JOURNAL_PER_BALANCE_CNT * 3 + 5 +
1340 	    4 * REISERFS_QUOTA_TRANS_BLOCKS(old_dir->i_sb);
1341 
1342 	retval = dquot_initialize(old_dir);
1343 	if (retval)
1344 		return retval;
1345 	retval = dquot_initialize(new_dir);
1346 	if (retval)
1347 		return retval;
1348 
1349 	old_inode = d_inode(old_dentry);
1350 	new_dentry_inode = d_inode(new_dentry);
1351 
1352 	/*
1353 	 * make sure that oldname still exists and points to an object we
1354 	 * are going to rename
1355 	 */
1356 	old_de.de_gen_number_bit_string = NULL;
1357 	reiserfs_write_lock(old_dir->i_sb);
1358 	retval =
1359 	    reiserfs_find_entry(old_dir, old_dentry->d_name.name,
1360 				old_dentry->d_name.len, &old_entry_path,
1361 				&old_de);
1362 	pathrelse(&old_entry_path);
1363 	if (retval == IO_ERROR) {
1364 		reiserfs_write_unlock(old_dir->i_sb);
1365 		return -EIO;
1366 	}
1367 
1368 	if (retval != NAME_FOUND || old_de.de_objectid != old_inode->i_ino) {
1369 		reiserfs_write_unlock(old_dir->i_sb);
1370 		return -ENOENT;
1371 	}
1372 
1373 	old_inode_mode = old_inode->i_mode;
1374 	if (S_ISDIR(old_inode_mode)) {
1375 		/*
1376 		 * make sure that directory being renamed has correct ".."
1377 		 * and that its new parent directory has not too many links
1378 		 * already
1379 		 */
1380 		if (new_dentry_inode) {
1381 			if (!reiserfs_empty_dir(new_dentry_inode)) {
1382 				reiserfs_write_unlock(old_dir->i_sb);
1383 				return -ENOTEMPTY;
1384 			}
1385 		}
1386 
1387 		/*
1388 		 * directory is renamed, its parent directory will be changed,
1389 		 * so find ".." entry
1390 		 */
1391 		dot_dot_de.de_gen_number_bit_string = NULL;
1392 		retval =
1393 		    reiserfs_find_entry(old_inode, "..", 2, &dot_dot_entry_path,
1394 					&dot_dot_de);
1395 		pathrelse(&dot_dot_entry_path);
1396 		if (retval != NAME_FOUND) {
1397 			reiserfs_write_unlock(old_dir->i_sb);
1398 			return -EIO;
1399 		}
1400 
1401 		/* inode number of .. must equal old_dir->i_ino */
1402 		if (dot_dot_de.de_objectid != old_dir->i_ino) {
1403 			reiserfs_write_unlock(old_dir->i_sb);
1404 			return -EIO;
1405 		}
1406 	}
1407 
1408 	retval = journal_begin(&th, old_dir->i_sb, jbegin_count);
1409 	if (retval) {
1410 		reiserfs_write_unlock(old_dir->i_sb);
1411 		return retval;
1412 	}
1413 
1414 	/* add new entry (or find the existing one) */
1415 	retval =
1416 	    reiserfs_add_entry(&th, new_dir, new_dentry->d_name.name,
1417 			       new_dentry->d_name.len, old_inode, 0);
1418 	if (retval == -EEXIST) {
1419 		if (!new_dentry_inode) {
1420 			reiserfs_panic(old_dir->i_sb, "vs-7050",
1421 				       "new entry is found, new inode == 0");
1422 		}
1423 	} else if (retval) {
1424 		int err = journal_end(&th);
1425 		reiserfs_write_unlock(old_dir->i_sb);
1426 		return err ? err : retval;
1427 	}
1428 
1429 	reiserfs_update_inode_transaction(old_dir);
1430 	reiserfs_update_inode_transaction(new_dir);
1431 
1432 	/*
1433 	 * this makes it so an fsync on an open fd for the old name will
1434 	 * commit the rename operation
1435 	 */
1436 	reiserfs_update_inode_transaction(old_inode);
1437 
1438 	if (new_dentry_inode)
1439 		reiserfs_update_inode_transaction(new_dentry_inode);
1440 
1441 	while (1) {
1442 		/*
1443 		 * look for old name using corresponding entry key
1444 		 * (found by reiserfs_find_entry)
1445 		 */
1446 		if ((retval =
1447 		     search_by_entry_key(new_dir->i_sb, &old_de.de_entry_key,
1448 					 &old_entry_path,
1449 					 &old_de)) != NAME_FOUND) {
1450 			pathrelse(&old_entry_path);
1451 			journal_end(&th);
1452 			reiserfs_write_unlock(old_dir->i_sb);
1453 			return -EIO;
1454 		}
1455 
1456 		copy_item_head(&old_entry_ih, tp_item_head(&old_entry_path));
1457 
1458 		reiserfs_prepare_for_journal(old_inode->i_sb, old_de.de_bh, 1);
1459 
1460 		/* look for new name by reiserfs_find_entry */
1461 		new_de.de_gen_number_bit_string = NULL;
1462 		retval =
1463 		    reiserfs_find_entry(new_dir, new_dentry->d_name.name,
1464 					new_dentry->d_name.len, &new_entry_path,
1465 					&new_de);
1466 		/*
1467 		 * reiserfs_add_entry should not return IO_ERROR,
1468 		 * because it is called with essentially same parameters from
1469 		 * reiserfs_add_entry above, and we'll catch any i/o errors
1470 		 * before we get here.
1471 		 */
1472 		if (retval != NAME_FOUND_INVISIBLE && retval != NAME_FOUND) {
1473 			pathrelse(&new_entry_path);
1474 			pathrelse(&old_entry_path);
1475 			journal_end(&th);
1476 			reiserfs_write_unlock(old_dir->i_sb);
1477 			return -EIO;
1478 		}
1479 
1480 		copy_item_head(&new_entry_ih, tp_item_head(&new_entry_path));
1481 
1482 		reiserfs_prepare_for_journal(old_inode->i_sb, new_de.de_bh, 1);
1483 
1484 		if (S_ISDIR(old_inode->i_mode)) {
1485 			if ((retval =
1486 			     search_by_entry_key(new_dir->i_sb,
1487 						 &dot_dot_de.de_entry_key,
1488 						 &dot_dot_entry_path,
1489 						 &dot_dot_de)) != NAME_FOUND) {
1490 				pathrelse(&dot_dot_entry_path);
1491 				pathrelse(&new_entry_path);
1492 				pathrelse(&old_entry_path);
1493 				journal_end(&th);
1494 				reiserfs_write_unlock(old_dir->i_sb);
1495 				return -EIO;
1496 			}
1497 			copy_item_head(&dot_dot_ih,
1498 				       tp_item_head(&dot_dot_entry_path));
1499 			/* node containing ".." gets into transaction */
1500 			reiserfs_prepare_for_journal(old_inode->i_sb,
1501 						     dot_dot_de.de_bh, 1);
1502 		}
1503 		/*
1504 		 * we should check seals here, not do
1505 		 * this stuff, yes? Then, having
1506 		 * gathered everything into RAM we
1507 		 * should lock the buffers, yes?  -Hans
1508 		 */
1509 		/*
1510 		 * probably.  our rename needs to hold more
1511 		 * than one path at once.  The seals would
1512 		 * have to be written to deal with multi-path
1513 		 * issues -chris
1514 		 */
1515 		/*
1516 		 * sanity checking before doing the rename - avoid races many
1517 		 * of the above checks could have scheduled.  We have to be
1518 		 * sure our items haven't been shifted by another process.
1519 		 */
1520 		if (item_moved(&new_entry_ih, &new_entry_path) ||
1521 		    !entry_points_to_object(new_dentry->d_name.name,
1522 					    new_dentry->d_name.len,
1523 					    &new_de, new_dentry_inode) ||
1524 		    item_moved(&old_entry_ih, &old_entry_path) ||
1525 		    !entry_points_to_object(old_dentry->d_name.name,
1526 					    old_dentry->d_name.len,
1527 					    &old_de, old_inode)) {
1528 			reiserfs_restore_prepared_buffer(old_inode->i_sb,
1529 							 new_de.de_bh);
1530 			reiserfs_restore_prepared_buffer(old_inode->i_sb,
1531 							 old_de.de_bh);
1532 			if (S_ISDIR(old_inode_mode))
1533 				reiserfs_restore_prepared_buffer(old_inode->
1534 								 i_sb,
1535 								 dot_dot_de.
1536 								 de_bh);
1537 			continue;
1538 		}
1539 		if (S_ISDIR(old_inode_mode)) {
1540 			if (item_moved(&dot_dot_ih, &dot_dot_entry_path) ||
1541 			    !entry_points_to_object("..", 2, &dot_dot_de,
1542 						    old_dir)) {
1543 				reiserfs_restore_prepared_buffer(old_inode->
1544 								 i_sb,
1545 								 old_de.de_bh);
1546 				reiserfs_restore_prepared_buffer(old_inode->
1547 								 i_sb,
1548 								 new_de.de_bh);
1549 				reiserfs_restore_prepared_buffer(old_inode->
1550 								 i_sb,
1551 								 dot_dot_de.
1552 								 de_bh);
1553 				continue;
1554 			}
1555 		}
1556 
1557 		RFALSE(S_ISDIR(old_inode_mode) &&
1558 		       !buffer_journal_prepared(dot_dot_de.de_bh), "");
1559 
1560 		break;
1561 	}
1562 
1563 	/*
1564 	 * ok, all the changes can be done in one fell swoop when we
1565 	 * have claimed all the buffers needed.
1566 	 */
1567 
1568 	mark_de_visible(new_de.de_deh + new_de.de_entry_num);
1569 	set_ino_in_dir_entry(&new_de, INODE_PKEY(old_inode));
1570 	journal_mark_dirty(&th, new_de.de_bh);
1571 
1572 	mark_de_hidden(old_de.de_deh + old_de.de_entry_num);
1573 	journal_mark_dirty(&th, old_de.de_bh);
1574 	ctime = current_time(old_dir);
1575 	old_dir->i_ctime = old_dir->i_mtime = ctime;
1576 	new_dir->i_ctime = new_dir->i_mtime = ctime;
1577 	/*
1578 	 * thanks to Alex Adriaanse <alex_a@caltech.edu> for patch
1579 	 * which adds ctime update of renamed object
1580 	 */
1581 	old_inode->i_ctime = ctime;
1582 
1583 	if (new_dentry_inode) {
1584 		/* adjust link number of the victim */
1585 		if (S_ISDIR(new_dentry_inode->i_mode)) {
1586 			clear_nlink(new_dentry_inode);
1587 		} else {
1588 			drop_nlink(new_dentry_inode);
1589 		}
1590 		new_dentry_inode->i_ctime = ctime;
1591 		savelink = new_dentry_inode->i_nlink;
1592 	}
1593 
1594 	if (S_ISDIR(old_inode_mode)) {
1595 		/* adjust ".." of renamed directory */
1596 		set_ino_in_dir_entry(&dot_dot_de, INODE_PKEY(new_dir));
1597 		journal_mark_dirty(&th, dot_dot_de.de_bh);
1598 
1599 		/*
1600 		 * there (in new_dir) was no directory, so it got new link
1601 		 * (".."  of renamed directory)
1602 		 */
1603 		if (!new_dentry_inode)
1604 			INC_DIR_INODE_NLINK(new_dir);
1605 
1606 		/* old directory lost one link - ".. " of renamed directory */
1607 		DEC_DIR_INODE_NLINK(old_dir);
1608 	}
1609 	/*
1610 	 * looks like in 2.3.99pre3 brelse is atomic.
1611 	 * so we can use pathrelse
1612 	 */
1613 	pathrelse(&new_entry_path);
1614 	pathrelse(&dot_dot_entry_path);
1615 
1616 	/*
1617 	 * FIXME: this reiserfs_cut_from_item's return value may screw up
1618 	 * anybody, but it will panic if will not be able to find the
1619 	 * entry. This needs one more clean up
1620 	 */
1621 	if (reiserfs_cut_from_item
1622 	    (&th, &old_entry_path, &old_de.de_entry_key, old_dir, NULL,
1623 	     0) < 0)
1624 		reiserfs_error(old_dir->i_sb, "vs-7060",
1625 			       "couldn't not cut old name. Fsck later?");
1626 
1627 	old_dir->i_size -= DEH_SIZE + old_de.de_entrylen;
1628 
1629 	reiserfs_update_sd(&th, old_dir);
1630 	reiserfs_update_sd(&th, new_dir);
1631 	reiserfs_update_sd(&th, old_inode);
1632 
1633 	if (new_dentry_inode) {
1634 		if (savelink == 0)
1635 			add_save_link(&th, new_dentry_inode,
1636 				      0 /* not truncate */ );
1637 		reiserfs_update_sd(&th, new_dentry_inode);
1638 	}
1639 
1640 	retval = journal_end(&th);
1641 	reiserfs_write_unlock(old_dir->i_sb);
1642 	return retval;
1643 }
1644 
1645 /* directories can handle most operations...  */
1646 const struct inode_operations reiserfs_dir_inode_operations = {
1647 	.create = reiserfs_create,
1648 	.lookup = reiserfs_lookup,
1649 	.link = reiserfs_link,
1650 	.unlink = reiserfs_unlink,
1651 	.symlink = reiserfs_symlink,
1652 	.mkdir = reiserfs_mkdir,
1653 	.rmdir = reiserfs_rmdir,
1654 	.mknod = reiserfs_mknod,
1655 	.rename = reiserfs_rename,
1656 	.setattr = reiserfs_setattr,
1657 	.listxattr = reiserfs_listxattr,
1658 	.permission = reiserfs_permission,
1659 	.get_acl = reiserfs_get_acl,
1660 	.set_acl = reiserfs_set_acl,
1661 };
1662 
1663 /*
1664  * symlink operations.. same as page_symlink_inode_operations, with xattr
1665  * stuff added
1666  */
1667 const struct inode_operations reiserfs_symlink_inode_operations = {
1668 	.readlink = generic_readlink,
1669 	.get_link	= page_get_link,
1670 	.setattr = reiserfs_setattr,
1671 	.listxattr = reiserfs_listxattr,
1672 	.permission = reiserfs_permission,
1673 };
1674 
1675 /*
1676  * special file operations.. just xattr/acl stuff
1677  */
1678 const struct inode_operations reiserfs_special_inode_operations = {
1679 	.setattr = reiserfs_setattr,
1680 	.listxattr = reiserfs_listxattr,
1681 	.permission = reiserfs_permission,
1682 	.get_acl = reiserfs_get_acl,
1683 	.set_acl = reiserfs_set_acl,
1684 };
1685