test/pipeline: fix return type of stub miss
[dpdk.git] / test / test / test_table_pipeline.c
1 /* SPDX-License-Identifier: BSD-3-Clause
2  * Copyright(c) 2010-2014 Intel Corporation
3  */
4
5 #include <string.h>
6 #include <rte_pipeline.h>
7 #include <rte_log.h>
8 #include <inttypes.h>
9 #include <rte_hexdump.h>
10 #include "test_table.h"
11 #include "test_table_pipeline.h"
12
13 #if 0
14
15 static rte_pipeline_port_out_action_handler port_action_0x00
16         (struct rte_mbuf **pkts, uint32_t n, uint64_t *pkts_mask, void *arg);
17 static rte_pipeline_port_out_action_handler port_action_0xFF
18         (struct rte_mbuf **pkts, uint32_t n, uint64_t *pkts_mask, void *arg);
19 static rte_pipeline_port_out_action_handler port_action_stub
20         (struct rte_mbuf **pkts, uint32_t n, uint64_t *pkts_mask, void *arg);
21
22
23 rte_pipeline_port_out_action_handler port_action_0x00(struct rte_mbuf **pkts,
24         uint32_t n,
25         uint64_t *pkts_mask,
26         void *arg)
27 {
28         RTE_SET_USED(pkts);
29         RTE_SET_USED(n);
30         RTE_SET_USED(arg);
31         printf("Port Action 0x00\n");
32         *pkts_mask = 0x00;
33         return 0;
34 }
35
36 rte_pipeline_port_out_action_handler port_action_0xFF(struct rte_mbuf **pkts,
37         uint32_t n,
38         uint64_t *pkts_mask,
39         void *arg)
40 {
41         RTE_SET_USED(pkts);
42         RTE_SET_USED(n);
43         RTE_SET_USED(arg);
44         printf("Port Action 0xFF\n");
45         *pkts_mask = 0xFF;
46         return 0;
47 }
48
49 rte_pipeline_port_out_action_handler port_action_stub(struct rte_mbuf **pkts,
50         uint32_t n,
51         uint64_t *pkts_mask,
52         void *arg)
53 {
54         RTE_SET_USED(pkts);
55         RTE_SET_USED(n);
56         RTE_SET_USED(pkts_mask);
57         RTE_SET_USED(arg);
58         printf("Port Action stub\n");
59         return 0;
60 }
61
62 #endif
63
64 rte_pipeline_table_action_handler_hit
65 table_action_0x00(struct rte_pipeline *p, struct rte_mbuf **pkts,
66         uint64_t pkts_mask, struct rte_pipeline_table_entry **entry, void *arg);
67
68 rte_pipeline_table_action_handler_hit
69 table_action_stub_hit(struct rte_pipeline *p, struct rte_mbuf **pkts,
70         uint64_t pkts_mask, struct rte_pipeline_table_entry **entry, void *arg);
71
72 static int
73 table_action_stub_miss(struct rte_pipeline *p, struct rte_mbuf **pkts,
74         uint64_t pkts_mask, struct rte_pipeline_table_entry **entry, void *arg);
75
76 rte_pipeline_table_action_handler_hit
77 table_action_0x00(__attribute__((unused)) struct rte_pipeline *p,
78         __attribute__((unused)) struct rte_mbuf **pkts,
79         uint64_t pkts_mask,
80         __attribute__((unused)) struct rte_pipeline_table_entry **entry,
81         __attribute__((unused)) void *arg)
82 {
83         printf("Table Action, setting pkts_mask to 0x00\n");
84         pkts_mask = ~0x00;
85         rte_pipeline_ah_packet_drop(p, pkts_mask);
86         return 0;
87 }
88
89 rte_pipeline_table_action_handler_hit
90 table_action_stub_hit(__attribute__((unused)) struct rte_pipeline *p,
91         __attribute__((unused)) struct rte_mbuf **pkts,
92         uint64_t pkts_mask,
93         __attribute__((unused)) struct rte_pipeline_table_entry **entry,
94         __attribute__((unused)) void *arg)
95 {
96         printf("STUB Table Action Hit - doing nothing\n");
97         printf("STUB Table Action Hit - setting mask to 0x%"PRIx64"\n",
98                 override_hit_mask);
99         pkts_mask = (~override_hit_mask) & 0x3;
100         rte_pipeline_ah_packet_drop(p, pkts_mask);
101         return 0;
102 }
103
104 static int
105 table_action_stub_miss(struct rte_pipeline *p,
106         __attribute__((unused)) struct rte_mbuf **pkts,
107         uint64_t pkts_mask,
108         __attribute__((unused)) struct rte_pipeline_table_entry **entry,
109         __attribute__((unused)) void *arg)
110 {
111         printf("STUB Table Action Miss - setting mask to 0x%"PRIx64"\n",
112                 override_miss_mask);
113         pkts_mask = (~override_miss_mask) & 0x3;
114         rte_pipeline_ah_packet_drop(p, pkts_mask);
115         return 0;
116 }
117
118 enum e_test_type {
119         e_TEST_STUB = 0,
120         e_TEST_LPM,
121         e_TEST_LPM6,
122         e_TEST_HASH_LRU_8,
123         e_TEST_HASH_LRU_16,
124         e_TEST_HASH_LRU_32,
125         e_TEST_HASH_EXT_8,
126         e_TEST_HASH_EXT_16,
127         e_TEST_HASH_EXT_32
128 };
129
130 char pipeline_test_names[][64] = {
131         "Stub",
132         "LPM",
133         "LPMv6",
134         "8-bit LRU Hash",
135         "16-bit LRU Hash",
136         "32-bit LRU Hash",
137         "16-bit Ext Hash",
138         "8-bit Ext Hash",
139         "32-bit Ext Hash",
140         ""
141 };
142
143
144 static int
145 cleanup_pipeline(void)
146 {
147
148         rte_pipeline_free(p);
149
150         return 0;
151 }
152
153
154 static int check_pipeline_invalid_params(void);
155
156 static int
157 check_pipeline_invalid_params(void)
158 {
159         struct rte_pipeline_params pipeline_params_1 = {
160                 .name = NULL,
161                 .socket_id = 0,
162         };
163         struct rte_pipeline_params pipeline_params_2 = {
164                 .name = "PIPELINE",
165                 .socket_id = -1,
166         };
167         struct rte_pipeline_params pipeline_params_3 = {
168                 .name = "PIPELINE",
169                 .socket_id = 127,
170         };
171
172         p = rte_pipeline_create(NULL);
173         if (p != NULL) {
174                 RTE_LOG(INFO, PIPELINE,
175                         "%s: configured pipeline with null params\n",
176                         __func__);
177                 goto fail;
178         }
179         p = rte_pipeline_create(&pipeline_params_1);
180         if (p != NULL) {
181                 RTE_LOG(INFO, PIPELINE, "%s: Configure pipeline with NULL "
182                         "name\n", __func__);
183                 goto fail;
184         }
185
186         p = rte_pipeline_create(&pipeline_params_2);
187         if (p != NULL) {
188                 RTE_LOG(INFO, PIPELINE, "%s: Configure pipeline with invalid "
189                         "socket\n", __func__);
190                 goto fail;
191         }
192
193         p = rte_pipeline_create(&pipeline_params_3);
194         if (p != NULL) {
195                 RTE_LOG(INFO, PIPELINE, "%s: Configure pipeline with invalid "
196                         "socket\n", __func__);
197                 goto fail;
198         }
199
200         /* Check pipeline consistency */
201         if (!rte_pipeline_check(p)) {
202                 rte_panic("Pipeline consistency reported as OK\n");
203                 goto fail;
204         }
205
206
207         return 0;
208 fail:
209         return -1;
210 }
211
212
213 static int
214 setup_pipeline(int test_type)
215 {
216         int ret;
217         int i;
218         struct rte_pipeline_params pipeline_params = {
219                 .name = "PIPELINE",
220                 .socket_id = 0,
221         };
222
223         RTE_LOG(INFO, PIPELINE, "%s: **** Setting up %s test\n",
224                 __func__, pipeline_test_names[test_type]);
225
226         /* Pipeline configuration */
227         p = rte_pipeline_create(&pipeline_params);
228         if (p == NULL) {
229                 RTE_LOG(INFO, PIPELINE, "%s: Failed to configure pipeline\n",
230                         __func__);
231                 goto fail;
232         }
233
234         ret = rte_pipeline_free(p);
235         if (ret != 0) {
236                 RTE_LOG(INFO, PIPELINE, "%s: Failed to free pipeline\n",
237                         __func__);
238                 goto fail;
239         }
240
241         /* Pipeline configuration */
242         p = rte_pipeline_create(&pipeline_params);
243         if (p == NULL) {
244                 RTE_LOG(INFO, PIPELINE, "%s: Failed to configure pipeline\n",
245                         __func__);
246                 goto fail;
247         }
248
249
250         /* Input port configuration */
251         for (i = 0; i < N_PORTS; i++) {
252                 struct rte_port_ring_reader_params port_ring_params = {
253                         .ring = rings_rx[i],
254                 };
255
256                 struct rte_pipeline_port_in_params port_params = {
257                         .ops = &rte_port_ring_reader_ops,
258                         .arg_create = (void *) &port_ring_params,
259                         .f_action = NULL,
260                         .burst_size = BURST_SIZE,
261                 };
262
263                 /* Put in action for some ports */
264                 if (i)
265                         port_params.f_action = NULL;
266
267                 ret = rte_pipeline_port_in_create(p, &port_params,
268                         &port_in_id[i]);
269                 if (ret) {
270                         rte_panic("Unable to configure input port %d, ret:%d\n",
271                                 i, ret);
272                         goto fail;
273                 }
274         }
275
276         /* output Port configuration */
277         for (i = 0; i < N_PORTS; i++) {
278                 struct rte_port_ring_writer_params port_ring_params = {
279                         .ring = rings_tx[i],
280                         .tx_burst_sz = BURST_SIZE,
281                 };
282
283                 struct rte_pipeline_port_out_params port_params = {
284                         .ops = &rte_port_ring_writer_ops,
285                         .arg_create = (void *) &port_ring_params,
286                         .f_action = NULL,
287                         .arg_ah = NULL,
288                 };
289
290                 if (i)
291                         port_params.f_action = port_out_action;
292
293                 if (rte_pipeline_port_out_create(p, &port_params,
294                         &port_out_id[i])) {
295                         rte_panic("Unable to configure output port %d\n", i);
296                         goto fail;
297                 }
298         }
299
300         /* Table configuration  */
301         for (i = 0; i < N_PORTS; i++) {
302                 struct rte_pipeline_table_params table_params = {
303                                 .ops = &rte_table_stub_ops,
304                                 .arg_create = NULL,
305                                 .f_action_hit = action_handler_hit,
306                                 .f_action_miss = action_handler_miss,
307                                 .action_data_size = 0,
308                 };
309
310                 if (rte_pipeline_table_create(p, &table_params, &table_id[i])) {
311                         rte_panic("Unable to configure table %u\n", i);
312                         goto fail;
313                 }
314
315                 if (connect_miss_action_to_table)
316                         if (rte_pipeline_table_create(p, &table_params,
317                                 &table_id[i+2])) {
318                                 rte_panic("Unable to configure table %u\n", i);
319                                 goto fail;
320                         }
321         }
322
323         for (i = 0; i < N_PORTS; i++)
324                 if (rte_pipeline_port_in_connect_to_table(p, port_in_id[i],
325                         table_id[i])) {
326                         rte_panic("Unable to connect input port %u to "
327                                 "table %u\n", port_in_id[i],  table_id[i]);
328                         goto fail;
329                 }
330
331         /* Add entries to tables */
332         for (i = 0; i < N_PORTS; i++) {
333                 struct rte_pipeline_table_entry default_entry = {
334                         .action = (enum rte_pipeline_action)
335                                 table_entry_default_action,
336                         {.port_id = port_out_id[i^1]},
337                 };
338                 struct rte_pipeline_table_entry *default_entry_ptr;
339
340                 if (connect_miss_action_to_table) {
341                         printf("Setting first table to output to next table\n");
342                         default_entry.action = RTE_PIPELINE_ACTION_TABLE;
343                         default_entry.table_id = table_id[i+2];
344                 }
345
346                 /* Add the default action for the table. */
347                 ret = rte_pipeline_table_default_entry_add(p, table_id[i],
348                         &default_entry, &default_entry_ptr);
349                 if (ret < 0) {
350                         rte_panic("Unable to add default entry to table %u "
351                                 "code %d\n", table_id[i], ret);
352                         goto fail;
353                 } else
354                         printf("Added default entry to table id %d with "
355                                 "action %x\n",
356                                 table_id[i], default_entry.action);
357
358                 if (connect_miss_action_to_table) {
359                         /* We create a second table so the first can pass
360                         traffic into it */
361                         struct rte_pipeline_table_entry default_entry = {
362                                 .action = RTE_PIPELINE_ACTION_PORT,
363                                 {.port_id = port_out_id[i^1]},
364                         };
365                         printf("Setting secont table to output to port\n");
366
367                         /* Add the default action for the table. */
368                         ret = rte_pipeline_table_default_entry_add(p,
369                                 table_id[i+2],
370                                 &default_entry, &default_entry_ptr);
371                         if (ret < 0) {
372                                 rte_panic("Unable to add default entry to "
373                                         "table %u code %d\n",
374                                         table_id[i], ret);
375                                 goto fail;
376                         } else
377                                 printf("Added default entry to table id %d "
378                                         "with action %x\n",
379                                         table_id[i], default_entry.action);
380                 }
381         }
382
383         /* Enable input ports */
384         for (i = 0; i < N_PORTS ; i++)
385                 if (rte_pipeline_port_in_enable(p, port_in_id[i]))
386                         rte_panic("Unable to enable input port %u\n",
387                                 port_in_id[i]);
388
389         /* Check pipeline consistency */
390         if (rte_pipeline_check(p) < 0) {
391                 rte_panic("Pipeline consistency check failed\n");
392                 goto fail;
393         } else
394                 printf("Pipeline Consistency OK!\n");
395
396         return 0;
397 fail:
398
399         return -1;
400 }
401
402 static int
403 test_pipeline_single_filter(int test_type, int expected_count)
404 {
405         int i;
406         int j;
407         int ret;
408         int tx_count;
409
410         RTE_LOG(INFO, PIPELINE, "%s: **** Running %s test\n",
411                 __func__, pipeline_test_names[test_type]);
412         /* Run pipeline once */
413         for (i = 0; i < N_PORTS; i++)
414                 rte_pipeline_run(p);
415
416
417         ret = rte_pipeline_flush(NULL);
418         if (ret != -EINVAL) {
419                 RTE_LOG(INFO, PIPELINE,
420                         "%s: No pipeline flush error NULL pipeline (%d)\n",
421                         __func__, ret);
422                 goto fail;
423         }
424
425         /*
426          * Allocate a few mbufs and manually insert into the rings. */
427         for (i = 0; i < N_PORTS; i++)
428                 for (j = 0; j < N_PORTS; j++) {
429                         struct rte_mbuf *m;
430                         uint8_t *key;
431                         uint32_t *k32;
432
433                         m = rte_pktmbuf_alloc(pool);
434                         if (m == NULL) {
435                                 rte_panic("Failed to alloc mbuf from pool\n");
436                                 return -1;
437                         }
438                         key = RTE_MBUF_METADATA_UINT8_PTR(m,
439                                         APP_METADATA_OFFSET(32));
440
441                         k32 = (uint32_t *) key;
442                         k32[0] = 0xadadadad >> (j % 2);
443
444                         RTE_LOG(INFO, PIPELINE, "%s: Enqueue onto ring %d\n",
445                                 __func__, i);
446                         rte_ring_enqueue(rings_rx[i], m);
447                 }
448
449         /* Run pipeline once */
450         for (i = 0; i < N_PORTS; i++)
451                 rte_pipeline_run(p);
452
453    /*
454         * need to flush the pipeline, as there may be less hits than the burst
455         size and they will not have been flushed to the tx rings. */
456         rte_pipeline_flush(p);
457
458    /*
459         * Now we'll see what we got back on the tx rings. We should see whatever
460         * packets we had hits on that were destined for the output ports.
461         */
462         tx_count = 0;
463
464         for (i = 0; i < N_PORTS; i++) {
465                 void *objs[RING_TX_SIZE];
466                 struct rte_mbuf *mbuf;
467
468                 ret = rte_ring_sc_dequeue_burst(rings_tx[i], objs, 10, NULL);
469                 if (ret <= 0)
470                         printf("Got no objects from ring %d - error code %d\n",
471                                 i, ret);
472                 else {
473                         printf("Got %d object(s) from ring %d!\n", ret, i);
474                         for (j = 0; j < ret; j++) {
475                                 mbuf = objs[j];
476                                 rte_hexdump(stdout, "Object:",
477                                         rte_pktmbuf_mtod(mbuf, char *),
478                                         mbuf->data_len);
479                                 rte_pktmbuf_free(mbuf);
480                         }
481                         tx_count += ret;
482                 }
483         }
484
485         if (tx_count != expected_count) {
486                 RTE_LOG(INFO, PIPELINE,
487                         "%s: Unexpected packets out for %s test, expected %d, "
488                         "got %d\n", __func__, pipeline_test_names[test_type],
489                         expected_count, tx_count);
490                 goto fail;
491         }
492
493         cleanup_pipeline();
494
495         return 0;
496 fail:
497         return -1;
498
499 }
500
501 int
502 test_table_pipeline(void)
503 {
504         /* TEST - All packets dropped */
505         action_handler_hit = NULL;
506         action_handler_miss = NULL;
507         table_entry_default_action = RTE_PIPELINE_ACTION_DROP;
508         setup_pipeline(e_TEST_STUB);
509         if (test_pipeline_single_filter(e_TEST_STUB, 0) < 0)
510                 return -1;
511
512         /* TEST - All packets passed through */
513         table_entry_default_action = RTE_PIPELINE_ACTION_PORT;
514         setup_pipeline(e_TEST_STUB);
515         if (test_pipeline_single_filter(e_TEST_STUB, 4) < 0)
516                 return -1;
517
518         /* TEST - one packet per port */
519         action_handler_hit = NULL;
520         action_handler_miss =
521                 (rte_pipeline_table_action_handler_miss) table_action_stub_miss;
522         table_entry_default_action = RTE_PIPELINE_ACTION_PORT;
523         override_miss_mask = 0x01; /* one packet per port */
524         setup_pipeline(e_TEST_STUB);
525         if (test_pipeline_single_filter(e_TEST_STUB, 2) < 0)
526                 return -1;
527
528         /* TEST - one packet per port */
529         override_miss_mask = 0x02; /*all per port */
530         setup_pipeline(e_TEST_STUB);
531         if (test_pipeline_single_filter(e_TEST_STUB, 2) < 0)
532                 return -1;
533
534         /* TEST - all packets per port */
535         override_miss_mask = 0x03; /*all per port */
536         setup_pipeline(e_TEST_STUB);
537         if (test_pipeline_single_filter(e_TEST_STUB, 4) < 0)
538                 return -1;
539
540    /*
541         * This test will set up two tables in the pipeline. the first table
542         * will forward to another table on miss, and the second table will
543         * forward to port.
544         */
545         connect_miss_action_to_table = 1;
546         table_entry_default_action = RTE_PIPELINE_ACTION_TABLE;
547         action_handler_hit = NULL;  /* not for stub, hitmask always zero */
548         action_handler_miss = NULL;
549         setup_pipeline(e_TEST_STUB);
550         if (test_pipeline_single_filter(e_TEST_STUB, 4) < 0)
551                 return -1;
552         connect_miss_action_to_table = 0;
553
554         printf("TEST - two tables, hitmask override to 0x01\n");
555         connect_miss_action_to_table = 1;
556         action_handler_miss =
557                 (rte_pipeline_table_action_handler_miss)table_action_stub_miss;
558         override_miss_mask = 0x01;
559         setup_pipeline(e_TEST_STUB);
560         if (test_pipeline_single_filter(e_TEST_STUB, 2) < 0)
561                 return -1;
562         connect_miss_action_to_table = 0;
563
564         if (check_pipeline_invalid_params()) {
565                 RTE_LOG(INFO, PIPELINE, "%s: Check pipeline invalid params "
566                         "failed.\n", __func__);
567                 return -1;
568         }
569
570         return 0;
571 }