GFS2: Merge mount.c and ops_super.c into super.c

obj-$(CONFIG_GFS2_FS) += gfs2.o

gfs2-y := acl.o bmap.o dir.o eaops.o eattr.o glock.o \

	glops.o inode.o log.o lops.o main.o meta_io.o \

	mount.o aops.o dentry.o export.o file.o \

	ops_fstype.o ops_inode.o ops_super.o quota.o \

	aops.o dentry.o export.o file.o \

	ops_fstype.o ops_inode.o quota.o \

	recovery.o rgrp.o super.o sys.o trans.o util.o

gfs2-$(CONFIG_GFS2_FS_LOCKING_DLM) += lock_dlm.o

/*

 * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.

 * Copyright (C) 2004-2006 Red Hat, Inc.  All rights reserved.

 *

 * This copyrighted material is made available to anyone wishing to use,

 * modify, copy, or redistribute it subject to the terms and conditions

 * of the GNU General Public License version 2.

 */

#include <linux/slab.h>

#include <linux/spinlock.h>

#include <linux/completion.h>

#include <linux/buffer_head.h>

#include <linux/gfs2_ondisk.h>

#include <linux/parser.h>

#include "gfs2.h"

#include "incore.h"

#include "super.h"

#include "sys.h"

#include "util.h"

enum {

	Opt_lockproto,

	Opt_locktable,

	Opt_hostdata,

	Opt_spectator,

	Opt_ignore_local_fs,

	Opt_localflocks,

	Opt_localcaching,

	Opt_debug,

	Opt_nodebug,

	Opt_upgrade,

	Opt_acl,

	Opt_noacl,

	Opt_quota_off,

	Opt_quota_account,

	Opt_quota_on,

	Opt_quota,

	Opt_noquota,

	Opt_suiddir,

	Opt_nosuiddir,

	Opt_data_writeback,

	Opt_data_ordered,

	Opt_meta,

	Opt_discard,

	Opt_nodiscard,

	Opt_commit,

	Opt_err,

};

static const match_table_t tokens = {

	{Opt_lockproto, "lockproto=%s"},

	{Opt_locktable, "locktable=%s"},

	{Opt_hostdata, "hostdata=%s"},

	{Opt_spectator, "spectator"},

	{Opt_ignore_local_fs, "ignore_local_fs"},

	{Opt_localflocks, "localflocks"},

	{Opt_localcaching, "localcaching"},

	{Opt_debug, "debug"},

	{Opt_nodebug, "nodebug"},

	{Opt_upgrade, "upgrade"},

	{Opt_acl, "acl"},

	{Opt_noacl, "noacl"},

	{Opt_quota_off, "quota=off"},

	{Opt_quota_account, "quota=account"},

	{Opt_quota_on, "quota=on"},

	{Opt_quota, "quota"},

	{Opt_noquota, "noquota"},

	{Opt_suiddir, "suiddir"},

	{Opt_nosuiddir, "nosuiddir"},

	{Opt_data_writeback, "data=writeback"},

	{Opt_data_ordered, "data=ordered"},

	{Opt_meta, "meta"},

	{Opt_discard, "discard"},

	{Opt_nodiscard, "nodiscard"},

	{Opt_commit, "commit=%d"},

	{Opt_err, NULL}

};

/**

 * gfs2_mount_args - Parse mount options

 * @sdp:

 * @data:

 *

 * Return: errno

 */

int gfs2_mount_args(struct gfs2_sbd *sdp, struct gfs2_args *args, char *options)

{

	char *o;

	int token;

	substring_t tmp[MAX_OPT_ARGS];

	int rv;

	/* Split the options into tokens with the "," character and

	   process them */

	while (1) {

		o = strsep(&options, ",");

		if (o == NULL)

			break;

		if (*o == '\0')

			continue;

		token = match_token(o, tokens, tmp);

		switch (token) {

		case Opt_lockproto:

			match_strlcpy(args->ar_lockproto, &tmp[0],

				      GFS2_LOCKNAME_LEN);

			break;

		case Opt_locktable:

			match_strlcpy(args->ar_locktable, &tmp[0],

				      GFS2_LOCKNAME_LEN);

			break;

		case Opt_hostdata:

			match_strlcpy(args->ar_hostdata, &tmp[0],

				      GFS2_LOCKNAME_LEN);

			break;

		case Opt_spectator:

			args->ar_spectator = 1;

			break;

		case Opt_ignore_local_fs:

			args->ar_ignore_local_fs = 1;

			break;

		case Opt_localflocks:

			args->ar_localflocks = 1;

			break;

		case Opt_localcaching:

			args->ar_localcaching = 1;

			break;

		case Opt_debug:

			args->ar_debug = 1;

			break;

		case Opt_nodebug:

			args->ar_debug = 0;

			break;

		case Opt_upgrade:

			args->ar_upgrade = 1;

			break;

		case Opt_acl:

			args->ar_posix_acl = 1;

			break;

		case Opt_noacl:

			args->ar_posix_acl = 0;

			break;

		case Opt_quota_off:

		case Opt_noquota:

			args->ar_quota = GFS2_QUOTA_OFF;

			break;

		case Opt_quota_account:

			args->ar_quota = GFS2_QUOTA_ACCOUNT;

			break;

		case Opt_quota_on:

		case Opt_quota:

			args->ar_quota = GFS2_QUOTA_ON;

			break;

		case Opt_suiddir:

			args->ar_suiddir = 1;

			break;

		case Opt_nosuiddir:

			args->ar_suiddir = 0;

			break;

		case Opt_data_writeback:

			args->ar_data = GFS2_DATA_WRITEBACK;

			break;

		case Opt_data_ordered:

			args->ar_data = GFS2_DATA_ORDERED;

			break;

		case Opt_meta:

			args->ar_meta = 1;

			break;

		case Opt_discard:

			args->ar_discard = 1;

			break;

		case Opt_nodiscard:

			args->ar_discard = 0;

			break;

		case Opt_commit:

			rv = match_int(&tmp[0], &args->ar_commit);

			if (rv || args->ar_commit <= 0) {

				fs_info(sdp, "commit mount option requires a positive numeric argument\n");

				return rv ? rv : -EINVAL;

			}

			break;

		case Opt_err:

		default:

			fs_info(sdp, "invalid mount option: %s\n", o);

			return -EINVAL;

		}

	}

	return 0;

}

/*

 * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.

 * Copyright (C) 2004-2008 Red Hat, Inc.  All rights reserved.

 *

 * This copyrighted material is made available to anyone wishing to use,

 * modify, copy, or redistribute it subject to the terms and conditions

 * of the GNU General Public License version 2.

 */

#include <linux/sched.h>

#include <linux/slab.h>

#include <linux/spinlock.h>

#include <linux/completion.h>

#include <linux/buffer_head.h>

#include <linux/statfs.h>

#include <linux/seq_file.h>

#include <linux/mount.h>

#include <linux/kthread.h>

#include <linux/delay.h>

#include <linux/gfs2_ondisk.h>

#include <linux/crc32.h>

#include <linux/time.h>

#include "gfs2.h"

#include "incore.h"

#include "glock.h"

#include "inode.h"

#include "log.h"

#include "quota.h"

#include "recovery.h"

#include "rgrp.h"

#include "super.h"

#include "sys.h"

#include "util.h"

#include "trans.h"

#include "dir.h"

#include "eattr.h"

#include "bmap.h"

#include "meta_io.h"

#define args_neq(a1, a2, x) ((a1)->ar_##x != (a2)->ar_##x)

/**

 * gfs2_write_inode - Make sure the inode is stable on the disk

 * @inode: The inode

 * @sync: synchronous write flag

 *

 * Returns: errno

 */

static int gfs2_write_inode(struct inode *inode, int sync)

{

	struct gfs2_inode *ip = GFS2_I(inode);

	struct gfs2_sbd *sdp = GFS2_SB(inode);

	struct gfs2_holder gh;

	struct buffer_head *bh;

	struct timespec atime;

	struct gfs2_dinode *di;

	int ret = 0;

	/* Check this is a "normal" inode, etc */

	if (!test_bit(GIF_USER, &ip->i_flags) ||

	    (current->flags & PF_MEMALLOC))

		return 0;

	ret = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);

	if (ret)

		goto do_flush;

	ret = gfs2_trans_begin(sdp, RES_DINODE, 0);

	if (ret)

		goto do_unlock;

	ret = gfs2_meta_inode_buffer(ip, &bh);

	if (ret == 0) {

		di = (struct gfs2_dinode *)bh->b_data;

		atime.tv_sec = be64_to_cpu(di->di_atime);

		atime.tv_nsec = be32_to_cpu(di->di_atime_nsec);

		if (timespec_compare(&inode->i_atime, &atime) > 0) {

			gfs2_trans_add_bh(ip->i_gl, bh, 1);

			gfs2_dinode_out(ip, bh->b_data);

		}

		brelse(bh);

	}

	gfs2_trans_end(sdp);

do_unlock:

	gfs2_glock_dq_uninit(&gh);

do_flush:

	if (sync != 0)

		gfs2_log_flush(GFS2_SB(inode), ip->i_gl);

	return ret;

}

/**

 * gfs2_make_fs_ro - Turn a Read-Write FS into a Read-Only one

 * @sdp: the filesystem

 *

 * Returns: errno

 */

static int gfs2_make_fs_ro(struct gfs2_sbd *sdp)

{

	struct gfs2_holder t_gh;

	int error;

	gfs2_quota_sync(sdp);

	gfs2_statfs_sync(sdp);

	error = gfs2_glock_nq_init(sdp->sd_trans_gl, LM_ST_SHARED, GL_NOCACHE,

				   &t_gh);

	if (error && !test_bit(SDF_SHUTDOWN, &sdp->sd_flags))

		return error;

	gfs2_meta_syncfs(sdp);

	gfs2_log_shutdown(sdp);

	clear_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags);

	if (t_gh.gh_gl)

		gfs2_glock_dq_uninit(&t_gh);

	gfs2_quota_cleanup(sdp);

	return error;

}

static int gfs2_umount_recovery_wait(void *word)

{

	schedule();

	return 0;

}

/**

 * gfs2_put_super - Unmount the filesystem

 * @sb: The VFS superblock

 *

 */

static void gfs2_put_super(struct super_block *sb)

{

	struct gfs2_sbd *sdp = sb->s_fs_info;

	int error;

	struct gfs2_jdesc *jd;

	/*  Unfreeze the filesystem, if we need to  */

	mutex_lock(&sdp->sd_freeze_lock);

	if (sdp->sd_freeze_count)

		gfs2_glock_dq_uninit(&sdp->sd_freeze_gh);

	mutex_unlock(&sdp->sd_freeze_lock);

	/* No more recovery requests */

	set_bit(SDF_NORECOVERY, &sdp->sd_flags);

	smp_mb();

	/* Wait on outstanding recovery */

restart:

	spin_lock(&sdp->sd_jindex_spin);

	list_for_each_entry(jd, &sdp->sd_jindex_list, jd_list) {

		if (!test_bit(JDF_RECOVERY, &jd->jd_flags))

			continue;

		spin_unlock(&sdp->sd_jindex_spin);

		wait_on_bit(&jd->jd_flags, JDF_RECOVERY,

			    gfs2_umount_recovery_wait, TASK_UNINTERRUPTIBLE);

		goto restart;

	}

	spin_unlock(&sdp->sd_jindex_spin);

	kthread_stop(sdp->sd_quotad_process);

	kthread_stop(sdp->sd_logd_process);

	if (!(sb->s_flags & MS_RDONLY)) {

		error = gfs2_make_fs_ro(sdp);

		if (error)

			gfs2_io_error(sdp);

	}

	/*  At this point, we're through modifying the disk  */

	/*  Release stuff  */

	iput(sdp->sd_jindex);

	iput(sdp->sd_inum_inode);

	iput(sdp->sd_statfs_inode);

	iput(sdp->sd_rindex);

	iput(sdp->sd_quota_inode);

	gfs2_glock_put(sdp->sd_rename_gl);

	gfs2_glock_put(sdp->sd_trans_gl);

	if (!sdp->sd_args.ar_spectator) {

		gfs2_glock_dq_uninit(&sdp->sd_journal_gh);

		gfs2_glock_dq_uninit(&sdp->sd_jinode_gh);

		gfs2_glock_dq_uninit(&sdp->sd_ir_gh);

		gfs2_glock_dq_uninit(&sdp->sd_sc_gh);

		gfs2_glock_dq_uninit(&sdp->sd_qc_gh);

		iput(sdp->sd_ir_inode);

		iput(sdp->sd_sc_inode);

		iput(sdp->sd_qc_inode);

	}

	gfs2_glock_dq_uninit(&sdp->sd_live_gh);

	gfs2_clear_rgrpd(sdp);

	gfs2_jindex_free(sdp);

	/*  Take apart glock structures and buffer lists  */

	gfs2_gl_hash_clear(sdp);

	/*  Unmount the locking protocol  */

	gfs2_lm_unmount(sdp);

	/*  At this point, we're through participating in the lockspace  */

	gfs2_sys_fs_del(sdp);

}

/**

 * gfs2_write_super

 * @sb: the superblock

 *

 */

static void gfs2_write_super(struct super_block *sb)

{

	sb->s_dirt = 0;

}

/**

 * gfs2_sync_fs - sync the filesystem

 * @sb: the superblock

 *

 * Flushes the log to disk.

 */

static int gfs2_sync_fs(struct super_block *sb, int wait)

{

	sb->s_dirt = 0;

	if (wait && sb->s_fs_info)

		gfs2_log_flush(sb->s_fs_info, NULL);

	return 0;

}

/**

 * gfs2_freeze - prevent further writes to the filesystem

 * @sb: the VFS structure for the filesystem

 *

 */

static int gfs2_freeze(struct super_block *sb)

{

	struct gfs2_sbd *sdp = sb->s_fs_info;

	int error;

	if (test_bit(SDF_SHUTDOWN, &sdp->sd_flags))

		return -EINVAL;

	for (;;) {

		error = gfs2_freeze_fs(sdp);

		if (!error)

			break;

		switch (error) {

		case -EBUSY:

			fs_err(sdp, "waiting for recovery before freeze\n");

			break;

		default:

			fs_err(sdp, "error freezing FS: %d\n", error);

			break;

		}

		fs_err(sdp, "retrying...\n");

		msleep(1000);

	}

	return 0;

}

/**

 * gfs2_unfreeze - reallow writes to the filesystem

 * @sb: the VFS structure for the filesystem

 *

 */

static int gfs2_unfreeze(struct super_block *sb)

{

	gfs2_unfreeze_fs(sb->s_fs_info);

	return 0;

}

/**

 * statfs_fill - fill in the sg for a given RG

 * @rgd: the RG

 * @sc: the sc structure

 *

 * Returns: 0 on success, -ESTALE if the LVB is invalid

 */

static int statfs_slow_fill(struct gfs2_rgrpd *rgd,

			    struct gfs2_statfs_change_host *sc)

{

	gfs2_rgrp_verify(rgd);

	sc->sc_total += rgd->rd_data;

	sc->sc_free += rgd->rd_free;

	sc->sc_dinodes += rgd->rd_dinodes;

	return 0;

}

/**

 * gfs2_statfs_slow - Stat a filesystem using asynchronous locking

 * @sdp: the filesystem

 * @sc: the sc info that will be returned

 *

 * Any error (other than a signal) will cause this routine to fall back

 * to the synchronous version.

 *

 * FIXME: This really shouldn't busy wait like this.

 *

 * Returns: errno

 */

static int gfs2_statfs_slow(struct gfs2_sbd *sdp, struct gfs2_statfs_change_host *sc)

{

	struct gfs2_holder ri_gh;

	struct gfs2_rgrpd *rgd_next;

	struct gfs2_holder *gha, *gh;

	unsigned int slots = 64;

	unsigned int x;

	int done;

	int error = 0, err;

	memset(sc, 0, sizeof(struct gfs2_statfs_change_host));

	gha = kcalloc(slots, sizeof(struct gfs2_holder), GFP_KERNEL);

	if (!gha)

		return -ENOMEM;

	error = gfs2_rindex_hold(sdp, &ri_gh);

	if (error)

		goto out;

	rgd_next = gfs2_rgrpd_get_first(sdp);

	for (;;) {

		done = 1;

		for (x = 0; x < slots; x++) {

			gh = gha + x;

			if (gh->gh_gl && gfs2_glock_poll(gh)) {

				err = gfs2_glock_wait(gh);

				if (err) {

					gfs2_holder_uninit(gh);

					error = err;

				} else {

					if (!error)

						error = statfs_slow_fill(

							gh->gh_gl->gl_object, sc);

					gfs2_glock_dq_uninit(gh);

				}

			}

			if (gh->gh_gl)

				done = 0;

			else if (rgd_next && !error) {

				error = gfs2_glock_nq_init(rgd_next->rd_gl,

							   LM_ST_SHARED,

							   GL_ASYNC,

							   gh);

				rgd_next = gfs2_rgrpd_get_next(rgd_next);

				done = 0;

			}

			if (signal_pending(current))

				error = -ERESTARTSYS;

		}

		if (done)

			break;

		yield();

	}

	gfs2_glock_dq_uninit(&ri_gh);

out:

	kfree(gha);

	return error;

}

/**

 * gfs2_statfs_i - Do a statfs

 * @sdp: the filesystem

 * @sg: the sg structure

 *

 * Returns: errno

 */

static int gfs2_statfs_i(struct gfs2_sbd *sdp, struct gfs2_statfs_change_host *sc)

{

	struct gfs2_statfs_change_host *m_sc = &sdp->sd_statfs_master;

	struct gfs2_statfs_change_host *l_sc = &sdp->sd_statfs_local;

	spin_lock(&sdp->sd_statfs_spin);

	*sc = *m_sc;

	sc->sc_total += l_sc->sc_total;

	sc->sc_free += l_sc->sc_free;

	sc->sc_dinodes += l_sc->sc_dinodes;

	spin_unlock(&sdp->sd_statfs_spin);

	if (sc->sc_free < 0)

		sc->sc_free = 0;

	if (sc->sc_free > sc->sc_total)

		sc->sc_free = sc->sc_total;

	if (sc->sc_dinodes < 0)

		sc->sc_dinodes = 0;

	return 0;

}

/**

 * gfs2_statfs - Gather and return stats about the filesystem

 * @sb: The superblock

 * @statfsbuf: The buffer

 *

 * Returns: 0 on success or error code

 */

static int gfs2_statfs(struct dentry *dentry, struct kstatfs *buf)

{

	struct super_block *sb = dentry->d_inode->i_sb;

	struct gfs2_sbd *sdp = sb->s_fs_info;

	struct gfs2_statfs_change_host sc;

	int error;

	if (gfs2_tune_get(sdp, gt_statfs_slow))

		error = gfs2_statfs_slow(sdp, &sc);

	else

		error = gfs2_statfs_i(sdp, &sc);

	if (error)

		return error;

	buf->f_type = GFS2_MAGIC;

	buf->f_bsize = sdp->sd_sb.sb_bsize;

	buf->f_blocks = sc.sc_total;

	buf->f_bfree = sc.sc_free;

	buf->f_bavail = sc.sc_free;

	buf->f_files = sc.sc_dinodes + sc.sc_free;

	buf->f_ffree = sc.sc_free;

	buf->f_namelen = GFS2_FNAMESIZE;

	return 0;

}

/**

 * gfs2_remount_fs - called when the FS is remounted

 * @sb:  the filesystem

 * @flags:  the remount flags

 * @data:  extra data passed in (not used right now)

 *

 * Returns: errno

 */

static int gfs2_remount_fs(struct super_block *sb, int *flags, char *data)

{

	struct gfs2_sbd *sdp = sb->s_fs_info;

	struct gfs2_args args = sdp->sd_args; /* Default to current settings */

	struct gfs2_tune *gt = &sdp->sd_tune;

	int error;

	spin_lock(&gt->gt_spin);

	args.ar_commit = gt->gt_log_flush_secs;

	spin_unlock(&gt->gt_spin);

	error = gfs2_mount_args(sdp, &args, data);

	if (error)

		return error;

	/* Not allowed to change locking details */

	if (strcmp(args.ar_lockproto, sdp->sd_args.ar_lockproto) ||

	    strcmp(args.ar_locktable, sdp->sd_args.ar_locktable) ||

	    strcmp(args.ar_hostdata, sdp->sd_args.ar_hostdata))

		return -EINVAL;

	/* Some flags must not be changed */

	if (args_neq(&args, &sdp->sd_args, spectator) ||

	    args_neq(&args, &sdp->sd_args, ignore_local_fs) ||

	    args_neq(&args, &sdp->sd_args, localflocks) ||

	    args_neq(&args, &sdp->sd_args, localcaching) ||

	    args_neq(&args, &sdp->sd_args, meta))

		return -EINVAL;

	if (sdp->sd_args.ar_spectator)

		*flags |= MS_RDONLY;

	if ((sb->s_flags ^ *flags) & MS_RDONLY) {

		if (*flags & MS_RDONLY)

			error = gfs2_make_fs_ro(sdp);

		else

			error = gfs2_make_fs_rw(sdp);

		if (error)

			return error;

	}

	sdp->sd_args = args;

	if (sdp->sd_args.ar_posix_acl)

		sb->s_flags |= MS_POSIXACL;

	else

		sb->s_flags &= ~MS_POSIXACL;

	spin_lock(&gt->gt_spin);

	gt->gt_log_flush_secs = args.ar_commit;

	spin_unlock(&gt->gt_spin);

	return 0;

}

/**

 * gfs2_drop_inode - Drop an inode (test for remote unlink)

 * @inode: The inode to drop

 *

 * If we've received a callback on an iopen lock then its because a

 * remote node tried to deallocate the inode but failed due to this node

 * still having the inode open. Here we mark the link count zero

 * since we know that it must have reached zero if the GLF_DEMOTE flag

 * is set on the iopen glock. If we didn't do a disk read since the

 * remote node removed the final link then we might otherwise miss

 * this event. This check ensures that this node will deallocate the

 * inode's blocks, or alternatively pass the baton on to another

 * node for later deallocation.

 */

static void gfs2_drop_inode(struct inode *inode)

{

	struct gfs2_inode *ip = GFS2_I(inode);

	if (test_bit(GIF_USER, &ip->i_flags) && inode->i_nlink) {

		struct gfs2_glock *gl = ip->i_iopen_gh.gh_gl;

		if (gl && test_bit(GLF_DEMOTE, &gl->gl_flags))

			clear_nlink(inode);