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 } 369