jcfg.h

Go to the documentation of this file.

/* SPDX-License-Identifier: BSD-3-Clause
 * Copyright (c) 2019-2022 Intel Corporation.
 */
 
#ifndef _JCFG_H_
#define _JCFG_H_
 
#include <pthread.h>           // for pthread_t
#include <sched.h>             // for cpu_set_t
#include <stdint.h>            // for uint16_t, uint32_t, uint64_t, int64_t
#include <sys/socket.h>        // for accept, bind, listen, socket, AF_UNIX
#include <sys/queue.h>         // for STAILQ_ENTRY, STAILQ_HEAD
#include <sys/un.h>            // for sockaddr_un
#include <bsd/sys/bitstring.h>
#include <json-c/json_object.h>
#include <json-c/json_tokener.h>
#include <json-c/json_util.h>
#include <json-c/json_visit.h>        // for json_c_visit_userfunc
#include <json-c/linkhash.h>
#include <cne_common.h>        // for CNDP_API, CNE_STD_C11
#include <cne_log.h>
#include <cne_mmap.h>        // for mmap_t
#include <cne_thread.h>
#include <pktmbuf.h>        // for pktmbuf_info_t
 
#define DEFAULT_CHUNK_SIZE   1024
#define UMEM_MAX_REGIONS     128
#define JCFG_MAX_STRING_SIZE 32
 
#ifdef __cplusplus
extern "C" {
#endif
 
struct json_object;
 
#define APP_TAG         "application"
#define DEFAULT_TAG     "defaults"
#define OPTION_TAG      "options"
#define UMEM_TAG        "umems"
#define LPORT_TAG       "lports"
#define LGROUP_TAG      "lcore-groups"
#define THREAD_TAG      "threads"
#define LPORT_GROUP_TAG "lport-groups"
#define USER_TAG        "users"
 
#define JCFG_TAG_NAMES                                                                 \
    {                                                                                  \
        APP_TAG, DEFAULT_TAG, OPTION_TAG, UMEM_TAG, LPORT_TAG, LGROUP_TAG, THREAD_TAG, \
            LPORT_GROUP_TAG, USER_TAG,                                                 \
    }
 
typedef enum {
    /* jcfg_opt_t types */
    JCFG_APPLICATION_TYPE, 
    JCFG_DEFAULT_TYPE,     
    JCFG_OPTION_TYPE,      
    /* Non jcfg_opt_t types */
    JCFG_UMEM_TYPE,        
    JCFG_LPORT_TYPE,       
    JCFG_LGROUP_TYPE,      
    JCFG_THREAD_TYPE,      
    JCFG_LPORT_GROUP_TYPE, 
    JCFG_USER_TYPE,        
    JCFG_MAX_TYPES 
} jcfg_cb_type_t;
 
typedef enum {
    UNKNOWN_OPT_TYPE,
    BOOLEAN_OPT_TYPE,
    STRING_OPT_TYPE,
    INTEGER_OPT_TYPE,
    ARRAY_OPT_TYPE,
    OBJECT_OPT_TYPE
} obj_type_t;
 
typedef struct obj_value {
    obj_type_t type;    
    uint16_t array_sz;  
    uint16_t reserved;  /* reserved space */
    CNE_STD_C11 union { /* Use union members directly */
        int boolean;    
        int64_t value;  
        char *str;      
        struct obj_value **arr;
    };
} obj_value_t;
 
#define JCFG_COMMON_HDR(_t)                                         \
    STAILQ_ENTRY(_t) next;  \
    char *name;                           \
    char *desc;                \
    void *priv_;                   \
    jcfg_cb_type_t cbtype  
typedef struct jcfg_hdr {
    JCFG_COMMON_HDR(jcfg_hdr); 
} jcfg_hdr_t;
 
typedef struct jcfg_opt {
    JCFG_COMMON_HDR(jcfg_opt); 
    obj_value_t val;           
} jcfg_opt_t;
 
typedef struct region_info {
    char *addr;           
    pktmbuf_info_t *pool; 
    uint32_t bufcnt;      
} region_info_t;
 
typedef struct jcfg_umem {
    JCFG_COMMON_HDR(jcfg_umem); 
    mmap_t *mm;                 
    uint32_t bufcnt;            
    uint32_t bufsz;             
    uint16_t mtype;             
    uint16_t rxdesc;            
    uint16_t txdesc;            
    uint16_t idx;               
    uint16_t shared_umem;       
    uint16_t region_cnt;        
    region_info_t *rinfo;       
} jcfg_umem_t;
 
typedef struct jcfg_lport {
    JCFG_COMMON_HDR(jcfg_lport); 
    char *netdev;                
    char *pmd_name;              
    char *pmd_opts;              
    char *umem_name;             
    jcfg_umem_t *umem;           
    uint16_t region_idx;         
    uint16_t lpid;               
    uint16_t qid;                
    uint16_t busy_timeout;       
    uint16_t busy_budget;        
    uint16_t flags; 
} jcfg_lport_t;
 
#define JCFG_LPORT_PMD_NAME          "pmd"
#define JCFG_LPORT_UMEM_NAME         "umem"
#define JCFG_LPORT_REGION_NAME       "region"
#define JCFG_LPORT_QID_NAME          "qid"
#define JCFG_LPORT_DESCRIPTION_NAME  "description"
#define JCFG_LPORT_DESC_NAME         "desc"
#define JCFG_LPORT_BUSY_POLL_NAME    "busy_poll"
#define JCFG_LPORT_BUSY_POLLING_NAME "busy_polling"
#define JCFG_LPORT_BUSY_TIMEOUT_NAME "busy_timeout"
#define JCFG_LPORT_BUSY_BUDGET_NAME  "busy_budget"
#define JCFG_LPORT_UNPRIVILEGED_NAME "unprivileged"
#define JCFG_LPORT_FORCE_WAKEUP_NAME "force_wakeup"
#define JCFG_LPORT_SKB_MODE_NAME     "skb_mode"
 
typedef struct jcfg_lgroup {
    JCFG_COMMON_HDR(jcfg_lgroup); 
    uint16_t lcore_cnt;           
    cpu_set_t lcore_bitmap;       
} jcfg_lgroup_t;
 
typedef struct jcfg_thd {
    JCFG_COMMON_HDR(jcfg_thd); 
    char *group_name;          
    char *thread_type;         
    jcfg_lgroup_t *group;      
    uint16_t lport_cnt;        
    uint16_t lport_sz;         
    uint16_t idx;              
    char **lport_names;        
    jcfg_lport_t **lports;     
    int tid;                   
    volatile uint16_t quit;    
    volatile uint16_t pause;   
} jcfg_thd_t;
 
typedef struct jcfg_lport_group {
    JCFG_COMMON_HDR(jcfg_lport_group); 
    char **netdev_names;               
    int num_netdev_names;              
    char **thread_names;               
    int num_thread_names;              
    void *qlist;                       
    uint16_t *max_q;                   
    uint16_t total_q;                  
    char *pmd_name;                    
    char *pmd_opts;                    
    char *umem_name;                   
    jcfg_umem_t *umem;                 
    uint16_t busy_timeout;             
    uint16_t busy_budget;              
    uint16_t flags; 
} jcfg_lport_group_t;
 
#define JCFG_LPORT_GROUP_NETDEV_NAMES_NAME "netdevs"
#define JCFG_LPORT_GROUP_QUEUES_NAME       "queues"
#define JCFG_LPORT_GROUP_THREAD_NAMES_NAME "threads"
 
typedef struct jcfg_user {
    JCFG_COMMON_HDR(jcfg_user); 
    obj_value_t val;            
} jcfg_user_t;
 
typedef struct jcfg_list {
    int cnt;     
    int sz;      
    void **list; 
} jcfg_list_t;
 
typedef struct jcfg_data {
    STAILQ_HEAD(, jcfg_opt) application; 
    STAILQ_HEAD(, jcfg_opt) defaults;    
    STAILQ_HEAD(, jcfg_opt) options;     
    STAILQ_HEAD(, jcfg_umem) umems;      
    STAILQ_HEAD(, jcfg_lport) lports;    
    STAILQ_HEAD(, jcfg_lgroup) lgroups;  
    STAILQ_HEAD(, jcfg_thd) threads;     
    STAILQ_HEAD(, jcfg_lport_group) lport_groups;
    STAILQ_HEAD(, jcfg_user) users; 
    jcfg_list_t lport_list;         
    jcfg_list_t umem_list;          
    jcfg_list_t thd_list;           
    int thread_count;               
    int lport_count;                
    int umem_count;                 
    int app_count;                  
    int default_count;              
    int opt_count;                  
    int lgroup_count;               
    int lport_group_count;          
    int user_count;                 
} jcfg_data_t;
 
typedef union {
    jcfg_hdr_t *hdr;         
    jcfg_opt_t *app;         
    jcfg_opt_t *def;         
    jcfg_opt_t *opt;         
    jcfg_umem_t *umem;       
    jcfg_lport_t *lport;     
    jcfg_lgroup_t *lgroup;   
    jcfg_thd_t *thd;         
    jcfg_lport_group_t *lpg; 
    jcfg_user_t *usr;        
} jcfg_obj_t;
 
struct jcfg_info_s;
 
typedef int jcfg_parse_cb_t(struct jcfg_info_s *jinfo, void *obj, void *arg, int idx);
 
typedef struct jcfg_info_s {
    uint32_t flags;         
    int listen_sock;        
    struct sockaddr_un sun; 
    volatile int running;   
    void *cfg;              
    jcfg_parse_cb_t *cb;    
} jcfg_info_t;
 
enum {
    JCFG_NO_FLAGS         = 0,
    JCFG_INFO_VERBOSE     = (1 << 0), 
    JCFG_DEBUG_DECODING   = (1 << 1), 
    JCFG_DEBUG_PARSING    = (1 << 2), 
    JCFG_INFO_STRICT_FLAG = (1 << 3), 
    JCFG_PARSE_FILE       = (1 << 4), 
    JCFG_PARSE_SOCKET     = (1 << 5), 
    JCFG_PARSE_STRING     = (1 << 6), 
};
 
typedef int jcfg_cb_t(jcfg_info_t *jinfo, void *obj, void *arg, int idx);
 
CNDP_API int jcfg_object_foreach(jcfg_info_t *jinfo, jcfg_cb_type_t cbtype, jcfg_cb_t *func,
                                 void *arg);
 
#define jcfg_application_foreach(j, f, a) jcfg_object_foreach(j, JCFG_APPLICATION_TYPE, f, a)
#define jcfg_defaults_foreach(j, f, a)    jcfg_object_foreach(j, JCFG_DEFAULT_TYPE, f, a)
#define jcfg_option_foreach(j, f, a)      jcfg_object_foreach(j, JCFG_OPTION_TYPE, f, a)
#define jcfg_umem_foreach(j, f, a)        jcfg_object_foreach(j, JCFG_UMEM_TYPE, f, a)
#define jcfg_lport_foreach(j, f, a)       jcfg_object_foreach(j, JCFG_LPORT_TYPE, f, a)
#define jcfg_lgroup_foreach(j, f, a)      jcfg_object_foreach(j, JCFG_LGROUP_TYPE, f, a)
#define jcfg_thread_foreach(j, f, a)      jcfg_object_foreach(j, JCFG_THREAD_TYPE, f, a)
#define jcfg_lport_group_foreach(j, f, a) jcfg_object_foreach(j, JCFG_LPORT_GROUP_TYPE, f, a)
#define jcfg_user_foreach(j, f, a)        jcfg_object_foreach(j, JCFG_USER_TYPE, f, a)
 
CNDP_API void *jcfg_object_lookup(jcfg_info_t *jinfo, jcfg_cb_type_t cbtype, const char *name);
 
#define jcfg_lookup_option(j, n)      (jcfg_opt_t *)jcfg_object_lookup(j, JCFG_OPTION_TYPE, n)
#define jcfg_lookup_default(j, n)     (jcfg_opt_t *)jcfg_object_lookup(j, JCFG_DEFAULT_TYPE, n)
#define jcfg_lookup_application(j, n) (jcfg_opt_t *)jcfg_object_lookup(j, JCFG_APPLICATION_TYPE, n)
#define jcfg_lookup_umem(j, n)        (jcfg_umem_t *)jcfg_object_lookup(j, JCFG_UMEM_TYPE, n)
#define jcfg_lookup_lport(j, n)       (jcfg_lport_t *)jcfg_object_lookup(j, JCFG_LPORT_TYPE, n)
#define jcfg_lookup_lport(j, n)       (jcfg_lport_t *)jcfg_object_lookup(j, JCFG_LPORT_TYPE, n)
#define jcfg_lookup_lgroup(j, n)      (jcfg_lgroup_t *)jcfg_object_lookup(j, JCFG_LGROUP_TYPE, n)
#define jcfg_lookup_thread(j, n)      (jcfg_thd_t *)jcfg_object_lookup(j, JCFG_THREAD_TYPE, n)
#define jcfg_lookup_lport_group(j, n) \
    (jcfg_lport_group_t *)jcfg_object_lookup(j, JCFG_LPORT_GROUP_TYPE, n)
#define jcfg_lookup_user(j, n) (jcfg_user_t *)jcfg_object_lookup(j, JCFG_USER_TYPE, n)
 
CNDP_API int jcfg_num_objects(jcfg_info_t *jinfo, jcfg_cb_type_t cbtype);
 
#define jcfg_num_applications(j) jcfg_num_objects(j, JCFG_APPLICATION_TYPE)
#define jcfg_num_defaults(j)     jcfg_num_objects(j, JCFG_DEFAULT_TYPE)
#define jcfg_num_options(j)      jcfg_num_objects(j, JCFG_OPTION_TYPE)
#define jcfg_num_lports(j)       jcfg_num_objects(j, JCFG_LPORT_TYPE)
#define jcfg_num_lgroups(j)      jcfg_num_objects(j, JCFG_LGROUP_TYPE)
#define jcfg_num_threads(j)      jcfg_num_objects(j, JCFG_THREAD_TYPE)
#define jcfg_num_lport_groups(j) jcfg_num_objects(j, JCFG_LPORT_GROUP_TYPE)
#define jcfg_num_umems(j)        jcfg_num_objects(j, JCFG_UMEM_TYPE)
 
CNDP_API int jcfg_default_get(jcfg_info_t *jinfo, const char *name, uint64_t *val);
 
CNDP_API int jcfg_default_array_get(jcfg_info_t *jinfo, const char *name, obj_value_t **val_arr);
 
static inline int
jcfg_default_get_bool(jcfg_info_t *jinfo, const char *name, uint32_t *v)
{
    uint64_t val;
 
    if (jcfg_default_get(jinfo, name, &val) < 0)
        return -1;
    *v = (uint32_t)val;
    return 0;
}
 
static inline int
jcfg_default_get_u32(jcfg_info_t *jinfo, const char *name, uint32_t *v)
{
    uint64_t val;
 
    if (jcfg_default_get(jinfo, name, &val) < 0)
        return -1;
    *v = (uint32_t)val;
    return 0;
}
 
static inline int
jcfg_default_get_u16(jcfg_info_t *jinfo, const char *name, uint16_t *v)
{
    uint64_t val;
 
    if (jcfg_default_get(jinfo, name, &val) < 0)
        return -1;
    *v = (uint16_t)val;
    return 0;
}
 
static inline int
jcfg_default_get_string(jcfg_info_t *jinfo, const char *name, char **v)
{
    uint64_t val;
 
    if (jcfg_default_get(jinfo, name, &val) < 0)
        return -1;
    *v = (char *)val;
    return 0;
}
 
CNDP_API int jcfg_option_get(jcfg_info_t *jinfo, const char *name, uint64_t *val);
 
CNDP_API int jcfg_option_array_get(jcfg_info_t *jinfo, const char *name, obj_value_t **val_arr);
 
static inline int
jcfg_option_get_string(jcfg_info_t *jinfo, const char *name, char **v)
{
    uint64_t val;
 
    if (jcfg_option_get(jinfo, name, &val) < 0)
        return -1;
    *v = (char *)val;
    return 0;
}
 
CNDP_API jcfg_info_t *jcfg_parser(int flags, const char *s);
 
CNDP_API void jcfg_destroy(jcfg_info_t *jinfo);
 
CNDP_API int jcfg_decode(jcfg_info_t *jinfo, const char *key, void *arg);
 
/********************************************************************
 * Routines to create and destroy a Unix Domain Socket for jcfg parsing
 */
 
CNDP_API int jcfg_socket_create(jcfg_info_t *jinfo, const char *runtime_dir);
 
CNDP_API void jcfg_socket_destroy(jcfg_info_t *jinfo);
 
/********************************************************************
 * Routine to add, remove or find decoders for parsing jcfg sections
 */
 
CNDP_API int jcfg_add_decoder(const char *section, json_c_visit_userfunc *func);
 
CNDP_API int jcfg_del_decoder(const char *section);
 
CNDP_API json_c_visit_userfunc *jcfg_get_decoder(const char *section);
 
/********************************************************************
 * Helper routine(s) for accessing internal data or dumping information
 */
 
CNDP_API jcfg_data_t *jcfg_get_data(jcfg_info_t *jinfo);
 
CNDP_API jcfg_umem_t *jcfg_umem_by_index(jcfg_info_t *jinfo, int idx);
 
CNDP_API char *jcfg_lport_region(jcfg_lport_t *lport, uint32_t *objcnt);
 
CNDP_API int jcfg_json_string_set(jcfg_info_t *jinfo, const char *str);
 
CNDP_API struct json_object *jcfg_object_by_name(jcfg_info_t *jinfo, const char *key);
 
CNDP_API jcfg_lport_t *jcfg_lport_by_index(jcfg_info_t *jinfo, int idx);
 
CNDP_API jcfg_thd_t *jcfg_thd_by_index(jcfg_info_t *jinfo, int idx);
 
CNDP_API int jcfg_dump_object(struct json_object *obj);
 
CNDP_API int jcfg_dump_at(jcfg_info_t *jinfo, const char *key);
 
CNDP_API int jcfg_dump(jcfg_info_t *jinfo);
 
CNDP_API void jcfg_dump_info(void);
 
#ifdef __cplusplus
}
#endif
 
#endif /* _JCFG_H_ */