blob: 86ded7375c216d55fe26eb1dfd6ff366ce1fa29d [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Quota code necessary even when VFS quota support is not compiled
3 * into the kernel. The interesting stuff is over in dquot.c, here
4 * we have symbols for initial quotactl(2) handling, the sysctl(2)
5 * variables, etc - things needed even when quota support disabled.
6 */
7
8#include <linux/fs.h>
9#include <linux/namei.h>
10#include <linux/slab.h>
11#include <asm/current.h>
Jeff Liuf3da9312012-05-28 23:40:17 +080012#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070013#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070014#include <linux/security.h>
15#include <linux/syscalls.h>
Randy Dunlap16f7e0f2006-01-11 12:17:46 -080016#include <linux/capability.h>
Adrian Bunkbe586ba2005-11-07 00:59:35 -080017#include <linux/quotaops.h>
Vasily Tarasovb7163952007-07-15 23:41:12 -070018#include <linux/types.h>
Christoph Hellwig8c4e4ac2010-02-16 03:44:51 -050019#include <linux/writeback.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020
Christoph Hellwigc988afb2010-02-16 03:44:50 -050021static int check_quotactl_permission(struct super_block *sb, int type, int cmd,
22 qid_t id)
Linus Torvalds1da177e2005-04-16 15:20:36 -070023{
Christoph Hellwigc988afb2010-02-16 03:44:50 -050024 switch (cmd) {
25 /* these commands do not require any special privilegues */
26 case Q_GETFMT:
27 case Q_SYNC:
28 case Q_GETINFO:
29 case Q_XGETQSTAT:
Chandra Seetharamanaf30cb42013-08-06 17:27:07 -050030 case Q_XGETQSTATV:
Christoph Hellwigc988afb2010-02-16 03:44:50 -050031 case Q_XQUOTASYNC:
32 break;
33 /* allow to query information for dquots we "own" */
34 case Q_GETQUOTA:
35 case Q_XGETQUOTA:
Eric W. Biederman74a8a102012-09-16 02:07:49 -070036 if ((type == USRQUOTA && uid_eq(current_euid(), make_kuid(current_user_ns(), id))) ||
37 (type == GRPQUOTA && in_egroup_p(make_kgid(current_user_ns(), id))))
Christoph Hellwigc988afb2010-02-16 03:44:50 -050038 break;
39 /*FALLTHROUGH*/
40 default:
Linus Torvalds1da177e2005-04-16 15:20:36 -070041 if (!capable(CAP_SYS_ADMIN))
42 return -EPERM;
43 }
44
Christoph Hellwigc988afb2010-02-16 03:44:50 -050045 return security_quotactl(cmd, type, id, sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -070046}
47
Al Viro01a05b32010-03-23 06:06:58 -040048static void quota_sync_one(struct super_block *sb, void *arg)
49{
Jan Kara2c5f6482014-09-30 10:43:09 +020050 int type = *(int *)arg;
51
52 if (sb->s_qcop && sb->s_qcop->quota_sync &&
53 (sb->s_quota_types & (1 << type)))
54 sb->s_qcop->quota_sync(sb, type);
Al Viro01a05b32010-03-23 06:06:58 -040055}
56
Christoph Hellwig6ae09572010-02-16 03:44:49 -050057static int quota_sync_all(int type)
Linus Torvalds1da177e2005-04-16 15:20:36 -070058{
Christoph Hellwig6ae09572010-02-16 03:44:49 -050059 int ret;
60
61 if (type >= MAXQUOTAS)
62 return -EINVAL;
63 ret = security_quotactl(Q_SYNC, type, 0, NULL);
Al Viro01a05b32010-03-23 06:06:58 -040064 if (!ret)
65 iterate_supers(quota_sync_one, &type);
66 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -070067}
68
Jan Karad3b86322014-10-08 16:07:12 +020069unsigned int qtype_enforce_flag(int type)
70{
71 switch (type) {
72 case USRQUOTA:
73 return FS_QUOTA_UDQ_ENFD;
74 case GRPQUOTA:
75 return FS_QUOTA_GDQ_ENFD;
76 case PRJQUOTA:
77 return FS_QUOTA_PDQ_ENFD;
78 }
79 return 0;
80}
81
Christoph Hellwigc411e5f2010-02-16 03:44:47 -050082static int quota_quotaon(struct super_block *sb, int type, int cmd, qid_t id,
Jan Karaf00c9e42010-09-15 17:38:58 +020083 struct path *path)
Christoph Hellwigc411e5f2010-02-16 03:44:47 -050084{
Jan Karaaaa3dae2014-10-08 18:35:31 +020085 if (!sb->s_qcop->quota_on && !sb->s_qcop->quota_enable)
Jan Karaf00c9e42010-09-15 17:38:58 +020086 return -ENOSYS;
Jan Karad3b86322014-10-08 16:07:12 +020087 if (sb->s_qcop->quota_enable)
88 return sb->s_qcop->quota_enable(sb, qtype_enforce_flag(type));
Jan Karaf00c9e42010-09-15 17:38:58 +020089 if (IS_ERR(path))
90 return PTR_ERR(path);
91 return sb->s_qcop->quota_on(sb, type, id, path);
Christoph Hellwigc411e5f2010-02-16 03:44:47 -050092}
93
Jan Karad3b86322014-10-08 16:07:12 +020094static int quota_quotaoff(struct super_block *sb, int type)
95{
96 if (!sb->s_qcop->quota_off && !sb->s_qcop->quota_disable)
97 return -ENOSYS;
98 if (sb->s_qcop->quota_disable)
99 return sb->s_qcop->quota_disable(sb, qtype_enforce_flag(type));
100 return sb->s_qcop->quota_off(sb, type);
101}
102
Christoph Hellwigc411e5f2010-02-16 03:44:47 -0500103static int quota_getfmt(struct super_block *sb, int type, void __user *addr)
104{
105 __u32 fmt;
106
Niu Yawei606cdcc2014-06-04 12:19:12 +0800107 mutex_lock(&sb_dqopt(sb)->dqonoff_mutex);
Christoph Hellwigc411e5f2010-02-16 03:44:47 -0500108 if (!sb_has_quota_active(sb, type)) {
Niu Yawei606cdcc2014-06-04 12:19:12 +0800109 mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
Christoph Hellwigc411e5f2010-02-16 03:44:47 -0500110 return -ESRCH;
111 }
112 fmt = sb_dqopt(sb)->info[type].dqi_format->qf_fmt_id;
Niu Yawei606cdcc2014-06-04 12:19:12 +0800113 mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
Christoph Hellwigc411e5f2010-02-16 03:44:47 -0500114 if (copy_to_user(addr, &fmt, sizeof(fmt)))
115 return -EFAULT;
116 return 0;
117}
118
119static int quota_getinfo(struct super_block *sb, int type, void __user *addr)
120{
Jan Kara0a2403392014-11-19 00:42:09 +0100121 struct qc_state state;
122 struct qc_type_state *tstate;
123 struct if_dqinfo uinfo;
Christoph Hellwigc411e5f2010-02-16 03:44:47 -0500124 int ret;
125
Jan Kara0a2403392014-11-19 00:42:09 +0100126 /* This checks whether qc_state has enough entries... */
127 BUILD_BUG_ON(MAXQUOTAS > XQM_MAXQUOTAS);
128 if (!sb->s_qcop->get_state)
Christoph Hellwigf450d4f2010-02-16 03:44:48 -0500129 return -ENOSYS;
Jan Kara0a2403392014-11-19 00:42:09 +0100130 ret = sb->s_qcop->get_state(sb, &state);
131 if (ret)
132 return ret;
133 tstate = state.s_state + type;
134 if (!(tstate->flags & QCI_ACCT_ENABLED))
135 return -ESRCH;
136 memset(&uinfo, 0, sizeof(uinfo));
137 uinfo.dqi_bgrace = tstate->spc_timelimit;
138 uinfo.dqi_igrace = tstate->ino_timelimit;
139 if (tstate->flags & QCI_SYSFILE)
140 uinfo.dqi_flags |= DQF_SYS_FILE;
141 if (tstate->flags & QCI_ROOT_SQUASH)
142 uinfo.dqi_flags |= DQF_ROOT_SQUASH;
143 uinfo.dqi_valid = IIF_ALL;
144 if (!ret && copy_to_user(addr, &uinfo, sizeof(uinfo)))
Christoph Hellwigc411e5f2010-02-16 03:44:47 -0500145 return -EFAULT;
146 return ret;
147}
148
149static int quota_setinfo(struct super_block *sb, int type, void __user *addr)
150{
151 struct if_dqinfo info;
Jan Kara5eacb2a2014-12-16 12:03:51 +0100152 struct qc_info qinfo;
Christoph Hellwigc411e5f2010-02-16 03:44:47 -0500153
154 if (copy_from_user(&info, addr, sizeof(info)))
155 return -EFAULT;
Christoph Hellwigf450d4f2010-02-16 03:44:48 -0500156 if (!sb->s_qcop->set_info)
157 return -ENOSYS;
Jan Kara5eacb2a2014-12-16 12:03:51 +0100158 if (info.dqi_valid & ~(IIF_FLAGS | IIF_BGRACE | IIF_IGRACE))
159 return -EINVAL;
160 memset(&qinfo, 0, sizeof(qinfo));
161 if (info.dqi_valid & IIF_FLAGS) {
162 if (info.dqi_flags & ~DQF_SETINFO_MASK)
163 return -EINVAL;
164 if (info.dqi_flags & DQF_ROOT_SQUASH)
165 qinfo.i_flags |= QCI_ROOT_SQUASH;
166 qinfo.i_fieldmask |= QC_FLAGS;
167 }
168 if (info.dqi_valid & IIF_BGRACE) {
169 qinfo.i_spc_timelimit = info.dqi_bgrace;
170 qinfo.i_fieldmask |= QC_SPC_TIMER;
171 }
172 if (info.dqi_valid & IIF_IGRACE) {
173 qinfo.i_ino_timelimit = info.dqi_igrace;
174 qinfo.i_fieldmask |= QC_INO_TIMER;
175 }
176 return sb->s_qcop->set_info(sb, type, &qinfo);
Christoph Hellwigc411e5f2010-02-16 03:44:47 -0500177}
178
Jan Kara14bf61f2014-10-09 16:03:13 +0200179static inline qsize_t qbtos(qsize_t blocks)
180{
181 return blocks << QIF_DQBLKSIZE_BITS;
182}
183
184static inline qsize_t stoqb(qsize_t space)
185{
186 return (space + QIF_DQBLKSIZE - 1) >> QIF_DQBLKSIZE_BITS;
187}
188
189static void copy_to_if_dqblk(struct if_dqblk *dst, struct qc_dqblk *src)
Christoph Hellwigb9b2dd32010-05-06 17:04:58 -0400190{
Dan Carpenter18da65e2013-11-01 13:21:54 +0300191 memset(dst, 0, sizeof(*dst));
Jan Kara14bf61f2014-10-09 16:03:13 +0200192 dst->dqb_bhardlimit = stoqb(src->d_spc_hardlimit);
193 dst->dqb_bsoftlimit = stoqb(src->d_spc_softlimit);
194 dst->dqb_curspace = src->d_space;
Christoph Hellwigb9b2dd32010-05-06 17:04:58 -0400195 dst->dqb_ihardlimit = src->d_ino_hardlimit;
196 dst->dqb_isoftlimit = src->d_ino_softlimit;
Jan Kara14bf61f2014-10-09 16:03:13 +0200197 dst->dqb_curinodes = src->d_ino_count;
198 dst->dqb_btime = src->d_spc_timer;
199 dst->dqb_itime = src->d_ino_timer;
Christoph Hellwigb9b2dd32010-05-06 17:04:58 -0400200 dst->dqb_valid = QIF_ALL;
201}
202
Christoph Hellwigc411e5f2010-02-16 03:44:47 -0500203static int quota_getquota(struct super_block *sb, int type, qid_t id,
204 void __user *addr)
205{
Eric W. Biederman74a8a102012-09-16 02:07:49 -0700206 struct kqid qid;
Jan Kara14bf61f2014-10-09 16:03:13 +0200207 struct qc_dqblk fdq;
Christoph Hellwigc411e5f2010-02-16 03:44:47 -0500208 struct if_dqblk idq;
209 int ret;
210
Christoph Hellwigf450d4f2010-02-16 03:44:48 -0500211 if (!sb->s_qcop->get_dqblk)
212 return -ENOSYS;
Eric W. Biederman74a8a102012-09-16 02:07:49 -0700213 qid = make_kqid(current_user_ns(), type, id);
214 if (!qid_valid(qid))
215 return -EINVAL;
216 ret = sb->s_qcop->get_dqblk(sb, qid, &fdq);
Christoph Hellwigc411e5f2010-02-16 03:44:47 -0500217 if (ret)
218 return ret;
Christoph Hellwigb9b2dd32010-05-06 17:04:58 -0400219 copy_to_if_dqblk(&idq, &fdq);
Christoph Hellwigc411e5f2010-02-16 03:44:47 -0500220 if (copy_to_user(addr, &idq, sizeof(idq)))
221 return -EFAULT;
222 return 0;
223}
224
Jan Kara14bf61f2014-10-09 16:03:13 +0200225static void copy_from_if_dqblk(struct qc_dqblk *dst, struct if_dqblk *src)
Christoph Hellwigc472b432010-05-06 17:05:17 -0400226{
Jan Kara14bf61f2014-10-09 16:03:13 +0200227 dst->d_spc_hardlimit = qbtos(src->dqb_bhardlimit);
228 dst->d_spc_softlimit = qbtos(src->dqb_bsoftlimit);
229 dst->d_space = src->dqb_curspace;
Christoph Hellwigc472b432010-05-06 17:05:17 -0400230 dst->d_ino_hardlimit = src->dqb_ihardlimit;
231 dst->d_ino_softlimit = src->dqb_isoftlimit;
Jan Kara14bf61f2014-10-09 16:03:13 +0200232 dst->d_ino_count = src->dqb_curinodes;
233 dst->d_spc_timer = src->dqb_btime;
234 dst->d_ino_timer = src->dqb_itime;
Christoph Hellwigc472b432010-05-06 17:05:17 -0400235
236 dst->d_fieldmask = 0;
237 if (src->dqb_valid & QIF_BLIMITS)
Jan Kara14bf61f2014-10-09 16:03:13 +0200238 dst->d_fieldmask |= QC_SPC_SOFT | QC_SPC_HARD;
Christoph Hellwigc472b432010-05-06 17:05:17 -0400239 if (src->dqb_valid & QIF_SPACE)
Jan Kara14bf61f2014-10-09 16:03:13 +0200240 dst->d_fieldmask |= QC_SPACE;
Christoph Hellwigc472b432010-05-06 17:05:17 -0400241 if (src->dqb_valid & QIF_ILIMITS)
Jan Kara14bf61f2014-10-09 16:03:13 +0200242 dst->d_fieldmask |= QC_INO_SOFT | QC_INO_HARD;
Christoph Hellwigc472b432010-05-06 17:05:17 -0400243 if (src->dqb_valid & QIF_INODES)
Jan Kara14bf61f2014-10-09 16:03:13 +0200244 dst->d_fieldmask |= QC_INO_COUNT;
Christoph Hellwigc472b432010-05-06 17:05:17 -0400245 if (src->dqb_valid & QIF_BTIME)
Jan Kara14bf61f2014-10-09 16:03:13 +0200246 dst->d_fieldmask |= QC_SPC_TIMER;
Christoph Hellwigc472b432010-05-06 17:05:17 -0400247 if (src->dqb_valid & QIF_ITIME)
Jan Kara14bf61f2014-10-09 16:03:13 +0200248 dst->d_fieldmask |= QC_INO_TIMER;
Christoph Hellwigc472b432010-05-06 17:05:17 -0400249}
250
Christoph Hellwigc411e5f2010-02-16 03:44:47 -0500251static int quota_setquota(struct super_block *sb, int type, qid_t id,
252 void __user *addr)
253{
Jan Kara14bf61f2014-10-09 16:03:13 +0200254 struct qc_dqblk fdq;
Christoph Hellwigc411e5f2010-02-16 03:44:47 -0500255 struct if_dqblk idq;
Eric W. Biederman74a8a102012-09-16 02:07:49 -0700256 struct kqid qid;
Christoph Hellwigc411e5f2010-02-16 03:44:47 -0500257
258 if (copy_from_user(&idq, addr, sizeof(idq)))
259 return -EFAULT;
Christoph Hellwigf450d4f2010-02-16 03:44:48 -0500260 if (!sb->s_qcop->set_dqblk)
261 return -ENOSYS;
Eric W. Biederman74a8a102012-09-16 02:07:49 -0700262 qid = make_kqid(current_user_ns(), type, id);
263 if (!qid_valid(qid))
264 return -EINVAL;
Christoph Hellwigc472b432010-05-06 17:05:17 -0400265 copy_from_if_dqblk(&fdq, &idq);
Eric W. Biederman74a8a102012-09-16 02:07:49 -0700266 return sb->s_qcop->set_dqblk(sb, qid, &fdq);
Christoph Hellwigc411e5f2010-02-16 03:44:47 -0500267}
268
Jan Kara38e478c2014-10-08 15:56:21 +0200269static int quota_enable(struct super_block *sb, void __user *addr)
Christoph Hellwigc411e5f2010-02-16 03:44:47 -0500270{
271 __u32 flags;
272
273 if (copy_from_user(&flags, addr, sizeof(flags)))
274 return -EFAULT;
Jan Kara38e478c2014-10-08 15:56:21 +0200275 if (!sb->s_qcop->quota_enable)
Christoph Hellwigf450d4f2010-02-16 03:44:48 -0500276 return -ENOSYS;
Jan Kara38e478c2014-10-08 15:56:21 +0200277 return sb->s_qcop->quota_enable(sb, flags);
278}
279
280static int quota_disable(struct super_block *sb, void __user *addr)
281{
282 __u32 flags;
283
284 if (copy_from_user(&flags, addr, sizeof(flags)))
285 return -EFAULT;
286 if (!sb->s_qcop->quota_disable)
287 return -ENOSYS;
288 return sb->s_qcop->quota_disable(sb, flags);
Christoph Hellwigc411e5f2010-02-16 03:44:47 -0500289}
290
Jan Karabc230e42014-11-19 16:17:45 +0100291static int quota_state_to_flags(struct qc_state *state)
292{
293 int flags = 0;
294
295 if (state->s_state[USRQUOTA].flags & QCI_ACCT_ENABLED)
296 flags |= FS_QUOTA_UDQ_ACCT;
297 if (state->s_state[USRQUOTA].flags & QCI_LIMITS_ENFORCED)
298 flags |= FS_QUOTA_UDQ_ENFD;
299 if (state->s_state[GRPQUOTA].flags & QCI_ACCT_ENABLED)
300 flags |= FS_QUOTA_GDQ_ACCT;
301 if (state->s_state[GRPQUOTA].flags & QCI_LIMITS_ENFORCED)
302 flags |= FS_QUOTA_GDQ_ENFD;
303 if (state->s_state[PRJQUOTA].flags & QCI_ACCT_ENABLED)
304 flags |= FS_QUOTA_PDQ_ACCT;
305 if (state->s_state[PRJQUOTA].flags & QCI_LIMITS_ENFORCED)
306 flags |= FS_QUOTA_PDQ_ENFD;
307 return flags;
308}
309
310static int quota_getstate(struct super_block *sb, struct fs_quota_stat *fqs)
311{
312 int type;
313 struct qc_state state;
314 int ret;
315
316 ret = sb->s_qcop->get_state(sb, &state);
317 if (ret < 0)
318 return ret;
319
320 memset(fqs, 0, sizeof(*fqs));
321 fqs->qs_version = FS_QSTAT_VERSION;
322 fqs->qs_flags = quota_state_to_flags(&state);
323 /* No quota enabled? */
324 if (!fqs->qs_flags)
325 return -ENOSYS;
326 fqs->qs_incoredqs = state.s_incoredqs;
327 /*
328 * GETXSTATE quotactl has space for just one set of time limits so
329 * report them for the first enabled quota type
330 */
331 for (type = 0; type < XQM_MAXQUOTAS; type++)
332 if (state.s_state[type].flags & QCI_ACCT_ENABLED)
333 break;
334 BUG_ON(type == XQM_MAXQUOTAS);
335 fqs->qs_btimelimit = state.s_state[type].spc_timelimit;
336 fqs->qs_itimelimit = state.s_state[type].ino_timelimit;
337 fqs->qs_rtbtimelimit = state.s_state[type].rt_spc_timelimit;
338 fqs->qs_bwarnlimit = state.s_state[type].spc_warnlimit;
339 fqs->qs_iwarnlimit = state.s_state[type].ino_warnlimit;
340 if (state.s_state[USRQUOTA].flags & QCI_ACCT_ENABLED) {
341 fqs->qs_uquota.qfs_ino = state.s_state[USRQUOTA].ino;
342 fqs->qs_uquota.qfs_nblks = state.s_state[USRQUOTA].blocks;
343 fqs->qs_uquota.qfs_nextents = state.s_state[USRQUOTA].nextents;
344 }
345 if (state.s_state[GRPQUOTA].flags & QCI_ACCT_ENABLED) {
346 fqs->qs_gquota.qfs_ino = state.s_state[GRPQUOTA].ino;
347 fqs->qs_gquota.qfs_nblks = state.s_state[GRPQUOTA].blocks;
348 fqs->qs_gquota.qfs_nextents = state.s_state[GRPQUOTA].nextents;
349 }
350 if (state.s_state[PRJQUOTA].flags & QCI_ACCT_ENABLED) {
351 /*
352 * Q_XGETQSTAT doesn't have room for both group and project
353 * quotas. So, allow the project quota values to be copied out
354 * only if there is no group quota information available.
355 */
356 if (!(state.s_state[GRPQUOTA].flags & QCI_ACCT_ENABLED)) {
357 fqs->qs_gquota.qfs_ino = state.s_state[PRJQUOTA].ino;
358 fqs->qs_gquota.qfs_nblks =
359 state.s_state[PRJQUOTA].blocks;
360 fqs->qs_gquota.qfs_nextents =
361 state.s_state[PRJQUOTA].nextents;
362 }
363 }
364 return 0;
365}
366
Christoph Hellwigc411e5f2010-02-16 03:44:47 -0500367static int quota_getxstate(struct super_block *sb, void __user *addr)
368{
369 struct fs_quota_stat fqs;
370 int ret;
Christoph Hellwigf450d4f2010-02-16 03:44:48 -0500371
Jan Kara59b6ba62014-11-19 16:44:58 +0100372 if (!sb->s_qcop->get_state)
Christoph Hellwigf450d4f2010-02-16 03:44:48 -0500373 return -ENOSYS;
Jan Kara59b6ba62014-11-19 16:44:58 +0100374 ret = quota_getstate(sb, &fqs);
Christoph Hellwigc411e5f2010-02-16 03:44:47 -0500375 if (!ret && copy_to_user(addr, &fqs, sizeof(fqs)))
376 return -EFAULT;
377 return ret;
378}
379
Jan Karabc230e42014-11-19 16:17:45 +0100380static int quota_getstatev(struct super_block *sb, struct fs_quota_statv *fqs)
381{
382 int type;
383 struct qc_state state;
384 int ret;
385
386 ret = sb->s_qcop->get_state(sb, &state);
387 if (ret < 0)
388 return ret;
389
390 memset(fqs, 0, sizeof(*fqs));
391 fqs->qs_version = FS_QSTAT_VERSION;
392 fqs->qs_flags = quota_state_to_flags(&state);
393 /* No quota enabled? */
394 if (!fqs->qs_flags)
395 return -ENOSYS;
396 fqs->qs_incoredqs = state.s_incoredqs;
397 /*
398 * GETXSTATV quotactl has space for just one set of time limits so
399 * report them for the first enabled quota type
400 */
401 for (type = 0; type < XQM_MAXQUOTAS; type++)
402 if (state.s_state[type].flags & QCI_ACCT_ENABLED)
403 break;
404 BUG_ON(type == XQM_MAXQUOTAS);
405 fqs->qs_btimelimit = state.s_state[type].spc_timelimit;
406 fqs->qs_itimelimit = state.s_state[type].ino_timelimit;
407 fqs->qs_rtbtimelimit = state.s_state[type].rt_spc_timelimit;
408 fqs->qs_bwarnlimit = state.s_state[type].spc_warnlimit;
409 fqs->qs_iwarnlimit = state.s_state[type].ino_warnlimit;
410 if (state.s_state[USRQUOTA].flags & QCI_ACCT_ENABLED) {
411 fqs->qs_uquota.qfs_ino = state.s_state[USRQUOTA].ino;
412 fqs->qs_uquota.qfs_nblks = state.s_state[USRQUOTA].blocks;
413 fqs->qs_uquota.qfs_nextents = state.s_state[USRQUOTA].nextents;
414 }
415 if (state.s_state[GRPQUOTA].flags & QCI_ACCT_ENABLED) {
416 fqs->qs_gquota.qfs_ino = state.s_state[GRPQUOTA].ino;
417 fqs->qs_gquota.qfs_nblks = state.s_state[GRPQUOTA].blocks;
418 fqs->qs_gquota.qfs_nextents = state.s_state[GRPQUOTA].nextents;
419 }
420 if (state.s_state[PRJQUOTA].flags & QCI_ACCT_ENABLED) {
421 fqs->qs_pquota.qfs_ino = state.s_state[PRJQUOTA].ino;
422 fqs->qs_pquota.qfs_nblks = state.s_state[PRJQUOTA].blocks;
423 fqs->qs_pquota.qfs_nextents = state.s_state[PRJQUOTA].nextents;
424 }
425 return 0;
426}
427
Chandra Seetharamanaf30cb42013-08-06 17:27:07 -0500428static int quota_getxstatev(struct super_block *sb, void __user *addr)
429{
430 struct fs_quota_statv fqs;
431 int ret;
432
Jan Kara59b6ba62014-11-19 16:44:58 +0100433 if (!sb->s_qcop->get_state)
Chandra Seetharamanaf30cb42013-08-06 17:27:07 -0500434 return -ENOSYS;
435
436 memset(&fqs, 0, sizeof(fqs));
437 if (copy_from_user(&fqs, addr, 1)) /* Just read qs_version */
438 return -EFAULT;
439
440 /* If this kernel doesn't support user specified version, fail */
441 switch (fqs.qs_version) {
442 case FS_QSTATV_VERSION1:
443 break;
444 default:
445 return -EINVAL;
446 }
Jan Kara59b6ba62014-11-19 16:44:58 +0100447 ret = quota_getstatev(sb, &fqs);
Chandra Seetharamanaf30cb42013-08-06 17:27:07 -0500448 if (!ret && copy_to_user(addr, &fqs, sizeof(fqs)))
449 return -EFAULT;
450 return ret;
451}
452
Jan Kara14bf61f2014-10-09 16:03:13 +0200453/*
454 * XFS defines BBTOB and BTOBB macros inside fs/xfs/ and we cannot move them
455 * out of there as xfsprogs rely on definitions being in that header file. So
456 * just define same functions here for quota purposes.
457 */
458#define XFS_BB_SHIFT 9
459
460static inline u64 quota_bbtob(u64 blocks)
461{
462 return blocks << XFS_BB_SHIFT;
463}
464
465static inline u64 quota_btobb(u64 bytes)
466{
467 return (bytes + (1 << XFS_BB_SHIFT) - 1) >> XFS_BB_SHIFT;
468}
469
470static void copy_from_xfs_dqblk(struct qc_dqblk *dst, struct fs_disk_quota *src)
471{
472 dst->d_spc_hardlimit = quota_bbtob(src->d_blk_hardlimit);
473 dst->d_spc_softlimit = quota_bbtob(src->d_blk_softlimit);
474 dst->d_ino_hardlimit = src->d_ino_hardlimit;
475 dst->d_ino_softlimit = src->d_ino_softlimit;
476 dst->d_space = quota_bbtob(src->d_bcount);
477 dst->d_ino_count = src->d_icount;
478 dst->d_ino_timer = src->d_itimer;
479 dst->d_spc_timer = src->d_btimer;
480 dst->d_ino_warns = src->d_iwarns;
481 dst->d_spc_warns = src->d_bwarns;
482 dst->d_rt_spc_hardlimit = quota_bbtob(src->d_rtb_hardlimit);
483 dst->d_rt_spc_softlimit = quota_bbtob(src->d_rtb_softlimit);
484 dst->d_rt_space = quota_bbtob(src->d_rtbcount);
485 dst->d_rt_spc_timer = src->d_rtbtimer;
486 dst->d_rt_spc_warns = src->d_rtbwarns;
487 dst->d_fieldmask = 0;
488 if (src->d_fieldmask & FS_DQ_ISOFT)
489 dst->d_fieldmask |= QC_INO_SOFT;
490 if (src->d_fieldmask & FS_DQ_IHARD)
491 dst->d_fieldmask |= QC_INO_HARD;
492 if (src->d_fieldmask & FS_DQ_BSOFT)
493 dst->d_fieldmask |= QC_SPC_SOFT;
494 if (src->d_fieldmask & FS_DQ_BHARD)
495 dst->d_fieldmask |= QC_SPC_HARD;
496 if (src->d_fieldmask & FS_DQ_RTBSOFT)
497 dst->d_fieldmask |= QC_RT_SPC_SOFT;
498 if (src->d_fieldmask & FS_DQ_RTBHARD)
499 dst->d_fieldmask |= QC_RT_SPC_HARD;
500 if (src->d_fieldmask & FS_DQ_BTIMER)
501 dst->d_fieldmask |= QC_SPC_TIMER;
502 if (src->d_fieldmask & FS_DQ_ITIMER)
503 dst->d_fieldmask |= QC_INO_TIMER;
504 if (src->d_fieldmask & FS_DQ_RTBTIMER)
505 dst->d_fieldmask |= QC_RT_SPC_TIMER;
506 if (src->d_fieldmask & FS_DQ_BWARNS)
507 dst->d_fieldmask |= QC_SPC_WARNS;
508 if (src->d_fieldmask & FS_DQ_IWARNS)
509 dst->d_fieldmask |= QC_INO_WARNS;
510 if (src->d_fieldmask & FS_DQ_RTBWARNS)
511 dst->d_fieldmask |= QC_RT_SPC_WARNS;
512 if (src->d_fieldmask & FS_DQ_BCOUNT)
513 dst->d_fieldmask |= QC_SPACE;
514 if (src->d_fieldmask & FS_DQ_ICOUNT)
515 dst->d_fieldmask |= QC_INO_COUNT;
516 if (src->d_fieldmask & FS_DQ_RTBCOUNT)
517 dst->d_fieldmask |= QC_RT_SPACE;
518}
519
Jan Karac39fb532014-12-16 16:12:27 +0100520static void copy_qcinfo_from_xfs_dqblk(struct qc_info *dst,
521 struct fs_disk_quota *src)
522{
523 memset(dst, 0, sizeof(*dst));
524 dst->i_spc_timelimit = src->d_btimer;
525 dst->i_ino_timelimit = src->d_itimer;
526 dst->i_rt_spc_timelimit = src->d_rtbtimer;
527 dst->i_ino_warnlimit = src->d_iwarns;
528 dst->i_spc_warnlimit = src->d_bwarns;
529 dst->i_rt_spc_warnlimit = src->d_rtbwarns;
530 if (src->d_fieldmask & FS_DQ_BWARNS)
531 dst->i_fieldmask |= QC_SPC_WARNS;
532 if (src->d_fieldmask & FS_DQ_IWARNS)
533 dst->i_fieldmask |= QC_INO_WARNS;
534 if (src->d_fieldmask & FS_DQ_RTBWARNS)
535 dst->i_fieldmask |= QC_RT_SPC_WARNS;
536 if (src->d_fieldmask & FS_DQ_BTIMER)
537 dst->i_fieldmask |= QC_SPC_TIMER;
538 if (src->d_fieldmask & FS_DQ_ITIMER)
539 dst->i_fieldmask |= QC_INO_TIMER;
540 if (src->d_fieldmask & FS_DQ_RTBTIMER)
541 dst->i_fieldmask |= QC_RT_SPC_TIMER;
542}
543
Christoph Hellwigc411e5f2010-02-16 03:44:47 -0500544static int quota_setxquota(struct super_block *sb, int type, qid_t id,
545 void __user *addr)
546{
547 struct fs_disk_quota fdq;
Jan Kara14bf61f2014-10-09 16:03:13 +0200548 struct qc_dqblk qdq;
Eric W. Biederman74a8a102012-09-16 02:07:49 -0700549 struct kqid qid;
Christoph Hellwigc411e5f2010-02-16 03:44:47 -0500550
551 if (copy_from_user(&fdq, addr, sizeof(fdq)))
552 return -EFAULT;
Christoph Hellwigc472b432010-05-06 17:05:17 -0400553 if (!sb->s_qcop->set_dqblk)
Christoph Hellwigf450d4f2010-02-16 03:44:48 -0500554 return -ENOSYS;
Eric W. Biederman74a8a102012-09-16 02:07:49 -0700555 qid = make_kqid(current_user_ns(), type, id);
556 if (!qid_valid(qid))
557 return -EINVAL;
Jan Karac39fb532014-12-16 16:12:27 +0100558 /* Are we actually setting timer / warning limits for all users? */
559 if (from_kqid(&init_user_ns, qid) == 0 &&
560 fdq.d_fieldmask & (FS_DQ_WARNS_MASK | FS_DQ_TIMER_MASK)) {
561 struct qc_info qinfo;
562 int ret;
563
564 if (!sb->s_qcop->set_info)
565 return -EINVAL;
566 copy_qcinfo_from_xfs_dqblk(&qinfo, &fdq);
567 ret = sb->s_qcop->set_info(sb, type, &qinfo);
568 if (ret)
569 return ret;
570 /* These are already done */
571 fdq.d_fieldmask &= ~(FS_DQ_WARNS_MASK | FS_DQ_TIMER_MASK);
572 }
Jan Kara14bf61f2014-10-09 16:03:13 +0200573 copy_from_xfs_dqblk(&qdq, &fdq);
574 return sb->s_qcop->set_dqblk(sb, qid, &qdq);
575}
576
577static void copy_to_xfs_dqblk(struct fs_disk_quota *dst, struct qc_dqblk *src,
578 int type, qid_t id)
579{
580 memset(dst, 0, sizeof(*dst));
581 dst->d_version = FS_DQUOT_VERSION;
582 dst->d_id = id;
583 if (type == USRQUOTA)
584 dst->d_flags = FS_USER_QUOTA;
585 else if (type == PRJQUOTA)
586 dst->d_flags = FS_PROJ_QUOTA;
587 else
588 dst->d_flags = FS_GROUP_QUOTA;
589 dst->d_blk_hardlimit = quota_btobb(src->d_spc_hardlimit);
590 dst->d_blk_softlimit = quota_btobb(src->d_spc_softlimit);
591 dst->d_ino_hardlimit = src->d_ino_hardlimit;
592 dst->d_ino_softlimit = src->d_ino_softlimit;
593 dst->d_bcount = quota_btobb(src->d_space);
594 dst->d_icount = src->d_ino_count;
595 dst->d_itimer = src->d_ino_timer;
596 dst->d_btimer = src->d_spc_timer;
597 dst->d_iwarns = src->d_ino_warns;
598 dst->d_bwarns = src->d_spc_warns;
599 dst->d_rtb_hardlimit = quota_btobb(src->d_rt_spc_hardlimit);
600 dst->d_rtb_softlimit = quota_btobb(src->d_rt_spc_softlimit);
601 dst->d_rtbcount = quota_btobb(src->d_rt_space);
602 dst->d_rtbtimer = src->d_rt_spc_timer;
603 dst->d_rtbwarns = src->d_rt_spc_warns;
Christoph Hellwigc411e5f2010-02-16 03:44:47 -0500604}
605
606static int quota_getxquota(struct super_block *sb, int type, qid_t id,
607 void __user *addr)
608{
609 struct fs_disk_quota fdq;
Jan Kara14bf61f2014-10-09 16:03:13 +0200610 struct qc_dqblk qdq;
Eric W. Biederman74a8a102012-09-16 02:07:49 -0700611 struct kqid qid;
Christoph Hellwigc411e5f2010-02-16 03:44:47 -0500612 int ret;
613
Christoph Hellwigb9b2dd32010-05-06 17:04:58 -0400614 if (!sb->s_qcop->get_dqblk)
Christoph Hellwigf450d4f2010-02-16 03:44:48 -0500615 return -ENOSYS;
Eric W. Biederman74a8a102012-09-16 02:07:49 -0700616 qid = make_kqid(current_user_ns(), type, id);
617 if (!qid_valid(qid))
618 return -EINVAL;
Jan Kara14bf61f2014-10-09 16:03:13 +0200619 ret = sb->s_qcop->get_dqblk(sb, qid, &qdq);
620 if (ret)
621 return ret;
622 copy_to_xfs_dqblk(&fdq, &qdq, type, id);
623 if (copy_to_user(addr, &fdq, sizeof(fdq)))
Christoph Hellwigc411e5f2010-02-16 03:44:47 -0500624 return -EFAULT;
625 return ret;
626}
627
Eric Sandeen9da93f92014-05-05 17:25:50 +1000628static int quota_rmxquota(struct super_block *sb, void __user *addr)
629{
630 __u32 flags;
631
632 if (copy_from_user(&flags, addr, sizeof(flags)))
633 return -EFAULT;
634 if (!sb->s_qcop->rm_xquota)
635 return -ENOSYS;
636 return sb->s_qcop->rm_xquota(sb, flags);
637}
638
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639/* Copy parameters and call proper function */
Jan Kara268157b2009-01-27 15:47:22 +0100640static int do_quotactl(struct super_block *sb, int type, int cmd, qid_t id,
Jan Karaf00c9e42010-09-15 17:38:58 +0200641 void __user *addr, struct path *path)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642{
Christoph Hellwigc988afb2010-02-16 03:44:50 -0500643 int ret;
644
645 if (type >= (XQM_COMMAND(cmd) ? XQM_MAXQUOTAS : MAXQUOTAS))
646 return -EINVAL;
Jan Kara2c5f6482014-09-30 10:43:09 +0200647 /*
648 * Quota not supported on this fs? Check this before s_quota_types
649 * since they needn't be set if quota is not supported at all.
650 */
Christoph Hellwigc988afb2010-02-16 03:44:50 -0500651 if (!sb->s_qcop)
652 return -ENOSYS;
Jan Kara2c5f6482014-09-30 10:43:09 +0200653 if (!(sb->s_quota_types & (1 << type)))
654 return -EINVAL;
Christoph Hellwigc988afb2010-02-16 03:44:50 -0500655
656 ret = check_quotactl_permission(sb, type, cmd, id);
657 if (ret < 0)
658 return ret;
659
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660 switch (cmd) {
Christoph Hellwigc411e5f2010-02-16 03:44:47 -0500661 case Q_QUOTAON:
Jan Karaf00c9e42010-09-15 17:38:58 +0200662 return quota_quotaon(sb, type, cmd, id, path);
Christoph Hellwigc411e5f2010-02-16 03:44:47 -0500663 case Q_QUOTAOFF:
Jan Karad3b86322014-10-08 16:07:12 +0200664 return quota_quotaoff(sb, type);
Christoph Hellwigc411e5f2010-02-16 03:44:47 -0500665 case Q_GETFMT:
666 return quota_getfmt(sb, type, addr);
667 case Q_GETINFO:
668 return quota_getinfo(sb, type, addr);
669 case Q_SETINFO:
670 return quota_setinfo(sb, type, addr);
671 case Q_GETQUOTA:
672 return quota_getquota(sb, type, id, addr);
673 case Q_SETQUOTA:
674 return quota_setquota(sb, type, id, addr);
675 case Q_SYNC:
Christoph Hellwig6ae09572010-02-16 03:44:49 -0500676 if (!sb->s_qcop->quota_sync)
677 return -ENOSYS;
Jan Karaceed1722012-07-03 16:45:28 +0200678 return sb->s_qcop->quota_sync(sb, type);
Christoph Hellwigc411e5f2010-02-16 03:44:47 -0500679 case Q_XQUOTAON:
Jan Kara38e478c2014-10-08 15:56:21 +0200680 return quota_enable(sb, addr);
Christoph Hellwigc411e5f2010-02-16 03:44:47 -0500681 case Q_XQUOTAOFF:
Jan Kara38e478c2014-10-08 15:56:21 +0200682 return quota_disable(sb, addr);
Eric Sandeen9da93f92014-05-05 17:25:50 +1000683 case Q_XQUOTARM:
684 return quota_rmxquota(sb, addr);
Christoph Hellwigc411e5f2010-02-16 03:44:47 -0500685 case Q_XGETQSTAT:
686 return quota_getxstate(sb, addr);
Chandra Seetharamanaf30cb42013-08-06 17:27:07 -0500687 case Q_XGETQSTATV:
688 return quota_getxstatev(sb, addr);
Christoph Hellwigc411e5f2010-02-16 03:44:47 -0500689 case Q_XSETQLIM:
690 return quota_setxquota(sb, type, id, addr);
691 case Q_XGETQUOTA:
692 return quota_getxquota(sb, type, id, addr);
693 case Q_XQUOTASYNC:
Christoph Hellwig8c4e4ac2010-02-16 03:44:51 -0500694 if (sb->s_flags & MS_RDONLY)
695 return -EROFS;
Christoph Hellwig4b217ed2012-02-20 02:28:18 +0000696 /* XFS quotas are fully coherent now, making this call a noop */
Christoph Hellwig8c4e4ac2010-02-16 03:44:51 -0500697 return 0;
Christoph Hellwigc411e5f2010-02-16 03:44:47 -0500698 default:
Christoph Hellwigf450d4f2010-02-16 03:44:48 -0500699 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701}
702
Lee Jones56df1272012-11-03 23:02:28 +0100703#ifdef CONFIG_BLOCK
704
Jan Karadcdbed82012-02-10 11:03:01 +0100705/* Return 1 if 'cmd' will block on frozen filesystem */
706static int quotactl_cmd_write(int cmd)
707{
708 switch (cmd) {
709 case Q_GETFMT:
710 case Q_GETINFO:
711 case Q_SYNC:
712 case Q_XGETQSTAT:
Chandra Seetharamanaf30cb42013-08-06 17:27:07 -0500713 case Q_XGETQSTATV:
Jan Karadcdbed82012-02-10 11:03:01 +0100714 case Q_XGETQUOTA:
715 case Q_XQUOTASYNC:
716 return 0;
717 }
718 return 1;
719}
720
Lee Jones56df1272012-11-03 23:02:28 +0100721#endif /* CONFIG_BLOCK */
722
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723/*
David Howells93614012006-09-30 20:45:40 +0200724 * look up a superblock on which quota ops will be performed
725 * - use the name of a block device to find the superblock thereon
726 */
Jan Karadcdbed82012-02-10 11:03:01 +0100727static struct super_block *quotactl_block(const char __user *special, int cmd)
David Howells93614012006-09-30 20:45:40 +0200728{
729#ifdef CONFIG_BLOCK
730 struct block_device *bdev;
731 struct super_block *sb;
Jeff Layton91a27b22012-10-10 15:25:28 -0400732 struct filename *tmp = getname(special);
David Howells93614012006-09-30 20:45:40 +0200733
734 if (IS_ERR(tmp))
David Howellse231c2e2008-02-07 00:15:26 -0800735 return ERR_CAST(tmp);
Jeff Layton91a27b22012-10-10 15:25:28 -0400736 bdev = lookup_bdev(tmp->name);
David Howells93614012006-09-30 20:45:40 +0200737 putname(tmp);
738 if (IS_ERR(bdev))
David Howellse231c2e2008-02-07 00:15:26 -0800739 return ERR_CAST(bdev);
Jan Karadcdbed82012-02-10 11:03:01 +0100740 if (quotactl_cmd_write(cmd))
741 sb = get_super_thawed(bdev);
742 else
743 sb = get_super(bdev);
David Howells93614012006-09-30 20:45:40 +0200744 bdput(bdev);
745 if (!sb)
746 return ERR_PTR(-ENODEV);
747
748 return sb;
749#else
750 return ERR_PTR(-ENODEV);
751#endif
752}
753
754/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700755 * This is the system call interface. This communicates with
756 * the user-level programs. Currently this only supports diskquota
757 * calls. Maybe we need to add the process quotas etc. in the future,
758 * but we probably should use rlimits for that.
759 */
Heiko Carstens3cdad422009-01-14 14:14:22 +0100760SYSCALL_DEFINE4(quotactl, unsigned int, cmd, const char __user *, special,
761 qid_t, id, void __user *, addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762{
763 uint cmds, type;
764 struct super_block *sb = NULL;
Jan Karaf00c9e42010-09-15 17:38:58 +0200765 struct path path, *pathp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766 int ret;
767
768 cmds = cmd >> SUBCMDSHIFT;
769 type = cmd & SUBCMDMASK;
770
Christoph Hellwig6ae09572010-02-16 03:44:49 -0500771 /*
772 * As a special case Q_SYNC can be called without a specific device.
773 * It will iterate all superblocks that have quota enabled and call
774 * the sync action on each of them.
775 */
776 if (!special) {
777 if (cmds == Q_SYNC)
778 return quota_sync_all(type);
779 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780 }
781
Jan Karaf00c9e42010-09-15 17:38:58 +0200782 /*
783 * Path for quotaon has to be resolved before grabbing superblock
784 * because that gets s_umount sem which is also possibly needed by path
785 * resolution (think about autofs) and thus deadlocks could arise.
786 */
787 if (cmds == Q_QUOTAON) {
Trond Myklebust815d4052011-09-26 20:36:09 -0400788 ret = user_path_at(AT_FDCWD, addr, LOOKUP_FOLLOW|LOOKUP_AUTOMOUNT, &path);
Jan Karaf00c9e42010-09-15 17:38:58 +0200789 if (ret)
790 pathp = ERR_PTR(ret);
791 else
792 pathp = &path;
793 }
794
Jan Karadcdbed82012-02-10 11:03:01 +0100795 sb = quotactl_block(special, cmds);
Jan Kara0aaa6182011-10-10 18:32:06 +0200796 if (IS_ERR(sb)) {
797 ret = PTR_ERR(sb);
798 goto out;
799 }
Christoph Hellwig6ae09572010-02-16 03:44:49 -0500800
Jan Karaf00c9e42010-09-15 17:38:58 +0200801 ret = do_quotactl(sb, type, cmds, id, addr, pathp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802
Christoph Hellwig6ae09572010-02-16 03:44:49 -0500803 drop_super(sb);
Jan Kara0aaa6182011-10-10 18:32:06 +0200804out:
Jan Karaf00c9e42010-09-15 17:38:58 +0200805 if (pathp && !IS_ERR(pathp))
806 path_put(pathp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807 return ret;
808}