efi_path.c File Reference

EFI device paths. More...

#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <errno.h>
#include <byteswap.h>
#include <ipxe/netdevice.h>
#include <ipxe/vlan.h>
#include <ipxe/uuid.h>
#include <ipxe/tcpip.h>
#include <ipxe/uri.h>
#include <ipxe/iscsi.h>
#include <ipxe/aoe.h>
#include <ipxe/fcp.h>
#include <ipxe/ib_srp.h>
#include <ipxe/usb.h>
#include <ipxe/settings.h>
#include <ipxe/dhcp.h>
#include <ipxe/efi/efi.h>
#include <ipxe/efi/efi_driver.h>
#include <ipxe/efi/efi_strings.h>
#include <ipxe/efi/efi_path.h>

Go to the source code of this file.

Data Structures
struct	efi_path_settings
	An EFI device path settings block. More...
struct	efi_path_setting
	An EFI device path setting. More...

Functions
	FILE_LICENCE (GPL2_OR_LATER)
EFI_DEVICE_PATH_PROTOCOL *	efi_path_next (EFI_DEVICE_PATH_PROTOCOL *path)
	Find next element in device path. More...
EFI_DEVICE_PATH_PROTOCOL *	efi_path_prev (EFI_DEVICE_PATH_PROTOCOL *path, EFI_DEVICE_PATH_PROTOCOL *curr)
	Find previous element of device path. More...
EFI_DEVICE_PATH_PROTOCOL *	efi_path_end (EFI_DEVICE_PATH_PROTOCOL *path)
	Find end of device path. More...
size_t	efi_path_len (EFI_DEVICE_PATH_PROTOCOL *path)
	Find length of device path (excluding terminator) More...
int	efi_path_check (EFI_DEVICE_PATH_PROTOCOL *path, size_t max)
	Check that device path is well-formed. More...
void *	efi_path_mac (EFI_DEVICE_PATH_PROTOCOL *path)
	Get MAC address from device path. More...
unsigned int	efi_path_vlan (EFI_DEVICE_PATH_PROTOCOL *path)
	Get VLAN tag from device path. More...
int	efi_path_guid (EFI_DEVICE_PATH_PROTOCOL *path, union uuid *guid)
	Get partition GUID from device path. More...
struct uri *	efi_path_uri (EFI_DEVICE_PATH_PROTOCOL *path)
	Parse URI from device path. More...
EFI_DEVICE_PATH_PROTOCOL *	efi_paths (EFI_DEVICE_PATH_PROTOCOL *first,...)
	Concatenate EFI device paths. More...
static EFI_DEVICE_PATH_PROTOCOL *	efi_parent_path (struct device *dev)
	Construct EFI parent device path. More...
EFI_DEVICE_PATH_PROTOCOL *	efi_netdev_path (struct net_device *netdev)
	Construct EFI device path for network device. More...
EFI_DEVICE_PATH_PROTOCOL *	efi_uri_path (struct uri *uri)
	Construct EFI device path for URI. More...
EFI_DEVICE_PATH_PROTOCOL *	efi_iscsi_path (struct iscsi_session *iscsi)
	Construct EFI device path for iSCSI device. More...
EFI_DEVICE_PATH_PROTOCOL *	efi_aoe_path (struct aoe_device *aoedev)
	Construct EFI device path for AoE device. More...
EFI_DEVICE_PATH_PROTOCOL *	efi_fcp_path (struct fcp_description *desc)
	Construct EFI device path for Fibre Channel device. More...
EFI_DEVICE_PATH_PROTOCOL *	efi_ib_srp_path (struct ib_srp_device *ib_srp)
	Construct EFI device path for Infiniband SRP device. More...
EFI_DEVICE_PATH_PROTOCOL *	efi_usb_path (struct usb_function *func)
	Construct EFI device path for USB function. More...
EFI_DEVICE_PATH_PROTOCOL *	efi_load_path (EFI_LOAD_OPTION *load, size_t len)
	Get EFI device path from load option. More...
EFI_DEVICE_PATH_PROTOCOL *	efi_boot_path (unsigned int number)
	Get EFI device path for numbered boot option. More...
EFI_DEVICE_PATH_PROTOCOL *	efi_current_boot_path (void)
	Get EFI device path for current boot option. More...
EFI_DEVICE_PATH_PROTOCOL *	efi_describe (struct interface *intf)
	Describe object as an EFI device path. More...
static int	efi_path_fetch_fixed (struct efi_path_setting *pathset, EFI_DEVICE_PATH_PROTOCOL *path, void *data, size_t len)
	Fetch an EFI device path fixed-size setting. More...
static int	efi_path_fetch_dns (struct efi_path_setting *pathset, EFI_DEVICE_PATH_PROTOCOL *path, void *data, size_t len)
	Fetch an EFI device path DNS setting. More...
static int	efi_path_fetch (struct settings *settings, struct setting *setting, void *data, size_t len)
	Fetch value of EFI device path setting. More...
static int	efi_path_net_probe (struct net_device *netdev, void *priv)
	Create per-netdevice EFI path settings. More...

Variables
struct {
BBS_BBS_DEVICE_PATH   bbs
CHAR8   tring [4]
EFI_DEVICE_PATH_PROTOCOL   end
}	efi_dummy_parent_path
	Dummy parent device path. More...
static struct efi_path_setting	efi_path_settings []
	EFI device path settings. More...
static struct settings_operations	efi_path_settings_operations
	EFI device path settings operations. More...
struct net_driver efi_path_net_driver	__net_driver
	EFI path settings per-netdevice driver. More...

Detailed Description

EFI device paths.

Definition in file efi_path.c.

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER

)

efi_path_next()

EFI_DEVICE_PATH_PROTOCOL* efi_path_next

(

EFI_DEVICE_PATH_PROTOCOL *

path

)

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 118 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_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
	)

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 144 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

)

Find end of device path.

Parameters

path	Device path, or NULL

Return values

path_end

End of device path, or NULL

Definition at line 162 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

)

Find length of device path (excluding terminator)

Parameters

path	Device path, or NULL

Return values

path_len

Length of device path

Definition at line 173 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_path(), 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
	)

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 186 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

)

Get MAC address from device path.

Parameters

path	Device path

Return values

mac	MAC address, or NULL if not found

Definition at line 212 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

)

Get VLAN tag from device path.

Parameters

path	Device path

Return values

tag	VLAN tag, or 0 if not a VLAN

Definition at line 236 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_guid()

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

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 260 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

)

Parse URI from device path.

Parameters

path	Device path

Return values

uri	URI, or NULL if not a URI

Definition at line 300 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,
			...
	)

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 343 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_parent_path()

static EFI_DEVICE_PATH_PROTOCOL* efi_parent_path ( struct device *  dev )

static

Construct EFI parent device path.

Parameters

dev	Generic device

Return values

path	Parent (or dummy) device path

Definition at line 389 of file efi_path.c.

                                                                         {
        struct efi_device *efidev;

        /* Use EFI parent device's path, if possible */
        efidev = efidev_parent ( dev );
        if ( efidev )
                return efidev->path;

        /* Otherwise, use a dummy parent device path */
        return &efi_dummy_parent_path.bbs.Header;
}

References efi_device::dev, efi_dummy_parent_path, efidev_parent(), and efi_device::path.

Referenced by efi_ib_srp_path(), efi_netdev_path(), and efi_usb_path().

efi_netdev_path()

EFI_DEVICE_PATH_PROTOCOL* efi_netdev_path

(

struct net_device *

netdev

)

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 410 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(), net_device::dev, 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, net_device::ll_addr, ll_protocol::ll_addr_len, ll_protocol::ll_proto, net_device::ll_protocol, 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

)

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 468 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

)

Construct EFI device path for iSCSI device.

Parameters

iscsi

iSCSI session

Return values

path	EFI device path, or NULL on error

Definition at line 505 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_session::lun, ISCSI_DEVICE_PATH::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

)

Construct EFI device path for AoE device.

Parameters

aoedev

AoE device

Return values

path	EFI device path, or NULL on error

Definition at line 571 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

)

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 615 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

)

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 643 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

)

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 696 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 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
	)

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 749 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

)

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 813 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, EFI_SYSTEM_TABLE::RuntimeServices, size, and strerror().

Referenced by efi_current_boot_path().

efi_current_boot_path()

EFI_DEVICE_PATH_PROTOCOL* efi_current_boot_path

(

void

)

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 886 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, EFI_SYSTEM_TABLE::RuntimeServices, size, and strerror().

Referenced by efi_init_application().

efi_describe()

EFI_DEVICE_PATH_PROTOCOL* efi_describe

(

struct interface *

intf

)

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 919 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().

efi_path_fetch_fixed()

static int efi_path_fetch_fixed ( struct efi_path_setting *  pathset, EFI_DEVICE_PATH_PROTOCOL *  path, void *  data, size_t  len  )

static

Fetch an EFI device path fixed-size setting.

Parameters

pathset	Path setting
path	Device path
data	Buffer to fill with setting data
len	Length of buffer

Return values

len	Length of setting data, or negative error

Definition at line 945 of file efi_path.c.

                                                           {

        /* Copy data */
        if ( len > pathset->len )
                len = pathset->len;
        memcpy ( data, ( ( ( void * ) path ) + pathset->offset ), len );

        return pathset->len;
}

References data, efi_path_setting::len, len, memcpy(), and efi_path_setting::offset.

efi_path_fetch_dns()

static int efi_path_fetch_dns ( struct efi_path_setting *  pathset, EFI_DEVICE_PATH_PROTOCOL *  path, void *  data, size_t  len  )

static

Fetch an EFI device path DNS setting.

Parameters

pathset	Path setting
path	Device path
data	Buffer to fill with setting data
len	Length of buffer

Return values

len	Length of setting data, or negative error

Definition at line 966 of file efi_path.c.

                                                         {
        DNS_DEVICE_PATH *dns = container_of ( path, DNS_DEVICE_PATH, Header );
        unsigned int count;
        unsigned int i;
        size_t frag_len;

        /* Check applicability */
        if ( ( !! dns->IsIPv6 ) !=
             ( pathset->setting->type == &setting_type_ipv6 ) )
                return -ENOENT;

        /* Calculate number of addresses */
        count = ( ( ( ( path->Length[1] << 8 ) | path->Length[0] ) -
                    pathset->offset ) / sizeof ( dns->DnsServerIp[0] ) );

        /* Copy data */
        for ( i = 0 ; i < count ; i++ ) {
                frag_len = len;
                if ( frag_len > pathset->len )
                        frag_len = pathset->len;
                memcpy ( data, &dns->DnsServerIp[i], frag_len );
                data += frag_len;
                len -= frag_len;
        }

        return ( count * pathset->len );
}

References container_of, count, data, DNS_DEVICE_PATH::DnsServerIp, ENOENT, Header, DNS_DEVICE_PATH::IsIPv6, efi_path_setting::len, len, EFI_DEVICE_PATH_PROTOCOL::Length, memcpy(), efi_path_setting::offset, efi_path_setting::setting, and setting::type.

efi_path_fetch()

static int efi_path_fetch ( struct settings *  settings, struct setting *  setting, void *  data, size_t  len  )

static

Fetch value of EFI device path setting.

Parameters

settings	Settings block
setting	Setting to fetch
data	Buffer to fill with setting data
len	Length of buffer

Return values

len	Length of setting data, or negative error

Definition at line 1033 of file efi_path.c.

                                                     {
        struct efi_path_settings *pathsets =
                container_of ( settings, struct efi_path_settings, settings );
        EFI_DEVICE_PATH_PROTOCOL *path = pathsets->path;
        EFI_DEVICE_PATH_PROTOCOL *next;
        struct efi_path_setting *pathset;
        unsigned int i;
        int ret;

        /* Find matching path setting, if any */
        for ( i = 0 ; i < ( sizeof ( efi_path_settings ) /
                            sizeof ( efi_path_settings[0] ) ) ; i++ ) {

                /* Check for a matching setting */
                pathset = &efi_path_settings[i];
                if ( setting_cmp ( setting, pathset->setting ) != 0 )
                        continue;

                /* Find matching device path element, if any */
                for ( ; ( next = efi_path_next ( path ) ) ; path = next ) {

                        /* Check for a matching path type */
                        if ( ( path->Type != pathset->type ) ||
                             ( path->SubType != pathset->subtype ) )
                                continue;

                        /* Fetch value */
                        if ( ( ret = pathset->fetch ( pathset, path,
                                                      data, len ) ) < 0 )
                                return ret;

                        /* Apply default type, if not already set */
                        if ( ! setting->type )
                                setting->type = pathset->setting->type;

                        return ret;
                }
                break;
        }

        return -ENOENT;
}

References container_of, data, efi_path_next(), efi_path_settings, ENOENT, efi_path_setting::fetch, len, next, efi_path_settings::path, efi_path_setting::setting, setting_cmp(), EFI_DEVICE_PATH_PROTOCOL::SubType, efi_path_setting::subtype, setting::type, EFI_DEVICE_PATH_PROTOCOL::Type, and efi_path_setting::type.

efi_path_net_probe()

static int efi_path_net_probe ( struct net_device *  netdev, void *  priv  )

static

Create per-netdevice EFI path settings.

Parameters

netdev	Network device
priv	Private data

Return values

rc	Return status code

Definition at line 1089 of file efi_path.c.

                                                                        {
        struct efi_path_settings *pathsets = priv;
        struct settings *settings = &pathsets->settings;
        EFI_DEVICE_PATH_PROTOCOL *path = efi_loaded_image_path;
        unsigned int vlan;
        void *mac;
        int rc;

        /* Check applicability */
        pathsets->path = path;
        mac = efi_path_mac ( path );
        vlan = efi_path_vlan ( path );
        if ( ( mac == NULL ) ||
             ( memcmp ( mac, netdev->ll_addr,
                        netdev->ll_protocol->ll_addr_len ) != 0 ) ||
             ( vlan != vlan_tag ( netdev ) ) ) {
                DBGC ( settings, "EFI path %s does not apply to %s\n",
                       efi_devpath_text ( path ), netdev->name );
                return 0;
        }

        /* Never override a real DHCP settings block */
        if ( find_child_settings ( netdev_settings ( netdev ),
                                   DHCP_SETTINGS_NAME ) ) {
                DBGC ( settings, "EFI path %s not overriding %s DHCP "
                       "settings\n", efi_devpath_text ( path ), netdev->name );
                return 0;
        }

        /* Initialise and register settings */
        settings_init ( settings, &efi_path_settings_operations,
                        &netdev->refcnt, NULL );
        if ( ( rc = register_settings ( settings, netdev_settings ( netdev ),
                                        DHCP_SETTINGS_NAME ) ) != 0 ) {
                DBGC ( settings, "EFI path %s could not register for %s: %s\n",
                       efi_devpath_text ( path ), netdev->name,
                       strerror ( rc ) );
                return rc;
        }
        DBGC ( settings, "EFI path %s registered for %s\n",
               efi_devpath_text ( path ), netdev->name );

        return 0;
}

References DBGC, DHCP_SETTINGS_NAME, efi_devpath_text(), efi_loaded_image_path, efi_path_mac(), efi_path_settings_operations, efi_path_vlan(), find_child_settings(), net_device::ll_addr, ll_protocol::ll_addr_len, net_device::ll_protocol, mac, memcmp(), net_device::name, netdev, netdev_settings(), NULL, efi_path_settings::path, priv, rc, net_device::refcnt, register_settings(), efi_path_settings::settings, settings_init(), strerror(), and vlan_tag().

Variable Documentation

bbs

BBS_BBS_DEVICE_PATH bbs

Definition at line 56 of file efi_path.c.

tring

CHAR8 tring[4]

Definition at line 57 of file efi_path.c.

end

EFI_DEVICE_PATH_PROTOCOL end

Definition at line 58 of file efi_path.c.

Referenced by efi_aoe_path(), efi_fcp_path(), efi_ib_srp_path(), efi_iscsi_path(), efi_netdev_path(), efi_path_len(), efi_paths(), efi_uri_path(), and efi_usb_path().

efi_dummy_parent_path

struct { ... } efi_dummy_parent_path

Initial value:

= {
        .bbs = {
                .Header = {
                        .Type = BBS_DEVICE_PATH,
                        .SubType = BBS_BBS_DP,
                        .Length[0] = ( sizeof ( efi_dummy_parent_path.bbs ) +
                                       sizeof ( efi_dummy_parent_path.tring )),
                },
                .DeviceType = BBS_TYPE_UNKNOWN,
                .String[0] = 'i',
        },
        .tring = "PXE",
        .end = {
                .Type = END_DEVICE_PATH_TYPE,
                .SubType = END_ENTIRE_DEVICE_PATH_SUBTYPE,
                .Length[0] = sizeof ( efi_dummy_parent_path.end ),
        },
}

Dummy parent device path.

This is used as the parent device path when we need to construct a path for a device that has no EFI parent device.

Referenced by efi_parent_path().

efi_path_settings

struct efi_path_setting efi_path_settings[]

static

Initial value:

= {
        { &ip_setting, efi_path_fetch_fixed, MESSAGING_DEVICE_PATH,
          MSG_IPv4_DP, offsetof ( IPv4_DEVICE_PATH, LocalIpAddress ),
          sizeof ( struct in_addr ) },
        { &netmask_setting, efi_path_fetch_fixed, MESSAGING_DEVICE_PATH,
          MSG_IPv4_DP, offsetof ( IPv4_DEVICE_PATH, SubnetMask ),
          sizeof ( struct in_addr ) },
        { &gateway_setting, efi_path_fetch_fixed, MESSAGING_DEVICE_PATH,
          MSG_IPv4_DP, offsetof ( IPv4_DEVICE_PATH, GatewayIpAddress ),
          sizeof ( struct in_addr ) },
        { &ip6_setting, efi_path_fetch_fixed, MESSAGING_DEVICE_PATH,
          MSG_IPv6_DP, offsetof ( IPv6_DEVICE_PATH, LocalIpAddress ),
          sizeof ( struct in6_addr ) },
        { &len6_setting, efi_path_fetch_fixed, MESSAGING_DEVICE_PATH,
          MSG_IPv6_DP, offsetof ( IPv6_DEVICE_PATH, PrefixLength ),
          sizeof ( uint8_t ) },
        { &gateway6_setting, efi_path_fetch_fixed, MESSAGING_DEVICE_PATH,
          MSG_IPv6_DP, offsetof ( IPv6_DEVICE_PATH, GatewayIpAddress ),
          sizeof ( struct in6_addr ) },
        { &dns_setting, efi_path_fetch_dns, MESSAGING_DEVICE_PATH,
          MSG_DNS_DP, offsetof ( DNS_DEVICE_PATH, DnsServerIp ),
          sizeof ( struct in_addr ) },
        { &dns6_setting, efi_path_fetch_dns, MESSAGING_DEVICE_PATH,
          MSG_DNS_DP, offsetof ( DNS_DEVICE_PATH, DnsServerIp ),
          sizeof ( struct in6_addr ) },
}

EFI device path settings.

Definition at line 997 of file efi_path.c.

Referenced by efi_path_fetch().

efi_path_settings_operations

struct settings_operations efi_path_settings_operations

static

Initial value:

= {
        .fetch = efi_path_fetch,
}

EFI device path settings operations.

Definition at line 1078 of file efi_path.c.

Referenced by efi_path_net_probe().

__net_driver

struct net_driver efi_path_net_driver __net_driver

Initial value:

= {
        .name = "EFI path",
        .priv_len = sizeof ( struct efi_path_settings ),
        .probe = efi_path_net_probe,
}

EFI path settings per-netdevice driver.

Definition at line 1135 of file efi_path.c.