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