Contributors: 2
Author Tokens Token Proportion Commits Commit Proportion
Steen Hegelund 2613 99.92% 11 91.67%
Yang Yingliang 2 0.08% 1 8.33%
Total 2615 12 


// SPDX-License-Identifier: BSD-3-Clause
/* Copyright (C) 2022 Microchip Technology Inc. and its subsidiaries.
 * Microchip VCAP API kunit test suite
 */

#include <kunit/test.h>
#include "vcap_api.h"
#include "vcap_api_client.h"
#include "vcap_api_debugfs.h"
#include "vcap_model_kunit.h"

/* First we have the test infrastructure that emulates the platform
 * implementation
 */
#define TEST_BUF_CNT 100
#define TEST_BUF_SZ  350
#define STREAMWSIZE 64

static u32 test_updateaddr[STREAMWSIZE] = {};
static int test_updateaddridx;
static int test_cache_erase_count;
static u32 test_init_start;
static u32 test_init_count;
static u32 test_hw_counter_id;
static struct vcap_cache_data test_hw_cache;
static struct net_device test_netdev = {};
static int test_move_addr;
static int test_move_offset;
static int test_move_count;
static char test_pr_buffer[TEST_BUF_CNT][TEST_BUF_SZ];
static int test_pr_bufferidx;
static int test_pr_idx;

/* Callback used by the VCAP API */
static enum vcap_keyfield_set test_val_keyset(struct net_device *ndev,
					      struct vcap_admin *admin,
					      struct vcap_rule *rule,
					      struct vcap_keyset_list *kslist,
					      u16 l3_proto)
{
	int idx;

	if (kslist->cnt > 0) {
		switch (admin->vtype) {
		case VCAP_TYPE_IS0:
			for (idx = 0; idx < kslist->cnt; idx++) {
				if (kslist->keysets[idx] == VCAP_KFS_ETAG)
					return kslist->keysets[idx];
				if (kslist->keysets[idx] ==
				    VCAP_KFS_PURE_5TUPLE_IP4)
					return kslist->keysets[idx];
				if (kslist->keysets[idx] ==
				    VCAP_KFS_NORMAL_5TUPLE_IP4)
					return kslist->keysets[idx];
				if (kslist->keysets[idx] ==
				    VCAP_KFS_NORMAL_7TUPLE)
					return kslist->keysets[idx];
			}
			break;
		case VCAP_TYPE_IS2:
			for (idx = 0; idx < kslist->cnt; idx++) {
				if (kslist->keysets[idx] == VCAP_KFS_MAC_ETYPE)
					return kslist->keysets[idx];
				if (kslist->keysets[idx] == VCAP_KFS_ARP)
					return kslist->keysets[idx];
				if (kslist->keysets[idx] == VCAP_KFS_IP_7TUPLE)
					return kslist->keysets[idx];
			}
			break;
		default:
			pr_info("%s:%d: no validation for VCAP %d\n",
				__func__, __LINE__, admin->vtype);
			break;
		}
	}
	return -EINVAL;
}

/* Callback used by the VCAP API */
static void test_add_def_fields(struct net_device *ndev,
				struct vcap_admin *admin,
				struct vcap_rule *rule)
{
	if (admin->vinst == 0 || admin->vinst == 2)
		vcap_rule_add_key_bit(rule, VCAP_KF_LOOKUP_FIRST_IS,
				      VCAP_BIT_1);
	else
		vcap_rule_add_key_bit(rule, VCAP_KF_LOOKUP_FIRST_IS,
				      VCAP_BIT_0);
}

/* Callback used by the VCAP API */
static void test_cache_erase(struct vcap_admin *admin)
{
	if (test_cache_erase_count) {
		memset(admin->cache.keystream, 0, test_cache_erase_count);
		memset(admin->cache.maskstream, 0, test_cache_erase_count);
		memset(admin->cache.actionstream, 0, test_cache_erase_count);
		test_cache_erase_count = 0;
	}
}

/* Callback used by the VCAP API */
static void test_cache_init(struct net_device *ndev, struct vcap_admin *admin,
			    u32 start, u32 count)
{
	test_init_start = start;
	test_init_count = count;
}

/* Callback used by the VCAP API */
static void test_cache_read(struct net_device *ndev, struct vcap_admin *admin,
			    enum vcap_selection sel, u32 start, u32 count)
{
	u32 *keystr, *mskstr, *actstr;
	int idx;

	pr_debug("%s:%d: %d %d\n", __func__, __LINE__, start, count);
	switch (sel) {
	case VCAP_SEL_ENTRY:
		keystr = &admin->cache.keystream[start];
		mskstr = &admin->cache.maskstream[start];
		for (idx = 0; idx < count; ++idx) {
			pr_debug("%s:%d: keydata[%02d]: 0x%08x\n", __func__,
				 __LINE__, start + idx, keystr[idx]);
		}
		for (idx = 0; idx < count; ++idx) {
			/* Invert the mask before decoding starts */
			mskstr[idx] = ~mskstr[idx];
			pr_debug("%s:%d: mskdata[%02d]: 0x%08x\n", __func__,
				 __LINE__, start + idx, mskstr[idx]);
		}
		break;
	case VCAP_SEL_ACTION:
		actstr = &admin->cache.actionstream[start];
		for (idx = 0; idx < count; ++idx) {
			pr_debug("%s:%d: actdata[%02d]: 0x%08x\n", __func__,
				 __LINE__, start + idx, actstr[idx]);
		}
		break;
	case VCAP_SEL_COUNTER:
		pr_debug("%s:%d\n", __func__, __LINE__);
		test_hw_counter_id = start;
		admin->cache.counter = test_hw_cache.counter;
		admin->cache.sticky = test_hw_cache.sticky;
		break;
	case VCAP_SEL_ALL:
		pr_debug("%s:%d\n", __func__, __LINE__);
		break;
	}
}

/* Callback used by the VCAP API */
static void test_cache_write(struct net_device *ndev, struct vcap_admin *admin,
			     enum vcap_selection sel, u32 start, u32 count)
{
	u32 *keystr, *mskstr, *actstr;
	int idx;

	switch (sel) {
	case VCAP_SEL_ENTRY:
		keystr = &admin->cache.keystream[start];
		mskstr = &admin->cache.maskstream[start];
		for (idx = 0; idx < count; ++idx) {
			pr_debug("%s:%d: keydata[%02d]: 0x%08x\n", __func__,
				 __LINE__, start + idx, keystr[idx]);
		}
		for (idx = 0; idx < count; ++idx) {
			/* Invert the mask before encoding starts */
			mskstr[idx] = ~mskstr[idx];
			pr_debug("%s:%d: mskdata[%02d]: 0x%08x\n", __func__,
				 __LINE__, start + idx, mskstr[idx]);
		}
		break;
	case VCAP_SEL_ACTION:
		actstr = &admin->cache.actionstream[start];
		for (idx = 0; idx < count; ++idx) {
			pr_debug("%s:%d: actdata[%02d]: 0x%08x\n", __func__,
				 __LINE__, start + idx, actstr[idx]);
		}
		break;
	case VCAP_SEL_COUNTER:
		pr_debug("%s:%d\n", __func__, __LINE__);
		test_hw_counter_id = start;
		test_hw_cache.counter = admin->cache.counter;
		test_hw_cache.sticky = admin->cache.sticky;
		break;
	case VCAP_SEL_ALL:
		pr_err("%s:%d: cannot write all streams at once\n",
		       __func__, __LINE__);
		break;
	}
}

/* Callback used by the VCAP API */
static void test_cache_update(struct net_device *ndev, struct vcap_admin *admin,
			      enum vcap_command cmd,
			      enum vcap_selection sel, u32 addr)
{
	if (test_updateaddridx < ARRAY_SIZE(test_updateaddr))
		test_updateaddr[test_updateaddridx] = addr;
	else
		pr_err("%s:%d: overflow: %d\n", __func__, __LINE__,
		       test_updateaddridx);
	test_updateaddridx++;
}

static void test_cache_move(struct net_device *ndev, struct vcap_admin *admin,
			    u32 addr, int offset, int count)
{
	test_move_addr = addr;
	test_move_offset = offset;
	test_move_count = count;
}

/* Provide port information via a callback interface */
static int vcap_test_port_info(struct net_device *ndev,
			       struct vcap_admin *admin,
			       struct vcap_output_print *out)
{
	return 0;
}

static int vcap_test_enable(struct net_device *ndev,
			    struct vcap_admin *admin,
			    bool enable)
{
	return 0;
}

static struct vcap_operations test_callbacks = {
	.validate_keyset = test_val_keyset,
	.add_default_fields = test_add_def_fields,
	.cache_erase = test_cache_erase,
	.cache_write = test_cache_write,
	.cache_read = test_cache_read,
	.init = test_cache_init,
	.update = test_cache_update,
	.move = test_cache_move,
	.port_info = vcap_test_port_info,
	.enable = vcap_test_enable,
};

static struct vcap_control test_vctrl = {
	.vcaps = kunit_test_vcaps,
	.stats = &kunit_test_vcap_stats,
	.ops = &test_callbacks,
};

static void vcap_test_api_init(struct vcap_admin *admin)
{
	/* Initialize the shared objects */
	INIT_LIST_HEAD(&test_vctrl.list);
	INIT_LIST_HEAD(&admin->list);
	INIT_LIST_HEAD(&admin->rules);
	list_add_tail(&admin->list, &test_vctrl.list);
	memset(test_updateaddr, 0, sizeof(test_updateaddr));
	test_updateaddridx = 0;
	test_pr_bufferidx = 0;
	test_pr_idx = 0;
}

/* callback used by the show_admin function */
static __printf(2, 3)
int test_prf(void *out, const char *fmt, ...)
{
	static char test_buffer[TEST_BUF_SZ];
	va_list args;
	int idx, cnt;

	if (test_pr_bufferidx >= TEST_BUF_CNT) {
		pr_err("%s:%d: overflow: %d\n", __func__, __LINE__,
		       test_pr_bufferidx);
		return 0;
	}

	va_start(args, fmt);
	cnt = vscnprintf(test_buffer, TEST_BUF_SZ, fmt, args);
	va_end(args);

	for (idx = 0; idx < cnt; ++idx) {
		test_pr_buffer[test_pr_bufferidx][test_pr_idx] =
			test_buffer[idx];
		if (test_buffer[idx] == '\n') {
			test_pr_buffer[test_pr_bufferidx][++test_pr_idx] = 0;
			test_pr_idx = 0;
			test_pr_bufferidx++;
		} else {
			++test_pr_idx;
		}
	}

	return cnt;
}

/* Define the test cases. */

static void vcap_api_addr_keyset_test(struct kunit *test)
{
	u32 keydata[12] = {
		0x40450042, 0x000feaf3, 0x00000003, 0x00050600,
		0x10203040, 0x00075880, 0x633c6864, 0x00040003,
		0x00000020, 0x00000008, 0x00000240, 0x00000000,
	};
	u32 mskdata[12] = {
		0x0030ff80, 0xfff00000, 0xfffffffc, 0xfff000ff,
		0x00000000, 0xfff00000, 0x00000000, 0xfff3fffc,
		0xffffffc0, 0xffffffff, 0xfffffc03, 0xffffffff,
	};
	u32 actdata[12] = {};
	struct vcap_admin admin = {
		.vtype = VCAP_TYPE_IS2,
		.cache = {
			.keystream = keydata,
			.maskstream = mskdata,
			.actionstream = actdata,
		},
	};
	enum vcap_keyfield_set keysets[10];
	struct vcap_keyset_list matches;
	int ret, idx, addr;

	vcap_test_api_init(&admin);

	/* Go from higher to lower addresses searching for a keyset */
	matches.keysets = keysets;
	matches.cnt = 0;
	matches.max = ARRAY_SIZE(keysets);
	for (idx = ARRAY_SIZE(keydata) - 1, addr = 799; idx > 0;
	     --idx, --addr) {
		admin.cache.keystream = &keydata[idx];
		admin.cache.maskstream = &mskdata[idx];
		ret = vcap_addr_keysets(&test_vctrl, &test_netdev, &admin,
					addr, &matches);
		KUNIT_EXPECT_EQ(test, -EINVAL, ret);
	}

	/* Finally we hit the start of the rule */
	admin.cache.keystream = &keydata[idx];
	admin.cache.maskstream = &mskdata[idx];
	matches.cnt = 0;
	ret = vcap_addr_keysets(&test_vctrl, &test_netdev, &admin,
				addr, &matches);
	KUNIT_EXPECT_EQ(test, 0, ret);
	KUNIT_EXPECT_EQ(test, matches.cnt, 1);
	KUNIT_EXPECT_EQ(test, matches.keysets[0], VCAP_KFS_MAC_ETYPE);
}

static void vcap_api_show_admin_raw_test(struct kunit *test)
{
	u32 keydata[4] = {
		0x40450042, 0x000feaf3, 0x00000003, 0x00050600,
	};
	u32 mskdata[4] = {
		0x0030ff80, 0xfff00000, 0xfffffffc, 0xfff000ff,
	};
	u32 actdata[12] = {};
	struct vcap_admin admin = {
		.vtype = VCAP_TYPE_IS2,
		.cache = {
			.keystream = keydata,
			.maskstream = mskdata,
			.actionstream = actdata,
		},
		.first_valid_addr = 786,
		.last_valid_addr = 788,
	};
	struct vcap_rule_internal ri = {
		.ndev = &test_netdev,
	};
	struct vcap_output_print out = {
		.prf = (void *)test_prf,
	};
	const char *test_expected =
		"  addr: 786, X6 rule, keysets: VCAP_KFS_MAC_ETYPE\n";
	int ret;

	vcap_test_api_init(&admin);
	list_add_tail(&ri.list, &admin.rules);

	ret = vcap_show_admin_raw(&test_vctrl, &admin, &out);
	KUNIT_EXPECT_EQ(test, 0, ret);
	KUNIT_EXPECT_STREQ(test, test_expected, test_pr_buffer[0]);
}

static const char * const test_admin_info_expect[] = {
	"name: is2\n",
	"rows: 256\n",
	"sw_count: 12\n",
	"sw_width: 52\n",
	"sticky_width: 1\n",
	"act_width: 110\n",
	"default_cnt: 73\n",
	"require_cnt_dis: 0\n",
	"version: 1\n",
	"vtype: 2\n",
	"vinst: 0\n",
	"first_cid: 10000\n",
	"last_cid: 19999\n",
	"lookups: 4\n",
	"first_valid_addr: 0\n",
	"last_valid_addr: 3071\n",
	"last_used_addr: 794\n",
};

static void vcap_api_show_admin_test(struct kunit *test)
{
	struct vcap_admin admin = {
		.vtype = VCAP_TYPE_IS2,
		.first_cid = 10000,
		.last_cid = 19999,
		.lookups = 4,
		.last_valid_addr = 3071,
		.first_valid_addr = 0,
		.last_used_addr = 794,
	};
	struct vcap_output_print out = {
		.prf = (void *)test_prf,
	};
	int idx;

	vcap_test_api_init(&admin);

	vcap_show_admin_info(&test_vctrl, &admin, &out);
	for (idx = 0; idx < test_pr_bufferidx; ++idx) {
		/* pr_info("log[%02d]: %s", idx, test_pr_buffer[idx]); */
		KUNIT_EXPECT_STREQ(test, test_admin_info_expect[idx],
				   test_pr_buffer[idx]);
	}
}

static const char * const test_admin_expect[] = {
	"name: is2\n",
	"rows: 256\n",
	"sw_count: 12\n",
	"sw_width: 52\n",
	"sticky_width: 1\n",
	"act_width: 110\n",
	"default_cnt: 73\n",
	"require_cnt_dis: 0\n",
	"version: 1\n",
	"vtype: 2\n",
	"vinst: 0\n",
	"first_cid: 8000000\n",
	"last_cid: 8199999\n",
	"lookups: 4\n",
	"first_valid_addr: 0\n",
	"last_valid_addr: 3071\n",
	"last_used_addr: 794\n",
	"\n",
	"rule: 100, addr: [794,799], X6, ctr[0]: 0, hit: 0\n",
	"  chain_id: 0\n",
	"  user: 0\n",
	"  priority: 0\n",
	"  keysets: VCAP_KFS_MAC_ETYPE\n",
	"  keyset_sw: 6\n",
	"  keyset_sw_regs: 2\n",
	"    ETYPE_LEN_IS: W1: 1/1\n",
	"    IF_IGR_PORT_MASK: W32: 0xffabcd01/0xffffffff\n",
	"    IF_IGR_PORT_MASK_RNG: W4: 5/15\n",
	"    L2_DMAC: W48: 01:02:03:04:05:06/ff:ff:ff:ff:ff:ff\n",
	"    L2_PAYLOAD_ETYPE: W64: 0x9000002000000081/0xff000000000000ff\n",
	"    L2_SMAC: W48: b1:9e:34:32:75:88/ff:ff:ff:ff:ff:ff\n",
	"    LOOKUP_FIRST_IS: W1: 1/1\n",
	"    TYPE: W4: 0/15\n",
	"  actionset: VCAP_AFS_BASE_TYPE\n",
	"  actionset_sw: 3\n",
	"  actionset_sw_regs: 4\n",
	"    CNT_ID: W12: 100\n",
	"    MATCH_ID: W16: 1\n",
	"    MATCH_ID_MASK: W16: 1\n",
	"    POLICE_ENA: W1: 1\n",
	"    PORT_MASK: W68: 0x0514670115f3324589\n",
};

static void vcap_api_show_admin_rule_test(struct kunit *test)
{
	u32 keydata[] = {
		0x40450042, 0x000feaf3, 0x00000003, 0x00050600,
		0x10203040, 0x00075880, 0x633c6864, 0x00040003,
		0x00000020, 0x00000008, 0x00000240, 0x00000000,
	};
	u32 mskdata[] = {
		0x0030ff80, 0xfff00000, 0xfffffffc, 0xfff000ff,
		0x00000000, 0xfff00000, 0x00000000, 0xfff3fffc,
		0xffffffc0, 0xffffffff, 0xfffffc03, 0xffffffff,
	};
	u32 actdata[] = {
		0x00040002, 0xf3324589, 0x14670115, 0x00000005,
		0x00000000, 0x00100000, 0x06400010, 0x00000000,
		0x00000000, 0x00000000, 0x00000000, 0x00000000,
		0x00000000, 0x00000000, 0x00000000, 0x00000000,
		0x00000000, 0x00000000, 0x00000000, 0x00000000,
		0x00000000, 0x00000000, 0x00000000, 0x00000000,
	};
	struct vcap_admin admin = {
		.vtype = VCAP_TYPE_IS2,
		.first_cid = 8000000,
		.last_cid = 8199999,
		.lookups = 4,
		.last_valid_addr = 3071,
		.first_valid_addr = 0,
		.last_used_addr = 794,
		.cache = {
			.keystream = keydata,
			.maskstream = mskdata,
			.actionstream = actdata,
		},
	};
	struct vcap_rule_internal ri = {
		.admin = &admin,
		.data = {
			.id = 100,
			.keyset = VCAP_KFS_MAC_ETYPE,
			.actionset = VCAP_AFS_BASE_TYPE,
		},
		.size = 6,
		.keyset_sw = 6,
		.keyset_sw_regs = 2,
		.actionset_sw = 3,
		.actionset_sw_regs = 4,
		.addr = 794,
		.vctrl = &test_vctrl,
	};
	struct vcap_output_print out = {
		.prf = (void *)test_prf,
	};
	int ret, idx;

	vcap_test_api_init(&admin);
	list_add_tail(&ri.list, &admin.rules);

	ret = vcap_show_admin(&test_vctrl, &admin, &out);
	KUNIT_EXPECT_EQ(test, 0, ret);
	for (idx = 0; idx < test_pr_bufferidx; ++idx) {
		/* pr_info("log[%02d]: %s", idx, test_pr_buffer[idx]); */
		KUNIT_EXPECT_STREQ(test, test_admin_expect[idx],
				   test_pr_buffer[idx]);
	}
}

static struct kunit_case vcap_api_debugfs_test_cases[] = {
	KUNIT_CASE(vcap_api_addr_keyset_test),
	KUNIT_CASE(vcap_api_show_admin_raw_test),
	KUNIT_CASE(vcap_api_show_admin_test),
	KUNIT_CASE(vcap_api_show_admin_rule_test),
	{}
};

static struct kunit_suite vcap_api_debugfs_test_suite = {
	.name = "VCAP_API_DebugFS_Testsuite",
	.test_cases = vcap_api_debugfs_test_cases,
};

kunit_test_suite(vcap_api_debugfs_test_suite);