stand/efi/boot1/boot1.c

   1 /*-
   2  * Copyright (c) 1998 Robert Nordier
   3  * All rights reserved.
   4  * Copyright (c) 2001 Robert Drehmel
   5  * All rights reserved.
   6  * Copyright (c) 2014 Nathan Whitehorn
   7  * All rights reserved.
   8  * Copyright (c) 2015 Eric McCorkle
   9  * All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms are freely
  12  * permitted provided that the above copyright notice and this
  13  * paragraph and the following disclaimer are duplicated in all
  14  * such forms.
  15  *
  16  * This software is provided "AS IS" and without any express or
  17  * implied warranties, including, without limitation, the implied
  18  * warranties of merchantability and fitness for a particular
  19  * purpose.
  20  */
  21
  22 #include <sys/cdefs.h>
  23 __FBSDID("$FreeBSD$");
  24
  25 #include <sys/param.h>
  26 #include <machine/elf.h>
  27 #include <machine/stdarg.h>
  28 #include <stand.h>
  29
  30 #include <efi.h>
  31 #include <eficonsctl.h>
  32 #include <efichar.h>
  33
  34 #include "boot_module.h"
  35 #include "paths.h"
  36 #include "proto.h"
  37
  38 static void efi_panic(EFI_STATUS s, const char *fmt, ...) __dead2 __printflike(2, 3);
  39
  40 const boot_module_t *boot_modules[] =
  41 {
  42 #ifdef EFI_ZFS_BOOT
  43         &zfs_module,
  44 #endif
  45 #ifdef EFI_UFS_BOOT
  46         &ufs_module
  47 #endif
  48 };
  49 const UINTN num_boot_modules = nitems(boot_modules);
  50
  51 static EFI_GUID BlockIoProtocolGUID = BLOCK_IO_PROTOCOL;
  52 static EFI_GUID DevicePathGUID = DEVICE_PATH_PROTOCOL;
  53 static EFI_GUID LoadedImageGUID = LOADED_IMAGE_PROTOCOL;
  54 static EFI_GUID ConsoleControlGUID = EFI_CONSOLE_CONTROL_PROTOCOL_GUID;
  55
  56 /*
  57  * Provide Malloc / Free / Calloc backed by EFIs AllocatePool / FreePool which ensures
  58  * memory is correctly aligned avoiding EFI_INVALID_PARAMETER returns from
  59  * EFI methods.
  60  */
  61
  62 void *
  63 Malloc(size_t len, const char *file __unused, int line __unused)
  64 {
  65         void *out;
  66
  67         if (BS->AllocatePool(EfiLoaderData, len, &out) == EFI_SUCCESS)
  68                 return (out);
  69
  70         return (NULL);
  71 }
  72
  73 void
  74 Free(void *buf, const char *file __unused, int line __unused)
  75 {
  76         if (buf != NULL)
  77                 (void)BS->FreePool(buf);
  78 }
  79
  80 void *
  81 Calloc(size_t n1, size_t n2, const char *file, int line)
  82 {
  83         size_t bytes;
  84         void *res;
  85
  86         bytes = n1 * n2;
  87         if ((res = Malloc(bytes, file, line)) != NULL)
  88                 bzero(res, bytes);
  89
  90         return (res);
  91 }
  92
  93 /*
  94  * try_boot only returns if it fails to load the loader. If it succeeds
  95  * it simply boots, otherwise it returns the status of last EFI call.
  96  */
  97 EFI_STATUS
  98 try_boot(const boot_module_t *mod, dev_info_t *dev, void *loaderbuf, size_t loadersize)
  99 {
 100         size_t bufsize, cmdsize;
 101         void *buf;
 102         char *cmd;
 103         EFI_HANDLE loaderhandle;
 104         EFI_LOADED_IMAGE *loaded_image;
 105         EFI_STATUS status;
 106
 107         /*
 108          * Read in and parse the command line from /boot.config or /boot/config,
 109          * if present. We'll pass it the next stage via a simple ASCII
 110          * string. loader.efi has a hack for ASCII strings, so we'll use that to
 111          * keep the size down here. We only try to read the alternate file if
 112          * we get EFI_NOT_FOUND because all other errors mean that the boot_module
 113          * had troubles with the filesystem. We could return early, but we'll let
 114          * loading the actual kernel sort all that out. Since these files are
 115          * optional, we don't report errors in trying to read them.
 116          */
 117         cmd = NULL;
 118         cmdsize = 0;
 119         status = mod->load(PATH_DOTCONFIG, dev, &buf, &bufsize);
 120         if (status == EFI_NOT_FOUND)
 121                 status = mod->load(PATH_CONFIG, dev, &buf, &bufsize);
 122         if (status == EFI_SUCCESS) {
 123                 cmdsize = bufsize + 1;
 124                 cmd = malloc(cmdsize);
 125                 if (cmd == NULL)
 126                         goto errout;
 127                 memcpy(cmd, buf, bufsize);
 128                 cmd[bufsize] = '\0';
 129                 free(buf);
 130                 buf = NULL;
 131         }
 132
 133         if ((status = BS->LoadImage(TRUE, IH, efi_devpath_last_node(dev->devpath),
 134             loaderbuf, loadersize, &loaderhandle)) != EFI_SUCCESS) {
 135                 printf("Failed to load image provided by %s, size: %zu, (%lu)\n",
 136                      mod->name, loadersize, EFI_ERROR_CODE(status));
 137                 goto errout;
 138         }
 139
 140         if ((status = BS->HandleProtocol(loaderhandle, &LoadedImageGUID,
 141             (VOID**)&loaded_image)) != EFI_SUCCESS) {
 142                 printf("Failed to query LoadedImage provided by %s (%lu)\n",
 143                     mod->name, EFI_ERROR_CODE(status));
 144                 goto errout;
 145         }
 146
 147         if (cmd != NULL)
 148                 printf("    command args: %s\n", cmd);
 149
 150         loaded_image->DeviceHandle = dev->devhandle;
 151         loaded_image->LoadOptionsSize = cmdsize;
 152         loaded_image->LoadOptions = cmd;
 153
 154         DPRINTF("Starting '%s' in 5 seconds...", PATH_LOADER_EFI);
 155         DSTALL(1000000);
 156         DPRINTF(".");
 157         DSTALL(1000000);
 158         DPRINTF(".");
 159         DSTALL(1000000);
 160         DPRINTF(".");
 161         DSTALL(1000000);
 162         DPRINTF(".");
 163         DSTALL(1000000);
 164         DPRINTF(".\n");
 165
 166         if ((status = BS->StartImage(loaderhandle, NULL, NULL)) !=
 167             EFI_SUCCESS) {
 168                 printf("Failed to start image provided by %s (%lu)\n",
 169                     mod->name, EFI_ERROR_CODE(status));
 170                 loaded_image->LoadOptionsSize = 0;
 171                 loaded_image->LoadOptions = NULL;
 172         }
 173
 174 errout:
 175         if (cmd != NULL)
 176                 free(cmd);
 177         if (buf != NULL)
 178                 free(buf);
 179         if (loaderbuf != NULL)
 180                 free(loaderbuf);
 181
 182         return (status);
 183 }
 184
 185 EFI_STATUS
 186 efi_main(EFI_HANDLE Ximage, EFI_SYSTEM_TABLE *Xsystab)
 187 {
 188         EFI_HANDLE *handles;
 189         EFI_LOADED_IMAGE *img;
 190         EFI_DEVICE_PATH *imgpath;
 191         EFI_STATUS status;
 192         EFI_CONSOLE_CONTROL_PROTOCOL *ConsoleControl = NULL;
 193         SIMPLE_TEXT_OUTPUT_INTERFACE *conout = NULL;
 194         UINTN i, hsize, nhandles;
 195         CHAR16 *text;
 196
 197         /* Basic initialization*/
 198         ST = Xsystab;
 199         IH = Ximage;
 200         BS = ST->BootServices;
 201         RS = ST->RuntimeServices;
 202
 203         /* Set up the console, so printf works. */
 204         status = BS->LocateProtocol(&ConsoleControlGUID, NULL,
 205             (VOID **)&ConsoleControl);
 206         if (status == EFI_SUCCESS)
 207                 (void)ConsoleControl->SetMode(ConsoleControl,
 208                     EfiConsoleControlScreenText);
 209         /*
 210          * Reset the console enable the cursor. Later we'll choose a better
 211          * console size through GOP/UGA.
 212          */
 213         conout = ST->ConOut;
 214         conout->Reset(conout, TRUE);
 215         /* Explicitly set conout to mode 0, 80x25 */
 216         conout->SetMode(conout, 0);
 217         conout->EnableCursor(conout, TRUE);
 218         conout->ClearScreen(conout);
 219
 220         printf("\n>> FreeBSD EFI boot block\n");
 221         printf("   Loader path: %s\n\n", PATH_LOADER_EFI);
 222         printf("   Initializing modules:");
 223         for (i = 0; i < num_boot_modules; i++) {
 224                 printf(" %s", boot_modules[i]->name);
 225                 if (boot_modules[i]->init != NULL)
 226                         boot_modules[i]->init();
 227         }
 228         putchar('\n');
 229
 230         /* Fetch all the block I/O handles, we have to search through them later */
 231         hsize = 0;
 232         BS->LocateHandle(ByProtocol, &BlockIoProtocolGUID, NULL,
 233             &hsize, NULL);
 234         handles = malloc(hsize);
 235         if (handles == NULL)
 236                 efi_panic(EFI_OUT_OF_RESOURCES, "Failed to allocate %d handles\n",
 237                     hsize);
 238         status = BS->LocateHandle(ByProtocol, &BlockIoProtocolGUID,
 239             NULL, &hsize, handles);
 240         if (status != EFI_SUCCESS)
 241                 efi_panic(status, "Failed to get device handles\n");
 242         nhandles = hsize / sizeof(*handles);
 243
 244         /* Determine the devpath of our image so we can prefer it. */
 245         status = BS->HandleProtocol(IH, &LoadedImageGUID, (VOID**)&img);
 246         imgpath = NULL;
 247         if (status == EFI_SUCCESS) {
 248                 text = efi_devpath_name(img->FilePath);
 249                 if (text != NULL) {
 250                         printf("   Load Path: %S\n", text);
 251                         efi_setenv_freebsd_wcs("Boot1Path", text);
 252                         efi_free_devpath_name(text);
 253                 }
 254
 255                 status = BS->HandleProtocol(img->DeviceHandle, &DevicePathGUID,
 256                     (void **)&imgpath);
 257                 if (status != EFI_SUCCESS) {
 258                         DPRINTF("Failed to get image DevicePath (%lu)\n",
 259                             EFI_ERROR_CODE(status));
 260                 } else {
 261                         text = efi_devpath_name(imgpath);
 262                         if (text != NULL) {
 263                                 printf("   Load Device: %S\n", text);
 264                                 efi_setenv_freebsd_wcs("Boot1Dev", text);
 265                                 efi_free_devpath_name(text);
 266                         }
 267                 }
 268         }
 269
 270         choice_protocol(handles, nhandles, imgpath);
 271
 272         /* If we get here, we're out of luck... */
 273         efi_panic(EFI_LOAD_ERROR, "No bootable partitions found!");
 274 }
 275
 276 /*
 277  * add_device adds a device to the passed devinfo list.
 278  */
 279 void
 280 add_device(dev_info_t **devinfop, dev_info_t *devinfo)
 281 {
 282         dev_info_t *dev;
 283
 284         if (*devinfop == NULL) {
 285                 *devinfop = devinfo;
 286                 return;
 287         }
 288
 289         for (dev = *devinfop; dev->next != NULL; dev = dev->next)
 290                 ;
 291
 292         dev->next = devinfo;
 293 }
 294
 295 /*
 296  * OK. We totally give up. Exit back to EFI with a sensible status so
 297  * it can try the next option on the list.
 298  */
 299 static void
 300 efi_panic(EFI_STATUS s, const char *fmt, ...)
 301 {
 302         va_list ap;
 303
 304         printf("panic: ");
 305         va_start(ap, fmt);
 306         vprintf(fmt, ap);
 307         va_end(ap);
 308         printf("\n");
 309
 310         BS->Exit(IH, s, 0, NULL);
 311 }
 312
 313 void
 314 putchar(int c)
 315 {
 316         CHAR16 buf[2];
 317
 318         if (c == '\n') {
 319                 buf[0] = '\r';
 320                 buf[1] = 0;
 321                 ST->ConOut->OutputString(ST->ConOut, buf);
 322         }
 323         buf[0] = c;
 324         buf[1] = 0;
 325         ST->ConOut->OutputString(ST->ConOut, buf);
 326 }