/*
 * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README
 *
 * Trivial changes by Alan Cox to remove EHASHCOLLISION for compatibility
 *
 * Trivial Changes:
 * Rights granted to Hans Reiser to redistribute under other terms providing
 * he accepts all liability including but not limited to patent, fitness
 * for purpose, and direct or indirect claims arising from failure to perform.
 *
 * NO WARRANTY
 */

#include <linux/time.h>
#include <linux/bitops.h>
#include <linux/slab.h>
#include "reiserfs.h"
#include "acl.h"
#include "xattr.h"
#include <linux/quotaops.h>

#define INC_DIR_INODE_NLINK(i) if (i->i_nlink != 1) { inc_nlink(i); if (i->i_nlink >= REISERFS_LINK_MAX) set_nlink(i, 1); }
#define DEC_DIR_INODE_NLINK(i) if (i->i_nlink != 1) drop_nlink(i);

/*
 * directory item contains array of entry headers. This performs
 * binary search through that array
 */
static int bin_search_in_dir_item(struct reiserfs_dir_entry *de, loff_t off)
{
        struct item_head *ih = de->de_ih;
        struct reiserfs_de_head *deh = de->de_deh;
        int rbound, lbound, j;

        lbound = 0;
        rbound = ih_entry_count(ih) - 1;

        for (j = (rbound + lbound) / 2; lbound <= rbound;
             j = (rbound + lbound) / 2) {
                if (off < deh_offset(deh + j)) {
                        rbound = j - 1;
                        continue;
                }
                if (off > deh_offset(deh + j)) {
                        lbound = j + 1;
                        continue;
                }
                /* this is not name found, but matched third key component */
                de->de_entry_num = j;
                return NAME_FOUND;
        }

        de->de_entry_num = lbound;
        return NAME_NOT_FOUND;
}

/*
 * comment?  maybe something like set de to point to what the path points to?
 */
static inline void set_de_item_location(struct reiserfs_dir_entry *de,
                                        struct treepath *path)
{
        de->de_bh = get_last_bh(path);
        de->de_ih = tp_item_head(path);
        de->de_deh = B_I_DEH(de->de_bh, de->de_ih);
        de->de_item_num = PATH_LAST_POSITION(path);
}

/*
 * de_bh, de_ih, de_deh (points to first element of array), de_item_num is set
 */
inline void set_de_name_and_namelen(struct reiserfs_dir_entry *de)
{
        struct reiserfs_de_head *deh = de->de_deh + de->de_entry_num;

        BUG_ON(de->de_entry_num >= ih_entry_count(de->de_ih));

        de->de_entrylen = entry_length(de->de_bh, de->de_ih, de->de_entry_num);
        de->de_namelen = de->de_entrylen - (de_with_sd(deh) ? SD_SIZE : 0);
        de->de_name = ih_item_body(de->de_bh, de->de_ih) + deh_location(deh);
        if (de->de_name[de->de_namelen - 1] == 0)
                de->de_namelen = strlen(de->de_name);
}

/* what entry points to */
static inline void set_de_object_key(struct reiserfs_dir_entry *de)
{
        BUG_ON(de->de_entry_num >= ih_entry_count(de->de_ih));
        de->de_dir_id = deh_dir_id(&de->de_deh[de->de_entry_num]);
        de->de_objectid = deh_objectid(&de->de_deh[de->de_entry_num]);
}

static inline void store_de_entry_key(struct reiserfs_dir_entry *de)
{
        struct reiserfs_de_head *deh = de->de_deh + de->de_entry_num;

        BUG_ON(de->de_entry_num >= ih_entry_count(de->de_ih));

        /* store key of the found entry */
        de->de_entry_key.version = KEY_FORMAT_3_5;
        de->de_entry_key.on_disk_key.k_dir_id =
            le32_to_cpu(de->de_ih->ih_key.k_dir_id);
        de->de_entry_key.on_disk_key.k_objectid =
            le32_to_cpu(de->de_ih->ih_key.k_objectid);
        set_cpu_key_k_offset(&de->de_entry_key, deh_offset(deh));
        set_cpu_key_k_type(&de->de_entry_key, TYPE_DIRENTRY);
}

/*
 * We assign a key to each directory item, and place multiple entries in a
 * single directory item.  A directory item has a key equal to the key of
 * the first directory entry in it.

 * This function first calls search_by_key, then, if item whose first entry
 * matches is not found it looks for the entry inside directory item found
 * by search_by_key. Fills the path to the entry, and to the entry position
 * in the item
 */
/* The function is NOT SCHEDULE-SAFE! */
int search_by_entry_key(struct super_block *sb, const struct cpu_key *key,
                        struct treepath *path, struct reiserfs_dir_entry *de)
{
        int retval;

        retval = search_item(sb, key, path);
        switch (retval) {
        case ITEM_NOT_FOUND:
                if (!PATH_LAST_POSITION(path)) {
                        reiserfs_error(sb, "vs-7000", "search_by_key "
                                       "returned item position == 0");
                        pathrelse(path);
                        return IO_ERROR;
                }
                PATH_LAST_POSITION(path)--;

        case ITEM_FOUND:
                break;

        case IO_ERROR:
                return retval;

        default:
                pathrelse(path);
                reiserfs_error(sb, "vs-7002", "no path to here");
                return IO_ERROR;
        }

        set_de_item_location(de, path);

#ifdef CONFIG_REISERFS_CHECK
        if (!is_direntry_le_ih(de->de_ih) ||
            COMP_SHORT_KEYS(&de->de_ih->ih_key, key)) {
                print_block(de->de_bh, 0, -1, -1);
                reiserfs_panic(sb, "vs-7005", "found item %h is not directory "
                               "item or does not belong to the same directory "
                               "as key %K", de->de_ih, key);
        }
#endif                          /* CONFIG_REISERFS_CHECK */

        /*
         * binary search in directory item by third component of the
         * key. sets de->de_entry_num of de
         */
        retval = bin_search_in_dir_item(de, cpu_key_k_offset(key));
        path->pos_in_item = de->de_entry_num;
        if (retval != NAME_NOT_FOUND) {
                /*
                 * ugly, but rename needs de_bh, de_deh, de_name,
                 * de_namelen, de_objectid set
                 */
                set_de_name_and_namelen(de);
                set_de_object_key(de);
        }
        return retval;
}

/* Keyed 32-bit hash function using TEA in a Davis-Meyer function */

/*
 * The third component is hashed, and you can choose from more than
 * one hash function.  Per directory hashes are not yet implemented
 * but are thought about. This function should be moved to hashes.c
 * Jedi, please do so.  -Hans
 */
static __u32 get_third_component(struct super_block *s,
                                 const char *name, int len)
{
        __u32 res;

        if (!len || (len == 1 && name[0] == '.'))
                return DOT_OFFSET;
        if (len == 2 && name[0] == '.' && name[1] == '.')
                return DOT_DOT_OFFSET;

        res = REISERFS_SB(s)->s_hash_function(name, len);

        /* take bits from 7-th to 30-th including both bounds */
        res = GET_HASH_VALUE(res);
        if (res == 0)
                /*
                 * needed to have no names before "." and ".." those have hash
                 * value == 0 and generation conters 1 and 2 accordingly
                 */
                res = 128;
        return res + MAX_GENERATION_NUMBER;
}

static int reiserfs_match(struct reiserfs_dir_entry *de,
                          const char *name, int namelen)
{
        int retval = NAME_NOT_FOUND;

        if ((namelen == de->de_namelen) &&
            !memcmp(de->de_name, name, de->de_namelen))
                retval =
                    (de_visible(de->de_deh + de->de_entry_num) ? NAME_FOUND :
                     NAME_FOUND_INVISIBLE);

        return retval;
}

/* de's de_bh, de_ih, de_deh, de_item_num, de_entry_num are set already */

/* used when hash collisions exist */

static int linear_search_in_dir_item(struct cpu_key *key,
                                     struct reiserfs_dir_entry *de,
                                     const char *name, int namelen)
{
        struct reiserfs_de_head *deh = de->de_deh;
        int retval;
        int i;

        i = de->de_entry_num;

        if (i == ih_entry_count(de->de_ih) ||
            GET_HASH_VALUE(deh_offset(deh + i)) !=
            GET_HASH_VALUE(cpu_key_k_offset(key))) {
                i--;
        }

        RFALSE(de->de_deh != B_I_DEH(de->de_bh, de->de_ih),
               "vs-7010: array of entry headers not found");

        deh += i;

        for (; i >= 0; i--, deh--) {
                /* hash value does not match, no need to check whole name */
                if (GET_HASH_VALUE(deh_offset(deh)) !=
                    GET_HASH_VALUE(cpu_key_k_offset(key))) {
                        return NAME_NOT_FOUND;
                }

                /* mark that this generation number is used */
                if (de->de_gen_number_bit_string)
                        set_bit(GET_GENERATION_NUMBER(deh_offset(deh)),
                                de->de_gen_number_bit_string);

                /* calculate pointer to name and namelen */
                de->de_entry_num = i;
                set_de_name_and_namelen(de);

                /*
                 * de's de_name, de_namelen, de_recordlen are set.
                 * Fill the rest.
                 */
                if ((retval =
                     reiserfs_match(de, name, namelen)) != NAME_NOT_FOUND) {

                        /* key of pointed object */
                        set_de_object_key(de);

                        store_de_entry_key(de);

                        /* retval can be NAME_FOUND or NAME_FOUND_INVISIBLE */
                        return retval;
                }
        }

        if (GET_GENERATION_NUMBER(le_ih_k_offset(de->de_ih)) == 0)
                /*
                 * we have reached left most entry in the node. In common we
                 * have to go to the left neighbor, but if generation counter
                 * is 0 already, we know for sure, that there is no name with
                 * the same hash value
                 */
                /*
                 * FIXME: this work correctly only because hash value can not
                 *  be 0. Btw, in case of Yura's hash it is probably possible,
                 * so, this is a bug
                 */
                return NAME_NOT_FOUND;

        RFALSE(de->de_item_num,
               "vs-7015: two diritems of the same directory in one node?");

        return GOTO_PREVIOUS_ITEM;
}

/*
 * may return NAME_FOUND, NAME_FOUND_INVISIBLE, NAME_NOT_FOUND
 * FIXME: should add something like IOERROR
 */
static int reiserfs_find_entry(struct inode *dir, const char *name, int namelen,
                               struct treepath *path_to_entry,
                               struct reiserfs_dir_entry *de)
{
        struct cpu_key key_to_search;
        int retval;

        if (namelen > REISERFS_MAX_NAME(dir->i_sb->s_blocksize))
                return NAME_NOT_FOUND;

        /* we will search for this key in the tree */
        make_cpu_key(&key_to_search, dir,
                     get_third_component(dir->i_sb, name, namelen),
                     TYPE_DIRENTRY, 3);

        while (1) {
                retval =
                    search_by_entry_key(dir->i_sb, &key_to_search,
                                        path_to_entry, de);
                if (retval == IO_ERROR) {
                        reiserfs_error(dir->i_sb, "zam-7001", "io error");
                        return IO_ERROR;
                }

                /* compare names for all entries having given hash value */
                retval =
                    linear_search_in_dir_item(&key_to_search, de, name,
                                              namelen);
                /*
                 * there is no need to scan directory anymore.
                 * Given entry found or does not exist
                 */
                if (retval != GOTO_PREVIOUS_ITEM) {
                        path_to_entry->pos_in_item = de->de_entry_num;
                        return retval;
                }

                /*
                 * there is left neighboring item of this directory
                 * and given entry can be there
                 */
                set_cpu_key_k_offset(&key_to_search,
                                     le_ih_k_offset(de->de_ih) - 1);
                pathrelse(path_to_entry);

        }                       /* while (1) */
}

static struct dentry *reiserfs_lookup(struct inode *dir, struct dentry *dentry,
                                      unsigned int flags)
{
        int retval;
        struct inode *inode = NULL;
        struct reiserfs_dir_entry de;
        INITIALIZE_PATH(path_to_entry);

        if (REISERFS_MAX_NAME(dir->i_sb->s_blocksize) < dentry->d_name.len)
                return ERR_PTR(-ENAMETOOLONG);

        reiserfs_write_lock(dir->i_sb);

        de.de_gen_number_bit_string = NULL;
        retval =
            reiserfs_find_entry(dir, dentry->d_name.name, dentry->d_name.len,
                                &path_to_entry, &de);
        pathrelse(&path_to_entry);
        if (retval == NAME_FOUND) {
                inode = reiserfs_iget(dir->i_sb,
                                      (struct cpu_key *)&de.de_dir_id);
                if (!inode || IS_ERR(inode)) {
                        reiserfs_write_unlock(dir->i_sb);
                        return ERR_PTR(-EACCES);
                }

                /*
                 * Propagate the private flag so we know we're
                 * in the priv tree
                 */
                if (IS_PRIVATE(dir))
                        inode->i_flags |= S_PRIVATE;
        }
        reiserfs_write_unlock(dir->i_sb);
        if (retval == IO_ERROR) {
                return ERR_PTR(-EIO);
        }

        return d_splice_alias(inode, dentry);
}

/*
 * looks up the dentry of the parent directory for child.
 * taken from ext2_get_parent
 */
struct dentry *reiserfs_get_parent(struct dentry *child)
{
        int retval;
        struct inode *inode = NULL;
        struct reiserfs_dir_entry de;
        INITIALIZE_PATH(path_to_entry);
        struct inode *dir = d_inode(child);

        if (dir->i_nlink == 0) {
                return ERR_PTR(-ENOENT);
        }
        de.de_gen_number_bit_string = NULL;

        reiserfs_write_lock(dir->i_sb);
        retval = reiserfs_find_entry(dir, "..", 2, &path_to_entry, &de);
        pathrelse(&path_to_entry);
        if (retval != NAME_FOUND) {
                reiserfs_write_unlock(dir->i_sb);
                return ERR_PTR(-ENOENT);
        }
        inode = reiserfs_iget(dir->i_sb, (struct cpu_key *)&de.de_dir_id);
        reiserfs_write_unlock(dir->i_sb);

        return d_obtain_alias(inode);
}

/* add entry to the directory (entry can be hidden).

insert definition of when hidden directories are used here -Hans

 Does not mark dir   inode dirty, do it after successesfull call to it */

static int reiserfs_add_entry(struct reiserfs_transaction_handle *th,
                              struct inode *dir, const char *name, int namelen,
                              struct inode *inode, int visible)
{
        struct cpu_key entry_key;
        struct reiserfs_de_head *deh;
        INITIALIZE_PATH(path);
        struct reiserfs_dir_entry de;
        DECLARE_BITMAP(bit_string, MAX_GENERATION_NUMBER + 1);
        int gen_number;

        /*
         * 48 bytes now and we avoid kmalloc if we
         * create file with short name
         */
        char small_buf[32 + DEH_SIZE];

        char *buffer;
        int buflen, paste_size;
        int retval;

        BUG_ON(!th->t_trans_id);

        /* cannot allow items to be added into a busy deleted directory */
        if (!namelen)
                return -EINVAL;

        if (namelen > REISERFS_MAX_NAME(dir->i_sb->s_blocksize))
                return -ENAMETOOLONG;

        /* each entry has unique key. compose it */
        make_cpu_key(&entry_key, dir,
                     get_third_component(dir->i_sb, name, namelen),
                     TYPE_DIRENTRY, 3);

        /* get memory for composing the entry */
        buflen = DEH_SIZE + ROUND_UP(namelen);
        if (buflen > sizeof(small_buf)) {
                buffer = kmalloc(buflen, GFP_NOFS);
                if (!buffer)
                        return -ENOMEM;
        } else
                buffer = small_buf;

        paste_size =
            (get_inode_sd_version(dir) ==
             STAT_DATA_V1) ? (DEH_SIZE + namelen) : buflen;

        /*
         * fill buffer : directory entry head, name[, dir objectid | ,
         * stat data | ,stat data, dir objectid ]
         */
        deh = (struct reiserfs_de_head *)buffer;
        deh->deh_location = 0;  /* JDM Endian safe if 0 */
        put_deh_offset(deh, cpu_key_k_offset(&entry_key));
        deh->deh_state = 0;     /* JDM Endian safe if 0 */
        /* put key (ino analog) to de */

        /* safe: k_dir_id is le */
        deh->deh_dir_id = INODE_PKEY(inode)->k_dir_id;
        /* safe: k_objectid is le */
        deh->deh_objectid = INODE_PKEY(inode)->k_objectid;

        /* copy name */
        memcpy((char *)(deh + 1), name, namelen);
        /* padd by 0s to the 4 byte boundary */
        padd_item((char *)(deh + 1), ROUND_UP(namelen), namelen);

        /*
         * entry is ready to be pasted into tree, set 'visibility'
         * and 'stat data in entry' attributes
         */
        mark_de_without_sd(deh);
        visible ? mark_de_visible(deh) : mark_de_hidden(deh);

        /* find the proper place for the new entry */
        memset(bit_string, 0, sizeof(bit_string));
        de.de_gen_number_bit_string = bit_string;
        retval = reiserfs_find_entry(dir, name, namelen, &path, &de);
        if (retval != NAME_NOT_FOUND) {
                if (buffer != small_buf)
                        kfree(buffer);
                pathrelse(&path);

                if (retval == IO_ERROR) {
                        return -EIO;
                }

                if (retval != NAME_FOUND) {
                        reiserfs_error(dir->i_sb, "zam-7002",
                                       "reiserfs_find_entry() returned "
                                       "unexpected value (%d)", retval);
                }

                return -EEXIST;
        }

        gen_number =
            find_first_zero_bit(bit_string,
                                MAX_GENERATION_NUMBER + 1);
        if (gen_number > MAX_GENERATION_NUMBER) {
                /* there is no free generation number */
                reiserfs_warning(dir->i_sb, "reiserfs-7010",
                                 "Congratulations! we have got hash function "
                                 "screwed up");
                if (buffer != small_buf)
                        kfree(buffer);
                pathrelse(&path);
                return -EBUSY;
        }
        /* adjust offset of directory enrty */
        put_deh_offset(deh, SET_GENERATION_NUMBER(deh_offset(deh), gen_number));
        set_cpu_key_k_offset(&entry_key, deh_offset(deh));

        /* update max-hash-collisions counter in reiserfs_sb_info */
        PROC_INFO_MAX(th->t_super, max_hash_collisions, gen_number);

        /* we need to re-search for the insertion point */
        if (gen_number != 0) {
                if (search_by_entry_key(dir->i_sb, &entry_key, &path, &de) !=
                    NAME_NOT_FOUND) {
                        reiserfs_warning(dir->i_sb, "vs-7032",
                                         "entry with this key (%K) already "
                                         "exists", &entry_key);

                        if (buffer != small_buf)
                                kfree(buffer);
                        pathrelse(&path);
                        return -EBUSY;
                }
        }

        /* perform the insertion of the entry that we have prepared */
        retval =
            reiserfs_paste_into_item(th, &path, &entry_key, dir, buffer,
                                     paste_size);
        if (buffer != small_buf)
                kfree(buffer);
        if (retval) {
                reiserfs_check_path(&path);
                return retval;
        }

        dir->i_size += paste_size;
        dir->i_mtime = dir->i_ctime = current_time(dir);
        if (!S_ISDIR(inode->i_mode) && visible)
                /* reiserfs_mkdir or reiserfs_rename will do that by itself */
                reiserfs_update_sd(th, dir);

        reiserfs_check_path(&path);
        return 0;
}

/*
 * quota utility function, call if you've had to abort after calling
 * new_inode_init, and have not called reiserfs_new_inode yet.
 * This should only be called on inodes that do not have stat data
 * inserted into the tree yet.
 */
static int drop_new_inode(struct inode *inode)
{
        dquot_drop(inode);
        make_bad_inode(inode);
        inode->i_flags |= S_NOQUOTA;
        iput(inode);
        return 0;
}

/*
 * utility function that does setup for reiserfs_new_inode.
 * dquot_initialize needs lots of credits so it's better to have it
 * outside of a transaction, so we had to pull some bits of
 * reiserfs_new_inode out into this func.
 */
static int new_inode_init(struct inode *inode, struct inode *dir, umode_t mode)
{
        /*
         * Make inode invalid - just in case we are going to drop it before
         * the initialization happens
         */
        INODE_PKEY(inode)->k_objectid = 0;

        /*
         * the quota init calls have to know who to charge the quota to, so
         * we have to set uid and gid here
         */
        inode_init_owner(inode, dir, mode);
        return dquot_initialize(inode);
}

static int reiserfs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
                           bool excl)
{
        int retval;
        struct inode *inode;
        /*
         * We need blocks for transaction + (user+group)*(quotas
         * for new inode + update of quota for directory owner)
         */
        int jbegin_count =
            JOURNAL_PER_BALANCE_CNT * 2 +
            2 * (REISERFS_QUOTA_INIT_BLOCKS(dir->i_sb) +
                 REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb));
        struct reiserfs_transaction_handle th;
        struct reiserfs_security_handle security;

        retval = dquot_initialize(dir);
        if (retval)
                return retval;

        if (!(inode = new_inode(dir->i_sb))) {
                return -ENOMEM;
        }
        retval = new_inode_init(inode, dir, mode);
        if (retval) {
                drop_new_inode(inode);
                return retval;
        }

        jbegin_count += reiserfs_cache_default_acl(dir);
        retval = reiserfs_security_init(dir, inode, &dentry->d_name, &security);
        if (retval < 0) {
                drop_new_inode(inode);
                return retval;
        }
        jbegin_count += retval;
        reiserfs_write_lock(dir->i_sb);

        retval = journal_begin(&th, dir->i_sb, jbegin_count);
        if (retval) {
                drop_new_inode(inode);
                goto out_failed;
        }

        retval =
            reiserfs_new_inode(&th, dir, mode, NULL, 0 /*i_size */ , dentry,
                               inode, &security);
        if (retval)
                goto out_failed;

        inode->i_op = &reiserfs_file_inode_operations;
        inode->i_fop = &reiserfs_file_operations;
        inode->i_mapping->a_ops = &reiserfs_address_space_operations;

        retval =
            reiserfs_add_entry(&th, dir, dentry->d_name.name,
                               dentry->d_name.len, inode, 1 /*visible */ );
        if (retval) {
                int err;
                drop_nlink(inode);
                reiserfs_update_sd(&th, inode);
                err = journal_end(&th);
                if (err)
                        retval = err;
                unlock_new_inode(inode);
                iput(inode);
                goto out_failed;
        }
        reiserfs_update_inode_transaction(inode);
        reiserfs_update_inode_transaction(dir);

        d_instantiate_new(dentry, inode);
        retval = journal_end(&th);

out_failed:
        reiserfs_write_unlock(dir->i_sb);
        return retval;
}

static int reiserfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode,
                          dev_t rdev)
{
        int retval;
        struct inode *inode;
        struct reiserfs_transaction_handle th;
        struct reiserfs_security_handle security;
        /*
         * We need blocks for transaction + (user+group)*(quotas
         * for new inode + update of quota for directory owner)
         */
        int jbegin_count =
            JOURNAL_PER_BALANCE_CNT * 3 +
            2 * (REISERFS_QUOTA_INIT_BLOCKS(dir->i_sb) +
                 REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb));

        retval = dquot_initialize(dir);
        if (retval)
                return retval;

        if (!(inode = new_inode(dir->i_sb))) {
                return -ENOMEM;
        }
        retval = new_inode_init(inode, dir, mode);
        if (retval) {
                drop_new_inode(inode);
                return retval;
        }

        jbegin_count += reiserfs_cache_default_acl(dir);
        retval = reiserfs_security_init(dir, inode, &dentry->d_name, &security);
        if (retval < 0) {
                drop_new_inode(inode);
                return retval;
        }
        jbegin_count += retval;
        reiserfs_write_lock(dir->i_sb);

        retval = journal_begin(&th, dir->i_sb, jbegin_count);
        if (retval) {
                drop_new_inode(inode);
                goto out_failed;
        }

        retval =
            reiserfs_new_inode(&th, dir, mode, NULL, 0 /*i_size */ , dentry,
                               inode, &security);
        if (retval) {
                goto out_failed;
        }

        inode->i_op = &reiserfs_special_inode_operations;
        init_special_inode(inode, inode->i_mode, rdev);

        /* FIXME: needed for block and char devices only */
        reiserfs_update_sd(&th, inode);

        reiserfs_update_inode_transaction(inode);
        reiserfs_update_inode_transaction(dir);

        retval =
            reiserfs_add_entry(&th, dir, dentry->d_name.name,
                               dentry->d_name.len, inode, 1 /*visible */ );
        if (retval) {
                int err;
                drop_nlink(inode);
                reiserfs_update_sd(&th, inode);
                err = journal_end(&th);
                if (err)
                        retval = err;
                unlock_new_inode(inode);
                iput(inode);
                goto out_failed;
        }

        d_instantiate_new(dentry, inode);
        retval = journal_end(&th);

out_failed:
        reiserfs_write_unlock(dir->i_sb);
        return retval;
}

static int reiserfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
{
        int retval;
        struct inode *inode;
        struct reiserfs_transaction_handle th;
        struct reiserfs_security_handle security;
        /*
         * We need blocks for transaction + (user+group)*(quotas
         * for new inode + update of quota for directory owner)
         */
        int jbegin_count =
            JOURNAL_PER_BALANCE_CNT * 3 +
            2 * (REISERFS_QUOTA_INIT_BLOCKS(dir->i_sb) +
                 REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb));

        retval = dquot_initialize(dir);
        if (retval)
                return retval;

#ifdef DISPLACE_NEW_PACKING_LOCALITIES
        /*
         * set flag that new packing locality created and new blocks
         * for the content of that directory are not displaced yet
         */
        REISERFS_I(dir)->new_packing_locality = 1;
#endif
        mode = S_IFDIR | mode;
        if (!(inode = new_inode(dir->i_sb))) {
                return -ENOMEM;
        }
        retval = new_inode_init(inode, dir, mode);
        if (retval) {
                drop_new_inode(inode);
                return retval;
        }

        jbegin_count += reiserfs_cache_default_acl(dir);
        retval = reiserfs_security_init(dir, inode, &dentry->d_name, &security);
        if (retval < 0) {
                drop_new_inode(inode);
                return retval;
        }
        jbegin_count += retval;
        reiserfs_write_lock(dir->i_sb);

        retval = journal_begin(&th, dir->i_sb, jbegin_count);
        if (retval) {
                drop_new_inode(inode);
                goto out_failed;
        }

        /*
         * inc the link count now, so another writer doesn't overflow
         * it while we sleep later on.
         */
        INC_DIR_INODE_NLINK(dir)

            retval = reiserfs_new_inode(&th, dir, mode, NULL /*symlink */ ,
                                        old_format_only(dir->i_sb) ?
                                        EMPTY_DIR_SIZE_V1 : EMPTY_DIR_SIZE,
                                        dentry, inode, &security);
        if (retval) {
                DEC_DIR_INODE_NLINK(dir)
                goto out_failed;
        }

        reiserfs_update_inode_transaction(inode);
        reiserfs_update_inode_transaction(dir);

        inode->i_op = &reiserfs_dir_inode_operations;
        inode->i_fop = &reiserfs_dir_operations;

        /* note, _this_ add_entry will not update dir's stat data */
        retval =
            reiserfs_add_entry(&th, dir, dentry->d_name.name,
                               dentry->d_name.len, inode, 1 /*visible */ );
        if (retval) {
                int err;
                clear_nlink(inode);
                DEC_DIR_INODE_NLINK(dir);
                reiserfs_update_sd(&th, inode);
                err = journal_end(&th);
                if (err)
                        retval = err;
                unlock_new_inode(inode);
                iput(inode);
                goto out_failed;
        }
        /* the above add_entry did not update dir's stat data */
        reiserfs_update_sd(&th, dir);

        d_instantiate_new(dentry, inode);
        retval = journal_end(&th);
out_failed:
        reiserfs_write_unlock(dir->i_sb);
        return retval;
}

static inline int reiserfs_empty_dir(struct inode *inode)
{
        /*
         * we can cheat because an old format dir cannot have
         * EMPTY_DIR_SIZE, and a new format dir cannot have
         * EMPTY_DIR_SIZE_V1.  So, if the inode is either size,
         * regardless of disk format version, the directory is empty.
         */
        if (inode->i_size != EMPTY_DIR_SIZE &&
            inode->i_size != EMPTY_DIR_SIZE_V1) {
                return 0;
        }
        return 1;
}

static int reiserfs_rmdir(struct inode *dir, struct dentry *dentry)
{
        int retval, err;
        struct inode *inode;
        struct reiserfs_transaction_handle th;
        int jbegin_count;
        INITIALIZE_PATH(path);
        struct reiserfs_dir_entry de;

        /*
         * we will be doing 2 balancings and update 2 stat data, we
         * change quotas of the owner of the directory and of the owner
         * of the parent directory.  The quota structure is possibly
         * deleted only on last iput => outside of this transaction
         */
        jbegin_count =
            JOURNAL_PER_BALANCE_CNT * 2 + 2 +
            4 * REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb);

        retval = dquot_initialize(dir);
        if (retval)
                return retval;

        reiserfs_write_lock(dir->i_sb);
        retval = journal_begin(&th, dir->i_sb, jbegin_count);
        if (retval)
                goto out_rmdir;

        de.de_gen_number_bit_string = NULL;
        if ((retval =
             reiserfs_find_entry(dir, dentry->d_name.name, dentry->d_name.len,
                                 &path, &de)) == NAME_NOT_FOUND) {
                retval = -ENOENT;
                goto end_rmdir;
        } else if (retval == IO_ERROR) {
                retval = -EIO;
                goto end_rmdir;
        }

        inode = d_inode(dentry);

        reiserfs_update_inode_transaction(inode);
        reiserfs_update_inode_transaction(dir);

        if (de.de_objectid != inode->i_ino) {
                /*
                 * FIXME: compare key of an object and a key found in the entry
                 */
                retval = -EIO;
                goto end_rmdir;
        }
        if (!reiserfs_empty_dir(inode)) {
                retval = -ENOTEMPTY;
                goto end_rmdir;
        }

        /* cut entry from dir directory */
        retval = reiserfs_cut_from_item(&th, &path, &de.de_entry_key,
                                        dir, NULL,      /* page */
                                        0 /*new file size - not used here */ );
        if (retval < 0)
                goto end_rmdir;

        if (inode->i_nlink != 2 && inode->i_nlink != 1)
                reiserfs_error(inode->i_sb, "reiserfs-7040",
                               "empty directory has nlink != 2 (%d)",
                               inode->i_nlink);

        clear_nlink(inode);
        inode->i_ctime = dir->i_ctime = dir->i_mtime = current_time(dir);
        reiserfs_update_sd(&th, inode);

        DEC_DIR_INODE_NLINK(dir)
            dir->i_size -= (DEH_SIZE + de.de_entrylen);
        reiserfs_update_sd(&th, dir);

        /* prevent empty directory from getting lost */
        add_save_link(&th, inode, 0 /* not truncate */ );

        retval = journal_end(&th);
        reiserfs_check_path(&path);
out_rmdir:
        reiserfs_write_unlock(dir->i_sb);
        return retval;

end_rmdir:
        /*
         * we must release path, because we did not call
         * reiserfs_cut_from_item, or reiserfs_cut_from_item does not
         * release path if operation was not complete
         */
        pathrelse(&path);
        err = journal_end(&th);
        reiserfs_write_unlock(dir->i_sb);
        return err ? err : retval;
}

static int reiserfs_unlink(struct inode *dir, struct dentry *dentry)
{
        int retval, err;
        struct inode *inode;
        struct reiserfs_dir_entry de;
        INITIALIZE_PATH(path);
        struct reiserfs_transaction_handle th;
        int jbegin_count;
        unsigned long savelink;

        retval = dquot_initialize(dir);
        if (retval)
                return retval;

        inode = d_inode(dentry);

        /*
         * in this transaction we can be doing at max two balancings and
         * update two stat datas, we change quotas of the owner of the
         * directory and of the owner of the parent directory. The quota
         * structure is possibly deleted only on iput => outside of
         * this transaction
         */
        jbegin_count =
            JOURNAL_PER_BALANCE_CNT * 2 + 2 +
            4 * REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb);

        reiserfs_write_lock(dir->i_sb);
        retval = journal_begin(&th, dir->i_sb, jbegin_count);
        if (retval)
                goto out_unlink;

        de.de_gen_number_bit_string = NULL;
        if ((retval =
             reiserfs_find_entry(dir, dentry->d_name.name, dentry->d_name.len,
                                 &path, &de)) == NAME_NOT_FOUND) {
                retval = -ENOENT;
                goto end_unlink;
        } else if (retval == IO_ERROR) {
                retval = -EIO;
                goto end_unlink;
        }

        reiserfs_update_inode_transaction(inode);
        reiserfs_update_inode_transaction(dir);

        if (de.de_objectid != inode->i_ino) {
                /*
                 * FIXME: compare key of an object and a key found in the entry
                 */
                retval = -EIO;
                goto end_unlink;
        }

        if (!inode->i_nlink) {
                reiserfs_warning(inode->i_sb, "reiserfs-7042",
                                 "deleting nonexistent file (%lu), %d",
                                 inode->i_ino, inode->i_nlink);
                set_nlink(inode, 1);
        }

        drop_nlink(inode);

        /*
         * we schedule before doing the add_save_link call, save the link
         * count so we don't race
         */
        savelink = inode->i_nlink;

        retval =
            reiserfs_cut_from_item(&th, &path, &de.de_entry_key, dir, NULL,
                                   0);
        if (retval < 0) {
                inc_nlink(inode);
                goto end_unlink;
        }
        inode->i_ctime = current_time(inode);
        reiserfs_update_sd(&th, inode);

        dir->i_size -= (de.de_entrylen + DEH_SIZE);
        dir->i_ctime = dir->i_mtime = current_time(dir);
        reiserfs_update_sd(&th, dir);

        if (!savelink)
                /* prevent file from getting lost */
                add_save_link(&th, inode, 0 /* not truncate */ );

        retval = journal_end(&th);
        reiserfs_check_path(&path);
        reiserfs_write_unlock(dir->i_sb);
        return retval;

end_unlink:
        pathrelse(&path);
        err = journal_end(&th);
        reiserfs_check_path(&path);
        if (err)
                retval = err;
out_unlink:
        reiserfs_write_unlock(dir->i_sb);
        return retval;
}

static int reiserfs_symlink(struct inode *parent_dir,
                            struct dentry *dentry, const char *symname)
{
        int retval;
        struct inode *inode;
        char *name;
        int item_len;
        struct reiserfs_transaction_handle th;
        struct reiserfs_security_handle security;
        int mode = S_IFLNK | S_IRWXUGO;
        /*
         * We need blocks for transaction + (user+group)*(quotas for
         * new inode + update of quota for directory owner)
         */
        int jbegin_count =
            JOURNAL_PER_BALANCE_CNT * 3 +
            2 * (REISERFS_QUOTA_INIT_BLOCKS(parent_dir->i_sb) +
                 REISERFS_QUOTA_TRANS_BLOCKS(parent_dir->i_sb));

        retval = dquot_initialize(parent_dir);
        if (retval)
                return retval;

        if (!(inode = new_inode(parent_dir->i_sb))) {
                return -ENOMEM;
        }
        retval = new_inode_init(inode, parent_dir, mode);
        if (retval) {
                drop_new_inode(inode);
                return retval;
        }

        retval = reiserfs_security_init(parent_dir, inode, &dentry->d_name,
                                        &security);
        if (retval < 0) {
                drop_new_inode(inode);
                return retval;
        }
        jbegin_count += retval;

        reiserfs_write_lock(parent_dir->i_sb);
        item_len = ROUND_UP(strlen(symname));
        if (item_len > MAX_DIRECT_ITEM_LEN(parent_dir->i_sb->s_blocksize)) {
                retval = -ENAMETOOLONG;
                drop_new_inode(inode);
                goto out_failed;
        }

        name = kmalloc(item_len, GFP_NOFS);
        if (!name) {
                drop_new_inode(inode);
                retval = -ENOMEM;
                goto out_failed;
        }
        memcpy(name, symname, strlen(symname));
        padd_item(name, item_len, strlen(symname));

        retval = journal_begin(&th, parent_dir->i_sb, jbegin_count);
        if (retval) {
                drop_new_inode(inode);
                kfree(name);
                goto out_failed;
        }

        retval =
            reiserfs_new_inode(&th, parent_dir, mode, name, strlen(symname),
                               dentry, inode, &security);
        kfree(name);
        if (retval) {           /* reiserfs_new_inode iputs for us */
                goto out_failed;
        }

        reiserfs_update_inode_transaction(inode);
        reiserfs_update_inode_transaction(parent_dir);

        inode->i_op = &reiserfs_symlink_inode_operations;
        inode_nohighmem(inode);
        inode->i_mapping->a_ops = &reiserfs_address_space_operations;

        retval = reiserfs_add_entry(&th, parent_dir, dentry->d_name.name,
                                    dentry->d_name.len, inode, 1 /*visible */ );
        if (retval) {
                int err;
                drop_nlink(inode);
                reiserfs_update_sd(&th, inode);
                err = journal_end(&th);
                if (err)
                        retval = err;
                unlock_new_inode(inode);
                iput(inode);
                goto out_failed;
        }

        d_instantiate_new(dentry, inode);
        retval = journal_end(&th);
out_failed:
        reiserfs_write_unlock(parent_dir->i_sb);
        return retval;
}

static int reiserfs_link(struct dentry *old_dentry, struct inode *dir,
                         struct dentry *dentry)
{
        int retval;
        struct inode *inode = d_inode(old_dentry);
        struct reiserfs_transaction_handle th;
        /*
         * We need blocks for transaction + update of quotas for
         * the owners of the directory
         */
        int jbegin_count =
            JOURNAL_PER_BALANCE_CNT * 3 +
            2 * REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb);

        retval = dquot_initialize(dir);
        if (retval)
                return retval;

        reiserfs_write_lock(dir->i_sb);
        if (inode->i_nlink >= REISERFS_LINK_MAX) {
                /* FIXME: sd_nlink is 32 bit for new files */
                reiserfs_write_unlock(dir->i_sb);
                return -EMLINK;
        }

        /* inc before scheduling so reiserfs_unlink knows we are here */
        inc_nlink(inode);

        retval = journal_begin(&th, dir->i_sb, jbegin_count);
        if (retval) {
                drop_nlink(inode);
                reiserfs_write_unlock(dir->i_sb);
                return retval;
        }

        /* create new entry */
        retval =
            reiserfs_add_entry(&th, dir, dentry->d_name.name,
                               dentry->d_name.len, inode, 1 /*visible */ );

        reiserfs_update_inode_transaction(inode);
        reiserfs_update_inode_transaction(dir);

        if (retval) {
                int err;
                drop_nlink(inode);
                err = journal_end(&th);
                reiserfs_write_unlock(dir->i_sb);
                return err ? err : retval;
        }

        inode->i_ctime = current_time(inode);
        reiserfs_update_sd(&th, inode);

        ihold(inode);
        d_instantiate(dentry, inode);
        retval = journal_end(&th);
        reiserfs_write_unlock(dir->i_sb);
        return retval;
}

/* de contains information pointing to an entry which */
static int de_still_valid(const char *name, int len,
                          struct reiserfs_dir_entry *de)
{
        struct reiserfs_dir_entry tmp = *de;

        /* recalculate pointer to name and name length */
        set_de_name_and_namelen(&tmp);
        /* FIXME: could check more */
        if (tmp.de_namelen != len || memcmp(name, de->de_name, len))
                return 0;
        return 1;
}

static int entry_points_to_object(const char *name, int len,
                                  struct reiserfs_dir_entry *de,
                                  struct inode *inode)
{
        if (!de_still_valid(name, len, de))
                return 0;

        if (inode) {
                if (!de_visible(de->de_deh + de->de_entry_num))
                        reiserfs_panic(inode->i_sb, "vs-7042",
                                       "entry must be visible");
                return (de->de_objectid == inode->i_ino) ? 1 : 0;
        }

        /* this must be added hidden entry */
        if (de_visible(de->de_deh + de->de_entry_num))
                reiserfs_panic(NULL, "vs-7043", "entry must be visible");

        return 1;
}

/* sets key of objectid the entry has to point to */
static void set_ino_in_dir_entry(struct reiserfs_dir_entry *de,
                                 struct reiserfs_key *key)
{
        /* JDM These operations are endian safe - both are le */
        de->de_deh[de->de_entry_num].deh_dir_id = key->k_dir_id;
        de->de_deh[de->de_entry_num].deh_objectid = key->k_objectid;
}

/*
 * process, that is going to call fix_nodes/do_balance must hold only
 * one path. If it holds 2 or more, it can get into endless waiting in
 * get_empty_nodes or its clones
 */
static int reiserfs_rename(struct inode *old_dir, struct dentry *old_dentry,
                           struct inode *new_dir, struct dentry *new_dentry,
                           unsigned int flags)
{
        int retval;
        INITIALIZE_PATH(old_entry_path);
        INITIALIZE_PATH(new_entry_path);
        INITIALIZE_PATH(dot_dot_entry_path);
        struct item_head new_entry_ih, old_entry_ih, dot_dot_ih;
        struct reiserfs_dir_entry old_de, new_de, dot_dot_de;
        struct inode *old_inode, *new_dentry_inode;
        struct reiserfs_transaction_handle th;
        int jbegin_count;
        umode_t old_inode_mode;
        unsigned long savelink = 1;
        struct timespec64 ctime;

        if (flags & ~RENAME_NOREPLACE)
                return -EINVAL;

        /*
         * three balancings: (1) old name removal, (2) new name insertion
         * and (3) maybe "save" link insertion
         * stat data updates: (1) old directory,
         * (2) new directory and (3) maybe old object stat data (when it is
         * directory) and (4) maybe stat data of object to which new entry
         * pointed initially and (5) maybe block containing ".." of
         * renamed directory
         * quota updates: two parent directories
         */
        jbegin_count =
            JOURNAL_PER_BALANCE_CNT * 3 + 5 +
            4 * REISERFS_QUOTA_TRANS_BLOCKS(old_dir->i_sb);

        retval = dquot_initialize(old_dir);
        if (retval)
                return retval;
        retval = dquot_initialize(new_dir);
        if (retval)
                return retval;

        old_inode = d_inode(old_dentry);
        new_dentry_inode = d_inode(new_dentry);

        /*
         * make sure that oldname still exists and points to an object we
         * are going to rename
         */
        old_de.de_gen_number_bit_string = NULL;
        reiserfs_write_lock(old_dir->i_sb);
        retval =
            reiserfs_find_entry(old_dir, old_dentry->d_name.name,
                                old_dentry->d_name.len, &old_entry_path,
                                &old_de);
        pathrelse(&old_entry_path);
        if (retval == IO_ERROR) {
                reiserfs_write_unlock(old_dir->i_sb);
                return -EIO;
        }

        if (retval != NAME_FOUND || old_de.de_objectid != old_inode->i_ino) {
                reiserfs_write_unlock(old_dir->i_sb);
                return -ENOENT;
        }

        old_inode_mode = old_inode->i_mode;
        if (S_ISDIR(old_inode_mode)) {
                /*
                 * make sure that directory being renamed has correct ".."
                 * and that its new parent directory has not too many links
                 * already
                 */
                if (new_dentry_inode) {
                        if (!reiserfs_empty_dir(new_dentry_inode)) {
                                reiserfs_write_unlock(old_dir->i_sb);
                                return -ENOTEMPTY;
                        }
                }

                /*
                 * directory is renamed, its parent directory will be changed,
                 * so find ".." entry
                 */
                dot_dot_de.de_gen_number_bit_string = NULL;
                retval =
                    reiserfs_find_entry(old_inode, "..", 2, &dot_dot_entry_path,
                                        &dot_dot_de);
                pathrelse(&dot_dot_entry_path);
                if (retval != NAME_FOUND) {
                        reiserfs_write_unlock(old_dir->i_sb);
                        return -EIO;
                }

                /* inode number of .. must equal old_dir->i_ino */
                if (dot_dot_de.de_objectid != old_dir->i_ino) {
                        reiserfs_write_unlock(old_dir->i_sb);
                        return -EIO;
                }
        }

        retval = journal_begin(&th, old_dir->i_sb, jbegin_count);
        if (retval) {
                reiserfs_write_unlock(old_dir->i_sb);
                return retval;
        }

        /* add new entry (or find the existing one) */
        retval =
            reiserfs_add_entry(&th, new_dir, new_dentry->d_name.name,
                               new_dentry->d_name.len, old_inode, 0);
        if (retval == -EEXIST) {
                if (!new_dentry_inode) {
                        reiserfs_panic(old_dir->i_sb, "vs-7050",
                                       "new entry is found, new inode == 0");
                }
        } else if (retval) {
                int err = journal_end(&th);
                reiserfs_write_unlock(old_dir->i_sb);
                return err ? err : retval;
        }

        reiserfs_update_inode_transaction(old_dir);
        reiserfs_update_inode_transaction(new_dir);

        /*
         * this makes it so an fsync on an open fd for the old name will
         * commit the rename operation
         */
        reiserfs_update_inode_transaction(old_inode);

        if (new_dentry_inode)
                reiserfs_update_inode_transaction(new_dentry_inode);

        while (1) {
                /*
                 * look for old name using corresponding entry key
                 * (found by reiserfs_find_entry)
                 */
                if ((retval =
                     search_by_entry_key(new_dir->i_sb, &old_de.de_entry_key,
                                         &old_entry_path,
                                         &old_de)) != NAME_FOUND) {
                        pathrelse(&old_entry_path);
                        journal_end(&th);
                        reiserfs_write_unlock(old_dir->i_sb);
                        return -EIO;
                }

                copy_item_head(&old_entry_ih, tp_item_head(&old_entry_path));

                reiserfs_prepare_for_journal(old_inode->i_sb, old_de.de_bh, 1);

                /* look for new name by reiserfs_find_entry */
                new_de.de_gen_number_bit_string = NULL;
                retval =
                    reiserfs_find_entry(new_dir, new_dentry->d_name.name,
                                        new_dentry->d_name.len, &new_entry_path,
                                        &new_de);
                /*
                 * reiserfs_add_entry should not return IO_ERROR,
                 * because it is called with essentially same parameters from
                 * reiserfs_add_entry above, and we'll catch any i/o errors
                 * before we get here.
                 */
                if (retval != NAME_FOUND_INVISIBLE && retval != NAME_FOUND) {
                        pathrelse(&new_entry_path);
                        pathrelse(&old_entry_path);
                        journal_end(&th);
                        reiserfs_write_unlock(old_dir->i_sb);
                        return -EIO;
                }

                copy_item_head(&new_entry_ih, tp_item_head(&new_entry_path));

                reiserfs_prepare_for_journal(old_inode->i_sb, new_de.de_bh, 1);

                if (S_ISDIR(old_inode->i_mode)) {
                        if ((retval =
                             search_by_entry_key(new_dir->i_sb,
                                                 &dot_dot_de.de_entry_key,
                                                 &dot_dot_entry_path,
                                                 &dot_dot_de)) != NAME_FOUND) {
                                pathrelse(&dot_dot_entry_path);
                                pathrelse(&new_entry_path);
                                pathrelse(&old_entry_path);
                                journal_end(&th);
                                reiserfs_write_unlock(old_dir->i_sb);
                                return -EIO;
                        }
                        copy_item_head(&dot_dot_ih,
                                       tp_item_head(&dot_dot_entry_path));
                        /* node containing ".." gets into transaction */
                        reiserfs_prepare_for_journal(old_inode->i_sb,
                                                     dot_dot_de.de_bh, 1);
                }
                /*
                 * we should check seals here, not do
                 * this stuff, yes? Then, having
                 * gathered everything into RAM we
                 * should lock the buffers, yes?  -Hans
                 */
                /*
                 * probably.  our rename needs to hold more
                 * than one path at once.  The seals would
                 * have to be written to deal with multi-path
                 * issues -chris
                 */
                /*
                 * sanity checking before doing the rename - avoid races many
                 * of the above checks could have scheduled.  We have to be
                 * sure our items haven't been shifted by another process.
                 */
                if (item_moved(&new_entry_ih, &new_entry_path) ||
                    !entry_points_to_object(new_dentry->d_name.name,
                                            new_dentry->d_name.len,
                                            &new_de, new_dentry_inode) ||
                    item_moved(&old_entry_ih, &old_entry_path) ||
                    !entry_points_to_object(old_dentry->d_name.name,
                                            old_dentry->d_name.len,
                                            &old_de, old_inode)) {
                        reiserfs_restore_prepared_buffer(old_inode->i_sb,
                                                         new_de.de_bh);
                        reiserfs_restore_prepared_buffer(old_inode->i_sb,
                                                         old_de.de_bh);
                        if (S_ISDIR(old_inode_mode))
                                reiserfs_restore_prepared_buffer(old_inode->
                                                                 i_sb,
                                                                 dot_dot_de.
                                                                 de_bh);
                        continue;
                }
                if (S_ISDIR(old_inode_mode)) {
                        if (item_moved(&dot_dot_ih, &dot_dot_entry_path) ||
                            !entry_points_to_object("..", 2, &dot_dot_de,
                                                    old_dir)) {
                                reiserfs_restore_prepared_buffer(old_inode->
                                                                 i_sb,
                                                                 old_de.de_bh);
                                reiserfs_restore_prepared_buffer(old_inode->
                                                                 i_sb,
                                                                 new_de.de_bh);
                                reiserfs_restore_prepared_buffer(old_inode->
                                                                 i_sb,
                                                                 dot_dot_de.
                                                                 de_bh);
                                continue;
                        }
                }

                RFALSE(S_ISDIR(old_inode_mode) &&
                       !buffer_journal_prepared(dot_dot_de.de_bh), "");

                break;
        }

        /*
         * ok, all the changes can be done in one fell swoop when we
         * have claimed all the buffers needed.
         */

        mark_de_visible(new_de.de_deh + new_de.de_entry_num);
        set_ino_in_dir_entry(&new_de, INODE_PKEY(old_inode));
        journal_mark_dirty(&th, new_de.de_bh);

        mark_de_hidden(old_de.de_deh + old_de.de_entry_num);
        journal_mark_dirty(&th, old_de.de_bh);
        ctime = current_time(old_dir);
        old_dir->i_ctime = old_dir->i_mtime = ctime;
        new_dir->i_ctime = new_dir->i_mtime = ctime;
        /*
         * thanks to Alex Adriaanse <alex_a@caltech.edu> for patch
         * which adds ctime update of renamed object
         */
        old_inode->i_ctime = ctime;

        if (new_dentry_inode) {
                /* adjust link number of the victim */
                if (S_ISDIR(new_dentry_inode->i_mode)) {
                        clear_nlink(new_dentry_inode);
                } else {
                        drop_nlink(new_dentry_inode);
                }
                new_dentry_inode->i_ctime = ctime;
                savelink = new_dentry_inode->i_nlink;
        }

        if (S_ISDIR(old_inode_mode)) {
                /* adjust ".." of renamed directory */
                set_ino_in_dir_entry(&dot_dot_de, INODE_PKEY(new_dir));
                journal_mark_dirty(&th, dot_dot_de.de_bh);

                /*
                 * there (in new_dir) was no directory, so it got new link
                 * (".."  of renamed directory)
                 */
                if (!new_dentry_inode)
                        INC_DIR_INODE_NLINK(new_dir);

                /* old directory lost one link - ".. " of renamed directory */
                DEC_DIR_INODE_NLINK(old_dir);
        }
        /*
         * looks like in 2.3.99pre3 brelse is atomic.
         * so we can use pathrelse
         */
        pathrelse(&new_entry_path);
        pathrelse(&dot_dot_entry_path);

        /*
         * FIXME: this reiserfs_cut_from_item's return value may screw up
         * anybody, but it will panic if will not be able to find the
         * entry. This needs one more clean up
         */
        if (reiserfs_cut_from_item
            (&th, &old_entry_path, &old_de.de_entry_key, old_dir, NULL,
             0) < 0)
                reiserfs_error(old_dir->i_sb, "vs-7060",
                               "couldn't not cut old name. Fsck later?");

        old_dir->i_size -= DEH_SIZE + old_de.de_entrylen;

        reiserfs_update_sd(&th, old_dir);
        reiserfs_update_sd(&th, new_dir);
        reiserfs_update_sd(&th, old_inode);

        if (new_dentry_inode) {
                if (savelink == 0)
                        add_save_link(&th, new_dentry_inode,
                                      0 /* not truncate */ );
                reiserfs_update_sd(&th, new_dentry_inode);
        }

        retval = journal_end(&th);
        reiserfs_write_unlock(old_dir->i_sb);
        return retval;
}

/* directories can handle most operations...  */
const struct inode_operations reiserfs_dir_inode_operations = {
        .create = reiserfs_create,
        .lookup = reiserfs_lookup,
        .link = reiserfs_link,
        .unlink = reiserfs_unlink,
        .symlink = reiserfs_symlink,
        .mkdir = reiserfs_mkdir,
        .rmdir = reiserfs_rmdir,
        .mknod = reiserfs_mknod,
        .rename = reiserfs_rename,
        .setattr = reiserfs_setattr,
        .listxattr = reiserfs_listxattr,
        .permission = reiserfs_permission,
        .get_acl = reiserfs_get_acl,
        .set_acl = reiserfs_set_acl,
};

/*
 * symlink operations.. same as page_symlink_inode_operations, with xattr
 * stuff added
 */
const struct inode_operations reiserfs_symlink_inode_operations = {
        .get_link       = page_get_link,
        .setattr = reiserfs_setattr,
        .listxattr = reiserfs_listxattr,
        .permission = reiserfs_permission,
};

/*
 * special file operations.. just xattr/acl stuff
 */
const struct inode_operations reiserfs_special_inode_operations = {
        .setattr = reiserfs_setattr,
        .listxattr = reiserfs_listxattr,
        .permission = reiserfs_permission,
        .get_acl = reiserfs_get_acl,
        .set_acl = reiserfs_set_acl,
};