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