Something went wrong. Try again.
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556// 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 const 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,};
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); mutex_init(&test_vctrl.lock); INIT_LIST_HEAD(&admin->list); INIT_LIST_HEAD(&admin->rules); INIT_LIST_HEAD(&admin->enabled); admin->vctrl = &test_vctrl; 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: 4\n", "vinst: 0\n", "ingress: 1\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, .ingress = true, }; 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: 4\n", "vinst: 0\n", "ingress: 1\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", " state: permanent\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, .ingress = true, .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);