Executable images. More...

#include <stddef.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
#include <errno.h>
#include <assert.h>
#include <libgen.h>
#include <syslog.h>
#include <ipxe/list.h>
#include <ipxe/uaccess.h>
#include <ipxe/umalloc.h>
#include <ipxe/uri.h>
#include <ipxe/image.h>

Macros
#define	EACCES_UNTRUSTED __einfo_error ( EINFO_EACCES_UNTRUSTED )
#define	EINFO_EACCES_UNTRUSTED __einfo_uniqify ( EINFO_EACCES, 0x01, "Untrusted image" )
#define	EACCES_PERMANENT __einfo_error ( EINFO_EACCES_PERMANENT )
#define	EINFO_EACCES_PERMANENT __einfo_uniqify ( EINFO_EACCES, 0x02, "Trust requirement is permanent" )

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
	FILE_SECBOOT (PERMITTED)
void	free_image (struct refcnt *refcnt)
	Free executable image.
struct image *	alloc_image (struct uri *uri)
	Allocate executable image.
int	image_set_uri (struct image image, struct uri uri)
	Set image URI.
int	image_set_name (struct image image, const char name)
	Set image name.
char *	image_strip_suffix (struct image *image)
	Strip dot suffix from image name, if present.
int	image_set_cmdline (struct image image, const char cmdline)
	Set image command line.
int	image_set_len (struct image *image, size_t len)
	Set image length.
int	image_set_data (struct image image, const void data, size_t len)
	Set image data.
static int	image_probe (struct image *image)
	Determine image type.
int	register_image (struct image *image)
	Register executable image.
void	unregister_image (struct image *image)
	Unregister executable image.
struct image *	find_image (const char *name)
	Find image by name.
struct image *	find_image_tag (struct image_tag *tag)
	Find image by tag.
int	image_exec (struct image *image)
	Execute image.
int	image_replace (struct image *replacement)
	Set replacement image.
int	image_select (struct image *image)
	Select image for execution.
int	image_set_trust (int require_trusted, int permanent)
	Change image trust requirement.
struct image *	image_memory (const char name, const void data, size_t len)
	Create registered image from block of memory.
const char *	image_argument (struct image image, const char key)
	Find argument within image command line.

Variables
struct list_head	images = LIST_HEAD_INIT ( images )
	List of registered images.
struct image_tag selected_image	__image_tag
	Image selected for execution.
static int	require_trusted_images = 0
	Current image trust requirement.
static int	require_trusted_images_permanent = 0
	Prevent changes to image trust requirement.
const char	empty_image_data [] = { '\0' }
	Empty image terminating NUL.

Detailed Description

Executable images.

Definition in file image.c.

Macro Definition Documentation

◆ EACCES_UNTRUSTED

#define EACCES_UNTRUSTED __einfo_error ( EINFO_EACCES_UNTRUSTED )

Definition at line 49 of file image.c.

49#define EACCES_UNTRUSTED \

50 __einfo_error ( EINFO_EACCES_UNTRUSTED )

Referenced by image_exec(), and x509_validate().

◆ EINFO_EACCES_UNTRUSTED

#define EINFO_EACCES_UNTRUSTED __einfo_uniqify ( EINFO_EACCES, 0x01, "Untrusted image" )

Definition at line 51 of file image.c.

51#define EINFO_EACCES_UNTRUSTED \

52 __einfo_uniqify ( EINFO_EACCES, 0x01, "Untrusted image" )

◆ EACCES_PERMANENT

#define EACCES_PERMANENT __einfo_error ( EINFO_EACCES_PERMANENT )

Definition at line 53 of file image.c.

53#define EACCES_PERMANENT \

54 __einfo_error ( EINFO_EACCES_PERMANENT )

Referenced by image_set_trust().

◆ EINFO_EACCES_PERMANENT

#define EINFO_EACCES_PERMANENT __einfo_uniqify ( EINFO_EACCES, 0x02, "Trust requirement is permanent" )

Definition at line 55 of file image.c.

55#define EINFO_EACCES_PERMANENT \

56 __einfo_uniqify ( EINFO_EACCES, 0x02, "Trust requirement is permanent" )

Function Documentation

◆ FILE_LICENCE()

FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL )

◆ FILE_SECBOOT()

FILE_SECBOOT ( PERMITTED )

◆ free_image()

void free_image ( struct refcnt * refcnt )

Free executable image.

Parameters

refcnt Reference counter

Image consumers must call image_put() rather than calling free_image() directly. This function is exposed for use only by static images.

Definition at line 89 of file image.c.

                                          {
        struct image *image = container_of ( refcnt, struct image, refcnt );
        struct image_tag *tag;
 
        /* Sanity check: free_image() should not be called directly on
         * dynamically allocated images.
         */
        assert ( refcnt->count < 0 );
        DBGC ( image, "IMAGE %s freed\n", image->name );
 
        /* Clear any tag weak references */
        for_each_table_entry ( tag, IMAGE_TAGS ) {
                if ( tag->image == image )
                        tag->image = NULL;
        }
 
        /* Free dynamic allocations used by both static and dynamic images */
        free ( image->cmdline );
        uri_put ( image->uri );
        image_put ( image->replacement );
 
        /* Free image name, if dynamically allocated */
        if ( ! ( image->flags & IMAGE_STATIC_NAME ) )
                free ( image->name );
 
        /* Free image data and image itself, if dynamically allocated */
        if ( ! ( image->flags & IMAGE_STATIC ) ) {
                image_set_len ( image, 0 );
                free ( image );
        }
}

References assert, image::cmdline, container_of, refcnt::count, DBGC, image::flags, for_each_table_entry, free, image_put(), image_set_len(), IMAGE_STATIC, IMAGE_STATIC_NAME, IMAGE_TAGS, image::name, NULL, image::replacement, tag, image::uri, and uri_put().

Referenced by alloc_image(), cmdline_image_free(), efi_cmdline_free(), and lkrn_exec().

◆ alloc_image()

struct image * alloc_image ( struct uri * uri )

Allocate executable image.

Parameters

uri	URI, or NULL

Return values

image Executable image

Definition at line 127 of file image.c.

                                               {
        struct image *image;
        int rc;
 
        /* Allocate image */
        image = zalloc ( sizeof ( *image ) );
        if ( ! image )
                goto err_alloc;
 
        /* Initialise image */
        ref_init ( &image->refcnt, free_image );
        if ( uri && ( ( rc = image_set_uri ( image, uri ) ) != 0 ) )
                goto err_set_uri;
        image->data = empty_image_data;
 
        return image;
 
 err_set_uri:
        image_put ( image );
 err_alloc:
        return NULL;
}

References image::data, empty_image_data, free_image(), image_put(), image_set_uri(), NULL, rc, ref_init, image::refcnt, and zalloc().

Referenced by cpio_okx(), image_extract(), image_memory(), and imgdownload().

◆ image_set_uri()

int image_set_uri	(	struct image *	image,
		struct uri *	uri )

Set image URI.

Parameters

image	Image
uri	New image URI

Return values

rc	Return status code

Definition at line 157 of file image.c.

                                                           {
        const char *name;
        int rc;
 
        /* Set name, if image does not already have one */
        if ( ! ( image->name && image->name[0] ) ) {
                name = ( uri->path ? uri->path : uri->opaque );
                if ( name ) {
                        name = basename ( ( char * ) name );
                        if ( ( rc = image_set_name ( image, name ) ) != 0 )
                                return rc;
                }
        }
 
        /* Update image URI */
        uri_put ( image->uri );
        image->uri = uri_get ( uri );
 
        return 0;
}

References basename(), image_set_name(), image::name, name, uri::opaque, uri::path, rc, image::uri, uri_get(), and uri_put().

Referenced by alloc_image(), and downloader_vredirect().

◆ image_set_name()

int image_set_name	(	struct image *	image,
		const char *	name )

Set image name.

Parameters

image	Image
name	New image name

Return values

rc	Return status code

Definition at line 185 of file image.c.

                                                             {
        char *name_copy;
 
        /* Duplicate name */
        name_copy = strdup ( name );
        if ( ! name_copy )
                return -ENOMEM;
 
        /* Free existing name, if not statically allocated */
        if ( ! ( image->flags & IMAGE_STATIC_NAME ) )
                free ( image->name );
 
        /* Replace existing name */
        image->name = name_copy;
        image->flags &= ~IMAGE_STATIC_NAME;
 
        return 0;
}

References ENOMEM, image::flags, free, IMAGE_STATIC_NAME, image::name, name, and strdup().

Referenced by cms_decrypt(), cpio_okx(), image_extract(), image_memory(), image_set_uri(), imgsingle_exec(), and register_image().

◆ image_strip_suffix()

char * image_strip_suffix ( struct image * image )

Strip dot suffix from image name, if present.

Parameters

image Image

Return values

sep	Position of old dot separator, or NULL

Definition at line 210 of file image.c.

                                                  {
        char *dot;
 
        /* Locate and strip suffix, if present */
        if ( image->name &&
             ( ( dot = strrchr ( image->name, '.' ) ) != NULL ) ) {
                *dot = '\0';
                return dot;
        }
 
        return NULL;
}

References image::name, NULL, and strrchr().

Referenced by cms_decrypt(), and image_extract().

◆ image_set_cmdline()

int image_set_cmdline	(	struct image *	image,
		const char *	cmdline )

Set image command line.

Parameters

image	Image
cmdline	New image command line, or NULL

Return values

rc	Return status code

Definition at line 230 of file image.c.

                                                                   {
 
        free ( image->cmdline );
        image->cmdline = NULL;
        if ( cmdline ) {
                image->cmdline = strdup ( cmdline );
                if ( ! image->cmdline )
                        return -ENOMEM;
        }
        return 0;
}

References cmdline, image::cmdline, ENOMEM, free, NULL, and strdup().

Referenced by cpio_okx(), image_clear_cmdline(), image_extract_exec(), and imgsingle_exec().

◆ image_set_len()

int image_set_len	(	struct image *	image,
		size_t	len )

Set image length.

Parameters

image	Image
len	Length of image data

Return values

rc	Return status code

Definition at line 249 of file image.c.

                                                      {
        size_t alloc_len;
        void *data;
        void *new;
        char *nul;
 
        /* Refuse to reallocate static images */
        if ( image->flags & IMAGE_STATIC )
                return -ENOTTY;
 
        /* Calculate allocation length (including a terminating NUL) */
        alloc_len = ( len ? ( len + 1 ) : 0 );
        if ( alloc_len < len )
                return -ERANGE;
 
        /* (Re)allocate image data */
        data = image->rwdata;
        if ( data == empty_image_data )
                data = NULL;
        new = urealloc ( data, alloc_len );
        if ( ! new )
                return -ENOMEM;
        image->data = ( len ? new : empty_image_data );
        image->len = len;
 
        /* Add terminating NUL (if not the empty image) */
        if ( len ) {
                nul = ( image->rwdata + len );
                *nul = '\0';
        }
 
        return 0;
}

References data, image::data, empty_image_data, ENOMEM, ENOTTY, ERANGE, image::flags, IMAGE_STATIC, image::len, len, NULL, image::rwdata, and urealloc().

Referenced by cpio_okx(), free_image(), gzip_extract(), image_set_data(), mime_decode_base64(), mime_decode_identity(), mime_extract_part(), xferbuf_image_realloc(), and zlib_deflate().

◆ image_set_data()

int image_set_data	(	struct image *	image,
		const void *	data,
		size_t	len )

Set image data.

Parameters

image	Image
data	Image data
len	Length of image data

Return values

rc	Return status code

Definition at line 291 of file image.c.

                                                                         {
        int rc;
 
        /* Set image length */
        if ( ( rc = image_set_len ( image, len ) ) != 0 )
                return rc;
 
        /* Copy in new image data */
        memcpy ( image->rwdata, data, len );
 
        return 0;
}

References data, image_set_len(), len, memcpy(), rc, and image::rwdata.

Referenced by image_memory(), and zimg_extract().

◆ image_probe()

int image_probe ( struct image * image )

static

Determine image type.

Parameters

image Executable image

Return values

rc	Return status code

Definition at line 310 of file image.c.

                                               {
        struct image_type *type;
        int rc;
 
        /* Try each type in turn */
        for_each_table_entry ( type, IMAGE_TYPES ) {
                if ( ( rc = type->probe ( image ) ) == 0 ) {
                        image->type = type;
                        DBGC ( image, "IMAGE %s is %s\n",
                               image->name, type->name );
                        return 0;
                }
                DBGC ( image, "IMAGE %s is not %s: %s\n", image->name,
                       type->name, strerror ( rc ) );
        }
 
        DBGC ( image, "IMAGE %s format not recognised\n", image->name );
        return -ENOTSUP;
}

References DBGC, ENOTSUP, for_each_table_entry, IMAGE_TYPES, image::name, rc, strerror(), image::type, and type.

Referenced by register_image().

◆ register_image()

int register_image ( struct image * image )

Register executable image.

Parameters

image Executable image

Return values

rc	Return status code

Definition at line 336 of file image.c.

                                           {
        static unsigned int imgindex = 0;
        char name[8]; /* "imgXXXX" */
        int rc;
 
        /* Sanity checks */
        if ( image->flags & IMAGE_STATIC ) {
                assert ( ( image->name == NULL ) ||
                         ( image->flags & IMAGE_STATIC_NAME ) );
                assert ( image->cmdline == NULL );
        }
 
        /* Create image name if it doesn't already have one */
        if ( ! image->name ) {
                snprintf ( name, sizeof ( name ), "img%d", imgindex++ );
                if ( ( rc = image_set_name ( image, name ) ) != 0 )
                        return rc;
        }
 
        /* Check for terminating NUL (required for text-based images) */
        if ( ! image->data ) {
                DBGC ( image, "IMAGE %s has no data\n", image->name );
                return -EINVAL;
        }
        if ( image->text[image->len] != '\0' ) {
                DBGC ( image, "IMAGE %s missing terminating NUL\n",
                       image->name );
                return -EINVAL;
        }
 
        /* Add to image list */
        image_get ( image );
        image->flags |= IMAGE_REGISTERED;
        list_add_tail ( &image->list, &images );
        DBGC ( image, "IMAGE %s at [%lx,%lx) registered\n",
               image->name, virt_to_phys ( image->data ),
               ( virt_to_phys ( image->data ) + image->len ) );
 
        /* Try to detect image type, if applicable.  Ignore failures,
         * since we expect to handle some unrecognised images
         * (e.g. kernel initrds, multiboot modules, random files
         * provided via our EFI virtual filesystem, etc).
         */
        if ( ! image->type )
                image_probe ( image );
 
        return 0;
}

References assert, image::cmdline, image::data, DBGC, EINVAL, image::flags, image_get(), image_probe(), IMAGE_REGISTERED, image_set_name(), IMAGE_STATIC, IMAGE_STATIC_NAME, images, image::len, image::list, list_add_tail, image::name, name, NULL, rc, snprintf(), image::text, and image::type.

Referenced by asn1_okx(), cmdline_init(), cms_decrypt(), efi_cmdline_init(), efi_image_exec(), embedded_init(), image_exec(), image_extract(), image_memory(), imgdownload(), pixbuf_okx(), and test_init().

◆ unregister_image()

void unregister_image ( struct image * image )

Unregister executable image.

Parameters

image Executable image

Definition at line 390 of file image.c.

                                              {
 
        /* Do nothing unless image is registered */
        if ( ! ( image->flags & IMAGE_REGISTERED ) )
                return;
 
        DBGC ( image, "IMAGE %s unregistered\n", image->name );
        list_del ( &image->list );
        image->flags &= ~IMAGE_REGISTERED;
        image_put ( image );
}

References DBGC, image::flags, image_put(), IMAGE_REGISTERED, image::list, list_del, and image::name.

Referenced by archive_okx(), asn1_okx(), bzimage_exec(), cert_exec(), cms_decrypt(), com32_exec_loop(), comboot_exec_loop(), console_exec(), efi_autoexec_load(), efi_image_exec(), fdt_test_exec(), image_exec(), image_extract(), image_extract_exec(), imgdecrypt_exec(), imgextract_exec(), imgfree_exec(), imgset_exec(), imgverify_exec(), and pixbuf_okx().

◆ find_image()

struct image * find_image ( const char * name )

Find image by name.

Parameters

name	Image name

Return values

image Executable image, or NULL

Definition at line 408 of file image.c.

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

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

Referenced by imgacquire(), and imgmulti_exec().

◆ find_image_tag()

struct image * find_image_tag ( struct image_tag * tag )

Find image by tag.

Parameters

tag Image tag

Return values

image Executable image, or NULL

Definition at line 425 of file image.c.

                                                        {
        struct image *image;
 
        for_each_image ( image ) {
                if ( tag->image == image )
                        return image;
        }
 
        return NULL;
}

References for_each_image, NULL, and tag.

Referenced by efi_file_open(), efi_image_exec(), fdt_create(), imgsingle_exec(), and shim_exec().

◆ image_exec()

int image_exec ( struct image * image )

Execute image.

Parameters

image Executable image

Return values

rc	Return status code

The image must already be registered. Note that executing an image may cause it to unregister itself. The caller must therefore assume that the image pointer becomes invalid.

Definition at line 446 of file image.c.

                                       {
        struct image *saved_current_image;
        struct image *replacement = NULL;
        struct uri *old_cwuri;
        int rc;
 
        /* Sanity check */
        assert ( image->flags & IMAGE_REGISTERED );
 
        /* Switch current working directory to be that of the image
         * itself, if applicable
         */
        old_cwuri = uri_get ( cwuri );
        if ( image->uri )
                churi ( image->uri );
 
        /* Set as currently running image */
        saved_current_image = image_tag ( image, &current_image );
 
        /* Take out a temporary reference to the image, so that it
         * does not get freed when temporarily unregistered.
         */
        image_get ( image );
 
        /* Check that this image can be executed */
        if ( ! ( image->type && image->type->exec ) ) {
                rc = -ENOEXEC;
                goto err;
        }
 
        /* Check that image is trusted (if applicable) */
        if ( require_trusted_images && ! ( image->flags & IMAGE_TRUSTED ) ) {
                DBGC ( image, "IMAGE %s is not trusted\n", image->name );
                rc = -EACCES_UNTRUSTED;
                goto err;
        }
 
        /* Record boot attempt */
        syslog ( LOG_NOTICE, "Executing \"%s\"\n", image->name );
 
        /* Temporarily unregister the image during its execution */
        unregister_image ( image );
 
        /* Try executing the image */
        if ( ( rc = image->type->exec ( image ) ) != 0 ) {
                DBGC ( image, "IMAGE %s could not execute: %s\n",
                       image->name, strerror ( rc ) );
                /* Do not return yet; we still have clean-up to do */
        }
 
        /* Record result of boot attempt */
        if ( rc == 0 ) {
                syslog ( LOG_NOTICE, "Execution of \"%s\" completed\n",
                         image->name );
        } else {
                syslog ( LOG_ERR, "Execution of \"%s\" failed: %s\n",
                         image->name, strerror ( rc ) );
        }
 
        /* Re-register image (unless due to be replaced) */
        if ( ! image->replacement )
                register_image ( image );
 
        /* Pick up replacement image before we drop the original
         * image's temporary reference.  The replacement image must
         * already be registered, so we don't need to hold a temporary
         * reference (which would complicate the tail-recursion).
         */
        replacement = image->replacement;
        if ( replacement )
                assert ( replacement->flags & IMAGE_REGISTERED );
 
        /* Clear any recorded replacement image */
        image_put ( image->replacement );
        image->replacement = NULL;
 
 err:
        /* Unregister image if applicable */
        if ( image->flags & IMAGE_AUTO_UNREGISTER )
                unregister_image ( image );
 
        /* Debug message for tail-recursion.  Placed here because the
         * image_put() may end up freeing the image.
         */
        if ( replacement ) {
                DBGC ( image, "IMAGE %s replacing self with IMAGE %s\n",
                       image->name, replacement->name );
        }
 
        /* Drop temporary reference to the original image */
        image_put ( image );
 
        /* Restore previous currently-running image */
        image_tag ( saved_current_image, &current_image );
 
        /* Reset current working directory */
        churi ( old_cwuri );
        uri_put ( old_cwuri );
 
        /* Tail-recurse into replacement image, if one exists */
        if ( replacement )
                return image_exec ( replacement );
 
        return rc;
}

References assert, churi(), current_image, cwuri, DBGC, EACCES_UNTRUSTED, ENOEXEC, image_type::exec, image::flags, IMAGE_AUTO_UNREGISTER, image_exec(), image_get(), image_put(), IMAGE_REGISTERED, image_tag(), IMAGE_TRUSTED, LOG_ERR, LOG_NOTICE, image::name, NULL, rc, register_image(), image::replacement, replacement, require_trusted_images, strerror(), syslog, image::type, unregister_image(), image::uri, uri_get(), and uri_put().

Referenced by image_exec(), imgexec(), ipxe(), and uriboot().

◆ image_replace()

int image_replace ( struct image * replacement )

Set replacement image.

Parameters

replacement Replacement image

Return values

rc	Return status code

The replacement image must already be registered, and must remain registered until the currently-executing image returns.

Definition at line 561 of file image.c.

                                                {
        struct image *image = current_image.image;
        int rc;
 
        /* Sanity check */
        assert ( replacement->flags & IMAGE_REGISTERED );
 
        /* Fail unless there is a currently-executing image */
        if ( ! image ) {
                rc = -ENOTTY;
                DBGC ( replacement, "IMAGE %s cannot replace non-existent "
                       "image: %s\n", replacement->name, strerror ( rc ) );
                return rc;
        }
 
        /* Check that the replacement image can be executed */
        if ( ! ( replacement->type && replacement->type->exec ) )
                return -ENOEXEC;
 
        /* Clear any existing replacement */
        image_put ( image->replacement );
 
        /* Set replacement */
        image->replacement = image_get ( replacement );
        DBGC ( image, "IMAGE %s will replace self with IMAGE %s\n",
               image->name, replacement->name );
 
        return 0;
}

References assert, current_image, DBGC, ENOEXEC, ENOTTY, image_get(), image_put(), IMAGE_REGISTERED, image::name, rc, image::replacement, replacement, and strerror().

Referenced by comboot_fetch_kernel(), image_extract_exec(), and imgexec().

◆ image_select()

int image_select ( struct image * image )

Select image for execution.

Parameters

image Executable image

Return values

rc	Return status code

Definition at line 597 of file image.c.

                                         {
 
        /* Check that this image can be executed */
        if ( ! ( image->type && image->type->exec ) )
                return -ENOEXEC;
 
        /* Mark image as selected */
        image_tag ( image, &selected_image );
 
        return 0;
}

References ENOEXEC, image_type::exec, image_tag(), selected_image, and image::type.

Referenced by embedded_init(), and imgselect().

◆ image_set_trust()

int image_set_trust	(	int	require_trusted,
		int	permanent )

Change image trust requirement.

Parameters

require_trusted	Require trusted images
permanent	Make trust requirement permanent

Return values

rc	Return status code

Definition at line 616 of file image.c.

                                                           {
 
        /* Update trust requirement, if permitted to do so */
        if ( ! require_trusted_images_permanent ) {
                require_trusted_images = require_trusted;
                require_trusted_images_permanent = permanent;
        }
 
        /* Fail if we attempted to change the trust requirement but
         * were not permitted to do so.
         */
        if ( require_trusted_images != require_trusted )
                return -EACCES_PERMANENT;
 
        return 0;
}

References EACCES_PERMANENT, require_trusted_images, and require_trusted_images_permanent.

Referenced by imgtrust_exec().

◆ image_memory()

struct image * image_memory	(	const char *	name,
		const void *	data,
		size_t	len )

Create registered image from block of memory.

Parameters

name	Name
data	Image data
len	Length

Return values

image Image, or NULL on error

Definition at line 641 of file image.c.

                                           {
        struct image *image;
        int rc;
 
        /* Allocate image */
        image = alloc_image ( NULL );
        if ( ! image ) {
                rc = -ENOMEM;
                goto err_alloc_image;
        }
 
        /* Set name */
        if ( ( rc = image_set_name ( image, name ) ) != 0 )
                goto err_set_name;
 
        /* Set data */
        if ( ( rc = image_set_data ( image, data, len ) ) != 0 )
                goto err_set_data;
 
        /* Register image */
        if ( ( rc = register_image ( image ) ) != 0 )
                goto err_register;
 
        /* Drop local reference to image */
        image_put ( image );
 
        return image;
 
 err_register:
 err_set_data:
 err_set_name:
        image_put ( image );
 err_alloc_image:
        return NULL;
}

References alloc_image(), data, ENOMEM, image_put(), image_set_data(), image_set_name(), len, name, NULL, rc, and register_image().

Referenced by archive_okx(), fdt_test_exec(), imgmem(), and initrd_init().

◆ image_argument()

const char * image_argument	(	struct image *	image,
		const char *	key )

Find argument within image command line.

Parameters

image	Image
key	Argument search key (including trailing delimiter)

Return values

value Argument value, or NULL if not found

Definition at line 685 of file image.c.

                                                                     {
        const char *cmdline = image->cmdline;
        const char *search;
        const char *match;
        const char *next;
 
        /* Find argument */
        for ( search = cmdline ; search ; search = next ) {
 
                /* Find next occurrence, if any */
                match = strstr ( search, key );
                if ( ! match )
                        break;
                next = ( match + strlen ( key ) );
 
                /* Check preceding delimiter, if any */
                if ( ( match == cmdline ) || isspace ( match[-1] ) )
                        return next;
        }
 
        return NULL;
}

References cmdline, image::cmdline, isspace(), key, next, NULL, strlen(), and strstr().

Referenced by bzimage_parse_cmdline(), and cpio_parse_cmdline().

Variable Documentation

◆ images

struct list_head images = LIST_HEAD_INIT ( images )

List of registered images.

Definition at line 59 of file image.c.

Referenced by first_image(), initrd_dump(), initrd_load(), initrd_region(), initrd_squash_high(), initrd_startup(), initrd_swap(), lkrn_exec(), and register_image().

◆ __image_tag

struct image_tag current_image __image_tag

Initial value:

               = {
        .name = "SELECTED",
}

Image selected for execution.

The downloaded flattened device tree tag.

Currently-executing image.

Definition at line 62 of file image.c.

                                            {
        .name = "SELECTED",
};

◆ require_trusted_images

int require_trusted_images = 0

static

Current image trust requirement.

Definition at line 72 of file image.c.

Referenced by image_exec(), and image_set_trust().

◆ require_trusted_images_permanent

int require_trusted_images_permanent = 0

static

Prevent changes to image trust requirement.

Definition at line 75 of file image.c.

Referenced by image_set_trust().

◆ empty_image_data

const char empty_image_data[] = { '\0' }

Empty image terminating NUL.

Definition at line 78 of file image.c.

78{ '\0' };

Referenced by alloc_image(), and image_set_len().

Macros

Functions

Variables

Detailed Description

Macro Definition Documentation

◆ EACCES_UNTRUSTED

◆ EINFO_EACCES_UNTRUSTED

◆ EACCES_PERMANENT

◆ EINFO_EACCES_PERMANENT

Function Documentation

◆ FILE_LICENCE()

◆ FILE_SECBOOT()

◆ free_image()

◆ alloc_image()

◆ image_set_uri()

◆ image_set_name()

◆ image_strip_suffix()

◆ image_set_cmdline()

◆ image_set_len()

◆ image_set_data()

◆ image_probe()

◆ register_image()

◆ unregister_image()

◆ find_image()

◆ find_image_tag()

◆ image_exec()

◆ image_replace()

◆ image_select()

◆ image_set_trust()

◆ image_memory()

◆ image_argument()

Variable Documentation

◆ images

◆ __image_tag

◆ require_trusted_images

◆ require_trusted_images_permanent

◆ empty_image_data