Loading...
Note: File does not exist in v4.6.
1// SPDX-License-Identifier: BSD-3-Clause
2/* Copyright (C) 2022 Microchip Technology Inc. and its subsidiaries.
3 * Microchip VCAP API kunit test suite
4 */
5
6#include <kunit/test.h>
7#include "vcap_api.h"
8#include "vcap_api_client.h"
9#include "vcap_model_kunit.h"
10
11/* First we have the test infrastructure that emulates the platform
12 * implementation
13 */
14#define TEST_BUF_CNT 100
15#define TEST_BUF_SZ 350
16#define STREAMWSIZE 64
17
18static u32 test_updateaddr[STREAMWSIZE] = {};
19static int test_updateaddridx;
20static int test_cache_erase_count;
21static u32 test_init_start;
22static u32 test_init_count;
23static u32 test_hw_counter_id;
24static struct vcap_cache_data test_hw_cache;
25static struct net_device test_netdev = {};
26static int test_move_addr;
27static int test_move_offset;
28static int test_move_count;
29
30/* Callback used by the VCAP API */
31static enum vcap_keyfield_set test_val_keyset(struct net_device *ndev,
32 struct vcap_admin *admin,
33 struct vcap_rule *rule,
34 struct vcap_keyset_list *kslist,
35 u16 l3_proto)
36{
37 int idx;
38
39 if (kslist->cnt > 0) {
40 switch (admin->vtype) {
41 case VCAP_TYPE_IS0:
42 for (idx = 0; idx < kslist->cnt; idx++) {
43 if (kslist->keysets[idx] == VCAP_KFS_ETAG)
44 return kslist->keysets[idx];
45 if (kslist->keysets[idx] == VCAP_KFS_PURE_5TUPLE_IP4)
46 return kslist->keysets[idx];
47 if (kslist->keysets[idx] == VCAP_KFS_NORMAL_5TUPLE_IP4)
48 return kslist->keysets[idx];
49 if (kslist->keysets[idx] == VCAP_KFS_NORMAL_7TUPLE)
50 return kslist->keysets[idx];
51 }
52 break;
53 case VCAP_TYPE_IS2:
54 for (idx = 0; idx < kslist->cnt; idx++) {
55 if (kslist->keysets[idx] == VCAP_KFS_MAC_ETYPE)
56 return kslist->keysets[idx];
57 if (kslist->keysets[idx] == VCAP_KFS_ARP)
58 return kslist->keysets[idx];
59 if (kslist->keysets[idx] == VCAP_KFS_IP_7TUPLE)
60 return kslist->keysets[idx];
61 }
62 break;
63 default:
64 pr_info("%s:%d: no validation for VCAP %d\n",
65 __func__, __LINE__, admin->vtype);
66 break;
67 }
68 }
69 return -EINVAL;
70}
71
72/* Callback used by the VCAP API */
73static void test_add_def_fields(struct net_device *ndev,
74 struct vcap_admin *admin,
75 struct vcap_rule *rule)
76{
77 if (admin->vinst == 0 || admin->vinst == 2)
78 vcap_rule_add_key_bit(rule, VCAP_KF_LOOKUP_FIRST_IS, VCAP_BIT_1);
79 else
80 vcap_rule_add_key_bit(rule, VCAP_KF_LOOKUP_FIRST_IS, VCAP_BIT_0);
81}
82
83/* Callback used by the VCAP API */
84static void test_cache_erase(struct vcap_admin *admin)
85{
86 if (test_cache_erase_count) {
87 memset(admin->cache.keystream, 0, test_cache_erase_count);
88 memset(admin->cache.maskstream, 0, test_cache_erase_count);
89 memset(admin->cache.actionstream, 0, test_cache_erase_count);
90 test_cache_erase_count = 0;
91 }
92}
93
94/* Callback used by the VCAP API */
95static void test_cache_init(struct net_device *ndev, struct vcap_admin *admin,
96 u32 start, u32 count)
97{
98 test_init_start = start;
99 test_init_count = count;
100}
101
102/* Callback used by the VCAP API */
103static void test_cache_read(struct net_device *ndev, struct vcap_admin *admin,
104 enum vcap_selection sel, u32 start, u32 count)
105{
106 u32 *keystr, *mskstr, *actstr;
107 int idx;
108
109 pr_debug("%s:%d: %d %d\n", __func__, __LINE__, start, count);
110 switch (sel) {
111 case VCAP_SEL_ENTRY:
112 keystr = &admin->cache.keystream[start];
113 mskstr = &admin->cache.maskstream[start];
114 for (idx = 0; idx < count; ++idx) {
115 pr_debug("%s:%d: keydata[%02d]: 0x%08x\n", __func__,
116 __LINE__, start + idx, keystr[idx]);
117 }
118 for (idx = 0; idx < count; ++idx) {
119 /* Invert the mask before decoding starts */
120 mskstr[idx] = ~mskstr[idx];
121 pr_debug("%s:%d: mskdata[%02d]: 0x%08x\n", __func__,
122 __LINE__, start + idx, mskstr[idx]);
123 }
124 break;
125 case VCAP_SEL_ACTION:
126 actstr = &admin->cache.actionstream[start];
127 for (idx = 0; idx < count; ++idx) {
128 pr_debug("%s:%d: actdata[%02d]: 0x%08x\n", __func__,
129 __LINE__, start + idx, actstr[idx]);
130 }
131 break;
132 case VCAP_SEL_COUNTER:
133 pr_debug("%s:%d\n", __func__, __LINE__);
134 test_hw_counter_id = start;
135 admin->cache.counter = test_hw_cache.counter;
136 admin->cache.sticky = test_hw_cache.sticky;
137 break;
138 case VCAP_SEL_ALL:
139 pr_debug("%s:%d\n", __func__, __LINE__);
140 break;
141 }
142}
143
144/* Callback used by the VCAP API */
145static void test_cache_write(struct net_device *ndev, struct vcap_admin *admin,
146 enum vcap_selection sel, u32 start, u32 count)
147{
148 u32 *keystr, *mskstr, *actstr;
149 int idx;
150
151 switch (sel) {
152 case VCAP_SEL_ENTRY:
153 keystr = &admin->cache.keystream[start];
154 mskstr = &admin->cache.maskstream[start];
155 for (idx = 0; idx < count; ++idx) {
156 pr_debug("%s:%d: keydata[%02d]: 0x%08x\n", __func__,
157 __LINE__, start + idx, keystr[idx]);
158 }
159 for (idx = 0; idx < count; ++idx) {
160 /* Invert the mask before encoding starts */
161 mskstr[idx] = ~mskstr[idx];
162 pr_debug("%s:%d: mskdata[%02d]: 0x%08x\n", __func__,
163 __LINE__, start + idx, mskstr[idx]);
164 }
165 break;
166 case VCAP_SEL_ACTION:
167 actstr = &admin->cache.actionstream[start];
168 for (idx = 0; idx < count; ++idx) {
169 pr_debug("%s:%d: actdata[%02d]: 0x%08x\n", __func__,
170 __LINE__, start + idx, actstr[idx]);
171 }
172 break;
173 case VCAP_SEL_COUNTER:
174 pr_debug("%s:%d\n", __func__, __LINE__);
175 test_hw_counter_id = start;
176 test_hw_cache.counter = admin->cache.counter;
177 test_hw_cache.sticky = admin->cache.sticky;
178 break;
179 case VCAP_SEL_ALL:
180 pr_err("%s:%d: cannot write all streams at once\n",
181 __func__, __LINE__);
182 break;
183 }
184}
185
186/* Callback used by the VCAP API */
187static void test_cache_update(struct net_device *ndev, struct vcap_admin *admin,
188 enum vcap_command cmd,
189 enum vcap_selection sel, u32 addr)
190{
191 if (test_updateaddridx < ARRAY_SIZE(test_updateaddr))
192 test_updateaddr[test_updateaddridx] = addr;
193 else
194 pr_err("%s:%d: overflow: %d\n", __func__, __LINE__, test_updateaddridx);
195 test_updateaddridx++;
196}
197
198static void test_cache_move(struct net_device *ndev, struct vcap_admin *admin,
199 u32 addr, int offset, int count)
200{
201 test_move_addr = addr;
202 test_move_offset = offset;
203 test_move_count = count;
204}
205
206/* Provide port information via a callback interface */
207static int vcap_test_port_info(struct net_device *ndev,
208 struct vcap_admin *admin,
209 struct vcap_output_print *out)
210{
211 return 0;
212}
213
214static struct vcap_operations test_callbacks = {
215 .validate_keyset = test_val_keyset,
216 .add_default_fields = test_add_def_fields,
217 .cache_erase = test_cache_erase,
218 .cache_write = test_cache_write,
219 .cache_read = test_cache_read,
220 .init = test_cache_init,
221 .update = test_cache_update,
222 .move = test_cache_move,
223 .port_info = vcap_test_port_info,
224};
225
226static struct vcap_control test_vctrl = {
227 .vcaps = kunit_test_vcaps,
228 .stats = &kunit_test_vcap_stats,
229 .ops = &test_callbacks,
230};
231
232static void vcap_test_api_init(struct vcap_admin *admin)
233{
234 /* Initialize the shared objects */
235 INIT_LIST_HEAD(&test_vctrl.list);
236 INIT_LIST_HEAD(&admin->list);
237 INIT_LIST_HEAD(&admin->rules);
238 INIT_LIST_HEAD(&admin->enabled);
239 mutex_init(&admin->lock);
240 list_add_tail(&admin->list, &test_vctrl.list);
241 memset(test_updateaddr, 0, sizeof(test_updateaddr));
242 test_updateaddridx = 0;
243}
244
245/* Helper function to create a rule of a specific size */
246static void test_vcap_xn_rule_creator(struct kunit *test, int cid,
247 enum vcap_user user, u16 priority,
248 int id, int size, int expected_addr)
249{
250 struct vcap_rule *rule;
251 struct vcap_rule_internal *ri;
252 enum vcap_keyfield_set keyset = VCAP_KFS_NO_VALUE;
253 enum vcap_actionfield_set actionset = VCAP_AFS_NO_VALUE;
254 int ret;
255
256 /* init before testing */
257 memset(test_updateaddr, 0, sizeof(test_updateaddr));
258 test_updateaddridx = 0;
259 test_move_addr = 0;
260 test_move_offset = 0;
261 test_move_count = 0;
262
263 switch (size) {
264 case 2:
265 keyset = VCAP_KFS_ETAG;
266 actionset = VCAP_AFS_CLASS_REDUCED;
267 break;
268 case 3:
269 keyset = VCAP_KFS_PURE_5TUPLE_IP4;
270 actionset = VCAP_AFS_CLASSIFICATION;
271 break;
272 case 6:
273 keyset = VCAP_KFS_NORMAL_5TUPLE_IP4;
274 actionset = VCAP_AFS_CLASSIFICATION;
275 break;
276 case 12:
277 keyset = VCAP_KFS_NORMAL_7TUPLE;
278 actionset = VCAP_AFS_FULL;
279 break;
280 default:
281 break;
282 }
283
284 /* Check that a valid size was used */
285 KUNIT_ASSERT_NE(test, VCAP_KFS_NO_VALUE, keyset);
286
287 /* Allocate the rule */
288 rule = vcap_alloc_rule(&test_vctrl, &test_netdev, cid, user, priority,
289 id);
290 KUNIT_EXPECT_PTR_NE(test, NULL, rule);
291
292 ri = (struct vcap_rule_internal *)rule;
293
294 /* Override rule keyset */
295 ret = vcap_set_rule_set_keyset(rule, keyset);
296
297 /* Add rule actions : there must be at least one action */
298 ret = vcap_rule_add_action_u32(rule, VCAP_AF_ISDX_VAL, 0);
299
300 /* Override rule actionset */
301 ret = vcap_set_rule_set_actionset(rule, actionset);
302
303 ret = vcap_val_rule(rule, ETH_P_ALL);
304 KUNIT_EXPECT_EQ(test, 0, ret);
305 KUNIT_EXPECT_EQ(test, keyset, rule->keyset);
306 KUNIT_EXPECT_EQ(test, actionset, rule->actionset);
307 KUNIT_EXPECT_EQ(test, size, ri->size);
308
309 /* Add rule with write callback */
310 ret = vcap_add_rule(rule);
311 KUNIT_EXPECT_EQ(test, 0, ret);
312 KUNIT_EXPECT_EQ(test, expected_addr, ri->addr);
313 vcap_free_rule(rule);
314}
315
316/* Prepare testing rule deletion */
317static void test_init_rule_deletion(void)
318{
319 test_move_addr = 0;
320 test_move_offset = 0;
321 test_move_count = 0;
322 test_init_start = 0;
323 test_init_count = 0;
324}
325
326/* Define the test cases. */
327
328static void vcap_api_set_bit_1_test(struct kunit *test)
329{
330 struct vcap_stream_iter iter = {
331 .offset = 35,
332 .sw_width = 52,
333 .reg_idx = 1,
334 .reg_bitpos = 20,
335 .tg = NULL,
336 };
337 u32 stream[2] = {0};
338
339 vcap_set_bit(stream, &iter, 1);
340
341 KUNIT_EXPECT_EQ(test, (u32)0x0, stream[0]);
342 KUNIT_EXPECT_EQ(test, (u32)BIT(20), stream[1]);
343}
344
345static void vcap_api_set_bit_0_test(struct kunit *test)
346{
347 struct vcap_stream_iter iter = {
348 .offset = 35,
349 .sw_width = 52,
350 .reg_idx = 2,
351 .reg_bitpos = 11,
352 .tg = NULL,
353 };
354 u32 stream[3] = {~0, ~0, ~0};
355
356 vcap_set_bit(stream, &iter, 0);
357
358 KUNIT_EXPECT_EQ(test, (u32)~0, stream[0]);
359 KUNIT_EXPECT_EQ(test, (u32)~0, stream[1]);
360 KUNIT_EXPECT_EQ(test, (u32)~BIT(11), stream[2]);
361}
362
363static void vcap_api_iterator_init_test(struct kunit *test)
364{
365 struct vcap_stream_iter iter;
366 struct vcap_typegroup typegroups[] = {
367 { .offset = 0, .width = 2, .value = 2, },
368 { .offset = 156, .width = 1, .value = 0, },
369 { .offset = 0, .width = 0, .value = 0, },
370 };
371 struct vcap_typegroup typegroups2[] = {
372 { .offset = 0, .width = 3, .value = 4, },
373 { .offset = 49, .width = 2, .value = 0, },
374 { .offset = 98, .width = 2, .value = 0, },
375 };
376
377 vcap_iter_init(&iter, 52, typegroups, 86);
378
379 KUNIT_EXPECT_EQ(test, 52, iter.sw_width);
380 KUNIT_EXPECT_EQ(test, 86 + 2, iter.offset);
381 KUNIT_EXPECT_EQ(test, 3, iter.reg_idx);
382 KUNIT_EXPECT_EQ(test, 4, iter.reg_bitpos);
383
384 vcap_iter_init(&iter, 49, typegroups2, 134);
385
386 KUNIT_EXPECT_EQ(test, 49, iter.sw_width);
387 KUNIT_EXPECT_EQ(test, 134 + 7, iter.offset);
388 KUNIT_EXPECT_EQ(test, 5, iter.reg_idx);
389 KUNIT_EXPECT_EQ(test, 11, iter.reg_bitpos);
390}
391
392static void vcap_api_iterator_next_test(struct kunit *test)
393{
394 struct vcap_stream_iter iter;
395 struct vcap_typegroup typegroups[] = {
396 { .offset = 0, .width = 4, .value = 8, },
397 { .offset = 49, .width = 1, .value = 0, },
398 { .offset = 98, .width = 2, .value = 0, },
399 { .offset = 147, .width = 3, .value = 0, },
400 { .offset = 196, .width = 2, .value = 0, },
401 { .offset = 245, .width = 1, .value = 0, },
402 };
403 int idx;
404
405 vcap_iter_init(&iter, 49, typegroups, 86);
406
407 KUNIT_EXPECT_EQ(test, 49, iter.sw_width);
408 KUNIT_EXPECT_EQ(test, 86 + 5, iter.offset);
409 KUNIT_EXPECT_EQ(test, 3, iter.reg_idx);
410 KUNIT_EXPECT_EQ(test, 10, iter.reg_bitpos);
411
412 vcap_iter_next(&iter);
413
414 KUNIT_EXPECT_EQ(test, 91 + 1, iter.offset);
415 KUNIT_EXPECT_EQ(test, 3, iter.reg_idx);
416 KUNIT_EXPECT_EQ(test, 11, iter.reg_bitpos);
417
418 for (idx = 0; idx < 6; idx++)
419 vcap_iter_next(&iter);
420
421 KUNIT_EXPECT_EQ(test, 92 + 6 + 2, iter.offset);
422 KUNIT_EXPECT_EQ(test, 4, iter.reg_idx);
423 KUNIT_EXPECT_EQ(test, 2, iter.reg_bitpos);
424}
425
426static void vcap_api_encode_typegroups_test(struct kunit *test)
427{
428 u32 stream[12] = {0};
429 struct vcap_typegroup typegroups[] = {
430 { .offset = 0, .width = 4, .value = 8, },
431 { .offset = 49, .width = 1, .value = 1, },
432 { .offset = 98, .width = 2, .value = 3, },
433 { .offset = 147, .width = 3, .value = 5, },
434 { .offset = 196, .width = 2, .value = 2, },
435 { .offset = 245, .width = 5, .value = 27, },
436 { .offset = 0, .width = 0, .value = 0, },
437 };
438
439 vcap_encode_typegroups(stream, 49, typegroups, false);
440
441 KUNIT_EXPECT_EQ(test, (u32)0x8, stream[0]);
442 KUNIT_EXPECT_EQ(test, (u32)0x0, stream[1]);
443 KUNIT_EXPECT_EQ(test, (u32)0x1, stream[2]);
444 KUNIT_EXPECT_EQ(test, (u32)0x0, stream[3]);
445 KUNIT_EXPECT_EQ(test, (u32)0x3, stream[4]);
446 KUNIT_EXPECT_EQ(test, (u32)0x0, stream[5]);
447 KUNIT_EXPECT_EQ(test, (u32)0x5, stream[6]);
448 KUNIT_EXPECT_EQ(test, (u32)0x0, stream[7]);
449 KUNIT_EXPECT_EQ(test, (u32)0x2, stream[8]);
450 KUNIT_EXPECT_EQ(test, (u32)0x0, stream[9]);
451 KUNIT_EXPECT_EQ(test, (u32)27, stream[10]);
452 KUNIT_EXPECT_EQ(test, (u32)0x0, stream[11]);
453}
454
455static void vcap_api_encode_bit_test(struct kunit *test)
456{
457 struct vcap_stream_iter iter;
458 u32 stream[4] = {0};
459 struct vcap_typegroup typegroups[] = {
460 { .offset = 0, .width = 4, .value = 8, },
461 { .offset = 49, .width = 1, .value = 1, },
462 { .offset = 98, .width = 2, .value = 3, },
463 { .offset = 147, .width = 3, .value = 5, },
464 { .offset = 196, .width = 2, .value = 2, },
465 { .offset = 245, .width = 1, .value = 0, },
466 };
467
468 vcap_iter_init(&iter, 49, typegroups, 44);
469
470 KUNIT_EXPECT_EQ(test, 48, iter.offset);
471 KUNIT_EXPECT_EQ(test, 1, iter.reg_idx);
472 KUNIT_EXPECT_EQ(test, 16, iter.reg_bitpos);
473
474 vcap_encode_bit(stream, &iter, 1);
475
476 KUNIT_EXPECT_EQ(test, (u32)0x0, stream[0]);
477 KUNIT_EXPECT_EQ(test, (u32)BIT(16), stream[1]);
478 KUNIT_EXPECT_EQ(test, (u32)0x0, stream[2]);
479}
480
481static void vcap_api_encode_field_test(struct kunit *test)
482{
483 struct vcap_stream_iter iter;
484 u32 stream[16] = {0};
485 struct vcap_typegroup typegroups[] = {
486 { .offset = 0, .width = 4, .value = 8, },
487 { .offset = 49, .width = 1, .value = 1, },
488 { .offset = 98, .width = 2, .value = 3, },
489 { .offset = 147, .width = 3, .value = 5, },
490 { .offset = 196, .width = 2, .value = 2, },
491 { .offset = 245, .width = 5, .value = 27, },
492 { .offset = 0, .width = 0, .value = 0, },
493 };
494 struct vcap_field rf = {
495 .type = VCAP_FIELD_U32,
496 .offset = 86,
497 .width = 4,
498 };
499 u8 value[] = {0x5};
500
501 vcap_iter_init(&iter, 49, typegroups, rf.offset);
502
503 KUNIT_EXPECT_EQ(test, 91, iter.offset);
504 KUNIT_EXPECT_EQ(test, 3, iter.reg_idx);
505 KUNIT_EXPECT_EQ(test, 10, iter.reg_bitpos);
506
507 vcap_encode_field(stream, &iter, rf.width, value);
508
509 KUNIT_EXPECT_EQ(test, (u32)0x0, stream[0]);
510 KUNIT_EXPECT_EQ(test, (u32)0x0, stream[1]);
511 KUNIT_EXPECT_EQ(test, (u32)0x0, stream[2]);
512 KUNIT_EXPECT_EQ(test, (u32)(0x5 << 10), stream[3]);
513 KUNIT_EXPECT_EQ(test, (u32)0x0, stream[4]);
514
515 vcap_encode_typegroups(stream, 49, typegroups, false);
516
517 KUNIT_EXPECT_EQ(test, (u32)0x8, stream[0]);
518 KUNIT_EXPECT_EQ(test, (u32)0x0, stream[1]);
519 KUNIT_EXPECT_EQ(test, (u32)0x1, stream[2]);
520 KUNIT_EXPECT_EQ(test, (u32)(0x5 << 10), stream[3]);
521 KUNIT_EXPECT_EQ(test, (u32)0x3, stream[4]);
522 KUNIT_EXPECT_EQ(test, (u32)0x0, stream[5]);
523 KUNIT_EXPECT_EQ(test, (u32)0x5, stream[6]);
524 KUNIT_EXPECT_EQ(test, (u32)0x0, stream[7]);
525 KUNIT_EXPECT_EQ(test, (u32)0x2, stream[8]);
526 KUNIT_EXPECT_EQ(test, (u32)0x0, stream[9]);
527 KUNIT_EXPECT_EQ(test, (u32)27, stream[10]);
528 KUNIT_EXPECT_EQ(test, (u32)0x0, stream[11]);
529}
530
531/* In this testcase the subword is smaller than a register */
532static void vcap_api_encode_short_field_test(struct kunit *test)
533{
534 struct vcap_stream_iter iter;
535 int sw_width = 21;
536 u32 stream[6] = {0};
537 struct vcap_typegroup tgt[] = {
538 { .offset = 0, .width = 3, .value = 7, },
539 { .offset = 21, .width = 2, .value = 3, },
540 { .offset = 42, .width = 1, .value = 1, },
541 { .offset = 0, .width = 0, .value = 0, },
542 };
543 struct vcap_field rf = {
544 .type = VCAP_FIELD_U32,
545 .offset = 25,
546 .width = 4,
547 };
548 u8 value[] = {0x5};
549
550 vcap_iter_init(&iter, sw_width, tgt, rf.offset);
551
552 KUNIT_EXPECT_EQ(test, 1, iter.regs_per_sw);
553 KUNIT_EXPECT_EQ(test, 21, iter.sw_width);
554 KUNIT_EXPECT_EQ(test, 25 + 3 + 2, iter.offset);
555 KUNIT_EXPECT_EQ(test, 1, iter.reg_idx);
556 KUNIT_EXPECT_EQ(test, 25 + 3 + 2 - sw_width, iter.reg_bitpos);
557
558 vcap_encode_field(stream, &iter, rf.width, value);
559
560 KUNIT_EXPECT_EQ(test, (u32)0x0, stream[0]);
561 KUNIT_EXPECT_EQ(test, (u32)(0x5 << (25 + 3 + 2 - sw_width)), stream[1]);
562 KUNIT_EXPECT_EQ(test, (u32)0x0, stream[2]);
563 KUNIT_EXPECT_EQ(test, (u32)0x0, stream[3]);
564 KUNIT_EXPECT_EQ(test, (u32)0x0, stream[4]);
565 KUNIT_EXPECT_EQ(test, (u32)0x0, stream[5]);
566
567 vcap_encode_typegroups(stream, sw_width, tgt, false);
568
569 KUNIT_EXPECT_EQ(test, (u32)7, stream[0]);
570 KUNIT_EXPECT_EQ(test, (u32)((0x5 << (25 + 3 + 2 - sw_width)) + 3), stream[1]);
571 KUNIT_EXPECT_EQ(test, (u32)1, stream[2]);
572 KUNIT_EXPECT_EQ(test, (u32)0, stream[3]);
573 KUNIT_EXPECT_EQ(test, (u32)0, stream[4]);
574 KUNIT_EXPECT_EQ(test, (u32)0, stream[5]);
575}
576
577static void vcap_api_encode_keyfield_test(struct kunit *test)
578{
579 u32 keywords[16] = {0};
580 u32 maskwords[16] = {0};
581 struct vcap_admin admin = {
582 .vtype = VCAP_TYPE_IS2,
583 .cache = {
584 .keystream = keywords,
585 .maskstream = maskwords,
586 .actionstream = keywords,
587 },
588 };
589 struct vcap_rule_internal rule = {
590 .admin = &admin,
591 .data = {
592 .keyset = VCAP_KFS_MAC_ETYPE,
593 },
594 .vctrl = &test_vctrl,
595 };
596 struct vcap_client_keyfield ckf = {
597 .ctrl.list = {},
598 .ctrl.key = VCAP_KF_ISDX_CLS,
599 .ctrl.type = VCAP_FIELD_U32,
600 .data.u32.value = 0xeef014a1,
601 .data.u32.mask = 0xfff,
602 };
603 struct vcap_field rf = {
604 .type = VCAP_FIELD_U32,
605 .offset = 56,
606 .width = 12,
607 };
608 struct vcap_typegroup tgt[] = {
609 { .offset = 0, .width = 2, .value = 2, },
610 { .offset = 156, .width = 1, .value = 1, },
611 { .offset = 0, .width = 0, .value = 0, },
612 };
613
614 vcap_test_api_init(&admin);
615 vcap_encode_keyfield(&rule, &ckf, &rf, tgt);
616
617 /* Key */
618 KUNIT_EXPECT_EQ(test, (u32)0x0, keywords[0]);
619 KUNIT_EXPECT_EQ(test, (u32)0x0, keywords[1]);
620 KUNIT_EXPECT_EQ(test, (u32)(0x04a1 << 6), keywords[2]);
621 KUNIT_EXPECT_EQ(test, (u32)0x0, keywords[3]);
622 KUNIT_EXPECT_EQ(test, (u32)0x0, keywords[4]);
623 KUNIT_EXPECT_EQ(test, (u32)0x0, keywords[5]);
624 KUNIT_EXPECT_EQ(test, (u32)0x0, keywords[6]);
625
626 /* Mask */
627 KUNIT_EXPECT_EQ(test, (u32)0x0, maskwords[0]);
628 KUNIT_EXPECT_EQ(test, (u32)0x0, maskwords[1]);
629 KUNIT_EXPECT_EQ(test, (u32)(0x0fff << 6), maskwords[2]);
630 KUNIT_EXPECT_EQ(test, (u32)0x0, maskwords[3]);
631 KUNIT_EXPECT_EQ(test, (u32)0x0, maskwords[4]);
632 KUNIT_EXPECT_EQ(test, (u32)0x0, maskwords[5]);
633 KUNIT_EXPECT_EQ(test, (u32)0x0, maskwords[6]);
634}
635
636static void vcap_api_encode_max_keyfield_test(struct kunit *test)
637{
638 int idx;
639 u32 keywords[6] = {0};
640 u32 maskwords[6] = {0};
641 struct vcap_admin admin = {
642 .vtype = VCAP_TYPE_IS2,
643 /* IS2 sw_width = 52 bit */
644 .cache = {
645 .keystream = keywords,
646 .maskstream = maskwords,
647 .actionstream = keywords,
648 },
649 };
650 struct vcap_rule_internal rule = {
651 .admin = &admin,
652 .data = {
653 .keyset = VCAP_KFS_IP_7TUPLE,
654 },
655 .vctrl = &test_vctrl,
656 };
657 struct vcap_client_keyfield ckf = {
658 .ctrl.list = {},
659 .ctrl.key = VCAP_KF_L3_IP6_DIP,
660 .ctrl.type = VCAP_FIELD_U128,
661 .data.u128.value = { 0xa1, 0xa2, 0xa3, 0xa4, 0, 0, 0x43, 0,
662 0, 0, 0, 0, 0, 0, 0x78, 0x8e, },
663 .data.u128.mask = { 0xff, 0xff, 0xff, 0xff, 0, 0, 0xff, 0,
664 0, 0, 0, 0, 0, 0, 0xff, 0xff },
665 };
666 struct vcap_field rf = {
667 .type = VCAP_FIELD_U128,
668 .offset = 0,
669 .width = 128,
670 };
671 struct vcap_typegroup tgt[] = {
672 { .offset = 0, .width = 2, .value = 2, },
673 { .offset = 156, .width = 1, .value = 1, },
674 { .offset = 0, .width = 0, .value = 0, },
675 };
676 u32 keyres[] = {
677 0x928e8a84,
678 0x000c0002,
679 0x00000010,
680 0x00000000,
681 0x0239e000,
682 0x00000000,
683 };
684 u32 mskres[] = {
685 0xfffffffc,
686 0x000c0003,
687 0x0000003f,
688 0x00000000,
689 0x03fffc00,
690 0x00000000,
691 };
692
693 vcap_encode_keyfield(&rule, &ckf, &rf, tgt);
694
695 /* Key */
696 for (idx = 0; idx < ARRAY_SIZE(keyres); ++idx)
697 KUNIT_EXPECT_EQ(test, keyres[idx], keywords[idx]);
698 /* Mask */
699 for (idx = 0; idx < ARRAY_SIZE(mskres); ++idx)
700 KUNIT_EXPECT_EQ(test, mskres[idx], maskwords[idx]);
701}
702
703static void vcap_api_encode_actionfield_test(struct kunit *test)
704{
705 u32 actwords[16] = {0};
706 int sw_width = 21;
707 struct vcap_admin admin = {
708 .vtype = VCAP_TYPE_ES2, /* act_width = 21 */
709 .cache = {
710 .actionstream = actwords,
711 },
712 };
713 struct vcap_rule_internal rule = {
714 .admin = &admin,
715 .data = {
716 .actionset = VCAP_AFS_BASE_TYPE,
717 },
718 .vctrl = &test_vctrl,
719 };
720 struct vcap_client_actionfield caf = {
721 .ctrl.list = {},
722 .ctrl.action = VCAP_AF_POLICE_IDX,
723 .ctrl.type = VCAP_FIELD_U32,
724 .data.u32.value = 0x67908032,
725 };
726 struct vcap_field rf = {
727 .type = VCAP_FIELD_U32,
728 .offset = 35,
729 .width = 6,
730 };
731 struct vcap_typegroup tgt[] = {
732 { .offset = 0, .width = 2, .value = 2, },
733 { .offset = 21, .width = 1, .value = 1, },
734 { .offset = 42, .width = 1, .value = 0, },
735 { .offset = 0, .width = 0, .value = 0, },
736 };
737
738 vcap_encode_actionfield(&rule, &caf, &rf, tgt);
739
740 /* Action */
741 KUNIT_EXPECT_EQ(test, (u32)0x0, actwords[0]);
742 KUNIT_EXPECT_EQ(test, (u32)((0x32 << (35 + 2 + 1 - sw_width)) & 0x1fffff), actwords[1]);
743 KUNIT_EXPECT_EQ(test, (u32)((0x32 >> ((2 * sw_width) - 38 - 1))), actwords[2]);
744 KUNIT_EXPECT_EQ(test, (u32)0x0, actwords[3]);
745 KUNIT_EXPECT_EQ(test, (u32)0x0, actwords[4]);
746 KUNIT_EXPECT_EQ(test, (u32)0x0, actwords[5]);
747 KUNIT_EXPECT_EQ(test, (u32)0x0, actwords[6]);
748}
749
750static void vcap_api_keyfield_typegroup_test(struct kunit *test)
751{
752 const struct vcap_typegroup *tg;
753
754 tg = vcap_keyfield_typegroup(&test_vctrl, VCAP_TYPE_IS2, VCAP_KFS_MAC_ETYPE);
755 KUNIT_EXPECT_PTR_NE(test, NULL, tg);
756 KUNIT_EXPECT_EQ(test, 0, tg[0].offset);
757 KUNIT_EXPECT_EQ(test, 2, tg[0].width);
758 KUNIT_EXPECT_EQ(test, 2, tg[0].value);
759 KUNIT_EXPECT_EQ(test, 156, tg[1].offset);
760 KUNIT_EXPECT_EQ(test, 1, tg[1].width);
761 KUNIT_EXPECT_EQ(test, 0, tg[1].value);
762 KUNIT_EXPECT_EQ(test, 0, tg[2].offset);
763 KUNIT_EXPECT_EQ(test, 0, tg[2].width);
764 KUNIT_EXPECT_EQ(test, 0, tg[2].value);
765
766 tg = vcap_keyfield_typegroup(&test_vctrl, VCAP_TYPE_ES2, VCAP_KFS_LL_FULL);
767 KUNIT_EXPECT_PTR_EQ(test, NULL, tg);
768}
769
770static void vcap_api_actionfield_typegroup_test(struct kunit *test)
771{
772 const struct vcap_typegroup *tg;
773
774 tg = vcap_actionfield_typegroup(&test_vctrl, VCAP_TYPE_IS0, VCAP_AFS_FULL);
775 KUNIT_EXPECT_PTR_NE(test, NULL, tg);
776 KUNIT_EXPECT_EQ(test, 0, tg[0].offset);
777 KUNIT_EXPECT_EQ(test, 3, tg[0].width);
778 KUNIT_EXPECT_EQ(test, 4, tg[0].value);
779 KUNIT_EXPECT_EQ(test, 110, tg[1].offset);
780 KUNIT_EXPECT_EQ(test, 2, tg[1].width);
781 KUNIT_EXPECT_EQ(test, 0, tg[1].value);
782 KUNIT_EXPECT_EQ(test, 220, tg[2].offset);
783 KUNIT_EXPECT_EQ(test, 2, tg[2].width);
784 KUNIT_EXPECT_EQ(test, 0, tg[2].value);
785 KUNIT_EXPECT_EQ(test, 0, tg[3].offset);
786 KUNIT_EXPECT_EQ(test, 0, tg[3].width);
787 KUNIT_EXPECT_EQ(test, 0, tg[3].value);
788
789 tg = vcap_actionfield_typegroup(&test_vctrl, VCAP_TYPE_IS2, VCAP_AFS_CLASSIFICATION);
790 KUNIT_EXPECT_PTR_EQ(test, NULL, tg);
791}
792
793static void vcap_api_vcap_keyfields_test(struct kunit *test)
794{
795 const struct vcap_field *ft;
796
797 ft = vcap_keyfields(&test_vctrl, VCAP_TYPE_IS2, VCAP_KFS_MAC_ETYPE);
798 KUNIT_EXPECT_PTR_NE(test, NULL, ft);
799
800 /* Keyset that is not available and within the maximum keyset enum value */
801 ft = vcap_keyfields(&test_vctrl, VCAP_TYPE_ES2, VCAP_KFS_PURE_5TUPLE_IP4);
802 KUNIT_EXPECT_PTR_EQ(test, NULL, ft);
803
804 /* Keyset that is not available and beyond the maximum keyset enum value */
805 ft = vcap_keyfields(&test_vctrl, VCAP_TYPE_ES2, VCAP_KFS_LL_FULL);
806 KUNIT_EXPECT_PTR_EQ(test, NULL, ft);
807}
808
809static void vcap_api_vcap_actionfields_test(struct kunit *test)
810{
811 const struct vcap_field *ft;
812
813 ft = vcap_actionfields(&test_vctrl, VCAP_TYPE_IS0, VCAP_AFS_FULL);
814 KUNIT_EXPECT_PTR_NE(test, NULL, ft);
815
816 ft = vcap_actionfields(&test_vctrl, VCAP_TYPE_IS2, VCAP_AFS_FULL);
817 KUNIT_EXPECT_PTR_EQ(test, NULL, ft);
818
819 ft = vcap_actionfields(&test_vctrl, VCAP_TYPE_IS2, VCAP_AFS_CLASSIFICATION);
820 KUNIT_EXPECT_PTR_EQ(test, NULL, ft);
821}
822
823static void vcap_api_encode_rule_keyset_test(struct kunit *test)
824{
825 u32 keywords[16] = {0};
826 u32 maskwords[16] = {0};
827 struct vcap_admin admin = {
828 .vtype = VCAP_TYPE_IS2,
829 .cache = {
830 .keystream = keywords,
831 .maskstream = maskwords,
832 },
833 };
834 struct vcap_rule_internal rule = {
835 .admin = &admin,
836 .data = {
837 .keyset = VCAP_KFS_MAC_ETYPE,
838 },
839 .vctrl = &test_vctrl,
840 };
841 struct vcap_client_keyfield ckf[] = {
842 {
843 .ctrl.key = VCAP_KF_TYPE,
844 .ctrl.type = VCAP_FIELD_U32,
845 .data.u32.value = 0x00,
846 .data.u32.mask = 0x0f,
847 },
848 {
849 .ctrl.key = VCAP_KF_LOOKUP_FIRST_IS,
850 .ctrl.type = VCAP_FIELD_BIT,
851 .data.u1.value = 0x01,
852 .data.u1.mask = 0x01,
853 },
854 {
855 .ctrl.key = VCAP_KF_IF_IGR_PORT_MASK_L3,
856 .ctrl.type = VCAP_FIELD_BIT,
857 .data.u1.value = 0x00,
858 .data.u1.mask = 0x01,
859 },
860 {
861 .ctrl.key = VCAP_KF_IF_IGR_PORT_MASK_RNG,
862 .ctrl.type = VCAP_FIELD_U32,
863 .data.u32.value = 0x00,
864 .data.u32.mask = 0x0f,
865 },
866 {
867 .ctrl.key = VCAP_KF_IF_IGR_PORT_MASK,
868 .ctrl.type = VCAP_FIELD_U72,
869 .data.u72.value = {0x0, 0x00, 0x00, 0x00},
870 .data.u72.mask = {0xfd, 0xff, 0xff, 0xff},
871 },
872 {
873 .ctrl.key = VCAP_KF_L2_DMAC,
874 .ctrl.type = VCAP_FIELD_U48,
875 /* Opposite endianness */
876 .data.u48.value = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06},
877 .data.u48.mask = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
878 },
879 {
880 .ctrl.key = VCAP_KF_ETYPE_LEN_IS,
881 .ctrl.type = VCAP_FIELD_BIT,
882 .data.u1.value = 0x01,
883 .data.u1.mask = 0x01,
884 },
885 {
886 .ctrl.key = VCAP_KF_ETYPE,
887 .ctrl.type = VCAP_FIELD_U32,
888 .data.u32.value = 0xaabb,
889 .data.u32.mask = 0xffff,
890 },
891 };
892 int idx;
893 int ret;
894
895 /* Empty entry list */
896 INIT_LIST_HEAD(&rule.data.keyfields);
897 ret = vcap_encode_rule_keyset(&rule);
898 KUNIT_EXPECT_EQ(test, -EINVAL, ret);
899
900 for (idx = 0; idx < ARRAY_SIZE(ckf); idx++)
901 list_add_tail(&ckf[idx].ctrl.list, &rule.data.keyfields);
902 ret = vcap_encode_rule_keyset(&rule);
903 KUNIT_EXPECT_EQ(test, 0, ret);
904
905 /* The key and mask values below are from an actual Sparx5 rule config */
906 /* Key */
907 KUNIT_EXPECT_EQ(test, (u32)0x00000042, keywords[0]);
908 KUNIT_EXPECT_EQ(test, (u32)0x00000000, keywords[1]);
909 KUNIT_EXPECT_EQ(test, (u32)0x00000000, keywords[2]);
910 KUNIT_EXPECT_EQ(test, (u32)0x00020100, keywords[3]);
911 KUNIT_EXPECT_EQ(test, (u32)0x60504030, keywords[4]);
912 KUNIT_EXPECT_EQ(test, (u32)0x00000000, keywords[5]);
913 KUNIT_EXPECT_EQ(test, (u32)0x00000000, keywords[6]);
914 KUNIT_EXPECT_EQ(test, (u32)0x0002aaee, keywords[7]);
915 KUNIT_EXPECT_EQ(test, (u32)0x00000000, keywords[8]);
916 KUNIT_EXPECT_EQ(test, (u32)0x00000000, keywords[9]);
917 KUNIT_EXPECT_EQ(test, (u32)0x00000000, keywords[10]);
918 KUNIT_EXPECT_EQ(test, (u32)0x00000000, keywords[11]);
919
920 /* Mask: they will be inverted when applied to the register */
921 KUNIT_EXPECT_EQ(test, (u32)~0x00b07f80, maskwords[0]);
922 KUNIT_EXPECT_EQ(test, (u32)~0xfff00000, maskwords[1]);
923 KUNIT_EXPECT_EQ(test, (u32)~0xfffffffc, maskwords[2]);
924 KUNIT_EXPECT_EQ(test, (u32)~0xfff000ff, maskwords[3]);
925 KUNIT_EXPECT_EQ(test, (u32)~0x00000000, maskwords[4]);
926 KUNIT_EXPECT_EQ(test, (u32)~0xfffffff0, maskwords[5]);
927 KUNIT_EXPECT_EQ(test, (u32)~0xfffffffe, maskwords[6]);
928 KUNIT_EXPECT_EQ(test, (u32)~0xfffc0001, maskwords[7]);
929 KUNIT_EXPECT_EQ(test, (u32)~0xffffffff, maskwords[8]);
930 KUNIT_EXPECT_EQ(test, (u32)~0xffffffff, maskwords[9]);
931 KUNIT_EXPECT_EQ(test, (u32)~0xffffffff, maskwords[10]);
932 KUNIT_EXPECT_EQ(test, (u32)~0xffffffff, maskwords[11]);
933}
934
935static void vcap_api_encode_rule_actionset_test(struct kunit *test)
936{
937 u32 actwords[16] = {0};
938 struct vcap_admin admin = {
939 .vtype = VCAP_TYPE_IS2,
940 .cache = {
941 .actionstream = actwords,
942 },
943 };
944 struct vcap_rule_internal rule = {
945 .admin = &admin,
946 .data = {
947 .actionset = VCAP_AFS_BASE_TYPE,
948 },
949 .vctrl = &test_vctrl,
950 };
951 struct vcap_client_actionfield caf[] = {
952 {
953 .ctrl.action = VCAP_AF_MATCH_ID,
954 .ctrl.type = VCAP_FIELD_U32,
955 .data.u32.value = 0x01,
956 },
957 {
958 .ctrl.action = VCAP_AF_MATCH_ID_MASK,
959 .ctrl.type = VCAP_FIELD_U32,
960 .data.u32.value = 0x01,
961 },
962 {
963 .ctrl.action = VCAP_AF_CNT_ID,
964 .ctrl.type = VCAP_FIELD_U32,
965 .data.u32.value = 0x64,
966 },
967 };
968 int idx;
969 int ret;
970
971 /* Empty entry list */
972 INIT_LIST_HEAD(&rule.data.actionfields);
973 ret = vcap_encode_rule_actionset(&rule);
974 /* We allow rules with no actions */
975 KUNIT_EXPECT_EQ(test, 0, ret);
976
977 for (idx = 0; idx < ARRAY_SIZE(caf); idx++)
978 list_add_tail(&caf[idx].ctrl.list, &rule.data.actionfields);
979 ret = vcap_encode_rule_actionset(&rule);
980 KUNIT_EXPECT_EQ(test, 0, ret);
981
982 /* The action values below are from an actual Sparx5 rule config */
983 KUNIT_EXPECT_EQ(test, (u32)0x00000002, actwords[0]);
984 KUNIT_EXPECT_EQ(test, (u32)0x00000000, actwords[1]);
985 KUNIT_EXPECT_EQ(test, (u32)0x00000000, actwords[2]);
986 KUNIT_EXPECT_EQ(test, (u32)0x00000000, actwords[3]);
987 KUNIT_EXPECT_EQ(test, (u32)0x00000000, actwords[4]);
988 KUNIT_EXPECT_EQ(test, (u32)0x00100000, actwords[5]);
989 KUNIT_EXPECT_EQ(test, (u32)0x06400010, actwords[6]);
990 KUNIT_EXPECT_EQ(test, (u32)0x00000000, actwords[7]);
991 KUNIT_EXPECT_EQ(test, (u32)0x00000000, actwords[8]);
992 KUNIT_EXPECT_EQ(test, (u32)0x00000000, actwords[9]);
993 KUNIT_EXPECT_EQ(test, (u32)0x00000000, actwords[10]);
994 KUNIT_EXPECT_EQ(test, (u32)0x00000000, actwords[11]);
995}
996
997static void vcap_free_ckf(struct vcap_rule *rule)
998{
999 struct vcap_client_keyfield *ckf, *next_ckf;
1000
1001 list_for_each_entry_safe(ckf, next_ckf, &rule->keyfields, ctrl.list) {
1002 list_del(&ckf->ctrl.list);
1003 kfree(ckf);
1004 }
1005}
1006
1007static void vcap_api_rule_add_keyvalue_test(struct kunit *test)
1008{
1009 struct vcap_admin admin = {
1010 .vtype = VCAP_TYPE_IS2,
1011 };
1012 struct vcap_rule_internal ri = {
1013 .admin = &admin,
1014 .data = {
1015 .keyset = VCAP_KFS_NO_VALUE,
1016 },
1017 .vctrl = &test_vctrl,
1018 };
1019 struct vcap_rule *rule = (struct vcap_rule *)&ri;
1020 struct vcap_client_keyfield *kf;
1021 int ret;
1022 struct vcap_u128_key dip = {
1023 .value = {0x17, 0x26, 0x35, 0x44, 0x63, 0x62, 0x71},
1024 .mask = {0xf1, 0xf2, 0xf3, 0xf4, 0x4f, 0x3f, 0x2f, 0x1f},
1025 };
1026 int idx;
1027
1028 INIT_LIST_HEAD(&rule->keyfields);
1029 ret = vcap_rule_add_key_bit(rule, VCAP_KF_LOOKUP_FIRST_IS, VCAP_BIT_0);
1030 KUNIT_EXPECT_EQ(test, 0, ret);
1031 ret = list_empty(&rule->keyfields);
1032 KUNIT_EXPECT_EQ(test, false, ret);
1033 kf = list_first_entry(&rule->keyfields, struct vcap_client_keyfield,
1034 ctrl.list);
1035 KUNIT_EXPECT_EQ(test, VCAP_KF_LOOKUP_FIRST_IS, kf->ctrl.key);
1036 KUNIT_EXPECT_EQ(test, VCAP_FIELD_BIT, kf->ctrl.type);
1037 KUNIT_EXPECT_EQ(test, 0x0, kf->data.u1.value);
1038 KUNIT_EXPECT_EQ(test, 0x1, kf->data.u1.mask);
1039 vcap_free_ckf(rule);
1040
1041 INIT_LIST_HEAD(&rule->keyfields);
1042 ret = vcap_rule_add_key_bit(rule, VCAP_KF_LOOKUP_FIRST_IS, VCAP_BIT_1);
1043 KUNIT_EXPECT_EQ(test, 0, ret);
1044 ret = list_empty(&rule->keyfields);
1045 KUNIT_EXPECT_EQ(test, false, ret);
1046 kf = list_first_entry(&rule->keyfields, struct vcap_client_keyfield,
1047 ctrl.list);
1048 KUNIT_EXPECT_EQ(test, VCAP_KF_LOOKUP_FIRST_IS, kf->ctrl.key);
1049 KUNIT_EXPECT_EQ(test, VCAP_FIELD_BIT, kf->ctrl.type);
1050 KUNIT_EXPECT_EQ(test, 0x1, kf->data.u1.value);
1051 KUNIT_EXPECT_EQ(test, 0x1, kf->data.u1.mask);
1052 vcap_free_ckf(rule);
1053
1054 INIT_LIST_HEAD(&rule->keyfields);
1055 ret = vcap_rule_add_key_bit(rule, VCAP_KF_LOOKUP_FIRST_IS,
1056 VCAP_BIT_ANY);
1057 KUNIT_EXPECT_EQ(test, 0, ret);
1058 ret = list_empty(&rule->keyfields);
1059 KUNIT_EXPECT_EQ(test, false, ret);
1060 kf = list_first_entry(&rule->keyfields, struct vcap_client_keyfield,
1061 ctrl.list);
1062 KUNIT_EXPECT_EQ(test, VCAP_KF_LOOKUP_FIRST_IS, kf->ctrl.key);
1063 KUNIT_EXPECT_EQ(test, VCAP_FIELD_BIT, kf->ctrl.type);
1064 KUNIT_EXPECT_EQ(test, 0x0, kf->data.u1.value);
1065 KUNIT_EXPECT_EQ(test, 0x0, kf->data.u1.mask);
1066 vcap_free_ckf(rule);
1067
1068 INIT_LIST_HEAD(&rule->keyfields);
1069 ret = vcap_rule_add_key_u32(rule, VCAP_KF_TYPE, 0x98765432, 0xff00ffab);
1070 KUNIT_EXPECT_EQ(test, 0, ret);
1071 ret = list_empty(&rule->keyfields);
1072 KUNIT_EXPECT_EQ(test, false, ret);
1073 kf = list_first_entry(&rule->keyfields, struct vcap_client_keyfield,
1074 ctrl.list);
1075 KUNIT_EXPECT_EQ(test, VCAP_KF_TYPE, kf->ctrl.key);
1076 KUNIT_EXPECT_EQ(test, VCAP_FIELD_U32, kf->ctrl.type);
1077 KUNIT_EXPECT_EQ(test, 0x98765432, kf->data.u32.value);
1078 KUNIT_EXPECT_EQ(test, 0xff00ffab, kf->data.u32.mask);
1079 vcap_free_ckf(rule);
1080
1081 INIT_LIST_HEAD(&rule->keyfields);
1082 ret = vcap_rule_add_key_u128(rule, VCAP_KF_L3_IP6_SIP, &dip);
1083 KUNIT_EXPECT_EQ(test, 0, ret);
1084 ret = list_empty(&rule->keyfields);
1085 KUNIT_EXPECT_EQ(test, false, ret);
1086 kf = list_first_entry(&rule->keyfields, struct vcap_client_keyfield,
1087 ctrl.list);
1088 KUNIT_EXPECT_EQ(test, VCAP_KF_L3_IP6_SIP, kf->ctrl.key);
1089 KUNIT_EXPECT_EQ(test, VCAP_FIELD_U128, kf->ctrl.type);
1090 for (idx = 0; idx < ARRAY_SIZE(dip.value); ++idx)
1091 KUNIT_EXPECT_EQ(test, dip.value[idx], kf->data.u128.value[idx]);
1092 for (idx = 0; idx < ARRAY_SIZE(dip.mask); ++idx)
1093 KUNIT_EXPECT_EQ(test, dip.mask[idx], kf->data.u128.mask[idx]);
1094 vcap_free_ckf(rule);
1095}
1096
1097static void vcap_free_caf(struct vcap_rule *rule)
1098{
1099 struct vcap_client_actionfield *caf, *next_caf;
1100
1101 list_for_each_entry_safe(caf, next_caf,
1102 &rule->actionfields, ctrl.list) {
1103 list_del(&caf->ctrl.list);
1104 kfree(caf);
1105 }
1106}
1107
1108static void vcap_api_rule_add_actionvalue_test(struct kunit *test)
1109{
1110 struct vcap_admin admin = {
1111 .vtype = VCAP_TYPE_IS2,
1112 };
1113 struct vcap_rule_internal ri = {
1114 .admin = &admin,
1115 .data = {
1116 .actionset = VCAP_AFS_NO_VALUE,
1117 },
1118 };
1119 struct vcap_rule *rule = (struct vcap_rule *)&ri;
1120 struct vcap_client_actionfield *af;
1121 int ret;
1122
1123 INIT_LIST_HEAD(&rule->actionfields);
1124 ret = vcap_rule_add_action_bit(rule, VCAP_AF_POLICE_ENA, VCAP_BIT_0);
1125 KUNIT_EXPECT_EQ(test, 0, ret);
1126 ret = list_empty(&rule->actionfields);
1127 KUNIT_EXPECT_EQ(test, false, ret);
1128 af = list_first_entry(&rule->actionfields,
1129 struct vcap_client_actionfield, ctrl.list);
1130 KUNIT_EXPECT_EQ(test, VCAP_AF_POLICE_ENA, af->ctrl.action);
1131 KUNIT_EXPECT_EQ(test, VCAP_FIELD_BIT, af->ctrl.type);
1132 KUNIT_EXPECT_EQ(test, 0x0, af->data.u1.value);
1133 vcap_free_caf(rule);
1134
1135 INIT_LIST_HEAD(&rule->actionfields);
1136 ret = vcap_rule_add_action_bit(rule, VCAP_AF_POLICE_ENA, VCAP_BIT_1);
1137 KUNIT_EXPECT_EQ(test, 0, ret);
1138 ret = list_empty(&rule->actionfields);
1139 KUNIT_EXPECT_EQ(test, false, ret);
1140 af = list_first_entry(&rule->actionfields,
1141 struct vcap_client_actionfield, ctrl.list);
1142 KUNIT_EXPECT_EQ(test, VCAP_AF_POLICE_ENA, af->ctrl.action);
1143 KUNIT_EXPECT_EQ(test, VCAP_FIELD_BIT, af->ctrl.type);
1144 KUNIT_EXPECT_EQ(test, 0x1, af->data.u1.value);
1145 vcap_free_caf(rule);
1146
1147 INIT_LIST_HEAD(&rule->actionfields);
1148 ret = vcap_rule_add_action_bit(rule, VCAP_AF_POLICE_ENA, VCAP_BIT_ANY);
1149 KUNIT_EXPECT_EQ(test, 0, ret);
1150 ret = list_empty(&rule->actionfields);
1151 KUNIT_EXPECT_EQ(test, false, ret);
1152 af = list_first_entry(&rule->actionfields,
1153 struct vcap_client_actionfield, ctrl.list);
1154 KUNIT_EXPECT_EQ(test, VCAP_AF_POLICE_ENA, af->ctrl.action);
1155 KUNIT_EXPECT_EQ(test, VCAP_FIELD_BIT, af->ctrl.type);
1156 KUNIT_EXPECT_EQ(test, 0x0, af->data.u1.value);
1157 vcap_free_caf(rule);
1158
1159 INIT_LIST_HEAD(&rule->actionfields);
1160 ret = vcap_rule_add_action_u32(rule, VCAP_AF_TYPE, 0x98765432);
1161 KUNIT_EXPECT_EQ(test, 0, ret);
1162 ret = list_empty(&rule->actionfields);
1163 KUNIT_EXPECT_EQ(test, false, ret);
1164 af = list_first_entry(&rule->actionfields,
1165 struct vcap_client_actionfield, ctrl.list);
1166 KUNIT_EXPECT_EQ(test, VCAP_AF_TYPE, af->ctrl.action);
1167 KUNIT_EXPECT_EQ(test, VCAP_FIELD_U32, af->ctrl.type);
1168 KUNIT_EXPECT_EQ(test, 0x98765432, af->data.u32.value);
1169 vcap_free_caf(rule);
1170
1171 INIT_LIST_HEAD(&rule->actionfields);
1172 ret = vcap_rule_add_action_u32(rule, VCAP_AF_MASK_MODE, 0xaabbccdd);
1173 KUNIT_EXPECT_EQ(test, 0, ret);
1174 ret = list_empty(&rule->actionfields);
1175 KUNIT_EXPECT_EQ(test, false, ret);
1176 af = list_first_entry(&rule->actionfields,
1177 struct vcap_client_actionfield, ctrl.list);
1178 KUNIT_EXPECT_EQ(test, VCAP_AF_MASK_MODE, af->ctrl.action);
1179 KUNIT_EXPECT_EQ(test, VCAP_FIELD_U32, af->ctrl.type);
1180 KUNIT_EXPECT_EQ(test, 0xaabbccdd, af->data.u32.value);
1181 vcap_free_caf(rule);
1182}
1183
1184static void vcap_api_rule_find_keyset_basic_test(struct kunit *test)
1185{
1186 struct vcap_keyset_list matches = {};
1187 struct vcap_admin admin = {
1188 .vtype = VCAP_TYPE_IS2,
1189 };
1190 struct vcap_rule_internal ri = {
1191 .admin = &admin,
1192 .vctrl = &test_vctrl,
1193 };
1194 struct vcap_client_keyfield ckf[] = {
1195 {
1196 .ctrl.key = VCAP_KF_TYPE,
1197 }, {
1198 .ctrl.key = VCAP_KF_LOOKUP_FIRST_IS,
1199 }, {
1200 .ctrl.key = VCAP_KF_IF_IGR_PORT_MASK_L3,
1201 }, {
1202 .ctrl.key = VCAP_KF_IF_IGR_PORT_MASK_RNG,
1203 }, {
1204 .ctrl.key = VCAP_KF_IF_IGR_PORT_MASK,
1205 }, {
1206 .ctrl.key = VCAP_KF_L2_DMAC,
1207 }, {
1208 .ctrl.key = VCAP_KF_ETYPE_LEN_IS,
1209 }, {
1210 .ctrl.key = VCAP_KF_ETYPE,
1211 },
1212 };
1213 int idx;
1214 bool ret;
1215 enum vcap_keyfield_set keysets[10] = {};
1216
1217 matches.keysets = keysets;
1218 matches.max = ARRAY_SIZE(keysets);
1219
1220 INIT_LIST_HEAD(&ri.data.keyfields);
1221 for (idx = 0; idx < ARRAY_SIZE(ckf); idx++)
1222 list_add_tail(&ckf[idx].ctrl.list, &ri.data.keyfields);
1223
1224 ret = vcap_rule_find_keysets(&ri.data, &matches);
1225
1226 KUNIT_EXPECT_EQ(test, true, ret);
1227 KUNIT_EXPECT_EQ(test, 1, matches.cnt);
1228 KUNIT_EXPECT_EQ(test, VCAP_KFS_MAC_ETYPE, matches.keysets[0]);
1229}
1230
1231static void vcap_api_rule_find_keyset_failed_test(struct kunit *test)
1232{
1233 struct vcap_keyset_list matches = {};
1234 struct vcap_admin admin = {
1235 .vtype = VCAP_TYPE_IS2,
1236 };
1237 struct vcap_rule_internal ri = {
1238 .admin = &admin,
1239 .vctrl = &test_vctrl,
1240 };
1241 struct vcap_client_keyfield ckf[] = {
1242 {
1243 .ctrl.key = VCAP_KF_TYPE,
1244 }, {
1245 .ctrl.key = VCAP_KF_LOOKUP_FIRST_IS,
1246 }, {
1247 .ctrl.key = VCAP_KF_ARP_OPCODE,
1248 }, {
1249 .ctrl.key = VCAP_KF_L3_IP4_SIP,
1250 }, {
1251 .ctrl.key = VCAP_KF_L3_IP4_DIP,
1252 }, {
1253 .ctrl.key = VCAP_KF_8021Q_PCP_CLS,
1254 }, {
1255 .ctrl.key = VCAP_KF_ETYPE_LEN_IS, /* Not with ARP */
1256 }, {
1257 .ctrl.key = VCAP_KF_ETYPE, /* Not with ARP */
1258 },
1259 };
1260 int idx;
1261 bool ret;
1262 enum vcap_keyfield_set keysets[10] = {};
1263
1264 matches.keysets = keysets;
1265 matches.max = ARRAY_SIZE(keysets);
1266
1267 INIT_LIST_HEAD(&ri.data.keyfields);
1268 for (idx = 0; idx < ARRAY_SIZE(ckf); idx++)
1269 list_add_tail(&ckf[idx].ctrl.list, &ri.data.keyfields);
1270
1271 ret = vcap_rule_find_keysets(&ri.data, &matches);
1272
1273 KUNIT_EXPECT_EQ(test, false, ret);
1274 KUNIT_EXPECT_EQ(test, 0, matches.cnt);
1275 KUNIT_EXPECT_EQ(test, VCAP_KFS_NO_VALUE, matches.keysets[0]);
1276}
1277
1278static void vcap_api_rule_find_keyset_many_test(struct kunit *test)
1279{
1280 struct vcap_keyset_list matches = {};
1281 struct vcap_admin admin = {
1282 .vtype = VCAP_TYPE_IS2,
1283 };
1284 struct vcap_rule_internal ri = {
1285 .admin = &admin,
1286 .vctrl = &test_vctrl,
1287 };
1288 struct vcap_client_keyfield ckf[] = {
1289 {
1290 .ctrl.key = VCAP_KF_TYPE,
1291 }, {
1292 .ctrl.key = VCAP_KF_LOOKUP_FIRST_IS,
1293 }, {
1294 .ctrl.key = VCAP_KF_8021Q_DEI_CLS,
1295 }, {
1296 .ctrl.key = VCAP_KF_8021Q_PCP_CLS,
1297 }, {
1298 .ctrl.key = VCAP_KF_8021Q_VID_CLS,
1299 }, {
1300 .ctrl.key = VCAP_KF_ISDX_CLS,
1301 }, {
1302 .ctrl.key = VCAP_KF_L2_MC_IS,
1303 }, {
1304 .ctrl.key = VCAP_KF_L2_BC_IS,
1305 },
1306 };
1307 int idx;
1308 bool ret;
1309 enum vcap_keyfield_set keysets[10] = {};
1310
1311 matches.keysets = keysets;
1312 matches.max = ARRAY_SIZE(keysets);
1313
1314 INIT_LIST_HEAD(&ri.data.keyfields);
1315 for (idx = 0; idx < ARRAY_SIZE(ckf); idx++)
1316 list_add_tail(&ckf[idx].ctrl.list, &ri.data.keyfields);
1317
1318 ret = vcap_rule_find_keysets(&ri.data, &matches);
1319
1320 KUNIT_EXPECT_EQ(test, true, ret);
1321 KUNIT_EXPECT_EQ(test, 6, matches.cnt);
1322 KUNIT_EXPECT_EQ(test, VCAP_KFS_ARP, matches.keysets[0]);
1323 KUNIT_EXPECT_EQ(test, VCAP_KFS_IP4_OTHER, matches.keysets[1]);
1324 KUNIT_EXPECT_EQ(test, VCAP_KFS_IP4_TCP_UDP, matches.keysets[2]);
1325 KUNIT_EXPECT_EQ(test, VCAP_KFS_IP6_STD, matches.keysets[3]);
1326 KUNIT_EXPECT_EQ(test, VCAP_KFS_IP_7TUPLE, matches.keysets[4]);
1327 KUNIT_EXPECT_EQ(test, VCAP_KFS_MAC_ETYPE, matches.keysets[5]);
1328}
1329
1330static void vcap_api_encode_rule_test(struct kunit *test)
1331{
1332 /* Data used by VCAP Library callback */
1333 static u32 keydata[32] = {};
1334 static u32 mskdata[32] = {};
1335 static u32 actdata[32] = {};
1336
1337 struct vcap_admin is2_admin = {
1338 .vtype = VCAP_TYPE_IS2,
1339 .first_cid = 8000000,
1340 .last_cid = 8099999,
1341 .lookups = 4,
1342 .last_valid_addr = 3071,
1343 .first_valid_addr = 0,
1344 .last_used_addr = 800,
1345 .cache = {
1346 .keystream = keydata,
1347 .maskstream = mskdata,
1348 .actionstream = actdata,
1349 },
1350 };
1351 struct vcap_rule *rule;
1352 struct vcap_rule_internal *ri;
1353 int vcap_chain_id = 8000000;
1354 enum vcap_user user = VCAP_USER_VCAP_UTIL;
1355 u16 priority = 10;
1356 int id = 100;
1357 int ret;
1358 struct vcap_u48_key smac = {
1359 .value = { 0x88, 0x75, 0x32, 0x34, 0x9e, 0xb1 },
1360 .mask = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }
1361 };
1362 struct vcap_u48_key dmac = {
1363 .value = { 0x06, 0x05, 0x04, 0x03, 0x02, 0x01 },
1364 .mask = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }
1365 };
1366 u32 port_mask_rng_value = 0x05;
1367 u32 port_mask_rng_mask = 0x0f;
1368 u32 igr_port_mask_value = 0xffabcd01;
1369 u32 igr_port_mask_mask = ~0;
1370 /* counter is written as the first operation */
1371 u32 expwriteaddr[] = {792, 792, 793, 794, 795, 796, 797};
1372 int idx;
1373
1374 vcap_test_api_init(&is2_admin);
1375
1376 /* Allocate the rule */
1377 rule = vcap_alloc_rule(&test_vctrl, &test_netdev, vcap_chain_id, user,
1378 priority, id);
1379 KUNIT_EXPECT_PTR_NE(test, NULL, rule);
1380 ri = (struct vcap_rule_internal *)rule;
1381
1382 /* Add rule keys */
1383 ret = vcap_rule_add_key_u48(rule, VCAP_KF_L2_DMAC, &dmac);
1384 KUNIT_EXPECT_EQ(test, 0, ret);
1385 ret = vcap_rule_add_key_u48(rule, VCAP_KF_L2_SMAC, &smac);
1386 KUNIT_EXPECT_EQ(test, 0, ret);
1387 ret = vcap_rule_add_key_bit(rule, VCAP_KF_ETYPE_LEN_IS, VCAP_BIT_1);
1388 KUNIT_EXPECT_EQ(test, 0, ret);
1389 /* Cannot add the same field twice */
1390 ret = vcap_rule_add_key_bit(rule, VCAP_KF_ETYPE_LEN_IS, VCAP_BIT_1);
1391 KUNIT_EXPECT_EQ(test, -EINVAL, ret);
1392 ret = vcap_rule_add_key_bit(rule, VCAP_KF_IF_IGR_PORT_MASK_L3,
1393 VCAP_BIT_ANY);
1394 KUNIT_EXPECT_EQ(test, 0, ret);
1395 ret = vcap_rule_add_key_u32(rule, VCAP_KF_IF_IGR_PORT_MASK_RNG,
1396 port_mask_rng_value, port_mask_rng_mask);
1397 KUNIT_EXPECT_EQ(test, 0, ret);
1398 ret = vcap_rule_add_key_u32(rule, VCAP_KF_IF_IGR_PORT_MASK,
1399 igr_port_mask_value, igr_port_mask_mask);
1400 KUNIT_EXPECT_EQ(test, 0, ret);
1401
1402 /* Add rule actions */
1403 ret = vcap_rule_add_action_bit(rule, VCAP_AF_POLICE_ENA, VCAP_BIT_1);
1404 KUNIT_EXPECT_EQ(test, 0, ret);
1405 ret = vcap_rule_add_action_u32(rule, VCAP_AF_CNT_ID, id);
1406 KUNIT_EXPECT_EQ(test, 0, ret);
1407 ret = vcap_rule_add_action_u32(rule, VCAP_AF_MATCH_ID, 1);
1408 KUNIT_EXPECT_EQ(test, 0, ret);
1409 ret = vcap_rule_add_action_u32(rule, VCAP_AF_MATCH_ID_MASK, 1);
1410 KUNIT_EXPECT_EQ(test, 0, ret);
1411
1412 /* For now the actionset is hardcoded */
1413 ret = vcap_set_rule_set_actionset(rule, VCAP_AFS_BASE_TYPE);
1414 KUNIT_EXPECT_EQ(test, 0, ret);
1415
1416 /* Validation with validate keyset callback */
1417 ret = vcap_val_rule(rule, ETH_P_ALL);
1418 KUNIT_EXPECT_EQ(test, 0, ret);
1419 KUNIT_EXPECT_EQ(test, VCAP_KFS_MAC_ETYPE, rule->keyset);
1420 KUNIT_EXPECT_EQ(test, VCAP_AFS_BASE_TYPE, rule->actionset);
1421 KUNIT_EXPECT_EQ(test, 6, ri->size);
1422 KUNIT_EXPECT_EQ(test, 2, ri->keyset_sw_regs);
1423 KUNIT_EXPECT_EQ(test, 4, ri->actionset_sw_regs);
1424
1425 /* Enable lookup, so the rule will be written */
1426 ret = vcap_enable_lookups(&test_vctrl, &test_netdev, 0,
1427 rule->vcap_chain_id, rule->cookie, true);
1428 KUNIT_EXPECT_EQ(test, 0, ret);
1429
1430 /* Add rule with write callback */
1431 ret = vcap_add_rule(rule);
1432 KUNIT_EXPECT_EQ(test, 0, ret);
1433 KUNIT_EXPECT_EQ(test, 792, is2_admin.last_used_addr);
1434 for (idx = 0; idx < ARRAY_SIZE(expwriteaddr); ++idx)
1435 KUNIT_EXPECT_EQ(test, expwriteaddr[idx], test_updateaddr[idx]);
1436
1437 /* Check that the rule has been added */
1438 ret = list_empty(&is2_admin.rules);
1439 KUNIT_EXPECT_EQ(test, false, ret);
1440 KUNIT_EXPECT_EQ(test, 0, ret);
1441
1442 vcap_enable_lookups(&test_vctrl, &test_netdev, 0, 0,
1443 rule->cookie, false);
1444
1445 vcap_free_rule(rule);
1446
1447 /* Check that the rule has been freed: tricky to access since this
1448 * memory should not be accessible anymore
1449 */
1450 KUNIT_EXPECT_PTR_NE(test, NULL, rule);
1451 ret = list_empty(&rule->keyfields);
1452 KUNIT_EXPECT_EQ(test, true, ret);
1453 ret = list_empty(&rule->actionfields);
1454 KUNIT_EXPECT_EQ(test, true, ret);
1455
1456 vcap_del_rule(&test_vctrl, &test_netdev, id);
1457}
1458
1459static void vcap_api_set_rule_counter_test(struct kunit *test)
1460{
1461 struct vcap_admin is2_admin = {
1462 .cache = {
1463 .counter = 100,
1464 .sticky = true,
1465 },
1466 };
1467 struct vcap_rule_internal ri = {
1468 .data = {
1469 .id = 1001,
1470 },
1471 .addr = 600,
1472 .admin = &is2_admin,
1473 .counter_id = 1002,
1474 .vctrl = &test_vctrl,
1475 };
1476 struct vcap_rule_internal ri2 = {
1477 .data = {
1478 .id = 2001,
1479 },
1480 .addr = 700,
1481 .admin = &is2_admin,
1482 .counter_id = 2002,
1483 .vctrl = &test_vctrl,
1484 };
1485 struct vcap_counter ctr = { .value = 0, .sticky = false};
1486 struct vcap_counter ctr2 = { .value = 101, .sticky = true};
1487 int ret;
1488
1489 vcap_test_api_init(&is2_admin);
1490 list_add_tail(&ri.list, &is2_admin.rules);
1491 list_add_tail(&ri2.list, &is2_admin.rules);
1492
1493 pr_info("%s:%d\n", __func__, __LINE__);
1494 ret = vcap_rule_set_counter(&ri.data, &ctr);
1495 pr_info("%s:%d\n", __func__, __LINE__);
1496 KUNIT_EXPECT_EQ(test, 0, ret);
1497
1498 KUNIT_EXPECT_EQ(test, 1002, test_hw_counter_id);
1499 KUNIT_EXPECT_EQ(test, 0, test_hw_cache.counter);
1500 KUNIT_EXPECT_EQ(test, false, test_hw_cache.sticky);
1501 KUNIT_EXPECT_EQ(test, 600, test_updateaddr[0]);
1502
1503 ret = vcap_rule_set_counter(&ri2.data, &ctr2);
1504 KUNIT_EXPECT_EQ(test, 0, ret);
1505
1506 KUNIT_EXPECT_EQ(test, 2002, test_hw_counter_id);
1507 KUNIT_EXPECT_EQ(test, 101, test_hw_cache.counter);
1508 KUNIT_EXPECT_EQ(test, true, test_hw_cache.sticky);
1509 KUNIT_EXPECT_EQ(test, 700, test_updateaddr[1]);
1510}
1511
1512static void vcap_api_get_rule_counter_test(struct kunit *test)
1513{
1514 struct vcap_admin is2_admin = {
1515 .cache = {
1516 .counter = 100,
1517 .sticky = true,
1518 },
1519 };
1520 struct vcap_rule_internal ri = {
1521 .data = {
1522 .id = 1010,
1523 },
1524 .addr = 400,
1525 .admin = &is2_admin,
1526 .counter_id = 1011,
1527 .vctrl = &test_vctrl,
1528 };
1529 struct vcap_rule_internal ri2 = {
1530 .data = {
1531 .id = 2011,
1532 },
1533 .addr = 300,
1534 .admin = &is2_admin,
1535 .counter_id = 2012,
1536 .vctrl = &test_vctrl,
1537 };
1538 struct vcap_counter ctr = {};
1539 struct vcap_counter ctr2 = {};
1540 int ret;
1541
1542 vcap_test_api_init(&is2_admin);
1543 test_hw_cache.counter = 55;
1544 test_hw_cache.sticky = true;
1545
1546 list_add_tail(&ri.list, &is2_admin.rules);
1547 list_add_tail(&ri2.list, &is2_admin.rules);
1548
1549 ret = vcap_rule_get_counter(&ri.data, &ctr);
1550 KUNIT_EXPECT_EQ(test, 0, ret);
1551
1552 KUNIT_EXPECT_EQ(test, 1011, test_hw_counter_id);
1553 KUNIT_EXPECT_EQ(test, 55, ctr.value);
1554 KUNIT_EXPECT_EQ(test, true, ctr.sticky);
1555 KUNIT_EXPECT_EQ(test, 400, test_updateaddr[0]);
1556
1557 test_hw_cache.counter = 22;
1558 test_hw_cache.sticky = false;
1559
1560 ret = vcap_rule_get_counter(&ri2.data, &ctr2);
1561 KUNIT_EXPECT_EQ(test, 0, ret);
1562
1563 KUNIT_EXPECT_EQ(test, 2012, test_hw_counter_id);
1564 KUNIT_EXPECT_EQ(test, 22, ctr2.value);
1565 KUNIT_EXPECT_EQ(test, false, ctr2.sticky);
1566 KUNIT_EXPECT_EQ(test, 300, test_updateaddr[1]);
1567}
1568
1569static void vcap_api_rule_insert_in_order_test(struct kunit *test)
1570{
1571 /* Data used by VCAP Library callback */
1572 static u32 keydata[32] = {};
1573 static u32 mskdata[32] = {};
1574 static u32 actdata[32] = {};
1575
1576 struct vcap_admin admin = {
1577 .vtype = VCAP_TYPE_IS0,
1578 .first_cid = 10000,
1579 .last_cid = 19999,
1580 .lookups = 4,
1581 .last_valid_addr = 3071,
1582 .first_valid_addr = 0,
1583 .last_used_addr = 800,
1584 .cache = {
1585 .keystream = keydata,
1586 .maskstream = mskdata,
1587 .actionstream = actdata,
1588 },
1589 };
1590
1591 vcap_test_api_init(&admin);
1592
1593 /* Create rules with different sizes and check that they are placed
1594 * at the correct address in the VCAP according to size
1595 */
1596 test_vcap_xn_rule_creator(test, 10000, VCAP_USER_QOS, 10, 500, 12, 780);
1597 test_vcap_xn_rule_creator(test, 10000, VCAP_USER_QOS, 20, 400, 6, 774);
1598 test_vcap_xn_rule_creator(test, 10000, VCAP_USER_QOS, 30, 300, 3, 771);
1599 test_vcap_xn_rule_creator(test, 10000, VCAP_USER_QOS, 40, 200, 2, 768);
1600
1601 vcap_del_rule(&test_vctrl, &test_netdev, 200);
1602 vcap_del_rule(&test_vctrl, &test_netdev, 300);
1603 vcap_del_rule(&test_vctrl, &test_netdev, 400);
1604 vcap_del_rule(&test_vctrl, &test_netdev, 500);
1605}
1606
1607static void vcap_api_rule_insert_reverse_order_test(struct kunit *test)
1608{
1609 /* Data used by VCAP Library callback */
1610 static u32 keydata[32] = {};
1611 static u32 mskdata[32] = {};
1612 static u32 actdata[32] = {};
1613
1614 struct vcap_admin admin = {
1615 .vtype = VCAP_TYPE_IS0,
1616 .first_cid = 10000,
1617 .last_cid = 19999,
1618 .lookups = 4,
1619 .last_valid_addr = 3071,
1620 .first_valid_addr = 0,
1621 .last_used_addr = 800,
1622 .cache = {
1623 .keystream = keydata,
1624 .maskstream = mskdata,
1625 .actionstream = actdata,
1626 },
1627 };
1628 struct vcap_rule_internal *elem;
1629 u32 exp_addr[] = {780, 774, 771, 768, 767};
1630 int idx;
1631
1632 vcap_test_api_init(&admin);
1633
1634 /* Create rules with different sizes and check that they are placed
1635 * at the correct address in the VCAP according to size
1636 */
1637 test_vcap_xn_rule_creator(test, 10000, VCAP_USER_QOS, 20, 200, 2, 798);
1638 KUNIT_EXPECT_EQ(test, 0, test_move_offset);
1639 KUNIT_EXPECT_EQ(test, 0, test_move_count);
1640 KUNIT_EXPECT_EQ(test, 0, test_move_addr);
1641
1642 test_vcap_xn_rule_creator(test, 10000, VCAP_USER_QOS, 30, 300, 3, 795);
1643 KUNIT_EXPECT_EQ(test, 6, test_move_offset);
1644 KUNIT_EXPECT_EQ(test, 3, test_move_count);
1645 KUNIT_EXPECT_EQ(test, 798, test_move_addr);
1646
1647 test_vcap_xn_rule_creator(test, 10000, VCAP_USER_QOS, 40, 400, 6, 792);
1648 KUNIT_EXPECT_EQ(test, 6, test_move_offset);
1649 KUNIT_EXPECT_EQ(test, 6, test_move_count);
1650 KUNIT_EXPECT_EQ(test, 792, test_move_addr);
1651
1652 test_vcap_xn_rule_creator(test, 10000, VCAP_USER_QOS, 50, 500, 12, 780);
1653 KUNIT_EXPECT_EQ(test, 18, test_move_offset);
1654 KUNIT_EXPECT_EQ(test, 12, test_move_count);
1655 KUNIT_EXPECT_EQ(test, 786, test_move_addr);
1656
1657 idx = 0;
1658 list_for_each_entry(elem, &admin.rules, list) {
1659 KUNIT_EXPECT_EQ(test, exp_addr[idx], elem->addr);
1660 ++idx;
1661 }
1662 KUNIT_EXPECT_EQ(test, 768, admin.last_used_addr);
1663
1664 vcap_del_rule(&test_vctrl, &test_netdev, 500);
1665 vcap_del_rule(&test_vctrl, &test_netdev, 400);
1666 vcap_del_rule(&test_vctrl, &test_netdev, 300);
1667 vcap_del_rule(&test_vctrl, &test_netdev, 200);
1668}
1669
1670static void vcap_api_rule_remove_at_end_test(struct kunit *test)
1671{
1672 /* Data used by VCAP Library callback */
1673 static u32 keydata[32] = {};
1674 static u32 mskdata[32] = {};
1675 static u32 actdata[32] = {};
1676
1677 struct vcap_admin admin = {
1678 .vtype = VCAP_TYPE_IS0,
1679 .first_cid = 10000,
1680 .last_cid = 19999,
1681 .lookups = 4,
1682 .last_valid_addr = 3071,
1683 .first_valid_addr = 0,
1684 .last_used_addr = 800,
1685 .cache = {
1686 .keystream = keydata,
1687 .maskstream = mskdata,
1688 .actionstream = actdata,
1689 },
1690 };
1691 int ret;
1692
1693 vcap_test_api_init(&admin);
1694 test_init_rule_deletion();
1695
1696 /* Create rules with different sizes and check that they are placed
1697 * at the correct address in the VCAP according to size
1698 */
1699 test_vcap_xn_rule_creator(test, 10000, VCAP_USER_QOS, 10, 500, 12, 780);
1700 test_vcap_xn_rule_creator(test, 10000, VCAP_USER_QOS, 20, 400, 6, 774);
1701 test_vcap_xn_rule_creator(test, 10000, VCAP_USER_QOS, 30, 300, 3, 771);
1702 test_vcap_xn_rule_creator(test, 10000, VCAP_USER_QOS, 40, 200, 2, 768);
1703
1704 /* Remove rules again from the end */
1705 ret = vcap_del_rule(&test_vctrl, &test_netdev, 200);
1706 KUNIT_EXPECT_EQ(test, 0, ret);
1707 KUNIT_EXPECT_EQ(test, 0, test_move_addr);
1708 KUNIT_EXPECT_EQ(test, 0, test_move_offset);
1709 KUNIT_EXPECT_EQ(test, 0, test_move_count);
1710 KUNIT_EXPECT_EQ(test, 768, test_init_start);
1711 KUNIT_EXPECT_EQ(test, 2, test_init_count);
1712 KUNIT_EXPECT_EQ(test, 771, admin.last_used_addr);
1713
1714 ret = vcap_del_rule(&test_vctrl, &test_netdev, 300);
1715 KUNIT_EXPECT_EQ(test, ret, 0);
1716 KUNIT_EXPECT_EQ(test, 0, test_move_addr);
1717 KUNIT_EXPECT_EQ(test, 0, test_move_offset);
1718 KUNIT_EXPECT_EQ(test, 0, test_move_count);
1719 KUNIT_EXPECT_EQ(test, 771, test_init_start);
1720 KUNIT_EXPECT_EQ(test, 3, test_init_count);
1721 KUNIT_EXPECT_EQ(test, 774, admin.last_used_addr);
1722
1723 ret = vcap_del_rule(&test_vctrl, &test_netdev, 400);
1724 KUNIT_EXPECT_EQ(test, ret, 0);
1725 KUNIT_EXPECT_EQ(test, 0, test_move_addr);
1726 KUNIT_EXPECT_EQ(test, 0, test_move_offset);
1727 KUNIT_EXPECT_EQ(test, 0, test_move_count);
1728 KUNIT_EXPECT_EQ(test, 774, test_init_start);
1729 KUNIT_EXPECT_EQ(test, 6, test_init_count);
1730 KUNIT_EXPECT_EQ(test, 780, admin.last_used_addr);
1731
1732 ret = vcap_del_rule(&test_vctrl, &test_netdev, 500);
1733 KUNIT_EXPECT_EQ(test, ret, 0);
1734 KUNIT_EXPECT_EQ(test, 0, test_move_addr);
1735 KUNIT_EXPECT_EQ(test, 0, test_move_offset);
1736 KUNIT_EXPECT_EQ(test, 0, test_move_count);
1737 KUNIT_EXPECT_EQ(test, 780, test_init_start);
1738 KUNIT_EXPECT_EQ(test, 12, test_init_count);
1739 KUNIT_EXPECT_EQ(test, 3072, admin.last_used_addr);
1740}
1741
1742static void vcap_api_rule_remove_in_middle_test(struct kunit *test)
1743{
1744 /* Data used by VCAP Library callback */
1745 static u32 keydata[32] = {};
1746 static u32 mskdata[32] = {};
1747 static u32 actdata[32] = {};
1748
1749 struct vcap_admin admin = {
1750 .vtype = VCAP_TYPE_IS0,
1751 .first_cid = 10000,
1752 .last_cid = 19999,
1753 .lookups = 4,
1754 .first_valid_addr = 0,
1755 .last_used_addr = 800,
1756 .last_valid_addr = 800 - 1,
1757 .cache = {
1758 .keystream = keydata,
1759 .maskstream = mskdata,
1760 .actionstream = actdata,
1761 },
1762 };
1763 int ret;
1764
1765 vcap_test_api_init(&admin);
1766
1767 /* Create rules with different sizes and check that they are placed
1768 * at the correct address in the VCAP according to size
1769 */
1770 test_vcap_xn_rule_creator(test, 10000, VCAP_USER_QOS, 10, 500, 12, 780);
1771 test_vcap_xn_rule_creator(test, 10000, VCAP_USER_QOS, 20, 400, 6, 774);
1772 test_vcap_xn_rule_creator(test, 10000, VCAP_USER_QOS, 30, 300, 3, 771);
1773 test_vcap_xn_rule_creator(test, 10000, VCAP_USER_QOS, 40, 200, 2, 768);
1774
1775 /* Remove rules in the middle */
1776 test_init_rule_deletion();
1777 ret = vcap_del_rule(&test_vctrl, &test_netdev, 400);
1778 KUNIT_EXPECT_EQ(test, 0, ret);
1779 KUNIT_EXPECT_EQ(test, 768, test_move_addr);
1780 KUNIT_EXPECT_EQ(test, -6, test_move_offset);
1781 KUNIT_EXPECT_EQ(test, 6, test_move_count);
1782 KUNIT_EXPECT_EQ(test, 768, test_init_start);
1783 KUNIT_EXPECT_EQ(test, 6, test_init_count);
1784 KUNIT_EXPECT_EQ(test, 774, admin.last_used_addr);
1785
1786 test_init_rule_deletion();
1787 ret = vcap_del_rule(&test_vctrl, &test_netdev, 300);
1788 KUNIT_EXPECT_EQ(test, 0, ret);
1789 KUNIT_EXPECT_EQ(test, 774, test_move_addr);
1790 KUNIT_EXPECT_EQ(test, -4, test_move_offset);
1791 KUNIT_EXPECT_EQ(test, 2, test_move_count);
1792 KUNIT_EXPECT_EQ(test, 774, test_init_start);
1793 KUNIT_EXPECT_EQ(test, 4, test_init_count);
1794 KUNIT_EXPECT_EQ(test, 778, admin.last_used_addr);
1795
1796 test_init_rule_deletion();
1797 ret = vcap_del_rule(&test_vctrl, &test_netdev, 500);
1798 KUNIT_EXPECT_EQ(test, 0, ret);
1799 KUNIT_EXPECT_EQ(test, 778, test_move_addr);
1800 KUNIT_EXPECT_EQ(test, -20, test_move_offset);
1801 KUNIT_EXPECT_EQ(test, 2, test_move_count);
1802 KUNIT_EXPECT_EQ(test, 778, test_init_start);
1803 KUNIT_EXPECT_EQ(test, 20, test_init_count);
1804 KUNIT_EXPECT_EQ(test, 798, admin.last_used_addr);
1805
1806 test_init_rule_deletion();
1807 ret = vcap_del_rule(&test_vctrl, &test_netdev, 200);
1808 KUNIT_EXPECT_EQ(test, 0, ret);
1809 KUNIT_EXPECT_EQ(test, 0, test_move_addr);
1810 KUNIT_EXPECT_EQ(test, 0, test_move_offset);
1811 KUNIT_EXPECT_EQ(test, 0, test_move_count);
1812 KUNIT_EXPECT_EQ(test, 798, test_init_start);
1813 KUNIT_EXPECT_EQ(test, 2, test_init_count);
1814 KUNIT_EXPECT_EQ(test, 800, admin.last_used_addr);
1815}
1816
1817static void vcap_api_rule_remove_in_front_test(struct kunit *test)
1818{
1819 /* Data used by VCAP Library callback */
1820 static u32 keydata[32] = {};
1821 static u32 mskdata[32] = {};
1822 static u32 actdata[32] = {};
1823
1824 struct vcap_admin admin = {
1825 .vtype = VCAP_TYPE_IS0,
1826 .first_cid = 10000,
1827 .last_cid = 19999,
1828 .lookups = 4,
1829 .first_valid_addr = 0,
1830 .last_used_addr = 800,
1831 .last_valid_addr = 800 - 1,
1832 .cache = {
1833 .keystream = keydata,
1834 .maskstream = mskdata,
1835 .actionstream = actdata,
1836 },
1837 };
1838 int ret;
1839
1840 vcap_test_api_init(&admin);
1841
1842 test_vcap_xn_rule_creator(test, 10000, VCAP_USER_QOS, 10, 500, 12, 780);
1843 KUNIT_EXPECT_EQ(test, 780, admin.last_used_addr);
1844
1845 test_init_rule_deletion();
1846 ret = vcap_del_rule(&test_vctrl, &test_netdev, 500);
1847 KUNIT_EXPECT_EQ(test, 0, ret);
1848 KUNIT_EXPECT_EQ(test, 0, test_move_addr);
1849 KUNIT_EXPECT_EQ(test, 0, test_move_offset);
1850 KUNIT_EXPECT_EQ(test, 0, test_move_count);
1851 KUNIT_EXPECT_EQ(test, 780, test_init_start);
1852 KUNIT_EXPECT_EQ(test, 12, test_init_count);
1853 KUNIT_EXPECT_EQ(test, 800, admin.last_used_addr);
1854
1855 test_vcap_xn_rule_creator(test, 10000, VCAP_USER_QOS, 20, 400, 6, 792);
1856 test_vcap_xn_rule_creator(test, 10000, VCAP_USER_QOS, 30, 300, 3, 789);
1857 test_vcap_xn_rule_creator(test, 10000, VCAP_USER_QOS, 40, 200, 2, 786);
1858
1859 test_init_rule_deletion();
1860 ret = vcap_del_rule(&test_vctrl, &test_netdev, 400);
1861 KUNIT_EXPECT_EQ(test, 0, ret);
1862 KUNIT_EXPECT_EQ(test, 786, test_move_addr);
1863 KUNIT_EXPECT_EQ(test, -8, test_move_offset);
1864 KUNIT_EXPECT_EQ(test, 6, test_move_count);
1865 KUNIT_EXPECT_EQ(test, 786, test_init_start);
1866 KUNIT_EXPECT_EQ(test, 8, test_init_count);
1867 KUNIT_EXPECT_EQ(test, 794, admin.last_used_addr);
1868
1869 vcap_del_rule(&test_vctrl, &test_netdev, 200);
1870 vcap_del_rule(&test_vctrl, &test_netdev, 300);
1871}
1872
1873static struct kunit_case vcap_api_rule_remove_test_cases[] = {
1874 KUNIT_CASE(vcap_api_rule_remove_at_end_test),
1875 KUNIT_CASE(vcap_api_rule_remove_in_middle_test),
1876 KUNIT_CASE(vcap_api_rule_remove_in_front_test),
1877 {}
1878};
1879
1880static void vcap_api_next_lookup_basic_test(struct kunit *test)
1881{
1882 struct vcap_admin admin1 = {
1883 .vtype = VCAP_TYPE_IS2,
1884 .vinst = 0,
1885 .first_cid = 8000000,
1886 .last_cid = 8199999,
1887 .lookups = 4,
1888 .lookups_per_instance = 2,
1889 };
1890 struct vcap_admin admin2 = {
1891 .vtype = VCAP_TYPE_IS2,
1892 .vinst = 1,
1893 .first_cid = 8200000,
1894 .last_cid = 8399999,
1895 .lookups = 4,
1896 .lookups_per_instance = 2,
1897 };
1898 bool ret;
1899
1900 vcap_test_api_init(&admin1);
1901 list_add_tail(&admin2.list, &test_vctrl.list);
1902
1903 ret = vcap_is_next_lookup(&test_vctrl, 8000000, 1001000);
1904 KUNIT_EXPECT_EQ(test, false, ret);
1905 ret = vcap_is_next_lookup(&test_vctrl, 8000000, 8001000);
1906 KUNIT_EXPECT_EQ(test, false, ret);
1907 ret = vcap_is_next_lookup(&test_vctrl, 8000000, 8101000);
1908 KUNIT_EXPECT_EQ(test, true, ret);
1909
1910 ret = vcap_is_next_lookup(&test_vctrl, 8100000, 8101000);
1911 KUNIT_EXPECT_EQ(test, false, ret);
1912 ret = vcap_is_next_lookup(&test_vctrl, 8100000, 8201000);
1913 KUNIT_EXPECT_EQ(test, true, ret);
1914
1915 ret = vcap_is_next_lookup(&test_vctrl, 8200000, 8201000);
1916 KUNIT_EXPECT_EQ(test, false, ret);
1917 ret = vcap_is_next_lookup(&test_vctrl, 8200000, 8301000);
1918 KUNIT_EXPECT_EQ(test, true, ret);
1919
1920 ret = vcap_is_next_lookup(&test_vctrl, 8300000, 8301000);
1921 KUNIT_EXPECT_EQ(test, false, ret);
1922 ret = vcap_is_next_lookup(&test_vctrl, 8300000, 8401000);
1923 KUNIT_EXPECT_EQ(test, false, ret);
1924}
1925
1926static void vcap_api_next_lookup_advanced_test(struct kunit *test)
1927{
1928 struct vcap_admin admin[] = {
1929 {
1930 .vtype = VCAP_TYPE_IS0,
1931 .vinst = 0,
1932 .first_cid = 1000000,
1933 .last_cid = 1199999,
1934 .lookups = 6,
1935 .lookups_per_instance = 2,
1936 }, {
1937 .vtype = VCAP_TYPE_IS0,
1938 .vinst = 1,
1939 .first_cid = 1200000,
1940 .last_cid = 1399999,
1941 .lookups = 6,
1942 .lookups_per_instance = 2,
1943 }, {
1944 .vtype = VCAP_TYPE_IS0,
1945 .vinst = 2,
1946 .first_cid = 1400000,
1947 .last_cid = 1599999,
1948 .lookups = 6,
1949 .lookups_per_instance = 2,
1950 }, {
1951 .vtype = VCAP_TYPE_IS2,
1952 .vinst = 0,
1953 .first_cid = 8000000,
1954 .last_cid = 8199999,
1955 .lookups = 4,
1956 .lookups_per_instance = 2,
1957 }, {
1958 .vtype = VCAP_TYPE_IS2,
1959 .vinst = 1,
1960 .first_cid = 8200000,
1961 .last_cid = 8399999,
1962 .lookups = 4,
1963 .lookups_per_instance = 2,
1964 }
1965 };
1966 bool ret;
1967
1968 vcap_test_api_init(&admin[0]);
1969 list_add_tail(&admin[1].list, &test_vctrl.list);
1970 list_add_tail(&admin[2].list, &test_vctrl.list);
1971 list_add_tail(&admin[3].list, &test_vctrl.list);
1972 list_add_tail(&admin[4].list, &test_vctrl.list);
1973
1974 ret = vcap_is_next_lookup(&test_vctrl, 1000000, 1001000);
1975 KUNIT_EXPECT_EQ(test, false, ret);
1976 ret = vcap_is_next_lookup(&test_vctrl, 1000000, 1101000);
1977 KUNIT_EXPECT_EQ(test, true, ret);
1978
1979 ret = vcap_is_next_lookup(&test_vctrl, 1100000, 1201000);
1980 KUNIT_EXPECT_EQ(test, true, ret);
1981 ret = vcap_is_next_lookup(&test_vctrl, 1100000, 1301000);
1982 KUNIT_EXPECT_EQ(test, true, ret);
1983 ret = vcap_is_next_lookup(&test_vctrl, 1100000, 8101000);
1984 KUNIT_EXPECT_EQ(test, true, ret);
1985 ret = vcap_is_next_lookup(&test_vctrl, 1300000, 1401000);
1986 KUNIT_EXPECT_EQ(test, true, ret);
1987 ret = vcap_is_next_lookup(&test_vctrl, 1400000, 1501000);
1988 KUNIT_EXPECT_EQ(test, true, ret);
1989 ret = vcap_is_next_lookup(&test_vctrl, 1500000, 8001000);
1990 KUNIT_EXPECT_EQ(test, true, ret);
1991
1992 ret = vcap_is_next_lookup(&test_vctrl, 8000000, 8001000);
1993 KUNIT_EXPECT_EQ(test, false, ret);
1994 ret = vcap_is_next_lookup(&test_vctrl, 8000000, 8101000);
1995 KUNIT_EXPECT_EQ(test, true, ret);
1996
1997 ret = vcap_is_next_lookup(&test_vctrl, 8300000, 8301000);
1998 KUNIT_EXPECT_EQ(test, false, ret);
1999 ret = vcap_is_next_lookup(&test_vctrl, 8300000, 8401000);
2000 KUNIT_EXPECT_EQ(test, false, ret);
2001}
2002
2003static void vcap_api_filter_unsupported_keys_test(struct kunit *test)
2004{
2005 struct vcap_admin admin = {
2006 .vtype = VCAP_TYPE_IS2,
2007 };
2008 struct vcap_rule_internal ri = {
2009 .admin = &admin,
2010 .vctrl = &test_vctrl,
2011 .data.keyset = VCAP_KFS_MAC_ETYPE,
2012 };
2013 enum vcap_key_field keylist[] = {
2014 VCAP_KF_TYPE,
2015 VCAP_KF_LOOKUP_FIRST_IS,
2016 VCAP_KF_ARP_ADDR_SPACE_OK_IS, /* arp keys are not in keyset */
2017 VCAP_KF_ARP_PROTO_SPACE_OK_IS,
2018 VCAP_KF_ARP_LEN_OK_IS,
2019 VCAP_KF_ARP_TGT_MATCH_IS,
2020 VCAP_KF_ARP_SENDER_MATCH_IS,
2021 VCAP_KF_ARP_OPCODE_UNKNOWN_IS,
2022 VCAP_KF_ARP_OPCODE,
2023 VCAP_KF_8021Q_DEI_CLS,
2024 VCAP_KF_8021Q_PCP_CLS,
2025 VCAP_KF_8021Q_VID_CLS,
2026 VCAP_KF_L2_MC_IS,
2027 VCAP_KF_L2_BC_IS,
2028 };
2029 enum vcap_key_field expected[] = {
2030 VCAP_KF_TYPE,
2031 VCAP_KF_LOOKUP_FIRST_IS,
2032 VCAP_KF_8021Q_DEI_CLS,
2033 VCAP_KF_8021Q_PCP_CLS,
2034 VCAP_KF_8021Q_VID_CLS,
2035 VCAP_KF_L2_MC_IS,
2036 VCAP_KF_L2_BC_IS,
2037 };
2038 struct vcap_client_keyfield *ckf, *next;
2039 bool ret;
2040 int idx;
2041
2042 /* Add all keys to the rule */
2043 INIT_LIST_HEAD(&ri.data.keyfields);
2044 for (idx = 0; idx < ARRAY_SIZE(keylist); idx++) {
2045 ckf = kzalloc(sizeof(*ckf), GFP_KERNEL);
2046 if (ckf) {
2047 ckf->ctrl.key = keylist[idx];
2048 list_add_tail(&ckf->ctrl.list, &ri.data.keyfields);
2049 }
2050 }
2051
2052 KUNIT_EXPECT_EQ(test, 14, ARRAY_SIZE(keylist));
2053
2054 /* Drop unsupported keys from the rule */
2055 ret = vcap_filter_rule_keys(&ri.data, NULL, 0, true);
2056
2057 KUNIT_EXPECT_EQ(test, 0, ret);
2058
2059 /* Check remaining keys in the rule */
2060 idx = 0;
2061 list_for_each_entry_safe(ckf, next, &ri.data.keyfields, ctrl.list) {
2062 KUNIT_EXPECT_EQ(test, expected[idx], ckf->ctrl.key);
2063 list_del(&ckf->ctrl.list);
2064 kfree(ckf);
2065 ++idx;
2066 }
2067 KUNIT_EXPECT_EQ(test, 7, idx);
2068}
2069
2070static void vcap_api_filter_keylist_test(struct kunit *test)
2071{
2072 struct vcap_admin admin = {
2073 .vtype = VCAP_TYPE_IS0,
2074 };
2075 struct vcap_rule_internal ri = {
2076 .admin = &admin,
2077 .vctrl = &test_vctrl,
2078 .data.keyset = VCAP_KFS_NORMAL_7TUPLE,
2079 };
2080 enum vcap_key_field keylist[] = {
2081 VCAP_KF_TYPE,
2082 VCAP_KF_LOOKUP_FIRST_IS,
2083 VCAP_KF_LOOKUP_GEN_IDX_SEL,
2084 VCAP_KF_LOOKUP_GEN_IDX,
2085 VCAP_KF_IF_IGR_PORT_MASK_SEL,
2086 VCAP_KF_IF_IGR_PORT_MASK,
2087 VCAP_KF_L2_MC_IS,
2088 VCAP_KF_L2_BC_IS,
2089 VCAP_KF_8021Q_VLAN_TAGS,
2090 VCAP_KF_8021Q_TPID0,
2091 VCAP_KF_8021Q_PCP0,
2092 VCAP_KF_8021Q_DEI0,
2093 VCAP_KF_8021Q_VID0,
2094 VCAP_KF_8021Q_TPID1,
2095 VCAP_KF_8021Q_PCP1,
2096 VCAP_KF_8021Q_DEI1,
2097 VCAP_KF_8021Q_VID1,
2098 VCAP_KF_8021Q_TPID2,
2099 VCAP_KF_8021Q_PCP2,
2100 VCAP_KF_8021Q_DEI2,
2101 VCAP_KF_8021Q_VID2,
2102 VCAP_KF_L2_DMAC,
2103 VCAP_KF_L2_SMAC,
2104 VCAP_KF_IP_MC_IS,
2105 VCAP_KF_ETYPE_LEN_IS,
2106 VCAP_KF_ETYPE,
2107 VCAP_KF_IP_SNAP_IS,
2108 VCAP_KF_IP4_IS,
2109 VCAP_KF_L3_FRAGMENT_TYPE,
2110 VCAP_KF_L3_FRAG_INVLD_L4_LEN,
2111 VCAP_KF_L3_OPTIONS_IS,
2112 VCAP_KF_L3_DSCP,
2113 VCAP_KF_L3_IP6_DIP,
2114 VCAP_KF_L3_IP6_SIP,
2115 VCAP_KF_TCP_UDP_IS,
2116 VCAP_KF_TCP_IS,
2117 VCAP_KF_L4_SPORT,
2118 VCAP_KF_L4_RNG,
2119 };
2120 enum vcap_key_field droplist[] = {
2121 VCAP_KF_8021Q_TPID1,
2122 VCAP_KF_8021Q_PCP1,
2123 VCAP_KF_8021Q_DEI1,
2124 VCAP_KF_8021Q_VID1,
2125 VCAP_KF_8021Q_TPID2,
2126 VCAP_KF_8021Q_PCP2,
2127 VCAP_KF_8021Q_DEI2,
2128 VCAP_KF_8021Q_VID2,
2129 VCAP_KF_L3_IP6_DIP,
2130 VCAP_KF_L3_IP6_SIP,
2131 VCAP_KF_L4_SPORT,
2132 VCAP_KF_L4_RNG,
2133 };
2134 enum vcap_key_field expected[] = {
2135 VCAP_KF_TYPE,
2136 VCAP_KF_LOOKUP_FIRST_IS,
2137 VCAP_KF_LOOKUP_GEN_IDX_SEL,
2138 VCAP_KF_LOOKUP_GEN_IDX,
2139 VCAP_KF_IF_IGR_PORT_MASK_SEL,
2140 VCAP_KF_IF_IGR_PORT_MASK,
2141 VCAP_KF_L2_MC_IS,
2142 VCAP_KF_L2_BC_IS,
2143 VCAP_KF_8021Q_VLAN_TAGS,
2144 VCAP_KF_8021Q_TPID0,
2145 VCAP_KF_8021Q_PCP0,
2146 VCAP_KF_8021Q_DEI0,
2147 VCAP_KF_8021Q_VID0,
2148 VCAP_KF_L2_DMAC,
2149 VCAP_KF_L2_SMAC,
2150 VCAP_KF_IP_MC_IS,
2151 VCAP_KF_ETYPE_LEN_IS,
2152 VCAP_KF_ETYPE,
2153 VCAP_KF_IP_SNAP_IS,
2154 VCAP_KF_IP4_IS,
2155 VCAP_KF_L3_FRAGMENT_TYPE,
2156 VCAP_KF_L3_FRAG_INVLD_L4_LEN,
2157 VCAP_KF_L3_OPTIONS_IS,
2158 VCAP_KF_L3_DSCP,
2159 VCAP_KF_TCP_UDP_IS,
2160 VCAP_KF_TCP_IS,
2161 };
2162 struct vcap_client_keyfield *ckf, *next;
2163 bool ret;
2164 int idx;
2165
2166 /* Add all keys to the rule */
2167 INIT_LIST_HEAD(&ri.data.keyfields);
2168 for (idx = 0; idx < ARRAY_SIZE(keylist); idx++) {
2169 ckf = kzalloc(sizeof(*ckf), GFP_KERNEL);
2170 if (ckf) {
2171 ckf->ctrl.key = keylist[idx];
2172 list_add_tail(&ckf->ctrl.list, &ri.data.keyfields);
2173 }
2174 }
2175
2176 KUNIT_EXPECT_EQ(test, 38, ARRAY_SIZE(keylist));
2177
2178 /* Drop listed keys from the rule */
2179 ret = vcap_filter_rule_keys(&ri.data, droplist, ARRAY_SIZE(droplist),
2180 false);
2181
2182 KUNIT_EXPECT_EQ(test, 0, ret);
2183
2184 /* Check remaining keys in the rule */
2185 idx = 0;
2186 list_for_each_entry_safe(ckf, next, &ri.data.keyfields, ctrl.list) {
2187 KUNIT_EXPECT_EQ(test, expected[idx], ckf->ctrl.key);
2188 list_del(&ckf->ctrl.list);
2189 kfree(ckf);
2190 ++idx;
2191 }
2192 KUNIT_EXPECT_EQ(test, 26, idx);
2193}
2194
2195static void vcap_api_rule_chain_path_test(struct kunit *test)
2196{
2197 struct vcap_admin admin1 = {
2198 .vtype = VCAP_TYPE_IS0,
2199 .vinst = 0,
2200 .first_cid = 1000000,
2201 .last_cid = 1199999,
2202 .lookups = 6,
2203 .lookups_per_instance = 2,
2204 };
2205 struct vcap_enabled_port eport3 = {
2206 .ndev = &test_netdev,
2207 .cookie = 0x100,
2208 .src_cid = 0,
2209 .dst_cid = 1000000,
2210 };
2211 struct vcap_enabled_port eport2 = {
2212 .ndev = &test_netdev,
2213 .cookie = 0x200,
2214 .src_cid = 1000000,
2215 .dst_cid = 1100000,
2216 };
2217 struct vcap_enabled_port eport1 = {
2218 .ndev = &test_netdev,
2219 .cookie = 0x300,
2220 .src_cid = 1100000,
2221 .dst_cid = 8000000,
2222 };
2223 bool ret;
2224 int chain;
2225
2226 vcap_test_api_init(&admin1);
2227 list_add_tail(&eport1.list, &admin1.enabled);
2228 list_add_tail(&eport2.list, &admin1.enabled);
2229 list_add_tail(&eport3.list, &admin1.enabled);
2230
2231 ret = vcap_path_exist(&test_vctrl, &test_netdev, 1000000);
2232 KUNIT_EXPECT_EQ(test, true, ret);
2233
2234 ret = vcap_path_exist(&test_vctrl, &test_netdev, 1100000);
2235 KUNIT_EXPECT_EQ(test, true, ret);
2236
2237 ret = vcap_path_exist(&test_vctrl, &test_netdev, 1200000);
2238 KUNIT_EXPECT_EQ(test, false, ret);
2239
2240 chain = vcap_get_next_chain(&test_vctrl, &test_netdev, 0);
2241 KUNIT_EXPECT_EQ(test, 1000000, chain);
2242
2243 chain = vcap_get_next_chain(&test_vctrl, &test_netdev, 1000000);
2244 KUNIT_EXPECT_EQ(test, 1100000, chain);
2245
2246 chain = vcap_get_next_chain(&test_vctrl, &test_netdev, 1100000);
2247 KUNIT_EXPECT_EQ(test, 8000000, chain);
2248}
2249
2250static struct kunit_case vcap_api_rule_enable_test_cases[] = {
2251 KUNIT_CASE(vcap_api_rule_chain_path_test),
2252 {}
2253};
2254
2255static struct kunit_suite vcap_api_rule_enable_test_suite = {
2256 .name = "VCAP_API_Rule_Enable_Testsuite",
2257 .test_cases = vcap_api_rule_enable_test_cases,
2258};
2259
2260static struct kunit_suite vcap_api_rule_remove_test_suite = {
2261 .name = "VCAP_API_Rule_Remove_Testsuite",
2262 .test_cases = vcap_api_rule_remove_test_cases,
2263};
2264
2265static struct kunit_case vcap_api_rule_insert_test_cases[] = {
2266 KUNIT_CASE(vcap_api_rule_insert_in_order_test),
2267 KUNIT_CASE(vcap_api_rule_insert_reverse_order_test),
2268 {}
2269};
2270
2271static struct kunit_suite vcap_api_rule_insert_test_suite = {
2272 .name = "VCAP_API_Rule_Insert_Testsuite",
2273 .test_cases = vcap_api_rule_insert_test_cases,
2274};
2275
2276static struct kunit_case vcap_api_rule_counter_test_cases[] = {
2277 KUNIT_CASE(vcap_api_set_rule_counter_test),
2278 KUNIT_CASE(vcap_api_get_rule_counter_test),
2279 {}
2280};
2281
2282static struct kunit_suite vcap_api_rule_counter_test_suite = {
2283 .name = "VCAP_API_Rule_Counter_Testsuite",
2284 .test_cases = vcap_api_rule_counter_test_cases,
2285};
2286
2287static struct kunit_case vcap_api_support_test_cases[] = {
2288 KUNIT_CASE(vcap_api_next_lookup_basic_test),
2289 KUNIT_CASE(vcap_api_next_lookup_advanced_test),
2290 KUNIT_CASE(vcap_api_filter_unsupported_keys_test),
2291 KUNIT_CASE(vcap_api_filter_keylist_test),
2292 {}
2293};
2294
2295static struct kunit_suite vcap_api_support_test_suite = {
2296 .name = "VCAP_API_Support_Testsuite",
2297 .test_cases = vcap_api_support_test_cases,
2298};
2299
2300static struct kunit_case vcap_api_full_rule_test_cases[] = {
2301 KUNIT_CASE(vcap_api_rule_find_keyset_basic_test),
2302 KUNIT_CASE(vcap_api_rule_find_keyset_failed_test),
2303 KUNIT_CASE(vcap_api_rule_find_keyset_many_test),
2304 KUNIT_CASE(vcap_api_encode_rule_test),
2305 {}
2306};
2307
2308static struct kunit_suite vcap_api_full_rule_test_suite = {
2309 .name = "VCAP_API_Full_Rule_Testsuite",
2310 .test_cases = vcap_api_full_rule_test_cases,
2311};
2312
2313static struct kunit_case vcap_api_rule_value_test_cases[] = {
2314 KUNIT_CASE(vcap_api_rule_add_keyvalue_test),
2315 KUNIT_CASE(vcap_api_rule_add_actionvalue_test),
2316 {}
2317};
2318
2319static struct kunit_suite vcap_api_rule_value_test_suite = {
2320 .name = "VCAP_API_Rule_Value_Testsuite",
2321 .test_cases = vcap_api_rule_value_test_cases,
2322};
2323
2324static struct kunit_case vcap_api_encoding_test_cases[] = {
2325 KUNIT_CASE(vcap_api_set_bit_1_test),
2326 KUNIT_CASE(vcap_api_set_bit_0_test),
2327 KUNIT_CASE(vcap_api_iterator_init_test),
2328 KUNIT_CASE(vcap_api_iterator_next_test),
2329 KUNIT_CASE(vcap_api_encode_typegroups_test),
2330 KUNIT_CASE(vcap_api_encode_bit_test),
2331 KUNIT_CASE(vcap_api_encode_field_test),
2332 KUNIT_CASE(vcap_api_encode_short_field_test),
2333 KUNIT_CASE(vcap_api_encode_keyfield_test),
2334 KUNIT_CASE(vcap_api_encode_max_keyfield_test),
2335 KUNIT_CASE(vcap_api_encode_actionfield_test),
2336 KUNIT_CASE(vcap_api_keyfield_typegroup_test),
2337 KUNIT_CASE(vcap_api_actionfield_typegroup_test),
2338 KUNIT_CASE(vcap_api_vcap_keyfields_test),
2339 KUNIT_CASE(vcap_api_vcap_actionfields_test),
2340 KUNIT_CASE(vcap_api_encode_rule_keyset_test),
2341 KUNIT_CASE(vcap_api_encode_rule_actionset_test),
2342 {}
2343};
2344
2345static struct kunit_suite vcap_api_encoding_test_suite = {
2346 .name = "VCAP_API_Encoding_Testsuite",
2347 .test_cases = vcap_api_encoding_test_cases,
2348};
2349
2350kunit_test_suite(vcap_api_rule_enable_test_suite);
2351kunit_test_suite(vcap_api_rule_remove_test_suite);
2352kunit_test_suite(vcap_api_rule_insert_test_suite);
2353kunit_test_suite(vcap_api_rule_counter_test_suite);
2354kunit_test_suite(vcap_api_support_test_suite);
2355kunit_test_suite(vcap_api_full_rule_test_suite);
2356kunit_test_suite(vcap_api_rule_value_test_suite);
2357kunit_test_suite(vcap_api_encoding_test_suite);