[linux-block.git] / fs / xfs / xfs_quotaops.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (c) 2008, Christoph Hellwig
 * All Rights Reserved.
 */
#include "xfs.h"
#include "xfs_shared.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_icache.h"
#include "xfs_qm.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_def_quota	*defq)
{
	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_nblocks;
	tstate->nextents = ip->i_df.if_nextents;
	tstate->spc_timelimit = (u32)defq->blk.time;
	tstate->ino_timelimit = (u32)defq->ino.time;
	tstate->rt_spc_timelimit = (u32)defq->rtb.time;
	tstate->spc_warnlimit = 0;
	tstate->ino_warnlimit = 0;
	tstate->rt_spc_warnlimit = 0;
	if (tempqip)
		xfs_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_ON(mp))
		return 0;
	state->s_incoredqs = q->qi_dquots;
	if (XFS_IS_UQUOTA_ON(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_ON(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_ON(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, &q->qi_usr_default);
	xfs_qm_fill_state(&state->s_state[GRPQUOTA], mp, q->qi_gquotaip,
			  mp->m_sb.sb_gquotino, &q->qi_grp_default);
	xfs_qm_fill_state(&state->s_state[PRJQUOTA], mp, q->qi_pquotaip,
			  mp->m_sb.sb_pquotino, &q->qi_prj_default);
	return 0;
}

STATIC xfs_dqtype_t
xfs_quota_type(int type)
{
	switch (type) {
	case USRQUOTA:
		return XFS_DQTYPE_USER;
	case GRPQUOTA:
		return XFS_DQTYPE_GROUP;
	default:
		return XFS_DQTYPE_PROJ;
	}
}

#define XFS_QC_SETINFO_MASK (QC_TIMER_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_rdonly(sb))
		return -EROFS;
	if (!XFS_IS_QUOTA_ON(mp))
		return -ENOSYS;
	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_rdonly(sb))
		return -EROFS;
	if (!XFS_IS_QUOTA_ON(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_rdonly(sb))
		return -EROFS;
	if (!XFS_IS_QUOTA_ON(mp))
		return -ENOSYS;

	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_rdonly(sb))
		return -EROFS;

	if (XFS_IS_QUOTA_ON(mp))
		return -EINVAL;

	if (uflags & ~(FS_USER_QUOTA | FS_GROUP_QUOTA | FS_PROJ_QUOTA))
		return -EINVAL;

	if (uflags & FS_USER_QUOTA)
		flags |= XFS_QMOPT_UQUOTA;
	if (uflags & FS_GROUP_QUOTA)
		flags |= XFS_QMOPT_GQUOTA;
	if (uflags & FS_PROJ_QUOTA)
		flags |= XFS_QMOPT_PQUOTA;

	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_ON(mp))
		return -ENOSYS;

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

/* 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_ON(mp))
		return -ENOSYS;

	id = from_kqid(&init_user_ns, *qid);
	ret = xfs_qm_scall_getquota_next(mp, &id, xfs_quota_type(qid->type),
			qdq);
	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_rdonly(sb))
		return -EROFS;
	if (!XFS_IS_QUOTA_ON(mp))
		return -ENOSYS;

	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
0b61f8a4	1	// SPDX-License-Identifier: GPL-2.0
fcafb71b CH	2	/*
	3	* Copyright (c) 2008, Christoph Hellwig
	4	* All Rights Reserved.
fcafb71b CH	5	*/
fcafb71b CH	6	#include "xfs.h"
5467b34b	7	#include "xfs_shared.h"
6ca1c906	8	#include "xfs_format.h"
239880ef	9	#include "xfs_log_format.h"
7fd36c44	10	#include "xfs_trans_resv.h"
fcafb71b	11	#include "xfs_mount.h"
a4fbe6ab	12	#include "xfs_inode.h"
fcafb71b	13	#include "xfs_quota.h"
fcafb71b	14	#include "xfs_trans.h"
5d3684c2	15	#include "xfs_icache.h"
06f8e2d6	16	#include "xfs_qm.h"
fcafb71b CH	17
fcafb71b CH	18
5d3684c2 JK	19	static void
	20	xfs_qm_fill_state(
	21	struct qc_type_state *tstate,
	22	struct xfs_mount *mp,
	23	struct xfs_inode *ip,
e850301f ES	24	xfs_ino_t ino,
e850301f ES	25	struct xfs_def_quota *defq)
fcafb71b	26	{
8d077f5b	27	bool tempqip = false;
5d3684c2 JK	28
	29	tstate->ino = ino;
	30	if (!ip && ino == NULLFSINO)
	31	return;
	32	if (!ip) {
	33	if (xfs_iget(mp, NULL, ino, 0, 0, &ip))
	34	return;
	35	tempqip = true;
fcafb71b	36	}
5d3684c2	37	tstate->flags \|= QCI_SYSFILE;
6e73a545	38	tstate->blocks = ip->i_nblocks;
daf83964	39	tstate->nextents = ip->i_df.if_nextents;
438769e3 DW	40	tstate->spc_timelimit = (u32)defq->blk.time;
	41	tstate->ino_timelimit = (u32)defq->ino.time;
	42	tstate->rt_spc_timelimit = (u32)defq->rtb.time;
5cc21e52 CH	43	tstate->spc_warnlimit = 0;
	44	tstate->ino_warnlimit = 0;
	45	tstate->rt_spc_warnlimit = 0;
5d3684c2	46	if (tempqip)
44a8736b	47	xfs_irele(ip);
fcafb71b CH	48	}
fcafb71b CH	49
5d3684c2 JK	50	/*
	51	* Return quota status information, such as enforcements, quota file inode
	52	* numbers etc.
	53	*/
	54	static int
	55	xfs_fs_get_quota_state(
fcafb71b	56	struct super_block *sb,
5d3684c2	57	struct qc_state *state)
fcafb71b	58	{
5d3684c2 JK	59	struct xfs_mount *mp = XFS_M(sb);
5d3684c2 JK	60	struct xfs_quotainfo *q = mp->m_quotainfo;
fcafb71b	61
5d3684c2	62	memset(state, 0, sizeof(*state));
149e53af	63	if (!XFS_IS_QUOTA_ON(mp))
5d3684c2 JK	64	return 0;
5d3684c2 JK	65	state->s_incoredqs = q->qi_dquots;
149e53af	66	if (XFS_IS_UQUOTA_ON(mp))
5d3684c2 JK	67	state->s_state[USRQUOTA].flags \|= QCI_ACCT_ENABLED;
	68	if (XFS_IS_UQUOTA_ENFORCED(mp))
	69	state->s_state[USRQUOTA].flags \|= QCI_LIMITS_ENFORCED;
149e53af	70	if (XFS_IS_GQUOTA_ON(mp))
5d3684c2 JK	71	state->s_state[GRPQUOTA].flags \|= QCI_ACCT_ENABLED;
	72	if (XFS_IS_GQUOTA_ENFORCED(mp))
	73	state->s_state[GRPQUOTA].flags \|= QCI_LIMITS_ENFORCED;
149e53af	74	if (XFS_IS_PQUOTA_ON(mp))
5d3684c2 JK	75	state->s_state[PRJQUOTA].flags \|= QCI_ACCT_ENABLED;
	76	if (XFS_IS_PQUOTA_ENFORCED(mp))
	77	state->s_state[PRJQUOTA].flags \|= QCI_LIMITS_ENFORCED;
	78
	79	xfs_qm_fill_state(&state->s_state[USRQUOTA], mp, q->qi_uquotaip,
e850301f	80	mp->m_sb.sb_uquotino, &q->qi_usr_default);
5d3684c2	81	xfs_qm_fill_state(&state->s_state[GRPQUOTA], mp, q->qi_gquotaip,
e850301f	82	mp->m_sb.sb_gquotino, &q->qi_grp_default);
5d3684c2	83	xfs_qm_fill_state(&state->s_state[PRJQUOTA], mp, q->qi_pquotaip,
e850301f	84	mp->m_sb.sb_pquotino, &q->qi_prj_default);
5d3684c2	85	return 0;
fcafb71b CH	86	}
fcafb71b CH	87
1a7ed271	88	STATIC xfs_dqtype_t
5d3684c2	89	xfs_quota_type(int type)
5d5e3d57	90	{
5d3684c2 JK	91	switch (type) {
5d3684c2 JK	92	case USRQUOTA:
8cd4901d	93	return XFS_DQTYPE_USER;
5d3684c2	94	case GRPQUOTA:
8cd4901d	95	return XFS_DQTYPE_GROUP;
5d3684c2	96	default:
8cd4901d	97	return XFS_DQTYPE_PROJ;
5d3684c2	98	}
5d5e3d57 CS	99	}
5d5e3d57 CS	100
5349b2af	101	#define XFS_QC_SETINFO_MASK (QC_TIMER_MASK)
c14cad9e JK	102
	103	/*
	104	* Adjust quota timers & warnings
	105	*/
	106	static int
	107	xfs_fs_set_info(
	108	struct super_block *sb,
	109	int type,
	110	struct qc_info *info)
	111	{
8d077f5b ES	112	struct xfs_mount *mp = XFS_M(sb);
8d077f5b ES	113	struct qc_dqblk newlim;
c14cad9e	114
bc98a42c	115	if (sb_rdonly(sb))
c14cad9e	116	return -EROFS;
c14cad9e	117	if (!XFS_IS_QUOTA_ON(mp))
149e53af	118	return -ENOSYS;
c14cad9e JK	119	if (info->i_fieldmask & ~XFS_QC_SETINFO_MASK)
	120	return -EINVAL;
	121	if ((info->i_fieldmask & XFS_QC_SETINFO_MASK) == 0)
	122	return 0;
	123
	124	newlim.d_fieldmask = info->i_fieldmask;
	125	newlim.d_spc_timer = info->i_spc_timelimit;
	126	newlim.d_ino_timer = info->i_ino_timelimit;
	127	newlim.d_rt_spc_timer = info->i_rt_spc_timelimit;
	128	newlim.d_ino_warns = info->i_ino_warnlimit;
	129	newlim.d_spc_warns = info->i_spc_warnlimit;
	130	newlim.d_rt_spc_warns = info->i_rt_spc_warnlimit;
	131
	132	return xfs_qm_scall_setqlim(mp, 0, xfs_quota_type(type), &newlim);
	133	}
	134
38e478c4 JK	135	static unsigned int
38e478c4 JK	136	xfs_quota_flags(unsigned int uflags)
fcafb71b	137	{
38e478c4	138	unsigned int flags = 0;
fcafb71b	139
ade7ce31	140	if (uflags & FS_QUOTA_UDQ_ACCT)
fcafb71b	141	flags \|= XFS_UQUOTA_ACCT;
ade7ce31	142	if (uflags & FS_QUOTA_PDQ_ACCT)
fcafb71b	143	flags \|= XFS_PQUOTA_ACCT;
ade7ce31	144	if (uflags & FS_QUOTA_GDQ_ACCT)
fcafb71b	145	flags \|= XFS_GQUOTA_ACCT;
ade7ce31	146	if (uflags & FS_QUOTA_UDQ_ENFD)
fcafb71b	147	flags \|= XFS_UQUOTA_ENFD;
83e782e1 CS	148	if (uflags & FS_QUOTA_GDQ_ENFD)
	149	flags \|= XFS_GQUOTA_ENFD;
	150	if (uflags & FS_QUOTA_PDQ_ENFD)
	151	flags \|= XFS_PQUOTA_ENFD;
fcafb71b	152
38e478c4 JK	153	return flags;
	154	}
	155
	156	STATIC int
	157	xfs_quota_enable(
	158	struct super_block *sb,
	159	unsigned int uflags)
	160	{
	161	struct xfs_mount *mp = XFS_M(sb);
	162
bc98a42c	163	if (sb_rdonly(sb))
38e478c4	164	return -EROFS;
149e53af	165	if (!XFS_IS_QUOTA_ON(mp))
38e478c4 JK	166	return -ENOSYS;
	167
	168	return xfs_qm_scall_quotaon(mp, xfs_quota_flags(uflags));
	169	}
	170
	171	STATIC int
	172	xfs_quota_disable(
	173	struct super_block *sb,
	174	unsigned int uflags)
	175	{
	176	struct xfs_mount *mp = XFS_M(sb);
	177
bc98a42c	178	if (sb_rdonly(sb))
38e478c4	179	return -EROFS;
38e478c4	180	if (!XFS_IS_QUOTA_ON(mp))
149e53af	181	return -ENOSYS;
fcafb71b	182
38e478c4	183	return xfs_qm_scall_quotaoff(mp, xfs_quota_flags(uflags));
fcafb71b CH	184	}
fcafb71b CH	185
9da93f9b ES	186	STATIC int
	187	xfs_fs_rm_xquota(
	188	struct super_block *sb,
	189	unsigned int uflags)
	190	{
	191	struct xfs_mount *mp = XFS_M(sb);
	192	unsigned int flags = 0;
2451337d	193
bc98a42c	194	if (sb_rdonly(sb))
9da93f9b ES	195	return -EROFS;
	196
	197	if (XFS_IS_QUOTA_ON(mp))
	198	return -EINVAL;
	199
3dd4d40b JK	200	if (uflags & ~(FS_USER_QUOTA \| FS_GROUP_QUOTA \| FS_PROJ_QUOTA))
	201	return -EINVAL;
	202
9da93f9b	203	if (uflags & FS_USER_QUOTA)
41ed4a5f	204	flags \|= XFS_QMOPT_UQUOTA;
9da93f9b	205	if (uflags & FS_GROUP_QUOTA)
41ed4a5f	206	flags \|= XFS_QMOPT_GQUOTA;
74dc93a9	207	if (uflags & FS_PROJ_QUOTA)
41ed4a5f	208	flags \|= XFS_QMOPT_PQUOTA;
9da93f9b	209
2451337d DC	210	return xfs_qm_scall_trunc_qfiles(mp, flags);
2451337d DC	211	}
9da93f9b	212
fcafb71b	213	STATIC int
b9b2dd36	214	xfs_fs_get_dqblk(
fcafb71b	215	struct super_block *sb,
74a8a103	216	struct kqid qid,
14bf61ff	217	struct qc_dqblk *qdq)
fcafb71b CH	218	{
fcafb71b CH	219	struct xfs_mount *mp = XFS_M(sb);
296c24e2	220	xfs_dqid_t id;
fcafb71b	221
fcafb71b	222	if (!XFS_IS_QUOTA_ON(mp))
149e53af	223	return -ENOSYS;
fcafb71b	224
296c24e2	225	id = from_kqid(&init_user_ns, qid);
2e330e76	226	return xfs_qm_scall_getquota(mp, id, xfs_quota_type(qid.type), qdq);
296c24e2 ES	227	}
	228
	229	/* Return quota info for active quota >= this qid */
	230	STATIC int
	231	xfs_fs_get_nextdqblk(
	232	struct super_block *sb,
	233	struct kqid *qid,
	234	struct qc_dqblk *qdq)
	235	{
	236	int ret;
	237	struct xfs_mount *mp = XFS_M(sb);
	238	xfs_dqid_t id;
	239
296c24e2	240	if (!XFS_IS_QUOTA_ON(mp))
149e53af	241	return -ENOSYS;
296c24e2 ES	242
296c24e2 ES	243	id = from_kqid(&init_user_ns, *qid);
2e330e76 DW	244	ret = xfs_qm_scall_getquota_next(mp, &id, xfs_quota_type(qid->type),
2e330e76 DW	245	qdq);
296c24e2 ES	246	if (ret)
	247	return ret;
	248
	249	/* ID may be different, so convert back what we got */
	250	*qid = make_kqid(current_user_ns(), qid->type, id);
	251	return 0;
fcafb71b CH	252	}
	253
	254	STATIC int
c472b432	255	xfs_fs_set_dqblk(
fcafb71b	256	struct super_block *sb,
74a8a103	257	struct kqid qid,
14bf61ff	258	struct qc_dqblk *qdq)
fcafb71b CH	259	{
	260	struct xfs_mount *mp = XFS_M(sb);
	261
bc98a42c	262	if (sb_rdonly(sb))
fcafb71b	263	return -EROFS;
fcafb71b	264	if (!XFS_IS_QUOTA_ON(mp))
149e53af	265	return -ENOSYS;
fcafb71b	266
2451337d	267	return xfs_qm_scall_setqlim(mp, from_kqid(&init_user_ns, qid),
14bf61ff	268	xfs_quota_type(qid.type), qdq);
fcafb71b CH	269	}
fcafb71b CH	270
0d54b217	271	const struct quotactl_ops xfs_quotactl_operations = {
5d3684c2	272	.get_state = xfs_fs_get_quota_state,
c14cad9e	273	.set_info = xfs_fs_set_info,
38e478c4 JK	274	.quota_enable = xfs_quota_enable,
38e478c4 JK	275	.quota_disable = xfs_quota_disable,
9da93f9b	276	.rm_xquota = xfs_fs_rm_xquota,
b9b2dd36	277	.get_dqblk = xfs_fs_get_dqblk,
296c24e2	278	.get_nextdqblk = xfs_fs_get_nextdqblk,
c472b432	279	.set_dqblk = xfs_fs_set_dqblk,
fcafb71b	280	};