[GitHub/mt8127/android_kernel_alcatel_ttab.git] / fs / xfs / quota / xfs_qm_bhv.c

/*
 * Copyright (c) 2000-2004 Silicon Graphics, Inc.  All Rights Reserved.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of version 2 of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it would be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 *
 * Further, this software is distributed without any warranty that it is
 * free of the rightful claim of any third person regarding infringement
 * or the like.	 Any license provided herein, whether implied or
 * otherwise, applies only to this software file.  Patent licenses, if
 * any, provided herein do not apply to combinations of this program with
 * other software, or any other product whatsoever.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write the Free Software Foundation, Inc., 59
 * Temple Place - Suite 330, Boston MA 02111-1307, USA.
 *
 * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
 * Mountain View, CA  94043, or:
 *
 * http://www.sgi.com
 *
 * For further information regarding this notice, see:
 *
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 */

#include "xfs.h"
#include "xfs_fs.h"
#include "xfs_inum.h"
#include "xfs_log.h"
#include "xfs_clnt.h"
#include "xfs_trans.h"
#include "xfs_sb.h"
#include "xfs_dir.h"
#include "xfs_dir2.h"
#include "xfs_alloc.h"
#include "xfs_dmapi.h"
#include "xfs_quota.h"
#include "xfs_mount.h"
#include "xfs_alloc_btree.h"
#include "xfs_bmap_btree.h"
#include "xfs_ialloc_btree.h"
#include "xfs_btree.h"
#include "xfs_ialloc.h"
#include "xfs_attr_sf.h"
#include "xfs_dir_sf.h"
#include "xfs_dir2_sf.h"
#include "xfs_dinode.h"
#include "xfs_inode.h"
#include "xfs_bmap.h"
#include "xfs_bit.h"
#include "xfs_rtalloc.h"
#include "xfs_error.h"
#include "xfs_itable.h"
#include "xfs_rw.h"
#include "xfs_acl.h"
#include "xfs_cap.h"
#include "xfs_mac.h"
#include "xfs_attr.h"
#include "xfs_buf_item.h"

#include "xfs_qm.h"

#define MNTOPT_QUOTA	"quota"		/* disk quotas (user) */
#define MNTOPT_NOQUOTA	"noquota"	/* no quotas */
#define MNTOPT_USRQUOTA	"usrquota"	/* user quota enabled */
#define MNTOPT_GRPQUOTA	"grpquota"	/* group quota enabled */
#define MNTOPT_UQUOTA	"uquota"	/* user quota (IRIX variant) */
#define MNTOPT_GQUOTA	"gquota"	/* group quota (IRIX variant) */
#define MNTOPT_UQUOTANOENF "uqnoenforce"/* user quota limit enforcement */
#define MNTOPT_GQUOTANOENF "gqnoenforce"/* group quota limit enforcement */
#define MNTOPT_QUOTANOENF  "qnoenforce"	/* same as uqnoenforce */

STATIC int
xfs_qm_parseargs(
	struct bhv_desc		*bhv,
	char			*options,
	struct xfs_mount_args	*args,
	int			update)
{
	size_t			length;
	char			*local_options = options;
	char			*this_char;
	int			error;
	int			referenced = update;

	while ((this_char = strsep(&local_options, ",")) != NULL) {
		length = strlen(this_char);
		if (local_options)
			length++;

		if (!strcmp(this_char, MNTOPT_NOQUOTA)) {
			args->flags &= ~(XFSMNT_UQUOTAENF|XFSMNT_UQUOTA);
			args->flags &= ~(XFSMNT_GQUOTAENF|XFSMNT_GQUOTA);
			referenced = update;
		} else if (!strcmp(this_char, MNTOPT_QUOTA) ||
			   !strcmp(this_char, MNTOPT_UQUOTA) ||
			   !strcmp(this_char, MNTOPT_USRQUOTA)) {
			args->flags |= XFSMNT_UQUOTA | XFSMNT_UQUOTAENF;
			referenced = 1;
		} else if (!strcmp(this_char, MNTOPT_QUOTANOENF) ||
			   !strcmp(this_char, MNTOPT_UQUOTANOENF)) {
			args->flags |= XFSMNT_UQUOTA;
			args->flags &= ~XFSMNT_UQUOTAENF;
			referenced = 1;
		} else if (!strcmp(this_char, MNTOPT_GQUOTA) ||
			   !strcmp(this_char, MNTOPT_GRPQUOTA)) {
			args->flags |= XFSMNT_GQUOTA | XFSMNT_GQUOTAENF;
			referenced = 1;
		} else if (!strcmp(this_char, MNTOPT_GQUOTANOENF)) {
			args->flags |= XFSMNT_GQUOTA;
			args->flags &= ~XFSMNT_GQUOTAENF;
			referenced = 1;
		} else {
			if (local_options)
				*(local_options-1) = ',';
			continue;
		}

		while (length--)
			*this_char++ = ',';
	}

	PVFS_PARSEARGS(BHV_NEXT(bhv), options, args, update, error);
	if (!error && !referenced)
		bhv_remove_vfsops(bhvtovfs(bhv), VFS_POSITION_QM);
	return error;
}

STATIC int
xfs_qm_showargs(
	struct bhv_desc		*bhv,
	struct seq_file		*m)
{
	struct vfs		*vfsp = bhvtovfs(bhv);
	struct xfs_mount	*mp = XFS_VFSTOM(vfsp);
	int			error;

	if (mp->m_qflags & XFS_UQUOTA_ACCT) {
		(mp->m_qflags & XFS_UQUOTA_ENFD) ?
			seq_puts(m, "," MNTOPT_USRQUOTA) :
			seq_puts(m, "," MNTOPT_UQUOTANOENF);
	}

	if (mp->m_qflags & XFS_GQUOTA_ACCT) {
		(mp->m_qflags & XFS_GQUOTA_ENFD) ?
			seq_puts(m, "," MNTOPT_GRPQUOTA) :
			seq_puts(m, "," MNTOPT_GQUOTANOENF);
	}

	if (!(mp->m_qflags & (XFS_UQUOTA_ACCT|XFS_GQUOTA_ACCT)))
		seq_puts(m, "," MNTOPT_NOQUOTA);

	PVFS_SHOWARGS(BHV_NEXT(bhv), m, error);
	return error;
}

STATIC int
xfs_qm_mount(
	struct bhv_desc		*bhv,
	struct xfs_mount_args	*args,
	struct cred		*cr)
{
	struct vfs		*vfsp = bhvtovfs(bhv);
	struct xfs_mount	*mp = XFS_VFSTOM(vfsp);
	int			error;

	if (args->flags & (XFSMNT_UQUOTA | XFSMNT_GQUOTA))
		xfs_qm_mount_quotainit(mp, args->flags);
	PVFS_MOUNT(BHV_NEXT(bhv), args, cr, error);
	return error;
}

STATIC int
xfs_qm_syncall(
	struct bhv_desc		*bhv,
	int			flags,
	cred_t			*credp)
{
	struct vfs		*vfsp = bhvtovfs(bhv);
	struct xfs_mount	*mp = XFS_VFSTOM(vfsp);
	int			error;

	/*
	 * Get the Quota Manager to flush the dquots.
	 */
	if (XFS_IS_QUOTA_ON(mp)) {
		if ((error = xfs_qm_sync(mp, flags))) {
			/*
			 * If we got an IO error, we will be shutting down.
			 * So, there's nothing more for us to do here.
			 */
			ASSERT(error != EIO || XFS_FORCED_SHUTDOWN(mp));
			if (XFS_FORCED_SHUTDOWN(mp)) {
				return XFS_ERROR(error);
			}
		}
	}
	PVFS_SYNC(BHV_NEXT(bhv), flags, credp, error);
	return error;
}

/*
 * Clear the quotaflags in memory and in the superblock.
 */
void
xfs_mount_reset_sbqflags(
	xfs_mount_t		*mp)
{
	xfs_trans_t		*tp;
	unsigned long		s;

	mp->m_qflags = 0;
	/*
	 * It is OK to look at sb_qflags here in mount path,
	 * without SB_LOCK.
	 */
	if (mp->m_sb.sb_qflags == 0)
		return;
	s = XFS_SB_LOCK(mp);
	mp->m_sb.sb_qflags = 0;
	XFS_SB_UNLOCK(mp, s);

	/*
	 * if the fs is readonly, let the incore superblock run
	 * with quotas off but don't flush the update out to disk
	 */
	if (XFS_MTOVFS(mp)->vfs_flag & VFS_RDONLY)
		return;
#ifdef QUOTADEBUG
	xfs_fs_cmn_err(CE_NOTE, mp, "Writing superblock quota changes");
#endif
	tp = xfs_trans_alloc(mp, XFS_TRANS_QM_SBCHANGE);
	if (xfs_trans_reserve(tp, 0, mp->m_sb.sb_sectsize + 128, 0, 0,
				      XFS_DEFAULT_LOG_COUNT)) {
		xfs_trans_cancel(tp, 0);
		xfs_fs_cmn_err(CE_ALERT, mp,
			"xfs_mount_reset_sbqflags: Superblock update failed!");
		return;
	}
	xfs_mod_sb(tp, XFS_SB_QFLAGS);
	xfs_trans_commit(tp, 0, NULL);
}

STATIC int
xfs_qm_newmount(
	xfs_mount_t	*mp,
	uint		*needquotamount,
	uint		*quotaflags)
{
	uint		quotaondisk;
	uint		uquotaondisk = 0, gquotaondisk = 0;

	*quotaflags = 0;
	*needquotamount = B_FALSE;

	quotaondisk = XFS_SB_VERSION_HASQUOTA(&mp->m_sb) &&
		mp->m_sb.sb_qflags & (XFS_UQUOTA_ACCT|XFS_GQUOTA_ACCT);

	if (quotaondisk) {
		uquotaondisk = mp->m_sb.sb_qflags & XFS_UQUOTA_ACCT;
		gquotaondisk = mp->m_sb.sb_qflags & XFS_GQUOTA_ACCT;
	}

	/*
	 * If the device itself is read-only, we can't allow
	 * the user to change the state of quota on the mount -
	 * this would generate a transaction on the ro device,
	 * which would lead to an I/O error and shutdown
	 */

	if (((uquotaondisk && !XFS_IS_UQUOTA_ON(mp)) ||
	    (!uquotaondisk &&  XFS_IS_UQUOTA_ON(mp)) ||
	     (gquotaondisk && !XFS_IS_GQUOTA_ON(mp)) ||
	    (!gquotaondisk &&  XFS_IS_GQUOTA_ON(mp)))  &&
	    xfs_dev_is_read_only(mp, "changing quota state")) {
		cmn_err(CE_WARN,
			"XFS: please mount with%s%s%s.",
			(!quotaondisk ? "out quota" : ""),
			(uquotaondisk ? " usrquota" : ""),
			(gquotaondisk ? " grpquota" : ""));
		return XFS_ERROR(EPERM);
	}

	if (XFS_IS_QUOTA_ON(mp) || quotaondisk) {
		/*
		 * Call mount_quotas at this point only if we won't have to do
		 * a quotacheck.
		 */
		if (quotaondisk && !XFS_QM_NEED_QUOTACHECK(mp)) {
			/*
			 * If an error occured, qm_mount_quotas code
			 * has already disabled quotas. So, just finish
			 * mounting, and get on with the boring life
			 * without disk quotas.
			 */
			xfs_qm_mount_quotas(mp, 0);
		} else {
			/*
			 * Clear the quota flags, but remember them. This
			 * is so that the quota code doesn't get invoked
			 * before we're ready. This can happen when an
			 * inode goes inactive and wants to free blocks,
			 * or via xfs_log_mount_finish.
			 */
			*needquotamount = B_TRUE;
			*quotaflags = mp->m_qflags;
			mp->m_qflags = 0;
		}
	}

	return 0;
}

STATIC int
xfs_qm_endmount(
	xfs_mount_t	*mp,
	uint		needquotamount,
	uint		quotaflags,
	int		mfsi_flags)
{
	if (needquotamount) {
		ASSERT(mp->m_qflags == 0);
		mp->m_qflags = quotaflags;
		xfs_qm_mount_quotas(mp, mfsi_flags);
	}

#if defined(DEBUG) && defined(XFS_LOUD_RECOVERY)
	if (! (XFS_IS_QUOTA_ON(mp)))
		xfs_fs_cmn_err(CE_NOTE, mp, "Disk quotas not turned on");
	else
		xfs_fs_cmn_err(CE_NOTE, mp, "Disk quotas turned on");
#endif

#ifdef QUOTADEBUG
	if (XFS_IS_QUOTA_ON(mp) && xfs_qm_internalqcheck(mp))
		cmn_err(CE_WARN, "XFS: mount internalqcheck failed");
#endif

	return 0;
}

STATIC void
xfs_qm_dqrele_null(
	xfs_dquot_t	*dq)
{
	/*
	 * Called from XFS, where we always check first for a NULL dquot.
	 */
	if (!dq)
		return;
	xfs_qm_dqrele(dq);
}


STATIC struct xfs_qmops xfs_qmcore_xfs = {
	.xfs_qminit		= xfs_qm_newmount,
	.xfs_qmdone		= xfs_qm_unmount_quotadestroy,
	.xfs_qmmount		= xfs_qm_endmount,
	.xfs_qmunmount		= xfs_qm_unmount_quotas,
	.xfs_dqrele		= xfs_qm_dqrele_null,
	.xfs_dqattach		= xfs_qm_dqattach,
	.xfs_dqdetach		= xfs_qm_dqdetach,
	.xfs_dqpurgeall		= xfs_qm_dqpurge_all,
	.xfs_dqvopalloc		= xfs_qm_vop_dqalloc,
	.xfs_dqvopcreate	= xfs_qm_vop_dqattach_and_dqmod_newinode,
	.xfs_dqvoprename	= xfs_qm_vop_rename_dqattach,
	.xfs_dqvopchown		= xfs_qm_vop_chown,
	.xfs_dqvopchownresv	= xfs_qm_vop_chown_reserve,
	.xfs_dqtrxops		= &xfs_trans_dquot_ops,
};

struct bhv_vfsops xfs_qmops = { {
	BHV_IDENTITY_INIT(VFS_BHV_QM, VFS_POSITION_QM),
	.vfs_parseargs		= xfs_qm_parseargs,
	.vfs_showargs		= xfs_qm_showargs,
	.vfs_mount		= xfs_qm_mount,
	.vfs_sync		= xfs_qm_syncall,
	.vfs_quotactl		= xfs_qm_quotactl, },
};


void __init
xfs_qm_init(void)
{
	static char	message[] __initdata =
		KERN_INFO "SGI XFS Quota Management subsystem\n";

	printk(message);
	mutex_init(&xfs_Gqm_lock, MUTEX_DEFAULT, "xfs_qmlock");
	vfs_bhv_set_custom(&xfs_qmops, &xfs_qmcore_xfs);
	xfs_qm_init_procfs();
}

void __exit
xfs_qm_exit(void)
{
	vfs_bhv_clr_custom(&xfs_qmops);
	xfs_qm_cleanup_procfs();
	if (qm_dqzone)
		kmem_cache_destroy(qm_dqzone);
	if (qm_dqtrxzone)
		kmem_cache_destroy(qm_dqtrxzone);
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* Copyright (c) 2000-2004 Silicon Graphics, Inc. All Rights Reserved.
	3	*
	4	* This program is free software; you can redistribute it and/or modify it
	5	* under the terms of version 2 of the GNU General Public License as
	6	* published by the Free Software Foundation.
	7	*
	8	* This program is distributed in the hope that it would be useful, but
	9	* WITHOUT ANY WARRANTY; without even the implied warranty of
	10	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
	11	*
	12	* Further, this software is distributed without any warranty that it is
	13	* free of the rightful claim of any third person regarding infringement
	14	* or the like. Any license provided herein, whether implied or
	15	* otherwise, applies only to this software file. Patent licenses, if
	16	* any, provided herein do not apply to combinations of this program with
	17	* other software, or any other product whatsoever.
	18	*
	19	* You should have received a copy of the GNU General Public License along
	20	* with this program; if not, write the Free Software Foundation, Inc., 59
	21	* Temple Place - Suite 330, Boston MA 02111-1307, USA.
	22	*
	23	* Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
	24	* Mountain View, CA 94043, or:
	25	*
	26	* http://www.sgi.com
	27	*
	28	* For further information regarding this notice, see:
	29	*
	30	* http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
	31	*/
	32
	33	#include "xfs.h"
	34	#include "xfs_fs.h"
	35	#include "xfs_inum.h"
	36	#include "xfs_log.h"
	37	#include "xfs_clnt.h"
	38	#include "xfs_trans.h"
	39	#include "xfs_sb.h"
	40	#include "xfs_dir.h"
	41	#include "xfs_dir2.h"
	42	#include "xfs_alloc.h"
	43	#include "xfs_dmapi.h"
	44	#include "xfs_quota.h"
	45	#include "xfs_mount.h"
	46	#include "xfs_alloc_btree.h"
	47	#include "xfs_bmap_btree.h"
	48	#include "xfs_ialloc_btree.h"
	49	#include "xfs_btree.h"
	50	#include "xfs_ialloc.h"
	51	#include "xfs_attr_sf.h"
	52	#include "xfs_dir_sf.h"
	53	#include "xfs_dir2_sf.h"
	54	#include "xfs_dinode.h"
	55	#include "xfs_inode.h"
	56	#include "xfs_bmap.h"
	57	#include "xfs_bit.h"
	58	#include "xfs_rtalloc.h"
	59	#include "xfs_error.h"
	60	#include "xfs_itable.h"
	61	#include "xfs_rw.h"
	62	#include "xfs_acl.h"
	63	#include "xfs_cap.h"
	64	#include "xfs_mac.h"
65	#include "xfs_attr.h"
66	#include "xfs_buf_item.h"
67
68	#include "xfs_qm.h"
69
70	#define MNTOPT_QUOTA "quota" /* disk quotas (user) */
71	#define MNTOPT_NOQUOTA "noquota" /* no quotas */
72	#define MNTOPT_USRQUOTA "usrquota" /* user quota enabled */
73	#define MNTOPT_GRPQUOTA "grpquota" /* group quota enabled */
74	#define MNTOPT_UQUOTA "uquota" /* user quota (IRIX variant) */
75	#define MNTOPT_GQUOTA "gquota" /* group quota (IRIX variant) */
76	#define MNTOPT_UQUOTANOENF "uqnoenforce"/* user quota limit enforcement */
77	#define MNTOPT_GQUOTANOENF "gqnoenforce"/* group quota limit enforcement */
78	#define MNTOPT_QUOTANOENF "qnoenforce" /* same as uqnoenforce */
79
80	STATIC int
81	xfs_qm_parseargs(
82	struct bhv_desc *bhv,
83	char *options,
84	struct xfs_mount_args *args,
85	int update)
86	{
87	size_t length;
88	char *local_options = options;
89	char *this_char;
90	int error;
91	int referenced = update;
92
93	while ((this_char = strsep(&local_options, ",")) != NULL) {
94	length = strlen(this_char);
95	if (local_options)
96	length++;
97
98	if (!strcmp(this_char, MNTOPT_NOQUOTA)) {
99	args->flags &= ~(XFSMNT_UQUOTAENF\|XFSMNT_UQUOTA);
100	args->flags &= ~(XFSMNT_GQUOTAENF\|XFSMNT_GQUOTA);
101	referenced = update;
102	} else if (!strcmp(this_char, MNTOPT_QUOTA) \|\|
103	!strcmp(this_char, MNTOPT_UQUOTA) \|\|
104	!strcmp(this_char, MNTOPT_USRQUOTA)) {
105	args->flags \|= XFSMNT_UQUOTA \| XFSMNT_UQUOTAENF;
106	referenced = 1;
107	} else if (!strcmp(this_char, MNTOPT_QUOTANOENF) \|\|
108	!strcmp(this_char, MNTOPT_UQUOTANOENF)) {
109	args->flags \|= XFSMNT_UQUOTA;
110	args->flags &= ~XFSMNT_UQUOTAENF;
111	referenced = 1;
112	} else if (!strcmp(this_char, MNTOPT_GQUOTA) \|\|
113	!strcmp(this_char, MNTOPT_GRPQUOTA)) {
114	args->flags \|= XFSMNT_GQUOTA \| XFSMNT_GQUOTAENF;
115	referenced = 1;
116	} else if (!strcmp(this_char, MNTOPT_GQUOTANOENF)) {
117	args->flags \|= XFSMNT_GQUOTA;
118	args->flags &= ~XFSMNT_GQUOTAENF;
119	referenced = 1;
120	} else {
121	if (local_options)
122	*(local_options-1) = ',';
123	continue;
124	}
125
126	while (length--)
127	*this_char++ = ',';
128	}
129
130	PVFS_PARSEARGS(BHV_NEXT(bhv), options, args, update, error);
131	if (!error && !referenced)
132	bhv_remove_vfsops(bhvtovfs(bhv), VFS_POSITION_QM);
133	return error;
134	}
135
136	STATIC int
137	xfs_qm_showargs(
138	struct bhv_desc *bhv,
139	struct seq_file *m)
140	{
141	struct vfs *vfsp = bhvtovfs(bhv);
142	struct xfs_mount *mp = XFS_VFSTOM(vfsp);
143	int error;
144
145	if (mp->m_qflags & XFS_UQUOTA_ACCT) {
146	(mp->m_qflags & XFS_UQUOTA_ENFD) ?
147	seq_puts(m, "," MNTOPT_USRQUOTA) :
148	seq_puts(m, "," MNTOPT_UQUOTANOENF);
149	}
150
151	if (mp->m_qflags & XFS_GQUOTA_ACCT) {
152	(mp->m_qflags & XFS_GQUOTA_ENFD) ?
153	seq_puts(m, "," MNTOPT_GRPQUOTA) :
154	seq_puts(m, "," MNTOPT_GQUOTANOENF);
155	}
156
157	if (!(mp->m_qflags & (XFS_UQUOTA_ACCT\|XFS_GQUOTA_ACCT)))
158	seq_puts(m, "," MNTOPT_NOQUOTA);
159
160	PVFS_SHOWARGS(BHV_NEXT(bhv), m, error);
161	return error;
162	}
163
164	STATIC int
165	xfs_qm_mount(
166	struct bhv_desc *bhv,
167	struct xfs_mount_args *args,
168	struct cred *cr)
169	{
170	struct vfs *vfsp = bhvtovfs(bhv);
171	struct xfs_mount *mp = XFS_VFSTOM(vfsp);
172	int error;
173
174	if (args->flags & (XFSMNT_UQUOTA \| XFSMNT_GQUOTA))
175	xfs_qm_mount_quotainit(mp, args->flags);
176	PVFS_MOUNT(BHV_NEXT(bhv), args, cr, error);
177	return error;
178	}
179
180	STATIC int
181	xfs_qm_syncall(
182	struct bhv_desc *bhv,
183	int flags,
184	cred_t *credp)
185	{
186	struct vfs *vfsp = bhvtovfs(bhv);
187	struct xfs_mount *mp = XFS_VFSTOM(vfsp);
188	int error;
189
190	/*
191	* Get the Quota Manager to flush the dquots.
192	*/
193	if (XFS_IS_QUOTA_ON(mp)) {
194	if ((error = xfs_qm_sync(mp, flags))) {
195	/*
196	* If we got an IO error, we will be shutting down.
197	* So, there's nothing more for us to do here.
198	*/
199	ASSERT(error != EIO \|\| XFS_FORCED_SHUTDOWN(mp));
200	if (XFS_FORCED_SHUTDOWN(mp)) {
201	return XFS_ERROR(error);
202	}
203	}
204	}
205	PVFS_SYNC(BHV_NEXT(bhv), flags, credp, error);
206	return error;
207	}
208
209	/*
210	* Clear the quotaflags in memory and in the superblock.
211	*/
212	void
213	xfs_mount_reset_sbqflags(
214	xfs_mount_t *mp)
215	{
216	xfs_trans_t *tp;
217	unsigned long s;
218
219	mp->m_qflags = 0;
220	/*
221	* It is OK to look at sb_qflags here in mount path,
222	* without SB_LOCK.
223	*/
224	if (mp->m_sb.sb_qflags == 0)
225	return;
226	s = XFS_SB_LOCK(mp);
227	mp->m_sb.sb_qflags = 0;
228	XFS_SB_UNLOCK(mp, s);
229
230	/*
231	* if the fs is readonly, let the incore superblock run
232	* with quotas off but don't flush the update out to disk
233	*/
234	if (XFS_MTOVFS(mp)->vfs_flag & VFS_RDONLY)
235	return;
236	#ifdef QUOTADEBUG
237	xfs_fs_cmn_err(CE_NOTE, mp, "Writing superblock quota changes");
238	#endif
239	tp = xfs_trans_alloc(mp, XFS_TRANS_QM_SBCHANGE);
240	if (xfs_trans_reserve(tp, 0, mp->m_sb.sb_sectsize + 128, 0, 0,
241	XFS_DEFAULT_LOG_COUNT)) {
242	xfs_trans_cancel(tp, 0);
243	xfs_fs_cmn_err(CE_ALERT, mp,
244	"xfs_mount_reset_sbqflags: Superblock update failed!");
245	return;
246	}
247	xfs_mod_sb(tp, XFS_SB_QFLAGS);
248	xfs_trans_commit(tp, 0, NULL);
249	}
250
251	STATIC int
252	xfs_qm_newmount(
253	xfs_mount_t *mp,
254	uint *needquotamount,
255	uint *quotaflags)
256	{
257	uint quotaondisk;
258	uint uquotaondisk = 0, gquotaondisk = 0;
259
260	*quotaflags = 0;
261	*needquotamount = B_FALSE;
262
263	quotaondisk = XFS_SB_VERSION_HASQUOTA(&mp->m_sb) &&
264	mp->m_sb.sb_qflags & (XFS_UQUOTA_ACCT\|XFS_GQUOTA_ACCT);
265
266	if (quotaondisk) {
267	uquotaondisk = mp->m_sb.sb_qflags & XFS_UQUOTA_ACCT;
268	gquotaondisk = mp->m_sb.sb_qflags & XFS_GQUOTA_ACCT;
269	}
270
271	/*
272	* If the device itself is read-only, we can't allow
273	* the user to change the state of quota on the mount -
274	* this would generate a transaction on the ro device,
275	* which would lead to an I/O error and shutdown
276	*/
277
278	if (((uquotaondisk && !XFS_IS_UQUOTA_ON(mp)) \|\|
279	(!uquotaondisk && XFS_IS_UQUOTA_ON(mp)) \|\|
280	(gquotaondisk && !XFS_IS_GQUOTA_ON(mp)) \|\|
281	(!gquotaondisk && XFS_IS_GQUOTA_ON(mp))) &&
282	xfs_dev_is_read_only(mp, "changing quota state")) {
283	cmn_err(CE_WARN,
284	"XFS: please mount with%s%s%s.",
285	(!quotaondisk ? "out quota" : ""),
286	(uquotaondisk ? " usrquota" : ""),
287	(gquotaondisk ? " grpquota" : ""));
288	return XFS_ERROR(EPERM);
289	}
290
291	if (XFS_IS_QUOTA_ON(mp) \|\| quotaondisk) {
292	/*
293	* Call mount_quotas at this point only if we won't have to do
294	* a quotacheck.
295	*/
296	if (quotaondisk && !XFS_QM_NEED_QUOTACHECK(mp)) {
297	/*
298	* If an error occured, qm_mount_quotas code
299	* has already disabled quotas. So, just finish
300	* mounting, and get on with the boring life
301	* without disk quotas.
302	*/
303	xfs_qm_mount_quotas(mp, 0);
304	} else {
305	/*
306	* Clear the quota flags, but remember them. This
307	* is so that the quota code doesn't get invoked
308	* before we're ready. This can happen when an
309	* inode goes inactive and wants to free blocks,
310	* or via xfs_log_mount_finish.
311	*/
312	*needquotamount = B_TRUE;
313	*quotaflags = mp->m_qflags;
314	mp->m_qflags = 0;
315	}
316	}
317
318	return 0;
319	}
320
321	STATIC int
322	xfs_qm_endmount(
323	xfs_mount_t *mp,
324	uint needquotamount,
325	uint quotaflags,
326	int mfsi_flags)
327	{
328	if (needquotamount) {
329	ASSERT(mp->m_qflags == 0);
330	mp->m_qflags = quotaflags;
331	xfs_qm_mount_quotas(mp, mfsi_flags);
332	}
333
334	#if defined(DEBUG) && defined(XFS_LOUD_RECOVERY)
335	if (! (XFS_IS_QUOTA_ON(mp)))
336	xfs_fs_cmn_err(CE_NOTE, mp, "Disk quotas not turned on");
337	else
338	xfs_fs_cmn_err(CE_NOTE, mp, "Disk quotas turned on");
339	#endif
340
341	#ifdef QUOTADEBUG
342	if (XFS_IS_QUOTA_ON(mp) && xfs_qm_internalqcheck(mp))
343	cmn_err(CE_WARN, "XFS: mount internalqcheck failed");
344	#endif
345
346	return 0;
347	}
348
349	STATIC void
350	xfs_qm_dqrele_null(
351	xfs_dquot_t *dq)
352	{
353	/*
354	* Called from XFS, where we always check first for a NULL dquot.
355	*/
356	if (!dq)
357	return;
358	xfs_qm_dqrele(dq);
359	}
360
361
ba0f32d4	362	STATIC struct xfs_qmops xfs_qmcore_xfs = {
1da177e4 LT	363	.xfs_qminit = xfs_qm_newmount,
	364	.xfs_qmdone = xfs_qm_unmount_quotadestroy,
	365	.xfs_qmmount = xfs_qm_endmount,
	366	.xfs_qmunmount = xfs_qm_unmount_quotas,
	367	.xfs_dqrele = xfs_qm_dqrele_null,
	368	.xfs_dqattach = xfs_qm_dqattach,
	369	.xfs_dqdetach = xfs_qm_dqdetach,
	370	.xfs_dqpurgeall = xfs_qm_dqpurge_all,
	371	.xfs_dqvopalloc = xfs_qm_vop_dqalloc,
	372	.xfs_dqvopcreate = xfs_qm_vop_dqattach_and_dqmod_newinode,
	373	.xfs_dqvoprename = xfs_qm_vop_rename_dqattach,
	374	.xfs_dqvopchown = xfs_qm_vop_chown,
	375	.xfs_dqvopchownresv = xfs_qm_vop_chown_reserve,
	376	.xfs_dqtrxops = &xfs_trans_dquot_ops,
	377	};
	378
	379	struct bhv_vfsops xfs_qmops = { {
	380	BHV_IDENTITY_INIT(VFS_BHV_QM, VFS_POSITION_QM),
	381	.vfs_parseargs = xfs_qm_parseargs,
	382	.vfs_showargs = xfs_qm_showargs,
	383	.vfs_mount = xfs_qm_mount,
	384	.vfs_sync = xfs_qm_syncall,
	385	.vfs_quotactl = xfs_qm_quotactl, },
	386	};
	387
	388
	389	void __init
	390	xfs_qm_init(void)
	391	{
	392	static char message[] __initdata =
	393	KERN_INFO "SGI XFS Quota Management subsystem\n";
	394
	395	printk(message);
	396	mutex_init(&xfs_Gqm_lock, MUTEX_DEFAULT, "xfs_qmlock");
	397	vfs_bhv_set_custom(&xfs_qmops, &xfs_qmcore_xfs);
	398	xfs_qm_init_procfs();
	399	}
	400
	401	void __exit
	402	xfs_qm_exit(void)
	403	{
	404	vfs_bhv_clr_custom(&xfs_qmops);
	405	xfs_qm_cleanup_procfs();
	406	if (qm_dqzone)
	407	kmem_cache_destroy(qm_dqzone);
	408	if (qm_dqtrxzone)
	409	kmem_cache_destroy(qm_dqtrxzone);
	410	}