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_mark_inode_private (inode);
 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     inode->i_xid = vx_current_fsxid(inode->i_sb);
 582     DQUOT_INIT(inode);
 583     return 0 ;
 584 }
 585
 586 static int reiserfs_create (struct inode * dir, struct dentry *dentry, int mode,
 587                 struct nameidata *nd)
 588 {
 589     int retval;
 590     struct inode * inode;
 591     /* We need blocks for transaction + (user+group)*(quotas for new inode + update of quota for directory owner) */
 592     int jbegin_count = JOURNAL_PER_BALANCE_CNT * 2 + 2 * (REISERFS_QUOTA_INIT_BLOCKS+REISERFS_QUOTA_TRANS_BLOCKS);
 593     struct reiserfs_transaction_handle th ;
 594     int locked;
 595
 596     if (!(inode = new_inode(dir->i_sb))) {
 597         return -ENOMEM ;
 598     }
 599     new_inode_init(inode, dir, mode);
 600
 601     locked = reiserfs_cache_default_acl (dir);
 602
 603     reiserfs_write_lock(dir->i_sb);
 604
 605     if (locked)
 606         reiserfs_write_lock_xattrs (dir->i_sb);
 607
 608     retval = journal_begin(&th, dir->i_sb, jbegin_count);
 609     if (retval) {
 610         drop_new_inode (inode);
 611         goto out_failed;
 612     }
 613
 614     retval = reiserfs_new_inode (&th, dir, mode, NULL, 0/*i_size*/, dentry, inode);
 615     if (retval)
 616         goto out_failed;
 617
 618     if (locked) {
 619         reiserfs_write_unlock_xattrs (dir->i_sb);
 620         locked = 0;
 621     }
 622
 623     inode->i_op = &reiserfs_file_inode_operations;
 624     inode->i_fop = &reiserfs_file_operations;
 625     inode->i_mapping->a_ops = &reiserfs_address_space_operations ;
 626
 627     retval = reiserfs_add_entry (&th, dir, dentry->d_name.name, dentry->d_name.len,
 628                                 inode, 1/*visible*/);
 629     if (retval) {
 630         int err;
 631         inode->i_nlink--;
 632         reiserfs_update_sd (&th, inode);
 633         err = journal_end(&th, dir->i_sb, jbegin_count) ;
 634         if (err)
 635             retval = err;
 636         iput (inode);
 637         goto out_failed;
 638     }
 639     reiserfs_update_inode_transaction(inode) ;
 640     reiserfs_update_inode_transaction(dir) ;
 641
 642     d_instantiate(dentry, inode);
 643     retval = journal_end(&th, dir->i_sb, jbegin_count) ;
 644
 645 out_failed:
 646     if (locked)
 647         reiserfs_write_unlock_xattrs (dir->i_sb);
 648     reiserfs_write_unlock(dir->i_sb);
 649     return retval;
 650 }
 651
 652
 653 static int reiserfs_mknod (struct inode * dir, struct dentry *dentry, int mode, dev_t rdev)
 654 {
 655     int retval;
 656     struct inode * inode;
 657     struct reiserfs_transaction_handle th ;
 658     /* We need blocks for transaction + (user+group)*(quotas for new inode + update of quota for directory owner) */
 659     int jbegin_count = JOURNAL_PER_BALANCE_CNT * 3 + 2 * (REISERFS_QUOTA_INIT_BLOCKS+REISERFS_QUOTA_TRANS_BLOCKS);
 660     int locked;
 661
 662     if (!new_valid_dev(rdev))
 663         return -EINVAL;
 664
 665     if (!(inode = new_inode(dir->i_sb))) {
 666         return -ENOMEM ;
 667     }
 668     new_inode_init(inode, dir, mode);
 669
 670     locked = reiserfs_cache_default_acl (dir);
 671
 672     reiserfs_write_lock(dir->i_sb);
 673
 674     if (locked)
 675         reiserfs_write_lock_xattrs (dir->i_sb);
 676
 677     retval = journal_begin(&th, dir->i_sb, jbegin_count) ;
 678     if (retval) {
 679         drop_new_inode (inode);
 680         goto out_failed;
 681     }
 682
 683     retval = reiserfs_new_inode (&th, dir, mode, NULL, 0/*i_size*/, dentry, inode);
 684     if (retval) {
 685         goto out_failed;
 686     }
 687
 688     if (locked) {
 689         reiserfs_write_unlock_xattrs (dir->i_sb);
 690         locked = 0;
 691     }
 692
 693
 694     inode->i_op = &reiserfs_special_inode_operations;
 695     init_special_inode(inode, inode->i_mode, rdev) ;
 696
 697     //FIXME: needed for block and char devices only
 698     reiserfs_update_sd (&th, inode);
 699
 700     reiserfs_update_inode_transaction(inode) ;
 701     reiserfs_update_inode_transaction(dir) ;
 702
 703     retval = reiserfs_add_entry (&th, dir, dentry->d_name.name, dentry->d_name.len,
 704                                  inode, 1/*visible*/);
 705     if (retval) {
 706         int err;
 707         inode->i_nlink--;
 708         reiserfs_update_sd (&th, inode);
 709         err = journal_end(&th, dir->i_sb, jbegin_count) ;
 710         if (err)
 711             retval = err;
 712         iput (inode);
 713         goto out_failed;
 714     }
 715
 716     d_instantiate(dentry, inode);
 717     retval = journal_end(&th, dir->i_sb, jbegin_count) ;
 718
 719 out_failed:
 720     if (locked)
 721         reiserfs_write_unlock_xattrs (dir->i_sb);
 722     reiserfs_write_unlock(dir->i_sb);
 723     return retval;
 724 }
 725
 726
 727 static int reiserfs_mkdir (struct inode * dir, struct dentry *dentry, int mode)
 728 {
 729     int retval;
 730     struct inode * inode;
 731     struct reiserfs_transaction_handle th ;
 732     /* We need blocks for transaction + (user+group)*(quotas for new inode + update of quota for directory owner) */
 733     int jbegin_count = JOURNAL_PER_BALANCE_CNT * 3 + 2 * (REISERFS_QUOTA_INIT_BLOCKS+REISERFS_QUOTA_TRANS_BLOCKS);
 734     int locked;
 735
 736 #ifdef DISPLACE_NEW_PACKING_LOCALITIES
 737     /* set flag that new packing locality created and new blocks for the content     * of that directory are not displaced yet */
 738     REISERFS_I(dir)->new_packing_locality = 1;
 739 #endif
 740     mode = S_IFDIR | mode;
 741     if (!(inode = new_inode(dir->i_sb))) {
 742         return -ENOMEM ;
 743     }
 744     new_inode_init(inode, dir, mode);
 745
 746     locked = reiserfs_cache_default_acl (dir);
 747
 748     reiserfs_write_lock(dir->i_sb);
 749     if (locked)
 750         reiserfs_write_lock_xattrs (dir->i_sb);
 751
 752     retval = journal_begin(&th, dir->i_sb, jbegin_count) ;
 753     if (retval) {
 754         drop_new_inode (inode);
 755         goto out_failed;
 756     }
 757
 758
 759     /* inc the link count now, so another writer doesn't overflow it while
 760     ** we sleep later on.
 761     */
 762     INC_DIR_INODE_NLINK(dir)
 763
 764     retval = reiserfs_new_inode (&th, dir, mode, NULL/*symlink*/,
 765                                 old_format_only (dir->i_sb) ?
 766                                 EMPTY_DIR_SIZE_V1 : EMPTY_DIR_SIZE,
 767                                 dentry, inode);
 768     if (retval) {
 769         dir->i_nlink-- ;
 770         goto out_failed;
 771     }
 772
 773     if (locked) {
 774         reiserfs_write_unlock_xattrs (dir->i_sb);
 775         locked = 0;
 776     }
 777
 778     reiserfs_update_inode_transaction(inode) ;
 779     reiserfs_update_inode_transaction(dir) ;
 780
 781     inode->i_op = &reiserfs_dir_inode_operations;
 782     inode->i_fop = &reiserfs_dir_operations;
 783
 784     // note, _this_ add_entry will not update dir's stat data
 785     retval = reiserfs_add_entry (&th, dir, dentry->d_name.name, dentry->d_name.len,
 786                                 inode, 1/*visible*/);
 787     if (retval) {
 788         int err;
 789         inode->i_nlink = 0;
 790         DEC_DIR_INODE_NLINK(dir);
 791         reiserfs_update_sd (&th, inode);
 792         err = journal_end(&th, dir->i_sb, jbegin_count) ;
 793         if (err)
 794             retval = err;
 795         iput (inode);
 796         goto out_failed;
 797     }
 798
 799     // the above add_entry did not update dir's stat data
 800     reiserfs_update_sd (&th, dir);
 801
 802     d_instantiate(dentry, inode);
 803     retval = journal_end(&th, dir->i_sb, jbegin_count) ;
 804 out_failed:
 805     if (locked)
 806         reiserfs_write_unlock_xattrs (dir->i_sb);
 807     reiserfs_write_unlock(dir->i_sb);
 808     return retval;
 809 }
 810
 811 static inline int reiserfs_empty_dir(struct inode *inode) {
 812     /* we can cheat because an old format dir cannot have
 813     ** EMPTY_DIR_SIZE, and a new format dir cannot have
 814     ** EMPTY_DIR_SIZE_V1.  So, if the inode is either size,
 815     ** regardless of disk format version, the directory is empty.
 816     */
 817     if (inode->i_size != EMPTY_DIR_SIZE &&
 818         inode->i_size != EMPTY_DIR_SIZE_V1) {
 819         return 0 ;
 820     }
 821     return 1 ;
 822 }
 823
 824 static int reiserfs_rmdir (struct inode * dir, struct dentry *dentry)
 825 {
 826     int retval, err;
 827     struct inode * inode;
 828     struct reiserfs_transaction_handle th ;
 829     int jbegin_count;
 830     INITIALIZE_PATH (path);
 831     struct reiserfs_dir_entry de;
 832
 833
 834     /* we will be doing 2 balancings and update 2 stat data, we change quotas
 835      * of the owner of the directory and of the owner of the parent directory */
 836     jbegin_count = JOURNAL_PER_BALANCE_CNT * 2 + 2 + 2 * (REISERFS_QUOTA_INIT_BLOCKS+REISERFS_QUOTA_TRANS_BLOCKS);
 837
 838     reiserfs_write_lock(dir->i_sb);
 839     retval = journal_begin(&th, dir->i_sb, jbegin_count) ;
 840     if (retval)
 841         goto out_rmdir;
 842
 843     de.de_gen_number_bit_string = NULL;
 844     if ( (retval = reiserfs_find_entry (dir, dentry->d_name.name, dentry->d_name.len, &path, &de)) == NAME_NOT_FOUND) {
 845         retval = -ENOENT;
 846         goto end_rmdir;
 847     } else if ( retval == IO_ERROR) {
 848         retval = -EIO;
 849         goto end_rmdir;
 850     }
 851
 852     inode = dentry->d_inode;
 853
 854     reiserfs_update_inode_transaction(inode) ;
 855     reiserfs_update_inode_transaction(dir) ;
 856
 857     if (de.de_objectid != inode->i_ino) {
 858         // FIXME: compare key of an object and a key found in the
 859         // entry
 860         retval = -EIO;
 861         goto end_rmdir;
 862     }
 863     if (!reiserfs_empty_dir(inode)) {
 864         retval = -ENOTEMPTY;
 865         goto end_rmdir;
 866     }
 867
 868     /* cut entry from dir directory */
 869     retval = reiserfs_cut_from_item (&th, &path, &(de.de_entry_key), dir,
 870                                      NULL, /* page */
 871                                      0/*new file size - not used here*/);
 872     if (retval < 0)
 873         goto end_rmdir;
 874
 875     if ( inode->i_nlink != 2 && inode->i_nlink != 1 )
 876         reiserfs_warning (inode->i_sb, "%s: empty directory has nlink "
 877                           "!= 2 (%d)", __FUNCTION__, inode->i_nlink);
 878
 879     inode->i_nlink = 0;
 880     inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME_SEC;
 881     reiserfs_update_sd (&th, inode);
 882
 883     DEC_DIR_INODE_NLINK(dir)
 884     dir->i_size -= (DEH_SIZE + de.de_entrylen);
 885     reiserfs_update_sd (&th, dir);
 886
 887     /* prevent empty directory from getting lost */
 888     add_save_link (&th, inode, 0/* not truncate */);
 889
 890     retval = journal_end(&th, dir->i_sb, jbegin_count) ;
 891     reiserfs_check_path(&path) ;
 892 out_rmdir:
 893     reiserfs_write_unlock(dir->i_sb);
 894     return retval;
 895
 896  end_rmdir:
 897     /* we must release path, because we did not call
 898        reiserfs_cut_from_item, or reiserfs_cut_from_item does not
 899        release path if operation was not complete */
 900     pathrelse (&path);
 901     err = journal_end(&th, dir->i_sb, jbegin_count) ;
 902     reiserfs_write_unlock(dir->i_sb);
 903     return err ? err : retval;
 904 }
 905
 906 static int reiserfs_unlink (struct inode * dir, struct dentry *dentry)
 907 {
 908     int retval, err;
 909     struct inode * inode;
 910     struct reiserfs_dir_entry de;
 911     INITIALIZE_PATH (path);
 912     struct reiserfs_transaction_handle th ;
 913     int jbegin_count;
 914     unsigned long savelink;
 915
 916     inode = dentry->d_inode;
 917
 918     /* in this transaction we can be doing at max two balancings and update
 919        two stat datas, we change quotas of the owner of the directory and of
 920        the owner of the parent directory */
 921     jbegin_count = JOURNAL_PER_BALANCE_CNT * 2 + 2 + 2 * (REISERFS_QUOTA_INIT_BLOCKS+REISERFS_QUOTA_TRANS_BLOCKS);
 922
 923     reiserfs_write_lock(dir->i_sb);
 924     retval = journal_begin(&th, dir->i_sb, jbegin_count) ;
 925     if (retval)
 926         goto out_unlink;
 927
 928     de.de_gen_number_bit_string = NULL;
 929     if ( (retval = reiserfs_find_entry (dir, dentry->d_name.name, dentry->d_name.len, &path, &de)) == NAME_NOT_FOUND) {
 930         retval = -ENOENT;
 931         goto end_unlink;
 932     } else if (retval == IO_ERROR) {
 933         retval = -EIO;
 934         goto end_unlink;
 935     }
 936
 937     reiserfs_update_inode_transaction(inode) ;
 938     reiserfs_update_inode_transaction(dir) ;
 939
 940     if (de.de_objectid != inode->i_ino) {
 941         // FIXME: compare key of an object and a key found in the
 942         // entry
 943         retval = -EIO;
 944         goto end_unlink;
 945     }
 946
 947     if (!inode->i_nlink) {
 948         reiserfs_warning (inode->i_sb, "%s: deleting nonexistent file "
 949                           "(%s:%lu), %d", __FUNCTION__,
 950                           reiserfs_bdevname (inode->i_sb), inode->i_ino,
 951                           inode->i_nlink);
 952         inode->i_nlink = 1;
 953     }
 954
 955     inode->i_nlink--;
 956
 957     /*
 958      * we schedule before doing the add_save_link call, save the link
 959      * count so we don't race
 960      */
 961     savelink = inode->i_nlink;
 962
 963
 964     retval = reiserfs_cut_from_item (&th, &path, &(de.de_entry_key), dir, NULL, 0);
 965     if (retval < 0) {
 966         inode->i_nlink++;
 967         goto end_unlink;
 968     }
 969     inode->i_ctime = CURRENT_TIME_SEC;
 970     reiserfs_update_sd (&th, inode);
 971
 972     dir->i_size -= (de.de_entrylen + DEH_SIZE);
 973     dir->i_ctime = dir->i_mtime = CURRENT_TIME_SEC;
 974     reiserfs_update_sd (&th, dir);
 975
 976     if (!savelink)
 977        /* prevent file from getting lost */
 978        add_save_link (&th, inode, 0/* not truncate */);
 979
 980     retval = journal_end(&th, dir->i_sb, jbegin_count) ;
 981     reiserfs_check_path(&path) ;
 982     reiserfs_write_unlock(dir->i_sb);
 983     return retval;
 984
 985  end_unlink:
 986     pathrelse (&path);
 987     err = journal_end(&th, dir->i_sb, jbegin_count) ;
 988     reiserfs_check_path(&path) ;
 989     if (err)
 990         retval = err;
 991 out_unlink:
 992     reiserfs_write_unlock(dir->i_sb);
 993     return retval;
 994 }
 995
 996 static int reiserfs_symlink (struct inode * parent_dir,
 997                             struct dentry * dentry, const char * symname)
 998 {
 999     int retval;
1000     struct inode * inode;
1001     char * name;
1002     int item_len;
1003     struct reiserfs_transaction_handle th ;
1004     int mode = S_IFLNK | S_IRWXUGO;
1005     /* We need blocks for transaction + (user+group)*(quotas for new inode + update of quota for directory owner) */
1006     int jbegin_count = JOURNAL_PER_BALANCE_CNT * 3 + 2 * (REISERFS_QUOTA_INIT_BLOCKS+REISERFS_QUOTA_TRANS_BLOCKS);
1007
1008     if (!(inode = new_inode(parent_dir->i_sb))) {
1009         return -ENOMEM ;
1010     }
1011     new_inode_init(inode, parent_dir, mode);
1012
1013     reiserfs_write_lock(parent_dir->i_sb);
1014     item_len = ROUND_UP (strlen (symname));
1015     if (item_len > MAX_DIRECT_ITEM_LEN (parent_dir->i_sb->s_blocksize)) {
1016         retval =  -ENAMETOOLONG;
1017         drop_new_inode(inode);
1018         goto out_failed;
1019     }
1020
1021     name = reiserfs_kmalloc (item_len, GFP_NOFS, parent_dir->i_sb);
1022     if (!name) {
1023         drop_new_inode(inode);
1024         retval =  -ENOMEM;
1025         goto out_failed;
1026     }
1027     memcpy (name, symname, strlen (symname));
1028     padd_item (name, item_len, strlen (symname));
1029
1030     /* We would inherit the default ACL here, but symlinks don't get ACLs */
1031
1032     retval = journal_begin(&th, parent_dir->i_sb, jbegin_count) ;
1033     if (retval) {
1034         drop_new_inode (inode);
1035         reiserfs_kfree (name, item_len, parent_dir->i_sb);
1036         goto out_failed;
1037     }
1038
1039     retval = reiserfs_new_inode (&th, parent_dir, mode, name, strlen (symname),
1040                                  dentry, inode);
1041     reiserfs_kfree (name, item_len, parent_dir->i_sb);
1042     if (retval) { /* reiserfs_new_inode iputs for us */
1043         goto out_failed;
1044     }
1045
1046     reiserfs_update_inode_transaction(inode) ;
1047     reiserfs_update_inode_transaction(parent_dir) ;
1048
1049     inode->i_op = &reiserfs_symlink_inode_operations;
1050     inode->i_mapping->a_ops = &reiserfs_address_space_operations;
1051
1052     // must be sure this inode is written with this transaction
1053     //
1054     //reiserfs_update_sd (&th, inode, READ_BLOCKS);
1055
1056     retval = reiserfs_add_entry (&th, parent_dir, dentry->d_name.name,
1057                                  dentry->d_name.len, inode, 1/*visible*/);
1058     if (retval) {
1059         int err;
1060         inode->i_nlink--;
1061         reiserfs_update_sd (&th, inode);
1062         err = journal_end(&th, parent_dir->i_sb, jbegin_count) ;
1063         if (err)
1064             retval = err;
1065         iput (inode);
1066         goto out_failed;
1067     }
1068
1069     d_instantiate(dentry, inode);
1070     retval = journal_end(&th, parent_dir->i_sb, jbegin_count) ;
1071 out_failed:
1072     reiserfs_write_unlock(parent_dir->i_sb);
1073     return retval;
1074 }
1075
1076 static int reiserfs_link (struct dentry * old_dentry, struct inode * dir, struct dentry * dentry)
1077 {
1078     int retval;
1079     struct inode *inode = old_dentry->d_inode;
1080     struct reiserfs_transaction_handle th ;
1081     /* We need blocks for transaction + update of quotas for the owners of the directory */
1082     int jbegin_count = JOURNAL_PER_BALANCE_CNT * 3 + 2 * REISERFS_QUOTA_TRANS_BLOCKS;
1083
1084     reiserfs_write_lock(dir->i_sb);
1085     if (inode->i_nlink >= REISERFS_LINK_MAX) {
1086         //FIXME: sd_nlink is 32 bit for new files
1087         reiserfs_write_unlock(dir->i_sb);
1088         return -EMLINK;
1089     }
1090     if (inode->i_nlink == 0) {
1091         reiserfs_write_unlock(dir->i_sb);
1092         return -ENOENT;
1093     }
1094
1095     /* inc before scheduling so reiserfs_unlink knows we are here */
1096     inode->i_nlink++;
1097
1098     retval = journal_begin(&th, dir->i_sb, jbegin_count) ;
1099     if (retval) {
1100         inode->i_nlink--;
1101         reiserfs_write_unlock (dir->i_sb);
1102         return retval;
1103     }
1104
1105     /* create new entry */
1106     retval = reiserfs_add_entry (&th, dir, dentry->d_name.name, dentry->d_name.len,
1107                                  inode, 1/*visible*/);
1108
1109     reiserfs_update_inode_transaction(inode) ;
1110     reiserfs_update_inode_transaction(dir) ;
1111
1112     if (retval) {
1113         int err;
1114         inode->i_nlink--;
1115         err = journal_end(&th, dir->i_sb, jbegin_count) ;
1116         reiserfs_write_unlock(dir->i_sb);
1117         return err ? err : retval;
1118     }
1119
1120     inode->i_ctime = CURRENT_TIME_SEC;
1121     reiserfs_update_sd (&th, inode);
1122
1123     atomic_inc(&inode->i_count) ;
1124     d_instantiate(dentry, inode);
1125     retval = journal_end(&th, dir->i_sb, jbegin_count) ;
1126     reiserfs_write_unlock(dir->i_sb);
1127     return retval;
1128 }
1129
1130
1131 // de contains information pointing to an entry which
1132 static int de_still_valid (const char * name, int len, struct reiserfs_dir_entry * de)
1133 {
1134     struct reiserfs_dir_entry tmp = *de;
1135
1136     // recalculate pointer to name and name length
1137     set_de_name_and_namelen (&tmp);
1138     // FIXME: could check more
1139     if (tmp.de_namelen != len || memcmp (name, de->de_name, len))
1140         return 0;
1141     return 1;
1142 }
1143
1144
1145 static int entry_points_to_object (const char * name, int len, struct reiserfs_dir_entry * de, struct inode * inode)
1146 {
1147     if (!de_still_valid (name, len, de))
1148         return 0;
1149
1150     if (inode) {
1151         if (!de_visible (de->de_deh + de->de_entry_num))
1152             reiserfs_panic (NULL, "vs-7042: entry_points_to_object: entry must be visible");
1153         return (de->de_objectid == inode->i_ino) ? 1 : 0;
1154     }
1155
1156     /* this must be added hidden entry */
1157     if (de_visible (de->de_deh + de->de_entry_num))
1158         reiserfs_panic (NULL, "vs-7043: entry_points_to_object: entry must be visible");
1159
1160     return 1;
1161 }
1162
1163
1164 /* sets key of objectid the entry has to point to */
1165 static void set_ino_in_dir_entry (struct reiserfs_dir_entry * de, struct reiserfs_key * key)
1166 {
1167     /* JDM These operations are endian safe - both are le */
1168     de->de_deh[de->de_entry_num].deh_dir_id = key->k_dir_id;
1169     de->de_deh[de->de_entry_num].deh_objectid = key->k_objectid;
1170 }
1171
1172
1173 /*
1174  * process, that is going to call fix_nodes/do_balance must hold only
1175  * one path. If it holds 2 or more, it can get into endless waiting in
1176  * get_empty_nodes or its clones
1177  */
1178 static int reiserfs_rename (struct inode * old_dir, struct dentry *old_dentry,
1179                             struct inode * new_dir, struct dentry *new_dentry)
1180 {
1181     int retval;
1182     INITIALIZE_PATH (old_entry_path);
1183     INITIALIZE_PATH (new_entry_path);
1184     INITIALIZE_PATH (dot_dot_entry_path);
1185     struct item_head new_entry_ih, old_entry_ih, dot_dot_ih ;
1186     struct reiserfs_dir_entry old_de, new_de, dot_dot_de;
1187     struct inode * old_inode, * new_dentry_inode;
1188     struct reiserfs_transaction_handle th ;
1189     int jbegin_count ;
1190     umode_t old_inode_mode;
1191     unsigned long savelink = 1;
1192     struct timespec ctime;
1193
1194     /* three balancings: (1) old name removal, (2) new name insertion
1195        and (3) maybe "save" link insertion
1196        stat data updates: (1) old directory,
1197        (2) new directory and (3) maybe old object stat data (when it is
1198        directory) and (4) maybe stat data of object to which new entry
1199        pointed initially and (5) maybe block containing ".." of
1200        renamed directory
1201        quota updates: two parent directories */
1202     jbegin_count = JOURNAL_PER_BALANCE_CNT * 3 + 5 + 4 * REISERFS_QUOTA_TRANS_BLOCKS;
1203
1204     old_inode = old_dentry->d_inode;
1205     new_dentry_inode = new_dentry->d_inode;
1206
1207     // make sure, that oldname still exists and points to an object we
1208     // are going to rename
1209     old_de.de_gen_number_bit_string = NULL;
1210     reiserfs_write_lock(old_dir->i_sb);
1211     retval = reiserfs_find_entry (old_dir, old_dentry->d_name.name, old_dentry->d_name.len,
1212                                   &old_entry_path, &old_de);
1213     pathrelse (&old_entry_path);
1214     if (retval == IO_ERROR) {
1215         reiserfs_write_unlock(old_dir->i_sb);
1216         return -EIO;
1217     }
1218
1219     if (retval != NAME_FOUND || old_de.de_objectid != old_inode->i_ino) {
1220         reiserfs_write_unlock(old_dir->i_sb);
1221         return -ENOENT;
1222     }
1223
1224     old_inode_mode = old_inode->i_mode;
1225     if (S_ISDIR(old_inode_mode)) {
1226         // make sure, that directory being renamed has correct ".."
1227         // and that its new parent directory has not too many links
1228         // already
1229
1230         if (new_dentry_inode) {
1231             if (!reiserfs_empty_dir(new_dentry_inode)) {
1232                 reiserfs_write_unlock(old_dir->i_sb);
1233                 return -ENOTEMPTY;
1234             }
1235         }
1236
1237         /* directory is renamed, its parent directory will be changed,
1238         ** so find ".." entry
1239         */
1240         dot_dot_de.de_gen_number_bit_string = NULL;
1241         retval = reiserfs_find_entry (old_inode, "..", 2, &dot_dot_entry_path, &dot_dot_de);
1242         pathrelse (&dot_dot_entry_path);
1243         if (retval != NAME_FOUND) {
1244             reiserfs_write_unlock(old_dir->i_sb);
1245             return -EIO;
1246         }
1247
1248         /* inode number of .. must equal old_dir->i_ino */
1249         if (dot_dot_de.de_objectid != old_dir->i_ino) {
1250             reiserfs_write_unlock(old_dir->i_sb);
1251             return -EIO;
1252         }
1253     }
1254
1255     retval = journal_begin(&th, old_dir->i_sb, jbegin_count) ;
1256     if (retval) {
1257         reiserfs_write_unlock (old_dir->i_sb);
1258         return retval;
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 ((retval = search_by_entry_key (new_dir->i_sb, &old_de.de_entry_key,
1289                                            &old_entry_path, &old_de)) != NAME_FOUND) {
1290             pathrelse(&old_entry_path);
1291             journal_end(&th, old_dir->i_sb, jbegin_count);
1292             reiserfs_write_unlock(old_dir->i_sb);
1293             return -EIO;
1294         }
1295
1296         copy_item_head(&old_entry_ih, get_ih(&old_entry_path)) ;
1297
1298         reiserfs_prepare_for_journal(old_inode->i_sb, old_de.de_bh, 1) ;
1299
1300         // look for new name by reiserfs_find_entry
1301         new_de.de_gen_number_bit_string = NULL;
1302         retval = reiserfs_find_entry (new_dir, new_dentry->d_name.name, new_dentry->d_name.len,
1303                                       &new_entry_path, &new_de);
1304         // reiserfs_add_entry should not return IO_ERROR, because it is called with essentially same parameters from
1305         // reiserfs_add_entry above, and we'll catch any i/o errors before we get here.
1306         if (retval != NAME_FOUND_INVISIBLE && retval != NAME_FOUND) {
1307             pathrelse(&new_entry_path);
1308             pathrelse(&old_entry_path);
1309             journal_end(&th, old_dir->i_sb, jbegin_count);
1310             reiserfs_write_unlock(old_dir->i_sb);
1311             return -EIO;
1312         }
1313
1314         copy_item_head(&new_entry_ih, get_ih(&new_entry_path)) ;
1315
1316         reiserfs_prepare_for_journal(old_inode->i_sb, new_de.de_bh, 1) ;
1317
1318         if (S_ISDIR(old_inode->i_mode)) {
1319             if ((retval = search_by_entry_key (new_dir->i_sb, &dot_dot_de.de_entry_key,
1320                                                &dot_dot_entry_path, &dot_dot_de)) != NAME_FOUND) {
1321                 pathrelse(&dot_dot_entry_path);
1322                 pathrelse(&new_entry_path);
1323                 pathrelse(&old_entry_path);
1324                 journal_end(&th, old_dir->i_sb, jbegin_count);
1325                 reiserfs_write_unlock(old_dir->i_sb);
1326                 return -EIO;
1327             }
1328             copy_item_head(&dot_dot_ih, get_ih(&dot_dot_entry_path)) ;
1329             // node containing ".." gets into transaction
1330             reiserfs_prepare_for_journal(old_inode->i_sb, dot_dot_de.de_bh, 1) ;
1331         }
1332                                 /* we should check seals here, not do
1333                                    this stuff, yes? Then, having
1334                                    gathered everything into RAM we
1335                                    should lock the buffers, yes?  -Hans */
1336                                 /* probably.  our rename needs to hold more
1337                                 ** than one path at once.  The seals would
1338                                 ** have to be written to deal with multi-path
1339                                 ** issues -chris
1340                                 */
1341         /* sanity checking before doing the rename - avoid races many
1342         ** of the above checks could have scheduled.  We have to be
1343         ** sure our items haven't been shifted by another process.
1344         */
1345         if (item_moved(&new_entry_ih, &new_entry_path) ||
1346             !entry_points_to_object(new_dentry->d_name.name,
1347                                     new_dentry->d_name.len,
1348                                     &new_de, new_dentry_inode) ||
1349             item_moved(&old_entry_ih, &old_entry_path) ||
1350             !entry_points_to_object (old_dentry->d_name.name,
1351                                      old_dentry->d_name.len,
1352                                      &old_de, old_inode)) {
1353             reiserfs_restore_prepared_buffer (old_inode->i_sb, new_de.de_bh);
1354             reiserfs_restore_prepared_buffer (old_inode->i_sb, old_de.de_bh);
1355             if (S_ISDIR(old_inode_mode))
1356                 reiserfs_restore_prepared_buffer (old_inode->i_sb, dot_dot_de.de_bh);
1357             continue;
1358         }
1359         if (S_ISDIR(old_inode_mode)) {
1360             if ( item_moved(&dot_dot_ih, &dot_dot_entry_path) ||
1361                 !entry_points_to_object ( "..", 2, &dot_dot_de, old_dir) ) {
1362                 reiserfs_restore_prepared_buffer (old_inode->i_sb, old_de.de_bh);
1363                 reiserfs_restore_prepared_buffer (old_inode->i_sb, new_de.de_bh);
1364                 reiserfs_restore_prepared_buffer (old_inode->i_sb, dot_dot_de.de_bh);
1365                 continue;
1366             }
1367         }
1368
1369         RFALSE( S_ISDIR(old_inode_mode) &&
1370                  !buffer_journal_prepared(dot_dot_de.de_bh), "" );
1371
1372         break;
1373     }
1374
1375     /* ok, all the changes can be done in one fell swoop when we
1376        have claimed all the buffers needed.*/
1377
1378     mark_de_visible (new_de.de_deh + new_de.de_entry_num);
1379     set_ino_in_dir_entry (&new_de, INODE_PKEY (old_inode));
1380     journal_mark_dirty (&th, old_dir->i_sb, new_de.de_bh);
1381
1382     mark_de_hidden (old_de.de_deh + old_de.de_entry_num);
1383     journal_mark_dirty (&th, old_dir->i_sb, old_de.de_bh);
1384     ctime = CURRENT_TIME_SEC;
1385     old_dir->i_ctime = old_dir->i_mtime = ctime;
1386     new_dir->i_ctime = new_dir->i_mtime = ctime;
1387     /* thanks to Alex Adriaanse <alex_a@caltech.edu> for patch which adds ctime update of
1388        renamed object */
1389     old_inode->i_ctime = ctime;
1390
1391     if (new_dentry_inode) {
1392         // adjust link number of the victim
1393         if (S_ISDIR(new_dentry_inode->i_mode)) {
1394             new_dentry_inode->i_nlink  = 0;
1395         } else {
1396             new_dentry_inode->i_nlink--;
1397         }
1398         new_dentry_inode->i_ctime = ctime;
1399         savelink = new_dentry_inode->i_nlink;
1400     }
1401
1402     if (S_ISDIR(old_inode_mode)) {
1403         // adjust ".." of renamed directory
1404         set_ino_in_dir_entry (&dot_dot_de, INODE_PKEY (new_dir));
1405         journal_mark_dirty (&th, new_dir->i_sb, dot_dot_de.de_bh);
1406
1407         if (!new_dentry_inode)
1408             /* there (in new_dir) was no directory, so it got new link
1409                (".."  of renamed directory) */
1410             INC_DIR_INODE_NLINK(new_dir);
1411
1412         /* old directory lost one link - ".. " of renamed directory */
1413         DEC_DIR_INODE_NLINK(old_dir);
1414     }
1415
1416     // looks like in 2.3.99pre3 brelse is atomic. so we can use pathrelse
1417     pathrelse (&new_entry_path);
1418     pathrelse (&dot_dot_entry_path);
1419
1420     // FIXME: this reiserfs_cut_from_item's return value may screw up
1421     // anybody, but it will panic if will not be able to find the
1422     // entry. This needs one more clean up
1423     if (reiserfs_cut_from_item (&th, &old_entry_path, &(old_de.de_entry_key), old_dir, NULL, 0) < 0)
1424         reiserfs_warning (old_dir->i_sb, "vs-7060: reiserfs_rename: couldn't not cut old name. Fsck later?");
1425
1426     old_dir->i_size -= DEH_SIZE + old_de.de_entrylen;
1427
1428     reiserfs_update_sd (&th, old_dir);
1429     reiserfs_update_sd (&th, new_dir);
1430     reiserfs_update_sd (&th, old_inode);
1431
1432     if (new_dentry_inode) {
1433         if (savelink == 0)
1434             add_save_link (&th, new_dentry_inode, 0/* not truncate */);
1435         reiserfs_update_sd (&th, new_dentry_inode);
1436     }
1437
1438     retval = journal_end(&th, old_dir->i_sb, jbegin_count) ;
1439     reiserfs_write_unlock(old_dir->i_sb);
1440     return retval;
1441 }
1442
1443 /*
1444  * directories can handle most operations...
1445  */
1446 struct inode_operations reiserfs_dir_inode_operations = {
1447   //&reiserfs_dir_operations,   /* default_file_ops */
1448     .create     = reiserfs_create,
1449     .lookup     = reiserfs_lookup,
1450     .link       = reiserfs_link,
1451     .unlink     = reiserfs_unlink,
1452     .symlink    = reiserfs_symlink,
1453     .mkdir      = reiserfs_mkdir,
1454     .rmdir      = reiserfs_rmdir,
1455     .mknod      = reiserfs_mknod,
1456     .rename     = reiserfs_rename,
1457     .setattr    = reiserfs_setattr,
1458     .setxattr   = reiserfs_setxattr,
1459     .getxattr   = reiserfs_getxattr,
1460     .listxattr  = reiserfs_listxattr,
1461     .removexattr = reiserfs_removexattr,
1462     .permission     = reiserfs_permission,
1463 };
1464
1465 /*
1466  * symlink operations.. same as page_symlink_inode_operations, with xattr
1467  * stuff added
1468  */
1469 struct inode_operations reiserfs_symlink_inode_operations = {
1470     .readlink       = generic_readlink,
1471     .follow_link    = page_follow_link_light,
1472     .put_link       = page_put_link,
1473     .setattr        = reiserfs_setattr,
1474     .setxattr       = reiserfs_setxattr,
1475     .getxattr       = reiserfs_getxattr,
1476     .listxattr      = reiserfs_listxattr,
1477     .removexattr    = reiserfs_removexattr,
1478     .permission     = reiserfs_permission,
1479
1480 };
1481
1482
1483 /*
1484  * special file operations.. just xattr/acl stuff
1485  */
1486 struct inode_operations reiserfs_special_inode_operations = {
1487     .setattr        = reiserfs_setattr,
1488     .setxattr       = reiserfs_setxattr,
1489     .getxattr       = reiserfs_getxattr,
1490     .listxattr      = reiserfs_listxattr,
1491     .removexattr    = reiserfs_removexattr,
1492     .permission     = reiserfs_permission,
1493
1494 };