SAFE public projects git trees. - safe/jmp/linux-2.6/blob - fs/reiserfs/namei.c

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