drivers/s390/char/hmcdrv_dev.c

   1 /*
   2  *    HMC Drive CD/DVD Device
   3  *
   4  *    Copyright IBM Corp. 2013
   5  *    Author(s): Ralf Hoppe (rhoppe@de.ibm.com)
   6  *
   7  *    This file provides a Linux "misc" character device for access to an
   8  *    assigned HMC drive CD/DVD-ROM. It works as follows: First create the
   9  *    device by calling hmcdrv_dev_init(). After open() a lseek(fd, 0,
  10  *    SEEK_END) indicates that a new FTP command follows (not needed on the
  11  *    first command after open). Then write() the FTP command ASCII string
  12  *    to it, e.g. "dir /" or "nls <directory>" or "get <filename>". At the
  13  *    end read() the response.
  14  */
  15
  16 #define KMSG_COMPONENT "hmcdrv"
  17 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
  18
  19 #include <linux/kernel.h>
  20 #include <linux/module.h>
  21 #include <linux/slab.h>
  22 #include <linux/fs.h>
  23 #include <linux/cdev.h>
  24 #include <linux/miscdevice.h>
  25 #include <linux/device.h>
  26 #include <linux/capability.h>
  27 #include <linux/delay.h>
  28 #include <linux/uaccess.h>
  29
  30 #include "hmcdrv_dev.h"
  31 #include "hmcdrv_ftp.h"
  32
  33 /* If the following macro is defined, then the HMC device creates it's own
  34  * separated device class (and dynamically assigns a major number). If not
  35  * defined then the HMC device is assigned to the "misc" class devices.
  36  *
  37 #define HMCDRV_DEV_CLASS "hmcftp"
  38  */
  39
  40 #define HMCDRV_DEV_NAME  "hmcdrv"
  41 #define HMCDRV_DEV_BUSY_DELAY    500 /* delay between -EBUSY trials in ms */
  42 #define HMCDRV_DEV_BUSY_RETRIES  3   /* number of retries on -EBUSY */
  43
  44 struct hmcdrv_dev_node {
  45
  46 #ifdef HMCDRV_DEV_CLASS
  47         struct cdev dev; /* character device structure */
  48         umode_t mode;    /* mode of device node (unused, zero) */
  49 #else
  50         struct miscdevice dev; /* "misc" device structure */
  51 #endif
  52
  53 };
  54
  55 static int hmcdrv_dev_open(struct inode *inode, struct file *fp);
  56 static int hmcdrv_dev_release(struct inode *inode, struct file *fp);
  57 static loff_t hmcdrv_dev_seek(struct file *fp, loff_t pos, int whence);
  58 static ssize_t hmcdrv_dev_read(struct file *fp, char __user *ubuf,
  59                                size_t len, loff_t *pos);
  60 static ssize_t hmcdrv_dev_write(struct file *fp, const char __user *ubuf,
  61                                 size_t len, loff_t *pos);
  62 static ssize_t hmcdrv_dev_transfer(char __kernel *cmd, loff_t offset,
  63                                    char __user *buf, size_t len);
  64
  65 /*
  66  * device operations
  67  */
  68 static const struct file_operations hmcdrv_dev_fops = {
  69         .open = hmcdrv_dev_open,
  70         .llseek = hmcdrv_dev_seek,
  71         .release = hmcdrv_dev_release,
  72         .read = hmcdrv_dev_read,
  73         .write = hmcdrv_dev_write,
  74 };
  75
  76 static struct hmcdrv_dev_node hmcdrv_dev; /* HMC device struct (static) */
  77
  78 #ifdef HMCDRV_DEV_CLASS
  79
  80 static struct class *hmcdrv_dev_class; /* device class pointer */
  81 static dev_t hmcdrv_dev_no; /* device number (major/minor) */
  82
  83 /**
  84  * hmcdrv_dev_name() - provides a naming hint for a device node in /dev
  85  * @dev: device for which the naming/mode hint is
  86  * @mode: file mode for device node created in /dev
  87  *
  88  * See: devtmpfs.c, function devtmpfs_create_node()
  89  *
  90  * Return: recommended device file name in /dev
  91  */
  92 static char *hmcdrv_dev_name(struct device *dev, umode_t *mode)
  93 {
  94         char *nodename = NULL;
  95         const char *devname = dev_name(dev); /* kernel device name */
  96
  97         if (devname)
  98                 nodename = kasprintf(GFP_KERNEL, "%s", devname);
  99
 100         /* on device destroy (rmmod) the mode pointer may be NULL
 101          */
 102         if (mode)
 103                 *mode = hmcdrv_dev.mode;
 104
 105         return nodename;
 106 }
 107
 108 #endif  /* HMCDRV_DEV_CLASS */
 109
 110 /*
 111  * open()
 112  */
 113 static int hmcdrv_dev_open(struct inode *inode, struct file *fp)
 114 {
 115         int rc;
 116
 117         /* check for non-blocking access, which is really unsupported
 118          */
 119         if (fp->f_flags & O_NONBLOCK)
 120                 return -EINVAL;
 121
 122         /* Because it makes no sense to open this device read-only (then a
 123          * FTP command cannot be emitted), we respond with an error.
 124          */
 125         if ((fp->f_flags & O_ACCMODE) == O_RDONLY)
 126                 return -EINVAL;
 127
 128         /* prevent unloading this module as long as anyone holds the
 129          * device file open - so increment the reference count here
 130          */
 131         if (!try_module_get(THIS_MODULE))
 132                 return -ENODEV;
 133
 134         fp->private_data = NULL; /* no command yet */
 135         rc = hmcdrv_ftp_startup();
 136         if (rc)
 137                 module_put(THIS_MODULE);
 138
 139         pr_debug("open file '/dev/%pD' with return code %d\n", fp, rc);
 140         return rc;
 141 }
 142
 143 /*
 144  * release()
 145  */
 146 static int hmcdrv_dev_release(struct inode *inode, struct file *fp)
 147 {
 148         pr_debug("closing file '/dev/%pD'\n", fp);
 149         kfree(fp->private_data);
 150         fp->private_data = NULL;
 151         hmcdrv_ftp_shutdown();
 152         module_put(THIS_MODULE);
 153         return 0;
 154 }
 155
 156 /*
 157  * lseek()
 158  */
 159 static loff_t hmcdrv_dev_seek(struct file *fp, loff_t pos, int whence)
 160 {
 161         switch (whence) {
 162         case SEEK_CUR: /* relative to current file position */
 163                 pos += fp->f_pos; /* new position stored in 'pos' */
 164                 break;
 165
 166         case SEEK_SET: /* absolute (relative to beginning of file) */
 167                 break; /* SEEK_SET */
 168
 169                 /* We use SEEK_END as a special indicator for a SEEK_SET
 170                  * (set absolute position), combined with a FTP command
 171                  * clear.
 172                  */
 173         case SEEK_END:
 174                 if (fp->private_data) {
 175                         kfree(fp->private_data);
 176                         fp->private_data = NULL;
 177                 }
 178
 179                 break; /* SEEK_END */
 180
 181         default: /* SEEK_DATA, SEEK_HOLE: unsupported */
 182                 return -EINVAL;
 183         }
 184
 185         if (pos < 0)
 186                 return -EINVAL;
 187
 188         if (fp->f_pos != pos)
 189                 ++fp->f_version;
 190
 191         fp->f_pos = pos;
 192         return pos;
 193 }
 194
 195 /*
 196  * transfer (helper function)
 197  */
 198 static ssize_t hmcdrv_dev_transfer(char __kernel *cmd, loff_t offset,
 199                                    char __user *buf, size_t len)
 200 {
 201         ssize_t retlen;
 202         unsigned trials = HMCDRV_DEV_BUSY_RETRIES;
 203
 204         do {
 205                 retlen = hmcdrv_ftp_cmd(cmd, offset, buf, len);
 206
 207                 if (retlen != -EBUSY)
 208                         break;
 209
 210                 msleep(HMCDRV_DEV_BUSY_DELAY);
 211
 212         } while (--trials > 0);
 213
 214         return retlen;
 215 }
 216
 217 /*
 218  * read()
 219  */
 220 static ssize_t hmcdrv_dev_read(struct file *fp, char __user *ubuf,
 221                                size_t len, loff_t *pos)
 222 {
 223         ssize_t retlen;
 224
 225         if (((fp->f_flags & O_ACCMODE) == O_WRONLY) ||
 226             (fp->private_data == NULL)) { /* no FTP cmd defined ? */
 227                 return -EBADF;
 228         }
 229
 230         retlen = hmcdrv_dev_transfer((char *) fp->private_data,
 231                                      *pos, ubuf, len);
 232
 233         pr_debug("read from file '/dev/%pD' at %lld returns %zd/%zu\n",
 234                  fp, (long long) *pos, retlen, len);
 235
 236         if (retlen > 0)
 237                 *pos += retlen;
 238
 239         return retlen;
 240 }
 241
 242 /*
 243  * write()
 244  */
 245 static ssize_t hmcdrv_dev_write(struct file *fp, const char __user *ubuf,
 246                                 size_t len, loff_t *pos)
 247 {
 248         ssize_t retlen;
 249
 250         pr_debug("writing file '/dev/%pD' at pos. %lld with length %zd\n",
 251                  fp, (long long) *pos, len);
 252
 253         if (!fp->private_data) { /* first expect a cmd write */
 254                 fp->private_data = kmalloc(len + 1, GFP_KERNEL);
 255
 256                 if (!fp->private_data)
 257                         return -ENOMEM;
 258
 259                 if (!copy_from_user(fp->private_data, ubuf, len)) {
 260                         ((char *)fp->private_data)[len] = '\0';
 261                         return len;
 262                 }
 263
 264                 kfree(fp->private_data);
 265                 fp->private_data = NULL;
 266                 return -EFAULT;
 267         }
 268
 269         retlen = hmcdrv_dev_transfer((char *) fp->private_data,
 270                                      *pos, (char __user *) ubuf, len);
 271         if (retlen > 0)
 272                 *pos += retlen;
 273
 274         pr_debug("write to file '/dev/%pD' returned %zd\n", fp, retlen);
 275
 276         return retlen;
 277 }
 278
 279 /**
 280  * hmcdrv_dev_init() - creates a HMC drive CD/DVD device
 281  *
 282  * This function creates a HMC drive CD/DVD kernel device and an associated
 283  * device under /dev, using a dynamically allocated major number.
 284  *
 285  * Return: 0 on success, else an error code.
 286  */
 287 int hmcdrv_dev_init(void)
 288 {
 289         int rc;
 290
 291 #ifdef HMCDRV_DEV_CLASS
 292         struct device *dev;
 293
 294         rc = alloc_chrdev_region(&hmcdrv_dev_no, 0, 1, HMCDRV_DEV_NAME);
 295
 296         if (rc)
 297                 goto out_err;
 298
 299         cdev_init(&hmcdrv_dev.dev, &hmcdrv_dev_fops);
 300         hmcdrv_dev.dev.owner = THIS_MODULE;
 301         rc = cdev_add(&hmcdrv_dev.dev, hmcdrv_dev_no, 1);
 302
 303         if (rc)
 304                 goto out_unreg;
 305
 306         /* At this point the character device exists in the kernel (see
 307          * /proc/devices), but not under /dev nor /sys/devices/virtual. So
 308          * we have to create an associated class (see /sys/class).
 309          */
 310         hmcdrv_dev_class = class_create(THIS_MODULE, HMCDRV_DEV_CLASS);
 311
 312         if (IS_ERR(hmcdrv_dev_class)) {
 313                 rc = PTR_ERR(hmcdrv_dev_class);
 314                 goto out_devdel;
 315         }
 316
 317         /* Finally a device node in /dev has to be established (as 'mkdev'
 318          * does from the command line). Notice that assignment of a device
 319          * node name/mode function is optional (only for mode != 0600).
 320          */
 321         hmcdrv_dev.mode = 0; /* "unset" */
 322         hmcdrv_dev_class->devnode = hmcdrv_dev_name;
 323
 324         dev = device_create(hmcdrv_dev_class, NULL, hmcdrv_dev_no, NULL,
 325                             "%s", HMCDRV_DEV_NAME);
 326         if (!IS_ERR(dev))
 327                 return 0;
 328
 329         rc = PTR_ERR(dev);
 330         class_destroy(hmcdrv_dev_class);
 331         hmcdrv_dev_class = NULL;
 332
 333 out_devdel:
 334         cdev_del(&hmcdrv_dev.dev);
 335
 336 out_unreg:
 337         unregister_chrdev_region(hmcdrv_dev_no, 1);
 338
 339 out_err:
 340
 341 #else  /* !HMCDRV_DEV_CLASS */
 342         hmcdrv_dev.dev.minor = MISC_DYNAMIC_MINOR;
 343         hmcdrv_dev.dev.name = HMCDRV_DEV_NAME;
 344         hmcdrv_dev.dev.fops = &hmcdrv_dev_fops;
 345         hmcdrv_dev.dev.mode = 0; /* finally produces 0600 */
 346         rc = misc_register(&hmcdrv_dev.dev);
 347 #endif  /* HMCDRV_DEV_CLASS */
 348
 349         return rc;
 350 }
 351
 352 /**
 353  * hmcdrv_dev_exit() - destroys a HMC drive CD/DVD device
 354  */
 355 void hmcdrv_dev_exit(void)
 356 {
 357 #ifdef HMCDRV_DEV_CLASS
 358         if (!IS_ERR_OR_NULL(hmcdrv_dev_class)) {
 359                 device_destroy(hmcdrv_dev_class, hmcdrv_dev_no);
 360                 class_destroy(hmcdrv_dev_class);
 361         }
 362
 363         cdev_del(&hmcdrv_dev.dev);
 364         unregister_chrdev_region(hmcdrv_dev_no, 1);
 365 #else  /* !HMCDRV_DEV_CLASS */
 366         misc_deregister(&hmcdrv_dev.dev);
 367 #endif  /* HMCDRV_DEV_CLASS */
 368 }