// 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_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;/* 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,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 :"%s:%d: no validation for VCAP %d\n" ,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 )else /* Callback used by the VCAP API */ static void test_cache_erase(struct vcap_admin *admin)if (test_cache_erase_count) {0 , test_cache_erase_count);0 , test_cache_erase_count);0 , test_cache_erase_count);0 ;/* Callback used by the VCAP API */ static void test_cache_init(struct net_device *ndev, struct vcap_admin *admin,/* 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)int idx;"%s:%d: %d %d\n" , __func__, __LINE__, start, count);switch (sel) {case VCAP_SEL_ENTRY:for (idx = 0 ; idx < count; ++idx) {"%s:%d: keydata[%02d]: 0x%08x\n" , __func__,for (idx = 0 ; idx < count; ++idx) {/* Invert the mask before decoding starts */ "%s:%d: mskdata[%02d]: 0x%08x\n" , __func__,break ;case VCAP_SEL_ACTION:for (idx = 0 ; idx < count; ++idx) {"%s:%d: actdata[%02d]: 0x%08x\n" , __func__,break ;case VCAP_SEL_COUNTER:"%s:%d\n" , __func__, __LINE__);break ;case VCAP_SEL_ALL:"%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)int idx;switch (sel) {case VCAP_SEL_ENTRY:for (idx = 0 ; idx < count; ++idx) {"%s:%d: keydata[%02d]: 0x%08x\n" , __func__,for (idx = 0 ; idx < count; ++idx) {/* Invert the mask before encoding starts */ "%s:%d: mskdata[%02d]: 0x%08x\n" , __func__,break ;case VCAP_SEL_ACTION:for (idx = 0 ; idx < count; ++idx) {"%s:%d: actdata[%02d]: 0x%08x\n" , __func__,break ;case VCAP_SEL_COUNTER:"%s:%d\n" , __func__, __LINE__);break ;case VCAP_SEL_ALL:"%s:%d: cannot write all streams at once\n" ,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))else "%s:%d: overflow: %d\n" , __func__, __LINE__, test_updateaddridx);static void test_cache_move(struct net_device *ndev, struct vcap_admin *admin,int offset, int 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 = {static struct vcap_control test_vctrl = {static void vcap_test_api_init(struct vcap_admin *admin)/* Initialize the shared objects */ 0 , sizeof (test_updateaddr));0 ;/* Helper function to create a rule of a specific size */ static void test_vcap_xn_rule_creator(struct kunit *test, int cid,enum vcap_user user, u16 priority,int id, int size, int expected_addr)struct vcap_rule *rule;struct vcap_rule_internal *ri;enum vcap_keyfield_set keyset = VCAP_KFS_NO_VALUE;enum vcap_actionfield_set actionset = VCAP_AFS_NO_VALUE;int ret;/* init before testing */ 0 , sizeof (test_updateaddr));0 ;0 ;0 ;0 ;switch (size) {case 2 :break ;case 3 :break ;case 6 :break ;case 12 :break ;default :break ;/* Check that a valid size was used */ /* Allocate the rule */ struct vcap_rule_internal *)rule;/* Override rule keyset */ /* Add rule actions : there must be at least one action */ 0 );/* Override rule actionset */ 0 , ret);/* Add rule with write callback */ 0 , ret);/* Prepare testing rule deletion */ static void test_init_rule_deletion(void )0 ;0 ;0 ;0 ;0 ;/* Define the test cases. */ static void vcap_api_set_bit_1_test(struct kunit *test)struct vcap_stream_iter iter = {35 ,52 ,1 ,20 ,2 ] = {0 };1 );0 x0, stream[0 ]);20 ), stream[1 ]);static void vcap_api_set_bit_0_test(struct kunit *test)struct vcap_stream_iter iter = {35 ,52 ,2 ,11 ,3 ] = {~0 , ~0 , ~0 };0 );0 , stream[0 ]);0 , stream[1 ]);11 ), stream[2 ]);static void vcap_api_iterator_init_test(struct kunit *test)struct vcap_stream_iter iter;struct vcap_typegroup typegroups[] = {0 , .width = 2 , .value = 2 , },156 , .width = 1 , .value = 0 , },struct vcap_typegroup typegroups2[] = {0 , .width = 3 , .value = 4 , },49 , .width = 2 , .value = 0 , },98 , .width = 2 , .value = 0 , },52 , typegroups, 86 );52 , iter.sw_width);86 + 2 , iter.offset);3 , iter.reg_idx);4 , iter.reg_bitpos);49 , typegroups2, 134 );49 , iter.sw_width);134 + 7 , iter.offset);5 , iter.reg_idx);11 , iter.reg_bitpos);static void vcap_api_iterator_next_test(struct kunit *test)struct vcap_stream_iter iter;struct vcap_typegroup typegroups[] = {0 , .width = 4 , .value = 8 , },49 , .width = 1 , .value = 0 , },98 , .width = 2 , .value = 0 , },147 , .width = 3 , .value = 0 , },196 , .width = 2 , .value = 0 , },245 , .width = 1 , .value = 0 , },int idx;49 , typegroups, 86 );49 , iter.sw_width);86 + 5 , iter.offset);3 , iter.reg_idx);10 , iter.reg_bitpos);91 + 1 , iter.offset);3 , iter.reg_idx);11 , iter.reg_bitpos);for (idx = 0 ; idx < 6 ; idx++)92 + 6 + 2 , iter.offset);4 , iter.reg_idx);2 , iter.reg_bitpos);static void vcap_api_encode_typegroups_test(struct kunit *test)12 ] = {0 };struct vcap_typegroup typegroups[] = {0 , .width = 4 , .value = 8 , },49 , .width = 1 , .value = 1 , },98 , .width = 2 , .value = 3 , },147 , .width = 3 , .value = 5 , },196 , .width = 2 , .value = 2 , },245 , .width = 5 , .value = 27 , },49 , typegroups, false );0 x8, stream[0 ]);0 x0, stream[1 ]);0 x1, stream[2 ]);0 x0, stream[3 ]);0 x3, stream[4 ]);0 x0, stream[5 ]);0 x5, stream[6 ]);0 x0, stream[7 ]);0 x2, stream[8 ]);0 x0, stream[9 ]);27 , stream[10 ]);0 x0, stream[11 ]);static void vcap_api_encode_bit_test(struct kunit *test)struct vcap_stream_iter iter;4 ] = {0 };struct vcap_typegroup typegroups[] = {0 , .width = 4 , .value = 8 , },49 , .width = 1 , .value = 1 , },98 , .width = 2 , .value = 3 , },147 , .width = 3 , .value = 5 , },196 , .width = 2 , .value = 2 , },245 , .width = 1 , .value = 0 , },49 , typegroups, 44 );48 , iter.offset);1 , iter.reg_idx);16 , iter.reg_bitpos);1 );0 x0, stream[0 ]);16 ), stream[1 ]);0 x0, stream[2 ]);static void vcap_api_encode_field_test(struct kunit *test)struct vcap_stream_iter iter;16 ] = {0 };struct vcap_typegroup typegroups[] = {0 , .width = 4 , .value = 8 , },49 , .width = 1 , .value = 1 , },98 , .width = 2 , .value = 3 , },147 , .width = 3 , .value = 5 , },196 , .width = 2 , .value = 2 , },245 , .width = 5 , .value = 27 , },struct vcap_field rf = {86 ,4 ,0 x5};49 , typegroups, rf.offset);91 , iter.offset);3 , iter.reg_idx);10 , iter.reg_bitpos);0 x0, stream[0 ]);0 x0, stream[1 ]);0 x0, stream[2 ]);0 x5 << 10 ), stream[3 ]);0 x0, stream[4 ]);49 , typegroups, false );0 x8, stream[0 ]);0 x0, stream[1 ]);0 x1, stream[2 ]);0 x5 << 10 ), stream[3 ]);0 x3, stream[4 ]);0 x0, stream[5 ]);0 x5, stream[6 ]);0 x0, stream[7 ]);0 x2, stream[8 ]);0 x0, stream[9 ]);27 , stream[10 ]);0 x0, stream[11 ]);/* In this testcase the subword is smaller than a register */ static void vcap_api_encode_short_field_test(struct kunit *test)struct vcap_stream_iter iter;int sw_width = 21 ;6 ] = {0 };struct vcap_typegroup tgt[] = {0 , .width = 3 , .value = 7 , },21 , .width = 2 , .value = 3 , },42 , .width = 1 , .value = 1 , },struct vcap_field rf = {25 ,4 ,0 x5};1 , iter.regs_per_sw);21 , iter.sw_width);25 + 3 + 2 , iter.offset);1 , iter.reg_idx);25 + 3 + 2 - sw_width, iter.reg_bitpos);0 x0, stream[0 ]);0 x5 << (25 + 3 + 2 - sw_width)), stream[1 ]);0 x0, stream[2 ]);0 x0, stream[3 ]);0 x0, stream[4 ]);0 x0, stream[5 ]);false );7 , stream[0 ]);0 x5 << (25 + 3 + 2 - sw_width)) + 3 ), stream[1 ]);1 , stream[2 ]);0 , stream[3 ]);0 , stream[4 ]);0 , stream[5 ]);static void vcap_api_encode_keyfield_test(struct kunit *test)16 ] = {0 };16 ] = {0 };struct vcap_admin admin = {struct vcap_rule_internal rule = {struct vcap_client_keyfield ckf = {0 xeef014a1,0 xfff,struct vcap_field rf = {56 ,12 ,struct vcap_typegroup tgt[] = {0 , .width = 2 , .value = 2 , },156 , .width = 1 , .value = 1 , },/* Key */ 0 x0, keywords[0 ]);0 x0, keywords[1 ]);0 x04a1 << 6 ), keywords[2 ]);0 x0, keywords[3 ]);0 x0, keywords[4 ]);0 x0, keywords[5 ]);0 x0, keywords[6 ]);/* Mask */ 0 x0, maskwords[0 ]);0 x0, maskwords[1 ]);0 x0fff << 6 ), maskwords[2 ]);0 x0, maskwords[3 ]);0 x0, maskwords[4 ]);0 x0, maskwords[5 ]);0 x0, maskwords[6 ]);static void vcap_api_encode_max_keyfield_test(struct kunit *test)int idx;6 ] = {0 };6 ] = {0 };struct vcap_admin admin = {/* IS2 sw_width = 52 bit */ struct vcap_rule_internal rule = {struct vcap_client_keyfield ckf = {0 xa1, 0 xa2, 0 xa3, 0 xa4, 0 , 0 , 0 x43, 0 ,0 , 0 , 0 , 0 , 0 , 0 , 0 x78, 0 x8e, },0 xff, 0 xff, 0 xff, 0 xff, 0 , 0 , 0 xff, 0 ,0 , 0 , 0 , 0 , 0 , 0 , 0 xff, 0 xff },struct vcap_field rf = {0 ,128 ,struct vcap_typegroup tgt[] = {0 , .width = 2 , .value = 2 , },156 , .width = 1 , .value = 1 , },0 x928e8a84,0 x000c0002,0 x00000010,0 x00000000,0 x0239e000,0 x00000000,0 xfffffffc,0 x000c0003,0 x0000003f,0 x00000000,0 x03fffc00,0 x00000000,/* Key */ for (idx = 0 ; idx < ARRAY_SIZE(keyres); ++idx)/* Mask */ for (idx = 0 ; idx < ARRAY_SIZE(mskres); ++idx)static void vcap_api_encode_actionfield_test(struct kunit *test)16 ] = {0 };int sw_width = 21 ;struct vcap_admin admin = {/* act_width = 21 */ struct vcap_rule_internal rule = {struct vcap_client_actionfield caf = {0 x67908032,struct vcap_field rf = {35 ,6 ,struct vcap_typegroup tgt[] = {0 , .width = 2 , .value = 2 , },21 , .width = 1 , .value = 1 , },42 , .width = 1 , .value = 0 , },/* Action */ 0 x0, actwords[0 ]);0 x32 << (35 + 2 + 1 - sw_width)) & 0 x1fffff), actwords[1 ]);0 x32 >> ((2 * sw_width) - 38 - 1 ))), actwords[2 ]);0 x0, actwords[3 ]);0 x0, actwords[4 ]);0 x0, actwords[5 ]);0 x0, actwords[6 ]);static void vcap_api_keyfield_typegroup_test(struct kunit *test)const struct vcap_typegroup *tg;0 , tg[0 ].offset);2 , tg[0 ].width);2 , tg[0 ].value);156 , tg[1 ].offset);1 , tg[1 ].width);0 , tg[1 ].value);0 , tg[2 ].offset);0 , tg[2 ].width);0 , tg[2 ].value);static void vcap_api_actionfield_typegroup_test(struct kunit *test)const struct vcap_typegroup *tg;0 , tg[0 ].offset);3 , tg[0 ].width);4 , tg[0 ].value);110 , tg[1 ].offset);2 , tg[1 ].width);0 , tg[1 ].value);220 , tg[2 ].offset);2 , tg[2 ].width);0 , tg[2 ].value);0 , tg[3 ].offset);0 , tg[3 ].width);0 , tg[3 ].value);static void vcap_api_vcap_keyfields_test(struct kunit *test)const struct vcap_field *ft;/* Keyset that is not available and within the maximum keyset enum value */ /* Keyset that is not available and beyond the maximum keyset enum value */ static void vcap_api_vcap_actionfields_test(struct kunit *test)const struct vcap_field *ft;static void vcap_api_encode_rule_keyset_test(struct kunit *test)16 ] = {0 };16 ] = {0 };struct vcap_admin admin = {struct vcap_rule_internal rule = {struct vcap_client_keyfield ckf[] = {0 x00,0 x0f,0 x01,0 x01,0 x00,0 x01,0 x00,0 x0f,0 x0, 0 x00, 0 x00, 0 x00},0 xfd, 0 xff, 0 xff, 0 xff},/* Opposite endianness */ 0 x01, 0 x02, 0 x03, 0 x04, 0 x05, 0 x06},0 xff, 0 xff, 0 xff, 0 xff, 0 xff, 0 xff},0 x01,0 x01,0 xaabb,0 xffff,int idx;int ret;/* Empty entry list */ for (idx = 0 ; idx < ARRAY_SIZE(ckf); idx++)0 , ret);/* The key and mask values below are from an actual Sparx5 rule config */ /* Key */ 0 x00000042, keywords[0 ]);0 x00000000, keywords[1 ]);0 x00000000, keywords[2 ]);0 x00020100, keywords[3 ]);0 x60504030, keywords[4 ]);0 x00000000, keywords[5 ]);0 x00000000, keywords[6 ]);0 x0002aaee, keywords[7 ]);0 x00000000, keywords[8 ]);0 x00000000, keywords[9 ]);0 x00000000, keywords[10 ]);0 x00000000, keywords[11 ]);/* Mask: they will be inverted when applied to the register */ 0 x00b07f80, maskwords[0 ]);0 xfff00000, maskwords[1 ]);0 xfffffffc, maskwords[2 ]);0 xfff000ff, maskwords[3 ]);0 x00000000, maskwords[4 ]);0 xfffffff0, maskwords[5 ]);0 xfffffffe, maskwords[6 ]);0 xfffc0001, maskwords[7 ]);0 xffffffff, maskwords[8 ]);0 xffffffff, maskwords[9 ]);0 xffffffff, maskwords[10 ]);0 xffffffff, maskwords[11 ]);static void vcap_api_encode_rule_actionset_test(struct kunit *test)16 ] = {0 };struct vcap_admin admin = {struct vcap_rule_internal rule = {struct vcap_client_actionfield caf[] = {0 x01,0 x01,0 x64,int idx;int ret;/* Empty entry list */ /* We allow rules with no actions */ 0 , ret);for (idx = 0 ; idx < ARRAY_SIZE(caf); idx++)0 , ret);/* The action values below are from an actual Sparx5 rule config */ 0 x00000002, actwords[0 ]);0 x00000000, actwords[1 ]);0 x00000000, actwords[2 ]);0 x00000000, actwords[3 ]);0 x00000000, actwords[4 ]);0 x00100000, actwords[5 ]);0 x06400010, actwords[6 ]);0 x00000000, actwords[7 ]);0 x00000000, actwords[8 ]);0 x00000000, actwords[9 ]);0 x00000000, actwords[10 ]);0 x00000000, actwords[11 ]);static void vcap_free_ckf(struct vcap_rule *rule)struct vcap_client_keyfield *ckf, *next_ckf;static void vcap_api_rule_add_keyvalue_test(struct kunit *test)struct vcap_admin admin = {struct vcap_rule_internal ri = {struct vcap_rule *rule = (struct vcap_rule *)&ri;struct vcap_client_keyfield *kf;int ret;struct vcap_u128_key dip = {0 x17, 0 x26, 0 x35, 0 x44, 0 x63, 0 x62, 0 x71},0 xf1, 0 xf2, 0 xf3, 0 xf4, 0 x4f, 0 x3f, 0 x2f, 0 x1f},int idx;0 , ret);false , ret);struct vcap_client_keyfield,0 x0, kf->data.u1.value);0 x1, kf->data.u1.mask);0 , ret);false , ret);struct vcap_client_keyfield,0 x1, kf->data.u1.value);0 x1, kf->data.u1.mask);0 , ret);false , ret);struct vcap_client_keyfield,0 x0, kf->data.u1.value);0 x0, kf->data.u1.mask);0 x98765432, 0 xff00ffab);0 , ret);false , ret);struct vcap_client_keyfield,0 x98765432, kf->data.u32.value);0 xff00ffab, kf->data.u32.mask);0 , ret);false , ret);struct vcap_client_keyfield,for (idx = 0 ; idx < ARRAY_SIZE(dip.value); ++idx)for (idx = 0 ; idx < ARRAY_SIZE(dip.mask); ++idx)static void vcap_free_caf(struct vcap_rule *rule)struct vcap_client_actionfield *caf, *next_caf;static void vcap_api_rule_add_actionvalue_test(struct kunit *test)struct vcap_admin admin = {struct vcap_rule_internal ri = {struct vcap_rule *rule = (struct vcap_rule *)&ri;struct vcap_client_actionfield *af;int ret;0 , ret);false , ret);struct vcap_client_actionfield, ctrl.list);0 x0, af->data.u1.value);0 , ret);false , ret);struct vcap_client_actionfield, ctrl.list);0 x1, af->data.u1.value);0 , ret);false , ret);struct vcap_client_actionfield, ctrl.list);0 x0, af->data.u1.value);0 x98765432);0 , ret);false , ret);struct vcap_client_actionfield, ctrl.list);0 x98765432, af->data.u32.value);0 xaabbccdd);0 , ret);false , ret);struct vcap_client_actionfield, ctrl.list);0 xaabbccdd, af->data.u32.value);static void vcap_api_rule_find_keyset_basic_test(struct kunit *test)struct vcap_keyset_list matches = {};struct vcap_admin admin = {struct vcap_rule_internal ri = {struct vcap_client_keyfield ckf[] = {int idx;bool ret;enum vcap_keyfield_set keysets[10 ] = {};for (idx = 0 ; idx < ARRAY_SIZE(ckf); idx++)true , ret);1 , matches.cnt);0 ]);static void vcap_api_rule_find_keyset_failed_test(struct kunit *test)struct vcap_keyset_list matches = {};struct vcap_admin admin = {struct vcap_rule_internal ri = {struct vcap_client_keyfield ckf[] = {/* Not with ARP */ /* Not with ARP */ int idx;bool ret;enum vcap_keyfield_set keysets[10 ] = {};for (idx = 0 ; idx < ARRAY_SIZE(ckf); idx++)false , ret);0 , matches.cnt);0 ]);static void vcap_api_rule_find_keyset_many_test(struct kunit *test)struct vcap_keyset_list matches = {};struct vcap_admin admin = {struct vcap_rule_internal ri = {struct vcap_client_keyfield ckf[] = {int idx;bool ret;enum vcap_keyfield_set keysets[10 ] = {};for (idx = 0 ; idx < ARRAY_SIZE(ckf); idx++)true , ret);6 , matches.cnt);0 ]);1 ]);2 ]);3 ]);4 ]);5 ]);static void vcap_api_encode_rule_test(struct kunit *test)/* Data used by VCAP Library callback */ static u32 keydata[32 ] = {};static u32 mskdata[32 ] = {};static u32 actdata[32 ] = {};struct vcap_admin is2_admin = {8000000 ,8099999 ,4 ,3071 ,0 ,800 ,struct vcap_rule *rule;struct vcap_rule_internal *ri;int vcap_chain_id = 8000000 ;enum vcap_user user = VCAP_USER_VCAP_UTIL;10 ;int id = 100 ;int ret;struct vcap_u48_key smac = {0 x88, 0 x75, 0 x32, 0 x34, 0 x9e, 0 xb1 },0 xff, 0 xff, 0 xff, 0 xff, 0 xff, 0 xff }struct vcap_u48_key dmac = {0 x06, 0 x05, 0 x04, 0 x03, 0 x02, 0 x01 },0 xff, 0 xff, 0 xff, 0 xff, 0 xff, 0 xff }0 x05;0 x0f;0 xffabcd01;0 ;/* counter is written as the first operation */ 792 , 792 , 793 , 794 , 795 , 796 , 797 };int idx;/* Allocate the rule */ struct vcap_rule_internal *)rule;/* Add rule keys */ 0 , ret);0 , ret);0 , ret);/* Cannot add the same field twice */ 0 , ret);0 , ret);0 , ret);/* Add rule actions */ 0 , ret);0 , ret);1 );0 , ret);1 );0 , ret);/* For now the actionset is hardcoded */ 0 , ret);/* Validation with validate keyset callback */ 0 , ret);6 , ri->size);2 , ri->keyset_sw_regs);4 , ri->actionset_sw_regs);/* Enable lookup, so the rule will be written */ 0 ,true );0 , ret);/* Add rule with write callback */ 0 , ret);792 , is2_admin.last_used_addr);for (idx = 0 ; idx < ARRAY_SIZE(expwriteaddr); ++idx)/* Check that the rule has been added */ false , ret);0 , ret);0 , 0 ,false );0 , ret);static void vcap_api_set_rule_counter_test(struct kunit *test)struct vcap_admin is2_admin = {100 ,true ,struct vcap_rule_internal ri = {1001 ,600 ,1002 ,struct vcap_rule_internal ri2 = {2001 ,700 ,2002 ,struct vcap_counter ctr = { .value = 0 , .sticky = false };struct vcap_counter ctr2 = { .value = 101 , .sticky = true };int ret;"%s:%d\n" , __func__, __LINE__);"%s:%d\n" , __func__, __LINE__);0 , ret);1002 , test_hw_counter_id);0 , test_hw_cache.counter);false , test_hw_cache.sticky);600 , test_updateaddr[0 ]);0 , ret);2002 , test_hw_counter_id);101 , test_hw_cache.counter);true , test_hw_cache.sticky);700 , test_updateaddr[1 ]);static void vcap_api_get_rule_counter_test(struct kunit *test)struct vcap_admin is2_admin = {100 ,true ,struct vcap_rule_internal ri = {1010 ,400 ,1011 ,struct vcap_rule_internal ri2 = {2011 ,300 ,2012 ,struct vcap_counter ctr = {};struct vcap_counter ctr2 = {};int ret;55 ;true ;0 , ret);1011 , test_hw_counter_id);55 , ctr.value);true , ctr.sticky);400 , test_updateaddr[0 ]);22 ;false ;0 , ret);2012 , test_hw_counter_id);22 , ctr2.value);false , ctr2.sticky);300 , test_updateaddr[1 ]);static void vcap_api_rule_insert_in_order_test(struct kunit *test)/* Data used by VCAP Library callback */ static u32 keydata[32 ] = {};static u32 mskdata[32 ] = {};static u32 actdata[32 ] = {};struct vcap_admin admin = {10000 ,19999 ,4 ,3071 ,0 ,800 ,/* Create rules with different sizes and check that they are placed * at the correct address in the VCAP according to size 10000 , VCAP_USER_QOS, 10 , 500 , 12 , 780 );10000 , VCAP_USER_QOS, 20 , 400 , 6 , 774 );10000 , VCAP_USER_QOS, 30 , 300 , 3 , 771 );10000 , VCAP_USER_QOS, 40 , 200 , 2 , 768 );200 );300 );400 );500 );static void vcap_api_rule_insert_reverse_order_test(struct kunit *test)/* Data used by VCAP Library callback */ static u32 keydata[32 ] = {};static u32 mskdata[32 ] = {};static u32 actdata[32 ] = {};struct vcap_admin admin = {10000 ,19999 ,4 ,3071 ,0 ,800 ,struct vcap_rule_internal *elem;780 , 774 , 771 , 768 , 767 };int idx;/* Create rules with different sizes and check that they are placed * at the correct address in the VCAP according to size 10000 , VCAP_USER_QOS, 20 , 200 , 2 , 798 );0 , test_move_offset);0 , test_move_count);0 , test_move_addr);10000 , VCAP_USER_QOS, 30 , 300 , 3 , 795 );6 , test_move_offset);3 , test_move_count);798 , test_move_addr);10000 , VCAP_USER_QOS, 40 , 400 , 6 , 792 );6 , test_move_offset);6 , test_move_count);792 , test_move_addr);10000 , VCAP_USER_QOS, 50 , 500 , 12 , 780 );18 , test_move_offset);12 , test_move_count);786 , test_move_addr);0 ;768 , admin.last_used_addr);500 );400 );300 );200 );static void vcap_api_rule_remove_at_end_test(struct kunit *test)/* Data used by VCAP Library callback */ static u32 keydata[32 ] = {};static u32 mskdata[32 ] = {};static u32 actdata[32 ] = {};struct vcap_admin admin = {10000 ,19999 ,4 ,3071 ,0 ,800 ,int ret;/* Create rules with different sizes and check that they are placed * at the correct address in the VCAP according to size 10000 , VCAP_USER_QOS, 10 , 500 , 12 , 780 );10000 , VCAP_USER_QOS, 20 , 400 , 6 , 774 );10000 , VCAP_USER_QOS, 30 , 300 , 3 , 771 );10000 , VCAP_USER_QOS, 40 , 200 , 2 , 768 );/* Remove rules again from the end */ 200 );0 , ret);0 , test_move_addr);0 , test_move_offset);0 , test_move_count);768 , test_init_start);2 , test_init_count);771 , admin.last_used_addr);300 );0 );0 , test_move_addr);0 , test_move_offset);0 , test_move_count);771 , test_init_start);3 , test_init_count);774 , admin.last_used_addr);400 );0 );0 , test_move_addr);0 , test_move_offset);0 , test_move_count);774 , test_init_start);6 , test_init_count);780 , admin.last_used_addr);500 );0 );0 , test_move_addr);0 , test_move_offset);0 , test_move_count);780 , test_init_start);12 , test_init_count);3072 , admin.last_used_addr);static void vcap_api_rule_remove_in_middle_test(struct kunit *test)/* Data used by VCAP Library callback */ static u32 keydata[32 ] = {};static u32 mskdata[32 ] = {};static u32 actdata[32 ] = {};struct vcap_admin admin = {10000 ,19999 ,4 ,0 ,800 ,800 - 1 ,int ret;/* Create rules with different sizes and check that they are placed * at the correct address in the VCAP according to size 10000 , VCAP_USER_QOS, 10 , 500 , 12 , 780 );10000 , VCAP_USER_QOS, 20 , 400 , 6 , 774 );10000 , VCAP_USER_QOS, 30 , 300 , 3 , 771 );10000 , VCAP_USER_QOS, 40 , 200 , 2 , 768 );/* Remove rules in the middle */ 400 );0 , ret);768 , test_move_addr);6 , test_move_offset);6 , test_move_count);768 , test_init_start);6 , test_init_count);774 , admin.last_used_addr);300 );0 , ret);774 , test_move_addr);4 , test_move_offset);2 , test_move_count);774 , test_init_start);4 , test_init_count);778 , admin.last_used_addr);500 );0 , ret);778 , test_move_addr);20 , test_move_offset);2 , test_move_count);778 , test_init_start);20 , test_init_count);798 , admin.last_used_addr);200 );0 , ret);0 , test_move_addr);0 , test_move_offset);0 , test_move_count);798 , test_init_start);2 , test_init_count);800 , admin.last_used_addr);static void vcap_api_rule_remove_in_front_test(struct kunit *test)/* Data used by VCAP Library callback */ static u32 keydata[32 ] = {};static u32 mskdata[32 ] = {};static u32 actdata[32 ] = {};struct vcap_admin admin = {10000 ,19999 ,4 ,0 ,800 ,800 - 1 ,int ret;10000 , VCAP_USER_QOS, 10 , 500 , 12 , 780 );780 , admin.last_used_addr);500 );0 , ret);0 , test_move_addr);0 , test_move_offset);0 , test_move_count);780 , test_init_start);12 , test_init_count);800 , admin.last_used_addr);10000 , VCAP_USER_QOS, 20 , 400 , 6 , 792 );10000 , VCAP_USER_QOS, 30 , 300 , 3 , 789 );10000 , VCAP_USER_QOS, 40 , 200 , 2 , 786 );400 );0 , ret);786 , test_move_addr);8 , test_move_offset);6 , test_move_count);786 , test_init_start);8 , test_init_count);794 , admin.last_used_addr);200 );300 );static struct kunit_case vcap_api_rule_remove_test_cases[] = {static void vcap_api_next_lookup_basic_test(struct kunit *test)struct vcap_admin admin1 = {0 ,8000000 ,8199999 ,4 ,2 ,struct vcap_admin admin2 = {1 ,8200000 ,8399999 ,4 ,2 ,bool ret;8000000 , 1001000 );false , ret);8000000 , 8001000 );false , ret);8000000 , 8101000 );true , ret);8100000 , 8101000 );false , ret);8100000 , 8201000 );true , ret);8200000 , 8201000 );false , ret);8200000 , 8301000 );true , ret);8300000 , 8301000 );false , ret);8300000 , 8401000 );false , ret);static void vcap_api_next_lookup_advanced_test(struct kunit *test)struct vcap_admin admin[] = {0 ,1000000 ,1199999 ,6 ,2 ,1 ,1200000 ,1399999 ,6 ,2 ,2 ,1400000 ,1599999 ,6 ,2 ,0 ,8000000 ,8199999 ,4 ,2 ,1 ,8200000 ,8399999 ,4 ,2 ,bool ret;0 ]);1 ].list, &test_vctrl.list);2 ].list, &test_vctrl.list);3 ].list, &test_vctrl.list);4 ].list, &test_vctrl.list);1000000 , 1001000 );false , ret);1000000 , 1101000 );true , ret);1100000 , 1201000 );true , ret);1100000 , 1301000 );true , ret);1100000 , 8101000 );true , ret);1300000 , 1401000 );true , ret);1400000 , 1501000 );true , ret);1500000 , 8001000 );true , ret);8000000 , 8001000 );false , ret);8000000 , 8101000 );true , ret);8300000 , 8301000 );false , ret);8300000 , 8401000 );false , ret);static void vcap_api_filter_unsupported_keys_test(struct kunit *test)struct vcap_admin admin = {struct vcap_rule_internal ri = {enum vcap_key_field keylist[] = {/* arp keys are not in keyset */ enum vcap_key_field expected[] = {struct vcap_client_keyfield *ckf, *next;bool ret;int idx;/* Add all keys to the rule */ for (idx = 0 ; idx < ARRAY_SIZE(keylist); idx++) {sizeof (*ckf), GFP_KERNEL);if (ckf) {14 , ARRAY_SIZE(keylist));/* Drop unsupported keys from the rule */ 0 , true );0 , ret);/* Check remaining keys in the rule */ 0 ;7 , idx);static void vcap_api_filter_keylist_test(struct kunit *test)struct vcap_admin admin = {struct vcap_rule_internal ri = {enum vcap_key_field keylist[] = {enum vcap_key_field droplist[] = {enum vcap_key_field expected[] = {struct vcap_client_keyfield *ckf, *next;bool ret;int idx;/* Add all keys to the rule */ for (idx = 0 ; idx < ARRAY_SIZE(keylist); idx++) {sizeof (*ckf), GFP_KERNEL);if (ckf) {38 , ARRAY_SIZE(keylist));/* Drop listed keys from the rule */ false );0 , ret);/* Check remaining keys in the rule */ 0 ;26 , idx);static void vcap_api_rule_chain_path_test(struct kunit *test)struct vcap_admin admin1 = {0 ,1000000 ,1199999 ,6 ,2 ,struct vcap_enabled_port eport3 = {0 x100,0 ,1000000 ,struct vcap_enabled_port eport2 = {0 x200,1000000 ,1100000 ,struct vcap_enabled_port eport1 = {0 x300,1100000 ,8000000 ,bool ret;int chain;1000000 );true , ret);1100000 );true , ret);1200000 );false , ret);0 );1000000 , chain);1000000 );1100000 , chain);1100000 );8000000 , chain);static struct kunit_case vcap_api_rule_enable_test_cases[] = {static struct kunit_suite vcap_api_rule_enable_test_suite = {"VCAP_API_Rule_Enable_Testsuite" ,static struct kunit_suite vcap_api_rule_remove_test_suite = {"VCAP_API_Rule_Remove_Testsuite" ,static struct kunit_case vcap_api_rule_insert_test_cases[] = {static struct kunit_suite vcap_api_rule_insert_test_suite = {"VCAP_API_Rule_Insert_Testsuite" ,static struct kunit_case vcap_api_rule_counter_test_cases[] = {static struct kunit_suite vcap_api_rule_counter_test_suite = {"VCAP_API_Rule_Counter_Testsuite" ,static struct kunit_case vcap_api_support_test_cases[] = {static struct kunit_suite vcap_api_support_test_suite = {"VCAP_API_Support_Testsuite" ,static struct kunit_case vcap_api_full_rule_test_cases[] = {static struct kunit_suite vcap_api_full_rule_test_suite = {"VCAP_API_Full_Rule_Testsuite" ,static struct kunit_case vcap_api_rule_value_test_cases[] = {static struct kunit_suite vcap_api_rule_value_test_suite = {"VCAP_API_Rule_Value_Testsuite" ,static struct kunit_case vcap_api_encoding_test_cases[] = {static struct kunit_suite vcap_api_encoding_test_suite = {"VCAP_API_Encoding_Testsuite" ,
Messung V0.5 in Prozent C=94 H=92 G=92
¤ Dauer der Verarbeitung: 0.24 Sekunden
(vorverarbeitet am 2026-06-07)
¤ *© Formatika GbR, Deutschland
