1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Copyright (c) 2013, The Chromium Authors 4 */ 5 6 #include <common.h> 7 #include <bootm.h> 8 #include <command.h> 9 #include <malloc.h> 10 #include <mapmem.h> 11 #include <asm/io.h> 12 13 #include <u-boot/zlib.h> 14 #include <bzlib.h> 15 16 #include <lzma/LzmaTypes.h> 17 #include <lzma/LzmaDec.h> 18 #include <lzma/LzmaTools.h> 19 20 #include <linux/lzo.h> 21 #include <test/compression.h> 22 #include <test/suites.h> 23 #include <test/ut.h> 24 25 static const char plain[] = 26 "I am a highly compressable bit of text.\n" 27 "I am a highly compressable bit of text.\n" 28 "I am a highly compressable bit of text.\n" 29 "There are many like me, but this one is mine.\n" 30 "If I were any shorter, there wouldn't be much sense in\n" 31 "compressing me in the first place. At least with lzo, anyway,\n" 32 "which appears to behave poorly in the face of short text\n" 33 "messages.\n"; 34 35 /* bzip2 -c /tmp/plain.txt > /tmp/plain.bz2 */ 36 static const char bzip2_compressed[] = 37 "\x42\x5a\x68\x39\x31\x41\x59\x26\x53\x59\xe5\x63\xdd\x09\x00\x00" 38 "\x28\x57\x80\x00\x10\x40\x85\x20\x20\x04\x00\x3f\xef\xdf\xf0\x30" 39 "\x00\xd6\xd0\x34\x91\x89\xa6\xf5\x4d\x19\x1a\x19\x0d\x02\x34\xd4" 40 "\xc9\x00\x34\x34\x00\x02\x48\x41\x35\x4f\xd4\xc6\x88\xd3\x50\x3d" 41 "\x4f\x51\x82\x4f\x88\xc3\x0d\x05\x62\x4f\x91\xa3\x52\x1b\xd0\x52" 42 "\x41\x4a\xa3\x98\xc2\x6b\xca\xa3\x82\xa5\xac\x8b\x15\x99\x68\xad" 43 "\xdf\x29\xd6\xf1\xf7\x5a\x10\xcd\x8c\x26\x61\x94\x95\xfe\x9e\x16" 44 "\x18\x28\x69\xd4\x23\x64\xcc\x2b\xe5\xe8\x5f\x00\xa4\x70\x26\x2c" 45 "\xee\xbd\x59\x6d\x6a\xec\xfc\x31\xda\x59\x0a\x14\x2a\x60\x1c\xf0" 46 "\x04\x86\x73\x9a\xc5\x5b\x87\x3f\x5b\x4c\x93\xe6\xb5\x35\x0d\xa6" 47 "\xb1\x2e\x62\x7b\xab\x67\xe7\x99\x2a\x14\x5e\x9f\x64\xcb\x96\xf4" 48 "\x0d\x65\xd4\x39\xe6\x8b\x7e\xea\x1c\x03\x69\x97\x83\x58\x91\x96" 49 "\xe1\xf0\x9d\xa4\x15\x8b\xb8\xc6\x93\xdc\x3d\xd9\x3c\x22\x55\xef" 50 "\xfb\xbb\x2a\xd3\x87\xa2\x8b\x04\xd9\x19\xf8\xe2\xfd\x4f\xdb\x1a" 51 "\x07\xc8\x60\xa3\x3f\xf8\xbb\x92\x29\xc2\x84\x87\x2b\x1e\xe8\x48"; 52 static const unsigned long bzip2_compressed_size = 240; 53 54 /* lzma -z -c /tmp/plain.txt > /tmp/plain.lzma */ 55 static const char lzma_compressed[] = 56 "\x5d\x00\x00\x80\x00\xff\xff\xff\xff\xff\xff\xff\xff\x00\x24\x88" 57 "\x08\x26\xd8\x41\xff\x99\xc8\xcf\x66\x3d\x80\xac\xba\x17\xf1\xc8" 58 "\xb9\xdf\x49\x37\xb1\x68\xa0\x2a\xdd\x63\xd1\xa7\xa3\x66\xf8\x15" 59 "\xef\xa6\x67\x8a\x14\x18\x80\xcb\xc7\xb1\xcb\x84\x6a\xb2\x51\x16" 60 "\xa1\x45\xa0\xd6\x3e\x55\x44\x8a\x5c\xa0\x7c\xe5\xa8\xbd\x04\x57" 61 "\x8f\x24\xfd\xb9\x34\x50\x83\x2f\xf3\x46\x3e\xb9\xb0\x00\x1a\xf5" 62 "\xd3\x86\x7e\x8f\x77\xd1\x5d\x0e\x7c\xe1\xac\xde\xf8\x65\x1f\x4d" 63 "\xce\x7f\xa7\x3d\xaa\xcf\x26\xa7\x58\x69\x1e\x4c\xea\x68\x8a\xe5" 64 "\x89\xd1\xdc\x4d\xc7\xe0\x07\x42\xbf\x0c\x9d\x06\xd7\x51\xa2\x0b" 65 "\x7c\x83\x35\xe1\x85\xdf\xee\xfb\xa3\xee\x2f\x47\x5f\x8b\x70\x2b" 66 "\xe1\x37\xf3\x16\xf6\x27\x54\x8a\x33\x72\x49\xea\x53\x7d\x60\x0b" 67 "\x21\x90\x66\xe7\x9e\x56\x61\x5d\xd8\xdc\x59\xf0\xac\x2f\xd6\x49" 68 "\x6b\x85\x40\x08\x1f\xdf\x26\x25\x3b\x72\x44\xb0\xb8\x21\x2f\xb3" 69 "\xd7\x9b\x24\x30\x78\x26\x44\x07\xc3\x33\xd1\x4d\x03\x1b\xe1\xff" 70 "\xfd\xf5\x50\x8d\xca"; 71 static const unsigned long lzma_compressed_size = 229; 72 73 /* lzop -c /tmp/plain.txt > /tmp/plain.lzo */ 74 static const char lzo_compressed[] = 75 "\x89\x4c\x5a\x4f\x00\x0d\x0a\x1a\x0a\x10\x30\x20\x60\x09\x40\x01" 76 "\x05\x03\x00\x00\x09\x00\x00\x81\xb4\x52\x09\x54\xf1\x00\x00\x00" 77 "\x00\x09\x70\x6c\x61\x69\x6e\x2e\x74\x78\x74\x65\xb1\x07\x9c\x00" 78 "\x00\x01\x5e\x00\x00\x01\x0f\xc3\xc7\x7a\xe0\x00\x16\x49\x20\x61" 79 "\x6d\x20\x61\x20\x68\x69\x67\x68\x6c\x79\x20\x63\x6f\x6d\x70\x72" 80 "\x65\x73\x73\x61\x62\x6c\x65\x20\x62\x69\x74\x20\x6f\x66\x20\x74" 81 "\x65\x78\x74\x2e\x0a\x20\x2f\x9c\x00\x00\x22\x54\x68\x65\x72\x65" 82 "\x20\x61\x72\x65\x20\x6d\x61\x6e\x79\x20\x6c\x69\x6b\x65\x20\x6d" 83 "\x65\x2c\x20\x62\x75\x74\x20\x74\x68\x69\x73\x20\x6f\x6e\x65\x20" 84 "\x69\x73\x20\x6d\x69\x6e\x65\x2e\x0a\x49\x66\x20\x49\x20\x77\x84" 85 "\x06\x0a\x6e\x79\x20\x73\x68\x6f\x72\x74\x65\x72\x2c\x20\x74\x90" 86 "\x08\x00\x08\x77\x6f\x75\x6c\x64\x6e\x27\x74\x20\x62\x65\x20\x6d" 87 "\x75\x63\x68\x20\x73\x65\x6e\x73\x65\x20\x69\x6e\x0a\xf8\x19\x02" 88 "\x69\x6e\x67\x20\x6d\x64\x02\x64\x06\x00\x5a\x20\x66\x69\x72\x73" 89 "\x74\x20\x70\x6c\x61\x63\x65\x2e\x20\x41\x74\x20\x6c\x65\x61\x73" 90 "\x74\x20\x77\x69\x74\x68\x20\x6c\x7a\x6f\x2c\x20\x61\x6e\x79\x77" 91 "\x61\x79\x2c\x0a\x77\x68\x69\x63\x68\x20\x61\x70\x70\x65\x61\x72" 92 "\x73\x20\x74\x6f\x20\x62\x65\x68\x61\x76\x65\x20\x70\x6f\x6f\x72" 93 "\x6c\x79\x20\x69\x6e\x20\x74\x68\x65\x20\x66\x61\x63\x65\x20\x6f" 94 "\x66\x20\x73\x68\x6f\x72\x74\x20\x74\x65\x78\x74\x0a\x6d\x65\x73" 95 "\x73\x61\x67\x65\x73\x2e\x0a\x11\x00\x00\x00\x00\x00\x00"; 96 static const unsigned long lzo_compressed_size = 334; 97 98 /* lz4 -z /tmp/plain.txt > /tmp/plain.lz4 */ 99 static const char lz4_compressed[] = 100 "\x04\x22\x4d\x18\x64\x70\xb9\x01\x01\x00\x00\xff\x19\x49\x20\x61" 101 "\x6d\x20\x61\x20\x68\x69\x67\x68\x6c\x79\x20\x63\x6f\x6d\x70\x72" 102 "\x65\x73\x73\x61\x62\x6c\x65\x20\x62\x69\x74\x20\x6f\x66\x20\x74" 103 "\x65\x78\x74\x2e\x0a\x28\x00\x3d\xf1\x25\x54\x68\x65\x72\x65\x20" 104 "\x61\x72\x65\x20\x6d\x61\x6e\x79\x20\x6c\x69\x6b\x65\x20\x6d\x65" 105 "\x2c\x20\x62\x75\x74\x20\x74\x68\x69\x73\x20\x6f\x6e\x65\x20\x69" 106 "\x73\x20\x6d\x69\x6e\x65\x2e\x0a\x49\x66\x20\x49\x20\x77\x32\x00" 107 "\xd1\x6e\x79\x20\x73\x68\x6f\x72\x74\x65\x72\x2c\x20\x74\x45\x00" 108 "\xf4\x0b\x77\x6f\x75\x6c\x64\x6e\x27\x74\x20\x62\x65\x20\x6d\x75" 109 "\x63\x68\x20\x73\x65\x6e\x73\x65\x20\x69\x6e\x0a\xcf\x00\x50\x69" 110 "\x6e\x67\x20\x6d\x12\x00\x00\x32\x00\xf0\x11\x20\x66\x69\x72\x73" 111 "\x74\x20\x70\x6c\x61\x63\x65\x2e\x20\x41\x74\x20\x6c\x65\x61\x73" 112 "\x74\x20\x77\x69\x74\x68\x20\x6c\x7a\x6f\x2c\x63\x00\xf5\x14\x77" 113 "\x61\x79\x2c\x0a\x77\x68\x69\x63\x68\x20\x61\x70\x70\x65\x61\x72" 114 "\x73\x20\x74\x6f\x20\x62\x65\x68\x61\x76\x65\x20\x70\x6f\x6f\x72" 115 "\x6c\x79\x4e\x00\x30\x61\x63\x65\x27\x01\x01\x95\x00\x01\x2d\x01" 116 "\xb0\x0a\x6d\x65\x73\x73\x61\x67\x65\x73\x2e\x0a\x00\x00\x00\x00" 117 "\x9d\x12\x8c\x9d"; 118 static const unsigned long lz4_compressed_size = 276; 119 120 121 #define TEST_BUFFER_SIZE 512 122 123 typedef int (*mutate_func)(struct unit_test_state *uts, void *, unsigned long, 124 void *, unsigned long, unsigned long *); 125 126 static int compress_using_gzip(struct unit_test_state *uts, 127 void *in, unsigned long in_size, 128 void *out, unsigned long out_max, 129 unsigned long *out_size) 130 { 131 int ret; 132 unsigned long inout_size = out_max; 133 134 ret = gzip(out, &inout_size, in, in_size); 135 if (out_size) 136 *out_size = inout_size; 137 138 return ret; 139 } 140 141 static int uncompress_using_gzip(struct unit_test_state *uts, 142 void *in, unsigned long in_size, 143 void *out, unsigned long out_max, 144 unsigned long *out_size) 145 { 146 int ret; 147 unsigned long inout_size = in_size; 148 149 ret = gunzip(out, out_max, in, &inout_size); 150 if (out_size) 151 *out_size = inout_size; 152 153 return ret; 154 } 155 156 static int compress_using_bzip2(struct unit_test_state *uts, 157 void *in, unsigned long in_size, 158 void *out, unsigned long out_max, 159 unsigned long *out_size) 160 { 161 /* There is no bzip2 compression in u-boot, so fake it. */ 162 ut_asserteq(in_size, strlen(plain)); 163 ut_asserteq(0, memcmp(plain, in, in_size)); 164 165 if (bzip2_compressed_size > out_max) 166 return -1; 167 168 memcpy(out, bzip2_compressed, bzip2_compressed_size); 169 if (out_size) 170 *out_size = bzip2_compressed_size; 171 172 return 0; 173 } 174 175 static int uncompress_using_bzip2(struct unit_test_state *uts, 176 void *in, unsigned long in_size, 177 void *out, unsigned long out_max, 178 unsigned long *out_size) 179 { 180 int ret; 181 unsigned int inout_size = out_max; 182 183 ret = BZ2_bzBuffToBuffDecompress(out, &inout_size, in, in_size, 184 CONFIG_SYS_MALLOC_LEN < (4096 * 1024), 0); 185 if (out_size) 186 *out_size = inout_size; 187 188 return (ret != BZ_OK); 189 } 190 191 static int compress_using_lzma(struct unit_test_state *uts, 192 void *in, unsigned long in_size, 193 void *out, unsigned long out_max, 194 unsigned long *out_size) 195 { 196 /* There is no lzma compression in u-boot, so fake it. */ 197 ut_asserteq(in_size, strlen(plain)); 198 ut_asserteq(0, memcmp(plain, in, in_size)); 199 200 if (lzma_compressed_size > out_max) 201 return -1; 202 203 memcpy(out, lzma_compressed, lzma_compressed_size); 204 if (out_size) 205 *out_size = lzma_compressed_size; 206 207 return 0; 208 } 209 210 static int uncompress_using_lzma(struct unit_test_state *uts, 211 void *in, unsigned long in_size, 212 void *out, unsigned long out_max, 213 unsigned long *out_size) 214 { 215 int ret; 216 SizeT inout_size = out_max; 217 218 ret = lzmaBuffToBuffDecompress(out, &inout_size, in, in_size); 219 if (out_size) 220 *out_size = inout_size; 221 222 return (ret != SZ_OK); 223 } 224 225 static int compress_using_lzo(struct unit_test_state *uts, 226 void *in, unsigned long in_size, 227 void *out, unsigned long out_max, 228 unsigned long *out_size) 229 { 230 /* There is no lzo compression in u-boot, so fake it. */ 231 ut_asserteq(in_size, strlen(plain)); 232 ut_asserteq(0, memcmp(plain, in, in_size)); 233 234 if (lzo_compressed_size > out_max) 235 return -1; 236 237 memcpy(out, lzo_compressed, lzo_compressed_size); 238 if (out_size) 239 *out_size = lzo_compressed_size; 240 241 return 0; 242 } 243 244 static int uncompress_using_lzo(struct unit_test_state *uts, 245 void *in, unsigned long in_size, 246 void *out, unsigned long out_max, 247 unsigned long *out_size) 248 { 249 int ret; 250 size_t input_size = in_size; 251 size_t output_size = out_max; 252 253 ret = lzop_decompress(in, input_size, out, &output_size); 254 if (out_size) 255 *out_size = output_size; 256 257 return (ret != LZO_E_OK); 258 } 259 260 static int compress_using_lz4(struct unit_test_state *uts, 261 void *in, unsigned long in_size, 262 void *out, unsigned long out_max, 263 unsigned long *out_size) 264 { 265 /* There is no lz4 compression in u-boot, so fake it. */ 266 ut_asserteq(in_size, strlen(plain)); 267 ut_asserteq(0, memcmp(plain, in, in_size)); 268 269 if (lz4_compressed_size > out_max) 270 return -1; 271 272 memcpy(out, lz4_compressed, lz4_compressed_size); 273 if (out_size) 274 *out_size = lz4_compressed_size; 275 276 return 0; 277 } 278 279 static int uncompress_using_lz4(struct unit_test_state *uts, 280 void *in, unsigned long in_size, 281 void *out, unsigned long out_max, 282 unsigned long *out_size) 283 { 284 int ret; 285 size_t input_size = in_size; 286 size_t output_size = out_max; 287 288 ret = ulz4fn(in, input_size, out, &output_size); 289 if (out_size) 290 *out_size = output_size; 291 292 return (ret != 0); 293 } 294 295 #define errcheck(statement) if (!(statement)) { \ 296 fprintf(stderr, "\tFailed: %s\n", #statement); \ 297 ret = 1; \ 298 goto out; \ 299 } 300 301 struct buf_state { 302 ulong orig_size; 303 ulong compressed_size; 304 ulong uncompressed_size; 305 void *orig_buf; 306 void *compressed_buf; 307 void *uncompressed_buf; 308 void *compare_buf; 309 }; 310 311 static int run_test_internal(struct unit_test_state *uts, char *name, 312 mutate_func compress, mutate_func uncompress, 313 struct buf_state *buf) 314 { 315 int ret; 316 317 /* Compress works as expected. */ 318 printf("\torig_size:%lu\n", buf->orig_size); 319 memset(buf->compressed_buf, 'A', TEST_BUFFER_SIZE); 320 errcheck(compress(uts, buf->orig_buf, buf->orig_size, 321 buf->compressed_buf, buf->compressed_size, 322 &buf->compressed_size) == 0); 323 printf("\tcompressed_size:%lu\n", buf->compressed_size); 324 errcheck(buf->compressed_size > 0); 325 errcheck(buf->compressed_size < buf->orig_size); 326 errcheck(((char *)buf->compressed_buf)[buf->compressed_size - 1] != 327 'A'); 328 errcheck(((char *)buf->compressed_buf)[buf->compressed_size] == 'A'); 329 330 /* Uncompresses with space remaining. */ 331 errcheck(uncompress(uts, buf->compressed_buf, buf->compressed_size, 332 buf->uncompressed_buf, buf->uncompressed_size, 333 &buf->uncompressed_size) == 0); 334 printf("\tuncompressed_size:%lu\n", buf->uncompressed_size); 335 errcheck(buf->uncompressed_size == buf->orig_size); 336 errcheck(memcmp(buf->orig_buf, buf->uncompressed_buf, 337 buf->orig_size) == 0); 338 339 /* Uncompresses with exactly the right size output buffer. */ 340 memset(buf->uncompressed_buf, 'A', TEST_BUFFER_SIZE); 341 errcheck(uncompress(uts, buf->compressed_buf, buf->compressed_size, 342 buf->uncompressed_buf, buf->orig_size, 343 &buf->uncompressed_size) == 0); 344 errcheck(buf->uncompressed_size == buf->orig_size); 345 errcheck(memcmp(buf->orig_buf, buf->uncompressed_buf, 346 buf->orig_size) == 0); 347 errcheck(((char *)buf->uncompressed_buf)[buf->orig_size] == 'A'); 348 349 /* Make sure compression does not over-run. */ 350 memset(buf->compare_buf, 'A', TEST_BUFFER_SIZE); 351 ret = compress(uts, buf->orig_buf, buf->orig_size, 352 buf->compare_buf, buf->compressed_size - 1, 353 NULL); 354 errcheck(((char *)buf->compare_buf)[buf->compressed_size] == 'A'); 355 errcheck(ret != 0); 356 printf("\tcompress does not overrun\n"); 357 358 /* Make sure decompression does not over-run. */ 359 memset(buf->compare_buf, 'A', TEST_BUFFER_SIZE); 360 ret = uncompress(uts, buf->compressed_buf, buf->compressed_size, 361 buf->compare_buf, buf->uncompressed_size - 1, 362 NULL); 363 errcheck(((char *)buf->compare_buf)[buf->uncompressed_size - 1] == 'A'); 364 errcheck(ret != 0); 365 printf("\tuncompress does not overrun\n"); 366 367 /* Got here, everything is fine. */ 368 ret = 0; 369 370 out: 371 return ret; 372 } 373 374 static int run_test(struct unit_test_state *uts, char *name, 375 mutate_func compress, mutate_func uncompress) 376 { 377 struct buf_state sbuf, *buf = &sbuf; 378 int ret; 379 380 printf(" testing %s ...\n", name); 381 382 buf->orig_buf = (void *)plain; 383 buf->orig_size = strlen(buf->orig_buf); /* Trailing NUL not included */ 384 errcheck(buf->orig_size > 0); 385 386 buf->compressed_size = TEST_BUFFER_SIZE; 387 buf->uncompressed_size = TEST_BUFFER_SIZE; 388 buf->compressed_buf = malloc(buf->compressed_size); 389 errcheck(buf->compressed_buf); 390 buf->uncompressed_buf = malloc(buf->uncompressed_size); 391 errcheck(buf->uncompressed_buf); 392 buf->compare_buf = malloc(buf->uncompressed_size); 393 errcheck(buf->compare_buf); 394 395 ret = run_test_internal(uts, name, compress, uncompress, buf); 396 out: 397 printf(" %s: %s\n", name, ret == 0 ? "ok" : "FAILED"); 398 399 free(buf->compare_buf); 400 free(buf->uncompressed_buf); 401 free(buf->compressed_buf); 402 403 return ret; 404 } 405 406 static int compression_test_gzip(struct unit_test_state *uts) 407 { 408 return run_test(uts, "gzip", compress_using_gzip, 409 uncompress_using_gzip); 410 } 411 COMPRESSION_TEST(compression_test_gzip, 0); 412 413 static int compression_test_bzip2(struct unit_test_state *uts) 414 { 415 return run_test(uts, "bzip2", compress_using_bzip2, 416 uncompress_using_bzip2); 417 } 418 COMPRESSION_TEST(compression_test_bzip2, 0); 419 420 static int compression_test_lzma(struct unit_test_state *uts) 421 { 422 return run_test(uts, "lzma", compress_using_lzma, 423 uncompress_using_lzma); 424 } 425 COMPRESSION_TEST(compression_test_lzma, 0); 426 427 static int compression_test_lzo(struct unit_test_state *uts) 428 { 429 return run_test(uts, "lzo", compress_using_lzo, uncompress_using_lzo); 430 } 431 COMPRESSION_TEST(compression_test_lzo, 0); 432 433 static int compression_test_lz4(struct unit_test_state *uts) 434 { 435 return run_test(uts, "lz4", compress_using_lz4, uncompress_using_lz4); 436 } 437 COMPRESSION_TEST(compression_test_lz4, 0); 438 439 static int compress_using_none(struct unit_test_state *uts, 440 void *in, unsigned long in_size, 441 void *out, unsigned long out_max, 442 unsigned long *out_size) 443 { 444 /* Here we just copy */ 445 memcpy(out, in, in_size); 446 *out_size = in_size; 447 448 return 0; 449 } 450 451 /** 452 * run_bootm_test() - Run tests on the bootm decopmression function 453 * 454 * @comp_type: Compression type to test 455 * @compress: Our function to compress data 456 * @return 0 if OK, non-zero on failure 457 */ 458 static int run_bootm_test(struct unit_test_state *uts, int comp_type, 459 mutate_func compress) 460 { 461 ulong compress_size = 1024; 462 void *compress_buff; 463 int unc_len; 464 int err = 0; 465 const ulong image_start = 0; 466 const ulong load_addr = 0x1000; 467 ulong load_end; 468 469 printf("Testing: %s\n", genimg_get_comp_name(comp_type)); 470 compress_buff = map_sysmem(image_start, 0); 471 unc_len = strlen(plain); 472 compress(uts, (void *)plain, unc_len, compress_buff, compress_size, 473 &compress_size); 474 err = bootm_decomp_image(comp_type, load_addr, image_start, 475 IH_TYPE_KERNEL, map_sysmem(load_addr, 0), 476 compress_buff, compress_size, unc_len, 477 &load_end); 478 ut_assertok(err); 479 err = bootm_decomp_image(comp_type, load_addr, image_start, 480 IH_TYPE_KERNEL, map_sysmem(load_addr, 0), 481 compress_buff, compress_size, unc_len - 1, 482 &load_end); 483 ut_assert(err); 484 485 /* We can't detect corruption when not decompressing */ 486 if (comp_type == IH_COMP_NONE) 487 return 0; 488 memset(compress_buff + compress_size / 2, '\x49', 489 compress_size / 2); 490 err = bootm_decomp_image(comp_type, load_addr, image_start, 491 IH_TYPE_KERNEL, map_sysmem(load_addr, 0), 492 compress_buff, compress_size, 0x10000, 493 &load_end); 494 ut_assert(err); 495 496 return 0; 497 } 498 499 static int compression_test_bootm_gzip(struct unit_test_state *uts) 500 { 501 return run_bootm_test(uts, IH_COMP_GZIP, compress_using_gzip); 502 } 503 COMPRESSION_TEST(compression_test_bootm_gzip, 0); 504 505 static int compression_test_bootm_bzip2(struct unit_test_state *uts) 506 { 507 return run_bootm_test(uts, IH_COMP_BZIP2, compress_using_bzip2); 508 } 509 COMPRESSION_TEST(compression_test_bootm_bzip2, 0); 510 511 static int compression_test_bootm_lzma(struct unit_test_state *uts) 512 { 513 return run_bootm_test(uts, IH_COMP_LZMA, compress_using_lzma); 514 } 515 COMPRESSION_TEST(compression_test_bootm_lzma, 0); 516 517 static int compression_test_bootm_lzo(struct unit_test_state *uts) 518 { 519 return run_bootm_test(uts, IH_COMP_LZO, compress_using_lzo); 520 } 521 COMPRESSION_TEST(compression_test_bootm_lzo, 0); 522 523 static int compression_test_bootm_lz4(struct unit_test_state *uts) 524 { 525 return run_bootm_test(uts, IH_COMP_LZ4, compress_using_lz4); 526 } 527 COMPRESSION_TEST(compression_test_bootm_lz4, 0); 528 529 static int compression_test_bootm_none(struct unit_test_state *uts) 530 { 531 return run_bootm_test(uts, IH_COMP_NONE, compress_using_none); 532 } 533 COMPRESSION_TEST(compression_test_bootm_none, 0); 534 535 int do_ut_compression(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) 536 { 537 struct unit_test *tests = ll_entry_start(struct unit_test, 538 compression_test); 539 const int n_ents = ll_entry_count(struct unit_test, compression_test); 540 541 return cmd_ut_category("compression", tests, n_ents, argc, argv); 542 } 543