* [RFC PATCH net-next v5 0/9] net/smc: Introduce SMC-D-based OS internal communication acceleration
@ 2023-04-23 12:17 Wen Gu
2023-04-23 12:17 ` [RFC PATCH net-next v5 1/9] net/smc: Decouple ism_dev from SMC-D device dump Wen Gu
` (9 more replies)
0 siblings, 10 replies; 17+ messages in thread
From: Wen Gu @ 2023-04-23 12:17 UTC (permalink / raw)
To: kgraul, wenjia, jaka, davem, edumazet, kuba, pabeni
Cc: linux-s390, netdev, linux-kernel
Hi, all
# Background
The background and previous discussion can be referred from [1]~[3].
We found SMC-D can be used to accelerate OS internal communication, such as
loopback or between two containers within the same OS instance. So this patch
set provides a kind of SMC-D dummy device (we call it the SMC-D loopback device)
to emulate an ISM device, so that SMC-D can also be used on architectures
other than s390. The SMC-D loopback device are designed as a system global
device, visible to all containers.
# Design
This patch set basically follows the design of the previous version.
Patch #1/9 ~ #3/9 attempt to decouple ISM-related structures from the SMC-D
generalized code and extract some helpers to make SMC-D protocol compatible
with devices other than s390 ISM device.
Patch #4/9 introduces a kind of loopback device, which is defined as SMC-Dv2
device and designed to provide communication between SMC sockets on the same
OS instance.
+-------------------------------------------+
| +--------------+ +--------------+ |
| | SMC socket A | | SMC socket B | |
| +--------------+ +--------------+ |
| ^ ^ |
| | +----------------+ | |
| | | SMC stack | | |
| +--->| +------------+ |<--| |
| | | dummy | | |
| | | device | | |
| +-+------------+-+ |
| OS |
+-------------------------------------------+
Patch #5/9 ~ #8/9 expand SMC-D protocol interface (smcd_ops) for scenarios where
SMC-D is used to communicate within VM (loopback here) or between VMs on the same
host (based on virtio-ism device, see [4]). What these scenarios have in common
is that the local sndbuf and peer RMB can be mapped to same physical memory region,
so the data copy between the local sndbuf and peer RMB can be omitted. Performance
improvement brought by this extension can be found in # Benchmark Test.
+----------+ +----------+
| socket A | | socket B |
+----------+ +----------+
| ^
| +---------+ |
regard as | | ----------|
local sndbuf | B's | regard as
| | RMB | local RMB
|-------> | |
+---------+
Patch #9/9 realizes the support of loopback device for the above-mentioned expanded
SMC-D protocol interface.
# Benchmark Test
* Test environments:
- VM with Intel Xeon Platinum 8 core 2.50GHz, 16 GiB mem.
- SMC sndbuf/RMB size 1MB.
* Test object:
- TCP lo: run on TCP loopback.
- domain: run on UNIX domain.
- SMC lo: run on SMC loopback device with patch #1/9 ~ #4/9.
- SMC lo-nocpy: run on SMC loopback device with patch #1/9 ~ #9/9.
1. ipc-benchmark (see [5])
- ./<foo> -c 1000000 -s 100
TCP-lo domain SMC-lo SMC-lo-nocpy
Message
rate (msg/s) 79025 115736(+46.45%) 146760(+85.71%) 149800(+89.56%)
2. sockperf
- serv: <smc_run> taskset -c <cpu> sockperf sr --tcp
- clnt: <smc_run> taskset -c <cpu> sockperf { tp | pp } --tcp --msg-size={ 64000 for tp | 14 for pp } -i 127.0.0.1 -t 30
TCP-lo SMC-lo SMC-lo-nocpy
Bandwidth(MBps) 4822.388 4940.918(+2.56%) 8086.67(+67.69%)
Latency(us) 6.298 3.352(-46.78%) 3.35(-46.81%)
3. iperf3
- serv: <smc_run> taskset -c <cpu> iperf3 -s
- clnt: <smc_run> taskset -c <cpu> iperf3 -c 127.0.0.1 -t 15
TCP-lo SMC-lo SMC-lo-nocpy
Bitrate(Gb/s) 40.7 40.5(-0.49%) 72.4(+77.89%)
4. nginx/wrk
- serv: <smc_run> nginx
- clnt: <smc_run> wrk -t 8 -c 500 -d 30 http://127.0.0.1:80
TCP-lo SMC-lo SMC-lo-nocpy
Requests/s 155994.57 214544.79(+37.53%) 215538.55(+38.17%)
v5->v4
1. The loopback device generates SEID in the same way as the ISM devices when coexisting
with ISM devices and uses a default fixed SEID in other cases.
2. Ensure each DMB token of the same loopback device is unique.
3. Fixe a crash caused by setting smcd_ops->signal_event interface to NULL.
4. Fixe a compilation warning complained by kernel test rebot.
v4->v3
1. Rebase to the latest net-next;
2. Introduce SEID helper. SMC-D loopback will return SMCD_DEFAULT_V2_SEID. And if it
coexist with ISM device, the SEID of ISM device will overwrite SMCD_DEFAULT_V2_SEID
as smc_ism_v2_system_eid.
3. Won't remove dmb_node from hashtable until no sndbuf attaching to it.
Something postponed in this version
1. Hierarchy perference of SMC-D devices when loopback and ISM devices coexist, which
will be determinated after comparing the performance of loopback and ISM.
v3->v2
1. Adapt new generalized interface provided by [2];
2. Select loopback device through SMC-D v2 protocol;
3. Split the loopback-related implementation and generic implementation into different
patches more reasonably.
v1->v2
1. Fix some build WARNINGs complained by kernel test rebot
Reported-by: kernel test robot <lkp@intel.com>
2. Add iperf3 test data.
[1] https://lore.kernel.org/netdev/1671506505-104676-1-git-send-email-guwen@linux.alibaba.com/
[2] https://lore.kernel.org/netdev/1676477905-88043-1-git-send-email-guwen@linux.alibaba.com/
[3] https://lore.kernel.org/netdev/1679887699-54797-1-git-send-email-guwen@linux.alibaba.com/
[4] https://lore.kernel.org/all/20230209033056.96657-1-xuanzhuo@linux.alibaba.com/
[5] https://github.com/goldsborough/ipc-bench
Wen Gu (9):
net/smc: Decouple ism_dev from SMC-D device dump
net/smc: Decouple ism_dev from SMC-D DMB registration
net/smc: Extract v2 check helper from SMC-D device registration
net/smc: Introduce SMC-D loopback device
net/smc: Introduce an interface for getting DMB attribute
net/smc: Introudce interfaces for DMB attach and detach
net/smc: Avoid data copy from sndbuf to peer RMB in SMC-D
net/smc: Modify cursor update logic when using mappable DMB
net/smc: Add interface implementation of loopback device
drivers/s390/net/ism_drv.c | 5 +-
include/net/smc.h | 18 +-
net/smc/Makefile | 2 +-
net/smc/af_smc.c | 26 ++-
net/smc/smc_cdc.c | 59 ++++--
net/smc/smc_cdc.h | 1 +
net/smc/smc_core.c | 70 ++++++-
net/smc/smc_core.h | 1 +
net/smc/smc_ism.c | 79 ++++++--
net/smc/smc_ism.h | 6 +
net/smc/smc_loopback.c | 491 +++++++++++++++++++++++++++++++++++++++++++++
net/smc/smc_loopback.h | 56 ++++++
12 files changed, 777 insertions(+), 37 deletions(-)
create mode 100644 net/smc/smc_loopback.c
create mode 100644 net/smc/smc_loopback.h
--
1.8.3.1
^ permalink raw reply [flat|nested] 17+ messages in thread
* [RFC PATCH net-next v5 1/9] net/smc: Decouple ism_dev from SMC-D device dump
2023-04-23 12:17 [RFC PATCH net-next v5 0/9] net/smc: Introduce SMC-D-based OS internal communication acceleration Wen Gu
@ 2023-04-23 12:17 ` Wen Gu
2023-04-23 12:17 ` [RFC PATCH net-next v5 2/9] net/smc: Decouple ism_dev from SMC-D DMB registration Wen Gu
` (8 subsequent siblings)
9 siblings, 0 replies; 17+ messages in thread
From: Wen Gu @ 2023-04-23 12:17 UTC (permalink / raw)
To: kgraul, wenjia, jaka, davem, edumazet, kuba, pabeni
Cc: linux-s390, netdev, linux-kernel
This patch helps to decouple SMC-D device and ISM device, allowing
different underlying device forms, such as non-PCI devices.
Signed-off-by: Wen Gu <guwen@linux.alibaba.com>
---
include/net/smc.h | 1 +
net/smc/smc_ism.c | 6 +++---
2 files changed, 4 insertions(+), 3 deletions(-)
diff --git a/include/net/smc.h b/include/net/smc.h
index a002552..963ce9c 100644
--- a/include/net/smc.h
+++ b/include/net/smc.h
@@ -77,6 +77,7 @@ struct smcd_ops {
struct smcd_dev {
const struct smcd_ops *ops;
void *priv;
+ struct device *parent_pci_dev;
struct list_head list;
spinlock_t lock;
struct smc_connection **conn;
diff --git a/net/smc/smc_ism.c b/net/smc/smc_ism.c
index fbee249..4249fb9 100644
--- a/net/smc/smc_ism.c
+++ b/net/smc/smc_ism.c
@@ -231,11 +231,9 @@ static int smc_nl_handle_smcd_dev(struct smcd_dev *smcd,
struct smc_pci_dev smc_pci_dev;
struct nlattr *port_attrs;
struct nlattr *attrs;
- struct ism_dev *ism;
int use_cnt = 0;
void *nlh;
- ism = smcd->priv;
nlh = genlmsg_put(skb, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq,
&smc_gen_nl_family, NLM_F_MULTI,
SMC_NETLINK_GET_DEV_SMCD);
@@ -250,7 +248,8 @@ static int smc_nl_handle_smcd_dev(struct smcd_dev *smcd,
if (nla_put_u8(skb, SMC_NLA_DEV_IS_CRIT, use_cnt > 0))
goto errattr;
memset(&smc_pci_dev, 0, sizeof(smc_pci_dev));
- smc_set_pci_values(to_pci_dev(ism->dev.parent), &smc_pci_dev);
+ if (smcd->parent_pci_dev)
+ smc_set_pci_values(to_pci_dev(smcd->parent_pci_dev), &smc_pci_dev);
if (nla_put_u32(skb, SMC_NLA_DEV_PCI_FID, smc_pci_dev.pci_fid))
goto errattr;
if (nla_put_u16(skb, SMC_NLA_DEV_PCI_CHID, smc_pci_dev.pci_pchid))
@@ -420,6 +419,7 @@ static void smcd_register_dev(struct ism_dev *ism)
if (!smcd)
return;
smcd->priv = ism;
+ smcd->parent_pci_dev = ism->dev.parent;
ism_set_priv(ism, &smc_ism_client, smcd);
if (smc_pnetid_by_dev_port(&ism->pdev->dev, 0, smcd->pnetid))
smc_pnetid_by_table_smcd(smcd);
--
1.8.3.1
^ permalink raw reply related [flat|nested] 17+ messages in thread
* [RFC PATCH net-next v5 2/9] net/smc: Decouple ism_dev from SMC-D DMB registration
2023-04-23 12:17 [RFC PATCH net-next v5 0/9] net/smc: Introduce SMC-D-based OS internal communication acceleration Wen Gu
2023-04-23 12:17 ` [RFC PATCH net-next v5 1/9] net/smc: Decouple ism_dev from SMC-D device dump Wen Gu
@ 2023-04-23 12:17 ` Wen Gu
2023-04-28 14:40 ` Simon Horman
2023-04-23 12:17 ` [RFC PATCH net-next v5 3/9] net/smc: Extract v2 check helper from SMC-D device registration Wen Gu
` (7 subsequent siblings)
9 siblings, 1 reply; 17+ messages in thread
From: Wen Gu @ 2023-04-23 12:17 UTC (permalink / raw)
To: kgraul, wenjia, jaka, davem, edumazet, kuba, pabeni
Cc: linux-s390, netdev, linux-kernel
This patch tries to decouple ISM device from SMC-D DMB registration,
So that the register_dmb option is not restricted to be used by ISM
device.
Signed-off-by: Wen Gu <guwen@linux.alibaba.com>
---
drivers/s390/net/ism_drv.c | 5 +++--
include/net/smc.h | 4 ++--
net/smc/smc_ism.c | 7 ++-----
3 files changed, 7 insertions(+), 9 deletions(-)
diff --git a/drivers/s390/net/ism_drv.c b/drivers/s390/net/ism_drv.c
index 8acb9eb..5eeb54d 100644
--- a/drivers/s390/net/ism_drv.c
+++ b/drivers/s390/net/ism_drv.c
@@ -796,9 +796,10 @@ static int smcd_query_rgid(struct smcd_dev *smcd, u64 rgid, u32 vid_valid,
}
static int smcd_register_dmb(struct smcd_dev *smcd, struct smcd_dmb *dmb,
- struct ism_client *client)
+ void *client_priv)
{
- return ism_register_dmb(smcd->priv, (struct ism_dmb *)dmb, client);
+ return ism_register_dmb(smcd->priv, (struct ism_dmb *)dmb,
+ (struct ism_client *)client_priv);
}
static int smcd_unregister_dmb(struct smcd_dev *smcd, struct smcd_dmb *dmb)
diff --git a/include/net/smc.h b/include/net/smc.h
index 963ce9c..26206d2 100644
--- a/include/net/smc.h
+++ b/include/net/smc.h
@@ -50,13 +50,12 @@ struct smcd_dmb {
#define ISM_ERROR 0xFFFF
struct smcd_dev;
-struct ism_client;
struct smcd_ops {
int (*query_remote_gid)(struct smcd_dev *dev, u64 rgid, u32 vid_valid,
u32 vid);
int (*register_dmb)(struct smcd_dev *dev, struct smcd_dmb *dmb,
- struct ism_client *client);
+ void *client_priv);
int (*unregister_dmb)(struct smcd_dev *dev, struct smcd_dmb *dmb);
int (*add_vlan_id)(struct smcd_dev *dev, u64 vlan_id);
int (*del_vlan_id)(struct smcd_dev *dev, u64 vlan_id);
@@ -77,6 +76,7 @@ struct smcd_ops {
struct smcd_dev {
const struct smcd_ops *ops;
void *priv;
+ void *client_priv;
struct device *parent_pci_dev;
struct list_head list;
spinlock_t lock;
diff --git a/net/smc/smc_ism.c b/net/smc/smc_ism.c
index 4249fb9..d4709ca 100644
--- a/net/smc/smc_ism.c
+++ b/net/smc/smc_ism.c
@@ -200,7 +200,6 @@ int smc_ism_unregister_dmb(struct smcd_dev *smcd, struct smc_buf_desc *dmb_desc)
int smc_ism_register_dmb(struct smc_link_group *lgr, int dmb_len,
struct smc_buf_desc *dmb_desc)
{
-#if IS_ENABLED(CONFIG_ISM)
struct smcd_dmb dmb;
int rc;
@@ -209,7 +208,7 @@ int smc_ism_register_dmb(struct smc_link_group *lgr, int dmb_len,
dmb.sba_idx = dmb_desc->sba_idx;
dmb.vlan_id = lgr->vlan_id;
dmb.rgid = lgr->peer_gid;
- rc = lgr->smcd->ops->register_dmb(lgr->smcd, &dmb, &smc_ism_client);
+ rc = lgr->smcd->ops->register_dmb(lgr->smcd, &dmb, lgr->smcd->client_priv);
if (!rc) {
dmb_desc->sba_idx = dmb.sba_idx;
dmb_desc->token = dmb.dmb_tok;
@@ -218,9 +217,6 @@ int smc_ism_register_dmb(struct smc_link_group *lgr, int dmb_len,
dmb_desc->len = dmb.dmb_len;
}
return rc;
-#else
- return 0;
-#endif
}
static int smc_nl_handle_smcd_dev(struct smcd_dev *smcd,
@@ -419,6 +415,7 @@ static void smcd_register_dev(struct ism_dev *ism)
if (!smcd)
return;
smcd->priv = ism;
+ smcd->client_priv = &smc_ism_client;
smcd->parent_pci_dev = ism->dev.parent;
ism_set_priv(ism, &smc_ism_client, smcd);
if (smc_pnetid_by_dev_port(&ism->pdev->dev, 0, smcd->pnetid))
--
1.8.3.1
^ permalink raw reply related [flat|nested] 17+ messages in thread
* [RFC PATCH net-next v5 3/9] net/smc: Extract v2 check helper from SMC-D device registration
2023-04-23 12:17 [RFC PATCH net-next v5 0/9] net/smc: Introduce SMC-D-based OS internal communication acceleration Wen Gu
2023-04-23 12:17 ` [RFC PATCH net-next v5 1/9] net/smc: Decouple ism_dev from SMC-D device dump Wen Gu
2023-04-23 12:17 ` [RFC PATCH net-next v5 2/9] net/smc: Decouple ism_dev from SMC-D DMB registration Wen Gu
@ 2023-04-23 12:17 ` Wen Gu
2023-04-23 12:17 ` [RFC PATCH net-next v5 4/9] net/smc: Introduce SMC-D loopback device Wen Gu
` (6 subsequent siblings)
9 siblings, 0 replies; 17+ messages in thread
From: Wen Gu @ 2023-04-23 12:17 UTC (permalink / raw)
To: kgraul, wenjia, jaka, davem, edumazet, kuba, pabeni
Cc: linux-s390, netdev, linux-kernel
This patch extracts v2-capable logic from the process of registering the
ISM device as an SMC-D device, so that the registration process of other
underlying devices can reuse it.
Signed-off-by: Wen Gu <guwen@linux.alibaba.com>
---
net/smc/smc_ism.c | 27 +++++++++++++++++----------
net/smc/smc_ism.h | 1 +
2 files changed, 18 insertions(+), 10 deletions(-)
diff --git a/net/smc/smc_ism.c b/net/smc/smc_ism.c
index d4709ca..8ad4c71 100644
--- a/net/smc/smc_ism.c
+++ b/net/smc/smc_ism.c
@@ -69,6 +69,22 @@ bool smc_ism_is_v2_capable(void)
return smc_ism_v2_capable;
}
+/* must be called under smcd_dev_list.mutex lock */
+void smc_ism_check_v2_capable(struct smcd_dev *smcd)
+{
+ u8 *system_eid = NULL;
+
+ if (!list_empty(&smcd_dev_list.list))
+ return;
+
+ system_eid = smcd->ops->get_system_eid();
+ if (smcd->ops->supports_v2()) {
+ smc_ism_v2_capable = true;
+ memcpy(smc_ism_v2_system_eid, system_eid,
+ SMC_MAX_EID_LEN);
+ }
+}
+
/* Set a connection using this DMBE. */
void smc_ism_set_conn(struct smc_connection *conn)
{
@@ -422,16 +438,7 @@ static void smcd_register_dev(struct ism_dev *ism)
smc_pnetid_by_table_smcd(smcd);
mutex_lock(&smcd_dev_list.mutex);
- if (list_empty(&smcd_dev_list.list)) {
- u8 *system_eid = NULL;
-
- system_eid = smcd->ops->get_system_eid();
- if (smcd->ops->supports_v2()) {
- smc_ism_v2_capable = true;
- memcpy(smc_ism_v2_system_eid, system_eid,
- SMC_MAX_EID_LEN);
- }
- }
+ smc_ism_check_v2_capable(smcd);
/* sort list: devices without pnetid before devices with pnetid */
if (smcd->pnetid[0])
list_add_tail(&smcd->list, &smcd_dev_list.list);
diff --git a/net/smc/smc_ism.h b/net/smc/smc_ism.h
index 832b2f4..14d2e77 100644
--- a/net/smc/smc_ism.h
+++ b/net/smc/smc_ism.h
@@ -42,6 +42,7 @@ int smc_ism_register_dmb(struct smc_link_group *lgr, int buf_size,
void smc_ism_get_system_eid(u8 **eid);
u16 smc_ism_get_chid(struct smcd_dev *dev);
bool smc_ism_is_v2_capable(void);
+void smc_ism_check_v2_capable(struct smcd_dev *dev);
int smc_ism_init(void);
void smc_ism_exit(void);
int smcd_nl_get_device(struct sk_buff *skb, struct netlink_callback *cb);
--
1.8.3.1
^ permalink raw reply related [flat|nested] 17+ messages in thread
* [RFC PATCH net-next v5 4/9] net/smc: Introduce SMC-D loopback device
2023-04-23 12:17 [RFC PATCH net-next v5 0/9] net/smc: Introduce SMC-D-based OS internal communication acceleration Wen Gu
` (2 preceding siblings ...)
2023-04-23 12:17 ` [RFC PATCH net-next v5 3/9] net/smc: Extract v2 check helper from SMC-D device registration Wen Gu
@ 2023-04-23 12:17 ` Wen Gu
2023-04-28 14:45 ` Simon Horman
2023-04-23 12:17 ` [RFC PATCH net-next v5 5/9] net/smc: Introduce an interface for getting DMB attribute Wen Gu
` (5 subsequent siblings)
9 siblings, 1 reply; 17+ messages in thread
From: Wen Gu @ 2023-04-23 12:17 UTC (permalink / raw)
To: kgraul, wenjia, jaka, davem, edumazet, kuba, pabeni
Cc: linux-s390, netdev, linux-kernel
This patch introduces a kind of loopback device for SMC-D, thus
enabling the SMC communication between two local sockets within
one OS instance.
The loopback device supports basic capabilities defined by SMC-D
options, and exposed as an SMC-D v2 device.
The GID of loopback device is random generated, CHID is 0xFFFF
and SEID is SMCD_DEFAULT_V2_SEID.
TODO:
- The hierarchy preference of coexistent SMC-D devices.
Signed-off-by: Wen Gu <guwen@linux.alibaba.com>
---
include/net/smc.h | 6 +
net/smc/Makefile | 2 +-
net/smc/af_smc.c | 12 +-
net/smc/smc_cdc.c | 9 +-
net/smc/smc_cdc.h | 1 +
net/smc/smc_ism.h | 2 +
net/smc/smc_loopback.c | 406 +++++++++++++++++++++++++++++++++++++++++++++++++
net/smc/smc_loopback.h | 51 +++++++
8 files changed, 486 insertions(+), 3 deletions(-)
create mode 100644 net/smc/smc_loopback.c
create mode 100644 net/smc/smc_loopback.h
diff --git a/include/net/smc.h b/include/net/smc.h
index 26206d2..021ca42 100644
--- a/include/net/smc.h
+++ b/include/net/smc.h
@@ -41,6 +41,12 @@ struct smcd_dmb {
dma_addr_t dma_addr;
};
+struct smcd_seid {
+ u8 seid_string[24];
+ u8 serial_number[4];
+ u8 type[4];
+};
+
#define ISM_EVENT_DMB 0
#define ISM_EVENT_GID 1
#define ISM_EVENT_SWR 2
diff --git a/net/smc/Makefile b/net/smc/Makefile
index 875efcd..a8c3711 100644
--- a/net/smc/Makefile
+++ b/net/smc/Makefile
@@ -4,5 +4,5 @@ obj-$(CONFIG_SMC) += smc.o
obj-$(CONFIG_SMC_DIAG) += smc_diag.o
smc-y := af_smc.o smc_pnet.o smc_ib.o smc_clc.o smc_core.o smc_wr.o smc_llc.o
smc-y += smc_cdc.o smc_tx.o smc_rx.o smc_close.o smc_ism.o smc_netlink.o smc_stats.o
-smc-y += smc_tracepoint.o
+smc-y += smc_tracepoint.o smc_loopback.o
smc-$(CONFIG_SYSCTL) += smc_sysctl.o
diff --git a/net/smc/af_smc.c b/net/smc/af_smc.c
index 50c38b6..3230309 100644
--- a/net/smc/af_smc.c
+++ b/net/smc/af_smc.c
@@ -53,6 +53,7 @@
#include "smc_stats.h"
#include "smc_tracepoint.h"
#include "smc_sysctl.h"
+#include "smc_loopback.h"
static DEFINE_MUTEX(smc_server_lgr_pending); /* serialize link group
* creation on server
@@ -3482,15 +3483,23 @@ static int __init smc_init(void)
goto out_sock;
}
+ rc = smc_loopback_init();
+ if (rc) {
+ pr_err("%s: smc_loopback_init fails with %d\n", __func__, rc);
+ goto out_ib;
+ }
+
rc = tcp_register_ulp(&smc_ulp_ops);
if (rc) {
pr_err("%s: tcp_ulp_register fails with %d\n", __func__, rc);
- goto out_ib;
+ goto out_lo;
}
static_branch_enable(&tcp_have_smc);
return 0;
+out_lo:
+ smc_loopback_exit();
out_ib:
smc_ib_unregister_client();
out_sock:
@@ -3528,6 +3537,7 @@ static void __exit smc_exit(void)
tcp_unregister_ulp(&smc_ulp_ops);
sock_unregister(PF_SMC);
smc_core_exit();
+ smc_loopback_exit();
smc_ib_unregister_client();
smc_ism_exit();
destroy_workqueue(smc_close_wq);
diff --git a/net/smc/smc_cdc.c b/net/smc/smc_cdc.c
index 89105e9..2f79bac 100644
--- a/net/smc/smc_cdc.c
+++ b/net/smc/smc_cdc.c
@@ -410,7 +410,14 @@ static void smc_cdc_msg_recv(struct smc_sock *smc, struct smc_cdc_msg *cdc)
*/
static void smcd_cdc_rx_tsklet(struct tasklet_struct *t)
{
- struct smc_connection *conn = from_tasklet(conn, t, rx_tsklet);
+ struct smc_connection *conn =
+ from_tasklet(conn, t, rx_tsklet);
+
+ smcd_cdc_rx_handler(conn);
+}
+
+void smcd_cdc_rx_handler(struct smc_connection *conn)
+{
struct smcd_cdc_msg *data_cdc;
struct smcd_cdc_msg cdc;
struct smc_sock *smc;
diff --git a/net/smc/smc_cdc.h b/net/smc/smc_cdc.h
index 696cc11..11559d4 100644
--- a/net/smc/smc_cdc.h
+++ b/net/smc/smc_cdc.h
@@ -301,5 +301,6 @@ int smcr_cdc_msg_send_validation(struct smc_connection *conn,
struct smc_wr_buf *wr_buf);
int smc_cdc_init(void) __init;
void smcd_cdc_rx_init(struct smc_connection *conn);
+void smcd_cdc_rx_handler(struct smc_connection *conn);
#endif /* SMC_CDC_H */
diff --git a/net/smc/smc_ism.h b/net/smc/smc_ism.h
index 14d2e77..d18c50a 100644
--- a/net/smc/smc_ism.h
+++ b/net/smc/smc_ism.h
@@ -15,6 +15,8 @@
#include "smc.h"
+#define S390_ISM_IDENT_MASK 0x00FFFF
+
struct smcd_dev_list { /* List of SMCD devices */
struct list_head list;
struct mutex mutex; /* Protects list of devices */
diff --git a/net/smc/smc_loopback.c b/net/smc/smc_loopback.c
new file mode 100644
index 0000000..4197201
--- /dev/null
+++ b/net/smc/smc_loopback.c
@@ -0,0 +1,406 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Shared Memory Communications Direct over loopback device.
+ *
+ * Provide a SMC-D loopback dummy device.
+ *
+ * Copyright (c) 2022, Alibaba Inc.
+ *
+ * Author: Wen Gu <guwen@linux.alibaba.com>
+ * Tony Lu <tonylu@linux.alibaba.com>
+ *
+ */
+
+#include <linux/device.h>
+#include <linux/types.h>
+#include <net/smc.h>
+
+#include "smc_cdc.h"
+#include "smc_ism.h"
+#include "smc_loopback.h"
+
+#define SMC_LO_SUPPORTS_V2 0x1 /* SMC-D loopback supports SMC-Dv2 */
+#define SMC_LO_DMA_ADDR_INVALID (~(dma_addr_t)0)
+
+static const char smc_lo_dev_name[] = "smcd_loopback_dev";
+static struct smcd_seid SMC_LO_SEID = {
+ .seid_string = "IBM-SYSZ-ISMSEID00000000",
+ .serial_number = "0000",
+ .type = "0000",
+};
+
+static struct smc_lo_dev *lo_dev;
+
+static void smc_lo_create_seid(struct smcd_seid *seid)
+{
+#if IS_ENABLED(CONFIG_ISM)
+ struct cpuid id;
+ u16 ident_tail;
+ char tmp[5];
+
+ get_cpu_id(&id);
+ ident_tail = (u16)(id.ident & S390_ISM_IDENT_MASK);
+ snprintf(tmp, 5, "%04X", ident_tail);
+ memcpy(&seid->serial_number, tmp, 4);
+ snprintf(tmp, 5, "%04X", id.machine);
+ memcpy(&seid->type, tmp, 4);
+#endif
+}
+
+static void smc_lo_generate_id(struct smc_lo_dev *ldev)
+{
+ /* Note that local GID of loopback device is random generated,
+ * so there is a very little possibility of collision. The
+ * collision may cause a mistaken belief that two sides are on
+ * the same OS instance and loopback device can be used to
+ * communicate with each other.
+ *
+ * But here is a relief that when choosing loopback device in
+ * CLC handshake, local sndbuf will be attached to peer RMB (DMB),
+ * which involves another 64-bits rtoken check.
+ *
+ * Therefore, the probability of mistakenly believing loopback
+ * can be used is equivalent to the collision probability of
+ * 128-bits random numbers (64-bits GID and 64-bits rtoken).
+ */
+ get_random_bytes(&ldev->local_gid, sizeof(ldev->local_gid));
+ ldev->chid = SMC_LO_CHID;
+ smc_lo_create_seid(&SMC_LO_SEID);
+}
+
+static int smc_lo_query_rgid(struct smcd_dev *smcd, u64 rgid,
+ u32 vid_valid, u32 vid)
+{
+ struct smc_lo_dev *ldev = smcd->priv;
+
+ /* rgid should equal to lgid in loopback */
+ if (!ldev || rgid != ldev->local_gid)
+ return -ENETUNREACH;
+ return 0;
+}
+
+static int smc_lo_register_dmb(struct smcd_dev *smcd, struct smcd_dmb *dmb,
+ void *client_priv)
+{
+ struct smc_lo_dmb_node *dmb_node, *tmp_node;
+ struct smc_lo_dev *ldev = smcd->priv;
+ int sba_idx, rc;
+
+ /* check space for new dmb */
+ for_each_clear_bit(sba_idx, ldev->sba_idx_mask, SMC_LODEV_MAX_DMBS) {
+ if (!test_and_set_bit(sba_idx, ldev->sba_idx_mask))
+ break;
+ }
+ if (sba_idx == SMC_LODEV_MAX_DMBS)
+ return -ENOSPC;
+
+ dmb_node = kzalloc(sizeof(*dmb_node), GFP_KERNEL);
+ if (!dmb_node) {
+ rc = -ENOMEM;
+ goto err_bit;
+ }
+
+ dmb_node->sba_idx = sba_idx;
+ dmb_node->cpu_addr = kzalloc(dmb->dmb_len, GFP_KERNEL |
+ __GFP_NOWARN | __GFP_NORETRY |
+ __GFP_NOMEMALLOC);
+ if (!dmb_node->cpu_addr) {
+ rc = -ENOMEM;
+ goto err_node;
+ }
+ dmb_node->len = dmb->dmb_len;
+ dmb_node->dma_addr = SMC_LO_DMA_ADDR_INVALID;
+
+again:
+ /* add new dmb into hash table */
+ get_random_bytes(&dmb_node->token, sizeof(dmb_node->token));
+ write_lock(&ldev->dmb_ht_lock);
+ hash_for_each_possible(ldev->dmb_ht, tmp_node, list, dmb_node->token) {
+ /* make sure the tokens in the same OS are unique */
+ if (tmp_node->token == dmb_node->token) {
+ write_unlock(&ldev->dmb_ht_lock);
+ goto again;
+ }
+ }
+ hash_add(ldev->dmb_ht, &dmb_node->list, dmb_node->token);
+ write_unlock(&ldev->dmb_ht_lock);
+
+ dmb->sba_idx = dmb_node->sba_idx;
+ dmb->dmb_tok = dmb_node->token;
+ dmb->cpu_addr = dmb_node->cpu_addr;
+ dmb->dma_addr = dmb_node->dma_addr;
+ dmb->dmb_len = dmb_node->len;
+
+ return 0;
+
+err_node:
+ kfree(dmb_node);
+err_bit:
+ clear_bit(sba_idx, ldev->sba_idx_mask);
+ return rc;
+}
+
+static int smc_lo_unregister_dmb(struct smcd_dev *smcd, struct smcd_dmb *dmb)
+{
+ struct smc_lo_dmb_node *dmb_node = NULL, *tmp_node;
+ struct smc_lo_dev *ldev = smcd->priv;
+
+ /* remove dmb from hash table */
+ write_lock(&ldev->dmb_ht_lock);
+ hash_for_each_possible(ldev->dmb_ht, tmp_node, list, dmb->dmb_tok) {
+ if (tmp_node->token == dmb->dmb_tok) {
+ dmb_node = tmp_node;
+ break;
+ }
+ }
+ if (!dmb_node) {
+ write_unlock(&ldev->dmb_ht_lock);
+ return -EINVAL;
+ }
+ hash_del(&dmb_node->list);
+ write_unlock(&ldev->dmb_ht_lock);
+
+ clear_bit(dmb_node->sba_idx, ldev->sba_idx_mask);
+ kfree(dmb_node->cpu_addr);
+ kfree(dmb_node);
+
+ return 0;
+}
+
+static int smc_lo_add_vlan_id(struct smcd_dev *smcd, u64 vlan_id)
+{
+ return -EOPNOTSUPP;
+}
+
+static int smc_lo_del_vlan_id(struct smcd_dev *smcd, u64 vlan_id)
+{
+ return -EOPNOTSUPP;
+}
+
+static int smc_lo_set_vlan_required(struct smcd_dev *smcd)
+{
+ return -EOPNOTSUPP;
+}
+
+static int smc_lo_reset_vlan_required(struct smcd_dev *smcd)
+{
+ return -EOPNOTSUPP;
+}
+
+static int smc_lo_signal_event(struct smcd_dev *dev, u64 rgid, u32 trigger_irq,
+ u32 event_code, u64 info)
+{
+ return 0;
+}
+
+static int smc_lo_move_data(struct smcd_dev *smcd, u64 dmb_tok, unsigned int idx,
+ bool sf, unsigned int offset, void *data,
+ unsigned int size)
+{
+ struct smc_lo_dmb_node *rmb_node = NULL, *tmp_node;
+ struct smc_lo_dev *ldev = smcd->priv;
+
+ read_lock(&ldev->dmb_ht_lock);
+ hash_for_each_possible(ldev->dmb_ht, tmp_node, list, dmb_tok) {
+ if (tmp_node->token == dmb_tok) {
+ rmb_node = tmp_node;
+ break;
+ }
+ }
+ if (!rmb_node) {
+ read_unlock(&ldev->dmb_ht_lock);
+ return -EINVAL;
+ }
+ read_unlock(&ldev->dmb_ht_lock);
+
+ memcpy((char *)rmb_node->cpu_addr + offset, data, size);
+
+ if (sf) {
+ struct smc_connection *conn =
+ smcd->conn[rmb_node->sba_idx];
+
+ if (conn && !conn->killed)
+ smcd_cdc_rx_handler(conn);
+ }
+ return 0;
+}
+
+static int smc_lo_supports_v2(void)
+{
+ return SMC_LO_SUPPORTS_V2;
+}
+
+static u8 *smc_lo_get_system_eid(void)
+{
+ return SMC_LO_SEID.seid_string;
+}
+
+static u64 smc_lo_get_local_gid(struct smcd_dev *smcd)
+{
+ return ((struct smc_lo_dev *)smcd->priv)->local_gid;
+}
+
+static u16 smc_lo_get_chid(struct smcd_dev *smcd)
+{
+ return ((struct smc_lo_dev *)smcd->priv)->chid;
+}
+
+static struct device *smc_lo_get_dev(struct smcd_dev *smcd)
+{
+ return &((struct smc_lo_dev *)smcd->priv)->dev;
+}
+
+static const struct smcd_ops lo_ops = {
+ .query_remote_gid = smc_lo_query_rgid,
+ .register_dmb = smc_lo_register_dmb,
+ .unregister_dmb = smc_lo_unregister_dmb,
+ .add_vlan_id = smc_lo_add_vlan_id,
+ .del_vlan_id = smc_lo_del_vlan_id,
+ .set_vlan_required = smc_lo_set_vlan_required,
+ .reset_vlan_required = smc_lo_reset_vlan_required,
+ .signal_event = smc_lo_signal_event,
+ .move_data = smc_lo_move_data,
+ .supports_v2 = smc_lo_supports_v2,
+ .get_system_eid = smc_lo_get_system_eid,
+ .get_local_gid = smc_lo_get_local_gid,
+ .get_chid = smc_lo_get_chid,
+ .get_dev = smc_lo_get_dev,
+};
+
+static struct smcd_dev *smcd_lo_alloc_dev(const struct smcd_ops *ops,
+ int max_dmbs)
+{
+ struct smcd_dev *smcd;
+
+ smcd = kzalloc(sizeof(*smcd), GFP_KERNEL);
+ if (!smcd)
+ return NULL;
+
+ smcd->conn = kcalloc(max_dmbs, sizeof(struct smc_connection *),
+ GFP_KERNEL);
+ if (!smcd->conn)
+ goto out_smcd;
+
+ smcd->ops = ops;
+
+ spin_lock_init(&smcd->lock);
+ spin_lock_init(&smcd->lgr_lock);
+ INIT_LIST_HEAD(&smcd->vlan);
+ INIT_LIST_HEAD(&smcd->lgr_list);
+ init_waitqueue_head(&smcd->lgrs_deleted);
+ return smcd;
+
+out_smcd:
+ kfree(smcd);
+ return NULL;
+}
+
+static int smcd_lo_register_dev(struct smc_lo_dev *ldev)
+{
+ struct smcd_dev *smcd;
+
+ smcd = smcd_lo_alloc_dev(&lo_ops, SMC_LODEV_MAX_DMBS);
+ if (!smcd)
+ return -ENOMEM;
+
+ ldev->smcd = smcd;
+ smcd->priv = ldev;
+ smcd->parent_pci_dev = NULL;
+ mutex_lock(&smcd_dev_list.mutex);
+ smc_ism_check_v2_capable(smcd);
+ list_add(&smcd->list, &smcd_dev_list.list);
+ mutex_unlock(&smcd_dev_list.mutex);
+ pr_warn_ratelimited("smc: adding smcd device %s with pnetid %.16s%s\n",
+ smc_lo_dev_name, smcd->pnetid,
+ smcd->pnetid_by_user ? " (user defined)" : "");
+ return 0;
+}
+
+static void smcd_lo_unregister_dev(struct smc_lo_dev *ldev)
+{
+ struct smcd_dev *smcd = ldev->smcd;
+
+ pr_warn_ratelimited("smc: removing smcd device %s\n",
+ smc_lo_dev_name);
+ smcd->going_away = 1;
+ smc_smcd_terminate_all(smcd);
+ mutex_lock(&smcd_dev_list.mutex);
+ list_del_init(&smcd->list);
+ mutex_unlock(&smcd_dev_list.mutex);
+}
+
+static void smc_lo_dev_release(struct device *dev)
+{
+ struct smc_lo_dev *ldev =
+ container_of(dev, struct smc_lo_dev, dev);
+ struct smcd_dev *smcd = ldev->smcd;
+
+ kfree(smcd->conn);
+ kfree(smcd);
+ kfree(ldev);
+}
+
+static int smc_lo_dev_init(struct smc_lo_dev *ldev)
+{
+ smc_lo_generate_id(ldev);
+ rwlock_init(&ldev->dmb_ht_lock);
+ hash_init(ldev->dmb_ht);
+
+ return smcd_lo_register_dev(ldev);
+}
+
+static int smc_lo_dev_probe(void)
+{
+ struct smc_lo_dev *ldev;
+ int ret;
+
+ ldev = kzalloc(sizeof(*ldev), GFP_KERNEL);
+ if (!ldev)
+ return -ENOMEM;
+
+ ldev->dev.parent = NULL;
+ ldev->dev.release = smc_lo_dev_release;
+ device_initialize(&ldev->dev);
+ dev_set_name(&ldev->dev, smc_lo_dev_name);
+ ret = device_add(&ldev->dev);
+ if (ret)
+ goto free_dev;
+
+ ret = smc_lo_dev_init(ldev);
+ if (ret)
+ goto put_dev;
+
+ lo_dev = ldev; /* global loopback device */
+ return 0;
+
+put_dev:
+ device_del(&ldev->dev);
+free_dev:
+ kfree(ldev);
+ return ret;
+}
+
+static void smc_lo_dev_exit(struct smc_lo_dev *ldev)
+{
+ smcd_lo_unregister_dev(ldev);
+}
+
+static void smc_lo_dev_remove(void)
+{
+ if (!lo_dev)
+ return;
+
+ smc_lo_dev_exit(lo_dev);
+ device_del(&lo_dev->dev); /* device_add in smc_lo_dev_probe */
+ put_device(&lo_dev->dev); /* device_initialize in smc_lo_dev_probe */
+}
+
+int smc_loopback_init(void)
+{
+ return smc_lo_dev_probe();
+}
+
+void smc_loopback_exit(void)
+{
+ smc_lo_dev_remove();
+}
diff --git a/net/smc/smc_loopback.h b/net/smc/smc_loopback.h
new file mode 100644
index 0000000..9d34aba
--- /dev/null
+++ b/net/smc/smc_loopback.h
@@ -0,0 +1,51 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Shared Memory Communications Direct over loopback device.
+ *
+ * Provide a SMC-D loopback dummy device.
+ *
+ * Copyright (c) 2022, Alibaba Inc.
+ *
+ * Author: Wen Gu <guwen@linux.alibaba.com>
+ * Tony Lu <tonylu@linux.alibaba.com>
+ *
+ */
+
+#ifndef _SMC_LOOPBACK_H
+#define _SMC_LOOPBACK_H
+
+#include <linux/types.h>
+#include <linux/interrupt.h>
+#include <linux/device.h>
+#include <linux/err.h>
+#include <net/smc.h>
+
+#include "smc_core.h"
+
+#define SMC_LO_CHID 0xFFFF
+#define SMC_LODEV_MAX_DMBS 5000
+#define SMC_LODEV_MAX_DMBS_BUCKETS 16
+
+struct smc_lo_dmb_node {
+ struct hlist_node list;
+ u64 token;
+ u32 len;
+ u32 sba_idx;
+ void *cpu_addr;
+ dma_addr_t dma_addr;
+};
+
+struct smc_lo_dev {
+ struct smcd_dev *smcd;
+ struct device dev;
+ u16 chid;
+ u64 local_gid;
+ DECLARE_BITMAP(sba_idx_mask, SMC_LODEV_MAX_DMBS);
+ rwlock_t dmb_ht_lock;
+ DECLARE_HASHTABLE(dmb_ht, SMC_LODEV_MAX_DMBS_BUCKETS);
+};
+
+int smc_loopback_init(void);
+void smc_loopback_exit(void);
+
+#endif /* _SMC_LOOPBACK_H */
--
1.8.3.1
^ permalink raw reply related [flat|nested] 17+ messages in thread
* [RFC PATCH net-next v5 5/9] net/smc: Introduce an interface for getting DMB attribute
2023-04-23 12:17 [RFC PATCH net-next v5 0/9] net/smc: Introduce SMC-D-based OS internal communication acceleration Wen Gu
` (3 preceding siblings ...)
2023-04-23 12:17 ` [RFC PATCH net-next v5 4/9] net/smc: Introduce SMC-D loopback device Wen Gu
@ 2023-04-23 12:17 ` Wen Gu
2023-04-28 15:08 ` Simon Horman
2023-04-23 12:17 ` [RFC PATCH net-next v5 6/9] net/smc: Introudce interfaces for DMB attach and detach Wen Gu
` (4 subsequent siblings)
9 siblings, 1 reply; 17+ messages in thread
From: Wen Gu @ 2023-04-23 12:17 UTC (permalink / raw)
To: kgraul, wenjia, jaka, davem, edumazet, kuba, pabeni
Cc: linux-s390, netdev, linux-kernel
On s390, since all OSs run on a kind of machine level hypervisor which
is a partitioning hypervisor without paging, the sndbufs and DMBs in
such case are unable to be mapped to the same physical memory.
However, in other scene, such as communication within the same OS instance
(loopback) or between guests of a paging hypervisor (eg. KVM), the sndbufs
and DMBs can be mapped to the same physical memory to avoid memory copy
from sndbufs to DMBs.
So this patch introduces an interface to smcd_ops for users to judge
whether DMB-map is available. And for reuse, the interface is designed
to return DMB attribute, not only mappability.
Signed-off-by: Wen Gu <guwen@linux.alibaba.com>
---
include/net/smc.h | 5 +++++
net/smc/smc_ism.c | 8 ++++++++
net/smc/smc_ism.h | 1 +
3 files changed, 14 insertions(+)
diff --git a/include/net/smc.h b/include/net/smc.h
index 021ca42..e39ac41 100644
--- a/include/net/smc.h
+++ b/include/net/smc.h
@@ -55,6 +55,10 @@ struct smcd_seid {
#define ISM_ERROR 0xFFFF
+enum {
+ ISM_DMB_MAPPABLE = 0,
+};
+
struct smcd_dev;
struct smcd_ops {
@@ -77,6 +81,7 @@ struct smcd_ops {
u64 (*get_local_gid)(struct smcd_dev *dev);
u16 (*get_chid)(struct smcd_dev *dev);
struct device* (*get_dev)(struct smcd_dev *dev);
+ int (*get_dev_dmb_attr)(struct smcd_dev *dev);
};
struct smcd_dev {
diff --git a/net/smc/smc_ism.c b/net/smc/smc_ism.c
index 8ad4c71..1d97e77 100644
--- a/net/smc/smc_ism.c
+++ b/net/smc/smc_ism.c
@@ -213,6 +213,14 @@ int smc_ism_unregister_dmb(struct smcd_dev *smcd, struct smc_buf_desc *dmb_desc)
return rc;
}
+bool smc_ism_dmb_mappable(struct smcd_dev *smcd)
+{
+ if (smcd->ops->get_dev_dmb_attr &&
+ (smcd->ops->get_dev_dmb_attr(smcd) & (1 << ISM_DMB_MAPPABLE)))
+ return true;
+ return false;
+}
+
int smc_ism_register_dmb(struct smc_link_group *lgr, int dmb_len,
struct smc_buf_desc *dmb_desc)
{
diff --git a/net/smc/smc_ism.h b/net/smc/smc_ism.h
index d18c50a..0b1913a 100644
--- a/net/smc/smc_ism.h
+++ b/net/smc/smc_ism.h
@@ -40,6 +40,7 @@ struct smc_ism_vlanid { /* VLAN id set on ISM device */
int smc_ism_register_dmb(struct smc_link_group *lgr, int buf_size,
struct smc_buf_desc *dmb_desc);
int smc_ism_unregister_dmb(struct smcd_dev *dev, struct smc_buf_desc *dmb_desc);
+bool smc_ism_dmb_mappable(struct smcd_dev *smcd);
int smc_ism_signal_shutdown(struct smc_link_group *lgr);
void smc_ism_get_system_eid(u8 **eid);
u16 smc_ism_get_chid(struct smcd_dev *dev);
--
1.8.3.1
^ permalink raw reply related [flat|nested] 17+ messages in thread
* [RFC PATCH net-next v5 6/9] net/smc: Introudce interfaces for DMB attach and detach
2023-04-23 12:17 [RFC PATCH net-next v5 0/9] net/smc: Introduce SMC-D-based OS internal communication acceleration Wen Gu
` (4 preceding siblings ...)
2023-04-23 12:17 ` [RFC PATCH net-next v5 5/9] net/smc: Introduce an interface for getting DMB attribute Wen Gu
@ 2023-04-23 12:17 ` Wen Gu
2023-04-23 12:17 ` [RFC PATCH net-next v5 7/9] net/smc: Avoid data copy from sndbuf to peer RMB in SMC-D Wen Gu
` (3 subsequent siblings)
9 siblings, 0 replies; 17+ messages in thread
From: Wen Gu @ 2023-04-23 12:17 UTC (permalink / raw)
To: kgraul, wenjia, jaka, davem, edumazet, kuba, pabeni
Cc: linux-s390, netdev, linux-kernel
This patch extends smcd_ops, adding two more semantic for SMC-D DMB:
- attach_dmb:
Attach an already registered DMB to a specific buf_desc, so that we
can refer to the DMB through this buf_desc.
- detach_dmb:
Reverse operation of attach_dmb. detach the DMB from the buf_desc.
This interface extension is to prepare for the avoidance of memory
copy from sndbuf to RMB with SMC-D device whose DMBs has ISM_DMB_MAPPABLE
attribute.
Signed-off-by: Wen Gu <guwen@linux.alibaba.com>
---
include/net/smc.h | 2 ++
net/smc/smc_ism.c | 31 +++++++++++++++++++++++++++++++
net/smc/smc_ism.h | 2 ++
3 files changed, 35 insertions(+)
diff --git a/include/net/smc.h b/include/net/smc.h
index e39ac41..0132522 100644
--- a/include/net/smc.h
+++ b/include/net/smc.h
@@ -67,6 +67,8 @@ struct smcd_ops {
int (*register_dmb)(struct smcd_dev *dev, struct smcd_dmb *dmb,
void *client_priv);
int (*unregister_dmb)(struct smcd_dev *dev, struct smcd_dmb *dmb);
+ int (*attach_dmb)(struct smcd_dev *dev, struct smcd_dmb *dmb);
+ int (*detach_dmb)(struct smcd_dev *dev, u64 token);
int (*add_vlan_id)(struct smcd_dev *dev, u64 vlan_id);
int (*del_vlan_id)(struct smcd_dev *dev, u64 vlan_id);
int (*set_vlan_required)(struct smcd_dev *dev);
diff --git a/net/smc/smc_ism.c b/net/smc/smc_ism.c
index 1d97e77..925af13 100644
--- a/net/smc/smc_ism.c
+++ b/net/smc/smc_ism.c
@@ -243,6 +243,37 @@ int smc_ism_register_dmb(struct smc_link_group *lgr, int dmb_len,
return rc;
}
+int smc_ism_attach_dmb(struct smcd_dev *dev, u64 token,
+ struct smc_buf_desc *dmb_desc)
+{
+ struct smcd_dmb dmb;
+ int rc = 0;
+
+ memset(&dmb, 0, sizeof(dmb));
+ dmb.dmb_tok = token;
+
+ if (!dev->ops->attach_dmb)
+ return -EINVAL;
+
+ rc = dev->ops->attach_dmb(dev, &dmb);
+ if (!rc) {
+ dmb_desc->sba_idx = dmb.sba_idx;
+ dmb_desc->token = dmb.dmb_tok;
+ dmb_desc->cpu_addr = dmb.cpu_addr;
+ dmb_desc->dma_addr = dmb.dma_addr;
+ dmb_desc->len = dmb.dmb_len;
+ }
+ return rc;
+}
+
+int smc_ism_detach_dmb(struct smcd_dev *dev, u64 token)
+{
+ if (!dev->ops->detach_dmb)
+ return -EINVAL;
+
+ return dev->ops->detach_dmb(dev, token);
+}
+
static int smc_nl_handle_smcd_dev(struct smcd_dev *smcd,
struct sk_buff *skb,
struct netlink_callback *cb)
diff --git a/net/smc/smc_ism.h b/net/smc/smc_ism.h
index 0b1913a..31eb010 100644
--- a/net/smc/smc_ism.h
+++ b/net/smc/smc_ism.h
@@ -41,6 +41,8 @@ int smc_ism_register_dmb(struct smc_link_group *lgr, int buf_size,
struct smc_buf_desc *dmb_desc);
int smc_ism_unregister_dmb(struct smcd_dev *dev, struct smc_buf_desc *dmb_desc);
bool smc_ism_dmb_mappable(struct smcd_dev *smcd);
+int smc_ism_attach_dmb(struct smcd_dev *dev, u64 token, struct smc_buf_desc *dmb_desc);
+int smc_ism_detach_dmb(struct smcd_dev *dev, u64 token);
int smc_ism_signal_shutdown(struct smc_link_group *lgr);
void smc_ism_get_system_eid(u8 **eid);
u16 smc_ism_get_chid(struct smcd_dev *dev);
--
1.8.3.1
^ permalink raw reply related [flat|nested] 17+ messages in thread
* [RFC PATCH net-next v5 7/9] net/smc: Avoid data copy from sndbuf to peer RMB in SMC-D
2023-04-23 12:17 [RFC PATCH net-next v5 0/9] net/smc: Introduce SMC-D-based OS internal communication acceleration Wen Gu
` (5 preceding siblings ...)
2023-04-23 12:17 ` [RFC PATCH net-next v5 6/9] net/smc: Introudce interfaces for DMB attach and detach Wen Gu
@ 2023-04-23 12:17 ` Wen Gu
2023-04-23 12:17 ` [RFC PATCH net-next v5 8/9] net/smc: Modify cursor update logic when using mappable DMB Wen Gu
` (2 subsequent siblings)
9 siblings, 0 replies; 17+ messages in thread
From: Wen Gu @ 2023-04-23 12:17 UTC (permalink / raw)
To: kgraul, wenjia, jaka, davem, edumazet, kuba, pabeni
Cc: linux-s390, netdev, linux-kernel
This patch aims to avoid data copy from local sndbuf to peer RMB by
attaching local sndbuf to peer RMB when DMBs have ISM_DMB_MAPPABLE
attribute.
After this, local sndbuf and peer RMB share the same physical memory.
+----------+ +----------+
| socket A | | socket B |
+----------+ +----------+
| ^
| +---------+ |
regard as | | ----------|
local sndbuf | B's | regard as
| | RMB | local RMB
|-------> | |
+---------+
1. Actions on local RMB.
a. Create or reuse RMB when connection is created;
b. Unuse RMB when connection is freed;
c. Free RMB when link group is freed;
2. Actions on local sndbuf.
a. Attach local sndbuf to peer RMB by the rtoken exchanged through
CLC message. Since then, accessing local sndbuf is equivalent to
accessing peer RMB
b. sndbuf_desc is exclusive to specific connection and won't be
added to lgr buffer pool for reuse.
c. Local sndbuf is detached from peer RMB and freed when connection
is freed.
Therefore, the data written to local sndbuf will directly reach peer RMB.
Signed-off-by: Wen Gu <guwen@linux.alibaba.com>
---
net/smc/af_smc.c | 14 +++++++++++
net/smc/smc_core.c | 70 +++++++++++++++++++++++++++++++++++++++++++++++++++++-
net/smc/smc_core.h | 1 +
3 files changed, 84 insertions(+), 1 deletion(-)
diff --git a/net/smc/af_smc.c b/net/smc/af_smc.c
index 3230309..0956cf5 100644
--- a/net/smc/af_smc.c
+++ b/net/smc/af_smc.c
@@ -1378,6 +1378,12 @@ static int smc_connect_ism(struct smc_sock *smc,
}
smc_conn_save_peer_info(smc, aclc);
+
+ if (smc_ism_dmb_mappable(smc->conn.lgr->smcd)) {
+ rc = smcd_buf_attach(smc);
+ if (rc)
+ goto connect_abort;
+ }
smc_close_init(smc);
smc_rx_init(smc);
smc_tx_init(smc);
@@ -2436,6 +2442,14 @@ static void smc_listen_work(struct work_struct *work)
mutex_unlock(&smc_server_lgr_pending);
}
smc_conn_save_peer_info(new_smc, cclc);
+
+ if (ini->is_smcd &&
+ smc_ism_dmb_mappable(new_smc->conn.lgr->smcd)) {
+ rc = smcd_buf_attach(new_smc);
+ if (rc)
+ goto out_decl;
+ }
+
smc_listen_out_connected(new_smc);
SMC_STAT_SERV_SUCC_INC(sock_net(newclcsock->sk), ini);
goto out_free;
diff --git a/net/smc/smc_core.c b/net/smc/smc_core.c
index 4543567..0fa26cc 100644
--- a/net/smc/smc_core.c
+++ b/net/smc/smc_core.c
@@ -1130,6 +1130,20 @@ static void smcr_buf_unuse(struct smc_buf_desc *buf_desc, bool is_rmb,
}
}
+static void smcd_buf_detach(struct smc_connection *conn)
+{
+ struct smcd_dev *smcd = conn->lgr->smcd;
+ u64 peer_token = conn->peer_token;
+
+ if (!conn->sndbuf_desc)
+ return;
+
+ smc_ism_detach_dmb(smcd, peer_token);
+
+ kfree(conn->sndbuf_desc);
+ conn->sndbuf_desc = NULL;
+}
+
static void smc_buf_unuse(struct smc_connection *conn,
struct smc_link_group *lgr)
{
@@ -1174,6 +1188,10 @@ void smc_conn_free(struct smc_connection *conn)
if (!list_empty(&lgr->list))
smc_ism_unset_conn(conn);
tasklet_kill(&conn->rx_tsklet);
+
+ /* detach sndbuf from peer RMB */
+ if (smc_ism_dmb_mappable(lgr->smcd))
+ smcd_buf_detach(conn);
} else {
smc_cdc_wait_pend_tx_wr(conn);
if (current_work() != &conn->abort_work)
@@ -2425,15 +2443,23 @@ void smc_rmb_sync_sg_for_cpu(struct smc_connection *conn)
*/
int smc_buf_create(struct smc_sock *smc, bool is_smcd)
{
+ bool sndbuf_created = false;
int rc;
+ if (is_smcd &&
+ smc_ism_dmb_mappable(smc->conn.lgr->smcd))
+ goto create_rmb;
+
/* create send buffer */
rc = __smc_buf_create(smc, is_smcd, false);
if (rc)
return rc;
+ sndbuf_created = true;
+
+create_rmb:
/* create rmb */
rc = __smc_buf_create(smc, is_smcd, true);
- if (rc) {
+ if (rc && sndbuf_created) {
down_write(&smc->conn.lgr->sndbufs_lock);
list_del(&smc->conn.sndbuf_desc->list);
up_write(&smc->conn.lgr->sndbufs_lock);
@@ -2443,6 +2469,48 @@ int smc_buf_create(struct smc_sock *smc, bool is_smcd)
return rc;
}
+int smcd_buf_attach(struct smc_sock *smc)
+{
+ struct smc_connection *conn = &smc->conn;
+ struct smcd_dev *smcd = conn->lgr->smcd;
+ u64 peer_token = conn->peer_token;
+ struct smc_buf_desc *buf_desc;
+ int rc;
+
+ buf_desc = kzalloc(sizeof(*buf_desc), GFP_KERNEL);
+ if (!buf_desc)
+ return -ENOMEM;
+
+ /* map local sndbuf desc to peer RMB, so operations on local
+ * sndbuf are equivalent to operations on peer RMB.
+ */
+ rc = smc_ism_attach_dmb(smcd, peer_token, buf_desc);
+ if (rc) {
+ rc = SMC_CLC_DECL_MEM;
+ goto free;
+ }
+
+ smc->sk.sk_sndbuf = buf_desc->len;
+ buf_desc->cpu_addr = (u8 *)buf_desc->cpu_addr + sizeof(struct smcd_cdc_msg);
+ buf_desc->len -= sizeof(struct smcd_cdc_msg);
+ conn->sndbuf_desc = buf_desc;
+ conn->sndbuf_desc->used = 1;
+ atomic_set(&conn->sndbuf_space, conn->sndbuf_desc->len);
+ return 0;
+
+free:
+ if (conn->rmb_desc) {
+ /* free local RMB as well */
+ down_write(&conn->lgr->rmbs_lock);
+ list_del(&conn->rmb_desc->list);
+ up_write(&conn->lgr->rmbs_lock);
+ smc_buf_free(conn->lgr, true, conn->rmb_desc);
+ conn->rmb_desc = NULL;
+ }
+ kfree(buf_desc);
+ return rc;
+}
+
static inline int smc_rmb_reserve_rtoken_idx(struct smc_link_group *lgr)
{
int i;
diff --git a/net/smc/smc_core.h b/net/smc/smc_core.h
index 1645fba..e52cf70 100644
--- a/net/smc/smc_core.h
+++ b/net/smc/smc_core.h
@@ -524,6 +524,7 @@ void smc_smcd_terminate(struct smcd_dev *dev, u64 peer_gid,
void smc_smcd_terminate_all(struct smcd_dev *dev);
void smc_smcr_terminate_all(struct smc_ib_device *smcibdev);
int smc_buf_create(struct smc_sock *smc, bool is_smcd);
+int smcd_buf_attach(struct smc_sock *smc);
int smc_uncompress_bufsize(u8 compressed);
int smc_rmb_rtoken_handling(struct smc_connection *conn, struct smc_link *link,
struct smc_clc_msg_accept_confirm *clc);
--
1.8.3.1
^ permalink raw reply related [flat|nested] 17+ messages in thread
* [RFC PATCH net-next v5 8/9] net/smc: Modify cursor update logic when using mappable DMB
2023-04-23 12:17 [RFC PATCH net-next v5 0/9] net/smc: Introduce SMC-D-based OS internal communication acceleration Wen Gu
` (6 preceding siblings ...)
2023-04-23 12:17 ` [RFC PATCH net-next v5 7/9] net/smc: Avoid data copy from sndbuf to peer RMB in SMC-D Wen Gu
@ 2023-04-23 12:17 ` Wen Gu
2023-04-23 12:17 ` [RFC PATCH net-next v5 9/9] net/smc: Add interface implementation of loopback device Wen Gu
2023-05-10 2:02 ` [RFC PATCH net-next v5 0/9] net/smc: Introduce SMC-D-based OS internal communication acceleration Wen Gu
9 siblings, 0 replies; 17+ messages in thread
From: Wen Gu @ 2023-04-23 12:17 UTC (permalink / raw)
To: kgraul, wenjia, jaka, davem, edumazet, kuba, pabeni
Cc: linux-s390, netdev, linux-kernel
Since local sndbuf shares the same physical memory region with peer
RMB when using mappable DMBs, the cursor update logic needs to be
adapted.
The main concern is to ensure that the data written by local to this
memory region won't overwrite the data that has not been consumed by
the peer.
So in this scene, the fin_curs and sndbuf_space that were originally
updated when sending out CDC message are not updated until the cons_curs
update from the peer is received.
Signed-off-by: Wen Gu <guwen@linux.alibaba.com>
---
net/smc/smc_cdc.c | 50 +++++++++++++++++++++++++++++++++++++++-----------
1 file changed, 39 insertions(+), 11 deletions(-)
diff --git a/net/smc/smc_cdc.c b/net/smc/smc_cdc.c
index 2f79bac..915b8e7 100644
--- a/net/smc/smc_cdc.c
+++ b/net/smc/smc_cdc.c
@@ -18,6 +18,7 @@
#include "smc_tx.h"
#include "smc_rx.h"
#include "smc_close.h"
+#include "smc_ism.h"
/********************************** send *************************************/
@@ -256,17 +257,24 @@ int smcd_cdc_msg_send(struct smc_connection *conn)
return rc;
smc_curs_copy(&conn->rx_curs_confirmed, &curs, conn);
conn->local_rx_ctrl.prod_flags.cons_curs_upd_req = 0;
- /* Calculate transmitted data and increment free send buffer space */
- diff = smc_curs_diff(conn->sndbuf_desc->len, &conn->tx_curs_fin,
- &conn->tx_curs_sent);
- /* increased by confirmed number of bytes */
- smp_mb__before_atomic();
- atomic_add(diff, &conn->sndbuf_space);
- /* guarantee 0 <= sndbuf_space <= sndbuf_desc->len */
- smp_mb__after_atomic();
- smc_curs_copy(&conn->tx_curs_fin, &conn->tx_curs_sent, conn);
+ if (!smc_ism_dmb_mappable(conn->lgr->smcd)) {
+ /* If local sndbuf has been mapped to peer RMB, then
+ * don't update the tx_curs_fin and sndbuf_space until
+ * peer has consumed the data in RMB.
+ */
- smc_tx_sndbuf_nonfull(smc);
+ /* Calculate transmitted data and increment free send buffer space */
+ diff = smc_curs_diff(conn->sndbuf_desc->len, &conn->tx_curs_fin,
+ &conn->tx_curs_sent);
+ /* increased by confirmed number of bytes */
+ smp_mb__before_atomic();
+ atomic_add(diff, &conn->sndbuf_space);
+ /* guarantee 0 <= sndbuf_space <= sndbuf_desc->len */
+ smp_mb__after_atomic();
+ smc_curs_copy(&conn->tx_curs_fin, &conn->tx_curs_sent, conn);
+
+ smc_tx_sndbuf_nonfull(smc);
+ }
return rc;
}
@@ -324,7 +332,7 @@ static void smc_cdc_msg_recv_action(struct smc_sock *smc,
{
union smc_host_cursor cons_old, prod_old;
struct smc_connection *conn = &smc->conn;
- int diff_cons, diff_prod;
+ int diff_cons, diff_prod, diff_tx;
smc_curs_copy(&prod_old, &conn->local_rx_ctrl.prod, conn);
smc_curs_copy(&cons_old, &conn->local_rx_ctrl.cons, conn);
@@ -340,6 +348,26 @@ static void smc_cdc_msg_recv_action(struct smc_sock *smc,
atomic_add(diff_cons, &conn->peer_rmbe_space);
/* guarantee 0 <= peer_rmbe_space <= peer_rmbe_size */
smp_mb__after_atomic();
+
+ if (conn->lgr->is_smcd &&
+ smc_ism_dmb_mappable(conn->lgr->smcd)) {
+ /* If local sndbuf has been mapped to peer RMB, then
+ * update tx_curs_fin and sndbuf_space when peer has
+ * consumed the data in it's RMB.
+ */
+
+ /* calculate peer rmb consumed data */
+ diff_tx = smc_curs_diff(conn->sndbuf_desc->len, &conn->tx_curs_fin,
+ &conn->local_rx_ctrl.cons);
+ /* increase local sndbuf space and fin_curs */
+ smp_mb__before_atomic();
+ atomic_add(diff_tx, &conn->sndbuf_space);
+ /* guarantee 0 <= sndbuf_space <= sndbuf_desc->len */
+ smp_mb__after_atomic();
+ smc_curs_copy(&conn->tx_curs_fin, &conn->local_rx_ctrl.cons, conn);
+
+ smc_tx_sndbuf_nonfull(smc);
+ }
}
diff_prod = smc_curs_diff(conn->rmb_desc->len, &prod_old,
--
1.8.3.1
^ permalink raw reply related [flat|nested] 17+ messages in thread
* [RFC PATCH net-next v5 9/9] net/smc: Add interface implementation of loopback device
2023-04-23 12:17 [RFC PATCH net-next v5 0/9] net/smc: Introduce SMC-D-based OS internal communication acceleration Wen Gu
` (7 preceding siblings ...)
2023-04-23 12:17 ` [RFC PATCH net-next v5 8/9] net/smc: Modify cursor update logic when using mappable DMB Wen Gu
@ 2023-04-23 12:17 ` Wen Gu
2023-05-10 2:02 ` [RFC PATCH net-next v5 0/9] net/smc: Introduce SMC-D-based OS internal communication acceleration Wen Gu
9 siblings, 0 replies; 17+ messages in thread
From: Wen Gu @ 2023-04-23 12:17 UTC (permalink / raw)
To: kgraul, wenjia, jaka, davem, edumazet, kuba, pabeni
Cc: linux-s390, netdev, linux-kernel
This patch completes the specific implementation of loopback device
for the newly added SMC-D DMB-related interface.
The loopback device always provides mappable DMB because the device
users are in the same OS instance.
Signed-off-by: Wen Gu <guwen@linux.alibaba.com>
---
net/smc/smc_loopback.c | 101 +++++++++++++++++++++++++++++++++++++++++++++----
net/smc/smc_loopback.h | 5 +++
2 files changed, 98 insertions(+), 8 deletions(-)
diff --git a/net/smc/smc_loopback.c b/net/smc/smc_loopback.c
index 4197201..dc1909b 100644
--- a/net/smc/smc_loopback.c
+++ b/net/smc/smc_loopback.c
@@ -110,6 +110,7 @@ static int smc_lo_register_dmb(struct smcd_dev *smcd, struct smcd_dmb *dmb,
}
dmb_node->len = dmb->dmb_len;
dmb_node->dma_addr = SMC_LO_DMA_ADDR_INVALID;
+ refcount_set(&dmb_node->refcnt, 1);
again:
/* add new dmb into hash table */
@@ -124,6 +125,7 @@ static int smc_lo_register_dmb(struct smcd_dev *smcd, struct smcd_dmb *dmb,
}
hash_add(ldev->dmb_ht, &dmb_node->list, dmb_node->token);
write_unlock(&ldev->dmb_ht_lock);
+ atomic_inc(&ldev->dmb_cnt);
dmb->sba_idx = dmb_node->sba_idx;
dmb->dmb_tok = dmb_node->token;
@@ -145,11 +147,12 @@ static int smc_lo_unregister_dmb(struct smcd_dev *smcd, struct smcd_dmb *dmb)
struct smc_lo_dmb_node *dmb_node = NULL, *tmp_node;
struct smc_lo_dev *ldev = smcd->priv;
- /* remove dmb from hash table */
+ /* find dmb from hash table */
write_lock(&ldev->dmb_ht_lock);
hash_for_each_possible(ldev->dmb_ht, tmp_node, list, dmb->dmb_tok) {
if (tmp_node->token == dmb->dmb_tok) {
dmb_node = tmp_node;
+ dmb_node->freeing = 1;
break;
}
}
@@ -157,16 +160,85 @@ static int smc_lo_unregister_dmb(struct smcd_dev *smcd, struct smcd_dmb *dmb)
write_unlock(&ldev->dmb_ht_lock);
return -EINVAL;
}
+ write_unlock(&ldev->dmb_ht_lock);
+
+ /* wait for dmb refcnt to be 0 */
+ if (!refcount_dec_and_test(&dmb_node->refcnt))
+ wait_event(ldev->dmbs_release, !refcount_read(&dmb_node->refcnt));
+
+ /* remove dmb from hash table */
+ write_lock(&ldev->dmb_ht_lock);
hash_del(&dmb_node->list);
write_unlock(&ldev->dmb_ht_lock);
clear_bit(dmb_node->sba_idx, ldev->sba_idx_mask);
+
kfree(dmb_node->cpu_addr);
kfree(dmb_node);
+ if (atomic_dec_and_test(&ldev->dmb_cnt))
+ wake_up(&ldev->ldev_release);
return 0;
}
+static int smc_lo_attach_dmb(struct smcd_dev *smcd, struct smcd_dmb *dmb)
+{
+ struct smc_lo_dmb_node *dmb_node = NULL, *tmp_node;
+ struct smc_lo_dev *ldev = smcd->priv;
+
+ /* find dmb_node according to dmb->dmb_tok */
+ read_lock(&ldev->dmb_ht_lock);
+ hash_for_each_possible(ldev->dmb_ht, tmp_node, list, dmb->dmb_tok) {
+ if (tmp_node->token == dmb->dmb_tok && !tmp_node->freeing) {
+ dmb_node = tmp_node;
+ break;
+ }
+ }
+ if (!dmb_node) {
+ read_unlock(&ldev->dmb_ht_lock);
+ return -EINVAL;
+ }
+ refcount_inc(&dmb_node->refcnt);
+ read_unlock(&ldev->dmb_ht_lock);
+
+ /* provide dmb information */
+ dmb->sba_idx = dmb_node->sba_idx;
+ dmb->dmb_tok = dmb_node->token;
+ dmb->cpu_addr = dmb_node->cpu_addr;
+ dmb->dma_addr = dmb_node->dma_addr;
+ dmb->dmb_len = dmb_node->len;
+ return 0;
+}
+
+static int smc_lo_detach_dmb(struct smcd_dev *smcd, u64 token)
+{
+ struct smc_lo_dmb_node *dmb_node = NULL, *tmp_node;
+ struct smc_lo_dev *ldev = smcd->priv;
+
+ /* find dmb_node according to dmb->dmb_tok */
+ read_lock(&ldev->dmb_ht_lock);
+ hash_for_each_possible(ldev->dmb_ht, tmp_node, list, token) {
+ if (tmp_node->token == token) {
+ dmb_node = tmp_node;
+ break;
+ }
+ }
+ if (!dmb_node) {
+ read_unlock(&ldev->dmb_ht_lock);
+ return -EINVAL;
+ }
+ read_unlock(&ldev->dmb_ht_lock);
+
+ if (refcount_dec_and_test(&dmb_node->refcnt))
+ wake_up_all(&ldev->dmbs_release);
+ return 0;
+}
+
+static int smc_lo_get_dev_dmb_attr(struct smcd_dev *smcd)
+{
+ return (1 << ISM_DMB_MAPPABLE);
+}
+
static int smc_lo_add_vlan_id(struct smcd_dev *smcd, u64 vlan_id)
{
return -EOPNOTSUPP;
@@ -199,7 +271,15 @@ static int smc_lo_move_data(struct smcd_dev *smcd, u64 dmb_tok, unsigned int idx
{
struct smc_lo_dmb_node *rmb_node = NULL, *tmp_node;
struct smc_lo_dev *ldev = smcd->priv;
-
+ struct smc_connection *conn;
+
+ if (!sf) {
+ /* local sndbuf shares the same physical memory with
+ * peer RMB, so no need to copy data from local sndbuf
+ * to peer RMB.
+ */
+ return 0;
+ }
read_lock(&ldev->dmb_ht_lock);
hash_for_each_possible(ldev->dmb_ht, tmp_node, list, dmb_tok) {
if (tmp_node->token == dmb_tok) {
@@ -215,13 +295,10 @@ static int smc_lo_move_data(struct smcd_dev *smcd, u64 dmb_tok, unsigned int idx
memcpy((char *)rmb_node->cpu_addr + offset, data, size);
- if (sf) {
- struct smc_connection *conn =
- smcd->conn[rmb_node->sba_idx];
+ conn = smcd->conn[rmb_node->sba_idx];
+ if (conn && !conn->killed)
+ smcd_cdc_rx_handler(conn);
- if (conn && !conn->killed)
- smcd_cdc_rx_handler(conn);
- }
return 0;
}
@@ -254,6 +331,8 @@ static struct device *smc_lo_get_dev(struct smcd_dev *smcd)
.query_remote_gid = smc_lo_query_rgid,
.register_dmb = smc_lo_register_dmb,
.unregister_dmb = smc_lo_unregister_dmb,
+ .attach_dmb = smc_lo_attach_dmb,
+ .detach_dmb = smc_lo_detach_dmb,
.add_vlan_id = smc_lo_add_vlan_id,
.del_vlan_id = smc_lo_del_vlan_id,
.set_vlan_required = smc_lo_set_vlan_required,
@@ -265,6 +344,7 @@ static struct device *smc_lo_get_dev(struct smcd_dev *smcd)
.get_local_gid = smc_lo_get_local_gid,
.get_chid = smc_lo_get_chid,
.get_dev = smc_lo_get_dev,
+ .get_dev_dmb_attr = smc_lo_get_dev_dmb_attr,
};
static struct smcd_dev *smcd_lo_alloc_dev(const struct smcd_ops *ops,
@@ -345,6 +425,9 @@ static int smc_lo_dev_init(struct smc_lo_dev *ldev)
smc_lo_generate_id(ldev);
rwlock_init(&ldev->dmb_ht_lock);
hash_init(ldev->dmb_ht);
+ atomic_set(&ldev->dmb_cnt, 0);
+ init_waitqueue_head(&ldev->dmbs_release);
+ init_waitqueue_head(&ldev->ldev_release);
return smcd_lo_register_dev(ldev);
}
@@ -383,6 +466,8 @@ static int smc_lo_dev_probe(void)
static void smc_lo_dev_exit(struct smc_lo_dev *ldev)
{
smcd_lo_unregister_dev(ldev);
+ if (atomic_read(&ldev->dmb_cnt))
+ wait_event(ldev->ldev_release, !atomic_read(&ldev->dmb_cnt));
}
static void smc_lo_dev_remove(void)
diff --git a/net/smc/smc_loopback.h b/net/smc/smc_loopback.h
index 9d34aba..e0bf044 100644
--- a/net/smc/smc_loopback.h
+++ b/net/smc/smc_loopback.h
@@ -33,6 +33,8 @@ struct smc_lo_dmb_node {
u32 sba_idx;
void *cpu_addr;
dma_addr_t dma_addr;
+ refcount_t refcnt;
+ u8 freeing : 1;
};
struct smc_lo_dev {
@@ -43,6 +45,9 @@ struct smc_lo_dev {
DECLARE_BITMAP(sba_idx_mask, SMC_LODEV_MAX_DMBS);
rwlock_t dmb_ht_lock;
DECLARE_HASHTABLE(dmb_ht, SMC_LODEV_MAX_DMBS_BUCKETS);
+ atomic_t dmb_cnt;
+ wait_queue_head_t dmbs_release;
+ wait_queue_head_t ldev_release;
};
int smc_loopback_init(void);
--
1.8.3.1
^ permalink raw reply related [flat|nested] 17+ messages in thread
* Re: [RFC PATCH net-next v5 2/9] net/smc: Decouple ism_dev from SMC-D DMB registration
2023-04-23 12:17 ` [RFC PATCH net-next v5 2/9] net/smc: Decouple ism_dev from SMC-D DMB registration Wen Gu
@ 2023-04-28 14:40 ` Simon Horman
2023-05-04 6:22 ` Wen Gu
0 siblings, 1 reply; 17+ messages in thread
From: Simon Horman @ 2023-04-28 14:40 UTC (permalink / raw)
To: Wen Gu
Cc: kgraul, wenjia, jaka, davem, edumazet, kuba, pabeni, linux-s390,
netdev, linux-kernel
On Sun, Apr 23, 2023 at 08:17:44PM +0800, Wen Gu wrote:
> This patch tries to decouple ISM device from SMC-D DMB registration,
> So that the register_dmb option is not restricted to be used by ISM
> device.
>
> Signed-off-by: Wen Gu <guwen@linux.alibaba.com>
> ---
> drivers/s390/net/ism_drv.c | 5 +++--
> include/net/smc.h | 4 ++--
> net/smc/smc_ism.c | 7 ++-----
> 3 files changed, 7 insertions(+), 9 deletions(-)
>
> diff --git a/drivers/s390/net/ism_drv.c b/drivers/s390/net/ism_drv.c
> index 8acb9eb..5eeb54d 100644
> --- a/drivers/s390/net/ism_drv.c
> +++ b/drivers/s390/net/ism_drv.c
> @@ -796,9 +796,10 @@ static int smcd_query_rgid(struct smcd_dev *smcd, u64 rgid, u32 vid_valid,
> }
>
> static int smcd_register_dmb(struct smcd_dev *smcd, struct smcd_dmb *dmb,
> - struct ism_client *client)
> + void *client_priv)
> {
> - return ism_register_dmb(smcd->priv, (struct ism_dmb *)dmb, client);
> + return ism_register_dmb(smcd->priv, (struct ism_dmb *)dmb,
> + (struct ism_client *)client_priv);
Hi Wen Gu,
a minor nit from my side: there is no need to cast a void pointer to
another type.
> }
>
> static int smcd_unregister_dmb(struct smcd_dev *smcd, struct smcd_dmb *dmb)
...
^ permalink raw reply [flat|nested] 17+ messages in thread
* Re: [RFC PATCH net-next v5 4/9] net/smc: Introduce SMC-D loopback device
2023-04-23 12:17 ` [RFC PATCH net-next v5 4/9] net/smc: Introduce SMC-D loopback device Wen Gu
@ 2023-04-28 14:45 ` Simon Horman
0 siblings, 0 replies; 17+ messages in thread
From: Simon Horman @ 2023-04-28 14:45 UTC (permalink / raw)
To: Wen Gu
Cc: kgraul, wenjia, jaka, davem, edumazet, kuba, pabeni, linux-s390,
netdev, linux-kernel
On Sun, Apr 23, 2023 at 08:17:46PM +0800, Wen Gu wrote:
> This patch introduces a kind of loopback device for SMC-D, thus
> enabling the SMC communication between two local sockets within
> one OS instance.
>
> The loopback device supports basic capabilities defined by SMC-D
> options, and exposed as an SMC-D v2 device.
>
> The GID of loopback device is random generated, CHID is 0xFFFF
> and SEID is SMCD_DEFAULT_V2_SEID.
>
> TODO:
> - The hierarchy preference of coexistent SMC-D devices.
>
> Signed-off-by: Wen Gu <guwen@linux.alibaba.com>
> ---
> include/net/smc.h | 6 +
> net/smc/Makefile | 2 +-
> net/smc/af_smc.c | 12 +-
> net/smc/smc_cdc.c | 9 +-
> net/smc/smc_cdc.h | 1 +
> net/smc/smc_ism.h | 2 +
> net/smc/smc_loopback.c | 406 +++++++++++++++++++++++++++++++++++++++++++++++++
> net/smc/smc_loopback.h | 51 +++++++
> 8 files changed, 486 insertions(+), 3 deletions(-)
> create mode 100644 net/smc/smc_loopback.c
> create mode 100644 net/smc/smc_loopback.h
>
> diff --git a/include/net/smc.h b/include/net/smc.h
> index 26206d2..021ca42 100644
> --- a/include/net/smc.h
> +++ b/include/net/smc.h
> @@ -41,6 +41,12 @@ struct smcd_dmb {
> dma_addr_t dma_addr;
> };
>
> +struct smcd_seid {
> + u8 seid_string[24];
> + u8 serial_number[4];
> + u8 type[4];
> +};
> +
> #define ISM_EVENT_DMB 0
> #define ISM_EVENT_GID 1
> #define ISM_EVENT_SWR 2
> diff --git a/net/smc/Makefile b/net/smc/Makefile
> index 875efcd..a8c3711 100644
> --- a/net/smc/Makefile
> +++ b/net/smc/Makefile
> @@ -4,5 +4,5 @@ obj-$(CONFIG_SMC) += smc.o
> obj-$(CONFIG_SMC_DIAG) += smc_diag.o
> smc-y := af_smc.o smc_pnet.o smc_ib.o smc_clc.o smc_core.o smc_wr.o smc_llc.o
> smc-y += smc_cdc.o smc_tx.o smc_rx.o smc_close.o smc_ism.o smc_netlink.o smc_stats.o
> -smc-y += smc_tracepoint.o
> +smc-y += smc_tracepoint.o smc_loopback.o
> smc-$(CONFIG_SYSCTL) += smc_sysctl.o
> diff --git a/net/smc/af_smc.c b/net/smc/af_smc.c
> index 50c38b6..3230309 100644
> --- a/net/smc/af_smc.c
> +++ b/net/smc/af_smc.c
> @@ -53,6 +53,7 @@
> #include "smc_stats.h"
> #include "smc_tracepoint.h"
> #include "smc_sysctl.h"
> +#include "smc_loopback.h"
>
> static DEFINE_MUTEX(smc_server_lgr_pending); /* serialize link group
> * creation on server
> @@ -3482,15 +3483,23 @@ static int __init smc_init(void)
> goto out_sock;
> }
>
> + rc = smc_loopback_init();
> + if (rc) {
> + pr_err("%s: smc_loopback_init fails with %d\n", __func__, rc);
> + goto out_ib;
> + }
> +
> rc = tcp_register_ulp(&smc_ulp_ops);
> if (rc) {
> pr_err("%s: tcp_ulp_register fails with %d\n", __func__, rc);
> - goto out_ib;
> + goto out_lo;
> }
>
> static_branch_enable(&tcp_have_smc);
> return 0;
>
> +out_lo:
> + smc_loopback_exit();
> out_ib:
> smc_ib_unregister_client();
> out_sock:
> @@ -3528,6 +3537,7 @@ static void __exit smc_exit(void)
> tcp_unregister_ulp(&smc_ulp_ops);
> sock_unregister(PF_SMC);
> smc_core_exit();
> + smc_loopback_exit();
> smc_ib_unregister_client();
> smc_ism_exit();
> destroy_workqueue(smc_close_wq);
> diff --git a/net/smc/smc_cdc.c b/net/smc/smc_cdc.c
> index 89105e9..2f79bac 100644
> --- a/net/smc/smc_cdc.c
> +++ b/net/smc/smc_cdc.c
> @@ -410,7 +410,14 @@ static void smc_cdc_msg_recv(struct smc_sock *smc, struct smc_cdc_msg *cdc)
> */
> static void smcd_cdc_rx_tsklet(struct tasklet_struct *t)
> {
> - struct smc_connection *conn = from_tasklet(conn, t, rx_tsklet);
> + struct smc_connection *conn =
> + from_tasklet(conn, t, rx_tsklet);
nit: I think the above can be on one line, as it was before this patch.
> +
> + smcd_cdc_rx_handler(conn);
> +}
> +
> +void smcd_cdc_rx_handler(struct smc_connection *conn)
> +{
> struct smcd_cdc_msg *data_cdc;
> struct smcd_cdc_msg cdc;
> struct smc_sock *smc;
> diff --git a/net/smc/smc_cdc.h b/net/smc/smc_cdc.h
> index 696cc11..11559d4 100644
> --- a/net/smc/smc_cdc.h
> +++ b/net/smc/smc_cdc.h
> @@ -301,5 +301,6 @@ int smcr_cdc_msg_send_validation(struct smc_connection *conn,
> struct smc_wr_buf *wr_buf);
> int smc_cdc_init(void) __init;
> void smcd_cdc_rx_init(struct smc_connection *conn);
> +void smcd_cdc_rx_handler(struct smc_connection *conn);
>
> #endif /* SMC_CDC_H */
> diff --git a/net/smc/smc_ism.h b/net/smc/smc_ism.h
> index 14d2e77..d18c50a 100644
> --- a/net/smc/smc_ism.h
> +++ b/net/smc/smc_ism.h
> @@ -15,6 +15,8 @@
>
> #include "smc.h"
>
> +#define S390_ISM_IDENT_MASK 0x00FFFF
nit: I think GENMASK is appropriate here.
> +
> struct smcd_dev_list { /* List of SMCD devices */
> struct list_head list;
> struct mutex mutex; /* Protects list of devices */
...
^ permalink raw reply [flat|nested] 17+ messages in thread
* Re: [RFC PATCH net-next v5 5/9] net/smc: Introduce an interface for getting DMB attribute
2023-04-23 12:17 ` [RFC PATCH net-next v5 5/9] net/smc: Introduce an interface for getting DMB attribute Wen Gu
@ 2023-04-28 15:08 ` Simon Horman
0 siblings, 0 replies; 17+ messages in thread
From: Simon Horman @ 2023-04-28 15:08 UTC (permalink / raw)
To: Wen Gu
Cc: kgraul, wenjia, jaka, davem, edumazet, kuba, pabeni, linux-s390,
netdev, linux-kernel
On Sun, Apr 23, 2023 at 08:17:47PM +0800, Wen Gu wrote:
> On s390, since all OSs run on a kind of machine level hypervisor which
> is a partitioning hypervisor without paging, the sndbufs and DMBs in
> such case are unable to be mapped to the same physical memory.
>
> However, in other scene, such as communication within the same OS instance
> (loopback) or between guests of a paging hypervisor (eg. KVM), the sndbufs
> and DMBs can be mapped to the same physical memory to avoid memory copy
> from sndbufs to DMBs.
>
> So this patch introduces an interface to smcd_ops for users to judge
> whether DMB-map is available. And for reuse, the interface is designed
> to return DMB attribute, not only mappability.
>
> Signed-off-by: Wen Gu <guwen@linux.alibaba.com>
...
> diff --git a/net/smc/smc_ism.c b/net/smc/smc_ism.c
> index 8ad4c71..1d97e77 100644
> --- a/net/smc/smc_ism.c
> +++ b/net/smc/smc_ism.c
> @@ -213,6 +213,14 @@ int smc_ism_unregister_dmb(struct smcd_dev *smcd, struct smc_buf_desc *dmb_desc)
> return rc;
> }
>
> +bool smc_ism_dmb_mappable(struct smcd_dev *smcd)
> +{
> + if (smcd->ops->get_dev_dmb_attr &&
> + (smcd->ops->get_dev_dmb_attr(smcd) & (1 << ISM_DMB_MAPPABLE)))
nit: this could use BIT(ISM_DMB_MAPPABLE)
> + return true;
> + return false;
> +}
> +
> int smc_ism_register_dmb(struct smc_link_group *lgr, int dmb_len,
> struct smc_buf_desc *dmb_desc)
> {
...
^ permalink raw reply [flat|nested] 17+ messages in thread
* Re: [RFC PATCH net-next v5 2/9] net/smc: Decouple ism_dev from SMC-D DMB registration
2023-04-28 14:40 ` Simon Horman
@ 2023-05-04 6:22 ` Wen Gu
0 siblings, 0 replies; 17+ messages in thread
From: Wen Gu @ 2023-05-04 6:22 UTC (permalink / raw)
To: Simon Horman
Cc: kgraul, wenjia, jaka, davem, edumazet, kuba, pabeni, linux-s390,
netdev, linux-kernel
On 2023/4/28 22:40, Simon Horman wrote:
> On Sun, Apr 23, 2023 at 08:17:44PM +0800, Wen Gu wrote:
>> This patch tries to decouple ISM device from SMC-D DMB registration,
>> So that the register_dmb option is not restricted to be used by ISM
>> device.
>>
>> Signed-off-by: Wen Gu <guwen@linux.alibaba.com>
>> ---
>> drivers/s390/net/ism_drv.c | 5 +++--
>> include/net/smc.h | 4 ++--
>> net/smc/smc_ism.c | 7 ++-----
>> 3 files changed, 7 insertions(+), 9 deletions(-)
>>
>> diff --git a/drivers/s390/net/ism_drv.c b/drivers/s390/net/ism_drv.c
>> index 8acb9eb..5eeb54d 100644
>> --- a/drivers/s390/net/ism_drv.c
>> +++ b/drivers/s390/net/ism_drv.c
>> @@ -796,9 +796,10 @@ static int smcd_query_rgid(struct smcd_dev *smcd, u64 rgid, u32 vid_valid,
>> }
>>
>> static int smcd_register_dmb(struct smcd_dev *smcd, struct smcd_dmb *dmb,
>> - struct ism_client *client)
>> + void *client_priv)
>> {
>> - return ism_register_dmb(smcd->priv, (struct ism_dmb *)dmb, client);
>> + return ism_register_dmb(smcd->priv, (struct ism_dmb *)dmb,
>> + (struct ism_client *)client_priv);
>
> Hi Wen Gu,
>
> a minor nit from my side: there is no need to cast a void pointer to
> another type.
>
>> }
>>
>> static int smcd_unregister_dmb(struct smcd_dev *smcd, struct smcd_dmb *dmb)
>
> ...
Hi Simon Horman,
Thanks for your review and suggestions in this patch and others.
I will take them in the next version.
Thanks!
Wen Gu
^ permalink raw reply [flat|nested] 17+ messages in thread
* Re: [RFC PATCH net-next v5 0/9] net/smc: Introduce SMC-D-based OS internal communication acceleration
2023-04-23 12:17 [RFC PATCH net-next v5 0/9] net/smc: Introduce SMC-D-based OS internal communication acceleration Wen Gu
` (8 preceding siblings ...)
2023-04-23 12:17 ` [RFC PATCH net-next v5 9/9] net/smc: Add interface implementation of loopback device Wen Gu
@ 2023-05-10 2:02 ` Wen Gu
2023-05-10 9:56 ` Jan Karcher
9 siblings, 1 reply; 17+ messages in thread
From: Wen Gu @ 2023-05-10 2:02 UTC (permalink / raw)
To: kgraul, wenjia, jaka, davem, edumazet, kuba, pabeni
Cc: linux-s390, netdev, linux-kernel, Alexandra Winter
Hi Wenjia & Jan:
Does this version work fine on your platform?
And any comments on this version? :)
Best regards,
Wen Gu
On 2023/4/23 20:17, Wen Gu wrote:
> Hi, all
>
> # Background
>
> The background and previous discussion can be referred from [1]~[3].
>
> We found SMC-D can be used to accelerate OS internal communication, such as
> loopback or between two containers within the same OS instance. So this patch
> set provides a kind of SMC-D dummy device (we call it the SMC-D loopback device)
> to emulate an ISM device, so that SMC-D can also be used on architectures
> other than s390. The SMC-D loopback device are designed as a system global
> device, visible to all containers.
>
> # Design
>
> This patch set basically follows the design of the previous version.
>
> Patch #1/9 ~ #3/9 attempt to decouple ISM-related structures from the SMC-D
> generalized code and extract some helpers to make SMC-D protocol compatible
> with devices other than s390 ISM device.
>
> Patch #4/9 introduces a kind of loopback device, which is defined as SMC-Dv2
> device and designed to provide communication between SMC sockets on the same
> OS instance.
>
> +-------------------------------------------+
> | +--------------+ +--------------+ |
> | | SMC socket A | | SMC socket B | |
> | +--------------+ +--------------+ |
> | ^ ^ |
> | | +----------------+ | |
> | | | SMC stack | | |
> | +--->| +------------+ |<--| |
> | | | dummy | | |
> | | | device | | |
> | +-+------------+-+ |
> | OS |
> +-------------------------------------------+
>
> Patch #5/9 ~ #8/9 expand SMC-D protocol interface (smcd_ops) for scenarios where
> SMC-D is used to communicate within VM (loopback here) or between VMs on the same
> host (based on virtio-ism device, see [4]). What these scenarios have in common
> is that the local sndbuf and peer RMB can be mapped to same physical memory region,
> so the data copy between the local sndbuf and peer RMB can be omitted. Performance
> improvement brought by this extension can be found in # Benchmark Test.
>
> +----------+ +----------+
> | socket A | | socket B |
> +----------+ +----------+
> | ^
> | +---------+ |
> regard as | | ----------|
> local sndbuf | B's | regard as
> | | RMB | local RMB
> |-------> | |
> +---------+
>
> Patch #9/9 realizes the support of loopback device for the above-mentioned expanded
> SMC-D protocol interface.
>
> # Benchmark Test
>
> * Test environments:
> - VM with Intel Xeon Platinum 8 core 2.50GHz, 16 GiB mem.
> - SMC sndbuf/RMB size 1MB.
>
> * Test object:
> - TCP lo: run on TCP loopback.
> - domain: run on UNIX domain.
> - SMC lo: run on SMC loopback device with patch #1/9 ~ #4/9.
> - SMC lo-nocpy: run on SMC loopback device with patch #1/9 ~ #9/9.
>
> 1. ipc-benchmark (see [5])
>
> - ./<foo> -c 1000000 -s 100
>
> TCP-lo domain SMC-lo SMC-lo-nocpy
> Message
> rate (msg/s) 79025 115736(+46.45%) 146760(+85.71%) 149800(+89.56%)
>
> 2. sockperf
>
> - serv: <smc_run> taskset -c <cpu> sockperf sr --tcp
> - clnt: <smc_run> taskset -c <cpu> sockperf { tp | pp } --tcp --msg-size={ 64000 for tp | 14 for pp } -i 127.0.0.1 -t 30
>
> TCP-lo SMC-lo SMC-lo-nocpy
> Bandwidth(MBps) 4822.388 4940.918(+2.56%) 8086.67(+67.69%)
> Latency(us) 6.298 3.352(-46.78%) 3.35(-46.81%)
>
> 3. iperf3
>
> - serv: <smc_run> taskset -c <cpu> iperf3 -s
> - clnt: <smc_run> taskset -c <cpu> iperf3 -c 127.0.0.1 -t 15
>
> TCP-lo SMC-lo SMC-lo-nocpy
> Bitrate(Gb/s) 40.7 40.5(-0.49%) 72.4(+77.89%)
>
> 4. nginx/wrk
>
> - serv: <smc_run> nginx
> - clnt: <smc_run> wrk -t 8 -c 500 -d 30 http://127.0.0.1:80
>
> TCP-lo SMC-lo SMC-lo-nocpy
> Requests/s 155994.57 214544.79(+37.53%) 215538.55(+38.17%)
>
>
> v5->v4
> 1. The loopback device generates SEID in the same way as the ISM devices when coexisting
> with ISM devices and uses a default fixed SEID in other cases.
> 2. Ensure each DMB token of the same loopback device is unique.
> 3. Fixe a crash caused by setting smcd_ops->signal_event interface to NULL.
> 4. Fixe a compilation warning complained by kernel test rebot.
>
> v4->v3
> 1. Rebase to the latest net-next;
> 2. Introduce SEID helper. SMC-D loopback will return SMCD_DEFAULT_V2_SEID. And if it
> coexist with ISM device, the SEID of ISM device will overwrite SMCD_DEFAULT_V2_SEID
> as smc_ism_v2_system_eid.
> 3. Won't remove dmb_node from hashtable until no sndbuf attaching to it.
>
> Something postponed in this version
> 1. Hierarchy perference of SMC-D devices when loopback and ISM devices coexist, which
> will be determinated after comparing the performance of loopback and ISM.
>
> v3->v2
> 1. Adapt new generalized interface provided by [2];
> 2. Select loopback device through SMC-D v2 protocol;
> 3. Split the loopback-related implementation and generic implementation into different
> patches more reasonably.
>
> v1->v2
> 1. Fix some build WARNINGs complained by kernel test rebot
> Reported-by: kernel test robot <lkp@intel.com>
> 2. Add iperf3 test data.
>
>
> [1] https://lore.kernel.org/netdev/1671506505-104676-1-git-send-email-guwen@linux.alibaba.com/
> [2] https://lore.kernel.org/netdev/1676477905-88043-1-git-send-email-guwen@linux.alibaba.com/
> [3] https://lore.kernel.org/netdev/1679887699-54797-1-git-send-email-guwen@linux.alibaba.com/
> [4] https://lore.kernel.org/all/20230209033056.96657-1-xuanzhuo@linux.alibaba.com/
> [5] https://github.com/goldsborough/ipc-bench
>
>
>
> Wen Gu (9):
> net/smc: Decouple ism_dev from SMC-D device dump
> net/smc: Decouple ism_dev from SMC-D DMB registration
> net/smc: Extract v2 check helper from SMC-D device registration
> net/smc: Introduce SMC-D loopback device
> net/smc: Introduce an interface for getting DMB attribute
> net/smc: Introudce interfaces for DMB attach and detach
> net/smc: Avoid data copy from sndbuf to peer RMB in SMC-D
> net/smc: Modify cursor update logic when using mappable DMB
> net/smc: Add interface implementation of loopback device
>
> drivers/s390/net/ism_drv.c | 5 +-
> include/net/smc.h | 18 +-
> net/smc/Makefile | 2 +-
> net/smc/af_smc.c | 26 ++-
> net/smc/smc_cdc.c | 59 ++++--
> net/smc/smc_cdc.h | 1 +
> net/smc/smc_core.c | 70 ++++++-
> net/smc/smc_core.h | 1 +
> net/smc/smc_ism.c | 79 ++++++--
> net/smc/smc_ism.h | 6 +
> net/smc/smc_loopback.c | 491 +++++++++++++++++++++++++++++++++++++++++++++
> net/smc/smc_loopback.h | 56 ++++++
> 12 files changed, 777 insertions(+), 37 deletions(-)
> create mode 100644 net/smc/smc_loopback.c
> create mode 100644 net/smc/smc_loopback.h
>
^ permalink raw reply [flat|nested] 17+ messages in thread
* Re: [RFC PATCH net-next v5 0/9] net/smc: Introduce SMC-D-based OS internal communication acceleration
2023-05-10 2:02 ` [RFC PATCH net-next v5 0/9] net/smc: Introduce SMC-D-based OS internal communication acceleration Wen Gu
@ 2023-05-10 9:56 ` Jan Karcher
2023-05-10 11:59 ` Wen Gu
0 siblings, 1 reply; 17+ messages in thread
From: Jan Karcher @ 2023-05-10 9:56 UTC (permalink / raw)
To: Wen Gu, kgraul, wenjia, davem, edumazet, kuba, pabeni
Cc: linux-s390, netdev, linux-kernel, Alexandra Winter
On 10/05/2023 04:02, Wen Gu wrote:
> Hi Wenjia & Jan:
>
> Does this version work fine on your platform?
>
> And any comments on this version? :)
Hi Wen Gu,
as background for the others: IBM & Alibaba are having calls regarding
SMC since Alibaba shows a lot of interest and there is a lot to discuss
(as you may have noticed).
As we have agreed in our calls, the information shared about SMC-D in
specific doesn't make it easy to understand the underlying concepts
(e.g. role of GID, EIDs, DMB tokens, etc.).
That's why one of the next calls is dedicated to explain some of the
concepts in depth to you and see where we can improve our flow of
information to the community in the future.
After that we can go over this RFC with a shared understanding of the
concepts.
Thank you
- Jan
>
>
> Best regards,
> Wen Gu
>
>
> On 2023/4/23 20:17, Wen Gu wrote:
>
>> Hi, all
>>
>> # Background
>>
>> The background and previous discussion can be referred from [1]~[3].
>>
>> We found SMC-D can be used to accelerate OS internal communication,
>> such as
>> loopback or between two containers within the same OS instance. So
>> this patch
>> set provides a kind of SMC-D dummy device (we call it the SMC-D
>> loopback device)
>> to emulate an ISM device, so that SMC-D can also be used on architectures
>> other than s390. The SMC-D loopback device are designed as a system
>> global
>> device, visible to all containers.
>>
>> # Design
>>
>> This patch set basically follows the design of the previous version.
>>
>> Patch #1/9 ~ #3/9 attempt to decouple ISM-related structures from the
>> SMC-D
>> generalized code and extract some helpers to make SMC-D protocol
>> compatible
>> with devices other than s390 ISM device.
>>
>> Patch #4/9 introduces a kind of loopback device, which is defined as
>> SMC-Dv2
>> device and designed to provide communication between SMC sockets on
>> the same
>> OS instance.
>>
>> +-------------------------------------------+
>> | +--------------+ +--------------+ |
>> | | SMC socket A | | SMC socket B | |
>> | +--------------+ +--------------+ |
>> | ^ ^ |
>> | | +----------------+ | |
>> | | | SMC stack | | |
>> | +--->| +------------+ |<--| |
>> | | | dummy | | |
>> | | | device | | |
>> | +-+------------+-+ |
>> | OS |
>> +-------------------------------------------+
>>
>> Patch #5/9 ~ #8/9 expand SMC-D protocol interface (smcd_ops) for
>> scenarios where
>> SMC-D is used to communicate within VM (loopback here) or between VMs
>> on the same
>> host (based on virtio-ism device, see [4]). What these scenarios have
>> in common
>> is that the local sndbuf and peer RMB can be mapped to same physical
>> memory region,
>> so the data copy between the local sndbuf and peer RMB can be omitted.
>> Performance
>> improvement brought by this extension can be found in # Benchmark Test.
>>
>> +----------+ +----------+
>> | socket A | | socket B |
>> +----------+ +----------+
>> | ^
>> | +---------+ |
>> regard as | | ----------|
>> local sndbuf | B's | regard as
>> | | RMB | local RMB
>> |-------> | |
>> +---------+
>>
>> Patch #9/9 realizes the support of loopback device for the
>> above-mentioned expanded
>> SMC-D protocol interface.
>>
>> # Benchmark Test
>>
>> * Test environments:
>> - VM with Intel Xeon Platinum 8 core 2.50GHz, 16 GiB mem.
>> - SMC sndbuf/RMB size 1MB.
>>
>> * Test object:
>> - TCP lo: run on TCP loopback.
>> - domain: run on UNIX domain.
>> - SMC lo: run on SMC loopback device with patch #1/9 ~ #4/9.
>> - SMC lo-nocpy: run on SMC loopback device with patch #1/9 ~ #9/9.
>>
>> 1. ipc-benchmark (see [5])
>>
>> - ./<foo> -c 1000000 -s 100
>>
>> TCP-lo domain
>> SMC-lo SMC-lo-nocpy
>> Message
>> rate (msg/s) 79025 115736(+46.45%)
>> 146760(+85.71%) 149800(+89.56%)
>>
>> 2. sockperf
>>
>> - serv: <smc_run> taskset -c <cpu> sockperf sr --tcp
>> - clnt: <smc_run> taskset -c <cpu> sockperf { tp | pp } --tcp
>> --msg-size={ 64000 for tp | 14 for pp } -i 127.0.0.1 -t 30
>>
>> TCP-lo SMC-lo
>> SMC-lo-nocpy
>> Bandwidth(MBps) 4822.388 4940.918(+2.56%)
>> 8086.67(+67.69%)
>> Latency(us) 6.298 3.352(-46.78%)
>> 3.35(-46.81%)
>>
>> 3. iperf3
>>
>> - serv: <smc_run> taskset -c <cpu> iperf3 -s
>> - clnt: <smc_run> taskset -c <cpu> iperf3 -c 127.0.0.1 -t 15
>>
>> TCP-lo SMC-lo
>> SMC-lo-nocpy
>> Bitrate(Gb/s) 40.7 40.5(-0.49%)
>> 72.4(+77.89%)
>>
>> 4. nginx/wrk
>>
>> - serv: <smc_run> nginx
>> - clnt: <smc_run> wrk -t 8 -c 500 -d 30 http://127.0.0.1:80
>>
>> TCP-lo SMC-lo
>> SMC-lo-nocpy
>> Requests/s 155994.57 214544.79(+37.53%)
>> 215538.55(+38.17%)
>>
>>
>> v5->v4
>> 1. The loopback device generates SEID in the same way as the ISM
>> devices when coexisting
>> with ISM devices and uses a default fixed SEID in other cases.
>> 2. Ensure each DMB token of the same loopback device is unique.
>> 3. Fixe a crash caused by setting smcd_ops->signal_event interface
>> to NULL.
>> 4. Fixe a compilation warning complained by kernel test rebot.
>>
>> v4->v3
>> 1. Rebase to the latest net-next;
>> 2. Introduce SEID helper. SMC-D loopback will return
>> SMCD_DEFAULT_V2_SEID. And if it
>> coexist with ISM device, the SEID of ISM device will overwrite
>> SMCD_DEFAULT_V2_SEID
>> as smc_ism_v2_system_eid.
>> 3. Won't remove dmb_node from hashtable until no sndbuf attaching to
>> it.
>>
>> Something postponed in this version
>> 1. Hierarchy perference of SMC-D devices when loopback and ISM
>> devices coexist, which
>> will be determinated after comparing the performance of loopback
>> and ISM.
>>
>> v3->v2
>> 1. Adapt new generalized interface provided by [2];
>> 2. Select loopback device through SMC-D v2 protocol;
>> 3. Split the loopback-related implementation and generic
>> implementation into different
>> patches more reasonably.
>>
>> v1->v2
>> 1. Fix some build WARNINGs complained by kernel test rebot
>> Reported-by: kernel test robot <lkp@intel.com>
>> 2. Add iperf3 test data.
>>
>>
>> [1]
>> https://lore.kernel.org/netdev/1671506505-104676-1-git-send-email-guwen@linux.alibaba.com/
>> [2]
>> https://lore.kernel.org/netdev/1676477905-88043-1-git-send-email-guwen@linux.alibaba.com/
>> [3]
>> https://lore.kernel.org/netdev/1679887699-54797-1-git-send-email-guwen@linux.alibaba.com/
>> [4]
>> https://lore.kernel.org/all/20230209033056.96657-1-xuanzhuo@linux.alibaba.com/
>> [5] https://github.com/goldsborough/ipc-bench
>>
>>
>>
>> Wen Gu (9):
>> net/smc: Decouple ism_dev from SMC-D device dump
>> net/smc: Decouple ism_dev from SMC-D DMB registration
>> net/smc: Extract v2 check helper from SMC-D device registration
>> net/smc: Introduce SMC-D loopback device
>> net/smc: Introduce an interface for getting DMB attribute
>> net/smc: Introudce interfaces for DMB attach and detach
>> net/smc: Avoid data copy from sndbuf to peer RMB in SMC-D
>> net/smc: Modify cursor update logic when using mappable DMB
>> net/smc: Add interface implementation of loopback device
>>
>> drivers/s390/net/ism_drv.c | 5 +-
>> include/net/smc.h | 18 +-
>> net/smc/Makefile | 2 +-
>> net/smc/af_smc.c | 26 ++-
>> net/smc/smc_cdc.c | 59 ++++--
>> net/smc/smc_cdc.h | 1 +
>> net/smc/smc_core.c | 70 ++++++-
>> net/smc/smc_core.h | 1 +
>> net/smc/smc_ism.c | 79 ++++++--
>> net/smc/smc_ism.h | 6 +
>> net/smc/smc_loopback.c | 491
>> +++++++++++++++++++++++++++++++++++++++++++++
>> net/smc/smc_loopback.h | 56 ++++++
>> 12 files changed, 777 insertions(+), 37 deletions(-)
>> create mode 100644 net/smc/smc_loopback.c
>> create mode 100644 net/smc/smc_loopback.h
>>
^ permalink raw reply [flat|nested] 17+ messages in thread
* Re: [RFC PATCH net-next v5 0/9] net/smc: Introduce SMC-D-based OS internal communication acceleration
2023-05-10 9:56 ` Jan Karcher
@ 2023-05-10 11:59 ` Wen Gu
0 siblings, 0 replies; 17+ messages in thread
From: Wen Gu @ 2023-05-10 11:59 UTC (permalink / raw)
To: Jan Karcher, kgraul, wenjia, davem, edumazet, kuba, pabeni
Cc: linux-s390, netdev, linux-kernel, Alexandra Winter
On 2023/5/10 17:56, Jan Karcher wrote:
> On 10/05/2023 04:02, Wen Gu wrote:
>> Hi Wenjia & Jan:
>>
>> Does this version work fine on your platform?
>>
>> And any comments on this version? :)
>
> Hi Wen Gu,
>
> as background for the others: IBM & Alibaba are having calls regarding SMC since Alibaba shows a lot of interest and
> there is a lot to discuss (as you may have noticed).
>
> As we have agreed in our calls, the information shared about SMC-D in specific doesn't make it easy to understand the
> underlying concepts (e.g. role of GID, EIDs, DMB tokens, etc.).
> That's why one of the next calls is dedicated to explain some of the concepts in depth to you and see where we can
> improve our flow of information to the community in the future.
> After that we can go over this RFC with a shared understanding of the concepts.
>
> Thank you
> - Jan
>
OK, Jan, Let's follow this plan and thank you for organizing this.
Thanks,
Wen Gu
^ permalink raw reply [flat|nested] 17+ messages in thread
end of thread, other threads:[~2023-05-10 11:59 UTC | newest]
Thread overview: 17+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2023-04-23 12:17 [RFC PATCH net-next v5 0/9] net/smc: Introduce SMC-D-based OS internal communication acceleration Wen Gu
2023-04-23 12:17 ` [RFC PATCH net-next v5 1/9] net/smc: Decouple ism_dev from SMC-D device dump Wen Gu
2023-04-23 12:17 ` [RFC PATCH net-next v5 2/9] net/smc: Decouple ism_dev from SMC-D DMB registration Wen Gu
2023-04-28 14:40 ` Simon Horman
2023-05-04 6:22 ` Wen Gu
2023-04-23 12:17 ` [RFC PATCH net-next v5 3/9] net/smc: Extract v2 check helper from SMC-D device registration Wen Gu
2023-04-23 12:17 ` [RFC PATCH net-next v5 4/9] net/smc: Introduce SMC-D loopback device Wen Gu
2023-04-28 14:45 ` Simon Horman
2023-04-23 12:17 ` [RFC PATCH net-next v5 5/9] net/smc: Introduce an interface for getting DMB attribute Wen Gu
2023-04-28 15:08 ` Simon Horman
2023-04-23 12:17 ` [RFC PATCH net-next v5 6/9] net/smc: Introudce interfaces for DMB attach and detach Wen Gu
2023-04-23 12:17 ` [RFC PATCH net-next v5 7/9] net/smc: Avoid data copy from sndbuf to peer RMB in SMC-D Wen Gu
2023-04-23 12:17 ` [RFC PATCH net-next v5 8/9] net/smc: Modify cursor update logic when using mappable DMB Wen Gu
2023-04-23 12:17 ` [RFC PATCH net-next v5 9/9] net/smc: Add interface implementation of loopback device Wen Gu
2023-05-10 2:02 ` [RFC PATCH net-next v5 0/9] net/smc: Introduce SMC-D-based OS internal communication acceleration Wen Gu
2023-05-10 9:56 ` Jan Karcher
2023-05-10 11:59 ` Wen Gu
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).