efi_block.c File Reference

EFI block device protocols. More...

#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <ipxe/refcnt.h>
#include <ipxe/list.h>
#include <ipxe/uri.h>
#include <ipxe/interface.h>
#include <ipxe/blockdev.h>
#include <ipxe/xfer.h>
#include <ipxe/open.h>
#include <ipxe/retry.h>
#include <ipxe/timer.h>
#include <ipxe/process.h>
#include <ipxe/sanboot.h>
#include <ipxe/iso9660.h>
#include <ipxe/acpi.h>
#include <ipxe/efi/efi.h>
#include <ipxe/efi/Protocol/BlockIo.h>
#include <ipxe/efi/Protocol/SimpleFileSystem.h>
#include <ipxe/efi/Protocol/AcpiTable.h>
#include <ipxe/efi/efi_driver.h>
#include <ipxe/efi/efi_strings.h>
#include <ipxe/efi/efi_snp.h>
#include <ipxe/efi/efi_path.h>
#include <ipxe/efi/efi_null.h>
#include <ipxe/efi/efi_block.h>

Go to the source code of this file.

Data Structures
struct	efi_block_data
	EFI SAN device private data. More...
struct	efi_acpi_table
	An installed ACPI table. More...

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
	EFI_REQUEST_PROTOCOL (EFI_ACPI_TABLE_PROTOCOL, &acpi)
static int	efi_block_rw (struct san_device *sandev, uint64_t lba, void *data, size_t len, int(*sandev_rw)(struct san_device *sandev, uint64_t lba, unsigned int count, userptr_t buffer))
	Read from or write to EFI block device. More...
static EFI_STATUS EFIAPI	efi_block_io_reset (EFI_BLOCK_IO_PROTOCOL *block_io, BOOLEAN verify __unused)
	Reset EFI block device. More...
static EFI_STATUS EFIAPI	efi_block_io_read (EFI_BLOCK_IO_PROTOCOL *block_io, UINT32 media __unused, EFI_LBA lba, UINTN len, VOID *data)
	Read from EFI block device. More...
static EFI_STATUS EFIAPI	efi_block_io_write (EFI_BLOCK_IO_PROTOCOL *block_io, UINT32 media __unused, EFI_LBA lba, UINTN len, VOID *data)
	Write to EFI block device. More...
static EFI_STATUS EFIAPI	efi_block_io_flush (EFI_BLOCK_IO_PROTOCOL *block_io)
	Flush data to EFI block device. More...
static void	efi_block_connect (struct san_device *sandev)
	Connect all possible drivers to EFI block device. More...
static int	efi_block_hook (unsigned int drive, struct uri **uris, unsigned int count, unsigned int flags)
	Hook EFI block device. More...
static void	efi_block_unhook (unsigned int drive)
	Unhook EFI block device. More...
static	LIST_HEAD (efi_acpi_tables)
	List of installed ACPI tables. More...
static int	efi_block_install (struct acpi_header *hdr)
	Install ACPI table. More...
static int	efi_block_describe (void)
	Describe EFI block devices. More...
static int	efi_block_boot_image (struct san_device *sandev, EFI_HANDLE handle, const char *filename, EFI_HANDLE *image)
	Try booting from child device of EFI block device. More...
static int	efi_block_boot (unsigned int drive, const char *filename)
	Boot from EFI block device. More...
	PROVIDE_SANBOOT (efi, san_hook, efi_block_hook)
	PROVIDE_SANBOOT (efi, san_unhook, efi_block_unhook)
	PROVIDE_SANBOOT (efi, san_describe, efi_block_describe)
	PROVIDE_SANBOOT (efi, san_boot, efi_block_boot)

Variables
static EFI_ACPI_TABLE_PROTOCOL *	acpi
	ACPI table protocol protocol. More...
static wchar_t	efi_block_boot_filename [] = EFI_REMOVABLE_MEDIA_FILE_NAME
	Boot filename. More...

Detailed Description

EFI block device protocols.

Definition in file efi_block.c.

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

EFI_REQUEST_PROTOCOL()

EFI_REQUEST_PROTOCOL	(	EFI_ACPI_TABLE_PROTOCOL	,
		&	acpi
	)

efi_block_rw()

static int efi_block_rw ( struct san_device *  sandev, uint64_t  lba, void *  data, size_t  len, int(*)(struct san_device *sandev, uint64_t lba, unsigned int count, userptr_t buffer)  sandev_rw  )

static

Read from or write to EFI block device.

Parameters

sandev	SAN device
lba	Starting LBA
data	Data buffer
len	Size of buffer
sandev_rw	SAN device read/write method

Return values

rc	Return status code

Definition at line 92 of file efi_block.c.

                                                                     {
        struct efi_block_data *block = sandev->priv;
        unsigned int count;
        int rc;

        /* Sanity check */
        count = ( len / block->media.BlockSize );
        if ( ( count * block->media.BlockSize ) != len ) {
                DBGC ( sandev, "EFIBLK %#02x impossible length %#zx\n",
                       sandev->drive, len );
                return -EINVAL;
        }

        /* Read from / write to block device */
        if ( ( rc = sandev_rw ( sandev, lba, count,
                                virt_to_user ( data ) ) ) != 0 ) {
                DBGC ( sandev, "EFIBLK %#02x I/O failed: %s\n",
                       sandev->drive, strerror ( rc ) );
                return rc;
        }

        return 0;
}

References block, count, data, DBGC, san_device::drive, EINVAL, lba, len, san_device::priv, rc, efi_block_data::sandev, sandev_rw(), strerror(), and virt_to_user().

Referenced by efi_block_io_read(), and efi_block_io_write().

efi_block_io_reset()

static EFI_STATUS EFIAPI efi_block_io_reset ( EFI_BLOCK_IO_PROTOCOL *  block_io, BOOLEAN verify  __unused  )

static

Reset EFI block device.

Parameters

block_io	Block I/O protocol
verify	Perform extended verification

Return values

efirc

EFI status code

Definition at line 127 of file efi_block.c.

                                                                        {
        struct efi_block_data *block =
                container_of ( block_io, struct efi_block_data, block_io );
        struct san_device *sandev = block->sandev;
        int rc;

        DBGC2 ( sandev, "EFIBLK %#02x reset\n", sandev->drive );
        efi_snp_claim();
        rc = sandev_reset ( sandev );
        efi_snp_release();
        return EFIRC ( rc );
}

References block, efi_block_data::block_io, container_of, DBGC2, san_device::drive, efi_snp_claim(), efi_snp_release(), EFIRC, rc, and sandev_reset().

Referenced by efi_block_hook().

efi_block_io_read()

static EFI_STATUS EFIAPI efi_block_io_read ( EFI_BLOCK_IO_PROTOCOL *  block_io, UINT32 media  __unused, EFI_LBA  lba, UINTN  len, VOID *  data  )

static

Read from EFI block device.

Parameters

block_io	Block I/O protocol
media	Media identifier
lba	Starting LBA
len	Size of buffer
data	Data buffer

Return values

efirc

EFI status code

Definition at line 152 of file efi_block.c.

                                                         {
        struct efi_block_data *block =
                container_of ( block_io, struct efi_block_data, block_io );
        struct san_device *sandev = block->sandev;
        int rc;

        DBGC2 ( sandev, "EFIBLK %#02x read LBA %#08llx to %p+%#08zx\n",
                sandev->drive, lba, data, ( ( size_t ) len ) );
        efi_snp_claim();
        rc = efi_block_rw ( sandev, lba, data, len, sandev_read );
        efi_snp_release();
        return EFIRC ( rc );
}

References block, efi_block_data::block_io, container_of, data, DBGC2, san_device::drive, efi_block_rw(), efi_snp_claim(), efi_snp_release(), EFIRC, lba, len, rc, and sandev_read().

Referenced by efi_block_hook().

efi_block_io_write()

static EFI_STATUS EFIAPI efi_block_io_write ( EFI_BLOCK_IO_PROTOCOL *  block_io, UINT32 media  __unused, EFI_LBA  lba, UINTN  len, VOID *  data  )

static

Write to EFI block device.

Parameters

block_io	Block I/O protocol
media	Media identifier
lba	Starting LBA
len	Size of buffer
data	Data buffer

Return values

efirc

EFI status code

Definition at line 178 of file efi_block.c.

                                                          {
        struct efi_block_data *block =
                container_of ( block_io, struct efi_block_data, block_io );
        struct san_device *sandev = block->sandev;
        int rc;

        DBGC2 ( sandev, "EFIBLK %#02x write LBA %#08llx from %p+%#08zx\n",
                sandev->drive, lba, data, ( ( size_t ) len ) );
        efi_snp_claim();
        rc = efi_block_rw ( sandev, lba, data, len, sandev_write );
        efi_snp_release();
        return EFIRC ( rc );
}

References block, efi_block_data::block_io, container_of, data, DBGC2, san_device::drive, efi_block_rw(), efi_snp_claim(), efi_snp_release(), EFIRC, lba, len, rc, and sandev_write().

Referenced by efi_block_hook().

efi_block_io_flush()

static EFI_STATUS EFIAPI efi_block_io_flush ( EFI_BLOCK_IO_PROTOCOL *  block_io )

static

Flush data to EFI block device.

Parameters

block_io

Block I/O protocol

Return values

efirc

EFI status code

Definition at line 200 of file efi_block.c.

                                                       {
        struct efi_block_data *block =
                container_of ( block_io, struct efi_block_data, block_io );
        struct san_device *sandev = block->sandev;

        DBGC2 ( sandev, "EFIBLK %#02x flush\n", sandev->drive );

        /* Nothing to do */
        return 0;
}

References block, efi_block_data::block_io, container_of, DBGC2, and san_device::drive.

Referenced by efi_block_hook().

efi_block_connect()

static void efi_block_connect ( struct san_device *  sandev )

static

Connect all possible drivers to EFI block device.

Parameters

sandev

SAN device

Definition at line 216 of file efi_block.c.

                                                            {
        EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
        struct efi_block_data *block = sandev->priv;
        EFI_STATUS efirc;
        int rc;

        /* Try to connect all possible drivers to this block device */
        if ( ( efirc = bs->ConnectController ( block->handle, NULL,
                                               NULL, TRUE ) ) != 0 ) {
                rc = -EEFI ( efirc );
                DBGC ( sandev, "EFIBLK %#02x could not connect drivers: %s\n",
                       sandev->drive, strerror ( rc ) );
                /* May not be an error; may already be connected */
        }
        DBGC2 ( sandev, "EFIBLK %#02x supports protocols:\n", sandev->drive );
        DBGC2_EFI_PROTOCOLS ( sandev, block->handle );
}

References block, EFI_SYSTEM_TABLE::BootServices, EFI_BOOT_SERVICES::ConnectController, DBGC, DBGC2, DBGC2_EFI_PROTOCOLS, san_device::drive, EEFI, efi_systab, NULL, san_device::priv, rc, efi_block_data::sandev, strerror(), and TRUE.

Referenced by efi_block_boot(), and efi_block_hook().

efi_block_hook()

static int efi_block_hook ( unsigned int  drive, struct uri **  uris, unsigned int  count, unsigned int  flags  )

static

Hook EFI block device.

Parameters

drive	Drive number
uris	List of URIs
count	Number of URIs
flags	Flags

Return values

drive

Drive number, or negative error

Definition at line 243 of file efi_block.c.

                                                                     {
        EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
        struct san_device *sandev;
        struct efi_block_data *block;
        int leak = 0;
        EFI_STATUS efirc;
        int rc;

        /* Sanity check */
        if ( ! count ) {
                DBG ( "EFIBLK has no URIs\n" );
                rc = -ENOTTY;
                goto err_no_uris;
        }

        /* Allocate and initialise structure */
        sandev = alloc_sandev ( uris, count, sizeof ( *block ) );
        if ( ! sandev ) {
                rc = -ENOMEM;
                goto err_alloc;
        }
        block = sandev->priv;
        block->sandev = sandev;
        block->media.MediaPresent = 1;
        block->media.LogicalBlocksPerPhysicalBlock = 1;
        block->block_io.Revision = EFI_BLOCK_IO_PROTOCOL_REVISION3;
        block->block_io.Media = &block->media;
        block->block_io.Reset = efi_block_io_reset;
        block->block_io.ReadBlocks = efi_block_io_read;
        block->block_io.WriteBlocks = efi_block_io_write;
        block->block_io.FlushBlocks = efi_block_io_flush;

        /* Register SAN device */
        if ( ( rc = register_sandev ( sandev, drive, flags ) ) != 0 ) {
                DBGC ( sandev, "EFIBLK %#02x could not register: %s\n",
                       drive, strerror ( rc ) );
                goto err_register;
        }

        /* Update media descriptor */
        block->media.BlockSize =
                ( sandev->capacity.blksize << sandev->blksize_shift );
        block->media.LastBlock =
                ( ( sandev->capacity.blocks >> sandev->blksize_shift ) - 1 );

        /* Construct device path */
        if ( ! sandev->active ) {
                rc = -ENODEV;
                DBGC ( sandev, "EFIBLK %#02x not active after registration\n",
                       drive );
                goto err_active;
        }
        block->path = efi_describe ( &sandev->active->block );
        if ( ! block->path ) {
                rc = -ENODEV;
                DBGC ( sandev, "EFIBLK %#02x has no device path\n", drive );
                goto err_describe;
        }
        DBGC ( sandev, "EFIBLK %#02x has device path %s\n",
               drive, efi_devpath_text ( block->path ) );

        /* Install protocols */
        if ( ( efirc = bs->InstallMultipleProtocolInterfaces (
                        &block->handle,
                        &efi_block_io_protocol_guid, &block->block_io,
                        &efi_device_path_protocol_guid, block->path,
                        NULL ) ) != 0 ) {
                rc = -EEFI ( efirc );
                DBGC ( sandev, "EFIBLK %#02x could not install protocols: %s\n",
                       sandev->drive, strerror ( rc ) );
                goto err_install;
        }

        /* Connect all possible protocols */
        efi_block_connect ( sandev );

        return drive;

        if ( ( efirc = bs->UninstallMultipleProtocolInterfaces (
                        block->handle,
                        &efi_block_io_protocol_guid, &block->block_io,
                        &efi_device_path_protocol_guid, block->path,
                        NULL ) ) != 0 ) {
                DBGC ( sandev, "EFIBLK %#02x could not uninstall protocols: "
                       "%s\n", sandev->drive, strerror ( -EEFI ( efirc ) ) );
                leak = 1;
        }
        efi_nullify_block ( &block->block_io );
 err_install:
        if ( ! leak )  {
                free ( block->path );
                block->path = NULL;
        }
 err_describe:
 err_active:
        unregister_sandev ( sandev );
 err_register:
        if ( ! leak )
                sandev_put ( sandev );
 err_alloc:
 err_no_uris:
        if ( leak ) {
                DBGC ( sandev, "EFIBLK %#02x nullified and leaked\n",
                       sandev->drive );
        }
        return rc;
}

References san_device::active, alloc_sandev(), block_device_capacity::blksize, san_device::blksize_shift, block, san_path::block, block_device_capacity::blocks, EFI_SYSTEM_TABLE::BootServices, san_device::capacity, count, DBG, DBGC, drive, san_device::drive, EEFI, efi_block_connect(), efi_block_io_flush(), efi_block_io_protocol_guid, EFI_BLOCK_IO_PROTOCOL_REVISION3, efi_block_io_read(), efi_block_io_reset(), efi_block_io_write(), efi_describe(), efi_device_path_protocol_guid, efi_devpath_text(), efi_nullify_block(), efi_systab, ENODEV, ENOMEM, ENOTTY, flags, free, EFI_BOOT_SERVICES::InstallMultipleProtocolInterfaces, NULL, san_device::priv, rc, register_sandev(), efi_block_data::sandev, sandev_put(), strerror(), EFI_BOOT_SERVICES::UninstallMultipleProtocolInterfaces, and unregister_sandev().

efi_block_unhook()

static void efi_block_unhook ( unsigned int  drive )

static

Unhook EFI block device.

Parameters

drive

Drive number

Definition at line 357 of file efi_block.c.

                                                    {
        EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
        struct san_device *sandev;
        struct efi_block_data *block;
        int leak = efi_shutdown_in_progress;
        EFI_STATUS efirc;

        /* Find SAN device */
        sandev = sandev_find ( drive );
        if ( ! sandev ) {
                DBG ( "EFIBLK cannot find drive %#02x\n", drive );
                return;
        }
        block = sandev->priv;

        /* Uninstall protocols */
        if ( ( ! efi_shutdown_in_progress ) &&
             ( ( efirc = bs->UninstallMultipleProtocolInterfaces (
                        block->handle,
                        &efi_block_io_protocol_guid, &block->block_io,
                        &efi_device_path_protocol_guid, block->path,
                        NULL ) ) != 0 ) ) {
                DBGC ( sandev, "EFIBLK %#02x could not uninstall protocols: "
                       "%s\n", sandev->drive, strerror ( -EEFI ( efirc ) ) );
                leak = 1;
        }
        efi_nullify_block ( &block->block_io );

        /* Free device path */
        if ( ! leak ) {
                free ( block->path );
                block->path = NULL;
        }

        /* Unregister SAN device */
        unregister_sandev ( sandev );

        /* Drop reference to drive */
        if ( ! leak )
                sandev_put ( sandev );

        /* Report leakage, if applicable */
        if ( leak && ( ! efi_shutdown_in_progress ) ) {
                DBGC ( sandev, "EFIBLK %#02x nullified and leaked\n",
                       sandev->drive );
        }
}

References block, EFI_SYSTEM_TABLE::BootServices, DBG, DBGC, drive, san_device::drive, EEFI, efi_block_io_protocol_guid, efi_device_path_protocol_guid, efi_nullify_block(), efi_shutdown_in_progress, efi_systab, free, NULL, san_device::priv, efi_block_data::sandev, sandev_find(), sandev_put(), strerror(), EFI_BOOT_SERVICES::UninstallMultipleProtocolInterfaces, and unregister_sandev().

LIST_HEAD()

static LIST_HEAD ( efi_acpi_tables  )

static

List of installed ACPI tables.

efi_block_install()

static int efi_block_install ( struct acpi_header *  hdr )

static

Install ACPI table.

Parameters

hdr	ACPI description header

Return values

rc	Return status code

Definition at line 422 of file efi_block.c.

                                                         {
        size_t len = le32_to_cpu ( hdr->length );
        struct efi_acpi_table *installed;
        EFI_STATUS efirc;
        int rc;

        /* Allocate installed table record */
        installed = zalloc ( sizeof ( *installed ) );
        if ( ! installed ) {
                rc = -ENOMEM;
                goto err_alloc;
        }

        /* Fill in common parameters */
        strncpy ( hdr->oem_id, "FENSYS", sizeof ( hdr->oem_id ) );
        strncpy ( hdr->oem_table_id, "iPXE", sizeof ( hdr->oem_table_id ) );

        /* Fix up ACPI checksum */
        acpi_fix_checksum ( hdr );

        /* Install table */
        if ( ( efirc = acpi->InstallAcpiTable ( acpi, hdr, len,
                                                &installed->key ) ) != 0 ){
                rc = -EEFI ( efirc );
                DBGC ( acpi, "EFIBLK could not install %s: %s\n",
                       acpi_name ( hdr->signature ), strerror ( rc ) );
                DBGC2_HDA ( acpi, 0, hdr, len );
                goto err_install;
        }

        /* Add to list of installed tables */
        list_add_tail ( &installed->list, &efi_acpi_tables );

        DBGC ( acpi, "EFIBLK installed %s as ACPI table %#lx\n",
               acpi_name ( hdr->signature ),
               ( ( unsigned long ) installed->key ) );
        DBGC2_HDA ( acpi, 0, hdr, len );
        return 0;

        list_del ( &installed->list );
 err_install:
        free ( installed );
 err_alloc:
        return rc;
}

References acpi, acpi_fix_checksum(), acpi_name(), DBGC, DBGC2_HDA, EEFI, ENOMEM, free, hdr, _EFI_ACPI_TABLE_PROTOCOL::InstallAcpiTable, efi_acpi_table::key, le32_to_cpu, len, efi_acpi_table::list, list_add_tail, list_del, rc, strerror(), strncpy(), and zalloc().

Referenced by efi_block_describe().

efi_block_describe()

static int efi_block_describe ( void  )

static

Describe EFI block devices.

Return values

rc	Return status code

Definition at line 473 of file efi_block.c.

                                       {
        struct efi_acpi_table *installed;
        struct efi_acpi_table *tmp;
        UINTN key;
        EFI_STATUS efirc;
        int rc;

        /* Sanity check */
        if ( ! acpi ) {
                DBG ( "EFIBLK has no ACPI table protocol\n" );
                return -ENOTSUP;
        }

        /* Uninstall any existing ACPI tables */
        list_for_each_entry_safe ( installed, tmp, &efi_acpi_tables, list ) {
                key = installed->key;
                if ( ( efirc = acpi->UninstallAcpiTable ( acpi, key ) ) != 0 ) {
                        rc = -EEFI ( efirc );
                        DBGC ( acpi, "EFIBLK could not uninstall ACPI table "
                               "%#lx: %s\n", ( ( unsigned long ) key ),
                               strerror ( rc ) );
                        /* Continue anyway */
                }
                list_del ( &installed->list );
                free ( installed );
        }

        /* Install ACPI tables */
        if ( ( rc = acpi_install ( efi_block_install ) ) != 0 )  {
                DBGC ( acpi, "EFIBLK could not install ACPI tables: %s\n",
                       strerror ( rc ) );
                return rc;
        }

        return 0;
}

References acpi, acpi_install(), DBG, DBGC, EEFI, efi_block_install(), ENOTSUP, free, key, efi_acpi_table::key, efi_acpi_table::list, list_del, list_for_each_entry_safe, rc, strerror(), tmp, and _EFI_ACPI_TABLE_PROTOCOL::UninstallAcpiTable.

efi_block_boot_image()

static int efi_block_boot_image ( struct san_device *  sandev, EFI_HANDLE  handle, const char *  filename, EFI_HANDLE *  image  )

static

Try booting from child device of EFI block device.

Parameters

sandev	SAN device
handle	EFI handle
filename	Filename (or NULL to use default)
image	Image handle to fill in

Return values

rc	Return status code

Definition at line 519 of file efi_block.c.

                                                                            {
        EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
        struct efi_block_data *block = sandev->priv;
        union {
                EFI_DEVICE_PATH_PROTOCOL *path;
                void *interface;
        } path;
        EFI_DEVICE_PATH_PROTOCOL *boot_path;
        FILEPATH_DEVICE_PATH *filepath;
        EFI_DEVICE_PATH_PROTOCOL *end;
        size_t prefix_len;
        size_t filepath_len;
        size_t boot_path_len;
        EFI_STATUS efirc;
        int rc;

        /* Identify device path */
        if ( ( efirc = bs->OpenProtocol ( handle,
                                          &efi_device_path_protocol_guid,
                                          &path.interface, efi_image_handle,
                                          handle,
                                          EFI_OPEN_PROTOCOL_GET_PROTOCOL ))!=0){
                DBGC ( sandev, "EFIBLK %#02x found filesystem with no device "
                       "path??", sandev->drive );
                rc = -EEFI ( efirc );
                goto err_open_device_path;
        }

        /* Check if this device is a child of our block device */
        prefix_len = efi_path_len ( block->path );
        if ( memcmp ( path.path, block->path, prefix_len ) != 0 ) {
                /* Not a child device */
                rc = -ENOTTY;
                goto err_not_child;
        }
        DBGC ( sandev, "EFIBLK %#02x found child device %s\n",
               sandev->drive, efi_devpath_text ( path.path ) );

        /* Construct device path for boot image */
        end = efi_path_end ( path.path );
        prefix_len = ( ( ( void * ) end ) - ( ( void * ) path.path ) );
        filepath_len = ( SIZE_OF_FILEPATH_DEVICE_PATH +
                         ( filename ?
                           ( ( strlen ( filename ) + 1 /* NUL */ ) *
                             sizeof ( filepath->PathName[0] ) ) :
                           sizeof ( efi_block_boot_filename ) ) );
        boot_path_len = ( prefix_len + filepath_len + sizeof ( *end ) );
        boot_path = zalloc ( boot_path_len );
        if ( ! boot_path ) {
                rc = -ENOMEM;
                goto err_alloc_path;
        }
        memcpy ( boot_path, path.path, prefix_len );
        filepath = ( ( ( void * ) boot_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 );
        if ( filename ) {
                efi_sprintf ( filepath->PathName, "%s", filename );
        } else {
                memcpy ( filepath->PathName, efi_block_boot_filename,
                         sizeof ( efi_block_boot_filename ) );
        }
        end = ( ( ( void * ) filepath ) + filepath_len );
        end->Type = END_DEVICE_PATH_TYPE;
        end->SubType = END_ENTIRE_DEVICE_PATH_SUBTYPE;
        end->Length[0] = sizeof ( *end );
        DBGC ( sandev, "EFIBLK %#02x trying to load %s\n",
               sandev->drive, efi_devpath_text ( boot_path ) );

        /* Try loading boot image from this device */
        *image = NULL;
        if ( ( efirc = bs->LoadImage ( FALSE, efi_image_handle, boot_path,
                                       NULL, 0, image ) ) != 0 ) {
                rc = -EEFI ( efirc );
                DBGC ( sandev, "EFIBLK %#02x could not load image: %s\n",
                       sandev->drive, strerror ( rc ) );
                if ( efirc == EFI_SECURITY_VIOLATION )
                        bs->UnloadImage ( *image );
                goto err_load_image;
        }

        /* Success */
        rc = 0;

 err_load_image:
        free ( boot_path );
 err_alloc_path:
 err_not_child:
 err_open_device_path:
        return rc;
}

References block, EFI_SYSTEM_TABLE::BootServices, DBGC, san_device::drive, EEFI, efi_block_boot_filename, efi_device_path_protocol_guid, efi_devpath_text(), efi_image_handle, EFI_OPEN_PROTOCOL_GET_PROTOCOL, efi_path_end(), efi_path_len(), EFI_SECURITY_VIOLATION, efi_sprintf, efi_systab, end, END_DEVICE_PATH_TYPE, END_ENTIRE_DEVICE_PATH_SUBTYPE, ENOMEM, ENOTTY, FALSE, free, handle, FILEPATH_DEVICE_PATH::Header, EFI_DEVICE_PATH_PROTOCOL::Length, EFI_BOOT_SERVICES::LoadImage, MEDIA_DEVICE_PATH, MEDIA_FILEPATH_DP, memcmp(), memcpy(), NULL, EFI_BOOT_SERVICES::OpenProtocol, efi_block_data::path, FILEPATH_DEVICE_PATH::PathName, san_device::priv, rc, efi_block_data::sandev, SIZE_OF_FILEPATH_DEVICE_PATH, strerror(), strlen(), EFI_DEVICE_PATH_PROTOCOL::SubType, EFI_DEVICE_PATH_PROTOCOL::Type, EFI_BOOT_SERVICES::UnloadImage, and zalloc().

Referenced by efi_block_boot().

efi_block_boot()

static int efi_block_boot ( unsigned int  drive, const char *  filename  )

static

Boot from EFI block device.

Parameters

drive	Drive number
filename	Filename (or NULL to use default)

Return values

rc	Return status code

Definition at line 621 of file efi_block.c.

                                                                       {
        EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
        struct san_device *sandev;
        EFI_HANDLE *handles;
        EFI_HANDLE image = NULL;
        UINTN count;
        unsigned int i;
        EFI_STATUS efirc;
        int rc;

        /* Find SAN device */
        sandev = sandev_find ( drive );
        if ( ! sandev ) {
                DBG ( "EFIBLK cannot find drive %#02x\n", drive );
                rc = -ENODEV;
                goto err_sandev_find;
        }

        /* Release SNP devices */
        efi_snp_release();

        /* Connect all possible protocols */
        efi_block_connect ( sandev );

        /* Locate all handles supporting the Simple File System protocol */
        if ( ( efirc = bs->LocateHandleBuffer (
                        ByProtocol, &efi_simple_file_system_protocol_guid,
                        NULL, &count, &handles ) ) != 0 ) {
                rc = -EEFI ( efirc );
                DBGC ( sandev, "EFIBLK %#02x cannot locate file systems: %s\n",
                       sandev->drive, strerror ( rc ) );
                goto err_locate_file_systems;
        }

        /* Try booting from any available child device containing a
         * suitable boot image.  This is something of a wild stab in
         * the dark, but should end up conforming to user expectations
         * most of the time.
         */
        rc = -ENOENT;
        for ( i = 0 ; i < count ; i++ ) {
                if ( ( rc = efi_block_boot_image ( sandev, handles[i], filename,
                                                   &image ) ) != 0 )
                        continue;
                DBGC ( sandev, "EFIBLK %#02x found boot image\n",
                       sandev->drive );
                efirc = bs->StartImage ( image, NULL, NULL );
                rc = ( efirc ? -EEFI ( efirc ) : 0 );
                bs->UnloadImage ( image );
                DBGC ( sandev, "EFIBLK %#02x boot image returned: %s\n",
                       sandev->drive, strerror ( rc ) );
                break;
        }

        bs->FreePool ( handles );
 err_locate_file_systems:
        efi_snp_claim();
 err_sandev_find:
        return rc;
}

References EFI_SYSTEM_TABLE::BootServices, ByProtocol, count, DBG, DBGC, drive, san_device::drive, EEFI, efi_block_boot_image(), efi_block_connect(), efi_simple_file_system_protocol_guid, efi_snp_claim(), efi_snp_release(), efi_systab, ENODEV, ENOENT, EFI_BOOT_SERVICES::FreePool, EFI_BOOT_SERVICES::LocateHandleBuffer, NULL, rc, sandev_find(), EFI_BOOT_SERVICES::StartImage, strerror(), and EFI_BOOT_SERVICES::UnloadImage.

PROVIDE_SANBOOT() [1/4]

PROVIDE_SANBOOT	(	efi	,
		san_hook	,
		efi_block_hook
	)

PROVIDE_SANBOOT() [2/4]

PROVIDE_SANBOOT	(	efi	,
		san_unhook	,
		efi_block_unhook
	)

PROVIDE_SANBOOT() [3/4]

PROVIDE_SANBOOT	(	efi	,
		san_describe	,
		efi_block_describe
	)

PROVIDE_SANBOOT() [4/4]

PROVIDE_SANBOOT	(	efi	,
		san_boot	,
		efi_block_boot
	)

Variable Documentation

acpi

EFI_ACPI_TABLE_PROTOCOL* acpi

static

ACPI table protocol protocol.

Definition at line 62 of file efi_block.c.

Referenced by acpi_find_via_rsdt(), acpi_fix_checksum(), acpi_settings_fetch(), acpi_zsdt(), dummy_install(), efi_block_describe(), efi_block_install(), ibft_install(), int13_install(), nii_pci_open(), and typeof().

efi_block_boot_filename

wchar_t efi_block_boot_filename[] = EFI_REMOVABLE_MEDIA_FILE_NAME

static

Boot filename.

Definition at line 66 of file efi_block.c.

Referenced by efi_block_boot_image().