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