--- /dev/null
+/*
+ * Copyright (C) 2008 Michael Brown <mbrown@fensystems.co.uk>.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301, USA.
+ */
+
+FILE_LICENCE ( GPL2_OR_LATER );
+
+#include <errno.h>
+#include <stdlib.h>
+#include <wchar.h>
+#include <ipxe/efi/efi.h>
+#include <ipxe/efi/efi_snp.h>
+#include <ipxe/efi/efi_download.h>
+#include <ipxe/efi/efi_file.h>
+#include <ipxe/efi/efi_utils.h>
+#include <ipxe/efi/efi_strings.h>
+#include <ipxe/efi/efi_wrap.h>
+#include <ipxe/image.h>
+#include <ipxe/init.h>
+#include <ipxe/features.h>
+#include <ipxe/uri.h>
+
+FEATURE ( FEATURE_IMAGE, "EFI", DHCP_EB_FEATURE_EFI, 1 );
+
+/* Disambiguate the various error causes */
+#define EINFO_EEFI_LOAD \
+ __einfo_uniqify ( EINFO_EPLATFORM, 0x01, \
+ "Could not load image" )
+#define EINFO_EEFI_LOAD_PROHIBITED \
+ __einfo_platformify ( EINFO_EEFI_LOAD, EFI_SECURITY_VIOLATION, \
+ "Image prohibited by security policy" )
+#define EEFI_LOAD_PROHIBITED \
+ __einfo_error ( EINFO_EEFI_LOAD_PROHIBITED )
+#define EEFI_LOAD( efirc ) EPLATFORM ( EINFO_EEFI_LOAD, efirc, \
+ EEFI_LOAD_PROHIBITED )
+#define EINFO_EEFI_START \
+ __einfo_uniqify ( EINFO_EPLATFORM, 0x02, \
+ "Could not start image" )
+#define EEFI_START( efirc ) EPLATFORM ( EINFO_EEFI_START, efirc )
+
+/**
+ * Create device path for image
+ *
+ * @v image EFI image
+ * @v parent Parent device path
+ * @ret path Device path, or NULL on failure
+ *
+ * The caller must eventually free() the device path.
+ */
+static EFI_DEVICE_PATH_PROTOCOL *
+efi_image_path ( struct image *image, EFI_DEVICE_PATH_PROTOCOL *parent ) {
+ EFI_DEVICE_PATH_PROTOCOL *path;
+ FILEPATH_DEVICE_PATH *filepath;
+ EFI_DEVICE_PATH_PROTOCOL *end;
+ size_t name_len;
+ size_t prefix_len;
+ size_t filepath_len;
+ size_t len;
+
+ /* Calculate device path lengths */
+ end = efi_devpath_end ( parent );
+ prefix_len = ( ( void * ) end - ( void * ) parent );
+ name_len = strlen ( image->name );
+ filepath_len = ( SIZE_OF_FILEPATH_DEVICE_PATH +
+ ( name_len + 1 /* NUL */ ) * sizeof ( wchar_t ) );
+ len = ( prefix_len + filepath_len + sizeof ( *end ) );
+
+ /* Allocate device path */
+ path = zalloc ( len );
+ if ( ! path )
+ return NULL;
+
+ /* Construct device path */
+ memcpy ( path, parent, prefix_len );
+ filepath = ( ( ( void * ) path ) + prefix_len );
+ filepath->Header.Type = MEDIA_DEVICE_PATH;
+ filepath->Header.SubType = MEDIA_FILEPATH_DP;
+ filepath->Header.Length[0] = ( filepath_len & 0xff );
+ filepath->Header.Length[1] = ( filepath_len >> 8 );
+ efi_snprintf ( filepath->PathName, ( name_len + 1 /* NUL */ ),
+ "%s", image->name );
+ end = ( ( ( void * ) filepath ) + filepath_len );
+ end->Type = END_DEVICE_PATH_TYPE;
+ end->SubType = END_ENTIRE_DEVICE_PATH_SUBTYPE;
+ end->Length[0] = sizeof ( *end );
+
+ return path;
+}
+
+/**
+ * Create command line for image
+ *
+ * @v image EFI image
+ * @ret cmdline Command line, or NULL on failure
+ */
+static wchar_t * efi_image_cmdline ( struct image *image ) {
+ wchar_t *cmdline;
+ size_t len;
+
+ len = ( strlen ( image->name ) +
+ ( image->cmdline ?
+ ( 1 /* " " */ + strlen ( image->cmdline ) ) : 0 ) );
+ cmdline = zalloc ( ( len + 1 /* NUL */ ) * sizeof ( wchar_t ) );
+ if ( ! cmdline )
+ return NULL;
+ efi_snprintf ( cmdline, ( len + 1 /* NUL */ ), "%s%s%s",
+ image->name,
+ ( image->cmdline ? " " : "" ),
+ ( image->cmdline ? image->cmdline : "" ) );
+ return cmdline;
+}
+
+/**
+ * Execute EFI image
+ *
+ * @v image EFI image
+ * @ret rc Return status code
+ */
+static int efi_image_exec ( struct image *image ) {
+ EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
+ struct efi_snp_device *snpdev;
+ EFI_DEVICE_PATH_PROTOCOL *path;
+ union {
+ EFI_LOADED_IMAGE_PROTOCOL *image;
+ void *interface;
+ } loaded;
+ EFI_HANDLE handle;
+ wchar_t *cmdline;
+ EFI_STATUS efirc;
+ int rc;
+
+ /* Find an appropriate device handle to use */
+ snpdev = last_opened_snpdev();
+ if ( ! snpdev ) {
+ DBGC ( image, "EFIIMAGE %p could not identify SNP device\n",
+ image );
+ rc = -ENODEV;
+ goto err_no_snpdev;
+ }
+
+ /* Install file I/O protocols */
+ if ( ( rc = efi_file_install ( snpdev->handle ) ) != 0 ) {
+ DBGC ( image, "EFIIMAGE %p could not install file protocol: "
+ "%s\n", image, strerror ( rc ) );
+ goto err_file_install;
+ }
+
+ /* Install iPXE download protocol */
+ if ( ( rc = efi_download_install ( snpdev->handle ) ) != 0 ) {
+ DBGC ( image, "EFIIMAGE %p could not install iPXE download "
+ "protocol: %s\n", image, strerror ( rc ) );
+ goto err_download_install;
+ }
+
+ /* Create device path for image */
+ path = efi_image_path ( image, snpdev->path );
+ if ( ! path ) {
+ DBGC ( image, "EFIIMAGE %p could not create device path\n",
+ image );
+ rc = -ENOMEM;
+ goto err_image_path;
+ }
+
+ /* Create command line for image */
+ cmdline = efi_image_cmdline ( image );
+ if ( ! cmdline ) {
+ DBGC ( image, "EFIIMAGE %p could not create command line\n",
+ image );
+ rc = -ENOMEM;
+ goto err_cmdline;
+ }
+
+ /* Attempt loading image */
+ if ( ( efirc = bs->LoadImage ( FALSE, efi_image_handle, path,
+ user_to_virt ( image->data, 0 ),
+ image->len, &handle ) ) != 0 ) {
+ /* Not an EFI image */
+ rc = -EEFI_LOAD ( efirc );
+ DBGC ( image, "EFIIMAGE %p could not load: %s\n",
+ image, strerror ( rc ) );
+ goto err_load_image;
+ }
+
+ /* Get the loaded image protocol for the newly loaded image */
+ efirc = bs->OpenProtocol ( handle, &efi_loaded_image_protocol_guid,
+ &loaded.interface, efi_image_handle,
+ NULL, EFI_OPEN_PROTOCOL_GET_PROTOCOL );
+ if ( efirc ) {
+ /* Should never happen */
+ rc = -EEFI ( efirc );
+ goto err_open_protocol;
+ }
+
+ /* Some EFI 1.10 implementations seem not to fill in DeviceHandle */
+ if ( loaded.image->DeviceHandle == NULL ) {
+ DBGC ( image, "EFIIMAGE %p filling in missing DeviceHandle\n",
+ image );
+ loaded.image->DeviceHandle = snpdev->handle;
+ }
+
+ /* Sanity checks */
+ assert ( loaded.image->ParentHandle == efi_image_handle );
+ assert ( loaded.image->DeviceHandle == snpdev->handle );
+ assert ( loaded.image->LoadOptionsSize == 0 );
+ assert ( loaded.image->LoadOptions == NULL );
+
+ /* Set command line */
+ loaded.image->LoadOptions = cmdline;
+ loaded.image->LoadOptionsSize =
+ ( ( wcslen ( cmdline ) + 1 /* NUL */ ) * sizeof ( wchar_t ) );
+
+ /* Release network devices for use via SNP */
+ efi_snp_release();
+
+ /* Wrap calls made by the loaded image (for debugging) */
+ efi_wrap ( handle );
+
+ /* Start the image */
+ if ( ( efirc = bs->StartImage ( handle, NULL, NULL ) ) != 0 ) {
+ rc = -EEFI_START ( efirc );
+ DBGC ( image, "EFIIMAGE %p could not start (or returned with "
+ "error): %s\n", image, strerror ( rc ) );
+ goto err_start_image;
+ }
+
+ /* Success */
+ rc = 0;
+
+ err_start_image:
+ efi_snp_claim();
+ err_open_protocol:
+ /* If there was no error, then the image must have been
+ * started and returned successfully. It either unloaded
+ * itself, or it intended to remain loaded (e.g. it was a
+ * driver). We therefore do not unload successful images.
+ *
+ * If there was an error, attempt to unload the image. This
+ * may not work. In particular, there is no way to tell
+ * whether an error returned from StartImage() was due to
+ * being unable to start the image (in which case we probably
+ * should call UnloadImage()), or due to the image itself
+ * returning an error (in which case we probably should not
+ * call UnloadImage()). We therefore ignore any failures from
+ * the UnloadImage() call itself.
+ */
+ if ( rc != 0 )
+ bs->UnloadImage ( handle );
+ err_load_image:
+ free ( cmdline );
+ err_cmdline:
+ free ( path );
+ err_image_path:
+ efi_download_uninstall ( snpdev->handle );
+ err_download_install:
+ efi_file_uninstall ( snpdev->handle );
+ err_file_install:
+ err_no_snpdev:
+ return rc;
+}
+
+/**
+ * Probe EFI image
+ *
+ * @v image EFI file
+ * @ret rc Return status code
+ */
+static int efi_image_probe ( struct image *image ) {
+ EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
+ static EFI_DEVICE_PATH_PROTOCOL empty_path = {
+ .Type = END_DEVICE_PATH_TYPE,
+ .SubType = END_ENTIRE_DEVICE_PATH_SUBTYPE,
+ .Length[0] = sizeof ( empty_path ),
+ };
+ EFI_HANDLE handle;
+ EFI_STATUS efirc;
+ int rc;
+
+ /* Attempt loading image */
+ if ( ( efirc = bs->LoadImage ( FALSE, efi_image_handle, &empty_path,
+ user_to_virt ( image->data, 0 ),
+ image->len, &handle ) ) != 0 ) {
+ /* Not an EFI image */
+ rc = -EEFI_LOAD ( efirc );
+ DBGC ( image, "EFIIMAGE %p could not load: %s\n",
+ image, strerror ( rc ) );
+ return rc;
+ }
+
+ /* Unload the image. We can't leave it loaded, because we
+ * have no "unload" operation.
+ */
+ bs->UnloadImage ( handle );
+
+ return 0;
+}
+
+/** EFI image type */
+struct image_type efi_image_type __image_type ( PROBE_NORMAL ) = {
+ .name = "EFI",
+ .probe = efi_image_probe,
+ .exec = efi_image_exec,
+};
Code Review / kvmfornfv.git / blobdiff