PageRenderTime 101ms CodeModel.GetById 3ms app.highlight 88ms RepoModel.GetById 1ms app.codeStats 0ms

/fs/gfs2/ops_fstype.c

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