]>
Commit | Line | Data |
---|---|---|
ca20cf32 BS |
1 | #ifndef LOADER_H |
2 | #define LOADER_H | |
a88b362c | 3 | #include "hw/nvram/fw_cfg.h" |
ca20cf32 BS |
4 | |
5 | /* loader.c */ | |
a1483f88 MT |
6 | /** |
7 | * get_image_size: retrieve size of an image file | |
8 | * @filename: Path to the image file | |
9 | * | |
10 | * Returns the size of the image file on success, -1 otherwise. | |
11 | * On error, errno is also set as appropriate. | |
12 | */ | |
f3839fda | 13 | int64_t get_image_size(const char *filename); |
06192329 PM |
14 | /** |
15 | * load_image_size: load an image file into specified buffer | |
16 | * @filename: Path to the image file | |
17 | * @addr: Buffer to load image into | |
18 | * @size: Size of buffer in bytes | |
19 | * | |
20 | * Load an image file from disk into the specified buffer. | |
21 | * If the image is larger than the specified buffer, only | |
22 | * @size bytes are read (this is not considered an error). | |
23 | * | |
24 | * Prefer to use the GLib function g_file_get_contents() rather | |
25 | * than a "get_image_size()/g_malloc()/load_image_size()" sequence. | |
26 | * | |
27 | * Returns the number of bytes read, or -1 on error. On error, | |
28 | * errno is also set as appropriate. | |
29 | */ | |
ea87616d | 30 | ssize_t load_image_size(const char *filename, void *addr, size_t size); |
93ffc7c7 AF |
31 | |
32 | /**load_image_targphys_as: | |
33 | * @filename: Path to the image file | |
34 | * @addr: Address to load the image to | |
35 | * @max_sz: The maximum size of the image to load | |
36 | * @as: The AddressSpace to load the ELF to. The value of address_space_memory | |
37 | * is used if nothing is supplied here. | |
38 | * | |
39 | * Load a fixed image into memory. | |
40 | * | |
41 | * Returns the size of the loaded image on success, -1 otherwise. | |
42 | */ | |
af975131 JI |
43 | ssize_t load_image_targphys_as(const char *filename, |
44 | hwaddr addr, uint64_t max_sz, AddressSpace *as); | |
93ffc7c7 | 45 | |
e4a25ed9 SH |
46 | /**load_targphys_hex_as: |
47 | * @filename: Path to the .hex file | |
48 | * @entry: Store the entry point given by the .hex file | |
49 | * @as: The AddressSpace to load the .hex file to. The value of | |
50 | * address_space_memory is used if nothing is supplied here. | |
51 | * | |
52 | * Load a fixed .hex file into memory. | |
53 | * | |
54 | * Returns the size of the loaded .hex file on success, -1 otherwise. | |
55 | */ | |
af975131 JI |
56 | ssize_t load_targphys_hex_as(const char *filename, hwaddr *entry, |
57 | AddressSpace *as); | |
e4a25ed9 | 58 | |
93ffc7c7 AF |
59 | /** load_image_targphys: |
60 | * Same as load_image_targphys_as(), but doesn't allow the caller to specify | |
61 | * an AddressSpace. | |
62 | */ | |
af975131 JI |
63 | ssize_t load_image_targphys(const char *filename, hwaddr, |
64 | uint64_t max_sz); | |
93ffc7c7 | 65 | |
76151cac PM |
66 | /** |
67 | * load_image_mr: load an image into a memory region | |
68 | * @filename: Path to the image file | |
69 | * @mr: Memory Region to load into | |
70 | * | |
71 | * Load the specified file into the memory region. | |
72 | * The file loaded is registered as a ROM, so its contents will be | |
73 | * reinstated whenever the system is reset. | |
74 | * If the file is larger than the memory region's size the call will fail. | |
75 | * Returns -1 on failure, or the size of the file. | |
76 | */ | |
af975131 | 77 | ssize_t load_image_mr(const char *filename, MemoryRegion *mr); |
7d48a0f7 LE |
78 | |
79 | /* This is the limit on the maximum uncompressed image size that | |
80 | * load_image_gzipped_buffer() and load_image_gzipped() will read. It prevents | |
81 | * g_malloc() in those functions from allocating a huge amount of memory. | |
82 | */ | |
83 | #define LOAD_IMAGE_MAX_GUNZIP_BYTES (256 << 20) | |
84 | ||
af975131 JI |
85 | ssize_t load_image_gzipped_buffer(const char *filename, uint64_t max_sz, |
86 | uint8_t **buffer); | |
87 | ssize_t load_image_gzipped(const char *filename, hwaddr addr, uint64_t max_sz); | |
18674b26 AK |
88 | |
89 | #define ELF_LOAD_FAILED -1 | |
90 | #define ELF_LOAD_NOT_ELF -2 | |
91 | #define ELF_LOAD_WRONG_ARCH -3 | |
92 | #define ELF_LOAD_WRONG_ENDIAN -4 | |
41a26351 | 93 | #define ELF_LOAD_TOO_BIG -5 |
8975eb89 | 94 | const char *load_elf_strerror(ssize_t error); |
140b7ce5 | 95 | |
a2480ffa | 96 | /** load_elf_ram_sym: |
140b7ce5 | 97 | * @filename: Path of ELF file |
4366e1db LM |
98 | * @elf_note_fn: optional function to parse ELF Note type |
99 | * passed via @translate_opaque | |
140b7ce5 PC |
100 | * @translate_fn: optional function to translate load addresses |
101 | * @translate_opaque: opaque data passed to @translate_fn | |
102 | * @pentry: Populated with program entry point. Ignored if NULL. | |
103 | * @lowaddr: Populated with lowest loaded address. Ignored if NULL. | |
104 | * @highaddr: Populated with highest loaded address. Ignored if NULL. | |
6cdda0ff | 105 | * @pflags: Populated with ELF processor-specific flags. Ignore if NULL. |
140b7ce5 PC |
106 | * @bigendian: Expected ELF endianness. 0 for LE otherwise BE |
107 | * @elf_machine: Expected ELF machine type | |
108 | * @clear_lsb: Set to mask off LSB of addresses (Some architectures use | |
109 | * this for non-address data) | |
7ef295ea PC |
110 | * @data_swab: Set to order of byte swapping for data. 0 for no swap, 1 |
111 | * for swapping bytes within halfwords, 2 for bytes within | |
112 | * words and 3 for within doublewords. | |
70bb1d16 AF |
113 | * @as: The AddressSpace to load the ELF to. The value of address_space_memory |
114 | * is used if nothing is supplied here. | |
34f1b23f | 115 | * @load_rom : Load ELF binary as ROM |
a2480ffa | 116 | * @sym_cb: Callback function for symbol table entries |
140b7ce5 PC |
117 | * |
118 | * Load an ELF file's contents to the emulated system's address space. | |
119 | * Clients may optionally specify a callback to perform address | |
120 | * translations. @pentry, @lowaddr and @highaddr are optional pointers | |
121 | * which will be populated with various load information. @bigendian and | |
122 | * @elf_machine give the expected endianness and machine for the ELF the | |
123 | * load will fail if the target ELF does not match. Some architectures | |
124 | * have some architecture-specific behaviours that come into effect when | |
125 | * their particular values for @elf_machine are set. | |
8cf6e9da AF |
126 | * If @elf_machine is EM_NONE then the machine type will be read from the |
127 | * ELF header and no checks will be carried out against the machine type. | |
140b7ce5 | 128 | */ |
a2480ffa MC |
129 | typedef void (*symbol_fn_t)(const char *st_name, int st_info, |
130 | uint64_t st_value, uint64_t st_size); | |
131 | ||
8975eb89 LM |
132 | ssize_t load_elf_ram_sym(const char *filename, |
133 | uint64_t (*elf_note_fn)(void *, void *, bool), | |
134 | uint64_t (*translate_fn)(void *, uint64_t), | |
135 | void *translate_opaque, uint64_t *pentry, | |
136 | uint64_t *lowaddr, uint64_t *highaddr, | |
137 | uint32_t *pflags, int big_endian, int elf_machine, | |
138 | int clear_lsb, int data_swab, | |
139 | AddressSpace *as, bool load_rom, symbol_fn_t sym_cb); | |
a2480ffa MC |
140 | |
141 | /** load_elf_ram: | |
142 | * Same as load_elf_ram_sym(), but doesn't allow the caller to specify a | |
143 | * symbol callback function | |
144 | */ | |
8975eb89 LM |
145 | ssize_t load_elf_ram(const char *filename, |
146 | uint64_t (*elf_note_fn)(void *, void *, bool), | |
147 | uint64_t (*translate_fn)(void *, uint64_t), | |
148 | void *translate_opaque, uint64_t *pentry, | |
149 | uint64_t *lowaddr, uint64_t *highaddr, uint32_t *pflags, | |
150 | int big_endian, int elf_machine, int clear_lsb, | |
151 | int data_swab, AddressSpace *as, bool load_rom); | |
34f1b23f FA |
152 | |
153 | /** load_elf_as: | |
154 | * Same as load_elf_ram(), but always loads the elf as ROM | |
155 | */ | |
8975eb89 LM |
156 | ssize_t load_elf_as(const char *filename, |
157 | uint64_t (*elf_note_fn)(void *, void *, bool), | |
158 | uint64_t (*translate_fn)(void *, uint64_t), | |
159 | void *translate_opaque, uint64_t *pentry, uint64_t *lowaddr, | |
160 | uint64_t *highaddr, uint32_t *pflags, int big_endian, | |
161 | int elf_machine, int clear_lsb, int data_swab, | |
162 | AddressSpace *as); | |
140b7ce5 | 163 | |
70bb1d16 AF |
164 | /** load_elf: |
165 | * Same as load_elf_as(), but doesn't allow the caller to specify an | |
166 | * AddressSpace. | |
167 | */ | |
8975eb89 LM |
168 | ssize_t load_elf(const char *filename, |
169 | uint64_t (*elf_note_fn)(void *, void *, bool), | |
170 | uint64_t (*translate_fn)(void *, uint64_t), | |
171 | void *translate_opaque, uint64_t *pentry, uint64_t *lowaddr, | |
172 | uint64_t *highaddr, uint32_t *pflags, int big_endian, | |
173 | int elf_machine, int clear_lsb, int data_swab); | |
04ae712a PC |
174 | |
175 | /** load_elf_hdr: | |
176 | * @filename: Path of ELF file | |
177 | * @hdr: Buffer to populate with header data. Header data will not be | |
178 | * filled if set to NULL. | |
179 | * @is64: Set to true if the ELF is 64bit. Ignored if set to NULL | |
180 | * @errp: Populated with an error in failure cases | |
181 | * | |
182 | * Inspect an ELF file's header. Read its full header contents into a | |
183 | * buffer and/or determine if the ELF is 64bit. | |
184 | */ | |
185 | void load_elf_hdr(const char *filename, void *hdr, bool *is64, Error **errp); | |
186 | ||
af975131 JI |
187 | ssize_t load_aout(const char *filename, hwaddr addr, int max_sz, |
188 | int bswap_needed, hwaddr target_page_size); | |
5e774eb3 | 189 | |
f831f955 NH |
190 | #define LOAD_UIMAGE_LOADADDR_INVALID (-1) |
191 | ||
5e774eb3 AF |
192 | /** load_uimage_as: |
193 | * @filename: Path of uimage file | |
194 | * @ep: Populated with program entry point. Ignored if NULL. | |
f831f955 NH |
195 | * @loadaddr: load address if none specified in the image or when loading a |
196 | * ramdisk. Populated with the load address. Ignored if NULL or | |
197 | * LOAD_UIMAGE_LOADADDR_INVALID (images which do not specify a load | |
198 | * address will not be loadable). | |
5e774eb3 AF |
199 | * @is_linux: Is set to true if the image loaded is Linux. Ignored if NULL. |
200 | * @translate_fn: optional function to translate load addresses | |
201 | * @translate_opaque: opaque data passed to @translate_fn | |
202 | * @as: The AddressSpace to load the ELF to. The value of address_space_memory | |
203 | * is used if nothing is supplied here. | |
204 | * | |
205 | * Loads a u-boot image into memory. | |
206 | * | |
207 | * Returns the size of the loaded image on success, -1 otherwise. | |
208 | */ | |
af975131 JI |
209 | ssize_t load_uimage_as(const char *filename, hwaddr *ep, |
210 | hwaddr *loadaddr, int *is_linux, | |
211 | uint64_t (*translate_fn)(void *, uint64_t), | |
212 | void *translate_opaque, AddressSpace *as); | |
5e774eb3 AF |
213 | |
214 | /** load_uimage: | |
215 | * Same as load_uimage_as(), but doesn't allow the caller to specify an | |
216 | * AddressSpace. | |
217 | */ | |
af975131 JI |
218 | ssize_t load_uimage(const char *filename, hwaddr *ep, |
219 | hwaddr *loadaddr, int *is_linux, | |
220 | uint64_t (*translate_fn)(void *, uint64_t), | |
221 | void *translate_opaque); | |
ca20cf32 | 222 | |
84aee0de | 223 | /** |
97df5fee | 224 | * load_ramdisk_as: |
84aee0de SB |
225 | * @filename: Path to the ramdisk image |
226 | * @addr: Memory address to load the ramdisk to | |
227 | * @max_sz: Maximum allowed ramdisk size (for non-u-boot ramdisks) | |
97df5fee PM |
228 | * @as: The AddressSpace to load the ELF to. The value of address_space_memory |
229 | * is used if nothing is supplied here. | |
84aee0de SB |
230 | * |
231 | * Load a ramdisk image with U-Boot header to the specified memory | |
232 | * address. | |
233 | * | |
234 | * Returns the size of the loaded image on success, -1 otherwise. | |
235 | */ | |
af975131 JI |
236 | ssize_t load_ramdisk_as(const char *filename, hwaddr addr, uint64_t max_sz, |
237 | AddressSpace *as); | |
97df5fee PM |
238 | |
239 | /** | |
240 | * load_ramdisk: | |
241 | * Same as load_ramdisk_as(), but doesn't allow the caller to specify | |
242 | * an AddressSpace. | |
243 | */ | |
af975131 | 244 | ssize_t load_ramdisk(const char *filename, hwaddr addr, uint64_t max_sz); |
84aee0de | 245 | |
51b58561 PB |
246 | ssize_t gunzip(void *dst, size_t dstlen, uint8_t *src, size_t srclen); |
247 | ||
725e14e9 | 248 | ssize_t read_targphys(const char *name, |
a8170e5e | 249 | int fd, hwaddr dst_addr, size_t nbytes); |
3c178e72 | 250 | void pstrcpy_targphys(const char *name, |
a8170e5e | 251 | hwaddr dest, int buf_size, |
ca20cf32 | 252 | const char *source); |
45a50b16 | 253 | |
af975131 JI |
254 | ssize_t rom_add_file(const char *file, const char *fw_dir, |
255 | hwaddr addr, int32_t bootindex, | |
256 | bool option_rom, MemoryRegion *mr, AddressSpace *as); | |
339240b5 PB |
257 | MemoryRegion *rom_add_blob(const char *name, const void *blob, size_t len, |
258 | size_t max_len, hwaddr addr, | |
259 | const char *fw_file_name, | |
6f6f4aec | 260 | FWCfgCallback fw_callback, |
baf2d5bf MT |
261 | void *callback_opaque, AddressSpace *as, |
262 | bool read_only); | |
fef28891 SG |
263 | int rom_add_elf_program(const char *name, GMappedFile *mapped_file, void *data, |
264 | size_t datasize, size_t romsize, hwaddr addr, | |
265 | AddressSpace *as); | |
6b3f7f63 | 266 | int rom_check_and_register_reset(void); |
a88b362c | 267 | void rom_set_fw(FWCfgState *f); |
bab47d9a GH |
268 | void rom_set_order_override(int order); |
269 | void rom_reset_order_override(void); | |
e2336043 SH |
270 | |
271 | /** | |
272 | * rom_transaction_begin: | |
273 | * | |
274 | * Call this before of a series of rom_add_*() calls. Call | |
275 | * rom_transaction_end() afterwards to commit or abort. These functions are | |
276 | * useful for undoing a series of rom_add_*() calls if image file loading fails | |
277 | * partway through. | |
278 | */ | |
279 | void rom_transaction_begin(void); | |
280 | ||
281 | /** | |
282 | * rom_transaction_end: | |
283 | * @commit: true to commit added roms, false to drop added roms | |
284 | * | |
285 | * Call this after a series of rom_add_*() calls. See rom_transaction_begin(). | |
286 | */ | |
287 | void rom_transaction_end(bool commit); | |
288 | ||
a8170e5e | 289 | int rom_copy(uint8_t *dest, hwaddr addr, size_t size); |
0f0f8b61 | 290 | void *rom_ptr(hwaddr addr, size_t size); |
1228c459 PM |
291 | /** |
292 | * rom_ptr_for_as: Return a pointer to ROM blob data for the address | |
293 | * @as: AddressSpace to look for the ROM blob in | |
294 | * @addr: Address within @as | |
295 | * @size: size of data required in bytes | |
296 | * | |
297 | * Returns: pointer into the data which backs the matching ROM blob, | |
298 | * or NULL if no blob covers the address range. | |
299 | * | |
300 | * This function looks for a ROM blob which covers the specified range | |
301 | * of bytes of length @size starting at @addr within the address space | |
302 | * @as. This is useful for code which runs as part of board | |
303 | * initialization or CPU reset which wants to read data that is part | |
304 | * of a user-supplied guest image or other guest memory contents, but | |
305 | * which runs before the ROM loader's reset function has copied the | |
306 | * blobs into guest memory. | |
307 | * | |
308 | * rom_ptr_for_as() will look not just for blobs loaded directly to | |
309 | * the specified address, but also for blobs which were loaded to an | |
310 | * alias of the region at a different location in the AddressSpace. | |
311 | * In other words, if a machine model has RAM at address 0x0000_0000 | |
312 | * which is aliased to also appear at 0x1000_0000, rom_ptr_for_as() | |
313 | * will return the correct data whether the guest image was linked and | |
314 | * loaded at 0x0000_0000 or 0x1000_0000. Contrast rom_ptr(), which | |
315 | * will only return data if the image load address is an exact match | |
316 | * with the queried address. | |
317 | * | |
318 | * New code should prefer to use rom_ptr_for_as() instead of | |
319 | * rom_ptr(). | |
320 | */ | |
321 | void *rom_ptr_for_as(AddressSpace *as, hwaddr addr, size_t size); | |
1ce6be24 | 322 | void hmp_info_roms(Monitor *mon, const QDict *qdict); |
45a50b16 | 323 | |
2e55e842 | 324 | #define rom_add_file_fixed(_f, _a, _i) \ |
3e76099a | 325 | rom_add_file(_f, NULL, _a, _i, false, NULL, NULL) |
45a50b16 | 326 | #define rom_add_blob_fixed(_f, _b, _l, _a) \ |
baf2d5bf | 327 | rom_add_blob(_f, _b, _l, _l, _a, NULL, NULL, NULL, NULL, true) |
76151cac | 328 | #define rom_add_file_mr(_f, _mr, _i) \ |
3e76099a AF |
329 | rom_add_file(_f, NULL, 0, _i, false, _mr, NULL) |
330 | #define rom_add_file_as(_f, _as, _i) \ | |
331 | rom_add_file(_f, NULL, 0, _i, false, NULL, _as) | |
93ffc7c7 AF |
332 | #define rom_add_file_fixed_as(_f, _a, _i, _as) \ |
333 | rom_add_file(_f, NULL, _a, _i, false, NULL, _as) | |
5e774eb3 | 334 | #define rom_add_blob_fixed_as(_f, _b, _l, _a, _as) \ |
baf2d5bf | 335 | rom_add_blob(_f, _b, _l, _l, _a, NULL, NULL, NULL, _as, true) |
45a50b16 | 336 | |
af975131 JI |
337 | ssize_t rom_add_vga(const char *file); |
338 | ssize_t rom_add_option(const char *file, int32_t bootindex); | |
45a50b16 | 339 | |
51b58561 PB |
340 | /* This is the usual maximum in uboot, so if a uImage overflows this, it would |
341 | * overflow on real hardware too. */ | |
342 | #define UBOOT_MAX_GUNZIP_BYTES (64 << 20) | |
343 | ||
5fc983af AB |
344 | typedef struct RomGap { |
345 | hwaddr base; | |
346 | size_t size; | |
347 | } RomGap; | |
348 | ||
349 | /** | |
350 | * rom_find_largest_gap_between: return largest gap between ROMs in given range | |
351 | * | |
352 | * Given a range of addresses, this function finds the largest | |
353 | * contiguous subrange which has no ROMs loaded to it. That is, | |
354 | * it finds the biggest gap which is free for use for other things. | |
355 | */ | |
356 | RomGap rom_find_largest_gap_between(hwaddr base, size_t size); | |
357 | ||
ca20cf32 | 358 | #endif |