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