[people/ms/u-boot.git] / test / compression.c

/*
 * Copyright (c) 2013, The Chromium Authors
 *
 * SPDX-License-Identifier:	GPL-2.0+
 */

#include <common.h>
#include <bootm.h>
#include <command.h>
#include <malloc.h>
#include <mapmem.h>
#include <asm/io.h>

#include <u-boot/zlib.h>
#include <bzlib.h>

#include <lzma/LzmaTypes.h>
#include <lzma/LzmaDec.h>
#include <lzma/LzmaTools.h>

#include <linux/lzo.h>
#include <test/compression.h>
#include <test/suites.h>
#include <test/ut.h>

static const char plain[] =
	"I am a highly compressable bit of text.\n"
	"I am a highly compressable bit of text.\n"
	"I am a highly compressable bit of text.\n"
	"There are many like me, but this one is mine.\n"
	"If I were any shorter, there wouldn't be much sense in\n"
	"compressing me in the first place. At least with lzo, anyway,\n"
	"which appears to behave poorly in the face of short text\n"
	"messages.\n";

/* bzip2 -c /tmp/plain.txt > /tmp/plain.bz2 */
static const char bzip2_compressed[] =
	"\x42\x5a\x68\x39\x31\x41\x59\x26\x53\x59\xe5\x63\xdd\x09\x00\x00"
	"\x28\x57\x80\x00\x10\x40\x85\x20\x20\x04\x00\x3f\xef\xdf\xf0\x30"
	"\x00\xd6\xd0\x34\x91\x89\xa6\xf5\x4d\x19\x1a\x19\x0d\x02\x34\xd4"
	"\xc9\x00\x34\x34\x00\x02\x48\x41\x35\x4f\xd4\xc6\x88\xd3\x50\x3d"
	"\x4f\x51\x82\x4f\x88\xc3\x0d\x05\x62\x4f\x91\xa3\x52\x1b\xd0\x52"
	"\x41\x4a\xa3\x98\xc2\x6b\xca\xa3\x82\xa5\xac\x8b\x15\x99\x68\xad"
	"\xdf\x29\xd6\xf1\xf7\x5a\x10\xcd\x8c\x26\x61\x94\x95\xfe\x9e\x16"
	"\x18\x28\x69\xd4\x23\x64\xcc\x2b\xe5\xe8\x5f\x00\xa4\x70\x26\x2c"
	"\xee\xbd\x59\x6d\x6a\xec\xfc\x31\xda\x59\x0a\x14\x2a\x60\x1c\xf0"
	"\x04\x86\x73\x9a\xc5\x5b\x87\x3f\x5b\x4c\x93\xe6\xb5\x35\x0d\xa6"
	"\xb1\x2e\x62\x7b\xab\x67\xe7\x99\x2a\x14\x5e\x9f\x64\xcb\x96\xf4"
	"\x0d\x65\xd4\x39\xe6\x8b\x7e\xea\x1c\x03\x69\x97\x83\x58\x91\x96"
	"\xe1\xf0\x9d\xa4\x15\x8b\xb8\xc6\x93\xdc\x3d\xd9\x3c\x22\x55\xef"
	"\xfb\xbb\x2a\xd3\x87\xa2\x8b\x04\xd9\x19\xf8\xe2\xfd\x4f\xdb\x1a"
	"\x07\xc8\x60\xa3\x3f\xf8\xbb\x92\x29\xc2\x84\x87\x2b\x1e\xe8\x48";
static const unsigned long bzip2_compressed_size = 240;

/* lzma -z -c /tmp/plain.txt > /tmp/plain.lzma */
static const char lzma_compressed[] =
	"\x5d\x00\x00\x80\x00\xff\xff\xff\xff\xff\xff\xff\xff\x00\x24\x88"
	"\x08\x26\xd8\x41\xff\x99\xc8\xcf\x66\x3d\x80\xac\xba\x17\xf1\xc8"
	"\xb9\xdf\x49\x37\xb1\x68\xa0\x2a\xdd\x63\xd1\xa7\xa3\x66\xf8\x15"
	"\xef\xa6\x67\x8a\x14\x18\x80\xcb\xc7\xb1\xcb\x84\x6a\xb2\x51\x16"
	"\xa1\x45\xa0\xd6\x3e\x55\x44\x8a\x5c\xa0\x7c\xe5\xa8\xbd\x04\x57"
	"\x8f\x24\xfd\xb9\x34\x50\x83\x2f\xf3\x46\x3e\xb9\xb0\x00\x1a\xf5"
	"\xd3\x86\x7e\x8f\x77\xd1\x5d\x0e\x7c\xe1\xac\xde\xf8\x65\x1f\x4d"
	"\xce\x7f\xa7\x3d\xaa\xcf\x26\xa7\x58\x69\x1e\x4c\xea\x68\x8a\xe5"
	"\x89\xd1\xdc\x4d\xc7\xe0\x07\x42\xbf\x0c\x9d\x06\xd7\x51\xa2\x0b"
	"\x7c\x83\x35\xe1\x85\xdf\xee\xfb\xa3\xee\x2f\x47\x5f\x8b\x70\x2b"
	"\xe1\x37\xf3\x16\xf6\x27\x54\x8a\x33\x72\x49\xea\x53\x7d\x60\x0b"
	"\x21\x90\x66\xe7\x9e\x56\x61\x5d\xd8\xdc\x59\xf0\xac\x2f\xd6\x49"
	"\x6b\x85\x40\x08\x1f\xdf\x26\x25\x3b\x72\x44\xb0\xb8\x21\x2f\xb3"
	"\xd7\x9b\x24\x30\x78\x26\x44\x07\xc3\x33\xd1\x4d\x03\x1b\xe1\xff"
	"\xfd\xf5\x50\x8d\xca";
static const unsigned long lzma_compressed_size = 229;

/* lzop -c /tmp/plain.txt > /tmp/plain.lzo */
static const char lzo_compressed[] =
	"\x89\x4c\x5a\x4f\x00\x0d\x0a\x1a\x0a\x10\x30\x20\x60\x09\x40\x01"
	"\x05\x03\x00\x00\x09\x00\x00\x81\xb4\x52\x09\x54\xf1\x00\x00\x00"
	"\x00\x09\x70\x6c\x61\x69\x6e\x2e\x74\x78\x74\x65\xb1\x07\x9c\x00"
	"\x00\x01\x5e\x00\x00\x01\x0f\xc3\xc7\x7a\xe0\x00\x16\x49\x20\x61"
	"\x6d\x20\x61\x20\x68\x69\x67\x68\x6c\x79\x20\x63\x6f\x6d\x70\x72"
	"\x65\x73\x73\x61\x62\x6c\x65\x20\x62\x69\x74\x20\x6f\x66\x20\x74"
	"\x65\x78\x74\x2e\x0a\x20\x2f\x9c\x00\x00\x22\x54\x68\x65\x72\x65"
	"\x20\x61\x72\x65\x20\x6d\x61\x6e\x79\x20\x6c\x69\x6b\x65\x20\x6d"
	"\x65\x2c\x20\x62\x75\x74\x20\x74\x68\x69\x73\x20\x6f\x6e\x65\x20"
	"\x69\x73\x20\x6d\x69\x6e\x65\x2e\x0a\x49\x66\x20\x49\x20\x77\x84"
	"\x06\x0a\x6e\x79\x20\x73\x68\x6f\x72\x74\x65\x72\x2c\x20\x74\x90"
	"\x08\x00\x08\x77\x6f\x75\x6c\x64\x6e\x27\x74\x20\x62\x65\x20\x6d"
	"\x75\x63\x68\x20\x73\x65\x6e\x73\x65\x20\x69\x6e\x0a\xf8\x19\x02"
	"\x69\x6e\x67\x20\x6d\x64\x02\x64\x06\x00\x5a\x20\x66\x69\x72\x73"
	"\x74\x20\x70\x6c\x61\x63\x65\x2e\x20\x41\x74\x20\x6c\x65\x61\x73"
	"\x74\x20\x77\x69\x74\x68\x20\x6c\x7a\x6f\x2c\x20\x61\x6e\x79\x77"
	"\x61\x79\x2c\x0a\x77\x68\x69\x63\x68\x20\x61\x70\x70\x65\x61\x72"
	"\x73\x20\x74\x6f\x20\x62\x65\x68\x61\x76\x65\x20\x70\x6f\x6f\x72"
	"\x6c\x79\x20\x69\x6e\x20\x74\x68\x65\x20\x66\x61\x63\x65\x20\x6f"
	"\x66\x20\x73\x68\x6f\x72\x74\x20\x74\x65\x78\x74\x0a\x6d\x65\x73"
	"\x73\x61\x67\x65\x73\x2e\x0a\x11\x00\x00\x00\x00\x00\x00";
static const unsigned long lzo_compressed_size = 334;

/* lz4 -z /tmp/plain.txt > /tmp/plain.lz4 */
static const char lz4_compressed[] =
	"\x04\x22\x4d\x18\x64\x70\xb9\x01\x01\x00\x00\xff\x19\x49\x20\x61"
	"\x6d\x20\x61\x20\x68\x69\x67\x68\x6c\x79\x20\x63\x6f\x6d\x70\x72"
	"\x65\x73\x73\x61\x62\x6c\x65\x20\x62\x69\x74\x20\x6f\x66\x20\x74"
	"\x65\x78\x74\x2e\x0a\x28\x00\x3d\xf1\x25\x54\x68\x65\x72\x65\x20"
	"\x61\x72\x65\x20\x6d\x61\x6e\x79\x20\x6c\x69\x6b\x65\x20\x6d\x65"
	"\x2c\x20\x62\x75\x74\x20\x74\x68\x69\x73\x20\x6f\x6e\x65\x20\x69"
	"\x73\x20\x6d\x69\x6e\x65\x2e\x0a\x49\x66\x20\x49\x20\x77\x32\x00"
	"\xd1\x6e\x79\x20\x73\x68\x6f\x72\x74\x65\x72\x2c\x20\x74\x45\x00"
	"\xf4\x0b\x77\x6f\x75\x6c\x64\x6e\x27\x74\x20\x62\x65\x20\x6d\x75"
	"\x63\x68\x20\x73\x65\x6e\x73\x65\x20\x69\x6e\x0a\xcf\x00\x50\x69"
	"\x6e\x67\x20\x6d\x12\x00\x00\x32\x00\xf0\x11\x20\x66\x69\x72\x73"
	"\x74\x20\x70\x6c\x61\x63\x65\x2e\x20\x41\x74\x20\x6c\x65\x61\x73"
	"\x74\x20\x77\x69\x74\x68\x20\x6c\x7a\x6f\x2c\x63\x00\xf5\x14\x77"
	"\x61\x79\x2c\x0a\x77\x68\x69\x63\x68\x20\x61\x70\x70\x65\x61\x72"
	"\x73\x20\x74\x6f\x20\x62\x65\x68\x61\x76\x65\x20\x70\x6f\x6f\x72"
	"\x6c\x79\x4e\x00\x30\x61\x63\x65\x27\x01\x01\x95\x00\x01\x2d\x01"
	"\xb0\x0a\x6d\x65\x73\x73\x61\x67\x65\x73\x2e\x0a\x00\x00\x00\x00"
	"\x9d\x12\x8c\x9d";
static const unsigned long lz4_compressed_size = 276;


#define TEST_BUFFER_SIZE	512

typedef int (*mutate_func)(struct unit_test_state *uts, void *, unsigned long,
			   void *, unsigned long, unsigned long *);

static int compress_using_gzip(struct unit_test_state *uts,
			       void *in, unsigned long in_size,
			       void *out, unsigned long out_max,
			       unsigned long *out_size)
{
	int ret;
	unsigned long inout_size = out_max;

	ret = gzip(out, &inout_size, in, in_size);
	if (out_size)
		*out_size = inout_size;

	return ret;
}

static int uncompress_using_gzip(struct unit_test_state *uts,
				 void *in, unsigned long in_size,
				 void *out, unsigned long out_max,
				 unsigned long *out_size)
{
	int ret;
	unsigned long inout_size = in_size;

	ret = gunzip(out, out_max, in, &inout_size);
	if (out_size)
		*out_size = inout_size;

	return ret;
}

static int compress_using_bzip2(struct unit_test_state *uts,
				void *in, unsigned long in_size,
				void *out, unsigned long out_max,
				unsigned long *out_size)
{
	/* There is no bzip2 compression in u-boot, so fake it. */
	ut_asserteq(in_size, strlen(plain));
	ut_asserteq(0, memcmp(plain, in, in_size));

	if (bzip2_compressed_size > out_max)
		return -1;

	memcpy(out, bzip2_compressed, bzip2_compressed_size);
	if (out_size)
		*out_size = bzip2_compressed_size;

	return 0;
}

static int uncompress_using_bzip2(struct unit_test_state *uts,
				  void *in, unsigned long in_size,
				  void *out, unsigned long out_max,
				  unsigned long *out_size)
{
	int ret;
	unsigned int inout_size = out_max;

	ret = BZ2_bzBuffToBuffDecompress(out, &inout_size, in, in_size,
			CONFIG_SYS_MALLOC_LEN < (4096 * 1024), 0);
	if (out_size)
		*out_size = inout_size;

	return (ret != BZ_OK);
}

static int compress_using_lzma(struct unit_test_state *uts,
			       void *in, unsigned long in_size,
			       void *out, unsigned long out_max,
			       unsigned long *out_size)
{
	/* There is no lzma compression in u-boot, so fake it. */
	ut_asserteq(in_size,  strlen(plain));
	ut_asserteq(0, memcmp(plain, in, in_size));

	if (lzma_compressed_size > out_max)
		return -1;

	memcpy(out, lzma_compressed, lzma_compressed_size);
	if (out_size)
		*out_size = lzma_compressed_size;

	return 0;
}

static int uncompress_using_lzma(struct unit_test_state *uts,
				 void *in, unsigned long in_size,
				 void *out, unsigned long out_max,
				 unsigned long *out_size)
{
	int ret;
	SizeT inout_size = out_max;

	ret = lzmaBuffToBuffDecompress(out, &inout_size, in, in_size);
	if (out_size)
		*out_size = inout_size;

	return (ret != SZ_OK);
}

static int compress_using_lzo(struct unit_test_state *uts,
			      void *in, unsigned long in_size,
			      void *out, unsigned long out_max,
			      unsigned long *out_size)
{
	/* There is no lzo compression in u-boot, so fake it. */
	ut_asserteq(in_size,  strlen(plain));
	ut_asserteq(0, memcmp(plain, in, in_size));

	if (lzo_compressed_size > out_max)
		return -1;

	memcpy(out, lzo_compressed, lzo_compressed_size);
	if (out_size)
		*out_size = lzo_compressed_size;

	return 0;
}

static int uncompress_using_lzo(struct unit_test_state *uts,
				void *in, unsigned long in_size,
				void *out, unsigned long out_max,
				unsigned long *out_size)
{
	int ret;
	size_t input_size = in_size;
	size_t output_size = out_max;

	ret = lzop_decompress(in, input_size, out, &output_size);
	if (out_size)
		*out_size = output_size;

	return (ret != LZO_E_OK);
}

static int compress_using_lz4(struct unit_test_state *uts,
			      void *in, unsigned long in_size,
			      void *out, unsigned long out_max,
			      unsigned long *out_size)
{
	/* There is no lz4 compression in u-boot, so fake it. */
	ut_asserteq(in_size,  strlen(plain));
	ut_asserteq(0, memcmp(plain, in, in_size));

	if (lz4_compressed_size > out_max)
		return -1;

	memcpy(out, lz4_compressed, lz4_compressed_size);
	if (out_size)
		*out_size = lz4_compressed_size;

	return 0;
}

static int uncompress_using_lz4(struct unit_test_state *uts,
				void *in, unsigned long in_size,
				void *out, unsigned long out_max,
				unsigned long *out_size)
{
	int ret;
	size_t input_size = in_size;
	size_t output_size = out_max;

	ret = ulz4fn(in, input_size, out, &output_size);
	if (out_size)
		*out_size = output_size;

	return (ret != 0);
}

#define errcheck(statement) if (!(statement)) { \
	fprintf(stderr, "\tFailed: %s\n", #statement); \
	ret = 1; \
	goto out; \
}

struct buf_state {
	ulong orig_size;
	ulong compressed_size;
	ulong uncompressed_size;
	void *orig_buf;
	void *compressed_buf;
	void *uncompressed_buf;
	void *compare_buf;
};

static int run_test_internal(struct unit_test_state *uts, char *name,
			     mutate_func compress, mutate_func uncompress,
			     struct buf_state *buf)
{
	int ret;

	/* Compress works as expected. */
	printf("\torig_size:%lu\n", buf->orig_size);
	memset(buf->compressed_buf, 'A', TEST_BUFFER_SIZE);
	errcheck(compress(uts, buf->orig_buf, buf->orig_size,
			  buf->compressed_buf, buf->compressed_size,
			  &buf->compressed_size) == 0);
	printf("\tcompressed_size:%lu\n", buf->compressed_size);
	errcheck(buf->compressed_size > 0);
	errcheck(buf->compressed_size < buf->orig_size);
	errcheck(((char *)buf->compressed_buf)[buf->compressed_size - 1] !=
			'A');
	errcheck(((char *)buf->compressed_buf)[buf->compressed_size] == 'A');

	/* Uncompresses with space remaining. */
	errcheck(uncompress(uts, buf->compressed_buf, buf->compressed_size,
			    buf->uncompressed_buf, buf->uncompressed_size,
			    &buf->uncompressed_size) == 0);
	printf("\tuncompressed_size:%lu\n", buf->uncompressed_size);
	errcheck(buf->uncompressed_size == buf->orig_size);
	errcheck(memcmp(buf->orig_buf, buf->uncompressed_buf,
			buf->orig_size) == 0);

	/* Uncompresses with exactly the right size output buffer. */
	memset(buf->uncompressed_buf, 'A', TEST_BUFFER_SIZE);
	errcheck(uncompress(uts, buf->compressed_buf, buf->compressed_size,
			    buf->uncompressed_buf, buf->orig_size,
			    &buf->uncompressed_size) == 0);
	errcheck(buf->uncompressed_size == buf->orig_size);
	errcheck(memcmp(buf->orig_buf, buf->uncompressed_buf,
			buf->orig_size) == 0);
	errcheck(((char *)buf->uncompressed_buf)[buf->orig_size] == 'A');

	/* Make sure compression does not over-run. */
	memset(buf->compare_buf, 'A', TEST_BUFFER_SIZE);
	ret = compress(uts, buf->orig_buf, buf->orig_size,
		       buf->compare_buf, buf->compressed_size - 1,
		       NULL);
	errcheck(((char *)buf->compare_buf)[buf->compressed_size] == 'A');
	errcheck(ret != 0);
	printf("\tcompress does not overrun\n");

	/* Make sure decompression does not over-run. */
	memset(buf->compare_buf, 'A', TEST_BUFFER_SIZE);
	ret = uncompress(uts, buf->compressed_buf, buf->compressed_size,
			 buf->compare_buf, buf->uncompressed_size - 1,
			 NULL);
	errcheck(((char *)buf->compare_buf)[buf->uncompressed_size - 1] == 'A');
	errcheck(ret != 0);
	printf("\tuncompress does not overrun\n");

	/* Got here, everything is fine. */
	ret = 0;

out:
	return ret;
}

static int run_test(struct unit_test_state *uts, char *name,
		    mutate_func compress, mutate_func uncompress)
{
	struct buf_state sbuf, *buf = &sbuf;
	int ret;

	printf(" testing %s ...\n", name);

	buf->orig_buf = (void *)plain;
	buf->orig_size = strlen(buf->orig_buf); /* Trailing NUL not included */
	errcheck(buf->orig_size > 0);

	buf->compressed_size = TEST_BUFFER_SIZE;
	buf->uncompressed_size = TEST_BUFFER_SIZE;
	buf->compressed_buf = malloc(buf->compressed_size);
	errcheck(buf->compressed_buf);
	buf->uncompressed_buf = malloc(buf->uncompressed_size);
	errcheck(buf->uncompressed_buf);
	buf->compare_buf = malloc(buf->uncompressed_size);
	errcheck(buf->compare_buf);

	ret = run_test_internal(uts, name, compress, uncompress, buf);
out:
	printf(" %s: %s\n", name, ret == 0 ? "ok" : "FAILED");

	free(buf->compare_buf);
	free(buf->uncompressed_buf);
	free(buf->compressed_buf);

	return ret;
}

static int compression_test_gzip(struct unit_test_state *uts)
{
	return run_test(uts, "gzip", compress_using_gzip,
			uncompress_using_gzip);
}
COMPRESSION_TEST(compression_test_gzip, 0);

static int compression_test_bzip2(struct unit_test_state *uts)
{
	return run_test(uts, "bzip2", compress_using_bzip2,
			uncompress_using_bzip2);
}
COMPRESSION_TEST(compression_test_bzip2, 0);

static int compression_test_lzma(struct unit_test_state *uts)
{
	return run_test(uts, "lzma", compress_using_lzma,
			uncompress_using_lzma);
}
COMPRESSION_TEST(compression_test_lzma, 0);

static int compression_test_lzo(struct unit_test_state *uts)
{
	return run_test(uts, "lzo", compress_using_lzo, uncompress_using_lzo);
}
COMPRESSION_TEST(compression_test_lzo, 0);

static int compression_test_lz4(struct unit_test_state *uts)
{
	return run_test(uts, "lz4", compress_using_lz4, uncompress_using_lz4);
}
COMPRESSION_TEST(compression_test_lz4, 0);

static int compress_using_none(struct unit_test_state *uts,
			       void *in, unsigned long in_size,
			       void *out, unsigned long out_max,
			       unsigned long *out_size)
{
	/* Here we just copy */
	memcpy(out, in, in_size);
	*out_size = in_size;

	return 0;
}

/**
 * run_bootm_test() - Run tests on the bootm decopmression function
 *
 * @comp_type:	Compression type to test
 * @compress:	Our function to compress data
 * @return 0 if OK, non-zero on failure
 */
static int run_bootm_test(struct unit_test_state *uts, int comp_type,
			  mutate_func compress)
{
	ulong compress_size = 1024;
	void *compress_buff;
	int unc_len;
	int err = 0;
	const ulong image_start = 0;
	const ulong load_addr = 0x1000;
	ulong load_end;

	printf("Testing: %s\n", genimg_get_comp_name(comp_type));
	compress_buff = map_sysmem(image_start, 0);
	unc_len = strlen(plain);
	compress(uts, (void *)plain, unc_len, compress_buff, compress_size,
		 &compress_size);
	err = bootm_decomp_image(comp_type, load_addr, image_start,
				 IH_TYPE_KERNEL, map_sysmem(load_addr, 0),
				 compress_buff, compress_size, unc_len,
				 &load_end);
	ut_assertok(err);
	err = bootm_decomp_image(comp_type, load_addr, image_start,
				 IH_TYPE_KERNEL, map_sysmem(load_addr, 0),
				 compress_buff, compress_size, unc_len - 1,
				 &load_end);
	ut_assert(err);

	/* We can't detect corruption when not decompressing */
	if (comp_type == IH_COMP_NONE)
		return 0;
	memset(compress_buff + compress_size / 2, '\x49',
	       compress_size / 2);
	err = bootm_decomp_image(comp_type, load_addr, image_start,
				 IH_TYPE_KERNEL, map_sysmem(load_addr, 0),
				 compress_buff, compress_size, 0x10000,
				 &load_end);
	ut_assert(err);

	return 0;
}

static int compression_test_bootm_gzip(struct unit_test_state *uts)
{
	return run_bootm_test(uts, IH_COMP_GZIP, compress_using_gzip);
}
COMPRESSION_TEST(compression_test_bootm_gzip, 0);

static int compression_test_bootm_bzip2(struct unit_test_state *uts)
{
	return run_bootm_test(uts, IH_COMP_BZIP2, compress_using_bzip2);
}
COMPRESSION_TEST(compression_test_bootm_bzip2, 0);

static int compression_test_bootm_lzma(struct unit_test_state *uts)
{
	return run_bootm_test(uts, IH_COMP_LZMA, compress_using_lzma);
}
COMPRESSION_TEST(compression_test_bootm_lzma, 0);

static int compression_test_bootm_lzo(struct unit_test_state *uts)
{
	return run_bootm_test(uts, IH_COMP_LZO, compress_using_lzo);
}
COMPRESSION_TEST(compression_test_bootm_lzo, 0);

static int compression_test_bootm_lz4(struct unit_test_state *uts)
{
	return run_bootm_test(uts, IH_COMP_LZ4, compress_using_lz4);
}
COMPRESSION_TEST(compression_test_bootm_lz4, 0);

static int compression_test_bootm_none(struct unit_test_state *uts)
{
	return run_bootm_test(uts, IH_COMP_NONE, compress_using_none);
}
COMPRESSION_TEST(compression_test_bootm_none, 0);

int do_ut_compression(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
	struct unit_test *tests = ll_entry_start(struct unit_test,
						 compression_test);
	const int n_ents = ll_entry_count(struct unit_test, compression_test);

	return cmd_ut_category("compression", tests, n_ents, argc, argv);
}
Commit	Line	Data
3153e915 KC	1	/*
	2	* Copyright (c) 2013, The Chromium Authors
	3	*
	4	* SPDX-License-Identifier: GPL-2.0+
	5	*/
	6
3153e915	7	#include <common.h>
6ed4dc78	8	#include <bootm.h>
3153e915 KC	9	#include <command.h>
3153e915 KC	10	#include <malloc.h>
0eb25b61	11	#include <mapmem.h>
6ed4dc78	12	#include <asm/io.h>
3153e915 KC	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>
0aac10f2 SG	22	#include <test/compression.h>
	23	#include <test/suites.h>
	24	#include <test/ut.h>
3153e915 KC	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
027b728d JW	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
3153e915 KC	121
	122	#define TEST_BUFFER_SIZE 512
	123
0aac10f2 SG	124	typedef int (mutate_func)(struct unit_test_state uts, void *, unsigned long,
0aac10f2 SG	125	void , unsigned long, unsigned long );
3153e915	126
0aac10f2 SG	127	static int compress_using_gzip(struct unit_test_state *uts,
0aac10f2 SG	128	void *in, unsigned long in_size,
3153e915 KC	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
0aac10f2 SG	142	static int uncompress_using_gzip(struct unit_test_state *uts,
0aac10f2 SG	143	void *in, unsigned long in_size,
3153e915 KC	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
0aac10f2 SG	157	static int compress_using_bzip2(struct unit_test_state *uts,
0aac10f2 SG	158	void *in, unsigned long in_size,
93e14596 WD	159	void *out, unsigned long out_max,
93e14596 WD	160	unsigned long *out_size)
3153e915 KC	161	{
3153e915 KC	162	/* There is no bzip2 compression in u-boot, so fake it. */
0aac10f2 SG	163	ut_asserteq(in_size, strlen(plain));
0aac10f2 SG	164	ut_asserteq(0, memcmp(plain, in, in_size));
3153e915 KC	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
0aac10f2 SG	176	static int uncompress_using_bzip2(struct unit_test_state *uts,
0aac10f2 SG	177	void *in, unsigned long in_size,
3153e915 KC	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
0aac10f2 SG	192	static int compress_using_lzma(struct unit_test_state *uts,
0aac10f2 SG	193	void *in, unsigned long in_size,
3153e915 KC	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. */
0aac10f2 SG	198	ut_asserteq(in_size, strlen(plain));
0aac10f2 SG	199	ut_asserteq(0, memcmp(plain, in, in_size));
3153e915 KC	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
0aac10f2 SG	211	static int uncompress_using_lzma(struct unit_test_state *uts,
0aac10f2 SG	212	void *in, unsigned long in_size,
3153e915 KC	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
0aac10f2 SG	226	static int compress_using_lzo(struct unit_test_state *uts,
0aac10f2 SG	227	void *in, unsigned long in_size,
3153e915 KC	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. */
0aac10f2 SG	232	ut_asserteq(in_size, strlen(plain));
0aac10f2 SG	233	ut_asserteq(0, memcmp(plain, in, in_size));
3153e915 KC	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
0aac10f2 SG	245	static int uncompress_using_lzo(struct unit_test_state *uts,
0aac10f2 SG	246	void *in, unsigned long in_size,
3153e915 KC	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
0aac10f2 SG	261	static int compress_using_lz4(struct unit_test_state *uts,
0aac10f2 SG	262	void *in, unsigned long in_size,
027b728d JW	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. */
0aac10f2 SG	267	ut_asserteq(in_size, strlen(plain));
0aac10f2 SG	268	ut_asserteq(0, memcmp(plain, in, in_size));
027b728d JW	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
0aac10f2 SG	280	static int uncompress_using_lz4(struct unit_test_state *uts,
0aac10f2 SG	281	void *in, unsigned long in_size,
027b728d JW	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
3153e915 KC	296	#define errcheck(statement) if (!(statement)) { \
	297	fprintf(stderr, "\tFailed: %s\n", #statement); \
	298	ret = 1; \
	299	goto out; \
	300	}
	301
49f22c38 SG	302	struct buf_state {
	303	ulong orig_size;
	304	ulong compressed_size;
	305	ulong uncompressed_size;
3153e915	306	void *orig_buf;
49f22c38 SG	307	void *compressed_buf;
	308	void *uncompressed_buf;
	309	void *compare_buf;
	310	};
	311
0aac10f2	312	static int run_test_internal(struct unit_test_state uts, char name,
49f22c38 SG	313	mutate_func compress, mutate_func uncompress,
	314	struct buf_state *buf)
	315	{
3153e915 KC	316	int ret;
3153e915 KC	317
3153e915	318	/* Compress works as expected. */
49f22c38 SG	319	printf("\torig_size:%lu\n", buf->orig_size);
49f22c38 SG	320	memset(buf->compressed_buf, 'A', TEST_BUFFER_SIZE);
0aac10f2 SG	321	errcheck(compress(uts, buf->orig_buf, buf->orig_size,
	322	buf->compressed_buf, buf->compressed_size,
	323	&buf->compressed_size) == 0);
49f22c38 SG	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');
3153e915 KC	330
3153e915 KC	331	/* Uncompresses with space remaining. */
0aac10f2	332	errcheck(uncompress(uts, buf->compressed_buf, buf->compressed_size,
49f22c38 SG	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);
3153e915 KC	339
3153e915 KC	340	/* Uncompresses with exactly the right size output buffer. */
49f22c38	341	memset(buf->uncompressed_buf, 'A', TEST_BUFFER_SIZE);
0aac10f2	342	errcheck(uncompress(uts, buf->compressed_buf, buf->compressed_size,
49f22c38 SG	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');
3153e915 KC	349
3153e915 KC	350	/* Make sure compression does not over-run. */
49f22c38	351	memset(buf->compare_buf, 'A', TEST_BUFFER_SIZE);
0aac10f2	352	ret = compress(uts, buf->orig_buf, buf->orig_size,
49f22c38	353	buf->compare_buf, buf->compressed_size - 1,
3153e915	354	NULL);
49f22c38	355	errcheck(((char *)buf->compare_buf)[buf->compressed_size] == 'A');
3153e915 KC	356	errcheck(ret != 0);
	357	printf("\tcompress does not overrun\n");
	358
	359	/* Make sure decompression does not over-run. */
49f22c38	360	memset(buf->compare_buf, 'A', TEST_BUFFER_SIZE);
0aac10f2	361	ret = uncompress(uts, buf->compressed_buf, buf->compressed_size,
49f22c38	362	buf->compare_buf, buf->uncompressed_size - 1,
3153e915	363	NULL);
49f22c38	364	errcheck(((char *)buf->compare_buf)[buf->uncompressed_size - 1] == 'A');
3153e915 KC	365	errcheck(ret != 0);
	366	printf("\tuncompress does not overrun\n");
	367
	368	/* Got here, everything is fine. */
	369	ret = 0;
	370
49f22c38 SG	371	out:
	372	return ret;
	373	}
	374
0aac10f2 SG	375	static int run_test(struct unit_test_state uts, char name,
0aac10f2 SG	376	mutate_func compress, mutate_func uncompress)
49f22c38 SG	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
0aac10f2	396	ret = run_test_internal(uts, name, compress, uncompress, buf);
3153e915 KC	397	out:
	398	printf(" %s: %s\n", name, ret == 0 ? "ok" : "FAILED");
	399
49f22c38 SG	400	free(buf->compare_buf);
	401	free(buf->uncompressed_buf);
	402	free(buf->compressed_buf);
3153e915 KC	403
	404	return ret;
	405	}
	406
0aac10f2	407	static int compression_test_gzip(struct unit_test_state *uts)
3153e915	408	{
0aac10f2 SG	409	return run_test(uts, "gzip", compress_using_gzip,
	410	uncompress_using_gzip);
	411	}
	412	COMPRESSION_TEST(compression_test_gzip, 0);
3153e915	413
0aac10f2 SG	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);
3153e915	427
0aac10f2 SG	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);
3153e915	433
0aac10f2 SG	434	static int compression_test_lz4(struct unit_test_state *uts)
	435	{
	436	return run_test(uts, "lz4", compress_using_lz4, uncompress_using_lz4);
3153e915	437	}
0aac10f2	438	COMPRESSION_TEST(compression_test_lz4, 0);
3153e915	439
0aac10f2 SG	440	static int compress_using_none(struct unit_test_state *uts,
0aac10f2 SG	441	void *in, unsigned long in_size,
6ed4dc78 SG	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	*/
0aac10f2 SG	459	static int run_bootm_test(struct unit_test_state *uts, int comp_type,
0aac10f2 SG	460	mutate_func compress)
6ed4dc78 SG	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);
0aac10f2	473	compress(uts, (void *)plain, unc_len, compress_buff, compress_size,
6ed4dc78 SG	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);
0aac10f2	479	ut_assertok(err);
6ed4dc78 SG	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);
0aac10f2	484	ut_assert(err);
6ed4dc78 SG	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);
0aac10f2	495	ut_assert(err);
6ed4dc78 SG	496
	497	return 0;
	498	}
	499
0aac10f2	500	static int compression_test_bootm_gzip(struct unit_test_state *uts)
6ed4dc78	501	{
0aac10f2 SG	502	return run_bootm_test(uts, IH_COMP_GZIP, compress_using_gzip);
	503	}
	504	COMPRESSION_TEST(compression_test_bootm_gzip, 0);
6ed4dc78	505
0aac10f2 SG	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);
6ed4dc78	511
0aac10f2 SG	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);
6ed4dc78	517
0aac10f2 SG	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);
6ed4dc78	521	}
0aac10f2	522	COMPRESSION_TEST(compression_test_bootm_lzo, 0);
6ed4dc78	523
0aac10f2 SG	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);
6ed4dc78	529
0aac10f2 SG	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	}