1/*-
2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3 *
4 * Copyright (c) 2016 iXsystems Inc.
5 * All rights reserved.
6 *
7 * This software was developed by Jakub Klama <jceel@FreeBSD.org>
8 * under sponsorship from iXsystems Inc.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 *    notice, this list of conditions and the following disclaimer
15 *    in this position and unchanged.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 *    notice, this list of conditions and the following disclaimer in the
18 *    documentation and/or other materials provided with the distribution.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30 * SUCH DAMAGE.
31 */
32
33#include <sys/cdefs.h>
34__FBSDID("$FreeBSD$");
35
36#include <sys/param.h>
37#ifndef WITHOUT_CAPSICUM
38#include <sys/capsicum.h>
39#endif
40#include <sys/linker_set.h>
41#include <sys/uio.h>
42#include <sys/types.h>
43#include <sys/socket.h>
44#include <sys/un.h>
45
46#ifndef WITHOUT_CAPSICUM
47#include <capsicum_helpers.h>
48#endif
49#include <err.h>
50#include <errno.h>
51#include <fcntl.h>
52#include <stdio.h>
53#include <stdlib.h>
54#include <stdbool.h>
55#include <string.h>
56#include <unistd.h>
57#include <assert.h>
58#include <pthread.h>
59#include <libgen.h>
60#include <sysexits.h>
61
62#include "bhyverun.h"
63#include "debug.h"
64#include "pci_emul.h"
65#include "virtio.h"
66#include "mevent.h"
67#include "sockstream.h"
68
69#define	VTCON_RINGSZ	64
70#define	VTCON_MAXPORTS	16
71#define	VTCON_MAXQ	(VTCON_MAXPORTS * 2 + 2)
72
73#define	VTCON_DEVICE_READY	0
74#define	VTCON_DEVICE_ADD	1
75#define	VTCON_DEVICE_REMOVE	2
76#define	VTCON_PORT_READY	3
77#define	VTCON_CONSOLE_PORT	4
78#define	VTCON_CONSOLE_RESIZE	5
79#define	VTCON_PORT_OPEN		6
80#define	VTCON_PORT_NAME		7
81
82#define	VTCON_F_SIZE		0
83#define	VTCON_F_MULTIPORT	1
84#define	VTCON_F_EMERG_WRITE	2
85#define	VTCON_S_HOSTCAPS	\
86    (VTCON_F_SIZE | VTCON_F_MULTIPORT | VTCON_F_EMERG_WRITE)
87
88static int pci_vtcon_debug;
89#define DPRINTF(params) if (pci_vtcon_debug) PRINTLN params
90#define WPRINTF(params) PRINTLN params
91
92struct pci_vtcon_softc;
93struct pci_vtcon_port;
94struct pci_vtcon_config;
95typedef void (pci_vtcon_cb_t)(struct pci_vtcon_port *, void *, struct iovec *,
96    int);
97
98struct pci_vtcon_port {
99	struct pci_vtcon_softc * vsp_sc;
100	int                      vsp_id;
101	const char *             vsp_name;
102	bool                     vsp_enabled;
103	bool                     vsp_console;
104	bool                     vsp_rx_ready;
105	bool                     vsp_open;
106	int                      vsp_rxq;
107	int                      vsp_txq;
108	void *                   vsp_arg;
109	pci_vtcon_cb_t *         vsp_cb;
110};
111
112struct pci_vtcon_sock
113{
114	struct pci_vtcon_port *  vss_port;
115	const char *             vss_path;
116	struct mevent *          vss_server_evp;
117	struct mevent *          vss_conn_evp;
118	int                      vss_server_fd;
119	int                      vss_conn_fd;
120	bool                     vss_open;
121};
122
123struct pci_vtcon_softc {
124	struct virtio_softc      vsc_vs;
125	struct vqueue_info       vsc_queues[VTCON_MAXQ];
126	pthread_mutex_t          vsc_mtx;
127	uint64_t                 vsc_cfg;
128	uint64_t                 vsc_features;
129	char *                   vsc_rootdir;
130	int                      vsc_kq;
131	int                      vsc_nports;
132	bool                     vsc_ready;
133	struct pci_vtcon_port    vsc_control_port;
134 	struct pci_vtcon_port    vsc_ports[VTCON_MAXPORTS];
135	struct pci_vtcon_config *vsc_config;
136};
137
138struct pci_vtcon_config {
139	uint16_t cols;
140	uint16_t rows;
141	uint32_t max_nr_ports;
142	uint32_t emerg_wr;
143} __attribute__((packed));
144
145struct pci_vtcon_control {
146	uint32_t id;
147	uint16_t event;
148	uint16_t value;
149} __attribute__((packed));
150
151struct pci_vtcon_console_resize {
152	uint16_t cols;
153	uint16_t rows;
154} __attribute__((packed));
155
156static void pci_vtcon_reset(void *);
157static void pci_vtcon_notify_rx(void *, struct vqueue_info *);
158static void pci_vtcon_notify_tx(void *, struct vqueue_info *);
159static int pci_vtcon_cfgread(void *, int, int, uint32_t *);
160static int pci_vtcon_cfgwrite(void *, int, int, uint32_t);
161static void pci_vtcon_neg_features(void *, uint64_t);
162static void pci_vtcon_sock_accept(int, enum ev_type,  void *);
163static void pci_vtcon_sock_rx(int, enum ev_type, void *);
164static void pci_vtcon_sock_tx(struct pci_vtcon_port *, void *, struct iovec *,
165    int);
166static void pci_vtcon_control_send(struct pci_vtcon_softc *,
167    struct pci_vtcon_control *, const void *, size_t);
168static void pci_vtcon_announce_port(struct pci_vtcon_port *);
169static void pci_vtcon_open_port(struct pci_vtcon_port *, bool);
170
171static struct virtio_consts vtcon_vi_consts = {
172	"vtcon",		/* our name */
173	VTCON_MAXQ,		/* we support VTCON_MAXQ virtqueues */
174	sizeof(struct pci_vtcon_config), /* config reg size */
175	pci_vtcon_reset,	/* reset */
176	NULL,			/* device-wide qnotify */
177	pci_vtcon_cfgread,	/* read virtio config */
178	pci_vtcon_cfgwrite,	/* write virtio config */
179	pci_vtcon_neg_features,	/* apply negotiated features */
180	VTCON_S_HOSTCAPS,	/* our capabilities */
181};
182
183
184static void
185pci_vtcon_reset(void *vsc)
186{
187	struct pci_vtcon_softc *sc;
188
189	sc = vsc;
190
191	DPRINTF(("vtcon: device reset requested!"));
192	vi_reset_dev(&sc->vsc_vs);
193}
194
195static void
196pci_vtcon_neg_features(void *vsc, uint64_t negotiated_features)
197{
198	struct pci_vtcon_softc *sc = vsc;
199
200	sc->vsc_features = negotiated_features;
201}
202
203static int
204pci_vtcon_cfgread(void *vsc, int offset, int size, uint32_t *retval)
205{
206	struct pci_vtcon_softc *sc = vsc;
207	void *ptr;
208
209	ptr = (uint8_t *)sc->vsc_config + offset;
210	memcpy(retval, ptr, size);
211	return (0);
212}
213
214static int
215pci_vtcon_cfgwrite(void *vsc, int offset, int size, uint32_t val)
216{
217
218	return (0);
219}
220
221static inline struct pci_vtcon_port *
222pci_vtcon_vq_to_port(struct pci_vtcon_softc *sc, struct vqueue_info *vq)
223{
224	uint16_t num = vq->vq_num;
225
226	if (num == 0 || num == 1)
227		return (&sc->vsc_ports[0]);
228
229	if (num == 2 || num == 3)
230		return (&sc->vsc_control_port);
231
232	return (&sc->vsc_ports[(num / 2) - 1]);
233}
234
235static inline struct vqueue_info *
236pci_vtcon_port_to_vq(struct pci_vtcon_port *port, bool tx_queue)
237{
238	int qnum;
239
240	qnum = tx_queue ? port->vsp_txq : port->vsp_rxq;
241	return (&port->vsp_sc->vsc_queues[qnum]);
242}
243
244static struct pci_vtcon_port *
245pci_vtcon_port_add(struct pci_vtcon_softc *sc, const char *name,
246    pci_vtcon_cb_t *cb, void *arg)
247{
248	struct pci_vtcon_port *port;
249
250	if (sc->vsc_nports == VTCON_MAXPORTS) {
251		errno = EBUSY;
252		return (NULL);
253	}
254
255	port = &sc->vsc_ports[sc->vsc_nports++];
256	port->vsp_id = sc->vsc_nports - 1;
257	port->vsp_sc = sc;
258	port->vsp_name = name;
259	port->vsp_cb = cb;
260	port->vsp_arg = arg;
261
262	if (port->vsp_id == 0) {
263		/* port0 */
264		port->vsp_txq = 0;
265		port->vsp_rxq = 1;
266	} else {
267		port->vsp_txq = sc->vsc_nports * 2;
268		port->vsp_rxq = port->vsp_txq + 1;
269	}
270
271	port->vsp_enabled = true;
272	return (port);
273}
274
275static int
276pci_vtcon_sock_add(struct pci_vtcon_softc *sc, const char *name,
277    const char *path)
278{
279	struct pci_vtcon_sock *sock;
280	struct sockaddr_un sun;
281	char *pathcopy;
282	int s = -1, fd = -1, error = 0;
283#ifndef WITHOUT_CAPSICUM
284	cap_rights_t rights;
285#endif
286
287	sock = calloc(1, sizeof(struct pci_vtcon_sock));
288	if (sock == NULL) {
289		error = -1;
290		goto out;
291	}
292
293	s = socket(AF_UNIX, SOCK_STREAM, 0);
294	if (s < 0) {
295		error = -1;
296		goto out;
297	}
298
299	pathcopy = strdup(path);
300	if (pathcopy == NULL) {
301		error = -1;
302		goto out;
303	}
304
305	fd = open(dirname(pathcopy), O_RDONLY | O_DIRECTORY);
306	if (fd < 0) {
307		free(pathcopy);
308		error = -1;
309		goto out;
310	}
311
312	sun.sun_family = AF_UNIX;
313	sun.sun_len = sizeof(struct sockaddr_un);
314	strcpy(pathcopy, path);
315	strlcpy(sun.sun_path, basename(pathcopy), sizeof(sun.sun_path));
316	free(pathcopy);
317
318	if (bindat(fd, s, (struct sockaddr *)&sun, sun.sun_len) < 0) {
319		error = -1;
320		goto out;
321	}
322
323	if (fcntl(s, F_SETFL, O_NONBLOCK) < 0) {
324		error = -1;
325		goto out;
326	}
327
328	if (listen(s, 1) < 0) {
329		error = -1;
330		goto out;
331	}
332
333#ifndef WITHOUT_CAPSICUM
334	cap_rights_init(&rights, CAP_ACCEPT, CAP_EVENT, CAP_READ, CAP_WRITE);
335	if (caph_rights_limit(s, &rights) == -1)
336		errx(EX_OSERR, "Unable to apply rights for sandbox");
337#endif
338
339	sock->vss_port = pci_vtcon_port_add(sc, name, pci_vtcon_sock_tx, sock);
340	if (sock->vss_port == NULL) {
341		error = -1;
342		goto out;
343	}
344
345	sock->vss_open = false;
346	sock->vss_conn_fd = -1;
347	sock->vss_server_fd = s;
348	sock->vss_server_evp = mevent_add(s, EVF_READ, pci_vtcon_sock_accept,
349	    sock);
350
351	if (sock->vss_server_evp == NULL) {
352		error = -1;
353		goto out;
354	}
355
356out:
357	if (fd != -1)
358		close(fd);
359
360	if (error != 0) {
361		if (s != -1)
362			close(s);
363		free(sock);
364	}
365
366	return (error);
367}
368
369static void
370pci_vtcon_sock_accept(int fd __unused, enum ev_type t __unused, void *arg)
371{
372	struct pci_vtcon_sock *sock = (struct pci_vtcon_sock *)arg;
373	int s;
374
375	s = accept(sock->vss_server_fd, NULL, NULL);
376	if (s < 0)
377		return;
378
379	if (sock->vss_open) {
380		close(s);
381		return;
382	}
383
384	sock->vss_open = true;
385	sock->vss_conn_fd = s;
386	sock->vss_conn_evp = mevent_add(s, EVF_READ, pci_vtcon_sock_rx, sock);
387
388	pci_vtcon_open_port(sock->vss_port, true);
389}
390
391static void
392pci_vtcon_sock_rx(int fd __unused, enum ev_type t __unused, void *arg)
393{
394	struct pci_vtcon_port *port;
395	struct pci_vtcon_sock *sock = (struct pci_vtcon_sock *)arg;
396	struct vqueue_info *vq;
397	struct iovec iov;
398	static char dummybuf[2048];
399	int len, n;
400	uint16_t idx;
401
402	port = sock->vss_port;
403	vq = pci_vtcon_port_to_vq(port, true);
404
405	if (!sock->vss_open || !port->vsp_rx_ready) {
406		len = read(sock->vss_conn_fd, dummybuf, sizeof(dummybuf));
407		if (len == 0)
408			goto close;
409
410		return;
411	}
412
413	if (!vq_has_descs(vq)) {
414		len = read(sock->vss_conn_fd, dummybuf, sizeof(dummybuf));
415		vq_endchains(vq, 1);
416		if (len == 0)
417			goto close;
418
419		return;
420	}
421
422	do {
423		n = vq_getchain(vq, &idx, &iov, 1, NULL);
424		len = readv(sock->vss_conn_fd, &iov, n);
425
426		if (len == 0 || (len < 0 && errno == EWOULDBLOCK)) {
427			vq_retchains(vq, 1);
428			vq_endchains(vq, 0);
429			if (len == 0)
430				goto close;
431
432			return;
433		}
434
435		vq_relchain(vq, idx, len);
436	} while (vq_has_descs(vq));
437
438	vq_endchains(vq, 1);
439
440close:
441	mevent_delete_close(sock->vss_conn_evp);
442	sock->vss_conn_fd = -1;
443	sock->vss_open = false;
444}
445
446static void
447pci_vtcon_sock_tx(struct pci_vtcon_port *port, void *arg, struct iovec *iov,
448    int niov)
449{
450	struct pci_vtcon_sock *sock;
451	int i, ret;
452
453	sock = (struct pci_vtcon_sock *)arg;
454
455	if (sock->vss_conn_fd == -1)
456		return;
457
458	for (i = 0; i < niov; i++) {
459		ret = stream_write(sock->vss_conn_fd, iov[i].iov_base,
460		    iov[i].iov_len);
461		if (ret <= 0)
462			break;
463	}
464
465	if (ret <= 0) {
466		mevent_delete_close(sock->vss_conn_evp);
467		sock->vss_conn_fd = -1;
468		sock->vss_open = false;
469	}
470}
471
472static void
473pci_vtcon_control_tx(struct pci_vtcon_port *port, void *arg, struct iovec *iov,
474    int niov)
475{
476	struct pci_vtcon_softc *sc;
477	struct pci_vtcon_port *tmp;
478	struct pci_vtcon_control resp, *ctrl;
479	int i;
480
481	assert(niov == 1);
482
483	sc = port->vsp_sc;
484	ctrl = (struct pci_vtcon_control *)iov->iov_base;
485
486	switch (ctrl->event) {
487	case VTCON_DEVICE_READY:
488		sc->vsc_ready = true;
489		/* set port ready events for registered ports */
490		for (i = 0; i < VTCON_MAXPORTS; i++) {
491			tmp = &sc->vsc_ports[i];
492			if (tmp->vsp_enabled)
493				pci_vtcon_announce_port(tmp);
494
495			if (tmp->vsp_open)
496				pci_vtcon_open_port(tmp, true);
497		}
498		break;
499
500	case VTCON_PORT_READY:
501		if (ctrl->id >= sc->vsc_nports) {
502			WPRINTF(("VTCON_PORT_READY event for unknown port %d",
503			    ctrl->id));
504			return;
505		}
506
507		tmp = &sc->vsc_ports[ctrl->id];
508		if (tmp->vsp_console) {
509			resp.event = VTCON_CONSOLE_PORT;
510			resp.id = ctrl->id;
511			resp.value = 1;
512			pci_vtcon_control_send(sc, &resp, NULL, 0);
513		}
514		break;
515	}
516}
517
518static void
519pci_vtcon_announce_port(struct pci_vtcon_port *port)
520{
521	struct pci_vtcon_control event;
522
523	event.id = port->vsp_id;
524	event.event = VTCON_DEVICE_ADD;
525	event.value = 1;
526	pci_vtcon_control_send(port->vsp_sc, &event, NULL, 0);
527
528	event.event = VTCON_PORT_NAME;
529	pci_vtcon_control_send(port->vsp_sc, &event, port->vsp_name,
530	    strlen(port->vsp_name));
531}
532
533static void
534pci_vtcon_open_port(struct pci_vtcon_port *port, bool open)
535{
536	struct pci_vtcon_control event;
537
538	if (!port->vsp_sc->vsc_ready) {
539		port->vsp_open = true;
540		return;
541	}
542
543	event.id = port->vsp_id;
544	event.event = VTCON_PORT_OPEN;
545	event.value = (int)open;
546	pci_vtcon_control_send(port->vsp_sc, &event, NULL, 0);
547}
548
549static void
550pci_vtcon_control_send(struct pci_vtcon_softc *sc,
551    struct pci_vtcon_control *ctrl, const void *payload, size_t len)
552{
553	struct vqueue_info *vq;
554	struct iovec iov;
555	uint16_t idx;
556	int n;
557
558	vq = pci_vtcon_port_to_vq(&sc->vsc_control_port, true);
559
560	if (!vq_has_descs(vq))
561		return;
562
563	n = vq_getchain(vq, &idx, &iov, 1, NULL);
564
565	assert(n == 1);
566
567	memcpy(iov.iov_base, ctrl, sizeof(struct pci_vtcon_control));
568	if (payload != NULL && len > 0)
569		memcpy(iov.iov_base + sizeof(struct pci_vtcon_control),
570		     payload, len);
571
572	vq_relchain(vq, idx, sizeof(struct pci_vtcon_control) + len);
573	vq_endchains(vq, 1);
574}
575
576
577static void
578pci_vtcon_notify_tx(void *vsc, struct vqueue_info *vq)
579{
580	struct pci_vtcon_softc *sc;
581	struct pci_vtcon_port *port;
582	struct iovec iov[1];
583	uint16_t idx, n;
584	uint16_t flags[8];
585
586	sc = vsc;
587	port = pci_vtcon_vq_to_port(sc, vq);
588
589	while (vq_has_descs(vq)) {
590		n = vq_getchain(vq, &idx, iov, 1, flags);
591		assert(n >= 1);
592		if (port != NULL)
593			port->vsp_cb(port, port->vsp_arg, iov, 1);
594
595		/*
596		 * Release this chain and handle more
597		 */
598		vq_relchain(vq, idx, 0);
599	}
600	vq_endchains(vq, 1);	/* Generate interrupt if appropriate. */
601}
602
603static void
604pci_vtcon_notify_rx(void *vsc, struct vqueue_info *vq)
605{
606	struct pci_vtcon_softc *sc;
607	struct pci_vtcon_port *port;
608
609	sc = vsc;
610	port = pci_vtcon_vq_to_port(sc, vq);
611
612	if (!port->vsp_rx_ready) {
613		port->vsp_rx_ready = 1;
614		vq_kick_disable(vq);
615	}
616}
617
618static int
619pci_vtcon_init(struct vmctx *ctx, struct pci_devinst *pi, char *opts)
620{
621	struct pci_vtcon_softc *sc;
622	char *portname = NULL;
623	char *portpath = NULL;
624	char *opt;
625	int i;
626
627	sc = calloc(1, sizeof(struct pci_vtcon_softc));
628	sc->vsc_config = calloc(1, sizeof(struct pci_vtcon_config));
629	sc->vsc_config->max_nr_ports = VTCON_MAXPORTS;
630	sc->vsc_config->cols = 80;
631	sc->vsc_config->rows = 25;
632
633	vi_softc_linkup(&sc->vsc_vs, &vtcon_vi_consts, sc, pi, sc->vsc_queues);
634	sc->vsc_vs.vs_mtx = &sc->vsc_mtx;
635
636	for (i = 0; i < VTCON_MAXQ; i++) {
637		sc->vsc_queues[i].vq_qsize = VTCON_RINGSZ;
638		sc->vsc_queues[i].vq_notify = i % 2 == 0
639		    ? pci_vtcon_notify_rx
640		    : pci_vtcon_notify_tx;
641	}
642
643	/* initialize config space */
644	pci_set_cfgdata16(pi, PCIR_DEVICE, VIRTIO_DEV_CONSOLE);
645	pci_set_cfgdata16(pi, PCIR_VENDOR, VIRTIO_VENDOR);
646	pci_set_cfgdata8(pi, PCIR_CLASS, PCIC_SIMPLECOMM);
647	pci_set_cfgdata16(pi, PCIR_SUBDEV_0, VIRTIO_TYPE_CONSOLE);
648	pci_set_cfgdata16(pi, PCIR_SUBVEND_0, VIRTIO_VENDOR);
649
650	if (vi_intr_init(&sc->vsc_vs, 1, fbsdrun_virtio_msix()))
651		return (1);
652	vi_set_io_bar(&sc->vsc_vs, 0);
653
654	/* create control port */
655	sc->vsc_control_port.vsp_sc = sc;
656	sc->vsc_control_port.vsp_txq = 2;
657	sc->vsc_control_port.vsp_rxq = 3;
658	sc->vsc_control_port.vsp_cb = pci_vtcon_control_tx;
659	sc->vsc_control_port.vsp_enabled = true;
660
661	while ((opt = strsep(&opts, ",")) != NULL) {
662		portname = strsep(&opt, "=");
663		portpath = opt;
664
665		/* create port */
666		if (pci_vtcon_sock_add(sc, portname, portpath) < 0) {
667			EPRINTLN("cannot create port %s: %s",
668			    portname, strerror(errno));
669			return (1);
670		}
671	}
672
673	return (0);
674}
675
676struct pci_devemu pci_de_vcon = {
677	.pe_emu =	"virtio-console",
678	.pe_init =	pci_vtcon_init,
679	.pe_barwrite =	vi_pci_write,
680	.pe_barread =	vi_pci_read
681};
682PCI_EMUL_SET(pci_de_vcon);
683