iPXE
Macros | Functions | Variables
image.c File Reference

Executable images. More...

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

Go to the source code of this file.

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)
 
static void free_image (struct refcnt *refcnt)
 Free executable image. More...
 
struct imagealloc_image (struct uri *uri)
 Allocate executable image. More...
 
int image_set_uri (struct image *image, struct uri *uri)
 Set image URI. More...
 
int image_set_name (struct image *image, const char *name)
 Set image name. More...
 
int image_set_cmdline (struct image *image, const char *cmdline)
 Set image command line. More...
 
static int image_probe (struct image *image)
 Determine image type. More...
 
int register_image (struct image *image)
 Register executable image. More...
 
void unregister_image (struct image *image)
 Unregister executable image. More...
 
struct imagefind_image (const char *name)
 Find image by name. More...
 
int image_exec (struct image *image)
 Execute image. More...
 
int image_replace (struct image *replacement)
 Set replacement image. More...
 
int image_select (struct image *image)
 Select image for execution. More...
 
struct imageimage_find_selected (void)
 Find selected image. More...
 
int image_set_trust (int require_trusted, int permanent)
 Change image trust requirement. More...
 

Variables

struct list_head images = LIST_HEAD_INIT ( images )
 List of registered images. More...
 
struct imagecurrent_image
 Currently-executing image. More...
 
static int require_trusted_images = 0
 Current image trust requirement. More...
 
static int require_trusted_images_permanent = 0
 Prevent changes to image trust requirement. More...
 

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 46 of file image.c.

◆ EINFO_EACCES_UNTRUSTED

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

Definition at line 48 of file image.c.

◆ EACCES_PERMANENT

#define EACCES_PERMANENT   __einfo_error ( EINFO_EACCES_PERMANENT )

Definition at line 50 of file image.c.

◆ EINFO_EACCES_PERMANENT

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

Definition at line 52 of file image.c.

Function Documentation

◆ FILE_LICENCE()

FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL  )

◆ free_image()

static void free_image ( struct refcnt refcnt)
static

Free executable image.

Parameters
refcntReference counter

Definition at line 72 of file image.c.

72  {
73  struct image *image = container_of ( refcnt, struct image, refcnt );
74 
75  DBGC ( image, "IMAGE %s freed\n", image->name );
76  free ( image->name );
77  free ( image->cmdline );
78  uri_put ( image->uri );
79  ufree ( image->data );
81  free ( image );
82 }
userptr_t data
Raw file image.
Definition: image.h:41
static void uri_put(struct uri *uri)
Decrement URI reference count.
Definition: uri.h:188
#define DBGC(...)
Definition: compiler.h:505
An executable image.
Definition: image.h:24
char * cmdline
Command line to pass to image.
Definition: image.h:39
A reference counter.
Definition: refcnt.h:26
#define container_of(ptr, type, field)
Get containing structure.
Definition: stddef.h:35
static void(* free)(struct refcnt *refcnt))
Definition: refcnt.h:54
struct uri * uri
URI of image.
Definition: image.h:32
static void image_put(struct image *image)
Decrement reference count on an image.
Definition: image.h:206
static __always_inline void ufree(userptr_t userptr)
Free external memory.
Definition: umalloc.h:65
struct image * replacement
Replacement image.
Definition: image.h:60
char * name
Name.
Definition: image.h:34

References image::cmdline, container_of, image::data, DBGC, free, image_put(), image::name, image::replacement, ufree(), image::uri, and uri_put().

Referenced by alloc_image().

◆ alloc_image()

struct image* alloc_image ( struct uri uri)

Allocate executable image.

Parameters
uriURI, or NULL
Return values
imageExecutable image

Definition at line 90 of file image.c.

90  {
91  struct image *image;
92  int rc;
93 
94  /* Allocate image */
95  image = zalloc ( sizeof ( *image ) );
96  if ( ! image )
97  goto err_alloc;
98 
99  /* Initialise image */
101  if ( uri && ( ( rc = image_set_uri ( image, uri ) ) != 0 ) )
102  goto err_set_uri;
103 
104  return image;
105 
106  err_set_uri:
107  image_put ( image );
108  err_alloc:
109  return NULL;
110 }
struct arbelprm_rc_send_wqe rc
Definition: arbel.h:14
int image_set_uri(struct image *image, struct uri *uri)
Set image URI.
Definition: image.c:119
#define ref_init(refcnt, free)
Initialise a reference counter.
Definition: refcnt.h:64
An executable image.
Definition: image.h:24
static void free_image(struct refcnt *refcnt)
Free executable image.
Definition: image.c:72
void * zalloc(size_t size)
Allocate cleared memory.
Definition: malloc.c:624
static void image_put(struct image *image)
Decrement reference count on an image.
Definition: image.h:206
A Uniform Resource Identifier.
Definition: uri.h:50
#define NULL
NULL pointer (VOID *)
Definition: Base.h:362
struct refcnt refcnt
Reference count.
Definition: image.h:26

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

Referenced by imgdownload(), and initrd_init().

◆ image_set_uri()

int image_set_uri ( struct image image,
struct uri uri 
)

Set image URI.

Parameters
imageImage
uriNew image URI
Return values
rcReturn status code

Definition at line 119 of file image.c.

119  {
120  const char *name;
121  int rc;
122 
123  /* Set name, if image does not already have one */
124  if ( uri->path && ( ! ( image->name && image->name[0] ) ) ) {
125  name = basename ( ( char * ) uri->path );
126  if ( ( rc = image_set_name ( image, name ) ) != 0 )
127  return rc;
128  }
129 
130  /* Update image URI */
131  uri_put ( image->uri );
132  image->uri = uri_get ( uri );
133 
134  return 0;
135 }
struct arbelprm_rc_send_wqe rc
Definition: arbel.h:14
const char * name
Definition: ath9k_hw.c:1984
static void uri_put(struct uri *uri)
Decrement URI reference count.
Definition: uri.h:188
static struct uri * uri_get(struct uri *uri)
Increment URI reference count.
Definition: uri.h:177
An executable image.
Definition: image.h:24
const char * path
Path.
Definition: uri.h:66
char * basename(char *path)
Return base name from path.
Definition: basename.c:42
int image_set_name(struct image *image, const char *name)
Set image name.
Definition: image.c:144
struct uri * uri
URI of image.
Definition: image.h:32
A Uniform Resource Identifier.
Definition: uri.h:50
char * name
Name.
Definition: image.h:34

References basename(), image_set_name(), image::name, name, 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
imageImage
nameNew image name
Return values
rcReturn status code

Definition at line 144 of file image.c.

144  {
145  char *name_copy;
146 
147  /* Duplicate name */
148  name_copy = strdup ( name );
149  if ( ! name_copy )
150  return -ENOMEM;
151 
152  /* Replace existing name */
153  free ( image->name );
154  image->name = name_copy;
155 
156  return 0;
157 }
const char * name
Definition: ath9k_hw.c:1984
An executable image.
Definition: image.h:24
#define ENOMEM
Not enough space.
Definition: errno.h:534
static void(* free)(struct refcnt *refcnt))
Definition: refcnt.h:54
char * strdup(const char *src)
Duplicate string.
Definition: string.c:350
char * name
Name.
Definition: image.h:34

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

Referenced by image_set_uri(), imgsingle_exec(), initrd_init(), and register_image().

◆ image_set_cmdline()

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

Set image command line.

Parameters
imageImage
cmdlineNew image command line, or NULL
Return values
rcReturn status code

Definition at line 166 of file image.c.

166  {
167 
168  free ( image->cmdline );
169  image->cmdline = NULL;
170  if ( cmdline ) {
171  image->cmdline = strdup ( cmdline );
172  if ( ! image->cmdline )
173  return -ENOMEM;
174  }
175  return 0;
176 }
An executable image.
Definition: image.h:24
char * cmdline
Command line to pass to image.
Definition: image.h:39
#define ENOMEM
Not enough space.
Definition: errno.h:534
static void(* free)(struct refcnt *refcnt))
Definition: refcnt.h:54
char * strdup(const char *src)
Duplicate string.
Definition: string.c:350
uint32_t cmdline
Definition: multiboot.h:16
#define NULL
NULL pointer (VOID *)
Definition: Base.h:362

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

Referenced by image_clear_cmdline(), and imgsingle_exec().

◆ image_probe()

static int image_probe ( struct image image)
static

Determine image type.

Parameters
imageExecutable image
Return values
rcReturn status code

Definition at line 184 of file image.c.

184  {
185  struct image_type *type;
186  int rc;
187 
188  /* Try each type in turn */
190  if ( ( rc = type->probe ( image ) ) == 0 ) {
191  image->type = type;
192  DBGC ( image, "IMAGE %s is %s\n",
193  image->name, type->name );
194  return 0;
195  }
196  DBGC ( image, "IMAGE %s is not %s: %s\n", image->name,
197  type->name, strerror ( rc ) );
198  }
199 
200  DBGC ( image, "IMAGE %s format not recognised\n", image->name );
201  return -ENOTSUP;
202 }
#define IMAGE_TYPES
Executable image type table.
Definition: image.h:140
struct arbelprm_rc_send_wqe rc
Definition: arbel.h:14
struct image_type * type
Image type, if known.
Definition: image.h:46
uint8_t type
Type.
Definition: ena.h:16
#define DBGC(...)
Definition: compiler.h:505
An executable image type.
Definition: image.h:76
An executable image.
Definition: image.h:24
#define ENOTSUP
Operation not supported.
Definition: errno.h:589
char * strerror(int errno)
Retrieve string representation of error number.
Definition: strerror.c:78
#define for_each_table_entry(pointer, table)
Iterate through all entries within a linker table.
Definition: tables.h:358
char * name
Name.
Definition: image.h:34

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

Referenced by register_image().

◆ register_image()

int register_image ( struct image image)

Register executable image.

Parameters
imageExecutable image
Return values
rcReturn status code

Definition at line 210 of file image.c.

210  {
211  static unsigned int imgindex = 0;
212  char name[8]; /* "imgXXXX" */
213  int rc;
214 
215  /* Create image name if it doesn't already have one */
216  if ( ! image->name ) {
217  snprintf ( name, sizeof ( name ), "img%d", imgindex++ );
218  if ( ( rc = image_set_name ( image, name ) ) != 0 )
219  return rc;
220  }
221 
222  /* Avoid ending up with multiple "selected" images on
223  * re-registration
224  */
225  if ( image_find_selected() )
227 
228  /* Add to image list */
229  image_get ( image );
231  list_add_tail ( &image->list, &images );
232  DBGC ( image, "IMAGE %s at [%lx,%lx) registered\n",
233  image->name, user_to_phys ( image->data, 0 ),
234  user_to_phys ( image->data, image->len ) );
235 
236  /* Try to detect image type, if applicable. Ignore failures,
237  * since we expect to handle some unrecognised images
238  * (e.g. kernel initrds, multiboot modules, random files
239  * provided via our EFI virtual filesystem, etc).
240  */
241  if ( ! image->type )
242  image_probe ( image );
243 
244  return 0;
245 }
unsigned int flags
Flags.
Definition: image.h:36
struct arbelprm_rc_send_wqe rc
Definition: arbel.h:14
const char * name
Definition: ath9k_hw.c:1984
userptr_t data
Raw file image.
Definition: image.h:41
struct image_type * type
Image type, if known.
Definition: image.h:46
static struct image * image_get(struct image *image)
Increment reference count on an image.
Definition: image.h:196
unsigned long user_to_phys(userptr_t userptr, off_t offset)
Convert user pointer to physical address.
#define DBGC(...)
Definition: compiler.h:505
An executable image.
Definition: image.h:24
static int image_probe(struct image *image)
Determine image type.
Definition: image.c:184
#define IMAGE_SELECTED
Image is selected for execution.
Definition: image.h:67
#define list_add_tail(new, head)
Add a new entry to the tail of a list.
Definition: list.h:93
#define IMAGE_REGISTERED
Image is registered.
Definition: image.h:64
size_t len
Length of raw file image.
Definition: image.h:43
struct list_head images
List of registered images.
Definition: image.c:56
int image_set_name(struct image *image, const char *name)
Set image name.
Definition: image.c:144
struct image * image_find_selected(void)
Find selected image.
Definition: image.c:451
int snprintf(char *buf, size_t size, const char *fmt,...)
Write a formatted string to a buffer.
Definition: vsprintf.c:382
struct list_head list
List of registered images.
Definition: image.h:29
char * name
Name.
Definition: image.h:34

References image::data, DBGC, image::flags, image_find_selected(), image_get(), image_probe(), IMAGE_REGISTERED, IMAGE_SELECTED, image_set_name(), images, image::len, image::list, list_add_tail, image::name, name, rc, snprintf(), image::type, and user_to_phys().

Referenced by asn1_okx(), cmdline_init(), embedded_init(), imgdownload(), initrd_init(), pixbuf_okx(), script_exec(), and test_init().

◆ unregister_image()

void unregister_image ( struct image image)

Unregister executable image.

Parameters
imageExecutable image

Definition at line 252 of file image.c.

252  {
253 
254  /* Do nothing unless image is registered */
255  if ( ! ( image->flags & IMAGE_REGISTERED ) )
256  return;
257 
258  DBGC ( image, "IMAGE %s unregistered\n", image->name );
259  list_del ( &image->list );
261  image_put ( image );
262 }
unsigned int flags
Flags.
Definition: image.h:36
#define DBGC(...)
Definition: compiler.h:505
An executable image.
Definition: image.h:24
#define list_del(list)
Delete an entry from a list.
Definition: list.h:119
#define IMAGE_REGISTERED
Image is registered.
Definition: image.h:64
static void image_put(struct image *image)
Decrement reference count on an image.
Definition: image.h:206
struct list_head list
List of registered images.
Definition: image.h:29
char * name
Name.
Definition: image.h:34

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

Referenced by asn1_okx(), bzimage_exec(), cert_exec(), com32_exec_loop(), comboot_exec_loop(), console_exec(), image_exec(), imgfree_exec(), imgverify_exec(), pixbuf_okx(), and script_exec().

◆ find_image()

struct image* find_image ( const char *  name)

Find image by name.

Parameters
nameImage name
Return values
imageExecutable image, or NULL

Definition at line 270 of file image.c.

270  {
271  struct image *image;
272 
274  if ( strcmp ( image->name, name ) == 0 )
275  return image;
276  }
277 
278  return NULL;
279 }
const char * name
Definition: ath9k_hw.c:1984
An executable image.
Definition: image.h:24
#define list_for_each_entry(pos, head, member)
Iterate over entries in a list.
Definition: list.h:420
struct list_head images
List of registered images.
Definition: image.c:56
int strcmp(const char *first, const char *second)
Compare strings.
Definition: string.c:157
struct list_head list
List of registered images.
Definition: image.h:29
char * name
Name.
Definition: image.h:34
#define NULL
NULL pointer (VOID *)
Definition: Base.h:362

References images, image::list, list_for_each_entry, image::name, name, NULL, and strcmp().

Referenced by imgacquire(), and imgmulti_exec().

◆ image_exec()

int image_exec ( struct image image)

Execute image.

Parameters
imageExecutable image
Return values
rcReturn 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 291 of file image.c.

291  {
292  struct image *saved_current_image;
293  struct image *replacement = NULL;
294  struct uri *old_cwuri;
295  int rc;
296 
297  /* Sanity check */
299 
300  /* Switch current working directory to be that of the image itself */
301  old_cwuri = uri_get ( cwuri );
302  churi ( image->uri );
303 
304  /* Preserve record of any currently-running image */
305  saved_current_image = current_image;
306 
307  /* Take out a temporary reference to the image. This allows
308  * the image to unregister itself if necessary, without
309  * automatically freeing itself.
310  */
312 
313  /* Check that this image can be executed */
314  if ( ! ( image->type && image->type->exec ) ) {
315  rc = -ENOEXEC;
316  goto err;
317  }
318 
319  /* Check that image is trusted (if applicable) */
320  if ( require_trusted_images && ! ( image->flags & IMAGE_TRUSTED ) ) {
321  DBGC ( image, "IMAGE %s is not trusted\n", image->name );
322  rc = -EACCES_UNTRUSTED;
323  goto err;
324  }
325 
326  /* Record boot attempt */
327  syslog ( LOG_NOTICE, "Executing \"%s\"\n", image->name );
328 
329  /* Try executing the image */
330  if ( ( rc = image->type->exec ( image ) ) != 0 ) {
331  DBGC ( image, "IMAGE %s could not execute: %s\n",
332  image->name, strerror ( rc ) );
333  /* Do not return yet; we still have clean-up to do */
334  }
335 
336  /* Record result of boot attempt */
337  if ( rc == 0 ) {
338  syslog ( LOG_NOTICE, "Execution of \"%s\" completed\n",
339  image->name );
340  } else {
341  syslog ( LOG_ERR, "Execution of \"%s\" failed: %s\n",
342  image->name, strerror ( rc ) );
343  }
344 
345  /* Pick up replacement image before we drop the original
346  * image's temporary reference. The replacement image must
347  * already be registered, so we don't need to hold a temporary
348  * reference (which would complicate the tail-recursion).
349  */
350  replacement = image->replacement;
351  if ( replacement )
352  assert ( replacement->flags & IMAGE_REGISTERED );
353 
354  err:
355  /* Unregister image if applicable */
358 
359  /* Debug message for tail-recursion. Placed here because the
360  * image_put() may end up freeing the image.
361  */
362  if ( replacement ) {
363  DBGC ( image, "IMAGE %s replacing self with IMAGE %s\n",
364  image->name, replacement->name );
365  }
366 
367  /* Drop temporary reference to the original image */
368  image_put ( image );
369 
370  /* Restore previous currently-running image */
371  current_image = saved_current_image;
372 
373  /* Reset current working directory */
374  churi ( old_cwuri );
375  uri_put ( old_cwuri );
376 
377  /* Tail-recurse into replacement image, if one exists */
378  if ( replacement )
379  return image_exec ( replacement );
380 
381  return rc;
382 }
unsigned int flags
Flags.
Definition: image.h:36
struct arbelprm_rc_send_wqe rc
Definition: arbel.h:14
struct image * current_image
Currently-executing image.
Definition: image.c:59
static void uri_put(struct uri *uri)
Decrement URI reference count.
Definition: uri.h:188
static struct uri * uri_get(struct uri *uri)
Increment URI reference count.
Definition: uri.h:177
#define EACCES_UNTRUSTED
Definition: image.c:46
#define ENOEXEC
Exec format error.
Definition: errno.h:519
struct image_type * type
Image type, if known.
Definition: image.h:46
static struct image * image_get(struct image *image)
Increment reference count on an image.
Definition: image.h:196
#define DBGC(...)
Definition: compiler.h:505
An executable image.
Definition: image.h:24
#define LOG_ERR
Error: error conditions.
Definition: syslog.h:35
#define IMAGE_AUTO_UNREGISTER
Image will be automatically unregistered after execution.
Definition: image.h:73
int(* exec)(struct image *image)
Execute image.
Definition: image.h:94
int image_exec(struct image *image)
Execute image.
Definition: image.c:291
void churi(struct uri *uri)
Change working URI.
Definition: cwuri.c:45
assert((readw(&hdr->flags) &(GTF_reading|GTF_writing))==0)
#define IMAGE_REGISTERED
Image is registered.
Definition: image.h:64
char * strerror(int errno)
Retrieve string representation of error number.
Definition: strerror.c:78
#define IMAGE_TRUSTED
Image is trusted.
Definition: image.h:70
struct uri * uri
URI of image.
Definition: image.h:32
static void image_put(struct image *image)
Decrement reference count on an image.
Definition: image.h:206
void unregister_image(struct image *image)
Unregister executable image.
Definition: image.c:252
#define syslog(priority, fmt,...)
Write message to system log.
Definition: syslog.h:93
struct image * replacement
Replacement image.
Definition: image.h:60
A Uniform Resource Identifier.
Definition: uri.h:50
static int require_trusted_images
Current image trust requirement.
Definition: image.c:62
struct uri * cwuri
Current working URI.
Definition: cwuri.c:38
char * name
Name.
Definition: image.h:34
#define NULL
NULL pointer (VOID *)
Definition: Base.h:362
#define LOG_NOTICE
Notice: normal but significant conditions.
Definition: syslog.h:41

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_TRUSTED, LOG_ERR, LOG_NOTICE, image::name, NULL, rc, image::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
replacementReplacement image
Return values
rcReturn status code

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

Definition at line 393 of file image.c.

393  {
394  struct image *image = current_image;
395  int rc;
396 
397  /* Sanity check */
399 
400  /* Fail unless there is a currently-executing image */
401  if ( ! image ) {
402  rc = -ENOTTY;
403  DBGC ( replacement, "IMAGE %s cannot replace non-existent "
404  "image: %s\n", replacement->name, strerror ( rc ) );
405  return rc;
406  }
407 
408  /* Check that the replacement image can be executed */
409  if ( ! ( replacement->type && replacement->type->exec ) )
410  return -ENOEXEC;
411 
412  /* Clear any existing replacement */
414 
415  /* Set replacement */
417  DBGC ( image, "IMAGE %s will replace self with IMAGE %s\n",
418  image->name, replacement->name );
419 
420  return 0;
421 }
unsigned int flags
Flags.
Definition: image.h:36
struct arbelprm_rc_send_wqe rc
Definition: arbel.h:14
struct image * current_image
Currently-executing image.
Definition: image.c:59
#define ENOEXEC
Exec format error.
Definition: errno.h:519
struct image_type * type
Image type, if known.
Definition: image.h:46
static struct image * image_get(struct image *image)
Increment reference count on an image.
Definition: image.h:196
#define DBGC(...)
Definition: compiler.h:505
An executable image.
Definition: image.h:24
int(* exec)(struct image *image)
Execute image.
Definition: image.h:94
assert((readw(&hdr->flags) &(GTF_reading|GTF_writing))==0)
#define IMAGE_REGISTERED
Image is registered.
Definition: image.h:64
char * strerror(int errno)
Retrieve string representation of error number.
Definition: strerror.c:78
static void image_put(struct image *image)
Decrement reference count on an image.
Definition: image.h:206
#define ENOTTY
Inappropriate I/O control operation.
Definition: errno.h:594
struct image * replacement
Replacement image.
Definition: image.h:60
char * name
Name.
Definition: image.h:34

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

Referenced by comboot_fetch_kernel(), and imgexec().

◆ image_select()

int image_select ( struct image image)

Select image for execution.

Parameters
imageExecutable image
Return values
rcReturn status code

Definition at line 429 of file image.c.

429  {
430  struct image *tmp;
431 
432  /* Unselect all other images */
433  for_each_image ( tmp )
434  tmp->flags &= ~IMAGE_SELECTED;
435 
436  /* Check that this image can be executed */
437  if ( ! ( image->type && image->type->exec ) )
438  return -ENOEXEC;
439 
440  /* Mark image as selected */
442 
443  return 0;
444 }
unsigned int flags
Flags.
Definition: image.h:36
#define ENOEXEC
Exec format error.
Definition: errno.h:519
struct image_type * type
Image type, if known.
Definition: image.h:46
An executable image.
Definition: image.h:24
int(* exec)(struct image *image)
Execute image.
Definition: image.h:94
#define IMAGE_SELECTED
Image is selected for execution.
Definition: image.h:67
#define for_each_image(image)
Iterate over all registered images.
Definition: image.h:149
uint8_t * tmp
Definition: entropy.h:156

References ENOEXEC, image_type::exec, image::flags, for_each_image, IMAGE_SELECTED, tmp, and image::type.

Referenced by embedded_init(), and imgselect().

◆ image_find_selected()

struct image* image_find_selected ( void  )

Find selected image.

Return values
imageExecutable image, or NULL

Definition at line 451 of file image.c.

451  {
452  struct image *image;
453 
454  for_each_image ( image ) {
455  if ( image->flags & IMAGE_SELECTED )
456  return image;
457  }
458  return NULL;
459 }
unsigned int flags
Flags.
Definition: image.h:36
An executable image.
Definition: image.h:24
#define IMAGE_SELECTED
Image is selected for execution.
Definition: image.h:67
#define for_each_image(image)
Iterate over all registered images.
Definition: image.h:149
#define NULL
NULL pointer (VOID *)
Definition: Base.h:362

References image::flags, for_each_image, IMAGE_SELECTED, and NULL.

Referenced by imgsingle_exec(), and register_image().

◆ image_set_trust()

int image_set_trust ( int  require_trusted,
int  permanent 
)

Change image trust requirement.

Parameters
require_trustedRequire trusted images
permanentMake trust requirement permanent
Return values
rcReturn status code

Definition at line 468 of file image.c.

468  {
469 
470  /* Update trust requirement, if permitted to do so */
472  require_trusted_images = require_trusted;
474  }
475 
476  /* Fail if we attempted to change the trust requirement but
477  * were not permitted to do so.
478  */
479  if ( require_trusted_images != require_trusted )
480  return -EACCES_PERMANENT;
481 
482  return 0;
483 }
static int require_trusted_images_permanent
Prevent changes to image trust requirement.
Definition: image.c:65
#define EACCES_PERMANENT
Definition: image.c:50
static int require_trusted_images
Current image trust requirement.
Definition: image.c:62

References EACCES_PERMANENT, require_trusted_images, and require_trusted_images_permanent.

Referenced by imgtrust_exec().

Variable Documentation

◆ images

struct list_head images = LIST_HEAD_INIT ( images )

◆ current_image

struct image* current_image

Currently-executing image.

Definition at line 59 of file image.c.

Referenced by goto_exec(), image_exec(), and image_replace().

◆ require_trusted_images

int require_trusted_images = 0
static

Current image trust requirement.

Definition at line 62 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 65 of file image.c.

Referenced by image_set_trust().