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