1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * efi_selftest_loadimage
4 *
5 * Copyright (c) 2019 Heinrich Schuchardt <xypron.glpk@gmx.de>
6 *
7 * This test checks the LoadImage and StartImage boot service.
8 *
9 * The efi_selftest_miniapp_exit.efi application is loaded via a file device
10 * path and started.
11 */
12
13 #include <efi_selftest.h>
14 /* Include containing the efi_selftest_miniapp_exit.efi application */
15 #include "efi_miniapp_file_image_exit.h"
16
17 /* Block size of compressed disk image */
18 #define COMPRESSED_DISK_IMAGE_BLOCK_SIZE 8
19
20 /* Binary logarithm of the block size */
21 #define LB_BLOCK_SIZE 9
22
23 #define FILE_NAME L"app.efi"
24 #define VOLUME_NAME L"EfiDisk"
25
26 static struct efi_boot_services *boottime;
27 static efi_handle_t handle_image;
28 static efi_handle_t handle_volume;
29
30 static const efi_guid_t guid_device_path = EFI_DEVICE_PATH_PROTOCOL_GUID;
31 static const efi_guid_t guid_simple_file_system_protocol =
32 EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_GUID;
33 static const efi_guid_t guid_file_info = EFI_FILE_INFO_GUID;
34 static const efi_guid_t guid_file_system_info = EFI_FILE_SYSTEM_INFO_GUID;
35
36 /* One 8 byte block of the compressed disk image */
37 struct line {
38 size_t addr;
39 char *line;
40 };
41
42 /* Compressed file image */
43 struct compressed_file_image {
44 size_t length;
45 struct line lines[];
46 };
47
48 /* File info including file name */
49 struct file_info {
50 struct efi_file_info info;
51 u16 file_name[sizeof(FILE_NAME)];
52 };
53
54 /* File system info including volume name */
55 struct file_system_info {
56 struct efi_file_system_info info;
57 u16 file_name[sizeof(VOLUME_NAME)];
58 };
59
60 /* Compressed file image */
61 static struct compressed_file_image img = EFI_ST_DISK_IMG;
62
63 /* Pointer to decompressed file image */
64 static u8 *image;
65
66 /* File info */
67 static struct file_info priv_file_info = {
68 {
69 .size = sizeof(struct file_info),
70 .attribute = EFI_FILE_READ_ONLY,
71 },
72 FILE_NAME,
73 };
74
75 /* Pointer to file info */
76 struct efi_file_info *file_info = &priv_file_info.info;
77
78 /* Volume device path */
79 static struct {
80 struct efi_device_path_vendor vendor;
81 struct efi_device_path end;
82 } __packed dp_volume = {
83 .vendor = {
84 .dp = {
85 .type = DEVICE_PATH_TYPE_HARDWARE_DEVICE,
86 .sub_type = DEVICE_PATH_SUB_TYPE_VENDOR,
87 .length = sizeof(struct efi_device_path_vendor),
88 },
89 .guid = EFI_GUID(0x4f9a0ebf, 0xa179, 0x88a6, 0x25, 0x68,
90 0x10, 0x72, 0xb1, 0x93, 0x51, 0x71),
91 },
92 .end = {
93 .type = DEVICE_PATH_TYPE_END,
94 .sub_type = DEVICE_PATH_SUB_TYPE_END,
95 .length = sizeof(struct efi_device_path),
96 }
97 };
98
99 /* File device path */
100 static struct {
101 struct efi_device_path_vendor vendor;
102 struct efi_device_path path;
103 u16 file[sizeof(FILE_NAME)];
104 struct efi_device_path end;
105 } __packed dp_file = {
106 .vendor = {
107 .dp = {
108 .type = DEVICE_PATH_TYPE_HARDWARE_DEVICE,
109 .sub_type = DEVICE_PATH_SUB_TYPE_VENDOR,
110 .length = sizeof(struct efi_device_path_vendor),
111 },
112 .guid = EFI_GUID(0x4f9a0ebf, 0xa179, 0x88a6, 0x25, 0x68,
113 0x10, 0x72, 0xb1, 0x93, 0x51, 0x71),
114 },
115 .path = {
116 .type = DEVICE_PATH_TYPE_MEDIA_DEVICE,
117 .sub_type = DEVICE_PATH_SUB_TYPE_FILE_PATH,
118 .length = sizeof(struct efi_device_path) + sizeof(dp_file.file),
119 },
120 .file = FILE_NAME,
121 .end = {
122 .type = DEVICE_PATH_TYPE_END,
123 .sub_type = DEVICE_PATH_SUB_TYPE_END,
124 .length = sizeof(struct efi_device_path),
125 }
126 };
127
128 /* File system info */
129 static struct file_system_info priv_file_system_info = {
130 {
131 .size = sizeof(struct file_system_info),
132 .read_only = true,
133 .volume_size = 0x100000,
134 .free_space = 0x0,
135 .block_size = 0x200,
136 },
137 VOLUME_NAME
138 };
139
140 /* Pointer to file system info */
141 static struct efi_file_system_info *file_system_info =
142 &priv_file_system_info.info;
143
144 /* Forward definitions of file and file system functions */
145 static efi_status_t EFIAPI open_volume
146 (struct efi_simple_file_system_protocol *this,
147 struct efi_file_handle **root);
148
149 static efi_status_t EFIAPI open
150 (struct efi_file_handle *this,
151 struct efi_file_handle **new_handle,
152 u16 *file_name, u64 open_mode, u64 attributes);
153
154 static efi_status_t EFIAPI close(struct efi_file_handle *this);
155
156 static efi_status_t EFIAPI delete(struct efi_file_handle *this);
157
158 static efi_status_t EFIAPI read
159 (struct efi_file_handle *this, efi_uintn_t *buffer_size, void *buffer);
160
161 static efi_status_t EFIAPI write
162 (struct efi_file_handle *this, efi_uintn_t *buffer_size, void *buffer);
163
164 static efi_status_t EFIAPI getpos(struct efi_file_handle *this, u64 *pos);
165
166 static efi_status_t EFIAPI setpos(struct efi_file_handle *this, u64 pos);
167
168 static efi_status_t EFIAPI getinfo
169 (struct efi_file_handle *this, const efi_guid_t *info_type,
170 efi_uintn_t *buffer_size, void *buffer);
171
172 static efi_status_t EFIAPI setinfo
173 (struct efi_file_handle *this, const efi_guid_t *info_type,
174 efi_uintn_t buffer_size, void *buffer);
175
176 static efi_status_t EFIAPI flush(struct efi_file_handle *this);
177
178 /* Internal information about status of file system */
179 static struct {
180 /* Difference of volume open count minus volume close count */
181 int volume_open_count;
182 /* Difference of file open count minus file close count */
183 int file_open_count;
184 /* File size */
185 u64 file_size;
186 /* Current position in file */
187 u64 file_pos;
188 } priv;
189
190 /* EFI_FILE_PROTOCOL for file */
191 static struct efi_file_handle file = {
192 .rev = 0x00010000,
193 .open = open,
194 .close = close,
195 .delete = delete,
196 .read = read,
197 .write = write,
198 .getpos = getpos,
199 .setpos = setpos,
200 .getinfo = getinfo,
201 .setinfo = setinfo,
202 .flush = flush,
203 };
204
205 /* EFI_FILE_PROTOCOL for root directory */
206 static struct efi_file_handle volume = {
207 .rev = 0x00010000,
208 .open = open,
209 .close = close,
210 .delete = delete,
211 .read = read,
212 .write = write,
213 .getpos = getpos,
214 .setpos = setpos,
215 .getinfo = getinfo,
216 .setinfo = setinfo,
217 .flush = flush,
218 };
219
220 /* EFI_SIMPLE_FILE_SYSTEM_PROTOCOL of the block device */
221 struct efi_simple_file_system_protocol file_system = {
222 .rev = 0x00010000,
223 .open_volume = open_volume,
224 };
225
open_volume(struct efi_simple_file_system_protocol * this,struct efi_file_handle ** root)226 static efi_status_t EFIAPI open_volume
227 (struct efi_simple_file_system_protocol *this,
228 struct efi_file_handle **root)
229 {
230 if (this != &file_system || !root)
231 return EFI_INVALID_PARAMETER;
232
233 *root = &volume;
234 priv.volume_open_count++;
235
236 return EFI_SUCCESS;
237 }
238
open(struct efi_file_handle * this,struct efi_file_handle ** new_handle,u16 * file_name,u64 open_mode,u64 attributes)239 static efi_status_t EFIAPI open
240 (struct efi_file_handle *this,
241 struct efi_file_handle **new_handle,
242 u16 *file_name, u64 open_mode, u64 attributes)
243 {
244 if (this != &volume)
245 return EFI_INVALID_PARAMETER;
246
247 *new_handle = &file;
248 priv.file_pos = 0;
249 priv.file_open_count++;
250
251 return EFI_SUCCESS;
252 }
253
close(struct efi_file_handle * this)254 static efi_status_t EFIAPI close(struct efi_file_handle *this)
255 {
256 if (this == &file)
257 priv.file_open_count--;
258 else if (this == &volume)
259 priv.volume_open_count--;
260 else
261 return EFI_INVALID_PARAMETER;
262
263 return EFI_SUCCESS;
264 }
265
delete(struct efi_file_handle * this)266 static efi_status_t EFIAPI delete(struct efi_file_handle *this)
267 {
268 if (this != &file)
269 return EFI_INVALID_PARAMETER;
270
271 return EFI_UNSUPPORTED;
272 }
273
read(struct efi_file_handle * this,efi_uintn_t * buffer_size,void * buffer)274 static efi_status_t EFIAPI read
275 (struct efi_file_handle *this, efi_uintn_t *buffer_size, void *buffer)
276 {
277 if (this != &file)
278 return EFI_INVALID_PARAMETER;
279
280 if (priv.file_pos >= img.length)
281 *buffer_size = 0;
282 else if (priv.file_pos + *buffer_size > img.length)
283 *buffer_size = img.length - priv.file_pos;
284
285 boottime->copy_mem(buffer, &image[priv.file_pos], *buffer_size);
286 priv.file_pos += *buffer_size;
287
288 return EFI_SUCCESS;
289 }
290
write(struct efi_file_handle * this,efi_uintn_t * buffer_size,void * buffer)291 static efi_status_t EFIAPI write
292 (struct efi_file_handle *this, efi_uintn_t *buffer_size, void *buffer)
293 {
294 if (this != &file)
295 return EFI_INVALID_PARAMETER;
296
297 return EFI_UNSUPPORTED;
298 }
299
getpos(struct efi_file_handle * this,u64 * pos)300 static efi_status_t EFIAPI getpos(struct efi_file_handle *this, u64 *pos)
301 {
302 if (this != &file)
303 return EFI_INVALID_PARAMETER;
304
305 *pos = priv.file_pos;
306
307 return EFI_SUCCESS;
308 }
309
setpos(struct efi_file_handle * this,u64 pos)310 static efi_status_t EFIAPI setpos(struct efi_file_handle *this, u64 pos)
311 {
312 if (this != &file)
313 return EFI_INVALID_PARAMETER;
314
315 priv.file_pos = pos;
316
317 return EFI_SUCCESS;
318 }
319
getinfo(struct efi_file_handle * this,const efi_guid_t * info_type,efi_uintn_t * buffer_size,void * buffer)320 static efi_status_t EFIAPI getinfo
321 (struct efi_file_handle *this, const efi_guid_t *info_type,
322 efi_uintn_t *buffer_size, void *buffer)
323 {
324 if (this == &file) {
325 if (memcmp(info_type, &guid_file_info, sizeof(efi_guid_t)))
326 return EFI_INVALID_PARAMETER;
327 if (*buffer_size >= sizeof(struct file_info)) {
328 boottime->copy_mem(buffer, file_info,
329 sizeof(struct file_info));
330 } else {
331 *buffer_size = sizeof(struct file_info);
332 return EFI_BUFFER_TOO_SMALL;
333 }
334 } else if (this == &volume) {
335 if (memcmp(info_type, &guid_file_system_info,
336 sizeof(efi_guid_t)))
337 return EFI_INVALID_PARAMETER;
338 if (*buffer_size >= sizeof(struct file_system_info)) {
339 boottime->copy_mem(buffer, file_system_info,
340 sizeof(struct file_system_info));
341 } else {
342 *buffer_size = sizeof(struct file_system_info);
343 return EFI_BUFFER_TOO_SMALL;
344 }
345 } else {
346 return EFI_INVALID_PARAMETER;
347 }
348 return EFI_SUCCESS;
349 }
350
setinfo(struct efi_file_handle * this,const efi_guid_t * info_type,efi_uintn_t buffer_size,void * buffer)351 static efi_status_t EFIAPI setinfo
352 (struct efi_file_handle *this, const efi_guid_t *info_type,
353 efi_uintn_t buffer_size, void *buffer)
354 {
355 if (this != &file)
356 return EFI_INVALID_PARAMETER;
357
358 return EFI_UNSUPPORTED;
359 }
360
flush(struct efi_file_handle * this)361 static efi_status_t EFIAPI flush(struct efi_file_handle *this)
362 {
363 if (this != &file)
364 return EFI_INVALID_PARAMETER;
365
366 return EFI_UNSUPPORTED;
367 }
368
369 /*
370 * Decompress the disk image.
371 *
372 * @image decompressed disk image
373 * @return status code
374 */
decompress(u8 ** image)375 static efi_status_t decompress(u8 **image)
376 {
377 u8 *buf;
378 size_t i;
379 size_t addr;
380 size_t len;
381 efi_status_t ret;
382
383 ret = boottime->allocate_pool(EFI_LOADER_DATA, img.length,
384 (void **)&buf);
385 if (ret != EFI_SUCCESS) {
386 efi_st_error("Out of memory\n");
387 return ret;
388 }
389 boottime->set_mem(buf, img.length, 0);
390
391 for (i = 0; ; ++i) {
392 if (!img.lines[i].line)
393 break;
394 addr = img.lines[i].addr;
395 len = COMPRESSED_DISK_IMAGE_BLOCK_SIZE;
396 if (addr + len > img.length)
397 len = img.length - addr;
398 boottime->copy_mem(buf + addr, img.lines[i].line, len);
399 }
400 *image = buf;
401 priv.file_size = img.length;
402 file_info->file_size = img.length;
403 return ret;
404 }
405
406 /*
407 * Setup unit test.
408 *
409 * Decompress application image and provide a handle for the in memory block
410 * device.
411 *
412 * @handle: handle of the loaded image
413 * @systable: system table
414 * @return: EFI_ST_SUCCESS for success
415 */
setup(const efi_handle_t handle,const struct efi_system_table * systable)416 static int setup(const efi_handle_t handle,
417 const struct efi_system_table *systable)
418 {
419 efi_status_t ret;
420
421 handle_image = handle;
422 boottime = systable->boottime;
423
424 /* Load the application image into memory */
425 decompress(&image);
426
427 ret = boottime->install_protocol_interface
428 (&handle_volume, &guid_device_path, EFI_NATIVE_INTERFACE,
429 &dp_volume);
430 if (ret != EFI_SUCCESS) {
431 efi_st_error("Failed to install device path\n");
432 return EFI_ST_FAILURE;
433 }
434 ret = boottime->install_protocol_interface
435 (&handle_volume, &guid_simple_file_system_protocol,
436 EFI_NATIVE_INTERFACE, &file_system);
437 if (ret != EFI_SUCCESS) {
438 efi_st_error("Failed to install simple file system protocol\n");
439 return EFI_ST_FAILURE;
440 }
441
442 return EFI_ST_SUCCESS;
443 }
444
445 /*
446 * Tear down unit test.
447 *
448 * Uninstall protocols and free memory.
449 *
450 * @return: EFI_ST_SUCCESS for success
451 */
teardown(void)452 static int teardown(void)
453 {
454 efi_status_t ret = EFI_ST_SUCCESS;
455
456 if (handle_volume) {
457 ret = boottime->uninstall_protocol_interface
458 (handle_volume, &guid_simple_file_system_protocol,
459 &file_system);
460 if (ret != EFI_SUCCESS) {
461 efi_st_error
462 ("Failed to uninstall simple file system protocol\n");
463 return EFI_ST_FAILURE;
464 }
465 ret = boottime->uninstall_protocol_interface
466 (handle_volume, &guid_device_path, &dp_volume);
467 if (ret != EFI_SUCCESS) {
468 efi_st_error
469 ("Failed to uninstall device path protocol\n");
470 return EFI_ST_FAILURE;
471 }
472 }
473
474 if (image) {
475 ret = boottime->free_pool(image);
476 if (ret != EFI_SUCCESS) {
477 efi_st_error("Failed to free image\n");
478 return EFI_ST_FAILURE;
479 }
480 }
481 return ret;
482 }
483
484 /*
485 * Execute unit test.
486 *
487 * Load and start the application image.
488 *
489 * @return: EFI_ST_SUCCESS for success
490 */
execute(void)491 static int execute(void)
492 {
493 efi_status_t ret;
494 efi_handle_t handle;
495
496 ret = boottime->load_image(false, handle_image, &dp_file.vendor.dp,
497 NULL, 0, &handle);
498 if (ret != EFI_SUCCESS) {
499 efi_st_error("Failed to load image\n");
500 return EFI_ST_FAILURE;
501 }
502 ret = boottime->start_image(handle, NULL, NULL);
503 if (ret != EFI_UNSUPPORTED) {
504 efi_st_error("Wrong return value from application\n");
505 return EFI_ST_FAILURE;
506 }
507
508 if (priv.file_open_count) {
509 efi_st_error("File open count = %d, expected 0\n",
510 priv.file_open_count);
511 return EFI_ST_FAILURE;
512 }
513 if (priv.volume_open_count) {
514 efi_st_error("Volume open count = %d, expected 0\n",
515 priv.volume_open_count);
516 return EFI_ST_FAILURE;
517 }
518
519 return EFI_ST_SUCCESS;
520 }
521
522 EFI_UNIT_TEST(loadimage) = {
523 .name = "load image from file",
524 .phase = EFI_EXECUTE_BEFORE_BOOTTIME_EXIT,
525 .setup = setup,
526 .execute = execute,
527 .teardown = teardown,
528 };
529