[linux-2.6-block.git] / fs / gfs2 / super.c

/*
 * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
 * Copyright (C) 2004-2007 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/crc32.h>
#include <linux/gfs2_ondisk.h>
#include <linux/bio.h>
#include <linux/lm_interface.h>

#include "gfs2.h"
#include "incore.h"
#include "bmap.h"
#include "dir.h"
#include "glock.h"
#include "glops.h"
#include "inode.h"
#include "log.h"
#include "meta_io.h"
#include "quota.h"
#include "recovery.h"
#include "rgrp.h"
#include "super.h"
#include "trans.h"
#include "util.h"

/**
 * gfs2_jindex_free - Clear all the journal index information
 * @sdp: The GFS2 superblock
 *
 */

void gfs2_jindex_free(struct gfs2_sbd *sdp)
{
	struct list_head list, *head;
	struct gfs2_jdesc *jd;
	struct gfs2_journal_extent *jext;

	spin_lock(&sdp->sd_jindex_spin);
	list_add(&list, &sdp->sd_jindex_list);
	list_del_init(&sdp->sd_jindex_list);
	sdp->sd_journals = 0;
	spin_unlock(&sdp->sd_jindex_spin);

	while (!list_empty(&list)) {
		jd = list_entry(list.next, struct gfs2_jdesc, jd_list);
		head = &jd->extent_list;
		while (!list_empty(head)) {
			jext = list_entry(head->next,
					  struct gfs2_journal_extent,
					  extent_list);
			list_del(&jext->extent_list);
			kfree(jext);
		}
		list_del(&jd->jd_list);
		iput(jd->jd_inode);
		kfree(jd);
	}
}

static struct gfs2_jdesc *jdesc_find_i(struct list_head *head, unsigned int jid)
{
	struct gfs2_jdesc *jd;
	int found = 0;

	list_for_each_entry(jd, head, jd_list) {
		if (jd->jd_jid == jid) {
			found = 1;
			break;
		}
	}

	if (!found)
		jd = NULL;

	return jd;
}

struct gfs2_jdesc *gfs2_jdesc_find(struct gfs2_sbd *sdp, unsigned int jid)
{
	struct gfs2_jdesc *jd;

	spin_lock(&sdp->sd_jindex_spin);
	jd = jdesc_find_i(&sdp->sd_jindex_list, jid);
	spin_unlock(&sdp->sd_jindex_spin);

	return jd;
}

int gfs2_jdesc_check(struct gfs2_jdesc *jd)
{
	struct gfs2_inode *ip = GFS2_I(jd->jd_inode);
	struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
	int ar;
	int error;

	if (ip->i_disksize < (8 << 20) || ip->i_disksize > (1 << 30) ||
	    (ip->i_disksize & (sdp->sd_sb.sb_bsize - 1))) {
		gfs2_consist_inode(ip);
		return -EIO;
	}
	jd->jd_blocks = ip->i_disksize >> sdp->sd_sb.sb_bsize_shift;

	error = gfs2_write_alloc_required(ip, 0, ip->i_disksize, &ar);
	if (!error && ar) {
		gfs2_consist_inode(ip);
		error = -EIO;
	}

	return error;
}

/**
 * gfs2_make_fs_rw - Turn a Read-Only FS into a Read-Write one
 * @sdp: the filesystem
 *
 * Returns: errno
 */

int gfs2_make_fs_rw(struct gfs2_sbd *sdp)
{
	struct gfs2_inode *ip = GFS2_I(sdp->sd_jdesc->jd_inode);
	struct gfs2_glock *j_gl = ip->i_gl;
	struct gfs2_holder t_gh;
	struct gfs2_log_header_host head;
	int error;

	error = gfs2_glock_nq_init(sdp->sd_trans_gl, LM_ST_SHARED, 0, &t_gh);
	if (error)
		return error;

	j_gl->gl_ops->go_inval(j_gl, DIO_METADATA);

	error = gfs2_find_jhead(sdp->sd_jdesc, &head);
	if (error)
		goto fail;

	if (!(head.lh_flags & GFS2_LOG_HEAD_UNMOUNT)) {
		gfs2_consist(sdp);
		error = -EIO;
		goto fail;
	}

	/*  Initialize some head of the log stuff  */
	sdp->sd_log_sequence = head.lh_sequence + 1;
	gfs2_log_pointers_init(sdp, head.lh_blkno);

	error = gfs2_quota_init(sdp);
	if (error)
		goto fail;

	set_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags);

	gfs2_glock_dq_uninit(&t_gh);

	return 0;

fail:
	t_gh.gh_flags |= GL_NOCACHE;
	gfs2_glock_dq_uninit(&t_gh);

	return error;
}

static void gfs2_statfs_change_in(struct gfs2_statfs_change_host *sc, const void *buf)
{
	const struct gfs2_statfs_change *str = buf;

	sc->sc_total = be64_to_cpu(str->sc_total);
	sc->sc_free = be64_to_cpu(str->sc_free);
	sc->sc_dinodes = be64_to_cpu(str->sc_dinodes);
}

static void gfs2_statfs_change_out(const struct gfs2_statfs_change_host *sc, void *buf)
{
	struct gfs2_statfs_change *str = buf;

	str->sc_total = cpu_to_be64(sc->sc_total);
	str->sc_free = cpu_to_be64(sc->sc_free);
	str->sc_dinodes = cpu_to_be64(sc->sc_dinodes);
}

int gfs2_statfs_init(struct gfs2_sbd *sdp)
{
	struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode);
	struct gfs2_statfs_change_host *m_sc = &sdp->sd_statfs_master;
	struct gfs2_inode *l_ip = GFS2_I(sdp->sd_sc_inode);
	struct gfs2_statfs_change_host *l_sc = &sdp->sd_statfs_local;
	struct buffer_head *m_bh, *l_bh;
	struct gfs2_holder gh;
	int error;

	error = gfs2_glock_nq_init(m_ip->i_gl, LM_ST_EXCLUSIVE, GL_NOCACHE,
				   &gh);
	if (error)
		return error;

	error = gfs2_meta_inode_buffer(m_ip, &m_bh);
	if (error)
		goto out;

	if (sdp->sd_args.ar_spectator) {
		spin_lock(&sdp->sd_statfs_spin);
		gfs2_statfs_change_in(m_sc, m_bh->b_data +
				      sizeof(struct gfs2_dinode));
		spin_unlock(&sdp->sd_statfs_spin);
	} else {
		error = gfs2_meta_inode_buffer(l_ip, &l_bh);
		if (error)
			goto out_m_bh;

		spin_lock(&sdp->sd_statfs_spin);
		gfs2_statfs_change_in(m_sc, m_bh->b_data +
				      sizeof(struct gfs2_dinode));
		gfs2_statfs_change_in(l_sc, l_bh->b_data +
				      sizeof(struct gfs2_dinode));
		spin_unlock(&sdp->sd_statfs_spin);

		brelse(l_bh);
	}

out_m_bh:
	brelse(m_bh);
out:
	gfs2_glock_dq_uninit(&gh);
	return 0;
}

void gfs2_statfs_change(struct gfs2_sbd *sdp, s64 total, s64 free,
			s64 dinodes)
{
	struct gfs2_inode *l_ip = GFS2_I(sdp->sd_sc_inode);
	struct gfs2_statfs_change_host *l_sc = &sdp->sd_statfs_local;
	struct buffer_head *l_bh;
	int error;

	error = gfs2_meta_inode_buffer(l_ip, &l_bh);
	if (error)
		return;

	gfs2_trans_add_bh(l_ip->i_gl, l_bh, 1);

	spin_lock(&sdp->sd_statfs_spin);
	l_sc->sc_total += total;
	l_sc->sc_free += free;
	l_sc->sc_dinodes += dinodes;
	gfs2_statfs_change_out(l_sc, l_bh->b_data + sizeof(struct gfs2_dinode));
	spin_unlock(&sdp->sd_statfs_spin);

	brelse(l_bh);
}

int gfs2_statfs_sync(struct gfs2_sbd *sdp)
{
	struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode);
	struct gfs2_inode *l_ip = GFS2_I(sdp->sd_sc_inode);
	struct gfs2_statfs_change_host *m_sc = &sdp->sd_statfs_master;
	struct gfs2_statfs_change_host *l_sc = &sdp->sd_statfs_local;
	struct gfs2_holder gh;
	struct buffer_head *m_bh, *l_bh;
	int error;

	error = gfs2_glock_nq_init(m_ip->i_gl, LM_ST_EXCLUSIVE, GL_NOCACHE,
				   &gh);
	if (error)
		return error;

	error = gfs2_meta_inode_buffer(m_ip, &m_bh);
	if (error)
		goto out;

	spin_lock(&sdp->sd_statfs_spin);
	gfs2_statfs_change_in(m_sc, m_bh->b_data +
			      sizeof(struct gfs2_dinode));
	if (!l_sc->sc_total && !l_sc->sc_free && !l_sc->sc_dinodes) {
		spin_unlock(&sdp->sd_statfs_spin);
		goto out_bh;
	}
	spin_unlock(&sdp->sd_statfs_spin);

	error = gfs2_meta_inode_buffer(l_ip, &l_bh);
	if (error)
		goto out_bh;

	error = gfs2_trans_begin(sdp, 2 * RES_DINODE, 0);
	if (error)
		goto out_bh2;

	gfs2_trans_add_bh(l_ip->i_gl, l_bh, 1);

	spin_lock(&sdp->sd_statfs_spin);
	m_sc->sc_total += l_sc->sc_total;
	m_sc->sc_free += l_sc->sc_free;
	m_sc->sc_dinodes += l_sc->sc_dinodes;
	memset(l_sc, 0, sizeof(struct gfs2_statfs_change));
	memset(l_bh->b_data + sizeof(struct gfs2_dinode),
	       0, sizeof(struct gfs2_statfs_change));
	spin_unlock(&sdp->sd_statfs_spin);

	gfs2_trans_add_bh(m_ip->i_gl, m_bh, 1);
	gfs2_statfs_change_out(m_sc, m_bh->b_data + sizeof(struct gfs2_dinode));

	gfs2_trans_end(sdp);

out_bh2:
	brelse(l_bh);
out_bh:
	brelse(m_bh);
out:
	gfs2_glock_dq_uninit(&gh);
	return error;
}

struct lfcc {
	struct list_head list;
	struct gfs2_holder gh;
};

/**
 * gfs2_lock_fs_check_clean - Stop all writes to the FS and check that all
 *                            journals are clean
 * @sdp: the file system
 * @state: the state to put the transaction lock into
 * @t_gh: the hold on the transaction lock
 *
 * Returns: errno
 */

static int gfs2_lock_fs_check_clean(struct gfs2_sbd *sdp,
				    struct gfs2_holder *t_gh)
{
	struct gfs2_inode *ip;
	struct gfs2_holder ji_gh;
	struct gfs2_jdesc *jd;
	struct lfcc *lfcc;
	LIST_HEAD(list);
	struct gfs2_log_header_host lh;
	int error;

	list_for_each_entry(jd, &sdp->sd_jindex_list, jd_list) {
		lfcc = kmalloc(sizeof(struct lfcc), GFP_KERNEL);
		if (!lfcc) {
			error = -ENOMEM;
			goto out;
		}
		ip = GFS2_I(jd->jd_inode);
		error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 0, &lfcc->gh);
		if (error) {
			kfree(lfcc);
			goto out;
		}
		list_add(&lfcc->list, &list);
	}

	error = gfs2_glock_nq_init(sdp->sd_trans_gl, LM_ST_DEFERRED,
				   GL_NOCACHE, t_gh);

	list_for_each_entry(jd, &sdp->sd_jindex_list, jd_list) {
		error = gfs2_jdesc_check(jd);
		if (error)
			break;
		error = gfs2_find_jhead(jd, &lh);
		if (error)
			break;
		if (!(lh.lh_flags & GFS2_LOG_HEAD_UNMOUNT)) {
			error = -EBUSY;
			break;
		}
	}

	if (error)
		gfs2_glock_dq_uninit(t_gh);

out:
	while (!list_empty(&list)) {
		lfcc = list_entry(list.next, struct lfcc, list);
		list_del(&lfcc->list);
		gfs2_glock_dq_uninit(&lfcc->gh);
		kfree(lfcc);
	}
	gfs2_glock_dq_uninit(&ji_gh);
	return error;
}

/**
 * gfs2_freeze_fs - freezes the file system
 * @sdp: the file system
 *
 * This function flushes data and meta data for all machines by
 * aquiring the transaction log exclusively.  All journals are
 * ensured to be in a clean state as well.
 *
 * Returns: errno
 */

int gfs2_freeze_fs(struct gfs2_sbd *sdp)
{
	int error = 0;

	mutex_lock(&sdp->sd_freeze_lock);

	if (!sdp->sd_freeze_count++) {
		error = gfs2_lock_fs_check_clean(sdp, &sdp->sd_freeze_gh);
		if (error)
			sdp->sd_freeze_count--;
	}

	mutex_unlock(&sdp->sd_freeze_lock);

	return error;
}

/**
 * gfs2_unfreeze_fs - unfreezes the file system
 * @sdp: the file system
 *
 * This function allows the file system to proceed by unlocking
 * the exclusively held transaction lock.  Other GFS2 nodes are
 * now free to acquire the lock shared and go on with their lives.
 *
 */

void gfs2_unfreeze_fs(struct gfs2_sbd *sdp)
{
	mutex_lock(&sdp->sd_freeze_lock);

	if (sdp->sd_freeze_count && !--sdp->sd_freeze_count)
		gfs2_glock_dq_uninit(&sdp->sd_freeze_gh);

	mutex_unlock(&sdp->sd_freeze_lock);
}
Commit	Line	Data
b3b94faa DT	1	/*
b3b94faa DT	2	* Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
da6dd40d	3	* Copyright (C) 2004-2007 Red Hat, Inc. All rights reserved.
b3b94faa DT	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
e9fc2aa0	7	* of the GNU General Public License version 2.
b3b94faa DT	8	*/
	9
	10	#include <linux/sched.h>
	11	#include <linux/slab.h>
	12	#include <linux/spinlock.h>
	13	#include <linux/completion.h>
	14	#include <linux/buffer_head.h>
71b86f56	15	#include <linux/crc32.h>
5c676f6d	16	#include <linux/gfs2_ondisk.h>
f45b7ddd	17	#include <linux/bio.h>
7d308590	18	#include <linux/lm_interface.h>
b3b94faa DT	19
b3b94faa DT	20	#include "gfs2.h"
5c676f6d	21	#include "incore.h"
b3b94faa DT	22	#include "bmap.h"
b3b94faa DT	23	#include "dir.h"
b3b94faa DT	24	#include "glock.h"
	25	#include "glops.h"
	26	#include "inode.h"
	27	#include "log.h"
	28	#include "meta_io.h"
	29	#include "quota.h"
	30	#include "recovery.h"
	31	#include "rgrp.h"
	32	#include "super.h"
	33	#include "trans.h"
5c676f6d	34	#include "util.h"
b3b94faa	35
fefc03bf SW	36	/**
	37	* gfs2_jindex_free - Clear all the journal index information
	38	* @sdp: The GFS2 superblock
	39	*
	40	*/
	41
	42	void gfs2_jindex_free(struct gfs2_sbd *sdp)
	43	{
	44	struct list_head list, *head;
	45	struct gfs2_jdesc *jd;
	46	struct gfs2_journal_extent *jext;
	47
	48	spin_lock(&sdp->sd_jindex_spin);
	49	list_add(&list, &sdp->sd_jindex_list);
	50	list_del_init(&sdp->sd_jindex_list);
	51	sdp->sd_journals = 0;
	52	spin_unlock(&sdp->sd_jindex_spin);
	53
	54	while (!list_empty(&list)) {
	55	jd = list_entry(list.next, struct gfs2_jdesc, jd_list);
	56	head = &jd->extent_list;
	57	while (!list_empty(head)) {
	58	jext = list_entry(head->next,
	59	struct gfs2_journal_extent,
	60	extent_list);
	61	list_del(&jext->extent_list);
	62	kfree(jext);
	63	}
	64	list_del(&jd->jd_list);
	65	iput(jd->jd_inode);
	66	kfree(jd);
	67	}
	68	}
	69
b3b94faa DT	70	static struct gfs2_jdesc jdesc_find_i(struct list_head head, unsigned int jid)
	71	{
	72	struct gfs2_jdesc *jd;
	73	int found = 0;
	74
	75	list_for_each_entry(jd, head, jd_list) {
	76	if (jd->jd_jid == jid) {
	77	found = 1;
	78	break;
	79	}
	80	}
	81
	82	if (!found)
	83	jd = NULL;
	84
	85	return jd;
	86	}
	87
	88	struct gfs2_jdesc gfs2_jdesc_find(struct gfs2_sbd sdp, unsigned int jid)
	89	{
	90	struct gfs2_jdesc *jd;
	91
	92	spin_lock(&sdp->sd_jindex_spin);
	93	jd = jdesc_find_i(&sdp->sd_jindex_list, jid);
	94	spin_unlock(&sdp->sd_jindex_spin);
	95
	96	return jd;
	97	}
	98
b3b94faa DT	99	int gfs2_jdesc_check(struct gfs2_jdesc *jd)
b3b94faa DT	100	{
feaa7bba SW	101	struct gfs2_inode *ip = GFS2_I(jd->jd_inode);
feaa7bba SW	102	struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
b3b94faa DT	103	int ar;
	104	int error;
	105
c9e98886 SW	106	if (ip->i_disksize < (8 << 20) \|\| ip->i_disksize > (1 << 30) \|\|
c9e98886 SW	107	(ip->i_disksize & (sdp->sd_sb.sb_bsize - 1))) {
b3b94faa DT	108	gfs2_consist_inode(ip);
	109	return -EIO;
	110	}
c9e98886	111	jd->jd_blocks = ip->i_disksize >> sdp->sd_sb.sb_bsize_shift;
b3b94faa	112
c9e98886	113	error = gfs2_write_alloc_required(ip, 0, ip->i_disksize, &ar);
b3b94faa DT	114	if (!error && ar) {
	115	gfs2_consist_inode(ip);
	116	error = -EIO;
	117	}
	118
	119	return error;
	120	}
	121
b3b94faa DT	122	/**
	123	* gfs2_make_fs_rw - Turn a Read-Only FS into a Read-Write one
	124	* @sdp: the filesystem
	125	*
	126	* Returns: errno
	127	*/
	128
	129	int gfs2_make_fs_rw(struct gfs2_sbd *sdp)
	130	{
feaa7bba	131	struct gfs2_inode *ip = GFS2_I(sdp->sd_jdesc->jd_inode);
5c676f6d	132	struct gfs2_glock *j_gl = ip->i_gl;
b3b94faa	133	struct gfs2_holder t_gh;
55167622	134	struct gfs2_log_header_host head;
b3b94faa DT	135	int error;
b3b94faa DT	136
1c0f4872	137	error = gfs2_glock_nq_init(sdp->sd_trans_gl, LM_ST_SHARED, 0, &t_gh);
b3b94faa DT	138	if (error)
	139	return error;
	140
1a14d3a6	141	j_gl->gl_ops->go_inval(j_gl, DIO_METADATA);
b3b94faa DT	142
	143	error = gfs2_find_jhead(sdp->sd_jdesc, &head);
	144	if (error)
	145	goto fail;
	146
	147	if (!(head.lh_flags & GFS2_LOG_HEAD_UNMOUNT)) {
	148	gfs2_consist(sdp);
	149	error = -EIO;
	150	goto fail;
	151	}
	152
	153	/* Initialize some head of the log stuff */
	154	sdp->sd_log_sequence = head.lh_sequence + 1;
	155	gfs2_log_pointers_init(sdp, head.lh_blkno);
	156
b3b94faa DT	157	error = gfs2_quota_init(sdp);
b3b94faa DT	158	if (error)
a91ea69f	159	goto fail;
b3b94faa DT	160
	161	set_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags);
	162
	163	gfs2_glock_dq_uninit(&t_gh);
	164
	165	return 0;
	166
a91ea69f	167	fail:
b3b94faa DT	168	t_gh.gh_flags \|= GL_NOCACHE;
	169	gfs2_glock_dq_uninit(&t_gh);
	170
	171	return error;
	172	}
	173
bb8d8a6f SW	174	static void gfs2_statfs_change_in(struct gfs2_statfs_change_host sc, const void buf)
	175	{
	176	const struct gfs2_statfs_change *str = buf;
	177
	178	sc->sc_total = be64_to_cpu(str->sc_total);
	179	sc->sc_free = be64_to_cpu(str->sc_free);
	180	sc->sc_dinodes = be64_to_cpu(str->sc_dinodes);
	181	}
	182
	183	static void gfs2_statfs_change_out(const struct gfs2_statfs_change_host sc, void buf)
	184	{
	185	struct gfs2_statfs_change *str = buf;
	186
	187	str->sc_total = cpu_to_be64(sc->sc_total);
	188	str->sc_free = cpu_to_be64(sc->sc_free);
	189	str->sc_dinodes = cpu_to_be64(sc->sc_dinodes);
	190	}
	191
b3b94faa DT	192	int gfs2_statfs_init(struct gfs2_sbd *sdp)
b3b94faa DT	193	{
feaa7bba	194	struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode);
bd209cc0	195	struct gfs2_statfs_change_host *m_sc = &sdp->sd_statfs_master;
feaa7bba	196	struct gfs2_inode *l_ip = GFS2_I(sdp->sd_sc_inode);
bd209cc0	197	struct gfs2_statfs_change_host *l_sc = &sdp->sd_statfs_local;
b3b94faa DT	198	struct buffer_head m_bh, l_bh;
	199	struct gfs2_holder gh;
	200	int error;
	201
	202	error = gfs2_glock_nq_init(m_ip->i_gl, LM_ST_EXCLUSIVE, GL_NOCACHE,
	203	&gh);
	204	if (error)
	205	return error;
	206
	207	error = gfs2_meta_inode_buffer(m_ip, &m_bh);
	208	if (error)
	209	goto out;
	210
	211	if (sdp->sd_args.ar_spectator) {
	212	spin_lock(&sdp->sd_statfs_spin);
	213	gfs2_statfs_change_in(m_sc, m_bh->b_data +
	214	sizeof(struct gfs2_dinode));
	215	spin_unlock(&sdp->sd_statfs_spin);
	216	} else {
	217	error = gfs2_meta_inode_buffer(l_ip, &l_bh);
	218	if (error)
	219	goto out_m_bh;
	220
	221	spin_lock(&sdp->sd_statfs_spin);
	222	gfs2_statfs_change_in(m_sc, m_bh->b_data +
	223	sizeof(struct gfs2_dinode));
	224	gfs2_statfs_change_in(l_sc, l_bh->b_data +
	225	sizeof(struct gfs2_dinode));
	226	spin_unlock(&sdp->sd_statfs_spin);
	227
	228	brelse(l_bh);
	229	}
	230
a91ea69f	231	out_m_bh:
b3b94faa	232	brelse(m_bh);
a91ea69f	233	out:
b3b94faa	234	gfs2_glock_dq_uninit(&gh);
b3b94faa DT	235	return 0;
	236	}
	237
cd915493 SW	238	void gfs2_statfs_change(struct gfs2_sbd *sdp, s64 total, s64 free,
cd915493 SW	239	s64 dinodes)
b3b94faa	240	{
feaa7bba	241	struct gfs2_inode *l_ip = GFS2_I(sdp->sd_sc_inode);
bd209cc0	242	struct gfs2_statfs_change_host *l_sc = &sdp->sd_statfs_local;
b3b94faa DT	243	struct buffer_head *l_bh;
	244	int error;
	245
	246	error = gfs2_meta_inode_buffer(l_ip, &l_bh);
	247	if (error)
	248	return;
	249
d4e9c4c3	250	gfs2_trans_add_bh(l_ip->i_gl, l_bh, 1);
b3b94faa DT	251
	252	spin_lock(&sdp->sd_statfs_spin);
	253	l_sc->sc_total += total;
	254	l_sc->sc_free += free;
	255	l_sc->sc_dinodes += dinodes;
907b9bce	256	gfs2_statfs_change_out(l_sc, l_bh->b_data + sizeof(struct gfs2_dinode));
b3b94faa DT	257	spin_unlock(&sdp->sd_statfs_spin);
	258
	259	brelse(l_bh);
	260	}
	261
	262	int gfs2_statfs_sync(struct gfs2_sbd *sdp)
	263	{
feaa7bba SW	264	struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode);
feaa7bba SW	265	struct gfs2_inode *l_ip = GFS2_I(sdp->sd_sc_inode);
bd209cc0 AV	266	struct gfs2_statfs_change_host *m_sc = &sdp->sd_statfs_master;
bd209cc0 AV	267	struct gfs2_statfs_change_host *l_sc = &sdp->sd_statfs_local;
b3b94faa DT	268	struct gfs2_holder gh;
	269	struct buffer_head m_bh, l_bh;
	270	int error;
	271
	272	error = gfs2_glock_nq_init(m_ip->i_gl, LM_ST_EXCLUSIVE, GL_NOCACHE,
	273	&gh);
	274	if (error)
	275	return error;
	276
	277	error = gfs2_meta_inode_buffer(m_ip, &m_bh);
	278	if (error)
	279	goto out;
	280
	281	spin_lock(&sdp->sd_statfs_spin);
	282	gfs2_statfs_change_in(m_sc, m_bh->b_data +
907b9bce	283	sizeof(struct gfs2_dinode));
b3b94faa DT	284	if (!l_sc->sc_total && !l_sc->sc_free && !l_sc->sc_dinodes) {
	285	spin_unlock(&sdp->sd_statfs_spin);
	286	goto out_bh;
	287	}
	288	spin_unlock(&sdp->sd_statfs_spin);
	289
	290	error = gfs2_meta_inode_buffer(l_ip, &l_bh);
	291	if (error)
	292	goto out_bh;
	293
	294	error = gfs2_trans_begin(sdp, 2 * RES_DINODE, 0);
	295	if (error)
	296	goto out_bh2;
	297
d4e9c4c3	298	gfs2_trans_add_bh(l_ip->i_gl, l_bh, 1);
b3b94faa DT	299
	300	spin_lock(&sdp->sd_statfs_spin);
	301	m_sc->sc_total += l_sc->sc_total;
	302	m_sc->sc_free += l_sc->sc_free;
	303	m_sc->sc_dinodes += l_sc->sc_dinodes;
	304	memset(l_sc, 0, sizeof(struct gfs2_statfs_change));
	305	memset(l_bh->b_data + sizeof(struct gfs2_dinode),
	306	0, sizeof(struct gfs2_statfs_change));
	307	spin_unlock(&sdp->sd_statfs_spin);
	308
d4e9c4c3	309	gfs2_trans_add_bh(m_ip->i_gl, m_bh, 1);
b3b94faa DT	310	gfs2_statfs_change_out(m_sc, m_bh->b_data + sizeof(struct gfs2_dinode));
	311
	312	gfs2_trans_end(sdp);
	313
a91ea69f	314	out_bh2:
b3b94faa	315	brelse(l_bh);
a91ea69f	316	out_bh:
b3b94faa	317	brelse(m_bh);
a91ea69f	318	out:
b3b94faa	319	gfs2_glock_dq_uninit(&gh);
b3b94faa DT	320	return error;
	321	}
	322
b3b94faa DT	323	struct lfcc {
	324	struct list_head list;
	325	struct gfs2_holder gh;
	326	};
	327
	328	/**
	329	* gfs2_lock_fs_check_clean - Stop all writes to the FS and check that all
	330	* journals are clean
	331	* @sdp: the file system
	332	* @state: the state to put the transaction lock into
	333	* @t_gh: the hold on the transaction lock
	334	*
	335	* Returns: errno
	336	*/
	337
08bc2dbc AB	338	static int gfs2_lock_fs_check_clean(struct gfs2_sbd *sdp,
08bc2dbc AB	339	struct gfs2_holder *t_gh)
b3b94faa	340	{
5c676f6d	341	struct gfs2_inode *ip;
b3b94faa DT	342	struct gfs2_holder ji_gh;
	343	struct gfs2_jdesc *jd;
	344	struct lfcc *lfcc;
	345	LIST_HEAD(list);
55167622	346	struct gfs2_log_header_host lh;
b3b94faa DT	347	int error;
b3b94faa DT	348
b3b94faa DT	349	list_for_each_entry(jd, &sdp->sd_jindex_list, jd_list) {
	350	lfcc = kmalloc(sizeof(struct lfcc), GFP_KERNEL);
	351	if (!lfcc) {
	352	error = -ENOMEM;
	353	goto out;
	354	}
feaa7bba SW	355	ip = GFS2_I(jd->jd_inode);
feaa7bba SW	356	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 0, &lfcc->gh);
b3b94faa DT	357	if (error) {
	358	kfree(lfcc);
	359	goto out;
	360	}
	361	list_add(&lfcc->list, &list);
	362	}
	363
	364	error = gfs2_glock_nq_init(sdp->sd_trans_gl, LM_ST_DEFERRED,
6802e340	365	GL_NOCACHE, t_gh);
b3b94faa DT	366
	367	list_for_each_entry(jd, &sdp->sd_jindex_list, jd_list) {
	368	error = gfs2_jdesc_check(jd);
	369	if (error)
	370	break;
	371	error = gfs2_find_jhead(jd, &lh);
	372	if (error)
	373	break;
	374	if (!(lh.lh_flags & GFS2_LOG_HEAD_UNMOUNT)) {
	375	error = -EBUSY;
	376	break;
	377	}
	378	}
	379
	380	if (error)
	381	gfs2_glock_dq_uninit(t_gh);
	382
a91ea69f	383	out:
b3b94faa DT	384	while (!list_empty(&list)) {
	385	lfcc = list_entry(list.next, struct lfcc, list);
	386	list_del(&lfcc->list);
	387	gfs2_glock_dq_uninit(&lfcc->gh);
	388	kfree(lfcc);
	389	}
	390	gfs2_glock_dq_uninit(&ji_gh);
b3b94faa DT	391	return error;
	392	}
	393
	394	/**
	395	* gfs2_freeze_fs - freezes the file system
	396	* @sdp: the file system
	397	*
	398	* This function flushes data and meta data for all machines by
	399	* aquiring the transaction log exclusively. All journals are
	400	* ensured to be in a clean state as well.
	401	*
	402	* Returns: errno
	403	*/
	404
	405	int gfs2_freeze_fs(struct gfs2_sbd *sdp)
	406	{
	407	int error = 0;
	408
f55ab26a	409	mutex_lock(&sdp->sd_freeze_lock);
b3b94faa DT	410
	411	if (!sdp->sd_freeze_count++) {
	412	error = gfs2_lock_fs_check_clean(sdp, &sdp->sd_freeze_gh);
	413	if (error)
	414	sdp->sd_freeze_count--;
	415	}
	416
f55ab26a	417	mutex_unlock(&sdp->sd_freeze_lock);
b3b94faa DT	418
	419	return error;
	420	}
	421
	422	/**
	423	* gfs2_unfreeze_fs - unfreezes the file system
	424	* @sdp: the file system
	425	*
	426	* This function allows the file system to proceed by unlocking
	427	* the exclusively held transaction lock. Other GFS2 nodes are
	428	* now free to acquire the lock shared and go on with their lives.
	429	*
	430	*/
	431
	432	void gfs2_unfreeze_fs(struct gfs2_sbd *sdp)
	433	{
f55ab26a	434	mutex_lock(&sdp->sd_freeze_lock);
b3b94faa DT	435
	436	if (sdp->sd_freeze_count && !--sdp->sd_freeze_count)
	437	gfs2_glock_dq_uninit(&sdp->sd_freeze_gh);
	438
f55ab26a	439	mutex_unlock(&sdp->sd_freeze_lock);
b3b94faa DT	440	}
b3b94faa DT	441