exec.c revision 1.22
1 /* $NetBSD: exec.c,v 1.22 2021/06/20 19:07:39 jmcneill Exp $ */ 2 3 /*- 4 * Copyright (c) 2019 Jason R. Thorpe 5 * Copyright (c) 2018 Jared McNeill <jmcneill (at) invisible.ca> 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 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 REGENTS 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 REGENTS 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 #include "efiboot.h" 31 #include "efifdt.h" 32 #include "efiacpi.h" 33 #include "efirng.h" 34 #include "module.h" 35 #include "overlay.h" 36 37 #include <sys/param.h> 38 #include <sys/reboot.h> 39 40 extern char twiddle_toggle; 41 42 u_long load_offset = 0; 43 44 #define FDT_SPACE (4 * 1024 * 1024) 45 #define FDT_ALIGN (2 * 1024 * 1024) 46 47 static EFI_PHYSICAL_ADDRESS initrd_addr, dtb_addr, rndseed_addr, efirng_addr; 48 static u_long initrd_size = 0, dtb_size = 0, rndseed_size = 0, efirng_size = 0; 49 50 static int 51 load_file(const char *path, u_long extra, bool quiet_errors, 52 EFI_PHYSICAL_ADDRESS *paddr, u_long *psize) 53 { 54 EFI_STATUS status; 55 struct stat st; 56 ssize_t len; 57 ssize_t expectedlen; 58 int fd; 59 60 if (strlen(path) == 0) 61 return 0; 62 63 fd = open(path, 0); 64 if (fd < 0) { 65 if (!quiet_errors) { 66 printf("boot: failed to open %s: %s\n", path, 67 strerror(errno)); 68 } 69 return errno; 70 } 71 if (fstat(fd, &st) < 0) { 72 printf("boot: failed to fstat %s: %s\n", path, strerror(errno)); 73 close(fd); 74 return errno; 75 } 76 if (st.st_size == 0) { 77 if (!quiet_errors) { 78 printf("boot: empty file %s\n", path); 79 } 80 close(fd); 81 return EINVAL; 82 } 83 84 expectedlen = st.st_size; 85 *psize = st.st_size + extra; 86 87 #ifdef EFIBOOT_ALLOCATE_MAX_ADDRESS 88 *paddr = EFIBOOT_ALLOCATE_MAX_ADDRESS; 89 status = uefi_call_wrapper(BS->AllocatePages, 4, AllocateMaxAddress, EfiLoaderData, 90 EFI_SIZE_TO_PAGES(*psize), paddr); 91 #else 92 *paddr = 0; 93 status = uefi_call_wrapper(BS->AllocatePages, 4, AllocateAnyPages, EfiLoaderData, 94 EFI_SIZE_TO_PAGES(*psize), paddr); 95 #endif 96 if (EFI_ERROR(status)) { 97 printf("Failed to allocate %lu bytes for %s (error %lu)\n", 98 *psize, path, (u_long)status); 99 close(fd); 100 *paddr = 0; 101 return ENOMEM; 102 } 103 104 printf("boot: loading %s ", path); 105 len = read(fd, (void *)(uintptr_t)*paddr, expectedlen); 106 close(fd); 107 108 if (len != expectedlen) { 109 if (len < 0) { 110 printf(": %s\n", strerror(errno)); 111 } else { 112 printf(": returned %ld (expected %ld)\n", len, 113 expectedlen); 114 } 115 return EIO; 116 } 117 118 printf("done.\n"); 119 120 efi_dcache_flush(*paddr, *psize); 121 122 return 0; 123 } 124 125 static void 126 apply_overlay(const char *path, void *dtbo) 127 { 128 129 if (!efi_fdt_overlay_is_compatible(dtbo)) { 130 printf("boot: %s: incompatible overlay\n", path); 131 return; 132 } 133 134 int fdterr; 135 136 if (efi_fdt_overlay_apply(dtbo, &fdterr) != 0) { 137 printf("boot: %s: error %d applying overlay\n", path, fdterr); 138 } 139 } 140 141 static void 142 apply_overlay_file(const char *path) 143 { 144 EFI_PHYSICAL_ADDRESS dtbo_addr; 145 u_long dtbo_size; 146 147 if (strlen(path) == 0) 148 return; 149 150 if (load_file(path, 0, false, &dtbo_addr, &dtbo_size) != 0 || 151 dtbo_addr == 0) { 152 /* Error messages have already been displayed. */ 153 goto out; 154 } 155 156 apply_overlay(path, (void *)(uintptr_t)dtbo_addr); 157 158 out: 159 if (dtbo_addr) { 160 uefi_call_wrapper(BS->FreePages, 2, dtbo_addr, 161 EFI_SIZE_TO_PAGES(dtbo_size)); 162 } 163 } 164 165 static void 166 load_fdt_overlays(void) 167 { 168 if (!dtoverlay_enabled) 169 return; 170 171 dtoverlay_foreach(apply_overlay_file); 172 } 173 174 static void 175 load_module(const char *module_name) 176 { 177 EFI_PHYSICAL_ADDRESS addr; 178 u_long size; 179 char path[PATH_MAX]; 180 181 snprintf(path, sizeof(path), "%s/%s/%s.kmod", module_prefix, 182 module_name, module_name); 183 184 if (load_file(path, 0, false, &addr, &size) != 0 || addr == 0 || size == 0) 185 return; 186 187 efi_fdt_module(module_name, (u_long)addr, size); 188 } 189 190 static void 191 load_modules(const char *kernel_name) 192 { 193 if (!module_enabled) 194 return; 195 196 module_init(kernel_name); 197 module_foreach(load_module); 198 } 199 200 static void 201 generate_efirng(void) 202 { 203 EFI_PHYSICAL_ADDRESS addr; 204 u_long size = EFI_PAGE_SIZE; 205 EFI_STATUS status; 206 207 /* Check whether the RNG is available before bothering. */ 208 if (!efi_rng_available()) 209 return; 210 211 /* 212 * Allocate a page. This is the smallest unit we can pass into 213 * the kernel conveniently. 214 */ 215 #ifdef EFIBOOT_ALLOCATE_MAX_ADDRESS 216 addr = EFIBOOT_ALLOCATE_MAX_ADDRESS; 217 status = uefi_call_wrapper(BS->AllocatePages, 4, AllocateMaxAddress, 218 EfiLoaderData, EFI_SIZE_TO_PAGES(size), &addr); 219 #else 220 addr = 0; 221 status = uefi_call_wrapper(BS->AllocatePages, 4, AllocateAnyPages, 222 EfiLoaderData, EFI_SIZE_TO_PAGES(size), &addr); 223 #endif 224 if (EFI_ERROR(status)) { 225 Print(L"Failed to allocate page for EFI RNG output: %r\n", 226 status); 227 return; 228 } 229 230 /* Fill the page with whatever the EFI RNG will do. */ 231 if (efi_rng((void *)(uintptr_t)addr, size)) { 232 uefi_call_wrapper(BS->FreePages, 2, addr, size); 233 return; 234 } 235 236 /* Success! */ 237 efirng_addr = addr; 238 efirng_size = size; 239 } 240 241 int 242 exec_netbsd(const char *fname, const char *args) 243 { 244 EFI_PHYSICAL_ADDRESS addr; 245 u_long marks[MARK_MAX], alloc_size; 246 EFI_STATUS status; 247 int fd, ohowto; 248 249 twiddle_toggle = 0; 250 251 load_file(get_initrd_path(), 0, false, &initrd_addr, &initrd_size); 252 load_file(get_dtb_path(), 0, false, &dtb_addr, &dtb_size); 253 generate_efirng(); 254 255 memset(marks, 0, sizeof(marks)); 256 ohowto = howto; 257 howto |= AB_SILENT; 258 fd = loadfile(fname, marks, COUNT_KERNEL | LOAD_NOTE); 259 howto = ohowto; 260 if (fd < 0) { 261 printf("boot: %s: %s\n", fname, strerror(errno)); 262 return EIO; 263 } 264 close(fd); 265 marks[MARK_END] = (((u_long) marks[MARK_END] + sizeof(int) - 1)) & -sizeof(int); 266 alloc_size = marks[MARK_END] - marks[MARK_START] + FDT_SPACE + EFIBOOT_ALIGN; 267 268 #ifdef EFIBOOT_ALLOCATE_MAX_ADDRESS 269 addr = EFIBOOT_ALLOCATE_MAX_ADDRESS; 270 status = uefi_call_wrapper(BS->AllocatePages, 4, AllocateMaxAddress, EfiLoaderData, 271 EFI_SIZE_TO_PAGES(alloc_size), &addr); 272 #else 273 addr = 0; 274 status = uefi_call_wrapper(BS->AllocatePages, 4, AllocateAnyPages, EfiLoaderData, 275 EFI_SIZE_TO_PAGES(alloc_size), &addr); 276 #endif 277 if (EFI_ERROR(status)) { 278 printf("Failed to allocate %lu bytes for kernel image (error %lu)\n", 279 alloc_size, (u_long)status); 280 return ENOMEM; 281 } 282 283 memset(marks, 0, sizeof(marks)); 284 load_offset = (addr + EFIBOOT_ALIGN - 1) & -EFIBOOT_ALIGN; 285 fd = loadfile(fname, marks, LOAD_KERNEL); 286 if (fd < 0) { 287 printf("boot: %s: %s\n", fname, strerror(errno)); 288 goto cleanup; 289 } 290 close(fd); 291 load_offset = 0; 292 293 #ifdef EFIBOOT_ACPI 294 /* ACPI support only works for little endian kernels */ 295 efi_acpi_enable(netbsd_elf_data == ELFDATA2LSB); 296 297 if (efi_acpi_available() && efi_acpi_enabled()) { 298 efi_acpi_create_fdt(); 299 } else 300 #endif 301 if (dtb_addr && efi_fdt_set_data((void *)(uintptr_t)dtb_addr) != 0) { 302 printf("boot: invalid DTB data\n"); 303 goto cleanup; 304 } 305 306 if (efi_fdt_size() > 0) { 307 /* 308 * Load the rndseed as late as possible -- after we 309 * have committed to using fdt and executing this 310 * kernel -- so that it doesn't hang around in memory 311 * if we have to bail or the kernel won't use it. 312 */ 313 load_file(get_rndseed_path(), 0, false, 314 &rndseed_addr, &rndseed_size); 315 316 efi_fdt_init((marks[MARK_END] + FDT_ALIGN - 1) & -FDT_ALIGN, FDT_ALIGN); 317 load_modules(fname); 318 load_fdt_overlays(); 319 efi_fdt_initrd(initrd_addr, initrd_size); 320 efi_fdt_rndseed(rndseed_addr, rndseed_size); 321 efi_fdt_efirng(efirng_addr, efirng_size); 322 efi_fdt_bootargs(args); 323 efi_fdt_system_table(); 324 efi_fdt_gop(); 325 efi_fdt_memory_map(); 326 } 327 328 efi_cleanup(); 329 330 if (efi_fdt_size() > 0) { 331 efi_fdt_fini(); 332 } 333 334 efi_boot_kernel(marks); 335 336 /* This should not happen.. */ 337 printf("boot returned\n"); 338 339 cleanup: 340 uefi_call_wrapper(BS->FreePages, 2, addr, EFI_SIZE_TO_PAGES(alloc_size)); 341 if (initrd_addr) { 342 uefi_call_wrapper(BS->FreePages, 2, initrd_addr, EFI_SIZE_TO_PAGES(initrd_size)); 343 initrd_addr = 0; 344 initrd_size = 0; 345 } 346 if (dtb_addr) { 347 uefi_call_wrapper(BS->FreePages, 2, dtb_addr, EFI_SIZE_TO_PAGES(dtb_size)); 348 dtb_addr = 0; 349 dtb_size = 0; 350 } 351 return EIO; 352 } 353
Indexes created Fri Sep 26 20:09:58 GMT 2025