efi_local.c File Reference

EFI local file access. More...

#include <string.h>
#include <strings.h>
#include <stdio.h>
#include <errno.h>
#include <assert.h>
#include <ipxe/refcnt.h>
#include <ipxe/malloc.h>
#include <ipxe/xfer.h>
#include <ipxe/open.h>
#include <ipxe/uri.h>
#include <ipxe/iobuf.h>
#include <ipxe/process.h>
#include <ipxe/errortab.h>
#include <ipxe/efi/efi.h>
#include <ipxe/efi/efi_strings.h>
#include <ipxe/efi/efi_path.h>
#include <ipxe/efi/Protocol/SimpleFileSystem.h>
#include <ipxe/efi/Guid/FileInfo.h>
#include <ipxe/efi/Guid/FileSystemInfo.h>

Go to the source code of this file.

Data Structures
struct	efi_local
	An EFI local file. More...

Macros
#define	EINFO_EEFI_OPEN   __einfo_uniqify ( EINFO_EPLATFORM, 0x01, "Could not open" )
#define	EINFO_EEFI_OPEN_NOT_FOUND
#define	EEFI_OPEN_NOT_FOUND   __einfo_error ( EINFO_EEFI_OPEN_NOT_FOUND )
#define	EEFI_OPEN(efirc)
#define	EFI_LOCAL_BLKSIZE   4096
	Download blocksize. More...

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
static void	efi_local_free (struct refcnt *refcnt)
	Free local file. More...
static void	efi_local_close (struct efi_local *local, int rc)
	Close local file. More...
static int	efi_local_check_volume_name (struct efi_local *local, EFI_HANDLE device, EFI_FILE_PROTOCOL *root, const char *volume)
	Check for matching volume name. More...
static int	efi_local_open_root (struct efi_local *local, EFI_HANDLE device, EFI_FILE_PROTOCOL **root)
	Open root filesystem. More...
static int	efi_local_open_volume (struct efi_local *local)
	Open root filesystem of specified volume. More...
static int	efi_local_open_resolved (struct efi_local *local, const char *resolved)
	Open fully-resolved path. More...
static int	efi_local_open_path (struct efi_local *local)
	Open specified path. More...
static int	efi_local_len (struct efi_local *local)
	Get file length. More...
static void	efi_local_step (struct efi_local *local)
	Local file process. More...
static int	efi_local_open (struct interface *xfer, struct uri *uri)
	Open local file. More...

Variables
struct errortab efi_local_errors []	__errortab
	Human-readable error messages. More...
static struct interface_operation	efi_local_operations []
	Data transfer interface operations. More...
static struct interface_descriptor	efi_local_xfer_desc
	Data transfer interface descriptor. More...
static struct process_descriptor	efi_local_process_desc
	Process descriptor. More...
struct uri_opener efi_local_uri_opener	__uri_opener
	EFI local file URI opener. More...

Detailed Description

EFI local file access.

Definition in file efi_local.c.

Macro Definition Documentation

EINFO_EEFI_OPEN

#define EINFO_EEFI_OPEN   __einfo_uniqify ( EINFO_EPLATFORM, 0x01, "Could not open" )

Definition at line 53 of file efi_local.c.

EINFO_EEFI_OPEN_NOT_FOUND

#define EINFO_EEFI_OPEN_NOT_FOUND

Value:

__einfo_platformify ( EINFO_EEFI_OPEN, EFI_NOT_FOUND,           \
                              "Not found" )

Definition at line 55 of file efi_local.c.

EEFI_OPEN_NOT_FOUND

#define EEFI_OPEN_NOT_FOUND   __einfo_error ( EINFO_EEFI_OPEN_NOT_FOUND )

Definition at line 58 of file efi_local.c.

EEFI_OPEN

#define EEFI_OPEN

(

efirc

)

Value:

EPLATFORM ( EINFO_EEFI_OPEN, efirc,             \
                                       EEFI_OPEN_NOT_FOUND )

Definition at line 60 of file efi_local.c.

EFI_LOCAL_BLKSIZE

#define EFI_LOCAL_BLKSIZE   4096

Download blocksize.

Definition at line 64 of file efi_local.c.

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

efi_local_free()

static void efi_local_free ( struct refcnt *  refcnt )

static

Free local file.

Parameters

refcnt

Reference count

Definition at line 100 of file efi_local.c.

                                                     {
        struct efi_local *local =
                container_of ( refcnt, struct efi_local, refcnt );

        uri_put ( local->uri );
        free ( local );
}

References container_of, free, efi_local::uri, and uri_put().

Referenced by efi_local_open().

efi_local_close()

static void efi_local_close ( struct efi_local *  local, int  rc  )

static

Close local file.

Parameters

local	Local file
rc	Reason for close

Definition at line 114 of file efi_local.c.

                                                                {

        /* Stop process */
        process_del ( &local->process );

        /* Shut down data transfer interface */
        intf_shutdown ( &local->xfer, rc );

        /* Close EFI file */
        if ( local->file ) {
                local->file->Close ( local->file );
                local->file = NULL;
        }

        /* Close EFI root directory */
        if ( local->root ) {
                local->root->Close ( local->root );
                local->root = NULL;
        }
}

References _EFI_FILE_PROTOCOL::Close, efi_local::file, intf_shutdown(), NULL, efi_local::process, process_del(), rc, efi_local::root, and efi_local::xfer.

Referenced by efi_local_step().

efi_local_check_volume_name()

static int efi_local_check_volume_name ( struct efi_local *  local, EFI_HANDLE  device, EFI_FILE_PROTOCOL *  root, const char *  volume  )

static

Check for matching volume name.

Parameters

local	Local file
device	Device handle
root	Root filesystem handle
volume	Volume name

Return values

rc	Return status code

Definition at line 144 of file efi_local.c.

                                                              {
        EFI_FILE_SYSTEM_INFO *info;
        UINTN size;
        char *label;
        EFI_STATUS efirc;
        int rc;

        /* Get length of file system information */
        size = 0;
        root->GetInfo ( root, &efi_file_system_info_id, &size, NULL );

        /* Allocate file system information */
        info = malloc ( size );
        if ( ! info ) {
                rc = -ENOMEM;
                goto err_alloc_info;
        }

        /* Get file system information */
        if ( ( efirc = root->GetInfo ( root, &efi_file_system_info_id, &size,
                                       info ) ) != 0 ) {
                rc = -EEFI ( efirc );
                DBGC ( local, "LOCAL %p could not get file system info on %s: "
                       "%s\n", local, efi_handle_name ( device ),
                       strerror ( rc ) );
                goto err_get_info;
        }
        DBGC2 ( local, "LOCAL %p found %s with label \"%ls\"\n",
                local, efi_handle_name ( device ), info->VolumeLabel );

        /* Construct volume label for comparison */
        if ( asprintf ( &label, "%ls", info->VolumeLabel ) < 0 ) {
                rc = -ENOMEM;
                goto err_alloc_label;
        }

        /* Compare volume label */
        if ( strcasecmp ( volume, label ) != 0 ) {
                rc = -ENOENT;
                goto err_compare;
        }

        /* Success */
        rc = 0;

 err_compare:
        free ( label );
 err_alloc_label:
 err_get_info:
        free ( info );
 err_alloc_info:
        return rc;
}

References asprintf(), DBGC, DBGC2, EEFI, efi_file_system_info_id, efi_handle_name(), ENOENT, ENOMEM, free, info, malloc(), NULL, rc, root, size, strcasecmp(), strerror(), and efi_local::volume.

Referenced by efi_local_open_volume().

efi_local_open_root()

static int efi_local_open_root ( struct efi_local *  local, EFI_HANDLE  device, EFI_FILE_PROTOCOL **  root  )

static

Open root filesystem.

Parameters

local	Local file
device	Device handle
root	Root filesystem handle to fill in

Return values

rc	Return status code

Definition at line 209 of file efi_local.c.

                                                            {
        EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
        union {
                void *interface;
                EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *fs;
        } u;
        EFI_STATUS efirc;
        int rc;

        /* Open file system protocol */
        if ( ( efirc = bs->OpenProtocol ( device,
                                          &efi_simple_file_system_protocol_guid,
                                          &u.interface, efi_image_handle,
                                          device,
                                          EFI_OPEN_PROTOCOL_GET_PROTOCOL ))!=0){
                rc = -EEFI ( efirc );
                DBGC ( local, "LOCAL %p could not open filesystem on %s: %s\n",
                       local, efi_handle_name ( device ), strerror ( rc ) );
                goto err_filesystem;
        }

        /* Open root directory */
        if ( ( efirc = u.fs->OpenVolume ( u.fs, root ) ) != 0 ) {
                rc = -EEFI ( efirc );
                DBGC ( local, "LOCAL %p could not open volume on %s: %s\n",
                       local, efi_handle_name ( device ), strerror ( rc ) );
                goto err_volume;
        }

        /* Success */
        rc = 0;

 err_volume:
        bs->CloseProtocol ( device, &efi_simple_file_system_protocol_guid,
                            efi_image_handle, device );
 err_filesystem:
        return rc;
}

References EFI_SYSTEM_TABLE::BootServices, EFI_BOOT_SERVICES::CloseProtocol, DBGC, EEFI, efi_handle_name(), efi_image_handle, EFI_OPEN_PROTOCOL_GET_PROTOCOL, efi_simple_file_system_protocol_guid, efi_systab, fs, EFI_BOOT_SERVICES::OpenProtocol, rc, root, strerror(), and u.

Referenced by efi_local_open_volume().

efi_local_open_volume()

static int efi_local_open_volume ( struct efi_local *  local )

static

Open root filesystem of specified volume.

Parameters

local

Local file

Return values

rc	Return status code

Definition at line 255 of file efi_local.c.

                                                             {
        EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
        EFI_GUID *protocol = &efi_simple_file_system_protocol_guid;
        int ( * check ) ( struct efi_local *local, EFI_HANDLE device,
                          EFI_FILE_PROTOCOL *root, const char *volume );
        const char *volume = local->volume;
        EFI_DEVICE_PATH_PROTOCOL *path;
        EFI_FILE_PROTOCOL *root;
        EFI_HANDLE *handles;
        EFI_HANDLE device;
        UINTN num_handles;
        UINTN i;
        EFI_STATUS efirc;
        int rc;

        /* Identify candidate handles */
        if ( volume ) {
                /* Locate all filesystem handles */
                if ( ( efirc = bs->LocateHandleBuffer ( ByProtocol, protocol,
                                                        NULL, &num_handles,
                                                        &handles ) ) != 0 ) {
                        rc = -EEFI ( efirc );
                        DBGC ( local, "LOCAL %p could not enumerate handles: "
                               "%s\n", local, strerror ( rc ) );
                        return rc;
                }
                check = efi_local_check_volume_name;
        } else {
                /* Locate filesystem from which we were loaded */
                path = efi_loaded_image_path;
                if ( ( efirc = bs->LocateDevicePath ( protocol, &path,
                                                      &device ) ) != 0 ) {
                        rc = -EEFI ( efirc );
                        DBGC ( local, "LOCAL %p could not locate file system "
                               "on %s: %s\n", local,
                               efi_devpath_text ( efi_loaded_image_path ),
                               strerror ( rc ) );
                        return rc;
                }
                handles = &device;
                num_handles = 1;
                check = NULL;
        }

        /* Find matching handle */
        for ( i = 0 ; i < num_handles ; i++ ) {

                /* Get this device handle */
                device = handles[i];

                /* Open root directory */
                if ( ( rc = efi_local_open_root ( local, device, &root ) ) != 0)
                        continue;

                /* Check volume name, if applicable */
                if ( ( check == NULL ) ||
                     ( ( rc = check ( local, device, root, volume ) ) == 0 ) ) {
                        DBGC ( local, "LOCAL %p using %s",
                               local, efi_handle_name ( device ) );
                        if ( volume )
                                DBGC ( local, " with label \"%s\"", volume );
                        DBGC ( local, "\n" );
                        local->root = root;
                        break;
                }

                /* Close root directory */
                root->Close ( root );
        }

        /* Free handles, if applicable */
        if ( volume )
                bs->FreePool ( handles );

        /* Fail if we found no matching handle */
        if ( ! local->root ) {
                DBGC ( local, "LOCAL %p found no matching handle\n", local );
                return -ENOENT;
        }

        return 0;
}

References EFI_SYSTEM_TABLE::BootServices, ByProtocol, DBGC, device, EEFI, efi_devpath_text(), efi_handle_name(), efi_loaded_image_path, efi_local_check_volume_name(), efi_local_open_root(), efi_simple_file_system_protocol_guid, efi_systab, ENOENT, EFI_BOOT_SERVICES::FreePool, EFI_BOOT_SERVICES::LocateDevicePath, EFI_BOOT_SERVICES::LocateHandleBuffer, NULL, efi_local::path, protocol, rc, root, efi_local::root, strerror(), and efi_local::volume.

Referenced by efi_local_step().

efi_local_open_resolved()

static int efi_local_open_resolved ( struct efi_local *  local, const char *  resolved  )

static

Open fully-resolved path.

Parameters

local	Local file
resolved	Resolved path

Return values

rc	Return status code

Definition at line 345 of file efi_local.c.

                                                            {
        size_t name_len = strlen ( resolved );
        CHAR16 name[ name_len + 1 /* wNUL */ ];
        EFI_FILE_PROTOCOL *file;
        EFI_STATUS efirc;
        int rc;

        /* Construct filename */
        efi_snprintf ( name, ( name_len + 1 /* wNUL */ ), "%s", resolved );

        /* Open file */
        if ( ( efirc = local->root->Open ( local->root, &file, name,
                                           EFI_FILE_MODE_READ, 0 ) ) != 0 ) {
                rc = -EEFI_OPEN ( efirc );
                DBGC ( local, "LOCAL %p could not open \"%s\": %s\n",
                       local, resolved, strerror ( rc ) );
                return rc;
        }
        local->file = file;

        return 0;
}

References DBGC, EEFI_OPEN, EFI_FILE_MODE_READ, efi_snprintf(), efi_local::file, name, _EFI_FILE_PROTOCOL::Open, rc, efi_local::root, strerror(), and strlen().

Referenced by efi_local_open_path().

efi_local_open_path()

static int efi_local_open_path ( struct efi_local *  local )

static

Open specified path.

Parameters

local

Local file

Return values

rc	Return status code

Definition at line 375 of file efi_local.c.

                                                           {
        EFI_DEVICE_PATH_PROTOCOL *path = efi_loaded_image->FilePath;
        EFI_DEVICE_PATH_PROTOCOL *next;
        FILEPATH_DEVICE_PATH *fp;
        char base[ efi_path_len ( path ) / 2 /* Cannot exceed this length */ ];
        size_t remaining = sizeof ( base );
        size_t len;
        char *resolved;
        char *tmp;
        int rc;

        /* Construct base path to our own image, if possible */
        memset ( base, 0, sizeof ( base ) );
        tmp = base;
        for ( ; ( next = efi_path_next ( path ) ) ; path = next ) {
                fp = container_of ( path, FILEPATH_DEVICE_PATH, Header );
                len = snprintf ( tmp, remaining, "%ls", fp->PathName );
                assert ( len < remaining );
                tmp += len;
                remaining -= len;
        }
        DBGC2 ( local, "LOCAL %p base path \"%s\"\n",
                local, base );

        /* Convert to sane path separators */
        for ( tmp = base ; *tmp ; tmp++ ) {
                if ( *tmp == '\\' )
                        *tmp = '/';
        }

        /* Resolve path */
        resolved = resolve_path ( base, local->path );
        if ( ! resolved ) {
                rc = -ENOMEM;
                goto err_resolve;
        }

        /* Convert to insane path separators */
        for ( tmp = resolved ; *tmp ; tmp++ ) {
                if ( *tmp == '/' )
                        *tmp = '\\';
        }
        DBGC ( local, "LOCAL %p using \"%s\"\n",
               local, resolved );

        /* Open resolved path */
        if ( ( rc = efi_local_open_resolved ( local, resolved ) ) != 0 )
                goto err_open;

 err_open:
        free ( resolved );
 err_resolve:
        return rc;
}

References assert(), base, container_of, DBGC, DBGC2, efi_loaded_image, efi_local_open_resolved(), efi_path_len(), efi_path_next(), ENOMEM, EFI_LOADED_IMAGE_PROTOCOL::FilePath, free, Header, len, memset(), next, efi_local::path, FILEPATH_DEVICE_PATH::PathName, rc, resolve_path(), snprintf(), and tmp.

Referenced by efi_local_step().

efi_local_len()

static int efi_local_len ( struct efi_local *  local )

static

Get file length.

Parameters

local

Local file

Return values

rc	Return status code

Definition at line 436 of file efi_local.c.

                                                     {
        EFI_FILE_PROTOCOL *file = local->file;
        EFI_FILE_INFO *info;
        EFI_STATUS efirc;
        UINTN size;
        int rc;

        /* Get size of file information */
        size = 0;
        file->GetInfo ( file, &efi_file_info_id, &size, NULL );

        /* Allocate file information */
        info = malloc ( size );
        if ( ! info ) {
                rc = -ENOMEM;
                goto err_alloc;
        }

        /* Get file information */
        if ( ( efirc = file->GetInfo ( file, &efi_file_info_id, &size,
                                       info ) ) != 0 ) {
                rc = -EEFI ( efirc );
                DBGC ( local, "LOCAL %p could not get file info: %s\n",
                       local, strerror ( rc ) );
                goto err_info;
        }

        /* Record file length */
        local->len = info->FileSize;

        /* Success */
        rc = 0;

 err_info:
        free ( info );
 err_alloc:
        return rc;
}

References DBGC, EEFI, efi_file_info_id, ENOMEM, efi_local::file, free, _EFI_FILE_PROTOCOL::GetInfo, info, efi_local::len, malloc(), NULL, rc, size, and strerror().

Referenced by efi_local_step().

efi_local_step()

static void efi_local_step ( struct efi_local *  local )

static

Local file process.

Parameters

local

Local file

Definition at line 480 of file efi_local.c.

                                                       {
        struct io_buffer *iobuf = NULL;
        size_t remaining;
        size_t frag_len;
        UINTN size;
        EFI_STATUS efirc;
        int rc;

        /* Wait until data transfer interface is ready */
        if ( ! xfer_window ( &local->xfer ) )
                return;

        /* Open specified volume root directory, if not yet open */
        if ( ( ! local->root ) &&
             ( ( rc = efi_local_open_volume ( local ) ) != 0 ) )
                goto err;

        /* Open specified file, if not yet open */
        if ( ( ! local->file ) &&
             ( ( rc = efi_local_open_path ( local ) ) != 0 ) )
                goto err;

        /* Get file length, if not yet known */
        if ( ( ! local->len ) &&
             ( ( rc = efi_local_len ( local ) ) != 0 ) )
                goto err;

        /* Presize receive buffer */
        remaining = local->len;
        xfer_seek ( &local->xfer, remaining );
        xfer_seek ( &local->xfer, 0 );

        /* Get file contents */
        while ( remaining ) {

                /* Calculate length for this fragment */
                frag_len = remaining;
                if ( frag_len > EFI_LOCAL_BLKSIZE )
                        frag_len = EFI_LOCAL_BLKSIZE;

                /* Allocate I/O buffer */
                iobuf = xfer_alloc_iob ( &local->xfer, frag_len );
                if ( ! iobuf ) {
                        rc = -ENOMEM;
                        goto err;
                }

                /* Read block */
                size = frag_len;
                if ( ( efirc = local->file->Read ( local->file, &size,
                                                   iobuf->data ) ) != 0 ) {
                        rc = -EEFI ( efirc );
                        DBGC ( local, "LOCAL %p could not read from file: %s\n",
                               local, strerror ( rc ) );
                        goto err;
                }
                assert ( size <= frag_len );
                iob_put ( iobuf, size );

                /* Deliver data */
                if ( ( rc = xfer_deliver_iob ( &local->xfer,
                                               iob_disown ( iobuf ) ) ) != 0 ) {
                        DBGC ( local, "LOCAL %p could not deliver data: %s\n",
                               local, strerror ( rc ) );
                        goto err;
                }

                /* Move to next block */
                remaining -= frag_len;
        }

        /* Close download */
        efi_local_close ( local, 0 );

        return;

 err:
        free_iob ( iobuf );
        efi_local_close ( local, rc );
}

References assert(), io_buffer::data, DBGC, EEFI, EFI_LOCAL_BLKSIZE, efi_local_close(), efi_local_len(), efi_local_open_path(), efi_local_open_volume(), ENOMEM, efi_local::file, free_iob(), iob_disown, iob_put, efi_local::len, NULL, rc, _EFI_FILE_PROTOCOL::Read, efi_local::root, size, strerror(), efi_local::xfer, xfer_alloc_iob(), xfer_deliver_iob(), xfer_seek(), and xfer_window().

efi_local_open()

static int efi_local_open ( struct interface *  xfer, struct uri *  uri  )

static

Open local file.

Parameters

xfer	Data transfer interface
uri	Request URI

Return values

rc	Return status code

Definition at line 582 of file efi_local.c.

                                                                      {
        struct efi_local *local;

        /* Allocate and initialise structure */
        local = zalloc ( sizeof ( *local ) );
        if ( ! local )
                return -ENOMEM;
        ref_init ( &local->refcnt, efi_local_free );
        intf_init ( &local->xfer, &efi_local_xfer_desc, &local->refcnt );
        process_init_stopped ( &local->process, &efi_local_process_desc,
                               &local->refcnt );
        local->uri = uri_get ( uri );
        local->volume = ( ( uri->host && uri->host[0] ) ? uri->host : NULL );
        local->path = ( uri->opaque ? uri->opaque : uri->path );

        /* Start download process */
        process_add ( &local->process );

        /* Attach to parent interface, mortalise self, and return */
        intf_plug_plug ( &local->xfer, xfer );
        ref_put ( &local->refcnt );
        return 0;
}

References efi_local_free(), efi_local_process_desc, efi_local_xfer_desc, ENOMEM, uri::host, intf_init(), intf_plug_plug(), NULL, uri::opaque, efi_local::path, uri::path, efi_local::process, process_add(), process_init_stopped(), ref_init, ref_put, efi_local::refcnt, efi_local::uri, uri_get(), efi_local::volume, efi_local::xfer, and zalloc().

Variable Documentation

__errortab

struct errortab efi_local_errors [] __errortab

Initial value:

= {
        __einfo_errortab ( EINFO_EEFI_OPEN_NOT_FOUND ),
}

Human-readable error messages.

Definition at line 91 of file efi_local.c.

efi_local_operations

struct interface_operation efi_local_operations[]

static

Initial value:

= {
        INTF_OP ( xfer_window_changed, struct efi_local *, efi_local_step ),
        INTF_OP ( intf_close, struct efi_local *, efi_local_close ),
}

Data transfer interface operations.

Definition at line 562 of file efi_local.c.

efi_local_xfer_desc

struct interface_descriptor efi_local_xfer_desc

static

Initial value:

=
        INTF_DESC ( struct efi_local, xfer, efi_local_operations )

Data transfer interface descriptor.

Definition at line 568 of file efi_local.c.

Referenced by efi_local_open().

efi_local_process_desc

struct process_descriptor efi_local_process_desc

static

Initial value:

=
        PROC_DESC_ONCE ( struct efi_local, process, efi_local_step )

Process descriptor.

Definition at line 572 of file efi_local.c.

Referenced by efi_local_open().

__uri_opener

struct uri_opener efi_local_uri_opener __uri_opener

Initial value:

= {
        .scheme = "file",
        .open   = efi_local_open,
}

EFI local file URI opener.

Definition at line 607 of file efi_local.c.