doc/uefi/uefi.rst

   1 .. SPDX-License-Identifier: GPL-2.0+
   2 .. Copyright (c) 2018 Heinrich Schuchardt
   3
   4 UEFI on U-Boot
   5 ==============
   6
   7 The Unified Extensible Firmware Interface Specification (UEFI) [1] has become
   8 the default for booting on AArch64 and x86 systems. It provides a stable API for
   9 the interaction of drivers and applications with the firmware. The API comprises
  10 access to block storage, network, and console to name a few. The Linux kernel
  11 and boot loaders like GRUB or the FreeBSD loader can be executed.
  12
  13 Development target
  14 ------------------
  15
  16 The implementation of UEFI in U-Boot strives to reach the requirements described
  17 in the "Embedded Base Boot Requirements (EBBR) Specification - Release v1.0"
  18 [2]. The "Server Base Boot Requirements System Software on ARM Platforms" [3]
  19 describes a superset of the EBBR specification and may be used as further
  20 reference.
  21
  22 A full blown UEFI implementation would contradict the U-Boot design principle
  23 "keep it small".
  24
  25 Building U-Boot for UEFI
  26 ------------------------
  27
  28 The UEFI standard supports only little-endian systems. The UEFI support can be
  29 activated for ARM and x86 by specifying::
  30
  31     CONFIG_CMD_BOOTEFI=y
  32     CONFIG_EFI_LOADER=y
  33
  34 in the .config file.
  35
  36 Support for attaching virtual block devices, e.g. iSCSI drives connected by the
  37 loaded UEFI application [4], requires::
  38
  39     CONFIG_BLK=y
  40     CONFIG_PARTITIONS=y
  41
  42 Executing a UEFI binary
  43 ~~~~~~~~~~~~~~~~~~~~~~~
  44
  45 The bootefi command is used to start UEFI applications or to install UEFI
  46 drivers. It takes two parameters::
  47
  48     bootefi <image address> [fdt address]
  49
  50 * image address - the memory address of the UEFI binary
  51 * fdt address - the memory address of the flattened device tree
  52
  53 Below you find the output of an example session starting GRUB::
  54
  55     => load mmc 0:2 ${fdt_addr_r} boot/dtb
  56     29830 bytes read in 14 ms (2 MiB/s)
  57     => load mmc 0:1 ${kernel_addr_r} efi/debian/grubaa64.efi
  58     reading efi/debian/grubaa64.efi
  59     120832 bytes read in 7 ms (16.5 MiB/s)
  60     => bootefi ${kernel_addr_r} ${fdt_addr_r}
  61
  62 The environment variable 'bootargs' is passed as load options in the UEFI system
  63 table. The Linux kernel EFI stub uses the load options as command line
  64 arguments.
  65
  66 Launching a UEFI binary from a FIT image
  67 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  68
  69 A signed FIT image can be used to securely boot a UEFI image via the
  70 bootm command. This feature is available if U-Boot is configured with::
  71
  72     CONFIG_BOOTM_EFI=y
  73
  74 A sample configuration is provided as file doc/uImage.FIT/uefi.its.
  75
  76 Below you find the output of an example session starting GRUB::
  77
  78     => load mmc 0:1 ${kernel_addr_r} image.fit
  79     4620426 bytes read in 83 ms (53.1 MiB/s)
  80     => bootm ${kernel_addr_r}#config-grub-nofdt
  81     ## Loading kernel from FIT Image at 40400000 ...
  82        Using 'config-grub-nofdt' configuration
  83        Verifying Hash Integrity ... sha256,rsa2048:dev+ OK
  84        Trying 'efi-grub' kernel subimage
  85          Description:  GRUB EFI Firmware
  86          Created:      2019-11-20   8:18:16 UTC
  87          Type:         Kernel Image (no loading done)
  88          Compression:  uncompressed
  89          Data Start:   0x404000d0
  90          Data Size:    450560 Bytes = 440 KiB
  91          Hash algo:    sha256
  92          Hash value:   4dbee00021112df618f58b3f7cf5e1595533d543094064b9ce991e8b054a9eec
  93        Verifying Hash Integrity ... sha256+ OK
  94        XIP Kernel Image (no loading done)
  95     ## Transferring control to EFI (at address 404000d0) ...
  96     Welcome to GRUB!
  97
  98 See doc/uImage.FIT/howto.txt for an introduction to FIT images.
  99
 100 Configuring UEFI secure boot
 101 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 102
 103 UEFI specification[1] defines a secure way of executing UEFI images
 104 by verifying a signature (or message digest) of image with certificates.
 105 This feature on U-Boot is enabled with::
 106
 107     CONFIG_UEFI_SECURE_BOOT=y
 108
 109 To make the boot sequence safe, you need to establish a chain of trust;
 110 In UEFI secure boot, you can make it with the UEFI variables, "PK"
 111 (Platform Key), "KEK" (Key Exchange Keys), "db" (white list database)
 112 and "dbx" (black list database).
 113
 114 There are many online documents that describe what UEFI secure boot is
 115 and how it works. Please consult some of them for details.
 116
 117 Here is a simple example that you can follow for your initial attempt
 118 (Please note that the actual steps would absolutely depend on your system
 119 and environment.):
 120
 121 1. Install utility commands on your host
 122     * openssl
 123     * efitools
 124     * sbsigntool
 125
 126 2. Create signing keys and key database files on your host
 127     for PK::
 128
 129         $ openssl req -x509 -sha256 -newkey rsa:2048 -subj /CN=TEST_PK/ \
 130                 -keyout PK.key -out PK.crt -nodes -days 365
 131         $ cert-to-efi-sig-list -g 11111111-2222-3333-4444-123456789abc \
 132                 PK.crt PK.esl;
 133         $ sign-efi-sig-list -c PK.crt -k PK.key PK PK.esl PK.auth
 134
 135     for KEK::
 136
 137         $ openssl req -x509 -sha256 -newkey rsa:2048 -subj /CN=TEST_KEK/ \
 138                 -keyout KEK.key -out KEK.crt -nodes -days 365
 139         $ cert-to-efi-sig-list -g 11111111-2222-3333-4444-123456789abc \
 140                 KEK.crt KEK.esl
 141         $ sign-efi-sig-list -c PK.crt -k PK.key KEK KEK.esl KEK.auth
 142
 143     for db::
 144
 145         $ openssl req -x509 -sha256 -newkey rsa:2048 -subj /CN=TEST_db/ \
 146                 -keyout db.key -out db.crt -nodes -days 365
 147         $ cert-to-efi-sig-list -g 11111111-2222-3333-4444-123456789abc \
 148                 db.crt db.esl
 149         $ sign-efi-sig-list -c KEK.crt -k KEK.key db db.esl db.auth
 150
 151     Copy \*.auth to media, say mmc, that is accessible from U-Boot.
 152
 153 3. Sign an image with one key in "db" on your host::
 154
 155     $ sbsign --key db.key --cert db.crt helloworld.efi
 156
 157 4. Install keys on your board::
 158
 159     ==> fatload mmc 0:1 <tmpaddr> PK.auth
 160     ==> setenv -e -nv -bs -rt -at -i <tmpaddr>,$filesize PK
 161     ==> fatload mmc 0:1 <tmpaddr> KEK.auth
 162     ==> setenv -e -nv -bs -rt -at -i <tmpaddr>,$filesize KEK
 163     ==> fatload mmc 0:1 <tmpaddr> db.auth
 164     ==> setenv -e -nv -bs -rt -at -i <tmpaddr>,$filesize db
 165
 166 5. Set up boot parameters on your board::
 167
 168     ==> efidebug boot add 1 HELLO mmc 0:1 /helloworld.efi.signed ""
 169
 170 Then your board runs that image from Boot manager (See below).
 171 You can also try this sequence by running Pytest, test_efi_secboot,
 172 on sandbox::
 173
 174     $ cd <U-Boot source directory>
 175     $ pytest.py test/py/tests/test_efi_secboot/test_signed.py --bd sandbox
 176
 177 Executing the boot manager
 178 ~~~~~~~~~~~~~~~~~~~~~~~~~~
 179
 180 The UEFI specification foresees to define boot entries and boot sequence via UEFI
 181 variables. Booting according to these variables is possible via::
 182
 183     bootefi bootmgr [fdt address]
 184
 185 As of U-Boot v2018.03 UEFI variables are not persisted and cannot be set at
 186 runtime.
 187
 188 Executing the built in hello world application
 189 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 190
 191 A hello world UEFI application can be built with::
 192
 193     CONFIG_CMD_BOOTEFI_HELLO_COMPILE=y
 194
 195 It can be embedded into the U-Boot binary with::
 196
 197     CONFIG_CMD_BOOTEFI_HELLO=y
 198
 199 The bootefi command is used to start the embedded hello world application::
 200
 201     bootefi hello [fdt address]
 202
 203 Below you find the output of an example session::
 204
 205     => bootefi hello ${fdtcontroladdr}
 206     ## Starting EFI application at 01000000 ...
 207     WARNING: using memory device/image path, this may confuse some payloads!
 208     Hello, world!
 209     Running on UEFI 2.7
 210     Have SMBIOS table
 211     Have device tree
 212     Load options: root=/dev/sdb3 init=/sbin/init rootwait ro
 213     ## Application terminated, r = 0
 214
 215 The environment variable fdtcontroladdr points to U-Boot's internal device tree
 216 (if available).
 217
 218 Executing the built-in self-test
 219 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 220
 221 An UEFI self-test suite can be embedded in U-Boot by building with::
 222
 223     CONFIG_CMD_BOOTEFI_SELFTEST=y
 224
 225 For testing the UEFI implementation the bootefi command can be used to start the
 226 self-test::
 227
 228     bootefi selftest [fdt address]
 229
 230 The environment variable 'efi_selftest' can be used to select a single test. If
 231 it is not provided all tests are executed except those marked as 'on request'.
 232 If the environment variable is set to 'list' a list of all tests is shown.
 233
 234 Below you can find the output of an example session::
 235
 236     => setenv efi_selftest simple network protocol
 237     => bootefi selftest
 238     Testing EFI API implementation
 239     Selected test: 'simple network protocol'
 240     Setting up 'simple network protocol'
 241     Setting up 'simple network protocol' succeeded
 242     Executing 'simple network protocol'
 243     DHCP Discover
 244     DHCP reply received from 192.168.76.2 (52:55:c0:a8:4c:02)
 245       as broadcast message.
 246     Executing 'simple network protocol' succeeded
 247     Tearing down 'simple network protocol'
 248     Tearing down 'simple network protocol' succeeded
 249     Boot services terminated
 250     Summary: 0 failures
 251     Preparing for reset. Press any key.
 252
 253 The UEFI life cycle
 254 -------------------
 255
 256 After the U-Boot platform has been initialized the UEFI API provides two kinds
 257 of services:
 258
 259 * boot services
 260 * runtime services
 261
 262 The API can be extended by loading UEFI drivers which come in two variants:
 263
 264 * boot drivers
 265 * runtime drivers
 266
 267 UEFI drivers are installed with U-Boot's bootefi command. With the same command
 268 UEFI applications can be executed.
 269
 270 Loaded images of UEFI drivers stay in memory after returning to U-Boot while
 271 loaded images of applications are removed from memory.
 272
 273 An UEFI application (e.g. an operating system) that wants to take full control
 274 of the system calls ExitBootServices. After a UEFI application calls
 275 ExitBootServices
 276
 277 * boot services are not available anymore
 278 * timer events are stopped
 279 * the memory used by U-Boot except for runtime services is released
 280 * the memory used by boot time drivers is released
 281
 282 So this is a point of no return. Afterwards the UEFI application can only return
 283 to U-Boot by rebooting.
 284
 285 The UEFI object model
 286 ---------------------
 287
 288 UEFI offers a flexible and expandable object model. The objects in the UEFI API
 289 are devices, drivers, and loaded images. These objects are referenced by
 290 handles.
 291
 292 The interfaces implemented by the objects are referred to as protocols. These
 293 are identified by GUIDs. They can be installed and uninstalled by calling the
 294 appropriate boot services.
 295
 296 Handles are created by the InstallProtocolInterface or the
 297 InstallMultipleProtocolinterfaces service if NULL is passed as handle.
 298
 299 Handles are deleted when the last protocol has been removed with the
 300 UninstallProtocolInterface or the UninstallMultipleProtocolInterfaces service.
 301
 302 Devices offer the EFI_DEVICE_PATH_PROTOCOL. A device path is the concatenation
 303 of device nodes. By their device paths all devices of a system are arranged in a
 304 tree.
 305
 306 Drivers offer the EFI_DRIVER_BINDING_PROTOCOL. This protocol is used to connect
 307 a driver to devices (which are referenced as controllers in this context).
 308
 309 Loaded images offer the EFI_LOADED_IMAGE_PROTOCOL. This protocol provides meta
 310 information about the image and a pointer to the unload callback function.
 311
 312 The UEFI events
 313 ---------------
 314
 315 In the UEFI terminology an event is a data object referencing a notification
 316 function which is queued for calling when the event is signaled. The following
 317 types of events exist:
 318
 319 * periodic and single shot timer events
 320 * exit boot services events, triggered by calling the ExitBootServices() service
 321 * virtual address change events
 322 * memory map change events
 323 * read to boot events
 324 * reset system events
 325 * system table events
 326 * events that are only triggered programmatically
 327
 328 Events can be created with the CreateEvent service and deleted with CloseEvent
 329 service.
 330
 331 Events can be assigned to an event group. If any of the events in a group is
 332 signaled, all other events in the group are also set to the signaled state.
 333
 334 The UEFI driver model
 335 ---------------------
 336
 337 A driver is specific for a single protocol installed on a device. To install a
 338 driver on a device the ConnectController service is called. In this context
 339 controller refers to the device for which the driver is installed.
 340
 341 The relevant drivers are identified using the EFI_DRIVER_BINDING_PROTOCOL. This
 342 protocol has has three functions:
 343
 344 * supported - determines if the driver is compatible with the device
 345 * start - installs the driver by opening the relevant protocol with
 346   attribute EFI_OPEN_PROTOCOL_BY_DRIVER
 347 * stop - uninstalls the driver
 348
 349 The driver may create child controllers (child devices). E.g. a driver for block
 350 IO devices will create the device handles for the partitions. The child
 351 controllers  will open the supported protocol with the attribute
 352 EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER.
 353
 354 A driver can be detached from a device using the DisconnectController service.
 355
 356 U-Boot devices mapped as UEFI devices
 357 -------------------------------------
 358
 359 Some of the U-Boot devices are mapped as UEFI devices
 360
 361 * block IO devices
 362 * console
 363 * graphical output
 364 * network adapter
 365
 366 As of U-Boot 2018.03 the logic for doing this is hard coded.
 367
 368 The development target is to integrate the setup of these UEFI devices with the
 369 U-Boot driver model [5]. So when a U-Boot device is discovered a handle should
 370 be created and the device path protocol and the relevant IO protocol should be
 371 installed. The UEFI driver then would be attached by calling ConnectController.
 372 When a U-Boot device is removed DisconnectController should be called.
 373
 374 UEFI devices mapped as U-Boot devices
 375 -------------------------------------
 376
 377 UEFI drivers binaries and applications may create new (virtual) devices, install
 378 a protocol and call the ConnectController service. Now the matching UEFI driver
 379 is determined by iterating over the implementations of the
 380 EFI_DRIVER_BINDING_PROTOCOL.
 381
 382 It is the task of the UEFI driver to create a corresponding U-Boot device and to
 383 proxy calls for this U-Boot device to the controller.
 384
 385 In U-Boot 2018.03 this has only been implemented for block IO devices.
 386
 387 UEFI uclass
 388 ~~~~~~~~~~~
 389
 390 An UEFI uclass driver (lib/efi_driver/efi_uclass.c) has been created that
 391 takes care of initializing the UEFI drivers and providing the
 392 EFI_DRIVER_BINDING_PROTOCOL implementation for the UEFI drivers.
 393
 394 A linker created list is used to keep track of the UEFI drivers. To create an
 395 entry in the list the UEFI driver uses the U_BOOT_DRIVER macro specifying
 396 UCLASS_EFI as the ID of its uclass, e.g::
 397
 398     /* Identify as UEFI driver */
 399     U_BOOT_DRIVER(efi_block) = {
 400         .name  = "EFI block driver",
 401         .id    = UCLASS_EFI,
 402         .ops   = &driver_ops,
 403     };
 404
 405 The available operations are defined via the structure struct efi_driver_ops::
 406
 407     struct efi_driver_ops {
 408         const efi_guid_t *protocol;
 409         const efi_guid_t *child_protocol;
 410         int (*bind)(efi_handle_t handle, void *interface);
 411     };
 412
 413 When the supported() function of the EFI_DRIVER_BINDING_PROTOCOL is called the
 414 uclass checks if the protocol GUID matches the protocol GUID of the UEFI driver.
 415 In the start() function the bind() function of the UEFI driver is called after
 416 checking the GUID.
 417 The stop() function of the EFI_DRIVER_BINDING_PROTOCOL disconnects the child
 418 controllers created by the UEFI driver and the UEFI driver. (In U-Boot v2013.03
 419 this is not yet completely implemented.)
 420
 421 UEFI block IO driver
 422 ~~~~~~~~~~~~~~~~~~~~
 423
 424 The UEFI block IO driver supports devices exposing the EFI_BLOCK_IO_PROTOCOL.
 425
 426 When connected it creates a new U-Boot block IO device with interface type
 427 IF_TYPE_EFI, adds child controllers mapping the partitions, and installs the
 428 EFI_SIMPLE_FILE_SYSTEM_PROTOCOL on these. This can be used together with the
 429 software iPXE to boot from iSCSI network drives [4].
 430
 431 This driver is only available if U-Boot is configured with::
 432
 433     CONFIG_BLK=y
 434     CONFIG_PARTITIONS=y
 435
 436 Miscellaneous
 437 -------------
 438
 439 Load file 2 protocol
 440 ~~~~~~~~~~~~~~~~~~~~
 441
 442 The load file 2 protocol can be used by the Linux kernel to load the initial
 443 RAM disk. U-Boot can be configured to provide an implementation with::
 444
 445     EFI_LOAD_FILE2_INITRD=y
 446     EFI_INITRD_FILESPEC=interface dev:part path_to_initrd
 447
 448 Links
 449 -----
 450
 451 * [1] http://uefi.org/specifications - UEFI specifications
 452 * [2] https://github.com/ARM-software/ebbr/releases/download/v1.0/ebbr-v1.0.pdf -
 453   Embedded Base Boot Requirements (EBBR) Specification - Release v1.0
 454 * [3] https://developer.arm.com/docs/den0044/latest/server-base-boot-requirements-system-software-on-arm-platforms-version-11 -
 455   Server Base Boot Requirements System Software on ARM Platforms - Version 1.1
 456 * [4] :doc:`iscsi`
 457 * [5] :doc:`../driver-model/index`