test/compression.c

   1 /*
   2  * Copyright (c) 2013, The Chromium Authors
   3  *
   4  * SPDX-License-Identifier:     GPL-2.0+
   5  */
   6
   7 #define DEBUG
   8
   9 #include <common.h>
  10 #include <command.h>
  11 #include <malloc.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
  22 static const char plain[] =
  23         "I am a highly compressable bit of text.\n"
  24         "I am a highly compressable bit of text.\n"
  25         "I am a highly compressable bit of text.\n"
  26         "There are many like me, but this one is mine.\n"
  27         "If I were any shorter, there wouldn't be much sense in\n"
  28         "compressing me in the first place. At least with lzo, anyway,\n"
  29         "which appears to behave poorly in the face of short text\n"
  30         "messages.\n";
  31
  32 /* bzip2 -c /tmp/plain.txt > /tmp/plain.bz2 */
  33 static const char bzip2_compressed[] =
  34         "\x42\x5a\x68\x39\x31\x41\x59\x26\x53\x59\xe5\x63\xdd\x09\x00\x00"
  35         "\x28\x57\x80\x00\x10\x40\x85\x20\x20\x04\x00\x3f\xef\xdf\xf0\x30"
  36         "\x00\xd6\xd0\x34\x91\x89\xa6\xf5\x4d\x19\x1a\x19\x0d\x02\x34\xd4"
  37         "\xc9\x00\x34\x34\x00\x02\x48\x41\x35\x4f\xd4\xc6\x88\xd3\x50\x3d"
  38         "\x4f\x51\x82\x4f\x88\xc3\x0d\x05\x62\x4f\x91\xa3\x52\x1b\xd0\x52"
  39         "\x41\x4a\xa3\x98\xc2\x6b\xca\xa3\x82\xa5\xac\x8b\x15\x99\x68\xad"
  40         "\xdf\x29\xd6\xf1\xf7\x5a\x10\xcd\x8c\x26\x61\x94\x95\xfe\x9e\x16"
  41         "\x18\x28\x69\xd4\x23\x64\xcc\x2b\xe5\xe8\x5f\x00\xa4\x70\x26\x2c"
  42         "\xee\xbd\x59\x6d\x6a\xec\xfc\x31\xda\x59\x0a\x14\x2a\x60\x1c\xf0"
  43         "\x04\x86\x73\x9a\xc5\x5b\x87\x3f\x5b\x4c\x93\xe6\xb5\x35\x0d\xa6"
  44         "\xb1\x2e\x62\x7b\xab\x67\xe7\x99\x2a\x14\x5e\x9f\x64\xcb\x96\xf4"
  45         "\x0d\x65\xd4\x39\xe6\x8b\x7e\xea\x1c\x03\x69\x97\x83\x58\x91\x96"
  46         "\xe1\xf0\x9d\xa4\x15\x8b\xb8\xc6\x93\xdc\x3d\xd9\x3c\x22\x55\xef"
  47         "\xfb\xbb\x2a\xd3\x87\xa2\x8b\x04\xd9\x19\xf8\xe2\xfd\x4f\xdb\x1a"
  48         "\x07\xc8\x60\xa3\x3f\xf8\xbb\x92\x29\xc2\x84\x87\x2b\x1e\xe8\x48";
  49 static const unsigned long bzip2_compressed_size = 240;
  50
  51 /* lzma -z -c /tmp/plain.txt > /tmp/plain.lzma */
  52 static const char lzma_compressed[] =
  53         "\x5d\x00\x00\x80\x00\xff\xff\xff\xff\xff\xff\xff\xff\x00\x24\x88"
  54         "\x08\x26\xd8\x41\xff\x99\xc8\xcf\x66\x3d\x80\xac\xba\x17\xf1\xc8"
  55         "\xb9\xdf\x49\x37\xb1\x68\xa0\x2a\xdd\x63\xd1\xa7\xa3\x66\xf8\x15"
  56         "\xef\xa6\x67\x8a\x14\x18\x80\xcb\xc7\xb1\xcb\x84\x6a\xb2\x51\x16"
  57         "\xa1\x45\xa0\xd6\x3e\x55\x44\x8a\x5c\xa0\x7c\xe5\xa8\xbd\x04\x57"
  58         "\x8f\x24\xfd\xb9\x34\x50\x83\x2f\xf3\x46\x3e\xb9\xb0\x00\x1a\xf5"
  59         "\xd3\x86\x7e\x8f\x77\xd1\x5d\x0e\x7c\xe1\xac\xde\xf8\x65\x1f\x4d"
  60         "\xce\x7f\xa7\x3d\xaa\xcf\x26\xa7\x58\x69\x1e\x4c\xea\x68\x8a\xe5"
  61         "\x89\xd1\xdc\x4d\xc7\xe0\x07\x42\xbf\x0c\x9d\x06\xd7\x51\xa2\x0b"
  62         "\x7c\x83\x35\xe1\x85\xdf\xee\xfb\xa3\xee\x2f\x47\x5f\x8b\x70\x2b"
  63         "\xe1\x37\xf3\x16\xf6\x27\x54\x8a\x33\x72\x49\xea\x53\x7d\x60\x0b"
  64         "\x21\x90\x66\xe7\x9e\x56\x61\x5d\xd8\xdc\x59\xf0\xac\x2f\xd6\x49"
  65         "\x6b\x85\x40\x08\x1f\xdf\x26\x25\x3b\x72\x44\xb0\xb8\x21\x2f\xb3"
  66         "\xd7\x9b\x24\x30\x78\x26\x44\x07\xc3\x33\xd1\x4d\x03\x1b\xe1\xff"
  67         "\xfd\xf5\x50\x8d\xca";
  68 static const unsigned long lzma_compressed_size = 229;
  69
  70 /* lzop -c /tmp/plain.txt > /tmp/plain.lzo */
  71 static const char lzo_compressed[] =
  72         "\x89\x4c\x5a\x4f\x00\x0d\x0a\x1a\x0a\x10\x30\x20\x60\x09\x40\x01"
  73         "\x05\x03\x00\x00\x09\x00\x00\x81\xb4\x52\x09\x54\xf1\x00\x00\x00"
  74         "\x00\x09\x70\x6c\x61\x69\x6e\x2e\x74\x78\x74\x65\xb1\x07\x9c\x00"
  75         "\x00\x01\x5e\x00\x00\x01\x0f\xc3\xc7\x7a\xe0\x00\x16\x49\x20\x61"
  76         "\x6d\x20\x61\x20\x68\x69\x67\x68\x6c\x79\x20\x63\x6f\x6d\x70\x72"
  77         "\x65\x73\x73\x61\x62\x6c\x65\x20\x62\x69\x74\x20\x6f\x66\x20\x74"
  78         "\x65\x78\x74\x2e\x0a\x20\x2f\x9c\x00\x00\x22\x54\x68\x65\x72\x65"
  79         "\x20\x61\x72\x65\x20\x6d\x61\x6e\x79\x20\x6c\x69\x6b\x65\x20\x6d"
  80         "\x65\x2c\x20\x62\x75\x74\x20\x74\x68\x69\x73\x20\x6f\x6e\x65\x20"
  81         "\x69\x73\x20\x6d\x69\x6e\x65\x2e\x0a\x49\x66\x20\x49\x20\x77\x84"
  82         "\x06\x0a\x6e\x79\x20\x73\x68\x6f\x72\x74\x65\x72\x2c\x20\x74\x90"
  83         "\x08\x00\x08\x77\x6f\x75\x6c\x64\x6e\x27\x74\x20\x62\x65\x20\x6d"
  84         "\x75\x63\x68\x20\x73\x65\x6e\x73\x65\x20\x69\x6e\x0a\xf8\x19\x02"
  85         "\x69\x6e\x67\x20\x6d\x64\x02\x64\x06\x00\x5a\x20\x66\x69\x72\x73"
  86         "\x74\x20\x70\x6c\x61\x63\x65\x2e\x20\x41\x74\x20\x6c\x65\x61\x73"
  87         "\x74\x20\x77\x69\x74\x68\x20\x6c\x7a\x6f\x2c\x20\x61\x6e\x79\x77"
  88         "\x61\x79\x2c\x0a\x77\x68\x69\x63\x68\x20\x61\x70\x70\x65\x61\x72"
  89         "\x73\x20\x74\x6f\x20\x62\x65\x68\x61\x76\x65\x20\x70\x6f\x6f\x72"
  90         "\x6c\x79\x20\x69\x6e\x20\x74\x68\x65\x20\x66\x61\x63\x65\x20\x6f"
  91         "\x66\x20\x73\x68\x6f\x72\x74\x20\x74\x65\x78\x74\x0a\x6d\x65\x73"
  92         "\x73\x61\x67\x65\x73\x2e\x0a\x11\x00\x00\x00\x00\x00\x00";
  93 static const unsigned long lzo_compressed_size = 334;
  94
  95
  96 #define TEST_BUFFER_SIZE        512
  97
  98 typedef int (*mutate_func)(void *, unsigned long, void *, unsigned long,
  99                            unsigned long *);
 100
 101 static int compress_using_gzip(void *in, unsigned long in_size,
 102                                void *out, unsigned long out_max,
 103                                unsigned long *out_size)
 104 {
 105         int ret;
 106         unsigned long inout_size = out_max;
 107
 108         ret = gzip(out, &inout_size, in, in_size);
 109         if (out_size)
 110                 *out_size = inout_size;
 111
 112         return ret;
 113 }
 114
 115 static int uncompress_using_gzip(void *in, unsigned long in_size,
 116                                  void *out, unsigned long out_max,
 117                                  unsigned long *out_size)
 118 {
 119         int ret;
 120         unsigned long inout_size = in_size;
 121
 122         ret = gunzip(out, out_max, in, &inout_size);
 123         if (out_size)
 124                 *out_size = inout_size;
 125
 126         return ret;
 127 }
 128
 129 static int compress_using_bzip2(void *in, unsigned long in_size,
 130                                 void *out, unsigned long out_max,
 131                                 unsigned long *out_size)
 132 {
 133         /* There is no bzip2 compression in u-boot, so fake it. */
 134         assert(in_size == strlen(plain));
 135         assert(memcmp(plain, in, in_size) == 0);
 136
 137         if (bzip2_compressed_size > out_max)
 138                 return -1;
 139
 140         memcpy(out, bzip2_compressed, bzip2_compressed_size);
 141         if (out_size)
 142                 *out_size = bzip2_compressed_size;
 143
 144         return 0;
 145 }
 146
 147 static int uncompress_using_bzip2(void *in, unsigned long in_size,
 148                                   void *out, unsigned long out_max,
 149                                   unsigned long *out_size)
 150 {
 151         int ret;
 152         unsigned int inout_size = out_max;
 153
 154         ret = BZ2_bzBuffToBuffDecompress(out, &inout_size, in, in_size,
 155                         CONFIG_SYS_MALLOC_LEN < (4096 * 1024), 0);
 156         if (out_size)
 157                 *out_size = inout_size;
 158
 159         return (ret != BZ_OK);
 160 }
 161
 162 static int compress_using_lzma(void *in, unsigned long in_size,
 163                                void *out, unsigned long out_max,
 164                                unsigned long *out_size)
 165 {
 166         /* There is no lzma compression in u-boot, so fake it. */
 167         assert(in_size == strlen(plain));
 168         assert(memcmp(plain, in, in_size) == 0);
 169
 170         if (lzma_compressed_size > out_max)
 171                 return -1;
 172
 173         memcpy(out, lzma_compressed, lzma_compressed_size);
 174         if (out_size)
 175                 *out_size = lzma_compressed_size;
 176
 177         return 0;
 178 }
 179
 180 static int uncompress_using_lzma(void *in, unsigned long in_size,
 181                                  void *out, unsigned long out_max,
 182                                  unsigned long *out_size)
 183 {
 184         int ret;
 185         SizeT inout_size = out_max;
 186
 187         ret = lzmaBuffToBuffDecompress(out, &inout_size, in, in_size);
 188         if (out_size)
 189                 *out_size = inout_size;
 190
 191         return (ret != SZ_OK);
 192 }
 193
 194 static int compress_using_lzo(void *in, unsigned long in_size,
 195                               void *out, unsigned long out_max,
 196                               unsigned long *out_size)
 197 {
 198         /* There is no lzo compression in u-boot, so fake it. */
 199         assert(in_size == strlen(plain));
 200         assert(memcmp(plain, in, in_size) == 0);
 201
 202         if (lzo_compressed_size > out_max)
 203                 return -1;
 204
 205         memcpy(out, lzo_compressed, lzo_compressed_size);
 206         if (out_size)
 207                 *out_size = lzo_compressed_size;
 208
 209         return 0;
 210 }
 211
 212 static int uncompress_using_lzo(void *in, unsigned long in_size,
 213                                 void *out, unsigned long out_max,
 214                                 unsigned long *out_size)
 215 {
 216         int ret;
 217         size_t input_size = in_size;
 218         size_t output_size = out_max;
 219
 220         ret = lzop_decompress(in, input_size, out, &output_size);
 221         if (out_size)
 222                 *out_size = output_size;
 223
 224         return (ret != LZO_E_OK);
 225 }
 226
 227 #define errcheck(statement) if (!(statement)) { \
 228         fprintf(stderr, "\tFailed: %s\n", #statement); \
 229         ret = 1; \
 230         goto out; \
 231 }
 232
 233 static int run_test(char *name, mutate_func compress, mutate_func uncompress)
 234 {
 235         ulong orig_size, compressed_size, uncompressed_size;
 236         void *orig_buf;
 237         void *compressed_buf = NULL;
 238         void *uncompressed_buf = NULL;
 239         void *compare_buf = NULL;
 240         int ret;
 241
 242         printf(" testing %s ...\n", name);
 243
 244         orig_buf = (void *)plain;
 245         orig_size = strlen(orig_buf); /* Trailing NULL not included. */
 246         errcheck(orig_size > 0);
 247
 248         compressed_size = uncompressed_size = TEST_BUFFER_SIZE;
 249         compressed_buf = malloc(compressed_size);
 250         errcheck(compressed_buf != NULL);
 251         uncompressed_buf = malloc(uncompressed_size);
 252         errcheck(uncompressed_buf != NULL);
 253         compare_buf = malloc(uncompressed_size);
 254         errcheck(compare_buf != NULL);
 255
 256         /* Compress works as expected. */
 257         printf("\torig_size:%lu\n", orig_size);
 258         memset(compressed_buf, 'A', TEST_BUFFER_SIZE);
 259         errcheck(compress(orig_buf, orig_size,
 260                         compressed_buf, compressed_size,
 261                         &compressed_size) == 0);
 262         printf("\tcompressed_size:%lu\n", compressed_size);
 263         errcheck(compressed_size > 0);
 264         errcheck(compressed_size < orig_size);
 265         errcheck(((char *)compressed_buf)[compressed_size-1] != 'A');
 266         errcheck(((char *)compressed_buf)[compressed_size] == 'A');
 267
 268         /* Uncompresses with space remaining. */
 269         errcheck(uncompress(compressed_buf, compressed_size,
 270                           uncompressed_buf, uncompressed_size,
 271                           &uncompressed_size) == 0);
 272         printf("\tuncompressed_size:%lu\n", uncompressed_size);
 273         errcheck(uncompressed_size == orig_size);
 274         errcheck(memcmp(orig_buf, uncompressed_buf, orig_size) == 0);
 275
 276         /* Uncompresses with exactly the right size output buffer. */
 277         memset(uncompressed_buf, 'A', TEST_BUFFER_SIZE);
 278         errcheck(uncompress(compressed_buf, compressed_size,
 279                           uncompressed_buf, orig_size,
 280                           &uncompressed_size) == 0);
 281         errcheck(uncompressed_size == orig_size);
 282         errcheck(memcmp(orig_buf, uncompressed_buf, orig_size) == 0);
 283         errcheck(((char *)uncompressed_buf)[orig_size] == 'A');
 284
 285         /* Make sure compression does not over-run. */
 286         memset(compare_buf, 'A', TEST_BUFFER_SIZE);
 287         ret = compress(orig_buf, orig_size,
 288                        compare_buf, compressed_size - 1,
 289                        NULL);
 290         errcheck(((char *)compare_buf)[compressed_size] == 'A');
 291         errcheck(ret != 0);
 292         printf("\tcompress does not overrun\n");
 293
 294         /* Make sure decompression does not over-run. */
 295         memset(compare_buf, 'A', TEST_BUFFER_SIZE);
 296         ret = uncompress(compressed_buf, compressed_size,
 297                          compare_buf, uncompressed_size - 1,
 298                          NULL);
 299         errcheck(((char *)compare_buf)[uncompressed_size - 1] == 'A');
 300         errcheck(ret != 0);
 301         printf("\tuncompress does not overrun\n");
 302
 303         /* Got here, everything is fine. */
 304         ret = 0;
 305
 306 out:
 307         printf(" %s: %s\n", name, ret == 0 ? "ok" : "FAILED");
 308
 309         free(compare_buf);
 310         free(uncompressed_buf);
 311         free(compressed_buf);
 312
 313         return ret;
 314 }
 315
 316
 317 static int do_test_compression(cmd_tbl_t *cmdtp, int flag, int argc,
 318                                char * const argv[])
 319 {
 320         int err = 0;
 321
 322         err += run_test("gzip", compress_using_gzip, uncompress_using_gzip);
 323         err += run_test("bzip2", compress_using_bzip2, uncompress_using_bzip2);
 324         err += run_test("lzma", compress_using_lzma, uncompress_using_lzma);
 325         err += run_test("lzo", compress_using_lzo, uncompress_using_lzo);
 326
 327         printf("test_compression %s\n", err == 0 ? "ok" : "FAILED");
 328
 329         return err;
 330 }
 331
 332 U_BOOT_CMD(
 333         test_compression,       5,      1,      do_test_compression,
 334         "Basic test of compressors: gzip bzip2 lzma lzo", ""
 335 );