DPDK  20.05.0
Data Structures | Macros | Functions
rte_mbuf.h File Reference
#include <stdint.h>
#include <rte_compat.h>
#include <rte_common.h>
#include <rte_config.h>
#include <rte_mempool.h>
#include <rte_memory.h>
#include <rte_atomic.h>
#include <rte_prefetch.h>
#include <rte_branch_prediction.h>
#include <rte_byteorder.h>
#include <rte_mbuf_ptype.h>
#include <rte_mbuf_core.h>

Go to the source code of this file.

Data Structures

struct  rte_pktmbuf_pool_private
 
struct  rte_pktmbuf_extmem
 

Macros

#define RTE_PKTMBUF_POOL_F_PINNED_EXT_BUF   (1 << 0)
 
#define RTE_MBUF_HAS_PINNED_EXTBUF(mb)   (rte_pktmbuf_priv_flags(mb->pool) & RTE_PKTMBUF_POOL_F_PINNED_EXT_BUF)
 
#define __rte_mbuf_sanity_check(m, is_h)   do { } while (0)
 
#define RTE_MBUF_PREFETCH_TO_FREE(m)
 
#define MBUF_INVALID_PORT   UINT16_MAX
 
#define rte_pktmbuf_detach_extbuf(m)   rte_pktmbuf_detach(m)
 
#define rte_pktmbuf_pkt_len(m)   ((m)->pkt_len)
 
#define rte_pktmbuf_data_len(m)   ((m)->data_len)
 

Functions

const char * rte_get_rx_ol_flag_name (uint64_t mask)
 
int rte_get_rx_ol_flag_list (uint64_t mask, char *buf, size_t buflen)
 
const char * rte_get_tx_ol_flag_name (uint64_t mask)
 
int rte_get_tx_ol_flag_list (uint64_t mask, char *buf, size_t buflen)
 
static void rte_mbuf_prefetch_part1 (struct rte_mbuf *m)
 
static void rte_mbuf_prefetch_part2 (struct rte_mbuf *m)
 
static uint16_t rte_pktmbuf_priv_size (struct rte_mempool *mp)
 
static rte_iova_t rte_mbuf_data_iova (const struct rte_mbuf *mb)
 
static rte_iova_t rte_mbuf_data_iova_default (const struct rte_mbuf *mb)
 
static struct rte_mbufrte_mbuf_from_indirect (struct rte_mbuf *mi)
 
static __rte_experimental char * rte_mbuf_buf_addr (struct rte_mbuf *mb, struct rte_mempool *mp)
 
static __rte_experimental char * rte_mbuf_data_addr_default (__rte_unused struct rte_mbuf *mb)
 
static char * rte_mbuf_to_baddr (struct rte_mbuf *md)
 
static __rte_experimental void * rte_mbuf_to_priv (struct rte_mbuf *m)
 
static uint32_t rte_pktmbuf_priv_flags (struct rte_mempool *mp)
 
static uint16_t rte_mbuf_refcnt_update (struct rte_mbuf *m, int16_t value)
 
static uint16_t rte_mbuf_refcnt_read (const struct rte_mbuf *m)
 
static void rte_mbuf_refcnt_set (struct rte_mbuf *m, uint16_t new_value)
 
static uint16_t rte_mbuf_ext_refcnt_read (const struct rte_mbuf_ext_shared_info *shinfo)
 
static void rte_mbuf_ext_refcnt_set (struct rte_mbuf_ext_shared_info *shinfo, uint16_t new_value)
 
static uint16_t rte_mbuf_ext_refcnt_update (struct rte_mbuf_ext_shared_info *shinfo, int16_t value)
 
void rte_mbuf_sanity_check (const struct rte_mbuf *m, int is_header)
 
__rte_experimental int rte_mbuf_check (const struct rte_mbuf *m, int is_header, const char **reason)
 
static struct rte_mbufrte_mbuf_raw_alloc (struct rte_mempool *mp)
 
static __rte_always_inline void rte_mbuf_raw_free (struct rte_mbuf *m)
 
void rte_pktmbuf_init (struct rte_mempool *mp, void *opaque_arg, void *m, unsigned i)
 
void rte_pktmbuf_pool_init (struct rte_mempool *mp, void *opaque_arg)
 
struct rte_mempoolrte_pktmbuf_pool_create (const char *name, unsigned n, unsigned cache_size, uint16_t priv_size, uint16_t data_room_size, int socket_id)
 
struct rte_mempoolrte_pktmbuf_pool_create_by_ops (const char *name, unsigned int n, unsigned int cache_size, uint16_t priv_size, uint16_t data_room_size, int socket_id, const char *ops_name)
 
__rte_experimental struct rte_mempoolrte_pktmbuf_pool_create_extbuf (const char *name, unsigned int n, unsigned int cache_size, uint16_t priv_size, uint16_t data_room_size, int socket_id, const struct rte_pktmbuf_extmem *ext_mem, unsigned int ext_num)
 
static uint16_t rte_pktmbuf_data_room_size (struct rte_mempool *mp)
 
static void rte_pktmbuf_reset_headroom (struct rte_mbuf *m)
 
static struct rte_mbufrte_pktmbuf_alloc (struct rte_mempool *mp)
 
static int rte_pktmbuf_alloc_bulk (struct rte_mempool *pool, struct rte_mbuf **mbufs, unsigned count)
 
static struct rte_mbuf_ext_shared_inforte_pktmbuf_ext_shinfo_init_helper (void *buf_addr, uint16_t *buf_len, rte_mbuf_extbuf_free_callback_t free_cb, void *fcb_opaque)
 
static void rte_pktmbuf_attach_extbuf (struct rte_mbuf *m, void *buf_addr, rte_iova_t buf_iova, uint16_t buf_len, struct rte_mbuf_ext_shared_info *shinfo)
 
static void rte_mbuf_dynfield_copy (struct rte_mbuf *mdst, const struct rte_mbuf *msrc)
 
static void rte_pktmbuf_attach (struct rte_mbuf *mi, struct rte_mbuf *m)
 
static void rte_pktmbuf_detach (struct rte_mbuf *m)
 
static __rte_always_inline struct rte_mbufrte_pktmbuf_prefree_seg (struct rte_mbuf *m)
 
static __rte_always_inline void rte_pktmbuf_free_seg (struct rte_mbuf *m)
 
static void rte_pktmbuf_free (struct rte_mbuf *m)
 
__rte_experimental void rte_pktmbuf_free_bulk (struct rte_mbuf **mbufs, unsigned int count)
 
struct rte_mbufrte_pktmbuf_clone (struct rte_mbuf *md, struct rte_mempool *mp)
 
__rte_experimental struct rte_mbufrte_pktmbuf_copy (const struct rte_mbuf *m, struct rte_mempool *mp, uint32_t offset, uint32_t length)
 
static void rte_pktmbuf_refcnt_update (struct rte_mbuf *m, int16_t v)
 
static uint16_t rte_pktmbuf_headroom (const struct rte_mbuf *m)
 
static uint16_t rte_pktmbuf_tailroom (const struct rte_mbuf *m)
 
static struct rte_mbufrte_pktmbuf_lastseg (struct rte_mbuf *m)
 
static char * rte_pktmbuf_prepend (struct rte_mbuf *m, uint16_t len)
 
static char * rte_pktmbuf_append (struct rte_mbuf *m, uint16_t len)
 
static char * rte_pktmbuf_adj (struct rte_mbuf *m, uint16_t len)
 
static int rte_pktmbuf_trim (struct rte_mbuf *m, uint16_t len)
 
static int rte_pktmbuf_is_contiguous (const struct rte_mbuf *m)
 
static const void * rte_pktmbuf_read (const struct rte_mbuf *m, uint32_t off, uint32_t len, void *buf)
 
static int rte_pktmbuf_chain (struct rte_mbuf *head, struct rte_mbuf *tail)
 
static int rte_validate_tx_offload (const struct rte_mbuf *m)
 
static int rte_pktmbuf_linearize (struct rte_mbuf *mbuf)
 
void rte_pktmbuf_dump (FILE *f, const struct rte_mbuf *m, unsigned dump_len)
 
static uint32_t rte_mbuf_sched_queue_get (const struct rte_mbuf *m)
 
static uint8_t rte_mbuf_sched_traffic_class_get (const struct rte_mbuf *m)
 
static uint8_t rte_mbuf_sched_color_get (const struct rte_mbuf *m)
 
static void rte_mbuf_sched_get (const struct rte_mbuf *m, uint32_t *queue_id, uint8_t *traffic_class, uint8_t *color)
 
static void rte_mbuf_sched_queue_set (struct rte_mbuf *m, uint32_t queue_id)
 
static void rte_mbuf_sched_traffic_class_set (struct rte_mbuf *m, uint8_t traffic_class)
 
static void rte_mbuf_sched_color_set (struct rte_mbuf *m, uint8_t color)
 
static void rte_mbuf_sched_set (struct rte_mbuf *m, uint32_t queue_id, uint8_t traffic_class, uint8_t color)
 

Detailed Description

RTE Mbuf

The mbuf library provides the ability to create and destroy buffers that may be used by the RTE application to store message buffers. The message buffers are stored in a mempool, using the RTE mempool library.

The preferred way to create a mbuf pool is to use rte_pktmbuf_pool_create(). However, in some situations, an application may want to have more control (ex: populate the pool with specific memory), in this case it is possible to use functions from rte_mempool. See how rte_pktmbuf_pool_create() is implemented for details.

This library provides an API to allocate/free packet mbufs, which are used to carry network packets.

To understand the concepts of packet buffers or mbufs, you should read "TCP/IP Illustrated, Volume 2: The Implementation, Addison-Wesley, 1995, ISBN 0-201-63354-X from Richard Stevens" http://www.kohala.com/start/tcpipiv2.html

Definition in file rte_mbuf.h.

Macro Definition Documentation

#define RTE_PKTMBUF_POOL_F_PINNED_EXT_BUF   (1 << 0)

When set, pktmbuf mempool will hold only mbufs with pinned external buffer. The external buffer will be attached to the mbuf at the memory pool creation and will never be detached by the mbuf free calls. mbuf should not contain any room for data after the mbuf structure.

Definition at line 332 of file rte_mbuf.h.

#define RTE_MBUF_HAS_PINNED_EXTBUF (   mb)    (rte_pktmbuf_priv_flags(mb->pool) & RTE_PKTMBUF_POOL_F_PINNED_EXT_BUF)

Returns non zero if given mbuf has a pinned external buffer, or zero otherwise. The pinned external buffer is allocated at pool creation time and should not be freed on mbuf freeing.

External buffer is a user-provided anonymous buffer.

Definition at line 341 of file rte_mbuf.h.

#define __rte_mbuf_sanity_check (   m,
  is_h 
)    do { } while (0)

check mbuf type in debug mode

Examples:
examples/ipv4_multicast/main.c.

Definition at line 352 of file rte_mbuf.h.

#define RTE_MBUF_PREFETCH_TO_FREE (   m)
Value:
do { \
if ((m) != NULL) \
} while (0)
static void rte_prefetch0(const volatile void *p)

Mbuf prefetch

Definition at line 512 of file rte_mbuf.h.

#define MBUF_INVALID_PORT   UINT16_MAX

Reset the fields of a packet mbuf to their default values.

The given mbuf must have only one segment.

Parameters
mThe packet mbuf to be reset.

Definition at line 860 of file rte_mbuf.h.

#define rte_pktmbuf_detach_extbuf (   m)    rte_pktmbuf_detach(m)

Detach the external buffer attached to a mbuf, same as rte_pktmbuf_detach()

Parameters
mThe mbuf having external buffer.

Definition at line 1098 of file rte_mbuf.h.

#define rte_pktmbuf_pkt_len (   m)    ((m)->pkt_len)

A macro that returns the length of the packet.

The value can be read or assigned.

Parameters
mThe packet mbuf.
Examples:
examples/fips_validation/main.c, examples/ipsec-secgw/esp.c, examples/l2fwd-crypto/main.c, and examples/qos_meter/main.c.

Definition at line 1554 of file rte_mbuf.h.

#define rte_pktmbuf_data_len (   m)    ((m)->data_len)

A macro that returns the length of the segment.

The value can be read or assigned.

Parameters
mThe packet mbuf.
Examples:
examples/bbdev_app/main.c, examples/ioat/ioatfwd.c, examples/ipsec-secgw/esp.c, examples/l2fwd-crypto/main.c, and examples/vhost/virtio_net.c.

Definition at line 1564 of file rte_mbuf.h.

Function Documentation

const char* rte_get_rx_ol_flag_name ( uint64_t  mask)

Get the name of a RX offload flag

Parameters
maskThe mask describing the flag.
Returns
The name of this flag, or NULL if it's not a valid RX flag.
int rte_get_rx_ol_flag_list ( uint64_t  mask,
char *  buf,
size_t  buflen 
)

Dump the list of RX offload flags in a buffer

Parameters
maskThe mask describing the RX flags.
bufThe output buffer.
buflenThe length of the buffer.
Returns
0 on success, (-1) on error.
const char* rte_get_tx_ol_flag_name ( uint64_t  mask)

Get the name of a TX offload flag

Parameters
maskThe mask describing the flag. Usually only one bit must be set. Several bits can be given if they belong to the same mask. Ex: PKT_TX_L4_MASK.
Returns
The name of this flag, or NULL if it's not a valid TX flag.
int rte_get_tx_ol_flag_list ( uint64_t  mask,
char *  buf,
size_t  buflen 
)

Dump the list of TX offload flags in a buffer

Parameters
maskThe mask describing the TX flags.
bufThe output buffer.
buflenThe length of the buffer.
Returns
0 on success, (-1) on error.
static void rte_mbuf_prefetch_part1 ( struct rte_mbuf m)
inlinestatic

Prefetch the first part of the mbuf

The first 64 bytes of the mbuf corresponds to fields that are used early in the receive path. If the cache line of the architecture is higher than 64B, the second part will also be prefetched.

Parameters
mThe pointer to the mbuf.

Definition at line 112 of file rte_mbuf.h.

static void rte_mbuf_prefetch_part2 ( struct rte_mbuf m)
inlinestatic

Prefetch the second part of the mbuf

The next 64 bytes of the mbuf corresponds to fields that are used in the transmit path. If the cache line of the architecture is higher than 64B, this function does nothing as it is expected that the full mbuf is already in cache.

Parameters
mThe pointer to the mbuf.
Examples:
examples/ipsec-secgw/ipsec-secgw.c.

Definition at line 129 of file rte_mbuf.h.

static uint16_t rte_pktmbuf_priv_size ( struct rte_mempool mp)
inlinestatic

Get the application private size of mbufs stored in a pktmbuf_pool

The private size of mbuf is a zone located between the rte_mbuf structure and the data buffer where an application can store data associated to a packet.

Parameters
mpThe packet mbuf pool.
Returns
The private size of mbufs stored in this mempool.

Definition at line 830 of file rte_mbuf.h.

static rte_iova_t rte_mbuf_data_iova ( const struct rte_mbuf mb)
inlinestatic

Return the IO address of the beginning of the mbuf data

Parameters
mbThe pointer to the mbuf.
Returns
The IO address of the beginning of the mbuf data

Definition at line 150 of file rte_mbuf.h.

static rte_iova_t rte_mbuf_data_iova_default ( const struct rte_mbuf mb)
inlinestatic

Return the default IO address of the beginning of the mbuf data

This function is used by drivers in their receive function, as it returns the location where data should be written by the NIC, taking the default headroom in account.

Parameters
mbThe pointer to the mbuf.
Returns
The IO address of the beginning of the mbuf data

Definition at line 175 of file rte_mbuf.h.

static struct rte_mbuf* rte_mbuf_from_indirect ( struct rte_mbuf mi)
static

Return the mbuf owning the data buffer address of an indirect mbuf.

Parameters
miThe pointer to the indirect mbuf.
Returns
The address of the direct mbuf corresponding to buffer_addr.

Definition at line 196 of file rte_mbuf.h.

static __rte_experimental char* rte_mbuf_buf_addr ( struct rte_mbuf mb,
struct rte_mempool mp 
)
inlinestatic

Return address of buffer embedded in the given mbuf.

The return value shall be same as mb->buf_addr if the mbuf is already initialized and direct. However, this API is useful if mempool of the mbuf is already known because it doesn't need to access mbuf contents in order to get the mempool pointer.

Warning
EXPERIMENTAL: This API may change without prior notice. This will be used by rte_mbuf_to_baddr() which has redundant code once experimental tag is removed.
Parameters
mbThe pointer to the mbuf.
mpThe pointer to the mempool of the mbuf.
Returns
The pointer of the mbuf buffer.

Definition at line 223 of file rte_mbuf.h.

static __rte_experimental char* rte_mbuf_data_addr_default ( __rte_unused struct rte_mbuf mb)
inlinestatic

Return the default address of the beginning of the mbuf data.

Warning
EXPERIMENTAL: This API may change without prior notice.
Parameters
mbThe pointer to the mbuf.
Returns
The pointer of the beginning of the mbuf data.

Definition at line 241 of file rte_mbuf.h.

static char* rte_mbuf_to_baddr ( struct rte_mbuf md)
inlinestatic

Return address of buffer embedded in the given mbuf.

Note
: Accessing mempool pointer of a mbuf is expensive because the pointer is stored in the 2nd cache line of mbuf. If mempool is known, it is better not to reference the mempool pointer in mbuf but calling rte_mbuf_buf_addr() would be more efficient.
Parameters
mdThe pointer to the mbuf.
Returns
The address of the data buffer owned by the mbuf.

Definition at line 267 of file rte_mbuf.h.

static __rte_experimental void* rte_mbuf_to_priv ( struct rte_mbuf m)
inlinestatic

Return the starting address of the private data area embedded in the given mbuf.

Note that no check is made to ensure that a private data area actually exists in the supplied mbuf.

Parameters
mThe pointer to the mbuf.
Returns
The starting address of the private data area of the given mbuf.

Definition at line 292 of file rte_mbuf.h.

static uint32_t rte_pktmbuf_priv_flags ( struct rte_mempool mp)
inlinestatic

Return the flags from private data in an mempool structure.

Parameters
mpA pointer to the mempool structure.
Returns
The flags from the private data structure.

Definition at line 318 of file rte_mbuf.h.

static uint16_t rte_mbuf_refcnt_update ( struct rte_mbuf m,
int16_t  value 
)
inlinestatic

Adds given value to an mbuf's refcnt and returns its new value.

Definition at line 433 of file rte_mbuf.h.

static uint16_t rte_mbuf_refcnt_read ( const struct rte_mbuf m)
inlinestatic

Reads the value of an mbuf's refcnt.

Definition at line 442 of file rte_mbuf.h.

static void rte_mbuf_refcnt_set ( struct rte_mbuf m,
uint16_t  new_value 
)
inlinestatic

Sets an mbuf's refcnt to the defined value.

Definition at line 451 of file rte_mbuf.h.

static uint16_t rte_mbuf_ext_refcnt_read ( const struct rte_mbuf_ext_shared_info shinfo)
inlinestatic

Reads the refcnt of an external buffer.

Parameters
shinfoShared data of the external buffer.
Returns
Reference count number.

Definition at line 467 of file rte_mbuf.h.

static void rte_mbuf_ext_refcnt_set ( struct rte_mbuf_ext_shared_info shinfo,
uint16_t  new_value 
)
inlinestatic

Set refcnt of an external buffer.

Parameters
shinfoShared data of the external buffer.
new_valueValue set

Definition at line 481 of file rte_mbuf.h.

static uint16_t rte_mbuf_ext_refcnt_update ( struct rte_mbuf_ext_shared_info shinfo,
int16_t  value 
)
inlinestatic

Add given value to refcnt of an external buffer and return its new value.

Parameters
shinfoShared data of the external buffer.
valueValue to add/subtract
Returns
Updated value

Definition at line 499 of file rte_mbuf.h.

void rte_mbuf_sanity_check ( const struct rte_mbuf m,
int  is_header 
)

Sanity checks on an mbuf.

Check the consistency of the given mbuf. The function will cause a panic if corruption is detected.

Parameters
mThe mbuf to be checked.
is_headerTrue if the mbuf is a packet header, false if it is a sub-segment of a packet (in this case, some fields like nb_segs are not checked)
__rte_experimental int rte_mbuf_check ( const struct rte_mbuf m,
int  is_header,
const char **  reason 
)

Sanity checks on a mbuf.

Almost like rte_mbuf_sanity_check(), but this function gives the reason if corruption is detected rather than panic.

Parameters
mThe mbuf to be checked.
is_headerTrue if the mbuf is a packet header, false if it is a sub-segment of a packet (in this case, some fields like nb_segs are not checked)
reasonA reference to a string pointer where to store the reason why a mbuf is considered invalid.
Returns
  • 0 if no issue has been found, reason is left untouched.
  • -1 if a problem is detected, reason then points to a string describing the reason why the mbuf is deemed invalid.
static struct rte_mbuf* rte_mbuf_raw_alloc ( struct rte_mempool mp)
static

Allocate an uninitialized mbuf from mempool mp.

This function can be used by PMDs (especially in RX functions) to allocate an uninitialized mbuf. The driver is responsible of initializing all the required fields. See rte_pktmbuf_reset(). For standard needs, prefer rte_pktmbuf_alloc().

The caller can expect that the following fields of the mbuf structure are initialized: buf_addr, buf_iova, buf_len, refcnt=1, nb_segs=1, next=NULL, pool, priv_size. The other fields must be initialized by the caller.

Parameters
mpThe mempool from which mbuf is allocated.
Returns
  • The pointer to the new mbuf on success.
  • NULL if allocation failed.
Examples:
examples/ntb/ntb_fwd.c.

Definition at line 582 of file rte_mbuf.h.

static __rte_always_inline void rte_mbuf_raw_free ( struct rte_mbuf m)
static

Put mbuf back into its original mempool.

The caller must ensure that the mbuf is direct and properly reinitialized (refcnt=1, next=NULL, nb_segs=1), as done by rte_pktmbuf_prefree_seg().

This function should be used with care, when optimization is required. For standard needs, prefer rte_pktmbuf_free() or rte_pktmbuf_free_seg().

Parameters
mThe mbuf to be freed.

Definition at line 607 of file rte_mbuf.h.

void rte_pktmbuf_init ( struct rte_mempool mp,
void *  opaque_arg,
void *  m,
unsigned  i 
)

The packet mbuf constructor.

This function initializes some fields in the mbuf structure that are not modified by the user once created (origin pool, buffer start address, and so on). This function is given as a callback function to rte_mempool_obj_iter() or rte_mempool_create() at pool creation time.

Parameters
mpThe mempool from which mbufs originate.
opaque_argA pointer that can be used by the user to retrieve useful information for mbuf initialization. This pointer is the opaque argument passed to rte_mempool_obj_iter() or rte_mempool_create().
mThe mbuf to initialize.
iThe index of the mbuf in the pool table.
Examples:
examples/ntb/ntb_fwd.c.
void rte_pktmbuf_pool_init ( struct rte_mempool mp,
void *  opaque_arg 
)

A packet mbuf pool constructor.

This function initializes the mempool private data in the case of a pktmbuf pool. This private data is needed by the driver. The function must be called on the mempool before it is used, or it can be given as a callback function to rte_mempool_create() at pool creation. It can be extended by the user, for example, to provide another packet size.

Parameters
mpThe mempool from which mbufs originate.
opaque_argA pointer that can be used by the user to retrieve useful information for mbuf initialization. This pointer is the opaque argument passed to rte_mempool_create().
Examples:
examples/ntb/ntb_fwd.c.
struct rte_mempool* rte_pktmbuf_pool_create ( const char *  name,
unsigned  n,
unsigned  cache_size,
uint16_t  priv_size,
uint16_t  data_room_size,
int  socket_id 
)

Create a mbuf pool.

This function creates and initializes a packet mbuf pool. It is a wrapper to rte_mempool functions.

Parameters
nameThe name of the mbuf pool.
nThe number of elements in the mbuf pool. The optimum size (in terms of memory usage) for a mempool is when n is a power of two minus one: n = (2^q - 1).
cache_sizeSize of the per-core object cache. See rte_mempool_create() for details.
priv_sizeSize of application private are between the rte_mbuf structure and the data buffer. This value must be aligned to RTE_MBUF_PRIV_ALIGN.
data_room_sizeSize of data buffer in each mbuf, including RTE_PKTMBUF_HEADROOM.
socket_idThe socket identifier where the memory should be allocated. The value can be SOCKET_ID_ANY if there is no NUMA constraint for the reserved zone.
Returns
The pointer to the new allocated mempool, on success. NULL on error with rte_errno set appropriately. Possible rte_errno values include:
  • E_RTE_NO_CONFIG - function could not get pointer to rte_config structure
  • E_RTE_SECONDARY - function was called from a secondary process instance
  • EINVAL - cache size provided is too large, or priv_size is not aligned.
  • ENOSPC - the maximum number of memzones has already been allocated
  • EEXIST - a memzone with the same name already exists
  • ENOMEM - no appropriate memory area found in which to create memzone
Examples:
examples/bbdev_app/main.c, examples/bond/main.c, examples/distributor/main.c, examples/ethtool/ethtool-app/main.c, examples/eventdev_pipeline/pipeline_worker_generic.c, examples/eventdev_pipeline/pipeline_worker_tx.c, examples/fips_validation/fips_dev_self_test.c, examples/fips_validation/main.c, examples/flow_classify/flow_classify.c, examples/flow_filtering/main.c, examples/ioat/ioatfwd.c, examples/ip_fragmentation/main.c, examples/ip_pipeline/mempool.c, examples/ip_reassembly/main.c, examples/ipsec-secgw/ipsec-secgw.c, examples/ipv4_multicast/main.c, examples/kni/main.c, examples/l2fwd-cat/l2fwd-cat.c, examples/l2fwd-crypto/main.c, examples/l2fwd-event/main.c, examples/l2fwd-jobstats/main.c, examples/l2fwd-keepalive/main.c, examples/l2fwd/main.c, examples/l3fwd-acl/main.c, examples/l3fwd-graph/main.c, examples/l3fwd-power/main.c, examples/l3fwd/main.c, examples/link_status_interrupt/main.c, examples/multi_process/client_server_mp/mp_server/init.c, examples/multi_process/symmetric_mp/main.c, examples/packet_ordering/main.c, examples/performance-thread/l3fwd-thread/main.c, examples/ptpclient/ptpclient.c, examples/qos_meter/main.c, examples/qos_sched/init.c, examples/rxtx_callbacks/main.c, examples/server_node_efd/server/init.c, examples/skeleton/basicfwd.c, examples/tep_termination/main.c, examples/vhost/main.c, examples/vm_power_manager/main.c, examples/vmdq/main.c, and examples/vmdq_dcb/main.c.
struct rte_mempool* rte_pktmbuf_pool_create_by_ops ( const char *  name,
unsigned int  n,
unsigned int  cache_size,
uint16_t  priv_size,
uint16_t  data_room_size,
int  socket_id,
const char *  ops_name 
)

Create a mbuf pool with a given mempool ops name

This function creates and initializes a packet mbuf pool. It is a wrapper to rte_mempool functions.

Parameters
nameThe name of the mbuf pool.
nThe number of elements in the mbuf pool. The optimum size (in terms of memory usage) for a mempool is when n is a power of two minus one: n = (2^q - 1).
cache_sizeSize of the per-core object cache. See rte_mempool_create() for details.
priv_sizeSize of application private are between the rte_mbuf structure and the data buffer. This value must be aligned to RTE_MBUF_PRIV_ALIGN.
data_room_sizeSize of data buffer in each mbuf, including RTE_PKTMBUF_HEADROOM.
socket_idThe socket identifier where the memory should be allocated. The value can be SOCKET_ID_ANY if there is no NUMA constraint for the reserved zone.
ops_nameThe mempool ops name to be used for this mempool instead of default mempool. The value can be NULL to use default mempool.
Returns
The pointer to the new allocated mempool, on success. NULL on error with rte_errno set appropriately. Possible rte_errno values include:
  • E_RTE_NO_CONFIG - function could not get pointer to rte_config structure
  • E_RTE_SECONDARY - function was called from a secondary process instance
  • EINVAL - cache size provided is too large, or priv_size is not aligned.
  • ENOSPC - the maximum number of memzones has already been allocated
  • EEXIST - a memzone with the same name already exists
  • ENOMEM - no appropriate memory area found in which to create memzone
__rte_experimental struct rte_mempool* rte_pktmbuf_pool_create_extbuf ( const char *  name,
unsigned int  n,
unsigned int  cache_size,
uint16_t  priv_size,
uint16_t  data_room_size,
int  socket_id,
const struct rte_pktmbuf_extmem ext_mem,
unsigned int  ext_num 
)

Create a mbuf pool with external pinned data buffers.

This function creates and initializes a packet mbuf pool that contains only mbufs with external buffer. It is a wrapper to rte_mempool functions.

Parameters
nameThe name of the mbuf pool.
nThe number of elements in the mbuf pool. The optimum size (in terms of memory usage) for a mempool is when n is a power of two minus one: n = (2^q - 1).
cache_sizeSize of the per-core object cache. See rte_mempool_create() for details.
priv_sizeSize of application private are between the rte_mbuf structure and the data buffer. This value must be aligned to RTE_MBUF_PRIV_ALIGN.
data_room_sizeSize of data buffer in each mbuf, including RTE_PKTMBUF_HEADROOM.
socket_idThe socket identifier where the memory should be allocated. The value can be SOCKET_ID_ANY if there is no NUMA constraint for the reserved zone.
ext_memPointer to the array of structures describing the external memory for data buffers. It is caller responsibility to register this memory with rte_extmem_register() (if needed), map this memory to appropriate physical device, etc.
ext_numNumber of elements in the ext_mem array.
Returns
The pointer to the new allocated mempool, on success. NULL on error with rte_errno set appropriately. Possible rte_errno values include:
  • E_RTE_NO_CONFIG - function could not get pointer to rte_config structure
  • E_RTE_SECONDARY - function was called from a secondary process instance
  • EINVAL - cache size provided is too large, or priv_size is not aligned.
  • ENOSPC - the maximum number of memzones has already been allocated
  • EEXIST - a memzone with the same name already exists
  • ENOMEM - no appropriate memory area found in which to create memzone
static uint16_t rte_pktmbuf_data_room_size ( struct rte_mempool mp)
inlinestatic

Get the data room size of mbufs stored in a pktmbuf_pool

The data room size is the amount of data that can be stored in a mbuf including the headroom (RTE_PKTMBUF_HEADROOM).

Parameters
mpThe packet mbuf pool.
Returns
The data room size of mbufs stored in this mempool.

Definition at line 809 of file rte_mbuf.h.

static void rte_pktmbuf_reset_headroom ( struct rte_mbuf m)
inlinestatic

Reset the data_off field of a packet mbuf to its default value.

The given mbuf must have only one segment, which should be empty.

Parameters
mThe packet mbuf's data_off field has to be reset.

Definition at line 846 of file rte_mbuf.h.

static struct rte_mbuf* rte_pktmbuf_alloc ( struct rte_mempool mp)
static

Allocate a new mbuf from a mempool.

This new mbuf contains one segment, which has a length of 0. The pointer to data is initialized to have some bytes of headroom in the buffer (if buffer size allows).

Parameters
mpThe mempool from which the mbuf is allocated.
Returns
  • The pointer to the new mbuf on success.
  • NULL if allocation failed.
Examples:
examples/bond/main.c, examples/fips_validation/fips_dev_self_test.c, examples/fips_validation/main.c, examples/ipv4_multicast/main.c, examples/ntb/ntb_fwd.c, examples/ptpclient/ptpclient.c, and examples/vhost/virtio_net.c.

Definition at line 893 of file rte_mbuf.h.

static int rte_pktmbuf_alloc_bulk ( struct rte_mempool pool,
struct rte_mbuf **  mbufs,
unsigned  count 
)
inlinestatic

Allocate a bulk of mbufs, initialize refcnt and reset the fields to default values.

Parameters
poolThe mempool from which mbufs are allocated.
mbufsArray of pointers to mbufs
countArray size
Returns
  • 0: Success
  • -ENOENT: Not enough entries in the mempool; no mbufs are retrieved.

Definition at line 915 of file rte_mbuf.h.

static struct rte_mbuf_ext_shared_info* rte_pktmbuf_ext_shinfo_init_helper ( void *  buf_addr,
uint16_t *  buf_len,
rte_mbuf_extbuf_free_callback_t  free_cb,
void *  fcb_opaque 
)
static

Initialize shared data at the end of an external buffer before attaching to a mbuf by rte_pktmbuf_attach_extbuf(). This is not a mandatory initialization but a helper function to simply spare a few bytes at the end of the buffer for shared data. If shared data is allocated separately, this should not be called but application has to properly initialize the shared data according to its need.

Free callback and its argument is saved and the refcnt is set to 1.

Warning
The value of buf_len will be reduced to RTE_PTR_DIFF(shinfo, buf_addr) after this initialization. This shall be used for rte_pktmbuf_attach_extbuf()
Parameters
buf_addrThe pointer to the external buffer.
[in,out]buf_lenThe pointer to length of the external buffer. Input value must be larger than the size of struct rte_mbuf_ext_shared_info and padding for alignment. If not enough, this function will return NULL. Adjusted buffer length will be returned through this pointer.
free_cbFree callback function to call when the external buffer needs to be freed.
fcb_opaqueArgument for the free callback function.
Returns
A pointer to the initialized shared data on success, return NULL otherwise.

Definition at line 990 of file rte_mbuf.h.

static void rte_pktmbuf_attach_extbuf ( struct rte_mbuf m,
void *  buf_addr,
rte_iova_t  buf_iova,
uint16_t  buf_len,
struct rte_mbuf_ext_shared_info shinfo 
)
inlinestatic

Attach an external buffer to a mbuf.

User-managed anonymous buffer can be attached to an mbuf. When attaching it, corresponding free callback function and its argument should be provided via shinfo. This callback function will be called once all the mbufs are detached from the buffer (refcnt becomes zero).

The headroom length of the attaching mbuf will be set to zero and this can be properly adjusted after attachment. For example, rte_pktmbuf_adj() or rte_pktmbuf_reset_headroom() might be used.

Similarly, the packet length is initialized to 0. If the buffer contains data, the user has to adjust data_len and the pkt_len field of the mbuf accordingly.

More mbufs can be attached to the same external buffer by rte_pktmbuf_attach() once the external buffer has been attached by this API.

Detachment can be done by either rte_pktmbuf_detach_extbuf() or rte_pktmbuf_detach().

Memory for shared data must be provided and user must initialize all of the content properly, especially free callback and refcnt. The pointer of shared data will be stored in m->shinfo. rte_pktmbuf_ext_shinfo_init_helper can help to simply spare a few bytes at the end of buffer for the shared data, store free callback and its argument and set the refcnt to 1. The following is an example:

struct rte_mbuf_ext_shared_info *shinfo = rte_pktmbuf_ext_shinfo_init_helper(buf_addr, &buf_len, free_cb, fcb_arg); rte_pktmbuf_attach_extbuf(m, buf_addr, buf_iova, buf_len, shinfo); rte_pktmbuf_reset_headroom(m); rte_pktmbuf_adj(m, data_len);

Attaching an external buffer is quite similar to mbuf indirection in replacing buffer addresses and length of a mbuf, but a few differences:

  • When an indirect mbuf is attached, refcnt of the direct mbuf would be 2 as long as the direct mbuf itself isn't freed after the attachment. In such cases, the buffer area of a direct mbuf must be read-only. But external buffer has its own refcnt and it starts from 1. Unless multiple mbufs are attached to a mbuf having an external buffer, the external buffer is writable.
  • There's no need to allocate buffer from a mempool. Any buffer can be attached with appropriate free callback and its IO address.
  • Smaller metadata is required to maintain shared data such as refcnt.
Parameters
mThe pointer to the mbuf.
buf_addrThe pointer to the external buffer.
buf_iovaIO address of the external buffer.
buf_lenThe size of the external buffer.
shinfoUser-provided memory for shared data of the external buffer.

Definition at line 1072 of file rte_mbuf.h.

static void rte_mbuf_dynfield_copy ( struct rte_mbuf mdst,
const struct rte_mbuf msrc 
)
inlinestatic

Copy dynamic fields from msrc to mdst.

Parameters
mdstThe destination mbuf.
msrcThe source mbuf.

Definition at line 1109 of file rte_mbuf.h.

static void rte_pktmbuf_attach ( struct rte_mbuf mi,
struct rte_mbuf m 
)
inlinestatic

Attach packet mbuf to another packet mbuf.

If the mbuf we are attaching to isn't a direct buffer and is attached to an external buffer, the mbuf being attached will be attached to the external buffer instead of mbuf indirection.

Otherwise, the mbuf will be indirectly attached. After attachment we refer the mbuf we attached as 'indirect', while mbuf we attached to as 'direct'. The direct mbuf's reference counter is incremented.

Right now, not supported:

  • attachment for already indirect mbuf (e.g. - mi has to be direct).
  • mbuf we trying to attach (mi) is used by someone else e.g. it's reference counter is greater then 1.
Parameters
miThe indirect packet mbuf.
mThe packet mbuf we're attaching to.

Definition at line 1149 of file rte_mbuf.h.

static void rte_pktmbuf_detach ( struct rte_mbuf m)
inlinestatic

Detach a packet mbuf from external buffer or direct buffer.

  • decrement refcnt and free the external/direct buffer if refcnt becomes zero.
  • restore original mbuf address and length values.
  • reset pktmbuf data and data_len to their default values.

All other fields of the given packet mbuf will be left intact.

If the packet mbuf was allocated from the pool with pinned external buffers the rte_pktmbuf_detach does nothing with the mbuf of this kind, because the pinned buffers are not supposed to be detached.

Parameters
mThe indirect attached packet mbuf.

Definition at line 1239 of file rte_mbuf.h.

static __rte_always_inline struct rte_mbuf* rte_pktmbuf_prefree_seg ( struct rte_mbuf m)
static

Decrease reference counter and unlink a mbuf segment

This function does the same than a free, except that it does not return the segment to its pool. It decreases the reference counter, and if it reaches 0, it is detached from its parent for an indirect mbuf.

Parameters
mThe mbuf to be unlinked
Returns
  • (m) if it is the last reference. It can be recycled or freed.
  • (NULL) if the mbuf still has remaining references on it.

Definition at line 1331 of file rte_mbuf.h.

static __rte_always_inline void rte_pktmbuf_free_seg ( struct rte_mbuf m)
static

Free a segment of a packet mbuf into its original mempool.

Free an mbuf, without parsing other segments in case of chained buffers.

Parameters
mThe packet mbuf segment to be freed.

Definition at line 1383 of file rte_mbuf.h.

static void rte_pktmbuf_free ( struct rte_mbuf m)
inlinestatic

Free a packet mbuf back into its original mempool.

Free an mbuf, and all its segments in case of chained buffers. Each segment is added back into its original mempool.

Parameters
mThe packet mbuf to be freed. If NULL, the function does nothing.
Examples:
examples/bbdev_app/main.c, examples/bond/main.c, examples/distributor/main.c, examples/fips_validation/fips_dev_self_test.c, examples/fips_validation/main.c, examples/flow_classify/flow_classify.c, examples/flow_filtering/main.c, examples/ip_fragmentation/main.c, examples/ip_reassembly/main.c, examples/ipsec-secgw/ipsec-secgw.c, examples/ipsec-secgw/ipsec.c, examples/ipsec-secgw/ipsec_process.c, examples/ipsec-secgw/ipsec_worker.c, examples/ipv4_multicast/main.c, examples/kni/main.c, examples/l2fwd-cat/l2fwd-cat.c, examples/l2fwd-crypto/main.c, examples/l3fwd-acl/main.c, examples/l3fwd-power/main.c, examples/l3fwd/l3fwd_em.c, examples/l3fwd/l3fwd_lpm.c, examples/multi_process/client_server_mp/mp_client/client.c, examples/multi_process/client_server_mp/mp_server/main.c, examples/multi_process/symmetric_mp/main.c, examples/ntb/ntb_fwd.c, examples/packet_ordering/main.c, examples/performance-thread/l3fwd-thread/main.c, examples/ptpclient/ptpclient.c, examples/qos_meter/main.c, examples/qos_sched/app_thread.c, examples/rxtx_callbacks/main.c, examples/server_node_efd/node/node.c, examples/server_node_efd/server/main.c, examples/skeleton/basicfwd.c, examples/tep_termination/main.c, examples/tep_termination/vxlan_setup.c, examples/vhost/main.c, examples/vhost/virtio_net.c, examples/vmdq/main.c, and examples/vmdq_dcb/main.c.

Definition at line 1399 of file rte_mbuf.h.

__rte_experimental void rte_pktmbuf_free_bulk ( struct rte_mbuf **  mbufs,
unsigned int  count 
)

Free a bulk of packet mbufs back into their original mempools.

Free a bulk of mbufs, and all their segments in case of chained buffers. Each segment is added back into its original mempool.

Parameters
mbufsArray of pointers to packet mbufs. The array may contain NULL pointers.
countArray size.
struct rte_mbuf* rte_pktmbuf_clone ( struct rte_mbuf md,
struct rte_mempool mp 
)

Create a "clone" of the given packet mbuf.

Walks through all segments of the given packet mbuf, and for each of them:

  • Creates a new packet mbuf from the given pool.
  • Attaches newly created mbuf to the segment. Then updates pkt_len and nb_segs of the "clone" packet mbuf to match values from the original packet mbuf.
Parameters
mdThe packet mbuf to be cloned.
mpThe mempool from which the "clone" mbufs are allocated.
Returns
  • The pointer to the new "clone" mbuf on success.
  • NULL if allocation fails.
Examples:
examples/ipv4_multicast/main.c.
__rte_experimental struct rte_mbuf* rte_pktmbuf_copy ( const struct rte_mbuf m,
struct rte_mempool mp,
uint32_t  offset,
uint32_t  length 
)

Create a full copy of a given packet mbuf.

Copies all the data from a given packet mbuf to a newly allocated set of mbufs. The private data are is not copied.

Parameters
mThe packet mbuf to be copiedd.
mpThe mempool from which the "clone" mbufs are allocated.
offsetThe number of bytes to skip before copying. If the mbuf does not have that many bytes, it is an error and NULL is returned.
lengthThe upper limit on bytes to copy. Passing UINT32_MAX means all data (after offset).
Returns
  • The pointer to the new "clone" mbuf on success.
  • NULL if allocation fails.
static void rte_pktmbuf_refcnt_update ( struct rte_mbuf m,
int16_t  v 
)
inlinestatic

Adds given value to the refcnt of all packet mbuf segments.

Walks through all segments of given packet mbuf and for each of them invokes rte_mbuf_refcnt_update().

Parameters
mThe packet mbuf whose refcnt to be updated.
vThe value to add to the mbuf's segments refcnt.
Examples:
examples/ipv4_multicast/main.c.

Definition at line 1485 of file rte_mbuf.h.

static uint16_t rte_pktmbuf_headroom ( const struct rte_mbuf m)
inlinestatic

Get the headroom in a packet mbuf.

Parameters
mThe packet mbuf.
Returns
The length of the headroom.

Definition at line 1502 of file rte_mbuf.h.

static uint16_t rte_pktmbuf_tailroom ( const struct rte_mbuf m)
inlinestatic

Get the tailroom of a packet mbuf.

Parameters
mThe packet mbuf.
Returns
The length of the tailroom.
Examples:
examples/vhost/main.c.

Definition at line 1516 of file rte_mbuf.h.

static struct rte_mbuf* rte_pktmbuf_lastseg ( struct rte_mbuf m)
static

Get the last segment of the packet.

Parameters
mThe packet mbuf.
Returns
The last segment of the given mbuf.

Definition at line 1531 of file rte_mbuf.h.

static char* rte_pktmbuf_prepend ( struct rte_mbuf m,
uint16_t  len 
)
inlinestatic

Prepend len bytes to an mbuf data area.

Returns a pointer to the new data start address. If there is not enough headroom in the first segment, the function will return NULL, without modifying the mbuf.

Parameters
mThe pkt mbuf.
lenThe amount of data to prepend (in bytes).
Returns
A pointer to the start of the newly prepended data, or NULL if there is not enough headroom space in the first segment
Examples:
examples/ip_fragmentation/main.c, examples/ipsec-secgw/esp.c, examples/ipsec-secgw/ipsec-secgw.c, examples/ipv4_multicast/main.c, and examples/tep_termination/vxlan.c.

Definition at line 1581 of file rte_mbuf.h.

static char* rte_pktmbuf_append ( struct rte_mbuf m,
uint16_t  len 
)
inlinestatic

Append len bytes to an mbuf.

Append len bytes to an mbuf and return a pointer to the start address of the added data. If there is not enough tailroom in the last segment, the function will return NULL, without modifying the mbuf.

Parameters
mThe packet mbuf.
lenThe amount of data to append (in bytes).
Returns
A pointer to the start of the newly appended data, or NULL if there is not enough tailroom space in the last segment
Examples:
examples/bbdev_app/main.c, examples/fips_validation/fips_dev_self_test.c, examples/fips_validation/main.c, examples/ipsec-secgw/esp.c, and examples/l2fwd-crypto/main.c.

Definition at line 1614 of file rte_mbuf.h.

static char* rte_pktmbuf_adj ( struct rte_mbuf m,
uint16_t  len 
)
inlinestatic

Remove len bytes at the beginning of an mbuf.

Returns a pointer to the start address of the new data area. If the length is greater than the length of the first segment, then the function will fail and return NULL, without modifying the mbuf.

Parameters
mThe packet mbuf.
lenThe amount of data to remove (in bytes).
Returns
A pointer to the new start of the data.
Examples:
examples/ip_fragmentation/main.c, examples/ipsec-secgw/esp.c, examples/ipsec-secgw/ipsec-secgw.c, examples/ipv4_multicast/main.c, and examples/tep_termination/vxlan.c.

Definition at line 1645 of file rte_mbuf.h.

static int rte_pktmbuf_trim ( struct rte_mbuf m,
uint16_t  len 
)
inlinestatic

Remove len bytes of data at the end of the mbuf.

If the length is greater than the length of the last segment, the function will fail and return -1 without modifying the mbuf.

Parameters
mThe packet mbuf.
lenThe amount of data to remove (in bytes).
Returns
  • 0: On success.
  • -1: On error.
Examples:
examples/bbdev_app/main.c, examples/ipsec-secgw/esp.c, and examples/ipsec-secgw/ipsec-secgw.c.

Definition at line 1675 of file rte_mbuf.h.

static int rte_pktmbuf_is_contiguous ( const struct rte_mbuf m)
inlinestatic

Test if mbuf data is contiguous.

Parameters
mThe packet mbuf.
Returns
  • 1, if all data is contiguous (one segment).
  • 0, if there is several segments.

Definition at line 1699 of file rte_mbuf.h.

static const void* rte_pktmbuf_read ( const struct rte_mbuf m,
uint32_t  off,
uint32_t  len,
void *  buf 
)
inlinestatic

Read len data bytes in a mbuf at specified offset.

If the data is contiguous, return the pointer in the mbuf data, else copy the data in the buffer provided by the user and return its pointer.

Parameters
mThe pointer to the mbuf.
offThe offset of the data in the mbuf.
lenThe amount of bytes to read.
bufThe buffer where data is copied if it is not contiguous in mbuf data. Its length should be at least equal to the len parameter.
Returns
The pointer to the data, either in the mbuf if it is contiguous, or in the user buffer. If mbuf is too small, NULL is returned.

Definition at line 1731 of file rte_mbuf.h.

static int rte_pktmbuf_chain ( struct rte_mbuf head,
struct rte_mbuf tail 
)
inlinestatic

Chain an mbuf to another, thereby creating a segmented packet.

Note: The implementation will do a linear walk over the segments to find the tail entry. For cases when there are many segments, it's better to chain the entries manually.

Parameters
headThe head of the mbuf chain (the first packet)
tailThe mbuf to put last in the chain
Returns
  • 0, on success.
  • -EOVERFLOW, if the chain segment limit exceeded

Definition at line 1756 of file rte_mbuf.h.

static int rte_validate_tx_offload ( const struct rte_mbuf m)
inlinestatic

Validate general requirements for Tx offload in mbuf.

This function checks correctness and completeness of Tx offload settings.

Parameters
mThe packet mbuf to be validated.
Returns
0 if packet is valid

Definition at line 1829 of file rte_mbuf.h.

static int rte_pktmbuf_linearize ( struct rte_mbuf mbuf)
inlinestatic

Linearize data in mbuf.

This function moves the mbuf data in the first segment if there is enough tailroom. The subsequent segments are unchained and freed.

Parameters
mbufmbuf to linearize
Returns
  • 0, on success
  • -1, on error

Definition at line 1879 of file rte_mbuf.h.

void rte_pktmbuf_dump ( FILE *  f,
const struct rte_mbuf m,
unsigned  dump_len 
)

Dump an mbuf structure to a file.

Dump all fields for the given packet mbuf and all its associated segments (in the case of a chained buffer).

Parameters
fA pointer to a file for output
mThe packet mbuf.
dump_lenIf dump_len != 0, also dump the "dump_len" first data bytes of the packet.
Examples:
examples/bpf/t3.c.
static uint32_t rte_mbuf_sched_queue_get ( const struct rte_mbuf m)
inlinestatic

Get the value of mbuf sched queue_id field.

Definition at line 1906 of file rte_mbuf.h.

static uint8_t rte_mbuf_sched_traffic_class_get ( const struct rte_mbuf m)
inlinestatic

Get the value of mbuf sched traffic_class field.

Definition at line 1915 of file rte_mbuf.h.

static uint8_t rte_mbuf_sched_color_get ( const struct rte_mbuf m)
inlinestatic

Get the value of mbuf sched color field.

Definition at line 1924 of file rte_mbuf.h.

static void rte_mbuf_sched_get ( const struct rte_mbuf m,
uint32_t *  queue_id,
uint8_t *  traffic_class,
uint8_t *  color 
)
inlinestatic

Get the values of mbuf sched queue_id, traffic_class and color.

Parameters
mMbuf to read
queue_idReturns the queue id
traffic_classReturns the traffic class id
colorReturns the colour id

Definition at line 1942 of file rte_mbuf.h.

static void rte_mbuf_sched_queue_set ( struct rte_mbuf m,
uint32_t  queue_id 
)
inlinestatic

Set the mbuf sched queue_id to the defined value.

Definition at line 1957 of file rte_mbuf.h.

static void rte_mbuf_sched_traffic_class_set ( struct rte_mbuf m,
uint8_t  traffic_class 
)
inlinestatic

Set the mbuf sched traffic_class id to the defined value.

Definition at line 1966 of file rte_mbuf.h.

static void rte_mbuf_sched_color_set ( struct rte_mbuf m,
uint8_t  color 
)
inlinestatic

Set the mbuf sched color id to the defined value.

Definition at line 1975 of file rte_mbuf.h.

static void rte_mbuf_sched_set ( struct rte_mbuf m,
uint32_t  queue_id,
uint8_t  traffic_class,
uint8_t  color 
)
inlinestatic

Set the mbuf sched queue_id, traffic_class and color.

Parameters
mMbuf to set
queue_idQueue id value to be set
traffic_classTraffic class id value to be set
colorColor id to be set

Definition at line 1993 of file rte_mbuf.h.