From 639614622b2cbe937740af078b76b4956f9ce7ce Mon Sep 17 00:00:00 2001 From: luwenpeng Date: Mon, 11 Mar 2024 15:04:18 +0800 Subject: [PATCH] update session_manager_stat --- src/packet/packet.cpp | 6 + src/session/session_manager.cpp | 193 ++++++++++++++++---------------- src/session/session_manager.h | 49 ++++---- src/session/test/test_utils.h | 27 +++-- 4 files changed, 135 insertions(+), 140 deletions(-) diff --git a/src/packet/packet.cpp b/src/packet/packet.cpp index f0598e0..77822b7 100644 --- a/src/packet/packet.cpp +++ b/src/packet/packet.cpp @@ -1148,6 +1148,7 @@ void packet_print(const struct packet *pkt) // return -1 : not found int packet_get_innermost_tuple2(const struct packet *pkt, struct tuple2 *tuple) { + memset(tuple, 0, sizeof(struct tuple2)); const struct layer *layer = NULL; for (int8_t i = pkt->layers_used - 1; i >= 0; i--) @@ -1168,6 +1169,7 @@ int packet_get_innermost_tuple2(const struct packet *pkt, struct tuple2 *tuple) // return -1 : not found int packet_get_outermost_tuple2(const struct packet *pkt, struct tuple2 *tuple) { + memset(tuple, 0, sizeof(struct tuple2)); const struct layer *layer = NULL; for (int8_t i = 0; i < pkt->layers_used; i++) @@ -1188,6 +1190,7 @@ int packet_get_outermost_tuple2(const struct packet *pkt, struct tuple2 *tuple) // return -1 : not found int packet_get_innermost_tuple4(const struct packet *pkt, struct tuple4 *tuple) { + memset(tuple, 0, sizeof(struct tuple4)); const struct layer *layer_l3 = NULL; const struct layer *layer_l4 = NULL; const struct layer *layer = NULL; @@ -1227,6 +1230,7 @@ int packet_get_innermost_tuple4(const struct packet *pkt, struct tuple4 *tuple) // return -1 : not found int packet_get_outermost_tuple4(const struct packet *pkt, struct tuple4 *tuple) { + memset(tuple, 0, sizeof(struct tuple4)); const struct layer *layer_l3 = NULL; const struct layer *layer_l4 = NULL; const struct layer *layer = NULL; @@ -1266,6 +1270,7 @@ int packet_get_outermost_tuple4(const struct packet *pkt, struct tuple4 *tuple) // return -1 : not found int packet_get_innermost_tuple6(const struct packet *pkt, struct tuple6 *tuple) { + memset(tuple, 0, sizeof(struct tuple6)); const struct layer *layer_l3 = NULL; const struct layer *layer_l4 = NULL; const struct layer *layer = NULL; @@ -1306,6 +1311,7 @@ int packet_get_innermost_tuple6(const struct packet *pkt, struct tuple6 *tuple) // return -1 : not found int packet_get_outermost_tuple6(const struct packet *pkt, struct tuple6 *tuple) { + memset(tuple, 0, sizeof(struct tuple6)); const struct layer *layer_l3 = NULL; const struct layer *layer_l4 = NULL; const struct layer *layer = NULL; diff --git a/src/session/session_manager.cpp b/src/session/session_manager.cpp index 4adba9a..9b31fb1 100644 --- a/src/session/session_manager.cpp +++ b/src/session/session_manager.cpp @@ -32,21 +32,7 @@ struct session_manager * session manager status ***************************************************************/ - // session number - uint64_t tcp_sess_num; - uint64_t tcp_opening_sess_num; - uint64_t tcp_active_sess_num; - uint64_t tcp_closing_sess_num; - - uint64_t udp_sess_num; - uint64_t udp_opening_sess_num; - uint64_t udp_active_sess_num; - uint64_t udp_closing_sess_num; - - uint64_t tcp_overload_evict_old_sess_num; - uint64_t tcp_overload_evict_new_sess_num; - uint64_t udp_overload_evict_old_sess_num; - uint64_t udp_overload_evict_new_sess_num; + struct session_manager_stat stat; // packet filter status uint64_t npkts_miss_l4_proto; // fast forward @@ -58,80 +44,108 @@ struct session_manager uint64_t npkts_hit_udp_evicted; // fast forward }; -enum packet_flag +enum trigger { NONE = 0, + + // packet TCP_SYN = 1 << 0, TCP_SYN_ACK = 1 << 1, - TCP_FIN = 1 << 2, + TCP_FIN = 1 << 2, // only fist fin TCP_RST = 1 << 3, TCP_DATA = 1 << 4, UDP_DATA = 1 << 5, + + // session timeout TIMEOUT = 1 << 6, + + // session table full evict + LRU_EVICT = 1 << 7, }; +/* + * session finite state machine + * + * SESSION_STATE_INIT -> SESSION_STATE_INIT ( NONE ) + * SESSION_STATE_INIT -> SESSION_STATE_OPENING ( TCP_SYN | TCP_SYN_ACK | UDP_DATA ) + * + * SESSION_STATE_OPENING -> SESSION_STATE_OPENING ( NONE ) + * SESSION_STATE_OPENING -> SESSION_STATE_ACTIVE ( TCP_DATA | UDP_DATA ) + * SESSION_STATE_OPENING -> SESSION_STATE_CLOSING ( TCP_FIN | TCP_RST | TIMEOUT ) + * SESSION_STATE_OPENING -> SESSION_STATE_CLOSED ( LRU_EVICT ) + * + * SESSION_STATE_ACTIVE -> SESSION_STATE_ACTIVE ( NONE ) + * SESSION_STATE_ACTIVE -> SESSION_STATE_CLOSING ( TCP_FIN | TCP_RST | TIMEOUT ) + * SESSION_STATE_ACTIVE -> SESSION_STATE_CLOSED ( LRU_EVICT ) + * + * SESSION_STATE_CLOSING -> SESSION_STATE_CLOSING ( NONE ) + * SESSION_STATE_CLOSING -> SESSION_STATE_CLOSED ( TIMEOUT | LRU_EVICT ) + */ + struct session_finite_state_machine { - int flag_mask; - int next_state; + int trigger_mask; + enum session_state next_state; } sess_fsm[SESSION_STATE_MAX][8]; void session_finite_state_machine_init() { - // SESSION_STATE_INIT -> SESSION_STATE_OPENING - // SESSION_STATE_INIT -> SESSION_STATE_INIT + // SESSION_STATE_INIT -> SESSION_STATE_OPENING ( TCP_SYN | TCP_SYN_ACK | UDP_DATA ) + // SESSION_STATE_INIT -> SESSION_STATE_INIT ( NONE ) - sess_fsm[SESSION_STATE_INIT][0].flag_mask = TCP_SYN | TCP_SYN_ACK | UDP_DATA; + sess_fsm[SESSION_STATE_INIT][0].trigger_mask = TCP_SYN | TCP_SYN_ACK | UDP_DATA; sess_fsm[SESSION_STATE_INIT][0].next_state = SESSION_STATE_OPENING; - sess_fsm[SESSION_STATE_INIT][1].flag_mask = NONE; + sess_fsm[SESSION_STATE_INIT][1].trigger_mask = NONE; sess_fsm[SESSION_STATE_INIT][1].next_state = SESSION_STATE_INIT; - // SESSION_STATE_OPENING -> SESSION_STATE_ACTIVE - // SESSION_STATE_OPENING -> SESSION_STATE_CLOSING - // SESSION_STATE_OPENING -> SESSION_STATE_CLOSED - // SESSION_STATE_OPENING -> SESSION_STATE_OPENING + // SESSION_STATE_OPENING -> SESSION_STATE_ACTIVE ( TCP_DATA | UDP_DATA ) + // SESSION_STATE_OPENING -> SESSION_STATE_CLOSING ( TCP_FIN | TCP_RST | TIMEOUT ) + // SESSION_STATE_OPENING -> SESSION_STATE_CLOSED ( LRU_EVICT ) + // SESSION_STATE_OPENING -> SESSION_STATE_OPENING ( NONE ) - sess_fsm[SESSION_STATE_OPENING][0].flag_mask = TCP_DATA | UDP_DATA; + sess_fsm[SESSION_STATE_OPENING][0].trigger_mask = TCP_DATA | UDP_DATA; sess_fsm[SESSION_STATE_OPENING][0].next_state = SESSION_STATE_ACTIVE; - sess_fsm[SESSION_STATE_OPENING][1].flag_mask = TCP_FIN | TCP_RST; + sess_fsm[SESSION_STATE_OPENING][1].trigger_mask = TCP_FIN | TCP_RST | TIMEOUT; sess_fsm[SESSION_STATE_OPENING][1].next_state = SESSION_STATE_CLOSING; - sess_fsm[SESSION_STATE_OPENING][2].flag_mask = TIMEOUT; + sess_fsm[SESSION_STATE_OPENING][2].trigger_mask = LRU_EVICT; sess_fsm[SESSION_STATE_OPENING][2].next_state = SESSION_STATE_CLOSED; - sess_fsm[SESSION_STATE_OPENING][3].flag_mask = NONE; + sess_fsm[SESSION_STATE_OPENING][3].trigger_mask = NONE; sess_fsm[SESSION_STATE_OPENING][3].next_state = SESSION_STATE_OPENING; - // SESSION_STATE_ACTIVE -> SESSION_STATE_CLOSING - // SESSION_STATE_ACTIVE -> SESSION_STATE_ACTIVE + // SESSION_STATE_ACTIVE -> SESSION_STATE_CLOSING ( TCP_FIN | TCP_RST | TIMEOUT ) + // SESSION_STATE_ACTIVE -> SESSION_STATE_CLOSED ( LRU_EVICT ) + // SESSION_STATE_ACTIVE -> SESSION_STATE_ACTIVE ( NONE ) - sess_fsm[SESSION_STATE_ACTIVE][0].flag_mask = TCP_FIN | TCP_RST | TIMEOUT; + sess_fsm[SESSION_STATE_ACTIVE][0].trigger_mask = TCP_FIN | TCP_RST | TIMEOUT; sess_fsm[SESSION_STATE_ACTIVE][0].next_state = SESSION_STATE_CLOSING; - sess_fsm[SESSION_STATE_ACTIVE][1].flag_mask = NONE; - sess_fsm[SESSION_STATE_ACTIVE][1].next_state = SESSION_STATE_ACTIVE; + sess_fsm[SESSION_STATE_ACTIVE][1].trigger_mask = LRU_EVICT; + sess_fsm[SESSION_STATE_ACTIVE][1].next_state = SESSION_STATE_CLOSED; - // SESSION_STATE_CLOSING -> SESSION_STATE_CLOSED - // SESSION_STATE_CLOSING -> SESSION_STATE_CLOSING + sess_fsm[SESSION_STATE_ACTIVE][2].trigger_mask = NONE; + sess_fsm[SESSION_STATE_ACTIVE][2].next_state = SESSION_STATE_ACTIVE; - sess_fsm[SESSION_STATE_CLOSING][0].flag_mask = TIMEOUT; + // SESSION_STATE_CLOSING -> SESSION_STATE_CLOSED ( TIMEOUT | LRU_EVICT ) + // SESSION_STATE_CLOSING -> SESSION_STATE_CLOSING ( NONE ) + + sess_fsm[SESSION_STATE_CLOSING][0].trigger_mask = TIMEOUT | LRU_EVICT; sess_fsm[SESSION_STATE_CLOSING][0].next_state = SESSION_STATE_CLOSED; - sess_fsm[SESSION_STATE_CLOSING][1].flag_mask = NONE; + sess_fsm[SESSION_STATE_CLOSING][1].trigger_mask = NONE; sess_fsm[SESSION_STATE_CLOSING][1].next_state = SESSION_STATE_CLOSING; - - // SESSION_STATE_CLOSED -> SESSION_STATE_INIT } -int session_finite_state_machine_run(enum session_state curr_state, int input_pkt_flag) +enum session_state session_finite_state_machine_run(enum session_state curr_state, enum trigger trigger) { struct session_finite_state_machine *list = sess_fsm[curr_state]; for (int i = 0; i < 8; i++) { - int mask = list[i].flag_mask; - if (mask & input_pkt_flag) + int mask = list[i].trigger_mask; + if (mask & trigger) { return list[i].next_state; } @@ -582,13 +596,13 @@ static inline void session_manager_update_session_state(struct session_manager * switch (session_get_state(sess)) { case SESSION_STATE_OPENING: - mgr->tcp_opening_sess_num--; + mgr->stat.tcp_opening_sess_num--; break; case SESSION_STATE_ACTIVE: - mgr->tcp_active_sess_num--; + mgr->stat.tcp_active_sess_num--; break; case SESSION_STATE_CLOSING: - mgr->tcp_closing_sess_num--; + mgr->stat.tcp_closing_sess_num--; break; case SESSION_STATE_CLOSED: /* void */ @@ -601,17 +615,17 @@ static inline void session_manager_update_session_state(struct session_manager * switch (state) { case SESSION_STATE_OPENING: - mgr->tcp_opening_sess_num++; - mgr->tcp_sess_num++; + mgr->stat.tcp_opening_sess_num++; + mgr->stat.tcp_sess_num++; break; case SESSION_STATE_ACTIVE: - mgr->tcp_active_sess_num++; + mgr->stat.tcp_active_sess_num++; break; case SESSION_STATE_CLOSING: - mgr->tcp_closing_sess_num++; + mgr->stat.tcp_closing_sess_num++; break; case SESSION_STATE_CLOSED: - mgr->tcp_sess_num--; + mgr->stat.tcp_sess_num--; break; default: break; @@ -623,13 +637,13 @@ static inline void session_manager_update_session_state(struct session_manager * switch (session_get_state(sess)) { case SESSION_STATE_OPENING: - mgr->udp_opening_sess_num--; + mgr->stat.udp_opening_sess_num--; break; case SESSION_STATE_ACTIVE: - mgr->udp_active_sess_num--; + mgr->stat.udp_active_sess_num--; break; case SESSION_STATE_CLOSING: - mgr->udp_closing_sess_num--; + mgr->stat.udp_closing_sess_num--; break; case SESSION_STATE_CLOSED: /* void */ @@ -642,17 +656,17 @@ static inline void session_manager_update_session_state(struct session_manager * switch (state) { case SESSION_STATE_OPENING: - mgr->udp_opening_sess_num++; - mgr->udp_sess_num++; + mgr->stat.udp_opening_sess_num++; + mgr->stat.udp_sess_num++; break; case SESSION_STATE_ACTIVE: - mgr->udp_active_sess_num++; + mgr->stat.udp_active_sess_num++; break; case SESSION_STATE_CLOSING: - mgr->udp_closing_sess_num++; + mgr->stat.udp_closing_sess_num++; break; case SESSION_STATE_CLOSED: - mgr->udp_sess_num--; + mgr->stat.udp_sess_num--; break; default: break; @@ -887,20 +901,20 @@ static inline struct session *session_manager_new_tcp_session(struct session_man return NULL; } - if (mgr->tcp_sess_num >= mgr->opts.max_tcp_session_num - RX_BURST_MAX - 1) + if (mgr->stat.tcp_sess_num >= mgr->opts.max_tcp_session_num - RX_BURST_MAX - 1) { if (mgr->opts.tcp_overload_evict_old_sess) { struct session *evicted_sess = session_table_find_least_recently_unused_session(mgr->tcp_sess_table); assert(evicted_sess); session_manager_evicte_session(mgr, evicted_sess); - mgr->tcp_overload_evict_old_sess_num++; + mgr->stat.tcp_overload_evict_old_sess_num++; } else { - if (mgr->tcp_sess_num >= mgr->opts.max_tcp_session_num) + if (mgr->stat.tcp_sess_num >= mgr->opts.max_tcp_session_num) { - mgr->tcp_overload_evict_new_sess_num++; + mgr->stat.tcp_overload_evict_new_sess_num++; return NULL; } else @@ -938,20 +952,20 @@ static inline struct session *session_manager_new_udp_session(struct session_man return NULL; } - if (mgr->udp_sess_num >= mgr->opts.max_udp_session_num - RX_BURST_MAX - 1) + if (mgr->stat.udp_sess_num >= mgr->opts.max_udp_session_num - RX_BURST_MAX - 1) { if (mgr->opts.udp_overload_evict_old_sess) { struct session *evicted_sess = session_table_find_least_recently_unused_session(mgr->udp_sess_table); assert(evicted_sess); session_manager_evicte_session(mgr, evicted_sess); - mgr->udp_overload_evict_old_sess_num++; + mgr->stat.udp_overload_evict_old_sess_num++; } else { - if (mgr->udp_sess_num >= mgr->opts.max_udp_session_num) + if (mgr->stat.udp_sess_num >= mgr->opts.max_udp_session_num) { - mgr->udp_overload_evict_new_sess_num++; + mgr->stat.udp_overload_evict_new_sess_num++; return NULL; } else @@ -1333,20 +1347,20 @@ void session_manager_print_stat(struct session_manager *mgr) { printf("session manager status:\n"); - printf("tcp session number : %lu\n", mgr->tcp_sess_num); - printf(" opening number : %lu\n", mgr->tcp_opening_sess_num); - printf(" active number : %lu\n", mgr->tcp_active_sess_num); - printf(" closing number : %lu\n", mgr->tcp_closing_sess_num); - printf("udp session number : %lu\n", mgr->udp_sess_num); - printf(" opening number : %lu\n", mgr->udp_opening_sess_num); - printf(" active number : %lu\n", mgr->udp_active_sess_num); - printf(" closing number : %lu\n", mgr->udp_closing_sess_num); + printf("tcp session number : %lu\n", mgr->stat.tcp_sess_num); + printf(" opening number : %lu\n", mgr->stat.tcp_opening_sess_num); + printf(" active number : %lu\n", mgr->stat.tcp_active_sess_num); + printf(" closing number : %lu\n", mgr->stat.tcp_closing_sess_num); + printf("udp session number : %lu\n", mgr->stat.udp_sess_num); + printf(" opening number : %lu\n", mgr->stat.udp_opening_sess_num); + printf(" active number : %lu\n", mgr->stat.udp_active_sess_num); + printf(" closing number : %lu\n", mgr->stat.udp_closing_sess_num); printf("tcp overload evict : \n"); - printf(" old session number: %lu\n", mgr->tcp_overload_evict_old_sess_num); - printf(" new session number: %lu\n", mgr->tcp_overload_evict_new_sess_num); + printf(" old session number: %lu\n", mgr->stat.tcp_overload_evict_old_sess_num); + printf(" new session number: %lu\n", mgr->stat.tcp_overload_evict_new_sess_num); printf("udp overload evict : \n"); - printf(" old session number: %lu\n", mgr->udp_overload_evict_old_sess_num); - printf(" new session number: %lu\n", mgr->udp_overload_evict_new_sess_num); + printf(" old session number: %lu\n", mgr->stat.udp_overload_evict_old_sess_num); + printf(" new session number: %lu\n", mgr->stat.udp_overload_evict_new_sess_num); printf("packet status:\n"); printf(" miss l4 proto : %lu (bypass)\n", mgr->npkts_miss_l4_proto); @@ -1358,20 +1372,7 @@ void session_manager_print_stat(struct session_manager *mgr) printf(" hit udp evicted : %lu (bypass)\n", mgr->npkts_hit_udp_evicted); } -void session_manager_get_stat(struct session_manager *mgr, struct session_manager_stat *out) +struct session_manager_stat *session_manager_get_stat(struct session_manager *mgr) { - out->tcp_sess_num = mgr->tcp_sess_num; - out->tcp_opening_sess_num = mgr->tcp_opening_sess_num; - out->tcp_active_sess_num = mgr->tcp_active_sess_num; - out->tcp_closing_sess_num = mgr->tcp_closing_sess_num; - - out->udp_sess_num = mgr->udp_sess_num; - out->udp_opening_sess_num = mgr->udp_opening_sess_num; - out->udp_active_sess_num = mgr->udp_active_sess_num; - out->udp_closing_sess_num = mgr->udp_closing_sess_num; - - out->tcp_overload_evict_old_sess_num = mgr->tcp_overload_evict_old_sess_num; - out->tcp_overload_evict_new_sess_num = mgr->tcp_overload_evict_new_sess_num; - out->udp_overload_evict_old_sess_num = mgr->udp_overload_evict_old_sess_num; - out->udp_overload_evict_new_sess_num = mgr->udp_overload_evict_new_sess_num; + return &mgr->stat; } diff --git a/src/session/session_manager.h b/src/session/session_manager.h index dc34d7f..20dcb2b 100644 --- a/src/session/session_manager.h +++ b/src/session/session_manager.h @@ -46,35 +46,6 @@ struct session_manager_options double evicted_session_filter_error_rate; }; -struct session_manager; -struct session_manager *session_manager_new(struct session_manager_options *opts); -void session_manager_free(struct session_manager *mgr); -struct session *session_manager_lookup_session(struct session_manager *mgr, const struct packet *pkt); - -/* - * return NULL following case: - * 1.Not TCP or UDP - * 2.UDP eviction packet - * 3.UDP overloading and config to bypass new session - * 4.TCP no SYN flag - * 5.UDP overloading and config to bypass new session - */ -struct session *session_manager_new_session(struct session_manager *mgr, const struct packet *pkt); -void session_manager_free_session(struct session_manager *mgr, struct session *sess); -/* - * return NULL following case: - * 1.Not TCP or UDP - * 2.TCP duplicate packet - */ -int session_manager_update_session(struct session_manager *mgr, struct session *sess, const struct packet *pkt); -// return session need free by session_manager_free_session() -struct session *session_manager_get_expired_session(struct session_manager *mgr); -// return session need free by session_manager_free_session() -struct session *session_manager_get_evicted_session(struct session_manager *mgr); -// return 0: have already timeout session -// return >0: next expire interval -uint64_t session_manager_get_expire_interval(struct session_manager *mgr); - struct session_manager_stat { uint64_t tcp_sess_num; @@ -93,8 +64,26 @@ struct session_manager_stat uint64_t udp_overload_evict_new_sess_num; }; +struct session_manager; +struct session_manager *session_manager_new(struct session_manager_options *opts); +void session_manager_free(struct session_manager *mgr); + +struct session *session_manager_new_session(struct session_manager *mgr, const struct packet *pkt); +void session_manager_free_session(struct session_manager *mgr, struct session *sess); + +struct session *session_manager_lookup_session(struct session_manager *mgr, const struct packet *pkt); +int session_manager_update_session(struct session_manager *mgr, struct session *sess, const struct packet *pkt); + +// return session need free by session_manager_free_session() +struct session *session_manager_get_expired_session(struct session_manager *mgr); +struct session *session_manager_get_evicted_session(struct session_manager *mgr); + +// return 0: have already timeout session +// return >0: next expire interval +uint64_t session_manager_get_expire_interval(struct session_manager *mgr); + void session_manager_print_stat(struct session_manager *mgr); -void session_manager_get_stat(struct session_manager *mgr, struct session_manager_stat *out); +struct session_manager_stat *session_manager_get_stat(struct session_manager *mgr); #ifdef __cpluscplus } diff --git a/src/session/test/test_utils.h b/src/session/test/test_utils.h index 4b53adb..6c6f99b 100644 --- a/src/session/test/test_utils.h +++ b/src/session/test/test_utils.h @@ -93,23 +93,22 @@ __attribute__((unused)) static void __session_manager_check_counter(struct sessi uint64_t tcp_overload_evict_new_sess_num, uint64_t tcp_overload_evict_old_sess_num, uint64_t udp_overload_evict_new_sess_num, uint64_t udp_overload_evict_old_sess_num) { - struct session_manager_stat counter; - session_manager_get_stat(mgr, &counter); + struct session_manager_stat *stat = session_manager_get_stat(mgr); - EXPECT_TRUE(counter.tcp_sess_num == tcp_opening_sess_num + tcp_active_sess_num + tcp_closing_sess_num); - EXPECT_TRUE(counter.tcp_opening_sess_num == tcp_opening_sess_num); - EXPECT_TRUE(counter.tcp_active_sess_num == tcp_active_sess_num); - EXPECT_TRUE(counter.tcp_closing_sess_num == tcp_closing_sess_num); + EXPECT_TRUE(stat->tcp_sess_num == tcp_opening_sess_num + tcp_active_sess_num + tcp_closing_sess_num); + EXPECT_TRUE(stat->tcp_opening_sess_num == tcp_opening_sess_num); + EXPECT_TRUE(stat->tcp_active_sess_num == tcp_active_sess_num); + EXPECT_TRUE(stat->tcp_closing_sess_num == tcp_closing_sess_num); - EXPECT_TRUE(counter.udp_sess_num == udp_opening_sess_num + udp_active_sess_num + udp_closing_sess_num); - EXPECT_TRUE(counter.udp_opening_sess_num == udp_opening_sess_num); - EXPECT_TRUE(counter.udp_active_sess_num == udp_active_sess_num); - EXPECT_TRUE(counter.udp_closing_sess_num == udp_closing_sess_num); + EXPECT_TRUE(stat->udp_sess_num == udp_opening_sess_num + udp_active_sess_num + udp_closing_sess_num); + EXPECT_TRUE(stat->udp_opening_sess_num == udp_opening_sess_num); + EXPECT_TRUE(stat->udp_active_sess_num == udp_active_sess_num); + EXPECT_TRUE(stat->udp_closing_sess_num == udp_closing_sess_num); - EXPECT_TRUE(counter.tcp_overload_evict_new_sess_num == tcp_overload_evict_new_sess_num); - EXPECT_TRUE(counter.tcp_overload_evict_old_sess_num == tcp_overload_evict_old_sess_num); - EXPECT_TRUE(counter.udp_overload_evict_new_sess_num == udp_overload_evict_new_sess_num); - EXPECT_TRUE(counter.udp_overload_evict_old_sess_num == udp_overload_evict_old_sess_num); + EXPECT_TRUE(stat->tcp_overload_evict_new_sess_num == tcp_overload_evict_new_sess_num); + EXPECT_TRUE(stat->tcp_overload_evict_old_sess_num == tcp_overload_evict_old_sess_num); + EXPECT_TRUE(stat->udp_overload_evict_new_sess_num == udp_overload_evict_new_sess_num); + EXPECT_TRUE(stat->udp_overload_evict_old_sess_num == udp_overload_evict_old_sess_num); } __attribute__((unused)) static void __session_manager_check_tcp_timeout_init(struct session_manager *mgr, struct session_manager_options *opts)