fs/reiserfs/namei.c

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