new helper: iterate_supers()
[linux-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 <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                          void __user *addr)
68 {
69         char *pathname;
70         int ret = -ENOSYS;
71
72         pathname = getname(addr);
73         if (IS_ERR(pathname))
74                 return PTR_ERR(pathname);
75         if (sb->s_qcop->quota_on)
76                 ret = sb->s_qcop->quota_on(sb, type, id, pathname, 0);
77         putname(pathname);
78         return ret;
79 }
80
81 static int quota_getfmt(struct super_block *sb, int type, void __user *addr)
82 {
83         __u32 fmt;
84
85         down_read(&sb_dqopt(sb)->dqptr_sem);
86         if (!sb_has_quota_active(sb, type)) {
87                 up_read(&sb_dqopt(sb)->dqptr_sem);
88                 return -ESRCH;
89         }
90         fmt = sb_dqopt(sb)->info[type].dqi_format->qf_fmt_id;
91         up_read(&sb_dqopt(sb)->dqptr_sem);
92         if (copy_to_user(addr, &fmt, sizeof(fmt)))
93                 return -EFAULT;
94         return 0;
95 }
96
97 static int quota_getinfo(struct super_block *sb, int type, void __user *addr)
98 {
99         struct if_dqinfo info;
100         int ret;
101
102         if (!sb->s_qcop->get_info)
103                 return -ENOSYS;
104         ret = sb->s_qcop->get_info(sb, type, &info);
105         if (!ret && copy_to_user(addr, &info, sizeof(info)))
106                 return -EFAULT;
107         return ret;
108 }
109
110 static int quota_setinfo(struct super_block *sb, int type, void __user *addr)
111 {
112         struct if_dqinfo info;
113
114         if (copy_from_user(&info, addr, sizeof(info)))
115                 return -EFAULT;
116         if (!sb->s_qcop->set_info)
117                 return -ENOSYS;
118         return sb->s_qcop->set_info(sb, type, &info);
119 }
120
121 static void copy_to_if_dqblk(struct if_dqblk *dst, struct fs_disk_quota *src)
122 {
123         dst->dqb_bhardlimit = src->d_blk_hardlimit;
124         dst->dqb_bsoftlimit = src->d_blk_softlimit;
125         dst->dqb_curspace = src->d_bcount;
126         dst->dqb_ihardlimit = src->d_ino_hardlimit;
127         dst->dqb_isoftlimit = src->d_ino_softlimit;
128         dst->dqb_curinodes = src->d_icount;
129         dst->dqb_btime = src->d_btimer;
130         dst->dqb_itime = src->d_itimer;
131         dst->dqb_valid = QIF_ALL;
132 }
133
134 static int quota_getquota(struct super_block *sb, int type, qid_t id,
135                           void __user *addr)
136 {
137         struct fs_disk_quota fdq;
138         struct if_dqblk idq;
139         int ret;
140
141         if (!sb->s_qcop->get_dqblk)
142                 return -ENOSYS;
143         ret = sb->s_qcop->get_dqblk(sb, type, id, &fdq);
144         if (ret)
145                 return ret;
146         copy_to_if_dqblk(&idq, &fdq);
147         if (copy_to_user(addr, &idq, sizeof(idq)))
148                 return -EFAULT;
149         return 0;
150 }
151
152 static void copy_from_if_dqblk(struct fs_disk_quota *dst, struct if_dqblk *src)
153 {
154         dst->d_blk_hardlimit = src->dqb_bhardlimit;
155         dst->d_blk_softlimit  = src->dqb_bsoftlimit;
156         dst->d_bcount = src->dqb_curspace;
157         dst->d_ino_hardlimit = src->dqb_ihardlimit;
158         dst->d_ino_softlimit = src->dqb_isoftlimit;
159         dst->d_icount = src->dqb_curinodes;
160         dst->d_btimer = src->dqb_btime;
161         dst->d_itimer = src->dqb_itime;
162
163         dst->d_fieldmask = 0;
164         if (src->dqb_valid & QIF_BLIMITS)
165                 dst->d_fieldmask |= FS_DQ_BSOFT | FS_DQ_BHARD;
166         if (src->dqb_valid & QIF_SPACE)
167                 dst->d_fieldmask |= FS_DQ_BCOUNT;
168         if (src->dqb_valid & QIF_ILIMITS)
169                 dst->d_fieldmask |= FS_DQ_ISOFT | FS_DQ_IHARD;
170         if (src->dqb_valid & QIF_INODES)
171                 dst->d_fieldmask |= FS_DQ_ICOUNT;
172         if (src->dqb_valid & QIF_BTIME)
173                 dst->d_fieldmask |= FS_DQ_BTIMER;
174         if (src->dqb_valid & QIF_ITIME)
175                 dst->d_fieldmask |= FS_DQ_ITIMER;
176 }
177
178 static int quota_setquota(struct super_block *sb, int type, qid_t id,
179                           void __user *addr)
180 {
181         struct fs_disk_quota fdq;
182         struct if_dqblk idq;
183
184         if (copy_from_user(&idq, addr, sizeof(idq)))
185                 return -EFAULT;
186         if (!sb->s_qcop->set_dqblk)
187                 return -ENOSYS;
188         copy_from_if_dqblk(&fdq, &idq);
189         return sb->s_qcop->set_dqblk(sb, type, id, &fdq);
190 }
191
192 static int quota_setxstate(struct super_block *sb, int cmd, void __user *addr)
193 {
194         __u32 flags;
195
196         if (copy_from_user(&flags, addr, sizeof(flags)))
197                 return -EFAULT;
198         if (!sb->s_qcop->set_xstate)
199                 return -ENOSYS;
200         return sb->s_qcop->set_xstate(sb, flags, cmd);
201 }
202
203 static int quota_getxstate(struct super_block *sb, void __user *addr)
204 {
205         struct fs_quota_stat fqs;
206         int ret;
207
208         if (!sb->s_qcop->get_xstate)
209                 return -ENOSYS;
210         ret = sb->s_qcop->get_xstate(sb, &fqs);
211         if (!ret && copy_to_user(addr, &fqs, sizeof(fqs)))
212                 return -EFAULT;
213         return ret;
214 }
215
216 static int quota_setxquota(struct super_block *sb, int type, qid_t id,
217                            void __user *addr)
218 {
219         struct fs_disk_quota fdq;
220
221         if (copy_from_user(&fdq, addr, sizeof(fdq)))
222                 return -EFAULT;
223         if (!sb->s_qcop->set_dqblk)
224                 return -ENOSYS;
225         return sb->s_qcop->set_dqblk(sb, type, id, &fdq);
226 }
227
228 static int quota_getxquota(struct super_block *sb, int type, qid_t id,
229                            void __user *addr)
230 {
231         struct fs_disk_quota fdq;
232         int ret;
233
234         if (!sb->s_qcop->get_dqblk)
235                 return -ENOSYS;
236         ret = sb->s_qcop->get_dqblk(sb, type, id, &fdq);
237         if (!ret && copy_to_user(addr, &fdq, sizeof(fdq)))
238                 return -EFAULT;
239         return ret;
240 }
241
242 /* Copy parameters and call proper function */
243 static int do_quotactl(struct super_block *sb, int type, int cmd, qid_t id,
244                        void __user *addr)
245 {
246         int ret;
247
248         if (type >= (XQM_COMMAND(cmd) ? XQM_MAXQUOTAS : MAXQUOTAS))
249                 return -EINVAL;
250         if (!sb->s_qcop)
251                 return -ENOSYS;
252
253         ret = check_quotactl_permission(sb, type, cmd, id);
254         if (ret < 0)
255                 return ret;
256
257         switch (cmd) {
258         case Q_QUOTAON:
259                 return quota_quotaon(sb, type, cmd, id, addr);
260         case Q_QUOTAOFF:
261                 if (!sb->s_qcop->quota_off)
262                         return -ENOSYS;
263                 return sb->s_qcop->quota_off(sb, type, 0);
264         case Q_GETFMT:
265                 return quota_getfmt(sb, type, addr);
266         case Q_GETINFO:
267                 return quota_getinfo(sb, type, addr);
268         case Q_SETINFO:
269                 return quota_setinfo(sb, type, addr);
270         case Q_GETQUOTA:
271                 return quota_getquota(sb, type, id, addr);
272         case Q_SETQUOTA:
273                 return quota_setquota(sb, type, id, addr);
274         case Q_SYNC:
275                 if (!sb->s_qcop->quota_sync)
276                         return -ENOSYS;
277                 return sb->s_qcop->quota_sync(sb, type, 1);
278         case Q_XQUOTAON:
279         case Q_XQUOTAOFF:
280         case Q_XQUOTARM:
281                 return quota_setxstate(sb, cmd, addr);
282         case Q_XGETQSTAT:
283                 return quota_getxstate(sb, addr);
284         case Q_XSETQLIM:
285                 return quota_setxquota(sb, type, id, addr);
286         case Q_XGETQUOTA:
287                 return quota_getxquota(sb, type, id, addr);
288         case Q_XQUOTASYNC:
289                 /* caller already holds s_umount */
290                 if (sb->s_flags & MS_RDONLY)
291                         return -EROFS;
292                 writeback_inodes_sb(sb);
293                 return 0;
294         default:
295                 return -EINVAL;
296         }
297 }
298
299 /*
300  * look up a superblock on which quota ops will be performed
301  * - use the name of a block device to find the superblock thereon
302  */
303 static struct super_block *quotactl_block(const char __user *special)
304 {
305 #ifdef CONFIG_BLOCK
306         struct block_device *bdev;
307         struct super_block *sb;
308         char *tmp = getname(special);
309
310         if (IS_ERR(tmp))
311                 return ERR_CAST(tmp);
312         bdev = lookup_bdev(tmp);
313         putname(tmp);
314         if (IS_ERR(bdev))
315                 return ERR_CAST(bdev);
316         sb = get_super(bdev);
317         bdput(bdev);
318         if (!sb)
319                 return ERR_PTR(-ENODEV);
320
321         return sb;
322 #else
323         return ERR_PTR(-ENODEV);
324 #endif
325 }
326
327 /*
328  * This is the system call interface. This communicates with
329  * the user-level programs. Currently this only supports diskquota
330  * calls. Maybe we need to add the process quotas etc. in the future,
331  * but we probably should use rlimits for that.
332  */
333 SYSCALL_DEFINE4(quotactl, unsigned int, cmd, const char __user *, special,
334                 qid_t, id, void __user *, addr)
335 {
336         uint cmds, type;
337         struct super_block *sb = NULL;
338         int ret;
339
340         cmds = cmd >> SUBCMDSHIFT;
341         type = cmd & SUBCMDMASK;
342
343         /*
344          * As a special case Q_SYNC can be called without a specific device.
345          * It will iterate all superblocks that have quota enabled and call
346          * the sync action on each of them.
347          */
348         if (!special) {
349                 if (cmds == Q_SYNC)
350                         return quota_sync_all(type);
351                 return -ENODEV;
352         }
353
354         sb = quotactl_block(special);
355         if (IS_ERR(sb))
356                 return PTR_ERR(sb);
357
358         ret = do_quotactl(sb, type, cmds, id, addr);
359
360         drop_super(sb);
361         return ret;
362 }