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

sync FAULT INJECT: gazelle add packet delay and packet drop

Browse Source 
(cherry picked from commit b8f329ae854d5dc96cf94d0b1634eb95881917f4)
This commit is contained in:
jiangheng 2024-03-14 16:18:25 +08:00 committed by openeuler-sync-bot
parent 28ba70b0ae
commit 4c132e3e07
10 changed files with 4833 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

62
0132-add-observable-method-of-data-aggregation.patch Normal file
View File

@ -0,0 +1,62 @@
From 36d2ddc58cd0f467d6d7682689cc10947a8a1973 Mon Sep 17 00:00:00 2001
From: yangchen <yangchen145@huawei.com>
Date: Tue, 6 Feb 2024 11:29:26 +0800
Subject: [PATCH] add observable method of data aggregation
---
src/common/gazelle_dfx_msg.h | 2 ++
src/lstack/core/lstack_lwip.c | 2 ++
src/ltran/ltran_dfx.c | 4 +++-
3 files changed, 7 insertions(+), 1 deletion(-)
diff --git a/src/common/gazelle_dfx_msg.h b/src/common/gazelle_dfx_msg.h
index d465efa..1ca210b 100644
--- a/src/common/gazelle_dfx_msg.h
+++ b/src/common/gazelle_dfx_msg.h
@@ -73,6 +73,8 @@ struct gazelle_stack_stat {
uint64_t tx;
uint64_t tx_prepare_fail;
uint64_t accept_fail;
+ uint64_t sock_rx_drop;
+ uint64_t sock_tx_merge;
};
struct gazelle_wakeup_stat {
diff --git a/src/lstack/core/lstack_lwip.c b/src/lstack/core/lstack_lwip.c
index 63044c2..4523907 100644
--- a/src/lstack/core/lstack_lwip.c
+++ b/src/lstack/core/lstack_lwip.c
@@ -541,6 +541,7 @@ static ssize_t do_lwip_fill_sendring(struct lwip_sock *sock, const void *buf, si
/* merge data into last pbuf */
if (!NETCONN_IS_UDP(sock) && sock->remain_len) {
+ sock->stack->stats.sock_tx_merge++;
send_len = merge_data_lastpbuf(sock, (char *)buf, len);
if (send_len >= len) {
send_len = len;
@@ -1039,6 +1040,7 @@ ssize_t do_lwip_read_from_stack(int32_t fd, void *buf, size_t len, int32_t flags
/* in udp, if pbuf remaining len less than copy_len, discard these packets */
if (recvd > 0 && NETCONN_IS_UDP(sock)) {
+ sock->stack->stats.sock_rx_drop++;
break;
}
}
diff --git a/src/ltran/ltran_dfx.c b/src/ltran/ltran_dfx.c
index 4b246a1..9f12096 100644
--- a/src/ltran/ltran_dfx.c
+++ b/src/ltran/ltran_dfx.c
@@ -648,7 +648,9 @@ static void show_lstack_stats(struct gazelle_stack_dfx_data *lstack_stat)
printf("send_pkts_fail: %-13"PRIu64" ", lstack_stat->data.pkts.stack_stat.send_pkts_fail);
printf("mbuf_pool_freecnt: %-10"PRIu32" ", lstack_stat->data.pkts.mbufpool_avail_cnt);
printf("rpc_pool_freecnt: %-12"PRIu32" \n", lstack_stat->data.pkts.rpcpool_avail_cnt);
- printf("accpet_fail: %-12"PRIu64" \n", lstack_stat->data.pkts.stack_stat.accept_fail);
+ printf("accpet_fail: %-16"PRIu64" ", lstack_stat->data.pkts.stack_stat.accept_fail);
+ printf("sock_rx_drop: %-15"PRIu64" ", lstack_stat->data.pkts.stack_stat.sock_rx_drop);
+ printf("sock_tx_merge: %-16"PRIu64" \n", lstack_stat->data.pkts.stack_stat.sock_tx_merge);
}
static void gazelle_print_lstack_stat_detail(struct gazelle_stack_dfx_data *lstack_stat,
--
2.27.0

191
0133-try-to-ensure-arp-packet-can-be-sent.patch Normal file
View File

@ -0,0 +1,191 @@
From 1a7bb2f60a459c2cca6646ccbe04a52fcd8272f6 Mon Sep 17 00:00:00 2001
From: jiangheng <jiangheng14@huawei.com>
Date: Wed, 31 Jan 2024 14:49:40 +0800
Subject: [PATCH] try to ensure arp packet can be sent
---
src/lstack/core/lstack_dpdk.c | 18 ++++++++++--------
src/lstack/core/lstack_lwip.c | 13 ++++++++++---
src/lstack/core/lstack_protocol_stack.c | 4 ++--
src/lstack/include/lstack_dpdk.h | 2 +-
src/lstack/include/lstack_protocol_stack.h | 2 +-
src/lstack/netif/lstack_ethdev.c | 8 ++++----
src/lstack/netif/lstack_vdev.c | 2 +-
7 files changed, 29 insertions(+), 20 deletions(-)
diff --git a/src/lstack/core/lstack_dpdk.c b/src/lstack/core/lstack_dpdk.c
index e352850..74e033b 100644
--- a/src/lstack/core/lstack_dpdk.c
+++ b/src/lstack/core/lstack_dpdk.c
@@ -280,14 +280,16 @@ int32_t create_shared_ring(struct protocol_stack *stack)
return 0;
}
-int32_t dpdk_alloc_pktmbuf(struct rte_mempool *pool, struct rte_mbuf **mbufs, uint32_t num)
+int32_t dpdk_alloc_pktmbuf(struct rte_mempool *pool, struct rte_mbuf **mbufs, uint32_t num, bool reserve)
{
- /*
- * don't use rte_mempool_avail_count, it traverse cpu local cache,
- * when RTE_MAX_LCORE is too large, it's time-consuming
- */
- if (rte_ring_count(pool->pool_data) < MBUFPOOL_RESERVE_NUM + num) {
- return -ENOMEM;
+ if (reserve) {
+ /*
+ * don't use rte_mempool_avail_count, it traverse cpu local cache,
+ * when RTE_MAX_LCORE is too large, it's time-consuming
+ */
+ if (rte_ring_count(pool->pool_data) < MBUFPOOL_RESERVE_NUM + num) {
+ return -ENOMEM;
+ }
}
int32_t ret = rte_pktmbuf_alloc_bulk(pool, mbufs, num);
@@ -310,7 +312,7 @@ int32_t fill_mbuf_to_ring(struct rte_mempool *mempool, struct rte_ring *ring, ui
while (remain > 0) {
batch = LWIP_MIN(remain, RING_SIZE(FREE_RX_QUEUE_SZ));
- ret = dpdk_alloc_pktmbuf(mempool, free_buf, batch);
+ ret = dpdk_alloc_pktmbuf(mempool, free_buf, batch, true);
if (ret != 0) {
LSTACK_LOG(ERR, LSTACK, "cannot alloc mbuf for ring, count: %u ret=%d\n", batch, ret);
return -1;
diff --git a/src/lstack/core/lstack_lwip.c b/src/lstack/core/lstack_lwip.c
index 3f76424..da50fec 100644
--- a/src/lstack/core/lstack_lwip.c
+++ b/src/lstack/core/lstack_lwip.c
@@ -22,6 +22,7 @@
#include <lwip/posix_api.h>
#include <lwip/api.h>
#include <lwip/tcp.h>
+#include <lwip/prot/etharp.h>
#include <securec.h>
#include <rte_errno.h>
#include <rte_malloc.h>
@@ -101,7 +102,6 @@ static struct pbuf *init_mbuf_to_pbuf(struct rte_mbuf *mbuf, pbuf_layer layer, u
struct pbuf *pbuf = pbuf_alloced_custom(layer, length, type, pbuf_custom, data, MAX_PACKET_SZ);
if (pbuf) {
pbuf->allow_in = 1;
- pbuf->last = pbuf;
pbuf->addr = *IP_ANY_TYPE;
pbuf->port = 0;
pthread_spin_init(&pbuf->pbuf_lock, PTHREAD_PROCESS_SHARED);
@@ -122,7 +122,7 @@ static bool replenish_send_idlembuf(struct protocol_stack *stack, struct lwip_so
return false;
}
- if (dpdk_alloc_pktmbuf(stack->rxtx_mbuf_pool, (struct rte_mbuf **)pbuf, replenish_cnt) != 0) {
+ if (dpdk_alloc_pktmbuf(stack->rxtx_mbuf_pool, (struct rte_mbuf **)pbuf, replenish_cnt, true) != 0) {
stack->stats.tx_allocmbuf_fail++;
return true;
}
@@ -209,10 +209,17 @@ void do_lwip_free_pbuf(struct pbuf *pbuf)
struct pbuf *do_lwip_alloc_pbuf(pbuf_layer layer, uint16_t length, pbuf_type type)
{
+ int ret;
struct rte_mbuf *mbuf;
struct protocol_stack *stack = get_protocol_stack();
- if (dpdk_alloc_pktmbuf(stack->rxtx_mbuf_pool, &mbuf, 1) != 0) {
+ /* ensure arp packet can be sent */
+ if (layer == PBUF_LINK && length == SIZEOF_ETHARP_HDR) {
+ ret = dpdk_alloc_pktmbuf(stack->rxtx_mbuf_pool, &mbuf, 1, false);
+ } else {
+ ret = dpdk_alloc_pktmbuf(stack->rxtx_mbuf_pool, &mbuf, 1, true);
+ }
+ if (ret != 0) {
stack->stats.tx_allocmbuf_fail++;
return NULL;
}
diff --git a/src/lstack/core/lstack_protocol_stack.c b/src/lstack/core/lstack_protocol_stack.c
index 8b99e82..cb39928 100644
--- a/src/lstack/core/lstack_protocol_stack.c
+++ b/src/lstack/core/lstack_protocol_stack.c
@@ -940,7 +940,7 @@ void stack_broadcast_arp(struct rte_mbuf *mbuf, struct protocol_stack *cur_stack
continue;
}
- ret = dpdk_alloc_pktmbuf(stack->rxtx_mbuf_pool, &mbuf_copy, 1);
+ ret = dpdk_alloc_pktmbuf(stack->rxtx_mbuf_pool, &mbuf_copy, 1, true);
if (ret != 0) {
stack->stats.rx_allocmbuf_fail++;
return;
@@ -952,7 +952,7 @@ void stack_broadcast_arp(struct rte_mbuf *mbuf, struct protocol_stack *cur_stack
return;
}
}
- ret = dpdk_alloc_pktmbuf(cur_stack->rxtx_mbuf_pool, &mbuf_copy, 1);
+ ret = dpdk_alloc_pktmbuf(cur_stack->rxtx_mbuf_pool, &mbuf_copy, 1, true);
if (ret != 0) {
cur_stack->stats.rx_allocmbuf_fail++;
return;
diff --git a/src/lstack/include/lstack_dpdk.h b/src/lstack/include/lstack_dpdk.h
index b39d199..c40f3c0 100644
--- a/src/lstack/include/lstack_dpdk.h
+++ b/src/lstack/include/lstack_dpdk.h
@@ -56,6 +56,6 @@ struct rte_mempool *create_pktmbuf_mempool(const char *name, uint32_t nb_mbuf,
uint32_t mbuf_cache_size, uint16_t queue_id, unsigned numa_id);
void dpdk_nic_xstats_get(struct gazelle_stack_dfx_data *dfx, uint16_t port_id);
-int32_t dpdk_alloc_pktmbuf(struct rte_mempool *pool, struct rte_mbuf **mbufs, uint32_t num);
+int32_t dpdk_alloc_pktmbuf(struct rte_mempool *pool, struct rte_mbuf **mbufs, uint32_t num, bool reserve);
void dpdk_nic_features_get(struct gazelle_stack_dfx_data *dfx, uint16_t port_id);
#endif /* GAZELLE_DPDK_H */
diff --git a/src/lstack/include/lstack_protocol_stack.h b/src/lstack/include/lstack_protocol_stack.h
index c681547..0a523b7 100644
--- a/src/lstack/include/lstack_protocol_stack.h
+++ b/src/lstack/include/lstack_protocol_stack.h
@@ -31,7 +31,7 @@
#define SOCK_SEND_REPLENISH_THRES (16)
#define WAKEUP_MAX_NUM (32)
-#define MBUFPOOL_RESERVE_NUM 5000
+#define MBUFPOOL_RESERVE_NUM (get_global_cfg_params()->nic.rxqueue_size + 1024)
struct rte_mempool;
struct rte_ring;
diff --git a/src/lstack/netif/lstack_ethdev.c b/src/lstack/netif/lstack_ethdev.c
index 4d6f620..acf3c10 100644
--- a/src/lstack/netif/lstack_ethdev.c
+++ b/src/lstack/netif/lstack_ethdev.c
@@ -543,9 +543,9 @@ void parse_arp_and_transefer(char* buf)
int32_t ret;
for (int32_t i = 0; i < stack_group->stack_num; i++) {
stack = stack_group->stacks[i];
- ret = dpdk_alloc_pktmbuf(stack->rxtx_mbuf_pool, &mbuf_copy, 1);
+ ret = dpdk_alloc_pktmbuf(stack->rxtx_mbuf_pool, &mbuf_copy, 1, true);
while (ret != 0) {
- ret = dpdk_alloc_pktmbuf(stack->rxtx_mbuf_pool, &mbuf_copy, 1);
+ ret = dpdk_alloc_pktmbuf(stack->rxtx_mbuf_pool, &mbuf_copy, 1, true);
stack->stats.rx_allocmbuf_fail++;
}
copy_mbuf(mbuf_copy, mbuf);
@@ -572,9 +572,9 @@ void parse_tcp_and_transefer(char* buf)
struct rte_mbuf *mbuf_copy = NULL;
struct protocol_stack *stack = stack_group->stacks[stk_index];
- int32_t ret = dpdk_alloc_pktmbuf(stack->rxtx_mbuf_pool, &mbuf_copy, 1);
+ int32_t ret = dpdk_alloc_pktmbuf(stack->rxtx_mbuf_pool, &mbuf_copy, 1, true);
while (ret != 0) {
- ret = dpdk_alloc_pktmbuf(stack->rxtx_mbuf_pool, &mbuf_copy, 1);
+ ret = dpdk_alloc_pktmbuf(stack->rxtx_mbuf_pool, &mbuf_copy, 1, true);
stack->stats.rx_allocmbuf_fail++;
}
diff --git a/src/lstack/netif/lstack_vdev.c b/src/lstack/netif/lstack_vdev.c
index fe17f59..f78e48a 100644
--- a/src/lstack/netif/lstack_vdev.c
+++ b/src/lstack/netif/lstack_vdev.c
@@ -59,7 +59,7 @@ static uint32_t ltran_rx_poll(struct protocol_stack *stack, struct rte_mbuf **pk
stack->rx_ring_used += rcvd_pkts;
if (unlikely(stack->rx_ring_used >= USED_RX_PKTS_WATERMARK)) {
uint32_t free_cnt = LWIP_MIN(stack->rx_ring_used, RING_SIZE(DPDK_PKT_BURST_SIZE));
- int32_t ret = dpdk_alloc_pktmbuf(stack->rxtx_mbuf_pool, (struct rte_mbuf **)free_buf, free_cnt);
+ int32_t ret = dpdk_alloc_pktmbuf(stack->rxtx_mbuf_pool, (struct rte_mbuf **)free_buf, free_cnt, true);
if (likely(ret == 0)) {
nr_pkts = gazelle_ring_sp_enqueue(stack->rx_ring, (void **)free_buf, free_cnt);
stack->rx_ring_used -= nr_pkts;
--
2.27.0

345
0134-gazellectl-support-send-latency-show.patch Normal file
View File

@ -0,0 +1,345 @@
From 03eabf12b7d486278598ad44d2b7d8e310ff0abf Mon Sep 17 00:00:00 2001
From: yangchen <yangchen145@huawei.com>
Date: Sun, 4 Feb 2024 13:29:15 +0800
Subject: [PATCH] gazellectl: support send latency show
---
src/common/dpdk_common.h | 10 +++
src/common/gazelle_dfx_msg.h | 20 ++++-
src/lstack/core/lstack_lwip.c | 14 +++-
src/lstack/core/lstack_stack_stat.c | 15 ++--
src/lstack/netif/lstack_ethdev.c | 4 +
src/ltran/ltran_dfx.c | 110 +++++++++++++++-------------
6 files changed, 111 insertions(+), 62 deletions(-)
diff --git a/src/common/dpdk_common.h b/src/common/dpdk_common.h
index 38f09ae..a79a0f2 100644
--- a/src/common/dpdk_common.h
+++ b/src/common/dpdk_common.h
@@ -95,6 +95,16 @@ static __rte_always_inline void time_stamp_into_mbuf(uint32_t rx_count, struct r
}
}
+static __rte_always_inline void time_stamp_into_pbuf(uint32_t tx_count, struct pbuf *buf[], uint64_t time_stamp)
+{
+ struct latency_timestamp *lt;
+ for (uint32_t i = 0; i < tx_count; i++) {
+ lt = &pbuf_to_private(buf[i])->lt;
+ lt->stamp = time_stamp;
+ lt->check = ~(time_stamp);
+ }
+}
+
bool get_kni_started(void);
struct rte_kni* get_gazelle_kni(void);
int32_t dpdk_kni_init(uint16_t port, struct rte_mempool *pool);
diff --git a/src/common/gazelle_dfx_msg.h b/src/common/gazelle_dfx_msg.h
index d465efa..d47ed9a 100644
--- a/src/common/gazelle_dfx_msg.h
+++ b/src/common/gazelle_dfx_msg.h
@@ -24,6 +24,10 @@
/* maybe it should be consistent with MEMP_NUM_TCP_PCB */
#define GAZELLE_LSTACK_MAX_CONN (20000 + 2000) // same as MAX_CLIENTS + RESERVED_CLIENTS in lwipopts.h
+#define GAZELLE_RESULT_LEN 4096
+#define GAZELLE_MAX_LATENCY_TIME 1800 // max latency time 30mins
+#define GAZELLE_RESULT_LINE_LEN 80 // for a single row, the max len of result is 80
+
enum GAZELLE_STAT_MODE {
GAZELLE_STAT_LTRAN_SHOW = 0,
GAZELLE_STAT_LTRAN_SHOW_RATE,
@@ -54,8 +58,11 @@ enum GAZELLE_STAT_MODE {
};
enum GAZELLE_LATENCY_TYPE {
- GAZELLE_LATENCY_LWIP,
- GAZELLE_LATENCY_READ,
+ GAZELLE_LATENCY_READ_LWIP,
+ GAZELLE_LATENCY_READ_LSTACK,
+ GAZELLE_LATENCY_WRITE_LWIP,
+ GAZELLE_LATENCY_WRITE_LSTACK,
+ GAZELLE_LATENCY_MAX,
};
struct gazelle_stack_stat {
@@ -216,9 +223,14 @@ struct stack_latency {
uint64_t latency_total;
};
+struct gazelle_latency_result {
+ int latency_stat_index;
+ struct stack_latency latency_stat_record;
+ char latency_stat_result[GAZELLE_RESULT_LEN];
+};
+
struct gazelle_stack_latency {
- struct stack_latency read_latency;
- struct stack_latency lwip_latency;
+ struct stack_latency latency[GAZELLE_LATENCY_MAX];
uint64_t start_time;
uint64_t g_cycles_per_us;
};
diff --git a/src/lstack/core/lstack_lwip.c b/src/lstack/core/lstack_lwip.c
index 22605dd..be2c6de 100644
--- a/src/lstack/core/lstack_lwip.c
+++ b/src/lstack/core/lstack_lwip.c
@@ -244,6 +244,11 @@ struct pbuf *do_lwip_get_from_sendring(struct lwip_sock *sock, uint16_t remain_s
if (pbuf == NULL) {
return NULL;
}
+
+ if (get_protocol_stack_group()->latency_start) {
+ calculate_lstack_latency(&sock->stack->latency, pbuf, GAZELLE_LATENCY_WRITE_LWIP);
+ }
+
sock->send_pre_del = pbuf;
if (!gazelle_ring_readover_count(sock->send_ring)) {
@@ -303,6 +308,11 @@ static inline ssize_t app_buff_write(struct lwip_sock *sock, void *buf, size_t l
(void)gazelle_ring_read(sock->send_ring, (void **)pbufs, write_num);
+ if (get_protocol_stack_group()->latency_start) {
+ uint64_t time_stamp = get_current_time();
+ time_stamp_into_pbuf(write_num, pbufs, time_stamp);
+ }
+
ssize_t send_len = do_app_write(pbufs, buf, len, write_num);
if (addr) {
@@ -573,7 +583,7 @@ ssize_t do_lwip_read_from_lwip(struct lwip_sock *sock, int32_t flags, u8_t apifl
for (uint32_t i = 0; get_protocol_stack_group()->latency_start && i < read_count; i++) {
if (pbufs[i] != NULL) {
- calculate_lstack_latency(&sock->stack->latency, pbufs[i], GAZELLE_LATENCY_LWIP);
+ calculate_lstack_latency(&sock->stack->latency, pbufs[i], GAZELLE_LATENCY_READ_LWIP);
}
}
@@ -895,7 +905,7 @@ ssize_t do_lwip_read_from_stack(int32_t fd, void *buf, size_t len, int32_t flags
sock->wakeup->stat.app_read_cnt += 1;
}
if (latency_enable) {
- calculate_lstack_latency(&sock->stack->latency, pbuf, GAZELLE_LATENCY_READ);
+ calculate_lstack_latency(&sock->stack->latency, pbuf, GAZELLE_LATENCY_READ_LSTACK);
}
gazelle_ring_read_over(sock->recv_ring);
diff --git a/src/lstack/core/lstack_stack_stat.c b/src/lstack/core/lstack_stack_stat.c
index 23571b4..cb11dc3 100644
--- a/src/lstack/core/lstack_stack_stat.c
+++ b/src/lstack/core/lstack_stack_stat.c
@@ -53,8 +53,9 @@ void calculate_lstack_latency(struct gazelle_stack_latency *stack_latency, const
{
uint64_t latency;
const struct latency_timestamp *lt;
+ struct stack_latency *latency_stat;
- if (pbuf == NULL) {
+ if (pbuf == NULL || type >= GAZELLE_LATENCY_MAX) {
return;
}
@@ -62,10 +63,9 @@ void calculate_lstack_latency(struct gazelle_stack_latency *stack_latency, const
if (lt->stamp != ~(lt->check) || lt->stamp < stack_latency->start_time) {
return;
}
- latency = get_current_time() - lt->stamp;
- struct stack_latency *latency_stat = (type == GAZELLE_LATENCY_LWIP) ?
- &stack_latency->lwip_latency : &stack_latency->read_latency;
+ latency = get_current_time() - lt->stamp;
+ latency_stat = &stack_latency->latency[type];
latency_stat->latency_total += latency;
latency_stat->latency_max = (latency_stat->latency_max > latency) ? latency_stat->latency_max : latency;
@@ -118,8 +118,11 @@ static void set_latency_start_flag(bool start)
LSTACK_LOG(ERR, LSTACK, "memset_s faile\n");
}
stack->latency.start_time = get_current_time();
- stack->latency.lwip_latency.latency_min = ~((uint64_t)0);
- stack->latency.read_latency.latency_min = ~((uint64_t)0);
+
+ for (uint32_t j = 0; j < GAZELLE_LATENCY_MAX; j++) {
+ stack->latency.latency[j].latency_min = ~((uint64_t)0);
+ }
+
memset_s(&stack->aggregate_stats, sizeof(struct gazelle_stack_aggregate_stats),
0, sizeof(stack->aggregate_stats));
}
diff --git a/src/lstack/netif/lstack_ethdev.c b/src/lstack/netif/lstack_ethdev.c
index 4d6f620..94ecffc 100644
--- a/src/lstack/netif/lstack_ethdev.c
+++ b/src/lstack/netif/lstack_ethdev.c
@@ -889,6 +889,10 @@ static err_t eth_dev_output(struct netif *netif, struct pbuf *pbuf)
pre_mbuf = mbuf;
rte_mbuf_refcnt_update(mbuf, 1);
+
+ if (get_protocol_stack_group()->latency_start) {
+ calculate_lstack_latency(&stack->latency, pbuf, GAZELLE_LATENCY_WRITE_LSTACK);
+ }
pbuf = pbuf->next;
}
diff --git a/src/ltran/ltran_dfx.c b/src/ltran/ltran_dfx.c
index 4b246a1..ecdb5f9 100644
--- a/src/ltran/ltran_dfx.c
+++ b/src/ltran/ltran_dfx.c
@@ -50,9 +50,6 @@
#define GAZELLE_CMD_MAX 5
#define CMD_WAIT_TIME 1 // sec
-#define GAZELLE_RESULT_LEN 8291
-#define GAZELLE_MAX_LATENCY_TIME 1800 // max latency time 30mins
-
#define GAZELLE_DECIMAL 10
#define GAZELLE_KEEPALIVE_STR_LEN 35
#define GAZELLE_TIME_STR_LEN 25
@@ -702,8 +699,8 @@ static void parse_thread_latency_result(const struct stack_latency *latency, cha
{
if (latency->latency_pkts > 0) {
*pos += sprintf_s(result + *pos, max_len, "%-8"PRIu64" ", latency->latency_pkts);
- *pos += sprintf_s(result + *pos, max_len, "%-6"PRIu64" ", latency->latency_min);
- *pos += sprintf_s(result + *pos, max_len, "%-6"PRIu64" ", latency->latency_max);
+ *pos += sprintf_s(result + *pos, max_len, "%-8"PRIu64" ", latency->latency_min);
+ *pos += sprintf_s(result + *pos, max_len, "%-8"PRIu64" ", latency->latency_max);
*pos += sprintf_s(result + *pos, max_len, "%-6.2f \n",
(double)latency->latency_total / latency->latency_pkts);
} else {
@@ -719,52 +716,53 @@ static void parse_thread_latency_result(const struct stack_latency *latency, cha
static void parse_latency_total_result(char *result, size_t max_len, int32_t *pos,
const struct stack_latency *record)
{
+ if (max_len < GAZELLE_RESULT_LINE_LEN) {
+ printf("total latency result show failed, out of memory bounds\n");
+ return;
+ }
+
if (record->latency_pkts > 0) {
- *pos += sprintf_s(result + *pos, max_len, " total: ");
+ *pos += sprintf_s(result + *pos, max_len, " total: ");
*pos += sprintf_s(result + *pos, max_len, "%-8"PRIu64" ", record->latency_pkts);
- *pos += sprintf_s(result + *pos, max_len, "%-6"PRIu64" ", record->latency_min);
- *pos += sprintf_s(result + *pos, max_len, "%-6"PRIu64" ", record->latency_max);
- *pos += sprintf_s(result + *pos, max_len, "%-6.2f \n\n\n",
+ *pos += sprintf_s(result + *pos, max_len, "%-8"PRIu64" ", record->latency_min);
+ *pos += sprintf_s(result + *pos, max_len, "%-8"PRIu64" ", record->latency_max);
+ *pos += sprintf_s(result + *pos, max_len, "%-6.2f \n\n",
(double)record->latency_total / record->latency_pkts);
} else {
- *pos += sprintf_s(result + *pos, max_len, " total: 0\n\n\n");
+ *pos += sprintf_s(result + *pos, max_len, " total: 0\n\n");
}
}
-static void gazelle_print_lstack_stat_latency(void *buf, const struct gazelle_stat_msg_request *req_msg)
+static void gazelle_show_latency_result(const struct gazelle_stat_msg_request *req_msg,
+ struct gazelle_stack_dfx_data *stat, struct stack_latency *latency,
+ struct gazelle_latency_result *res)
{
- struct gazelle_stack_dfx_data *stat = (struct gazelle_stack_dfx_data *)buf;
- struct gazelle_stack_latency *latency = &stat->data.latency;
- int32_t ret = GAZELLE_OK;
- int32_t lwip_index = 0;
- int32_t read_index = 0;
- struct stack_latency lwip_record = {0};
- struct stack_latency read_record = {0};
- char str_ip[GAZELLE_SUBNET_LENGTH_MAX] = {0};
+ char str_ip[GAZELLE_SUBNET_LENGTH_MAX] = { 0 };
- read_record.latency_min = ~((uint64_t)0);
- lwip_record.latency_min = ~((uint64_t)0);
-
- char *lwip_result = calloc(GAZELLE_RESULT_LEN, sizeof(char));
- if (lwip_result == NULL) {
- return;
- }
- char *read_result = calloc(GAZELLE_RESULT_LEN, sizeof(char));
- if (read_result == NULL) {
- free(lwip_result);
+ if (GAZELLE_RESULT_LEN - res->latency_stat_index < GAZELLE_RESULT_LINE_LEN) {
+ printf("too many threads show latency result, out of memory bounds\n");
return;
}
- do {
- lwip_index += sprintf_s(lwip_result + lwip_index, (size_t)(GAZELLE_RESULT_LEN - lwip_index),
- "ip: %-15s tid: %-8u ", inet_ntop(AF_INET, &req_msg->ip, str_ip, sizeof(str_ip)), stat->tid);
- parse_thread_latency_result(&latency->lwip_latency, lwip_result, (size_t)(GAZELLE_RESULT_LEN - lwip_index),
- &lwip_index, &lwip_record);
+ res->latency_stat_index += sprintf_s(res->latency_stat_result + res->latency_stat_index,
+ (size_t)(GAZELLE_RESULT_LEN - res->latency_stat_index), "ip: %-15s tid: %-8u ",
+ inet_ntop(AF_INET, &req_msg->ip, str_ip, sizeof(str_ip)), stat->tid);
- read_index += sprintf_s(read_result + read_index, (size_t)(GAZELLE_RESULT_LEN - read_index),
- "ip: %-15s tid: %-8u ", inet_ntop(AF_INET, &req_msg->ip, str_ip, sizeof(str_ip)), stat->tid);
- parse_thread_latency_result(&latency->read_latency, read_result, (size_t)(GAZELLE_RESULT_LEN - read_index),
- &read_index, &read_record);
+ parse_thread_latency_result(latency, res->latency_stat_result,
+ (size_t)(GAZELLE_RESULT_LEN - res->latency_stat_index), &res->latency_stat_index, &res->latency_stat_record);
+}
+
+static void gazelle_show_latency_result_total(void *buf, const struct gazelle_stat_msg_request *req_msg,
+ struct gazelle_latency_result *res)
+{
+ int ret = GAZELLE_OK;
+ struct gazelle_stack_dfx_data *stat = (struct gazelle_stack_dfx_data *)buf;
+ struct gazelle_stack_latency *latency = &stat->data.latency;
+
+ do {
+ for (int i = 0; i < GAZELLE_LATENCY_MAX; i++) {
+ gazelle_show_latency_result(req_msg, stat, &latency->latency[i], &res[i]);
+ }
if ((stat->eof != 0) || (ret != GAZELLE_OK)) {
break;
@@ -772,21 +770,33 @@ static void gazelle_print_lstack_stat_latency(void *buf, const struct gazelle_st
ret = dfx_stat_read_from_ltran(buf, sizeof(struct gazelle_stack_dfx_data), req_msg->stat_mode);
} while (true);
- parse_latency_total_result(lwip_result, (size_t)(GAZELLE_RESULT_LEN - lwip_index), &lwip_index, &lwip_record);
- parse_latency_total_result(read_result, (size_t)(GAZELLE_RESULT_LEN - read_index), &read_index, &read_record);
+ for (int i = 0; i < GAZELLE_LATENCY_MAX; i++) {
+ parse_latency_total_result(res[i].latency_stat_result, (size_t)(GAZELLE_RESULT_LEN - res[i].latency_stat_index),
+ &res[i].latency_stat_index, &res[i].latency_stat_record);
+ }
+}
+
+static void gazelle_print_lstack_stat_latency(void *buf, const struct gazelle_stat_msg_request *req_msg)
+{
+ struct gazelle_latency_result *res = calloc(GAZELLE_LATENCY_MAX, sizeof(struct gazelle_latency_result));
+ if (res == NULL) {
+ return;
+ }
+
+ for (int i = 0; i < GAZELLE_LATENCY_MAX; i++) {
+ res[i].latency_stat_record.latency_min = ~((uint64_t)0);
+ }
- printf("Statistics of lstack latency: t0--->t3 \
- (t0:read form nic t1:into lstask queue t2:into app queue t3:app read)\n");
- printf(" pkts min(us) max(us) average(us)\n%s",
- read_result);
+ gazelle_show_latency_result_total(buf, req_msg, res);
- printf("Statistics of lstack latency: t0--->t2 \
- (t0:read form nic t1:into lstask queue t2:into app queue t3:app read)\n");
- printf(" pkts min(us) max(us) average(us)\n%s",
- lwip_result);
+ printf("Statistics of lstack latency pkts min(us) max(us) average(us)\n");
+ printf("range: t0--->t3\n%s", res[GAZELLE_LATENCY_READ_LSTACK].latency_stat_result);
+ printf("range: t0--->t2\n%s", res[GAZELLE_LATENCY_READ_LWIP].latency_stat_result);
+ printf("range: t3--->t0\n%s", res[GAZELLE_LATENCY_WRITE_LSTACK].latency_stat_result);
+ printf("range: t2--->t0\n%s", res[GAZELLE_LATENCY_WRITE_LWIP].latency_stat_result);
+ printf("t0:read form/send to nic t1:into/out of lstask queue t2:into/out of app queue t3:app read/send\n");
- free(read_result);
- free(lwip_result);
+ free(res);
}
static void gazelle_print_lstack_stat_lpm(void *buf, const struct gazelle_stat_msg_request *req_msg)
--
2.27.0

1336
0135-rpc-function-does-not-depend-on-protocol-stack.patch Normal file
View File

File diff suppressed because it is too large Load Diff

30
0136-readv-return-1-errno-is-EAGAIN-when-recvring-no-data.patch Normal file
View File

@ -0,0 +1,30 @@
From 61888e1e0d4810d3f0dbe5aa1d43a2dbcf2ad0f5 Mon Sep 17 00:00:00 2001
From: jiangheng <jiangheng14@huawei.com>
Date: Wed, 21 Feb 2024 07:44:59 +0800
Subject: [PATCH] readv return -1, errno is EAGAIN when recvring no data
---
src/lstack/api/lstack_rtw_api.c | 7 +------
1 file changed, 1 insertion(+), 6 deletions(-)
diff --git a/src/lstack/api/lstack_rtw_api.c b/src/lstack/api/lstack_rtw_api.c
index 8498b8e..e50fe37 100644
--- a/src/lstack/api/lstack_rtw_api.c
+++ b/src/lstack/api/lstack_rtw_api.c
@@ -127,12 +127,7 @@ ssize_t rtw_readv(int s, const struct iovec *iov, int iovcnt)
msg.msg_control = NULL;
msg.msg_controllen = 0;
msg.msg_flags = 0;
- ssize_t result = do_lwip_recvmsg_from_stack(s, &msg, 0);
- if (result == -1 && errno == EAGAIN) {
- errno = 0;
- return 0;
- }
- return result;
+ return do_lwip_recvmsg_from_stack(s, &msg, 0);
}
ssize_t rtw_write(int s, const void *mem, size_t size)
--
2.27.0

1707
0137-split-the-flow-fules-related-functions-into-separate.patch Normal file
View File

File diff suppressed because it is too large Load Diff

66
0138-fix-coreddump-when-stack-setup-failed-in-rtc-mode.patch Normal file
View File

@ -0,0 +1,66 @@
From 52fafeafd51ed5363081064076dff4ed276a99c1 Mon Sep 17 00:00:00 2001
From: jiangheng <jiangheng14@huawei.com>
Date: Thu, 22 Feb 2024 21:22:44 +0800
Subject: [PATCH] fix coreddump when stack setup failed in rtc mode
---
src/lstack/api/lstack_rtc_api.c | 6 +++---
src/lstack/core/lstack_init.c | 11 +++++------
2 files changed, 8 insertions(+), 9 deletions(-)
diff --git a/src/lstack/api/lstack_rtc_api.c b/src/lstack/api/lstack_rtc_api.c
index d29e51e..2e10e30 100644
--- a/src/lstack/api/lstack_rtc_api.c
+++ b/src/lstack/api/lstack_rtc_api.c
@@ -45,7 +45,7 @@ int rtc_socket(int domain, int type, int protocol)
int ret;
if (stack_setup_app_thread() < 0) {
- LSTACK_EXIT(1, "stack_setup_app_thread failed!\n");
+ exit(1);
}
/* need call stack thread init function */
@@ -74,7 +74,7 @@ int rtc_shutdown(int fd, int how)
int rtc_epoll_create(int flags)
{
if (stack_setup_app_thread() < 0) {
- LSTACK_EXIT(1, "stack_setup_app_thread failed!\n");
+ exit(1);
}
return lstack_epoll_create(flags);
@@ -83,7 +83,7 @@ int rtc_epoll_create(int flags)
int rtc_epoll_create1(int flags)
{
if (stack_setup_app_thread() < 0) {
- LSTACK_EXIT(1, "stack_setup_app_thread failed!\n");
+ exit(1);
}
return lstack_epoll_create1(flags);
diff --git a/src/lstack/core/lstack_init.c b/src/lstack/core/lstack_init.c
index 31fd91d..bd9ba8a 100644
--- a/src/lstack/core/lstack_init.c
+++ b/src/lstack/core/lstack_init.c
@@ -109,12 +109,11 @@ static int32_t check_process_conflict(void)
void gazelle_exit(void)
{
- if (!get_global_cfg_params()->stack_mode_rtc) {
- wrap_api_set_dummy();
- /* 1: wait until app thread call send functio complete */
- sleep(1);
- stack_group_exit();
- }
+ wrap_api_set_dummy();
+ /* 1: wait until app thread call send functio complete */
+ sleep(1);
+ stack_group_exit();
+
if (!use_ltran()) {
#if RTE_VERSION < RTE_VERSION_NUM(23, 11, 0, 0)
dpdk_kni_release();
--
2.27.0

277
0139-diff-udp-and-tcp-read-from-stack.patch Normal file
View File

@ -0,0 +1,277 @@
From 472e2f00b3fda7dad4396704fd94715d91be4642 Mon Sep 17 00:00:00 2001
From: jiangheng <jiangheng14@huawei.com>
Date: Wed, 21 Feb 2024 04:25:43 +0800
Subject: [PATCH] diff udp and tcp read from stack
---
src/lstack/core/lstack_lwip.c | 211 +++++++++++++++++++++++-----------
1 file changed, 146 insertions(+), 65 deletions(-)
diff --git a/src/lstack/core/lstack_lwip.c b/src/lstack/core/lstack_lwip.c
index 50a3389..0b339fe 100644
--- a/src/lstack/core/lstack_lwip.c
+++ b/src/lstack/core/lstack_lwip.c
@@ -831,74 +831,96 @@ static struct pbuf *pbuf_free_partial(struct pbuf *pbuf, uint16_t free_len)
return pbuf;
}
-ssize_t do_lwip_read_from_stack(int32_t fd, void *buf, size_t len, int32_t flags,
- struct sockaddr *addr, socklen_t *addrlen)
+static bool recv_break_for_err(struct lwip_sock *sock)
{
- size_t recv_left = len;
- struct pbuf *pbuf = NULL;
- ssize_t recvd = 0;
- uint32_t copy_len;
- struct lwip_sock *sock = get_socket_by_fd(fd);
- bool latency_enable = get_protocol_stack_group()->latency_start;
-
- if (sock->errevent > 0 && !NETCONN_IS_DATAIN(sock)) {
- errno = err_to_errno(netconn_err(sock->conn));
- return -1;
- }
+ bool break_wait = (sock->errevent > 0) && (!NETCONN_IS_DATAIN(sock));
+ errno = err_to_errno(netconn_err(sock->conn));
+ return break_wait;
+}
- thread_bind_stack(sock);
+static void recv_block_wait(struct lwip_sock *sock)
+{
+ lstack_block_wait(sock->wakeup);
+}
- if (sock->same_node_rx_ring != NULL) {
- return gazelle_same_node_ring_recv(sock, buf, len, flags);
+/*
+ * return 0 on success, -1 on error
+ * pbuf maybe NULL(tcp fin packet)
+ */
+static int recv_ring_get_one(struct lwip_sock *sock, bool noblock, struct pbuf **pbuf)
+{
+ if (sock->recv_lastdata != NULL) {
+ *pbuf = sock->recv_lastdata;
+ sock->recv_lastdata = NULL;
+ return 0;
}
- while (recv_left > 0) {
- if (sock->recv_lastdata) {
- pbuf = sock->recv_lastdata;
- sock->recv_lastdata = NULL;
+ if (noblock) {
+ if (gazelle_ring_read(sock->recv_ring, (void **)pbuf, 1) != 1) {
+ errno = EAGAIN;
+ return -1;
} else {
- if (netconn_is_nonblocking(sock->conn)) {
- if (gazelle_ring_read(sock->recv_ring, (void **)&pbuf, 1) != 1) {
- break;
- }
- } else {
- while (gazelle_ring_read(sock->recv_ring, (void **)&pbuf, 1) != 1 && recvd == 0) {
- /* if the connection is disconnected, recv return 0 */
- if (sock->errevent > 0 && !NETCONN_IS_DATAIN(sock)) {
- errno = err_to_errno(netconn_err(sock->conn));
- return -1;
- }
-
- lstack_block_wait(sock->wakeup);
- }
+ return 0;
+ }
+ } else {
+ while (gazelle_ring_read(sock->recv_ring, (void **)pbuf, 1) != 1) {
+ if (recv_break_for_err(sock)) {
+ return -1;
}
+ recv_block_wait(sock);
}
+ return 0;
+ }
+}
- /* if udp recv a packet whose len is 0, return 0 */
- if (NETCONN_IS_UDP(sock) && pbuf->tot_len == 0) {
- return 0;
+/* return true: fin is read to user, false: pend fin */
+static bool recv_ring_handle_fin(struct lwip_sock *sock, struct pbuf *pbuf, ssize_t recvd)
+{
+ if (pbuf == NULL) {
+ if (recvd > 0) {
+ /* handle data first, then handle fin */
+ sock->recv_lastdata = (void *)&fin_packet;
+ gazelle_ring_read_over(sock->recv_ring);
+ return false;
}
+ gazelle_ring_read_over(sock->recv_ring);
+ return true;
+ }
+ /* pending fin */
+ if (pbuf == (void *)&fin_packet) {
+ return true;
+ }
- /* fin */
- if (unlikely(pbuf == NULL)) {
- if (recvd > 0) {
- /* read data first, then read fin */
- sock->recv_lastdata = (void *)&fin_packet;
- gazelle_ring_read_over(sock->recv_ring);
- break;
- }
- gazelle_ring_read_over(sock->recv_ring);
- return 0;
+ return false;
+}
+
+static ssize_t recv_ring_tcp_read(struct lwip_sock *sock, void *buf, size_t len, bool noblock)
+{
+ ssize_t recvd = 0;
+ size_t recv_left = len;
+ uint32_t copy_len;
+ struct pbuf *pbuf = NULL;
+
+ if (len == 0) {
+ return 0;
+ }
+
+ while (recv_left > 0) {
+ if (recv_ring_get_one(sock, noblock, &pbuf) != 0) {
+ break;
}
- /* pending fin */
- if (unlikely(pbuf == (void *)&fin_packet)) {
- return 0;
+ if (unlikely((pbuf == NULL) || (pbuf == (void *)&fin_packet))) {
+ if (recv_ring_handle_fin(sock, pbuf, recvd)) {
+ return 0;
+ } else {
+ break; /* recvd > 0, pending fin, handle data */
+ }
}
copy_len = (recv_left > pbuf->tot_len) ? pbuf->tot_len : recv_left;
if (copy_len > UINT16_MAX) {
- copy_len = UINT16_MAX;
+ copy_len = UINT16_MAX; /* it's impossible to get here */
}
pbuf_copy_partial(pbuf, (char *)buf + recvd, copy_len, 0);
@@ -907,39 +929,98 @@ ssize_t do_lwip_read_from_stack(int32_t fd, void *buf, size_t len, int32_t flags
if (pbuf->tot_len > copy_len) {
sock->recv_lastdata = pbuf_free_partial(pbuf, copy_len);
- break;
} else {
if (sock->wakeup) {
sock->wakeup->stat.app_read_cnt += 1;
}
- if (latency_enable) {
+
+ if (get_protocol_stack_group()->latency_start) {
calculate_lstack_latency(&sock->stack->latency, pbuf, GAZELLE_LATENCY_READ_LSTACK);
}
- gazelle_ring_read_over(sock->recv_ring);
- /* in udp, if pbuf remaining len less than copy_len, discard these packets */
- if (recvd > 0 && NETCONN_IS_UDP(sock)) {
- sock->stack->stats.sock_rx_drop++;
- break;
- }
+ gazelle_ring_read_over(sock->recv_ring);
}
}
- /* rte_ring_count reduce lock */
- if (sock->wakeup && sock->wakeup->type == WAKEUP_EPOLL && (sock->events & EPOLLIN)
- && (!NETCONN_IS_DATAIN(sock))) {
- del_sock_event(sock, EPOLLIN);
+ if (recvd > 0) {
+ errno = 0;
+ } else {
+ recvd = -1;
}
+ return recvd;
+}
+
+static ssize_t recv_ring_udp_read(struct lwip_sock *sock, void *buf, size_t len, bool noblock,
+ struct sockaddr *addr, socklen_t *addrlen)
+{
+ size_t recv_left = len;
+ struct pbuf *pbuf = NULL;
+ uint32_t copy_len;
+
+ sock->recv_lastdata = NULL;
+
+ if (recv_ring_get_one(sock, noblock, &pbuf) != 0) {
+ /* errno have set */
+ return -1;
+ }
+
+ copy_len = (recv_left > pbuf->tot_len) ? pbuf->tot_len : recv_left;
+ pbuf_copy_partial(pbuf, (char *)buf, copy_len, 0);
+ /* drop remaining data if have */
+ gazelle_ring_read_over(sock->recv_ring);
+
if (pbuf && addr && addrlen) {
lwip_sock_make_addr(sock->conn, &(pbuf->addr), pbuf->port, addr, addrlen);
}
- if (recvd == 0) {
+ if (copy_len < pbuf->tot_len) {
+ sock->stack->stats.sock_rx_drop++;
+ }
+
+ if (sock->wakeup) {
+ sock->wakeup->stat.app_read_cnt++;
+ }
+ if (get_protocol_stack_group()->latency_start) {
+ calculate_lstack_latency(&sock->stack->latency, pbuf, GAZELLE_LATENCY_READ_LSTACK);
+ }
+
+ return copy_len;
+}
+
+ssize_t do_lwip_read_from_stack(int32_t fd, void *buf, size_t len, int32_t flags,
+ struct sockaddr *addr, socklen_t *addrlen)
+{
+ ssize_t recvd = 0;
+ struct lwip_sock *sock = get_socket_by_fd(fd);
+
+ if (recv_break_for_err(sock)) {
+ return -1;
+ }
+
+ thread_bind_stack(sock);
+
+ if (sock->same_node_rx_ring != NULL) {
+ return gazelle_same_node_ring_recv(sock, buf, len, flags);
+ }
+
+ if (NETCONN_IS_UDP(sock)) {
+ recvd = recv_ring_udp_read(sock, buf, len, netconn_is_nonblocking(sock->conn), addr, addrlen);
+ } else {
+ recvd = recv_ring_tcp_read(sock, buf, len, netconn_is_nonblocking(sock->conn));
+ }
+
+ /* rte_ring_count reduce lock */
+ if (sock->wakeup && sock->wakeup->type == WAKEUP_EPOLL && (sock->events & EPOLLIN)
+ && (!NETCONN_IS_DATAIN(sock))) {
+ del_sock_event(sock, EPOLLIN);
+ }
+
+ if (recvd < 0) {
if (sock->wakeup) {
sock->wakeup->stat.read_null++;
}
- GAZELLE_RETURN(EAGAIN);
+ return -1;
}
return recvd;
}
--
2.27.0

798
0140-FAULT-INJECT-gazelle-add-packet-delay-and-packet-dro.patch Normal file
View File

@ -0,0 +1,798 @@
From f28b880f3be68377003c60005011a835eb18e105 Mon Sep 17 00:00:00 2001
From: yinbin6 <yinbin8@huawei.com>
Date: Sun, 18 Feb 2024 17:11:05 +0800
Subject: [PATCH] FAULT INJECT: gazelle add packet delay and packet drop
---
src/common/gazelle_dfx_msg.h | 15 ++
src/common/gazelle_fault_inject_common.h | 75 +++++++
src/lstack/Makefile | 5 +
src/lstack/core/lstack_control_plane.c | 13 +-
src/lstack/include/lstack_fault_inject.h | 20 ++
src/lstack/include/lstack_vdev.h | 1 +
src/lstack/netif/dir.mk | 3 +
src/lstack/netif/lstack_fault_inject.c | 187 ++++++++++++++++
src/lstack/netif/lstack_vdev.c | 2 +-
src/ltran/CMakeLists.txt | 5 +
src/ltran/ltran_dfx.c | 274 ++++++++++++++++++++++-
11 files changed, 595 insertions(+), 5 deletions(-)
create mode 100644 src/common/gazelle_fault_inject_common.h
create mode 100644 src/lstack/include/lstack_fault_inject.h
create mode 100644 src/lstack/netif/lstack_fault_inject.c
diff --git a/src/common/gazelle_dfx_msg.h b/src/common/gazelle_dfx_msg.h
index 7f8422a..8d528d6 100644
--- a/src/common/gazelle_dfx_msg.h
+++ b/src/common/gazelle_dfx_msg.h
@@ -18,6 +18,10 @@
#include <lwip/reg_sock.h>
+#ifdef GAZELLE_FAULT_INJECT_ENABLE
+#include "gazelle_fault_inject_common.h"
+#endif /* GAZELLE_FAULT_INJECT_ENABLE */
+
#define GAZELLE_CLIENT_NUM_MIN 1
#define GAZELLE_LOG_LEVEL_MAX 10
#define GAZELLECTL_TIMEOUT 5000 // millisecond
@@ -54,6 +58,11 @@ enum GAZELLE_STAT_MODE {
GAZELLE_STAT_LSTACK_SHOW_AGGREGATE,
GAZELLE_STAT_LSTACK_SHOW_NIC_FEATURES,
+#ifdef GAZELLE_FAULT_INJECT_ENABLE
+ GAZELLE_STAT_FAULT_INJECT_SET,
+ GAZELLE_STAT_FAULT_INJECT_UNSET,
+#endif /* GAZELLE_FAULT_INJECT_ENABLE */
+
GAZELLE_STAT_MODE_MAX,
};
@@ -277,6 +286,9 @@ struct gazelle_stack_dfx_data {
struct gazelle_stat_lstack_snmp snmp;
struct nic_eth_xstats nic_xstats;
struct nic_eth_features nic_features;
+#ifdef GAZELLE_FAULT_INJECT_ENABLE
+ struct gazelle_fault_inject_data inject;
+#endif /* GAZELLE_FAULT_INJECT_ENABLE */
} data;
};
@@ -307,6 +319,9 @@ struct gazelle_stat_msg_request {
union stat_param {
char log_level[GAZELLE_LOG_LEVEL_MAX];
uint16_t low_power_mod;
+#ifdef GAZELLE_FAULT_INJECT_ENABLE
+ struct gazelle_fault_inject_data inject;
+#endif /* GAZELLE_FAULT_INJECT_ENABLE */
} data;
};
diff --git a/src/common/gazelle_fault_inject_common.h b/src/common/gazelle_fault_inject_common.h
new file mode 100644
index 0000000..3a77f39
--- /dev/null
+++ b/src/common/gazelle_fault_inject_common.h
@@ -0,0 +1,75 @@
+/*
+* Copyright (c) Huawei Technologies Co., Ltd. 2020-2021. All rights reserved.
+* gazelle is licensed under the Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+* http://license.coscl.org.cn/MulanPSL2
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR
+* PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+#ifndef __GAZELLE_INJECT_COMMON_H__
+#define __GAZELLE_INJECT_COMMON_H__
+
+#include <stdint.h>
+
+enum GAZELLE_FAULT_INJECT_TYPE {
+ GAZELLE_FAULT_INJECT_TYPE_ERR = 0,
+ GAZELLE_FAULT_INJECT_PACKET_DELAY,
+ GAZELLE_FAULT_INJECT_PACKET_LOSS,
+ GAZELLE_FAULT_INJECT_PACKAET_DUPLICATE,
+ GAZELLE_FAULT_INJECT_PACKET_REORDER,
+ GAZELLE_FAULT_INJECT_TYPE_MAX,
+};
+
+enum GAZELLE_FAULT_INJECT_RULE {
+ INJECT_RULE_ERR = 0,
+ /* packet delay rule */
+ INJECT_DELAY_RANDOM,
+ /* packet loss rule */
+ INJECT_LOSS_RANDOM,
+ /* packet duplicate */
+ INJECT_DUPLICATE_RANDOM,
+ /* packet reorder */
+ INJECT_REORDER_RANDOM,
+};
+
+/* fault inject delay: packet delay's time and range, time unit is "ms" */
+struct delay_data {
+ uint32_t delay_time;
+ uint32_t delay_range;
+};
+
+/* fault inject loss: packet loss rate */
+struct loss_data {
+ double loss_rate;
+ uint32_t loss_sigle_count;
+};
+
+/* fault inject duplicate: packet duplicate rate and duplicate count */
+struct duplicate_data {
+ double duplicate_rate;
+ uint32_t duplicate_sigle_count;
+};
+
+/* fault inject reorder: packet reorder rate and reorder count */
+struct reorder_data {
+ double reorder_rate;
+ uint32_t reorder_sigle_count;
+};
+
+struct gazelle_fault_inject_data {
+ int32_t fault_inject_on;
+ enum GAZELLE_FAULT_INJECT_TYPE inject_type;
+ enum GAZELLE_FAULT_INJECT_RULE inject_rule;
+ union {
+ struct delay_data delay;
+ struct loss_data loss;
+ struct duplicate_data duplicate;
+ struct reorder_data reorder;
+ } inject_data;
+};
+
+#endif /* __GAZELLE_INJECT_COMMON_H__ */
diff --git a/src/lstack/Makefile b/src/lstack/Makefile
index df1ddaa..d2c039d 100644
--- a/src/lstack/Makefile
+++ b/src/lstack/Makefile
@@ -47,6 +47,11 @@ ifeq ($(GAZELLE_COVERAGE_ENABLE), 1)
CFLAGS += -fprofile-arcs -ftest-coverage
endif
+ifeq ($(GAZELLE_FAULT_INJECT_ENABLE), 1)
+ LDFLAGS += -DGAZELLE_FAULT_INJECT_ENABLE
+ CFLAGS += -DGAZELLE_FAULT_INJECT_ENABLE
+endif
+
ifeq ($(shell $(CC) -dumpmachine | cut -d"-" -f1), x86_64)
CFLAGS += -mssse3
endif
diff --git a/src/lstack/core/lstack_control_plane.c b/src/lstack/core/lstack_control_plane.c
index 025291d..783f21c 100644
--- a/src/lstack/core/lstack_control_plane.c
+++ b/src/lstack/core/lstack_control_plane.c
@@ -34,6 +34,10 @@
#include "lstack_protocol_stack.h"
#include "lstack_control_plane.h"
+#ifdef GAZELLE_FAULT_INJECT_ENABLE
+#include "lstack_fault_inject.h"
+#endif /* GAZELLE_FAULT_INJECT_ENABLE */
+
/* intervals between two connection attempts and two registration attempts, in second */
#define CONNECT_TO_LTRAN_INFINITE (-1)
#define CONNECT_TO_LTRAN_RETRY_INTERVAL 1
@@ -582,7 +586,14 @@ static int32_t handle_stat_request(int32_t sockfd)
LSTACK_LOG(ERR, LSTACK, "recv wrong stat mode %d\n", (int32_t)msg.stat_mode);
return 0;
}
-
+
+#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);
+ }
+#endif /* GAZELLE_FAULT_INJECT_ENABLE */
+
if (msg.stat_mode == GAZELLE_STAT_LSTACK_LOG_LEVEL_SET ||
msg.stat_mode == GAZELLE_STAT_LSTACK_LOW_POWER_MDF) {
return handle_proc_cmd(sockfd, &msg);
diff --git a/src/lstack/include/lstack_fault_inject.h b/src/lstack/include/lstack_fault_inject.h
new file mode 100644
index 0000000..d54f1f2
--- /dev/null
+++ b/src/lstack/include/lstack_fault_inject.h
@@ -0,0 +1,20 @@
+/*
+* Copyright (c) Huawei Technologies Co., Ltd. 2020-2021. All rights reserved.
+* gazelle is licensed under the Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+* http://license.coscl.org.cn/MulanPSL2
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR
+* PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+#ifndef __GAZELLE_INJECT_H__
+#define __GAZELLE_INJECT_H__
+
+#include <stdbool.h>
+
+int32_t handle_fault_inject_cmd(int32_t sockfd, struct gazelle_stat_msg_request *msg);
+
+#endif /* __GAZELLE_INJECT_H__ */
diff --git a/src/lstack/include/lstack_vdev.h b/src/lstack/include/lstack_vdev.h
index 4e5d191..1a8342a 100644
--- a/src/lstack/include/lstack_vdev.h
+++ b/src/lstack/include/lstack_vdev.h
@@ -18,5 +18,6 @@ struct gazelle_quintuple;
enum reg_ring_type;
void vdev_dev_ops_init(struct lstack_dev_ops *dev_ops);
int vdev_reg_xmit(enum reg_ring_type type, struct gazelle_quintuple *qtuple);
+uint32_t vdev_tx_xmit(struct protocol_stack *stack, struct rte_mbuf **pkts, uint32_t nr_pkts);
#endif /* _GAZELLE_VDEV_H_ */
diff --git a/src/lstack/netif/dir.mk b/src/lstack/netif/dir.mk
index 20fb5d6..1e67734 100644
--- a/src/lstack/netif/dir.mk
+++ b/src/lstack/netif/dir.mk
@@ -9,4 +9,7 @@
# See the Mulan PSL v2 for more details.
SRC = lstack_ethdev.c lstack_vdev.c lstack_flow.c
+ifeq ($(GAZELLE_FAULT_INJECT_ENABLE), 1)
+ SRC += lstack_fault_inject.c
+endif
$(eval $(call register_dir, netif, $(SRC)))
diff --git a/src/lstack/netif/lstack_fault_inject.c b/src/lstack/netif/lstack_fault_inject.c
new file mode 100644
index 0000000..4daad10
--- /dev/null
+++ b/src/lstack/netif/lstack_fault_inject.c
@@ -0,0 +1,187 @@
+/*
+* Copyright (c) Huawei Technologies Co., Ltd. 2020-2021. All rights reserved.
+* gazelle is licensed under the Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+* http://license.coscl.org.cn/MulanPSL2
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR
+* PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+#include <securec.h>
+#include <rte_gro.h>
+#include <rte_net.h>
+
+#include <lwip/posix_api.h>
+
+#include "lstack_cfg.h"
+#include "lstack_log.h"
+#include "lstack_vdev.h"
+
+#define INJECT_MODULO 1000 /* used in modulus operator */
+#define INJECT_US_TO_MS 1000 /* transefer time unit us to ms */
+
+typedef int32_t (*inject_xmit_func)(struct protocol_stack *stack, struct rte_mbuf **pkts,
+ uint32_t nr_pkts, struct gazelle_fault_inject_data data);
+struct inject_tbl {
+ struct gazelle_fault_inject_data inject_data;
+ inject_xmit_func inject_func;
+};
+static struct inject_tbl g_inject_tbl[GAZELLE_FAULT_INJECT_TYPE_MAX];
+
+struct inject_func_tbl {
+ enum GAZELLE_FAULT_INJECT_TYPE type;
+ enum GAZELLE_FAULT_INJECT_RULE rule;
+ inject_xmit_func inject_func;
+};
+
+static int32_t inject_packet_delay_random(struct protocol_stack *stack, struct rte_mbuf **pkts,
+ uint32_t nr_pkts, struct gazelle_fault_inject_data data);
+static int32_t inject_packet_loss_random(struct protocol_stack *stack, struct rte_mbuf **pkts,
+ uint32_t nr_pkts, struct gazelle_fault_inject_data data);
+
+static struct inject_func_tbl g_inject_func_tbl[] = {
+ {GAZELLE_FAULT_INJECT_PACKET_LOSS, INJECT_LOSS_RANDOM, inject_packet_loss_random},
+ {GAZELLE_FAULT_INJECT_PACKET_DELAY, INJECT_DELAY_RANDOM, inject_packet_delay_random},
+};
+
+static int32_t inject_func_tbl_update()
+{
+ int32_t func_count = sizeof(g_inject_func_tbl) / sizeof(g_inject_func_tbl[0]);
+
+ for (int32_t i = 0; i < GAZELLE_FAULT_INJECT_TYPE_MAX; ++i) {
+ if (!g_inject_tbl[i].inject_data.fault_inject_on) {
+ continue;
+ }
+ for (int32_t j = 0; j < func_count; ++j) {
+ if (g_inject_func_tbl[j].type == g_inject_tbl[i].inject_data.inject_type &&
+ g_inject_func_tbl[j].rule == g_inject_tbl[i].inject_data.inject_rule) {
+ g_inject_tbl[i].inject_func = g_inject_func_tbl[j].inject_func;
+ }
+ }
+ }
+ return 0;
+}
+
+static uint32_t inject_tx_xmit(struct protocol_stack *stack, struct rte_mbuf **pkts, uint32_t nr_pkts)
+{
+ for (int32_t i = 0; i < GAZELLE_FAULT_INJECT_TYPE_MAX; ++i) {
+ if (g_inject_tbl[i].inject_data.fault_inject_on) {
+ int32_t xmit_pkts = 0;
+ xmit_pkts = g_inject_tbl[i].inject_func(stack, pkts, nr_pkts,
+ g_inject_tbl[i].inject_data);
+ if (xmit_pkts == nr_pkts) {
+ continue;
+ }
+ return xmit_pkts;
+ }
+ }
+ if (rte_mbuf_refcnt_read(*pkts) == 1) {
+ return nr_pkts;
+ }
+ return vdev_tx_xmit(stack, pkts, nr_pkts);
+}
+
+static int32_t inject_strategy_update()
+{
+ inject_func_tbl_update();
+
+ int32_t inject_on = 0;
+ for (int32_t i = 0; i < GAZELLE_FAULT_INJECT_TYPE_MAX; ++i) {
+ if (g_inject_tbl[i].inject_data.fault_inject_on) {
+ inject_on = 1;
+ break;
+ }
+ }
+
+ struct protocol_stack_group *stack_group = get_protocol_stack_group();
+
+ if (inject_on) {
+ for (uint32_t i = 0; i < stack_group->stack_num; ++i) {
+ struct protocol_stack *stack = stack_group->stacks[i];
+ stack->dev_ops.tx_xmit = inject_tx_xmit;
+ }
+ return 0;
+ }
+
+ for (uint32_t i = 0; i < stack_group->stack_num; ++i) {
+ struct protocol_stack *stack = stack_group->stacks[i];
+ vdev_dev_ops_init(&stack->dev_ops);
+ }
+
+ return 0;
+}
+
+static int32_t inject_packet_delay_random(struct protocol_stack *stack, struct rte_mbuf **pkts,
+ uint32_t nr_pkts, struct gazelle_fault_inject_data data)
+{
+ /* while *pkts->refcnt == 1, other inject type is on, and the packets have been loss. */
+ if (rte_mbuf_refcnt_read(*pkts) == 1) {
+ return nr_pkts;
+ }
+ int32_t delay_time = data.inject_data.delay.delay_time;
+ int32_t delay_range = data.inject_data.delay.delay_range;
+ int32_t rand_num = rte_rand();
+ rand_num %= INJECT_MODULO;
+ delay_time += delay_range * rand_num / INJECT_MODULO;
+ rte_delay_us(delay_time * INJECT_US_TO_MS);
+
+ return nr_pkts;
+}
+
+static int32_t inject_packet_loss_random(struct protocol_stack *stack, struct rte_mbuf **pkts,
+ uint32_t nr_pkts, struct gazelle_fault_inject_data data)
+{
+ double loss_rate = data.inject_data.loss.loss_rate;
+ int32_t boundary = (int32_t) (loss_rate * INJECT_MODULO);
+
+ uint32_t rand_num = rte_rand();
+ rand_num %= INJECT_MODULO;
+
+ if (rand_num > boundary) {
+ return nr_pkts;
+ }
+
+ for (int32_t i = 0; i < nr_pkts; ++i) {
+ rte_pktmbuf_free(pkts[i]);
+ }
+ return nr_pkts;
+}
+
+int32_t handle_fault_inject_cmd(int32_t sockfd, struct gazelle_stat_msg_request *msg)
+{
+ 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));
+ if (ret != EOK) {
+ LSTACK_LOG(ERR, LSTACK, "fault inject memcpy_s error, ret = %d", ret);
+ return -1;
+ }
+ if (i == GAZELLE_FAULT_INJECT_TYPE_MAX -1) {
+ rsp.eof = 1;
+ }
+ ret = (int32_t) posix_api->write_fn(sockfd, (void *)&rsp, sizeof(rsp));
+ if (ret <= 0) {
+ LSTACK_LOG(ERR, LSTACK, "write msg from peer failed, errno %d. ret=%d\n", errno, ret);
+ return -1;
+ }
+ }
+
+ return 0;
+}
+
diff --git a/src/lstack/netif/lstack_vdev.c b/src/lstack/netif/lstack_vdev.c
index 3703092..107ee8c 100644
--- a/src/lstack/netif/lstack_vdev.c
+++ b/src/lstack/netif/lstack_vdev.c
@@ -150,7 +150,7 @@ static uint32_t ltran_tx_xmit(struct protocol_stack *stack, struct rte_mbuf **pk
return sent_pkts;
}
-static uint32_t vdev_tx_xmit(struct protocol_stack *stack, struct rte_mbuf **pkts, uint32_t nr_pkts)
+uint32_t vdev_tx_xmit(struct protocol_stack *stack, struct rte_mbuf **pkts, uint32_t nr_pkts)
{
uint32_t sent_pkts = 0;
diff --git a/src/ltran/CMakeLists.txt b/src/ltran/CMakeLists.txt
index f739ceb..a484ae3 100644
--- a/src/ltran/CMakeLists.txt
+++ b/src/ltran/CMakeLists.txt
@@ -27,6 +27,11 @@ if($ENV{GAZELLE_COVERAGE_ENABLE})
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -ftest-coverage -fprofile-arcs")
endif($ENV{GAZELLE_COVERAGE_ENABLE})
+if($ENV{GAZELLE_FAULT_INJECT_ENABLE})
+ message("Enable Fault inject option")
+ set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DGAZELLE_FAULT_INJECT_ENABLE")
+endif($ENV{GAZELLE_FAULT_INJECT_ENABLE})
+
execute_process(
COMMAND rpm -qa dpdk
OUTPUT_VARIABLE DPDK_VERSION_FULL
diff --git a/src/ltran/ltran_dfx.c b/src/ltran/ltran_dfx.c
index 344afb2..413bf89 100644
--- a/src/ltran/ltran_dfx.c
+++ b/src/ltran/ltran_dfx.c
@@ -60,6 +60,46 @@ static struct gazelle_stat_ltran_total g_last_ltran_total;
static struct gazelle_stat_lstack_total g_last_lstack_total[GAZELLE_MAX_STACK_ARRAY_SIZE];
static struct gazelle_stack_dfx_data g_last_lstack_data[GAZELLE_MAX_STACK_ARRAY_SIZE];
+#ifdef GAZELLE_FAULT_INJECT_ENABLE
+#define INJECT_NAME_SIZE 32
+#define INJECT_RULE_SIZE 32
+
+typedef int32_t (*inject_parse_digit_fun)(char*, char*, struct gazelle_stat_msg_request *req_msg);
+static int32_t parse_inject_packet_delay_digit(char *time, char *range, struct gazelle_stat_msg_request *req_msg);
+static int32_t parse_inject_packet_loss_digit(char *rate, char *count, struct gazelle_stat_msg_request *req_msg);
+static int32_t parse_inject_packet_duplicate_digit(char *rate, char *count, struct gazelle_stat_msg_request *req_msg);
+static int32_t parse_inject_packet_reorder_digit(char *rate, char *count, struct gazelle_stat_msg_request *req_msg);
+
+struct gazelle_fault_inject_type_list {
+ char inject_type_item[INJECT_NAME_SIZE];
+ enum GAZELLE_FAULT_INJECT_TYPE inject_type_parsed;
+ inject_parse_digit_fun parse_digit_func;
+};
+
+static struct gazelle_fault_inject_type_list inject_type_list[] = {
+ {"delay", GAZELLE_FAULT_INJECT_PACKET_DELAY, parse_inject_packet_delay_digit},
+ {"loss", GAZELLE_FAULT_INJECT_PACKET_LOSS, parse_inject_packet_loss_digit},
+ {"duplicate", GAZELLE_FAULT_INJECT_PACKAET_DUPLICATE, parse_inject_packet_duplicate_digit},
+ {"reorder", GAZELLE_FAULT_INJECT_PACKET_REORDER, parse_inject_packet_reorder_digit},
+};
+
+struct gazelle_fault_inject_rule_list {
+ char inject_rule_item[INJECT_RULE_SIZE];
+ enum GAZELLE_FAULT_INJECT_RULE inject_rule_parsed;
+ enum GAZELLE_FAULT_INJECT_TYPE rule_parse_assit;
+};
+
+static struct gazelle_fault_inject_rule_list g_gazelle_fault_inject_rule_list[] = {
+ {"random", INJECT_DELAY_RANDOM, GAZELLE_FAULT_INJECT_PACKET_DELAY},
+ {"random", INJECT_LOSS_RANDOM, GAZELLE_FAULT_INJECT_PACKET_LOSS},
+ {"random", INJECT_DUPLICATE_RANDOM, GAZELLE_FAULT_INJECT_PACKAET_DUPLICATE},
+ {"random", INJECT_REORDER_RANDOM, GAZELLE_FAULT_INJECT_PACKET_REORDER},
+};
+
+static void gazelle_print_fault_inject_set_status(void *buf, const struct gazelle_stat_msg_request *req_msg);
+
+#endif /* GAZELLE_FAULT_INJECT_ENABLE */
+
static bool g_use_ltran = false;
static char* g_unix_prefix;
@@ -95,6 +135,11 @@ static void gazelle_print_lstack_xstats(void *buf, const struct gazelle_stat_msg
static void gazelle_print_lstack_aggregate(void *buf, const struct gazelle_stat_msg_request *req_msg);
static void gazelle_print_lstack_nic_features(void *buf, const struct gazelle_stat_msg_request *req_msg);
+#ifdef GAZELLE_FAULT_INJECT_ENABLE
+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 struct gazelle_dfx_list g_gazelle_dfx_tbl[] = {
{GAZELLE_STAT_LTRAN_SHOW, sizeof(struct gazelle_stat_ltran_total), gazelle_print_ltran_stat_total},
{GAZELLE_STAT_LTRAN_SHOW_RATE, sizeof(struct gazelle_stat_ltran_total), gazelle_print_ltran_stat_rate},
@@ -121,6 +166,11 @@ static struct gazelle_dfx_list g_gazelle_dfx_tbl[] = {
{GAZELLE_STAT_LSTACK_SHOW_XSTATS, sizeof(struct gazelle_stack_dfx_data), gazelle_print_lstack_xstats},
{GAZELLE_STAT_LSTACK_SHOW_AGGREGATE, sizeof(struct gazelle_stack_dfx_data), gazelle_print_lstack_aggregate},
{GAZELLE_STAT_LSTACK_SHOW_NIC_FEATURES, sizeof(struct gazelle_stack_dfx_data), gazelle_print_lstack_nic_features},
+
+#ifdef GAZELLE_FAULT_INJECT_ENABLE
+ {GAZELLE_STAT_FAULT_INJECT_SET, sizeof(struct gazelle_stack_dfx_data), gazelle_print_fault_inject_set_status},
+ {GAZELLE_STAT_FAULT_INJECT_UNSET, sizeof(struct gazelle_stack_dfx_data), gazelle_print_fault_inject_unset_status},
+#endif /* GAZELLE_FAULT_INJECT_ENABLE */
};
static int32_t g_wait_reply = 1;
@@ -1121,7 +1171,10 @@ static void show_usage(void)
{
printf("Usage: gazellectl [-h | help] \n"
" or: gazellectl ltran {quit | show | set} [LTRAN_OPTIONS] [-u UNIX_PREFIX]\n"
- " or: gazellectl lstack {show | set} ip [LSTACK_OPTIONS] [-u UNIX_PREFIX]\n \n"
+ " or: gazellectl lstack {show | set} ip [LSTACK_OPTIONS] [-u UNIX_PREFIX]\n\n"
+#ifdef GAZELLE_FAULT_INJECT_ENABLE
+ " or: gazellectl inject [inject_type] [digit_param_1] [digit_param_2] [inject_rule]\n\n"
+#endif /* GAZELLE_FAULT_INJECT_ENABLE */
" quit ltran process exit \n \n"
" where LTRAN_OPTIONS := \n"
" show: \n"
@@ -1146,7 +1199,13 @@ static void show_usage(void)
" set: \n"
" loglevel {error | info | debug} set lstack loglevel \n"
" lowpower {0 | 1} set lowpower enable \n"
- " [time] measure latency time default 1S, maximum 30mins \n");
+ " [time] measure latency time default 1S, maximum 30mins \n\n"
+#ifdef GAZELLE_FAULT_INJECT_ENABLE
+ " *inject params*\n"
+ " |inject_type | digit_param_1 | digit_param_2 | inject_rule |\n"
+ " | delay | delay_time(unit: ms) | delay_range(unit: ms) | random |\n"
+#endif /* GAZELLE_FAULT_INJECT_ENABLE */
+ );
}
static int32_t parse_dfx_ltran_set_args(int32_t argc, char *argv[], struct gazelle_stat_msg_request *req_msg)
@@ -1436,6 +1495,211 @@ 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
+#define GAZELLE_UNSET_FAULT_INJECT_PARAM_COUNT 4
+#define INJECT_TYPE_INDEX 2
+#define INJECT_DIGITAL_FIRST_INDEX 3
+#define INJECT_DIGITAL_SECOND_INDEX 4
+#define INJECT_RULE_INDEX 5
+
+
+static void gazelle_print_fault_inject_type_info(struct gazelle_fault_inject_data *inject)
+{
+ if (!inject->fault_inject_on) {
+ return;
+ }
+
+ if (inject->inject_type == GAZELLE_FAULT_INJECT_PACKET_DELAY) {
+ printf("\t| inject_type: delay | delay_time: %-7d | delay_range: %-3d | "
+ "inject_rule: random |\n", inject->inject_data.delay.delay_time,
+ inject->inject_data.delay.delay_range);
+ }
+
+#define INJECT_PERCENT 100
+
+ if (inject->inject_type == GAZELLE_FAULT_INJECT_PACKET_LOSS) {
+ printf("\t| inject_type: loss | loss_rate: %-3.1f%% | loss_single_count: %-3d | "
+ "inject_rule: random |\n", inject->inject_data.loss.loss_rate * INJECT_PERCENT,
+ inject->inject_data.loss.loss_sigle_count);
+ }
+ printf("\n");
+}
+
+static void gazelle_print_fault_inject_set_status(void *buf, const struct gazelle_stat_msg_request *req_msg)
+{
+ int32_t ret;
+ struct gazelle_stack_dfx_data *stat = (struct gazelle_stack_dfx_data *)buf;
+ struct gazelle_fault_inject_data *inject = &stat->data.inject;
+
+ printf("\n\n\t\t\t\t\t **** FAULT INJECT INFO **** \n\n");
+ do {
+ 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);
+}
+
+static void gazelle_print_fault_inject_unset_status(void *buf, const struct gazelle_stat_msg_request *req_msg)
+{
+ return;
+}
+
+static int32_t parse_inject_packet_delay_digit(char* time, char* range, struct gazelle_stat_msg_request *req_msg)
+{
+ int32_t parse_success = 0;
+ int32_t delay_time = atoi(time);
+ if (delay_time <= 0) {
+ printf("FAULT INJECT error: delay time error -- %d, need positive integer.\n", delay_time);
+ return parse_success;
+ }
+ req_msg->data.inject.inject_data.delay.delay_time = (uint32_t) delay_time;
+
+ int32_t delay_range = atoi(range);
+ if (delay_range < 0) {
+ printf("FAULT INJECT error: delay range error -- %d, need positive integer.\n", delay_range);
+ return parse_success;
+ }
+ if (delay_time - delay_range <= 0) {
+ printf("FAULT INJECT error: delay range should lower than delay time.\n");
+ return parse_success;
+ }
+ req_msg->data.inject.inject_data.delay.delay_range = delay_range;
+
+ return ++parse_success;
+}
+
+#define INJECT_RATE_LOWER 0.001
+
+static int32_t parse_inject_packet_loss_digit(char *rate, char *count, struct gazelle_stat_msg_request *req_msg)
+{
+ int32_t parse_success = 0;
+ double loss_rate = atof(rate);
+ if (loss_rate < INJECT_RATE_LOWER || loss_rate >= 1) {
+ printf("FAULT INJECT error: loss rate error, range in [0.001, 1), now is %f\n", loss_rate);
+ return parse_success;
+ }
+ req_msg->data.inject.inject_data.loss.loss_rate = loss_rate;
+
+ int32_t loss_counts = atoi(count);
+ if (loss_counts <= 0) {
+ printf("FAULT INJECT error: single loss counts wrong --%d, need positive integer.", loss_counts);
+ return parse_success;
+ }
+ req_msg->data.inject.inject_data.loss.loss_sigle_count = loss_counts;
+
+ return ++parse_success;
+}
+
+static int32_t parse_inject_packet_duplicate_digit(char *rate, char *count, struct gazelle_stat_msg_request *req_msg)
+{
+ int32_t parse_success = 0;
+ double duplicate_rate = atof(rate);
+ if (duplicate_rate < INJECT_RATE_LOWER || duplicate_rate >= 1) {
+ printf("FAULT INJECT error: duplicate rate error, range in [0.001, 1), now is %f\n", duplicate_rate);
+ return parse_success;
+ }
+ req_msg->data.inject.inject_data.duplicate.duplicate_rate = duplicate_rate;
+
+ int32_t duplicate_counts = atoi(count);
+ if (duplicate_counts <= 0) {
+ printf("FAULT INJECT error: single duplicate counts wrong --%d, need positive integer.", duplicate_counts);
+ return parse_success;
+ }
+ req_msg->data.inject.inject_data.duplicate.duplicate_sigle_count = duplicate_counts;
+
+ return ++parse_success;
+}
+
+static int32_t parse_inject_packet_reorder_digit(char *rate, char *count, struct gazelle_stat_msg_request *req_msg)
+{
+ int32_t parse_success = 0;
+ double reorder_rate = atof(rate);
+ if (reorder_rate < INJECT_RATE_LOWER || reorder_rate >= 1) {
+ printf("FAULT INJECT error: reorder rate error, range in [0.001, 1), now is %f\n", reorder_rate);
+ return parse_success;
+ }
+ req_msg->data.inject.inject_data.reorder.reorder_rate = reorder_rate;
+
+ int32_t reorder_counts = atoi(count);
+ if (reorder_counts <= 0) {
+ printf("FAULT INJECT error: single duplicate counts wrong --%d, need positive integer.", reorder_counts);
+ return parse_success;
+ }
+ req_msg->data.inject.inject_data.reorder.reorder_sigle_count = reorder_counts;
+
+ return ++parse_success;
+}
+
+static int32_t parse_fault_inject_digital_data(char *argv[], struct gazelle_stat_msg_request *req_msg)
+{
+ int32_t parse_success = 0;
+ int32_t func_count = sizeof(inject_type_list) / sizeof(inject_type_list[0]);
+ for (int32_t i = 0; i < func_count; ++i) {
+ if (inject_type_list[i].inject_type_parsed == req_msg->data.inject.inject_type) {
+ parse_success = inject_type_list[i].parse_digit_func(argv[INJECT_DIGITAL_FIRST_INDEX],
+ argv[INJECT_DIGITAL_SECOND_INDEX], req_msg);
+ break;
+ }
+ }
+
+ return parse_success;
+}
+
+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. */
+
+ req_msg->data.inject.fault_inject_on = 1; /* set fault inject on */
+
+ 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);
+ return num_cmd;
+ }
+
+ 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) {
+ 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;
+ }
+
+ int32_t inject_rule_count = sizeof(g_gazelle_fault_inject_rule_list) / sizeof(g_gazelle_fault_inject_rule_list[0]);
+ for (int32_t i = 0; i < inject_rule_count; ++i) {
+ if (strcmp(g_gazelle_fault_inject_rule_list[i].inject_rule_item, argv[INJECT_RULE_INDEX]) == 0 &&
+ g_gazelle_fault_inject_rule_list[i].rule_parse_assit == req_msg->data.inject.inject_type) {
+ req_msg->data.inject.inject_rule = g_gazelle_fault_inject_rule_list[i].inject_rule_parsed;
+ break;
+ }
+ }
+ if (req_msg->data.inject.inject_rule == INJECT_RULE_ERR) {
+ printf("FAULT_INJECT error: input inject rule is wrong -- %s\n", argv[INJECT_RULE_INDEX]);
+ return num_cmd;
+ }
+
+ num_cmd = parse_fault_inject_digital_data(argv, req_msg);
+
+ 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)
{
int32_t num_cmd = 0;
@@ -1451,7 +1715,11 @@ static int32_t parse_dfx_cmd_args(int32_t argc, char *argv[], struct gazelle_sta
if (strcmp(param, "lstack") == 0) {
num_cmd = parse_dfx_lstack_args(argc, argv, req_msg);
}
-
+#ifdef GAZELLE_FAULT_INJECT_ENABLE
+ if (strcmp(param, "inject") == 0) {
+ num_cmd = parse_dfx_fault_inject_args(argc, argv, req_msg);
+ }
+#endif /* GAZELLE_FAULT_INJECT_ENABLE */
return num_cmd;
}
--
2.27.0

22
gazelle.spec
View File

@ -2,7 +2,7 @@
Name: gazelle
Version: 1.0.2
Release: 27
Release: 28
Summary: gazelle is a high performance user-mode stack
License: MulanPSL-2.0
URL: https://gitee.com/openeuler/gazelle
@ -145,6 +145,15 @@ Patch9128: 0128-fix-t_params-double-free.patch
Patch9129: 0129-fix-receive-fin-packet-process-error.patch
Patch9130: 0130-support-netperf-UDP_STREAM-and-UDP_RR.patch
Patch9131: 0131-adapt-lwip-2.2.0.patch
Patch9132: 0132-add-observable-method-of-data-aggregation.patch
Patch9133: 0133-try-to-ensure-arp-packet-can-be-sent.patch
Patch9134: 0134-gazellectl-support-send-latency-show.patch
Patch9135: 0135-rpc-function-does-not-depend-on-protocol-stack.patch
Patch9136: 0136-readv-return-1-errno-is-EAGAIN-when-recvring-no-data.patch
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
%description
%{name} is a high performance user-mode stack.
@ -186,6 +195,17 @@ 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-28
- FAULT INJECT: gazelle add packet delay and packet drop
- diff udp and tcp read from stack
- fix coreddump when stack setup failed in rtc mode
- split the flow fules related functions into separate file
- readv return -1, errno is EAGAIN when recvring no data
- rpc function does not depend on protocol stack diff rpc queue and dfx rpc queue
- gazellectl: support send latency show
- try to ensure arp packet can be sent
- add observable method of data aggregation
* Wed Feb 07 2024 yibin6 <yinbin8@huawei.com> - 1.0.2-27
- support netperf UDP_STREAM and UDP_RR