xref: /freebsd/usr.sbin/bhyve/bootrom.c (revision 058ac3e8063366dafa634d9107642e12b038bf09)
1 /*-
2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3  *
4  * Copyright (c) 2015 Neel Natu <neel@freebsd.org>
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  * 2. Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  *
16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND
17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26  * SUCH DAMAGE.
27  */
28 
29 #include <sys/param.h>
30 __FBSDID("$FreeBSD$");
31 
32 #include <sys/types.h>
33 #include <sys/mman.h>
34 #include <sys/stat.h>
35 
36 #include <machine/vmm.h>
37 
38 #include <err.h>
39 #include <errno.h>
40 #include <fcntl.h>
41 #include <stdio.h>
42 #include <stdlib.h>
43 #include <string.h>
44 #include <unistd.h>
45 #include <stdbool.h>
46 
47 #include <vmmapi.h>
48 
49 #include "bhyverun.h"
50 #include "bootrom.h"
51 #include "debug.h"
52 #include "mem.h"
53 
54 #define	BOOTROM_SIZE	(16 * 1024 * 1024)	/* 16 MB */
55 
56 /*
57  * ROM region is 16 MB at the top of 4GB ("low") memory.
58  *
59  * The size is limited so it doesn't encroach into reserved MMIO space (e.g.,
60  * APIC, HPET, MSI).
61  *
62  * It is allocated in page-multiple blocks on a first-come first-serve basis,
63  * from high to low, during initialization, and does not change at runtime.
64  */
65 static char *romptr;	/* Pointer to userspace-mapped bootrom region. */
66 static vm_paddr_t gpa_base;	/* GPA of low end of region. */
67 static vm_paddr_t gpa_allocbot;	/* Low GPA of free region. */
68 static vm_paddr_t gpa_alloctop;	/* High GPA, minus 1, of free region. */
69 
70 #define CFI_BCS_WRITE_BYTE      0x10
71 #define CFI_BCS_CLEAR_STATUS    0x50
72 #define CFI_BCS_READ_STATUS     0x70
73 #define CFI_BCS_READ_ARRAY      0xff
74 
75 static struct bootrom_var_state {
76 	uint8_t		*mmap;
77 	uint64_t	gpa;
78 	off_t		size;
79 	uint8_t		cmd;
80 } var = { NULL, 0, 0, CFI_BCS_READ_ARRAY };
81 
82 /*
83  * Emulate just those CFI basic commands that will convince EDK II
84  * that the Firmware Volume area is writable and persistent.
85  */
86 static int
87 bootrom_var_mem_handler(struct vmctx *ctx __unused, int vcpu __unused, int dir,
88     uint64_t addr, int size, uint64_t *val, void *arg1 __unused,
89     long arg2 __unused)
90 {
91 	off_t offset;
92 
93 	offset = addr - var.gpa;
94 	if (offset + size > var.size || offset < 0 || offset + size <= offset)
95 		return (EINVAL);
96 
97 	if (dir == MEM_F_WRITE) {
98 		switch (var.cmd) {
99 		case CFI_BCS_WRITE_BYTE:
100 			memcpy(var.mmap + offset, val, size);
101 			var.cmd = CFI_BCS_READ_ARRAY;
102 			break;
103 		default:
104 			var.cmd = *(uint8_t *)val;
105 		}
106 	} else {
107 		switch (var.cmd) {
108 		case CFI_BCS_CLEAR_STATUS:
109 		case CFI_BCS_READ_STATUS:
110 			memset(val, 0, size);
111 			var.cmd = CFI_BCS_READ_ARRAY;
112 			break;
113 		default:
114 			memcpy(val, var.mmap + offset, size);
115 			break;
116 		}
117 	}
118 	return (0);
119 }
120 
121 void
122 init_bootrom(struct vmctx *ctx)
123 {
124 	romptr = vm_create_devmem(ctx, VM_BOOTROM, "bootrom", BOOTROM_SIZE);
125 	if (romptr == MAP_FAILED)
126 		err(4, "%s: vm_create_devmem", __func__);
127 	gpa_base = (1ULL << 32) - BOOTROM_SIZE;
128 	gpa_allocbot = gpa_base;
129 	gpa_alloctop = (1ULL << 32) - 1;
130 }
131 
132 int
133 bootrom_alloc(struct vmctx *ctx, size_t len, int prot, int flags,
134     char **region_out, uint64_t *gpa_out)
135 {
136 	static const int bootrom_valid_flags = BOOTROM_ALLOC_TOP;
137 
138 	vm_paddr_t gpa;
139 	vm_ooffset_t segoff;
140 
141 	if (flags & ~bootrom_valid_flags) {
142 		warnx("%s: Invalid flags: %x", __func__,
143 		    flags & ~bootrom_valid_flags);
144 		return (EINVAL);
145 	}
146 	if (prot & ~_PROT_ALL) {
147 		warnx("%s: Invalid protection: %x", __func__,
148 		    prot & ~_PROT_ALL);
149 		return (EINVAL);
150 	}
151 
152 	if (len == 0 || len > BOOTROM_SIZE) {
153 		warnx("ROM size %zu is invalid", len);
154 		return (EINVAL);
155 	}
156 	if (len & PAGE_MASK) {
157 		warnx("ROM size %zu is not a multiple of the page size",
158 		    len);
159 		return (EINVAL);
160 	}
161 
162 	if (flags & BOOTROM_ALLOC_TOP) {
163 		gpa = (gpa_alloctop - len) + 1;
164 		if (gpa < gpa_allocbot) {
165 			warnx("No room for %zu ROM in bootrom region", len);
166 			return (ENOMEM);
167 		}
168 	} else {
169 		gpa = gpa_allocbot;
170 		if (gpa > (gpa_alloctop - len) + 1) {
171 			warnx("No room for %zu ROM in bootrom region", len);
172 			return (ENOMEM);
173 		}
174 	}
175 
176 	segoff = gpa - gpa_base;
177 	if (vm_mmap_memseg(ctx, gpa, VM_BOOTROM, segoff, len, prot) != 0) {
178 		int serrno = errno;
179 		warn("%s: vm_mmap_mapseg", __func__);
180 		return (serrno);
181 	}
182 
183 	if (flags & BOOTROM_ALLOC_TOP)
184 		gpa_alloctop = gpa - 1;
185 	else
186 		gpa_allocbot = gpa + len;
187 
188 	*region_out = romptr + segoff;
189 	if (gpa_out != NULL)
190 		*gpa_out = gpa;
191 	return (0);
192 }
193 
194 int
195 bootrom_loadrom(struct vmctx *ctx, const nvlist_t *nvl)
196 {
197 	struct stat sbuf;
198 	ssize_t rlen;
199 	off_t rom_size, var_size, total_size;
200 	char *ptr, *romfile;
201 	int fd, varfd, i, rv;
202 	const char *bootrom, *varfile;
203 
204 	rv = -1;
205 	varfd = -1;
206 
207 	bootrom = get_config_value_node(nvl, "bootrom");
208 	if (bootrom == NULL) {
209 		return (-1);
210 	}
211 
212 	/*
213 	 * get_config_value_node may use a thread local buffer to return
214 	 * variables. So, when we query the second variable, the first variable
215 	 * might get overwritten. For that reason, the bootrom should be
216 	 * duplicated.
217 	 */
218 	romfile = strdup(bootrom);
219 	if (romfile == NULL) {
220 		return (-1);
221 	}
222 
223 	fd = open(romfile, O_RDONLY);
224 	if (fd < 0) {
225 		EPRINTLN("Error opening bootrom \"%s\": %s",
226 		    romfile, strerror(errno));
227 		goto done;
228 	}
229 
230 	if (fstat(fd, &sbuf) < 0) {
231 		EPRINTLN("Could not fstat bootrom file \"%s\": %s", romfile,
232 		    strerror(errno));
233 		goto done;
234 	}
235 
236 	rom_size = sbuf.st_size;
237 
238 	varfile = get_config_value_node(nvl, "bootvars");
239 	var_size = 0;
240 	if (varfile != NULL) {
241 		varfd = open(varfile, O_RDWR);
242 		if (varfd < 0) {
243 			fprintf(stderr, "Error opening bootrom variable file "
244 			    "\"%s\": %s\n", varfile, strerror(errno));
245 			goto done;
246 		}
247 
248 		if (fstat(varfd, &sbuf) < 0) {
249 			fprintf(stderr,
250 			    "Could not fstat bootrom variable file \"%s\": %s\n",
251 			    varfile, strerror(errno));
252 			goto done;
253 		}
254 
255 		var_size = sbuf.st_size;
256 	}
257 
258 	if (var_size > BOOTROM_SIZE ||
259 	    (var_size != 0 && var_size < PAGE_SIZE)) {
260 		fprintf(stderr, "Invalid bootrom variable size %ld\n",
261 		    var_size);
262 		goto done;
263 	}
264 
265 	total_size = rom_size + var_size;
266 
267 	if (total_size > BOOTROM_SIZE) {
268 		fprintf(stderr, "Invalid bootrom and variable aggregate size "
269 		    "%ld\n", total_size);
270 		goto done;
271 	}
272 
273 	/* Map the bootrom into the guest address space */
274 	if (bootrom_alloc(ctx, rom_size, PROT_READ | PROT_EXEC,
275 	    BOOTROM_ALLOC_TOP, &ptr, NULL) != 0) {
276 		goto done;
277 	}
278 
279 	/* Read 'romfile' into the guest address space */
280 	for (i = 0; i < rom_size / PAGE_SIZE; i++) {
281 		rlen = read(fd, ptr + i * PAGE_SIZE, PAGE_SIZE);
282 		if (rlen != PAGE_SIZE) {
283 			EPRINTLN("Incomplete read of page %d of bootrom "
284 			    "file %s: %ld bytes", i, romfile, rlen);
285 			goto done;
286 		}
287 	}
288 
289 	if (varfd >= 0) {
290 		var.mmap = mmap(NULL, var_size, PROT_READ | PROT_WRITE,
291 		    MAP_SHARED, varfd, 0);
292 		if (var.mmap == MAP_FAILED)
293 			goto done;
294 		var.size = var_size;
295 		var.gpa = (gpa_alloctop - var_size) + 1;
296 		gpa_alloctop = var.gpa - 1;
297 		rv = register_mem(&(struct mem_range){
298 		    .name = "bootrom variable",
299 		    .flags = MEM_F_RW,
300 		    .handler = bootrom_var_mem_handler,
301 		    .base = var.gpa,
302 		    .size = var.size,
303 		});
304 		if (rv != 0)
305 			goto done;
306 	}
307 
308 	rv = 0;
309 done:
310 	if (varfd >= 0)
311 		close(varfd);
312 	if (fd >= 0)
313 		close(fd);
314 	free(romfile);
315 	return (rv);
316 }
317