packages/gazelle
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

!722 [sync] PR-713: sync fix rpc_pool create failed coredump

Browse Source 
From: @openeuler-sync-bot 
Reviewed-by: @jiangheng12 
Signed-off-by: @jiangheng12
This commit is contained in:
openeuler-ci-bot 2024-03-15 02:47:54 +00:00 committed by Gitee
commit 7dc2bd0804
No known key found for this signature in database
GPG Key ID: 173E9B9CA92EEF8F
9 changed files with 923 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
0141-recv-support-MSG_DONTWAIT.patch Normal file
View File

@ -0,0 +1,36 @@
From 34c272bf7f0484a1371033c187719adc72f061d5 Mon Sep 17 00:00:00 2001
From: li_yunqing <liyunqing@kylinos.cn>
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

29
0142-do_setsockopt-function-no-longer-checks-the-results-.patch Normal file
View File

@ -0,0 +1,29 @@
From 712a3c23451ed79449cea9322586d958c27c679f Mon Sep 17 00:00:00 2001
From: jiangjixiang <jiangjixiang@kylinos.cn>
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

254
0143-FAUT-INJECT-add-fault-inject-unset-method.patch Normal file
View File

@ -0,0 +1,254 @@
From c2cf2ef0cc9f28a8322e17870d209f546ad6711d Mon Sep 17 00:00:00 2001
From: yinbin6 <yinbin8@huawei.com>
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 <stdbool.h>
-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

85
0144-support-udp-pkglen-mtu.patch Normal file
View File

@ -0,0 +1,85 @@
From 5ba19529acaf76a681313245a9a278356b615687 Mon Sep 17 00:00:00 2001
From: yangchen <yangchen145@huawei.com>
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

86
0145-add-limit-with-level-for-sockopt.patch Normal file
View File

@ -0,0 +1,86 @@
From 5e4b2366417b5f951ffd5ee45c0917ae67bd502e Mon Sep 17 00:00:00 2001
From: hantwofish <hankangkang5@huawei.com>
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

42
0146-udp-add-restriction-message-too-long.patch Normal file
View File

@ -0,0 +1,42 @@
From a37c451e63bed06a70e887aba6364183d71f414f Mon Sep 17 00:00:00 2001
From: yangchen <yangchen145@huawei.com>
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

269
0147-dfx-improve-log-readability-when-connect-ltran-lstac.patch Normal file
View File

@ -0,0 +1,269 @@
From 9d68f6bca1adfba6802e85aa213dbba5002cb289 Mon Sep 17 00:00:00 2001
From: jiangheng <jiangheng14@huawei.com>
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

103
0148-fix-rpc_pool-create-failed-coredump.patch Normal file
View File

@ -0,0 +1,103 @@
From 98b8e8cea061d65ece3865ce8e772f5b4226199e Mon Sep 17 00:00:00 2001
From: jiangheng <jiangheng14@huawei.com>
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

20
gazelle.spec
View File

@ -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 <jiangheng14@huawei.com> - 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 <jiangheng14@huawei.com> - 1.0.2-28
- FAULT INJECT: gazelle add packet delay and packet drop
- diff udp and tcp read from stack