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