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
|
// SPDX-License-Identifier: GPL-2.0-or-later
/*
* Tests for zip/unzip/gzwrite commands
*
* Copyright 2026, Marek Vasut <[email protected]>
*/
#include <command.h>
#include <env.h>
#include <dm.h>
#include <dm/lists.h>
#include <dm/test.h>
#include <linux/sizes.h>
#include <mapmem.h>
#include <part.h>
#include <test/cmd.h>
#include <test/test.h>
#include <test/ut.h>
#include <u-boot/crc.h>
/* sys/random.h is not accessible */
extern ssize_t getrandom(void *buf, size_t size, unsigned int flags);
static const ssize_t sizes[] = { 32, SZ_1K, SZ_4K, SZ_1M, SZ_16M, SZ_1M - 1, SZ_1M + 1, 6758401 };
static int do_test_cmd_zip_unzip(struct unit_test_state *uts, ssize_t size,
const bool gzwrite)
{
unsigned long loadaddr = env_get_ulong("loadaddr", 16, 0);
unsigned long encaddr = loadaddr + size + 0x10000;
unsigned long decaddr = encaddr + size + 0x10000;
unsigned char *loadmap = map_sysmem(loadaddr, size);
unsigned char *decmap = map_sysmem(decaddr, size);
unsigned char *encmap = map_sysmem(encaddr, size);
/*
* Prepare three buffers, $loadadd, $encaddr, $decaddr, and
* fill them all with random data. Add slight space between
* the compressed buffer 'encaddr' and uncompressed buffer
* 'decaddr', because the compressed data with gzip header
* might be longer than uncompressed source data 'loadaddr',
* and if the uncompressed data buffer 'decaddr' followed
* 'encaddr', the decompression could corrupt end of 'encaddr'
* buffer.
*/
ut_assert(getrandom(loadmap, size, 0) == size);
ut_assert(getrandom(decmap, size, 0) == size);
ut_assert(getrandom(encmap, size, 0) == size);
/* Compress data in $loadaddr into $encaddr */
ut_assertok(run_commandf("zip $loadaddr %zx %zx", size, encaddr));
console_record_readline(uts->actual_str, sizeof(uts->actual_str));
ut_assert(strstr(uts->actual_str, "Compressed size: "));
if (gzwrite) {
unsigned int sectsize = DIV_ROUND_UP(size, 512);
u32 crc = crc32(0, loadmap, size);
struct blk_desc *mmc_dev_desc;
ut_assertok(run_commandf("gzwrite mmc 9 %zx $filesize", encaddr));
ut_assert_skip_to_line("\t%zu bytes, crc 0x%08x", size, crc);
ut_asserteq(9, blk_get_device_by_str("mmc", "9", &mmc_dev_desc));
ut_assertok(run_commandf("mmc dev 9"));
ut_assert_nextline("switch to partitions #0, OK");
ut_assert_nextline("mmc9 is current device");
ut_assertok(run_commandf("mmc read %zx 0 %x", decaddr, sectsize));
ut_assert_nextline("MMC read: dev # 9, block # 0, count %u ... %u blocks read: OK",
sectsize, sectsize);
} else {
/* Decompress data in $encaddr into $decaddr */
ut_assertok(run_commandf("unzip %zx %zx $filesize", encaddr, decaddr));
ut_assert_nextline("Uncompressed size: %zu = 0x%zX", size, size);
}
/* Input data and compressed-decompressed data */
ut_asserteq_mem(loadmap, decmap, size);
ut_assert_console_end();
unmap_sysmem(loadmap);
unmap_sysmem(decmap);
unmap_sysmem(encmap);
return 0;
}
static int dm_test_cmd_zip_unzip(struct unit_test_state *uts)
{
int i, ret;
for (i = 0; i < ARRAY_SIZE(sizes); i++) {
ret = do_test_cmd_zip_unzip(uts, sizes[i], false);
if (ret)
return ret;
}
return 0;
}
DM_TEST(dm_test_cmd_zip_unzip, UTF_CONSOLE);
static int dm_test_cmd_zip_gzwrite(struct unit_test_state *uts)
{
struct udevice *dev;
ofnode root, node;
int i, ret;
/* Enable the mmc9 node for this test */
root = oftree_root(oftree_default());
node = ofnode_find_subnode(root, "mmc9");
ut_assert(ofnode_valid(node));
ut_assertok(lists_bind_fdt(gd->dm_root, node, &dev, NULL, false));
for (i = 0; i < ARRAY_SIZE(sizes); i++) {
ret = do_test_cmd_zip_unzip(uts, sizes[i], true);
if (ret)
return ret;
}
return 0;
}
DM_TEST(dm_test_cmd_zip_gzwrite, UTF_CONSOLE);
|
