1 /*-
2 * Copyright (c) 2014, Bryan Venteicher <[email protected]>
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice unmodified, this list of conditions, and the following
10 * disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 */
26
27 /* Driver for VirtIO console devices. */
28
29 #include <sys/cdefs.h>
30 __FBSDID("$FreeBSD$");
31
32 #include <sys/param.h>
33 #include <sys/ctype.h>
34 #include <sys/systm.h>
35 #include <sys/kernel.h>
36 #include <sys/malloc.h>
37 #include <sys/module.h>
38 #include <sys/kdb.h>
39 #include <sys/lock.h>
40 #include <sys/mutex.h>
41 #include <sys/sglist.h>
42 #include <sys/sysctl.h>
43 #include <sys/taskqueue.h>
44 #include <sys/queue.h>
45
46 #include <sys/conf.h>
47 #include <sys/cons.h>
48 #include <sys/tty.h>
49
50 #include <machine/bus.h>
51 #include <machine/resource.h>
52 #include <sys/bus.h>
53
54 #include <dev/virtio/virtio.h>
55 #include <dev/virtio/virtqueue.h>
56 #include <dev/virtio/console/virtio_console.h>
57
58 #include "virtio_if.h"
59
60 #define VTCON_MAX_PORTS 32
61 #define VTCON_TTY_PREFIX "V"
62 #define VTCON_TTY_ALIAS_PREFIX "vtcon"
63 #define VTCON_BULK_BUFSZ 128
64 #define VTCON_CTRL_BUFSZ 128
65
66 /*
67 * The buffers cannot cross more than one page boundary due to the
68 * size of the sglist segment array used.
69 */
70 CTASSERT(VTCON_BULK_BUFSZ <= PAGE_SIZE);
71 CTASSERT(VTCON_CTRL_BUFSZ <= PAGE_SIZE);
72
73 CTASSERT(sizeof(struct virtio_console_config) <= VTCON_CTRL_BUFSZ);
74
75 struct vtcon_softc;
76 struct vtcon_softc_port;
77
78 struct vtcon_port {
79 struct mtx vtcport_mtx;
80 struct vtcon_softc *vtcport_sc;
81 struct vtcon_softc_port *vtcport_scport;
82 struct tty *vtcport_tty;
83 struct virtqueue *vtcport_invq;
84 struct virtqueue *vtcport_outvq;
85 int vtcport_id;
86 int vtcport_flags;
87 #define VTCON_PORT_FLAG_GONE 0x01
88 #define VTCON_PORT_FLAG_CONSOLE 0x02
89 #define VTCON_PORT_FLAG_ALIAS 0x04
90
91 #if defined(KDB)
92 int vtcport_alt_break_state;
93 #endif
94 };
95
96 #define VTCON_PORT_LOCK(_port) mtx_lock(&(_port)->vtcport_mtx)
97 #define VTCON_PORT_UNLOCK(_port) mtx_unlock(&(_port)->vtcport_mtx)
98
99 struct vtcon_softc_port {
100 struct vtcon_softc *vcsp_sc;
101 struct vtcon_port *vcsp_port;
102 struct virtqueue *vcsp_invq;
103 struct virtqueue *vcsp_outvq;
104 };
105
106 struct vtcon_softc {
107 device_t vtcon_dev;
108 struct mtx vtcon_mtx;
109 uint64_t vtcon_features;
110 uint32_t vtcon_max_ports;
111 uint32_t vtcon_flags;
112 #define VTCON_FLAG_DETACHED 0x01
113 #define VTCON_FLAG_SIZE 0x02
114 #define VTCON_FLAG_MULTIPORT 0x04
115
116 /*
117 * Ports can be added and removed during runtime, but we have
118 * to allocate all the virtqueues during attach. This array is
119 * indexed by the port ID.
120 */
121 struct vtcon_softc_port *vtcon_ports;
122
123 struct task vtcon_ctrl_task;
124 struct virtqueue *vtcon_ctrl_rxvq;
125 struct virtqueue *vtcon_ctrl_txvq;
126 struct mtx vtcon_ctrl_tx_mtx;
127 };
128
129 #define VTCON_LOCK(_sc) mtx_lock(&(_sc)->vtcon_mtx)
130 #define VTCON_UNLOCK(_sc) mtx_unlock(&(_sc)->vtcon_mtx)
131 #define VTCON_LOCK_ASSERT(_sc) \
132 mtx_assert(&(_sc)->vtcon_mtx, MA_OWNED)
133 #define VTCON_LOCK_ASSERT_NOTOWNED(_sc) \
134 mtx_assert(&(_sc)->vtcon_mtx, MA_NOTOWNED)
135
136 #define VTCON_CTRL_TX_LOCK(_sc) mtx_lock(&(_sc)->vtcon_ctrl_tx_mtx)
137 #define VTCON_CTRL_TX_UNLOCK(_sc) mtx_unlock(&(_sc)->vtcon_ctrl_tx_mtx)
138
139 #define VTCON_ASSERT_VALID_PORTID(_sc, _id) \
140 KASSERT((_id) >= 0 && (_id) < (_sc)->vtcon_max_ports, \
141 ("%s: port ID %d out of range", __func__, _id))
142
143 #define VTCON_FEATURES VIRTIO_CONSOLE_F_MULTIPORT
144
145 static struct virtio_feature_desc vtcon_feature_desc[] = {
146 { VIRTIO_CONSOLE_F_SIZE, "ConsoleSize" },
147 { VIRTIO_CONSOLE_F_MULTIPORT, "MultiplePorts" },
148 { VIRTIO_CONSOLE_F_EMERG_WRITE, "EmergencyWrite" },
149
150 { 0, NULL }
151 };
152
153 static int vtcon_modevent(module_t, int, void *);
154 static void vtcon_drain_all(void);
155
156 static int vtcon_probe(device_t);
157 static int vtcon_attach(device_t);
158 static int vtcon_detach(device_t);
159 static int vtcon_config_change(device_t);
160
161 static void vtcon_setup_features(struct vtcon_softc *);
162 static void vtcon_negotiate_features(struct vtcon_softc *);
163 static int vtcon_alloc_scports(struct vtcon_softc *);
164 static int vtcon_alloc_virtqueues(struct vtcon_softc *);
165 static void vtcon_read_config(struct vtcon_softc *,
166 struct virtio_console_config *);
167
168 static void vtcon_determine_max_ports(struct vtcon_softc *,
169 struct virtio_console_config *);
170 static void vtcon_destroy_ports(struct vtcon_softc *);
171 static void vtcon_stop(struct vtcon_softc *);
172
173 static int vtcon_ctrl_event_enqueue(struct vtcon_softc *,
174 struct virtio_console_control *);
175 static int vtcon_ctrl_event_create(struct vtcon_softc *);
176 static void vtcon_ctrl_event_requeue(struct vtcon_softc *,
177 struct virtio_console_control *);
178 static int vtcon_ctrl_event_populate(struct vtcon_softc *);
179 static void vtcon_ctrl_event_drain(struct vtcon_softc *);
180 static int vtcon_ctrl_init(struct vtcon_softc *);
181 static void vtcon_ctrl_deinit(struct vtcon_softc *);
182 static void vtcon_ctrl_port_add_event(struct vtcon_softc *, int);
183 static void vtcon_ctrl_port_remove_event(struct vtcon_softc *, int);
184 static void vtcon_ctrl_port_console_event(struct vtcon_softc *, int);
185 static void vtcon_ctrl_port_open_event(struct vtcon_softc *, int);
186 static void vtcon_ctrl_port_name_event(struct vtcon_softc *, int,
187 const char *, size_t);
188 static void vtcon_ctrl_process_event(struct vtcon_softc *,
189 struct virtio_console_control *, void *, size_t);
190 static void vtcon_ctrl_task_cb(void *, int);
191 static void vtcon_ctrl_event_intr(void *);
192 static void vtcon_ctrl_poll(struct vtcon_softc *,
193 struct virtio_console_control *control);
194 static void vtcon_ctrl_send_control(struct vtcon_softc *, uint32_t,
195 uint16_t, uint16_t);
196
197 static int vtcon_port_enqueue_buf(struct vtcon_port *, void *, size_t);
198 static int vtcon_port_create_buf(struct vtcon_port *);
199 static void vtcon_port_requeue_buf(struct vtcon_port *, void *);
200 static int vtcon_port_populate(struct vtcon_port *);
201 static void vtcon_port_destroy(struct vtcon_port *);
202 static int vtcon_port_create(struct vtcon_softc *, int);
203 static void vtcon_port_dev_alias(struct vtcon_port *, const char *,
204 size_t);
205 static void vtcon_port_drain_bufs(struct virtqueue *);
206 static void vtcon_port_drain(struct vtcon_port *);
207 static void vtcon_port_teardown(struct vtcon_port *);
208 static void vtcon_port_change_size(struct vtcon_port *, uint16_t,
209 uint16_t);
210 static void vtcon_port_update_console_size(struct vtcon_softc *);
211 static void vtcon_port_enable_intr(struct vtcon_port *);
212 static void vtcon_port_disable_intr(struct vtcon_port *);
213 static void vtcon_port_in(struct vtcon_port *);
214 static void vtcon_port_intr(void *);
215 static void vtcon_port_out(struct vtcon_port *, void *, int);
216 static void vtcon_port_submit_event(struct vtcon_port *, uint16_t,
217 uint16_t);
218
219 static int vtcon_tty_open(struct tty *);
220 static void vtcon_tty_close(struct tty *);
221 static void vtcon_tty_outwakeup(struct tty *);
222 static void vtcon_tty_free(void *);
223
224 static void vtcon_get_console_size(struct vtcon_softc *, uint16_t *,
225 uint16_t *);
226
227 static void vtcon_enable_interrupts(struct vtcon_softc *);
228 static void vtcon_disable_interrupts(struct vtcon_softc *);
229
230 static int vtcon_pending_free;
231
232 static struct ttydevsw vtcon_tty_class = {
233 .tsw_flags = 0,
234 .tsw_open = vtcon_tty_open,
235 .tsw_close = vtcon_tty_close,
236 .tsw_outwakeup = vtcon_tty_outwakeup,
237 .tsw_free = vtcon_tty_free,
238 };
239
240 static device_method_t vtcon_methods[] = {
241 /* Device methods. */
242 DEVMETHOD(device_probe, vtcon_probe),
243 DEVMETHOD(device_attach, vtcon_attach),
244 DEVMETHOD(device_detach, vtcon_detach),
245
246 /* VirtIO methods. */
247 DEVMETHOD(virtio_config_change, vtcon_config_change),
248
249 DEVMETHOD_END
250 };
251
252 static driver_t vtcon_driver = {
253 "vtcon",
254 vtcon_methods,
255 sizeof(struct vtcon_softc)
256 };
257 static devclass_t vtcon_devclass;
258
259 DRIVER_MODULE(virtio_console, virtio_pci, vtcon_driver, vtcon_devclass,
260 vtcon_modevent, 0);
261 MODULE_VERSION(virtio_console, 1);
262 MODULE_DEPEND(virtio_console, virtio, 1, 1, 1);
263
264 static int
vtcon_modevent(module_t mod,int type,void * unused)265 vtcon_modevent(module_t mod, int type, void *unused)
266 {
267 int error;
268
269 switch (type) {
270 case MOD_LOAD:
271 error = 0;
272 break;
273 case MOD_QUIESCE:
274 error = 0;
275 break;
276 case MOD_UNLOAD:
277 vtcon_drain_all();
278 error = 0;
279 break;
280 case MOD_SHUTDOWN:
281 error = 0;
282 break;
283 default:
284 error = EOPNOTSUPP;
285 break;
286 }
287
288 return (error);
289 }
290
291 static void
vtcon_drain_all(void)292 vtcon_drain_all(void)
293 {
294 int first;
295
296 for (first = 1; vtcon_pending_free != 0; first = 0) {
297 if (first != 0) {
298 printf("virtio_console: Waiting for all detached TTY "
299 "devices to have open fds closed.\n");
300 }
301 pause("vtcondra", hz);
302 }
303 }
304
305 static int
vtcon_probe(device_t dev)306 vtcon_probe(device_t dev)
307 {
308
309 if (virtio_get_device_type(dev) != VIRTIO_ID_CONSOLE)
310 return (ENXIO);
311
312 device_set_desc(dev, "VirtIO Console Adapter");
313
314 return (BUS_PROBE_DEFAULT);
315 }
316
317 static int
vtcon_attach(device_t dev)318 vtcon_attach(device_t dev)
319 {
320 struct vtcon_softc *sc;
321 struct virtio_console_config concfg;
322 int error;
323
324 sc = device_get_softc(dev);
325 sc->vtcon_dev = dev;
326
327 mtx_init(&sc->vtcon_mtx, "vtconmtx", NULL, MTX_DEF);
328 mtx_init(&sc->vtcon_ctrl_tx_mtx, "vtconctrlmtx", NULL, MTX_DEF);
329
330 virtio_set_feature_desc(dev, vtcon_feature_desc);
331 vtcon_setup_features(sc);
332
333 vtcon_read_config(sc, &concfg);
334 vtcon_determine_max_ports(sc, &concfg);
335
336 error = vtcon_alloc_scports(sc);
337 if (error) {
338 device_printf(dev, "cannot allocate softc port structures\n");
339 goto fail;
340 }
341
342 error = vtcon_alloc_virtqueues(sc);
343 if (error) {
344 device_printf(dev, "cannot allocate virtqueues\n");
345 goto fail;
346 }
347
348 if (sc->vtcon_flags & VTCON_FLAG_MULTIPORT) {
349 TASK_INIT(&sc->vtcon_ctrl_task, 0, vtcon_ctrl_task_cb, sc);
350 error = vtcon_ctrl_init(sc);
351 if (error)
352 goto fail;
353 } else {
354 error = vtcon_port_create(sc, 0);
355 if (error)
356 goto fail;
357 if (sc->vtcon_flags & VTCON_FLAG_SIZE)
358 vtcon_port_update_console_size(sc);
359 }
360
361 error = virtio_setup_intr(dev, INTR_TYPE_TTY);
362 if (error) {
363 device_printf(dev, "cannot setup virtqueue interrupts\n");
364 goto fail;
365 }
366
367 vtcon_enable_interrupts(sc);
368
369 vtcon_ctrl_send_control(sc, VIRTIO_CONSOLE_BAD_ID,
370 VIRTIO_CONSOLE_DEVICE_READY, 1);
371
372 fail:
373 if (error)
374 vtcon_detach(dev);
375
376 return (error);
377 }
378
379 static int
vtcon_detach(device_t dev)380 vtcon_detach(device_t dev)
381 {
382 struct vtcon_softc *sc;
383
384 sc = device_get_softc(dev);
385
386 VTCON_LOCK(sc);
387 sc->vtcon_flags |= VTCON_FLAG_DETACHED;
388 if (device_is_attached(dev))
389 vtcon_stop(sc);
390 VTCON_UNLOCK(sc);
391
392 if (sc->vtcon_flags & VTCON_FLAG_MULTIPORT) {
393 taskqueue_drain(taskqueue_thread, &sc->vtcon_ctrl_task);
394 vtcon_ctrl_deinit(sc);
395 }
396
397 vtcon_destroy_ports(sc);
398 mtx_destroy(&sc->vtcon_mtx);
399 mtx_destroy(&sc->vtcon_ctrl_tx_mtx);
400
401 return (0);
402 }
403
404 static int
vtcon_config_change(device_t dev)405 vtcon_config_change(device_t dev)
406 {
407 struct vtcon_softc *sc;
408
409 sc = device_get_softc(dev);
410
411 /*
412 * When the multiport feature is negotiated, all configuration
413 * changes are done through control virtqueue events.
414 */
415 if ((sc->vtcon_flags & VTCON_FLAG_MULTIPORT) == 0) {
416 if (sc->vtcon_flags & VTCON_FLAG_SIZE)
417 vtcon_port_update_console_size(sc);
418 }
419
420 return (0);
421 }
422
423 static void
vtcon_negotiate_features(struct vtcon_softc * sc)424 vtcon_negotiate_features(struct vtcon_softc *sc)
425 {
426 device_t dev;
427 uint64_t features;
428
429 dev = sc->vtcon_dev;
430 features = VTCON_FEATURES;
431
432 sc->vtcon_features = virtio_negotiate_features(dev, features);
433 }
434
435 static void
vtcon_setup_features(struct vtcon_softc * sc)436 vtcon_setup_features(struct vtcon_softc *sc)
437 {
438 device_t dev;
439
440 dev = sc->vtcon_dev;
441
442 vtcon_negotiate_features(sc);
443
444 if (virtio_with_feature(dev, VIRTIO_CONSOLE_F_SIZE))
445 sc->vtcon_flags |= VTCON_FLAG_SIZE;
446 if (virtio_with_feature(dev, VIRTIO_CONSOLE_F_MULTIPORT))
447 sc->vtcon_flags |= VTCON_FLAG_MULTIPORT;
448 }
449
450 #define VTCON_GET_CONFIG(_dev, _feature, _field, _cfg) \
451 if (virtio_with_feature(_dev, _feature)) { \
452 virtio_read_device_config(_dev, \
453 offsetof(struct virtio_console_config, _field), \
454 &(_cfg)->_field, sizeof((_cfg)->_field)); \
455 }
456
457 static void
vtcon_read_config(struct vtcon_softc * sc,struct virtio_console_config * concfg)458 vtcon_read_config(struct vtcon_softc *sc, struct virtio_console_config *concfg)
459 {
460 device_t dev;
461
462 dev = sc->vtcon_dev;
463
464 bzero(concfg, sizeof(struct virtio_console_config));
465
466 VTCON_GET_CONFIG(dev, VIRTIO_CONSOLE_F_SIZE, cols, concfg);
467 VTCON_GET_CONFIG(dev, VIRTIO_CONSOLE_F_SIZE, rows, concfg);
468 VTCON_GET_CONFIG(dev, VIRTIO_CONSOLE_F_MULTIPORT, max_nr_ports, concfg);
469 }
470
471 #undef VTCON_GET_CONFIG
472
473 static int
vtcon_alloc_scports(struct vtcon_softc * sc)474 vtcon_alloc_scports(struct vtcon_softc *sc)
475 {
476 struct vtcon_softc_port *scport;
477 int max, i;
478
479 max = sc->vtcon_max_ports;
480
481 sc->vtcon_ports = malloc(sizeof(struct vtcon_softc_port) * max,
482 M_DEVBUF, M_NOWAIT | M_ZERO);
483 if (sc->vtcon_ports == NULL)
484 return (ENOMEM);
485
486 for (i = 0; i < max; i++) {
487 scport = &sc->vtcon_ports[i];
488 scport->vcsp_sc = sc;
489 }
490
491 return (0);
492 }
493
494 static int
vtcon_alloc_virtqueues(struct vtcon_softc * sc)495 vtcon_alloc_virtqueues(struct vtcon_softc *sc)
496 {
497 device_t dev;
498 struct vq_alloc_info *info;
499 struct vtcon_softc_port *scport;
500 int i, idx, portidx, nvqs, error;
501
502 dev = sc->vtcon_dev;
503
504 nvqs = sc->vtcon_max_ports * 2;
505 if (sc->vtcon_flags & VTCON_FLAG_MULTIPORT)
506 nvqs += 2;
507
508 info = malloc(sizeof(struct vq_alloc_info) * nvqs, M_TEMP, M_NOWAIT);
509 if (info == NULL)
510 return (ENOMEM);
511
512 for (i = 0, idx = 0, portidx = 0; i < nvqs / 2; i++, idx += 2) {
513
514 if (i == 1) {
515 /* The control virtqueues are after the first port. */
516 VQ_ALLOC_INFO_INIT(&info[idx], 0,
517 vtcon_ctrl_event_intr, sc, &sc->vtcon_ctrl_rxvq,
518 "%s-control rx", device_get_nameunit(dev));
519 VQ_ALLOC_INFO_INIT(&info[idx+1], 0,
520 NULL, sc, &sc->vtcon_ctrl_txvq,
521 "%s-control tx", device_get_nameunit(dev));
522 continue;
523 }
524
525 scport = &sc->vtcon_ports[portidx];
526
527 VQ_ALLOC_INFO_INIT(&info[idx], 0, vtcon_port_intr,
528 scport, &scport->vcsp_invq, "%s-port%d in",
529 device_get_nameunit(dev), i);
530 VQ_ALLOC_INFO_INIT(&info[idx+1], 0, NULL,
531 NULL, &scport->vcsp_outvq, "%s-port%d out",
532 device_get_nameunit(dev), i);
533
534 portidx++;
535 }
536
537 error = virtio_alloc_virtqueues(dev, 0, nvqs, info);
538 free(info, M_TEMP);
539
540 return (error);
541 }
542
543 static void
vtcon_determine_max_ports(struct vtcon_softc * sc,struct virtio_console_config * concfg)544 vtcon_determine_max_ports(struct vtcon_softc *sc,
545 struct virtio_console_config *concfg)
546 {
547
548 if (sc->vtcon_flags & VTCON_FLAG_MULTIPORT) {
549 sc->vtcon_max_ports =
550 min(concfg->max_nr_ports, VTCON_MAX_PORTS);
551 if (sc->vtcon_max_ports == 0)
552 sc->vtcon_max_ports = 1;
553 } else
554 sc->vtcon_max_ports = 1;
555 }
556
557 static void
vtcon_destroy_ports(struct vtcon_softc * sc)558 vtcon_destroy_ports(struct vtcon_softc *sc)
559 {
560 struct vtcon_softc_port *scport;
561 struct vtcon_port *port;
562 struct virtqueue *vq;
563 int i;
564
565 if (sc->vtcon_ports == NULL)
566 return;
567
568 VTCON_LOCK(sc);
569 for (i = 0; i < sc->vtcon_max_ports; i++) {
570 scport = &sc->vtcon_ports[i];
571
572 port = scport->vcsp_port;
573 if (port != NULL) {
574 scport->vcsp_port = NULL;
575 VTCON_PORT_LOCK(port);
576 VTCON_UNLOCK(sc);
577 vtcon_port_teardown(port);
578 VTCON_LOCK(sc);
579 }
580
581 vq = scport->vcsp_invq;
582 if (vq != NULL)
583 vtcon_port_drain_bufs(vq);
584 }
585 VTCON_UNLOCK(sc);
586
587 free(sc->vtcon_ports, M_DEVBUF);
588 sc->vtcon_ports = NULL;
589 }
590
591 static void
vtcon_stop(struct vtcon_softc * sc)592 vtcon_stop(struct vtcon_softc *sc)
593 {
594
595 vtcon_disable_interrupts(sc);
596 virtio_stop(sc->vtcon_dev);
597 }
598
599 static int
vtcon_ctrl_event_enqueue(struct vtcon_softc * sc,struct virtio_console_control * control)600 vtcon_ctrl_event_enqueue(struct vtcon_softc *sc,
601 struct virtio_console_control *control)
602 {
603 struct sglist_seg segs[2];
604 struct sglist sg;
605 struct virtqueue *vq;
606 int error;
607
608 vq = sc->vtcon_ctrl_rxvq;
609
610 sglist_init(&sg, 2, segs);
611 error = sglist_append(&sg, control, VTCON_CTRL_BUFSZ);
612 KASSERT(error == 0, ("%s: error %d adding control to sglist",
613 __func__, error));
614
615 return (virtqueue_enqueue(vq, control, &sg, 0, sg.sg_nseg));
616 }
617
618 static int
vtcon_ctrl_event_create(struct vtcon_softc * sc)619 vtcon_ctrl_event_create(struct vtcon_softc *sc)
620 {
621 struct virtio_console_control *control;
622 int error;
623
624 control = malloc(VTCON_CTRL_BUFSZ, M_DEVBUF, M_ZERO | M_NOWAIT);
625 if (control == NULL)
626 return (ENOMEM);
627
628 error = vtcon_ctrl_event_enqueue(sc, control);
629 if (error)
630 free(control, M_DEVBUF);
631
632 return (error);
633 }
634
635 static void
vtcon_ctrl_event_requeue(struct vtcon_softc * sc,struct virtio_console_control * control)636 vtcon_ctrl_event_requeue(struct vtcon_softc *sc,
637 struct virtio_console_control *control)
638 {
639 int error;
640
641 bzero(control, VTCON_CTRL_BUFSZ);
642
643 error = vtcon_ctrl_event_enqueue(sc, control);
644 KASSERT(error == 0,
645 ("%s: cannot requeue control buffer %d", __func__, error));
646 }
647
648 static int
vtcon_ctrl_event_populate(struct vtcon_softc * sc)649 vtcon_ctrl_event_populate(struct vtcon_softc *sc)
650 {
651 struct virtqueue *vq;
652 int nbufs, error;
653
654 vq = sc->vtcon_ctrl_rxvq;
655 error = ENOSPC;
656
657 for (nbufs = 0; !virtqueue_full(vq); nbufs++) {
658 error = vtcon_ctrl_event_create(sc);
659 if (error)
660 break;
661 }
662
663 if (nbufs > 0) {
664 virtqueue_notify(vq);
665 error = 0;
666 }
667
668 return (error);
669 }
670
671 static void
vtcon_ctrl_event_drain(struct vtcon_softc * sc)672 vtcon_ctrl_event_drain(struct vtcon_softc *sc)
673 {
674 struct virtio_console_control *control;
675 struct virtqueue *vq;
676 int last;
677
678 vq = sc->vtcon_ctrl_rxvq;
679 last = 0;
680
681 if (vq == NULL)
682 return;
683
684 VTCON_LOCK(sc);
685 while ((control = virtqueue_drain(vq, &last)) != NULL)
686 free(control, M_DEVBUF);
687 VTCON_UNLOCK(sc);
688 }
689
690 static int
vtcon_ctrl_init(struct vtcon_softc * sc)691 vtcon_ctrl_init(struct vtcon_softc *sc)
692 {
693 int error;
694
695 error = vtcon_ctrl_event_populate(sc);
696
697 return (error);
698 }
699
700 static void
vtcon_ctrl_deinit(struct vtcon_softc * sc)701 vtcon_ctrl_deinit(struct vtcon_softc *sc)
702 {
703
704 vtcon_ctrl_event_drain(sc);
705 }
706
707 static void
vtcon_ctrl_port_add_event(struct vtcon_softc * sc,int id)708 vtcon_ctrl_port_add_event(struct vtcon_softc *sc, int id)
709 {
710 device_t dev;
711 int error;
712
713 dev = sc->vtcon_dev;
714
715 /* This single thread only way for ports to be created. */
716 if (sc->vtcon_ports[id].vcsp_port != NULL) {
717 device_printf(dev, "%s: adding port %d, but already exists\n",
718 __func__, id);
719 return;
720 }
721
722 error = vtcon_port_create(sc, id);
723 if (error) {
724 device_printf(dev, "%s: cannot create port %d: %d\n",
725 __func__, id, error);
726 vtcon_ctrl_send_control(sc, id, VIRTIO_CONSOLE_PORT_READY, 0);
727 return;
728 }
729 }
730
731 static void
vtcon_ctrl_port_remove_event(struct vtcon_softc * sc,int id)732 vtcon_ctrl_port_remove_event(struct vtcon_softc *sc, int id)
733 {
734 device_t dev;
735 struct vtcon_softc_port *scport;
736 struct vtcon_port *port;
737
738 dev = sc->vtcon_dev;
739 scport = &sc->vtcon_ports[id];
740
741 VTCON_LOCK(sc);
742 port = scport->vcsp_port;
743 if (port == NULL) {
744 VTCON_UNLOCK(sc);
745 device_printf(dev, "%s: remove port %d, but does not exist\n",
746 __func__, id);
747 return;
748 }
749
750 scport->vcsp_port = NULL;
751 VTCON_PORT_LOCK(port);
752 VTCON_UNLOCK(sc);
753 vtcon_port_teardown(port);
754 }
755
756 static void
vtcon_ctrl_port_console_event(struct vtcon_softc * sc,int id)757 vtcon_ctrl_port_console_event(struct vtcon_softc *sc, int id)
758 {
759 device_t dev;
760 struct vtcon_softc_port *scport;
761 struct vtcon_port *port;
762
763 dev = sc->vtcon_dev;
764 scport = &sc->vtcon_ports[id];
765
766 VTCON_LOCK(sc);
767 port = scport->vcsp_port;
768 if (port == NULL) {
769 VTCON_UNLOCK(sc);
770 device_printf(dev, "%s: console port %d, but does not exist\n",
771 __func__, id);
772 return;
773 }
774
775 VTCON_PORT_LOCK(port);
776 VTCON_UNLOCK(sc);
777 port->vtcport_flags |= VTCON_PORT_FLAG_CONSOLE;
778 vtcon_port_submit_event(port, VIRTIO_CONSOLE_PORT_OPEN, 1);
779 VTCON_PORT_UNLOCK(port);
780 }
781
782 static void
vtcon_ctrl_port_open_event(struct vtcon_softc * sc,int id)783 vtcon_ctrl_port_open_event(struct vtcon_softc *sc, int id)
784 {
785 device_t dev;
786 struct vtcon_softc_port *scport;
787 struct vtcon_port *port;
788
789 dev = sc->vtcon_dev;
790 scport = &sc->vtcon_ports[id];
791
792 VTCON_LOCK(sc);
793 port = scport->vcsp_port;
794 if (port == NULL) {
795 VTCON_UNLOCK(sc);
796 device_printf(dev, "%s: open port %d, but does not exist\n",
797 __func__, id);
798 return;
799 }
800
801 VTCON_PORT_LOCK(port);
802 VTCON_UNLOCK(sc);
803 vtcon_port_enable_intr(port);
804 VTCON_PORT_UNLOCK(port);
805 }
806
807 static void
vtcon_ctrl_port_name_event(struct vtcon_softc * sc,int id,const char * name,size_t len)808 vtcon_ctrl_port_name_event(struct vtcon_softc *sc, int id, const char *name,
809 size_t len)
810 {
811 device_t dev;
812 struct vtcon_softc_port *scport;
813 struct vtcon_port *port;
814
815 dev = sc->vtcon_dev;
816 scport = &sc->vtcon_ports[id];
817
818 /*
819 * The VirtIO specification says the NUL terminator is not included in
820 * the length, but QEMU includes it. Adjust the length if needed.
821 */
822 if (name == NULL || len == 0)
823 return;
824 if (name[len - 1] == '\0') {
825 len--;
826 if (len == 0)
827 return;
828 }
829
830 VTCON_LOCK(sc);
831 port = scport->vcsp_port;
832 if (port == NULL) {
833 VTCON_UNLOCK(sc);
834 device_printf(dev, "%s: name port %d, but does not exist\n",
835 __func__, id);
836 return;
837 }
838
839 VTCON_PORT_LOCK(port);
840 VTCON_UNLOCK(sc);
841 vtcon_port_dev_alias(port, name, len);
842 VTCON_PORT_UNLOCK(port);
843 }
844
845 static void
vtcon_ctrl_process_event(struct vtcon_softc * sc,struct virtio_console_control * control,void * data,size_t data_len)846 vtcon_ctrl_process_event(struct vtcon_softc *sc,
847 struct virtio_console_control *control, void *data, size_t data_len)
848 {
849 device_t dev;
850 int id;
851
852 dev = sc->vtcon_dev;
853 id = control->id;
854
855 if (id < 0 || id >= sc->vtcon_max_ports) {
856 device_printf(dev, "%s: invalid port ID %d\n", __func__, id);
857 return;
858 }
859
860 switch (control->event) {
861 case VIRTIO_CONSOLE_PORT_ADD:
862 vtcon_ctrl_port_add_event(sc, id);
863 break;
864
865 case VIRTIO_CONSOLE_PORT_REMOVE:
866 vtcon_ctrl_port_remove_event(sc, id);
867 break;
868
869 case VIRTIO_CONSOLE_CONSOLE_PORT:
870 vtcon_ctrl_port_console_event(sc, id);
871 break;
872
873 case VIRTIO_CONSOLE_RESIZE:
874 break;
875
876 case VIRTIO_CONSOLE_PORT_OPEN:
877 vtcon_ctrl_port_open_event(sc, id);
878 break;
879
880 case VIRTIO_CONSOLE_PORT_NAME:
881 vtcon_ctrl_port_name_event(sc, id, (const char *)data, data_len);
882 break;
883 }
884 }
885
886 static void
vtcon_ctrl_task_cb(void * xsc,int pending)887 vtcon_ctrl_task_cb(void *xsc, int pending)
888 {
889 struct vtcon_softc *sc;
890 struct virtqueue *vq;
891 struct virtio_console_control *control;
892 void *data;
893 size_t data_len;
894 int detached;
895 uint32_t len;
896
897 sc = xsc;
898 vq = sc->vtcon_ctrl_rxvq;
899
900 VTCON_LOCK(sc);
901
902 while ((detached = (sc->vtcon_flags & VTCON_FLAG_DETACHED)) == 0) {
903 control = virtqueue_dequeue(vq, &len);
904 if (control == NULL)
905 break;
906
907 if (len > sizeof(struct virtio_console_control)) {
908 data = (void *) &control[1];
909 data_len = len - sizeof(struct virtio_console_control);
910 } else {
911 data = NULL;
912 data_len = 0;
913 }
914
915 VTCON_UNLOCK(sc);
916 vtcon_ctrl_process_event(sc, control, data, data_len);
917 VTCON_LOCK(sc);
918 vtcon_ctrl_event_requeue(sc, control);
919 }
920
921 if (!detached) {
922 virtqueue_notify(vq);
923 if (virtqueue_enable_intr(vq) != 0)
924 taskqueue_enqueue(taskqueue_thread,
925 &sc->vtcon_ctrl_task);
926 }
927
928 VTCON_UNLOCK(sc);
929 }
930
931 static void
vtcon_ctrl_event_intr(void * xsc)932 vtcon_ctrl_event_intr(void *xsc)
933 {
934 struct vtcon_softc *sc;
935
936 sc = xsc;
937
938 /*
939 * Only some events require us to potentially block, but it
940 * easier to just defer all event handling to the taskqueue.
941 */
942 taskqueue_enqueue(taskqueue_thread, &sc->vtcon_ctrl_task);
943 }
944
945 static void
vtcon_ctrl_poll(struct vtcon_softc * sc,struct virtio_console_control * control)946 vtcon_ctrl_poll(struct vtcon_softc *sc,
947 struct virtio_console_control *control)
948 {
949 struct sglist_seg segs[2];
950 struct sglist sg;
951 struct virtqueue *vq;
952 int error;
953
954 vq = sc->vtcon_ctrl_txvq;
955
956 sglist_init(&sg, 2, segs);
957 error = sglist_append(&sg, control,
958 sizeof(struct virtio_console_control));
959 KASSERT(error == 0, ("%s: error %d adding control to sglist",
960 __func__, error));
961
962 /*
963 * We cannot use the softc lock to serialize access to this
964 * virtqueue since this is called from the tty layer with the
965 * port lock held. Acquiring the softc would violate our lock
966 * ordering.
967 */
968 VTCON_CTRL_TX_LOCK(sc);
969 KASSERT(virtqueue_empty(vq),
970 ("%s: virtqueue is not emtpy", __func__));
971 error = virtqueue_enqueue(vq, control, &sg, sg.sg_nseg, 0);
972 if (error == 0) {
973 virtqueue_notify(vq);
974 virtqueue_poll(vq, NULL);
975 }
976 VTCON_CTRL_TX_UNLOCK(sc);
977 }
978
979 static void
vtcon_ctrl_send_control(struct vtcon_softc * sc,uint32_t portid,uint16_t event,uint16_t value)980 vtcon_ctrl_send_control(struct vtcon_softc *sc, uint32_t portid,
981 uint16_t event, uint16_t value)
982 {
983 struct virtio_console_control control;
984
985 if ((sc->vtcon_flags & VTCON_FLAG_MULTIPORT) == 0)
986 return;
987
988 control.id = portid;
989 control.event = event;
990 control.value = value;
991
992 vtcon_ctrl_poll(sc, &control);
993 }
994
995 static int
vtcon_port_enqueue_buf(struct vtcon_port * port,void * buf,size_t len)996 vtcon_port_enqueue_buf(struct vtcon_port *port, void *buf, size_t len)
997 {
998 struct sglist_seg segs[2];
999 struct sglist sg;
1000 struct virtqueue *vq;
1001 int error;
1002
1003 vq = port->vtcport_invq;
1004
1005 sglist_init(&sg, 2, segs);
1006 error = sglist_append(&sg, buf, len);
1007 KASSERT(error == 0,
1008 ("%s: error %d adding buffer to sglist", __func__, error));
1009
1010 error = virtqueue_enqueue(vq, buf, &sg, 0, sg.sg_nseg);
1011
1012 return (error);
1013 }
1014
1015 static int
vtcon_port_create_buf(struct vtcon_port * port)1016 vtcon_port_create_buf(struct vtcon_port *port)
1017 {
1018 void *buf;
1019 int error;
1020
1021 buf = malloc(VTCON_BULK_BUFSZ, M_DEVBUF, M_ZERO | M_NOWAIT);
1022 if (buf == NULL)
1023 return (ENOMEM);
1024
1025 error = vtcon_port_enqueue_buf(port, buf, VTCON_BULK_BUFSZ);
1026 if (error)
1027 free(buf, M_DEVBUF);
1028
1029 return (error);
1030 }
1031
1032 static void
vtcon_port_requeue_buf(struct vtcon_port * port,void * buf)1033 vtcon_port_requeue_buf(struct vtcon_port *port, void *buf)
1034 {
1035 int error;
1036
1037 error = vtcon_port_enqueue_buf(port, buf, VTCON_BULK_BUFSZ);
1038 KASSERT(error == 0,
1039 ("%s: cannot requeue input buffer %d", __func__, error));
1040 }
1041
1042 static int
vtcon_port_populate(struct vtcon_port * port)1043 vtcon_port_populate(struct vtcon_port *port)
1044 {
1045 struct virtqueue *vq;
1046 int nbufs, error;
1047
1048 vq = port->vtcport_invq;
1049 error = ENOSPC;
1050
1051 for (nbufs = 0; !virtqueue_full(vq); nbufs++) {
1052 error = vtcon_port_create_buf(port);
1053 if (error)
1054 break;
1055 }
1056
1057 if (nbufs > 0) {
1058 virtqueue_notify(vq);
1059 error = 0;
1060 }
1061
1062 return (error);
1063 }
1064
1065 static void
vtcon_port_destroy(struct vtcon_port * port)1066 vtcon_port_destroy(struct vtcon_port *port)
1067 {
1068
1069 port->vtcport_sc = NULL;
1070 port->vtcport_scport = NULL;
1071 port->vtcport_invq = NULL;
1072 port->vtcport_outvq = NULL;
1073 port->vtcport_id = -1;
1074 mtx_destroy(&port->vtcport_mtx);
1075 free(port, M_DEVBUF);
1076 }
1077
1078 static int
vtcon_port_init_vqs(struct vtcon_port * port)1079 vtcon_port_init_vqs(struct vtcon_port *port)
1080 {
1081 struct vtcon_softc_port *scport;
1082 int error;
1083
1084 scport = port->vtcport_scport;
1085
1086 port->vtcport_invq = scport->vcsp_invq;
1087 port->vtcport_outvq = scport->vcsp_outvq;
1088
1089 /*
1090 * Free any data left over from when this virtqueue was in use by a
1091 * prior port. We have not yet notified the host that the port is
1092 * ready, so assume nothing in the virtqueue can be for us.
1093 */
1094 vtcon_port_drain(port);
1095
1096 KASSERT(virtqueue_empty(port->vtcport_invq),
1097 ("%s: in virtqueue is not empty", __func__));
1098 KASSERT(virtqueue_empty(port->vtcport_outvq),
1099 ("%s: out virtqueue is not empty", __func__));
1100
1101 error = vtcon_port_populate(port);
1102 if (error)
1103 return (error);
1104
1105 return (0);
1106 }
1107
1108 static int
vtcon_port_create(struct vtcon_softc * sc,int id)1109 vtcon_port_create(struct vtcon_softc *sc, int id)
1110 {
1111 device_t dev;
1112 struct vtcon_softc_port *scport;
1113 struct vtcon_port *port;
1114 int error;
1115
1116 dev = sc->vtcon_dev;
1117 scport = &sc->vtcon_ports[id];
1118
1119 VTCON_ASSERT_VALID_PORTID(sc, id);
1120 MPASS(scport->vcsp_port == NULL);
1121
1122 port = malloc(sizeof(struct vtcon_port), M_DEVBUF, M_NOWAIT | M_ZERO);
1123 if (port == NULL)
1124 return (ENOMEM);
1125
1126 port->vtcport_sc = sc;
1127 port->vtcport_scport = scport;
1128 port->vtcport_id = id;
1129 mtx_init(&port->vtcport_mtx, "vtcpmtx", NULL, MTX_DEF);
1130 port->vtcport_tty = tty_alloc_mutex(&vtcon_tty_class, port,
1131 &port->vtcport_mtx);
1132
1133 error = vtcon_port_init_vqs(port);
1134 if (error) {
1135 VTCON_PORT_LOCK(port);
1136 vtcon_port_teardown(port);
1137 return (error);
1138 }
1139
1140 VTCON_LOCK(sc);
1141 VTCON_PORT_LOCK(port);
1142 scport->vcsp_port = port;
1143 vtcon_port_enable_intr(port);
1144 vtcon_port_submit_event(port, VIRTIO_CONSOLE_PORT_READY, 1);
1145 VTCON_PORT_UNLOCK(port);
1146 VTCON_UNLOCK(sc);
1147
1148 tty_makedev(port->vtcport_tty, NULL, "%s%r.%r", VTCON_TTY_PREFIX,
1149 device_get_unit(dev), id);
1150
1151 return (0);
1152 }
1153
1154 static void
vtcon_port_dev_alias(struct vtcon_port * port,const char * name,size_t len)1155 vtcon_port_dev_alias(struct vtcon_port *port, const char *name, size_t len)
1156 {
1157 struct vtcon_softc *sc;
1158 struct cdev *pdev;
1159 struct tty *tp;
1160 int i, error;
1161
1162 sc = port->vtcport_sc;
1163 tp = port->vtcport_tty;
1164
1165 if (port->vtcport_flags & VTCON_PORT_FLAG_ALIAS)
1166 return;
1167
1168 /* Port name is UTF-8, but we can only handle ASCII. */
1169 for (i = 0; i < len; i++) {
1170 if (!isascii(name[i]))
1171 return;
1172 }
1173
1174 /*
1175 * Port name may not conform to the devfs requirements so we cannot use
1176 * tty_makealias() because the MAKEDEV_CHECKNAME flag must be specified.
1177 */
1178 error = make_dev_alias_p(MAKEDEV_NOWAIT | MAKEDEV_CHECKNAME, &pdev,
1179 tp->t_dev, "%s/%*s", VTCON_TTY_ALIAS_PREFIX, (int)len, name);
1180 if (error) {
1181 device_printf(sc->vtcon_dev,
1182 "%s: cannot make dev alias (%s/%*s) error %d\n", __func__,
1183 VTCON_TTY_ALIAS_PREFIX, (int)len, name, error);
1184 } else
1185 port->vtcport_flags |= VTCON_PORT_FLAG_ALIAS;
1186 }
1187
1188 static void
vtcon_port_drain_bufs(struct virtqueue * vq)1189 vtcon_port_drain_bufs(struct virtqueue *vq)
1190 {
1191 void *buf;
1192 int last;
1193
1194 last = 0;
1195
1196 while ((buf = virtqueue_drain(vq, &last)) != NULL)
1197 free(buf, M_DEVBUF);
1198 }
1199
1200 static void
vtcon_port_drain(struct vtcon_port * port)1201 vtcon_port_drain(struct vtcon_port *port)
1202 {
1203
1204 vtcon_port_drain_bufs(port->vtcport_invq);
1205 }
1206
1207 static void
vtcon_port_teardown(struct vtcon_port * port)1208 vtcon_port_teardown(struct vtcon_port *port)
1209 {
1210 struct tty *tp;
1211
1212 tp = port->vtcport_tty;
1213
1214 port->vtcport_flags |= VTCON_PORT_FLAG_GONE;
1215
1216 if (tp != NULL) {
1217 atomic_add_int(&vtcon_pending_free, 1);
1218 tty_rel_gone(tp);
1219 } else
1220 vtcon_port_destroy(port);
1221 }
1222
1223 static void
vtcon_port_change_size(struct vtcon_port * port,uint16_t cols,uint16_t rows)1224 vtcon_port_change_size(struct vtcon_port *port, uint16_t cols, uint16_t rows)
1225 {
1226 struct tty *tp;
1227 struct winsize sz;
1228
1229 tp = port->vtcport_tty;
1230
1231 if (tp == NULL)
1232 return;
1233
1234 bzero(&sz, sizeof(struct winsize));
1235 sz.ws_col = cols;
1236 sz.ws_row = rows;
1237
1238 tty_set_winsize(tp, &sz);
1239 }
1240
1241 static void
vtcon_port_update_console_size(struct vtcon_softc * sc)1242 vtcon_port_update_console_size(struct vtcon_softc *sc)
1243 {
1244 struct vtcon_port *port;
1245 struct vtcon_softc_port *scport;
1246 uint16_t cols, rows;
1247
1248 vtcon_get_console_size(sc, &cols, &rows);
1249
1250 /*
1251 * For now, assume the first (only) port is the console. Note
1252 * QEMU does not implement this feature yet.
1253 */
1254 scport = &sc->vtcon_ports[0];
1255
1256 VTCON_LOCK(sc);
1257 port = scport->vcsp_port;
1258
1259 if (port != NULL) {
1260 VTCON_PORT_LOCK(port);
1261 VTCON_UNLOCK(sc);
1262 vtcon_port_change_size(port, cols, rows);
1263 VTCON_PORT_UNLOCK(port);
1264 } else
1265 VTCON_UNLOCK(sc);
1266 }
1267
1268 static void
vtcon_port_enable_intr(struct vtcon_port * port)1269 vtcon_port_enable_intr(struct vtcon_port *port)
1270 {
1271
1272 /*
1273 * NOTE: The out virtqueue is always polled, so its interrupt
1274 * kept disabled.
1275 */
1276 virtqueue_enable_intr(port->vtcport_invq);
1277 }
1278
1279 static void
vtcon_port_disable_intr(struct vtcon_port * port)1280 vtcon_port_disable_intr(struct vtcon_port *port)
1281 {
1282
1283 if (port->vtcport_invq != NULL)
1284 virtqueue_disable_intr(port->vtcport_invq);
1285 if (port->vtcport_outvq != NULL)
1286 virtqueue_disable_intr(port->vtcport_outvq);
1287 }
1288
1289 static void
vtcon_port_in(struct vtcon_port * port)1290 vtcon_port_in(struct vtcon_port *port)
1291 {
1292 struct virtqueue *vq;
1293 struct tty *tp;
1294 char *buf;
1295 uint32_t len;
1296 int i, deq;
1297
1298 tp = port->vtcport_tty;
1299 vq = port->vtcport_invq;
1300
1301 again:
1302 deq = 0;
1303
1304 while ((buf = virtqueue_dequeue(vq, &len)) != NULL) {
1305 for (i = 0; i < len; i++) {
1306 #if defined(KDB)
1307 if (port->vtcport_flags & VTCON_PORT_FLAG_CONSOLE)
1308 kdb_alt_break(buf[i],
1309 &port->vtcport_alt_break_state);
1310 #endif
1311 ttydisc_rint(tp, buf[i], 0);
1312 }
1313 vtcon_port_requeue_buf(port, buf);
1314 deq++;
1315 }
1316 ttydisc_rint_done(tp);
1317
1318 if (deq > 0)
1319 virtqueue_notify(vq);
1320
1321 if (virtqueue_enable_intr(vq) != 0)
1322 goto again;
1323 }
1324
1325 static void
vtcon_port_intr(void * scportx)1326 vtcon_port_intr(void *scportx)
1327 {
1328 struct vtcon_softc_port *scport;
1329 struct vtcon_softc *sc;
1330 struct vtcon_port *port;
1331
1332 scport = scportx;
1333 sc = scport->vcsp_sc;
1334
1335 VTCON_LOCK(sc);
1336 port = scport->vcsp_port;
1337 if (port == NULL) {
1338 VTCON_UNLOCK(sc);
1339 return;
1340 }
1341 VTCON_PORT_LOCK(port);
1342 VTCON_UNLOCK(sc);
1343 if ((port->vtcport_flags & VTCON_PORT_FLAG_GONE) == 0)
1344 vtcon_port_in(port);
1345 VTCON_PORT_UNLOCK(port);
1346 }
1347
1348 static void
vtcon_port_out(struct vtcon_port * port,void * buf,int bufsize)1349 vtcon_port_out(struct vtcon_port *port, void *buf, int bufsize)
1350 {
1351 struct sglist_seg segs[2];
1352 struct sglist sg;
1353 struct virtqueue *vq;
1354 int error;
1355
1356 vq = port->vtcport_outvq;
1357 KASSERT(virtqueue_empty(vq),
1358 ("%s: port %p out virtqueue not emtpy", __func__, port));
1359
1360 sglist_init(&sg, 2, segs);
1361 error = sglist_append(&sg, buf, bufsize);
1362 KASSERT(error == 0, ("%s: error %d adding buffer to sglist",
1363 __func__, error));
1364
1365 error = virtqueue_enqueue(vq, buf, &sg, sg.sg_nseg, 0);
1366 if (error == 0) {
1367 virtqueue_notify(vq);
1368 virtqueue_poll(vq, NULL);
1369 }
1370 }
1371
1372 static void
vtcon_port_submit_event(struct vtcon_port * port,uint16_t event,uint16_t value)1373 vtcon_port_submit_event(struct vtcon_port *port, uint16_t event,
1374 uint16_t value)
1375 {
1376 struct vtcon_softc *sc;
1377
1378 sc = port->vtcport_sc;
1379
1380 vtcon_ctrl_send_control(sc, port->vtcport_id, event, value);
1381 }
1382
1383 static int
vtcon_tty_open(struct tty * tp)1384 vtcon_tty_open(struct tty *tp)
1385 {
1386 struct vtcon_port *port;
1387
1388 port = tty_softc(tp);
1389
1390 if (port->vtcport_flags & VTCON_PORT_FLAG_GONE)
1391 return (ENXIO);
1392
1393 vtcon_port_submit_event(port, VIRTIO_CONSOLE_PORT_OPEN, 1);
1394
1395 return (0);
1396 }
1397
1398 static void
vtcon_tty_close(struct tty * tp)1399 vtcon_tty_close(struct tty *tp)
1400 {
1401 struct vtcon_port *port;
1402
1403 port = tty_softc(tp);
1404
1405 if (port->vtcport_flags & VTCON_PORT_FLAG_GONE)
1406 return;
1407
1408 vtcon_port_submit_event(port, VIRTIO_CONSOLE_PORT_OPEN, 0);
1409 }
1410
1411 static void
vtcon_tty_outwakeup(struct tty * tp)1412 vtcon_tty_outwakeup(struct tty *tp)
1413 {
1414 struct vtcon_port *port;
1415 char buf[VTCON_BULK_BUFSZ];
1416 int len;
1417
1418 port = tty_softc(tp);
1419
1420 if (port->vtcport_flags & VTCON_PORT_FLAG_GONE)
1421 return;
1422
1423 while ((len = ttydisc_getc(tp, buf, sizeof(buf))) != 0)
1424 vtcon_port_out(port, buf, len);
1425 }
1426
1427 static void
vtcon_tty_free(void * xport)1428 vtcon_tty_free(void *xport)
1429 {
1430 struct vtcon_port *port;
1431
1432 port = xport;
1433
1434 vtcon_port_destroy(port);
1435 atomic_subtract_int(&vtcon_pending_free, 1);
1436 }
1437
1438 static void
vtcon_get_console_size(struct vtcon_softc * sc,uint16_t * cols,uint16_t * rows)1439 vtcon_get_console_size(struct vtcon_softc *sc, uint16_t *cols, uint16_t *rows)
1440 {
1441 struct virtio_console_config concfg;
1442
1443 KASSERT(sc->vtcon_flags & VTCON_FLAG_SIZE,
1444 ("%s: size feature not negotiated", __func__));
1445
1446 vtcon_read_config(sc, &concfg);
1447
1448 *cols = concfg.cols;
1449 *rows = concfg.rows;
1450 }
1451
1452 static void
vtcon_enable_interrupts(struct vtcon_softc * sc)1453 vtcon_enable_interrupts(struct vtcon_softc *sc)
1454 {
1455 struct vtcon_softc_port *scport;
1456 struct vtcon_port *port;
1457 int i;
1458
1459 VTCON_LOCK(sc);
1460
1461 if (sc->vtcon_flags & VTCON_FLAG_MULTIPORT)
1462 virtqueue_enable_intr(sc->vtcon_ctrl_rxvq);
1463
1464 for (i = 0; i < sc->vtcon_max_ports; i++) {
1465 scport = &sc->vtcon_ports[i];
1466
1467 port = scport->vcsp_port;
1468 if (port == NULL)
1469 continue;
1470
1471 VTCON_PORT_LOCK(port);
1472 vtcon_port_enable_intr(port);
1473 VTCON_PORT_UNLOCK(port);
1474 }
1475
1476 VTCON_UNLOCK(sc);
1477 }
1478
1479 static void
vtcon_disable_interrupts(struct vtcon_softc * sc)1480 vtcon_disable_interrupts(struct vtcon_softc *sc)
1481 {
1482 struct vtcon_softc_port *scport;
1483 struct vtcon_port *port;
1484 int i;
1485
1486 VTCON_LOCK_ASSERT(sc);
1487
1488 if (sc->vtcon_flags & VTCON_FLAG_MULTIPORT)
1489 virtqueue_disable_intr(sc->vtcon_ctrl_rxvq);
1490
1491 for (i = 0; i < sc->vtcon_max_ports; i++) {
1492 scport = &sc->vtcon_ports[i];
1493
1494 port = scport->vcsp_port;
1495 if (port == NULL)
1496 continue;
1497
1498 VTCON_PORT_LOCK(port);
1499 vtcon_port_disable_intr(port);
1500 VTCON_PORT_UNLOCK(port);
1501 }
1502 }
1503