cne_acl.h

Go to the documentation of this file.

/* SPDX-License-Identifier: BSD-3-Clause
 * Copyright (c) 2010-2022 Intel Corporation
 */
 
#ifndef _CNE_ACL_H_
#define _CNE_ACL_H_
 
#include <cne_acl_osdep.h>
#include <limits.h>        // for CHAR_BIT
#include <stddef.h>        // for size_t
#include <stdint.h>        // for uint32_t, uint8_t, int32_t, uint16_t, uint64_t
 
#include "cne_common.h"        // for CNE_LEN2MASK
#include "cne_vect.h"          // for XMM_SIZE
 
struct cne_acl_ctx;
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define CNE_ACL_MAX_CATEGORIES 16
 
#define CNE_ACL_RESULTS_MULTIPLIER (XMM_SIZE / sizeof(uint32_t))
 
#define CNE_ACL_MAX_LEVELS 64
#define CNE_ACL_MAX_FIELDS 64
 
union cne_acl_field_types {
    uint8_t u8;
    uint16_t u16;
    uint32_t u32;
    uint64_t u64;
};
 
enum { CNE_ACL_FIELD_TYPE_MASK = 0, CNE_ACL_FIELD_TYPE_RANGE, CNE_ACL_FIELD_TYPE_BITMASK };
 
struct cne_acl_field_def {
    uint8_t type;        
    uint8_t size;        
    uint8_t field_index; 
    uint8_t input_index; 
    uint32_t offset;     
};
 
struct cne_acl_config {
    uint32_t num_categories; 
    uint32_t num_fields;     
    struct cne_acl_field_def defs[CNE_ACL_MAX_FIELDS];
    size_t max_size;
};
 
struct cne_acl_field {
    union cne_acl_field_types value;
    union cne_acl_field_types mask_range;
};
 
enum {
    CNE_ACL_TYPE_SHIFT   = 29,
    CNE_ACL_MAX_INDEX    = CNE_LEN2MASK(CNE_ACL_TYPE_SHIFT, uint32_t),
    CNE_ACL_MAX_PRIORITY = CNE_ACL_MAX_INDEX,
    CNE_ACL_MIN_PRIORITY = 1,
};
 
#define CNE_ACL_MASKLEN_TO_BITMASK(v, s) \
    ((v) == 0 ? (v) : (typeof(v))((uint64_t)-1 << ((s)*CHAR_BIT - (v))))
 
struct cne_acl_rule_data {
    uint32_t category_mask; 
    int32_t priority;       
    uint32_t userdata;      
};
 
#define CNE_ACL_RULE_DEF(name, fld_num)      \
    struct name {                            \
        struct cne_acl_rule_data data;       \
        struct cne_acl_field field[fld_num]; \
    }
 
CNE_ACL_RULE_DEF(cne_acl_rule, );
 
#define CNE_ACL_RULE_SZ(fld_num) \
    (sizeof(struct cne_acl_rule) + sizeof(struct cne_acl_field) * (fld_num))
 
#define CNE_ACL_NAMESIZE 32
 
struct cne_acl_param {
    const char *name;      
    uint32_t rule_size;    
    uint32_t max_rule_num; 
};
enum cne_acl_classify_alg {
    CNE_ACL_CLASSIFY_DEFAULT   = 0,
    CNE_ACL_CLASSIFY_SCALAR    = 1, 
    CNE_ACL_CLASSIFY_SSE       = 2, 
    CNE_ACL_CLASSIFY_AVX2      = 3, 
    CNE_ACL_CLASSIFY_NEON      = 4, 
    CNE_ACL_CLASSIFY_ALTIVEC   = 5, 
    CNE_ACL_CLASSIFY_AVX512X16 = 6, 
    CNE_ACL_CLASSIFY_AVX512X32 = 7, 
    CNE_ACL_CLASSIFY_NUM            /* should always be the last one. */
};
 
struct cne_acl_ctx *cne_acl_create(const struct cne_acl_param *param);
 
void cne_acl_free(struct cne_acl_ctx *ctx);
 
int cne_acl_add_rules(struct cne_acl_ctx *ctx, const struct cne_acl_rule *rules, uint32_t num);
 
void cne_acl_reset_rules(struct cne_acl_ctx *ctx);
 
int cne_acl_build(struct cne_acl_ctx *ctx, const struct cne_acl_config *cfg);
 
void cne_acl_reset(struct cne_acl_ctx *ctx);
 
void cne_acl_set_algo(struct cne_acl_ctx *ctx, enum cne_acl_classify_alg algo);
 
extern int cne_acl_classify(const struct cne_acl_ctx *ctx, const uint8_t **data, uint32_t *results,
                            uint32_t num, uint32_t categories);
 
extern int cne_acl_classify_alg(const struct cne_acl_ctx *ctx, const uint8_t **data,
                                uint32_t *results, uint32_t num, uint32_t categories,
                                enum cne_acl_classify_alg alg);
 
/*
 * Override the default classifier function for a given ACL context.
 * @param ctx
 *   ACL context to change classify function for.
 * @param alg
 *   New default classify algorithm for given ACL context.
 *   It is the caller responsibility to ensure that the value refers to the
 *   existing algorithm, and that it could be run on the given CPU.
 * @return
 *   - -EINVAL if the parameters are invalid.
 *   - Zero if operation completed successfully.
 */
extern int cne_acl_set_ctx_classify(struct cne_acl_ctx *ctx, enum cne_acl_classify_alg alg);
 
void cne_acl_dump(const struct cne_acl_ctx *ctx);
 
#ifdef __cplusplus
}
#endif
 
#endif /* _CNE_ACL_H_ */