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...
 
int image_set_len (struct image *image, size_t len)
 Set image length. More...
 
int image_set_data (struct image *image, userptr_t data, size_t len)
 Set image data. 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...
 
struct imageimage_memory (const char *name, userptr_t data, size_t len)
 Create registered image from block of memory. 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:205
#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:221
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:221
A Uniform Resource Identifier.
Definition: uri.h:64
#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 image_extract(), image_memory(), and imgdownload().

◆ 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:205
static struct uri * uri_get(struct uri *uri)
Increment URI reference count.
Definition: uri.h:194
An executable image.
Definition: image.h:24
const char * path
Path (after URI decoding)
Definition: uri.h:80
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:64
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:380
char * name
Name.
Definition: image.h:34

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

Referenced by image_extract(), image_memory(), image_set_uri(), imgsingle_exec(), 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:380
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(), image_extract_exec(), and imgsingle_exec().

◆ image_set_len()

int image_set_len ( struct image image,
size_t  len 
)

Set image length.

Parameters
imageImage
lenLength of image data
Return values
rcReturn status code

Definition at line 185 of file image.c.

185  {
186  userptr_t new;
187 
188  /* (Re)allocate image data */
189  new = urealloc ( image->data, len );
190  if ( ! new )
191  return -ENOMEM;
192  image->data = new;
193  image->len = len;
194 
195  return 0;
196 }
userptr_t data
Raw file image.
Definition: image.h:41
An executable image.
Definition: image.h:24
#define ENOMEM
Not enough space.
Definition: errno.h:534
userptr_t urealloc(userptr_t userptr, size_t new_size)
Reallocate external memory.
size_t len
Length of raw file image.
Definition: image.h:43
uint32_t len
Length.
Definition: ena.h:14
unsigned long userptr_t
A pointer to a user buffer.
Definition: uaccess.h:33

References image::data, ENOMEM, len, image::len, and urealloc().

Referenced by gzip_extract(), image_set_data(), and zlib_deflate().

◆ image_set_data()

int image_set_data ( struct image image,
userptr_t  data,
size_t  len 
)

Set image data.

Parameters
imageImage
dataImage data
lenLength of image data
Return values
rcReturn status code

Definition at line 206 of file image.c.

206  {
207  int rc;
208 
209  /* Set image length */
210  if ( ( rc = image_set_len ( image, len ) ) != 0 )
211  return rc;
212 
213  /* Copy in new image data */
214  memcpy_user ( image->data, 0, data, 0, len );
215 
216  return 0;
217 }
struct arbelprm_rc_send_wqe rc
Definition: arbel.h:14
userptr_t data
Raw file image.
Definition: image.h:41
An executable image.
Definition: image.h:24
int image_set_len(struct image *image, size_t len)
Set image length.
Definition: image.c:185
uint32_t len
Length.
Definition: ena.h:14
struct arbelprm_port_state_change_st data
Message.
Definition: arbel.h:12
void memcpy_user(userptr_t dest, off_t dest_off, userptr_t src, off_t src_off, size_t len)
Copy data between user buffers.

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

Referenced by image_memory().

◆ image_probe()

static int image_probe ( struct image image)
static

Determine image type.

Parameters
imageExecutable image
Return values
rcReturn status code

Definition at line 225 of file image.c.

225  {
226  struct image_type *type;
227  int rc;
228 
229  /* Try each type in turn */
231  if ( ( rc = type->probe ( image ) ) == 0 ) {
232  image->type = type;
233  DBGC ( image, "IMAGE %s is %s\n",
234  image->name, type->name );
235  return 0;
236  }
237  DBGC ( image, "IMAGE %s is not %s: %s\n", image->name,
238  type->name, strerror ( rc ) );
239  }
240 
241  DBGC ( image, "IMAGE %s format not recognised\n", image->name );
242  return -ENOTSUP;
243 }
#define IMAGE_TYPES
Executable image type table.
Definition: image.h:148
struct arbelprm_rc_send_wqe rc
Definition: arbel.h:14
struct image_type * type
Image type, if known.
Definition: image.h:46
uint32_t type
Operating system type.
Definition: ena.h:12
#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:385
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 251 of file image.c.

251  {
252  static unsigned int imgindex = 0;
253  char name[8]; /* "imgXXXX" */
254  int rc;
255 
256  /* Create image name if it doesn't already have one */
257  if ( ! image->name ) {
258  snprintf ( name, sizeof ( name ), "img%d", imgindex++ );
259  if ( ( rc = image_set_name ( image, name ) ) != 0 )
260  return rc;
261  }
262 
263  /* Avoid ending up with multiple "selected" images on
264  * re-registration
265  */
266  if ( image_find_selected() )
268 
269  /* Add to image list */
270  image_get ( image );
272  list_add_tail ( &image->list, &images );
273  DBGC ( image, "IMAGE %s at [%lx,%lx) registered\n",
274  image->name, user_to_phys ( image->data, 0 ),
275  user_to_phys ( image->data, image->len ) );
276 
277  /* Try to detect image type, if applicable. Ignore failures,
278  * since we expect to handle some unrecognised images
279  * (e.g. kernel initrds, multiboot modules, random files
280  * provided via our EFI virtual filesystem, etc).
281  */
282  if ( ! image->type )
283  image_probe ( image );
284 
285  return 0;
286 }
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:211
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:225
#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:495
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(), image_extract(), image_memory(), imgdownload(), pixbuf_okx(), script_exec(), and test_init().

◆ unregister_image()

void unregister_image ( struct image image)

Unregister executable image.

Parameters
imageExecutable image

Definition at line 293 of file image.c.

293  {
294 
295  /* Do nothing unless image is registered */
296  if ( ! ( image->flags & IMAGE_REGISTERED ) )
297  return;
298 
299  DBGC ( image, "IMAGE %s unregistered\n", image->name );
300  list_del ( &image->list );
302  image_put ( image );
303 }
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:221
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(), gzip_okx(), image_exec(), image_extract(), image_extract_exec(), imgextract_exec(), imgfree_exec(), imgverify_exec(), pixbuf_okx(), script_exec(), and zlib_okx().

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

311  {
312  struct image *image;
313 
315  if ( strcmp ( image->name, name ) == 0 )
316  return image;
317  }
318 
319  return NULL;
320 }
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:173
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 332 of file image.c.

332  {
333  struct image *saved_current_image;
334  struct image *replacement = NULL;
335  struct uri *old_cwuri;
336  int rc;
337 
338  /* Sanity check */
340 
341  /* Switch current working directory to be that of the image
342  * itself, if applicable
343  */
344  old_cwuri = uri_get ( cwuri );
345  if ( image->uri )
346  churi ( image->uri );
347 
348  /* Preserve record of any currently-running image */
349  saved_current_image = current_image;
350 
351  /* Take out a temporary reference to the image. This allows
352  * the image to unregister itself if necessary, without
353  * automatically freeing itself.
354  */
356 
357  /* Check that this image can be executed */
358  if ( ! ( image->type && image->type->exec ) ) {
359  rc = -ENOEXEC;
360  goto err;
361  }
362 
363  /* Check that image is trusted (if applicable) */
364  if ( require_trusted_images && ! ( image->flags & IMAGE_TRUSTED ) ) {
365  DBGC ( image, "IMAGE %s is not trusted\n", image->name );
366  rc = -EACCES_UNTRUSTED;
367  goto err;
368  }
369 
370  /* Record boot attempt */
371  syslog ( LOG_NOTICE, "Executing \"%s\"\n", image->name );
372 
373  /* Try executing the image */
374  if ( ( rc = image->type->exec ( image ) ) != 0 ) {
375  DBGC ( image, "IMAGE %s could not execute: %s\n",
376  image->name, strerror ( rc ) );
377  /* Do not return yet; we still have clean-up to do */
378  }
379 
380  /* Record result of boot attempt */
381  if ( rc == 0 ) {
382  syslog ( LOG_NOTICE, "Execution of \"%s\" completed\n",
383  image->name );
384  } else {
385  syslog ( LOG_ERR, "Execution of \"%s\" failed: %s\n",
386  image->name, strerror ( rc ) );
387  }
388 
389  /* Pick up replacement image before we drop the original
390  * image's temporary reference. The replacement image must
391  * already be registered, so we don't need to hold a temporary
392  * reference (which would complicate the tail-recursion).
393  */
394  replacement = image->replacement;
395  if ( replacement )
396  assert ( replacement->flags & IMAGE_REGISTERED );
397 
398  err:
399  /* Unregister image if applicable */
402 
403  /* Debug message for tail-recursion. Placed here because the
404  * image_put() may end up freeing the image.
405  */
406  if ( replacement ) {
407  DBGC ( image, "IMAGE %s replacing self with IMAGE %s\n",
408  image->name, replacement->name );
409  }
410 
411  /* Drop temporary reference to the original image */
412  image_put ( image );
413 
414  /* Restore previous currently-running image */
415  current_image = saved_current_image;
416 
417  /* Reset current working directory */
418  churi ( old_cwuri );
419  uri_put ( old_cwuri );
420 
421  /* Tail-recurse into replacement image, if one exists */
422  if ( replacement )
423  return image_exec ( replacement );
424 
425  return rc;
426 }
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:205
static struct uri * uri_get(struct uri *uri)
Increment URI reference count.
Definition: uri.h:194
#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:211
#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:332
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:221
void unregister_image(struct image *image)
Unregister executable image.
Definition: image.c:293
#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:64
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(), image_extract_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 437 of file image.c.

437  {
438  struct image *image = current_image;
439  int rc;
440 
441  /* Sanity check */
443 
444  /* Fail unless there is a currently-executing image */
445  if ( ! image ) {
446  rc = -ENOTTY;
447  DBGC ( replacement, "IMAGE %s cannot replace non-existent "
448  "image: %s\n", replacement->name, strerror ( rc ) );
449  return rc;
450  }
451 
452  /* Check that the replacement image can be executed */
453  if ( ! ( replacement->type && replacement->type->exec ) )
454  return -ENOEXEC;
455 
456  /* Clear any existing replacement */
458 
459  /* Set replacement */
461  DBGC ( image, "IMAGE %s will replace self with IMAGE %s\n",
462  image->name, replacement->name );
463 
464  return 0;
465 }
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:211
#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:221
#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 473 of file image.c.

473  {
474  struct image *tmp;
475 
476  /* Unselect all other images */
477  for_each_image ( tmp )
478  tmp->flags &= ~IMAGE_SELECTED;
479 
480  /* Check that this image can be executed */
481  if ( ! ( image->type && image->type->exec ) )
482  return -ENOEXEC;
483 
484  /* Mark image as selected */
486 
487  return 0;
488 }
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:157
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 495 of file image.c.

495  {
496  struct image *image;
497 
498  for_each_image ( image ) {
499  if ( image->flags & IMAGE_SELECTED )
500  return image;
501  }
502  return NULL;
503 }
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:157
#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 512 of file image.c.

512  {
513 
514  /* Update trust requirement, if permitted to do so */
516  require_trusted_images = require_trusted;
518  }
519 
520  /* Fail if we attempted to change the trust requirement but
521  * were not permitted to do so.
522  */
523  if ( require_trusted_images != require_trusted )
524  return -EACCES_PERMANENT;
525 
526  return 0;
527 }
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().

◆ image_memory()

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

Create registered image from block of memory.

Parameters
nameName
dataImage data
lenLength
Return values
imageImage, or NULL on error

Definition at line 537 of file image.c.

537  {
538  struct image *image;
539  int rc;
540 
541  /* Allocate image */
542  image = alloc_image ( NULL );
543  if ( ! image ) {
544  rc = -ENOMEM;
545  goto err_alloc_image;
546  }
547 
548  /* Set name */
549  if ( ( rc = image_set_name ( image, name ) ) != 0 )
550  goto err_set_name;
551 
552  /* Set data */
553  if ( ( rc = image_set_data ( image, data, len ) ) != 0 )
554  goto err_set_data;
555 
556  /* Register image */
557  if ( ( rc = register_image ( image ) ) != 0 )
558  goto err_register;
559 
560  /* Drop local reference to image */
561  image_put ( image );
562 
563  return image;
564 
565  err_register:
566  err_set_data:
567  err_set_name:
568  image_put ( image );
569  err_alloc_image:
570  return NULL;
571 }
struct arbelprm_rc_send_wqe rc
Definition: arbel.h:14
const char * name
Definition: ath9k_hw.c:1984
An executable image.
Definition: image.h:24
#define ENOMEM
Not enough space.
Definition: errno.h:534
int register_image(struct image *image)
Register executable image.
Definition: image.c:251
int image_set_name(struct image *image, const char *name)
Set image name.
Definition: image.c:144
static void image_put(struct image *image)
Decrement reference count on an image.
Definition: image.h:221
int image_set_data(struct image *image, userptr_t data, size_t len)
Set image data.
Definition: image.c:206
uint32_t len
Length.
Definition: ena.h:14
struct arbelprm_port_state_change_st data
Message.
Definition: arbel.h:12
struct image * alloc_image(struct uri *uri)
Allocate executable image.
Definition: image.c:90
#define NULL
NULL pointer (VOID *)
Definition: Base.h:362

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

Referenced by efi_autoexec_startup(), gzip_okx(), imgmem(), initrd_init(), and zlib_okx().

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 efi_file_read_initrd(), 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().