Open Build Service

We truncated the diff of some files because they were too big. If you want to see the full diff for every file, click here.

Changes of Revision 96

_service:tar_scm:gazelle.spec Changed

@@ -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 @@
 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 @@
 %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

_service:tar_scm:0141-recv-support-MSG_DONTWAIT.patch Added

@@ -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
+

_service:tar_scm:0142-do_setsockopt-function-no-longer-checks-the-results-.patch Added

_service:tar_scm:0143-FAUT-INJECT-add-fault-inject-unset-method.patch Added

@@ -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;

_service:tar_scm:0144-support-udp-pkglen-mtu.patch Added

@@ -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
+

_service:tar_scm:0145-add-limit-with-level-for-sockopt.patch Added

@@ -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
+

_service:tar_scm:0146-udp-add-restriction-message-too-long.patch Added

@@ -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
+

_service:tar_scm:0147-dfx-improve-log-readability-when-connect-ltran-lstac.patch Added

@@ -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++;
++                       }

_service:tar_scm:0148-fix-rpc_pool-create-failed-coredump.patch Added

@@ -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
+

_service:tar_scm:gazelle-1710405912.3687929.tar Deleted

_service:tar_scm:gazelle-1710470578.592cf63.tar Added