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