fs/reiserfs/namei.c

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