* [PATCH v3 0/5] Send RPC-on-TCP with one sock_sendmsg() call
@ 2023-07-19 18:30 Chuck Lever
2023-07-19 18:31 ` [PATCH v3 1/5] SUNRPC: Convert svc_tcp_sendmsg to use bio_vecs directly Chuck Lever
` (10 more replies)
0 siblings, 11 replies; 14+ messages in thread
From: Chuck Lever @ 2023-07-19 18:30 UTC (permalink / raw)
To: linux-nfs, netdev; +Cc: Chuck Lever, David Howells, dhowells
After some discussion with David Howells at LSF/MM 2023, we arrived
at a plan to use a single sock_sendmsg() call for transmitting an
RPC message on socket-based transports. This is an initial part of
the transition to support handling folios with file content, but it
has scalability benefits as well.
Initial performance benchmark results show 5-10% throughput gains
with a fast link layer and a tmpfs export. I've added some other
ideas to this series for further discussion -- these have also shown
performance benefits in my testing.
Changes since v2:
* Keep rq_bvec instead of switching to a per-transport bio_vec array
* Remove the cork/uncork logic in svc_tcp_sendto
* Attempt to mitigate wake-up storms when receiving large RPC messages
Changes since RFC:
* Moved xdr_buf-to-bio_vec array helper to generic XDR code
* Added bio_vec array bounds-checking
* Re-ordered patches
---
Chuck Lever (5):
SUNRPC: Convert svc_tcp_sendmsg to use bio_vecs directly
SUNRPC: Send RPC message on TCP with a single sock_sendmsg() call
SUNRPC: Convert svc_udp_sendto() to use the per-socket bio_vec array
SUNRPC: Revert e0a912e8ddba
SUNRPC: Reduce thread wake-up rate when receiving large RPC messages
include/linux/sunrpc/svcsock.h | 4 +-
include/linux/sunrpc/xdr.h | 2 +
net/sunrpc/svcsock.c | 127 +++++++++++++++------------------
net/sunrpc/xdr.c | 50 +++++++++++++
4 files changed, 112 insertions(+), 71 deletions(-)
--
Chuck Lever
^ permalink raw reply [flat|nested] 14+ messages in thread
* [PATCH v3 1/5] SUNRPC: Convert svc_tcp_sendmsg to use bio_vecs directly
2023-07-19 18:30 [PATCH v3 0/5] Send RPC-on-TCP with one sock_sendmsg() call Chuck Lever
@ 2023-07-19 18:31 ` Chuck Lever
2023-07-19 18:31 ` [PATCH v3 2/5] SUNRPC: Send RPC message on TCP with a single sock_sendmsg() call Chuck Lever
` (9 subsequent siblings)
10 siblings, 0 replies; 14+ messages in thread
From: Chuck Lever @ 2023-07-19 18:31 UTC (permalink / raw)
To: linux-nfs, netdev; +Cc: Chuck Lever, dhowells
From: Chuck Lever <chuck.lever@oracle.com>
Add a helper to convert a whole xdr_buf directly into an array of
bio_vecs, then send this array instead of iterating piecemeal over
the xdr_buf containing the outbound RPC message.
Signed-off-by: Chuck Lever <chuck.lever@oracle.com>
---
include/linux/sunrpc/xdr.h | 2 +
net/sunrpc/svcsock.c | 59 +++++++++++++++-----------------------------
net/sunrpc/xdr.c | 50 +++++++++++++++++++++++++++++++++++++
3 files changed, 72 insertions(+), 39 deletions(-)
diff --git a/include/linux/sunrpc/xdr.h b/include/linux/sunrpc/xdr.h
index f89ec4b5ea16..42f9d7eb9a1a 100644
--- a/include/linux/sunrpc/xdr.h
+++ b/include/linux/sunrpc/xdr.h
@@ -139,6 +139,8 @@ void xdr_terminate_string(const struct xdr_buf *, const u32);
size_t xdr_buf_pagecount(const struct xdr_buf *buf);
int xdr_alloc_bvec(struct xdr_buf *buf, gfp_t gfp);
void xdr_free_bvec(struct xdr_buf *buf);
+unsigned int xdr_buf_to_bvec(struct bio_vec *bvec, unsigned int bvec_size,
+ const struct xdr_buf *xdr);
static inline __be32 *xdr_encode_array(__be32 *p, const void *s, unsigned int len)
{
diff --git a/net/sunrpc/svcsock.c b/net/sunrpc/svcsock.c
index e43f26382411..90b1ab95c223 100644
--- a/net/sunrpc/svcsock.c
+++ b/net/sunrpc/svcsock.c
@@ -36,6 +36,8 @@
#include <linux/skbuff.h>
#include <linux/file.h>
#include <linux/freezer.h>
+#include <linux/bvec.h>
+
#include <net/sock.h>
#include <net/checksum.h>
#include <net/ip.h>
@@ -1194,72 +1196,52 @@ static int svc_tcp_recvfrom(struct svc_rqst *rqstp)
return 0; /* record not complete */
}
-static int svc_tcp_send_kvec(struct socket *sock, const struct kvec *vec,
- int flags)
-{
- struct msghdr msg = { .msg_flags = MSG_SPLICE_PAGES | flags, };
-
- iov_iter_kvec(&msg.msg_iter, ITER_SOURCE, vec, 1, vec->iov_len);
- return sock_sendmsg(sock, &msg);
-}
-
/*
* MSG_SPLICE_PAGES is used exclusively to reduce the number of
* copy operations in this path. Therefore the caller must ensure
* that the pages backing @xdr are unchanging.
*
- * In addition, the logic assumes that * .bv_len is never larger
- * than PAGE_SIZE.
+ * Note that the send is non-blocking. The caller has incremented
+ * the reference count on each page backing the RPC message, and
+ * the network layer will "put" these pages when transmission is
+ * complete.
+ *
+ * This is safe for our RPC services because the memory backing
+ * the head and tail components is never kmalloc'd. These always
+ * come from pages in the svc_rqst::rq_pages array.
*/
-static int svc_tcp_sendmsg(struct socket *sock, struct xdr_buf *xdr,
+static int svc_tcp_sendmsg(struct svc_sock *svsk, struct svc_rqst *rqstp,
rpc_fraghdr marker, unsigned int *sentp)
{
- const struct kvec *head = xdr->head;
- const struct kvec *tail = xdr->tail;
struct kvec rm = {
.iov_base = &marker,
.iov_len = sizeof(marker),
};
struct msghdr msg = {
- .msg_flags = 0,
+ .msg_flags = MSG_MORE,
};
+ unsigned int count;
int ret;
*sentp = 0;
- ret = xdr_alloc_bvec(xdr, GFP_KERNEL);
- if (ret < 0)
- return ret;
- ret = kernel_sendmsg(sock, &msg, &rm, 1, rm.iov_len);
+ ret = kernel_sendmsg(svsk->sk_sock, &msg, &rm, 1, rm.iov_len);
if (ret < 0)
return ret;
*sentp += ret;
if (ret != rm.iov_len)
return -EAGAIN;
- ret = svc_tcp_send_kvec(sock, head, 0);
- if (ret < 0)
- return ret;
- *sentp += ret;
- if (ret != head->iov_len)
- goto out;
+ count = xdr_buf_to_bvec(rqstp->rq_bvec, ARRAY_SIZE(rqstp->rq_bvec),
+ &rqstp->rq_res);
msg.msg_flags = MSG_SPLICE_PAGES;
- iov_iter_bvec(&msg.msg_iter, ITER_SOURCE, xdr->bvec,
- xdr_buf_pagecount(xdr), xdr->page_len);
- ret = sock_sendmsg(sock, &msg);
+ iov_iter_bvec(&msg.msg_iter, ITER_SOURCE, rqstp->rq_bvec,
+ count, rqstp->rq_res.len);
+ ret = sock_sendmsg(svsk->sk_sock, &msg);
if (ret < 0)
return ret;
*sentp += ret;
-
- if (tail->iov_len) {
- ret = svc_tcp_send_kvec(sock, tail, 0);
- if (ret < 0)
- return ret;
- *sentp += ret;
- }
-
-out:
return 0;
}
@@ -1290,8 +1272,7 @@ static int svc_tcp_sendto(struct svc_rqst *rqstp)
if (svc_xprt_is_dead(xprt))
goto out_notconn;
tcp_sock_set_cork(svsk->sk_sk, true);
- err = svc_tcp_sendmsg(svsk->sk_sock, xdr, marker, &sent);
- xdr_free_bvec(xdr);
+ err = svc_tcp_sendmsg(svsk, rqstp, marker, &sent);
trace_svcsock_tcp_send(xprt, err < 0 ? (long)err : sent);
if (err < 0 || sent != (xdr->len + sizeof(marker)))
goto out_close;
diff --git a/net/sunrpc/xdr.c b/net/sunrpc/xdr.c
index 2a22e78af116..358e6de91775 100644
--- a/net/sunrpc/xdr.c
+++ b/net/sunrpc/xdr.c
@@ -164,6 +164,56 @@ xdr_free_bvec(struct xdr_buf *buf)
buf->bvec = NULL;
}
+/**
+ * xdr_buf_to_bvec - Copy components of an xdr_buf into a bio_vec array
+ * @bvec: bio_vec array to populate
+ * @bvec_size: element count of @bio_vec
+ * @xdr: xdr_buf to be copied
+ *
+ * Returns the number of entries consumed in @bvec.
+ */
+unsigned int xdr_buf_to_bvec(struct bio_vec *bvec, unsigned int bvec_size,
+ const struct xdr_buf *xdr)
+{
+ const struct kvec *head = xdr->head;
+ const struct kvec *tail = xdr->tail;
+ unsigned int count = 0;
+
+ if (head->iov_len) {
+ bvec_set_virt(bvec++, head->iov_base, head->iov_len);
+ ++count;
+ }
+
+ if (xdr->page_len) {
+ unsigned int offset, len, remaining;
+ struct page **pages = xdr->pages;
+
+ offset = offset_in_page(xdr->page_base);
+ remaining = xdr->page_len;
+ while (remaining > 0) {
+ len = min_t(unsigned int, remaining,
+ PAGE_SIZE - offset);
+ bvec_set_page(bvec++, *pages++, len, offset);
+ remaining -= len;
+ offset = 0;
+ if (unlikely(++count > bvec_size))
+ goto bvec_overflow;
+ }
+ }
+
+ if (tail->iov_len) {
+ bvec_set_virt(bvec, tail->iov_base, tail->iov_len);
+ if (unlikely(++count > bvec_size))
+ goto bvec_overflow;
+ }
+
+ return count;
+
+bvec_overflow:
+ pr_warn_once("%s: bio_vec array overflow\n", __func__);
+ return count - 1;
+}
+
/**
* xdr_inline_pages - Prepare receive buffer for a large reply
* @xdr: xdr_buf into which reply will be placed
^ permalink raw reply related [flat|nested] 14+ messages in thread
* [PATCH v3 2/5] SUNRPC: Send RPC message on TCP with a single sock_sendmsg() call
2023-07-19 18:30 [PATCH v3 0/5] Send RPC-on-TCP with one sock_sendmsg() call Chuck Lever
2023-07-19 18:31 ` [PATCH v3 1/5] SUNRPC: Convert svc_tcp_sendmsg to use bio_vecs directly Chuck Lever
@ 2023-07-19 18:31 ` Chuck Lever
2023-07-19 18:31 ` [PATCH v3 3/5] SUNRPC: Convert svc_udp_sendto() to use the per-socket bio_vec array Chuck Lever
` (8 subsequent siblings)
10 siblings, 0 replies; 14+ messages in thread
From: Chuck Lever @ 2023-07-19 18:31 UTC (permalink / raw)
To: linux-nfs, netdev; +Cc: David Howells, Chuck Lever, dhowells
From: Chuck Lever <chuck.lever@oracle.com>
There is now enough infrastructure in place to combine the stream
record marker into the biovec array used to send each outgoing RPC
message on TCP. The whole message can be more efficiently sent with
a single call to sock_sendmsg() using a bio_vec iterator.
Note that this also helps with RPC-with-TLS: the TLS implementation
can now clearly see where the upper layer message boundaries are.
Before, it would send each component of the xdr_buf (record marker,
head, page payload, tail) in separate TLS records.
Suggested-by: David Howells <dhowells@redhat.com>
Signed-off-by: Chuck Lever <chuck.lever@oracle.com>
---
include/linux/sunrpc/svcsock.h | 2 ++
net/sunrpc/svcsock.c | 33 ++++++++++++++++++---------------
2 files changed, 20 insertions(+), 15 deletions(-)
diff --git a/include/linux/sunrpc/svcsock.h b/include/linux/sunrpc/svcsock.h
index a7116048a4d4..caf3308f1f07 100644
--- a/include/linux/sunrpc/svcsock.h
+++ b/include/linux/sunrpc/svcsock.h
@@ -38,6 +38,8 @@ struct svc_sock {
/* Number of queued send requests */
atomic_t sk_sendqlen;
+ struct page_frag_cache sk_frag_cache;
+
struct completion sk_handshake_done;
struct page * sk_pages[RPCSVC_MAXPAGES]; /* received data */
diff --git a/net/sunrpc/svcsock.c b/net/sunrpc/svcsock.c
index 90b1ab95c223..d4d816036c04 100644
--- a/net/sunrpc/svcsock.c
+++ b/net/sunrpc/svcsock.c
@@ -1213,31 +1213,30 @@ static int svc_tcp_recvfrom(struct svc_rqst *rqstp)
static int svc_tcp_sendmsg(struct svc_sock *svsk, struct svc_rqst *rqstp,
rpc_fraghdr marker, unsigned int *sentp)
{
- struct kvec rm = {
- .iov_base = &marker,
- .iov_len = sizeof(marker),
- };
struct msghdr msg = {
- .msg_flags = MSG_MORE,
+ .msg_flags = MSG_SPLICE_PAGES,
};
unsigned int count;
+ void *buf;
int ret;
*sentp = 0;
- ret = kernel_sendmsg(svsk->sk_sock, &msg, &rm, 1, rm.iov_len);
- if (ret < 0)
- return ret;
- *sentp += ret;
- if (ret != rm.iov_len)
- return -EAGAIN;
+ /* The stream record marker is copied into a temporary page
+ * fragment buffer so that it can be included in rq_bvec.
+ */
+ buf = page_frag_alloc(&svsk->sk_frag_cache, sizeof(marker),
+ GFP_KERNEL);
+ if (!buf)
+ return -ENOMEM;
+ memcpy(buf, &marker, sizeof(marker));
+ bvec_set_virt(rqstp->rq_bvec, buf, sizeof(marker));
- count = xdr_buf_to_bvec(rqstp->rq_bvec, ARRAY_SIZE(rqstp->rq_bvec),
- &rqstp->rq_res);
+ count = xdr_buf_to_bvec(rqstp->rq_bvec + 1,
+ ARRAY_SIZE(rqstp->rq_bvec) - 1, &rqstp->rq_res);
- msg.msg_flags = MSG_SPLICE_PAGES;
iov_iter_bvec(&msg.msg_iter, ITER_SOURCE, rqstp->rq_bvec,
- count, rqstp->rq_res.len);
+ 1 + count, sizeof(marker) + rqstp->rq_res.len);
ret = sock_sendmsg(svsk->sk_sock, &msg);
if (ret < 0)
return ret;
@@ -1616,6 +1615,7 @@ static void svc_tcp_sock_detach(struct svc_xprt *xprt)
static void svc_sock_free(struct svc_xprt *xprt)
{
struct svc_sock *svsk = container_of(xprt, struct svc_sock, sk_xprt);
+ struct page_frag_cache *pfc = &svsk->sk_frag_cache;
struct socket *sock = svsk->sk_sock;
trace_svcsock_free(svsk, sock);
@@ -1625,5 +1625,8 @@ static void svc_sock_free(struct svc_xprt *xprt)
sockfd_put(sock);
else
sock_release(sock);
+ if (pfc->va)
+ __page_frag_cache_drain(virt_to_head_page(pfc->va),
+ pfc->pagecnt_bias);
kfree(svsk);
}
^ permalink raw reply related [flat|nested] 14+ messages in thread
* [PATCH v3 3/5] SUNRPC: Convert svc_udp_sendto() to use the per-socket bio_vec array
2023-07-19 18:30 [PATCH v3 0/5] Send RPC-on-TCP with one sock_sendmsg() call Chuck Lever
2023-07-19 18:31 ` [PATCH v3 1/5] SUNRPC: Convert svc_tcp_sendmsg to use bio_vecs directly Chuck Lever
2023-07-19 18:31 ` [PATCH v3 2/5] SUNRPC: Send RPC message on TCP with a single sock_sendmsg() call Chuck Lever
@ 2023-07-19 18:31 ` Chuck Lever
2023-07-19 18:31 ` [PATCH v3 4/5] SUNRPC: Revert e0a912e8ddba Chuck Lever
` (7 subsequent siblings)
10 siblings, 0 replies; 14+ messages in thread
From: Chuck Lever @ 2023-07-19 18:31 UTC (permalink / raw)
To: linux-nfs, netdev; +Cc: Chuck Lever, dhowells
From: Chuck Lever <chuck.lever@oracle.com>
Commit da1661b93bf4 ("SUNRPC: Teach server to use xprt_sock_sendmsg
for socket sends") modified svc_udp_sendto() to use xprt_sock_sendmsg()
because we originally believed xprt_sock_sendmsg() would be needed
for TLS support. That does not actually appear to be the case.
In addition, the linkage between the client and server send code has
been a bit of a maintenance headache because of the distinct ways
that the client and server handle memory allocation.
Going forward, eventually the XDR layer will deal with its buffers
in the form of bio_vec arrays, so convert this function accordingly.
Signed-off-by: Chuck Lever <chuck.lever@oracle.com>
---
net/sunrpc/svcsock.c | 23 ++++++++++++-----------
1 file changed, 12 insertions(+), 11 deletions(-)
diff --git a/net/sunrpc/svcsock.c b/net/sunrpc/svcsock.c
index d4d816036c04..f28790f282c2 100644
--- a/net/sunrpc/svcsock.c
+++ b/net/sunrpc/svcsock.c
@@ -695,7 +695,7 @@ static int svc_udp_sendto(struct svc_rqst *rqstp)
.msg_control = cmh,
.msg_controllen = sizeof(buffer),
};
- unsigned int sent;
+ unsigned int count;
int err;
svc_udp_release_ctxt(xprt, rqstp->rq_xprt_ctxt);
@@ -708,22 +708,23 @@ static int svc_udp_sendto(struct svc_rqst *rqstp)
if (svc_xprt_is_dead(xprt))
goto out_notconn;
- err = xdr_alloc_bvec(xdr, GFP_KERNEL);
- if (err < 0)
- goto out_unlock;
+ count = xdr_buf_to_bvec(rqstp->rq_bvec,
+ ARRAY_SIZE(rqstp->rq_bvec), xdr);
- err = xprt_sock_sendmsg(svsk->sk_sock, &msg, xdr, 0, 0, &sent);
+ iov_iter_bvec(&msg.msg_iter, ITER_SOURCE, rqstp->rq_bvec,
+ count, 0);
+ err = sock_sendmsg(svsk->sk_sock, &msg);
if (err == -ECONNREFUSED) {
/* ICMP error on earlier request. */
- err = xprt_sock_sendmsg(svsk->sk_sock, &msg, xdr, 0, 0, &sent);
+ iov_iter_bvec(&msg.msg_iter, ITER_SOURCE, rqstp->rq_bvec,
+ count, 0);
+ err = sock_sendmsg(svsk->sk_sock, &msg);
}
- xdr_free_bvec(xdr);
+
trace_svcsock_udp_send(xprt, err);
-out_unlock:
+
mutex_unlock(&xprt->xpt_mutex);
- if (err < 0)
- return err;
- return sent;
+ return err;
out_notconn:
mutex_unlock(&xprt->xpt_mutex);
^ permalink raw reply related [flat|nested] 14+ messages in thread
* [PATCH v3 4/5] SUNRPC: Revert e0a912e8ddba
2023-07-19 18:30 [PATCH v3 0/5] Send RPC-on-TCP with one sock_sendmsg() call Chuck Lever
` (2 preceding siblings ...)
2023-07-19 18:31 ` [PATCH v3 3/5] SUNRPC: Convert svc_udp_sendto() to use the per-socket bio_vec array Chuck Lever
@ 2023-07-19 18:31 ` Chuck Lever
2023-07-19 18:31 ` [PATCH v3 5/5] SUNRPC: Reduce thread wake-up rate when receiving large RPC messages Chuck Lever
` (6 subsequent siblings)
10 siblings, 0 replies; 14+ messages in thread
From: Chuck Lever @ 2023-07-19 18:31 UTC (permalink / raw)
To: linux-nfs, netdev; +Cc: Chuck Lever, dhowells
From: Chuck Lever <chuck.lever@oracle.com>
Flamegraph analysis showed that the cork/uncork calls consume
nearly a third of the CPU time spent in svc_tcp_sendto(). The
other two consumers are mutex lock/unlock and svc_tcp_sendmsg().
Now that svc_tcp_sendto() coalesces RPC messages properly, there
is no need to introduce artificial delays to prevent sending
partial messages.
After applying this change, I measured a 1.2K read IOPS increase
for 8KB random I/O (several percent) on 56Gb IP over IB.
Signed-off-by: Chuck Lever <chuck.lever@oracle.com>
---
include/linux/sunrpc/svcsock.h | 2 --
net/sunrpc/svcsock.c | 6 ------
2 files changed, 8 deletions(-)
diff --git a/include/linux/sunrpc/svcsock.h b/include/linux/sunrpc/svcsock.h
index caf3308f1f07..a7ea54460b1a 100644
--- a/include/linux/sunrpc/svcsock.h
+++ b/include/linux/sunrpc/svcsock.h
@@ -35,8 +35,6 @@ struct svc_sock {
/* Total length of the data (not including fragment headers)
* received so far in the fragments making up this rpc: */
u32 sk_datalen;
- /* Number of queued send requests */
- atomic_t sk_sendqlen;
struct page_frag_cache sk_frag_cache;
diff --git a/net/sunrpc/svcsock.c b/net/sunrpc/svcsock.c
index f28790f282c2..7b7358908a21 100644
--- a/net/sunrpc/svcsock.c
+++ b/net/sunrpc/svcsock.c
@@ -1267,22 +1267,17 @@ static int svc_tcp_sendto(struct svc_rqst *rqstp)
svc_tcp_release_ctxt(xprt, rqstp->rq_xprt_ctxt);
rqstp->rq_xprt_ctxt = NULL;
- atomic_inc(&svsk->sk_sendqlen);
mutex_lock(&xprt->xpt_mutex);
if (svc_xprt_is_dead(xprt))
goto out_notconn;
- tcp_sock_set_cork(svsk->sk_sk, true);
err = svc_tcp_sendmsg(svsk, rqstp, marker, &sent);
trace_svcsock_tcp_send(xprt, err < 0 ? (long)err : sent);
if (err < 0 || sent != (xdr->len + sizeof(marker)))
goto out_close;
- if (atomic_dec_and_test(&svsk->sk_sendqlen))
- tcp_sock_set_cork(svsk->sk_sk, false);
mutex_unlock(&xprt->xpt_mutex);
return sent;
out_notconn:
- atomic_dec(&svsk->sk_sendqlen);
mutex_unlock(&xprt->xpt_mutex);
return -ENOTCONN;
out_close:
@@ -1291,7 +1286,6 @@ static int svc_tcp_sendto(struct svc_rqst *rqstp)
(err < 0) ? "got error" : "sent",
(err < 0) ? err : sent, xdr->len);
svc_xprt_deferred_close(xprt);
- atomic_dec(&svsk->sk_sendqlen);
mutex_unlock(&xprt->xpt_mutex);
return -EAGAIN;
}
^ permalink raw reply related [flat|nested] 14+ messages in thread
* [PATCH v3 5/5] SUNRPC: Reduce thread wake-up rate when receiving large RPC messages
2023-07-19 18:30 [PATCH v3 0/5] Send RPC-on-TCP with one sock_sendmsg() call Chuck Lever
` (3 preceding siblings ...)
2023-07-19 18:31 ` [PATCH v3 4/5] SUNRPC: Revert e0a912e8ddba Chuck Lever
@ 2023-07-19 18:31 ` Chuck Lever
2023-07-24 9:58 ` [PATCH v3 2/5] SUNRPC: Send RPC message on TCP with a single sock_sendmsg() call David Howells
` (5 subsequent siblings)
10 siblings, 0 replies; 14+ messages in thread
From: Chuck Lever @ 2023-07-19 18:31 UTC (permalink / raw)
To: linux-nfs, netdev; +Cc: Chuck Lever, dhowells
From: Chuck Lever <chuck.lever@oracle.com>
With large NFS WRITE requests on TCP, I measured 5-10 thread wake-
ups to receive each request. This is because the socket layer
calls ->sk_data_ready() frequently, and each call triggers a
thread wake-up. Each recvmsg() seems to pull in less than 100KB.
Have the socket layer hold ->sk_data_ready() calls until the full
incoming message has arrived to reduce the wake-up rate.
Signed-off-by: Chuck Lever <chuck.lever@oracle.com>
---
net/sunrpc/svcsock.c | 12 +++++++++++-
1 file changed, 11 insertions(+), 1 deletion(-)
diff --git a/net/sunrpc/svcsock.c b/net/sunrpc/svcsock.c
index 7b7358908a21..36e5070132ea 100644
--- a/net/sunrpc/svcsock.c
+++ b/net/sunrpc/svcsock.c
@@ -1088,6 +1088,9 @@ static void svc_tcp_fragment_received(struct svc_sock *svsk)
/* If we have more data, signal svc_xprt_enqueue() to try again */
svsk->sk_tcplen = 0;
svsk->sk_marker = xdr_zero;
+
+ smp_wmb();
+ tcp_set_rcvlowat(svsk->sk_sk, 1);
}
/**
@@ -1177,10 +1180,17 @@ static int svc_tcp_recvfrom(struct svc_rqst *rqstp)
goto err_delete;
if (len == want)
svc_tcp_fragment_received(svsk);
- else
+ else {
+ /* Avoid more ->sk_data_ready() calls until the rest
+ * of the message has arrived. This reduces service
+ * thread wake-ups on large incoming messages. */
+ tcp_set_rcvlowat(svsk->sk_sk,
+ svc_sock_reclen(svsk) - svsk->sk_tcplen);
+
trace_svcsock_tcp_recv_short(&svsk->sk_xprt,
svc_sock_reclen(svsk),
svsk->sk_tcplen - sizeof(rpc_fraghdr));
+ }
goto err_noclose;
error:
if (len != -EAGAIN)
^ permalink raw reply related [flat|nested] 14+ messages in thread
* Re: [PATCH v3 2/5] SUNRPC: Send RPC message on TCP with a single sock_sendmsg() call
2023-07-19 18:30 [PATCH v3 0/5] Send RPC-on-TCP with one sock_sendmsg() call Chuck Lever
` (4 preceding siblings ...)
2023-07-19 18:31 ` [PATCH v3 5/5] SUNRPC: Reduce thread wake-up rate when receiving large RPC messages Chuck Lever
@ 2023-07-24 9:58 ` David Howells
2023-07-24 13:27 ` Chuck Lever
2023-07-26 12:13 ` [PATCH v3 0/5] Send RPC-on-TCP with one " David Howells
` (4 subsequent siblings)
10 siblings, 1 reply; 14+ messages in thread
From: David Howells @ 2023-07-24 9:58 UTC (permalink / raw)
To: Chuck Lever; +Cc: dhowells, linux-nfs, netdev, Chuck Lever
Chuck Lever <cel@kernel.org> wrote:
> + buf = page_frag_alloc(&svsk->sk_frag_cache, sizeof(marker),
> + GFP_KERNEL);
Is this SMP-safe? page_frag_alloc() does no locking.
David
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH v3 2/5] SUNRPC: Send RPC message on TCP with a single sock_sendmsg() call
2023-07-24 9:58 ` [PATCH v3 2/5] SUNRPC: Send RPC message on TCP with a single sock_sendmsg() call David Howells
@ 2023-07-24 13:27 ` Chuck Lever
0 siblings, 0 replies; 14+ messages in thread
From: Chuck Lever @ 2023-07-24 13:27 UTC (permalink / raw)
To: David Howells; +Cc: Chuck Lever, linux-nfs, netdev
On Mon, Jul 24, 2023 at 10:58:50AM +0100, David Howells wrote:
> Chuck Lever <cel@kernel.org> wrote:
>
> > + buf = page_frag_alloc(&svsk->sk_frag_cache, sizeof(marker),
> > + GFP_KERNEL);
>
> Is this SMP-safe? page_frag_alloc() does no locking.
Note that svc_tcp_sendto() takes xprt->xpt_mutex. There can be only
one thread (per svsk) running in svc_tcp_sendmsg() at a time.
--
Chuck Lever
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH v3 0/5] Send RPC-on-TCP with one sock_sendmsg() call
2023-07-19 18:30 [PATCH v3 0/5] Send RPC-on-TCP with one sock_sendmsg() call Chuck Lever
` (5 preceding siblings ...)
2023-07-24 9:58 ` [PATCH v3 2/5] SUNRPC: Send RPC message on TCP with a single sock_sendmsg() call David Howells
@ 2023-07-26 12:13 ` David Howells
2023-07-26 12:13 ` [PATCH v3 1/5] SUNRPC: Convert svc_tcp_sendmsg to use bio_vecs directly David Howells
` (3 subsequent siblings)
10 siblings, 0 replies; 14+ messages in thread
From: David Howells @ 2023-07-26 12:13 UTC (permalink / raw)
To: Chuck Lever; +Cc: dhowells, linux-nfs, netdev, Chuck Lever
Chuck Lever <cel@kernel.org> wrote:
> After some discussion with David Howells at LSF/MM 2023, we arrived
> at a plan to use a single sock_sendmsg() call for transmitting an
> RPC message on socket-based transports. This is an initial part of
> the transition to support handling folios with file content, but it
> has scalability benefits as well.
>
> Initial performance benchmark results show 5-10% throughput gains
> with a fast link layer and a tmpfs export. I've added some other
> ideas to this series for further discussion -- these have also shown
> performance benefits in my testing.
I like it :-)
David
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH v3 1/5] SUNRPC: Convert svc_tcp_sendmsg to use bio_vecs directly
2023-07-19 18:30 [PATCH v3 0/5] Send RPC-on-TCP with one sock_sendmsg() call Chuck Lever
` (6 preceding siblings ...)
2023-07-26 12:13 ` [PATCH v3 0/5] Send RPC-on-TCP with one " David Howells
@ 2023-07-26 12:13 ` David Howells
2023-07-26 12:13 ` [PATCH v3 2/5] SUNRPC: Send RPC message on TCP with a single sock_sendmsg() call David Howells
` (2 subsequent siblings)
10 siblings, 0 replies; 14+ messages in thread
From: David Howells @ 2023-07-26 12:13 UTC (permalink / raw)
To: Chuck Lever; +Cc: dhowells, linux-nfs, netdev, Chuck Lever
Chuck Lever <cel@kernel.org> wrote:
> Add a helper to convert a whole xdr_buf directly into an array of
> bio_vecs, then send this array instead of iterating piecemeal over
> the xdr_buf containing the outbound RPC message.
>
> Signed-off-by: Chuck Lever <chuck.lever@oracle.com>
Reviewed-by: David Howells <dhowells@redhat.com>
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH v3 2/5] SUNRPC: Send RPC message on TCP with a single sock_sendmsg() call
2023-07-19 18:30 [PATCH v3 0/5] Send RPC-on-TCP with one sock_sendmsg() call Chuck Lever
` (7 preceding siblings ...)
2023-07-26 12:13 ` [PATCH v3 1/5] SUNRPC: Convert svc_tcp_sendmsg to use bio_vecs directly David Howells
@ 2023-07-26 12:13 ` David Howells
2023-07-26 12:14 ` [PATCH v3 4/5] SUNRPC: Revert e0a912e8ddba David Howells
2023-07-26 12:15 ` [PATCH v3 3/5] SUNRPC: Convert svc_udp_sendto() to use the per-socket bio_vec array David Howells
10 siblings, 0 replies; 14+ messages in thread
From: David Howells @ 2023-07-26 12:13 UTC (permalink / raw)
To: Chuck Lever; +Cc: dhowells, linux-nfs, netdev, Chuck Lever
Chuck Lever <cel@kernel.org> wrote:
> From: Chuck Lever <chuck.lever@oracle.com>
>
> There is now enough infrastructure in place to combine the stream
> record marker into the biovec array used to send each outgoing RPC
> message on TCP. The whole message can be more efficiently sent with
> a single call to sock_sendmsg() using a bio_vec iterator.
>
> Note that this also helps with RPC-with-TLS: the TLS implementation
> can now clearly see where the upper layer message boundaries are.
> Before, it would send each component of the xdr_buf (record marker,
> head, page payload, tail) in separate TLS records.
>
> Suggested-by: David Howells <dhowells@redhat.com>
> Signed-off-by: Chuck Lever <chuck.lever@oracle.com>
Reviewed-by: David Howells <dhowells@redhat.com>
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH v3 4/5] SUNRPC: Revert e0a912e8ddba
2023-07-19 18:30 [PATCH v3 0/5] Send RPC-on-TCP with one sock_sendmsg() call Chuck Lever
` (8 preceding siblings ...)
2023-07-26 12:13 ` [PATCH v3 2/5] SUNRPC: Send RPC message on TCP with a single sock_sendmsg() call David Howells
@ 2023-07-26 12:14 ` David Howells
2023-07-26 12:15 ` [PATCH v3 3/5] SUNRPC: Convert svc_udp_sendto() to use the per-socket bio_vec array David Howells
10 siblings, 0 replies; 14+ messages in thread
From: David Howells @ 2023-07-26 12:14 UTC (permalink / raw)
To: Chuck Lever; +Cc: dhowells, linux-nfs, netdev, Chuck Lever
Chuck Lever <cel@kernel.org> wrote:
> Flamegraph analysis showed that the cork/uncork calls consume
> nearly a third of the CPU time spent in svc_tcp_sendto(). The
> other two consumers are mutex lock/unlock and svc_tcp_sendmsg().
>
> Now that svc_tcp_sendto() coalesces RPC messages properly, there
> is no need to introduce artificial delays to prevent sending
> partial messages.
>
> After applying this change, I measured a 1.2K read IOPS increase
> for 8KB random I/O (several percent) on 56Gb IP over IB.
>
> Signed-off-by: Chuck Lever <chuck.lever@oracle.com>
Reviewed-by: David Howells <dhowells@redhat.com>
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH v3 3/5] SUNRPC: Convert svc_udp_sendto() to use the per-socket bio_vec array
2023-07-19 18:30 [PATCH v3 0/5] Send RPC-on-TCP with one sock_sendmsg() call Chuck Lever
` (9 preceding siblings ...)
2023-07-26 12:14 ` [PATCH v3 4/5] SUNRPC: Revert e0a912e8ddba David Howells
@ 2023-07-26 12:15 ` David Howells
2023-07-26 13:11 ` Chuck Lever
10 siblings, 1 reply; 14+ messages in thread
From: David Howells @ 2023-07-26 12:15 UTC (permalink / raw)
To: Chuck Lever; +Cc: dhowells, linux-nfs, netdev, Chuck Lever
Should svc_udp_sendto() also be using MSG_SPLICE_PAGES now?
David
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH v3 3/5] SUNRPC: Convert svc_udp_sendto() to use the per-socket bio_vec array
2023-07-26 12:15 ` [PATCH v3 3/5] SUNRPC: Convert svc_udp_sendto() to use the per-socket bio_vec array David Howells
@ 2023-07-26 13:11 ` Chuck Lever
0 siblings, 0 replies; 14+ messages in thread
From: Chuck Lever @ 2023-07-26 13:11 UTC (permalink / raw)
To: David Howells; +Cc: Chuck Lever, linux-nfs, netdev
On Wed, Jul 26, 2023 at 01:15:30PM +0100, David Howells wrote:
> Should svc_udp_sendto() also be using MSG_SPLICE_PAGES now?
Ah. Yes, it should. Will fix.
--
Chuck Lever
^ permalink raw reply [flat|nested] 14+ messages in thread
end of thread, other threads:[~2023-07-26 13:11 UTC | newest]
Thread overview: 14+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2023-07-19 18:30 [PATCH v3 0/5] Send RPC-on-TCP with one sock_sendmsg() call Chuck Lever
2023-07-19 18:31 ` [PATCH v3 1/5] SUNRPC: Convert svc_tcp_sendmsg to use bio_vecs directly Chuck Lever
2023-07-19 18:31 ` [PATCH v3 2/5] SUNRPC: Send RPC message on TCP with a single sock_sendmsg() call Chuck Lever
2023-07-19 18:31 ` [PATCH v3 3/5] SUNRPC: Convert svc_udp_sendto() to use the per-socket bio_vec array Chuck Lever
2023-07-19 18:31 ` [PATCH v3 4/5] SUNRPC: Revert e0a912e8ddba Chuck Lever
2023-07-19 18:31 ` [PATCH v3 5/5] SUNRPC: Reduce thread wake-up rate when receiving large RPC messages Chuck Lever
2023-07-24 9:58 ` [PATCH v3 2/5] SUNRPC: Send RPC message on TCP with a single sock_sendmsg() call David Howells
2023-07-24 13:27 ` Chuck Lever
2023-07-26 12:13 ` [PATCH v3 0/5] Send RPC-on-TCP with one " David Howells
2023-07-26 12:13 ` [PATCH v3 1/5] SUNRPC: Convert svc_tcp_sendmsg to use bio_vecs directly David Howells
2023-07-26 12:13 ` [PATCH v3 2/5] SUNRPC: Send RPC message on TCP with a single sock_sendmsg() call David Howells
2023-07-26 12:14 ` [PATCH v3 4/5] SUNRPC: Revert e0a912e8ddba David Howells
2023-07-26 12:15 ` [PATCH v3 3/5] SUNRPC: Convert svc_udp_sendto() to use the per-socket bio_vec array David Howells
2023-07-26 13:11 ` Chuck Lever
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 read-only IMAP folder(s) and NNTP newsgroup(s).