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

TSG-13878 tsg-service-chaining-engine支持fieldstat2

Browse Source
This commit is contained in:
luwenpeng
2023-02-21 09:58:31 +08:00
parent b1abe96b06
commit 823490bcd1
20 changed files with 555 additions and 204 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
ci/travis.sh
View File

@@ -38,6 +38,7 @@ yum install -y mrzcpd
yum install -y libmaatframe-devel
yum install -y libMESA_handle_logger-devel
yum install -y libMESA_prof_load-devel
yum install -y libMESA_field_stat2-devel
yum install -y librulescan-devel
yum install -y sapp-devel # Maat_rule require MESA/stream.h
yum install -y libasan

6
common/include/g_vxlan.h
View File

@@ -19,7 +19,7 @@ struct g_vxlan
unsigned int dir_is_e2i : 1;
unsigned int traffic_is_decrypted : 1;
unsigned int next_sf_index : 5; // max value 32
unsigned int sf_index : 5; // max value 32
unsigned int online_test : 1;
// Reserved 1 Bytes
@@ -34,11 +34,11 @@ struct g_vxlan
} __attribute__((__packed__));
void g_vxlan_set_packet_dir(struct g_vxlan *hdr, int dir_is_e2i);
void g_vxlan_set_next_sf_index(struct g_vxlan *hdr, int next_sf_index);
void g_vxlan_set_sf_index(struct g_vxlan *hdr, int sf_index);
void g_vxlan_set_traffic_type(struct g_vxlan *hdr, int traffic_is_decrypted);
int g_vxlan_get_packet_dir(struct g_vxlan *hdr);
int g_vxlan_get_next_sf_index(struct g_vxlan *hdr);
int g_vxlan_get_sf_index(struct g_vxlan *hdr);
int g_vxlan_get_traffic_type(struct g_vxlan *hdr);
// return 0 : success

62
common/include/log.h
View File

@@ -7,6 +7,7 @@ extern "C"
#endif
#include <stdio.h>
#include <pthread.h>
#include <MESA/MESA_handle_logger.h>
extern void *g_default_logger;
@@ -15,31 +16,50 @@ int LOG_INIT(const char *profile);
void LOG_CLOSE(void);
void LOG_RELOAD(void);
#define LOG_DEBUG(format, ...) \
do \
{ \
if (g_default_logger) \
MESA_handle_runtime_log(g_default_logger, RLOG_LV_DEBUG, __FUNCTION__, format, ##__VA_ARGS__); \
else \
fprintf(stdout, "DEBUG " format "\n", ##__VA_ARGS__); \
// __FUNCTION__
#define LOG_DEBUG(format, ...) \
do \
{ \
if (g_default_logger) \
{ \
char __tid_buff[16] = {0}; \
snprintf(__tid_buff, 16, "tid:%ld", pthread_self()); \
MESA_handle_runtime_log(g_default_logger, RLOG_LV_DEBUG, __tid_buff, format, ##__VA_ARGS__); \
} \
else \
{ \
fprintf(stdout, "DEBUG " format "\n", ##__VA_ARGS__); \
} \
} while (0)
#define LOG_INFO(format, ...) \
do \
{ \
if (g_default_logger) \
MESA_handle_runtime_log(g_default_logger, RLOG_LV_INFO, __FUNCTION__, format, ##__VA_ARGS__); \
else \
fprintf(stdout, "INFO " format "\n", ##__VA_ARGS__); \
#define LOG_INFO(format, ...) \
do \
{ \
if (g_default_logger) \
{ \
char __tid_buff[16] = {0}; \
snprintf(__tid_buff, 16, "tid:%ld", pthread_self()); \
MESA_handle_runtime_log(g_default_logger, RLOG_LV_INFO, __tid_buff, format, ##__VA_ARGS__); \
} \
else \
{ \
fprintf(stdout, "INFOR " format "\n", ##__VA_ARGS__); \
} \
} while (0)
#define LOG_ERROR(format, ...) \
do \
{ \
if (g_default_logger) \
MESA_handle_runtime_log(g_default_logger, RLOG_LV_FATAL, __FUNCTION__, format, ##__VA_ARGS__); \
else \
fprintf(stderr, "ERROR " format "\n", ##__VA_ARGS__); \
#define LOG_ERROR(format, ...) \
do \
{ \
if (g_default_logger) \
{ \
char __tid_buff[16] = {0}; \
snprintf(__tid_buff, 16, "tid:%ld", pthread_self()); \
MESA_handle_runtime_log(g_default_logger, RLOG_LV_FATAL, __tid_buff, format, ##__VA_ARGS__); \
} \
else \
{ \
fprintf(stderr, "ERROR " format "\n", ##__VA_ARGS__); \
} \
} while (0)
#ifdef __cpluscplus

5
common/src/ctrl_packet.cpp
View File

@@ -1,4 +1,5 @@
#include <string.h>
#include <stdlib.h>
#include <cjson/cJSON.h>
#include "log.h"
@@ -54,12 +55,12 @@ int ctrl_packet_parser_parse(struct ctrl_pkt_parser *handler, const char *data,
// session_id
item = cJSON_GetObjectItem(json, "session_id");
if (!item || !cJSON_IsNumber(item))
if (!item || !cJSON_IsString(item))
{
LOG_ERROR("%s: unexpected control packet: (invalid session_id format) %s", LOG_TAG_CTRLPKT, data);
goto error_out;
}
handler->session_id = item->valueint;
handler->session_id = atoll(item->valuestring);
// state
item = cJSON_GetObjectItem(json, "state");

8
common/src/g_vxlan.cpp
View File

@@ -9,9 +9,9 @@ void g_vxlan_set_packet_dir(struct g_vxlan *hdr, int dir_is_e2i)
hdr->dir_is_e2i = (!!dir_is_e2i);
}
void g_vxlan_set_next_sf_index(struct g_vxlan *hdr, int next_sf_index)
void g_vxlan_set_sf_index(struct g_vxlan *hdr, int sf_index)
{
hdr->next_sf_index = (0x1f & next_sf_index);
hdr->sf_index = (0x1f & sf_index);
}
void g_vxlan_set_traffic_type(struct g_vxlan *hdr, int traffic_is_decrypted)
@@ -24,9 +24,9 @@ int g_vxlan_get_packet_dir(struct g_vxlan *hdr)
return (!!hdr->dir_is_e2i);
}
int g_vxlan_get_next_sf_index(struct g_vxlan *hdr)
int g_vxlan_get_sf_index(struct g_vxlan *hdr)
{
return hdr->next_sf_index;
return hdr->sf_index;
}
int g_vxlan_get_traffic_type(struct g_vxlan *hdr)

2
common/src/raw_packet.cpp
View File

@@ -392,7 +392,7 @@ uint64_t raw_packet_parser_get_hash_value(struct raw_pkt_parser *handler, enum l
char *inner_addr_str = addr_tuple4_to_str(&inner_addr);
char *outer_addr_str = addr_tuple4_to_str(&outer_addr);
LOG_ERROR("%s: pkt_trace_id: %lu, outer_addr: %s, inner_addr: %s, is_internal: %d, hash_method: %s, hash_value: %lu",
LOG_DEBUG("%s: pkt_trace_id: %lu, outer_addr: %s, inner_addr: %s, is_internal: %d, hash_method: %s, hash_value: %lu",
LOG_TAG_RAWPKT, handler->pkt_trace_id, outer_addr_str, inner_addr_str, dir_is_internal, ldbc_method_to_string(method), hash_value);
free(inner_addr_str);
free(outer_addr_str);

16
conf/sce.conf
View File

@@ -10,7 +10,7 @@ perf_switch=1
scan_detail=0
deferred_load=0
effect_interval_ms=1000
stat_file=log/sce.fs2
stat_file=log/maat.fs2
table_info=resource/table_info.conf
accept_path=/opt/tsg/etc/tsg_device_tag.json
inc_cfg_dir=resource/inc/
@@ -30,6 +30,18 @@ app_symbol=sce
dev_endpoint=eth_sf_endpoint
dev_nf_interface=eth_nf_interface
default_src_ip=192.168.100.1
default_dst_ip=192.168.100.2
default_src_mac=aa:aa:aa:aa:aa:aa
# only used for bypass_all_traffic=2
default_dst_ip=192.168.100.2
default_dst_mac=bb:bb:bb:bb:bb:bb
[stat]
output_file=log/sce.fs2
statsd_server=127.0.0.1
statsd_port=8100
# 1 : FS_OUTPUT_STATSD
# 2 : FS_OUTPUT_INFLUX_LINE
statsd_format=1
statsd_cycle=2
prometheus_listen_port=9001
prometheus_listen_url=/sce_prometheus

3
platform/CMakeLists.txt
View File

@@ -1,7 +1,8 @@
add_library(platform src/policy.cpp src/health_check.cpp src/sce.cpp src/packet_io.cpp)
add_library(platform src/policy.cpp src/health_check.cpp src/sce.cpp src/packet_io.cpp src/global_metrics.cpp)
target_link_libraries(platform PUBLIC common)
target_link_libraries(platform PUBLIC pthread)
target_link_libraries(platform PUBLIC MESA_prof_load)
target_link_libraries(platform PUBLIC MESA_field_stat)
target_link_libraries(platform PUBLIC maatframe)
target_link_libraries(platform PUBLIC mrzcpd)
target_link_libraries(platform PUBLIC cjson)

54
platform/include/global_metrics.h Normal file
View File

@@ -0,0 +1,54 @@
#ifndef _GLOBAL_METRICS_H
#define _GLOBAL_METRICS_H
#ifdef __cpluscplus
extern "C"
{
#endif
#include "utils.h"
#include <MESA/field_stat2.h>
struct global_metrics_config
{
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];
};
struct global_metrics
{
struct throughput_metrics dev_endpoint_rx; // 累计值
struct throughput_metrics dev_endpoint_tx; // 累计值
struct throughput_metrics dev_endpoint_err_drop; // 累计值
struct throughput_metrics dev_nf_interface_rx; // 累计值
struct throughput_metrics dev_nf_interface_tx; // 累计值
struct throughput_metrics dev_nf_interface_err_bypass; // 累计值
struct throughput_metrics hit_block_policy; // 累计值
struct throughput_metrics hit_bypass_policy; // 累计值
struct throughput_metrics control_packet_rx; // 累计值
uint64_t session_nums; // 瞬时值
struct global_metrics_config config;
screen_stat_handle_t fs_handle;
int fs_id[32];
};
struct global_metrics *global_metrics_create(const char *profile);
void global_metrics_destory(struct global_metrics *metrics);
void global_metrics_dump(struct global_metrics *metrics);
#ifdef __cpluscplus
}
#endif
#endif

4
platform/include/health_check.h
View File

@@ -28,10 +28,6 @@ int health_check_session_get_status(int session_id);
// return -1 : key not exist
int health_check_session_set_status(int session_id, int is_active);
// return 0 : success
// return -1 : key not exist
int health_check_session_get_ip(int session_id, char *ip_buff);
// return 0 : success
// return -1 : key not exist
int health_check_session_get_mac(int session_id, char *mac_buff);

2
platform/include/policy.h
View File

@@ -79,6 +79,7 @@ struct connectivity
int int_vlan_tag;
int ext_vlan_tag;
char dest_ip[64];
char dest_mac[32]; // CM does not send this field, but only reads it from json, which is used for debugging
};
struct selected_sf
@@ -124,6 +125,7 @@ void selected_chaining_destory(struct selected_chaining *chaining);
void selected_chaining_dump(struct selected_chaining *chaining);
void selected_chaining_bref(struct selected_chaining *chaining);
const char *session_action_reason_to_string(enum session_action_reason session_action_reason);
void policy_enforce_select_chaining(struct selected_chaining *chaining, struct policy_enforcer *enforcer, struct raw_pkt_parser *parser, int policy_id, int dir_is_internal);
#ifdef __cpluscplus

27
platform/include/sce.h
View File

@@ -6,42 +6,17 @@ extern "C"
{
#endif
#include "utils.h"
#include "policy.h"
#include "packet_io.h"
#include "session_table.h"
/******************************************************************************
* Struct For Global
******************************************************************************/
struct global_metrics
{
struct throughput_metrics dev_endpoint_rx; // 累计值
struct throughput_metrics dev_endpoint_tx; // 累计值
struct throughput_metrics dev_endpoint_err_drop; // 累计值
struct throughput_metrics dev_nf_interface_rx; // 累计值
struct throughput_metrics dev_nf_interface_tx; // 累计值
struct throughput_metrics dev_nf_interface_err_bypass; // 累计值
struct throughput_metrics hit_block_policy; // 累计值
struct throughput_metrics hit_bypass_policy; // 累计值
uint64_t session_nums; // 瞬时值
};
struct global_metrics *global_metrics_create();
void global_metrics_destory(struct global_metrics *metrics);
void global_metrics_dump(struct global_metrics *metrics);
/******************************************************************************
* Struct For Thread
******************************************************************************/
struct thread_ctx
{
pthread_t tid;
pthread_t tid;
int thread_index;
struct session_table *session_table;

219
platform/src/global_metrics.cpp Normal file
View File

@@ -0,0 +1,219 @@
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <MESA/MESA_prof_load.h>
#include "log.h"
#include "global_metrics.h"
enum SCE_STAT_FIELD
{
// dev endpoint
STAT_ENDPOINT_RX_PKT,
STAT_ENDPOINT_RX_B,
STAT_ENDPOINT_TX_PKT,
STAT_ENDPOINT_TX_B,
STAT_ENDPOINT_ERR_DROP_PKT,
STAT_ENDPOINT_ERR_DROP_B,
// hit block policy
STAT_HIT_BLOCK_POLICY_PKT,
STAT_HIT_BLOCK_POLICY_B,
// dev nf interface
STAT_NF_INTERFACE_RX_PKT,
STAT_NF_INTERFACE_RX_B,
STAT_NF_INTERFACE_TX_PKT,
STAT_NF_INTERFACE_TX_B,
STAT_NF_INTERFACE_ERR_BYPASS_PKT,
STAT_NF_INTERFACE_ERR_BYPASS_B,
// hit bypass policy
STAT_HIT_BYPASS_POLICY_PKT,
STAT_HIT_BYPASS_POLICY_B,
// control packet
STAT_CONTROL_RX_PKT,
STAT_CONTROL_RX_B,
// current session number
STAT_CURRENT_SESSION_NUMS,
// max
STAT_MAX,
};
static const char *stat_map[] =
{
// dev endpoint
[STAT_ENDPOINT_RX_PKT] = "endp_rx_pkt",
[STAT_ENDPOINT_RX_B] = "endp_rx_B",
[STAT_ENDPOINT_TX_PKT] = "endp_tx_pkt",
[STAT_ENDPOINT_TX_B] = "endp_tx_B",
[STAT_ENDPOINT_ERR_DROP_PKT] = "endp_e_drop_pkt",
[STAT_ENDPOINT_ERR_DROP_B] = "endp_e_drop_B",
// hit block policy
[STAT_HIT_BLOCK_POLICY_PKT] = "hit_block_pkt",
[STAT_HIT_BLOCK_POLICY_B] = "hit_block_B",
// dev nf interface
[STAT_NF_INTERFACE_RX_PKT] = "nf_rx_pkt",
[STAT_NF_INTERFACE_RX_B] = "nf_rx_B",
[STAT_NF_INTERFACE_TX_PKT] = "nf_tx_pkt",
[STAT_NF_INTERFACE_TX_B] = "nf_tx_B",
[STAT_NF_INTERFACE_ERR_BYPASS_PKT] = "nf_e_bypass_pkt",
[STAT_NF_INTERFACE_ERR_BYPASS_B] = "nf_e_bypass_B",
// hit bypass policy
[STAT_HIT_BYPASS_POLICY_PKT] = "hit_bypass_pkt",
[STAT_HIT_BYPASS_POLICY_B] = "hit_bypass_B",
// control packet
[STAT_CONTROL_RX_PKT] = "ctrl_rx_pkt",
[STAT_CONTROL_RX_B] = "ctrl_rx_B",
// current session number
[STAT_CURRENT_SESSION_NUMS] = "curr_sess_num",
[STAT_MAX] = NULL};
static void global_metrics_parse_config(const char *profile, struct global_metrics_config *config)
{
MESA_load_profile_string_def(profile, "STAT", "output_file", config->output_file, sizeof(config->output_file), "log/sce.fs2");
MESA_load_profile_string_def(profile, "STAT", "statsd_server", config->statsd_server, sizeof(config->statsd_server), "127.0.0.1");
MESA_load_profile_int_def(profile, "STAT", "statsd_port", &(config->statsd_port), 8100);
MESA_load_profile_int_def(profile, "STAT", "statsd_format", &(config->statsd_format), 1); // FS_OUTPUT_STATSD=1, FS_OUTPUT_INFLUX_LINE=2
MESA_load_profile_int_def(profile, "STAT", "statsd_cycle", &(config->statsd_cycle), 1);
MESA_load_profile_int_def(profile, "STAT", "prometheus_listen_port", &(config->prometheus_listen_port), 9001);
MESA_load_profile_string_def(profile, "STAT", "prometheus_listen_url", config->prometheus_listen_url, sizeof(config->prometheus_listen_url), "/sce_prometheus");
if (config->statsd_format != 1 && config->statsd_format != 2)
{
config->statsd_format = 1;
}
LOG_DEBUG("%s: STAT->output_file : %s", LOG_TAG_METRICS, config->output_file);
LOG_DEBUG("%s: STAT->statsd_server : %s", LOG_TAG_METRICS, config->statsd_server);
LOG_DEBUG("%s: STAT->statsd_port : %d", LOG_TAG_METRICS, config->statsd_port);
LOG_DEBUG("%s: STAT->statsd_format : %d", LOG_TAG_METRICS, config->statsd_format);
LOG_DEBUG("%s: STAT->statsd_cycle : %d", LOG_TAG_METRICS, config->statsd_cycle);
LOG_DEBUG("%s: STAT->prometheus_listen_port : %d", LOG_TAG_METRICS, config->prometheus_listen_port);
LOG_DEBUG("%s: STAT->prometheus_listen_url : %s", LOG_TAG_METRICS, config->prometheus_listen_url);
}
struct global_metrics *global_metrics_create(const char *profile)
{
struct global_metrics *metrics = (struct global_metrics *)calloc(1, sizeof(struct global_metrics));
assert(metrics != NULL);
global_metrics_parse_config(profile, &metrics->config);
FS_library_set_prometheus_port(metrics->config.prometheus_listen_port);
FS_library_set_prometheus_url_path(metrics->config.prometheus_listen_url);
FS_library_init();
int value = 0;
metrics->fs_handle = FS_create_handle(); // TODO memleak no free() API
FS_set_para(metrics->fs_handle, APP_NAME, "SCE", 3);
FS_set_para(metrics->fs_handle, OUTPUT_DEVICE, metrics->config.output_file, strlen(metrics->config.output_file));
value = 1;
FS_set_para(metrics->fs_handle, OUTPUT_PROMETHEUS, &value, sizeof(value));
value = 1;
FS_set_para(metrics->fs_handle, PRINT_MODE, &value, sizeof(value));
value = 0;
FS_set_para(metrics->fs_handle, CREATE_THREAD, &value, sizeof(value));
if (strlen(metrics->config.statsd_server) > 0 && metrics->config.statsd_port != 0)
{
FS_set_para(metrics->fs_handle, STATS_SERVER_IP, metrics->config.statsd_server, strlen(metrics->config.statsd_server));
FS_set_para(metrics->fs_handle, STATS_SERVER_PORT, &(metrics->config.statsd_port), sizeof(metrics->config.statsd_port));
FS_set_para(metrics->fs_handle, STATS_FORMAT, &metrics->config.statsd_format, sizeof(metrics->config.statsd_format));
}
for (int i = 0; i < STAT_MAX; i++)
{
metrics->fs_id[i] = FS_register(metrics->fs_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, stat_map[i]);
}
FS_start(metrics->fs_handle);
return metrics;
}
void global_metrics_destory(struct global_metrics *metrics)
{
if (metrics)
{
FS_library_destroy();
free(metrics);
metrics = NULL;
}
}
void global_metrics_dump(struct global_metrics *metrics)
{
if (strlen(metrics->config.statsd_server) == 0)
{
LOG_INFO("%s: dev_endpoint_rx : n_pkts : %6lu, n_bytes: %6lu", LOG_TAG_METRICS, metrics->dev_endpoint_rx.n_pkts, metrics->dev_endpoint_rx.n_bytes);
LOG_INFO("%s: dev_endpoint_tx : n_pkts : %6lu, n_bytes: %6lu", LOG_TAG_METRICS, metrics->dev_endpoint_tx.n_pkts, metrics->dev_endpoint_tx.n_bytes);
LOG_INFO("%s: dev_endpoint_err_drop : n_pkts : %6lu, n_bytes: %6lu", LOG_TAG_METRICS, metrics->dev_endpoint_err_drop.n_pkts, metrics->dev_endpoint_err_drop.n_bytes);
LOG_INFO("%s: dev_nf_interface_rx : n_pkts : %6lu, n_bytes: %6lu", LOG_TAG_METRICS, metrics->dev_nf_interface_rx.n_pkts, metrics->dev_nf_interface_rx.n_bytes);
LOG_INFO("%s: dev_nf_interface_tx : n_pkts : %6lu, n_bytes: %6lu", LOG_TAG_METRICS, metrics->dev_nf_interface_tx.n_pkts, metrics->dev_nf_interface_tx.n_bytes);
LOG_INFO("%s: dev_nf_interface_err_bypass : n_pkts : %6lu, n_bytes: %6lu", LOG_TAG_METRICS, metrics->dev_nf_interface_err_bypass.n_pkts, metrics->dev_nf_interface_err_bypass.n_bytes);
LOG_INFO("%s: hit_block_policy : n_pkts : %6lu, n_bytes: %6lu", LOG_TAG_METRICS, metrics->hit_block_policy.n_pkts, metrics->hit_block_policy.n_bytes);
LOG_INFO("%s: hit_bypass_policy : n_pkts : %6lu, n_bytes: %6lu", LOG_TAG_METRICS, metrics->hit_bypass_policy.n_pkts, metrics->hit_bypass_policy.n_bytes);
LOG_INFO("%s: control_packet : n_pkts : %6lu, n_bytes: %6lu", LOG_TAG_METRICS, metrics->control_packet_rx.n_pkts, metrics->control_packet_rx.n_bytes);
LOG_INFO("%s: current_session_num : %6lu", LOG_TAG_METRICS, metrics->session_nums);
}
// dev endpoint
FS_operate(metrics->fs_handle, metrics->fs_id[STAT_ENDPOINT_RX_PKT], 0, FS_OP_SET, __atomic_fetch_add(&(metrics->dev_endpoint_rx.n_pkts), 0, __ATOMIC_RELAXED));
FS_operate(metrics->fs_handle, metrics->fs_id[STAT_ENDPOINT_RX_B], 0, FS_OP_SET, __atomic_fetch_add(&(metrics->dev_endpoint_rx.n_bytes), 0, __ATOMIC_RELAXED));
FS_operate(metrics->fs_handle, metrics->fs_id[STAT_ENDPOINT_TX_PKT], 0, FS_OP_SET, __atomic_fetch_add(&(metrics->dev_endpoint_tx.n_pkts), 0, __ATOMIC_RELAXED));
FS_operate(metrics->fs_handle, metrics->fs_id[STAT_ENDPOINT_TX_B], 0, FS_OP_SET, __atomic_fetch_add(&(metrics->dev_endpoint_tx.n_bytes), 0, __ATOMIC_RELAXED));
FS_operate(metrics->fs_handle, metrics->fs_id[STAT_ENDPOINT_ERR_DROP_PKT], 0, FS_OP_SET, __atomic_fetch_add(&(metrics->dev_endpoint_err_drop.n_pkts), 0, __ATOMIC_RELAXED));
FS_operate(metrics->fs_handle, metrics->fs_id[STAT_ENDPOINT_ERR_DROP_B], 0, FS_OP_SET, __atomic_fetch_add(&(metrics->dev_endpoint_err_drop.n_bytes), 0, __ATOMIC_RELAXED));
// hit policy
FS_operate(metrics->fs_handle, metrics->fs_id[STAT_HIT_BLOCK_POLICY_PKT], 0, FS_OP_SET, __atomic_fetch_add(&(metrics->hit_block_policy.n_pkts), 0, __ATOMIC_RELAXED));
FS_operate(metrics->fs_handle, metrics->fs_id[STAT_HIT_BLOCK_POLICY_B], 0, FS_OP_SET, __atomic_fetch_add(&(metrics->hit_block_policy.n_bytes), 0, __ATOMIC_RELAXED));
// dev nf interface
FS_operate(metrics->fs_handle, metrics->fs_id[STAT_NF_INTERFACE_RX_PKT], 0, FS_OP_SET, __atomic_fetch_add(&(metrics->dev_nf_interface_rx.n_pkts), 0, __ATOMIC_RELAXED));
FS_operate(metrics->fs_handle, metrics->fs_id[STAT_NF_INTERFACE_RX_B], 0, FS_OP_SET, __atomic_fetch_add(&(metrics->dev_nf_interface_rx.n_bytes), 0, __ATOMIC_RELAXED));
FS_operate(metrics->fs_handle, metrics->fs_id[STAT_NF_INTERFACE_TX_PKT], 0, FS_OP_SET, __atomic_fetch_add(&(metrics->dev_nf_interface_tx.n_pkts), 0, __ATOMIC_RELAXED));
FS_operate(metrics->fs_handle, metrics->fs_id[STAT_NF_INTERFACE_TX_B], 0, FS_OP_SET, __atomic_fetch_add(&(metrics->dev_nf_interface_tx.n_bytes), 0, __ATOMIC_RELAXED));
FS_operate(metrics->fs_handle, metrics->fs_id[STAT_NF_INTERFACE_ERR_BYPASS_PKT], 0, FS_OP_SET, __atomic_fetch_add(&(metrics->dev_nf_interface_err_bypass.n_pkts), 0, __ATOMIC_RELAXED));
FS_operate(metrics->fs_handle, metrics->fs_id[STAT_NF_INTERFACE_ERR_BYPASS_B], 0, FS_OP_SET, __atomic_fetch_add(&(metrics->dev_nf_interface_err_bypass.n_bytes), 0, __ATOMIC_RELAXED));
// hit bypass policy
FS_operate(metrics->fs_handle, metrics->fs_id[STAT_HIT_BYPASS_POLICY_PKT], 0, FS_OP_SET, __atomic_fetch_add(&(metrics->hit_bypass_policy.n_pkts), 0, __ATOMIC_RELAXED));
FS_operate(metrics->fs_handle, metrics->fs_id[STAT_HIT_BYPASS_POLICY_B], 0, FS_OP_SET, __atomic_fetch_add(&(metrics->hit_bypass_policy.n_bytes), 0, __ATOMIC_RELAXED));
// control packet
FS_operate(metrics->fs_handle, metrics->fs_id[STAT_CONTROL_RX_PKT], 0, FS_OP_SET, __atomic_fetch_add(&(metrics->control_packet_rx.n_pkts), 0, __ATOMIC_RELAXED));
FS_operate(metrics->fs_handle, metrics->fs_id[STAT_CONTROL_RX_B], 0, FS_OP_SET, __atomic_fetch_add(&(metrics->control_packet_rx.n_bytes), 0, __ATOMIC_RELAXED));
// current session number
FS_operate(metrics->fs_handle, metrics->fs_id[STAT_CURRENT_SESSION_NUMS], 0, FS_OP_SET, __atomic_fetch_add(&(metrics->session_nums), 0, __ATOMIC_RELAXED));
FS_passive_output(metrics->fs_handle);
}

9
platform/src/health_check.cpp
View File

@@ -61,18 +61,11 @@ int health_check_session_set_status(int session_id, int is_active)
return 0;
}
// return 0 : success
// return -1 : key not exist
int health_check_session_get_ip(int session_id, char *ip_buff)
{
// TODO
return 0;
}
// return 0 : success
// return -1 : key not exist
int health_check_session_get_mac(int session_id, char *mac_buff)
{
strcpy(mac_buff, "66:AA:AA:AA:AA:AA");
// TODO
return 0;
}

3
platform/src/main.cpp
View File

@@ -6,6 +6,7 @@
#include "sce.h"
#include "log.h"
#include "utils.h"
#include "global_metrics.h"
static void sig_handler(int signo)
{
@@ -96,8 +97,8 @@ int main(int argc, char **argv)
while (1)
{
sleep(20);
global_metrics_dump(ctx->metrics);
sleep(ctx->metrics->config.statsd_cycle);
}
error_out:

253
platform/src/packet_io.cpp
View File

@@ -11,10 +11,11 @@
#include "utils.h"
#include "g_vxlan.h"
#include "ctrl_packet.h"
#include "global_metrics.h"
/*
* add: vxlan_hdr
* del: marsio_buff_reset()
* del: marsio_buff_ctrlzone_reset()
* +----+ NF2SF +----+
* | |--------------------------->| |
* | | | |
@@ -89,7 +90,7 @@ struct metadata
int dir_is_e2i;
int is_ctrl_pkt;
int l7_offset; // only control packet set l7_offset
uint16_t l7_offset; // only control packet set l7_offset
int traffic_is_decrypted; // only raw packet set traffic_is_decrypted
struct sids sids;
@@ -106,6 +107,8 @@ void packet_io_destory(struct packet_io *handle);
int packet_io_polling_nf_interface(struct packet_io *handle, int thread_seq, void *ctx);
int packet_io_polling_endpoint(struct packet_io *handle, int thread_seq, void *ctx);
// return 0 : success
// return -1 : error
static int packet_io_config(const char *profile, struct config *config);
// return 0 : success
@@ -114,6 +117,7 @@ static int packet_io_get_metadata(marsio_buff_t *tx_buff, struct metadata *meta)
// return 0 : success
// return -1 : error
static int packet_io_set_metadata(marsio_buff_t *tx_buff, struct metadata *meta);
static void packet_io_dump_metadata(marsio_buff_t *tx_buff, struct metadata *meta);
// return 0 : success
// return -1 : error
@@ -122,21 +126,25 @@ static int handle_control_packet(struct packet_io *handle, marsio_buff_t *rx_buf
// return : RAW_PKT_HIT_BYPASS
// return : RAW_PKT_HIT_BLOCK
// reutrn : RAW_PKT_HIT_FORWARD
static enum raw_pkt_action handle_raw_packet(struct packet_io *handle, marsio_buff_t *rx_buff, int thread_seq, void *ctx);
static enum raw_pkt_action handle_raw_packet(struct packet_io *handle, marsio_buff_t *rx_buff, int thread_seq, void *ctx, int *action_bytes);
// return : INJT_PKT_ERR_DROP
// return : INJT_PKT_HIT_BLOCK
// return : INJT_PKT_HIT_FWD2SF
// return : INJT_PKT_HIT_FWD2NF
static enum inject_pkt_action handle_inject_packet(struct packet_io *handle, marsio_buff_t *rx_buff, int thread_seq, void *ctx);
static enum inject_pkt_action handle_inject_packet(struct packet_io *handle, marsio_buff_t *rx_buff, int thread_seq, void *ctx, int *action_bytes);
// return 0 : success
// return + : send n bytes
// return -1 : error
static int forward_packet_to_sf(struct packet_io *handle, marsio_buff_t *rx_buff, struct metadata *meta, struct selected_sf *sf, int thread_seq, void *ctx);
// return 0 : success
// return + : send n bytes
// return -1 : error
static int forward_packet_to_nf(struct packet_io *handle, marsio_buff_t *rx_buff, struct metadata *meta, int thread_seq, void *ct);
static void forward_all_nf_packet_to_sf(struct packet_io *handle, marsio_buff_t *rx_buff, struct selected_sf *sf, int thread_seq, void *ctx);
static void forward_all_sf_packet_to_nf(struct packet_io *handle, marsio_buff_t *rx_buff, int thread_seq, void *ctx);
// return + : send n bytes
// return -1 : error bypass
static int forward_all_nf_packet_to_sf(struct packet_io *handle, marsio_buff_t *rx_buff, struct selected_sf *sf, int thread_seq, void *ctx);
// return + : send n bytes
// return -1 : error drop
static int forward_all_sf_packet_to_nf(struct packet_io *handle, marsio_buff_t *rx_buff, int thread_seq, void *ctx);
// return 0 : success
// return -1 : error
@@ -282,7 +290,7 @@ int packet_io_polling_nf_interface(struct packet_io *handle, int thread_seq, voi
{
for (int j = 0; j < nr_recv; j++)
{
if (marsio_buff_is_ctrlbuf(rx_buffs[j]))
if (!marsio_buff_is_ctrlbuf(rx_buffs[j]))
{
int raw_len = marsio_buff_datalen(rx_buffs[j]);
throughput_metrics_inc(&g_metrics->dev_nf_interface_rx, 1, raw_len);
@@ -304,8 +312,18 @@ int packet_io_polling_nf_interface(struct packet_io *handle, int thread_seq, voi
marsio_buff_t *rx_buff = rx_buffs[j];
int raw_len = marsio_buff_datalen(rx_buff);
throughput_metrics_inc(&g_metrics->dev_nf_interface_rx, 1, raw_len);
throughput_metrics_inc(&g_metrics->dev_endpoint_tx, 1, raw_len);
forward_all_nf_packet_to_sf(handle, rx_buff, &sf, thread_seq, ctx);
// return + : send n bytes
// return -1 : error bypass
int nsend = forward_all_nf_packet_to_sf(handle, rx_buff, &sf, thread_seq, ctx);
if (nsend > 0)
{
throughput_metrics_inc(&g_metrics->dev_endpoint_tx, 1, nsend);
}
else
{
throughput_metrics_inc(&g_metrics->dev_nf_interface_err_bypass, 1, raw_len);
marsio_send_burst(handle->dev_nf_interface.mr_path, thread_seq, &rx_buff, 1);
}
}
return nr_recv;
}
@@ -313,29 +331,33 @@ int packet_io_polling_nf_interface(struct packet_io *handle, int thread_seq, voi
for (int j = 0; j < nr_recv; j++)
{
marsio_buff_t *rx_buff = rx_buffs[j];
int raw_len = marsio_buff_datalen(rx_buff);
if (marsio_buff_is_ctrlbuf(rx_buff))
{
handle_control_packet(handle, rx_buff, thread_seq, ctx);
throughput_metrics_inc(&g_metrics->control_packet_rx, 1, raw_len);
// all control packet need bypass
marsio_send_burst(handle->dev_nf_interface.mr_path, thread_seq, &rx_buff, 1);
}
else
{
int raw_len = marsio_buff_datalen(rx_buff);
throughput_metrics_inc(&g_metrics->dev_nf_interface_rx, 1, raw_len);
enum raw_pkt_action action = handle_raw_packet(handle, rx_buff, thread_seq, ctx);
int action_bytes = 0;
enum raw_pkt_action action = handle_raw_packet(handle, rx_buff, thread_seq, ctx, &action_bytes);
assert(action_bytes > 0);
switch (action)
{
case RAW_PKT_ERR_BYPASS:
throughput_metrics_inc(&g_metrics->dev_nf_interface_err_bypass, 1, raw_len);
throughput_metrics_inc(&g_metrics->dev_nf_interface_err_bypass, 1, action_bytes);
break;
case RAW_PKT_HIT_BYPASS:
throughput_metrics_inc(&g_metrics->hit_bypass_policy, 1, raw_len);
throughput_metrics_inc(&g_metrics->hit_bypass_policy, 1, action_bytes);
break;
case RAW_PKT_HIT_BLOCK:
throughput_metrics_inc(&g_metrics->hit_block_policy, 1, raw_len);
throughput_metrics_inc(&g_metrics->hit_block_policy, 1, action_bytes);
break;
case RAW_PKT_HIT_FORWARD:
throughput_metrics_inc(&g_metrics->dev_endpoint_tx, 1, action_bytes);
break;
}
}
@@ -377,8 +399,17 @@ int packet_io_polling_endpoint(struct packet_io *handle, int thread_seq, void *c
marsio_buff_t *rx_buff = rx_buffs[j];
int raw_len = marsio_buff_datalen(rx_buff);
throughput_metrics_inc(&g_metrics->dev_endpoint_rx, 1, raw_len);
throughput_metrics_inc(&g_metrics->dev_nf_interface_tx, 1, raw_len);
forward_all_sf_packet_to_nf(handle, rx_buff, thread_seq, ctx);
// return + : send n bytes
// return -1 : error drop
int nsend = forward_all_sf_packet_to_nf(handle, rx_buff, thread_seq, ctx);
if (nsend > 0)
{
throughput_metrics_inc(&g_metrics->dev_nf_interface_tx, 1, nsend);
}
else
{
throughput_metrics_inc(&g_metrics->dev_endpoint_err_drop, 1, raw_len);
}
}
return nr_recv;
}
@@ -389,20 +420,22 @@ int packet_io_polling_endpoint(struct packet_io *handle, int thread_seq, void *c
int data_len = marsio_buff_datalen(rx_buff);
throughput_metrics_inc(&g_metrics->dev_endpoint_rx, 1, data_len);
enum inject_pkt_action action = handle_inject_packet(handle, rx_buff, thread_seq, ctx);
int action_bytes = 0;
enum inject_pkt_action action = handle_inject_packet(handle, rx_buff, thread_seq, ctx, &action_bytes);
assert(action_bytes > 0);
switch (action)
{
case INJT_PKT_ERR_DROP:
throughput_metrics_inc(&g_metrics->dev_endpoint_err_drop, 1, data_len);
throughput_metrics_inc(&g_metrics->dev_endpoint_err_drop, 1, action_bytes);
break;
case INJT_PKT_HIT_BLOCK:
throughput_metrics_inc(&g_metrics->hit_block_policy, 1, data_len);
throughput_metrics_inc(&g_metrics->hit_block_policy, 1, action_bytes);
break;
case INJT_PKT_HIT_FWD2SF: // forward to next service function
throughput_metrics_inc(&g_metrics->dev_endpoint_tx, 1, data_len);
throughput_metrics_inc(&g_metrics->dev_endpoint_tx, 1, action_bytes);
break;
case INJT_PKT_HIT_FWD2NF: // forward to network function
throughput_metrics_inc(&g_metrics->dev_nf_interface_tx, 1, data_len);
throughput_metrics_inc(&g_metrics->dev_nf_interface_tx, 1, action_bytes);
break;
}
}
@@ -410,8 +443,8 @@ int packet_io_polling_endpoint(struct packet_io *handle, int thread_seq, void *c
return nr_recv;
}
// return -1 : error
// return 0 : success
// return -1 : error
static int packet_io_config(const char *profile, struct config *config)
{
MESA_load_profile_int_def(profile, "PACKET_IO", "bypass_all_traffic", (int *)&(config->bypass_all_traffic), 0);
@@ -468,7 +501,7 @@ static int packet_io_get_metadata(marsio_buff_t *rx_buff, struct metadata *meta)
{
memset(meta, 0, sizeof(struct metadata));
if (marsio_buff_get_metadata(rx_buff, MR_BUFF_SESSION_ID, &(meta->session_id), sizeof(meta->session_id)) != 0)
if (marsio_buff_get_metadata(rx_buff, MR_BUFF_SESSION_ID, &(meta->session_id), sizeof(meta->session_id)) <= 0)
{
LOG_ERROR("%s: unable to get session_id from metadata", LOG_TAG_PKTIO);
return -1;
@@ -484,7 +517,7 @@ static int packet_io_get_metadata(marsio_buff_t *rx_buff, struct metadata *meta)
// 1: E2I
// 0: I2E
if (marsio_buff_get_metadata(rx_buff, MR_BUFF_DIR, &(meta->dir_is_e2i), sizeof(meta->dir_is_e2i)) != 0)
if (marsio_buff_get_metadata(rx_buff, MR_BUFF_DIR, &(meta->dir_is_e2i), sizeof(meta->dir_is_e2i)) <= 0)
{
LOG_ERROR("%s: unable to get buff_dir from metadata", LOG_TAG_PKTIO);
return -1;
@@ -493,15 +526,12 @@ static int packet_io_get_metadata(marsio_buff_t *rx_buff, struct metadata *meta)
if (marsio_buff_is_ctrlbuf(rx_buff))
{
meta->is_ctrl_pkt = 1;
// only control packet set MR_L7_OFFSET
// TODO
#if 0
if (marsio_buff_get_metadata(rx_buff, MR_L7_OFFSET, &(meta->l7_offset), sizeof(meta->l7_offset)) != 0)
// only control packet set MR_BUFF_PAYLOAD_OFFSET
if (marsio_buff_get_metadata(rx_buff, MR_BUFF_PAYLOAD_OFFSET, &(meta->l7_offset), sizeof(meta->l7_offset)) <= 0)
{
LOG_ERROR("%s: unable to get l7_offset from metadata", LOG_TAG_PKTIO);
return -1;
}
#endif
}
else
{
@@ -509,7 +539,7 @@ static int packet_io_get_metadata(marsio_buff_t *rx_buff, struct metadata *meta)
// only raw packet set MR_IS_DECRYPTED
// TODO
#if 0
if (marsio_buff_get_metadata(rx_buff, MR_IS_DECRYPTED, &(meta->traffic_is_decrypted), sizeof(meta->traffic_is_decrypted)) != 0)
if (marsio_buff_get_metadata(rx_buff, MR_IS_DECRYPTED, &(meta->traffic_is_decrypted), sizeof(meta->traffic_is_decrypted)) <= 0)
{
LOG_ERROR("%s: unable to get traffic_is_decrypted from metadata", LOG_TAG_PKTIO);
return -1;
@@ -517,7 +547,7 @@ static int packet_io_get_metadata(marsio_buff_t *rx_buff, struct metadata *meta)
#endif
}
if (marsio_buff_get_metadata(rx_buff, MR_BUFF_ROUTE_CTX, meta->route_ctx, sizeof(meta->route_ctx)) != 0)
if (marsio_buff_get_metadata(rx_buff, MR_BUFF_ROUTE_CTX, meta->route_ctx, sizeof(meta->route_ctx)) <= 0)
{
LOG_ERROR("%s: unable to get route_ctx from metadata", LOG_TAG_PKTIO);
return -1;
@@ -548,22 +578,22 @@ static int packet_io_set_metadata(marsio_buff_t *tx_buff, struct metadata *meta)
// 1: E2I
// 0: I2E
#if 0
// use MR_BUFF_ROUTE_CTX instead
if (marsio_buff_set_metadata(tx_buff, MR_BUFF_DIR, &(meta->dir_is_e2i), sizeof(meta->dir_is_e2i)) != 0)
{
LOG_ERROR("%s: unable to set buff_dir for metadata", LOG_TAG_PKTIO);
return -1;
}
#endif
if (meta->is_ctrl_pkt)
{
// TODO
#if 0
if (marsio_buff_set_metadata(tx_buff, MR_L7_OFFSET, &(meta->l7_offset), sizeof(meta->l7_offset)) != 0)
if (marsio_buff_set_metadata(tx_buff, MR_BUFF_PAYLOAD_OFFSET, &(meta->l7_offset), sizeof(meta->l7_offset)) != 0)
{
LOG_ERROR("%s: unable to set l7_offset for metadata", LOG_TAG_PKTIO);
return -1;
}
#endif
}
else
{
@@ -598,6 +628,11 @@ static int packet_io_set_metadata(marsio_buff_t *tx_buff, struct metadata *meta)
return 0;
}
static void packet_io_dump_metadata(marsio_buff_t *tx_buff, struct metadata *meta)
{
LOG_DEBUG("%s: META={session_id: %lu, raw_len: %d, dir_is_e2i: %d, is_ctrl_pkt: %d, l7_offset: %d, traffic_is_decrypted: %d, sids_num: %d}", LOG_TAG_PKTIO, meta->session_id, meta->raw_len, meta->dir_is_e2i, meta->is_ctrl_pkt, meta->l7_offset, meta->traffic_is_decrypted, meta->sids.num);
}
// return 0 : success
// return -1 : error
static int handle_control_packet(struct packet_io *handle, marsio_buff_t *rx_buff, int thread_seq, void *ctx)
@@ -606,6 +641,7 @@ static int handle_control_packet(struct packet_io *handle, marsio_buff_t *rx_buf
if (packet_io_get_metadata(rx_buff, &meta) == -1)
{
LOG_ERROR("%s: unexpected control packet, unable to get metadata", LOG_TAG_PKTIO);
packet_io_dump_metadata(rx_buff, &meta);
return -1;
}
@@ -644,15 +680,20 @@ static int handle_control_packet(struct packet_io *handle, marsio_buff_t *rx_buf
// return : RAW_PKT_HIT_BYPASS
// return : RAW_PKT_HIT_BLOCK
// reutrn : RAW_PKT_HIT_FORWARD
static enum raw_pkt_action handle_raw_packet(struct packet_io *handle, marsio_buff_t *rx_buff, int thread_seq, void *ctx)
static enum raw_pkt_action handle_raw_packet(struct packet_io *handle, marsio_buff_t *rx_buff, int thread_seq, void *ctx, int *action_bytes)
{
int nsend = 0;
struct thread_ctx *thread = (struct thread_ctx *)ctx;
int raw_len = marsio_buff_datalen(rx_buff);
*action_bytes = 0;
struct metadata meta;
if (packet_io_get_metadata(rx_buff, &meta) == -1)
{
LOG_ERROR("%s: unexpected raw packet, unable to get metadata, bypass !!!", LOG_TAG_PKTIO);
packet_io_dump_metadata(rx_buff, &meta);
marsio_send_burst(handle->dev_nf_interface.mr_path, thread_seq, &rx_buff, 1);
*action_bytes = raw_len;
return RAW_PKT_ERR_BYPASS;
}
@@ -661,6 +702,7 @@ static enum raw_pkt_action handle_raw_packet(struct packet_io *handle, marsio_bu
{
LOG_ERROR("%s: unexpected raw packet, unable to find session %lu from session table, bypass !!!", LOG_TAG_PKTIO, meta.session_id);
marsio_send_burst(handle->dev_nf_interface.mr_path, thread_seq, &rx_buff, 1);
*action_bytes = raw_len;
return RAW_PKT_ERR_BYPASS;
}
@@ -689,14 +731,15 @@ static enum raw_pkt_action handle_raw_packet(struct packet_io *handle, marsio_bu
{
LOG_ERROR("%s: unexpected raw packet, session %lu %s misses policy, bypass !!!", LOG_TAG_PKTIO, s_ctx->session_id, s_ctx->first_ctrl_pkt.addr_string);
marsio_send_burst(handle->dev_nf_interface.mr_path, thread_seq, &rx_buff, 1);
*action_bytes = raw_len;
return RAW_PKT_ERR_BYPASS;
}
for (int i = 0; i < chaining->chaining_used; i++)
{
struct selected_sf *node = &(chaining->chaining[i]);
LOG_INFO("%s: session %lu %s execute policy: %d -> sff_profile_id %d -> sf_profile_id %d -> sf_need_skip %d sf_action_reason : %d",
LOG_TAG_PKTIO, s_ctx->session_id, s_ctx->first_ctrl_pkt.addr_string, node->policy_id, node->sff_profile_id, node->sf_profile_id, node->sf_need_skip, node->sf_action_reason);
LOG_INFO("%s: session %lu %s execute policy: %d -> sff_profile_id %d -> sf_profile_id %d -> sf_need_skip %d sf_action_reason : %s",
LOG_TAG_PKTIO, s_ctx->session_id, s_ctx->first_ctrl_pkt.addr_string, node->policy_id, node->sff_profile_id, node->sf_profile_id, node->sf_need_skip, session_action_reason_to_string(node->sf_action_reason));
if (node->sf_need_skip)
{
@@ -711,25 +754,29 @@ static enum raw_pkt_action handle_raw_packet(struct packet_io *handle, marsio_bu
case SESSION_ACTION_BLOCK:
// BLOCK ALL SF
marsio_buff_free(handle->instance, &rx_buff, 1, 0, thread_seq);
*action_bytes = raw_len;
return RAW_PKT_HIT_BLOCK;
case SESSION_ACTION_FORWARD:
if (node->sf_connectivity.method != PACKAGE_METHOD_VXLAN_G)
{
LOG_ERROR("%s: processing raw packets, session %lu %s requires encapsulation format not supported, bypass !!!", LOG_TAG_PKTIO, s_ctx->session_id, s_ctx->first_ctrl_pkt.addr_string);
marsio_send_burst(handle->dev_nf_interface.mr_path, thread_seq, &rx_buff, 1);
*action_bytes = raw_len;
return RAW_PKT_ERR_BYPASS;
}
if (forward_packet_to_sf(handle, rx_buff, &meta, node, thread_seq, ctx) == 0)
nsend = forward_packet_to_sf(handle, rx_buff, &meta, node, thread_seq, ctx);
if (nsend > 0)
{
throughput_metrics_inc(&node->tx, 1, meta.raw_len);
throughput_metrics_inc(&node->tx, 1, nsend);
*action_bytes = nsend;
return RAW_PKT_HIT_FORWARD;
}
else
{
LOG_ERROR("%s: processing raw packet, session %lu %s forwarding packet to service function failed, bypass !!!", LOG_TAG_PKTIO, s_ctx->session_id, s_ctx->first_ctrl_pkt.addr_string);
// TODO
marsio_send_burst(handle->dev_nf_interface.mr_path, thread_seq, &rx_buff, 1);
*action_bytes = raw_len;
return RAW_PKT_ERR_BYPASS;
}
default:
@@ -740,6 +787,7 @@ static enum raw_pkt_action handle_raw_packet(struct packet_io *handle, marsio_bu
// BYPASS ALL SF
LOG_INFO("%s: session %lu %s bypass all service function", LOG_TAG_PKTIO, s_ctx->session_id, s_ctx->first_ctrl_pkt.addr_string);
marsio_send_burst(handle->dev_nf_interface.mr_path, thread_seq, &rx_buff, 1);
*action_bytes = raw_len;
return RAW_PKT_HIT_BYPASS;
}
@@ -747,17 +795,20 @@ static enum raw_pkt_action handle_raw_packet(struct packet_io *handle, marsio_bu
// return : INJT_PKT_HIT_BLOCK
// return : INJT_PKT_HIT_FWD2SF
// return : INJT_PKT_HIT_FWD2NF
static enum inject_pkt_action handle_inject_packet(struct packet_io *handle, marsio_buff_t *rx_buff, int thread_seq, void *ctx)
static enum inject_pkt_action handle_inject_packet(struct packet_io *handle, marsio_buff_t *rx_buff, int thread_seq, void *ctx, int *action_bytes)
{
int nsend = 0;
struct thread_ctx *thread = (struct thread_ctx *)ctx;
struct g_vxlan *g_vxlan_hdr = NULL;
int raw_len = marsio_buff_datalen(rx_buff);
char *raw_data = marsio_buff_mtod(rx_buff);
*action_bytes = 0;
if (g_vxlan_decode(&g_vxlan_hdr, raw_data, raw_len) == -1)
{
LOG_ERROR("%s: unexpected inject packet, not a vxlan-encapsulated packet, drop !!!", LOG_TAG_PKTIO);
marsio_buff_free(handle->instance, &rx_buff, 1, 0, thread_seq);
*action_bytes = raw_len;
return INJT_PKT_ERR_DROP;
}
@@ -771,7 +822,7 @@ static enum inject_pkt_action handle_inject_packet(struct packet_io *handle, mar
meta.l7_offset = 0;
// meta.session_id set later
// meta.sids set later
int next_sf_index = g_vxlan_get_next_sf_index(g_vxlan_hdr);
int sf_index = g_vxlan_get_sf_index(g_vxlan_hdr);
struct addr_tuple4 inner_addr;
struct raw_pkt_parser raw_parser;
@@ -787,6 +838,7 @@ static enum inject_pkt_action handle_inject_packet(struct packet_io *handle, mar
LOG_ERROR("%s: unexpected inject packet, unable to find session %s from session table, drop !!!", LOG_TAG_PKTIO, addr_string);
free(addr_string);
marsio_buff_free(handle->instance, &rx_buff, 1, 0, thread_seq);
*action_bytes = raw_len;
return INJT_PKT_ERR_DROP;
}
@@ -802,22 +854,25 @@ static enum inject_pkt_action handle_inject_packet(struct packet_io *handle, mar
sids_copy(&meta.sids, &s_ctx->raw_pkt_i2e_sids);
memcpy(meta.route_ctx, s_ctx->raw_pkt_i2e_route_ctx, sizeof(s_ctx->raw_pkt_i2e_route_ctx));
}
LOG_DEBUG("%s: session %lu get metadata from inject packet, META={raw_len: %d, dir_is_e2i: %d, traffic_is_decrypted: %d, sf_index: %d}", LOG_TAG_PKTIO, meta.session_id, meta.raw_len, meta.dir_is_e2i, meta.traffic_is_decrypted, sf_index);
struct selected_chaining *chaining = s_ctx->chaining;
if (chaining == NULL || next_sf_index < 1 || next_sf_index > chaining->chaining_used)
if (chaining == NULL || sf_index < 0 || sf_index >= chaining->chaining_used)
{
LOG_ERROR("%s: unexpected inject packet, session %lu %s misses chaining index, drop !!!", LOG_TAG_PKTIO, s_ctx->session_id, s_ctx->first_ctrl_pkt.addr_string);
marsio_buff_free(handle->instance, &rx_buff, 1, 0, thread_seq);
*action_bytes = raw_len;
return INJT_PKT_ERR_DROP;
}
throughput_metrics_inc(&chaining->chaining[next_sf_index - 1].rx, 1, meta.raw_len);
throughput_metrics_inc(&chaining->chaining[sf_index].rx, 1, meta.raw_len);
for (int i = next_sf_index; i < chaining->chaining_used; i++)
int next_sf_index;
for (next_sf_index = sf_index + 1; next_sf_index < chaining->chaining_used; next_sf_index++)
{
struct selected_sf *node = &(chaining->chaining[i]);
LOG_INFO("%s: session %lu %s execute policy: %d -> sff_profile_id %d -> sf_profile_id %d -> sf_need_skip %d sf_action_reason : %d",
LOG_TAG_PKTIO, s_ctx->session_id, s_ctx->first_ctrl_pkt.addr_string, node->policy_id, node->sff_profile_id, node->sf_profile_id, node->sf_need_skip, node->sf_action_reason);
struct selected_sf *node = &(chaining->chaining[next_sf_index]);
LOG_INFO("%s: session %lu %s execute policy: %d -> sff_profile_id %d -> sf_profile_id %d -> sf_need_skip %d sf_action_reason : %s",
LOG_TAG_PKTIO, s_ctx->session_id, s_ctx->first_ctrl_pkt.addr_string, node->policy_id, node->sff_profile_id, node->sf_profile_id, node->sf_need_skip, session_action_reason_to_string(node->sf_action_reason));
if (node->sf_need_skip)
{
@@ -832,77 +887,93 @@ static enum inject_pkt_action handle_inject_packet(struct packet_io *handle, mar
case SESSION_ACTION_BLOCK:
// BLOCK ALL SF
marsio_buff_free(handle->instance, &rx_buff, 1, 0, thread_seq);
*action_bytes = raw_len;
return INJT_PKT_HIT_BLOCK;
case SESSION_ACTION_FORWARD:
if (node->sf_connectivity.method != PACKAGE_METHOD_VXLAN_G)
{
LOG_ERROR("%s: processing inject packets, session %lu %s requires encapsulation format not supported, drop !!!", LOG_TAG_PKTIO, s_ctx->session_id, s_ctx->first_ctrl_pkt.addr_string);
marsio_buff_free(handle->instance, &rx_buff, 1, 0, thread_seq);
*action_bytes = raw_len;
return INJT_PKT_ERR_DROP;
}
if (forward_packet_to_sf(handle, rx_buff, &meta, node, thread_seq, ctx) == 0)
nsend = forward_packet_to_sf(handle, rx_buff, &meta, node, thread_seq, ctx);
if (nsend > 0)
{
throughput_metrics_inc(&node->tx, 1, meta.raw_len);
throughput_metrics_inc(&node->tx, 1, nsend);
*action_bytes = nsend;
return INJT_PKT_HIT_FWD2SF;
}
else
{
LOG_ERROR("%s: processing inject packet, session %lu %s forwarding packet to service function failed, drop !!!", LOG_TAG_PKTIO, s_ctx->session_id, s_ctx->first_ctrl_pkt.addr_string);
marsio_buff_free(handle->instance, &rx_buff, 1, 0, thread_seq);
*action_bytes = raw_len;
return INJT_PKT_ERR_DROP;
}
default:
assert(0);
continue;
}
}
// the last sf need bypass or need skip
if (next_sf_index != chaining->chaining_used)
{
LOG_ERROR("%s: unexpected inject packet, session %lu %s using invalid chaining index, drop !!!", LOG_TAG_PKTIO, s_ctx->session_id, s_ctx->first_ctrl_pkt.addr_string);
marsio_buff_free(handle->instance, &rx_buff, 1, 0, thread_seq);
return INJT_PKT_ERR_DROP;
}
if (forward_packet_to_nf(handle, rx_buff, &meta, thread_seq, ctx) == -1)
{
LOG_ERROR("%s: processing inject packet, session %lu %s forwarding packet to network function failed, drop !!!", LOG_TAG_PKTIO, s_ctx->session_id, s_ctx->first_ctrl_pkt.addr_string);
marsio_buff_free(handle->instance, &rx_buff, 1, 0, thread_seq);
*action_bytes = raw_len;
return INJT_PKT_ERR_DROP;
}
else
{
return INJT_PKT_HIT_FWD2NF;
int nsend = forward_packet_to_nf(handle, rx_buff, &meta, thread_seq, ctx);
if (nsend > 0)
{
*action_bytes = nsend;
return INJT_PKT_HIT_FWD2NF;
}
else
{
LOG_ERROR("%s: processing inject packet, session %lu %s forwarding packet to network function failed, drop !!!", LOG_TAG_PKTIO, s_ctx->session_id, s_ctx->first_ctrl_pkt.addr_string);
marsio_buff_free(handle->instance, &rx_buff, 1, 0, thread_seq);
*action_bytes = raw_len;
return INJT_PKT_ERR_DROP;
}
}
}
// return 0 : success
// return + : send n bytes
// return -1 : error
static int forward_packet_to_sf(struct packet_io *handle, marsio_buff_t *rx_buff, struct metadata *meta, struct selected_sf *sf, int thread_seq, void *ctx)
{
marsio_buff_reset(rx_buff);
marsio_buff_ctrlzone_reset(rx_buff);
struct ethhdr *eth_hdr = (struct ethhdr *)marsio_buff_prepend(rx_buff, 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));
LOG_DEBUG("%s: session %lu set metadata to inject packet, META={raw_len: %d, dir_is_e2i: %d, traffic_is_decrypted: %d, sf_index: %d}", LOG_TAG_PKTIO, meta->session_id, meta->raw_len, meta->dir_is_e2i, meta->traffic_is_decrypted, sf->sf_index);
memset(g_vxlan_hdr, 0, sizeof(struct g_vxlan));
g_vxlan_set_packet_dir(g_vxlan_hdr, meta->dir_is_e2i);
g_vxlan_set_next_sf_index(g_vxlan_hdr, sf->sf_index + 1);
g_vxlan_set_sf_index(g_vxlan_hdr, sf->sf_index);
g_vxlan_set_traffic_type(g_vxlan_hdr, meta->traffic_is_decrypted);
build_ether_header(eth_hdr, ETH_P_IP, handle->config.default_src_mac, sf->sf_dst_mac);
build_ip_header(ip_hdr, IPPROTO_UDP, handle->config.default_src_ip, sf->sf_dst_ip, sizeof(struct udp_hdr) + sizeof(struct g_vxlan) + meta->raw_len);
build_udp_header((const char *)&ip_hdr->ip_src, 8, udp_hdr, meta->session_id % (65535 - 49152) + 49152, 4789, sizeof(struct g_vxlan) + meta->raw_len);
int raw_len = marsio_buff_datalen(rx_buff);
if (marsio_send_burst(handle->dev_endpoint.mr_path, thread_seq, &rx_buff, 1) != 0)
{
LOG_ERROR("%s: unable to send burst on device %s, thread_seq: %d", LOG_TAG_PKTIO, handle->config.dev_endpoint, thread_seq);
return -1;
}
return 0;
return raw_len;
}
// return 0 : success
@@ -911,22 +982,25 @@ static int forward_packet_to_nf(struct packet_io *handle, marsio_buff_t *rx_buff
{
marsio_buff_adj(rx_buff, marsio_buff_datalen(rx_buff) - meta->raw_len);
marsio_buff_reset(rx_buff);
marsio_buff_ctrlzone_reset(rx_buff);
if (packet_io_set_metadata(rx_buff, meta) != 0)
{
return -1;
}
int raw_len = marsio_buff_datalen(rx_buff);
if (marsio_send_burst(handle->dev_nf_interface.mr_path, thread_seq, &rx_buff, 1) != 0)
{
LOG_ERROR("%s: unable to send burst on device %s, thread_seq: %d", LOG_TAG_PKTIO, handle->config.dev_nf_interface, thread_seq);
return -1;
}
return 0;
return raw_len;
}
static void forward_all_nf_packet_to_sf(struct packet_io *handle, marsio_buff_t *rx_buff, struct selected_sf *sf, int thread_seq, void *ctx)
// return + : send n bytes
// return -1 : error drop
static int forward_all_nf_packet_to_sf(struct packet_io *handle, marsio_buff_t *rx_buff, struct selected_sf *sf, int thread_seq, void *ctx)
{
struct thread_ctx *thread = (struct thread_ctx *)ctx;
struct global_metrics *g_metrics = thread->ref_metrics;
@@ -941,9 +1015,9 @@ static void forward_all_nf_packet_to_sf(struct packet_io *handle, marsio_buff_t
// get metadata
if (packet_io_get_metadata(rx_buff, &meta) == -1)
{
LOG_ERROR("%s: unexpected raw packet, unable to get metadata, drop !!!", LOG_TAG_PKTIO);
marsio_buff_free(handle->instance, &rx_buff, 1, 0, thread_seq);
return;
LOG_ERROR("%s: unexpected raw packet, unable to get metadata, bypass !!!", LOG_TAG_PKTIO);
packet_io_dump_metadata(rx_buff, &meta);
return -1;
}
// search session id
@@ -992,15 +1066,21 @@ static void forward_all_nf_packet_to_sf(struct packet_io *handle, marsio_buff_t
// forward data
forward:
if (forward_packet_to_sf(handle, rx_buff, &meta, sf, thread_seq, ctx) == 0)
int nsend = forward_packet_to_sf(handle, rx_buff, &meta, sf, thread_seq, ctx);
if (nsend > 0)
{
LOG_ERROR("%s: processing raw packet, session %lu %s forwarding packet to service function failed, drop !!!", LOG_TAG_PKTIO, s_ctx->session_id, s_ctx->first_ctrl_pkt.addr_string);
marsio_buff_free(handle->instance, &rx_buff, 1, 0, thread_seq);
return;
return nsend;
}
else
{
LOG_ERROR("%s: processing raw packet, session %lu %s forwarding packet to service function failed, bypass !!!", LOG_TAG_PKTIO, s_ctx->session_id, s_ctx->first_ctrl_pkt.addr_string);
return -1;
}
}
static void forward_all_sf_packet_to_nf(struct packet_io *handle, marsio_buff_t *rx_buff, int thread_seq, void *ctx)
// return + : send n bytes
// return -1 : error drop
static int forward_all_sf_packet_to_nf(struct packet_io *handle, marsio_buff_t *rx_buff, int thread_seq, void *ctx)
{
struct thread_ctx *thread = (struct thread_ctx *)ctx;
// struct global_metrics *g_metrics = thread->ref_metrics;
@@ -1013,7 +1093,7 @@ static void forward_all_sf_packet_to_nf(struct packet_io *handle, marsio_buff_t
{
LOG_ERROR("%s: unexpected inject packet, not a vxlan-encapsulated packet, drop !!!", LOG_TAG_PKTIO);
marsio_buff_free(handle->instance, &rx_buff, 1, 0, thread_seq);
return;
return -1;
}
struct metadata meta;
@@ -1041,7 +1121,7 @@ static void forward_all_sf_packet_to_nf(struct packet_io *handle, marsio_buff_t
LOG_ERROR("%s: unexpected inject packet, unable to find session %s from session table, drop !!!", LOG_TAG_PKTIO, addr_string);
free(addr_string);
marsio_buff_free(handle->instance, &rx_buff, 1, 0, thread_seq);
return;
return -1;
}
// add meta data
@@ -1059,11 +1139,16 @@ static void forward_all_sf_packet_to_nf(struct packet_io *handle, marsio_buff_t
}
// sendto nf
if (forward_packet_to_nf(handle, rx_buff, &meta, thread_seq, ctx) == -1)
int nsend = forward_packet_to_nf(handle, rx_buff, &meta, thread_seq, ctx);
if (nsend > 0)
{
return nsend;
}
else
{
LOG_ERROR("%s: processing inject packet, session %lu %s forwarding packet to network function failed, drop !!!", LOG_TAG_PKTIO, s_ctx->session_id, s_ctx->first_ctrl_pkt.addr_string);
marsio_buff_free(handle->instance, &rx_buff, 1, 0, thread_seq);
return;
return -1;
}
}
@@ -1097,6 +1182,8 @@ static int handle_session_opening(struct metadata *meta, struct ctrl_pkt_parser
s_ctx->first_ctrl_pkt.header_len = meta->l7_offset;
s_ctx->chaining = selected_chaining_create(128);
LOG_INFO("%s: session %lu %s opening", LOG_TAG_PKTIO, s_ctx->session_id, s_ctx->first_ctrl_pkt.addr_string);
for (int i = 0; i < parser->policy_id_num; i++)
{
int new_policy_id = parser->policy_ids[i];
@@ -1107,12 +1194,11 @@ static int handle_session_opening(struct metadata *meta, struct ctrl_pkt_parser
else
{
policy_enforce_select_chaining(s_ctx->chaining, thread->ref_enforcer, &raw_parser, new_policy_id, meta->dir_is_e2i);
selected_chaining_bref(s_ctx->chaining);
fixed_num_array_add_elem(&s_ctx->policy_ids, new_policy_id);
}
}
LOG_INFO("%s: session %lu %s opening", LOG_TAG_PKTIO, s_ctx->session_id, s_ctx->first_ctrl_pkt.addr_string);
__atomic_fetch_add(&g_metrics->session_nums, 1, __ATOMIC_RELAXED);
session_table_insert(thread->session_table, s_ctx->session_id, &(s_ctx->first_ctrl_pkt.tuple4), s_ctx, session_value_free_cb);
@@ -1161,6 +1247,8 @@ static int handle_session_active(struct metadata *meta, struct ctrl_pkt_parser *
}
struct session_ctx *s_ctx = (struct session_ctx *)node->val_data;
LOG_INFO("%s: session %lu %s update", LOG_TAG_PKTIO, s_ctx->session_id, s_ctx->first_ctrl_pkt.addr_string);
for (int i = 0; i < parser->policy_id_num; i++)
{
int new_policy_id = parser->policy_ids[i];
@@ -1171,6 +1259,7 @@ static int handle_session_active(struct metadata *meta, struct ctrl_pkt_parser *
else
{
policy_enforce_select_chaining(s_ctx->chaining, thread->ref_enforcer, &raw_parser, new_policy_id, meta->dir_is_e2i);
selected_chaining_bref(s_ctx->chaining);
fixed_num_array_add_elem(&s_ctx->policy_ids, new_policy_id);
}
}

25
platform/src/policy.cpp
View File

@@ -190,7 +190,7 @@ static const char *session_action_to_string(enum session_action session_action)
}
}
static const char *session_action_reason_to_string(enum session_action_reason session_action_reason)
const char *session_action_reason_to_string(enum session_action_reason session_action_reason)
{
switch (session_action_reason)
{
@@ -830,6 +830,14 @@ static void sf_param_new_cb(int table_id, const char *key, const char *table_lin
}
memcpy(param->sf_connectivity.dest_ip, item->valuestring, strlen(item->valuestring));
LOG_DEBUG("%s: parse sf profile: %d, connectivity->dest_ip: %s", LOG_TAG_POLICY, param->sf_profile_id, item->valuestring);
// CM does not send this field, but only reads it from json, which is used for debugging
item = cJSON_GetObjectItem(root1, "dest_mac");
if (item && cJSON_IsString(item))
{
memcpy(param->sf_connectivity.dest_mac, item->valuestring, strlen(item->valuestring));
LOG_DEBUG("%s: parse sf profile: %d, connectivity->dst_mac: %s", LOG_TAG_POLICY, param->sf_profile_id, item->valuestring);
}
}
// health_check
@@ -1107,6 +1115,7 @@ static void selected_sf_init(struct selected_sf *item)
{
if (item)
{
memset(item, 0, sizeof(struct selected_sf));
item->policy_id = -1;
item->traffic_type = TRAFFIC_TYPE_NONE;
item->sff_profile_id = -1;
@@ -1115,7 +1124,6 @@ static void selected_sf_init(struct selected_sf *item)
item->sf_profile_id = -1;
item->sf_action = SESSION_ACTION_BYPASS;
item->sf_action_reason = ACTION_BYPASS_DUE_DEFAULT;
memset(&item->sf_connectivity, 0, sizeof(struct connectivity));
}
}
@@ -1475,8 +1483,17 @@ void policy_enforce_select_chaining(struct selected_chaining *chaining, struct p
item->sf_connectivity.int_vlan_tag = sf_param->sf_connectivity.int_vlan_tag;
item->sf_connectivity.ext_vlan_tag = sf_param->sf_connectivity.ext_vlan_tag;
memcpy(item->sf_connectivity.dest_ip, sf_param->sf_connectivity.dest_ip, strlen(sf_param->sf_connectivity.dest_ip));
health_check_session_get_ip(item->sf_profile_id, item->sf_dst_ip);
health_check_session_get_mac(item->sf_profile_id, item->sf_dst_mac);
memcpy(item->sf_dst_ip, sf_param->sf_connectivity.dest_ip, strlen(sf_param->sf_connectivity.dest_ip));
if (strlen(sf_param->sf_connectivity.dest_mac))
{
// CM does not send this field, but only reads it from json, which is used for debugging
memcpy(item->sf_dst_mac, sf_param->sf_connectivity.dest_ip, strlen(sf_param->sf_connectivity.dest_ip));
}
else
{
health_check_session_get_mac(item->sf_profile_id, item->sf_dst_mac);
}
chaining->chaining_used++;
sf_param_free(sf_param);

48
platform/src/sce.cpp
View File

@@ -3,46 +3,7 @@
#include "sce.h"
#include "log.h"
/******************************************************************************
* global_metrics
******************************************************************************/
struct global_metrics *global_metrics_create()
{
struct global_metrics *metrics = (struct global_metrics *)calloc(1, sizeof(struct global_metrics));
assert(metrics == NULL);
return metrics;
}
void global_metrics_destory(struct global_metrics *metrics)
{
if (metrics)
{
free(metrics);
metrics = NULL;
}
}
void global_metrics_dump(struct global_metrics *metrics)
{
if (metrics)
{
LOG_INFO("%s: dev_endpoint_rx : n_pkts : %6lu, n_bytes: %6lu", LOG_TAG_METRICS, metrics->dev_endpoint_rx.n_pkts, metrics->dev_endpoint_rx.n_bytes);
LOG_INFO("%s: dev_endpoint_tx : n_pkts : %6lu, n_bytes: %6lu", LOG_TAG_METRICS, metrics->dev_endpoint_tx.n_pkts, metrics->dev_endpoint_tx.n_bytes);
LOG_INFO("%s: dev_endpoint_err_drop : n_pkts : %6lu, n_bytes: %6lu", LOG_TAG_METRICS, metrics->dev_endpoint_err_drop.n_pkts, metrics->dev_endpoint_err_drop.n_bytes);
LOG_INFO("%s: dev_nf_interface_rx : n_pkts : %6lu, n_bytes: %6lu", LOG_TAG_METRICS, metrics->dev_nf_interface_rx.n_pkts, metrics->dev_nf_interface_rx.n_bytes);
LOG_INFO("%s: dev_nf_interface_tx : n_pkts : %6lu, n_bytes: %6lu", LOG_TAG_METRICS, metrics->dev_nf_interface_tx.n_pkts, metrics->dev_nf_interface_tx.n_bytes);
LOG_INFO("%s: dev_nf_interface_err_bypass : n_pkts : %6lu, n_bytes: %6lu", LOG_TAG_METRICS, metrics->dev_nf_interface_err_bypass.n_pkts, metrics->dev_nf_interface_err_bypass.n_bytes);
LOG_INFO("%s: hit_block_policy : n_pkts : %6lu, n_bytes: %6lu", LOG_TAG_METRICS, metrics->hit_block_policy.n_pkts, metrics->hit_block_policy.n_bytes);
LOG_INFO("%s: hit_bypass_policy : n_pkts : %6lu, n_bytes: %6lu", LOG_TAG_METRICS, metrics->hit_bypass_policy.n_pkts, metrics->hit_bypass_policy.n_bytes);
LOG_INFO("%s: current_session_num : %6lu", LOG_TAG_METRICS, metrics->session_nums);
}
}
#include "global_metrics.h"
/******************************************************************************
* session_ctx
@@ -100,7 +61,7 @@ struct sce_ctx *sce_ctx_create(const char *profile)
goto error_out;
}
ctx->metrics = global_metrics_create();
ctx->metrics = global_metrics_create(profile);
if (ctx->metrics == NULL)
{
goto error_out;
@@ -112,6 +73,11 @@ struct sce_ctx *sce_ctx_create(const char *profile)
goto error_out;
}
if (policy_enforcer_register(ctx->enforcer) == -1)
{
goto error_out;
}
return ctx;
error_out:

4
resource/sce.json
View File

@@ -3,8 +3,8 @@
{
"table_name": "SERVICE_FUNCTION_PROFILE",
"table_content": [
"1\tdevice_group_a\t1\t{\"method\":\"vxlan_g\",\"dest_ip\":\"1.1.1.1\"}\t{\"method\":\"none\"}\t1",
"2\tdevice_group_a\t1\t{\"method\":\"vxlan_g\",\"dest_ip\":\"1.1.1.1\"}\t{\"method\":\"bfd\",\"address\":\"1.2.3.4\",\"port\":\"10000\",\"interval_ms\":100,\"retires\":5}\t1",
"1\tdevice_group_a\t1\t{\"method\":\"vxlan_g\",\"dest_ip\":\"1.1.1.1\",\"dest_mac\":\"AA:AA:AA:AA:AA:AA\"}\t{\"method\":\"none\"}\t1",
"2\tdevice_group_a\t1\t{\"method\":\"vxlan_g\",\"dest_ip\":\"2.2.2.2\",\"dest_mac\":\"BB:BB:BB:BB:BB:BB\"}\t{\"method\":\"bfd\",\"address\":\"1.2.3.4\",\"port\":\"10000\",\"interval_ms\":100,\"retires\":5}\t1",
"3\tdevice_group_a\t1\t{\"method\":\"vxlan_g\",\"dest_ip\":\"1.1.1.1\"}\t{\"method\":\"in_band_bfd\",\"address\":\"1.2.3.4\",\"port\":\"10000\",\"interval_ms\":100,\"retires\":5}\t1",
"4\tdevice_group_a\t1\t{\"method\":\"vxlan_g\",\"dest_ip\":\"1.1.1.1\"}\t{\"method\":\"http\",\"url\":\"http://192.168.100.1:8080/health_check.index\",\"interval_ms\":100,\"retires\":5}\t1",
"5\tdevice_group_a\t1\t{\"method\":\"layer2_switch\",\"int_vlan_tag\":10,\"ext_vlan_tag\":5}\t{\"method\":\"none\"}\t1",

4
vendor/CMakeLists.txt vendored
View File

@@ -48,6 +48,10 @@ add_library(MESA_prof_load SHARED IMPORTED GLOBAL)
set_property(TARGET MESA_prof_load PROPERTY IMPORTED_LOCATION ${MESA_FRAMEWORK_LIB_DIR}/libMESA_prof_load.so)
set_property(TARGET MESA_prof_load PROPERTY INTERFACE_INCLUDE_DIRECTORIES ${MESA_FRAMEWORK_INCLUDE_DIR})
add_library(MESA_field_stat SHARED IMPORTED GLOBAL)
set_property(TARGET MESA_field_stat PROPERTY IMPORTED_LOCATION ${MESA_FRAMEWORK_LIB_DIR}/libMESA_field_stat2.so)
set_property(TARGET MESA_field_stat PROPERTY INTERFACE_INCLUDE_DIRECTORIES ${MESA_FRAMEWORK_INCLUDE_DIR})
add_library(maatframe SHARED IMPORTED GLOBAL)
set_property(TARGET maatframe PROPERTY IMPORTED_LOCATION ${MESA_FRAMEWORK_LIB_DIR}/libmaatframe.so)
set_property(TARGET maatframe PROPERTY INTERFACE_INCLUDE_DIRECTORIES ${MESA_FRAMEWORK_INCLUDE_DIR})