efi_file.c File Reference

EFI file protocols. More...

#include <stddef.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <strings.h>
#include <errno.h>
#include <wchar.h>
#include <ipxe/image.h>
#include <ipxe/cpio.h>
#include <ipxe/initrd.h>
#include <ipxe/efi/efi.h>
#include <ipxe/efi/Protocol/SimpleFileSystem.h>
#include <ipxe/efi/Protocol/BlockIo.h>
#include <ipxe/efi/Protocol/DiskIo.h>
#include <ipxe/efi/Protocol/LoadFile2.h>
#include <ipxe/efi/Guid/FileInfo.h>
#include <ipxe/efi/Guid/FileSystemInfo.h>
#include <ipxe/efi/efi_strings.h>
#include <ipxe/efi/efi_path.h>
#include <ipxe/efi/efi_file.h>

Go to the source code of this file.

Data Structures
struct	efi_file_reader
	An EFI virtual file reader. More...
struct	efi_file
	An EFI file. More...
struct	efi_file_path
	An EFI fixed device path file. More...

Macros
#define	EFI_MEDIA_ID_MAGIC   0x69505845
	EFI media ID.
#define	LINUX_INITRD_VENDOR_GUID
	Linux initrd fixed device path vendor GUID.

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
	FILE_SECBOOT (PERMITTED)
static void	efi_file_free (struct refcnt *refcnt)
	Free EFI file.
static const char *	efi_file_name (struct efi_file *file)
	Get EFI file name (for debugging)
static struct image *	efi_file_find (const char *name)
	Find EFI file image.
static size_t	efi_file_len (struct efi_file *file)
	Get length of EFI file.
static size_t	efi_file_read_chunk (struct efi_file_reader *reader, const void *data, size_t len)
	Read chunk of EFI file.
static size_t	efi_file_read_image (struct efi_file_reader *reader)
	Read from image-backed file.
static size_t	efi_file_read_initrd (struct efi_file_reader *reader)
	Read from magic initrd file.
static EFI_STATUS	efi_file_open_fixed (struct efi_file *file, const wchar_t *wname, EFI_FILE_PROTOCOL **new)
	Open fixed file.
static void	efi_file_image (struct efi_file *file, struct image *image)
	Associate file with image.
static EFI_STATUS	efi_file_open_image (struct image *image, const wchar_t *wname, EFI_FILE_PROTOCOL **new)
	Open image-backed file.
static EFI_STATUS EFIAPI	efi_file_open (EFI_FILE_PROTOCOL *this, EFI_FILE_PROTOCOL **new, CHAR16 *wname, UINT64 mode, UINT64 attributes __unused)
	Open file.
static EFI_STATUS EFIAPI	efi_file_close (EFI_FILE_PROTOCOL *this)
	Close file.
static EFI_STATUS EFIAPI	efi_file_delete (EFI_FILE_PROTOCOL *this)
	Close and delete file.
static EFI_STATUS	efi_file_varlen (UINT64 *base, size_t base_len, const char *name, UINTN *len, VOID *data)
	Return variable-length data structure.
static EFI_STATUS	efi_file_info (struct efi_file *file, UINTN *len, VOID *data)
	Return file information structure.
static EFI_STATUS	efi_file_read_dir (struct efi_file *file, UINTN *len, VOID *data)
	Read directory entry.
static EFI_STATUS EFIAPI	efi_file_read (EFI_FILE_PROTOCOL *this, UINTN *len, VOID *data)
	Read from file.
static EFI_STATUS EFIAPI	efi_file_write (EFI_FILE_PROTOCOL *this, UINTN *len, VOID *data __unused)
	Write to file.
static EFI_STATUS EFIAPI	efi_file_set_position (EFI_FILE_PROTOCOL *this, UINT64 position)
	Set file position.
static EFI_STATUS EFIAPI	efi_file_get_position (EFI_FILE_PROTOCOL *this, UINT64 *position)
	Get file position.
static EFI_STATUS EFIAPI	efi_file_get_info (EFI_FILE_PROTOCOL *this, EFI_GUID *type, UINTN *len, VOID *data)
	Get file information.
static EFI_STATUS EFIAPI	efi_file_set_info (EFI_FILE_PROTOCOL *this, EFI_GUID *type, UINTN len __unused, VOID *data __unused)
	Set file information.
static EFI_STATUS EFIAPI	efi_file_flush (EFI_FILE_PROTOCOL *this)
	Flush file modified data.
static EFI_STATUS EFIAPI	efi_file_load (EFI_LOAD_FILE2_PROTOCOL *this, EFI_DEVICE_PATH_PROTOCOL *path __unused, BOOLEAN boot __unused, UINTN *len, VOID *data)
	Load file.
static EFI_STATUS EFIAPI	efi_file_open_volume (EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *filesystem __unused, EFI_FILE_PROTOCOL **file)
	Open root directory.
static EFI_STATUS EFIAPI	efi_block_io_reset (EFI_BLOCK_IO_PROTOCOL *this __unused, BOOLEAN extended)
	Dummy block I/O reset.
static EFI_STATUS EFIAPI	efi_block_io_read_blocks (EFI_BLOCK_IO_PROTOCOL *this __unused, UINT32 MediaId, EFI_LBA lba, UINTN len, VOID *data)
	Dummy block I/O read.
static EFI_STATUS EFIAPI	efi_block_io_write_blocks (EFI_BLOCK_IO_PROTOCOL *this __unused, UINT32 MediaId, EFI_LBA lba, UINTN len, VOID *data)
	Dummy block I/O write.
static EFI_STATUS EFIAPI	efi_block_io_flush_blocks (EFI_BLOCK_IO_PROTOCOL *this __unused)
	Dummy block I/O flush.
static EFI_STATUS EFIAPI	efi_disk_io_read_disk (EFI_DISK_IO_PROTOCOL *this __unused, UINT32 MediaId, UINT64 offset, UINTN len, VOID *data)
	Dummy disk I/O read.
static EFI_STATUS EFIAPI	efi_disk_io_write_disk (EFI_DISK_IO_PROTOCOL *this __unused, UINT32 MediaId, UINT64 offset, UINTN len, VOID *data)
	Dummy disk I/O write.
static int	efi_file_path_claim (struct efi_file_path *file)
	Claim use of fixed device path.
static int	efi_file_path_install (struct efi_file_path *file)
	Install fixed device path file.
static void	efi_file_path_uninstall (struct efi_file_path *file)
	Uninstall fixed device path file.
int	efi_file_install (EFI_HANDLE handle)
	Install EFI simple file system protocol.
void	efi_file_uninstall (EFI_HANDLE handle)
	Uninstall EFI simple file system protocol.

Variables
static struct efi_file	efi_file_root
	Root directory.
static struct efi_file_path	efi_file_initrd
	Magic initrd file.
struct {
VENDOR_DEVICE_PATH   vendor
EFI_DEVICE_PATH_PROTOCOL   end
}	efi_file_initrd_path
	Linux initrd fixed device path.
static EFI_SIMPLE_FILE_SYSTEM_PROTOCOL	efi_simple_file_system_protocol
	EFI simple file system protocol.
static EFI_BLOCK_IO_MEDIA	efi_block_io_media
	Dummy block I/O media.
static EFI_BLOCK_IO_PROTOCOL	efi_block_io_protocol
	Dummy EFI block I/O protocol.
static EFI_DISK_IO_PROTOCOL	efi_disk_io_protocol
	Dummy EFI disk I/O protocol.

Detailed Description

EFI file protocols.

Definition in file efi_file.c.

Macro Definition Documentation

EFI_MEDIA_ID_MAGIC

#define EFI_MEDIA_ID_MAGIC   0x69505845

EFI media ID.

Definition at line 56 of file efi_file.c.

LINUX_INITRD_VENDOR_GUID

#define LINUX_INITRD_VENDOR_GUID

Value:

        { 0x5568e427, 0x68fc, 0x4f3d,                                   \
          { 0xac, 0x74, 0xca, 0x55, 0x52, 0x31, 0xcc, 0x68 } }

Linux initrd fixed device path vendor GUID.

Definition at line 59 of file efi_file.c.

#define LINUX_INITRD_VENDOR_GUID                                        \
        { 0x5568e427, 0x68fc, 0x4f3d,                                   \
          { 0xac, 0x74, 0xca, 0x55, 0x52, 0x31, 0xcc, 0x68 } }

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

FILE_SECBOOT()

FILE_SECBOOT

(

PERMITTED

)

efi_file_free()

void efi_file_free ( struct refcnt * refcnt )

static

Free EFI file.

Parameters

refcnt

Reference count

Definition at line 116 of file efi_file.c.

                                                    {
        struct efi_file *file =
                container_of ( refcnt, struct efi_file, refcnt );
 
        image_put ( file->image );
        free ( file );
}

References container_of, efi_file::file, free, and image_put().

Referenced by efi_file_open_image().

efi_file_name()

const char * efi_file_name ( struct efi_file * file )

static

Get EFI file name (for debugging)

Parameters

file

EFI file

Return values

name

Name

Definition at line 130 of file efi_file.c.

                                                            {
 
        return ( file == &efi_file_root ? "<root>" : file->name );
}

References efi_file_root, and efi_file::file.

Referenced by efi_file_close(), efi_file_delete(), efi_file_flush(), efi_file_get_info(), efi_file_load(), efi_file_open(), efi_file_open_fixed(), efi_file_open_image(), efi_file_path_claim(), efi_file_path_install(), efi_file_path_uninstall(), efi_file_read(), efi_file_read_initrd(), efi_file_set_info(), efi_file_set_position(), and efi_file_write().

efi_file_find()

struct image * efi_file_find ( const char * name )

static

Find EFI file image.

Parameters

name

Filename

Return values

image

Image, or NULL

Definition at line 141 of file efi_file.c.

                                                         {
        struct image *image;
 
        /* Find image */
        for_each_image ( image ) {
                if ( strcasecmp ( image->name, name ) == 0 )
                        return image;
        }
 
        return NULL;
}

References for_each_image, image::name, name, NULL, and strcasecmp().

Referenced by efi_file_open().

efi_file_len()

size_t efi_file_len ( struct efi_file * file )

static

Get length of EFI file.

Parameters

file

EFI file

Return values

len	Length of file

Definition at line 159 of file efi_file.c.

                                                     {
        struct efi_file_reader reader;
 
        /* If this is the root directory, then treat as length zero */
        if ( ! file->read )
                return 0;
 
        /* Initialise reader */
        reader.file = file;
        reader.pos = 0;
        reader.data = NULL;
        reader.len = 0;
 
        /* Perform dummy read to determine file length */
        file->read ( &reader );
 
        return reader.pos;
}

References efi_file_reader::data, efi_file_reader::file, efi_file_reader::len, NULL, efi_file_reader::pos, and efi_file::read.

Referenced by efi_file_info(), efi_file_load(), and efi_file_set_position().

efi_file_read_chunk()

size_t efi_file_read_chunk ( struct efi_file_reader * reader, const void * data, size_t len )

static

Read chunk of EFI file.

Parameters

reader	EFI file reader
data	Input data, or NULL to zero-fill
len	Length of input data

Return values

len	Length of output data

Definition at line 186 of file efi_file.c.

                                                                   {
        struct efi_file *file = reader->file;
        size_t offset;
 
        /* Calculate offset into input data */
        offset = ( file->pos - reader->pos );
 
        /* Consume input data range */
        reader->pos += len;
 
        /* Calculate output length */
        if ( offset < len ) {
                len -= offset;
        } else {
                len = 0;
        }
        if ( len > reader->len )
                len = reader->len;
 
        /* Copy or zero output data */
        if ( data ) {
                memcpy ( reader->data, ( data + offset ), len );
        } else {
                memset ( reader->data, 0, len );
        }
 
        /* Consume output buffer */
        file->pos += len;
        reader->data += len;
        reader->len -= len;
 
        return len;
}

References data, efi_file_reader::data, efi_file::file, efi_file_reader::file, efi_file_reader::len, len, memcpy(), memset(), offset, and efi_file_reader::pos.

Referenced by efi_file_read_image(), and efi_file_read_initrd().

efi_file_read_image()

size_t efi_file_read_image ( struct efi_file_reader * reader )

static

Read from image-backed file.

Parameters

reader

EFI file reader

Return values

len	Length read

Definition at line 227 of file efi_file.c.

                                                                     {
        struct efi_file *file = reader->file;
        struct image *image = file->image;
 
        /* Read from file */
        return efi_file_read_chunk ( reader, image->data, image->len );
}

References image::data, efi_file_read_chunk(), efi_file::file, efi_file_reader::file, efi_file::image, and image::len.

Referenced by efi_file_image().

efi_file_read_initrd()

size_t efi_file_read_initrd ( struct efi_file_reader * reader )

static

Read from magic initrd file.

Parameters

reader

EFI file reader

Return values

len	Length read

Definition at line 241 of file efi_file.c.

                                                                      {
        struct efi_file *file = reader->file;
        struct cpio_header cpio;
        struct image *image;
        const char *name;
        size_t pad_len;
        size_t cpio_len;
        size_t name_len;
        size_t len;
        unsigned int i;
 
        /* Read from file */
        len = 0;
        for_each_image ( image ) {
 
                /* Skip hidden images */
                if ( image->flags & IMAGE_HIDDEN )
                        continue;
 
                /* Pad to alignment boundary */
                pad_len = ( ( -reader->pos ) & ( INITRD_ALIGN - 1 ) );
                if ( pad_len ) {
                        DBGC ( file, "EFIFILE %s [%#08zx,%#08zx) pad\n",
                               efi_file_name ( file ), reader->pos,
                               ( reader->pos + pad_len ) );
                }
                len += efi_file_read_chunk ( reader, NULL, pad_len );
 
                /* Read CPIO header(s), if applicable */
                name = cpio_name ( image );
                for ( i = 0 ; ( cpio_len = cpio_header ( image, i, &cpio ) );
                      i++ ) {
                        name_len = ( cpio_len - sizeof ( cpio ) );
                        pad_len = cpio_pad_len ( cpio_len );
                        DBGC ( file, "EFIFILE %s [%#08zx,%#08zx) %s header\n",
                               efi_file_name ( file ), reader->pos,
                               ( reader->pos + cpio_len + pad_len ),
                               image->name );
                        len += efi_file_read_chunk ( reader, &cpio,
                                                     sizeof ( cpio ) );
                        len += efi_file_read_chunk ( reader, name, name_len );
                        len += efi_file_read_chunk ( reader, NULL, pad_len );
                }
 
                /* Read file data */
                DBGC ( file, "EFIFILE %s [%#08zx,%#08zx) %s\n",
                       efi_file_name ( file ), reader->pos,
                       ( reader->pos + image->len ), image->name );
                len += efi_file_read_chunk ( reader, image->data, image->len );
        }
 
        return len;
}

References cpio_header(), cpio_name(), cpio_pad_len(), image::data, DBGC, efi_file_name(), efi_file_read_chunk(), efi_file::file, efi_file_reader::file, image::flags, for_each_image, IMAGE_HIDDEN, INITRD_ALIGN, image::len, len, image::name, name, NULL, pad_len, and efi_file_reader::pos.

efi_file_open_fixed()

EFI_STATUS efi_file_open_fixed ( struct efi_file * file, const wchar_t * wname, EFI_FILE_PROTOCOL ** new )

static

Open fixed file.

Parameters

file	EFI file
wname	Filename
new	New EFI file

Return values

efirc

EFI status code

Definition at line 303 of file efi_file.c.

                                                                  {
 
        /* Increment reference count */
        ref_get ( &file->refcnt );
 
        /* Return opened file */
        *new = &file->file;
 
        DBGC ( file, "EFIFILE %s opened via %ls\n",
               efi_file_name ( file ), wname );
        return 0;
}

References DBGC, efi_file_name(), efi_file::file, ref_get, and efi_file::refcnt.

Referenced by efi_file_open(), and efi_file_open_volume().

efi_file_image()

void efi_file_image ( struct efi_file * file, struct image * image )

static

Associate file with image.

Parameters

file	EFI file
image	Image

Definition at line 324 of file efi_file.c.

                                                                          {
 
        file->image = image;
        file->name = image->name;
        file->read = efi_file_read_image;
}

References efi_file_read_image(), efi_file::image, efi_file::name, image::name, and efi_file::read.

Referenced by efi_file_open_image(), and efi_file_read_dir().

efi_file_open_image()

EFI_STATUS efi_file_open_image ( struct image * image, const wchar_t * wname, EFI_FILE_PROTOCOL ** new )

static

Open image-backed file.

Parameters

image	Image
wname	Filename
new	New EFI file

Return values

efirc

EFI status code

Definition at line 339 of file efi_file.c.

                                                                  {
        struct efi_file *file;
 
        /* Allocate and initialise file */
        file = zalloc ( sizeof ( *file ) );
        if ( ! file )
                return EFI_OUT_OF_RESOURCES;
        ref_init ( &file->refcnt, efi_file_free );
        memcpy ( &file->file, &efi_file_root.file, sizeof ( file->file ) );
        memcpy ( &file->load, &efi_file_root.load, sizeof ( file->load ) );
        efi_file_image ( file, image_get ( image ) );
 
        /* Return opened file */
        *new = &file->file;
 
        DBGC ( file, "EFIFILE %s opened via %ls\n",
               efi_file_name ( file ), wname );
        return 0;
}

References DBGC, efi_file_free(), efi_file_image(), efi_file_name(), efi_file_root, EFI_OUT_OF_RESOURCES, efi_file::file, image_get(), memcpy(), ref_init, and zalloc().

Referenced by efi_file_open().

efi_file_open()

EFI_STATUS EFIAPI efi_file_open ( EFI_FILE_PROTOCOL * this, EFI_FILE_PROTOCOL ** new, CHAR16 * wname, UINT64 mode, UINT64 attributes __unused )

static

Open file.

Parameters

this

EFI file

Return values

new	New EFI file

Parameters

wname	Filename
mode	File mode
attributes	File attributes (for newly-created files)

Return values

efirc

EFI status code

Definition at line 372 of file efi_file.c.

                                                                         {
        struct efi_file *file = container_of ( this, struct efi_file, file );
        char buf[ wcslen ( wname ) + 1 /* NUL */ ];
        struct image *image;
        char *name;
        char *sep;
 
        /* Convert name to ASCII */
        snprintf ( buf, sizeof ( buf ), "%ls", wname );
        name = buf;
 
        /* Initial '\' indicates opening from the root directory */
        while ( *name == '\\' ) {
                file = &efi_file_root;
                name++;
        }
 
        /* Strip redundant path separator characters */
        while ( ( *name == '\\' ) || ( *name == '.' ) )
                name++;
 
        /* Allow root directory itself to be opened */
        if ( ! *name )
                return efi_file_open_fixed ( &efi_file_root, wname, new );
 
        /* Fail unless opening from the root */
        if ( file != &efi_file_root ) {
                DBGC ( file, "EFIFILE %s is not a directory\n",
                       efi_file_name ( file ) );
                return EFI_NOT_FOUND;
        }
 
        /* Fail unless opening read-only */
        if ( mode != EFI_FILE_MODE_READ ) {
                DBGC ( file, "EFIFILE %s cannot be opened in mode %#08llx\n",
                       name, mode );
                return EFI_WRITE_PROTECTED;
        }
 
        /* Allow registered images to be opened */
        if ( ( image = efi_file_find ( name ) ) != NULL )
                return efi_file_open_image ( image, wname, new );
 
        /* Allow magic initrd to be opened */
        if ( strcasecmp ( name, efi_file_initrd.file.name ) == 0 ) {
                return efi_file_open_fixed ( &efi_file_initrd.file, wname,
                                             new );
        }
 
        /* Allow currently selected image to be opened as "grub*.efi",
         * to work around buggy versions of the UEFI shim.
         */
        if ( ( strncasecmp ( name, "grub", 4 ) == 0 ) &&
             ( ( sep = strrchr ( name, '.' ) ) != NULL ) &&
             ( strcasecmp ( sep, ".efi" ) == 0 ) &&
             ( ( image = find_image_tag ( &selected_image ) ) != NULL ) ) {
                return efi_file_open_image ( image, wname, new );
        }
 
        DBGC ( file, "EFIFILE %ls does not exist\n", wname );
        return EFI_NOT_FOUND;
}

References __unused, container_of, DBGC, efi_file_find(), efi_file_initrd, EFI_FILE_MODE_READ, efi_file_name(), efi_file_open_fixed(), efi_file_open_image(), efi_file_root, EFI_NOT_FOUND, EFI_WRITE_PROTECTED, efi_file::file, find_image_tag(), mode, name, NULL, selected_image, snprintf(), strcasecmp(), strncasecmp(), strrchr(), and wcslen().

efi_file_close()

EFI_STATUS EFIAPI efi_file_close ( EFI_FILE_PROTOCOL * this )

static

Close file.

Parameters

this

EFI file

Return values

efirc

EFI status code

Definition at line 442 of file efi_file.c.

                                                                    {
        struct efi_file *file = container_of ( this, struct efi_file, file );
 
        /* Close file */
        DBGC ( file, "EFIFILE %s closed\n", efi_file_name ( file ) );
        ref_put ( &file->refcnt );
 
        return 0;
}

References container_of, DBGC, efi_file_name(), EFIAPI, efi_file::file, and ref_put.

Referenced by efi_file_delete().

efi_file_delete()

EFI_STATUS EFIAPI efi_file_delete ( EFI_FILE_PROTOCOL * this )

static

Close and delete file.

Parameters

this

EFI file

Return values

efirc

EFI status code

Definition at line 458 of file efi_file.c.

                                                                     {
        struct efi_file *file = container_of ( this, struct efi_file, file );
 
        DBGC ( file, "EFIFILE %s cannot be deleted\n", efi_file_name ( file ) );
 
        /* Close file */
        efi_file_close ( this );
 
        /* Warn of failure to delete */
        return EFI_WARN_DELETE_FAILURE;
}

References container_of, DBGC, efi_file_close(), efi_file_name(), EFI_WARN_DELETE_FAILURE, EFIAPI, and efi_file::file.

efi_file_varlen()

EFI_STATUS efi_file_varlen ( UINT64 * base, size_t base_len, const char * name, UINTN * len, VOID * data )

static

Return variable-length data structure.

Parameters

base	Base data structure (starting with UINT64)
base_len	Length of base data structure
name	Name to append to base data structure
len	Length of data buffer
data	Data buffer

Return values

efirc

EFI status code

Definition at line 480 of file efi_file.c.

                                                                               {
        size_t name_len;
 
        /* Calculate structure length */
        name_len = strlen ( name );
        *base = ( base_len + ( name_len + 1 /* NUL */ ) * sizeof ( wchar_t ) );
        if ( *len < *base ) {
                *len = *base;
                return EFI_BUFFER_TOO_SMALL;
        }
 
        /* Copy data to buffer */
        *len = *base;
        memcpy ( data, base, base_len );
        efi_snprintf ( ( data + base_len ), ( name_len + 1 /* NUL */ ),
                       "%s", name );
 
        return 0;
}

References base, data, EFI_BUFFER_TOO_SMALL, efi_snprintf(), len, memcpy(), name, strlen(), and VOID.

Referenced by efi_file_get_info(), and efi_file_info().

efi_file_info()

EFI_STATUS efi_file_info ( struct efi_file * file, UINTN * len, VOID * data )

static

Return file information structure.

Parameters

file	EFI file
len	Length of data buffer
data	Data buffer

Return values

efirc

EFI status code

Definition at line 509 of file efi_file.c.

                                               {
        EFI_FILE_INFO info;
        size_t file_len;
 
        /* Get file length */
        file_len = efi_file_len ( file );
 
        /* Populate file information */
        memset ( &info, 0, sizeof ( info ) );
        info.FileSize = file_len;
        info.PhysicalSize = file_len;
        info.Attribute = EFI_FILE_READ_ONLY;
        if ( file == &efi_file_root )
                info.Attribute |= EFI_FILE_DIRECTORY;
 
        return efi_file_varlen ( &info.Size, SIZE_OF_EFI_FILE_INFO,
                                 file->name, len, data );
}

References data, EFI_FILE_DIRECTORY, efi_file_len(), EFI_FILE_READ_ONLY, efi_file_root, efi_file_varlen(), efi_file::file, info, len, memset(), SIZE_OF_EFI_FILE_INFO, and VOID.

Referenced by efi_file_get_info(), and efi_file_read_dir().

efi_file_read_dir()

EFI_STATUS efi_file_read_dir ( struct efi_file * file, UINTN * len, VOID * data )

static

Read directory entry.

Parameters

file	EFI file
len	Length to read
data	Data buffer

Return values

efirc

EFI status code

Definition at line 537 of file efi_file.c.

                                                   {
        EFI_STATUS efirc;
        struct efi_file entry;
        struct image *image;
        unsigned int index;
 
        /* Construct directory entries for image-backed files */
        index = file->pos;
        for_each_image ( image ) {
 
                /* Skip hidden images */
                if ( image->flags & IMAGE_HIDDEN )
                        continue;
 
                /* Skip preceding images */
                if ( index-- )
                        continue;
 
                /* Construct directory entry */
                efi_file_image ( &entry, image );
                efirc = efi_file_info ( &entry, len, data );
                if ( efirc == 0 )
                        file->pos++;
                return efirc;
        }
 
        /* No more entries */
        *len = 0;
        return 0;
}

References data, efi_file_image(), efi_file_info(), image::flags, for_each_image, IMAGE_HIDDEN, index, len, efi_file::pos, and VOID.

Referenced by efi_file_read().

efi_file_read()

EFI_STATUS EFIAPI efi_file_read ( EFI_FILE_PROTOCOL * this, UINTN * len, VOID * data )

static

Read from file.

Parameters

this	EFI file
len	Length to read
data	Data buffer

Return values

efirc

EFI status code

Definition at line 577 of file efi_file.c.

                                                                  {
        struct efi_file *file = container_of ( this, struct efi_file, file );
        struct efi_file_reader reader;
        size_t pos = file->pos;
 
        /* If this is the root directory, then construct a directory entry */
        if ( ! file->read )
                return efi_file_read_dir ( file, len, data );
 
        /* Initialise reader */
        reader.file = file;
        reader.pos = 0;
        reader.data = data;
        reader.len = *len;
 
        /* Read from the file */
        DBGC ( file, "EFIFILE %s read [%#08zx,%#08zx)\n",
               efi_file_name ( file ), pos, ( ( size_t ) ( pos + *len ) ) );
        *len = file->read ( &reader );
        assert ( ( pos + *len ) == file->pos );
 
        return 0;
}

References assert, container_of, data, efi_file_reader::data, DBGC, efi_file_name(), efi_file_read_dir(), EFIAPI, efi_file::file, efi_file_reader::file, efi_file_reader::len, len, efi_file::pos, efi_file_reader::pos, efi_file::read, and VOID.

Referenced by efi_file_load().

efi_file_write()

EFI_STATUS EFIAPI efi_file_write ( EFI_FILE_PROTOCOL * this, UINTN * len, VOID *data __unused )

static

Write to file.

Parameters

this	EFI file
len	Length to write
data	Data buffer

Return values

efirc

EFI status code

Definition at line 610 of file efi_file.c.

                                                                            {
        struct efi_file *file = container_of ( this, struct efi_file, file );
 
        DBGC ( file, "EFIFILE %s cannot write [%#08zx, %#08zx)\n",
               efi_file_name ( file ), file->pos,
               ( ( size_t ) ( file->pos + *len ) ) );
        return EFI_WRITE_PROTECTED;
}

References __unused, container_of, data, DBGC, efi_file_name(), EFI_WRITE_PROTECTED, EFIAPI, efi_file::file, len, and VOID.

efi_file_set_position()

EFI_STATUS EFIAPI efi_file_set_position ( EFI_FILE_PROTOCOL * this, UINT64 position )

static

Set file position.

Parameters

this	EFI file
position	New file position

Return values

efirc

EFI status code

Definition at line 627 of file efi_file.c.

                                                                   {
        struct efi_file *file = container_of ( this, struct efi_file, file );
        size_t len;
 
        /* Get file length */
        len = efi_file_len ( file );
 
        /* Check for the magic end-of-file value */
        if ( position == 0xffffffffffffffffULL )
                position = len;
 
        /* Fail if we attempt to seek past the end of the file (since
         * we do not support writes).
         */
        if ( position > len ) {
                DBGC ( file, "EFIFILE %s cannot seek to %#08llx of %#08zx\n",
                       efi_file_name ( file ), position, len );
                return EFI_UNSUPPORTED;
        }
 
        /* Set position */
        file->pos = position;
        DBGC ( file, "EFIFILE %s position set to %#08zx\n",
               efi_file_name ( file ), file->pos );
 
        return 0;
}

References container_of, DBGC, efi_file_len(), efi_file_name(), EFI_UNSUPPORTED, EFIAPI, efi_file::file, and len.

efi_file_get_position()

EFI_STATUS EFIAPI efi_file_get_position ( EFI_FILE_PROTOCOL * this, UINT64 * position )

static

Get file position.

Parameters

this

EFI file

Return values

position	New file position
efirc	EFI status code

Definition at line 663 of file efi_file.c.

                                                                    {
        struct efi_file *file = container_of ( this, struct efi_file, file );
 
        *position = file->pos;
        return 0;
}

References container_of, EFIAPI, and efi_file::file.

efi_file_get_info()

EFI_STATUS EFIAPI efi_file_get_info ( EFI_FILE_PROTOCOL * this, EFI_GUID * type, UINTN * len, VOID * data )

static

Get file information.

Parameters

this	EFI file
type	Type of information
len	Buffer size
data	Buffer

Return values

efirc

EFI status code

Definition at line 680 of file efi_file.c.

                                                                      {
        struct efi_file *file = container_of ( this, struct efi_file, file );
        EFI_FILE_SYSTEM_INFO fsinfo;
        struct image *image;
 
        /* Determine information to return */
        if ( memcmp ( type, &efi_file_info_id, sizeof ( *type ) ) == 0 ) {
 
                /* Get file information */
                DBGC ( file, "EFIFILE %s get file information\n",
                       efi_file_name ( file ) );
                return efi_file_info ( file, len, data );
 
        } else if ( memcmp ( type, &efi_file_system_info_id,
                             sizeof ( *type ) ) == 0 ) {
 
                /* Get file system information */
                DBGC ( file, "EFIFILE %s get file system information\n",
                       efi_file_name ( file ) );
                memset ( &fsinfo, 0, sizeof ( fsinfo ) );
                fsinfo.ReadOnly = 1;
                for_each_image ( image )
                        fsinfo.VolumeSize += image->len;
                return efi_file_varlen ( &fsinfo.Size,
                                         SIZE_OF_EFI_FILE_SYSTEM_INFO, "iPXE",
                                         len, data );
        } else {
 
                DBGC ( file, "EFIFILE %s cannot get information of type %s\n",
                       efi_file_name ( file ), efi_guid_ntoa ( type ) );
                return EFI_UNSUPPORTED;
        }
}

References container_of, data, DBGC, efi_file_info(), efi_file_info_id, efi_file_name(), efi_file_system_info_id, efi_file_varlen(), efi_guid_ntoa(), EFI_UNSUPPORTED, EFIAPI, efi_file::file, for_each_image, image::len, len, memcmp(), memset(), EFI_FILE_SYSTEM_INFO::ReadOnly, EFI_FILE_SYSTEM_INFO::Size, SIZE_OF_EFI_FILE_SYSTEM_INFO, type, VOID, and EFI_FILE_SYSTEM_INFO::VolumeSize.

efi_file_set_info()

EFI_STATUS EFIAPI efi_file_set_info ( EFI_FILE_PROTOCOL * this, EFI_GUID * type, UINTN len __unused, VOID *data __unused )

static

Set file information.

Parameters

this	EFI file
type	Type of information
len	Buffer size
data	Buffer

Return values

efirc

EFI status code

Definition at line 726 of file efi_file.c.

                                                              {
        struct efi_file *file = container_of ( this, struct efi_file, file );
 
        DBGC ( file, "EFIFILE %s cannot set information of type %s\n",
               efi_file_name ( file ), efi_guid_ntoa ( type ) );
        return EFI_WRITE_PROTECTED;
}

References __unused, container_of, data, DBGC, efi_file_name(), efi_guid_ntoa(), EFI_WRITE_PROTECTED, efi_file::file, len, type, and VOID.

efi_file_flush()

EFI_STATUS EFIAPI efi_file_flush ( EFI_FILE_PROTOCOL * this )

static

Flush file modified data.

Parameters

this	EFI file
type	Type of information
len	Buffer size
data	Buffer

Return values

efirc

EFI status code

Definition at line 744 of file efi_file.c.

                                                                    {
        struct efi_file *file = container_of ( this, struct efi_file, file );
 
        DBGC ( file, "EFIFILE %s flushed\n", efi_file_name ( file ) );
        return 0;
}

References container_of, DBGC, efi_file_name(), EFIAPI, and efi_file::file.

efi_file_load()

EFI_STATUS EFIAPI efi_file_load ( EFI_LOAD_FILE2_PROTOCOL * this, EFI_DEVICE_PATH_PROTOCOL *path __unused, BOOLEAN boot __unused, UINTN * len, VOID * data )

static

Load file.

Parameters

this	EFI file loader
path	File path
boot	Boot policy
len	Buffer size
data	Buffer, or NULL

Return values

efirc

EFI status code

Definition at line 762 of file efi_file.c.

                                                                {
        struct efi_file *file = container_of ( this, struct efi_file, load );
        size_t max_len;
        size_t file_len;
        EFI_STATUS efirc;
 
        /* Calculate maximum length */
        max_len = ( data ? *len : 0 );
        DBGC ( file, "EFIFILE %s load at %p+%#zx\n",
               efi_file_name ( file ), data, max_len );
 
        /* Check buffer size */
        file_len = efi_file_len ( file );
        if ( file_len > max_len ) {
                *len = file_len;
                return EFI_BUFFER_TOO_SMALL;
        }
 
        /* Read from file */
        if ( ( efirc = efi_file_read ( &file->file, len, data ) ) != 0 )
                return efirc;
 
        return 0;
}

References __unused, container_of, data, DBGC, EFI_BUFFER_TOO_SMALL, efi_file_len(), efi_file_name(), efi_file_read(), efi_file::file, len, efi_file::load, and VOID.

efi_file_open_volume()

EFI_STATUS EFIAPI efi_file_open_volume ( EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *filesystem __unused, EFI_FILE_PROTOCOL ** file )

static

Open root directory.

Parameters

filesystem

EFI simple file system

Return values

file	EFI file handle
efirc	EFI status code

Definition at line 867 of file efi_file.c.

                                                  {
 
        DBGC ( &efi_file_root, "EFIFILE open volume\n" );
        return efi_file_open_fixed ( &efi_file_root, L"<volume>", file );
}

References __unused, DBGC, efi_file_open_fixed(), efi_file_root, efi_file_path::file, and filesystem.

efi_block_io_reset()

EFI_STATUS EFIAPI efi_block_io_reset ( EFI_BLOCK_IO_PROTOCOL *this __unused, BOOLEAN extended )

static

Dummy block I/O reset.

Definition at line 882 of file efi_file.c.

                                                                              {
 
        DBGC ( &efi_file_root, "EFIFILE block %sreset\n",
               ( extended ? "extended " : "" ) );
        return 0;
}

References __unused, DBGC, and efi_file_root.

efi_block_io_read_blocks()

EFI_STATUS EFIAPI efi_block_io_read_blocks ( EFI_BLOCK_IO_PROTOCOL *this __unused, UINT32 MediaId, EFI_LBA lba, UINTN len, VOID * data )

static

Dummy block I/O read.

Definition at line 891 of file efi_file.c.

                                                                {
 
        DBGC ( &efi_file_root, "EFIFILE block read ID %#08x LBA %#08llx -> "
               "%p+%zx\n", MediaId, ( ( unsigned long long ) lba ),
               data, ( ( size_t ) len ) );
        return EFI_NO_MEDIA;
}

References __unused, data, DBGC, efi_file_root, EFI_NO_MEDIA, lba, len, and VOID.

efi_block_io_write_blocks()

EFI_STATUS EFIAPI efi_block_io_write_blocks ( EFI_BLOCK_IO_PROTOCOL *this __unused, UINT32 MediaId, EFI_LBA lba, UINTN len, VOID * data )

static

Dummy block I/O write.

Definition at line 902 of file efi_file.c.

                                         {
 
        DBGC ( &efi_file_root, "EFIFILE block write ID %#08x LBA %#08llx <- "
               "%p+%zx\n", MediaId, ( ( unsigned long long ) lba ),
               data, ( ( size_t ) len ) );
        return EFI_NO_MEDIA;
}

References __unused, data, DBGC, efi_file_root, EFI_NO_MEDIA, lba, len, and VOID.

efi_block_io_flush_blocks()

EFI_STATUS EFIAPI efi_block_io_flush_blocks ( EFI_BLOCK_IO_PROTOCOL *this __unused )

static

Dummy block I/O flush.

Definition at line 914 of file efi_file.c.

                                                                   {
 
        DBGC ( &efi_file_root, "EFIFILE block flush\n" );
        return 0;
}

References __unused, DBGC, and efi_file_root.

efi_disk_io_read_disk()

EFI_STATUS EFIAPI efi_disk_io_read_disk ( EFI_DISK_IO_PROTOCOL *this __unused, UINT32 MediaId, UINT64 offset, UINTN len, VOID * data )

static

Dummy disk I/O read.

Definition at line 940 of file efi_file.c.

                                                               {
 
        DBGC ( &efi_file_root, "EFIFILE disk read ID %#08x offset %#08llx -> "
               "%p+%zx\n", MediaId, ( ( unsigned long long ) offset ),
               data, ( ( size_t ) len ) );
        return EFI_NO_MEDIA;
}

References __unused, data, DBGC, efi_file_root, EFI_NO_MEDIA, len, offset, and VOID.

efi_disk_io_write_disk()

EFI_STATUS EFIAPI efi_disk_io_write_disk ( EFI_DISK_IO_PROTOCOL *this __unused, UINT32 MediaId, UINT64 offset, UINTN len, VOID * data )

static

Dummy disk I/O write.

Definition at line 951 of file efi_file.c.

                                                                {
 
        DBGC ( &efi_file_root, "EFIFILE disk write ID %#08x offset %#08llx <- "
               "%p+%zx\n", MediaId, ( ( unsigned long long ) offset ),
               data, ( ( size_t ) len ) );
        return EFI_NO_MEDIA;
}

References __unused, data, DBGC, efi_file_root, EFI_NO_MEDIA, len, offset, and VOID.

efi_file_path_claim()

int efi_file_path_claim ( struct efi_file_path * file )

static

Claim use of fixed device path.

Parameters

file	Fixed device path file

Return values

rc	Return status code

The design choice in Linux of using a single fixed device path is unfortunately messy to support, since device paths must be unique within a system. When multiple bootloaders are used (e.g. GRUB loading iPXE loading Linux) then only one bootloader can ever install the device path onto a handle. Bootloaders must therefore be prepared to locate an existing handle and uninstall its device path protocol instance before installing a new handle with the required device path.

Definition at line 982 of file efi_file.c.

                                                              {
        EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
        EFI_DEVICE_PATH_PROTOCOL *old;
        EFI_DEVICE_PATH_PROTOCOL *end;
        EFI_HANDLE handle;
        EFI_STATUS efirc;
        int rc;
 
        /* Sanity check */
        assert ( file->handle == NULL );
 
        /* Locate handle with this device path, if any */
        end = file->path;
        if ( ( ( efirc = bs->LocateDevicePath ( &efi_device_path_protocol_guid,
                                                &end, &handle ) ) != 0 ) ||
             ( end->Type != END_DEVICE_PATH_TYPE ) ) {
                return 0;
        }
 
        /* Locate device path protocol on this handle */
        if ( ( rc = efi_open ( handle, &efi_device_path_protocol_guid,
                               &old ) != 0 ) ) {
                DBGC ( file, "EFIFILE %s could not locate %s: %s\n",
                       efi_file_name ( &file->file ),
                       efi_devpath_text ( file->path ), strerror ( rc ) );
                return rc;
        }
 
        /* Uninstall device path protocol, leaving other protocols untouched */
        if ( ( efirc = bs->UninstallMultipleProtocolInterfaces (
                                handle,
                                &efi_device_path_protocol_guid, old,
                                NULL ) ) != 0 ) {
                rc = -EEFI ( efirc );
                DBGC ( file, "EFIFILE %s could not claim %s: %s\n",
                       efi_file_name ( &file->file ),
                       efi_devpath_text ( file->path ), strerror ( rc ) );
                return rc;
        }
 
        DBGC ( file, "EFIFILE %s claimed %s",
               efi_file_name ( &file->file ), efi_devpath_text ( file->path ) );
        DBGC ( file, " from %s\n", efi_handle_name ( handle ) );
        return 0;
}

References assert, DBGC, EEFI, efi_device_path_protocol_guid, efi_devpath_text(), efi_file_name(), EFI_HANDLE, efi_handle_name(), efi_open, efi_systab, end, END_DEVICE_PATH_TYPE, efi_file::file, efi_file_path::file, handle, EFI_BOOT_SERVICES::LocateDevicePath, NULL, old, rc, strerror(), and EFI_BOOT_SERVICES::UninstallMultipleProtocolInterfaces.

Referenced by efi_file_install().

efi_file_path_install()

int efi_file_path_install ( struct efi_file_path * file )

static

Install fixed device path file.

Parameters

file	Fixed device path file

Return values

rc	Return status code

Linux 5.7 added the ability to autodetect an initrd by searching for a handle via a fixed vendor-specific "Linux initrd device path" and then locating and using the EFI_LOAD_FILE2_PROTOCOL instance on that handle.

Definition at line 1039 of file efi_file.c.

                                                                {
        EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
        EFI_STATUS efirc;
        int rc;
 
        /* Sanity check */
        assert ( file->handle == NULL );
 
        /* Create a new handle with this device path */
        if ( ( efirc = bs->InstallMultipleProtocolInterfaces (
                                &file->handle,
                                &efi_device_path_protocol_guid, file->path,
                                &efi_load_file2_protocol_guid, &file->file.load,
                                NULL ) ) != 0 ) {
                rc = -EEFI ( efirc );
                DBGC ( file, "EFIFILE %s could not install %s: %s\n",
                       efi_file_name ( &file->file ),
                       efi_devpath_text ( file->path ), strerror ( rc ) );
                return rc;
        }
 
        DBGC ( file, "EFIFILE %s installed as %s\n",
               efi_file_name ( &file->file ), efi_devpath_text ( file->path ) );
        return 0;
}

References assert, DBGC, EEFI, efi_device_path_protocol_guid, efi_devpath_text(), efi_file_name(), efi_load_file2_protocol_guid, efi_systab, efi_file::file, efi_file_path::file, EFI_BOOT_SERVICES::InstallMultipleProtocolInterfaces, NULL, rc, and strerror().

Referenced by efi_file_install().

efi_file_path_uninstall()

void efi_file_path_uninstall ( struct efi_file_path * file )

static

Uninstall fixed device path file.

Parameters

file	Fixed device path file

Return values

rc	Return status code

Definition at line 1071 of file efi_file.c.

                                                                   {
        EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
        EFI_STATUS efirc;
        int rc;
 
        /* Do nothing if file is already uninstalled */
        if ( ! file->handle )
                return;
 
        /* Uninstall protocols.  Do this via two separate calls, in
         * case another executable has already uninstalled the device
         * path protocol from our handle.
         */
        if ( ( efirc = bs->UninstallMultipleProtocolInterfaces (
                                file->handle,
                                &efi_device_path_protocol_guid, file->path,
                                NULL ) ) != 0 ) {
                rc = -EEFI ( efirc );
                DBGC ( file, "EFIFILE %s could not uninstall %s: %s\n",
                       efi_file_name ( &file->file ),
                       efi_devpath_text ( file->path ), strerror ( rc ) );
                /* Continue uninstalling */
        }
        if ( ( efirc = bs->UninstallMultipleProtocolInterfaces (
                                file->handle,
                                &efi_load_file2_protocol_guid, &file->file.load,
                                NULL ) ) != 0 ) {
                rc = -EEFI ( efirc );
                DBGC ( file, "EFIFILE %s could not uninstall %s: %s\n",
                       efi_file_name ( &file->file ),
                       efi_guid_ntoa ( &efi_load_file2_protocol_guid ),
                       strerror ( rc ) );
                /* Continue uninstalling */
        }
 
        /* Mark handle as uninstalled */
        file->handle = NULL;
}

References DBGC, EEFI, efi_device_path_protocol_guid, efi_devpath_text(), efi_file_name(), efi_guid_ntoa(), efi_load_file2_protocol_guid, efi_systab, efi_file::file, efi_file_path::file, NULL, rc, strerror(), and EFI_BOOT_SERVICES::UninstallMultipleProtocolInterfaces.

Referenced by efi_file_install(), and efi_file_uninstall().

efi_file_install()

int efi_file_install

(

EFI_HANDLE

handle

)

Install EFI simple file system protocol.

Parameters

handle

EFI handle

Return values

rc	Return status code

Definition at line 1116 of file efi_file.c.

                                           {
        EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
        EFI_DISK_IO_PROTOCOL *diskio;
        struct image *image;
        EFI_STATUS efirc;
        int rc;
 
        /* Reset root directory state */
        efi_file_root.pos = 0;
 
        /* Install the simple file system protocol, block I/O
         * protocol, and disk I/O protocol.  We don't have a block
         * device, but large parts of the EDK2 codebase make the
         * assumption that file systems are normally attached to block
         * devices, and so we create a dummy block device on the same
         * handle just to keep things looking normal.
         */
        if ( ( efirc = bs->InstallMultipleProtocolInterfaces (
                        &handle,
                        &efi_block_io_protocol_guid,
                        &efi_block_io_protocol,
                        &efi_disk_io_protocol_guid,
                        &efi_disk_io_protocol,
                        &efi_simple_file_system_protocol_guid,
                        &efi_simple_file_system_protocol, NULL ) ) != 0 ) {
                rc = -EEFI ( efirc );
                DBGC ( handle, "Could not install simple file system "
                       "protocols: %s\n", strerror ( rc ) );
                goto err_install;
        }
 
        /* The FAT filesystem driver has a bug: if a block device
         * contains no FAT filesystem but does have an
         * EFI_SIMPLE_FILE_SYSTEM_PROTOCOL instance, the FAT driver
         * will assume that it must have previously installed the
         * EFI_SIMPLE_FILE_SYSTEM_PROTOCOL.  This causes the FAT
         * driver to claim control of our device, and to refuse to
         * stop driving it, which prevents us from later uninstalling
         * correctly.
         *
         * Work around this bug by opening the disk I/O protocol
         * ourselves, thereby preventing the FAT driver from opening
         * it.
         *
         * Note that the alternative approach of opening the block I/O
         * protocol (and thereby in theory preventing DiskIo from
         * attaching to the block I/O protocol) causes an endless loop
         * of calls to our DRIVER_STOP method when starting the EFI
         * shell.  I have no idea why this is.
         */
        if ( ( rc = efi_open_by_driver ( handle, &efi_disk_io_protocol_guid,
                                         &diskio ) ) != 0 ) {
                DBGC ( handle, "Could not open disk I/O protocol: %s\n",
                       strerror ( rc ) );
                DBGC_EFI_OPENERS ( handle, handle, &efi_disk_io_protocol_guid );
                goto err_open;
        }
        assert ( diskio == &efi_disk_io_protocol );
 
        /* Claim Linux initrd fixed device path */
        if ( ( rc = efi_file_path_claim ( &efi_file_initrd ) ) != 0 )
                goto err_initrd_claim;
 
        /* Install Linux initrd fixed device path file if non-empty */
        for_each_image ( image ) {
                if ( image->flags & IMAGE_HIDDEN )
                        continue;
                if ( ( rc = efi_file_path_install ( &efi_file_initrd ) ) != 0 )
                        goto err_initrd_install;
                break;
        }
 
        return 0;
 
        efi_file_path_uninstall ( &efi_file_initrd );
 err_initrd_install:
 err_initrd_claim:
        efi_close_by_driver ( handle, &efi_disk_io_protocol_guid );
 err_open:
        bs->UninstallMultipleProtocolInterfaces (
                        handle,
                        &efi_simple_file_system_protocol_guid,
                        &efi_simple_file_system_protocol,
                        &efi_disk_io_protocol_guid,
                        &efi_disk_io_protocol,
                        &efi_block_io_protocol_guid,
                        &efi_block_io_protocol, NULL );
 err_install:
        return rc;
}

References assert, DBGC, DBGC_EFI_OPENERS, EEFI, efi_block_io_protocol, efi_block_io_protocol_guid, efi_close_by_driver(), efi_disk_io_protocol, efi_disk_io_protocol_guid, efi_file_initrd, efi_file_path_claim(), efi_file_path_install(), efi_file_path_uninstall(), efi_file_root, EFI_HANDLE, efi_open_by_driver, efi_simple_file_system_protocol, efi_simple_file_system_protocol_guid, efi_systab, image::flags, for_each_image, handle, IMAGE_HIDDEN, EFI_BOOT_SERVICES::InstallMultipleProtocolInterfaces, NULL, rc, strerror(), and EFI_BOOT_SERVICES::UninstallMultipleProtocolInterfaces.

Referenced by efi_image_exec().

efi_file_uninstall()

void efi_file_uninstall

(

EFI_HANDLE

handle

)

Uninstall EFI simple file system protocol.

Parameters

handle

EFI handle

Definition at line 1212 of file efi_file.c.

                                              {
        EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
        EFI_STATUS efirc;
        int rc;
 
        /* Uninstall Linux initrd fixed device path file */
        efi_file_path_uninstall ( &efi_file_initrd );
 
        /* Close our own disk I/O protocol */
        efi_close_by_driver ( handle, &efi_disk_io_protocol_guid );
 
        /* We must install the file system protocol first, since
         * otherwise the EDK2 code will attempt to helpfully uninstall
         * it when the block I/O protocol is uninstalled, leading to a
         * system lock-up.
         */
        if ( ( efirc = bs->UninstallMultipleProtocolInterfaces (
                        handle,
                        &efi_simple_file_system_protocol_guid,
                        &efi_simple_file_system_protocol,
                        &efi_disk_io_protocol_guid,
                        &efi_disk_io_protocol,
                        &efi_block_io_protocol_guid,
                        &efi_block_io_protocol, NULL ) ) != 0 ) {
                rc = -EEFI ( efirc );
                DBGC ( handle, "Could not uninstall simple file system "
                       "protocols: %s\n", strerror ( rc ) );
                /* Oh dear */
        }
}

References DBGC, EEFI, efi_block_io_protocol, efi_block_io_protocol_guid, efi_close_by_driver(), efi_disk_io_protocol, efi_disk_io_protocol_guid, efi_file_initrd, efi_file_path_uninstall(), EFI_HANDLE, efi_simple_file_system_protocol, efi_simple_file_system_protocol_guid, efi_systab, handle, NULL, rc, strerror(), and EFI_BOOT_SERVICES::UninstallMultipleProtocolInterfaces.

Referenced by efi_image_exec().

Variable Documentation

efi_file_root

struct efi_file efi_file_root

static

Initial value:

= {
        .refcnt = REF_INIT ( ref_no_free ),
        .file = {
                .Revision = EFI_FILE_PROTOCOL_REVISION,
                .Open = efi_file_open,
                .Close = efi_file_close,
                .Delete = efi_file_delete,
                .Read = efi_file_read,
                .Write = efi_file_write,
                .GetPosition = efi_file_get_position,
                .SetPosition = efi_file_set_position,
                .GetInfo = efi_file_get_info,
                .SetInfo = efi_file_set_info,
                .Flush = efi_file_flush,
        },
        .load = {
                .LoadFile = efi_file_load,
        },
        .image = NULL,
        .name = "",
}

Root directory.

Definition at line 108 of file efi_file.c.

Referenced by efi_block_io_flush_blocks(), efi_block_io_read_blocks(), efi_block_io_reset(), efi_block_io_write_blocks(), efi_disk_io_read_disk(), efi_disk_io_write_disk(), efi_file_info(), efi_file_install(), efi_file_name(), efi_file_open(), efi_file_open_image(), and efi_file_open_volume().

efi_file_initrd

struct efi_file_path efi_file_initrd

static

Initial value:

= {
        .file = {
                .refcnt = REF_INIT ( ref_no_free ),
                .file = {
                        .Revision = EFI_FILE_PROTOCOL_REVISION,
                        .Open = efi_file_open,
                        .Close = efi_file_close,
                        .Delete = efi_file_delete,
                        .Read = efi_file_read,
                        .Write = efi_file_write,
                        .GetPosition = efi_file_get_position,
                        .SetPosition = efi_file_set_position,
                        .GetInfo = efi_file_get_info,
                        .SetInfo = efi_file_set_info,
                        .Flush = efi_file_flush,
                },
                .load = {
                        .LoadFile = efi_file_load,
                },
                .image = NULL,
                .name = "initrd.magic",
                .read = efi_file_read_initrd,
        },
        .path = &efi_file_initrd_path.vendor.Header,
}

Magic initrd file.

Definition at line 109 of file efi_file.c.

Referenced by efi_file_install(), efi_file_open(), and efi_file_uninstall().

vendor

VENDOR_DEVICE_PATH vendor

Definition at line 814 of file efi_file.c.

end

EFI_DEVICE_PATH_PROTOCOL end

Definition at line 815 of file efi_file.c.

[struct]

struct { ... } efi_file_initrd_path

Initial value:

= {
        .vendor = {
                .Header = {
                        .Type = MEDIA_DEVICE_PATH,
                        .SubType = MEDIA_VENDOR_DP,
                        .Length[0] = sizeof ( efi_file_initrd_path.vendor ),
                },
                .Guid = LINUX_INITRD_VENDOR_GUID,
        },
        .end = {
                .Type = END_DEVICE_PATH_TYPE,
                .SubType = END_ENTIRE_DEVICE_PATH_SUBTYPE,
                .Length[0] = sizeof ( efi_file_initrd_path.end ),
        },
}

Linux initrd fixed device path.

efi_simple_file_system_protocol

EFI_SIMPLE_FILE_SYSTEM_PROTOCOL efi_simple_file_system_protocol

static

Initial value:

= {
        .Revision = EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_REVISION,
        .OpenVolume = efi_file_open_volume,
}

EFI simple file system protocol.

Definition at line 875 of file efi_file.c.

                                                                         {
        .Revision = EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_REVISION,
        .OpenVolume = efi_file_open_volume,
};

Referenced by efi_file_install(), and efi_file_uninstall().

efi_block_io_media

EFI_BLOCK_IO_MEDIA efi_block_io_media

static

Initial value:

= {
        .MediaId = EFI_MEDIA_ID_MAGIC,
        .MediaPresent = TRUE,
        .ReadOnly = TRUE,
        .BlockSize = 1,
}

Dummy block I/O media.

Definition at line 921 of file efi_file.c.

                                               {
        .MediaId = EFI_MEDIA_ID_MAGIC,
        .MediaPresent = TRUE,
        .ReadOnly = TRUE,
        .BlockSize = 1,
};

efi_block_io_protocol

EFI_BLOCK_IO_PROTOCOL efi_block_io_protocol

static

Initial value:

= {
        .Revision = EFI_BLOCK_IO_PROTOCOL_REVISION,
        .Media = &efi_block_io_media,
        .Reset = efi_block_io_reset,
        .ReadBlocks = efi_block_io_read_blocks,
        .WriteBlocks = efi_block_io_write_blocks,
        .FlushBlocks = efi_block_io_flush_blocks,
}

Dummy EFI block I/O protocol.

Definition at line 929 of file efi_file.c.

                                                     {
        .Revision = EFI_BLOCK_IO_PROTOCOL_REVISION,
        .Media = &efi_block_io_media,
        .Reset = efi_block_io_reset,
        .ReadBlocks = efi_block_io_read_blocks,
        .WriteBlocks = efi_block_io_write_blocks,
        .FlushBlocks = efi_block_io_flush_blocks,
};

Referenced by efi_file_install(), and efi_file_uninstall().

efi_disk_io_protocol

EFI_DISK_IO_PROTOCOL efi_disk_io_protocol

static

Initial value:

= {
        .Revision = EFI_DISK_IO_PROTOCOL_REVISION,
        .ReadDisk = efi_disk_io_read_disk,
        .WriteDisk = efi_disk_io_write_disk,
}

Dummy EFI disk I/O protocol.

Definition at line 961 of file efi_file.c.

                                                   {
        .Revision = EFI_DISK_IO_PROTOCOL_REVISION,
        .ReadDisk = efi_disk_io_read_disk,
        .WriteDisk = efi_disk_io_write_disk,
};

Referenced by efi_file_install(), and efi_file_uninstall().