2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
4 * Copyright (c) 2015 Neel Natu <neel@freebsd.org>
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
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.
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
29 #include <sys/param.h>
30 __FBSDID("$FreeBSD$");
32 #include <sys/types.h>
36 #include <machine/vmm.h>
54 #define BOOTROM_SIZE (16 * 1024 * 1024) /* 16 MB */
57 * ROM region is 16 MB at the top of 4GB ("low") memory.
59 * The size is limited so it doesn't encroach into reserved MMIO space (e.g.,
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.
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. */
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
75 static struct bootrom_var_state {
80 } var = { NULL, 0, 0, CFI_BCS_READ_ARRAY };
83 * Emulate just those CFI basic commands that will convince EDK II
84 * that the Firmware Volume area is writable and persistent.
87 bootrom_var_mem_handler(struct vmctx *ctx, int vcpu, int dir, uint64_t addr,
88 int size, uint64_t *val, void *arg1, long arg2)
92 offset = addr - var.gpa;
93 if (offset + size > var.size || offset < 0 || offset + size <= offset)
96 if (dir == MEM_F_WRITE) {
98 case CFI_BCS_WRITE_BYTE:
99 memcpy(var.mmap + offset, val, size);
100 var.cmd = CFI_BCS_READ_ARRAY;
103 var.cmd = *(uint8_t *)val;
107 case CFI_BCS_CLEAR_STATUS:
108 case CFI_BCS_READ_STATUS:
109 memset(val, 0, size);
110 var.cmd = CFI_BCS_READ_ARRAY;
113 memcpy(val, var.mmap + offset, size);
121 init_bootrom(struct vmctx *ctx)
123 romptr = vm_create_devmem(ctx, VM_BOOTROM, "bootrom", BOOTROM_SIZE);
124 if (romptr == MAP_FAILED)
125 err(4, "%s: vm_create_devmem", __func__);
126 gpa_base = (1ULL << 32) - BOOTROM_SIZE;
127 gpa_allocbot = gpa_base;
128 gpa_alloctop = (1ULL << 32) - 1;
132 bootrom_alloc(struct vmctx *ctx, size_t len, int prot, int flags,
133 char **region_out, uint64_t *gpa_out)
135 static const int bootrom_valid_flags = BOOTROM_ALLOC_TOP;
140 if (flags & ~bootrom_valid_flags) {
141 warnx("%s: Invalid flags: %x", __func__,
142 flags & ~bootrom_valid_flags);
145 if (prot & ~_PROT_ALL) {
146 warnx("%s: Invalid protection: %x", __func__,
151 if (len == 0 || len > BOOTROM_SIZE) {
152 warnx("ROM size %zu is invalid", len);
155 if (len & PAGE_MASK) {
156 warnx("ROM size %zu is not a multiple of the page size",
161 if (flags & BOOTROM_ALLOC_TOP) {
162 gpa = (gpa_alloctop - len) + 1;
163 if (gpa < gpa_allocbot) {
164 warnx("No room for %zu ROM in bootrom region", len);
169 if (gpa > (gpa_alloctop - len) + 1) {
170 warnx("No room for %zu ROM in bootrom region", len);
175 segoff = gpa - gpa_base;
176 if (vm_mmap_memseg(ctx, gpa, VM_BOOTROM, segoff, len, prot) != 0) {
178 warn("%s: vm_mmap_mapseg", __func__);
182 if (flags & BOOTROM_ALLOC_TOP)
183 gpa_alloctop = gpa - 1;
185 gpa_allocbot = gpa + len;
187 *region_out = romptr + segoff;
194 bootrom_loadrom(struct vmctx *ctx, const nvlist_t *nvl)
198 off_t rom_size, var_size, total_size;
200 int fd, varfd, i, rv;
201 const char *bootrom, *varfile;
206 bootrom = get_config_value_node(nvl, "bootrom");
207 if (bootrom == NULL) {
212 * get_config_value_node may use a thread local buffer to return
213 * variables. So, when we query the second variable, the first variable
214 * might get overwritten. For that reason, the bootrom should be
217 romfile = strdup(bootrom);
218 if (romfile == NULL) {
222 fd = open(romfile, O_RDONLY);
224 EPRINTLN("Error opening bootrom \"%s\": %s",
225 romfile, strerror(errno));
229 if (fstat(fd, &sbuf) < 0) {
230 EPRINTLN("Could not fstat bootrom file \"%s\": %s", romfile,
235 rom_size = sbuf.st_size;
237 varfile = get_config_value_node(nvl, "bootvars");
239 if (varfile != NULL) {
240 varfd = open(varfile, O_RDWR);
242 fprintf(stderr, "Error opening bootrom variable file "
243 "\"%s\": %s\n", varfile, strerror(errno));
247 if (fstat(varfd, &sbuf) < 0) {
249 "Could not fstat bootrom variable file \"%s\": %s\n",
250 varfile, strerror(errno));
254 var_size = sbuf.st_size;
257 if (var_size > BOOTROM_SIZE ||
258 (var_size != 0 && var_size < PAGE_SIZE)) {
259 fprintf(stderr, "Invalid bootrom variable size %ld\n",
264 total_size = rom_size + var_size;
266 if (total_size > BOOTROM_SIZE) {
267 fprintf(stderr, "Invalid bootrom and variable aggregate size "
268 "%ld\n", total_size);
272 /* Map the bootrom into the guest address space */
273 if (bootrom_alloc(ctx, rom_size, PROT_READ | PROT_EXEC,
274 BOOTROM_ALLOC_TOP, &ptr, NULL) != 0) {
278 /* Read 'romfile' into the guest address space */
279 for (i = 0; i < rom_size / PAGE_SIZE; i++) {
280 rlen = read(fd, ptr + i * PAGE_SIZE, PAGE_SIZE);
281 if (rlen != PAGE_SIZE) {
282 EPRINTLN("Incomplete read of page %d of bootrom "
283 "file %s: %ld bytes", i, romfile, rlen);
289 var.mmap = mmap(NULL, var_size, PROT_READ | PROT_WRITE,
290 MAP_SHARED, varfd, 0);
291 if (var.mmap == MAP_FAILED)
294 var.gpa = (gpa_alloctop - var_size) + 1;
295 gpa_alloctop = var.gpa - 1;
296 rv = register_mem(&(struct mem_range){
297 .name = "bootrom variable",
299 .handler = bootrom_var_mem_handler,