1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause
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
38 #include <sys/param.h>
39 #ifndef WITHOUT_CAPSICUM
40 #include <sys/capsicum.h>
41 #endif
42 #include <sys/linker_set.h>
43 #include <sys/uio.h>
44
45 #ifndef WITHOUT_CAPSICUM
46 #include <capsicum_helpers.h>
47 #endif
48 #include <err.h>
49 #include <errno.h>
50 #include <fcntl.h>
51 #include <stdio.h>
52 #include <stdlib.h>
53 #include <string.h>
54 #include <unistd.h>
55 #include <assert.h>
56 #include <pthread.h>
57 #include <sysexits.h>
58
59 #include "bhyverun.h"
60 #include "debug.h"
61 #include "pci_emul.h"
62 #include "virtio.h"
63
64 #define VTRND_RINGSZ 64
65
66
67 static int pci_vtrnd_debug;
68 #define DPRINTF(params) if (pci_vtrnd_debug) PRINTLN params
69 #define WPRINTF(params) PRINTLN params
70
71 /*
72 * Per-device softc
73 */
74 struct pci_vtrnd_softc {
75 struct virtio_softc vrsc_vs;
76 struct vqueue_info vrsc_vq;
77 pthread_mutex_t vrsc_mtx;
78 uint64_t vrsc_cfg;
79 int vrsc_fd;
80 };
81
82 static void pci_vtrnd_reset(void *);
83 static void pci_vtrnd_notify(void *, struct vqueue_info *);
84
85 static struct virtio_consts vtrnd_vi_consts = {
86 .vc_name = "vtrnd",
87 .vc_nvq = 1,
88 .vc_cfgsize = 0,
89 .vc_reset = pci_vtrnd_reset,
90 .vc_qnotify = pci_vtrnd_notify,
91 .vc_hv_caps = 0,
92 };
93
94 static void
pci_vtrnd_reset(void * vsc)95 pci_vtrnd_reset(void *vsc)
96 {
97 struct pci_vtrnd_softc *sc;
98
99 sc = vsc;
100
101 DPRINTF(("vtrnd: device reset requested !"));
102 vi_reset_dev(&sc->vrsc_vs);
103 }
104
105
106 static void
pci_vtrnd_notify(void * vsc,struct vqueue_info * vq)107 pci_vtrnd_notify(void *vsc, struct vqueue_info *vq)
108 {
109 struct iovec iov;
110 struct pci_vtrnd_softc *sc;
111 struct vi_req req;
112 int len, n;
113
114 sc = vsc;
115
116 if (sc->vrsc_fd < 0) {
117 vq_endchains(vq, 0);
118 return;
119 }
120
121 while (vq_has_descs(vq)) {
122 n = vq_getchain(vq, &iov, 1, &req);
123 assert(n == 1);
124
125 len = read(sc->vrsc_fd, iov.iov_base, iov.iov_len);
126
127 DPRINTF(("vtrnd: vtrnd_notify(): %d", len));
128
129 /* Catastrophe if unable to read from /dev/random */
130 assert(len > 0);
131
132 /*
133 * Release this chain and handle more
134 */
135 vq_relchain(vq, req.idx, len);
136 }
137 vq_endchains(vq, 1); /* Generate interrupt if appropriate. */
138 }
139
140
141 static int
pci_vtrnd_init(struct pci_devinst * pi,nvlist_t * nvl __unused)142 pci_vtrnd_init(struct pci_devinst *pi, nvlist_t *nvl __unused)
143 {
144 struct pci_vtrnd_softc *sc;
145 int fd;
146 int len;
147 uint8_t v;
148 #ifndef WITHOUT_CAPSICUM
149 cap_rights_t rights;
150 #endif
151
152 /*
153 * Should always be able to open /dev/random.
154 */
155 fd = open("/dev/random", O_RDONLY | O_NONBLOCK);
156
157 assert(fd >= 0);
158
159 #ifndef WITHOUT_CAPSICUM
160 cap_rights_init(&rights, CAP_READ);
161 if (caph_rights_limit(fd, &rights) == -1)
162 errx(EX_OSERR, "Unable to apply rights for sandbox");
163 #endif
164
165 /*
166 * Check that device is seeded and non-blocking.
167 */
168 len = read(fd, &v, sizeof(v));
169 if (len <= 0) {
170 WPRINTF(("vtrnd: /dev/random not ready, read(): %d", len));
171 close(fd);
172 return (1);
173 }
174
175 sc = calloc(1, sizeof(struct pci_vtrnd_softc));
176
177 pthread_mutex_init(&sc->vrsc_mtx, NULL);
178
179 vi_softc_linkup(&sc->vrsc_vs, &vtrnd_vi_consts, sc, pi, &sc->vrsc_vq);
180 sc->vrsc_vs.vs_mtx = &sc->vrsc_mtx;
181
182 sc->vrsc_vq.vq_qsize = VTRND_RINGSZ;
183
184 /* keep /dev/random opened while emulating */
185 sc->vrsc_fd = fd;
186
187 /* initialize config space */
188 pci_set_cfgdata16(pi, PCIR_DEVICE, VIRTIO_DEV_RANDOM);
189 pci_set_cfgdata16(pi, PCIR_VENDOR, VIRTIO_VENDOR);
190 pci_set_cfgdata8(pi, PCIR_CLASS, PCIC_CRYPTO);
191 pci_set_cfgdata16(pi, PCIR_SUBDEV_0, VIRTIO_ID_ENTROPY);
192 pci_set_cfgdata16(pi, PCIR_SUBVEND_0, VIRTIO_VENDOR);
193
194 if (vi_intr_init(&sc->vrsc_vs, 1, fbsdrun_virtio_msix()))
195 return (1);
196 vi_set_io_bar(&sc->vrsc_vs, 0);
197
198 return (0);
199 }
200
201
202 static const struct pci_devemu pci_de_vrnd = {
203 .pe_emu = "virtio-rnd",
204 .pe_init = pci_vtrnd_init,
205 .pe_barwrite = vi_pci_write,
206 .pe_barread = vi_pci_read,
207 };
208 PCI_EMUL_SET(pci_de_vrnd);
209