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