Merge git://git.kernel.org/pub/scm/linux/kernel/git/herbert/crypto-2.6
[firefly-linux-kernel-4.4.55.git] / fs / quota / quota.c
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>
12 #include <linux/uaccess.h>
13 #include <linux/kernel.h>
14 #include <linux/security.h>
15 #include <linux/syscalls.h>
16 #include <linux/capability.h>
17 #include <linux/quotaops.h>
18 #include <linux/types.h>
19 #include <linux/writeback.h>
20
21 static int check_quotactl_permission(struct super_block *sb, int type, int cmd,
22                                      qid_t id)
23 {
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:
30         case Q_XGETQSTATV:
31         case Q_XQUOTASYNC:
32                 break;
33         /* allow to query information for dquots we "own" */
34         case Q_GETQUOTA:
35         case Q_XGETQUOTA:
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))))
38                         break;
39                 /*FALLTHROUGH*/
40         default:
41                 if (!capable(CAP_SYS_ADMIN))
42                         return -EPERM;
43         }
44
45         return security_quotactl(cmd, type, id, sb);
46 }
47
48 static void quota_sync_one(struct super_block *sb, void *arg)
49 {
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);
55 }
56
57 static int quota_sync_all(int type)
58 {
59         int ret;
60
61         if (type >= MAXQUOTAS)
62                 return -EINVAL;
63         ret = security_quotactl(Q_SYNC, type, 0, NULL);
64         if (!ret)
65                 iterate_supers(quota_sync_one, &type);
66         return ret;
67 }
68
69 unsigned 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
82 static int quota_quotaon(struct super_block *sb, int type, int cmd, qid_t id,
83                          struct path *path)
84 {
85         if (!sb->s_qcop->quota_on && !sb->s_qcop->quota_enable)
86                 return -ENOSYS;
87         if (sb->s_qcop->quota_enable)
88                 return sb->s_qcop->quota_enable(sb, qtype_enforce_flag(type));
89         if (IS_ERR(path))
90                 return PTR_ERR(path);
91         return sb->s_qcop->quota_on(sb, type, id, path);
92 }
93
94 static 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
103 static int quota_getfmt(struct super_block *sb, int type, void __user *addr)
104 {
105         __u32 fmt;
106
107         mutex_lock(&sb_dqopt(sb)->dqonoff_mutex);
108         if (!sb_has_quota_active(sb, type)) {
109                 mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
110                 return -ESRCH;
111         }
112         fmt = sb_dqopt(sb)->info[type].dqi_format->qf_fmt_id;
113         mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
114         if (copy_to_user(addr, &fmt, sizeof(fmt)))
115                 return -EFAULT;
116         return 0;
117 }
118
119 static int quota_getinfo(struct super_block *sb, int type, void __user *addr)
120 {
121         struct qc_state state;
122         struct qc_type_state *tstate;
123         struct if_dqinfo uinfo;
124         int ret;
125
126         /* This checks whether qc_state has enough entries... */
127         BUILD_BUG_ON(MAXQUOTAS > XQM_MAXQUOTAS);
128         if (!sb->s_qcop->get_state)
129                 return -ENOSYS;
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)))
145                 return -EFAULT;
146         return ret;
147 }
148
149 static int quota_setinfo(struct super_block *sb, int type, void __user *addr)
150 {
151         struct if_dqinfo info;
152         struct qc_info qinfo;
153
154         if (copy_from_user(&info, addr, sizeof(info)))
155                 return -EFAULT;
156         if (!sb->s_qcop->set_info)
157                 return -ENOSYS;
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);
177 }
178
179 static inline qsize_t qbtos(qsize_t blocks)
180 {
181         return blocks << QIF_DQBLKSIZE_BITS;
182 }
183
184 static inline qsize_t stoqb(qsize_t space)
185 {
186         return (space + QIF_DQBLKSIZE - 1) >> QIF_DQBLKSIZE_BITS;
187 }
188
189 static void copy_to_if_dqblk(struct if_dqblk *dst, struct qc_dqblk *src)
190 {
191         memset(dst, 0, sizeof(*dst));
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;
195         dst->dqb_ihardlimit = src->d_ino_hardlimit;
196         dst->dqb_isoftlimit = src->d_ino_softlimit;
197         dst->dqb_curinodes = src->d_ino_count;
198         dst->dqb_btime = src->d_spc_timer;
199         dst->dqb_itime = src->d_ino_timer;
200         dst->dqb_valid = QIF_ALL;
201 }
202
203 static int quota_getquota(struct super_block *sb, int type, qid_t id,
204                           void __user *addr)
205 {
206         struct kqid qid;
207         struct qc_dqblk fdq;
208         struct if_dqblk idq;
209         int ret;
210
211         if (!sb->s_qcop->get_dqblk)
212                 return -ENOSYS;
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);
217         if (ret)
218                 return ret;
219         copy_to_if_dqblk(&idq, &fdq);
220         if (copy_to_user(addr, &idq, sizeof(idq)))
221                 return -EFAULT;
222         return 0;
223 }
224
225 static void copy_from_if_dqblk(struct qc_dqblk *dst, struct if_dqblk *src)
226 {
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;
230         dst->d_ino_hardlimit = src->dqb_ihardlimit;
231         dst->d_ino_softlimit = src->dqb_isoftlimit;
232         dst->d_ino_count = src->dqb_curinodes;
233         dst->d_spc_timer = src->dqb_btime;
234         dst->d_ino_timer = src->dqb_itime;
235
236         dst->d_fieldmask = 0;
237         if (src->dqb_valid & QIF_BLIMITS)
238                 dst->d_fieldmask |= QC_SPC_SOFT | QC_SPC_HARD;
239         if (src->dqb_valid & QIF_SPACE)
240                 dst->d_fieldmask |= QC_SPACE;
241         if (src->dqb_valid & QIF_ILIMITS)
242                 dst->d_fieldmask |= QC_INO_SOFT | QC_INO_HARD;
243         if (src->dqb_valid & QIF_INODES)
244                 dst->d_fieldmask |= QC_INO_COUNT;
245         if (src->dqb_valid & QIF_BTIME)
246                 dst->d_fieldmask |= QC_SPC_TIMER;
247         if (src->dqb_valid & QIF_ITIME)
248                 dst->d_fieldmask |= QC_INO_TIMER;
249 }
250
251 static int quota_setquota(struct super_block *sb, int type, qid_t id,
252                           void __user *addr)
253 {
254         struct qc_dqblk fdq;
255         struct if_dqblk idq;
256         struct kqid qid;
257
258         if (copy_from_user(&idq, addr, sizeof(idq)))
259                 return -EFAULT;
260         if (!sb->s_qcop->set_dqblk)
261                 return -ENOSYS;
262         qid = make_kqid(current_user_ns(), type, id);
263         if (!qid_valid(qid))
264                 return -EINVAL;
265         copy_from_if_dqblk(&fdq, &idq);
266         return sb->s_qcop->set_dqblk(sb, qid, &fdq);
267 }
268
269 static int quota_enable(struct super_block *sb, void __user *addr)
270 {
271         __u32 flags;
272
273         if (copy_from_user(&flags, addr, sizeof(flags)))
274                 return -EFAULT;
275         if (!sb->s_qcop->quota_enable)
276                 return -ENOSYS;
277         return sb->s_qcop->quota_enable(sb, flags);
278 }
279
280 static 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);
289 }
290
291 static 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
310 static 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
367 static int quota_getxstate(struct super_block *sb, void __user *addr)
368 {
369         struct fs_quota_stat fqs;
370         int ret;
371
372         if (!sb->s_qcop->get_state)
373                 return -ENOSYS;
374         ret = quota_getstate(sb, &fqs);
375         if (!ret && copy_to_user(addr, &fqs, sizeof(fqs)))
376                 return -EFAULT;
377         return ret;
378 }
379
380 static 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
428 static int quota_getxstatev(struct super_block *sb, void __user *addr)
429 {
430         struct fs_quota_statv fqs;
431         int ret;
432
433         if (!sb->s_qcop->get_state)
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         }
447         ret = quota_getstatev(sb, &fqs);
448         if (!ret && copy_to_user(addr, &fqs, sizeof(fqs)))
449                 return -EFAULT;
450         return ret;
451 }
452
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
460 static inline u64 quota_bbtob(u64 blocks)
461 {
462         return blocks << XFS_BB_SHIFT;
463 }
464
465 static inline u64 quota_btobb(u64 bytes)
466 {
467         return (bytes + (1 << XFS_BB_SHIFT) - 1) >> XFS_BB_SHIFT;
468 }
469
470 static 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
520 static 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
544 static int quota_setxquota(struct super_block *sb, int type, qid_t id,
545                            void __user *addr)
546 {
547         struct fs_disk_quota fdq;
548         struct qc_dqblk qdq;
549         struct kqid qid;
550
551         if (copy_from_user(&fdq, addr, sizeof(fdq)))
552                 return -EFAULT;
553         if (!sb->s_qcop->set_dqblk)
554                 return -ENOSYS;
555         qid = make_kqid(current_user_ns(), type, id);
556         if (!qid_valid(qid))
557                 return -EINVAL;
558         /* 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         }
573         copy_from_xfs_dqblk(&qdq, &fdq);
574         return sb->s_qcop->set_dqblk(sb, qid, &qdq);
575 }
576
577 static 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;
604 }
605
606 static int quota_getxquota(struct super_block *sb, int type, qid_t id,
607                            void __user *addr)
608 {
609         struct fs_disk_quota fdq;
610         struct qc_dqblk qdq;
611         struct kqid qid;
612         int ret;
613
614         if (!sb->s_qcop->get_dqblk)
615                 return -ENOSYS;
616         qid = make_kqid(current_user_ns(), type, id);
617         if (!qid_valid(qid))
618                 return -EINVAL;
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)))
624                 return -EFAULT;
625         return ret;
626 }
627
628 static 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
639 /* Copy parameters and call proper function */
640 static int do_quotactl(struct super_block *sb, int type, int cmd, qid_t id,
641                        void __user *addr, struct path *path)
642 {
643         int ret;
644
645         if (type >= (XQM_COMMAND(cmd) ? XQM_MAXQUOTAS : MAXQUOTAS))
646                 return -EINVAL;
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          */
651         if (!sb->s_qcop)
652                 return -ENOSYS;
653         if (!(sb->s_quota_types & (1 << type)))
654                 return -EINVAL;
655
656         ret = check_quotactl_permission(sb, type, cmd, id);
657         if (ret < 0)
658                 return ret;
659
660         switch (cmd) {
661         case Q_QUOTAON:
662                 return quota_quotaon(sb, type, cmd, id, path);
663         case Q_QUOTAOFF:
664                 return quota_quotaoff(sb, type);
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:
676                 if (!sb->s_qcop->quota_sync)
677                         return -ENOSYS;
678                 return sb->s_qcop->quota_sync(sb, type);
679         case Q_XQUOTAON:
680                 return quota_enable(sb, addr);
681         case Q_XQUOTAOFF:
682                 return quota_disable(sb, addr);
683         case Q_XQUOTARM:
684                 return quota_rmxquota(sb, addr);
685         case Q_XGETQSTAT:
686                 return quota_getxstate(sb, addr);
687         case Q_XGETQSTATV:
688                 return quota_getxstatev(sb, addr);
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:
694                 if (sb->s_flags & MS_RDONLY)
695                         return -EROFS;
696                 /* XFS quotas are fully coherent now, making this call a noop */
697                 return 0;
698         default:
699                 return -EINVAL;
700         }
701 }
702
703 #ifdef CONFIG_BLOCK
704
705 /* Return 1 if 'cmd' will block on frozen filesystem */
706 static 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:
713         case Q_XGETQSTATV:
714         case Q_XGETQUOTA:
715         case Q_XQUOTASYNC:
716                 return 0;
717         }
718         return 1;
719 }
720
721 #endif /* CONFIG_BLOCK */
722
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  */
727 static struct super_block *quotactl_block(const char __user *special, int cmd)
728 {
729 #ifdef CONFIG_BLOCK
730         struct block_device *bdev;
731         struct super_block *sb;
732         struct filename *tmp = getname(special);
733
734         if (IS_ERR(tmp))
735                 return ERR_CAST(tmp);
736         bdev = lookup_bdev(tmp->name);
737         putname(tmp);
738         if (IS_ERR(bdev))
739                 return ERR_CAST(bdev);
740         if (quotactl_cmd_write(cmd))
741                 sb = get_super_thawed(bdev);
742         else
743                 sb = get_super(bdev);
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
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  */
760 SYSCALL_DEFINE4(quotactl, unsigned int, cmd, const char __user *, special,
761                 qid_t, id, void __user *, addr)
762 {
763         uint cmds, type;
764         struct super_block *sb = NULL;
765         struct path path, *pathp = NULL;
766         int ret;
767
768         cmds = cmd >> SUBCMDSHIFT;
769         type = cmd & SUBCMDMASK;
770
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;
780         }
781
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) {
788                 ret = user_path_at(AT_FDCWD, addr, LOOKUP_FOLLOW|LOOKUP_AUTOMOUNT, &path);
789                 if (ret)
790                         pathp = ERR_PTR(ret);
791                 else
792                         pathp = &path;
793         }
794
795         sb = quotactl_block(special, cmds);
796         if (IS_ERR(sb)) {
797                 ret = PTR_ERR(sb);
798                 goto out;
799         }
800
801         ret = do_quotactl(sb, type, cmds, id, addr, pathp);
802
803         drop_super(sb);
804 out:
805         if (pathp && !IS_ERR(pathp))
806                 path_put(pathp);
807         return ret;
808 }