X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2Frmr%2Fcommon%2Finclude%2Frmr_agnostic.h;h=0858fdec932cd9968e5e88937f7aa7bcc9a1be18;hb=c8e651e15839411c85e105d16fd2ffc14c1cc1dd;hp=419145b1b5a9198266430898d2069ca10a124b13;hpb=fcea3951d44de0cc55d33c5e114487abe79d3406;p=ric-plt%2Flib%2Frmr.git diff --git a/src/rmr/common/include/rmr_agnostic.h b/src/rmr/common/include/rmr_agnostic.h index 419145b..0858fde 100644 --- a/src/rmr/common/include/rmr_agnostic.h +++ b/src/rmr/common/include/rmr_agnostic.h @@ -30,6 +30,7 @@ #define _rmr_agnostic_h #include // needed to support some structs +#include typedef struct endpoint endpoint_t; // place holder for structs defined in nano/nng private.h typedef struct uta_ctx uta_ctx_t; @@ -59,6 +60,7 @@ typedef struct uta_ctx uta_ctx_t; #define ENV_RTG_PORT "RMR_RTG_SVC" // the port we'll listen on for rtg connections (deprecated; see RTG_SVC and CTL_PORT) #define ENV_RTG_ADDR "RMR_RTG_SVC" // the address we will connect to for route manager updates #define ENV_SEED_RT "RMR_SEED_RT" // where we expect to find the name of the seed route table +#define ENV_STASH_RT "RMR_STASH_RT" // location for the last Route Table received from the generator we snarfed and saved #define ENV_SEED_MEMAP "RMR_SEED_MEMAP" // where we expect to find the name of the seed route table #define ENV_RTG_RAW "RMR_RTG_ISRAW" // if > 0 we expect route table gen messages as raw (not sent from an RMr application) #define ENV_VERBOSE_FILE "RMR_VCTL_FILE" // file where vlevel may be managed for some (non-time critical) functions @@ -70,6 +72,10 @@ typedef struct uta_ctx uta_ctx_t; #define ENV_CTL_PORT "RMR_CTL_PORT" // route collector will listen here for control messages (4561 default) #define ENV_RTREQ_FREA "RMR_RTREQ_FREQ" // frequency we will request route table updates when we want one (1-300 inclusive) + +#define ENV_AM_NAME "ALARM_MGR_SERVICE_NAME" // alarm manager env vars that we need +#define ENV_AM_PORT "ALARM_MGR_SERVICE_PORT" + #define NO_FLAGS 0 // no flags to pass to a function #define FL_NOTHREAD 0x01 // do not start an additional thread (must be 'user land' to support rtg @@ -77,11 +83,11 @@ typedef struct uta_ctx uta_ctx_t; // internal flags, must be > than UFLAG_MASK //#define IFL_.... + // context flags #define CFL_MTC_ENABLED 0x01 // multi-threaded call is enabled #define CFL_NO_RTACK 0x02 // no route table ack needed when end received - - // context flags -#define CTXFL_WARN 0x01 // ok to warn on stderr for some things that shouldn't happen +#define CFL_WARN 0x04 // ok to warn on stderr for some things that shouldn't happen +#define CFL_FULLRT 0x08 // set when we have received an initial full route table (prevent updates before one arrives) // msg buffer flags #define MFL_ZEROCOPY 0x01 // the message is an allocated zero copy message and can be sent. @@ -147,6 +153,17 @@ typedef struct uta_ctx uta_ctx_t; #define HFL_SUBID 0x02 // subscription ID is populated #define HFL_CALL_MSG 0x04 // msg sent via blocking call +/* + Alarm action constants describe the type (e.g. dropping messages) and whether or not + this is a "raise" or "clear" action. Raise/clear is determined by the least significant + bit; 1 == raise. +*/ +#define ALARM_RAISE 0x01 +#define ALARM_CLEAR 0x00 +#define ALARM_KIND(a) (a&ALARM_MASK) +#define ALARM_DROPS 0x02 +#define ALARM_MASK 0xfffe + /* Message header; interpreted by the other side, but never seen by the user application. @@ -224,9 +241,13 @@ typedef struct { The route table. */ typedef struct { - void* hash; // hash table. + int error; // set if there was a problem building the table + void* hash; // hash table for msg type and meid. + void* ephash; // hash for endpoint references int updates; // counter of update records received int mupdates; // counter of meid update records received + int ref_count; // num threads currently using + pthread_mutex_t* gate; // lock allowing update to ref counter } route_table_t; /* @@ -253,6 +274,10 @@ typedef struct { #define RING_NONE 0 // no options #define RING_RLOCK 0x01 // create/destroy the read lock on the ring #define RING_WLOCK 0x02 // create/destroy the write lockk on the ring +#define RING_FRLOCK 0x04 // read locking with no wait if locked option + + // flag values +#define RING_FL_FLOCK 0x01 // fast read lock (don't wait if locked when reading) typedef struct ring { uint16_t head; // index of the head of the ring (insert point) @@ -260,6 +285,7 @@ typedef struct ring { uint16_t nelements; // number of elements in the ring void** data; // the ring data (pointers to blobs of stuff) int pfd; // event fd for the ring for epoll + int flags; // RING_FL_* constants pthread_mutex_t* rgate; // read lock if used pthread_mutex_t* wgate; // write lock if used } ring_t; @@ -303,22 +329,28 @@ static inline int uta_ring_insert( void* vr, void* new_data ); static int ie_test( void* r, int i_factor, long inserts ); +// --- internal alarm generation --------------------- +static void uta_alarm( void* vctx, int kind, int prob_id, char* info ); +static void uta_alarm_send( void* vctx, rmr_mbuf_t* msg ); + // ----- route table generic static things --------- static inline uint64_t build_rt_key( int32_t sub_id, int32_t mtype ); static void collect_things( void* st, void* entry, char const* name, void* thing, void* vthing_list ); static void del_rte( void* st, void* entry, char const* name, void* thing, void* data ); static endpoint_t* get_meid_owner( route_table_t *rt, char const* meid ); static char* uta_fib( char const* fname ); -static route_table_t* uta_rt_init( ); -static route_table_t* uta_rt_clone( route_table_t* srt ); -static route_table_t* uta_rt_clone_all( route_table_t* srt ); +static route_table_t* uta_rt_init( uta_ctx_t* ctx ); +static route_table_t* uta_rt_clone( uta_ctx_t* ctx, route_table_t* srt, route_table_t* drt, int all ); static void uta_rt_drop( route_table_t* rt ); +static inline route_table_t* get_rt( uta_ctx_t* ctx ); static endpoint_t* uta_add_ep( route_table_t* rt, rtable_ent_t* rte, char* ep_name, int group ); static rtable_ent_t* uta_add_rte( route_table_t* rt, uint64_t key, int nrrgroups ); static endpoint_t* uta_get_ep( route_table_t* rt, char const* ep_name ); static void read_static_rt( uta_ctx_t* ctx, int vlevel ); +static route_table_t* prep_new_rt( uta_ctx_t* ctx, int all ); static void parse_rt_rec( uta_ctx_t* ctx, uta_ctx_t* pctx, char* buf, int vlevel, rmr_mbuf_t* mbuf ); static rmr_mbuf_t* realloc_msg( rmr_mbuf_t* msg, int size ); +static void release_rt( uta_ctx_t* ctx, route_table_t* rt ); static void* rtc( void* vctx ); static endpoint_t* rt_ensure_ep( route_table_t* rt, char const* ep_name );