diff --git a/0241-dfx-set-g_unix_fd-to-1-after-abnormal-close-fd-to-av.patch b/0241-dfx-set-g_unix_fd-to-1-after-abnormal-close-fd-to-av.patch new file mode 100644 index 0000000..7859eba --- /dev/null +++ b/0241-dfx-set-g_unix_fd-to-1-after-abnormal-close-fd-to-av.patch @@ -0,0 +1,60 @@ +From 1cdbc7c47200b9ffc1911656567b48f53f4107b8 Mon Sep 17 00:00:00 2001 +From: jiangheng12 +Date: Wed, 26 Apr 2023 19:34:58 +0800 +Subject: [PATCH] dfx: set g_unix_fd to -1 after abnormal close fd to avoid + double close + +--- + src/ltran/ltran_dfx.c | 22 ++++++++++++---------- + 1 file changed, 12 insertions(+), 10 deletions(-) + +diff --git a/src/ltran/ltran_dfx.c b/src/ltran/ltran_dfx.c +index 3513125..4baca26 100644 +--- a/src/ltran/ltran_dfx.c ++++ b/src/ltran/ltran_dfx.c +@@ -289,6 +289,7 @@ static int32_t dfx_stat_read_from_ltran(char *buf, uint32_t len, enum GAZELLE_ST + dfx = find_dfx_node(mode); + if (dfx == NULL) { + close(fd); ++ g_unix_fd = -1; + return GAZELLE_ERR; + } + +@@ -297,6 +298,7 @@ static int32_t dfx_stat_read_from_ltran(char *buf, uint32_t len, enum GAZELLE_ST + if (ret == -1) { + printf("read stat response msg failed ret=%d\n", ret); + close(fd); ++ g_unix_fd = -1; + return GAZELLE_ERR; + } + } +@@ -1368,16 +1370,16 @@ int32_t main(int32_t argc, char *argv[]) + + int unix_arg = 0; + for (int32_t i = 1; i < argc; i++) { +- if (unix_arg == 0) { +- if (!strcmp(argv[i], "-u")) { +- unix_arg++; +- } +- } else if (unix_arg == 1) { +- g_unix_prefix = argv[i]; +- unix_arg++; +- } else { +- argv[i - unix_arg] = argv[i]; +- } ++ if (unix_arg == 0) { ++ if (!strcmp(argv[i], "-u")) { ++ unix_arg++; ++ } ++ } else if (unix_arg == 1) { ++ g_unix_prefix = argv[i]; ++ unix_arg++; ++ } else { ++ argv[i - unix_arg] = argv[i]; ++ } + } + + argv[argc - unix_arg] = argv[argc]; +-- +2.33.0 + diff --git a/0242-dfx-security-function-failed-return-error-directly.patch b/0242-dfx-security-function-failed-return-error-directly.patch new file mode 100644 index 0000000..473f39c --- /dev/null +++ b/0242-dfx-security-function-failed-return-error-directly.patch @@ -0,0 +1,63 @@ +From b3b492c64bab47d4bb898422fb9a57a2536e0d61 Mon Sep 17 00:00:00 2001 +From: jiangheng12 +Date: Wed, 26 Apr 2023 20:06:42 +0800 +Subject: [PATCH] dfx: security function failed, return error directly + +--- + src/ltran/ltran_dfx.c | 10 ++++++++-- + 1 file changed, 8 insertions(+), 2 deletions(-) + +diff --git a/src/ltran/ltran_dfx.c b/src/ltran/ltran_dfx.c +index 4baca26..944675e 100644 +--- a/src/ltran/ltran_dfx.c ++++ b/src/ltran/ltran_dfx.c +@@ -206,12 +206,14 @@ static int32_t dfx_connect_ltran(bool use_ltran, bool probe) + ret = memset_s(&addr, sizeof(addr), 0, sizeof(struct sockaddr_un)); + if (ret != EOK) { + printf("%s:%d memset_s fail ret=%d\n", __FUNCTION__, __LINE__, ret); ++ goto END; + } + + ret = strncpy_s(addr.sun_path, sizeof(addr.sun_path), GAZELLE_RUN_DIR, + strlen(GAZELLE_RUN_DIR) + 1); + if (ret != EOK) { + printf("%s:%d strncpy_s fail ret=%d\n", __FUNCTION__, __LINE__, ret); ++ goto END; + } + + if (g_unix_prefix) { +@@ -219,6 +221,7 @@ static int32_t dfx_connect_ltran(bool use_ltran, bool probe) + strlen(g_unix_prefix) + 1); + if (ret != EOK) { + printf("%s:%d strncat_s fail ret=%d\n", __FUNCTION__, __LINE__, ret); ++ goto END; + } + } + +@@ -234,6 +237,7 @@ static int32_t dfx_connect_ltran(bool use_ltran, bool probe) + strlen(GAZELLE_REG_SOCK_FILENAME) + 1); + if (ret != EOK) { + printf("%s:%d strncat_s fail ret=%d\n", __FUNCTION__, __LINE__, ret); ++ goto END; + } + } + +@@ -243,11 +247,13 @@ static int32_t dfx_connect_ltran(bool use_ltran, bool probe) + printf("connect ltran failed. errno: %d ret=%d\n", errno, ret); + printf("You may need to use the -u parameter to specify the UNIX_PREFIX that matches the configuration.\n"); + } +- close(fd); +- return GAZELLE_ERR; ++ goto END; + } + + return fd; ++END: ++ close(fd); ++ return GAZELLE_ERR; + } + + static int32_t dfx_stat_conn_to_ltran(struct gazelle_stat_msg_request *req_msg) +-- +2.33.0 + diff --git a/0243-add-bond4-suport.patch b/0243-add-bond4-suport.patch new file mode 100644 index 0000000..60ef541 --- /dev/null +++ b/0243-add-bond4-suport.patch @@ -0,0 +1,277 @@ +From: 97e31b514dde519ac5b83a3b7519c98d9805d746 Mon Sep 17 00:00:00 2001 +From: compile_success <980965867@qq.com> +Date: Fri, 5 May 2023 11:18:59 +0000 +Subject: [PATCH] add bond4 suport + +--- + src/lstack/Makefile | 3 +- + src/lstack/core/lstack_cfg.c | 55 +++++++++++++++++++ + src/lstack/core/lstack_dpdk.c | 90 +++++++++++++++++++++++++++++--- + src/lstack/include/lstack_cfg.h | 3 ++ + src/lstack/include/lstack_dpdk.h | 2 +- + 5 files changed, 143 insertions(+), 10 deletions(-) + +diff --git a/src/lstack/Makefile b/src/lstack/Makefile +index d475961..a79b963 100644 +--- a/src/lstack/Makefile ++++ b/src/lstack/Makefile +@@ -83,7 +83,8 @@ LIBRTE_LIB = $(DPDK_LIB_PATH)/librte_pci.so \ + $(DPDK_LIB_PATH)/librte_net.so \ + $(DPDK_LIB_PATH)/librte_ethdev.so \ + $(DPDK_LIB_PATH)/librte_pdump.so \ +- $(DPDK_LIB_PATH)/librte_pmd_pcap.so ++ $(DPDK_LIB_PATH)/librte_pmd_pcap.so \ ++ $(DPDK_LIB_PATH)/librte_pmd_bond.so + + + DEP_LIBS = $(LWIP_LIB) $(LIBRTE_LIB) +diff --git a/src/lstack/core/lstack_cfg.c b/src/lstack/core/lstack_cfg.c +index cdb0200..c4919d3 100644 +--- a/src/lstack/core/lstack_cfg.c ++++ b/src/lstack/core/lstack_cfg.c +@@ -69,6 +69,8 @@ static int32_t parse_process_numa(void); + static int32_t parse_process_index(void); + static int32_t parse_seperate_sendrecv_args(void); + static int32_t parse_tuple_filter(void); ++static int32_t parse_use_bond4(void); ++static int32_t parse_bond4_slave_mac(void); + + #define PARSE_ARG(_arg, _arg_string, _default_val, _min_val, _max_val, _ret) \ + do { \ +@@ -121,6 +123,8 @@ static struct config_vector_t g_config_tbl[] = { + { "process_numa", parse_process_numa }, + { "process_idx", parse_process_index }, + { "tuple_filter", parse_tuple_filter }, ++ { "use_bond4", parse_use_bond4 }, ++ { "bond4_slave_mac", parse_bond4_slave_mac }, + { NULL, NULL } + }; + +@@ -1052,3 +1056,54 @@ static int parse_tuple_filter(void) + + return 0; + } ++ ++static int32_t parse_use_bond4(void) ++{ ++ int32_t ret; ++ PARSE_ARG(g_config_params.use_bond4, "use_bond4", 0, 0, 1, ret); ++ return ret; ++} ++ ++static int32_t parse_bond4_slave_mac(void) ++{ ++ if (g_config_params.use_bond4 == 0) { ++ return 0; ++ } ++ ++ int32_t ret; ++ const char *slave_mac1 = NULL; ++ const char *slave_mac2 = NULL; ++ const config_setting_t *devs = NULL; ++ ++ devs = config_lookup(&g_config, "slave_mac1"); ++ if (devs == NULL) { ++ return -EINVAL; ++ } ++ slave_mac1 = config_setting_get_string(devs); ++ if (slave_mac1 == NULL) { ++ return 0; ++ } ++ ++ devs = config_lookup(&g_config, "slave_mac2"); ++ if (devs == NULL) { ++ return -EINVAL; ++ } ++ slave_mac2 = config_setting_get_string(devs); ++ if (slave_mac2 == NULL) { ++ return 0; ++ } ++ ++ /* add dev */ ++ ret = str_to_eth_addr(slave_mac1, g_config_params.bond4_slave1_mac_addr); ++ if (ret != 0) { ++ LSTACK_PRE_LOG(LSTACK_ERR, "cfg: invalid device name %s ret=%d.\n", slave_mac1, ret); ++ return ret; ++ } ++ ++ ret = str_to_eth_addr(slave_mac2, g_config_params.bond4_slave2_mac_addr); ++ if (ret != 0) { ++ LSTACK_PRE_LOG(LSTACK_ERR, "cfg: invalid device name %s ret=%d.\n", slave_mac2, ret); ++ } ++ return ret; ++} ++ +diff --git a/src/lstack/core/lstack_dpdk.c b/src/lstack/core/lstack_dpdk.c +index e386dfc..297dd7b 100644 +--- a/src/lstack/core/lstack_dpdk.c ++++ b/src/lstack/core/lstack_dpdk.c +@@ -35,6 +35,9 @@ + #include + #include + #include ++#include ++#include ++#include + + #include "lstack_log.h" + #include "dpdk_common.h" +@@ -427,9 +430,10 @@ static void rss_setup(const int port_id, const uint16_t nb_queues) + free(reta_conf); + } + +-int32_t dpdk_ethdev_init(void) ++int32_t dpdk_ethdev_init(int port_id, bool bond_port) + { + uint16_t nb_queues = get_global_cfg_params()->num_cpu; ++ int32_t use_bond4 = get_global_cfg_params()->use_bond4; + if (get_global_cfg_params()->seperate_send_recv) { + nb_queues = get_global_cfg_params()->num_cpu * 2; + } +@@ -440,10 +444,13 @@ int32_t dpdk_ethdev_init(void) + + struct protocol_stack_group *stack_group = get_protocol_stack_group(); + +- int32_t port_id = ethdev_port_id(get_global_cfg_params()->mac_addr); +- if (port_id < 0) { +- return port_id; ++ if (!use_bond4) { ++ port_id = ethdev_port_id(get_global_cfg_params()->mac_addr); ++ if (port_id < 0) { ++ return port_id; ++ } + } ++ + get_global_cfg_params()->port_id = port_id; + + struct rte_eth_dev_info dev_info; +@@ -459,10 +466,38 @@ int32_t dpdk_ethdev_init(void) + return -EINVAL; + } + ++ if (bond_port) { ++ int slave_num = 2; ++ int32_t slave_port_id[2]; ++ slave_port_id[0] = ethdev_port_id(get_global_cfg_params()->bond4_slave1_mac_addr); ++ slave_port_id[1] = ethdev_port_id(get_global_cfg_params()->bond4_slave2_mac_addr); ++ ++ for (int i = 0; i < slave_num; i++) { ++ ret = dpdk_ethdev_init(slave_port_id[i], 0); ++ if (ret != 0) { ++ LSTACK_LOG(ERR, LSTACK, "dpdk_ethdev_init failed\n"); ++ return -1; ++ } ++ ret = rte_eth_promiscuous_enable(slave_port_id[i]); ++ rte_eth_allmulticast_enable(slave_port_id[i]); ++ ret = rte_eth_bond_slave_add(port_id, slave_port_id[i]); ++ ret = rte_eth_dev_start(slave_port_id[i]); ++ } ++ } ++ + struct eth_params *eth_params = alloc_eth_params(port_id, nb_queues); + if (eth_params == NULL) { + return -ENOMEM; + } ++ ++ if (bond_port) { ++ struct rte_eth_dev_info slave_dev_info; ++ int slave_id = rte_eth_bond_primary_get(port_id); ++ rte_eth_dev_info_get(slave_id, &slave_dev_info); ++ dev_info.rx_offload_capa = slave_dev_info.rx_offload_capa; ++ dev_info.tx_offload_capa = slave_dev_info.tx_offload_capa; ++ } ++ + eth_params_checksum(ð_params->conf, &dev_info); + int32_t rss_enable = 0; + if (!get_global_cfg_params()->tuple_filter) { +@@ -556,6 +591,10 @@ int32_t dpdk_ethdev_start(void) + } + } + ++ if (get_global_cfg_params()->use_bond4) { ++ return 0; ++ } ++ + ret = rte_eth_dev_start(stack_group->eth_params->port_id); + if (ret < 0) { + LSTACK_LOG(ERR, LSTACK, "cannot start ethdev: %d\n", (-ret)); +@@ -603,10 +642,45 @@ int32_t init_dpdk_ethdev(void) + { + int32_t ret; + +- ret = dpdk_ethdev_init(); +- if (ret != 0) { +- LSTACK_LOG(ERR, LSTACK, "dpdk_ethdev_init failed\n"); +- return -1; ++ if (get_global_cfg_params()->use_bond4) { ++ int bond_port_id = rte_eth_bond_create("net_bonding0", 4, (uint8_t)rte_socket_id()); ++ if (bond_port_id < 0) { ++ LSTACK_LOG(ERR, LSTACK, "get bond port id failed ret=%d\n", bond_port_id); ++ return bond_port_id; ++ } ++ ++ ret = dpdk_ethdev_init(bond_port_id, 1); ++ ret = rte_eth_bond_xmit_policy_set(bond_port_id, BALANCE_XMIT_POLICY_LAYER34); ++ if (ret < 0) { ++ return -1; ++ } ++ ++ ret = rte_eth_bond_8023ad_dedicated_queues_enable(bond_port_id); ++ if (ret < 0) { ++ return -1; ++ } ++ ++ ret = rte_eth_promiscuous_enable(bond_port_id); ++ if (ret < 0) { ++ return -1; ++ } ++ ++ ret = rte_eth_allmulticast_enable(bond_port_id); ++ if (ret < 0) { ++ return -1; ++ } ++ ++ ret = rte_eth_dev_start(bond_port_id); ++ /* 20: sleep for lacp ,this is a temp plan, it will be changed in future */ ++ int wait_lacp = 20; ++ sleep(wait_lacp); ++ ++ } else { ++ ret = dpdk_ethdev_init(0, 0); ++ if (ret != 0) { ++ LSTACK_LOG(ERR, LSTACK, "dpdk_ethdev_init failed\n"); ++ return -1; ++ } + } + + if (get_global_cfg_params()->kni_switch && get_global_cfg_params()->is_primary) { +diff --git a/src/lstack/include/lstack_cfg.h b/src/lstack/include/lstack_cfg.h +index a4170ca..4d0f611 100644 +--- a/src/lstack/include/lstack_cfg.h ++++ b/src/lstack/include/lstack_cfg.h +@@ -103,6 +103,9 @@ struct cfg_params { + uint16_t send_ring_size; + bool expand_send_ring; + bool tuple_filter; ++ bool use_bond4; ++ uint8_t bond4_slave1_mac_addr[ETHER_ADDR_LEN]; ++ uint8_t bond4_slave2_mac_addr[ETHER_ADDR_LEN]; + }; + + struct cfg_params *get_global_cfg_params(void); +diff --git a/src/lstack/include/lstack_dpdk.h b/src/lstack/include/lstack_dpdk.h +index a896903..1047c44 100644 +--- a/src/lstack/include/lstack_dpdk.h ++++ b/src/lstack/include/lstack_dpdk.h +@@ -46,7 +46,7 @@ int32_t pktmbuf_pool_init(struct protocol_stack *stack, uint16_t stack_num); + struct rte_ring *create_ring(const char *name, uint32_t count, uint32_t flags, int32_t queue_id); + int32_t create_shared_ring(struct protocol_stack *stack); + void lstack_log_level_init(void); +-int dpdk_ethdev_init(void); ++int dpdk_ethdev_init(int port_id, bool bond_port); + int dpdk_ethdev_start(void); + void dpdk_skip_nic_init(void); + int32_t dpdk_init_lstack_kni(void); +-- +2.33.0 + diff --git a/0244-clean-code.patch b/0244-clean-code.patch new file mode 100644 index 0000000..b441224 --- /dev/null +++ b/0244-clean-code.patch @@ -0,0 +1,2187 @@ +From dd9a270402cf8fe7f2adf9d6bad3a3ac1a2b7289 Mon Sep 17 00:00:00 2001 +From: jiangheng12 +Date: Fri, 5 May 2023 16:42:35 +0800 +Subject: [PATCH] clean code + +--- + src/common/gazelle_dfx_msg.h | 1 - + src/common/gazelle_opt.h | 3 +- + src/common/gazelle_parse_config.c | 8 +- + src/lstack/api/lstack_epoll.c | 1 - + src/lstack/api/lstack_wrap.c | 85 +++--- + src/lstack/core/lstack_cfg.c | 31 +- + src/lstack/core/lstack_control_plane.c | 9 +- + src/lstack/core/lstack_dpdk.c | 21 +- + src/lstack/core/lstack_init.c | 63 ++-- + src/lstack/core/lstack_lwip.c | 310 ++++++++++---------- + src/lstack/core/lstack_protocol_stack.c | 42 +-- + src/lstack/core/lstack_stack_stat.c | 10 +- + src/lstack/include/lstack_dpdk.h | 3 +- + src/lstack/include/lstack_ethdev.h | 4 +- + src/lstack/include/lstack_lockless_queue.h | 6 +- + src/lstack/include/lstack_protocol_stack.h | 2 +- + src/lstack/include/lstack_vdev.h | 3 +- + src/lstack/netif/lstack_ethdev.c | 318 +++++++++++---------- + src/lstack/netif/lstack_vdev.c | 16 +- + src/ltran/ltran_dfx.c | 10 +- + src/ltran/ltran_monitor.c | 2 +- + src/ltran/ltran_param.c | 2 +- + src/ltran/main.c | 4 +- + 23 files changed, 489 insertions(+), 465 deletions(-) + +diff --git a/src/common/gazelle_dfx_msg.h b/src/common/gazelle_dfx_msg.h +index e4da687..a89b82c 100644 +--- a/src/common/gazelle_dfx_msg.h ++++ b/src/common/gazelle_dfx_msg.h +@@ -15,7 +15,6 @@ + + #include + #include +-#include + + #define GAZELLE_CLIENT_NUM_MIN 1 + #define GAZELLE_LOG_LEVEL_MAX 10 +diff --git a/src/common/gazelle_opt.h b/src/common/gazelle_opt.h +index fe0483b..7b6aa19 100644 +--- a/src/common/gazelle_opt.h ++++ b/src/common/gazelle_opt.h +@@ -47,7 +47,8 @@ + + #define TCP_CONN_COUNT 1500 + #define MBUF_COUNT_PER_CONN 170 +-#define RXTX_NB_MBUF_DEFAULT (MBUF_COUNT_PER_CONN * TCP_CONN_COUNT) /* mbuf per connect * connect num. size of mbuf is 2536 Byte */ ++/* mbuf per connect * connect num. size of mbuf is 2536 Byte */ ++#define RXTX_NB_MBUF_DEFAULT (MBUF_COUNT_PER_CONN * TCP_CONN_COUNT) + #define STACK_THREAD_DEFAULT 4 + #define STACK_NIC_READ_DEFAULT 128 + +diff --git a/src/common/gazelle_parse_config.c b/src/common/gazelle_parse_config.c +index ce6a3f8..42e12b5 100644 +--- a/src/common/gazelle_parse_config.c ++++ b/src/common/gazelle_parse_config.c +@@ -55,7 +55,7 @@ int32_t separate_str_to_array(char *args, uint32_t *array, int32_t array_size, i + return -1; + } + errno = 0; +- /* prefix 0x,0X indicate hexdecimal */ ++ /* 2: prefix 0x,0X indicate hexdecimal */ + if (strncmp(args, "0x", 2) == 0 || strncmp(args, "0X", 2) == 0) { + idx = strtol(args, &end, 16); /* 16: hexdecimal */ + } else { +@@ -116,13 +116,15 @@ int32_t filename_check(const char* args) + } + + if (strlen(args) <= 0 || strlen(args) > GAZELLE_SOCK_FILENAME_MAXLEN - 1) { +- COMMON_ERR("socket_filename_check: invalid unix sock name %s, filename exceeds the limit %d.\n", args, GAZELLE_SOCK_FILENAME_MAXLEN); ++ COMMON_ERR("socket_filename_check: invalid unix sock name %s, filename exceeds the limit %d.\n", ++ args, GAZELLE_SOCK_FILENAME_MAXLEN); + return 1; + } + + char* sensitive_chars = strpbrk(args, "|;&$><`\\!\n"); + if (sensitive_chars != NULL) { +- COMMON_ERR("socket_filename_check: invalid unix sock name %s, filename contains sensitive characters.\n", args); ++ COMMON_ERR("socket_filename_check: invalid unix sock name %s, filename contains sensitive characters.\n", ++ args); + return 1; + } + +diff --git a/src/lstack/api/lstack_epoll.c b/src/lstack/api/lstack_epoll.c +index d4b4be7..06bd71b 100644 +--- a/src/lstack/api/lstack_epoll.c ++++ b/src/lstack/api/lstack_epoll.c +@@ -320,7 +320,6 @@ int32_t lstack_epoll_ctl(int32_t epfd, int32_t op, int32_t fd, struct epoll_even + return posix_api->epoll_ctl_fn(epfd, op, fd, event); + } + +- + struct wakeup_poll *wakeup = epoll_sock->wakeup; + struct lwip_sock *sock = get_socket(fd); + if (sock == NULL) { +diff --git a/src/lstack/api/lstack_wrap.c b/src/lstack/api/lstack_wrap.c +index 1b12822..98632c0 100644 +--- a/src/lstack/api/lstack_wrap.c ++++ b/src/lstack/api/lstack_wrap.c +@@ -199,7 +199,7 @@ static int get_addr(struct sockaddr_in *sin, char *interface) + memset_s(&ifr, sizeof(ifr), 0, sizeof(ifr)); + snprintf_s(ifr.ifr_name, sizeof(ifr.ifr_name), (sizeof(ifr.ifr_name) - 1), "%s", interface); + +- if(posix_api->ioctl_fn(sockfd, SIOCGIFADDR, &ifr) < 0){ ++ if (posix_api->ioctl_fn(sockfd, SIOCGIFADDR, &ifr) < 0) { + posix_api->close_fn(sockfd); + return -1; + } +@@ -243,11 +243,15 @@ bool is_dst_ip_localhost(const struct sockaddr *addr) + struct sockaddr_in* sin = malloc(sizeof(struct sockaddr_in)); + + while (getdelim(&line, &linel, '\n', ifh) > 0) { +- if (linenum++ < 2) continue; ++ /* 2: skip the first two lines, which are not nic name */ ++ if (linenum++ < 2) { ++ continue; ++ } + + p = line; +- while (isspace(*p)) +- ++p; ++ while (isspace(*p)) { ++ ++p; ++ } + int n = strcspn(p, ": \t"); + + char interface[20] = {0}; /* 20: nic name len */ +@@ -256,7 +260,7 @@ bool is_dst_ip_localhost(const struct sockaddr *addr) + memset_s(sin, sizeof(struct sockaddr_in), 0, sizeof(struct sockaddr_in)); + int ret = get_addr(sin, interface); + if (ret == 0) { +- if(sin->sin_addr.s_addr == servaddr->sin_addr.s_addr){ ++ if (sin->sin_addr.s_addr == servaddr->sin_addr.s_addr) { + return 1; + } + } +@@ -289,13 +293,14 @@ static int32_t do_connect(int32_t s, const struct sockaddr *name, socklen_t name + int32_t ret = 0; + char listen_ring_name[RING_NAME_LEN]; + int remote_port = htons(((struct sockaddr_in *)name)->sin_port); +- snprintf_s(listen_ring_name, sizeof(listen_ring_name), sizeof(listen_ring_name) - 1, "listen_rx_ring_%d", remote_port); ++ snprintf_s(listen_ring_name, sizeof(listen_ring_name), sizeof(listen_ring_name) - 1, ++ "listen_rx_ring_%d", remote_port); + if (is_dst_ip_localhost(name) && rte_ring_lookup(listen_ring_name) == NULL) { + ret = posix_api->connect_fn(s, name, namelen); +- SET_CONN_TYPE_HOST(sock->conn); ++ SET_CONN_TYPE_HOST(sock->conn); + } else { + ret = rpc_call_connect(s, name, namelen); +- SET_CONN_TYPE_LIBOS(sock->conn); ++ SET_CONN_TYPE_LIBOS(sock->conn); + } + + return ret; +@@ -435,26 +440,26 @@ static inline ssize_t do_read(int32_t s, void *mem, size_t len) + + static inline ssize_t do_readv(int32_t s, const struct iovec *iov, int iovcnt) + { +- struct lwip_sock *sock = NULL; +- if (select_path(s, &sock) != PATH_LWIP) { ++ struct lwip_sock *sock = NULL; ++ if (select_path(s, &sock) != PATH_LWIP) { + return posix_api->readv_fn(s, iov, iovcnt); +- } +- +- struct msghdr msg; +- +- msg.msg_name = NULL; +- msg.msg_namelen = 0; +- msg.msg_iov = LWIP_CONST_CAST(struct iovec *, iov); +- msg.msg_iovlen = iovcnt; +- msg.msg_control = NULL; +- msg.msg_controllen = 0; +- msg.msg_flags = 0; +- ssize_t result = recvmsg_from_stack(s, &msg, 0); +- if(result == -1 && errno == EAGAIN){ ++ } ++ ++ struct msghdr msg; ++ ++ msg.msg_name = NULL; ++ msg.msg_namelen = 0; ++ msg.msg_iov = LWIP_CONST_CAST(struct iovec *, iov); ++ msg.msg_iovlen = iovcnt; ++ msg.msg_control = NULL; ++ msg.msg_controllen = 0; ++ msg.msg_flags = 0; ++ ssize_t result = recvmsg_from_stack(s, &msg, 0); ++ if (result == -1 && errno == EAGAIN) { + errno = 0; +- return 0; +- } +- return result; ++ return 0; ++ } ++ return result; + } + + static inline ssize_t do_send(int32_t sockfd, const void *buf, size_t len, int32_t flags) +@@ -479,21 +484,21 @@ static inline ssize_t do_write(int32_t s, const void *mem, size_t size) + + static inline ssize_t do_writev(int32_t s, const struct iovec *iov, int iovcnt) + { +- struct lwip_sock *sock = NULL; +- if (select_path(s, &sock) != PATH_LWIP) { ++ struct lwip_sock *sock = NULL; ++ if (select_path(s, &sock) != PATH_LWIP) { + return posix_api->writev_fn(s, iov, iovcnt); +- } +- +- struct msghdr msg; +- +- msg.msg_name = NULL; +- msg.msg_namelen = 0; +- msg.msg_iov = LWIP_CONST_CAST(struct iovec *, iov); +- msg.msg_iovlen = iovcnt; +- msg.msg_control = NULL; +- msg.msg_controllen = 0; +- msg.msg_flags = 0; +- return sendmsg_to_stack(sock, s, &msg, 0); ++ } ++ ++ struct msghdr msg; ++ ++ msg.msg_name = NULL; ++ msg.msg_namelen = 0; ++ msg.msg_iov = LWIP_CONST_CAST(struct iovec *, iov); ++ msg.msg_iovlen = iovcnt; ++ msg.msg_control = NULL; ++ msg.msg_controllen = 0; ++ msg.msg_flags = 0; ++ return sendmsg_to_stack(sock, s, &msg, 0); + } + + static inline ssize_t do_recvmsg(int32_t s, struct msghdr *message, int32_t flags) +diff --git a/src/lstack/core/lstack_cfg.c b/src/lstack/core/lstack_cfg.c +index c4919d3..a21992e 100644 +--- a/src/lstack/core/lstack_cfg.c ++++ b/src/lstack/core/lstack_cfg.c +@@ -77,19 +77,19 @@ static int32_t parse_bond4_slave_mac(void); + const config_setting_t *_config_arg = NULL; \ + _config_arg = config_lookup(&g_config, _arg_string); \ + if (_config_arg == NULL) { \ +- _arg = _default_val; \ +- _ret = 0; \ ++ (_arg) = (_default_val); \ ++ (_ret) = 0; \ + break; \ + } \ + int32_t _val = config_setting_get_int(_config_arg); \ +- if (_val < _min_val || _val > _max_val) { \ ++ if (_val < (_min_val) || _val > (_max_val)) { \ + LSTACK_PRE_LOG(LSTACK_ERR, "cfg %s %d invaild, range is [%d, %d].\n", \ +- _arg_string, _val, _min_val, _max_val); \ +- _ret = -EINVAL; \ ++ (_arg_string), _val, (_min_val), (_max_val)); \ ++ (_ret) = -EINVAL; \ + break; \ + } \ +- _arg = _val; \ +- _ret = 0; \ ++ (_arg) = _val; \ ++ (_ret) = 0; \ + } while (0) + + struct config_vector_t { +@@ -346,7 +346,8 @@ static int32_t parse_stack_cpu_number(void) + } + + char *tmp_arg_send = strdup(args); +- int32_t send_cpu_cnt = separate_str_to_array(tmp_arg_send, g_config_params.send_cpus, CFG_MAX_CPUS, CFG_MAX_CPUS); ++ int32_t send_cpu_cnt = separate_str_to_array(tmp_arg_send, g_config_params.send_cpus, ++ CFG_MAX_CPUS, CFG_MAX_CPUS); + free(tmp_arg_send); + + // recv_num_cpus +@@ -372,7 +373,8 @@ static int32_t parse_stack_cpu_number(void) + } + + char *tmp_arg_recv = strdup(args); +- int32_t recv_cpu_cnt = separate_str_to_array(tmp_arg_recv, g_config_params.recv_cpus, CFG_MAX_CPUS, CFG_MAX_CPUS); ++ int32_t recv_cpu_cnt = separate_str_to_array(tmp_arg_recv, g_config_params.recv_cpus, ++ CFG_MAX_CPUS, CFG_MAX_CPUS); + free(tmp_arg_recv); + + if (send_cpu_cnt <= 0 || send_cpu_cnt > CFG_MAX_CPUS / 2 || send_cpu_cnt != recv_cpu_cnt) { +@@ -448,7 +450,7 @@ int32_t init_stack_numa_cpuset(struct protocol_stack *stack) + for (int32_t idx = 0; idx < cfg->num_cpu; ++idx) { + if (!cfg->seperate_send_recv) { + CPU_SET(cfg->cpus[idx], &stack_cpuset); +- }else { ++ } else { + CPU_SET(cfg->send_cpus[idx], &stack_cpuset); + CPU_SET(cfg->recv_cpus[idx], &stack_cpuset); + } +@@ -498,7 +500,6 @@ static int32_t gazelle_parse_socket_mem(const char *arg, struct secondary_attach + + int32_t count = separate_str_to_array(socket_mem, sec_attach_arg->socket_per_size, + GAZELLE_MAX_NUMA_NODES, INT32_MAX); +- + if (count < 0) { + return -1; + } +@@ -730,7 +731,7 @@ static int32_t parse_dpdk_args(void) + g_config_params.dpdk_argv[start_index + i] = p; + + const char *primary = "primary"; +- if(strcmp(p, primary) == 0){ ++ if (strcmp(p, primary) == 0) { + struct cfg_params *global_params = get_global_cfg_params(); + global_params->is_primary = 1; + } +@@ -941,10 +942,8 @@ static int32_t parse_unix_prefix(void) + } + + unix_prefix = config_lookup(&g_config, "unix_prefix"); +- + if (unix_prefix) { + args = config_setting_get_string(unix_prefix); +- + if (filename_check(args)) { + return -EINVAL; + } +@@ -983,7 +982,7 @@ static int32_t parse_num_process(void) + num_process = config_lookup(&g_config, "num_process"); + if (num_process == NULL) { + g_config_params.num_process = 1; +- }else { ++ } else { + g_config_params.num_process = (uint8_t)config_setting_get_int(num_process); + } + +@@ -1026,7 +1025,7 @@ static int parse_process_index(void) + if (process_idx == NULL) { + if (g_config_params.num_process == 1) { + g_config_params.process_idx = 0; +- }else { ++ } else { + return -EINVAL; + } + } else { +diff --git a/src/lstack/core/lstack_control_plane.c b/src/lstack/core/lstack_control_plane.c +index e705cae..be156dc 100644 +--- a/src/lstack/core/lstack_control_plane.c ++++ b/src/lstack/core/lstack_control_plane.c +@@ -466,14 +466,15 @@ void control_fd_close(void) + + struct cfg_params *global_params = get_global_cfg_params(); + if (!global_params->use_ltran) { +- int ret = unlink(global_params->unix_socket_filename); +- if (ret == -1) { ++ int ret = unlink(global_params->unix_socket_filename); ++ if (ret == -1) { + LSTACK_LOG(ERR, LSTACK, "unlink failed, just skip it\n"); +- } ++ } + } + } + +-void delete_primary_path(void) { ++void delete_primary_path(void) ++{ + if (!remove(GAZELLE_PRIMARY_START_PATH)) { + LSTACK_LOG(ERR, LSTACK, "delete %s failed\n", GAZELLE_PRIMARY_START_PATH); + } +diff --git a/src/lstack/core/lstack_dpdk.c b/src/lstack/core/lstack_dpdk.c +index 297dd7b..b321c18 100644 +--- a/src/lstack/core/lstack_dpdk.c ++++ b/src/lstack/core/lstack_dpdk.c +@@ -41,12 +41,12 @@ + + #include "lstack_log.h" + #include "dpdk_common.h" +-#include "lstack_dpdk.h" + #include "lstack_lockless_queue.h" + #include "lstack_protocol_stack.h" + #include "lstack_thread_rpc.h" + #include "lstack_lwip.h" + #include "lstack_cfg.h" ++#include "lstack_dpdk.h" + + struct eth_params { + uint16_t port_id; +@@ -119,7 +119,7 @@ int32_t dpdk_eal_init(void) + ret = 0; + } else { + LSTACK_PRE_LOG(LSTACK_ERR, "rte_eal_init failed init, rte_errno %d\n", rte_errno); +- return ret; ++ return ret; + } + } else { + LSTACK_PRE_LOG(LSTACK_INFO, "dpdk_eal_init success\n"); +@@ -158,7 +158,8 @@ struct rte_mempool *create_pktmbuf_mempool(const char *name, uint32_t nb_mbuf, + return pool; + } + +-static struct rte_mempool* get_pktmbuf_mempool(const char *name, uint16_t queue_id){ ++static struct rte_mempool* get_pktmbuf_mempool(const char *name, uint16_t queue_id) ++{ + int32_t ret; + char pool_name[PATH_MAX]; + struct rte_mempool *pool; +@@ -172,9 +173,7 @@ static struct rte_mempool* get_pktmbuf_mempool(const char *name, uint16_t queue_ + LSTACK_LOG(ERR, LSTACK, "look up %s pool rte_err=%d\n", pool_name, rte_errno); + } + +- // rte_mempool_dump(stdout, pool) ; + return pool; +- + } + + static struct reg_ring_msg *create_reg_mempool(const char *name, uint16_t queue_id) +@@ -223,7 +222,8 @@ struct rte_ring *create_ring(const char *name, uint32_t count, uint32_t flags, i + char ring_name[RTE_RING_NAMESIZE] = {0}; + struct rte_ring *ring; + +- int32_t ret = snprintf_s(ring_name, sizeof(ring_name), RTE_RING_NAMESIZE - 1, "%s_%d_%d", name, get_global_cfg_params()->process_idx, queue_id); ++ int32_t ret = snprintf_s(ring_name, sizeof(ring_name), RTE_RING_NAMESIZE - 1, ++ "%s_%d_%d", name, get_global_cfg_params()->process_idx, queue_id); + if (ret < 0) { + return NULL; + } +@@ -556,10 +556,10 @@ static int32_t dpdk_ethdev_setup(const struct eth_params *eth_params, uint16_t i + struct rte_mempool *rxtx_pktmbuf_pool = get_protocol_stack_group()->total_rxtx_pktmbuf_pool[idx]; + + uint16_t socket_id = 0; +- struct cfg_params * cfg = get_global_cfg_params(); ++ struct cfg_params *cfg = get_global_cfg_params(); + if (!cfg->use_ltran && cfg->num_process == 1) { + socket_id = numa_node_of_cpu(cfg->cpus[idx]); +- }else { ++ } else { + socket_id = cfg->process_numa[idx]; + } + ret = rte_eth_rx_queue_setup(eth_params->port_id, idx, eth_params->nb_rx_desc, socket_id, +@@ -607,8 +607,6 @@ int32_t dpdk_ethdev_start(void) + int32_t dpdk_init_lstack_kni(void) + { + struct protocol_stack_group *stack_group = get_protocol_stack_group(); +- +- + stack_group->kni_pktmbuf_pool = create_pktmbuf_mempool("kni_mbuf", KNI_NB_MBUF, 0, 0); + if (stack_group->kni_pktmbuf_pool == NULL) { + return -1; +@@ -725,7 +723,8 @@ void dpdk_nic_xstats_get(struct gazelle_stack_dfx_data *dfx, uint16_t port_id) + if (len < 0) { + return; + } +- if (len != rte_eth_xstats_get_names_by_id(port_id, (struct rte_eth_xstat_name *)dfx->data.nic_xstats.xstats_name, len, NULL)) { ++ if (len != rte_eth_xstats_get_names_by_id(port_id, ++ (struct rte_eth_xstat_name *)dfx->data.nic_xstats.xstats_name, len, NULL)) { + dfx->data.nic_xstats.len = -1; + return; + } +diff --git a/src/lstack/core/lstack_init.c b/src/lstack/core/lstack_init.c +index f17e4d2..4fbbc14 100644 +--- a/src/lstack/core/lstack_init.c ++++ b/src/lstack/core/lstack_init.c +@@ -98,18 +98,20 @@ static int32_t preload_info_init(void) + return 0; + } + +-static void check_process_start(void) { ++static void check_process_start(void) ++{ + if (get_global_cfg_params()->is_primary) { + return; + } + + while (!fopen(GAZELLE_PRIMARY_START_PATH, "r")) { +- printf("please make sure the primary process start already!\n"); +- sleep(1); ++ LSTACK_LOG(INFO, LSTACK, "please make sure the primary process start already!\n"); ++ sleep(1); + } + } + +-static int32_t set_process_start_flag(void) { ++static int32_t set_process_start_flag(void) ++{ + if (!get_global_cfg_params()->is_primary) { + return 0; + } +@@ -118,7 +120,7 @@ static int32_t set_process_start_flag(void) { + fp = fopen(GAZELLE_PRIMARY_START_PATH, "w"); + if (fp == NULL) { + LSTACK_PRE_LOG(LSTACK_ERR, "set primary proceaa start flag failed!\n"); +- return -1; ++ return -1; + } + (void)fclose(fp); + return 0; +@@ -199,9 +201,7 @@ static void create_control_thread(void) + + pthread_t tid; + if (use_ltran()) { +- /* +- * The function call here should be in strict order. +- */ ++ /* The function call here should be in strict order. */ + dpdk_skip_nic_init(); + if (control_init_client(false) != 0) { + LSTACK_EXIT(1, "control_init_client failed\n"); +@@ -235,8 +235,7 @@ static void gazelle_signal_init(void) + LSTACK_EXIT(1, "signal SIGPIPE SIG_IGN\n"); + } + +- /* +- * register core sig handler func to dumped stack */ ++ /* register core sig handler func to dumped stack */ + lstack_signal_init(); + } + +@@ -264,15 +263,16 @@ static void set_kni_ip_mac() + } + + set_ifr.ifr_hwaddr.sa_family = ARPHRD_ETHER; ++ /* 6: mac addr len */ + for (int i = 0; i < 6; i++) { + set_ifr.ifr_hwaddr.sa_data[i] = cfg->mac_addr[i]; + } + + if (posix_api->ioctl_fn(fd, SIOCSIFHWADDR, &set_ifr) < 0) { + LSTACK_LOG(ERR, LSTACK, "set kni macaddr=%hhx:%hhx:%hhx:%hhx:%hhx:%hhx fail\n", +- cfg->mac_addr[0], cfg->mac_addr[1], +- cfg->mac_addr[2], cfg->mac_addr[3], +- cfg->mac_addr[4], cfg->mac_addr[5]); ++ cfg->mac_addr[0], cfg->mac_addr[1], ++ cfg->mac_addr[2], cfg->mac_addr[3], ++ cfg->mac_addr[4], cfg->mac_addr[5]); + } + + if (posix_api->ioctl_fn(fd, SIOCGIFFLAGS, &set_ifr) < 0) { +@@ -280,7 +280,7 @@ static void set_kni_ip_mac() + } + + set_ifr.ifr_flags |= (IFF_RUNNING | IFF_UP); +- if (posix_api->ioctl_fn(fd, SIOCSIFFLAGS, &set_ifr) < 0){ ++ if (posix_api->ioctl_fn(fd, SIOCSIFFLAGS, &set_ifr) < 0) { + LSTACK_LOG(ERR, LSTACK, "set kni state fail\n"); + } + +@@ -289,16 +289,14 @@ static void set_kni_ip_mac() + + __attribute__((constructor)) void gazelle_network_init(void) + { +- /* +- * Init POSXI API and prelog */ ++ /* Init POSXI API and prelog */ + lstack_prelog_init("LSTACK"); + if (posix_api_init() != 0) { + LSTACK_PRE_LOG(LSTACK_ERR, "posix_api_init failed\n"); + LSTACK_EXIT(1, "failed\n"); + } + +- /* +- * Init LD_PRELOAD */ ++ /* Init LD_PRELOAD */ + if (preload_info_init() < 0) { + return; + } +@@ -306,35 +304,29 @@ __attribute__((constructor)) void gazelle_network_init(void) + return; + } + +- /* +- * Read configure from lstack.cfg */ ++ /* Read configure from lstack.cfg */ + if (cfg_init() != 0) { + LSTACK_PRE_LOG(LSTACK_ERR, "cfg_init failed\n"); + LSTACK_EXIT(1, "cfg_init failed\n"); + } + LSTACK_PRE_LOG(LSTACK_INFO, "cfg_init success\n"); + +- /* +- * check primary process start */ ++ /* check primary process start */ + check_process_start(); + +- /* +- * check conflict */ ++ /* check conflict */ + if (check_process_conflict() < 0) { + LSTACK_PRE_LOG(LSTACK_INFO, "Have another same primary process. WARNING: Posix API will use kernel mode!\n"); + return; + } + +- /** +- * check lstack num, and get process idx +- */ ++ /* check lstack num, and get process idx */ + if (check_params_from_primary() < 0) { + LSTACK_PRE_LOG(LSTACK_ERR, "lstack num error, not same to primary process!\n"); + LSTACK_EXIT(1, "lstack num error, not same to primary process!\n"); + } + +- /* +- * save initial affinity */ ++ /* save initial affinity */ + if (!get_global_cfg_params()->main_thread_affinity) { + if (thread_affinity_default() < 0) { + LSTACK_PRE_LOG(LSTACK_ERR, "pthread_getaffinity_np failed\n"); +@@ -342,17 +334,13 @@ __attribute__((constructor)) void gazelle_network_init(void) + } + } + +- // @todo, check process 2 dumped, resorce need to release. +- + gazelle_signal_init(); + +- /* +- * Init control plane and dpdk init */ ++ /* Init control plane and dpdk init */ + create_control_thread(); + dpdk_restore_pci(); + +- /* +- * cancel the core binding from DPDK initialization */ ++ /* cancel the core binding from DPDK initialization */ + if (!get_global_cfg_params()->main_thread_affinity) { + if (thread_affinity_default() < 0) { + LSTACK_EXIT(1, "pthread_setaffinity_np failed\n"); +@@ -366,16 +354,13 @@ __attribute__((constructor)) void gazelle_network_init(void) + LSTACK_EXIT(1, "init_protocol_stack failed\n"); + } + +- /* +- * nic */ + if (!use_ltran()) { + if (init_dpdk_ethdev() != 0) { + LSTACK_EXIT(1, "init_dpdk_ethdev failed\n"); + } + } + +- /* +- * lwip initialization */ ++ /* lwip initialization */ + lwip_sock_init(); + + /* wait stack thread and kernel_event thread init finish */ +diff --git a/src/lstack/core/lstack_lwip.c b/src/lstack/core/lstack_lwip.c +index f992e67..ed89054 100644 +--- a/src/lstack/core/lstack_lwip.c ++++ b/src/lstack/core/lstack_lwip.c +@@ -33,8 +33,8 @@ + #include "posix/lstack_epoll.h" + #include "lstack_thread_rpc.h" + #include "dpdk_common.h" +-#include "lstack_lwip.h" + #include "lstack_cfg.h" ++#include "lstack_lwip.h" + + static void free_ring_pbuf(struct rte_ring *ring) + { +@@ -263,7 +263,7 @@ struct pbuf *write_lwip_data(struct lwip_sock *sock, uint16_t remain_size, uint8 + return NULL; + } + if (pbuf->allow_in == 1) { +- __sync_fetch_and_sub(&pbuf->allow_in, 1); ++ __sync_fetch_and_sub(&pbuf->allow_in, 1); + } + pthread_spin_unlock(&pbuf->pbuf_lock); + +@@ -300,7 +300,7 @@ struct pbuf *write_lwip_data(struct lwip_sock *sock, uint16_t remain_size, uint8 + pbuf->head = 1; + return NULL; + } +- if(pbuf->allow_in == 1){ ++ if (pbuf->allow_in == 1) { + __sync_fetch_and_sub(&pbuf->allow_in, 1); + } + pthread_spin_unlock(&pbuf->pbuf_lock); +@@ -374,6 +374,9 @@ static ssize_t do_app_write(struct pbuf *pbufs[], void *buf, size_t len, uint32_ + static inline ssize_t app_direct_write(struct protocol_stack *stack, struct lwip_sock *sock, void *buf, + size_t len, uint32_t write_num) + { ++ if (write_num == 0) { ++ return 0; ++ } + struct pbuf **pbufs = (struct pbuf **)malloc(write_num * sizeof(struct pbuf *)); + if (pbufs == NULL) { + return 0; +@@ -410,6 +413,9 @@ static inline ssize_t app_direct_write(struct protocol_stack *stack, struct lwip + static inline ssize_t app_direct_attach(struct protocol_stack *stack, struct pbuf *attach_pbuf, void *buf, + size_t len, uint32_t write_num) + { ++ if (write_num == 0) { ++ return 0; ++ } + struct pbuf **pbufs = (struct pbuf **)malloc(write_num * sizeof(struct pbuf *)); + if (pbufs == NULL) { + return 0; +@@ -468,7 +474,7 @@ static inline struct pbuf *gazelle_ring_readlast(struct rte_ring *r) + + DEQUEUE_PTRS(r, &r[1], last, ((void **)&last_pbuf), 1, void *); + if (pthread_spin_trylock(&last_pbuf->pbuf_lock) != 0) { +- return NULL; ++ return NULL; + } + if (last_pbuf->allow_in != 1) { + pthread_spin_unlock(&last_pbuf->pbuf_lock); +@@ -586,7 +592,8 @@ ssize_t write_stack_data(struct lwip_sock *sock, const void *buf, size_t len) + + /* send_ring have idle */ + if (get_global_cfg_params()->expand_send_ring) { +- send_len += (write_num <= write_avail) ? app_buff_write(sock, (char *)buf + send_len, len - send_len, write_num) : ++ send_len += (write_num <= write_avail) ? ++ app_buff_write(sock, (char *)buf + send_len, len - send_len, write_num) : + app_direct_write(stack, sock, (char *)buf + send_len, len - send_len, write_num); + } else { + if (write_num > write_avail) { +@@ -661,7 +668,7 @@ void stack_send(struct rpc_msg *msg) + rpc_msg_free(msg); + return; + } else { +- if(__atomic_load_n(&sock->call_num, __ATOMIC_ACQUIRE) == 0){ ++ if (__atomic_load_n(&sock->call_num, __ATOMIC_ACQUIRE) == 0) { + rpc_call(&stack->rpc_queue, msg); + __sync_fetch_and_add(&sock->call_num, 1); + } else { +@@ -740,7 +747,7 @@ ssize_t read_lwip_data(struct lwip_sock *sock, int32_t flags, u8_t apiflags) + + sock->stack->stats.read_lwip_cnt += read_count; + if (recv_len == 0) { +- GAZELLE_RETURN(EAGAIN); ++ GAZELLE_RETURN(EAGAIN); + } + return recv_len; + } +@@ -796,11 +803,10 @@ ssize_t recvmsg_from_stack(int32_t s, struct msghdr *message, int32_t flags) + + static inline void notice_stack_send(struct lwip_sock *sock, int32_t fd, int32_t len, int32_t flags) + { +- if(__atomic_load_n(&sock->call_num, __ATOMIC_ACQUIRE) >= 2){ +- ;; +- } else { ++ // 2: call_num >= 2, don't need add new rpc send ++ if (__atomic_load_n(&sock->call_num, __ATOMIC_ACQUIRE) < 2) { + while (rpc_call_send(fd, NULL, len, flags) < 0) { +- usleep(1000); // wait 1ms to exec again ++ usleep(1000); // 1000: wait 1ms to exec again + LSTACK_LOG(INFO, LSTACK, "rpc_call_send failed, try again\n"); + } + __sync_fetch_and_add(&sock->call_num, 1); +@@ -837,10 +843,8 @@ ssize_t gazelle_same_node_ring_recv(struct lwip_sock *sock, const void *buf, siz + act_len = -1; + goto END; + } +- + act_len = cur_end - index + 1; + act_len = RTE_MIN(act_len, len); +- + if ((index & SAME_NODE_RING_MASK) + act_len > SAME_NODE_RING_LEN) { + size_t act_len1 = SAME_NODE_RING_LEN - (index & SAME_NODE_RING_MASK); + size_t act_len2 = act_len - act_len1; +@@ -897,7 +901,8 @@ ssize_t gazelle_same_node_ring_send(struct lwip_sock *sock, const void *buf, siz + PER_THREAD uint16_t stack_sock_num[GAZELLE_MAX_STACK_NUM] = {0}; + PER_THREAD uint16_t max_sock_stack = 0; + +-static inline void thread_bind_stack(struct lwip_sock *sock) { ++static inline void thread_bind_stack(struct lwip_sock *sock) ++{ + if (likely(sock->already_bind_numa || !sock->stack)) { + return; + } +@@ -905,7 +910,7 @@ static inline void thread_bind_stack(struct lwip_sock *sock) { + stack_sock_num[sock->stack->stack_idx]++; + if (stack_sock_num[sock->stack->stack_idx] > max_sock_stack) { + max_sock_stack = stack_sock_num[sock->stack->stack_idx]; +- bind_to_stack_numa(sock->stack); ++ bind_to_stack_numa(sock->stack); + } + } + +@@ -959,7 +964,7 @@ ssize_t sendmsg_to_stack(struct lwip_sock *sock, int32_t s, const struct msghdr + buflen += ret; + + if (ret < message->msg_iov[i].iov_len) { +- break; ++ break; + } + } + +@@ -1103,7 +1108,6 @@ void read_recv_list(struct protocol_stack *stack, uint32_t max_num) + + ssize_t len = lwip_recv(sock->conn->socket, NULL, 0, 0); + if (len == 0) { +- /* FIXME: should use POLLRDHUP, when connection be closed. lwip event-callback no POLLRDHUP */ + sock->errevent = 1; + add_sock_event(sock, EPOLLERR); + } else if (len > 0) { +@@ -1124,7 +1128,7 @@ void gazelle_connected_callback(struct netconn *conn) + return; + } + +- if (sock->wakeup != NULL && sock->wakeup->epollfd > 0){ ++ if (sock->wakeup != NULL && sock->wakeup->epollfd > 0) { + posix_api->epoll_ctl_fn(sock->wakeup->epollfd, EPOLL_CTL_DEL, fd, NULL); + } + +@@ -1185,7 +1189,7 @@ static inline void clone_lwip_socket_opt(struct lwip_sock *dst_sock, struct lwip + + int32_t gazelle_socket(int domain, int type, int protocol) + { +- if (((type & SOCK_TYPE_MASK) & ~SOCK_STREAM) != 0){ ++ if (((type & SOCK_TYPE_MASK) & ~SOCK_STREAM) != 0) { + LSTACK_LOG(ERR, LSTACK, "sock type error:%d, only support SOCK_STREAM \n", type); + return -1; + } +@@ -1336,125 +1340,125 @@ void stack_recvlist_count(struct rpc_msg *msg) + + void netif_poll(struct netif *netif) + { +- struct tcp_pcb *pcb = NULL; +- struct tcp_pcb_listen *pcbl = NULL; ++ struct tcp_pcb *pcb = NULL; ++ struct tcp_pcb_listen *pcbl = NULL; + +- for (pcb = tcp_active_pcbs; pcb != NULL; pcb = pcb->next) { ++ for (pcb = tcp_active_pcbs; pcb != NULL; pcb = pcb->next) { + #define NETIF_POLL_READ_COUNT 32 +- struct pbuf *pbufs[NETIF_POLL_READ_COUNT]; +- int ret; +- +- if (pcb->client_rx_ring != NULL) { +- ret = rte_ring_sc_dequeue_burst(pcb->client_rx_ring, (void **)pbufs, NETIF_POLL_READ_COUNT, NULL); +- for (int i = 0; i < ret; i++) { +- if (ip_input(pbufs[i], netif) != 0) { +- LSTACK_LOG(INFO, LSTACK, "netif_poll: ip_input return err\n"); +- pbuf_free(pbufs[i]); ++ struct pbuf *pbufs[NETIF_POLL_READ_COUNT]; ++ int ret; ++ ++ if (pcb->client_rx_ring != NULL) { ++ ret = rte_ring_sc_dequeue_burst(pcb->client_rx_ring, (void **)pbufs, NETIF_POLL_READ_COUNT, NULL); ++ for (int i = 0; i < ret; i++) { ++ if (ip_input(pbufs[i], netif) != 0) { ++ LSTACK_LOG(INFO, LSTACK, "ip_input return err\n"); ++ pbuf_free(pbufs[i]); ++ } ++ } + } +- } +- } +- } +- for (pcbl = tcp_listen_pcbs.listen_pcbs; pcbl != NULL; pcbl = pcbl->next) { +- if (pcbl->listen_rx_ring != NULL) { +- struct pbuf *pbuf; +- if (rte_ring_sc_dequeue(pcbl->listen_rx_ring, (void **)&pbuf) == 0) { +- if (ip_input(pbuf, netif) != ERR_OK) { +- pbuf_free(pbuf); ++ } ++ for (pcbl = tcp_listen_pcbs.listen_pcbs; pcbl != NULL; pcbl = pcbl->next) { ++ if (pcbl->listen_rx_ring != NULL) { ++ struct pbuf *pbuf; ++ if (rte_ring_sc_dequeue(pcbl->listen_rx_ring, (void **)&pbuf) == 0) { ++ if (ip_input(pbuf, netif) != ERR_OK) { ++ pbuf_free(pbuf); ++ } ++ } + } +- } + } +- } + } + + /* processes on same node handshake packet use this function */ + err_t netif_loop_output(struct netif *netif, struct pbuf *p) + { +- struct tcp_pcb *pcb = p->pcb; +- struct pbuf *head = NULL; +- +- if (pcb == NULL || pcb->client_tx_ring == NULL) { +- LSTACK_LOG(ERR, LSTACK, "netif_loop_output: pcb is null\n"); +- return ERR_ARG; +- } +- +- if (p->next != NULL) { +- LSTACK_LOG(ERR, LSTACK, "netif_loop_output: not support chained pbuf\n"); +- return ERR_ARG; +- } +- +- struct tcp_hdr *tcp_hdr = (struct tcp_hdr *)((char *)p->payload + sizeof(struct ip_hdr)); +- uint8_t flags = TCPH_FLAGS(tcp_hdr); +- +- head = pbuf_alloc(0, p->len, PBUF_RAM); +- if (head == NULL) { +- LSTACK_LOG(ERR, LSTACK, "netif_loop_output: pbuf_alloc failed\n"); +- return ERR_MEM; +- } +- head->ol_flags = p->ol_flags; +- memcpy_s(head->payload, head->len, p->payload, p->len); +- +- if ((flags & TCP_SYN) && !(flags & TCP_ACK)) { +- /* SYN packet, send to listen_ring */ +- char ring_name[RING_NAME_LEN] = {0}; +- snprintf_s(ring_name, sizeof(ring_name), sizeof(ring_name) - 1, "listen_rx_ring_%d", pcb->remote_port); +- struct rte_ring *ring = rte_ring_lookup(ring_name); +- if (ring == NULL) { +- LSTACK_LOG(INFO, LSTACK, "netif_loop_output: cant find listen_rx_ring %d\n", pcb->remote_port); +- pbuf_free(head); ++ struct tcp_pcb *pcb = p->pcb; ++ struct pbuf *head = NULL; ++ ++ if (pcb == NULL || pcb->client_tx_ring == NULL) { ++ LSTACK_LOG(ERR, LSTACK, "pcb is null\n"); ++ return ERR_ARG; ++ } ++ ++ if (p->next != NULL) { ++ LSTACK_LOG(ERR, LSTACK, "netif_loop_output: not support chained pbuf\n"); ++ return ERR_ARG; ++ } ++ ++ struct tcp_hdr *tcp_hdr = (struct tcp_hdr *)((char *)p->payload + sizeof(struct ip_hdr)); ++ uint8_t flags = TCPH_FLAGS(tcp_hdr); ++ ++ head = pbuf_alloc(0, p->len, PBUF_RAM); ++ if (head == NULL) { ++ LSTACK_LOG(ERR, LSTACK, "netif_loop_output: pbuf_alloc failed\n"); ++ return ERR_MEM; ++ } ++ head->ol_flags = p->ol_flags; ++ memcpy_s(head->payload, head->len, p->payload, p->len); ++ ++ if ((flags & TCP_SYN) && !(flags & TCP_ACK)) { ++ /* SYN packet, send to listen_ring */ ++ char ring_name[RING_NAME_LEN] = {0}; ++ snprintf_s(ring_name, sizeof(ring_name), sizeof(ring_name) - 1, "listen_rx_ring_%d", pcb->remote_port); ++ struct rte_ring *ring = rte_ring_lookup(ring_name); ++ if (ring == NULL) { ++ LSTACK_LOG(INFO, LSTACK, "netif_loop_output: cant find listen_rx_ring %d\n", pcb->remote_port); ++ pbuf_free(head); ++ } else { ++ if (rte_ring_mp_enqueue(ring, head) != 0) { ++ LSTACK_LOG(INFO, LSTACK, "enqueue sync packet failed\n"); ++ pbuf_free(head); ++ } ++ } + } else { +- if (rte_ring_mp_enqueue(ring, head) != 0) { +- LSTACK_LOG(INFO, LSTACK, "enqueue sync packet failed\n"); ++ /* send other type packet to tx_ring */ ++ if (rte_ring_sp_enqueue(pcb->client_tx_ring, head) != 0) { ++ LSTACK_LOG(INFO, LSTACK, "client tx ring full\n"); + pbuf_free(head); + } + } +- } else { +- /* send other type packet to tx_ring */ +- if (rte_ring_sp_enqueue(pcb->client_tx_ring, head) != 0) { +- LSTACK_LOG(INFO, LSTACK, "client tx ring full\n"); +- pbuf_free(head); +- } +- } + +- return ERR_OK; ++ return ERR_OK; + } + + err_t find_same_node_memzone(struct tcp_pcb *pcb, struct lwip_sock *nsock) + { +- char name[RING_NAME_LEN]; +- snprintf_s(name, sizeof(name), sizeof(name) - 1, "rte_mz_rx_%u", pcb->remote_port); +- if ((nsock->same_node_tx_ring_mz = rte_memzone_lookup(name)) == NULL) { +- LSTACK_LOG(INFO, LSTACK, "lwip_accept: can't find %s\n",name); +- return -1; +- } else { +- LSTACK_LOG(INFO, LSTACK, "lookup %s success\n", name); +- } +- nsock->same_node_tx_ring = (struct same_node_ring *)nsock->same_node_tx_ring_mz->addr; +- +- snprintf_s(name, sizeof(name), sizeof(name) - 1, "rte_mz_buf_rx_%u", pcb->remote_port); +- if ((nsock->same_node_tx_ring->mz = rte_memzone_lookup(name)) == NULL) { +- LSTACK_LOG(INFO, LSTACK, "lwip_accept: can't find %s\n",name); +- return -1; +- } +- +- snprintf_s(name, sizeof(name), sizeof(name) - 1, "rte_mz_tx_%u", pcb->remote_port); +- if ((nsock->same_node_rx_ring_mz = rte_memzone_lookup(name)) == NULL) { +- LSTACK_LOG(INFO, LSTACK, "lwip_accept: can't find %s\n",name); +- return -1; +- } else { +- LSTACK_LOG(INFO, LSTACK, "lookup %s success\n", name); +- } +- nsock->same_node_rx_ring = (struct same_node_ring *)nsock->same_node_rx_ring_mz->addr; +- +- snprintf_s(name, sizeof(name), sizeof(name) - 1,"rte_mz_buf_tx_%u", pcb->remote_port); +- if ((nsock->same_node_rx_ring->mz = rte_memzone_lookup(name)) == NULL) { +- LSTACK_LOG(INFO, LSTACK, "lwip_accept: can't find %s\n",name); +- return -1; +- } +- +- /* rcvlink init in alloc_socket() */ +- /* remove from g_rcv_process_list in free_socket */ +- list_add_node(&nsock->stack->same_node_recv_list, &nsock->recv_list); +- return 0; ++ char name[RING_NAME_LEN]; ++ snprintf_s(name, sizeof(name), sizeof(name) - 1, "rte_mz_rx_%u", pcb->remote_port); ++ if ((nsock->same_node_tx_ring_mz = rte_memzone_lookup(name)) == NULL) { ++ LSTACK_LOG(INFO, LSTACK, "lwip_accept: can't find %s\n",name); ++ return -1; ++ } else { ++ LSTACK_LOG(INFO, LSTACK, "lookup %s success\n", name); ++ } ++ nsock->same_node_tx_ring = (struct same_node_ring *)nsock->same_node_tx_ring_mz->addr; ++ ++ snprintf_s(name, sizeof(name), sizeof(name) - 1, "rte_mz_buf_rx_%u", pcb->remote_port); ++ if ((nsock->same_node_tx_ring->mz = rte_memzone_lookup(name)) == NULL) { ++ LSTACK_LOG(INFO, LSTACK, "lwip_accept: can't find %s\n",name); ++ return -1; ++ } ++ ++ snprintf_s(name, sizeof(name), sizeof(name) - 1, "rte_mz_tx_%u", pcb->remote_port); ++ if ((nsock->same_node_rx_ring_mz = rte_memzone_lookup(name)) == NULL) { ++ LSTACK_LOG(INFO, LSTACK, "lwip_accept: can't find %s\n",name); ++ return -1; ++ } else { ++ LSTACK_LOG(INFO, LSTACK, "lookup %s success\n", name); ++ } ++ nsock->same_node_rx_ring = (struct same_node_ring *)nsock->same_node_rx_ring_mz->addr; ++ ++ snprintf_s(name, sizeof(name), sizeof(name) - 1,"rte_mz_buf_tx_%u", pcb->remote_port); ++ if ((nsock->same_node_rx_ring->mz = rte_memzone_lookup(name)) == NULL) { ++ LSTACK_LOG(INFO, LSTACK, "lwip_accept: can't find %s\n",name); ++ return -1; ++ } ++ ++ /* rcvlink init in alloc_socket() */ ++ /* remove from g_rcv_process_list in free_socket */ ++ list_add_node(&nsock->stack->same_node_recv_list, &nsock->recv_list); ++ return 0; + } + + err_t same_node_memzone_create(const struct rte_memzone **zone, int size, int port, char *name, char *rx) +@@ -1468,7 +1472,8 @@ err_t same_node_memzone_create(const struct rte_memzone **zone, int size, int po + return ERR_MEM; + } + +- LSTACK_LOG(INFO, LSTACK, "lstack id %d, reserve %s(%p) success, addr is %p, size is %u\n", rte_socket_id(), mem_name, *zone, (*zone)->addr, size); ++ LSTACK_LOG(INFO, LSTACK, "lstack id %d, reserve %s(%p) success, addr is %p, size is %u\n", ++ rte_socket_id(), mem_name, *zone, (*zone)->addr, size); + + return ERR_OK; + } +@@ -1495,16 +1500,16 @@ err_t same_node_ring_create(struct rte_ring **ring, int size, int port, char *na + + static void init_same_node_ring(struct tcp_pcb *pcb) + { +- struct netconn *netconn = (struct netconn *)pcb->callback_arg; +- struct lwip_sock *sock = get_socket(netconn->socket); +- +- pcb->client_rx_ring = NULL; +- pcb->client_tx_ring = NULL; +- pcb->free_ring = 0; +- sock->same_node_rx_ring = NULL; +- sock->same_node_rx_ring_mz = NULL; +- sock->same_node_tx_ring = NULL; +- sock->same_node_tx_ring_mz = NULL; ++ struct netconn *netconn = (struct netconn *)pcb->callback_arg; ++ struct lwip_sock *sock = get_socket(netconn->socket); ++ ++ pcb->client_rx_ring = NULL; ++ pcb->client_tx_ring = NULL; ++ pcb->free_ring = 0; ++ sock->same_node_rx_ring = NULL; ++ sock->same_node_rx_ring_mz = NULL; ++ sock->same_node_tx_ring = NULL; ++ sock->same_node_tx_ring_mz = NULL; + } + + #define CLIENT_RING_SIZE 512 +@@ -1521,24 +1526,28 @@ err_t create_same_node_ring(struct tcp_pcb *pcb) + } + pcb->free_ring = 1; + +- if (same_node_memzone_create(&sock->same_node_rx_ring_mz, sizeof(struct same_node_ring), pcb->local_port, "rte_mz", "rx") != 0) { ++ if (same_node_memzone_create(&sock->same_node_rx_ring_mz, sizeof(struct same_node_ring), ++ pcb->local_port, "rte_mz", "rx") != 0) { + goto END; + } + sock->same_node_rx_ring = (struct same_node_ring*)sock->same_node_rx_ring_mz->addr; + +- if (same_node_memzone_create(&sock->same_node_rx_ring->mz, SAME_NODE_RING_LEN, pcb->local_port, "rte_mz_buf", "rx") != 0) { ++ if (same_node_memzone_create(&sock->same_node_rx_ring->mz, SAME_NODE_RING_LEN, ++ pcb->local_port, "rte_mz_buf", "rx") != 0) { + goto END; + } + + sock->same_node_rx_ring->sndbegin = 0; + sock->same_node_rx_ring->sndend = 0; + +- if (same_node_memzone_create(&sock->same_node_tx_ring_mz, sizeof(struct same_node_ring), pcb->local_port, "rte_mz", "tx") != 0) { ++ if (same_node_memzone_create(&sock->same_node_tx_ring_mz, sizeof(struct same_node_ring), ++ pcb->local_port, "rte_mz", "tx") != 0) { + goto END; + } + sock->same_node_tx_ring = (struct same_node_ring*)sock->same_node_tx_ring_mz->addr; + +- if (same_node_memzone_create(&sock->same_node_tx_ring->mz, SAME_NODE_RING_LEN, pcb->local_port, "rte_mz_buf", "tx") != 0) { ++ if (same_node_memzone_create(&sock->same_node_tx_ring->mz, SAME_NODE_RING_LEN, ++ pcb->local_port, "rte_mz_buf", "tx") != 0) { + goto END; + } + +@@ -1559,20 +1568,21 @@ END: + + err_t find_same_node_ring(struct tcp_pcb *npcb) + { +- char name[RING_NAME_LEN] = {0}; +- snprintf_s(name, sizeof(name), sizeof(name) - 1, "client_tx_ring_%u", npcb->remote_port); +- npcb->client_rx_ring = rte_ring_lookup(name); +- memset_s(name, sizeof(name), 0, sizeof(name)); +- snprintf_s(name, sizeof(name), sizeof(name) - 1, "client_rx_ring_%u", npcb->remote_port); +- npcb->client_tx_ring = rte_ring_lookup(name); +- npcb->free_ring = 0; +- if (npcb->client_tx_ring == NULL || +- npcb->client_rx_ring == NULL) { +- LSTACK_LOG(INFO, LSTACK, "lookup client rxtx ring failed, port is %d\n", npcb->remote_port); +- tcp_abandon(npcb, 0); +- return ERR_CONN; +- } else { +- LSTACK_LOG(INFO, LSTACK, "find client_tx_ring_%u and client_rx_ring_%u\n", npcb->remote_port, npcb->remote_port); +- } +- return 0; ++ char name[RING_NAME_LEN] = {0}; ++ snprintf_s(name, sizeof(name), sizeof(name) - 1, "client_tx_ring_%u", npcb->remote_port); ++ npcb->client_rx_ring = rte_ring_lookup(name); ++ memset_s(name, sizeof(name), 0, sizeof(name)); ++ snprintf_s(name, sizeof(name), sizeof(name) - 1, "client_rx_ring_%u", npcb->remote_port); ++ npcb->client_tx_ring = rte_ring_lookup(name); ++ npcb->free_ring = 0; ++ if (npcb->client_tx_ring == NULL || ++ npcb->client_rx_ring == NULL) { ++ LSTACK_LOG(INFO, LSTACK, "lookup client rxtx ring failed, port is %d\n", npcb->remote_port); ++ tcp_abandon(npcb, 0); ++ return ERR_CONN; ++ } else { ++ LSTACK_LOG(INFO, LSTACK, "find client_tx_ring_%u and client_rx_ring_%u\n", ++ npcb->remote_port, npcb->remote_port); ++ } ++ return 0; + } +diff --git a/src/lstack/core/lstack_protocol_stack.c b/src/lstack/core/lstack_protocol_stack.c +index 7b1b994..d5523df 100644 +--- a/src/lstack/core/lstack_protocol_stack.c ++++ b/src/lstack/core/lstack_protocol_stack.c +@@ -32,11 +32,11 @@ + #include "lstack_ethdev.h" + #include "lstack_vdev.h" + #include "lstack_lwip.h" +-#include "lstack_protocol_stack.h" + #include "lstack_cfg.h" + #include "lstack_control_plane.h" + #include "posix/lstack_epoll.h" + #include "lstack_stack_stat.h" ++#include "lstack_protocol_stack.h" + + #define KERNEL_EVENT_100us 100 + +@@ -98,7 +98,6 @@ int get_min_conn_stack(struct protocol_stack_group *stack_group) + min_conn_num = stack->conn_num; + } + } +- + } + return min_conn_stk_idx; + } +@@ -236,7 +235,6 @@ static int32_t create_thread(void *arg, char *thread_name, stack_thread_func fun + LSTACK_LOG(ERR, LSTACK, "set name failed\n"); + return -1; + } +- + } else { + ret = sprintf_s(name, sizeof(name), "%s%02hu", thread_name, t_params->queue_id); + if (ret < 0) { +@@ -307,15 +305,16 @@ static int32_t init_stack_value(struct protocol_stack *stack, void *arg) + + int idx = t_params->idx; + if (get_global_cfg_params()->seperate_send_recv) { ++ // 2: idx is even, stack is recv thread, idx is odd, stack is send thread + if (idx % 2 == 0) { +- stack->cpu_id = get_global_cfg_params()->recv_cpus[idx/2]; ++ stack->cpu_id = get_global_cfg_params()->recv_cpus[idx / 2]; + stack->is_send_thread = 0; +- }else { +- stack->cpu_id = get_global_cfg_params()->send_cpus[idx/2]; ++ } else { ++ stack->cpu_id = get_global_cfg_params()->send_cpus[idx / 2]; + stack->is_send_thread = 1; + } +- }else { +- stack->cpu_id = get_global_cfg_params()->cpus[idx]; ++ } else { ++ stack->cpu_id = get_global_cfg_params()->cpus[idx]; + } + + stack->socket_id = numa_node_of_cpu(stack->cpu_id); +@@ -355,7 +354,7 @@ static int32_t create_affiliate_thread(void *arg) + + static struct protocol_stack *stack_thread_init(void *arg) + { +- struct protocol_stack_group *stack_group = get_protocol_stack_group(); ++ struct protocol_stack_group *stack_group = get_protocol_stack_group(); + struct protocol_stack *stack = calloc(1, sizeof(*stack)); + if (stack == NULL) { + LSTACK_LOG(ERR, LSTACK, "malloc stack failed\n"); +@@ -437,7 +436,7 @@ static void* gazelle_stack_thread(void *arg) + + uint16_t queue_id = t_params->queue_id; + struct cfg_params *cfg = get_global_cfg_params(); +- uint8_t use_ltran_flag = cfg->use_ltran;; ++ uint8_t use_ltran_flag = cfg->use_ltran; + bool kni_switch = cfg->kni_switch; + uint32_t read_connect_number = cfg->read_connect_number; + uint32_t rpc_number = cfg->rpc_number; +@@ -502,7 +501,7 @@ static void* gazelle_stack_thread(void *arg) + + static void libnet_listen_thread(void *arg) + { +- struct cfg_params * cfg_param = get_global_cfg_params(); ++ struct cfg_params *cfg_param = get_global_cfg_params(); + recv_pkts_from_other_process(cfg_param->process_idx, arg); + } + +@@ -542,7 +541,7 @@ int32_t init_protocol_stack(void) + + if (!get_global_cfg_params()->seperate_send_recv) { + stack_group->stack_num = get_global_cfg_params()->num_cpu; +- }else { ++ } else { + stack_group->stack_num = get_global_cfg_params()->num_cpu * 2; + } + +@@ -550,7 +549,6 @@ int32_t init_protocol_stack(void) + pthread_spin_init(&stack_group->poll_list_lock, PTHREAD_PROCESS_PRIVATE); + pthread_spin_init(&stack_group->socket_lock, PTHREAD_PROCESS_PRIVATE); + +- + if (init_protocol_sem() != 0) { + return -1; + } +@@ -559,9 +557,10 @@ int32_t init_protocol_stack(void) + int process_index = get_global_cfg_params()->process_idx; + + if (get_global_cfg_params()->is_primary) { ++ uint32_t total_mbufs = get_global_cfg_params()->mbuf_count_per_conn * get_global_cfg_params()->tcp_conn_count; + for (uint16_t idx = 0; idx < get_global_cfg_params()->tot_queue_num; idx++) { + struct rte_mempool* rxtx_mbuf = create_pktmbuf_mempool("rxtx_mbuf", +- get_global_cfg_params()->mbuf_count_per_conn * get_global_cfg_params()->tcp_conn_count / stack_group->stack_num, RXTX_CACHE_SZ, idx); ++ total_mbufs / stack_group->stack_num, RXTX_CACHE_SZ, idx); + if (rxtx_mbuf == NULL) { + return -1; + } +@@ -572,12 +571,12 @@ int32_t init_protocol_stack(void) + for (uint32_t i = 0; i < queue_num; i++) { + if (get_global_cfg_params()->seperate_send_recv) { + if (i % 2 == 0) { +- ret = sprintf_s(name, sizeof(name), "%s_%d_%d", LSTACK_RECV_THREAD_NAME, process_index, i/2); ++ ret = sprintf_s(name, sizeof(name), "%s_%d_%d", LSTACK_RECV_THREAD_NAME, process_index, i / 2); + if (ret < 0) { + return -1; + } + } else { +- ret = sprintf_s(name, sizeof(name), "%s_%d_%d", LSTACK_SEND_THREAD_NAME, process_index, i/2); ++ ret = sprintf_s(name, sizeof(name), "%s_%d_%d", LSTACK_SEND_THREAD_NAME, process_index, i / 2); + if (ret < 0) { + return -1; + } +@@ -601,17 +600,18 @@ int32_t init_protocol_stack(void) + + wait_sem_value(&stack_group->thread_phase1, stack_group->stack_num); + +- for(int idx = 0; idx < queue_num; idx++){ ++ for (int idx = 0; idx < queue_num; idx++){ + free(t_params[idx]); + } + +- if (!use_ltran()) { ++ if (!use_ltran()) { + ret = sem_init(&stack_group->sem_listen_thread, 0, 0); + ret = sprintf_s(name, sizeof(name), "%s", "listen_thread"); +- struct sys_thread *thread = sys_thread_new(name, libnet_listen_thread, (void*)(&stack_group->sem_listen_thread), 0, 0); ++ struct sys_thread *thread = sys_thread_new(name, libnet_listen_thread, ++ (void*)(&stack_group->sem_listen_thread), 0, 0); + free(thread); + sem_wait(&stack_group->sem_listen_thread); +- } ++ } + + if (get_init_fail()) { + return -1; +@@ -888,7 +888,7 @@ int32_t stack_broadcast_listen(int32_t fd, int32_t backlog) + + if (min_conn_stk_idx == i) { + get_socket_by_fd(clone_fd)->conn->is_master_fd = 1; +- }else { ++ } else { + get_socket_by_fd(clone_fd)->conn->is_master_fd = 0; + } + +diff --git a/src/lstack/core/lstack_stack_stat.c b/src/lstack/core/lstack_stack_stat.c +index d1c749a..60832b4 100644 +--- a/src/lstack/core/lstack_stack_stat.c ++++ b/src/lstack/core/lstack_stack_stat.c +@@ -25,9 +25,9 @@ + #include "gazelle_dfx_msg.h" + #include "lstack_thread_rpc.h" + #include "lstack_protocol_stack.h" +-#include "lstack_stack_stat.h" + #include "posix/lstack_epoll.h" + #include "lstack_dpdk.h" ++#include "lstack_stack_stat.h" + + #define US_PER_SEC 1000000 + +@@ -55,7 +55,7 @@ void calculate_lstack_latency(struct gazelle_stack_latency *stack_latency, const + const struct latency_timestamp *lt; + + if (pbuf == NULL) { +- return; ++ return; + } + + lt = &pbuf_to_private(pbuf)->lt; +@@ -120,7 +120,8 @@ static void set_latency_start_flag(bool start) + stack->latency.start_time = get_current_time(); + stack->latency.lwip_latency.latency_min = ~((uint64_t)0); + stack->latency.read_latency.latency_min = ~((uint64_t)0); +- memset_s(&stack->aggregate_stats, sizeof(struct gazelle_stack_aggregate_stats), 0, sizeof(stack->aggregate_stats)); ++ memset_s(&stack->aggregate_stats, sizeof(struct gazelle_stack_aggregate_stats), ++ 0, sizeof(stack->aggregate_stats)); + } + } + +@@ -218,7 +219,8 @@ static void get_stack_dfx_data(struct gazelle_stack_dfx_data *dfx, struct protoc + } + break; + case GAZELLE_STAT_LSTACK_SHOW_AGGREGATE: +- ret = memcpy_s(&dfx->data.aggregate_stats, sizeof(dfx->data.aggregate_stats), &stack->aggregate_stats, sizeof(stack->aggregate_stats)); ++ ret = memcpy_s(&dfx->data.aggregate_stats, sizeof(dfx->data.aggregate_stats), ++ &stack->aggregate_stats, sizeof(stack->aggregate_stats)); + if (ret != EOK) { + LSTACK_LOG(ERR, LSTACK, "memcpy_s err ret=%d \n", ret); + } +diff --git a/src/lstack/include/lstack_dpdk.h b/src/lstack/include/lstack_dpdk.h +index 1047c44..a189557 100644 +--- a/src/lstack/include/lstack_dpdk.h ++++ b/src/lstack/include/lstack_dpdk.h +@@ -53,7 +53,8 @@ int32_t dpdk_init_lstack_kni(void); + void dpdk_restore_pci(void); + bool port_in_stack_queue(uint32_t src_ip, uint32_t dst_ip, uint16_t src_port, uint16_t dst_port); + uint16_t get_port_id(void); +-struct rte_mempool *create_pktmbuf_mempool(const char *name, uint32_t nb_mbuf,uint32_t mbuf_cache_size, uint16_t queue_id); ++struct rte_mempool *create_pktmbuf_mempool(const char *name, uint32_t nb_mbuf, ++ uint32_t mbuf_cache_size, uint16_t queue_id); + + void dpdk_nic_xstats_get(struct gazelle_stack_dfx_data *dfx, uint16_t port_id); + #endif /* GAZELLE_DPDK_H */ +diff --git a/src/lstack/include/lstack_ethdev.h b/src/lstack/include/lstack_ethdev.h +index 7f944eb..326bd1b 100644 +--- a/src/lstack/include/lstack_ethdev.h ++++ b/src/lstack/include/lstack_ethdev.h +@@ -20,10 +20,10 @@ enum port_type { + PORT_CONNECT, + }; + +-enum PACKET_TRANSFER_TYPE{ ++enum PACKET_TRANSFER_TYPE { + TRANSFER_KERNEL = -1, + TRANSFER_OTHER_THREAD, +- TRANSFER_CURRENT_THREAD, ++ TRANSFER_CURRENT_THREAD, + }; + + enum TRANSFER_MESSAGE_RESULT { +diff --git a/src/lstack/include/lstack_lockless_queue.h b/src/lstack/include/lstack_lockless_queue.h +index c70b56a..c6f6f32 100644 +--- a/src/lstack/include/lstack_lockless_queue.h ++++ b/src/lstack/include/lstack_lockless_queue.h +@@ -70,8 +70,9 @@ static inline lockless_queue_node* lockless_queue_mpsc_pop(lockless_queue* queue + lockless_queue_node *next = tail->next; + + if (tail == &queue->stub) { +- if (next == NULL) ++ if (next == NULL) { + return NULL; ++ } + queue->tail = next; + tail = next; + next = next->next; +@@ -83,8 +84,9 @@ static inline lockless_queue_node* lockless_queue_mpsc_pop(lockless_queue* queue + } + + lockless_queue_node *head = queue->head; +- if (tail != head) ++ if (tail != head) { + return NULL; ++ } + + lockless_queue_mpsc_push(queue, &queue->stub); + +diff --git a/src/lstack/include/lstack_protocol_stack.h b/src/lstack/include/lstack_protocol_stack.h +index c75161f..3a447dc 100644 +--- a/src/lstack/include/lstack_protocol_stack.h ++++ b/src/lstack/include/lstack_protocol_stack.h +@@ -138,7 +138,7 @@ void stack_broadcast_clean_epoll(struct wakeup_poll *wakeup); + void stack_send_pkts(struct protocol_stack *stack); + + struct rpc_msg; +-struct thread_params{ ++struct thread_params { + uint16_t queue_id; + uint16_t idx; + }; +diff --git a/src/lstack/include/lstack_vdev.h b/src/lstack/include/lstack_vdev.h +index 540a31a..007eec7 100644 +--- a/src/lstack/include/lstack_vdev.h ++++ b/src/lstack/include/lstack_vdev.h +@@ -23,7 +23,8 @@ int vdev_reg_xmit(enum reg_ring_type type, struct gazelle_quintuple *qtuple); + + int recv_pkts_from_other_process(int process_index, void* arg); + void transfer_delete_rule_info_to_process0(uint32_t dst_ip, uint16_t src_port, uint16_t dst_port); +-void transfer_create_rule_info_to_process0(uint16_t queue_id, uint32_t src_ip, uint32_t dst_ip, uint16_t src_port, uint16_t dst_port); ++void transfer_create_rule_info_to_process0(uint16_t queue_id, uint32_t src_ip, ++ uint32_t dst_ip, uint16_t src_port, uint16_t dst_port); + void transfer_add_or_delete_listen_port_to_process0(uint16_t listen_port, uint8_t process_idx, uint8_t is_add); + void init_listen_and_user_ports(); + +diff --git a/src/lstack/netif/lstack_ethdev.c b/src/lstack/netif/lstack_ethdev.c +index 5d7477f..7514e58 100644 +--- a/src/lstack/netif/lstack_ethdev.c ++++ b/src/lstack/netif/lstack_ethdev.c +@@ -21,7 +21,7 @@ + #include + #include + #include +-#include "lwip/tcp.h" ++#include + #include + + #include +@@ -36,37 +36,41 @@ + #include "lstack_lwip.h" + #include "dpdk_common.h" + #include "lstack_protocol_stack.h" +-#include "lstack_ethdev.h" + #include "lstack_thread_rpc.h" ++#include "lstack_ethdev.h" + + /* FRAME_MTU + 14byte header */ +-#define MBUF_MAX_LEN 1514 +-#define MAX_PATTERN_NUM 4 +-#define MAX_ACTION_NUM 2 +-#define FULL_MASK 0xffffffff /* full mask */ +-#define EMPTY_MASK 0x0 /* empty mask */ +-#define LSTACK_MBUF_LEN 64 +-#define TRANSFER_TCP_MUBF_LEN LSTACK_MBUF_LEN + 3 +-#define DELETE_FLOWS_PARAMS_NUM 3 +-#define DELETE_FLOWS_PARAMS_LENGTH 30 +-#define CREATE_FLOWS_PARAMS_NUM 6 +-#define CREATE_FLOWS_PARAMS_LENGTH 60 ++#define MBUF_MAX_LEN 1514 ++#define MAX_PATTERN_NUM 4 ++#define MAX_ACTION_NUM 2 ++#define FULL_MASK 0xffffffff /* full mask */ ++#define EMPTY_MASK 0x0 /* empty mask */ ++#define LSTACK_MBUF_LEN 64 ++#define TRANSFER_TCP_MUBF_LEN (LSTACK_MBUF_LEN + 3) ++#define DELETE_FLOWS_PARAMS_NUM 3 ++#define DELETE_FLOWS_PARAMS_LENGTH 30 ++#define CREATE_FLOWS_PARAMS_NUM 6 ++#define CREATE_FLOWS_PARAMS_LENGTH 60 + #define ADD_OR_DELETE_LISTEN_PORT_PARAMS_LENGTH 25 +-#define ADD_OR_DELETE_LISTEN_PORT_PARAMS_NUM 3 +-#define REPLY_LEN 10 +-#define SUCCESS_REPLY "success" +-#define ERROR_REPLY "error" +-#define PACKET_READ_SIZE 32 ++#define ADD_OR_DELETE_LISTEN_PORT_PARAMS_NUM 3 ++#define REPLY_LEN 10 ++#define SUCCESS_REPLY "success" ++#define ERROR_REPLY "error" ++#define PACKET_READ_SIZE 32 ++ ++#define GET_LSTACK_NUM 14 ++#define GET_LSTACK_NUM_STRING "get_lstack_num" ++ ++#define SERVER_PATH "/var/run/gazelle/server.socket" ++#define SPLIT_DELIM "," + +-#define GET_LSTACK_NUM 14 +-#define GET_LSTACK_NUM_STRING "get_lstack_num" ++#define UNIX_TCP_PORT_MAX 65535 + +-char *client_path = "/var/run/gazelle/client.socket"; +-char *server_path = "/var/run/gazelle/server.socket"; +-const char *split_delim = ","; ++#define IPV4_VERSION_OFFSET 4 ++#define IPV4_VERSION 4 + +-uint8_t g_user_ports[65535] = {INVAILD_PROCESS_IDX,}; +-uint8_t g_listen_ports[65535] = {INVAILD_PROCESS_IDX,}; ++static uint8_t g_user_ports[UNIX_TCP_PORT_MAX] = {INVAILD_PROCESS_IDX, }; ++static uint8_t g_listen_ports[UNIX_TCP_PORT_MAX] = {INVAILD_PROCESS_IDX, }; + + void eth_dev_recv(struct rte_mbuf *mbuf, struct protocol_stack *stack) + { +@@ -173,9 +177,9 @@ void add_rule(char* rule_key, struct rte_flow *flow) + struct flow_rule *rule; + HASH_FIND_STR(g_flow_rules, rule_key, rule); + if (rule == NULL) { +- rule = (struct flow_rule*)malloc(sizeof(struct flow_rule)); +- strcpy_s(rule->rule_key, RULE_KEY_LEN, rule_key); +- HASH_ADD_STR(g_flow_rules, rule_key, rule); ++ rule = (struct flow_rule*)malloc(sizeof(struct flow_rule)); ++ strcpy_s(rule->rule_key, RULE_KEY_LEN, rule_key); ++ HASH_ADD_STR(g_flow_rules, rule_key, rule); + } + rule->flow = flow; + } +@@ -185,8 +189,8 @@ void delete_rule(char* rule_key) + struct flow_rule *rule = NULL; + HASH_FIND_STR(g_flow_rules, rule_key, rule); + if (rule == NULL) { +- HASH_DEL(g_flow_rules, rule); +- free(rule); ++ HASH_DEL(g_flow_rules, rule); ++ free(rule); + } + } + +@@ -204,15 +208,14 @@ int transfer_pkt_to_other_process(char *buf, int process_index, int write_len, b + int ret = 0; + + sockfd = posix_api->socket_fn(AF_UNIX, SOCK_STREAM, 0); +- +- memset_s(&serun, sizeof(serun), 0, sizeof(serun)); ++ memset_s(&serun, sizeof(serun), 0, sizeof(serun)); + serun.sun_family = AF_UNIX; +- sprintf_s(serun.sun_path, PATH_MAX,"%s%d", server_path, process_index); ++ sprintf_s(serun.sun_path, PATH_MAX, "%s%d", SERVER_PATH, process_index); + int32_t len = offsetof(struct sockaddr_un, sun_path) + strlen(serun.sun_path); +- if (posix_api->connect_fn(sockfd, (struct sockaddr *)&serun, len) < 0){ +- return CONNECT_ERROR; ++ if (posix_api->connect_fn(sockfd, (struct sockaddr *)&serun, len) < 0) { ++ return CONNECT_ERROR; + } +- posix_api->write_fn(sockfd, buf, write_len); ++ posix_api->write_fn(sockfd, buf, write_len); + if (need_reply) { + char reply_message[REPLY_LEN]; + int32_t read_result = posix_api->read_fn(sockfd, reply_message, REPLY_LEN); +@@ -233,7 +236,8 @@ int transfer_pkt_to_other_process(char *buf, int process_index, int write_len, b + return ret; + } + +-int32_t check_params_from_primary(void){ ++int32_t check_params_from_primary(void) ++{ + struct cfg_params *cfg = get_global_cfg_params(); + if (cfg->is_primary) { + return 0; +@@ -248,39 +252,40 @@ int32_t check_params_from_primary(void){ + return 0; + } + +-struct rte_flow * +-create_flow_director(uint16_t port_id, uint16_t queue_id, uint32_t src_ip, uint32_t dst_ip, +- uint16_t src_port, uint16_t dst_port, struct rte_flow_error *error) ++struct rte_flow *create_flow_director(uint16_t port_id, uint16_t queue_id, ++ uint32_t src_ip, uint32_t dst_ip, ++ uint16_t src_port, uint16_t dst_port, ++ struct rte_flow_error *error) + { + struct rte_flow_attr attr; +- struct rte_flow_item pattern[MAX_PATTERN_NUM]; +- struct rte_flow_action action[MAX_ACTION_NUM]; +- struct rte_flow *flow = NULL; +- struct rte_flow_action_queue queue = { .index = queue_id }; +- struct rte_flow_item_ipv4 ip_spec; +- struct rte_flow_item_ipv4 ip_mask; ++ struct rte_flow_item pattern[MAX_PATTERN_NUM]; ++ struct rte_flow_action action[MAX_ACTION_NUM]; ++ struct rte_flow *flow = NULL; ++ struct rte_flow_action_queue queue = { .index = queue_id }; ++ struct rte_flow_item_ipv4 ip_spec; ++ struct rte_flow_item_ipv4 ip_mask; + + struct rte_flow_item_tcp tcp_spec; + struct rte_flow_item_tcp tcp_mask; +- int res; ++ int res; + +- memset_s(pattern, sizeof(pattern), 0, sizeof(pattern)); +- memset_s(action, sizeof(action), 0, sizeof(action)); ++ memset_s(pattern, sizeof(pattern), 0, sizeof(pattern)); ++ memset_s(action, sizeof(action), 0, sizeof(action)); + + /* +- * set the rule attribute. +- * in this case only ingress packets will be checked. +- */ +- memset_s(&attr, sizeof(struct rte_flow_attr), 0, sizeof(struct rte_flow_attr)); +- attr.ingress = 1; ++ * set the rule attribute. ++ * in this case only ingress packets will be checked. ++ */ ++ memset_s(&attr, sizeof(struct rte_flow_attr), 0, sizeof(struct rte_flow_attr)); ++ attr.ingress = 1; + + /* +- * create the action sequence. +- * one action only, move packet to queue +- */ +- action[0].type = RTE_FLOW_ACTION_TYPE_QUEUE; +- action[0].conf = &queue; +- action[1].type = RTE_FLOW_ACTION_TYPE_END; ++ * create the action sequence. ++ * one action only, move packet to queue ++ */ ++ action[0].type = RTE_FLOW_ACTION_TYPE_QUEUE; ++ action[0].conf = &queue; ++ action[1].type = RTE_FLOW_ACTION_TYPE_END; + + // not limit eth header + pattern[0].type = RTE_FLOW_ITEM_TYPE_ETH; +@@ -299,7 +304,7 @@ create_flow_director(uint16_t port_id, uint16_t queue_id, uint32_t src_ip, uint3 + // tcp header, full mask 0xffff + memset_s(&tcp_spec, sizeof(struct rte_flow_item_tcp), 0, sizeof(struct rte_flow_item_tcp)); + memset_s(&tcp_mask, sizeof(struct rte_flow_item_tcp), 0, sizeof(struct rte_flow_item_tcp)); +- pattern[2].type = RTE_FLOW_ITEM_TYPE_TCP; ++ pattern[2].type = RTE_FLOW_ITEM_TYPE_TCP; // 2: pattern 2 is tcp header + tcp_spec.hdr.src_port = src_port; + tcp_spec.hdr.dst_port = dst_port; + tcp_mask.hdr.src_port = rte_flow_item_tcp_mask.hdr.src_port; +@@ -308,35 +313,39 @@ create_flow_director(uint16_t port_id, uint16_t queue_id, uint32_t src_ip, uint3 + pattern[2].mask = &tcp_mask; + + /* the final level must be always type end */ +- pattern[3].type = RTE_FLOW_ITEM_TYPE_END; ++ pattern[3].type = RTE_FLOW_ITEM_TYPE_END; + res = rte_flow_validate(port_id, &attr, pattern, action, error); +- if (!res){ ++ if (!res) { + flow = rte_flow_create(port_id, &attr, pattern, action, error); +- }else { +- LSTACK_LOG(ERR, PORT,"rte_flow_create.rte_flow_validate error, res %d \n", res); ++ } else { ++ LSTACK_LOG(ERR, PORT, "rte_flow_create.rte_flow_validate error, res %d \n", res); + } + +- return flow; ++ return flow; + } + +-void config_flow_director(uint16_t queue_id, uint32_t src_ip, uint32_t dst_ip, uint16_t src_port, uint16_t dst_port){ +- ++void config_flow_director(uint16_t queue_id, uint32_t src_ip, ++ uint32_t dst_ip, uint16_t src_port, uint16_t dst_port) ++{ + uint16_t port_id = get_port_id(); + char rule_key[RULE_KEY_LEN] = {0}; + sprintf_s(rule_key, sizeof(rule_key), "%u_%u_%u", src_ip, src_port, dst_port); + struct flow_rule *fl_exist = find_rule(rule_key); +- if(fl_exist != NULL){ ++ if (fl_exist != NULL) { + return; + } + +- LSTACK_LOG(INFO, LSTACK, "config_flow_director, flow queue_id %u, src_ip %u,src_port_ntohs:%u, dst_port_ntohs :%u \n", +- queue_id, src_ip,ntohs(src_port), ntohs(dst_port) ); ++ LSTACK_LOG(INFO, LSTACK, ++ "config_flow_director, flow queue_id %u, src_ip %u,src_port_ntohs:%u, dst_port_ntohs:%u\n", ++ queue_id, src_ip, ntohs(src_port), ntohs(dst_port)); + + struct rte_flow_error error; + struct rte_flow *flow = create_flow_director(port_id, queue_id, src_ip, dst_ip, src_port, dst_port, &error); + if (!flow) { +- LSTACK_LOG(ERR, LSTACK,"config_flow_director, flow can not be created. queue_id %u, src_ip %u, src_port %u, dst_port %u, dst_port_ntohs :%u, type %d. message: %s\n", +- queue_id, src_ip,src_port,dst_port,ntohs(dst_port), error.type, error.message ? error.message : "(no stated reason)"); ++ LSTACK_LOG(ERR, LSTACK,"flow can not be created. queue_id %u, src_ip %u, src_port %u," ++ "dst_port %u, dst_port_ntohs :%u, type %d. message: %s\n", ++ queue_id, src_ip, src_port, dst_port, ntohs(dst_port), ++ error.type, error.message ? error.message : "(no stated reason)"); + return; + } + __sync_fetch_and_add(&g_flow_num, 1); +@@ -354,59 +363,61 @@ void delete_flow_director(uint32_t dst_ip, uint16_t src_port, uint16_t dst_port) + struct rte_flow_error error; + int ret = rte_flow_destroy(port_id, fl->flow, &error); + if(ret != 0){ +- LSTACK_LOG(ERR, PORT,"Flow can't be delete %d message: %s\n",error.type,error.message ? error.message : "(no stated reason)"); ++ LSTACK_LOG(ERR, PORT, "Flow can't be delete %d message: %s\n", ++ error.type, error.message ? error.message : "(no stated reason)"); + } + delete_rule(rule_key); + __sync_fetch_and_sub(&g_flow_num, 1); + } + } + +-/* +- * delete flows +- * if process 0, delete directly, else transfer 'dst_ip,src_port,dst_port' to process 0. +- */ ++/* if process 0, delete directly, else transfer 'dst_ip,src_port,dst_port' to process 0. */ + void transfer_delete_rule_info_to_process0(uint32_t dst_ip, uint16_t src_port, uint16_t dst_port) + { +- if (get_global_cfg_params()->is_primary){ ++ if (get_global_cfg_params()->is_primary) { + delete_flow_director(dst_ip, src_port, dst_port); +- }else { ++ } else { + char process_server_path[DELETE_FLOWS_PARAMS_LENGTH]; +- sprintf_s(process_server_path, DELETE_FLOWS_PARAMS_LENGTH, "%u%s%u%s%u", dst_ip,split_delim, src_port,split_delim,dst_port); ++ sprintf_s(process_server_path, DELETE_FLOWS_PARAMS_LENGTH, "%u%s%u%s%u", ++ dst_ip, SPLIT_DELIM, src_port, SPLIT_DELIM, dst_port); + int ret = transfer_pkt_to_other_process(process_server_path, 0, DELETE_FLOWS_PARAMS_LENGTH, false); + if(ret != TRANSFER_SUCESS){ +- LSTACK_LOG(ERR, LSTACK,"transfer_delete_rule_info_to_process0 error. tid %d. dst_ip %u, src_port: %u, dst_port %u\n", ++ LSTACK_LOG(ERR, LSTACK, "error. tid %d. dst_ip %u, src_port: %u, dst_port %u\n", + rte_gettid(), dst_ip, src_port, dst_port); + } + } + } + +-/* +- * add flows +- * if process 0, add directly, else transfer 'src_ip,dst_ip，src_port，dst_port,queue_id' to process 0. +- */ +-void transfer_create_rule_info_to_process0(uint16_t queue_id, uint32_t src_ip, uint32_t dst_ip, uint16_t src_port, uint16_t dst_port) ++// if process 0, add directly, else transfer 'src_ip,dst_ip，src_port，dst_port,queue_id' to process 0. ++void transfer_create_rule_info_to_process0(uint16_t queue_id, uint32_t src_ip, ++ uint32_t dst_ip, uint16_t src_port, ++ uint16_t dst_port) + { + char process_server_path[CREATE_FLOWS_PARAMS_LENGTH]; + /* exchage src_ip and dst_ip, src_port and dst_port */ + uint8_t process_idx = get_global_cfg_params()->process_idx; +- sprintf_s(process_server_path, CREATE_FLOWS_PARAMS_LENGTH, "%u%s%u%s%u%s%u%s%u%s%u", +- dst_ip,split_delim,src_ip,split_delim, dst_port,split_delim,src_port, split_delim,queue_id,split_delim,process_idx); ++ sprintf_s(process_server_path, CREATE_FLOWS_PARAMS_LENGTH, "%u%s%u%s%u%s%u%s%u%s%u", ++ dst_ip, SPLIT_DELIM, src_ip, SPLIT_DELIM, ++ dst_port, SPLIT_DELIM, src_port, SPLIT_DELIM, ++ queue_id, SPLIT_DELIM, process_idx); + int ret = transfer_pkt_to_other_process(process_server_path, 0, CREATE_FLOWS_PARAMS_LENGTH, true); +- if(ret != TRANSFER_SUCESS){ +- LSTACK_LOG(ERR, LSTACK,"transfer_create_rule_info_to_process0 error. tid %d. src_ip %u, dst_ip %u, src_port: %u, dst_port %u, queue_id %u, process_idx %u\n", +- rte_gettid(), src_ip, dst_ip, src_port, dst_port, queue_id, process_idx); ++ if (ret != TRANSFER_SUCESS) { ++ LSTACK_LOG(ERR, LSTACK, "error. tid %d. src_ip %u, dst_ip %u, src_port: %u, dst_port %u," ++ "queue_id %u, process_idx %u\n", ++ rte_gettid(), src_ip, dst_ip, src_port, dst_port, queue_id, process_idx); + } + } + + void transfer_add_or_delete_listen_port_to_process0(uint16_t listen_port, uint8_t process_idx, uint8_t is_add) + { + char process_server_path[ADD_OR_DELETE_LISTEN_PORT_PARAMS_LENGTH]; +- sprintf_s(process_server_path, ADD_OR_DELETE_LISTEN_PORT_PARAMS_LENGTH, "%u%s%u%s%u", listen_port,split_delim,process_idx, split_delim, is_add); ++ sprintf_s(process_server_path, ADD_OR_DELETE_LISTEN_PORT_PARAMS_LENGTH, ++ "%u%s%u%s%u", listen_port, SPLIT_DELIM, process_idx, SPLIT_DELIM, is_add); + int ret = transfer_pkt_to_other_process(process_server_path, 0, ADD_OR_DELETE_LISTEN_PORT_PARAMS_LENGTH, true); + if(ret != TRANSFER_SUCESS) { +- LSTACK_LOG(ERR, LSTACK,"transfer_add_or_delete_listen_port_to_process0 error. tid %d. listen_port %u, process_idx %u\n", +- rte_gettid(), listen_port, process_idx); +- } ++ LSTACK_LOG(ERR, LSTACK, "error. tid %d. listen_port %u, process_idx %u\n", ++ rte_gettid(), listen_port, process_idx); ++ } + } + + static int str_to_array(char *args, uint32_t *array, int size) +@@ -417,7 +428,7 @@ static int str_to_array(char *args, uint32_t *array, int size) + char *next_token = NULL; + + memset_s(array, sizeof(*array) * size, 0, sizeof(*array) * size); +- elem = strtok_s((char *)args, split_delim, &next_token); ++ elem = strtok_s((char *)args, SPLIT_DELIM, &next_token); + while (elem != NULL) { + if (cnt >= size) { + return -1; +@@ -429,7 +440,7 @@ static int str_to_array(char *args, uint32_t *array, int size) + array[cnt] = (uint32_t)val; + cnt++; + +- elem = strtok_s(NULL, split_delim, &next_token); ++ elem = strtok_s(NULL, SPLIT_DELIM, &next_token); + } + + return cnt; +@@ -445,18 +456,20 @@ void parse_and_delete_rule(char* buf) + delete_flow_director(dst_ip, src_port, dst_port); + } + +-void add_user_process_port(uint16_t dst_port, uint8_t process_idx, enum port_type type){ ++void add_user_process_port(uint16_t dst_port, uint8_t process_idx, enum port_type type) ++{ + if (type == PORT_LISTEN) { +- g_listen_ports[dst_port] = process_idx; +- }else { ++ g_listen_ports[dst_port] = process_idx; ++ } else { + g_user_ports[dst_port] = process_idx; + } + } + +-void delete_user_process_port(uint16_t dst_port, enum port_type type){ ++void delete_user_process_port(uint16_t dst_port, enum port_type type) ++{ + if (type == PORT_LISTEN) { + g_listen_ports[dst_port] = INVAILD_PROCESS_IDX; +- }else { ++ } else { + g_user_ports[dst_port] = INVAILD_PROCESS_IDX; + } + } +@@ -483,8 +496,8 @@ void parse_and_add_or_delete_listen_port(char* buf) + uint8_t process_idx = array[1]; + uint8_t is_add = array[2]; + if (is_add == 1) { +- add_user_process_port(listen_port,process_idx, PORT_LISTEN); +- }else { ++ add_user_process_port(listen_port, process_idx, PORT_LISTEN); ++ } else { + delete_user_process_port(listen_port, PORT_LISTEN); + } + +@@ -498,9 +511,9 @@ void transfer_arp_to_other_process(struct rte_mbuf *mbuf) + char arp_mbuf[LSTACK_MBUF_LEN] = {0}; + sprintf_s(arp_mbuf, sizeof(arp_mbuf), "%lu", mbuf); + int result = transfer_pkt_to_other_process(arp_mbuf, i, LSTACK_MBUF_LEN, false); +- if(result == CONNECT_ERROR){ ++ if (result == CONNECT_ERROR) { + LSTACK_LOG(INFO, LSTACK,"connect process %d failed, ensure the process is started.\n", i); +- }else if (result == REPLY_ERROR) { ++ } else if (result == REPLY_ERROR) { + LSTACK_LOG(ERR, LSTACK,"transfer arp pakages to process %d error. %m\n", i); + } + } +@@ -544,9 +557,9 @@ void parse_arp_and_transefer(char* buf) + void parse_tcp_and_transefer(char* buf) + { + char *next_token = NULL; +- char *elem = strtok_s(buf, split_delim, &next_token); ++ char *elem = strtok_s(buf, SPLIT_DELIM, &next_token); + struct rte_mbuf *mbuf = (struct rte_mbuf *) atoll(elem); +- elem = strtok_s(NULL, split_delim, &next_token); ++ elem = strtok_s(NULL, SPLIT_DELIM, &next_token); + uint16_t queue_id = atoll(elem); + + struct protocol_stack_group *stack_group = get_protocol_stack_group(); +@@ -566,8 +579,9 @@ void parse_tcp_and_transefer(char* buf) + transfer_tcp_to_thread(mbuf_copy, stk_index); + } + +-int recv_pkts_from_other_process(int process_index, void* arg){ +- struct sockaddr_un serun, cliun; ++int recv_pkts_from_other_process(int process_index, void* arg) ++{ ++ struct sockaddr_un serun, cliun; + socklen_t cliun_len; + int listenfd, connfd, size; + char buf[132]; +@@ -580,23 +594,23 @@ int recv_pkts_from_other_process(int process_index, void* arg){ + memset_s(&serun, sizeof(serun), 0, sizeof(serun)); + serun.sun_family = AF_UNIX; + char process_server_path[PATH_MAX]; +- sprintf_s(process_server_path, sizeof(process_server_path), "%s%d", server_path, process_index); +- strcpy_s(serun.sun_path, sizeof(serun.sun_path),process_server_path); ++ sprintf_s(process_server_path, sizeof(process_server_path), "%s%d", SERVER_PATH, process_index); ++ strcpy_s(serun.sun_path, sizeof(serun.sun_path), process_server_path); + size = offsetof(struct sockaddr_un, sun_path) + strlen(serun.sun_path); + unlink(process_server_path); +- if (posix_api->bind_fn(listenfd, (struct sockaddr *)&serun, size) < 0) { ++ if (posix_api->bind_fn(listenfd, (struct sockaddr *)&serun, size) < 0) { + perror("bind error"); + return -1; + } + if (posix_api->listen_fn(listenfd, 20) < 0) { /* 20: max backlog */ +- perror("listen error"); ++ perror("listen error"); + return -1; +- } ++ } + sem_post((sem_t *)arg); + /* block */ +- while(1) { ++ while(1) { + cliun_len = sizeof(cliun); +- if ((connfd = posix_api->accept_fn(listenfd, (struct sockaddr *)&cliun, &cliun_len)) < 0){ ++ if ((connfd = posix_api->accept_fn(listenfd, (struct sockaddr *)&cliun, &cliun_len)) < 0) { + perror("accept error"); + continue; + } +@@ -605,11 +619,11 @@ int recv_pkts_from_other_process(int process_index, void* arg){ + if (n < 0) { + perror("read error"); + break; +- } else if(n == 0) { ++ } else if (n == 0) { + break; + } + +- if(n == LSTACK_MBUF_LEN){ ++ if(n == LSTACK_MBUF_LEN) { + /* arp */ + parse_arp_and_transefer(buf); + } else if (n == TRANSFER_TCP_MUBF_LEN) { +@@ -618,17 +632,17 @@ int recv_pkts_from_other_process(int process_index, void* arg){ + } else if (n == DELETE_FLOWS_PARAMS_LENGTH) { + /* delete rule */ + parse_and_delete_rule(buf); +- }else if(n == CREATE_FLOWS_PARAMS_LENGTH){ ++ } else if(n == CREATE_FLOWS_PARAMS_LENGTH) { + /* add rule */ + parse_and_create_rule(buf); + char reply_buf[REPLY_LEN]; + sprintf_s(reply_buf, sizeof(reply_buf), "%s", SUCCESS_REPLY); + posix_api->write_fn(connfd, reply_buf, REPLY_LEN); +- }else if (n == GET_LSTACK_NUM) { ++ } else if (n == GET_LSTACK_NUM) { + char reply_buf[REPLY_LEN]; + sprintf_s(reply_buf, sizeof(reply_buf), "%d", get_global_cfg_params()->num_cpu); + posix_api->write_fn(connfd, reply_buf, REPLY_LEN); +- }else{ ++ } else { + /* add port */ + parse_and_add_or_delete_listen_port(buf); + char reply_buf[REPLY_LEN]; +@@ -643,59 +657,62 @@ int recv_pkts_from_other_process(int process_index, void* arg){ + return 0; + } + +-void concat_mbuf_and_queue_id(struct rte_mbuf *mbuf, uint16_t queue_id, char* mbuf_and_queue_id, int write_len){ +- +- sprintf_s(mbuf_and_queue_id, write_len, "%lu%s%u", mbuf,split_delim,queue_id); ++void concat_mbuf_and_queue_id(struct rte_mbuf *mbuf, uint16_t queue_id, ++ char* mbuf_and_queue_id, int write_len) ++{ ++ sprintf_s(mbuf_and_queue_id, write_len, "%lu%s%u", mbuf, SPLIT_DELIM, queue_id); + } + +-const int32_t ipv4_version_offset = 4; +-const int32_t ipv4_version = 4; +- + int distribute_pakages(struct rte_mbuf *mbuf) + { + struct rte_ipv4_hdr *iph = rte_pktmbuf_mtod_offset(mbuf, struct rte_ipv4_hdr *, sizeof(struct rte_ether_hdr)); +- uint8_t ip_version = (iph->version_ihl & 0xf0) >> ipv4_version_offset; +- if (likely(ip_version == ipv4_version)) { ++ uint8_t ip_version = (iph->version_ihl & 0xf0) >> IPV4_VERSION_OFFSET; ++ if (likely(ip_version == IPV4_VERSION)) { + if (likely(iph->next_proto_id == IPPROTO_TCP)) { + int each_process_queue_num = get_global_cfg_params()->num_queue; + +- struct rte_tcp_hdr *tcp_hdr = rte_pktmbuf_mtod_offset(mbuf, struct rte_tcp_hdr *, sizeof(struct rte_ether_hdr) + +- sizeof(struct rte_ipv4_hdr)); ++ struct rte_tcp_hdr *tcp_hdr = rte_pktmbuf_mtod_offset(mbuf, struct rte_tcp_hdr *, ++ sizeof(struct rte_ether_hdr) + sizeof(struct rte_ipv4_hdr)); + uint16_t dst_port = tcp_hdr->dst_port; ++ uint32_t user_process_idx; + +- int user_process_idx = (g_listen_ports[dst_port] != INVAILD_PROCESS_IDX) ? g_listen_ports[dst_port] : g_user_ports[dst_port]; ++ if (g_listen_ports[dst_port] != INVAILD_PROCESS_IDX) { ++ user_process_idx = g_listen_ports[dst_port]; ++ } else { ++ user_process_idx = g_user_ports[dst_port]; ++ } + + if (user_process_idx == INVAILD_PROCESS_IDX) { + return TRANSFER_KERNEL; + } +- if(unlikely(tcp_hdr->tcp_flags == TCP_SYN)){ ++ if (unlikely(tcp_hdr->tcp_flags == TCP_SYN)) { + uint32_t src_ip = iph->src_addr; + uint16_t src_port = tcp_hdr->src_port; +- uint32_t index = rte_jhash_3words(src_ip, src_port | (dst_port) << 16, 0, 0) % each_process_queue_num; ++ uint32_t index = rte_jhash_3words(src_ip, src_port | ((dst_port) << 16), 0, 0); ++ index = index % each_process_queue_num; + uint16_t queue_id = 0; + if (get_global_cfg_params()->seperate_send_recv) { +- queue_id = user_process_idx * each_process_queue_num + (index/2) * 2; +- }else { ++ queue_id = user_process_idx * each_process_queue_num + (index / 2) * 2; ++ } else { + queue_id = user_process_idx * each_process_queue_num + index; + } +- if(queue_id != 0){ +- if(user_process_idx == 0){ ++ if (queue_id != 0) { ++ if (user_process_idx == 0) { + transfer_tcp_to_thread(mbuf, queue_id); +- }else { ++ } else { + char mbuf_and_queue_id[TRANSFER_TCP_MUBF_LEN]; + concat_mbuf_and_queue_id(mbuf, queue_id, mbuf_and_queue_id, TRANSFER_TCP_MUBF_LEN); +- transfer_pkt_to_other_process(mbuf_and_queue_id, user_process_idx, TRANSFER_TCP_MUBF_LEN, false); ++ transfer_pkt_to_other_process(mbuf_and_queue_id, user_process_idx, ++ TRANSFER_TCP_MUBF_LEN, false); + } + return TRANSFER_OTHER_THREAD; +- }else { ++ } else { + return TRANSFER_CURRENT_THREAD; + } +- }else { ++ } else { + return TRANSFER_CURRENT_THREAD; +- } ++ } + } +- }else { +- return TRANSFER_KERNEL; + } + return TRANSFER_KERNEL; + } +@@ -706,7 +723,7 @@ void kni_handle_rx(uint16_t port_id) + struct rte_kni* kni = get_gazelle_kni(); + uint32_t nb_kni_rx = 0; + if (kni) { +- nb_kni_rx = rte_kni_rx_burst(kni, pkts_burst, PACKET_READ_SIZE); ++ nb_kni_rx = rte_kni_rx_burst(kni, pkts_burst, PACKET_READ_SIZE); + } + if (nb_kni_rx > 0) { + uint16_t nb_rx = rte_eth_tx_burst(port_id, 0, pkts_burst, nb_kni_rx); +@@ -777,12 +794,11 @@ int32_t gazelle_eth_dev_poll(struct protocol_stack *stack, uint8_t use_ltran_fla + + if (likely(transfer_type == TRANSFER_CURRENT_THREAD)) { + eth_dev_recv(stack->pkts[i], stack); +- + } else if (transfer_type == TRANSFER_KERNEL) { + kni_handle_tx(stack->pkts[i]); + } else { +- /*transfer to other thread*/ +- } ++ /* transfer to other thread */ ++ } + } + + stack->stats.rx += nr_pkts; +diff --git a/src/lstack/netif/lstack_vdev.c b/src/lstack/netif/lstack_vdev.c +index aef6035..5ea1f31 100644 +--- a/src/lstack/netif/lstack_vdev.c ++++ b/src/lstack/netif/lstack_vdev.c +@@ -43,7 +43,7 @@ + #define IPV4_MASK (0xf0) + #define IPV4_VERION (0x40) + +-#define TCP_HDR_LEN(tcp_hdr) ((tcp_hdr->data_off & 0xf0) >> 2) ++#define TCP_HDR_LEN(tcp_hdr) (((tcp_hdr)->data_off & 0xf0) >> 2) + + static uint32_t ltran_rx_poll(struct protocol_stack *stack, struct rte_mbuf **pkts, uint32_t max_mbuf) + { +@@ -156,7 +156,8 @@ int32_t vdev_reg_xmit(enum reg_ring_type type, struct gazelle_quintuple *qtuple) + if (get_global_cfg_params()->is_primary) { + delete_user_process_port(qtuple->src_port, PORT_LISTEN); + } else { +- transfer_add_or_delete_listen_port_to_process0(qtuple->src_port,get_global_cfg_params()->process_idx, 0); ++ transfer_add_or_delete_listen_port_to_process0(qtuple->src_port, ++ get_global_cfg_params()->process_idx, 0); + } + } + +@@ -174,13 +175,15 @@ int32_t vdev_reg_xmit(enum reg_ring_type type, struct gazelle_quintuple *qtuple) + + if (type == REG_RING_TCP_CONNECT) { + uint16_t queue_id = get_protocol_stack()->queue_id; +- if (get_global_cfg_params()->is_primary){ ++ if (get_global_cfg_params()->is_primary) { + add_user_process_port(qtuple->src_port, get_global_cfg_params()->process_idx, PORT_CONNECT); + if (queue_id != 0) { +- transfer_create_rule_info_to_process0(queue_id, qtuple->src_ip, qtuple->dst_ip, qtuple->src_port, qtuple->dst_port); ++ transfer_create_rule_info_to_process0(queue_id, qtuple->src_ip, qtuple->dst_ip, ++ qtuple->src_port, qtuple->dst_port); + } + } else { +- transfer_create_rule_info_to_process0(queue_id, qtuple->src_ip, qtuple->dst_ip, qtuple->src_port, qtuple->dst_port); ++ transfer_create_rule_info_to_process0(queue_id, qtuple->src_ip, qtuple->dst_ip, ++ qtuple->src_port, qtuple->dst_port); + } + } + +@@ -188,7 +191,8 @@ int32_t vdev_reg_xmit(enum reg_ring_type type, struct gazelle_quintuple *qtuple) + if (get_global_cfg_params()->is_primary) { + add_user_process_port(qtuple->src_port, get_global_cfg_params()->process_idx, PORT_LISTEN); + } else { +- transfer_add_or_delete_listen_port_to_process0(qtuple->src_port, get_global_cfg_params()->process_idx, 1); ++ transfer_add_or_delete_listen_port_to_process0(qtuple->src_port, ++ get_global_cfg_params()->process_idx, 1); + } + } + return 0; +diff --git a/src/ltran/ltran_dfx.c b/src/ltran/ltran_dfx.c +index b1ef967..37d05c8 100644 +--- a/src/ltran/ltran_dfx.c ++++ b/src/ltran/ltran_dfx.c +@@ -139,19 +139,17 @@ static void gazelle_print_lstack_xstats(void *buf, const struct gazelle_stat_msg + static const char *nic_stats_border = "########################"; + + printf("###### NIC extended statistics for port %-2d #########\n", xstats->port_id); +- printf("%s############################\n",nic_stats_border); ++ printf("%s############################\n", nic_stats_border); + if (xstats->len <= 0 || xstats->len > RTE_ETH_XSTATS_MAX_LEN) { + printf("xstats item(%d) num error!\n", xstats->len); + return; + } + + for (uint32_t i = 0; i < xstats->len; i++) { +- printf("%s: %"PRIu64"\n", xstats->xstats_name[i].name, +- xstats->values[i]); ++ printf("%s: %"PRIu64"\n", xstats->xstats_name[i].name, xstats->values[i]); + } + +- printf("%s############################\n", +- nic_stats_border); ++ printf("%s############################\n", nic_stats_border); + } + + static void gazelle_print_ltran_conn(void *buf, const struct gazelle_stat_msg_request *req_msg) +@@ -1111,7 +1109,7 @@ static void gazelle_print_lstack_aggregate(void *buf, const struct gazelle_stat_ + break; + } + ret = dfx_stat_read_from_ltran(buf, sizeof(struct gazelle_stack_dfx_data), req_msg->stat_mode); +- } while(true); ++ } while (true); + } + + static int32_t parse_dfx_ltran_args(int32_t argc, char *argv[], struct gazelle_stat_msg_request *req_msg) +diff --git a/src/ltran/ltran_monitor.c b/src/ltran/ltran_monitor.c +index bd047fc..d163a47 100644 +--- a/src/ltran/ltran_monitor.c ++++ b/src/ltran/ltran_monitor.c +@@ -31,8 +31,8 @@ + #include "ltran_instance.h" + #include "gazelle_dfx_msg.h" + #include "gazelle_base_func.h" +-#include "ltran_monitor.h" + #include "ltran_param.h" ++#include "ltran_monitor.h" + + #define GAZELLE_LISTEN_BACKLOG 5 + +diff --git a/src/ltran/ltran_param.c b/src/ltran/ltran_param.c +index 2bafec8..1b14186 100644 +--- a/src/ltran/ltran_param.c ++++ b/src/ltran/ltran_param.c +@@ -21,12 +21,12 @@ + #include + #include + +-#include "ltran_param.h" + #include "ltran_errno.h" + #include "ltran_base.h" + #include "ltran_log.h" + #include "gazelle_dfx_msg.h" + #include "gazelle_base_func.h" ++#include "ltran_param.h" + + #define HEX_BASE 16 + +diff --git a/src/ltran/main.c b/src/ltran/main.c +index 997e44d..f2fd94f 100644 +--- a/src/ltran/main.c ++++ b/src/ltran/main.c +@@ -62,11 +62,11 @@ static void sig_default_handler(int32_t sig) + int ret = 0; + ret = unlink(get_ltran_config()->unix_socket_filename); + if (ret) { +- LTRAN_WARN("unlink %s ERROR. errn: %d. ret=%d\n", get_ltran_config()->unix_socket_filename, errno, ret); ++ LTRAN_WARN("unlink %s ERROR. errn: %d. ret=%d\n", get_ltran_config()->unix_socket_filename, errno, ret); + } + ret = unlink(get_ltran_config()->dfx_socket_filename); + if (ret) { +- LTRAN_WARN("unlink %s ERROR. errn: %d. ret=%d\n", get_ltran_config()->dfx_socket_filename, errno, ret); ++ LTRAN_WARN("unlink %s ERROR. errn: %d. ret=%d\n", get_ltran_config()->dfx_socket_filename, errno, ret); + } + kill(getpid(), sig); + } +-- +2.33.0 + diff --git a/0245-add-udp-multicast-support-in-gazelle.patch b/0245-add-udp-multicast-support-in-gazelle.patch new file mode 100644 index 0000000..0b8f834 --- /dev/null +++ b/0245-add-udp-multicast-support-in-gazelle.patch @@ -0,0 +1,518 @@ +From 2c82e9a9f745f7a959014f788059ac79181b9440 Mon Sep 17 00:00:00 2001 +From: kircher +Date: Sat, 13 May 2023 14:32:02 +0800 +Subject: [PATCH] add udp multicast support in gazelle + +--- + src/lstack/api/lstack_wrap.c | 75 ++++++++++++++++++++++--- + src/lstack/core/lstack_lwip.c | 94 ++++++++++++++++++++++++-------- + src/lstack/include/lstack_lwip.h | 9 ++- + src/lstack/lstack.Makefile | 4 +- + src/lstack/netif/lstack_ethdev.c | 6 +- + src/ltran/ltran_stat.c | 8 ++- + 6 files changed, 159 insertions(+), 37 deletions(-) + +diff --git a/src/lstack/api/lstack_wrap.c b/src/lstack/api/lstack_wrap.c +index 98632c0..505e33d 100644 +--- a/src/lstack/api/lstack_wrap.c ++++ b/src/lstack/api/lstack_wrap.c +@@ -81,14 +81,21 @@ static inline enum KERNEL_LWIP_PATH select_path(int fd, struct lwip_sock **socke + return PATH_LWIP; + } + +- struct tcp_pcb *pcb = sock->conn->pcb.tcp; +- /* after lwip connect, call send immediately, pcb->state is SYN_SENT, need return PATH_LWIP */ +- /* pcb->state default value is CLOSED when call socket, need return PATH_UNKNOW */ +- if (pcb != NULL && pcb->state <= ESTABLISHED && pcb->state >= LISTEN) { ++ if (NETCONN_IS_UDP(sock)) { + if (socket) { + *socket = sock; + } + return PATH_LWIP; ++ } else { ++ struct tcp_pcb *pcb = sock->conn->pcb.tcp; ++ /* after lwip connect, call send immediately, pcb->state is SYN_SENT, need return PATH_LWIP */ ++ /* pcb->state default value is CLOSED when call socket, need return PATH_UNKNOW */ ++ if (pcb != NULL && pcb->state <= ESTABLISHED && pcb->state >= LISTEN) { ++ if (socket) { ++ *socket = sock; ++ } ++ return PATH_LWIP; ++ } + } + + return PATH_UNKNOW; +@@ -396,7 +403,7 @@ static inline int32_t do_setsockopt(int32_t s, int32_t level, int32_t optname, c + static inline int32_t do_socket(int32_t domain, int32_t type, int32_t protocol) + { + if ((domain != AF_INET && domain != AF_UNSPEC) +- || posix_api->ues_posix || ((type & SOCK_TYPE_MASK) & ~SOCK_STREAM)) { ++ || posix_api->ues_posix) { + return posix_api->socket_fn(domain, type, protocol); + } + +@@ -415,7 +422,7 @@ static inline ssize_t do_recv(int32_t sockfd, void *buf, size_t len, int32_t fla + + struct lwip_sock *sock = NULL; + if (select_path(sockfd, &sock) == PATH_LWIP) { +- return read_stack_data(sockfd, buf, len, flags); ++ return read_stack_data(sockfd, buf, len, flags, NULL, NULL); + } + + return posix_api->recv_fn(sockfd, buf, len, flags); +@@ -433,7 +440,7 @@ static inline ssize_t do_read(int32_t s, void *mem, size_t len) + + struct lwip_sock *sock = NULL; + if (select_path(s, &sock) == PATH_LWIP) { +- return read_stack_data(s, mem, len, 0); ++ return read_stack_data(s, mem, len, 0, NULL, NULL); + } + return posix_api->read_fn(s, mem, len); + } +@@ -469,7 +476,7 @@ static inline ssize_t do_send(int32_t sockfd, const void *buf, size_t len, int32 + return posix_api->send_fn(sockfd, buf, len, flags); + } + +- return gazelle_send(sockfd, buf, len, flags); ++ return gazelle_send(sockfd, buf, len, flags, NULL, 0); + } + + static inline ssize_t do_write(int32_t s, const void *mem, size_t size) +@@ -479,7 +486,7 @@ static inline ssize_t do_write(int32_t s, const void *mem, size_t size) + return posix_api->write_fn(s, mem, size); + } + +- return gazelle_send(s, mem, size, 0); ++ return gazelle_send(s, mem, size, 0, NULL, 0); + } + + static inline ssize_t do_writev(int32_t s, const struct iovec *iov, int iovcnt) +@@ -529,6 +536,36 @@ static inline ssize_t do_sendmsg(int32_t s, const struct msghdr *message, int32_ + return posix_api->send_msg(s, message, flags); + } + ++static inline ssize_t do_recvfrom(int32_t sockfd, void *buf, size_t len, int32_t flags, ++ struct sockaddr *addr, socklen_t *addrlen) ++{ ++ if (buf == NULL) { ++ GAZELLE_RETURN(EINVAL); ++ } ++ ++ if (len == 0) { ++ return 0; ++ } ++ ++ struct lwip_sock *sock = NULL; ++ if (select_path(sockfd, &sock) == PATH_LWIP) { ++ return read_stack_data(sockfd, buf, len, flags, addr, addrlen); ++ } ++ ++ return posix_api->recv_from(sockfd, buf, len, flags, addr, addrlen); ++} ++ ++static inline ssize_t do_sendto(int32_t sockfd, const void *buf, size_t len, int32_t flags, ++ const struct sockaddr *addr, socklen_t addrlen) ++{ ++ struct lwip_sock *sock = NULL; ++ if (select_path(sockfd, &sock) != PATH_LWIP) { ++ return posix_api->send_to(sockfd, buf, len, flags, addr, addrlen); ++ } ++ ++ return gazelle_send(sockfd, buf, len, flags, addr, addrlen); ++} ++ + static inline int32_t do_close(int32_t s) + { + struct lwip_sock *sock = NULL; +@@ -716,6 +753,16 @@ ssize_t sendmsg(int32_t s, const struct msghdr *message, int32_t flags) + { + return do_sendmsg(s, message, flags); + } ++ssize_t recvfrom(int32_t sockfd, void *buf, size_t len, int32_t flags, ++ struct sockaddr *addr, socklen_t *addrlen) ++{ ++ return do_recvfrom(sockfd, buf, len, flags, addr, addrlen); ++} ++ssize_t sendto(int32_t sockfd, const void *buf, size_t len, int32_t flags, ++ const struct sockaddr *addr, socklen_t addrlen) ++{ ++ return do_sendto(sockfd, buf, len, flags, addr, addrlen); ++} + int32_t close(int32_t s) + { + return do_close(s); +@@ -835,6 +882,16 @@ ssize_t __wrap_sendmsg(int32_t s, const struct msghdr *message, int32_t flags) + { + return do_sendmsg(s, message, flags); + } ++ssize_t __wrap_recvfrom(int32_t sockfd, void *buf, size_t len, int32_t flags, ++ struct sockaddr *addr, socklen_t *addrlen) ++{ ++ return do_recvfrom(sockfd, buf, len, flags, addr, addrlen); ++} ++ssize_t __wrap_sendto(int32_t sockfd, const void *buf, size_t len, int32_t flags, ++ const struct sockaddr *addr, socklen_t addrlen) ++{ ++ return do_sendto(sockfd, buf, len, flags, addr, addrlen); ++} + int32_t __wrap_close(int32_t s) + { + return do_close(s); +diff --git a/src/lstack/core/lstack_lwip.c b/src/lstack/core/lstack_lwip.c +index ed89054..c748b37 100644 +--- a/src/lstack/core/lstack_lwip.c ++++ b/src/lstack/core/lstack_lwip.c +@@ -14,11 +14,13 @@ + #include + #include + #include ++#include + #include + #include + #include + #include + #include ++#include + #include + #include + #include +@@ -121,6 +123,8 @@ static struct pbuf *init_mbuf_to_pbuf(struct rte_mbuf *mbuf, pbuf_layer layer, u + pbuf->allow_in = 1; + pbuf->head = 0; + pbuf->last = pbuf; ++ pbuf->addr.addr = 0; ++ pbuf->port = 0; + pthread_spin_init(&pbuf->pbuf_lock, PTHREAD_PROCESS_SHARED); + } + +@@ -449,7 +453,8 @@ static inline ssize_t app_direct_attach(struct protocol_stack *stack, struct pbu + return send_len; + } + +-static inline ssize_t app_buff_write(struct lwip_sock *sock, void *buf, size_t len, uint32_t write_num) ++static inline ssize_t app_buff_write(struct lwip_sock *sock, void *buf, size_t len, uint32_t write_num, ++ const struct sockaddr *addr, socklen_t addrlen) + { + struct pbuf *pbufs[SOCK_SEND_RING_SIZE_MAX]; + +@@ -457,6 +462,14 @@ static inline ssize_t app_buff_write(struct lwip_sock *sock, void *buf, size_t l + + ssize_t send_len = do_app_write(pbufs, buf, len, write_num); + ++ if (addr) { ++ struct sockaddr_in *saddr = (struct sockaddr_in *)addr; ++ for (int i = 0; i < write_num; i++) { ++ pbufs[i]->addr.addr = saddr->sin_addr.s_addr; ++ pbufs[i]->port = lwip_ntohs((saddr)->sin_port); ++ } ++ } ++ + gazelle_ring_read_over(sock->send_ring); + + sock->remain_len = MBUF_MAX_DATA_LEN - pbufs[write_num - 1]->len; +@@ -535,7 +548,8 @@ int sem_timedwait_nsecs(sem_t *sem) + return sem_timedwait(sem, &ts); + } + +-ssize_t write_stack_data(struct lwip_sock *sock, const void *buf, size_t len) ++ssize_t write_stack_data(struct lwip_sock *sock, const void *buf, size_t len, ++ const struct sockaddr *addr, socklen_t addrlen) + { + if (sock->errevent > 0) { + GAZELLE_RETURN(ENOTCONN); +@@ -580,6 +594,11 @@ ssize_t write_stack_data(struct lwip_sock *sock, const void *buf, size_t len) + if (wakeup) { + wakeup->stat.app_write_cnt += write_num; + } ++ if (addr) { ++ struct sockaddr_in *saddr = (struct sockaddr_in *)addr; ++ last_pbuf->addr.addr = saddr->sin_addr.s_addr; ++ last_pbuf->port = lwip_ntohs((saddr)->sin_port); ++ } + } else { + (void)rpc_call_replenish(stack, sock); + if (wakeup) { +@@ -593,14 +612,14 @@ ssize_t write_stack_data(struct lwip_sock *sock, const void *buf, size_t len) + /* send_ring have idle */ + if (get_global_cfg_params()->expand_send_ring) { + send_len += (write_num <= write_avail) ? +- app_buff_write(sock, (char *)buf + send_len, len - send_len, write_num) : ++ app_buff_write(sock, (char *)buf + send_len, len - send_len, write_num, addr, addrlen) : + app_direct_write(stack, sock, (char *)buf + send_len, len - send_len, write_num); + } else { + if (write_num > write_avail) { + write_num = write_avail; + len = write_num * MBUF_MAX_DATA_LEN; + } +- send_len += app_buff_write(sock, (char *)buf + send_len, len - send_len, write_num); ++ send_len += app_buff_write(sock, (char *)buf + send_len, len - send_len, write_num, addr, addrlen); + } + + if (wakeup) { +@@ -640,10 +659,15 @@ void rpc_replenish(struct rpc_msg *msg) + msg->result = replenish_send_ring(stack, sock); + } + +-static inline bool do_lwip_send(struct protocol_stack *stack, int32_t fd, struct lwip_sock *sock, int32_t flags) ++static inline bool do_lwip_send(struct protocol_stack *stack, int32_t fd, struct lwip_sock *sock, ++ size_t len, int32_t flags) + { + /* send all send_ring, so len set lwip send max. */ +- (void)lwip_send(fd, sock, UINT16_MAX, flags); ++ if (NETCONN_IS_UDP(sock)) { ++ (void)lwip_send(fd, sock, len, flags); ++ } else { ++ (void)lwip_send(fd, sock, UINT16_MAX, flags); ++ } + + return replenish_send_ring(stack, sock); + } +@@ -651,6 +675,7 @@ static inline bool do_lwip_send(struct protocol_stack *stack, int32_t fd, struct + void stack_send(struct rpc_msg *msg) + { + int32_t fd = msg->args[MSG_ARG_0].i; ++ size_t len = msg->args[MSG_ARG_1].size; + struct protocol_stack *stack = (struct protocol_stack *)msg->args[MSG_ARG_3].p; + bool replenish_again; + +@@ -662,7 +687,7 @@ void stack_send(struct rpc_msg *msg) + return; + } + +- replenish_again = do_lwip_send(stack, sock->conn->socket, sock, 0); ++ replenish_again = do_lwip_send(stack, sock->conn->socket, sock, len, 0); + __sync_fetch_and_sub(&sock->call_num, 1); + if (!NETCONN_IS_DATAOUT(sock) && !replenish_again) { + rpc_msg_free(msg); +@@ -711,11 +736,21 @@ ssize_t read_lwip_data(struct lwip_sock *sock, int32_t flags, u8_t apiflags) + uint32_t data_count = rte_ring_count(sock->conn->recvmbox->ring); + uint32_t read_num = LWIP_MIN(free_count, data_count); + struct pbuf *pbufs[SOCK_RECV_RING_SIZE]; ++ struct netbuf *netbufs[SOCK_RECV_RING_SIZE]; + uint32_t read_count = 0; + ssize_t recv_len = 0; + + for (uint32_t i = 0; i < read_num; i++) { +- err_t err = netconn_recv_tcp_pbuf_flags(sock->conn, &pbufs[i], apiflags); ++ ++ err_t err = ERR_OK; ++ if (NETCONN_IS_UDP(sock)) { ++ err = netconn_recv_udp_raw_netbuf_flags(sock->conn, &netbufs[i], apiflags); ++ pbufs[i] = netbufs[i]->p; ++ pbufs[i]->addr = netbufs[i]->addr; ++ pbufs[i]->port = netbufs[i]->port; ++ } else { ++ err = netconn_recv_tcp_pbuf_flags(sock->conn, &pbufs[i], apiflags); ++ } + if (err != ERR_OK) { + if (recv_len > 0) { + /* already received data, return that (this trusts in getting the same error from +@@ -734,10 +769,19 @@ ssize_t read_lwip_data(struct lwip_sock *sock, int32_t flags, u8_t apiflags) + } + + uint32_t enqueue_num = gazelle_ring_sp_enqueue(sock->recv_ring, (void **)pbufs, read_count); ++ if (NETCONN_IS_UDP(sock)) { ++ for (uint32_t i = 0; i < read_count; i++) { ++ memp_free(MEMP_NETBUF, netbufs[i]); ++ } ++ } + for (uint32_t i = enqueue_num; i < read_count; i++) { +- /* update receive window */ +- tcp_recved(sock->conn->pcb.tcp, pbufs[i]->tot_len); +- pbuf_free(pbufs[i]); ++ if (NETCONN_IS_UDP(sock)) { ++ netbuf_delete(netbufs[i]); ++ } else { ++ /* update receive window */ ++ tcp_recved(sock->conn->pcb.tcp, pbufs[i]->tot_len); ++ pbuf_free(pbufs[i]); ++ } + sock->stack->stats.read_lwip_drop++; + } + +@@ -785,7 +829,8 @@ ssize_t recvmsg_from_stack(int32_t s, struct msghdr *message, int32_t flags) + continue; + } + +- ssize_t recvd_local = read_stack_data(s, message->msg_iov[i].iov_base, message->msg_iov[i].iov_len, flags); ++ ssize_t recvd_local = read_stack_data(s, message->msg_iov[i].iov_base, message->msg_iov[i].iov_len, ++ flags, NULL, NULL); + if (recvd_local > 0) { + buflen += recvd_local; + } +@@ -914,7 +959,8 @@ static inline void thread_bind_stack(struct lwip_sock *sock) + } + } + +-ssize_t gazelle_send(int32_t fd, const void *buf, size_t len, int32_t flags) ++ssize_t gazelle_send(int32_t fd, const void *buf, size_t len, int32_t flags, ++ const struct sockaddr *addr, socklen_t addrlen) + { + if (buf == NULL) { + GAZELLE_RETURN(EINVAL); +@@ -931,7 +977,7 @@ ssize_t gazelle_send(int32_t fd, const void *buf, size_t len, int32_t flags) + if (sock->same_node_tx_ring != NULL) { + return gazelle_same_node_ring_send(sock, buf, len, flags); + } +- ssize_t send = write_stack_data(sock, buf, len); ++ ssize_t send = write_stack_data(sock, buf, len, addr, addrlen); + if (send <= 0) { + return send; + } +@@ -955,7 +1001,7 @@ ssize_t sendmsg_to_stack(struct lwip_sock *sock, int32_t s, const struct msghdr + continue; + } + +- ret = write_stack_data(sock, message->msg_iov[i].iov_base, message->msg_iov[i].iov_len); ++ ret = write_stack_data(sock, message->msg_iov[i].iov_base, message->msg_iov[i].iov_len, NULL, 0); + if (ret <= 0) { + buflen = (buflen == 0) ? ret : buflen; + break; +@@ -994,7 +1040,7 @@ static struct pbuf *pbuf_free_partial(struct pbuf *pbuf, uint16_t free_len) + return pbuf; + } + +-ssize_t read_stack_data(int32_t fd, void *buf, size_t len, int32_t flags) ++ssize_t read_stack_data(int32_t fd, void *buf, size_t len, int32_t flags, struct sockaddr *addr, socklen_t *addrlen) + { + size_t recv_left = len; + struct pbuf *pbuf = NULL; +@@ -1051,6 +1097,10 @@ ssize_t read_stack_data(int32_t fd, void *buf, size_t len, int32_t flags) + del_data_in_event(sock); + } + ++ if (addr && addrlen) { ++ lwip_sock_make_addr(sock->conn, &(pbuf->addr), pbuf->port, addr, addrlen); ++ } ++ + if (recvd == 0) { + if (sock->wakeup) { + sock->wakeup->stat.read_null++; +@@ -1106,7 +1156,12 @@ void read_recv_list(struct protocol_stack *stack, uint32_t max_num) + continue; + } + +- ssize_t len = lwip_recv(sock->conn->socket, NULL, 0, 0); ++ ssize_t len = 0; ++ if (NETCONN_IS_UDP(sock)) { ++ len = lwip_recv(sock->conn->socket, NULL, SSIZE_MAX, 0); ++ } else { ++ len = lwip_recv(sock->conn->socket, NULL, 0, 0); ++ } + if (len == 0) { + sock->errevent = 1; + add_sock_event(sock, EPOLLERR); +@@ -1189,11 +1244,6 @@ static inline void clone_lwip_socket_opt(struct lwip_sock *dst_sock, struct lwip + + int32_t gazelle_socket(int domain, int type, int protocol) + { +- if (((type & SOCK_TYPE_MASK) & ~SOCK_STREAM) != 0) { +- LSTACK_LOG(ERR, LSTACK, "sock type error:%d, only support SOCK_STREAM \n", type); +- return -1; +- } +- + int32_t fd = lwip_socket(AF_INET, type, 0); + if (fd < 0) { + return fd; +diff --git a/src/lstack/include/lstack_lwip.h b/src/lstack/include/lstack_lwip.h +index 0b29e71..223ff93 100644 +--- a/src/lstack/include/lstack_lwip.h ++++ b/src/lstack/include/lstack_lwip.h +@@ -17,6 +17,7 @@ + #define NETCONN_IS_DATAIN(sock) ((gazelle_ring_readable_count((sock)->recv_ring) || (sock)->recv_lastdata) || (sock->same_node_rx_ring != NULL && same_node_ring_count(sock))) + #define NETCONN_IS_DATAOUT(sock) (gazelle_ring_readover_count((sock)->send_ring) || (sock)->send_lastdata || (sock)->send_pre_del) + #define NETCONN_IS_OUTIDLE(sock) gazelle_ring_readable_count((sock)->send_ring) ++#define NETCONN_IS_UDP(sock) (NETCONNTYPE_GROUP(netconn_type((sock)->conn)) == NETCONN_UDP) + + struct lwip_sock; + struct rte_mempool; +@@ -29,8 +30,9 @@ int32_t gazelle_socket(int domain, int type, int protocol); + void gazelle_clean_sock(int32_t fd); + struct pbuf *write_lwip_data(struct lwip_sock *sock, uint16_t remain_size, uint8_t *apiflags); + void write_lwip_over(struct lwip_sock *sock); +-ssize_t write_stack_data(struct lwip_sock *sock, const void *buf, size_t len); +-ssize_t read_stack_data(int32_t fd, void *buf, size_t len, int32_t flags); ++ssize_t write_stack_data(struct lwip_sock *sock, const void *buf, size_t len, ++ const struct sockaddr *addr, socklen_t addrlen); ++ssize_t read_stack_data(int32_t fd, void *buf, size_t len, int32_t flags, struct sockaddr *addr, socklen_t *addrlen); + ssize_t read_lwip_data(struct lwip_sock *sock, int32_t flags, uint8_t apiflags); + void read_recv_list(struct protocol_stack *stack, uint32_t max_num); + void read_same_node_recv_list(struct protocol_stack *stack); +@@ -45,7 +47,8 @@ int32_t gazelle_alloc_pktmbuf(struct rte_mempool *pool, struct rte_mbuf **mbufs, + void gazelle_free_pbuf(struct pbuf *pbuf); + ssize_t sendmsg_to_stack(struct lwip_sock *sock, int32_t s, const struct msghdr *message, int32_t flags); + ssize_t recvmsg_from_stack(int32_t s, struct msghdr *message, int32_t flags); +-ssize_t gazelle_send(int32_t fd, const void *buf, size_t len, int32_t flags); ++ssize_t gazelle_send(int32_t fd, const void *buf, size_t len, int32_t flags, ++ const struct sockaddr *addr, socklen_t addrlen); + void rpc_replenish(struct rpc_msg *msg); + void stack_mempool_size(struct rpc_msg *msg); + +diff --git a/src/lstack/lstack.Makefile b/src/lstack/lstack.Makefile +index 7da439d..768c5ba 100644 +--- a/src/lstack/lstack.Makefile ++++ b/src/lstack/lstack.Makefile +@@ -45,7 +45,9 @@ WRAP_API := epoll_ctl \ + readv \ + writev \ + poll \ +- ppoll ++ ppoll \ ++ sendto \ ++ recvfrom + + WRAP_LDFLAGS = $(patsubst %, $(WRAP_PREFIX)%, $(WRAP_API)) + +diff --git a/src/lstack/netif/lstack_ethdev.c b/src/lstack/netif/lstack_ethdev.c +index 7514e58..ebe7450 100644 +--- a/src/lstack/netif/lstack_ethdev.c ++++ b/src/lstack/netif/lstack_ethdev.c +@@ -842,6 +842,10 @@ static err_t eth_dev_output(struct netif *netif, struct pbuf *pbuf) + } + } + ++ if (first_pbuf->l4_len == 8) { ++ mbuf->data_off += 12; ++ } ++ + if (likely(first_mbuf->pkt_len > MBUF_MAX_LEN)) { + mbuf->ol_flags |= PKT_TX_TCP_SEG; + mbuf->tso_segsz = MBUF_MAX_DATA_LEN; +@@ -873,7 +877,7 @@ static err_t eth_dev_init(struct netif *netif) + + netif->name[0] = 'e'; + netif->name[1] = 't'; +- netif->flags |= NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP; ++ netif->flags |= NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP | NETIF_FLAG_IGMP; + netif->mtu = FRAME_MTU; + netif->output = etharp_output; + netif->linkoutput = eth_dev_output; +diff --git a/src/ltran/ltran_stat.c b/src/ltran/ltran_stat.c +index 50f65e3..c17a5c1 100644 +--- a/src/ltran/ltran_stat.c ++++ b/src/ltran/ltran_stat.c +@@ -16,7 +16,6 @@ + #include + #include + #include +-#include + + #include "ltran_tcp_sock.h" + #include "ltran_tcp_conn.h" +@@ -30,6 +29,13 @@ + #include "dpdk_common.h" + #include "ltran_forward.h" + ++/* undefine lwip_ntohs in lwip/def.h */ ++#ifdef ntohs ++#undef ntohs ++#endif ++#include ++ ++ + static uint64_t g_start_time_stamp = 0; + static int32_t g_start_latency = GAZELLE_OFF; + volatile int32_t g_ltran_stop_flag = GAZELLE_FALSE; +-- +2.33.0 + diff --git a/gazelle.spec b/gazelle.spec index 62c8f62..4c7f22b 100644 --- a/gazelle.spec +++ b/gazelle.spec @@ -2,7 +2,7 @@ Name: gazelle Version: 1.0.1 -Release: 62 +Release: 63 Summary: gazelle is a high performance user-mode stack License: MulanPSL-2.0 URL: https://gitee.com/openeuler/gazelle @@ -255,6 +255,11 @@ Patch9237: 0237-fix-rpc-msg-alloc-failed.patch Patch9238: 0238-add-parentheses-to-fix-build-error.patch Patch9239: 0239-add-udp-protocol-support-in-example.patch Patch9240: 0240-fix-bond_ports-parse-error.patch +Patch9241: 0241-dfx-set-g_unix_fd-to-1-after-abnormal-close-fd-to-av.patch +Patch9242: 0242-dfx-security-function-failed-return-error-directly.patch +Patch9243: 0243-add-bond4-suport.patch +Patch9244: 0244-clean-code.patch +Patch9245: 0245-add-udp-multicast-support-in-gazelle.patch %description %{name} is a high performance user-mode stack. @@ -295,6 +300,13 @@ install -Dpm 0640 %{_builddir}/%{name}-%{version}/src/ltran/ltran.conf %{b %config(noreplace) %{conf_path}/ltran.conf %changelog +* Tue May 16 2023 kircher - 1.0.1-63 +- add udp multicast support in gazelle +- clean code +- add bond4 suport +- dfx: security function failed, return error directly +- dfx: set g_unix_fd to -1 after abnormal close fd to avoid double close + * Mon Apr 10 2023 jiangheng12 - 1.0.1-62 - fix bond_ports parse error fix socket_mem parse error when the value exceeds 65536 exit if create_rxtx_pktmbuf failed build.sh build failed return 1 clean code - add udp protocol support in example