autoboot.c File Reference

Automatic booting. More...

#include <string.h>
#include <stdio.h>
#include <errno.h>
#include <ipxe/netdevice.h>
#include <ipxe/vlan.h>
#include <ipxe/dhcp.h>
#include <ipxe/settings.h>
#include <ipxe/image.h>
#include <ipxe/sanboot.h>
#include <ipxe/uri.h>
#include <ipxe/open.h>
#include <ipxe/init.h>
#include <ipxe/keys.h>
#include <ipxe/version.h>
#include <ipxe/shell.h>
#include <ipxe/features.h>
#include <ipxe/timer.h>
#include <usr/ifmgmt.h>
#include <usr/route.h>
#include <usr/imgmgmt.h>
#include <usr/prompt.h>
#include <usr/autoboot.h>
#include <config/general.h>
#include <config/branding.h>

Go to the source code of this file.

Macros
#define	ENOENT_BOOT   __einfo_error ( EINFO_ENOENT_BOOT )
#define	EINFO_ENOENT_BOOT   __einfo_uniqify ( EINFO_ENOENT, 0x01, "Nothing to boot" )
#define	NORMAL   "\033[0m"
#define	BOLD   "\033[1m"
#define	CYAN   "\033[36m"

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
const struct setting scriptlet_setting	__setting (SETTING_MISC, scriptlet)
	The "scriptlet" setting. More...
__weak int	pxe_menu_boot (struct net_device *netdev __unused)
	Perform PXE menu boot when PXE stack is not available. More...
const struct setting keep_san_setting	__setting (SETTING_SANBOOT_EXTRA, keep-san)
	The "keep-san" setting. More...
const struct setting skip_san_boot_setting	__setting (SETTING_SANBOOT_EXTRA, skip-san-boot)
	The "skip-san-boot" setting. More...
int	uriboot (struct uri *filename, struct uri **root_paths, unsigned int root_path_count, int drive, struct san_boot_config *san_config, unsigned int flags)
	Boot from filename and root-path URIs. More...
static void	close_other_netdevs (struct net_device *netdev)
	Close all but one network device. More...
struct uri *	fetch_next_server_and_filename (struct settings *settings)
	Fetch next-server and filename settings into a URI. More...
static struct uri *	fetch_root_path (struct settings *settings)
	Fetch root-path setting into a URI. More...
static char *	fetch_san_filename (struct settings *settings)
	Fetch san-filename setting. More...
static int	have_pxe_menu (void)
	Check whether or not we have a usable PXE menu. More...
int	netboot (struct net_device *netdev)
	Boot from a network device. More...
static int	is_autoboot_busloc (struct net_device *netdev)
	Test if network device matches the autoboot device bus type and location. More...
void	set_autoboot_busloc (unsigned int bus_type, unsigned int location)
	Identify autoboot device by bus type and location. More...
static int	is_autoboot_ll_addr (struct net_device *netdev)
	Test if network device matches the autoboot device link-layer address. More...
void	set_autoboot_ll_addr (const void *ll_addr, size_t len, unsigned int vlan)
	Identify autoboot device by link-layer address. More...
static int	autoboot (void)
	Boot the system. More...
static int	shell_banner (void)
	Prompt for shell entry. More...
int	ipxe (struct net_device *netdev)
	Main iPXE flow of execution. More...

Variables
static uint8_t	autoboot_ll_addr [MAX_LL_ADDR_LEN]
	Link-layer address of preferred autoboot device, if known. More...
static unsigned int	autoboot_vlan
	VLAN tag of preferred autoboot device, if known. More...
static struct device_description	autoboot_desc
	Device location of preferred autoboot device, if known. More...
static int(*	is_autoboot_device )(struct net_device *netdev)
	Autoboot device tester. More...

Detailed Description

Automatic booting.

Definition in file autoboot.c.

Macro Definition Documentation

ENOENT_BOOT

#define ENOENT_BOOT   __einfo_error ( EINFO_ENOENT_BOOT )

Definition at line 71 of file autoboot.c.

EINFO_ENOENT_BOOT

#define EINFO_ENOENT_BOOT   __einfo_uniqify ( EINFO_ENOENT, 0x01, "Nothing to boot" )

Definition at line 72 of file autoboot.c.

NORMAL

#define NORMAL   "\033[0m"

Definition at line 75 of file autoboot.c.

BOLD

#define BOLD   "\033[1m"

Definition at line 76 of file autoboot.c.

CYAN

#define CYAN   "\033[36m"

Definition at line 77 of file autoboot.c.

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

__setting() [1/3]

const struct setting scriptlet_setting __setting	(	SETTING_MISC	,
		scriptlet
	)

The "scriptlet" setting.

pxe_menu_boot()

__weak int pxe_menu_boot

(

struct net_device *netdev

__unused

)

Perform PXE menu boot when PXE stack is not available.

Definition at line 90 of file autoboot.c.

                                                                {
        return -ENOTSUP;
}

References ENOTSUP.

Referenced by netboot().

__setting() [2/3]

const struct setting keep_san_setting __setting	(	SETTING_SANBOOT_EXTRA	,
		keep-	san
	)

The "keep-san" setting.

__setting() [3/3]

const struct setting skip_san_boot_setting __setting	(	SETTING_SANBOOT_EXTRA	,
		skip-san-	boot
	)

The "skip-san-boot" setting.

uriboot()

int uriboot	(	struct uri *	filename,
		struct uri **	root_paths,
		unsigned int	root_path_count,
		int	drive,
		struct san_boot_config *	san_config,
		unsigned int	flags
	)

Boot from filename and root-path URIs.

Parameters

filename	Filename
root_paths	Root path(s)
root_path_count	Number of root paths
drive	SAN drive (if applicable)
san_config	SAN boot configuration parameters
flags	Boot action flags

Return values

rc	Return status code

The somewhat tortuous flow of control in this function exists in order to ensure that the "sanboot" command remains identical in function to a SAN boot via a DHCP-specified root path, and to provide backwards compatibility for the "keep-san" and "skip-san-boot" options.

Definition at line 129 of file autoboot.c.

                                                                       {
        struct image *image;
        const char *san_filename;
        int rc;

        /* Hook SAN device, if applicable */
        if ( root_path_count ) {
                drive = san_hook ( drive, root_paths, root_path_count,
                                   ( ( flags & URIBOOT_NO_SAN_DESCRIBE ) ?
                                     SAN_NO_DESCRIBE : 0 ) );
                if ( drive < 0 ) {
                        rc = drive;
                        printf ( "Could not open SAN device: %s\n",
                                 strerror ( rc ) );
                        goto err_san_hook;
                }
                printf ( "Registered SAN device %#02x\n", drive );
        }

        /* Describe SAN device, if applicable */
        if ( ! ( flags & URIBOOT_NO_SAN_DESCRIBE ) ) {
                if ( ( rc = san_describe() ) != 0 ) {
                        printf ( "Could not describe SAN devices: %s\n",
                                 strerror ( rc ) );
                        goto err_san_describe;
                }
        }

        /* Allow a root-path-only boot with skip-san enabled to succeed */
        rc = 0;

        /* Attempt filename boot if applicable */
        if ( filename ) {
                if ( ( rc = imgdownload ( filename, 0, &image ) ) != 0 )
                        goto err_download;
                imgstat ( image );
                image->flags |= IMAGE_AUTO_UNREGISTER;
                if ( ( rc = image_exec ( image ) ) != 0 ) {
                        printf ( "Could not boot image: %s\n",
                                 strerror ( rc ) );
                        /* Fall through to (possibly) attempt a SAN boot
                         * as a fallback.  If no SAN boot is attempted,
                         * our status will become the return status.
                         */
                } else {
                        /* Always print an extra newline, because we
                         * don't know where the NBP may have left the
                         * cursor.
                         */
                        printf ( "\n" );
                }
        }

        /* Attempt SAN boot if applicable */
        if ( ! ( flags & URIBOOT_NO_SAN_BOOT ) ) {
                san_filename = san_config->filename;
                if ( fetch_intz_setting ( NULL, &skip_san_boot_setting) == 0 ) {
                        printf ( "Booting%s%s from SAN device %#02x\n",
                                 ( san_filename ? " " : "" ),
                                 ( san_filename ? san_filename : "" ), drive );
                        rc = san_boot ( drive, san_config );
                        printf ( "Boot from SAN device %#02x failed: %s\n",
                                 drive, strerror ( rc ) );
                } else {
                        printf ( "Skipping boot from SAN device %#02x\n",
                                 drive );
                        /* Avoid overwriting a possible failure status
                         * from a filename boot.
                         */
                }
        }

 err_download:
 err_san_describe:
        /* Unhook SAN device, if applicable */
        if ( ! ( flags & URIBOOT_NO_SAN_UNHOOK ) ) {
                if ( fetch_intz_setting ( NULL, &keep_san_setting ) == 0 ) {
                        san_unhook ( drive );
                        printf ( "Unregistered SAN device %#02x\n", drive );
                } else {
                        printf ( "Preserving SAN device %#02x\n", drive );
                }
        }
 err_san_hook:
        return rc;
}

References drive, fetch_intz_setting(), san_boot_config::filename, flags, image::flags, IMAGE_AUTO_UNREGISTER, image_exec(), imgdownload(), imgstat(), NULL, printf(), rc, san_boot(), san_describe(), san_hook(), SAN_NO_DESCRIBE, san_unhook(), strerror(), URIBOOT_NO_SAN_BOOT, URIBOOT_NO_SAN_DESCRIBE, and URIBOOT_NO_SAN_UNHOOK.

Referenced by netboot(), pxe_menu_boot(), and sanboot_core_exec().

close_other_netdevs()

static void close_other_netdevs ( struct net_device *  netdev )

static

Close all but one network device.

Called before a fresh boot attempt in order to free up memory. We don't just close the device immediately after the boot fails, because there may still be TCP connections in the process of closing.

Definition at line 226 of file autoboot.c.

                                                              {
        struct net_device *other;

        for_each_netdev ( other ) {
                if ( other != netdev )
                        ifclose ( other );
        }
}

References for_each_netdev, ifclose(), and netdev.

Referenced by netboot().

fetch_next_server_and_filename()

struct uri* fetch_next_server_and_filename

(

struct settings *

settings

)

Fetch next-server and filename settings into a URI.

Parameters

settings

Settings block

Return values

uri	URI, or NULL on failure

Definition at line 241 of file autoboot.c.

                                                                          {
        union {
                struct sockaddr sa;
                struct sockaddr_in sin;
        } next_server;
        char *raw_filename = NULL;
        struct uri *uri = NULL;
        char *filename;

        /* Initialise server address */
        memset ( &next_server, 0, sizeof ( next_server ) );

        /* If we have a filename, fetch it along with the next-server
         * setting from the same settings block.
         */
        if ( fetch_setting ( settings, &filename_setting, &settings,
                             NULL, NULL, 0 ) >= 0 ) {
                fetch_string_setting_copy ( settings, &filename_setting,
                                            &raw_filename );
                fetch_ipv4_setting ( settings, &next_server_setting,
                                     &next_server.sin.sin_addr );
        }
        if ( ! raw_filename )
                goto err_fetch;

        /* Populate server address */
        if ( next_server.sin.sin_addr.s_addr ) {
                next_server.sin.sin_family = AF_INET;
                printf ( "Next server: %s\n",
                         inet_ntoa ( next_server.sin.sin_addr ) );
        }

        /* Expand filename setting */
        filename = expand_settings ( raw_filename );
        if ( ! filename )
                goto err_expand;
        if ( filename[0] )
                printf ( "Filename: %s\n", filename );

        /* Construct URI */
        uri = pxe_uri ( &next_server.sa, filename );
        if ( ! uri )
                goto err_parse;

 err_parse:
        free ( filename );
 err_expand:
        free ( raw_filename );
 err_fetch:
        return uri;
}

References AF_INET, expand_settings(), fetch_ipv4_setting(), fetch_setting(), fetch_string_setting_copy(), free, inet_ntoa(), memset(), NULL, printf(), pxe_uri(), sa, and sin.

Referenced by netboot(), and pxe_menu_boot().

fetch_root_path()

static struct uri* fetch_root_path ( struct settings *  settings )

static

Fetch root-path setting into a URI.

Parameters

settings

Settings block

Return values

uri	URI, or NULL on failure

Definition at line 299 of file autoboot.c.

                                                                  {
        struct uri *uri = NULL;
        char *raw_root_path;
        char *root_path;

        /* Fetch root-path setting */
        fetch_string_setting_copy ( settings, &root_path_setting,
                                    &raw_root_path );
        if ( ! raw_root_path )
                goto err_fetch;

        /* Expand filename setting */
        root_path = expand_settings ( raw_root_path );
        if ( ! root_path )
                goto err_expand;
        if ( root_path[0] )
                printf ( "Root path: %s\n", root_path );

        /* Parse root path */
        uri = parse_uri ( root_path );
        if ( ! uri )
                goto err_parse;

 err_parse:
        free ( root_path );
 err_expand:
        free ( raw_root_path );
 err_fetch:
        return uri;
}

References expand_settings(), fetch_string_setting_copy(), free, NULL, parse_uri(), and printf().

Referenced by netboot().

fetch_san_filename()

static char* fetch_san_filename ( struct settings *  settings )

static

Fetch san-filename setting.

Parameters

settings

Settings block

Return values

san_filename

SAN filename, or NULL on failure

Definition at line 336 of file autoboot.c.

                                                               {
        char *raw_san_filename;
        char *san_filename = NULL;

        /* Fetch san-filename setting */
        fetch_string_setting_copy ( settings, &san_filename_setting,
                                    &raw_san_filename );
        if ( ! raw_san_filename )
                goto err_fetch;

        /* Expand san-filename setting */
        san_filename = expand_settings ( raw_san_filename );
        if ( ! san_filename )
                goto err_expand;
        if ( san_filename[0] )
                printf ( "SAN filename: %s\n", san_filename );

 err_expand:
        free ( raw_san_filename );
 err_fetch:
        return san_filename;
}

References expand_settings(), fetch_string_setting_copy(), free, NULL, and printf().

Referenced by netboot().

have_pxe_menu()

static int have_pxe_menu ( void  )

static

Check whether or not we have a usable PXE menu.

Return values

have_menu

A usable PXE menu is present

Definition at line 364 of file autoboot.c.

                                  {
        struct setting vendor_class_id_setting
                = { .tag = DHCP_VENDOR_CLASS_ID };
        struct setting pxe_discovery_control_setting
                = { .tag = DHCP_PXE_DISCOVERY_CONTROL };
        struct setting pxe_boot_menu_setting
                = { .tag = DHCP_PXE_BOOT_MENU };
        char buf[ 10 /* "PXEClient" + NUL */ ];
        unsigned int pxe_discovery_control;

        fetch_string_setting ( NULL, &vendor_class_id_setting,
                               buf, sizeof ( buf ) );
        pxe_discovery_control =
                fetch_uintz_setting ( NULL, &pxe_discovery_control_setting );

        return ( ( strcmp ( buf, "PXEClient" ) == 0 ) &&
                 setting_exists ( NULL, &pxe_boot_menu_setting ) &&
                 ( ! ( ( pxe_discovery_control & PXEBS_SKIP ) &&
                       setting_exists ( NULL, &filename_setting ) ) ) );
}

References DHCP_PXE_BOOT_MENU, DHCP_PXE_DISCOVERY_CONTROL, DHCP_VENDOR_CLASS_ID, fetch_string_setting(), fetch_uintz_setting(), NULL, PXEBS_SKIP, setting_exists(), strcmp(), and setting::tag.

Referenced by netboot().

netboot()

int netboot

(

struct net_device *

netdev

)

Boot from a network device.

Parameters

netdev

Network device

Return values

rc	Return status code

Definition at line 391 of file autoboot.c.

                                          {
        struct san_boot_config san_config;
        struct uri *filename;
        struct uri *root_path;
        char *san_filename;
        int rc;

        /* Close all other network devices */
        close_other_netdevs ( netdev );

        /* Open device and display device status */
        if ( ( rc = ifopen ( netdev ) ) != 0 )
                goto err_ifopen;
        ifstat ( netdev );

        /* Configure device */
        if ( ( rc = ifconf ( netdev, NULL, 0 ) ) != 0 )
                goto err_dhcp;
        route();

        /* Try PXE menu boot, if applicable */
        if ( have_pxe_menu() ) {
                printf ( "Booting from PXE menu\n" );
                rc = pxe_menu_boot ( netdev );
                goto err_pxe_menu_boot;
        }

        /* Fetch next server and filename (if any) */
        filename = fetch_next_server_and_filename ( NULL );

        /* Fetch root path (if any) */
        root_path = fetch_root_path ( NULL );

        /* Fetch SAN filename (if any) */
        san_filename = fetch_san_filename ( NULL );

        /* Construct SAN boot configuration parameters */
        memset ( &san_config, 0, sizeof ( san_config ) );
        san_config.filename = san_filename;

        /* If we have both a filename and a root path, ignore an
         * unsupported or missing URI scheme in the root path, since
         * it may represent an NFS root.
         */
        if ( filename && root_path &&
             ( ( ! uri_is_absolute ( root_path ) ) ||
               ( xfer_uri_opener ( root_path->scheme ) == NULL ) ) ) {
                printf ( "Ignoring unsupported root path\n" );
                uri_put ( root_path );
                root_path = NULL;
        }

        /* Check that we have something to boot */
        if ( ! ( filename || root_path ) ) {
                rc = -ENOENT_BOOT;
                printf ( "Nothing to boot: %s\n", strerror ( rc ) );
                goto err_no_boot;
        }

        /* Boot using next server, filename and root path */
        if ( ( rc = uriboot ( filename, &root_path, ( root_path ? 1 : 0 ),
                              san_default_drive(), &san_config,
                              ( root_path ? 0 : URIBOOT_NO_SAN ) ) ) != 0 )
                goto err_uriboot;

 err_uriboot:
 err_no_boot:
        free ( san_filename );
        uri_put ( root_path );
        uri_put ( filename );
 err_pxe_menu_boot:
 err_dhcp:
 err_ifopen:
        return rc;
}

References close_other_netdevs(), ENOENT_BOOT, fetch_next_server_and_filename(), fetch_root_path(), fetch_san_filename(), san_boot_config::filename, free, have_pxe_menu(), ifconf(), ifopen(), ifstat(), memset(), netdev, NULL, printf(), pxe_menu_boot(), rc, route(), san_default_drive(), uri::scheme, strerror(), uri_is_absolute(), uri_put(), uriboot(), URIBOOT_NO_SAN, and xfer_uri_opener().

Referenced by autoboot(), autoboot_payload(), and ipxe().

is_autoboot_busloc()

static int is_autoboot_busloc ( struct net_device *  netdev )

static

Test if network device matches the autoboot device bus type and location.

Parameters

netdev

Network device

Return values

is_autoboot

Network device matches the autoboot device

Definition at line 473 of file autoboot.c.

                                                            {
        struct device *dev;

        for ( dev = netdev->dev ; dev ; dev = dev->parent ) {
                if ( ( dev->desc.bus_type == autoboot_desc.bus_type ) &&
                     ( dev->desc.location == autoboot_desc.location ) )
                        return 1;
        }
        return 0;
}

References autoboot_desc, device_description::bus_type, device::desc, net_device::dev, device_description::location, netdev, and device::parent.

Referenced by set_autoboot_busloc().

set_autoboot_busloc()

void set_autoboot_busloc	(	unsigned int	bus_type,
		unsigned int	location
	)

Identify autoboot device by bus type and location.

Parameters

bus_type	Bus type
location	Location

Definition at line 490 of file autoboot.c.

                                                                          {

        /* Record autoboot device description */
        autoboot_desc.bus_type = bus_type;
        autoboot_desc.location = location;

        /* Mark autoboot device as present */
        is_autoboot_device = is_autoboot_busloc;
}

References autoboot_desc, device_description::bus_type, is_autoboot_busloc(), is_autoboot_device, and device_description::location.

Referenced by pci_autoboot_init().

is_autoboot_ll_addr()

static int is_autoboot_ll_addr ( struct net_device *  netdev )

static

Test if network device matches the autoboot device link-layer address.

Parameters

netdev

Network device

Return values

is_autoboot

Network device matches the autoboot device

Definition at line 506 of file autoboot.c.

                                                             {

        return ( ( memcmp ( netdev->ll_addr, autoboot_ll_addr,
                            netdev->ll_protocol->ll_addr_len ) == 0 ) &&
                 ( vlan_tag ( netdev ) == autoboot_vlan ) );
}

References autoboot_ll_addr, autoboot_vlan, net_device::ll_addr, ll_protocol::ll_addr_len, net_device::ll_protocol, memcmp(), netdev, and vlan_tag().

Referenced by set_autoboot_ll_addr().

set_autoboot_ll_addr()

void set_autoboot_ll_addr	(	const void *	ll_addr,
		size_t	len,
		unsigned int	vlan
	)

Identify autoboot device by link-layer address.

Parameters

ll_addr	Link-layer address
len	Length of link-layer address
vlan	VLAN tag

Definition at line 520 of file autoboot.c.

                                                {

        /* Record autoboot link-layer address (truncated if necessary) */
        if ( len > sizeof ( autoboot_ll_addr ) )
                len = sizeof ( autoboot_ll_addr );
        memcpy ( autoboot_ll_addr, ll_addr, len );

        /* Record autoboot VLAN tag */
        autoboot_vlan = vlan;

        /* Mark autoboot device as present */
        is_autoboot_device = is_autoboot_ll_addr;
}

References autoboot_ll_addr, autoboot_vlan, is_autoboot_device, is_autoboot_ll_addr(), len, and memcpy().

Referenced by efi_set_autoboot_ll_addr().

autoboot()

static int autoboot ( void  )

static

Boot the system.

Definition at line 538 of file autoboot.c.

                             {
        struct net_device *netdev;
        int rc = -ENODEV;

        /* Try booting from each network device.  If we have a
         * specified autoboot device location, then use only devices
         * matching that location.
         */
        for_each_netdev ( netdev ) {

                /* Skip any non-matching devices, if applicable */
                if ( is_autoboot_device && ( ! is_autoboot_device ( netdev ) ) )
                        continue;

                /* Attempt booting from this device */
                rc = netboot ( netdev );
        }

        printf ( "No more network devices\n" );
        return rc;
}

References ENODEV, for_each_netdev, is_autoboot_device, netboot(), netdev, printf(), and rc.

Referenced by ipxe().

shell_banner()

static int shell_banner ( void  )

static

Prompt for shell entry.

Return values

enter_shell

User wants to enter shell

Definition at line 565 of file autoboot.c.

                                 {

        /* Skip prompt if timeout is zero */
        if ( BANNER_TIMEOUT <= 0 )
                return 0;

        /* Prompt user */
        printf ( "\n" );
        return ( prompt ( "Press Ctrl-B for the " PRODUCT_SHORT_NAME
                          " command line...",
                          ( ( BANNER_TIMEOUT * TICKS_PER_SEC ) / 10 ),
                          CTRL_B ) == 0 );
}

References BANNER_TIMEOUT, CTRL_B, printf(), PRODUCT_SHORT_NAME, prompt(), and TICKS_PER_SEC.

Referenced by ipxe().

ipxe()

int ipxe

(

struct net_device *

netdev

)

Main iPXE flow of execution.

Parameters

netdev

Network device, or NULL

Return values

rc	Return status code

Definition at line 585 of file autoboot.c.

                                       {
        struct feature *feature;
        struct image *image;
        char *scriptlet;
        int rc;

        /*
         * Print welcome banner
         *
         *
         * If you wish to brand this build of iPXE, please do so by
         * defining the string PRODUCT_NAME in config/branding.h.
         *
         * While nothing in the GPL prevents you from removing all
         * references to iPXE or https://ipxe.org, we prefer you not
         * to do so.
         *
         */
        printf ( NORMAL "\n\n" PRODUCT_NAME "\n" BOLD PRODUCT_SHORT_NAME " %s"
                 NORMAL " -- " PRODUCT_TAG_LINE " -- "
                 CYAN PRODUCT_URI NORMAL "\nFeatures:", product_version );
        for_each_table_entry ( feature, FEATURES )
                printf ( " %s", feature->name );
        printf ( "\n" );

        /* Boot system */
        if ( ( image = first_image() ) != NULL ) {
                /* We have an embedded image; execute it */
                return image_exec ( image );
        } else if ( shell_banner() ) {
                /* User wants shell; just give them a shell */
                return shell();
        } else {
                fetch_string_setting_copy ( NULL, &scriptlet_setting,
                                            &scriptlet );
                if ( scriptlet ) {
                        /* User has defined a scriptlet; execute it */
                        rc = system ( scriptlet );
                        free ( scriptlet );
                        return rc;
                } else {
                        /* Try booting.  If booting fails, offer the
                         * user another chance to enter the shell.
                         */
                        if ( netdev ) {
                                rc = netboot ( netdev );
                        } else {
                                rc = autoboot();
                        }
                        if ( shell_banner() )
                                rc = shell();
                        return rc;
                }
        }
}

References autoboot(), BOLD, CYAN, feature, FEATURES, fetch_string_setting_copy(), first_image(), for_each_table_entry, free, image_exec(), feature::name, netboot(), netdev, NORMAL, NULL, printf(), PRODUCT_NAME, PRODUCT_SHORT_NAME, PRODUCT_TAG_LINE, PRODUCT_URI, product_version, rc, shell(), shell_banner(), and system.

Referenced by efi_snp_load_file(), and main().

Variable Documentation

autoboot_ll_addr

uint8_t autoboot_ll_addr[MAX_LL_ADDR_LEN]

static

Link-layer address of preferred autoboot device, if known.

Definition at line 59 of file autoboot.c.

Referenced by is_autoboot_ll_addr(), and set_autoboot_ll_addr().

autoboot_vlan

unsigned int autoboot_vlan

static

VLAN tag of preferred autoboot device, if known.

Definition at line 62 of file autoboot.c.

Referenced by is_autoboot_ll_addr(), and set_autoboot_ll_addr().

autoboot_desc

struct device_description autoboot_desc

static

Device location of preferred autoboot device, if known.

Definition at line 65 of file autoboot.c.

Referenced by is_autoboot_busloc(), and set_autoboot_busloc().

is_autoboot_device

int( * is_autoboot_device) (struct net_device *netdev)

static

Autoboot device tester.

Definition at line 68 of file autoboot.c.

Referenced by autoboot(), set_autoboot_busloc(), and set_autoboot_ll_addr().