]>
git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - fs/quota/quota.c
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.
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>
21 static int check_quotactl_permission(struct super_block
*sb
, int type
, int cmd
,
25 /* these commands do not require any special privilegues */
33 /* allow to query information for dquots we "own" */
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
))))
41 if (!capable(CAP_SYS_ADMIN
))
45 return security_quotactl(cmd
, type
, id
, sb
);
48 static void quota_sync_one(struct super_block
*sb
, void *arg
)
50 int type
= *(int *)arg
;
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
);
57 static int quota_sync_all(int type
)
61 if (type
>= MAXQUOTAS
)
63 ret
= security_quotactl(Q_SYNC
, type
, 0, NULL
);
65 iterate_supers(quota_sync_one
, &type
);
69 unsigned int qtype_enforce_flag(int type
)
73 return FS_QUOTA_UDQ_ENFD
;
75 return FS_QUOTA_GDQ_ENFD
;
77 return FS_QUOTA_PDQ_ENFD
;
82 static int quota_quotaon(struct super_block
*sb
, int type
, int cmd
, qid_t id
,
85 if (!sb
->s_qcop
->quota_on
&& !sb
->s_qcop
->quota_enable
)
87 if (sb
->s_qcop
->quota_enable
)
88 return sb
->s_qcop
->quota_enable(sb
, qtype_enforce_flag(type
));
91 return sb
->s_qcop
->quota_on(sb
, type
, id
, path
);
94 static int quota_quotaoff(struct super_block
*sb
, int type
)
96 if (!sb
->s_qcop
->quota_off
&& !sb
->s_qcop
->quota_disable
)
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
);
103 static int quota_getfmt(struct super_block
*sb
, int type
, void __user
*addr
)
107 mutex_lock(&sb_dqopt(sb
)->dqonoff_mutex
);
108 if (!sb_has_quota_active(sb
, type
)) {
109 mutex_unlock(&sb_dqopt(sb
)->dqonoff_mutex
);
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
)))
119 static int quota_getinfo(struct super_block
*sb
, int type
, void __user
*addr
)
121 struct if_dqinfo info
;
124 if (!sb
->s_qcop
->get_info
)
126 ret
= sb
->s_qcop
->get_info(sb
, type
, &info
);
127 if (!ret
&& copy_to_user(addr
, &info
, sizeof(info
)))
132 static int quota_setinfo(struct super_block
*sb
, int type
, void __user
*addr
)
134 struct if_dqinfo info
;
136 if (copy_from_user(&info
, addr
, sizeof(info
)))
138 if (!sb
->s_qcop
->set_info
)
140 return sb
->s_qcop
->set_info(sb
, type
, &info
);
143 static inline qsize_t
qbtos(qsize_t blocks
)
145 return blocks
<< QIF_DQBLKSIZE_BITS
;
148 static inline qsize_t
stoqb(qsize_t space
)
150 return (space
+ QIF_DQBLKSIZE
- 1) >> QIF_DQBLKSIZE_BITS
;
153 static void copy_to_if_dqblk(struct if_dqblk
*dst
, struct qc_dqblk
*src
)
155 memset(dst
, 0, sizeof(*dst
));
156 dst
->dqb_bhardlimit
= stoqb(src
->d_spc_hardlimit
);
157 dst
->dqb_bsoftlimit
= stoqb(src
->d_spc_softlimit
);
158 dst
->dqb_curspace
= src
->d_space
;
159 dst
->dqb_ihardlimit
= src
->d_ino_hardlimit
;
160 dst
->dqb_isoftlimit
= src
->d_ino_softlimit
;
161 dst
->dqb_curinodes
= src
->d_ino_count
;
162 dst
->dqb_btime
= src
->d_spc_timer
;
163 dst
->dqb_itime
= src
->d_ino_timer
;
164 dst
->dqb_valid
= QIF_ALL
;
167 static int quota_getquota(struct super_block
*sb
, int type
, qid_t id
,
175 if (!sb
->s_qcop
->get_dqblk
)
177 qid
= make_kqid(current_user_ns(), type
, id
);
180 ret
= sb
->s_qcop
->get_dqblk(sb
, qid
, &fdq
);
183 copy_to_if_dqblk(&idq
, &fdq
);
184 if (copy_to_user(addr
, &idq
, sizeof(idq
)))
189 static void copy_from_if_dqblk(struct qc_dqblk
*dst
, struct if_dqblk
*src
)
191 dst
->d_spc_hardlimit
= qbtos(src
->dqb_bhardlimit
);
192 dst
->d_spc_softlimit
= qbtos(src
->dqb_bsoftlimit
);
193 dst
->d_space
= src
->dqb_curspace
;
194 dst
->d_ino_hardlimit
= src
->dqb_ihardlimit
;
195 dst
->d_ino_softlimit
= src
->dqb_isoftlimit
;
196 dst
->d_ino_count
= src
->dqb_curinodes
;
197 dst
->d_spc_timer
= src
->dqb_btime
;
198 dst
->d_ino_timer
= src
->dqb_itime
;
200 dst
->d_fieldmask
= 0;
201 if (src
->dqb_valid
& QIF_BLIMITS
)
202 dst
->d_fieldmask
|= QC_SPC_SOFT
| QC_SPC_HARD
;
203 if (src
->dqb_valid
& QIF_SPACE
)
204 dst
->d_fieldmask
|= QC_SPACE
;
205 if (src
->dqb_valid
& QIF_ILIMITS
)
206 dst
->d_fieldmask
|= QC_INO_SOFT
| QC_INO_HARD
;
207 if (src
->dqb_valid
& QIF_INODES
)
208 dst
->d_fieldmask
|= QC_INO_COUNT
;
209 if (src
->dqb_valid
& QIF_BTIME
)
210 dst
->d_fieldmask
|= QC_SPC_TIMER
;
211 if (src
->dqb_valid
& QIF_ITIME
)
212 dst
->d_fieldmask
|= QC_INO_TIMER
;
215 static int quota_setquota(struct super_block
*sb
, int type
, qid_t id
,
222 if (copy_from_user(&idq
, addr
, sizeof(idq
)))
224 if (!sb
->s_qcop
->set_dqblk
)
226 qid
= make_kqid(current_user_ns(), type
, id
);
229 copy_from_if_dqblk(&fdq
, &idq
);
230 return sb
->s_qcop
->set_dqblk(sb
, qid
, &fdq
);
233 static int quota_enable(struct super_block
*sb
, void __user
*addr
)
237 if (copy_from_user(&flags
, addr
, sizeof(flags
)))
239 if (!sb
->s_qcop
->quota_enable
)
241 return sb
->s_qcop
->quota_enable(sb
, flags
);
244 static int quota_disable(struct super_block
*sb
, void __user
*addr
)
248 if (copy_from_user(&flags
, addr
, sizeof(flags
)))
250 if (!sb
->s_qcop
->quota_disable
)
252 return sb
->s_qcop
->quota_disable(sb
, flags
);
255 static int quota_getxstate(struct super_block
*sb
, void __user
*addr
)
257 struct fs_quota_stat fqs
;
260 if (!sb
->s_qcop
->get_xstate
)
262 ret
= sb
->s_qcop
->get_xstate(sb
, &fqs
);
263 if (!ret
&& copy_to_user(addr
, &fqs
, sizeof(fqs
)))
268 static int quota_getxstatev(struct super_block
*sb
, void __user
*addr
)
270 struct fs_quota_statv fqs
;
273 if (!sb
->s_qcop
->get_xstatev
)
276 memset(&fqs
, 0, sizeof(fqs
));
277 if (copy_from_user(&fqs
, addr
, 1)) /* Just read qs_version */
280 /* If this kernel doesn't support user specified version, fail */
281 switch (fqs
.qs_version
) {
282 case FS_QSTATV_VERSION1
:
287 ret
= sb
->s_qcop
->get_xstatev(sb
, &fqs
);
288 if (!ret
&& copy_to_user(addr
, &fqs
, sizeof(fqs
)))
294 * XFS defines BBTOB and BTOBB macros inside fs/xfs/ and we cannot move them
295 * out of there as xfsprogs rely on definitions being in that header file. So
296 * just define same functions here for quota purposes.
298 #define XFS_BB_SHIFT 9
300 static inline u64
quota_bbtob(u64 blocks
)
302 return blocks
<< XFS_BB_SHIFT
;
305 static inline u64
quota_btobb(u64 bytes
)
307 return (bytes
+ (1 << XFS_BB_SHIFT
) - 1) >> XFS_BB_SHIFT
;
310 static void copy_from_xfs_dqblk(struct qc_dqblk
*dst
, struct fs_disk_quota
*src
)
312 dst
->d_spc_hardlimit
= quota_bbtob(src
->d_blk_hardlimit
);
313 dst
->d_spc_softlimit
= quota_bbtob(src
->d_blk_softlimit
);
314 dst
->d_ino_hardlimit
= src
->d_ino_hardlimit
;
315 dst
->d_ino_softlimit
= src
->d_ino_softlimit
;
316 dst
->d_space
= quota_bbtob(src
->d_bcount
);
317 dst
->d_ino_count
= src
->d_icount
;
318 dst
->d_ino_timer
= src
->d_itimer
;
319 dst
->d_spc_timer
= src
->d_btimer
;
320 dst
->d_ino_warns
= src
->d_iwarns
;
321 dst
->d_spc_warns
= src
->d_bwarns
;
322 dst
->d_rt_spc_hardlimit
= quota_bbtob(src
->d_rtb_hardlimit
);
323 dst
->d_rt_spc_softlimit
= quota_bbtob(src
->d_rtb_softlimit
);
324 dst
->d_rt_space
= quota_bbtob(src
->d_rtbcount
);
325 dst
->d_rt_spc_timer
= src
->d_rtbtimer
;
326 dst
->d_rt_spc_warns
= src
->d_rtbwarns
;
327 dst
->d_fieldmask
= 0;
328 if (src
->d_fieldmask
& FS_DQ_ISOFT
)
329 dst
->d_fieldmask
|= QC_INO_SOFT
;
330 if (src
->d_fieldmask
& FS_DQ_IHARD
)
331 dst
->d_fieldmask
|= QC_INO_HARD
;
332 if (src
->d_fieldmask
& FS_DQ_BSOFT
)
333 dst
->d_fieldmask
|= QC_SPC_SOFT
;
334 if (src
->d_fieldmask
& FS_DQ_BHARD
)
335 dst
->d_fieldmask
|= QC_SPC_HARD
;
336 if (src
->d_fieldmask
& FS_DQ_RTBSOFT
)
337 dst
->d_fieldmask
|= QC_RT_SPC_SOFT
;
338 if (src
->d_fieldmask
& FS_DQ_RTBHARD
)
339 dst
->d_fieldmask
|= QC_RT_SPC_HARD
;
340 if (src
->d_fieldmask
& FS_DQ_BTIMER
)
341 dst
->d_fieldmask
|= QC_SPC_TIMER
;
342 if (src
->d_fieldmask
& FS_DQ_ITIMER
)
343 dst
->d_fieldmask
|= QC_INO_TIMER
;
344 if (src
->d_fieldmask
& FS_DQ_RTBTIMER
)
345 dst
->d_fieldmask
|= QC_RT_SPC_TIMER
;
346 if (src
->d_fieldmask
& FS_DQ_BWARNS
)
347 dst
->d_fieldmask
|= QC_SPC_WARNS
;
348 if (src
->d_fieldmask
& FS_DQ_IWARNS
)
349 dst
->d_fieldmask
|= QC_INO_WARNS
;
350 if (src
->d_fieldmask
& FS_DQ_RTBWARNS
)
351 dst
->d_fieldmask
|= QC_RT_SPC_WARNS
;
352 if (src
->d_fieldmask
& FS_DQ_BCOUNT
)
353 dst
->d_fieldmask
|= QC_SPACE
;
354 if (src
->d_fieldmask
& FS_DQ_ICOUNT
)
355 dst
->d_fieldmask
|= QC_INO_COUNT
;
356 if (src
->d_fieldmask
& FS_DQ_RTBCOUNT
)
357 dst
->d_fieldmask
|= QC_RT_SPACE
;
360 static int quota_setxquota(struct super_block
*sb
, int type
, qid_t id
,
363 struct fs_disk_quota fdq
;
367 if (copy_from_user(&fdq
, addr
, sizeof(fdq
)))
369 if (!sb
->s_qcop
->set_dqblk
)
371 qid
= make_kqid(current_user_ns(), type
, id
);
374 copy_from_xfs_dqblk(&qdq
, &fdq
);
375 return sb
->s_qcop
->set_dqblk(sb
, qid
, &qdq
);
378 static void copy_to_xfs_dqblk(struct fs_disk_quota
*dst
, struct qc_dqblk
*src
,
381 memset(dst
, 0, sizeof(*dst
));
382 dst
->d_version
= FS_DQUOT_VERSION
;
384 if (type
== USRQUOTA
)
385 dst
->d_flags
= FS_USER_QUOTA
;
386 else if (type
== PRJQUOTA
)
387 dst
->d_flags
= FS_PROJ_QUOTA
;
389 dst
->d_flags
= FS_GROUP_QUOTA
;
390 dst
->d_blk_hardlimit
= quota_btobb(src
->d_spc_hardlimit
);
391 dst
->d_blk_softlimit
= quota_btobb(src
->d_spc_softlimit
);
392 dst
->d_ino_hardlimit
= src
->d_ino_hardlimit
;
393 dst
->d_ino_softlimit
= src
->d_ino_softlimit
;
394 dst
->d_bcount
= quota_btobb(src
->d_space
);
395 dst
->d_icount
= src
->d_ino_count
;
396 dst
->d_itimer
= src
->d_ino_timer
;
397 dst
->d_btimer
= src
->d_spc_timer
;
398 dst
->d_iwarns
= src
->d_ino_warns
;
399 dst
->d_bwarns
= src
->d_spc_warns
;
400 dst
->d_rtb_hardlimit
= quota_btobb(src
->d_rt_spc_hardlimit
);
401 dst
->d_rtb_softlimit
= quota_btobb(src
->d_rt_spc_softlimit
);
402 dst
->d_rtbcount
= quota_btobb(src
->d_rt_space
);
403 dst
->d_rtbtimer
= src
->d_rt_spc_timer
;
404 dst
->d_rtbwarns
= src
->d_rt_spc_warns
;
407 static int quota_getxquota(struct super_block
*sb
, int type
, qid_t id
,
410 struct fs_disk_quota fdq
;
415 if (!sb
->s_qcop
->get_dqblk
)
417 qid
= make_kqid(current_user_ns(), type
, id
);
420 ret
= sb
->s_qcop
->get_dqblk(sb
, qid
, &qdq
);
423 copy_to_xfs_dqblk(&fdq
, &qdq
, type
, id
);
424 if (copy_to_user(addr
, &fdq
, sizeof(fdq
)))
429 static int quota_rmxquota(struct super_block
*sb
, void __user
*addr
)
433 if (copy_from_user(&flags
, addr
, sizeof(flags
)))
435 if (!sb
->s_qcop
->rm_xquota
)
437 return sb
->s_qcop
->rm_xquota(sb
, flags
);
440 /* Copy parameters and call proper function */
441 static int do_quotactl(struct super_block
*sb
, int type
, int cmd
, qid_t id
,
442 void __user
*addr
, struct path
*path
)
446 if (type
>= (XQM_COMMAND(cmd
) ? XQM_MAXQUOTAS
: MAXQUOTAS
))
449 * Quota not supported on this fs? Check this before s_quota_types
450 * since they needn't be set if quota is not supported at all.
454 if (!(sb
->s_quota_types
& (1 << type
)))
457 ret
= check_quotactl_permission(sb
, type
, cmd
, id
);
463 return quota_quotaon(sb
, type
, cmd
, id
, path
);
465 return quota_quotaoff(sb
, type
);
467 return quota_getfmt(sb
, type
, addr
);
469 return quota_getinfo(sb
, type
, addr
);
471 return quota_setinfo(sb
, type
, addr
);
473 return quota_getquota(sb
, type
, id
, addr
);
475 return quota_setquota(sb
, type
, id
, addr
);
477 if (!sb
->s_qcop
->quota_sync
)
479 return sb
->s_qcop
->quota_sync(sb
, type
);
481 return quota_enable(sb
, addr
);
483 return quota_disable(sb
, addr
);
485 return quota_rmxquota(sb
, addr
);
487 return quota_getxstate(sb
, addr
);
489 return quota_getxstatev(sb
, addr
);
491 return quota_setxquota(sb
, type
, id
, addr
);
493 return quota_getxquota(sb
, type
, id
, addr
);
495 if (sb
->s_flags
& MS_RDONLY
)
497 /* XFS quotas are fully coherent now, making this call a noop */
506 /* Return 1 if 'cmd' will block on frozen filesystem */
507 static int quotactl_cmd_write(int cmd
)
522 #endif /* CONFIG_BLOCK */
525 * look up a superblock on which quota ops will be performed
526 * - use the name of a block device to find the superblock thereon
528 static struct super_block
*quotactl_block(const char __user
*special
, int cmd
)
531 struct block_device
*bdev
;
532 struct super_block
*sb
;
533 struct filename
*tmp
= getname(special
);
536 return ERR_CAST(tmp
);
537 bdev
= lookup_bdev(tmp
->name
);
540 return ERR_CAST(bdev
);
541 if (quotactl_cmd_write(cmd
))
542 sb
= get_super_thawed(bdev
);
544 sb
= get_super(bdev
);
547 return ERR_PTR(-ENODEV
);
551 return ERR_PTR(-ENODEV
);
556 * This is the system call interface. This communicates with
557 * the user-level programs. Currently this only supports diskquota
558 * calls. Maybe we need to add the process quotas etc. in the future,
559 * but we probably should use rlimits for that.
561 SYSCALL_DEFINE4(quotactl
, unsigned int, cmd
, const char __user
*, special
,
562 qid_t
, id
, void __user
*, addr
)
565 struct super_block
*sb
= NULL
;
566 struct path path
, *pathp
= NULL
;
569 cmds
= cmd
>> SUBCMDSHIFT
;
570 type
= cmd
& SUBCMDMASK
;
573 * As a special case Q_SYNC can be called without a specific device.
574 * It will iterate all superblocks that have quota enabled and call
575 * the sync action on each of them.
579 return quota_sync_all(type
);
584 * Path for quotaon has to be resolved before grabbing superblock
585 * because that gets s_umount sem which is also possibly needed by path
586 * resolution (think about autofs) and thus deadlocks could arise.
588 if (cmds
== Q_QUOTAON
) {
589 ret
= user_path_at(AT_FDCWD
, addr
, LOOKUP_FOLLOW
|LOOKUP_AUTOMOUNT
, &path
);
591 pathp
= ERR_PTR(ret
);
596 sb
= quotactl_block(special
, cmds
);
602 ret
= do_quotactl(sb
, type
, cmds
, id
, addr
, pathp
);
606 if (pathp
&& !IS_ERR(pathp
))