lib/efi_loader/efi_disk.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  *  EFI application disk support
   4  *
   5  *  Copyright (c) 2016 Alexander Graf
   6  */
   7
   8 #include <common.h>
   9 #include <blk.h>
  10 #include <dm.h>
  11 #include <efi_loader.h>
  12 #include <part.h>
  13 #include <malloc.h>
  14
  15 const efi_guid_t efi_block_io_guid = EFI_BLOCK_IO_PROTOCOL_GUID;
  16
  17 /**
  18  * struct efi_disk_obj - EFI disk object
  19  *
  20  * @header:     EFI object header
  21  * @ops:        EFI disk I/O protocol interface
  22  * @ifname:     interface name for block device
  23  * @dev_index:  device index of block device
  24  * @media:      block I/O media information
  25  * @dp:         device path to the block device
  26  * @part:       partition
  27  * @volume:     simple file system protocol of the partition
  28  * @offset:     offset into disk for simple partition
  29  * @desc:       internal block device descriptor
  30  */
  31 struct efi_disk_obj {
  32         struct efi_object header;
  33         struct efi_block_io ops;
  34         const char *ifname;
  35         int dev_index;
  36         struct efi_block_io_media media;
  37         struct efi_device_path *dp;
  38         unsigned int part;
  39         struct efi_simple_file_system_protocol *volume;
  40         lbaint_t offset;
  41         struct blk_desc *desc;
  42 };
  43
  44 /**
  45  * efi_disk_reset() - reset block device
  46  *
  47  * This function implements the Reset service of the EFI_BLOCK_IO_PROTOCOL.
  48  *
  49  * As U-Boot's block devices do not have a reset function simply return
  50  * EFI_SUCCESS.
  51  *
  52  * See the Unified Extensible Firmware Interface (UEFI) specification for
  53  * details.
  54  *
  55  * @this:                       pointer to the BLOCK_IO_PROTOCOL
  56  * @extended_verification:      extended verification
  57  * Return:                      status code
  58  */
  59 static efi_status_t EFIAPI efi_disk_reset(struct efi_block_io *this,
  60                         char extended_verification)
  61 {
  62         EFI_ENTRY("%p, %x", this, extended_verification);
  63         return EFI_EXIT(EFI_SUCCESS);
  64 }
  65
  66 enum efi_disk_direction {
  67         EFI_DISK_READ,
  68         EFI_DISK_WRITE,
  69 };
  70
  71 static efi_status_t efi_disk_rw_blocks(struct efi_block_io *this,
  72                         u32 media_id, u64 lba, unsigned long buffer_size,
  73                         void *buffer, enum efi_disk_direction direction)
  74 {
  75         struct efi_disk_obj *diskobj;
  76         struct blk_desc *desc;
  77         int blksz;
  78         int blocks;
  79         unsigned long n;
  80
  81         diskobj = container_of(this, struct efi_disk_obj, ops);
  82         desc = (struct blk_desc *) diskobj->desc;
  83         blksz = desc->blksz;
  84         blocks = buffer_size / blksz;
  85         lba += diskobj->offset;
  86
  87         EFI_PRINT("blocks=%x lba=%llx blksz=%x dir=%d\n",
  88                   blocks, lba, blksz, direction);
  89
  90         /* We only support full block access */
  91         if (buffer_size & (blksz - 1))
  92                 return EFI_BAD_BUFFER_SIZE;
  93
  94         if (direction == EFI_DISK_READ)
  95                 n = blk_dread(desc, lba, blocks, buffer);
  96         else
  97                 n = blk_dwrite(desc, lba, blocks, buffer);
  98
  99         /* We don't do interrupts, so check for timers cooperatively */
 100         efi_timer_check();
 101
 102         EFI_PRINT("n=%lx blocks=%x\n", n, blocks);
 103
 104         if (n != blocks)
 105                 return EFI_DEVICE_ERROR;
 106
 107         return EFI_SUCCESS;
 108 }
 109
 110 static efi_status_t EFIAPI efi_disk_read_blocks(struct efi_block_io *this,
 111                         u32 media_id, u64 lba, efi_uintn_t buffer_size,
 112                         void *buffer)
 113 {
 114         void *real_buffer = buffer;
 115         efi_status_t r;
 116
 117         if (!this)
 118                 return EFI_INVALID_PARAMETER;
 119         /* TODO: check for media changes */
 120         if (media_id != this->media->media_id)
 121                 return EFI_MEDIA_CHANGED;
 122         if (!this->media->media_present)
 123                 return EFI_NO_MEDIA;
 124         /* media->io_align is a power of 2 */
 125         if ((uintptr_t)buffer & (this->media->io_align - 1))
 126                 return EFI_INVALID_PARAMETER;
 127         if (lba * this->media->block_size + buffer_size >
 128             this->media->last_block * this->media->block_size)
 129                 return EFI_INVALID_PARAMETER;
 130
 131 #ifdef CONFIG_EFI_LOADER_BOUNCE_BUFFER
 132         if (buffer_size > EFI_LOADER_BOUNCE_BUFFER_SIZE) {
 133                 r = efi_disk_read_blocks(this, media_id, lba,
 134                         EFI_LOADER_BOUNCE_BUFFER_SIZE, buffer);
 135                 if (r != EFI_SUCCESS)
 136                         return r;
 137                 return efi_disk_read_blocks(this, media_id, lba +
 138                         EFI_LOADER_BOUNCE_BUFFER_SIZE / this->media->block_size,
 139                         buffer_size - EFI_LOADER_BOUNCE_BUFFER_SIZE,
 140                         buffer + EFI_LOADER_BOUNCE_BUFFER_SIZE);
 141         }
 142
 143         real_buffer = efi_bounce_buffer;
 144 #endif
 145
 146         EFI_ENTRY("%p, %x, %llx, %zx, %p", this, media_id, lba,
 147                   buffer_size, buffer);
 148
 149         r = efi_disk_rw_blocks(this, media_id, lba, buffer_size, real_buffer,
 150                                EFI_DISK_READ);
 151
 152         /* Copy from bounce buffer to real buffer if necessary */
 153         if ((r == EFI_SUCCESS) && (real_buffer != buffer))
 154                 memcpy(buffer, real_buffer, buffer_size);
 155
 156         return EFI_EXIT(r);
 157 }
 158
 159 static efi_status_t EFIAPI efi_disk_write_blocks(struct efi_block_io *this,
 160                         u32 media_id, u64 lba, efi_uintn_t buffer_size,
 161                         void *buffer)
 162 {
 163         void *real_buffer = buffer;
 164         efi_status_t r;
 165
 166         if (!this)
 167                 return EFI_INVALID_PARAMETER;
 168         if (this->media->read_only)
 169                 return EFI_WRITE_PROTECTED;
 170         /* TODO: check for media changes */
 171         if (media_id != this->media->media_id)
 172                 return EFI_MEDIA_CHANGED;
 173         if (!this->media->media_present)
 174                 return EFI_NO_MEDIA;
 175         /* media->io_align is a power of 2 */
 176         if ((uintptr_t)buffer & (this->media->io_align - 1))
 177                 return EFI_INVALID_PARAMETER;
 178         if (lba * this->media->block_size + buffer_size >
 179             this->media->last_block * this->media->block_size)
 180                 return EFI_INVALID_PARAMETER;
 181
 182 #ifdef CONFIG_EFI_LOADER_BOUNCE_BUFFER
 183         if (buffer_size > EFI_LOADER_BOUNCE_BUFFER_SIZE) {
 184                 r = efi_disk_write_blocks(this, media_id, lba,
 185                         EFI_LOADER_BOUNCE_BUFFER_SIZE, buffer);
 186                 if (r != EFI_SUCCESS)
 187                         return r;
 188                 return efi_disk_write_blocks(this, media_id, lba +
 189                         EFI_LOADER_BOUNCE_BUFFER_SIZE / this->media->block_size,
 190                         buffer_size - EFI_LOADER_BOUNCE_BUFFER_SIZE,
 191                         buffer + EFI_LOADER_BOUNCE_BUFFER_SIZE);
 192         }
 193
 194         real_buffer = efi_bounce_buffer;
 195 #endif
 196
 197         EFI_ENTRY("%p, %x, %llx, %zx, %p", this, media_id, lba,
 198                   buffer_size, buffer);
 199
 200         /* Populate bounce buffer if necessary */
 201         if (real_buffer != buffer)
 202                 memcpy(real_buffer, buffer, buffer_size);
 203
 204         r = efi_disk_rw_blocks(this, media_id, lba, buffer_size, real_buffer,
 205                                EFI_DISK_WRITE);
 206
 207         return EFI_EXIT(r);
 208 }
 209
 210 static efi_status_t EFIAPI efi_disk_flush_blocks(struct efi_block_io *this)
 211 {
 212         /* We always write synchronously */
 213         EFI_ENTRY("%p", this);
 214         return EFI_EXIT(EFI_SUCCESS);
 215 }
 216
 217 static const struct efi_block_io block_io_disk_template = {
 218         .reset = &efi_disk_reset,
 219         .read_blocks = &efi_disk_read_blocks,
 220         .write_blocks = &efi_disk_write_blocks,
 221         .flush_blocks = &efi_disk_flush_blocks,
 222 };
 223
 224 /*
 225  * Get the simple file system protocol for a file device path.
 226  *
 227  * The full path provided is split into device part and into a file
 228  * part. The device part is used to find the handle on which the
 229  * simple file system protocol is installed.
 230  *
 231  * @full_path   device path including device and file
 232  * @return      simple file system protocol
 233  */
 234 struct efi_simple_file_system_protocol *
 235 efi_fs_from_path(struct efi_device_path *full_path)
 236 {
 237         struct efi_object *efiobj;
 238         struct efi_handler *handler;
 239         struct efi_device_path *device_path;
 240         struct efi_device_path *file_path;
 241         efi_status_t ret;
 242
 243         /* Split the path into a device part and a file part */
 244         ret = efi_dp_split_file_path(full_path, &device_path, &file_path);
 245         if (ret != EFI_SUCCESS)
 246                 return NULL;
 247         efi_free_pool(file_path);
 248
 249         /* Get the EFI object for the partition */
 250         efiobj = efi_dp_find_obj(device_path, NULL);
 251         efi_free_pool(device_path);
 252         if (!efiobj)
 253                 return NULL;
 254
 255         /* Find the simple file system protocol */
 256         ret = efi_search_protocol(efiobj, &efi_simple_file_system_protocol_guid,
 257                                   &handler);
 258         if (ret != EFI_SUCCESS)
 259                 return NULL;
 260
 261         /* Return the simple file system protocol for the partition */
 262         return handler->protocol_interface;
 263 }
 264
 265 /*
 266  * Create a handle for a partition or disk
 267  *
 268  * @parent      parent handle
 269  * @dp_parent   parent device path
 270  * @if_typename interface name for block device
 271  * @desc        internal block device
 272  * @dev_index   device index for block device
 273  * @offset      offset into disk for simple partitions
 274  * @return      disk object
 275  */
 276 static efi_status_t efi_disk_add_dev(
 277                                 efi_handle_t parent,
 278                                 struct efi_device_path *dp_parent,
 279                                 const char *if_typename,
 280                                 struct blk_desc *desc,
 281                                 int dev_index,
 282                                 lbaint_t offset,
 283                                 unsigned int part,
 284                                 struct efi_disk_obj **disk)
 285 {
 286         struct efi_disk_obj *diskobj;
 287         efi_status_t ret;
 288
 289         /* Don't add empty devices */
 290         if (!desc->lba)
 291                 return EFI_NOT_READY;
 292
 293         diskobj = calloc(1, sizeof(*diskobj));
 294         if (!diskobj)
 295                 return EFI_OUT_OF_RESOURCES;
 296
 297         /* Hook up to the device list */
 298         efi_add_handle(&diskobj->header);
 299
 300         /* Fill in object data */
 301         if (part) {
 302                 struct efi_device_path *node = efi_dp_part_node(desc, part);
 303
 304                 diskobj->dp = efi_dp_append_node(dp_parent, node);
 305                 efi_free_pool(node);
 306         } else {
 307                 diskobj->dp = efi_dp_from_part(desc, part);
 308         }
 309         diskobj->part = part;
 310         ret = efi_add_protocol(&diskobj->header, &efi_block_io_guid,
 311                                &diskobj->ops);
 312         if (ret != EFI_SUCCESS)
 313                 return ret;
 314         ret = efi_add_protocol(&diskobj->header, &efi_guid_device_path,
 315                                diskobj->dp);
 316         if (ret != EFI_SUCCESS)
 317                 return ret;
 318         if (part >= 1) {
 319                 diskobj->volume = efi_simple_file_system(desc, part,
 320                                                          diskobj->dp);
 321                 ret = efi_add_protocol(&diskobj->header,
 322                                        &efi_simple_file_system_protocol_guid,
 323                                        diskobj->volume);
 324                 if (ret != EFI_SUCCESS)
 325                         return ret;
 326         }
 327         diskobj->ops = block_io_disk_template;
 328         diskobj->ifname = if_typename;
 329         diskobj->dev_index = dev_index;
 330         diskobj->offset = offset;
 331         diskobj->desc = desc;
 332
 333         /* Fill in EFI IO Media info (for read/write callbacks) */
 334         diskobj->media.removable_media = desc->removable;
 335         diskobj->media.media_present = 1;
 336         /*
 337          * MediaID is just an arbitrary counter.
 338          * We have to change it if the medium is removed or changed.
 339          */
 340         diskobj->media.media_id = 1;
 341         diskobj->media.block_size = desc->blksz;
 342         diskobj->media.io_align = desc->blksz;
 343         diskobj->media.last_block = desc->lba - offset;
 344         if (part != 0)
 345                 diskobj->media.logical_partition = 1;
 346         diskobj->ops.media = &diskobj->media;
 347         if (disk)
 348                 *disk = diskobj;
 349         return EFI_SUCCESS;
 350 }
 351
 352 /*
 353  * Create handles and protocols for the partitions of a block device
 354  *
 355  * @parent              handle of the parent disk
 356  * @blk_desc            block device
 357  * @if_typename         interface type
 358  * @diskid              device number
 359  * @pdevname            device name
 360  * @return              number of partitions created
 361  */
 362 int efi_disk_create_partitions(efi_handle_t parent, struct blk_desc *desc,
 363                                const char *if_typename, int diskid,
 364                                const char *pdevname)
 365 {
 366         int disks = 0;
 367         char devname[32] = { 0 }; /* dp->str is u16[32] long */
 368         disk_partition_t info;
 369         int part;
 370         struct efi_device_path *dp = NULL;
 371         efi_status_t ret;
 372         struct efi_handler *handler;
 373
 374         /* Get the device path of the parent */
 375         ret = efi_search_protocol(parent, &efi_guid_device_path, &handler);
 376         if (ret == EFI_SUCCESS)
 377                 dp = handler->protocol_interface;
 378
 379         /* Add devices for each partition */
 380         for (part = 1; part <= MAX_SEARCH_PARTITIONS; part++) {
 381                 if (part_get_info(desc, part, &info))
 382                         continue;
 383                 snprintf(devname, sizeof(devname), "%s:%d", pdevname,
 384                          part);
 385                 ret = efi_disk_add_dev(parent, dp, if_typename, desc, diskid,
 386                                        info.start, part, NULL);
 387                 if (ret != EFI_SUCCESS) {
 388                         printf("Adding partition %s failed\n", pdevname);
 389                         continue;
 390                 }
 391                 disks++;
 392         }
 393
 394         return disks;
 395 }
 396
 397 /*
 398  * U-Boot doesn't have a list of all online disk devices. So when running our
 399  * EFI payload, we scan through all of the potentially available ones and
 400  * store them in our object pool.
 401  *
 402  * TODO([email protected]): Actually with CONFIG_BLK, U-Boot does have this.
 403  * Consider converting the code to look up devices as needed. The EFI device
 404  * could be a child of the UCLASS_BLK block device, perhaps.
 405  *
 406  * This gets called from do_bootefi_exec().
 407  */
 408 efi_status_t efi_disk_register(void)
 409 {
 410         struct efi_disk_obj *disk;
 411         int disks = 0;
 412         efi_status_t ret;
 413 #ifdef CONFIG_BLK
 414         struct udevice *dev;
 415
 416         for (uclass_first_device_check(UCLASS_BLK, &dev); dev;
 417              uclass_next_device_check(&dev)) {
 418                 struct blk_desc *desc = dev_get_uclass_platdata(dev);
 419                 const char *if_typename = blk_get_if_type_name(desc->if_type);
 420
 421                 /* Add block device for the full device */
 422                 printf("Scanning disk %s...\n", dev->name);
 423                 ret = efi_disk_add_dev(NULL, NULL, if_typename,
 424                                         desc, desc->devnum, 0, 0, &disk);
 425                 if (ret == EFI_NOT_READY) {
 426                         printf("Disk %s not ready\n", dev->name);
 427                         continue;
 428                 }
 429                 if (ret) {
 430                         printf("ERROR: failure to add disk device %s, r = %lu\n",
 431                                dev->name, ret & ~EFI_ERROR_MASK);
 432                         return ret;
 433                 }
 434                 disks++;
 435
 436                 /* Partitions show up as block devices in EFI */
 437                 disks += efi_disk_create_partitions(
 438                                         &disk->header, desc, if_typename,
 439                                         desc->devnum, dev->name);
 440         }
 441 #else
 442         int i, if_type;
 443
 444         /* Search for all available disk devices */
 445         for (if_type = 0; if_type < IF_TYPE_COUNT; if_type++) {
 446                 const struct blk_driver *cur_drvr;
 447                 const char *if_typename;
 448
 449                 cur_drvr = blk_driver_lookup_type(if_type);
 450                 if (!cur_drvr)
 451                         continue;
 452
 453                 if_typename = cur_drvr->if_typename;
 454                 printf("Scanning disks on %s...\n", if_typename);
 455                 for (i = 0; i < 4; i++) {
 456                         struct blk_desc *desc;
 457                         char devname[32] = { 0 }; /* dp->str is u16[32] long */
 458
 459                         desc = blk_get_devnum_by_type(if_type, i);
 460                         if (!desc)
 461                                 continue;
 462                         if (desc->type == DEV_TYPE_UNKNOWN)
 463                                 continue;
 464
 465                         snprintf(devname, sizeof(devname), "%s%d",
 466                                  if_typename, i);
 467
 468                         /* Add block device for the full device */
 469                         ret = efi_disk_add_dev(NULL, NULL, if_typename, desc,
 470                                                i, 0, 0, &disk);
 471                         if (ret == EFI_NOT_READY) {
 472                                 printf("Disk %s not ready\n", devname);
 473                                 continue;
 474                         }
 475                         if (ret) {
 476                                 printf("ERROR: failure to add disk device %s, r = %lu\n",
 477                                        devname, ret & ~EFI_ERROR_MASK);
 478                                 return ret;
 479                         }
 480                         disks++;
 481
 482                         /* Partitions show up as block devices in EFI */
 483                         disks += efi_disk_create_partitions
 484                                                 (&disk->header, desc,
 485                                                  if_typename, i, devname);
 486                 }
 487         }
 488 #endif
 489         printf("Found %d disks\n", disks);
 490
 491         return EFI_SUCCESS;
 492 }