1/*-
2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3 *
4 * Copyright (c) 2014 Nahanni Systems Inc.
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 *    notice, this list of conditions and the following disclaimer
12 *    in this position and unchanged.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 *    notice, this list of conditions and the following disclaimer in the
15 *    documentation and/or other materials provided with the distribution.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * SUCH DAMAGE.
28 */
29
30/*
31 * virtio entropy device emulation.
32 * Randomness is sourced from /dev/random which does not block
33 * once it has been seeded at bootup.
34 */
35
36#include <sys/cdefs.h>
37__FBSDID("$FreeBSD$");
38
39#include <sys/param.h>
40#ifndef WITHOUT_CAPSICUM
41#include <sys/capsicum.h>
42#endif
43#include <sys/linker_set.h>
44#include <sys/uio.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 <string.h>
55#include <unistd.h>
56#include <assert.h>
57#include <pthread.h>
58#include <sysexits.h>
59
60#include "bhyverun.h"
61#include "debug.h"
62#include "pci_emul.h"
63#include "virtio.h"
64
65#define VTRND_RINGSZ	64
66
67
68static int pci_vtrnd_debug;
69#define DPRINTF(params) if (pci_vtrnd_debug) PRINTLN params
70#define WPRINTF(params) PRINTLN params
71
72/*
73 * Per-device softc
74 */
75struct pci_vtrnd_softc {
76	struct virtio_softc vrsc_vs;
77	struct vqueue_info  vrsc_vq;
78	pthread_mutex_t     vrsc_mtx;
79	uint64_t            vrsc_cfg;
80	int                 vrsc_fd;
81};
82
83static void pci_vtrnd_reset(void *);
84static void pci_vtrnd_notify(void *, struct vqueue_info *);
85
86static struct virtio_consts vtrnd_vi_consts = {
87	"vtrnd",		/* our name */
88	1,			/* we support 1 virtqueue */
89	0,			/* config reg size */
90	pci_vtrnd_reset,	/* reset */
91	pci_vtrnd_notify,	/* device-wide qnotify */
92	NULL,			/* read virtio config */
93	NULL,			/* write virtio config */
94	NULL,			/* apply negotiated features */
95	0,			/* our capabilities */
96};
97
98
99static void
100pci_vtrnd_reset(void *vsc)
101{
102	struct pci_vtrnd_softc *sc;
103
104	sc = vsc;
105
106	DPRINTF(("vtrnd: device reset requested !"));
107	vi_reset_dev(&sc->vrsc_vs);
108}
109
110
111static void
112pci_vtrnd_notify(void *vsc, struct vqueue_info *vq)
113{
114	struct iovec iov;
115	struct pci_vtrnd_softc *sc;
116	int len;
117	uint16_t idx;
118
119	sc = vsc;
120
121	if (sc->vrsc_fd < 0) {
122		vq_endchains(vq, 0);
123		return;
124	}
125
126	while (vq_has_descs(vq)) {
127		vq_getchain(vq, &idx, &iov, 1, NULL);
128
129		len = read(sc->vrsc_fd, iov.iov_base, iov.iov_len);
130
131		DPRINTF(("vtrnd: vtrnd_notify(): %d", len));
132
133		/* Catastrophe if unable to read from /dev/random */
134		assert(len > 0);
135
136		/*
137		 * Release this chain and handle more
138		 */
139		vq_relchain(vq, idx, len);
140	}
141	vq_endchains(vq, 1);	/* Generate interrupt if appropriate. */
142}
143
144
145static int
146pci_vtrnd_init(struct vmctx *ctx, struct pci_devinst *pi, char *opts)
147{
148	struct pci_vtrnd_softc *sc;
149	int fd;
150	int len;
151	uint8_t v;
152#ifndef WITHOUT_CAPSICUM
153	cap_rights_t rights;
154#endif
155
156	/*
157	 * Should always be able to open /dev/random.
158	 */
159	fd = open("/dev/random", O_RDONLY | O_NONBLOCK);
160
161	assert(fd >= 0);
162
163#ifndef WITHOUT_CAPSICUM
164	cap_rights_init(&rights, CAP_READ);
165	if (caph_rights_limit(fd, &rights) == -1)
166		errx(EX_OSERR, "Unable to apply rights for sandbox");
167#endif
168
169	/*
170	 * Check that device is seeded and non-blocking.
171	 */
172	len = read(fd, &v, sizeof(v));
173	if (len <= 0) {
174		WPRINTF(("vtrnd: /dev/random not ready, read(): %d", len));
175		close(fd);
176		return (1);
177	}
178
179	sc = calloc(1, sizeof(struct pci_vtrnd_softc));
180
181	vi_softc_linkup(&sc->vrsc_vs, &vtrnd_vi_consts, sc, pi, &sc->vrsc_vq);
182	sc->vrsc_vs.vs_mtx = &sc->vrsc_mtx;
183
184	sc->vrsc_vq.vq_qsize = VTRND_RINGSZ;
185
186	/* keep /dev/random opened while emulating */
187	sc->vrsc_fd = fd;
188
189	/* initialize config space */
190	pci_set_cfgdata16(pi, PCIR_DEVICE, VIRTIO_DEV_RANDOM);
191	pci_set_cfgdata16(pi, PCIR_VENDOR, VIRTIO_VENDOR);
192	pci_set_cfgdata8(pi, PCIR_CLASS, PCIC_CRYPTO);
193	pci_set_cfgdata16(pi, PCIR_SUBDEV_0, VIRTIO_TYPE_ENTROPY);
194	pci_set_cfgdata16(pi, PCIR_SUBVEND_0, VIRTIO_VENDOR);
195
196	if (vi_intr_init(&sc->vrsc_vs, 1, fbsdrun_virtio_msix()))
197		return (1);
198	vi_set_io_bar(&sc->vrsc_vs, 0);
199
200	return (0);
201}
202
203
204struct pci_devemu pci_de_vrnd = {
205	.pe_emu =	"virtio-rnd",
206	.pe_init =	pci_vtrnd_init,
207	.pe_barwrite =	vi_pci_write,
208	.pe_barread =	vi_pci_read
209};
210PCI_EMUL_SET(pci_de_vrnd);
211