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, ADDPART_FLAG_NONE); 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); 84 85 mutex_lock_nested(&bdev->bd_mutex, 1); 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 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 EXPORT_SYMBOL_GPL(blkdev_driver_ioctl); 219 220 int blkdev_ioctl(struct inode *inode, struct file *file, unsigned cmd, 221 unsigned long arg) 222 { 223 struct block_device *bdev = inode->i_bdev; 224 struct gendisk *disk = bdev->bd_disk; 225 int ret, n; 226 227 switch(cmd) { 228 case BLKFLSBUF: 229 if (!capable(CAP_SYS_ADMIN)) 230 return -EACCES; 231 232 ret = blkdev_driver_ioctl(inode, file, disk, cmd, arg); 233 /* -EINVAL to handle old uncorrected drivers */ 234 if (ret != -EINVAL && ret != -ENOTTY) 235 return ret; 236 237 lock_kernel(); 238 fsync_bdev(bdev); 239 invalidate_bdev(bdev); 240 unlock_kernel(); 241 return 0; 242 243 case BLKROSET: 244 ret = blkdev_driver_ioctl(inode, file, disk, cmd, arg); 245 /* -EINVAL to handle old uncorrected drivers */ 246 if (ret != -EINVAL && ret != -ENOTTY) 247 return ret; 248 if (!capable(CAP_SYS_ADMIN)) 249 return -EACCES; 250 if (get_user(n, (int __user *)(arg))) 251 return -EFAULT; 252 lock_kernel(); 253 set_device_ro(bdev, n); 254 unlock_kernel(); 255 return 0; 256 case HDIO_GETGEO: { 257 struct hd_geometry geo; 258 259 if (!arg) 260 return -EINVAL; 261 if (!disk->fops->getgeo) 262 return -ENOTTY; 263 264 /* 265 * We need to set the startsect first, the driver may 266 * want to override it. 267 */ 268 geo.start = get_start_sect(bdev); 269 ret = disk->fops->getgeo(bdev, &geo); 270 if (ret) 271 return ret; 272 if (copy_to_user((struct hd_geometry __user *)arg, &geo, 273 sizeof(geo))) 274 return -EFAULT; 275 return 0; 276 } 277 } 278 279 lock_kernel(); 280 ret = blkdev_locked_ioctl(file, bdev, cmd, arg); 281 unlock_kernel(); 282 if (ret != -ENOIOCTLCMD) 283 return ret; 284 285 return blkdev_driver_ioctl(inode, file, disk, cmd, arg); 286 } 287 288 /* Most of the generic ioctls are handled in the normal fallback path. 289 This assumes the blkdev's low level compat_ioctl always returns 290 ENOIOCTLCMD for unknown ioctls. */ 291 long compat_blkdev_ioctl(struct file *file, unsigned cmd, unsigned long arg) 292 { 293 struct block_device *bdev = file->f_path.dentry->d_inode->i_bdev; 294 struct gendisk *disk = bdev->bd_disk; 295 int ret = -ENOIOCTLCMD; 296 if (disk->fops->compat_ioctl) { 297 lock_kernel(); 298 ret = disk->fops->compat_ioctl(file, cmd, arg); 299 unlock_kernel(); 300 } 301 return ret; 302 } 303 304 EXPORT_SYMBOL_GPL(blkdev_ioctl); 305