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

// SPDX-License-Identifier: GPL-2.0+
/*
 * Copyright (c) 2018, Google Inc. All rights reserved.
 */

#include <common.h>
#include <bloblist.h>
#include <log.h>
#include <mapmem.h>
#include <test/suites.h>
#include <test/test.h>
#include <test/ut.h>

DECLARE_GLOBAL_DATA_PTR;

/* Declare a new compression test */
#define BLOBLIST_TEST(_name, _flags) \
		UNIT_TEST(_name, _flags, bloblist_test)

enum {
	TEST_TAG		= 1,
	TEST_TAG2		= 2,
	TEST_TAG_MISSING	= 3,

	TEST_SIZE		= 10,
	TEST_SIZE2		= 20,
	TEST_SIZE_LARGE		= 0xe0,

	TEST_ADDR		= CONFIG_BLOBLIST_ADDR,
	TEST_BLOBLIST_SIZE	= 0x100,
};

static struct bloblist_hdr *clear_bloblist(void)
{
	struct bloblist_hdr *hdr;

	/*
	 * Clear out any existing bloblist so we have a clean slate. Zero the
	 * header so that existing records are removed, but set everything else
	 * to 0xff for testing purposes.
	 */
	hdr = map_sysmem(CONFIG_BLOBLIST_ADDR, TEST_BLOBLIST_SIZE);
	memset(hdr, '\xff', TEST_BLOBLIST_SIZE);
	memset(hdr, '\0', sizeof(*hdr));

	return hdr;
}

static int check_zero(void *data, int size)
{
	u8 *ptr;
	int i;

	for (ptr = data, i = 0; i < size; i++, ptr++) {
		if (*ptr)
			return -EINVAL;
	}

	return 0;
}

static int bloblist_test_init(struct unit_test_state *uts)
{
	struct bloblist_hdr *hdr;

	hdr = clear_bloblist();
	ut_asserteq(-ENOENT, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
	ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE, 0));
	hdr->version++;
	ut_asserteq(-EPROTONOSUPPORT, bloblist_check(TEST_ADDR,
						     TEST_BLOBLIST_SIZE));

	ut_asserteq(-ENOSPC, bloblist_new(TEST_ADDR, 0x10, 0));
	ut_asserteq(-EFAULT, bloblist_new(1, TEST_BLOBLIST_SIZE, 0));
	ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE, 0));

	ut_asserteq(-EIO, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
	ut_assertok(bloblist_finish());
	ut_assertok(bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
	hdr->flags++;
	ut_asserteq(-EIO, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));

	return 1;
}
BLOBLIST_TEST(bloblist_test_init, 0);

static int bloblist_test_blob(struct unit_test_state *uts)
{
	struct bloblist_hdr *hdr;
	struct bloblist_rec *rec, *rec2;
	char *data;

	/* At the start there should be no records */
	hdr = clear_bloblist();
	ut_assertnull(bloblist_find(TEST_TAG, TEST_BLOBLIST_SIZE));
	ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE, 0));

	/* Add a record and check that we can find it */
	data = bloblist_add(TEST_TAG, TEST_SIZE);
	rec = (void *)(hdr + 1);
	ut_asserteq_ptr(rec + 1, data);
	data = bloblist_find(TEST_TAG, TEST_SIZE);
	ut_asserteq_ptr(rec + 1, data);

	/* Check the data is zeroed */
	ut_assertok(check_zero(data, TEST_SIZE));

	/* Check the 'ensure' method */
	ut_asserteq_ptr(data, bloblist_ensure(TEST_TAG, TEST_SIZE));
	ut_assertnull(bloblist_ensure(TEST_TAG, TEST_SIZE2));
	rec2 = (struct bloblist_rec *)(data + ALIGN(TEST_SIZE, BLOBLIST_ALIGN));
	ut_assertok(check_zero(data, TEST_SIZE));

	/* Check for a non-existent record */
	ut_asserteq_ptr(data, bloblist_ensure(TEST_TAG, TEST_SIZE));
	ut_asserteq_ptr(rec2 + 1, bloblist_ensure(TEST_TAG2, TEST_SIZE2));
	ut_assertnull(bloblist_find(TEST_TAG_MISSING, 0));

	return 0;
}
BLOBLIST_TEST(bloblist_test_blob, 0);

/* Check bloblist_ensure_size_ret() */
static int bloblist_test_blob_ensure(struct unit_test_state *uts)
{
	void *data, *data2;
	int size;

	/* At the start there should be no records */
	clear_bloblist();
	ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE, 0));

	/* Test with an empty bloblist */
	size = TEST_SIZE;
	ut_assertok(bloblist_ensure_size_ret(TEST_TAG, &size, &data));
	ut_asserteq(TEST_SIZE, size);
	ut_assertok(check_zero(data, TEST_SIZE));

	/* Check that we get the same thing again */
	ut_assertok(bloblist_ensure_size_ret(TEST_TAG, &size, &data2));
	ut_asserteq(TEST_SIZE, size);
	ut_asserteq_ptr(data, data2);

	/* Check that the size remains the same */
	size = TEST_SIZE2;
	ut_assertok(bloblist_ensure_size_ret(TEST_TAG, &size, &data));
	ut_asserteq(TEST_SIZE, size);

	/* Check running out of space */
	size = TEST_SIZE_LARGE;
	ut_asserteq(-ENOSPC, bloblist_ensure_size_ret(TEST_TAG2, &size, &data));

	return 0;
}
BLOBLIST_TEST(bloblist_test_blob_ensure, 0);

static int bloblist_test_bad_blob(struct unit_test_state *uts)
{
	struct bloblist_hdr *hdr;
	void *data;

	hdr = clear_bloblist();
	ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE, 0));
	data = hdr + 1;
	data += sizeof(struct bloblist_rec);
	ut_asserteq_ptr(data, bloblist_ensure(TEST_TAG, TEST_SIZE));
	ut_asserteq_ptr(data, bloblist_ensure(TEST_TAG, TEST_SIZE));

	return 0;
}
BLOBLIST_TEST(bloblist_test_bad_blob, 0);

static int bloblist_test_checksum(struct unit_test_state *uts)
{
	struct bloblist_hdr *hdr;
	char *data, *data2;

	hdr = clear_bloblist();
	ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE, 0));
	ut_assertok(bloblist_finish());
	ut_assertok(bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));

	/*
	 * Now change things amd make sure that the checksum notices. We cannot
	 * change the size or alloced fields, since that will crash the code.
	 * It has to rely on these being correct.
	 */
	hdr->flags--;
	ut_asserteq(-EIO, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
	hdr->flags++;

	hdr->size--;
	ut_asserteq(-EFBIG, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
	hdr->size++;

	hdr->spare++;
	ut_asserteq(-EIO, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
	hdr->spare--;

	hdr->chksum++;
	ut_asserteq(-EIO, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
	hdr->chksum--;

	/* Make sure the checksum changes when we add blobs */
	data = bloblist_add(TEST_TAG, TEST_SIZE);
	ut_asserteq(-EIO, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));

	data2 = bloblist_add(TEST_TAG2, TEST_SIZE2);
	ut_asserteq(-EIO, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
	ut_assertok(bloblist_finish());

	/* It should also change if we change the data */
	ut_assertok(bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
	*data += 1;
	ut_asserteq(-EIO, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
	*data -= 1;

	ut_assertok(bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
	*data2 += 1;
	ut_asserteq(-EIO, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
	*data2 -= 1;

	/*
	 * Changing data outside the range of valid data should not affect
	 * the checksum.
	 */
	ut_assertok(bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
	data[TEST_SIZE]++;
	data2[TEST_SIZE2]++;
	ut_assertok(bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));

	return 0;
}

BLOBLIST_TEST(bloblist_test_checksum, 0);

int do_ut_bloblist(struct cmd_tbl *cmdtp, int flag, int argc,
		   char *const argv[])
{
	struct unit_test *tests = ll_entry_start(struct unit_test,
						 bloblist_test);
	const int n_ents = ll_entry_count(struct unit_test, bloblist_test);

	return cmd_ut_category("bloblist", "bloblist_test_",
			       tests, n_ents, argc, argv);
}
Commit	Line	Data
919e7a8f SG	1	// SPDX-License-Identifier: GPL-2.0+
	2	/*
	3	* Copyright (c) 2018, Google Inc. All rights reserved.
	4	*/
	5
	6	#include <common.h>
	7	#include <bloblist.h>
	8	#include <log.h>
	9	#include <mapmem.h>
	10	#include <test/suites.h>
	11	#include <test/test.h>
	12	#include <test/ut.h>
	13
	14	DECLARE_GLOBAL_DATA_PTR;
	15
	16	/* Declare a new compression test */
	17	#define BLOBLIST_TEST(_name, _flags) \
	18	UNIT_TEST(_name, _flags, bloblist_test)
	19
	20	enum {
	21	TEST_TAG = 1,
	22	TEST_TAG2 = 2,
	23	TEST_TAG_MISSING = 3,
	24
	25	TEST_SIZE = 10,
	26	TEST_SIZE2 = 20,
5b044548	27	TEST_SIZE_LARGE = 0xe0,
919e7a8f SG	28
	29	TEST_ADDR = CONFIG_BLOBLIST_ADDR,
	30	TEST_BLOBLIST_SIZE = 0x100,
	31	};
	32
	33	static struct bloblist_hdr *clear_bloblist(void)
	34	{
	35	struct bloblist_hdr *hdr;
	36
b83994de SG	37	/*
	38	* Clear out any existing bloblist so we have a clean slate. Zero the
	39	* header so that existing records are removed, but set everything else
	40	* to 0xff for testing purposes.
	41	*/
919e7a8f	42	hdr = map_sysmem(CONFIG_BLOBLIST_ADDR, TEST_BLOBLIST_SIZE);
b83994de SG	43	memset(hdr, '\xff', TEST_BLOBLIST_SIZE);
b83994de SG	44	memset(hdr, '\0', sizeof(*hdr));
919e7a8f SG	45
	46	return hdr;
	47	}
	48
b83994de SG	49	static int check_zero(void *data, int size)
	50	{
	51	u8 *ptr;
	52	int i;
	53
	54	for (ptr = data, i = 0; i < size; i++, ptr++) {
	55	if (*ptr)
	56	return -EINVAL;
	57	}
	58
	59	return 0;
	60	}
	61
919e7a8f SG	62	static int bloblist_test_init(struct unit_test_state *uts)
	63	{
	64	struct bloblist_hdr *hdr;
	65
	66	hdr = clear_bloblist();
	67	ut_asserteq(-ENOENT, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
	68	ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE, 0));
	69	hdr->version++;
	70	ut_asserteq(-EPROTONOSUPPORT, bloblist_check(TEST_ADDR,
	71	TEST_BLOBLIST_SIZE));
	72
	73	ut_asserteq(-ENOSPC, bloblist_new(TEST_ADDR, 0x10, 0));
	74	ut_asserteq(-EFAULT, bloblist_new(1, TEST_BLOBLIST_SIZE, 0));
	75	ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE, 0));
	76
	77	ut_asserteq(-EIO, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
	78	ut_assertok(bloblist_finish());
	79	ut_assertok(bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
	80	hdr->flags++;
	81	ut_asserteq(-EIO, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
	82
	83	return 1;
	84	}
	85	BLOBLIST_TEST(bloblist_test_init, 0);
	86
	87	static int bloblist_test_blob(struct unit_test_state *uts)
	88	{
	89	struct bloblist_hdr *hdr;
	90	struct bloblist_rec rec, rec2;
	91	char *data;
	92
	93	/* At the start there should be no records */
	94	hdr = clear_bloblist();
	95	ut_assertnull(bloblist_find(TEST_TAG, TEST_BLOBLIST_SIZE));
	96	ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE, 0));
	97
	98	/* Add a record and check that we can find it */
	99	data = bloblist_add(TEST_TAG, TEST_SIZE);
	100	rec = (void *)(hdr + 1);
	101	ut_asserteq_ptr(rec + 1, data);
	102	data = bloblist_find(TEST_TAG, TEST_SIZE);
	103	ut_asserteq_ptr(rec + 1, data);
	104
b83994de SG	105	/* Check the data is zeroed */
	106	ut_assertok(check_zero(data, TEST_SIZE));
	107
919e7a8f SG	108	/* Check the 'ensure' method */
	109	ut_asserteq_ptr(data, bloblist_ensure(TEST_TAG, TEST_SIZE));
	110	ut_assertnull(bloblist_ensure(TEST_TAG, TEST_SIZE2));
	111	rec2 = (struct bloblist_rec *)(data + ALIGN(TEST_SIZE, BLOBLIST_ALIGN));
b83994de	112	ut_assertok(check_zero(data, TEST_SIZE));
919e7a8f SG	113
	114	/* Check for a non-existent record */
	115	ut_asserteq_ptr(data, bloblist_ensure(TEST_TAG, TEST_SIZE));
	116	ut_asserteq_ptr(rec2 + 1, bloblist_ensure(TEST_TAG2, TEST_SIZE2));
	117	ut_assertnull(bloblist_find(TEST_TAG_MISSING, 0));
	118
	119	return 0;
	120	}
	121	BLOBLIST_TEST(bloblist_test_blob, 0);
	122
5b044548 SG	123	/* Check bloblist_ensure_size_ret() */
	124	static int bloblist_test_blob_ensure(struct unit_test_state *uts)
	125	{
	126	void data, data2;
	127	int size;
	128
	129	/* At the start there should be no records */
	130	clear_bloblist();
	131	ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE, 0));
	132
	133	/* Test with an empty bloblist */
	134	size = TEST_SIZE;
	135	ut_assertok(bloblist_ensure_size_ret(TEST_TAG, &size, &data));
	136	ut_asserteq(TEST_SIZE, size);
b83994de	137	ut_assertok(check_zero(data, TEST_SIZE));
5b044548 SG	138
	139	/* Check that we get the same thing again */
	140	ut_assertok(bloblist_ensure_size_ret(TEST_TAG, &size, &data2));
	141	ut_asserteq(TEST_SIZE, size);
	142	ut_asserteq_ptr(data, data2);
	143
	144	/* Check that the size remains the same */
	145	size = TEST_SIZE2;
	146	ut_assertok(bloblist_ensure_size_ret(TEST_TAG, &size, &data));
	147	ut_asserteq(TEST_SIZE, size);
	148
	149	/* Check running out of space */
	150	size = TEST_SIZE_LARGE;
	151	ut_asserteq(-ENOSPC, bloblist_ensure_size_ret(TEST_TAG2, &size, &data));
	152
	153	return 0;
	154	}
	155	BLOBLIST_TEST(bloblist_test_blob_ensure, 0);
	156
919e7a8f SG	157	static int bloblist_test_bad_blob(struct unit_test_state *uts)
	158	{
	159	struct bloblist_hdr *hdr;
	160	void *data;
	161
	162	hdr = clear_bloblist();
	163	ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE, 0));
	164	data = hdr + 1;
	165	data += sizeof(struct bloblist_rec);
	166	ut_asserteq_ptr(data, bloblist_ensure(TEST_TAG, TEST_SIZE));
	167	ut_asserteq_ptr(data, bloblist_ensure(TEST_TAG, TEST_SIZE));
	168
	169	return 0;
	170	}
	171	BLOBLIST_TEST(bloblist_test_bad_blob, 0);
	172
	173	static int bloblist_test_checksum(struct unit_test_state *uts)
	174	{
	175	struct bloblist_hdr *hdr;
	176	char data, data2;
	177
	178	hdr = clear_bloblist();
	179	ut_assertok(bloblist_new(TEST_ADDR, TEST_BLOBLIST_SIZE, 0));
	180	ut_assertok(bloblist_finish());
	181	ut_assertok(bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
	182
	183	/*
	184	* Now change things amd make sure that the checksum notices. We cannot
	185	* change the size or alloced fields, since that will crash the code.
	186	* It has to rely on these being correct.
	187	*/
	188	hdr->flags--;
	189	ut_asserteq(-EIO, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
	190	hdr->flags++;
	191
	192	hdr->size--;
	193	ut_asserteq(-EFBIG, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
	194	hdr->size++;
	195
	196	hdr->spare++;
	197	ut_asserteq(-EIO, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
	198	hdr->spare--;
	199
	200	hdr->chksum++;
	201	ut_asserteq(-EIO, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
	202	hdr->chksum--;
	203
	204	/* Make sure the checksum changes when we add blobs */
	205	data = bloblist_add(TEST_TAG, TEST_SIZE);
	206	ut_asserteq(-EIO, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
	207
	208	data2 = bloblist_add(TEST_TAG2, TEST_SIZE2);
	209	ut_asserteq(-EIO, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
	210	ut_assertok(bloblist_finish());
	211
	212	/* It should also change if we change the data */
	213	ut_assertok(bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
	214	*data += 1;
	215	ut_asserteq(-EIO, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
	216	*data -= 1;
	217
	218	ut_assertok(bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
	219	*data2 += 1;
	220	ut_asserteq(-EIO, bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
221	*data2 -= 1;
222
223	/*
224	* Changing data outside the range of valid data should not affect
225	* the checksum.
226	*/
227	ut_assertok(bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
228	data[TEST_SIZE]++;
229	data2[TEST_SIZE2]++;
230	ut_assertok(bloblist_check(TEST_ADDR, TEST_BLOBLIST_SIZE));
231
232	return 0;
233	}
234
235	BLOBLIST_TEST(bloblist_test_checksum, 0);
236
09140113 SG	237	int do_ut_bloblist(struct cmd_tbl *cmdtp, int flag, int argc,
09140113 SG	238	char *const argv[])
919e7a8f SG	239	{
	240	struct unit_test *tests = ll_entry_start(struct unit_test,
	241	bloblist_test);
	242	const int n_ents = ll_entry_count(struct unit_test, bloblist_test);
	243
4ad4edfe PR	244	return cmd_ut_category("bloblist", "bloblist_test_",
4ad4edfe PR	245	tests, n_ents, argc, argv);
919e7a8f	246	}