From e0743109ab82f51fc143b3d3bd8e1be5328c0c9d Mon Sep 17 00:00:00 2001 From: jiangheng12 Date: Mon, 10 Apr 2023 09:48:53 +0800 Subject: [PATCH] sync fix bond_ports parse error fix socket_mem parse error when the value exceeds 65536 exit if create_rxtx_pktmbuf failed build.sh build failed return 1 clean code (cherry picked from commit 66c5d4e2aa25c48777d89c6bfda9c8fb61b15358) --- ...onblock-to-fix-example-connect-error.patch | 41 ++ 0236-kni-down-not-stop-nic.patch | 218 ++++++ 0237-fix-rpc-msg-alloc-failed.patch | 79 +++ 0238-add-parentheses-to-fix-build-error.patch | 27 + ...-add-udp-protocol-support-in-example.patch | 624 ++++++++++++++++++ 0240-fix-bond_ports-parse-error.patch | 446 +++++++++++++ gazelle.spec | 16 +- 7 files changed, 1450 insertions(+), 1 deletion(-) create mode 100644 0235-set-client-nonblock-to-fix-example-connect-error.patch create mode 100644 0236-kni-down-not-stop-nic.patch create mode 100644 0237-fix-rpc-msg-alloc-failed.patch create mode 100644 0238-add-parentheses-to-fix-build-error.patch create mode 100644 0239-add-udp-protocol-support-in-example.patch create mode 100644 0240-fix-bond_ports-parse-error.patch diff --git a/0235-set-client-nonblock-to-fix-example-connect-error.patch b/0235-set-client-nonblock-to-fix-example-connect-error.patch new file mode 100644 index 0000000..2022139 --- /dev/null +++ b/0235-set-client-nonblock-to-fix-example-connect-error.patch @@ -0,0 +1,41 @@ +From 81de059e410f6d1fc38e7caa380b13a0ea1fc9f1 Mon Sep 17 00:00:00 2001 +From: kircher +Date: Sat, 1 Apr 2023 17:30:07 +0800 +Subject: [PATCH] set client nonblock to fix example connect error + +--- + examples/src/client.c | 1 + + examples/src/utilities.c | 5 +++++ + 2 files changed, 6 insertions(+) + +diff --git a/examples/src/client.c b/examples/src/client.c +index 46dd039..a3a3ad0 100644 +--- a/examples/src/client.c ++++ b/examples/src/client.c +@@ -372,6 +372,7 @@ int32_t client_create_and_run(struct ProgramParams *params) + client_unit->epollcreate = params->epollcreate; + client_unit->debug = params->debug; + client_unit->next = (struct ClientUnit *)malloc(sizeof(struct ClientUnit)); ++ memset_s(client_unit->next, sizeof(struct ClientUnit), 0, sizeof(struct ClientUnit)); + + if (pthread_create((tids + i), NULL, client_s_create_and_run, client_unit) < 0) { + PRINT_ERROR("client can't create thread of poisx %d! ", errno); +diff --git a/examples/src/utilities.c b/examples/src/utilities.c +index 38a0d3e..877e611 100644 +--- a/examples/src/utilities.c ++++ b/examples/src/utilities.c +@@ -86,6 +86,11 @@ int32_t create_socket_and_connect(int32_t *socket_fd, in_addr_t ip, uint16_t por + return PROGRAM_FAULT; + } + ++ if (set_socket_unblock(*socket_fd) < 0) { ++ PRINT_ERROR("can't set the socket to unblock! "); ++ return PROGRAM_FAULT; ++ } ++ + struct sockaddr_in server_addr; + memset_s(&server_addr, sizeof(server_addr), 0, sizeof(server_addr)); + server_addr.sin_family = AF_INET; +-- +2.23.0 + diff --git a/0236-kni-down-not-stop-nic.patch b/0236-kni-down-not-stop-nic.patch new file mode 100644 index 0000000..fad4bcb --- /dev/null +++ b/0236-kni-down-not-stop-nic.patch @@ -0,0 +1,218 @@ +From 59c658fa0f75748fa7b49170b9fc34267ef1797c Mon Sep 17 00:00:00 2001 +From: jiangheng12 +Date: Mon, 3 Apr 2023 14:42:53 +0800 +Subject: [PATCH] kni down not stop nic + +--- + src/common/dpdk_common.c | 37 +++++++++++-------------- + src/common/dpdk_common.h | 2 +- + src/lstack/core/lstack_cfg.c | 8 +++--- + src/lstack/core/lstack_protocol_stack.c | 10 ++++--- + src/lstack/netif/lstack_ethdev.c | 8 ++++-- + src/ltran/ltran_forward.c | 5 ++-- + 6 files changed, 34 insertions(+), 36 deletions(-) + +diff --git a/src/common/dpdk_common.c b/src/common/dpdk_common.c +index f5a20dd..23c96d6 100644 +--- a/src/common/dpdk_common.c ++++ b/src/common/dpdk_common.c +@@ -34,16 +34,12 @@ + #define COMMON_INFO(fmt, ...) LSTACK_LOG(INFO, LSTACK, fmt, ##__VA_ARGS__) + #endif + +-static pthread_mutex_t g_kni_mutex = PTHREAD_MUTEX_INITIALIZER; + struct rte_kni *g_pkni = NULL; ++static volatile bool g_kni_started = false; + +-/* +- * lock for preventing data race between tx thread and down operation. +- * Don't need to add lock on rx because down operation and rx are in the same thread +- */ +-pthread_mutex_t *get_kni_mutex(void) ++bool get_kni_started(void) + { +- return &g_kni_mutex; ++ return g_kni_started; + } + + struct rte_kni* get_gazelle_kni(void) +@@ -62,23 +58,18 @@ static int32_t kni_config_network_interface(uint16_t port_id, uint8_t if_up) + } + + if (if_up != 0) { /* Configure network interface up */ +- if (!g_bond_dev_started) { +- pthread_mutex_lock(&g_kni_mutex); +- ret = rte_eth_dev_start(port_id); +- pthread_mutex_unlock(&g_kni_mutex); +- if (ret < 0) { +- COMMON_ERR("Failed to start port %hu ret=%d\n", port_id, ret); ++ if (!g_kni_started) { ++ g_kni_started = true; ++ if (!g_bond_dev_started) { ++ rte_eth_dev_start(port_id); ++ g_bond_dev_started = true; + } +- g_bond_dev_started = true; + } else { + COMMON_INFO("trying to start a started dev. \n"); + } + } else { /* Configure network interface down */ +- if (g_bond_dev_started) { +- pthread_mutex_lock(&g_kni_mutex); +- rte_eth_dev_stop(port_id); +- pthread_mutex_unlock(&g_kni_mutex); +- g_bond_dev_started = false; ++ if (g_kni_started) { ++ g_kni_started = false; + } else { + COMMON_INFO("trying to stop a stopped dev. \n"); + } +@@ -201,6 +192,12 @@ void dpdk_kni_release(void) + int32_t kni_process_tx(struct rte_mbuf **pkts_burst, uint32_t count) + { + uint32_t i; ++ if (!g_kni_started) { ++ for (i = 0; i < count; i++) { ++ rte_pktmbuf_free(pkts_burst[i]); ++ } ++ return 0; ++ } + + for (i = 0; i < count; ++i) { + struct rte_ipv4_hdr * ipv4_hdr = (struct rte_ipv4_hdr *)(rte_pktmbuf_mtod(pkts_burst[i], char*) +@@ -227,9 +224,7 @@ void kni_process_rx(uint16_t port) + + nb_kni_rx = rte_kni_rx_burst(g_pkni, pkts_burst, GAZELLE_KNI_READ_SIZE); + if (nb_kni_rx > 0) { +- pthread_mutex_lock(&g_kni_mutex); + nb_rx = rte_eth_tx_burst(port, 0, pkts_burst, nb_kni_rx); +- pthread_mutex_unlock(&g_kni_mutex); + + for (i = nb_rx; i < nb_kni_rx; ++i) { + rte_pktmbuf_free(pkts_burst[i]); +diff --git a/src/common/dpdk_common.h b/src/common/dpdk_common.h +index 6b107ae..2f0e8d1 100644 +--- a/src/common/dpdk_common.h ++++ b/src/common/dpdk_common.h +@@ -94,7 +94,7 @@ static __rte_always_inline void time_stamp_into_mbuf(uint32_t rx_count, struct r + } + } + +-pthread_mutex_t *get_kni_mutex(void); ++bool get_kni_started(void); + struct rte_kni* get_gazelle_kni(void); + int32_t dpdk_kni_init(uint16_t port, struct rte_mempool *pool); + int32_t kni_process_tx(struct rte_mbuf **pkts_burst, uint32_t count); +diff --git a/src/lstack/core/lstack_cfg.c b/src/lstack/core/lstack_cfg.c +index 168aa49..8558121 100644 +--- a/src/lstack/core/lstack_cfg.c ++++ b/src/lstack/core/lstack_cfg.c +@@ -1026,6 +1026,10 @@ static int parse_process_index(void) + } + } else { + g_config_params.process_idx = (uint8_t)config_setting_get_int(process_idx); ++ if (g_config_params.is_primary && g_config_params.process_idx != 0 || ++ !g_config_params.is_primary && g_config_params.process_idx == 0) { ++ return -EINVAL; ++ } + } + + return 0; +@@ -1045,9 +1049,5 @@ static int parse_tuple_filter(void) + return -EINVAL; + } + +- // check primary process_idx +- if (g_config_params.is_primary && g_config_params.process_idx != 0) { +- return -EINVAL; +- } + return 0; + } +diff --git a/src/lstack/core/lstack_protocol_stack.c b/src/lstack/core/lstack_protocol_stack.c +index 76914f8..a858b37 100644 +--- a/src/lstack/core/lstack_protocol_stack.c ++++ b/src/lstack/core/lstack_protocol_stack.c +@@ -483,7 +483,9 @@ static void* gazelle_stack_thread(void *arg) + * so processing KNI requests only in the thread with queue_id No.0 is sufficient. */ + if (kni_switch && !queue_id && !(wakeup_tick & 0xfff)) { + rte_kni_handle_request(get_gazelle_kni()); +- kni_handle_rx(get_port_id()); ++ if (get_kni_started()) { ++ kni_handle_rx(get_port_id()); ++ } + } + + wakeup_tick++; +@@ -557,9 +559,9 @@ int32_t init_protocol_stack(void) + + if (get_global_cfg_params()->is_primary) { + for (uint16_t idx = 0; idx < get_global_cfg_params()->tot_queue_num; idx++) { +- struct rte_mempool* rxtx_mbuf = create_pktmbuf_mempool("rxtx_mbuf", +- get_global_cfg_params()->mbuf_count_per_conn * get_global_cfg_params()->tcp_conn_count / stack_group->stack_num, RXTX_CACHE_SZ, idx); +- get_protocol_stack_group()->total_rxtx_pktmbuf_pool[idx] = rxtx_mbuf; ++ struct rte_mempool* rxtx_mbuf = create_pktmbuf_mempool("rxtx_mbuf", ++ get_global_cfg_params()->mbuf_count_per_conn * get_global_cfg_params()->tcp_conn_count / stack_group->stack_num, RXTX_CACHE_SZ, idx); ++ get_protocol_stack_group()->total_rxtx_pktmbuf_pool[idx] = rxtx_mbuf; + } + } + +diff --git a/src/lstack/netif/lstack_ethdev.c b/src/lstack/netif/lstack_ethdev.c +index e26fe30..4103f22 100644 +--- a/src/lstack/netif/lstack_ethdev.c ++++ b/src/lstack/netif/lstack_ethdev.c +@@ -719,7 +719,9 @@ void kni_handle_rx(uint16_t port_id) + + void kni_handle_tx(struct rte_mbuf *mbuf) + { +- if (!get_global_cfg_params()->kni_switch) { ++ if (!get_global_cfg_params()->kni_switch || ++ !get_kni_started()) { ++ rte_pktmbuf_free(mbuf); + return; + } + struct rte_ipv4_hdr *ipv4_hdr; +@@ -776,9 +778,9 @@ int32_t gazelle_eth_dev_poll(struct protocol_stack *stack, uint8_t use_ltran_fla + if (likely(transfer_type == TRANSFER_CURRENT_THREAD)) { + eth_dev_recv(stack->pkts[i], stack); + +- }else if (transfer_type == TRANSFER_KERNEL) { ++ } else if (transfer_type == TRANSFER_KERNEL) { + kni_handle_tx(stack->pkts[i]); +- }else { ++ } else { + /*transfer to other thread*/ + } + } +diff --git a/src/ltran/ltran_forward.c b/src/ltran/ltran_forward.c +index 8629acb..b41e1e2 100644 +--- a/src/ltran/ltran_forward.c ++++ b/src/ltran/ltran_forward.c +@@ -690,7 +690,6 @@ static __rte_always_inline void downstream_forward_one(struct gazelle_stack *sta + /* send packets anyway. */ + tx_pkts = 0; + +- pthread_mutex_lock(get_kni_mutex()); + while (tx_pkts < used_cnt) { + tx_pkts += rte_eth_tx_burst(port_id, queue_id, + (struct rte_mbuf **)(&dst_bufs[tx_pkts]), +@@ -702,7 +701,6 @@ static __rte_always_inline void downstream_forward_one(struct gazelle_stack *sta + } + } + } +- pthread_mutex_unlock(get_kni_mutex()); + + get_statistics()->port_stats[g_port_index].tx_bytes += tx_bytes; + get_statistics()->port_stats[g_port_index].tx += tx_pkts; +@@ -737,7 +735,8 @@ int32_t downstream_forward(uint16_t *port) + + while (get_ltran_stop_flag() != GAZELLE_TRUE) { + /* kni rx means read from kni and send to nic */ +- if (get_ltran_config()->dpdk.kni_switch == GAZELLE_ON) { ++ if (get_ltran_config()->dpdk.kni_switch == GAZELLE_ON && ++ get_kni_started()) { + kni_process_rx(g_port_index); + } + +-- +2.23.0 + diff --git a/0237-fix-rpc-msg-alloc-failed.patch b/0237-fix-rpc-msg-alloc-failed.patch new file mode 100644 index 0000000..754e528 --- /dev/null +++ b/0237-fix-rpc-msg-alloc-failed.patch @@ -0,0 +1,79 @@ +From 9ae296b6fbda03781799251ba8801e166cded656 Mon Sep 17 00:00:00 2001 +From: jiangheng12 +Date: Thu, 6 Apr 2023 19:42:59 +0800 +Subject: [PATCH] fix rpc msg alloc failed fix process_numa args error coredump + fix sock->conn not free when fd is kernel mode + +--- + src/lstack/api/lstack_wrap.c | 9 ++++++++- + src/lstack/core/lstack_cfg.c | 4 ++-- + src/lstack/core/lstack_protocol_stack.c | 4 ++++ + src/lstack/include/lstack_thread_rpc.h | 2 +- + 4 files changed, 15 insertions(+), 4 deletions(-) + +diff --git a/src/lstack/api/lstack_wrap.c b/src/lstack/api/lstack_wrap.c +index b8a6590..90b2252 100644 +--- a/src/lstack/api/lstack_wrap.c ++++ b/src/lstack/api/lstack_wrap.c +@@ -528,7 +528,14 @@ static inline int32_t do_close(int32_t s) + { + struct lwip_sock *sock = NULL; + if (select_path(s, &sock) == PATH_KERNEL) { +- return posix_api->close_fn(s); ++ /* we called lwip_socket, even if kernel fd */ ++ if (posix_api != NULL && !posix_api->ues_posix && ++ /* contain posix_api->close_fn if success */ ++ stack_broadcast_close(s) == 0) { ++ return 0; ++ } else { ++ return posix_api->close_fn(s); ++ } + } + if (sock && sock->wakeup && sock->wakeup->epollfd == s) { + return lstack_epoll_close(s); +diff --git a/src/lstack/core/lstack_cfg.c b/src/lstack/core/lstack_cfg.c +index 8558121..9430dd7 100644 +--- a/src/lstack/core/lstack_cfg.c ++++ b/src/lstack/core/lstack_cfg.c +@@ -998,8 +998,8 @@ static int32_t parse_process_numa(void) + return 0; + + args = config_setting_get_string(cfg_args); +- if (cfg_args == NULL) { +- return 0; ++ if (args == NULL) { ++ return -EINVAL; + } + + ret = separate_str_to_array((char *)args, g_config_params.process_numa, PROTOCOL_STACK_MAX, GAZELLE_MAX_NUMA_NODES); +diff --git a/src/lstack/core/lstack_protocol_stack.c b/src/lstack/core/lstack_protocol_stack.c +index a858b37..061582f 100644 +--- a/src/lstack/core/lstack_protocol_stack.c ++++ b/src/lstack/core/lstack_protocol_stack.c +@@ -819,6 +819,10 @@ int32_t stack_broadcast_close(int32_t fd) + struct lwip_sock *sock = get_socket(fd); + int32_t ret = 0; + ++ if (sock == NULL) { ++ return -1; ++ } ++ + do { + sock = sock->listen_next; + if (rpc_call_close(fd)) { +diff --git a/src/lstack/include/lstack_thread_rpc.h b/src/lstack/include/lstack_thread_rpc.h +index ed111fb..657ffa9 100644 +--- a/src/lstack/include/lstack_thread_rpc.h ++++ b/src/lstack/include/lstack_thread_rpc.h +@@ -25,7 +25,7 @@ + #define MSG_ARG_4 (4) + #define RPM_MSG_ARG_SIZE (5) + +-#define RPC_MSG_MAX 512 ++#define RPC_MSG_MAX 2048 + #define RPC_MSG_MASK (RPC_MSG_MAX - 1) + + struct rpc_msg; +-- +2.23.0 + diff --git a/0238-add-parentheses-to-fix-build-error.patch b/0238-add-parentheses-to-fix-build-error.patch new file mode 100644 index 0000000..d1cc64b --- /dev/null +++ b/0238-add-parentheses-to-fix-build-error.patch @@ -0,0 +1,27 @@ +From ace78c329b02e69162c1ec4b9b3260d276694ece Mon Sep 17 00:00:00 2001 +From: jiangheng12 +Date: Fri, 7 Apr 2023 09:42:39 +0800 +Subject: [PATCH] add parentheses to fix build error + +--- + src/lstack/core/lstack_cfg.c | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +diff --git a/src/lstack/core/lstack_cfg.c b/src/lstack/core/lstack_cfg.c +index 9430dd7..394cb13 100644 +--- a/src/lstack/core/lstack_cfg.c ++++ b/src/lstack/core/lstack_cfg.c +@@ -1026,8 +1026,8 @@ static int parse_process_index(void) + } + } else { + g_config_params.process_idx = (uint8_t)config_setting_get_int(process_idx); +- if (g_config_params.is_primary && g_config_params.process_idx != 0 || +- !g_config_params.is_primary && g_config_params.process_idx == 0) { ++ if ((g_config_params.is_primary && g_config_params.process_idx != 0) || ++ (!g_config_params.is_primary && g_config_params.process_idx == 0)) { + return -EINVAL; + } + } +-- +2.23.0 + diff --git a/0239-add-udp-protocol-support-in-example.patch b/0239-add-udp-protocol-support-in-example.patch new file mode 100644 index 0000000..5293307 --- /dev/null +++ b/0239-add-udp-protocol-support-in-example.patch @@ -0,0 +1,624 @@ +From ee26b3ee749cd7906d3f1cc928c3a5603e74d6e0 Mon Sep 17 00:00:00 2001 +From: kircher +Date: Fri, 7 Apr 2023 17:18:58 +0800 +Subject: [PATCH] add udp protocol support in example + +--- + examples/inc/bussiness.h | 2 +- + examples/inc/client.h | 4 +++- + examples/inc/parameter.h | 4 ++++ + examples/inc/server.h | 2 +- + examples/inc/utilities.h | 2 +- + examples/src/bussiness.c | 46 +++++++++++++++++++++++++++++++++------- + examples/src/client.c | 11 +++++----- + examples/src/parameter.c | 41 +++++++++++++++++++++++++++++------ + examples/src/server.c | 26 +++++++++++++++-------- + examples/src/utilities.c | 45 ++++++++++++++++++++++++++++++++------- + 10 files changed, 142 insertions(+), 41 deletions(-) + +diff --git a/examples/inc/bussiness.h b/examples/inc/bussiness.h +index f16d771..3abb448 100644 +--- a/examples/inc/bussiness.h ++++ b/examples/inc/bussiness.h +@@ -95,7 +95,7 @@ int32_t client_bussiness(char *out, const char *in, uint32_t size, bool verify, + * @param api the api + * @return the result + */ +-int32_t server_ans(struct ServerHandler *server_handler, uint32_t pktlen, const char* api); ++int32_t server_ans(struct ServerHandler *server_handler, uint32_t pktlen, const char* api, const char* domain); + + /** + * @brief client asks server +diff --git a/examples/inc/client.h b/examples/inc/client.h +index ad824c7..fa506fb 100644 +--- a/examples/inc/client.h ++++ b/examples/inc/client.h +@@ -33,6 +33,7 @@ struct ClientUnit + uint64_t send_bytes; ///< total send bytes + in_addr_t ip; ///< server ip + uint16_t port; ///< server port ++ uint16_t sport; ///< client sport + uint32_t connect_num; ///< total connection number + uint32_t pktlen; ///< the length of peckage + bool verify; ///< if we verify or not +@@ -80,10 +81,11 @@ void client_info_print(struct Client *client); + * @param epoll_fd the epoll file descriptor + * @param ip ip address + * @param port port ++ * @param sport sport + * @param domain domain + * @return the result pointer + */ +-int32_t client_thread_try_connect(struct ClientHandler *client_handler, int32_t epoll_fd, in_addr_t ip, uint16_t port, const char *api); ++int32_t client_thread_try_connect(struct ClientHandler *client_handler, int32_t epoll_fd, in_addr_t ip, uint16_t port, uint16_t sport, const char *api); + + /** + * @brief the single thread, client retry to connect to server, register to epoll +diff --git a/examples/inc/parameter.h b/examples/inc/parameter.h +index 0683822..4242d1a 100644 +--- a/examples/inc/parameter.h ++++ b/examples/inc/parameter.h +@@ -21,6 +21,7 @@ + #define PARAM_DEFAULT_AS ("server") ///< default type + #define PARAM_DEFAULT_IP ("127.0.0.1") ///< default IP + #define PARAM_DEFAULT_PORT (5050) ///< default port ++#define PARAM_DEFAULT_SPORT (0) ///< default sport + #define PARAM_DEFAULT_MODEL ("mum") ///< default model type + #define PARAM_DEFAULT_CONNECT_NUM (10) ///< default connection number + #define PARAM_DEFAULT_THREAD_NUM (8) ///< default thread number +@@ -41,6 +42,8 @@ enum { + PARAM_NUM_IP = 'i', + #define PARAM_NAME_PORT ("port") ///< name of parameter port + PARAM_NUM_PORT = 'p', ++#define PARAM_NAME_SPORT ("sport") ///< name of parameter sport ++ PARAM_NUM_SPORT = 's', + #define PARAM_NAME_MODEL ("model") ///< name of parameter model type + PARAM_NUM_MODEL = 'm', + #define PARAM_NAME_CONNECT_NUM ("connectnum") ///< name of parameter connection number +@@ -91,6 +94,7 @@ struct ProgramParams { + char* as; ///< as server or client + char* ip; ///< IP address + uint32_t port; ///< port ++ uint32_t sport; ///< sport + char* model; ///< model type + uint32_t thread_num; ///< the number of threads + uint32_t connect_num; ///< the connection number +diff --git a/examples/inc/server.h b/examples/inc/server.h +index 45ca895..7b175db 100644 +--- a/examples/inc/server.h ++++ b/examples/inc/server.h +@@ -142,7 +142,7 @@ int32_t sermud_listener_accept_connects(struct ServerMud *server_mud); + * @param worker_unit the server worker + * @return the result pointer + */ +-int32_t sermud_worker_proc_epevs(struct ServerMudWorker *worker_unit); ++int32_t sermud_worker_proc_epevs(struct ServerMudWorker *worker_unit, const char* domain); + + /** + * @brief the listener thread, unblock, dissymmetric server processes the events +diff --git a/examples/inc/utilities.h b/examples/inc/utilities.h +index a083f57..9c22abe 100644 +--- a/examples/inc/utilities.h ++++ b/examples/inc/utilities.h +@@ -128,7 +128,7 @@ int32_t create_socket_and_listen(int32_t *socket_fd, in_addr_t ip, uint16_t port + * @param domain domain + * @return the result + */ +-int32_t create_socket_and_connect(int32_t *socket_fd, in_addr_t ip, uint16_t port, const char *domain); ++int32_t create_socket_and_connect(int32_t *socket_fd, in_addr_t ip, uint16_t port, uint16_t sport, const char *domain); + + /** + * @brief set the socket to unblock +diff --git a/examples/src/bussiness.c b/examples/src/bussiness.c +index b084b37..f108a9f 100644 +--- a/examples/src/bussiness.c ++++ b/examples/src/bussiness.c +@@ -37,7 +37,7 @@ static const char bussiness_messages_cap[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; // t + iov[2].iov_base = buffer_in + iov_len_size + iov_len_size; + iov[2].iov_len = length- iov_len_size - iov_len_size; + return readv(fd, iov, iovcnt); +- } else { ++ } else if (strcmp(api, "recvsendmsg") == 0) { + struct msghdr msg_recv; + struct iovec iov; + +@@ -52,6 +52,8 @@ static const char bussiness_messages_cap[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; // t + msg_recv.msg_flags = 0; + + return recvmsg(fd, &msg_recv, 0); ++ } else { ++ return recvfrom(fd, buffer_in, length, 0, NULL, 0); + } + } + +@@ -75,7 +77,7 @@ static const char bussiness_messages_cap[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; // t + iov[2].iov_len = length- iov_len_size - iov_len_size; + + return writev(fd, iov, iovcnt); +- } else { ++ } else if (strcmp(api, "recvsendmsg") == 0) { + struct msghdr msg_send; + struct iovec iov; + +@@ -90,6 +92,8 @@ static const char bussiness_messages_cap[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; // t + msg_send.msg_flags = 0; + + return sendmsg(fd, &msg_send, 0); ++ } else { ++ return sendto(fd, buffer_out, length, 0, NULL, 0); + } + } + +@@ -131,7 +135,7 @@ int32_t client_bussiness(char *out, const char *in, uint32_t size, bool verify, + } + + // server answers +-int32_t server_ans(struct ServerHandler *server_handler, uint32_t pktlen, const char* api) ++int32_t server_ans(struct ServerHandler *server_handler, uint32_t pktlen, const char* api, const char* domain) + { + const uint32_t length = pktlen; + char *buffer_in = (char *)malloc(length * sizeof(char)); +@@ -139,14 +143,34 @@ int32_t server_ans(struct ServerHandler *server_handler, uint32_t pktlen, const + + int32_t cread = 0; + int32_t sread = length; ++ int32_t nread = 0; ++ struct sockaddr_in client_addr; ++ socklen_t len = sizeof(client_addr); ++ ++ if (strcmp(domain, "udp") == 0 && strcmp(api, "recvfromsendto") != 0) { ++ if (getpeername(server_handler->fd, (struct sockaddr *)&client_addr, &len) < 0) { ++ if (recvfrom(server_handler->fd, buffer_in, length, MSG_PEEK, (struct sockaddr *)&client_addr, &len) < 0) { ++ return PROGRAM_FAULT; ++ } ++ if (connect(server_handler->fd, (struct sockaddr *)&client_addr, sizeof(struct sockaddr_in)) < 0) { ++ return PROGRAM_FAULT; ++ } ++ } ++ } ++ + while (cread < sread) { +- int32_t nread = read_api(server_handler->fd, buffer_in, length, api); ++ if (strcmp(domain, "udp") == 0 && strcmp(api, "recvfromsendto") == 0) { ++ nread = recvfrom(server_handler->fd, buffer_in, length, 0, (struct sockaddr *)&client_addr, &len); ++ } else { ++ nread = read_api(server_handler->fd, buffer_in, length, api); ++ } ++ + if (nread == 0) { + return PROGRAM_ABORT; + } else if (nread < 0) { +- if (errno != EINTR && errno != EWOULDBLOCK && errno != EAGAIN) { ++ if (errno != EINTR && errno != EWOULDBLOCK && errno != EAGAIN) { + return PROGRAM_FAULT; +- } ++ } + } else { + cread += nread; + continue; +@@ -157,8 +181,14 @@ int32_t server_ans(struct ServerHandler *server_handler, uint32_t pktlen, const + + int32_t cwrite = 0; + int32_t swrite = length; ++ int32_t nwrite = 0; + while (cwrite < swrite) { +- int32_t nwrite = write_api(server_handler->fd, buffer_out, length, api); ++ if (strcmp(domain, "udp") == 0 && strcmp(api, "recvfromsendto") == 0) { ++ nwrite = sendto(server_handler->fd, buffer_out, length, 0, (struct sockaddr *)&client_addr, len); ++ } else { ++ nwrite = write_api(server_handler->fd, buffer_out, length, api); ++ } ++ + if (nwrite == 0) { + return PROGRAM_ABORT; + } else if (nwrite < 0) { +@@ -256,4 +286,4 @@ int32_t client_chkans(struct ClientHandler *client_handler, uint32_t pktlen, boo + free(buffer_out); + + return PROGRAM_OK; +-} +\ No newline at end of file ++} +diff --git a/examples/src/client.c b/examples/src/client.c +index a3a3ad0..b0b99b6 100644 +--- a/examples/src/client.c ++++ b/examples/src/client.c +@@ -85,9 +85,9 @@ void client_info_print(struct Client *client) + } + + // the single thread, client try to connect to server, register to epoll +-int32_t client_thread_try_connect(struct ClientHandler *client_handler, int32_t epoll_fd, in_addr_t ip, uint16_t port, const char *domain) ++int32_t client_thread_try_connect(struct ClientHandler *client_handler, int32_t epoll_fd, in_addr_t ip, uint16_t port, uint16_t sport, const char *domain) + { +- int32_t create_socket_and_connect_ret = create_socket_and_connect(&(client_handler->fd), ip, port, domain); ++ int32_t create_socket_and_connect_ret = create_socket_and_connect(&(client_handler->fd), ip, port, sport, domain); + if (create_socket_and_connect_ret == PROGRAM_INPROGRESS) { + struct epoll_event ep_ev; + ep_ev.events = EPOLLOUT; +@@ -103,7 +103,7 @@ int32_t client_thread_try_connect(struct ClientHandler *client_handler, int32_t + // the single thread, client retry to connect to server, register to epoll + int32_t client_thread_retry_connect(struct ClientUnit *client_unit, struct ClientHandler *client_handler) + { +- int32_t clithd_try_cnntask_ret = client_thread_try_connect(client_handler, client_unit->epfd, client_unit->ip, client_unit->port, client_unit->domain); ++ int32_t clithd_try_cnntask_ret = client_thread_try_connect(client_handler, client_unit->epfd, client_unit->ip, client_unit->port, client_unit->sport, client_unit->domain); + if (clithd_try_cnntask_ret < 0) { + if (clithd_try_cnntask_ret == PROGRAM_INPROGRESS) { + return PROGRAM_OK; +@@ -168,7 +168,7 @@ int32_t client_thread_create_epfd_and_reg(struct ClientUnit *client_unit) + } + + for (uint32_t i = 0; i < connect_num; ++i) { +- int32_t clithd_try_cnntask_ret = client_thread_try_connect(client_unit->handlers + i, client_unit->epfd, client_unit->ip, client_unit->port, client_unit->domain); ++ int32_t clithd_try_cnntask_ret = client_thread_try_connect(client_unit->handlers + i, client_unit->epfd, client_unit->ip, client_unit->port, client_unit->sport, client_unit->domain); + if (clithd_try_cnntask_ret < 0) { + if (clithd_try_cnntask_ret == PROGRAM_INPROGRESS) { + continue; +@@ -230,7 +230,7 @@ int32_t clithd_proc_epevs(struct ClientUnit *client_unit) + for (int32_t i = 0; i < epoll_nfds; ++i) { + struct epoll_event *curr_epev = client_unit->epevs + i; + +- if (curr_epev->events == EPOLLERR) { ++ if (curr_epev->events == EPOLLERR && errno != 0) { + PRINT_ERROR("client epoll wait error! %d", curr_epev->events); + return PROGRAM_FAULT; + } else if (curr_epev->events == EPOLLOUT) { +@@ -364,6 +364,7 @@ int32_t client_create_and_run(struct ProgramParams *params) + client_unit->send_bytes = 0; + client_unit->ip = inet_addr(params->ip); + client_unit->port = htons(params->port); ++ client_unit->sport = htons(params->sport); + client_unit->connect_num = params->connect_num; + client_unit->pktlen = params->pktlen; + client_unit->verify = params->verify; +diff --git a/examples/src/parameter.c b/examples/src/parameter.c +index 3116a18..a152700 100644 +--- a/examples/src/parameter.c ++++ b/examples/src/parameter.c +@@ -19,6 +19,7 @@ const char prog_short_opts[] = \ + "a:" // as + "i:" // ip + "p:" // port ++ "s:" // sport + "m:" // model + "t:" // thread number + "c:" // connect number +@@ -39,6 +40,7 @@ const struct ProgramOption prog_long_opts[] = \ + {PARAM_NAME_AS, REQUIRED_ARGUMETN, NULL, PARAM_NUM_AS}, + {PARAM_NAME_IP, REQUIRED_ARGUMETN, NULL, PARAM_NUM_IP}, + {PARAM_NAME_PORT, REQUIRED_ARGUMETN, NULL, PARAM_NUM_PORT}, ++ {PARAM_NAME_SPORT, REQUIRED_ARGUMETN, NULL, PARAM_NUM_SPORT}, + {PARAM_NAME_MODEL, REQUIRED_ARGUMETN, NULL, PARAM_NUM_MODEL}, + {PARAM_NAME_THREAD_NUM, REQUIRED_ARGUMETN, NULL, PARAM_NUM_THREAD_NUM}, + {PARAM_NAME_CONNECT_NUM, REQUIRED_ARGUMETN, NULL, PARAM_NUM_CONNECT_NUM}, +@@ -93,6 +95,19 @@ void program_param_parse_port(struct ProgramParams *params) + } + } + ++// set `sport` parameter ++void program_param_parse_sport(struct ProgramParams *params) ++{ ++ int32_t sport_arg = strtol(optarg, NULL, 0); ++ printf("%d\n", sport_arg); ++ if (CHECK_VAL_RANGE(sport_arg, UNIX_TCP_PORT_MIN, UNIX_TCP_PORT_MAX) == true) { ++ params->sport = (uint32_t)sport_arg; ++ } else { ++ PRINT_ERROR("illigal argument -- %s \n", optarg); ++ exit(PROGRAM_ABORT); ++ } ++} ++ + // set `model` parameter + void program_param_parse_model(struct ProgramParams *params) + { +@@ -131,7 +146,7 @@ void program_param_parse_threadnum(struct ProgramParams *params) + // set `domain` parameter + void program_param_parse_domain(struct ProgramParams *params) + { +- if (strcmp(optarg, "unix") == 0 || strcmp(optarg, "posix") == 0) { ++ if (strcmp(optarg, "unix") == 0 || strcmp(optarg, "tcp") == 0 || strcmp(optarg, "udp") == 0) { + params->domain = optarg; + } else { + PRINT_ERROR("illigal argument -- %s \n", optarg); +@@ -143,7 +158,7 @@ void program_param_parse_domain(struct ProgramParams *params) + void program_param_parse_api(struct ProgramParams *params) + { + printf("aaaaaa %s\n", optarg); +- if (strcmp(optarg, "readwrite") == 0 || strcmp(optarg, "readvwritev") == 0 || strcmp(optarg, "recvsend") == 0 || strcmp(optarg, "recvsendmsg") == 0) { ++ if (strcmp(optarg, "readwrite") == 0 || strcmp(optarg, "readvwritev") == 0 || strcmp(optarg, "recvsend") == 0 || strcmp(optarg, "recvsendmsg") == 0 || strcmp(optarg, "recvfromsendto") == 0) { + params->api = optarg; + } else { + PRINT_ERROR("illigal argument -- %s \n", optarg); +@@ -191,6 +206,7 @@ void program_params_init(struct ProgramParams *params) + params->as = PARAM_DEFAULT_AS; + params->ip = PARAM_DEFAULT_IP; + params->port = PARAM_DEFAULT_PORT; ++ params->sport = PARAM_DEFAULT_SPORT; + params->model = PARAM_DEFAULT_MODEL; + params->thread_num = PARAM_DEFAULT_THREAD_NUM; + params->connect_num = PARAM_DEFAULT_CONNECT_NUM; +@@ -213,18 +229,21 @@ void program_params_help(void) + printf(" client: as client. \n"); + printf("-i, --ip [???.???.???.???]: set ip address. \n"); + printf("-p, --port [????]: set port number in range of %d - %d. \n", UNIX_TCP_PORT_MIN, UNIX_TCP_PORT_MAX); ++ printf("-s, --sport [????]: set sport number in range of %d - %d. \n", UNIX_TCP_PORT_MIN, UNIX_TCP_PORT_MAX); + printf("-m, --model [mum | mud]: set the network model. \n"); + printf(" mum: multi thread, unblock, multiplexing IO network model. \n"); + printf(" mud: multi thread, unblock, dissymmetric network model. \n"); + printf("-t, --threadnum [???]: set thread number in range of %d - %d. \n", THREAD_NUM_MIN, THREAD_NUM_MAX); + printf("-c, --connectnum [???]: set connection number of each thread. \n"); +- printf("-D, --domain [unix | posix]: set domain type is server or client. \n"); ++ printf("-D, --domain [unix | tcp | udp]: set domain type is server or client. \n"); + printf(" unix: use unix's api. \n"); +- printf(" posix: use posix api. \n"); +- printf("-A, --api [readwrite | recvsend | recvsendmsg]: set api type is server or client. \n"); ++ printf(" tcp: use tcp api. \n"); ++ printf(" udp: use udp api. \n"); ++ printf("-A, --api [readwrite | recvsend | recvsendmsg | recvfromsendto]: set api type is server or client. \n"); + printf(" readwrite: use `read` and `write`. \n"); + printf(" recvsend: use `recv and `send`. \n"); + printf(" recvsendmsg: use `recvmsg` and `sendmsg`. \n"); ++ printf(" recvfromsendto: use `recvfrom` and `sendto`. \n"); + printf("-P, --pktlen [????]: set packet length in range of %d - %d. \n", MESSAGE_PKTLEN_MIN, MESSAGE_PKTLEN_MAX); + printf("-v, --verify: set to verifying the message packet. \n"); + printf("-r, --ringpmd: set to use ringpmd. \n"); +@@ -259,6 +278,9 @@ int32_t program_params_parse(struct ProgramParams *params, uint32_t argc, char * + case (PARAM_NUM_PORT): + program_param_parse_port(params); + break; ++ case (PARAM_NUM_SPORT): ++ program_param_parse_sport(params); ++ break; + case (PARAM_NUM_MODEL): + program_param_parse_model(params); + break; +@@ -303,7 +325,7 @@ int32_t program_params_parse(struct ProgramParams *params, uint32_t argc, char * + } + } + +- if (strcmp(params->domain, "unix") == 0) { ++ if (strcmp(params->domain, "tcp") != 0) { + params->thread_num = 1; + params->connect_num = 1; + } +@@ -319,6 +341,9 @@ void program_params_print(struct ProgramParams *params) + printf("--> [as]: %s \n", params->as); + printf("--> [server ip]: %s \n", params->ip); + printf("--> [server port]: %u \n", params->port); ++ if (params->sport && strcmp(params->as, "client") == 0) { ++ printf("--> [client sport]: %u \n", params->sport); ++ } + if (strcmp(params->as, "server") == 0) { + printf("--> [model]: %s \n", params->model); + } +@@ -333,8 +358,10 @@ void program_params_print(struct ProgramParams *params) + printf("--> [api]: read & write \n"); + } else if (strcmp(params->api, "recvsend") == 0) { + printf("--> [api]: recv & send \n"); +- } else { ++ } else if (strcmp(params->api, "recvsendmsg") == 0) { + printf("--> [api]: recvmsg & sendmsg \n"); ++ } else { ++ printf("--> [api]: recvfrom & sendto \n"); + } + printf("--> [packet length]: %u \n", params->pktlen); + printf("--> [verify]: %s \n", (params->verify == true) ? "on" : "off"); +diff --git a/examples/src/server.c b/examples/src/server.c +index 7ee73db..6a35f33 100644 +--- a/examples/src/server.c ++++ b/examples/src/server.c +@@ -13,7 +13,6 @@ + + #include "server.h" + +- + static pthread_mutex_t server_debug_mutex; // the server mutex for debug + + // server debug information print +@@ -142,6 +141,10 @@ int32_t sermud_listener_accept_connects(struct ServerMud *server_mud) + struct sockaddr_in accept_addr; + uint32_t sockaddr_in_len = sizeof(struct sockaddr_in); + int32_t accept_fd; ++ if (strcmp(server_mud->domain, "udp") == 0) { ++ break; ++ } ++ + if (strcmp(server_mud->accept, "ac4") == 0) { + accept_fd = accept4(server_mud->listener.fd, (struct sockaddr *)&accept_addr, &sockaddr_in_len, SOCK_CLOEXEC); + } else { +@@ -175,7 +178,7 @@ int32_t sermud_listener_accept_connects(struct ServerMud *server_mud) + + server_mud->workers = worker; + +- if (pthread_create(tid, NULL, sermud_worker_create_and_run, server_mud->workers) < 0) { ++ if (pthread_create(tid, NULL, sermud_worker_create_and_run, server_mud) < 0) { + PRINT_ERROR("server can't create poisx thread %d! ", errno); + return PROGRAM_FAULT; + } +@@ -187,7 +190,7 @@ int32_t sermud_listener_accept_connects(struct ServerMud *server_mud) + } + + // the worker thread, unblock, dissymmetric server processes the events +-int32_t sermud_worker_proc_epevs(struct ServerMudWorker *worker_unit) ++int32_t sermud_worker_proc_epevs(struct ServerMudWorker *worker_unit, const char* domain) + { + int32_t epoll_nfds = epoll_wait(worker_unit->epfd, worker_unit->epevs, SERVER_EPOLL_SIZE_MAX, SERVER_EPOLL_WAIT_TIMEOUT); + if (epoll_nfds < 0) { +@@ -206,7 +209,7 @@ int32_t sermud_worker_proc_epevs(struct ServerMudWorker *worker_unit) + if (curr_epev->events == EPOLLIN) { + struct ServerHandler *server_handler = (struct ServerHandler *)curr_epev->data.ptr; + +- int32_t server_ans_ret = server_ans(server_handler, worker_unit->pktlen, worker_unit->api); ++ int32_t server_ans_ret = server_ans(server_handler, worker_unit->pktlen, worker_unit->api, domain); + if (server_ans_ret == PROGRAM_FAULT) { + struct epoll_event ep_ev; + if (epoll_ctl(worker_unit->epfd, EPOLL_CTL_DEL, server_handler->fd, &ep_ev) < 0) { +@@ -263,13 +266,14 @@ void *sermud_worker_create_and_run(void *arg) + { + pthread_detach(pthread_self()); + +- struct ServerMudWorker *worker_unit = (struct ServerMudWorker *)arg; ++ struct ServerMudWorker *worker_unit = ((struct ServerMud *)arg)->workers; ++ char* domain = ((struct ServerMud *)arg)->domain; + + if (sermud_worker_create_epfd_and_reg(worker_unit) < 0) { + exit(PROGRAM_FAULT); + } + while (true) { +- if (sermud_worker_proc_epevs(worker_unit) < 0) { ++ if (sermud_worker_proc_epevs(worker_unit, domain) < 0) { + exit(PROGRAM_FAULT); + } + } +@@ -428,6 +432,10 @@ int32_t sersum_accept_connects(struct ServerMumUnit *server_unit, struct ServerH + struct sockaddr_in accept_addr; + uint32_t sockaddr_in_len = sizeof(struct sockaddr_in); + int32_t accept_fd; ++ if (strcmp(server_unit->domain, "udp") == 0) { ++ break; ++ } ++ + if (strcmp(server_unit->accept, "ac4") == 0) { + accept_fd = accept4(server_unit->listener.fd, (struct sockaddr *)&accept_addr, &sockaddr_in_len, SOCK_CLOEXEC); + } else { +@@ -479,7 +487,7 @@ int32_t sersum_proc_epevs(struct ServerMumUnit *server_unit) + } + + if (curr_epev->events == EPOLLIN) { +- if (curr_epev->data.ptr == (void *)&(server_unit->listener)) { ++ if (curr_epev->data.ptr == (void *)&(server_unit->listener) && strcmp(server_unit->domain, "udp") != 0) { + int32_t sersum_accept_connects_ret = sersum_accept_connects(server_unit, &(server_unit->listener)); + if (sersum_accept_connects_ret < 0) { + PRINT_ERROR("server try accept error %d! ", sersum_accept_connects_ret); +@@ -490,12 +498,12 @@ int32_t sersum_proc_epevs(struct ServerMumUnit *server_unit) + struct ServerHandler *server_handler = (struct ServerHandler *)curr_epev->data.ptr; + struct sockaddr_in connect_addr; + socklen_t connect_addr_len = sizeof(connect_addr); +- if (getpeername(server_handler->fd, (struct sockaddr *)&connect_addr, &connect_addr_len) < 0) { ++ if (strcmp(server_unit->domain, "udp") != 0 && getpeername(server_handler->fd, (struct sockaddr *)&connect_addr, &connect_addr_len) < 0) { + PRINT_ERROR("server can't socket peername %d! ", errno); + return PROGRAM_FAULT; + } + +- int32_t server_ans_ret = server_ans(server_handler, server_unit->pktlen, server_unit->api); ++ int32_t server_ans_ret = server_ans(server_handler, server_unit->pktlen, server_unit->api, server_unit->domain); + if (server_ans_ret == PROGRAM_FAULT) { + --server_unit->curr_connect; + struct epoll_event ep_ev; +diff --git a/examples/src/utilities.c b/examples/src/utilities.c +index 877e611..0a65784 100644 +--- a/examples/src/utilities.c ++++ b/examples/src/utilities.c +@@ -17,18 +17,24 @@ + // create the socket and listen + int32_t create_socket_and_listen(int32_t *socket_fd, in_addr_t ip, uint16_t port, const char *domain) + { +- if (strcmp(domain, "posix") == 0) { ++ if (strcmp(domain, "tcp") == 0) { + *socket_fd = socket(AF_INET, SOCK_STREAM, 0); + if (*socket_fd < 0) { + PRINT_ERROR("can't create socket %d! ", errno); + return PROGRAM_FAULT; + } +- } else { ++ } else if (strcmp(domain, "unix") == 0) { + *socket_fd = socket(AF_UNIX, SOCK_STREAM, 0); + if (*socket_fd < 0) { + PRINT_ERROR("can't create socket %d! ", errno); + return PROGRAM_FAULT; + } ++ } else if (strcmp(domain, "udp") == 0) { ++ *socket_fd = socket(AF_INET, SOCK_DGRAM, 0); ++ if (*socket_fd < 0) { ++ PRINT_ERROR("can't create socket %d! ", errno); ++ return PROGRAM_FAULT; ++ } + } + + int32_t port_multi = 1; +@@ -42,7 +48,7 @@ int32_t create_socket_and_listen(int32_t *socket_fd, in_addr_t ip, uint16_t port + return PROGRAM_FAULT; + } + +- if (strcmp(domain, "posix") == 0) { ++ if (strcmp(domain, "tcp") == 0) { + struct sockaddr_in socket_addr; + memset_s(&socket_addr, sizeof(socket_addr), 0, sizeof(socket_addr)); + socket_addr.sin_family = AF_INET; +@@ -57,7 +63,7 @@ int32_t create_socket_and_listen(int32_t *socket_fd, in_addr_t ip, uint16_t port + PRINT_ERROR("server socket can't lisiten %d! ", errno); + return PROGRAM_FAULT; + } +- } else { ++ } else if (strcmp(domain, "unix") == 0) { + struct sockaddr_un socket_addr; + unlink(SOCKET_UNIX_DOMAIN_FILE); + socket_addr.sun_family = AF_UNIX; +@@ -71,16 +77,30 @@ int32_t create_socket_and_listen(int32_t *socket_fd, in_addr_t ip, uint16_t port + PRINT_ERROR("server socket can't lisiten %d! ", errno); + return PROGRAM_FAULT; + } ++ } else if (strcmp(domain, "udp") == 0) { ++ struct sockaddr_in socket_addr; ++ memset_s(&socket_addr, sizeof(socket_addr), 0, sizeof(socket_addr)); ++ socket_addr.sin_family = AF_INET; ++ socket_addr.sin_addr.s_addr = ip; ++ socket_addr.sin_port = port; ++ if (bind(*socket_fd, (struct sockaddr *)&socket_addr, sizeof(struct sockaddr_in)) < 0) { ++ PRINT_ERROR("can't bind the address to socket %d! ", errno); ++ return PROGRAM_FAULT; ++ } + } + + return PROGRAM_OK; + } + + // create the socket and connect +-int32_t create_socket_and_connect(int32_t *socket_fd, in_addr_t ip, uint16_t port, const char *domain) ++int32_t create_socket_and_connect(int32_t *socket_fd, in_addr_t ip, uint16_t port, uint16_t sport, const char *domain) + { +- if (strcmp(domain, "posix") == 0) { +- *socket_fd = socket(AF_INET, SOCK_STREAM, 0); ++ if (strcmp(domain, "tcp") == 0 || strcmp(domain, "udp") == 0) { ++ if (strcmp(domain, "tcp") == 0) { ++ *socket_fd = socket(AF_INET, SOCK_STREAM, 0); ++ } else { ++ *socket_fd = socket(AF_INET, SOCK_DGRAM, 0); ++ } + if (*socket_fd < 0) { + PRINT_ERROR("client can't create socket %d! ", errno); + return PROGRAM_FAULT; +@@ -94,6 +114,14 @@ int32_t create_socket_and_connect(int32_t *socket_fd, in_addr_t ip, uint16_t por + struct sockaddr_in server_addr; + memset_s(&server_addr, sizeof(server_addr), 0, sizeof(server_addr)); + server_addr.sin_family = AF_INET; ++ if (sport) { ++ server_addr.sin_addr.s_addr = htonl(INADDR_ANY); ++ server_addr.sin_port = sport; ++ if (bind(*socket_fd, (struct sockaddr *)&server_addr, sizeof(struct sockaddr_in)) < 0) { ++ PRINT_ERROR("can't bind the address to socket %d! ", errno); ++ return PROGRAM_FAULT; ++ } ++ } + server_addr.sin_addr.s_addr = ip; + server_addr.sin_port = port; + if (connect(*socket_fd, (struct sockaddr *)&server_addr, sizeof(struct sockaddr_in)) < 0) { +@@ -104,7 +132,7 @@ int32_t create_socket_and_connect(int32_t *socket_fd, in_addr_t ip, uint16_t por + return PROGRAM_FAULT; + } + } +- } else { ++ } else if (strcmp(domain, "unix") == 0) { + *socket_fd = socket(AF_UNIX, SOCK_STREAM, 0); + if (*socket_fd < 0) { + PRINT_ERROR("client can't create socket %d! ", errno); +@@ -123,6 +151,7 @@ int32_t create_socket_and_connect(int32_t *socket_fd, in_addr_t ip, uint16_t por + } + } + } ++ + return PROGRAM_OK; + } + +-- +2.23.0 + diff --git a/0240-fix-bond_ports-parse-error.patch b/0240-fix-bond_ports-parse-error.patch new file mode 100644 index 0000000..162536c --- /dev/null +++ b/0240-fix-bond_ports-parse-error.patch @@ -0,0 +1,446 @@ +From 2188bdbdfbe6ebe2bc091c87bfd9932747a7e9a4 Mon Sep 17 00:00:00 2001 +From: jiangheng12 +Date: Fri, 7 Apr 2023 14:28:53 +0800 +Subject: [PATCH] fix bond_ports parse error fix socket_mem parse error when + the value exceeds 65536 exit if create_rxtx_pktmbuf failed build.sh build + failed return 1 clean code + +--- + build/build.sh | 8 +++ + src/common/gazelle_opt.h | 2 - + src/common/gazelle_parse_config.c | 17 +++--- + src/lstack/api/lstack_wrap.c | 8 +-- + src/lstack/core/lstack_cfg.c | 3 +- + src/lstack/core/lstack_init.c | 3 +- + src/lstack/core/lstack_lwip.c | 6 +-- + src/lstack/core/lstack_protocol_stack.c | 20 ++++--- + src/lstack/netif/lstack_ethdev.c | 4 +- + src/ltran/ltran_dfx.c | 14 ++--- + src/ltran/ltran_param.c | 69 +++++++++++++------------ + 11 files changed, 86 insertions(+), 68 deletions(-) + +diff --git a/build/build.sh b/build/build.sh +index ab25d88..4464f8c 100755 +--- a/build/build.sh ++++ b/build/build.sh +@@ -14,6 +14,10 @@ cd $CURRENT_PATH + + make -C ../src/lstack clean + make -C ../src/lstack ++if [ $? -ne 0 ]; then ++ echo "build lstack failed" ++ exit 1 ++fi + + cd ../src/ltran + rm -f CMakeCache.txt +@@ -21,5 +25,9 @@ rm -f ltran gazellectl + rm -rf CMakeFiles + cmake . + make ++if [ $? -ne 0 ]; then ++ echo "build ltran failed" ++ exit 1 ++fi + + cd - +diff --git a/src/common/gazelle_opt.h b/src/common/gazelle_opt.h +index 4420ba4..fe0483b 100644 +--- a/src/common/gazelle_opt.h ++++ b/src/common/gazelle_opt.h +@@ -88,8 +88,6 @@ + #define GAZELLE_PRIMARY_START_PATH "/var/run/gazelle/gazelle_primary" + #define GAZELLE_FILE_PERMISSION 0700 + +-#define GAZELLE_MAX_PORTS_VALUE (UINT16_MAX - 1) +- + #define SEND_TIME_WAIT_NS 20000 + #define SECOND_NSECOND 1000000000 + +diff --git a/src/common/gazelle_parse_config.c b/src/common/gazelle_parse_config.c +index a2bdde1..ce6a3f8 100644 +--- a/src/common/gazelle_parse_config.c ++++ b/src/common/gazelle_parse_config.c +@@ -55,7 +55,12 @@ int32_t separate_str_to_array(char *args, uint32_t *array, int32_t array_size, i + return -1; + } + errno = 0; +- idx = strtol(args, &end, 10); /* 10: decimal */ ++ /* prefix 0x,0X indicate hexdecimal */ ++ if (strncmp(args, "0x", 2) == 0 || strncmp(args, "0X", 2) == 0) { ++ idx = strtol(args, &end, 16); /* 16: hexdecimal */ ++ } else { ++ idx = strtol(args, &end, 10); /* 10: decimal */ ++ } + if (errno || end == NULL) { + return -1; + } +@@ -107,18 +112,18 @@ int32_t check_and_set_run_dir(void) + int32_t filename_check(const char* args) + { + if (args == NULL) { +- return 1; ++ return 1; + } + + if (strlen(args) <= 0 || strlen(args) > GAZELLE_SOCK_FILENAME_MAXLEN - 1) { +- COMMON_ERR("socket_filename_check: invalid unix sock name %s, filename exceeds the limit %d.\n", args, GAZELLE_SOCK_FILENAME_MAXLEN); +- return 1; ++ COMMON_ERR("socket_filename_check: invalid unix sock name %s, filename exceeds the limit %d.\n", args, GAZELLE_SOCK_FILENAME_MAXLEN); ++ return 1; + } + + char* sensitive_chars = strpbrk(args, "|;&$><`\\!\n"); + if (sensitive_chars != NULL) { +- COMMON_ERR("socket_filename_check: invalid unix sock name %s, filename contains sensitive characters.\n", args); +- return 1; ++ COMMON_ERR("socket_filename_check: invalid unix sock name %s, filename contains sensitive characters.\n", args); ++ return 1; + } + + return 0; +diff --git a/src/lstack/api/lstack_wrap.c b/src/lstack/api/lstack_wrap.c +index 90b2252..1b12822 100644 +--- a/src/lstack/api/lstack_wrap.c ++++ b/src/lstack/api/lstack_wrap.c +@@ -205,7 +205,7 @@ static int get_addr(struct sockaddr_in *sin, char *interface) + } + posix_api->close_fn(sockfd); + +- memcpy(sin, &ifr.ifr_addr, sizeof(struct sockaddr_in)); ++ memcpy_s(sin, sizeof(struct sockaddr_in), &ifr.ifr_addr, sizeof(struct sockaddr_in)); + + return 0; + } +@@ -250,8 +250,8 @@ bool is_dst_ip_localhost(const struct sockaddr *addr) + ++p; + int n = strcspn(p, ": \t"); + +- char interface[20] = {0}; +- strncpy(interface, p, n); ++ char interface[20] = {0}; /* 20: nic name len */ ++ strncpy_s(interface, sizeof(interface), p, n); + + memset_s(sin, sizeof(struct sockaddr_in), 0, sizeof(struct sockaddr_in)); + int ret = get_addr(sin, interface); +@@ -289,7 +289,7 @@ static int32_t do_connect(int32_t s, const struct sockaddr *name, socklen_t name + int32_t ret = 0; + char listen_ring_name[RING_NAME_LEN]; + int remote_port = htons(((struct sockaddr_in *)name)->sin_port); +- snprintf_s(listen_ring_name, sizeof(listen_ring_name), sizeof(listen_ring_name) - 1, "listen_rx_ring_%u", remote_port); ++ snprintf_s(listen_ring_name, sizeof(listen_ring_name), sizeof(listen_ring_name) - 1, "listen_rx_ring_%d", remote_port); + if (is_dst_ip_localhost(name) && rte_ring_lookup(listen_ring_name) == NULL) { + ret = posix_api->connect_fn(s, name, namelen); + SET_CONN_TYPE_HOST(sock->conn); +diff --git a/src/lstack/core/lstack_cfg.c b/src/lstack/core/lstack_cfg.c +index 394cb13..cdb0200 100644 +--- a/src/lstack/core/lstack_cfg.c ++++ b/src/lstack/core/lstack_cfg.c +@@ -492,7 +492,8 @@ static int32_t gazelle_parse_socket_mem(const char *arg, struct secondary_attach + return -1; + } + +- int32_t count = separate_str_to_array(socket_mem, sec_attach_arg->socket_per_size, GAZELLE_MAX_NUMA_NODES, GAZELLE_MAX_PORTS_VALUE); ++ int32_t count = separate_str_to_array(socket_mem, sec_attach_arg->socket_per_size, ++ GAZELLE_MAX_NUMA_NODES, INT32_MAX); + + if (count < 0) { + return -1; +diff --git a/src/lstack/core/lstack_init.c b/src/lstack/core/lstack_init.c +index 76dd384..f17e4d2 100644 +--- a/src/lstack/core/lstack_init.c ++++ b/src/lstack/core/lstack_init.c +@@ -240,7 +240,8 @@ static void gazelle_signal_init(void) + lstack_signal_init(); + } + +-static void set_kni_ip_mac() { ++static void set_kni_ip_mac() ++{ + struct cfg_params *cfg = get_global_cfg_params(); + + int32_t fd = posix_api->socket_fn(AF_INET, SOCK_DGRAM, IPPROTO_IP); +diff --git a/src/lstack/core/lstack_lwip.c b/src/lstack/core/lstack_lwip.c +index ebdb469..0535428 100644 +--- a/src/lstack/core/lstack_lwip.c ++++ b/src/lstack/core/lstack_lwip.c +@@ -1392,7 +1392,7 @@ err_t netif_loop_output(struct netif *netif, struct pbuf *p) + return ERR_MEM; + } + head->ol_flags = p->ol_flags; +- memcpy(head->payload, p->payload, p->len); ++ memcpy_s(head->payload, head->len, p->payload, p->len); + + if ((flags & TCP_SYN) && !(flags & TCP_ACK)) { + /* SYN packet, send to listen_ring */ +@@ -1461,7 +1461,7 @@ err_t find_same_node_memzone(struct tcp_pcb *pcb, struct lwip_sock *nsock) + err_t same_node_memzone_create(const struct rte_memzone **zone, int size, int port, char *name, char *rx) + { + char mem_name[RING_NAME_LEN] = {0}; +- snprintf_s(mem_name, sizeof(mem_name), sizeof(mem_name) - 1, "%s_%s_%u", name, rx, port); ++ snprintf_s(mem_name, sizeof(mem_name), sizeof(mem_name) - 1, "%s_%s_%d", name, rx, port); + + *zone = rte_memzone_reserve_aligned(mem_name, size, rte_socket_id(), 0, RTE_CACHE_LINE_SIZE); + if (*zone == NULL) { +@@ -1484,7 +1484,7 @@ err_t same_node_ring_create(struct rte_ring **ring, int size, int port, char *na + flags = RING_F_SP_ENQ | RING_F_SC_DEQ; + } + +- snprintf_s(ring_name, sizeof(ring_name), sizeof(ring_name) - 1, "%s_%s_ring_%u", name, rx, port); ++ snprintf_s(ring_name, sizeof(ring_name), sizeof(ring_name) - 1, "%s_%s_ring_%d", name, rx, port); + *ring = rte_ring_create(ring_name, size, rte_socket_id(), flags); + if (*ring == NULL) { + LSTACK_LOG(ERR, LSTACK, "cannot create rte_ring %s, errno is %d\n", ring_name, rte_errno); +diff --git a/src/lstack/core/lstack_protocol_stack.c b/src/lstack/core/lstack_protocol_stack.c +index 061582f..7b1b994 100644 +--- a/src/lstack/core/lstack_protocol_stack.c ++++ b/src/lstack/core/lstack_protocol_stack.c +@@ -81,7 +81,8 @@ struct protocol_stack_group *get_protocol_stack_group(void) + return &g_stack_group; + } + +-int get_min_conn_stack(struct protocol_stack_group *stack_group){ ++int get_min_conn_stack(struct protocol_stack_group *stack_group) ++{ + int min_conn_stk_idx = 0; + int min_conn_num = GAZELLE_MAX_CLIENTS; + for (int i = 0; i < stack_group->stack_num; i++) { +@@ -91,7 +92,7 @@ int get_min_conn_stack(struct protocol_stack_group *stack_group){ + min_conn_stk_idx = i; + min_conn_num = stack->conn_num; + } +- }else { ++ } else { + if (stack->conn_num < min_conn_num) { + min_conn_stk_idx = i; + min_conn_num = stack->conn_num; +@@ -100,7 +101,6 @@ int get_min_conn_stack(struct protocol_stack_group *stack_group){ + + } + return min_conn_stk_idx; +- + } + + struct protocol_stack *get_protocol_stack(void) +@@ -230,14 +230,14 @@ static int32_t create_thread(void *arg, char *thread_name, stack_thread_func fun + return -1; + } + +- if (get_global_cfg_params()->seperate_send_recv){ ++ if (get_global_cfg_params()->seperate_send_recv) { + ret = sprintf_s(name, sizeof(name), "%s", thread_name); + if (ret < 0) { + LSTACK_LOG(ERR, LSTACK, "set name failed\n"); + return -1; + } + +- }else { ++ } else { + ret = sprintf_s(name, sizeof(name), "%s%02hu", thread_name, t_params->queue_id); + if (ret < 0) { + LSTACK_LOG(ERR, LSTACK, "set name failed\n"); +@@ -500,7 +500,8 @@ static void* gazelle_stack_thread(void *arg) + return NULL; + } + +-static void libnet_listen_thread(void *arg){ ++static void libnet_listen_thread(void *arg) ++{ + struct cfg_params * cfg_param = get_global_cfg_params(); + recv_pkts_from_other_process(cfg_param->process_idx, arg); + } +@@ -561,6 +562,9 @@ int32_t init_protocol_stack(void) + for (uint16_t idx = 0; idx < get_global_cfg_params()->tot_queue_num; idx++) { + struct rte_mempool* rxtx_mbuf = create_pktmbuf_mempool("rxtx_mbuf", + get_global_cfg_params()->mbuf_count_per_conn * get_global_cfg_params()->tcp_conn_count / stack_group->stack_num, RXTX_CACHE_SZ, idx); ++ if (rxtx_mbuf == NULL) { ++ return -1; ++ } + get_protocol_stack_group()->total_rxtx_pktmbuf_pool[idx] = rxtx_mbuf; + } + } +@@ -572,13 +576,13 @@ int32_t init_protocol_stack(void) + if (ret < 0) { + return -1; + } +- }else { ++ } else { + ret = sprintf_s(name, sizeof(name), "%s_%d_%d", LSTACK_SEND_THREAD_NAME, process_index, i/2); + if (ret < 0) { + return -1; + } + } +- }else { ++ } else { + ret = sprintf_s(name, sizeof(name), "%s", LSTACK_THREAD_NAME); + if (ret < 0) { + return -1; +diff --git a/src/lstack/netif/lstack_ethdev.c b/src/lstack/netif/lstack_ethdev.c +index 4103f22..0a91f79 100644 +--- a/src/lstack/netif/lstack_ethdev.c ++++ b/src/lstack/netif/lstack_ethdev.c +@@ -323,7 +323,7 @@ void config_flow_director(uint16_t queue_id, uint32_t src_ip, uint32_t dst_ip, u + + uint16_t port_id = get_port_id(); + char rule_key[RULE_KEY_LEN] = {0}; +- sprintf(rule_key,"%u_%u_%u",src_ip,src_port,dst_port); ++ sprintf_s(rule_key, sizeof(rule_key), "%u_%u_%u", src_ip, src_port, dst_port); + struct flow_rule *fl_exist = find_rule(rule_key); + if(fl_exist != NULL){ + return; +@@ -347,7 +347,7 @@ void delete_flow_director(uint32_t dst_ip, uint16_t src_port, uint16_t dst_port) + { + uint16_t port_id = get_port_id(); + char rule_key[RULE_KEY_LEN] = {0}; +- sprintf(rule_key,"%u_%u_%u",dst_ip,dst_port,src_port); ++ sprintf_s(rule_key, RULE_KEY_LEN, "%u_%u_%u",dst_ip, dst_port, src_port); + struct flow_rule *fl = find_rule(rule_key); + + if(fl != NULL){ +diff --git a/src/ltran/ltran_dfx.c b/src/ltran/ltran_dfx.c +index 761bbb7..3513125 100644 +--- a/src/ltran/ltran_dfx.c ++++ b/src/ltran/ltran_dfx.c +@@ -209,17 +209,17 @@ static int32_t dfx_connect_ltran(bool use_ltran, bool probe) + } + + ret = strncpy_s(addr.sun_path, sizeof(addr.sun_path), GAZELLE_RUN_DIR, +- strlen(GAZELLE_RUN_DIR) + 1); ++ strlen(GAZELLE_RUN_DIR) + 1); + if (ret != EOK) { +- printf("%s:%d strncpy_s fail ret=%d\n", __FUNCTION__, __LINE__, ret); ++ printf("%s:%d strncpy_s fail ret=%d\n", __FUNCTION__, __LINE__, ret); + } + + if (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); +- } ++ 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); ++ } + } + + addr.sun_family = AF_UNIX; +diff --git a/src/ltran/ltran_param.c b/src/ltran/ltran_param.c +index 7cf3423..1eb4f48 100644 +--- a/src/ltran/ltran_param.c ++++ b/src/ltran/ltran_param.c +@@ -339,7 +339,8 @@ static int32_t parse_bond_ports(const config_t *config, const char *key, struct + return GAZELLE_ERR; + } + +- ltran_config->bond.port_num = separate_str_to_array(port_str, ltran_config->bond.portmask, GAZELLE_MAX_BOND_NUM, GAZELLE_MAX_PORTS_VALUE); ++ ltran_config->bond.port_num = separate_str_to_array(port_str, ltran_config->bond.portmask, ++ GAZELLE_MAX_BOND_NUM, UINT16_MAX); + + if (ltran_config->bond.port_num > GAZELLE_MAX_BOND_NUM) { + free(port_str); +@@ -547,67 +548,67 @@ static int32_t parse_unix_prefix(const config_t *config, const char *key, struct + int32_t ret = 0; + + ret = memset_s(ltran_config->unix_socket_filename, sizeof(ltran_config->unix_socket_filename), +- 0, sizeof(ltran_config->unix_socket_filename)); ++ 0, sizeof(ltran_config->unix_socket_filename)); + if (ret != EOK) { +- gazelle_set_errno(GAZELLE_EINETATON); +- return GAZELLE_ERR; ++ gazelle_set_errno(GAZELLE_EINETATON); ++ return GAZELLE_ERR; + } + + ret = memset_s(ltran_config->dfx_socket_filename, sizeof(ltran_config->dfx_socket_filename), +- 0, sizeof(ltran_config->dfx_socket_filename)); ++ 0, sizeof(ltran_config->dfx_socket_filename)); + if (ret != EOK) { +- gazelle_set_errno(GAZELLE_EINETATON); +- return GAZELLE_ERR; ++ gazelle_set_errno(GAZELLE_EINETATON); ++ return GAZELLE_ERR; + } + + ret = strncpy_s(ltran_config->unix_socket_filename, sizeof(ltran_config->unix_socket_filename), +- GAZELLE_RUN_DIR, strlen(GAZELLE_RUN_DIR) + 1); ++ GAZELLE_RUN_DIR, strlen(GAZELLE_RUN_DIR) + 1); + if (ret != EOK) { +- gazelle_set_errno(GAZELLE_EINETATON); +- return GAZELLE_ERR; ++ gazelle_set_errno(GAZELLE_EINETATON); ++ return GAZELLE_ERR; + } + + ret = strncpy_s(ltran_config->dfx_socket_filename, sizeof(ltran_config->dfx_socket_filename), +- GAZELLE_RUN_DIR, strlen(GAZELLE_RUN_DIR) + 1); ++ GAZELLE_RUN_DIR, strlen(GAZELLE_RUN_DIR) + 1); + if (ret != EOK) { +- gazelle_set_errno(GAZELLE_EINETATON); +- return GAZELLE_ERR; ++ gazelle_set_errno(GAZELLE_EINETATON); ++ return GAZELLE_ERR; + } + + ret = config_lookup_string(config, key, &prefix); + if (ret) { + if (filename_check(prefix)) { +- gazelle_set_errno(GAZELLE_EINETATON); +- return GAZELLE_ERR; +- } ++ gazelle_set_errno(GAZELLE_EINETATON); ++ return GAZELLE_ERR; ++ } + +- ret = strncat_s(ltran_config->unix_socket_filename, sizeof(ltran_config->unix_socket_filename), +- prefix, strlen(prefix) + 1); +- if (ret != EOK) { +- gazelle_set_errno(GAZELLE_EINETATON); +- return GAZELLE_ERR; +- } ++ ret = strncat_s(ltran_config->unix_socket_filename, sizeof(ltran_config->unix_socket_filename), ++ prefix, strlen(prefix) + 1); ++ if (ret != EOK) { ++ gazelle_set_errno(GAZELLE_EINETATON); ++ return GAZELLE_ERR; ++ } + +- ret = strncat_s(ltran_config->dfx_socket_filename, sizeof(ltran_config->dfx_socket_filename), +- prefix, strlen(prefix) + 1); +- if (ret != EOK) { +- gazelle_set_errno(GAZELLE_EINETATON); +- return GAZELLE_ERR; +- } ++ ret = strncat_s(ltran_config->dfx_socket_filename, sizeof(ltran_config->dfx_socket_filename), ++ prefix, strlen(prefix) + 1); ++ if (ret != EOK) { ++ gazelle_set_errno(GAZELLE_EINETATON); ++ return GAZELLE_ERR; ++ } + } + + ret = strncat_s(ltran_config->unix_socket_filename, sizeof(ltran_config->unix_socket_filename), +- GAZELLE_REG_SOCK_FILENAME, strlen(GAZELLE_REG_SOCK_FILENAME) + 1); ++ GAZELLE_REG_SOCK_FILENAME, strlen(GAZELLE_REG_SOCK_FILENAME) + 1); + if (ret != EOK) { +- gazelle_set_errno(GAZELLE_EINETATON); +- return GAZELLE_ERR; ++ gazelle_set_errno(GAZELLE_EINETATON); ++ return GAZELLE_ERR; + } + + ret = strncat_s(ltran_config->dfx_socket_filename, sizeof(ltran_config->dfx_socket_filename), +- GAZELLE_DFX_SOCK_FILENAME, strlen(GAZELLE_DFX_SOCK_FILENAME) + 1); ++ GAZELLE_DFX_SOCK_FILENAME, strlen(GAZELLE_DFX_SOCK_FILENAME) + 1); + if (ret != EOK) { +- gazelle_set_errno(GAZELLE_EINETATON); +- return GAZELLE_ERR; ++ gazelle_set_errno(GAZELLE_EINETATON); ++ return GAZELLE_ERR; + } + + return GAZELLE_OK; +-- +2.23.0 + diff --git a/gazelle.spec b/gazelle.spec index 1a230aa..62c8f62 100644 --- a/gazelle.spec +++ b/gazelle.spec @@ -2,7 +2,7 @@ Name: gazelle Version: 1.0.1 -Release: 61 +Release: 62 Summary: gazelle is a high performance user-mode stack License: MulanPSL-2.0 URL: https://gitee.com/openeuler/gazelle @@ -249,6 +249,12 @@ Patch9231: 0231-fix-config-flow-rule-race.patch Patch9232: 0232-update-lstack.Makefile.patch Patch9233: 0233-fix-gazellectl-x-error-when-multiplt-user-nic-config.patch Patch9234: 0234-fix-client-connect-number-unbalance-on-lstack.patch +Patch9235: 0235-set-client-nonblock-to-fix-example-connect-error.patch +Patch9236: 0236-kni-down-not-stop-nic.patch +Patch9237: 0237-fix-rpc-msg-alloc-failed.patch +Patch9238: 0238-add-parentheses-to-fix-build-error.patch +Patch9239: 0239-add-udp-protocol-support-in-example.patch +Patch9240: 0240-fix-bond_ports-parse-error.patch %description %{name} is a high performance user-mode stack. @@ -289,6 +295,14 @@ install -Dpm 0640 %{_builddir}/%{name}-%{version}/src/ltran/ltran.conf %{b %config(noreplace) %{conf_path}/ltran.conf %changelog +* Mon Apr 10 2023 jiangheng12 - 1.0.1-62 +- fix bond_ports parse error fix socket_mem parse error when the value exceeds 65536 exit if create_rxtx_pktmbuf failed build.sh build failed return 1 clean code +- add udp protocol support in example +- add parentheses to fix build error +- fix rpc msg alloc failed fix process_numa args error coredump fix sock->conn not free when fd is kernel mode +- kni down not stop nic +- set client nonblock to fix example connect error + * Fri Mar 31 2023 jiangheng12 - 1.0.1-61 - fix gazellectl -x error when multiplt user nic config - update lstack.Makefile