cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

ops_fstype.c (45019B)


      1// SPDX-License-Identifier: GPL-2.0-only
      2/*
      3 * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
      4 * Copyright (C) 2004-2008 Red Hat, Inc.  All rights reserved.
      5 */
      6
      7#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
      8
      9#include <linux/sched.h>
     10#include <linux/slab.h>
     11#include <linux/spinlock.h>
     12#include <linux/completion.h>
     13#include <linux/buffer_head.h>
     14#include <linux/blkdev.h>
     15#include <linux/kthread.h>
     16#include <linux/export.h>
     17#include <linux/namei.h>
     18#include <linux/mount.h>
     19#include <linux/gfs2_ondisk.h>
     20#include <linux/quotaops.h>
     21#include <linux/lockdep.h>
     22#include <linux/module.h>
     23#include <linux/backing-dev.h>
     24#include <linux/fs_parser.h>
     25
     26#include "gfs2.h"
     27#include "incore.h"
     28#include "bmap.h"
     29#include "glock.h"
     30#include "glops.h"
     31#include "inode.h"
     32#include "recovery.h"
     33#include "rgrp.h"
     34#include "super.h"
     35#include "sys.h"
     36#include "util.h"
     37#include "log.h"
     38#include "quota.h"
     39#include "dir.h"
     40#include "meta_io.h"
     41#include "trace_gfs2.h"
     42#include "lops.h"
     43
     44#define DO 0
     45#define UNDO 1
     46
     47/**
     48 * gfs2_tune_init - Fill a gfs2_tune structure with default values
     49 * @gt: tune
     50 *
     51 */
     52
     53static void gfs2_tune_init(struct gfs2_tune *gt)
     54{
     55	spin_lock_init(&gt->gt_spin);
     56
     57	gt->gt_quota_warn_period = 10;
     58	gt->gt_quota_scale_num = 1;
     59	gt->gt_quota_scale_den = 1;
     60	gt->gt_new_files_jdata = 0;
     61	gt->gt_max_readahead = BIT(18);
     62	gt->gt_complain_secs = 10;
     63}
     64
     65void free_sbd(struct gfs2_sbd *sdp)
     66{
     67	if (sdp->sd_lkstats)
     68		free_percpu(sdp->sd_lkstats);
     69	kfree(sdp);
     70}
     71
     72static struct gfs2_sbd *init_sbd(struct super_block *sb)
     73{
     74	struct gfs2_sbd *sdp;
     75	struct address_space *mapping;
     76
     77	sdp = kzalloc(sizeof(struct gfs2_sbd), GFP_KERNEL);
     78	if (!sdp)
     79		return NULL;
     80
     81	sdp->sd_vfs = sb;
     82	sdp->sd_lkstats = alloc_percpu(struct gfs2_pcpu_lkstats);
     83	if (!sdp->sd_lkstats)
     84		goto fail;
     85	sb->s_fs_info = sdp;
     86
     87	set_bit(SDF_NOJOURNALID, &sdp->sd_flags);
     88	gfs2_tune_init(&sdp->sd_tune);
     89
     90	init_waitqueue_head(&sdp->sd_glock_wait);
     91	init_waitqueue_head(&sdp->sd_async_glock_wait);
     92	atomic_set(&sdp->sd_glock_disposal, 0);
     93	init_completion(&sdp->sd_locking_init);
     94	init_completion(&sdp->sd_wdack);
     95	spin_lock_init(&sdp->sd_statfs_spin);
     96
     97	spin_lock_init(&sdp->sd_rindex_spin);
     98	sdp->sd_rindex_tree.rb_node = NULL;
     99
    100	INIT_LIST_HEAD(&sdp->sd_jindex_list);
    101	spin_lock_init(&sdp->sd_jindex_spin);
    102	mutex_init(&sdp->sd_jindex_mutex);
    103	init_completion(&sdp->sd_journal_ready);
    104
    105	INIT_LIST_HEAD(&sdp->sd_quota_list);
    106	mutex_init(&sdp->sd_quota_mutex);
    107	mutex_init(&sdp->sd_quota_sync_mutex);
    108	init_waitqueue_head(&sdp->sd_quota_wait);
    109	INIT_LIST_HEAD(&sdp->sd_trunc_list);
    110	spin_lock_init(&sdp->sd_trunc_lock);
    111	spin_lock_init(&sdp->sd_bitmap_lock);
    112
    113	INIT_LIST_HEAD(&sdp->sd_sc_inodes_list);
    114
    115	mapping = &sdp->sd_aspace;
    116
    117	address_space_init_once(mapping);
    118	mapping->a_ops = &gfs2_rgrp_aops;
    119	mapping->host = sb->s_bdev->bd_inode;
    120	mapping->flags = 0;
    121	mapping_set_gfp_mask(mapping, GFP_NOFS);
    122	mapping->private_data = NULL;
    123	mapping->writeback_index = 0;
    124
    125	spin_lock_init(&sdp->sd_log_lock);
    126	atomic_set(&sdp->sd_log_pinned, 0);
    127	INIT_LIST_HEAD(&sdp->sd_log_revokes);
    128	INIT_LIST_HEAD(&sdp->sd_log_ordered);
    129	spin_lock_init(&sdp->sd_ordered_lock);
    130
    131	init_waitqueue_head(&sdp->sd_log_waitq);
    132	init_waitqueue_head(&sdp->sd_logd_waitq);
    133	spin_lock_init(&sdp->sd_ail_lock);
    134	INIT_LIST_HEAD(&sdp->sd_ail1_list);
    135	INIT_LIST_HEAD(&sdp->sd_ail2_list);
    136
    137	init_rwsem(&sdp->sd_log_flush_lock);
    138	atomic_set(&sdp->sd_log_in_flight, 0);
    139	init_waitqueue_head(&sdp->sd_log_flush_wait);
    140	atomic_set(&sdp->sd_freeze_state, SFS_UNFROZEN);
    141	mutex_init(&sdp->sd_freeze_mutex);
    142
    143	return sdp;
    144
    145fail:
    146	free_sbd(sdp);
    147	return NULL;
    148}
    149
    150/**
    151 * gfs2_check_sb - Check superblock
    152 * @sdp: the filesystem
    153 * @silent: Don't print a message if the check fails
    154 *
    155 * Checks the version code of the FS is one that we understand how to
    156 * read and that the sizes of the various on-disk structures have not
    157 * changed.
    158 */
    159
    160static int gfs2_check_sb(struct gfs2_sbd *sdp, int silent)
    161{
    162	struct gfs2_sb_host *sb = &sdp->sd_sb;
    163
    164	if (sb->sb_magic != GFS2_MAGIC ||
    165	    sb->sb_type != GFS2_METATYPE_SB) {
    166		if (!silent)
    167			pr_warn("not a GFS2 filesystem\n");
    168		return -EINVAL;
    169	}
    170
    171	if (sb->sb_fs_format < GFS2_FS_FORMAT_MIN ||
    172	    sb->sb_fs_format > GFS2_FS_FORMAT_MAX ||
    173	    sb->sb_multihost_format != GFS2_FORMAT_MULTI) {
    174		fs_warn(sdp, "Unknown on-disk format, unable to mount\n");
    175		return -EINVAL;
    176	}
    177
    178	if (sb->sb_bsize < 512 || sb->sb_bsize > PAGE_SIZE ||
    179	    (sb->sb_bsize & (sb->sb_bsize - 1))) {
    180		pr_warn("Invalid block size\n");
    181		return -EINVAL;
    182	}
    183
    184	return 0;
    185}
    186
    187static void end_bio_io_page(struct bio *bio)
    188{
    189	struct page *page = bio->bi_private;
    190
    191	if (!bio->bi_status)
    192		SetPageUptodate(page);
    193	else
    194		pr_warn("error %d reading superblock\n", bio->bi_status);
    195	unlock_page(page);
    196}
    197
    198static void gfs2_sb_in(struct gfs2_sbd *sdp, const void *buf)
    199{
    200	struct gfs2_sb_host *sb = &sdp->sd_sb;
    201	struct super_block *s = sdp->sd_vfs;
    202	const struct gfs2_sb *str = buf;
    203
    204	sb->sb_magic = be32_to_cpu(str->sb_header.mh_magic);
    205	sb->sb_type = be32_to_cpu(str->sb_header.mh_type);
    206	sb->sb_fs_format = be32_to_cpu(str->sb_fs_format);
    207	sb->sb_multihost_format = be32_to_cpu(str->sb_multihost_format);
    208	sb->sb_bsize = be32_to_cpu(str->sb_bsize);
    209	sb->sb_bsize_shift = be32_to_cpu(str->sb_bsize_shift);
    210	sb->sb_master_dir.no_addr = be64_to_cpu(str->sb_master_dir.no_addr);
    211	sb->sb_master_dir.no_formal_ino = be64_to_cpu(str->sb_master_dir.no_formal_ino);
    212	sb->sb_root_dir.no_addr = be64_to_cpu(str->sb_root_dir.no_addr);
    213	sb->sb_root_dir.no_formal_ino = be64_to_cpu(str->sb_root_dir.no_formal_ino);
    214
    215	memcpy(sb->sb_lockproto, str->sb_lockproto, GFS2_LOCKNAME_LEN);
    216	memcpy(sb->sb_locktable, str->sb_locktable, GFS2_LOCKNAME_LEN);
    217	memcpy(&s->s_uuid, str->sb_uuid, 16);
    218}
    219
    220/**
    221 * gfs2_read_super - Read the gfs2 super block from disk
    222 * @sdp: The GFS2 super block
    223 * @sector: The location of the super block
    224 * @silent: Don't print a message if the check fails
    225 *
    226 * This uses the bio functions to read the super block from disk
    227 * because we want to be 100% sure that we never read cached data.
    228 * A super block is read twice only during each GFS2 mount and is
    229 * never written to by the filesystem. The first time its read no
    230 * locks are held, and the only details which are looked at are those
    231 * relating to the locking protocol. Once locking is up and working,
    232 * the sb is read again under the lock to establish the location of
    233 * the master directory (contains pointers to journals etc) and the
    234 * root directory.
    235 *
    236 * Returns: 0 on success or error
    237 */
    238
    239static int gfs2_read_super(struct gfs2_sbd *sdp, sector_t sector, int silent)
    240{
    241	struct super_block *sb = sdp->sd_vfs;
    242	struct gfs2_sb *p;
    243	struct page *page;
    244	struct bio *bio;
    245
    246	page = alloc_page(GFP_NOFS);
    247	if (unlikely(!page))
    248		return -ENOMEM;
    249
    250	ClearPageUptodate(page);
    251	ClearPageDirty(page);
    252	lock_page(page);
    253
    254	bio = bio_alloc(sb->s_bdev, 1, REQ_OP_READ | REQ_META, GFP_NOFS);
    255	bio->bi_iter.bi_sector = sector * (sb->s_blocksize >> 9);
    256	bio_add_page(bio, page, PAGE_SIZE, 0);
    257
    258	bio->bi_end_io = end_bio_io_page;
    259	bio->bi_private = page;
    260	submit_bio(bio);
    261	wait_on_page_locked(page);
    262	bio_put(bio);
    263	if (!PageUptodate(page)) {
    264		__free_page(page);
    265		return -EIO;
    266	}
    267	p = kmap(page);
    268	gfs2_sb_in(sdp, p);
    269	kunmap(page);
    270	__free_page(page);
    271	return gfs2_check_sb(sdp, silent);
    272}
    273
    274/**
    275 * gfs2_read_sb - Read super block
    276 * @sdp: The GFS2 superblock
    277 * @silent: Don't print message if mount fails
    278 *
    279 */
    280
    281static int gfs2_read_sb(struct gfs2_sbd *sdp, int silent)
    282{
    283	u32 hash_blocks, ind_blocks, leaf_blocks;
    284	u32 tmp_blocks;
    285	unsigned int x;
    286	int error;
    287
    288	error = gfs2_read_super(sdp, GFS2_SB_ADDR >> sdp->sd_fsb2bb_shift, silent);
    289	if (error) {
    290		if (!silent)
    291			fs_err(sdp, "can't read superblock\n");
    292		return error;
    293	}
    294
    295	sdp->sd_fsb2bb_shift = sdp->sd_sb.sb_bsize_shift -
    296			       GFS2_BASIC_BLOCK_SHIFT;
    297	sdp->sd_fsb2bb = BIT(sdp->sd_fsb2bb_shift);
    298	sdp->sd_diptrs = (sdp->sd_sb.sb_bsize -
    299			  sizeof(struct gfs2_dinode)) / sizeof(u64);
    300	sdp->sd_inptrs = (sdp->sd_sb.sb_bsize -
    301			  sizeof(struct gfs2_meta_header)) / sizeof(u64);
    302	sdp->sd_ldptrs = (sdp->sd_sb.sb_bsize -
    303			  sizeof(struct gfs2_log_descriptor)) / sizeof(u64);
    304	sdp->sd_jbsize = sdp->sd_sb.sb_bsize - sizeof(struct gfs2_meta_header);
    305	sdp->sd_hash_bsize = sdp->sd_sb.sb_bsize / 2;
    306	sdp->sd_hash_bsize_shift = sdp->sd_sb.sb_bsize_shift - 1;
    307	sdp->sd_hash_ptrs = sdp->sd_hash_bsize / sizeof(u64);
    308	sdp->sd_qc_per_block = (sdp->sd_sb.sb_bsize -
    309				sizeof(struct gfs2_meta_header)) /
    310			        sizeof(struct gfs2_quota_change);
    311	sdp->sd_blocks_per_bitmap = (sdp->sd_sb.sb_bsize -
    312				     sizeof(struct gfs2_meta_header))
    313		* GFS2_NBBY; /* not the rgrp bitmap, subsequent bitmaps only */
    314
    315	/*
    316	 * We always keep at least one block reserved for revokes in
    317	 * transactions.  This greatly simplifies allocating additional
    318	 * revoke blocks.
    319	 */
    320	atomic_set(&sdp->sd_log_revokes_available, sdp->sd_ldptrs);
    321
    322	/* Compute maximum reservation required to add a entry to a directory */
    323
    324	hash_blocks = DIV_ROUND_UP(sizeof(u64) * BIT(GFS2_DIR_MAX_DEPTH),
    325			     sdp->sd_jbsize);
    326
    327	ind_blocks = 0;
    328	for (tmp_blocks = hash_blocks; tmp_blocks > sdp->sd_diptrs;) {
    329		tmp_blocks = DIV_ROUND_UP(tmp_blocks, sdp->sd_inptrs);
    330		ind_blocks += tmp_blocks;
    331	}
    332
    333	leaf_blocks = 2 + GFS2_DIR_MAX_DEPTH;
    334
    335	sdp->sd_max_dirres = hash_blocks + ind_blocks + leaf_blocks;
    336
    337	sdp->sd_heightsize[0] = sdp->sd_sb.sb_bsize -
    338				sizeof(struct gfs2_dinode);
    339	sdp->sd_heightsize[1] = sdp->sd_sb.sb_bsize * sdp->sd_diptrs;
    340	for (x = 2;; x++) {
    341		u64 space, d;
    342		u32 m;
    343
    344		space = sdp->sd_heightsize[x - 1] * sdp->sd_inptrs;
    345		d = space;
    346		m = do_div(d, sdp->sd_inptrs);
    347
    348		if (d != sdp->sd_heightsize[x - 1] || m)
    349			break;
    350		sdp->sd_heightsize[x] = space;
    351	}
    352	sdp->sd_max_height = x;
    353	sdp->sd_heightsize[x] = ~0;
    354	gfs2_assert(sdp, sdp->sd_max_height <= GFS2_MAX_META_HEIGHT);
    355
    356	sdp->sd_max_dents_per_leaf = (sdp->sd_sb.sb_bsize -
    357				      sizeof(struct gfs2_leaf)) /
    358				     GFS2_MIN_DIRENT_SIZE;
    359	return 0;
    360}
    361
    362static int init_names(struct gfs2_sbd *sdp, int silent)
    363{
    364	char *proto, *table;
    365	int error = 0;
    366
    367	proto = sdp->sd_args.ar_lockproto;
    368	table = sdp->sd_args.ar_locktable;
    369
    370	/*  Try to autodetect  */
    371
    372	if (!proto[0] || !table[0]) {
    373		error = gfs2_read_super(sdp, GFS2_SB_ADDR >> sdp->sd_fsb2bb_shift, silent);
    374		if (error)
    375			return error;
    376
    377		if (!proto[0])
    378			proto = sdp->sd_sb.sb_lockproto;
    379		if (!table[0])
    380			table = sdp->sd_sb.sb_locktable;
    381	}
    382
    383	if (!table[0])
    384		table = sdp->sd_vfs->s_id;
    385
    386	strlcpy(sdp->sd_proto_name, proto, GFS2_FSNAME_LEN);
    387	strlcpy(sdp->sd_table_name, table, GFS2_FSNAME_LEN);
    388
    389	table = sdp->sd_table_name;
    390	while ((table = strchr(table, '/')))
    391		*table = '_';
    392
    393	return error;
    394}
    395
    396static int init_locking(struct gfs2_sbd *sdp, struct gfs2_holder *mount_gh,
    397			int undo)
    398{
    399	int error = 0;
    400
    401	if (undo)
    402		goto fail_trans;
    403
    404	error = gfs2_glock_nq_num(sdp,
    405				  GFS2_MOUNT_LOCK, &gfs2_nondisk_glops,
    406				  LM_ST_EXCLUSIVE, LM_FLAG_NOEXP | GL_NOCACHE,
    407				  mount_gh);
    408	if (error) {
    409		fs_err(sdp, "can't acquire mount glock: %d\n", error);
    410		goto fail;
    411	}
    412
    413	error = gfs2_glock_nq_num(sdp,
    414				  GFS2_LIVE_LOCK, &gfs2_nondisk_glops,
    415				  LM_ST_SHARED,
    416				  LM_FLAG_NOEXP | GL_EXACT,
    417				  &sdp->sd_live_gh);
    418	if (error) {
    419		fs_err(sdp, "can't acquire live glock: %d\n", error);
    420		goto fail_mount;
    421	}
    422
    423	error = gfs2_glock_get(sdp, GFS2_RENAME_LOCK, &gfs2_nondisk_glops,
    424			       CREATE, &sdp->sd_rename_gl);
    425	if (error) {
    426		fs_err(sdp, "can't create rename glock: %d\n", error);
    427		goto fail_live;
    428	}
    429
    430	error = gfs2_glock_get(sdp, GFS2_FREEZE_LOCK, &gfs2_freeze_glops,
    431			       CREATE, &sdp->sd_freeze_gl);
    432	if (error) {
    433		fs_err(sdp, "can't create transaction glock: %d\n", error);
    434		goto fail_rename;
    435	}
    436
    437	return 0;
    438
    439fail_trans:
    440	gfs2_glock_put(sdp->sd_freeze_gl);
    441fail_rename:
    442	gfs2_glock_put(sdp->sd_rename_gl);
    443fail_live:
    444	gfs2_glock_dq_uninit(&sdp->sd_live_gh);
    445fail_mount:
    446	gfs2_glock_dq_uninit(mount_gh);
    447fail:
    448	return error;
    449}
    450
    451static int gfs2_lookup_root(struct super_block *sb, struct dentry **dptr,
    452			    u64 no_addr, const char *name)
    453{
    454	struct gfs2_sbd *sdp = sb->s_fs_info;
    455	struct dentry *dentry;
    456	struct inode *inode;
    457
    458	inode = gfs2_inode_lookup(sb, DT_DIR, no_addr, 0,
    459				  GFS2_BLKST_FREE /* ignore */);
    460	if (IS_ERR(inode)) {
    461		fs_err(sdp, "can't read in %s inode: %ld\n", name, PTR_ERR(inode));
    462		return PTR_ERR(inode);
    463	}
    464	dentry = d_make_root(inode);
    465	if (!dentry) {
    466		fs_err(sdp, "can't alloc %s dentry\n", name);
    467		return -ENOMEM;
    468	}
    469	*dptr = dentry;
    470	return 0;
    471}
    472
    473static int init_sb(struct gfs2_sbd *sdp, int silent)
    474{
    475	struct super_block *sb = sdp->sd_vfs;
    476	struct gfs2_holder sb_gh;
    477	u64 no_addr;
    478	int ret;
    479
    480	ret = gfs2_glock_nq_num(sdp, GFS2_SB_LOCK, &gfs2_meta_glops,
    481				LM_ST_SHARED, 0, &sb_gh);
    482	if (ret) {
    483		fs_err(sdp, "can't acquire superblock glock: %d\n", ret);
    484		return ret;
    485	}
    486
    487	ret = gfs2_read_sb(sdp, silent);
    488	if (ret) {
    489		fs_err(sdp, "can't read superblock: %d\n", ret);
    490		goto out;
    491	}
    492
    493	switch(sdp->sd_sb.sb_fs_format) {
    494	case GFS2_FS_FORMAT_MAX:
    495		sb->s_xattr = gfs2_xattr_handlers_max;
    496		break;
    497
    498	case GFS2_FS_FORMAT_MIN:
    499		sb->s_xattr = gfs2_xattr_handlers_min;
    500		break;
    501
    502	default:
    503		BUG();
    504	}
    505
    506	/* Set up the buffer cache and SB for real */
    507	if (sdp->sd_sb.sb_bsize < bdev_logical_block_size(sb->s_bdev)) {
    508		ret = -EINVAL;
    509		fs_err(sdp, "FS block size (%u) is too small for device "
    510		       "block size (%u)\n",
    511		       sdp->sd_sb.sb_bsize, bdev_logical_block_size(sb->s_bdev));
    512		goto out;
    513	}
    514	if (sdp->sd_sb.sb_bsize > PAGE_SIZE) {
    515		ret = -EINVAL;
    516		fs_err(sdp, "FS block size (%u) is too big for machine "
    517		       "page size (%u)\n",
    518		       sdp->sd_sb.sb_bsize, (unsigned int)PAGE_SIZE);
    519		goto out;
    520	}
    521	sb_set_blocksize(sb, sdp->sd_sb.sb_bsize);
    522
    523	/* Get the root inode */
    524	no_addr = sdp->sd_sb.sb_root_dir.no_addr;
    525	ret = gfs2_lookup_root(sb, &sdp->sd_root_dir, no_addr, "root");
    526	if (ret)
    527		goto out;
    528
    529	/* Get the master inode */
    530	no_addr = sdp->sd_sb.sb_master_dir.no_addr;
    531	ret = gfs2_lookup_root(sb, &sdp->sd_master_dir, no_addr, "master");
    532	if (ret) {
    533		dput(sdp->sd_root_dir);
    534		goto out;
    535	}
    536	sb->s_root = dget(sdp->sd_args.ar_meta ? sdp->sd_master_dir : sdp->sd_root_dir);
    537out:
    538	gfs2_glock_dq_uninit(&sb_gh);
    539	return ret;
    540}
    541
    542static void gfs2_others_may_mount(struct gfs2_sbd *sdp)
    543{
    544	char *message = "FIRSTMOUNT=Done";
    545	char *envp[] = { message, NULL };
    546
    547	fs_info(sdp, "first mount done, others may mount\n");
    548
    549	if (sdp->sd_lockstruct.ls_ops->lm_first_done)
    550		sdp->sd_lockstruct.ls_ops->lm_first_done(sdp);
    551
    552	kobject_uevent_env(&sdp->sd_kobj, KOBJ_CHANGE, envp);
    553}
    554
    555/**
    556 * gfs2_jindex_hold - Grab a lock on the jindex
    557 * @sdp: The GFS2 superblock
    558 * @ji_gh: the holder for the jindex glock
    559 *
    560 * Returns: errno
    561 */
    562
    563static int gfs2_jindex_hold(struct gfs2_sbd *sdp, struct gfs2_holder *ji_gh)
    564{
    565	struct gfs2_inode *dip = GFS2_I(sdp->sd_jindex);
    566	struct qstr name;
    567	char buf[20];
    568	struct gfs2_jdesc *jd;
    569	int error;
    570
    571	name.name = buf;
    572
    573	mutex_lock(&sdp->sd_jindex_mutex);
    574
    575	for (;;) {
    576		struct gfs2_inode *jip;
    577
    578		error = gfs2_glock_nq_init(dip->i_gl, LM_ST_SHARED, 0, ji_gh);
    579		if (error)
    580			break;
    581
    582		name.len = sprintf(buf, "journal%u", sdp->sd_journals);
    583		name.hash = gfs2_disk_hash(name.name, name.len);
    584
    585		error = gfs2_dir_check(sdp->sd_jindex, &name, NULL);
    586		if (error == -ENOENT) {
    587			error = 0;
    588			break;
    589		}
    590
    591		gfs2_glock_dq_uninit(ji_gh);
    592
    593		if (error)
    594			break;
    595
    596		error = -ENOMEM;
    597		jd = kzalloc(sizeof(struct gfs2_jdesc), GFP_KERNEL);
    598		if (!jd)
    599			break;
    600
    601		INIT_LIST_HEAD(&jd->extent_list);
    602		INIT_LIST_HEAD(&jd->jd_revoke_list);
    603
    604		INIT_WORK(&jd->jd_work, gfs2_recover_func);
    605		jd->jd_inode = gfs2_lookupi(sdp->sd_jindex, &name, 1);
    606		if (IS_ERR_OR_NULL(jd->jd_inode)) {
    607			if (!jd->jd_inode)
    608				error = -ENOENT;
    609			else
    610				error = PTR_ERR(jd->jd_inode);
    611			kfree(jd);
    612			break;
    613		}
    614
    615		d_mark_dontcache(jd->jd_inode);
    616		spin_lock(&sdp->sd_jindex_spin);
    617		jd->jd_jid = sdp->sd_journals++;
    618		jip = GFS2_I(jd->jd_inode);
    619		jd->jd_no_addr = jip->i_no_addr;
    620		list_add_tail(&jd->jd_list, &sdp->sd_jindex_list);
    621		spin_unlock(&sdp->sd_jindex_spin);
    622	}
    623
    624	mutex_unlock(&sdp->sd_jindex_mutex);
    625
    626	return error;
    627}
    628
    629/**
    630 * init_statfs - look up and initialize master and local (per node) statfs inodes
    631 * @sdp: The GFS2 superblock
    632 *
    633 * This should be called after the jindex is initialized in init_journal() and
    634 * before gfs2_journal_recovery() is called because we need to be able to write
    635 * to these inodes during recovery.
    636 *
    637 * Returns: errno
    638 */
    639static int init_statfs(struct gfs2_sbd *sdp)
    640{
    641	int error = 0;
    642	struct inode *master = d_inode(sdp->sd_master_dir);
    643	struct inode *pn = NULL;
    644	char buf[30];
    645	struct gfs2_jdesc *jd;
    646	struct gfs2_inode *ip;
    647
    648	sdp->sd_statfs_inode = gfs2_lookup_simple(master, "statfs");
    649	if (IS_ERR(sdp->sd_statfs_inode)) {
    650		error = PTR_ERR(sdp->sd_statfs_inode);
    651		fs_err(sdp, "can't read in statfs inode: %d\n", error);
    652		goto out;
    653	}
    654	if (sdp->sd_args.ar_spectator)
    655		goto out;
    656
    657	pn = gfs2_lookup_simple(master, "per_node");
    658	if (IS_ERR(pn)) {
    659		error = PTR_ERR(pn);
    660		fs_err(sdp, "can't find per_node directory: %d\n", error);
    661		goto put_statfs;
    662	}
    663
    664	/* For each jid, lookup the corresponding local statfs inode in the
    665	 * per_node metafs directory and save it in the sdp->sd_sc_inodes_list. */
    666	list_for_each_entry(jd, &sdp->sd_jindex_list, jd_list) {
    667		struct local_statfs_inode *lsi =
    668			kmalloc(sizeof(struct local_statfs_inode), GFP_NOFS);
    669		if (!lsi) {
    670			error = -ENOMEM;
    671			goto free_local;
    672		}
    673		sprintf(buf, "statfs_change%u", jd->jd_jid);
    674		lsi->si_sc_inode = gfs2_lookup_simple(pn, buf);
    675		if (IS_ERR(lsi->si_sc_inode)) {
    676			error = PTR_ERR(lsi->si_sc_inode);
    677			fs_err(sdp, "can't find local \"sc\" file#%u: %d\n",
    678			       jd->jd_jid, error);
    679			kfree(lsi);
    680			goto free_local;
    681		}
    682		lsi->si_jid = jd->jd_jid;
    683		if (jd->jd_jid == sdp->sd_jdesc->jd_jid)
    684			sdp->sd_sc_inode = lsi->si_sc_inode;
    685
    686		list_add_tail(&lsi->si_list, &sdp->sd_sc_inodes_list);
    687	}
    688
    689	iput(pn);
    690	pn = NULL;
    691	ip = GFS2_I(sdp->sd_sc_inode);
    692	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0,
    693				   &sdp->sd_sc_gh);
    694	if (error) {
    695		fs_err(sdp, "can't lock local \"sc\" file: %d\n", error);
    696		goto free_local;
    697	}
    698	/* read in the local statfs buffer - other nodes don't change it. */
    699	error = gfs2_meta_inode_buffer(ip, &sdp->sd_sc_bh);
    700	if (error) {
    701		fs_err(sdp, "Cannot read in local statfs: %d\n", error);
    702		goto unlock_sd_gh;
    703	}
    704	return 0;
    705
    706unlock_sd_gh:
    707	gfs2_glock_dq_uninit(&sdp->sd_sc_gh);
    708free_local:
    709	free_local_statfs_inodes(sdp);
    710	iput(pn);
    711put_statfs:
    712	iput(sdp->sd_statfs_inode);
    713out:
    714	return error;
    715}
    716
    717/* Uninitialize and free up memory used by the list of statfs inodes */
    718static void uninit_statfs(struct gfs2_sbd *sdp)
    719{
    720	if (!sdp->sd_args.ar_spectator) {
    721		brelse(sdp->sd_sc_bh);
    722		gfs2_glock_dq_uninit(&sdp->sd_sc_gh);
    723		free_local_statfs_inodes(sdp);
    724	}
    725	iput(sdp->sd_statfs_inode);
    726}
    727
    728static int init_journal(struct gfs2_sbd *sdp, int undo)
    729{
    730	struct inode *master = d_inode(sdp->sd_master_dir);
    731	struct gfs2_holder ji_gh;
    732	struct gfs2_inode *ip;
    733	int jindex = 1;
    734	int error = 0;
    735
    736	if (undo) {
    737		jindex = 0;
    738		goto fail_statfs;
    739	}
    740
    741	sdp->sd_jindex = gfs2_lookup_simple(master, "jindex");
    742	if (IS_ERR(sdp->sd_jindex)) {
    743		fs_err(sdp, "can't lookup journal index: %d\n", error);
    744		return PTR_ERR(sdp->sd_jindex);
    745	}
    746
    747	/* Load in the journal index special file */
    748
    749	error = gfs2_jindex_hold(sdp, &ji_gh);
    750	if (error) {
    751		fs_err(sdp, "can't read journal index: %d\n", error);
    752		goto fail;
    753	}
    754
    755	error = -EUSERS;
    756	if (!gfs2_jindex_size(sdp)) {
    757		fs_err(sdp, "no journals!\n");
    758		goto fail_jindex;
    759	}
    760
    761	atomic_set(&sdp->sd_log_blks_needed, 0);
    762	if (sdp->sd_args.ar_spectator) {
    763		sdp->sd_jdesc = gfs2_jdesc_find(sdp, 0);
    764		atomic_set(&sdp->sd_log_blks_free, sdp->sd_jdesc->jd_blocks);
    765		atomic_set(&sdp->sd_log_thresh1, 2*sdp->sd_jdesc->jd_blocks/5);
    766		atomic_set(&sdp->sd_log_thresh2, 4*sdp->sd_jdesc->jd_blocks/5);
    767	} else {
    768		if (sdp->sd_lockstruct.ls_jid >= gfs2_jindex_size(sdp)) {
    769			fs_err(sdp, "can't mount journal #%u\n",
    770			       sdp->sd_lockstruct.ls_jid);
    771			fs_err(sdp, "there are only %u journals (0 - %u)\n",
    772			       gfs2_jindex_size(sdp),
    773			       gfs2_jindex_size(sdp) - 1);
    774			goto fail_jindex;
    775		}
    776		sdp->sd_jdesc = gfs2_jdesc_find(sdp, sdp->sd_lockstruct.ls_jid);
    777
    778		error = gfs2_glock_nq_num(sdp, sdp->sd_lockstruct.ls_jid,
    779					  &gfs2_journal_glops,
    780					  LM_ST_EXCLUSIVE,
    781					  LM_FLAG_NOEXP | GL_NOCACHE,
    782					  &sdp->sd_journal_gh);
    783		if (error) {
    784			fs_err(sdp, "can't acquire journal glock: %d\n", error);
    785			goto fail_jindex;
    786		}
    787
    788		ip = GFS2_I(sdp->sd_jdesc->jd_inode);
    789		sdp->sd_jinode_gl = ip->i_gl;
    790		error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED,
    791					   LM_FLAG_NOEXP | GL_EXACT | GL_NOCACHE,
    792					   &sdp->sd_jinode_gh);
    793		if (error) {
    794			fs_err(sdp, "can't acquire journal inode glock: %d\n",
    795			       error);
    796			goto fail_journal_gh;
    797		}
    798
    799		error = gfs2_jdesc_check(sdp->sd_jdesc);
    800		if (error) {
    801			fs_err(sdp, "my journal (%u) is bad: %d\n",
    802			       sdp->sd_jdesc->jd_jid, error);
    803			goto fail_jinode_gh;
    804		}
    805		atomic_set(&sdp->sd_log_blks_free, sdp->sd_jdesc->jd_blocks);
    806		atomic_set(&sdp->sd_log_thresh1, 2*sdp->sd_jdesc->jd_blocks/5);
    807		atomic_set(&sdp->sd_log_thresh2, 4*sdp->sd_jdesc->jd_blocks/5);
    808
    809		/* Map the extents for this journal's blocks */
    810		gfs2_map_journal_extents(sdp, sdp->sd_jdesc);
    811	}
    812	trace_gfs2_log_blocks(sdp, atomic_read(&sdp->sd_log_blks_free));
    813
    814	/* Lookup statfs inodes here so journal recovery can use them. */
    815	error = init_statfs(sdp);
    816	if (error)
    817		goto fail_jinode_gh;
    818
    819	if (sdp->sd_lockstruct.ls_first) {
    820		unsigned int x;
    821		for (x = 0; x < sdp->sd_journals; x++) {
    822			struct gfs2_jdesc *jd = gfs2_jdesc_find(sdp, x);
    823
    824			if (sdp->sd_args.ar_spectator) {
    825				error = check_journal_clean(sdp, jd, true);
    826				if (error)
    827					goto fail_statfs;
    828				continue;
    829			}
    830			error = gfs2_recover_journal(jd, true);
    831			if (error) {
    832				fs_err(sdp, "error recovering journal %u: %d\n",
    833				       x, error);
    834				goto fail_statfs;
    835			}
    836		}
    837
    838		gfs2_others_may_mount(sdp);
    839	} else if (!sdp->sd_args.ar_spectator) {
    840		error = gfs2_recover_journal(sdp->sd_jdesc, true);
    841		if (error) {
    842			fs_err(sdp, "error recovering my journal: %d\n", error);
    843			goto fail_statfs;
    844		}
    845	}
    846
    847	sdp->sd_log_idle = 1;
    848	set_bit(SDF_JOURNAL_CHECKED, &sdp->sd_flags);
    849	gfs2_glock_dq_uninit(&ji_gh);
    850	jindex = 0;
    851	INIT_WORK(&sdp->sd_freeze_work, gfs2_freeze_func);
    852	return 0;
    853
    854fail_statfs:
    855	uninit_statfs(sdp);
    856fail_jinode_gh:
    857	/* A withdraw may have done dq/uninit so now we need to check it */
    858	if (!sdp->sd_args.ar_spectator &&
    859	    gfs2_holder_initialized(&sdp->sd_jinode_gh))
    860		gfs2_glock_dq_uninit(&sdp->sd_jinode_gh);
    861fail_journal_gh:
    862	if (!sdp->sd_args.ar_spectator &&
    863	    gfs2_holder_initialized(&sdp->sd_journal_gh))
    864		gfs2_glock_dq_uninit(&sdp->sd_journal_gh);
    865fail_jindex:
    866	gfs2_jindex_free(sdp);
    867	if (jindex)
    868		gfs2_glock_dq_uninit(&ji_gh);
    869fail:
    870	iput(sdp->sd_jindex);
    871	return error;
    872}
    873
    874static struct lock_class_key gfs2_quota_imutex_key;
    875
    876static int init_inodes(struct gfs2_sbd *sdp, int undo)
    877{
    878	int error = 0;
    879	struct inode *master = d_inode(sdp->sd_master_dir);
    880
    881	if (undo)
    882		goto fail_qinode;
    883
    884	error = init_journal(sdp, undo);
    885	complete_all(&sdp->sd_journal_ready);
    886	if (error)
    887		goto fail;
    888
    889	/* Read in the resource index inode */
    890	sdp->sd_rindex = gfs2_lookup_simple(master, "rindex");
    891	if (IS_ERR(sdp->sd_rindex)) {
    892		error = PTR_ERR(sdp->sd_rindex);
    893		fs_err(sdp, "can't get resource index inode: %d\n", error);
    894		goto fail_journal;
    895	}
    896	sdp->sd_rindex_uptodate = 0;
    897
    898	/* Read in the quota inode */
    899	sdp->sd_quota_inode = gfs2_lookup_simple(master, "quota");
    900	if (IS_ERR(sdp->sd_quota_inode)) {
    901		error = PTR_ERR(sdp->sd_quota_inode);
    902		fs_err(sdp, "can't get quota file inode: %d\n", error);
    903		goto fail_rindex;
    904	}
    905	/*
    906	 * i_rwsem on quota files is special. Since this inode is hidden system
    907	 * file, we are safe to define locking ourselves.
    908	 */
    909	lockdep_set_class(&sdp->sd_quota_inode->i_rwsem,
    910			  &gfs2_quota_imutex_key);
    911
    912	error = gfs2_rindex_update(sdp);
    913	if (error)
    914		goto fail_qinode;
    915
    916	return 0;
    917
    918fail_qinode:
    919	iput(sdp->sd_quota_inode);
    920fail_rindex:
    921	gfs2_clear_rgrpd(sdp);
    922	iput(sdp->sd_rindex);
    923fail_journal:
    924	init_journal(sdp, UNDO);
    925fail:
    926	return error;
    927}
    928
    929static int init_per_node(struct gfs2_sbd *sdp, int undo)
    930{
    931	struct inode *pn = NULL;
    932	char buf[30];
    933	int error = 0;
    934	struct gfs2_inode *ip;
    935	struct inode *master = d_inode(sdp->sd_master_dir);
    936
    937	if (sdp->sd_args.ar_spectator)
    938		return 0;
    939
    940	if (undo)
    941		goto fail_qc_gh;
    942
    943	pn = gfs2_lookup_simple(master, "per_node");
    944	if (IS_ERR(pn)) {
    945		error = PTR_ERR(pn);
    946		fs_err(sdp, "can't find per_node directory: %d\n", error);
    947		return error;
    948	}
    949
    950	sprintf(buf, "quota_change%u", sdp->sd_jdesc->jd_jid);
    951	sdp->sd_qc_inode = gfs2_lookup_simple(pn, buf);
    952	if (IS_ERR(sdp->sd_qc_inode)) {
    953		error = PTR_ERR(sdp->sd_qc_inode);
    954		fs_err(sdp, "can't find local \"qc\" file: %d\n", error);
    955		goto fail_ut_i;
    956	}
    957
    958	iput(pn);
    959	pn = NULL;
    960
    961	ip = GFS2_I(sdp->sd_qc_inode);
    962	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0,
    963				   &sdp->sd_qc_gh);
    964	if (error) {
    965		fs_err(sdp, "can't lock local \"qc\" file: %d\n", error);
    966		goto fail_qc_i;
    967	}
    968
    969	return 0;
    970
    971fail_qc_gh:
    972	gfs2_glock_dq_uninit(&sdp->sd_qc_gh);
    973fail_qc_i:
    974	iput(sdp->sd_qc_inode);
    975fail_ut_i:
    976	iput(pn);
    977	return error;
    978}
    979
    980static const match_table_t nolock_tokens = {
    981	{ Opt_jid, "jid=%d", },
    982	{ Opt_err, NULL },
    983};
    984
    985static const struct lm_lockops nolock_ops = {
    986	.lm_proto_name = "lock_nolock",
    987	.lm_put_lock = gfs2_glock_free,
    988	.lm_tokens = &nolock_tokens,
    989};
    990
    991/**
    992 * gfs2_lm_mount - mount a locking protocol
    993 * @sdp: the filesystem
    994 * @silent: if 1, don't complain if the FS isn't a GFS2 fs
    995 *
    996 * Returns: errno
    997 */
    998
    999static int gfs2_lm_mount(struct gfs2_sbd *sdp, int silent)
   1000{
   1001	const struct lm_lockops *lm;
   1002	struct lm_lockstruct *ls = &sdp->sd_lockstruct;
   1003	struct gfs2_args *args = &sdp->sd_args;
   1004	const char *proto = sdp->sd_proto_name;
   1005	const char *table = sdp->sd_table_name;
   1006	char *o, *options;
   1007	int ret;
   1008
   1009	if (!strcmp("lock_nolock", proto)) {
   1010		lm = &nolock_ops;
   1011		sdp->sd_args.ar_localflocks = 1;
   1012#ifdef CONFIG_GFS2_FS_LOCKING_DLM
   1013	} else if (!strcmp("lock_dlm", proto)) {
   1014		lm = &gfs2_dlm_ops;
   1015#endif
   1016	} else {
   1017		pr_info("can't find protocol %s\n", proto);
   1018		return -ENOENT;
   1019	}
   1020
   1021	fs_info(sdp, "Trying to join cluster \"%s\", \"%s\"\n", proto, table);
   1022
   1023	ls->ls_ops = lm;
   1024	ls->ls_first = 1;
   1025
   1026	for (options = args->ar_hostdata; (o = strsep(&options, ":")); ) {
   1027		substring_t tmp[MAX_OPT_ARGS];
   1028		int token, option;
   1029
   1030		if (!o || !*o)
   1031			continue;
   1032
   1033		token = match_token(o, *lm->lm_tokens, tmp);
   1034		switch (token) {
   1035		case Opt_jid:
   1036			ret = match_int(&tmp[0], &option);
   1037			if (ret || option < 0) 
   1038				goto hostdata_error;
   1039			if (test_and_clear_bit(SDF_NOJOURNALID, &sdp->sd_flags))
   1040				ls->ls_jid = option;
   1041			break;
   1042		case Opt_id:
   1043		case Opt_nodir:
   1044			/* Obsolete, but left for backward compat purposes */
   1045			break;
   1046		case Opt_first:
   1047			ret = match_int(&tmp[0], &option);
   1048			if (ret || (option != 0 && option != 1))
   1049				goto hostdata_error;
   1050			ls->ls_first = option;
   1051			break;
   1052		case Opt_err:
   1053		default:
   1054hostdata_error:
   1055			fs_info(sdp, "unknown hostdata (%s)\n", o);
   1056			return -EINVAL;
   1057		}
   1058	}
   1059
   1060	if (lm->lm_mount == NULL) {
   1061		fs_info(sdp, "Now mounting FS (format %u)...\n", sdp->sd_sb.sb_fs_format);
   1062		complete_all(&sdp->sd_locking_init);
   1063		return 0;
   1064	}
   1065	ret = lm->lm_mount(sdp, table);
   1066	if (ret == 0)
   1067		fs_info(sdp, "Joined cluster. Now mounting FS (format %u)...\n",
   1068		        sdp->sd_sb.sb_fs_format);
   1069	complete_all(&sdp->sd_locking_init);
   1070	return ret;
   1071}
   1072
   1073void gfs2_lm_unmount(struct gfs2_sbd *sdp)
   1074{
   1075	const struct lm_lockops *lm = sdp->sd_lockstruct.ls_ops;
   1076	if (likely(!gfs2_withdrawn(sdp)) && lm->lm_unmount)
   1077		lm->lm_unmount(sdp);
   1078}
   1079
   1080static int wait_on_journal(struct gfs2_sbd *sdp)
   1081{
   1082	if (sdp->sd_lockstruct.ls_ops->lm_mount == NULL)
   1083		return 0;
   1084
   1085	return wait_on_bit(&sdp->sd_flags, SDF_NOJOURNALID, TASK_INTERRUPTIBLE)
   1086		? -EINTR : 0;
   1087}
   1088
   1089void gfs2_online_uevent(struct gfs2_sbd *sdp)
   1090{
   1091	struct super_block *sb = sdp->sd_vfs;
   1092	char ro[20];
   1093	char spectator[20];
   1094	char *envp[] = { ro, spectator, NULL };
   1095	sprintf(ro, "RDONLY=%d", sb_rdonly(sb));
   1096	sprintf(spectator, "SPECTATOR=%d", sdp->sd_args.ar_spectator ? 1 : 0);
   1097	kobject_uevent_env(&sdp->sd_kobj, KOBJ_ONLINE, envp);
   1098}
   1099
   1100static int init_threads(struct gfs2_sbd *sdp)
   1101{
   1102	struct task_struct *p;
   1103	int error = 0;
   1104
   1105	p = kthread_run(gfs2_logd, sdp, "gfs2_logd");
   1106	if (IS_ERR(p)) {
   1107		error = PTR_ERR(p);
   1108		fs_err(sdp, "can't start logd thread: %d\n", error);
   1109		return error;
   1110	}
   1111	sdp->sd_logd_process = p;
   1112
   1113	p = kthread_run(gfs2_quotad, sdp, "gfs2_quotad");
   1114	if (IS_ERR(p)) {
   1115		error = PTR_ERR(p);
   1116		fs_err(sdp, "can't start quotad thread: %d\n", error);
   1117		goto fail;
   1118	}
   1119	sdp->sd_quotad_process = p;
   1120	return 0;
   1121
   1122fail:
   1123	kthread_stop(sdp->sd_logd_process);
   1124	sdp->sd_logd_process = NULL;
   1125	return error;
   1126}
   1127
   1128/**
   1129 * gfs2_fill_super - Read in superblock
   1130 * @sb: The VFS superblock
   1131 * @fc: Mount options and flags
   1132 *
   1133 * Returns: -errno
   1134 */
   1135static int gfs2_fill_super(struct super_block *sb, struct fs_context *fc)
   1136{
   1137	struct gfs2_args *args = fc->fs_private;
   1138	int silent = fc->sb_flags & SB_SILENT;
   1139	struct gfs2_sbd *sdp;
   1140	struct gfs2_holder mount_gh;
   1141	struct gfs2_holder freeze_gh;
   1142	int error;
   1143
   1144	sdp = init_sbd(sb);
   1145	if (!sdp) {
   1146		pr_warn("can't alloc struct gfs2_sbd\n");
   1147		return -ENOMEM;
   1148	}
   1149	sdp->sd_args = *args;
   1150
   1151	if (sdp->sd_args.ar_spectator) {
   1152                sb->s_flags |= SB_RDONLY;
   1153		set_bit(SDF_RORECOVERY, &sdp->sd_flags);
   1154	}
   1155	if (sdp->sd_args.ar_posix_acl)
   1156		sb->s_flags |= SB_POSIXACL;
   1157	if (sdp->sd_args.ar_nobarrier)
   1158		set_bit(SDF_NOBARRIERS, &sdp->sd_flags);
   1159
   1160	sb->s_flags |= SB_NOSEC;
   1161	sb->s_magic = GFS2_MAGIC;
   1162	sb->s_op = &gfs2_super_ops;
   1163	sb->s_d_op = &gfs2_dops;
   1164	sb->s_export_op = &gfs2_export_ops;
   1165	sb->s_qcop = &gfs2_quotactl_ops;
   1166	sb->s_quota_types = QTYPE_MASK_USR | QTYPE_MASK_GRP;
   1167	sb_dqopt(sb)->flags |= DQUOT_QUOTA_SYS_FILE;
   1168	sb->s_time_gran = 1;
   1169	sb->s_maxbytes = MAX_LFS_FILESIZE;
   1170
   1171	/* Set up the buffer cache and fill in some fake block size values
   1172	   to allow us to read-in the on-disk superblock. */
   1173	sdp->sd_sb.sb_bsize = sb_min_blocksize(sb, GFS2_BASIC_BLOCK);
   1174	sdp->sd_sb.sb_bsize_shift = sb->s_blocksize_bits;
   1175	sdp->sd_fsb2bb_shift = sdp->sd_sb.sb_bsize_shift -
   1176                               GFS2_BASIC_BLOCK_SHIFT;
   1177	sdp->sd_fsb2bb = BIT(sdp->sd_fsb2bb_shift);
   1178
   1179	sdp->sd_tune.gt_logd_secs = sdp->sd_args.ar_commit;
   1180	sdp->sd_tune.gt_quota_quantum = sdp->sd_args.ar_quota_quantum;
   1181	if (sdp->sd_args.ar_statfs_quantum) {
   1182		sdp->sd_tune.gt_statfs_slow = 0;
   1183		sdp->sd_tune.gt_statfs_quantum = sdp->sd_args.ar_statfs_quantum;
   1184	} else {
   1185		sdp->sd_tune.gt_statfs_slow = 1;
   1186		sdp->sd_tune.gt_statfs_quantum = 30;
   1187	}
   1188
   1189	error = init_names(sdp, silent);
   1190	if (error)
   1191		goto fail_free;
   1192
   1193	snprintf(sdp->sd_fsname, sizeof(sdp->sd_fsname), "%s", sdp->sd_table_name);
   1194
   1195	error = gfs2_sys_fs_add(sdp);
   1196	if (error)
   1197		goto fail_free;
   1198
   1199	gfs2_create_debugfs_file(sdp);
   1200
   1201	error = gfs2_lm_mount(sdp, silent);
   1202	if (error)
   1203		goto fail_debug;
   1204
   1205	error = init_locking(sdp, &mount_gh, DO);
   1206	if (error)
   1207		goto fail_lm;
   1208
   1209	error = init_sb(sdp, silent);
   1210	if (error)
   1211		goto fail_locking;
   1212
   1213	/* Turn rgrplvb on by default if fs format is recent enough */
   1214	if (!sdp->sd_args.ar_got_rgrplvb && sdp->sd_sb.sb_fs_format > 1801)
   1215		sdp->sd_args.ar_rgrplvb = 1;
   1216
   1217	error = wait_on_journal(sdp);
   1218	if (error)
   1219		goto fail_sb;
   1220
   1221	/*
   1222	 * If user space has failed to join the cluster or some similar
   1223	 * failure has occurred, then the journal id will contain a
   1224	 * negative (error) number. This will then be returned to the
   1225	 * caller (of the mount syscall). We do this even for spectator
   1226	 * mounts (which just write a jid of 0 to indicate "ok" even though
   1227	 * the jid is unused in the spectator case)
   1228	 */
   1229	if (sdp->sd_lockstruct.ls_jid < 0) {
   1230		error = sdp->sd_lockstruct.ls_jid;
   1231		sdp->sd_lockstruct.ls_jid = 0;
   1232		goto fail_sb;
   1233	}
   1234
   1235	if (sdp->sd_args.ar_spectator)
   1236		snprintf(sdp->sd_fsname, sizeof(sdp->sd_fsname), "%s.s",
   1237			 sdp->sd_table_name);
   1238	else
   1239		snprintf(sdp->sd_fsname, sizeof(sdp->sd_fsname), "%s.%u",
   1240			 sdp->sd_table_name, sdp->sd_lockstruct.ls_jid);
   1241
   1242	error = init_inodes(sdp, DO);
   1243	if (error)
   1244		goto fail_sb;
   1245
   1246	error = init_per_node(sdp, DO);
   1247	if (error)
   1248		goto fail_inodes;
   1249
   1250	error = gfs2_statfs_init(sdp);
   1251	if (error) {
   1252		fs_err(sdp, "can't initialize statfs subsystem: %d\n", error);
   1253		goto fail_per_node;
   1254	}
   1255
   1256	if (!sb_rdonly(sb)) {
   1257		error = init_threads(sdp);
   1258		if (error) {
   1259			gfs2_withdraw_delayed(sdp);
   1260			goto fail_per_node;
   1261		}
   1262	}
   1263
   1264	error = gfs2_freeze_lock(sdp, &freeze_gh, 0);
   1265	if (error)
   1266		goto fail_per_node;
   1267
   1268	if (!sb_rdonly(sb))
   1269		error = gfs2_make_fs_rw(sdp);
   1270
   1271	gfs2_freeze_unlock(&freeze_gh);
   1272	if (error) {
   1273		if (sdp->sd_quotad_process)
   1274			kthread_stop(sdp->sd_quotad_process);
   1275		sdp->sd_quotad_process = NULL;
   1276		if (sdp->sd_logd_process)
   1277			kthread_stop(sdp->sd_logd_process);
   1278		sdp->sd_logd_process = NULL;
   1279		fs_err(sdp, "can't make FS RW: %d\n", error);
   1280		goto fail_per_node;
   1281	}
   1282	gfs2_glock_dq_uninit(&mount_gh);
   1283	gfs2_online_uevent(sdp);
   1284	return 0;
   1285
   1286fail_per_node:
   1287	init_per_node(sdp, UNDO);
   1288fail_inodes:
   1289	init_inodes(sdp, UNDO);
   1290fail_sb:
   1291	if (sdp->sd_root_dir)
   1292		dput(sdp->sd_root_dir);
   1293	if (sdp->sd_master_dir)
   1294		dput(sdp->sd_master_dir);
   1295	if (sb->s_root)
   1296		dput(sb->s_root);
   1297	sb->s_root = NULL;
   1298fail_locking:
   1299	init_locking(sdp, &mount_gh, UNDO);
   1300fail_lm:
   1301	complete_all(&sdp->sd_journal_ready);
   1302	gfs2_gl_hash_clear(sdp);
   1303	gfs2_lm_unmount(sdp);
   1304fail_debug:
   1305	gfs2_delete_debugfs_file(sdp);
   1306	gfs2_sys_fs_del(sdp);
   1307fail_free:
   1308	free_sbd(sdp);
   1309	sb->s_fs_info = NULL;
   1310	return error;
   1311}
   1312
   1313/**
   1314 * gfs2_get_tree - Get the GFS2 superblock and root directory
   1315 * @fc: The filesystem context
   1316 *
   1317 * Returns: 0 or -errno on error
   1318 */
   1319static int gfs2_get_tree(struct fs_context *fc)
   1320{
   1321	struct gfs2_args *args = fc->fs_private;
   1322	struct gfs2_sbd *sdp;
   1323	int error;
   1324
   1325	error = get_tree_bdev(fc, gfs2_fill_super);
   1326	if (error)
   1327		return error;
   1328
   1329	sdp = fc->root->d_sb->s_fs_info;
   1330	dput(fc->root);
   1331	if (args->ar_meta)
   1332		fc->root = dget(sdp->sd_master_dir);
   1333	else
   1334		fc->root = dget(sdp->sd_root_dir);
   1335	return 0;
   1336}
   1337
   1338static void gfs2_fc_free(struct fs_context *fc)
   1339{
   1340	struct gfs2_args *args = fc->fs_private;
   1341
   1342	kfree(args);
   1343}
   1344
   1345enum gfs2_param {
   1346	Opt_lockproto,
   1347	Opt_locktable,
   1348	Opt_hostdata,
   1349	Opt_spectator,
   1350	Opt_ignore_local_fs,
   1351	Opt_localflocks,
   1352	Opt_localcaching,
   1353	Opt_debug,
   1354	Opt_upgrade,
   1355	Opt_acl,
   1356	Opt_quota,
   1357	Opt_quota_flag,
   1358	Opt_suiddir,
   1359	Opt_data,
   1360	Opt_meta,
   1361	Opt_discard,
   1362	Opt_commit,
   1363	Opt_errors,
   1364	Opt_statfs_quantum,
   1365	Opt_statfs_percent,
   1366	Opt_quota_quantum,
   1367	Opt_barrier,
   1368	Opt_rgrplvb,
   1369	Opt_loccookie,
   1370};
   1371
   1372static const struct constant_table gfs2_param_quota[] = {
   1373	{"off",        GFS2_QUOTA_OFF},
   1374	{"account",    GFS2_QUOTA_ACCOUNT},
   1375	{"on",         GFS2_QUOTA_ON},
   1376	{}
   1377};
   1378
   1379enum opt_data {
   1380	Opt_data_writeback = GFS2_DATA_WRITEBACK,
   1381	Opt_data_ordered   = GFS2_DATA_ORDERED,
   1382};
   1383
   1384static const struct constant_table gfs2_param_data[] = {
   1385	{"writeback",  Opt_data_writeback },
   1386	{"ordered",    Opt_data_ordered },
   1387	{}
   1388};
   1389
   1390enum opt_errors {
   1391	Opt_errors_withdraw = GFS2_ERRORS_WITHDRAW,
   1392	Opt_errors_panic    = GFS2_ERRORS_PANIC,
   1393};
   1394
   1395static const struct constant_table gfs2_param_errors[] = {
   1396	{"withdraw",   Opt_errors_withdraw },
   1397	{"panic",      Opt_errors_panic },
   1398	{}
   1399};
   1400
   1401static const struct fs_parameter_spec gfs2_fs_parameters[] = {
   1402	fsparam_string ("lockproto",          Opt_lockproto),
   1403	fsparam_string ("locktable",          Opt_locktable),
   1404	fsparam_string ("hostdata",           Opt_hostdata),
   1405	fsparam_flag   ("spectator",          Opt_spectator),
   1406	fsparam_flag   ("norecovery",         Opt_spectator),
   1407	fsparam_flag   ("ignore_local_fs",    Opt_ignore_local_fs),
   1408	fsparam_flag   ("localflocks",        Opt_localflocks),
   1409	fsparam_flag   ("localcaching",       Opt_localcaching),
   1410	fsparam_flag_no("debug",              Opt_debug),
   1411	fsparam_flag   ("upgrade",            Opt_upgrade),
   1412	fsparam_flag_no("acl",                Opt_acl),
   1413	fsparam_flag_no("suiddir",            Opt_suiddir),
   1414	fsparam_enum   ("data",               Opt_data, gfs2_param_data),
   1415	fsparam_flag   ("meta",               Opt_meta),
   1416	fsparam_flag_no("discard",            Opt_discard),
   1417	fsparam_s32    ("commit",             Opt_commit),
   1418	fsparam_enum   ("errors",             Opt_errors, gfs2_param_errors),
   1419	fsparam_s32    ("statfs_quantum",     Opt_statfs_quantum),
   1420	fsparam_s32    ("statfs_percent",     Opt_statfs_percent),
   1421	fsparam_s32    ("quota_quantum",      Opt_quota_quantum),
   1422	fsparam_flag_no("barrier",            Opt_barrier),
   1423	fsparam_flag_no("rgrplvb",            Opt_rgrplvb),
   1424	fsparam_flag_no("loccookie",          Opt_loccookie),
   1425	/* quota can be a flag or an enum so it gets special treatment */
   1426	fsparam_flag_no("quota",	      Opt_quota_flag),
   1427	fsparam_enum("quota",		      Opt_quota, gfs2_param_quota),
   1428	{}
   1429};
   1430
   1431/* Parse a single mount parameter */
   1432static int gfs2_parse_param(struct fs_context *fc, struct fs_parameter *param)
   1433{
   1434	struct gfs2_args *args = fc->fs_private;
   1435	struct fs_parse_result result;
   1436	int o;
   1437
   1438	o = fs_parse(fc, gfs2_fs_parameters, param, &result);
   1439	if (o < 0)
   1440		return o;
   1441
   1442	switch (o) {
   1443	case Opt_lockproto:
   1444		strlcpy(args->ar_lockproto, param->string, GFS2_LOCKNAME_LEN);
   1445		break;
   1446	case Opt_locktable:
   1447		strlcpy(args->ar_locktable, param->string, GFS2_LOCKNAME_LEN);
   1448		break;
   1449	case Opt_hostdata:
   1450		strlcpy(args->ar_hostdata, param->string, GFS2_LOCKNAME_LEN);
   1451		break;
   1452	case Opt_spectator:
   1453		args->ar_spectator = 1;
   1454		break;
   1455	case Opt_ignore_local_fs:
   1456		/* Retained for backwards compat only */
   1457		break;
   1458	case Opt_localflocks:
   1459		args->ar_localflocks = 1;
   1460		break;
   1461	case Opt_localcaching:
   1462		/* Retained for backwards compat only */
   1463		break;
   1464	case Opt_debug:
   1465		if (result.boolean && args->ar_errors == GFS2_ERRORS_PANIC)
   1466			return invalfc(fc, "-o debug and -o errors=panic are mutually exclusive");
   1467		args->ar_debug = result.boolean;
   1468		break;
   1469	case Opt_upgrade:
   1470		/* Retained for backwards compat only */
   1471		break;
   1472	case Opt_acl:
   1473		args->ar_posix_acl = result.boolean;
   1474		break;
   1475	case Opt_quota_flag:
   1476		args->ar_quota = result.negated ? GFS2_QUOTA_OFF : GFS2_QUOTA_ON;
   1477		break;
   1478	case Opt_quota:
   1479		args->ar_quota = result.int_32;
   1480		break;
   1481	case Opt_suiddir:
   1482		args->ar_suiddir = result.boolean;
   1483		break;
   1484	case Opt_data:
   1485		/* The uint_32 result maps directly to GFS2_DATA_* */
   1486		args->ar_data = result.uint_32;
   1487		break;
   1488	case Opt_meta:
   1489		args->ar_meta = 1;
   1490		break;
   1491	case Opt_discard:
   1492		args->ar_discard = result.boolean;
   1493		break;
   1494	case Opt_commit:
   1495		if (result.int_32 <= 0)
   1496			return invalfc(fc, "commit mount option requires a positive numeric argument");
   1497		args->ar_commit = result.int_32;
   1498		break;
   1499	case Opt_statfs_quantum:
   1500		if (result.int_32 < 0)
   1501			return invalfc(fc, "statfs_quantum mount option requires a non-negative numeric argument");
   1502		args->ar_statfs_quantum = result.int_32;
   1503		break;
   1504	case Opt_quota_quantum:
   1505		if (result.int_32 <= 0)
   1506			return invalfc(fc, "quota_quantum mount option requires a positive numeric argument");
   1507		args->ar_quota_quantum = result.int_32;
   1508		break;
   1509	case Opt_statfs_percent:
   1510		if (result.int_32 < 0 || result.int_32 > 100)
   1511			return invalfc(fc, "statfs_percent mount option requires a numeric argument between 0 and 100");
   1512		args->ar_statfs_percent = result.int_32;
   1513		break;
   1514	case Opt_errors:
   1515		if (args->ar_debug && result.uint_32 == GFS2_ERRORS_PANIC)
   1516			return invalfc(fc, "-o debug and -o errors=panic are mutually exclusive");
   1517		args->ar_errors = result.uint_32;
   1518		break;
   1519	case Opt_barrier:
   1520		args->ar_nobarrier = result.boolean;
   1521		break;
   1522	case Opt_rgrplvb:
   1523		args->ar_rgrplvb = result.boolean;
   1524		args->ar_got_rgrplvb = 1;
   1525		break;
   1526	case Opt_loccookie:
   1527		args->ar_loccookie = result.boolean;
   1528		break;
   1529	default:
   1530		return invalfc(fc, "invalid mount option: %s", param->key);
   1531	}
   1532	return 0;
   1533}
   1534
   1535static int gfs2_reconfigure(struct fs_context *fc)
   1536{
   1537	struct super_block *sb = fc->root->d_sb;
   1538	struct gfs2_sbd *sdp = sb->s_fs_info;
   1539	struct gfs2_args *oldargs = &sdp->sd_args;
   1540	struct gfs2_args *newargs = fc->fs_private;
   1541	struct gfs2_tune *gt = &sdp->sd_tune;
   1542	int error = 0;
   1543
   1544	sync_filesystem(sb);
   1545
   1546	spin_lock(&gt->gt_spin);
   1547	oldargs->ar_commit = gt->gt_logd_secs;
   1548	oldargs->ar_quota_quantum = gt->gt_quota_quantum;
   1549	if (gt->gt_statfs_slow)
   1550		oldargs->ar_statfs_quantum = 0;
   1551	else
   1552		oldargs->ar_statfs_quantum = gt->gt_statfs_quantum;
   1553	spin_unlock(&gt->gt_spin);
   1554
   1555	if (strcmp(newargs->ar_lockproto, oldargs->ar_lockproto)) {
   1556		errorfc(fc, "reconfiguration of locking protocol not allowed");
   1557		return -EINVAL;
   1558	}
   1559	if (strcmp(newargs->ar_locktable, oldargs->ar_locktable)) {
   1560		errorfc(fc, "reconfiguration of lock table not allowed");
   1561		return -EINVAL;
   1562	}
   1563	if (strcmp(newargs->ar_hostdata, oldargs->ar_hostdata)) {
   1564		errorfc(fc, "reconfiguration of host data not allowed");
   1565		return -EINVAL;
   1566	}
   1567	if (newargs->ar_spectator != oldargs->ar_spectator) {
   1568		errorfc(fc, "reconfiguration of spectator mode not allowed");
   1569		return -EINVAL;
   1570	}
   1571	if (newargs->ar_localflocks != oldargs->ar_localflocks) {
   1572		errorfc(fc, "reconfiguration of localflocks not allowed");
   1573		return -EINVAL;
   1574	}
   1575	if (newargs->ar_meta != oldargs->ar_meta) {
   1576		errorfc(fc, "switching between gfs2 and gfs2meta not allowed");
   1577		return -EINVAL;
   1578	}
   1579	if (oldargs->ar_spectator)
   1580		fc->sb_flags |= SB_RDONLY;
   1581
   1582	if ((sb->s_flags ^ fc->sb_flags) & SB_RDONLY) {
   1583		struct gfs2_holder freeze_gh;
   1584
   1585		error = gfs2_freeze_lock(sdp, &freeze_gh, 0);
   1586		if (error)
   1587			return -EINVAL;
   1588
   1589		if (fc->sb_flags & SB_RDONLY) {
   1590			gfs2_make_fs_ro(sdp);
   1591		} else {
   1592			error = gfs2_make_fs_rw(sdp);
   1593			if (error)
   1594				errorfc(fc, "unable to remount read-write");
   1595		}
   1596		gfs2_freeze_unlock(&freeze_gh);
   1597	}
   1598	sdp->sd_args = *newargs;
   1599
   1600	if (sdp->sd_args.ar_posix_acl)
   1601		sb->s_flags |= SB_POSIXACL;
   1602	else
   1603		sb->s_flags &= ~SB_POSIXACL;
   1604	if (sdp->sd_args.ar_nobarrier)
   1605		set_bit(SDF_NOBARRIERS, &sdp->sd_flags);
   1606	else
   1607		clear_bit(SDF_NOBARRIERS, &sdp->sd_flags);
   1608	spin_lock(&gt->gt_spin);
   1609	gt->gt_logd_secs = newargs->ar_commit;
   1610	gt->gt_quota_quantum = newargs->ar_quota_quantum;
   1611	if (newargs->ar_statfs_quantum) {
   1612		gt->gt_statfs_slow = 0;
   1613		gt->gt_statfs_quantum = newargs->ar_statfs_quantum;
   1614	}
   1615	else {
   1616		gt->gt_statfs_slow = 1;
   1617		gt->gt_statfs_quantum = 30;
   1618	}
   1619	spin_unlock(&gt->gt_spin);
   1620
   1621	gfs2_online_uevent(sdp);
   1622	return error;
   1623}
   1624
   1625static const struct fs_context_operations gfs2_context_ops = {
   1626	.free        = gfs2_fc_free,
   1627	.parse_param = gfs2_parse_param,
   1628	.get_tree    = gfs2_get_tree,
   1629	.reconfigure = gfs2_reconfigure,
   1630};
   1631
   1632/* Set up the filesystem mount context */
   1633static int gfs2_init_fs_context(struct fs_context *fc)
   1634{
   1635	struct gfs2_args *args;
   1636
   1637	args = kmalloc(sizeof(*args), GFP_KERNEL);
   1638	if (args == NULL)
   1639		return -ENOMEM;
   1640
   1641	if (fc->purpose == FS_CONTEXT_FOR_RECONFIGURE) {
   1642		struct gfs2_sbd *sdp = fc->root->d_sb->s_fs_info;
   1643
   1644		*args = sdp->sd_args;
   1645	} else {
   1646		memset(args, 0, sizeof(*args));
   1647		args->ar_quota = GFS2_QUOTA_DEFAULT;
   1648		args->ar_data = GFS2_DATA_DEFAULT;
   1649		args->ar_commit = 30;
   1650		args->ar_statfs_quantum = 30;
   1651		args->ar_quota_quantum = 60;
   1652		args->ar_errors = GFS2_ERRORS_DEFAULT;
   1653	}
   1654	fc->fs_private = args;
   1655	fc->ops = &gfs2_context_ops;
   1656	return 0;
   1657}
   1658
   1659static int set_meta_super(struct super_block *s, struct fs_context *fc)
   1660{
   1661	return -EINVAL;
   1662}
   1663
   1664static int test_meta_super(struct super_block *s, struct fs_context *fc)
   1665{
   1666	return (fc->sget_key == s->s_bdev);
   1667}
   1668
   1669static int gfs2_meta_get_tree(struct fs_context *fc)
   1670{
   1671	struct super_block *s;
   1672	struct gfs2_sbd *sdp;
   1673	struct path path;
   1674	int error;
   1675
   1676	if (!fc->source || !*fc->source)
   1677		return -EINVAL;
   1678
   1679	error = kern_path(fc->source, LOOKUP_FOLLOW, &path);
   1680	if (error) {
   1681		pr_warn("path_lookup on %s returned error %d\n",
   1682		        fc->source, error);
   1683		return error;
   1684	}
   1685	fc->fs_type = &gfs2_fs_type;
   1686	fc->sget_key = path.dentry->d_sb->s_bdev;
   1687	s = sget_fc(fc, test_meta_super, set_meta_super);
   1688	path_put(&path);
   1689	if (IS_ERR(s)) {
   1690		pr_warn("gfs2 mount does not exist\n");
   1691		return PTR_ERR(s);
   1692	}
   1693	if ((fc->sb_flags ^ s->s_flags) & SB_RDONLY) {
   1694		deactivate_locked_super(s);
   1695		return -EBUSY;
   1696	}
   1697	sdp = s->s_fs_info;
   1698	fc->root = dget(sdp->sd_master_dir);
   1699	return 0;
   1700}
   1701
   1702static const struct fs_context_operations gfs2_meta_context_ops = {
   1703	.free        = gfs2_fc_free,
   1704	.get_tree    = gfs2_meta_get_tree,
   1705};
   1706
   1707static int gfs2_meta_init_fs_context(struct fs_context *fc)
   1708{
   1709	int ret = gfs2_init_fs_context(fc);
   1710
   1711	if (ret)
   1712		return ret;
   1713
   1714	fc->ops = &gfs2_meta_context_ops;
   1715	return 0;
   1716}
   1717
   1718static void gfs2_kill_sb(struct super_block *sb)
   1719{
   1720	struct gfs2_sbd *sdp = sb->s_fs_info;
   1721
   1722	if (sdp == NULL) {
   1723		kill_block_super(sb);
   1724		return;
   1725	}
   1726
   1727	gfs2_log_flush(sdp, NULL, GFS2_LOG_HEAD_FLUSH_SYNC | GFS2_LFC_KILL_SB);
   1728	dput(sdp->sd_root_dir);
   1729	dput(sdp->sd_master_dir);
   1730	sdp->sd_root_dir = NULL;
   1731	sdp->sd_master_dir = NULL;
   1732	shrink_dcache_sb(sb);
   1733	kill_block_super(sb);
   1734}
   1735
   1736struct file_system_type gfs2_fs_type = {
   1737	.name = "gfs2",
   1738	.fs_flags = FS_REQUIRES_DEV,
   1739	.init_fs_context = gfs2_init_fs_context,
   1740	.parameters = gfs2_fs_parameters,
   1741	.kill_sb = gfs2_kill_sb,
   1742	.owner = THIS_MODULE,
   1743};
   1744MODULE_ALIAS_FS("gfs2");
   1745
   1746struct file_system_type gfs2meta_fs_type = {
   1747	.name = "gfs2meta",
   1748	.fs_flags = FS_REQUIRES_DEV,
   1749	.init_fs_context = gfs2_meta_init_fs_context,
   1750	.owner = THIS_MODULE,
   1751};
   1752MODULE_ALIAS_FS("gfs2meta");