]>
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 if (sb
->s_qcop
&& sb
->s_qcop
->quota_sync
)
51 sb
->s_qcop
->quota_sync(sb
, *(int *)arg
);
54 static int quota_sync_all(int type
)
58 if (type
>= MAXQUOTAS
)
60 ret
= security_quotactl(Q_SYNC
, type
, 0, NULL
);
62 iterate_supers(quota_sync_one
, &type
);
66 static int quota_quotaon(struct super_block
*sb
, int type
, int cmd
, qid_t id
,
69 if (!sb
->s_qcop
->quota_on
&& !sb
->s_qcop
->quota_on_meta
)
71 if (sb
->s_qcop
->quota_on_meta
)
72 return sb
->s_qcop
->quota_on_meta(sb
, type
, id
);
75 return sb
->s_qcop
->quota_on(sb
, type
, id
, path
);
78 static int quota_getfmt(struct super_block
*sb
, int type
, void __user
*addr
)
82 down_read(&sb_dqopt(sb
)->dqptr_sem
);
83 if (!sb_has_quota_active(sb
, type
)) {
84 up_read(&sb_dqopt(sb
)->dqptr_sem
);
87 fmt
= sb_dqopt(sb
)->info
[type
].dqi_format
->qf_fmt_id
;
88 up_read(&sb_dqopt(sb
)->dqptr_sem
);
89 if (copy_to_user(addr
, &fmt
, sizeof(fmt
)))
94 static int quota_getinfo(struct super_block
*sb
, int type
, void __user
*addr
)
96 struct if_dqinfo info
;
99 if (!sb
->s_qcop
->get_info
)
101 ret
= sb
->s_qcop
->get_info(sb
, type
, &info
);
102 if (!ret
&& copy_to_user(addr
, &info
, sizeof(info
)))
107 static int quota_setinfo(struct super_block
*sb
, int type
, void __user
*addr
)
109 struct if_dqinfo info
;
111 if (copy_from_user(&info
, addr
, sizeof(info
)))
113 if (!sb
->s_qcop
->set_info
)
115 return sb
->s_qcop
->set_info(sb
, type
, &info
);
118 static void copy_to_if_dqblk(struct if_dqblk
*dst
, struct fs_disk_quota
*src
)
120 dst
->dqb_bhardlimit
= src
->d_blk_hardlimit
;
121 dst
->dqb_bsoftlimit
= src
->d_blk_softlimit
;
122 dst
->dqb_curspace
= src
->d_bcount
;
123 dst
->dqb_ihardlimit
= src
->d_ino_hardlimit
;
124 dst
->dqb_isoftlimit
= src
->d_ino_softlimit
;
125 dst
->dqb_curinodes
= src
->d_icount
;
126 dst
->dqb_btime
= src
->d_btimer
;
127 dst
->dqb_itime
= src
->d_itimer
;
128 dst
->dqb_valid
= QIF_ALL
;
131 static int quota_getquota(struct super_block
*sb
, int type
, qid_t id
,
135 struct fs_disk_quota fdq
;
139 if (!sb
->s_qcop
->get_dqblk
)
141 qid
= make_kqid(current_user_ns(), type
, id
);
144 ret
= sb
->s_qcop
->get_dqblk(sb
, qid
, &fdq
);
147 copy_to_if_dqblk(&idq
, &fdq
);
148 if (copy_to_user(addr
, &idq
, sizeof(idq
)))
153 static void copy_from_if_dqblk(struct fs_disk_quota
*dst
, struct if_dqblk
*src
)
155 dst
->d_blk_hardlimit
= src
->dqb_bhardlimit
;
156 dst
->d_blk_softlimit
= src
->dqb_bsoftlimit
;
157 dst
->d_bcount
= src
->dqb_curspace
;
158 dst
->d_ino_hardlimit
= src
->dqb_ihardlimit
;
159 dst
->d_ino_softlimit
= src
->dqb_isoftlimit
;
160 dst
->d_icount
= src
->dqb_curinodes
;
161 dst
->d_btimer
= src
->dqb_btime
;
162 dst
->d_itimer
= src
->dqb_itime
;
164 dst
->d_fieldmask
= 0;
165 if (src
->dqb_valid
& QIF_BLIMITS
)
166 dst
->d_fieldmask
|= FS_DQ_BSOFT
| FS_DQ_BHARD
;
167 if (src
->dqb_valid
& QIF_SPACE
)
168 dst
->d_fieldmask
|= FS_DQ_BCOUNT
;
169 if (src
->dqb_valid
& QIF_ILIMITS
)
170 dst
->d_fieldmask
|= FS_DQ_ISOFT
| FS_DQ_IHARD
;
171 if (src
->dqb_valid
& QIF_INODES
)
172 dst
->d_fieldmask
|= FS_DQ_ICOUNT
;
173 if (src
->dqb_valid
& QIF_BTIME
)
174 dst
->d_fieldmask
|= FS_DQ_BTIMER
;
175 if (src
->dqb_valid
& QIF_ITIME
)
176 dst
->d_fieldmask
|= FS_DQ_ITIMER
;
179 static int quota_setquota(struct super_block
*sb
, int type
, qid_t id
,
182 struct fs_disk_quota fdq
;
186 if (copy_from_user(&idq
, addr
, sizeof(idq
)))
188 if (!sb
->s_qcop
->set_dqblk
)
190 qid
= make_kqid(current_user_ns(), type
, id
);
193 copy_from_if_dqblk(&fdq
, &idq
);
194 return sb
->s_qcop
->set_dqblk(sb
, qid
, &fdq
);
197 static int quota_setxstate(struct super_block
*sb
, int cmd
, void __user
*addr
)
201 if (copy_from_user(&flags
, addr
, sizeof(flags
)))
203 if (!sb
->s_qcop
->set_xstate
)
205 return sb
->s_qcop
->set_xstate(sb
, flags
, cmd
);
208 static int quota_getxstate(struct super_block
*sb
, void __user
*addr
)
210 struct fs_quota_stat fqs
;
213 if (!sb
->s_qcop
->get_xstate
)
215 ret
= sb
->s_qcop
->get_xstate(sb
, &fqs
);
216 if (!ret
&& copy_to_user(addr
, &fqs
, sizeof(fqs
)))
221 static int quota_getxstatev(struct super_block
*sb
, void __user
*addr
)
223 struct fs_quota_statv fqs
;
226 if (!sb
->s_qcop
->get_xstatev
)
229 memset(&fqs
, 0, sizeof(fqs
));
230 if (copy_from_user(&fqs
, addr
, 1)) /* Just read qs_version */
233 /* If this kernel doesn't support user specified version, fail */
234 switch (fqs
.qs_version
) {
235 case FS_QSTATV_VERSION1
:
240 ret
= sb
->s_qcop
->get_xstatev(sb
, &fqs
);
241 if (!ret
&& copy_to_user(addr
, &fqs
, sizeof(fqs
)))
246 static int quota_setxquota(struct super_block
*sb
, int type
, qid_t id
,
249 struct fs_disk_quota fdq
;
252 if (copy_from_user(&fdq
, addr
, sizeof(fdq
)))
254 if (!sb
->s_qcop
->set_dqblk
)
256 qid
= make_kqid(current_user_ns(), type
, id
);
259 return sb
->s_qcop
->set_dqblk(sb
, qid
, &fdq
);
262 static int quota_getxquota(struct super_block
*sb
, int type
, qid_t id
,
265 struct fs_disk_quota fdq
;
269 if (!sb
->s_qcop
->get_dqblk
)
271 qid
= make_kqid(current_user_ns(), type
, id
);
274 ret
= sb
->s_qcop
->get_dqblk(sb
, qid
, &fdq
);
275 if (!ret
&& copy_to_user(addr
, &fdq
, sizeof(fdq
)))
280 /* Copy parameters and call proper function */
281 static int do_quotactl(struct super_block
*sb
, int type
, int cmd
, qid_t id
,
282 void __user
*addr
, struct path
*path
)
286 if (type
>= (XQM_COMMAND(cmd
) ? XQM_MAXQUOTAS
: MAXQUOTAS
))
291 ret
= check_quotactl_permission(sb
, type
, cmd
, id
);
297 return quota_quotaon(sb
, type
, cmd
, id
, path
);
299 if (!sb
->s_qcop
->quota_off
)
301 return sb
->s_qcop
->quota_off(sb
, type
);
303 return quota_getfmt(sb
, type
, addr
);
305 return quota_getinfo(sb
, type
, addr
);
307 return quota_setinfo(sb
, type
, addr
);
309 return quota_getquota(sb
, type
, id
, addr
);
311 return quota_setquota(sb
, type
, id
, addr
);
313 if (!sb
->s_qcop
->quota_sync
)
315 return sb
->s_qcop
->quota_sync(sb
, type
);
319 return quota_setxstate(sb
, cmd
, addr
);
321 return quota_getxstate(sb
, addr
);
323 return quota_getxstatev(sb
, addr
);
325 return quota_setxquota(sb
, type
, id
, addr
);
327 return quota_getxquota(sb
, type
, id
, addr
);
329 if (sb
->s_flags
& MS_RDONLY
)
331 /* XFS quotas are fully coherent now, making this call a noop */
340 /* Return 1 if 'cmd' will block on frozen filesystem */
341 static int quotactl_cmd_write(int cmd
)
356 #endif /* CONFIG_BLOCK */
359 * look up a superblock on which quota ops will be performed
360 * - use the name of a block device to find the superblock thereon
362 static struct super_block
*quotactl_block(const char __user
*special
, int cmd
)
365 struct block_device
*bdev
;
366 struct super_block
*sb
;
367 struct filename
*tmp
= getname(special
);
370 return ERR_CAST(tmp
);
371 bdev
= lookup_bdev(tmp
->name
);
374 return ERR_CAST(bdev
);
375 if (quotactl_cmd_write(cmd
))
376 sb
= get_super_thawed(bdev
);
378 sb
= get_super(bdev
);
381 return ERR_PTR(-ENODEV
);
385 return ERR_PTR(-ENODEV
);
390 * This is the system call interface. This communicates with
391 * the user-level programs. Currently this only supports diskquota
392 * calls. Maybe we need to add the process quotas etc. in the future,
393 * but we probably should use rlimits for that.
395 SYSCALL_DEFINE4(quotactl
, unsigned int, cmd
, const char __user
*, special
,
396 qid_t
, id
, void __user
*, addr
)
399 struct super_block
*sb
= NULL
;
400 struct path path
, *pathp
= NULL
;
403 cmds
= cmd
>> SUBCMDSHIFT
;
404 type
= cmd
& SUBCMDMASK
;
407 * As a special case Q_SYNC can be called without a specific device.
408 * It will iterate all superblocks that have quota enabled and call
409 * the sync action on each of them.
413 return quota_sync_all(type
);
418 * Path for quotaon has to be resolved before grabbing superblock
419 * because that gets s_umount sem which is also possibly needed by path
420 * resolution (think about autofs) and thus deadlocks could arise.
422 if (cmds
== Q_QUOTAON
) {
423 ret
= user_path_at(AT_FDCWD
, addr
, LOOKUP_FOLLOW
|LOOKUP_AUTOMOUNT
, &path
);
425 pathp
= ERR_PTR(ret
);
430 sb
= quotactl_block(special
, cmds
);
436 ret
= do_quotactl(sb
, type
, cmds
, id
, addr
, pathp
);
440 if (pathp
&& !IS_ERR(pathp
))