1 /*
2  * This work is licensed under the terms of the GNU GPL, version 2 or
3  * (at your option) any later version.  See the COPYING file in the
4  * top-level directory.
5  */
6 
7 #include "qemu/osdep.h"
8 
9 #include <glib.h>
10 #include <linux/input.h>
11 
12 #include "qemu/iov.h"
13 #include "qemu/bswap.h"
14 #include "qemu/sockets.h"
15 #include "contrib/libvhost-user/libvhost-user.h"
16 #include "contrib/libvhost-user/libvhost-user-glib.h"
17 #include "standard-headers/linux/virtio_input.h"
18 #include "qapi/error.h"
19 
20 enum {
21     VHOST_USER_INPUT_MAX_QUEUES = 2,
22 };
23 
24 typedef struct virtio_input_event virtio_input_event;
25 typedef struct virtio_input_config virtio_input_config;
26 
27 typedef struct VuInput {
28     VugDev dev;
29     GSource *evsrc;
30     int evdevfd;
31     GArray *config;
32     virtio_input_config *sel_config;
33     struct {
34         virtio_input_event event;
35         VuVirtqElement *elem;
36     } *queue;
37     uint32_t qindex, qsize;
38 } VuInput;
39 
40 static void vi_input_send(VuInput *vi, struct virtio_input_event *event)
41 {
42     VuDev *dev = &vi->dev.parent;
43     VuVirtq *vq = vu_get_queue(dev, 0);
44     VuVirtqElement *elem;
45     int i, len;
46 
47     /* queue up events ... */
48     if (vi->qindex == vi->qsize) {
49         vi->qsize++;
50         vi->queue = g_realloc_n(vi->queue, vi->qsize, sizeof(vi->queue[0]));
51     }
52     vi->queue[vi->qindex++].event = *event;
53 
54     /* ... until we see a report sync ... */
55     if (event->type != htole16(EV_SYN) ||
56         event->code != htole16(SYN_REPORT)) {
57         return;
58     }
59 
60     /* ... then check available space ... */
61     for (i = 0; i < vi->qindex; i++) {
62         elem = vu_queue_pop(dev, vq, sizeof(VuVirtqElement));
63         if (!elem) {
64             while (--i >= 0) {
65                 vu_queue_unpop(dev, vq, vi->queue[i].elem, 0);
66             }
67             vi->qindex = 0;
68             g_warning("virtio-input queue full");
69             return;
70         }
71         vi->queue[i].elem = elem;
72     }
73 
74     /* ... and finally pass them to the guest */
75     for (i = 0; i < vi->qindex; i++) {
76         elem = vi->queue[i].elem;
77         len = iov_from_buf(elem->in_sg, elem->in_num,
78                            0, &vi->queue[i].event, sizeof(virtio_input_event));
79         vu_queue_push(dev, vq, elem, len);
80         free(elem);
81     }
82 
83     vu_queue_notify(&vi->dev.parent, vq);
84     vi->qindex = 0;
85 }
86 
87 static void
88 vi_evdev_watch(VuDev *dev, int condition, void *data)
89 {
90     VuInput *vi = data;
91     int fd = vi->evdevfd;
92 
93     g_debug("Got evdev condition %x", condition);
94 
95     struct virtio_input_event virtio;
96     struct input_event evdev;
97     int rc;
98 
99     for (;;) {
100         rc = read(fd, &evdev, sizeof(evdev));
101         if (rc != sizeof(evdev)) {
102             break;
103         }
104 
105         g_debug("input %d %d %d", evdev.type, evdev.code, evdev.value);
106 
107         virtio.type  = htole16(evdev.type);
108         virtio.code  = htole16(evdev.code);
109         virtio.value = htole32(evdev.value);
110         vi_input_send(vi, &virtio);
111     }
112 }
113 
114 
115 static void vi_handle_status(VuInput *vi, virtio_input_event *event)
116 {
117     struct input_event evdev;
118     int rc;
119 
120     if (gettimeofday(&evdev.time, NULL)) {
121         perror("vi_handle_status: gettimeofday");
122         return;
123     }
124 
125     evdev.type = le16toh(event->type);
126     evdev.code = le16toh(event->code);
127     evdev.value = le32toh(event->value);
128 
129     rc = write(vi->evdevfd, &evdev, sizeof(evdev));
130     if (rc == -1) {
131         perror("vi_host_handle_status: write");
132     }
133 }
134 
135 static void vi_handle_sts(VuDev *dev, int qidx)
136 {
137     VuInput *vi = container_of(dev, VuInput, dev.parent);
138     VuVirtq *vq = vu_get_queue(dev, qidx);
139     virtio_input_event event;
140     VuVirtqElement *elem;
141     int len;
142 
143     g_debug("%s", G_STRFUNC);
144 
145     for (;;) {
146         elem = vu_queue_pop(dev, vq, sizeof(VuVirtqElement));
147         if (!elem) {
148             break;
149         }
150 
151         memset(&event, 0, sizeof(event));
152         len = iov_to_buf(elem->out_sg, elem->out_num,
153                          0, &event, sizeof(event));
154         vi_handle_status(vi, &event);
155         vu_queue_push(dev, vq, elem, len);
156         free(elem);
157     }
158 
159     vu_queue_notify(&vi->dev.parent, vq);
160 }
161 
162 static void
163 vi_panic(VuDev *dev, const char *msg)
164 {
165     g_critical("%s\n", msg);
166     exit(EXIT_FAILURE);
167 }
168 
169 static void
170 vi_queue_set_started(VuDev *dev, int qidx, bool started)
171 {
172     VuInput *vi = container_of(dev, VuInput, dev.parent);
173     VuVirtq *vq = vu_get_queue(dev, qidx);
174 
175     g_debug("queue started %d:%d", qidx, started);
176 
177     if (qidx == 1) {
178         vu_set_queue_handler(dev, vq, started ? vi_handle_sts : NULL);
179     }
180 
181     started = vu_queue_started(dev, vu_get_queue(dev, 0)) &&
182         vu_queue_started(dev, vu_get_queue(dev, 1));
183 
184     if (started && !vi->evsrc) {
185         vi->evsrc = vug_source_new(&vi->dev, vi->evdevfd,
186                                    G_IO_IN, vi_evdev_watch, vi);
187     }
188 
189     if (!started && vi->evsrc) {
190         g_source_destroy(vi->evsrc);
191         vi->evsrc = NULL;
192     }
193 }
194 
195 static virtio_input_config *
196 vi_find_config(VuInput *vi, uint8_t select, uint8_t subsel)
197 {
198     virtio_input_config *cfg;
199     int i;
200 
201     for (i = 0; i < vi->config->len; i++) {
202         cfg = &g_array_index(vi->config, virtio_input_config, i);
203         if (select == cfg->select && subsel == cfg->subsel) {
204             return cfg;
205         }
206     }
207 
208     return NULL;
209 }
210 
211 static int vi_get_config(VuDev *dev, uint8_t *config, uint32_t len)
212 {
213     VuInput *vi = container_of(dev, VuInput, dev.parent);
214 
215     g_return_val_if_fail(len <= sizeof(*vi->sel_config), -1);
216 
217     if (vi->sel_config) {
218         memcpy(config, vi->sel_config, len);
219     } else {
220         memset(config, 0, len);
221     }
222 
223     return 0;
224 }
225 
226 static int vi_set_config(VuDev *dev, const uint8_t *data,
227                          uint32_t offset, uint32_t size,
228                          uint32_t flags)
229 {
230     VuInput *vi = container_of(dev, VuInput, dev.parent);
231     virtio_input_config *config = (virtio_input_config *)data;
232 
233     vi->sel_config = vi_find_config(vi, config->select, config->subsel);
234 
235     return 0;
236 }
237 
238 static const VuDevIface vuiface = {
239     .queue_set_started = vi_queue_set_started,
240     .get_config = vi_get_config,
241     .set_config = vi_set_config,
242 };
243 
244 static void
245 vi_bits_config(VuInput *vi, int type, int count)
246 {
247     virtio_input_config bits;
248     int rc, i, size = 0;
249 
250     memset(&bits, 0, sizeof(bits));
251     rc = ioctl(vi->evdevfd, EVIOCGBIT(type, count / 8), bits.u.bitmap);
252     if (rc < 0) {
253         return;
254     }
255 
256     for (i = 0; i < count / 8; i++) {
257         if (bits.u.bitmap[i]) {
258             size = i + 1;
259         }
260     }
261     if (size == 0) {
262         return;
263     }
264 
265     bits.select = VIRTIO_INPUT_CFG_EV_BITS;
266     bits.subsel = type;
267     bits.size   = size;
268     g_array_append_val(vi->config, bits);
269 }
270 
271 static char *opt_evdev;
272 static int opt_fdnum = -1;
273 static char *opt_socket_path;
274 static gboolean opt_nograb;
275 static gboolean opt_print_caps;
276 
277 static GOptionEntry entries[] = {
278     { "print-capabilities", 'c', 0, G_OPTION_ARG_NONE, &opt_print_caps,
279       "Print capabilities", NULL },
280     { "no-grab", 'n', 0, G_OPTION_ARG_NONE, &opt_nograb,
281       "Don't grab device", NULL },
282     { "fd", 'f', 0, G_OPTION_ARG_INT, &opt_fdnum,
283       "Use inherited fd socket", "FDNUM" },
284     { "socket-path", 's', 0, G_OPTION_ARG_FILENAME, &opt_socket_path,
285       "Use UNIX socket path", "PATH" },
286     { "evdev-path", 'p', 0, G_OPTION_ARG_FILENAME, &opt_evdev,
287       "evdev input device path", "PATH" },
288     { NULL, }
289 };
290 
291 int
292 main(int argc, char *argv[])
293 {
294     GMainLoop *loop = NULL;
295     VuInput vi = { 0, };
296     int rc, ver, fd;
297     virtio_input_config id;
298     struct input_id ids;
299     GError *error = NULL;
300     GOptionContext *context;
301 
302     context = g_option_context_new(NULL);
303     g_option_context_add_main_entries(context, entries, NULL);
304     if (!g_option_context_parse(context, &argc, &argv, &error)) {
305         g_printerr("Option parsing failed: %s\n", error->message);
306         exit(EXIT_FAILURE);
307     }
308     if (opt_print_caps) {
309         g_print("{\n");
310         g_print("  \"type\": \"input\",\n");
311         g_print("  \"features\": [\n");
312         g_print("    \"evdev-path\",\n");
313         g_print("    \"no-grab\"\n");
314         g_print("  ]\n");
315         g_print("}\n");
316         exit(EXIT_SUCCESS);
317     }
318     if (!opt_evdev) {
319         g_printerr("Please specify an evdev path\n");
320         exit(EXIT_FAILURE);
321     }
322     if ((!!opt_socket_path + (opt_fdnum != -1)) != 1) {
323         g_printerr("Please specify either --fd or --socket-path\n");
324         exit(EXIT_FAILURE);
325     }
326 
327     vi.evdevfd = open(opt_evdev, O_RDWR);
328     if (vi.evdevfd < 0) {
329         g_printerr("Failed to open evdev: %s\n", g_strerror(errno));
330         exit(EXIT_FAILURE);
331     }
332 
333     rc = ioctl(vi.evdevfd, EVIOCGVERSION, &ver);
334     if (rc < 0) {
335         g_printerr("%s: is not an evdev device\n", argv[1]);
336         exit(EXIT_FAILURE);
337     }
338 
339     if (!opt_nograb) {
340         rc = ioctl(vi.evdevfd, EVIOCGRAB, 1);
341         if (rc < 0) {
342             g_printerr("Failed to grab device\n");
343             exit(EXIT_FAILURE);
344         }
345     }
346 
347     vi.config = g_array_new(false, false, sizeof(virtio_input_config));
348     memset(&id, 0, sizeof(id));
349     if (ioctl(vi.evdevfd, EVIOCGNAME(sizeof(id.u.string) - 1),
350               id.u.string) < 0) {
351         g_printerr("Failed to get evdev name: %s\n", g_strerror(errno));
352         exit(EXIT_FAILURE);
353     }
354     id.select = VIRTIO_INPUT_CFG_ID_NAME;
355     id.size = strlen(id.u.string);
356     g_array_append_val(vi.config, id);
357 
358     if (ioctl(vi.evdevfd, EVIOCGID, &ids) == 0) {
359         memset(&id, 0, sizeof(id));
360         id.select = VIRTIO_INPUT_CFG_ID_DEVIDS;
361         id.size = sizeof(struct virtio_input_devids);
362         id.u.ids.bustype = cpu_to_le16(ids.bustype);
363         id.u.ids.vendor  = cpu_to_le16(ids.vendor);
364         id.u.ids.product = cpu_to_le16(ids.product);
365         id.u.ids.version = cpu_to_le16(ids.version);
366         g_array_append_val(vi.config, id);
367     }
368 
369     vi_bits_config(&vi, EV_KEY, KEY_CNT);
370     vi_bits_config(&vi, EV_REL, REL_CNT);
371     vi_bits_config(&vi, EV_ABS, ABS_CNT);
372     vi_bits_config(&vi, EV_MSC, MSC_CNT);
373     vi_bits_config(&vi, EV_SW,  SW_CNT);
374     g_debug("config length: %u", vi.config->len);
375 
376     if (opt_socket_path) {
377         int lsock = unix_listen(opt_socket_path, &error_fatal);
378         if (lsock < 0) {
379             g_printerr("Failed to listen on %s.\n", opt_socket_path);
380             exit(EXIT_FAILURE);
381         }
382         fd = accept(lsock, NULL, NULL);
383         close(lsock);
384     } else {
385         fd = opt_fdnum;
386     }
387     if (fd == -1) {
388         g_printerr("Invalid vhost-user socket.\n");
389         exit(EXIT_FAILURE);
390     }
391 
392     if (!vug_init(&vi.dev, VHOST_USER_INPUT_MAX_QUEUES, fd, vi_panic,
393                   &vuiface)) {
394         g_printerr("Failed to initialize libvhost-user-glib.\n");
395         exit(EXIT_FAILURE);
396     }
397 
398     loop = g_main_loop_new(NULL, FALSE);
399     g_main_loop_run(loop);
400     g_main_loop_unref(loop);
401 
402     vug_deinit(&vi.dev);
403 
404     if (vi.evsrc) {
405         g_source_unref(vi.evsrc);
406     }
407     g_array_free(vi.config, TRUE);
408     g_free(vi.queue);
409     return 0;
410 }
411