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