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

sync init: stack setup in app thread when app call socket/epoll_create first in rtc mode

Browse Source 
(cherry picked from commit 9e767dcd8b03ad4be93593b474bbc7153c2923b3)
This commit is contained in:
jiangheng 2023-11-04 11:26:49 +08:00 committed by openeuler-sync-bot
parent 0dc69d6ab4
commit 1bce5672e8
7 changed files with 1561 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

136
0020-statck-the-for-loop-in-lstack-thread-is-defined-as-s.patch Normal file
View File

@ -0,0 +1,136 @@
From 71defaec9e10ee23bf9b3e01989dac4feab94d82 Mon Sep 17 00:00:00 2001
From: jiangheng <jiangheng14@huawei.com>
Date: Mon, 9 Oct 2023 10:28:30 +0800
Subject: [PATCH] statck: the for loop in lstack thread is defined as
stack_polling
---
src/lstack/core/lstack_protocol_stack.c | 85 ++++++++++++----------
src/lstack/include/lstack_protocol_stack.h | 1 +
2 files changed, 49 insertions(+), 37 deletions(-)
diff --git a/src/lstack/core/lstack_protocol_stack.c b/src/lstack/core/lstack_protocol_stack.c
index 09cba14..ea85bc1 100644
--- a/src/lstack/core/lstack_protocol_stack.c
+++ b/src/lstack/core/lstack_protocol_stack.c
@@ -432,18 +432,60 @@ END:
return NULL;
}
-static void* gazelle_stack_thread(void *arg)
+void stack_polling(uint32_t wakeup_tick)
{
- struct thread_params *t_params = (struct thread_params*) arg;
-
- uint16_t queue_id = t_params->queue_id;
struct cfg_params *cfg = get_global_cfg_params();
uint8_t use_ltran_flag = cfg->use_ltran;
bool kni_switch = cfg->kni_switch;
bool use_sockmap = cfg->use_sockmap;
- uint32_t read_connect_number = cfg->read_connect_number;
+ bool stack_mode_rtc = cfg->stack_mode_rtc;
uint32_t rpc_number = cfg->rpc_number;
uint32_t nic_read_number = cfg->nic_read_number;
+ uint32_t read_connect_number = cfg->read_connect_number;
+ struct protocol_stack *stack = get_protocol_stack();
+
+ poll_rpc_msg(stack, rpc_number);
+ gazelle_eth_dev_poll(stack, use_ltran_flag, nic_read_number);
+ sys_timer_run();
+ if (cfg->low_power_mod != 0) {
+ low_power_idling(stack);
+ }
+
+ if (stack_mode_rtc) {
+ return;
+ }
+
+ do_lwip_read_recvlist(stack, read_connect_number);
+ if ((wakeup_tick & 0xf) == 0) {
+ wakeup_stack_epoll(stack);
+ }
+
+ /* run to completion mode currently does not support sockmap */
+ if (use_sockmap) {
+ netif_poll(&stack->netif);
+ /* reduce traversal times */
+ if ((wakeup_tick & 0xff) == 0) {
+ read_same_node_recv_list(stack);
+ }
+ }
+
+ /* run to completion mode currently does not support kni */
+ /* KNI requests are generally low-rate I/Os,
+ * so processing KNI requests only in the thread with queue_id No.0 is sufficient. */
+ if (kni_switch && !stack->queue_id && !(wakeup_tick & 0xfff)) {
+ rte_kni_handle_request(get_gazelle_kni());
+ if (get_kni_started()) {
+ kni_handle_rx(get_port_id());
+ }
+ }
+ return;
+}
+
+static void* gazelle_stack_thread(void *arg)
+{
+ struct thread_params *t_params = (struct thread_params*) arg;
+
+ uint16_t queue_id = t_params->queue_id;
uint32_t wakeup_tick = 0;
struct protocol_stack *stack = stack_thread_init(arg);
@@ -461,39 +503,8 @@ static void* gazelle_stack_thread(void *arg)
LSTACK_LOG(INFO, LSTACK, "stack_%02hu init success\n", queue_id);
for (;;) {
- poll_rpc_msg(stack, rpc_number);
-
- gazelle_eth_dev_poll(stack, use_ltran_flag, nic_read_number);
-
- if (use_sockmap) {
- netif_poll(&stack->netif);
- /* reduce traversal times */
- if ((wakeup_tick & 0xff) == 0) {
- read_same_node_recv_list(stack);
- }
- }
- do_lwip_read_recvlist(stack, read_connect_number);
-
- if ((wakeup_tick & 0xf) == 0) {
- wakeup_stack_epoll(stack);
- }
-
- /* KNI requests are generally low-rate I/Os,
- * 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());
- if (get_kni_started()) {
- kni_handle_rx(get_port_id());
- }
- }
-
+ stack_polling(wakeup_tick);
wakeup_tick++;
-
- sys_timer_run();
-
- if (cfg->low_power_mod != 0) {
- low_power_idling(stack);
- }
}
return NULL;
diff --git a/src/lstack/include/lstack_protocol_stack.h b/src/lstack/include/lstack_protocol_stack.h
index a4f6ac2..7cb37bf 100644
--- a/src/lstack/include/lstack_protocol_stack.h
+++ b/src/lstack/include/lstack_protocol_stack.h
@@ -167,5 +167,6 @@ void stack_replenish_sendring(struct rpc_msg *msg);
void stack_get_conntable(struct rpc_msg *msg);
void stack_get_connnum(struct rpc_msg *msg);
void stack_recvlist_count(struct rpc_msg *msg);
+void stack_polling(uint32_t wakeup_tick);
void kni_handle_tx(struct rte_mbuf *mbuf);
#endif
--
2.27.0

25
0021-delete_rule-bug.patch Normal file
View File

@ -0,0 +1,25 @@
From 09c2b39b22397272668e49060e5f3e3b50fd40b4 Mon Sep 17 00:00:00 2001
From: zhengjiebing <zhengjiebing_yewu@cmss.chinamobile.com>
Date: Fri, 20 Oct 2023 09:52:11 +0800
Subject: [PATCH] delete_rule bug
---
src/lstack/netif/lstack_ethdev.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/lstack/netif/lstack_ethdev.c b/src/lstack/netif/lstack_ethdev.c
index 30c3c9a..6e4c9de 100644
--- a/src/lstack/netif/lstack_ethdev.c
+++ b/src/lstack/netif/lstack_ethdev.c
@@ -189,7 +189,7 @@ void delete_rule(char* rule_key)
{
struct flow_rule *rule = NULL;
HASH_FIND_STR(g_flow_rules, rule_key, rule);
- if (rule == NULL) {
+ if (rule != NULL) {
HASH_DEL(g_flow_rules, rule);
free(rule);
}
--
2.27.0

198
0022-tools-gazelle_setup-adapt-non-ltran-mode.patch Normal file
View File

@ -0,0 +1,198 @@
From 1ebdb7124823835cd29d62c8a81a0b8010c1d754 Mon Sep 17 00:00:00 2001
From: jiangheng <jiangheng14@huawei.com>
Date: Fri, 20 Oct 2023 19:44:52 +0800
Subject: [PATCH] tools: gazelle_setup adapt non ltran mode
---
tools/gazelle_common.sh | 40 ++++++++++++++++++++--------------------
tools/gazelle_setup.sh | 38 ++++++++++++++++++--------------------
2 files changed, 38 insertions(+), 40 deletions(-)
diff --git a/tools/gazelle_common.sh b/tools/gazelle_common.sh
index b4c011a..fac0d68 100644
--- a/tools/gazelle_common.sh
+++ b/tools/gazelle_common.sh
@@ -231,18 +231,18 @@ install_nic_mod() {
}
create_mnt_huge() {
- msg_show "Creating /mnt/hugepages and mounting as hugetlbfs"
- sudo mkdir -p /mnt/hugepages
- sudo mkdir -p /mnt/hugepages-2M
+ msg_show "Creating /mnt/hugepages-ltran and mounting as hugetlbfs"
+ sudo mkdir -p /mnt/hugepages-ltran
+ sudo mkdir -p /mnt/hugepages-lstack
- grep -s "/mnt/hugepages " /proc/mounts > /dev/null
+ grep -s "/mnt/hugepages-ltran " /proc/mounts > /dev/null
if [ $? -ne 0 ]; then
- sudo mount -t hugetlbfs nodev /mnt/hugepages
+ sudo mount -t hugetlbfs nodev /mnt/hugepages-ltran
fi
- grep -s "/mnt/hugepages-2M " /proc/mounts > /dev/null
+ grep -s "/mnt/hugepages-lstack " /proc/mounts > /dev/null
if [ $? -ne 0 ]; then
- sudo mount -t hugetlbfs nodev /mnt/hugepages-2M
+ sudo mount -t hugetlbfs nodev /mnt/hugepages-lstack
fi
}
@@ -285,21 +285,21 @@ set_numa_pages() {
# Removes all reserved hugepages.
clear_huge_pages() {
- msg_show "Unmounting /mnt/hugepages and removing directory"
- grep -s "/mnt/hugepages " /proc/mounts > /dev/null
+ msg_show "Unmounting /mnt/hugepages-ltran and removing directory"
+ grep -s "/mnt/hugepages-ltran " /proc/mounts > /dev/null
if [ $? -eq 0 ]; then
- sudo umount /mnt/hugepages
+ sudo umount /mnt/hugepages-ltran
if [ $? -ne 0 ]; then
- msg_err "sudo umount /mnt/hugepages failed!"
+ msg_err "sudo umount /mnt/hugepages-ltran failed!"
return 1
fi
fi
- grep -s "/mnt/hugepages-2M " /proc/mounts > /dev/null
+ grep -s "/mnt/hugepages-lstack " /proc/mounts > /dev/null
if [ $? -eq 0 ]; then
- sudo umount /mnt/hugepages-2M
+ sudo umount /mnt/hugepages-lstack
if [ $? -ne 0 ]; then
- msg_err "sudo umount /mnt/hugepages-2M failed!"
+ msg_err "sudo umount /mnt/hugepages-lstack failed!"
return 1
fi
fi
@@ -312,17 +312,17 @@ clear_huge_pages() {
sudo sh .echo_tmp
rm -f .echo_tmp
- if [ -d /mnt/hugepages ]; then
- sudo rm -R /mnt/hugepages
+ if [ -d /mnt/hugepages-ltran ]; then
+ sudo rm -R /mnt/hugepages-ltran
if [ $? -ne 0 ]; then
- msg_err "sudo rm -R /mnt/hugepages failed!"
+ msg_err "sudo rm -R /mnt/hugepages-ltran failed!"
return 1
fi
fi
- if [ -d /mnt/hugepages-2M ]; then
- sudo rm -R /mnt/hugepages-2M
+ if [ -d /mnt/hugepages-lstack ]; then
+ sudo rm -R /mnt/hugepages-lstack
if [ $? -ne 0 ]; then
- msg_err "sudo rm -R /mnt/hugepages failed!"
+ msg_err "sudo rm -R /mnt/hugepages-lstack failed!"
return 1
fi
fi
diff --git a/tools/gazelle_setup.sh b/tools/gazelle_setup.sh
index 014d333..c3ad830 100644
--- a/tools/gazelle_setup.sh
+++ b/tools/gazelle_setup.sh
@@ -66,8 +66,10 @@ show_usage() {
echo " [-l|--lowpower=<low power mode>]"
echo " [--ltrancore=<ltran core>]"
echo " [--lstackcore=<ltran core>]"
+ echo " [--useltran=<use ltran>]"
+ echo " [--listenshadow=<listen shadow>]"
echo "examples:"
- echo " $0 -i eth0 -n 1024,1024 -d 1/0 -k 1/0 -l 1/0 --ltrancore 0,1 --lstackcore 2-3"
+ echo " $0 -i eth0 -n 1024,1024 -d 1/0 -k 1/0 -l 1/0 --ltrancore 0,1 --lstackcore 2-3 --useltran 0/1 --listenshadow 0/1"
}
check_init() {
@@ -155,14 +157,13 @@ check_args() {
g_low_power=${g_low_power:-0}
check_switch_param $g_low_power
ret=$(($? + ret))
- g_useltran=${g_useltran:-1}
+ g_useltran=${g_useltran:-0}
check_switch_param $g_useltran
- g_listen_shadow=${g_listen_shadow:-0}
+ g_listen_shadow=${g_listen_shadow:-1}
check_switch_param $g_listen_shadow
ret=$(($? + ret))
g_ltrancore=${g_ltrancore:-0,1}
g_lstackcore=${g_lstackcore:-2}
- g_wakeupcpus=${g_lstackcore}
if [ $ret -eq 0 ]; then
msg_show "the args is reasonable..."
else
@@ -278,6 +279,12 @@ gen_lstack_conf() {
sed -i "/^gateway_addr/c gateway_addr=\"$g_gateway\"" $CONF_DIR/lstack.conf
sed -i "/^devices/c devices=\"$g_kni_mac\"" $CONF_DIR/lstack.conf
+ if [ ${g_useltran} -eq 0 ]; then
+ sed -i "/^kni_switch/c kni_switch = $g_kni_switch" $CONF_DIR/lstack.conf
+ else
+ sed -i "/^kni_switch/c kni_switch = 0" $CONF_DIR/lstack.conf
+ fi
+
shadow_exist=$(grep listen_shadow $CONF_DIR/lstack.conf)
if [ -n "${shadow_exist}" ];then
sed -i "/^listen_shadow/c listen_shadow = $g_listen_shadow" $CONF_DIR/lstack.conf
@@ -289,20 +296,15 @@ gen_lstack_conf() {
local old_lstackcore=$(grep num_cpus $CONF_DIR/lstack.conf | awk -F= '{print $2}' | awk -F "\"" '{print $2}')
sed -i "/^num_cpus/s/${old_lstackcore}/${g_lstackcore}/" $CONF_DIR/lstack.conf
- # wakeup_cpus
- local old_wakeupcpus=$(grep wakeup_cpus $CONF_DIR/lstack.conf | awk -F= '{print $2}' | awk -F "\"" '{print $2}')
- if [ -n "${g_wakeupcpus}" ]; then
- sed -i "/^wakeup_cpus/s/${old_wakeupcpus}/${g_wakeupcpus}/" $CONF_DIR/lstack.conf
- fi
-
local old_numa=$(grep dpdk_args $CONF_DIR/lstack.conf | awk -F "-socket-mem" '{print $2}' | awk '{print $2}' | awk -F "\"" '{print $2}')
old_numa="\"${old_numa}\","
sed -i "/^dpdk_args/s/${old_numa}/\"${g_hugepages}\",/" $CONF_DIR/lstack.conf
local cpu_count=$(parse_cpu_count ${g_lstackcore})
- local mbuf_pool_size=$(expr 200000 \* ${cpu_count} + 8192)
- sed -i "/^mbuf_pool_size/c mbuf_pool_size=${mbuf_pool_size}" $CONF_DIR/lstack.conf
+ tcp_conn_count=1500
+ mbuf_count_per_conn=$(expr 170 \* ${cpu_count})
- # export LSTACK_CONF_PATH=$CONF_DIR/lstack.conf
+ sed -i "/^tcp_conn_count/c tcp_conn_count=${tcp_conn_count}" $CONF_DIR/lstack.conf
+ sed -i "/^mbuf_count_per_conn/c mbuf_count_per_conn=${mbuf_count_per_conn}" $CONF_DIR/lstack.conf
}
gen_run_param() {
@@ -399,10 +401,6 @@ while true; do
g_lstackcore=$2
shift 2
;;
- --wakeupcpus)
- g_wakeupcpus=$2
- shift 2
- ;;
-h | --help)
show_usage
shift 1
@@ -458,8 +456,8 @@ gen_run_param
msg_show "-----------------"
msg_show "start dpdk"
setup_dpdk
-__chown /mnt/hugepages
-__chown /mnt/hugepages-2M
+__chown /mnt/hugepages-ltran
+__chown /mnt/hugepages-lstack
##############################################
# generate the conf file
@@ -504,7 +502,7 @@ fi
##############################################
# start ltran
if [ $g_useltran -eq 0 ];then
- msg_show "only gen lstack conf"
+ msg_show "gen lstack conf success"
exit 0
fi
msg_show "start ltran on $g_conn_if"
--
2.27.0

993
0023-wrap-add-run-to-completion-wakeup-mode-api.patch Normal file
View File

@ -0,0 +1,993 @@
From 476b225bc50737678223fa29757b0ac08f1a500d Mon Sep 17 00:00:00 2001
From: jiangheng <jiangheng14@huawei.com>
Date: Sun, 8 Oct 2023 20:59:57 +0800
Subject: [PATCH] wrap: add run-to-completion/wakeup mode api
---
src/lstack/api/dir.mk | 2 +-
src/lstack/api/lstack_rtc_api.c | 72 ++++++
src/lstack/api/lstack_rtw_api.c | 239 ++++++++++++++++++
src/lstack/api/lstack_wrap.c | 206 +++++++--------
src/lstack/core/lstack_init.c | 3 +
src/lstack/core/lstack_lwip.c | 2 +-
src/lstack/include/lstack_lwip.h | 2 +-
.../lstack_socket.h => lstack_rtc_api.h} | 59 +++--
src/lstack/include/lstack_rtw_api.h | 47 ++++
src/lstack/include/lstack_wrap.h | 19 ++
10 files changed, 514 insertions(+), 137 deletions(-)
create mode 100644 src/lstack/api/lstack_rtc_api.c
create mode 100644 src/lstack/api/lstack_rtw_api.c
rename src/lstack/include/{posix/lstack_socket.h => lstack_rtc_api.h} (53%)
create mode 100644 src/lstack/include/lstack_rtw_api.h
create mode 100644 src/lstack/include/lstack_wrap.h
diff --git a/src/lstack/api/dir.mk b/src/lstack/api/dir.mk
index f5370a2..ffbb137 100644
--- a/src/lstack/api/dir.mk
+++ b/src/lstack/api/dir.mk
@@ -8,7 +8,7 @@
# PURPOSE.
# See the Mulan PSL v2 for more details.
-SRC = lstack_epoll.c lstack_signal.c lstack_fork.c lstack_wrap.c
+SRC = lstack_epoll.c lstack_signal.c lstack_fork.c lstack_wrap.c lstack_rtw_api.c lstack_rtc_api.c
$(eval $(call register_dir, api, $(SRC)))
diff --git a/src/lstack/api/lstack_rtc_api.c b/src/lstack/api/lstack_rtc_api.c
new file mode 100644
index 0000000..b7c6380
--- /dev/null
+++ b/src/lstack/api/lstack_rtc_api.c
@@ -0,0 +1,72 @@
+/*
+* 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 <fcntl.h>
+#include <sys/epoll.h>
+#include <sys/socket.h>
+#include <unistd.h>
+#include <lwip/posix_api.h>
+#include <lwip/lwipsock.h>
+#include "posix/lstack_epoll.h"
+#include "lstack_log.h"
+#include "lstack_cfg.h"
+#include "lstack_protocol_stack.h"
+#include "lstack_rtc_api.h"
+
+int rtc_poll(struct pollfd *fds, nfds_t nfds, int timeout)
+{
+ return -1;
+}
+
+int rtc_epoll_wait(int epfd, struct epoll_event* events, int maxevents, int timeout)
+{
+ return -1;
+}
+
+int rtc_socket(int domain, int type, int protocol)
+{
+ int ret;
+
+ /* need call stack thread init function */
+ ret = lwip_socket(domain, type, protocol);
+ struct lwip_sock *sock = get_socket(ret);
+ if (sock != NULL) {
+ sock->stack = get_protocol_stack();
+ sock->epoll_events = 0;
+ sock->events = 0;
+ sock->wakeup = NULL;
+ init_list_node_null(&sock->event_list);
+ }
+ return ret;
+}
+
+int rtc_close(int s)
+{
+ return lwip_close(s);
+}
+
+int rtc_epoll_create(int flags)
+{
+ /* need call stack thread init function */
+ return lstack_epoll_create(flags);
+}
+
+int rtc_epoll_create1(int flags)
+{
+ /* need call stack thread init function */
+ return lstack_epoll_create1(flags);
+}
+
+int rtc_epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)
+{
+ return lstack_epoll_ctl(epfd, op, fd, event);
+}
diff --git a/src/lstack/api/lstack_rtw_api.c b/src/lstack/api/lstack_rtw_api.c
new file mode 100644
index 0000000..9b8678a
--- /dev/null
+++ b/src/lstack/api/lstack_rtw_api.c
@@ -0,0 +1,239 @@
+/*
+* 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 <fcntl.h>
+#include <sys/epoll.h>
+#include <sys/socket.h>
+#include <unistd.h>
+
+#include <lwip/lwipsock.h>
+
+#include "lstack_thread_rpc.h"
+#include "posix/lstack_epoll.h"
+#include "lstack_protocol_stack.h"
+#include "lstack_cfg.h"
+#include "lstack_lwip.h"
+#include "lstack_rtw_api.h"
+
+int rtw_socket(int domain, int type, int protocol)
+{
+ return rpc_call_socket(domain, type, protocol);
+}
+
+int rtw_accept(int s, struct sockaddr *addr, socklen_t *addrlen)
+{
+ return stack_broadcast_accept(s, addr, addrlen);
+}
+
+int rtw_accept4(int s, struct sockaddr *addr, socklen_t *addrlen, int flags)
+{
+ return stack_broadcast_accept4(s, addr, addrlen, flags);
+}
+
+int rtw_bind(int s, const struct sockaddr *name, socklen_t namelen)
+{
+ struct lwip_sock *sock = get_socket_by_fd(s);
+
+ if (NETCONN_IS_UDP(sock) && get_global_cfg_params()->listen_shadow) {
+ return stack_broadcast_bind(s, name, namelen);
+ } else {
+ return stack_single_bind(s, name, namelen);
+ }
+}
+
+int rtw_listen(int s, int backlog)
+{
+ if (!get_global_cfg_params()->tuple_filter &&
+ !get_global_cfg_params()->listen_shadow) {
+ return stack_single_listen(s, backlog);
+ } else {
+ return stack_broadcast_listen(s, backlog);
+ }
+}
+
+int rtw_connect(int s, const struct sockaddr *name, socklen_t namelen)
+{
+ return rpc_call_connect(s, name, namelen);
+}
+
+int rtw_setsockopt(int s, int level, int optname, const void *optval, socklen_t optlen)
+{
+ return rpc_call_setsockopt(s, level, optname, optval, optlen);
+}
+
+int rtw_getsockopt(int s, int level, int optname, void *optval, socklen_t *optlen)
+{
+ return rpc_call_getsockopt(s, level, optname, optval, optlen);
+}
+
+int rtw_getpeername(int s, struct sockaddr *name, socklen_t *namelen)
+{
+ return rpc_call_getpeername(s, name, namelen);
+}
+
+int rtw_getsockname(int s, struct sockaddr *name, socklen_t *namelen)
+{
+ return rpc_call_getsockname(s, name, namelen);
+}
+
+ssize_t rtw_read(int s, void *mem, size_t len)
+{
+ return do_lwip_read_from_stack(s, mem, len, 0, NULL, NULL);
+}
+
+ssize_t rtw_readv(int s, const struct iovec *iov, int iovcnt)
+{
+ struct msghdr msg;
+
+ msg.msg_name = NULL;
+ msg.msg_namelen = 0;
+ msg.msg_iov = LWIP_CONST_CAST(struct iovec *, iov);
+ msg.msg_iovlen = 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;
+}
+
+ssize_t rtw_write(int s, const void *mem, size_t size)
+{
+ return do_lwip_send_to_stack(s, mem, size, 0, NULL, 0);
+}
+
+ssize_t rtw_writev(int s, const struct iovec *iov, int iovcnt)
+{
+ struct lwip_sock *sock = get_socket_by_fd(s);
+ struct msghdr msg;
+
+ msg.msg_name = NULL;
+ msg.msg_namelen = 0;
+ msg.msg_iov = LWIP_CONST_CAST(struct iovec *, iov);
+ msg.msg_iovlen = iovcnt;
+ msg.msg_control = NULL;
+ msg.msg_controllen = 0;
+ msg.msg_flags = 0;
+ return do_lwip_sendmsg_to_stack(sock, s, &msg, 0);
+}
+
+ssize_t rtw_recv(int sockfd, void *buf, size_t len, int flags)
+{
+ return do_lwip_read_from_stack(sockfd, buf, len, flags, NULL, NULL);
+}
+
+ssize_t rtw_send(int sockfd, const void *buf, size_t len, int flags)
+{
+ return do_lwip_send_to_stack(sockfd, buf, len, flags, NULL, 0);
+}
+
+ssize_t rtw_recvmsg(int s, const struct msghdr *message, int flags)
+{
+ return do_lwip_recvmsg_from_stack(s, message, flags);
+}
+
+ssize_t rtw_sendmsg(int s, const struct msghdr *message, int flags)
+{
+ struct lwip_sock *sock = get_socket_by_fd(s);
+ return do_lwip_sendmsg_to_stack(sock, s, message, flags);
+}
+
+static ssize_t rtw_udp_recvfrom(int sockfd, void *buf, size_t len, int flags,
+ struct sockaddr *addr, socklen_t *addrlen)
+{
+ struct lwip_sock *sock = get_socket_by_fd(sockfd);
+ int ret;
+
+ while (1) {
+ ret = do_lwip_read_from_stack(sockfd, buf, len, flags, addr, addrlen);
+ if (ret > 0) {
+ return ret;
+ }
+ if (ret <= 0 && errno != EAGAIN) {
+ return -1;
+ }
+ sock = sock->listen_next;
+ if (sock != NULL && sock->conn != NULL) {
+ sockfd = sock->conn->socket;
+ } else {
+ if (sock == NULL) {
+ errno = EAGAIN;
+ return -1;
+ } else {
+ errno = ENOTCONN;
+ return -1;
+ }
+ }
+ }
+}
+
+static inline ssize_t rtw_tcp_recvfrom(int sockfd, void *buf, size_t len, int flags,
+ struct sockaddr *addr, socklen_t *addrlen)
+{
+ return do_lwip_read_from_stack(sockfd, buf, len, flags, addr, addrlen);
+}
+
+
+ssize_t rtw_recvfrom(int sockfd, void *buf, size_t len, int flags,
+ struct sockaddr *addr, socklen_t *addrlen)
+{
+ struct lwip_sock *sock = get_socket_by_fd(sockfd);
+ if (NETCONN_IS_UDP(sock)) {
+ return rtw_udp_recvfrom(sockfd, buf, len, flags, addr, addrlen);
+ } else {
+ return rtw_tcp_recvfrom(sockfd, buf, len, flags, addr, addrlen);
+ }
+}
+
+ssize_t rtw_sendto(int sockfd, const void *buf, size_t len, int flags,
+ const struct sockaddr *addr, socklen_t addrlen)
+{
+ return do_lwip_send_to_stack(sockfd, buf, len, flags, addr, addrlen);
+}
+
+
+int rtw_epoll_wait(int epfd, struct epoll_event* events, int maxevents, int timeout)
+{
+ return lstack_epoll_wait(epfd, events, maxevents, timeout);
+}
+
+int rtw_poll(struct pollfd *fds, nfds_t nfds, int timeout)
+{
+ return lstack_poll(fds, nfds, timeout);
+}
+
+int rtw_close(int s)
+{
+ struct lwip_sock *sock = get_socket(s);
+ if (sock && sock->wakeup && sock->wakeup->epollfd == s) {
+ return lstack_epoll_close(s);
+ }
+ return stack_broadcast_close(s);
+}
+
+int rtw_epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)
+{
+ return lstack_epoll_ctl(epfd, op, fd, event);
+}
+
+int rtw_epoll_create1(int flags)
+{
+ return lstack_epoll_create1(flags);
+}
+
+int rtw_epoll_create(int flags)
+{
+ return lstack_epoll_create(flags);
+}
diff --git a/src/lstack/api/lstack_wrap.c b/src/lstack/api/lstack_wrap.c
index ab39a68..a808ee8 100644
--- a/src/lstack/api/lstack_wrap.c
+++ b/src/lstack/api/lstack_wrap.c
@@ -12,17 +12,12 @@
#define _GNU_SOURCE
#include <dlfcn.h>
-#include <string.h>
#include <signal.h>
-#include <sys/socket.h>
#include <fcntl.h>
-#include <sys/socket.h>
-#include <stdarg.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <sys/epoll.h>
-#include <unistd.h>
#include <net/if.h>
#include <securec.h>
@@ -30,29 +25,94 @@
#include <lwip/lwipsock.h>
#include <lwip/tcp.h>
-#include "posix/lstack_epoll.h"
#include "posix/lstack_unistd.h"
-#include "posix/lstack_socket.h"
#include "lstack_log.h"
#include "lstack_cfg.h"
#include "lstack_lwip.h"
-#include "lstack_protocol_stack.h"
#include "gazelle_base_func.h"
-#include "lstack_thread_rpc.h"
-
#include "lstack_preload.h"
+#include "lstack_rtc_api.h"
+#include "lstack_rtw_api.h"
+
#ifndef SOCK_TYPE_MASK
#define SOCK_TYPE_MASK 0xf
#endif
+posix_api_t g_wrap_api_value;
+posix_api_t *g_wrap_api;
+
+void wrap_api_init(void)
+{
+ if (g_wrap_api != NULL) {
+ return;
+ }
+
+ g_wrap_api = &g_wrap_api_value;
+ if (get_global_cfg_params()->stack_mode_rtc) {
+ g_wrap_api->socket_fn = rtc_socket;
+ g_wrap_api->accept_fn = lwip_accept;
+ g_wrap_api->accept4_fn = lwip_accept4;
+ g_wrap_api->bind_fn = lwip_bind;
+ g_wrap_api->listen_fn = lwip_listen;
+ g_wrap_api->connect_fn = lwip_connect;
+ g_wrap_api->setsockopt_fn = lwip_setsockopt;
+ g_wrap_api->getsockopt_fn = lwip_getsockopt;
+ g_wrap_api->getpeername_fn = lwip_getpeername;
+ g_wrap_api->getsockname_fn = lwip_getsockname;
+ g_wrap_api->read_fn = lwip_read;
+ g_wrap_api->readv_fn = lwip_readv;
+ g_wrap_api->write_fn = lwip_write;
+ g_wrap_api->writev_fn = lwip_writev;
+ g_wrap_api->recv_fn = lwip_recv;
+ g_wrap_api->send_fn = lwip_send;
+ g_wrap_api->recv_msg = lwip_recvmsg;
+ g_wrap_api->send_msg = lwip_sendmsg;
+ g_wrap_api->recv_from = lwip_recvfrom;
+ g_wrap_api->send_to = lwip_sendto;
+ g_wrap_api->epoll_wait_fn = rtc_epoll_wait;
+ g_wrap_api->poll_fn = rtc_poll;
+ g_wrap_api->close_fn = rtc_close;
+ g_wrap_api->epoll_ctl_fn = rtc_epoll_ctl;
+ g_wrap_api->epoll_create1_fn = rtc_epoll_create1;
+ g_wrap_api->epoll_create_fn = rtc_epoll_create;
+ } else {
+ g_wrap_api->socket_fn = rtw_socket;
+ g_wrap_api->accept_fn = rtw_accept;
+ g_wrap_api->accept4_fn = rtw_accept4;
+ g_wrap_api->bind_fn = rtw_bind;
+ g_wrap_api->listen_fn = rtw_listen;
+ g_wrap_api->connect_fn = rtw_connect;
+ g_wrap_api->setsockopt_fn = rtw_setsockopt;
+ g_wrap_api->getsockopt_fn = rtw_getsockopt;
+ g_wrap_api->getpeername_fn = rtw_getpeername;
+ g_wrap_api->getsockname_fn = rtw_getsockname;
+ g_wrap_api->read_fn = rtw_read;
+ g_wrap_api->readv_fn = rtw_readv;
+ g_wrap_api->write_fn = rtw_write;
+ g_wrap_api->writev_fn = rtw_writev;
+ g_wrap_api->recv_fn = rtw_recv;
+ g_wrap_api->send_fn = rtw_send;
+ g_wrap_api->recv_msg = rtw_recvmsg;
+ g_wrap_api->send_msg = rtw_sendmsg;
+ g_wrap_api->recv_from = rtw_recvfrom;
+ g_wrap_api->send_to = rtw_sendto;
+ g_wrap_api->epoll_wait_fn = rtw_epoll_wait;
+ g_wrap_api->poll_fn = rtw_poll;
+ g_wrap_api->close_fn = rtw_close;
+ g_wrap_api->epoll_ctl_fn = rtw_epoll_ctl;
+ g_wrap_api->epoll_create1_fn = rtw_epoll_create1;
+ g_wrap_api->epoll_create_fn = rtw_epoll_create;
+ }
+}
+
static inline int32_t do_epoll_create1(int32_t flags)
{
if (select_posix_path() == PATH_KERNEL) {
return posix_api->epoll_create1_fn(flags);
}
- return lstack_epoll_create1(flags);
+ return g_wrap_api->epoll_create1_fn(flags);
}
static inline int32_t do_epoll_create(int32_t size)
@@ -61,7 +121,7 @@ static inline int32_t do_epoll_create(int32_t size)
return posix_api->epoll_create_fn(size);
}
- return lstack_epoll_create(size);
+ return g_wrap_api->epoll_create_fn(size);
}
static inline int32_t do_epoll_ctl(int32_t epfd, int32_t op, int32_t fd, struct epoll_event* event)
@@ -70,7 +130,7 @@ static inline int32_t do_epoll_ctl(int32_t epfd, int32_t op, int32_t fd, struct
return posix_api->epoll_ctl_fn(epfd, op, fd, event);
}
- return lstack_epoll_ctl(epfd, op, fd, event);
+ return g_wrap_api->epoll_ctl_fn(epfd, op, fd, event);
}
static inline int32_t do_epoll_wait(int32_t epfd, struct epoll_event* events, int32_t maxevents, int32_t timeout)
@@ -87,7 +147,7 @@ static inline int32_t do_epoll_wait(int32_t epfd, struct epoll_event* events, in
GAZELLE_RETURN(EINVAL);
}
- return lstack_epoll_wait(epfd, events, maxevents, timeout);
+ return g_wrap_api->epoll_wait_fn(epfd, events, maxevents, timeout);
}
static inline int32_t do_accept(int32_t s, struct sockaddr *addr, socklen_t *addrlen)
@@ -96,7 +156,7 @@ static inline int32_t do_accept(int32_t s, struct sockaddr *addr, socklen_t *add
return posix_api->accept_fn(s, addr, addrlen);
}
- int32_t fd = stack_broadcast_accept(s, addr, addrlen);
+ int32_t fd = g_wrap_api->accept_fn(s, addr, addrlen);
if (fd >= 0) {
return fd;
}
@@ -114,7 +174,7 @@ static int32_t do_accept4(int32_t s, struct sockaddr *addr, socklen_t *addrlen,
return posix_api->accept4_fn(s, addr, addrlen, flags);
}
- int32_t fd = stack_broadcast_accept4(s, addr, addrlen, flags);
+ int32_t fd = g_wrap_api->accept4_fn(s, addr, addrlen, flags);
if (fd >= 0) {
return fd;
}
@@ -158,11 +218,7 @@ static int32_t do_bind(int32_t s, const struct sockaddr *name, socklen_t namelen
if (match_host_addr(((struct sockaddr_in *)name)->sin_addr.s_addr)) {
/* maybe kni addr */
posix_api->bind_fn(s, name, namelen);
- if (NETCONN_IS_UDP(sock) && get_global_cfg_params()->listen_shadow) {
- return stack_broadcast_bind(s, name, namelen);
- } else {
- return stack_single_bind(s, name, namelen);
- }
+ return g_wrap_api->bind_fn(s, name, namelen);
} else {
SET_CONN_TYPE_HOST(sock->conn);
return posix_api->bind_fn(s, name, namelen);
@@ -253,7 +309,7 @@ static int32_t do_connect(int32_t s, const struct sockaddr *name, socklen_t name
ret = posix_api->connect_fn(s, name, namelen);
SET_CONN_TYPE_HOST(sock->conn);
} else {
- ret = rpc_call_connect(s, name, namelen);
+ ret = g_wrap_api->connect_fn(s, name, namelen);
SET_CONN_TYPE_LIBOS(sock->conn);
}
@@ -266,13 +322,7 @@ static inline int32_t do_listen(int32_t s, int32_t backlog)
return posix_api->listen_fn(s, backlog);
}
- int32_t ret;
- if (!get_global_cfg_params()->tuple_filter &&
- !get_global_cfg_params()->listen_shadow) {
- ret = stack_single_listen(s, backlog);
- } else {
- ret = stack_broadcast_listen(s, backlog);
- }
+ int32_t ret = g_wrap_api->listen_fn(s, backlog);
if (ret != 0) {
return ret;
}
@@ -287,7 +337,7 @@ static inline int32_t do_getpeername(int32_t s, struct sockaddr *name, socklen_t
}
if (select_fd_posix_path(s, NULL) == PATH_LWIP) {
- return rpc_call_getpeername(s, name, namelen);
+ return g_wrap_api->getpeername_fn(s, name, namelen);
}
return posix_api->getpeername_fn(s, name, namelen);
@@ -300,7 +350,7 @@ static inline int32_t do_getsockname(int32_t s, struct sockaddr *name, socklen_t
}
if (select_fd_posix_path(s, NULL) == PATH_LWIP) {
- return rpc_call_getsockname(s, name, namelen);
+ return g_wrap_api->getsockname_fn(s, name, namelen);
}
return posix_api->getsockname_fn(s, name, namelen);
@@ -321,7 +371,7 @@ static bool unsupport_optname(int32_t optname)
static inline int32_t do_getsockopt(int32_t s, int32_t level, int32_t optname, void *optval, socklen_t *optlen)
{
if (select_fd_posix_path(s, NULL) == PATH_LWIP && !unsupport_optname(optname)) {
- return rpc_call_getsockopt(s, level, optname, optval, optlen);
+ return g_wrap_api->getsockopt_fn(s, level, optname, optval, optlen);
}
return posix_api->getsockopt_fn(s, level, optname, optval, optlen);
@@ -339,7 +389,7 @@ static inline int32_t do_setsockopt(int32_t s, int32_t level, int32_t optname, c
return ret;
}
- return rpc_call_setsockopt(s, level, optname, optval, optlen);
+ return g_wrap_api->setsockopt_fn(s, level, optname, optval, optlen);
}
static inline int32_t do_socket(int32_t domain, int32_t type, int32_t protocol)
@@ -355,7 +405,7 @@ static inline int32_t do_socket(int32_t domain, int32_t type, int32_t protocol)
return posix_api->socket_fn(domain, type, protocol);
}
- ret = rpc_call_socket(domain, type, protocol);
+ ret = g_wrap_api->socket_fn(domain, type, protocol);
/* if udp_enable = 1 in lstack.conf, udp protocol must be in user path currently */
if ((ret >= 0) && (type & SOCK_DGRAM)) {
struct lwip_sock *sock = get_socket(ret);
@@ -382,7 +432,7 @@ static inline ssize_t do_recv(int32_t sockfd, void *buf, size_t len, int32_t fla
return posix_api->recv_fn(sockfd, buf, len, flags);
}
- return do_lwip_read_from_stack(sockfd, buf, len, flags, NULL, NULL);
+ return g_wrap_api->recv_fn(sockfd, buf, len, flags);
}
static inline ssize_t do_read(int32_t s, void *mem, size_t len)
@@ -400,7 +450,7 @@ static inline ssize_t do_read(int32_t s, void *mem, size_t len)
return posix_api->read_fn(s, mem, len);
}
- return do_lwip_read_from_stack(s, mem, len, 0, NULL, NULL);
+ return g_wrap_api->read_fn(s, mem, len);
}
static inline ssize_t do_readv(int32_t s, const struct iovec *iov, int iovcnt)
@@ -410,21 +460,7 @@ static inline ssize_t do_readv(int32_t s, const struct iovec *iov, int iovcnt)
return posix_api->readv_fn(s, iov, iovcnt);
}
- struct msghdr msg;
-
- msg.msg_name = NULL;
- msg.msg_namelen = 0;
- msg.msg_iov = LWIP_CONST_CAST(struct iovec *, iov);
- msg.msg_iovlen = 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 g_wrap_api->readv_fn(s, iov, iovcnt);
}
static inline ssize_t do_send(int32_t sockfd, const void *buf, size_t len, int32_t flags)
@@ -434,7 +470,7 @@ static inline ssize_t do_send(int32_t sockfd, const void *buf, size_t len, int32
return posix_api->send_fn(sockfd, buf, len, flags);
}
- return do_lwip_send_to_stack(sockfd, buf, len, flags, NULL, 0);
+ return g_wrap_api->send_fn(sockfd, buf, len, flags);
}
static inline ssize_t do_write(int32_t s, const void *mem, size_t size)
@@ -444,7 +480,7 @@ static inline ssize_t do_write(int32_t s, const void *mem, size_t size)
return posix_api->write_fn(s, mem, size);
}
- return do_lwip_send_to_stack(s, mem, size, 0, NULL, 0);
+ return g_wrap_api->write_fn(s, mem, size);
}
static inline ssize_t do_writev(int32_t s, const struct iovec *iov, int iovcnt)
@@ -455,16 +491,7 @@ static inline ssize_t do_writev(int32_t s, const struct iovec *iov, int iovcnt)
return posix_api->writev_fn(s, iov, iovcnt);
}
- struct msghdr msg;
-
- msg.msg_name = NULL;
- msg.msg_namelen = 0;
- msg.msg_iov = LWIP_CONST_CAST(struct iovec *, iov);
- msg.msg_iovlen = iovcnt;
- msg.msg_control = NULL;
- msg.msg_controllen = 0;
- msg.msg_flags = 0;
- return do_lwip_sendmsg_to_stack(sock, s, &msg, 0);
+ return g_wrap_api->writev_fn(s, iov, iovcnt);
}
static inline ssize_t do_recvmsg(int32_t s, struct msghdr *message, int32_t flags)
@@ -478,7 +505,7 @@ static inline ssize_t do_recvmsg(int32_t s, struct msghdr *message, int32_t flag
return posix_api->recv_msg(s, message, flags);
}
- return do_lwip_recvmsg_from_stack(s, message, flags);
+ return g_wrap_api->recv_msg(s, message, flags);
}
static inline ssize_t do_sendmsg(int32_t s, const struct msghdr *message, int32_t flags)
@@ -493,39 +520,7 @@ static inline ssize_t do_sendmsg(int32_t s, const struct msghdr *message, int32_
return posix_api->send_msg(s, message, flags);
}
- return do_lwip_sendmsg_to_stack(sock, s, message, flags);
-}
-
-static inline ssize_t udp_recvfrom(struct lwip_sock *sock, int32_t sockfd, void *buf, size_t len, int32_t flags,
- struct sockaddr *addr, socklen_t *addrlen)
-{
- int32_t ret;
-
- while (1) {
- ret = do_lwip_read_from_stack(sockfd, buf, len, flags, addr, addrlen);
- if (ret > 0) {
- return ret;
- }
- if (ret <= 0 && errno != EAGAIN) {
- return -1;
- }
- sock = sock->listen_next;
- if (sock != NULL && sock->conn != NULL) {
- sockfd = sock->conn->socket;
- } else {
- if (sock == NULL) {
- GAZELLE_RETURN(EAGAIN);
- } else {
- GAZELLE_RETURN(ENOTCONN);
- }
- }
- }
-}
-
-static inline ssize_t tcp_recvfrom(struct lwip_sock *sock, int32_t sockfd, void *buf, size_t len, int32_t flags,
- struct sockaddr *addr, socklen_t *addrlen)
-{
- return do_lwip_read_from_stack(sockfd, buf, len, flags, addr, addrlen);
+ return g_wrap_api->send_msg(s, message, flags);
}
static inline ssize_t do_recvfrom(int32_t sockfd, void *buf, size_t len, int32_t flags,
@@ -541,11 +536,7 @@ static inline ssize_t do_recvfrom(int32_t sockfd, void *buf, size_t len, int32_t
struct lwip_sock *sock = NULL;
if (select_fd_posix_path(sockfd, &sock) == PATH_LWIP) {
- if (NETCONN_IS_UDP(sock)) {
- return udp_recvfrom(sock, sockfd, buf, len, flags, addr, addrlen);
- } else {
- return tcp_recvfrom(sock, sockfd, buf, len, flags, addr, addrlen);
- }
+ return g_wrap_api->recv_from(sockfd, buf, len, flags, addr, addrlen);
}
return posix_api->recv_from(sockfd, buf, len, flags, addr, addrlen);
@@ -559,7 +550,7 @@ static inline ssize_t do_sendto(int32_t sockfd, const void *buf, size_t len, int
return posix_api->send_to(sockfd, buf, len, flags, addr, addrlen);
}
- return do_lwip_send_to_stack(sockfd, buf, len, flags, addr, addrlen);
+ return g_wrap_api->send_to(sockfd, buf, len, flags, addr, addrlen);
}
static inline int32_t do_close(int32_t s)
@@ -570,16 +561,13 @@ static inline int32_t do_close(int32_t 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) {
+ g_wrap_api->close_fn(s) == 0) {
return 0;
} else {
return posix_api->close_fn(s);
}
}
- if (sock && sock->wakeup && sock->wakeup->epollfd == s) {
- return lstack_epoll_close(s);
- }
- return stack_broadcast_close(s);
+ return g_wrap_api->close_fn(s);
}
static int32_t do_poll(struct pollfd *fds, nfds_t nfds, int32_t timeout)
@@ -588,7 +576,7 @@ static int32_t do_poll(struct pollfd *fds, nfds_t nfds, int32_t timeout)
return posix_api->poll_fn(fds, nfds, timeout);
}
- return lstack_poll(fds, nfds, timeout);
+ return g_wrap_api->poll_fn(fds, nfds, timeout);
}
static int32_t do_ppoll(struct pollfd *fds, nfds_t nfds, const struct timespec *tmo_p, const sigset_t *sigmask)
diff --git a/src/lstack/core/lstack_init.c b/src/lstack/core/lstack_init.c
index b6e9bf1..950fa8d 100644
--- a/src/lstack/core/lstack_init.c
+++ b/src/lstack/core/lstack_init.c
@@ -47,6 +47,7 @@
#include "gazelle_base_func.h"
#include "lstack_protocol_stack.h"
#include "lstack_preload.h"
+#include "lstack_wrap.h"
static void check_process_start(void)
{
@@ -235,6 +236,8 @@ __attribute__((constructor)) void gazelle_network_init(void)
}
LSTACK_PRE_LOG(LSTACK_INFO, "cfg_init success\n");
+ wrap_api_init();
+
/* check primary process start */
check_process_start();
diff --git a/src/lstack/core/lstack_lwip.c b/src/lstack/core/lstack_lwip.c
index a98b1b8..cdb0089 100644
--- a/src/lstack/core/lstack_lwip.c
+++ b/src/lstack/core/lstack_lwip.c
@@ -744,7 +744,7 @@ static int32_t check_msg_vaild(const struct msghdr *message)
return 0;
}
-ssize_t do_lwip_recvmsg_from_stack(int32_t s, struct msghdr *message, int32_t flags)
+ssize_t do_lwip_recvmsg_from_stack(int32_t s, const struct msghdr *message, int32_t flags)
{
ssize_t buflen = 0;
diff --git a/src/lstack/include/lstack_lwip.h b/src/lstack/include/lstack_lwip.h
index 55a483e..4a13204 100644
--- a/src/lstack/include/lstack_lwip.h
+++ b/src/lstack/include/lstack_lwip.h
@@ -41,7 +41,7 @@ ssize_t do_lwip_read_from_lwip(struct lwip_sock *sock, int32_t flags, uint8_t ap
/* app write/read ring */
ssize_t do_lwip_sendmsg_to_stack(struct lwip_sock *sock, int32_t s,
const struct msghdr *message, int32_t flags);
-ssize_t do_lwip_recvmsg_from_stack(int32_t s, struct msghdr *message, int32_t flags);
+ssize_t do_lwip_recvmsg_from_stack(int32_t s, const struct msghdr *message, int32_t flags);
ssize_t do_lwip_send_to_stack(int32_t fd, const void *buf, size_t len, int32_t flags,
const struct sockaddr *addr, socklen_t addrlen);
diff --git a/src/lstack/include/posix/lstack_socket.h b/src/lstack/include/lstack_rtc_api.h
similarity index 53%
rename from src/lstack/include/posix/lstack_socket.h
rename to src/lstack/include/lstack_rtc_api.h
index a3ce1eb..563cbd8 100644
--- a/src/lstack/include/posix/lstack_socket.h
+++ b/src/lstack/include/lstack_rtc_api.h
@@ -10,37 +10,46 @@
* See the Mulan PSL v2 for more details.
*/
-#ifndef _GAZELLE_SOCKET_H_
-#define _GAZELLE_SOCKET_H_
+#ifndef _LSTACK_RTC_API_H_
+#define _LSTACK_RTC_API_H_
+#include <sys/epoll.h>
+#include <sys/socket.h>
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-int lwip_socket(int domain, int type, int protocol);
-int lwip_bind(int s, const struct sockaddr *name, socklen_t namelen);
-int lwip_connect(int s, const struct sockaddr *name, socklen_t namelen);
-int lwip_listen(int s, int backlog);
+/* don't include lwip/sockets.h, conflict with sys/socket.h */
+/* extern lwip_api here */
+int lwip_fcntl(int s, int cmd, int val);
+int lwip_ioctl(int s, long cmd, ...);
int lwip_accept(int s, struct sockaddr *addr, socklen_t *addrlen);
-int lwip_close(int s);
+int lwip_accept4(int s, struct sockaddr *addr, socklen_t *addrlen, int flags);
+int lwip_bind(int s, const struct sockaddr *name, socklen_t namelen);
+int lwip_shutdown(int s, int how);
int lwip_getpeername(int s, struct sockaddr *name, socklen_t *namelen);
int lwip_getsockname(int s, struct sockaddr *name, socklen_t *namelen);
int lwip_getsockopt(int s, int level, int optname, void *optval, socklen_t *optlen);
int lwip_setsockopt(int s, int level, int optname, const void *optval, socklen_t optlen);
-
-ssize_t lwip_write(int s, const void *dataptr, size_t size);
-ssize_t lwip_send(int s, const void *data, size_t size, int flags);
-ssize_t lwip_recvmsg(int s, struct msghdr *message, int flags);
-ssize_t lwip_sendmsg(int s, const struct msghdr *message, int flags);
-ssize_t lwip_read(int s, void *mem, size_t len);
-ssize_t lwip_recvfrom(int s, void *mem, size_t len, int flags, void *from, void *fromlen);
+int lwip_close(int s);
+int lwip_connect(int s, const struct sockaddr *name, socklen_t namelen);
+int lwip_listen(int s, int backlog);
ssize_t lwip_recv(int s, void *mem, size_t len, int flags);
+ssize_t lwip_read(int s, void *mem, size_t len);
+ssize_t lwip_readv(int s, const struct iovec *iov, int iovcnt);
+ssize_t lwip_recvfrom(int s, void *mem, size_t len, int flags,
+ struct sockaddr *from, socklen_t *fromlen);
+ssize_t lwip_recvmsg(int s, const struct msghdr *message, int flags);
+ssize_t lwip_send(int s, const void *dataptr, size_t size, int flags);
+ssize_t lwip_sendmsg(int s, const struct msghdr *message, int flags);
+ssize_t lwip_sendto(int s, const void *dataptr, size_t size, int flags,
+ const struct sockaddr *to, socklen_t tolen);
+int lwip_socket(int domain, int type, int protocol);
+ssize_t lwip_write(int s, const void *dataptr, size_t size);
+ssize_t lwip_writev(int s, const struct iovec *iov, int iovcnt);
-int lwip_fcntl(int s, int cmd, int val);
-int lwip_ioctl(int s, int cmd, ...);
-
-#ifdef __cplusplus
-}
-#endif
+int rtc_poll(struct pollfd *fds, nfds_t nfds, int timeout);
+int rtc_epoll_wait(int epfd, struct epoll_event* events, int maxevents, int timeout);
+int rtc_socket(int domain, int type, int protocol);
+int rtc_close(int s);
+int rtc_epoll_create(int flags);
+int rtc_epoll_create1(int flags);
+int rtc_epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
-#endif /* _GAZELLE_SOCKET_H_ */
+#endif /* __LSTACK_RTC_API_H_ */
diff --git a/src/lstack/include/lstack_rtw_api.h b/src/lstack/include/lstack_rtw_api.h
new file mode 100644
index 0000000..facf4c0
--- /dev/null
+++ b/src/lstack/include/lstack_rtw_api.h
@@ -0,0 +1,47 @@
+/*
+* 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 _LSTACK_RTW_API_H_
+#define _LSTACK_RTW_API_H_
+
+#include <sys/epoll.h>
+#include <sys/socket.h>
+
+int rtw_socket(int domain, int type, int protocol);
+int rtw_accept(int s, struct sockaddr *addr, socklen_t *addrlen);
+int rtw_accept4(int s, struct sockaddr *addr, socklen_t *addrlen, int flags);
+int rtw_bind(int s, const struct sockaddr *name, socklen_t namelen);
+int rtw_listen(int s, int backlog);
+int rtw_connect(int s, const struct sockaddr *name, socklen_t namelen);
+int rtw_setsockopt(int s, int level, int optname, const void *optval, socklen_t optlen);
+int rtw_getsockopt(int s, int level, int optname, void *optval, socklen_t *optlen);
+int rtw_getpeername(int s, struct sockaddr *name, socklen_t *namelen);
+int rtw_getsockname(int s, struct sockaddr *name, socklen_t *namelen);
+ssize_t rtw_read(int s, void *mem, size_t len);
+ssize_t rtw_readv(int s, const struct iovec *iov, int iovcnt);
+ssize_t rtw_write(int s, const void *mem, size_t size);
+ssize_t rtw_writev(int s, const struct iovec *iov, int iovcnt);
+ssize_t rtw_recv(int sockfd, void *buf, size_t len, int flags);
+ssize_t rtw_send(int sockfd, const void *buf, size_t len, int flags);
+ssize_t rtw_recvmsg(int s, const struct msghdr *message, int flags);
+ssize_t rtw_sendmsg(int s, const struct msghdr *message, int flags);
+ssize_t rtw_recvfrom(int sockfd, void *buf, size_t len, int flags,
+ struct sockaddr *addr, socklen_t *addrlen);
+ssize_t rtw_sendto(int sockfd, const void *buf, size_t len, int flags,
+ const struct sockaddr *addr, socklen_t addrlen);
+int rtw_epoll_wait(int epfd, struct epoll_event* events, int maxevents, int timeout);
+int rtw_poll(struct pollfd *fds, nfds_t nfds, int timeout);
+int rtw_close(int s);
+int rtw_epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
+int rtw_epoll_create1(int flags);
+int rtw_epoll_create(int flags);
+#endif /* _LSTACK_RTW_API_H_ */
diff --git a/src/lstack/include/lstack_wrap.h b/src/lstack/include/lstack_wrap.h
new file mode 100644
index 0000000..80e5f3c
--- /dev/null
+++ b/src/lstack/include/lstack_wrap.h
@@ -0,0 +1,19 @@
+/*
+* 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 _LSTACK_WRAP_H_
+#define _LSTACK_WRAP_H_
+
+void wrap_api_init(void);
+
+#endif
+
--
2.27.0

25
0024-fix-arping-gazelle-return-value-is-1.patch Normal file
View File

@ -0,0 +1,25 @@
From e7fc6fab09b5687e84467520bf04f84f79de2c03 Mon Sep 17 00:00:00 2001
From: yinbin <yinbin8@huawei.com>
Date: Tue, 24 Oct 2023 14:33:00 +0800
Subject: [PATCH] fix arping gazelle return value is 1
---
src/lstack/core/lstack_protocol_stack.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/lstack/core/lstack_protocol_stack.c b/src/lstack/core/lstack_protocol_stack.c
index ea85bc1..1ef0850 100644
--- a/src/lstack/core/lstack_protocol_stack.c
+++ b/src/lstack/core/lstack_protocol_stack.c
@@ -786,7 +786,7 @@ void stack_broadcast_arp(struct rte_mbuf *mbuf, struct protocol_stack *cur_stack
for (int32_t i = 0; i < stack_group->stack_num; i++) {
stack = stack_group->stacks[i];
- if (cur_stack == stack && use_ltran()) {
+ if (cur_stack == stack) {
continue;
}
--
2.27.0

169
0025-init-stack-setup-in-app-thread-when-app-call-socket-.patch Normal file
View File

@ -0,0 +1,169 @@
From 76dc40bf3d8730e4155c142002bc4a27325672a8 Mon Sep 17 00:00:00 2001
From: jiangheng <jiangheng14@huawei.com>
Date: Mon, 9 Oct 2023 10:18:20 +0800
Subject: [PATCH] init: stack setup in app thread when app call
socket/epoll_create first in rtc mode
---
src/lstack/api/lstack_rtc_api.c | 14 ++++++-
src/lstack/core/lstack_init.c | 6 ++-
src/lstack/core/lstack_protocol_stack.c | 43 ++++++++++++++++++++--
src/lstack/include/lstack_protocol_stack.h | 3 +-
4 files changed, 57 insertions(+), 9 deletions(-)
diff --git a/src/lstack/api/lstack_rtc_api.c b/src/lstack/api/lstack_rtc_api.c
index b7c6380..276bec0 100644
--- a/src/lstack/api/lstack_rtc_api.c
+++ b/src/lstack/api/lstack_rtc_api.c
@@ -35,6 +35,10 @@ int rtc_epoll_wait(int epfd, struct epoll_event* events, int maxevents, int time
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");
+ }
/* need call stack thread init function */
ret = lwip_socket(domain, type, protocol);
@@ -56,13 +60,19 @@ int rtc_close(int s)
int rtc_epoll_create(int flags)
{
- /* need call stack thread init function */
+ if (stack_setup_app_thread() < 0) {
+ LSTACK_EXIT(1, "stack_setup_app_thread failed!\n");
+ }
+
return lstack_epoll_create(flags);
}
int rtc_epoll_create1(int flags)
{
- /* need call stack thread init function */
+ if (stack_setup_app_thread() < 0) {
+ LSTACK_EXIT(1, "stack_setup_app_thread failed!\n");
+ }
+
return lstack_epoll_create1(flags);
}
diff --git a/src/lstack/core/lstack_init.c b/src/lstack/core/lstack_init.c
index 950fa8d..a3ca4ff 100644
--- a/src/lstack/core/lstack_init.c
+++ b/src/lstack/core/lstack_init.c
@@ -287,8 +287,10 @@ __attribute__((constructor)) void gazelle_network_init(void)
}
}
- if (stack_thread_setup() != 0) {
- LSTACK_EXIT(1, "stack_thread_setup failed\n");
+ if (!get_global_cfg_params()->stack_mode_rtc) {
+ if (stack_setup_thread() != 0) {
+ LSTACK_EXIT(1, "stack_setup_thread failed\n");
+ }
}
/* lwip initialization */
diff --git a/src/lstack/core/lstack_protocol_stack.c b/src/lstack/core/lstack_protocol_stack.c
index ea85bc1..69897c7 100644
--- a/src/lstack/core/lstack_protocol_stack.c
+++ b/src/lstack/core/lstack_protocol_stack.c
@@ -501,6 +501,9 @@ static void* gazelle_stack_thread(void *arg)
}
LSTACK_LOG(INFO, LSTACK, "stack_%02hu init success\n", queue_id);
+ if (get_global_cfg_params()->stack_mode_rtc) {
+ return NULL;
+ }
for (;;) {
stack_polling(wakeup_tick);
@@ -510,7 +513,7 @@ static void* gazelle_stack_thread(void *arg)
return NULL;
}
-static void libnet_listen_thread(void *arg)
+static void gazelle_listen_thread(void *arg)
{
struct cfg_params *cfg_param = get_global_cfg_params();
recv_pkts_from_other_process(cfg_param->process_idx, arg);
@@ -541,11 +544,12 @@ int32_t stack_group_init(void)
}
}
- if (!use_ltran()) {
+ /* run to completion mode does not currently support multiple process */
+ if (!use_ltran() && !get_global_cfg_params()->stack_mode_rtc) {
char name[PATH_MAX];
sem_init(&stack_group->sem_listen_thread, 0, 0);
sprintf_s(name, sizeof(name), "%s", "listen_thread");
- struct sys_thread *thread = sys_thread_new(name, libnet_listen_thread,
+ struct sys_thread *thread = sys_thread_new(name, gazelle_listen_thread,
(void*)(&stack_group->sem_listen_thread), 0, 0);
free(thread);
sem_wait(&stack_group->sem_listen_thread);
@@ -554,7 +558,33 @@ int32_t stack_group_init(void)
return 0;
}
-int32_t stack_thread_setup(void)
+int32_t stack_setup_app_thread(void)
+{
+ static PER_THREAD int first_flags = 1;
+ static _Atomic uint32_t queue_id = 0;
+
+ if (likely(first_flags == 0)) {
+ return 0;
+ }
+ first_flags=0;
+
+ uint32_t cur_queue_id = atomic_fetch_add(&queue_id, 1);
+ struct thread_params *t_params = malloc(sizeof(struct thread_params));
+ if (t_params == NULL) {
+ return -1;
+ }
+ t_params->idx = cur_queue_id;
+ t_params->queue_id = cur_queue_id;
+
+ if (stack_thread_init(t_params) == NULL) {
+ LSTACK_LOG(INFO, LSTACK, "stack setup failed in app thread\n");
+ return -1;
+ }
+
+ return 0;
+}
+
+int32_t stack_setup_thread(void)
{
int32_t ret;
char name[PATH_MAX];
@@ -790,6 +820,11 @@ void stack_broadcast_arp(struct rte_mbuf *mbuf, struct protocol_stack *cur_stack
continue;
}
+ /* stack maybe not init in app thread yet */
+ if (stack == NULL || !(netif_is_up(&stack->netif))) {
+ continue;
+ }
+
ret = dpdk_alloc_pktmbuf(stack->rxtx_pktmbuf_pool, &mbuf_copy, 1);
if (ret != 0) {
stack->stats.rx_allocmbuf_fail++;
diff --git a/src/lstack/include/lstack_protocol_stack.h b/src/lstack/include/lstack_protocol_stack.h
index 7cb37bf..4f1b127 100644
--- a/src/lstack/include/lstack_protocol_stack.h
+++ b/src/lstack/include/lstack_protocol_stack.h
@@ -110,7 +110,8 @@ struct protocol_stack *get_bind_protocol_stack(void);
struct protocol_stack_group *get_protocol_stack_group(void);
int32_t stack_group_init(void);
-int32_t stack_thread_setup(void);
+int32_t stack_setup_thread(void);
+int32_t stack_setup_app_thread(void);
void bind_to_stack_numa(struct protocol_stack *stack);
int32_t init_dpdk_ethdev(void);
--
2.27.0

16
gazelle.spec
View File

@ -2,7 +2,7 @@
Name: gazelle
Version: 1.0.2
Release: 8
Release: 9
Summary: gazelle is a high performance user-mode stack
License: MulanPSL-2.0
URL: https://gitee.com/openeuler/gazelle
@ -35,6 +35,12 @@ Patch9016: 0016-cfg-nic-rx-tx-queue-size-configure.patch
Patch9017: 0017-epoll-distinguish-add-del_sock_event-and-add-del_soc.patch
Patch9018: 0018-preload-support-thread-hijacking-mode.patch
Patch9019: 0019-cfg-add-run-to-completion-mode-configure.patch
Patch9020: 0020-statck-the-for-loop-in-lstack-thread-is-defined-as-s.patch
Patch9021: 0021-delete_rule-bug.patch
Patch9022: 0022-tools-gazelle_setup-adapt-non-ltran-mode.patch
Patch9023: 0023-wrap-add-run-to-completion-wakeup-mode-api.patch
Patch9024: 0024-fix-arping-gazelle-return-value-is-1.patch
Patch9025: 0025-init-stack-setup-in-app-thread-when-app-call-socket-.patch
%description
%{name} is a high performance user-mode stack.
@ -76,6 +82,14 @@ install -Dpm 0640 %{_builddir}/%{name}-%{version}/src/ltran/ltran.conf %{b
%config(noreplace) %{conf_path}/ltran.conf
%changelog
* Sat Nov 4 2023 yinbin6 <yinbin8@huawei.com> - 1.0.2-9
- init: stack setup in app thread when app call socket/epoll_create first in rtc mode
- fix arping gazelle return value is 1
- wrap: add run-to-completion/wakeup mode api
- tools: gazelle_setup adapt non ltran mode
- delete_rule bug
- statck: the for loop in lstack thread is defined as stack_polling
* Mon Oct 30 2023 yangchenCloud <yangchen145@huawei.com> - 1.0.2-8
- cfg: add run-to-completion mode configure
- preload: support thread hijacking mode