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
184
185
186
187
188
189
190
191
192
|
/*
* 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/emalloc.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 at [%lx,%lx) registered as %s\n",
image, user_to_phys ( image->data, 0 ),
user_to_phys ( image->data, image->len ), 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 );
}
/**
* Move image to start of list of registered images
*
* @v image Executable/loadable image
*
* Move the image to the start of the image list. This makes it
* easier to keep track of which of the images marked as loaded is
* likely to still be valid.
*/
void promote_image ( struct image *image ) {
list_del ( &image->list );
list_add ( &image->list, &images );
}
/**
* 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;
}
/**
* Load executable/loadable image into memory
*
* @v image Executable/loadable image
* @v type Executable/loadable image type
* @ret rc Return status code
*/
static int image_load_type ( struct image *image, struct image_type *type ) {
int rc;
if ( ( rc = type->load ( image ) ) != 0 ) {
DBGC ( image, "IMAGE %p could not load as %s: %s\n",
image, type->name, strerror ( rc ) );
return rc;
}
/* Flag as loaded */
image->flags |= IMAGE_LOADED;
return 0;
}
/**
* Load executable/loadable image into memory
*
* @v image Executable/loadable image
* @ret rc Return status code
*/
int image_load ( struct image *image ) {
assert ( image->type != NULL );
return image_load_type ( image, image->type );
}
/**
* 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 = image_load_type ( image, type );
if ( image->type == NULL )
continue;
return rc;
}
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;
}
|
