gfwleak/tango-tsg-service-chaining-engine
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

perf: 优化session_ctx减少内存占用; 优化global metrics的结构

Browse Source
This commit is contained in:
luwenpeng
2023-11-24 15:17:18 +08:00
parent bda50d79af
commit eedd18183e
12 changed files with 331 additions and 439 deletions
Download Patch File Download Diff File Expand all files Collapse all files

43
common/include/utils.h
View File

@@ -52,49 +52,6 @@ int mutable_array_count_elem(struct mutable_array *array);
int mutable_array_exist_elem(struct mutable_array *array, uint64_t elem);
int mutable_array_index_elem(struct mutable_array *array, int index);
/******************************************************************************
* sids
******************************************************************************/
typedef uint16_t sid_t;
#define MR_SID_LIST_MAXLEN 8
struct sids
{
int num;
sid_t elems[MR_SID_LIST_MAXLEN];
};
void sids_copy(struct sids *dst, struct sids *src);
/******************************************************************************
* route_ctx
******************************************************************************/
struct route_ctx
{
char data[64];
int len;
};
void route_ctx_copy(struct route_ctx *dst, struct route_ctx *src);
/******************************************************************************
* throughput_metrics
******************************************************************************/
struct throughput_metrics
{
uint64_t n_pkts;
uint64_t n_bytes;
};
static inline void throughput_metrics_inc(struct throughput_metrics *iterm, uint64_t n_pkts, uint64_t n_bytes)
{
iterm->n_bytes += n_bytes;
iterm->n_pkts += n_pkts;
}
/******************************************************************************
* device
******************************************************************************/

23
common/src/utils.cpp
View File

@@ -98,29 +98,6 @@ int mutable_array_index_elem(struct mutable_array *array, int index)
return array->elems[index];
}
/******************************************************************************
* sids
******************************************************************************/
void sids_copy(struct sids *dst, struct sids *src)
{
if (dst && src)
{
dst->num = src->num;
memcpy(dst->elems, src->elems, sizeof(dst->elems[0]) * dst->num);
}
}
/******************************************************************************
* route_ctx
******************************************************************************/
void route_ctx_copy(struct route_ctx *dst, struct route_ctx *src)
{
memcpy(dst->data, src->data, src->len);
dst->len = src->len;
}
/******************************************************************************
* device
******************************************************************************/

28
common/test/gtest_utils.cpp
View File

@@ -36,34 +36,6 @@ TEST(UTILS, FIXED_NUM_ARRAY)
EXPECT_TRUE(mutable_array_count_elem(&array) == 0);
}
TEST(UTILS, SIDS)
{
struct sids src;
struct sids dst;
for (int i = 0; i < MR_SID_LIST_MAXLEN; i++)
{
src.elems[i] = i;
}
src.num = MR_SID_LIST_MAXLEN;
sids_copy(&dst, &src);
EXPECT_TRUE(dst.num == src.num);
for (int i = 0; i < MR_SID_LIST_MAXLEN; i++)
{
EXPECT_TRUE(dst.elems[i] == i);
}
}
TEST(UTILS, THROUGHPUT_METRICS)
{
struct throughput_metrics iterm = {.n_pkts = 0, .n_bytes = 0};
throughput_metrics_inc(&iterm, 1, 2);
EXPECT_TRUE(iterm.n_pkts == 1);
EXPECT_TRUE(iterm.n_bytes == 2);
}
TEST(UTILS, DEVICE)
{
const char *dev_name = "lo";

108
platform/include/global_metrics.h
View File

@@ -9,20 +9,29 @@ extern "C"
#include "utils.h"
#include <MESA/field_stat2.h>
struct metrics_config
struct throughput_metrics
{
char output_file[256];
char statsd_server[32];
int statsd_port;
int statsd_format;
int statsd_cycle;
int prometheus_listen_port;
char prometheus_listen_url[256];
uint64_t n_pkts;
uint64_t n_bytes;
};
struct device_metrics
#define THROUGHPUT_METRICS_INC(iterm, _n_pkts, _n_bytes) \
do \
{ \
(iterm)->n_pkts += (_n_pkts); \
(iterm)->n_bytes += (_n_bytes); \
} while (0)
struct thread_metrics
{
// keepalived packet metrics
struct throughput_metrics downlink_rx; // 累计值
struct throughput_metrics downlink_tx; // 累计值
struct throughput_metrics uplink_rx; // 累计值
struct throughput_metrics uplink_tx_drop; // 累计值
// device packet metrics
struct throughput_metrics nf_rx; // 累计值
struct throughput_metrics nf_tx; // 累计值
@@ -33,11 +42,8 @@ struct device_metrics
struct throughput_metrics endpoint_vlan_rx; // 累计值
struct throughput_metrics endpoint_vlan_tx; // 累计值
struct throughput_metrics endpoint_vlan_drop; // 累计值
};
// data_pkt_metrics 不包含 vxlan frame 所占的字节
struct data_pkt_metrics
{
// data packet metrics 不包含 vxlan frame / vlan header 所占的字节
struct throughput_metrics mirr_bypass; // 累计值
struct throughput_metrics mirr_block; // 累计值
struct throughput_metrics mirr_rx_drop; // 累计值
@@ -51,61 +57,41 @@ struct data_pkt_metrics
struct throughput_metrics miss_sess; // 累计值
struct throughput_metrics error_bypass; // 累计值
struct throughput_metrics error_block; // 累计值
// control packet metrics
struct throughput_metrics ctrl_rx; // 累计值
struct throughput_metrics ctrl_tx; // 累计值
uint64_t ctrl_opening; // 累计值
uint64_t ctrl_active; // 累计值
uint64_t ctrl_closing; // 累计值
uint64_t ctrl_resetall; // 累计值
uint64_t ctrl_error; // 累计值
// sf status metrics
uint64_t sf_active; // 累计值
uint64_t sf_inactive; // 累计值
// sf session metrics
uint64_t session_num; // 当前值
uint64_t session_log; // 累计值
};
struct ctrl_pkt_metrics
struct metrics_config
{
struct throughput_metrics rx; // 累计值
struct throughput_metrics tx; // 累计值
char output_file[256];
char statsd_server[32];
int statsd_port;
int statsd_format;
int statsd_cycle;
uint64_t opening; // 累计值
uint64_t active; // 累计值
uint64_t closing; // 累计值
uint64_t resetall; // 累计值
uint64_t error; // 累计值
};
struct keepalived_pkt_metrics
{
struct throughput_metrics downlink_rx; // 累计值
struct throughput_metrics downlink_tx; // 累计值
struct throughput_metrics uplink_rx; // 累计值
struct throughput_metrics uplink_tx_drop; // 累计值
};
struct sf_status_metrics
{
uint64_t active; // 累计值
uint64_t inactive; // 累计值
};
struct sf_session_metrics
{
uint64_t num; // 当前值
uint64_t log; // 累计值
};
struct thread_metrics
{
struct device_metrics device;
struct data_pkt_metrics data_pkt;
struct ctrl_pkt_metrics ctrl_pkt;
struct keepalived_pkt_metrics kee_pkt;
struct sf_status_metrics sf_status;
struct sf_session_metrics sf_session;
int prometheus_listen_port;
char prometheus_listen_url[256];
};
struct global_metrics
{
struct device_metrics device;
struct data_pkt_metrics data_pkt;
struct ctrl_pkt_metrics ctrl_pkt;
struct keepalived_pkt_metrics kee_pkt;
struct sf_status_metrics sf_status;
struct sf_session_metrics sf_session;
struct thread_metrics sum;
struct metrics_config config;
screen_stat_handle_t fs_handle;

29
platform/include/packet_io.h
View File

@@ -12,6 +12,35 @@ extern "C"
* Packet IO API for gtest
******************************************************************************/
struct sids
{
sid_t elems[MR_SID_LIST_MAXLEN];
int num;
};
struct route_ctx
{
char data[64];
int len;
};
struct metadata
{
uint64_t session_id;
uint32_t rehash_index;
char *raw_data; // refer to current packet data
int raw_len;
uint16_t l7offset;
int direction; // 1: E2I; 0: I2E
int is_ctrl_pkt;
int is_decrypted;
struct sids sids;
struct route_ctx route_ctx;
};
int mbuff_get_metadata(marsio_buff_t *rx_buff, struct metadata *meta);
int mbuff_set_metadata(marsio_buff_t *tx_buff, struct metadata *meta);
void vlan_encapsulate(marsio_buff_t *mbuff, int vlan_id, int replace_orig_vlan_header);

1
platform/include/policy.h
View File

@@ -8,6 +8,7 @@ extern "C"
#include "utils.h"
#include "packet.h"
#include "global_metrics.h"
#include <linux/if_ether.h>
enum traffic_type

49
platform/include/sce.h
View File

@@ -39,31 +39,6 @@ struct thread_ctx
uint64_t tx_packets_ipid;
};
/******************************************************************************
* Struct Metadata
******************************************************************************/
struct metadata
{
int write_ref;
uint64_t session_id;
uint32_t rehash_index;
char *raw_data; // refer to current packet data
int raw_len;
uint16_t l7offset;
int direction; // 1: E2I; 0: I2E
int is_ctrl_pkt;
int is_decrypted;
struct sids sids;
struct route_ctx route_ctx;
};
int metadata_isempty(struct metadata *meta);
void metadata_copy(struct metadata *dst, struct metadata *src);
char *memdup(const char *src, int len);
/******************************************************************************
@@ -74,22 +49,32 @@ struct session_ctx
{
uint64_t session_id;
char *session_addr;
uint32_t rehash_index;
// dup from received control packet, for sending control packet
char *ctrl_packet_header_data;
uint16_t ctrl_packet_header_len;
char *ctrl_pkt_hdr_ptr;
uint16_t ctrl_pkt_hdr_len;
uint16_t vxlan_src_port;
struct four_tuple inner_tuple4;
struct mutable_array rule_ids;
struct metadata decrypted_meta_i2e;
struct metadata decrypted_meta_e2i;
struct metadata raw_meta_i2e;
struct metadata raw_meta_e2i;
struct metadata ctrl_meta;
// route ctx
struct route_ctx decrypted_e2i_route_ctx;
struct route_ctx decrypted_i2e_route_ctx;
struct route_ctx raw_e2i_route_ctx;
struct route_ctx raw_i2e_route_ctx;
struct route_ctx ctrl_route_ctx;
// sids
struct sids decrypted_e2i_sids;
struct sids decrypted_i2e_sids;
struct sids raw_e2i_sids;
struct sids raw_i2e_sids;
struct sids ctrl_sids;
// chaining
struct selected_chaining *chaining_raw;
struct selected_chaining *chaining_decrypted;

241
platform/src/global_metrics.cpp
View File

@@ -319,172 +319,173 @@ void global_metrics_update(struct global_metrics *global_metrics, struct thread_
void global_metrics_dump(struct global_metrics *global_metrics)
{
struct thread_metrics *sum = &global_metrics->sum;
for (int i = 0; i < global_metrics->thread_num; i++)
{
if (ATOMIC_READ(&(global_metrics->thread_metrics_flag[i])) == THREAD_METRICS_CACHE_IS_BUSY)
{
struct thread_metrics *thread_metrics = &global_metrics->thread_metrics_cache[i];
struct thread_metrics *thread = &global_metrics->thread_metrics_cache[i];
global_metrics->device.nf_rx.n_pkts += thread_metrics->device.nf_rx.n_pkts;
global_metrics->device.nf_rx.n_bytes += thread_metrics->device.nf_rx.n_bytes;
global_metrics->device.nf_tx.n_pkts += thread_metrics->device.nf_tx.n_pkts;
global_metrics->device.nf_tx.n_bytes += thread_metrics->device.nf_tx.n_bytes;
sum->nf_rx.n_pkts += thread->nf_rx.n_pkts;
sum->nf_rx.n_bytes += thread->nf_rx.n_bytes;
sum->nf_tx.n_pkts += thread->nf_tx.n_pkts;
sum->nf_tx.n_bytes += thread->nf_tx.n_bytes;
global_metrics->device.endpoint_vxlan_rx.n_pkts += thread_metrics->device.endpoint_vxlan_rx.n_pkts;
global_metrics->device.endpoint_vxlan_rx.n_bytes += thread_metrics->device.endpoint_vxlan_rx.n_bytes;
global_metrics->device.endpoint_vxlan_tx.n_pkts += thread_metrics->device.endpoint_vxlan_tx.n_pkts;
global_metrics->device.endpoint_vxlan_tx.n_bytes += thread_metrics->device.endpoint_vxlan_tx.n_bytes;
global_metrics->device.endpoint_vxlan_drop.n_pkts += thread_metrics->device.endpoint_vxlan_drop.n_pkts;
global_metrics->device.endpoint_vxlan_drop.n_bytes += thread_metrics->device.endpoint_vxlan_drop.n_bytes;
sum->endpoint_vxlan_rx.n_pkts += thread->endpoint_vxlan_rx.n_pkts;
sum->endpoint_vxlan_rx.n_bytes += thread->endpoint_vxlan_rx.n_bytes;
sum->endpoint_vxlan_tx.n_pkts += thread->endpoint_vxlan_tx.n_pkts;
sum->endpoint_vxlan_tx.n_bytes += thread->endpoint_vxlan_tx.n_bytes;
sum->endpoint_vxlan_drop.n_pkts += thread->endpoint_vxlan_drop.n_pkts;
sum->endpoint_vxlan_drop.n_bytes += thread->endpoint_vxlan_drop.n_bytes;
global_metrics->device.endpoint_vlan_rx.n_pkts += thread_metrics->device.endpoint_vlan_rx.n_pkts;
global_metrics->device.endpoint_vlan_rx.n_bytes += thread_metrics->device.endpoint_vlan_rx.n_bytes;
global_metrics->device.endpoint_vlan_tx.n_pkts += thread_metrics->device.endpoint_vlan_tx.n_pkts;
global_metrics->device.endpoint_vlan_tx.n_bytes += thread_metrics->device.endpoint_vlan_tx.n_bytes;
global_metrics->device.endpoint_vlan_drop.n_pkts += thread_metrics->device.endpoint_vlan_drop.n_pkts;
global_metrics->device.endpoint_vlan_drop.n_bytes += thread_metrics->device.endpoint_vlan_drop.n_bytes;
sum->endpoint_vlan_rx.n_pkts += thread->endpoint_vlan_rx.n_pkts;
sum->endpoint_vlan_rx.n_bytes += thread->endpoint_vlan_rx.n_bytes;
sum->endpoint_vlan_tx.n_pkts += thread->endpoint_vlan_tx.n_pkts;
sum->endpoint_vlan_tx.n_bytes += thread->endpoint_vlan_tx.n_bytes;
sum->endpoint_vlan_drop.n_pkts += thread->endpoint_vlan_drop.n_pkts;
sum->endpoint_vlan_drop.n_bytes += thread->endpoint_vlan_drop.n_bytes;
global_metrics->data_pkt.mirr_bypass.n_pkts += thread_metrics->data_pkt.mirr_bypass.n_pkts;
global_metrics->data_pkt.mirr_bypass.n_bytes += thread_metrics->data_pkt.mirr_bypass.n_bytes;
global_metrics->data_pkt.mirr_block.n_pkts += thread_metrics->data_pkt.mirr_block.n_pkts;
global_metrics->data_pkt.mirr_block.n_bytes += thread_metrics->data_pkt.mirr_block.n_bytes;
global_metrics->data_pkt.mirr_rx_drop.n_pkts += thread_metrics->data_pkt.mirr_rx_drop.n_pkts;
global_metrics->data_pkt.mirr_rx_drop.n_bytes += thread_metrics->data_pkt.mirr_rx_drop.n_bytes;
global_metrics->data_pkt.mirr_tx.n_pkts += thread_metrics->data_pkt.mirr_tx.n_pkts;
global_metrics->data_pkt.mirr_tx.n_bytes += thread_metrics->data_pkt.mirr_tx.n_bytes;
global_metrics->data_pkt.stee_bypass.n_pkts += thread_metrics->data_pkt.stee_bypass.n_pkts;
global_metrics->data_pkt.stee_bypass.n_bytes += thread_metrics->data_pkt.stee_bypass.n_bytes;
global_metrics->data_pkt.stee_block.n_pkts += thread_metrics->data_pkt.stee_block.n_pkts;
global_metrics->data_pkt.stee_block.n_bytes += thread_metrics->data_pkt.stee_block.n_bytes;
global_metrics->data_pkt.stee_rx.n_pkts += thread_metrics->data_pkt.stee_rx.n_pkts;
global_metrics->data_pkt.stee_rx.n_bytes += thread_metrics->data_pkt.stee_rx.n_bytes;
global_metrics->data_pkt.stee_tx.n_pkts += thread_metrics->data_pkt.stee_tx.n_pkts;
global_metrics->data_pkt.stee_tx.n_bytes += thread_metrics->data_pkt.stee_tx.n_bytes;
global_metrics->data_pkt.miss_sess.n_pkts += thread_metrics->data_pkt.miss_sess.n_pkts;
global_metrics->data_pkt.miss_sess.n_bytes += thread_metrics->data_pkt.miss_sess.n_bytes;
global_metrics->data_pkt.error_bypass.n_pkts += thread_metrics->data_pkt.error_bypass.n_pkts;
global_metrics->data_pkt.error_bypass.n_bytes += thread_metrics->data_pkt.error_bypass.n_bytes;
global_metrics->data_pkt.error_block.n_pkts += thread_metrics->data_pkt.error_block.n_pkts;
global_metrics->data_pkt.error_block.n_bytes += thread_metrics->data_pkt.error_block.n_bytes;
global_metrics->ctrl_pkt.rx.n_pkts += thread_metrics->ctrl_pkt.rx.n_pkts;
global_metrics->ctrl_pkt.rx.n_bytes += thread_metrics->ctrl_pkt.rx.n_bytes;
global_metrics->ctrl_pkt.tx.n_pkts += thread_metrics->ctrl_pkt.tx.n_pkts;
global_metrics->ctrl_pkt.tx.n_bytes += thread_metrics->ctrl_pkt.tx.n_bytes;
global_metrics->ctrl_pkt.opening += thread_metrics->ctrl_pkt.opening;
global_metrics->ctrl_pkt.active += thread_metrics->ctrl_pkt.active;
global_metrics->ctrl_pkt.closing += thread_metrics->ctrl_pkt.closing;
global_metrics->ctrl_pkt.resetall += thread_metrics->ctrl_pkt.resetall;
global_metrics->ctrl_pkt.error += thread_metrics->ctrl_pkt.error;
global_metrics->kee_pkt.downlink_rx.n_pkts += thread_metrics->kee_pkt.downlink_rx.n_pkts;
global_metrics->kee_pkt.downlink_rx.n_bytes += thread_metrics->kee_pkt.downlink_rx.n_bytes;
global_metrics->kee_pkt.downlink_tx.n_pkts += thread_metrics->kee_pkt.downlink_tx.n_pkts;
global_metrics->kee_pkt.downlink_tx.n_bytes += thread_metrics->kee_pkt.downlink_tx.n_bytes;
global_metrics->kee_pkt.uplink_rx.n_pkts += thread_metrics->kee_pkt.uplink_rx.n_pkts;
global_metrics->kee_pkt.uplink_rx.n_bytes += thread_metrics->kee_pkt.uplink_rx.n_bytes;
global_metrics->kee_pkt.uplink_tx_drop.n_pkts += thread_metrics->kee_pkt.uplink_tx_drop.n_pkts;
global_metrics->kee_pkt.uplink_tx_drop.n_bytes += thread_metrics->kee_pkt.uplink_tx_drop.n_bytes;
global_metrics->sf_status.active += thread_metrics->sf_status.active;
global_metrics->sf_status.inactive += thread_metrics->sf_status.inactive;
global_metrics->sf_session.num += thread_metrics->sf_session.num;
global_metrics->sf_session.log += thread_metrics->sf_session.log;
sum->mirr_bypass.n_pkts += thread->mirr_bypass.n_pkts;
sum->mirr_bypass.n_bytes += thread->mirr_bypass.n_bytes;
sum->mirr_block.n_pkts += thread->mirr_block.n_pkts;
sum->mirr_block.n_bytes += thread->mirr_block.n_bytes;
sum->mirr_rx_drop.n_pkts += thread->mirr_rx_drop.n_pkts;
sum->mirr_rx_drop.n_bytes += thread->mirr_rx_drop.n_bytes;
sum->mirr_tx.n_pkts += thread->mirr_tx.n_pkts;
sum->mirr_tx.n_bytes += thread->mirr_tx.n_bytes;
sum->stee_bypass.n_pkts += thread->stee_bypass.n_pkts;
sum->stee_bypass.n_bytes += thread->stee_bypass.n_bytes;
sum->stee_block.n_pkts += thread->stee_block.n_pkts;
sum->stee_block.n_bytes += thread->stee_block.n_bytes;
sum->stee_rx.n_pkts += thread->stee_rx.n_pkts;
sum->stee_rx.n_bytes += thread->stee_rx.n_bytes;
sum->stee_tx.n_pkts += thread->stee_tx.n_pkts;
sum->stee_tx.n_bytes += thread->stee_tx.n_bytes;
sum->miss_sess.n_pkts += thread->miss_sess.n_pkts;
sum->miss_sess.n_bytes += thread->miss_sess.n_bytes;
sum->error_bypass.n_pkts += thread->error_bypass.n_pkts;
sum->error_bypass.n_bytes += thread->error_bypass.n_bytes;
sum->error_block.n_pkts += thread->error_block.n_pkts;
sum->error_block.n_bytes += thread->error_block.n_bytes;
sum->ctrl_rx.n_pkts += thread->ctrl_rx.n_pkts;
sum->ctrl_rx.n_bytes += thread->ctrl_rx.n_bytes;
sum->ctrl_tx.n_pkts += thread->ctrl_tx.n_pkts;
sum->ctrl_tx.n_bytes += thread->ctrl_tx.n_bytes;
sum->ctrl_opening += thread->ctrl_opening;
sum->ctrl_active += thread->ctrl_active;
sum->ctrl_closing += thread->ctrl_closing;
sum->ctrl_resetall += thread->ctrl_resetall;
sum->ctrl_error += thread->ctrl_error;
sum->downlink_rx.n_pkts += thread->downlink_rx.n_pkts;
sum->downlink_rx.n_bytes += thread->downlink_rx.n_bytes;
sum->downlink_tx.n_pkts += thread->downlink_tx.n_pkts;
sum->downlink_tx.n_bytes += thread->downlink_tx.n_bytes;
sum->uplink_rx.n_pkts += thread->uplink_rx.n_pkts;
sum->uplink_rx.n_bytes += thread->uplink_rx.n_bytes;
sum->uplink_tx_drop.n_pkts += thread->uplink_tx_drop.n_pkts;
sum->uplink_tx_drop.n_bytes += thread->uplink_tx_drop.n_bytes;
sum->sf_active += thread->sf_active;
sum->sf_inactive += thread->sf_inactive;
sum->session_num += thread->session_num;
sum->session_log += thread->session_log;
memset(thread_metrics, 0, sizeof(struct thread_metrics));
memset(thread, 0, sizeof(struct thread_metrics));
ATOMIC_SET(&(global_metrics->thread_metrics_flag[i]), THREAD_METRICS_CACHE_IS_FREE);
}
}
// device_metrics
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_NF_RX_PKT], 0, FS_OP_SET, global_metrics->device.nf_rx.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_NF_RX_B], 0, FS_OP_SET, global_metrics->device.nf_rx.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_NF_RX_PKT], 0, FS_OP_SET, sum->nf_rx.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_NF_RX_B], 0, FS_OP_SET, sum->nf_rx.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_NF_TX_PKT], 0, FS_OP_SET, global_metrics->device.nf_tx.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_NF_TX_B], 0, FS_OP_SET, global_metrics->device.nf_tx.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_NF_TX_PKT], 0, FS_OP_SET, sum->nf_tx.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_NF_TX_B], 0, FS_OP_SET, sum->nf_tx.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VXLAN_RX_PKT], 0, FS_OP_SET, global_metrics->device.endpoint_vxlan_rx.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VXLAN_RX_B], 0, FS_OP_SET, global_metrics->device.endpoint_vxlan_rx.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VXLAN_RX_PKT], 0, FS_OP_SET, sum->endpoint_vxlan_rx.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VXLAN_RX_B], 0, FS_OP_SET, sum->endpoint_vxlan_rx.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VXLAN_TX_PKT], 0, FS_OP_SET, global_metrics->device.endpoint_vxlan_tx.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VXLAN_TX_B], 0, FS_OP_SET, global_metrics->device.endpoint_vxlan_tx.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VXLAN_TX_PKT], 0, FS_OP_SET, sum->endpoint_vxlan_tx.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VXLAN_TX_B], 0, FS_OP_SET, sum->endpoint_vxlan_tx.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VXLAN_DROP_PKT], 0, FS_OP_SET, global_metrics->device.endpoint_vxlan_drop.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VXLAN_DROP_B], 0, FS_OP_SET, global_metrics->device.endpoint_vxlan_drop.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VXLAN_DROP_PKT], 0, FS_OP_SET, sum->endpoint_vxlan_drop.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VXLAN_DROP_B], 0, FS_OP_SET, sum->endpoint_vxlan_drop.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VLAN_RX_PKT], 0, FS_OP_SET, global_metrics->device.endpoint_vlan_rx.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VLAN_RX_B], 0, FS_OP_SET, global_metrics->device.endpoint_vlan_rx.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VLAN_RX_PKT], 0, FS_OP_SET, sum->endpoint_vlan_rx.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VLAN_RX_B], 0, FS_OP_SET, sum->endpoint_vlan_rx.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VLAN_TX_PKT], 0, FS_OP_SET, global_metrics->device.endpoint_vlan_tx.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VLAN_TX_B], 0, FS_OP_SET, global_metrics->device.endpoint_vlan_tx.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VLAN_TX_PKT], 0, FS_OP_SET, sum->endpoint_vlan_tx.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VLAN_TX_B], 0, FS_OP_SET, sum->endpoint_vlan_tx.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VLAN_DROP_PKT], 0, FS_OP_SET, global_metrics->device.endpoint_vlan_drop.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VLAN_DROP_B], 0, FS_OP_SET, global_metrics->device.endpoint_vlan_drop.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VLAN_DROP_PKT], 0, FS_OP_SET, sum->endpoint_vlan_drop.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VLAN_DROP_B], 0, FS_OP_SET, sum->endpoint_vlan_drop.n_bytes);
// data_pkt_metrics
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_MIRR_BYPASS_PKT], 0, FS_OP_SET, global_metrics->data_pkt.mirr_bypass.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_MIRR_BYPASS_B], 0, FS_OP_SET, global_metrics->data_pkt.mirr_bypass.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_MIRR_BYPASS_PKT], 0, FS_OP_SET, sum->mirr_bypass.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_MIRR_BYPASS_B], 0, FS_OP_SET, sum->mirr_bypass.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_MIRR_BLOCK_PKT], 0, FS_OP_SET, global_metrics->data_pkt.mirr_block.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_MIRR_BLOCK_B], 0, FS_OP_SET, global_metrics->data_pkt.mirr_block.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_MIRR_BLOCK_PKT], 0, FS_OP_SET, sum->mirr_block.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_MIRR_BLOCK_B], 0, FS_OP_SET, sum->mirr_block.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_MIRR_RX_DROP_PKT], 0, FS_OP_SET, global_metrics->data_pkt.mirr_rx_drop.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_MIRR_RX_DROP_B], 0, FS_OP_SET, global_metrics->data_pkt.mirr_rx_drop.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_MIRR_RX_DROP_PKT], 0, FS_OP_SET, sum->mirr_rx_drop.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_MIRR_RX_DROP_B], 0, FS_OP_SET, sum->mirr_rx_drop.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_MIRR_TX_PKT], 0, FS_OP_SET, global_metrics->data_pkt.mirr_tx.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_MIRR_TX_B], 0, FS_OP_SET, global_metrics->data_pkt.mirr_tx.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_MIRR_TX_PKT], 0, FS_OP_SET, sum->mirr_tx.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_MIRR_TX_B], 0, FS_OP_SET, sum->mirr_tx.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_STEE_BYPASS_PKT], 0, FS_OP_SET, global_metrics->data_pkt.stee_bypass.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_STEE_BYPASS_B], 0, FS_OP_SET, global_metrics->data_pkt.stee_bypass.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_STEE_BYPASS_PKT], 0, FS_OP_SET, sum->stee_bypass.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_STEE_BYPASS_B], 0, FS_OP_SET, sum->stee_bypass.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_STEE_BLOCK_PKT], 0, FS_OP_SET, global_metrics->data_pkt.stee_block.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_STEE_BLOCK_B], 0, FS_OP_SET, global_metrics->data_pkt.stee_block.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_STEE_BLOCK_PKT], 0, FS_OP_SET, sum->stee_block.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_STEE_BLOCK_B], 0, FS_OP_SET, sum->stee_block.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_STEE_RX_PKT], 0, FS_OP_SET, global_metrics->data_pkt.stee_rx.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_STEE_RX_B], 0, FS_OP_SET, global_metrics->data_pkt.stee_rx.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_STEE_RX_PKT], 0, FS_OP_SET, sum->stee_rx.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_STEE_RX_B], 0, FS_OP_SET, sum->stee_rx.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_STEE_TX_PKT], 0, FS_OP_SET, global_metrics->data_pkt.stee_tx.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_STEE_TX_B], 0, FS_OP_SET, global_metrics->data_pkt.stee_tx.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_STEE_TX_PKT], 0, FS_OP_SET, sum->stee_tx.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_STEE_TX_B], 0, FS_OP_SET, sum->stee_tx.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_MISS_SESS_PKT], 0, FS_OP_SET, global_metrics->data_pkt.miss_sess.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_MISS_SESS_B], 0, FS_OP_SET, global_metrics->data_pkt.miss_sess.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_MISS_SESS_PKT], 0, FS_OP_SET, sum->miss_sess.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_MISS_SESS_B], 0, FS_OP_SET, sum->miss_sess.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_ERROR_BYPASS_PKT], 0, FS_OP_SET, global_metrics->data_pkt.error_bypass.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_ERROR_BYPASS_B], 0, FS_OP_SET, global_metrics->data_pkt.error_bypass.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_ERROR_BYPASS_PKT], 0, FS_OP_SET, sum->error_bypass.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_ERROR_BYPASS_B], 0, FS_OP_SET, sum->error_bypass.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_ERROR_BLOCK_PKT], 0, FS_OP_SET, global_metrics->data_pkt.error_block.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_ERROR_BLOCK_B], 0, FS_OP_SET, global_metrics->data_pkt.error_block.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_ERROR_BLOCK_PKT], 0, FS_OP_SET, sum->error_block.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_ERROR_BLOCK_B], 0, FS_OP_SET, sum->error_block.n_bytes);
// ctrl_pkt_metrics
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_CTRL_PKT_RX_PKT], 0, FS_OP_SET, global_metrics->ctrl_pkt.rx.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_CTRL_PKT_RX_B], 0, FS_OP_SET, global_metrics->ctrl_pkt.rx.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_CTRL_PKT_RX_PKT], 0, FS_OP_SET, sum->ctrl_rx.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_CTRL_PKT_RX_B], 0, FS_OP_SET, sum->ctrl_rx.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_CTRL_PKT_TX_PKT], 0, FS_OP_SET, global_metrics->ctrl_pkt.tx.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_CTRL_PKT_TX_B], 0, FS_OP_SET, global_metrics->ctrl_pkt.tx.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_CTRL_PKT_TX_PKT], 0, FS_OP_SET, sum->ctrl_tx.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_CTRL_PKT_TX_B], 0, FS_OP_SET, sum->ctrl_tx.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_CTRL_PKT_OPENING], 0, FS_OP_SET, global_metrics->ctrl_pkt.opening);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_CTRL_PKT_ACTIVE], 0, FS_OP_SET, global_metrics->ctrl_pkt.active);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_CTRL_PKT_CLOSING], 0, FS_OP_SET, global_metrics->ctrl_pkt.closing);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_CTRL_PKT_RESETALL], 0, FS_OP_SET, global_metrics->ctrl_pkt.resetall);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_CTRL_PKT_ERROR], 0, FS_OP_SET, global_metrics->ctrl_pkt.error);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_CTRL_PKT_OPENING], 0, FS_OP_SET, sum->ctrl_opening);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_CTRL_PKT_ACTIVE], 0, FS_OP_SET, sum->ctrl_active);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_CTRL_PKT_CLOSING], 0, FS_OP_SET, sum->ctrl_closing);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_CTRL_PKT_RESETALL], 0, FS_OP_SET, sum->ctrl_resetall);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_CTRL_PKT_ERROR], 0, FS_OP_SET, sum->ctrl_error);
// keepalived_pkt_metrics
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_KEE_PKT_DOWN_RX_PKT], 0, FS_OP_SET, global_metrics->kee_pkt.downlink_rx.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_KEE_PKT_DOWN_RX_B], 0, FS_OP_SET, global_metrics->kee_pkt.downlink_rx.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_KEE_PKT_DOWN_RX_PKT], 0, FS_OP_SET, sum->downlink_rx.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_KEE_PKT_DOWN_RX_B], 0, FS_OP_SET, sum->downlink_rx.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_KEE_PKT_DOWN_TX_PKT], 0, FS_OP_SET, global_metrics->kee_pkt.downlink_tx.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_KEE_PKT_DOWN_TX_B], 0, FS_OP_SET, global_metrics->kee_pkt.downlink_tx.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_KEE_PKT_DOWN_TX_PKT], 0, FS_OP_SET, sum->downlink_tx.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_KEE_PKT_DOWN_TX_B], 0, FS_OP_SET, sum->downlink_tx.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_KEE_PKT_UP_RX_PKT], 0, FS_OP_SET, global_metrics->kee_pkt.uplink_rx.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_KEE_PKT_UP_RX_B], 0, FS_OP_SET, global_metrics->kee_pkt.uplink_rx.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_KEE_PKT_UP_RX_PKT], 0, FS_OP_SET, sum->uplink_rx.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_KEE_PKT_UP_RX_B], 0, FS_OP_SET, sum->uplink_rx.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_KEE_PKT_UP_TX_DROP_PKT], 0, FS_OP_SET, global_metrics->kee_pkt.uplink_tx_drop.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_KEE_PKT_UP_TX_DROP_B], 0, FS_OP_SET, global_metrics->kee_pkt.uplink_tx_drop.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_KEE_PKT_UP_TX_DROP_PKT], 0, FS_OP_SET, sum->uplink_tx_drop.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_KEE_PKT_UP_TX_DROP_B], 0, FS_OP_SET, sum->uplink_tx_drop.n_bytes);
// sf_status_metrics
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_SF_STATUS_ACTIVE], 0, FS_OP_SET, global_metrics->sf_status.active);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_SF_STATUS_INACTIVE], 0, FS_OP_SET, global_metrics->sf_status.inactive);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_SF_STATUS_ACTIVE], 0, FS_OP_SET, sum->sf_active);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_SF_STATUS_INACTIVE], 0, FS_OP_SET, sum->sf_inactive);
// sf_session_metrics
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_SF_SESSION_NUM], 0, FS_OP_SET, global_metrics->sf_session.num);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_SF_SESSION_LOG], 0, FS_OP_SET, global_metrics->sf_session.log);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_SF_SESSION_NUM], 0, FS_OP_SET, sum->session_num);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_SF_SESSION_LOG], 0, FS_OP_SET, sum->session_log);
FS_passive_output(global_metrics->fs_handle);
}

205
platform/src/packet_io.cpp
View File

@@ -67,6 +67,30 @@ struct packet_io
* metadata
******************************************************************************/
static inline void sids_copy(struct sids *dst, struct sids *src)
{
if (dst && src)
{
dst->num = src->num;
memcpy(dst->elems, src->elems, sizeof(dst->elems[0]) * dst->num);
}
}
static inline void route_ctx_copy(struct route_ctx *dst, struct route_ctx *src)
{
memcpy(dst->data, src->data, src->len);
dst->len = src->len;
}
static inline void route_ctx_copy_once(struct route_ctx *dst, struct route_ctx *src)
{
if (dst->len == 0)
{
memcpy(dst->data, src->data, src->len);
dst->len = src->len;
}
}
void sce_packet_get_innermost_tuple(const struct packet *handler, struct four_tuple *tuple)
{
memset(tuple, 0, sizeof(struct four_tuple));
@@ -205,47 +229,39 @@ int mbuff_set_metadata(marsio_buff_t *tx_buff, struct metadata *meta)
static void update_session_by_metadata(struct session_ctx *ctx, struct metadata *meta)
{
struct metadata *dst_meta_i2e = NULL;
struct metadata *dst_meta_e2i = NULL;
struct sids *e2i_sids = NULL;
struct sids *i2e_sids = NULL;
struct route_ctx *e2i_route_ctx = NULL;
struct route_ctx *i2e_route_ctx = NULL;
if (meta->is_decrypted)
{
dst_meta_i2e = &ctx->decrypted_meta_i2e;
dst_meta_e2i = &ctx->decrypted_meta_e2i;
e2i_sids = &ctx->decrypted_e2i_sids;
i2e_sids = &ctx->decrypted_i2e_sids;
e2i_route_ctx = &ctx->decrypted_e2i_route_ctx;
i2e_route_ctx = &ctx->decrypted_i2e_route_ctx;
}
else
{
dst_meta_i2e = &ctx->raw_meta_i2e;
dst_meta_e2i = &ctx->raw_meta_e2i;
e2i_sids = &ctx->raw_e2i_sids;
i2e_sids = &ctx->raw_i2e_sids;
e2i_route_ctx = &ctx->raw_e2i_route_ctx;
i2e_route_ctx = &ctx->raw_i2e_route_ctx;
}
// 1: E2I
// 0: I2E
if (meta->direction)
{
// first packet update metadata
if (metadata_isempty(dst_meta_e2i))
{
metadata_copy(dst_meta_e2i, meta);
route_ctx_copy_once(e2i_route_ctx, &meta->route_ctx);
sids_copy(e2i_sids, &meta->sids);
}
else
{
// next packet only update sids
sids_copy(&dst_meta_e2i->sids, &meta->sids);
}
}
else
{
// first packet update metadata
if (metadata_isempty(dst_meta_i2e))
{
metadata_copy(dst_meta_i2e, meta);
}
else
{
// next packet only update sids
sids_copy(&dst_meta_i2e->sids, &meta->sids);
}
route_ctx_copy_once(i2e_route_ctx, &meta->route_ctx);
sids_copy(i2e_sids, &meta->sids);
}
}
@@ -262,26 +278,26 @@ static void update_metadata_by_session(struct session_ctx *ctx, struct metadata
{
if (meta->is_decrypted)
{
sids = &(ctx->decrypted_meta_e2i.sids);
route_ctx = &(ctx->decrypted_meta_e2i.route_ctx);
sids = &(ctx->decrypted_e2i_sids);
route_ctx = &(ctx->decrypted_e2i_route_ctx);
}
else
{
sids = &(ctx->raw_meta_e2i.sids);
route_ctx = &(ctx->raw_meta_e2i.route_ctx);
sids = &(ctx->raw_e2i_sids);
route_ctx = &(ctx->raw_e2i_route_ctx);
}
}
else
{
if (meta->is_decrypted)
{
sids = &(ctx->decrypted_meta_i2e.sids);
route_ctx = &(ctx->decrypted_meta_i2e.route_ctx);
sids = &(ctx->decrypted_i2e_sids);
route_ctx = &(ctx->decrypted_i2e_route_ctx);
}
else
{
sids = &(ctx->raw_meta_i2e.sids);
route_ctx = &(ctx->raw_meta_i2e.route_ctx);
sids = &(ctx->raw_i2e_sids);
route_ctx = &(ctx->raw_i2e_route_ctx);
}
}
@@ -295,7 +311,7 @@ static void update_metadata_by_session(struct session_ctx *ctx, struct metadata
// return 0 : not keepalive packet
// return 1 : is keepalive packet
static int is_downlink_keepalive_packet(marsio_buff_t *rx_buff, int raw_len)
static inline int is_downlink_keepalive_packet(marsio_buff_t *rx_buff, int raw_len)
{
char *raw_data = marsio_buff_mtod(rx_buff);
if (raw_data == NULL || raw_len < (int)(sizeof(struct ethhdr)))
@@ -316,7 +332,7 @@ static int is_downlink_keepalive_packet(marsio_buff_t *rx_buff, int raw_len)
// return 0 : not keepalive packet
// return 1 : is keepalive packet
static int is_uplink_keepalive_packet(marsio_buff_t *rx_buff, int raw_len)
static inline int is_uplink_keepalive_packet(marsio_buff_t *rx_buff, int raw_len)
{
char *raw_data = marsio_buff_mtod(rx_buff);
if (raw_data == NULL || raw_len < (int)(sizeof(struct ethhdr) + sizeof(struct ip) + sizeof(struct udphdr)))
@@ -495,7 +511,7 @@ static inline int send_packet_to_sf(struct session_ctx *session_ctx, marsio_buff
char *buffer = NULL;
struct packet_io *packet_io = thread_ctx->ref_io;
struct thread_metrics *thread_metrics = &thread_ctx->thread_metrics;
uint32_t rehash_index = session_ctx->ctrl_meta.rehash_index;
uint32_t rehash_index = session_ctx->rehash_index;
marsio_buff_ctrlzone_reset(mbuff);
switch (sf->sf_connectivity.method)
@@ -511,7 +527,7 @@ static inline int send_packet_to_sf(struct session_ctx *session_ctx, marsio_buff
nsend = marsio_buff_datalen(mbuff);
marsio_buff_set_metadata(mbuff, MR_BUFF_REHASH_INDEX, &rehash_index, sizeof(rehash_index));
marsio_send_burst(packet_io->dev_endpoint_l3.mr_path, thread_ctx->thread_index, &mbuff, 1);
throughput_metrics_inc(&(thread_metrics->device.endpoint_vxlan_tx), 1, nsend);
THROUGHPUT_METRICS_INC(&(thread_metrics->endpoint_vxlan_tx), 1, nsend);
break;
case ENCAPSULATE_METHOD_LAYER2_SWITCH:
vlan_encapsulate(mbuff,
@@ -520,7 +536,7 @@ static inline int send_packet_to_sf(struct session_ctx *session_ctx, marsio_buff
nsend = marsio_buff_datalen(mbuff);
marsio_buff_set_metadata(mbuff, MR_BUFF_REHASH_INDEX, &rehash_index, sizeof(rehash_index));
marsio_send_burst(packet_io->dev_endpoint_l2.mr_path, thread_ctx->thread_index, &mbuff, 1);
throughput_metrics_inc(&(thread_metrics->device.endpoint_vlan_tx), 1, nsend);
THROUGHPUT_METRICS_INC(&(thread_metrics->endpoint_vlan_tx), 1, nsend);
break;
case ENCAPSULATE_METHOD_LAYER3_SWITCH:
// TODO
@@ -541,7 +557,7 @@ static inline void action_err_bypass(marsio_buff_t *rx_buff, struct metadata *me
int nsend = action_nf_inject(rx_buff, meta, sf, thread_ctx);
if (nsend > 0)
{
throughput_metrics_inc(&(thread_metrics->data_pkt.error_bypass), 1, nsend);
THROUGHPUT_METRICS_INC(&(thread_metrics->error_bypass), 1, nsend);
}
}
@@ -551,7 +567,7 @@ static inline void action_err_block(marsio_buff_t *rx_buff, struct metadata *met
struct packet_io *packet_io = thread_ctx->ref_io;
int thread_index = thread_ctx->thread_index;
throughput_metrics_inc(&(thread_metrics->data_pkt.error_block), 1, meta->raw_len);
THROUGHPUT_METRICS_INC(&(thread_metrics->error_block), 1, meta->raw_len);
marsio_buff_free(packet_io->instance, &rx_buff, 1, 0, thread_index);
}
@@ -570,7 +586,7 @@ static inline int action_nf_inject(marsio_buff_t *rx_buff, struct metadata *meta
}
marsio_send_burst(packet_io->dev_nf.mr_path, thread_index, &rx_buff, 1);
throughput_metrics_inc(&(thread_metrics->device.nf_tx), 1, meta->raw_len);
THROUGHPUT_METRICS_INC(&(thread_metrics->nf_tx), 1, meta->raw_len);
return meta->raw_len;
}
@@ -578,14 +594,14 @@ static inline void action_mirr_bypass(marsio_buff_t *rx_buff, struct metadata *m
{
struct thread_metrics *thread_metrics = &thread_ctx->thread_metrics;
throughput_metrics_inc(&(thread_metrics->data_pkt.mirr_bypass), 1, meta->raw_len);
THROUGHPUT_METRICS_INC(&(thread_metrics->mirr_bypass), 1, meta->raw_len);
}
static inline void action_mirr_block(marsio_buff_t *rx_buff, struct metadata *meta, struct selected_sf *sf, struct thread_ctx *thread_ctx)
{
struct thread_metrics *thread_metrics = &thread_ctx->thread_metrics;
throughput_metrics_inc(&(thread_metrics->data_pkt.mirr_block), 1, meta->raw_len);
THROUGHPUT_METRICS_INC(&(thread_metrics->mirr_block), 1, meta->raw_len);
}
static inline void action_mirr_forward(struct session_ctx *session_ctx, marsio_buff_t *rx_buff, struct metadata *meta, struct selected_sf *sf, struct thread_ctx *thread_ctx)
@@ -607,8 +623,8 @@ static inline void action_mirr_forward(struct session_ctx *session_ctx, marsio_b
memcpy(copy_ptr, raw_data, meta->raw_len);
int nsend = send_packet_to_sf(session_ctx, new_buff, meta, sf, thread_ctx);
throughput_metrics_inc(&(thread_metrics->data_pkt.mirr_tx), 1, meta->raw_len);
throughput_metrics_inc(&sf->tx, 1, nsend);
THROUGHPUT_METRICS_INC(&(thread_metrics->mirr_tx), 1, meta->raw_len);
THROUGHPUT_METRICS_INC(&sf->tx, 1, nsend);
struct sf_metrics_key key = {0};
key.rule_id = sf->rule_id;
key.sff_profile_id = sf->sff_profile_id;
@@ -621,7 +637,7 @@ static inline void action_stee_bypass(marsio_buff_t *rx_buff, struct metadata *m
{
struct thread_metrics *thread_metrics = &thread_ctx->thread_metrics;
throughput_metrics_inc(&(thread_metrics->data_pkt.stee_bypass), 1, meta->raw_len);
THROUGHPUT_METRICS_INC(&(thread_metrics->stee_bypass), 1, meta->raw_len);
}
static inline void action_stee_block(marsio_buff_t *rx_buff, struct metadata *meta, struct selected_sf *sf, struct thread_ctx *thread_ctx)
@@ -630,7 +646,7 @@ static inline void action_stee_block(marsio_buff_t *rx_buff, struct metadata *me
struct packet_io *packet_io = thread_ctx->ref_io;
int thread_index = thread_ctx->thread_index;
throughput_metrics_inc(&(thread_metrics->data_pkt.stee_block), 1, meta->raw_len);
THROUGHPUT_METRICS_INC(&(thread_metrics->stee_block), 1, meta->raw_len);
marsio_buff_free(packet_io->instance, &rx_buff, 1, 0, thread_index);
}
@@ -639,8 +655,8 @@ static inline void action_stee_forward(struct session_ctx *session_ctx, marsio_b
struct thread_metrics *thread_metrics = &thread_ctx->thread_metrics;
int nsend = send_packet_to_sf(session_ctx, rx_buff, meta, sf, thread_ctx);
throughput_metrics_inc(&(thread_metrics->data_pkt.stee_tx), 1, meta->raw_len);
throughput_metrics_inc(&sf->tx, 1, nsend);
THROUGHPUT_METRICS_INC(&(thread_metrics->stee_tx), 1, meta->raw_len);
THROUGHPUT_METRICS_INC(&sf->tx, 1, nsend);
struct sf_metrics_key key = {0};
key.rule_id = sf->rule_id;
key.sff_profile_id = sf->sff_profile_id;
@@ -839,8 +855,8 @@ static int send_ctrl_packet(struct session_ctx *session_ctx, struct thread_ctx *
LOG_INFO("%s: session %lu %s send event log %ld bytes", LOG_TAG_SFMETRICS, session_ctx->session_id, session_ctx->session_addr, size);
marsio_buff_t *tx_buffs[1];
const char *packet_header_data = session_ctx->ctrl_packet_header_data;
int packet_header_len = session_ctx->ctrl_packet_header_len;
const char *packet_header_data = session_ctx->ctrl_pkt_hdr_ptr;
int packet_header_len = session_ctx->ctrl_pkt_hdr_len;
marsio_buff_malloc_global(packet_io->instance, tx_buffs, 1, 0, thread_index);
char *dst = marsio_buff_append(tx_buffs[0], packet_header_len + size);
memcpy(dst, packet_header_data, packet_header_len);
@@ -852,7 +868,7 @@ static int send_ctrl_packet(struct session_ctx *session_ctx, struct thread_ctx *
meta.is_ctrl_pkt = 1;
meta.sids.num = 1;
meta.sids.elems[0] = sce_ctx->firewall_sids;
route_ctx_copy(&meta.route_ctx, &(session_ctx->ctrl_meta.route_ctx));
route_ctx_copy(&meta.route_ctx, &(session_ctx->ctrl_route_ctx));
mbuff_set_metadata(tx_buffs[0], &meta);
int nsend = marsio_buff_datalen(tx_buffs[0]);
marsio_send_burst(packet_io->dev_nf.mr_path, thread_index, tx_buffs, 1);
@@ -872,9 +888,9 @@ static void send_event_log(struct session_ctx *session_ctx, struct thread_ctx *t
nsend = send_ctrl_packet(session_ctx, thread_ctx);
if (nsend > 0)
{
ATOMIC_INC(&(thread_metrics->sf_session.log));
throughput_metrics_inc(&(thread_metrics->ctrl_pkt.tx), 1, nsend);
throughput_metrics_inc(&(thread_metrics->device.nf_tx), 1, nsend);
ATOMIC_INC(&(thread_metrics->session_log));
THROUGHPUT_METRICS_INC(&(thread_metrics->ctrl_tx), 1, nsend);
THROUGHPUT_METRICS_INC(&(thread_metrics->nf_tx), 1, nsend);
}
}
}
@@ -945,7 +961,7 @@ static void handle_session_closing(struct metadata *meta, struct control_packet
dump_sf_metrics(s_ctx, s_ctx->chaining_decrypted);
session_table_delete_by_id(session_table, meta->session_id);
ATOMIC_DEC(&(thread_metrics->sf_session.num));
ATOMIC_DEC(&(thread_metrics->session_num));
}
}
@@ -991,11 +1007,12 @@ static void handle_session_active(struct metadata *meta, struct control_packet *
struct session_ctx *session_ctx = session_ctx_new();
session_ctx->session_id = meta->session_id;
session_ctx->session_addr = sce_ctx->enable_debug ? four_tuple_tostring(&inner_tuple4) : NULL;
session_ctx->rehash_index = meta->rehash_index;
session_ctx->vxlan_src_port = calculate_vxlan_source_port(&inner_tuple4);
four_tuple_copy(&session_ctx->inner_tuple4, &inner_tuple4);
metadata_copy(&session_ctx->ctrl_meta, meta);
session_ctx->ctrl_packet_header_data = memdup(meta->raw_data, meta->raw_len);
session_ctx->ctrl_packet_header_len = meta->raw_len;
route_ctx_copy(&session_ctx->ctrl_route_ctx, &meta->route_ctx);
session_ctx->ctrl_pkt_hdr_ptr = memdup(meta->raw_data, meta->raw_len);
session_ctx->ctrl_pkt_hdr_len = meta->raw_len;
session_ctx->chaining_raw = selected_chaining_create(chaining_size, session_ctx->session_id, session_ctx->session_addr);
session_ctx->chaining_decrypted = selected_chaining_create(chaining_size, session_ctx->session_id, session_ctx->session_addr);
session_ctx->ref_thread_ctx = thread_ctx;
@@ -1005,7 +1022,7 @@ static void handle_session_active(struct metadata *meta, struct control_packet *
send_event_log(session_ctx, thread_ctx);
session_table_insert(session_table, session_ctx->session_id, &session_ctx->inner_tuple4, session_ctx, session_value_free_cb);
ATOMIC_INC(&(thread_metrics->sf_session.num));
ATOMIC_INC(&(thread_metrics->session_num));
}
}
@@ -1015,7 +1032,7 @@ static void handle_session_resetall(struct metadata *meta, struct control_packet
struct sce_ctx *sce_ctx = thread_ctx->ref_sce_ctx;
LOG_ERROR("%s: session %lu resetall: notification clears all session tables !!!", LOG_TAG_PKTIO, meta->session_id);
ATOMIC_ZERO(&(global_metrics->sf_session.num));
ATOMIC_ZERO(&(global_metrics->sum.session_num));
for (int i = 0; i < sce_ctx->nr_worker_threads; i++)
{
struct thread_ctx *temp_ctx = &sce_ctx->work_threads[i];
@@ -1058,20 +1075,20 @@ static void handle_control_packet(marsio_buff_t *rx_buff, struct thread_ctx *thr
switch (ctrl_pkt.state)
{
case SESSION_STATE_OPENING:
ATOMIC_INC(&(thread_metrics->ctrl_pkt.opening));
ATOMIC_INC(&(thread_metrics->ctrl_opening));
// when session opening, firewall not send policy id
// return handle_session_opening(&meta, &ctrl_pkt, ctx);
break;
case SESSION_STATE_CLOSING:
ATOMIC_INC(&(thread_metrics->ctrl_pkt.closing));
ATOMIC_INC(&(thread_metrics->ctrl_closing));
handle_session_closing(&meta, &ctrl_pkt, thread_ctx);
break;
case SESSION_STATE_ACTIVE:
ATOMIC_INC(&(thread_metrics->ctrl_pkt.active));
ATOMIC_INC(&(thread_metrics->ctrl_active));
handle_session_active(&meta, &ctrl_pkt, thread_ctx);
break;
case SESSION_STATE_RESETALL:
ATOMIC_INC(&(thread_metrics->ctrl_pkt.resetall));
ATOMIC_INC(&(thread_metrics->ctrl_resetall));
handle_session_resetall(&meta, &ctrl_pkt, thread_ctx);
break;
default:
@@ -1080,7 +1097,7 @@ static void handle_control_packet(marsio_buff_t *rx_buff, struct thread_ctx *thr
return;
error_ctrl_pkt:
ATOMIC_INC(&(thread_metrics->ctrl_pkt.error));
ATOMIC_INC(&(thread_metrics->ctrl_error));
return;
}
@@ -1122,7 +1139,7 @@ static void handle_data_packet(marsio_buff_t *rx_buff, struct thread_ctx *thread
session_ctx = data_packet_search_session(session_table, meta.raw_data, meta.raw_len, meta.session_id);
if (session_ctx == NULL)
{
throughput_metrics_inc(&(thread_metrics->data_pkt.miss_sess), 1, meta.raw_len);
THROUGHPUT_METRICS_INC(&(thread_metrics->miss_sess), 1, meta.raw_len);
goto error_bypass;
}
@@ -1164,7 +1181,7 @@ static void handle_inject_vxlan_packet(marsio_buff_t *rx_buff, struct thread_ctx
char *raw_data = marsio_buff_mtod(rx_buff);
if (vxlan_frame_decode(&vxlan_hdr, raw_data, raw_len) == -1)
{
throughput_metrics_inc(&(thread_metrics->device.endpoint_vxlan_drop), 1, raw_len);
THROUGHPUT_METRICS_INC(&(thread_metrics->endpoint_vxlan_drop), 1, raw_len);
meta.raw_len = raw_len;
action_err_block(rx_buff, &meta, NULL, thread_ctx);
return;
@@ -1206,14 +1223,14 @@ static void handle_inject_vxlan_packet(marsio_buff_t *rx_buff, struct thread_ctx
{
LOG_DEBUG("%s: unexpected inject packet, session %lu %s with sf_profile_id %d executes mirror and does not require reflow, drop !!!",
LOG_TAG_PKTIO, session_ctx->session_id, session_ctx->session_addr, chaining->chaining[sf_index].sf_profile_id);
throughput_metrics_inc(&(thread_metrics->data_pkt.mirr_rx_drop), 1, meta.raw_len);
THROUGHPUT_METRICS_INC(&(thread_metrics->mirr_rx_drop), 1, meta.raw_len);
goto error_block;
}
else
{
struct selected_sf *sf = &(chaining->chaining[sf_index]);
throughput_metrics_inc(&sf->rx, 1, raw_len);
throughput_metrics_inc(&(thread_metrics->data_pkt.stee_rx), 1, meta.raw_len);
THROUGHPUT_METRICS_INC(&sf->rx, 1, raw_len);
THROUGHPUT_METRICS_INC(&(thread_metrics->stee_rx), 1, meta.raw_len);
struct sf_metrics_key key = {0};
key.rule_id = sf->rule_id;
key.sff_profile_id = sf->sff_profile_id;
@@ -1227,7 +1244,7 @@ static void handle_inject_vxlan_packet(marsio_buff_t *rx_buff, struct thread_ctx
return;
error_block:
throughput_metrics_inc(&(thread_metrics->device.endpoint_vxlan_drop), 1, raw_len);
THROUGHPUT_METRICS_INC(&(thread_metrics->endpoint_vxlan_drop), 1, raw_len);
marsio_buff_adj(rx_buff, raw_len - meta.raw_len);
action_err_block(rx_buff, &meta, NULL, thread_ctx);
}
@@ -1496,8 +1513,8 @@ int packet_io_thread_polling_nf(struct packet_io *handle, struct thread_ctx *thr
{
int raw_len = marsio_buff_datalen(rx_buffs[j]);
throughput_metrics_inc(&(thread_metrics->device.nf_rx), 1, raw_len);
throughput_metrics_inc(&(thread_metrics->device.nf_tx), 1, raw_len);
THROUGHPUT_METRICS_INC(&(thread_metrics->nf_rx), 1, raw_len);
THROUGHPUT_METRICS_INC(&(thread_metrics->nf_tx), 1, raw_len);
}
marsio_send_burst(handle->dev_nf.mr_path, thread_index, rx_buffs, nr_recv);
@@ -1511,28 +1528,28 @@ int packet_io_thread_polling_nf(struct packet_io *handle, struct thread_ctx *thr
if (is_downlink_keepalive_packet(rx_buff, raw_len))
{
throughput_metrics_inc(&(thread_metrics->device.nf_rx), 1, raw_len);
throughput_metrics_inc(&(thread_metrics->device.nf_tx), 1, raw_len);
THROUGHPUT_METRICS_INC(&(thread_metrics->nf_rx), 1, raw_len);
THROUGHPUT_METRICS_INC(&(thread_metrics->nf_tx), 1, raw_len);
throughput_metrics_inc(&(thread_metrics->kee_pkt.downlink_rx), 1, raw_len);
throughput_metrics_inc(&(thread_metrics->kee_pkt.downlink_tx), 1, raw_len);
THROUGHPUT_METRICS_INC(&(thread_metrics->downlink_rx), 1, raw_len);
THROUGHPUT_METRICS_INC(&(thread_metrics->downlink_tx), 1, raw_len);
marsio_send_burst(handle->dev_nf.mr_path, thread_index, &rx_buff, 1);
}
else if (marsio_buff_is_ctrlbuf(rx_buff))
{
throughput_metrics_inc(&(thread_metrics->device.nf_rx), 1, raw_len);
throughput_metrics_inc(&(thread_metrics->device.nf_tx), 1, raw_len);
THROUGHPUT_METRICS_INC(&(thread_metrics->nf_rx), 1, raw_len);
THROUGHPUT_METRICS_INC(&(thread_metrics->nf_tx), 1, raw_len);
throughput_metrics_inc(&(thread_metrics->ctrl_pkt.rx), 1, raw_len);
throughput_metrics_inc(&(thread_metrics->ctrl_pkt.tx), 1, raw_len);
THROUGHPUT_METRICS_INC(&(thread_metrics->ctrl_rx), 1, raw_len);
THROUGHPUT_METRICS_INC(&(thread_metrics->ctrl_tx), 1, raw_len);
handle_control_packet(rx_buff, thread_ctx, raw_len);
marsio_send_burst(handle->dev_nf.mr_path, thread_index, &rx_buff, 1);
}
else
{
throughput_metrics_inc(&(thread_metrics->device.nf_rx), 1, raw_len);
THROUGHPUT_METRICS_INC(&(thread_metrics->nf_rx), 1, raw_len);
handle_data_packet(rx_buff, thread_ctx, raw_len);
}
@@ -1559,8 +1576,8 @@ int packet_io_thread_polling_endpoint_l3(struct packet_io *handle, struct thread
{
int raw_len = marsio_buff_datalen(rx_buffs[j]);
throughput_metrics_inc(&(thread_metrics->device.endpoint_vxlan_rx), 1, raw_len);
throughput_metrics_inc(&(thread_metrics->device.endpoint_vxlan_tx), 1, raw_len);
THROUGHPUT_METRICS_INC(&(thread_metrics->endpoint_vxlan_rx), 1, raw_len);
THROUGHPUT_METRICS_INC(&(thread_metrics->endpoint_vxlan_tx), 1, raw_len);
}
marsio_send_burst(handle->dev_endpoint_l3.mr_path, thread_index, rx_buffs, nr_recv);
@@ -1574,15 +1591,15 @@ int packet_io_thread_polling_endpoint_l3(struct packet_io *handle, struct thread
if (is_uplink_keepalive_packet(rx_buff, raw_len))
{
throughput_metrics_inc(&(thread_metrics->device.endpoint_vxlan_rx), 1, raw_len);
throughput_metrics_inc(&(thread_metrics->kee_pkt.uplink_rx), 1, raw_len);
throughput_metrics_inc(&(thread_metrics->kee_pkt.uplink_tx_drop), 1, raw_len);
THROUGHPUT_METRICS_INC(&(thread_metrics->endpoint_vxlan_rx), 1, raw_len);
THROUGHPUT_METRICS_INC(&(thread_metrics->uplink_rx), 1, raw_len);
THROUGHPUT_METRICS_INC(&(thread_metrics->uplink_tx_drop), 1, raw_len);
marsio_buff_free(handle->instance, &rx_buff, 1, 0, thread_index);
}
else
{
throughput_metrics_inc(&(thread_metrics->device.endpoint_vxlan_rx), 1, raw_len);
THROUGHPUT_METRICS_INC(&(thread_metrics->endpoint_vxlan_rx), 1, raw_len);
handle_inject_vxlan_packet(rx_buff, thread_ctx, raw_len);
}
@@ -1609,8 +1626,8 @@ int packet_io_thread_polling_endpoint_l2(struct packet_io *handle, struct thread
{
int raw_len = marsio_buff_datalen(rx_buffs[j]);
throughput_metrics_inc(&(thread_metrics->device.endpoint_vlan_rx), 1, raw_len);
throughput_metrics_inc(&(thread_metrics->device.endpoint_vlan_tx), 1, raw_len);
THROUGHPUT_METRICS_INC(&(thread_metrics->endpoint_vlan_rx), 1, raw_len);
THROUGHPUT_METRICS_INC(&(thread_metrics->endpoint_vlan_tx), 1, raw_len);
}
marsio_send_burst(handle->dev_endpoint_l2.mr_path, thread_index, rx_buffs, nr_recv);
@@ -1622,8 +1639,8 @@ int packet_io_thread_polling_endpoint_l2(struct packet_io *handle, struct thread
marsio_buff_t *rx_buff = rx_buffs[j];
int raw_len = marsio_buff_datalen(rx_buffs[j]);
throughput_metrics_inc(&(thread_metrics->device.endpoint_vlan_rx), 1, raw_len);
throughput_metrics_inc(&(thread_metrics->device.endpoint_vlan_drop), 1, raw_len);
THROUGHPUT_METRICS_INC(&(thread_metrics->endpoint_vlan_rx), 1, raw_len);
THROUGHPUT_METRICS_INC(&(thread_metrics->endpoint_vlan_drop), 1, raw_len);
marsio_buff_free(handle->instance, &rx_buff, 1, 0, thread_index);
}

4
platform/src/policy.cpp
View File

@@ -1194,7 +1194,7 @@ static void select_sf_by_ldbc(struct sff_param *sff_param, struct selected_sf *s
memset(selected_sf->sf_dst_mac, 0, sizeof(selected_sf->sf_dst_mac));
if (health_check_session_get_mac(sf_param->health_check_session_id, selected_sf->sf_dst_mac) == 0)
{
ATOMIC_INC(&(thread_metrics->sf_status.active));
ATOMIC_INC(&(thread_metrics->sf_active));
LOG_INFO("%s: session %lu %s select sf by ldbc, sf_profile_id %d to be selected", LOG_TAG_POLICY, s_ctx->session_id, s_ctx->session_addr, sf_param->sf_profile_id);
selected_sf_set_action(selected_sf, ACTION_FORWAED_DUE_SELECTED_SF);
selected_sf_set_info(selected_sf, sf_param);
@@ -1202,7 +1202,7 @@ static void select_sf_by_ldbc(struct sff_param *sff_param, struct selected_sf *s
}
else
{
ATOMIC_INC(&(thread_metrics->sf_status.inactive));
ATOMIC_INC(&(thread_metrics->sf_inactive));
if (handle_fail_action(&sff_param->sff_exception, selected_sf, utarray_len(sf_array) - 1) == 0)
{
LOG_INFO("%s: session %lu %s select sf by re-dispatch, sf_profile_id %d to be excluded", LOG_TAG_POLICY, s_ctx->session_id, s_ctx->session_addr, sf_param->sf_profile_id);

38
platform/src/sce.cpp
View File

@@ -5,38 +5,6 @@
#include "log.h"
#include "global_metrics.h"
/******************************************************************************
* Struct Metadata
******************************************************************************/
int metadata_isempty(struct metadata *meta)
{
if (meta->write_ref == 0)
{
return 1;
}
else
{
return 0;
}
}
void metadata_copy(struct metadata *dst, struct metadata *src)
{
dst->write_ref++;
dst->session_id = src->session_id;
dst->rehash_index = src->rehash_index;
dst->raw_data = NULL;
dst->raw_len = 0;
dst->l7offset = src->l7offset;
dst->direction = src->direction;
dst->is_ctrl_pkt = src->is_ctrl_pkt;
dst->is_decrypted = src->is_decrypted;
sids_copy(&dst->sids, &src->sids);
route_ctx_copy(&dst->route_ctx, &src->route_ctx);
}
char *memdup(const char *src, int len)
{
if (src == NULL || len == 0)
@@ -72,10 +40,10 @@ void session_ctx_free(struct session_ctx *session_ctx)
session_ctx->session_addr = NULL;
}
if (session_ctx->ctrl_packet_header_data)
if (session_ctx->ctrl_pkt_hdr_ptr)
{
free(session_ctx->ctrl_packet_header_data);
session_ctx->ctrl_packet_header_data = NULL;
free(session_ctx->ctrl_pkt_hdr_ptr);
session_ctx->ctrl_pkt_hdr_ptr = NULL;
}
if (session_ctx->chaining_raw)

1
test/gtest_utils.h
View File

@@ -29,7 +29,6 @@ extern marsio_buff_t *marsio_mbuff_dup(marsio_buff_t *m);
#define set_metadata(meta, id, offset, is_ctrl, is_decrypt) \
{ \
memset(&meta, 0, sizeof(meta)); \
meta.write_ref = 0; \
meta.session_id = id; \
meta.raw_data = NULL; \
meta.raw_len = 0; \