xskdev.h

Go to the documentation of this file.

/* SPDX-License-Identifier: BSD-3-Clause
 * Copyright (c) 2019-2022 Intel Corporation
 */
 
#ifndef _XSKDEV_H_
#define _XSKDEV_H_
 
#include <poll.h>           // for pollfd
#include <pthread.h>        // for pthread_mutex_t, pthread_mutex_init, pthre...
#include <stdint.h>         // for uint16_t, uint32_t
#include <stdio.h>          // for FILE, NULL, size_t
#if USE_LIBXDP
#include <xdp/xsk.h>
#else
#include <bpf/xsk.h>
#endif
#include <net/if.h>        // for IF_NAMESIZE
 
#include <cne_common.h>        // for CNDP_API, CNE_STD_C11
#include <cne_lport.h>         // for lport_stats_t, buf_alloc_t, buf_free_t
#include <pktmbuf.h>           // for pktmbuf_t
#include <uds.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#ifndef SOL_XDP
#define SOL_XDP 283
#endif
 
#ifndef AF_XDP
#define AF_XDP 44
#endif
 
#ifndef PF_XDP
#define PF_XDP AF_XDP
#endif
 
#ifndef XDP_USE_NEED_WAKEUP
/* If this option is set, the driver might go sleep and in that case
 * the XDP_RING_NEED_WAKEUP flag in the fill and/or Tx rings will be
 * set. If it is set, the application need to explicitly wake up the
 * driver with a poll() (Rx and Tx) or sendto() (Tx only). If you are
 * running the driver and the application on the same core, you should
 * use this option so that the kernel will yield to the user space
 * application.
 */
#define XDP_USE_NEED_WAKEUP (1 << 3)
#endif
 
#define XSKDEV_STATS_FLAG       (1 << 0) 
#define XSKDEV_RX_FQ_TX_CQ_FLAG (1 << 1) 
#define AF_XDP_DFLT_BUSY_BUDGET  64
#define AF_XDP_DFLT_BUSY_TIMEOUT 20
 
#ifndef SO_PREFER_BUSY_POLL
#define SO_PREFER_BUSY_POLL 69
#endif
#ifndef SO_BUSY_POLL_BUDGET
#define SO_BUSY_POLL_BUDGET 70
#endif
 
typedef void *(*xskdev_pull_cq_addr_t)(uint64_t addr, uint64_t umem_addr, uint64_t mask,
                                       uint64_t pool_header_sz);
typedef uint64_t (*xskdev_get_mbuf_addr_tx_t)(void *xi, void *mb, uint64_t umem_addr);
typedef uint16_t (*xskdev_get_mbuf_t)(void *xi, void *umem_addr, const struct xdp_desc *d,
                                      void *buf);
typedef uint16_t (*xskdev_get_mbuf_rx_t)(void *xi, void *umem_addr, const struct xdp_desc *d,
                                         void **buf);
 
struct xskdev_umem {
    struct xsk_ring_prod fq; 
    struct xsk_ring_cons cq; 
    struct xsk_umem *umem;   
    void *umem_addr;         
    size_t umem_size;        
    uint32_t obj_sz;         
    uint32_t fq_size;        
};
 
struct xskdev_queue {
    CNE_STD_C11
    union {
        struct xsk_ring_cons rx; 
        struct xsk_ring_prod tx; 
    };
    struct xskdev_umem *ux; 
    struct xsk_socket *xsk; 
    struct pollfd fds;      
};
 
/* Defines to map the xskdev_queue to be Rx/Tx like queues */
typedef struct xskdev_queue xskdev_rxq_t;
typedef struct xskdev_queue xskdev_txq_t;
 
typedef struct xskdev_info {
    TAILQ_ENTRY(xskdev_info) next; 
    char ifname[IF_NAMESIZE];      
    unsigned int if_index;         
    uint32_t prog_id;              
    pktmbuf_info_t *pi;            
    xskdev_rxq_t rxq;              
    xskdev_txq_t txq;              
    lport_stats_t stats;           
    pthread_mutex_t tx_lock;       
    int xdp_flags;                 
    uint32_t busy_timeout;         
    uint32_t busy_budget;          
    uds_info_t *uds_info;          
    int xsk_map_fd;                
    /* byte flags to mirror the lport_cfg_t.flags bits */
    bool unprivileged; 
    bool needs_wakeup; 
    bool skb_mode;     
    bool busy_polling; 
    bool shared_umem;  
    lport_buf_mgmt_t buf_mgmt; 
    xskdev_get_mbuf_addr_tx_t
        __get_mbuf_addr_tx;               
    xskdev_get_mbuf_rx_t __get_mbuf_rx;   
    xskdev_pull_cq_addr_t __pull_cq_addr; 
    struct xdp_statistics orig_stats; 
} xskdev_info_t;
 
CNDP_API xskdev_info_t *xskdev_socket_create(struct lport_cfg *c);
 
CNDP_API void xskdev_socket_destroy(xskdev_info_t *xi);
 
CNDP_API __cne_always_inline uint16_t
xskdev_rx_burst(xskdev_info_t *xi, void **bufs, uint16_t nb_pkts)
{
    return xi->buf_mgmt.buf_rx_burst(xi, bufs, nb_pkts);
}
 
CNDP_API __cne_always_inline uint16_t
xskdev_tx_burst(xskdev_info_t *xi, void **bufs, uint16_t nb_pkts)
{
    return xi->buf_mgmt.buf_tx_burst(xi, bufs, nb_pkts);
}
 
CNDP_API int xskdev_stats_get(xskdev_info_t *xi, lport_stats_t *stats);
 
CNDP_API int xskdev_stats_reset(xskdev_info_t *xi);
 
CNDP_API void xskdev_dump(xskdev_info_t *xi, uint32_t flags);
 
CNDP_API void xskdev_dump_all(uint32_t flags);
 
CNDP_API int xskdev_print_stats(const char *name, lport_stats_t *s, bool dbg_stats);
 
CNDP_API __cne_always_inline void *
xskdev_arg_get(xskdev_info_t *xi)
{
    return xi->buf_mgmt.buf_arg;
}
 
CNDP_API __cne_always_inline int
xskdev_buf_alloc(xskdev_info_t *xi, void **bufs, uint16_t nb_bufs)
{
    return xi->buf_mgmt.buf_alloc(xskdev_arg_get(xi), bufs, nb_bufs);
}
 
CNDP_API __cne_always_inline void
xskdev_buf_free(xskdev_info_t *xi, void **bufs, uint16_t nb_bufs)
{
    xi->buf_mgmt.buf_free(xskdev_arg_get(xi), bufs, nb_bufs);
}
 
CNDP_API __cne_always_inline void
xskdev_buf_set_len(xskdev_info_t *xi, void *buf, int len)
{
    xi->buf_mgmt.buf_set_len(buf, len);
}
 
CNDP_API __cne_always_inline void
xskdev_buf_set_data_len(xskdev_info_t *xi, void *buf, int len)
{
    xi->buf_mgmt.buf_set_data_len(buf, len);
}
 
CNDP_API __cne_always_inline void
xskdev_buf_set_data(xskdev_info_t *xi, void *buf, uint64_t off)
{
    xi->buf_mgmt.buf_set_data(buf, off);
}
 
CNDP_API __cne_always_inline uint16_t
xskdev_buf_get_data_len(xskdev_info_t *xi, void *buf)
{
    return xi->buf_mgmt.buf_get_data_len(buf);
}
 
CNDP_API __cne_always_inline uint64_t
xskdev_buf_get_data(xskdev_info_t *xi, void *buf)
{
    return xi->buf_mgmt.buf_get_data(buf);
}
 
CNDP_API __cne_always_inline uint64_t
xskdev_buf_get_addr(xskdev_info_t *xi, void *buf)
{
    return xi->buf_mgmt.buf_get_addr(buf);
}
 
CNDP_API __cne_always_inline void **
xskdev_buf_inc_ptr(xskdev_info_t *xi, void **buf)
{
    return xi->buf_mgmt.buf_inc_ptr(buf);
}
 
CNDP_API __cne_always_inline void
xskdev_buf_reset(xskdev_info_t *xi, void *buf, uint32_t buf_len, size_t headroom)
{
    xi->buf_mgmt.buf_reset(buf, buf_len, headroom);
}
 
#ifdef __cplusplus
}
#endif
 
#endif /* _XSKDEV_H_ */