cne_common.h

Go to the documentation of this file.

/* SPDX-License-Identifier: BSD-3-Clause
 * Copyright (c) 2019-2022 Intel Corporation
 */
 
#ifndef _CNE_COMMON_H_
#define _CNE_COMMON_H_
 
#include <stdint.h>
#include <stdlib.h>
#include <ctype.h>
#include <errno.h>
#include <limits.h>
#include <unistd.h>
#include <sys/syscall.h>
#include <linux/version.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#ifndef typeof
#define typeof __typeof__
#endif
 
#ifndef asm
#define asm __asm__
#endif
 
#define CNE_VER_PREFIX       "CNDP"
#define CNE_NAME_LEN         24
#define XDP_PKT_HEADROOM     256 
#define CNE_PKTMBUF_HEADROOM (XDP_PKT_HEADROOM - sizeof(pktmbuf_t))
#define CNE_CACHE_LINE_SIZE  64
 
#define PKTDEV_QUEUE_STAT_CNTRS 16
#define CNE_MAX_QUEUES_PER_PORT 128
#define CNE_MAX_ETHPORTS        32
#define MEMPOOL_CACHE_MAX_SIZE  256
 
#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 10, 0) && HAS_XSK_UMEM_SHARED == 1
#define CAN_USE_XSK_UMEM_SHARED 1
#endif
 
#define CNE_DEFAULT_SET(x, y, z) \
    do {                         \
        if (x == y)              \
            x = z;               \
    } while ((0))
 
#define CNE_MAX_SET(x, z) \
    do {                  \
        if (x > z)        \
            x = z;        \
    } while ((0))
 
#if !defined(__STDC_VERSION__) || __STDC_VERSION__ < 201112L
#define CNE_STD_C11 __extension__
#else
#define CNE_STD_C11
#endif
 
typedef uint64_t unaligned_uint64_t;
typedef uint32_t unaligned_uint32_t;
typedef uint16_t unaligned_uint16_t;
 
#define CNDP_API __attribute__((visibility("default")))
 
#ifdef CNE_BUILD_SHARED_LIBS
#define FUNCTION_VERSION(internal, api, ver) __asm__(".symver " #internal ", " #api "@" #ver)
#define DEFAULT_VERSION(internal, api, ver)  __asm__(".symver " #internal ", " #api "@@" #ver)
#else
#define FUNCTION_VERSION(internal, api, ver)
#define DEFAULT_VERSION(internal, api, ver)
#endif
 
#define cne_compiler_barrier()           \
    do {                                 \
        asm volatile("" : : : "memory"); \
    } while (0)
 
#define __cne_aligned(a) __attribute__((aligned(a)))
 
#define __cne_packed __attribute__((__packed__))
 
/******* Macro to mark functions and fields scheduled for removal *****/
#define __cne_deprecated __attribute__((__deprecated__))
 
#define __cne_weak __attribute__((__weak__))
 
/*********** Macros to eliminate unused variable warnings ********/
 
#define __cne_unused __attribute__((__unused__))
 
#define CNE_SET_USED(x) (void)(x)
 
#define cne_roundup(_x, _y) ((((_x) + ((_y)-1)) / (_y)) * (_y))
#define cne_ctz(_v)         __builtin_ctz(_v)
#define cne_prefixbits(_v)  ((__typeof__(_v))(sizeof(_v) * 8) - cne_ctz(_v))
#define cne_numbytes(_v)    ((cne_prefixbits(_v) + 7) / 8)
 
#define CNE_PRIORITY_INIT   101
#define CNE_PRIORITY_START  102
#define CNE_PRIORITY_THREAD 103
#define CNE_PRIORITY_STATE  110
#define CNE_PRIORITY_CLASS  120
#define CNE_PRIORITY_STACK  130
#define CNE_PRIORITY_LAST   65535
 
#define CNE_PRIO(prio) CNE_PRIORITY_##prio
 
#ifndef CNE_INIT_PRIO /* Allow to override from CNE */
#define CNE_INIT_PRIO(func, prio) \
    static void __attribute__((constructor(CNE_PRIO(prio)), used)) func(void)
#endif
 
#define CNE_INIT(func) CNE_INIT_PRIO(func, LAST)
 
#ifndef CNE_FINI_PRIO /* Allow to override from CNE */
#define CNE_FINI_PRIO(func, prio) \
    static void __attribute__((destructor(CNE_PRIO(prio)), used)) func(void)
#endif
 
#define CNE_FINI(func) CNE_FINI_PRIO(func, LAST)
 
#define __cne_always_inline inline __attribute__((__always_inline__))
 
#define __cne_noinline __attribute__((__noinline__))
 
#define CNE_PTR_CAST(ptr, x) (x)((uintptr_t)(ptr))
 
/*********** Macros for pointer arithmetic ********/
 
#define CNE_PTR_ADD(ptr, x) ((void *)((uintptr_t)(ptr) + (x)))
 
#define CNE_PTR_SUB(ptr, x) ((void *)((uintptr_t)ptr - (x)))
 
#define CNE_PTR_DIFF(ptr1, ptr2) ((uintptr_t)(ptr1) - (uintptr_t)(ptr2))
 
#define CNE_CAST_FIELD(var, field, type) \
    (*(type *)((uintptr_t)(var) + offsetof(typeof(*(var)), field)))
 
/*********** Macros/static functions for doing alignment ********/
 
#define CNE_PTR_ALIGN_FLOOR(ptr, align) ((typeof(ptr))CNE_ALIGN_FLOOR((uintptr_t)ptr, align))
 
#define CNE_ALIGN_FLOOR(val, align) (typeof(val))((val) & (~((typeof(val))((align)-1))))
 
#define CNE_PTR_ALIGN_CEIL(ptr, align) \
    CNE_PTR_ALIGN_FLOOR((typeof(ptr))CNE_PTR_ADD(ptr, (align)-1), align)
 
#define CNE_ALIGN_CEIL(val, align) CNE_ALIGN_FLOOR(((val) + ((typeof(val))(align)-1)), align)
 
#define CNE_PTR_ALIGN(ptr, align) CNE_PTR_ALIGN_CEIL(ptr, align)
 
#define CNE_ALIGN(val, align) CNE_ALIGN_CEIL(val, align)
 
#define CNE_ALIGN_MUL_CEIL(v, mul) \
    (((v + (typeof(v))(mul)-1) / ((typeof(v))(mul))) * (typeof(v))(mul))
 
#define CNE_ALIGN_MUL_FLOOR(v, mul) ((v / ((typeof(v))(mul))) * (typeof(v))(mul))
 
#define CNE_ALIGN_MUL_NEAR(v, mul)                     \
    ({                                                 \
        typeof(v) ceil  = CNE_ALIGN_MUL_CEIL(v, mul);  \
        typeof(v) floor = CNE_ALIGN_MUL_FLOOR(v, mul); \
        (ceil - v) > (v - floor) ? floor : ceil;       \
    })
 
static inline int
cne_is_aligned(void *ptr, unsigned align)
{
    return CNE_PTR_ALIGN(ptr, (uintptr_t)align) == ptr;
}
 
/*********** Macros for compile type checks ********/
 
#define CNE_BUILD_BUG_ON(condition) ((void)sizeof(char[1 - 2 * !!(condition)]))
 
/*********** Cache line related macros ********/
 
#define CNE_CACHE_LINE_MASK (CNE_CACHE_LINE_SIZE - 1)
 
#define CNE_CACHE_LINE_ROUNDUP(size) \
    (CNE_CACHE_LINE_SIZE * ((size + CNE_CACHE_LINE_SIZE - 1) / CNE_CACHE_LINE_SIZE))
 
#if CNE_CACHE_LINE_SIZE == 64
#define CNE_CACHE_LINE_SIZE_LOG2 6
#else
#error "Unsupported cache line size"
#endif
 
#define CNE_CACHE_LINE_MIN_SIZE 64
 
#define __cne_cache_aligned __cne_aligned(CNE_CACHE_LINE_SIZE)
 
#define __cne_cache_min_aligned __cne_aligned(CNE_CACHE_LINE_MIN_SIZE)
 
__extension__ typedef void *CNE_MARKER[0];
__extension__ typedef uint8_t CNE_MARKER8[0];
__extension__ typedef uint16_t CNE_MARKER16[0];
__extension__ typedef uint32_t CNE_MARKER32[0];
__extension__ typedef uint64_t CNE_MARKER64[0];
 
/*********** PA/IOVA type definitions ********/
 
typedef uint64_t phys_addr_t;
#define CNE_BAD_PHYS_ADDR ((phys_addr_t)-1)
 
typedef uint64_t cne_iova_t;
#define CNE_BAD_IOVA ((cne_iova_t)-1)
 
static inline uint32_t
cne_combine32ms1b(uint32_t x)
{
    x |= x >> 1;
    x |= x >> 2;
    x |= x >> 4;
    x |= x >> 8;
    x |= x >> 16;
 
    return x;
}
 
static inline uint64_t
cne_combine64ms1b(uint64_t v)
{
    v |= v >> 1;
    v |= v >> 2;
    v |= v >> 4;
    v |= v >> 8;
    v |= v >> 16;
    v |= v >> 32;
 
    return v;
}
 
/*********** Macros to work with powers of 2 ********/
 
#define CNE_IS_POWER_OF_2(n) ((n) && !(((n)-1) & (n)))
 
static inline int
cne_is_power_of_2(uint32_t n)
{
    return n && !(n & (n - 1));
}
 
static inline uint32_t
cne_align32pow2(uint32_t x)
{
    x--;
    x = cne_combine32ms1b(x);
 
    return x + 1;
}
 
static inline uint32_t
cne_align32prevpow2(uint32_t x)
{
    x = cne_combine32ms1b(x);
 
    return x - (x >> 1);
}
 
static inline uint64_t
cne_align64pow2(uint64_t v)
{
    v--;
    v = cne_combine64ms1b(v);
 
    return v + 1;
}
 
static inline uint64_t
cne_align64prevpow2(uint64_t v)
{
    v = cne_combine64ms1b(v);
 
    return v - (v >> 1);
}
 
/*********** Macros for calculating min and max **********/
 
#define CNE_MIN(a, b)       \
    __extension__({         \
        typeof(a) _a = (a); \
        typeof(b) _b = (b); \
        _a < _b ? _a : _b;  \
    })
 
#define CNE_MAX(a, b)       \
    __extension__({         \
        typeof(a) _a = (a); \
        typeof(b) _b = (b); \
        _a > _b ? _a : _b;  \
    })
 
/*********** Other general functions / macros ********/
 
static inline uint32_t
cne_bsf32(uint32_t v)
{
    return (uint32_t)__builtin_ctz(v);
}
 
static inline int
cne_bsf32_safe(uint64_t v, uint32_t *pos)
{
    if (v == 0)
        return 0;
 
    *pos = cne_bsf32(v);
    return 1;
}
 
static inline uint32_t
cne_log2_u32(uint32_t v)
{
    if (v == 0)
        return 0;
    v = cne_align32pow2(v);
    return cne_bsf32(v);
}
 
static inline int
cne_fls_u32(uint32_t x)
{
    return (x == 0) ? 0 : 32 - __builtin_clz(x);
}
 
static inline int
cne_bsf64(uint64_t v)
{
    return (uint32_t)__builtin_ctzll(v);
}
 
static inline int
cne_bsf64_safe(uint64_t v, uint32_t *pos)
{
    if (v == 0)
        return 0;
 
    *pos = cne_bsf64(v);
    return 1;
}
 
static inline int
cne_fls_u64(uint64_t x)
{
    return (x == 0) ? 0 : 64 - __builtin_clzll(x);
}
 
static inline uint32_t
cne_log2_u64(uint64_t v)
{
    if (v == 0)
        return 0;
    v = cne_align64pow2(v);
    /* we checked for v being 0 already, so no undefined behavior */
    return cne_bsf64(v);
}
 
#ifndef offsetof
#define offsetof(TYPE, MEMBER) __builtin_offsetof(TYPE, MEMBER)
#endif
 
#ifndef container_of
#define container_of(ptr, type, member)                            \
    __extension__({                                                \
        const typeof(((type *)0)->member) *_ptr   = (ptr);         \
        __attribute__((unused)) type *_target_ptr = (type *)(ptr); \
        (type *)(((uintptr_t)_ptr) - offsetof(type, member));      \
    })
#endif
 
#define CNE_SIZEOF_FIELD(type, field) (sizeof(((type *)0)->field))
 
#define _CNE_STR(x) #x
#define CNE_STR(x) _CNE_STR(x)
 
#define CNE_FMT(fmt, ...)      fmt "%.0s", __VA_ARGS__ ""
#define CNE_FMT_HEAD(fmt, ...) fmt
#define CNE_FMT_TAIL(fmt, ...) __VA_ARGS__
 
#define CNE_LEN2MASK(ln, tp) ((tp)((uint64_t)-1 >> (sizeof(uint64_t) * CHAR_BIT - (ln))))
 
#define CNE_DIM(a)     (int)(sizeof(a) / sizeof((a)[0]))
#define cne_countof(a) CNE_DIM(a)
 
static inline uint64_t
cne_str_to_size(const char *str)
{
    char *endptr;
    unsigned long long size;
 
    while (isspace((int)*str))
        str++;
    if (*str == '-')
        return 0;
 
    errno = 0;
    size  = strtoull(str, &endptr, 0);
    if (errno)
        return 0;
 
    if (*endptr == ' ')
        endptr++; /* allow 1 space gap */
 
    switch (*endptr) {
    case 'G':
    case 'g':
        size *= 1024; /* fall-through */
    case 'M':
    case 'm':
        size *= 1024; /* fall-through */
    case 'K':
    case 'k':
        size *= 1024; /* fall-through */
    default:
        break;
    }
    return size;
}
 
#ifdef __cplusplus
}
#endif
 
#endif