blob: 82030e1dfd631b1495f87ebe632f30ed6f1086fa [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001#include <linux/sched.h> /* for capable() */
2#include <linux/blkdev.h>
3#include <linux/blkpg.h>
Christoph Hellwiga885c8c2006-01-08 01:02:50 -08004#include <linux/hdreg.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -07005#include <linux/backing-dev.h>
6#include <linux/buffer_head.h>
7#include <linux/smp_lock.h>
8#include <asm/uaccess.h>
9
10static int blkpg_ioctl(struct block_device *bdev, struct blkpg_ioctl_arg __user *arg)
11{
12 struct block_device *bdevp;
13 struct gendisk *disk;
14 struct blkpg_ioctl_arg a;
15 struct blkpg_partition p;
16 long long start, length;
17 int part;
18 int i;
19
20 if (!capable(CAP_SYS_ADMIN))
21 return -EACCES;
22 if (copy_from_user(&a, arg, sizeof(struct blkpg_ioctl_arg)))
23 return -EFAULT;
24 if (copy_from_user(&p, a.data, sizeof(struct blkpg_partition)))
25 return -EFAULT;
26 disk = bdev->bd_disk;
27 if (bdev != bdev->bd_contains)
28 return -EINVAL;
29 part = p.pno;
30 if (part <= 0 || part >= disk->minors)
31 return -EINVAL;
32 switch (a.op) {
33 case BLKPG_ADD_PARTITION:
34 start = p.start >> 9;
35 length = p.length >> 9;
36 /* check for fit in a hd_struct */
37 if (sizeof(sector_t) == sizeof(long) &&
38 sizeof(long long) > sizeof(long)) {
39 long pstart = start, plength = length;
40 if (pstart != start || plength != length
41 || pstart < 0 || plength < 0)
42 return -EINVAL;
43 }
44 /* partition number in use? */
45 down(&bdev->bd_sem);
46 if (disk->part[part - 1]) {
47 up(&bdev->bd_sem);
48 return -EBUSY;
49 }
50 /* overlap? */
51 for (i = 0; i < disk->minors - 1; i++) {
52 struct hd_struct *s = disk->part[i];
53
54 if (!s)
55 continue;
56 if (!(start+length <= s->start_sect ||
57 start >= s->start_sect + s->nr_sects)) {
58 up(&bdev->bd_sem);
59 return -EBUSY;
60 }
61 }
62 /* all seems OK */
63 add_partition(disk, part, start, length);
64 up(&bdev->bd_sem);
65 return 0;
66 case BLKPG_DEL_PARTITION:
67 if (!disk->part[part-1])
68 return -ENXIO;
69 if (disk->part[part - 1]->nr_sects == 0)
70 return -ENXIO;
71 bdevp = bdget_disk(disk, part);
72 if (!bdevp)
73 return -ENOMEM;
74 down(&bdevp->bd_sem);
75 if (bdevp->bd_openers) {
76 up(&bdevp->bd_sem);
77 bdput(bdevp);
78 return -EBUSY;
79 }
80 /* all seems OK */
81 fsync_bdev(bdevp);
82 invalidate_bdev(bdevp, 0);
83
84 down(&bdev->bd_sem);
85 delete_partition(disk, part);
86 up(&bdev->bd_sem);
87 up(&bdevp->bd_sem);
88 bdput(bdevp);
89
90 return 0;
91 default:
92 return -EINVAL;
93 }
94}
95
96static int blkdev_reread_part(struct block_device *bdev)
97{
98 struct gendisk *disk = bdev->bd_disk;
99 int res;
100
101 if (disk->minors == 1 || bdev != bdev->bd_contains)
102 return -EINVAL;
103 if (!capable(CAP_SYS_ADMIN))
104 return -EACCES;
105 if (down_trylock(&bdev->bd_sem))
106 return -EBUSY;
107 res = rescan_partitions(disk, bdev);
108 up(&bdev->bd_sem);
109 return res;
110}
111
112static int put_ushort(unsigned long arg, unsigned short val)
113{
114 return put_user(val, (unsigned short __user *)arg);
115}
116
117static int put_int(unsigned long arg, int val)
118{
119 return put_user(val, (int __user *)arg);
120}
121
122static int put_long(unsigned long arg, long val)
123{
124 return put_user(val, (long __user *)arg);
125}
126
127static int put_ulong(unsigned long arg, unsigned long val)
128{
129 return put_user(val, (unsigned long __user *)arg);
130}
131
132static int put_u64(unsigned long arg, u64 val)
133{
134 return put_user(val, (u64 __user *)arg);
135}
136
Arnd Bergmannbb93e3a2005-06-23 00:10:15 -0700137static int blkdev_locked_ioctl(struct file *file, struct block_device *bdev,
138 unsigned cmd, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140 struct backing_dev_info *bdi;
141 int ret, n;
142
143 switch (cmd) {
144 case BLKRAGET:
145 case BLKFRAGET:
146 if (!arg)
147 return -EINVAL;
148 bdi = blk_get_backing_dev_info(bdev);
149 if (bdi == NULL)
150 return -ENOTTY;
151 return put_long(arg, (bdi->ra_pages * PAGE_CACHE_SIZE) / 512);
152 case BLKROGET:
153 return put_int(arg, bdev_read_only(bdev) != 0);
154 case BLKBSZGET: /* get the logical block size (cf. BLKSSZGET) */
155 return put_int(arg, block_size(bdev));
156 case BLKSSZGET: /* get block device hardware sector size */
157 return put_int(arg, bdev_hardsect_size(bdev));
158 case BLKSECTGET:
159 return put_ushort(arg, bdev_get_queue(bdev)->max_sectors);
160 case BLKRASET:
161 case BLKFRASET:
162 if(!capable(CAP_SYS_ADMIN))
163 return -EACCES;
164 bdi = blk_get_backing_dev_info(bdev);
165 if (bdi == NULL)
166 return -ENOTTY;
167 bdi->ra_pages = (arg * 512) / PAGE_CACHE_SIZE;
168 return 0;
169 case BLKBSZSET:
170 /* set the logical block size */
171 if (!capable(CAP_SYS_ADMIN))
172 return -EACCES;
173 if (!arg)
174 return -EINVAL;
175 if (get_user(n, (int __user *) arg))
176 return -EFAULT;
177 if (bd_claim(bdev, file) < 0)
178 return -EBUSY;
179 ret = set_blocksize(bdev, n);
180 bd_release(bdev);
181 return ret;
182 case BLKPG:
183 return blkpg_ioctl(bdev, (struct blkpg_ioctl_arg __user *) arg);
184 case BLKRRPART:
185 return blkdev_reread_part(bdev);
186 case BLKGETSIZE:
187 if ((bdev->bd_inode->i_size >> 9) > ~0UL)
188 return -EFBIG;
189 return put_ulong(arg, bdev->bd_inode->i_size >> 9);
190 case BLKGETSIZE64:
191 return put_u64(arg, bdev->bd_inode->i_size);
Arnd Bergmannbb93e3a2005-06-23 00:10:15 -0700192 }
193 return -ENOIOCTLCMD;
194}
195
196static int blkdev_driver_ioctl(struct inode *inode, struct file *file,
197 struct gendisk *disk, unsigned cmd, unsigned long arg)
198{
199 int ret;
200 if (disk->fops->unlocked_ioctl)
201 return disk->fops->unlocked_ioctl(file, cmd, arg);
202
203 if (disk->fops->ioctl) {
204 lock_kernel();
205 ret = disk->fops->ioctl(inode, file, cmd, arg);
206 unlock_kernel();
207 return ret;
208 }
209
210 return -ENOTTY;
211}
212
213int blkdev_ioctl(struct inode *inode, struct file *file, unsigned cmd,
214 unsigned long arg)
215{
216 struct block_device *bdev = inode->i_bdev;
217 struct gendisk *disk = bdev->bd_disk;
218 int ret, n;
219
220 switch(cmd) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221 case BLKFLSBUF:
222 if (!capable(CAP_SYS_ADMIN))
223 return -EACCES;
Arnd Bergmannbb93e3a2005-06-23 00:10:15 -0700224
225 ret = blkdev_driver_ioctl(inode, file, disk, cmd, arg);
226 /* -EINVAL to handle old uncorrected drivers */
227 if (ret != -EINVAL && ret != -ENOTTY)
228 return ret;
229
230 lock_kernel();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 fsync_bdev(bdev);
232 invalidate_bdev(bdev, 0);
Arnd Bergmannbb93e3a2005-06-23 00:10:15 -0700233 unlock_kernel();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234 return 0;
Arnd Bergmannbb93e3a2005-06-23 00:10:15 -0700235
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236 case BLKROSET:
Arnd Bergmannbb93e3a2005-06-23 00:10:15 -0700237 ret = blkdev_driver_ioctl(inode, file, disk, cmd, arg);
238 /* -EINVAL to handle old uncorrected drivers */
239 if (ret != -EINVAL && ret != -ENOTTY)
240 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241 if (!capable(CAP_SYS_ADMIN))
242 return -EACCES;
243 if (get_user(n, (int __user *)(arg)))
244 return -EFAULT;
Arnd Bergmannbb93e3a2005-06-23 00:10:15 -0700245 lock_kernel();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 set_device_ro(bdev, n);
Arnd Bergmannbb93e3a2005-06-23 00:10:15 -0700247 unlock_kernel();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248 return 0;
Christoph Hellwiga885c8c2006-01-08 01:02:50 -0800249 case HDIO_GETGEO: {
250 struct hd_geometry geo;
251
252 if (!arg)
253 return -EINVAL;
254 if (!disk->fops->getgeo)
255 return -ENOTTY;
256
257 /*
258 * We need to set the startsect first, the driver may
259 * want to override it.
260 */
261 geo.start = get_start_sect(bdev);
262 ret = disk->fops->getgeo(bdev, &geo);
263 if (ret)
264 return ret;
265 if (copy_to_user((struct hd_geometry __user *)arg, &geo,
266 sizeof(geo)))
267 return -EFAULT;
268 return 0;
269 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270 }
Arnd Bergmannbb93e3a2005-06-23 00:10:15 -0700271
272 lock_kernel();
273 ret = blkdev_locked_ioctl(file, bdev, cmd, arg);
274 unlock_kernel();
275 if (ret != -ENOIOCTLCMD)
276 return ret;
277
278 return blkdev_driver_ioctl(inode, file, disk, cmd, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279}
280
281/* Most of the generic ioctls are handled in the normal fallback path.
282 This assumes the blkdev's low level compat_ioctl always returns
283 ENOIOCTLCMD for unknown ioctls. */
284long compat_blkdev_ioctl(struct file *file, unsigned cmd, unsigned long arg)
285{
286 struct block_device *bdev = file->f_dentry->d_inode->i_bdev;
287 struct gendisk *disk = bdev->bd_disk;
288 int ret = -ENOIOCTLCMD;
289 if (disk->fops->compat_ioctl) {
290 lock_kernel();
291 ret = disk->fops->compat_ioctl(file, cmd, arg);
292 unlock_kernel();
293 }
294 return ret;
295}
Stephen Tweedie68f66fe2005-05-13 23:31:19 -0400296
297EXPORT_SYMBOL_GPL(blkdev_ioctl);