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