Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright(C) 2023 Marvell.
3 : : */
4 : :
5 : : #include <stdio.h>
6 : : #include <inttypes.h>
7 : :
8 : : #include <rte_ethdev.h>
9 : : #include <rte_malloc.h>
10 : : #include <rte_security.h>
11 : :
12 : : #include "test.h"
13 : : #include "test_security_inline_macsec_vectors.h"
14 : :
15 : : #ifdef RTE_EXEC_ENV_WINDOWS
16 : : static int
17 : : test_inline_macsec(void)
18 : : {
19 : : printf("Inline MACsec not supported on Windows, skipping test\n");
20 : : return TEST_SKIPPED;
21 : : }
22 : :
23 : : #else
24 : :
25 : : #define NB_ETHPORTS_USED 1
26 : : #define MEMPOOL_CACHE_SIZE 32
27 : : #define RTE_TEST_RX_DESC_DEFAULT 1024
28 : : #define RTE_TEST_TX_DESC_DEFAULT 1024
29 : : #define RTE_PORT_ALL (~(uint16_t)0x0)
30 : :
31 : : #define RX_PTHRESH 8 /**< Default values of RX prefetch threshold reg. */
32 : : #define RX_HTHRESH 8 /**< Default values of RX host threshold reg. */
33 : : #define RX_WTHRESH 0 /**< Default values of RX write-back threshold reg. */
34 : :
35 : : #define TX_PTHRESH 32 /**< Default values of TX prefetch threshold reg. */
36 : : #define TX_HTHRESH 0 /**< Default values of TX host threshold reg. */
37 : : #define TX_WTHRESH 0 /**< Default values of TX write-back threshold reg. */
38 : :
39 : : #define MAX_TRAFFIC_BURST 2048
40 : : #define NB_MBUF 10240
41 : :
42 : : #define MCS_INVALID_SA 0xFFFF
43 : : #define MCS_DEFAULT_PN_THRESHOLD 0xFFFFF
44 : :
45 : : static struct rte_mempool *mbufpool;
46 : : static struct rte_mempool *sess_pool;
47 : : /* ethernet addresses of ports */
48 : : static struct rte_ether_addr ports_eth_addr[RTE_MAX_ETHPORTS];
49 : :
50 : : struct mcs_test_opts {
51 : : int val_frames;
52 : : int nb_td;
53 : : uint16_t mtu;
54 : : uint8_t sa_in_use;
55 : : bool encrypt;
56 : : bool protect_frames;
57 : : uint8_t sectag_insert_mode;
58 : : uint8_t nb_vlan;
59 : : uint32_t replay_win_sz;
60 : : uint8_t replay_protect;
61 : : uint8_t rekey_en;
62 : : const struct mcs_test_vector *rekey_td;
63 : : const struct mcs_test_vector *ar_td[3];
64 : : bool dump_all_stats;
65 : : uint8_t check_untagged_rx;
66 : : uint8_t check_bad_tag_cnt;
67 : : uint8_t check_sa_not_in_use;
68 : : uint8_t check_decap_stats;
69 : : uint8_t check_verify_only_stats;
70 : : uint8_t check_pkts_invalid_stats;
71 : : uint8_t check_pkts_unchecked_stats;
72 : : uint8_t check_out_pkts_untagged;
73 : : uint8_t check_out_pkts_toolong;
74 : : uint8_t check_encap_stats;
75 : : uint8_t check_auth_only_stats;
76 : : uint8_t check_sectag_interrupts;
77 : : };
78 : :
79 : : static struct rte_eth_conf port_conf = {
80 : : .rxmode = {
81 : : .mq_mode = RTE_ETH_MQ_RX_NONE,
82 : : .offloads = RTE_ETH_RX_OFFLOAD_CHECKSUM |
83 : : RTE_ETH_RX_OFFLOAD_MACSEC_STRIP,
84 : : },
85 : : .txmode = {
86 : : .mq_mode = RTE_ETH_MQ_TX_NONE,
87 : : .offloads = RTE_ETH_TX_OFFLOAD_MBUF_FAST_FREE |
88 : : RTE_ETH_TX_OFFLOAD_MACSEC_INSERT,
89 : : },
90 : : .lpbk_mode = 1, /* enable loopback */
91 : : };
92 : :
93 : : static struct rte_eth_rxconf rx_conf = {
94 : : .rx_thresh = {
95 : : .pthresh = RX_PTHRESH,
96 : : .hthresh = RX_HTHRESH,
97 : : .wthresh = RX_WTHRESH,
98 : : },
99 : : .rx_free_thresh = 32,
100 : : };
101 : :
102 : : static struct rte_eth_txconf tx_conf = {
103 : : .tx_thresh = {
104 : : .pthresh = TX_PTHRESH,
105 : : .hthresh = TX_HTHRESH,
106 : : .wthresh = TX_WTHRESH,
107 : : },
108 : : .tx_free_thresh = 32, /* Use PMD default values */
109 : : .tx_rs_thresh = 32, /* Use PMD default values */
110 : : };
111 : :
112 : : static uint16_t port_id;
113 : :
114 : : static uint64_t link_mbps;
115 : :
116 : : static struct rte_flow *default_tx_flow[RTE_MAX_ETHPORTS];
117 : : static struct rte_flow *default_rx_flow[RTE_MAX_ETHPORTS];
118 : :
119 : : static struct rte_mbuf **tx_pkts_burst;
120 : : static struct rte_mbuf **rx_pkts_burst;
121 : :
122 : : static inline struct rte_mbuf *
123 : 0 : init_packet(struct rte_mempool *mp, const uint8_t *data, unsigned int len)
124 : : {
125 : : struct rte_mbuf *pkt;
126 : :
127 : 0 : pkt = rte_pktmbuf_alloc(mp);
128 [ # # ]: 0 : if (pkt == NULL)
129 : : return NULL;
130 : :
131 : 0 : rte_memcpy(rte_pktmbuf_append(pkt, len), data, len);
132 : :
133 : : return pkt;
134 : : }
135 : :
136 : : static int
137 : 0 : init_mempools(unsigned int nb_mbuf)
138 : : {
139 : : void *sec_ctx;
140 : : uint16_t nb_sess = 512;
141 : : uint32_t sess_sz;
142 : : char s[64];
143 : :
144 [ # # ]: 0 : if (mbufpool == NULL) {
145 : : snprintf(s, sizeof(s), "mbuf_pool");
146 : 0 : mbufpool = rte_pktmbuf_pool_create(s, nb_mbuf,
147 : : MEMPOOL_CACHE_SIZE, 0,
148 : : RTE_MBUF_DEFAULT_BUF_SIZE, SOCKET_ID_ANY);
149 [ # # ]: 0 : if (mbufpool == NULL) {
150 : : printf("Cannot init mbuf pool\n");
151 : 0 : return TEST_FAILED;
152 : : }
153 : : printf("Allocated mbuf pool\n");
154 : : }
155 : :
156 : 0 : sec_ctx = rte_eth_dev_get_sec_ctx(port_id);
157 [ # # ]: 0 : if (sec_ctx == NULL) {
158 : : printf("Device does not support Security ctx\n");
159 : 0 : return TEST_SKIPPED;
160 : : }
161 : 0 : sess_sz = rte_security_session_get_size(sec_ctx);
162 [ # # ]: 0 : if (sess_pool == NULL) {
163 : : snprintf(s, sizeof(s), "sess_pool");
164 : 0 : sess_pool = rte_mempool_create(s, nb_sess, sess_sz,
165 : : MEMPOOL_CACHE_SIZE, 0,
166 : : NULL, NULL, NULL, NULL,
167 : : SOCKET_ID_ANY, 0);
168 [ # # ]: 0 : if (sess_pool == NULL) {
169 : : printf("Cannot init sess pool\n");
170 : 0 : return TEST_FAILED;
171 : : }
172 : : printf("Allocated sess pool\n");
173 : : }
174 : :
175 : : return 0;
176 : : }
177 : :
178 : : static void
179 : : fill_macsec_sa_conf(const struct mcs_test_vector *td, struct rte_security_macsec_sa *sa,
180 : : enum rte_security_macsec_direction dir, uint8_t an, uint8_t tci_off)
181 : : {
182 : 0 : sa->dir = dir;
183 : :
184 : 0 : sa->key.data = td->sa_key.data;
185 : 0 : sa->key.length = td->sa_key.len;
186 : :
187 : : memcpy((uint8_t *)sa->salt, (const uint8_t *)td->salt, RTE_SECURITY_MACSEC_SALT_LEN);
188 : :
189 : : /* AN is set as per the value in secure packet in test vector */
190 : 0 : sa->an = an & RTE_MACSEC_AN_MASK;
191 : :
192 : 0 : sa->ssci = td->ssci;
193 : 0 : sa->xpn = td->xpn;
194 : : /* Starting packet number which is expected to come next.
195 : : * It is take from the test vector so that we can match the out packet.
196 : : */
197 : 0 : sa->next_pn = *(const uint32_t *)(&td->secure_pkt.data[tci_off + 2]);
198 : 0 : }
199 : :
200 : : static void
201 : 0 : fill_macsec_sc_conf(const struct mcs_test_vector *td,
202 : : struct rte_security_macsec_sc *sc_conf,
203 : : const struct mcs_test_opts *opts,
204 : : enum rte_security_macsec_direction dir,
205 : : uint16_t sa_id[], uint8_t tci_off)
206 : : {
207 : : uint8_t i;
208 : :
209 : 0 : sc_conf->dir = dir;
210 : 0 : sc_conf->pn_threshold = ((uint64_t)td->xpn << 32) |
211 [ # # ]: 0 : rte_be_to_cpu_32(*(const uint32_t *)(&td->secure_pkt.data[tci_off + 2]));
212 [ # # ]: 0 : if (dir == RTE_SECURITY_MACSEC_DIR_TX) {
213 : 0 : sc_conf->sc_tx.sa_id = sa_id[0];
214 [ # # ]: 0 : if (sa_id[1] != MCS_INVALID_SA) {
215 : 0 : sc_conf->sc_tx.sa_id_rekey = sa_id[1];
216 : 0 : sc_conf->sc_tx.re_key_en = 1;
217 : : }
218 : 0 : sc_conf->sc_tx.active = 1;
219 : : /* is SCI valid */
220 [ # # ]: 0 : if (td->secure_pkt.data[tci_off] & RTE_MACSEC_TCI_SC) {
221 [ # # ]: 0 : memcpy(&sc_conf->sc_tx.sci, &td->secure_pkt.data[tci_off + 6],
222 : : sizeof(sc_conf->sc_tx.sci));
223 [ # # ]: 0 : sc_conf->sc_tx.sci = rte_be_to_cpu_64(sc_conf->sc_tx.sci);
224 [ # # ]: 0 : } else if (td->secure_pkt.data[tci_off] & RTE_MACSEC_TCI_ES) {
225 : : /* sci = source_mac + port_id when ES.bit = 1 & SC.bit = 0 */
226 : 0 : const uint8_t *smac = td->plain_pkt.data + RTE_ETHER_ADDR_LEN;
227 : 0 : uint8_t *ptr = (uint8_t *)&sc_conf->sc_tx.sci;
228 : :
229 : 0 : ptr[0] = 0x01;
230 : 0 : ptr[1] = 0;
231 [ # # ]: 0 : for (i = 0; i < RTE_ETHER_ADDR_LEN; i++)
232 : 0 : ptr[2 + i] = smac[RTE_ETHER_ADDR_LEN - 1 - i];
233 : : } else {
234 : : /* use some default SCI */
235 : 0 : sc_conf->sc_tx.sci = 0xf1341e023a2b1c5d;
236 : : }
237 [ # # ]: 0 : if (td->xpn > 0)
238 : 0 : sc_conf->sc_tx.is_xpn = 1;
239 : : } else {
240 [ # # ]: 0 : for (i = 0; i < RTE_SECURITY_MACSEC_NUM_AN; i++) {
241 : 0 : sc_conf->sc_rx.sa_id[i] = sa_id[i];
242 : 0 : sc_conf->sc_rx.sa_in_use[i] = opts->sa_in_use;
243 : : }
244 : 0 : sc_conf->sc_rx.active = 1;
245 [ # # ]: 0 : if (td->xpn > 0)
246 : 0 : sc_conf->sc_rx.is_xpn = 1;
247 : : }
248 : 0 : }
249 : :
250 : :
251 : : /* Create Inline MACsec session */
252 : : static int
253 : 0 : fill_session_conf(const struct mcs_test_vector *td, uint16_t portid __rte_unused,
254 : : const struct mcs_test_opts *opts,
255 : : struct rte_security_session_conf *sess_conf,
256 : : enum rte_security_macsec_direction dir,
257 : : uint16_t sc_id,
258 : : uint8_t tci_off)
259 : : {
260 : 0 : sess_conf->action_type = RTE_SECURITY_ACTION_TYPE_INLINE_PROTOCOL;
261 : 0 : sess_conf->protocol = RTE_SECURITY_PROTOCOL_MACSEC;
262 : 0 : sess_conf->macsec.dir = dir;
263 : 0 : sess_conf->macsec.alg = td->alg;
264 : 0 : sess_conf->macsec.cipher_off = 0;
265 [ # # ]: 0 : if (td->secure_pkt.data[tci_off] & RTE_MACSEC_TCI_SC) {
266 [ # # ]: 0 : sess_conf->macsec.sci = rte_be_to_cpu_64(*(const uint64_t *)
267 : : (&td->secure_pkt.data[tci_off + 6]));
268 [ # # ]: 0 : } else if (td->secure_pkt.data[tci_off] & RTE_MACSEC_TCI_ES) {
269 : : /* sci = source_mac + port_id when ES.bit = 1 & SC.bit = 0 */
270 : 0 : const uint8_t *smac = td->plain_pkt.data + RTE_ETHER_ADDR_LEN;
271 : 0 : uint8_t *ptr = (uint8_t *)&sess_conf->macsec.sci;
272 : : uint8_t j;
273 : :
274 : 0 : ptr[0] = 0x01;
275 : 0 : ptr[1] = 0;
276 [ # # ]: 0 : for (j = 0; j < RTE_ETHER_ADDR_LEN; j++)
277 : 0 : ptr[2 + j] = smac[RTE_ETHER_ADDR_LEN - 1 - j];
278 : : }
279 : 0 : sess_conf->macsec.sc_id = sc_id;
280 [ # # ]: 0 : if (dir == RTE_SECURITY_MACSEC_DIR_TX) {
281 : 0 : sess_conf->macsec.tx_secy.mtu = opts->mtu;
282 [ # # ]: 0 : sess_conf->macsec.tx_secy.sectag_off = (opts->sectag_insert_mode == 1) ?
283 : : 2 * RTE_ETHER_ADDR_LEN :
284 : : RTE_VLAN_HLEN;
285 : 0 : sess_conf->macsec.tx_secy.sectag_insert_mode = opts->sectag_insert_mode;
286 : 0 : sess_conf->macsec.tx_secy.ctrl_port_enable = 1;
287 : 0 : sess_conf->macsec.tx_secy.sectag_version = 0;
288 : 0 : sess_conf->macsec.tx_secy.end_station =
289 : 0 : (td->secure_pkt.data[tci_off] & RTE_MACSEC_TCI_ES) >> 6;
290 : 0 : sess_conf->macsec.tx_secy.send_sci =
291 : 0 : (td->secure_pkt.data[tci_off] & RTE_MACSEC_TCI_SC) >> 5;
292 : 0 : sess_conf->macsec.tx_secy.scb =
293 : 0 : (td->secure_pkt.data[tci_off] & RTE_MACSEC_TCI_SCB) >> 4;
294 : 0 : sess_conf->macsec.tx_secy.encrypt = opts->encrypt;
295 : 0 : sess_conf->macsec.tx_secy.protect_frames = opts->protect_frames;
296 : 0 : sess_conf->macsec.tx_secy.icv_include_da_sa = 1;
297 : : } else {
298 : 0 : sess_conf->macsec.rx_secy.replay_win_sz = opts->replay_win_sz;
299 : 0 : sess_conf->macsec.rx_secy.replay_protect = opts->replay_protect;
300 : 0 : sess_conf->macsec.rx_secy.icv_include_da_sa = 1;
301 : 0 : sess_conf->macsec.rx_secy.ctrl_port_enable = 1;
302 : 0 : sess_conf->macsec.rx_secy.preserve_sectag = 0;
303 : 0 : sess_conf->macsec.rx_secy.preserve_icv = 0;
304 : 0 : sess_conf->macsec.rx_secy.validate_frames = opts->val_frames;
305 : : }
306 : :
307 : 0 : return 0;
308 : : }
309 : :
310 : : static int
311 : 0 : create_default_flow(const struct mcs_test_vector *td, uint16_t portid,
312 : : enum rte_security_macsec_direction dir, void *sess)
313 : : {
314 : : struct rte_flow_action action[2];
315 : : struct rte_flow_item pattern[2];
316 : 0 : struct rte_flow_attr attr = {0};
317 : : struct rte_flow_error err;
318 : : struct rte_flow *flow;
319 : 0 : struct rte_flow_item_eth eth = { .hdr.ether_type = 0, };
320 : : static const struct rte_flow_item_eth eth_mask = {
321 : : .hdr.dst_addr.addr_bytes = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
322 : : .hdr.src_addr.addr_bytes = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
323 : : .hdr.ether_type = RTE_BE16(0x0000),
324 : : };
325 : :
326 : : int ret;
327 : :
328 : : eth.has_vlan = 0;
329 [ # # ]: 0 : if (dir == RTE_SECURITY_MACSEC_DIR_TX)
330 : 0 : memcpy(ð.hdr, td->plain_pkt.data, RTE_ETHER_HDR_LEN);
331 : : else
332 : 0 : memcpy(ð.hdr, td->secure_pkt.data, RTE_ETHER_HDR_LEN);
333 : :
334 : 0 : pattern[0].type = RTE_FLOW_ITEM_TYPE_ETH;
335 : 0 : pattern[0].spec = ð
336 : 0 : pattern[0].mask = ð_mask;
337 : 0 : pattern[0].last = NULL;
338 : 0 : pattern[1].type = RTE_FLOW_ITEM_TYPE_END;
339 : :
340 : 0 : action[0].type = RTE_FLOW_ACTION_TYPE_SECURITY;
341 : 0 : action[0].conf = sess;
342 : 0 : action[1].type = RTE_FLOW_ACTION_TYPE_END;
343 : 0 : action[1].conf = NULL;
344 : :
345 : 0 : attr.ingress = (dir == RTE_SECURITY_MACSEC_DIR_RX) ? 1 : 0;
346 : 0 : attr.egress = (dir == RTE_SECURITY_MACSEC_DIR_TX) ? 1 : 0;
347 : :
348 : 0 : ret = rte_flow_validate(portid, &attr, pattern, action, &err);
349 [ # # ]: 0 : if (ret) {
350 : : printf("\nValidate flow failed, ret = %d\n", ret);
351 : 0 : return -1;
352 : : }
353 : 0 : flow = rte_flow_create(portid, &attr, pattern, action, &err);
354 [ # # ]: 0 : if (flow == NULL) {
355 : : printf("\nDefault flow rule create failed\n");
356 : 0 : return -1;
357 : : }
358 : :
359 [ # # ]: 0 : if (dir == RTE_SECURITY_MACSEC_DIR_TX)
360 : 0 : default_tx_flow[portid] = flow;
361 : : else
362 : 0 : default_rx_flow[portid] = flow;
363 : :
364 : : return 0;
365 : : }
366 : :
367 : : static void
368 : 0 : destroy_default_flow(uint16_t portid)
369 : : {
370 : : struct rte_flow_error err;
371 : : int ret;
372 : :
373 [ # # ]: 0 : if (default_tx_flow[portid]) {
374 : 0 : ret = rte_flow_destroy(portid, default_tx_flow[portid], &err);
375 [ # # ]: 0 : if (ret) {
376 : : printf("\nDefault Tx flow rule destroy failed\n");
377 : 0 : return;
378 : : }
379 : 0 : default_tx_flow[portid] = NULL;
380 : : }
381 [ # # ]: 0 : if (default_rx_flow[portid]) {
382 : 0 : ret = rte_flow_destroy(portid, default_rx_flow[portid], &err);
383 [ # # ]: 0 : if (ret) {
384 : : printf("\nDefault Rx flow rule destroy failed\n");
385 : 0 : return;
386 : : }
387 : 0 : default_rx_flow[portid] = NULL;
388 : : }
389 : : }
390 : :
391 : : static void
392 : 0 : print_ethaddr(const char *name, const struct rte_ether_addr *eth_addr)
393 : : {
394 : : char buf[RTE_ETHER_ADDR_FMT_SIZE];
395 : 0 : rte_ether_format_addr(buf, RTE_ETHER_ADDR_FMT_SIZE, eth_addr);
396 : : printf("%s%s", name, buf);
397 : 0 : }
398 : :
399 : : /* Check the link status of all ports in up to 3s, and print them finally */
400 : : static void
401 : 0 : check_all_ports_link_status(uint16_t port_num, uint32_t port_mask)
402 : : {
403 : : #define CHECK_INTERVAL 100 /* 100ms */
404 : : #define MAX_CHECK_TIME 30 /* 3s (30 * 100ms) in total */
405 : : uint16_t portid;
406 : : uint8_t count, all_ports_up, print_flag = 0;
407 : : struct rte_eth_link link;
408 : : int ret;
409 : : char link_status[RTE_ETH_LINK_MAX_STR_LEN];
410 : :
411 : : printf("Checking link statuses...\n");
412 : 0 : fflush(stdout);
413 [ # # ]: 0 : for (count = 0; count <= MAX_CHECK_TIME; count++) {
414 : : all_ports_up = 1;
415 [ # # ]: 0 : for (portid = 0; portid < port_num; portid++) {
416 [ # # ]: 0 : if ((port_mask & (1 << portid)) == 0)
417 : 0 : continue;
418 : : memset(&link, 0, sizeof(link));
419 : 0 : ret = rte_eth_link_get_nowait(portid, &link);
420 [ # # ]: 0 : if (ret < 0) {
421 : : all_ports_up = 0;
422 [ # # ]: 0 : if (print_flag == 1)
423 : 0 : printf("Port %u link get failed: %s\n",
424 : : portid, rte_strerror(-ret));
425 : 0 : continue;
426 : : }
427 : :
428 : : /* print link status if flag set */
429 [ # # ]: 0 : if (print_flag == 1) {
430 [ # # # # ]: 0 : if (link.link_status && link_mbps == 0)
431 : 0 : link_mbps = link.link_speed;
432 : :
433 : 0 : rte_eth_link_to_str(link_status,
434 : : sizeof(link_status), &link);
435 : : printf("Port %d %s\n", portid, link_status);
436 : 0 : continue;
437 : : }
438 : : /* clear all_ports_up flag if any link down */
439 [ # # ]: 0 : if (link.link_status == RTE_ETH_LINK_DOWN) {
440 : : all_ports_up = 0;
441 : : break;
442 : : }
443 : : }
444 : : /* after finally printing all link status, get out */
445 [ # # ]: 0 : if (print_flag == 1)
446 : : break;
447 : :
448 [ # # ]: 0 : if (all_ports_up == 0)
449 : 0 : fflush(stdout);
450 : :
451 : : /* set the print_flag if all ports up or timeout */
452 [ # # ]: 0 : if (all_ports_up == 1 || count == (MAX_CHECK_TIME - 1))
453 : : print_flag = 1;
454 : : }
455 : 0 : }
456 : :
457 : : static int
458 : 0 : test_macsec_post_process(struct rte_mbuf *m, const struct mcs_test_vector *td,
459 : : enum mcs_op op, uint8_t check_out_pkts_untagged)
460 : : {
461 : : const uint8_t *dptr;
462 : : uint16_t pkt_len;
463 : :
464 : 0 : if (op == MCS_DECAP || op == MCS_ENCAP_DECAP ||
465 [ # # ]: 0 : op == MCS_VERIFY_ONLY || op == MCS_AUTH_VERIFY ||
466 [ # # ]: 0 : check_out_pkts_untagged == 1) {
467 : 0 : dptr = td->plain_pkt.data;
468 : 0 : pkt_len = td->plain_pkt.len;
469 : : } else {
470 : 0 : dptr = td->secure_pkt.data;
471 : 0 : pkt_len = td->secure_pkt.len;
472 : : }
473 : :
474 [ # # ]: 0 : if (memcmp(rte_pktmbuf_mtod(m, uint8_t *), dptr, pkt_len)) {
475 : : printf("\nData comparison failed for td.");
476 : 0 : rte_pktmbuf_dump(stdout, m, m->pkt_len);
477 : 0 : rte_hexdump(stdout, "expected_data", dptr, pkt_len);
478 : 0 : return TEST_FAILED;
479 : : }
480 : :
481 : : return TEST_SUCCESS;
482 : : }
483 : :
484 : : static void
485 : 0 : mcs_stats_dump(void *ctx, enum mcs_op op,
486 : : void *rx_sess, void *tx_sess,
487 : : uint8_t rx_sc_id, uint8_t tx_sc_id,
488 : : uint16_t rx_sa_id[], uint16_t tx_sa_id[])
489 : : {
490 : 0 : struct rte_security_stats sess_stats = {0};
491 : : struct rte_security_macsec_secy_stats *secy_stat;
492 : 0 : struct rte_security_macsec_sc_stats sc_stat = {0};
493 : 0 : struct rte_security_macsec_sa_stats sa_stat = {0};
494 : : int i;
495 : :
496 : 0 : if (op == MCS_DECAP || op == MCS_ENCAP_DECAP ||
497 [ # # # # ]: 0 : op == MCS_VERIFY_ONLY || op == MCS_AUTH_VERIFY) {
498 : : printf("\n********* RX SECY STATS ************\n");
499 : 0 : rte_security_session_stats_get(ctx, rx_sess, &sess_stats);
500 : : secy_stat = &sess_stats.macsec;
501 : :
502 [ # # ]: 0 : if (secy_stat->ctl_pkt_bcast_cnt)
503 : : printf("RX: ctl_pkt_bcast_cnt: 0x%" PRIx64 "\n",
504 : : secy_stat->ctl_pkt_bcast_cnt);
505 [ # # ]: 0 : if (secy_stat->ctl_pkt_mcast_cnt)
506 : : printf("RX: ctl_pkt_mcast_cnt: 0x%" PRIx64 "\n",
507 : : secy_stat->ctl_pkt_mcast_cnt);
508 [ # # ]: 0 : if (secy_stat->ctl_pkt_ucast_cnt)
509 : : printf("RX: ctl_pkt_ucast_cnt: 0x%" PRIx64 "\n",
510 : : secy_stat->ctl_pkt_ucast_cnt);
511 [ # # ]: 0 : if (secy_stat->ctl_octet_cnt)
512 : : printf("RX: ctl_octet_cnt: 0x%" PRIx64 "\n", secy_stat->ctl_octet_cnt);
513 [ # # ]: 0 : if (secy_stat->unctl_pkt_bcast_cnt)
514 : : printf("RX: unctl_pkt_bcast_cnt: 0x%" PRIx64 "\n",
515 : : secy_stat->unctl_pkt_bcast_cnt);
516 [ # # ]: 0 : if (secy_stat->unctl_pkt_mcast_cnt)
517 : : printf("RX: unctl_pkt_mcast_cnt: 0x%" PRIx64 "\n",
518 : : secy_stat->unctl_pkt_mcast_cnt);
519 [ # # ]: 0 : if (secy_stat->unctl_pkt_ucast_cnt)
520 : : printf("RX: unctl_pkt_ucast_cnt: 0x%" PRIx64 "\n",
521 : : secy_stat->unctl_pkt_ucast_cnt);
522 [ # # ]: 0 : if (secy_stat->unctl_octet_cnt)
523 : : printf("RX: unctl_octet_cnt: 0x%" PRIx64 "\n", secy_stat->unctl_octet_cnt);
524 : : /* Valid only for RX */
525 [ # # ]: 0 : if (secy_stat->octet_decrypted_cnt)
526 : : printf("RX: octet_decrypted_cnt: 0x%" PRIx64 "\n",
527 : : secy_stat->octet_decrypted_cnt);
528 [ # # ]: 0 : if (secy_stat->octet_validated_cnt)
529 : : printf("RX: octet_validated_cnt: 0x%" PRIx64 "\n",
530 : : secy_stat->octet_validated_cnt);
531 [ # # ]: 0 : if (secy_stat->pkt_port_disabled_cnt)
532 : : printf("RX: pkt_port_disabled_cnt: 0x%" PRIx64 "\n",
533 : : secy_stat->pkt_port_disabled_cnt);
534 [ # # ]: 0 : if (secy_stat->pkt_badtag_cnt)
535 : : printf("RX: pkt_badtag_cnt: 0x%" PRIx64 "\n", secy_stat->pkt_badtag_cnt);
536 [ # # ]: 0 : if (secy_stat->pkt_nosa_cnt)
537 : : printf("RX: pkt_nosa_cnt: 0x%" PRIx64 "\n", secy_stat->pkt_nosa_cnt);
538 [ # # ]: 0 : if (secy_stat->pkt_nosaerror_cnt)
539 : : printf("RX: pkt_nosaerror_cnt: 0x%" PRIx64 "\n",
540 : : secy_stat->pkt_nosaerror_cnt);
541 [ # # ]: 0 : if (secy_stat->pkt_tagged_ctl_cnt)
542 : : printf("RX: pkt_tagged_ctl_cnt: 0x%" PRIx64 "\n",
543 : : secy_stat->pkt_tagged_ctl_cnt);
544 [ # # ]: 0 : if (secy_stat->pkt_untaged_cnt)
545 : : printf("RX: pkt_untaged_cnt: 0x%" PRIx64 "\n", secy_stat->pkt_untaged_cnt);
546 [ # # ]: 0 : if (secy_stat->pkt_ctl_cnt)
547 : : printf("RX: pkt_ctl_cnt: 0x%" PRIx64 "\n", secy_stat->pkt_ctl_cnt);
548 [ # # ]: 0 : if (secy_stat->pkt_notag_cnt)
549 : : printf("RX: pkt_notag_cnt: 0x%" PRIx64 "\n", secy_stat->pkt_notag_cnt);
550 : : printf("\n");
551 : 0 : printf("\n********** RX SC[%u] STATS **************\n", rx_sc_id);
552 : :
553 : 0 : rte_security_macsec_sc_stats_get(ctx, rx_sc_id, RTE_SECURITY_MACSEC_DIR_RX,
554 : : &sc_stat);
555 : : /* RX */
556 [ # # ]: 0 : if (sc_stat.hit_cnt)
557 : : printf("RX hit_cnt: 0x%" PRIx64 "\n", sc_stat.hit_cnt);
558 [ # # ]: 0 : if (sc_stat.pkt_invalid_cnt)
559 : : printf("RX pkt_invalid_cnt: 0x%" PRIx64 "\n", sc_stat.pkt_invalid_cnt);
560 [ # # ]: 0 : if (sc_stat.pkt_late_cnt)
561 : : printf("RX pkt_late_cnt: 0x%" PRIx64 "\n", sc_stat.pkt_late_cnt);
562 [ # # ]: 0 : if (sc_stat.pkt_notvalid_cnt)
563 : : printf("RX pkt_notvalid_cnt: 0x%" PRIx64 "\n", sc_stat.pkt_notvalid_cnt);
564 [ # # ]: 0 : if (sc_stat.pkt_unchecked_cnt)
565 : : printf("RX pkt_unchecked_cnt: 0x%" PRIx64 "\n", sc_stat.pkt_unchecked_cnt);
566 [ # # ]: 0 : if (sc_stat.pkt_delay_cnt)
567 : : printf("RX pkt_delay_cnt: 0x%" PRIx64 "\n", sc_stat.pkt_delay_cnt);
568 [ # # ]: 0 : if (sc_stat.pkt_ok_cnt)
569 : : printf("RX pkt_ok_cnt: 0x%" PRIx64 "\n", sc_stat.pkt_ok_cnt);
570 [ # # ]: 0 : if (sc_stat.octet_decrypt_cnt)
571 : : printf("RX octet_decrypt_cnt: 0x%" PRIx64 "\n", sc_stat.octet_decrypt_cnt);
572 [ # # ]: 0 : if (sc_stat.octet_validate_cnt)
573 : : printf("RX octet_validate_cnt: 0x%" PRIx64 "\n",
574 : : sc_stat.octet_validate_cnt);
575 : : printf("\n");
576 [ # # ]: 0 : for (i = 0; i < RTE_SECURITY_MACSEC_NUM_AN; i++) {
577 : 0 : printf("\n********** RX SA[%u] STATS ****************\n", rx_sa_id[i]);
578 : : memset(&sa_stat, 0, sizeof(struct rte_security_macsec_sa_stats));
579 : 0 : rte_security_macsec_sa_stats_get(ctx, rx_sa_id[i],
580 : : RTE_SECURITY_MACSEC_DIR_RX, &sa_stat);
581 : :
582 : : /* RX */
583 [ # # ]: 0 : if (sa_stat.pkt_invalid_cnt)
584 : : printf("RX pkt_invalid_cnt: 0x%" PRIx64 "\n",
585 : : sa_stat.pkt_invalid_cnt);
586 [ # # ]: 0 : if (sa_stat.pkt_nosaerror_cnt)
587 : : printf("RX pkt_nosaerror_cnt: 0x%" PRIx64 "\n",
588 : : sa_stat.pkt_nosaerror_cnt);
589 [ # # ]: 0 : if (sa_stat.pkt_notvalid_cnt)
590 : : printf("RX pkt_notvalid_cnt: 0x%" PRIx64 "\n",
591 : : sa_stat.pkt_notvalid_cnt);
592 [ # # ]: 0 : if (sa_stat.pkt_ok_cnt)
593 : : printf("RX pkt_ok_cnt: 0x%" PRIx64 "\n", sa_stat.pkt_ok_cnt);
594 [ # # ]: 0 : if (sa_stat.pkt_nosa_cnt)
595 : : printf("RX pkt_nosa_cnt: 0x%" PRIx64 "\n", sa_stat.pkt_nosa_cnt);
596 : : printf("\n");
597 : : }
598 : : }
599 : :
600 [ # # ]: 0 : if (op == MCS_ENCAP || op == MCS_ENCAP_DECAP ||
601 [ # # ]: 0 : op == MCS_AUTH_ONLY || op == MCS_AUTH_VERIFY) {
602 : : memset(&sess_stats, 0, sizeof(struct rte_security_stats));
603 : 0 : rte_security_session_stats_get(ctx, tx_sess, &sess_stats);
604 : : secy_stat = &sess_stats.macsec;
605 : :
606 : : printf("\n********* TX SECY STATS ************\n");
607 [ # # ]: 0 : if (secy_stat->ctl_pkt_bcast_cnt)
608 : : printf("TX: ctl_pkt_bcast_cnt: 0x%" PRIx64 "\n",
609 : : secy_stat->ctl_pkt_bcast_cnt);
610 [ # # ]: 0 : if (secy_stat->ctl_pkt_mcast_cnt)
611 : : printf("TX: ctl_pkt_mcast_cnt: 0x%" PRIx64 "\n",
612 : : secy_stat->ctl_pkt_mcast_cnt);
613 [ # # ]: 0 : if (secy_stat->ctl_pkt_ucast_cnt)
614 : : printf("TX: ctl_pkt_ucast_cnt: 0x%" PRIx64 "\n",
615 : : secy_stat->ctl_pkt_ucast_cnt);
616 [ # # ]: 0 : if (secy_stat->ctl_octet_cnt)
617 : : printf("TX: ctl_octet_cnt: 0x%" PRIx64 "\n", secy_stat->ctl_octet_cnt);
618 [ # # ]: 0 : if (secy_stat->unctl_pkt_bcast_cnt)
619 : : printf("TX: unctl_pkt_bcast_cnt: 0x%" PRIx64 "\n",
620 : : secy_stat->unctl_pkt_bcast_cnt);
621 [ # # ]: 0 : if (secy_stat->unctl_pkt_mcast_cnt)
622 : : printf("TX: unctl_pkt_mcast_cnt: 0x%" PRIx64 "\n",
623 : : secy_stat->unctl_pkt_mcast_cnt);
624 [ # # ]: 0 : if (secy_stat->unctl_pkt_ucast_cnt)
625 : : printf("TX: unctl_pkt_ucast_cnt: 0x%" PRIx64 "\n",
626 : : secy_stat->unctl_pkt_ucast_cnt);
627 [ # # ]: 0 : if (secy_stat->unctl_octet_cnt)
628 : : printf("TX: unctl_octet_cnt: 0x%" PRIx64 "\n",
629 : : secy_stat->unctl_octet_cnt);
630 : : /* Valid only for TX */
631 [ # # ]: 0 : if (secy_stat->octet_encrypted_cnt)
632 : : printf("TX: octet_encrypted_cnt: 0x%" PRIx64 "\n",
633 : : secy_stat->octet_encrypted_cnt);
634 [ # # ]: 0 : if (secy_stat->octet_protected_cnt)
635 : : printf("TX: octet_protected_cnt: 0x%" PRIx64 "\n",
636 : : secy_stat->octet_protected_cnt);
637 [ # # ]: 0 : if (secy_stat->pkt_noactivesa_cnt)
638 : : printf("TX: pkt_noactivesa_cnt: 0x%" PRIx64 "\n",
639 : : secy_stat->pkt_noactivesa_cnt);
640 [ # # ]: 0 : if (secy_stat->pkt_toolong_cnt)
641 : : printf("TX: pkt_toolong_cnt: 0x%" PRIx64 "\n", secy_stat->pkt_toolong_cnt);
642 [ # # ]: 0 : if (secy_stat->pkt_untagged_cnt)
643 : : printf("TX: pkt_untagged_cnt: 0x%" PRIx64 "\n",
644 : : secy_stat->pkt_untagged_cnt);
645 : :
646 : :
647 : : memset(&sc_stat, 0, sizeof(struct rte_security_macsec_sc_stats));
648 : 0 : rte_security_macsec_sc_stats_get(ctx, tx_sc_id, RTE_SECURITY_MACSEC_DIR_TX,
649 : : &sc_stat);
650 : : printf("\n********** TX SC[%u] STATS **************\n", tx_sc_id);
651 [ # # ]: 0 : if (sc_stat.pkt_encrypt_cnt)
652 : : printf("TX pkt_encrypt_cnt: 0x%" PRIx64 "\n", sc_stat.pkt_encrypt_cnt);
653 [ # # ]: 0 : if (sc_stat.pkt_protected_cnt)
654 : : printf("TX pkt_protected_cnt: 0x%" PRIx64 "\n", sc_stat.pkt_protected_cnt);
655 [ # # ]: 0 : if (sc_stat.octet_encrypt_cnt)
656 : : printf("TX octet_encrypt_cnt: 0x%" PRIx64 "\n", sc_stat.octet_encrypt_cnt);
657 : :
658 : : memset(&sa_stat, 0, sizeof(struct rte_security_macsec_sa_stats));
659 : 0 : rte_security_macsec_sa_stats_get(ctx, tx_sa_id[0],
660 : : RTE_SECURITY_MACSEC_DIR_TX, &sa_stat);
661 : 0 : printf("\n********** TX SA[%u] STATS ****************\n", tx_sa_id[0]);
662 [ # # ]: 0 : if (sa_stat.pkt_encrypt_cnt)
663 : : printf("TX pkt_encrypt_cnt: 0x%" PRIx64 "\n", sa_stat.pkt_encrypt_cnt);
664 [ # # ]: 0 : if (sa_stat.pkt_protected_cnt)
665 : : printf("TX pkt_protected_cnt: 0x%" PRIx64 "\n", sa_stat.pkt_protected_cnt);
666 : : }
667 : 0 : }
668 : :
669 : : static int
670 : 0 : mcs_stats_check(void *ctx, enum mcs_op op,
671 : : const struct mcs_test_opts *opts,
672 : : const struct mcs_test_vector *td,
673 : : void *rx_sess, void *tx_sess,
674 : : uint8_t rx_sc_id, uint8_t tx_sc_id,
675 : : uint16_t rx_sa_id[], uint16_t tx_sa_id[])
676 : : {
677 : 0 : struct rte_security_stats sess_stats = {0};
678 : : struct rte_security_macsec_secy_stats *secy_stat;
679 : 0 : struct rte_security_macsec_sc_stats sc_stat = {0};
680 : 0 : struct rte_security_macsec_sa_stats sa_stat = {0};
681 : : int i;
682 : :
683 : 0 : if (op == MCS_DECAP || op == MCS_ENCAP_DECAP ||
684 [ # # # # ]: 0 : op == MCS_VERIFY_ONLY || op == MCS_AUTH_VERIFY) {
685 : 0 : rte_security_session_stats_get(ctx, rx_sess, &sess_stats);
686 : : secy_stat = &sess_stats.macsec;
687 : :
688 [ # # # # ]: 0 : if ((opts->check_untagged_rx && secy_stat->pkt_notag_cnt != 1) ||
689 [ # # ]: 0 : (opts->check_untagged_rx && secy_stat->pkt_untaged_cnt != 1))
690 : : return TEST_FAILED;
691 : :
692 [ # # # # ]: 0 : if (opts->check_bad_tag_cnt && secy_stat->pkt_badtag_cnt != 1)
693 : : return TEST_FAILED;
694 : :
695 [ # # # # ]: 0 : if (opts->check_sa_not_in_use && secy_stat->pkt_nosaerror_cnt != 1)
696 : : return TEST_FAILED;
697 : :
698 [ # # ]: 0 : if (opts->check_decap_stats && secy_stat->octet_decrypted_cnt !=
699 [ # # ]: 0 : (uint16_t)(td->plain_pkt.len - 2 * RTE_ETHER_ADDR_LEN))
700 : : return TEST_FAILED;
701 : :
702 [ # # ]: 0 : if (opts->check_verify_only_stats && secy_stat->octet_validated_cnt !=
703 [ # # ]: 0 : (uint16_t)(td->plain_pkt.len - 2 * RTE_ETHER_ADDR_LEN))
704 : : return TEST_FAILED;
705 : :
706 : 0 : rte_security_macsec_sc_stats_get(ctx, rx_sc_id,
707 : : RTE_SECURITY_MACSEC_DIR_RX, &sc_stat);
708 : :
709 [ # # ]: 0 : if ((opts->check_decap_stats || opts->check_verify_only_stats) &&
710 [ # # ]: 0 : sc_stat.pkt_ok_cnt != 1)
711 : : return TEST_FAILED;
712 : :
713 [ # # # # ]: 0 : if (opts->check_pkts_invalid_stats && sc_stat.pkt_notvalid_cnt != 1)
714 : : return TEST_FAILED;
715 : :
716 [ # # # # ]: 0 : if (opts->check_pkts_unchecked_stats && sc_stat.pkt_unchecked_cnt != 1)
717 : : return TEST_FAILED;
718 : :
719 [ # # ]: 0 : if (opts->replay_protect) {
720 [ # # ]: 0 : if (opts->replay_win_sz == 0 &&
721 [ # # ]: 0 : sc_stat.pkt_late_cnt != 2)
722 : : return TEST_FAILED;
723 [ # # ]: 0 : else if (opts->replay_win_sz == 32 &&
724 [ # # ]: 0 : sc_stat.pkt_late_cnt != 1)
725 : : return TEST_FAILED;
726 : : }
727 : :
728 [ # # ]: 0 : for (i = 0; i < RTE_SECURITY_MACSEC_NUM_AN; i++) {
729 : : memset(&sa_stat, 0, sizeof(struct rte_security_macsec_sa_stats));
730 : 0 : rte_security_macsec_sa_stats_get(ctx, rx_sa_id[i],
731 : : RTE_SECURITY_MACSEC_DIR_RX, &sa_stat);
732 : :
733 : : }
734 : : }
735 : :
736 [ # # ]: 0 : if (op == MCS_ENCAP || op == MCS_ENCAP_DECAP ||
737 [ # # ]: 0 : op == MCS_AUTH_ONLY || op == MCS_AUTH_VERIFY) {
738 : : memset(&sess_stats, 0, sizeof(struct rte_security_stats));
739 : 0 : rte_security_session_stats_get(ctx, tx_sess, &sess_stats);
740 : : secy_stat = &sess_stats.macsec;
741 : :
742 [ # # # # ]: 0 : if (opts->check_out_pkts_untagged && secy_stat->pkt_untagged_cnt != 1)
743 : : return TEST_FAILED;
744 : :
745 [ # # # # ]: 0 : if (opts->check_out_pkts_toolong && secy_stat->pkt_toolong_cnt != 1)
746 : : return TEST_FAILED;
747 : :
748 [ # # ]: 0 : if (opts->check_encap_stats && secy_stat->octet_encrypted_cnt !=
749 [ # # ]: 0 : (uint16_t)(td->plain_pkt.len - 2 * RTE_ETHER_ADDR_LEN))
750 : : return TEST_FAILED;
751 : :
752 [ # # ]: 0 : if (opts->check_auth_only_stats && secy_stat->octet_protected_cnt !=
753 [ # # ]: 0 : (uint16_t)(td->plain_pkt.len - 2 * RTE_ETHER_ADDR_LEN))
754 : : return TEST_FAILED;
755 : :
756 : :
757 : : memset(&sc_stat, 0, sizeof(struct rte_security_macsec_sc_stats));
758 : 0 : rte_security_macsec_sc_stats_get(ctx, tx_sc_id, RTE_SECURITY_MACSEC_DIR_TX,
759 : : &sc_stat);
760 : :
761 [ # # # # ]: 0 : if (opts->check_encap_stats && sc_stat.pkt_encrypt_cnt != 1)
762 : : return TEST_FAILED;
763 : :
764 [ # # # # ]: 0 : if (opts->check_auth_only_stats && sc_stat.pkt_protected_cnt != 1)
765 : : return TEST_FAILED;
766 : :
767 : : memset(&sa_stat, 0, sizeof(struct rte_security_macsec_sa_stats));
768 : 0 : rte_security_macsec_sa_stats_get(ctx, tx_sa_id[0],
769 : : RTE_SECURITY_MACSEC_DIR_TX, &sa_stat);
770 : : }
771 : :
772 : : return 0;
773 : : }
774 : :
775 : : static int
776 : 0 : test_macsec_event_callback(uint16_t port_id, enum rte_eth_event_type type,
777 : : void *param, void *ret_param)
778 : : {
779 : : struct mcs_err_vector *vector = (struct mcs_err_vector *)param;
780 : : struct rte_eth_event_macsec_desc *event_desc = NULL;
781 : :
782 : : RTE_SET_USED(port_id);
783 : :
784 [ # # ]: 0 : if (type != RTE_ETH_EVENT_MACSEC)
785 : : return -1;
786 : :
787 : : event_desc = ret_param;
788 [ # # ]: 0 : if (event_desc == NULL) {
789 : : printf("Event descriptor not set\n");
790 : 0 : return -1;
791 : : }
792 : 0 : vector->notify_event = true;
793 : :
794 [ # # # # : 0 : switch (event_desc->type) {
# # # ]
795 : 0 : case RTE_ETH_EVENT_MACSEC_SECTAG_VAL_ERR:
796 : 0 : vector->event = RTE_ETH_EVENT_MACSEC_SECTAG_VAL_ERR;
797 [ # # # # : 0 : switch (event_desc->subtype) {
# # ]
798 : 0 : case RTE_ETH_SUBEVENT_MACSEC_RX_SECTAG_V_EQ1:
799 : 0 : vector->event_subtype = RTE_ETH_SUBEVENT_MACSEC_RX_SECTAG_V_EQ1;
800 : 0 : break;
801 : 0 : case RTE_ETH_SUBEVENT_MACSEC_RX_SECTAG_E_EQ0_C_EQ1:
802 : 0 : vector->event_subtype = RTE_ETH_SUBEVENT_MACSEC_RX_SECTAG_E_EQ0_C_EQ1;
803 : 0 : break;
804 : 0 : case RTE_ETH_SUBEVENT_MACSEC_RX_SECTAG_SL_GTE48:
805 : 0 : vector->event_subtype = RTE_ETH_SUBEVENT_MACSEC_RX_SECTAG_SL_GTE48;
806 : 0 : break;
807 : 0 : case RTE_ETH_SUBEVENT_MACSEC_RX_SECTAG_ES_EQ1_SC_EQ1:
808 : 0 : vector->event_subtype = RTE_ETH_SUBEVENT_MACSEC_RX_SECTAG_ES_EQ1_SC_EQ1;
809 : 0 : break;
810 : 0 : case RTE_ETH_SUBEVENT_MACSEC_RX_SECTAG_SC_EQ1_SCB_EQ1:
811 : 0 : vector->event_subtype = RTE_ETH_SUBEVENT_MACSEC_RX_SECTAG_SC_EQ1_SCB_EQ1;
812 : 0 : break;
813 : 0 : default:
814 : : printf("\nUnknown Macsec event subtype: %d", event_desc->subtype);
815 : : }
816 : : break;
817 : 0 : case RTE_ETH_EVENT_MACSEC_RX_SA_PN_HARD_EXP:
818 : 0 : vector->event = RTE_ETH_EVENT_MACSEC_RX_SA_PN_HARD_EXP;
819 : 0 : break;
820 : 0 : case RTE_ETH_EVENT_MACSEC_RX_SA_PN_SOFT_EXP:
821 : 0 : vector->event = RTE_ETH_EVENT_MACSEC_RX_SA_PN_SOFT_EXP;
822 : 0 : break;
823 : 0 : case RTE_ETH_EVENT_MACSEC_TX_SA_PN_HARD_EXP:
824 : 0 : vector->event = RTE_ETH_EVENT_MACSEC_TX_SA_PN_HARD_EXP;
825 : 0 : break;
826 : 0 : case RTE_ETH_EVENT_MACSEC_TX_SA_PN_SOFT_EXP:
827 : 0 : vector->event = RTE_ETH_EVENT_MACSEC_TX_SA_PN_SOFT_EXP;
828 : 0 : break;
829 : 0 : case RTE_ETH_EVENT_MACSEC_SA_NOT_VALID:
830 : 0 : vector->event = RTE_ETH_EVENT_MACSEC_SA_NOT_VALID;
831 : 0 : break;
832 : : default:
833 : : printf("Invalid MACsec event reported\n");
834 : 0 : return -1;
835 : : }
836 : :
837 : : return 0;
838 : : }
839 : :
840 : : static int
841 : 0 : test_macsec_sec_caps_verify(const struct mcs_test_opts *opts,
842 : : const struct rte_security_capability *sec_cap, bool silent)
843 : : {
844 [ # # ]: 0 : if (opts->mtu > sec_cap->macsec.mtu) {
845 [ # # ]: 0 : if (!silent)
846 : 0 : RTE_LOG(INFO, USER1, "MTU size is not supported\n");
847 : 0 : return -ENOTSUP;
848 : : }
849 : :
850 [ # # # # ]: 0 : if (opts->replay_protect == 1 && sec_cap->macsec.anti_replay == 0) {
851 [ # # ]: 0 : if (!silent)
852 : 0 : RTE_LOG(INFO, USER1, "Anti replay is not supported\n");
853 : 0 : return -ENOTSUP;
854 : : }
855 : :
856 [ # # ]: 0 : if (opts->replay_win_sz > sec_cap->macsec.replay_win_sz) {
857 [ # # ]: 0 : if (!silent)
858 : 0 : RTE_LOG(INFO, USER1, "Replay window size is not "
859 : : "supported\n");
860 : 0 : return -ENOTSUP;
861 : : }
862 : :
863 [ # # # # ]: 0 : if (opts->rekey_en == 1 && sec_cap->macsec.re_key == 0) {
864 [ # # ]: 0 : if (!silent)
865 : 0 : RTE_LOG(INFO, USER1, "Rekey is not supported\n");
866 : 0 : return -ENOTSUP;
867 : : }
868 : :
869 [ # # ]: 0 : if (opts->sectag_insert_mode == 0 &&
870 [ # # ]: 0 : sec_cap->macsec.relative_sectag_insert == 0) {
871 [ # # ]: 0 : if (!silent)
872 : 0 : RTE_LOG(INFO, USER1, "Relative offset sectag insert "
873 : : "not supported\n");
874 : 0 : return -ENOTSUP;
875 : : }
876 : :
877 [ # # ]: 0 : if (opts->sectag_insert_mode == 1 &&
878 [ # # ]: 0 : sec_cap->macsec.fixed_sectag_insert == 0) {
879 [ # # ]: 0 : if (!silent)
880 : 0 : RTE_LOG(INFO, USER1, "Fixed offset sectag insert "
881 : : "not supported\n");
882 : 0 : return -ENOTSUP;
883 : : }
884 : :
885 : : return 0;
886 : : }
887 : :
888 : : static int
889 : 0 : test_macsec(const struct mcs_test_vector *td[], enum mcs_op op, const struct mcs_test_opts *opts)
890 : : {
891 : 0 : uint16_t rx_sa_id[MCS_MAX_FLOWS][RTE_SECURITY_MACSEC_NUM_AN] = {{0}};
892 : : struct rte_security_capability_idx sec_cap_idx;
893 : : const struct rte_security_capability *sec_cap;
894 : 0 : uint16_t tx_sa_id[MCS_MAX_FLOWS][2] = {{0}};
895 : 0 : uint16_t rx_sc_id[MCS_MAX_FLOWS] = {0};
896 : 0 : uint16_t tx_sc_id[MCS_MAX_FLOWS] = {0};
897 : 0 : void *rx_sess[MCS_MAX_FLOWS] = {0};
898 : 0 : void *tx_sess[MCS_MAX_FLOWS] = {0};
899 : 0 : struct rte_security_session_conf sess_conf = {0};
900 : 0 : struct rte_security_macsec_sa sa_conf = {0};
901 : 0 : struct rte_security_macsec_sc sc_conf = {0};
902 : 0 : struct mcs_err_vector err_vector = {0};
903 : : void *ctx;
904 : : int nb_rx = 0, nb_sent;
905 : : int i, j = 0, ret, id, an = 0;
906 : : uint8_t tci_off;
907 : : int k;
908 : :
909 : 0 : memset(rx_pkts_burst, 0, sizeof(rx_pkts_burst[0]) * opts->nb_td);
910 : :
911 : 0 : ctx = rte_eth_dev_get_sec_ctx(port_id);
912 [ # # ]: 0 : if (ctx == NULL) {
913 : : printf("Ethernet device doesn't support security features.\n");
914 : 0 : return TEST_SKIPPED;
915 : : }
916 : :
917 : 0 : sec_cap_idx.action = RTE_SECURITY_ACTION_TYPE_INLINE_PROTOCOL;
918 : 0 : sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_MACSEC;
919 : 0 : sec_cap_idx.macsec.alg = td[0]->alg;
920 : 0 : sec_cap = rte_security_capability_get(ctx, &sec_cap_idx);
921 [ # # ]: 0 : if (sec_cap == NULL) {
922 : : printf("No capabilities registered\n");
923 : 0 : return TEST_SKIPPED;
924 : : }
925 : :
926 [ # # ]: 0 : if (test_macsec_sec_caps_verify(opts, sec_cap, false) != 0)
927 : : return TEST_SKIPPED;
928 : :
929 [ # # ]: 0 : if (opts->rekey_en) {
930 : : /* Verify the rekey td */
931 : 0 : sec_cap_idx.macsec.alg = opts->rekey_td->alg;
932 : 0 : sec_cap = rte_security_capability_get(ctx, &sec_cap_idx);
933 [ # # ]: 0 : if (sec_cap == NULL) {
934 : : printf("No capabilities registered\n");
935 : 0 : return TEST_SKIPPED;
936 : : }
937 [ # # ]: 0 : if (test_macsec_sec_caps_verify(opts, sec_cap, false) != 0)
938 : : return TEST_SKIPPED;
939 : : }
940 : :
941 [ # # ]: 0 : tci_off = (opts->sectag_insert_mode == 1) ? RTE_ETHER_HDR_LEN :
942 : 0 : RTE_ETHER_HDR_LEN + (opts->nb_vlan * RTE_VLAN_HLEN);
943 : :
944 [ # # ]: 0 : for (i = 0, j = 0; i < opts->nb_td; i++) {
945 [ # # ]: 0 : if (op == MCS_DECAP || op == MCS_VERIFY_ONLY)
946 : 0 : tx_pkts_burst[j] = init_packet(mbufpool, td[i]->secure_pkt.data,
947 : 0 : td[i]->secure_pkt.len);
948 : : else {
949 : 0 : tx_pkts_burst[j] = init_packet(mbufpool, td[i]->plain_pkt.data,
950 : 0 : td[i]->plain_pkt.len);
951 : :
952 : 0 : tx_pkts_burst[j]->ol_flags |= RTE_MBUF_F_TX_MACSEC;
953 : : }
954 [ # # ]: 0 : if (tx_pkts_burst[j] == NULL) {
955 : 0 : rte_pktmbuf_free_bulk(tx_pkts_burst, j);
956 : : ret = TEST_FAILED;
957 : 0 : goto out;
958 : : }
959 : 0 : j++;
960 : :
961 [ # # ]: 0 : if (opts->replay_protect) {
962 [ # # ]: 0 : for (k = 0; k < 3; k++, j++) {
963 : 0 : tx_pkts_burst[j] = init_packet(mbufpool,
964 : 0 : opts->ar_td[k]->secure_pkt.data,
965 : 0 : opts->ar_td[k]->secure_pkt.len);
966 [ # # ]: 0 : if (tx_pkts_burst[j] == NULL) {
967 : 0 : rte_pktmbuf_free_bulk(tx_pkts_burst, j);
968 : : ret = TEST_FAILED;
969 : 0 : goto out;
970 : : }
971 : : }
972 : : }
973 : :
974 [ # # ]: 0 : if (opts->rekey_en) {
975 : :
976 : 0 : err_vector.td = td[i];
977 : 0 : err_vector.rekey_td = opts->rekey_td;
978 : 0 : err_vector.event = RTE_ETH_EVENT_MACSEC_UNKNOWN;
979 : 0 : err_vector.event_subtype = RTE_ETH_SUBEVENT_MACSEC_UNKNOWN;
980 : 0 : rte_eth_dev_callback_register(port_id, RTE_ETH_EVENT_MACSEC,
981 : : test_macsec_event_callback, &err_vector);
982 [ # # ]: 0 : if (op == MCS_DECAP || op == MCS_VERIFY_ONLY)
983 : 0 : tx_pkts_burst[j] = init_packet(mbufpool,
984 : 0 : opts->rekey_td->secure_pkt.data,
985 : 0 : opts->rekey_td->secure_pkt.len);
986 : : else {
987 : 0 : tx_pkts_burst[j] = init_packet(mbufpool,
988 : 0 : opts->rekey_td->plain_pkt.data,
989 : 0 : opts->rekey_td->plain_pkt.len);
990 : :
991 : 0 : tx_pkts_burst[j]->ol_flags |= RTE_MBUF_F_TX_MACSEC;
992 : : }
993 [ # # ]: 0 : if (tx_pkts_burst[j] == NULL) {
994 : 0 : rte_pktmbuf_free_bulk(tx_pkts_burst, j);
995 : : ret = TEST_FAILED;
996 : 0 : goto out;
997 : : }
998 : 0 : j++;
999 : : }
1000 : :
1001 [ # # ]: 0 : if (op == MCS_DECAP || op == MCS_ENCAP_DECAP ||
1002 [ # # ]: 0 : op == MCS_VERIFY_ONLY || op == MCS_AUTH_VERIFY) {
1003 [ # # ]: 0 : for (an = 0; an < RTE_SECURITY_MACSEC_NUM_AN; an++) {
1004 [ # # ]: 0 : if (opts->rekey_en && an ==
1005 [ # # ]: 0 : (opts->rekey_td->secure_pkt.data[tci_off] &
1006 : : RTE_MACSEC_AN_MASK))
1007 : : fill_macsec_sa_conf(opts->rekey_td, &sa_conf,
1008 : : RTE_SECURITY_MACSEC_DIR_RX, an, tci_off);
1009 : : else
1010 : : /* For simplicity, using same SA conf for all AN */
1011 : 0 : fill_macsec_sa_conf(td[i], &sa_conf,
1012 : : RTE_SECURITY_MACSEC_DIR_RX, an, tci_off);
1013 : 0 : id = rte_security_macsec_sa_create(ctx, &sa_conf);
1014 [ # # ]: 0 : if (id < 0) {
1015 : : printf("MACsec SA create failed : %d.\n", id);
1016 : 0 : rte_pktmbuf_free_bulk(tx_pkts_burst, j);
1017 : : ret = TEST_FAILED;
1018 : 0 : goto out;
1019 : : }
1020 : 0 : rx_sa_id[i][an] = (uint16_t)id;
1021 : : }
1022 : 0 : fill_macsec_sc_conf(td[i], &sc_conf, opts,
1023 : 0 : RTE_SECURITY_MACSEC_DIR_RX, rx_sa_id[i], tci_off);
1024 : 0 : id = rte_security_macsec_sc_create(ctx, &sc_conf);
1025 [ # # ]: 0 : if (id < 0) {
1026 : : printf("MACsec SC create failed : %d.\n", id);
1027 : 0 : rte_pktmbuf_free_bulk(tx_pkts_burst, j);
1028 : : ret = TEST_FAILED;
1029 : 0 : goto out;
1030 : : }
1031 : 0 : rx_sc_id[i] = (uint16_t)id;
1032 : :
1033 : : /* Create Inline IPsec session. */
1034 : 0 : ret = fill_session_conf(td[i], port_id, opts, &sess_conf,
1035 : : RTE_SECURITY_MACSEC_DIR_RX, rx_sc_id[i], tci_off);
1036 [ # # ]: 0 : if (ret) {
1037 : 0 : rte_pktmbuf_free_bulk(tx_pkts_burst, j);
1038 : : ret = TEST_FAILED;
1039 : 0 : goto out;
1040 : : }
1041 : 0 : rx_sess[i] = rte_security_session_create(ctx, &sess_conf,
1042 : : sess_pool);
1043 [ # # ]: 0 : if (rx_sess[i] == NULL) {
1044 : : printf("SEC Session init failed.\n");
1045 : 0 : rte_pktmbuf_free_bulk(tx_pkts_burst, j);
1046 : : ret = TEST_FAILED;
1047 : 0 : goto out;
1048 : : }
1049 : 0 : ret = create_default_flow(td[i], port_id,
1050 : : RTE_SECURITY_MACSEC_DIR_RX, rx_sess[i]);
1051 [ # # ]: 0 : if (ret) {
1052 : 0 : rte_pktmbuf_free_bulk(tx_pkts_burst, j);
1053 : : ret = TEST_FAILED;
1054 : 0 : goto out;
1055 : : }
1056 : : }
1057 [ # # ]: 0 : if (op == MCS_ENCAP || op == MCS_ENCAP_DECAP ||
1058 [ # # ]: 0 : op == MCS_AUTH_ONLY || op == MCS_AUTH_VERIFY) {
1059 : : int id;
1060 : :
1061 : 0 : fill_macsec_sa_conf(td[i], &sa_conf,
1062 : : RTE_SECURITY_MACSEC_DIR_TX,
1063 : 0 : td[i]->secure_pkt.data[tci_off] & RTE_MACSEC_AN_MASK,
1064 : : tci_off);
1065 : 0 : id = rte_security_macsec_sa_create(ctx, &sa_conf);
1066 [ # # ]: 0 : if (id < 0) {
1067 : : printf("MACsec SA create failed : %d.\n", id);
1068 : 0 : rte_pktmbuf_free_bulk(tx_pkts_burst, j);
1069 : : ret = TEST_FAILED;
1070 : 0 : goto out;
1071 : : }
1072 : 0 : tx_sa_id[i][0] = (uint16_t)id;
1073 : 0 : tx_sa_id[i][1] = MCS_INVALID_SA;
1074 [ # # ]: 0 : if (opts->rekey_en) {
1075 : : memset(&sa_conf, 0, sizeof(struct rte_security_macsec_sa));
1076 : : fill_macsec_sa_conf(opts->rekey_td, &sa_conf,
1077 : : RTE_SECURITY_MACSEC_DIR_TX,
1078 : 0 : opts->rekey_td->secure_pkt.data[tci_off] &
1079 : : RTE_MACSEC_AN_MASK,
1080 : : tci_off);
1081 : 0 : id = rte_security_macsec_sa_create(ctx, &sa_conf);
1082 [ # # ]: 0 : if (id < 0) {
1083 : : printf("MACsec rekey SA create failed : %d.\n", id);
1084 : 0 : rte_pktmbuf_free_bulk(tx_pkts_burst, j);
1085 : : ret = TEST_FAILED;
1086 : 0 : goto out;
1087 : : }
1088 : 0 : tx_sa_id[i][1] = (uint16_t)id;
1089 : : }
1090 : 0 : fill_macsec_sc_conf(td[i], &sc_conf, opts,
1091 : 0 : RTE_SECURITY_MACSEC_DIR_TX, tx_sa_id[i], tci_off);
1092 : 0 : id = rte_security_macsec_sc_create(ctx, &sc_conf);
1093 [ # # ]: 0 : if (id < 0) {
1094 : : printf("MACsec SC create failed : %d.\n", id);
1095 : 0 : rte_pktmbuf_free_bulk(tx_pkts_burst, j);
1096 : : ret = TEST_FAILED;
1097 : 0 : goto out;
1098 : : }
1099 : 0 : tx_sc_id[i] = (uint16_t)id;
1100 : :
1101 : : /* Create Inline IPsec session. */
1102 : 0 : ret = fill_session_conf(td[i], port_id, opts, &sess_conf,
1103 : : RTE_SECURITY_MACSEC_DIR_TX, tx_sc_id[i], tci_off);
1104 [ # # ]: 0 : if (ret) {
1105 : 0 : rte_pktmbuf_free_bulk(tx_pkts_burst, j);
1106 : : ret = TEST_FAILED;
1107 : 0 : goto out;
1108 : : }
1109 : 0 : tx_sess[i] = rte_security_session_create(ctx, &sess_conf,
1110 : : sess_pool);
1111 [ # # ]: 0 : if (tx_sess[i] == NULL) {
1112 : : printf("SEC Session init failed.\n");
1113 : 0 : rte_pktmbuf_free_bulk(tx_pkts_burst, j);
1114 : : ret = TEST_FAILED;
1115 : 0 : goto out;
1116 : : }
1117 : 0 : ret = create_default_flow(td[i], port_id,
1118 : : RTE_SECURITY_MACSEC_DIR_TX, tx_sess[i]);
1119 [ # # ]: 0 : if (ret) {
1120 : 0 : rte_pktmbuf_free_bulk(tx_pkts_burst, j);
1121 : : ret = TEST_FAILED;
1122 : 0 : goto out;
1123 : : }
1124 : : }
1125 : : }
1126 : :
1127 : : /* Send packet to ethdev for inline MACsec processing. */
1128 : 0 : nb_sent = rte_eth_tx_burst(port_id, 0, tx_pkts_burst, j);
1129 : :
1130 [ # # ]: 0 : if (nb_sent != j) {
1131 : : printf("\nUnable to TX %d packets, sent: %i", j, nb_sent);
1132 [ # # ]: 0 : for ( ; nb_sent < j; nb_sent++)
1133 : 0 : rte_pktmbuf_free(tx_pkts_burst[nb_sent]);
1134 : : ret = TEST_FAILED;
1135 : 0 : goto out;
1136 : : }
1137 : :
1138 : : rte_pause();
1139 : :
1140 : : j = 0;
1141 : : /* Receive back packet on loopback interface. */
1142 : : do {
1143 : 0 : nb_rx += rte_eth_rx_burst(port_id, 0,
1144 : : &rx_pkts_burst[nb_rx],
1145 : 0 : nb_sent - nb_rx);
1146 [ # # ]: 0 : if (nb_rx >= nb_sent)
1147 : : break;
1148 : : rte_delay_ms(1);
1149 [ # # # # ]: 0 : } while (j++ < 5 && nb_rx == 0);
1150 : :
1151 [ # # ]: 0 : if (nb_rx != nb_sent) {
1152 : : printf("\nUnable to RX all %d packets, received(%i)",
1153 : : nb_sent, nb_rx);
1154 : 0 : rte_pktmbuf_free_bulk(rx_pkts_burst, nb_rx);
1155 : : ret = TEST_FAILED;
1156 [ # # ]: 0 : if (opts->check_sectag_interrupts == 1)
1157 : : ret = TEST_SUCCESS;
1158 : 0 : goto out;
1159 : : }
1160 : :
1161 [ # # ]: 0 : if (opts->rekey_en) {
1162 [ # # # ]: 0 : switch (err_vector.event) {
1163 : : case RTE_ETH_EVENT_MACSEC_TX_SA_PN_SOFT_EXP:
1164 : : printf("Received RTE_ETH_EVENT_MACSEC_TX_SA_PN_SOFT_EXP event\n");
1165 : : /* The first sa is active now, so the 0th sa can be
1166 : : * reconfigured. Using the same key as zeroeth sa, but
1167 : : * other key can also be configured.
1168 : : */
1169 : 0 : rte_security_macsec_sa_destroy(ctx, tx_sa_id[0][0],
1170 : : RTE_SECURITY_MACSEC_DIR_TX);
1171 : 0 : fill_macsec_sa_conf(td[0], &sa_conf,
1172 : : RTE_SECURITY_MACSEC_DIR_TX,
1173 : 0 : td[0]->secure_pkt.data[tci_off] &
1174 : : RTE_MACSEC_AN_MASK, tci_off);
1175 : 0 : id = rte_security_macsec_sa_create(ctx, &sa_conf);
1176 [ # # ]: 0 : if (id < 0) {
1177 : : printf("MACsec SA create failed : %d.\n", id);
1178 : 0 : rte_pktmbuf_free_bulk(rx_pkts_burst, nb_rx);
1179 : : ret = TEST_FAILED;
1180 : 0 : goto out;
1181 : : }
1182 : 0 : tx_sa_id[0][0] = (uint16_t)id;
1183 : 0 : break;
1184 : : case RTE_ETH_EVENT_MACSEC_RX_SA_PN_SOFT_EXP:
1185 : : printf("Received RTE_ETH_EVENT_MACSEC_RX_SA_PN_SOFT_EXP event\n");
1186 : : break;
1187 : : default:
1188 : : printf("Received unsupported event\n");
1189 : : }
1190 : : }
1191 : :
1192 [ # # ]: 0 : if (opts->replay_protect) {
1193 [ # # ]: 0 : for (i = 0; i < nb_rx; i++) {
1194 : 0 : rte_pktmbuf_free(rx_pkts_burst[i]);
1195 : 0 : rx_pkts_burst[i] = NULL;
1196 : : }
1197 : : ret = TEST_SUCCESS;
1198 : 0 : goto out;
1199 : : }
1200 : :
1201 [ # # ]: 0 : for (i = 0; i < nb_rx; i++) {
1202 [ # # # # ]: 0 : if (opts->rekey_en && i == 1) {
1203 : : /* The second received packet is matched with
1204 : : * rekey td
1205 : : */
1206 : 0 : ret = test_macsec_post_process(rx_pkts_burst[i],
1207 : 0 : opts->rekey_td, op,
1208 : 0 : opts->check_out_pkts_untagged);
1209 : : } else {
1210 : 0 : ret = test_macsec_post_process(rx_pkts_burst[i], td[i],
1211 : 0 : op, opts->check_out_pkts_untagged);
1212 : : }
1213 [ # # ]: 0 : if (ret != TEST_SUCCESS) {
1214 [ # # ]: 0 : for ( ; i < nb_rx; i++)
1215 : 0 : rte_pktmbuf_free(rx_pkts_burst[i]);
1216 : 0 : goto out;
1217 : : }
1218 : :
1219 : 0 : rte_pktmbuf_free(rx_pkts_burst[i]);
1220 : 0 : rx_pkts_burst[i] = NULL;
1221 : : }
1222 : 0 : out:
1223 [ # # ]: 0 : if (opts->check_out_pkts_toolong == 1 ||
1224 [ # # ]: 0 : opts->check_sa_not_in_use == 1 ||
1225 [ # # ]: 0 : opts->check_bad_tag_cnt == 1)
1226 : : ret = TEST_SUCCESS;
1227 : :
1228 [ # # ]: 0 : for (i = 0; i < opts->nb_td; i++) {
1229 [ # # ]: 0 : if (opts->dump_all_stats) {
1230 : 0 : mcs_stats_dump(ctx, op,
1231 : : rx_sess[i], tx_sess[i],
1232 : 0 : rx_sc_id[i], tx_sc_id[i],
1233 : 0 : rx_sa_id[i], tx_sa_id[i]);
1234 : : } else {
1235 [ # # ]: 0 : if (ret == TEST_SUCCESS)
1236 : 0 : ret = mcs_stats_check(ctx, op, opts, td[i],
1237 : : rx_sess[i], tx_sess[i],
1238 : 0 : rx_sc_id[i], tx_sc_id[i],
1239 : 0 : rx_sa_id[i], tx_sa_id[i]);
1240 : : }
1241 : : }
1242 : :
1243 : 0 : destroy_default_flow(port_id);
1244 : :
1245 [ # # ]: 0 : if (opts->rekey_en)
1246 : 0 : rte_eth_dev_callback_unregister(port_id, RTE_ETH_EVENT_MACSEC,
1247 : : test_macsec_event_callback, &err_vector);
1248 : :
1249 : : /* Destroy session so that other cases can create the session again */
1250 [ # # ]: 0 : for (i = 0; i < opts->nb_td; i++) {
1251 [ # # ]: 0 : if (op == MCS_ENCAP || op == MCS_ENCAP_DECAP ||
1252 : : op == MCS_AUTH_ONLY || op == MCS_AUTH_VERIFY) {
1253 : 0 : rte_security_session_destroy(ctx, tx_sess[i]);
1254 : 0 : tx_sess[i] = NULL;
1255 : 0 : rte_security_macsec_sc_destroy(ctx, tx_sc_id[i],
1256 : : RTE_SECURITY_MACSEC_DIR_TX);
1257 : 0 : rte_security_macsec_sa_destroy(ctx, tx_sa_id[i][0],
1258 : : RTE_SECURITY_MACSEC_DIR_TX);
1259 [ # # ]: 0 : if (opts->rekey_en) {
1260 : 0 : rte_security_macsec_sa_destroy(ctx, tx_sa_id[i][1],
1261 : : RTE_SECURITY_MACSEC_DIR_TX);
1262 : : }
1263 : : }
1264 : 0 : if (op == MCS_DECAP || op == MCS_ENCAP_DECAP ||
1265 [ # # # # ]: 0 : op == MCS_VERIFY_ONLY || op == MCS_AUTH_VERIFY) {
1266 : 0 : rte_security_session_destroy(ctx, rx_sess[i]);
1267 : 0 : rx_sess[i] = NULL;
1268 : 0 : rte_security_macsec_sc_destroy(ctx, rx_sc_id[i],
1269 : : RTE_SECURITY_MACSEC_DIR_RX);
1270 [ # # ]: 0 : for (j = 0; j < RTE_SECURITY_MACSEC_NUM_AN; j++) {
1271 : 0 : rte_security_macsec_sa_destroy(ctx, rx_sa_id[i][j],
1272 : : RTE_SECURITY_MACSEC_DIR_RX);
1273 : : }
1274 : : }
1275 : : }
1276 : :
1277 : : return ret;
1278 : : }
1279 : :
1280 : : static int
1281 : 0 : test_inline_macsec_encap_all(void)
1282 : : {
1283 : : const struct mcs_test_vector *cur_td;
1284 : 0 : struct mcs_test_opts opts = {0};
1285 : : int err, all_err = 0;
1286 : : int skipped = 0;
1287 : : int i, size;
1288 : :
1289 : 0 : opts.val_frames = RTE_SECURITY_MACSEC_VALIDATE_STRICT;
1290 : 0 : opts.encrypt = true;
1291 : 0 : opts.protect_frames = true;
1292 : 0 : opts.sa_in_use = 1;
1293 : 0 : opts.nb_td = 1;
1294 : 0 : opts.sectag_insert_mode = 1;
1295 : 0 : opts.mtu = RTE_ETHER_MTU;
1296 : :
1297 : : size = (sizeof(list_mcs_cipher_vectors) / sizeof((list_mcs_cipher_vectors)[0]));
1298 [ # # ]: 0 : for (i = 0; i < size; i++) {
1299 : 0 : cur_td = &list_mcs_cipher_vectors[i];
1300 : 0 : err = test_macsec(&cur_td, MCS_ENCAP, &opts);
1301 [ # # ]: 0 : if (err == TEST_SKIPPED) {
1302 : 0 : printf("Cipher Auth Encryption case %d skipped\n", cur_td->test_idx);
1303 : 0 : skipped += 1;
1304 : : err = 0;
1305 [ # # ]: 0 : } else if (err) {
1306 : 0 : printf("\nCipher Auth Encryption case %d failed", cur_td->test_idx);
1307 : : err = -1;
1308 : : } else {
1309 : 0 : printf("\nCipher Auth Encryption case %d Passed", cur_td->test_idx);
1310 : : err = 0;
1311 : : }
1312 : 0 : all_err += err;
1313 : : }
1314 : 0 : printf("\n%s: Success: %d, Failure: %d, Skipped: %d\n", __func__,
1315 : 0 : size + all_err - skipped, -all_err, skipped);
1316 : :
1317 [ # # ]: 0 : return skipped > 0 ? TEST_SKIPPED : all_err;
1318 : : }
1319 : :
1320 : : static int
1321 : 0 : test_inline_macsec_decap_all(void)
1322 : : {
1323 : : const struct mcs_test_vector *cur_td;
1324 : 0 : struct mcs_test_opts opts = {0};
1325 : : int err, all_err = 0;
1326 : : int skipped = 0;
1327 : : int i, size;
1328 : :
1329 : 0 : opts.val_frames = RTE_SECURITY_MACSEC_VALIDATE_STRICT;
1330 : 0 : opts.sa_in_use = 1;
1331 : 0 : opts.nb_td = 1;
1332 : 0 : opts.sectag_insert_mode = 1;
1333 : 0 : opts.mtu = RTE_ETHER_MTU;
1334 : :
1335 : : size = (sizeof(list_mcs_cipher_vectors) / sizeof((list_mcs_cipher_vectors)[0]));
1336 [ # # ]: 0 : for (i = 0; i < size; i++) {
1337 : 0 : cur_td = &list_mcs_cipher_vectors[i];
1338 : 0 : err = test_macsec(&cur_td, MCS_DECAP, &opts);
1339 [ # # ]: 0 : if (err == TEST_SKIPPED) {
1340 : 0 : printf("Cipher Auth Decryption case %d skipped\n", cur_td->test_idx);
1341 : 0 : skipped += 1;
1342 : : err = 0;
1343 [ # # ]: 0 : } else if (err) {
1344 : 0 : printf("\nCipher Auth Decryption case %d failed", cur_td->test_idx);
1345 : : err = -1;
1346 : : } else {
1347 : 0 : printf("\nCipher Auth Decryption case %d Passed", cur_td->test_idx);
1348 : : err = 0;
1349 : : }
1350 : 0 : all_err += err;
1351 : : }
1352 : 0 : printf("\n%s: Success: %d, Failure: %d, Skipped: %d\n", __func__,
1353 : 0 : size + all_err - skipped, -all_err, skipped);
1354 : :
1355 [ # # ]: 0 : return skipped > 0 ? TEST_SKIPPED : all_err;
1356 : : }
1357 : :
1358 : : static int
1359 : 0 : test_inline_macsec_auth_only_all(void)
1360 : : {
1361 : : const struct mcs_test_vector *cur_td;
1362 : 0 : struct mcs_test_opts opts = {0};
1363 : : int err, all_err = 0;
1364 : : int skipped = 0;
1365 : : int i, size;
1366 : :
1367 : 0 : opts.val_frames = RTE_SECURITY_MACSEC_VALIDATE_STRICT;
1368 : 0 : opts.protect_frames = true;
1369 : 0 : opts.sa_in_use = 1;
1370 : 0 : opts.nb_td = 1;
1371 : 0 : opts.sectag_insert_mode = 1;
1372 : 0 : opts.mtu = RTE_ETHER_MTU;
1373 : :
1374 : : size = (sizeof(list_mcs_integrity_vectors) / sizeof((list_mcs_integrity_vectors)[0]));
1375 : :
1376 [ # # ]: 0 : for (i = 0; i < size; i++) {
1377 : 0 : cur_td = &list_mcs_integrity_vectors[i];
1378 : 0 : err = test_macsec(&cur_td, MCS_AUTH_ONLY, &opts);
1379 [ # # ]: 0 : if (err == TEST_SKIPPED) {
1380 : 0 : printf("Auth Generate case %d skipped\n", cur_td->test_idx);
1381 : 0 : skipped += 1;
1382 : : err = 0;
1383 [ # # ]: 0 : } else if (err) {
1384 : 0 : printf("\nAuth Generate case %d failed", cur_td->test_idx);
1385 : : err = -1;
1386 : : } else {
1387 : 0 : printf("\nAuth Generate case %d Passed", cur_td->test_idx);
1388 : : err = 0;
1389 : : }
1390 : 0 : all_err += err;
1391 : : }
1392 : 0 : printf("\n%s: Success: %d, Failure: %d, Skipped: %d\n", __func__,
1393 : 0 : size + all_err - skipped, -all_err, skipped);
1394 : :
1395 [ # # ]: 0 : return skipped > 0 ? TEST_SKIPPED : all_err;
1396 : : }
1397 : :
1398 : : static int
1399 : 0 : test_inline_macsec_verify_only_all(void)
1400 : : {
1401 : : const struct mcs_test_vector *cur_td;
1402 : 0 : struct mcs_test_opts opts = {0};
1403 : : int err, all_err = 0;
1404 : : int skipped = 0;
1405 : : int i, size;
1406 : :
1407 : 0 : opts.val_frames = RTE_SECURITY_MACSEC_VALIDATE_STRICT;
1408 : 0 : opts.sa_in_use = 1;
1409 : 0 : opts.nb_td = 1;
1410 : 0 : opts.sectag_insert_mode = 1;
1411 : 0 : opts.mtu = RTE_ETHER_MTU;
1412 : :
1413 : : size = (sizeof(list_mcs_integrity_vectors) / sizeof((list_mcs_integrity_vectors)[0]));
1414 : :
1415 [ # # ]: 0 : for (i = 0; i < size; i++) {
1416 : 0 : cur_td = &list_mcs_integrity_vectors[i];
1417 : 0 : err = test_macsec(&cur_td, MCS_VERIFY_ONLY, &opts);
1418 [ # # ]: 0 : if (err == TEST_SKIPPED) {
1419 : 0 : printf("Auth Verify case %d skipped\n", cur_td->test_idx);
1420 : 0 : skipped += 1;
1421 : : err = 0;
1422 [ # # ]: 0 : } else if (err) {
1423 : 0 : printf("\nAuth Verify case %d failed", cur_td->test_idx);
1424 : : err = -1;
1425 : : } else {
1426 : 0 : printf("\nAuth Verify case %d Passed", cur_td->test_idx);
1427 : : err = 0;
1428 : : }
1429 : 0 : all_err += err;
1430 : : }
1431 : 0 : printf("\n%s: Success: %d, Failure: %d, Skipped: %d\n", __func__,
1432 : 0 : size + all_err - skipped, -all_err, skipped);
1433 : :
1434 [ # # ]: 0 : return skipped > 0 ? TEST_SKIPPED : all_err;
1435 : : }
1436 : :
1437 : : static int
1438 : 0 : test_inline_macsec_encap_decap_all(void)
1439 : : {
1440 : : const struct mcs_test_vector *cur_td;
1441 : 0 : struct mcs_test_opts opts = {0};
1442 : : int err, all_err = 0;
1443 : : int skipped = 0;
1444 : : int i, size;
1445 : :
1446 : 0 : opts.val_frames = RTE_SECURITY_MACSEC_VALIDATE_STRICT;
1447 : 0 : opts.encrypt = true;
1448 : 0 : opts.protect_frames = true;
1449 : 0 : opts.sa_in_use = 1;
1450 : 0 : opts.nb_td = 1;
1451 : 0 : opts.sectag_insert_mode = 1;
1452 : 0 : opts.mtu = RTE_ETHER_MTU;
1453 : :
1454 : : size = (sizeof(list_mcs_cipher_vectors) / sizeof((list_mcs_cipher_vectors)[0]));
1455 : :
1456 [ # # ]: 0 : for (i = 0; i < size; i++) {
1457 : 0 : cur_td = &list_mcs_cipher_vectors[i];
1458 : 0 : err = test_macsec(&cur_td, MCS_ENCAP_DECAP, &opts);
1459 [ # # ]: 0 : if (err == TEST_SKIPPED) {
1460 : 0 : printf("Cipher Auth Encap-decap case %d skipped\n", cur_td->test_idx);
1461 : 0 : skipped += 1;
1462 : : err = 0;
1463 [ # # ]: 0 : } else if (err) {
1464 : 0 : printf("\nCipher Auth Encap-decap case %d failed", cur_td->test_idx);
1465 : : err = -1;
1466 : : } else {
1467 : 0 : printf("\nCipher Auth Encap-decap case %d Passed", cur_td->test_idx);
1468 : : err = 0;
1469 : : }
1470 : 0 : all_err += err;
1471 : : }
1472 : 0 : printf("\n%s: Success: %d, Failure: %d, Skipped: %d\n", __func__,
1473 : 0 : size + all_err - skipped, -all_err, skipped);
1474 : :
1475 [ # # ]: 0 : return skipped > 0 ? TEST_SKIPPED : all_err;
1476 : : }
1477 : :
1478 : :
1479 : : static int
1480 : 0 : test_inline_macsec_auth_verify_all(void)
1481 : : {
1482 : : const struct mcs_test_vector *cur_td;
1483 : 0 : struct mcs_test_opts opts = {0};
1484 : : int err, all_err = 0;
1485 : : int skipped = 0;
1486 : : int i, size;
1487 : :
1488 : 0 : opts.val_frames = RTE_SECURITY_MACSEC_VALIDATE_STRICT;
1489 : 0 : opts.protect_frames = true;
1490 : 0 : opts.sa_in_use = 1;
1491 : 0 : opts.nb_td = 1;
1492 : 0 : opts.sectag_insert_mode = 1;
1493 : 0 : opts.mtu = RTE_ETHER_MTU;
1494 : :
1495 : : size = (sizeof(list_mcs_integrity_vectors) / sizeof((list_mcs_integrity_vectors)[0]));
1496 : :
1497 [ # # ]: 0 : for (i = 0; i < size; i++) {
1498 : 0 : cur_td = &list_mcs_integrity_vectors[i];
1499 : 0 : err = test_macsec(&cur_td, MCS_AUTH_VERIFY, &opts);
1500 [ # # ]: 0 : if (err == TEST_SKIPPED) {
1501 : 0 : printf("Auth Generate + Verify case %d skipped\n", cur_td->test_idx);
1502 : 0 : skipped += 1;
1503 : : err = 0;
1504 [ # # ]: 0 : } else if (err) {
1505 : 0 : printf("\nAuth Generate + Verify case %d failed", cur_td->test_idx);
1506 : : err = -1;
1507 : : } else {
1508 : 0 : printf("\nAuth Generate + Verify case %d Passed", cur_td->test_idx);
1509 : : err = 0;
1510 : : }
1511 : 0 : all_err += err;
1512 : : }
1513 : 0 : printf("\n%s: Success: %d, Failure: %d, Skipped: %d\n", __func__,
1514 : 0 : size + all_err - skipped, -all_err, skipped);
1515 : :
1516 [ # # ]: 0 : return skipped > 0 ? TEST_SKIPPED : all_err;
1517 : : }
1518 : :
1519 : : static int
1520 : 0 : test_inline_macsec_multi_flow(void)
1521 : : {
1522 : : const struct mcs_test_vector *tv[MCS_MAX_FLOWS];
1523 : : struct mcs_test_vector iter[MCS_MAX_FLOWS];
1524 : 0 : struct mcs_test_opts opts = {0};
1525 : : int i, err;
1526 : :
1527 : 0 : opts.val_frames = RTE_SECURITY_MACSEC_VALIDATE_STRICT;
1528 : 0 : opts.encrypt = true;
1529 : 0 : opts.protect_frames = true;
1530 : 0 : opts.sa_in_use = 1;
1531 : 0 : opts.nb_td = MCS_MAX_FLOWS;
1532 : 0 : opts.sectag_insert_mode = 1;
1533 : 0 : opts.mtu = RTE_ETHER_MTU;
1534 : :
1535 [ # # ]: 0 : for (i = 0; i < MCS_MAX_FLOWS; i++) {
1536 : 0 : memcpy(&iter[i].sa_key.data, sa_key, MCS_MULTI_FLOW_TD_KEY_SZ);
1537 : 0 : memcpy(&iter[i].plain_pkt.data, eth_addrs[i], 2 * RTE_ETHER_ADDR_LEN);
1538 : 0 : memcpy(&iter[i].plain_pkt.data[2 * RTE_ETHER_ADDR_LEN], plain_user_data,
1539 : : MCS_MULTI_FLOW_TD_PLAIN_DATA_SZ);
1540 : 0 : memcpy(&iter[i].secure_pkt.data, eth_addrs[i], 2 * RTE_ETHER_ADDR_LEN);
1541 : 0 : memcpy(&iter[i].secure_pkt.data[2 * RTE_ETHER_ADDR_LEN], secure_user_data,
1542 : : MCS_MULTI_FLOW_TD_SECURE_DATA_SZ);
1543 : 0 : iter[i].sa_key.len = MCS_MULTI_FLOW_TD_KEY_SZ;
1544 : 0 : iter[i].plain_pkt.len = MCS_MULTI_FLOW_TD_PLAIN_DATA_SZ +
1545 : : (2 * RTE_ETHER_ADDR_LEN);
1546 : 0 : iter[i].secure_pkt.len = MCS_MULTI_FLOW_TD_SECURE_DATA_SZ +
1547 : : (2 * RTE_ETHER_ADDR_LEN);
1548 : 0 : iter[i].alg = RTE_SECURITY_MACSEC_ALG_GCM_128;
1549 : 0 : iter[i].ssci = 0x0;
1550 : 0 : iter[i].xpn = 0x0;
1551 : 0 : tv[i] = (const struct mcs_test_vector *)&iter[i];
1552 : : }
1553 : 0 : err = test_macsec(tv, MCS_ENCAP_DECAP, &opts);
1554 [ # # ]: 0 : if (err == TEST_SKIPPED) {
1555 : : printf("Cipher Auth Encryption multi flow skipped\n");
1556 [ # # ]: 0 : } else if (err) {
1557 : : printf("\nCipher Auth Encryption multi flow failed");
1558 : : err = -1;
1559 : : } else {
1560 : : printf("\nCipher Auth Encryption multi flow Passed");
1561 : : err = 0;
1562 : : }
1563 : 0 : return err;
1564 : : }
1565 : :
1566 : : static int
1567 : 0 : test_inline_macsec_with_vlan(void)
1568 : : {
1569 : : const struct mcs_test_vector *cur_td;
1570 : 0 : struct mcs_test_opts opts = {0};
1571 : : int err, all_err = 0;
1572 : : int skipped = 0;
1573 : : int i, size;
1574 : :
1575 : 0 : opts.val_frames = RTE_SECURITY_MACSEC_VALIDATE_STRICT;
1576 : 0 : opts.protect_frames = true;
1577 : 0 : opts.sa_in_use = 1;
1578 : 0 : opts.nb_td = 1;
1579 : 0 : opts.mtu = RTE_ETHER_MTU;
1580 : :
1581 : : size = (sizeof(list_mcs_vlan_vectors) / sizeof((list_mcs_vlan_vectors)[0]));
1582 : :
1583 [ # # ]: 0 : for (i = 0; i < size; i++) {
1584 : 0 : cur_td = &list_mcs_vlan_vectors[i];
1585 [ # # ]: 0 : if (i == 0) {
1586 : 0 : opts.sectag_insert_mode = 1;
1587 [ # # ]: 0 : } else if (i == 1) {
1588 : 0 : opts.sectag_insert_mode = 0; /* offset from special E-type */
1589 : 0 : opts.nb_vlan = 1;
1590 : : } else if (i == 2) {
1591 : 0 : opts.sectag_insert_mode = 0; /* offset from special E-type */
1592 : 0 : opts.nb_vlan = 2;
1593 : : }
1594 : 0 : err = test_macsec(&cur_td, MCS_ENCAP, &opts);
1595 [ # # ]: 0 : if (err == TEST_SKIPPED) {
1596 : 0 : printf("VLAN Encap case %d skipped", cur_td->test_idx);
1597 : 0 : skipped += 1;
1598 : : err = 0;
1599 [ # # ]: 0 : } else if (err) {
1600 : 0 : printf("\n VLAN Encap case %d failed", cur_td->test_idx);
1601 : : err = -1;
1602 : : } else {
1603 : 0 : printf("\n VLAN Encap case %d passed", cur_td->test_idx);
1604 : : err = 0;
1605 : : }
1606 : 0 : all_err += err;
1607 : : }
1608 [ # # ]: 0 : for (i = 0; i < size; i++) {
1609 : 0 : cur_td = &list_mcs_vlan_vectors[i];
1610 [ # # ]: 0 : if (i == 0) {
1611 : 0 : opts.sectag_insert_mode = 1;
1612 [ # # ]: 0 : } else if (i == 1) {
1613 : 0 : opts.sectag_insert_mode = 0; /* offset from special E-type */
1614 : 0 : opts.nb_vlan = 1;
1615 : : } else if (i == 2) {
1616 : 0 : opts.sectag_insert_mode = 0; /* offset from special E-type */
1617 : 0 : opts.nb_vlan = 2;
1618 : : }
1619 : 0 : err = test_macsec(&cur_td, MCS_DECAP, &opts);
1620 [ # # ]: 0 : if (err == TEST_SKIPPED) {
1621 : 0 : printf("VLAN Decap case %d skipped", cur_td->test_idx);
1622 : 0 : skipped += 1;
1623 : : err = 0;
1624 [ # # ]: 0 : } else if (err) {
1625 : 0 : printf("\n VLAN Decap case %d failed", cur_td->test_idx);
1626 : : err = -1;
1627 : : } else {
1628 : 0 : printf("\n VLAN Decap case %d passed", cur_td->test_idx);
1629 : : err = 0;
1630 : : }
1631 : 0 : all_err += err;
1632 : : }
1633 : :
1634 : 0 : printf("\n%s: Success: %d, Failure: %d, Skipped: %d\n", __func__,
1635 : 0 : 2 * size + all_err - skipped, -all_err, skipped);
1636 [ # # ]: 0 : return skipped > 0 ? TEST_SKIPPED : all_err;
1637 : : }
1638 : :
1639 : : static int
1640 : 0 : test_inline_macsec_pkt_drop(void)
1641 : : {
1642 : : const struct mcs_test_vector *cur_td;
1643 : 0 : struct mcs_test_opts opts = {0};
1644 : : int err, all_err = 0;
1645 : : int skipped = 0;
1646 : : int i, size;
1647 : :
1648 : 0 : opts.val_frames = RTE_SECURITY_MACSEC_VALIDATE_STRICT;
1649 : 0 : opts.encrypt = true;
1650 : 0 : opts.protect_frames = true;
1651 : 0 : opts.sa_in_use = 1;
1652 : 0 : opts.nb_td = 1;
1653 : 0 : opts.sectag_insert_mode = 1;
1654 : 0 : opts.mtu = RTE_ETHER_MTU;
1655 : :
1656 : : size = (sizeof(list_mcs_err_cipher_vectors) / sizeof((list_mcs_err_cipher_vectors)[0]));
1657 : :
1658 [ # # ]: 0 : for (i = 0; i < size; i++) {
1659 : 0 : cur_td = &list_mcs_err_cipher_vectors[i];
1660 : 0 : err = test_macsec(&cur_td, MCS_DECAP, &opts);
1661 [ # # ]: 0 : if (err == TEST_SKIPPED) {
1662 : 0 : printf("Packet drop case %d skipped", cur_td->test_idx);
1663 : 0 : skipped += 1;
1664 : : err = 0;
1665 [ # # ]: 0 : } else if (err) {
1666 : 0 : printf("\nPacket drop case %d passed", cur_td->test_idx);
1667 : : err = 0;
1668 : : } else {
1669 : 0 : printf("\nPacket drop case %d failed", cur_td->test_idx);
1670 : : err = -1;
1671 : : }
1672 : 0 : all_err += err;
1673 : : }
1674 : 0 : printf("\n%s: Success: %d, Failure: %d, Skipped: %d\n", __func__,
1675 : 0 : size + all_err - skipped, -all_err, skipped);
1676 : :
1677 [ # # ]: 0 : return skipped > 0 ? TEST_SKIPPED : all_err;
1678 : : }
1679 : :
1680 : : static int
1681 : 0 : test_inline_macsec_untagged_rx(void)
1682 : : {
1683 : : const struct mcs_test_vector *cur_td;
1684 : 0 : struct mcs_test_opts opts = {0};
1685 : : int err, all_err = 0;
1686 : : int skipped = 0;
1687 : : int i, size;
1688 : :
1689 : 0 : opts.val_frames = RTE_SECURITY_MACSEC_VALIDATE_STRICT;
1690 : 0 : opts.sa_in_use = 1;
1691 : 0 : opts.nb_td = 1;
1692 : 0 : opts.sectag_insert_mode = 1;
1693 : 0 : opts.mtu = RTE_ETHER_MTU;
1694 : 0 : opts.check_untagged_rx = 1;
1695 : :
1696 : : size = (sizeof(list_mcs_untagged_cipher_vectors) /
1697 : : sizeof((list_mcs_untagged_cipher_vectors)[0]));
1698 : :
1699 [ # # ]: 0 : for (i = 0; i < size; i++) {
1700 : 0 : cur_td = &list_mcs_untagged_cipher_vectors[i];
1701 : 0 : err = test_macsec(&cur_td, MCS_DECAP, &opts);
1702 [ # # ]: 0 : if (err == TEST_SKIPPED) {
1703 : 0 : skipped += 1;
1704 : : err = 0;
1705 [ # # ]: 0 : } else if (err)
1706 : : err = 0;
1707 : : else
1708 : : err = -1;
1709 : :
1710 : 0 : all_err += err;
1711 : : }
1712 : :
1713 : 0 : opts.val_frames = RTE_SECURITY_MACSEC_VALIDATE_NO_DISCARD;
1714 [ # # ]: 0 : for (i = 0; i < size; i++) {
1715 : 0 : cur_td = &list_mcs_untagged_cipher_vectors[i];
1716 : 0 : err = test_macsec(&cur_td, MCS_DECAP, &opts);
1717 [ # # ]: 0 : if (err == TEST_SKIPPED) {
1718 : 0 : skipped += 1;
1719 : : err = 0;
1720 [ # # ]: 0 : } else if (err)
1721 : : err = 0;
1722 : : else
1723 : : err = -1;
1724 : :
1725 : 0 : all_err += err;
1726 : : }
1727 : 0 : printf("\n%s: Success: %d, Failure: %d, Skipped: %d\n", __func__,
1728 : 0 : 2 * size + all_err - skipped, -all_err, skipped);
1729 : :
1730 [ # # ]: 0 : return skipped > 0 ? TEST_SKIPPED : all_err;
1731 : : }
1732 : :
1733 : : static int
1734 : 0 : test_inline_macsec_bad_tag_rx(void)
1735 : : {
1736 : : const struct mcs_test_vector *cur_td;
1737 : 0 : struct mcs_test_opts opts = {0};
1738 : : int err, all_err = 0;
1739 : : int skipped = 0;
1740 : : int i, size;
1741 : :
1742 : 0 : opts.val_frames = RTE_SECURITY_MACSEC_VALIDATE_STRICT;
1743 : 0 : opts.protect_frames = true;
1744 : 0 : opts.sa_in_use = 1;
1745 : 0 : opts.nb_td = 1;
1746 : 0 : opts.sectag_insert_mode = 1;
1747 : 0 : opts.mtu = RTE_ETHER_MTU;
1748 : 0 : opts.check_bad_tag_cnt = 1;
1749 : :
1750 : : size = (sizeof(list_mcs_bad_tag_vectors) / sizeof((list_mcs_bad_tag_vectors)[0]));
1751 : :
1752 [ # # ]: 0 : for (i = 0; i < size; i++) {
1753 : 0 : cur_td = &list_mcs_bad_tag_vectors[i];
1754 : 0 : err = test_macsec(&cur_td, MCS_DECAP, &opts);
1755 [ # # ]: 0 : if (err == TEST_SKIPPED) {
1756 : 0 : skipped += 1;
1757 : : err = 0;
1758 [ # # ]: 0 : } else if (err)
1759 : : err = -1;
1760 : : else
1761 : : err = 0;
1762 : :
1763 : 0 : all_err += err;
1764 : : }
1765 : :
1766 : 0 : printf("\n%s: Success: %d, Failure: %d, Skipped: %d\n", __func__,
1767 : 0 : size + all_err - skipped, -all_err, skipped);
1768 : :
1769 [ # # ]: 0 : return skipped > 0 ? TEST_SKIPPED : all_err;
1770 : : }
1771 : :
1772 : : static int
1773 : 0 : test_inline_macsec_sa_not_in_use(void)
1774 : : {
1775 : : const struct mcs_test_vector *cur_td;
1776 : 0 : struct mcs_test_opts opts = {0};
1777 : : int err, all_err = 0;
1778 : : int skipped = 0;
1779 : : int i, size;
1780 : :
1781 : 0 : opts.val_frames = RTE_SECURITY_MACSEC_VALIDATE_STRICT;
1782 : 0 : opts.protect_frames = true;
1783 : : opts.sa_in_use = 0;
1784 : 0 : opts.nb_td = 1;
1785 : 0 : opts.sectag_insert_mode = 1;
1786 : 0 : opts.mtu = RTE_ETHER_MTU;
1787 : 0 : opts.check_sa_not_in_use = 1;
1788 : :
1789 : : size = (sizeof(list_mcs_cipher_vectors) / sizeof((list_mcs_cipher_vectors)[0]));
1790 : :
1791 [ # # ]: 0 : for (i = 0; i < size; i++) {
1792 : 0 : cur_td = &list_mcs_cipher_vectors[i];
1793 : 0 : err = test_macsec(&cur_td, MCS_DECAP, &opts);
1794 [ # # ]: 0 : if (err == TEST_SKIPPED) {
1795 : 0 : skipped += 1;
1796 : : err = 0;
1797 [ # # ]: 0 : } else if (err)
1798 : : err = -1;
1799 : : else
1800 : : err = 0;
1801 : :
1802 : 0 : all_err += err;
1803 : : }
1804 : :
1805 : 0 : printf("\n%s: Success: %d, Failure: %d, Skipped: %d\n", __func__,
1806 : 0 : size + all_err - skipped, -all_err, skipped);
1807 : :
1808 [ # # ]: 0 : return skipped > 0 ? TEST_SKIPPED : all_err;
1809 : : }
1810 : :
1811 : : static int
1812 : 0 : test_inline_macsec_decap_stats(void)
1813 : : {
1814 : : const struct mcs_test_vector *cur_td;
1815 : 0 : struct mcs_test_opts opts = {0};
1816 : : int err, all_err = 0;
1817 : : int skipped = 0;
1818 : : int i, size;
1819 : :
1820 : 0 : opts.val_frames = RTE_SECURITY_MACSEC_VALIDATE_STRICT;
1821 : 0 : opts.protect_frames = true;
1822 : 0 : opts.sa_in_use = 1;
1823 : 0 : opts.nb_td = 1;
1824 : 0 : opts.sectag_insert_mode = 1;
1825 : 0 : opts.mtu = RTE_ETHER_MTU;
1826 : 0 : opts.check_decap_stats = 1;
1827 : :
1828 : : size = (sizeof(list_mcs_cipher_vectors) / sizeof((list_mcs_cipher_vectors)[0]));
1829 : :
1830 [ # # ]: 0 : for (i = 0; i < size; i++) {
1831 : 0 : cur_td = &list_mcs_cipher_vectors[i];
1832 : 0 : err = test_macsec(&cur_td, MCS_DECAP, &opts);
1833 [ # # ]: 0 : if (err == TEST_SKIPPED) {
1834 : 0 : printf("Decap stats case %d skipped\n", cur_td->test_idx);
1835 : 0 : skipped += 1;
1836 : : err = 0;
1837 [ # # ]: 0 : } else if (err) {
1838 : 0 : printf("\nDecap stats case %d failed", cur_td->test_idx);
1839 : : err = -1;
1840 : : } else {
1841 : 0 : printf("\nDecap stats case %d passed", cur_td->test_idx);
1842 : : err = 0;
1843 : : }
1844 : 0 : all_err += err;
1845 : : }
1846 : 0 : printf("\n%s: Success: %d, Failure: %d, Skipped: %d\n", __func__,
1847 : 0 : size + all_err - skipped, -all_err, skipped);
1848 : :
1849 [ # # ]: 0 : return skipped > 0 ? TEST_SKIPPED : all_err;
1850 : : }
1851 : :
1852 : : static int
1853 : 0 : test_inline_macsec_verify_only_stats(void)
1854 : : {
1855 : : const struct mcs_test_vector *cur_td;
1856 : 0 : struct mcs_test_opts opts = {0};
1857 : : int err, all_err = 0;
1858 : : int skipped = 0;
1859 : : int i, size;
1860 : :
1861 : 0 : opts.val_frames = RTE_SECURITY_MACSEC_VALIDATE_STRICT;
1862 : 0 : opts.protect_frames = true;
1863 : 0 : opts.sa_in_use = 1;
1864 : 0 : opts.nb_td = 1;
1865 : 0 : opts.sectag_insert_mode = 1;
1866 : 0 : opts.mtu = RTE_ETHER_MTU;
1867 : 0 : opts.check_verify_only_stats = 1;
1868 : :
1869 : : size = (sizeof(list_mcs_integrity_vectors) / sizeof((list_mcs_integrity_vectors)[0]));
1870 : :
1871 [ # # ]: 0 : for (i = 0; i < size; i++) {
1872 : 0 : cur_td = &list_mcs_integrity_vectors[i];
1873 : 0 : err = test_macsec(&cur_td, MCS_VERIFY_ONLY, &opts);
1874 [ # # ]: 0 : if (err == TEST_SKIPPED) {
1875 : 0 : printf("Verify only stats case %d skipped\n", cur_td->test_idx);
1876 : 0 : skipped += 1;
1877 : : err = 0;
1878 [ # # ]: 0 : } else if (err) {
1879 : 0 : printf("\nVerify only stats case %d failed", cur_td->test_idx);
1880 : : err = -1;
1881 : : } else {
1882 : 0 : printf("\nVerify only stats case %d Passed", cur_td->test_idx);
1883 : : err = 0;
1884 : : }
1885 : 0 : all_err += err;
1886 : : }
1887 : 0 : printf("\n%s: Success: %d, Failure: %d, Skipped: %d\n", __func__,
1888 : 0 : size + all_err - skipped, -all_err, skipped);
1889 : :
1890 [ # # ]: 0 : return skipped > 0 ? TEST_SKIPPED : all_err;
1891 : : }
1892 : :
1893 : : static int
1894 : 0 : test_inline_macsec_pkts_invalid_stats(void)
1895 : : {
1896 : : const struct mcs_test_vector *cur_td;
1897 : 0 : struct mcs_test_opts opts = {0};
1898 : : int err, all_err = 0;
1899 : : int skipped = 0;
1900 : : int i, size;
1901 : :
1902 : 0 : opts.val_frames = RTE_SECURITY_MACSEC_VALIDATE_STRICT;
1903 : 0 : opts.protect_frames = true;
1904 : 0 : opts.sa_in_use = 1;
1905 : 0 : opts.nb_td = 1;
1906 : 0 : opts.sectag_insert_mode = 1;
1907 : 0 : opts.mtu = RTE_ETHER_MTU;
1908 : :
1909 : : size = (sizeof(list_mcs_err_cipher_vectors) / sizeof((list_mcs_err_cipher_vectors)[0]));
1910 : :
1911 [ # # ]: 0 : for (i = 0; i < size; i++) {
1912 : 0 : cur_td = &list_mcs_err_cipher_vectors[i];
1913 : 0 : err = test_macsec(&cur_td, MCS_DECAP, &opts);
1914 [ # # ]: 0 : if (err == TEST_SKIPPED) {
1915 : 0 : skipped += 1;
1916 : : err = 0;
1917 [ # # ]: 0 : } else if (err)
1918 : : err = 0;
1919 : : else
1920 : : err = -1;
1921 : :
1922 : 0 : all_err += err;
1923 : : }
1924 : 0 : printf("\n%s: Success: %d, Failure: %d, Skipped: %d\n", __func__,
1925 : 0 : size + all_err - skipped, -all_err, skipped);
1926 [ # # ]: 0 : return skipped > 0 ? TEST_SKIPPED : all_err;
1927 : : }
1928 : :
1929 : : static int
1930 : 0 : test_inline_macsec_pkts_unchecked_stats(void)
1931 : : {
1932 : : const struct mcs_test_vector *cur_td;
1933 : 0 : struct mcs_test_opts opts = {0};
1934 : : int err, all_err = 0;
1935 : : int skipped = 0;
1936 : : int i, size;
1937 : :
1938 : : opts.val_frames = RTE_SECURITY_MACSEC_VALIDATE_DISABLE;
1939 : 0 : opts.protect_frames = true;
1940 : 0 : opts.sa_in_use = 1;
1941 : 0 : opts.nb_td = 1;
1942 : 0 : opts.sectag_insert_mode = 1;
1943 : 0 : opts.mtu = RTE_ETHER_MTU;
1944 : 0 : opts.check_pkts_unchecked_stats = 1;
1945 : :
1946 : : size = (sizeof(list_mcs_integrity_vectors) / sizeof((list_mcs_integrity_vectors)[0]));
1947 : :
1948 [ # # ]: 0 : for (i = 0; i < size; i++) {
1949 : 0 : cur_td = &list_mcs_integrity_vectors[i];
1950 : 0 : err = test_macsec(&cur_td, MCS_VERIFY_ONLY, &opts);
1951 [ # # ]: 0 : if (err == TEST_SKIPPED) {
1952 : 0 : skipped += 1;
1953 : : err = 0;
1954 [ # # ]: 0 : } else if (err)
1955 : : err = -1;
1956 : : else
1957 : : err = 0;
1958 : :
1959 : 0 : all_err += err;
1960 : : }
1961 : :
1962 : 0 : printf("\n%s: Success: %d, Failure: %d, Skipped: %d\n", __func__,
1963 : 0 : size + all_err - skipped, -all_err, skipped);
1964 [ # # ]: 0 : return skipped > 0 ? TEST_SKIPPED : all_err;
1965 : : }
1966 : :
1967 : : static int
1968 : 0 : test_inline_macsec_out_pkts_untagged(void)
1969 : : {
1970 : : const struct mcs_test_vector *cur_td;
1971 : 0 : struct mcs_test_opts opts = {0};
1972 : : int err, all_err = 0;
1973 : : int skipped = 0;
1974 : : int i, size;
1975 : :
1976 : 0 : opts.val_frames = RTE_SECURITY_MACSEC_VALIDATE_STRICT;
1977 : : opts.encrypt = false;
1978 : : opts.protect_frames = false;
1979 : 0 : opts.sa_in_use = 1;
1980 : 0 : opts.nb_td = 1;
1981 : 0 : opts.sectag_insert_mode = 1;
1982 : 0 : opts.mtu = RTE_ETHER_MTU;
1983 : 0 : opts.check_out_pkts_untagged = 1;
1984 : :
1985 : : size = (sizeof(list_mcs_cipher_vectors) / sizeof((list_mcs_cipher_vectors)[0]));
1986 [ # # ]: 0 : for (i = 0; i < size; i++) {
1987 : 0 : cur_td = &list_mcs_cipher_vectors[i];
1988 : 0 : err = test_macsec(&cur_td, MCS_ENCAP, &opts);
1989 [ # # ]: 0 : if (err == TEST_SKIPPED) {
1990 : 0 : skipped += 1;
1991 : : err = 0;
1992 [ # # ]: 0 : } else if (err)
1993 : : err = -1;
1994 : : else
1995 : : err = 0;
1996 : :
1997 : 0 : all_err += err;
1998 : : }
1999 : :
2000 : 0 : printf("\n%s: Success: %d, Failure: %d, Skipped: %d\n", __func__,
2001 : 0 : size + all_err - skipped, -all_err, skipped);
2002 [ # # ]: 0 : return skipped > 0 ? TEST_SKIPPED : all_err;
2003 : : }
2004 : :
2005 : : static int
2006 : 0 : test_inline_macsec_out_pkts_toolong(void)
2007 : : {
2008 : : const struct mcs_test_vector *cur_td;
2009 : 0 : struct mcs_test_opts opts = {0};
2010 : : int err, all_err = 0;
2011 : : int skipped = 0;
2012 : : int i, size;
2013 : :
2014 : 0 : opts.val_frames = RTE_SECURITY_MACSEC_VALIDATE_NO_DISCARD;
2015 : 0 : opts.encrypt = true;
2016 : 0 : opts.protect_frames = true;
2017 : 0 : opts.sa_in_use = 1;
2018 : 0 : opts.nb_td = 1;
2019 : 0 : opts.sectag_insert_mode = 1;
2020 : 0 : opts.mtu = 50;
2021 : 0 : opts.check_out_pkts_toolong = 1;
2022 : :
2023 : : size = (sizeof(list_mcs_cipher_vectors) / sizeof((list_mcs_cipher_vectors)[0]));
2024 [ # # ]: 0 : for (i = 0; i < size; i++) {
2025 : 0 : cur_td = &list_mcs_cipher_vectors[i];
2026 : 0 : err = test_macsec(&cur_td, MCS_ENCAP, &opts);
2027 [ # # ]: 0 : if (err == TEST_SKIPPED) {
2028 : 0 : skipped += 1;
2029 : : err = 0;
2030 [ # # ]: 0 : } else if (err)
2031 : : err = -1;
2032 : : else
2033 : : err = 0;
2034 : :
2035 : 0 : all_err += err;
2036 : : }
2037 : :
2038 : 0 : printf("\n%s: Success: %d, Failure: %d, Skipped: %d\n", __func__,
2039 : 0 : size + all_err - skipped, -all_err, skipped);
2040 [ # # ]: 0 : return skipped > 0 ? TEST_SKIPPED : all_err;
2041 : : }
2042 : :
2043 : : static int
2044 : 0 : test_inline_macsec_encap_stats(void)
2045 : : {
2046 : : const struct mcs_test_vector *cur_td;
2047 : 0 : struct mcs_test_opts opts = {0};
2048 : : int err, all_err = 0;
2049 : : int skipped = 0;
2050 : : int i, size;
2051 : :
2052 : 0 : opts.val_frames = RTE_SECURITY_MACSEC_VALIDATE_STRICT;
2053 : 0 : opts.encrypt = true;
2054 : 0 : opts.protect_frames = true;
2055 : 0 : opts.sa_in_use = 1;
2056 : 0 : opts.nb_td = 1;
2057 : 0 : opts.sectag_insert_mode = 1;
2058 : 0 : opts.mtu = RTE_ETHER_MTU;
2059 : 0 : opts.check_encap_stats = 1;
2060 : :
2061 : : size = (sizeof(list_mcs_cipher_vectors) / sizeof((list_mcs_cipher_vectors)[0]));
2062 [ # # ]: 0 : for (i = 0; i < size; i++) {
2063 : 0 : cur_td = &list_mcs_cipher_vectors[i];
2064 : 0 : err = test_macsec(&cur_td, MCS_ENCAP, &opts);
2065 [ # # ]: 0 : if (err == TEST_SKIPPED) {
2066 : 0 : skipped += 1;
2067 : : err = 0;
2068 [ # # ]: 0 : } else if (err)
2069 : : err = -1;
2070 : : else
2071 : : err = 0;
2072 : :
2073 : 0 : all_err += err;
2074 : : }
2075 : :
2076 : 0 : printf("\n%s: Success: %d, Failure: %d, Skipped: %d\n", __func__,
2077 : 0 : size + all_err - skipped, -all_err, skipped);
2078 [ # # ]: 0 : return skipped > 0 ? TEST_SKIPPED : all_err;
2079 : : }
2080 : :
2081 : : static int
2082 : 0 : test_inline_macsec_auth_only_stats(void)
2083 : : {
2084 : : const struct mcs_test_vector *cur_td;
2085 : 0 : struct mcs_test_opts opts = {0};
2086 : : int err, all_err = 0;
2087 : : int skipped = 0;
2088 : : int i, size;
2089 : :
2090 : 0 : opts.val_frames = RTE_SECURITY_MACSEC_VALIDATE_STRICT;
2091 : 0 : opts.protect_frames = true;
2092 : 0 : opts.sa_in_use = 1;
2093 : 0 : opts.nb_td = 1;
2094 : 0 : opts.sectag_insert_mode = 1;
2095 : 0 : opts.mtu = RTE_ETHER_MTU;
2096 : 0 : opts.check_auth_only_stats = 1;
2097 : :
2098 : : size = (sizeof(list_mcs_integrity_vectors) / sizeof((list_mcs_integrity_vectors)[0]));
2099 : :
2100 [ # # ]: 0 : for (i = 0; i < size; i++) {
2101 : 0 : cur_td = &list_mcs_integrity_vectors[i];
2102 : 0 : err = test_macsec(&cur_td, MCS_AUTH_ONLY, &opts);
2103 [ # # ]: 0 : if (err == TEST_SKIPPED) {
2104 : 0 : skipped += 1;
2105 : : err = 0;
2106 [ # # ]: 0 : } else if (err)
2107 : : err = -1;
2108 : : else
2109 : : err = 0;
2110 : :
2111 : 0 : all_err += err;
2112 : : }
2113 : :
2114 : 0 : printf("\n%s: Success: %d, Failure: %d, Skipped: %d\n", __func__,
2115 : 0 : size + all_err - skipped, -all_err, skipped);
2116 [ # # ]: 0 : return skipped > 0 ? TEST_SKIPPED : all_err;
2117 : : }
2118 : :
2119 : : static int
2120 : 0 : test_inline_macsec_interrupts_all(void)
2121 : : {
2122 : 0 : struct mcs_err_vector err_vector = {0};
2123 : : const struct mcs_test_vector *cur_td;
2124 : 0 : struct mcs_test_opts opts = {0};
2125 : : int skipped = 0;
2126 : : int i, size;
2127 : : int err, all_err = 0;
2128 : 0 : enum rte_eth_event_macsec_subtype subtype[] = {
2129 : : RTE_ETH_SUBEVENT_MACSEC_RX_SECTAG_V_EQ1,
2130 : : RTE_ETH_SUBEVENT_MACSEC_RX_SECTAG_E_EQ0_C_EQ1,
2131 : : RTE_ETH_SUBEVENT_MACSEC_RX_SECTAG_SL_GTE48,
2132 : : RTE_ETH_SUBEVENT_MACSEC_RX_SECTAG_ES_EQ1_SC_EQ1,
2133 : : RTE_ETH_SUBEVENT_MACSEC_RX_SECTAG_SC_EQ1_SCB_EQ1,
2134 : : };
2135 : :
2136 : 0 : opts.val_frames = RTE_SECURITY_MACSEC_VALIDATE_STRICT;
2137 : 0 : opts.protect_frames = true;
2138 : 0 : opts.sa_in_use = 1;
2139 : 0 : opts.nb_td = 1;
2140 : 0 : opts.sectag_insert_mode = 1;
2141 : 0 : opts.mtu = RTE_ETHER_MTU;
2142 : 0 : opts.check_sectag_interrupts = 1;
2143 : :
2144 : : err_vector.event = RTE_ETH_EVENT_MACSEC_UNKNOWN;
2145 : : err_vector.event_subtype = RTE_ETH_SUBEVENT_MACSEC_UNKNOWN;
2146 : 0 : rte_eth_dev_callback_register(port_id, RTE_ETH_EVENT_MACSEC,
2147 : : test_macsec_event_callback, &err_vector);
2148 : :
2149 : : size = (sizeof(list_mcs_intr_test_vectors) / sizeof((list_mcs_intr_test_vectors)[0]));
2150 : :
2151 [ # # ]: 0 : for (i = 0; i < size; i++) {
2152 : 0 : cur_td = &list_mcs_intr_test_vectors[i];
2153 : 0 : err = test_macsec(&cur_td, MCS_DECAP, &opts);
2154 [ # # ]: 0 : if (err == TEST_SKIPPED) {
2155 : : printf("Sectag val err interrupt test case %d skipped",
2156 : 0 : cur_td->test_idx);
2157 : 0 : skipped += 1;
2158 : : err = 0;
2159 [ # # ]: 0 : } else if ((err_vector.event == RTE_ETH_EVENT_MACSEC_SECTAG_VAL_ERR) &&
2160 [ # # ]: 0 : (err_vector.event_subtype == subtype[i])) {
2161 : : printf("\nSectag val err interrupt test case %d passed",
2162 : 0 : cur_td->test_idx);
2163 : 0 : err = 0;
2164 : : } else {
2165 : : printf("\nSectag val err interrupt test case %d failed",
2166 : 0 : cur_td->test_idx);
2167 : : err = -1;
2168 : : }
2169 : 0 : all_err += err;
2170 : : }
2171 : 0 : rte_eth_dev_callback_unregister(port_id, RTE_ETH_EVENT_MACSEC,
2172 : : test_macsec_event_callback, &err_vector);
2173 : :
2174 : 0 : printf("\n%s: Success: %d, Failure: %d, Skipped: %d\n", __func__,
2175 : 0 : size + all_err - skipped, -all_err, skipped);
2176 [ # # ]: 0 : return skipped > 0 ? TEST_SKIPPED : all_err;
2177 : : }
2178 : :
2179 : : static int
2180 : 0 : test_inline_macsec_rekey_tx(void)
2181 : : {
2182 : : const struct mcs_test_vector *cur_td;
2183 : 0 : struct mcs_test_opts opts = {0};
2184 : : int err, all_err = 0;
2185 : : int skipped = 0;
2186 : : int i, size;
2187 : :
2188 : 0 : opts.val_frames = RTE_SECURITY_MACSEC_VALIDATE_STRICT;
2189 : 0 : opts.protect_frames = true;
2190 : 0 : opts.encrypt = true;
2191 : 0 : opts.sa_in_use = 1;
2192 : 0 : opts.nb_td = 1;
2193 : 0 : opts.sectag_insert_mode = 1;
2194 : 0 : opts.mtu = RTE_ETHER_MTU;
2195 : 0 : opts.rekey_en = 1;
2196 : :
2197 : : size = (sizeof(list_mcs_rekey_vectors) / sizeof((list_mcs_rekey_vectors)[0]));
2198 : :
2199 [ # # ]: 0 : for (i = 0; i < size; i++) {
2200 : 0 : cur_td = &list_mcs_rekey_vectors[i];
2201 : 0 : opts.rekey_td = &list_mcs_rekey_vectors[++i];
2202 : 0 : err = test_macsec(&cur_td, MCS_ENCAP, &opts);
2203 [ # # ]: 0 : if (err == TEST_SKIPPED) {
2204 : : printf("Tx hw rekey test case %d skipped\n", i);
2205 : 0 : skipped += 1;
2206 : : err = 0;
2207 [ # # ]: 0 : } else if (err) {
2208 : : printf("Tx hw rekey test case %d failed\n", i);
2209 : : err = -1;
2210 : : } else {
2211 : : printf("Tx hw rekey test case %d passed\n", i);
2212 : : err = 0;
2213 : : }
2214 : 0 : all_err += err;
2215 : : }
2216 : :
2217 : 0 : printf("\n%s: Success: %d, Failure: %d, Skipped: %d\n", __func__,
2218 : 0 : size / 2 + all_err - skipped, -all_err, skipped);
2219 [ # # ]: 0 : return skipped > 0 ? TEST_SKIPPED : all_err;
2220 : : }
2221 : :
2222 : : static int
2223 : 0 : test_inline_macsec_rekey_rx(void)
2224 : : {
2225 : : const struct mcs_test_vector *cur_td;
2226 : 0 : struct mcs_test_opts opts = {0};
2227 : : int err, all_err = 0;
2228 : : int skipped = 0;
2229 : : int i, size;
2230 : :
2231 : 0 : opts.val_frames = RTE_SECURITY_MACSEC_VALIDATE_STRICT;
2232 : 0 : opts.protect_frames = true;
2233 : 0 : opts.sa_in_use = 1;
2234 : 0 : opts.nb_td = 1;
2235 : 0 : opts.sectag_insert_mode = 1;
2236 : 0 : opts.mtu = RTE_ETHER_MTU;
2237 : 0 : opts.rekey_en = 1;
2238 : :
2239 : : size = (sizeof(list_mcs_rekey_vectors) / sizeof((list_mcs_rekey_vectors)[0]));
2240 [ # # ]: 0 : for (i = 0; i < size; i++) {
2241 : 0 : cur_td = &list_mcs_rekey_vectors[i];
2242 : 0 : opts.rekey_td = &list_mcs_rekey_vectors[++i];
2243 : 0 : err = test_macsec(&cur_td, MCS_DECAP, &opts);
2244 [ # # ]: 0 : if (err == TEST_SKIPPED) {
2245 : : printf("Rx rekey test case %d skipped\n", i);
2246 : 0 : skipped += 1;
2247 : : err = 0;
2248 [ # # ]: 0 : } else if (err) {
2249 : : printf("Rx rekey test case %d failed\n", i);
2250 : : err = -1;
2251 : : } else {
2252 : : printf("Rx rekey test case %d passed\n", i);
2253 : : err = 0;
2254 : : }
2255 : 0 : all_err += err;
2256 : : }
2257 : :
2258 : 0 : printf("\n%s: Success: %d, Failure: %d, Skipped: %d\n", __func__,
2259 : 0 : size / 2 + all_err - skipped, -all_err, skipped);
2260 [ # # ]: 0 : return skipped > 0 ? TEST_SKIPPED : all_err;
2261 : : }
2262 : :
2263 : : static int
2264 : 0 : test_inline_macsec_anti_replay(void)
2265 : : {
2266 : : const struct mcs_test_vector *cur_td;
2267 : 0 : struct mcs_test_opts opts = {0};
2268 : 0 : uint16_t replay_win_sz[2] = {32, 0};
2269 : : int err, all_err = 0;
2270 : : int skipped = 0;
2271 : : int i, size;
2272 : : int j;
2273 : :
2274 : 0 : opts.val_frames = RTE_SECURITY_MACSEC_VALIDATE_STRICT;
2275 : 0 : opts.sa_in_use = 1;
2276 : 0 : opts.nb_td = 1;
2277 : 0 : opts.sectag_insert_mode = 1;
2278 : 0 : opts.replay_protect = 1;
2279 : :
2280 : : size = (sizeof(list_mcs_anti_replay_vectors) / sizeof((list_mcs_anti_replay_vectors)[0]));
2281 : :
2282 [ # # ]: 0 : for (j = 0; j < 2; j++) {
2283 : 0 : opts.replay_win_sz = replay_win_sz[j];
2284 : :
2285 [ # # ]: 0 : for (i = 0; i < size; i++) {
2286 : 0 : cur_td = &list_mcs_anti_replay_vectors[i];
2287 : 0 : opts.ar_td[0] = &list_mcs_anti_replay_vectors[++i];
2288 : 0 : opts.ar_td[1] = &list_mcs_anti_replay_vectors[++i];
2289 : 0 : opts.ar_td[2] = &list_mcs_anti_replay_vectors[++i];
2290 : 0 : err = test_macsec(&cur_td, MCS_DECAP, &opts);
2291 [ # # ]: 0 : if (err == TEST_SKIPPED) {
2292 : 0 : printf("Replay window: %u, Anti replay test "
2293 : : "case %d skipped\n", opts.replay_win_sz,
2294 : : i);
2295 : 0 : skipped += 1;
2296 : : err = 0;
2297 [ # # ]: 0 : } else if (err) {
2298 : 0 : printf("Replay window: %u, Anti replay test "
2299 : : "case %d failed\n", opts.replay_win_sz,
2300 : : i);
2301 : : err = -1;
2302 : : } else {
2303 : 0 : printf("Replay window: %u, Anti replay test "
2304 : : "case %d passed\n", opts.replay_win_sz,
2305 : : i);
2306 : : err = 0;
2307 : : }
2308 : 0 : all_err += err;
2309 : : }
2310 : : }
2311 : :
2312 : 0 : printf("\n%s: Success: %d, Failure: %d, Skipped: %d\n", __func__,
2313 : 0 : size / 2 + all_err - skipped, -all_err, skipped);
2314 [ # # ]: 0 : return skipped > 0 ? TEST_SKIPPED : all_err;
2315 : : }
2316 : :
2317 : : static int
2318 : 0 : ut_setup_inline_macsec(void)
2319 : : {
2320 : : int ret;
2321 : :
2322 : : /* Start device */
2323 : 0 : ret = rte_eth_dev_start(port_id);
2324 [ # # ]: 0 : if (ret < 0) {
2325 : 0 : printf("rte_eth_dev_start: err=%d, port=%d\n",
2326 : : ret, port_id);
2327 : 0 : return ret;
2328 : : }
2329 : : /* always enable promiscuous */
2330 : 0 : ret = rte_eth_promiscuous_enable(port_id);
2331 [ # # ]: 0 : if (ret != 0) {
2332 : 0 : printf("rte_eth_promiscuous_enable: err=%s, port=%d\n",
2333 : : rte_strerror(-ret), port_id);
2334 : 0 : return ret;
2335 : : }
2336 : :
2337 : 0 : check_all_ports_link_status(1, RTE_PORT_ALL);
2338 : :
2339 : 0 : return 0;
2340 : : }
2341 : :
2342 : : static void
2343 : 0 : ut_teardown_inline_macsec(void)
2344 : : {
2345 : : uint16_t portid;
2346 : : int ret;
2347 : :
2348 : : /* port tear down */
2349 [ # # ]: 0 : RTE_ETH_FOREACH_DEV(portid) {
2350 : 0 : ret = rte_eth_dev_stop(portid);
2351 [ # # ]: 0 : if (ret != 0)
2352 : 0 : printf("rte_eth_dev_stop: err=%s, port=%u\n",
2353 : : rte_strerror(-ret), portid);
2354 : :
2355 : : }
2356 : 0 : }
2357 : :
2358 : : static int
2359 : 0 : inline_macsec_testsuite_setup(void)
2360 : : {
2361 : : uint16_t nb_rxd;
2362 : : uint16_t nb_txd;
2363 : : uint16_t nb_ports;
2364 : : int ret;
2365 : : uint16_t nb_rx_queue = 1, nb_tx_queue = 1;
2366 : :
2367 : : printf("Start inline MACsec test.\n");
2368 : :
2369 : 0 : nb_ports = rte_eth_dev_count_avail();
2370 [ # # ]: 0 : if (nb_ports < NB_ETHPORTS_USED) {
2371 : : printf("At least %u port(s) used for test\n",
2372 : : NB_ETHPORTS_USED);
2373 : 0 : return TEST_SKIPPED;
2374 : : }
2375 : :
2376 : 0 : ret = init_mempools(NB_MBUF);
2377 [ # # ]: 0 : if (ret)
2378 : : return ret;
2379 : :
2380 [ # # ]: 0 : if (tx_pkts_burst == NULL) {
2381 : 0 : tx_pkts_burst = (struct rte_mbuf **)rte_calloc("tx_buff",
2382 : : MAX_TRAFFIC_BURST,
2383 : : sizeof(void *),
2384 : : RTE_CACHE_LINE_SIZE);
2385 [ # # ]: 0 : if (!tx_pkts_burst)
2386 : : return TEST_FAILED;
2387 : :
2388 : 0 : rx_pkts_burst = (struct rte_mbuf **)rte_calloc("rx_buff",
2389 : : MAX_TRAFFIC_BURST,
2390 : : sizeof(void *),
2391 : : RTE_CACHE_LINE_SIZE);
2392 [ # # ]: 0 : if (!rx_pkts_burst)
2393 : : return TEST_FAILED;
2394 : : }
2395 : :
2396 : : printf("Generate %d packets\n", MAX_TRAFFIC_BURST);
2397 : :
2398 : : nb_rxd = RTE_TEST_RX_DESC_DEFAULT;
2399 : : nb_txd = RTE_TEST_TX_DESC_DEFAULT;
2400 : :
2401 : : /* configuring port 0 for the test is enough */
2402 : 0 : port_id = 0;
2403 : : /* port configure */
2404 : 0 : ret = rte_eth_dev_configure(port_id, nb_rx_queue,
2405 : : nb_tx_queue, &port_conf);
2406 [ # # ]: 0 : if (ret < 0) {
2407 : 0 : printf("Cannot configure device: err=%d, port=%d\n",
2408 : : ret, port_id);
2409 : 0 : return ret;
2410 : : }
2411 : 0 : ret = rte_eth_macaddr_get(port_id, &ports_eth_addr[port_id]);
2412 [ # # ]: 0 : if (ret < 0) {
2413 : 0 : printf("Cannot get mac address: err=%d, port=%d\n",
2414 : : ret, port_id);
2415 : 0 : return ret;
2416 : : }
2417 : 0 : printf("Port %u ", port_id);
2418 : 0 : print_ethaddr("Address:", &ports_eth_addr[port_id]);
2419 : : printf("\n");
2420 : :
2421 : : /* tx queue setup */
2422 : 0 : ret = rte_eth_tx_queue_setup(port_id, 0, nb_txd,
2423 : : SOCKET_ID_ANY, &tx_conf);
2424 [ # # ]: 0 : if (ret < 0) {
2425 : 0 : printf("rte_eth_tx_queue_setup: err=%d, port=%d\n",
2426 : : ret, port_id);
2427 : 0 : return ret;
2428 : : }
2429 : : /* rx queue steup */
2430 : 0 : ret = rte_eth_rx_queue_setup(port_id, 0, nb_rxd, SOCKET_ID_ANY,
2431 : : &rx_conf, mbufpool);
2432 [ # # ]: 0 : if (ret < 0) {
2433 : 0 : printf("rte_eth_rx_queue_setup: err=%d, port=%d\n",
2434 : : ret, port_id);
2435 : 0 : return ret;
2436 : : }
2437 : :
2438 : : return 0;
2439 : : }
2440 : :
2441 : : static void
2442 : 0 : inline_macsec_testsuite_teardown(void)
2443 : : {
2444 : : uint16_t portid;
2445 : : int ret;
2446 : :
2447 : : /* port tear down */
2448 [ # # ]: 0 : RTE_ETH_FOREACH_DEV(portid) {
2449 : 0 : ret = rte_eth_dev_reset(portid);
2450 [ # # ]: 0 : if (ret != 0)
2451 : 0 : printf("rte_eth_dev_reset: err=%s, port=%u\n",
2452 : : rte_strerror(-ret), port_id);
2453 : : }
2454 : 0 : rte_free(tx_pkts_burst);
2455 : 0 : rte_free(rx_pkts_burst);
2456 : 0 : }
2457 : :
2458 : :
2459 : : static struct unit_test_suite inline_macsec_testsuite = {
2460 : : .suite_name = "Inline MACsec Ethernet Device Unit Test Suite",
2461 : : .unit_test_cases = {
2462 : : TEST_CASE_NAMED_ST(
2463 : : "MACsec Encap + decap Multi flow",
2464 : : ut_setup_inline_macsec, ut_teardown_inline_macsec,
2465 : : test_inline_macsec_multi_flow),
2466 : : TEST_CASE_NAMED_ST(
2467 : : "MACsec encap(Cipher+Auth) known vector",
2468 : : ut_setup_inline_macsec, ut_teardown_inline_macsec,
2469 : : test_inline_macsec_encap_all),
2470 : : TEST_CASE_NAMED_ST(
2471 : : "MACsec decap(De-cipher+verify) known vector",
2472 : : ut_setup_inline_macsec, ut_teardown_inline_macsec,
2473 : : test_inline_macsec_decap_all),
2474 : : TEST_CASE_NAMED_ST(
2475 : : "MACsec auth only known vector",
2476 : : ut_setup_inline_macsec, ut_teardown_inline_macsec,
2477 : : test_inline_macsec_auth_only_all),
2478 : : TEST_CASE_NAMED_ST(
2479 : : "MACsec verify only known vector",
2480 : : ut_setup_inline_macsec, ut_teardown_inline_macsec,
2481 : : test_inline_macsec_verify_only_all),
2482 : : TEST_CASE_NAMED_ST(
2483 : : "MACsec encap + decap known vector",
2484 : : ut_setup_inline_macsec, ut_teardown_inline_macsec,
2485 : : test_inline_macsec_encap_decap_all),
2486 : : TEST_CASE_NAMED_ST(
2487 : : "MACsec auth + verify known vector",
2488 : : ut_setup_inline_macsec, ut_teardown_inline_macsec,
2489 : : test_inline_macsec_auth_verify_all),
2490 : : TEST_CASE_NAMED_ST(
2491 : : "MACsec Encap and decap with VLAN",
2492 : : ut_setup_inline_macsec, ut_teardown_inline_macsec,
2493 : : test_inline_macsec_with_vlan),
2494 : : TEST_CASE_NAMED_ST(
2495 : : "MACsec packet drop",
2496 : : ut_setup_inline_macsec, ut_teardown_inline_macsec,
2497 : : test_inline_macsec_pkt_drop),
2498 : : TEST_CASE_NAMED_ST(
2499 : : "MACsec untagged Rx",
2500 : : ut_setup_inline_macsec, ut_teardown_inline_macsec,
2501 : : test_inline_macsec_untagged_rx),
2502 : : TEST_CASE_NAMED_ST(
2503 : : "MACsec bad tag Rx",
2504 : : ut_setup_inline_macsec, ut_teardown_inline_macsec,
2505 : : test_inline_macsec_bad_tag_rx),
2506 : : TEST_CASE_NAMED_ST(
2507 : : "MACsec SA not in use",
2508 : : ut_setup_inline_macsec, ut_teardown_inline_macsec,
2509 : : test_inline_macsec_sa_not_in_use),
2510 : : TEST_CASE_NAMED_ST(
2511 : : "MACsec decap stats",
2512 : : ut_setup_inline_macsec, ut_teardown_inline_macsec,
2513 : : test_inline_macsec_decap_stats),
2514 : : TEST_CASE_NAMED_ST(
2515 : : "MACsec verify only stats",
2516 : : ut_setup_inline_macsec, ut_teardown_inline_macsec,
2517 : : test_inline_macsec_verify_only_stats),
2518 : : TEST_CASE_NAMED_ST(
2519 : : "MACsec pkts invalid stats",
2520 : : ut_setup_inline_macsec, ut_teardown_inline_macsec,
2521 : : test_inline_macsec_pkts_invalid_stats),
2522 : : TEST_CASE_NAMED_ST(
2523 : : "MACsec pkts unchecked stats",
2524 : : ut_setup_inline_macsec, ut_teardown_inline_macsec,
2525 : : test_inline_macsec_pkts_unchecked_stats),
2526 : : TEST_CASE_NAMED_ST(
2527 : : "MACsec out pkts untagged",
2528 : : ut_setup_inline_macsec, ut_teardown_inline_macsec,
2529 : : test_inline_macsec_out_pkts_untagged),
2530 : : TEST_CASE_NAMED_ST(
2531 : : "MACsec out pkts too long",
2532 : : ut_setup_inline_macsec, ut_teardown_inline_macsec,
2533 : : test_inline_macsec_out_pkts_toolong),
2534 : : TEST_CASE_NAMED_ST(
2535 : : "MACsec Encap stats",
2536 : : ut_setup_inline_macsec, ut_teardown_inline_macsec,
2537 : : test_inline_macsec_encap_stats),
2538 : : TEST_CASE_NAMED_ST(
2539 : : "MACsec auth only stats",
2540 : : ut_setup_inline_macsec, ut_teardown_inline_macsec,
2541 : : test_inline_macsec_auth_only_stats),
2542 : : TEST_CASE_NAMED_ST(
2543 : : "MACsec interrupts all",
2544 : : ut_setup_inline_macsec, ut_teardown_inline_macsec,
2545 : : test_inline_macsec_interrupts_all),
2546 : : TEST_CASE_NAMED_ST(
2547 : : "MACsec re-key Tx",
2548 : : ut_setup_inline_macsec, ut_teardown_inline_macsec,
2549 : : test_inline_macsec_rekey_tx),
2550 : : TEST_CASE_NAMED_ST(
2551 : : "MACsec re-key Rx",
2552 : : ut_setup_inline_macsec, ut_teardown_inline_macsec,
2553 : : test_inline_macsec_rekey_rx),
2554 : : TEST_CASE_NAMED_ST(
2555 : : "MACsec anti-replay",
2556 : : ut_setup_inline_macsec, ut_teardown_inline_macsec,
2557 : : test_inline_macsec_anti_replay),
2558 : :
2559 : : TEST_CASES_END() /**< NULL terminate unit test array */
2560 : : },
2561 : : };
2562 : :
2563 : : static int
2564 : 0 : test_inline_macsec(void)
2565 : : {
2566 : 0 : inline_macsec_testsuite.setup = inline_macsec_testsuite_setup;
2567 : 0 : inline_macsec_testsuite.teardown = inline_macsec_testsuite_teardown;
2568 : 0 : return unit_test_suite_runner(&inline_macsec_testsuite);
2569 : : }
2570 : :
2571 : : #endif /* !RTE_EXEC_ENV_WINDOWS */
2572 : :
2573 : 251 : REGISTER_TEST_COMMAND(inline_macsec_autotest, test_inline_macsec);
|
