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