cnet_fib_info.h

Go to the documentation of this file.

/* SPDX-License-Identifier: BSD-3-Clause
 * Copyright (c) 2016-2022 Intel Corporation
 */
 
#ifndef __CNET_FIB_INFO_H
#define __CNET_FIB_INFO_H
 
#include <stddef.h>               // for NULL
#include <stdint.h>               // for uint8_t, uint32_t
#include <sys/queue.h>            // for TAILQ_HEAD
#include <bsd/sys/queue.h>        // for TAILQ_HEAD
 
#include <cne_rwlock.h>
#include <cne_fib.h>
 
struct rt4_entry;
#ifdef __cplusplus
extern "C" {
#endif
 
typedef struct fib_info {
    struct cne_fib *fib;  
    void **idx2obj;       
    cne_rwlock_t lock;    
    uint32_t objcnt;      
    uint32_t mask;        
    uint32_t index_shift; 
    uint32_t index;       
} fib_info_t;
 
static inline uint32_t
fi_obj_index(fib_info_t *fi, uint32_t idx)
{
    uint32_t obj_idx = UINT32_MAX;
 
    if (fi)
        obj_idx = (idx & ((1UL << fi->index_shift) - 1));
 
    return obj_idx;
}
 
static inline int
fib_info_alloc(fib_info_t *fi, void *obj)
{
    uint32_t idx, prev_idx;
 
    cne_rwlock_write_lock(&fi->lock);
    idx = prev_idx = fi->index;
 
    prev_idx--;
    prev_idx = (prev_idx & fi->mask);
    while (fi->idx2obj[idx] && (idx != prev_idx)) {
        idx++;
        idx = (idx & fi->mask);
    }
 
    if (idx == prev_idx) {
        cne_rwlock_write_unlock(&fi->lock);
        return -1;
    }
 
    fi->idx2obj[idx] = obj;
    fi->index        = idx;
    cne_rwlock_write_unlock(&fi->lock);
 
    return idx;
}
 
static inline void *
fib_info_free(fib_info_t *fi, uint32_t idx)
{
    void *obj = NULL;
 
    cne_rwlock_write_lock(&fi->lock);
 
    idx = fi_obj_index(fi, idx);
 
    if (idx < fi->objcnt) {
        obj = fi->idx2obj[idx];
 
        fi->idx2obj[idx] = NULL;
    }
    cne_rwlock_write_unlock(&fi->lock);
    return obj;
}
 
static inline void
fib_info_destroy(fib_info_t *fi)
{
    if (fi) {
        if (fi->idx2obj)
            free(fi->idx2obj);
        if (fi->fib)
            cne_fib_free(fi->fib);
        free(fi);
    }
}
 
static inline fib_info_t *
fib_info_create(struct cne_fib *fib, uint32_t objcnt, uint32_t index_shift)
{
    fib_info_t *fi;
 
    if (!fib || objcnt == 0 || index_shift == 0)
        return NULL;
 
    fi = calloc(1, sizeof(fib_info_t));
    if (fi) {
        fi->fib         = fib;
        fi->objcnt      = cne_align32pow2(objcnt);
        fi->mask        = fi->objcnt - 1;
        fi->index_shift = index_shift;
        cne_rwlock_init(&fi->lock);
 
        fi->idx2obj = calloc(fi->objcnt, sizeof(void *));
        if (!fi->idx2obj) {
            fib_info_destroy(fi);
            return NULL;
        }
    }
 
    return fi;
}
 
static inline void *
fib_info_object_get(fib_info_t *fi, uint32_t idx)
{
    if (!fi)
        return NULL;
 
    idx = fi_obj_index(fi, idx);
 
    if (idx >= fi->objcnt)
        return NULL;
 
    return fi->idx2obj[idx];
}
 
static inline int
fib_info_index_valid(fib_info_t *fi, uint32_t idx)
{
    idx = fi_obj_index(fi, idx);
 
    if (fi && (idx < fi->objcnt))
        return 1;
 
    return 0;
}
 
static inline struct cne_fib *
fib_info_get_fib(fib_info_t *fi)
{
    return (fi) ? fi->fib : NULL;
}
 
typedef int (*fib_func_t)(void *obj, void *arg);
 
static inline int
fib_info_foreach(fib_info_t *fi, fib_func_t func, void *arg)
{
    if (fi) {
        for (uint32_t i = 0; i < fi->objcnt; i++) {
            void *obj = fib_info_object_get(fi, i);
 
            if (obj && (func(obj, arg) < 0))
                return -1;
        }
    }
    return 0;
}
 
static inline int
fib_info_get(fib_info_t *fi, uint64_t *idxs, void **objs, int n)
{
    void *objects[n];
    int i, k;
 
    if (!fi || !idxs)
        return -1;
 
    if (!objs)
        objs = objects;
 
    memset(objs, 0, sizeof(void *) * n);
 
    for (i = 0, k = 0; i < n; i++) {
        objs[i] = fib_info_object_get(fi, (uint32_t)idxs[i]);
 
        if (objs[i])
            k++;
    }
    return k;
}
 
static inline int
fib_info_lookup(fib_info_t *fi, uint32_t *ip, void **objs, int n)
{
    if (fi && ip) {
        uint64_t nh[n];
 
        if (cne_fib_lookup_bulk(fi->fib, ip, nh, n) == 0)
            return fib_info_get(fi, nh, objs, n);
    }
    return 0;
}
 
static inline int
fib_info_lookup_index(fib_info_t *fi, uint32_t *ip, uint64_t *idxs, int n)
{
    if (!fi || !ip || !idxs)
        return -1;
    return cne_fib_lookup_bulk(fi->fib, ip, idxs, n) == 0;
}
 
#ifdef __cplusplus
}
#endif
 
#endif /* __CNET_FIB_INFO_H */