linux/fs/gfs2/ops_fstype.c
<<
>>
Prefs
   1/*
   2 * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
   3 * Copyright (C) 2004-2008 Red Hat, Inc.  All rights reserved.
   4 *
   5 * This copyrighted material is made available to anyone wishing to use,
   6 * modify, copy, or redistribute it subject to the terms and conditions
   7 * of the GNU General Public License version 2.
   8 */
   9
  10#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  11
  12#include <linux/sched.h>
  13#include <linux/slab.h>
  14#include <linux/spinlock.h>
  15#include <linux/completion.h>
  16#include <linux/buffer_head.h>
  17#include <linux/blkdev.h>
  18#include <linux/kthread.h>
  19#include <linux/export.h>
  20#include <linux/namei.h>
  21#include <linux/mount.h>
  22#include <linux/gfs2_ondisk.h>
  23#include <linux/quotaops.h>
  24#include <linux/lockdep.h>
  25#include <linux/module.h>
  26
  27#include "gfs2.h"
  28#include "incore.h"
  29#include "bmap.h"
  30#include "glock.h"
  31#include "glops.h"
  32#include "inode.h"
  33#include "recovery.h"
  34#include "rgrp.h"
  35#include "super.h"
  36#include "sys.h"
  37#include "util.h"
  38#include "log.h"
  39#include "quota.h"
  40#include "dir.h"
  41#include "meta_io.h"
  42#include "trace_gfs2.h"
  43
  44#define DO 0
  45#define UNDO 1
  46
  47/**
  48 * gfs2_tune_init - Fill a gfs2_tune structure with default values
  49 * @gt: tune
  50 *
  51 */
  52
  53static void gfs2_tune_init(struct gfs2_tune *gt)
  54{
  55        spin_lock_init(&gt->gt_spin);
  56
  57        gt->gt_quota_warn_period = 10;
  58        gt->gt_quota_scale_num = 1;
  59        gt->gt_quota_scale_den = 1;
  60        gt->gt_new_files_jdata = 0;
  61        gt->gt_max_readahead = 1 << 18;
  62        gt->gt_complain_secs = 10;
  63}
  64
  65static struct gfs2_sbd *init_sbd(struct super_block *sb)
  66{
  67        struct gfs2_sbd *sdp;
  68        struct address_space *mapping;
  69
  70        sdp = kzalloc(sizeof(struct gfs2_sbd), GFP_KERNEL);
  71        if (!sdp)
  72                return NULL;
  73
  74        sb->s_fs_info = sdp;
  75        sdp->sd_vfs = sb;
  76        sdp->sd_lkstats = alloc_percpu(struct gfs2_pcpu_lkstats);
  77        if (!sdp->sd_lkstats) {
  78                kfree(sdp);
  79                return NULL;
  80        }
  81
  82        set_bit(SDF_NOJOURNALID, &sdp->sd_flags);
  83        gfs2_tune_init(&sdp->sd_tune);
  84
  85        init_waitqueue_head(&sdp->sd_glock_wait);
  86        atomic_set(&sdp->sd_glock_disposal, 0);
  87        init_completion(&sdp->sd_locking_init);
  88        init_completion(&sdp->sd_wdack);
  89        spin_lock_init(&sdp->sd_statfs_spin);
  90
  91        spin_lock_init(&sdp->sd_rindex_spin);
  92        sdp->sd_rindex_tree.rb_node = NULL;
  93
  94        INIT_LIST_HEAD(&sdp->sd_jindex_list);
  95        spin_lock_init(&sdp->sd_jindex_spin);
  96        mutex_init(&sdp->sd_jindex_mutex);
  97        init_completion(&sdp->sd_journal_ready);
  98
  99        INIT_LIST_HEAD(&sdp->sd_quota_list);
 100        mutex_init(&sdp->sd_quota_mutex);
 101        mutex_init(&sdp->sd_quota_sync_mutex);
 102        init_waitqueue_head(&sdp->sd_quota_wait);
 103        INIT_LIST_HEAD(&sdp->sd_trunc_list);
 104        spin_lock_init(&sdp->sd_trunc_lock);
 105        spin_lock_init(&sdp->sd_bitmap_lock);
 106
 107        mapping = &sdp->sd_aspace;
 108
 109        address_space_init_once(mapping);
 110        mapping->a_ops = &gfs2_rgrp_aops;
 111        mapping->host = sb->s_bdev->bd_inode;
 112        mapping->flags = 0;
 113        mapping_set_gfp_mask(mapping, GFP_NOFS);
 114        mapping->private_data = NULL;
 115        mapping->writeback_index = 0;
 116
 117        spin_lock_init(&sdp->sd_log_lock);
 118        atomic_set(&sdp->sd_log_pinned, 0);
 119        INIT_LIST_HEAD(&sdp->sd_log_le_revoke);
 120        INIT_LIST_HEAD(&sdp->sd_log_le_ordered);
 121        spin_lock_init(&sdp->sd_ordered_lock);
 122
 123        init_waitqueue_head(&sdp->sd_log_waitq);
 124        init_waitqueue_head(&sdp->sd_logd_waitq);
 125        spin_lock_init(&sdp->sd_ail_lock);
 126        INIT_LIST_HEAD(&sdp->sd_ail1_list);
 127        INIT_LIST_HEAD(&sdp->sd_ail2_list);
 128
 129        init_rwsem(&sdp->sd_log_flush_lock);
 130        atomic_set(&sdp->sd_log_in_flight, 0);
 131        atomic_set(&sdp->sd_reserving_log, 0);
 132        init_waitqueue_head(&sdp->sd_reserving_log_wait);
 133        init_waitqueue_head(&sdp->sd_log_flush_wait);
 134        atomic_set(&sdp->sd_freeze_state, SFS_UNFROZEN);
 135        mutex_init(&sdp->sd_freeze_mutex);
 136
 137        return sdp;
 138}
 139
 140
 141/**
 142 * gfs2_check_sb - Check superblock
 143 * @sdp: the filesystem
 144 * @sb: The superblock
 145 * @silent: Don't print a message if the check fails
 146 *
 147 * Checks the version code of the FS is one that we understand how to
 148 * read and that the sizes of the various on-disk structures have not
 149 * changed.
 150 */
 151
 152static int gfs2_check_sb(struct gfs2_sbd *sdp, int silent)
 153{
 154        struct gfs2_sb_host *sb = &sdp->sd_sb;
 155
 156        if (sb->sb_magic != GFS2_MAGIC ||
 157            sb->sb_type != GFS2_METATYPE_SB) {
 158                if (!silent)
 159                        pr_warn("not a GFS2 filesystem\n");
 160                return -EINVAL;
 161        }
 162
 163        /*  If format numbers match exactly, we're done.  */
 164
 165        if (sb->sb_fs_format == GFS2_FORMAT_FS &&
 166            sb->sb_multihost_format == GFS2_FORMAT_MULTI)
 167                return 0;
 168
 169        fs_warn(sdp, "Unknown on-disk format, unable to mount\n");
 170
 171        return -EINVAL;
 172}
 173
 174static void end_bio_io_page(struct bio *bio)
 175{
 176        struct page *page = bio->bi_private;
 177
 178        if (!bio->bi_error)
 179                SetPageUptodate(page);
 180        else
 181                pr_warn("error %d reading superblock\n", bio->bi_error);
 182        unlock_page(page);
 183}
 184
 185static void gfs2_sb_in(struct gfs2_sbd *sdp, const void *buf)
 186{
 187        struct gfs2_sb_host *sb = &sdp->sd_sb;
 188        struct super_block *s = sdp->sd_vfs;
 189        const struct gfs2_sb *str = buf;
 190
 191        sb->sb_magic = be32_to_cpu(str->sb_header.mh_magic);
 192        sb->sb_type = be32_to_cpu(str->sb_header.mh_type);
 193        sb->sb_format = be32_to_cpu(str->sb_header.mh_format);
 194        sb->sb_fs_format = be32_to_cpu(str->sb_fs_format);
 195        sb->sb_multihost_format = be32_to_cpu(str->sb_multihost_format);
 196        sb->sb_bsize = be32_to_cpu(str->sb_bsize);
 197        sb->sb_bsize_shift = be32_to_cpu(str->sb_bsize_shift);
 198        sb->sb_master_dir.no_addr = be64_to_cpu(str->sb_master_dir.no_addr);
 199        sb->sb_master_dir.no_formal_ino = be64_to_cpu(str->sb_master_dir.no_formal_ino);
 200        sb->sb_root_dir.no_addr = be64_to_cpu(str->sb_root_dir.no_addr);
 201        sb->sb_root_dir.no_formal_ino = be64_to_cpu(str->sb_root_dir.no_formal_ino);
 202
 203        memcpy(sb->sb_lockproto, str->sb_lockproto, GFS2_LOCKNAME_LEN);
 204        memcpy(sb->sb_locktable, str->sb_locktable, GFS2_LOCKNAME_LEN);
 205        memcpy(s->s_uuid, str->sb_uuid, 16);
 206}
 207
 208/**
 209 * gfs2_read_super - Read the gfs2 super block from disk
 210 * @sdp: The GFS2 super block
 211 * @sector: The location of the super block
 212 * @error: The error code to return
 213 *
 214 * This uses the bio functions to read the super block from disk
 215 * because we want to be 100% sure that we never read cached data.
 216 * A super block is read twice only during each GFS2 mount and is
 217 * never written to by the filesystem. The first time its read no
 218 * locks are held, and the only details which are looked at are those
 219 * relating to the locking protocol. Once locking is up and working,
 220 * the sb is read again under the lock to establish the location of
 221 * the master directory (contains pointers to journals etc) and the
 222 * root directory.
 223 *
 224 * Returns: 0 on success or error
 225 */
 226
 227static int gfs2_read_super(struct gfs2_sbd *sdp, sector_t sector, int silent)
 228{
 229        struct super_block *sb = sdp->sd_vfs;
 230        struct gfs2_sb *p;
 231        struct page *page;
 232        struct bio *bio;
 233
 234        page = alloc_page(GFP_NOFS);
 235        if (unlikely(!page))
 236                return -ENOMEM;
 237
 238        ClearPageUptodate(page);
 239        ClearPageDirty(page);
 240        lock_page(page);
 241
 242        bio = bio_alloc(GFP_NOFS, 1);
 243        bio->bi_iter.bi_sector = sector * (sb->s_blocksize >> 9);
 244        bio->bi_bdev = sb->s_bdev;
 245        bio_add_page(bio, page, PAGE_SIZE, 0);
 246
 247        bio->bi_end_io = end_bio_io_page;
 248        bio->bi_private = page;
 249        submit_bio(READ_SYNC | REQ_META, bio);
 250        wait_on_page_locked(page);
 251        bio_put(bio);
 252        if (!PageUptodate(page)) {
 253                __free_page(page);
 254                return -EIO;
 255        }
 256        p = kmap(page);
 257        gfs2_sb_in(sdp, p);
 258        kunmap(page);
 259        __free_page(page);
 260        return gfs2_check_sb(sdp, silent);
 261}
 262
 263/**
 264 * gfs2_read_sb - Read super block
 265 * @sdp: The GFS2 superblock
 266 * @silent: Don't print message if mount fails
 267 *
 268 */
 269
 270static int gfs2_read_sb(struct gfs2_sbd *sdp, int silent)
 271{
 272        u32 hash_blocks, ind_blocks, leaf_blocks;
 273        u32 tmp_blocks;
 274        unsigned int x;
 275        int error;
 276
 277        error = gfs2_read_super(sdp, GFS2_SB_ADDR >> sdp->sd_fsb2bb_shift, silent);
 278        if (error) {
 279                if (!silent)
 280                        fs_err(sdp, "can't read superblock\n");
 281                return error;
 282        }
 283
 284        sdp->sd_fsb2bb_shift = sdp->sd_sb.sb_bsize_shift -
 285                               GFS2_BASIC_BLOCK_SHIFT;
 286        sdp->sd_fsb2bb = 1 << sdp->sd_fsb2bb_shift;
 287        sdp->sd_diptrs = (sdp->sd_sb.sb_bsize -
 288                          sizeof(struct gfs2_dinode)) / sizeof(u64);
 289        sdp->sd_inptrs = (sdp->sd_sb.sb_bsize -
 290                          sizeof(struct gfs2_meta_header)) / sizeof(u64);
 291        sdp->sd_jbsize = sdp->sd_sb.sb_bsize - sizeof(struct gfs2_meta_header);
 292        sdp->sd_hash_bsize = sdp->sd_sb.sb_bsize / 2;
 293        sdp->sd_hash_bsize_shift = sdp->sd_sb.sb_bsize_shift - 1;
 294        sdp->sd_hash_ptrs = sdp->sd_hash_bsize / sizeof(u64);
 295        sdp->sd_qc_per_block = (sdp->sd_sb.sb_bsize -
 296                                sizeof(struct gfs2_meta_header)) /
 297                                sizeof(struct gfs2_quota_change);
 298        sdp->sd_blocks_per_bitmap = (sdp->sd_sb.sb_bsize -
 299                                     sizeof(struct gfs2_meta_header))
 300                * GFS2_NBBY; /* not the rgrp bitmap, subsequent bitmaps only */
 301
 302        /* Compute maximum reservation required to add a entry to a directory */
 303
 304        hash_blocks = DIV_ROUND_UP(sizeof(u64) * (1 << GFS2_DIR_MAX_DEPTH),
 305                             sdp->sd_jbsize);
 306
 307        ind_blocks = 0;
 308        for (tmp_blocks = hash_blocks; tmp_blocks > sdp->sd_diptrs;) {
 309                tmp_blocks = DIV_ROUND_UP(tmp_blocks, sdp->sd_inptrs);
 310                ind_blocks += tmp_blocks;
 311        }
 312
 313        leaf_blocks = 2 + GFS2_DIR_MAX_DEPTH;
 314
 315        sdp->sd_max_dirres = hash_blocks + ind_blocks + leaf_blocks;
 316
 317        sdp->sd_heightsize[0] = sdp->sd_sb.sb_bsize -
 318                                sizeof(struct gfs2_dinode);
 319        sdp->sd_heightsize[1] = sdp->sd_sb.sb_bsize * sdp->sd_diptrs;
 320        for (x = 2;; x++) {
 321                u64 space, d;
 322                u32 m;
 323
 324                space = sdp->sd_heightsize[x - 1] * sdp->sd_inptrs;
 325                d = space;
 326                m = do_div(d, sdp->sd_inptrs);
 327
 328                if (d != sdp->sd_heightsize[x - 1] || m)
 329                        break;
 330                sdp->sd_heightsize[x] = space;
 331        }
 332        sdp->sd_max_height = x;
 333        sdp->sd_heightsize[x] = ~0;
 334        gfs2_assert(sdp, sdp->sd_max_height <= GFS2_MAX_META_HEIGHT);
 335
 336        sdp->sd_jheightsize[0] = sdp->sd_sb.sb_bsize -
 337                                 sizeof(struct gfs2_dinode);
 338        sdp->sd_jheightsize[1] = sdp->sd_jbsize * sdp->sd_diptrs;
 339        for (x = 2;; x++) {
 340                u64 space, d;
 341                u32 m;
 342
 343                space = sdp->sd_jheightsize[x - 1] * sdp->sd_inptrs;
 344                d = space;
 345                m = do_div(d, sdp->sd_inptrs);
 346
 347                if (d != sdp->sd_jheightsize[x - 1] || m)
 348                        break;
 349                sdp->sd_jheightsize[x] = space;
 350        }
 351        sdp->sd_max_jheight = x;
 352        sdp->sd_jheightsize[x] = ~0;
 353        gfs2_assert(sdp, sdp->sd_max_jheight <= GFS2_MAX_META_HEIGHT);
 354
 355        sdp->sd_max_dents_per_leaf = (sdp->sd_sb.sb_bsize -
 356                                      sizeof(struct gfs2_leaf)) /
 357                                     GFS2_MIN_DIRENT_SIZE;
 358        return 0;
 359}
 360
 361static int init_names(struct gfs2_sbd *sdp, int silent)
 362{
 363        char *proto, *table;
 364        int error = 0;
 365
 366        proto = sdp->sd_args.ar_lockproto;
 367        table = sdp->sd_args.ar_locktable;
 368
 369        /*  Try to autodetect  */
 370
 371        if (!proto[0] || !table[0]) {
 372                error = gfs2_read_super(sdp, GFS2_SB_ADDR >> sdp->sd_fsb2bb_shift, silent);
 373                if (error)
 374                        return error;
 375
 376                if (!proto[0])
 377                        proto = sdp->sd_sb.sb_lockproto;
 378                if (!table[0])
 379                        table = sdp->sd_sb.sb_locktable;
 380        }
 381
 382        if (!table[0])
 383                table = sdp->sd_vfs->s_id;
 384
 385        strlcpy(sdp->sd_proto_name, proto, GFS2_FSNAME_LEN);
 386        strlcpy(sdp->sd_table_name, table, GFS2_FSNAME_LEN);
 387
 388        table = sdp->sd_table_name;
 389        while ((table = strchr(table, '/')))
 390                *table = '_';
 391
 392        return error;
 393}
 394
 395static int init_locking(struct gfs2_sbd *sdp, struct gfs2_holder *mount_gh,
 396                        int undo)
 397{
 398        int error = 0;
 399
 400        if (undo)
 401                goto fail_trans;
 402
 403        error = gfs2_glock_nq_num(sdp,
 404                                  GFS2_MOUNT_LOCK, &gfs2_nondisk_glops,
 405                                  LM_ST_EXCLUSIVE, LM_FLAG_NOEXP | GL_NOCACHE,
 406                                  mount_gh);
 407        if (error) {
 408                fs_err(sdp, "can't acquire mount glock: %d\n", error);
 409                goto fail;
 410        }
 411
 412        error = gfs2_glock_nq_num(sdp,
 413                                  GFS2_LIVE_LOCK, &gfs2_nondisk_glops,
 414                                  LM_ST_SHARED,
 415                                  LM_FLAG_NOEXP | GL_EXACT,
 416                                  &sdp->sd_live_gh);
 417        if (error) {
 418                fs_err(sdp, "can't acquire live glock: %d\n", error);
 419                goto fail_mount;
 420        }
 421
 422        error = gfs2_glock_get(sdp, GFS2_RENAME_LOCK, &gfs2_nondisk_glops,
 423                               CREATE, &sdp->sd_rename_gl);
 424        if (error) {
 425                fs_err(sdp, "can't create rename glock: %d\n", error);
 426                goto fail_live;
 427        }
 428
 429        error = gfs2_glock_get(sdp, GFS2_FREEZE_LOCK, &gfs2_freeze_glops,
 430                               CREATE, &sdp->sd_freeze_gl);
 431        if (error) {
 432                fs_err(sdp, "can't create transaction glock: %d\n", error);
 433                goto fail_rename;
 434        }
 435
 436        return 0;
 437
 438fail_trans:
 439        gfs2_glock_put(sdp->sd_freeze_gl);
 440fail_rename:
 441        gfs2_glock_put(sdp->sd_rename_gl);
 442fail_live:
 443        gfs2_glock_dq_uninit(&sdp->sd_live_gh);
 444fail_mount:
 445        gfs2_glock_dq_uninit(mount_gh);
 446fail:
 447        return error;
 448}
 449
 450static int gfs2_lookup_root(struct super_block *sb, struct dentry **dptr,
 451                            u64 no_addr, const char *name)
 452{
 453        struct gfs2_sbd *sdp = sb->s_fs_info;
 454        struct dentry *dentry;
 455        struct inode *inode;
 456
 457        inode = gfs2_inode_lookup(sb, DT_DIR, no_addr, 0);
 458        if (IS_ERR(inode)) {
 459                fs_err(sdp, "can't read in %s inode: %ld\n", name, PTR_ERR(inode));
 460                return PTR_ERR(inode);
 461        }
 462        dentry = d_make_root(inode);
 463        if (!dentry) {
 464                fs_err(sdp, "can't alloc %s dentry\n", name);
 465                return -ENOMEM;
 466        }
 467        *dptr = dentry;
 468        return 0;
 469}
 470
 471static int init_sb(struct gfs2_sbd *sdp, int silent)
 472{
 473        struct super_block *sb = sdp->sd_vfs;
 474        struct gfs2_holder sb_gh;
 475        u64 no_addr;
 476        int ret;
 477
 478        ret = gfs2_glock_nq_num(sdp, GFS2_SB_LOCK, &gfs2_meta_glops,
 479                                LM_ST_SHARED, 0, &sb_gh);
 480        if (ret) {
 481                fs_err(sdp, "can't acquire superblock glock: %d\n", ret);
 482                return ret;
 483        }
 484
 485        ret = gfs2_read_sb(sdp, silent);
 486        if (ret) {
 487                fs_err(sdp, "can't read superblock: %d\n", ret);
 488                goto out;
 489        }
 490
 491        /* Set up the buffer cache and SB for real */
 492        if (sdp->sd_sb.sb_bsize < bdev_logical_block_size(sb->s_bdev)) {
 493                ret = -EINVAL;
 494                fs_err(sdp, "FS block size (%u) is too small for device "
 495                       "block size (%u)\n",
 496                       sdp->sd_sb.sb_bsize, bdev_logical_block_size(sb->s_bdev));
 497                goto out;
 498        }
 499        if (sdp->sd_sb.sb_bsize > PAGE_SIZE) {
 500                ret = -EINVAL;
 501                fs_err(sdp, "FS block size (%u) is too big for machine "
 502                       "page size (%u)\n",
 503                       sdp->sd_sb.sb_bsize, (unsigned int)PAGE_SIZE);
 504                goto out;
 505        }
 506        sb_set_blocksize(sb, sdp->sd_sb.sb_bsize);
 507
 508        /* Get the root inode */
 509        no_addr = sdp->sd_sb.sb_root_dir.no_addr;
 510        ret = gfs2_lookup_root(sb, &sdp->sd_root_dir, no_addr, "root");
 511        if (ret)
 512                goto out;
 513
 514        /* Get the master inode */
 515        no_addr = sdp->sd_sb.sb_master_dir.no_addr;
 516        ret = gfs2_lookup_root(sb, &sdp->sd_master_dir, no_addr, "master");
 517        if (ret) {
 518                dput(sdp->sd_root_dir);
 519                goto out;
 520        }
 521        sb->s_root = dget(sdp->sd_args.ar_meta ? sdp->sd_master_dir : sdp->sd_root_dir);
 522out:
 523        gfs2_glock_dq_uninit(&sb_gh);
 524        return ret;
 525}
 526
 527static void gfs2_others_may_mount(struct gfs2_sbd *sdp)
 528{
 529        char *message = "FIRSTMOUNT=Done";
 530        char *envp[] = { message, NULL };
 531
 532        fs_info(sdp, "first mount done, others may mount\n");
 533
 534        if (sdp->sd_lockstruct.ls_ops->lm_first_done)
 535                sdp->sd_lockstruct.ls_ops->lm_first_done(sdp);
 536
 537        kobject_uevent_env(&sdp->sd_kobj, KOBJ_CHANGE, envp);
 538}
 539
 540/**
 541 * gfs2_jindex_hold - Grab a lock on the jindex
 542 * @sdp: The GFS2 superblock
 543 * @ji_gh: the holder for the jindex glock
 544 *
 545 * Returns: errno
 546 */
 547
 548static int gfs2_jindex_hold(struct gfs2_sbd *sdp, struct gfs2_holder *ji_gh)
 549{
 550        struct gfs2_inode *dip = GFS2_I(sdp->sd_jindex);
 551        struct qstr name;
 552        char buf[20];
 553        struct gfs2_jdesc *jd;
 554        int error;
 555
 556        name.name = buf;
 557
 558        mutex_lock(&sdp->sd_jindex_mutex);
 559
 560        for (;;) {
 561                error = gfs2_glock_nq_init(dip->i_gl, LM_ST_SHARED, 0, ji_gh);
 562                if (error)
 563                        break;
 564
 565                name.len = sprintf(buf, "journal%u", sdp->sd_journals);
 566                name.hash = gfs2_disk_hash(name.name, name.len);
 567
 568                error = gfs2_dir_check(sdp->sd_jindex, &name, NULL);
 569                if (error == -ENOENT) {
 570                        error = 0;
 571                        break;
 572                }
 573
 574                gfs2_glock_dq_uninit(ji_gh);
 575
 576                if (error)
 577                        break;
 578
 579                error = -ENOMEM;
 580                jd = kzalloc(sizeof(struct gfs2_jdesc), GFP_KERNEL);
 581                if (!jd)
 582                        break;
 583
 584                INIT_LIST_HEAD(&jd->extent_list);
 585                INIT_LIST_HEAD(&jd->jd_revoke_list);
 586
 587                INIT_WORK(&jd->jd_work, gfs2_recover_func);
 588                jd->jd_inode = gfs2_lookupi(sdp->sd_jindex, &name, 1);
 589                if (!jd->jd_inode || IS_ERR(jd->jd_inode)) {
 590                        if (!jd->jd_inode)
 591                                error = -ENOENT;
 592                        else
 593                                error = PTR_ERR(jd->jd_inode);
 594                        kfree(jd);
 595                        break;
 596                }
 597
 598                spin_lock(&sdp->sd_jindex_spin);
 599                jd->jd_jid = sdp->sd_journals++;
 600                list_add_tail(&jd->jd_list, &sdp->sd_jindex_list);
 601                spin_unlock(&sdp->sd_jindex_spin);
 602        }
 603
 604        mutex_unlock(&sdp->sd_jindex_mutex);
 605
 606        return error;
 607}
 608
 609/**
 610 * check_journal_clean - Make sure a journal is clean for a spectator mount
 611 * @sdp: The GFS2 superblock
 612 * @jd: The journal descriptor
 613 *
 614 * Returns: 0 if the journal is clean or locked, else an error
 615 */
 616static int check_journal_clean(struct gfs2_sbd *sdp, struct gfs2_jdesc *jd)
 617{
 618        int error;
 619        struct gfs2_holder j_gh;
 620        struct gfs2_log_header_host head;
 621        struct gfs2_inode *ip;
 622
 623        ip = GFS2_I(jd->jd_inode);
 624        error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_NOEXP |
 625                                   GL_EXACT | GL_NOCACHE, &j_gh);
 626        if (error) {
 627                fs_err(sdp, "Error locking journal for spectator mount.\n");
 628                return -EPERM;
 629        }
 630        error = gfs2_jdesc_check(jd);
 631        if (error) {
 632                fs_err(sdp, "Error checking journal for spectator mount.\n");
 633                goto out_unlock;
 634        }
 635        error = gfs2_find_jhead(jd, &head);
 636        if (error) {
 637                fs_err(sdp, "Error parsing journal for spectator mount.\n");
 638                goto out_unlock;
 639        }
 640        if (!(head.lh_flags & GFS2_LOG_HEAD_UNMOUNT)) {
 641                error = -EPERM;
 642                fs_err(sdp, "jid=%u: Journal is dirty, so the first mounter "
 643                       "must not be a spectator.\n", jd->jd_jid);
 644        }
 645
 646out_unlock:
 647        gfs2_glock_dq_uninit(&j_gh);
 648        return error;
 649}
 650
 651static int init_journal(struct gfs2_sbd *sdp, int undo)
 652{
 653        struct inode *master = d_inode(sdp->sd_master_dir);
 654        struct gfs2_holder ji_gh;
 655        struct gfs2_inode *ip;
 656        int jindex = 1;
 657        int error = 0;
 658
 659        if (undo) {
 660                jindex = 0;
 661                goto fail_jinode_gh;
 662        }
 663
 664        sdp->sd_jindex = gfs2_lookup_simple(master, "jindex");
 665        if (IS_ERR(sdp->sd_jindex)) {
 666                fs_err(sdp, "can't lookup journal index: %d\n", error);
 667                return PTR_ERR(sdp->sd_jindex);
 668        }
 669
 670        /* Load in the journal index special file */
 671
 672        error = gfs2_jindex_hold(sdp, &ji_gh);
 673        if (error) {
 674                fs_err(sdp, "can't read journal index: %d\n", error);
 675                goto fail;
 676        }
 677
 678        error = -EUSERS;
 679        if (!gfs2_jindex_size(sdp)) {
 680                fs_err(sdp, "no journals!\n");
 681                goto fail_jindex;
 682        }
 683
 684        if (sdp->sd_args.ar_spectator) {
 685                sdp->sd_jdesc = gfs2_jdesc_find(sdp, 0);
 686                atomic_set(&sdp->sd_log_blks_free, sdp->sd_jdesc->jd_blocks);
 687                atomic_set(&sdp->sd_log_thresh1, 2*sdp->sd_jdesc->jd_blocks/5);
 688                atomic_set(&sdp->sd_log_thresh2, 4*sdp->sd_jdesc->jd_blocks/5);
 689        } else {
 690                if (sdp->sd_lockstruct.ls_jid >= gfs2_jindex_size(sdp)) {
 691                        fs_err(sdp, "can't mount journal #%u\n",
 692                               sdp->sd_lockstruct.ls_jid);
 693                        fs_err(sdp, "there are only %u journals (0 - %u)\n",
 694                               gfs2_jindex_size(sdp),
 695                               gfs2_jindex_size(sdp) - 1);
 696                        goto fail_jindex;
 697                }
 698                sdp->sd_jdesc = gfs2_jdesc_find(sdp, sdp->sd_lockstruct.ls_jid);
 699
 700                error = gfs2_glock_nq_num(sdp, sdp->sd_lockstruct.ls_jid,
 701                                          &gfs2_journal_glops,
 702                                          LM_ST_EXCLUSIVE, LM_FLAG_NOEXP,
 703                                          &sdp->sd_journal_gh);
 704                if (error) {
 705                        fs_err(sdp, "can't acquire journal glock: %d\n", error);
 706                        goto fail_jindex;
 707                }
 708
 709                ip = GFS2_I(sdp->sd_jdesc->jd_inode);
 710                error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED,
 711                                           LM_FLAG_NOEXP | GL_EXACT | GL_NOCACHE,
 712                                           &sdp->sd_jinode_gh);
 713                if (error) {
 714                        fs_err(sdp, "can't acquire journal inode glock: %d\n",
 715                               error);
 716                        goto fail_journal_gh;
 717                }
 718
 719                error = gfs2_jdesc_check(sdp->sd_jdesc);
 720                if (error) {
 721                        fs_err(sdp, "my journal (%u) is bad: %d\n",
 722                               sdp->sd_jdesc->jd_jid, error);
 723                        goto fail_jinode_gh;
 724                }
 725                atomic_set(&sdp->sd_log_blks_free, sdp->sd_jdesc->jd_blocks);
 726                atomic_set(&sdp->sd_log_thresh1, 2*sdp->sd_jdesc->jd_blocks/5);
 727                atomic_set(&sdp->sd_log_thresh2, 4*sdp->sd_jdesc->jd_blocks/5);
 728
 729                /* Map the extents for this journal's blocks */
 730                gfs2_map_journal_extents(sdp, sdp->sd_jdesc);
 731        }
 732        trace_gfs2_log_blocks(sdp, atomic_read(&sdp->sd_log_blks_free));
 733
 734        if (sdp->sd_lockstruct.ls_first) {
 735                unsigned int x;
 736                for (x = 0; x < sdp->sd_journals; x++) {
 737                        struct gfs2_jdesc *jd = gfs2_jdesc_find(sdp, x);
 738
 739                        if (sdp->sd_args.ar_spectator) {
 740                                error = check_journal_clean(sdp, jd);
 741                                if (error)
 742                                        goto fail_jinode_gh;
 743                                continue;
 744                        }
 745                        error = gfs2_recover_journal(jd, true);
 746                        if (error) {
 747                                fs_err(sdp, "error recovering journal %u: %d\n",
 748                                       x, error);
 749                                goto fail_jinode_gh;
 750                        }
 751                }
 752
 753                gfs2_others_may_mount(sdp);
 754        } else if (!sdp->sd_args.ar_spectator) {
 755                error = gfs2_recover_journal(sdp->sd_jdesc, true);
 756                if (error) {
 757                        fs_err(sdp, "error recovering my journal: %d\n", error);
 758                        goto fail_jinode_gh;
 759                }
 760        }
 761
 762        sdp->sd_log_idle = 1;
 763        set_bit(SDF_JOURNAL_CHECKED, &sdp->sd_flags);
 764        gfs2_glock_dq_uninit(&ji_gh);
 765        jindex = 0;
 766        INIT_WORK(&sdp->sd_freeze_work, gfs2_freeze_func);
 767        return 0;
 768
 769fail_jinode_gh:
 770        if (!sdp->sd_args.ar_spectator)
 771                gfs2_glock_dq_uninit(&sdp->sd_jinode_gh);
 772fail_journal_gh:
 773        if (!sdp->sd_args.ar_spectator)
 774                gfs2_glock_dq_uninit(&sdp->sd_journal_gh);
 775fail_jindex:
 776        gfs2_jindex_free(sdp);
 777        if (jindex)
 778                gfs2_glock_dq_uninit(&ji_gh);
 779fail:
 780        iput(sdp->sd_jindex);
 781        return error;
 782}
 783
 784static struct lock_class_key gfs2_quota_imutex_key;
 785
 786static int init_inodes(struct gfs2_sbd *sdp, int undo)
 787{
 788        int error = 0;
 789        struct inode *master = d_inode(sdp->sd_master_dir);
 790
 791        if (undo)
 792                goto fail_qinode;
 793
 794        error = init_journal(sdp, undo);
 795        complete_all(&sdp->sd_journal_ready);
 796        if (error)
 797                goto fail;
 798
 799        /* Read in the master statfs inode */
 800        sdp->sd_statfs_inode = gfs2_lookup_simple(master, "statfs");
 801        if (IS_ERR(sdp->sd_statfs_inode)) {
 802                error = PTR_ERR(sdp->sd_statfs_inode);
 803                fs_err(sdp, "can't read in statfs inode: %d\n", error);
 804                goto fail_journal;
 805        }
 806
 807        /* Read in the resource index inode */
 808        sdp->sd_rindex = gfs2_lookup_simple(master, "rindex");
 809        if (IS_ERR(sdp->sd_rindex)) {
 810                error = PTR_ERR(sdp->sd_rindex);
 811                fs_err(sdp, "can't get resource index inode: %d\n", error);
 812                goto fail_statfs;
 813        }
 814        sdp->sd_rindex_uptodate = 0;
 815
 816        /* Read in the quota inode */
 817        sdp->sd_quota_inode = gfs2_lookup_simple(master, "quota");
 818        if (IS_ERR(sdp->sd_quota_inode)) {
 819                error = PTR_ERR(sdp->sd_quota_inode);
 820                fs_err(sdp, "can't get quota file inode: %d\n", error);
 821                goto fail_rindex;
 822        }
 823        /*
 824         * i_mutex on quota files is special. Since this inode is hidden system
 825         * file, we are safe to define locking ourselves.
 826         */
 827        lockdep_set_class(&sdp->sd_quota_inode->i_rwsem,
 828                          &gfs2_quota_imutex_key);
 829
 830        error = gfs2_rindex_update(sdp);
 831        if (error)
 832                goto fail_qinode;
 833
 834        return 0;
 835
 836fail_qinode:
 837        iput(sdp->sd_quota_inode);
 838fail_rindex:
 839        gfs2_clear_rgrpd(sdp);
 840        iput(sdp->sd_rindex);
 841fail_statfs:
 842        iput(sdp->sd_statfs_inode);
 843fail_journal:
 844        init_journal(sdp, UNDO);
 845fail:
 846        return error;
 847}
 848
 849static int init_per_node(struct gfs2_sbd *sdp, int undo)
 850{
 851        struct inode *pn = NULL;
 852        char buf[30];
 853        int error = 0;
 854        struct gfs2_inode *ip;
 855        struct inode *master = d_inode(sdp->sd_master_dir);
 856
 857        if (sdp->sd_args.ar_spectator)
 858                return 0;
 859
 860        if (undo)
 861                goto fail_qc_gh;
 862
 863        pn = gfs2_lookup_simple(master, "per_node");
 864        if (IS_ERR(pn)) {
 865                error = PTR_ERR(pn);
 866                fs_err(sdp, "can't find per_node directory: %d\n", error);
 867                return error;
 868        }
 869
 870        sprintf(buf, "statfs_change%u", sdp->sd_jdesc->jd_jid);
 871        sdp->sd_sc_inode = gfs2_lookup_simple(pn, buf);
 872        if (IS_ERR(sdp->sd_sc_inode)) {
 873                error = PTR_ERR(sdp->sd_sc_inode);
 874                fs_err(sdp, "can't find local \"sc\" file: %d\n", error);
 875                goto fail;
 876        }
 877
 878        sprintf(buf, "quota_change%u", sdp->sd_jdesc->jd_jid);
 879        sdp->sd_qc_inode = gfs2_lookup_simple(pn, buf);
 880        if (IS_ERR(sdp->sd_qc_inode)) {
 881                error = PTR_ERR(sdp->sd_qc_inode);
 882                fs_err(sdp, "can't find local \"qc\" file: %d\n", error);
 883                goto fail_ut_i;
 884        }
 885
 886        iput(pn);
 887        pn = NULL;
 888
 889        ip = GFS2_I(sdp->sd_sc_inode);
 890        error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0,
 891                                   &sdp->sd_sc_gh);
 892        if (error) {
 893                fs_err(sdp, "can't lock local \"sc\" file: %d\n", error);
 894                goto fail_qc_i;
 895        }
 896
 897        ip = GFS2_I(sdp->sd_qc_inode);
 898        error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0,
 899                                   &sdp->sd_qc_gh);
 900        if (error) {
 901                fs_err(sdp, "can't lock local \"qc\" file: %d\n", error);
 902                goto fail_ut_gh;
 903        }
 904
 905        return 0;
 906
 907fail_qc_gh:
 908        gfs2_glock_dq_uninit(&sdp->sd_qc_gh);
 909fail_ut_gh:
 910        gfs2_glock_dq_uninit(&sdp->sd_sc_gh);
 911fail_qc_i:
 912        iput(sdp->sd_qc_inode);
 913fail_ut_i:
 914        iput(sdp->sd_sc_inode);
 915fail:
 916        iput(pn);
 917        return error;
 918}
 919
 920static const match_table_t nolock_tokens = {
 921        { Opt_jid, "jid=%d\n", },
 922        { Opt_err, NULL },
 923};
 924
 925static const struct lm_lockops nolock_ops = {
 926        .lm_proto_name = "lock_nolock",
 927        .lm_put_lock = gfs2_glock_free,
 928        .lm_tokens = &nolock_tokens,
 929};
 930
 931/**
 932 * gfs2_lm_mount - mount a locking protocol
 933 * @sdp: the filesystem
 934 * @args: mount arguments
 935 * @silent: if 1, don't complain if the FS isn't a GFS2 fs
 936 *
 937 * Returns: errno
 938 */
 939
 940static int gfs2_lm_mount(struct gfs2_sbd *sdp, int silent)
 941{
 942        const struct lm_lockops *lm;
 943        struct lm_lockstruct *ls = &sdp->sd_lockstruct;
 944        struct gfs2_args *args = &sdp->sd_args;
 945        const char *proto = sdp->sd_proto_name;
 946        const char *table = sdp->sd_table_name;
 947        char *o, *options;
 948        int ret;
 949
 950        if (!strcmp("lock_nolock", proto)) {
 951                lm = &nolock_ops;
 952                sdp->sd_args.ar_localflocks = 1;
 953#ifdef CONFIG_GFS2_FS_LOCKING_DLM
 954        } else if (!strcmp("lock_dlm", proto)) {
 955                lm = &gfs2_dlm_ops;
 956#endif
 957        } else {
 958                pr_info("can't find protocol %s\n", proto);
 959                return -ENOENT;
 960        }
 961
 962        fs_info(sdp, "Trying to join cluster \"%s\", \"%s\"\n", proto, table);
 963
 964        ls->ls_ops = lm;
 965        ls->ls_first = 1;
 966
 967        for (options = args->ar_hostdata; (o = strsep(&options, ":")); ) {
 968                substring_t tmp[MAX_OPT_ARGS];
 969                int token, option;
 970
 971                if (!o || !*o)
 972                        continue;
 973
 974                token = match_token(o, *lm->lm_tokens, tmp);
 975                switch (token) {
 976                case Opt_jid:
 977                        ret = match_int(&tmp[0], &option);
 978                        if (ret || option < 0) 
 979                                goto hostdata_error;
 980                        if (test_and_clear_bit(SDF_NOJOURNALID, &sdp->sd_flags))
 981                                ls->ls_jid = option;
 982                        break;
 983                case Opt_id:
 984                case Opt_nodir:
 985                        /* Obsolete, but left for backward compat purposes */
 986                        break;
 987                case Opt_first:
 988                        ret = match_int(&tmp[0], &option);
 989                        if (ret || (option != 0 && option != 1))
 990                                goto hostdata_error;
 991                        ls->ls_first = option;
 992                        break;
 993                case Opt_err:
 994                default:
 995hostdata_error:
 996                        fs_info(sdp, "unknown hostdata (%s)\n", o);
 997                        return -EINVAL;
 998                }
 999        }
1000
1001        if (lm->lm_mount == NULL) {
1002                fs_info(sdp, "Now mounting FS...\n");
1003                complete_all(&sdp->sd_locking_init);
1004                return 0;
1005        }
1006        ret = lm->lm_mount(sdp, table);
1007        if (ret == 0)
1008                fs_info(sdp, "Joined cluster. Now mounting FS...\n");
1009        complete_all(&sdp->sd_locking_init);
1010        return ret;
1011}
1012
1013void gfs2_lm_unmount(struct gfs2_sbd *sdp)
1014{
1015        const struct lm_lockops *lm = sdp->sd_lockstruct.ls_ops;
1016        if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)) &&
1017            lm->lm_unmount)
1018                lm->lm_unmount(sdp);
1019}
1020
1021static int wait_on_journal(struct gfs2_sbd *sdp)
1022{
1023        if (sdp->sd_lockstruct.ls_ops->lm_mount == NULL)
1024                return 0;
1025
1026        return wait_on_bit(&sdp->sd_flags, SDF_NOJOURNALID, TASK_INTERRUPTIBLE)
1027                ? -EINTR : 0;
1028}
1029
1030void gfs2_online_uevent(struct gfs2_sbd *sdp)
1031{
1032        struct super_block *sb = sdp->sd_vfs;
1033        char ro[20];
1034        char spectator[20];
1035        char *envp[] = { ro, spectator, NULL };
1036        sprintf(ro, "RDONLY=%d", (sb->s_flags & MS_RDONLY) ? 1 : 0);
1037        sprintf(spectator, "SPECTATOR=%d", sdp->sd_args.ar_spectator ? 1 : 0);
1038        kobject_uevent_env(&sdp->sd_kobj, KOBJ_ONLINE, envp);
1039}
1040
1041/**
1042 * fill_super - Read in superblock
1043 * @sb: The VFS superblock
1044 * @data: Mount options
1045 * @silent: Don't complain if it's not a GFS2 filesystem
1046 *
1047 * Returns: errno
1048 */
1049
1050static int fill_super(struct super_block *sb, struct gfs2_args *args, int silent)
1051{
1052        struct gfs2_sbd *sdp;
1053        struct gfs2_holder mount_gh;
1054        int error;
1055
1056        sdp = init_sbd(sb);
1057        if (!sdp) {
1058                pr_warn("can't alloc struct gfs2_sbd\n");
1059                return -ENOMEM;
1060        }
1061        sdp->sd_args = *args;
1062
1063        if (sdp->sd_args.ar_spectator) {
1064                sb->s_flags |= MS_RDONLY;
1065                set_bit(SDF_RORECOVERY, &sdp->sd_flags);
1066        }
1067        if (sdp->sd_args.ar_posix_acl)
1068                sb->s_flags |= MS_POSIXACL;
1069        if (sdp->sd_args.ar_nobarrier)
1070                set_bit(SDF_NOBARRIERS, &sdp->sd_flags);
1071
1072        sb->s_flags |= MS_NOSEC;
1073        sb->s_magic = GFS2_MAGIC;
1074        sb->s_op = &gfs2_super_ops;
1075        sb->s_d_op = &gfs2_dops;
1076        sb->s_export_op = &gfs2_export_ops;
1077        sb->s_xattr = gfs2_xattr_handlers;
1078        sb->s_qcop = &gfs2_quotactl_ops;
1079        sb->s_quota_types = QTYPE_MASK_USR | QTYPE_MASK_GRP;
1080        sb_dqopt(sb)->flags |= DQUOT_QUOTA_SYS_FILE;
1081        sb->s_time_gran = 1;
1082        sb->s_maxbytes = MAX_LFS_FILESIZE;
1083
1084        /* Set up the buffer cache and fill in some fake block size values
1085           to allow us to read-in the on-disk superblock. */
1086        sdp->sd_sb.sb_bsize = sb_min_blocksize(sb, GFS2_BASIC_BLOCK);
1087        sdp->sd_sb.sb_bsize_shift = sb->s_blocksize_bits;
1088        sdp->sd_fsb2bb_shift = sdp->sd_sb.sb_bsize_shift -
1089                               GFS2_BASIC_BLOCK_SHIFT;
1090        sdp->sd_fsb2bb = 1 << sdp->sd_fsb2bb_shift;
1091
1092        sdp->sd_tune.gt_logd_secs = sdp->sd_args.ar_commit;
1093        sdp->sd_tune.gt_quota_quantum = sdp->sd_args.ar_quota_quantum;
1094        if (sdp->sd_args.ar_statfs_quantum) {
1095                sdp->sd_tune.gt_statfs_slow = 0;
1096                sdp->sd_tune.gt_statfs_quantum = sdp->sd_args.ar_statfs_quantum;
1097        } else {
1098                sdp->sd_tune.gt_statfs_slow = 1;
1099                sdp->sd_tune.gt_statfs_quantum = 30;
1100        }
1101
1102        error = init_names(sdp, silent);
1103        if (error) {
1104                /* In this case, we haven't initialized sysfs, so we have to
1105                   manually free the sdp. */
1106                free_percpu(sdp->sd_lkstats);
1107                kfree(sdp);
1108                sb->s_fs_info = NULL;
1109                return error;
1110        }
1111
1112        snprintf(sdp->sd_fsname, GFS2_FSNAME_LEN, "%s", sdp->sd_table_name);
1113
1114        error = gfs2_sys_fs_add(sdp);
1115        /*
1116         * If we hit an error here, gfs2_sys_fs_add will have called function
1117         * kobject_put which causes the sysfs usage count to go to zero, which
1118         * causes sysfs to call function gfs2_sbd_release, which frees sdp.
1119         * Subsequent error paths here will call gfs2_sys_fs_del, which also
1120         * kobject_put to free sdp.
1121         */
1122        if (error)
1123                return error;
1124
1125        gfs2_create_debugfs_file(sdp);
1126
1127        error = gfs2_lm_mount(sdp, silent);
1128        if (error)
1129                goto fail_debug;
1130
1131        error = init_locking(sdp, &mount_gh, DO);
1132        if (error)
1133                goto fail_lm;
1134
1135        error = init_sb(sdp, silent);
1136        if (error)
1137                goto fail_locking;
1138
1139        error = wait_on_journal(sdp);
1140        if (error)
1141                goto fail_sb;
1142
1143        /*
1144         * If user space has failed to join the cluster or some similar
1145         * failure has occurred, then the journal id will contain a
1146         * negative (error) number. This will then be returned to the
1147         * caller (of the mount syscall). We do this even for spectator
1148         * mounts (which just write a jid of 0 to indicate "ok" even though
1149         * the jid is unused in the spectator case)
1150         */
1151        if (sdp->sd_lockstruct.ls_jid < 0) {
1152                error = sdp->sd_lockstruct.ls_jid;
1153                sdp->sd_lockstruct.ls_jid = 0;
1154                goto fail_sb;
1155        }
1156
1157        if (sdp->sd_args.ar_spectator)
1158                snprintf(sdp->sd_fsname, GFS2_FSNAME_LEN, "%s.s",
1159                         sdp->sd_table_name);
1160        else
1161                snprintf(sdp->sd_fsname, GFS2_FSNAME_LEN, "%s.%u",
1162                         sdp->sd_table_name, sdp->sd_lockstruct.ls_jid);
1163
1164        error = init_inodes(sdp, DO);
1165        if (error)
1166                goto fail_sb;
1167
1168        error = init_per_node(sdp, DO);
1169        if (error)
1170                goto fail_inodes;
1171
1172        error = gfs2_statfs_init(sdp);
1173        if (error) {
1174                fs_err(sdp, "can't initialize statfs subsystem: %d\n", error);
1175                goto fail_per_node;
1176        }
1177
1178        if (!(sb->s_flags & MS_RDONLY)) {
1179                error = gfs2_make_fs_rw(sdp);
1180                if (error) {
1181                        fs_err(sdp, "can't make FS RW: %d\n", error);
1182                        goto fail_per_node;
1183                }
1184        }
1185
1186        gfs2_glock_dq_uninit(&mount_gh);
1187        gfs2_online_uevent(sdp);
1188        return 0;
1189
1190fail_per_node:
1191        init_per_node(sdp, UNDO);
1192fail_inodes:
1193        init_inodes(sdp, UNDO);
1194fail_sb:
1195        if (sdp->sd_root_dir)
1196                dput(sdp->sd_root_dir);
1197        if (sdp->sd_master_dir)
1198                dput(sdp->sd_master_dir);
1199        if (sb->s_root)
1200                dput(sb->s_root);
1201        sb->s_root = NULL;
1202fail_locking:
1203        init_locking(sdp, &mount_gh, UNDO);
1204fail_lm:
1205        complete_all(&sdp->sd_journal_ready);
1206        gfs2_gl_hash_clear(sdp);
1207        gfs2_lm_unmount(sdp);
1208fail_debug:
1209        gfs2_delete_debugfs_file(sdp);
1210        free_percpu(sdp->sd_lkstats);
1211        /* gfs2_sys_fs_del must be the last thing we do, since it causes
1212         * sysfs to call function gfs2_sbd_release, which frees sdp. */
1213        gfs2_sys_fs_del(sdp);
1214        sb->s_fs_info = NULL;
1215        return error;
1216}
1217
1218static int set_gfs2_super(struct super_block *s, void *data)
1219{
1220        s->s_bdev = data;
1221        s->s_dev = s->s_bdev->bd_dev;
1222
1223        /*
1224         * We set the bdi here to the queue backing, file systems can
1225         * overwrite this in ->fill_super()
1226         */
1227        s->s_bdi = &bdev_get_queue(s->s_bdev)->backing_dev_info;
1228        return 0;
1229}
1230
1231static int test_gfs2_super(struct super_block *s, void *ptr)
1232{
1233        struct block_device *bdev = ptr;
1234        return (bdev == s->s_bdev);
1235}
1236
1237/**
1238 * gfs2_mount - Get the GFS2 superblock
1239 * @fs_type: The GFS2 filesystem type
1240 * @flags: Mount flags
1241 * @dev_name: The name of the device
1242 * @data: The mount arguments
1243 *
1244 * Q. Why not use get_sb_bdev() ?
1245 * A. We need to select one of two root directories to mount, independent
1246 *    of whether this is the initial, or subsequent, mount of this sb
1247 *
1248 * Returns: 0 or -ve on error
1249 */
1250
1251static struct dentry *gfs2_mount(struct file_system_type *fs_type, int flags,
1252                       const char *dev_name, void *data)
1253{
1254        struct block_device *bdev;
1255        struct super_block *s;
1256        fmode_t mode = FMODE_READ | FMODE_EXCL;
1257        int error;
1258        struct gfs2_args args;
1259        struct gfs2_sbd *sdp;
1260
1261        if (!(flags & MS_RDONLY))
1262                mode |= FMODE_WRITE;
1263
1264        bdev = blkdev_get_by_path(dev_name, mode, fs_type);
1265        if (IS_ERR(bdev))
1266                return ERR_CAST(bdev);
1267
1268        /*
1269         * once the super is inserted into the list by sget, s_umount
1270         * will protect the lockfs code from trying to start a snapshot
1271         * while we are mounting
1272         */
1273        mutex_lock(&bdev->bd_fsfreeze_mutex);
1274        if (bdev->bd_fsfreeze_count > 0) {
1275                mutex_unlock(&bdev->bd_fsfreeze_mutex);
1276                error = -EBUSY;
1277                goto error_bdev;
1278        }
1279        s = sget(fs_type, test_gfs2_super, set_gfs2_super, flags, bdev);
1280        mutex_unlock(&bdev->bd_fsfreeze_mutex);
1281        error = PTR_ERR(s);
1282        if (IS_ERR(s))
1283                goto error_bdev;
1284
1285        if (s->s_root) {
1286                /*
1287                 * s_umount nests inside bd_mutex during
1288                 * __invalidate_device().  blkdev_put() acquires
1289                 * bd_mutex and can't be called under s_umount.  Drop
1290                 * s_umount temporarily.  This is safe as we're
1291                 * holding an active reference.
1292                 */
1293                up_write(&s->s_umount);
1294                blkdev_put(bdev, mode);
1295                down_write(&s->s_umount);
1296        } else {
1297                /* s_mode must be set before deactivate_locked_super calls */
1298                s->s_mode = mode;
1299        }
1300
1301        memset(&args, 0, sizeof(args));
1302        args.ar_quota = GFS2_QUOTA_DEFAULT;
1303        args.ar_data = GFS2_DATA_DEFAULT;
1304        args.ar_commit = 30;
1305        args.ar_statfs_quantum = 30;
1306        args.ar_quota_quantum = 60;
1307        args.ar_errors = GFS2_ERRORS_DEFAULT;
1308
1309        error = gfs2_mount_args(&args, data);
1310        if (error) {
1311                pr_warn("can't parse mount arguments\n");
1312                goto error_super;
1313        }
1314
1315        if (s->s_root) {
1316                error = -EBUSY;
1317                if ((flags ^ s->s_flags) & MS_RDONLY)
1318                        goto error_super;
1319        } else {
1320                snprintf(s->s_id, sizeof(s->s_id), "%pg", bdev);
1321                sb_set_blocksize(s, block_size(bdev));
1322                error = fill_super(s, &args, flags & MS_SILENT ? 1 : 0);
1323                if (error)
1324                        goto error_super;
1325                s->s_flags |= MS_ACTIVE;
1326                bdev->bd_super = s;
1327        }
1328
1329        sdp = s->s_fs_info;
1330        if (args.ar_meta)
1331                return dget(sdp->sd_master_dir);
1332        else
1333                return dget(sdp->sd_root_dir);
1334
1335error_super:
1336        deactivate_locked_super(s);
1337        return ERR_PTR(error);
1338error_bdev:
1339        blkdev_put(bdev, mode);
1340        return ERR_PTR(error);
1341}
1342
1343static int set_meta_super(struct super_block *s, void *ptr)
1344{
1345        return -EINVAL;
1346}
1347
1348static struct dentry *gfs2_mount_meta(struct file_system_type *fs_type,
1349                        int flags, const char *dev_name, void *data)
1350{
1351        struct super_block *s;
1352        struct gfs2_sbd *sdp;
1353        struct path path;
1354        int error;
1355
1356        error = kern_path(dev_name, LOOKUP_FOLLOW, &path);
1357        if (error) {
1358                pr_warn("path_lookup on %s returned error %d\n",
1359                        dev_name, error);
1360                return ERR_PTR(error);
1361        }
1362        s = sget(&gfs2_fs_type, test_gfs2_super, set_meta_super, flags,
1363                 path.dentry->d_sb->s_bdev);
1364        path_put(&path);
1365        if (IS_ERR(s)) {
1366                pr_warn("gfs2 mount does not exist\n");
1367                return ERR_CAST(s);
1368        }
1369        if ((flags ^ s->s_flags) & MS_RDONLY) {
1370                deactivate_locked_super(s);
1371                return ERR_PTR(-EBUSY);
1372        }
1373        sdp = s->s_fs_info;
1374        return dget(sdp->sd_master_dir);
1375}
1376
1377static void gfs2_kill_sb(struct super_block *sb)
1378{
1379        struct gfs2_sbd *sdp = sb->s_fs_info;
1380
1381        if (sdp == NULL) {
1382                kill_block_super(sb);
1383                return;
1384        }
1385
1386        gfs2_log_flush(sdp, NULL, SYNC_FLUSH);
1387        dput(sdp->sd_root_dir);
1388        dput(sdp->sd_master_dir);
1389        sdp->sd_root_dir = NULL;
1390        sdp->sd_master_dir = NULL;
1391        shrink_dcache_sb(sb);
1392        gfs2_delete_debugfs_file(sdp);
1393        free_percpu(sdp->sd_lkstats);
1394        kill_block_super(sb);
1395}
1396
1397struct file_system_type gfs2_fs_type = {
1398        .name = "gfs2",
1399        .fs_flags = FS_REQUIRES_DEV,
1400        .mount = gfs2_mount,
1401        .kill_sb = gfs2_kill_sb,
1402        .owner = THIS_MODULE,
1403};
1404MODULE_ALIAS_FS("gfs2");
1405
1406struct file_system_type gfs2meta_fs_type = {
1407        .name = "gfs2meta",
1408        .fs_flags = FS_REQUIRES_DEV,
1409        .mount = gfs2_mount_meta,
1410        .owner = THIS_MODULE,
1411};
1412MODULE_ALIAS_FS("gfs2meta");
1413