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