linux/fs/reiserfs/super.c
<<
>>
Prefs
   1/*
   2 * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README
   3 *
   4 * Trivial changes by Alan Cox to add the LFS fixes
   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/module.h>
  15#include <linux/slab.h>
  16#include <linux/vmalloc.h>
  17#include <linux/time.h>
  18#include <linux/uaccess.h>
  19#include "reiserfs.h"
  20#include "acl.h"
  21#include "xattr.h"
  22#include <linux/init.h>
  23#include <linux/blkdev.h>
  24#include <linux/backing-dev.h>
  25#include <linux/buffer_head.h>
  26#include <linux/exportfs.h>
  27#include <linux/quotaops.h>
  28#include <linux/vfs.h>
  29#include <linux/mount.h>
  30#include <linux/namei.h>
  31#include <linux/crc32.h>
  32#include <linux/seq_file.h>
  33
  34struct file_system_type reiserfs_fs_type;
  35
  36static const char reiserfs_3_5_magic_string[] = REISERFS_SUPER_MAGIC_STRING;
  37static const char reiserfs_3_6_magic_string[] = REISER2FS_SUPER_MAGIC_STRING;
  38static const char reiserfs_jr_magic_string[] = REISER2FS_JR_SUPER_MAGIC_STRING;
  39
  40int is_reiserfs_3_5(struct reiserfs_super_block *rs)
  41{
  42        return !strncmp(rs->s_v1.s_magic, reiserfs_3_5_magic_string,
  43                        strlen(reiserfs_3_5_magic_string));
  44}
  45
  46int is_reiserfs_3_6(struct reiserfs_super_block *rs)
  47{
  48        return !strncmp(rs->s_v1.s_magic, reiserfs_3_6_magic_string,
  49                        strlen(reiserfs_3_6_magic_string));
  50}
  51
  52int is_reiserfs_jr(struct reiserfs_super_block *rs)
  53{
  54        return !strncmp(rs->s_v1.s_magic, reiserfs_jr_magic_string,
  55                        strlen(reiserfs_jr_magic_string));
  56}
  57
  58static int is_any_reiserfs_magic_string(struct reiserfs_super_block *rs)
  59{
  60        return (is_reiserfs_3_5(rs) || is_reiserfs_3_6(rs) ||
  61                is_reiserfs_jr(rs));
  62}
  63
  64static int reiserfs_remount(struct super_block *s, int *flags, char *data);
  65static int reiserfs_statfs(struct dentry *dentry, struct kstatfs *buf);
  66
  67static int reiserfs_sync_fs(struct super_block *s, int wait)
  68{
  69        struct reiserfs_transaction_handle th;
  70
  71        /*
  72         * Writeback quota in non-journalled quota case - journalled quota has
  73         * no dirty dquots
  74         */
  75        dquot_writeback_dquots(s, -1);
  76        reiserfs_write_lock(s);
  77        if (!journal_begin(&th, s, 1))
  78                if (!journal_end_sync(&th))
  79                        reiserfs_flush_old_commits(s);
  80        reiserfs_write_unlock(s);
  81        return 0;
  82}
  83
  84static void flush_old_commits(struct work_struct *work)
  85{
  86        struct reiserfs_sb_info *sbi;
  87        struct super_block *s;
  88
  89        sbi = container_of(work, struct reiserfs_sb_info, old_work.work);
  90        s = sbi->s_journal->j_work_sb;
  91
  92        /*
  93         * We need s_umount for protecting quota writeback. We have to use
  94         * trylock as reiserfs_cancel_old_flush() may be waiting for this work
  95         * to complete with s_umount held.
  96         */
  97        if (!down_read_trylock(&s->s_umount)) {
  98                /* Requeue work if we are not cancelling it */
  99                spin_lock(&sbi->old_work_lock);
 100                if (sbi->work_queued == 1)
 101                        queue_delayed_work(system_long_wq, &sbi->old_work, HZ);
 102                spin_unlock(&sbi->old_work_lock);
 103                return;
 104        }
 105        spin_lock(&sbi->old_work_lock);
 106        /* Avoid clobbering the cancel state... */
 107        if (sbi->work_queued == 1)
 108                sbi->work_queued = 0;
 109        spin_unlock(&sbi->old_work_lock);
 110
 111        reiserfs_sync_fs(s, 1);
 112        up_read(&s->s_umount);
 113}
 114
 115void reiserfs_schedule_old_flush(struct super_block *s)
 116{
 117        struct reiserfs_sb_info *sbi = REISERFS_SB(s);
 118        unsigned long delay;
 119
 120        /*
 121         * Avoid scheduling flush when sb is being shut down. It can race
 122         * with journal shutdown and free still queued delayed work.
 123         */
 124        if (sb_rdonly(s) || !(s->s_flags & SB_ACTIVE))
 125                return;
 126
 127        spin_lock(&sbi->old_work_lock);
 128        if (!sbi->work_queued) {
 129                delay = msecs_to_jiffies(dirty_writeback_interval * 10);
 130                queue_delayed_work(system_long_wq, &sbi->old_work, delay);
 131                sbi->work_queued = 1;
 132        }
 133        spin_unlock(&sbi->old_work_lock);
 134}
 135
 136void reiserfs_cancel_old_flush(struct super_block *s)
 137{
 138        struct reiserfs_sb_info *sbi = REISERFS_SB(s);
 139
 140        spin_lock(&sbi->old_work_lock);
 141        /* Make sure no new flushes will be queued */
 142        sbi->work_queued = 2;
 143        spin_unlock(&sbi->old_work_lock);
 144        cancel_delayed_work_sync(&REISERFS_SB(s)->old_work);
 145}
 146
 147static int reiserfs_freeze(struct super_block *s)
 148{
 149        struct reiserfs_transaction_handle th;
 150
 151        reiserfs_cancel_old_flush(s);
 152
 153        reiserfs_write_lock(s);
 154        if (!sb_rdonly(s)) {
 155                int err = journal_begin(&th, s, 1);
 156                if (err) {
 157                        reiserfs_block_writes(&th);
 158                } else {
 159                        reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s),
 160                                                     1);
 161                        journal_mark_dirty(&th, SB_BUFFER_WITH_SB(s));
 162                        reiserfs_block_writes(&th);
 163                        journal_end_sync(&th);
 164                }
 165        }
 166        reiserfs_write_unlock(s);
 167        return 0;
 168}
 169
 170static int reiserfs_unfreeze(struct super_block *s)
 171{
 172        struct reiserfs_sb_info *sbi = REISERFS_SB(s);
 173
 174        reiserfs_allow_writes(s);
 175        spin_lock(&sbi->old_work_lock);
 176        /* Allow old_work to run again */
 177        sbi->work_queued = 0;
 178        spin_unlock(&sbi->old_work_lock);
 179        return 0;
 180}
 181
 182extern const struct in_core_key MAX_IN_CORE_KEY;
 183
 184/*
 185 * this is used to delete "save link" when there are no items of a
 186 * file it points to. It can either happen if unlink is completed but
 187 * "save unlink" removal, or if file has both unlink and truncate
 188 * pending and as unlink completes first (because key of "save link"
 189 * protecting unlink is bigger that a key lf "save link" which
 190 * protects truncate), so there left no items to make truncate
 191 * completion on
 192 */
 193static int remove_save_link_only(struct super_block *s,
 194                                 struct reiserfs_key *key, int oid_free)
 195{
 196        struct reiserfs_transaction_handle th;
 197        int err;
 198
 199        /* we are going to do one balancing */
 200        err = journal_begin(&th, s, JOURNAL_PER_BALANCE_CNT);
 201        if (err)
 202                return err;
 203
 204        reiserfs_delete_solid_item(&th, NULL, key);
 205        if (oid_free)
 206                /* removals are protected by direct items */
 207                reiserfs_release_objectid(&th, le32_to_cpu(key->k_objectid));
 208
 209        return journal_end(&th);
 210}
 211
 212#ifdef CONFIG_QUOTA
 213static int reiserfs_quota_on_mount(struct super_block *, int);
 214#endif
 215
 216/*
 217 * Look for uncompleted unlinks and truncates and complete them
 218 *
 219 * Called with superblock write locked.  If quotas are enabled, we have to
 220 * release/retake lest we call dquot_quota_on_mount(), proceed to
 221 * schedule_on_each_cpu() in invalidate_bdev() and deadlock waiting for the per
 222 * cpu worklets to complete flush_async_commits() that in turn wait for the
 223 * superblock write lock.
 224 */
 225static int finish_unfinished(struct super_block *s)
 226{
 227        INITIALIZE_PATH(path);
 228        struct cpu_key max_cpu_key, obj_key;
 229        struct reiserfs_key save_link_key, last_inode_key;
 230        int retval = 0;
 231        struct item_head *ih;
 232        struct buffer_head *bh;
 233        int item_pos;
 234        char *item;
 235        int done;
 236        struct inode *inode;
 237        int truncate;
 238#ifdef CONFIG_QUOTA
 239        int i;
 240        int ms_active_set;
 241        int quota_enabled[REISERFS_MAXQUOTAS];
 242#endif
 243
 244        /* compose key to look for "save" links */
 245        max_cpu_key.version = KEY_FORMAT_3_5;
 246        max_cpu_key.on_disk_key.k_dir_id = ~0U;
 247        max_cpu_key.on_disk_key.k_objectid = ~0U;
 248        set_cpu_key_k_offset(&max_cpu_key, ~0U);
 249        max_cpu_key.key_length = 3;
 250
 251        memset(&last_inode_key, 0, sizeof(last_inode_key));
 252
 253#ifdef CONFIG_QUOTA
 254        /* Needed for iput() to work correctly and not trash data */
 255        if (s->s_flags & SB_ACTIVE) {
 256                ms_active_set = 0;
 257        } else {
 258                ms_active_set = 1;
 259                s->s_flags |= SB_ACTIVE;
 260        }
 261        /* Turn on quotas so that they are updated correctly */
 262        for (i = 0; i < REISERFS_MAXQUOTAS; i++) {
 263                quota_enabled[i] = 1;
 264                if (REISERFS_SB(s)->s_qf_names[i]) {
 265                        int ret;
 266
 267                        if (sb_has_quota_active(s, i)) {
 268                                quota_enabled[i] = 0;
 269                                continue;
 270                        }
 271                        reiserfs_write_unlock(s);
 272                        ret = reiserfs_quota_on_mount(s, i);
 273                        reiserfs_write_lock(s);
 274                        if (ret < 0)
 275                                reiserfs_warning(s, "reiserfs-2500",
 276                                                 "cannot turn on journaled "
 277                                                 "quota: error %d", ret);
 278                }
 279        }
 280#endif
 281
 282        done = 0;
 283        REISERFS_SB(s)->s_is_unlinked_ok = 1;
 284        while (!retval) {
 285                int depth;
 286                retval = search_item(s, &max_cpu_key, &path);
 287                if (retval != ITEM_NOT_FOUND) {
 288                        reiserfs_error(s, "vs-2140",
 289                                       "search_by_key returned %d", retval);
 290                        break;
 291                }
 292
 293                bh = get_last_bh(&path);
 294                item_pos = get_item_pos(&path);
 295                if (item_pos != B_NR_ITEMS(bh)) {
 296                        reiserfs_warning(s, "vs-2060",
 297                                         "wrong position found");
 298                        break;
 299                }
 300                item_pos--;
 301                ih = item_head(bh, item_pos);
 302
 303                if (le32_to_cpu(ih->ih_key.k_dir_id) != MAX_KEY_OBJECTID)
 304                        /* there are no "save" links anymore */
 305                        break;
 306
 307                save_link_key = ih->ih_key;
 308                if (is_indirect_le_ih(ih))
 309                        truncate = 1;
 310                else
 311                        truncate = 0;
 312
 313                /* reiserfs_iget needs k_dirid and k_objectid only */
 314                item = ih_item_body(bh, ih);
 315                obj_key.on_disk_key.k_dir_id = le32_to_cpu(*(__le32 *) item);
 316                obj_key.on_disk_key.k_objectid =
 317                    le32_to_cpu(ih->ih_key.k_objectid);
 318                obj_key.on_disk_key.k_offset = 0;
 319                obj_key.on_disk_key.k_type = 0;
 320
 321                pathrelse(&path);
 322
 323                inode = reiserfs_iget(s, &obj_key);
 324                if (IS_ERR_OR_NULL(inode)) {
 325                        /*
 326                         * the unlink almost completed, it just did not
 327                         * manage to remove "save" link and release objectid
 328                         */
 329                        reiserfs_warning(s, "vs-2180", "iget failed for %K",
 330                                         &obj_key);
 331                        retval = remove_save_link_only(s, &save_link_key, 1);
 332                        continue;
 333                }
 334
 335                if (!truncate && inode->i_nlink) {
 336                        /* file is not unlinked */
 337                        reiserfs_warning(s, "vs-2185",
 338                                         "file %K is not unlinked",
 339                                         &obj_key);
 340                        retval = remove_save_link_only(s, &save_link_key, 0);
 341                        continue;
 342                }
 343                depth = reiserfs_write_unlock_nested(inode->i_sb);
 344                dquot_initialize(inode);
 345                reiserfs_write_lock_nested(inode->i_sb, depth);
 346
 347                if (truncate && S_ISDIR(inode->i_mode)) {
 348                        /*
 349                         * We got a truncate request for a dir which
 350                         * is impossible.  The only imaginable way is to
 351                         * execute unfinished truncate request then boot
 352                         * into old kernel, remove the file and create dir
 353                         * with the same key.
 354                         */
 355                        reiserfs_warning(s, "green-2101",
 356                                         "impossible truncate on a "
 357                                         "directory %k. Please report",
 358                                         INODE_PKEY(inode));
 359                        retval = remove_save_link_only(s, &save_link_key, 0);
 360                        truncate = 0;
 361                        iput(inode);
 362                        continue;
 363                }
 364
 365                if (truncate) {
 366                        REISERFS_I(inode)->i_flags |=
 367                            i_link_saved_truncate_mask;
 368                        /*
 369                         * not completed truncate found. New size was
 370                         * committed together with "save" link
 371                         */
 372                        reiserfs_info(s, "Truncating %k to %lld ..",
 373                                      INODE_PKEY(inode), inode->i_size);
 374
 375                        /* don't update modification time */
 376                        reiserfs_truncate_file(inode, 0);
 377
 378                        retval = remove_save_link(inode, truncate);
 379                } else {
 380                        REISERFS_I(inode)->i_flags |= i_link_saved_unlink_mask;
 381                        /* not completed unlink (rmdir) found */
 382                        reiserfs_info(s, "Removing %k..", INODE_PKEY(inode));
 383                        if (memcmp(&last_inode_key, INODE_PKEY(inode),
 384                                        sizeof(last_inode_key))){
 385                                last_inode_key = *INODE_PKEY(inode);
 386                                /* removal gets completed in iput */
 387                                retval = 0;
 388                        } else {
 389                                reiserfs_warning(s, "super-2189", "Dead loop "
 390                                                 "in finish_unfinished "
 391                                                 "detected, just remove "
 392                                                 "save link\n");
 393                                retval = remove_save_link_only(s,
 394                                                        &save_link_key, 0);
 395                        }
 396                }
 397
 398                iput(inode);
 399                printk("done\n");
 400                done++;
 401        }
 402        REISERFS_SB(s)->s_is_unlinked_ok = 0;
 403
 404#ifdef CONFIG_QUOTA
 405        /* Turn quotas off */
 406        reiserfs_write_unlock(s);
 407        for (i = 0; i < REISERFS_MAXQUOTAS; i++) {
 408                if (sb_dqopt(s)->files[i] && quota_enabled[i])
 409                        dquot_quota_off(s, i);
 410        }
 411        reiserfs_write_lock(s);
 412        if (ms_active_set)
 413                /* Restore the flag back */
 414                s->s_flags &= ~SB_ACTIVE;
 415#endif
 416        pathrelse(&path);
 417        if (done)
 418                reiserfs_info(s, "There were %d uncompleted unlinks/truncates. "
 419                              "Completed\n", done);
 420        return retval;
 421}
 422
 423/*
 424 * to protect file being unlinked from getting lost we "safe" link files
 425 * being unlinked. This link will be deleted in the same transaction with last
 426 * item of file. mounting the filesystem we scan all these links and remove
 427 * files which almost got lost
 428 */
 429void add_save_link(struct reiserfs_transaction_handle *th,
 430                   struct inode *inode, int truncate)
 431{
 432        INITIALIZE_PATH(path);
 433        int retval;
 434        struct cpu_key key;
 435        struct item_head ih;
 436        __le32 link;
 437
 438        BUG_ON(!th->t_trans_id);
 439
 440        /* file can only get one "save link" of each kind */
 441        RFALSE(truncate &&
 442               (REISERFS_I(inode)->i_flags & i_link_saved_truncate_mask),
 443               "saved link already exists for truncated inode %lx",
 444               (long)inode->i_ino);
 445        RFALSE(!truncate &&
 446               (REISERFS_I(inode)->i_flags & i_link_saved_unlink_mask),
 447               "saved link already exists for unlinked inode %lx",
 448               (long)inode->i_ino);
 449
 450        /* setup key of "save" link */
 451        key.version = KEY_FORMAT_3_5;
 452        key.on_disk_key.k_dir_id = MAX_KEY_OBJECTID;
 453        key.on_disk_key.k_objectid = inode->i_ino;
 454        if (!truncate) {
 455                /* unlink, rmdir, rename */
 456                set_cpu_key_k_offset(&key, 1 + inode->i_sb->s_blocksize);
 457                set_cpu_key_k_type(&key, TYPE_DIRECT);
 458
 459                /* item head of "safe" link */
 460                make_le_item_head(&ih, &key, key.version,
 461                                  1 + inode->i_sb->s_blocksize, TYPE_DIRECT,
 462                                  4 /*length */ , 0xffff /*free space */ );
 463        } else {
 464                /* truncate */
 465                if (S_ISDIR(inode->i_mode))
 466                        reiserfs_warning(inode->i_sb, "green-2102",
 467                                         "Adding a truncate savelink for "
 468                                         "a directory %k! Please report",
 469                                         INODE_PKEY(inode));
 470                set_cpu_key_k_offset(&key, 1);
 471                set_cpu_key_k_type(&key, TYPE_INDIRECT);
 472
 473                /* item head of "safe" link */
 474                make_le_item_head(&ih, &key, key.version, 1, TYPE_INDIRECT,
 475                                  4 /*length */ , 0 /*free space */ );
 476        }
 477        key.key_length = 3;
 478
 479        /* look for its place in the tree */
 480        retval = search_item(inode->i_sb, &key, &path);
 481        if (retval != ITEM_NOT_FOUND) {
 482                if (retval != -ENOSPC)
 483                        reiserfs_error(inode->i_sb, "vs-2100",
 484                                       "search_by_key (%K) returned %d", &key,
 485                                       retval);
 486                pathrelse(&path);
 487                return;
 488        }
 489
 490        /* body of "save" link */
 491        link = INODE_PKEY(inode)->k_dir_id;
 492
 493        /* put "save" link into tree, don't charge quota to anyone */
 494        retval =
 495            reiserfs_insert_item(th, &path, &key, &ih, NULL, (char *)&link);
 496        if (retval) {
 497                if (retval != -ENOSPC)
 498                        reiserfs_error(inode->i_sb, "vs-2120",
 499                                       "insert_item returned %d", retval);
 500        } else {
 501                if (truncate)
 502                        REISERFS_I(inode)->i_flags |=
 503                            i_link_saved_truncate_mask;
 504                else
 505                        REISERFS_I(inode)->i_flags |= i_link_saved_unlink_mask;
 506        }
 507}
 508
 509/* this opens transaction unlike add_save_link */
 510int remove_save_link(struct inode *inode, int truncate)
 511{
 512        struct reiserfs_transaction_handle th;
 513        struct reiserfs_key key;
 514        int err;
 515
 516        /* we are going to do one balancing only */
 517        err = journal_begin(&th, inode->i_sb, JOURNAL_PER_BALANCE_CNT);
 518        if (err)
 519                return err;
 520
 521        /* setup key of "save" link */
 522        key.k_dir_id = cpu_to_le32(MAX_KEY_OBJECTID);
 523        key.k_objectid = INODE_PKEY(inode)->k_objectid;
 524        if (!truncate) {
 525                /* unlink, rmdir, rename */
 526                set_le_key_k_offset(KEY_FORMAT_3_5, &key,
 527                                    1 + inode->i_sb->s_blocksize);
 528                set_le_key_k_type(KEY_FORMAT_3_5, &key, TYPE_DIRECT);
 529        } else {
 530                /* truncate */
 531                set_le_key_k_offset(KEY_FORMAT_3_5, &key, 1);
 532                set_le_key_k_type(KEY_FORMAT_3_5, &key, TYPE_INDIRECT);
 533        }
 534
 535        if ((truncate &&
 536             (REISERFS_I(inode)->i_flags & i_link_saved_truncate_mask)) ||
 537            (!truncate &&
 538             (REISERFS_I(inode)->i_flags & i_link_saved_unlink_mask)))
 539                /* don't take quota bytes from anywhere */
 540                reiserfs_delete_solid_item(&th, NULL, &key);
 541        if (!truncate) {
 542                reiserfs_release_objectid(&th, inode->i_ino);
 543                REISERFS_I(inode)->i_flags &= ~i_link_saved_unlink_mask;
 544        } else
 545                REISERFS_I(inode)->i_flags &= ~i_link_saved_truncate_mask;
 546
 547        return journal_end(&th);
 548}
 549
 550static void reiserfs_kill_sb(struct super_block *s)
 551{
 552        if (REISERFS_SB(s)) {
 553                reiserfs_proc_info_done(s);
 554                /*
 555                 * Force any pending inode evictions to occur now. Any
 556                 * inodes to be removed that have extended attributes
 557                 * associated with them need to clean them up before
 558                 * we can release the extended attribute root dentries.
 559                 * shrink_dcache_for_umount will BUG if we don't release
 560                 * those before it's called so ->put_super is too late.
 561                 */
 562                shrink_dcache_sb(s);
 563
 564                dput(REISERFS_SB(s)->xattr_root);
 565                REISERFS_SB(s)->xattr_root = NULL;
 566                dput(REISERFS_SB(s)->priv_root);
 567                REISERFS_SB(s)->priv_root = NULL;
 568        }
 569
 570        kill_block_super(s);
 571}
 572
 573#ifdef CONFIG_QUOTA
 574static int reiserfs_quota_off(struct super_block *sb, int type);
 575
 576static void reiserfs_quota_off_umount(struct super_block *s)
 577{
 578        int type;
 579
 580        for (type = 0; type < REISERFS_MAXQUOTAS; type++)
 581                reiserfs_quota_off(s, type);
 582}
 583#else
 584static inline void reiserfs_quota_off_umount(struct super_block *s)
 585{
 586}
 587#endif
 588
 589static void reiserfs_put_super(struct super_block *s)
 590{
 591        struct reiserfs_transaction_handle th;
 592        th.t_trans_id = 0;
 593
 594        reiserfs_quota_off_umount(s);
 595
 596        reiserfs_write_lock(s);
 597
 598        /*
 599         * change file system state to current state if it was mounted
 600         * with read-write permissions
 601         */
 602        if (!sb_rdonly(s)) {
 603                if (!journal_begin(&th, s, 10)) {
 604                        reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s),
 605                                                     1);
 606                        set_sb_umount_state(SB_DISK_SUPER_BLOCK(s),
 607                                            REISERFS_SB(s)->s_mount_state);
 608                        journal_mark_dirty(&th, SB_BUFFER_WITH_SB(s));
 609                }
 610        }
 611
 612        /*
 613         * note, journal_release checks for readonly mount, and can
 614         * decide not to do a journal_end
 615         */
 616        journal_release(&th, s);
 617
 618        reiserfs_free_bitmap_cache(s);
 619
 620        brelse(SB_BUFFER_WITH_SB(s));
 621
 622        print_statistics(s);
 623
 624        if (REISERFS_SB(s)->reserved_blocks != 0) {
 625                reiserfs_warning(s, "green-2005", "reserved blocks left %d",
 626                                 REISERFS_SB(s)->reserved_blocks);
 627        }
 628
 629        reiserfs_write_unlock(s);
 630        mutex_destroy(&REISERFS_SB(s)->lock);
 631        destroy_workqueue(REISERFS_SB(s)->commit_wq);
 632        kfree(REISERFS_SB(s)->s_jdev);
 633        kfree(s->s_fs_info);
 634        s->s_fs_info = NULL;
 635}
 636
 637static struct kmem_cache *reiserfs_inode_cachep;
 638
 639static struct inode *reiserfs_alloc_inode(struct super_block *sb)
 640{
 641        struct reiserfs_inode_info *ei;
 642        ei = kmem_cache_alloc(reiserfs_inode_cachep, GFP_KERNEL);
 643        if (!ei)
 644                return NULL;
 645        atomic_set(&ei->openers, 0);
 646        mutex_init(&ei->tailpack);
 647#ifdef CONFIG_QUOTA
 648        memset(&ei->i_dquot, 0, sizeof(ei->i_dquot));
 649#endif
 650
 651        return &ei->vfs_inode;
 652}
 653
 654static void reiserfs_free_inode(struct inode *inode)
 655{
 656        kmem_cache_free(reiserfs_inode_cachep, REISERFS_I(inode));
 657}
 658
 659static void init_once(void *foo)
 660{
 661        struct reiserfs_inode_info *ei = (struct reiserfs_inode_info *)foo;
 662
 663        INIT_LIST_HEAD(&ei->i_prealloc_list);
 664        inode_init_once(&ei->vfs_inode);
 665}
 666
 667static int __init init_inodecache(void)
 668{
 669        reiserfs_inode_cachep = kmem_cache_create("reiser_inode_cache",
 670                                                  sizeof(struct
 671                                                         reiserfs_inode_info),
 672                                                  0, (SLAB_RECLAIM_ACCOUNT|
 673                                                      SLAB_MEM_SPREAD|
 674                                                      SLAB_ACCOUNT),
 675                                                  init_once);
 676        if (reiserfs_inode_cachep == NULL)
 677                return -ENOMEM;
 678        return 0;
 679}
 680
 681static void destroy_inodecache(void)
 682{
 683        /*
 684         * Make sure all delayed rcu free inodes are flushed before we
 685         * destroy cache.
 686         */
 687        rcu_barrier();
 688        kmem_cache_destroy(reiserfs_inode_cachep);
 689}
 690
 691/* we don't mark inodes dirty, we just log them */
 692static void reiserfs_dirty_inode(struct inode *inode, int flags)
 693{
 694        struct reiserfs_transaction_handle th;
 695
 696        int err = 0;
 697
 698        if (sb_rdonly(inode->i_sb)) {
 699                reiserfs_warning(inode->i_sb, "clm-6006",
 700                                 "writing inode %lu on readonly FS",
 701                                 inode->i_ino);
 702                return;
 703        }
 704        reiserfs_write_lock(inode->i_sb);
 705
 706        /*
 707         * this is really only used for atime updates, so they don't have
 708         * to be included in O_SYNC or fsync
 709         */
 710        err = journal_begin(&th, inode->i_sb, 1);
 711        if (err)
 712                goto out;
 713
 714        reiserfs_update_sd(&th, inode);
 715        journal_end(&th);
 716
 717out:
 718        reiserfs_write_unlock(inode->i_sb);
 719}
 720
 721static int reiserfs_show_options(struct seq_file *seq, struct dentry *root)
 722{
 723        struct super_block *s = root->d_sb;
 724        struct reiserfs_journal *journal = SB_JOURNAL(s);
 725        long opts = REISERFS_SB(s)->s_mount_opt;
 726
 727        if (opts & (1 << REISERFS_LARGETAIL))
 728                seq_puts(seq, ",tails=on");
 729        else if (!(opts & (1 << REISERFS_SMALLTAIL)))
 730                seq_puts(seq, ",notail");
 731        /* tails=small is default so we don't show it */
 732
 733        if (!(opts & (1 << REISERFS_BARRIER_FLUSH)))
 734                seq_puts(seq, ",barrier=none");
 735        /* barrier=flush is default so we don't show it */
 736
 737        if (opts & (1 << REISERFS_ERROR_CONTINUE))
 738                seq_puts(seq, ",errors=continue");
 739        else if (opts & (1 << REISERFS_ERROR_PANIC))
 740                seq_puts(seq, ",errors=panic");
 741        /* errors=ro is default so we don't show it */
 742
 743        if (opts & (1 << REISERFS_DATA_LOG))
 744                seq_puts(seq, ",data=journal");
 745        else if (opts & (1 << REISERFS_DATA_WRITEBACK))
 746                seq_puts(seq, ",data=writeback");
 747        /* data=ordered is default so we don't show it */
 748
 749        if (opts & (1 << REISERFS_ATTRS))
 750                seq_puts(seq, ",attrs");
 751
 752        if (opts & (1 << REISERFS_XATTRS_USER))
 753                seq_puts(seq, ",user_xattr");
 754
 755        if (opts & (1 << REISERFS_EXPOSE_PRIVROOT))
 756                seq_puts(seq, ",expose_privroot");
 757
 758        if (opts & (1 << REISERFS_POSIXACL))
 759                seq_puts(seq, ",acl");
 760
 761        if (REISERFS_SB(s)->s_jdev)
 762                seq_show_option(seq, "jdev", REISERFS_SB(s)->s_jdev);
 763
 764        if (journal->j_max_commit_age != journal->j_default_max_commit_age)
 765                seq_printf(seq, ",commit=%d", journal->j_max_commit_age);
 766
 767#ifdef CONFIG_QUOTA
 768        if (REISERFS_SB(s)->s_qf_names[USRQUOTA])
 769                seq_show_option(seq, "usrjquota",
 770                                REISERFS_SB(s)->s_qf_names[USRQUOTA]);
 771        else if (opts & (1 << REISERFS_USRQUOTA))
 772                seq_puts(seq, ",usrquota");
 773        if (REISERFS_SB(s)->s_qf_names[GRPQUOTA])
 774                seq_show_option(seq, "grpjquota",
 775                                REISERFS_SB(s)->s_qf_names[GRPQUOTA]);
 776        else if (opts & (1 << REISERFS_GRPQUOTA))
 777                seq_puts(seq, ",grpquota");
 778        if (REISERFS_SB(s)->s_jquota_fmt) {
 779                if (REISERFS_SB(s)->s_jquota_fmt == QFMT_VFS_OLD)
 780                        seq_puts(seq, ",jqfmt=vfsold");
 781                else if (REISERFS_SB(s)->s_jquota_fmt == QFMT_VFS_V0)
 782                        seq_puts(seq, ",jqfmt=vfsv0");
 783        }
 784#endif
 785
 786        /* Block allocator options */
 787        if (opts & (1 << REISERFS_NO_BORDER))
 788                seq_puts(seq, ",block-allocator=noborder");
 789        if (opts & (1 << REISERFS_NO_UNHASHED_RELOCATION))
 790                seq_puts(seq, ",block-allocator=no_unhashed_relocation");
 791        if (opts & (1 << REISERFS_HASHED_RELOCATION))
 792                seq_puts(seq, ",block-allocator=hashed_relocation");
 793        if (opts & (1 << REISERFS_TEST4))
 794                seq_puts(seq, ",block-allocator=test4");
 795        show_alloc_options(seq, s);
 796        return 0;
 797}
 798
 799#ifdef CONFIG_QUOTA
 800static ssize_t reiserfs_quota_write(struct super_block *, int, const char *,
 801                                    size_t, loff_t);
 802static ssize_t reiserfs_quota_read(struct super_block *, int, char *, size_t,
 803                                   loff_t);
 804
 805static struct dquot **reiserfs_get_dquots(struct inode *inode)
 806{
 807        return REISERFS_I(inode)->i_dquot;
 808}
 809#endif
 810
 811static const struct super_operations reiserfs_sops = {
 812        .alloc_inode = reiserfs_alloc_inode,
 813        .free_inode = reiserfs_free_inode,
 814        .write_inode = reiserfs_write_inode,
 815        .dirty_inode = reiserfs_dirty_inode,
 816        .evict_inode = reiserfs_evict_inode,
 817        .put_super = reiserfs_put_super,
 818        .sync_fs = reiserfs_sync_fs,
 819        .freeze_fs = reiserfs_freeze,
 820        .unfreeze_fs = reiserfs_unfreeze,
 821        .statfs = reiserfs_statfs,
 822        .remount_fs = reiserfs_remount,
 823        .show_options = reiserfs_show_options,
 824#ifdef CONFIG_QUOTA
 825        .quota_read = reiserfs_quota_read,
 826        .quota_write = reiserfs_quota_write,
 827        .get_dquots = reiserfs_get_dquots,
 828#endif
 829};
 830
 831#ifdef CONFIG_QUOTA
 832#define QTYPE2NAME(t) ((t)==USRQUOTA?"user":"group")
 833
 834static int reiserfs_write_dquot(struct dquot *);
 835static int reiserfs_acquire_dquot(struct dquot *);
 836static int reiserfs_release_dquot(struct dquot *);
 837static int reiserfs_mark_dquot_dirty(struct dquot *);
 838static int reiserfs_write_info(struct super_block *, int);
 839static int reiserfs_quota_on(struct super_block *, int, int, const struct path *);
 840
 841static const struct dquot_operations reiserfs_quota_operations = {
 842        .write_dquot = reiserfs_write_dquot,
 843        .acquire_dquot = reiserfs_acquire_dquot,
 844        .release_dquot = reiserfs_release_dquot,
 845        .mark_dirty = reiserfs_mark_dquot_dirty,
 846        .write_info = reiserfs_write_info,
 847        .alloc_dquot    = dquot_alloc,
 848        .destroy_dquot  = dquot_destroy,
 849        .get_next_id    = dquot_get_next_id,
 850};
 851
 852static const struct quotactl_ops reiserfs_qctl_operations = {
 853        .quota_on = reiserfs_quota_on,
 854        .quota_off = reiserfs_quota_off,
 855        .quota_sync = dquot_quota_sync,
 856        .get_state = dquot_get_state,
 857        .set_info = dquot_set_dqinfo,
 858        .get_dqblk = dquot_get_dqblk,
 859        .set_dqblk = dquot_set_dqblk,
 860};
 861#endif
 862
 863static const struct export_operations reiserfs_export_ops = {
 864        .encode_fh = reiserfs_encode_fh,
 865        .fh_to_dentry = reiserfs_fh_to_dentry,
 866        .fh_to_parent = reiserfs_fh_to_parent,
 867        .get_parent = reiserfs_get_parent,
 868};
 869
 870/*
 871 * this struct is used in reiserfs_getopt () for containing the value for
 872 * those mount options that have values rather than being toggles.
 873 */
 874typedef struct {
 875        char *value;
 876        /*
 877         * bitmask which is to set on mount_options bitmask
 878         * when this value is found, 0 is no bits are to be changed.
 879         */
 880        int setmask;
 881        /*
 882         * bitmask which is to clear on mount_options bitmask
 883         * when this value is found, 0 is no bits are to be changed.
 884         * This is applied BEFORE setmask
 885         */
 886        int clrmask;
 887} arg_desc_t;
 888
 889/* Set this bit in arg_required to allow empty arguments */
 890#define REISERFS_OPT_ALLOWEMPTY 31
 891
 892/*
 893 * this struct is used in reiserfs_getopt() for describing the
 894 * set of reiserfs mount options
 895 */
 896typedef struct {
 897        char *option_name;
 898
 899        /* 0 if argument is not required, not 0 otherwise */
 900        int arg_required;
 901
 902        /* list of values accepted by an option */
 903        const arg_desc_t *values;
 904
 905        /*
 906         * bitmask which is to set on mount_options bitmask
 907         * when this value is found, 0 is no bits are to be changed.
 908         */
 909        int setmask;
 910
 911        /*
 912         * bitmask which is to clear on mount_options bitmask
 913         * when this value is found, 0 is no bits are to be changed.
 914         * This is applied BEFORE setmask
 915         */
 916        int clrmask;
 917} opt_desc_t;
 918
 919/* possible values for -o data= */
 920static const arg_desc_t logging_mode[] = {
 921        {"ordered", 1 << REISERFS_DATA_ORDERED,
 922         (1 << REISERFS_DATA_LOG | 1 << REISERFS_DATA_WRITEBACK)},
 923        {"journal", 1 << REISERFS_DATA_LOG,
 924         (1 << REISERFS_DATA_ORDERED | 1 << REISERFS_DATA_WRITEBACK)},
 925        {"writeback", 1 << REISERFS_DATA_WRITEBACK,
 926         (1 << REISERFS_DATA_ORDERED | 1 << REISERFS_DATA_LOG)},
 927        {.value = NULL}
 928};
 929
 930/* possible values for -o barrier= */
 931static const arg_desc_t barrier_mode[] = {
 932        {"none", 1 << REISERFS_BARRIER_NONE, 1 << REISERFS_BARRIER_FLUSH},
 933        {"flush", 1 << REISERFS_BARRIER_FLUSH, 1 << REISERFS_BARRIER_NONE},
 934        {.value = NULL}
 935};
 936
 937/*
 938 * possible values for "-o block-allocator=" and bits which are to be set in
 939 * s_mount_opt of reiserfs specific part of in-core super block
 940 */
 941static const arg_desc_t balloc[] = {
 942        {"noborder", 1 << REISERFS_NO_BORDER, 0},
 943        {"border", 0, 1 << REISERFS_NO_BORDER},
 944        {"no_unhashed_relocation", 1 << REISERFS_NO_UNHASHED_RELOCATION, 0},
 945        {"hashed_relocation", 1 << REISERFS_HASHED_RELOCATION, 0},
 946        {"test4", 1 << REISERFS_TEST4, 0},
 947        {"notest4", 0, 1 << REISERFS_TEST4},
 948        {NULL, 0, 0}
 949};
 950
 951static const arg_desc_t tails[] = {
 952        {"on", 1 << REISERFS_LARGETAIL, 1 << REISERFS_SMALLTAIL},
 953        {"off", 0, (1 << REISERFS_LARGETAIL) | (1 << REISERFS_SMALLTAIL)},
 954        {"small", 1 << REISERFS_SMALLTAIL, 1 << REISERFS_LARGETAIL},
 955        {NULL, 0, 0}
 956};
 957
 958static const arg_desc_t error_actions[] = {
 959        {"panic", 1 << REISERFS_ERROR_PANIC,
 960         (1 << REISERFS_ERROR_RO | 1 << REISERFS_ERROR_CONTINUE)},
 961        {"ro-remount", 1 << REISERFS_ERROR_RO,
 962         (1 << REISERFS_ERROR_PANIC | 1 << REISERFS_ERROR_CONTINUE)},
 963#ifdef REISERFS_JOURNAL_ERROR_ALLOWS_NO_LOG
 964        {"continue", 1 << REISERFS_ERROR_CONTINUE,
 965         (1 << REISERFS_ERROR_PANIC | 1 << REISERFS_ERROR_RO)},
 966#endif
 967        {NULL, 0, 0},
 968};
 969
 970/*
 971 * proceed only one option from a list *cur - string containing of mount
 972 * options
 973 * opts - array of options which are accepted
 974 * opt_arg - if option is found and requires an argument and if it is specifed
 975 * in the input - pointer to the argument is stored here
 976 * bit_flags - if option requires to set a certain bit - it is set here
 977 * return -1 if unknown option is found, opt->arg_required otherwise
 978 */
 979static int reiserfs_getopt(struct super_block *s, char **cur, opt_desc_t * opts,
 980                           char **opt_arg, unsigned long *bit_flags)
 981{
 982        char *p;
 983        /*
 984         * foo=bar,
 985         * ^   ^  ^
 986         * |   |  +-- option_end
 987         * |   +-- arg_start
 988         * +-- option_start
 989         */
 990        const opt_desc_t *opt;
 991        const arg_desc_t *arg;
 992
 993        p = *cur;
 994
 995        /* assume argument cannot contain commas */
 996        *cur = strchr(p, ',');
 997        if (*cur) {
 998                *(*cur) = '\0';
 999                (*cur)++;
1000        }
1001
1002        if (!strncmp(p, "alloc=", 6)) {
1003                /*
1004                 * Ugly special case, probably we should redo options
1005                 * parser so that it can understand several arguments for
1006                 * some options, also so that it can fill several bitfields
1007                 * with option values.
1008                 */
1009                if (reiserfs_parse_alloc_options(s, p + 6)) {
1010                        return -1;
1011                } else {
1012                        return 0;
1013                }
1014        }
1015
1016        /* for every option in the list */
1017        for (opt = opts; opt->option_name; opt++) {
1018                if (!strncmp(p, opt->option_name, strlen(opt->option_name))) {
1019                        if (bit_flags) {
1020                                if (opt->clrmask ==
1021                                    (1 << REISERFS_UNSUPPORTED_OPT))
1022                                        reiserfs_warning(s, "super-6500",
1023                                                         "%s not supported.\n",
1024                                                         p);
1025                                else
1026                                        *bit_flags &= ~opt->clrmask;
1027                                if (opt->setmask ==
1028                                    (1 << REISERFS_UNSUPPORTED_OPT))
1029                                        reiserfs_warning(s, "super-6501",
1030                                                         "%s not supported.\n",
1031                                                         p);
1032                                else
1033                                        *bit_flags |= opt->setmask;
1034                        }
1035                        break;
1036                }
1037        }
1038        if (!opt->option_name) {
1039                reiserfs_warning(s, "super-6502",
1040                                 "unknown mount option \"%s\"", p);
1041                return -1;
1042        }
1043
1044        p += strlen(opt->option_name);
1045        switch (*p) {
1046        case '=':
1047                if (!opt->arg_required) {
1048                        reiserfs_warning(s, "super-6503",
1049                                         "the option \"%s\" does not "
1050                                         "require an argument\n",
1051                                         opt->option_name);
1052                        return -1;
1053                }
1054                break;
1055
1056        case 0:
1057                if (opt->arg_required) {
1058                        reiserfs_warning(s, "super-6504",
1059                                         "the option \"%s\" requires an "
1060                                         "argument\n", opt->option_name);
1061                        return -1;
1062                }
1063                break;
1064        default:
1065                reiserfs_warning(s, "super-6505",
1066                                 "head of option \"%s\" is only correct\n",
1067                                 opt->option_name);
1068                return -1;
1069        }
1070
1071        /*
1072         * move to the argument, or to next option if argument is not
1073         * required
1074         */
1075        p++;
1076
1077        if (opt->arg_required
1078            && !(opt->arg_required & (1 << REISERFS_OPT_ALLOWEMPTY))
1079            && !strlen(p)) {
1080                /* this catches "option=," if not allowed */
1081                reiserfs_warning(s, "super-6506",
1082                                 "empty argument for \"%s\"\n",
1083                                 opt->option_name);
1084                return -1;
1085        }
1086
1087        if (!opt->values) {
1088                /* *=NULLopt_arg contains pointer to argument */
1089                *opt_arg = p;
1090                return opt->arg_required & ~(1 << REISERFS_OPT_ALLOWEMPTY);
1091        }
1092
1093        /* values possible for this option are listed in opt->values */
1094        for (arg = opt->values; arg->value; arg++) {
1095                if (!strcmp(p, arg->value)) {
1096                        if (bit_flags) {
1097                                *bit_flags &= ~arg->clrmask;
1098                                *bit_flags |= arg->setmask;
1099                        }
1100                        return opt->arg_required;
1101                }
1102        }
1103
1104        reiserfs_warning(s, "super-6506",
1105                         "bad value \"%s\" for option \"%s\"\n", p,
1106                         opt->option_name);
1107        return -1;
1108}
1109
1110/* returns 0 if something is wrong in option string, 1 - otherwise */
1111static int reiserfs_parse_options(struct super_block *s,
1112
1113                                  /* string given via mount's -o */
1114                                  char *options,
1115
1116                                  /*
1117                                   * after the parsing phase, contains the
1118                                   * collection of bitflags defining what
1119                                   * mount options were selected.
1120                                   */
1121                                  unsigned long *mount_options,
1122
1123                                  /* strtol-ed from NNN of resize=NNN */
1124                                  unsigned long *blocks,
1125                                  char **jdev_name,
1126                                  unsigned int *commit_max_age,
1127                                  char **qf_names,
1128                                  unsigned int *qfmt)
1129{
1130        int c;
1131        char *arg = NULL;
1132        char *pos;
1133        opt_desc_t opts[] = {
1134                /*
1135                 * Compatibility stuff, so that -o notail for old
1136                 * setups still work
1137                 */
1138                {"tails",.arg_required = 't',.values = tails},
1139                {"notail",.clrmask =
1140                 (1 << REISERFS_LARGETAIL) | (1 << REISERFS_SMALLTAIL)},
1141                {"conv",.setmask = 1 << REISERFS_CONVERT},
1142                {"attrs",.setmask = 1 << REISERFS_ATTRS},
1143                {"noattrs",.clrmask = 1 << REISERFS_ATTRS},
1144                {"expose_privroot", .setmask = 1 << REISERFS_EXPOSE_PRIVROOT},
1145#ifdef CONFIG_REISERFS_FS_XATTR
1146                {"user_xattr",.setmask = 1 << REISERFS_XATTRS_USER},
1147                {"nouser_xattr",.clrmask = 1 << REISERFS_XATTRS_USER},
1148#else
1149                {"user_xattr",.setmask = 1 << REISERFS_UNSUPPORTED_OPT},
1150                {"nouser_xattr",.clrmask = 1 << REISERFS_UNSUPPORTED_OPT},
1151#endif
1152#ifdef CONFIG_REISERFS_FS_POSIX_ACL
1153                {"acl",.setmask = 1 << REISERFS_POSIXACL},
1154                {"noacl",.clrmask = 1 << REISERFS_POSIXACL},
1155#else
1156                {"acl",.setmask = 1 << REISERFS_UNSUPPORTED_OPT},
1157                {"noacl",.clrmask = 1 << REISERFS_UNSUPPORTED_OPT},
1158#endif
1159                {.option_name = "nolog"},
1160                {"replayonly",.setmask = 1 << REPLAYONLY},
1161                {"block-allocator",.arg_required = 'a',.values = balloc},
1162                {"data",.arg_required = 'd',.values = logging_mode},
1163                {"barrier",.arg_required = 'b',.values = barrier_mode},
1164                {"resize",.arg_required = 'r',.values = NULL},
1165                {"jdev",.arg_required = 'j',.values = NULL},
1166                {"nolargeio",.arg_required = 'w',.values = NULL},
1167                {"commit",.arg_required = 'c',.values = NULL},
1168                {"usrquota",.setmask = 1 << REISERFS_USRQUOTA},
1169                {"grpquota",.setmask = 1 << REISERFS_GRPQUOTA},
1170                {"noquota",.clrmask = 1 << REISERFS_USRQUOTA | 1 << REISERFS_GRPQUOTA},
1171                {"errors",.arg_required = 'e',.values = error_actions},
1172                {"usrjquota",.arg_required =
1173                 'u' | (1 << REISERFS_OPT_ALLOWEMPTY),.values = NULL},
1174                {"grpjquota",.arg_required =
1175                 'g' | (1 << REISERFS_OPT_ALLOWEMPTY),.values = NULL},
1176                {"jqfmt",.arg_required = 'f',.values = NULL},
1177                {.option_name = NULL}
1178        };
1179
1180        *blocks = 0;
1181        if (!options || !*options)
1182                /*
1183                 * use default configuration: create tails, journaling on, no
1184                 * conversion to newest format
1185                 */
1186                return 1;
1187
1188        for (pos = options; pos;) {
1189                c = reiserfs_getopt(s, &pos, opts, &arg, mount_options);
1190                if (c == -1)
1191                        /* wrong option is given */
1192                        return 0;
1193
1194                if (c == 'r') {
1195                        char *p;
1196
1197                        p = NULL;
1198                        /* "resize=NNN" or "resize=auto" */
1199
1200                        if (!strcmp(arg, "auto")) {
1201                                /* From JFS code, to auto-get the size. */
1202                                *blocks =
1203                                    i_size_read(s->s_bdev->bd_inode) >> s->
1204                                    s_blocksize_bits;
1205                        } else {
1206                                *blocks = simple_strtoul(arg, &p, 0);
1207                                if (*p != '\0') {
1208                                        /* NNN does not look like a number */
1209                                        reiserfs_warning(s, "super-6507",
1210                                                         "bad value %s for "
1211                                                         "-oresize\n", arg);
1212                                        return 0;
1213                                }
1214                        }
1215                }
1216
1217                if (c == 'c') {
1218                        char *p = NULL;
1219                        unsigned long val = simple_strtoul(arg, &p, 0);
1220                        /* commit=NNN (time in seconds) */
1221                        if (*p != '\0' || val >= (unsigned int)-1) {
1222                                reiserfs_warning(s, "super-6508",
1223                                                 "bad value %s for -ocommit\n",
1224                                                 arg);
1225                                return 0;
1226                        }
1227                        *commit_max_age = (unsigned int)val;
1228                }
1229
1230                if (c == 'w') {
1231                        reiserfs_warning(s, "super-6509", "nolargeio option "
1232                                         "is no longer supported");
1233                        return 0;
1234                }
1235
1236                if (c == 'j') {
1237                        if (arg && *arg && jdev_name) {
1238                                /* Hm, already assigned? */
1239                                if (*jdev_name) {
1240                                        reiserfs_warning(s, "super-6510",
1241                                                         "journal device was "
1242                                                         "already specified to "
1243                                                         "be %s", *jdev_name);
1244                                        return 0;
1245                                }
1246                                *jdev_name = arg;
1247                        }
1248                }
1249#ifdef CONFIG_QUOTA
1250                if (c == 'u' || c == 'g') {
1251                        int qtype = c == 'u' ? USRQUOTA : GRPQUOTA;
1252
1253                        if (sb_any_quota_loaded(s) &&
1254                            (!*arg != !REISERFS_SB(s)->s_qf_names[qtype])) {
1255                                reiserfs_warning(s, "super-6511",
1256                                                 "cannot change journaled "
1257                                                 "quota options when quota "
1258                                                 "turned on.");
1259                                return 0;
1260                        }
1261                        if (*arg) {     /* Some filename specified? */
1262                                if (REISERFS_SB(s)->s_qf_names[qtype]
1263                                    && strcmp(REISERFS_SB(s)->s_qf_names[qtype],
1264                                              arg)) {
1265                                        reiserfs_warning(s, "super-6512",
1266                                                         "%s quota file "
1267                                                         "already specified.",
1268                                                         QTYPE2NAME(qtype));
1269                                        return 0;
1270                                }
1271                                if (strchr(arg, '/')) {
1272                                        reiserfs_warning(s, "super-6513",
1273                                                         "quotafile must be "
1274                                                         "on filesystem root.");
1275                                        return 0;
1276                                }
1277                                qf_names[qtype] = kstrdup(arg, GFP_KERNEL);
1278                                if (!qf_names[qtype]) {
1279                                        reiserfs_warning(s, "reiserfs-2502",
1280                                                         "not enough memory "
1281                                                         "for storing "
1282                                                         "quotafile name.");
1283                                        return 0;
1284                                }
1285                                if (qtype == USRQUOTA)
1286                                        *mount_options |= 1 << REISERFS_USRQUOTA;
1287                                else
1288                                        *mount_options |= 1 << REISERFS_GRPQUOTA;
1289                        } else {
1290                                if (qf_names[qtype] !=
1291                                    REISERFS_SB(s)->s_qf_names[qtype])
1292                                        kfree(qf_names[qtype]);
1293                                qf_names[qtype] = NULL;
1294                                if (qtype == USRQUOTA)
1295                                        *mount_options &= ~(1 << REISERFS_USRQUOTA);
1296                                else
1297                                        *mount_options &= ~(1 << REISERFS_GRPQUOTA);
1298                        }
1299                }
1300                if (c == 'f') {
1301                        if (!strcmp(arg, "vfsold"))
1302                                *qfmt = QFMT_VFS_OLD;
1303                        else if (!strcmp(arg, "vfsv0"))
1304                                *qfmt = QFMT_VFS_V0;
1305                        else {
1306                                reiserfs_warning(s, "super-6514",
1307                                                 "unknown quota format "
1308                                                 "specified.");
1309                                return 0;
1310                        }
1311                        if (sb_any_quota_loaded(s) &&
1312                            *qfmt != REISERFS_SB(s)->s_jquota_fmt) {
1313                                reiserfs_warning(s, "super-6515",
1314                                                 "cannot change journaled "
1315                                                 "quota options when quota "
1316                                                 "turned on.");
1317                                return 0;
1318                        }
1319                }
1320#else
1321                if (c == 'u' || c == 'g' || c == 'f') {
1322                        reiserfs_warning(s, "reiserfs-2503", "journaled "
1323                                         "quota options not supported.");
1324                        return 0;
1325                }
1326#endif
1327        }
1328
1329#ifdef CONFIG_QUOTA
1330        if (!REISERFS_SB(s)->s_jquota_fmt && !*qfmt
1331            && (qf_names[USRQUOTA] || qf_names[GRPQUOTA])) {
1332                reiserfs_warning(s, "super-6515",
1333                                 "journaled quota format not specified.");
1334                return 0;
1335        }
1336        if ((!(*mount_options & (1 << REISERFS_USRQUOTA)) &&
1337               sb_has_quota_loaded(s, USRQUOTA)) ||
1338            (!(*mount_options & (1 << REISERFS_GRPQUOTA)) &&
1339               sb_has_quota_loaded(s, GRPQUOTA))) {
1340                reiserfs_warning(s, "super-6516", "quota options must "
1341                                 "be present when quota is turned on.");
1342                return 0;
1343        }
1344#endif
1345
1346        return 1;
1347}
1348
1349static void switch_data_mode(struct super_block *s, unsigned long mode)
1350{
1351        REISERFS_SB(s)->s_mount_opt &= ~((1 << REISERFS_DATA_LOG) |
1352                                         (1 << REISERFS_DATA_ORDERED) |
1353                                         (1 << REISERFS_DATA_WRITEBACK));
1354        REISERFS_SB(s)->s_mount_opt |= (1 << mode);
1355}
1356
1357static void handle_data_mode(struct super_block *s, unsigned long mount_options)
1358{
1359        if (mount_options & (1 << REISERFS_DATA_LOG)) {
1360                if (!reiserfs_data_log(s)) {
1361                        switch_data_mode(s, REISERFS_DATA_LOG);
1362                        reiserfs_info(s, "switching to journaled data mode\n");
1363                }
1364        } else if (mount_options & (1 << REISERFS_DATA_ORDERED)) {
1365                if (!reiserfs_data_ordered(s)) {
1366                        switch_data_mode(s, REISERFS_DATA_ORDERED);
1367                        reiserfs_info(s, "switching to ordered data mode\n");
1368                }
1369        } else if (mount_options & (1 << REISERFS_DATA_WRITEBACK)) {
1370                if (!reiserfs_data_writeback(s)) {
1371                        switch_data_mode(s, REISERFS_DATA_WRITEBACK);
1372                        reiserfs_info(s, "switching to writeback data mode\n");
1373                }
1374        }
1375}
1376
1377static void handle_barrier_mode(struct super_block *s, unsigned long bits)
1378{
1379        int flush = (1 << REISERFS_BARRIER_FLUSH);
1380        int none = (1 << REISERFS_BARRIER_NONE);
1381        int all_barrier = flush | none;
1382
1383        if (bits & all_barrier) {
1384                REISERFS_SB(s)->s_mount_opt &= ~all_barrier;
1385                if (bits & flush) {
1386                        REISERFS_SB(s)->s_mount_opt |= flush;
1387                        printk("reiserfs: enabling write barrier flush mode\n");
1388                } else if (bits & none) {
1389                        REISERFS_SB(s)->s_mount_opt |= none;
1390                        printk("reiserfs: write barriers turned off\n");
1391                }
1392        }
1393}
1394
1395static void handle_attrs(struct super_block *s)
1396{
1397        struct reiserfs_super_block *rs = SB_DISK_SUPER_BLOCK(s);
1398
1399        if (reiserfs_attrs(s)) {
1400                if (old_format_only(s)) {
1401                        reiserfs_warning(s, "super-6517", "cannot support "
1402                                         "attributes on 3.5.x disk format");
1403                        REISERFS_SB(s)->s_mount_opt &= ~(1 << REISERFS_ATTRS);
1404                        return;
1405                }
1406                if (!(le32_to_cpu(rs->s_flags) & reiserfs_attrs_cleared)) {
1407                        reiserfs_warning(s, "super-6518", "cannot support "
1408                                         "attributes until flag is set in "
1409                                         "super-block");
1410                        REISERFS_SB(s)->s_mount_opt &= ~(1 << REISERFS_ATTRS);
1411                }
1412        }
1413}
1414
1415#ifdef CONFIG_QUOTA
1416static void handle_quota_files(struct super_block *s, char **qf_names,
1417                               unsigned int *qfmt)
1418{
1419        int i;
1420
1421        for (i = 0; i < REISERFS_MAXQUOTAS; i++) {
1422                if (qf_names[i] != REISERFS_SB(s)->s_qf_names[i])
1423                        kfree(REISERFS_SB(s)->s_qf_names[i]);
1424                REISERFS_SB(s)->s_qf_names[i] = qf_names[i];
1425        }
1426        if (*qfmt)
1427                REISERFS_SB(s)->s_jquota_fmt = *qfmt;
1428}
1429#endif
1430
1431static int reiserfs_remount(struct super_block *s, int *mount_flags, char *arg)
1432{
1433        struct reiserfs_super_block *rs;
1434        struct reiserfs_transaction_handle th;
1435        unsigned long blocks;
1436        unsigned long mount_options = REISERFS_SB(s)->s_mount_opt;
1437        unsigned long safe_mask = 0;
1438        unsigned int commit_max_age = (unsigned int)-1;
1439        struct reiserfs_journal *journal = SB_JOURNAL(s);
1440        char *new_opts;
1441        int err;
1442        char *qf_names[REISERFS_MAXQUOTAS];
1443        unsigned int qfmt = 0;
1444#ifdef CONFIG_QUOTA
1445        int i;
1446#endif
1447
1448        new_opts = kstrdup(arg, GFP_KERNEL);
1449        if (arg && !new_opts)
1450                return -ENOMEM;
1451
1452        sync_filesystem(s);
1453        reiserfs_write_lock(s);
1454
1455#ifdef CONFIG_QUOTA
1456        memcpy(qf_names, REISERFS_SB(s)->s_qf_names, sizeof(qf_names));
1457#endif
1458
1459        rs = SB_DISK_SUPER_BLOCK(s);
1460
1461        if (!reiserfs_parse_options
1462            (s, arg, &mount_options, &blocks, NULL, &commit_max_age,
1463            qf_names, &qfmt)) {
1464#ifdef CONFIG_QUOTA
1465                for (i = 0; i < REISERFS_MAXQUOTAS; i++)
1466                        if (qf_names[i] != REISERFS_SB(s)->s_qf_names[i])
1467                                kfree(qf_names[i]);
1468#endif
1469                err = -EINVAL;
1470                goto out_err_unlock;
1471        }
1472#ifdef CONFIG_QUOTA
1473        handle_quota_files(s, qf_names, &qfmt);
1474#endif
1475
1476        handle_attrs(s);
1477
1478        /* Add options that are safe here */
1479        safe_mask |= 1 << REISERFS_SMALLTAIL;
1480        safe_mask |= 1 << REISERFS_LARGETAIL;
1481        safe_mask |= 1 << REISERFS_NO_BORDER;
1482        safe_mask |= 1 << REISERFS_NO_UNHASHED_RELOCATION;
1483        safe_mask |= 1 << REISERFS_HASHED_RELOCATION;
1484        safe_mask |= 1 << REISERFS_TEST4;
1485        safe_mask |= 1 << REISERFS_ATTRS;
1486        safe_mask |= 1 << REISERFS_XATTRS_USER;
1487        safe_mask |= 1 << REISERFS_POSIXACL;
1488        safe_mask |= 1 << REISERFS_BARRIER_FLUSH;
1489        safe_mask |= 1 << REISERFS_BARRIER_NONE;
1490        safe_mask |= 1 << REISERFS_ERROR_RO;
1491        safe_mask |= 1 << REISERFS_ERROR_CONTINUE;
1492        safe_mask |= 1 << REISERFS_ERROR_PANIC;
1493        safe_mask |= 1 << REISERFS_USRQUOTA;
1494        safe_mask |= 1 << REISERFS_GRPQUOTA;
1495
1496        /*
1497         * Update the bitmask, taking care to keep
1498         * the bits we're not allowed to change here
1499         */
1500        REISERFS_SB(s)->s_mount_opt =
1501            (REISERFS_SB(s)->
1502             s_mount_opt & ~safe_mask) | (mount_options & safe_mask);
1503
1504        if (commit_max_age != 0 && commit_max_age != (unsigned int)-1) {
1505                journal->j_max_commit_age = commit_max_age;
1506                journal->j_max_trans_age = commit_max_age;
1507        } else if (commit_max_age == 0) {
1508                /* 0 means restore defaults. */
1509                journal->j_max_commit_age = journal->j_default_max_commit_age;
1510                journal->j_max_trans_age = JOURNAL_MAX_TRANS_AGE;
1511        }
1512
1513        if (blocks) {
1514                err = reiserfs_resize(s, blocks);
1515                if (err != 0)
1516                        goto out_err_unlock;
1517        }
1518
1519        if (*mount_flags & SB_RDONLY) {
1520                reiserfs_write_unlock(s);
1521                reiserfs_xattr_init(s, *mount_flags);
1522                /* remount read-only */
1523                if (sb_rdonly(s))
1524                        /* it is read-only already */
1525                        goto out_ok_unlocked;
1526
1527                err = dquot_suspend(s, -1);
1528                if (err < 0)
1529                        goto out_err;
1530
1531                /* try to remount file system with read-only permissions */
1532                if (sb_umount_state(rs) == REISERFS_VALID_FS
1533                    || REISERFS_SB(s)->s_mount_state != REISERFS_VALID_FS) {
1534                        goto out_ok_unlocked;
1535                }
1536
1537                reiserfs_write_lock(s);
1538
1539                err = journal_begin(&th, s, 10);
1540                if (err)
1541                        goto out_err_unlock;
1542
1543                /* Mounting a rw partition read-only. */
1544                reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1);
1545                set_sb_umount_state(rs, REISERFS_SB(s)->s_mount_state);
1546                journal_mark_dirty(&th, SB_BUFFER_WITH_SB(s));
1547        } else {
1548                /* remount read-write */
1549                if (!sb_rdonly(s)) {
1550                        reiserfs_write_unlock(s);
1551                        reiserfs_xattr_init(s, *mount_flags);
1552                        goto out_ok_unlocked;   /* We are read-write already */
1553                }
1554
1555                if (reiserfs_is_journal_aborted(journal)) {
1556                        err = journal->j_errno;
1557                        goto out_err_unlock;
1558                }
1559
1560                handle_data_mode(s, mount_options);
1561                handle_barrier_mode(s, mount_options);
1562                REISERFS_SB(s)->s_mount_state = sb_umount_state(rs);
1563
1564                /* now it is safe to call journal_begin */
1565                s->s_flags &= ~SB_RDONLY;
1566                err = journal_begin(&th, s, 10);
1567                if (err)
1568                        goto out_err_unlock;
1569
1570                /* Mount a partition which is read-only, read-write */
1571                reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1);
1572                REISERFS_SB(s)->s_mount_state = sb_umount_state(rs);
1573                s->s_flags &= ~SB_RDONLY;
1574                set_sb_umount_state(rs, REISERFS_ERROR_FS);
1575                if (!old_format_only(s))
1576                        set_sb_mnt_count(rs, sb_mnt_count(rs) + 1);
1577                /* mark_buffer_dirty (SB_BUFFER_WITH_SB (s), 1); */
1578                journal_mark_dirty(&th, SB_BUFFER_WITH_SB(s));
1579                REISERFS_SB(s)->s_mount_state = REISERFS_VALID_FS;
1580        }
1581        /* this will force a full flush of all journal lists */
1582        SB_JOURNAL(s)->j_must_wait = 1;
1583        err = journal_end(&th);
1584        if (err)
1585                goto out_err_unlock;
1586
1587        reiserfs_write_unlock(s);
1588        if (!(*mount_flags & SB_RDONLY)) {
1589                dquot_resume(s, -1);
1590                reiserfs_write_lock(s);
1591                finish_unfinished(s);
1592                reiserfs_write_unlock(s);
1593                reiserfs_xattr_init(s, *mount_flags);
1594        }
1595
1596out_ok_unlocked:
1597        return 0;
1598
1599out_err_unlock:
1600        reiserfs_write_unlock(s);
1601out_err:
1602        kfree(new_opts);
1603        return err;
1604}
1605
1606static int read_super_block(struct super_block *s, int offset)
1607{
1608        struct buffer_head *bh;
1609        struct reiserfs_super_block *rs;
1610        int fs_blocksize;
1611
1612        bh = sb_bread(s, offset / s->s_blocksize);
1613        if (!bh) {
1614                reiserfs_warning(s, "sh-2006",
1615                                 "bread failed (dev %s, block %lu, size %lu)",
1616                                 s->s_id, offset / s->s_blocksize,
1617                                 s->s_blocksize);
1618                return 1;
1619        }
1620
1621        rs = (struct reiserfs_super_block *)bh->b_data;
1622        if (!is_any_reiserfs_magic_string(rs)) {
1623                brelse(bh);
1624                return 1;
1625        }
1626        /*
1627         * ok, reiserfs signature (old or new) found in at the given offset
1628         */
1629        fs_blocksize = sb_blocksize(rs);
1630        brelse(bh);
1631        sb_set_blocksize(s, fs_blocksize);
1632
1633        bh = sb_bread(s, offset / s->s_blocksize);
1634        if (!bh) {
1635                reiserfs_warning(s, "sh-2007",
1636                                 "bread failed (dev %s, block %lu, size %lu)",
1637                                 s->s_id, offset / s->s_blocksize,
1638                                 s->s_blocksize);
1639                return 1;
1640        }
1641
1642        rs = (struct reiserfs_super_block *)bh->b_data;
1643        if (sb_blocksize(rs) != s->s_blocksize) {
1644                reiserfs_warning(s, "sh-2011", "can't find a reiserfs "
1645                                 "filesystem on (dev %s, block %llu, size %lu)",
1646                                 s->s_id,
1647                                 (unsigned long long)bh->b_blocknr,
1648                                 s->s_blocksize);
1649                brelse(bh);
1650                return 1;
1651        }
1652
1653        if (rs->s_v1.s_root_block == cpu_to_le32(-1)) {
1654                brelse(bh);
1655                reiserfs_warning(s, "super-6519", "Unfinished reiserfsck "
1656                                 "--rebuild-tree run detected. Please run\n"
1657                                 "reiserfsck --rebuild-tree and wait for a "
1658                                 "completion. If that fails\n"
1659                                 "get newer reiserfsprogs package");
1660                return 1;
1661        }
1662
1663        SB_BUFFER_WITH_SB(s) = bh;
1664        SB_DISK_SUPER_BLOCK(s) = rs;
1665
1666        /*
1667         * magic is of non-standard journal filesystem, look at s_version to
1668         * find which format is in use
1669         */
1670        if (is_reiserfs_jr(rs)) {
1671                if (sb_version(rs) == REISERFS_VERSION_2)
1672                        reiserfs_info(s, "found reiserfs format \"3.6\""
1673                                      " with non-standard journal\n");
1674                else if (sb_version(rs) == REISERFS_VERSION_1)
1675                        reiserfs_info(s, "found reiserfs format \"3.5\""
1676                                      " with non-standard journal\n");
1677                else {
1678                        reiserfs_warning(s, "sh-2012", "found unknown "
1679                                         "format \"%u\" of reiserfs with "
1680                                         "non-standard magic", sb_version(rs));
1681                        return 1;
1682                }
1683        } else
1684                /*
1685                 * s_version of standard format may contain incorrect
1686                 * information, so we just look at the magic string
1687                 */
1688                reiserfs_info(s,
1689                              "found reiserfs format \"%s\" with standard journal\n",
1690                              is_reiserfs_3_5(rs) ? "3.5" : "3.6");
1691
1692        s->s_op = &reiserfs_sops;
1693        s->s_export_op = &reiserfs_export_ops;
1694#ifdef CONFIG_QUOTA
1695        s->s_qcop = &reiserfs_qctl_operations;
1696        s->dq_op = &reiserfs_quota_operations;
1697        s->s_quota_types = QTYPE_MASK_USR | QTYPE_MASK_GRP;
1698#endif
1699
1700        /*
1701         * new format is limited by the 32 bit wide i_blocks field, want to
1702         * be one full block below that.
1703         */
1704        s->s_maxbytes = (512LL << 32) - s->s_blocksize;
1705        return 0;
1706}
1707
1708/* after journal replay, reread all bitmap and super blocks */
1709static int reread_meta_blocks(struct super_block *s)
1710{
1711        ll_rw_block(REQ_OP_READ, 0, 1, &SB_BUFFER_WITH_SB(s));
1712        wait_on_buffer(SB_BUFFER_WITH_SB(s));
1713        if (!buffer_uptodate(SB_BUFFER_WITH_SB(s))) {
1714                reiserfs_warning(s, "reiserfs-2504", "error reading the super");
1715                return 1;
1716        }
1717
1718        return 0;
1719}
1720
1721/* hash detection stuff */
1722
1723/*
1724 * if root directory is empty - we set default - Yura's - hash and
1725 * warn about it
1726 * FIXME: we look for only one name in a directory. If tea and yura
1727 * both have the same value - we ask user to send report to the
1728 * mailing list
1729 */
1730static __u32 find_hash_out(struct super_block *s)
1731{
1732        int retval;
1733        struct inode *inode;
1734        struct cpu_key key;
1735        INITIALIZE_PATH(path);
1736        struct reiserfs_dir_entry de;
1737        struct reiserfs_de_head *deh;
1738        __u32 hash = DEFAULT_HASH;
1739        __u32 deh_hashval, teahash, r5hash, yurahash;
1740
1741        inode = d_inode(s->s_root);
1742
1743        make_cpu_key(&key, inode, ~0, TYPE_DIRENTRY, 3);
1744        retval = search_by_entry_key(s, &key, &path, &de);
1745        if (retval == IO_ERROR) {
1746                pathrelse(&path);
1747                return UNSET_HASH;
1748        }
1749        if (retval == NAME_NOT_FOUND)
1750                de.de_entry_num--;
1751
1752        set_de_name_and_namelen(&de);
1753        deh = de.de_deh + de.de_entry_num;
1754
1755        if (deh_offset(deh) == DOT_DOT_OFFSET) {
1756                /* allow override in this case */
1757                if (reiserfs_rupasov_hash(s))
1758                        hash = YURA_HASH;
1759                reiserfs_info(s, "FS seems to be empty, autodetect is using the default hash\n");
1760                goto out;
1761        }
1762
1763        deh_hashval = GET_HASH_VALUE(deh_offset(deh));
1764        r5hash = GET_HASH_VALUE(r5_hash(de.de_name, de.de_namelen));
1765        teahash = GET_HASH_VALUE(keyed_hash(de.de_name, de.de_namelen));
1766        yurahash = GET_HASH_VALUE(yura_hash(de.de_name, de.de_namelen));
1767
1768        if ((teahash == r5hash && deh_hashval == r5hash) ||
1769            (teahash == yurahash && deh_hashval == yurahash) ||
1770            (r5hash == yurahash && deh_hashval == yurahash)) {
1771                reiserfs_warning(s, "reiserfs-2506",
1772                                 "Unable to automatically detect hash "
1773                                 "function. Please mount with -o "
1774                                 "hash={tea,rupasov,r5}");
1775                hash = UNSET_HASH;
1776                goto out;
1777        }
1778
1779        if (deh_hashval == yurahash)
1780                hash = YURA_HASH;
1781        else if (deh_hashval == teahash)
1782                hash = TEA_HASH;
1783        else if (deh_hashval == r5hash)
1784                hash = R5_HASH;
1785        else {
1786                reiserfs_warning(s, "reiserfs-2506",
1787                                 "Unrecognised hash function");
1788                hash = UNSET_HASH;
1789        }
1790out:
1791        pathrelse(&path);
1792        return hash;
1793}
1794
1795/* finds out which hash names are sorted with */
1796static int what_hash(struct super_block *s)
1797{
1798        __u32 code;
1799
1800        code = sb_hash_function_code(SB_DISK_SUPER_BLOCK(s));
1801
1802        /*
1803         * reiserfs_hash_detect() == true if any of the hash mount options
1804         * were used.  We must check them to make sure the user isn't
1805         * using a bad hash value
1806         */
1807        if (code == UNSET_HASH || reiserfs_hash_detect(s))
1808                code = find_hash_out(s);
1809
1810        if (code != UNSET_HASH && reiserfs_hash_detect(s)) {
1811                /*
1812                 * detection has found the hash, and we must check against the
1813                 * mount options
1814                 */
1815                if (reiserfs_rupasov_hash(s) && code != YURA_HASH) {
1816                        reiserfs_warning(s, "reiserfs-2507",
1817                                         "Error, %s hash detected, "
1818                                         "unable to force rupasov hash",
1819                                         reiserfs_hashname(code));
1820                        code = UNSET_HASH;
1821                } else if (reiserfs_tea_hash(s) && code != TEA_HASH) {
1822                        reiserfs_warning(s, "reiserfs-2508",
1823                                         "Error, %s hash detected, "
1824                                         "unable to force tea hash",
1825                                         reiserfs_hashname(code));
1826                        code = UNSET_HASH;
1827                } else if (reiserfs_r5_hash(s) && code != R5_HASH) {
1828                        reiserfs_warning(s, "reiserfs-2509",
1829                                         "Error, %s hash detected, "
1830                                         "unable to force r5 hash",
1831                                         reiserfs_hashname(code));
1832                        code = UNSET_HASH;
1833                }
1834        } else {
1835                /*
1836                 * find_hash_out was not called or
1837                 * could not determine the hash
1838                 */
1839                if (reiserfs_rupasov_hash(s)) {
1840                        code = YURA_HASH;
1841                } else if (reiserfs_tea_hash(s)) {
1842                        code = TEA_HASH;
1843                } else if (reiserfs_r5_hash(s)) {
1844                        code = R5_HASH;
1845                }
1846        }
1847
1848        /*
1849         * if we are mounted RW, and we have a new valid hash code, update
1850         * the super
1851         */
1852        if (code != UNSET_HASH &&
1853            !sb_rdonly(s) &&
1854            code != sb_hash_function_code(SB_DISK_SUPER_BLOCK(s))) {
1855                set_sb_hash_function_code(SB_DISK_SUPER_BLOCK(s), code);
1856        }
1857        return code;
1858}
1859
1860/* return pointer to appropriate function */
1861static hashf_t hash_function(struct super_block *s)
1862{
1863        switch (what_hash(s)) {
1864        case TEA_HASH:
1865                reiserfs_info(s, "Using tea hash to sort names\n");
1866                return keyed_hash;
1867        case YURA_HASH:
1868                reiserfs_info(s, "Using rupasov hash to sort names\n");
1869                return yura_hash;
1870        case R5_HASH:
1871                reiserfs_info(s, "Using r5 hash to sort names\n");
1872                return r5_hash;
1873        }
1874        return NULL;
1875}
1876
1877/* this is used to set up correct value for old partitions */
1878static int function2code(hashf_t func)
1879{
1880        if (func == keyed_hash)
1881                return TEA_HASH;
1882        if (func == yura_hash)
1883                return YURA_HASH;
1884        if (func == r5_hash)
1885                return R5_HASH;
1886
1887        BUG();                  /* should never happen */
1888
1889        return 0;
1890}
1891
1892#define SWARN(silent, s, id, ...)                       \
1893        if (!(silent))                          \
1894                reiserfs_warning(s, id, __VA_ARGS__)
1895
1896static int reiserfs_fill_super(struct super_block *s, void *data, int silent)
1897{
1898        struct inode *root_inode;
1899        struct reiserfs_transaction_handle th;
1900        int old_format = 0;
1901        unsigned long blocks;
1902        unsigned int commit_max_age = 0;
1903        int jinit_done = 0;
1904        struct reiserfs_iget_args args;
1905        struct reiserfs_super_block *rs;
1906        char *jdev_name;
1907        struct reiserfs_sb_info *sbi;
1908        int errval = -EINVAL;
1909        char *qf_names[REISERFS_MAXQUOTAS] = {};
1910        unsigned int qfmt = 0;
1911
1912        sbi = kzalloc(sizeof(struct reiserfs_sb_info), GFP_KERNEL);
1913        if (!sbi)
1914                return -ENOMEM;
1915        s->s_fs_info = sbi;
1916        /* Set default values for options: non-aggressive tails, RO on errors */
1917        sbi->s_mount_opt |= (1 << REISERFS_SMALLTAIL);
1918        sbi->s_mount_opt |= (1 << REISERFS_ERROR_RO);
1919        sbi->s_mount_opt |= (1 << REISERFS_BARRIER_FLUSH);
1920        /* no preallocation minimum, be smart in reiserfs_file_write instead */
1921        sbi->s_alloc_options.preallocmin = 0;
1922        /* Preallocate by 16 blocks (17-1) at once */
1923        sbi->s_alloc_options.preallocsize = 17;
1924        /* setup default block allocator options */
1925        reiserfs_init_alloc_options(s);
1926
1927        spin_lock_init(&sbi->old_work_lock);
1928        INIT_DELAYED_WORK(&sbi->old_work, flush_old_commits);
1929        mutex_init(&sbi->lock);
1930        sbi->lock_depth = -1;
1931
1932        sbi->commit_wq = alloc_workqueue("reiserfs/%s", WQ_MEM_RECLAIM, 0,
1933                                         s->s_id);
1934        if (!sbi->commit_wq) {
1935                SWARN(silent, s, "", "Cannot allocate commit workqueue");
1936                errval = -ENOMEM;
1937                goto error_unlocked;
1938        }
1939
1940        jdev_name = NULL;
1941        if (reiserfs_parse_options
1942            (s, (char *)data, &sbi->s_mount_opt, &blocks, &jdev_name,
1943             &commit_max_age, qf_names, &qfmt) == 0) {
1944                goto error_unlocked;
1945        }
1946        if (jdev_name && jdev_name[0]) {
1947                sbi->s_jdev = kstrdup(jdev_name, GFP_KERNEL);
1948                if (!sbi->s_jdev) {
1949                        SWARN(silent, s, "", "Cannot allocate memory for "
1950                                "journal device name");
1951                        goto error_unlocked;
1952                }
1953        }
1954#ifdef CONFIG_QUOTA
1955        handle_quota_files(s, qf_names, &qfmt);
1956#endif
1957
1958        if (blocks) {
1959                SWARN(silent, s, "jmacd-7", "resize option for remount only");
1960                goto error_unlocked;
1961        }
1962
1963        /*
1964         * try old format (undistributed bitmap, super block in 8-th 1k
1965         * block of a device)
1966         */
1967        if (!read_super_block(s, REISERFS_OLD_DISK_OFFSET_IN_BYTES))
1968                old_format = 1;
1969
1970        /*
1971         * try new format (64-th 1k block), which can contain reiserfs
1972         * super block
1973         */
1974        else if (read_super_block(s, REISERFS_DISK_OFFSET_IN_BYTES)) {
1975                SWARN(silent, s, "sh-2021", "can not find reiserfs on %s",
1976                      s->s_id);
1977                goto error_unlocked;
1978        }
1979
1980        s->s_time_min = 0;
1981        s->s_time_max = U32_MAX;
1982
1983        rs = SB_DISK_SUPER_BLOCK(s);
1984        /*
1985         * Let's do basic sanity check to verify that underlying device is not
1986         * smaller than the filesystem. If the check fails then abort and
1987         * scream, because bad stuff will happen otherwise.
1988         */
1989        if (s->s_bdev && s->s_bdev->bd_inode
1990            && i_size_read(s->s_bdev->bd_inode) <
1991            sb_block_count(rs) * sb_blocksize(rs)) {
1992                SWARN(silent, s, "", "Filesystem cannot be "
1993                      "mounted because it is bigger than the device");
1994                SWARN(silent, s, "", "You may need to run fsck "
1995                      "or increase size of your LVM partition");
1996                SWARN(silent, s, "", "Or may be you forgot to "
1997                      "reboot after fdisk when it told you to");
1998                goto error_unlocked;
1999        }
2000
2001        sbi->s_mount_state = SB_REISERFS_STATE(s);
2002        sbi->s_mount_state = REISERFS_VALID_FS;
2003
2004        if ((errval = reiserfs_init_bitmap_cache(s))) {
2005                SWARN(silent, s, "jmacd-8", "unable to read bitmap");
2006                goto error_unlocked;
2007        }
2008
2009        errval = -EINVAL;
2010#ifdef CONFIG_REISERFS_CHECK
2011        SWARN(silent, s, "", "CONFIG_REISERFS_CHECK is set ON");
2012        SWARN(silent, s, "", "- it is slow mode for debugging.");
2013#endif
2014
2015        /* make data=ordered the default */
2016        if (!reiserfs_data_log(s) && !reiserfs_data_ordered(s) &&
2017            !reiserfs_data_writeback(s)) {
2018                sbi->s_mount_opt |= (1 << REISERFS_DATA_ORDERED);
2019        }
2020
2021        if (reiserfs_data_log(s)) {
2022                reiserfs_info(s, "using journaled data mode\n");
2023        } else if (reiserfs_data_ordered(s)) {
2024                reiserfs_info(s, "using ordered data mode\n");
2025        } else {
2026                reiserfs_info(s, "using writeback data mode\n");
2027        }
2028        if (reiserfs_barrier_flush(s)) {
2029                printk("reiserfs: using flush barriers\n");
2030        }
2031
2032        if (journal_init(s, jdev_name, old_format, commit_max_age)) {
2033                SWARN(silent, s, "sh-2022",
2034                      "unable to initialize journal space");
2035                goto error_unlocked;
2036        } else {
2037                /*
2038                 * once this is set, journal_release must be called
2039                 * if we error out of the mount
2040                 */
2041                jinit_done = 1;
2042        }
2043
2044        if (reread_meta_blocks(s)) {
2045                SWARN(silent, s, "jmacd-9",
2046                      "unable to reread meta blocks after journal init");
2047                goto error_unlocked;
2048        }
2049
2050        if (replay_only(s))
2051                goto error_unlocked;
2052
2053        s->s_xattr = reiserfs_xattr_handlers;
2054
2055        if (bdev_read_only(s->s_bdev) && !sb_rdonly(s)) {
2056                SWARN(silent, s, "clm-7000",
2057                      "Detected readonly device, marking FS readonly");
2058                s->s_flags |= SB_RDONLY;
2059        }
2060        args.objectid = REISERFS_ROOT_OBJECTID;
2061        args.dirid = REISERFS_ROOT_PARENT_OBJECTID;
2062        root_inode =
2063            iget5_locked(s, REISERFS_ROOT_OBJECTID, reiserfs_find_actor,
2064                         reiserfs_init_locked_inode, (void *)&args);
2065        if (!root_inode) {
2066                SWARN(silent, s, "jmacd-10", "get root inode failed");
2067                goto error_unlocked;
2068        }
2069
2070        /*
2071         * This path assumed to be called with the BKL in the old times.
2072         * Now we have inherited the big reiserfs lock from it and many
2073         * reiserfs helpers called in the mount path and elsewhere require
2074         * this lock to be held even if it's not always necessary. Let's be
2075         * conservative and hold it early. The window can be reduced after
2076         * careful review of the code.
2077         */
2078        reiserfs_write_lock(s);
2079
2080        if (root_inode->i_state & I_NEW) {
2081                reiserfs_read_locked_inode(root_inode, &args);
2082                unlock_new_inode(root_inode);
2083        }
2084
2085        s->s_root = d_make_root(root_inode);
2086        if (!s->s_root)
2087                goto error;
2088        /* define and initialize hash function */
2089        sbi->s_hash_function = hash_function(s);
2090        if (sbi->s_hash_function == NULL) {
2091                dput(s->s_root);
2092                s->s_root = NULL;
2093                goto error;
2094        }
2095
2096        if (is_reiserfs_3_5(rs)
2097            || (is_reiserfs_jr(rs) && SB_VERSION(s) == REISERFS_VERSION_1))
2098                set_bit(REISERFS_3_5, &sbi->s_properties);
2099        else if (old_format)
2100                set_bit(REISERFS_OLD_FORMAT, &sbi->s_properties);
2101        else
2102                set_bit(REISERFS_3_6, &sbi->s_properties);
2103
2104        if (!sb_rdonly(s)) {
2105
2106                errval = journal_begin(&th, s, 1);
2107                if (errval) {
2108                        dput(s->s_root);
2109                        s->s_root = NULL;
2110                        goto error;
2111                }
2112                reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1);
2113
2114                set_sb_umount_state(rs, REISERFS_ERROR_FS);
2115                set_sb_fs_state(rs, 0);
2116
2117                /*
2118                 * Clear out s_bmap_nr if it would wrap. We can handle this
2119                 * case, but older revisions can't. This will cause the
2120                 * file system to fail mount on those older implementations,
2121                 * avoiding corruption. -jeffm
2122                 */
2123                if (bmap_would_wrap(reiserfs_bmap_count(s)) &&
2124                    sb_bmap_nr(rs) != 0) {
2125                        reiserfs_warning(s, "super-2030", "This file system "
2126                                        "claims to use %u bitmap blocks in "
2127                                        "its super block, but requires %u. "
2128                                        "Clearing to zero.", sb_bmap_nr(rs),
2129                                        reiserfs_bmap_count(s));
2130
2131                        set_sb_bmap_nr(rs, 0);
2132                }
2133
2134                if (old_format_only(s)) {
2135                        /*
2136                         * filesystem of format 3.5 either with standard
2137                         * or non-standard journal
2138                         */
2139                        if (convert_reiserfs(s)) {
2140                                /* and -o conv is given */
2141                                if (!silent)
2142                                        reiserfs_info(s,
2143                                                      "converting 3.5 filesystem to the 3.6 format");
2144
2145                                if (is_reiserfs_3_5(rs))
2146                                        /*
2147                                         * put magic string of 3.6 format.
2148                                         * 2.2 will not be able to
2149                                         * mount this filesystem anymore
2150                                         */
2151                                        memcpy(rs->s_v1.s_magic,
2152                                               reiserfs_3_6_magic_string,
2153                                               sizeof
2154                                               (reiserfs_3_6_magic_string));
2155
2156                                set_sb_version(rs, REISERFS_VERSION_2);
2157                                reiserfs_convert_objectid_map_v1(s);
2158                                set_bit(REISERFS_3_6, &sbi->s_properties);
2159                                clear_bit(REISERFS_3_5, &sbi->s_properties);
2160                        } else if (!silent) {
2161                                reiserfs_info(s, "using 3.5.x disk format\n");
2162                        }
2163                } else
2164                        set_sb_mnt_count(rs, sb_mnt_count(rs) + 1);
2165
2166
2167                journal_mark_dirty(&th, SB_BUFFER_WITH_SB(s));
2168                errval = journal_end(&th);
2169                if (errval) {
2170                        dput(s->s_root);
2171                        s->s_root = NULL;
2172                        goto error;
2173                }
2174
2175                reiserfs_write_unlock(s);
2176                if ((errval = reiserfs_lookup_privroot(s)) ||
2177                    (errval = reiserfs_xattr_init(s, s->s_flags))) {
2178                        dput(s->s_root);
2179                        s->s_root = NULL;
2180                        goto error_unlocked;
2181                }
2182                reiserfs_write_lock(s);
2183
2184                /*
2185                 * look for files which were to be removed in previous session
2186                 */
2187                finish_unfinished(s);
2188        } else {
2189                if (old_format_only(s) && !silent) {
2190                        reiserfs_info(s, "using 3.5.x disk format\n");
2191                }
2192
2193                reiserfs_write_unlock(s);
2194                if ((errval = reiserfs_lookup_privroot(s)) ||
2195                    (errval = reiserfs_xattr_init(s, s->s_flags))) {
2196                        dput(s->s_root);
2197                        s->s_root = NULL;
2198                        goto error_unlocked;
2199                }
2200                reiserfs_write_lock(s);
2201        }
2202        /*
2203         * mark hash in super block: it could be unset. overwrite should be ok
2204         */
2205        set_sb_hash_function_code(rs, function2code(sbi->s_hash_function));
2206
2207        handle_attrs(s);
2208
2209        reiserfs_proc_info_init(s);
2210
2211        init_waitqueue_head(&(sbi->s_wait));
2212        spin_lock_init(&sbi->bitmap_lock);
2213
2214        reiserfs_write_unlock(s);
2215
2216        return (0);
2217
2218error:
2219        reiserfs_write_unlock(s);
2220
2221error_unlocked:
2222        /* kill the commit thread, free journal ram */
2223        if (jinit_done) {
2224                reiserfs_write_lock(s);
2225                journal_release_error(NULL, s);
2226                reiserfs_write_unlock(s);
2227        }
2228
2229        if (sbi->commit_wq)
2230                destroy_workqueue(sbi->commit_wq);
2231
2232        reiserfs_cancel_old_flush(s);
2233
2234        reiserfs_free_bitmap_cache(s);
2235        if (SB_BUFFER_WITH_SB(s))
2236                brelse(SB_BUFFER_WITH_SB(s));
2237#ifdef CONFIG_QUOTA
2238        {
2239                int j;
2240                for (j = 0; j < REISERFS_MAXQUOTAS; j++)
2241                        kfree(qf_names[j]);
2242        }
2243#endif
2244        kfree(sbi->s_jdev);
2245        kfree(sbi);
2246
2247        s->s_fs_info = NULL;
2248        return errval;
2249}
2250
2251static int reiserfs_statfs(struct dentry *dentry, struct kstatfs *buf)
2252{
2253        struct reiserfs_super_block *rs = SB_DISK_SUPER_BLOCK(dentry->d_sb);
2254
2255        buf->f_namelen = (REISERFS_MAX_NAME(s->s_blocksize));
2256        buf->f_bfree = sb_free_blocks(rs);
2257        buf->f_bavail = buf->f_bfree;
2258        buf->f_blocks = sb_block_count(rs) - sb_bmap_nr(rs) - 1;
2259        buf->f_bsize = dentry->d_sb->s_blocksize;
2260        /* changed to accommodate gcc folks. */
2261        buf->f_type = REISERFS_SUPER_MAGIC;
2262        buf->f_fsid.val[0] = (u32)crc32_le(0, rs->s_uuid, sizeof(rs->s_uuid)/2);
2263        buf->f_fsid.val[1] = (u32)crc32_le(0, rs->s_uuid + sizeof(rs->s_uuid)/2,
2264                                sizeof(rs->s_uuid)/2);
2265
2266        return 0;
2267}
2268
2269#ifdef CONFIG_QUOTA
2270static int reiserfs_write_dquot(struct dquot *dquot)
2271{
2272        struct reiserfs_transaction_handle th;
2273        int ret, err;
2274        int depth;
2275
2276        reiserfs_write_lock(dquot->dq_sb);
2277        ret =
2278            journal_begin(&th, dquot->dq_sb,
2279                          REISERFS_QUOTA_TRANS_BLOCKS(dquot->dq_sb));
2280        if (ret)
2281                goto out;
2282        depth = reiserfs_write_unlock_nested(dquot->dq_sb);
2283        ret = dquot_commit(dquot);
2284        reiserfs_write_lock_nested(dquot->dq_sb, depth);
2285        err = journal_end(&th);
2286        if (!ret && err)
2287                ret = err;
2288out:
2289        reiserfs_write_unlock(dquot->dq_sb);
2290        return ret;
2291}
2292
2293static int reiserfs_acquire_dquot(struct dquot *dquot)
2294{
2295        struct reiserfs_transaction_handle th;
2296        int ret, err;
2297        int depth;
2298
2299        reiserfs_write_lock(dquot->dq_sb);
2300        ret =
2301            journal_begin(&th, dquot->dq_sb,
2302                          REISERFS_QUOTA_INIT_BLOCKS(dquot->dq_sb));
2303        if (ret)
2304                goto out;
2305        depth = reiserfs_write_unlock_nested(dquot->dq_sb);
2306        ret = dquot_acquire(dquot);
2307        reiserfs_write_lock_nested(dquot->dq_sb, depth);
2308        err = journal_end(&th);
2309        if (!ret && err)
2310                ret = err;
2311out:
2312        reiserfs_write_unlock(dquot->dq_sb);
2313        return ret;
2314}
2315
2316static int reiserfs_release_dquot(struct dquot *dquot)
2317{
2318        struct reiserfs_transaction_handle th;
2319        int ret, err;
2320
2321        reiserfs_write_lock(dquot->dq_sb);
2322        ret =
2323            journal_begin(&th, dquot->dq_sb,
2324                          REISERFS_QUOTA_DEL_BLOCKS(dquot->dq_sb));
2325        reiserfs_write_unlock(dquot->dq_sb);
2326        if (ret) {
2327                /* Release dquot anyway to avoid endless cycle in dqput() */
2328                dquot_release(dquot);
2329                goto out;
2330        }
2331        ret = dquot_release(dquot);
2332        reiserfs_write_lock(dquot->dq_sb);
2333        err = journal_end(&th);
2334        if (!ret && err)
2335                ret = err;
2336        reiserfs_write_unlock(dquot->dq_sb);
2337out:
2338        return ret;
2339}
2340
2341static int reiserfs_mark_dquot_dirty(struct dquot *dquot)
2342{
2343        /* Are we journaling quotas? */
2344        if (REISERFS_SB(dquot->dq_sb)->s_qf_names[USRQUOTA] ||
2345            REISERFS_SB(dquot->dq_sb)->s_qf_names[GRPQUOTA]) {
2346                dquot_mark_dquot_dirty(dquot);
2347                return reiserfs_write_dquot(dquot);
2348        } else
2349                return dquot_mark_dquot_dirty(dquot);
2350}
2351
2352static int reiserfs_write_info(struct super_block *sb, int type)
2353{
2354        struct reiserfs_transaction_handle th;
2355        int ret, err;
2356        int depth;
2357
2358        /* Data block + inode block */
2359        reiserfs_write_lock(sb);
2360        ret = journal_begin(&th, sb, 2);
2361        if (ret)
2362                goto out;
2363        depth = reiserfs_write_unlock_nested(sb);
2364        ret = dquot_commit_info(sb, type);
2365        reiserfs_write_lock_nested(sb, depth);
2366        err = journal_end(&th);
2367        if (!ret && err)
2368                ret = err;
2369out:
2370        reiserfs_write_unlock(sb);
2371        return ret;
2372}
2373
2374/*
2375 * Turn on quotas during mount time - we need to find the quota file and such...
2376 */
2377static int reiserfs_quota_on_mount(struct super_block *sb, int type)
2378{
2379        return dquot_quota_on_mount(sb, REISERFS_SB(sb)->s_qf_names[type],
2380                                        REISERFS_SB(sb)->s_jquota_fmt, type);
2381}
2382
2383/*
2384 * Standard function to be called on quota_on
2385 */
2386static int reiserfs_quota_on(struct super_block *sb, int type, int format_id,
2387                             const struct path *path)
2388{
2389        int err;
2390        struct inode *inode;
2391        struct reiserfs_transaction_handle th;
2392        int opt = type == USRQUOTA ? REISERFS_USRQUOTA : REISERFS_GRPQUOTA;
2393
2394        reiserfs_write_lock(sb);
2395        if (!(REISERFS_SB(sb)->s_mount_opt & (1 << opt))) {
2396                err = -EINVAL;
2397                goto out;
2398        }
2399
2400        /* Quotafile not on the same filesystem? */
2401        if (path->dentry->d_sb != sb) {
2402                err = -EXDEV;
2403                goto out;
2404        }
2405        inode = d_inode(path->dentry);
2406        /*
2407         * We must not pack tails for quota files on reiserfs for quota
2408         * IO to work
2409         */
2410        if (!(REISERFS_I(inode)->i_flags & i_nopack_mask)) {
2411                err = reiserfs_unpack(inode, NULL);
2412                if (err) {
2413                        reiserfs_warning(sb, "super-6520",
2414                                "Unpacking tail of quota file failed"
2415                                " (%d). Cannot turn on quotas.", err);
2416                        err = -EINVAL;
2417                        goto out;
2418                }
2419                mark_inode_dirty(inode);
2420        }
2421        /* Journaling quota? */
2422        if (REISERFS_SB(sb)->s_qf_names[type]) {
2423                /* Quotafile not of fs root? */
2424                if (path->dentry->d_parent != sb->s_root)
2425                        reiserfs_warning(sb, "super-6521",
2426                                 "Quota file not on filesystem root. "
2427                                 "Journalled quota will not work.");
2428        }
2429
2430        /*
2431         * When we journal data on quota file, we have to flush journal to see
2432         * all updates to the file when we bypass pagecache...
2433         */
2434        if (reiserfs_file_data_log(inode)) {
2435                /* Just start temporary transaction and finish it */
2436                err = journal_begin(&th, sb, 1);
2437                if (err)
2438                        goto out;
2439                err = journal_end_sync(&th);
2440                if (err)
2441                        goto out;
2442        }
2443        reiserfs_write_unlock(sb);
2444        err = dquot_quota_on(sb, type, format_id, path);
2445        if (!err) {
2446                inode_lock(inode);
2447                REISERFS_I(inode)->i_attrs |= REISERFS_IMMUTABLE_FL |
2448                                              REISERFS_NOATIME_FL;
2449                inode_set_flags(inode, S_IMMUTABLE | S_NOATIME,
2450                                S_IMMUTABLE | S_NOATIME);
2451                inode_unlock(inode);
2452                mark_inode_dirty(inode);
2453        }
2454        return err;
2455out:
2456        reiserfs_write_unlock(sb);
2457        return err;
2458}
2459
2460static int reiserfs_quota_off(struct super_block *sb, int type)
2461{
2462        int err;
2463        struct inode *inode = sb_dqopt(sb)->files[type];
2464
2465        if (!inode || !igrab(inode))
2466                goto out;
2467
2468        err = dquot_quota_off(sb, type);
2469        if (err)
2470                goto out_put;
2471
2472        inode_lock(inode);
2473        REISERFS_I(inode)->i_attrs &= ~(REISERFS_IMMUTABLE_FL |
2474                                        REISERFS_NOATIME_FL);
2475        inode_set_flags(inode, 0, S_IMMUTABLE | S_NOATIME);
2476        inode_unlock(inode);
2477        mark_inode_dirty(inode);
2478out_put:
2479        iput(inode);
2480        return err;
2481out:
2482        return dquot_quota_off(sb, type);
2483}
2484
2485/*
2486 * Read data from quotafile - avoid pagecache and such because we cannot afford
2487 * acquiring the locks... As quota files are never truncated and quota code
2488 * itself serializes the operations (and no one else should touch the files)
2489 * we don't have to be afraid of races
2490 */
2491static ssize_t reiserfs_quota_read(struct super_block *sb, int type, char *data,
2492                                   size_t len, loff_t off)
2493{
2494        struct inode *inode = sb_dqopt(sb)->files[type];
2495        unsigned long blk = off >> sb->s_blocksize_bits;
2496        int err = 0, offset = off & (sb->s_blocksize - 1), tocopy;
2497        size_t toread;
2498        struct buffer_head tmp_bh, *bh;
2499        loff_t i_size = i_size_read(inode);
2500
2501        if (off > i_size)
2502                return 0;
2503        if (off + len > i_size)
2504                len = i_size - off;
2505        toread = len;
2506        while (toread > 0) {
2507                tocopy =
2508                    sb->s_blocksize - offset <
2509                    toread ? sb->s_blocksize - offset : toread;
2510                tmp_bh.b_state = 0;
2511                /*
2512                 * Quota files are without tails so we can safely
2513                 * use this function
2514                 */
2515                reiserfs_write_lock(sb);
2516                err = reiserfs_get_block(inode, blk, &tmp_bh, 0);
2517                reiserfs_write_unlock(sb);
2518                if (err)
2519                        return err;
2520                if (!buffer_mapped(&tmp_bh))    /* A hole? */
2521                        memset(data, 0, tocopy);
2522                else {
2523                        bh = sb_bread(sb, tmp_bh.b_blocknr);
2524                        if (!bh)
2525                                return -EIO;
2526                        memcpy(data, bh->b_data + offset, tocopy);
2527                        brelse(bh);
2528                }
2529                offset = 0;
2530                toread -= tocopy;
2531                data += tocopy;
2532                blk++;
2533        }
2534        return len;
2535}
2536
2537/*
2538 * Write to quotafile (we know the transaction is already started and has
2539 * enough credits)
2540 */
2541static ssize_t reiserfs_quota_write(struct super_block *sb, int type,
2542                                    const char *data, size_t len, loff_t off)
2543{
2544        struct inode *inode = sb_dqopt(sb)->files[type];
2545        unsigned long blk = off >> sb->s_blocksize_bits;
2546        int err = 0, offset = off & (sb->s_blocksize - 1), tocopy;
2547        int journal_quota = REISERFS_SB(sb)->s_qf_names[type] != NULL;
2548        size_t towrite = len;
2549        struct buffer_head tmp_bh, *bh;
2550
2551        if (!current->journal_info) {
2552                printk(KERN_WARNING "reiserfs: Quota write (off=%llu, len=%llu) cancelled because transaction is not started.\n",
2553                        (unsigned long long)off, (unsigned long long)len);
2554                return -EIO;
2555        }
2556        while (towrite > 0) {
2557                tocopy = sb->s_blocksize - offset < towrite ?
2558                    sb->s_blocksize - offset : towrite;
2559                tmp_bh.b_state = 0;
2560                reiserfs_write_lock(sb);
2561                err = reiserfs_get_block(inode, blk, &tmp_bh, GET_BLOCK_CREATE);
2562                reiserfs_write_unlock(sb);
2563                if (err)
2564                        goto out;
2565                if (offset || tocopy != sb->s_blocksize)
2566                        bh = sb_bread(sb, tmp_bh.b_blocknr);
2567                else
2568                        bh = sb_getblk(sb, tmp_bh.b_blocknr);
2569                if (!bh) {
2570                        err = -EIO;
2571                        goto out;
2572                }
2573                lock_buffer(bh);
2574                memcpy(bh->b_data + offset, data, tocopy);
2575                flush_dcache_page(bh->b_page);
2576                set_buffer_uptodate(bh);
2577                unlock_buffer(bh);
2578                reiserfs_write_lock(sb);
2579                reiserfs_prepare_for_journal(sb, bh, 1);
2580                journal_mark_dirty(current->journal_info, bh);
2581                if (!journal_quota)
2582                        reiserfs_add_ordered_list(inode, bh);
2583                reiserfs_write_unlock(sb);
2584                brelse(bh);
2585                offset = 0;
2586                towrite -= tocopy;
2587                data += tocopy;
2588                blk++;
2589        }
2590out:
2591        if (len == towrite)
2592                return err;
2593        if (inode->i_size < off + len - towrite)
2594                i_size_write(inode, off + len - towrite);
2595        inode->i_mtime = inode->i_ctime = current_time(inode);
2596        mark_inode_dirty(inode);
2597        return len - towrite;
2598}
2599
2600#endif
2601
2602static struct dentry *get_super_block(struct file_system_type *fs_type,
2603                           int flags, const char *dev_name,
2604                           void *data)
2605{
2606        return mount_bdev(fs_type, flags, dev_name, data, reiserfs_fill_super);
2607}
2608
2609static int __init init_reiserfs_fs(void)
2610{
2611        int ret;
2612
2613        ret = init_inodecache();
2614        if (ret)
2615                return ret;
2616
2617        reiserfs_proc_info_global_init();
2618
2619        ret = register_filesystem(&reiserfs_fs_type);
2620        if (ret)
2621                goto out;
2622
2623        return 0;
2624out:
2625        reiserfs_proc_info_global_done();
2626        destroy_inodecache();
2627
2628        return ret;
2629}
2630
2631static void __exit exit_reiserfs_fs(void)
2632{
2633        reiserfs_proc_info_global_done();
2634        unregister_filesystem(&reiserfs_fs_type);
2635        destroy_inodecache();
2636}
2637
2638struct file_system_type reiserfs_fs_type = {
2639        .owner = THIS_MODULE,
2640        .name = "reiserfs",
2641        .mount = get_super_block,
2642        .kill_sb = reiserfs_kill_sb,
2643        .fs_flags = FS_REQUIRES_DEV,
2644};
2645MODULE_ALIAS_FS("reiserfs");
2646
2647MODULE_DESCRIPTION("ReiserFS journaled filesystem");
2648MODULE_AUTHOR("Hans Reiser <reiser@namesys.com>");
2649MODULE_LICENSE("GPL");
2650
2651module_init(init_reiserfs_fs);
2652module_exit(exit_reiserfs_fs);
2653