xfs_quotaops.c 7.0 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
/*
 * 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"
19
#include "xfs_format.h"
20
#include "xfs_log_format.h"
21
#include "xfs_trans_resv.h"
22
#include "xfs_mount.h"
23
#include "xfs_inode.h"
24 25
#include "xfs_quota.h"
#include "xfs_trans.h"
26 27
#include "xfs_trace.h"
#include "xfs_icache.h"
28
#include "xfs_qm.h"
29 30 31
#include <linux/quota.h>


32 33 34 35 36 37
static void
xfs_qm_fill_state(
	struct qc_type_state	*tstate,
	struct xfs_mount	*mp,
	struct xfs_inode	*ip,
	xfs_ino_t		ino)
38
{
39 40 41 42 43 44 45 46 47 48
	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;
49
	}
50 51 52 53 54 55 56 57 58 59 60
	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);
61 62
}

63 64 65 66 67 68
/*
 * Return quota status information, such as enforcements, quota file inode
 * numbers etc.
 */
static int
xfs_fs_get_quota_state(
69
	struct super_block	*sb,
70
	struct qc_state		*state)
71
{
72 73
	struct xfs_mount *mp = XFS_M(sb);
	struct xfs_quotainfo *q = mp->m_quotainfo;
74

75
	memset(state, 0, sizeof(*state));
76
	if (!XFS_IS_QUOTA_RUNNING(mp))
77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98
		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;
99 100
}

101
STATIC int
102
xfs_quota_type(int type)
103
{
104 105 106 107 108 109 110 111
	switch (type) {
	case USRQUOTA:
		return XFS_DQ_USER;
	case GRPQUOTA:
		return XFS_DQ_GROUP;
	default:
		return XFS_DQ_PROJ;
	}
112 113
}

J
Jan Kara 已提交
114 115 116 117 118 119 120 121 122 123 124 125 126 127
#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;

128
	if (sb_rdonly(sb))
J
Jan Kara 已提交
129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149
		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);
}

150 151
static unsigned int
xfs_quota_flags(unsigned int uflags)
152
{
153
	unsigned int flags = 0;
154

155
	if (uflags & FS_QUOTA_UDQ_ACCT)
156
		flags |= XFS_UQUOTA_ACCT;
157
	if (uflags & FS_QUOTA_PDQ_ACCT)
158
		flags |= XFS_PQUOTA_ACCT;
159
	if (uflags & FS_QUOTA_GDQ_ACCT)
160
		flags |= XFS_GQUOTA_ACCT;
161
	if (uflags & FS_QUOTA_UDQ_ENFD)
162
		flags |= XFS_UQUOTA_ENFD;
163 164 165 166
	if (uflags & FS_QUOTA_GDQ_ENFD)
		flags |= XFS_GQUOTA_ENFD;
	if (uflags & FS_QUOTA_PDQ_ENFD)
		flags |= XFS_PQUOTA_ENFD;
167

168 169 170 171 172 173 174 175 176 177
	return flags;
}

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

178
	if (sb_rdonly(sb))
179 180 181 182 183 184 185 186 187 188 189 190 191 192
		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);

193
	if (sb_rdonly(sb))
194 195 196 197 198
		return -EROFS;
	if (!XFS_IS_QUOTA_RUNNING(mp))
		return -ENOSYS;
	if (!XFS_IS_QUOTA_ON(mp))
		return -EINVAL;
199

200
	return xfs_qm_scall_quotaoff(mp, xfs_quota_flags(uflags));
201 202
}

E
Eric Sandeen 已提交
203 204 205 206 207 208 209
STATIC int
xfs_fs_rm_xquota(
	struct super_block	*sb,
	unsigned int		uflags)
{
	struct xfs_mount	*mp = XFS_M(sb);
	unsigned int		flags = 0;
D
Dave Chinner 已提交
210

211
	if (sb_rdonly(sb))
E
Eric Sandeen 已提交
212 213 214 215 216 217 218 219 220
		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;
221
	if (uflags & FS_PROJ_QUOTA)
E
Eric Sandeen 已提交
222 223
		flags |= XFS_DQ_PROJ;

D
Dave Chinner 已提交
224 225
	return xfs_qm_scall_trunc_qfiles(mp, flags);
}
E
Eric Sandeen 已提交
226

227
STATIC int
C
Christoph Hellwig 已提交
228
xfs_fs_get_dqblk(
229
	struct super_block	*sb,
E
Eric W. Biederman 已提交
230
	struct kqid		qid,
231
	struct qc_dqblk		*qdq)
232 233
{
	struct xfs_mount	*mp = XFS_M(sb);
234
	xfs_dqid_t		id;
235 236 237 238 239 240

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

241
	id = from_kqid(&init_user_ns, qid);
242
	return xfs_qm_scall_getquota(mp, id, xfs_quota_type(qid.type), qdq);
243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261
}

/* 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);
262 263
	ret = xfs_qm_scall_getquota_next(mp, &id, xfs_quota_type(qid->type),
			qdq);
264 265 266 267 268 269
	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;
270 271 272
}

STATIC int
C
Christoph Hellwig 已提交
273
xfs_fs_set_dqblk(
274
	struct super_block	*sb,
E
Eric W. Biederman 已提交
275
	struct kqid		qid,
276
	struct qc_dqblk		*qdq)
277 278 279
{
	struct xfs_mount	*mp = XFS_M(sb);

280
	if (sb_rdonly(sb))
281 282 283 284 285 286
		return -EROFS;
	if (!XFS_IS_QUOTA_RUNNING(mp))
		return -ENOSYS;
	if (!XFS_IS_QUOTA_ON(mp))
		return -ESRCH;

D
Dave Chinner 已提交
287
	return xfs_qm_scall_setqlim(mp, from_kqid(&init_user_ns, qid),
288
				     xfs_quota_type(qid.type), qdq);
289 290
}

291
const struct quotactl_ops xfs_quotactl_operations = {
292
	.get_state		= xfs_fs_get_quota_state,
J
Jan Kara 已提交
293
	.set_info		= xfs_fs_set_info,
294 295
	.quota_enable		= xfs_quota_enable,
	.quota_disable		= xfs_quota_disable,
E
Eric Sandeen 已提交
296
	.rm_xquota		= xfs_fs_rm_xquota,
C
Christoph Hellwig 已提交
297
	.get_dqblk		= xfs_fs_get_dqblk,
298
	.get_nextdqblk		= xfs_fs_get_nextdqblk,
C
Christoph Hellwig 已提交
299
	.set_dqblk		= xfs_fs_set_dqblk,
300
};