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