1 | #ifndef LOADER_H |
2 | #define LOADER_H |
3 | #include "hw/nvram/fw_cfg.h" |
4 | |
5 | /* loader.c */ |
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 | */ |
13 | int64_t get_image_size(const char *filename); |
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 | */ |
30 | ssize_t load_image_size(const char *filename, void *addr, size_t size); |
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 | */ |
43 | int load_image_targphys_as(const char *filename, |
44 | hwaddr addr, uint64_t max_sz, AddressSpace *as); |
45 | |
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 | */ |
56 | int load_targphys_hex_as(const char *filename, hwaddr *entry, AddressSpace *as); |
57 | |
58 | /** load_image_targphys: |
59 | * Same as load_image_targphys_as(), but doesn't allow the caller to specify |
60 | * an AddressSpace. |
61 | */ |
62 | int load_image_targphys(const char *filename, hwaddr, |
63 | uint64_t max_sz); |
64 | |
65 | /** |
66 | * load_image_mr: load an image into a memory region |
67 | * @filename: Path to the image file |
68 | * @mr: Memory Region to load into |
69 | * |
70 | * Load the specified file into the memory region. |
71 | * The file loaded is registered as a ROM, so its contents will be |
72 | * reinstated whenever the system is reset. |
73 | * If the file is larger than the memory region's size the call will fail. |
74 | * Returns -1 on failure, or the size of the file. |
75 | */ |
76 | int load_image_mr(const char *filename, MemoryRegion *mr); |
77 | |
78 | /* This is the limit on the maximum uncompressed image size that |
79 | * load_image_gzipped_buffer() and load_image_gzipped() will read. It prevents |
80 | * g_malloc() in those functions from allocating a huge amount of memory. |
81 | */ |
82 | #define LOAD_IMAGE_MAX_GUNZIP_BYTES (256 << 20) |
83 | |
84 | int load_image_gzipped_buffer(const char *filename, uint64_t max_sz, |
85 | uint8_t **buffer); |
86 | int load_image_gzipped(const char *filename, hwaddr addr, uint64_t max_sz); |
87 | |
88 | #define ELF_LOAD_FAILED -1 |
89 | #define ELF_LOAD_NOT_ELF -2 |
90 | #define ELF_LOAD_WRONG_ARCH -3 |
91 | #define ELF_LOAD_WRONG_ENDIAN -4 |
92 | const char *load_elf_strerror(int error); |
93 | |
94 | /** load_elf_ram_sym: |
95 | * @filename: Path of ELF file |
96 | * @elf_note_fn: optional function to parse ELF Note type |
97 | * passed via @translate_opaque |
98 | * @translate_fn: optional function to translate load addresses |
99 | * @translate_opaque: opaque data passed to @translate_fn |
100 | * @pentry: Populated with program entry point. Ignored if NULL. |
101 | * @lowaddr: Populated with lowest loaded address. Ignored if NULL. |
102 | * @highaddr: Populated with highest loaded address. Ignored if NULL. |
103 | * @bigendian: Expected ELF endianness. 0 for LE otherwise BE |
104 | * @elf_machine: Expected ELF machine type |
105 | * @clear_lsb: Set to mask off LSB of addresses (Some architectures use |
106 | * this for non-address data) |
107 | * @data_swab: Set to order of byte swapping for data. 0 for no swap, 1 |
108 | * for swapping bytes within halfwords, 2 for bytes within |
109 | * words and 3 for within doublewords. |
110 | * @as: The AddressSpace to load the ELF to. The value of address_space_memory |
111 | * is used if nothing is supplied here. |
112 | * @load_rom : Load ELF binary as ROM |
113 | * @sym_cb: Callback function for symbol table entries |
114 | * |
115 | * Load an ELF file's contents to the emulated system's address space. |
116 | * Clients may optionally specify a callback to perform address |
117 | * translations. @pentry, @lowaddr and @highaddr are optional pointers |
118 | * which will be populated with various load information. @bigendian and |
119 | * @elf_machine give the expected endianness and machine for the ELF the |
120 | * load will fail if the target ELF does not match. Some architectures |
121 | * have some architecture-specific behaviours that come into effect when |
122 | * their particular values for @elf_machine are set. |
123 | * If @elf_machine is EM_NONE then the machine type will be read from the |
124 | * ELF header and no checks will be carried out against the machine type. |
125 | */ |
126 | typedef void (*symbol_fn_t)(const char *st_name, int st_info, |
127 | uint64_t st_value, uint64_t st_size); |
128 | |
129 | int load_elf_ram_sym(const char *filename, |
130 | uint64_t (*elf_note_fn)(void *, void *, bool), |
131 | uint64_t (*translate_fn)(void *, uint64_t), |
132 | void *translate_opaque, uint64_t *pentry, |
133 | uint64_t *lowaddr, uint64_t *highaddr, int big_endian, |
134 | int elf_machine, int clear_lsb, int data_swab, |
135 | AddressSpace *as, bool load_rom, symbol_fn_t sym_cb); |
136 | |
137 | /** load_elf_ram: |
138 | * Same as load_elf_ram_sym(), but doesn't allow the caller to specify a |
139 | * symbol callback function |
140 | */ |
141 | int load_elf_ram(const char *filename, |
142 | uint64_t (*elf_note_fn)(void *, void *, bool), |
143 | uint64_t (*translate_fn)(void *, uint64_t), |
144 | void *translate_opaque, uint64_t *pentry, uint64_t *lowaddr, |
145 | uint64_t *highaddr, int big_endian, int elf_machine, |
146 | int clear_lsb, int data_swab, AddressSpace *as, |
147 | bool load_rom); |
148 | |
149 | /** load_elf_as: |
150 | * Same as load_elf_ram(), but always loads the elf as ROM |
151 | */ |
152 | int load_elf_as(const char *filename, |
153 | uint64_t (*elf_note_fn)(void *, void *, bool), |
154 | uint64_t (*translate_fn)(void *, uint64_t), |
155 | void *translate_opaque, uint64_t *pentry, uint64_t *lowaddr, |
156 | uint64_t *highaddr, int big_endian, int elf_machine, |
157 | int clear_lsb, int data_swab, AddressSpace *as); |
158 | |
159 | /** load_elf: |
160 | * Same as load_elf_as(), but doesn't allow the caller to specify an |
161 | * AddressSpace. |
162 | */ |
163 | int load_elf(const char *filename, |
164 | uint64_t (*elf_note_fn)(void *, void *, bool), |
165 | uint64_t (*translate_fn)(void *, uint64_t), |
166 | void *translate_opaque, uint64_t *pentry, uint64_t *lowaddr, |
167 | uint64_t *highaddr, int big_endian, int elf_machine, |
168 | int clear_lsb, int data_swab); |
169 | |
170 | /** load_elf_hdr: |
171 | * @filename: Path of ELF file |
172 | * @hdr: Buffer to populate with header data. Header data will not be |
173 | * filled if set to NULL. |
174 | * @is64: Set to true if the ELF is 64bit. Ignored if set to NULL |
175 | * @errp: Populated with an error in failure cases |
176 | * |
177 | * Inspect an ELF file's header. Read its full header contents into a |
178 | * buffer and/or determine if the ELF is 64bit. |
179 | */ |
180 | void load_elf_hdr(const char *filename, void *hdr, bool *is64, Error **errp); |
181 | |
182 | int load_aout(const char *filename, hwaddr addr, int max_sz, |
183 | int bswap_needed, hwaddr target_page_size); |
184 | |
185 | #define LOAD_UIMAGE_LOADADDR_INVALID (-1) |
186 | |
187 | /** load_uimage_as: |
188 | * @filename: Path of uimage file |
189 | * @ep: Populated with program entry point. Ignored if NULL. |
190 | * @loadaddr: load address if none specified in the image or when loading a |
191 | * ramdisk. Populated with the load address. Ignored if NULL or |
192 | * LOAD_UIMAGE_LOADADDR_INVALID (images which do not specify a load |
193 | * address will not be loadable). |
194 | * @is_linux: Is set to true if the image loaded is Linux. Ignored if NULL. |
195 | * @translate_fn: optional function to translate load addresses |
196 | * @translate_opaque: opaque data passed to @translate_fn |
197 | * @as: The AddressSpace to load the ELF to. The value of address_space_memory |
198 | * is used if nothing is supplied here. |
199 | * |
200 | * Loads a u-boot image into memory. |
201 | * |
202 | * Returns the size of the loaded image on success, -1 otherwise. |
203 | */ |
204 | int load_uimage_as(const char *filename, hwaddr *ep, |
205 | hwaddr *loadaddr, int *is_linux, |
206 | uint64_t (*translate_fn)(void *, uint64_t), |
207 | void *translate_opaque, AddressSpace *as); |
208 | |
209 | /** load_uimage: |
210 | * Same as load_uimage_as(), but doesn't allow the caller to specify an |
211 | * AddressSpace. |
212 | */ |
213 | int load_uimage(const char *filename, hwaddr *ep, |
214 | hwaddr *loadaddr, int *is_linux, |
215 | uint64_t (*translate_fn)(void *, uint64_t), |
216 | void *translate_opaque); |
217 | |
218 | /** |
219 | * load_ramdisk_as: |
220 | * @filename: Path to the ramdisk image |
221 | * @addr: Memory address to load the ramdisk to |
222 | * @max_sz: Maximum allowed ramdisk size (for non-u-boot ramdisks) |
223 | * @as: The AddressSpace to load the ELF to. The value of address_space_memory |
224 | * is used if nothing is supplied here. |
225 | * |
226 | * Load a ramdisk image with U-Boot header to the specified memory |
227 | * address. |
228 | * |
229 | * Returns the size of the loaded image on success, -1 otherwise. |
230 | */ |
231 | int load_ramdisk_as(const char *filename, hwaddr addr, uint64_t max_sz, |
232 | AddressSpace *as); |
233 | |
234 | /** |
235 | * load_ramdisk: |
236 | * Same as load_ramdisk_as(), but doesn't allow the caller to specify |
237 | * an AddressSpace. |
238 | */ |
239 | int load_ramdisk(const char *filename, hwaddr addr, uint64_t max_sz); |
240 | |
241 | ssize_t gunzip(void *dst, size_t dstlen, uint8_t *src, size_t srclen); |
242 | |
243 | ssize_t read_targphys(const char *name, |
244 | int fd, hwaddr dst_addr, size_t nbytes); |
245 | void pstrcpy_targphys(const char *name, |
246 | hwaddr dest, int buf_size, |
247 | const char *source); |
248 | |
249 | extern bool option_rom_has_mr; |
250 | extern bool rom_file_has_mr; |
251 | |
252 | int rom_add_file(const char *file, const char *fw_dir, |
253 | hwaddr addr, int32_t bootindex, |
254 | bool option_rom, MemoryRegion *mr, AddressSpace *as); |
255 | MemoryRegion *rom_add_blob(const char *name, const void *blob, size_t len, |
256 | size_t max_len, hwaddr addr, |
257 | const char *fw_file_name, |
258 | FWCfgCallback fw_callback, |
259 | void *callback_opaque, AddressSpace *as, |
260 | bool read_only); |
261 | int rom_add_elf_program(const char *name, GMappedFile *mapped_file, void *data, |
262 | size_t datasize, size_t romsize, hwaddr addr, |
263 | AddressSpace *as); |
264 | int rom_check_and_register_reset(void); |
265 | void rom_set_fw(FWCfgState *f); |
266 | void rom_set_order_override(int order); |
267 | void rom_reset_order_override(void); |
268 | |
269 | /** |
270 | * rom_transaction_begin: |
271 | * |
272 | * Call this before of a series of rom_add_*() calls. Call |
273 | * rom_transaction_end() afterwards to commit or abort. These functions are |
274 | * useful for undoing a series of rom_add_*() calls if image file loading fails |
275 | * partway through. |
276 | */ |
277 | void rom_transaction_begin(void); |
278 | |
279 | /** |
280 | * rom_transaction_end: |
281 | * @commit: true to commit added roms, false to drop added roms |
282 | * |
283 | * Call this after a series of rom_add_*() calls. See rom_transaction_begin(). |
284 | */ |
285 | void rom_transaction_end(bool commit); |
286 | |
287 | int rom_copy(uint8_t *dest, hwaddr addr, size_t size); |
288 | void *rom_ptr(hwaddr addr, size_t size); |
289 | void hmp_info_roms(Monitor *mon, const QDict *qdict); |
290 | |
291 | #define rom_add_file_fixed(_f, _a, _i) \ |
292 | rom_add_file(_f, NULL, _a, _i, false, NULL, NULL) |
293 | #define rom_add_blob_fixed(_f, _b, _l, _a) \ |
294 | rom_add_blob(_f, _b, _l, _l, _a, NULL, NULL, NULL, NULL, true) |
295 | #define rom_add_file_mr(_f, _mr, _i) \ |
296 | rom_add_file(_f, NULL, 0, _i, false, _mr, NULL) |
297 | #define rom_add_file_as(_f, _as, _i) \ |
298 | rom_add_file(_f, NULL, 0, _i, false, NULL, _as) |
299 | #define rom_add_file_fixed_as(_f, _a, _i, _as) \ |
300 | rom_add_file(_f, NULL, _a, _i, false, NULL, _as) |
301 | #define rom_add_blob_fixed_as(_f, _b, _l, _a, _as) \ |
302 | rom_add_blob(_f, _b, _l, _l, _a, NULL, NULL, NULL, _as, true) |
303 | |
304 | #define PC_ROM_MIN_VGA 0xc0000 |
305 | #define PC_ROM_MIN_OPTION 0xc8000 |
306 | #define PC_ROM_MAX 0xe0000 |
307 | #define PC_ROM_ALIGN 0x800 |
308 | #define PC_ROM_SIZE (PC_ROM_MAX - PC_ROM_MIN_VGA) |
309 | |
310 | int rom_add_vga(const char *file); |
311 | int rom_add_option(const char *file, int32_t bootindex); |
312 | |
313 | /* This is the usual maximum in uboot, so if a uImage overflows this, it would |
314 | * overflow on real hardware too. */ |
315 | #define UBOOT_MAX_GUNZIP_BYTES (64 << 20) |
316 | |
317 | #endif |
318 | |