rte_ip_frag.h(3)

📦
version 25.11.3 · 11 versions
, in ubuntu resolute, ubuntu stonking

💖 rte_ip_frag.h — like, the manual page, bestie 💖

Ok so this is rte_ip_frag.h(3), and it lives in the Library Functions Manual section of your friendly neighborhood man pages (section 3, functions, you know the vibe). Grab a snack, we're doing IP fragmentation and reassembly 🌸

✨ NAME ✨

rte_ip_frag.h — that's it, that's the name, no cap 💅

✨ SYNOPSIS ✨

First off, you gotta pull in the squad:

#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

  • struct rte_ip_frag_death_row — yes it's really called that, and yes it's iconic, we'll get to it 😭

🎀 Macros

  • #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.

bestie. these are on the way out. do not build your whole personality around them 🫶
#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

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 — that's the whole thing, that's the assignment 💖

Implementation of IP packet fragmentation and reassembly. Basically: you have one big packet, the wire says "no ❌ that's too thicc for me", so you chop it up, send the pieces, and glue them back together on the other side. It's giving arts and crafts but for networking 🎀

Definition in file rte_ip_frag.h.

🧚 Macro Definition Documentation 🧚

#define RTE_IP_FRAG_DEATH_ROW_LEN 32

death row size (in packets)

Definition at line 31 of file rte_ip_frag.h.

#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.

#define IP_FRAG_DEATH_ROW_LEN RTE_IP_FRAG_DEATH_ROW_LEN

Obsolete 🙈 (we 👏 said 👏 what 👏 we 👏 said)

Definition at line 298 of file rte_ip_frag.h.

#define IP_FRAG_DEATH_ROW_MBUF_LEN RTE_IP_FRAG_DEATH_ROW_MBUF_LEN

Obsolete 🙈

Definition at line 300 of file rte_ip_frag.h.

#define ipv6_extension_fragment rte_ipv6_fragment_ext

Obsolete 🙈

Definition at line 302 of file rte_ip_frag.h.

👑 Function Documentation 👑

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)

Create a new IP fragmentation table. Fresh table, fresh start, main character energy ✨

Parameters

  • bucket_num — Number of buckets in the hash table.
  • bucket_entries — Number of entries per bucket (e.g. hash associativity). Should be power of two. (bestie. a power of two. we're serious.)
  • 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. (sad girl hours 😭)

void rte_ip_frag_table_destroy (struct rte_ip_frag_tbl * tbl)

Free allocated IP fragmentation table. Let it go, let it gooo 🦋

Parameters

  • tbl — Fragmentation table to free.

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. Chop chop 🔪✨

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. (yes, the header is part of the math, don't come for me 👑)
  • 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. 💀

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. (lowkey non-negotiable, set them up bestie 🫶)

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. (the group chat is still typing… ⏳)

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

Return a pointer to the packet's fragment header, if found. 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. (it's a one-glance girl, not a deep-dive girl 💅)

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.

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. 💀

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. (we're copying, we're not sharing, ok?)

This function implements the fragmentation of IPv4 packets by copy non-segmented mbuf. This function is 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.

note the missing pool_indirect in this one's signature — that's not a typo, that's just how she is 🎀

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. 💀

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. (spelled exactly like that in the source, and we respect it 💜)

Returns

Pointer to mbuf for reassembled packet, or NULL if:

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

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

Check if the IPv4 packet is fragmented. Vibe check but 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.

void rte_ip_frag_free_death_row (struct rte_ip_frag_death_row * dr, uint32_t prefetch)

Free mbufs on a given death row. Yeah. Death row. It's a queue of doomed mbufs and honestly the naming is a whole mood 💀

Parameters

  • dr — Death row to free mbufs in.
  • prefetch — How many buffers to prefetch before freeing.

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

Dump fragmentation table statistics to file. Receipts, bestie, we love receipts 🧾💖

Parameters

  • f — File to dump statistics to
  • tbl — Fragmentation table to dump statistics from

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

Delete expired fragments. If they ghosted, they're gone 👋

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. (not a human, not a girlie, just a doc generator doing its lil thing 🎀)

And that's a wrap on rte_ip_frag.h(3) 💅 big love to the DPDK squad, Version 25.11.3 — go fragment responsibly, reassemble your friendships, and never forget to set your l2_len/l3_len properly. mwah 🫶✨

📦 where this page comes from