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

optimizate: pass the current timeout to the ID generator as a parameter, instead of getting the time from the ID generator itself

Browse Source
This commit is contained in:
luwenpeng
2024-07-16 17:13:32 +08:00
parent 07ce636f64
commit b50f0c2c70
21 changed files with 197 additions and 201 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
include/stellar/session.h
View File

@@ -113,7 +113,7 @@ enum session_stat
MAX_STAT,
};
// realtime in seconds
// realtime in milliseconds
enum session_timestamp
{
SESSION_TIMESTAMP_START,

7
src/id_generator/id_generator.cpp
View File

@@ -3,7 +3,6 @@
#include "log.h"
#include "macro.h"
#include "times.h"
#include "stellar_core.h"
#include "id_generator.h"
@@ -18,7 +17,7 @@ struct id_generator
uint64_t thread_volatile[MAX_THREAD_NUM];
};
struct id_generator global_id_generator;
struct id_generator global_id_generator = {0};
// return 0: success
// return -1: failed
@@ -62,7 +61,7 @@ int id_generator_init(const struct id_generator_options *opts)
* | 1bit | 12bit device_id | 8bit thread_id | 28bit timestamp in sec | 15bit sequence per thread |
* +------+------------------+----------------+------------------------+---------------------------+
*/
uint64_t id_generator_alloc()
uint64_t id_generator_alloc(uint64_t now_sec)
{
#define MAX_ID_PER_THREAD (32768)
#define MAX_ID_BASE_TIME (268435456L)
@@ -71,7 +70,7 @@ uint64_t id_generator_alloc()
uint64_t global_id = 0;
uint64_t id_per_thread = (global_id_generator.thread_volatile[thr_idx]++) % MAX_ID_PER_THREAD;
uint64_t id_base_time = stellar_get_real_time_sec() % MAX_ID_BASE_TIME;
uint64_t id_base_time = now_sec % MAX_ID_BASE_TIME;
global_id = (global_id_generator.device_id << 51) |
(thr_idx << 43) |
(id_base_time << 15) |

2
src/id_generator/id_generator.h
View File

@@ -16,7 +16,7 @@ struct id_generator_options
// return 0: success
// return -1: failed
int id_generator_init(const struct id_generator_options *opts);
uint64_t id_generator_alloc();
uint64_t id_generator_alloc(uint64_t now_sec);
#ifdef __cplusplus
}

141
src/session/session_manager.cpp
View File

@@ -4,7 +4,6 @@
#include "log.h"
#include "macro.h"
#include "times.h"
#include "tcp_utils.h"
#include "udp_utils.h"
#include "packet_layer.h"
@@ -36,6 +35,12 @@ struct session_manager
struct session_manager_stat stat;
struct session_manager_options opts;
/*
* only used for session_set_discard() or session_manager record_duplicated_packet(),
* because the function is called by pluin and has no time input.
*/
uint64_t now_ms;
};
#define EVICTE_SESSION_BURST (RX_BURST_MAX)
@@ -286,7 +291,7 @@ static int tcp_init(struct session_manager *mgr, struct session *sess)
return 0;
}
static void tcp_update(struct session_manager *mgr, struct session *sess, enum flow_direction dir, const struct raw_layer *tcp_layer, uint64_t now)
static void tcp_update(struct session_manager *mgr, struct session *sess, enum flow_direction dir, const struct raw_layer *tcp_layer)
{
struct tcp_segment *seg;
struct tcphdr *hdr = (struct tcphdr *)tcp_layer->hdr_ptr;
@@ -329,7 +334,7 @@ static void tcp_update(struct session_manager *mgr, struct session *sess, enum f
tcp_reassembly_set_recv_next(half->assembler, len ? half->seq : half->seq + 1);
}
seg = tcp_reassembly_expire(half->assembler, now);
seg = tcp_reassembly_expire(half->assembler, mgr->now_ms);
if (seg)
{
session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_EXPIRED, 1);
@@ -371,7 +376,7 @@ static void tcp_update(struct session_manager *mgr, struct session *sess, enum f
}
else if ((seg = tcp_segment_new(half->seq, tcp_layer->pld_ptr, len)))
{
switch (tcp_reassembly_push(half->assembler, seg, now))
switch (tcp_reassembly_push(half->assembler, seg, mgr->now_ms))
{
case -2:
session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_RETRANSMIT, 1);
@@ -452,7 +457,7 @@ static enum flow_direction identify_direction_by_history(const struct session *s
******************************************************************************/
// on new session
static int tcp_overload_bypass(struct session_manager *mgr, const struct tuple6 *key, uint64_t now)
static int tcp_overload_bypass(struct session_manager *mgr, const struct tuple6 *key)
{
if (key->ip_proto == IPPROTO_TCP && mgr->stat.curr_nr_tcp_sess_used >= mgr->opts.max_tcp_session_num)
{
@@ -461,7 +466,8 @@ static int tcp_overload_bypass(struct session_manager *mgr, const struct tuple6
}
return 0;
}
static int udp_overload_bypass(struct session_manager *mgr, const struct tuple6 *key, uint64_t now)
static int udp_overload_bypass(struct session_manager *mgr, const struct tuple6 *key)
{
if (key->ip_proto == IPPROTO_UDP && mgr->stat.curr_nr_udp_sess_used >= mgr->opts.max_udp_session_num)
{
@@ -470,9 +476,10 @@ static int udp_overload_bypass(struct session_manager *mgr, const struct tuple6
}
return 0;
}
static int evicted_session_bypass(struct session_manager *mgr, const struct tuple6 *key, uint64_t now)
static int evicted_session_bypass(struct session_manager *mgr, const struct tuple6 *key)
{
if (mgr->opts.evicted_session_filter_enable && evicted_session_filter_lookup(mgr->evicte_sess_filter, key, now))
if (mgr->opts.evicted_session_filter_enable && evicted_session_filter_lookup(mgr->evicte_sess_filter, key, mgr->now_ms))
{
mgr->stat.nr_udp_pkts_evctd_bypass++;
return 1;
@@ -480,8 +487,9 @@ static int evicted_session_bypass(struct session_manager *mgr, const struct tupl
return 0;
}
// on update session
static int duplicated_packet_bypass(struct session_manager *mgr, struct session *sess, const struct packet *pkt, const struct tuple6 *key, uint64_t now)
static int duplicated_packet_bypass(struct session_manager *mgr, struct session *sess, const struct packet *pkt, const struct tuple6 *key)
{
if (mgr->opts.duplicated_packet_filter_enable == 0)
{
@@ -491,7 +499,7 @@ static int duplicated_packet_bypass(struct session_manager *mgr, struct session
enum flow_direction dir = identify_direction_by_history(sess, key);
if (session_get_stat(sess, dir, STAT_RAW_PACKETS_RECEIVED) < 3 || session_has_duplicate_traffic(sess))
{
if (duplicated_packet_filter_lookup(mgr->dup_pkt_filter, pkt, now))
if (duplicated_packet_filter_lookup(mgr->dup_pkt_filter, pkt, mgr->now_ms))
{
session_inc_stat(sess, dir, STAT_DUPLICATE_PACKETS_BYPASS, 1);
session_inc_stat(sess, dir, STAT_DUPLICATE_BYTES_BYPASS, packet_get_raw_len(pkt));
@@ -515,7 +523,7 @@ static int duplicated_packet_bypass(struct session_manager *mgr, struct session
}
else
{
duplicated_packet_filter_add(mgr->dup_pkt_filter, pkt, now);
duplicated_packet_filter_add(mgr->dup_pkt_filter, pkt, mgr->now_ms);
return 0;
}
}
@@ -527,12 +535,11 @@ static int duplicated_packet_bypass(struct session_manager *mgr, struct session
* Session Manager
******************************************************************************/
static void session_update(struct session *sess, enum session_state next_state, const struct packet *pkt, const struct tuple6 *key, enum flow_direction dir)
static void session_update(struct session_manager *mgr, struct session *sess, enum session_state next_state, const struct packet *pkt, const struct tuple6 *key, enum flow_direction dir)
{
uint64_t real_sec = stellar_get_real_time_sec();
if (session_get_current_state(sess) == SESSION_STATE_INIT)
{
session_set_id(sess, id_generator_alloc());
session_set_id(sess, id_generator_alloc(mgr->now_ms / 1000));
session_set_tuple6(sess, key);
session_set_tuple_direction(sess, dir);
@@ -562,7 +569,7 @@ static void session_update(struct session *sess, enum session_state next_state,
}
tuple6_to_str(key, sess->tuple_str, sizeof(sess->tuple_str));
session_set_timestamp(sess, SESSION_TIMESTAMP_START, real_sec);
session_set_timestamp(sess, SESSION_TIMESTAMP_START, mgr->now_ms);
switch (key->ip_proto)
{
case IPPROTO_TCP:
@@ -589,11 +596,11 @@ static void session_update(struct session *sess, enum session_state next_state,
session_set_current_packet(sess, pkt);
session_set_current_flow_direction(sess, dir);
session_set_timestamp(sess, SESSION_TIMESTAMP_LAST, real_sec);
session_set_timestamp(sess, SESSION_TIMESTAMP_LAST, mgr->now_ms);
session_set_current_state(sess, next_state);
}
static void session_manager_evicte_session(struct session_manager *mgr, struct session *sess, uint64_t now, int reason)
static void session_manager_evicte_session(struct session_manager *mgr, struct session *sess, int reason)
{
if (sess == NULL)
{
@@ -632,7 +639,7 @@ static void session_manager_evicte_session(struct session_manager *mgr, struct s
session_table_del(mgr->udp_sess_table, sess);
if (mgr->opts.evicted_session_filter_enable)
{
evicted_session_filter_add(mgr->evicte_sess_filter, session_get_tuple6(sess), now);
evicted_session_filter_add(mgr->evicte_sess_filter, session_get_tuple6(sess), mgr->now_ms);
}
SESS_MGR_STAT_UPDATE(&mgr->stat, curr_state, next_state, udp);
mgr->stat.nr_udp_sess_evicted++;
@@ -643,7 +650,7 @@ static void session_manager_evicte_session(struct session_manager *mgr, struct s
}
}
static struct session *session_manager_lookup_tcp_session(struct session_manager *mgr, const struct packet *pkt, const struct tuple6 *key, uint64_t now)
static struct session *session_manager_lookup_tcp_session(struct session_manager *mgr, const struct packet *pkt, const struct tuple6 *key)
{
struct session *sess = session_table_find_tuple6(mgr->tcp_sess_table, key);
if (sess == NULL)
@@ -665,7 +672,7 @@ static struct session *session_manager_lookup_tcp_session(struct session_manager
((half->history & TH_FIN) || (half->history & TH_RST))) // recv SYN after FIN or RST
{
// TCP port reuse, evict old session
session_manager_evicte_session(mgr, sess, now, PORT_REUSE_EVICT);
session_manager_evicte_session(mgr, sess, PORT_REUSE_EVICT);
return NULL;
}
else
@@ -675,7 +682,7 @@ static struct session *session_manager_lookup_tcp_session(struct session_manager
}
}
static struct session *session_manager_new_tcp_session(struct session_manager *mgr, const struct packet *pkt, const struct tuple6 *key, uint64_t now)
static struct session *session_manager_new_tcp_session(struct session_manager *mgr, const struct packet *pkt, const struct tuple6 *key)
{
const struct raw_layer *tcp_layer = packet_get_innermost_raw_layer(pkt, LAYER_PROTO_TCP);
const struct tcphdr *hdr = (const struct tcphdr *)tcp_layer->hdr_ptr;
@@ -690,7 +697,7 @@ static struct session *session_manager_new_tcp_session(struct session_manager *m
if (mgr->opts.tcp_overload_evict_old_sess && mgr->stat.curr_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, LRU_EVICT);
session_manager_evicte_session(mgr, evic_sess, LRU_EVICT);
}
enum flow_direction dir = (flags & TH_ACK) ? FLOW_DIRECTION_S2C : FLOW_DIRECTION_C2S;
@@ -705,7 +712,7 @@ static struct session *session_manager_new_tcp_session(struct session_manager *m
sess->mgr_stat = &mgr->stat;
enum session_state next_state = session_transition_run(SESSION_STATE_INIT, TCP_SYN);
session_update(sess, next_state, pkt, key, dir);
session_update(mgr, sess, next_state, pkt, key, dir);
session_transition_log(sess, SESSION_STATE_INIT, next_state, TCP_SYN);
if (tcp_init(mgr, sess) == -1)
@@ -714,15 +721,15 @@ static struct session *session_manager_new_tcp_session(struct session_manager *m
session_pool_push(mgr->sess_pool, sess);
return NULL;
}
tcp_update(mgr, sess, dir, tcp_layer, now);
tcp_update(mgr, sess, dir, tcp_layer);
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);
session_timer_update(mgr->sess_timer, sess, mgr->now_ms + timeout);
session_table_add(mgr->tcp_sess_table, sess);
if (mgr->opts.duplicated_packet_filter_enable)
{
duplicated_packet_filter_add(mgr->dup_pkt_filter, pkt, now);
duplicated_packet_filter_add(mgr->dup_pkt_filter, pkt, mgr->now_ms);
}
SESS_MGR_STAT_INC(&mgr->stat, next_state, tcp);
@@ -732,13 +739,13 @@ static struct session *session_manager_new_tcp_session(struct session_manager *m
return sess;
}
static struct session *session_manager_new_udp_session(struct session_manager *mgr, const struct packet *pkt, const struct tuple6 *key, uint64_t now)
static struct session *session_manager_new_udp_session(struct session_manager *mgr, const struct packet *pkt, const struct tuple6 *key)
{
// udp table full evict old session
if (mgr->opts.udp_overload_evict_old_sess && mgr->stat.curr_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, LRU_EVICT);
session_manager_evicte_session(mgr, evic_sess, LRU_EVICT);
}
struct session *sess = session_pool_pop(mgr->sess_pool);
@@ -753,10 +760,10 @@ static struct session *session_manager_new_udp_session(struct session_manager *m
enum flow_direction 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);
session_update(mgr, sess, next_state, pkt, key, dir);
session_transition_log(sess, SESSION_STATE_INIT, next_state, UDP_DATA);
session_timer_update(mgr->sess_timer, sess, now + mgr->opts.udp_data_timeout);
session_timer_update(mgr->sess_timer, sess, mgr->now_ms + mgr->opts.udp_data_timeout);
session_table_add(mgr->udp_sess_table, sess);
SESS_MGR_STAT_INC(&mgr->stat, next_state, udp);
@@ -766,7 +773,7 @@ static struct session *session_manager_new_udp_session(struct session_manager *m
return sess;
}
static int session_manager_update_tcp_session(struct session_manager *mgr, struct session *sess, const struct packet *pkt, const struct tuple6 *key, uint64_t now)
static int session_manager_update_tcp_session(struct session_manager *mgr, struct session *sess, const struct packet *pkt, const struct tuple6 *key)
{
const struct raw_layer *tcp_layer = packet_get_innermost_raw_layer(pkt, LAYER_PROTO_TCP);
const struct tcphdr *hdr = (const struct tcphdr *)tcp_layer->hdr_ptr;
@@ -783,11 +790,11 @@ static int session_manager_update_tcp_session(struct session_manager *mgr, struc
enum session_state next_state = session_transition_run(curr_state, inputs);
// update session
session_update(sess, next_state, pkt, key, dir);
session_update(mgr, sess, next_state, pkt, key, dir);
session_transition_log(sess, curr_state, next_state, inputs);
// update tcp
tcp_update(mgr, sess, dir, tcp_layer, now);
tcp_update(mgr, sess, dir, tcp_layer);
// set closing reason
if (next_state == SESSION_STATE_CLOSING && !session_get_closing_reason(sess))
@@ -844,28 +851,28 @@ static int session_manager_update_tcp_session(struct session_manager *mgr, struc
assert(0);
break;
}
session_timer_update(mgr->sess_timer, sess, now + timeout);
session_timer_update(mgr->sess_timer, sess, mgr->now_ms + timeout);
SESS_MGR_STAT_UPDATE(&mgr->stat, curr_state, next_state, tcp);
return 0;
}
static int session_manager_update_udp_session(struct session_manager *mgr, struct session *sess, const struct packet *pkt, const struct tuple6 *key, uint64_t now)
static int session_manager_update_udp_session(struct session_manager *mgr, struct session *sess, const struct packet *pkt, const struct tuple6 *key)
{
enum flow_direction dir = identify_direction_by_history(sess, key);
enum session_state curr_state = session_get_current_state(sess);
enum session_state next_state = session_transition_run(curr_state, UDP_DATA);
session_update(sess, next_state, pkt, key, dir);
session_update(mgr, sess, next_state, pkt, key, dir);
session_transition_log(sess, curr_state, next_state, UDP_DATA);
if (session_get_current_state(sess) == SESSION_STATE_DISCARD)
{
session_timer_update(mgr->sess_timer, sess, now + mgr->opts.udp_discard_timeout);
session_timer_update(mgr->sess_timer, sess, mgr->now_ms + mgr->opts.udp_discard_timeout);
}
else
{
session_timer_update(mgr->sess_timer, sess, now + mgr->opts.udp_data_timeout);
session_timer_update(mgr->sess_timer, sess, mgr->now_ms + mgr->opts.udp_data_timeout);
}
SESS_MGR_STAT_UPDATE(&mgr->stat, curr_state, next_state, udp);
@@ -877,7 +884,7 @@ static int session_manager_update_udp_session(struct session_manager *mgr, struc
* Public API
******************************************************************************/
struct session_manager *session_manager_new(struct session_manager_options *opts, uint64_t now)
struct session_manager *session_manager_new(struct session_manager_options *opts, uint64_t now_ms)
{
if (check_options(opts) == -1)
{
@@ -894,7 +901,7 @@ struct session_manager *session_manager_new(struct session_manager_options *opts
mgr->sess_pool = session_pool_new(mgr->opts.max_tcp_session_num + mgr->opts.max_udp_session_num);
mgr->tcp_sess_table = session_table_new();
mgr->udp_sess_table = session_table_new();
mgr->sess_timer = session_timer_new(now);
mgr->sess_timer = session_timer_new(now_ms);
if (mgr->sess_pool == NULL || mgr->tcp_sess_table == NULL || mgr->udp_sess_table == NULL || mgr->sess_timer == NULL)
{
goto error;
@@ -903,7 +910,7 @@ struct session_manager *session_manager_new(struct session_manager_options *opts
{
mgr->evicte_sess_filter = evicted_session_filter_new(mgr->opts.evicted_session_filter_capacity,
mgr->opts.evicted_session_filter_timeout,
mgr->opts.evicted_session_filter_error_rate, now);
mgr->opts.evicted_session_filter_error_rate, now_ms);
if (mgr->evicte_sess_filter == NULL)
{
goto error;
@@ -913,7 +920,7 @@ struct session_manager *session_manager_new(struct session_manager_options *opts
{
mgr->dup_pkt_filter = duplicated_packet_filter_new(mgr->opts.duplicated_packet_filter_capacity,
mgr->opts.duplicated_packet_filter_timeout,
mgr->opts.duplicated_packet_filter_error_rate, now);
mgr->opts.duplicated_packet_filter_error_rate, now_ms);
if (mgr->dup_pkt_filter == NULL)
{
goto error;
@@ -922,6 +929,7 @@ struct session_manager *session_manager_new(struct session_manager_options *opts
INIT_LIST_HEAD(&mgr->evicte_queue);
session_transition_init();
mgr->now_ms = now_ms;
return mgr;
@@ -969,16 +977,18 @@ void session_manager_free(struct session_manager *mgr)
}
}
void session_manager_record_duplicated_packet(struct session_manager *mgr, const struct packet *pkt, uint64_t now)
void session_manager_record_duplicated_packet(struct session_manager *mgr, const struct packet *pkt)
{
if (mgr->opts.duplicated_packet_filter_enable)
{
duplicated_packet_filter_add(mgr->dup_pkt_filter, pkt, now);
duplicated_packet_filter_add(mgr->dup_pkt_filter, pkt, mgr->now_ms);
}
}
struct session *session_manager_new_session(struct session_manager *mgr, const struct packet *pkt, uint64_t now)
struct session *session_manager_new_session(struct session_manager *mgr, const struct packet *pkt, uint64_t now_ms)
{
mgr->now_ms = now_ms;
struct tuple6 key;
if (packet_get_innermost_tuple6(pkt, &key))
{
@@ -987,21 +997,21 @@ struct session *session_manager_new_session(struct session_manager *mgr, const s
switch (key.ip_proto)
{
case IPPROTO_TCP:
if (tcp_overload_bypass(mgr, &key, now))
if (tcp_overload_bypass(mgr, &key))
{
return NULL;
}
return session_manager_new_tcp_session(mgr, pkt, &key, now);
return session_manager_new_tcp_session(mgr, pkt, &key);
case IPPROTO_UDP:
if (udp_overload_bypass(mgr, &key, now))
if (udp_overload_bypass(mgr, &key))
{
return NULL;
}
if (evicted_session_bypass(mgr, &key, now))
if (evicted_session_bypass(mgr, &key))
{
return NULL;
}
return session_manager_new_udp_session(mgr, pkt, &key, now);
return session_manager_new_udp_session(mgr, pkt, &key);
default:
return NULL;
}
@@ -1054,8 +1064,10 @@ void session_manager_free_session(struct session_manager *mgr, struct session *s
}
}
struct session *session_manager_lookup_session(struct session_manager *mgr, const struct packet *pkt, uint64_t now)
struct session *session_manager_lookup_session(struct session_manager *mgr, const struct packet *pkt, uint64_t now_ms)
{
mgr->now_ms = now_ms;
struct tuple6 key;
if (packet_get_innermost_tuple6(pkt, &key))
{
@@ -1066,37 +1078,41 @@ struct session *session_manager_lookup_session(struct session_manager *mgr, cons
case IPPROTO_UDP:
return session_table_find_tuple6(mgr->udp_sess_table, &key);
case IPPROTO_TCP:
return session_manager_lookup_tcp_session(mgr, pkt, &key, now);
return session_manager_lookup_tcp_session(mgr, pkt, &key);
default:
return NULL;
}
}
int session_manager_update_session(struct session_manager *mgr, struct session *sess, const struct packet *pkt, uint64_t now)
int session_manager_update_session(struct session_manager *mgr, struct session *sess, const struct packet *pkt, uint64_t now_ms)
{
mgr->now_ms = now_ms;
struct tuple6 key;
if (packet_get_innermost_tuple6(pkt, &key))
{
return -1;
}
if (duplicated_packet_bypass(mgr, sess, pkt, &key, now))
if (duplicated_packet_bypass(mgr, sess, pkt, &key))
{
return -1;
}
switch (session_get_type(sess))
{
case SESSION_TYPE_TCP:
return session_manager_update_tcp_session(mgr, sess, pkt, &key, now);
return session_manager_update_tcp_session(mgr, sess, pkt, &key);
case SESSION_TYPE_UDP:
return session_manager_update_udp_session(mgr, sess, pkt, &key, now);
return session_manager_update_udp_session(mgr, sess, pkt, &key);
default:
return -1;
}
}
struct session *session_manager_get_expired_session(struct session_manager *mgr, uint64_t now)
struct session *session_manager_get_expired_session(struct session_manager *mgr, uint64_t now_ms)
{
struct session *sess = session_timer_expire(mgr->sess_timer, now);
mgr->now_ms = now_ms;
struct session *sess = session_timer_expire(mgr->sess_timer, now_ms);
if (sess)
{
enum session_state curr_state = session_get_current_state(sess);
@@ -1132,10 +1148,10 @@ struct session *session_manager_get_expired_session(struct session_manager *mgr,
switch (session_get_type(sess))
{
case SESSION_TYPE_TCP:
session_timer_update(mgr->sess_timer, sess, now + mgr->opts.tcp_data_timeout);
session_timer_update(mgr->sess_timer, sess, now_ms + mgr->opts.tcp_data_timeout);
break;
case SESSION_TYPE_UDP:
session_timer_update(mgr->sess_timer, sess, now + mgr->opts.udp_data_timeout);
session_timer_update(mgr->sess_timer, sess, now_ms + mgr->opts.udp_data_timeout);
break;
default:
assert(0);
@@ -1174,7 +1190,6 @@ struct session_manager_stat *session_manager_stat(struct session_manager *mgr)
void session_set_discard(struct session *sess)
{
uint64_t now = stellar_get_monotonic_time_msec();
struct session_manager *mgr = sess->mgr;
enum session_type type = session_get_type(sess);
enum session_state curr_state = session_get_current_state(sess);
@@ -1185,11 +1200,11 @@ void session_set_discard(struct session *sess)
switch (type)
{
case SESSION_TYPE_TCP:
session_timer_update(mgr->sess_timer, sess, now + mgr->opts.tcp_discard_timeout);
session_timer_update(mgr->sess_timer, sess, mgr->now_ms + mgr->opts.tcp_discard_timeout);
SESS_MGR_STAT_UPDATE(&mgr->stat, curr_state, next_state, tcp);
break;
case SESSION_TYPE_UDP:
session_timer_update(mgr->sess_timer, sess, now + mgr->opts.udp_discard_timeout);
session_timer_update(mgr->sess_timer, sess, mgr->now_ms + mgr->opts.udp_discard_timeout);
SESS_MGR_STAT_UPDATE(&mgr->stat, curr_state, next_state, udp);
break;
default:

12
src/session/session_manager.h
View File

@@ -90,18 +90,18 @@ struct session_manager_stat
};
struct session_manager;
struct session_manager *session_manager_new(struct session_manager_options *opts, uint64_t now);
struct session_manager *session_manager_new(struct session_manager_options *opts, uint64_t now_ms);
void session_manager_free(struct session_manager *mgr);
void session_manager_record_duplicated_packet(struct session_manager *mgr, const struct packet *pkt, uint64_t now);
void session_manager_record_duplicated_packet(struct session_manager *mgr, const struct packet *pkt);
struct session *session_manager_new_session(struct session_manager *mgr, const struct packet *pkt, uint64_t now);
struct session *session_manager_new_session(struct session_manager *mgr, const struct packet *pkt, uint64_t now_ms);
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, uint64_t now);
int session_manager_update_session(struct session_manager *mgr, struct session *sess, const struct packet *pkt, uint64_t now);
struct session *session_manager_lookup_session(struct session_manager *mgr, const struct packet *pkt, uint64_t now_ms);
int session_manager_update_session(struct session_manager *mgr, struct session *sess, const struct packet *pkt, uint64_t now_ms);
// return session need free by session_manager_free_session()
struct session *session_manager_get_expired_session(struct session_manager *mgr, uint64_t now);
struct session *session_manager_get_expired_session(struct session_manager *mgr, uint64_t now_ms);
struct session *session_manager_get_evicted_session(struct session_manager *mgr);
// return 0: have already timeout session

8
src/session/test/gtest_case_tcp_fast_open.cpp
View File

@@ -1,9 +1,9 @@
#include <gtest/gtest.h>
#include "tuple.h"
#include "times.h"
#include "packet_def.h"
#include "packet_parse.h"
#include "id_generator.h"
#include "session_utils.h"
#include "session_manager.h"
#include "tcp_reassembly.h"
@@ -307,7 +307,6 @@ TEST(CASE, TCP_FAST_OPEN)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
stellar_update_time_cache();
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
@@ -421,6 +420,11 @@ TEST(CASE, TCP_FAST_OPEN)
int main(int argc, char **argv)
{
struct id_generator_options opt = {
.snowflake_worker_id_base = 1,
.snowflake_worker_id_offset = 2,
};
id_generator_init(&opt);
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}

13
src/session/test/gtest_state_tcp_active_to_closing.cpp
View File

@@ -2,11 +2,11 @@
#include <gtest/gtest.h>
#include "tuple.h"
#include "times.h"
#include "tcp_utils.h"
#include "packet_def.h"
#include "packet_parse.h"
#include "packet_layer.h"
#include "id_generator.h"
#include "session_utils.h"
#include "session_manager.h"
#include "test_packets.h"
@@ -92,7 +92,6 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_FIN_FIN)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
stellar_update_time_cache();
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
@@ -185,7 +184,6 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_RST)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
stellar_update_time_cache();
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
@@ -273,7 +271,6 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_RST)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
stellar_update_time_cache();
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
@@ -359,7 +356,6 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_DATA_TIMEOUT)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
stellar_update_time_cache();
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
@@ -409,7 +405,6 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_HALF_CLOSED_TIMEOUT)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
stellar_update_time_cache();
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
@@ -490,7 +485,6 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_HALF_CLOSED_TIMEOUT)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
stellar_update_time_cache();
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
@@ -560,6 +554,11 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_HALF_CLOSED_TIMEOUT)
int main(int argc, char **argv)
{
struct id_generator_options opt = {
.snowflake_worker_id_base = 1,
.snowflake_worker_id_offset = 2,
};
id_generator_init(&opt);
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}

15
src/session/test/gtest_state_tcp_init_to_opening.cpp
View File

@@ -2,11 +2,11 @@
#include <gtest/gtest.h>
#include "tuple.h"
#include "times.h"
#include "ip4_utils.h"
#include "packet_def.h"
#include "packet_parse.h"
#include "packet_layer.h"
#include "id_generator.h"
#include "session_utils.h"
#include "session_manager.h"
#include "test_packets.h"
@@ -63,7 +63,6 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
stellar_update_time_cache();
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
@@ -142,7 +141,6 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
stellar_update_time_cache();
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
@@ -221,7 +219,6 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
stellar_update_time_cache();
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
@@ -312,7 +309,6 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
stellar_update_time_cache();
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
@@ -417,7 +413,6 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
stellar_update_time_cache();
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
@@ -515,7 +510,6 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
stellar_update_time_cache();
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
@@ -612,7 +606,6 @@ TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
stellar_update_time_cache();
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
@@ -703,7 +696,6 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
stellar_update_time_cache();
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
@@ -783,6 +775,11 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC)
int main(int argc, char **argv)
{
struct id_generator_options opt = {
.snowflake_worker_id_base = 1,
.snowflake_worker_id_offset = 2,
};
id_generator_init(&opt);
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}

8
src/session/test/gtest_state_tcp_init_to_opening_to_active_to_closing_to_closed.cpp
View File

@@ -2,10 +2,10 @@
#include <gtest/gtest.h>
#include "tuple.h"
#include "times.h"
#include "packet_def.h"
#include "packet_parse.h"
#include "packet_layer.h"
#include "id_generator.h"
#include "session_utils.h"
#include "session_manager.h"
#include "test_packets.h"
@@ -58,7 +58,6 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
stellar_update_time_cache();
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
@@ -445,6 +444,11 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
int main(int argc, char **argv)
{
struct id_generator_options opt = {
.snowflake_worker_id_base = 1,
.snowflake_worker_id_offset = 2,
};
id_generator_init(&opt);
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}

9
src/session/test/gtest_state_tcp_opening_to_active.cpp
View File

@@ -2,10 +2,10 @@
#include <gtest/gtest.h>
#include "tuple.h"
#include "times.h"
#include "packet_def.h"
#include "packet_parse.h"
#include "packet_layer.h"
#include "id_generator.h"
#include "session_utils.h"
#include "session_manager.h"
#include "test_packets.h"
@@ -62,7 +62,6 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYN_C2S_DATA)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
stellar_update_time_cache();
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
@@ -153,7 +152,6 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
stellar_update_time_cache();
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
@@ -233,6 +231,11 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA)
int main(int argc, char **argv)
{
struct id_generator_options opt = {
.snowflake_worker_id_base = 1,
.snowflake_worker_id_offset = 2,
};
id_generator_init(&opt);
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}

15
src/session/test/gtest_state_tcp_opening_to_closing.cpp
View File

@@ -2,11 +2,11 @@
#include <gtest/gtest.h>
#include "tuple.h"
#include "times.h"
#include "tcp_utils.h"
#include "packet_def.h"
#include "packet_parse.h"
#include "packet_layer.h"
#include "id_generator.h"
#include "session_utils.h"
#include "session_manager.h"
#include "test_packets.h"
@@ -63,7 +63,6 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
stellar_update_time_cache();
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
@@ -165,7 +164,6 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_RST)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
stellar_update_time_cache();
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
@@ -262,7 +260,6 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_RST)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
stellar_update_time_cache();
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
@@ -358,7 +355,6 @@ TEST(TCP_OPENING_TO_CLOSING, BY_INIT_TIMEOUT)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
stellar_update_time_cache();
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
@@ -417,7 +413,6 @@ TEST(TCP_OPENING_TO_CLOSING, BY_HANDSHAKE_TIMEOUT)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
stellar_update_time_cache();
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
@@ -508,7 +503,6 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
stellar_update_time_cache();
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
@@ -611,7 +605,6 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_HALF_FIN)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
stellar_update_time_cache();
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
@@ -701,7 +694,6 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_HALF_FIN)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
stellar_update_time_cache();
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
@@ -780,6 +772,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_HALF_FIN)
int main(int argc, char **argv)
{
struct id_generator_options opt = {
.snowflake_worker_id_base = 1,
.snowflake_worker_id_offset = 2,
};
id_generator_init(&opt);
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}

8
src/session/test/gtest_state_udp_init_to_opening_to_active_to_closing.cpp
View File

@@ -2,10 +2,10 @@
#include <gtest/gtest.h>
#include "tuple.h"
#include "times.h"
#include "packet_def.h"
#include "packet_parse.h"
#include "packet_layer.h"
#include "id_generator.h"
#include "session_utils.h"
#include "session_manager.h"
#include "test_packets.h"
@@ -58,7 +58,6 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
stellar_update_time_cache();
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
@@ -157,6 +156,11 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST)
int main(int argc, char **argv)
{
struct id_generator_options opt = {
.snowflake_worker_id_base = 1,
.snowflake_worker_id_offset = 2,
};
id_generator_init(&opt);
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}

9
src/session/test/gtest_state_udp_init_to_opening_to_closing.cpp
View File

@@ -2,10 +2,10 @@
#include <gtest/gtest.h>
#include "tuple.h"
#include "times.h"
#include "packet_def.h"
#include "packet_parse.h"
#include "packet_layer.h"
#include "id_generator.h"
#include "session_utils.h"
#include "session_manager.h"
#include "test_packets.h"
@@ -63,7 +63,6 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_C2S)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
stellar_update_time_cache();
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
@@ -143,7 +142,6 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_S2C)
struct session_manager *mgr = NULL;
struct session_manager_stat *stat = NULL;
stellar_update_time_cache();
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
@@ -213,6 +211,11 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_S2C)
int main(int argc, char **argv)
{
struct id_generator_options opt = {
.snowflake_worker_id_base = 1,
.snowflake_worker_id_offset = 2,
};
id_generator_init(&opt);
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}

2
src/session/test/gtest_timeout_tcp_data.cpp
View File

@@ -1,7 +1,6 @@
#include <gtest/gtest.h>
#include "tuple.h"
#include "times.h"
#include "packet_def.h"
#include "packet_parse.h"
#include "packet_layer.h"
@@ -55,7 +54,6 @@ TEST(TIMEOUT, TCP_TIMEOUT_DATA)
struct session *sess = NULL;
struct session_manager *mgr = NULL;
stellar_update_time_cache();
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);

2
src/session/test/gtest_timeout_tcp_handshake.cpp
View File

@@ -1,7 +1,6 @@
#include <gtest/gtest.h>
#include "tuple.h"
#include "times.h"
#include "packet_def.h"
#include "packet_parse.h"
#include "packet_layer.h"
@@ -55,7 +54,6 @@ TEST(TIMEOUT, TCP_TIMEOUT_HANDSHAKE)
struct session *sess = NULL;
struct session_manager *mgr = NULL;
stellar_update_time_cache();
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);

2
src/session/test/gtest_timeout_tcp_init.cpp
View File

@@ -1,7 +1,6 @@
#include <gtest/gtest.h>
#include "tuple.h"
#include "times.h"
#include "packet_def.h"
#include "packet_parse.h"
#include "packet_layer.h"
@@ -55,7 +54,6 @@ TEST(TIMEOUT, TCP_TIMEOUT_INIT)
struct session *sess = NULL;
struct session_manager *mgr = NULL;
stellar_update_time_cache();
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);

3
src/session/test/gtest_timeout_udp_data.cpp
View File

@@ -1,7 +1,6 @@
#include <gtest/gtest.h>
#include "tuple.h"
#include "times.h"
#include "packet_def.h"
#include "packet_parse.h"
#include "packet_layer.h"
@@ -55,7 +54,6 @@ TEST(TIMEOUT, UDP_TIMEOUT_DATA1)
struct session *sess = NULL;
struct session_manager *mgr = NULL;
stellar_update_time_cache();
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);
@@ -92,7 +90,6 @@ TEST(TIMEOUT, UDP_TIMEOUT_DATA2)
struct session *sess = NULL;
struct session_manager *mgr = NULL;
stellar_update_time_cache();
mgr = session_manager_new(&opts, 1);
EXPECT_TRUE(mgr != NULL);

54
src/stellar/stellar_core.cpp
View File

@@ -111,13 +111,13 @@ static inline void free_evicted_sessions(struct session_manager *sess_mgr, uint6
}
}
static inline void free_expired_sessions(struct session_manager *sess_mgr, uint64_t max_free, uint64_t now)
static inline void free_expired_sessions(struct session_manager *sess_mgr, uint64_t max_free, uint64_t now_ms)
{
void *plugin_ctx = NULL;
struct session *sess = NULL;
for (uint64_t i = 0; i < max_free; i++)
{
sess = session_manager_get_expired_session(sess_mgr, now);
sess = session_manager_get_expired_session(sess_mgr, now_ms);
if (sess)
{
plugin_ctx = session_get_user_data(sess);
@@ -131,7 +131,7 @@ static inline void free_expired_sessions(struct session_manager *sess_mgr, uint6
}
}
static inline void merge_thread_stat(struct stellar_thread *thread, uint64_t now)
static inline void merge_thread_stat(struct stellar_thread *thread)
{
struct stellar_runtime *runtime = thread->runtime;
struct thread_stat thr_stat = {
@@ -145,7 +145,7 @@ static inline void merge_thread_stat(struct stellar_thread *thread, uint64_t now
static void *work_thread(void *arg)
{
int nr_recv;
uint64_t now = 0;
uint64_t now_ms = 0;
char thd_name[16] = {0};
void *plugin_ctx = NULL;
struct packet *pkt = NULL;
@@ -176,7 +176,15 @@ static void *work_thread(void *arg)
while (ATOMIC_READ(&need_exit) == 0)
{
now = stellar_get_monotonic_time_msec();
/*
* We use the system's real time instead of monotonic time for the following reasons:
* -> Session creation/closure times require real time (e.g., for logging session activities).
* -> Session ID generation relies on real time (e.g., for reverse calculating session creation time from the session ID).
*
* Note: Modifying the system time will affect the timing wheel, impacting session expiration, IP reassembly expiration, and TCP reassembly expiration.
* Suggestion: After modifying the system time, restart the service to ensure consistent timing.
*/
now_ms = stellar_get_real_time_msec();
memset(packets, 0, sizeof(packets));
nr_recv = packet_io_ingress(packet_io, thr_idx, packets, RX_BURST_MAX);
if (nr_recv == 0)
@@ -193,7 +201,7 @@ static void *work_thread(void *arg)
plugin_manager_on_packet(plug_mgr, pkt);
if (packet_is_fragment(pkt))
{
defraged_pkt = ip_reassembly_packet(ip_reass, pkt, now);
defraged_pkt = ip_reassembly_packet(ip_reass, pkt, now_ms);
if (defraged_pkt == NULL)
{
goto fast_path;
@@ -205,10 +213,10 @@ static void *work_thread(void *arg)
}
}
sess = session_manager_lookup_session(sess_mgr, pkt, now);
sess = session_manager_lookup_session(sess_mgr, pkt, now_ms);
if (sess == NULL)
{
sess = session_manager_new_session(sess_mgr, pkt, now);
sess = session_manager_new_session(sess_mgr, pkt, now_ms);
if (sess == NULL)
{
goto fast_path;
@@ -218,7 +226,7 @@ static void *work_thread(void *arg)
}
else
{
if (session_manager_update_session(sess_mgr, sess, pkt, now) == -1)
if (session_manager_update_session(sess_mgr, sess, pkt, now_ms) == -1)
{
goto fast_path;
}
@@ -269,14 +277,14 @@ static void *work_thread(void *arg)
free_evicted_sessions(sess_mgr, nr_recv);
// per 5 ms, atmost free 8 expired session
if (now - thread->timing_wheel_last_update_ts > 5)
if (now_ms - thread->timing_wheel_last_update_ts > 5)
{
free_expired_sessions(sess_mgr, 8, now);
thread->timing_wheel_last_update_ts = now;
free_expired_sessions(sess_mgr, 8, now_ms);
thread->timing_wheel_last_update_ts = now_ms;
}
merge_thread_stat(thread, now);
ip_reassembly_expire(ip_reass, now);
merge_thread_stat(thread);
ip_reassembly_expire(ip_reass, now_ms);
plugin_manager_on_polling(runtime->plug_mgr);
if (nr_recv == 0)
@@ -345,14 +353,14 @@ static int all_session_have_freed(struct stellar_runtime *runtime, struct stella
static int stellar_thread_init(struct stellar_runtime *runtime, struct stellar_config *config)
{
uint64_t now = stellar_get_monotonic_time_msec();
uint64_t now_ms = stellar_get_real_time_msec();
for (uint16_t i = 0; i < config->pkt_io_opts.nr_threads; i++)
{
struct stellar_thread *thread = &runtime->threads[i];
thread->idx = i;
thread->is_runing = 0;
thread->timing_wheel_last_update_ts = now;
thread->sess_mgr = session_manager_new(&config->sess_mgr_opts, now);
thread->timing_wheel_last_update_ts = now_ms;
thread->sess_mgr = session_manager_new(&config->sess_mgr_opts, now_ms);
if (thread->sess_mgr == NULL)
{
STELLAR_LOG_ERROR("unable to create session manager");
@@ -418,8 +426,6 @@ int stellar_run(int argc, char **argv)
struct stellar_runtime *runtime = &st.runtime;
struct stellar_config *config = &st.config;
stellar_update_time_cache();
signal(SIGINT, signal_handler);
signal(SIGQUIT, signal_handler);
signal(SIGTERM, signal_handler);
@@ -480,13 +486,12 @@ int stellar_run(int argc, char **argv)
goto error_out;
}
runtime->stat_last_output_ts = stellar_get_monotonic_time_msec();
runtime->stat_last_output_ts = stellar_get_real_time_msec();
while (!ATOMIC_READ(&need_exit))
{
stellar_update_time_cache();
if (stellar_get_monotonic_time_msec() - runtime->stat_last_output_ts > 2000)
if (stellar_get_real_time_msec() - runtime->stat_last_output_ts > 2000)
{
runtime->stat_last_output_ts = stellar_get_monotonic_time_msec();
runtime->stat_last_output_ts = stellar_get_real_time_msec();
stellar_stat_output(runtime->stat);
}
usleep(1000); // 1ms
@@ -545,11 +550,10 @@ uint16_t stellar_get_current_thread_index()
// only send user crafted packet, can't send packet which come from network
void stellar_send_crafted_packet(struct stellar *st, struct packet *pkt)
{
uint64_t time_ms = stellar_get_monotonic_time_msec();
uint16_t thr_idx = stellar_get_current_thread_index();
struct packet_io *packet_io = stellar_get_packet_io(st);
struct session_manager *sess_mgr = stellar_get_session_manager(st);
session_manager_record_duplicated_packet(sess_mgr, pkt, time_ms);
session_manager_record_duplicated_packet(sess_mgr, pkt);
if (packet_get_origin_ctx(pkt))
{

5
src/times/test/gtest_times.cpp
View File

@@ -9,12 +9,11 @@ TEST(TIMES, TEST)
uint64_t curr_sec = 0;
uint64_t curr_msec = 0;
stellar_update_time_cache();
last_sec = stellar_get_monotonic_time_sec();
last_msec = stellar_get_monotonic_time_msec();
usleep(1000); // 1ms
stellar_update_time_cache();
curr_sec = stellar_get_monotonic_time_sec();
curr_msec = stellar_get_monotonic_time_msec();
printf("After usleep(1000)\n");
@@ -24,7 +23,7 @@ TEST(TIMES, TEST)
EXPECT_TRUE(curr_msec - last_msec >= 1);
usleep(1000 * 1000); // 1s
stellar_update_time_cache();
last_sec = curr_sec;
last_msec = curr_msec;
curr_sec = stellar_get_monotonic_time_sec();

79
src/times/times.cpp
View File

@@ -1,6 +1,5 @@
#include <time.h>
#include "macro.h"
#include "times.h"
// 1 s = 1000 ms
@@ -17,69 +16,49 @@
* };
*/
struct
{
struct timespec real_time_spec;
uint64_t real_time_msec;
uint64_t real_time_sec;
/*
* CLOCK_MONOTONIC
*
* On Linux, that point corresponds to the number of sec‐
* onds that the system has been running since it was booted.
*
* The CLOCK_MONOTONIC clock is not affected by discontinuous
* jumps in the system time (e.g., if the system administrator
* manually changes the clock), but is affected by the incremen‐
* tal adjustments performed by adjtime(3) and NTP.
*/
struct timespec monotonic_time_spec;
uint64_t monotonic_time_msec;
uint64_t monotonic_time_sec;
} global_time;
void stellar_update_time_cache()
{
uint64_t time_msec;
uint64_t time_sec;
/*
* CLOCK_MONOTONIC
*
* On Linux, that point corresponds to the number of sec‐
* onds that the system has been running since it was booted.
*
* The CLOCK_MONOTONIC clock is not affected by discontinuous
* jumps in the system time (e.g., if the system administrator
* manually changes the clock), but is affected by the incremen‐
* tal adjustments performed by adjtime(3) and NTP.
*/
clock_gettime(CLOCK_MONOTONIC, &global_time.monotonic_time_spec);
time_msec = global_time.monotonic_time_spec.tv_sec * 1000 +
global_time.monotonic_time_spec.tv_nsec / 1000000;
time_sec = global_time.monotonic_time_spec.tv_sec +
global_time.monotonic_time_spec.tv_nsec / 1000000000;
ATOMIC_SET(&global_time.monotonic_time_msec, time_msec);
ATOMIC_SET(&global_time.monotonic_time_sec, time_sec);
clock_gettime(CLOCK_REALTIME, &global_time.real_time_spec);
time_msec = global_time.real_time_spec.tv_sec * 1000 +
global_time.real_time_spec.tv_nsec / 1000000;
time_sec = global_time.real_time_spec.tv_sec +
global_time.real_time_spec.tv_nsec / 1000000000;
ATOMIC_SET(&global_time.real_time_msec, time_msec);
ATOMIC_SET(&global_time.real_time_sec, time_sec);
}
#define TIMESPEC_TO_MSEC(ts) ((ts).tv_sec * 1000 + (ts).tv_nsec / 1000000)
#define TIMESPEC_TO_SEC(ts) ((ts).tv_sec + (ts).tv_nsec / 1000000000)
uint64_t stellar_get_monotonic_time_sec()
{
return ATOMIC_READ(&global_time.monotonic_time_sec);
struct timespec now;
clock_gettime(CLOCK_MONOTONIC, &now);
return TIMESPEC_TO_SEC(now);
}
uint64_t stellar_get_monotonic_time_msec()
{
return ATOMIC_READ(&global_time.monotonic_time_msec);
struct timespec now;
clock_gettime(CLOCK_MONOTONIC, &now);
return TIMESPEC_TO_MSEC(now);
}
uint64_t stellar_get_real_time_sec()
{
return ATOMIC_READ(&global_time.real_time_sec);
struct timespec now;
clock_gettime(CLOCK_REALTIME, &now);
return TIMESPEC_TO_SEC(now);
}
uint64_t stellar_get_real_time_msec()
{
return ATOMIC_READ(&global_time.real_time_msec);
struct timespec now;
clock_gettime(CLOCK_REALTIME, &now);
return TIMESPEC_TO_MSEC(now);
}

2
src/times/times.h
View File

@@ -7,8 +7,6 @@ extern "C"
#include <stdint.h>
void stellar_update_time_cache();
uint64_t stellar_get_monotonic_time_sec();
uint64_t stellar_get_monotonic_time_msec();