1 /* 2 * userio kernel serio device emulation module 3 * Copyright (C) 2015 Red Hat 4 * Copyright (C) 2015 Lyude Paul <thatslyude@gmail.com> 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 33 static struct miscdevice userio_misc; 34 35 struct 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 */ 55 static 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 73 static 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 96 static 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 115 static 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 134 static 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, ©len); 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 178 static 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 256 static 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 280 static __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 292 static 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 301 static struct miscdevice userio_misc = { 302 .fops = &userio_fops, 303 .minor = USERIO_MINOR, 304 .name = USERIO_NAME, 305 }; 306 module_driver(userio_misc, misc_register, misc_deregister); 307 308 MODULE_ALIAS_MISCDEV(USERIO_MINOR); 309 MODULE_ALIAS("devname:" USERIO_NAME); 310 311 MODULE_AUTHOR("Lyude Paul <thatslyude@gmail.com>"); 312 MODULE_DESCRIPTION("Virtual Serio Device Support"); 313 MODULE_LICENSE("GPL"); 314