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