ioctl.c 7.4 KB

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