]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blame - fs/quota/quota.c
projects / mirror_ubuntu-artful-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Revert "(namespace) quota: Handle quota data stored in s_user_ns in quota_setxquota"
[mirror_ubuntu-artful-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;
72d4d0e4 144 if (copy_to_user(addr, &uinfo, sizeof(uinfo)))
c411e5f6 145 return -EFAULT;
72d4d0e4 146 return 0;
c411e5f6 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 213 qid = make_kqid(current_user_ns(), type, id);
ec41f5ac 214 if (!qid_has_mapping(sb->s_user_ns, qid))
74a8a103
EB		 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 262 qid = make_kqid(current_user_ns(), type, id);
ec41f5ac 263 if (!qid_has_mapping(sb->s_user_ns, qid))
74a8a103 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
c39fb53b
JK		 520static 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
c411e5f6
CH		 544static int quota_setxquota(struct super_block *sb, int type, qid_t id,
545 void __user *addr)
546{
547 struct fs_disk_quota fdq;
14bf61ff 548 struct qc_dqblk qdq;
74a8a103 549 struct kqid qid;
c411e5f6
CH		 550
551 if (copy_from_user(&fdq, addr, sizeof(fdq)))
552 return -EFAULT;
c472b432 553 if (!sb->s_qcop->set_dqblk)
f450d4fe 554 return -ENOSYS;
74a8a103 555 qid = make_kqid(current_user_ns(), type, id);
ec41f5ac 556 if (!qid_has_mapping(sb->s_user_ns, qid))
74a8a103 557 return -EINVAL;
c39fb53b 558 /* Are we actually setting timer / warning limits for all users? */
fe8e1cba 559 if (from_kqid(&init_user_ns, qid) == 0 &&
c39fb53b
JK		 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 }
14bf61ff
JK		 573 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;
c411e5f6
CH		 604}
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;
14bf61ff 610 struct qc_dqblk qdq;
74a8a103 611 struct kqid qid;
c411e5f6
CH		 612 int ret;
613
b9b2dd36 614 if (!sb->s_qcop->get_dqblk)
f450d4fe 615 return -ENOSYS;
74a8a103 616 qid = make_kqid(current_user_ns(), type, id);
ec41f5ac 617 if (!qid_has_mapping(sb->s_user_ns, qid))
74a8a103 618 return -EINVAL;
14bf61ff
JK		 619 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)))
c411e5f6
CH		 624 return -EFAULT;
625 return ret;
626}
627
9da93f9b
ES		 628static 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
c411e5f6
CH		 639/* Copy parameters and call proper function */
640static int do_quotactl(struct super_block *sb, int type, int cmd, qid_t id,
f00c9e44 641 void __user *addr, struct path *path)
c411e5f6 642{
c988afb5
CH		 643 int ret;
644
645 if (type >= (XQM_COMMAND(cmd) ? XQM_MAXQUOTAS : MAXQUOTAS))
646 return -EINVAL;
2c5f648a
JK		 647 /*
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 */
c988afb5
CH		 651 if (!sb->s_qcop)
652 return -ENOSYS;
2c5f648a
JK		 653 if (!(sb->s_quota_types & (1 << type)))
654 return -EINVAL;
c988afb5
CH		 655
656 ret = check_quotactl_permission(sb, type, cmd, id);
657 if (ret < 0)
658 return ret;
659
c411e5f6
CH		 660 switch (cmd) {
661 case Q_QUOTAON:
f00c9e44 662 return quota_quotaon(sb, type, cmd, id, path);
c411e5f6 663 case Q_QUOTAOFF:
d3b86324 664 return quota_quotaoff(sb, type);
c411e5f6
CH		 665 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:
6ae09575
CH		 676 if (!sb->s_qcop->quota_sync)
677 return -ENOSYS;
ceed1723 678 return sb->s_qcop->quota_sync(sb, type);
c411e5f6 679 case Q_XQUOTAON:
38e478c4 680 return quota_enable(sb, addr);
c411e5f6 681 case Q_XQUOTAOFF:
38e478c4 682 return quota_disable(sb, addr);
9da93f9b
ES		 683 case Q_XQUOTARM:
684 return quota_rmxquota(sb, addr);
c411e5f6
CH		 685 case Q_XGETQSTAT:
686 return quota_getxstate(sb, addr);
af30cb44
CS		 687 case Q_XGETQSTATV:
688 return quota_getxstatev(sb, addr);
c411e5f6
CH		 689 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:
8c4e4acd
CH		 694 if (sb->s_flags & MS_RDONLY)
695 return -EROFS;
4b217ed9 696 /* XFS quotas are fully coherent now, making this call a noop */
8c4e4acd 697 return 0;
c411e5f6 698 default:
f450d4fe 699 return -EINVAL;
1da177e4 700 }
1da177e4
LT		 701}
702
56df1278
LJ		 703#ifdef CONFIG_BLOCK
704
dcdbed85
JK		 705/* 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:
af30cb44 713 case Q_XGETQSTATV:
dcdbed85
JK		 714 case Q_XGETQUOTA:
715 case Q_XQUOTASYNC:
716 return 0;
717 }
718 return 1;
719}
720
56df1278
LJ		 721#endif /* CONFIG_BLOCK */
722
9361401e
DH		 723/*
724 * 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 */
dcdbed85 727static struct super_block *quotactl_block(const char __user *special, int cmd)
9361401e
DH		 728{
729#ifdef CONFIG_BLOCK
730 struct block_device *bdev;
731 struct super_block *sb;
91a27b2a 732 struct filename *tmp = getname(special);
9361401e
DH		 733
734 if (IS_ERR(tmp))
e231c2ee 735 return ERR_CAST(tmp);
4a959886 736 bdev = lookup_bdev(tmp->name, 0);
9361401e
DH		 737 putname(tmp);
738 if (IS_ERR(bdev))
e231c2ee 739 return ERR_CAST(bdev);
dcdbed85
JK		 740 if (quotactl_cmd_write(cmd))
741 sb = get_super_thawed(bdev);
742 else
743 sb = get_super(bdev);
9361401e
DH		 744 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
1da177e4
LT		 754/*
755 * 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 */
3cdad428
HC		 760SYSCALL_DEFINE4(quotactl, unsigned int, cmd, const char __user *, special,
761 qid_t, id, void __user *, addr)
1da177e4
LT		 762{
763 uint cmds, type;
764 struct super_block *sb = NULL;
f00c9e44 765 struct path path, *pathp = NULL;
1da177e4
LT		 766 int ret;
767
768 cmds = cmd >> SUBCMDSHIFT;
769 type = cmd & SUBCMDMASK;
770
6ae09575
CH		 771 /*
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;
1da177e4
LT		 780 }
781
f00c9e44
JK		 782 /*
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) {
815d405c 788 ret = user_path_at(AT_FDCWD, addr, LOOKUP_FOLLOW|LOOKUP_AUTOMOUNT, &path);
f00c9e44
JK		 789 if (ret)
790 pathp = ERR_PTR(ret);
791 else
792 pathp = &path;
793 }
794
dcdbed85 795 sb = quotactl_block(special, cmds);
0aaa6188
JK		 796 if (IS_ERR(sb)) {
797 ret = PTR_ERR(sb);
798 goto out;
799 }
6ae09575 800
f00c9e44 801 ret = do_quotactl(sb, type, cmds, id, addr, pathp);
1da177e4 802
6ae09575 803 drop_super(sb);
0aaa6188 804out:
f00c9e44
JK		 805 if (pathp && !IS_ERR(pathp))
806 path_put(pathp);
1da177e4
LT		 807 return ret;
808}
Ubuntu Artful kernel mirror