git.sur5r.net Git - u-boot/blob - test/compression.c

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