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