[mirror_ubuntu-artful-kernel.git] / fs / xfs / xfs_quotaops.c

/*
 * Copyright (c) 2008, Christoph Hellwig
 * All Rights Reserved.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms 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.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write the Free Software Foundation,
 * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
#include "xfs.h"
#include "xfs_format.h"
#include "xfs_log_format.h"
#include "xfs_trans_resv.h"
#include "xfs_mount.h"
#include "xfs_inode.h"
#include "xfs_quota.h"
#include "xfs_trans.h"
#include "xfs_trace.h"
#include "xfs_icache.h"
#include "xfs_qm.h"
#include <linux/quota.h>


static void
xfs_qm_fill_state(
	struct qc_type_state	*tstate,
	struct xfs_mount	*mp,
	struct xfs_inode	*ip,
	xfs_ino_t		ino)
{
	struct xfs_quotainfo *q = mp->m_quotainfo;
	bool tempqip = false;

	tstate->ino = ino;
	if (!ip && ino == NULLFSINO)
		return;
	if (!ip) {
		if (xfs_iget(mp, NULL, ino, 0, 0, &ip))
			return;
		tempqip = true;
	}
	tstate->flags |= QCI_SYSFILE;
	tstate->blocks = ip->i_d.di_nblocks;
	tstate->nextents = ip->i_d.di_nextents;
	tstate->spc_timelimit = q->qi_btimelimit;
	tstate->ino_timelimit = q->qi_itimelimit;
	tstate->rt_spc_timelimit = q->qi_rtbtimelimit;
	tstate->spc_warnlimit = q->qi_bwarnlimit;
	tstate->ino_warnlimit = q->qi_iwarnlimit;
	tstate->rt_spc_warnlimit = q->qi_rtbwarnlimit;
	if (tempqip)
		IRELE(ip);
}

/*
 * Return quota status information, such as enforcements, quota file inode
 * numbers etc.
 */
static int
xfs_fs_get_quota_state(
	struct super_block	*sb,
	struct qc_state		*state)
{
	struct xfs_mount *mp = XFS_M(sb);
	struct xfs_quotainfo *q = mp->m_quotainfo;

	memset(state, 0, sizeof(*state));
	if (!XFS_IS_QUOTA_RUNNING(mp))
		return 0;
	state->s_incoredqs = q->qi_dquots;
	if (XFS_IS_UQUOTA_RUNNING(mp))
		state->s_state[USRQUOTA].flags |= QCI_ACCT_ENABLED;
	if (XFS_IS_UQUOTA_ENFORCED(mp))
		state->s_state[USRQUOTA].flags |= QCI_LIMITS_ENFORCED;
	if (XFS_IS_GQUOTA_RUNNING(mp))
		state->s_state[GRPQUOTA].flags |= QCI_ACCT_ENABLED;
	if (XFS_IS_GQUOTA_ENFORCED(mp))
		state->s_state[GRPQUOTA].flags |= QCI_LIMITS_ENFORCED;
	if (XFS_IS_PQUOTA_RUNNING(mp))
		state->s_state[PRJQUOTA].flags |= QCI_ACCT_ENABLED;
	if (XFS_IS_PQUOTA_ENFORCED(mp))
		state->s_state[PRJQUOTA].flags |= QCI_LIMITS_ENFORCED;

	xfs_qm_fill_state(&state->s_state[USRQUOTA], mp, q->qi_uquotaip,
			  mp->m_sb.sb_uquotino);
	xfs_qm_fill_state(&state->s_state[GRPQUOTA], mp, q->qi_gquotaip,
			  mp->m_sb.sb_gquotino);
	xfs_qm_fill_state(&state->s_state[PRJQUOTA], mp, q->qi_pquotaip,
			  mp->m_sb.sb_pquotino);
	return 0;
}

STATIC int
xfs_quota_type(int type)
{
	switch (type) {
	case USRQUOTA:
		return XFS_DQ_USER;
	case GRPQUOTA:
		return XFS_DQ_GROUP;
	default:
		return XFS_DQ_PROJ;
	}
}

#define XFS_QC_SETINFO_MASK (QC_TIMER_MASK | QC_WARNS_MASK)

/*
 * Adjust quota timers & warnings
 */
static int
xfs_fs_set_info(
	struct super_block	*sb,
	int			type,
	struct qc_info		*info)
{
	struct xfs_mount *mp = XFS_M(sb);
	struct qc_dqblk newlim;

	if (sb->s_flags & MS_RDONLY)
		return -EROFS;
	if (!XFS_IS_QUOTA_RUNNING(mp))
		return -ENOSYS;
	if (!XFS_IS_QUOTA_ON(mp))
		return -ESRCH;
	if (info->i_fieldmask & ~XFS_QC_SETINFO_MASK)
		return -EINVAL;
	if ((info->i_fieldmask & XFS_QC_SETINFO_MASK) == 0)
		return 0;

	newlim.d_fieldmask = info->i_fieldmask;
	newlim.d_spc_timer = info->i_spc_timelimit;
	newlim.d_ino_timer = info->i_ino_timelimit;
	newlim.d_rt_spc_timer = info->i_rt_spc_timelimit;
	newlim.d_ino_warns = info->i_ino_warnlimit;
	newlim.d_spc_warns = info->i_spc_warnlimit;
	newlim.d_rt_spc_warns = info->i_rt_spc_warnlimit;

	return xfs_qm_scall_setqlim(mp, 0, xfs_quota_type(type), &newlim);
}

static unsigned int
xfs_quota_flags(unsigned int uflags)
{
	unsigned int flags = 0;

	if (uflags & FS_QUOTA_UDQ_ACCT)
		flags |= XFS_UQUOTA_ACCT;
	if (uflags & FS_QUOTA_PDQ_ACCT)
		flags |= XFS_PQUOTA_ACCT;
	if (uflags & FS_QUOTA_GDQ_ACCT)
		flags |= XFS_GQUOTA_ACCT;
	if (uflags & FS_QUOTA_UDQ_ENFD)
		flags |= XFS_UQUOTA_ENFD;
	if (uflags & FS_QUOTA_GDQ_ENFD)
		flags |= XFS_GQUOTA_ENFD;
	if (uflags & FS_QUOTA_PDQ_ENFD)
		flags |= XFS_PQUOTA_ENFD;

	return flags;
}

STATIC int
xfs_quota_enable(
	struct super_block	*sb,
	unsigned int		uflags)
{
	struct xfs_mount	*mp = XFS_M(sb);

	if (sb->s_flags & MS_RDONLY)
		return -EROFS;
	if (!XFS_IS_QUOTA_RUNNING(mp))
		return -ENOSYS;

	return xfs_qm_scall_quotaon(mp, xfs_quota_flags(uflags));
}

STATIC int
xfs_quota_disable(
	struct super_block	*sb,
	unsigned int		uflags)
{
	struct xfs_mount	*mp = XFS_M(sb);

	if (sb->s_flags & MS_RDONLY)
		return -EROFS;
	if (!XFS_IS_QUOTA_RUNNING(mp))
		return -ENOSYS;
	if (!XFS_IS_QUOTA_ON(mp))
		return -EINVAL;

	return xfs_qm_scall_quotaoff(mp, xfs_quota_flags(uflags));
}

STATIC int
xfs_fs_rm_xquota(
	struct super_block	*sb,
	unsigned int		uflags)
{
	struct xfs_mount	*mp = XFS_M(sb);
	unsigned int		flags = 0;

	if (sb->s_flags & MS_RDONLY)
		return -EROFS;

	if (XFS_IS_QUOTA_ON(mp))
		return -EINVAL;

	if (uflags & FS_USER_QUOTA)
		flags |= XFS_DQ_USER;
	if (uflags & FS_GROUP_QUOTA)
		flags |= XFS_DQ_GROUP;
	if (uflags & FS_PROJ_QUOTA)
		flags |= XFS_DQ_PROJ;

	return xfs_qm_scall_trunc_qfiles(mp, flags);
}

STATIC int
xfs_fs_get_dqblk(
	struct super_block	*sb,
	struct kqid		qid,
	struct qc_dqblk		*qdq)
{
	struct xfs_mount	*mp = XFS_M(sb);
	xfs_dqid_t		id;

	if (!XFS_IS_QUOTA_RUNNING(mp))
		return -ENOSYS;
	if (!XFS_IS_QUOTA_ON(mp))
		return -ESRCH;

	id = from_kqid(&init_user_ns, qid);
	return xfs_qm_scall_getquota(mp, &id,
				      xfs_quota_type(qid.type), qdq, 0);
}

/* Return quota info for active quota >= this qid */
STATIC int
xfs_fs_get_nextdqblk(
	struct super_block	*sb,
	struct kqid		*qid,
	struct qc_dqblk		*qdq)
{
	int			ret;
	struct xfs_mount	*mp = XFS_M(sb);
	xfs_dqid_t		id;

	if (!XFS_IS_QUOTA_RUNNING(mp))
		return -ENOSYS;
	if (!XFS_IS_QUOTA_ON(mp))
		return -ESRCH;

	id = from_kqid(&init_user_ns, *qid);
	ret = xfs_qm_scall_getquota(mp, &id,
				    xfs_quota_type(qid->type), qdq,
				    XFS_QMOPT_DQNEXT);
	if (ret)
		return ret;

	/* ID may be different, so convert back what we got */
	*qid = make_kqid(current_user_ns(), qid->type, id);
	return 0;
}

STATIC int
xfs_fs_set_dqblk(
	struct super_block	*sb,
	struct kqid		qid,
	struct qc_dqblk		*qdq)
{
	struct xfs_mount	*mp = XFS_M(sb);

	if (sb->s_flags & MS_RDONLY)
		return -EROFS;
	if (!XFS_IS_QUOTA_RUNNING(mp))
		return -ENOSYS;
	if (!XFS_IS_QUOTA_ON(mp))
		return -ESRCH;

	return xfs_qm_scall_setqlim(mp, from_kqid(&init_user_ns, qid),
				     xfs_quota_type(qid.type), qdq);
}

const struct quotactl_ops xfs_quotactl_operations = {
	.get_state		= xfs_fs_get_quota_state,
	.set_info		= xfs_fs_set_info,
	.quota_enable		= xfs_quota_enable,
	.quota_disable		= xfs_quota_disable,
	.rm_xquota		= xfs_fs_rm_xquota,
	.get_dqblk		= xfs_fs_get_dqblk,
	.get_nextdqblk		= xfs_fs_get_nextdqblk,
	.set_dqblk		= xfs_fs_set_dqblk,
};
Commit	Line	Data
fcafb71b CH	1	/*
	2	* Copyright (c) 2008, Christoph Hellwig
	3	* All Rights Reserved.
	4	*
	5	* This program is free software; you can redistribute it and/or
	6	* modify it under the terms of the GNU General Public License as
	7	* published by the Free Software Foundation.
	8	*
	9	* This program is distributed in the hope that it would be useful,
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	* GNU General Public License for more details.
	13	*
	14	* You should have received a copy of the GNU General Public License
	15	* along with this program; if not, write the Free Software Foundation,
	16	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	17	*/
	18	#include "xfs.h"
6ca1c906	19	#include "xfs_format.h"
239880ef	20	#include "xfs_log_format.h"
7fd36c44	21	#include "xfs_trans_resv.h"
fcafb71b	22	#include "xfs_mount.h"
a4fbe6ab	23	#include "xfs_inode.h"
fcafb71b	24	#include "xfs_quota.h"
fcafb71b	25	#include "xfs_trans.h"
5d3684c2 JK	26	#include "xfs_trace.h"
5d3684c2 JK	27	#include "xfs_icache.h"
06f8e2d6	28	#include "xfs_qm.h"
fcafb71b CH	29	#include <linux/quota.h>
	30
	31
5d3684c2 JK	32	static void
	33	xfs_qm_fill_state(
	34	struct qc_type_state *tstate,
	35	struct xfs_mount *mp,
	36	struct xfs_inode *ip,
	37	xfs_ino_t ino)
fcafb71b	38	{
5d3684c2 JK	39	struct xfs_quotainfo *q = mp->m_quotainfo;
	40	bool tempqip = false;
	41
	42	tstate->ino = ino;
	43	if (!ip && ino == NULLFSINO)
	44	return;
	45	if (!ip) {
	46	if (xfs_iget(mp, NULL, ino, 0, 0, &ip))
	47	return;
	48	tempqip = true;
fcafb71b	49	}
5d3684c2 JK	50	tstate->flags \|= QCI_SYSFILE;
	51	tstate->blocks = ip->i_d.di_nblocks;
	52	tstate->nextents = ip->i_d.di_nextents;
	53	tstate->spc_timelimit = q->qi_btimelimit;
	54	tstate->ino_timelimit = q->qi_itimelimit;
	55	tstate->rt_spc_timelimit = q->qi_rtbtimelimit;
	56	tstate->spc_warnlimit = q->qi_bwarnlimit;
	57	tstate->ino_warnlimit = q->qi_iwarnlimit;
	58	tstate->rt_spc_warnlimit = q->qi_rtbwarnlimit;
	59	if (tempqip)
	60	IRELE(ip);
fcafb71b CH	61	}
fcafb71b CH	62
5d3684c2 JK	63	/*
	64	* Return quota status information, such as enforcements, quota file inode
	65	* numbers etc.
	66	*/
	67	static int
	68	xfs_fs_get_quota_state(
fcafb71b	69	struct super_block *sb,
5d3684c2	70	struct qc_state *state)
fcafb71b	71	{
5d3684c2 JK	72	struct xfs_mount *mp = XFS_M(sb);
5d3684c2 JK	73	struct xfs_quotainfo *q = mp->m_quotainfo;
fcafb71b	74
5d3684c2	75	memset(state, 0, sizeof(*state));
fcafb71b	76	if (!XFS_IS_QUOTA_RUNNING(mp))
5d3684c2 JK	77	return 0;
	78	state->s_incoredqs = q->qi_dquots;
	79	if (XFS_IS_UQUOTA_RUNNING(mp))
	80	state->s_state[USRQUOTA].flags \|= QCI_ACCT_ENABLED;
	81	if (XFS_IS_UQUOTA_ENFORCED(mp))
	82	state->s_state[USRQUOTA].flags \|= QCI_LIMITS_ENFORCED;
	83	if (XFS_IS_GQUOTA_RUNNING(mp))
	84	state->s_state[GRPQUOTA].flags \|= QCI_ACCT_ENABLED;
	85	if (XFS_IS_GQUOTA_ENFORCED(mp))
	86	state->s_state[GRPQUOTA].flags \|= QCI_LIMITS_ENFORCED;
	87	if (XFS_IS_PQUOTA_RUNNING(mp))
	88	state->s_state[PRJQUOTA].flags \|= QCI_ACCT_ENABLED;
	89	if (XFS_IS_PQUOTA_ENFORCED(mp))
	90	state->s_state[PRJQUOTA].flags \|= QCI_LIMITS_ENFORCED;
	91
	92	xfs_qm_fill_state(&state->s_state[USRQUOTA], mp, q->qi_uquotaip,
	93	mp->m_sb.sb_uquotino);
	94	xfs_qm_fill_state(&state->s_state[GRPQUOTA], mp, q->qi_gquotaip,
	95	mp->m_sb.sb_gquotino);
	96	xfs_qm_fill_state(&state->s_state[PRJQUOTA], mp, q->qi_pquotaip,
	97	mp->m_sb.sb_pquotino);
	98	return 0;
fcafb71b CH	99	}
fcafb71b CH	100
5d5e3d57	101	STATIC int
5d3684c2	102	xfs_quota_type(int type)
5d5e3d57	103	{
5d3684c2 JK	104	switch (type) {
	105	case USRQUOTA:
	106	return XFS_DQ_USER;
	107	case GRPQUOTA:
	108	return XFS_DQ_GROUP;
	109	default:
	110	return XFS_DQ_PROJ;
	111	}
5d5e3d57 CS	112	}
5d5e3d57 CS	113
c14cad9e JK	114	#define XFS_QC_SETINFO_MASK (QC_TIMER_MASK \| QC_WARNS_MASK)
	115
	116	/*
	117	* Adjust quota timers & warnings
	118	*/
	119	static int
	120	xfs_fs_set_info(
	121	struct super_block *sb,
	122	int type,
	123	struct qc_info *info)
	124	{
	125	struct xfs_mount *mp = XFS_M(sb);
	126	struct qc_dqblk newlim;
	127
	128	if (sb->s_flags & MS_RDONLY)
	129	return -EROFS;
	130	if (!XFS_IS_QUOTA_RUNNING(mp))
	131	return -ENOSYS;
	132	if (!XFS_IS_QUOTA_ON(mp))
	133	return -ESRCH;
	134	if (info->i_fieldmask & ~XFS_QC_SETINFO_MASK)
	135	return -EINVAL;
	136	if ((info->i_fieldmask & XFS_QC_SETINFO_MASK) == 0)
	137	return 0;
	138
	139	newlim.d_fieldmask = info->i_fieldmask;
	140	newlim.d_spc_timer = info->i_spc_timelimit;
	141	newlim.d_ino_timer = info->i_ino_timelimit;
	142	newlim.d_rt_spc_timer = info->i_rt_spc_timelimit;
	143	newlim.d_ino_warns = info->i_ino_warnlimit;
	144	newlim.d_spc_warns = info->i_spc_warnlimit;
	145	newlim.d_rt_spc_warns = info->i_rt_spc_warnlimit;
	146
	147	return xfs_qm_scall_setqlim(mp, 0, xfs_quota_type(type), &newlim);
	148	}
	149
38e478c4 JK	150	static unsigned int
38e478c4 JK	151	xfs_quota_flags(unsigned int uflags)
fcafb71b	152	{
38e478c4	153	unsigned int flags = 0;
fcafb71b	154
ade7ce31	155	if (uflags & FS_QUOTA_UDQ_ACCT)
fcafb71b	156	flags \|= XFS_UQUOTA_ACCT;
ade7ce31	157	if (uflags & FS_QUOTA_PDQ_ACCT)
fcafb71b	158	flags \|= XFS_PQUOTA_ACCT;
ade7ce31	159	if (uflags & FS_QUOTA_GDQ_ACCT)
fcafb71b	160	flags \|= XFS_GQUOTA_ACCT;
ade7ce31	161	if (uflags & FS_QUOTA_UDQ_ENFD)
fcafb71b	162	flags \|= XFS_UQUOTA_ENFD;
83e782e1 CS	163	if (uflags & FS_QUOTA_GDQ_ENFD)
	164	flags \|= XFS_GQUOTA_ENFD;
	165	if (uflags & FS_QUOTA_PDQ_ENFD)
	166	flags \|= XFS_PQUOTA_ENFD;
fcafb71b	167
38e478c4 JK	168	return flags;
	169	}
	170
	171	STATIC int
	172	xfs_quota_enable(
	173	struct super_block *sb,
	174	unsigned int uflags)
	175	{
	176	struct xfs_mount *mp = XFS_M(sb);
	177
	178	if (sb->s_flags & MS_RDONLY)
	179	return -EROFS;
	180	if (!XFS_IS_QUOTA_RUNNING(mp))
	181	return -ENOSYS;
	182
	183	return xfs_qm_scall_quotaon(mp, xfs_quota_flags(uflags));
	184	}
	185
	186	STATIC int
	187	xfs_quota_disable(
	188	struct super_block *sb,
	189	unsigned int uflags)
	190	{
	191	struct xfs_mount *mp = XFS_M(sb);
	192
	193	if (sb->s_flags & MS_RDONLY)
	194	return -EROFS;
	195	if (!XFS_IS_QUOTA_RUNNING(mp))
	196	return -ENOSYS;
	197	if (!XFS_IS_QUOTA_ON(mp))
	198	return -EINVAL;
fcafb71b	199
38e478c4	200	return xfs_qm_scall_quotaoff(mp, xfs_quota_flags(uflags));
fcafb71b CH	201	}
fcafb71b CH	202
9da93f9b ES	203	STATIC int
	204	xfs_fs_rm_xquota(
	205	struct super_block *sb,
	206	unsigned int uflags)
	207	{
	208	struct xfs_mount *mp = XFS_M(sb);
	209	unsigned int flags = 0;
2451337d	210
9da93f9b ES	211	if (sb->s_flags & MS_RDONLY)
	212	return -EROFS;
	213
	214	if (XFS_IS_QUOTA_ON(mp))
	215	return -EINVAL;
	216
	217	if (uflags & FS_USER_QUOTA)
	218	flags \|= XFS_DQ_USER;
	219	if (uflags & FS_GROUP_QUOTA)
	220	flags \|= XFS_DQ_GROUP;
74dc93a9	221	if (uflags & FS_PROJ_QUOTA)
9da93f9b ES	222	flags \|= XFS_DQ_PROJ;
9da93f9b ES	223
2451337d DC	224	return xfs_qm_scall_trunc_qfiles(mp, flags);
2451337d DC	225	}
9da93f9b	226
fcafb71b	227	STATIC int
b9b2dd36	228	xfs_fs_get_dqblk(
fcafb71b	229	struct super_block *sb,
74a8a103	230	struct kqid qid,
14bf61ff	231	struct qc_dqblk *qdq)
fcafb71b CH	232	{
fcafb71b CH	233	struct xfs_mount *mp = XFS_M(sb);
296c24e2	234	xfs_dqid_t id;
fcafb71b CH	235
	236	if (!XFS_IS_QUOTA_RUNNING(mp))
	237	return -ENOSYS;
	238	if (!XFS_IS_QUOTA_ON(mp))
	239	return -ESRCH;
	240
296c24e2 ES	241	id = from_kqid(&init_user_ns, qid);
	242	return xfs_qm_scall_getquota(mp, &id,
	243	xfs_quota_type(qid.type), qdq, 0);
	244	}
	245
	246	/* Return quota info for active quota >= this qid */
	247	STATIC int
	248	xfs_fs_get_nextdqblk(
	249	struct super_block *sb,
	250	struct kqid *qid,
	251	struct qc_dqblk *qdq)
	252	{
	253	int ret;
	254	struct xfs_mount *mp = XFS_M(sb);
	255	xfs_dqid_t id;
	256
	257	if (!XFS_IS_QUOTA_RUNNING(mp))
	258	return -ENOSYS;
	259	if (!XFS_IS_QUOTA_ON(mp))
	260	return -ESRCH;
	261
	262	id = from_kqid(&init_user_ns, *qid);
	263	ret = xfs_qm_scall_getquota(mp, &id,
	264	xfs_quota_type(qid->type), qdq,
	265	XFS_QMOPT_DQNEXT);
	266	if (ret)
	267	return ret;
	268
	269	/* ID may be different, so convert back what we got */
	270	*qid = make_kqid(current_user_ns(), qid->type, id);
	271	return 0;
fcafb71b CH	272	}
	273
	274	STATIC int
c472b432	275	xfs_fs_set_dqblk(
fcafb71b	276	struct super_block *sb,
74a8a103	277	struct kqid qid,
14bf61ff	278	struct qc_dqblk *qdq)
fcafb71b CH	279	{
	280	struct xfs_mount *mp = XFS_M(sb);
	281
	282	if (sb->s_flags & MS_RDONLY)
	283	return -EROFS;
	284	if (!XFS_IS_QUOTA_RUNNING(mp))
	285	return -ENOSYS;
	286	if (!XFS_IS_QUOTA_ON(mp))
	287	return -ESRCH;
fcafb71b	288
2451337d	289	return xfs_qm_scall_setqlim(mp, from_kqid(&init_user_ns, qid),
14bf61ff	290	xfs_quota_type(qid.type), qdq);
fcafb71b CH	291	}
fcafb71b CH	292
0d54b217	293	const struct quotactl_ops xfs_quotactl_operations = {
5d3684c2	294	.get_state = xfs_fs_get_quota_state,
c14cad9e	295	.set_info = xfs_fs_set_info,
38e478c4 JK	296	.quota_enable = xfs_quota_enable,
38e478c4 JK	297	.quota_disable = xfs_quota_disable,
9da93f9b	298	.rm_xquota = xfs_fs_rm_xquota,
b9b2dd36	299	.get_dqblk = xfs_fs_get_dqblk,
296c24e2	300	.get_nextdqblk = xfs_fs_get_nextdqblk,
c472b432	301	.set_dqblk = xfs_fs_set_dqblk,
fcafb71b	302	};