4 * Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
11 * * Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
17 * * Neither the name of Intel Corporation nor the names of its
18 * contributors may be used to endorse or promote products derived
19 * from this software without specific prior written permission.
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34 #include <rte_hexdump.h>
35 #include "test_table.h"
36 #include "test_table_acl.h"
38 #define IPv4(a, b, c, d) ((uint32_t)(((a) & 0xff) << 24) | \
39 (((b) & 0xff) << 16) | \
40 (((c) & 0xff) << 8) | \
44 * Rule and trace formats definitions.
64 struct rte_acl_field_def ipv4_defs
[NUM_FIELDS_IPV4
] = {
66 .type
= RTE_ACL_FIELD_TYPE_BITMASK
,
67 .size
= sizeof(uint8_t),
68 .field_index
= PROTO_FIELD_IPV4
,
69 .input_index
= PROTO_FIELD_IPV4
,
70 .offset
= offsetof(struct ipv4_5tuple
, proto
),
73 .type
= RTE_ACL_FIELD_TYPE_MASK
,
74 .size
= sizeof(uint32_t),
75 .field_index
= SRC_FIELD_IPV4
,
76 .input_index
= SRC_FIELD_IPV4
,
77 .offset
= offsetof(struct ipv4_5tuple
, ip_src
),
80 .type
= RTE_ACL_FIELD_TYPE_MASK
,
81 .size
= sizeof(uint32_t),
82 .field_index
= DST_FIELD_IPV4
,
83 .input_index
= DST_FIELD_IPV4
,
84 .offset
= offsetof(struct ipv4_5tuple
, ip_dst
),
87 .type
= RTE_ACL_FIELD_TYPE_RANGE
,
88 .size
= sizeof(uint16_t),
89 .field_index
= SRCP_FIELD_IPV4
,
90 .input_index
= SRCP_FIELD_IPV4
,
91 .offset
= offsetof(struct ipv4_5tuple
, port_src
),
94 .type
= RTE_ACL_FIELD_TYPE_RANGE
,
95 .size
= sizeof(uint16_t),
96 .field_index
= DSTP_FIELD_IPV4
,
97 .input_index
= SRCP_FIELD_IPV4
,
98 .offset
= offsetof(struct ipv4_5tuple
, port_dst
),
102 struct rte_table_acl_rule_add_params table_acl_IPv4_rule
;
104 typedef int (*parse_5tuple
)(char *text
,
105 struct rte_table_acl_rule_add_params
*rule
);
108 * The order of the fields in the rule string after the initial '@'
113 CB_FLD_SRC_PORT_RANGE
,
114 CB_FLD_DST_PORT_RANGE
,
120 #define GET_CB_FIELD(in, fd, base, lim, dlm) \
126 val = strtoul((in), &end, (base)); \
127 if (errno != 0 || end[0] != (dlm) || val > (lim)) \
129 (fd) = (typeof(fd)) val; \
137 parse_ipv4_net(const char *in
, uint32_t *addr
, uint32_t *mask_len
)
139 uint8_t a
, b
, c
, d
, m
;
141 GET_CB_FIELD(in
, a
, 0, UINT8_MAX
, '.');
142 GET_CB_FIELD(in
, b
, 0, UINT8_MAX
, '.');
143 GET_CB_FIELD(in
, c
, 0, UINT8_MAX
, '.');
144 GET_CB_FIELD(in
, d
, 0, UINT8_MAX
, '/');
145 GET_CB_FIELD(in
, m
, 0, sizeof(uint32_t) * CHAR_BIT
, 0);
147 addr
[0] = IPv4(a
, b
, c
, d
);
154 parse_port_range(const char *in
, uint16_t *port_low
, uint16_t *port_high
)
158 GET_CB_FIELD(in
, a
, 0, UINT16_MAX
, ':');
159 GET_CB_FIELD(in
, b
, 0, UINT16_MAX
, 0);
168 parse_cb_ipv4_rule(char *str
, struct rte_table_acl_rule_add_params
*v
)
171 char *s
, *sp
, *in
[CB_FLD_NUM
];
172 static const char *dlm
= " \t\n";
177 if (strchr(str
, '@') != str
)
183 * Populate the 'in' array with the location of each
184 * field in the string we're parsing
186 for (i
= 0; i
!= DIM(in
); i
++) {
187 in
[i
] = strtok_r(s
, dlm
, &sp
);
193 /* Parse x.x.x.x/x */
194 rc
= parse_ipv4_net(in
[CB_FLD_SRC_ADDR
],
195 &v
->field_value
[SRC_FIELD_IPV4
].value
.u32
,
196 &v
->field_value
[SRC_FIELD_IPV4
].mask_range
.u32
);
198 RTE_LOG(ERR
, PIPELINE
, "failed to read src address/mask: %s\n",
199 in
[CB_FLD_SRC_ADDR
]);
203 printf("V=%u, mask=%u\n", v
->field_value
[SRC_FIELD_IPV4
].value
.u32
,
204 v
->field_value
[SRC_FIELD_IPV4
].mask_range
.u32
);
206 /* Parse x.x.x.x/x */
207 rc
= parse_ipv4_net(in
[CB_FLD_DST_ADDR
],
208 &v
->field_value
[DST_FIELD_IPV4
].value
.u32
,
209 &v
->field_value
[DST_FIELD_IPV4
].mask_range
.u32
);
211 RTE_LOG(ERR
, PIPELINE
, "failed to read dest address/mask: %s\n",
212 in
[CB_FLD_DST_ADDR
]);
216 printf("V=%u, mask=%u\n", v
->field_value
[DST_FIELD_IPV4
].value
.u32
,
217 v
->field_value
[DST_FIELD_IPV4
].mask_range
.u32
);
219 rc
= parse_port_range(in
[CB_FLD_SRC_PORT_RANGE
],
220 &v
->field_value
[SRCP_FIELD_IPV4
].value
.u16
,
221 &v
->field_value
[SRCP_FIELD_IPV4
].mask_range
.u16
);
223 RTE_LOG(ERR
, PIPELINE
, "failed to read source port range: %s\n",
224 in
[CB_FLD_SRC_PORT_RANGE
]);
228 printf("V=%u, mask=%u\n", v
->field_value
[SRCP_FIELD_IPV4
].value
.u16
,
229 v
->field_value
[SRCP_FIELD_IPV4
].mask_range
.u16
);
231 rc
= parse_port_range(in
[CB_FLD_DST_PORT_RANGE
],
232 &v
->field_value
[DSTP_FIELD_IPV4
].value
.u16
,
233 &v
->field_value
[DSTP_FIELD_IPV4
].mask_range
.u16
);
235 RTE_LOG(ERR
, PIPELINE
, "failed to read dest port range: %s\n",
236 in
[CB_FLD_DST_PORT_RANGE
]);
240 printf("V=%u, mask=%u\n", v
->field_value
[DSTP_FIELD_IPV4
].value
.u16
,
241 v
->field_value
[DSTP_FIELD_IPV4
].mask_range
.u16
);
243 GET_CB_FIELD(in
[CB_FLD_PROTO
],
244 v
->field_value
[PROTO_FIELD_IPV4
].value
.u8
,
246 GET_CB_FIELD(in
[CB_FLD_PROTO
],
247 v
->field_value
[PROTO_FIELD_IPV4
].mask_range
.u8
,
250 printf("V=%u, mask=%u\n",
251 (unsigned int)v
->field_value
[PROTO_FIELD_IPV4
].value
.u8
,
252 v
->field_value
[PROTO_FIELD_IPV4
].mask_range
.u8
);
257 parse_cb_ipv4_rule_del(char *str
, struct rte_table_acl_rule_delete_params
*v
)
260 char *s
, *sp
, *in
[CB_FLD_NUM
];
261 static const char *dlm
= " \t\n";
266 if (strchr(str
, '@') != str
)
272 * Populate the 'in' array with the location of each
273 * field in the string we're parsing
275 for (i
= 0; i
!= DIM(in
); i
++) {
276 in
[i
] = strtok_r(s
, dlm
, &sp
);
282 /* Parse x.x.x.x/x */
283 rc
= parse_ipv4_net(in
[CB_FLD_SRC_ADDR
],
284 &v
->field_value
[SRC_FIELD_IPV4
].value
.u32
,
285 &v
->field_value
[SRC_FIELD_IPV4
].mask_range
.u32
);
287 RTE_LOG(ERR
, PIPELINE
, "failed to read src address/mask: %s\n",
288 in
[CB_FLD_SRC_ADDR
]);
292 printf("V=%u, mask=%u\n", v
->field_value
[SRC_FIELD_IPV4
].value
.u32
,
293 v
->field_value
[SRC_FIELD_IPV4
].mask_range
.u32
);
295 /* Parse x.x.x.x/x */
296 rc
= parse_ipv4_net(in
[CB_FLD_DST_ADDR
],
297 &v
->field_value
[DST_FIELD_IPV4
].value
.u32
,
298 &v
->field_value
[DST_FIELD_IPV4
].mask_range
.u32
);
300 RTE_LOG(ERR
, PIPELINE
, "failed to read dest address/mask: %s\n",
301 in
[CB_FLD_DST_ADDR
]);
305 printf("V=%u, mask=%u\n", v
->field_value
[DST_FIELD_IPV4
].value
.u32
,
306 v
->field_value
[DST_FIELD_IPV4
].mask_range
.u32
);
308 rc
= parse_port_range(in
[CB_FLD_SRC_PORT_RANGE
],
309 &v
->field_value
[SRCP_FIELD_IPV4
].value
.u16
,
310 &v
->field_value
[SRCP_FIELD_IPV4
].mask_range
.u16
);
312 RTE_LOG(ERR
, PIPELINE
, "failed to read source port range: %s\n",
313 in
[CB_FLD_SRC_PORT_RANGE
]);
317 printf("V=%u, mask=%u\n", v
->field_value
[SRCP_FIELD_IPV4
].value
.u16
,
318 v
->field_value
[SRCP_FIELD_IPV4
].mask_range
.u16
);
320 rc
= parse_port_range(in
[CB_FLD_DST_PORT_RANGE
],
321 &v
->field_value
[DSTP_FIELD_IPV4
].value
.u16
,
322 &v
->field_value
[DSTP_FIELD_IPV4
].mask_range
.u16
);
324 RTE_LOG(ERR
, PIPELINE
, "failed to read dest port range: %s\n",
325 in
[CB_FLD_DST_PORT_RANGE
]);
329 printf("V=%u, mask=%u\n", v
->field_value
[DSTP_FIELD_IPV4
].value
.u16
,
330 v
->field_value
[DSTP_FIELD_IPV4
].mask_range
.u16
);
332 GET_CB_FIELD(in
[CB_FLD_PROTO
],
333 v
->field_value
[PROTO_FIELD_IPV4
].value
.u8
,
335 GET_CB_FIELD(in
[CB_FLD_PROTO
],
336 v
->field_value
[PROTO_FIELD_IPV4
].mask_range
.u8
,
339 printf("V=%u, mask=%u\n",
340 (unsigned int)v
->field_value
[PROTO_FIELD_IPV4
].value
.u8
,
341 v
->field_value
[PROTO_FIELD_IPV4
].mask_range
.u8
);
346 * The format for these rules DO NOT need the port ranges to be
347 * separated by ' : ', just ':'. It's a lot more readable and
350 char lines
[][128] = {
351 "@0.0.0.0/0 0.0.0.0/0 0:65535 0:65535 2/0xff", /* Protocol check */
352 "@192.168.3.1/32 0.0.0.0/0 0:65535 0:65535 0/0", /* Src IP checl */
353 "@0.0.0.0/0 10.4.4.1/32 0:65535 0:65535 0/0", /* dst IP check */
354 "@0.0.0.0/0 0.0.0.0/0 105:105 0:65535 0/0", /* src port check */
355 "@0.0.0.0/0 0.0.0.0/0 0:65535 206:206 0/0", /* dst port check */
362 setup_acl_pipeline(void)
366 struct rte_pipeline_params pipeline_params
= {
371 struct rte_table_acl_rule_add_params rule_params
;
372 struct rte_pipeline_table_acl_rule_delete_params
*delete_params
;
376 /* Pipeline configuration */
377 p
= rte_pipeline_create(&pipeline_params
);
379 RTE_LOG(INFO
, PIPELINE
, "%s: Failed to configure pipeline\n",
384 /* Input port configuration */
385 for (i
= 0; i
< N_PORTS
; i
++) {
386 struct rte_port_ring_reader_params port_ring_params
= {
390 struct rte_pipeline_port_in_params port_params
= {
391 .ops
= &rte_port_ring_reader_ops
,
392 .arg_create
= (void *) &port_ring_params
,
394 .burst_size
= BURST_SIZE
,
397 /* Put in action for some ports */
399 port_params
.f_action
= port_in_action
;
401 ret
= rte_pipeline_port_in_create(p
, &port_params
,
404 rte_panic("Unable to configure input port %d, ret:%d\n",
410 /* output Port configuration */
411 for (i
= 0; i
< N_PORTS
; i
++) {
412 struct rte_port_ring_writer_params port_ring_params
= {
414 .tx_burst_sz
= BURST_SIZE
,
417 struct rte_pipeline_port_out_params port_params
= {
418 .ops
= &rte_port_ring_writer_ops
,
419 .arg_create
= (void *) &port_ring_params
,
425 if (rte_pipeline_port_out_create(p
, &port_params
,
427 rte_panic("Unable to configure output port %d\n", i
);
432 /* Table configuration */
433 for (i
= 0; i
< N_PORTS
; i
++) {
434 struct rte_pipeline_table_params table_params
;
436 /* Set up defaults for stub */
437 table_params
.ops
= &rte_table_stub_ops
;
438 table_params
.arg_create
= NULL
;
439 table_params
.f_action_hit
= action_handler_hit
;
440 table_params
.f_action_miss
= NULL
;
441 table_params
.action_data_size
= 0;
443 RTE_LOG(INFO
, PIPELINE
, "miss_action=%x\n",
444 table_entry_miss_action
);
446 printf("RTE_ACL_RULE_SZ(%zu) = %zu\n", DIM(ipv4_defs
),
447 RTE_ACL_RULE_SZ(DIM(ipv4_defs
)));
449 struct rte_table_acl_params acl_params
;
451 acl_params
.n_rules
= 1 << 5;
452 acl_params
.n_rule_fields
= DIM(ipv4_defs
);
453 snprintf(acl_name
, sizeof(acl_name
), "ACL%d", i
);
454 acl_params
.name
= acl_name
;
455 memcpy(acl_params
.field_format
, ipv4_defs
, sizeof(ipv4_defs
));
457 table_params
.ops
= &rte_table_acl_ops
;
458 table_params
.arg_create
= &acl_params
;
460 if (rte_pipeline_table_create(p
, &table_params
, &table_id
[i
])) {
461 rte_panic("Unable to configure table %u\n", i
);
465 if (connect_miss_action_to_table
) {
466 if (rte_pipeline_table_create(p
, &table_params
,
468 rte_panic("Unable to configure table %u\n", i
);
474 for (i
= 0; i
< N_PORTS
; i
++) {
475 if (rte_pipeline_port_in_connect_to_table(p
, port_in_id
[i
],
477 rte_panic("Unable to connect input port %u to "
479 port_in_id
[i
], table_id
[i
]);
484 /* Add bulk entries to tables */
485 for (i
= 0; i
< N_PORTS
; i
++) {
486 struct rte_table_acl_rule_add_params keys
[5];
487 struct rte_pipeline_table_entry entries
[5];
488 struct rte_table_acl_rule_add_params
*key_array
[5];
489 struct rte_pipeline_table_entry
*table_entries
[5];
491 struct rte_pipeline_table_entry
*table_entries_ptr
[5];
492 struct rte_pipeline_table_entry entries_ptr
[5];
494 parser
= parse_cb_ipv4_rule
;
495 for (n
= 0; n
< 5; n
++) {
496 memset(&keys
[n
], 0, sizeof(struct rte_table_acl_rule_add_params
));
497 key_array
[n
] = &keys
[n
];
499 snprintf(line
, sizeof(line
), "%s", lines
[n
]);
500 printf("PARSING [%s]\n", line
);
502 ret
= parser(line
, &keys
[n
]);
504 RTE_LOG(ERR
, PIPELINE
,
505 "line %u: parse_cb_ipv4vlan_rule"
506 " failed, error code: %d (%s)\n",
507 n
, ret
, strerror(-ret
));
511 keys
[n
].priority
= RTE_ACL_MAX_PRIORITY
- n
- 1;
513 entries
[n
].action
= RTE_PIPELINE_ACTION_PORT
;
514 entries
[n
].port_id
= port_out_id
[i
^1];
515 table_entries
[n
] = &entries
[n
];
516 table_entries_ptr
[n
] = &entries_ptr
[n
];
519 ret
= rte_pipeline_table_entry_add_bulk(p
, table_id
[i
],
520 (void **)key_array
, table_entries
, 5, key_found
, table_entries_ptr
);
522 rte_panic("Add entry bulk to table %u failed (%d)\n",
528 /* Delete bulk entries from tables */
529 for (i
= 0; i
< N_PORTS
; i
++) {
530 struct rte_table_acl_rule_delete_params keys
[5];
531 struct rte_table_acl_rule_delete_params
*key_array
[5];
532 struct rte_pipeline_table_entry
*table_entries
[5];
535 for (n
= 0; n
< 5; n
++) {
536 memset(&keys
[n
], 0, sizeof(struct rte_table_acl_rule_delete_params
));
537 key_array
[n
] = &keys
[n
];
539 snprintf(line
, sizeof(line
), "%s", lines
[n
]);
540 printf("PARSING [%s]\n", line
);
542 ret
= parse_cb_ipv4_rule_del(line
, &keys
[n
]);
544 RTE_LOG(ERR
, PIPELINE
,
545 "line %u: parse_cb_ipv4vlan_rule"
546 " failed, error code: %d (%s)\n",
547 n
, ret
, strerror(-ret
));
552 ret
= rte_pipeline_table_entry_delete_bulk(p
, table_id
[i
],
553 (void **)key_array
, 5, key_found
, table_entries
);
555 rte_panic("Delete bulk entries from table %u failed (%d)\n",
559 printf("Bulk deleted rules.\n");
562 /* Add entries to tables */
563 for (i
= 0; i
< N_PORTS
; i
++) {
564 struct rte_pipeline_table_entry table_entry
= {
565 .action
= RTE_PIPELINE_ACTION_PORT
,
566 {.port_id
= port_out_id
[i
^1]},
569 struct rte_pipeline_table_entry
*entry_ptr
;
571 memset(&rule_params
, 0, sizeof(rule_params
));
572 parser
= parse_cb_ipv4_rule
;
574 for (n
= 1; n
<= 5; n
++) {
575 snprintf(line
, sizeof(line
), "%s", lines
[n
-1]);
576 printf("PARSING [%s]\n", line
);
578 ret
= parser(line
, &rule_params
);
580 RTE_LOG(ERR
, PIPELINE
,
581 "line %u: parse_cb_ipv4vlan_rule"
582 " failed, error code: %d (%s)\n",
583 n
, ret
, strerror(-ret
));
587 rule_params
.priority
= RTE_ACL_MAX_PRIORITY
- n
;
589 ret
= rte_pipeline_table_entry_add(p
, table_id
[i
],
591 &table_entry
, &key_found
, &entry_ptr
);
593 rte_panic("Add entry to table %u failed (%d)\n",
599 /* delete a few rules */
600 for (n
= 2; n
<= 3; n
++) {
601 snprintf(line
, sizeof(line
), "%s", lines
[n
-1]);
602 printf("PARSING [%s]\n", line
);
604 ret
= parser(line
, &rule_params
);
606 RTE_LOG(ERR
, PIPELINE
, "line %u: parse rule "
607 " failed, error code: %d (%s)\n",
608 n
, ret
, strerror(-ret
));
612 delete_params
= (struct
613 rte_pipeline_table_acl_rule_delete_params
*)
614 &(rule_params
.field_value
[0]);
615 ret
= rte_pipeline_table_entry_delete(p
, table_id
[i
],
616 delete_params
, &key_found
, NULL
);
618 rte_panic("Add entry to table %u failed (%d)\n",
622 printf("Deleted Rule.\n");
626 /* Try to add duplicates */
627 for (n
= 1; n
<= 5; n
++) {
628 snprintf(line
, sizeof(line
), "%s", lines
[n
-1]);
629 printf("PARSING [%s]\n", line
);
631 ret
= parser(line
, &rule_params
);
633 RTE_LOG(ERR
, PIPELINE
, "line %u: parse rule"
634 " failed, error code: %d (%s)\n",
635 n
, ret
, strerror(-ret
));
639 rule_params
.priority
= RTE_ACL_MAX_PRIORITY
- n
;
641 ret
= rte_pipeline_table_entry_add(p
, table_id
[i
],
643 &table_entry
, &key_found
, &entry_ptr
);
645 rte_panic("Add entry to table %u failed (%d)\n",
652 /* Enable input ports */
653 for (i
= 0; i
< N_PORTS
; i
++)
654 if (rte_pipeline_port_in_enable(p
, port_in_id
[i
]))
655 rte_panic("Unable to enable input port %u\n",
658 /* Check pipeline consistency */
659 if (rte_pipeline_check(p
) < 0) {
660 rte_panic("Pipeline consistency check failed\n");
671 test_pipeline_single_filter(int expected_count
)
673 int i
, j
, ret
, tx_count
;
674 struct ipv4_5tuple five_tuple
;
676 /* Allocate a few mbufs and manually insert into the rings. */
677 for (i
= 0; i
< N_PORTS
; i
++) {
678 for (j
= 0; j
< 8; j
++) {
679 struct rte_mbuf
*mbuf
;
681 mbuf
= rte_pktmbuf_alloc(pool
);
683 /* this will cause test failure after cleanup
684 * of already enqueued mbufs, as the mbuf
685 * counts won't match */
687 memset(rte_pktmbuf_mtod(mbuf
, char *), 0x00,
688 sizeof(struct ipv4_5tuple
));
690 five_tuple
.proto
= j
;
691 five_tuple
.ip_src
= rte_bswap32(IPv4(192, 168, j
, 1));
692 five_tuple
.ip_dst
= rte_bswap32(IPv4(10, 4, j
, 1));
693 five_tuple
.port_src
= rte_bswap16(100 + j
);
694 five_tuple
.port_dst
= rte_bswap16(200 + j
);
696 memcpy(rte_pktmbuf_mtod(mbuf
, char *), &five_tuple
,
697 sizeof(struct ipv4_5tuple
));
698 RTE_LOG(INFO
, PIPELINE
, "%s: Enqueue onto ring %d\n",
700 rte_ring_enqueue(rings_rx
[i
], mbuf
);
704 /* Run pipeline once */
705 for (i
= 0; i
< N_PORTS
; i
++)
708 rte_pipeline_flush(p
);
712 for (i
= 0; i
< N_PORTS
; i
++) {
713 void *objs
[RING_TX_SIZE
];
714 struct rte_mbuf
*mbuf
;
716 ret
= rte_ring_sc_dequeue_burst(rings_tx
[i
], objs
, 10);
718 printf("Got no objects from ring %d - error code %d\n",
721 printf("Got %d object(s) from ring %d!\n", ret
, i
);
722 for (j
= 0; j
< ret
; j
++) {
723 mbuf
= (struct rte_mbuf
*)objs
[j
];
724 rte_hexdump(stdout
, "mbuf",
725 rte_pktmbuf_mtod(mbuf
, char *), 64);
726 rte_pktmbuf_free(mbuf
);
732 if (tx_count
!= expected_count
) {
733 RTE_LOG(INFO
, PIPELINE
,
734 "%s: Unexpected packets for ACL test, "
735 "expected %d, got %d\n",
736 __func__
, expected_count
, tx_count
);
740 rte_pipeline_free(p
);
753 override_hit_mask
= 0xFF; /* All packets are a hit */
755 setup_acl_pipeline();
756 if (test_pipeline_single_filter(10) < 0)