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