drivers/char/raw.c

   1 /*
   2  * linux/drivers/char/raw.c
   3  *
   4  * Front-end raw character devices.  These can be bound to any block
   5  * devices to provide genuine Unix raw character device semantics.
   6  *
   7  * We reserve minor number 0 for a control interface.  ioctl()s on this
   8  * device are used to bind the other minor numbers to block devices.
   9  */
  10
  11 #include <linux/init.h>
  12 #include <linux/fs.h>
  13 #include <linux/major.h>
  14 #include <linux/blkdev.h>
  15 #include <linux/module.h>
  16 #include <linux/raw.h>
  17 #include <linux/capability.h>
  18 #include <linux/uio.h>
  19 #include <linux/cdev.h>
  20 #include <linux/device.h>
  21 #include <linux/mutex.h>
  22 #include <linux/gfp.h>
  23 #include <linux/compat.h>
  24
  25 #include <asm/uaccess.h>
  26
  27 struct raw_device_data {
  28         struct block_device *binding;
  29         int inuse;
  30 };
  31
  32 static struct class *raw_class;
  33 static struct raw_device_data raw_devices[MAX_RAW_MINORS];
  34 static DEFINE_MUTEX(raw_mutex);
  35 static const struct file_operations raw_ctl_fops; /* forward declaration */
  36
  37 /*
  38  * Open/close code for raw IO.
  39  *
  40  * We just rewrite the i_mapping for the /dev/raw/rawN file descriptor to
  41  * point at the blockdev's address_space and set the file handle to use
  42  * O_DIRECT.
  43  *
  44  * Set the device's soft blocksize to the minimum possible.  This gives the
  45  * finest possible alignment and has no adverse impact on performance.
  46  */
  47 static int raw_open(struct inode *inode, struct file *filp)
  48 {
  49         const int minor = iminor(inode);
  50         struct block_device *bdev;
  51         int err;
  52
  53         if (minor == 0) {       /* It is the control device */
  54                 filp->f_op = &raw_ctl_fops;
  55                 return 0;
  56         }
  57
  58         mutex_lock(&raw_mutex);
  59
  60         /*
  61          * All we need to do on open is check that the device is bound.
  62          */
  63         bdev = raw_devices[minor].binding;
  64         err = -ENODEV;
  65         if (!bdev)
  66                 goto out;
  67         igrab(bdev->bd_inode);
  68         err = blkdev_get(bdev, filp->f_mode | FMODE_EXCL, raw_open);
  69         if (err)
  70                 goto out;
  71         err = set_blocksize(bdev, bdev_logical_block_size(bdev));
  72         if (err)
  73                 goto out1;
  74         filp->f_flags |= O_DIRECT;
  75         filp->f_mapping = bdev->bd_inode->i_mapping;
  76         if (++raw_devices[minor].inuse == 1)
  77                 filp->f_path.dentry->d_inode->i_mapping =
  78                         bdev->bd_inode->i_mapping;
  79         filp->private_data = bdev;
  80         mutex_unlock(&raw_mutex);
  81         return 0;
  82
  83 out1:
  84         blkdev_put(bdev, filp->f_mode | FMODE_EXCL);
  85 out:
  86         mutex_unlock(&raw_mutex);
  87         return err;
  88 }
  89
  90 /*
  91  * When the final fd which refers to this character-special node is closed, we
  92  * make its ->mapping point back at its own i_data.
  93  */
  94 static int raw_release(struct inode *inode, struct file *filp)
  95 {
  96         const int minor= iminor(inode);
  97         struct block_device *bdev;
  98
  99         mutex_lock(&raw_mutex);
 100         bdev = raw_devices[minor].binding;
 101         if (--raw_devices[minor].inuse == 0) {
 102                 /* Here  inode->i_mapping == bdev->bd_inode->i_mapping  */
 103                 inode->i_mapping = &inode->i_data;
 104                 inode->i_mapping->backing_dev_info = &default_backing_dev_info;
 105         }
 106         mutex_unlock(&raw_mutex);
 107
 108         blkdev_put(bdev, filp->f_mode | FMODE_EXCL);
 109         return 0;
 110 }
 111
 112 /*
 113  * Forward ioctls to the underlying block device.
 114  */
 115 static long
 116 raw_ioctl(struct file *filp, unsigned int command, unsigned long arg)
 117 {
 118         struct block_device *bdev = filp->private_data;
 119         return blkdev_ioctl(bdev, 0, command, arg);
 120 }
 121
 122 static int bind_set(int number, u64 major, u64 minor)
 123 {
 124         dev_t dev = MKDEV(major, minor);
 125         struct raw_device_data *rawdev;
 126         int err = 0;
 127
 128         if (number <= 0 || number >= MAX_RAW_MINORS)
 129                 return -EINVAL;
 130
 131         if (MAJOR(dev) != major || MINOR(dev) != minor)
 132                 return -EINVAL;
 133
 134         rawdev = &raw_devices[number];
 135
 136         /*
 137          * This is like making block devices, so demand the
 138          * same capability
 139          */
 140         if (!capable(CAP_SYS_ADMIN))
 141                 return -EPERM;
 142
 143         /*
 144          * For now, we don't need to check that the underlying
 145          * block device is present or not: we can do that when
 146          * the raw device is opened.  Just check that the
 147          * major/minor numbers make sense.
 148          */
 149
 150         if (MAJOR(dev) == 0 && dev != 0)
 151                 return -EINVAL;
 152
 153         mutex_lock(&raw_mutex);
 154         if (rawdev->inuse) {
 155                 mutex_unlock(&raw_mutex);
 156                 return -EBUSY;
 157         }
 158         if (rawdev->binding) {
 159                 bdput(rawdev->binding);
 160                 module_put(THIS_MODULE);
 161         }
 162         if (!dev) {
 163                 /* unbind */
 164                 rawdev->binding = NULL;
 165                 device_destroy(raw_class, MKDEV(RAW_MAJOR, number));
 166         } else {
 167                 rawdev->binding = bdget(dev);
 168                 if (rawdev->binding == NULL) {
 169                         err = -ENOMEM;
 170                 } else {
 171                         dev_t raw = MKDEV(RAW_MAJOR, number);
 172                         __module_get(THIS_MODULE);
 173                         device_destroy(raw_class, raw);
 174                         device_create(raw_class, NULL, raw, NULL,
 175                                       "raw%d", number);
 176                 }
 177         }
 178         mutex_unlock(&raw_mutex);
 179         return err;
 180 }
 181
 182 static int bind_get(int number, dev_t *dev)
 183 {
 184         struct raw_device_data *rawdev;
 185         struct block_device *bdev;
 186
 187         if (number <= 0 || number >= MAX_RAW_MINORS)
 188                 return -EINVAL;
 189
 190         rawdev = &raw_devices[number];
 191
 192         mutex_lock(&raw_mutex);
 193         bdev = rawdev->binding;
 194         *dev = bdev ? bdev->bd_dev : 0;
 195         mutex_unlock(&raw_mutex);
 196         return 0;
 197 }
 198
 199 /*
 200  * Deal with ioctls against the raw-device control interface, to bind
 201  * and unbind other raw devices.
 202  */
 203 static long raw_ctl_ioctl(struct file *filp, unsigned int command,
 204                           unsigned long arg)
 205 {
 206         struct raw_config_request rq;
 207         dev_t dev;
 208         int err;
 209
 210         switch (command) {
 211         case RAW_SETBIND:
 212                 if (copy_from_user(&rq, (void __user *) arg, sizeof(rq)))
 213                         return -EFAULT;
 214
 215                 return bind_set(rq.raw_minor, rq.block_major, rq.block_minor);
 216
 217         case RAW_GETBIND:
 218                 if (copy_from_user(&rq, (void __user *) arg, sizeof(rq)))
 219                         return -EFAULT;
 220
 221                 err = bind_get(rq.raw_minor, &dev);
 222                 if (err)
 223                         return err;
 224
 225                 rq.block_major = MAJOR(dev);
 226                 rq.block_minor = MINOR(dev);
 227
 228                 if (copy_to_user((void __user *)arg, &rq, sizeof(rq)))
 229                         return -EFAULT;
 230
 231                 return 0;
 232         }
 233
 234         return -EINVAL;
 235 }
 236
 237 #ifdef CONFIG_COMPAT
 238 struct raw32_config_request {
 239         compat_int_t    raw_minor;
 240         compat_u64      block_major;
 241         compat_u64      block_minor;
 242 };
 243
 244 static long raw_ctl_compat_ioctl(struct file *file, unsigned int cmd,
 245                                 unsigned long arg)
 246 {
 247         struct raw32_config_request __user *user_req = compat_ptr(arg);
 248         struct raw32_config_request rq;
 249         dev_t dev;
 250         int err = 0;
 251
 252         switch (cmd) {
 253         case RAW_SETBIND:
 254                 if (copy_from_user(&rq, user_req, sizeof(rq)))
 255                         return -EFAULT;
 256
 257                 return bind_set(rq.raw_minor, rq.block_major, rq.block_minor);
 258
 259         case RAW_GETBIND:
 260                 if (copy_from_user(&rq, user_req, sizeof(rq)))
 261                         return -EFAULT;
 262
 263                 err = bind_get(rq.raw_minor, &dev);
 264                 if (err)
 265                         return err;
 266
 267                 rq.block_major = MAJOR(dev);
 268                 rq.block_minor = MINOR(dev);
 269
 270                 if (copy_to_user(user_req, &rq, sizeof(rq)))
 271                         return -EFAULT;
 272
 273                 return 0;
 274         }
 275
 276         return -EINVAL;
 277 }
 278 #endif
 279
 280 static const struct file_operations raw_fops = {
 281         .read           = do_sync_read,
 282         .aio_read       = generic_file_aio_read,
 283         .write          = do_sync_write,
 284         .aio_write      = blkdev_aio_write,
 285         .fsync          = blkdev_fsync,
 286         .open           = raw_open,
 287         .release        = raw_release,
 288         .unlocked_ioctl = raw_ioctl,
 289         .llseek         = default_llseek,
 290         .owner          = THIS_MODULE,
 291 };
 292
 293 static const struct file_operations raw_ctl_fops = {
 294         .unlocked_ioctl = raw_ctl_ioctl,
 295 #ifdef CONFIG_COMPAT
 296         .compat_ioctl   = raw_ctl_compat_ioctl,
 297 #endif
 298         .open           = raw_open,
 299         .owner          = THIS_MODULE,
 300         .llseek         = noop_llseek,
 301 };
 302
 303 static struct cdev raw_cdev;
 304
 305 static char *raw_devnode(struct device *dev, mode_t *mode)
 306 {
 307         return kasprintf(GFP_KERNEL, "raw/%s", dev_name(dev));
 308 }
 309
 310 static int __init raw_init(void)
 311 {
 312         dev_t dev = MKDEV(RAW_MAJOR, 0);
 313         int ret;
 314
 315         ret = register_chrdev_region(dev, MAX_RAW_MINORS, "raw");
 316         if (ret)
 317                 goto error;
 318
 319         cdev_init(&raw_cdev, &raw_fops);
 320         ret = cdev_add(&raw_cdev, dev, MAX_RAW_MINORS);
 321         if (ret) {
 322                 kobject_put(&raw_cdev.kobj);
 323                 goto error_region;
 324         }
 325
 326         raw_class = class_create(THIS_MODULE, "raw");
 327         if (IS_ERR(raw_class)) {
 328                 printk(KERN_ERR "Error creating raw class.\n");
 329                 cdev_del(&raw_cdev);
 330                 ret = PTR_ERR(raw_class);
 331                 goto error_region;
 332         }
 333         raw_class->devnode = raw_devnode;
 334         device_create(raw_class, NULL, MKDEV(RAW_MAJOR, 0), NULL, "rawctl");
 335
 336         return 0;
 337
 338 error_region:
 339         unregister_chrdev_region(dev, MAX_RAW_MINORS);
 340 error:
 341         return ret;
 342 }
 343
 344 static void __exit raw_exit(void)
 345 {
 346         device_destroy(raw_class, MKDEV(RAW_MAJOR, 0));
 347         class_destroy(raw_class);
 348         cdev_del(&raw_cdev);
 349         unregister_chrdev_region(MKDEV(RAW_MAJOR, 0), MAX_RAW_MINORS);
 350 }
 351
 352 module_init(raw_init);
 353 module_exit(raw_exit);
 354 MODULE_LICENSE("GPL");