[J-u-boot.git] / test / compression.c

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

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