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