diff --git a/0003-execute-gazelle_init_sock-before-read-event.patch b/0003-execute-gazelle_init_sock-before-read-event.patch new file mode 100644 index 0000000..087a29f --- /dev/null +++ b/0003-execute-gazelle_init_sock-before-read-event.patch @@ -0,0 +1,27 @@ +From 23c3c39dda9ff0810ee16a5db7e2b21edc6a37d7 Mon Sep 17 00:00:00 2001 +From: jiangheng +Date: Mon, 7 Mar 2022 23:14:21 +0800 +Subject: [PATCH 03/34] execute gazelle_init_sock() before read event + +--- + src/lstack/core/lstack_protocol_stack.c | 4 +--- + 1 file changed, 1 insertion(+), 3 deletions(-) + +diff --git a/src/lstack/core/lstack_protocol_stack.c b/src/lstack/core/lstack_protocol_stack.c +index 35665e6..f96d7a3 100644 +--- a/src/lstack/core/lstack_protocol_stack.c ++++ b/src/lstack/core/lstack_protocol_stack.c +@@ -518,9 +518,7 @@ void stack_accept(struct rpc_msg *msg) + fd = sock->attach_fd; + + msg->result = lwip_accept(fd, msg->args[MSG_ARG_1].p, msg->args[MSG_ARG_2].p); +- if (msg->result > 0) { +- gazelle_init_sock(msg->result); +- } else { ++ if (msg->result <= 0) { + LSTACK_LOG(ERR, LSTACK, "tid %ld, fd %d attach_fd %d failed %ld\n", get_stack_tid(), msg->args[MSG_ARG_0].i, + fd, msg->result); + } +-- +1.8.3.1 + diff --git a/0004-recvmsg-sendmsg-should-use-recvmsg_from_stack-sendms.patch b/0004-recvmsg-sendmsg-should-use-recvmsg_from_stack-sendms.patch new file mode 100644 index 0000000..e4a9d9d --- /dev/null +++ b/0004-recvmsg-sendmsg-should-use-recvmsg_from_stack-sendms.patch @@ -0,0 +1,193 @@ +From 0f126e8723824823cddc608c2a6493ea9fc99e89 Mon Sep 17 00:00:00 2001 +From: jiangheng +Date: Tue, 8 Mar 2022 10:59:59 +0800 +Subject: [PATCH 04/34] recvmsg/sendmsg should use + recvmsg_from_stack/sendmsg_to_stack instead of + rpc_call_recvmsg/rpc_call_sendmsg + +--- + src/lstack/api/lstack_wrap.c | 33 +-------------- + src/lstack/core/lstack_lwip.c | 88 ++++++++++++++++++++++++++++++++++++++++ + src/lstack/include/lstack_lwip.h | 3 ++ + 3 files changed, 93 insertions(+), 31 deletions(-) + +diff --git a/src/lstack/api/lstack_wrap.c b/src/lstack/api/lstack_wrap.c +index 6488c62..7804ce9 100644 +--- a/src/lstack/api/lstack_wrap.c ++++ b/src/lstack/api/lstack_wrap.c +@@ -103,10 +103,6 @@ static inline int32_t do_epoll_wait(int32_t epfd, struct epoll_event* events, in + + static inline int32_t do_accept(int32_t s, struct sockaddr *addr, socklen_t *addrlen) + { +- if (addr == NULL || addrlen == NULL) { +- GAZELLE_RETURN(EINVAL); +- } +- + if (select_path(s) == PATH_KERNEL) { + return posix_api->accept_fn(s, addr, addrlen); + } +@@ -292,31 +288,6 @@ static inline ssize_t do_read(int32_t s, void *mem, size_t len) + return posix_api->read_fn(s, mem, len); + } + +-static inline ssize_t gazelle_send(int32_t fd, const void *buf, size_t len, int32_t flags) +-{ +- if (buf == NULL) { +- GAZELLE_RETURN(EINVAL); +- } +- +- if (len == 0) { +- return 0; +- } +- +- struct lwip_sock *sock = get_socket(fd); +- if (sock == NULL) { +- GAZELLE_RETURN(EINVAL); +- } +- +- ssize_t send = write_stack_data(sock, buf, len); +- if (send < 0 || sock->have_rpc_send) { +- return send; +- } +- +- sock->have_rpc_send = true; +- ssize_t ret = rpc_call_send(fd, buf, len, flags); +- return (ret < 0) ? ret : send; +-} +- + static inline ssize_t do_send(int32_t sockfd, const void *buf, size_t len, int32_t flags) + { + if (select_path(sockfd) != PATH_LWIP) { +@@ -342,7 +313,7 @@ static inline ssize_t do_recvmsg(int32_t s, struct msghdr *message, int32_t flag + } + + if (select_path(s) == PATH_LWIP) { +- return rpc_call_recvmsg(s, message, flags); ++ return recvmsg_from_stack(s, message, flags); + } + + return posix_api->recv_msg(s, message, flags); +@@ -355,7 +326,7 @@ static inline ssize_t do_sendmsg(int32_t s, const struct msghdr *message, int32_ + } + + if (select_path(s) == PATH_LWIP) { +- return rpc_call_sendmsg(s, message, flags); ++ return sendmsg_to_stack(s, message, flags); + } + + return posix_api->send_msg(s, message, flags); +diff --git a/src/lstack/core/lstack_lwip.c b/src/lstack/core/lstack_lwip.c +index fbb4d62..0a71aae 100644 +--- a/src/lstack/core/lstack_lwip.c ++++ b/src/lstack/core/lstack_lwip.c +@@ -386,6 +386,94 @@ ssize_t read_lwip_data(struct lwip_sock *sock, int32_t flags, u8_t apiflags) + return recv_len; + } + ++ssize_t recvmsg_from_stack(int32_t s, struct msghdr *message, int32_t flags) ++{ ++ ssize_t buflen = 0; ++ int32_t i; ++ ++ if (message == NULL || message->msg_iovlen <= 0 || message->msg_iovlen > IOV_MAX) { ++ GAZELLE_RETURN(EINVAL); ++ } ++ for (i = 0; i < message->msg_iovlen; i++) { ++ if ((message->msg_iov[i].iov_base == NULL) || ((ssize_t)message->msg_iov[i].iov_len <= 0) || ++ ((size_t)(ssize_t)message->msg_iov[i].iov_len != message->msg_iov[i].iov_len) || ++ ((ssize_t)(buflen + (ssize_t)message->msg_iov[i].iov_len) <= 0)) { ++ GAZELLE_RETURN(EINVAL); ++ } ++ buflen = (ssize_t)(buflen + (ssize_t)message->msg_iov[i].iov_len); ++ } ++ buflen = 0; ++ for (i = 0; i < message->msg_iovlen; i++) { ++ ssize_t recvd_local = read_stack_data(s, message->msg_iov[i].iov_base, message->msg_iov[i].iov_len, flags); ++ if (recvd_local > 0) { ++ buflen += recvd_local; ++ } ++ if (recvd_local < 0 || (recvd_local < (int)message->msg_iov[i].iov_len) || (flags & MSG_PEEK)) { ++ if (buflen <= 0) { ++ buflen = recvd_local; ++ } ++ break; ++ } ++ flags |= MSG_DONTWAIT; ++ } ++ ++ return buflen; ++} ++ ++ssize_t gazelle_send(int32_t fd, const void *buf, size_t len, int32_t flags) ++{ ++ if (buf == NULL) { ++ GAZELLE_RETURN(EINVAL); ++ } ++ ++ if (len == 0) { ++ return 0; ++ } ++ ++ struct lwip_sock *sock = get_socket(fd); ++ if (sock == NULL) { ++ GAZELLE_RETURN(EINVAL); ++ } ++ ++ ssize_t send = write_stack_data(sock, buf, len); ++ if (send < 0 || sock->have_rpc_send) { ++ return send; ++ } ++ ++ sock->have_rpc_send = true; ++ ssize_t ret = rpc_call_send(fd, buf, len, flags); ++ return (ret < 0) ? ret : send; ++} ++ ++ssize_t sendmsg_to_stack(int32_t s, const struct msghdr *message, int32_t flags) ++{ ++ int32_t ret; ++ int32_t i; ++ ssize_t buflen = 0; ++ ++ if (message == NULL || message->msg_iovlen <= 0 || message->msg_iovlen > IOV_MAX) { ++ GAZELLE_RETURN(EINVAL); ++ } ++ for (i = 0; i < message->msg_iovlen; i++) { ++ if ((message->msg_iov[i].iov_base == NULL) || ((ssize_t)message->msg_iov[i].iov_len <= 0) || ++ ((size_t)(ssize_t)message->msg_iov[i].iov_len != message->msg_iov[i].iov_len) || ++ ((ssize_t)(buflen + (ssize_t)message->msg_iov[i].iov_len) <= 0)) { ++ GAZELLE_RETURN(EINVAL); ++ } ++ buflen = (ssize_t)(buflen + (ssize_t)message->msg_iov[i].iov_len); ++ } ++ ++ for (i = 0; i < message->msg_iovlen; i++) { ++ ret = gazelle_send(s, message->msg_iov[i].iov_base, message->msg_iov[i].iov_len, flags); ++ if (ret < 0) { ++ return buflen == 0 ? ret : buflen; ++ } ++ buflen += ret; ++ } ++ ++ return buflen; ++} ++ + ssize_t read_stack_data(int32_t fd, void *buf, size_t len, int32_t flags) + { + size_t recv_left = len; +diff --git a/src/lstack/include/lstack_lwip.h b/src/lstack/include/lstack_lwip.h +index 8bf0f29..581b9fe 100644 +--- a/src/lstack/include/lstack_lwip.h ++++ b/src/lstack/include/lstack_lwip.h +@@ -39,5 +39,8 @@ void stack_recvlist_count(struct rpc_msg *msg); + void stack_replenish_send_idlembuf(struct protocol_stack *stack); + int32_t gazelle_alloc_pktmbuf(struct rte_mempool *pool, struct rte_mbuf **mbufs, uint32_t num); + void gazelle_free_pbuf(struct pbuf *pbuf); ++ssize_t sendmsg_to_stack(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); + + #endif +-- +1.8.3.1 + diff --git a/0005-fix-LD_PRELOAD.patch b/0005-fix-LD_PRELOAD.patch new file mode 100644 index 0000000..be6fed4 --- /dev/null +++ b/0005-fix-LD_PRELOAD.patch @@ -0,0 +1,31 @@ +From ff74c402d0502797fe4411178882bb3cb8e3ddd9 Mon Sep 17 00:00:00 2001 +From: jiangheng +Date: Mon, 7 Mar 2022 23:30:12 +0800 +Subject: [PATCH 05/34] fix LD_PRELOAD + +--- + src/lstack/api/lstack_wrap.c | 8 ++++++++ + 1 file changed, 8 insertions(+) + +diff --git a/src/lstack/api/lstack_wrap.c b/src/lstack/api/lstack_wrap.c +index 7804ce9..6ee5639 100644 +--- a/src/lstack/api/lstack_wrap.c ++++ b/src/lstack/api/lstack_wrap.c +@@ -44,6 +44,14 @@ enum KERNEL_LWIP_PATH { + + static inline enum KERNEL_LWIP_PATH select_path(int fd) + { ++ if (posix_api == NULL) { ++ /* link liblstack.so using LD_PRELOAD mode will read liblstack.so, ++ poisx_api need to be initialized here */ ++ if (posix_api_init() != 0) { ++ LSTACK_PRE_LOG(LSTACK_ERR, "posix_api_init failed\n"); ++ } ++ return PATH_KERNEL; ++ } + struct lwip_sock *sock = posix_api->get_socket(fd); + + /* AF_UNIX case */ +-- +1.8.3.1 + diff --git a/0006-reduce-replenish-send_idle_ring-rpc-call.patch b/0006-reduce-replenish-send_idle_ring-rpc-call.patch new file mode 100644 index 0000000..d88e667 --- /dev/null +++ b/0006-reduce-replenish-send_idle_ring-rpc-call.patch @@ -0,0 +1,65 @@ +From 7b7dd1bdda75f8877e57f3b29432e3e1686bf9b5 Mon Sep 17 00:00:00 2001 +From: jiangheng +Date: Mon, 7 Mar 2022 23:35:07 +0800 +Subject: [PATCH 06/34] reduce replenish send_idle_ring rpc call + +--- + src/lstack/core/lstack_lwip.c | 4 ++-- + src/lstack/core/lstack_thread_rpc.c | 2 ++ + src/lstack/include/lstack_protocol_stack.h | 1 + + 3 files changed, 5 insertions(+), 2 deletions(-) + +diff --git a/src/lstack/core/lstack_lwip.c b/src/lstack/core/lstack_lwip.c +index 0a71aae..a9ef824 100644 +--- a/src/lstack/core/lstack_lwip.c ++++ b/src/lstack/core/lstack_lwip.c +@@ -240,7 +240,7 @@ void stack_replenish_send_idlembuf(struct protocol_stack *stack) + ssize_t write_lwip_data(struct lwip_sock *sock, int32_t fd, int32_t flags) + { + struct pbuf *pbuf = NULL; +- ssize_t send_ret; ++ ssize_t send_ret = 0; + ssize_t send_len = 0; + + do { +@@ -327,7 +327,7 @@ ssize_t write_stack_data(struct lwip_sock *sock, const void *buf, size_t len) + sock->have_event = false; + } + +- if (rte_ring_free_count(sock->stack->send_idle_ring) > USED_IDLE_WATERMARK) { ++ if (rte_ring_free_count(sock->stack->send_idle_ring) > USED_IDLE_WATERMARK && !sock->stack->in_replenish) { + rpc_call_replenish_idlembuf(sock->stack); + } + +diff --git a/src/lstack/core/lstack_thread_rpc.c b/src/lstack/core/lstack_thread_rpc.c +index 1ed20dd..8b3d36c 100644 +--- a/src/lstack/core/lstack_thread_rpc.c ++++ b/src/lstack/core/lstack_thread_rpc.c +@@ -194,10 +194,12 @@ static void rpc_replenish_idlembuf(struct rpc_msg *msg) + { + struct protocol_stack *stack = get_protocol_stack(); + stack_replenish_send_idlembuf(stack); ++ stack->in_replenish = 0; + } + + void rpc_call_replenish_idlembuf(struct protocol_stack *stack) + { ++ stack->in_replenish = 1; + struct rpc_msg *msg = rpc_msg_alloc(stack->rpc_pool, rpc_replenish_idlembuf); + if (msg == NULL) { + return; +diff --git a/src/lstack/include/lstack_protocol_stack.h b/src/lstack/include/lstack_protocol_stack.h +index 3c49bd5..1020e83 100644 +--- a/src/lstack/include/lstack_protocol_stack.h ++++ b/src/lstack/include/lstack_protocol_stack.h +@@ -28,6 +28,7 @@ struct protocol_stack { + uint16_t socket_id; + uint16_t cpu_id; + volatile uint16_t conn_num; ++ volatile bool in_replenish; + + // for dispatcher thread + cpu_set_t idle_cpuset; +-- +1.8.3.1 + diff --git a/0007-parse_host_addr-should-be-executed-before-parse_dpdk.patch b/0007-parse_host_addr-should-be-executed-before-parse_dpdk.patch new file mode 100644 index 0000000..f9bf7c7 --- /dev/null +++ b/0007-parse_host_addr-should-be-executed-before-parse_dpdk.patch @@ -0,0 +1,50 @@ +From 6289822ec806dbcc0499378148e1b291d9f992f5 Mon Sep 17 00:00:00 2001 +From: jiangheng +Date: Thu, 10 Mar 2022 21:03:59 +0800 +Subject: [PATCH 07/34] parse_host_addr() should be executed before + parse_dpdk_args() + +--- + src/lstack/core/lstack_cfg.c | 13 +++++++------ + 1 file changed, 7 insertions(+), 6 deletions(-) + +diff --git a/src/lstack/core/lstack_cfg.c b/src/lstack/core/lstack_cfg.c +index 0f899b1..d8eaced 100644 +--- a/src/lstack/core/lstack_cfg.c ++++ b/src/lstack/core/lstack_cfg.c +@@ -63,16 +63,16 @@ struct config_vector_t { + }; + + static struct config_vector_t g_config_tbl[] = { +- { "dpdk_args", parse_dpdk_args }, ++ { "host_addr", parse_host_addr }, ++ { "gateway_addr", parse_gateway_addr }, ++ { "mask_addr", parse_mask_addr }, + { "use_ltran", parse_use_ltran }, ++ { "devices", parse_devices }, ++ { "dpdk_args", parse_dpdk_args }, + { "num_cpus", parse_stack_cpu_number }, + { "num_weakup", parse_weakup_cpu_number }, + { "numa_bind", parse_numa_bind }, + { "low_power_mode", parse_low_power_mode }, +- { "host_addr", parse_host_addr }, +- { "mask_addr", parse_mask_addr }, +- { "devices", parse_devices }, +- { "gateway_addr", parse_gateway_addr }, + { "kni_switch", parse_kni_switch }, + { NULL, NULL } + }; +@@ -302,8 +302,9 @@ static int32_t numa_to_cpusnum(unsigned socket_id, uint32_t *cpulist, int32_t nu + int32_t count = 0; + char *elem = strtok(strbuf, "-"); + while (elem && count < num) { +- while (elem && isspace(*elem)) ++ while (elem && isspace(*elem)) { + elem++; ++ } + cpulist[count++] = (uint32_t)strtol(elem, NULL, 10); // 10 : decimal + + if (count % 2 == 0) // 2 : even +-- +1.8.3.1 + diff --git a/0008-fix-gazellectl-l-option-error.patch b/0008-fix-gazellectl-l-option-error.patch new file mode 100644 index 0000000..85ba72d --- /dev/null +++ b/0008-fix-gazellectl-l-option-error.patch @@ -0,0 +1,56 @@ +From b9914a2ff92b34242eefd9d42bc80a8b0a6307c5 Mon Sep 17 00:00:00 2001 +From: wuchangsheng +Date: Tue, 8 Mar 2022 14:45:59 +0800 +Subject: [PATCH 08/34] fix gazellectl -l option error + +--- + src/ltran/ltran_dfx.c | 16 ++++++++++------ + 1 file changed, 10 insertions(+), 6 deletions(-) + +diff --git a/src/ltran/ltran_dfx.c b/src/ltran/ltran_dfx.c +index 159fbb9..381d30d 100644 +--- a/src/ltran/ltran_dfx.c ++++ b/src/ltran/ltran_dfx.c +@@ -1182,19 +1182,23 @@ static int32_t parse_dfx_cmd_args(int32_t argc, char *argv[], struct gazelle_sta + return num_cmd; + } + +-static int32_t check_cmd_support(enum GAZELLE_STAT_MODE stat_mode) ++static int32_t check_cmd_support(struct gazelle_stat_msg_request *req_msg, int32_t req_msg_num) + { +- switch (stat_mode) { ++ switch (req_msg[0].stat_mode) { + case GAZELLE_STAT_LSTACK_LOG_LEVEL_SET: + case GAZELLE_STAT_LSTACK_SHOW: + case GAZELLE_STAT_LSTACK_SHOW_SNMP: + case GAZELLE_STAT_LSTACK_SHOW_CONN: + case GAZELLE_STAT_LSTACK_SHOW_LATENCY: + case GAZELLE_STAT_LSTACK_LOW_POWER_MDF: +- case GAZELLE_STAT_LTRAN_START_LATENCY: + return 0; + default: +- show_usage(); ++ if (req_msg[0].stat_mode == GAZELLE_STAT_LTRAN_START_LATENCY && ++ req_msg[req_msg_num - 1].stat_mode == GAZELLE_STAT_LSTACK_SHOW_LATENCY) { ++ return 0; ++ } ++ /* keep output consistency */ ++ printf("connect ltran failed. errno: 111 ret=-1\n"); + return -1; + } + +@@ -1220,9 +1224,9 @@ int32_t main(int32_t argc, char *argv[]) + g_gazelle_dfx_tbl[GAZELLE_STAT_LSTACK_SHOW].recv_size = sizeof(struct gazelle_stack_dfx_data); + g_gazelle_dfx_tbl[GAZELLE_STAT_LTRAN_START_LATENCY].recv_size =sizeof(struct gazelle_stack_dfx_data); + g_gazelle_dfx_tbl[GAZELLE_STAT_LTRAN_STOP_LATENCY].recv_size =sizeof(struct gazelle_stack_dfx_data); +- ret = check_cmd_support(req_msg[msg_index].stat_mode); ++ ret = check_cmd_support(req_msg, req_msg_num); + if (ret < 0) { +- return 0; ++ return -1; + } + } + +-- +1.8.3.1 + diff --git a/0009-bind-cpu-fail-just-walrm.patch b/0009-bind-cpu-fail-just-walrm.patch new file mode 100644 index 0000000..4caf3d8 --- /dev/null +++ b/0009-bind-cpu-fail-just-walrm.patch @@ -0,0 +1,24 @@ +From bc1452fc1b981f62f72744954c2679497ac28f77 Mon Sep 17 00:00:00 2001 +From: wuchangsheng +Date: Tue, 8 Mar 2022 20:19:35 +0800 +Subject: [PATCH 09/34] bind cpu fail just walrm + +--- + src/lstack/core/lstack_dpdk.c | 1 - + 1 file changed, 1 deletion(-) + +diff --git a/src/lstack/core/lstack_dpdk.c b/src/lstack/core/lstack_dpdk.c +index 280d643..0544943 100644 +--- a/src/lstack/core/lstack_dpdk.c ++++ b/src/lstack/core/lstack_dpdk.c +@@ -80,7 +80,6 @@ int32_t thread_affinity_init(int32_t cpu_id) + ret = rte_thread_set_affinity(&cpuset); + if (ret != 0) { + LSTACK_LOG(ERR, LSTACK, "thread %d pthread_setaffinity_np failed ret=%d\n", rte_gettid(), ret); +- return -1; + } + + return 0; +-- +1.8.3.1 + diff --git a/0010-mfix-close-not-release-sock.patch b/0010-mfix-close-not-release-sock.patch new file mode 100644 index 0000000..7b7df05 --- /dev/null +++ b/0010-mfix-close-not-release-sock.patch @@ -0,0 +1,38 @@ +From 175ea2338bc5f9f428b1155d3910f40a8a311c25 Mon Sep 17 00:00:00 2001 +From: wuchangsheng +Date: Wed, 9 Mar 2022 17:34:59 +0800 +Subject: [PATCH 10/34] -mfix close not release sock + +--- + src/lstack/core/lstack_lwip.c | 6 +++--- + 1 file changed, 3 insertions(+), 3 deletions(-) + +diff --git a/src/lstack/core/lstack_lwip.c b/src/lstack/core/lstack_lwip.c +index a9ef824..87d99d3 100644 +--- a/src/lstack/core/lstack_lwip.c ++++ b/src/lstack/core/lstack_lwip.c +@@ -127,18 +127,18 @@ void gazelle_init_sock(int32_t fd) + + void gazelle_clean_sock(int32_t fd) + { +- struct lwip_sock *sock = get_socket(fd); ++ struct lwip_sock *sock = get_socket_by_fd(fd); + if (sock == NULL) { + return; + } + ++ sock->stack->conn_num--; ++ + reset_sock_data(sock); + + list_del_node_init(&sock->recv_list); + list_del_node_init(&sock->attach_list); + list_del_node_init(&sock->listen_list); +- +- sock->stack->conn_num--; + } + + void gazelle_free_pbuf(struct pbuf *pbuf) +-- +1.8.3.1 + diff --git a/0011-fix-evetns-err.patch b/0011-fix-evetns-err.patch new file mode 100644 index 0000000..b0ef758 --- /dev/null +++ b/0011-fix-evetns-err.patch @@ -0,0 +1,66 @@ +From 7f3dbd7145d683c22e70d69ec8799a49cb837415 Mon Sep 17 00:00:00 2001 +From: wuchangsheng +Date: Wed, 9 Mar 2022 17:44:50 +0800 +Subject: [PATCH 11/34] fix evetns err + +--- + src/lstack/core/lstack_lwip.c | 36 ++++++++++++++++++++---------------- + 1 file changed, 20 insertions(+), 16 deletions(-) + +diff --git a/src/lstack/core/lstack_lwip.c b/src/lstack/core/lstack_lwip.c +index 87d99d3..3b97bb8 100644 +--- a/src/lstack/core/lstack_lwip.c ++++ b/src/lstack/core/lstack_lwip.c +@@ -317,14 +317,16 @@ ssize_t write_stack_data(struct lwip_sock *sock, const void *buf, size_t len) + send_pkt++; + } + +- if (NETCONN_IS_DATAOUT(sock)) { +- sock->have_event = true; +- sock->events |= EPOLLOUT; +- rte_ring_mp_enqueue(sock->weakup->event_ring, (void *)sock); +- sem_post(&sock->weakup->event_sem); +- sock->stack->stats.write_events++; +- } else { +- sock->have_event = false; ++ if ((sock->epoll_events & EPOLLOUT)) { ++ if (NETCONN_IS_DATAOUT(sock)) { ++ sock->have_event = true; ++ sock->events |= EPOLLOUT; ++ rte_ring_mp_enqueue(sock->weakup->event_ring, (void *)sock); ++ sem_post(&sock->weakup->event_sem); ++ sock->stack->stats.write_events++; ++ } else { ++ sock->have_event = false; ++ } + } + + if (rte_ring_free_count(sock->stack->send_idle_ring) > USED_IDLE_WATERMARK && !sock->stack->in_replenish) { +@@ -518,14 +520,16 @@ ssize_t read_stack_data(int32_t fd, void *buf, size_t len, int32_t flags) + } + } + +- if (NETCONN_IS_DATAIN(sock)) { +- sock->have_event = true; +- sock->events |= EPOLLIN; +- rte_ring_mp_enqueue(sock->weakup->event_ring, (void *)sock); +- sem_post(&sock->weakup->event_sem); +- sock->stack->stats.read_events++; +- } else { +- sock->have_event = false; ++ if ((sock->epoll_events & EPOLLIN)) { ++ if (NETCONN_IS_DATAIN(sock)) { ++ sock->have_event = true; ++ sock->events |= EPOLLIN; ++ rte_ring_mp_enqueue(sock->weakup->event_ring, (void *)sock); ++ sem_post(&sock->weakup->event_sem); ++ sock->stack->stats.read_events++; ++ } else { ++ sock->have_event = false; ++ } + } + + if (recvd == 0) { +-- +1.8.3.1 + diff --git a/0012-fix-dfx-info-show.patch b/0012-fix-dfx-info-show.patch new file mode 100644 index 0000000..9814be6 --- /dev/null +++ b/0012-fix-dfx-info-show.patch @@ -0,0 +1,56 @@ +From 5d5268f64f4bd9b3fcdc2aad3d0d2f24c307351a Mon Sep 17 00:00:00 2001 +From: wuchangsheng +Date: Wed, 9 Mar 2022 19:26:51 +0800 +Subject: [PATCH 12/34] fix dfx info show + +--- + src/lstack/core/lstack_lwip.c | 12 ++++++------ + src/ltran/ltran_dfx.c | 2 +- + 2 files changed, 7 insertions(+), 7 deletions(-) + +diff --git a/src/lstack/core/lstack_lwip.c b/src/lstack/core/lstack_lwip.c +index 3b97bb8..8de032f 100644 +--- a/src/lstack/core/lstack_lwip.c ++++ b/src/lstack/core/lstack_lwip.c +@@ -667,6 +667,12 @@ void get_lwip_conntable(struct rpc_msg *msg) + conn_num++; + } + ++ for (pcb = tcp_tw_pcbs; pcb != NULL && conn_num < max_num; pcb = pcb->next) { ++ conn[conn_num].state = TIME_WAIT_LIST; ++ copy_pcb_to_conn(conn + conn_num, pcb); ++ conn_num++; ++ } ++ + for (struct tcp_pcb_listen *pcbl = tcp_listen_pcbs.listen_pcbs; pcbl != NULL && conn_num < max_num; + pcbl = pcbl->next) { + conn[conn_num].state = LISTEN_LIST; +@@ -680,12 +686,6 @@ void get_lwip_conntable(struct rpc_msg *msg) + conn_num++; + } + +- for (pcb = tcp_tw_pcbs; pcb != NULL && conn_num < max_num; pcb = pcb->next) { +- conn[conn_num].state = TIME_WAIT_LIST; +- copy_pcb_to_conn(conn + conn_num, pcb); +- conn_num++; +- } +- + msg->result = conn_num; + } + +diff --git a/src/ltran/ltran_dfx.c b/src/ltran/ltran_dfx.c +index 381d30d..2a268f7 100644 +--- a/src/ltran/ltran_dfx.c ++++ b/src/ltran/ltran_dfx.c +@@ -879,7 +879,7 @@ static void gazelle_print_lstack_stat_conn(void *buf, const struct gazelle_stat_ + do { + printf("\n------ stack tid: %6u ------\n", stat->tid); + printf("No. Proto recv_cnt recv_ring in_send send_ring Local Address" +- " Foreign Address State\n"); ++ " Foreign Address State\n"); + unread_pkts = 0; + for (i = 0; i < conn->conn_num && i < GAZELLE_LSTACK_MAX_CONN; i++) { + struct gazelle_stat_lstack_conn_info *conn_info = &conn->conn_list[i]; +-- +1.8.3.1 + diff --git a/0013-balance-acept.patch b/0013-balance-acept.patch new file mode 100644 index 0000000..f86b3cd --- /dev/null +++ b/0013-balance-acept.patch @@ -0,0 +1,49 @@ +From 92b990c766e21fc275bd7cd80bbdccc819ac30f8 Mon Sep 17 00:00:00 2001 +From: wuchangsheng +Date: Wed, 9 Mar 2022 20:13:16 +0800 +Subject: [PATCH 13/34] balance acept + +--- + src/lstack/core/lstack_protocol_stack.c | 16 ++++++++++++++-- + 1 file changed, 14 insertions(+), 2 deletions(-) + +diff --git a/src/lstack/core/lstack_protocol_stack.c b/src/lstack/core/lstack_protocol_stack.c +index f96d7a3..badcfd3 100644 +--- a/src/lstack/core/lstack_protocol_stack.c ++++ b/src/lstack/core/lstack_protocol_stack.c +@@ -709,18 +709,30 @@ int32_t stack_broadcast_listen(int32_t fd, int32_t backlog) + /* ergodic the protocol stack thread to find the connection, because all threads are listening */ + int32_t stack_broadcast_accept(int32_t fd, struct sockaddr *addr, socklen_t *addrlen) + { ++ struct lwip_sock *min_sock = NULL; ++ int32_t min_fd; ++ + while (fd > 0) { + struct lwip_sock *sock = get_socket(fd); + if (sock == NULL) { + GAZELLE_RETURN(EINVAL); + } + +- if (NETCONN_IS_ACCEPTIN(sock)) { +- return rpc_call_accept(fd, addr, addrlen); ++ if (!NETCONN_IS_ACCEPTIN(sock)) { ++ continue; ++ } ++ ++ if (min_sock == NULL || min_sock->stack->conn_num > sock->stack->conn_num) { ++ min_sock = sock; ++ min_fd = fd; + } + + fd = sock->nextfd; + } + ++ if (min_sock) { ++ return rpc_call_accept(min_fd, addr, addrlen); ++ } ++ + GAZELLE_RETURN(EAGAIN); + } +-- +1.8.3.1 + diff --git a/0014-fix-miss-evetn.patch b/0014-fix-miss-evetn.patch new file mode 100644 index 0000000..0a60412 --- /dev/null +++ b/0014-fix-miss-evetn.patch @@ -0,0 +1,248 @@ +From 4defcc589cfdd71234c2931ca8bee081ceab491a Mon Sep 17 00:00:00 2001 +From: wuchangsheng +Date: Wed, 9 Mar 2022 21:27:04 +0800 +Subject: [PATCH 14/34] fix miss evetn + +--- + src/common/gazelle_dfx_msg.h | 1 + + src/lstack/api/lstack_epoll.c | 5 --- + src/lstack/core/lstack_lwip.c | 16 ++++++--- + src/lstack/core/lstack_protocol_stack.c | 59 +++++++++++++++++++++++---------- + src/lstack/include/lstack_weakup.h | 26 ++++++++++----- + src/ltran/ltran_dfx.c | 7 ++-- + 6 files changed, 75 insertions(+), 39 deletions(-) + +diff --git a/src/common/gazelle_dfx_msg.h b/src/common/gazelle_dfx_msg.h +index cde2fec..e681424 100644 +--- a/src/common/gazelle_dfx_msg.h ++++ b/src/common/gazelle_dfx_msg.h +@@ -83,6 +83,7 @@ struct gazelle_stat_pkts { + uint64_t call_alloc_fail; + uint64_t read_events; + uint64_t write_events; ++ uint64_t accept_events; + uint64_t read_null; + uint64_t recv_empty; + uint64_t event_null; +diff --git a/src/lstack/api/lstack_epoll.c b/src/lstack/api/lstack_epoll.c +index 99d1eac..b1bb84c 100644 +--- a/src/lstack/api/lstack_epoll.c ++++ b/src/lstack/api/lstack_epoll.c +@@ -43,11 +43,6 @@ enum POLL_TYPE { + + static inline bool report_events(struct lwip_sock *sock, uint32_t event) + { +- /* listen fd event */ +- if (sock->attach_fd > 0) { +- return true; +- } +- + /* error event */ + if ((event & EPOLLERR) || (event & EPOLLHUP) || (event & EPOLLRDHUP)) { + return true; +diff --git a/src/lstack/core/lstack_lwip.c b/src/lstack/core/lstack_lwip.c +index 8de032f..0561678 100644 +--- a/src/lstack/core/lstack_lwip.c ++++ b/src/lstack/core/lstack_lwip.c +@@ -318,14 +318,18 @@ ssize_t write_stack_data(struct lwip_sock *sock, const void *buf, size_t len) + } + + if ((sock->epoll_events & EPOLLOUT)) { ++ /* avoid miss EPOLLOUT event, call NETCONN_IS_DATAOUT twice. ++ write data full and have_event=true, then data out add event failed because of have_event */ ++ if (!NETCONN_IS_DATAOUT(sock)) { ++ sock->have_event = false; ++ } ++ + if (NETCONN_IS_DATAOUT(sock)) { + sock->have_event = true; + sock->events |= EPOLLOUT; + rte_ring_mp_enqueue(sock->weakup->event_ring, (void *)sock); + sem_post(&sock->weakup->event_sem); + sock->stack->stats.write_events++; +- } else { +- sock->have_event = false; + } + } + +@@ -521,14 +525,18 @@ ssize_t read_stack_data(int32_t fd, void *buf, size_t len, int32_t flags) + } + + if ((sock->epoll_events & EPOLLIN)) { ++ /* avoid miss EPOLLIN event, call NETCONN_IS_DATAIN twice. ++ read data empty and have_event=true, then data in add event failed because of have_event */ ++ if (!NETCONN_IS_DATAIN(sock)) { ++ sock->have_event = false; ++ } ++ + if (NETCONN_IS_DATAIN(sock)) { + sock->have_event = true; + sock->events |= EPOLLIN; + rte_ring_mp_enqueue(sock->weakup->event_ring, (void *)sock); + sem_post(&sock->weakup->event_sem); + sock->stack->stats.read_events++; +- } else { +- sock->have_event = false; + } + } + +diff --git a/src/lstack/core/lstack_protocol_stack.c b/src/lstack/core/lstack_protocol_stack.c +index badcfd3..197942f 100644 +--- a/src/lstack/core/lstack_protocol_stack.c ++++ b/src/lstack/core/lstack_protocol_stack.c +@@ -505,6 +505,24 @@ void stack_listen(struct rpc_msg *msg) + } + } + ++static bool have_accept_event(int32_t fd) ++{ ++ do { ++ struct lwip_sock *sock = get_socket(fd); ++ if (sock == NULL) { ++ break; ++ } ++ ++ if (NETCONN_IS_ACCEPTIN(sock)) { ++ return true; ++ } ++ ++ fd = sock->nextfd; ++ } while (fd > 0); ++ ++ return false; ++} ++ + void stack_accept(struct rpc_msg *msg) + { + int32_t fd = msg->args[MSG_ARG_0].i; +@@ -522,21 +540,6 @@ void stack_accept(struct rpc_msg *msg) + LSTACK_LOG(ERR, LSTACK, "tid %ld, fd %d attach_fd %d failed %ld\n", get_stack_tid(), msg->args[MSG_ARG_0].i, + fd, msg->result); + } +- +- /* report remain accept event */ +- do { +- struct lwip_sock *sock = get_socket(fd); +- if (sock == NULL) { +- break; +- } +- +- if ((sock->epoll_events & EPOLLIN) && NETCONN_IS_ACCEPTIN(sock)) { +- add_epoll_event(sock->conn, EPOLLIN); +- break; +- } +- +- fd = sock->nextfd; +- } while (fd > 0); + } + + void stack_connect(struct rpc_msg *msg) +@@ -710,7 +713,9 @@ int32_t stack_broadcast_listen(int32_t fd, int32_t backlog) + int32_t stack_broadcast_accept(int32_t fd, struct sockaddr *addr, socklen_t *addrlen) + { + struct lwip_sock *min_sock = NULL; +- int32_t min_fd; ++ int32_t head_fd = fd; ++ int32_t min_fd = fd; ++ int32_t ret = -1; + + while (fd > 0) { + struct lwip_sock *sock = get_socket(fd); +@@ -731,8 +736,26 @@ int32_t stack_broadcast_accept(int32_t fd, struct sockaddr *addr, socklen_t *add + } + + if (min_sock) { +- return rpc_call_accept(min_fd, addr, addrlen); ++ ret = rpc_call_accept(min_fd, addr, addrlen); ++ } ++ ++ /* avoid miss accept event, call have_accept_event twice. ++ rpc_call_accept empty and have_event=true, then establish connection add event failed because of have_event */ ++ struct lwip_sock *sock = get_socket(head_fd); ++ if (!have_accept_event(head_fd)) { ++ sock->have_event = false; ++ } ++ ++ if (have_accept_event(head_fd)) { ++ sock->have_event = true; ++ sock->events |= EPOLLIN; ++ rte_ring_mp_enqueue(sock->weakup->event_ring, (void *)sock); ++ sem_post(&sock->weakup->event_sem); ++ sock->stack->stats.accept_events++; + } + +- GAZELLE_RETURN(EAGAIN); ++ if(ret < 0) { ++ errno = EAGAIN; ++ } ++ return ret; + } +diff --git a/src/lstack/include/lstack_weakup.h b/src/lstack/include/lstack_weakup.h +index 6f11653..f334a0f 100644 +--- a/src/lstack/include/lstack_weakup.h ++++ b/src/lstack/include/lstack_weakup.h +@@ -49,21 +49,29 @@ static inline __attribute__((always_inline)) void weakup_attach_sock(struct lwip + + static inline __attribute__((always_inline)) void weakup_thread(struct rte_ring *weakup_ring) + { +- uint32_t num; +- struct lwip_sock *sock[WEAKUP_MAX]; ++ struct lwip_sock *sock; + int32_t ret; + +- num = rte_ring_sc_dequeue_burst(weakup_ring, (void **)sock, WEAKUP_MAX, NULL); +- for (uint32_t i = 0; i < num; ++i) { +- ret = rte_ring_mp_enqueue(sock[i]->weakup->event_ring, (void *)sock[i]); ++ for (uint32_t i = 0; i < WEAKUP_MAX; ++i) { ++ ret = rte_ring_sc_dequeue(weakup_ring, (void **)&sock); ++ if (ret != 0) { ++ break; ++ } ++ ++ ret = rte_ring_mp_enqueue(sock->weakup->event_ring, (void *)sock); + if (ret == 0) { +- sem_post(&sock[i]->weakup->event_sem); +- sock[i]->stack->stats.lwip_events++; ++ sem_post(&sock->weakup->event_sem); ++ sock->stack->stats.lwip_events++; + } + + /* listen notice attach sock */ +- if (!list_is_empty(&sock[i]->attach_list)) { +- weakup_attach_sock(sock[i]); ++ if (!list_is_empty(&sock->attach_list)) { ++ weakup_attach_sock(sock); ++ } ++ ++ /* event_ring of attach sock may have idle elem */ ++ if (ret != 0) { ++ break; + } + } + } +diff --git a/src/ltran/ltran_dfx.c b/src/ltran/ltran_dfx.c +index 2a268f7..1f4d88a 100644 +--- a/src/ltran/ltran_dfx.c ++++ b/src/ltran/ltran_dfx.c +@@ -567,14 +567,15 @@ static void show_lstack_stats(struct gazelle_stack_dfx_data *lstack_stat) + printf("weakup_events: %-14"PRIu64" ", lstack_stat->data.pkts.weakup_events); + printf("lwip_events: %-16"PRIu64" ", lstack_stat->data.pkts.lwip_events); + printf("app_events: %-17"PRIu64"\n", lstack_stat->data.pkts.app_events); ++ printf("read_events: %-16"PRIu64" ", lstack_stat->data.pkts.read_events); ++ printf("write_events: %-15"PRIu64" ", lstack_stat->data.pkts.write_events); ++ printf("accept_events: %-14"PRIu64" \n", lstack_stat->data.pkts.accept_events); + printf("call_msg: %-19"PRIu64" ", lstack_stat->data.pkts.call_msg_cnt); + printf("read_null: %-18"PRIu64" ", lstack_stat->data.pkts.read_null); +- printf("read_events: %-16"PRIu64" \n", lstack_stat->data.pkts.read_events); ++ printf("recv_empty: %-17"PRIu64" \n", lstack_stat->data.pkts.recv_empty); + printf("call_alloc_fail: %-12"PRIu64" ", lstack_stat->data.pkts.call_alloc_fail); + printf("event_null: %-17"PRIu64" ", lstack_stat->data.pkts.event_null); + printf("remove_event: %-15"PRIu64" \n", lstack_stat->data.pkts.remove_event); +- printf("recv_empty: %-17"PRIu64" ", lstack_stat->data.pkts.recv_empty); +- printf("write_events: %-15"PRIu64" ", lstack_stat->data.pkts.write_events); + printf("send_self_rpc: %-14"PRIu64" \n", lstack_stat->data.pkts.send_self_rpc); + } + +-- +1.8.3.1 + diff --git a/0015-fix-too-much-evetns.patch b/0015-fix-too-much-evetns.patch new file mode 100644 index 0000000..293b6b3 --- /dev/null +++ b/0015-fix-too-much-evetns.patch @@ -0,0 +1,204 @@ +From a43b1b763b970660caeaf3f3206cd742990c0cd3 Mon Sep 17 00:00:00 2001 +From: wuchangsheng +Date: Wed, 9 Mar 2022 23:05:41 +0800 +Subject: [PATCH 15/34] fix too much evetns + +--- + src/lstack/api/lstack_epoll.c | 50 +++++++++++++++++---------------- + src/lstack/core/lstack_lwip.c | 40 ++++++++------------------ + src/lstack/core/lstack_protocol_stack.c | 8 +----- + src/ltran/ltran_dfx.c | 4 +-- + 4 files changed, 41 insertions(+), 61 deletions(-) + +diff --git a/src/lstack/api/lstack_epoll.c b/src/lstack/api/lstack_epoll.c +index b1bb84c..6c9c582 100644 +--- a/src/lstack/api/lstack_epoll.c ++++ b/src/lstack/api/lstack_epoll.c +@@ -41,6 +41,19 @@ enum POLL_TYPE { + TYPE_EPOLL, + }; + ++static inline bool check_event_vaild(struct lwip_sock *sock, uint32_t event) ++{ ++ if (event == EPOLLIN && !NETCONN_IS_ACCEPTIN(sock) && !NETCONN_IS_DATAIN(sock)) { ++ return false; ++ } ++ ++ if (sock->events == EPOLLOUT && !NETCONN_IS_DATAOUT(sock)) { ++ return false; ++ } ++ ++ return true; ++} ++ + static inline bool report_events(struct lwip_sock *sock, uint32_t event) + { + /* error event */ +@@ -48,7 +61,11 @@ static inline bool report_events(struct lwip_sock *sock, uint32_t event) + return true; + } + +- return false; ++ if (sock->have_event) { ++ return false; ++ } ++ ++ return check_event_vaild(sock, event); + } + + void add_epoll_event(struct netconn *conn, uint32_t event) +@@ -72,7 +89,7 @@ void add_epoll_event(struct netconn *conn, uint32_t event) + + sock->events |= event & sock->epoll_events; + +- if (!sock->have_event || report_events(sock, event)) { ++ if (report_events(sock, event)) { + sock->have_event = true; + weakup_enqueue(sock->stack->weakup_ring, sock); + sock->stack->stats.weakup_events++; +@@ -232,29 +249,16 @@ static inline int32_t save_poll_event(struct pollfd *fds, uint32_t maxevents, st + return event_num; + } + +-static int32_t check_event_vaild(struct epoll_event *events, int32_t event_num, struct lwip_sock *sock, +- struct lwip_sock **sock_list, enum POLL_TYPE etype) ++static bool remove_event(enum POLL_TYPE etype, struct lwip_sock **sock_list, int32_t event_num, struct lwip_sock *sock) + { + /* remove duplicate event */ +- if (etype == TYPE_EPOLL) { +- for (uint32_t i = 0; i < event_num; i++) { +- if (sock_list[i] == sock) { +- return -1; +- } ++ for (uint32_t i = 0; i < event_num && etype == TYPE_EPOLL; i++) { ++ if (sock_list[i] == sock) { ++ return true; + } + } + +- /* non_listen_fd remove no data EPOLLIN event */ +- if (sock->events == EPOLLIN && sock->attach_fd < 0 && !NETCONN_IS_DATAIN(sock)) { +- return -1; +- } +- +- /* remove no send_buff OUT event */ +- if (sock->events == EPOLLOUT && !NETCONN_IS_DATAOUT(sock)) { +- return -1; +- } +- +- return 0; ++ return !check_event_vaild(sock, sock->events); + } + + static int32_t get_lwip_events(struct weakup_poll *weakup, void *out, uint32_t maxevents, enum POLL_TYPE etype) +@@ -280,11 +284,9 @@ static int32_t get_lwip_events(struct weakup_poll *weakup, void *out, uint32_t m + get_protocol_stack_group()->event_null++; + break; + } ++ sock->have_event = false; + +- ret = check_event_vaild(events, event_num, sock, weakup->sock_list, etype); +- if (ret != 0) { +- events_cnt--; +- sock->have_event = false; ++ if (remove_event(etype, weakup->sock_list, event_num, sock)) { + sock->stack->stats.remove_event++; + continue; + } +diff --git a/src/lstack/core/lstack_lwip.c b/src/lstack/core/lstack_lwip.c +index 0561678..4a79f46 100644 +--- a/src/lstack/core/lstack_lwip.c ++++ b/src/lstack/core/lstack_lwip.c +@@ -317,20 +317,12 @@ ssize_t write_stack_data(struct lwip_sock *sock, const void *buf, size_t len) + send_pkt++; + } + +- if ((sock->epoll_events & EPOLLOUT)) { +- /* avoid miss EPOLLOUT event, call NETCONN_IS_DATAOUT twice. +- write data full and have_event=true, then data out add event failed because of have_event */ +- if (!NETCONN_IS_DATAOUT(sock)) { +- sock->have_event = false; +- } +- +- if (NETCONN_IS_DATAOUT(sock)) { +- sock->have_event = true; +- sock->events |= EPOLLOUT; +- rte_ring_mp_enqueue(sock->weakup->event_ring, (void *)sock); +- sem_post(&sock->weakup->event_sem); +- sock->stack->stats.write_events++; +- } ++ if (!sock->have_event && (sock->epoll_events & EPOLLOUT) && NETCONN_IS_DATAOUT(sock)) { ++ sock->have_event = true; ++ sock->events |= EPOLLOUT; ++ rte_ring_mp_enqueue(sock->weakup->event_ring, (void *)sock); ++ sem_post(&sock->weakup->event_sem); ++ sock->stack->stats.write_events++; + } + + if (rte_ring_free_count(sock->stack->send_idle_ring) > USED_IDLE_WATERMARK && !sock->stack->in_replenish) { +@@ -524,20 +516,12 @@ ssize_t read_stack_data(int32_t fd, void *buf, size_t len, int32_t flags) + } + } + +- if ((sock->epoll_events & EPOLLIN)) { +- /* avoid miss EPOLLIN event, call NETCONN_IS_DATAIN twice. +- read data empty and have_event=true, then data in add event failed because of have_event */ +- if (!NETCONN_IS_DATAIN(sock)) { +- sock->have_event = false; +- } +- +- if (NETCONN_IS_DATAIN(sock)) { +- sock->have_event = true; +- sock->events |= EPOLLIN; +- rte_ring_mp_enqueue(sock->weakup->event_ring, (void *)sock); +- sem_post(&sock->weakup->event_sem); +- sock->stack->stats.read_events++; +- } ++ if (!sock->have_event && (sock->epoll_events & EPOLLIN) && NETCONN_IS_DATAIN(sock)) { ++ sock->have_event = true; ++ sock->events |= EPOLLIN; ++ rte_ring_mp_enqueue(sock->weakup->event_ring, (void *)sock); ++ sem_post(&sock->weakup->event_sem); ++ sock->stack->stats.read_events++; + } + + if (recvd == 0) { +diff --git a/src/lstack/core/lstack_protocol_stack.c b/src/lstack/core/lstack_protocol_stack.c +index 197942f..68cc49d 100644 +--- a/src/lstack/core/lstack_protocol_stack.c ++++ b/src/lstack/core/lstack_protocol_stack.c +@@ -739,14 +739,8 @@ int32_t stack_broadcast_accept(int32_t fd, struct sockaddr *addr, socklen_t *add + ret = rpc_call_accept(min_fd, addr, addrlen); + } + +- /* avoid miss accept event, call have_accept_event twice. +- rpc_call_accept empty and have_event=true, then establish connection add event failed because of have_event */ + struct lwip_sock *sock = get_socket(head_fd); +- if (!have_accept_event(head_fd)) { +- sock->have_event = false; +- } +- +- if (have_accept_event(head_fd)) { ++ if (!sock->have_event && have_accept_event(head_fd)) { + sock->have_event = true; + sock->events |= EPOLLIN; + rte_ring_mp_enqueue(sock->weakup->event_ring, (void *)sock); +diff --git a/src/ltran/ltran_dfx.c b/src/ltran/ltran_dfx.c +index 1f4d88a..a552b40 100644 +--- a/src/ltran/ltran_dfx.c ++++ b/src/ltran/ltran_dfx.c +@@ -556,9 +556,9 @@ static void show_lstack_stats(struct gazelle_stack_dfx_data *lstack_stat) + printf("read_lwip: %-18"PRIu64" ", lstack_stat->data.pkts.read_lwip_cnt); + printf("read_lwip_drop: %-13"PRIu64" \n", lstack_stat->data.pkts.read_lwip_drop); + printf("app_write: %-18"PRIu64" ", lstack_stat->data.pkts.app_write_cnt); +- printf("app_write_drop: %-13"PRIu64" ", lstack_stat->data.pkts.app_write_drop); +- printf("app_get_idlefail: %-11"PRIu64" \n", lstack_stat->data.pkts.app_write_idlefail); + printf("write_lwip: %-17"PRIu64" ", lstack_stat->data.pkts.write_lwip_cnt); ++ printf("app_get_idlefail: %-11"PRIu64" \n", lstack_stat->data.pkts.app_write_idlefail); ++ printf("app_write_drop: %-13"PRIu64" ", lstack_stat->data.pkts.app_write_drop); + printf("write_lwip_drop: %-12"PRIu64" ", lstack_stat->data.pkts.write_lwip_drop); + printf("app_write_idlebuf: %-10"PRIu16" \n", lstack_stat->data.pkts.send_idle_ring_cnt); + printf("recv_list: %-18"PRIu64" ", lstack_stat->data.pkts.recv_list); +-- +1.8.3.1 + diff --git a/0016-fix-dead-loop.patch b/0016-fix-dead-loop.patch new file mode 100644 index 0000000..8475e95 --- /dev/null +++ b/0016-fix-dead-loop.patch @@ -0,0 +1,24 @@ +From 5755516a6d49b5fee68169521e974abe276801f1 Mon Sep 17 00:00:00 2001 +From: wuchangsheng +Date: Thu, 10 Mar 2022 10:12:09 +0800 +Subject: [PATCH 16/34] fix dead loop + +--- + src/lstack/core/lstack_protocol_stack.c | 1 + + 1 file changed, 1 insertion(+) + +diff --git a/src/lstack/core/lstack_protocol_stack.c b/src/lstack/core/lstack_protocol_stack.c +index 68cc49d..939543b 100644 +--- a/src/lstack/core/lstack_protocol_stack.c ++++ b/src/lstack/core/lstack_protocol_stack.c +@@ -724,6 +724,7 @@ int32_t stack_broadcast_accept(int32_t fd, struct sockaddr *addr, socklen_t *add + } + + if (!NETCONN_IS_ACCEPTIN(sock)) { ++ fd = sock->nextfd; + continue; + } + +-- +1.8.3.1 + diff --git a/0017-remove-unuse-event.patch b/0017-remove-unuse-event.patch new file mode 100644 index 0000000..7045997 --- /dev/null +++ b/0017-remove-unuse-event.patch @@ -0,0 +1,110 @@ +From 0a2b49d63807e62c5b13418e70e641b3d50ce3f2 Mon Sep 17 00:00:00 2001 +From: wuchangsheng +Date: Thu, 10 Mar 2022 20:19:14 +0800 +Subject: [PATCH 17/34] remove unuse event + +--- + src/lstack/api/lstack_epoll.c | 19 +++++++++++++------ + src/lstack/core/lstack_lwip.c | 9 ++++++++- + src/lstack/core/lstack_thread_rpc.c | 1 - + 3 files changed, 21 insertions(+), 8 deletions(-) + +diff --git a/src/lstack/api/lstack_epoll.c b/src/lstack/api/lstack_epoll.c +index 6c9c582..b12ce58 100644 +--- a/src/lstack/api/lstack_epoll.c ++++ b/src/lstack/api/lstack_epoll.c +@@ -43,15 +43,15 @@ enum POLL_TYPE { + + static inline bool check_event_vaild(struct lwip_sock *sock, uint32_t event) + { +- if (event == EPOLLIN && !NETCONN_IS_ACCEPTIN(sock) && !NETCONN_IS_DATAIN(sock)) { +- return false; ++ if ((event & EPOLLIN) && !NETCONN_IS_ACCEPTIN(sock) && !NETCONN_IS_DATAIN(sock)) { ++ event &= ~EPOLLIN; + } + +- if (sock->events == EPOLLOUT && !NETCONN_IS_DATAOUT(sock)) { +- return false; ++ if ((event & EPOLLOUT) && !NETCONN_IS_DATAOUT(sock)) { ++ event &= ~EPOLLOUT; + } + +- return true; ++ return (event) ? true : false; + } + + static inline bool report_events(struct lwip_sock *sock, uint32_t event) +@@ -251,6 +251,11 @@ static inline int32_t save_poll_event(struct pollfd *fds, uint32_t maxevents, st + + static bool remove_event(enum POLL_TYPE etype, struct lwip_sock **sock_list, int32_t event_num, struct lwip_sock *sock) + { ++ /* close sock */ ++ if (sock->stack == NULL) { ++ return true; ++ } ++ + /* remove duplicate event */ + for (uint32_t i = 0; i < event_num && etype == TYPE_EPOLL; i++) { + if (sock_list[i] == sock) { +@@ -287,7 +292,9 @@ static int32_t get_lwip_events(struct weakup_poll *weakup, void *out, uint32_t m + sock->have_event = false; + + if (remove_event(etype, weakup->sock_list, event_num, sock)) { +- sock->stack->stats.remove_event++; ++ if (sock->stack) { ++ sock->stack->stats.remove_event++; ++ } + continue; + } + +diff --git a/src/lstack/core/lstack_lwip.c b/src/lstack/core/lstack_lwip.c +index 4a79f46..fd334fb 100644 +--- a/src/lstack/core/lstack_lwip.c ++++ b/src/lstack/core/lstack_lwip.c +@@ -128,7 +128,7 @@ void gazelle_init_sock(int32_t fd) + void gazelle_clean_sock(int32_t fd) + { + struct lwip_sock *sock = get_socket_by_fd(fd); +- if (sock == NULL) { ++ if (sock == NULL || sock->stack == NULL) { + return; + } + +@@ -324,8 +324,12 @@ ssize_t write_stack_data(struct lwip_sock *sock, const void *buf, size_t len) + sem_post(&sock->weakup->event_sem); + sock->stack->stats.write_events++; + } ++ if (!NETCONN_IS_DATAOUT(sock)) { ++ sock->events &= ~EPOLLOUT; ++ } + + if (rte_ring_free_count(sock->stack->send_idle_ring) > USED_IDLE_WATERMARK && !sock->stack->in_replenish) { ++ stack->in_replenish = true; + rpc_call_replenish_idlembuf(sock->stack); + } + +@@ -523,6 +527,9 @@ ssize_t read_stack_data(int32_t fd, void *buf, size_t len, int32_t flags) + sem_post(&sock->weakup->event_sem); + sock->stack->stats.read_events++; + } ++ if (!NETCONN_IS_DATAIN(sock)) { ++ sock->events &= ~EPOLLIN; ++ } + + if (recvd == 0) { + sock->stack->stats.read_null++; +diff --git a/src/lstack/core/lstack_thread_rpc.c b/src/lstack/core/lstack_thread_rpc.c +index 8b3d36c..af5fad3 100644 +--- a/src/lstack/core/lstack_thread_rpc.c ++++ b/src/lstack/core/lstack_thread_rpc.c +@@ -199,7 +199,6 @@ static void rpc_replenish_idlembuf(struct rpc_msg *msg) + + void rpc_call_replenish_idlembuf(struct protocol_stack *stack) + { +- stack->in_replenish = 1; + struct rpc_msg *msg = rpc_msg_alloc(stack->rpc_pool, rpc_replenish_idlembuf); + if (msg == NULL) { + return; +-- +1.8.3.1 + diff --git a/0018-fix-gazellectl-show.patch b/0018-fix-gazellectl-show.patch new file mode 100644 index 0000000..180b83a --- /dev/null +++ b/0018-fix-gazellectl-show.patch @@ -0,0 +1,45 @@ +From e531579c08a56b2a53ea605a7bbba70bedfbae45 Mon Sep 17 00:00:00 2001 +From: jiangheng +Date: Fri, 11 Mar 2022 10:53:28 +0800 +Subject: [PATCH 18/34] fix gazellectl show + +--- + src/lstack/core/lstack_lwip.c | 2 +- + src/ltran/ltran_dfx.c | 2 +- + 2 files changed, 2 insertions(+), 2 deletions(-) + +diff --git a/src/lstack/core/lstack_lwip.c b/src/lstack/core/lstack_lwip.c +index fd334fb..90ddecc 100644 +--- a/src/lstack/core/lstack_lwip.c ++++ b/src/lstack/core/lstack_lwip.c +@@ -329,7 +329,7 @@ ssize_t write_stack_data(struct lwip_sock *sock, const void *buf, size_t len) + } + + if (rte_ring_free_count(sock->stack->send_idle_ring) > USED_IDLE_WATERMARK && !sock->stack->in_replenish) { +- stack->in_replenish = true; ++ sock->stack->in_replenish = true; + rpc_call_replenish_idlembuf(sock->stack); + } + +diff --git a/src/ltran/ltran_dfx.c b/src/ltran/ltran_dfx.c +index a552b40..a01d91f 100644 +--- a/src/ltran/ltran_dfx.c ++++ b/src/ltran/ltran_dfx.c +@@ -1214,13 +1214,13 @@ int32_t main(int32_t argc, char *argv[]) + struct gazelle_dfx_list *dfx = NULL; + char recv_buf[GAZELLE_CMD_RESP_BUFFER_SIZE + 1] = {0}; + ++ g_use_ltran = ltran_process_exist() ? true : false; + req_msg_num = parse_dfx_cmd_args(argc, argv, req_msg); + if (req_msg_num <= 0 || req_msg_num > GAZELLE_CMD_MAX) { + show_usage(); + return 0; + } + +- g_use_ltran = ltran_process_exist() ? true : false; + if (!g_use_ltran) { + g_gazelle_dfx_tbl[GAZELLE_STAT_LSTACK_SHOW].recv_size = sizeof(struct gazelle_stack_dfx_data); + g_gazelle_dfx_tbl[GAZELLE_STAT_LTRAN_START_LATENCY].recv_size =sizeof(struct gazelle_stack_dfx_data); +-- +1.8.3.1 + diff --git a/0019-fix-repeate-msg.patch b/0019-fix-repeate-msg.patch new file mode 100644 index 0000000..24dff80 --- /dev/null +++ b/0019-fix-repeate-msg.patch @@ -0,0 +1,423 @@ +From 18a911bfd87c4b558740a586728e2bbec9813a6f Mon Sep 17 00:00:00 2001 +From: wuchangsheng +Date: Fri, 11 Mar 2022 16:21:43 +0800 +Subject: [PATCH 19/34] fix repeate msg + +--- + src/common/gazelle_dfx_msg.h | 1 + + src/lstack/core/lstack_dpdk.c | 2 +- + src/lstack/core/lstack_lwip.c | 25 ++++--------- + src/lstack/core/lstack_protocol_stack.c | 2 +- + src/lstack/core/lstack_thread_rpc.c | 63 ++++++++++++++++++--------------- + src/lstack/include/lstack_thread_rpc.h | 3 +- + src/ltran/ltran_dfx.c | 3 +- + 7 files changed, 46 insertions(+), 53 deletions(-) + +diff --git a/src/common/gazelle_dfx_msg.h b/src/common/gazelle_dfx_msg.h +index e681424..41cbefa 100644 +--- a/src/common/gazelle_dfx_msg.h ++++ b/src/common/gazelle_dfx_msg.h +@@ -89,6 +89,7 @@ struct gazelle_stat_pkts { + uint64_t event_null; + uint64_t remove_event; + uint64_t send_self_rpc; ++ uint64_t call_null; + }; + + /* same as define in lwip/stats.h - struct stats_mib2 */ +diff --git a/src/lstack/core/lstack_dpdk.c b/src/lstack/core/lstack_dpdk.c +index 0544943..b8320db 100644 +--- a/src/lstack/core/lstack_dpdk.c ++++ b/src/lstack/core/lstack_dpdk.c +@@ -133,7 +133,7 @@ static struct rte_mempool *create_rpc_mempool(const char *name, uint16_t queue_i + if (ret < 0) { + return NULL; + } +- pool = rte_mempool_create(pool_name, CALL_POOL_SZ, sizeof(struct rpc_msg), CALL_CACHE_SZ, 0, NULL, NULL, NULL, ++ pool = rte_mempool_create(pool_name, CALL_POOL_SZ, sizeof(struct rpc_msg), 0, 0, NULL, NULL, NULL, + NULL, rte_socket_id(), 0); + if (pool == NULL) { + LSTACK_LOG(ERR, LSTACK, "cannot create %s pool rte_err=%d\n", pool_name, rte_errno); +diff --git a/src/lstack/core/lstack_lwip.c b/src/lstack/core/lstack_lwip.c +index 90ddecc..1fc8446 100644 +--- a/src/lstack/core/lstack_lwip.c ++++ b/src/lstack/core/lstack_lwip.c +@@ -26,6 +26,7 @@ + #include "lstack_protocol_stack.h" + #include "lstack_log.h" + #include "lstack_weakup.h" ++#include "lstack_dpdk.h" + #include "lstack_stack_stat.h" + #include "lstack_lwip.h" + +@@ -82,9 +83,9 @@ static void reset_sock_data(struct lwip_sock *sock) + } + } + +- + void gazelle_init_sock(int32_t fd) + { ++ static uint32_t name_tick = 0; + struct lwip_sock *sock = get_socket(fd); + if (sock == NULL) { + return; +@@ -92,29 +93,15 @@ void gazelle_init_sock(int32_t fd) + + reset_sock_data(sock); + +- int32_t ret; +- char name[RTE_RING_NAMESIZE] = {0}; +- static uint32_t name_tick = 0; +- +- ret = snprintf_s(name, sizeof(name), RTE_RING_NAMESIZE - 1, "%s_%d", "sock_recv", name_tick++); +- if (ret < 0) { +- LSTACK_LOG(ERR, LSTACK, "%s create failed.\n", name); +- return; +- } +- sock->recv_ring = rte_ring_create(name, SOCK_RECV_RING_SIZE, rte_socket_id(), RING_F_SP_ENQ | RING_F_SC_DEQ); ++ sock->recv_ring = create_ring("sock_recv", SOCK_RECV_RING_SIZE, 0, name_tick++); + if (sock->recv_ring == NULL) { +- LSTACK_LOG(ERR, LSTACK, "%s create failed. errno: %d.\n", name, rte_errno); ++ LSTACK_LOG(ERR, LSTACK, "sock_recv create failed. errno: %d.\n", rte_errno); + return; + } + +- ret = snprintf_s(name, sizeof(name), RTE_RING_NAMESIZE - 1, "%s_%d", "sock_send", name_tick++); +- if (ret < 0) { +- LSTACK_LOG(ERR, LSTACK, "%s create failed. errno: %d.\n", name, rte_errno); +- return; +- } +- sock->send_ring = rte_ring_create(name, SOCK_SEND_RING_SIZE, rte_socket_id(), RING_F_SP_ENQ | RING_F_SC_DEQ); ++ sock->send_ring = create_ring("sock_send", SOCK_SEND_RING_SIZE, 0, name_tick++); + if (sock->send_ring == NULL) { +- LSTACK_LOG(ERR, LSTACK, "%s create failed. errno: %d.\n", name, rte_errno); ++ LSTACK_LOG(ERR, LSTACK, "sock_send create failed. errno: %d.\n", rte_errno); + return; + } + +diff --git a/src/lstack/core/lstack_protocol_stack.c b/src/lstack/core/lstack_protocol_stack.c +index 939543b..db8a20a 100644 +--- a/src/lstack/core/lstack_protocol_stack.c ++++ b/src/lstack/core/lstack_protocol_stack.c +@@ -318,7 +318,7 @@ static void* gazelle_stack_thread(void *arg) + stack_thread_init(stack); + + for (;;) { +- poll_rpc_msg(&stack->rpc_queue, stack->rpc_pool); ++ poll_rpc_msg(stack); + + eth_dev_poll(); + +diff --git a/src/lstack/core/lstack_thread_rpc.c b/src/lstack/core/lstack_thread_rpc.c +index af5fad3..b4d57d3 100644 +--- a/src/lstack/core/lstack_thread_rpc.c ++++ b/src/lstack/core/lstack_thread_rpc.c +@@ -24,12 +24,12 @@ + #define HANDLE_RPC_MSG_MAX (8) + + static inline __attribute__((always_inline)) +-struct rpc_msg *rpc_msg_alloc(struct rte_mempool *pool, rpc_msg_func func) ++struct rpc_msg *rpc_msg_alloc(struct protocol_stack *stack, rpc_msg_func func) + { + int32_t ret; + struct rpc_msg *msg = NULL; + +- ret = rte_mempool_get(pool, (void **)&msg); ++ ret = rte_mempool_get(stack->rpc_pool, (void **)&msg); + if (ret < 0) { + get_protocol_stack_group()->call_alloc_fail++; + return NULL; +@@ -46,6 +46,9 @@ static inline __attribute__((always_inline)) + void rpc_msg_free(struct rte_mempool *pool, struct rpc_msg *msg) + { + pthread_spin_destroy(&msg->lock); ++ ++ msg->self_release = 0; ++ msg->func = NULL; + rte_mempool_put(pool, (void *)msg); + } + +@@ -71,7 +74,7 @@ int32_t rpc_sync_call(lockless_queue *queue, struct rte_mempool *pool, struct rp + return ret; + } + +-void poll_rpc_msg(lockless_queue *rpc_queue, struct rte_mempool *rpc_pool) ++void poll_rpc_msg(struct protocol_stack *stack) + { + int32_t num; + struct rpc_msg *msg = NULL; +@@ -79,7 +82,7 @@ void poll_rpc_msg(lockless_queue *rpc_queue, struct rte_mempool *rpc_pool) + num = 0; + lockless_queue_node *first_node = NULL; + while (num++ < HANDLE_RPC_MSG_MAX) { +- lockless_queue_node *node = lockless_queue_mpsc_pop(rpc_queue); ++ lockless_queue_node *node = lockless_queue_mpsc_pop(&stack->rpc_queue); + if (node == NULL) { + return; + } +@@ -91,6 +94,8 @@ void poll_rpc_msg(lockless_queue *rpc_queue, struct rte_mempool *rpc_pool) + + if (msg->func) { + msg->func(msg); ++ } else { ++ stack->stats.call_null++; + } + + rte_mb(); +@@ -98,7 +103,7 @@ void poll_rpc_msg(lockless_queue *rpc_queue, struct rte_mempool *rpc_pool) + if (msg->self_release) { + pthread_spin_unlock(&msg->lock); + } else { +- rpc_msg_free(rpc_pool, msg); ++ rpc_msg_free(stack->rpc_pool, msg); + } + + if (first_node == node) { +@@ -109,7 +114,7 @@ void poll_rpc_msg(lockless_queue *rpc_queue, struct rte_mempool *rpc_pool) + + int32_t rpc_call_conntable(struct protocol_stack *stack, void *conn_table, uint32_t max_conn) + { +- struct rpc_msg *msg = rpc_msg_alloc(stack->rpc_pool, get_lwip_conntable); ++ struct rpc_msg *msg = rpc_msg_alloc(stack, get_lwip_conntable); + if (msg == NULL) { + return -1; + } +@@ -122,7 +127,7 @@ int32_t rpc_call_conntable(struct protocol_stack *stack, void *conn_table, uint3 + + int32_t rpc_call_connnum(struct protocol_stack *stack) + { +- struct rpc_msg *msg = rpc_msg_alloc(stack->rpc_pool, get_lwip_connnum); ++ struct rpc_msg *msg = rpc_msg_alloc(stack, get_lwip_connnum); + if (msg == NULL) { + return -1; + } +@@ -132,7 +137,7 @@ int32_t rpc_call_connnum(struct protocol_stack *stack) + + int32_t rpc_call_shadow_fd(struct protocol_stack *stack, int32_t fd, const struct sockaddr *addr, socklen_t addrlen) + { +- struct rpc_msg *msg = rpc_msg_alloc(stack->rpc_pool, create_shadow_fd); ++ struct rpc_msg *msg = rpc_msg_alloc(stack, create_shadow_fd); + if (msg == NULL) { + return -1; + } +@@ -152,7 +157,7 @@ static void rpc_msgcnt(struct rpc_msg *msg) + + int32_t rpc_call_msgcnt(struct protocol_stack *stack) + { +- struct rpc_msg *msg = rpc_msg_alloc(stack->rpc_pool, rpc_msgcnt); ++ struct rpc_msg *msg = rpc_msg_alloc(stack, rpc_msgcnt); + if (msg == NULL) { + return -1; + } +@@ -162,7 +167,7 @@ int32_t rpc_call_msgcnt(struct protocol_stack *stack) + + int32_t rpc_call_thread_regphase1(struct protocol_stack *stack, void *conn) + { +- struct rpc_msg *msg = rpc_msg_alloc(stack->rpc_pool, thread_register_phase1); ++ struct rpc_msg *msg = rpc_msg_alloc(stack, thread_register_phase1); + if (msg == NULL) { + return -1; + } +@@ -172,7 +177,7 @@ int32_t rpc_call_thread_regphase1(struct protocol_stack *stack, void *conn) + + int32_t rpc_call_thread_regphase2(struct protocol_stack *stack, void *conn) + { +- struct rpc_msg *msg = rpc_msg_alloc(stack->rpc_pool, thread_register_phase2); ++ struct rpc_msg *msg = rpc_msg_alloc(stack, thread_register_phase2); + if (msg == NULL) { + return -1; + } +@@ -182,7 +187,7 @@ int32_t rpc_call_thread_regphase2(struct protocol_stack *stack, void *conn) + + int32_t rpc_call_recvlistcnt(struct protocol_stack *stack) + { +- struct rpc_msg *msg = rpc_msg_alloc(stack->rpc_pool, stack_recvlist_count); ++ struct rpc_msg *msg = rpc_msg_alloc(stack, stack_recvlist_count); + if (msg == NULL) { + return -1; + } +@@ -199,7 +204,7 @@ static void rpc_replenish_idlembuf(struct rpc_msg *msg) + + void rpc_call_replenish_idlembuf(struct protocol_stack *stack) + { +- struct rpc_msg *msg = rpc_msg_alloc(stack->rpc_pool, rpc_replenish_idlembuf); ++ struct rpc_msg *msg = rpc_msg_alloc(stack, rpc_replenish_idlembuf); + if (msg == NULL) { + return; + } +@@ -210,7 +215,7 @@ void rpc_call_replenish_idlembuf(struct protocol_stack *stack) + + int32_t rpc_call_arp(struct protocol_stack *stack, struct rte_mbuf *mbuf) + { +- struct rpc_msg *msg = rpc_msg_alloc(stack->rpc_pool, stack_arp); ++ struct rpc_msg *msg = rpc_msg_alloc(stack, stack_arp); + if (msg == NULL) { + return -1; + } +@@ -225,7 +230,7 @@ int32_t rpc_call_arp(struct protocol_stack *stack, struct rte_mbuf *mbuf) + int32_t rpc_call_socket(int32_t domain, int32_t type, int32_t protocol) + { + struct protocol_stack *stack = get_minconn_protocol_stack(); +- struct rpc_msg *msg = rpc_msg_alloc(stack->rpc_pool, stack_socket); ++ struct rpc_msg *msg = rpc_msg_alloc(stack, stack_socket); + if (msg == NULL) { + return -1; + } +@@ -240,7 +245,7 @@ int32_t rpc_call_socket(int32_t domain, int32_t type, int32_t protocol) + int32_t rpc_call_close(int fd) + { + struct protocol_stack *stack = get_protocol_stack_by_fd(fd); +- struct rpc_msg *msg = rpc_msg_alloc(stack->rpc_pool, stack_close); ++ struct rpc_msg *msg = rpc_msg_alloc(stack, stack_close); + if (msg == NULL) { + return -1; + } +@@ -253,7 +258,7 @@ int32_t rpc_call_close(int fd) + int32_t rpc_call_bind(int32_t fd, const struct sockaddr *addr, socklen_t addrlen) + { + struct protocol_stack *stack = get_protocol_stack_by_fd(fd); +- struct rpc_msg *msg = rpc_msg_alloc(stack->rpc_pool, stack_bind); ++ struct rpc_msg *msg = rpc_msg_alloc(stack, stack_bind); + if (msg == NULL) { + return -1; + } +@@ -268,7 +273,7 @@ int32_t rpc_call_bind(int32_t fd, const struct sockaddr *addr, socklen_t addrlen + int32_t rpc_call_listen(int s, int backlog) + { + struct protocol_stack *stack = get_protocol_stack_by_fd(s); +- struct rpc_msg *msg = rpc_msg_alloc(stack->rpc_pool, stack_listen); ++ struct rpc_msg *msg = rpc_msg_alloc(stack, stack_listen); + if (msg == NULL) { + return -1; + } +@@ -282,7 +287,7 @@ int32_t rpc_call_listen(int s, int backlog) + int32_t rpc_call_accept(int fd, struct sockaddr *addr, socklen_t *addrlen) + { + struct protocol_stack *stack = get_protocol_stack_by_fd(fd); +- struct rpc_msg *msg = rpc_msg_alloc(stack->rpc_pool, stack_accept); ++ struct rpc_msg *msg = rpc_msg_alloc(stack, stack_accept); + if (msg == NULL) { + return -1; + } +@@ -297,7 +302,7 @@ int32_t rpc_call_accept(int fd, struct sockaddr *addr, socklen_t *addrlen) + int32_t rpc_call_connect(int fd, const struct sockaddr *addr, socklen_t addrlen) + { + struct protocol_stack *stack = get_protocol_stack_by_fd(fd); +- struct rpc_msg *msg = rpc_msg_alloc(stack->rpc_pool, stack_connect); ++ struct rpc_msg *msg = rpc_msg_alloc(stack, stack_connect); + if (msg == NULL) { + return -1; + } +@@ -312,7 +317,7 @@ int32_t rpc_call_connect(int fd, const struct sockaddr *addr, socklen_t addrlen) + int32_t rpc_call_getpeername(int fd, struct sockaddr *addr, socklen_t *addrlen) + { + struct protocol_stack *stack = get_protocol_stack_by_fd(fd); +- struct rpc_msg *msg = rpc_msg_alloc(stack->rpc_pool, stack_getpeername); ++ struct rpc_msg *msg = rpc_msg_alloc(stack, stack_getpeername); + if (msg == NULL) { + return -1; + } +@@ -327,7 +332,7 @@ int32_t rpc_call_getpeername(int fd, struct sockaddr *addr, socklen_t *addrlen) + int32_t rpc_call_getsockname(int fd, struct sockaddr *addr, socklen_t *addrlen) + { + struct protocol_stack *stack = get_protocol_stack_by_fd(fd); +- struct rpc_msg *msg = rpc_msg_alloc(stack->rpc_pool, stack_getsockname); ++ struct rpc_msg *msg = rpc_msg_alloc(stack, stack_getsockname); + if (msg == NULL) { + return -1; + } +@@ -342,7 +347,7 @@ int32_t rpc_call_getsockname(int fd, struct sockaddr *addr, socklen_t *addrlen) + int32_t rpc_call_getsockopt(int fd, int level, int optname, void *optval, socklen_t *optlen) + { + struct protocol_stack *stack = get_protocol_stack_by_fd(fd); +- struct rpc_msg *msg = rpc_msg_alloc(stack->rpc_pool, stack_getsockopt); ++ struct rpc_msg *msg = rpc_msg_alloc(stack, stack_getsockopt); + if (msg == NULL) { + return -1; + } +@@ -359,7 +364,7 @@ int32_t rpc_call_getsockopt(int fd, int level, int optname, void *optval, sockle + int32_t rpc_call_setsockopt(int fd, int level, int optname, const void *optval, socklen_t optlen) + { + struct protocol_stack *stack = get_protocol_stack_by_fd(fd); +- struct rpc_msg *msg = rpc_msg_alloc(stack->rpc_pool, stack_setsockopt); ++ struct rpc_msg *msg = rpc_msg_alloc(stack, stack_setsockopt); + if (msg == NULL) { + return -1; + } +@@ -376,7 +381,7 @@ int32_t rpc_call_setsockopt(int fd, int level, int optname, const void *optval, + int32_t rpc_call_fcntl(int fd, int cmd, long val) + { + struct protocol_stack *stack = get_protocol_stack_by_fd(fd); +- struct rpc_msg *msg = rpc_msg_alloc(stack->rpc_pool, stack_fcntl); ++ struct rpc_msg *msg = rpc_msg_alloc(stack, stack_fcntl); + if (msg == NULL) { + return -1; + } +@@ -391,7 +396,7 @@ int32_t rpc_call_fcntl(int fd, int cmd, long val) + int32_t rpc_call_ioctl(int fd, long cmd, void *argp) + { + struct protocol_stack *stack = get_protocol_stack_by_fd(fd); +- struct rpc_msg *msg = rpc_msg_alloc(stack->rpc_pool, stack_ioctl); ++ struct rpc_msg *msg = rpc_msg_alloc(stack, stack_ioctl); + if (msg == NULL) { + return -1; + } +@@ -437,7 +442,7 @@ static void stack_send(struct rpc_msg *msg) + ssize_t rpc_call_send(int fd, const void *buf, size_t len, int flags) + { + struct protocol_stack *stack = get_protocol_stack_by_fd(fd); +- struct rpc_msg *msg = rpc_msg_alloc(stack->rpc_pool, stack_send); ++ struct rpc_msg *msg = rpc_msg_alloc(stack, stack_send); + if (msg == NULL) { + return -1; + } +@@ -454,7 +459,7 @@ ssize_t rpc_call_send(int fd, const void *buf, size_t len, int flags) + int32_t rpc_call_sendmsg(int fd, const struct msghdr *msghdr, int flags) + { + struct protocol_stack *stack = get_protocol_stack_by_fd(fd); +- struct rpc_msg *msg = rpc_msg_alloc(stack->rpc_pool, stack_sendmsg); ++ struct rpc_msg *msg = rpc_msg_alloc(stack, stack_sendmsg); + if (msg == NULL) { + return -1; + } +@@ -469,7 +474,7 @@ int32_t rpc_call_sendmsg(int fd, const struct msghdr *msghdr, int flags) + int32_t rpc_call_recvmsg(int fd, struct msghdr *msghdr, int flags) + { + struct protocol_stack *stack = get_protocol_stack_by_fd(fd); +- struct rpc_msg *msg = rpc_msg_alloc(stack->rpc_pool, stack_recvmsg); ++ struct rpc_msg *msg = rpc_msg_alloc(stack, stack_recvmsg); + if (msg == NULL) { + return -1; + } +diff --git a/src/lstack/include/lstack_thread_rpc.h b/src/lstack/include/lstack_thread_rpc.h +index 8a05d6c..1365234 100644 +--- a/src/lstack/include/lstack_thread_rpc.h ++++ b/src/lstack/include/lstack_thread_rpc.h +@@ -47,9 +47,8 @@ struct rpc_msg { + union rpc_msg_arg args[RPM_MSG_ARG_SIZE]; /* resolve by type */ + }; + +-void poll_rpc_msg(lockless_queue *rpc_queue, struct rte_mempool *rpc_pool); +- + struct protocol_stack; ++void poll_rpc_msg(struct protocol_stack *stack); + void rpc_call_replenish_idlembuf(struct protocol_stack *stack); + int32_t rpc_call_msgcnt(struct protocol_stack *stack); + int32_t rpc_call_shadow_fd(struct protocol_stack *stack, int32_t fd, const struct sockaddr *addr, socklen_t addrlen); +diff --git a/src/ltran/ltran_dfx.c b/src/ltran/ltran_dfx.c +index a01d91f..4b46ac9 100644 +--- a/src/ltran/ltran_dfx.c ++++ b/src/ltran/ltran_dfx.c +@@ -576,7 +576,8 @@ static void show_lstack_stats(struct gazelle_stack_dfx_data *lstack_stat) + printf("call_alloc_fail: %-12"PRIu64" ", lstack_stat->data.pkts.call_alloc_fail); + printf("event_null: %-17"PRIu64" ", lstack_stat->data.pkts.event_null); + printf("remove_event: %-15"PRIu64" \n", lstack_stat->data.pkts.remove_event); +- printf("send_self_rpc: %-14"PRIu64" \n", lstack_stat->data.pkts.send_self_rpc); ++ printf("send_self_rpc: %-14"PRIu64" ", lstack_stat->data.pkts.send_self_rpc); ++ printf("call_null: %-18"PRIu64" \n", lstack_stat->data.pkts.call_null); + } + + static void gazelle_print_lstack_stat_detail(struct gazelle_stack_dfx_data *lstack_stat, +-- +1.8.3.1 + diff --git a/0020-fix-wakeup-typos.patch b/0020-fix-wakeup-typos.patch new file mode 100644 index 0000000..d7bf865 --- /dev/null +++ b/0020-fix-wakeup-typos.patch @@ -0,0 +1,103 @@ +From e9294baffd16b59f481d787332f11c657d85473a Mon Sep 17 00:00:00 2001 +From: jiangheng +Date: Wed, 16 Mar 2022 14:34:43 +0800 +Subject: [PATCH 20/34] fix wakeup typos + +--- + src/lstack/core/lstack_cfg.c | 19 ++++++++++++------- + src/lstack/include/lstack_cfg.h | 2 +- + src/lstack/lstack.conf | 2 +- + 3 files changed, 14 insertions(+), 9 deletions(-) + +diff --git a/src/lstack/core/lstack_cfg.c b/src/lstack/core/lstack_cfg.c +index d8eaced..e5a92ca 100644 +--- a/src/lstack/core/lstack_cfg.c ++++ b/src/lstack/core/lstack_cfg.c +@@ -70,7 +70,7 @@ static struct config_vector_t g_config_tbl[] = { + { "devices", parse_devices }, + { "dpdk_args", parse_dpdk_args }, + { "num_cpus", parse_stack_cpu_number }, +- { "num_weakup", parse_weakup_cpu_number }, ++ { "num_wakeup", parse_weakup_cpu_number }, + { "numa_bind", parse_numa_bind }, + { "low_power_mode", parse_low_power_mode }, + { "kni_switch", parse_kni_switch }, +@@ -305,12 +305,17 @@ static int32_t numa_to_cpusnum(unsigned socket_id, uint32_t *cpulist, int32_t nu + while (elem && isspace(*elem)) { + elem++; + } ++ if (elem == NULL) { ++ LSTACK_LOG(ERR, LSTACK, "parse %s failed\n", path); ++ return -1; ++ } + cpulist[count++] = (uint32_t)strtol(elem, NULL, 10); // 10 : decimal + +- if (count % 2 == 0) // 2 : even ++ if (count % 2 == 0) { // 2 : even + elem = strtok(NULL, "-"); +- else ++ } else { + elem = strtok(NULL, ","); ++ } + } + + return count; +@@ -353,7 +358,7 @@ int32_t init_stack_numa_cpuset(void) + for (int32_t idx = 0; idx < cfg->num_cpu; ++idx) { + CPU_SET(cfg->cpus[idx], &stack_cpuset); + } +- for (int32_t idx = 0; idx < cfg->num_weakup; ++idx) { ++ for (int32_t idx = 0; idx < cfg->num_wakeup; ++idx) { + CPU_SET(cfg->weakup[idx], &stack_cpuset); + } + +@@ -691,9 +696,9 @@ static int32_t parse_weakup_cpu_number(void) + + int32_t ret; + +- g_config_params.num_weakup = 0; ++ g_config_params.num_wakeup = 0; + +- cfg_args = config_lookup(&g_config, "num_weakup"); ++ cfg_args = config_lookup(&g_config, "num_wakeup"); + if (cfg_args == NULL) { + return 0; + } +@@ -707,7 +712,7 @@ static int32_t parse_weakup_cpu_number(void) + if (ret <= 0) { + return -EINVAL; + } +- g_config_params.num_weakup = (uint16_t)ret; ++ g_config_params.num_wakeup = (uint16_t)ret; + + return 0; + } +diff --git a/src/lstack/include/lstack_cfg.h b/src/lstack/include/lstack_cfg.h +index a8f5ea0..9096797 100644 +--- a/src/lstack/include/lstack_cfg.h ++++ b/src/lstack/include/lstack_cfg.h +@@ -66,7 +66,7 @@ struct cfg_params { + uint8_t numa_bind; + uint16_t num_cpu; + uint16_t cpus[CFG_MAX_CPUS]; +- uint16_t num_weakup; ++ uint16_t num_wakeup; + uint16_t weakup[CFG_MAX_CPUS]; + uint8_t num_ports; + uint16_t ports[CFG_MAX_PORTS]; +diff --git a/src/lstack/lstack.conf b/src/lstack/lstack.conf +index 0f46e77..eb996f1 100644 +--- a/src/lstack/lstack.conf ++++ b/src/lstack/lstack.conf +@@ -16,7 +16,7 @@ kni_switch=0 + low_power_mode=0 + + num_cpus="2" +-num_weakup="3" ++num_wakeup="3" + + numa_bind=1 + +-- +1.8.3.1 + diff --git a/0021-fix-pasre-numacpulist.patch b/0021-fix-pasre-numacpulist.patch new file mode 100644 index 0000000..cd8b469 --- /dev/null +++ b/0021-fix-pasre-numacpulist.patch @@ -0,0 +1,50 @@ +From ce951a907f5634e8502d28fb66ae79a3a3c82689 Mon Sep 17 00:00:00 2001 +From: wuchangsheng +Date: Fri, 11 Mar 2022 21:19:19 +0800 +Subject: [PATCH 21/34] fix pasre numacpulist + +--- + src/lstack/core/lstack_cfg.c | 19 ++++++++----------- + 1 file changed, 8 insertions(+), 11 deletions(-) + +diff --git a/src/lstack/core/lstack_cfg.c b/src/lstack/core/lstack_cfg.c +index e5a92ca..058a392 100644 +--- a/src/lstack/core/lstack_cfg.c ++++ b/src/lstack/core/lstack_cfg.c +@@ -323,25 +323,22 @@ static int32_t numa_to_cpusnum(unsigned socket_id, uint32_t *cpulist, int32_t nu + + static int32_t stack_idle_cpuset(struct protocol_stack *stack, cpu_set_t *exclude) + { +- int32_t cpunum; + uint32_t cpulist[CPUS_RANGE_NUM]; + +- cpunum = numa_to_cpusnum(stack->socket_id, cpulist, CPUS_RANGE_NUM); +- if (cpunum <= 0 || cpunum % 2 != 0) { // 2 : even ++ int32_t cpunum = numa_to_cpusnum(stack->socket_id, cpulist, CPUS_RANGE_NUM); ++ if (cpunum <= 0 ) { + LSTACK_LOG(ERR, LSTACK, "numa_to_cpusnum failed\n"); + return -1; + } + + CPU_ZERO(&stack->idle_cpuset); +- for (uint32_t n = 0; n < cpunum; n += 2) { // 2 : even +- for (uint32_t i = cpulist[n]; i <= cpulist[n + 1]; i++) { +- /* skip stack cpu */ +- if (CPU_ISSET(i, exclude)) { +- continue; +- } +- +- CPU_SET(i, &stack->idle_cpuset); ++ for (int32_t i = 0; i < cpunum; i++) { ++ /* skip stack cpu */ ++ if (CPU_ISSET(cpulist[i], exclude)) { ++ continue; + } ++ ++ CPU_SET(cpulist[i], &stack->idle_cpuset); + } + + return 0; +-- +1.8.3.1 + diff --git a/0022-fix-get-data-error.patch b/0022-fix-get-data-error.patch new file mode 100644 index 0000000..1f24208 --- /dev/null +++ b/0022-fix-get-data-error.patch @@ -0,0 +1,267 @@ +From c064bea759414419d7fcae6c31455e517a9556f9 Mon Sep 17 00:00:00 2001 +From: jiangheng +Date: Wed, 16 Mar 2022 15:19:53 +0800 +Subject: [PATCH 22/34] fix get data error + +--- + src/common/gazelle_dfx_msg.h | 2 +- + src/lstack/api/lstack_epoll.c | 10 ++++------ + src/lstack/core/lstack_dpdk.c | 8 +++----- + src/lstack/core/lstack_lwip.c | 15 ++++++++------- + src/lstack/core/lstack_stack_stat.c | 1 - + src/lstack/core/lstack_thread_rpc.c | 8 -------- + src/lstack/include/lstack_protocol_stack.h | 1 - + src/lstack/netif/lstack_ethdev.c | 4 ++-- + src/ltran/ltran_dfx.c | 7 +++---- + 9 files changed, 21 insertions(+), 35 deletions(-) + +diff --git a/src/common/gazelle_dfx_msg.h b/src/common/gazelle_dfx_msg.h +index 41cbefa..3956c33 100644 +--- a/src/common/gazelle_dfx_msg.h ++++ b/src/common/gazelle_dfx_msg.h +@@ -86,10 +86,10 @@ struct gazelle_stat_pkts { + uint64_t accept_events; + uint64_t read_null; + uint64_t recv_empty; +- uint64_t event_null; + uint64_t remove_event; + uint64_t send_self_rpc; + uint64_t call_null; ++ uint64_t arp_copy_fail; + }; + + /* same as define in lwip/stats.h - struct stats_mib2 */ +diff --git a/src/lstack/api/lstack_epoll.c b/src/lstack/api/lstack_epoll.c +index b12ce58..885ec45 100644 +--- a/src/lstack/api/lstack_epoll.c ++++ b/src/lstack/api/lstack_epoll.c +@@ -78,17 +78,16 @@ void add_epoll_event(struct netconn *conn, uint32_t event) + sock = sock->shadowed_sock; + } + +- /* sock not in monitoring */ +- if (!sock->weakup) { ++ if ((event & sock->epoll_events) == 0) { + return; + } ++ sock->events |= event & sock->epoll_events; + +- if ((event & sock->epoll_events) == 0) { ++ /* sock not in monitoring */ ++ if (!sock->weakup) { + return; + } + +- sock->events |= event & sock->epoll_events; +- + if (report_events(sock, event)) { + sock->have_event = true; + weakup_enqueue(sock->stack->weakup_ring, sock); +@@ -286,7 +285,6 @@ static int32_t get_lwip_events(struct weakup_poll *weakup, void *out, uint32_t m + while (event_num < events_cnt) { + int32_t ret = rte_ring_sc_dequeue(weakup->event_ring, (void **)&sock); + if (ret != 0) { +- get_protocol_stack_group()->event_null++; + break; + } + sock->have_event = false; +diff --git a/src/lstack/core/lstack_dpdk.c b/src/lstack/core/lstack_dpdk.c +index b8320db..fb0e988 100644 +--- a/src/lstack/core/lstack_dpdk.c ++++ b/src/lstack/core/lstack_dpdk.c +@@ -167,14 +167,12 @@ int32_t pktmbuf_pool_init(struct protocol_stack *stack, uint16_t stack_num) + return -1; + } + +- stack->rx_pktmbuf_pool = create_pktmbuf_mempool("rx_mbuf", RX_NB_MBUF / stack_num, RX_MBUF_CACHE_SZ, +- stack->queue_id); ++ stack->rx_pktmbuf_pool = create_pktmbuf_mempool("rx_mbuf", RX_NB_MBUF / stack_num, 0, stack->queue_id); + if (stack->rx_pktmbuf_pool == NULL) { + return -1; + } + +- stack->tx_pktmbuf_pool = create_pktmbuf_mempool("tx_mbuf", TX_NB_MBUF / stack_num, TX_MBUF_CACHE_SZ, +- stack->queue_id); ++ stack->tx_pktmbuf_pool = create_pktmbuf_mempool("tx_mbuf", TX_NB_MBUF / stack_num, 0, stack->queue_id); + if (stack->tx_pktmbuf_pool == NULL) { + return -1; + } +@@ -557,7 +555,7 @@ 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, KNI_MBUF_CACHE_SZ, 0); ++ stack_group->kni_pktmbuf_pool = create_pktmbuf_mempool("kni_mbuf", KNI_NB_MBUF, 0, 0); + if (stack_group->kni_pktmbuf_pool == NULL) { + return -1; + } +diff --git a/src/lstack/core/lstack_lwip.c b/src/lstack/core/lstack_lwip.c +index 1fc8446..1a9d9b9 100644 +--- a/src/lstack/core/lstack_lwip.c ++++ b/src/lstack/core/lstack_lwip.c +@@ -175,7 +175,6 @@ int32_t gazelle_alloc_pktmbuf(struct rte_mempool *pool, struct rte_mbuf **mbufs, + + int32_t ret = alloc_mbufs(pool, mbufs, num); + if (ret != 0) { +- get_protocol_stack()->stats.tx_allocmbuf_fail++; + return ret; + } + +@@ -289,7 +288,7 @@ ssize_t write_stack_data(struct lwip_sock *sock, const void *buf, size_t len) + } + + copy_len = (len - send_len > pbuf->len) ? pbuf->len : (len - send_len); +- pbuf_take(pbuf, buf + send_len, copy_len); ++ pbuf_take(pbuf, (char *)buf + send_len, copy_len); + pbuf->tot_len = pbuf->len = copy_len; + + ret = rte_ring_sp_enqueue(sock->send_ring, pbuf); +@@ -331,13 +330,13 @@ ssize_t read_lwip_data(struct lwip_sock *sock, int32_t flags, u8_t apiflags) + + uint32_t free_count = rte_ring_free_count(sock->recv_ring); + uint32_t data_count = rte_ring_count(sock->conn->recvmbox->ring); +- ++ uint32_t read_max = LWIP_MIN(free_count, data_count); + struct pbuf *pbuf = NULL; +- uint32_t read_count = LWIP_MIN(free_count, data_count); ++ uint32_t read_count = 0; + ssize_t recv_len = 0; + int32_t ret; + +- for (uint32_t i = 0; i < read_count; i++) { ++ for (uint32_t i = 0; i < read_max; i++) { + err_t err = netconn_recv_tcp_pbuf_flags(sock->conn, &pbuf, apiflags); + if (err != ERR_OK) { + if (recv_len > 0) { +@@ -356,6 +355,7 @@ ssize_t read_lwip_data(struct lwip_sock *sock, int32_t flags, u8_t apiflags) + sock->stack->stats.read_lwip_drop++; + break; + } ++ read_count++; + } + + recv_len += pbuf->len; +@@ -364,7 +364,7 @@ ssize_t read_lwip_data(struct lwip_sock *sock, int32_t flags, u8_t apiflags) + apiflags |= NETCONN_DONTBLOCK | NETCONN_NOFIN; + } + +- if (data_count > free_count) { ++ if (data_count > read_count) { + add_recv_list(sock->conn->socket); + } + +@@ -481,6 +481,7 @@ ssize_t read_stack_data(int32_t fd, void *buf, size_t len, int32_t flags) + while (recv_left > 0) { + if (sock->recv_lastdata) { + pbuf = sock->recv_lastdata; ++ sock->recv_lastdata = NULL; + } else { + ret = rte_ring_sc_dequeue(sock->recv_ring, (void **)&pbuf); + if (ret != 0) { +@@ -490,7 +491,7 @@ ssize_t read_stack_data(int32_t fd, void *buf, size_t len, int32_t flags) + } + + copy_len = (recv_left > pbuf->tot_len) ? pbuf->tot_len : (u16_t)recv_left; +- pbuf_copy_partial(pbuf, buf + recvd, copy_len, 0); ++ pbuf_copy_partial(pbuf, (char *)buf + recvd, copy_len, 0); + + recvd += copy_len; + recv_left -= copy_len; +diff --git a/src/lstack/core/lstack_stack_stat.c b/src/lstack/core/lstack_stack_stat.c +index 0bd1c6c..41fe9bf 100644 +--- a/src/lstack/core/lstack_stack_stat.c ++++ b/src/lstack/core/lstack_stack_stat.c +@@ -105,7 +105,6 @@ static void get_stack_stats(struct gazelle_stack_dfx_data *dfx, struct protocol_ + lstack_get_low_power_info(&dfx->low_power_info); + memcpy_s(&dfx->data.pkts, sizeof(dfx->data.pkts), &stack->stats, sizeof(dfx->data.pkts)); + dfx->data.pkts.call_alloc_fail = stack_group->call_alloc_fail; +- dfx->data.pkts.event_null = stack_group->event_null; + dfx->data.pkts.weakup_ring_cnt = rte_ring_count(stack->weakup_ring); + dfx->data.pkts.send_idle_ring_cnt = rte_ring_count(stack->send_idle_ring); + dfx->data.pkts.call_msg_cnt = rpc_call_msgcnt(stack); +diff --git a/src/lstack/core/lstack_thread_rpc.c b/src/lstack/core/lstack_thread_rpc.c +index b4d57d3..8af1077 100644 +--- a/src/lstack/core/lstack_thread_rpc.c ++++ b/src/lstack/core/lstack_thread_rpc.c +@@ -80,15 +80,11 @@ void poll_rpc_msg(struct protocol_stack *stack) + struct rpc_msg *msg = NULL; + + num = 0; +- lockless_queue_node *first_node = NULL; + while (num++ < HANDLE_RPC_MSG_MAX) { + lockless_queue_node *node = lockless_queue_mpsc_pop(&stack->rpc_queue); + if (node == NULL) { + return; + } +- if (first_node == NULL) { +- first_node = node; +- } + + msg = container_of(node, struct rpc_msg, queue_node); + +@@ -105,10 +101,6 @@ void poll_rpc_msg(struct protocol_stack *stack) + } else { + rpc_msg_free(stack->rpc_pool, msg); + } +- +- if (first_node == node) { +- break; +- } + } + } + +diff --git a/src/lstack/include/lstack_protocol_stack.h b/src/lstack/include/lstack_protocol_stack.h +index 1020e83..f289465 100644 +--- a/src/lstack/include/lstack_protocol_stack.h ++++ b/src/lstack/include/lstack_protocol_stack.h +@@ -72,7 +72,6 @@ struct protocol_stack_group { + /* dfx stats */ + bool latency_start; + uint64_t call_alloc_fail; +- uint64_t event_null; + }; + + long get_stack_tid(void); +diff --git a/src/lstack/netif/lstack_ethdev.c b/src/lstack/netif/lstack_ethdev.c +index 796a46d..026f545 100644 +--- a/src/lstack/netif/lstack_ethdev.c ++++ b/src/lstack/netif/lstack_ethdev.c +@@ -97,8 +97,8 @@ int32_t eth_dev_poll(void) + } + + if (get_protocol_stack_group()->latency_start) { +- uint64_t time_stamp = get_current_time(); +- time_stamp_into_mbuf(nr_pkts, pkts, time_stamp); ++ uint64_t time_stamp = get_current_time(); ++ time_stamp_into_mbuf(nr_pkts, pkts, time_stamp); + } + + for (uint32_t i = 0; i < nr_pkts; i++) { +diff --git a/src/ltran/ltran_dfx.c b/src/ltran/ltran_dfx.c +index 4b46ac9..5b3a95c 100644 +--- a/src/ltran/ltran_dfx.c ++++ b/src/ltran/ltran_dfx.c +@@ -390,7 +390,7 @@ static void gazelle_print_ltran_start_latency(void *buf, const struct gazelle_st + static void gazelle_print_ltran_stat_latency(void *buf, const struct gazelle_stat_msg_request *req_msg) + { + struct in_addr *ip_addr = (struct in_addr *)buf; +- struct gazelle_stat_lstack_total *stat = (struct gazelle_stat_lstack_total *)(buf + sizeof(*ip_addr)); ++ struct gazelle_stat_lstack_total *stat = (struct gazelle_stat_lstack_total *)((char *)buf + sizeof(*ip_addr)); + uint64_t total_rx = 0; + double total_latency = 0; + uint64_t max = 0; +@@ -574,9 +574,8 @@ static void show_lstack_stats(struct gazelle_stack_dfx_data *lstack_stat) + printf("read_null: %-18"PRIu64" ", lstack_stat->data.pkts.read_null); + printf("recv_empty: %-17"PRIu64" \n", lstack_stat->data.pkts.recv_empty); + printf("call_alloc_fail: %-12"PRIu64" ", lstack_stat->data.pkts.call_alloc_fail); +- printf("event_null: %-17"PRIu64" ", lstack_stat->data.pkts.event_null); +- printf("remove_event: %-15"PRIu64" \n", lstack_stat->data.pkts.remove_event); +- printf("send_self_rpc: %-14"PRIu64" ", lstack_stat->data.pkts.send_self_rpc); ++ printf("remove_event: %-15"PRIu64" ", lstack_stat->data.pkts.remove_event); ++ printf("send_self_rpc: %-14"PRIu64" \n", lstack_stat->data.pkts.send_self_rpc); + printf("call_null: %-18"PRIu64" \n", lstack_stat->data.pkts.call_null); + } + +-- +1.8.3.1 + diff --git a/0023-delete-numa-bind-param.patch b/0023-delete-numa-bind-param.patch new file mode 100644 index 0000000..fd1e145 --- /dev/null +++ b/0023-delete-numa-bind-param.patch @@ -0,0 +1,197 @@ +From efd5bfb1a4a070217a0ff174d32500130b629d0a Mon Sep 17 00:00:00 2001 +From: jiangheng +Date: Wed, 16 Mar 2022 15:35:20 +0800 +Subject: [PATCH 23/34] delete numa bind param + +--- + src/common/gazelle_dfx_msg.h | 1 - + src/lstack/api/lstack_epoll.c | 11 ++++------- + src/lstack/core/lstack_cfg.c | 19 ------------------- + src/lstack/core/lstack_lwip.c | 1 - + src/lstack/core/lstack_protocol_stack.c | 4 ---- + src/lstack/core/lstack_thread_rpc.c | 8 +++----- + src/lstack/include/lstack_cfg.h | 1 - + src/lstack/lstack.conf | 2 -- + src/ltran/ltran_dfx.c | 5 ++--- + 9 files changed, 9 insertions(+), 43 deletions(-) + +diff --git a/src/common/gazelle_dfx_msg.h b/src/common/gazelle_dfx_msg.h +index 3956c33..cea4200 100644 +--- a/src/common/gazelle_dfx_msg.h ++++ b/src/common/gazelle_dfx_msg.h +@@ -85,7 +85,6 @@ struct gazelle_stat_pkts { + uint64_t write_events; + uint64_t accept_events; + uint64_t read_null; +- uint64_t recv_empty; + uint64_t remove_event; + uint64_t send_self_rpc; + uint64_t call_null; +diff --git a/src/lstack/api/lstack_epoll.c b/src/lstack/api/lstack_epoll.c +index 885ec45..bcbb35e 100644 +--- a/src/lstack/api/lstack_epoll.c ++++ b/src/lstack/api/lstack_epoll.c +@@ -83,16 +83,13 @@ void add_epoll_event(struct netconn *conn, uint32_t event) + } + sock->events |= event & sock->epoll_events; + +- /* sock not in monitoring */ +- if (!sock->weakup) { ++ if (!sock->weakup || !report_events(sock, event)) { + return; + } + +- if (report_events(sock, event)) { +- sock->have_event = true; +- weakup_enqueue(sock->stack->weakup_ring, sock); +- sock->stack->stats.weakup_events++; +- } ++ sock->have_event = true; ++ weakup_enqueue(sock->stack->weakup_ring, sock); ++ sock->stack->stats.weakup_events++; + } + + static void raise_pending_events(struct lwip_sock *sock) +diff --git a/src/lstack/core/lstack_cfg.c b/src/lstack/core/lstack_cfg.c +index 058a392..fcc1c0b 100644 +--- a/src/lstack/core/lstack_cfg.c ++++ b/src/lstack/core/lstack_cfg.c +@@ -53,7 +53,6 @@ static int32_t parse_weakup_cpu_number(void); + static int32_t parse_mask_addr(void); + static int32_t parse_devices(void); + static int32_t parse_dpdk_args(void); +-static int32_t parse_numa_bind(void); + static int32_t parse_gateway_addr(void); + static int32_t parse_kni_switch(void); + +@@ -71,7 +70,6 @@ static struct config_vector_t g_config_tbl[] = { + { "dpdk_args", parse_dpdk_args }, + { "num_cpus", parse_stack_cpu_number }, + { "num_wakeup", parse_weakup_cpu_number }, +- { "numa_bind", parse_numa_bind }, + { "low_power_mode", parse_low_power_mode }, + { "kni_switch", parse_kni_switch }, + { NULL, NULL } +@@ -714,23 +712,6 @@ static int32_t parse_weakup_cpu_number(void) + return 0; + } + +-static int32_t parse_numa_bind(void) +-{ +- const config_setting_t *numa_bind = NULL; +- +- numa_bind = config_lookup(&g_config, "numa_bind"); +- if (numa_bind == NULL) { +- g_config_params.numa_bind = 1; +- return 0; +- } +- g_config_params.numa_bind = (uint8_t)config_setting_get_bool(numa_bind); +- if (g_config_params.numa_bind != 0 && g_config_params.numa_bind != 1) { +- return -EINVAL; +- } +- +- return 0; +-} +- + static int32_t parse_use_ltran(void) + { + const config_setting_t *arg = NULL; +diff --git a/src/lstack/core/lstack_lwip.c b/src/lstack/core/lstack_lwip.c +index 1a9d9b9..b157517 100644 +--- a/src/lstack/core/lstack_lwip.c ++++ b/src/lstack/core/lstack_lwip.c +@@ -485,7 +485,6 @@ ssize_t read_stack_data(int32_t fd, void *buf, size_t len, int32_t flags) + } else { + ret = rte_ring_sc_dequeue(sock->recv_ring, (void **)&pbuf); + if (ret != 0) { +- sock->stack->stats.recv_empty++; + break; + } + } +diff --git a/src/lstack/core/lstack_protocol_stack.c b/src/lstack/core/lstack_protocol_stack.c +index db8a20a..c88f902 100644 +--- a/src/lstack/core/lstack_protocol_stack.c ++++ b/src/lstack/core/lstack_protocol_stack.c +@@ -46,10 +46,6 @@ int32_t bind_to_stack_numa(int32_t stack_id) + struct protocol_stack *stack = get_protocol_stack_group()->stacks[stack_id]; + pthread_t tid = pthread_self(); + +- if (get_global_cfg_params()->numa_bind == 0) { +- return 0; +- } +- + if (last_stack_id == stack_id) { + return 0; + } +diff --git a/src/lstack/core/lstack_thread_rpc.c b/src/lstack/core/lstack_thread_rpc.c +index 8af1077..b3665a7 100644 +--- a/src/lstack/core/lstack_thread_rpc.c ++++ b/src/lstack/core/lstack_thread_rpc.c +@@ -414,12 +414,9 @@ static void stack_send(struct rpc_msg *msg) + } + + msg->result = write_lwip_data(sock, fd, flags); +- if (msg->result < 0 || rte_ring_count(sock->send_ring) == 0) { +- msg->self_release = 0; +- sock->have_rpc_send = false; +- } ++ sock->have_rpc_send = false; + +- if (rte_ring_count(sock->send_ring)) { ++ if (msg->result >= 0 && rte_ring_count(sock->send_ring)) { + sock->have_rpc_send = true; + sock->stack->stats.send_self_rpc++; + msg->self_release = 1; +@@ -443,6 +440,7 @@ ssize_t rpc_call_send(int fd, const void *buf, size_t len, int flags) + msg->args[MSG_ARG_1].size = len; + msg->args[MSG_ARG_2].i = flags; + ++ msg->self_release = 0; + rpc_call(&stack->rpc_queue, msg); + + return 0; +diff --git a/src/lstack/include/lstack_cfg.h b/src/lstack/include/lstack_cfg.h +index 9096797..1a59c6c 100644 +--- a/src/lstack/include/lstack_cfg.h ++++ b/src/lstack/include/lstack_cfg.h +@@ -63,7 +63,6 @@ struct cfg_params { + ip4_addr_t netmask; + ip4_addr_t gateway_addr; + struct rte_ether_addr ethdev; +- uint8_t numa_bind; + uint16_t num_cpu; + uint16_t cpus[CFG_MAX_CPUS]; + uint16_t num_wakeup; +diff --git a/src/lstack/lstack.conf b/src/lstack/lstack.conf +index eb996f1..fdca602 100644 +--- a/src/lstack/lstack.conf ++++ b/src/lstack/lstack.conf +@@ -18,8 +18,6 @@ low_power_mode=0 + num_cpus="2" + num_wakeup="3" + +-numa_bind=1 +- + host_addr="192.168.1.10" + mask_addr="255.255.255.0" + gateway_addr="192.168.1.1" +diff --git a/src/ltran/ltran_dfx.c b/src/ltran/ltran_dfx.c +index 5b3a95c..451f527 100644 +--- a/src/ltran/ltran_dfx.c ++++ b/src/ltran/ltran_dfx.c +@@ -572,10 +572,9 @@ static void show_lstack_stats(struct gazelle_stack_dfx_data *lstack_stat) + printf("accept_events: %-14"PRIu64" \n", lstack_stat->data.pkts.accept_events); + printf("call_msg: %-19"PRIu64" ", lstack_stat->data.pkts.call_msg_cnt); + printf("read_null: %-18"PRIu64" ", lstack_stat->data.pkts.read_null); +- printf("recv_empty: %-17"PRIu64" \n", lstack_stat->data.pkts.recv_empty); +- printf("call_alloc_fail: %-12"PRIu64" ", lstack_stat->data.pkts.call_alloc_fail); ++ printf("call_alloc_fail: %-12"PRIu64" \n", lstack_stat->data.pkts.call_alloc_fail); + printf("remove_event: %-15"PRIu64" ", lstack_stat->data.pkts.remove_event); +- printf("send_self_rpc: %-14"PRIu64" \n", lstack_stat->data.pkts.send_self_rpc); ++ printf("send_self_rpc: %-14"PRIu64" ", lstack_stat->data.pkts.send_self_rpc); + printf("call_null: %-18"PRIu64" \n", lstack_stat->data.pkts.call_null); + } + +-- +1.8.3.1 + diff --git a/0024-refactor-event.patch b/0024-refactor-event.patch new file mode 100644 index 0000000..c6f85f5 --- /dev/null +++ b/0024-refactor-event.patch @@ -0,0 +1,806 @@ +From fadeb43a653ab5da503b7030b60b4e063f0b3aef Mon Sep 17 00:00:00 2001 +From: wuchangsheng +Date: Sun, 13 Mar 2022 22:57:44 +0800 +Subject: [PATCH 24/34] refactor event + +--- + src/common/gazelle_dfx_msg.h | 10 +++- + src/lstack/api/lstack_epoll.c | 73 +++++++++++++++++--------- + src/lstack/core/lstack_control_plane.c | 13 +++++ + src/lstack/core/lstack_lwip.c | 76 ++++++++++++++++++++------- + src/lstack/core/lstack_protocol_stack.c | 36 ++++++++++--- + src/lstack/core/lstack_stack_stat.c | 4 ++ + src/lstack/core/lstack_thread_rpc.c | 42 +++++++++++++++ + src/lstack/include/lstack_lwip.h | 3 ++ + src/lstack/include/lstack_protocol_stack.h | 2 + + src/lstack/include/lstack_thread_rpc.h | 3 ++ + src/lstack/include/lstack_weakup.h | 84 +++++++++++++++++++++--------- + src/ltran/ltran_dfx.c | 36 ++++++++----- + 12 files changed, 290 insertions(+), 92 deletions(-) + +diff --git a/src/common/gazelle_dfx_msg.h b/src/common/gazelle_dfx_msg.h +index cea4200..ae20436 100644 +--- a/src/common/gazelle_dfx_msg.h ++++ b/src/common/gazelle_dfx_msg.h +@@ -64,10 +64,12 @@ struct gazelle_stat_pkts { + uint64_t rx_drop; + uint64_t rx_allocmbuf_fail; + uint64_t tx_allocmbuf_fail; +- uint16_t weakup_ring_cnt; + uint64_t call_msg_cnt; ++ uint16_t weakup_ring_cnt; + uint16_t conn_num; + uint16_t send_idle_ring_cnt; ++ uint64_t event_list; ++ uint64_t wakeup_list; + uint64_t read_lwip_drop; + uint64_t read_lwip_cnt; + uint64_t write_lwip_drop; +@@ -89,6 +91,10 @@ struct gazelle_stat_pkts { + uint64_t send_self_rpc; + uint64_t call_null; + uint64_t arp_copy_fail; ++ uint64_t epoll_pending; ++ uint64_t epoll_pending_call; ++ uint64_t epoll_self_call; ++ uint64_t epoll_self_event; + }; + + /* same as define in lwip/stats.h - struct stats_mib2 */ +@@ -162,6 +168,8 @@ struct gazelle_stat_lstack_conn_info { + uint32_t send_ring_cnt; + uint32_t recv_ring_cnt; + uint32_t tcp_sub_state; ++ uint32_t event_ring_cnt; ++ uint32_t self_ring_cnt; + }; + + struct gazelle_stat_lstack_conn { +diff --git a/src/lstack/api/lstack_epoll.c b/src/lstack/api/lstack_epoll.c +index bcbb35e..a686ddb 100644 +--- a/src/lstack/api/lstack_epoll.c ++++ b/src/lstack/api/lstack_epoll.c +@@ -87,19 +87,27 @@ void add_epoll_event(struct netconn *conn, uint32_t event) + return; + } + +- sock->have_event = true; +- weakup_enqueue(sock->stack->weakup_ring, sock); +- sock->stack->stats.weakup_events++; ++ if (weakup_enqueue(sock->stack->weakup_ring, sock)) { ++ if (list_is_empty(&sock->event_list)) { ++ list_add_node(&sock->stack->event_list, &sock->event_list); ++ } ++ } else { ++ sock->have_event = true; ++ sock->stack->stats.weakup_events++; ++ } + } + + static void raise_pending_events(struct lwip_sock *sock) + { +- if (!sock->conn) { ++ struct weakup_poll *wakeup = sock->weakup; ++ struct protocol_stack *stack = sock->stack; ++ struct netconn *conn = sock->conn; ++ if (wakeup == NULL || stack == NULL || conn == NULL) { + return; + } + + struct lwip_sock *attach_sock = NULL; +- if (sock->attach_fd > 0 && sock->attach_fd != sock->conn->socket) { ++ if (sock->attach_fd > 0 && sock->attach_fd != conn->socket) { + attach_sock = get_socket_by_fd(sock->attach_fd); + if (attach_sock == NULL) { + return; +@@ -108,7 +116,10 @@ static void raise_pending_events(struct lwip_sock *sock) + attach_sock = sock; + } + +- struct netconn *conn = attach_sock->conn; ++ conn = attach_sock->conn; ++ if (conn == NULL) { ++ return; ++ } + struct tcp_pcb *tcp = conn->pcb.tcp; + if ((tcp == NULL) || (tcp->state < ESTABLISHED)) { + return; +@@ -132,10 +143,17 @@ static void raise_pending_events(struct lwip_sock *sock) + event |= POLLERR | POLLIN; + } + +- if (event != 0) { +- sock->events |= event; +- rte_ring_mp_enqueue(sock->weakup->event_ring, (void *)sock); +- sem_post(&sock->weakup->event_sem); ++ if (event == 0) { ++ return; ++ } ++ sock->events |= event; ++ if (rte_ring_mp_enqueue(wakeup->event_ring, (void *)sock) == 0 || ++ rte_ring_mp_enqueue(wakeup->self_ring, (void *)sock) == 0) { ++ sem_post(&wakeup->event_sem); ++ stack->stats.epoll_pending++; ++ } else { ++ rpc_call_addevent(stack, sock); ++ stack->stats.epoll_pending_call++; + } + } + +@@ -168,6 +186,12 @@ int32_t lstack_epoll_create(int32_t size) + GAZELLE_RETURN(ENOMEM); + } + ++ weakup->self_ring = create_ring("SELF_EVENT", VDEV_EVENT_QUEUE_SZ, RING_F_SC_DEQ, fd); ++ if (weakup->self_ring == NULL) { ++ posix_api->close_fn(fd); ++ GAZELLE_RETURN(ENOMEM); ++ } ++ + sock->weakup = weakup; + + return fd; +@@ -247,11 +271,6 @@ static inline int32_t save_poll_event(struct pollfd *fds, uint32_t maxevents, st + + static bool remove_event(enum POLL_TYPE etype, struct lwip_sock **sock_list, int32_t event_num, struct lwip_sock *sock) + { +- /* close sock */ +- if (sock->stack == NULL) { +- return true; +- } +- + /* remove duplicate event */ + for (uint32_t i = 0; i < event_num && etype == TYPE_EPOLL; i++) { + if (sock_list[i] == sock) { +@@ -267,29 +286,26 @@ static int32_t get_lwip_events(struct weakup_poll *weakup, void *out, uint32_t m + struct epoll_event *events = (struct epoll_event *)out; + struct pollfd *fds = (struct pollfd *)out; + +- uint32_t events_cnt = rte_ring_count(weakup->event_ring); +- if (events_cnt == 0) { +- return 0; +- } + + if (etype == TYPE_EPOLL) { + maxevents = LWIP_MIN(EPOLL_MAX_EVENTS, maxevents); + } +- events_cnt = LWIP_MIN(events_cnt, maxevents); + int32_t event_num = 0; + struct lwip_sock *sock = NULL; + +- while (event_num < events_cnt) { +- int32_t ret = rte_ring_sc_dequeue(weakup->event_ring, (void **)&sock); +- if (ret != 0) { ++ while (event_num < maxevents) { ++ if (rte_ring_sc_dequeue(weakup->self_ring, (void **)&sock) && ++ rte_ring_sc_dequeue(weakup->event_ring, (void **)&sock)) { + break; + } ++ /* close sock */ ++ if (sock->stack == NULL) { ++ return true; ++ } + sock->have_event = false; + + if (remove_event(etype, weakup->sock_list, event_num, sock)) { +- if (sock->stack) { +- sock->stack->stats.remove_event++; +- } ++ sock->stack->stats.remove_event++; + continue; + } + +@@ -390,6 +406,11 @@ static int32_t poll_init(struct pollfd *fds, nfds_t nfds, struct weakup_poll *we + if (weakup->event_ring == NULL) { + GAZELLE_RETURN(ENOMEM); + } ++ ++ weakup->self_ring = create_ring("SELF_EVENT", VDEV_EVENT_QUEUE_SZ, RING_F_SC_DEQ, rte_gettid()); ++ if (weakup->self_ring == NULL) { ++ GAZELLE_RETURN(ENOMEM); ++ } + } + + for (uint32_t i = 0; i < nfds; i++) { +diff --git a/src/lstack/core/lstack_control_plane.c b/src/lstack/core/lstack_control_plane.c +index a7e084d..c782d51 100644 +--- a/src/lstack/core/lstack_control_plane.c ++++ b/src/lstack/core/lstack_control_plane.c +@@ -38,6 +38,7 @@ + #define RECONNECT_TO_LTRAN_DELAY (1) + #define GAZELLE_BADFD (-1) + #define GAZELLE_LISTEN_BACKLOG 5 ++#define GAZELLE_10MS (10000) + + static int32_t g_data_fd = -1; + static volatile bool g_register_state = true; +@@ -701,6 +702,12 @@ void control_server_thread(void *arg) + int32_t num, connfd; + struct epoll_event evt_array; + while (1) { ++ /* wait init finish */ ++ if (posix_api->is_chld) { ++ usleep(GAZELLE_10MS); ++ continue; ++ } ++ + num = posix_api->epoll_wait_fn(epfd, &evt_array, 1, -1); + if (num <= 0) { + continue; +@@ -741,6 +748,12 @@ void control_client_thread(void *arg) + } + + while (1) { ++ /* wait init finish */ ++ if (posix_api->is_chld) { ++ usleep(GAZELLE_10MS); ++ continue; ++ } ++ + if (sockfd < 0) { + set_register_state(false); + sockfd = client_reg_proc_reconnect(epfd); +diff --git a/src/lstack/core/lstack_lwip.c b/src/lstack/core/lstack_lwip.c +index b157517..d55f1e6 100644 +--- a/src/lstack/core/lstack_lwip.c ++++ b/src/lstack/core/lstack_lwip.c +@@ -110,6 +110,8 @@ void gazelle_init_sock(int32_t fd) + init_list_node(&sock->recv_list); + init_list_node(&sock->attach_list); + init_list_node(&sock->listen_list); ++ init_list_node(&sock->event_list); ++ init_list_node(&sock->wakeup_list); + } + + void gazelle_clean_sock(int32_t fd) +@@ -126,6 +128,8 @@ void gazelle_clean_sock(int32_t fd) + list_del_node_init(&sock->recv_list); + list_del_node_init(&sock->attach_list); + list_del_node_init(&sock->listen_list); ++ list_del_node_init(&sock->event_list); ++ list_del_node_init(&sock->wakeup_list); + } + + void gazelle_free_pbuf(struct pbuf *pbuf) +@@ -266,6 +270,30 @@ ssize_t write_lwip_data(struct lwip_sock *sock, int32_t fd, int32_t flags) + return (send_ret < 0) ? send_ret : send_len; + } + ++void add_self_event(struct lwip_sock *sock, uint32_t events) ++{ ++ struct weakup_poll *wakeup = sock->weakup; ++ struct protocol_stack *stack = sock->stack; ++ if (wakeup == NULL || stack == NULL) { ++ return; ++ } ++ ++ sock->events |= events; ++ ++ if (sock->have_event) { ++ return; ++ } ++ ++ if (rte_ring_mp_enqueue(wakeup->self_ring, (void *)sock) == 0) { ++ sock->have_event = true; ++ sem_post(&sock->weakup->event_sem); ++ stack->stats.epoll_self_event++; ++ } else { ++ rpc_call_addevent(stack, sock); ++ stack->stats.epoll_self_call++; ++ } ++} ++ + ssize_t write_stack_data(struct lwip_sock *sock, const void *buf, size_t len) + { + uint32_t free_count = rte_ring_free_count(sock->send_ring); +@@ -303,14 +331,10 @@ ssize_t write_stack_data(struct lwip_sock *sock, const void *buf, size_t len) + send_pkt++; + } + +- if (!sock->have_event && (sock->epoll_events & EPOLLOUT) && NETCONN_IS_DATAOUT(sock)) { +- sock->have_event = true; +- sock->events |= EPOLLOUT; +- rte_ring_mp_enqueue(sock->weakup->event_ring, (void *)sock); +- sem_post(&sock->weakup->event_sem); ++ if ((sock->epoll_events & EPOLLOUT) && NETCONN_IS_DATAOUT(sock)) { ++ add_self_event(sock, EPOLLOUT); + sock->stack->stats.write_events++; +- } +- if (!NETCONN_IS_DATAOUT(sock)) { ++ } else { + sock->events &= ~EPOLLOUT; + } + +@@ -507,14 +531,10 @@ ssize_t read_stack_data(int32_t fd, void *buf, size_t len, int32_t flags) + } + } + +- if (!sock->have_event && (sock->epoll_events & EPOLLIN) && NETCONN_IS_DATAIN(sock)) { +- sock->have_event = true; +- sock->events |= EPOLLIN; +- rte_ring_mp_enqueue(sock->weakup->event_ring, (void *)sock); +- sem_post(&sock->weakup->event_sem); ++ if ((sock->epoll_events & EPOLLIN) && NETCONN_IS_DATAIN(sock)) { ++ add_self_event(sock, EPOLLIN); + sock->stack->stats.read_events++; +- } +- if (!NETCONN_IS_DATAIN(sock)) { ++ } else { + sock->events &= ~EPOLLIN; + } + +@@ -577,9 +597,14 @@ static void copy_pcb_to_conn(struct gazelle_stat_lstack_conn_info *conn, const s + conn->recv_cnt = rte_ring_count(netconn->recvmbox->ring); + + struct lwip_sock *sock = get_socket(netconn->socket); +- if (sock != NULL && sock->recv_ring != NULL && sock->send_ring != NULL) { ++ if (netconn->socket > 0 && sock != NULL && sock->recv_ring != NULL && sock->send_ring != NULL) { + conn->recv_ring_cnt = rte_ring_count(sock->recv_ring); + conn->send_ring_cnt = rte_ring_count(sock->send_ring); ++ struct weakup_poll *weakup = sock->weakup; ++ if (weakup) { ++ conn->event_ring_cnt = rte_ring_count(weakup->event_ring); ++ conn->self_ring_cnt = rte_ring_count(weakup->self_ring); ++ } + } + } + } +@@ -696,10 +721,8 @@ void get_lwip_connnum(struct rpc_msg *msg) + msg->result = conn_num; + } + +-void stack_recvlist_count(struct rpc_msg *msg) ++static uint32_t get_list_count(struct list_node *list) + { +- struct protocol_stack *stack = get_protocol_stack(); +- struct list_node *list = &(stack->recv_list); + struct list_node *node, *temp; + uint32_t count = 0; + +@@ -707,5 +730,20 @@ void stack_recvlist_count(struct rpc_msg *msg) + count++; + } + +- msg->result = count; ++ return count; ++} ++ ++void stack_wakeuplist_count(struct rpc_msg *msg) ++{ ++ msg->result = get_list_count(get_protocol_stack()->wakeup_list); ++} ++ ++void stack_eventlist_count(struct rpc_msg *msg) ++{ ++ msg->result = get_list_count(&get_protocol_stack()->event_list); ++} ++ ++void stack_recvlist_count(struct rpc_msg *msg) ++{ ++ msg->result = get_list_count(&get_protocol_stack()->recv_list); + } +diff --git a/src/lstack/core/lstack_protocol_stack.c b/src/lstack/core/lstack_protocol_stack.c +index c88f902..45649fe 100644 +--- a/src/lstack/core/lstack_protocol_stack.c ++++ b/src/lstack/core/lstack_protocol_stack.c +@@ -193,6 +193,7 @@ int32_t init_protocol_stack(void) + + init_list_node(&stack->recv_list); + init_list_node(&stack->listen_list); ++ init_list_node(&stack->event_list); + + stack_group->stacks[i] = stack; + } +@@ -261,8 +262,14 @@ static void* gazelle_weakup_thread(void *arg) + thread_affinity_init(lcore_id); + LSTACK_LOG(INFO, LSTACK, "weakup_%02d start\n", stack->queue_id); + ++ struct list_node wakeup_list; ++ init_list_node(&wakeup_list); ++ stack->wakeup_list = &wakeup_list; ++ + for (;;) { +- weakup_thread(stack->weakup_ring); ++ wakeup_list_sock(&wakeup_list); ++ ++ weakup_thread(stack->weakup_ring, &wakeup_list); + } + + return NULL; +@@ -307,6 +314,24 @@ static void stack_thread_init(struct protocol_stack *stack) + LSTACK_LOG(INFO, LSTACK, "stack_%02d init success\n", queue_id); + } + ++static void report_stack_event(struct protocol_stack *stack) ++{ ++ struct list_node *list = &(stack->event_list); ++ struct list_node *node, *temp; ++ struct lwip_sock *sock; ++ ++ list_for_each_safe(node, temp, list) { ++ sock = container_of(node, struct lwip_sock, event_list); ++ ++ if (weakup_enqueue(stack->weakup_ring, sock) == 0) { ++ list_del_node_init(&sock->event_list); ++ stack->stats.weakup_events++; ++ } else { ++ break; ++ } ++ } ++} ++ + static void* gazelle_stack_thread(void *arg) + { + struct protocol_stack *stack = (struct protocol_stack *)arg; +@@ -321,6 +346,8 @@ static void* gazelle_stack_thread(void *arg) + read_recv_list(); + + sys_timer_run(); ++ ++ report_stack_event(stack); + } + + return NULL; +@@ -737,11 +764,8 @@ int32_t stack_broadcast_accept(int32_t fd, struct sockaddr *addr, socklen_t *add + } + + struct lwip_sock *sock = get_socket(head_fd); +- if (!sock->have_event && have_accept_event(head_fd)) { +- sock->have_event = true; +- sock->events |= EPOLLIN; +- rte_ring_mp_enqueue(sock->weakup->event_ring, (void *)sock); +- sem_post(&sock->weakup->event_sem); ++ if (have_accept_event(head_fd)) { ++ add_self_event(sock, EPOLLIN); + sock->stack->stats.accept_events++; + } + +diff --git a/src/lstack/core/lstack_stack_stat.c b/src/lstack/core/lstack_stack_stat.c +index 41fe9bf..b7b94e2 100644 +--- a/src/lstack/core/lstack_stack_stat.c ++++ b/src/lstack/core/lstack_stack_stat.c +@@ -109,6 +109,10 @@ static void get_stack_stats(struct gazelle_stack_dfx_data *dfx, struct protocol_ + dfx->data.pkts.send_idle_ring_cnt = rte_ring_count(stack->send_idle_ring); + dfx->data.pkts.call_msg_cnt = rpc_call_msgcnt(stack); + dfx->data.pkts.recv_list = rpc_call_recvlistcnt(stack); ++ dfx->data.pkts.event_list = rpc_call_eventlistcnt(stack); ++ if (stack->wakeup_list) { ++ dfx->data.pkts.wakeup_list = rpc_call_eventlistcnt(stack); ++ } + dfx->data.pkts.conn_num = stack->conn_num; + } + +diff --git a/src/lstack/core/lstack_thread_rpc.c b/src/lstack/core/lstack_thread_rpc.c +index b3665a7..2fb24b4 100644 +--- a/src/lstack/core/lstack_thread_rpc.c ++++ b/src/lstack/core/lstack_thread_rpc.c +@@ -177,6 +177,26 @@ int32_t rpc_call_thread_regphase2(struct protocol_stack *stack, void *conn) + return rpc_sync_call(&stack->rpc_queue, stack->rpc_pool, msg); + } + ++int32_t rpc_call_wakeuplistcnt(struct protocol_stack *stack) ++{ ++ struct rpc_msg *msg = rpc_msg_alloc(stack, stack_wakeuplist_count); ++ if (msg == NULL) { ++ return -1; ++ } ++ ++ return rpc_sync_call(&stack->rpc_queue, stack->rpc_pool, msg); ++} ++ ++int32_t rpc_call_eventlistcnt(struct protocol_stack *stack) ++{ ++ struct rpc_msg *msg = rpc_msg_alloc(stack, stack_eventlist_count); ++ if (msg == NULL) { ++ return -1; ++ } ++ ++ return rpc_sync_call(&stack->rpc_queue, stack->rpc_pool, msg); ++} ++ + int32_t rpc_call_recvlistcnt(struct protocol_stack *stack) + { + struct rpc_msg *msg = rpc_msg_alloc(stack, stack_recvlist_count); +@@ -187,6 +207,28 @@ int32_t rpc_call_recvlistcnt(struct protocol_stack *stack) + return rpc_sync_call(&stack->rpc_queue, stack->rpc_pool, msg); + } + ++void add_epoll_event(struct netconn *conn, uint32_t event); ++static void rpc_add_event(struct rpc_msg *msg) ++{ ++ struct lwip_sock *sock = (struct lwip_sock *)msg->args[MSG_ARG_0].p; ++ if (sock->conn) { ++ add_epoll_event(sock->conn, sock->events); ++ } ++} ++ ++void rpc_call_addevent(struct protocol_stack *stack, void *sock) ++{ ++ struct rpc_msg *msg = rpc_msg_alloc(stack, rpc_add_event); ++ if (msg == NULL) { ++ return; ++ } ++ ++ msg->args[MSG_ARG_0].p = sock; ++ ++ msg->self_release = 0; ++ rpc_call(&stack->rpc_queue, msg); ++} ++ + static void rpc_replenish_idlembuf(struct rpc_msg *msg) + { + struct protocol_stack *stack = get_protocol_stack(); +diff --git a/src/lstack/include/lstack_lwip.h b/src/lstack/include/lstack_lwip.h +index 581b9fe..87442cd 100644 +--- a/src/lstack/include/lstack_lwip.h ++++ b/src/lstack/include/lstack_lwip.h +@@ -33,6 +33,8 @@ ssize_t read_stack_data(int32_t fd, void *buf, size_t len, int32_t flags); + ssize_t read_lwip_data(struct lwip_sock *sock, int32_t flags, u8_t apiflags); + void read_recv_list(void); + void add_recv_list(int32_t fd); ++void stack_eventlist_count(struct rpc_msg *msg); ++void stack_wakeuplist_count(struct rpc_msg *msg); + void get_lwip_conntable(struct rpc_msg *msg); + void get_lwip_connnum(struct rpc_msg *msg); + void stack_recvlist_count(struct rpc_msg *msg); +@@ -42,5 +44,6 @@ void gazelle_free_pbuf(struct pbuf *pbuf); + ssize_t sendmsg_to_stack(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); ++void add_self_event(struct lwip_sock *sock, uint32_t events); + + #endif +diff --git a/src/lstack/include/lstack_protocol_stack.h b/src/lstack/include/lstack_protocol_stack.h +index f289465..dd7633b 100644 +--- a/src/lstack/include/lstack_protocol_stack.h ++++ b/src/lstack/include/lstack_protocol_stack.h +@@ -51,6 +51,8 @@ struct protocol_stack { + + struct list_node recv_list; + struct list_node listen_list; ++ struct list_node event_list; ++ struct list_node *wakeup_list; + + struct gazelle_stat_pkts stats; + struct gazelle_stack_latency latency; +diff --git a/src/lstack/include/lstack_thread_rpc.h b/src/lstack/include/lstack_thread_rpc.h +index 1365234..cffb273 100644 +--- a/src/lstack/include/lstack_thread_rpc.h ++++ b/src/lstack/include/lstack_thread_rpc.h +@@ -50,9 +50,12 @@ struct rpc_msg { + struct protocol_stack; + void poll_rpc_msg(struct protocol_stack *stack); + void rpc_call_replenish_idlembuf(struct protocol_stack *stack); ++void rpc_call_addevent(struct protocol_stack *stack, void *sock); + int32_t rpc_call_msgcnt(struct protocol_stack *stack); + int32_t rpc_call_shadow_fd(struct protocol_stack *stack, int32_t fd, const struct sockaddr *addr, socklen_t addrlen); + int32_t rpc_call_recvlistcnt(struct protocol_stack *stack); ++int32_t rpc_call_eventlistcnt(struct protocol_stack *stack); ++int32_t rpc_call_wakeuplistcnt(struct protocol_stack *stack); + int32_t rpc_call_thread_regphase1(struct protocol_stack *stack, void *conn); + int32_t rpc_call_thread_regphase2(struct protocol_stack *stack, void *conn); + int32_t rpc_call_conntable(struct protocol_stack *stack, void *conn_table, uint32_t max_conn); +diff --git a/src/lstack/include/lstack_weakup.h b/src/lstack/include/lstack_weakup.h +index f334a0f..8f7fca2 100644 +--- a/src/lstack/include/lstack_weakup.h ++++ b/src/lstack/include/lstack_weakup.h +@@ -22,55 +22,93 @@ struct weakup_poll { + sem_t event_sem; + struct lwip_sock *sock_list[EPOLL_MAX_EVENTS]; + struct rte_ring *event_ring; ++ struct rte_ring *self_ring; + }; + + #define WEAKUP_MAX (32) + +-static inline __attribute__((always_inline)) void weakup_attach_sock(struct lwip_sock *sock) ++static inline void wakeup_list_sock(struct list_node *wakeup_list) + { +- struct list_node *list = &(sock->attach_list); + struct list_node *node, *temp; +- struct lwip_sock *attach_sock; +- int32_t ret; + +- list_for_each_safe(node, temp, list) { +- attach_sock = container_of(node, struct lwip_sock, attach_list); +- if (attach_sock->weakup == NULL) { ++ list_for_each_safe(node, temp, wakeup_list) { ++ struct lwip_sock *sock = container_of(node, struct lwip_sock, wakeup_list); ++ ++ struct weakup_poll *weakup = sock->weakup; ++ struct protocol_stack *stack = sock->stack; ++ if (weakup == NULL || stack == NULL) { + continue; + } + +- ret = rte_ring_mp_enqueue(attach_sock->weakup->event_ring, (void *)attach_sock); ++ int32_t ret = rte_ring_mp_enqueue(weakup->event_ring, (void *)sock); + if (ret == 0) { +- sem_post(&attach_sock->weakup->event_sem); +- attach_sock->stack->stats.lwip_events++; ++ list_del_node_init(&sock->event_list); ++ sem_post(&weakup->event_sem); ++ stack->stats.lwip_events++; ++ } else { ++ break; + } + } + } + +-static inline __attribute__((always_inline)) void weakup_thread(struct rte_ring *weakup_ring) ++static inline int32_t weakup_attach_sock(struct list_node *attach_list) ++{ ++ struct list_node *node, *temp; ++ int32_t wakeuped = -1; ++ ++ list_for_each_safe(node, temp, attach_list) { ++ struct lwip_sock *sock = container_of(node, struct lwip_sock, attach_list); ++ ++ struct weakup_poll *weakup = sock->weakup; ++ struct protocol_stack *stack = sock->stack; ++ if (weakup == NULL || stack == NULL) { ++ continue; ++ } ++ ++ int32_t ret = rte_ring_mp_enqueue(weakup->event_ring, (void *)sock); ++ if (ret == 0) { ++ sem_post(&weakup->event_sem); ++ stack->stats.lwip_events++; ++ wakeuped = 0; ++ } ++ } ++ ++ return wakeuped; ++} ++ ++static inline void weakup_thread(struct rte_ring *weakup_ring, struct list_node *wakeup_list) + { + struct lwip_sock *sock; +- int32_t ret; + + for (uint32_t i = 0; i < WEAKUP_MAX; ++i) { +- ret = rte_ring_sc_dequeue(weakup_ring, (void **)&sock); ++ int32_t ret = rte_ring_sc_dequeue(weakup_ring, (void **)&sock); + if (ret != 0) { + break; + } + +- ret = rte_ring_mp_enqueue(sock->weakup->event_ring, (void *)sock); ++ struct weakup_poll *weakup = sock->weakup; ++ struct protocol_stack *stack = sock->stack; ++ if (weakup == NULL || stack == NULL) { ++ continue; ++ } ++ ++ ret = rte_ring_mp_enqueue(weakup->event_ring, (void *)sock); + if (ret == 0) { +- sem_post(&sock->weakup->event_sem); +- sock->stack->stats.lwip_events++; ++ sem_post(&weakup->event_sem); ++ stack->stats.lwip_events++; + } + + /* listen notice attach sock */ ++ int32_t wakeuped = -1; + if (!list_is_empty(&sock->attach_list)) { +- weakup_attach_sock(sock); ++ wakeuped = weakup_attach_sock(&sock->attach_list); + } + +- /* event_ring of attach sock may have idle elem */ +- if (ret != 0) { ++ /* notice any epoll enough */ ++ if (ret != 0 && wakeuped != 0) { ++ if (list_is_empty(&sock->wakeup_list)) { ++ list_add_node(wakeup_list, &sock->wakeup_list); ++ } + break; + } + } +@@ -79,13 +117,7 @@ static inline __attribute__((always_inline)) void weakup_thread(struct rte_ring + static inline __attribute__((always_inline)) + int weakup_enqueue(struct rte_ring *weakup_ring, struct lwip_sock *sock) + { +- int ret = rte_ring_sp_enqueue(weakup_ring, (void *)sock); +- if (ret < 0) { +- LSTACK_LOG(ERR, LSTACK, "tid %d, failed\n", gettid()); +- return -1; +- } +- +- return 0; ++ return rte_ring_sp_enqueue(weakup_ring, (void *)sock); + } + + #endif +diff --git a/src/ltran/ltran_dfx.c b/src/ltran/ltran_dfx.c +index 451f527..66d6053 100644 +--- a/src/ltran/ltran_dfx.c ++++ b/src/ltran/ltran_dfx.c +@@ -567,14 +567,20 @@ static void show_lstack_stats(struct gazelle_stack_dfx_data *lstack_stat) + printf("weakup_events: %-14"PRIu64" ", lstack_stat->data.pkts.weakup_events); + printf("lwip_events: %-16"PRIu64" ", lstack_stat->data.pkts.lwip_events); + printf("app_events: %-17"PRIu64"\n", lstack_stat->data.pkts.app_events); ++ printf("epoll_pending: %-14"PRIu64" ", lstack_stat->data.pkts.epoll_pending); ++ printf("epoll_self_event: %-11"PRIu64" ", lstack_stat->data.pkts.epoll_self_event); ++ printf("remove_event: %-15"PRIu64" \n", lstack_stat->data.pkts.remove_event); + printf("read_events: %-16"PRIu64" ", lstack_stat->data.pkts.read_events); + printf("write_events: %-15"PRIu64" ", lstack_stat->data.pkts.write_events); + printf("accept_events: %-14"PRIu64" \n", lstack_stat->data.pkts.accept_events); +- printf("call_msg: %-19"PRIu64" ", lstack_stat->data.pkts.call_msg_cnt); + printf("read_null: %-18"PRIu64" ", lstack_stat->data.pkts.read_null); +- printf("call_alloc_fail: %-12"PRIu64" \n", lstack_stat->data.pkts.call_alloc_fail); +- printf("remove_event: %-15"PRIu64" ", lstack_stat->data.pkts.remove_event); ++ printf("wakeup_list: %-16"PRIu64" ", lstack_stat->data.pkts.wakeup_list); ++ printf("event_list: %-17"PRIu64" \n", lstack_stat->data.pkts.event_list); + printf("send_self_rpc: %-14"PRIu64" ", lstack_stat->data.pkts.send_self_rpc); ++ printf("epoll_pending_call: %-9"PRIu64" ", lstack_stat->data.pkts.epoll_pending_call); ++ printf("epoll_self_call: %-12"PRIu64" \n", lstack_stat->data.pkts.epoll_self_call); ++ printf("call_msg: %-19"PRIu64" ", lstack_stat->data.pkts.call_msg_cnt); ++ printf("call_alloc_fail: %-12"PRIu64" ", lstack_stat->data.pkts.call_alloc_fail); + printf("call_null: %-18"PRIu64" \n", lstack_stat->data.pkts.call_null); + } + +@@ -866,8 +872,7 @@ static void gazelle_print_lstack_stat_snmp(void *buf, const struct gazelle_stat_ + + static void gazelle_print_lstack_stat_conn(void *buf, const struct gazelle_stat_msg_request *req_msg) + { +- int32_t ret; +- uint32_t i, unread_pkts; ++ uint32_t i; + struct in_addr rip; + struct in_addr lip; + char str_ip[GAZELLE_SUBNET_LENGTH_MAX] = {0}; +@@ -878,30 +883,33 @@ static void gazelle_print_lstack_stat_conn(void *buf, const struct gazelle_stat_ + printf("Active Internet connections (servers and established)\n"); + do { + printf("\n------ stack tid: %6u ------\n", stat->tid); +- printf("No. Proto recv_cnt recv_ring in_send send_ring Local Address" ++ printf("No. Proto recv_cnt recv_ring in_send send_ring event self_event Local Address" + " Foreign Address State\n"); +- unread_pkts = 0; ++ uint32_t unread_pkts = 0; ++ uint32_t unsend_pkts = 0; + for (i = 0; i < conn->conn_num && i < GAZELLE_LSTACK_MAX_CONN; i++) { + struct gazelle_stat_lstack_conn_info *conn_info = &conn->conn_list[i]; + + rip.s_addr = conn_info->rip; + lip.s_addr = conn_info->lip; + if ((conn_info->state == GAZELLE_ACTIVE_LIST) || (conn_info->state == GAZELLE_TIME_WAIT_LIST)) { +- printf("%-6utcp %-10u%-11u%-9u%-11u%s:%hu\t%s:%hu\t%s\n", i, conn_info->recv_cnt, +- conn_info->recv_ring_cnt, conn_info->in_send, conn_info->send_ring_cnt, +- inet_ntop(AF_INET, &lip, str_ip, sizeof(str_ip)), conn_info->l_port, inet_ntop(AF_INET, &rip, +- str_rip, sizeof(str_rip)), conn_info->r_port, tcp_state_to_str(conn_info->tcp_sub_state)); ++ printf("%-6utcp %-10u%-11u%-9u%-11u%-7u%-12u%s:%hu\t%s:%hu\t%s\n", i, conn_info->recv_cnt, ++ conn_info->recv_ring_cnt, conn_info->in_send, conn_info->send_ring_cnt, conn_info->event_ring_cnt, ++ conn_info->self_ring_cnt, inet_ntop(AF_INET, &lip, str_ip, sizeof(str_ip)), conn_info->l_port, ++ inet_ntop(AF_INET, &rip, str_rip, sizeof(str_rip)), conn_info->r_port, ++ tcp_state_to_str(conn_info->tcp_sub_state)); + } else if (conn_info->state == GAZELLE_LISTEN_LIST) { +- printf("%-6utcp %-41u%s:%hu\t0.0.0.0:*\t\tLISTEN\n", i, conn_info->recv_cnt, ++ printf("%-6utcp %-60u%s:%hu\t0.0.0.0:*\t\tLISTEN\n", i, conn_info->recv_cnt, + inet_ntop(AF_INET, &lip, str_ip, sizeof(str_ip)), conn_info->l_port); + } else { + printf("Got unknow tcp conn::%s:%5hu, state:%u\n", + inet_ntop(AF_INET, &lip, str_ip, sizeof(str_ip)), conn_info->l_port, conn_info->state); + } + unread_pkts += conn_info->recv_ring_cnt; ++ unsend_pkts += conn_info->send_ring_cnt; + } + if (conn->conn_num > 0) { +- printf("Total unread pkts: %u \n", unread_pkts); ++ printf("Total unread pkts:%u unsend pkts:%u\n", unread_pkts, unsend_pkts); + } + + if (i < conn->total_conn_num) { +@@ -912,7 +920,7 @@ static void gazelle_print_lstack_stat_conn(void *buf, const struct gazelle_stat_ + if (stat->eof != 0) { + break; + } +- ret = dfx_stat_read_from_ltran(buf, sizeof(struct gazelle_stack_dfx_data), req_msg->stat_mode); ++ int32_t ret = dfx_stat_read_from_ltran(buf, sizeof(struct gazelle_stack_dfx_data), req_msg->stat_mode); + if (ret != GAZELLE_OK) { + return; + } +-- +1.8.3.1 + diff --git a/0025-fix-event-miss.patch b/0025-fix-event-miss.patch new file mode 100644 index 0000000..015fb32 --- /dev/null +++ b/0025-fix-event-miss.patch @@ -0,0 +1,420 @@ +From aa422a75961523de411ec849fd1f4e45da4477ac Mon Sep 17 00:00:00 2001 +From: wuchangsheng +Date: Mon, 14 Mar 2022 20:32:39 +0800 +Subject: [PATCH 25/34] fix event miss + +--- + src/common/gazelle_dfx_msg.h | 1 + + src/lstack/api/lstack_epoll.c | 6 ++-- + src/lstack/core/lstack_lwip.c | 54 ++++++++++++++++++++++++++---- + src/lstack/core/lstack_protocol_stack.c | 31 +++++++++++++++++ + src/lstack/core/lstack_stack_stat.c | 27 +++++++++++---- + src/lstack/core/lstack_thread_rpc.c | 38 ++++++--------------- + src/lstack/include/lstack_lwip.h | 2 ++ + src/lstack/include/lstack_protocol_stack.h | 1 + + src/lstack/include/lstack_thread_rpc.h | 1 + + src/lstack/include/lstack_weakup.h | 2 +- + src/ltran/ltran_dfx.c | 3 +- + 11 files changed, 120 insertions(+), 46 deletions(-) + +diff --git a/src/common/gazelle_dfx_msg.h b/src/common/gazelle_dfx_msg.h +index ae20436..de669f5 100644 +--- a/src/common/gazelle_dfx_msg.h ++++ b/src/common/gazelle_dfx_msg.h +@@ -95,6 +95,7 @@ struct gazelle_stat_pkts { + uint64_t epoll_pending_call; + uint64_t epoll_self_call; + uint64_t epoll_self_event; ++ uint64_t send_list; + }; + + /* same as define in lwip/stats.h - struct stats_mib2 */ +diff --git a/src/lstack/api/lstack_epoll.c b/src/lstack/api/lstack_epoll.c +index a686ddb..cf072b0 100644 +--- a/src/lstack/api/lstack_epoll.c ++++ b/src/lstack/api/lstack_epoll.c +@@ -61,7 +61,7 @@ static inline bool report_events(struct lwip_sock *sock, uint32_t event) + return true; + } + +- if (sock->have_event) { ++ if (__atomic_load_n(&sock->have_event, __ATOMIC_ACQUIRE)) { + return false; + } + +@@ -92,7 +92,7 @@ void add_epoll_event(struct netconn *conn, uint32_t event) + list_add_node(&sock->stack->event_list, &sock->event_list); + } + } else { +- sock->have_event = true; ++ __atomic_store_n(&sock->have_event, true, __ATOMIC_RELEASE); + sock->stack->stats.weakup_events++; + } + } +@@ -302,7 +302,7 @@ static int32_t get_lwip_events(struct weakup_poll *weakup, void *out, uint32_t m + if (sock->stack == NULL) { + return true; + } +- sock->have_event = false; ++ __atomic_store_n(&sock->have_event, false, __ATOMIC_RELEASE); + + if (remove_event(etype, weakup->sock_list, event_num, sock)) { + sock->stack->stats.remove_event++; +diff --git a/src/lstack/core/lstack_lwip.c b/src/lstack/core/lstack_lwip.c +index d55f1e6..d35a217 100644 +--- a/src/lstack/core/lstack_lwip.c ++++ b/src/lstack/core/lstack_lwip.c +@@ -112,6 +112,7 @@ void gazelle_init_sock(int32_t fd) + init_list_node(&sock->listen_list); + init_list_node(&sock->event_list); + init_list_node(&sock->wakeup_list); ++ init_list_node(&sock->send_list); + } + + void gazelle_clean_sock(int32_t fd) +@@ -130,6 +131,7 @@ void gazelle_clean_sock(int32_t fd) + list_del_node_init(&sock->listen_list); + list_del_node_init(&sock->event_list); + list_del_node_init(&sock->wakeup_list); ++ list_del_node_init(&sock->send_list); + } + + void gazelle_free_pbuf(struct pbuf *pbuf) +@@ -280,12 +282,12 @@ void add_self_event(struct lwip_sock *sock, uint32_t events) + + sock->events |= events; + +- if (sock->have_event) { ++ if (__atomic_load_n(&sock->have_event, __ATOMIC_ACQUIRE)) { + return; + } + + if (rte_ring_mp_enqueue(wakeup->self_ring, (void *)sock) == 0) { +- sock->have_event = true; ++ __atomic_store_n(&sock->have_event, true, __ATOMIC_RELEASE); + sem_post(&sock->weakup->event_sem); + stack->stats.epoll_self_event++; + } else { +@@ -346,6 +348,34 @@ ssize_t write_stack_data(struct lwip_sock *sock, const void *buf, size_t len) + return send_len; + } + ++void stack_send(struct rpc_msg *msg) ++{ ++ int32_t fd = msg->args[MSG_ARG_0].i; ++ int32_t flags = msg->args[MSG_ARG_2].i; ++ ++ struct protocol_stack *stack = get_protocol_stack(); ++ struct lwip_sock *sock = get_socket(fd); ++ if (sock == NULL) { ++ msg->result = -1; ++ return; ++ } ++ ++ msg->result = write_lwip_data(sock, fd, flags); ++ __atomic_store_n(&sock->have_rpc_send, false, __ATOMIC_RELEASE); ++ ++ if (msg->result >= 0 && rte_ring_count(sock->send_ring)) { ++ if (list_is_empty(&sock->send_list)) { ++ __atomic_store_n(&sock->have_rpc_send, true, __ATOMIC_RELEASE); ++ list_add_node(&stack->send_list, &sock->send_list); ++ sock->stack->stats.send_self_rpc++; ++ } ++ } ++ ++ if (rte_ring_free_count(sock->send_ring)) { ++ add_epoll_event(sock->conn, EPOLLOUT); ++ } ++} ++ + ssize_t read_lwip_data(struct lwip_sock *sock, int32_t flags, u8_t apiflags) + { + if (sock->conn->recvmbox == NULL) { +@@ -448,14 +478,19 @@ ssize_t gazelle_send(int32_t fd, const void *buf, size_t len, int32_t flags) + GAZELLE_RETURN(EINVAL); + } + ++ sock->send_flags = flags; + ssize_t send = write_stack_data(sock, buf, len); +- if (send < 0 || sock->have_rpc_send) { +- return send; ++ ++ ssize_t ret = 0; ++ if (!__atomic_load_n(&sock->have_rpc_send, __ATOMIC_ACQUIRE)) { ++ __atomic_store_n(&sock->have_rpc_send, true, __ATOMIC_RELEASE); ++ ret = rpc_call_send(fd, buf, len, flags); + } + +- sock->have_rpc_send = true; +- ssize_t ret = rpc_call_send(fd, buf, len, flags); +- return (ret < 0) ? ret : send; ++ if (send <= 0 || ret < 0) { ++ GAZELLE_RETURN(EAGAIN); ++ } ++ return send; + } + + ssize_t sendmsg_to_stack(int32_t s, const struct msghdr *message, int32_t flags) +@@ -743,6 +778,11 @@ void stack_eventlist_count(struct rpc_msg *msg) + msg->result = get_list_count(&get_protocol_stack()->event_list); + } + ++void stack_sendlist_count(struct rpc_msg *msg) ++{ ++ msg->result = get_list_count(&get_protocol_stack()->send_list); ++} ++ + void stack_recvlist_count(struct rpc_msg *msg) + { + msg->result = get_list_count(&get_protocol_stack()->recv_list); +diff --git a/src/lstack/core/lstack_protocol_stack.c b/src/lstack/core/lstack_protocol_stack.c +index 45649fe..4ba851a 100644 +--- a/src/lstack/core/lstack_protocol_stack.c ++++ b/src/lstack/core/lstack_protocol_stack.c +@@ -194,6 +194,7 @@ int32_t init_protocol_stack(void) + init_list_node(&stack->recv_list); + init_list_node(&stack->listen_list); + init_list_node(&stack->event_list); ++ init_list_node(&stack->send_list); + + stack_group->stacks[i] = stack; + } +@@ -324,6 +325,7 @@ static void report_stack_event(struct protocol_stack *stack) + sock = container_of(node, struct lwip_sock, event_list); + + if (weakup_enqueue(stack->weakup_ring, sock) == 0) { ++ __atomic_store_n(&sock->have_event, true, __ATOMIC_RELEASE); + list_del_node_init(&sock->event_list); + stack->stats.weakup_events++; + } else { +@@ -332,6 +334,33 @@ static void report_stack_event(struct protocol_stack *stack) + } + } + ++static void send_stack_list(struct protocol_stack *stack) ++{ ++ struct list_node *list = &(stack->send_list); ++ struct list_node *node, *temp; ++ struct lwip_sock *sock; ++ ++ list_for_each_safe(node, temp, list) { ++ sock = container_of(node, struct lwip_sock, send_list); ++ ++ if (sock->conn == NULL) { ++ continue; ++ } ++ ++ ssize_t ret = write_lwip_data(sock, sock->conn->socket, sock->send_flags); ++ __atomic_store_n(&sock->have_rpc_send, false, __ATOMIC_RELEASE); ++ if (ret >= 0 && rte_ring_count(sock->send_ring)) { ++ __atomic_store_n(&sock->have_rpc_send, true, __ATOMIC_RELEASE); ++ } else { ++ list_del_node_init(&sock->send_list); ++ } ++ ++ if (rte_ring_free_count(sock->send_ring)) { ++ add_epoll_event(sock->conn, EPOLLOUT); ++ } ++ } ++} ++ + static void* gazelle_stack_thread(void *arg) + { + struct protocol_stack *stack = (struct protocol_stack *)arg; +@@ -348,6 +377,8 @@ static void* gazelle_stack_thread(void *arg) + sys_timer_run(); + + report_stack_event(stack); ++ ++ send_stack_list(stack); + } + + return NULL; +diff --git a/src/lstack/core/lstack_stack_stat.c b/src/lstack/core/lstack_stack_stat.c +index b7b94e2..9a8fd08 100644 +--- a/src/lstack/core/lstack_stack_stat.c ++++ b/src/lstack/core/lstack_stack_stat.c +@@ -107,11 +107,22 @@ static void get_stack_stats(struct gazelle_stack_dfx_data *dfx, struct protocol_ + dfx->data.pkts.call_alloc_fail = stack_group->call_alloc_fail; + dfx->data.pkts.weakup_ring_cnt = rte_ring_count(stack->weakup_ring); + dfx->data.pkts.send_idle_ring_cnt = rte_ring_count(stack->send_idle_ring); +- dfx->data.pkts.call_msg_cnt = rpc_call_msgcnt(stack); +- dfx->data.pkts.recv_list = rpc_call_recvlistcnt(stack); +- dfx->data.pkts.event_list = rpc_call_eventlistcnt(stack); ++ ++ int32_t rpc_call_result = rpc_call_msgcnt(stack); ++ dfx->data.pkts.call_msg_cnt = (rpc_call_result < 0) ? 0 : rpc_call_result; ++ ++ rpc_call_result = rpc_call_recvlistcnt(stack); ++ dfx->data.pkts.recv_list = (rpc_call_result < 0) ? 0 : rpc_call_result; ++ ++ rpc_call_result = rpc_call_eventlistcnt(stack); ++ dfx->data.pkts.event_list = (rpc_call_result < 0) ? 0 : rpc_call_result; ++ ++ rpc_call_result = rpc_call_sendlistcnt(stack); ++ dfx->data.pkts.send_list = (rpc_call_result < 0) ? 0 : rpc_call_result; ++ + if (stack->wakeup_list) { +- dfx->data.pkts.wakeup_list = rpc_call_eventlistcnt(stack); ++ rpc_call_result = rpc_call_eventlistcnt(stack); ++ dfx->data.pkts.wakeup_list = (rpc_call_result < 0) ? 0 : rpc_call_result; + } + dfx->data.pkts.conn_num = stack->conn_num; + } +@@ -119,6 +130,8 @@ static void get_stack_stats(struct gazelle_stack_dfx_data *dfx, struct protocol_ + static void get_stack_dfx_data(struct gazelle_stack_dfx_data *dfx, struct protocol_stack *stack, + enum GAZELLE_STAT_MODE stat_mode) + { ++ int32_t rpc_call_result; ++ + switch (stat_mode) { + case GAZELLE_STAT_LSTACK_SHOW: + case GAZELLE_STAT_LSTACK_SHOW_RATE: +@@ -129,8 +142,10 @@ static void get_stack_dfx_data(struct gazelle_stack_dfx_data *dfx, struct protoc + sizeof(stack->lwip_stats->mib2)); + break; + case GAZELLE_STAT_LSTACK_SHOW_CONN: +- dfx->data.conn.conn_num = rpc_call_conntable(stack, dfx->data.conn.conn_list, GAZELLE_LSTACK_MAX_CONN); +- dfx->data.conn.total_conn_num = rpc_call_connnum(stack); ++ rpc_call_result = rpc_call_conntable(stack, dfx->data.conn.conn_list, GAZELLE_LSTACK_MAX_CONN); ++ dfx->data.conn.conn_num = (rpc_call_result < 0) ? 0 : rpc_call_result; ++ rpc_call_result = rpc_call_connnum(stack); ++ dfx->data.conn.total_conn_num = (rpc_call_result < 0) ? 0 : rpc_call_result; + break; + case GAZELLE_STAT_LSTACK_SHOW_LATENCY: + memcpy_s(&dfx->data.latency, sizeof(dfx->data.latency), &stack->latency, sizeof(stack->latency)); +diff --git a/src/lstack/core/lstack_thread_rpc.c b/src/lstack/core/lstack_thread_rpc.c +index 2fb24b4..c95f2c0 100644 +--- a/src/lstack/core/lstack_thread_rpc.c ++++ b/src/lstack/core/lstack_thread_rpc.c +@@ -197,6 +197,16 @@ int32_t rpc_call_eventlistcnt(struct protocol_stack *stack) + return rpc_sync_call(&stack->rpc_queue, stack->rpc_pool, msg); + } + ++int32_t rpc_call_sendlistcnt(struct protocol_stack *stack) ++{ ++ struct rpc_msg *msg = rpc_msg_alloc(stack, stack_sendlist_count); ++ if (msg == NULL) { ++ return -1; ++ } ++ ++ return rpc_sync_call(&stack->rpc_queue, stack->rpc_pool, msg); ++} ++ + int32_t rpc_call_recvlistcnt(struct protocol_stack *stack) + { + struct rpc_msg *msg = rpc_msg_alloc(stack, stack_recvlist_count); +@@ -442,34 +452,6 @@ int32_t rpc_call_ioctl(int fd, long cmd, void *argp) + return rpc_sync_call(&stack->rpc_queue, stack->rpc_pool, msg); + } + +-static void stack_send(struct rpc_msg *msg) +-{ +- int32_t fd = msg->args[MSG_ARG_0].i; +- int32_t flags = msg->args[MSG_ARG_2].i; +- +- struct protocol_stack *stack = get_protocol_stack(); +- struct lwip_sock *sock = get_socket(fd); +- if (sock == NULL) { +- msg->result = -1; +- msg->self_release = 0; +- return; +- } +- +- msg->result = write_lwip_data(sock, fd, flags); +- sock->have_rpc_send = false; +- +- if (msg->result >= 0 && rte_ring_count(sock->send_ring)) { +- sock->have_rpc_send = true; +- sock->stack->stats.send_self_rpc++; +- msg->self_release = 1; +- rpc_call(&stack->rpc_queue, msg); +- } +- +- if (rte_ring_free_count(sock->send_ring)) { +- add_epoll_event(sock->conn, EPOLLOUT); +- } +-} +- + ssize_t rpc_call_send(int fd, const void *buf, size_t len, int flags) + { + struct protocol_stack *stack = get_protocol_stack_by_fd(fd); +diff --git a/src/lstack/include/lstack_lwip.h b/src/lstack/include/lstack_lwip.h +index 87442cd..cfd454d 100644 +--- a/src/lstack/include/lstack_lwip.h ++++ b/src/lstack/include/lstack_lwip.h +@@ -33,11 +33,13 @@ ssize_t read_stack_data(int32_t fd, void *buf, size_t len, int32_t flags); + ssize_t read_lwip_data(struct lwip_sock *sock, int32_t flags, u8_t apiflags); + void read_recv_list(void); + void add_recv_list(int32_t fd); ++void stack_sendlist_count(struct rpc_msg *msg); + void stack_eventlist_count(struct rpc_msg *msg); + void stack_wakeuplist_count(struct rpc_msg *msg); + void get_lwip_conntable(struct rpc_msg *msg); + void get_lwip_connnum(struct rpc_msg *msg); + void stack_recvlist_count(struct rpc_msg *msg); ++void stack_send(struct rpc_msg *msg); + void stack_replenish_send_idlembuf(struct protocol_stack *stack); + int32_t gazelle_alloc_pktmbuf(struct rte_mempool *pool, struct rte_mbuf **mbufs, uint32_t num); + void gazelle_free_pbuf(struct pbuf *pbuf); +diff --git a/src/lstack/include/lstack_protocol_stack.h b/src/lstack/include/lstack_protocol_stack.h +index dd7633b..5b95dc9 100644 +--- a/src/lstack/include/lstack_protocol_stack.h ++++ b/src/lstack/include/lstack_protocol_stack.h +@@ -52,6 +52,7 @@ struct protocol_stack { + struct list_node recv_list; + struct list_node listen_list; + struct list_node event_list; ++ struct list_node send_list; + struct list_node *wakeup_list; + + struct gazelle_stat_pkts stats; +diff --git a/src/lstack/include/lstack_thread_rpc.h b/src/lstack/include/lstack_thread_rpc.h +index cffb273..76ba36a 100644 +--- a/src/lstack/include/lstack_thread_rpc.h ++++ b/src/lstack/include/lstack_thread_rpc.h +@@ -55,6 +55,7 @@ int32_t rpc_call_msgcnt(struct protocol_stack *stack); + int32_t rpc_call_shadow_fd(struct protocol_stack *stack, int32_t fd, const struct sockaddr *addr, socklen_t addrlen); + int32_t rpc_call_recvlistcnt(struct protocol_stack *stack); + int32_t rpc_call_eventlistcnt(struct protocol_stack *stack); ++int32_t rpc_call_sendlistcnt(struct protocol_stack *stack); + int32_t rpc_call_wakeuplistcnt(struct protocol_stack *stack); + int32_t rpc_call_thread_regphase1(struct protocol_stack *stack, void *conn); + int32_t rpc_call_thread_regphase2(struct protocol_stack *stack, void *conn); +diff --git a/src/lstack/include/lstack_weakup.h b/src/lstack/include/lstack_weakup.h +index 8f7fca2..4f6321e 100644 +--- a/src/lstack/include/lstack_weakup.h ++++ b/src/lstack/include/lstack_weakup.h +@@ -16,7 +16,7 @@ + #include + #include "lstack_dpdk.h" + +-#define EPOLL_MAX_EVENTS 256 ++#define EPOLL_MAX_EVENTS 512 + + struct weakup_poll { + sem_t event_sem; +diff --git a/src/ltran/ltran_dfx.c b/src/ltran/ltran_dfx.c +index 66d6053..a575c33 100644 +--- a/src/ltran/ltran_dfx.c ++++ b/src/ltran/ltran_dfx.c +@@ -582,6 +582,7 @@ static void show_lstack_stats(struct gazelle_stack_dfx_data *lstack_stat) + printf("call_msg: %-19"PRIu64" ", lstack_stat->data.pkts.call_msg_cnt); + printf("call_alloc_fail: %-12"PRIu64" ", lstack_stat->data.pkts.call_alloc_fail); + printf("call_null: %-18"PRIu64" \n", lstack_stat->data.pkts.call_null); ++ printf("send_list: %-18"PRIu64" \n", lstack_stat->data.pkts.send_list); + } + + static void gazelle_print_lstack_stat_detail(struct gazelle_stack_dfx_data *lstack_stat, +@@ -884,7 +885,7 @@ static void gazelle_print_lstack_stat_conn(void *buf, const struct gazelle_stat_ + do { + printf("\n------ stack tid: %6u ------\n", stat->tid); + printf("No. Proto recv_cnt recv_ring in_send send_ring event self_event Local Address" +- " Foreign Address State\n"); ++ " Foreign Address State\n"); + uint32_t unread_pkts = 0; + uint32_t unsend_pkts = 0; + for (i = 0; i < conn->conn_num && i < GAZELLE_LSTACK_MAX_CONN; i++) { +-- +1.8.3.1 + diff --git a/0026-get-fin-notice-app.patch b/0026-get-fin-notice-app.patch new file mode 100644 index 0000000..781db98 --- /dev/null +++ b/0026-get-fin-notice-app.patch @@ -0,0 +1,45 @@ +From a066142dfb38235ea46307e4b1d3395dcc2694a7 Mon Sep 17 00:00:00 2001 +From: wuchangsheng +Date: Tue, 15 Mar 2022 17:47:42 +0800 +Subject: [PATCH 26/34] get fin notice app + +--- + src/lstack/api/lstack_epoll.c | 8 ++++++-- + 1 file changed, 6 insertions(+), 2 deletions(-) + +diff --git a/src/lstack/api/lstack_epoll.c b/src/lstack/api/lstack_epoll.c +index cf072b0..1f0aea8 100644 +--- a/src/lstack/api/lstack_epoll.c ++++ b/src/lstack/api/lstack_epoll.c +@@ -73,6 +73,11 @@ void add_epoll_event(struct netconn *conn, uint32_t event) + /* conn sock nerver null, because lwip call this func */ + struct lwip_sock *sock = get_socket(conn->socket); + ++ /* close_wait event should be (EPOLLRDHUP | EPOLLIN), but lwip is EPOLLERR */ ++ if (event == EPOLLERR && conn->pcb.tcp && conn->pcb.tcp->state == CLOSE_WAIT) { ++ event = EPOLLRDHUP | EPOLLIN | EPOLLERR; ++ } ++ + /* shadow_fd event notice listen_fd */ + if (sock->shadowed_sock) { + sock = sock->shadowed_sock; +@@ -286,7 +291,6 @@ static int32_t get_lwip_events(struct weakup_poll *weakup, void *out, uint32_t m + struct epoll_event *events = (struct epoll_event *)out; + struct pollfd *fds = (struct pollfd *)out; + +- + if (etype == TYPE_EPOLL) { + maxevents = LWIP_MIN(EPOLL_MAX_EVENTS, maxevents); + } +@@ -300,7 +304,7 @@ static int32_t get_lwip_events(struct weakup_poll *weakup, void *out, uint32_t m + } + /* close sock */ + if (sock->stack == NULL) { +- return true; ++ continue; + } + __atomic_store_n(&sock->have_event, false, __ATOMIC_RELEASE); + +-- +1.8.3.1 + diff --git a/0027-fix-parse-config.patch b/0027-fix-parse-config.patch new file mode 100644 index 0000000..6613bd3 --- /dev/null +++ b/0027-fix-parse-config.patch @@ -0,0 +1,832 @@ +From d8c362e9a1af1c5ef50fbcda24fd4a127d591311 Mon Sep 17 00:00:00 2001 +From: jiangheng +Date: Wed, 16 Mar 2022 16:26:28 +0800 +Subject: [PATCH 27/34] fix parse config + +--- + src/common/dir.mk | 2 +- + src/common/dpdk_common.h | 4 +- + src/common/gazelle_parse_config.c | 64 ++++++++++++++++++++++++++++ + src/common/gazelle_parse_config.h | 20 +++++++++ + src/common/gazelle_reg_msg.h | 2 +- + src/lstack/Makefile | 2 +- + src/lstack/core/lstack_cfg.c | 67 +++++------------------------- + src/lstack/include/lstack_cfg.h | 14 +++---- + src/lstack/include/lstack_compiler.h | 6 +-- + src/lstack/include/lstack_control_plane.h | 6 +-- + src/lstack/include/lstack_dpdk.h | 8 ++-- + src/lstack/include/lstack_ethdev.h | 6 +-- + src/lstack/include/lstack_lockless_queue.h | 4 +- + src/lstack/include/lstack_lwip.h | 4 +- + src/lstack/include/lstack_protocol_stack.h | 4 +- + src/lstack/include/lstack_signal.h | 6 +-- + src/lstack/include/lstack_thread_rpc.h | 4 +- + src/lstack/include/lstack_vdev.h | 6 +-- + src/lstack/include/lstack_weakup.h | 4 +- + src/lstack/include/posix/lstack_epoll.h | 6 +-- + src/lstack/include/posix/lstack_fcntl.h | 6 +-- + src/lstack/include/posix/lstack_fork.h | 6 +-- + src/lstack/include/posix/lstack_socket.h | 6 +-- + src/lstack/include/posix/lstack_unistd.h | 6 +-- + src/lstack/netif/lstack_ethdev.c | 12 ------ + src/ltran/CMakeLists.txt | 3 +- + src/ltran/ltran_base.h | 2 +- + src/ltran/ltran_config.c | 5 ++- + src/ltran/ltran_ethdev.h | 2 +- + src/ltran/ltran_param.c | 33 +++------------ + 30 files changed, 162 insertions(+), 158 deletions(-) + create mode 100644 src/common/gazelle_parse_config.c + create mode 100644 src/common/gazelle_parse_config.h + +diff --git a/src/common/dir.mk b/src/common/dir.mk +index b61edf3..68a2b72 100644 +--- a/src/common/dir.mk ++++ b/src/common/dir.mk +@@ -8,6 +8,6 @@ + # PURPOSE. + # See the Mulan PSL v2 for more details. + +-SRC = dpdk_common.c ++SRC = dpdk_common.c gazelle_parse_config.c + $(eval $(call register_dir, ../common, $(SRC))) + +diff --git a/src/common/dpdk_common.h b/src/common/dpdk_common.h +index e9cacc3..6137bcb 100644 +--- a/src/common/dpdk_common.h ++++ b/src/common/dpdk_common.h +@@ -10,8 +10,8 @@ + * See the Mulan PSL v2 for more details. + */ + +-#ifndef __LIBOS_DPDK_COMMON_H__ +-#define __LIBOS_DPDK_COMMON_H__ ++#ifndef __GAZELLE_DPDK_COMMON_H__ ++#define __GAZELLE_DPDK_COMMON_H__ + + #include + +diff --git a/src/common/gazelle_parse_config.c b/src/common/gazelle_parse_config.c +new file mode 100644 +index 0000000..bbc8362 +--- /dev/null ++++ b/src/common/gazelle_parse_config.c +@@ -0,0 +1,64 @@ ++/* ++* Copyright (c) Huawei Technologies Co., Ltd. 2020-2021. All rights reserved. ++* gazelle is licensed under the Mulan PSL v2. ++* You can use this software according to the terms and conditions of the Mulan PSL v2. ++* You may obtain a copy of Mulan PSL v2 at: ++* http://license.coscl.org.cn/MulanPSL2 ++* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR ++* IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR ++* PURPOSE. ++* See the Mulan PSL v2 for more details. ++*/ ++ ++#include ++#include ++#include ++ ++#include "gazelle_parse_config.h" ++ ++static int32_t parse_str_data(char *args, uint32_t *array, int32_t array_size) ++{ ++ const char *delim = "-"; ++ char *elem = NULL; ++ char *next_token = NULL; ++ char *endptr = NULL; ++ int32_t cnt = 0; ++ int64_t start, end; ++ ++ elem = strtok_s(args, delim, &next_token); ++ start = strtol(elem, &endptr, 0); ++ ++ elem = strtok_s(NULL, delim, &next_token); ++ if (elem == NULL) { ++ /* just a single data */ ++ array[cnt++] = start; ++ return cnt; ++ } ++ end = strtol(elem, &endptr, 0); ++ ++ for (int64_t i = start; i <= end && cnt < array_size; i++) { ++ if (i < 0 || i > UINT_MAX) { ++ break; ++ } ++ array[cnt++] = i; ++ } ++ ++ return cnt; ++} ++ ++/* support '-' and ',' */ ++int32_t separate_str_to_array(char *args, uint32_t *array, int32_t array_size) ++{ ++ const char *delim = ","; ++ char *elem = NULL; ++ char *next_token = NULL; ++ int32_t cnt = 0; ++ ++ elem = strtok_s(args, delim, &next_token); ++ while (elem != NULL && cnt < array_size) { ++ cnt += parse_str_data(elem, &array[cnt], array_size - cnt); ++ elem = strtok_s(NULL, delim, &next_token); ++ } ++ ++ return cnt; ++} +diff --git a/src/common/gazelle_parse_config.h b/src/common/gazelle_parse_config.h +new file mode 100644 +index 0000000..0f86d80 +--- /dev/null ++++ b/src/common/gazelle_parse_config.h +@@ -0,0 +1,20 @@ ++/* ++* Copyright (c) Huawei Technologies Co., Ltd. 2020-2021. All rights reserved. ++* gazelle is licensed under the Mulan PSL v2. ++* You can use this software according to the terms and conditions of the Mulan PSL v2. ++* You may obtain a copy of Mulan PSL v2 at: ++* http://license.coscl.org.cn/MulanPSL2 ++* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR ++* IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR ++* PURPOSE. ++* See the Mulan PSL v2 for more details. ++*/ ++ ++#ifndef __GAZELLE_PARSE_CONFIG__ ++#define __GAZELLE_PARSE_CONFIG__ ++ ++#include ++ ++int32_t separate_str_to_array(char *args, uint32_t *array, int32_t array_size); ++ ++#endif +\ No newline at end of file +diff --git a/src/common/gazelle_reg_msg.h b/src/common/gazelle_reg_msg.h +index fa8f319..ff846fd 100644 +--- a/src/common/gazelle_reg_msg.h ++++ b/src/common/gazelle_reg_msg.h +@@ -18,7 +18,7 @@ + #include + #include + +-#define GAZELLE_REG_SOCK_PATHNAME "/var/run/gazelle/libos_client.sock" ++#define GAZELLE_REG_SOCK_PATHNAME "/var/run/gazelle/gazelle_client.sock" + #define GAZELLE_RUN_DIR "/var/run/gazelle/" + #define GAZELLE_FILE_PERMISSION 0700 + +diff --git a/src/lstack/Makefile b/src/lstack/Makefile +index 7a888de..8fc2435 100644 +--- a/src/lstack/Makefile ++++ b/src/lstack/Makefile +@@ -27,7 +27,7 @@ INC = -I$(LSTACK_DIR)/include \ + -I$(LSTACK_DIR)/../common \ + -I$(LWIP_INCLUDE_FILE) + +-CFLAGS = $(OPTIMIZATION) -fno-strict-aliasing $(INC) -DUSE_LIBOS_MEM ++CFLAGS = $(OPTIMIZATION) -fno-strict-aliasing $(INC) + + ifeq ($(GAZELLE_COVERAGE_ENABLE), 1) + LDFLAGS += -fprofile-arcs -ftest-coverage +diff --git a/src/lstack/core/lstack_cfg.c b/src/lstack/core/lstack_cfg.c +index fcc1c0b..ca25b58 100644 +--- a/src/lstack/core/lstack_cfg.c ++++ b/src/lstack/core/lstack_cfg.c +@@ -33,6 +33,7 @@ + #include "gazelle_reg_msg.h" + #include "lstack_log.h" + #include "gazelle_base_func.h" ++#include "gazelle_parse_config.h" + #include "lstack_protocol_stack.h" + + #define DEFAULT_CONF_FILE "/etc/gazelle/lstack.conf" +@@ -189,35 +190,6 @@ static int32_t parse_devices(void) + return ret; + } + +-static int32_t turn_str_to_array(char *args, uint16_t *array, int32_t size) +-{ +- int32_t val; +- uint16_t cnt = 0; +- const char *delim = ","; +- char *elem = NULL; +- char *next_token = NULL; +- +- memset_s(array, sizeof(*array) * size, 0, sizeof(*array) * size); +- +- elem = strtok_s((char *)args, delim, &next_token); +- while (elem != NULL) { +- if (cnt >= size) { +- return -1; +- } +- +- val = atoi(elem); +- if (val < 0) { +- return -1; +- } +- array[cnt] = (uint16_t)val; +- cnt++; +- +- elem = strtok_s(NULL, delim, &next_token); +- } +- +- return cnt; +-} +- + static int32_t get_param_idx(int32_t argc, char **argv, const char *param) + { + int32_t ret; +@@ -241,9 +213,6 @@ static int32_t parse_stack_cpu_number(void) + const config_setting_t *num_cpus = NULL; + const char *args = NULL; + +- int32_t ret; +- int32_t idx; +- + num_cpus = config_lookup(&g_config, "num_cpus"); + if (num_cpus == NULL) { + return -EINVAL; +@@ -254,7 +223,7 @@ static int32_t parse_stack_cpu_number(void) + return -EINVAL; + } + +- idx = get_param_idx(g_config_params.dpdk_argc, g_config_params.dpdk_argv, OPT_BIND_CORELIST); ++ int32_t idx = get_param_idx(g_config_params.dpdk_argc, g_config_params.dpdk_argv, OPT_BIND_CORELIST); + if (idx < 0) { + g_config_params.dpdk_argv[g_config_params.dpdk_argc] = strdup(OPT_BIND_CORELIST); + g_config_params.dpdk_argc++; +@@ -263,11 +232,14 @@ static int32_t parse_stack_cpu_number(void) + g_config_params.dpdk_argc++; + } + +- ret = turn_str_to_array((char *)args, g_config_params.cpus, CFG_MAX_CPUS); +- if (ret <= 0) { ++ char *tmp_arg = strdup(args); ++ int32_t cnt = separate_str_to_array(tmp_arg, g_config_params.cpus, CFG_MAX_CPUS); ++ free(tmp_arg); ++ if (cnt <= 0 || cnt > CFG_MAX_CPUS) { + return -EINVAL; + } +- g_config_params.num_cpu = (uint16_t)ret; ++ ++ g_config_params.num_cpu = cnt; + get_protocol_stack_group()->stack_num = g_config_params.num_cpu; + + return 0; +@@ -368,7 +340,6 @@ int32_t init_stack_numa_cpuset(void) + return 0; + } + +-#ifdef USE_LIBOS_MEM + static int32_t gazelle_parse_base_virtaddr(const char *arg, uintptr_t *base_vaddr) + { + uint64_t viraddr; +@@ -389,14 +360,8 @@ static int32_t gazelle_parse_base_virtaddr(const char *arg, uintptr_t *base_vadd + static int32_t gazelle_parse_socket_mem(const char *arg, struct secondary_attach_arg *sec_attach_arg) + { + size_t mem_size = 0; +- uint8_t count = 0; + char socket_mem[PATH_MAX]; + +- const char *delim = ","; +- char *mem_elem = NULL; +- char *end = NULL; +- char *next_token = NULL; +- + errno = 0; + + if ((arg == NULL) || (sec_attach_arg == NULL)) { +@@ -408,22 +373,13 @@ static int32_t gazelle_parse_socket_mem(const char *arg, struct secondary_attach + return -1; + } + +- mem_elem = strtok_s(socket_mem, delim, &next_token); +- while (mem_elem != NULL) { +- if (count >= GAZELLE_MAX_NUMA_NODES) { +- return -1; +- } +- sec_attach_arg->socket_per_size[count] = strtoull(mem_elem, &end, BASE_DEC_SCALE); ++ int32_t count = separate_str_to_array(socket_mem, sec_attach_arg->socket_per_size, GAZELLE_MAX_NUMA_NODES); ++ for (uint32_t i = 0; i < count; i++) { + mem_size += sec_attach_arg->socket_per_size[count]; +- if ((errno != 0) || end == NULL || (*end != '\0')) +- return -1; +- +- mem_elem = strtok_s(NULL, delim, &next_token); +- count++; + } + mem_size *= 1024LL; + mem_size *= 1024LL; +- if (mem_size > (UINT64_MAX / 1024LL / 1024LL)) { ++ if (mem_size > (UINT64_MAX / 1024LL / 1024LL) || count > UINT8_MAX) { + return -1; + } + sec_attach_arg->socket_num = count; +@@ -663,7 +619,6 @@ free_dpdk_args: + GAZELLE_FREE(g_config_params.dpdk_argv); + return -EINVAL; + } +-#endif + + static int32_t parse_low_power_mode(void) + { +diff --git a/src/lstack/include/lstack_cfg.h b/src/lstack/include/lstack_cfg.h +index 1a59c6c..48b7e44 100644 +--- a/src/lstack/include/lstack_cfg.h ++++ b/src/lstack/include/lstack_cfg.h +@@ -10,8 +10,8 @@ + * See the Mulan PSL v2 for more details. + */ + +-#ifndef LIBOS_NET_CFG_H +-#define LIBOS_NET_CFG_H ++#ifndef _GAZELLE_NET_CFG_H_ ++#define _GAZELLE_NET_CFG_H_ + #include + + #include +@@ -53,7 +53,7 @@ + struct secondary_attach_arg { + uint8_t socket_num; + uint64_t socket_size; +- uint64_t socket_per_size[GAZELLE_MAX_NUMA_NODES]; ++ uint32_t socket_per_size[GAZELLE_MAX_NUMA_NODES]; + uintptr_t base_virtaddr; + char file_prefix[PATH_MAX]; + }; +@@ -64,9 +64,9 @@ struct cfg_params { + ip4_addr_t gateway_addr; + struct rte_ether_addr ethdev; + uint16_t num_cpu; +- uint16_t cpus[CFG_MAX_CPUS]; ++ uint32_t cpus[CFG_MAX_CPUS]; + uint16_t num_wakeup; +- uint16_t weakup[CFG_MAX_CPUS]; ++ uint32_t weakup[CFG_MAX_CPUS]; + uint8_t num_ports; + uint16_t ports[CFG_MAX_PORTS]; + char log_file[PATH_MAX]; +@@ -78,9 +78,7 @@ struct cfg_params { + bool kni_switch; + int dpdk_argc; + char **dpdk_argv; +-#ifdef USE_LIBOS_MEM + struct secondary_attach_arg sec_attach_arg; +-#endif + }; + + struct cfg_params *get_global_cfg_params(void); +@@ -98,4 +96,4 @@ int gazelle_copy_param(const char *param, bool is_double, + int match_host_addr(uint32_t ipv4); + int32_t init_stack_numa_cpuset(void); + +-#endif /* LIBOS_NET_CFG_H */ ++#endif /* GAZELLE_NET_CFG_H */ +diff --git a/src/lstack/include/lstack_compiler.h b/src/lstack/include/lstack_compiler.h +index 1db27ae..c4880a5 100644 +--- a/src/lstack/include/lstack_compiler.h ++++ b/src/lstack/include/lstack_compiler.h +@@ -10,8 +10,8 @@ + * See the Mulan PSL v2 for more details. + */ + +-#ifndef LIBOS_COMPILER_H +-#define LIBOS_COMPILER_H ++#ifndef _GAZELLE_COMPILER_H_ ++#define _GAZELLE_COMPILER_H_ + + #ifdef __GNUC__ + +@@ -43,4 +43,4 @@ + #define ACCESS_ONCE(x) (*(volatile typeof(x) *)&(x)) + #endif + +-#endif /* LIBOS_COMPILER_H */ ++#endif /* GAZELLE_COMPILER_H */ +diff --git a/src/lstack/include/lstack_control_plane.h b/src/lstack/include/lstack_control_plane.h +index 7c267e2..0af891a 100644 +--- a/src/lstack/include/lstack_control_plane.h ++++ b/src/lstack/include/lstack_control_plane.h +@@ -10,8 +10,8 @@ + * See the Mulan PSL v2 for more details. + */ + +-#ifndef LIBOS_CONTROL_PLANE_H +-#define LIBOS_CONTROL_PLANE_H ++#ifndef _GAZELLE_CONTROL_PLANE_H_ ++#define _GAZELLE_CONTROL_PLANE_H_ + + #include "lstack_thread_rpc.h" + +@@ -33,4 +33,4 @@ bool get_register_state(void); + void thread_register_phase1(struct rpc_msg *msg); + void thread_register_phase2(struct rpc_msg *msg); + +-#endif /* LIBOS_CONTROL_PLANE_H */ ++#endif /* GAZELLE_CONTROL_PLANE_H */ +diff --git a/src/lstack/include/lstack_dpdk.h b/src/lstack/include/lstack_dpdk.h +index 7b623a7..e76a9a6 100644 +--- a/src/lstack/include/lstack_dpdk.h ++++ b/src/lstack/include/lstack_dpdk.h +@@ -10,13 +10,11 @@ + * See the Mulan PSL v2 for more details. + */ + +-#ifndef LIBOS_DPDK_H +-#define LIBOS_DPDK_H ++#ifndef _GAZELLE_DPDK_H_ ++#define _GAZELLE_DPDK_H_ + +-#ifdef USE_LIBOS_MEM + #include + #include +-#endif + + #include + #include "lstack_lockless_queue.h" +@@ -70,4 +68,4 @@ int dpdk_ethdev_start(void); + void dpdk_skip_nic_init(void); + int32_t dpdk_init_lstack_kni(void); + +-#endif /* LIBOS_DPDK_H */ ++#endif /* GAZELLE_DPDK_H */ +diff --git a/src/lstack/include/lstack_ethdev.h b/src/lstack/include/lstack_ethdev.h +index 29e0c23..573a413 100644 +--- a/src/lstack/include/lstack_ethdev.h ++++ b/src/lstack/include/lstack_ethdev.h +@@ -10,8 +10,8 @@ + * See the Mulan PSL v2 for more details. + */ + +-#ifndef __LIBOS_ETHDEV_H__ +-#define __LIBOS_ETHDEV_H__ ++#ifndef __GAZELLE_ETHDEV_H__ ++#define __GAZELLE_ETHDEV_H__ + + #include + #include +@@ -34,4 +34,4 @@ int32_t eth_dev_poll(void); + uint32_t eth_get_flow_cnt(void); + void eth_dev_recv(struct rte_mbuf *mbuf); + +-#endif /* __LIBOS_ETHDEV_H__ */ ++#endif /* __GAZELLE_ETHDEV_H__ */ +diff --git a/src/lstack/include/lstack_lockless_queue.h b/src/lstack/include/lstack_lockless_queue.h +index e015e93..c70b56a 100644 +--- a/src/lstack/include/lstack_lockless_queue.h ++++ b/src/lstack/include/lstack_lockless_queue.h +@@ -10,8 +10,8 @@ + * See the Mulan PSL v2 for more details. + */ + +-#ifndef __LIBOS_LOCKLESS_QUEUE_H__ +-#define __LIBOS_LOCKLESS_QUEUE_H__ ++#ifndef __GAZELLE_LOCKLESS_QUEUE_H__ ++#define __GAZELLE_LOCKLESS_QUEUE_H__ + + typedef struct lockless_queue_node { + struct lockless_queue_node *volatile next; +diff --git a/src/lstack/include/lstack_lwip.h b/src/lstack/include/lstack_lwip.h +index cfd454d..285095a 100644 +--- a/src/lstack/include/lstack_lwip.h ++++ b/src/lstack/include/lstack_lwip.h +@@ -10,8 +10,8 @@ + * See the Mulan PSL v2 for more details. + */ + +-#ifndef __LIBOS_LWIP_H__ +-#define __LIBOS_LWIP_H__ ++#ifndef __GAZELLE_LWIP_H__ ++#define __GAZELLE_LWIP_H__ + + #include "lstack_thread_rpc.h" + #include "lwipsock.h" +diff --git a/src/lstack/include/lstack_protocol_stack.h b/src/lstack/include/lstack_protocol_stack.h +index 5b95dc9..39052e1 100644 +--- a/src/lstack/include/lstack_protocol_stack.h ++++ b/src/lstack/include/lstack_protocol_stack.h +@@ -10,8 +10,8 @@ + * See the Mulan PSL v2 for more details. + */ + +-#ifndef __LIBOS_PROTOCOL_STACK_H__ +-#define __LIBOS_PROTOCOL_STACK_H__ ++#ifndef __GAZELLE_PROTOCOL_STACK_H__ ++#define __GAZELLE_PROTOCOL_STACK_H__ + + #include + #include +diff --git a/src/lstack/include/lstack_signal.h b/src/lstack/include/lstack_signal.h +index edc8de5..2541a37 100644 +--- a/src/lstack/include/lstack_signal.h ++++ b/src/lstack/include/lstack_signal.h +@@ -10,8 +10,8 @@ + * See the Mulan PSL v2 for more details. + */ + +-#ifndef _LIBOS_SIGNAL_ +-#define _LIBOS_SIGNAL_ ++#ifndef _GAZELLE_SIGNAL_ ++#define _GAZELLE_SIGNAL_ + + void lstack_signal_init(void); +-#endif // _LIBOS_SIGNAL_ ++#endif // _GAZELLE_SIGNAL_ +diff --git a/src/lstack/include/lstack_thread_rpc.h b/src/lstack/include/lstack_thread_rpc.h +index 76ba36a..20539d9 100644 +--- a/src/lstack/include/lstack_thread_rpc.h ++++ b/src/lstack/include/lstack_thread_rpc.h +@@ -10,8 +10,8 @@ + * See the Mulan PSL v2 for more details. + */ + +-#ifndef __LIBOS_THREAD_RPC_H__ +-#define __LIBOS_THREAD_RPC_H__ ++#ifndef __GAZELLE_THREAD_RPC_H__ ++#define __GAZELLE_THREAD_RPC_H__ + + #include + #include +diff --git a/src/lstack/include/lstack_vdev.h b/src/lstack/include/lstack_vdev.h +index 19b97f1..916b1e2 100644 +--- a/src/lstack/include/lstack_vdev.h ++++ b/src/lstack/include/lstack_vdev.h +@@ -10,8 +10,8 @@ + * See the Mulan PSL v2 for more details. + */ + +-#ifndef LIBOS_VDEV_H +-#define LIBOS_VDEV_H ++#ifndef _GAZELLE_VDEV_H_ ++#define _GAZELLE_VDEV_H_ + + #include "lstack_ethdev.h" + #include "gazelle_reg_msg.h" +@@ -33,4 +33,4 @@ struct eth_dev_ops; + void vdev_dev_ops_init(struct eth_dev_ops **dev_ops); + int vdev_reg_xmit(enum reg_ring_type type, struct gazelle_quintuple *qtuple); + +-#endif /* LIBOS_VDEV_H */ ++#endif /* _GAZELLE_VDEV_H_ */ +diff --git a/src/lstack/include/lstack_weakup.h b/src/lstack/include/lstack_weakup.h +index 4f6321e..b051b72 100644 +--- a/src/lstack/include/lstack_weakup.h ++++ b/src/lstack/include/lstack_weakup.h +@@ -10,8 +10,8 @@ + * See the Mulan PSL v2 for more details. + */ + +-#ifndef __LIBOS_WEAKUP_THREAD_H__ +-#define __LIBOS_WEAKUP_THREAD_H__ ++#ifndef __GAZELLE_WEAKUP_THREAD_H__ ++#define __GAZELLE_WEAKUP_THREAD_H__ + + #include + #include "lstack_dpdk.h" +diff --git a/src/lstack/include/posix/lstack_epoll.h b/src/lstack/include/posix/lstack_epoll.h +index c97978f..2b3cff4 100644 +--- a/src/lstack/include/posix/lstack_epoll.h ++++ b/src/lstack/include/posix/lstack_epoll.h +@@ -10,8 +10,8 @@ + * See the Mulan PSL v2 for more details. + */ + +-#ifndef LIBOS_EPOLL_H +-#define LIBOS_EPOLL_H ++#ifndef _GAZELLE_EPOLL_H_ ++#define _GAZELLE_EPOLL_H_ + + #ifdef __cplusplus + extern "C" { +@@ -26,4 +26,4 @@ int32_t lstack_poll(struct pollfd *fds, nfds_t nfds, int32_t timeout); + } + #endif + +-#endif /* LIBOS_EPOLL_H */ ++#endif /* _GAZELLE_EPOLL_H_ */ +diff --git a/src/lstack/include/posix/lstack_fcntl.h b/src/lstack/include/posix/lstack_fcntl.h +index b3d6797..d1087a6 100644 +--- a/src/lstack/include/posix/lstack_fcntl.h ++++ b/src/lstack/include/posix/lstack_fcntl.h +@@ -10,8 +10,8 @@ + * See the Mulan PSL v2 for more details. + */ + +-#ifndef LIBOS_FCNTL_H +-#define LIBOS_FCNTL_H ++#ifndef _GAZELLE_FCNTL_H_ ++#define _GAZELLE_FCNTL_H_ + + #ifdef __cplusplus + extern "C" { +@@ -24,5 +24,5 @@ int lwip_ioctl(int s, int cmd, ...); + } + #endif + +-#endif /* LIBOS_FCNTL_H */ ++#endif /* _GAZELLE_FCNTL_H_ */ + +diff --git a/src/lstack/include/posix/lstack_fork.h b/src/lstack/include/posix/lstack_fork.h +index 049903a..939534a 100644 +--- a/src/lstack/include/posix/lstack_fork.h ++++ b/src/lstack/include/posix/lstack_fork.h +@@ -10,8 +10,8 @@ + * See the Mulan PSL v2 for more details. + */ + +-#ifndef _LIBOS_FORK_ +-#define _LIBOS_FORK_ ++#ifndef _GAZELLE_FORK_ ++#define _GAZELLE_FORK_ + + pid_t lstack_fork(void); +-#endif // _LIBOS_FORK_ ++#endif // _GAZELLE_FORK_ +diff --git a/src/lstack/include/posix/lstack_socket.h b/src/lstack/include/posix/lstack_socket.h +index 6a44d41..776a6ab 100644 +--- a/src/lstack/include/posix/lstack_socket.h ++++ b/src/lstack/include/posix/lstack_socket.h +@@ -10,8 +10,8 @@ + * See the Mulan PSL v2 for more details. + */ + +-#ifndef LIBOS_SOCKET_H +-#define LIBOS_SOCKET_H ++#ifndef _GAZELLE_SOCKET_H_ ++#define _GAZELLE_SOCKET_H_ + + #ifdef __cplusplus + extern "C" { +@@ -40,4 +40,4 @@ ssize_t lwip_recv(int s, void *mem, size_t len, int flags); + } + #endif + +-#endif /* LIBOS_SOCKET_H */ ++#endif /* _GAZELLE_SOCKET_H_ */ +diff --git a/src/lstack/include/posix/lstack_unistd.h b/src/lstack/include/posix/lstack_unistd.h +index 8c57d3a..cdd46c9 100644 +--- a/src/lstack/include/posix/lstack_unistd.h ++++ b/src/lstack/include/posix/lstack_unistd.h +@@ -10,8 +10,8 @@ + * See the Mulan PSL v2 for more details. + */ + +-#ifndef LIBOS_UNISTD_H +-#define LIBOS_UNISTD_H ++#ifndef _GAZELLE_UNISTD_H_ ++#define _GAZELLE_UNISTD_H_ + + #include "lstack_fork.h" + #ifdef __cplusplus +@@ -24,4 +24,4 @@ int lstack_sigaction(int signum, const struct sigaction *act, struct sigaction * + } + #endif + +-#endif /* LIBOS_UNISTD_H */ ++#endif /* _GAZELLE_UNISTD_H_ */ +diff --git a/src/lstack/netif/lstack_ethdev.c b/src/lstack/netif/lstack_ethdev.c +index 026f545..c428bca 100644 +--- a/src/lstack/netif/lstack_ethdev.c ++++ b/src/lstack/netif/lstack_ethdev.c +@@ -10,20 +10,8 @@ + * See the Mulan PSL v2 for more details. + */ + +-#ifdef USE_LIBOS_MEM + #include + #include +-#else +-/* in dpdk 19.11 there is the following inclusion relationship +- * >> rte_ethdev.h +- * >> rte_eth_ctrl.h +- * >> rte_flow.h +- * >> rte_ip.h +- * >> netinet/ip.h +- * avoid conflicts with netinet/ip.h +- */ +-#include +-#endif + + #include + #include +diff --git a/src/ltran/CMakeLists.txt b/src/ltran/CMakeLists.txt +index 8662d7c..c21d88a 100644 +--- a/src/ltran/CMakeLists.txt ++++ b/src/ltran/CMakeLists.txt +@@ -23,7 +23,8 @@ endif($ENV{GAZELLE_COVERAGE_ENABLE}) + + add_executable(ltran main.c ltran_param.c ltran_config.c ltran_ethdev.c ltran_stat.c ltran_errno.c + ltran_monitor.c ltran_instance.c ltran_stack.c ltran_tcp_conn.c ltran_tcp_sock.c +- ltran_forward.c ltran_timer.c ${COMMON_DIR}/gazelle_dfx_msg.c ${COMMON_DIR}/dpdk_common.c) ++ ltran_forward.c ltran_timer.c ${COMMON_DIR}/gazelle_dfx_msg.c ${COMMON_DIR}/dpdk_common.c ++ ${COMMON_DIR}/gazelle_parse_config.c) + + target_include_directories(ltran PRIVATE ${COMMON_DIR} ${PROJECT_SOURCE_DIR}) + target_compile_options(ltran PRIVATE -march=native -fno-strict-aliasing -D__ARM_FEATURE_CRC32=1 -DRTE_MACHINE_CPUFLAG_NEON +diff --git a/src/ltran/ltran_base.h b/src/ltran/ltran_base.h +index 0a284bc..4663257 100644 +--- a/src/ltran/ltran_base.h ++++ b/src/ltran/ltran_base.h +@@ -94,6 +94,6 @@ + + #define GAZELLE_INET_ADDRSTRLEN 16 + +-#define GAZELLE_DFX_SOCK_PATHNAME "/var/run/gazelle/libos_cmd.sock" ++#define GAZELLE_DFX_SOCK_PATHNAME "/var/run/gazelle/gazelle_cmd.sock" + + #endif /* ifndef __GAZELLE_BASE_H__ */ +diff --git a/src/ltran/ltran_config.c b/src/ltran/ltran_config.c +index 366f89c..d9c1bd7 100644 +--- a/src/ltran/ltran_config.c ++++ b/src/ltran/ltran_config.c +@@ -10,13 +10,14 @@ + * See the Mulan PSL v2 for more details. + */ + +-#include "ltran_config.h" +- ++#include + #include + #include + #include + #include ++ + #include "ltran_log.h" ++#include "ltran_config.h" + + #define NO_ARGS 0 + #define HAS_ARGS 1 +diff --git a/src/ltran/ltran_ethdev.h b/src/ltran/ltran_ethdev.h +index 2a72704..de7cfbb 100644 +--- a/src/ltran/ltran_ethdev.h ++++ b/src/ltran/ltran_ethdev.h +@@ -23,7 +23,7 @@ struct port_info { + }; + + uint32_t get_bond_num(void); +-struct rte_kni* get_libos_kni(void); ++struct rte_kni* get_gazelle_kni(void); + void set_bond_num(const uint32_t bond_num); + struct port_info* get_port_info(void); + uint16_t* get_bond_port(void); +diff --git a/src/ltran/ltran_param.c b/src/ltran/ltran_param.c +index 44785bd..aafbeee 100644 +--- a/src/ltran/ltran_param.c ++++ b/src/ltran/ltran_param.c +@@ -22,6 +22,7 @@ + #include + + #include "ltran_log.h" ++#include "gazelle_parse_config.h" + #include "gazelle_base_func.h" + + #define HEX_BASE 16 +@@ -310,7 +311,6 @@ static int32_t is_bond_port_prefix_valid(const char *port_str) + + static int32_t parse_bond_ports(const config_t *config, const char *key, struct ltran_config *ltran_config) + { +- const char *delim = ","; + const char *port_mask_str = NULL; + int32_t ret; + +@@ -334,32 +334,11 @@ static int32_t parse_bond_ports(const config_t *config, const char *key, struct + return GAZELLE_ERR; + } + +- char *end = NULL; +- char *tmp = NULL; +- unsigned long one_port_mask; +- char *token = strtok_s(port_str, delim, &tmp); +- while (token != NULL) { +- if (ltran_config->bond.port_num == GAZELLE_MAX_BOND_NUM) { +- free(port_str); +- gazelle_set_errno(GAZELLE_ERANGE); +- return GAZELLE_ERR; +- } +- +- one_port_mask = strtoul(token, &end, HEX_BASE); +- if ((end == NULL) || (*end != '\0')) { +- gazelle_set_errno(GAZELLE_ESTRTOUL); +- free(port_str); +- return GAZELLE_ERR; +- } +- if ((one_port_mask < GAZELLE_BOND_PORT_MASK_MIN) || (one_port_mask > GAZELLE_BOND_PORT_MASK_MAX)) { +- gazelle_set_errno(GAZELLE_ERANGE); +- free(port_str); +- return GAZELLE_ERR; +- } +- +- token = strtok_s(NULL, delim, &tmp); +- ltran_config->bond.portmask[ltran_config->bond.port_num] = (uint32_t)one_port_mask; +- ltran_config->bond.port_num++; ++ ltran_config->bond.port_num = separate_str_to_array(port_str, ltran_config->bond.portmask, GAZELLE_MAX_BOND_NUM); ++ if (ltran_config->bond.port_num >= GAZELLE_MAX_BOND_NUM) { ++ free(port_str); ++ gazelle_set_errno(GAZELLE_ERANGE); ++ return GAZELLE_ERR; + } + + free(port_str); +-- +1.8.3.1 + diff --git a/0028-fix-lstack-show-latency.patch b/0028-fix-lstack-show-latency.patch new file mode 100644 index 0000000..7afb165 --- /dev/null +++ b/0028-fix-lstack-show-latency.patch @@ -0,0 +1,60 @@ +From 53969ac0be85346d2abd776c66d4ff244c9f5da7 Mon Sep 17 00:00:00 2001 +From: wuchangsheng +Date: Mon, 14 Mar 2022 22:41:57 +0800 +Subject: [PATCH 28/34] fix lstack show latency + +--- + src/lstack/core/lstack_init.c | 6 ++++++ + src/lstack/core/lstack_stack_stat.c | 5 +++++ + src/ltran/ltran_dfx.c | 2 -- + 3 files changed, 11 insertions(+), 2 deletions(-) + +diff --git a/src/lstack/core/lstack_init.c b/src/lstack/core/lstack_init.c +index df60c4f..17195c8 100644 +--- a/src/lstack/core/lstack_init.c ++++ b/src/lstack/core/lstack_init.c +@@ -190,6 +190,12 @@ __attribute__((constructor)) void gazelle_network_init(void) + LSTACK_EXIT(1, "pthread_getaffinity_np failed\n"); + } + ++ /* to prevent crash , just ignore SIGPIPE when socket is closed */ ++ if (signal(SIGPIPE, SIG_IGN) == SIG_ERR) { ++ LSTACK_PRE_LOG(LSTACK_ERR, "signal error, errno:%d.", errno); ++ LSTACK_EXIT(1, "signal SIGPIPE SIG_IGN\n"); ++ } ++ + /* + * Phase 6: Init control plane and dpdk init */ + pthread_t tid; +diff --git a/src/lstack/core/lstack_stack_stat.c b/src/lstack/core/lstack_stack_stat.c +index 9a8fd08..1813906 100644 +--- a/src/lstack/core/lstack_stack_stat.c ++++ b/src/lstack/core/lstack_stack_stat.c +@@ -190,6 +190,11 @@ int32_t handle_stack_cmd(int32_t fd, enum GAZELLE_STAT_MODE stat_mode) + struct protocol_stack *stack = stack_group->stacks[i]; + get_stack_dfx_data(&dfx, stack, stat_mode); + ++ if (!use_ltran() && ++ (stat_mode == GAZELLE_STAT_LTRAN_START_LATENCY || stat_mode == GAZELLE_STAT_LTRAN_STOP_LATENCY)) { ++ continue; ++ } ++ + dfx.tid = stack->tid; + if (i == stack_group->stack_num - 1) { + dfx.eof = 1; +diff --git a/src/ltran/ltran_dfx.c b/src/ltran/ltran_dfx.c +index a575c33..3baa017 100644 +--- a/src/ltran/ltran_dfx.c ++++ b/src/ltran/ltran_dfx.c +@@ -1231,8 +1231,6 @@ int32_t main(int32_t argc, char *argv[]) + + if (!g_use_ltran) { + g_gazelle_dfx_tbl[GAZELLE_STAT_LSTACK_SHOW].recv_size = sizeof(struct gazelle_stack_dfx_data); +- g_gazelle_dfx_tbl[GAZELLE_STAT_LTRAN_START_LATENCY].recv_size =sizeof(struct gazelle_stack_dfx_data); +- g_gazelle_dfx_tbl[GAZELLE_STAT_LTRAN_STOP_LATENCY].recv_size =sizeof(struct gazelle_stack_dfx_data); + ret = check_cmd_support(req_msg, req_msg_num); + if (ret < 0) { + return -1; +-- +1.8.3.1 + diff --git a/0029-fix-code-check.patch b/0029-fix-code-check.patch new file mode 100644 index 0000000..4d2eebd --- /dev/null +++ b/0029-fix-code-check.patch @@ -0,0 +1,217 @@ +From ce1cdc5e656596b1b70171481a8ce5d523c0b20f Mon Sep 17 00:00:00 2001 +From: jiangheng +Date: Wed, 16 Mar 2022 17:30:25 +0800 +Subject: [PATCH 29/34] fix code check + +--- + src/common/dpdk_common.h | 1 - + src/lstack/core/lstack_cfg.c | 30 ++++++------------------------ + src/lstack/core/lstack_dpdk.c | 5 +++-- + src/lstack/core/lstack_lwip.c | 3 +-- + src/lstack/core/lstack_protocol_stack.c | 4 ++-- + src/lstack/netif/lstack_ethdev.c | 4 ++-- + src/lstack/netif/lstack_vdev.c | 2 +- + src/ltran/ltran_dfx.c | 4 ++-- + src/ltran/ltran_forward.c | 1 + + 9 files changed, 18 insertions(+), 36 deletions(-) + +diff --git a/src/common/dpdk_common.h b/src/common/dpdk_common.h +index 6137bcb..595e85f 100644 +--- a/src/common/dpdk_common.h ++++ b/src/common/dpdk_common.h +@@ -40,7 +40,6 @@ static __rte_always_inline void copy_mbuf(struct rte_mbuf *dst, struct rte_mbuf + + uint8_t *dst_data = rte_pktmbuf_mtod(dst, void*); + uint8_t *src_data = rte_pktmbuf_mtod(src, void*); +- + rte_memcpy(dst_data, src_data, data_len); + + // copy private date. +diff --git a/src/lstack/core/lstack_cfg.c b/src/lstack/core/lstack_cfg.c +index ca25b58..53712a8 100644 +--- a/src/lstack/core/lstack_cfg.c ++++ b/src/lstack/core/lstack_cfg.c +@@ -269,25 +269,7 @@ static int32_t numa_to_cpusnum(unsigned socket_id, uint32_t *cpulist, int32_t nu + return -1; + } + +- int32_t count = 0; +- char *elem = strtok(strbuf, "-"); +- while (elem && count < num) { +- while (elem && isspace(*elem)) { +- elem++; +- } +- if (elem == NULL) { +- LSTACK_LOG(ERR, LSTACK, "parse %s failed\n", path); +- return -1; +- } +- cpulist[count++] = (uint32_t)strtol(elem, NULL, 10); // 10 : decimal +- +- if (count % 2 == 0) { // 2 : even +- elem = strtok(NULL, "-"); +- } else { +- elem = strtok(NULL, ","); +- } +- } +- ++ int32_t count = separate_str_to_array(strbuf, cpulist, num); + return count; + } + +@@ -644,8 +626,6 @@ static int32_t parse_weakup_cpu_number(void) + const config_setting_t *cfg_args = NULL; + const char *args = NULL; + +- int32_t ret; +- + g_config_params.num_wakeup = 0; + + cfg_args = config_lookup(&g_config, "num_wakeup"); +@@ -658,11 +638,13 @@ static int32_t parse_weakup_cpu_number(void) + return 0; + } + +- ret = turn_str_to_array((char *)args, g_config_params.weakup, CFG_MAX_CPUS); +- if (ret <= 0) { ++ char *tmp_arg = strdup(args); ++ int32_t cnt = separate_str_to_array(tmp_arg, g_config_params.weakup, CFG_MAX_CPUS); ++ free(tmp_arg); ++ if (cnt <= 0 || cnt > CFG_MAX_CPUS) { + return -EINVAL; + } +- g_config_params.num_wakeup = (uint16_t)ret; ++ g_config_params.num_wakeup = cnt; + + return 0; + } +diff --git a/src/lstack/core/lstack_dpdk.c b/src/lstack/core/lstack_dpdk.c +index fb0e988..430c6e5 100644 +--- a/src/lstack/core/lstack_dpdk.c ++++ b/src/lstack/core/lstack_dpdk.c +@@ -223,6 +223,7 @@ int32_t create_shared_ring(struct protocol_stack *stack) + if (stack->send_idle_ring == NULL) { + return -1; + } ++ stack->in_replenish = 0; + + if (use_ltran()) { + stack->rx_ring = create_ring("RING_RX", VDEV_RX_QUEUE_SZ, RING_F_SP_ENQ | RING_F_SC_DEQ, stack->queue_id); +@@ -255,7 +256,7 @@ int32_t fill_mbuf_to_ring(struct rte_mempool *mempool, struct rte_ring *ring, ui + while (remain > 0) { + batch = LWIP_MIN(remain, FREE_RX_QUEUE_SZ); + +- ret = gazelle_alloc_pktmbuf(mempool, free_buf, batch); ++ ret = gazelle_alloc_pktmbuf(mempool, free_buf, batch); + if (ret != 0) { + LSTACK_LOG(ERR, LSTACK, "cannot alloc mbuf for ring, count: %d ret=%d\n", (int32_t)batch, ret); + return -1; +@@ -339,7 +340,7 @@ static int eth_params_checksum(struct rte_eth_conf *conf, struct rte_eth_dev_inf + if (rx_ol_capa & DEV_RX_OFFLOAD_IPV4_CKSUM) { + #if CHECKSUM_CHECK_IP_HW + rx_ol |= DEV_RX_OFFLOAD_IPV4_CKSUM; +- LSTACK_LOG(INFO, LSTACK, "DEV_RX_OFFLOAD_IPV4_CKSUM\n"); ++ LSTACK_LOG(INFO, LSTACK, "DEV_RX_OFFLOAD_IPV4_CKSUM\n"); + #endif + } + +diff --git a/src/lstack/core/lstack_lwip.c b/src/lstack/core/lstack_lwip.c +index d35a217..636840f 100644 +--- a/src/lstack/core/lstack_lwip.c ++++ b/src/lstack/core/lstack_lwip.c +@@ -184,7 +184,6 @@ int32_t gazelle_alloc_pktmbuf(struct rte_mempool *pool, struct rte_mbuf **mbufs, + return ret; + } + +- + for (uint32_t i = 0; i < num; i++) { + pbuf_custom = mbuf_to_pbuf(mbufs[i]); + pbuf_custom->custom_free_function = gazelle_free_pbuf; +@@ -216,7 +215,7 @@ void stack_replenish_send_idlembuf(struct protocol_stack *stack) + uint32_t replenish_cnt = rte_ring_free_count(stack->send_idle_ring); + + for (uint32_t i = 0; i < replenish_cnt; i++) { +- struct pbuf *pbuf = lwip_alloc_pbuf(PBUF_TRANSPORT, MAX_PACKET_SZ - PBUF_TRANSPORT, PBUF_RAM); ++ struct pbuf *pbuf = lwip_alloc_pbuf(PBUF_TRANSPORT, MAX_PACKET_SZ - PBUF_TRANSPORT, PBUF_RAM); + if (pbuf == NULL) { + break; + } +diff --git a/src/lstack/core/lstack_protocol_stack.c b/src/lstack/core/lstack_protocol_stack.c +index 4ba851a..e297f7e 100644 +--- a/src/lstack/core/lstack_protocol_stack.c ++++ b/src/lstack/core/lstack_protocol_stack.c +@@ -686,8 +686,8 @@ void stack_broadcast_arp(struct rte_mbuf *mbuf, struct protocol_stack *cur_stack + if (cur_stack == stack) { + continue; + } +- +- ret = gazelle_alloc_pktmbuf(stack->rx_pktmbuf_pool, &mbuf_copy, 1); ++ ++ ret = gazelle_alloc_pktmbuf(stack->rx_pktmbuf_pool, &mbuf_copy, 1); + if (ret != 0) { + return; + } +diff --git a/src/lstack/netif/lstack_ethdev.c b/src/lstack/netif/lstack_ethdev.c +index c428bca..9cb9cb0 100644 +--- a/src/lstack/netif/lstack_ethdev.c ++++ b/src/lstack/netif/lstack_ethdev.c +@@ -45,7 +45,7 @@ void eth_dev_recv(struct rte_mbuf *mbuf) + len = (uint16_t)rte_pktmbuf_pkt_len(m); + payload = rte_pktmbuf_mtod(m, void *); + pc = mbuf_to_pbuf(m); +- pc->custom_free_function = gazelle_free_pbuf; ++ pc->custom_free_function = gazelle_free_pbuf; + next = pbuf_alloced_custom(PBUF_RAW, (uint16_t)len, PBUF_RAM, pc, payload, (uint16_t)len); + if (next == NULL) { + stack->stats.rx_allocmbuf_fail++; +@@ -139,7 +139,7 @@ static err_t eth_dev_output(struct netif *netif, struct pbuf *pbuf) + stack->stats.tx += sent_pkts; + if (sent_pkts < 1) { + stack->stats.tx_drop++; +- rte_pktmbuf_free(mbuf); ++ rte_pktmbuf_free(mbuf); + return ERR_MEM; + } + +diff --git a/src/lstack/netif/lstack_vdev.c b/src/lstack/netif/lstack_vdev.c +index a2f89fa..57d3bce 100644 +--- a/src/lstack/netif/lstack_vdev.c ++++ b/src/lstack/netif/lstack_vdev.c +@@ -47,7 +47,7 @@ static uint32_t ltran_rx_poll(struct protocol_stack *stack, struct rte_mbuf **pk + stack->rx_ring_used += rcvd_pkts; + if (unlikely(stack->rx_ring_used >= USED_RX_PKTS_WATERMARK)) { + uint32_t free_cnt = LWIP_MIN(stack->rx_ring_used, DPDK_PKT_BURST_SIZE); +- int32_t ret = gazelle_alloc_pktmbuf(stack->rx_pktmbuf_pool, (struct rte_mbuf **)free_buf, free_cnt); ++ int32_t ret = gazelle_alloc_pktmbuf(stack->rx_pktmbuf_pool, (struct rte_mbuf **)free_buf, free_cnt); + if (likely(ret == 0)) { + nr_pkts = rte_ring_en_enqueue_bulk(stack->rx_ring, (void **)free_buf, free_cnt); + stack->rx_ring_used -= nr_pkts; +diff --git a/src/ltran/ltran_dfx.c b/src/ltran/ltran_dfx.c +index 3baa017..8db5791 100644 +--- a/src/ltran/ltran_dfx.c ++++ b/src/ltran/ltran_dfx.c +@@ -111,8 +111,8 @@ static pid_t ltran_process_exist(void) + char line[LINE]; + FILE *cmd = popen("pidof ltran", "r"); + +- if(fgets(line, LINE, cmd) == NULL) { +- return 0; ++ if (fgets(line, LINE, cmd) == NULL) { ++ return 0; + } + + pid_t pid = strtoul(line, NULL, BASE_DEC_SCALE); +diff --git a/src/ltran/ltran_forward.c b/src/ltran/ltran_forward.c +index 9d1188e..b264ad3 100644 +--- a/src/ltran/ltran_forward.c ++++ b/src/ltran/ltran_forward.c +@@ -82,6 +82,7 @@ static __rte_always_inline void flush_rx_mbuf(struct gazelle_stack *stack, struc + calculate_ltran_latency(stack, src); + } + rte_pktmbuf_free(src); ++ src = NULL; + } + + static __rte_always_inline void backup_bufs_enque_rx_ring(struct gazelle_stack *stack) +-- +1.8.3.1 + diff --git a/0030-fix-accept-init-sock-faile.patch b/0030-fix-accept-init-sock-faile.patch new file mode 100644 index 0000000..fcadcd5 --- /dev/null +++ b/0030-fix-accept-init-sock-faile.patch @@ -0,0 +1,120 @@ +From 2da25e25b9553dfc014faaf9a3ebb869454615fd Mon Sep 17 00:00:00 2001 +From: wuchangsheng +Date: Tue, 15 Mar 2022 22:55:09 +0800 +Subject: [PATCH 30/34] fix accept init sock faile + +--- + src/lstack/core/lstack_lwip.c | 23 +++++++++++++++++++++-- + src/lstack/core/lstack_protocol_stack.c | 29 ++++++++++++++++++----------- + src/lstack/include/lstack_lwip.h | 1 + + 3 files changed, 40 insertions(+), 13 deletions(-) + +diff --git a/src/lstack/core/lstack_lwip.c b/src/lstack/core/lstack_lwip.c +index 636840f..9766a87 100644 +--- a/src/lstack/core/lstack_lwip.c ++++ b/src/lstack/core/lstack_lwip.c +@@ -657,19 +657,38 @@ static inline void clone_lwip_socket_opt(struct lwip_sock *dst_sock, struct lwip + dst_sock->conn->flags = src_sock->conn->flags; + } + ++int32_t gazelle_socket(int domain, int type, int protocol) ++{ ++ int32_t fd = lwip_socket(AF_INET, SOCK_STREAM, 0); ++ if (fd < 0) { ++ return fd; ++ } ++ ++ gazelle_init_sock(fd); ++ ++ struct lwip_sock *sock = get_socket(fd); ++ if (sock == NULL || sock->stack == NULL) { ++ lwip_close(fd); ++ gazelle_clean_sock(fd); ++ posix_api->close_fn(fd); ++ return -1; ++ } ++ ++ return fd; ++} ++ + void create_shadow_fd(struct rpc_msg *msg) + { + int32_t fd = msg->args[MSG_ARG_0].i; + struct sockaddr *addr = msg->args[MSG_ARG_1].p; + socklen_t addr_len = msg->args[MSG_ARG_2].socklen; + +- int32_t clone_fd = lwip_socket(AF_INET, SOCK_STREAM, 0); ++ int32_t clone_fd = gazelle_socket(AF_INET, SOCK_STREAM, 0); + if (clone_fd < 0) { + LSTACK_LOG(ERR, LSTACK, "clone socket failed clone_fd=%d errno=%d\n", clone_fd, errno); + msg->result = clone_fd; + return; + } +- gazelle_init_sock(clone_fd); + + struct lwip_sock *sock = get_socket_by_fd(fd); + struct lwip_sock *clone_sock = get_socket_by_fd(clone_fd); +diff --git a/src/lstack/core/lstack_protocol_stack.c b/src/lstack/core/lstack_protocol_stack.c +index e297f7e..3193eeb 100644 +--- a/src/lstack/core/lstack_protocol_stack.c ++++ b/src/lstack/core/lstack_protocol_stack.c +@@ -426,14 +426,10 @@ void stack_arp(struct rpc_msg *msg) + + void stack_socket(struct rpc_msg *msg) + { +- int32_t fd = lwip_socket(msg->args[MSG_ARG_0].i, msg->args[MSG_ARG_1].i, msg->args[MSG_ARG_2].i); +- msg->result = fd; +- if (fd < 0) { +- LSTACK_LOG(ERR, LSTACK, "tid %ld, %d socket failed\n", get_stack_tid(), fd); +- return; ++ msg->result = gazelle_socket(msg->args[MSG_ARG_0].i, msg->args[MSG_ARG_1].i, msg->args[MSG_ARG_2].i); ++ if (msg->result < 0) { ++ LSTACK_LOG(ERR, LSTACK, "tid %ld, %ld socket failed\n", get_stack_tid(), msg->result); + } +- +- gazelle_init_sock(fd); + } + + static inline bool is_real_close(int32_t fd) +@@ -589,11 +585,22 @@ void stack_accept(struct rpc_msg *msg) + } + fd = sock->attach_fd; + +- msg->result = lwip_accept(fd, msg->args[MSG_ARG_1].p, msg->args[MSG_ARG_2].p); +- if (msg->result <= 0) { +- LSTACK_LOG(ERR, LSTACK, "tid %ld, fd %d attach_fd %d failed %ld\n", get_stack_tid(), msg->args[MSG_ARG_0].i, +- fd, msg->result); ++ int32_t accept_fd = lwip_accept(fd, msg->args[MSG_ARG_1].p, msg->args[MSG_ARG_2].p); ++ if (accept_fd > 0) { ++ sock = get_socket(accept_fd); ++ if (sock && sock->stack) { ++ msg->result = accept_fd; ++ return; ++ } ++ ++ lwip_close(accept_fd); ++ gazelle_clean_sock(accept_fd); ++ posix_api->close_fn(accept_fd); + } ++ ++ LSTACK_LOG(ERR, LSTACK, "tid %ld, fd %d attach_fd %d failed %d\n", get_stack_tid(), msg->args[MSG_ARG_0].i, ++ fd, accept_fd); ++ msg->result = -1; + } + + void stack_connect(struct rpc_msg *msg) +diff --git a/src/lstack/include/lstack_lwip.h b/src/lstack/include/lstack_lwip.h +index 285095a..ffd3b80 100644 +--- a/src/lstack/include/lstack_lwip.h ++++ b/src/lstack/include/lstack_lwip.h +@@ -26,6 +26,7 @@ + void create_shadow_fd(struct rpc_msg *msg); + void listen_list_add_node(int32_t head_fd, int32_t add_fd); + void gazelle_init_sock(int32_t fd); ++int32_t gazelle_socket(int domain, int type, int protocol); + void gazelle_clean_sock(int32_t fd); + ssize_t write_lwip_data(struct lwip_sock *sock, int32_t fd, int32_t flags); + ssize_t write_stack_data(struct lwip_sock *sock, const void *buf, size_t len); +-- +1.8.3.1 + diff --git a/0031-fix-reuse-ip-listen-event-don-t-notice.patch b/0031-fix-reuse-ip-listen-event-don-t-notice.patch new file mode 100644 index 0000000..88ab038 --- /dev/null +++ b/0031-fix-reuse-ip-listen-event-don-t-notice.patch @@ -0,0 +1,153 @@ +From 40ac9666796bbc0cee5d52acfb14d6cc88a196b2 Mon Sep 17 00:00:00 2001 +From: wuchangsheng +Date: Wed, 16 Mar 2022 11:02:45 +0800 +Subject: [PATCH 31/34] fix reuse ip listen event don't notice + +--- + src/lstack/api/lstack_epoll.c | 61 +++++++++++++++++++++++-------------------- + 1 file changed, 33 insertions(+), 28 deletions(-) + +diff --git a/src/lstack/api/lstack_epoll.c b/src/lstack/api/lstack_epoll.c +index 1f0aea8..e54d496 100644 +--- a/src/lstack/api/lstack_epoll.c ++++ b/src/lstack/api/lstack_epoll.c +@@ -78,11 +78,6 @@ void add_epoll_event(struct netconn *conn, uint32_t event) + event = EPOLLRDHUP | EPOLLIN | EPOLLERR; + } + +- /* shadow_fd event notice listen_fd */ +- if (sock->shadowed_sock) { +- sock = sock->shadowed_sock; +- } +- + if ((event & sock->epoll_events) == 0) { + return; + } +@@ -111,14 +106,9 @@ static void raise_pending_events(struct lwip_sock *sock) + return; + } + +- struct lwip_sock *attach_sock = NULL; +- if (sock->attach_fd > 0 && sock->attach_fd != conn->socket) { +- attach_sock = get_socket_by_fd(sock->attach_fd); +- if (attach_sock == NULL) { +- return; +- } +- } else { +- attach_sock = sock; ++ struct lwip_sock *attach_sock = (sock->attach_fd > 0) ? get_socket_by_fd(sock->attach_fd) : sock; ++ if (attach_sock == NULL) { ++ return; + } + + conn = attach_sock->conn; +@@ -144,20 +134,20 @@ static void raise_pending_events(struct lwip_sock *sock) + } + } + +- if (sock->errevent > 0) { ++ if (attach_sock->errevent > 0) { + event |= POLLERR | POLLIN; + } + + if (event == 0) { + return; + } +- sock->events |= event; ++ attach_sock->events |= event; + if (rte_ring_mp_enqueue(wakeup->event_ring, (void *)sock) == 0 || + rte_ring_mp_enqueue(wakeup->self_ring, (void *)sock) == 0) { + sem_post(&wakeup->event_sem); + stack->stats.epoll_pending++; + } else { +- rpc_call_addevent(stack, sock); ++ rpc_call_addevent(stack, attach_sock); + stack->stats.epoll_pending_call++; + } + } +@@ -260,13 +250,14 @@ int32_t lstack_epoll_ctl(int32_t epfd, int32_t op, int32_t fd, struct epoll_even + return 0; + } + +-static inline int32_t save_poll_event(struct pollfd *fds, uint32_t maxevents, struct lwip_sock *sock, int32_t event_num) ++static inline int32_t save_poll_event(struct pollfd *fds, uint32_t maxevents, int32_t fd, uint32_t events) + { ++ int32_t event_num = 0; + for (uint32_t i = 0; i < maxevents; i++) { + /* fds[i].revents != 0, the events is kernel events */ +- if (fds[i].fd == sock->conn->socket && fds[i].revents == 0) { +- fds[i].revents = sock->events; +- event_num++; ++ if (fds[i].fd == fd && fds[i].revents == 0) { ++ fds[i].revents = events; ++ event_num = 1; + break; + } + } +@@ -274,7 +265,8 @@ static inline int32_t save_poll_event(struct pollfd *fds, uint32_t maxevents, st + return event_num; + } + +-static bool remove_event(enum POLL_TYPE etype, struct lwip_sock **sock_list, int32_t event_num, struct lwip_sock *sock) ++static bool remove_event(enum POLL_TYPE etype, struct lwip_sock **sock_list, int32_t event_num, struct lwip_sock *sock, ++ struct lwip_sock *attach_sock) + { + /* remove duplicate event */ + for (uint32_t i = 0; i < event_num && etype == TYPE_EPOLL; i++) { +@@ -283,7 +275,7 @@ static bool remove_event(enum POLL_TYPE etype, struct lwip_sock **sock_list, int + } + } + +- return !check_event_vaild(sock, sock->events); ++ return !check_event_vaild(attach_sock, attach_sock->events); + } + + static int32_t get_lwip_events(struct weakup_poll *weakup, void *out, uint32_t maxevents, enum POLL_TYPE etype) +@@ -302,25 +294,38 @@ static int32_t get_lwip_events(struct weakup_poll *weakup, void *out, uint32_t m + rte_ring_sc_dequeue(weakup->event_ring, (void **)&sock)) { + break; + } +- /* close sock */ ++ __atomic_store_n(&sock->have_event, false, __ATOMIC_RELEASE); ++ ++ /* sock->stack == NULL mean close sock */ + if (sock->stack == NULL) { + continue; + } +- __atomic_store_n(&sock->have_event, false, __ATOMIC_RELEASE); + +- if (remove_event(etype, weakup->sock_list, event_num, sock)) { ++ /* attach listen is empty, all event in attached listen. attached listen attach_fd is self */ ++ struct lwip_sock *attach_sock = (sock->attach_fd > 0) ? get_socket(sock->attach_fd) : sock; ++ if (attach_sock == NULL) { ++ continue; ++ } ++ ++ if (remove_event(etype, weakup->sock_list, event_num, sock, attach_sock)) { + sock->stack->stats.remove_event++; + continue; + } + + if (etype == TYPE_EPOLL) { +- events[event_num].events = sock->events; ++ events[event_num].events = attach_sock->events; + events[event_num].data = sock->ep_data; + weakup->sock_list[event_num] = sock; + event_num++; + } else { +- /* save one event at a time */ +- event_num = save_poll_event(fds, maxevents, sock, event_num); ++ /* shadow_fd event notice listen_fd */ ++ if (attach_sock->shadowed_sock) { ++ attach_sock = attach_sock->shadowed_sock; ++ } ++ ++ if (sock->conn) { ++ event_num += save_poll_event(fds, maxevents, sock->conn->socket, attach_sock->events); ++ } + } + + sock->stack->stats.app_events++; +-- +1.8.3.1 + diff --git a/0032-modify-readme-to-add-constraint.patch b/0032-modify-readme-to-add-constraint.patch new file mode 100644 index 0000000..a9d100b --- /dev/null +++ b/0032-modify-readme-to-add-constraint.patch @@ -0,0 +1,24 @@ +From cb29e0124945480fc8e017dfd426926ddfebd754 Mon Sep 17 00:00:00 2001 +From: jinag12 +Date: Wed, 16 Mar 2022 11:12:17 +0000 +Subject: [PATCH 32/34] modify readme to add constraint + +--- + README.md | 1 + + 1 file changed, 1 insertion(+) + +diff --git a/README.md b/README.md +index f2a933c..e914b26 100644 +--- a/README.md ++++ b/README.md +@@ -252,6 +252,7 @@ Usage: gazellectl [-h | help] + - 虚拟机网卡不支持多队列。 + - 不使用ltran模式，kni网口只支持本地通讯使用，且需要启动前配置NetworkManager不管理kni网卡 + - 虚拟kni网口的ip及mac地址，需要与lstack配置文件保持一致 ++- gazelle运行过程中，不允许删除运行文件，如果删除，需要重启gazelle + + ## Security risk note + gazelle有如下安全风险，用户需要评估使用场景风险 +-- +1.8.3.1 + diff --git a/0033-fix-accept-check-remain-conn.patch b/0033-fix-accept-check-remain-conn.patch new file mode 100644 index 0000000..39448c3 --- /dev/null +++ b/0033-fix-accept-check-remain-conn.patch @@ -0,0 +1,75 @@ +From 40531107531c4891defa71f899cbe96d30db9c6e Mon Sep 17 00:00:00 2001 +From: wuchangsheng +Date: Wed, 16 Mar 2022 16:05:46 +0800 +Subject: [PATCH 33/34] fix accept check remain conn + +--- + src/lstack/core/lstack_protocol_stack.c | 27 +++++++++++++-------------- + 1 file changed, 13 insertions(+), 14 deletions(-) + +diff --git a/src/lstack/core/lstack_protocol_stack.c b/src/lstack/core/lstack_protocol_stack.c +index 3193eeb..4a46044 100644 +--- a/src/lstack/core/lstack_protocol_stack.c ++++ b/src/lstack/core/lstack_protocol_stack.c +@@ -577,17 +577,9 @@ void stack_accept(struct rpc_msg *msg) + { + int32_t fd = msg->args[MSG_ARG_0].i; + +- /* listen sock attach_fd is self */ +- struct lwip_sock *sock = get_socket(fd); +- if (sock == NULL) { +- msg->result = -1; +- return; +- } +- fd = sock->attach_fd; +- + int32_t accept_fd = lwip_accept(fd, msg->args[MSG_ARG_1].p, msg->args[MSG_ARG_2].p); + if (accept_fd > 0) { +- sock = get_socket(accept_fd); ++ struct lwip_sock *sock = get_socket(accept_fd); + if (sock && sock->stack) { + msg->result = accept_fd; + return; +@@ -773,13 +765,19 @@ int32_t stack_broadcast_listen(int32_t fd, int32_t backlog) + /* ergodic the protocol stack thread to find the connection, because all threads are listening */ + int32_t stack_broadcast_accept(int32_t fd, struct sockaddr *addr, socklen_t *addrlen) + { +- struct lwip_sock *min_sock = NULL; ++ struct lwip_sock *sock = get_socket(fd); ++ if (sock == NULL) { ++ errno = EINVAL; ++ return -1; ++ } ++ ++ fd = sock->attach_fd; + int32_t head_fd = fd; +- int32_t min_fd = fd; +- int32_t ret = -1; + ++ struct lwip_sock *min_sock = NULL; ++ int32_t min_fd = fd; + while (fd > 0) { +- struct lwip_sock *sock = get_socket(fd); ++ sock = get_socket(fd); + if (sock == NULL) { + GAZELLE_RETURN(EINVAL); + } +@@ -797,13 +795,14 @@ int32_t stack_broadcast_accept(int32_t fd, struct sockaddr *addr, socklen_t *add + fd = sock->nextfd; + } + ++ int32_t ret = -1; + if (min_sock) { + ret = rpc_call_accept(min_fd, addr, addrlen); + } + +- struct lwip_sock *sock = get_socket(head_fd); + if (have_accept_event(head_fd)) { + add_self_event(sock, EPOLLIN); ++ sock = get_socket(head_fd); + sock->stack->stats.accept_events++; + } + +-- +1.8.3.1 + diff --git a/0034-fix-wakeup-list-dead-loop.patch b/0034-fix-wakeup-list-dead-loop.patch new file mode 100644 index 0000000..6e3d5e5 --- /dev/null +++ b/0034-fix-wakeup-list-dead-loop.patch @@ -0,0 +1,59 @@ +From e991d6a693af629e466f549cdd322ac11fc80f2e Mon Sep 17 00:00:00 2001 +From: jiangheng +Date: Wed, 16 Mar 2022 21:40:01 +0800 +Subject: [PATCH 34/34] fix wakeup list dead loop + +--- + src/lstack/core/lstack_lwip.c | 1 - + src/lstack/core/lstack_protocol_stack.c | 3 ++- + src/lstack/include/lstack_weakup.h | 3 ++- + 3 files changed, 4 insertions(+), 3 deletions(-) + +diff --git a/src/lstack/core/lstack_lwip.c b/src/lstack/core/lstack_lwip.c +index 9766a87..7bab92f 100644 +--- a/src/lstack/core/lstack_lwip.c ++++ b/src/lstack/core/lstack_lwip.c +@@ -130,7 +130,6 @@ void gazelle_clean_sock(int32_t fd) + list_del_node_init(&sock->attach_list); + list_del_node_init(&sock->listen_list); + list_del_node_init(&sock->event_list); +- list_del_node_init(&sock->wakeup_list); + list_del_node_init(&sock->send_list); + } + +diff --git a/src/lstack/core/lstack_protocol_stack.c b/src/lstack/core/lstack_protocol_stack.c +index 4a46044..1de546d 100644 +--- a/src/lstack/core/lstack_protocol_stack.c ++++ b/src/lstack/core/lstack_protocol_stack.c +@@ -343,7 +343,8 @@ static void send_stack_list(struct protocol_stack *stack) + list_for_each_safe(node, temp, list) { + sock = container_of(node, struct lwip_sock, send_list); + +- if (sock->conn == NULL) { ++ if (sock->conn == NULL || sock->stack == NULL) { ++ list_del_node_init(&sock->send_list); + continue; + } + +diff --git a/src/lstack/include/lstack_weakup.h b/src/lstack/include/lstack_weakup.h +index b051b72..77f3b9d 100644 +--- a/src/lstack/include/lstack_weakup.h ++++ b/src/lstack/include/lstack_weakup.h +@@ -37,12 +37,13 @@ static inline void wakeup_list_sock(struct list_node *wakeup_list) + struct weakup_poll *weakup = sock->weakup; + struct protocol_stack *stack = sock->stack; + if (weakup == NULL || stack == NULL) { ++ list_del_node_init(&sock->wakeup_list); + continue; + } + + int32_t ret = rte_ring_mp_enqueue(weakup->event_ring, (void *)sock); + if (ret == 0) { +- list_del_node_init(&sock->event_list); ++ list_del_node_init(&sock->wakeup_list); + sem_post(&weakup->event_sem); + stack->stats.lwip_events++; + } else { +-- +1.8.3.1 + diff --git a/README.md b/README.md index f2a933c..e914b26 100644 --- a/README.md +++ b/README.md @@ -252,6 +252,7 @@ Usage: gazellectl [-h | help] - 虚拟机网卡不支持多队列。 - 不使用ltran模式，kni网口只支持本地通讯使用，且需要启动前配置NetworkManager不管理kni网卡 - 虚拟kni网口的ip及mac地址，需要与lstack配置文件保持一致 +- gazelle运行过程中，不允许删除运行文件，如果删除，需要重启gazelle ## Security risk note gazelle有如下安全风险，用户需要评估使用场景风险 diff --git a/gazelle.spec b/gazelle.spec index 89b3c23..f241133 100644 --- a/gazelle.spec +++ b/gazelle.spec @@ -2,7 +2,7 @@ Name: gazelle Version: 1.0.1 -Release: 2 +Release: 3 Summary: gazelle is a high performance user-mode stack License: Mulan PSL v2 URL: https://gitee.com/openeuler/gazelle @@ -17,6 +17,38 @@ Requires: numactl libpcap libconfig libboundscheck Patch9001: 0001-fix-compile-error-unuse-result.patch Patch9002: 0002-reduce-copy-in-send.patch +Patch9003: 0003-execute-gazelle_init_sock-before-read-event.patch +Patch9004: 0004-recvmsg-sendmsg-should-use-recvmsg_from_stack-sendms.patch +Patch9005: 0005-fix-LD_PRELOAD.patch +Patch9006: 0006-reduce-replenish-send_idle_ring-rpc-call.patch +Patch9007: 0007-parse_host_addr-should-be-executed-before-parse_dpdk.patch +Patch9008: 0008-fix-gazellectl-l-option-error.patch +Patch9009: 0009-bind-cpu-fail-just-walrm.patch +Patch9010: 0010-mfix-close-not-release-sock.patch +Patch9011: 0011-fix-evetns-err.patch +Patch9012: 0012-fix-dfx-info-show.patch +Patch9013: 0013-balance-acept.patch +Patch9014: 0014-fix-miss-evetn.patch +Patch9015: 0015-fix-too-much-evetns.patch +Patch9016: 0016-fix-dead-loop.patch +Patch9017: 0017-remove-unuse-event.patch +Patch9018: 0018-fix-gazellectl-show.patch +Patch9019: 0019-fix-repeate-msg.patch +Patch9020: 0020-fix-wakeup-typos.patch +Patch9021: 0021-fix-pasre-numacpulist.patch +Patch9022: 0022-fix-get-data-error.patch +Patch9023: 0023-delete-numa-bind-param.patch +Patch9024: 0024-refactor-event.patch +Patch9025: 0025-fix-event-miss.patch +Patch9026: 0026-get-fin-notice-app.patch +Patch9027: 0027-fix-parse-config.patch +Patch9028: 0028-fix-lstack-show-latency.patch +Patch9029: 0029-fix-code-check.patch +Patch9030: 0030-fix-accept-init-sock-faile.patch +Patch9031: 0031-fix-reuse-ip-listen-event-don-t-notice.patch +Patch9032: 0032-modify-readme-to-add-constraint.patch +Patch9033: 0033-fix-accept-check-remain-conn.patch +Patch9034: 0034-fix-wakeup-list-dead-loop.patch %description %{name} is a high performance user-mode stack. @@ -57,6 +89,9 @@ install -Dpm 0640 %{_builddir}/%{name}-%{version}/src/ltran/ltran.conf %{b %config(noreplace) %{conf_path}/ltran.conf %changelog +* Wed Mar 16 2022 jiangheng - 1.0.1-3 +- fix gazelle test issue + * Mon Mar 7 2022 wu-changsheng - 1.0.1-2 - reduce copy in send