Commit | Line | Data |
---|---|---|
b2441318 | 1 | // SPDX-License-Identifier: GPL-2.0 |
8f933b10 RH |
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 | */ | |
93 | static char *hmcdrv_dev_name(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 | */ | |
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 | ||
a455589f | 140 | pr_debug("open file '/dev/%pD' with return code %d\n", fp, rc); |
8f933b10 RH |
141 | return rc; |
142 | } | |
143 | ||
144 | /* | |
145 | * release() | |
146 | */ | |
147 | static int hmcdrv_dev_release(struct inode *inode, struct file *fp) | |
148 | { | |
a455589f | 149 | pr_debug("closing file '/dev/%pD'\n", fp); |
8f933b10 RH |
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 | */ | |
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 | if (fp->f_pos != pos) | |
190 | ++fp->f_version; | |
191 | ||
192 | fp->f_pos = pos; | |
193 | return pos; | |
194 | } | |
195 | ||
196 | /* | |
197 | * transfer (helper function) | |
198 | */ | |
199 | static ssize_t hmcdrv_dev_transfer(char __kernel *cmd, loff_t offset, | |
200 | char __user *buf, size_t len) | |
201 | { | |
202 | ssize_t retlen; | |
203 | unsigned trials = HMCDRV_DEV_BUSY_RETRIES; | |
204 | ||
205 | do { | |
206 | retlen = hmcdrv_ftp_cmd(cmd, offset, buf, len); | |
207 | ||
208 | if (retlen != -EBUSY) | |
209 | break; | |
210 | ||
211 | msleep(HMCDRV_DEV_BUSY_DELAY); | |
212 | ||
213 | } while (--trials > 0); | |
214 | ||
215 | return retlen; | |
216 | } | |
217 | ||
218 | /* | |
219 | * read() | |
220 | */ | |
221 | static ssize_t hmcdrv_dev_read(struct file *fp, char __user *ubuf, | |
222 | size_t len, loff_t *pos) | |
223 | { | |
224 | ssize_t retlen; | |
225 | ||
226 | if (((fp->f_flags & O_ACCMODE) == O_WRONLY) || | |
227 | (fp->private_data == NULL)) { /* no FTP cmd defined ? */ | |
228 | return -EBADF; | |
229 | } | |
230 | ||
231 | retlen = hmcdrv_dev_transfer((char *) fp->private_data, | |
232 | *pos, ubuf, len); | |
233 | ||
a455589f AV |
234 | pr_debug("read from file '/dev/%pD' at %lld returns %zd/%zu\n", |
235 | fp, (long long) *pos, retlen, len); | |
8f933b10 RH |
236 | |
237 | if (retlen > 0) | |
238 | *pos += retlen; | |
239 | ||
240 | return retlen; | |
241 | } | |
242 | ||
243 | /* | |
244 | * write() | |
245 | */ | |
246 | static ssize_t hmcdrv_dev_write(struct file *fp, const char __user *ubuf, | |
247 | size_t len, loff_t *pos) | |
248 | { | |
249 | ssize_t retlen; | |
250 | ||
a455589f AV |
251 | pr_debug("writing file '/dev/%pD' at pos. %lld with length %zd\n", |
252 | fp, (long long) *pos, len); | |
8f933b10 RH |
253 | |
254 | if (!fp->private_data) { /* first expect a cmd write */ | |
255 | fp->private_data = kmalloc(len + 1, GFP_KERNEL); | |
256 | ||
257 | if (!fp->private_data) | |
258 | return -ENOMEM; | |
259 | ||
260 | if (!copy_from_user(fp->private_data, ubuf, len)) { | |
261 | ((char *)fp->private_data)[len] = '\0'; | |
262 | return len; | |
263 | } | |
264 | ||
265 | kfree(fp->private_data); | |
266 | fp->private_data = NULL; | |
267 | return -EFAULT; | |
268 | } | |
269 | ||
270 | retlen = hmcdrv_dev_transfer((char *) fp->private_data, | |
271 | *pos, (char __user *) ubuf, len); | |
272 | if (retlen > 0) | |
273 | *pos += retlen; | |
274 | ||
a455589f | 275 | pr_debug("write to file '/dev/%pD' returned %zd\n", fp, retlen); |
8f933b10 RH |
276 | |
277 | return retlen; | |
278 | } | |
279 | ||
280 | /** | |
281 | * hmcdrv_dev_init() - creates a HMC drive CD/DVD device | |
282 | * | |
283 | * This function creates a HMC drive CD/DVD kernel device and an associated | |
284 | * device under /dev, using a dynamically allocated major number. | |
285 | * | |
286 | * Return: 0 on success, else an error code. | |
287 | */ | |
288 | int hmcdrv_dev_init(void) | |
289 | { | |
290 | int rc; | |
291 | ||
292 | #ifdef HMCDRV_DEV_CLASS | |
293 | struct device *dev; | |
294 | ||
295 | rc = alloc_chrdev_region(&hmcdrv_dev_no, 0, 1, HMCDRV_DEV_NAME); | |
296 | ||
297 | if (rc) | |
298 | goto out_err; | |
299 | ||
300 | cdev_init(&hmcdrv_dev.dev, &hmcdrv_dev_fops); | |
301 | hmcdrv_dev.dev.owner = THIS_MODULE; | |
302 | rc = cdev_add(&hmcdrv_dev.dev, hmcdrv_dev_no, 1); | |
303 | ||
304 | if (rc) | |
305 | goto out_unreg; | |
306 | ||
307 | /* At this point the character device exists in the kernel (see | |
308 | * /proc/devices), but not under /dev nor /sys/devices/virtual. So | |
309 | * we have to create an associated class (see /sys/class). | |
310 | */ | |
311 | hmcdrv_dev_class = class_create(THIS_MODULE, HMCDRV_DEV_CLASS); | |
312 | ||
313 | if (IS_ERR(hmcdrv_dev_class)) { | |
314 | rc = PTR_ERR(hmcdrv_dev_class); | |
315 | goto out_devdel; | |
316 | } | |
317 | ||
318 | /* Finally a device node in /dev has to be established (as 'mkdev' | |
319 | * does from the command line). Notice that assignment of a device | |
320 | * node name/mode function is optional (only for mode != 0600). | |
321 | */ | |
322 | hmcdrv_dev.mode = 0; /* "unset" */ | |
323 | hmcdrv_dev_class->devnode = hmcdrv_dev_name; | |
324 | ||
325 | dev = device_create(hmcdrv_dev_class, NULL, hmcdrv_dev_no, NULL, | |
326 | "%s", HMCDRV_DEV_NAME); | |
327 | if (!IS_ERR(dev)) | |
328 | return 0; | |
329 | ||
330 | rc = PTR_ERR(dev); | |
331 | class_destroy(hmcdrv_dev_class); | |
332 | hmcdrv_dev_class = NULL; | |
333 | ||
334 | out_devdel: | |
335 | cdev_del(&hmcdrv_dev.dev); | |
336 | ||
337 | out_unreg: | |
338 | unregister_chrdev_region(hmcdrv_dev_no, 1); | |
339 | ||
340 | out_err: | |
341 | ||
342 | #else /* !HMCDRV_DEV_CLASS */ | |
343 | hmcdrv_dev.dev.minor = MISC_DYNAMIC_MINOR; | |
344 | hmcdrv_dev.dev.name = HMCDRV_DEV_NAME; | |
345 | hmcdrv_dev.dev.fops = &hmcdrv_dev_fops; | |
346 | hmcdrv_dev.dev.mode = 0; /* finally produces 0600 */ | |
347 | rc = misc_register(&hmcdrv_dev.dev); | |
348 | #endif /* HMCDRV_DEV_CLASS */ | |
349 | ||
350 | return rc; | |
351 | } | |
352 | ||
353 | /** | |
354 | * hmcdrv_dev_exit() - destroys a HMC drive CD/DVD device | |
355 | */ | |
356 | void hmcdrv_dev_exit(void) | |
357 | { | |
358 | #ifdef HMCDRV_DEV_CLASS | |
359 | if (!IS_ERR_OR_NULL(hmcdrv_dev_class)) { | |
360 | device_destroy(hmcdrv_dev_class, hmcdrv_dev_no); | |
361 | class_destroy(hmcdrv_dev_class); | |
362 | } | |
363 | ||
364 | cdev_del(&hmcdrv_dev.dev); | |
365 | unregister_chrdev_region(hmcdrv_dev_no, 1); | |
366 | #else /* !HMCDRV_DEV_CLASS */ | |
367 | misc_deregister(&hmcdrv_dev.dev); | |
368 | #endif /* HMCDRV_DEV_CLASS */ | |
369 | } |