blob: b82e405030246e92bce68b0e0d56728206087517 [file] [log] [blame]
Tom Rini10e47792018-05-06 17:58:06 -04001// SPDX-License-Identifier: GPL-2.0+
Heinrich Schuchardtd322f922018-01-21 19:29:31 +01002/*
3 * efi_selftest_block
4 *
5 * Copyright (c) 2017 Heinrich Schuchardt <xypron.glpk@gmx.de>
6 *
Heinrich Schuchardtd322f922018-01-21 19:29:31 +01007 * This test checks the driver for block IO devices.
8 * A disk image is created in memory.
9 * A handle is created for the new block IO device.
10 * The block I/O protocol is installed on the handle.
11 * ConnectController is used to setup partitions and to install the simple
12 * file protocol.
13 * A known file is read from the file system and verified.
14 */
15
16#include <efi_selftest.h>
17#include "efi_selftest_disk_image.h"
18
19/* Block size of compressed disk image */
20#define COMPRESSED_DISK_IMAGE_BLOCK_SIZE 8
21
22/* Binary logarithm of the block size */
23#define LB_BLOCK_SIZE 9
24
25static struct efi_boot_services *boottime;
26
27static const efi_guid_t block_io_protocol_guid = BLOCK_IO_GUID;
28static const efi_guid_t guid_device_path = DEVICE_PATH_GUID;
29static const efi_guid_t guid_simple_file_system_protocol =
30 EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_GUID;
Heinrich Schuchardtb6f15e92018-04-04 15:42:13 +020031static const efi_guid_t guid_file_system_info = EFI_FILE_SYSTEM_INFO_GUID;
Heinrich Schuchardtd322f922018-01-21 19:29:31 +010032static efi_guid_t guid_vendor =
33 EFI_GUID(0xdbca4c98, 0x6cb0, 0x694d,
34 0x08, 0x72, 0x81, 0x9c, 0x65, 0x0c, 0xb7, 0xb8);
35
36static struct efi_device_path *dp;
37
38/* One 8 byte block of the compressed disk image */
39struct line {
40 size_t addr;
41 char *line;
42};
43
44/* Compressed disk image */
45struct compressed_disk_image {
46 size_t length;
47 struct line lines[];
48};
49
50static const struct compressed_disk_image img = EFI_ST_DISK_IMG;
51
52/* Decompressed disk image */
53static u8 *image;
54
55/*
56 * Reset service of the block IO protocol.
57 *
58 * @this block IO protocol
59 * @return status code
60 */
61static efi_status_t EFIAPI reset(
62 struct efi_block_io *this,
63 char extended_verification)
64{
65 return EFI_SUCCESS;
66}
67
68/*
69 * Read service of the block IO protocol.
70 *
71 * @this block IO protocol
72 * @media_id media id
73 * @lba start of the read in logical blocks
74 * @buffer_size number of bytes to read
75 * @buffer target buffer
76 * @return status code
77 */
78static efi_status_t EFIAPI read_blocks(
79 struct efi_block_io *this, u32 media_id, u64 lba,
80 efi_uintn_t buffer_size, void *buffer)
81{
82 u8 *start;
83
84 if ((lba << LB_BLOCK_SIZE) + buffer_size > img.length)
85 return EFI_INVALID_PARAMETER;
86 start = image + (lba << LB_BLOCK_SIZE);
87
88 boottime->copy_mem(buffer, start, buffer_size);
89
90 return EFI_SUCCESS;
91}
92
93/*
94 * Write service of the block IO protocol.
95 *
96 * @this block IO protocol
97 * @media_id media id
98 * @lba start of the write in logical blocks
99 * @buffer_size number of bytes to read
100 * @buffer source buffer
101 * @return status code
102 */
103static efi_status_t EFIAPI write_blocks(
104 struct efi_block_io *this, u32 media_id, u64 lba,
105 efi_uintn_t buffer_size, void *buffer)
106{
107 u8 *start;
108
109 if ((lba << LB_BLOCK_SIZE) + buffer_size > img.length)
110 return EFI_INVALID_PARAMETER;
111 start = image + (lba << LB_BLOCK_SIZE);
112
113 boottime->copy_mem(start, buffer, buffer_size);
114
115 return EFI_SUCCESS;
116}
117
118/*
119 * Flush service of the block IO protocol.
120 *
121 * @this block IO protocol
122 * @return status code
123 */
124static efi_status_t EFIAPI flush_blocks(struct efi_block_io *this)
125{
126 return EFI_SUCCESS;
127}
128
129/*
130 * Decompress the disk image.
131 *
132 * @image decompressed disk image
133 * @return status code
134 */
135static efi_status_t decompress(u8 **image)
136{
137 u8 *buf;
138 size_t i;
139 size_t addr;
140 size_t len;
141 efi_status_t ret;
142
143 ret = boottime->allocate_pool(EFI_LOADER_DATA, img.length,
144 (void **)&buf);
145 if (ret != EFI_SUCCESS) {
146 efi_st_error("Out of memory\n");
147 return ret;
148 }
149 boottime->set_mem(buf, img.length, 0);
150
151 for (i = 0; ; ++i) {
152 if (!img.lines[i].line)
153 break;
154 addr = img.lines[i].addr;
155 len = COMPRESSED_DISK_IMAGE_BLOCK_SIZE;
156 if (addr + len > img.length)
157 len = img.length - addr;
158 boottime->copy_mem(buf + addr, img.lines[i].line, len);
159 }
160 *image = buf;
161 return ret;
162}
163
164static struct efi_block_io_media media;
165
166static struct efi_block_io block_io = {
167 .media = &media,
168 .reset = reset,
169 .read_blocks = read_blocks,
170 .write_blocks = write_blocks,
171 .flush_blocks = flush_blocks,
172};
173
174/* Handle for the block IO device */
175static efi_handle_t disk_handle;
176
177/*
178 * Setup unit test.
179 *
180 * @handle: handle of the loaded image
181 * @systable: system table
182 * @return: EFI_ST_SUCCESS for success
183 */
184static int setup(const efi_handle_t handle,
185 const struct efi_system_table *systable)
186{
187 efi_status_t ret;
188 struct efi_device_path_vendor vendor_node;
189 struct efi_device_path end_node;
190
191 boottime = systable->boottime;
192
193 decompress(&image);
194
195 block_io.media->block_size = 1 << LB_BLOCK_SIZE;
196 block_io.media->last_block = img.length >> LB_BLOCK_SIZE;
197
198 ret = boottime->install_protocol_interface(
199 &disk_handle, &block_io_protocol_guid,
200 EFI_NATIVE_INTERFACE, &block_io);
201 if (ret != EFI_SUCCESS) {
202 efi_st_error("Failed to install block I/O protocol\n");
203 return EFI_ST_FAILURE;
204 }
205
206 ret = boottime->allocate_pool(EFI_LOADER_DATA,
207 sizeof(struct efi_device_path_vendor) +
208 sizeof(struct efi_device_path),
209 (void **)&dp);
210 if (ret != EFI_SUCCESS) {
211 efi_st_error("Out of memory\n");
212 return EFI_ST_FAILURE;
213 }
214 vendor_node.dp.type = DEVICE_PATH_TYPE_HARDWARE_DEVICE;
215 vendor_node.dp.sub_type = DEVICE_PATH_SUB_TYPE_VENDOR;
216 vendor_node.dp.length = sizeof(struct efi_device_path_vendor);
217
218 boottime->copy_mem(&vendor_node.guid, &guid_vendor,
219 sizeof(efi_guid_t));
220 boottime->copy_mem(dp, &vendor_node,
221 sizeof(struct efi_device_path_vendor));
222 end_node.type = DEVICE_PATH_TYPE_END;
223 end_node.sub_type = DEVICE_PATH_SUB_TYPE_END;
224 end_node.length = sizeof(struct efi_device_path);
225
226 boottime->copy_mem((char *)dp + sizeof(struct efi_device_path_vendor),
227 &end_node, sizeof(struct efi_device_path));
228 ret = boottime->install_protocol_interface(&disk_handle,
229 &guid_device_path,
230 EFI_NATIVE_INTERFACE,
231 dp);
232 if (ret != EFI_SUCCESS) {
233 efi_st_error("InstallProtocolInterface failed\n");
234 return EFI_ST_FAILURE;
235 }
236 return EFI_ST_SUCCESS;
237}
238
239/*
240 * Tear down unit test.
241 *
242 * @return: EFI_ST_SUCCESS for success
243 */
244static int teardown(void)
245{
246 efi_status_t r = EFI_ST_SUCCESS;
247
248 if (disk_handle) {
249 r = boottime->uninstall_protocol_interface(disk_handle,
250 &guid_device_path,
251 dp);
252 if (r != EFI_SUCCESS) {
253 efi_st_error("Uninstall device path failed\n");
254 return EFI_ST_FAILURE;
255 }
256 r = boottime->uninstall_protocol_interface(
257 disk_handle, &block_io_protocol_guid,
258 &block_io);
259 if (r != EFI_SUCCESS) {
260 efi_st_todo(
261 "Failed to uninstall block I/O protocol\n");
262 return EFI_ST_SUCCESS;
263 }
264 }
265
266 if (image) {
267 r = efi_free_pool(image);
268 if (r != EFI_SUCCESS) {
269 efi_st_error("Failed to free image\n");
270 return EFI_ST_FAILURE;
271 }
272 }
273 return r;
274}
275
276/*
277 * Get length of device path without end tag.
278 *
279 * @dp device path
280 * @return length of device path in bytes
281 */
282static efi_uintn_t dp_size(struct efi_device_path *dp)
283{
284 struct efi_device_path *pos = dp;
285
286 while (pos->type != DEVICE_PATH_TYPE_END)
287 pos = (struct efi_device_path *)((char *)pos + pos->length);
288 return (char *)pos - (char *)dp;
289}
290
291/*
292 * Execute unit test.
293 *
294 * @return: EFI_ST_SUCCESS for success
295 */
296static int execute(void)
297{
298 efi_status_t ret;
299 efi_uintn_t no_handles, i, len;
300 efi_handle_t *handles;
301 efi_handle_t handle_partition = NULL;
302 struct efi_device_path *dp_partition;
303 struct efi_simple_file_system_protocol *file_system;
304 struct efi_file_handle *root, *file;
Heinrich Schuchardtb6f15e92018-04-04 15:42:13 +0200305 struct {
306 struct efi_file_system_info info;
307 u16 label[12];
308 } system_info;
Heinrich Schuchardt6b06e0d2018-04-03 22:37:11 +0200309 efi_uintn_t buf_size;
Heinrich Schuchardtd322f922018-01-21 19:29:31 +0100310 char buf[16] __aligned(ARCH_DMA_MINALIGN);
311
Heinrich Schuchardt76bc73c2018-07-02 02:41:24 +0200312 /* Connect controller to virtual disk */
Heinrich Schuchardtd322f922018-01-21 19:29:31 +0100313 ret = boottime->connect_controller(disk_handle, NULL, NULL, 1);
314 if (ret != EFI_SUCCESS) {
315 efi_st_error("Failed to connect controller\n");
316 return EFI_ST_FAILURE;
317 }
Heinrich Schuchardt76bc73c2018-07-02 02:41:24 +0200318
319 /* Get the handle for the partition */
Heinrich Schuchardtd322f922018-01-21 19:29:31 +0100320 ret = boottime->locate_handle_buffer(
321 BY_PROTOCOL, &guid_device_path, NULL,
322 &no_handles, &handles);
323 if (ret != EFI_SUCCESS) {
324 efi_st_error("Failed to locate handles\n");
325 return EFI_ST_FAILURE;
326 }
327 len = dp_size(dp);
328 for (i = 0; i < no_handles; ++i) {
329 ret = boottime->open_protocol(handles[i], &guid_device_path,
330 (void **)&dp_partition,
331 NULL, NULL,
332 EFI_OPEN_PROTOCOL_GET_PROTOCOL);
333 if (ret != EFI_SUCCESS) {
334 efi_st_error("Failed to open device path protocol\n");
335 return EFI_ST_FAILURE;
336 }
337 if (len >= dp_size(dp_partition))
338 continue;
339 if (efi_st_memcmp(dp, dp_partition, len))
340 continue;
341 handle_partition = handles[i];
342 break;
343 }
344 ret = boottime->free_pool(handles);
345 if (ret != EFI_SUCCESS) {
346 efi_st_error("Failed to free pool memory\n");
347 return EFI_ST_FAILURE;
348 }
349 if (!handle_partition) {
350 efi_st_error("Partition handle not found\n");
351 return EFI_ST_FAILURE;
352 }
Heinrich Schuchardt76bc73c2018-07-02 02:41:24 +0200353
354 /* Open the simple file system protocol */
Heinrich Schuchardtd322f922018-01-21 19:29:31 +0100355 ret = boottime->open_protocol(handle_partition,
356 &guid_simple_file_system_protocol,
357 (void **)&file_system, NULL, NULL,
358 EFI_OPEN_PROTOCOL_GET_PROTOCOL);
359 if (ret != EFI_SUCCESS) {
360 efi_st_error("Failed to open simple file system protocol\n");
361 return EFI_ST_FAILURE;
362 }
Heinrich Schuchardt76bc73c2018-07-02 02:41:24 +0200363
364 /* Open volume */
Heinrich Schuchardtd322f922018-01-21 19:29:31 +0100365 ret = file_system->open_volume(file_system, &root);
366 if (ret != EFI_SUCCESS) {
367 efi_st_error("Failed to open volume\n");
368 return EFI_ST_FAILURE;
369 }
Heinrich Schuchardtb6f15e92018-04-04 15:42:13 +0200370 buf_size = sizeof(system_info);
371 ret = root->getinfo(root, &guid_file_system_info, &buf_size,
372 &system_info);
373 if (ret != EFI_SUCCESS) {
374 efi_st_error("Failed to get file system info\n");
375 return EFI_ST_FAILURE;
376 }
377 if (system_info.info.block_size != 512) {
378 efi_st_error("Wrong block size %u, expected 512\n",
379 system_info.info.block_size);
380 return EFI_ST_FAILURE;
381 }
382 if (efi_st_strcmp_16_8(system_info.info.volume_label, "U-BOOT TEST")) {
383 efi_st_todo(
384 "Wrong volume label '%ps', expected 'U-BOOT TEST'\n",
385 system_info.info.volume_label);
386 }
Heinrich Schuchardt76bc73c2018-07-02 02:41:24 +0200387
388 /* Read file */
Heinrich Schuchardtd322f922018-01-21 19:29:31 +0100389 ret = root->open(root, &file, (s16 *)L"hello.txt", EFI_FILE_MODE_READ,
390 0);
391 if (ret != EFI_SUCCESS) {
392 efi_st_error("Failed to open file\n");
393 return EFI_ST_FAILURE;
394 }
395 buf_size = sizeof(buf) - 1;
396 ret = file->read(file, &buf_size, buf);
397 if (ret != EFI_SUCCESS) {
398 efi_st_error("Failed to read file\n");
399 return EFI_ST_FAILURE;
400 }
Heinrich Schuchardt76bc73c2018-07-02 02:41:24 +0200401 if (buf_size != 13) {
402 efi_st_error("Wrong number of bytes read: %u\n",
403 (unsigned int)buf_size);
404 return EFI_ST_FAILURE;
405 }
Heinrich Schuchardtd322f922018-01-21 19:29:31 +0100406 if (efi_st_memcmp(buf, "Hello world!", 12)) {
407 efi_st_error("Unexpected file content\n");
408 return EFI_ST_FAILURE;
409 }
410 ret = file->close(file);
411 if (ret != EFI_SUCCESS) {
412 efi_st_error("Failed to close file\n");
413 return EFI_ST_FAILURE;
414 }
Heinrich Schuchardt76bc73c2018-07-02 02:41:24 +0200415
416#ifdef CONFIG_FAT_WRITE
417 /* Write file */
418 ret = root->open(root, &file, (s16 *)L"u-boot.txt",
419 EFI_FILE_MODE_WRITE | EFI_FILE_MODE_CREATE, 0);
420 if (ret != EFI_SUCCESS) {
421 efi_st_error("Failed to open file\n");
422 return EFI_ST_FAILURE;
423 }
424 buf_size = 7;
425 boottime->set_mem(buf, sizeof(buf), 0);
426 boottime->copy_mem(buf, "U-Boot", buf_size);
427 ret = file->write(file, &buf_size, buf);
428 if (ret != EFI_SUCCESS || buf_size != 7) {
429 efi_st_error("Failed to write file\n");
430 return EFI_ST_FAILURE;
431 }
432 ret = file->close(file);
433 if (ret != EFI_SUCCESS) {
434 efi_st_error("Failed to close file\n");
435 return EFI_ST_FAILURE;
436 }
437
438 /* Verify file */
439 boottime->set_mem(buf, sizeof(buf), 0);
440 ret = root->open(root, &file, (s16 *)L"u-boot.txt", EFI_FILE_MODE_READ,
441 0);
442 if (ret != EFI_SUCCESS) {
443 efi_st_error("Failed to open file\n");
444 return EFI_ST_FAILURE;
445 }
446 buf_size = sizeof(buf) - 1;
447 ret = file->read(file, &buf_size, buf);
448 if (ret != EFI_SUCCESS) {
449 efi_st_error("Failed to read file\n");
450 return EFI_ST_FAILURE;
451 }
452 if (buf_size != 7) {
453 efi_st_error("Wrong number of bytes read: %u\n",
454 (unsigned int)buf_size);
455 return EFI_ST_FAILURE;
456 }
457 if (efi_st_memcmp(buf, "U-Boot", 7)) {
458 efi_st_error("Unexpected file content %s\n", buf);
459 return EFI_ST_FAILURE;
460 }
461 ret = file->close(file);
462 if (ret != EFI_SUCCESS) {
463 efi_st_error("Failed to close file\n");
464 return EFI_ST_FAILURE;
465 }
466#else
467 efi_st_todo("CONFIG_FAT_WRITE is not set\n");
468#endif /* CONFIG_FAT_WRITE */
469
470 /* Close volume */
Heinrich Schuchardtd322f922018-01-21 19:29:31 +0100471 ret = root->close(root);
472 if (ret != EFI_SUCCESS) {
473 efi_st_error("Failed to close volume\n");
474 return EFI_ST_FAILURE;
475 }
476
477 return EFI_ST_SUCCESS;
478}
479
480EFI_UNIT_TEST(blkdev) = {
481 .name = "block device",
482 .phase = EFI_EXECUTE_BEFORE_BOOTTIME_EXIT,
483 .setup = setup,
484 .execute = execute,
485 .teardown = teardown,
486};