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