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