gfwleak/stellar-stellar
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

update session_manager_stat

Browse Source
This commit is contained in:
luwenpeng
2024-03-11 15:04:18 +08:00
parent 512dfddd03
commit 639614622b
4 changed files with 135 additions and 140 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/packet/packet.cpp
View File

@@ -1148,6 +1148,7 @@ void packet_print(const struct packet *pkt)
// return -1 : not found // return -1 : not found
int packet_get_innermost_tuple2(const struct packet *pkt, struct tuple2 *tuple) int packet_get_innermost_tuple2(const struct packet *pkt, struct tuple2 *tuple)
{ {
memset(tuple, 0, sizeof(struct tuple2));
const struct layer *layer = NULL; const struct layer *layer = NULL;
for (int8_t i = pkt->layers_used - 1; i >= 0; i--) 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 // return -1 : not found
int packet_get_outermost_tuple2(const struct packet *pkt, struct tuple2 *tuple) int packet_get_outermost_tuple2(const struct packet *pkt, struct tuple2 *tuple)
{ {
memset(tuple, 0, sizeof(struct tuple2));
const struct layer *layer = NULL; const struct layer *layer = NULL;
for (int8_t i = 0; i < pkt->layers_used; i++) 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 // return -1 : not found
int packet_get_innermost_tuple4(const struct packet *pkt, struct tuple4 *tuple) 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_l3 = NULL;
const struct layer *layer_l4 = NULL; const struct layer *layer_l4 = NULL;
const struct layer *layer = 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 // return -1 : not found
int packet_get_outermost_tuple4(const struct packet *pkt, struct tuple4 *tuple) 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_l3 = NULL;
const struct layer *layer_l4 = NULL; const struct layer *layer_l4 = NULL;
const struct layer *layer = 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 // return -1 : not found
int packet_get_innermost_tuple6(const struct packet *pkt, struct tuple6 *tuple) 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_l3 = NULL;
const struct layer *layer_l4 = NULL; const struct layer *layer_l4 = NULL;
const struct layer *layer = 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 // return -1 : not found
int packet_get_outermost_tuple6(const struct packet *pkt, struct tuple6 *tuple) 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_l3 = NULL;
const struct layer *layer_l4 = NULL; const struct layer *layer_l4 = NULL;
const struct layer *layer = NULL; const struct layer *layer = NULL;

193
src/session/session_manager.cpp
View File

@@ -32,21 +32,7 @@ struct session_manager
* session manager status * session manager status
***************************************************************/ ***************************************************************/
// session number struct session_manager_stat stat;
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;
// packet filter status // packet filter status
uint64_t npkts_miss_l4_proto; // fast forward uint64_t npkts_miss_l4_proto; // fast forward
@@ -58,80 +44,108 @@ struct session_manager
uint64_t npkts_hit_udp_evicted; // fast forward uint64_t npkts_hit_udp_evicted; // fast forward
}; };
enum packet_flag enum trigger
{ {
NONE = 0, NONE = 0,
// packet
TCP_SYN = 1 << 0, TCP_SYN = 1 << 0,
TCP_SYN_ACK = 1 << 1, TCP_SYN_ACK = 1 << 1,
TCP_FIN = 1 << 2, TCP_FIN = 1 << 2, // only fist fin
TCP_RST = 1 << 3, TCP_RST = 1 << 3,
TCP_DATA = 1 << 4, TCP_DATA = 1 << 4,
UDP_DATA = 1 << 5, UDP_DATA = 1 << 5,
// session timeout
TIMEOUT = 1 << 6, 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 struct session_finite_state_machine
{ {
int flag_mask; int trigger_mask;
int next_state; enum session_state next_state;
} sess_fsm[SESSION_STATE_MAX][8]; } sess_fsm[SESSION_STATE_MAX][8];
void session_finite_state_machine_init() void session_finite_state_machine_init()
{ {
// SESSION_STATE_INIT -> SESSION_STATE_OPENING // SESSION_STATE_INIT -> SESSION_STATE_OPENING ( TCP_SYN | TCP_SYN_ACK | UDP_DATA )
// SESSION_STATE_INIT -> SESSION_STATE_INIT // 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][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; sess_fsm[SESSION_STATE_INIT][1].next_state = SESSION_STATE_INIT;
// SESSION_STATE_OPENING -> SESSION_STATE_ACTIVE // SESSION_STATE_OPENING -> SESSION_STATE_ACTIVE ( TCP_DATA | UDP_DATA )
// SESSION_STATE_OPENING -> SESSION_STATE_CLOSING // SESSION_STATE_OPENING -> SESSION_STATE_CLOSING ( TCP_FIN | TCP_RST | TIMEOUT )
// SESSION_STATE_OPENING -> SESSION_STATE_CLOSED // SESSION_STATE_OPENING -> SESSION_STATE_CLOSED ( LRU_EVICT )
// SESSION_STATE_OPENING -> SESSION_STATE_OPENING // 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][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][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][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; sess_fsm[SESSION_STATE_OPENING][3].next_state = SESSION_STATE_OPENING;
// SESSION_STATE_ACTIVE -> SESSION_STATE_CLOSING // SESSION_STATE_ACTIVE -> SESSION_STATE_CLOSING ( TCP_FIN | TCP_RST | TIMEOUT )
// SESSION_STATE_ACTIVE -> SESSION_STATE_ACTIVE // 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][0].next_state = SESSION_STATE_CLOSING;
sess_fsm[SESSION_STATE_ACTIVE][1].flag_mask = NONE; sess_fsm[SESSION_STATE_ACTIVE][1].trigger_mask = LRU_EVICT;
sess_fsm[SESSION_STATE_ACTIVE][1].next_state = SESSION_STATE_ACTIVE; sess_fsm[SESSION_STATE_ACTIVE][1].next_state = SESSION_STATE_CLOSED;
// SESSION_STATE_CLOSING -> SESSION_STATE_CLOSED sess_fsm[SESSION_STATE_ACTIVE][2].trigger_mask = NONE;
// SESSION_STATE_CLOSING -> SESSION_STATE_CLOSING 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][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; 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]; struct session_finite_state_machine *list = sess_fsm[curr_state];
for (int i = 0; i < 8; i++) for (int i = 0; i < 8; i++)
{ {
int mask = list[i].flag_mask; int mask = list[i].trigger_mask;
if (mask & input_pkt_flag) if (mask & trigger)
{ {
return list[i].next_state; 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)) switch (session_get_state(sess))
{ {
case SESSION_STATE_OPENING: case SESSION_STATE_OPENING:
mgr->tcp_opening_sess_num--; mgr->stat.tcp_opening_sess_num--;
break; break;
case SESSION_STATE_ACTIVE: case SESSION_STATE_ACTIVE:
mgr->tcp_active_sess_num--; mgr->stat.tcp_active_sess_num--;
break; break;
case SESSION_STATE_CLOSING: case SESSION_STATE_CLOSING:
mgr->tcp_closing_sess_num--; mgr->stat.tcp_closing_sess_num--;
break; break;
case SESSION_STATE_CLOSED: case SESSION_STATE_CLOSED:
/* void */ /* void */
@@ -601,17 +615,17 @@ static inline void session_manager_update_session_state(struct session_manager *
switch (state) switch (state)
{ {
case SESSION_STATE_OPENING: case SESSION_STATE_OPENING:
mgr->tcp_opening_sess_num++; mgr->stat.tcp_opening_sess_num++;
mgr->tcp_sess_num++; mgr->stat.tcp_sess_num++;
break; break;
case SESSION_STATE_ACTIVE: case SESSION_STATE_ACTIVE:
mgr->tcp_active_sess_num++; mgr->stat.tcp_active_sess_num++;
break; break;
case SESSION_STATE_CLOSING: case SESSION_STATE_CLOSING:
mgr->tcp_closing_sess_num++; mgr->stat.tcp_closing_sess_num++;
break; break;
case SESSION_STATE_CLOSED: case SESSION_STATE_CLOSED:
mgr->tcp_sess_num--; mgr->stat.tcp_sess_num--;
break; break;
default: default:
break; break;
@@ -623,13 +637,13 @@ static inline void session_manager_update_session_state(struct session_manager *
switch (session_get_state(sess)) switch (session_get_state(sess))
{ {
case SESSION_STATE_OPENING: case SESSION_STATE_OPENING:
mgr->udp_opening_sess_num--; mgr->stat.udp_opening_sess_num--;
break; break;
case SESSION_STATE_ACTIVE: case SESSION_STATE_ACTIVE:
mgr->udp_active_sess_num--; mgr->stat.udp_active_sess_num--;
break; break;
case SESSION_STATE_CLOSING: case SESSION_STATE_CLOSING:
mgr->udp_closing_sess_num--; mgr->stat.udp_closing_sess_num--;
break; break;
case SESSION_STATE_CLOSED: case SESSION_STATE_CLOSED:
/* void */ /* void */
@@ -642,17 +656,17 @@ static inline void session_manager_update_session_state(struct session_manager *
switch (state) switch (state)
{ {
case SESSION_STATE_OPENING: case SESSION_STATE_OPENING:
mgr->udp_opening_sess_num++; mgr->stat.udp_opening_sess_num++;
mgr->udp_sess_num++; mgr->stat.udp_sess_num++;
break; break;
case SESSION_STATE_ACTIVE: case SESSION_STATE_ACTIVE:
mgr->udp_active_sess_num++; mgr->stat.udp_active_sess_num++;
break; break;
case SESSION_STATE_CLOSING: case SESSION_STATE_CLOSING:
mgr->udp_closing_sess_num++; mgr->stat.udp_closing_sess_num++;
break; break;
case SESSION_STATE_CLOSED: case SESSION_STATE_CLOSED:
mgr->udp_sess_num--; mgr->stat.udp_sess_num--;
break; break;
default: default:
break; break;
@@ -887,20 +901,20 @@ static inline struct session *session_manager_new_tcp_session(struct session_man
return NULL; 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) if (mgr->opts.tcp_overload_evict_old_sess)
{ {
struct session *evicted_sess = session_table_find_least_recently_unused_session(mgr->tcp_sess_table); struct session *evicted_sess = session_table_find_least_recently_unused_session(mgr->tcp_sess_table);
assert(evicted_sess); assert(evicted_sess);
session_manager_evicte_session(mgr, 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 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; return NULL;
} }
else else
@@ -938,20 +952,20 @@ static inline struct session *session_manager_new_udp_session(struct session_man
return NULL; 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) if (mgr->opts.udp_overload_evict_old_sess)
{ {
struct session *evicted_sess = session_table_find_least_recently_unused_session(mgr->udp_sess_table); struct session *evicted_sess = session_table_find_least_recently_unused_session(mgr->udp_sess_table);
assert(evicted_sess); assert(evicted_sess);
session_manager_evicte_session(mgr, 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 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; return NULL;
} }
else else
@@ -1333,20 +1347,20 @@ void session_manager_print_stat(struct session_manager *mgr)
{ {
printf("session manager status:\n"); printf("session manager status:\n");
printf("tcp session number : %lu\n", mgr->tcp_sess_num); printf("tcp session number : %lu\n", mgr->stat.tcp_sess_num);
printf(" opening number : %lu\n", mgr->tcp_opening_sess_num); printf(" opening number : %lu\n", mgr->stat.tcp_opening_sess_num);
printf(" active number : %lu\n", mgr->tcp_active_sess_num); printf(" active number : %lu\n", mgr->stat.tcp_active_sess_num);
printf(" closing number : %lu\n", mgr->tcp_closing_sess_num); printf(" closing number : %lu\n", mgr->stat.tcp_closing_sess_num);
printf("udp session number : %lu\n", mgr->udp_sess_num); printf("udp session number : %lu\n", mgr->stat.udp_sess_num);
printf(" opening number : %lu\n", mgr->udp_opening_sess_num); printf(" opening number : %lu\n", mgr->stat.udp_opening_sess_num);
printf(" active number : %lu\n", mgr->udp_active_sess_num); printf(" active number : %lu\n", mgr->stat.udp_active_sess_num);
printf(" closing number : %lu\n", mgr->udp_closing_sess_num); printf(" closing number : %lu\n", mgr->stat.udp_closing_sess_num);
printf("tcp overload evict : \n"); printf("tcp overload evict : \n");
printf(" old session number: %lu\n", mgr->tcp_overload_evict_old_sess_num); printf(" old session number: %lu\n", mgr->stat.tcp_overload_evict_old_sess_num);
printf(" new session number: %lu\n", mgr->tcp_overload_evict_new_sess_num); printf(" new session number: %lu\n", mgr->stat.tcp_overload_evict_new_sess_num);
printf("udp overload evict : \n"); printf("udp overload evict : \n");
printf(" old session number: %lu\n", mgr->udp_overload_evict_old_sess_num); printf(" old session number: %lu\n", mgr->stat.udp_overload_evict_old_sess_num);
printf(" new session number: %lu\n", mgr->udp_overload_evict_new_sess_num); printf(" new session number: %lu\n", mgr->stat.udp_overload_evict_new_sess_num);
printf("packet status:\n"); printf("packet status:\n");
printf(" miss l4 proto : %lu (bypass)\n", mgr->npkts_miss_l4_proto); 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); 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; return &mgr->stat;
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;
} }

49
src/session/session_manager.h
View File

@@ -46,35 +46,6 @@ struct session_manager_options
double evicted_session_filter_error_rate; 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 struct session_manager_stat
{ {
uint64_t tcp_sess_num; uint64_t tcp_sess_num;
@@ -93,8 +64,26 @@ struct session_manager_stat
uint64_t udp_overload_evict_new_sess_num; 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_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 #ifdef __cpluscplus
} }

27
src/session/test/test_utils.h
View File

@@ -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 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) uint64_t udp_overload_evict_new_sess_num, uint64_t udp_overload_evict_old_sess_num)
{ {
struct session_manager_stat counter; struct session_manager_stat *stat = session_manager_get_stat(mgr);
session_manager_get_stat(mgr, &counter);
EXPECT_TRUE(counter.tcp_sess_num == tcp_opening_sess_num + tcp_active_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(counter.tcp_opening_sess_num == tcp_opening_sess_num); EXPECT_TRUE(stat->tcp_opening_sess_num == tcp_opening_sess_num);
EXPECT_TRUE(counter.tcp_active_sess_num == tcp_active_sess_num); EXPECT_TRUE(stat->tcp_active_sess_num == tcp_active_sess_num);
EXPECT_TRUE(counter.tcp_closing_sess_num == tcp_closing_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(stat->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(stat->udp_opening_sess_num == udp_opening_sess_num);
EXPECT_TRUE(counter.udp_active_sess_num == udp_active_sess_num); EXPECT_TRUE(stat->udp_active_sess_num == udp_active_sess_num);
EXPECT_TRUE(counter.udp_closing_sess_num == udp_closing_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(stat->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(stat->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(stat->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->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) __attribute__((unused)) static void __session_manager_check_tcp_timeout_init(struct session_manager *mgr, struct session_manager_options *opts)