test/crypto: skip validation of head/tailroom used by PMD

[dpdk.git] / examples / ipsec-secgw / ipsec-secgw.c

diff --git a/examples/ipsec-secgw/ipsec-secgw.c b/examples/ipsec-secgw/ipsec-secgw.c
index bc466f7..ff576eb 100644 (file)
--- a/examples/ipsec-secgw/ipsec-secgw.c
+++ b/examples/ipsec-secgw/ipsec-secgw.c
@@ -40,6 +40,7 @@
 #include <rte_hash.h>
 #include <rte_jhash.h>
 #include <rte_cryptodev.h>
+#include <rte_security.h>
 
 #include "ipsec.h"
 #include "parser.h"
@@ -198,7 +199,6 @@ static struct rte_eth_conf port_conf = {
                .split_hdr_size = 0,
                .offloads = DEV_RX_OFFLOAD_CHECKSUM |
                            DEV_RX_OFFLOAD_CRC_STRIP,
-               .ignore_offload_bitfield = 1,
        },
        .rx_adv_conf = {
                .rss_conf = {
@@ -1389,7 +1389,7 @@ cryptodevs_init(void)
 
        uint32_t max_sess_sz = 0, sess_sz;
        for (cdev_id = 0; cdev_id < rte_cryptodev_count(); cdev_id++) {
-               sess_sz = rte_cryptodev_get_private_session_size(cdev_id);
+               sess_sz = rte_cryptodev_sym_get_private_session_size(cdev_id);
                if (sess_sz > max_sess_sz)
                        max_sess_sz = sess_sz;
        }
@@ -1439,6 +1439,12 @@ cryptodevs_init(void)
                dev_conf.socket_id = rte_cryptodev_socket_id(cdev_id);
                dev_conf.nb_queue_pairs = qp;
 
+               uint32_t dev_max_sess = cdev_info.sym.max_nb_sessions;
+               if (dev_max_sess != 0 && dev_max_sess < (CDEV_MP_NB_OBJS / 2))
+                       rte_exit(EXIT_FAILURE,
+                               "Device does not support at least %u "
+                               "sessions", CDEV_MP_NB_OBJS / 2);
+
                if (!socket_ctx[dev_conf.socket_id].session_pool) {
                        char mp_name[RTE_MEMPOOL_NAMESIZE];
                        struct rte_mempool *sess_mp;
@@ -1565,6 +1571,18 @@ port_init(uint16_t portid)
        if (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_MBUF_FAST_FREE)
                local_port_conf.txmode.offloads |=
                        DEV_TX_OFFLOAD_MBUF_FAST_FREE;
+
+       local_port_conf.rx_adv_conf.rss_conf.rss_hf &=
+               dev_info.flow_type_rss_offloads;
+       if (local_port_conf.rx_adv_conf.rss_conf.rss_hf !=
+                       port_conf.rx_adv_conf.rss_conf.rss_hf) {
+               printf("Port %u modified RSS hash function based on hardware support,"
+                       "requested:%#"PRIx64" configured:%#"PRIx64"\n",
+                       portid,
+                       port_conf.rx_adv_conf.rss_conf.rss_hf,
+                       local_port_conf.rx_adv_conf.rss_conf.rss_hf);
+       }
+
        ret = rte_eth_dev_configure(portid, nb_rx_queue, nb_tx_queue,
                        &local_port_conf);
        if (ret < 0)
@@ -1591,7 +1609,6 @@ port_init(uint16_t portid)
                printf("Setup txq=%u,%d,%d\n", lcore_id, tx_queueid, socket_id);
 
                txconf = &dev_info.default_txconf;
-               txconf->txq_flags = ETH_TXQ_FLAGS_IGNORE;
                txconf->offloads = local_port_conf.txmode.offloads;
 
                ret = rte_eth_tx_queue_setup(portid, tx_queueid, nb_txd,
@@ -1650,6 +1667,61 @@ pool_init(struct socket_ctx *ctx, int32_t socket_id, uint32_t nb_mbuf)
                printf("Allocated mbuf pool on socket %d\n", socket_id);
 }
 
+static inline int
+inline_ipsec_event_esn_overflow(struct rte_security_ctx *ctx, uint64_t md)
+{
+       struct ipsec_sa *sa;
+
+       /* For inline protocol processing, the metadata in the event will
+        * uniquely identify the security session which raised the event.
+        * Application would then need the userdata it had registered with the
+        * security session to process the event.
+        */
+
+       sa = (struct ipsec_sa *)rte_security_get_userdata(ctx, md);
+
+       if (sa == NULL) {
+               /* userdata could not be retrieved */
+               return -1;
+       }
+
+       /* Sequence number over flow. SA need to be re-established */
+       RTE_SET_USED(sa);
+       return 0;
+}
+
+static int
+inline_ipsec_event_callback(uint16_t port_id, enum rte_eth_event_type type,
+                void *param, void *ret_param)
+{
+       uint64_t md;
+       struct rte_eth_event_ipsec_desc *event_desc = NULL;
+       struct rte_security_ctx *ctx = (struct rte_security_ctx *)
+                                       rte_eth_dev_get_sec_ctx(port_id);
+
+       RTE_SET_USED(param);
+
+       if (type != RTE_ETH_EVENT_IPSEC)
+               return -1;
+
+       event_desc = ret_param;
+       if (event_desc == NULL) {
+               printf("Event descriptor not set\n");
+               return -1;
+       }
+
+       md = event_desc->metadata;
+
+       if (event_desc->subtype == RTE_ETH_EVENT_IPSEC_ESN_OVERFLOW)
+               return inline_ipsec_event_esn_overflow(ctx, md);
+       else if (event_desc->subtype >= RTE_ETH_EVENT_IPSEC_MAX) {
+               printf("Invalid IPsec event reported\n");
+               return -1;
+       }
+
+       return -1;
+}
+
 int32_t
 main(int32_t argc, char **argv)
 {
@@ -1735,6 +1807,9 @@ main(int32_t argc, char **argv)
                 */
                if (promiscuous_on)
                        rte_eth_promiscuous_enable(portid);
+
+               rte_eth_dev_callback_register(portid,
+                       RTE_ETH_EVENT_IPSEC, inline_ipsec_event_callback, NULL);
        }
 
        check_all_ports_link_status(enabled_port_mask);