Merge branch 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jack/linux-fs
[sfrench/cifs-2.6.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, qid_t id,
83                          const 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         if (!sb_has_quota_active(sb, type))
108                 return -ESRCH;
109         fmt = sb_dqopt(sb)->info[type].dqi_format->qf_fmt_id;
110         if (copy_to_user(addr, &fmt, sizeof(fmt)))
111                 return -EFAULT;
112         return 0;
113 }
114
115 static int quota_getinfo(struct super_block *sb, int type, void __user *addr)
116 {
117         struct qc_state state;
118         struct qc_type_state *tstate;
119         struct if_dqinfo uinfo;
120         int ret;
121
122         /* This checks whether qc_state has enough entries... */
123         BUILD_BUG_ON(MAXQUOTAS > XQM_MAXQUOTAS);
124         if (!sb->s_qcop->get_state)
125                 return -ENOSYS;
126         ret = sb->s_qcop->get_state(sb, &state);
127         if (ret)
128                 return ret;
129         tstate = state.s_state + type;
130         if (!(tstate->flags & QCI_ACCT_ENABLED))
131                 return -ESRCH;
132         memset(&uinfo, 0, sizeof(uinfo));
133         uinfo.dqi_bgrace = tstate->spc_timelimit;
134         uinfo.dqi_igrace = tstate->ino_timelimit;
135         if (tstate->flags & QCI_SYSFILE)
136                 uinfo.dqi_flags |= DQF_SYS_FILE;
137         if (tstate->flags & QCI_ROOT_SQUASH)
138                 uinfo.dqi_flags |= DQF_ROOT_SQUASH;
139         uinfo.dqi_valid = IIF_ALL;
140         if (copy_to_user(addr, &uinfo, sizeof(uinfo)))
141                 return -EFAULT;
142         return 0;
143 }
144
145 static int quota_setinfo(struct super_block *sb, int type, void __user *addr)
146 {
147         struct if_dqinfo info;
148         struct qc_info qinfo;
149
150         if (copy_from_user(&info, addr, sizeof(info)))
151                 return -EFAULT;
152         if (!sb->s_qcop->set_info)
153                 return -ENOSYS;
154         if (info.dqi_valid & ~(IIF_FLAGS | IIF_BGRACE | IIF_IGRACE))
155                 return -EINVAL;
156         memset(&qinfo, 0, sizeof(qinfo));
157         if (info.dqi_valid & IIF_FLAGS) {
158                 if (info.dqi_flags & ~DQF_SETINFO_MASK)
159                         return -EINVAL;
160                 if (info.dqi_flags & DQF_ROOT_SQUASH)
161                         qinfo.i_flags |= QCI_ROOT_SQUASH;
162                 qinfo.i_fieldmask |= QC_FLAGS;
163         }
164         if (info.dqi_valid & IIF_BGRACE) {
165                 qinfo.i_spc_timelimit = info.dqi_bgrace;
166                 qinfo.i_fieldmask |= QC_SPC_TIMER;
167         }
168         if (info.dqi_valid & IIF_IGRACE) {
169                 qinfo.i_ino_timelimit = info.dqi_igrace;
170                 qinfo.i_fieldmask |= QC_INO_TIMER;
171         }
172         return sb->s_qcop->set_info(sb, type, &qinfo);
173 }
174
175 static inline qsize_t qbtos(qsize_t blocks)
176 {
177         return blocks << QIF_DQBLKSIZE_BITS;
178 }
179
180 static inline qsize_t stoqb(qsize_t space)
181 {
182         return (space + QIF_DQBLKSIZE - 1) >> QIF_DQBLKSIZE_BITS;
183 }
184
185 static void copy_to_if_dqblk(struct if_dqblk *dst, struct qc_dqblk *src)
186 {
187         memset(dst, 0, sizeof(*dst));
188         dst->dqb_bhardlimit = stoqb(src->d_spc_hardlimit);
189         dst->dqb_bsoftlimit = stoqb(src->d_spc_softlimit);
190         dst->dqb_curspace = src->d_space;
191         dst->dqb_ihardlimit = src->d_ino_hardlimit;
192         dst->dqb_isoftlimit = src->d_ino_softlimit;
193         dst->dqb_curinodes = src->d_ino_count;
194         dst->dqb_btime = src->d_spc_timer;
195         dst->dqb_itime = src->d_ino_timer;
196         dst->dqb_valid = QIF_ALL;
197 }
198
199 static int quota_getquota(struct super_block *sb, int type, qid_t id,
200                           void __user *addr)
201 {
202         struct kqid qid;
203         struct qc_dqblk fdq;
204         struct if_dqblk idq;
205         int ret;
206
207         if (!sb->s_qcop->get_dqblk)
208                 return -ENOSYS;
209         qid = make_kqid(current_user_ns(), type, id);
210         if (!qid_has_mapping(sb->s_user_ns, qid))
211                 return -EINVAL;
212         ret = sb->s_qcop->get_dqblk(sb, qid, &fdq);
213         if (ret)
214                 return ret;
215         copy_to_if_dqblk(&idq, &fdq);
216         if (copy_to_user(addr, &idq, sizeof(idq)))
217                 return -EFAULT;
218         return 0;
219 }
220
221 /*
222  * Return quota for next active quota >= this id, if any exists,
223  * otherwise return -ENOENT via ->get_nextdqblk
224  */
225 static int quota_getnextquota(struct super_block *sb, int type, qid_t id,
226                           void __user *addr)
227 {
228         struct kqid qid;
229         struct qc_dqblk fdq;
230         struct if_nextdqblk idq;
231         int ret;
232
233         if (!sb->s_qcop->get_nextdqblk)
234                 return -ENOSYS;
235         qid = make_kqid(current_user_ns(), type, id);
236         if (!qid_has_mapping(sb->s_user_ns, qid))
237                 return -EINVAL;
238         ret = sb->s_qcop->get_nextdqblk(sb, &qid, &fdq);
239         if (ret)
240                 return ret;
241         /* struct if_nextdqblk is a superset of struct if_dqblk */
242         copy_to_if_dqblk((struct if_dqblk *)&idq, &fdq);
243         idq.dqb_id = from_kqid(current_user_ns(), qid);
244         if (copy_to_user(addr, &idq, sizeof(idq)))
245                 return -EFAULT;
246         return 0;
247 }
248
249 static void copy_from_if_dqblk(struct qc_dqblk *dst, struct if_dqblk *src)
250 {
251         dst->d_spc_hardlimit = qbtos(src->dqb_bhardlimit);
252         dst->d_spc_softlimit = qbtos(src->dqb_bsoftlimit);
253         dst->d_space = src->dqb_curspace;
254         dst->d_ino_hardlimit = src->dqb_ihardlimit;
255         dst->d_ino_softlimit = src->dqb_isoftlimit;
256         dst->d_ino_count = src->dqb_curinodes;
257         dst->d_spc_timer = src->dqb_btime;
258         dst->d_ino_timer = src->dqb_itime;
259
260         dst->d_fieldmask = 0;
261         if (src->dqb_valid & QIF_BLIMITS)
262                 dst->d_fieldmask |= QC_SPC_SOFT | QC_SPC_HARD;
263         if (src->dqb_valid & QIF_SPACE)
264                 dst->d_fieldmask |= QC_SPACE;
265         if (src->dqb_valid & QIF_ILIMITS)
266                 dst->d_fieldmask |= QC_INO_SOFT | QC_INO_HARD;
267         if (src->dqb_valid & QIF_INODES)
268                 dst->d_fieldmask |= QC_INO_COUNT;
269         if (src->dqb_valid & QIF_BTIME)
270                 dst->d_fieldmask |= QC_SPC_TIMER;
271         if (src->dqb_valid & QIF_ITIME)
272                 dst->d_fieldmask |= QC_INO_TIMER;
273 }
274
275 static int quota_setquota(struct super_block *sb, int type, qid_t id,
276                           void __user *addr)
277 {
278         struct qc_dqblk fdq;
279         struct if_dqblk idq;
280         struct kqid qid;
281
282         if (copy_from_user(&idq, addr, sizeof(idq)))
283                 return -EFAULT;
284         if (!sb->s_qcop->set_dqblk)
285                 return -ENOSYS;
286         qid = make_kqid(current_user_ns(), type, id);
287         if (!qid_has_mapping(sb->s_user_ns, qid))
288                 return -EINVAL;
289         copy_from_if_dqblk(&fdq, &idq);
290         return sb->s_qcop->set_dqblk(sb, qid, &fdq);
291 }
292
293 static int quota_enable(struct super_block *sb, void __user *addr)
294 {
295         __u32 flags;
296
297         if (copy_from_user(&flags, addr, sizeof(flags)))
298                 return -EFAULT;
299         if (!sb->s_qcop->quota_enable)
300                 return -ENOSYS;
301         return sb->s_qcop->quota_enable(sb, flags);
302 }
303
304 static int quota_disable(struct super_block *sb, void __user *addr)
305 {
306         __u32 flags;
307
308         if (copy_from_user(&flags, addr, sizeof(flags)))
309                 return -EFAULT;
310         if (!sb->s_qcop->quota_disable)
311                 return -ENOSYS;
312         return sb->s_qcop->quota_disable(sb, flags);
313 }
314
315 static int quota_state_to_flags(struct qc_state *state)
316 {
317         int flags = 0;
318
319         if (state->s_state[USRQUOTA].flags & QCI_ACCT_ENABLED)
320                 flags |= FS_QUOTA_UDQ_ACCT;
321         if (state->s_state[USRQUOTA].flags & QCI_LIMITS_ENFORCED)
322                 flags |= FS_QUOTA_UDQ_ENFD;
323         if (state->s_state[GRPQUOTA].flags & QCI_ACCT_ENABLED)
324                 flags |= FS_QUOTA_GDQ_ACCT;
325         if (state->s_state[GRPQUOTA].flags & QCI_LIMITS_ENFORCED)
326                 flags |= FS_QUOTA_GDQ_ENFD;
327         if (state->s_state[PRJQUOTA].flags & QCI_ACCT_ENABLED)
328                 flags |= FS_QUOTA_PDQ_ACCT;
329         if (state->s_state[PRJQUOTA].flags & QCI_LIMITS_ENFORCED)
330                 flags |= FS_QUOTA_PDQ_ENFD;
331         return flags;
332 }
333
334 static int quota_getstate(struct super_block *sb, struct fs_quota_stat *fqs)
335 {
336         int type;
337         struct qc_state state;
338         int ret;
339
340         memset(&state, 0, sizeof (struct qc_state));
341         ret = sb->s_qcop->get_state(sb, &state);
342         if (ret < 0)
343                 return ret;
344
345         memset(fqs, 0, sizeof(*fqs));
346         fqs->qs_version = FS_QSTAT_VERSION;
347         fqs->qs_flags = quota_state_to_flags(&state);
348         /* No quota enabled? */
349         if (!fqs->qs_flags)
350                 return -ENOSYS;
351         fqs->qs_incoredqs = state.s_incoredqs;
352         /*
353          * GETXSTATE quotactl has space for just one set of time limits so
354          * report them for the first enabled quota type
355          */
356         for (type = 0; type < XQM_MAXQUOTAS; type++)
357                 if (state.s_state[type].flags & QCI_ACCT_ENABLED)
358                         break;
359         BUG_ON(type == XQM_MAXQUOTAS);
360         fqs->qs_btimelimit = state.s_state[type].spc_timelimit;
361         fqs->qs_itimelimit = state.s_state[type].ino_timelimit;
362         fqs->qs_rtbtimelimit = state.s_state[type].rt_spc_timelimit;
363         fqs->qs_bwarnlimit = state.s_state[type].spc_warnlimit;
364         fqs->qs_iwarnlimit = state.s_state[type].ino_warnlimit;
365
366         /* Inodes may be allocated even if inactive; copy out if present */
367         if (state.s_state[USRQUOTA].ino) {
368                 fqs->qs_uquota.qfs_ino = state.s_state[USRQUOTA].ino;
369                 fqs->qs_uquota.qfs_nblks = state.s_state[USRQUOTA].blocks;
370                 fqs->qs_uquota.qfs_nextents = state.s_state[USRQUOTA].nextents;
371         }
372         if (state.s_state[GRPQUOTA].ino) {
373                 fqs->qs_gquota.qfs_ino = state.s_state[GRPQUOTA].ino;
374                 fqs->qs_gquota.qfs_nblks = state.s_state[GRPQUOTA].blocks;
375                 fqs->qs_gquota.qfs_nextents = state.s_state[GRPQUOTA].nextents;
376         }
377         if (state.s_state[PRJQUOTA].ino) {
378                 /*
379                  * Q_XGETQSTAT doesn't have room for both group and project
380                  * quotas.  So, allow the project quota values to be copied out
381                  * only if there is no group quota information available.
382                  */
383                 if (!(state.s_state[GRPQUOTA].flags & QCI_ACCT_ENABLED)) {
384                         fqs->qs_gquota.qfs_ino = state.s_state[PRJQUOTA].ino;
385                         fqs->qs_gquota.qfs_nblks =
386                                         state.s_state[PRJQUOTA].blocks;
387                         fqs->qs_gquota.qfs_nextents =
388                                         state.s_state[PRJQUOTA].nextents;
389                 }
390         }
391         return 0;
392 }
393
394 static int quota_getxstate(struct super_block *sb, void __user *addr)
395 {
396         struct fs_quota_stat fqs;
397         int ret;
398
399         if (!sb->s_qcop->get_state)
400                 return -ENOSYS;
401         ret = quota_getstate(sb, &fqs);
402         if (!ret && copy_to_user(addr, &fqs, sizeof(fqs)))
403                 return -EFAULT;
404         return ret;
405 }
406
407 static int quota_getstatev(struct super_block *sb, struct fs_quota_statv *fqs)
408 {
409         int type;
410         struct qc_state state;
411         int ret;
412
413         memset(&state, 0, sizeof (struct qc_state));
414         ret = sb->s_qcop->get_state(sb, &state);
415         if (ret < 0)
416                 return ret;
417
418         memset(fqs, 0, sizeof(*fqs));
419         fqs->qs_version = FS_QSTAT_VERSION;
420         fqs->qs_flags = quota_state_to_flags(&state);
421         /* No quota enabled? */
422         if (!fqs->qs_flags)
423                 return -ENOSYS;
424         fqs->qs_incoredqs = state.s_incoredqs;
425         /*
426          * GETXSTATV quotactl has space for just one set of time limits so
427          * report them for the first enabled quota type
428          */
429         for (type = 0; type < XQM_MAXQUOTAS; type++)
430                 if (state.s_state[type].flags & QCI_ACCT_ENABLED)
431                         break;
432         BUG_ON(type == XQM_MAXQUOTAS);
433         fqs->qs_btimelimit = state.s_state[type].spc_timelimit;
434         fqs->qs_itimelimit = state.s_state[type].ino_timelimit;
435         fqs->qs_rtbtimelimit = state.s_state[type].rt_spc_timelimit;
436         fqs->qs_bwarnlimit = state.s_state[type].spc_warnlimit;
437         fqs->qs_iwarnlimit = state.s_state[type].ino_warnlimit;
438
439         /* Inodes may be allocated even if inactive; copy out if present */
440         if (state.s_state[USRQUOTA].ino) {
441                 fqs->qs_uquota.qfs_ino = state.s_state[USRQUOTA].ino;
442                 fqs->qs_uquota.qfs_nblks = state.s_state[USRQUOTA].blocks;
443                 fqs->qs_uquota.qfs_nextents = state.s_state[USRQUOTA].nextents;
444         }
445         if (state.s_state[GRPQUOTA].ino) {
446                 fqs->qs_gquota.qfs_ino = state.s_state[GRPQUOTA].ino;
447                 fqs->qs_gquota.qfs_nblks = state.s_state[GRPQUOTA].blocks;
448                 fqs->qs_gquota.qfs_nextents = state.s_state[GRPQUOTA].nextents;
449         }
450         if (state.s_state[PRJQUOTA].ino) {
451                 fqs->qs_pquota.qfs_ino = state.s_state[PRJQUOTA].ino;
452                 fqs->qs_pquota.qfs_nblks = state.s_state[PRJQUOTA].blocks;
453                 fqs->qs_pquota.qfs_nextents = state.s_state[PRJQUOTA].nextents;
454         }
455         return 0;
456 }
457
458 static int quota_getxstatev(struct super_block *sb, void __user *addr)
459 {
460         struct fs_quota_statv fqs;
461         int ret;
462
463         if (!sb->s_qcop->get_state)
464                 return -ENOSYS;
465
466         memset(&fqs, 0, sizeof(fqs));
467         if (copy_from_user(&fqs, addr, 1)) /* Just read qs_version */
468                 return -EFAULT;
469
470         /* If this kernel doesn't support user specified version, fail */
471         switch (fqs.qs_version) {
472         case FS_QSTATV_VERSION1:
473                 break;
474         default:
475                 return -EINVAL;
476         }
477         ret = quota_getstatev(sb, &fqs);
478         if (!ret && copy_to_user(addr, &fqs, sizeof(fqs)))
479                 return -EFAULT;
480         return ret;
481 }
482
483 /*
484  * XFS defines BBTOB and BTOBB macros inside fs/xfs/ and we cannot move them
485  * out of there as xfsprogs rely on definitions being in that header file. So
486  * just define same functions here for quota purposes.
487  */
488 #define XFS_BB_SHIFT 9
489
490 static inline u64 quota_bbtob(u64 blocks)
491 {
492         return blocks << XFS_BB_SHIFT;
493 }
494
495 static inline u64 quota_btobb(u64 bytes)
496 {
497         return (bytes + (1 << XFS_BB_SHIFT) - 1) >> XFS_BB_SHIFT;
498 }
499
500 static void copy_from_xfs_dqblk(struct qc_dqblk *dst, struct fs_disk_quota *src)
501 {
502         dst->d_spc_hardlimit = quota_bbtob(src->d_blk_hardlimit);
503         dst->d_spc_softlimit = quota_bbtob(src->d_blk_softlimit);
504         dst->d_ino_hardlimit = src->d_ino_hardlimit;
505         dst->d_ino_softlimit = src->d_ino_softlimit;
506         dst->d_space = quota_bbtob(src->d_bcount);
507         dst->d_ino_count = src->d_icount;
508         dst->d_ino_timer = src->d_itimer;
509         dst->d_spc_timer = src->d_btimer;
510         dst->d_ino_warns = src->d_iwarns;
511         dst->d_spc_warns = src->d_bwarns;
512         dst->d_rt_spc_hardlimit = quota_bbtob(src->d_rtb_hardlimit);
513         dst->d_rt_spc_softlimit = quota_bbtob(src->d_rtb_softlimit);
514         dst->d_rt_space = quota_bbtob(src->d_rtbcount);
515         dst->d_rt_spc_timer = src->d_rtbtimer;
516         dst->d_rt_spc_warns = src->d_rtbwarns;
517         dst->d_fieldmask = 0;
518         if (src->d_fieldmask & FS_DQ_ISOFT)
519                 dst->d_fieldmask |= QC_INO_SOFT;
520         if (src->d_fieldmask & FS_DQ_IHARD)
521                 dst->d_fieldmask |= QC_INO_HARD;
522         if (src->d_fieldmask & FS_DQ_BSOFT)
523                 dst->d_fieldmask |= QC_SPC_SOFT;
524         if (src->d_fieldmask & FS_DQ_BHARD)
525                 dst->d_fieldmask |= QC_SPC_HARD;
526         if (src->d_fieldmask & FS_DQ_RTBSOFT)
527                 dst->d_fieldmask |= QC_RT_SPC_SOFT;
528         if (src->d_fieldmask & FS_DQ_RTBHARD)
529                 dst->d_fieldmask |= QC_RT_SPC_HARD;
530         if (src->d_fieldmask & FS_DQ_BTIMER)
531                 dst->d_fieldmask |= QC_SPC_TIMER;
532         if (src->d_fieldmask & FS_DQ_ITIMER)
533                 dst->d_fieldmask |= QC_INO_TIMER;
534         if (src->d_fieldmask & FS_DQ_RTBTIMER)
535                 dst->d_fieldmask |= QC_RT_SPC_TIMER;
536         if (src->d_fieldmask & FS_DQ_BWARNS)
537                 dst->d_fieldmask |= QC_SPC_WARNS;
538         if (src->d_fieldmask & FS_DQ_IWARNS)
539                 dst->d_fieldmask |= QC_INO_WARNS;
540         if (src->d_fieldmask & FS_DQ_RTBWARNS)
541                 dst->d_fieldmask |= QC_RT_SPC_WARNS;
542         if (src->d_fieldmask & FS_DQ_BCOUNT)
543                 dst->d_fieldmask |= QC_SPACE;
544         if (src->d_fieldmask & FS_DQ_ICOUNT)
545                 dst->d_fieldmask |= QC_INO_COUNT;
546         if (src->d_fieldmask & FS_DQ_RTBCOUNT)
547                 dst->d_fieldmask |= QC_RT_SPACE;
548 }
549
550 static void copy_qcinfo_from_xfs_dqblk(struct qc_info *dst,
551                                        struct fs_disk_quota *src)
552 {
553         memset(dst, 0, sizeof(*dst));
554         dst->i_spc_timelimit = src->d_btimer;
555         dst->i_ino_timelimit = src->d_itimer;
556         dst->i_rt_spc_timelimit = src->d_rtbtimer;
557         dst->i_ino_warnlimit = src->d_iwarns;
558         dst->i_spc_warnlimit = src->d_bwarns;
559         dst->i_rt_spc_warnlimit = src->d_rtbwarns;
560         if (src->d_fieldmask & FS_DQ_BWARNS)
561                 dst->i_fieldmask |= QC_SPC_WARNS;
562         if (src->d_fieldmask & FS_DQ_IWARNS)
563                 dst->i_fieldmask |= QC_INO_WARNS;
564         if (src->d_fieldmask & FS_DQ_RTBWARNS)
565                 dst->i_fieldmask |= QC_RT_SPC_WARNS;
566         if (src->d_fieldmask & FS_DQ_BTIMER)
567                 dst->i_fieldmask |= QC_SPC_TIMER;
568         if (src->d_fieldmask & FS_DQ_ITIMER)
569                 dst->i_fieldmask |= QC_INO_TIMER;
570         if (src->d_fieldmask & FS_DQ_RTBTIMER)
571                 dst->i_fieldmask |= QC_RT_SPC_TIMER;
572 }
573
574 static int quota_setxquota(struct super_block *sb, int type, qid_t id,
575                            void __user *addr)
576 {
577         struct fs_disk_quota fdq;
578         struct qc_dqblk qdq;
579         struct kqid qid;
580
581         if (copy_from_user(&fdq, addr, sizeof(fdq)))
582                 return -EFAULT;
583         if (!sb->s_qcop->set_dqblk)
584                 return -ENOSYS;
585         qid = make_kqid(current_user_ns(), type, id);
586         if (!qid_has_mapping(sb->s_user_ns, qid))
587                 return -EINVAL;
588         /* Are we actually setting timer / warning limits for all users? */
589         if (from_kqid(sb->s_user_ns, qid) == 0 &&
590             fdq.d_fieldmask & (FS_DQ_WARNS_MASK | FS_DQ_TIMER_MASK)) {
591                 struct qc_info qinfo;
592                 int ret;
593
594                 if (!sb->s_qcop->set_info)
595                         return -EINVAL;
596                 copy_qcinfo_from_xfs_dqblk(&qinfo, &fdq);
597                 ret = sb->s_qcop->set_info(sb, type, &qinfo);
598                 if (ret)
599                         return ret;
600                 /* These are already done */
601                 fdq.d_fieldmask &= ~(FS_DQ_WARNS_MASK | FS_DQ_TIMER_MASK);
602         }
603         copy_from_xfs_dqblk(&qdq, &fdq);
604         return sb->s_qcop->set_dqblk(sb, qid, &qdq);
605 }
606
607 static void copy_to_xfs_dqblk(struct fs_disk_quota *dst, struct qc_dqblk *src,
608                               int type, qid_t id)
609 {
610         memset(dst, 0, sizeof(*dst));
611         dst->d_version = FS_DQUOT_VERSION;
612         dst->d_id = id;
613         if (type == USRQUOTA)
614                 dst->d_flags = FS_USER_QUOTA;
615         else if (type == PRJQUOTA)
616                 dst->d_flags = FS_PROJ_QUOTA;
617         else
618                 dst->d_flags = FS_GROUP_QUOTA;
619         dst->d_blk_hardlimit = quota_btobb(src->d_spc_hardlimit);
620         dst->d_blk_softlimit = quota_btobb(src->d_spc_softlimit);
621         dst->d_ino_hardlimit = src->d_ino_hardlimit;
622         dst->d_ino_softlimit = src->d_ino_softlimit;
623         dst->d_bcount = quota_btobb(src->d_space);
624         dst->d_icount = src->d_ino_count;
625         dst->d_itimer = src->d_ino_timer;
626         dst->d_btimer = src->d_spc_timer;
627         dst->d_iwarns = src->d_ino_warns;
628         dst->d_bwarns = src->d_spc_warns;
629         dst->d_rtb_hardlimit = quota_btobb(src->d_rt_spc_hardlimit);
630         dst->d_rtb_softlimit = quota_btobb(src->d_rt_spc_softlimit);
631         dst->d_rtbcount = quota_btobb(src->d_rt_space);
632         dst->d_rtbtimer = src->d_rt_spc_timer;
633         dst->d_rtbwarns = src->d_rt_spc_warns;
634 }
635
636 static int quota_getxquota(struct super_block *sb, int type, qid_t id,
637                            void __user *addr)
638 {
639         struct fs_disk_quota fdq;
640         struct qc_dqblk qdq;
641         struct kqid qid;
642         int ret;
643
644         if (!sb->s_qcop->get_dqblk)
645                 return -ENOSYS;
646         qid = make_kqid(current_user_ns(), type, id);
647         if (!qid_has_mapping(sb->s_user_ns, qid))
648                 return -EINVAL;
649         ret = sb->s_qcop->get_dqblk(sb, qid, &qdq);
650         if (ret)
651                 return ret;
652         copy_to_xfs_dqblk(&fdq, &qdq, type, id);
653         if (copy_to_user(addr, &fdq, sizeof(fdq)))
654                 return -EFAULT;
655         return ret;
656 }
657
658 /*
659  * Return quota for next active quota >= this id, if any exists,
660  * otherwise return -ENOENT via ->get_nextdqblk.
661  */
662 static int quota_getnextxquota(struct super_block *sb, int type, qid_t id,
663                             void __user *addr)
664 {
665         struct fs_disk_quota fdq;
666         struct qc_dqblk qdq;
667         struct kqid qid;
668         qid_t id_out;
669         int ret;
670
671         if (!sb->s_qcop->get_nextdqblk)
672                 return -ENOSYS;
673         qid = make_kqid(current_user_ns(), type, id);
674         if (!qid_has_mapping(sb->s_user_ns, qid))
675                 return -EINVAL;
676         ret = sb->s_qcop->get_nextdqblk(sb, &qid, &qdq);
677         if (ret)
678                 return ret;
679         id_out = from_kqid(current_user_ns(), qid);
680         copy_to_xfs_dqblk(&fdq, &qdq, type, id_out);
681         if (copy_to_user(addr, &fdq, sizeof(fdq)))
682                 return -EFAULT;
683         return ret;
684 }
685
686 static int quota_rmxquota(struct super_block *sb, void __user *addr)
687 {
688         __u32 flags;
689
690         if (copy_from_user(&flags, addr, sizeof(flags)))
691                 return -EFAULT;
692         if (!sb->s_qcop->rm_xquota)
693                 return -ENOSYS;
694         return sb->s_qcop->rm_xquota(sb, flags);
695 }
696
697 /* Copy parameters and call proper function */
698 static int do_quotactl(struct super_block *sb, int type, int cmd, qid_t id,
699                        void __user *addr, const struct path *path)
700 {
701         int ret;
702
703         if (type >= (XQM_COMMAND(cmd) ? XQM_MAXQUOTAS : MAXQUOTAS))
704                 return -EINVAL;
705         /*
706          * Quota not supported on this fs? Check this before s_quota_types
707          * since they needn't be set if quota is not supported at all.
708          */
709         if (!sb->s_qcop)
710                 return -ENOSYS;
711         if (!(sb->s_quota_types & (1 << type)))
712                 return -EINVAL;
713
714         ret = check_quotactl_permission(sb, type, cmd, id);
715         if (ret < 0)
716                 return ret;
717
718         switch (cmd) {
719         case Q_QUOTAON:
720                 return quota_quotaon(sb, type, id, path);
721         case Q_QUOTAOFF:
722                 return quota_quotaoff(sb, type);
723         case Q_GETFMT:
724                 return quota_getfmt(sb, type, addr);
725         case Q_GETINFO:
726                 return quota_getinfo(sb, type, addr);
727         case Q_SETINFO:
728                 return quota_setinfo(sb, type, addr);
729         case Q_GETQUOTA:
730                 return quota_getquota(sb, type, id, addr);
731         case Q_GETNEXTQUOTA:
732                 return quota_getnextquota(sb, type, id, addr);
733         case Q_SETQUOTA:
734                 return quota_setquota(sb, type, id, addr);
735         case Q_SYNC:
736                 if (!sb->s_qcop->quota_sync)
737                         return -ENOSYS;
738                 return sb->s_qcop->quota_sync(sb, type);
739         case Q_XQUOTAON:
740                 return quota_enable(sb, addr);
741         case Q_XQUOTAOFF:
742                 return quota_disable(sb, addr);
743         case Q_XQUOTARM:
744                 return quota_rmxquota(sb, addr);
745         case Q_XGETQSTAT:
746                 return quota_getxstate(sb, addr);
747         case Q_XGETQSTATV:
748                 return quota_getxstatev(sb, addr);
749         case Q_XSETQLIM:
750                 return quota_setxquota(sb, type, id, addr);
751         case Q_XGETQUOTA:
752                 return quota_getxquota(sb, type, id, addr);
753         case Q_XGETNEXTQUOTA:
754                 return quota_getnextxquota(sb, type, id, addr);
755         case Q_XQUOTASYNC:
756                 if (sb->s_flags & MS_RDONLY)
757                         return -EROFS;
758                 /* XFS quotas are fully coherent now, making this call a noop */
759                 return 0;
760         default:
761                 return -EINVAL;
762         }
763 }
764
765 #ifdef CONFIG_BLOCK
766
767 /* Return 1 if 'cmd' will block on frozen filesystem */
768 static int quotactl_cmd_write(int cmd)
769 {
770         /*
771          * We cannot allow Q_GETQUOTA and Q_GETNEXTQUOTA without write access
772          * as dquot_acquire() may allocate space for new structure and OCFS2
773          * needs to increment on-disk use count.
774          */
775         switch (cmd) {
776         case Q_GETFMT:
777         case Q_GETINFO:
778         case Q_SYNC:
779         case Q_XGETQSTAT:
780         case Q_XGETQSTATV:
781         case Q_XGETQUOTA:
782         case Q_XGETNEXTQUOTA:
783         case Q_XQUOTASYNC:
784                 return 0;
785         }
786         return 1;
787 }
788 #endif /* CONFIG_BLOCK */
789
790 /* Return true if quotactl command is manipulating quota on/off state */
791 static bool quotactl_cmd_onoff(int cmd)
792 {
793         return (cmd == Q_QUOTAON) || (cmd == Q_QUOTAOFF);
794 }
795
796 /*
797  * look up a superblock on which quota ops will be performed
798  * - use the name of a block device to find the superblock thereon
799  */
800 static struct super_block *quotactl_block(const char __user *special, int cmd)
801 {
802 #ifdef CONFIG_BLOCK
803         struct block_device *bdev;
804         struct super_block *sb;
805         struct filename *tmp = getname(special);
806
807         if (IS_ERR(tmp))
808                 return ERR_CAST(tmp);
809         bdev = lookup_bdev(tmp->name);
810         putname(tmp);
811         if (IS_ERR(bdev))
812                 return ERR_CAST(bdev);
813         if (quotactl_cmd_onoff(cmd))
814                 sb = get_super_exclusive_thawed(bdev);
815         else if (quotactl_cmd_write(cmd))
816                 sb = get_super_thawed(bdev);
817         else
818                 sb = get_super(bdev);
819         bdput(bdev);
820         if (!sb)
821                 return ERR_PTR(-ENODEV);
822
823         return sb;
824 #else
825         return ERR_PTR(-ENODEV);
826 #endif
827 }
828
829 /*
830  * This is the system call interface. This communicates with
831  * the user-level programs. Currently this only supports diskquota
832  * calls. Maybe we need to add the process quotas etc. in the future,
833  * but we probably should use rlimits for that.
834  */
835 SYSCALL_DEFINE4(quotactl, unsigned int, cmd, const char __user *, special,
836                 qid_t, id, void __user *, addr)
837 {
838         uint cmds, type;
839         struct super_block *sb = NULL;
840         struct path path, *pathp = NULL;
841         int ret;
842
843         cmds = cmd >> SUBCMDSHIFT;
844         type = cmd & SUBCMDMASK;
845
846         /*
847          * As a special case Q_SYNC can be called without a specific device.
848          * It will iterate all superblocks that have quota enabled and call
849          * the sync action on each of them.
850          */
851         if (!special) {
852                 if (cmds == Q_SYNC)
853                         return quota_sync_all(type);
854                 return -ENODEV;
855         }
856
857         /*
858          * Path for quotaon has to be resolved before grabbing superblock
859          * because that gets s_umount sem which is also possibly needed by path
860          * resolution (think about autofs) and thus deadlocks could arise.
861          */
862         if (cmds == Q_QUOTAON) {
863                 ret = user_path_at(AT_FDCWD, addr, LOOKUP_FOLLOW|LOOKUP_AUTOMOUNT, &path);
864                 if (ret)
865                         pathp = ERR_PTR(ret);
866                 else
867                         pathp = &path;
868         }
869
870         sb = quotactl_block(special, cmds);
871         if (IS_ERR(sb)) {
872                 ret = PTR_ERR(sb);
873                 goto out;
874         }
875
876         ret = do_quotactl(sb, type, cmds, id, addr, pathp);
877
878         if (!quotactl_cmd_onoff(cmds))
879                 drop_super(sb);
880         else
881                 drop_super_exclusive(sb);
882 out:
883         if (pathp && !IS_ERR(pathp))
884                 path_put(pathp);
885         return ret;
886 }