rte_ip_frag.h(3)

📦 version 26.03, in nixos 26.05, nixpkgs unstable

🌸 NAME 🌸

Okay bestie, this is rte_ip_frag.h(3) from the Library Functions Manual, and it's literally the RTE IP Fragmentation and Reassembly page. No cap, it's giving low-level packet-splitting main character energy 💅✨.

✨ SYNOPSIS ✨

First, the include glow-up:

#include <stdint.h>
#include <stdio.h>
#include <rte_config.h>
#include <rte_malloc.h>
#include <rte_memory.h>
#include <rte_ip.h>
#include <rte_byteorder.h>

🧸 Data Structures 🧸

The one and only struct:

struct rte_ip_frag_death_row

🎀 Macros 🎀

These are the macros, bestie:

#define RTE_IP_FRAG_DEATH_ROW_LEN   32
#define RTE_IP_FRAG_DEATH_ROW_MBUF_LEN   (RTE_IP_FRAG_DEATH_ROW_LEN *
    (RTE_LIBRTE_IP_FRAG_MAX_FRAG + 1))
Obsolete macros, kept here for compatibility reasons. Will be deprecated/removed in future DPDK releases.
#define IP_FRAG_DEATH_ROW_LEN   RTE_IP_FRAG_DEATH_ROW_LEN
#define IP_FRAG_DEATH_ROW_MBUF_LEN   RTE_IP_FRAG_DEATH_ROW_MBUF_LEN
#define ipv6_extension_fragment   rte_ipv6_fragment_ext

🛠️ Functions 🛠️

Here's the whole function lineup, iconically long and fully intact:

struct rte_ip_frag_tbl * rte_ip_frag_table_create (uint32_t bucket_num,
    uint32_t bucket_entries, uint32_t max_entries, uint64_t max_cycles,
    int socket_id)
void rte_ip_frag_table_destroy (struct rte_ip_frag_tbl *tbl)
int32_t rte_ipv6_fragment_packet (struct rte_mbuf *pkt_in, struct
    rte_mbuf **pkts_out, uint16_t nb_pkts_out, uint16_t mtu_size, struct
    rte_mempool *pool_direct, struct rte_mempool *pool_indirect)
struct rte_mbuf * rte_ipv6_frag_reassemble_packet (struct
    rte_ip_frag_tbl *tbl, struct rte_ip_frag_death_row *dr, struct
    rte_mbuf *mb, uint64_t tms, struct rte_ipv6_hdr *ip_hdr, struct
    rte_ipv6_fragment_ext *frag_hdr)
static struct rte_ipv6_fragment_ext *
    rte_ipv6_frag_get_ipv6_fragment_header (struct rte_ipv6_hdr *hdr)
int32_t rte_ipv4_fragment_packet (struct rte_mbuf *pkt_in, struct
    rte_mbuf **pkts_out, uint16_t nb_pkts_out, uint16_t mtu_size, struct
    rte_mempool *pool_direct, struct rte_mempool *pool_indirect)
int32_t rte_ipv4_fragment_copy_nonseg_packet (struct rte_mbuf *pkt_in,
    struct rte_mbuf **pkts_out, uint16_t nb_pkts_out, uint16_t mtu_size,
    struct rte_mempool *pool_direct)
struct rte_mbuf * rte_ipv4_frag_reassemble_packet (struct
    rte_ip_frag_tbl *tbl, struct rte_ip_frag_death_row *dr, struct
    rte_mbuf *mb, uint64_t tms, struct rte_ipv4_hdr *ip_hdr)
static int rte_ipv4_frag_pkt_is_fragmented (const struct rte_ipv4_hdr
    *hdr)
void rte_ip_frag_free_death_row (struct rte_ip_frag_death_row *dr,
    uint32_t prefetch)
void rte_ip_frag_table_statistics_dump (FILE *f, const struct
    rte_ip_frag_tbl *tbl)
void rte_ip_frag_table_del_expired_entries (struct rte_ip_frag_tbl *tbl,
    struct rte_ip_frag_death_row *dr, uint64_t tms)

🌈 Detailed Description 🌈

RTE IP Fragmentation and Reassembly — this is the implementation of IP packet fragmentation and reassembly. Definition in file rte_ip_frag.h.

🍓 Macro Definition Documentation 🍓

💖 RTE_IP_FRAG_DEATH_ROW_LEN = 32 💖

#define RTE_IP_FRAG_DEATH_ROW_LEN   32

Death row size (in packets).

Definition at line 31 of file rte_ip_frag.h.

💖 RTE_IP_FRAG_DEATH_ROW_MBUF_LEN 💖

#define RTE_IP_FRAG_DEATH_ROW_MBUF_LEN   (RTE_IP_FRAG_DEATH_ROW_LEN *
    (RTE_LIBRTE_IP_FRAG_MAX_FRAG + 1))

Death row size in mbufs.

Definition at line 34 of file rte_ip_frag.h.

🫶 IP_FRAG_DEATH_ROW_LEN 🫶

Obsolete.

#define IP_FRAG_DEATH_ROW_LEN   RTE_IP_FRAG_DEATH_ROW_LEN

Definition at line 298 of file rte_ip_frag.h.

🫶 IP_FRAG_DEATH_ROW_MBUF_LEN 🫶

Obsolete.

#define IP_FRAG_DEATH_ROW_MBUF_LEN   RTE_IP_FRAG_DEATH_ROW_MBUF_LEN

Definition at line 300 of file rte_ip_frag.h.

🫶 ipv6_extension_fragment 🫶

Obsolete.

#define ipv6_extension_fragment   rte_ipv6_fragment_ext

Definition at line 302 of file rte_ip_frag.h.

🔥 Function Documentation 🔥

🌟 rte_ip_frag_table_create 🌟

struct rte_ip_frag_tbl * rte_ip_frag_table_create (uint32_t bucket_num,
    uint32_t bucket_entries, uint32_t max_entries, uint64_t max_cycles, int
    socket_id)

Creates a shiny new IP fragmentation table. Iconic.

Parameters:

  • bucket_num — number of buckets in the hash table.
  • bucket_entries — number of entries per bucket (that's hash associativity, iykyk). Should be power of two.
  • max_entries — maximum number of entries that could be stored in the table. The value should be less or equal then bucket_num * bucket_entries.
  • max_cycles — maximum TTL in cycles for each fragmented packet.
  • socket_id — the socket_id argument is the socket identifier in the case of NUMA. The value can be SOCKET_ID_ANY if there is no NUMA constraints.

Returns: the pointer to the new allocated fragmentation table, on success. NULL on error.

🌟 rte_ip_frag_table_destroy 🌟

void rte_ip_frag_table_destroy (struct rte_ip_frag_tbl * tbl)

Frees an allocated IP fragmentation table. Bye bestie 💖.

Parameters:

  • tbl — fragmentation table to free.

🌟 rte_ipv6_fragment_packet 🌟

int32_t rte_ipv6_fragment_packet (struct rte_mbuf * pkt_in, struct rte_mbuf
    ** pkts_out, uint16_t nb_pkts_out, uint16_t mtu_size, struct rte_mempool
    * pool_direct, struct rte_mempool * pool_indirect)

This function implements the fragmentation of IPv6 packets. Splitting the vibe, IPv6 style.

Parameters:

  • pkt_in — the input packet.
  • pkts_out — array storing the output fragments.
  • nb_pkts_out — number of fragments.
  • mtu_size — size in bytes of the Maximum Transfer Unit (MTU) for the outgoing IPv6 datagrams. This value includes the size of the IPv6 header.
  • pool_direct — MBUF pool used for allocating direct buffers for the output fragments.
  • pool_indirect — MBUF pool used for allocating indirect buffers for the output fragments.

Returns: upon successful completion — number of output fragments placed in the pkts_out array. Otherwise — (-1) * errno.

🌟 rte_ipv6_frag_reassemble_packet 🌟

struct rte_mbuf * rte_ipv6_frag_reassemble_packet (struct rte_ip_frag_tbl *
    tbl, struct rte_ip_frag_death_row * dr, struct rte_mbuf * mb, uint64_t
    tms, struct rte_ipv6_hdr * ip_hdr, struct rte_ipv6_fragment_ext *
    frag_hdr)

This function implements reassembly of fragmented IPv6 packets. Incoming mbuf should have its l2_len/l3_len fields setup correctly.

Parameters:

  • tbl — table where to lookup/add the fragmented packet.
  • dr — death row to free buffers to.
  • mb — incoming mbuf with IPv6 fragment.
  • tms — fragment arrival timestamp.
  • ip_hdr — pointer to the IPv6 header.
  • frag_hdr — pointer to the IPv6 fragment extension header.

Returns: pointer to mbuf for reassembled packet, or NULL if:

  • an error occurred.
  • not all fragments of the packet are collected yet.

🌟 rte_ipv6_frag_get_ipv6_fragment_header 🌟

struct rte_ipv6_fragment_ext * rte_ipv6_frag_get_ipv6_fragment_header
    (struct rte_ipv6_hdr * hdr) [inline],  [static]

Returns a pointer to the packet's fragment header, if found. Heads up bestie: it only looks at the extension header that's right after the fixed IPv6 header, and doesn't follow the whole chain of extension headers. Very "first glance only" energy.

Parameters:

  • hdr — pointer to the IPv6 header.

Returns: pointer to the IPv6 fragment extension header, or NULL if it's not present.

Definition at line 143 of file rte_ip_frag.h.

🌟 rte_ipv4_fragment_packet 🌟

int32_t rte_ipv4_fragment_packet (struct rte_mbuf * pkt_in, struct rte_mbuf
    ** pkts_out, uint16_t nb_pkts_out, uint16_t mtu_size, struct rte_mempool
    * pool_direct, struct rte_mempool * pool_indirect)

IPv4 fragmentation. This function implements the fragmentation of IPv4 packets.

Parameters:

  • pkt_in — the input packet.
  • pkts_out — array storing the output fragments.
  • nb_pkts_out — number of fragments.
  • mtu_size — size in bytes of the Maximum Transfer Unit (MTU) for the outgoing IPv4 datagrams. This value includes the size of the IPv4 header.
  • pool_direct — MBUF pool used for allocating direct buffers for the output fragments.
  • pool_indirect — MBUF pool used for allocating indirect buffers for the output fragments.

Returns: upon successful completion — number of output fragments placed in the pkts_out array. Otherwise — (-1) * errno.

🌟 rte_ipv4_fragment_copy_nonseg_packet 🌟

int32_t rte_ipv4_fragment_copy_nonseg_packet (struct rte_mbuf * pkt_in,
    struct rte_mbuf ** pkts_out, uint16_t nb_pkts_out, uint16_t mtu_size,
    struct rte_mempool * pool_direct)

IPv4 fragmentation by copy. This function implements the fragmentation of IPv4 packets by copy non-segmented mbuf. It's mainly used to adapt Tx MBUF_FAST_FREE offload.

MBUF_FAST_FREE: device supports optimization for fast release of mbufs. When set, application must guarantee that per-queue all mbufs comes from the same mempool, has refcnt = 1, direct and non-segmented.

Parameters:

  • pkt_in — the input packet.
  • pkts_out — array storing the output fragments.
  • nb_pkts_out — number of fragments.
  • mtu_size — size in bytes of the Maximum Transfer Unit (MTU) for the outgoing IPv4 datagrams. This value includes the size of the IPv4 header.
  • pool_direct — MBUF pool used for allocating direct buffers for the output fragments.

Returns: upon successful completion — number of output fragments placed in the pkts_out array. Otherwise — (-1) * errno.

🌟 rte_ipv4_frag_reassemble_packet 🌟

struct rte_mbuf * rte_ipv4_frag_reassemble_packet (struct rte_ip_frag_tbl *
    tbl, struct rte_ip_frag_death_row * dr, struct rte_mbuf * mb, uint64_t
    tms, struct rte_ipv4_hdr * ip_hdr)

This function implements reassembly of fragmented IPv4 packets. Incoming mbufs should have its l2_len/l3_len fields setup correctly.

Parameters:

  • tbl — table where to lookup/add the fragmented packet.
  • dr — death row to free buffers to.
  • mb — incoming mbuf with IPv4 fragment.
  • tms — fragment arrival timestamp.
  • ip_hdr — pointer to the IPV4 header inside the fragment.

Returns: pointer to mbuf for reassembled packet, or NULL if:

  • an error occurred.
  • not all fragments of the packet are collected yet.

🌟 rte_ipv4_frag_pkt_is_fragmented 🌟

int rte_ipv4_frag_pkt_is_fragmented (const struct rte_ipv4_hdr * hdr)
    [inline],  [static]

Checks if the IPv4 packet is fragmented. Vibe check for fragments 🔍.

Parameters:

  • hdr — IPv4 header of the packet.

Returns: 1 if fragmented, 0 if not fragmented.

Definition at line 246 of file rte_ip_frag.h.

🌟 rte_ip_frag_free_death_row 🌟

void rte_ip_frag_free_death_row (struct rte_ip_frag_death_row * dr, uint32_t
    prefetch)

Frees mbufs on a given death row. Dramatic name, very practical job.

Parameters:

  • dr — death row to free mbufs in.
  • prefetch — how many buffers to prefetch before freeing.

🌟 rte_ip_frag_table_statistics_dump 🌟

void rte_ip_frag_table_statistics_dump (FILE * f, const struct
    rte_ip_frag_tbl * tbl)

Dumps fragmentation table statistics to a file.

Parameters:

  • f — file to dump statistics to.
  • tbl — fragmentation table to dump statistics from.

🌟 rte_ip_frag_table_del_expired_entries 🌟

void rte_ip_frag_table_del_expired_entries (struct rte_ip_frag_tbl * tbl,
    struct rte_ip_frag_death_row * dr, uint64_t tms)

Deletes expired fragments. Cleanup era ✨.

Parameters:

  • tbl — table to delete expired fragments from.
  • dr — death row to free buffers to.
  • tms — current timestamp.

👑 Author 👑

Generated automatically by Doxygen for DPDK from the source code.

Okay bestie, that's the whole rte_ip_frag.h(3) situation 💖. This page is from DPDK, Version 26.03.0, and the cute little footer tag is rte_ip_frag.h(3). Slay your fragmentation safely, periodt 🌈✨🎀.

📦 where this page comes from