Root/
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 <asm/uaccess.h> |
13 | #include <linux/kernel.h> |
14 | #include <linux/security.h> |
15 | #include <linux/syscalls.h> |
16 | #include <linux/buffer_head.h> |
17 | #include <linux/capability.h> |
18 | #include <linux/quotaops.h> |
19 | #include <linux/types.h> |
20 | #include <linux/writeback.h> |
21 | |
22 | static int check_quotactl_permission(struct super_block *sb, int type, int cmd, |
23 | qid_t id) |
24 | { |
25 | switch (cmd) { |
26 | /* these commands do not require any special privilegues */ |
27 | case Q_GETFMT: |
28 | case Q_SYNC: |
29 | case Q_GETINFO: |
30 | case Q_XGETQSTAT: |
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 && current_euid() == id) || |
37 | (type == GRPQUOTA && in_egroup_p(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 | if (sb->s_qcop && sb->s_qcop->quota_sync) |
51 | sb->s_qcop->quota_sync(sb, *(int *)arg, 1); |
52 | } |
53 | |
54 | static int quota_sync_all(int type) |
55 | { |
56 | int ret; |
57 | |
58 | if (type >= MAXQUOTAS) |
59 | return -EINVAL; |
60 | ret = security_quotactl(Q_SYNC, type, 0, NULL); |
61 | if (!ret) |
62 | iterate_supers(quota_sync_one, &type); |
63 | return ret; |
64 | } |
65 | |
66 | static int quota_quotaon(struct super_block *sb, int type, int cmd, qid_t id, |
67 | struct path *path) |
68 | { |
69 | if (!sb->s_qcop->quota_on && !sb->s_qcop->quota_on_meta) |
70 | return -ENOSYS; |
71 | if (sb->s_qcop->quota_on_meta) |
72 | return sb->s_qcop->quota_on_meta(sb, type, id); |
73 | if (IS_ERR(path)) |
74 | return PTR_ERR(path); |
75 | return sb->s_qcop->quota_on(sb, type, id, path); |
76 | } |
77 | |
78 | static int quota_getfmt(struct super_block *sb, int type, void __user *addr) |
79 | { |
80 | __u32 fmt; |
81 | |
82 | down_read(&sb_dqopt(sb)->dqptr_sem); |
83 | if (!sb_has_quota_active(sb, type)) { |
84 | up_read(&sb_dqopt(sb)->dqptr_sem); |
85 | return -ESRCH; |
86 | } |
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))) |
90 | return -EFAULT; |
91 | return 0; |
92 | } |
93 | |
94 | static int quota_getinfo(struct super_block *sb, int type, void __user *addr) |
95 | { |
96 | struct if_dqinfo info; |
97 | int ret; |
98 | |
99 | if (!sb->s_qcop->get_info) |
100 | return -ENOSYS; |
101 | ret = sb->s_qcop->get_info(sb, type, &info); |
102 | if (!ret && copy_to_user(addr, &info, sizeof(info))) |
103 | return -EFAULT; |
104 | return ret; |
105 | } |
106 | |
107 | static int quota_setinfo(struct super_block *sb, int type, void __user *addr) |
108 | { |
109 | struct if_dqinfo info; |
110 | |
111 | if (copy_from_user(&info, addr, sizeof(info))) |
112 | return -EFAULT; |
113 | if (!sb->s_qcop->set_info) |
114 | return -ENOSYS; |
115 | return sb->s_qcop->set_info(sb, type, &info); |
116 | } |
117 | |
118 | static void copy_to_if_dqblk(struct if_dqblk *dst, struct fs_disk_quota *src) |
119 | { |
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; |
129 | } |
130 | |
131 | static int quota_getquota(struct super_block *sb, int type, qid_t id, |
132 | void __user *addr) |
133 | { |
134 | struct fs_disk_quota fdq; |
135 | struct if_dqblk idq; |
136 | int ret; |
137 | |
138 | if (!sb->s_qcop->get_dqblk) |
139 | return -ENOSYS; |
140 | ret = sb->s_qcop->get_dqblk(sb, type, id, &fdq); |
141 | if (ret) |
142 | return ret; |
143 | copy_to_if_dqblk(&idq, &fdq); |
144 | if (copy_to_user(addr, &idq, sizeof(idq))) |
145 | return -EFAULT; |
146 | return 0; |
147 | } |
148 | |
149 | static void copy_from_if_dqblk(struct fs_disk_quota *dst, struct if_dqblk *src) |
150 | { |
151 | dst->d_blk_hardlimit = src->dqb_bhardlimit; |
152 | dst->d_blk_softlimit = src->dqb_bsoftlimit; |
153 | dst->d_bcount = src->dqb_curspace; |
154 | dst->d_ino_hardlimit = src->dqb_ihardlimit; |
155 | dst->d_ino_softlimit = src->dqb_isoftlimit; |
156 | dst->d_icount = src->dqb_curinodes; |
157 | dst->d_btimer = src->dqb_btime; |
158 | dst->d_itimer = src->dqb_itime; |
159 | |
160 | dst->d_fieldmask = 0; |
161 | if (src->dqb_valid & QIF_BLIMITS) |
162 | dst->d_fieldmask |= FS_DQ_BSOFT | FS_DQ_BHARD; |
163 | if (src->dqb_valid & QIF_SPACE) |
164 | dst->d_fieldmask |= FS_DQ_BCOUNT; |
165 | if (src->dqb_valid & QIF_ILIMITS) |
166 | dst->d_fieldmask |= FS_DQ_ISOFT | FS_DQ_IHARD; |
167 | if (src->dqb_valid & QIF_INODES) |
168 | dst->d_fieldmask |= FS_DQ_ICOUNT; |
169 | if (src->dqb_valid & QIF_BTIME) |
170 | dst->d_fieldmask |= FS_DQ_BTIMER; |
171 | if (src->dqb_valid & QIF_ITIME) |
172 | dst->d_fieldmask |= FS_DQ_ITIMER; |
173 | } |
174 | |
175 | static int quota_setquota(struct super_block *sb, int type, qid_t id, |
176 | void __user *addr) |
177 | { |
178 | struct fs_disk_quota fdq; |
179 | struct if_dqblk idq; |
180 | |
181 | if (copy_from_user(&idq, addr, sizeof(idq))) |
182 | return -EFAULT; |
183 | if (!sb->s_qcop->set_dqblk) |
184 | return -ENOSYS; |
185 | copy_from_if_dqblk(&fdq, &idq); |
186 | return sb->s_qcop->set_dqblk(sb, type, id, &fdq); |
187 | } |
188 | |
189 | static int quota_setxstate(struct super_block *sb, int cmd, void __user *addr) |
190 | { |
191 | __u32 flags; |
192 | |
193 | if (copy_from_user(&flags, addr, sizeof(flags))) |
194 | return -EFAULT; |
195 | if (!sb->s_qcop->set_xstate) |
196 | return -ENOSYS; |
197 | return sb->s_qcop->set_xstate(sb, flags, cmd); |
198 | } |
199 | |
200 | static int quota_getxstate(struct super_block *sb, void __user *addr) |
201 | { |
202 | struct fs_quota_stat fqs; |
203 | int ret; |
204 | |
205 | if (!sb->s_qcop->get_xstate) |
206 | return -ENOSYS; |
207 | ret = sb->s_qcop->get_xstate(sb, &fqs); |
208 | if (!ret && copy_to_user(addr, &fqs, sizeof(fqs))) |
209 | return -EFAULT; |
210 | return ret; |
211 | } |
212 | |
213 | static int quota_setxquota(struct super_block *sb, int type, qid_t id, |
214 | void __user *addr) |
215 | { |
216 | struct fs_disk_quota fdq; |
217 | |
218 | if (copy_from_user(&fdq, addr, sizeof(fdq))) |
219 | return -EFAULT; |
220 | if (!sb->s_qcop->set_dqblk) |
221 | return -ENOSYS; |
222 | return sb->s_qcop->set_dqblk(sb, type, id, &fdq); |
223 | } |
224 | |
225 | static int quota_getxquota(struct super_block *sb, int type, qid_t id, |
226 | void __user *addr) |
227 | { |
228 | struct fs_disk_quota fdq; |
229 | int ret; |
230 | |
231 | if (!sb->s_qcop->get_dqblk) |
232 | return -ENOSYS; |
233 | ret = sb->s_qcop->get_dqblk(sb, type, id, &fdq); |
234 | if (!ret && copy_to_user(addr, &fdq, sizeof(fdq))) |
235 | return -EFAULT; |
236 | return ret; |
237 | } |
238 | |
239 | /* Copy parameters and call proper function */ |
240 | static int do_quotactl(struct super_block *sb, int type, int cmd, qid_t id, |
241 | void __user *addr, struct path *path) |
242 | { |
243 | int ret; |
244 | |
245 | if (type >= (XQM_COMMAND(cmd) ? XQM_MAXQUOTAS : MAXQUOTAS)) |
246 | return -EINVAL; |
247 | if (!sb->s_qcop) |
248 | return -ENOSYS; |
249 | |
250 | ret = check_quotactl_permission(sb, type, cmd, id); |
251 | if (ret < 0) |
252 | return ret; |
253 | |
254 | switch (cmd) { |
255 | case Q_QUOTAON: |
256 | return quota_quotaon(sb, type, cmd, id, path); |
257 | case Q_QUOTAOFF: |
258 | if (!sb->s_qcop->quota_off) |
259 | return -ENOSYS; |
260 | return sb->s_qcop->quota_off(sb, type); |
261 | case Q_GETFMT: |
262 | return quota_getfmt(sb, type, addr); |
263 | case Q_GETINFO: |
264 | return quota_getinfo(sb, type, addr); |
265 | case Q_SETINFO: |
266 | return quota_setinfo(sb, type, addr); |
267 | case Q_GETQUOTA: |
268 | return quota_getquota(sb, type, id, addr); |
269 | case Q_SETQUOTA: |
270 | return quota_setquota(sb, type, id, addr); |
271 | case Q_SYNC: |
272 | if (!sb->s_qcop->quota_sync) |
273 | return -ENOSYS; |
274 | return sb->s_qcop->quota_sync(sb, type, 1); |
275 | case Q_XQUOTAON: |
276 | case Q_XQUOTAOFF: |
277 | case Q_XQUOTARM: |
278 | return quota_setxstate(sb, cmd, addr); |
279 | case Q_XGETQSTAT: |
280 | return quota_getxstate(sb, addr); |
281 | case Q_XSETQLIM: |
282 | return quota_setxquota(sb, type, id, addr); |
283 | case Q_XGETQUOTA: |
284 | return quota_getxquota(sb, type, id, addr); |
285 | case Q_XQUOTASYNC: |
286 | /* caller already holds s_umount */ |
287 | if (sb->s_flags & MS_RDONLY) |
288 | return -EROFS; |
289 | writeback_inodes_sb(sb); |
290 | return 0; |
291 | default: |
292 | return -EINVAL; |
293 | } |
294 | } |
295 | |
296 | /* |
297 | * look up a superblock on which quota ops will be performed |
298 | * - use the name of a block device to find the superblock thereon |
299 | */ |
300 | static struct super_block *quotactl_block(const char __user *special) |
301 | { |
302 | #ifdef CONFIG_BLOCK |
303 | struct block_device *bdev; |
304 | struct super_block *sb; |
305 | char *tmp = getname(special); |
306 | |
307 | if (IS_ERR(tmp)) |
308 | return ERR_CAST(tmp); |
309 | bdev = lookup_bdev(tmp); |
310 | putname(tmp); |
311 | if (IS_ERR(bdev)) |
312 | return ERR_CAST(bdev); |
313 | sb = get_super(bdev); |
314 | bdput(bdev); |
315 | if (!sb) |
316 | return ERR_PTR(-ENODEV); |
317 | |
318 | return sb; |
319 | #else |
320 | return ERR_PTR(-ENODEV); |
321 | #endif |
322 | } |
323 | |
324 | /* |
325 | * This is the system call interface. This communicates with |
326 | * the user-level programs. Currently this only supports diskquota |
327 | * calls. Maybe we need to add the process quotas etc. in the future, |
328 | * but we probably should use rlimits for that. |
329 | */ |
330 | SYSCALL_DEFINE4(quotactl, unsigned int, cmd, const char __user *, special, |
331 | qid_t, id, void __user *, addr) |
332 | { |
333 | uint cmds, type; |
334 | struct super_block *sb = NULL; |
335 | struct path path, *pathp = NULL; |
336 | int ret; |
337 | |
338 | cmds = cmd >> SUBCMDSHIFT; |
339 | type = cmd & SUBCMDMASK; |
340 | |
341 | /* |
342 | * As a special case Q_SYNC can be called without a specific device. |
343 | * It will iterate all superblocks that have quota enabled and call |
344 | * the sync action on each of them. |
345 | */ |
346 | if (!special) { |
347 | if (cmds == Q_SYNC) |
348 | return quota_sync_all(type); |
349 | return -ENODEV; |
350 | } |
351 | |
352 | /* |
353 | * Path for quotaon has to be resolved before grabbing superblock |
354 | * because that gets s_umount sem which is also possibly needed by path |
355 | * resolution (think about autofs) and thus deadlocks could arise. |
356 | */ |
357 | if (cmds == Q_QUOTAON) { |
358 | ret = user_path_at(AT_FDCWD, addr, LOOKUP_FOLLOW, &path); |
359 | if (ret) |
360 | pathp = ERR_PTR(ret); |
361 | else |
362 | pathp = &path; |
363 | } |
364 | |
365 | sb = quotactl_block(special); |
366 | if (IS_ERR(sb)) |
367 | return PTR_ERR(sb); |
368 | |
369 | ret = do_quotactl(sb, type, cmds, id, addr, pathp); |
370 | |
371 | drop_super(sb); |
372 | if (pathp && !IS_ERR(pathp)) |
373 | path_put(pathp); |
374 | return ret; |
375 | } |
376 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9