projects/linux·blob master · refs

313 lines · 7.2 KiB

1/*
2 * userio kernel serio device emulation module
3 * Copyright (C) 2015 Red Hat
4 * Copyright (C) 2015 Lyude Paul <[email protected]>
5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU Lesser General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or (at
9 * your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser
14 * General Public License for more details.
15 */
16
17#include <linux/circ_buf.h>
18#include <linux/mutex.h>
19#include <linux/module.h>
20#include <linux/init.h>
21#include <linux/kernel.h>
22#include <linux/serio.h>
23#include <linux/slab.h>
24#include <linux/fs.h>
25#include <linux/miscdevice.h>
26#include <linux/sched.h>
27#include <linux/poll.h>
28#include <uapi/linux/userio.h>
29
30#define USERIO_NAME "userio"
31#define USERIO_BUFSIZE 16
32
33static struct miscdevice userio_misc;
34
35struct userio_device {
36 struct serio *serio;
37 struct mutex mutex;
38
39 bool running;
40
41 u8 head;
42 u8 tail;
43
44 spinlock_t buf_lock;
45 unsigned char buf[USERIO_BUFSIZE];
46
47 wait_queue_head_t waitq;
48};
49
50/**
51 * userio_device_write - Write data from serio to a userio device in userspace
52 * @id: The serio port for the userio device
53 * @val: The data to write to the device
54 */
55static int userio_device_write(struct serio *id, unsigned char val)
56{
57 struct userio_device *userio = id->port_data;
58
59 scoped_guard(spinlock_irqsave, &userio->buf_lock) {
60 userio->buf[userio->head] = val;
61 userio->head = (userio->head + 1) % USERIO_BUFSIZE;
62
63 if (userio->head == userio->tail)
64 dev_warn(userio_misc.this_device,
65 "Buffer overflowed, userio client isn't keeping up");
66 }
67
68 wake_up_interruptible(&userio->waitq);
69
70 return 0;
71}
72
73static int userio_char_open(struct inode *inode, struct file *file)
74{
75 struct userio_device *userio __free(kfree) =
76 kzalloc_obj(*userio);
77 if (!userio)
78 return -ENOMEM;
79
80 mutex_init(&userio->mutex);
81 spin_lock_init(&userio->buf_lock);
82 init_waitqueue_head(&userio->waitq);
83
84 userio->serio = kzalloc_obj(*userio->serio);
85 if (!userio->serio)
86 return -ENOMEM;
87
88 userio->serio->write = userio_device_write;
89 userio->serio->port_data = userio;
90
91 file->private_data = no_free_ptr(userio);
92
93 return 0;
94}
95
96static int userio_char_release(struct inode *inode, struct file *file)
97{
98 struct userio_device *userio = file->private_data;
99
100 if (userio->running) {
101 /*
102 * Don't free the serio port here, serio_unregister_port()
103 * does it for us.
104 */
105 serio_unregister_port(userio->serio);
106 } else {
107 kfree(userio->serio);
108 }
109
110 kfree(userio);
111
112 return 0;
113}
114
115static size_t userio_fetch_data(struct userio_device *userio, u8 *buf,
116 size_t count, size_t *copylen)
117{
118 size_t available, len;
119
120 guard(spinlock_irqsave)(&userio->buf_lock);
121
122 available = CIRC_CNT_TO_END(userio->head, userio->tail,
123 USERIO_BUFSIZE);
124 len = min(available, count);
125 if (len) {
126 memcpy(buf, &userio->buf[userio->tail], len);
127 userio->tail = (userio->tail + len) % USERIO_BUFSIZE;
128 }
129
130 *copylen = len;
131 return available;
132}
133
134static ssize_t userio_char_read(struct file *file, char __user *user_buffer,
135 size_t count, loff_t *ppos)
136{
137 struct userio_device *userio = file->private_data;
138 int error;
139 size_t available, copylen;
140 u8 buf[USERIO_BUFSIZE];
141
142 /*
143 * By the time we get here, the data that was waiting might have
144 * been taken by another thread. Grab the buffer lock and check if
145 * there's still any data waiting, otherwise repeat this process
146 * until we have data (unless the file descriptor is non-blocking
147 * of course).
148 */
149 for (;;) {
150 available = userio_fetch_data(userio, buf, count, &copylen);
151 if (available)
152 break;
153
154 /* buffer was/is empty */
155 if (file->f_flags & O_NONBLOCK)
156 return -EAGAIN;
157
158 /*
159 * count == 0 is special - no IO is done but we check
160 * for error conditions (see above).
161 */
162 if (count == 0)
163 return 0;
164
165 error = wait_event_interruptible(userio->waitq,
166 userio->head != userio->tail);
167 if (error)
168 return error;
169 }
170
171 if (copylen)
172 if (copy_to_user(user_buffer, buf, copylen))
173 return -EFAULT;
174
175 return copylen;
176}
177
178static int userio_execute_cmd(struct userio_device *userio,
179 const struct userio_cmd *cmd)
180{
181 switch (cmd->type) {
182 case USERIO_CMD_REGISTER:
183 if (!userio->serio->id.type) {
184 dev_warn(userio_misc.this_device,
185 "No port type given on /dev/userio\n");
186 return -EINVAL;
187 }
188
189 if (userio->running) {
190 dev_warn(userio_misc.this_device,
191 "Begin command sent, but we're already running\n");
192 return -EBUSY;
193 }
194
195 userio->running = true;
196 serio_register_port(userio->serio);
197 break;
198
199 case USERIO_CMD_SET_PORT_TYPE:
200 if (userio->running) {
201 dev_warn(userio_misc.this_device,
202 "Can't change port type on an already running userio instance\n");
203 return -EBUSY;
204 }
205
206 userio->serio->id.type = cmd->data;
207 break;
208
209 case USERIO_CMD_SET_PORT_EXTRA:
210 if (userio->running) {
211 dev_warn(userio_misc.this_device,
212 "Can't change port extra on an already running userio instance\n");
213 return -EBUSY;
214 }
215
216 userio->serio->id.extra = cmd->data;
217 break;
218
219 case USERIO_CMD_SET_PORT_ID:
220 if (userio->running) {
221 dev_warn(userio_misc.this_device,
222 "Can't change port id on an already running userio instance\n");
223 return -EBUSY;
224 }
225
226 userio->serio->id.id = cmd->data;
227 break;
228
229 case USERIO_CMD_SET_PORT_PROTO:
230 if (userio->running) {
231 dev_warn(userio_misc.this_device,
232 "Can't change port proto on an already running userio instance\n");
233 return -EBUSY;
234 }
235
236 userio->serio->id.proto = cmd->data;
237 break;
238
239 case USERIO_CMD_SEND_INTERRUPT:
240 if (!userio->running) {
241 dev_warn(userio_misc.this_device,
242 "The device must be registered before sending interrupts\n");
243 return -ENODEV;
244 }
245
246 serio_interrupt(userio->serio, cmd->data, 0);
247 break;
248
249 default:
250 return -EOPNOTSUPP;
251 }
252
253 return 0;
254}
255
256static ssize_t userio_char_write(struct file *file, const char __user *buffer,
257 size_t count, loff_t *ppos)
258{
259 struct userio_device *userio = file->private_data;
260 struct userio_cmd cmd;
261 int error;
262
263 if (count != sizeof(cmd)) {
264 dev_warn(userio_misc.this_device, "Invalid payload size\n");
265 return -EINVAL;
266 }
267
268 if (copy_from_user(&cmd, buffer, sizeof(cmd)))
269 return -EFAULT;
270
271 scoped_cond_guard(mutex_intr, return -EINTR, &userio->mutex) {
272 error = userio_execute_cmd(userio, &cmd);
273 if (error)
274 return error;
275 }
276
277 return count;
278}
279
280static __poll_t userio_char_poll(struct file *file, poll_table *wait)
281{
282 struct userio_device *userio = file->private_data;
283
284 poll_wait(file, &userio->waitq, wait);
285
286 if (userio->head != userio->tail)
287 return EPOLLIN | EPOLLRDNORM;
288
289 return 0;
290}
291
292static const struct file_operations userio_fops = {
293 .owner = THIS_MODULE,
294 .open = userio_char_open,
295 .release = userio_char_release,
296 .read = userio_char_read,
297 .write = userio_char_write,
298 .poll = userio_char_poll,
299};
300
301static struct miscdevice userio_misc = {
302 .fops = &userio_fops,
303 .minor = USERIO_MINOR,
304 .name = USERIO_NAME,
305};
306module_driver(userio_misc, misc_register, misc_deregister);
307
308MODULE_ALIAS_MISCDEV(USERIO_MINOR);
309MODULE_ALIAS("devname:" USERIO_NAME);
310
311MODULE_AUTHOR("Lyude Paul <[email protected]>");
312MODULE_DESCRIPTION("Virtual Serio Device Support");
313MODULE_LICENSE("GPL");