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