Provided by: dpdk-doc_24.11.2-2_all bug

NAME

       rte_gro.h

SYNOPSIS

       #include <stdint.h>
       #include <rte_mbuf.h>

   Data Structures
       struct rte_gro_param

   Macros
       #define RTE_GRO_MAX_BURST_ITEM_NUM   128U
       #define RTE_GRO_TYPE_MAX_NUM   64
       #define RTE_GRO_TYPE_SUPPORT_NUM   2
       #define RTE_GRO_TCP_IPV4   (1ULL << RTE_GRO_TCP_IPV4_INDEX)
       #define RTE_GRO_IPV4_VXLAN_TCP_IPV4   (1ULL << RTE_GRO_IPV4_VXLAN_TCP_IPV4_INDEX)
       #define RTE_GRO_UDP_IPV4   (1ULL << RTE_GRO_UDP_IPV4_INDEX)
       #define RTE_GRO_IPV4_VXLAN_UDP_IPV4   (1ULL << RTE_GRO_IPV4_VXLAN_UDP_IPV4_INDEX)
       #define RTE_GRO_TCP_IPV6   (1ULL << RTE_GRO_TCP_IPV6_INDEX)

   Functions
       void * rte_gro_ctx_create (const struct rte_gro_param *param)
       void rte_gro_ctx_destroy (void *ctx)
       uint16_t rte_gro_reassemble_burst (struct rte_mbuf **pkts, uint16_t nb_pkts, const struct rte_gro_param
           *param)
       uint16_t rte_gro_reassemble (struct rte_mbuf **pkts, uint16_t nb_pkts, void *ctx)
       uint16_t rte_gro_timeout_flush (void *ctx, uint64_t timeout_cycles, uint64_t gro_types, struct rte_mbuf
           **out, uint16_t max_nb_out)
       uint64_t rte_gro_get_pkt_count (void *ctx)

Detailed Description

       Interface to GRO library

       Definition in file rte_gro.h.

Macro Definition Documentation

   #define RTE_GRO_MAX_BURST_ITEM_NUM   128U
       the max number of packets that rte_gro_reassemble_burst() can process in each invocation.

       Definition at line 23 of file rte_gro.h.

   #define RTE_GRO_TYPE_MAX_NUM   64
       the max number of supported GRO types

       Definition at line 25 of file rte_gro.h.

   #define RTE_GRO_TYPE_SUPPORT_NUM   2
       the number of currently supported GRO types

       Definition at line 27 of file rte_gro.h.

   #define RTE_GRO_TCP_IPV4   (1ULL << RTE_GRO_TCP_IPV4_INDEX)
       TCP/IPv4 GRO flag

       Definition at line 31 of file rte_gro.h.

   #define RTE_GRO_IPV4_VXLAN_TCP_IPV4   (1ULL << RTE_GRO_IPV4_VXLAN_TCP_IPV4_INDEX)
       VxLAN TCP/IPv4 GRO flag.

       Definition at line 34 of file rte_gro.h.

   #define RTE_GRO_UDP_IPV4   (1ULL << RTE_GRO_UDP_IPV4_INDEX)
       UDP/IPv4 GRO flag

       Definition at line 37 of file rte_gro.h.

   #define RTE_GRO_IPV4_VXLAN_UDP_IPV4   (1ULL << RTE_GRO_IPV4_VXLAN_UDP_IPV4_INDEX)
       VxLAN UDP/IPv4 GRO flag.

       Definition at line 40 of file rte_gro.h.

   #define RTE_GRO_TCP_IPV6   (1ULL << RTE_GRO_TCP_IPV6_INDEX)
       TCP/IPv6 GRO flag.

       Definition at line 43 of file rte_gro.h.

Function Documentation

   void * rte_gro_ctx_create (const struct rte_gro_param * param)
       Warning
           EXPERIMENTAL: this API may change without prior notice

       This function create a GRO context object, which is used to merge packets in rte_gro_reassemble().

       Parameters
           param applications use it to pass needed parameters to create a GRO context object.

       Returns
           if create successfully, return a pointer which points to the GRO context object. Otherwise, return
           NULL.

   void rte_gro_ctx_destroy (void * ctx)
       Warning
           EXPERIMENTAL: this API may change without prior notice

       This function destroys a GRO context object.

       Parameters
           ctx pointer points to a GRO context object.

   uint16_t rte_gro_reassemble_burst (struct rte_mbuf ** pkts, uint16_t nb_pkts, const struct rte_gro_param *
       param)
       This is one of the main reassembly APIs, which merges numbers of packets at a time. It doesn't check if
       input packets have correct checksums and doesn't re-calculate checksums for merged packets. It assumes
       the packets are complete (i.e., MF==0 && frag_off==0), when IP fragmentation is possible (i.e., DF==0).
       The GROed packets are returned as soon as the function finishes.

       Parameters
           pkts Pointer array pointing to the packets to reassemble. Besides, it keeps MBUF addresses for the
           GROed packets.
           nb_pkts The number of packets to reassemble
           param Application-determined parameters for reassembling packets.

       Returns
           The number of packets after been GROed. If no packets are merged, the return value is equals to
           nb_pkts.

   uint16_t rte_gro_reassemble (struct rte_mbuf ** pkts, uint16_t nb_pkts, void * ctx)
       Warning
           EXPERIMENTAL: this API may change without prior notice

       Reassembly function, which tries to merge input packets with the existed packets in the reassembly tables
       of a given GRO context. It doesn't check if input packets have correct checksums and doesn't re-calculate
       checksums for merged packets. Additionally, it assumes the packets are complete (i.e., MF==0 &&
       frag_off==0), when IP fragmentation is possible (i.e., DF==0).

       If the input packets have invalid parameters (e.g. no data payload, unsupported GRO types), they are
       returned to applications. Otherwise, they are either merged or inserted into the table. Applications need
       to flush packets from the tables by flush API, if they want to get the GROed packets.

       Parameters
           pkts Packets to reassemble. It's also used to store the unprocessed packets.
           nb_pkts The number of packets to reassemble
           ctx GRO context object pointer

       Returns
           The number of unprocessed packets.

   uint16_t rte_gro_timeout_flush (void * ctx, uint64_t timeout_cycles, uint64_t gro_types, struct rte_mbuf **
       out, uint16_t max_nb_out)
       Warning
           EXPERIMENTAL: this API may change without prior notice

       This function flushes the timeout packets from the reassembly tables of desired GRO types. The max number
       of flushed packets is the element number of 'out'.

       Additionally, the flushed packets may have incorrect checksums, since this function doesn't re-calculate
       checksums for merged packets.

       Parameters
           ctx GRO context object pointer.
           timeout_cycles The max TTL for packets in reassembly tables, measured in nanosecond.
           gro_types This function flushes packets whose GRO types are specified by gro_types.
           out Pointer array used to keep flushed packets.
           max_nb_out The element number of 'out'. It's also the max number of timeout packets that can be
           flushed finally.

       Returns
           The number of flushed packets.

   uint64_t rte_gro_get_pkt_count (void * ctx)
       Warning
           EXPERIMENTAL: this API may change without prior notice

       This function returns the number of packets in all reassembly tables of a given GRO context.

       Parameters
           ctx GRO context object pointer.

       Returns
           The number of packets in the tables.

Author

       Generated automatically by Doxygen for DPDK from the source code.

DPDK                                             Version 24.11.2                                    rte_gro.h(3)