efi_path.h File Reference

EFI device paths. More...

#include <ipxe/interface.h>
#include <ipxe/efi/efi.h>
#include <ipxe/efi/Protocol/DevicePath.h>

Go to the source code of this file.

Macros
#define	efi_describe_TYPE(object_type)

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
	FILE_SECBOOT (PERMITTED)
static void	efi_path_terminate (EFI_DEVICE_PATH_PROTOCOL *end)
	Terminate device path.
EFI_DEVICE_PATH_PROTOCOL *	efi_path_next (EFI_DEVICE_PATH_PROTOCOL *path)
	Find next element in device path.
EFI_DEVICE_PATH_PROTOCOL *	efi_path_prev (EFI_DEVICE_PATH_PROTOCOL *path, EFI_DEVICE_PATH_PROTOCOL *curr)
	Find previous element of device path.
EFI_DEVICE_PATH_PROTOCOL *	efi_path_end (EFI_DEVICE_PATH_PROTOCOL *path)
	Find end of device path.
size_t	efi_path_len (EFI_DEVICE_PATH_PROTOCOL *path)
	Find length of device path (excluding terminator).
int	efi_path_check (EFI_DEVICE_PATH_PROTOCOL *path, size_t max)
	Check that device path is well-formed.
void *	efi_path_mac (EFI_DEVICE_PATH_PROTOCOL *path)
	Get MAC address from device path.
unsigned int	efi_path_vlan (EFI_DEVICE_PATH_PROTOCOL *path)
	Get VLAN tag from device path.
unsigned int	efi_path_family (EFI_DEVICE_PATH_PROTOCOL *path)
	Get IP address family from device path.
int	efi_path_guid (EFI_DEVICE_PATH_PROTOCOL *path, union uuid *uuid)
	Get partition GUID from device path.
struct uri *	efi_path_uri (EFI_DEVICE_PATH_PROTOCOL *path)
	Parse URI from device path.
EFI_DEVICE_PATH_PROTOCOL *	efi_paths (EFI_DEVICE_PATH_PROTOCOL *first,...)
	Concatenate EFI device paths.
EFI_DEVICE_PATH_PROTOCOL *	efi_netdev_path (struct net_device *netdev)
	Construct EFI device path for network device.
EFI_DEVICE_PATH_PROTOCOL *	efi_uri_path (struct uri *uri)
	Construct EFI device path for URI.
EFI_DEVICE_PATH_PROTOCOL *	efi_iscsi_path (struct iscsi_session *iscsi)
	Construct EFI device path for iSCSI device.
EFI_DEVICE_PATH_PROTOCOL *	efi_aoe_path (struct aoe_device *aoedev)
	Construct EFI device path for AoE device.
EFI_DEVICE_PATH_PROTOCOL *	efi_fcp_path (struct fcp_description *desc)
	Construct EFI device path for Fibre Channel device.
EFI_DEVICE_PATH_PROTOCOL *	efi_ib_srp_path (struct ib_srp_device *ib_srp)
	Construct EFI device path for Infiniband SRP device.
EFI_DEVICE_PATH_PROTOCOL *	efi_usb_path (struct usb_function *func)
	Construct EFI device path for USB function.
EFI_DEVICE_PATH_PROTOCOL *	efi_load_path (EFI_LOAD_OPTION *load, size_t len)
	Get EFI device path from load option.
EFI_DEVICE_PATH_PROTOCOL *	efi_boot_path (unsigned int number)
	Get EFI device path for numbered boot option.
EFI_DEVICE_PATH_PROTOCOL *	efi_current_boot_path (void)
	Get EFI device path for current boot option.
EFI_DEVICE_PATH_PROTOCOL *	efi_describe (struct interface *interface)
	Describe object as an EFI device path.

Detailed Description

EFI device paths.

Definition in file efi_path.h.

Macro Definition Documentation

efi_describe_TYPE

#define efi_describe_TYPE

(

object_type

)

Value:

typeof ( EFI_DEVICE_PATH_PROTOCOL * ( object_type ) )

Definition at line 70 of file efi_path.h.

#define efi_describe_TYPE( object_type ) \
        typeof ( EFI_DEVICE_PATH_PROTOCOL * ( object_type ) )

Referenced by efi_describe().

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

FILE_SECBOOT()

FILE_SECBOOT

(

PERMITTED

)

efi_path_terminate()

void efi_path_terminate ( EFI_DEVICE_PATH_PROTOCOL * end )

inlinestatic

Terminate device path.

Parameters

end	End of device path to fill in

Definition at line 31 of file efi_path.h.

                                                                        {
 
        end->Type = END_DEVICE_PATH_TYPE;
        end->SubType = END_ENTIRE_DEVICE_PATH_SUBTYPE;
        end->Length[0] = sizeof ( *end );
        end->Length[1] = 0;
}

References end, END_DEVICE_PATH_TYPE, and END_ENTIRE_DEVICE_PATH_SUBTYPE.

Referenced by efi_aoe_path(), efi_block_exec(), efi_fcp_path(), efi_ib_srp_path(), efi_image_filepath(), efi_image_uripath(), efi_iscsi_path(), efi_locate_device(), efi_netdev_path(), efi_paths(), efi_snp_hii_install(), efi_uri_path(), and efi_usb_path().

efi_path_next()

EFI_DEVICE_PATH_PROTOCOL * efi_path_next ( EFI_DEVICE_PATH_PROTOCOL * path )

extern

Find next element in device path.

Parameters

path	Device path, or NULL
next	Next element in device path, or NULL if at end

Definition at line 120 of file efi_path.c.

                                                                            {
 
        /* Check for non-existent device path */
        if ( ! path )
                return NULL;
 
        /* Check for end of device path */
        if ( path->Type == END_DEVICE_PATH_TYPE )
                return NULL;
 
        /* Move to next component of the device path */
        path = ( ( ( void * ) path ) +
                 /* There's this amazing new-fangled thing known as
                  * a UINT16, but who wants to use one of those? */
                 ( ( path->Length[1] << 8 ) | path->Length[0] ) );
 
        return path;
}

References END_DEVICE_PATH_TYPE, EFI_DEVICE_PATH_PROTOCOL::Length, NULL, and EFI_DEVICE_PATH_PROTOCOL::Type.

Referenced by efi_local_open_path(), efi_path_check(), efi_path_family(), efi_path_fetch(), efi_path_guid(), efi_path_mac(), efi_path_prev(), efi_path_uri(), and efi_path_vlan().

efi_path_prev()

EFI_DEVICE_PATH_PROTOCOL * efi_path_prev ( EFI_DEVICE_PATH_PROTOCOL * path, EFI_DEVICE_PATH_PROTOCOL * curr )

extern

Find previous element of device path.

Parameters

path	Device path, or NULL for no path
curr	Current element in device path, or NULL for end of path

Return values

prev	Previous element in device path, or NULL

Definition at line 146 of file efi_path.c.

                                                                            {
        EFI_DEVICE_PATH_PROTOCOL *tmp;
 
        /* Find immediately preceding element */
        while ( ( tmp = efi_path_next ( path ) ) != curr ) {
                path = tmp;
        }
 
        return path;
}

References efi_path_next(), and tmp.

Referenced by efi_locate_device(), and efi_path_end().

efi_path_end()

EFI_DEVICE_PATH_PROTOCOL * efi_path_end ( EFI_DEVICE_PATH_PROTOCOL * path )

extern

Find end of device path.

Parameters

path	Device path, or NULL

Return values

path_end

End of device path, or NULL

Definition at line 164 of file efi_path.c.

                                                                           {
 
        return efi_path_prev ( path, NULL );
}

References efi_path_prev(), and NULL.

Referenced by efi_block_exec(), efi_path_len(), and usbio_open().

efi_path_len()

size_t efi_path_len ( EFI_DEVICE_PATH_PROTOCOL * path )

extern

Find length of device path (excluding terminator).

Parameters

path	Device path, or NULL

Return values

path_len

Length of device path

Definition at line 175 of file efi_path.c.

                                                       {
        EFI_DEVICE_PATH_PROTOCOL *end = efi_path_end ( path );
 
        return ( ( ( void * ) end ) - ( ( void * ) path ) );
}

References efi_path_end(), and end.

Referenced by efi_block_match(), efi_devpath_text(), efi_ib_srp_path(), efi_image_filepath(), efi_image_uripath(), efi_init(), efi_iscsi_path(), efi_local_open_path(), efi_locate_device(), efi_netdev_path(), efi_paths(), efi_snp_hii_install(), efi_usb_path(), efidev_alloc(), and usbio_path().

efi_path_check()

int efi_path_check ( EFI_DEVICE_PATH_PROTOCOL * path, size_t max )

extern

Check that device path is well-formed.

Parameters

path	Device path, or NULL
max	Maximum device path length

Return values

rc	Return status code

Definition at line 188 of file efi_path.c.

                                                                  {
        EFI_DEVICE_PATH_PROTOCOL *next;
        size_t remaining = max;
        size_t len;
 
        /* Check that path terminates within maximum length */
        for ( ; ; path = next ) {
                if ( remaining < sizeof ( *path ) )
                        return -EINVAL;
                next = efi_path_next ( path );
                if ( ! next )
                        break;
                len = ( ( ( void * ) next ) - ( ( void * ) path ) );
                if ( remaining < len )
                        return -EINVAL;
        }
 
        return 0;
}

References efi_path_next(), EINVAL, len, max, and next.

Referenced by efi_load_path().

efi_path_mac()

void * efi_path_mac ( EFI_DEVICE_PATH_PROTOCOL * path )

extern

Get MAC address from device path.

Parameters

path	Device path

Return values

mac	MAC address, or NULL if not found

Definition at line 214 of file efi_path.c.

                                                       {
        EFI_DEVICE_PATH_PROTOCOL *next;
        MAC_ADDR_DEVICE_PATH *mac;
 
        /* Search for MAC address path */
        for ( ; ( next = efi_path_next ( path ) ) ; path = next ) {
                if ( ( path->Type == MESSAGING_DEVICE_PATH ) &&
                     ( path->SubType == MSG_MAC_ADDR_DP ) ) {
                        mac = container_of ( path, MAC_ADDR_DEVICE_PATH,
                                             Header );
                        return &mac->MacAddress;
                }
        }
 
        /* No MAC address found */
        return NULL;
}

References container_of, efi_path_next(), Header, mac, MESSAGING_DEVICE_PATH, MSG_MAC_ADDR_DP, next, NULL, EFI_DEVICE_PATH_PROTOCOL::SubType, and EFI_DEVICE_PATH_PROTOCOL::Type.

Referenced by efi_path_net_probe().

efi_path_vlan()

unsigned int efi_path_vlan ( EFI_DEVICE_PATH_PROTOCOL * path )

extern

Get VLAN tag from device path.

Parameters

path	Device path

Return values

tag	VLAN tag, or 0 if not a VLAN

Definition at line 238 of file efi_path.c.

                                                              {
        EFI_DEVICE_PATH_PROTOCOL *next;
        VLAN_DEVICE_PATH *vlan;
 
        /* Search for VLAN device path */
        for ( ; ( next = efi_path_next ( path ) ) ; path = next ) {
                if ( ( path->Type == MESSAGING_DEVICE_PATH ) &&
                     ( path->SubType == MSG_VLAN_DP ) ) {
                        vlan = container_of ( path, VLAN_DEVICE_PATH, Header );
                        return vlan->VlanId;
                }
        }
 
        /* No VLAN device path found */
        return 0;
}

References container_of, efi_path_next(), Header, MESSAGING_DEVICE_PATH, MSG_VLAN_DP, next, EFI_DEVICE_PATH_PROTOCOL::SubType, EFI_DEVICE_PATH_PROTOCOL::Type, and VLAN_DEVICE_PATH::VlanId.

Referenced by efi_cachedhcp_record(), efi_path_net_probe(), and efi_set_autoboot_ll_addr().

efi_path_family()

unsigned int efi_path_family ( EFI_DEVICE_PATH_PROTOCOL * path )

extern

Get IP address family from device path.

Parameters

path	Device path

Return values

family

Address family, or 0 if not recognised

Definition at line 261 of file efi_path.c.

                                                                {
        EFI_DEVICE_PATH_PROTOCOL *next;
 
        /* Search for IP address device path */
        for ( ; ( next = efi_path_next ( path ) ) ; path = next ) {
                if ( path->Type == MESSAGING_DEVICE_PATH ) {
                        if ( path->SubType == MSG_IPv4_DP ) {
                                return AF_INET;
                        } else if ( path->SubType == MSG_IPv6_DP ) {
                                return AF_INET6;
                        }
                }
        }
 
        /* No IP address device path found */
        return 0;
}

References AF_INET, AF_INET6, efi_path_next(), MESSAGING_DEVICE_PATH, MSG_IPv4_DP, MSG_IPv6_DP, next, EFI_DEVICE_PATH_PROTOCOL::SubType, and EFI_DEVICE_PATH_PROTOCOL::Type.

Referenced by efi_path_net_probe().

efi_path_guid()

int efi_path_guid ( EFI_DEVICE_PATH_PROTOCOL * path, union uuid * guid )

extern

Get partition GUID from device path.

Parameters

path	Device path
guid	Partition GUID to fill in

Return values

rc	Return status code

Definition at line 286 of file efi_path.c.

                                                                       {
        EFI_DEVICE_PATH_PROTOCOL *next;
        HARDDRIVE_DEVICE_PATH *hd;
        int rc;
 
        /* Search for most specific partition device path */
        rc = -ENOENT;
        for ( ; ( next = efi_path_next ( path ) ) ; path = next ) {
 
                /* Skip non-harddrive device paths */
                if ( path->Type != MEDIA_DEVICE_PATH )
                        continue;
                if ( path->SubType != MEDIA_HARDDRIVE_DP )
                        continue;
 
                /* Skip non-GUID signatures */
                hd = container_of ( path, HARDDRIVE_DEVICE_PATH, Header );
                if ( hd->SignatureType != SIGNATURE_TYPE_GUID )
                        continue;
 
                /* Extract GUID */
                memcpy ( guid, hd->Signature, sizeof ( *guid ) );
                uuid_mangle ( guid );
 
                /* Record success, but continue searching in case
                 * there exists a more specific GUID (e.g. a partition
                 * GUID rather than a disk GUID).
                 */
                rc = 0;
        }
 
        return rc;
}

References container_of, efi_path_next(), ENOENT, guid, Header, MEDIA_DEVICE_PATH, MEDIA_HARDDRIVE_DP, memcpy(), next, rc, HARDDRIVE_DEVICE_PATH::Signature, SIGNATURE_TYPE_GUID, HARDDRIVE_DEVICE_PATH::SignatureType, EFI_DEVICE_PATH_PROTOCOL::SubType, EFI_DEVICE_PATH_PROTOCOL::Type, and uuid_mangle().

Referenced by efi_block_match().

efi_path_uri()

struct uri * efi_path_uri ( EFI_DEVICE_PATH_PROTOCOL * path )

extern

Parse URI from device path.

Parameters

path	Device path

Return values

uri	URI, or NULL if not a URI

Definition at line 326 of file efi_path.c.

                                                             {
        EFI_DEVICE_PATH_PROTOCOL *next;
        URI_DEVICE_PATH *uripath;
        char *uristring;
        struct uri *uri;
        size_t len;
 
        /* Search for URI device path */
        for ( ; ( next = efi_path_next ( path ) ) ; path = next ) {
                if ( ( path->Type == MESSAGING_DEVICE_PATH ) &&
                     ( path->SubType == MSG_URI_DP ) ) {
 
                        /* Calculate path length */
                        uripath = container_of ( path, URI_DEVICE_PATH,
                                                 Header );
                        len = ( ( ( path->Length[1] << 8 ) | path->Length[0] )
                                - offsetof ( typeof ( *uripath ), Uri ) );
 
                        /* Parse URI */
                        uristring = zalloc ( len + 1 /* NUL */ );
                        if ( ! uristring )
                                return NULL;
                        memcpy ( uristring, uripath->Uri, len );
                        uri = parse_uri ( uristring );
                        free ( uristring );
 
                        return uri;
                }
        }
 
        /* No URI path found */
        return NULL;
}

References container_of, efi_path_next(), free, Header, len, memcpy(), MESSAGING_DEVICE_PATH, MSG_URI_DP, next, NULL, offsetof, parse_uri(), uri::path, typeof(), URI_DEVICE_PATH::Uri, and zalloc().

Referenced by efi_init_application().

efi_paths()

EFI_DEVICE_PATH_PROTOCOL * efi_paths ( EFI_DEVICE_PATH_PROTOCOL * first, ... )

extern

Concatenate EFI device paths.

Parameters

...	List of device paths (NULL terminated)

Return values

path	Concatenated device path, or NULL on error

The caller is responsible for eventually calling free() on the allocated device path.

Definition at line 369 of file efi_path.c.

                                                                              {
        EFI_DEVICE_PATH_PROTOCOL *path;
        EFI_DEVICE_PATH_PROTOCOL *src;
        EFI_DEVICE_PATH_PROTOCOL *dst;
        EFI_DEVICE_PATH_PROTOCOL *end;
        va_list args;
        size_t len;
 
        /* Calculate device path length */
        va_start ( args, first );
        len = 0;
        src = first;
        while ( src ) {
                len += efi_path_len ( src );
                src = va_arg ( args, EFI_DEVICE_PATH_PROTOCOL * );
        }
        va_end ( args );
 
        /* Allocate device path */
        path = zalloc ( len + sizeof ( *end ) );
        if ( ! path )
                return NULL;
 
        /* Populate device path */
        va_start ( args, first );
        dst = path;
        src = first;
        while ( src ) {
                len = efi_path_len ( src );
                memcpy ( dst, src, len );
                dst = ( ( ( void * ) dst ) + len );
                src = va_arg ( args, EFI_DEVICE_PATH_PROTOCOL * );
        }
        va_end ( args );
        end = dst;
        efi_path_terminate ( end );
 
        return path;
}

References efi_path_len(), efi_path_terminate(), end, first, len, memcpy(), NULL, uri::path, src, va_arg, va_end, va_start, and zalloc().

Referenced by efi_aoe_path().

efi_netdev_path()

EFI_DEVICE_PATH_PROTOCOL * efi_netdev_path ( struct net_device * netdev )

extern

Construct EFI device path for network device.

Parameters

netdev

Network device

Return values

path	EFI device path, or NULL on error

The caller is responsible for eventually calling free() on the allocated device path.

Definition at line 436 of file efi_path.c.

                                                                         {
        EFI_DEVICE_PATH_PROTOCOL *parent;
        EFI_DEVICE_PATH_PROTOCOL *path;
        MAC_ADDR_DEVICE_PATH *macpath;
        VLAN_DEVICE_PATH *vlanpath;
        EFI_DEVICE_PATH_PROTOCOL *end;
        unsigned int tag;
        size_t prefix_len;
        size_t len;
 
        /* Get parent EFI device path */
        parent = efi_parent_path ( netdev->dev );
 
        /* Calculate device path length */
        prefix_len = efi_path_len ( parent );
        len = ( prefix_len + sizeof ( *macpath ) + sizeof ( *vlanpath ) +
                sizeof ( *end ) );
 
        /* Allocate device path */
        path = zalloc ( len );
        if ( ! path )
                return NULL;
 
        /* Construct device path */
        memcpy ( path, parent, prefix_len );
        macpath = ( ( ( void * ) path ) + prefix_len );
        macpath->Header.Type = MESSAGING_DEVICE_PATH;
        macpath->Header.SubType = MSG_MAC_ADDR_DP;
        macpath->Header.Length[0] = sizeof ( *macpath );
        assert ( netdev->ll_protocol->ll_addr_len <
                 sizeof ( macpath->MacAddress ) );
        memcpy ( &macpath->MacAddress, netdev->ll_addr,
                 netdev->ll_protocol->ll_addr_len );
        macpath->IfType = ntohs ( netdev->ll_protocol->ll_proto );
        if ( ( tag = vlan_tag ( netdev ) ) ) {
                vlanpath = ( ( ( void * ) macpath ) + sizeof ( *macpath ) );
                vlanpath->Header.Type = MESSAGING_DEVICE_PATH;
                vlanpath->Header.SubType = MSG_VLAN_DP;
                vlanpath->Header.Length[0] = sizeof ( *vlanpath );
                vlanpath->VlanId = tag;
                end = ( ( ( void * ) vlanpath ) + sizeof ( *vlanpath ) );
        } else {
                end = ( ( ( void * ) macpath ) + sizeof ( *macpath ) );
        }
        efi_path_terminate ( end );
 
        return path;
}

References assert, efi_parent_path(), efi_path_len(), efi_path_terminate(), end, MAC_ADDR_DEVICE_PATH::Header, VLAN_DEVICE_PATH::Header, MAC_ADDR_DEVICE_PATH::IfType, len, EFI_DEVICE_PATH_PROTOCOL::Length, MAC_ADDR_DEVICE_PATH::MacAddress, memcpy(), MESSAGING_DEVICE_PATH, MSG_MAC_ADDR_DP, MSG_VLAN_DP, netdev, ntohs, NULL, efi_device::path, EFI_DEVICE_PATH_PROTOCOL::SubType, tag, EFI_DEVICE_PATH_PROTOCOL::Type, vlan_tag(), VLAN_DEVICE_PATH::VlanId, and zalloc().

Referenced by efi_aoe_path(), efi_iscsi_path(), and efi_snp_probe().

efi_uri_path()

EFI_DEVICE_PATH_PROTOCOL * efi_uri_path ( struct uri * uri )

extern

Construct EFI device path for URI.

Parameters

uri

URI

Return values

path	EFI device path, or NULL on error

The caller is responsible for eventually calling free() on the allocated device path.

Definition at line 494 of file efi_path.c.

                                                            {
        EFI_DEVICE_PATH_PROTOCOL *path;
        EFI_DEVICE_PATH_PROTOCOL *end;
        URI_DEVICE_PATH *uripath;
        size_t uri_len;
        size_t uripath_len;
        size_t len;
 
        /* Calculate device path length */
        uri_len = ( format_uri ( uri, NULL, 0 ) + 1 /* NUL */ );
        uripath_len = ( sizeof ( *uripath ) + uri_len );
        len = ( uripath_len + sizeof ( *end ) );
 
        /* Allocate device path */
        path = zalloc ( len );
        if ( ! path )
                return NULL;
 
        /* Construct device path */
        uripath = ( ( void * ) path );
        uripath->Header.Type = MESSAGING_DEVICE_PATH;
        uripath->Header.SubType = MSG_URI_DP;
        uripath->Header.Length[0] = ( uripath_len & 0xff );
        uripath->Header.Length[1] = ( uripath_len >> 8 );
        format_uri ( uri, uripath->Uri, uri_len );
        end = ( ( ( void * ) path ) + uripath_len );
        efi_path_terminate ( end );
 
        return path;
}

References efi_path_terminate(), end, format_uri(), URI_DEVICE_PATH::Header, len, EFI_DEVICE_PATH_PROTOCOL::Length, MESSAGING_DEVICE_PATH, MSG_URI_DP, NULL, efi_device::path, EFI_DEVICE_PATH_PROTOCOL::SubType, EFI_DEVICE_PATH_PROTOCOL::Type, URI_DEVICE_PATH::Uri, and zalloc().

Referenced by http_efi_describe().

efi_iscsi_path()

EFI_DEVICE_PATH_PROTOCOL * efi_iscsi_path ( struct iscsi_session * iscsi )

extern

Construct EFI device path for iSCSI device.

Parameters

iscsi

iSCSI session

Return values

path	EFI device path, or NULL on error

Definition at line 531 of file efi_path.c.

                                                                          {
        struct sockaddr_tcpip *st_target;
        struct net_device *netdev;
        EFI_DEVICE_PATH_PROTOCOL *netpath;
        EFI_DEVICE_PATH_PROTOCOL *path;
        EFI_DEVICE_PATH_PROTOCOL *end;
        ISCSI_DEVICE_PATH *iscsipath;
        char *name;
        size_t prefix_len;
        size_t name_len;
        size_t iscsi_len;
        size_t len;
 
        /* Get network device associated with target address */
        st_target = ( ( struct sockaddr_tcpip * ) &iscsi->target_sockaddr );
        netdev = tcpip_netdev ( st_target );
        if ( ! netdev )
                goto err_netdev;
 
        /* Get network device path */
        netpath = efi_netdev_path ( netdev );
        if ( ! netpath )
                goto err_netpath;
 
        /* Calculate device path length */
        prefix_len = efi_path_len ( netpath );
        name_len = ( strlen ( iscsi->target_iqn ) + 1 /* NUL */ );
        iscsi_len = ( sizeof ( *iscsipath ) + name_len );
        len = ( prefix_len + iscsi_len + sizeof ( *end ) );
 
        /* Allocate device path */
        path = zalloc ( len );
        if ( ! path )
                goto err_alloc;
 
        /* Construct device path */
        memcpy ( path, netpath, prefix_len );
        iscsipath = ( ( ( void * ) path ) + prefix_len );
        iscsipath->Header.Type = MESSAGING_DEVICE_PATH;
        iscsipath->Header.SubType = MSG_ISCSI_DP;
        iscsipath->Header.Length[0] = iscsi_len;
        iscsipath->LoginOption = ISCSI_LOGIN_OPTION_AUTHMETHOD_NON;
        memcpy ( &iscsipath->Lun, &iscsi->lun, sizeof ( iscsipath->Lun ) );
        name = ( ( ( void * ) iscsipath ) + sizeof ( *iscsipath ) );
        memcpy ( name, iscsi->target_iqn, name_len );
        end = ( ( ( void * ) name ) + name_len );
        efi_path_terminate ( end );
 
        /* Free temporary paths */
        free ( netpath );
 
        return path;
 
 err_alloc:
        free ( netpath );
 err_netpath:
 err_netdev:
        return NULL;
}

References efi_netdev_path(), efi_path_len(), efi_path_terminate(), end, free, ISCSI_DEVICE_PATH::Header, ISCSI_LOGIN_OPTION_AUTHMETHOD_NON, len, EFI_DEVICE_PATH_PROTOCOL::Length, ISCSI_DEVICE_PATH::LoginOption, ISCSI_DEVICE_PATH::Lun, iscsi_session::lun, memcpy(), MESSAGING_DEVICE_PATH, MSG_ISCSI_DP, name, netdev, NULL, strlen(), EFI_DEVICE_PATH_PROTOCOL::SubType, iscsi_session::target_iqn, iscsi_session::target_sockaddr, tcpip_netdev(), EFI_DEVICE_PATH_PROTOCOL::Type, and zalloc().

efi_aoe_path()

EFI_DEVICE_PATH_PROTOCOL * efi_aoe_path ( struct aoe_device * aoedev )

extern

Construct EFI device path for AoE device.

Parameters

aoedev

AoE device

Return values

path	EFI device path, or NULL on error

Definition at line 597 of file efi_path.c.

                                                                      {
        struct {
                SATA_DEVICE_PATH sata;
                EFI_DEVICE_PATH_PROTOCOL end;
        } satapath;
        EFI_DEVICE_PATH_PROTOCOL *netpath;
        EFI_DEVICE_PATH_PROTOCOL *path;
 
        /* Get network device path */
        netpath = efi_netdev_path ( aoedev->netdev );
        if ( ! netpath )
                goto err_netdev;
 
        /* Construct SATA path */
        memset ( &satapath, 0, sizeof ( satapath ) );
        satapath.sata.Header.Type = MESSAGING_DEVICE_PATH;
        satapath.sata.Header.SubType = MSG_SATA_DP;
        satapath.sata.Header.Length[0] = sizeof ( satapath.sata );
        satapath.sata.HBAPortNumber = aoedev->major;
        satapath.sata.PortMultiplierPortNumber = aoedev->minor;
        efi_path_terminate ( &satapath.end );
 
        /* Construct overall device path */
        path = efi_paths ( netpath, &satapath, NULL );
        if ( ! path )
                goto err_paths;
 
        /* Free temporary paths */
        free ( netpath );
 
        return path;
 
 err_paths:
        free ( netpath );
 err_netdev:
        return NULL;
}

References efi_netdev_path(), efi_path_terminate(), efi_paths(), end, free, aoe_device::major, memset(), MESSAGING_DEVICE_PATH, aoe_device::minor, MSG_SATA_DP, aoe_device::netdev, and NULL.

efi_fcp_path()

EFI_DEVICE_PATH_PROTOCOL * efi_fcp_path ( struct fcp_description * desc )

extern

Construct EFI device path for Fibre Channel device.

Parameters

desc	FCP device description

Return values

path	EFI device path, or NULL on error

Definition at line 641 of file efi_path.c.

                                                                         {
        struct {
                FIBRECHANNELEX_DEVICE_PATH fc;
                EFI_DEVICE_PATH_PROTOCOL end;
        } __attribute__ (( packed )) *path;
 
        /* Allocate device path */
        path = zalloc ( sizeof ( *path ) );
        if ( ! path )
                return NULL;
 
        /* Construct device path */
        path->fc.Header.Type = MESSAGING_DEVICE_PATH;
        path->fc.Header.SubType = MSG_FIBRECHANNELEX_DP;
        path->fc.Header.Length[0] = sizeof ( path->fc );
        memcpy ( path->fc.WWN, &desc->wwn, sizeof ( path->fc.WWN ) );
        memcpy ( path->fc.Lun, &desc->lun, sizeof ( path->fc.Lun ) );
        efi_path_terminate ( &path->end );
 
        return &path->fc.Header;
}

References __attribute__, desc, efi_path_terminate(), end, fc, memcpy(), MESSAGING_DEVICE_PATH, MSG_FIBRECHANNELEX_DP, NULL, and zalloc().

Referenced by fcpdev_efi_describe().

efi_ib_srp_path()

EFI_DEVICE_PATH_PROTOCOL * efi_ib_srp_path ( struct ib_srp_device * ib_srp )

extern

Construct EFI device path for Infiniband SRP device.

Parameters

ib_srp

Infiniband SRP device

Return values

path	EFI device path, or NULL on error

Definition at line 669 of file efi_path.c.

                                                                            {
        const struct ipxe_ib_sbft *sbft = &ib_srp->sbft;
        union ib_srp_target_port_id *id =
                container_of ( &sbft->srp.target, union ib_srp_target_port_id,
                               srp );
        EFI_DEVICE_PATH_PROTOCOL *parent;
        EFI_DEVICE_PATH_PROTOCOL *path;
        INFINIBAND_DEVICE_PATH *ibpath;
        EFI_DEVICE_PATH_PROTOCOL *end;
        size_t prefix_len;
        size_t len;
 
        /* Get parent EFI device path */
        parent = efi_parent_path ( ib_srp->ibdev->dev );
 
        /* Calculate device path length */
        prefix_len = efi_path_len ( parent );
        len = ( prefix_len + sizeof ( *ibpath ) + sizeof ( *end ) );
 
        /* Allocate device path */
        path = zalloc ( len );
        if ( ! path )
                return NULL;
 
        /* Construct device path */
        memcpy ( path, parent, prefix_len );
        ibpath = ( ( ( void * ) path ) + prefix_len );
        ibpath->Header.Type = MESSAGING_DEVICE_PATH;
        ibpath->Header.SubType = MSG_INFINIBAND_DP;
        ibpath->Header.Length[0] = sizeof ( *ibpath );
        ibpath->ResourceFlags = INFINIBAND_RESOURCE_FLAG_STORAGE_PROTOCOL;
        memcpy ( ibpath->PortGid, &sbft->ib.dgid, sizeof ( ibpath->PortGid ) );
        memcpy ( &ibpath->ServiceId, &sbft->ib.service_id,
                 sizeof ( ibpath->ServiceId ) );
        memcpy ( &ibpath->TargetPortId, &id->ib.ioc_guid,
                 sizeof ( ibpath->TargetPortId ) );
        memcpy ( &ibpath->DeviceId, &id->ib.id_ext,
                 sizeof ( ibpath->DeviceId ) );
        end = ( ( ( void * ) ibpath ) + sizeof ( *ibpath ) );
        efi_path_terminate ( end );
 
        return path;
}

References container_of, ib_device::dev, INFINIBAND_DEVICE_PATH::DeviceId, sbft_ib_subtable::dgid, efi_parent_path(), efi_path_len(), efi_path_terminate(), end, INFINIBAND_DEVICE_PATH::Header, ipxe_ib_sbft::ib, ib_srp_device::ibdev, id, INFINIBAND_RESOURCE_FLAG_STORAGE_PROTOCOL, len, EFI_DEVICE_PATH_PROTOCOL::Length, memcpy(), MESSAGING_DEVICE_PATH, MSG_INFINIBAND_DP, NULL, INFINIBAND_DEVICE_PATH::PortGid, INFINIBAND_DEVICE_PATH::ResourceFlags, ib_srp_device::sbft, sbft_ib_subtable::service_id, INFINIBAND_DEVICE_PATH::ServiceId, ib_srp_target_port_id::srp, ipxe_ib_sbft::srp, EFI_DEVICE_PATH_PROTOCOL::SubType, sbft_srp_subtable::target, INFINIBAND_DEVICE_PATH::TargetPortId, EFI_DEVICE_PATH_PROTOCOL::Type, and zalloc().

efi_usb_path()

EFI_DEVICE_PATH_PROTOCOL * efi_usb_path ( struct usb_function * func )

extern

Construct EFI device path for USB function.

Parameters

func	USB function

Return values

path	EFI device path, or NULL on error

The caller is responsible for eventually calling free() on the allocated device path.

Definition at line 722 of file efi_path.c.

                                                                      {
        struct usb_device *usb = func->usb;
        EFI_DEVICE_PATH_PROTOCOL *parent;
        EFI_DEVICE_PATH_PROTOCOL *path;
        EFI_DEVICE_PATH_PROTOCOL *end;
        USB_DEVICE_PATH *usbpath;
        unsigned int count;
        size_t prefix_len;
        size_t len;
 
        /* Sanity check */
        assert ( func->desc.count >= 1 );
 
        /* Get parent EFI device path */
        parent = efi_parent_path ( &func->dev );
 
        /* Calculate device path length */
        count = ( usb_depth ( usb ) + 1 );
        prefix_len = efi_path_len ( parent );
        len = ( prefix_len + ( count * sizeof ( *usbpath ) ) +
                sizeof ( *end ) );
 
        /* Allocate device path */
        path = zalloc ( len );
        if ( ! path )
                return NULL;
 
        /* Construct device path */
        memcpy ( path, parent, prefix_len );
        end = ( ( ( void * ) path ) + len - sizeof ( *end ) );
        efi_path_terminate ( end );
        usbpath = ( ( ( void * ) end ) - sizeof ( *usbpath ) );
        usbpath->InterfaceNumber = func->interface[0];
        for ( ; usb ; usbpath--, usb = usb->port->hub->usb ) {
                usbpath->Header.Type = MESSAGING_DEVICE_PATH;
                usbpath->Header.SubType = MSG_USB_DP;
                usbpath->Header.Length[0] = sizeof ( *usbpath );
                usbpath->ParentPortNumber = ( usb->port->address - 1 );
        }
 
        return path;
}

References usb_port::address, assert, count, usb_function_descriptor::count, usb_function::desc, usb_function::dev, efi_parent_path(), efi_path_len(), efi_path_terminate(), end, USB_DEVICE_PATH::Header, usb_port::hub, usb_function::interface, USB_DEVICE_PATH::InterfaceNumber, len, EFI_DEVICE_PATH_PROTOCOL::Length, memcpy(), MESSAGING_DEVICE_PATH, MSG_USB_DP, NULL, USB_DEVICE_PATH::ParentPortNumber, usb_device::port, EFI_DEVICE_PATH_PROTOCOL::SubType, EFI_DEVICE_PATH_PROTOCOL::Type, usb_function::usb, usb_hub::usb, usb_depth(), and zalloc().

Referenced by efi_usb_install(), and usbblk_efi_describe().

efi_load_path()

EFI_DEVICE_PATH_PROTOCOL * efi_load_path ( EFI_LOAD_OPTION * load, size_t len )

extern

Get EFI device path from load option.

Parameters

load	EFI load option
len	Length of EFI load option

Return values

path	EFI device path, or NULL on error

The caller is responsible for eventually calling free() on the allocated device path.

Definition at line 775 of file efi_path.c.

                                                        {
        EFI_DEVICE_PATH_PROTOCOL *path;
        EFI_DEVICE_PATH_PROTOCOL *copy;
        CHAR16 *wdesc;
        size_t path_max;
        size_t wmax;
        size_t wlen;
 
        /* Check basic structure size */
        if ( len < sizeof ( *load ) ) {
                DBGC ( load, "EFI load option too short for header:\n" );
                DBGC_HDA ( load, 0, load, len );
                return NULL;
        }
 
        /* Get length of description */
        wdesc = ( ( ( void * ) load ) + sizeof ( *load ) );
        wmax = ( ( len - sizeof ( *load ) ) / sizeof ( wdesc[0] ) );
        wlen = wcsnlen ( wdesc, wmax );
        if ( wlen == wmax ) {
                DBGC ( load, "EFI load option has unterminated "
                       "description:\n" );
                DBGC_HDA ( load, 0, load, len );
                return NULL;
        }
 
        /* Get inline device path */
        path = ( ( ( void * ) load ) + sizeof ( *load ) +
                 ( wlen * sizeof ( wdesc[0] ) ) + 2 /* wNUL */ );
        path_max = ( len - sizeof ( *load ) - ( wlen * sizeof ( wdesc[0] ) )
                     - 2 /* wNUL */ );
        if ( load->FilePathListLength > path_max ) {
                DBGC ( load, "EFI load option too short for path(s):\n" );
                DBGC_HDA ( load, 0, load, len );
                return NULL;
        }
 
        /* Check path length */
        if ( efi_path_check ( path, path_max ) != 0 ) {
                DBGC ( load, "EFI load option has unterminated device "
                       "path:\n" );
                DBGC_HDA ( load, 0, load, len );
                return NULL;
        }
 
        /* Allocate copy of path */
        copy = malloc ( path_max );
        if ( ! copy )
                return NULL;
        memcpy ( copy, path, path_max );
 
        return copy;
}

References DBGC, DBGC_HDA, efi_path_check(), _EFI_LOAD_OPTION::FilePathListLength, len, malloc(), memcpy(), NULL, and wcsnlen().

Referenced by efi_boot_path().

efi_boot_path()

EFI_DEVICE_PATH_PROTOCOL * efi_boot_path ( unsigned int number )

extern

Get EFI device path for numbered boot option.

Parameters

number

Boot option number

Return values

path	EFI device path, or NULL on error

The caller is responsible for eventually calling free() on the allocated device path.

Definition at line 839 of file efi_path.c.

                                                                 {
        EFI_RUNTIME_SERVICES *rs = efi_systab->RuntimeServices;
        EFI_GUID *guid = &efi_global_variable;
        CHAR16 wname[ 9 /* "BootXXXX" + wNUL */ ];
        EFI_LOAD_OPTION *load;
        EFI_DEVICE_PATH *path;
        UINT32 attrs;
        UINTN size;
        EFI_STATUS efirc;
        int rc;
 
        /* Construct variable name */
        efi_snprintf ( wname, ( sizeof ( wname ) / sizeof ( wname[0] ) ),
                       "Boot%04X", number );
 
        /* Get variable length */
        size = 0;
        if ( ( efirc = rs->GetVariable ( wname, guid, &attrs, &size,
                                         NULL ) != EFI_BUFFER_TOO_SMALL ) ) {
                rc = -EEFI ( efirc );
                DBGC ( rs, "EFI could not get size of %ls: %s\n",
                       wname, strerror ( rc ) );
                goto err_size;
        }
 
        /* Allocate temporary buffer for EFI_LOAD_OPTION */
        load = malloc ( size );
        if ( ! load ) {
                rc = -ENOMEM;
                goto err_alloc;
        }
 
        /* Read variable */
        if ( ( efirc = rs->GetVariable ( wname, guid, &attrs, &size,
                                         load ) != 0 ) ) {
                rc = -EEFI ( efirc );
                DBGC ( rs, "EFI could not read %ls: %s\n",
                       wname, strerror ( rc ) );
                goto err_read;
        }
        DBGC2 ( rs, "EFI boot option %ls is:\n", wname );
        DBGC2_HDA ( rs, 0, load, size );
 
        /* Get device path from load option */
        path = efi_load_path ( load, size );
        if ( ! path ) {
                rc = -EINVAL;
                DBGC ( rs, "EFI could not parse %ls: %s\n",
                       wname, strerror ( rc ) );
                goto err_path;
        }
 
        /* Free temporary buffer */
        free ( load );
 
        return path;
 
 err_path:
 err_read:
        free ( load );
 err_alloc:
 err_size:
        return NULL;
}

References DBGC, DBGC2, DBGC2_HDA, EEFI, EFI_BUFFER_TOO_SMALL, efi_global_variable, efi_load_path(), efi_snprintf(), efi_systab, EINVAL, ENOMEM, free, EFI_RUNTIME_SERVICES::GetVariable, guid, malloc(), NULL, rc, size, and strerror().

Referenced by efi_current_boot_path().

efi_current_boot_path()

EFI_DEVICE_PATH_PROTOCOL * efi_current_boot_path ( void )

extern

Get EFI device path for current boot option.

Return values

path	EFI device path, or NULL on error

The caller is responsible for eventually calling free() on the allocated device path.

Definition at line 912 of file efi_path.c.

                                                          {
        EFI_RUNTIME_SERVICES *rs = efi_systab->RuntimeServices;
        EFI_GUID *guid = &efi_global_variable;
        CHAR16 wname[] = L"BootCurrent";
        UINT16 current;
        UINT32 attrs;
        UINTN size;
        EFI_STATUS efirc;
        int rc;
 
        /* Read current boot option index */
        size = sizeof ( current );
        if ( ( efirc = rs->GetVariable ( wname, guid, &attrs, &size,
                                         &current ) != 0 ) ) {
                rc = -EEFI ( efirc );
                DBGC ( rs, "EFI could not read %ls: %s\n",
                       wname, strerror ( rc ) );
                return NULL;
        }
 
        /* Get device path from this boot option */
        return efi_boot_path ( current );
}

References DBGC, EEFI, efi_boot_path(), efi_global_variable, efi_systab, EFI_RUNTIME_SERVICES::GetVariable, guid, NULL, rc, size, and strerror().

Referenced by efi_init_application().

efi_describe()

EFI_DEVICE_PATH_PROTOCOL * efi_describe ( struct interface * intf )

extern

Describe object as an EFI device path.

Parameters

intf

Interface

Return values

path	EFI device path, or NULL

The caller is responsible for eventually calling free() on the allocated device path.

Definition at line 945 of file efi_path.c.

                                                                   {
        struct interface *dest;
        efi_describe_TYPE ( void * ) *op =
                intf_get_dest_op ( intf, efi_describe, &dest );
        void *object = intf_object ( dest );
        EFI_DEVICE_PATH_PROTOCOL *path;
 
        if ( op ) {
                path = op ( object );
        } else {
                path = NULL;
        }
 
        intf_put ( dest );
        return path;
}

References dest, efi_describe(), efi_describe_TYPE, interface::intf, intf_get_dest_op, intf_object(), intf_put(), NULL, and op.

Referenced by efi_block_hook(), and efi_describe().