diff --git a/0141-recv-support-MSG_DONTWAIT.patch b/0141-recv-support-MSG_DONTWAIT.patch new file mode 100644 index 0000000..403b96b --- /dev/null +++ b/0141-recv-support-MSG_DONTWAIT.patch @@ -0,0 +1,36 @@ +From 34c272bf7f0484a1371033c187719adc72f061d5 Mon Sep 17 00:00:00 2001 +From: li_yunqing +Date: Tue, 27 Feb 2024 16:58:59 +0800 +Subject: [PATCH] recv support MSG_DONTWAIT + +--- + src/lstack/core/lstack_lwip.c | 5 +++-- + 1 file changed, 3 insertions(+), 2 deletions(-) + +diff --git a/src/lstack/core/lstack_lwip.c b/src/lstack/core/lstack_lwip.c +index 0b339fe..7715cf3 100644 +--- a/src/lstack/core/lstack_lwip.c ++++ b/src/lstack/core/lstack_lwip.c +@@ -993,6 +993,7 @@ ssize_t do_lwip_read_from_stack(int32_t fd, void *buf, size_t len, int32_t flags + { + ssize_t recvd = 0; + struct lwip_sock *sock = get_socket_by_fd(fd); ++ bool noblock = (flags & MSG_DONTWAIT) || netconn_is_nonblocking(sock->conn); + + if (recv_break_for_err(sock)) { + return -1; +@@ -1005,9 +1006,9 @@ ssize_t do_lwip_read_from_stack(int32_t fd, void *buf, size_t len, int32_t flags + } + + if (NETCONN_IS_UDP(sock)) { +- recvd = recv_ring_udp_read(sock, buf, len, netconn_is_nonblocking(sock->conn), addr, addrlen); ++ recvd = recv_ring_udp_read(sock, buf, len, noblock, addr, addrlen); + } else { +- recvd = recv_ring_tcp_read(sock, buf, len, netconn_is_nonblocking(sock->conn)); ++ recvd = recv_ring_tcp_read(sock, buf, len, noblock); + } + + /* rte_ring_count reduce lock */ +-- +2.27.0 + diff --git a/0142-do_setsockopt-function-no-longer-checks-the-results-.patch b/0142-do_setsockopt-function-no-longer-checks-the-results-.patch new file mode 100644 index 0000000..8a87350 --- /dev/null +++ b/0142-do_setsockopt-function-no-longer-checks-the-results-.patch @@ -0,0 +1,29 @@ +From 712a3c23451ed79449cea9322586d958c27c679f Mon Sep 17 00:00:00 2001 +From: jiangjixiang +Date: Fri, 1 Mar 2024 10:10:01 +0800 +Subject: [PATCH] do_setsockopt function no longer checks the results of the + kernel. + +--- + src/lstack/api/lstack_wrap.c | 5 +---- + 1 file changed, 1 insertion(+), 4 deletions(-) + +diff --git a/src/lstack/api/lstack_wrap.c b/src/lstack/api/lstack_wrap.c +index 8992e39..1e36d3d 100644 +--- a/src/lstack/api/lstack_wrap.c ++++ b/src/lstack/api/lstack_wrap.c +@@ -398,10 +398,7 @@ static inline int32_t do_setsockopt(int32_t s, int32_t level, int32_t optname, c + } + + /* we both set kernel and lwip */ +- int32_t ret = posix_api->setsockopt_fn(s, level, optname, optval, optlen); +- if (ret != 0) { +- return ret; +- } ++ posix_api->setsockopt_fn(s, level, optname, optval, optlen); + + return g_wrap_api->setsockopt_fn(s, level, optname, optval, optlen); + } +-- +2.27.0 + diff --git a/0143-FAUT-INJECT-add-fault-inject-unset-method.patch b/0143-FAUT-INJECT-add-fault-inject-unset-method.patch new file mode 100644 index 0000000..31a8c4b --- /dev/null +++ b/0143-FAUT-INJECT-add-fault-inject-unset-method.patch @@ -0,0 +1,254 @@ +From c2cf2ef0cc9f28a8322e17870d209f546ad6711d Mon Sep 17 00:00:00 2001 +From: yinbin6 +Date: Mon, 4 Mar 2024 11:15:34 +0800 +Subject: [PATCH] FAUT INJECT: add fault inject unset method + +--- + src/lstack/core/lstack_control_plane.c | 2 +- + src/lstack/include/lstack_fault_inject.h | 2 +- + src/lstack/netif/lstack_fault_inject.c | 60 ++++++++++++---- + src/ltran/ltran_dfx.c | 92 +++++++++++++++++++++--- + 4 files changed, 131 insertions(+), 25 deletions(-) + +diff --git a/src/lstack/core/lstack_control_plane.c b/src/lstack/core/lstack_control_plane.c +index 783f21c..9f0c313 100644 +--- a/src/lstack/core/lstack_control_plane.c ++++ b/src/lstack/core/lstack_control_plane.c +@@ -590,7 +590,7 @@ static int32_t handle_stat_request(int32_t sockfd) + #ifdef GAZELLE_FAULT_INJECT_ENABLE + if (msg.stat_mode == GAZELLE_STAT_FAULT_INJECT_SET || + msg.stat_mode == GAZELLE_STAT_FAULT_INJECT_UNSET) { +- return handle_fault_inject_cmd(sockfd, &msg); ++ return handle_fault_inject_cmd(sockfd, msg.data.inject, msg.stat_mode); + } + #endif /* GAZELLE_FAULT_INJECT_ENABLE */ + +diff --git a/src/lstack/include/lstack_fault_inject.h b/src/lstack/include/lstack_fault_inject.h +index d54f1f2..afd8faf 100644 +--- a/src/lstack/include/lstack_fault_inject.h ++++ b/src/lstack/include/lstack_fault_inject.h +@@ -15,6 +15,6 @@ + + #include + +-int32_t handle_fault_inject_cmd(int32_t sockfd, struct gazelle_stat_msg_request *msg); ++int32_t handle_fault_inject_cmd(int32_t sockfd, struct gazelle_fault_inject_data inject, enum GAZELLE_STAT_MODE stat_mode); + + #endif /* __GAZELLE_INJECT_H__ */ +diff --git a/src/lstack/netif/lstack_fault_inject.c b/src/lstack/netif/lstack_fault_inject.c +index 4daad10..41e7d95 100644 +--- a/src/lstack/netif/lstack_fault_inject.c ++++ b/src/lstack/netif/lstack_fault_inject.c +@@ -150,21 +150,10 @@ static int32_t inject_packet_loss_random(struct protocol_stack *stack, struct rt + return nr_pkts; + } + +-int32_t handle_fault_inject_cmd(int32_t sockfd, struct gazelle_stat_msg_request *msg) ++static int32_t inject_respond_msg(int32_t sockfd) + { + struct gazelle_stack_dfx_data rsp = {0}; + int32_t ret = 0; +- +- ret = memcpy_s(&g_inject_tbl[msg->data.inject.inject_type].inject_data, +- sizeof(struct gazelle_fault_inject_data), +- &msg->data.inject, sizeof(struct gazelle_fault_inject_data)); +- if (ret != EOK) { +- LSTACK_LOG(ERR, LSTACK, "fault inject memcpy_s error, ret = %d", ret); +- return -1; +- } +- +- inject_strategy_update(); +- + for (int32_t i = 0; i < GAZELLE_FAULT_INJECT_TYPE_MAX; ++i) { + ret = memcpy_s(&rsp.data.inject, sizeof(struct gazelle_fault_inject_data), + &g_inject_tbl[i].inject_data, sizeof(struct gazelle_fault_inject_data)); +@@ -185,3 +174,50 @@ int32_t handle_fault_inject_cmd(int32_t sockfd, struct gazelle_stat_msg_request + return 0; + } + ++static int32_t inject_unset_cmd(int32_t sockfd, struct gazelle_fault_inject_data inject) ++{ ++ if (inject.inject_type == GAZELLE_FAULT_INJECT_TYPE_MAX) { ++ /* means unset all kinds of fault inject type */ ++ for (int32_t i = 0; i < GAZELLE_FAULT_INJECT_TYPE_MAX; ++i) { ++ g_inject_tbl[i].inject_data.fault_inject_on = 0; ++ } ++ } else { ++ int32_t ret = 0; ++ ret = memcpy_s(&g_inject_tbl[inject.inject_type].inject_data, ++ sizeof(struct gazelle_fault_inject_data), ++ &inject, sizeof(struct gazelle_fault_inject_data)); ++ if (ret != EOK) { ++ LSTACK_LOG(ERR, LSTACK, "fault inject memcpy_s error, ret = %d", ret); ++ return -1; ++ } ++ } ++ ++ inject_strategy_update(); ++ ++ return inject_respond_msg(sockfd); ++} ++ ++static int32_t inject_set_cmd(int32_t sockfd, struct gazelle_fault_inject_data inject) ++{ ++ int32_t ret = 0; ++ ret = memcpy_s(&g_inject_tbl[inject.inject_type].inject_data, ++ sizeof(struct gazelle_fault_inject_data), ++ &inject, sizeof(struct gazelle_fault_inject_data)); ++ if (ret != EOK) { ++ LSTACK_LOG(ERR, LSTACK, "fault inject memcpy_s error, ret = %d", ret); ++ return -1; ++ } ++ ++ inject_strategy_update(); ++ ++ return inject_respond_msg(sockfd); ++} ++ ++int32_t handle_fault_inject_cmd(int32_t sockfd, struct gazelle_fault_inject_data inject, enum GAZELLE_STAT_MODE stat_mode) ++{ ++ if (stat_mode == GAZELLE_STAT_FAULT_INJECT_UNSET) { ++ return inject_unset_cmd(sockfd, inject); ++ } ++ return inject_set_cmd(sockfd, inject); ++} ++ +diff --git a/src/ltran/ltran_dfx.c b/src/ltran/ltran_dfx.c +index 413bf89..96509e5 100644 +--- a/src/ltran/ltran_dfx.c ++++ b/src/ltran/ltran_dfx.c +@@ -97,7 +97,7 @@ static struct gazelle_fault_inject_rule_list g_gazelle_fault_inject_rule_list[] + }; + + static void gazelle_print_fault_inject_set_status(void *buf, const struct gazelle_stat_msg_request *req_msg); +- ++static void gazelle_print_fault_inject_unset_status(void *buf, const struct gazelle_stat_msg_request *req_msg); + #endif /* GAZELLE_FAULT_INJECT_ENABLE */ + + static bool g_use_ltran = false; +@@ -1504,6 +1504,7 @@ static int32_t parse_dfx_lstack_args(int32_t argc, char *argv[], struct gazelle_ + #define INJECT_DIGITAL_FIRST_INDEX 3 + #define INJECT_DIGITAL_SECOND_INDEX 4 + #define INJECT_RULE_INDEX 5 ++#define INJECT_UNSET_TYPE_INDEX 3 + + + static void gazelle_print_fault_inject_type_info(struct gazelle_fault_inject_data *inject) +@@ -1549,6 +1550,33 @@ static void gazelle_print_fault_inject_set_status(void *buf, const struct gazell + + static void gazelle_print_fault_inject_unset_status(void *buf, const struct gazelle_stat_msg_request *req_msg) + { ++ int32_t ret; ++ static int32_t inject_enable[GAZELLE_FAULT_INJECT_TYPE_MAX]; ++ struct gazelle_stack_dfx_data *stat = (struct gazelle_stack_dfx_data *)buf; ++ struct gazelle_fault_inject_data *inject = &stat->data.inject; ++ ++ printf("\n\t\t\t\t\t **** INJECT ENABLE ITEM **** \n\n"); ++ do { ++ inject_enable[inject->inject_type] = inject->fault_inject_on; ++ gazelle_print_fault_inject_type_info(inject); ++ if (stat->eof != 0) { ++ break; ++ } ++ ret = dfx_stat_read_from_ltran(buf, sizeof(struct gazelle_stack_dfx_data), req_msg->stat_mode); ++ if (ret != GAZELLE_OK) { ++ return; ++ } ++ } while (true); ++ ++ printf("\n\n\t\t\t\t\t **** INJECT DISABLE ITEM **** \n\n"); ++ printf("\tThe currently closed inject types are: "); ++ for (int32_t i = 1; i < GAZELLE_FAULT_INJECT_TYPE_MAX; ++i) { ++ if (!inject_enable[i]) { ++ /* i - 1 means fault inject type mapping inject_type_item name */ ++ printf("\"%s\" ", inject_type_list[i - 1].inject_type_item); ++ } ++ } ++ printf("\n"); + return; + } + +@@ -1653,21 +1681,45 @@ static int32_t parse_fault_inject_digital_data(char *argv[], struct gazelle_stat + return parse_success; + } + +-static int32_t parse_dfx_fault_inject_args(int32_t argc, char *argv[], struct gazelle_stat_msg_request *req_msg) ++static int32_t parse_fault_inject_unset_type(char *argv[], struct gazelle_stat_msg_request *req_msg) + { +- int32_t num_cmd = 0; /* while parse error, num_cmd will return as 0, or num_cmd should be returned as 1. */ +- +- req_msg->data.inject.fault_inject_on = 1; /* set fault inject on */ ++ int32_t num_cmd = 0; ++ ++ if (strcmp(argv[INJECT_TYPE_INDEX], "unset") != 0) { ++ printf("FAULT_INJECT error: unrecognized input -- %s, should be \"unset\"\n", argv[INJECT_TYPE_INDEX]); ++ return num_cmd; ++ } ++ ++ req_msg->data.inject.fault_inject_on = 0; /* unset fault inject */ ++ req_msg->stat_mode = GAZELLE_STAT_FAULT_INJECT_UNSET; ++ ++ if (strcmp(argv[INJECT_UNSET_TYPE_INDEX], "all") == 0) { ++ req_msg->data.inject.inject_type = GAZELLE_FAULT_INJECT_TYPE_MAX; ++ return ++num_cmd; ++ } + +- if (argc == GAZELLE_SET_FAULT_INJECT_PARAM_COUNT) { +- req_msg->stat_mode = GAZELLE_STAT_FAULT_INJECT_SET; +- } else if (argc == GAZELLE_UNSET_FAULT_INJECT_PARAM_COUNT) { +- req_msg->stat_mode = GAZELLE_STAT_FAULT_INJECT_UNSET; +- } else { +- printf("FAULT_INJECT error: Count of params wrong , correct count is 6 or 4, now is %d\n", argc); ++ int32_t inject_type_count = sizeof(inject_type_list) / sizeof(inject_type_list[0]); ++ for (int32_t i = 0; i < inject_type_count; ++i) { ++ if (strcmp(inject_type_list[i].inject_type_item, argv[INJECT_UNSET_TYPE_INDEX]) == 0) { ++ req_msg->data.inject.inject_type = inject_type_list[i].inject_type_parsed; ++ break; ++ } ++ } ++ if (req_msg->data.inject.inject_type == GAZELLE_FAULT_INJECT_TYPE_ERR) { ++ printf("FAULT_INJECT error: input inject type is wrong -- %s\n", argv[INJECT_TYPE_INDEX]); + return num_cmd; + } + ++ return ++num_cmd; ++} ++ ++static int32_t parse_fault_inject_set_type(char *argv[], struct gazelle_stat_msg_request *req_msg) ++{ ++ int32_t num_cmd = 0; ++ ++ req_msg->data.inject.fault_inject_on = 1; /* set fault inject on */ ++ req_msg->stat_mode = GAZELLE_STAT_FAULT_INJECT_SET; ++ + int32_t inject_type_count = sizeof(inject_type_list) / sizeof(inject_type_list[0]); + for (int32_t i = 0; i < inject_type_count; ++i) { + if (strcmp(inject_type_list[i].inject_type_item, argv[INJECT_TYPE_INDEX]) == 0) { +@@ -1698,6 +1750,24 @@ static int32_t parse_dfx_fault_inject_args(int32_t argc, char *argv[], struct ga + return num_cmd; + } + ++static int32_t parse_dfx_fault_inject_args(int32_t argc, char *argv[], struct gazelle_stat_msg_request *req_msg) ++{ ++ int32_t num_cmd = 0; /* while parse error, num_cmd will return as 0, or num_cmd should be returned as 1. */ ++ ++ if (argc == GAZELLE_UNSET_FAULT_INJECT_PARAM_COUNT) { ++ num_cmd = parse_fault_inject_unset_type(argv, req_msg); ++ return num_cmd; ++ } ++ ++ if (argc == GAZELLE_SET_FAULT_INJECT_PARAM_COUNT) { ++ num_cmd = parse_fault_inject_set_type(argv, req_msg); ++ return num_cmd; ++ } ++ ++ printf("FAULT_INJECT error: Count of params wrong , correct count is 6 or 4, now is %d\n", argc); ++ return num_cmd; ++} ++ + #endif /* GAZELLE_FAULT_INJECT_ENABLE */ + + static int32_t parse_dfx_cmd_args(int32_t argc, char *argv[], struct gazelle_stat_msg_request *req_msg) +-- +2.27.0 + diff --git a/0144-support-udp-pkglen-mtu.patch b/0144-support-udp-pkglen-mtu.patch new file mode 100644 index 0000000..c03fd04 --- /dev/null +++ b/0144-support-udp-pkglen-mtu.patch @@ -0,0 +1,85 @@ +From 5ba19529acaf76a681313245a9a278356b615687 Mon Sep 17 00:00:00 2001 +From: yangchen +Date: Mon, 4 Mar 2024 14:10:43 +0800 +Subject: [PATCH] support udp pkglen > mtu + +--- + src/lstack/core/lstack_lwip.c | 20 ++++++++++++++++++-- + src/lstack/include/lstack_dpdk.h | 2 +- + 2 files changed, 19 insertions(+), 3 deletions(-) + +diff --git a/src/lstack/core/lstack_lwip.c b/src/lstack/core/lstack_lwip.c +index 7715cf3..f4199f8 100644 +--- a/src/lstack/core/lstack_lwip.c ++++ b/src/lstack/core/lstack_lwip.c +@@ -252,6 +252,13 @@ struct pbuf *do_lwip_get_from_sendring(struct lwip_sock *sock, uint16_t remain_s + return NULL; + } + ++ /* udp send a pbuf chain, dequeue all pbufs except head pbuf */ ++ if (NETCONN_IS_UDP(sock) && remain_size > MBUF_MAX_DATA_LEN) { ++ int size = (remain_size + MBUF_MAX_DATA_LEN - 1) / MBUF_MAX_DATA_LEN - 1; ++ struct pbuf *pbuf_used[size]; ++ gazelle_ring_sc_dequeue(sock->send_ring, (void **)&pbuf_used, size); ++ } ++ + if (get_protocol_stack_group()->latency_start) { + calculate_lstack_latency(&sock->stack->latency, pbuf, GAZELLE_LATENCY_WRITE_LWIP); + } +@@ -285,7 +292,7 @@ void do_lwip_get_from_sendring_over(struct lwip_sock *sock) + sock->stack->stats.write_lwip_cnt++; + } + +-static ssize_t do_app_write(struct pbuf *pbufs[], void *buf, size_t len, uint32_t write_num) ++static ssize_t do_app_write(struct lwip_sock *sock, struct pbuf *pbufs[], void *buf, size_t len, uint32_t write_num) + { + ssize_t send_len = 0; + uint32_t i = 0; +@@ -297,6 +304,11 @@ static ssize_t do_app_write(struct pbuf *pbufs[], void *buf, size_t len, uint32_ + rte_memcpy((char *)pbufs[i]->payload, (char *)buf + send_len, MBUF_MAX_DATA_LEN); + pbufs[i]->tot_len = pbufs[i]->len = MBUF_MAX_DATA_LEN; + send_len += MBUF_MAX_DATA_LEN; ++ ++ /* if udp pkg len > mtu, use pbuf chain to send it */ ++ if (NETCONN_IS_UDP(sock) && i > 0) { ++ pbuf_cat(pbufs[0], pbufs[i]); ++ } + } + + /* reduce the branch in loop */ +@@ -305,6 +317,10 @@ static ssize_t do_app_write(struct pbuf *pbufs[], void *buf, size_t len, uint32_ + pbufs[i]->tot_len = pbufs[i]->len = copy_len; + send_len += copy_len; + ++ if (NETCONN_IS_UDP(sock) && i > 0) { ++ pbuf_cat(pbufs[0], pbufs[i]); ++ } ++ + return send_len; + } + +@@ -320,7 +336,7 @@ static inline ssize_t app_buff_write(struct lwip_sock *sock, void *buf, size_t l + time_stamp_into_pbuf(write_num, pbufs, time_stamp); + } + +- ssize_t send_len = do_app_write(pbufs, buf, len, write_num); ++ ssize_t send_len = do_app_write(sock, pbufs, buf, len, write_num); + + if (addr) { + if (addr->sa_family == AF_INET) { +diff --git a/src/lstack/include/lstack_dpdk.h b/src/lstack/include/lstack_dpdk.h +index c40f3c0..c7cfbdf 100644 +--- a/src/lstack/include/lstack_dpdk.h ++++ b/src/lstack/include/lstack_dpdk.h +@@ -21,7 +21,7 @@ + + #define KNI_NB_MBUF (DEFAULT_RING_SIZE << 4) + +-#define MAX_PACKET_SZ 1530 ++#define MAX_PACKET_SZ 1538 + + #define RING_SIZE(x) ((x) - 1) + +-- +2.27.0 + diff --git a/0145-add-limit-with-level-for-sockopt.patch b/0145-add-limit-with-level-for-sockopt.patch new file mode 100644 index 0000000..c58bbc7 --- /dev/null +++ b/0145-add-limit-with-level-for-sockopt.patch @@ -0,0 +1,86 @@ +From 5e4b2366417b5f951ffd5ee45c0917ae67bd502e Mon Sep 17 00:00:00 2001 +From: hantwofish +Date: Sun, 3 Mar 2024 21:40:23 +0800 +Subject: [PATCH] add limit with level for sockopt + +--- + src/lstack/api/lstack_wrap.c | 49 +++++++++++++++++++++++++----------- + 2 files changed, 35 insertions(+), 16 deletions(-) + +diff --git a/src/lstack/api/lstack_wrap.c b/src/lstack/api/lstack_wrap.c +index 1e36d3d..49bbf91 100644 +--- a/src/lstack/api/lstack_wrap.c ++++ b/src/lstack/api/lstack_wrap.c +@@ -364,27 +364,46 @@ static inline int32_t do_getsockname(int32_t s, struct sockaddr *name, socklen_t + return posix_api->getsockname_fn(s, name, namelen); + } + +-static bool unsupport_optname(int32_t optname) +-{ +- if (optname == SO_BROADCAST || +- optname == SO_PROTOCOL || +- optname == TCP_QUICKACK || +- optname == SO_SNDTIMEO || +- optname == SO_RCVTIMEO || +- optname == SO_SNDBUF || +- optname == SO_RCVBUF || +- optname == TCP_INFO || +- optname == TCP_MAXSEG || +- optname == SO_DONTROUTE || +- optname == TCP_CONGESTION) { ++static bool unsupport_tcp_optname(int32_t optname) ++{ ++ if ((optname == TCP_QUICKACK) || ++ (optname == TCP_INFO) || ++ (optname == TCP_MAXSEG) || ++ (optname == TCP_CONGESTION)) { ++ return true; ++ } ++ return false; ++} ++ ++static bool unsupport_socket_optname(int32_t optname) ++{ ++ if ((optname == SO_BROADCAST) || ++ (optname == SO_PROTOCOL) || ++ (optname == SO_SNDTIMEO) || ++ (optname == SO_RCVTIMEO) || ++ (optname == SO_SNDBUF) || ++ (optname == SO_RCVBUF) || ++ (optname == SO_DONTROUTE)) { + return true; + } + return false; + } + ++static bool unsupport_optname(int32_t level, int32_t optname) ++{ ++ if (level == SOL_TCP) { ++ return unsupport_tcp_optname(optname); ++ } ++ ++ if (level == SOL_SOCKET) { ++ return unsupport_socket_optname(optname); ++ } ++ return false; ++} ++ + static inline int32_t do_getsockopt(int32_t s, int32_t level, int32_t optname, void *optval, socklen_t *optlen) + { +- if (select_fd_posix_path(s, NULL) == PATH_LWIP && !unsupport_optname(optname)) { ++ if (select_fd_posix_path(s, NULL) == PATH_LWIP && !unsupport_optname(level, optname)) { + return g_wrap_api->getsockopt_fn(s, level, optname, optval, optlen); + } + +@@ -393,7 +412,7 @@ static inline int32_t do_getsockopt(int32_t s, int32_t level, int32_t optname, v + + static inline int32_t do_setsockopt(int32_t s, int32_t level, int32_t optname, const void *optval, socklen_t optlen) + { +- if (select_fd_posix_path(s, NULL) == PATH_KERNEL || unsupport_optname(optname)) { ++ if (select_fd_posix_path(s, NULL) == PATH_KERNEL || unsupport_optname(level, optname)) { + return posix_api->setsockopt_fn(s, level, optname, optval, optlen); + } + +-- +2.27.0 + diff --git a/0146-udp-add-restriction-message-too-long.patch b/0146-udp-add-restriction-message-too-long.patch new file mode 100644 index 0000000..a74c49c --- /dev/null +++ b/0146-udp-add-restriction-message-too-long.patch @@ -0,0 +1,42 @@ +From a37c451e63bed06a70e887aba6364183d71f414f Mon Sep 17 00:00:00 2001 +From: yangchen +Date: Mon, 11 Mar 2024 11:18:54 +0800 +Subject: [PATCH] udp add restriction: message too long + +--- + src/common/gazelle_opt.h | 2 ++ + src/lstack/core/lstack_lwip.c | 5 +++++ + 2 files changed, 7 insertions(+) + +diff --git a/src/common/gazelle_opt.h b/src/common/gazelle_opt.h +index 1d1c5f5..6d787b9 100644 +--- a/src/common/gazelle_opt.h ++++ b/src/common/gazelle_opt.h +@@ -60,6 +60,8 @@ + + #define DPDK_PKT_BURST_SIZE 512 + ++#define GAZELLE_UDP_PKGLEN_MAX (65535 - IP_HLEN - UDP_HLEN) ++ + /* total:33 client, index 32 is invaild client */ + #define GAZELLE_CLIENT_NUM_ALL 33 + #define GAZELLE_NULL_CLIENT (GAZELLE_CLIENT_NUM_ALL - 1) +diff --git a/src/lstack/core/lstack_lwip.c b/src/lstack/core/lstack_lwip.c +index f4199f8..8aae433 100644 +--- a/src/lstack/core/lstack_lwip.c ++++ b/src/lstack/core/lstack_lwip.c +@@ -779,6 +779,11 @@ ssize_t do_lwip_send_to_stack(int32_t fd, const void *buf, size_t len, int32_t f + return 0; + } + ++ if (NETCONN_IS_UDP(sock) && (len > GAZELLE_UDP_PKGLEN_MAX)) { ++ LSTACK_LOG(ERR, LSTACK, "Message too long\n"); ++ GAZELLE_RETURN(EMSGSIZE); ++ } ++ + thread_bind_stack(sock); + + if (sock->same_node_tx_ring != NULL) { +-- +2.27.0 + diff --git a/0147-dfx-improve-log-readability-when-connect-ltran-lstac.patch b/0147-dfx-improve-log-readability-when-connect-ltran-lstac.patch new file mode 100644 index 0000000..f21edae --- /dev/null +++ b/0147-dfx-improve-log-readability-when-connect-ltran-lstac.patch @@ -0,0 +1,269 @@ +From 9d68f6bca1adfba6802e85aa213dbba5002cb289 Mon Sep 17 00:00:00 2001 +From: jiangheng +Date: Tue, 27 Feb 2024 22:48:19 +0800 +Subject: [PATCH] dfx: improve log readability when connect ltran/lstack failed + +--- + src/ltran/ltran_dfx.c | 152 +++++++++++++++++++++++++++--------------- + 1 file changed, 99 insertions(+), 53 deletions(-) + +diff --git a/src/ltran/ltran_dfx.c b/src/ltran/ltran_dfx.c +index 96509e5..a429866 100644 +--- a/src/ltran/ltran_dfx.c ++++ b/src/ltran/ltran_dfx.c +@@ -101,6 +101,8 @@ static void gazelle_print_fault_inject_unset_status(void *buf, const struct gaze + #endif /* GAZELLE_FAULT_INJECT_ENABLE */ + + static bool g_use_ltran = false; ++static char g_ltran_unix_path[PATH_MAX]; ++static char g_lstack_unix_path[PATH_MAX]; + + static char* g_unix_prefix; + +@@ -268,24 +270,16 @@ static void gazelle_print_ltran_sock(void *buf, const struct gazelle_stat_msg_re + printf("ltran sock table num: %u\n", table->conn_num); + } + +-static int32_t dfx_connect_ltran(bool use_ltran, bool probe) ++static int dfx_make_unix_addr(struct sockaddr_un *addr, bool use_ltran) + { +- int32_t ret, fd; +- struct sockaddr_un addr; +- +- fd = socket(AF_UNIX, SOCK_STREAM, 0); +- if (fd == -1) { +- printf("create socket failed. errno: %d\n", errno); +- return GAZELLE_ERR; +- } +- +- ret = memset_s(&addr, sizeof(addr), 0, sizeof(struct sockaddr_un)); ++ int ret; ++ ret = memset_s(addr, sizeof(*addr), 0, sizeof(struct sockaddr_un)); + if (ret != EOK) { + printf("%s:%d memset_s fail ret=%d\n", __FUNCTION__, __LINE__, ret); + goto END; + } + +- ret = strncpy_s(addr.sun_path, sizeof(addr.sun_path), GAZELLE_RUN_DIR, ++ ret = strncpy_s(addr->sun_path, sizeof(addr->sun_path), GAZELLE_RUN_DIR, + strlen(GAZELLE_RUN_DIR) + 1); + if (ret != EOK) { + printf("%s:%d strncpy_s fail ret=%d\n", __FUNCTION__, __LINE__, ret); +@@ -293,7 +287,7 @@ static int32_t dfx_connect_ltran(bool use_ltran, bool probe) + } + + if (g_unix_prefix) { +- ret = strncat_s(addr.sun_path, sizeof(addr.sun_path), g_unix_prefix, ++ ret = strncat_s(addr->sun_path, sizeof(addr->sun_path), g_unix_prefix, + strlen(g_unix_prefix) + 1); + if (ret != EOK) { + printf("%s:%d strncat_s fail ret=%d\n", __FUNCTION__, __LINE__, ret); +@@ -301,43 +295,89 @@ static int32_t dfx_connect_ltran(bool use_ltran, bool probe) + } + } + +- addr.sun_family = AF_UNIX; ++ addr->sun_family = AF_UNIX; + if (use_ltran) { +- ret = strncat_s(addr.sun_path, sizeof(addr.sun_path), LTRAN_DFX_SOCK_FILENAME, ++ ret = strncat_s(addr->sun_path, sizeof(addr->sun_path), LTRAN_DFX_SOCK_FILENAME, + strlen(LTRAN_DFX_SOCK_FILENAME) + 1); + if (ret != EOK) { + printf("%s:%d strncat_s fail ret=%d\n", __FUNCTION__, __LINE__, ret); + goto END; + } ++ memcpy_s(g_ltran_unix_path, PATH_MAX, addr->sun_path, sizeof(addr->sun_path)); + } else { +- ret = strncat_s(addr.sun_path, sizeof(addr.sun_path), LSTACK_DFX_SOCK_FILENAME, ++ ret = strncat_s(addr->sun_path, sizeof(addr->sun_path), LSTACK_DFX_SOCK_FILENAME, + strlen(LSTACK_DFX_SOCK_FILENAME) + 1); + if (ret != EOK) { + printf("%s:%d strncat_s fail ret=%d\n", __FUNCTION__, __LINE__, ret); + goto END; + } ++ memcpy_s(g_lstack_unix_path, PATH_MAX, addr->sun_path, sizeof(addr->sun_path)); + } ++ return 0; ++END: ++ return -1; ++} ++ ++static int32_t dfx_connect_server(bool use_ltran) ++{ ++ int32_t ret, fd; ++ struct sockaddr_un addr; ++ ++ fd = socket(AF_UNIX, SOCK_STREAM, 0); ++ if (fd == -1) { ++ printf("create socket failed. errno: %d\n", errno); ++ return GAZELLE_ERR; ++ } ++ ++ ret = dfx_make_unix_addr(&addr, use_ltran); ++ if (ret != 0) { ++ goto END; ++ } + + ret = connect(fd, (const struct sockaddr *)&addr, sizeof(struct sockaddr_un)); +- if (ret == -1) { +- if (!probe) { +- printf("connect ltran failed. errno: %d ret=%d\n", errno, ret); +- printf("You may need to use the -u parameter to specify the UNIX_PREFIX that matches the configuration.\n"); +- } ++ if (ret != 0) { + goto END; + } + + return fd; + END: ++ ret = errno; + close(fd); +- return GAZELLE_ERR; ++ return -ret; ++} ++ ++static int dfx_connect_probe(void) ++{ ++ int32_t ret1; ++ int32_t ret2; ++ ret1 = dfx_connect_server(true); ++ if (ret1 > 0) { ++ close(ret1); ++ return 1; ++ } ++ ret2 = dfx_connect_server(false); ++ if (ret2 > 0) { ++ close(ret2); ++ return 0; ++ } ++ ++ printf("Connect lstack(path:%s), errno: %d; Connect ltran(path:%s) failed, errno: %d\n", ++ g_lstack_unix_path, -ret2, g_ltran_unix_path, -ret1); ++ printf("Please ensure the process is started; If use ltran mode, \ ++ set use_ltran=1 in lstack.conf, otherwise set use_ltran=0\n"); ++ return -1; + } + + static int32_t dfx_stat_conn_to_ltran(struct gazelle_stat_msg_request *req_msg) + { +- int32_t fd = dfx_connect_ltran(g_use_ltran, false); ++ int32_t fd = dfx_connect_server(g_use_ltran); + if (fd < 0) { +- return fd; ++ if (g_use_ltran) { ++ printf("Connect ltran(path:%s) failed. errno: %d\n", g_ltran_unix_path, -fd); ++ } else { ++ printf("Connect lstack(path:%s) failed. errno: %d\n", g_lstack_unix_path, -fd); ++ } ++ return GAZELLE_ERR; + } + + int32_t ret = write_specied_len(fd, (char *)req_msg, sizeof(*req_msg)); +@@ -1417,12 +1457,12 @@ static int32_t parse_dfx_lstack_show_args(int32_t argc, char *argv[], struct gaz + char *param = argv[GAZELLE_OPTIONS1_ARG_IDX]; + if (strcmp(param, "rate") == 0 || strcmp(param, "-r") == 0) { + if (g_use_ltran) { +- req_msg[cmd_index++].stat_mode = GAZELLE_STAT_LTRAN_SHOW_LB_RATE; ++ req_msg[cmd_index++].stat_mode = GAZELLE_STAT_LTRAN_SHOW_LB_RATE; + } else { +- req_msg[cmd_index++].stat_mode = GAZELLE_STAT_LTRAN_START_LATENCY; +- req_msg[cmd_index++].stat_mode = GAZELLE_STAT_LTRAN_STOP_LATENCY; +- req_msg[cmd_index++].stat_mode = GAZELLE_STAT_LSTACK_SHOW_RATE; +- } ++ req_msg[cmd_index++].stat_mode = GAZELLE_STAT_LTRAN_START_LATENCY; ++ req_msg[cmd_index++].stat_mode = GAZELLE_STAT_LTRAN_STOP_LATENCY; ++ req_msg[cmd_index++].stat_mode = GAZELLE_STAT_LSTACK_SHOW_RATE; ++ } + req_msg[cmd_index++].stat_mode = GAZELLE_STAT_MODE_MAX; + } else if (strcmp(param, "snmp") == 0 || strcmp(param, "-s") == 0) { + req_msg[cmd_index++].stat_mode = GAZELLE_STAT_LSTACK_SHOW_SNMP; +@@ -1495,7 +1535,6 @@ static int32_t parse_dfx_lstack_args(int32_t argc, char *argv[], struct gazelle_ + return num_cmd; + } + +- + #ifdef GAZELLE_FAULT_INJECT_ENABLE + + #define GAZELLE_SET_FAULT_INJECT_PARAM_COUNT 6 +@@ -1770,19 +1809,48 @@ static int32_t parse_dfx_fault_inject_args(int32_t argc, char *argv[], struct ga + + #endif /* GAZELLE_FAULT_INJECT_ENABLE */ + ++static void parse_unix_arg(int32_t *argc, char *argv[]) ++{ ++ int unix_arg = 0; ++ for (int i = 1; i < *argc; i++) { ++ if (unix_arg == 0) { ++ if (!strcmp(argv[i], "-u")) { ++ unix_arg++; ++ } ++ } else if (unix_arg == 1) { ++ g_unix_prefix = argv[i]; ++ unix_arg++; ++ } else { ++ argv[i - unix_arg] = argv[i]; ++ } ++ } ++ ++ argv[*argc - unix_arg] = argv[*argc]; ++ *argc -= unix_arg; ++} ++ + static int32_t parse_dfx_cmd_args(int32_t argc, char *argv[], struct gazelle_stat_msg_request *req_msg) + { +- int32_t num_cmd = 0; ++ int num_cmd = 0; ++ int ret; + + if (argc < GAZELLE_PARAM_MINNUM) { + return num_cmd; + } + ++ parse_unix_arg(&argc, argv); ++ + char *param = argv[GAZELLE_TARGET_ARG_IDX]; + if (strcmp(param, "ltran") == 0) { ++ g_use_ltran = true; + num_cmd = parse_dfx_ltran_args(argc, argv, req_msg); + } + if (strcmp(param, "lstack") == 0) { ++ ret = dfx_connect_probe(); ++ if (ret < 0) { ++ exit(0); ++ } ++ g_use_ltran = ret; + num_cmd = parse_dfx_lstack_args(argc, argv, req_msg); + } + #ifdef GAZELLE_FAULT_INJECT_ENABLE +@@ -1846,28 +1914,6 @@ int32_t main(int32_t argc, char *argv[]) + struct gazelle_stat_msg_request req_msg[GAZELLE_CMD_MAX] = {0}; + int32_t req_msg_num; + +- int unix_arg = 0; +- for (int32_t i = 1; i < argc; i++) { +- if (unix_arg == 0) { +- if (!strcmp(argv[i], "-u")) { +- unix_arg++; +- } +- } else if (unix_arg == 1) { +- g_unix_prefix = argv[i]; +- unix_arg++; +- } else { +- argv[i - unix_arg] = argv[i]; +- } +- } +- +- argv[argc - unix_arg] = argv[argc]; +- argc -= unix_arg; +- +- int32_t fd = dfx_connect_ltran(true, true); +- if (fd > 0) { +- g_use_ltran = true; +- close(fd); +- } + req_msg_num = parse_dfx_cmd_args(argc, argv, req_msg); + if (req_msg_num <= 0 || req_msg_num > GAZELLE_CMD_MAX) { + show_usage(); +-- +2.27.0 + diff --git a/0148-fix-rpc_pool-create-failed-coredump.patch b/0148-fix-rpc_pool-create-failed-coredump.patch new file mode 100644 index 0000000..b52c089 --- /dev/null +++ b/0148-fix-rpc_pool-create-failed-coredump.patch @@ -0,0 +1,103 @@ +From 98b8e8cea061d65ece3865ce8e772f5b4226199e Mon Sep 17 00:00:00 2001 +From: jiangheng +Date: Tue, 27 Feb 2024 22:37:47 +0800 +Subject: [PATCH] fix rpc_pool create failed coredump + +--- + src/lstack/core/lstack_thread_rpc.c | 34 ++++++++++++++++++++------ + src/lstack/include/lstack_thread_rpc.h | 6 ++++- + 2 files changed, 31 insertions(+), 9 deletions(-) + +diff --git a/src/lstack/core/lstack_thread_rpc.c b/src/lstack/core/lstack_thread_rpc.c +index 1fdb037..20c5a43 100644 +--- a/src/lstack/core/lstack_thread_rpc.c ++++ b/src/lstack/core/lstack_thread_rpc.c +@@ -36,6 +36,27 @@ static inline __attribute__((always_inline)) struct rpc_msg *get_rpc_msg(struct + return msg; + } + ++static void rpc_msg_init(struct rpc_msg *msg, rpc_msg_func func, struct rpc_msg_pool *pool) ++{ ++ msg->rpcpool = pool; ++ pthread_spin_init(&msg->lock, PTHREAD_PROCESS_PRIVATE); ++ msg->func = func; ++ msg->sync_flag = 1; ++ msg->recall_flag = 0; ++} ++ ++static struct rpc_msg *rpc_msg_alloc_except(rpc_msg_func func) ++{ ++ struct rpc_msg *msg = calloc(1, sizeof(struct rpc_msg)); ++ if (msg == NULL) { ++ return NULL; ++ } ++ ++ rpc_msg_init(msg, func, NULL); ++ ++ return msg; ++} ++ + static struct rpc_msg *rpc_msg_alloc(rpc_msg_func func) + { + struct rpc_msg *msg = NULL; +@@ -45,14 +66,15 @@ static struct rpc_msg *rpc_msg_alloc(rpc_msg_func func) + if (g_rpc_pool == NULL) { + LSTACK_LOG(INFO, LSTACK, "g_rpc_pool calloc failed\n"); + g_rpc_stats.call_alloc_fail++; +- return NULL; ++ exit(-1); + } + + g_rpc_pool->mempool = create_mempool("rpc_pool", RPC_MSG_MAX, sizeof(struct rpc_msg), + 0, rte_gettid()); + if (g_rpc_pool->mempool == NULL) { ++ LSTACK_LOG(INFO, LSTACK, "rpc_pool create failed, errno is %d\n", errno); + g_rpc_stats.call_alloc_fail++; +- return NULL; ++ exit(-1); + } + } + +@@ -61,12 +83,8 @@ static struct rpc_msg *rpc_msg_alloc(rpc_msg_func func) + g_rpc_stats.call_alloc_fail++; + return NULL; + } +- msg->rpcpool = g_rpc_pool; ++ rpc_msg_init(msg, func, g_rpc_pool); + +- pthread_spin_init(&msg->lock, PTHREAD_PROCESS_PRIVATE); +- msg->func = func; +- msg->sync_flag = 1; +- msg->recall_flag = 0; + return msg; + } + +@@ -247,7 +265,7 @@ int32_t rpc_call_close(rpc_queue *queue, int fd) + + int32_t rpc_call_stack_exit(rpc_queue *queue) + { +- struct rpc_msg *msg = rpc_msg_alloc(stack_exit_by_rpc); ++ struct rpc_msg *msg = rpc_msg_alloc_except(stack_exit_by_rpc); + if (msg == NULL) { + return -1; + } +diff --git a/src/lstack/include/lstack_thread_rpc.h b/src/lstack/include/lstack_thread_rpc.h +index 30caa66..4d89604 100644 +--- a/src/lstack/include/lstack_thread_rpc.h ++++ b/src/lstack/include/lstack_thread_rpc.h +@@ -104,7 +104,11 @@ static inline __attribute__((always_inline)) void rpc_call(rpc_queue *queue, str + static inline __attribute__((always_inline)) void rpc_msg_free(struct rpc_msg *msg) + { + pthread_spin_destroy(&msg->lock); +- rte_mempool_put(msg->rpcpool->mempool, (void *)msg); ++ if (msg->rpcpool != NULL && msg->rpcpool->mempool != NULL) { ++ rte_mempool_put(msg->rpcpool->mempool, (void *)msg); ++ } else { ++ free(msg); ++ } + } + + #endif +-- +2.27.0 + diff --git a/gazelle.spec b/gazelle.spec index e9ed1ad..a2fb3e2 100644 --- a/gazelle.spec +++ b/gazelle.spec @@ -2,7 +2,7 @@ Name: gazelle Version: 1.0.2 -Release: 28 +Release: 29 Summary: gazelle is a high performance user-mode stack License: MulanPSL-2.0 URL: https://gitee.com/openeuler/gazelle @@ -154,6 +154,14 @@ Patch9137: 0137-split-the-flow-fules-related-functions-into-separate.patch Patch9138: 0138-fix-coreddump-when-stack-setup-failed-in-rtc-mode.patch Patch9139: 0139-diff-udp-and-tcp-read-from-stack.patch Patch9140: 0140-FAULT-INJECT-gazelle-add-packet-delay-and-packet-dro.patch +Patch9141: 0141-recv-support-MSG_DONTWAIT.patch +Patch9142: 0142-do_setsockopt-function-no-longer-checks-the-results-.patch +Patch9143: 0143-FAUT-INJECT-add-fault-inject-unset-method.patch +Patch9144: 0144-support-udp-pkglen-mtu.patch +Patch9145: 0145-add-limit-with-level-for-sockopt.patch +Patch9146: 0146-udp-add-restriction-message-too-long.patch +Patch9147: 0147-dfx-improve-log-readability-when-connect-ltran-lstac.patch +Patch9148: 0148-fix-rpc_pool-create-failed-coredump.patch %description %{name} is a high performance user-mode stack. @@ -195,6 +203,16 @@ install -Dpm 0640 %{_builddir}/%{name}-%{version}/src/ltran/ltran.conf %{b %config(noreplace) %{conf_path}/ltran.conf %changelog +* Thu Mar 14 2024 yinbin6 - 1.0.2-29 +- fix rpc_pool create failed coredump +- dfx: improve log readability when connect ltran/lstack failed +- udp add restriction: message too long +- add limit with level for sockopt +- support udp pkglen > mtu +- FAUT INJECT: add fault inject unset method +- do_setsockopt function no longer checks the results of the kernel. +- recv support MSG_DONTWAIT + * Thu Mar 14 2024 yinbin6 - 1.0.2-28 - FAULT INJECT: gazelle add packet delay and packet drop - diff udp and tcp read from stack