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

TSG-13684 tsg-service-chaining-engine使用VLAN封装Packet并执行Traffic Mirroring

Browse Source
This commit is contained in:
luwenpeng
2023-10-18 10:08:10 +08:00
parent 18561bc4fe
commit 0753e8018c
57 changed files with 1784 additions and 1175 deletions
Download Patch File Download Diff File Expand all files Collapse all files

322
platform/src/global_metrics.cpp
View File

@@ -8,68 +8,82 @@
enum SCE_STAT_FIELD
{
// device_metrics
// device_nf
STAT_DEVICE_NF_RX_PKT,
STAT_DEVICE_NF_RX_B,
STAT_DEVICE_NF_TX_PKT,
STAT_DEVICE_NF_TX_B,
STAT_DEVICE_ENDPOINT_RX_PKT,
STAT_DEVICE_ENDPOINT_RX_B,
STAT_DEVICE_ENDPOINT_TX_PKT,
STAT_DEVICE_ENDPOINT_TX_B,
// keepalived_pkt_metrics
STAT_KEE_PKT_DOWN_RX_PKT,
STAT_KEE_PKT_DOWN_RX_B,
STAT_KEE_PKT_DOWN_TX_PKT,
STAT_KEE_PKT_DOWN_TX_B,
// device_endpoint_vxlan
STAT_DEVICE_ENDPOINT_VXLAN_RX_PKT,
STAT_DEVICE_ENDPOINT_VXLAN_RX_B,
STAT_DEVICE_ENDPOINT_VXLAN_TX_PKT,
STAT_DEVICE_ENDPOINT_VXLAN_TX_B,
STAT_KEE_PKT_UP_RX_PKT,
STAT_KEE_PKT_UP_RX_B,
STAT_KEE_PKT_UP_TX_DROP_PKT,
STAT_KEE_PKT_UP_TX_DROP_B,
// raw_pkt_metrics
STAT_RAW_PKT_MIRR_BYPASS_PKT,
STAT_RAW_PKT_MIRR_BYPASS_B,
// device_endpoint_vlan
STAT_DEVICE_ENDPOINT_VLAN_RX_PKT,
STAT_DEVICE_ENDPOINT_VLAN_RX_B,
STAT_RAW_PKT_MIRR_BLOCK_PKT,
STAT_RAW_PKT_MIRR_BLOCK_B,
STAT_DEVICE_ENDPOINT_VLAN_TX_PKT,
STAT_DEVICE_ENDPOINT_VLAN_TX_B,
STAT_RAW_PKT_MIRR_RX_DROP_PKT,
STAT_RAW_PKT_MIRR_RX_DROP_B,
STAT_DEVICE_ENDPOINT_VXLAN_DROP_PKT,
STAT_DEVICE_ENDPOINT_VXLAN_DROP_B,
STAT_RAW_PKT_MIRR_TX_PKT,
STAT_RAW_PKT_MIRR_TX_B,
STAT_DEVICE_ENDPOINT_VLAN_DROP_PKT,
STAT_DEVICE_ENDPOINT_VLAN_DROP_B,
STAT_RAW_PKT_STEE_BYPASS_PKT,
STAT_RAW_PKT_STEE_BYPASS_B,
// data_pkt_metrics
STAT_DATA_PKT_MIRR_BYPASS_PKT,
STAT_DATA_PKT_MIRR_BYPASS_B,
STAT_RAW_PKT_STEE_BLOCK_PKT,
STAT_RAW_PKT_STEE_BLOCK_B,
STAT_DATA_PKT_MIRR_BLOCK_PKT,
STAT_DATA_PKT_MIRR_BLOCK_B,
STAT_RAW_PKT_STEE_RX_PKT,
STAT_RAW_PKT_STEE_RX_B,
STAT_DATA_PKT_MIRR_RX_DROP_PKT,
STAT_DATA_PKT_MIRR_RX_DROP_B,
STAT_RAW_PKT_STEE_TX_PKT,
STAT_RAW_PKT_STEE_TX_B,
STAT_DATA_PKT_MIRR_TX_PKT,
STAT_DATA_PKT_MIRR_TX_B,
STAT_RAW_PKT_MISS_SESS_PKT,
STAT_RAW_PKT_MISS_SESS_B,
STAT_DATA_PKT_STEE_BYPASS_PKT,
STAT_DATA_PKT_STEE_BYPASS_B,
STAT_RAW_PKT_ERROR_BYPASS_PKT,
STAT_RAW_PKT_ERROR_BYPASS_B,
STAT_DATA_PKT_STEE_BLOCK_PKT,
STAT_DATA_PKT_STEE_BLOCK_B,
STAT_RAW_PKT_ERROR_BLOCK_PKT,
STAT_RAW_PKT_ERROR_BLOCK_B,
STAT_DATA_PKT_STEE_RX_PKT,
STAT_DATA_PKT_STEE_RX_B,
STAT_DEVICE_ENDPOINT_DROP_PKT,
STAT_DEVICE_ENDPOINT_DROP_B,
STAT_DATA_PKT_STEE_TX_PKT,
STAT_DATA_PKT_STEE_TX_B,
STAT_DATA_PKT_MISS_SESS_PKT,
STAT_DATA_PKT_MISS_SESS_B,
STAT_DATA_PKT_ERROR_BYPASS_PKT,
STAT_DATA_PKT_ERROR_BYPASS_B,
STAT_DATA_PKT_ERROR_BLOCK_PKT,
STAT_DATA_PKT_ERROR_BLOCK_B,
// sf_status_metrics
STAT_SF_STATUS_ACTIVE,
STAT_SF_STATUS_INACTIVE,
// ctrl_pkt_metrics
STAT_CTRL_PKT_RX_PKT,
@@ -88,84 +102,94 @@ enum SCE_STAT_FIELD
STAT_SF_SESSION_NUM,
STAT_SF_SESSION_LOG,
// sf_status_metrics
STAT_SF_STATUS_ACTIVE,
STAT_SF_STATUS_INACTIVE,
// max
STAT_MAX,
};
static const char *stat_map[] =
{
// device_metrics
[STAT_DEVICE_NF_RX_PKT] = "nf_rx_pkt",
[STAT_DEVICE_NF_RX_B] = "nf_rx_B",
// device_nf
[STAT_DEVICE_NF_RX_PKT] = "dev_nf_rx_P",
[STAT_DEVICE_NF_RX_B] = "dev_nf_rx_B",
[STAT_DEVICE_NF_TX_PKT] = "nf_tx_pkt",
[STAT_DEVICE_NF_TX_B] = "nf_tx_B",
[STAT_DEVICE_NF_TX_PKT] = "dev_nf_tx_P",
[STAT_DEVICE_NF_TX_B] = "dev_nf_tx_B",
[STAT_DEVICE_ENDPOINT_RX_PKT] = "endp_rx_pkt",
[STAT_DEVICE_ENDPOINT_RX_B] = "endp_rx_B",
[STAT_DEVICE_ENDPOINT_TX_PKT] = "endp_tx_pkt",
[STAT_DEVICE_ENDPOINT_TX_B] = "endp_tx_B",
// keepalived_pkt_metrics
[STAT_KEE_PKT_DOWN_RX_PKT] = "kee_d_rx_pkt",
[STAT_KEE_PKT_DOWN_RX_PKT] = "kee_d_rx_P",
[STAT_KEE_PKT_DOWN_RX_B] = "kee_d_rx_B",
[STAT_KEE_PKT_DOWN_TX_PKT] = "kee_d_tx_pkt",
[STAT_KEE_PKT_DOWN_TX_PKT] = "kee_d_tx_P",
[STAT_KEE_PKT_DOWN_TX_B] = "kee_d_tx_B",
[STAT_KEE_PKT_UP_RX_PKT] = "kee_u_rx_pkt",
// device_endpoint_vxlan
[STAT_DEVICE_ENDPOINT_VXLAN_RX_PKT] = "dev_l3_rx_P",
[STAT_DEVICE_ENDPOINT_VXLAN_RX_B] = "dev_l3_rx_B",
[STAT_DEVICE_ENDPOINT_VXLAN_TX_PKT] = "dev_l3_tx_P",
[STAT_DEVICE_ENDPOINT_VXLAN_TX_B] = "dev_l3_tx_B",
[STAT_KEE_PKT_UP_RX_PKT] = "kee_u_rx_P",
[STAT_KEE_PKT_UP_RX_B] = "kee_u_rx_B",
[STAT_KEE_PKT_UP_TX_DROP_PKT] = "kee_u_rxdop_pkt",
[STAT_KEE_PKT_UP_TX_DROP_PKT] = "kee_u_rxdop_P",
[STAT_KEE_PKT_UP_TX_DROP_B] = "kee_u_rxdop_B",
// raw_pkt_metrics
[STAT_RAW_PKT_MIRR_BYPASS_PKT] = "mirr_bypass_pkt",
[STAT_RAW_PKT_MIRR_BYPASS_B] = "mirr_bypass_B",
// device_endpoint_vlan
[STAT_DEVICE_ENDPOINT_VLAN_RX_PKT] = "dev_l2_rx_P",
[STAT_DEVICE_ENDPOINT_VLAN_RX_B] = "dev_l2_rx_B",
[STAT_RAW_PKT_MIRR_BLOCK_PKT] = "mirr_block_pkt",
[STAT_RAW_PKT_MIRR_BLOCK_B] = "mirr_block_B",
[STAT_DEVICE_ENDPOINT_VLAN_TX_PKT] = "dev_l2_tx_P",
[STAT_DEVICE_ENDPOINT_VLAN_TX_B] = "dev_l2_tx_B",
[STAT_RAW_PKT_MIRR_RX_DROP_PKT] = "mirr_rxdop_pkt",
[STAT_RAW_PKT_MIRR_RX_DROP_B] = "mirr_rxdop_B",
[STAT_DEVICE_ENDPOINT_VXLAN_DROP_PKT] = "dev_l3_dop_P",
[STAT_DEVICE_ENDPOINT_VXLAN_DROP_B] = "dev_l3_dop_B",
[STAT_RAW_PKT_MIRR_TX_PKT] = "mirro_tx_pkt",
[STAT_RAW_PKT_MIRR_TX_B] = "mirro_tx_B",
[STAT_DEVICE_ENDPOINT_VLAN_DROP_PKT] = "dev_l2_dop_P",
[STAT_DEVICE_ENDPOINT_VLAN_DROP_B] = "dev_l2_dop_B",
[STAT_RAW_PKT_STEE_BYPASS_PKT] = "stee_bypass_pkt",
[STAT_RAW_PKT_STEE_BYPASS_B] = "stee_bypass_B",
// data_pkt_metrics
[STAT_DATA_PKT_MIRR_BYPASS_PKT] = "mirr_bypass_P",
[STAT_DATA_PKT_MIRR_BYPASS_B] = "mirr_bypass_B",
[STAT_RAW_PKT_STEE_BLOCK_PKT] = "stee_block_pkt",
[STAT_RAW_PKT_STEE_BLOCK_B] = "stee_block_B",
[STAT_DATA_PKT_MIRR_BLOCK_PKT] = "mirr_block_P",
[STAT_DATA_PKT_MIRR_BLOCK_B] = "mirr_block_B",
[STAT_RAW_PKT_STEE_RX_PKT] = "stee_rx_pkt",
[STAT_RAW_PKT_STEE_RX_B] = "stee_rx_B",
[STAT_DATA_PKT_MIRR_RX_DROP_PKT] = "mirr_rxdop_P",
[STAT_DATA_PKT_MIRR_RX_DROP_B] = "mirr_rxdop_B",
[STAT_RAW_PKT_STEE_TX_PKT] = "stee_tx_pkt",
[STAT_RAW_PKT_STEE_TX_B] = "stee_tx_B",
[STAT_DATA_PKT_MIRR_TX_PKT] = "mirro_tx_P",
[STAT_DATA_PKT_MIRR_TX_B] = "mirro_tx_B",
[STAT_RAW_PKT_MISS_SESS_PKT] = "miss_sess_pkt",
[STAT_RAW_PKT_MISS_SESS_B] = "miss_sess_B",
[STAT_DATA_PKT_STEE_BYPASS_PKT] = "stee_bypass_P",
[STAT_DATA_PKT_STEE_BYPASS_B] = "stee_bypass_B",
[STAT_RAW_PKT_ERROR_BYPASS_PKT] = "err_bypass_pkt",
[STAT_RAW_PKT_ERROR_BYPASS_B] = "err_bypass_B",
[STAT_DATA_PKT_STEE_BLOCK_PKT] = "stee_block_P",
[STAT_DATA_PKT_STEE_BLOCK_B] = "stee_block_B",
[STAT_RAW_PKT_ERROR_BLOCK_PKT] = "err_block_pkt",
[STAT_RAW_PKT_ERROR_BLOCK_B] = "err_block_B",
[STAT_DATA_PKT_STEE_RX_PKT] = "stee_rx_P",
[STAT_DATA_PKT_STEE_RX_B] = "stee_rx_B",
[STAT_DEVICE_ENDPOINT_DROP_PKT] = "endp_drop_pkt",
[STAT_DEVICE_ENDPOINT_DROP_B] = "endp_drop_B",
[STAT_DATA_PKT_STEE_TX_PKT] = "stee_tx_P",
[STAT_DATA_PKT_STEE_TX_B] = "stee_tx_B",
[STAT_DATA_PKT_MISS_SESS_PKT] = "miss_sess_P",
[STAT_DATA_PKT_MISS_SESS_B] = "miss_sess_B",
[STAT_DATA_PKT_ERROR_BYPASS_PKT] = "err_bypass_P",
[STAT_DATA_PKT_ERROR_BYPASS_B] = "err_bypass_B",
[STAT_DATA_PKT_ERROR_BLOCK_PKT] = "err_block_P",
[STAT_DATA_PKT_ERROR_BLOCK_B] = "err_block_B",
// sf_status_metrics
[STAT_SF_STATUS_ACTIVE] = "sf_active",
[STAT_SF_STATUS_INACTIVE] = "sf_inactive",
// ctrl_pkt_metrics
[STAT_CTRL_PKT_RX_PKT] = "ctrl_rx_pkt",
[STAT_CTRL_PKT_RX_PKT] = "ctrl_rx_P",
[STAT_CTRL_PKT_RX_B] = "ctrl_rx_B",
[STAT_CTRL_PKT_TX_PKT] = "ctrl_tx_pkt",
[STAT_CTRL_PKT_TX_PKT] = "ctrl_tx_P",
[STAT_CTRL_PKT_TX_B] = "ctrl_tx_B",
[STAT_CTRL_PKT_OPENING] = "ctrl_opening",
@@ -175,13 +199,9 @@ static const char *stat_map[] =
[STAT_CTRL_PKT_ERROR] = "ctrl_error",
// sf_session_metrics
[STAT_SF_SESSION_NUM] = "session_num",
[STAT_SF_SESSION_NUM] = "curr_sessions",
[STAT_SF_SESSION_LOG] = "session_logs",
// sf_status_metrics
[STAT_SF_STATUS_ACTIVE] = "sf_active",
[STAT_SF_STATUS_INACTIVE] = "sf_inactive",
[STAT_MAX] = NULL};
static void global_metrics_parse_config(const char *profile, struct metrics_config *config)
@@ -297,34 +317,43 @@ void global_metrics_dump(struct global_metrics *global_metrics)
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;
global_metrics->device.endpoint_rx.n_pkts += thread_metrics->device.endpoint_rx.n_pkts;
global_metrics->device.endpoint_rx.n_bytes += thread_metrics->device.endpoint_rx.n_bytes;
global_metrics->device.endpoint_tx.n_pkts += thread_metrics->device.endpoint_tx.n_pkts;
global_metrics->device.endpoint_tx.n_bytes += thread_metrics->device.endpoint_tx.n_bytes;
global_metrics->device.endpoint_drop.n_pkts += thread_metrics->device.endpoint_drop.n_pkts;
global_metrics->device.endpoint_drop.n_bytes += thread_metrics->device.endpoint_drop.n_bytes;
global_metrics->raw_pkt.mirr_bypass.n_pkts += thread_metrics->raw_pkt.mirr_bypass.n_pkts;
global_metrics->raw_pkt.mirr_bypass.n_bytes += thread_metrics->raw_pkt.mirr_bypass.n_bytes;
global_metrics->raw_pkt.mirr_block.n_pkts += thread_metrics->raw_pkt.mirr_block.n_pkts;
global_metrics->raw_pkt.mirr_block.n_bytes += thread_metrics->raw_pkt.mirr_block.n_bytes;
global_metrics->raw_pkt.mirr_rx_drop.n_pkts += thread_metrics->raw_pkt.mirr_rx_drop.n_pkts;
global_metrics->raw_pkt.mirr_rx_drop.n_bytes += thread_metrics->raw_pkt.mirr_rx_drop.n_bytes;
global_metrics->raw_pkt.mirr_tx.n_pkts += thread_metrics->raw_pkt.mirr_tx.n_pkts;
global_metrics->raw_pkt.mirr_tx.n_bytes += thread_metrics->raw_pkt.mirr_tx.n_bytes;
global_metrics->raw_pkt.stee_bypass.n_pkts += thread_metrics->raw_pkt.stee_bypass.n_pkts;
global_metrics->raw_pkt.stee_bypass.n_bytes += thread_metrics->raw_pkt.stee_bypass.n_bytes;
global_metrics->raw_pkt.stee_block.n_pkts += thread_metrics->raw_pkt.stee_block.n_pkts;
global_metrics->raw_pkt.stee_block.n_bytes += thread_metrics->raw_pkt.stee_block.n_bytes;
global_metrics->raw_pkt.stee_rx.n_pkts += thread_metrics->raw_pkt.stee_rx.n_pkts;
global_metrics->raw_pkt.stee_rx.n_bytes += thread_metrics->raw_pkt.stee_rx.n_bytes;
global_metrics->raw_pkt.stee_tx.n_pkts += thread_metrics->raw_pkt.stee_tx.n_pkts;
global_metrics->raw_pkt.stee_tx.n_bytes += thread_metrics->raw_pkt.stee_tx.n_bytes;
global_metrics->raw_pkt.miss_sess.n_pkts += thread_metrics->raw_pkt.miss_sess.n_pkts;
global_metrics->raw_pkt.miss_sess.n_bytes += thread_metrics->raw_pkt.miss_sess.n_bytes;
global_metrics->raw_pkt.error_bypass.n_pkts += thread_metrics->raw_pkt.error_bypass.n_pkts;
global_metrics->raw_pkt.error_bypass.n_bytes += thread_metrics->raw_pkt.error_bypass.n_bytes;
global_metrics->raw_pkt.error_block.n_pkts += thread_metrics->raw_pkt.error_block.n_pkts;
global_metrics->raw_pkt.error_block.n_bytes += thread_metrics->raw_pkt.error_block.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;
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;
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;
@@ -359,48 +388,57 @@ void global_metrics_dump(struct global_metrics *global_metrics)
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_ENDPOINT_RX_PKT], 0, FS_OP_SET, global_metrics->device.endpoint_rx.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_RX_B], 0, FS_OP_SET, global_metrics->device.endpoint_rx.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_TX_PKT], 0, FS_OP_SET, global_metrics->device.endpoint_tx.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_TX_B], 0, FS_OP_SET, global_metrics->device.endpoint_tx.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_DROP_PKT], 0, FS_OP_SET, global_metrics->device.endpoint_drop.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_DROP_B], 0, FS_OP_SET, global_metrics->device.endpoint_drop.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);
// raw_pkt_metrics
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_RAW_PKT_MIRR_BYPASS_PKT], 0, FS_OP_SET, global_metrics->raw_pkt.mirr_bypass.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_RAW_PKT_MIRR_BYPASS_B], 0, FS_OP_SET, global_metrics->raw_pkt.mirr_bypass.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_RAW_PKT_MIRR_BLOCK_PKT], 0, FS_OP_SET, global_metrics->raw_pkt.mirr_block.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_RAW_PKT_MIRR_BLOCK_B], 0, FS_OP_SET, global_metrics->raw_pkt.mirr_block.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_RAW_PKT_MIRR_RX_DROP_PKT], 0, FS_OP_SET, global_metrics->raw_pkt.mirr_rx_drop.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_RAW_PKT_MIRR_RX_DROP_B], 0, FS_OP_SET, global_metrics->raw_pkt.mirr_rx_drop.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_RAW_PKT_MIRR_TX_PKT], 0, FS_OP_SET, global_metrics->raw_pkt.mirr_tx.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_RAW_PKT_MIRR_TX_B], 0, FS_OP_SET, global_metrics->raw_pkt.mirr_tx.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_RAW_PKT_STEE_BYPASS_PKT], 0, FS_OP_SET, global_metrics->raw_pkt.stee_bypass.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_RAW_PKT_STEE_BYPASS_B], 0, FS_OP_SET, global_metrics->raw_pkt.stee_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_RAW_PKT_STEE_BLOCK_PKT], 0, FS_OP_SET, global_metrics->raw_pkt.stee_block.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_RAW_PKT_STEE_BLOCK_B], 0, FS_OP_SET, global_metrics->raw_pkt.stee_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_RAW_PKT_STEE_RX_PKT], 0, FS_OP_SET, global_metrics->raw_pkt.stee_rx.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_RAW_PKT_STEE_RX_B], 0, FS_OP_SET, global_metrics->raw_pkt.stee_rx.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_RAW_PKT_STEE_TX_PKT], 0, FS_OP_SET, global_metrics->raw_pkt.stee_tx.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_RAW_PKT_STEE_TX_B], 0, FS_OP_SET, global_metrics->raw_pkt.stee_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_RAW_PKT_MISS_SESS_PKT], 0, FS_OP_SET, global_metrics->raw_pkt.miss_sess.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_RAW_PKT_MISS_SESS_B], 0, FS_OP_SET, global_metrics->raw_pkt.miss_sess.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_RAW_PKT_ERROR_BYPASS_PKT], 0, FS_OP_SET, global_metrics->raw_pkt.error_bypass.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_RAW_PKT_ERROR_BYPASS_B], 0, FS_OP_SET, global_metrics->raw_pkt.error_bypass.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_RAW_PKT_ERROR_BLOCK_PKT], 0, FS_OP_SET, global_metrics->raw_pkt.error_block.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_RAW_PKT_ERROR_BLOCK_B], 0, FS_OP_SET, global_metrics->raw_pkt.error_block.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_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_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_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);
// 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);

10
platform/src/main.cpp
View File

@@ -72,8 +72,7 @@ static void *worker_thread_cycle(void *arg)
int thread_index = thread_ctx->thread_index;
int timeout_ms = 0;
int n_pkt_recv_from_nf = 0;
int n_pkt_recv_from_endp = 0;
int n_packet_recved = 0;
char thread_name[16];
uint64_t sf_metrics_last_send_ts = timestamp_get_msec(ts);
uint64_t sf_metrics_send_interval = sf_metrics_get_interval(sf_metrics) * 1000;
@@ -91,9 +90,10 @@ static void *worker_thread_cycle(void *arg)
while (!ATOMIC_READ(&is_need_stop))
{
n_pkt_recv_from_nf = packet_io_thread_polling_nf(handle, thread_ctx);
n_pkt_recv_from_endp = packet_io_thread_polling_endpoint(handle, thread_ctx);
if (n_pkt_recv_from_nf == 0 && n_pkt_recv_from_endp == 0)
n_packet_recved = packet_io_thread_polling_nf(handle, thread_ctx);
n_packet_recved += packet_io_thread_polling_endpoint_l3(handle, thread_ctx);
n_packet_recved += packet_io_thread_polling_endpoint_l2(handle, thread_ctx);
if (n_packet_recved == 0)
{
timeout_ms = sf_metrics_last_send_ts + sf_metrics_send_interval - timestamp_get_msec(ts);
if (timeout_ms <= 0)

484
platform/src/packet_io.cpp
View File

@@ -14,7 +14,7 @@
#include "g_vxlan.h"
#include "packet_io.h"
#include "sf_metrics.h"
#include "ctrl_packet.h"
#include "control_packet.h"
#include "global_metrics.h"
#define RX_BURST_MAX 128
@@ -30,13 +30,20 @@ struct config
int rx_burst_max;
int min_timeout_ms;
char app_symbol[256];
char dev_endpoint[256];
char dev_nf_interface[256];
char dev_endpoint_src_ip_str[16];
char dev_endpoint_src_mac_str[32];
in_addr_t dev_endpoint_src_ip;
u_char dev_endpoint_src_mac[ETH_ALEN];
// dev_nf
char dev_nf_name[256];
// dev_endpoint_l3
char dev_endpoint_l3_name[256];
char dev_endpoint_l3_ip_str[16];
char dev_endpoint_l3_mac_str[32];
in_addr_t dev_endpoint_l3_ip;
u_char dev_endpoint_l3_mac[ETH_ALEN];
// dev_endpoint_l2
char dev_endpoint_l2_name[256];
int vlan_encapsulate_replace_orig_vlan_header;
};
struct device
@@ -49,8 +56,9 @@ struct packet_io
{
int thread_num;
struct mr_instance *instance;
struct device dev_nf_interface;
struct device dev_endpoint;
struct device dev_nf;
struct device dev_endpoint_l3;
struct device dev_endpoint_l2;
struct config config;
};
@@ -337,19 +345,18 @@ static int is_uplink_keepalive_packet(marsio_buff_t *rx_buff)
// return !NULL
// return NULL
static struct session_ctx *raw_packet_search_session(struct session_table *table, const char *raw_data, int raw_len, uint64_t session_id)
static struct session_ctx *data_packet_search_session(struct session_table *table, const char *raw_data, int raw_len, uint64_t session_id)
{
struct addr_tuple4 inner_addr;
struct addr_tuple4 reverse_addr;
struct raw_pkt_parser raw_parser;
struct data_packet data_pkt;
memset(&inner_addr, 0, sizeof(struct addr_tuple4));
memset(&reverse_addr, 0, sizeof(struct addr_tuple4));
raw_packet_parser_init(&raw_parser, 0, LAYER_TYPE_ALL, 8);
raw_packet_parser_parse(&raw_parser, (const void *)raw_data, raw_len);
data_packet_parse(&data_pkt, (const void *)raw_data, raw_len, 0);
raw_packet_parser_get_most_inner_tuple4(&raw_parser, &inner_addr);
data_packet_get_innermost_tuple4(&data_pkt, &inner_addr);
addr_tuple4_reverse(&inner_addr, &reverse_addr);
struct session_node *node = session_table_search_by_id(table, session_id);
@@ -375,14 +382,13 @@ static struct session_ctx *raw_packet_search_session(struct session_table *table
static struct session_ctx *inject_packet_search_session(struct session_table *table, const char *raw_data, int raw_len)
{
struct addr_tuple4 inner_addr;
struct raw_pkt_parser raw_parser;
struct data_packet data_pkt;
memset(&inner_addr, 0, sizeof(struct addr_tuple4));
raw_packet_parser_init(&raw_parser, 0, LAYER_TYPE_ALL, 8);
raw_packet_parser_parse(&raw_parser, (const void *)raw_data, raw_len);
data_packet_parse(&data_pkt, (const void *)raw_data, raw_len, 0);
raw_packet_parser_get_most_inner_tuple4(&raw_parser, &inner_addr);
data_packet_get_innermost_tuple4(&data_pkt, &inner_addr);
struct session_node *node = session_table_search_by_addr(table, &inner_addr);
if (node == NULL)
@@ -400,13 +406,12 @@ static struct session_ctx *inject_packet_search_session(struct session_table *ta
* action bypass/block/forward
******************************************************************************/
static void vxlan_encapsulate(char *buffer,
static void vxlan_encapsulate(marsio_buff_t *mbuff,
const u_char src_mac[], const u_char dst_mac[],
const in_addr_t src_ip, const in_addr_t dst_ip,
int payload_len, int is_e2i, int is_decrypted, int sf_index,
uint64_t session_id, uint16_t ipid)
const in_addr_t src_ip, const in_addr_t dst_ip, uint16_t ipid,
uint16_t src_port, int payload_len, int is_e2i, int is_decrypted, int sf_index)
{
struct ethhdr *eth_hdr = (struct ethhdr *)buffer;
struct ethhdr *eth_hdr = (struct ethhdr *)marsio_buff_prepend(mbuff, sizeof(struct ethhdr) + sizeof(struct ip) + sizeof(struct udp_hdr) + sizeof(struct g_vxlan));
struct ip *ip_hdr = (struct ip *)((char *)eth_hdr + sizeof(struct ethhdr));
struct udp_hdr *udp_hdr = (struct udp_hdr *)((char *)ip_hdr + sizeof(struct ip));
struct g_vxlan *g_vxlan_hdr = (struct g_vxlan *)((char *)udp_hdr + sizeof(struct udp_hdr));
@@ -418,42 +423,121 @@ static void vxlan_encapsulate(char *buffer,
build_ether_header(eth_hdr, ETH_P_IP, src_mac, dst_mac);
build_ip_header(ip_hdr, IPPROTO_UDP, ipid, src_ip, dst_ip, sizeof(struct udp_hdr) + sizeof(struct g_vxlan) + payload_len);
build_udp_header((const char *)&ip_hdr->ip_src, 8, udp_hdr, session_id % (65535 - 49152) + 49152, 4789, sizeof(struct g_vxlan) + payload_len);
build_udp_header((const char *)&ip_hdr->ip_src, 8, udp_hdr, src_port, 4789, sizeof(struct g_vxlan) + payload_len);
}
static int send_packet_to_sf(marsio_buff_t *rx_buff, struct metadata *meta, struct selected_sf *sf, struct thread_ctx *thread_ctx)
struct vlan_hdr
{
uint16_t vlan_cfi;
uint16_t protocol;
} __attribute__((__packed__));
static void build_vlan_header(struct vlan_hdr *vlan_hdr, uint16_t vlan_id, uint16_t protocol)
{
vlan_hdr->vlan_cfi = 0;
vlan_hdr->vlan_cfi = htons(vlan_id & 0xFFF);
vlan_hdr->protocol = htons(protocol);
}
static void overwrite_vlan_id(struct vlan_hdr *vlan_hdr, uint16_t vlan_id)
{
vlan_hdr->vlan_cfi = 0;
vlan_hdr->vlan_cfi = htons(vlan_id & 0xFFF);
}
void vlan_encapsulate(marsio_buff_t *mbuff, int vlan_id, int replace_orig_vlan_header)
{
if (replace_orig_vlan_header == 0)
{
append:
struct ethhdr *eth_hdr = (struct ethhdr *)marsio_buff_prepend(mbuff, sizeof(struct vlan_hdr));
struct vlan_hdr *vlan_hdr = (struct vlan_hdr *)((char *)eth_hdr + sizeof(struct ethhdr));
memmove(eth_hdr, (char *)eth_hdr + sizeof(struct vlan_hdr), sizeof(struct ethhdr));
build_vlan_header(vlan_hdr, vlan_id, ntohs(eth_hdr->h_proto));
eth_hdr->h_proto = htons(ETH_P_8021Q);
return;
}
else
{
struct ethhdr *eth_hdr = (struct ethhdr *)marsio_buff_mtod(mbuff);
int next_proto = eth_hdr->h_proto;
char *start_layer = (char *)eth_hdr + sizeof(struct ethhdr);
char *next_layer = start_layer;
while (next_proto == htons(ETH_P_8021Q) || next_proto == htons(ETH_P_8021AD))
{
struct vlan_hdr *vlan_hdr = (struct vlan_hdr *)next_layer;
next_proto = vlan_hdr->protocol;
next_layer += sizeof(struct vlan_hdr);
}
// No vlan header found
uint64_t offset = next_layer - start_layer;
if (offset == 0)
{
goto append;
}
// Find a layer of vlan header
if (offset == sizeof(struct vlan_hdr))
{
struct vlan_hdr *vlan_hdr = (struct vlan_hdr *)start_layer;
overwrite_vlan_id(vlan_hdr, vlan_id);
return;
}
// Find the multi-layer vlan header
if (offset > sizeof(struct vlan_hdr))
{
struct vlan_hdr *vlan_hdr = (struct vlan_hdr *)(next_layer - sizeof(struct vlan_hdr));
struct ethhdr *new_eth_hdr = (struct ethhdr *)((char *)vlan_hdr - sizeof(struct ethhdr));
overwrite_vlan_id(vlan_hdr, vlan_id);
memmove(new_eth_hdr, (char *)eth_hdr, sizeof(struct ethhdr));
new_eth_hdr->h_proto = htons(ETH_P_8021Q);
marsio_buff_adj(mbuff, offset - sizeof(struct vlan_hdr));
return;
}
assert(0);
}
}
static int send_packet_to_sf(marsio_buff_t *mbuff, struct metadata *meta, struct selected_sf *sf, struct thread_ctx *thread_ctx)
{
thread_ctx->tx_packets_to_sf++;
int nsend = 0;
struct packet_io *packet_io = thread_ctx->ref_io;
int thread_index = thread_ctx->thread_index;
struct thread_metrics *thread_metrics = &thread_ctx->thread_metrics;
int payload_len = meta->raw_len;
int is_e2i = meta->is_e2i_dir;
int is_decrypted = meta->is_decrypted;
int sf_index = sf->sf_index;
int prepend_len = 0;
char *buffer = NULL;
marsio_buff_ctrlzone_reset(rx_buff);
marsio_buff_ctrlzone_reset(mbuff);
switch (sf->sf_connectivity.method)
{
case PACKAGE_METHOD_VXLAN_G:
prepend_len = sizeof(struct ethhdr) + sizeof(struct ip) + sizeof(struct udp_hdr) + sizeof(struct g_vxlan);
buffer = marsio_buff_prepend(rx_buff, prepend_len);
vxlan_encapsulate(buffer, packet_io->config.dev_endpoint_src_mac, sf->sf_dst_mac, packet_io->config.dev_endpoint_src_ip, sf->sf_dst_ip, payload_len, is_e2i, is_decrypted, sf_index, meta->session_id, thread_ctx->tx_packets_to_sf % 65535);
case ENCAPSULATE_METHOD_VXLAN_G:
vxlan_encapsulate(mbuff, packet_io->config.dev_endpoint_l3_mac, sf->sf_dst_mac,
packet_io->config.dev_endpoint_l3_ip, sf->sf_dst_ip, thread_ctx->tx_packets_to_sf % 65535,
meta->session_id % (65535 - 49152) + 49152, meta->raw_len, meta->is_e2i_dir, meta->is_decrypted, sf->sf_index);
nsend = marsio_buff_datalen(mbuff);
marsio_send_burst_with_options(packet_io->dev_endpoint_l3.mr_path, thread_ctx->thread_index, &mbuff, 1, MARSIO_SEND_OPT_REHASH);
throughput_metrics_inc(&(thread_metrics->device.endpoint_vxlan_tx), 1, nsend);
break;
case PACKAGE_METHOD_LAYER2_SWITCH:
// TODO
case ENCAPSULATE_METHOD_LAYER2_SWITCH:
vlan_encapsulate(mbuff,
meta->is_e2i_dir ? sf->sf_connectivity.ext_vlan_tag : sf->sf_connectivity.int_vlan_tag,
packet_io->config.vlan_encapsulate_replace_orig_vlan_header);
nsend = marsio_buff_datalen(mbuff);
marsio_send_burst_with_options(packet_io->dev_endpoint_l2.mr_path, thread_ctx->thread_index, &mbuff, 1, MARSIO_SEND_OPT_REHASH);
throughput_metrics_inc(&(thread_metrics->device.endpoint_vlan_tx), 1, nsend);
break;
case PACKAGE_METHOD_LAYER3_SWITCH:
case ENCAPSULATE_METHOD_LAYER3_SWITCH:
// TODO
break;
default:
break;
}
int nsend = marsio_buff_datalen(rx_buff);
marsio_send_burst_with_options(packet_io->dev_endpoint.mr_path, thread_index, &rx_buff, 1, MARSIO_SEND_OPT_REHASH);
return nsend;
}
@@ -466,7 +550,7 @@ static void action_err_bypass(marsio_buff_t *rx_buff, struct metadata *meta, str
int nsend = action_nf_inject(rx_buff, meta, sf, thread_ctx);
if (nsend > 0)
{
throughput_metrics_inc(&(thread_metrics->raw_pkt.error_bypass), 1, nsend);
throughput_metrics_inc(&(thread_metrics->data_pkt.error_bypass), 1, nsend);
}
}
@@ -477,7 +561,7 @@ static void action_err_block(marsio_buff_t *rx_buff, struct metadata *meta, stru
int thread_index = thread_ctx->thread_index;
int raw_len = marsio_buff_datalen(rx_buff);
throughput_metrics_inc(&(thread_metrics->raw_pkt.error_block), 1, raw_len);
throughput_metrics_inc(&(thread_metrics->data_pkt.error_block), 1, raw_len);
marsio_buff_free(packet_io->instance, &rx_buff, 1, 0, thread_index);
}
@@ -496,7 +580,7 @@ static int action_nf_inject(marsio_buff_t *rx_buff, struct metadata *meta, struc
}
int raw_len = marsio_buff_datalen(rx_buff);
marsio_send_burst(packet_io->dev_nf_interface.mr_path, thread_index, &rx_buff, 1);
marsio_send_burst(packet_io->dev_nf.mr_path, thread_index, &rx_buff, 1);
throughput_metrics_inc(&(thread_metrics->device.nf_tx), 1, raw_len);
return raw_len;
}
@@ -506,7 +590,7 @@ static void action_mirr_bypass(marsio_buff_t *rx_buff, struct metadata *meta, st
struct thread_metrics *thread_metrics = &thread_ctx->thread_metrics;
int raw_len = marsio_buff_datalen(rx_buff);
throughput_metrics_inc(&(thread_metrics->raw_pkt.mirr_bypass), 1, raw_len);
throughput_metrics_inc(&(thread_metrics->data_pkt.mirr_bypass), 1, raw_len);
}
static void action_mirr_block(marsio_buff_t *rx_buff, struct metadata *meta, struct selected_sf *sf, struct thread_ctx *thread_ctx)
@@ -514,7 +598,7 @@ static void action_mirr_block(marsio_buff_t *rx_buff, struct metadata *meta, str
struct thread_metrics *thread_metrics = &thread_ctx->thread_metrics;
int raw_len = marsio_buff_datalen(rx_buff);
throughput_metrics_inc(&(thread_metrics->raw_pkt.mirr_block), 1, raw_len);
throughput_metrics_inc(&(thread_metrics->data_pkt.mirr_block), 1, raw_len);
}
static void action_mirr_forward(marsio_buff_t *rx_buff, struct metadata *meta, struct selected_sf *sf, struct thread_ctx *thread_ctx)
@@ -537,8 +621,7 @@ static void action_mirr_forward(marsio_buff_t *rx_buff, struct metadata *meta, s
memcpy(copy_ptr, raw_data, raw_len);
int nsend = send_packet_to_sf(new_buff, meta, sf, thread_ctx);
throughput_metrics_inc(&(thread_metrics->device.endpoint_tx), 1, nsend);
throughput_metrics_inc(&(thread_metrics->raw_pkt.mirr_tx), 1, raw_len);
throughput_metrics_inc(&(thread_metrics->data_pkt.mirr_tx), 1, raw_len);
throughput_metrics_inc(&sf->tx, 1, nsend);
sf_metrics_inc(thread_ctx->sf_metrics, sf->rule_vsys_id, sf->rule_id, sf->sff_profile_id, sf->sf_profile_id, 0, 0, 1, nsend);
}
@@ -548,7 +631,7 @@ static void action_stee_bypass(marsio_buff_t *rx_buff, struct metadata *meta, st
struct thread_metrics *thread_metrics = &thread_ctx->thread_metrics;
int raw_len = marsio_buff_datalen(rx_buff);
throughput_metrics_inc(&(thread_metrics->raw_pkt.stee_bypass), 1, raw_len);
throughput_metrics_inc(&(thread_metrics->data_pkt.stee_bypass), 1, raw_len);
}
static void action_stee_block(marsio_buff_t *rx_buff, struct metadata *meta, struct selected_sf *sf, struct thread_ctx *thread_ctx)
@@ -558,7 +641,7 @@ static void action_stee_block(marsio_buff_t *rx_buff, struct metadata *meta, str
int thread_index = thread_ctx->thread_index;
int raw_len = marsio_buff_datalen(rx_buff);
throughput_metrics_inc(&(thread_metrics->raw_pkt.stee_block), 1, raw_len);
throughput_metrics_inc(&(thread_metrics->data_pkt.stee_block), 1, raw_len);
marsio_buff_free(packet_io->instance, &rx_buff, 1, 0, thread_index);
}
@@ -568,8 +651,7 @@ static void action_stee_forward(marsio_buff_t *rx_buff, struct metadata *meta, s
int raw_len = marsio_buff_datalen(rx_buff);
int nsend = send_packet_to_sf(rx_buff, meta, sf, thread_ctx);
throughput_metrics_inc(&(thread_metrics->device.endpoint_tx), 1, nsend);
throughput_metrics_inc(&(thread_metrics->raw_pkt.stee_tx), 1, raw_len);
throughput_metrics_inc(&(thread_metrics->data_pkt.stee_tx), 1, raw_len);
throughput_metrics_inc(&sf->tx, 1, nsend);
sf_metrics_inc(thread_ctx->sf_metrics, sf->rule_vsys_id, sf->rule_id, sf->sff_profile_id, sf->sf_profile_id, 0, 0, 1, nsend);
}
@@ -617,7 +699,7 @@ static void action_sf_chaining(struct thread_ctx *thread_ctx, struct session_ctx
}
case SESSION_ACTION_FORWARD:
if (sf->sf_connectivity.method != PACKAGE_METHOD_VXLAN_G)
if (sf->sf_connectivity.method != ENCAPSULATE_METHOD_VXLAN_G && sf->sf_connectivity.method != ENCAPSULATE_METHOD_LAYER2_SWITCH)
{
LOG_ERROR("%s: processing packets, session %lu %s requires encapsulation format not supported, bypass !!!",
LOG_TAG_PKTIO, session_ctx->session_id, session_ctx->session_addr);
@@ -723,23 +805,23 @@ static int send_ctrl_packet(struct session_ctx *session_ctx, struct selected_cha
LOG_INFO("%s: session %lu %s send event log %ld bytes", LOG_TAG_METRICS, session_ctx->session_id, session_ctx->session_addr, size);
marsio_buff_t *tx_buffs[1];
char *raw_packet_header_data = session_ctx->ctrl_meta->raw_data;
int raw_packet_header_len = session_ctx->ctrl_meta->l7offset;
char *packet_header_data = session_ctx->ctrl_meta->raw_data;
int packet_header_len = session_ctx->ctrl_meta->l7offset;
marsio_buff_malloc_global(packet_io->instance, tx_buffs, 1, 0, thread_index);
char *dst = marsio_buff_append(tx_buffs[0], raw_packet_header_len + size);
memcpy(dst, raw_packet_header_data, raw_packet_header_len);
memcpy(dst + raw_packet_header_len, data, size);
char *dst = marsio_buff_append(tx_buffs[0], packet_header_len + size);
memcpy(dst, packet_header_data, packet_header_len);
memcpy(dst + packet_header_len, data, size);
struct metadata meta = {0};
meta.session_id = session_ctx->session_id;
meta.l7offset = raw_packet_header_len;
meta.l7offset = packet_header_len;
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);
mbuff_set_metadata(tx_buffs[0], &meta);
int nsend = marsio_buff_datalen(tx_buffs[0]);
marsio_send_burst(packet_io->dev_nf_interface.mr_path, thread_index, tx_buffs, 1);
marsio_send_burst(packet_io->dev_nf.mr_path, thread_index, tx_buffs, 1);
free(data);
return nsend;
@@ -797,28 +879,28 @@ static void session_value_free_cb(void *ctx)
session_ctx_free(s_ctx);
}
static void handle_policy_mutil_hits(struct policy_enforcer *enforcer, struct session_ctx *session_ctx, struct ctrl_pkt_parser *ctrl_parser, raw_pkt_parser *raw_parser, int is_e2i_dir)
static void handle_policy_mutil_hits(struct policy_enforcer *enforcer, struct session_ctx *session_ctx, struct control_packet *ctrl_pkt, data_packet *data_pkt, int is_e2i_dir)
{
for (int i = 0; i < ctrl_parser->rule_id_num; i++)
for (int i = 0; i < ctrl_pkt->rule_id_num; i++)
{
uint64_t rule_id = ctrl_parser->rule_ids[i];
if (fixed_num_array_exist_elem(&session_ctx->rule_ids, rule_id))
uint64_t rule_id = ctrl_pkt->rule_ids[i];
if (mutable_array_exist_elem(&session_ctx->rule_ids, rule_id))
{
continue;
}
else
{
policy_enforce_select_chainings(enforcer, &session_ctx->chainings, session_ctx, raw_parser, rule_id, is_e2i_dir);
policy_enforce_select_chainings(enforcer, &session_ctx->chainings, session_ctx, data_pkt, rule_id, is_e2i_dir);
selected_chaining_bref(session_ctx->chainings.chaining_raw);
selected_chaining_bref(session_ctx->chainings.chaining_decrypted);
fixed_num_array_add_elem(&session_ctx->rule_ids, rule_id);
mutable_array_add_elem(&session_ctx->rule_ids, rule_id);
}
}
}
static void handle_session_opening(struct metadata *meta, struct ctrl_pkt_parser *ctrl_parser, struct thread_ctx *thread_ctx)
static void handle_session_opening(struct metadata *meta, struct control_packet *ctrl_pkt, struct thread_ctx *thread_ctx)
{
struct thread_metrics *thread_metrics = &thread_ctx->thread_metrics;
struct policy_enforcer *enforcer = thread_ctx->ref_enforcer;
@@ -832,11 +914,10 @@ static void handle_session_opening(struct metadata *meta, struct ctrl_pkt_parser
}
#endif
struct raw_pkt_parser raw_parser;
struct data_packet data_pkt;
struct addr_tuple4 inner_tuple4;
raw_packet_parser_init(&raw_parser, meta->session_id, LAYER_TYPE_ALL, 8);
const void *payload = raw_packet_parser_parse(&raw_parser, (const void *)meta->raw_data, meta->raw_len);
raw_packet_parser_get_most_inner_tuple4(&raw_parser, &inner_tuple4);
const void *payload = data_packet_parse(&data_pkt, (const void *)meta->raw_data, meta->raw_len, meta->session_id);
data_packet_get_innermost_tuple4(&data_pkt, &inner_tuple4);
uint16_t real_offset = (char *)payload - meta->raw_data;
if (real_offset != meta->l7offset)
{
@@ -855,14 +936,14 @@ static void handle_session_opening(struct metadata *meta, struct ctrl_pkt_parser
session_ctx->ref_thread_ctx = thread_ctx;
LOG_INFO("%s: session %lu %s active first", LOG_TAG_PKTIO, session_ctx->session_id, session_ctx->session_addr);
handle_policy_mutil_hits(enforcer, session_ctx, ctrl_parser, &raw_parser, meta->is_e2i_dir);
handle_policy_mutil_hits(enforcer, session_ctx, ctrl_pkt, &data_pkt, meta->is_e2i_dir);
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));
}
static void handle_session_closing(struct metadata *meta, struct ctrl_pkt_parser *ctrl_parser, struct thread_ctx *thread_ctx)
static void handle_session_closing(struct metadata *meta, struct control_packet *ctrl_pkt, struct thread_ctx *thread_ctx)
{
struct thread_metrics *thread_metrics = &thread_ctx->thread_metrics;
struct session_table *session_table = thread_ctx->session_table;
@@ -884,7 +965,7 @@ static void handle_session_closing(struct metadata *meta, struct ctrl_pkt_parser
}
}
static void handle_session_active(struct metadata *meta, struct ctrl_pkt_parser *ctrl_parser, struct thread_ctx *thread_ctx)
static void handle_session_active(struct metadata *meta, struct control_packet *ctrl_pkt, struct thread_ctx *thread_ctx)
{
struct session_table *session_table = thread_ctx->session_table;
struct policy_enforcer *enforcer = thread_ctx->ref_enforcer;
@@ -894,9 +975,8 @@ static void handle_session_active(struct metadata *meta, struct ctrl_pkt_parser
{
struct session_ctx *session_ctx = (struct session_ctx *)node->value;
struct raw_pkt_parser raw_parser;
raw_packet_parser_init(&raw_parser, meta->session_id, LAYER_TYPE_ALL, 8);
const void *payload = raw_packet_parser_parse(&raw_parser, (const void *)meta->raw_data, meta->raw_len);
struct data_packet data_pkt;
const void *payload = data_packet_parse(&data_pkt, (const void *)meta->raw_data, meta->raw_len, meta->session_id);
uint16_t real_offset = (char *)payload - meta->raw_data;
if (real_offset != meta->l7offset)
{
@@ -904,16 +984,16 @@ static void handle_session_active(struct metadata *meta, struct ctrl_pkt_parser
}
LOG_INFO("%s: session %lu %s active again", LOG_TAG_PKTIO, session_ctx->session_id, session_ctx->session_addr);
handle_policy_mutil_hits(enforcer, session_ctx, ctrl_parser, &raw_parser, meta->is_e2i_dir);
handle_policy_mutil_hits(enforcer, session_ctx, ctrl_pkt, &data_pkt, meta->is_e2i_dir);
send_event_log(session_ctx, thread_ctx);
}
else
{
handle_session_opening(meta, ctrl_parser, thread_ctx);
handle_session_opening(meta, ctrl_pkt, thread_ctx);
}
}
static void handle_session_resetall(struct metadata *meta, struct ctrl_pkt_parser *ctrl_parser, struct thread_ctx *thread_ctx)
static void handle_session_resetall(struct metadata *meta, struct control_packet *ctrl_pkt, struct thread_ctx *thread_ctx)
{
struct thread_metrics *thread_metrics = &thread_ctx->thread_metrics;
struct sce_ctx *sce_ctx = thread_ctx->ref_sce_ctx;
@@ -935,7 +1015,7 @@ static void handle_control_packet(marsio_buff_t *rx_buff, struct thread_ctx *thr
{
struct thread_metrics *thread_metrics = &thread_ctx->thread_metrics;
struct metadata meta;
struct ctrl_pkt_parser ctrl_parser;
struct control_packet ctrl_pkt;
if (mbuff_get_metadata(rx_buff, &meta) == -1)
{
@@ -943,37 +1023,36 @@ static void handle_control_packet(marsio_buff_t *rx_buff, struct thread_ctx *thr
goto error_ctrl_pkt;
}
ctrl_packet_parser_init(&ctrl_parser);
if (ctrl_packet_parser_parse(&ctrl_parser, meta.raw_data + meta.l7offset, meta.raw_len - meta.l7offset) == -1)
if (control_packet_parse(&ctrl_pkt, meta.raw_data + meta.l7offset, meta.raw_len - meta.l7offset) == -1)
{
LOG_ERROR("%s: unexpected control packet, unable to parse data", LOG_TAG_PKTIO);
goto error_ctrl_pkt;
}
if (ctrl_parser.session_id != meta.session_id)
if (ctrl_pkt.session_id != meta.session_id)
{
LOG_ERROR("%s: unexpected control packet, metadata's session %lu != control packet's session %lu", LOG_TAG_PKTIO, meta.session_id, ctrl_parser.session_id);
LOG_ERROR("%s: unexpected control packet, metadata's session %lu != control packet's session %lu", LOG_TAG_PKTIO, meta.session_id, ctrl_pkt.session_id);
goto error_ctrl_pkt;
}
switch (ctrl_parser.state)
switch (ctrl_pkt.state)
{
case SESSION_STATE_OPENING:
ATOMIC_INC(&(thread_metrics->ctrl_pkt.opening));
// when session opening, firewall not send policy id
// return handle_session_opening(&meta, &ctrl_parser, ctx);
// return handle_session_opening(&meta, &ctrl_pkt, ctx);
break;
case SESSION_STATE_CLOSING:
ATOMIC_INC(&(thread_metrics->ctrl_pkt.closing));
handle_session_closing(&meta, &ctrl_parser, thread_ctx);
handle_session_closing(&meta, &ctrl_pkt, thread_ctx);
break;
case SESSION_STATE_ACTIVE:
ATOMIC_INC(&(thread_metrics->ctrl_pkt.active));
handle_session_active(&meta, &ctrl_parser, thread_ctx);
handle_session_active(&meta, &ctrl_pkt, thread_ctx);
break;
case SESSION_STATE_RESETALL:
ATOMIC_INC(&(thread_metrics->ctrl_pkt.resetall));
handle_session_resetall(&meta, &ctrl_parser, thread_ctx);
handle_session_resetall(&meta, &ctrl_pkt, thread_ctx);
break;
default:
goto error_ctrl_pkt;
@@ -985,7 +1064,7 @@ error_ctrl_pkt:
return;
}
static void handle_raw_packet(marsio_buff_t *rx_buff, struct thread_ctx *thread_ctx)
static void handle_data_packet(marsio_buff_t *rx_buff, struct thread_ctx *thread_ctx)
{
struct session_table *session_table = thread_ctx->session_table;
struct thread_metrics *thread_metrics = &thread_ctx->thread_metrics;
@@ -1016,10 +1095,10 @@ static void handle_raw_packet(marsio_buff_t *rx_buff, struct thread_ctx *thread_
goto error_bypass;
}
session_ctx = raw_packet_search_session(session_table, meta.raw_data, meta.raw_len, meta.session_id);
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->raw_pkt.miss_sess), 1, meta.raw_len);
throughput_metrics_inc(&(thread_metrics->data_pkt.miss_sess), 1, meta.raw_len);
goto error_bypass;
}
@@ -1046,7 +1125,7 @@ error_bypass:
action_err_bypass(rx_buff, &meta, NULL, thread_ctx);
}
static void handle_inject_packet(marsio_buff_t *rx_buff, struct thread_ctx *thread_ctx)
static void handle_inject_vxlan_packet(marsio_buff_t *rx_buff, struct thread_ctx *thread_ctx)
{
struct session_table *session_table = thread_ctx->session_table;
struct thread_metrics *thread_metrics = &thread_ctx->thread_metrics;
@@ -1062,7 +1141,7 @@ static void handle_inject_packet(marsio_buff_t *rx_buff, struct thread_ctx *thre
char *raw_data = marsio_buff_mtod(rx_buff);
if (g_vxlan_decode(&g_vxlan_hdr, raw_data, raw_len) == -1)
{
throughput_metrics_inc(&(thread_metrics->device.endpoint_drop), 1, raw_len);
throughput_metrics_inc(&(thread_metrics->device.endpoint_vxlan_drop), 1, raw_len);
action_err_block(rx_buff, &meta, NULL, thread_ctx);
return;
}
@@ -1103,14 +1182,14 @@ static void handle_inject_packet(marsio_buff_t *rx_buff, struct thread_ctx *thre
{
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->raw_pkt.mirr_rx_drop), 1, meta.raw_len);
throughput_metrics_inc(&(thread_metrics->data_pkt.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->raw_pkt.stee_rx), 1, meta.raw_len);
throughput_metrics_inc(&(thread_metrics->data_pkt.stee_rx), 1, meta.raw_len);
sf_metrics_inc(thread_ctx->sf_metrics, sf->rule_vsys_id, sf->rule_id, sf->sff_profile_id, sf->sf_profile_id, 1, raw_len, 0, 0);
}
@@ -1119,7 +1198,7 @@ static void handle_inject_packet(marsio_buff_t *rx_buff, struct thread_ctx *thre
return;
error_block:
throughput_metrics_inc(&(thread_metrics->device.endpoint_drop), 1, raw_len);
throughput_metrics_inc(&(thread_metrics->device.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);
}
@@ -1140,11 +1219,15 @@ static int packet_io_config(const char *profile, struct config *config)
MESA_load_profile_int_def(profile, "PACKET_IO", "rx_burst_max", (int *)&(config->rx_burst_max), 1);
MESA_load_profile_int_def(profile, "PACKET_IO", "min_timeout_ms", (int *)&(config->min_timeout_ms), 900);
MESA_load_profile_string_nodef(profile, "PACKET_IO", "app_symbol", config->app_symbol, sizeof(config->app_symbol));
MESA_load_profile_string_nodef(profile, "PACKET_IO", "dev_endpoint", config->dev_endpoint, sizeof(config->dev_endpoint));
MESA_load_profile_string_nodef(profile, "PACKET_IO", "dev_nf_interface", config->dev_nf_interface, sizeof(config->dev_nf_interface));
MESA_load_profile_string_nodef(profile, "PACKET_IO", "dev_endpoint_src_ip", config->dev_endpoint_src_ip_str, sizeof(config->dev_endpoint_src_ip_str));
MESA_load_profile_string_nodef(profile, "PACKET_IO", "dev_endpoint_src_mac", config->dev_endpoint_src_mac_str, sizeof(config->dev_endpoint_src_mac_str));
MESA_load_profile_string_nodef(profile, "PACKET_IO", "dev_nf_name", config->dev_nf_name, sizeof(config->dev_nf_name));
MESA_load_profile_string_nodef(profile, "PACKET_IO", "dev_endpoint_l3_name", config->dev_endpoint_l3_name, sizeof(config->dev_endpoint_l3_name));
MESA_load_profile_string_nodef(profile, "PACKET_IO", "dev_endpoint_l3_ip", config->dev_endpoint_l3_ip_str, sizeof(config->dev_endpoint_l3_ip_str));
MESA_load_profile_string_nodef(profile, "PACKET_IO", "dev_endpoint_l3_mac", config->dev_endpoint_l3_mac_str, sizeof(config->dev_endpoint_l3_mac_str));
MESA_load_profile_string_nodef(profile, "PACKET_IO", "dev_endpoint_l2_name", config->dev_endpoint_l2_name, sizeof(config->dev_endpoint_l2_name));
MESA_load_profile_int_def(profile, "PACKET_IO", "vlan_encapsulate_replace_orig_vlan_header", (int *)&(config->vlan_encapsulate_replace_orig_vlan_header), 0);
if (config->rx_burst_max > RX_BURST_MAX)
{
@@ -1158,28 +1241,37 @@ static int packet_io_config(const char *profile, struct config *config)
return -1;
}
if (strlen(config->dev_endpoint) == 0)
if (strlen(config->dev_nf_name) == 0)
{
LOG_ERROR("%s: invalid dev_endpoint in %s", LOG_TAG_PKTIO, profile);
LOG_ERROR("%s: invalid dev_nf_name in %s", LOG_TAG_PKTIO, profile);
return -1;
}
if (strlen(config->dev_nf_interface) == 0)
if (strlen(config->dev_endpoint_l3_name) == 0)
{
LOG_ERROR("%s: invalid dev_nf_interface in %s", LOG_TAG_PKTIO, profile);
LOG_ERROR("%s: invalid dev_endpoint_l3_name in %s", LOG_TAG_PKTIO, profile);
return -1;
}
LOG_DEBUG("%s: PACKET_IO->bypass_traffic : %d", LOG_TAG_PKTIO, config->bypass_traffic);
LOG_DEBUG("%s: PACKET_IO->rx_burst_max : %d", LOG_TAG_PKTIO, config->rx_burst_max);
LOG_DEBUG("%s: PACKET_IO->min_timeout_ms : %d", LOG_TAG_PKTIO, config->min_timeout_ms);
LOG_DEBUG("%s: PACKET_IO->app_symbol : %s", LOG_TAG_PKTIO, config->app_symbol);
LOG_DEBUG("%s: PACKET_IO->dev_endpoint : %s", LOG_TAG_PKTIO, config->dev_endpoint);
LOG_DEBUG("%s: PACKET_IO->dev_nf_interface : %s", LOG_TAG_PKTIO, config->dev_nf_interface);
LOG_DEBUG("%s: PACKET_IO->dev_endpoint_src_ip : %s", LOG_TAG_PKTIO, config->dev_endpoint_src_ip_str);
if (strlen(config->dev_endpoint_src_mac_str))
if (strlen(config->dev_endpoint_l2_name) == 0)
{
LOG_DEBUG("%s: PACKET_IO->dev_endpoint_src_mac : %s (get from configuration file)", LOG_TAG_PKTIO, config->dev_endpoint_src_mac_str);
LOG_ERROR("%s: invalid dev_endpoint_l2_name in %s", LOG_TAG_PKTIO, profile);
return -1;
}
LOG_DEBUG("%s: PACKET_IO->bypass_traffic : %d", LOG_TAG_PKTIO, config->bypass_traffic);
LOG_DEBUG("%s: PACKET_IO->rx_burst_max : %d", LOG_TAG_PKTIO, config->rx_burst_max);
LOG_DEBUG("%s: PACKET_IO->min_timeout_ms : %d", LOG_TAG_PKTIO, config->min_timeout_ms);
LOG_DEBUG("%s: PACKET_IO->app_symbol : %s", LOG_TAG_PKTIO, config->app_symbol);
LOG_DEBUG("%s: PACKET_IO->dev_nf_name : %s", LOG_TAG_PKTIO, config->dev_nf_name);
LOG_DEBUG("%s: PACKET_IO->dev_endpoint_l3_name : %s", LOG_TAG_PKTIO, config->dev_endpoint_l3_name);
LOG_DEBUG("%s: PACKET_IO->dev_endpoint_l3_ip : %s", LOG_TAG_PKTIO, config->dev_endpoint_l3_ip_str);
LOG_DEBUG("%s: PACKET_IO->dev_endpoint_l2_name : %s", LOG_TAG_PKTIO, config->dev_endpoint_l2_name);
LOG_DEBUG("%s: PACKET_IO->vlan_encapsulate_replace_orig_vlan_header : %d", LOG_TAG_PKTIO, config->vlan_encapsulate_replace_orig_vlan_header);
if (strlen(config->dev_endpoint_l3_mac_str))
{
LOG_DEBUG("%s: PACKET_IO->dev_endpoint_l3_mac : %s (get from configuration file)", LOG_TAG_PKTIO, config->dev_endpoint_l3_mac_str);
}
return 0;
@@ -1222,41 +1314,55 @@ struct packet_io *packet_io_create(const char *profile, int thread_num, cpu_set_
goto error_out;
}
handle->dev_nf_interface.mr_dev = marsio_open_device(handle->instance, handle->config.dev_nf_interface, handle->thread_num, handle->thread_num);
if (handle->dev_nf_interface.mr_dev == NULL)
handle->dev_nf.mr_dev = marsio_open_device(handle->instance, handle->config.dev_nf_name, handle->thread_num, handle->thread_num);
if (handle->dev_nf.mr_dev == NULL)
{
LOG_ERROR("%s: unable to open device %s", LOG_TAG_PKTIO, handle->config.dev_nf_interface);
LOG_ERROR("%s: unable to open device %s", LOG_TAG_PKTIO, handle->config.dev_nf_name);
goto error_out;
}
handle->dev_nf_interface.mr_path = marsio_sendpath_create_by_vdev(handle->dev_nf_interface.mr_dev);
if (handle->dev_nf_interface.mr_path == NULL)
handle->dev_nf.mr_path = marsio_sendpath_create_by_vdev(handle->dev_nf.mr_dev);
if (handle->dev_nf.mr_path == NULL)
{
LOG_ERROR("%s: unable to create sendpath for device %s", LOG_TAG_PKTIO, handle->config.dev_nf_interface);
LOG_ERROR("%s: unable to create sendpath for device %s", LOG_TAG_PKTIO, handle->config.dev_nf_name);
goto error_out;
}
handle->dev_endpoint.mr_dev = marsio_open_device(handle->instance, handle->config.dev_endpoint, handle->thread_num, handle->thread_num);
if (handle->dev_endpoint.mr_dev == NULL)
handle->dev_endpoint_l3.mr_dev = marsio_open_device(handle->instance, handle->config.dev_endpoint_l3_name, handle->thread_num, handle->thread_num);
if (handle->dev_endpoint_l3.mr_dev == NULL)
{
LOG_ERROR("%s: unable to open device %s", LOG_TAG_PKTIO, handle->config.dev_endpoint);
LOG_ERROR("%s: unable to open device %s", LOG_TAG_PKTIO, handle->config.dev_endpoint_l3_name);
goto error_out;
}
handle->dev_endpoint.mr_path = marsio_sendpath_create_by_vdev(handle->dev_endpoint.mr_dev);
if (handle->dev_endpoint.mr_path == NULL)
handle->dev_endpoint_l3.mr_path = marsio_sendpath_create_by_vdev(handle->dev_endpoint_l3.mr_dev);
if (handle->dev_endpoint_l3.mr_path == NULL)
{
LOG_ERROR("%s: unable to create sendpath for device %s", LOG_TAG_PKTIO, handle->config.dev_endpoint);
LOG_ERROR("%s: unable to create sendpath for device %s", LOG_TAG_PKTIO, handle->config.dev_endpoint_l3_name);
goto error_out;
}
if (strlen(handle->config.dev_endpoint_src_mac_str) == 0)
handle->dev_endpoint_l2.mr_dev = marsio_open_device(handle->instance, handle->config.dev_endpoint_l2_name, handle->thread_num, handle->thread_num);
if (handle->dev_endpoint_l2.mr_dev == NULL)
{
marsio_get_device_ether_addr(handle->dev_endpoint.mr_dev, handle->config.dev_endpoint_src_mac_str, sizeof(handle->config.dev_endpoint_src_mac_str));
LOG_DEBUG("%s: PACKET_IO->dev_endpoint_src_mac : %s (get from marsio api)", LOG_TAG_PKTIO, handle->config.dev_endpoint_src_mac_str);
LOG_ERROR("%s: unable to open device %s", LOG_TAG_PKTIO, handle->config.dev_endpoint_l2_name);
goto error_out;
}
str_to_mac(handle->config.dev_endpoint_src_mac_str, handle->config.dev_endpoint_src_mac);
handle->config.dev_endpoint_src_ip = inet_addr(handle->config.dev_endpoint_src_ip_str);
handle->dev_endpoint_l2.mr_path = marsio_sendpath_create_by_vdev(handle->dev_endpoint_l2.mr_dev);
if (handle->dev_endpoint_l2.mr_path == NULL)
{
LOG_ERROR("%s: unable to create sendpath for device %s", LOG_TAG_PKTIO, handle->config.dev_endpoint_l2_name);
goto error_out;
}
if (strlen(handle->config.dev_endpoint_l3_mac_str) == 0)
{
marsio_get_device_ether_addr(handle->dev_endpoint_l3.mr_dev, handle->config.dev_endpoint_l3_mac_str, sizeof(handle->config.dev_endpoint_l3_mac_str));
LOG_DEBUG("%s: PACKET_IO->dev_endpoint_l3_mac : %s (get from marsio api)", LOG_TAG_PKTIO, handle->config.dev_endpoint_l3_mac_str);
}
str_to_mac(handle->config.dev_endpoint_l3_mac_str, handle->config.dev_endpoint_l3_mac);
handle->config.dev_endpoint_l3_ip = inet_addr(handle->config.dev_endpoint_l3_ip_str);
return handle;
@@ -1269,28 +1375,40 @@ void packet_io_destory(struct packet_io *handle)
{
if (handle)
{
if (handle->dev_nf_interface.mr_path)
if (handle->dev_nf.mr_path)
{
marsio_sendpath_destory(handle->dev_nf_interface.mr_path);
handle->dev_nf_interface.mr_path = NULL;
marsio_sendpath_destory(handle->dev_nf.mr_path);
handle->dev_nf.mr_path = NULL;
}
if (handle->dev_nf_interface.mr_dev)
if (handle->dev_nf.mr_dev)
{
marsio_close_device(handle->dev_nf_interface.mr_dev);
handle->dev_nf_interface.mr_dev = NULL;
marsio_close_device(handle->dev_nf.mr_dev);
handle->dev_nf.mr_dev = NULL;
}
if (handle->dev_endpoint.mr_path)
if (handle->dev_endpoint_l3.mr_path)
{
marsio_sendpath_destory(handle->dev_endpoint.mr_path);
handle->dev_endpoint.mr_path = NULL;
marsio_sendpath_destory(handle->dev_endpoint_l3.mr_path);
handle->dev_endpoint_l3.mr_path = NULL;
}
if (handle->dev_endpoint.mr_dev)
if (handle->dev_endpoint_l3.mr_dev)
{
marsio_close_device(handle->dev_endpoint.mr_dev);
handle->dev_endpoint.mr_dev = NULL;
marsio_close_device(handle->dev_endpoint_l3.mr_dev);
handle->dev_endpoint_l3.mr_dev = NULL;
}
if (handle->dev_endpoint_l2.mr_path)
{
marsio_sendpath_destory(handle->dev_endpoint_l2.mr_path);
handle->dev_endpoint_l2.mr_path = NULL;
}
if (handle->dev_endpoint_l2.mr_dev)
{
marsio_close_device(handle->dev_endpoint_l2.mr_dev);
handle->dev_endpoint_l2.mr_dev = NULL;
}
if (handle->instance)
@@ -1318,13 +1436,15 @@ int packet_io_thread_init(struct packet_io *handle, struct thread_ctx *thread_ct
void packet_io_thread_wait(struct packet_io *handle, struct thread_ctx *thread_ctx, int timeout_ms)
{
static __thread struct mr_vdev *vdevs[] = {
handle->dev_nf_interface.mr_dev,
handle->dev_endpoint.mr_dev};
handle->dev_nf.mr_dev,
handle->dev_endpoint_l3.mr_dev,
handle->dev_endpoint_l2.mr_dev,
};
int min_timeout_ms = MIN(handle->config.min_timeout_ms, timeout_ms);
if (min_timeout_ms > 0)
{
marsio_poll_wait(handle->instance, vdevs, 2, thread_ctx->thread_index, min_timeout_ms);
marsio_poll_wait(handle->instance, vdevs, 3, thread_ctx->thread_index, min_timeout_ms);
}
else
{
@@ -1338,7 +1458,7 @@ int packet_io_thread_polling_nf(struct packet_io *handle, struct thread_ctx *thr
int thread_index = thread_ctx->thread_index;
static __thread marsio_buff_t *rx_buffs[RX_BURST_MAX];
int nr_recv = marsio_recv_burst(handle->dev_nf_interface.mr_dev, thread_index, rx_buffs, handle->config.rx_burst_max);
int nr_recv = marsio_recv_burst(handle->dev_nf.mr_dev, thread_index, rx_buffs, handle->config.rx_burst_max);
if (nr_recv <= 0)
{
return 0;
@@ -1354,7 +1474,7 @@ int packet_io_thread_polling_nf(struct packet_io *handle, struct thread_ctx *thr
throughput_metrics_inc(&(thread_metrics->device.nf_tx), 1, raw_len);
}
marsio_send_burst(handle->dev_nf_interface.mr_path, thread_index, rx_buffs, nr_recv);
marsio_send_burst(handle->dev_nf.mr_path, thread_index, rx_buffs, nr_recv);
return nr_recv;
}
@@ -1371,7 +1491,7 @@ int packet_io_thread_polling_nf(struct packet_io *handle, struct thread_ctx *thr
throughput_metrics_inc(&(thread_metrics->kee_pkt.downlink_rx), 1, raw_len);
throughput_metrics_inc(&(thread_metrics->kee_pkt.downlink_tx), 1, raw_len);
marsio_send_burst(handle->dev_nf_interface.mr_path, thread_index, &rx_buff, 1);
marsio_send_burst(handle->dev_nf.mr_path, thread_index, &rx_buff, 1);
}
else if (marsio_buff_is_ctrlbuf(rx_buff))
{
@@ -1382,26 +1502,26 @@ int packet_io_thread_polling_nf(struct packet_io *handle, struct thread_ctx *thr
throughput_metrics_inc(&(thread_metrics->ctrl_pkt.tx), 1, raw_len);
handle_control_packet(rx_buff, thread_ctx);
marsio_send_burst(handle->dev_nf_interface.mr_path, thread_index, &rx_buff, 1);
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);
handle_raw_packet(rx_buff, thread_ctx);
handle_data_packet(rx_buff, thread_ctx);
}
}
return nr_recv;
}
int packet_io_thread_polling_endpoint(struct packet_io *handle, struct thread_ctx *thread_ctx)
int packet_io_thread_polling_endpoint_l3(struct packet_io *handle, struct thread_ctx *thread_ctx)
{
struct thread_metrics *thread_metrics = &thread_ctx->thread_metrics;
int thread_index = thread_ctx->thread_index;
static __thread marsio_buff_t *rx_buffs[RX_BURST_MAX];
int nr_recv = marsio_recv_burst(handle->dev_endpoint.mr_dev, thread_index, rx_buffs, handle->config.rx_burst_max);
int nr_recv = marsio_recv_burst(handle->dev_endpoint_l3.mr_dev, thread_index, rx_buffs, handle->config.rx_burst_max);
if (nr_recv <= 0)
{
return 0;
@@ -1413,11 +1533,11 @@ int packet_io_thread_polling_endpoint(struct packet_io *handle, struct thread_ct
{
int raw_len = marsio_buff_datalen(rx_buffs[j]);
throughput_metrics_inc(&(thread_metrics->device.endpoint_rx), 1, raw_len);
throughput_metrics_inc(&(thread_metrics->device.endpoint_tx), 1, raw_len);
throughput_metrics_inc(&(thread_metrics->device.endpoint_vxlan_rx), 1, raw_len);
throughput_metrics_inc(&(thread_metrics->device.endpoint_vxlan_tx), 1, raw_len);
}
marsio_send_burst(handle->dev_endpoint.mr_path, thread_index, rx_buffs, nr_recv);
marsio_send_burst(handle->dev_endpoint_l3.mr_path, thread_index, rx_buffs, nr_recv);
return nr_recv;
}
@@ -1428,7 +1548,7 @@ int packet_io_thread_polling_endpoint(struct packet_io *handle, struct thread_ct
if (is_uplink_keepalive_packet(rx_buff))
{
throughput_metrics_inc(&(thread_metrics->device.endpoint_rx), 1, 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);
@@ -1436,15 +1556,55 @@ int packet_io_thread_polling_endpoint(struct packet_io *handle, struct thread_ct
}
else
{
throughput_metrics_inc(&(thread_metrics->device.endpoint_rx), 1, raw_len);
throughput_metrics_inc(&(thread_metrics->device.endpoint_vxlan_rx), 1, raw_len);
handle_inject_packet(rx_buff, thread_ctx);
handle_inject_vxlan_packet(rx_buff, thread_ctx);
}
}
return nr_recv;
}
int packet_io_thread_polling_endpoint_l2(struct packet_io *handle, struct thread_ctx *thread_ctx)
{
struct thread_metrics *thread_metrics = &thread_ctx->thread_metrics;
int thread_index = thread_ctx->thread_index;
static __thread marsio_buff_t *rx_buffs[RX_BURST_MAX];
int nr_recv = marsio_recv_burst(handle->dev_endpoint_l2.mr_dev, thread_index, rx_buffs, handle->config.rx_burst_max);
if (nr_recv <= 0)
{
return 0;
}
if (handle->config.bypass_traffic == 1)
{
for (int j = 0; j < nr_recv; 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_tx), 1, raw_len);
}
marsio_send_burst(handle->dev_endpoint_l2.mr_path, thread_index, rx_buffs, nr_recv);
return nr_recv;
}
for (int j = 0; j < nr_recv; j++)
{
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);
marsio_buff_free(handle->instance, &rx_buff, 1, 0, thread_index);
}
return nr_recv;
}
struct mr_instance *packet_io_get_mr_instance(struct packet_io *handle)
{
if (handle)

110
platform/src/policy.cpp
View File

@@ -7,7 +7,7 @@
#include "global_metrics.h"
#include "health_check.h"
#include "raw_packet.h"
#include "data_packet.h"
#include "policy.h"
#include "utils.h"
#include "log.h"
@@ -800,24 +800,24 @@ static void sf_param_new_cb(const char *table_name, int table_id, const char *ke
}
if (0 == strcasecmp(item->valuestring, "layer2_switch"))
{
param->sf_connectivity.method = PACKAGE_METHOD_LAYER2_SWITCH;
param->sf_connectivity.method = ENCAPSULATE_METHOD_LAYER2_SWITCH;
}
else if (0 == strcasecmp(item->valuestring, "layer3_switch"))
{
param->sf_connectivity.method = PACKAGE_METHOD_LAYER3_SWITCH;
param->sf_connectivity.method = ENCAPSULATE_METHOD_LAYER3_SWITCH;
}
else if (0 == strcasecmp(item->valuestring, "vxlan_g"))
{
param->sf_connectivity.method = PACKAGE_METHOD_VXLAN_G;
param->sf_connectivity.method = ENCAPSULATE_METHOD_VXLAN_G;
}
else
{
LOG_ERROR("%s: unexpected sf profile: (invalid connectivity->method param) %s", LOG_TAG_POLICY, table_line);
goto error_out;
}
LOG_DEBUG("%s: parse sf profile: %d, connectivity->method: %s", LOG_TAG_POLICY, param->sf_profile_id, package_method_to_string(param->sf_connectivity.method));
LOG_DEBUG("%s: parse sf profile: %d, connectivity->method: %s", LOG_TAG_POLICY, param->sf_profile_id, encapsulate_method_to_string(param->sf_connectivity.method));
if (param->sf_connectivity.method == PACKAGE_METHOD_LAYER2_SWITCH || param->sf_connectivity.method == PACKAGE_METHOD_LAYER3_SWITCH)
if (param->sf_connectivity.method == ENCAPSULATE_METHOD_LAYER2_SWITCH || param->sf_connectivity.method == ENCAPSULATE_METHOD_LAYER3_SWITCH)
{
item = cJSON_GetObjectItem(root1, "int_vlan_tag");
if (!item || !cJSON_IsNumber(item))
@@ -837,7 +837,7 @@ static void sf_param_new_cb(const char *table_name, int table_id, const char *ke
param->sf_connectivity.ext_vlan_tag = item->valueint;
LOG_DEBUG("%s: parse sf profile: %d, connectivity->ext_vlan_tag: %d", LOG_TAG_POLICY, param->sf_profile_id, item->valueint);
}
else if (param->sf_connectivity.method == PACKAGE_METHOD_VXLAN_G)
else if (param->sf_connectivity.method == ENCAPSULATE_METHOD_VXLAN_G)
{
item = cJSON_GetObjectItem(root1, "dest_ip");
if (!item || !cJSON_IsString(item))
@@ -885,8 +885,8 @@ static void sf_param_new_cb(const char *table_name, int table_id, const char *ke
}
LOG_DEBUG("%s: parse sf profile: %d, health_check->method: %s", LOG_TAG_POLICY, param->sf_profile_id, item->valuestring);
if ((param->sf_health_check.method == HEALTH_CHECK_METHOD_BFD && param->sf_connectivity.method == PACKAGE_METHOD_VXLAN_G) ||
(param->sf_health_check.method == HEALTH_CHECK_METHOD_NONE && param->sf_connectivity.method == PACKAGE_METHOD_VXLAN_G))
if ((param->sf_health_check.method == HEALTH_CHECK_METHOD_BFD && param->sf_connectivity.method == ENCAPSULATE_METHOD_VXLAN_G) ||
(param->sf_health_check.method == HEALTH_CHECK_METHOD_NONE && param->sf_connectivity.method == ENCAPSULATE_METHOD_VXLAN_G))
{
memcpy(param->sf_health_check.address, param->sf_connectivity.dest_ip, strlen(param->sf_connectivity.dest_ip));
}
@@ -923,7 +923,10 @@ static void sf_param_new_cb(const char *table_name, int table_id, const char *ke
param->sf_health_check.retires = item->valueint;
LOG_DEBUG("%s: parse sf profile: %d, health_check->retires: %d", LOG_TAG_POLICY, param->sf_profile_id, item->valueint);
}
param->health_check_session_id = health_check_session_add(param->sf_profile_id, param->sf_vsys_id, &param->sf_health_check);
if (param->sf_connectivity.method != ENCAPSULATE_METHOD_LAYER2_SWITCH)
{
param->health_check_session_id = health_check_session_add(param->sf_profile_id, param->sf_vsys_id, &param->sf_health_check);
}
*ad = param;
LOG_INFO("%s: Add sf profile: %d", LOG_TAG_POLICY, param->sf_profile_id);
@@ -969,7 +972,10 @@ static void sf_param_free_cb(int table_id, void **ad, long argl, void *argp)
if ((__sync_sub_and_fetch(&param->sf_ref_cnt, 1) == 0))
{
health_check_session_del(param->health_check_session_id, param->sf_profile_id);
if (param->sf_connectivity.method != ENCAPSULATE_METHOD_LAYER2_SWITCH)
{
health_check_session_del(param->health_check_session_id, param->sf_profile_id);
}
LOG_INFO("%s: Del sf profile: %d", LOG_TAG_POLICY, param->sf_profile_id);
free(param);
param = NULL;
@@ -998,7 +1004,7 @@ static void sf_param_free(struct sf_param *param)
}
// After return must check array elem nums
static void select_sf_by_nearby_and_adminstatus(struct policy_enforcer *enforcer, struct sff_param *sff_param, struct fixed_num_array *array)
static void select_sf_by_nearby_and_adminstatus(struct policy_enforcer *enforcer, struct sff_param *sff_param, struct mutable_array *array)
{
char buffer[16];
struct sf_param *sf = NULL;
@@ -1022,7 +1028,7 @@ static void select_sf_by_nearby_and_adminstatus(struct policy_enforcer *enforcer
{
if (sf->sf_admin_status == ADMMIN_STATUS_ACTIVE)
{
fixed_num_array_add_elem(array, sff_param->sf_profile_ids[i]);
mutable_array_add_elem(array, sff_param->sf_profile_ids[i]);
}
}
}
@@ -1032,7 +1038,7 @@ static void select_sf_by_nearby_and_adminstatus(struct policy_enforcer *enforcer
{
if (sf->sf_admin_status == ADMMIN_STATUS_ACTIVE)
{
fixed_num_array_add_elem(array, sff_param->sf_profile_ids[i]);
mutable_array_add_elem(array, sff_param->sf_profile_ids[i]);
}
}
}
@@ -1041,7 +1047,7 @@ static void select_sf_by_nearby_and_adminstatus(struct policy_enforcer *enforcer
{
if (sf->sf_admin_status == ADMMIN_STATUS_ACTIVE)
{
fixed_num_array_add_elem(array, sff_param->sf_profile_ids[i]);
mutable_array_add_elem(array, sff_param->sf_profile_ids[i]);
}
}
sf_param_free(sf);
@@ -1051,7 +1057,7 @@ static void select_sf_by_nearby_and_adminstatus(struct policy_enforcer *enforcer
// return : SESSION_ACTION_BYPASS, not care selected_sf_profile_id
// return : SESSION_ACTION_BLOCK, not care selected_sf_profile_id
// return : SESSION_ACTION_FORWARD, care selected_sf_profile_id
static enum session_action select_sf_by_ldbc(struct policy_enforcer *enforcer, struct session_ctx *s_ctx, struct sff_param *sff_param, struct selected_sf *sf, struct fixed_num_array *array, uint64_t hash)
static enum session_action select_sf_by_ldbc(struct policy_enforcer *enforcer, struct session_ctx *s_ctx, struct sff_param *sff_param, struct selected_sf *sf, struct mutable_array *array, uint64_t hash)
{
struct thread_ctx *thread = (struct thread_ctx *)s_ctx->ref_thread_ctx;
struct thread_metrics *thread_metrics = &thread->thread_metrics;
@@ -1063,13 +1069,14 @@ static enum session_action select_sf_by_ldbc(struct policy_enforcer *enforcer, s
int sf_profile_index = 0;
int sf_profile_num = 0;
uint64_t health_check_session_id = 0;
enum encapsulate_method encap_method;
sf_profile_num = fixed_num_array_count_elem(array);
sf_profile_num = mutable_array_count_elem(array);
while (sf_profile_num)
{
sf_profile_index = (int)(hash % sf_profile_num);
sf_profile_id = fixed_num_array_index_elem(array, sf_profile_index);
sf_profile_id = mutable_array_index_elem(array, sf_profile_index);
memset(&buffer, 0, sizeof(buffer));
snprintf(buffer, sizeof(buffer), "%u", sf_profile_id);
@@ -1077,13 +1084,26 @@ static enum session_action select_sf_by_ldbc(struct policy_enforcer *enforcer, s
if (sf_param == NULL)
{
LOG_ERROR("%s: failed to get sf parameter of profile %d", LOG_TAG_POLICY, sf_profile_id);
fixed_num_array_del_elem(array, sf_profile_id);
mutable_array_del_elem(array, sf_profile_id);
continue;
}
health_check_session_id = sf_param->health_check_session_id;
encap_method = sf_param->sf_connectivity.method;
sf_param_free(sf_param);
memset(sf->sf_dst_mac, 0, sizeof(sf->sf_dst_mac));
// VLAN encapsulation not require health check
if (encap_method == ENCAPSULATE_METHOD_LAYER2_SWITCH)
{
ATOMIC_INC(&(thread_metrics->sf_status.active));
sf->sf_profile_id = sf_profile_id;
sf->sf_action_reason = ACTION_FORWAED_DUE_SELECTED_SF;
return SESSION_ACTION_FORWARD;
}
// VXLAN encapsulation require health check
if (health_check_session_get_mac(health_check_session_id, sf->sf_dst_mac) == 0)
{
ATOMIC_INC(&(thread_metrics->sf_status.active));
@@ -1098,8 +1118,8 @@ static enum session_action select_sf_by_ldbc(struct policy_enforcer *enforcer, s
if (sff_param->sff_exception.fail_action == FAILURE_ACTION_RE_DISPATCH)
{
fixed_num_array_del_elem(array, sf_profile_id);
sf_profile_num = fixed_num_array_count_elem(array);
mutable_array_del_elem(array, sf_profile_id);
sf_profile_num = mutable_array_count_elem(array);
if (sff_param->sff_exception.health_service_func_lt > 0 && sf_profile_num < sff_param->sff_exception.health_service_func_lt)
{
@@ -1248,17 +1268,17 @@ const char *action_reason_to_string(enum action_reason action_reason)
}
}
const char *package_method_to_string(enum package_method package_method)
const char *encapsulate_method_to_string(enum encapsulate_method encap_method)
{
switch (package_method)
switch (encap_method)
{
case PACKAGE_METHOD_NONE:
case ENCAPSULATE_METHOD_NONE:
return "none";
case PACKAGE_METHOD_LAYER2_SWITCH:
case ENCAPSULATE_METHOD_LAYER2_SWITCH:
return "layer2_switch";
case PACKAGE_METHOD_LAYER3_SWITCH:
case ENCAPSULATE_METHOD_LAYER3_SWITCH:
return "layer3_switch";
case PACKAGE_METHOD_VXLAN_G:
case ENCAPSULATE_METHOD_VXLAN_G:
return "vxlan_g";
default:
return "unknown";
@@ -1315,20 +1335,20 @@ void selected_chaining_dump(struct selected_chaining *chaining)
for (int i = 0; i < chaining->chaining_used; i++)
{
struct selected_sf *node = &(chaining->chaining[i]);
LOG_DEBUG("%s: session %lu %s selected_chaining->node[%d]->rule_id : %lu", LOG_TAG_POLICY, chaining->session_id, chaining->session_addr, i, node->rule_id);
LOG_DEBUG("%s: session %lu %s selected_chaining->node[%d]->traffic_type : %s", LOG_TAG_POLICY, chaining->session_id, chaining->session_addr, i, traffic_type_to_string(node->traffic_type));
LOG_DEBUG("%s: session %lu %s selected_chaining->node[%d]->rule_id : %lu", LOG_TAG_POLICY, chaining->session_id, chaining->session_addr, i, node->rule_id);
LOG_DEBUG("%s: session %lu %s selected_chaining->node[%d]->traffic_type : %s", LOG_TAG_POLICY, chaining->session_id, chaining->session_addr, i, traffic_type_to_string(node->traffic_type));
// sff
LOG_DEBUG("%s: session %lu %s selected_chaining->node[%d]->sff_profile_id : %d", LOG_TAG_POLICY, chaining->session_id, chaining->session_addr, i, node->sff_profile_id);
LOG_DEBUG("%s: session %lu %s selected_chaining->node[%d]->sff_forward_type : %s", LOG_TAG_POLICY, chaining->session_id, chaining->session_addr, i, forward_type_to_string(node->sff_forward_type));
LOG_DEBUG("%s: session %lu %s selected_chaining->node[%d]->sff_profile_id : %d", LOG_TAG_POLICY, chaining->session_id, chaining->session_addr, i, node->sff_profile_id);
LOG_DEBUG("%s: session %lu %s selected_chaining->node[%d]->sff_forward_type : %s", LOG_TAG_POLICY, chaining->session_id, chaining->session_addr, i, forward_type_to_string(node->sff_forward_type));
// sf
LOG_DEBUG("%s: session %lu %s selected_chaining->node[%d]->sf_profile_id : %d", LOG_TAG_POLICY, chaining->session_id, chaining->session_addr, i, node->sf_profile_id);
LOG_DEBUG("%s: session %lu %s selected_chaining->node[%d]->sf_need_skip : %d", LOG_TAG_POLICY, chaining->session_id, chaining->session_addr, i, node->sf_need_skip);
LOG_DEBUG("%s: session %lu %s selected_chaining->node[%d]->sf_action : %s", LOG_TAG_POLICY, chaining->session_id, chaining->session_addr, i, session_action_to_string(node->sf_action));
LOG_DEBUG("%s: session %lu %s selected_chaining->node[%d]->sf_action_reason : %s", LOG_TAG_POLICY, chaining->session_id, chaining->session_addr, i, action_reason_to_string(node->sf_action_reason));
LOG_DEBUG("%s: session %lu %s selected_chaining->node[%d]->sf_connectivity->package_method : %s", LOG_TAG_POLICY, chaining->session_id, chaining->session_addr, i, package_method_to_string(node->sf_connectivity.method));
LOG_DEBUG("%s: session %lu %s selected_chaining->node[%d]->sf_connectivity->int_vlan_tag : %d", LOG_TAG_POLICY, chaining->session_id, chaining->session_addr, i, node->sf_connectivity.int_vlan_tag);
LOG_DEBUG("%s: session %lu %s selected_chaining->node[%d]->sf_connectivity->ext_vlan_tag : %d", LOG_TAG_POLICY, chaining->session_id, chaining->session_addr, i, node->sf_connectivity.ext_vlan_tag);
LOG_DEBUG("%s: session %lu %s selected_chaining->node[%d]->sf_connectivity->dest_ip : %s", LOG_TAG_POLICY, chaining->session_id, chaining->session_addr, i, node->sf_connectivity.dest_ip);
LOG_DEBUG("%s: session %lu %s selected_chaining->node[%d]->sf_profile_id : %d", LOG_TAG_POLICY, chaining->session_id, chaining->session_addr, i, node->sf_profile_id);
LOG_DEBUG("%s: session %lu %s selected_chaining->node[%d]->sf_need_skip : %d", LOG_TAG_POLICY, chaining->session_id, chaining->session_addr, i, node->sf_need_skip);
LOG_DEBUG("%s: session %lu %s selected_chaining->node[%d]->sf_action : %s", LOG_TAG_POLICY, chaining->session_id, chaining->session_addr, i, session_action_to_string(node->sf_action));
LOG_DEBUG("%s: session %lu %s selected_chaining->node[%d]->sf_action_reason : %s", LOG_TAG_POLICY, chaining->session_id, chaining->session_addr, i, action_reason_to_string(node->sf_action_reason));
LOG_DEBUG("%s: session %lu %s selected_chaining->node[%d]->sf_connectivity->encapsulate_method : %s", LOG_TAG_POLICY, chaining->session_id, chaining->session_addr, i, encapsulate_method_to_string(node->sf_connectivity.method));
LOG_DEBUG("%s: session %lu %s selected_chaining->node[%d]->sf_connectivity->int_vlan_tag : %d", LOG_TAG_POLICY, chaining->session_id, chaining->session_addr, i, node->sf_connectivity.int_vlan_tag);
LOG_DEBUG("%s: session %lu %s selected_chaining->node[%d]->sf_connectivity->ext_vlan_tag : %d", LOG_TAG_POLICY, chaining->session_id, chaining->session_addr, i, node->sf_connectivity.ext_vlan_tag);
LOG_DEBUG("%s: session %lu %s selected_chaining->node[%d]->sf_connectivity->dest_ip : %s", LOG_TAG_POLICY, chaining->session_id, chaining->session_addr, i, node->sf_connectivity.dest_ip);
}
}
@@ -1585,13 +1605,13 @@ int policy_enforce_chaining_size(struct policy_enforcer *enforcer)
return enforcer->config.max_chaining_size;
}
void policy_enforce_select_chainings(struct policy_enforcer *enforcer, struct selected_chainings *chainings, struct session_ctx *s_ctx, struct raw_pkt_parser *parser, uint64_t rule_id, int dir_is_i2e)
void policy_enforce_select_chainings(struct policy_enforcer *enforcer, struct selected_chainings *chainings, struct session_ctx *s_ctx, struct data_packet *data_pkt, uint64_t rule_id, int dir_is_i2e)
{
uint64_t hash_value = 0;
char buffer[16] = {0};
struct sf_param *sf_param = NULL;
struct sff_param *sff_param = NULL;
struct fixed_num_array array = {0};
struct mutable_array array = {0};
struct chaining_param *chaining_param = NULL;
struct selected_chaining *chaining = NULL;
@@ -1638,10 +1658,10 @@ void policy_enforce_select_chainings(struct policy_enforcer *enforcer, struct se
item->sff_forward_type = sff_param->sff_forward_type;
memset(&array, 0, sizeof(array));
fixed_num_array_init(&array);
mutable_array_init(&array);
select_sf_by_nearby_and_adminstatus(enforcer, sff_param, &array);
LOG_DEBUG("%s: session %lu %s select sf from chaining rule %lu sff_profile %d, sf_profile_num (before filter: %d -> filter nearby/admin_status: %d)", LOG_TAG_POLICY, chaining->session_id, chaining->session_addr, rule_id, item->sff_profile_id, sff_param->sf_profile_ids_num, fixed_num_array_count_elem(&array));
if (fixed_num_array_count_elem(&array) == 0)
LOG_DEBUG("%s: session %lu %s select sf from chaining rule %lu sff_profile %d, sf_profile_num (before filter: %d -> filter nearby/admin_status: %d)", LOG_TAG_POLICY, chaining->session_id, chaining->session_addr, rule_id, item->sff_profile_id, sff_param->sf_profile_ids_num, mutable_array_count_elem(&array));
if (mutable_array_count_elem(&array) == 0)
{
switch (sff_param->sff_exception.fail_action)
{
@@ -1672,7 +1692,7 @@ void policy_enforce_select_chainings(struct policy_enforcer *enforcer, struct se
continue;
}
hash_value = raw_packet_parser_get_hash_value(parser, sff_param->sff_ldbc.method, dir_is_i2e);
hash_value = data_packet_get_hash(data_pkt, sff_param->sff_ldbc.method, dir_is_i2e);
item->sf_action = select_sf_by_ldbc(enforcer, s_ctx, sff_param, item, &array, hash_value);
if (item->sf_action != SESSION_ACTION_FORWARD)
{

2
platform/src/sce.cpp
View File

@@ -83,7 +83,7 @@ struct session_ctx *session_ctx_new()
struct session_ctx *session_ctx = (struct session_ctx *)calloc(1, sizeof(struct session_ctx));
assert(session_ctx != NULL);
fixed_num_array_init(&session_ctx->rule_ids);
mutable_array_init(&session_ctx->rule_ids);
session_ctx->decrypted_meta_i2e = metadata_new();
session_ctx->decrypted_meta_e2i = metadata_new();

8
platform/src/sf_metrics.cpp
View File

@@ -56,10 +56,10 @@ static void sf_metrics_parse_config(const char *profile, struct sf_metrics_confi
MESA_load_profile_int_def(profile, "METRICS", "telegraf_listen_port", &(config->telegraf_listen_port), 8300);
MESA_load_profile_string_def(profile, "METRICS", "telegraf_bind_address", config->telegraf_bind_address, sizeof(config->telegraf_bind_address), "127.0.0.1");
LOG_DEBUG("%s: METRICS->enable : %d", LOG_TAG_SF_METRICS, config->enable);
LOG_DEBUG("%s: METRICS->interval_s : %d", LOG_TAG_SF_METRICS, config->interval_s);
LOG_DEBUG("%s: METRICS->telegraf_listen_port : %d", LOG_TAG_SF_METRICS, config->telegraf_listen_port);
LOG_DEBUG("%s: METRICS->telegraf_bind_address : %s", LOG_TAG_SF_METRICS, config->telegraf_bind_address);
// LOG_DEBUG("%s: METRICS->enable : %d", LOG_TAG_SF_METRICS, config->enable);
// LOG_DEBUG("%s: METRICS->interval_s : %d", LOG_TAG_SF_METRICS, config->interval_s);
// LOG_DEBUG("%s: METRICS->telegraf_listen_port : %d", LOG_TAG_SF_METRICS, config->telegraf_listen_port);
// LOG_DEBUG("%s: METRICS->telegraf_bind_address : %s", LOG_TAG_SF_METRICS, config->telegraf_bind_address);
}
struct sf_metrics *sf_metrics_create(const char *profile)