stand/efi/gptboot/proto.c

   1 /*-
   2  * Copyright (c) 2019 Netflix, Inc
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  14  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  16  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  17  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  18  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  19  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  20  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  21  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  22  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  23  * SUCH DAMAGE.
  24  */
  25
  26 #include <sys/cdefs.h>
  27 __FBSDID("$FreeBSD$");
  28
  29 #include <sys/param.h>
  30 #include <machine/elf.h>
  31 #include <machine/stdarg.h>
  32 #include <stand.h>
  33
  34 #include <efi.h>
  35 #include <eficonsctl.h>
  36 #include <efichar.h>
  37
  38 #include "boot_module.h"
  39 #include "paths.h"
  40 #include "proto.h"
  41
  42 #include "gpt.h"
  43 #include <sys/gpt.h>
  44 static const uuid_t freebsd_ufs_uuid = GPT_ENT_TYPE_FREEBSD_UFS;
  45 static char secbuf[4096];
  46 static struct dsk dsk;
  47 static dev_info_t *devices = NULL;
  48 static dev_info_t *raw_device = NULL;
  49
  50 static EFI_GUID BlockIoProtocolGUID = BLOCK_IO_PROTOCOL;
  51 static EFI_GUID DevicePathGUID = DEVICE_PATH_PROTOCOL;
  52
  53 /*
  54  * Shim routine for the gpt code to read in the gpt table. The
  55  * devinfo is always going to be for the raw device.
  56  */
  57 int
  58 drvread(struct dsk *dskp, void *buf, daddr_t lba, unsigned nblk)
  59 {
  60         int size;
  61         EFI_STATUS status;
  62         dev_info_t *devinfo = (dev_info_t *)dskp->devinfo;
  63         EFI_BLOCK_IO *dev = devinfo->dev;
  64
  65         lba = lba / (dev->Media->BlockSize / DEV_BSIZE);
  66         size = nblk * DEV_BSIZE;
  67
  68         status = dev->ReadBlocks(dev, dev->Media->MediaId, lba, size, buf);
  69         if (status != EFI_SUCCESS) {
  70                 DPRINTF("dskread: failed dev: %p, id: %u, lba: %ju, size: %d, "
  71                     "status: %lu\n", devinfo->dev,
  72                     dev->Media->MediaId, (uintmax_t)lba, size,
  73                     EFI_ERROR_CODE(status));
  74                 return (-1);
  75         }
  76
  77         return (0);
  78 }
  79
  80 /*
  81  * Shim routine for the gpt code to write in the gpt table. The
  82  * devinfo is always going to be for the raw device.
  83  */
  84 int
  85 drvwrite(struct dsk *dskp, void *buf, daddr_t lba, unsigned nblk)
  86 {
  87         int size;
  88         EFI_STATUS status;
  89         dev_info_t *devinfo = (dev_info_t *)dskp->devinfo;
  90         EFI_BLOCK_IO *dev = devinfo->dev;
  91
  92         if (dev->Media->ReadOnly)
  93                 return -1;
  94
  95         lba = lba / (dev->Media->BlockSize / DEV_BSIZE);
  96         size = nblk * DEV_BSIZE;
  97
  98         status = dev->WriteBlocks(dev, dev->Media->MediaId, lba, size, buf);
  99         if (status != EFI_SUCCESS) {
 100                 DPRINTF("dskread: failed dev: %p, id: %u, lba: %ju, size: %d, "
 101                     "status: %lu\n", devinfo->dev,
 102                     dev->Media->MediaId, (uintmax_t)lba, size,
 103                     EFI_ERROR_CODE(status));
 104                 return (-1);
 105         }
 106
 107         return (0);
 108 }
 109
 110 /*
 111  * Return the number of LBAs the drive has.
 112  */
 113 uint64_t
 114 drvsize(struct dsk *dskp)
 115 {
 116         dev_info_t *devinfo = (dev_info_t *)dskp->devinfo;
 117         EFI_BLOCK_IO *dev = devinfo->dev;
 118
 119         return (dev->Media->LastBlock + 1);
 120 }
 121
 122 static int
 123 partition_number(EFI_DEVICE_PATH *devpath)
 124 {
 125         EFI_DEVICE_PATH *md;
 126         HARDDRIVE_DEVICE_PATH *hd;
 127
 128         md = efi_devpath_last_node(devpath);
 129         if (md == NULL)
 130                 return (-1);
 131         if (DevicePathSubType(md) != MEDIA_HARDDRIVE_DP)
 132                 return (-1);
 133         hd = (HARDDRIVE_DEVICE_PATH *)md;
 134         return (hd->PartitionNumber);
 135 }
 136
 137 /*
 138  * Find the raw partition for the imgpath and save it
 139  */
 140 static void
 141 probe_handle(EFI_HANDLE h, EFI_DEVICE_PATH *imgpath)
 142 {
 143         dev_info_t *devinfo;
 144         EFI_BLOCK_IO *blkio;
 145         EFI_DEVICE_PATH *devpath, *trimmed = NULL;
 146         EFI_STATUS status;
 147
 148         /* Figure out if we're dealing with an actual partition. */
 149         status = BS->HandleProtocol(h, &DevicePathGUID, (void **)&devpath);
 150         if (status != EFI_SUCCESS)
 151                 return;
 152 #ifdef EFI_DEBUG
 153         {
 154                 CHAR16 *text = efi_devpath_name(devpath);
 155                 DPRINTF("probing: %S ", text);
 156                 efi_free_devpath_name(text);
 157         }
 158 #endif
 159         /*
 160          * The RAW device is the same as the imgpath with the last
 161          * MEDIA_DEVICE bit trimmed off. imgpath will end with the
 162          * MEDIA_DEVICE for the ESP we booted off of.
 163          */
 164         if (!efi_devpath_same_disk(imgpath, devpath)) {
 165                 trimmed = efi_devpath_trim(imgpath);
 166                 if (!efi_devpath_match(trimmed, devpath)) {
 167                         free(trimmed);
 168                         DPRINTF("Not the same disk\n");
 169                         return;
 170                 }
 171         }
 172         status = BS->HandleProtocol(h, &BlockIoProtocolGUID, (void **)&blkio);
 173         if (status != EFI_SUCCESS) {
 174                 DPRINTF("Can't get the block I/O protocol block\n");
 175                 return;
 176         }
 177         devinfo = malloc(sizeof(*devinfo));
 178         if (devinfo == NULL) {
 179                 DPRINTF("Failed to allocate devinfo\n");
 180                 return;
 181         }
 182         devinfo->dev = blkio;
 183         devinfo->devpath = devpath;
 184         devinfo->devhandle = h;
 185         devinfo->preferred = 1;
 186         devinfo->next = NULL;
 187         devinfo->devdata = NULL;
 188         if (trimmed == NULL) {
 189                 DPRINTF("Found partition %d\n", partition_number(devpath));
 190                 add_device(&devices, devinfo);
 191         } else {
 192                 free(trimmed);
 193                 DPRINTF("Found raw device\n");
 194                 if (raw_device) {
 195                         printf(BOOTPROG": Found two raw devices, inconceivable?\n");
 196                         return;
 197                 }
 198                 raw_device = devinfo;
 199         }
 200 }
 201
 202 static void
 203 probe_handles(EFI_HANDLE *handles, UINTN nhandles, EFI_DEVICE_PATH *imgpath)
 204 {
 205         UINTN i;
 206
 207         for (i = 0; i < nhandles; i++)
 208                 probe_handle(handles[i], imgpath);
 209 }
 210
 211 static dev_info_t *
 212 find_partition(int part)
 213 {
 214         dev_info_t *dev;
 215
 216         if (part == 0)
 217                 return (NULL);
 218         for (dev = devices; dev != NULL; dev = dev->next)
 219                 if (partition_number(dev->devpath) == part)
 220                         break;
 221         return (dev);
 222 }
 223
 224 void
 225 choice_protocol(EFI_HANDLE *handles, UINTN nhandles, EFI_DEVICE_PATH *imgpath)
 226 {
 227         const boot_module_t *mod = &ufs_module;
 228         dev_info_t *bootdev;
 229         void *loaderbuf;
 230         size_t loadersize;
 231         int parts;
 232         const char *fn = PATH_LOADER_EFI;
 233
 234         /*
 235          * Probe the provided handles to find the partitions that
 236          * are on the same drive.
 237          */
 238         probe_handles(handles, nhandles, imgpath);
 239         dsk.devinfo = raw_device;
 240         if (dsk.devinfo == NULL) {
 241                 printf(BOOTPROG": unable to find raw disk to read gpt\n");
 242                 return;
 243         }
 244
 245         /*
 246          * Read in the GPT table, and then find the right partition.
 247          * gptread, gptfind and gptfaileboot are shared with the
 248          * BIOS version of the gptboot program.
 249          */
 250         if (gptread(&dsk, secbuf) == -1) {
 251                 printf(BOOTPROG ": unable to load GPT\n");
 252                 return;
 253         }
 254         // XXX:
 255         // real gptboot can parse a command line before trying this loop.
 256         // But since we don't parse anything at all, hard wire the partition
 257         // to be -1 (meaning look for the next one).
 258         parts = 0;
 259         while (gptfind(&freebsd_ufs_uuid, &dsk, -1) != -1) {
 260                 parts++;
 261                 bootdev = find_partition(dsk.part);
 262                 if (bootdev == NULL) {
 263                         printf(BOOTPROG": Can't find partition %d\n",
 264                             dsk.part);
 265                         goto next;
 266                 }
 267                 if (mod->load(fn, bootdev, &loaderbuf, &loadersize) !=
 268                     EFI_SUCCESS) {
 269                         printf(BOOTPROG": Can't load %s from partition %d\n",
 270                             fn, dsk.part);
 271                         goto next;
 272                 }
 273                 try_boot(mod, bootdev, loaderbuf, loadersize);
 274 next:
 275                 gptbootfailed(&dsk);
 276         }
 277         if (parts == 0)
 278                 printf("%s: no UFS partition was found\n", BOOTPROG);
 279 }