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

Modify the stat of session manager

Browse Source
This commit is contained in:
luwenpeng
2024-04-09 10:36:39 +08:00
parent daff1ecbc7
commit 3b00acab81
14 changed files with 536 additions and 528 deletions
Download Patch File Download Diff File Expand all files Collapse all files

301
src/session/session_manager.cpp
View File

@@ -30,6 +30,80 @@ struct session_manager
#define EVICTE_SESSION_BURST (RX_BURST_MAX)
/******************************************************************************
* Stat
******************************************************************************/
#define NR_SESS_STAT_INC(stat, state, type) \
{ \
switch ((state)) \
{ \
case SESSION_STATE_OPENING: \
(stat)->nr_##type##_sess_opening++; \
break; \
case SESSION_STATE_ACTIVE: \
(stat)->nr_##type##_sess_active++; \
break; \
case SESSION_STATE_CLOSING: \
(stat)->nr_##type##_sess_closing++; \
break; \
case SESSION_STATE_DISCARD: \
(stat)->nr_##type##_sess_discard++; \
break; \
case SESSION_STATE_CLOSED: \
(stat)->nr_##type##_sess_closed++; \
break; \
default: \
break; \
} \
}
#define NR_SESS_STAT_DEC(stat, state, type) \
{ \
switch ((state)) \
{ \
case SESSION_STATE_OPENING: \
(stat)->nr_##type##_sess_opening--; \
break; \
case SESSION_STATE_ACTIVE: \
(stat)->nr_##type##_sess_active--; \
break; \
case SESSION_STATE_CLOSING: \
(stat)->nr_##type##_sess_closing--; \
break; \
case SESSION_STATE_DISCARD: \
(stat)->nr_##type##_sess_discard--; \
break; \
case SESSION_STATE_CLOSED: \
(stat)->nr_##type##_sess_closed--; \
break; \
default: \
break; \
} \
}
#define NR_SESS_STAT_UPDATE(stat, curr, next, type) \
{ \
if (curr != next) \
{ \
NR_SESS_STAT_DEC(stat, curr, type); \
NR_SESS_STAT_INC(stat, next, type); \
} \
}
#define NR_TCP_SESS_STAT_INC(stat, state) NR_SESS_STAT_INC(stat, state, tcp)
#define NR_UDP_SESS_STAT_INC(stat, state) NR_SESS_STAT_INC(stat, state, udp)
#define NR_TCP_SESS_STAT_DEC(stat, state) NR_SESS_STAT_DEC(stat, state, tcp)
#define NR_UDP_SESS_STAT_DEC(stat, state) NR_SESS_STAT_DEC(stat, state, udp)
#define NR_TCP_SESS_STAT_UPDATE(stat, curr, next) NR_SESS_STAT_UPDATE(stat, curr, next, tcp)
#define NR_UDP_SESS_STAT_UPDATE(stat, curr, next) NR_SESS_STAT_UPDATE(stat, curr, next, udp)
/******************************************************************************
* Options
******************************************************************************/
static int check_options(const struct session_manager_options *opts)
{
if (opts == NULL)
@@ -155,6 +229,10 @@ static int check_options(const struct session_manager_options *opts)
return 0;
}
/******************************************************************************
* TCP protocol control block
******************************************************************************/
/*
* The next routines deal with comparing 32 bit unsigned ints
* and worry about wraparound (automatic with unsigned arithmetic).
@@ -193,7 +271,7 @@ static int tcp_pcb_init(struct tcp_pcb *pcb, uint8_t tcp_reassembly_enable, uint
return 0;
}
static void tcp_pcb_update(struct tcp_pcb *pcb, enum session_dir dir, const struct pkt_layer *tcp_layer, uint64_t now)
static void tcp_pcb_update(struct session_manager_stat *stat, struct tcp_pcb *pcb, enum session_dir dir, const struct pkt_layer *tcp_layer, uint64_t now)
{
struct tcp_segment *seg;
struct tcphdr *hdr = (struct tcphdr *)tcp_layer->hdr_ptr;
@@ -208,8 +286,10 @@ static void tcp_pcb_update(struct tcp_pcb *pcb, enum session_dir dir, const stru
{
if (tcp_layer->pld_len)
{
half->nr_seg_received++;
half->nr_seg_inorder++;
half->nr_tcp_seg_received++;
half->nr_tcp_seg_inorder++;
stat->nr_tcp_seg_received++;
stat->nr_tcp_seg_inorder++;
half->order.data = tcp_layer->pld_ptr;
half->order.len = tcp_layer->pld_len;
}
@@ -224,42 +304,51 @@ static void tcp_pcb_update(struct tcp_pcb *pcb, enum session_dir dir, const stru
seg = tcp_reassembly_expire(half->assembler, now);
if (seg)
{
half->nr_seg_expired++;
half->nr_seg_released++;
half->nr_tcp_seg_expired++;
half->nr_tcp_seg_released++;
stat->nr_tcp_seg_expired++;
stat->nr_tcp_seg_released++;
tcp_segment_free(seg);
}
if (tcp_layer->pld_len)
{
half->nr_seg_received++;
half->nr_tcp_seg_received++;
stat->nr_tcp_seg_received++;
uint32_t rcv_nxt = tcp_reassembly_get_recv_next(half->assembler);
if (half->seq == rcv_nxt)
{
half->nr_seg_inorder++;
half->nr_tcp_seg_inorder++;
stat->nr_tcp_seg_inorder++;
half->order.data = tcp_layer->pld_ptr;
half->order.len = tcp_layer->pld_len;
tcp_reassembly_inc_recv_next(half->assembler, tcp_layer->pld_len);
}
else if (before(half->seq, rcv_nxt))
{
// TODO add metric (overlap)
half->nr_seg_overlap++;
half->nr_tcp_seg_overlap++;
stat->nr_tcp_seg_overlap++;
}
else if ((seg = tcp_segment_new(half->seq, tcp_layer->pld_ptr, tcp_layer->pld_len)))
{
switch (tcp_reassembly_push(half->assembler, seg, now))
{
case -1:
half->nr_seg_no_space++;
half->nr_tcp_seg_no_space++;
stat->nr_tcp_seg_no_space++;
tcp_segment_free(seg);
break;
case 0:
half->nr_seg_buffered++;
half->nr_tcp_seg_buffered++;
stat->nr_tcp_seg_buffered++;
break;
case 1:
half->nr_seg_buffered++;
half->nr_seg_overlap++;
half->nr_tcp_seg_buffered++;
half->nr_tcp_seg_overlap++;
stat->nr_tcp_seg_buffered++;
stat->nr_tcp_seg_overlap++;
break;
default:
assert(0);
@@ -268,86 +357,12 @@ static void tcp_pcb_update(struct tcp_pcb *pcb, enum session_dir dir, const stru
}
else
{
half->nr_seg_no_space++;
half->nr_tcp_seg_no_space++;
stat->nr_tcp_seg_no_space++;
}
}
}
/******************************************************************************
* Stat
******************************************************************************/
static void session_stat_inc(struct session_stat *stat, enum session_state state)
{
switch (state)
{
case SESSION_STATE_INIT:
stat->nr_sess_init++;
break;
case SESSION_STATE_OPENING:
stat->nr_sess_opening++;
break;
case SESSION_STATE_ACTIVE:
stat->nr_sess_active++;
break;
case SESSION_STATE_CLOSING:
stat->nr_sess_closing++;
break;
case SESSION_STATE_DISCARD:
stat->nr_sess_discard++;
break;
case SESSION_STATE_CLOSED:
stat->nr_sess_closed++;
break;
default:
break;
}
}
static void session_stat_dec(struct session_stat *stat, enum session_state state)
{
switch (state)
{
case SESSION_STATE_INIT:
stat->nr_sess_init--;
break;
case SESSION_STATE_OPENING:
stat->nr_sess_opening--;
break;
case SESSION_STATE_ACTIVE:
stat->nr_sess_active--;
break;
case SESSION_STATE_CLOSING:
stat->nr_sess_closing--;
break;
case SESSION_STATE_DISCARD:
stat->nr_sess_discard--;
break;
case SESSION_STATE_CLOSED:
stat->nr_sess_closed--;
break;
default:
break;
}
}
static void session_stat_update(struct session_manager *mgr, struct session *sess, enum session_state curr_state, enum session_state next_state)
{
switch (session_get_type(sess))
{
case SESSION_TYPE_TCP:
session_stat_dec(&mgr->stat.tcp_sess, curr_state);
session_stat_inc(&mgr->stat.tcp_sess, next_state);
break;
case SESSION_TYPE_UDP:
session_stat_dec(&mgr->stat.udp_sess, curr_state);
session_stat_inc(&mgr->stat.udp_sess, next_state);
break;
default:
break;
}
}
/******************************************************************************
* Session Direction
******************************************************************************/
@@ -405,20 +420,16 @@ static int session_manager_self_protection(struct session_manager *mgr, struct s
switch (key->ip_proto)
{
case IPPROTO_TCP:
if (stat->tcp_sess.nr_sess_used >= mgr->opts.max_tcp_session_num)
if (stat->nr_tcp_sess_used >= mgr->opts.max_tcp_session_num)
{
stat->evc_pkt.nr_pkts++;
stat->evc_pkt.nr_bytes += packet_get_len(pkt);
stat->tcp_sess.nr_new_sess_evicted++;
stat->nr_tcp_pkts_bypass_no_space++;
return 1;
}
break;
case IPPROTO_UDP:
if (stat->udp_sess.nr_sess_used >= mgr->opts.max_udp_session_num)
if (stat->nr_udp_sess_used >= mgr->opts.max_udp_session_num)
{
stat->evc_pkt.nr_pkts++;
stat->evc_pkt.nr_bytes += packet_get_len(pkt);
stat->udp_sess.nr_new_sess_evicted++;
stat->nr_udp_pkts_bypass_no_space++;
return 1;
}
break;
@@ -434,8 +445,7 @@ static int session_manager_filter_evicted_session(struct session_manager *mgr, s
{
if (mgr->opts.evicted_session_filter_enable && evicted_session_filter_lookup(mgr->evicte_sess_filter, key, now))
{
mgr->stat.evc_pkt.nr_pkts++;
mgr->stat.evc_pkt.nr_bytes += packet_get_len(pkt);
mgr->stat.nr_udp_pkts_bypass_hit_evc++;
return 1;
}
@@ -457,8 +467,7 @@ static int session_manager_filter_duplicated_packet(struct session_manager *mgr,
{
if (duplicated_packet_filter_lookup(mgr->dup_pkt_filter, pkt, now))
{
mgr->stat.dup_pkt.nr_pkts++;
mgr->stat.dup_pkt.nr_bytes += packet_get_len(pkt);
mgr->stat.nr_tcp_pkts_bypass_hit_dup++;
session_set_dup_traffic(sess);
return 1;
}
@@ -570,7 +579,6 @@ static void session_manager_evicte_session(struct session_manager *mgr, struct s
enum session_state next_state = session_transition_run(curr_state, LRU_EVICT);
session_transition_log(sess, curr_state, next_state, LRU_EVICT);
session_set_state(sess, next_state);
session_stat_update(mgr, sess, curr_state, next_state);
session_timer_del(mgr->sess_timer, sess);
session_set_closing_reason(sess, CLOSING_BY_EVICTED);
@@ -580,17 +588,19 @@ static void session_manager_evicte_session(struct session_manager *mgr, struct s
{
case SESSION_TYPE_TCP:
SESSION_LOG_DEBUG("evicte tcp old session: %lu", session_get_id(sess));
mgr->stat.tcp_sess.nr_old_sess_evicted++;
session_table_del(mgr->tcp_sess_table, session_get_tuple(sess));
NR_TCP_SESS_STAT_UPDATE(&mgr->stat, curr_state, next_state);
mgr->stat.nr_tcp_sess_evicted++;
break;
case SESSION_TYPE_UDP:
SESSION_LOG_DEBUG("evicte udp old session: %lu", session_get_id(sess));
mgr->stat.udp_sess.nr_old_sess_evicted++;
session_table_del(mgr->udp_sess_table, session_get_tuple(sess));
if (mgr->opts.evicted_session_filter_enable)
{
evicted_session_filter_add(mgr->evicte_sess_filter, session_get_tuple(sess), now);
}
NR_UDP_SESS_STAT_UPDATE(&mgr->stat, curr_state, next_state);
mgr->stat.nr_udp_sess_evicted++;
break;
default:
assert(0);
@@ -605,11 +615,12 @@ static struct session *session_manager_new_tcp_session(struct session_manager *m
uint8_t flags = tcp_hdr_get_flags(hdr);
if (!(flags & TH_SYN))
{
mgr->stat.nr_tcp_pkts_bypass_miss_sess++;
return NULL;
}
// tcp table full evict old session
if (mgr->opts.tcp_overload_evict_old_sess && mgr->stat.tcp_sess.nr_sess_used >= mgr->opts.max_tcp_session_num - EVICTE_SESSION_BURST)
if (mgr->opts.tcp_overload_evict_old_sess && mgr->stat.nr_tcp_sess_used >= mgr->opts.max_tcp_session_num - EVICTE_SESSION_BURST)
{
struct session *evic_sess = session_table_find_lru(mgr->tcp_sess_table);
session_manager_evicte_session(mgr, evic_sess, now);
@@ -623,6 +634,7 @@ static struct session *session_manager_new_tcp_session(struct session_manager *m
return NULL;
}
session_init(sess);
sess->mgr_stat = &mgr->stat;
session_set_id(sess, id_generator_alloc());
if (tcp_pcb_init(&sess->tcp_pcb, mgr->opts.tcp_reassembly_enable, mgr->opts.tcp_reassembly_max_timeout, mgr->opts.tcp_reassembly_max_segments) == -1)
@@ -631,12 +643,11 @@ static struct session *session_manager_new_tcp_session(struct session_manager *m
session_pool_push(mgr->sess_pool, sess);
return NULL;
}
tcp_pcb_update(&sess->tcp_pcb, dir, tcp_layer, now);
tcp_pcb_update(&mgr->stat, &sess->tcp_pcb, dir, tcp_layer, now);
enum session_state next_state = session_transition_run(SESSION_STATE_INIT, TCP_SYN);
session_update(sess, next_state, pkt, key, dir, now);
session_transition_log(sess, SESSION_STATE_INIT, next_state, TCP_SYN);
session_stat_inc(&mgr->stat.tcp_sess, next_state);
uint64_t timeout = (flags & TH_ACK) ? mgr->opts.tcp_handshake_timeout : mgr->opts.tcp_init_timeout;
session_timer_update(mgr->sess_timer, sess, now + timeout);
@@ -648,7 +659,8 @@ static struct session *session_manager_new_tcp_session(struct session_manager *m
duplicated_packet_filter_add(mgr->dup_pkt_filter, pkt, now);
}
mgr->stat.tcp_sess.nr_sess_used++;
NR_TCP_SESS_STAT_INC(&mgr->stat, next_state);
mgr->stat.nr_tcp_sess_used++;
return sess;
}
@@ -656,7 +668,7 @@ static struct session *session_manager_new_tcp_session(struct session_manager *m
static struct session *session_manager_new_udp_session(struct session_manager *mgr, const struct packet *pkt, const struct tuple6 *key, uint64_t now)
{
// udp table full evict old session
if (mgr->opts.udp_overload_evict_old_sess && mgr->stat.udp_sess.nr_sess_used >= mgr->opts.max_udp_session_num - EVICTE_SESSION_BURST)
if (mgr->opts.udp_overload_evict_old_sess && mgr->stat.nr_udp_sess_used >= mgr->opts.max_udp_session_num - EVICTE_SESSION_BURST)
{
struct session *evic_sess = session_table_find_lru(mgr->udp_sess_table);
session_manager_evicte_session(mgr, evic_sess, now);
@@ -668,19 +680,21 @@ static struct session *session_manager_new_udp_session(struct session_manager *m
assert(sess);
return NULL;
}
mgr->stat.udp_sess.nr_sess_used++;
session_init(sess);
sess->mgr_stat = &mgr->stat;
session_set_id(sess, id_generator_alloc());
enum session_dir dir = identify_direction_by_port(ntohs(key->src_port), ntohs(key->dst_port));
enum session_state next_state = session_transition_run(SESSION_STATE_INIT, UDP_DATA);
session_update(sess, next_state, pkt, key, dir, now);
session_transition_log(sess, SESSION_STATE_INIT, next_state, UDP_DATA);
session_stat_inc(&mgr->stat.udp_sess, next_state);
session_timer_update(mgr->sess_timer, sess, now + mgr->opts.udp_data_timeout);
session_table_add(mgr->udp_sess_table, key, sess);
NR_UDP_SESS_STAT_INC(&mgr->stat, next_state);
mgr->stat.nr_udp_sess_used++;
return sess;
}
@@ -702,11 +716,10 @@ static int session_manager_update_tcp_session(struct session_manager *mgr, struc
// update session
session_update(sess, next_state, pkt, key, dir, now);
session_stat_update(mgr, sess, curr_state, next_state);
session_transition_log(sess, curr_state, next_state, inputs);
// update tcp pcb
tcp_pcb_update(&sess->tcp_pcb, dir, tcp_layer, now);
tcp_pcb_update(&mgr->stat, &sess->tcp_pcb, dir, tcp_layer, now);
if (mgr->opts.duplicated_packet_filter_enable)
{
@@ -770,6 +783,8 @@ static int session_manager_update_tcp_session(struct session_manager *mgr, struc
}
session_timer_update(mgr->sess_timer, sess, now + timeout);
NR_TCP_SESS_STAT_UPDATE(&mgr->stat, curr_state, next_state);
return 0;
}
@@ -780,9 +795,10 @@ static int session_manager_update_udp_session(struct session_manager *mgr, struc
enum session_state next_state = session_transition_run(curr_state, UDP_DATA);
session_update(sess, next_state, pkt, key, dir, now);
session_transition_log(sess, curr_state, next_state, UDP_DATA);
session_stat_update(mgr, sess, curr_state, next_state);
session_timer_update(mgr->sess_timer, sess, now + mgr->opts.udp_data_timeout);
NR_UDP_SESS_STAT_UPDATE(&mgr->stat, curr_state, next_state);
return 0;
}
@@ -913,13 +929,13 @@ void session_manager_free_session(struct session_manager *mgr, struct session *s
case SESSION_TYPE_TCP:
tcp_pcb_clean(&sess->tcp_pcb);
session_table_del(mgr->tcp_sess_table, session_get_tuple(sess));
session_stat_dec(&mgr->stat.tcp_sess, session_get_state(sess));
mgr->stat.tcp_sess.nr_sess_used--;
NR_TCP_SESS_STAT_DEC(&mgr->stat, session_get_state(sess));
mgr->stat.nr_tcp_sess_used--;
break;
case SESSION_TYPE_UDP:
session_table_del(mgr->udp_sess_table, session_get_tuple(sess));
session_stat_dec(&mgr->stat.udp_sess, session_get_state(sess));
mgr->stat.udp_sess.nr_sess_used--;
NR_UDP_SESS_STAT_DEC(&mgr->stat, session_get_state(sess));
mgr->stat.nr_udp_sess_used--;
break;
default:
assert(0);
@@ -984,7 +1000,22 @@ struct session *session_manager_get_expired_session(struct session_manager *mgr,
enum session_state next_state = session_transition_run(curr_state, TIMEOUT);
session_transition_log(sess, curr_state, next_state, TIMEOUT);
session_set_state(sess, next_state);
session_stat_update(mgr, sess, curr_state, next_state);
uint64_t timeout = 0;
switch (session_get_type(sess))
{
case SESSION_TYPE_TCP:
timeout = mgr->opts.tcp_data_timeout;
NR_TCP_SESS_STAT_UPDATE(&mgr->stat, curr_state, next_state);
break;
case SESSION_TYPE_UDP:
timeout = mgr->opts.udp_data_timeout;
NR_UDP_SESS_STAT_UPDATE(&mgr->stat, curr_state, next_state);
break;
default:
assert(0);
break;
}
if (next_state == SESSION_STATE_CLOSED)
{
@@ -998,19 +1029,6 @@ struct session *session_manager_get_expired_session(struct session_manager *mgr,
else
{
// in closing state, only update timeout
uint64_t timeout = 0;
switch (session_get_type(sess))
{
case SESSION_TYPE_TCP:
timeout = mgr->opts.tcp_data_timeout;
break;
case SESSION_TYPE_UDP:
timeout = mgr->opts.udp_data_timeout;
break;
default:
assert(0);
break;
}
session_timer_update(mgr->sess_timer, sess, now + timeout);
return NULL;
}
@@ -1042,17 +1060,14 @@ void session_manager_print_stat(struct session_manager *mgr)
{
if (mgr)
{
SESSION_LOG_DEBUG("session_manager_stat->tcp_sess_num: used: %u, init: %u, opening: %u, active: %u, closing: %u, closed: %u, evic_new: %u, evic_old: %u",
mgr->stat.tcp_sess.nr_sess_used, mgr->stat.tcp_sess.nr_sess_init, mgr->stat.tcp_sess.nr_sess_opening,
mgr->stat.tcp_sess.nr_sess_active, mgr->stat.tcp_sess.nr_sess_closing, mgr->stat.tcp_sess.nr_sess_closed,
mgr->stat.tcp_sess.nr_new_sess_evicted, mgr->stat.tcp_sess.nr_old_sess_evicted);
SESSION_LOG_DEBUG("session_manager_stat->udp_sess_num: used: %u, init: %u, opening: %u, active: %u, closing: %u, closed: %u, evic_new: %u, evic_old: %u",
mgr->stat.udp_sess.nr_sess_used, mgr->stat.udp_sess.nr_sess_init, mgr->stat.udp_sess.nr_sess_opening,
mgr->stat.udp_sess.nr_sess_active, mgr->stat.udp_sess.nr_sess_closing, mgr->stat.udp_sess.nr_sess_closed,
mgr->stat.udp_sess.nr_new_sess_evicted, mgr->stat.udp_sess.nr_old_sess_evicted);
SESSION_LOG_DEBUG("session_manager_stat: dup_pkts: %u, dup_bytes: %u, evic_pkts: %u, evic_bytes: %u",
mgr->stat.dup_pkt.nr_pkts, mgr->stat.dup_pkt.nr_bytes,
mgr->stat.evc_pkt.nr_pkts, mgr->stat.evc_pkt.nr_bytes);
SESSION_LOG_DEBUG("session_manager_stat->tcp_sess: used: %u, opening: %u, active: %u, closing: %u, closed: %u",
mgr->stat.nr_tcp_sess_used, mgr->stat.nr_tcp_sess_opening, mgr->stat.nr_tcp_sess_active,
mgr->stat.nr_tcp_sess_closing, mgr->stat.nr_tcp_sess_closed);
SESSION_LOG_DEBUG("session_manager_stat->udp_sess: used: %u, opening: %u, active: %u, closing: %u, closed: %u",
mgr->stat.nr_udp_sess_used, mgr->stat.nr_udp_sess_opening, mgr->stat.nr_udp_sess_active,
mgr->stat.nr_udp_sess_closing, mgr->stat.nr_udp_sess_closed);
SESSION_LOG_DEBUG("session_manager_stat->evicted_sess: tcp: %u, udp: %u",
mgr->stat.nr_tcp_sess_evicted, mgr->stat.nr_udp_sess_evicted);
}
}