rte_mbuf_history.h

Go to the documentation of this file.

/* SPDX-License-Identifier: BSD-3-Clause
 * Copyright(c) 2024 NVIDIA Corporation & Affiliates
 */
 
#ifndef _RTE_MBUF_HISTORY_H_
#define _RTE_MBUF_HISTORY_H_
 
#include <rte_common.h>
#include <rte_debug.h>
 
#include <rte_mbuf_dyn.h>
 
/* Forward declaration to avoid circular dependency. */
struct rte_mbuf;
struct rte_mempool;
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define RTE_MBUF_HISTORY_BITS 4
 
#define RTE_MBUF_HISTORY_MAX (sizeof(rte_mbuf_history_t) * 8 / RTE_MBUF_HISTORY_BITS)
 
enum rte_mbuf_history_op {
    RTE_MBUF_HISTORY_OP_NEVER     =  0, 
    RTE_MBUF_HISTORY_OP_LIB_FREE  =  1, 
    RTE_MBUF_HISTORY_OP_PMD_FREE  =  2, 
    RTE_MBUF_HISTORY_OP_APP_FREE  =  3, 
    /* With ops below, mbuf is considered allocated. */
    RTE_MBUF_HISTORY_OP_LIB_ALLOC =  4, 
    RTE_MBUF_HISTORY_OP_PMD_ALLOC =  5, 
    RTE_MBUF_HISTORY_OP_APP_ALLOC =  6, 
    RTE_MBUF_HISTORY_OP_RX        =  7, 
    RTE_MBUF_HISTORY_OP_TX        =  8, 
    RTE_MBUF_HISTORY_OP_TX_PREP   =  9, 
    RTE_MBUF_HISTORY_OP_TX_BUSY   = 10, 
    RTE_MBUF_HISTORY_OP_ENQUEUE   = 11, 
    RTE_MBUF_HISTORY_OP_DEQUEUE   = 12, 
    /*                              13,      reserved for future */
    RTE_MBUF_HISTORY_OP_USR2      = 14, 
    RTE_MBUF_HISTORY_OP_USR1      = 15, 
    RTE_MBUF_HISTORY_OP_MAX       = 16, 
};
 
extern int rte_mbuf_history_field_offset;
 
__rte_experimental
void rte_mbuf_history_init(void);
 
static inline void rte_mbuf_history_mark(struct rte_mbuf *m, enum rte_mbuf_history_op op)
{
#ifndef RTE_MBUF_HISTORY_DEBUG
    RTE_SET_USED(m);
    RTE_SET_USED(op);
#else
    RTE_ASSERT(rte_mbuf_history_field_offset >= 0);
    RTE_ASSERT(op < RTE_MBUF_HISTORY_OP_MAX);
    if (unlikely(m == NULL))
        return;
 
    rte_mbuf_history_t *history_field = RTE_MBUF_DYNFIELD(m,
            rte_mbuf_history_field_offset, rte_mbuf_history_t *);
    uint64_t old_history = rte_atomic_load_explicit(history_field,
            rte_memory_order_acquire);
    uint64_t new_history;
    do {
        new_history = (old_history << RTE_MBUF_HISTORY_BITS) | op;
    } while (unlikely(!rte_atomic_compare_exchange_weak_explicit(history_field,
            &old_history, new_history,
            rte_memory_order_release, rte_memory_order_acquire)));
#endif
}
 
static inline void rte_mbuf_history_mark_bulk(struct rte_mbuf * const *mbufs,
        unsigned int count, enum rte_mbuf_history_op op)
{
#ifndef RTE_MBUF_HISTORY_DEBUG
    RTE_SET_USED(mbufs);
    RTE_SET_USED(count);
    RTE_SET_USED(op);
#else
    RTE_ASSERT(rte_mbuf_history_field_offset >= 0);
    RTE_ASSERT(op < RTE_MBUF_HISTORY_OP_MAX);
    if (unlikely(mbufs == NULL))
        return;
 
    while (count--)
        rte_mbuf_history_mark(*mbufs++, op);
#endif
}
 
__rte_experimental
void rte_mbuf_history_dump(FILE *f, const struct rte_mbuf *m);
 
__rte_experimental
void rte_mbuf_history_dump_mempool(FILE *f, struct rte_mempool *mp);
 
__rte_experimental
void rte_mbuf_history_dump_all(FILE *f);
 
#ifdef __cplusplus
}
#endif
 
#endif /* _RTE_MBUF_HISTORY_H_ */