]> git.proxmox.com Git - mirror_ubuntu-zesty-kernel.git/blame - fs/quota/quota.c
projects / mirror_ubuntu-zesty-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
xfs: Add support for Q_SETINFO
[mirror_ubuntu-zesty-kernel.git] / fs / quota / quota.c
CommitLineData
1da177e4
LT		 1/*
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>
f3da9310 12#include <linux/uaccess.h>
1da177e4 13#include <linux/kernel.h>
1da177e4
LT		 14#include <linux/security.h>
15#include <linux/syscalls.h>
16f7e0fe 16#include <linux/capability.h>
be586bab 17#include <linux/quotaops.h>
b716395e 18#include <linux/types.h>
8c4e4acd 19#include <linux/writeback.h>
1da177e4 20
c988afb5
CH		 21static int check_quotactl_permission(struct super_block *sb, int type, int cmd,
22 qid_t id)
1da177e4 23{
c988afb5
CH		 24 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:
af30cb44 30 case Q_XGETQSTATV:
c988afb5
CH		 31 case Q_XQUOTASYNC:
32 break;
33 /* allow to query information for dquots we "own" */
34 case Q_GETQUOTA:
35 case Q_XGETQUOTA:
74a8a103
EB		 36 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))))
c988afb5
CH		 38 break;
39 /*FALLTHROUGH*/
40 default:
1da177e4
LT		 41 if (!capable(CAP_SYS_ADMIN))
42 return -EPERM;
43 }
44
c988afb5 45 return security_quotactl(cmd, type, id, sb);
1da177e4
LT		 46}
47
01a05b33
AV		 48static void quota_sync_one(struct super_block *sb, void *arg)
49{
2c5f648a
JK		 50 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);
01a05b33
AV		 55}
56
6ae09575 57static int quota_sync_all(int type)
1da177e4 58{
6ae09575
CH		 59 int ret;
60
61 if (type >= MAXQUOTAS)
62 return -EINVAL;
63 ret = security_quotactl(Q_SYNC, type, 0, NULL);
01a05b33
AV		 64 if (!ret)
65 iterate_supers(quota_sync_one, &type);
66 return ret;
1da177e4
LT		 67}
68
d3b86324
JK		 69unsigned 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
c411e5f6 82static int quota_quotaon(struct super_block *sb, int type, int cmd, qid_t id,
f00c9e44 83 struct path *path)
1da177e4 84{
aaa3daed 85 if (!sb->s_qcop->quota_on && !sb->s_qcop->quota_enable)
f00c9e44 86 return -ENOSYS;
d3b86324
JK		 87 if (sb->s_qcop->quota_enable)
88 return sb->s_qcop->quota_enable(sb, qtype_enforce_flag(type));
f00c9e44
JK		 89 if (IS_ERR(path))
90 return PTR_ERR(path);
91 return sb->s_qcop->quota_on(sb, type, id, path);
c411e5f6 92}
1da177e4 93
d3b86324
JK		 94static 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
c411e5f6
CH		 103static int quota_getfmt(struct super_block *sb, int type, void __user *addr)
104{
105 __u32 fmt;
1da177e4 106
606cdcca 107 mutex_lock(&sb_dqopt(sb)->dqonoff_mutex);
c411e5f6 108 if (!sb_has_quota_active(sb, type)) {
606cdcca 109 mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
c411e5f6
CH		 110 return -ESRCH;
111 }
112 fmt = sb_dqopt(sb)->info[type].dqi_format->qf_fmt_id;
606cdcca 113 mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
c411e5f6
CH		 114 if (copy_to_user(addr, &fmt, sizeof(fmt)))
115 return -EFAULT;
116 return 0;
117}
1da177e4 118
c411e5f6
CH		 119static int quota_getinfo(struct super_block *sb, int type, void __user *addr)
120{
0a240339
JK		 121 struct qc_state state;
122 struct qc_type_state *tstate;
123 struct if_dqinfo uinfo;
c411e5f6 124 int ret;
1da177e4 125
0a240339
JK		 126 /* This checks whether qc_state has enough entries... */
127 BUILD_BUG_ON(MAXQUOTAS > XQM_MAXQUOTAS);
128 if (!sb->s_qcop->get_state)
f450d4fe 129 return -ENOSYS;
0a240339
JK		 130 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)))
c411e5f6
CH		 145 return -EFAULT;
146 return ret;
147}
1da177e4 148
c411e5f6
CH		 149static int quota_setinfo(struct super_block *sb, int type, void __user *addr)
150{
151 struct if_dqinfo info;
5eacb2ac 152 struct qc_info qinfo;
1da177e4 153
c411e5f6
CH		 154 if (copy_from_user(&info, addr, sizeof(info)))
155 return -EFAULT;
f450d4fe
CH		 156 if (!sb->s_qcop->set_info)
157 return -ENOSYS;
5eacb2ac
JK		 158 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);
c411e5f6
CH		 177}
178
14bf61ff
JK		 179static 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)
b9b2dd36 190{
18da65e7 191 memset(dst, 0, sizeof(*dst));
14bf61ff
JK		 192 dst->dqb_bhardlimit = stoqb(src->d_spc_hardlimit);
193 dst->dqb_bsoftlimit = stoqb(src->d_spc_softlimit);
194 dst->dqb_curspace = src->d_space;
b9b2dd36
CH		 195 dst->dqb_ihardlimit = src->d_ino_hardlimit;
196 dst->dqb_isoftlimit = src->d_ino_softlimit;
14bf61ff
JK		 197 dst->dqb_curinodes = src->d_ino_count;
198 dst->dqb_btime = src->d_spc_timer;
199 dst->dqb_itime = src->d_ino_timer;
b9b2dd36
CH		 200 dst->dqb_valid = QIF_ALL;
201}
202
c411e5f6
CH		 203static int quota_getquota(struct super_block *sb, int type, qid_t id,
204 void __user *addr)
205{
74a8a103 206 struct kqid qid;
14bf61ff 207 struct qc_dqblk fdq;
c411e5f6
CH		 208 struct if_dqblk idq;
209 int ret;
210
f450d4fe
CH		 211 if (!sb->s_qcop->get_dqblk)
212 return -ENOSYS;
74a8a103
EB		 213 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);
c411e5f6
CH		 217 if (ret)
218 return ret;
b9b2dd36 219 copy_to_if_dqblk(&idq, &fdq);
c411e5f6
CH		 220 if (copy_to_user(addr, &idq, sizeof(idq)))
221 return -EFAULT;
222 return 0;
223}
224
14bf61ff 225static void copy_from_if_dqblk(struct qc_dqblk *dst, struct if_dqblk *src)
c472b432 226{
14bf61ff
JK		 227 dst->d_spc_hardlimit = qbtos(src->dqb_bhardlimit);
228 dst->d_spc_softlimit = qbtos(src->dqb_bsoftlimit);
229 dst->d_space = src->dqb_curspace;
c472b432
CH		 230 dst->d_ino_hardlimit = src->dqb_ihardlimit;
231 dst->d_ino_softlimit = src->dqb_isoftlimit;
14bf61ff
JK		 232 dst->d_ino_count = src->dqb_curinodes;
233 dst->d_spc_timer = src->dqb_btime;
234 dst->d_ino_timer = src->dqb_itime;
c472b432
CH		 235
236 dst->d_fieldmask = 0;
237 if (src->dqb_valid & QIF_BLIMITS)
14bf61ff 238 dst->d_fieldmask |= QC_SPC_SOFT | QC_SPC_HARD;
c472b432 239 if (src->dqb_valid & QIF_SPACE)
14bf61ff 240 dst->d_fieldmask |= QC_SPACE;
c472b432 241 if (src->dqb_valid & QIF_ILIMITS)
14bf61ff 242 dst->d_fieldmask |= QC_INO_SOFT | QC_INO_HARD;
c472b432 243 if (src->dqb_valid & QIF_INODES)
14bf61ff 244 dst->d_fieldmask |= QC_INO_COUNT;
c472b432 245 if (src->dqb_valid & QIF_BTIME)
14bf61ff 246 dst->d_fieldmask |= QC_SPC_TIMER;
c472b432 247 if (src->dqb_valid & QIF_ITIME)
14bf61ff 248 dst->d_fieldmask |= QC_INO_TIMER;
c472b432
CH		 249}
250
c411e5f6
CH		 251static int quota_setquota(struct super_block *sb, int type, qid_t id,
252 void __user *addr)
253{
14bf61ff 254 struct qc_dqblk fdq;
c411e5f6 255 struct if_dqblk idq;
74a8a103 256 struct kqid qid;
c411e5f6
CH		 257
258 if (copy_from_user(&idq, addr, sizeof(idq)))
259 return -EFAULT;
f450d4fe
CH		 260 if (!sb->s_qcop->set_dqblk)
261 return -ENOSYS;
74a8a103
EB		 262 qid = make_kqid(current_user_ns(), type, id);
263 if (!qid_valid(qid))
264 return -EINVAL;
c472b432 265 copy_from_if_dqblk(&fdq, &idq);
74a8a103 266 return sb->s_qcop->set_dqblk(sb, qid, &fdq);
c411e5f6
CH		 267}
268
38e478c4 269static int quota_enable(struct super_block *sb, void __user *addr)
c411e5f6
CH		 270{
271 __u32 flags;
272
273 if (copy_from_user(&flags, addr, sizeof(flags)))
274 return -EFAULT;
38e478c4 275 if (!sb->s_qcop->quota_enable)
f450d4fe 276 return -ENOSYS;
38e478c4
JK		 277 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);
c411e5f6
CH		 289}
290
bc230e4a
JK		 291static 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
c411e5f6
CH		 367static int quota_getxstate(struct super_block *sb, void __user *addr)
368{
369 struct fs_quota_stat fqs;
370 int ret;
f450d4fe 371
59b6ba69 372 if (!sb->s_qcop->get_state)
f450d4fe 373 return -ENOSYS;
59b6ba69 374 ret = quota_getstate(sb, &fqs);
c411e5f6
CH		 375 if (!ret && copy_to_user(addr, &fqs, sizeof(fqs)))
376 return -EFAULT;
377 return ret;
378}
1da177e4 379
bc230e4a
JK		 380static 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
af30cb44
CS		 428static int quota_getxstatev(struct super_block *sb, void __user *addr)
429{
430 struct fs_quota_statv fqs;
431 int ret;
432
59b6ba69 433 if (!sb->s_qcop->get_state)
af30cb44
CS		 434 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 }
59b6ba69 447 ret = quota_getstatev(sb, &fqs);
af30cb44
CS		 448 if (!ret && copy_to_user(addr, &fqs, sizeof(fqs)))
449 return -EFAULT;
450 return ret;
451}
452
14bf61ff
JK		 453/*
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
c411e5f6
CH		 520static int quota_setxquota(struct super_block *sb, int type, qid_t id,
521 void __user *addr)
522{
523 struct fs_disk_quota fdq;
14bf61ff 524 struct qc_dqblk qdq;
74a8a103 525 struct kqid qid;
c411e5f6
CH		 526
527 if (copy_from_user(&fdq, addr, sizeof(fdq)))
528 return -EFAULT;
c472b432 529 if (!sb->s_qcop->set_dqblk)
f450d4fe 530 return -ENOSYS;
74a8a103
EB		 531 qid = make_kqid(current_user_ns(), type, id);
532 if (!qid_valid(qid))
533 return -EINVAL;
14bf61ff
JK		 534 copy_from_xfs_dqblk(&qdq, &fdq);
535 return sb->s_qcop->set_dqblk(sb, qid, &qdq);
536}
537
538static void copy_to_xfs_dqblk(struct fs_disk_quota *dst, struct qc_dqblk *src,
539 int type, qid_t id)
540{
541 memset(dst, 0, sizeof(*dst));
542 dst->d_version = FS_DQUOT_VERSION;
543 dst->d_id = id;
544 if (type == USRQUOTA)
545 dst->d_flags = FS_USER_QUOTA;
546 else if (type == PRJQUOTA)
547 dst->d_flags = FS_PROJ_QUOTA;
548 else
549 dst->d_flags = FS_GROUP_QUOTA;
550 dst->d_blk_hardlimit = quota_btobb(src->d_spc_hardlimit);
551 dst->d_blk_softlimit = quota_btobb(src->d_spc_softlimit);
552 dst->d_ino_hardlimit = src->d_ino_hardlimit;
553 dst->d_ino_softlimit = src->d_ino_softlimit;
554 dst->d_bcount = quota_btobb(src->d_space);
555 dst->d_icount = src->d_ino_count;
556 dst->d_itimer = src->d_ino_timer;
557 dst->d_btimer = src->d_spc_timer;
558 dst->d_iwarns = src->d_ino_warns;
559 dst->d_bwarns = src->d_spc_warns;
560 dst->d_rtb_hardlimit = quota_btobb(src->d_rt_spc_hardlimit);
561 dst->d_rtb_softlimit = quota_btobb(src->d_rt_spc_softlimit);
562 dst->d_rtbcount = quota_btobb(src->d_rt_space);
563 dst->d_rtbtimer = src->d_rt_spc_timer;
564 dst->d_rtbwarns = src->d_rt_spc_warns;
c411e5f6
CH		 565}
566
567static int quota_getxquota(struct super_block *sb, int type, qid_t id,
568 void __user *addr)
569{
570 struct fs_disk_quota fdq;
14bf61ff 571 struct qc_dqblk qdq;
74a8a103 572 struct kqid qid;
c411e5f6
CH		 573 int ret;
574
b9b2dd36 575 if (!sb->s_qcop->get_dqblk)
f450d4fe 576 return -ENOSYS;
74a8a103
EB		 577 qid = make_kqid(current_user_ns(), type, id);
578 if (!qid_valid(qid))
579 return -EINVAL;
14bf61ff
JK		 580 ret = sb->s_qcop->get_dqblk(sb, qid, &qdq);
581 if (ret)
582 return ret;
583 copy_to_xfs_dqblk(&fdq, &qdq, type, id);
584 if (copy_to_user(addr, &fdq, sizeof(fdq)))
c411e5f6
CH		 585 return -EFAULT;
586 return ret;
587}
588
9da93f9b
ES		 589static int quota_rmxquota(struct super_block *sb, void __user *addr)
590{
591 __u32 flags;
592
593 if (copy_from_user(&flags, addr, sizeof(flags)))
594 return -EFAULT;
595 if (!sb->s_qcop->rm_xquota)
596 return -ENOSYS;
597 return sb->s_qcop->rm_xquota(sb, flags);
598}
599
c411e5f6
CH		 600/* Copy parameters and call proper function */
601static int do_quotactl(struct super_block *sb, int type, int cmd, qid_t id,
f00c9e44 602 void __user *addr, struct path *path)
c411e5f6 603{
c988afb5
CH		 604 int ret;
605
606 if (type >= (XQM_COMMAND(cmd) ? XQM_MAXQUOTAS : MAXQUOTAS))
607 return -EINVAL;
2c5f648a
JK		 608 /*
609 * Quota not supported on this fs? Check this before s_quota_types
610 * since they needn't be set if quota is not supported at all.
611 */
c988afb5
CH		 612 if (!sb->s_qcop)
613 return -ENOSYS;
2c5f648a
JK		 614 if (!(sb->s_quota_types & (1 << type)))
615 return -EINVAL;
c988afb5
CH		 616
617 ret = check_quotactl_permission(sb, type, cmd, id);
618 if (ret < 0)
619 return ret;
620
c411e5f6
CH		 621 switch (cmd) {
622 case Q_QUOTAON:
f00c9e44 623 return quota_quotaon(sb, type, cmd, id, path);
c411e5f6 624 case Q_QUOTAOFF:
d3b86324 625 return quota_quotaoff(sb, type);
c411e5f6
CH		 626 case Q_GETFMT:
627 return quota_getfmt(sb, type, addr);
628 case Q_GETINFO:
629 return quota_getinfo(sb, type, addr);
630 case Q_SETINFO:
631 return quota_setinfo(sb, type, addr);
632 case Q_GETQUOTA:
633 return quota_getquota(sb, type, id, addr);
634 case Q_SETQUOTA:
635 return quota_setquota(sb, type, id, addr);
636 case Q_SYNC:
6ae09575
CH		 637 if (!sb->s_qcop->quota_sync)
638 return -ENOSYS;
ceed1723 639 return sb->s_qcop->quota_sync(sb, type);
c411e5f6 640 case Q_XQUOTAON:
38e478c4 641 return quota_enable(sb, addr);
c411e5f6 642 case Q_XQUOTAOFF:
38e478c4 643 return quota_disable(sb, addr);
9da93f9b
ES		 644 case Q_XQUOTARM:
645 return quota_rmxquota(sb, addr);
c411e5f6
CH		 646 case Q_XGETQSTAT:
647 return quota_getxstate(sb, addr);
af30cb44
CS		 648 case Q_XGETQSTATV:
649 return quota_getxstatev(sb, addr);
c411e5f6
CH		 650 case Q_XSETQLIM:
651 return quota_setxquota(sb, type, id, addr);
652 case Q_XGETQUOTA:
653 return quota_getxquota(sb, type, id, addr);
654 case Q_XQUOTASYNC:
8c4e4acd
CH		 655 if (sb->s_flags & MS_RDONLY)
656 return -EROFS;
4b217ed9 657 /* XFS quotas are fully coherent now, making this call a noop */
8c4e4acd 658 return 0;
c411e5f6 659 default:
f450d4fe 660 return -EINVAL;
1da177e4 661 }
1da177e4
LT		 662}
663
56df1278
LJ		 664#ifdef CONFIG_BLOCK
665
dcdbed85
JK		 666/* Return 1 if 'cmd' will block on frozen filesystem */
667static int quotactl_cmd_write(int cmd)
668{
669 switch (cmd) {
670 case Q_GETFMT:
671 case Q_GETINFO:
672 case Q_SYNC:
673 case Q_XGETQSTAT:
af30cb44 674 case Q_XGETQSTATV:
dcdbed85
JK		 675 case Q_XGETQUOTA:
676 case Q_XQUOTASYNC:
677 return 0;
678 }
679 return 1;
680}
681
56df1278
LJ		 682#endif /* CONFIG_BLOCK */
683
9361401e
DH		 684/*
685 * look up a superblock on which quota ops will be performed
686 * - use the name of a block device to find the superblock thereon
687 */
dcdbed85 688static struct super_block *quotactl_block(const char __user *special, int cmd)
9361401e
DH		 689{
690#ifdef CONFIG_BLOCK
691 struct block_device *bdev;
692 struct super_block *sb;
91a27b2a 693 struct filename *tmp = getname(special);
9361401e
DH		 694
695 if (IS_ERR(tmp))
e231c2ee 696 return ERR_CAST(tmp);
91a27b2a 697 bdev = lookup_bdev(tmp->name);
9361401e
DH		 698 putname(tmp);
699 if (IS_ERR(bdev))
e231c2ee 700 return ERR_CAST(bdev);
dcdbed85
JK		 701 if (quotactl_cmd_write(cmd))
702 sb = get_super_thawed(bdev);
703 else
704 sb = get_super(bdev);
9361401e
DH		 705 bdput(bdev);
706 if (!sb)
707 return ERR_PTR(-ENODEV);
708
709 return sb;
710#else
711 return ERR_PTR(-ENODEV);
712#endif
713}
714
1da177e4
LT		 715/*
716 * This is the system call interface. This communicates with
717 * the user-level programs. Currently this only supports diskquota
718 * calls. Maybe we need to add the process quotas etc. in the future,
719 * but we probably should use rlimits for that.
720 */
3cdad428
HC		 721SYSCALL_DEFINE4(quotactl, unsigned int, cmd, const char __user *, special,
722 qid_t, id, void __user *, addr)
1da177e4
LT		 723{
724 uint cmds, type;
725 struct super_block *sb = NULL;
f00c9e44 726 struct path path, *pathp = NULL;
1da177e4
LT		 727 int ret;
728
729 cmds = cmd >> SUBCMDSHIFT;
730 type = cmd & SUBCMDMASK;
731
6ae09575
CH		 732 /*
733 * As a special case Q_SYNC can be called without a specific device.
734 * It will iterate all superblocks that have quota enabled and call
735 * the sync action on each of them.
736 */
737 if (!special) {
738 if (cmds == Q_SYNC)
739 return quota_sync_all(type);
740 return -ENODEV;
1da177e4
LT		 741 }
742
f00c9e44
JK		 743 /*
744 * Path for quotaon has to be resolved before grabbing superblock
745 * because that gets s_umount sem which is also possibly needed by path
746 * resolution (think about autofs) and thus deadlocks could arise.
747 */
748 if (cmds == Q_QUOTAON) {
815d405c 749 ret = user_path_at(AT_FDCWD, addr, LOOKUP_FOLLOW|LOOKUP_AUTOMOUNT, &path);
f00c9e44
JK		 750 if (ret)
751 pathp = ERR_PTR(ret);
752 else
753 pathp = &path;
754 }
755
dcdbed85 756 sb = quotactl_block(special, cmds);
0aaa6188
JK		 757 if (IS_ERR(sb)) {
758 ret = PTR_ERR(sb);
759 goto out;
760 }
6ae09575 761
f00c9e44 762 ret = do_quotactl(sb, type, cmds, id, addr, pathp);
1da177e4 763
6ae09575 764 drop_super(sb);
0aaa6188 765out:
f00c9e44
JK		 766 if (pathp && !IS_ERR(pathp))
767 path_put(pathp);
1da177e4
LT		 768 return ret;
769}
ubuntu-zesty-kernel mirror