1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
|
/*
* Copyright (C) 2006 Michael Brown <mbrown@fensystems.co.uk>.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include <stddef.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <assert.h>
#include <vsprintf.h>
#include <gpxe/list.h>
#include <gpxe/image.h>
/** @file
*
* Executable/loadable images
*
*/
/** List of registered images */
struct list_head images = LIST_HEAD_INIT ( images );
/** List of image types */
static struct image_type image_types[0]
__table_start ( struct image_type, image_types );
static struct image_type image_types_end[0]
__table_end ( struct image_type, image_types );
/**
* Register executable/loadable image
*
* @v image Executable/loadable image
* @ret rc Return status code
*/
int register_image ( struct image *image ) {
static unsigned int imgindex = 0;
/* Create image name if it doesn't already have one */
if ( ! image->name[0] ) {
snprintf ( image->name, sizeof ( image->name ), "img%d",
imgindex++ );
}
/* Add to image list */
list_add_tail ( &image->list, &images );
DBGC ( image, "IMAGE %p registered as %s\n", image, image->name );
return 0;
}
/**
* Unregister executable/loadable image
*
* @v image Executable/loadable image
*/
void unregister_image ( struct image *image ) {
list_del ( &image->list );
DBGC ( image, "IMAGE %p unregistered\n", image );
}
/**
* Find image by name
*
* @v name Image name
* @ret image Executable/loadable image, or NULL
*/
struct image * find_image ( const char *name ) {
struct image *image;
list_for_each_entry ( image, &images, list ) {
if ( strcmp ( image->name, name ) == 0 )
return image;
}
return NULL;
}
/**
* Free loaded image
*
* @v image Executable/loadable image
*
* This releases the memory being used to store the image; it does not
* release the @c struct @c image itself, nor does it unregister the
* image.
*/
void free_image ( struct image *image ) {
efree ( image->data );
image->data = UNULL;
image->len = 0;
}
/**
* Load executable/loadable image into memory
*
* @v image Executable/loadable image
* @ret rc Return status code
*/
int image_load ( struct image *image ) {
int rc;
assert ( image->type != NULL );
if ( ( rc = image->type->load ( image ) ) != 0 ) {
DBGC ( image, "IMAGE %p could not load: %s\n",
image, strerror ( rc ) );
return rc;
}
image->flags |= IMAGE_LOADED;
return 0;
}
/**
* Autodetect image type and load executable/loadable image into memory
*
* @v image Executable/loadable image
* @ret rc Return status code
*/
int image_autoload ( struct image *image ) {
struct image_type *type;
int rc;
for ( type = image_types ; type < image_types_end ; type++ ) {
DBGC ( image, "IMAGE %p trying type %s\n", image, type->name );
rc = type->load ( image );
if ( image->type == NULL )
continue;
if ( rc != 0 ) {
DBGC ( image, "IMAGE %p (%s) could not load: %s\n",
image, image->type->name, strerror ( rc ) );
return rc;
}
image->flags |= IMAGE_LOADED;
return 0;
}
DBGC ( image, "IMAGE %p format not recognised\n", image );
return -ENOEXEC;
}
/**
* Execute loaded image
*
* @v image Loaded image
* @ret rc Return status code
*/
int image_exec ( struct image *image ) {
int rc;
/* Image must be loaded first */
if ( ! ( image->flags & IMAGE_LOADED ) ) {
DBGC ( image, "IMAGE %p could not execute: not loaded\n",
image );
return -ENOTTY;
}
assert ( image->type != NULL );
/* Try executing the image */
if ( ( rc = image->type->exec ( image ) ) != 0 ) {
DBGC ( image, "IMAGE %p could not execute: %s\n",
image, strerror ( rc ) );
return rc;
}
/* Well, some formats might return... */
return 0;
}
|
