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