RDS: zerocopy support
Subsystems (5)
PATCH v3 1/7 skbuff: export mm_[un]account_pinned_pages for other modules
In reply to Sowmini VaradhanRDS would like to use the helper functions for managing pinned pages added by Commit a91dbff551a6 ("sock: ulimit on MSG_ZEROCOPY pages")
--- include/linux/skbuff.h | 3 +++ net/core/skbuff.c | 6 ++++-- 2 files changed, 7 insertions(+), 2 deletions(-)
include/linux/skbuff.h +3 -0
@@ -466,6 +466,9 @@ struct ubuf_info {#define skb_uarg (SKB ) ((struct ubuf_info *)(skb_shinfo(SKB)->destructor_arg)) +int mm_account_pinned_pages (struct mmpin *mmp,size_t size); +void mm_unaccount_pinned_pages (struct mmpin *mmp); +struct ubuf_info *sock_zerocopy_alloc (struct sock *sk,size_t size);struct ubuf_info *sock_zerocopy_realloc (struct sock *sk,size_t size,struct ubuf_info *uarg);
net/core/skbuff.c +4 -2
@@ -890,7 +890,7 @@ struct sk_buff *skb_morph(struct sk_buff *dst, struct sk_buff *src) }EXPORT_SYMBOL_GPL (skb_morph); -static int mm_account_pinned_pages (struct mmpin *mmp,size_t size) +int mm_account_pinned_pages (struct mmpin *mmp,size_t size) {unsigned long max_pg, num_pg, new_pg, old_pg;struct user_struct *user;
@@ -919,14 +919,16 @@ static int mm_account_pinned_pages(struct mmpin *mmp, size_t size)return 0 ; } +EXPORT_SYMBOL_GPL (mm_account_pinned_pages); -static void mm_unaccount_pinned_pages (struct mmpin *mmp) +void mm_unaccount_pinned_pages (struct mmpin *mmp) {if (mmp->user) {atomic_long_sub (mmp->num_pg, &mmp->user->locked_vm);free_uid (mmp->user); } } +EXPORT_SYMBOL_GPL (mm_unaccount_pinned_pages);struct ubuf_info *sock_zerocopy_alloc (struct sock *sk,size_t size) {
Signature · 1 line
1.7.1
PATCH v3 2/7 rds: hold a sock ref from rds_message to the rds_sock
In reply to Sowmini VaradhanThe existing model holds a reference from the rds_sock to the rds_message, but the rds_message does not itself hold a sock_put() on the rds_sock. Instead the m_rs field in the rds_message is assigned when the message is queued on the sock, and nulled when the message is dequeued from the sock.
We want to be able to notify userspace when the rds_message is actually freed (from rds_message_purge(), after the refcounts to the rds_message go to 0). At the time that rds_message_purge() is called, the message is no longer on the rds_sock retransmit queue. Thus the explicit reference for the m_rs is needed to send a notification that will signal to userspace that it is now safe to free/reuse any pages that may have been pinned down for zerocopy.
This patch manages the m_rs assignment in the rds_message with the necessary refcount book-keeping.
--- net/rds/message.c | 8 +++++++- net/rds/send.c | 7 +------ 2 files changed, 8 insertions(+), 7 deletions(-)
net/rds/message.c +7 -1
@@ -58,7 +58,7 @@ void rds_message_addref(struct rds_message *rm)*/ static void rds_message_purge (struct rds_message *rm) { -unsigned long i; +unsigned long i, flags;if (unlikely (test_bit (RDS_MSG_PAGEVEC , &rm->m_flags)))return ;
@@ -69,6 +69,12 @@ static void rds_message_purge(struct rds_message *rm)__free_page (sg_page (&rm->data.op_sg[i])); } rm->data.op_nents =0 ; +spin_lock_irqsave (&rm->m_rs_lock, flags); +if (rm->m_rs) { +sock_put (rds_rs_to_sk (rm->m_rs)); + rm->m_rs =NULL ; + } +spin_unlock_irqrestore (&rm->m_rs_lock, flags);if (rm->rdma.op_active)rds_rdma_free_op (&rm->rdma);
net/rds/send.c +1 -6
@@ -649,7 +649,6 @@ static void rds_send_remove_from_sock(struct list_head *messages, int status) rm->rdma.op_notifier =NULL ; } was_on_sock =1 ; - rm->m_rs =NULL ; }spin_unlock (&rs->rs_lock);
@@ -756,9 +755,6 @@ void rds_send_drop_to(struct rds_sock *rs, struct sockaddr_in *dest)*/ if (!test_and_clear_bit (RDS_MSG_ON_CONN , &rm->m_flags)) {spin_unlock_irqrestore (&cp->cp_lock, flags); -spin_lock_irqsave (&rm->m_rs_lock, flags); - rm->m_rs =NULL ; -spin_unlock_irqrestore (&rm->m_rs_lock, flags);continue ; }list_del_init (&rm->m_conn_item);
@@ -774,7 +770,6 @@ void rds_send_drop_to(struct rds_sock *rs, struct sockaddr_in *dest)__rds_send_complete (rs, rm,RDS_RDMA_CANCELED );spin_unlock (&rs->rs_lock); - rm->m_rs =NULL ;spin_unlock_irqrestore (&rm->m_rs_lock, flags);rds_message_put (rm);
@@ -798,7 +793,6 @@ void rds_send_drop_to(struct rds_sock *rs, struct sockaddr_in *dest)__rds_send_complete (rs, rm,RDS_RDMA_CANCELED );spin_unlock (&rs->rs_lock); - rm->m_rs =NULL ;spin_unlock_irqrestore (&rm->m_rs_lock, flags);rds_message_put (rm);
@@ -849,6 +843,7 @@ static int rds_send_queue_rm(struct rds_sock *rs, struct rds_connection *conn,list_add_tail (&rm->m_sock_item, &rs->rs_send_queue);set_bit (RDS_MSG_ON_SOCK , &rm->m_flags);rds_message_addref (rm); +sock_hold (rds_rs_to_sk (rs)); rm->m_rs = rs;/* The code ordering is a little weird, but we're
Signature · 1 line
1.7.1
PATCH v3 3/7 sock: permit SO_ZEROCOPY on PF_RDS socket
In reply to Sowmini Varadhanallow the application to set SO_ZEROCOPY on the underlying sk of a PF_RDS socket
--- net/core/sock.c | 25 ++++++++++++++----------- 1 files changed, 14 insertions(+), 11 deletions(-)
net/core/sock.c +14 -11
@@ -1049,18 +1049,21 @@ int sock_setsockopt(struct socket *sock, int level, int optname,break ;case SO_ZEROCOPY : -if (sk->sk_family !=PF_INET && sk->sk_family !=PF_INET6 ) +if (sk->sk_family ==PF_INET || sk->sk_family ==PF_INET6 ) { +if (sk->sk_protocol !=IPPROTO_TCP ) + ret = -ENOTSUPP ; +else if (sk->sk_state !=TCP_CLOSE ) + ret = -EBUSY ; + }else if (sk->sk_family !=PF_RDS ) { ret = -ENOTSUPP ; -else if (sk->sk_protocol !=IPPROTO_TCP ) - ret = -ENOTSUPP ; -else if (sk->sk_state !=TCP_CLOSE ) - ret = -EBUSY ; -else if (val <0 || val >1 ) - ret = -EINVAL ; -else -sock_valbool_flag (sk,SOCK_ZEROCOPY , valbool); -break ; - + } +if (!ret) { +if (val <0 || val >1 ) + ret = -EINVAL ; +else +sock_valbool_flag (sk,SOCK_ZEROCOPY , valbool); +break ; + }default : ret = -ENOPROTOOPT ;break ;
Signature · 1 line
1.7.1
PATCH v3 6/7 selftests/net: add support for PF_RDS sockets
In reply to Sowmini VaradhanAdd support for basic PF_RDS client-server testing in msg_zerocopy
--- tools/testing/selftests/net/msg_zerocopy.c | 65 +++++++++++++++++++++++++++- 1 files changed, 64 insertions(+), 1 deletions(-)
tools/testing/selftests/net/msg_zerocopy.c +64 -1
@@ -14,6 +14,9 @@* - SOCK_DGRAM * - SOCK_RAW * +* PF_RDS +* - SOCK_SEQPACKET +* * Start this program on two connected hosts, one in send mode and * the other with option '-r' to put it in receiver mode. *
@@ -53,6 +56,7 @@#include <sys/types.h> #include <sys/wait.h> #include <unistd.h> +#include <linux/rds.h> #ifndef SO_EE_ORIGIN_ZEROCOPY #define SO_EE_ORIGIN_ZEROCOPY 5
@@ -300,10 +304,15 @@ static int do_setup_tx(int domain, int type, int protocol)if (cfg_zerocopy)do_setsockopt (fd,SOL_SOCKET ,SO_ZEROCOPY ,1 ); -if (domain !=PF_PACKET ) +if (domain !=PF_PACKET && domain !=PF_RDS )if (connect (fd, (void *) &cfg_dst_addr, cfg_alen))error (1 , errno,"connect" ); +if (domain ==PF_RDS ) { +if (bind (fd, (void *) &cfg_src_addr, cfg_alen)) +error (1 , errno,"bind" ); + } +return fd; }
@@ -444,6 +453,13 @@ static void do_tx(int domain, int type, int protocol) msg.msg_iovlen++; } +if (domain ==PF_RDS ) { + msg.msg_name = &cfg_dst_addr; + msg.msg_namelen = (cfg_dst_addr.ss_family ==AF_INET ? +sizeof (struct sockaddr_in ) : +sizeof (struct sockaddr_in6 )); + } + iov[2 ].iov_base = payload; iov[2 ].iov_len = cfg_payload_len; msg.msg_iovlen++;
@@ -555,6 +571,40 @@ static void do_flush_datagram(int fd, int type) bytes += cfg_payload_len; } + +static void do_recvmsg (int fd) +{ +int ret, off =0 ; +char *buf; +struct iovec iov; +struct msghdr msg; +struct sockaddr_storage din; + + buf =calloc (cfg_payload_len,sizeof (char )); + iov.iov_base = buf; + iov.iov_len = cfg_payload_len; + +memset (&msg,0 ,sizeof (msg)); + msg.msg_name = &din; + msg.msg_namelen =sizeof (din); + msg.msg_iov = &iov; + msg.msg_iovlen =1 ; + + ret =recvmsg (fd, &msg,MSG_TRUNC ); + +if (ret ==-1 ) +error (1 , errno,"recv" ); +if (ret != cfg_payload_len) +error (1 ,0 ,"recv: ret=%u != %u" , ret, cfg_payload_len); + +if (memcmp (buf + off, payload, ret)) +error (1 ,0 ,"recv: data mismatch" ); + +free (buf); + packets++; + bytes += cfg_payload_len; +} +static void do_rx (int domain,int type,int protocol) {uint64_t tstop;
@@ -566,6 +616,8 @@ static void do_rx(int domain, int type, int protocol) do { if (type == SOCK_STREAM) do_flush_tcp(fd); + else if (domain == PF_RDS) + do_recvmsg(fd); else do_flush_datagram(fd, type);
@@ -610,6 +662,7 @@ static void parse_opts(int argc, char **argv)40 /* max tcp options */ ;int c;char *daddr =NULL , *saddr =NULL ; +char *cfg_test; cfg_payload_len = max_payload_len;
@@ -667,6 +720,14 @@ static void parse_opts(int argc, char **argv)break ; } } + + cfg_test = argv[argc -1 ]; +if (strcmp (cfg_test,"rds" ) ==0 ) { +if (!daddr) +error (1 ,0 ,"-D <server addr> required for PF_RDS\n" ); +if (!cfg_rx && !saddr) +error (1 ,0 ,"-S <client addr> required for PF_RDS\n" ); + }setup_sockaddr (cfg_family, daddr, &cfg_dst_addr);setup_sockaddr (cfg_family, saddr, &cfg_src_addr);
@@ -699,6 +760,8 @@ int main(int argc, char **argv)do_test (cfg_family,SOCK_STREAM ,0 ); else if (!strcmp(cfg_test, "udp"))do_test (cfg_family,SOCK_DGRAM ,0 ); + else if (!strcmp(cfg_test, "rds")) +do_test (PF_RDS ,SOCK_SEQPACKET ,0 ); else error(1, 0, "unknown cfg_test %s", cfg_test);
Signature · 1 line
1.7.1
PATCH v3 7/7 selftests/net: add zerocopy support for PF_RDS test case
In reply to Sowmini VaradhanSend a cookie with sendmsg() on PF_RDS sockets, and process the returned batched cookies in do_recv_completion()
---
v2:
- restructured do_recv_completion to avoid excessive code re-indent
- on-stack allocation of cmsghdr for cookie in do_sendmsg
- Additional verification: Verify ncookies <= MAX_.., verify ret == ncookies * sizeof(uint32_t)
tools/testing/selftests/net/msg_zerocopy.c | 68 ++++++++++++++++++++++++++-- 1 files changed, 64 insertions(+), 4 deletions(-)
tools/testing/selftests/net/msg_zerocopy.c +64 -4
@@ -168,17 +168,39 @@ static int do_accept(int fd)return fd; } -static bool do_sendmsg (int fd,struct msghdr *msg,bool do_zerocopy) +static void add_zcopy_cookie (struct msghdr *msg,uint32_t cookie) +{ +struct cmsghdr *cm; + +if (!msg->msg_control) +error (1 , errno,"NULL cookie" ); + cm = (void *)msg->msg_control; + cm->cmsg_len =CMSG_LEN (sizeof (cookie)); + cm->cmsg_level =SOL_RDS ; + cm->cmsg_type =RDS_CMSG_ZCOPY_COOKIE ; +memcpy (CMSG_DATA (cm), &cookie,sizeof (cookie)); +} + +static bool do_sendmsg (int fd,struct msghdr *msg,bool do_zerocopy,int domain) {int ret, len, i, flags; +static uint32_t cookie; +char ckbuf[CMSG_SPACE (sizeof (cookie))]; len =0 ;for (i =0 ; i < msg->msg_iovlen; i++) len += msg->msg_iov[i].iov_len; flags =MSG_DONTWAIT ; -if (do_zerocopy) +if (do_zerocopy) { flags |=MSG_ZEROCOPY ; +if (domain ==PF_RDS ) { +memset (&msg->msg_control,0 ,sizeof (msg->msg_control)); + msg->msg_controllen =CMSG_SPACE (sizeof (cookie)); + msg->msg_control = (struct cmsghdr *)ckbuf; +add_zcopy_cookie (msg, ++cookie); + } + } ret =sendmsg (fd, msg, flags);if (ret ==-1 && errno ==EAGAIN )
@@ -194,6 +216,10 @@ static bool do_sendmsg(int fd, struct msghdr *msg, bool do_zerocopy)if (do_zerocopy && ret) expected_completions++; } +if (do_zerocopy && domain ==PF_RDS ) { + msg->msg_control =NULL ; + msg->msg_controllen =0 ; + }return true; }
@@ -220,7 +246,9 @@ static void do_sendmsg_corked(int fd, struct msghdr *msg) msg->msg_iov[0 ].iov_len = payload_len + extra_len; extra_len =0 ; -do_sendmsg (fd, msg, do_zerocopy); +do_sendmsg (fd, msg, do_zerocopy, + (cfg_dst_addr.ss_family ==AF_INET ? +PF_INET :PF_INET6 )); }do_setsockopt (fd,IPPROTO_UDP ,UDP_CORK ,0 );
@@ -316,6 +344,26 @@ static int do_setup_tx(int domain, int type, int protocol)return fd; } +static int do_process_zerocopy_cookies (struct sock_extended_err *serr, +uint32_t *ckbuf,size_t nbytes) +{ +int ncookies, i; + +if (serr->ee_errno !=0 ) +error (1 ,0 ,"serr: wrong error code: %u" , serr->ee_errno); + ncookies = serr->ee_data; +if (ncookies >SO_EE_ORIGIN_MAX_ZCOOKIES ) +error (1 ,0 ,"Returned %d cookies, max expected %d\n" , + ncookies,SO_EE_ORIGIN_MAX_ZCOOKIES ); +if (nbytes != ncookies *sizeof (uint32_t )) +error (1 ,0 ,"Expected %d cookies, got %ld\n" , + ncookies, nbytes/sizeof (uint32_t )); +for (i =0 ; i < ncookies; i++) +if (cfg_verbose >=2 ) +fprintf (stderr,"%d\n" , ckbuf[i]); +return ncookies; +} +static bool do_recv_completion (int fd) {struct sock_extended_err *serr;
@@ -324,10 +372,17 @@ static bool do_recv_completion(int fd)uint32_t hi, lo, range;int ret, zerocopy;char control[100 ]; +uint32_t ckbuf[SO_EE_ORIGIN_MAX_ZCOOKIES ]; +struct iovec iov; msg.msg_control = control; msg.msg_controllen =sizeof (control); + iov.iov_base = ckbuf; + iov.iov_len = (SO_EE_ORIGIN_MAX_ZCOOKIES *sizeof (ckbuf[0 ])); + msg.msg_iov = &iov; + msg.msg_iovlen =1 ; + ret =recvmsg (fd, &msg,MSG_ERRQUEUE );if (ret ==-1 && errno ==EAGAIN )return false;
@@ -346,6 +401,11 @@ static bool do_recv_completion(int fd) cm->cmsg_level, cm->cmsg_type); serr = (void *)CMSG_DATA (cm); + +if (serr->ee_origin ==SO_EE_ORIGIN_ZCOOKIE ) { + completions +=do_process_zerocopy_cookies (serr, ckbuf, ret); +return true; + }if (serr->ee_origin !=SO_EE_ORIGIN_ZEROCOPY )error (1 ,0 ,"serr: wrong origin: %u" , serr->ee_origin);if (serr->ee_errno !=0 )
@@ -470,7 +530,7 @@ static void do_tx(int domain, int type, int protocol)if (cfg_cork)do_sendmsg_corked (fd, &msg);else -do_sendmsg (fd, &msg, cfg_zerocopy); +do_sendmsg (fd, &msg, cfg_zerocopy, domain);while (!do_poll (fd,POLLOUT )) {if (cfg_zerocopy)
Signature · 1 line
1.7.1
PATCH v3 4/7 rds: support for zcopy completion notification
In reply to Sowmini VaradhanRDS removes a datagram (rds_message) from the retransmit queue when an ACK is received. The ACK indicates that the receiver has queued the RDS datagram, so that the sender can safely forget the datagram. When all references to the rds_message are quiesced, rds_message_purge is called to release resources used by the rds_message
If the datagram to be removed had pinned pages set up, add an entry to the rs->rs_znotify_queue so that the notifcation will be sent up via rds_rm_zerocopy_callback() when the rds_message is eventually freed by rds_message_purge.
rds_rm_zerocopy_callback() attempts to batch the number of cookies sent with each notification to a max of SO_EE_ORIGIN_MAX_ZCOOKIES. This is achieved by checking the tail skb in the sk_error_queue:
if this has room for one more cookie, the cookie from the current notification is added; else a new skb is added to the sk_error_queue. Every invocation of rds_rm_zerocopy_callback() will trigger a ->sk_error_report to notify the application.
---
v2:
- make sure to always sock_put m_rs even if there is no znotifier.
- major rewrite of notification, resulting in much simplification.
v3:
- fix fragile use of skb->cb[], do not set ee_code incorrectly.
include/uapi/linux/errqueue.h | 2 + net/rds/af_rds.c | 2 + net/rds/message.c | 83 +++++++++++++++++++++++++++++++++++++--- net/rds/rds.h | 14 +++++++ net/rds/recv.c | 2 + 5 files changed, 96 insertions(+), 7 deletions(-)
include/uapi/linux/errqueue.h +2 -0
@@ -20,11 +20,13 @@ struct sock_extended_err {#define SO_EE_ORIGIN_ICMP6 3#define SO_EE_ORIGIN_TXSTATUS 4#define SO_EE_ORIGIN_ZEROCOPY 5 +#define SO_EE_ORIGIN_ZCOOKIE 6#define SO_EE_ORIGIN_TIMESTAMPING SO_EE_ORIGIN_TXSTATUS#define SO_EE_OFFENDER (ee) ((struct sockaddr*)((ee)+1))#define SO_EE_CODE_ZEROCOPY_COPIED 1 +#define SO_EE_ORIGIN_MAX_ZCOOKIES 8/** * struct scm_timestamping - timestamps exposed through cmsg
net/rds/af_rds.c +2 -0
@@ -182,6 +182,8 @@ static __poll_t rds_poll(struct file *file, struct socket *sock, mask |= (EPOLLIN |EPOLLRDNORM );if (rs->rs_snd_bytes <rds_sk_sndbuf (rs)) mask |= (EPOLLOUT |EPOLLWRNORM ); +if (sk->sk_err || !skb_queue_empty (&sk->sk_error_queue)) + mask |=POLLERR ;read_unlock_irqrestore (&rs->rs_recv_lock, flags);/* clear state any time we wake a seen-congested socket */
net/rds/message.c +76 -7
111 lines not on this page · raw message
net/rds/rds.h +14 -0
@@ -356,6 +356,19 @@ static inline u32 rds_rdma_cookie_offset(rds_rdma_cookie_t cookie)#define RDS_MSG_PAGEVEC 7#define RDS_MSG_FLUSH 8 +struct rds_znotifier { +struct list_head z_list; +struct mmpin z_mmp; +u32 z_cookie; +}; + +#define RDS_ZCOPY_SKB (__skb) ((struct rds_znotifier *)&((__skb)->cb[0])) + +static inline struct sk_buff *rds_skb_from_znotifier (struct rds_znotifier *z) +{ + return container_of((void *)z, struct sk_buff, cb); +} +struct rds_message {refcount_t m_refcount;struct list_head m_sock_item;
@@ -436,6 +449,7 @@ struct rds_message {unsigned int op_count;unsigned int op_dmasg;unsigned int op_dmaoff; +struct rds_znotifier *op_mmp_znotifier;struct scatterlist *op_sg; } data; };
net/rds/recv.c +2 -0
@@ -594,6 +594,8 @@ int rds_recvmsg(struct socket *sock, struct msghdr *msg, size_t size,if (msg_flags &MSG_OOB ) goto out; +if (msg_flags &MSG_ERRQUEUE ) +return sock_recv_errqueue (sk, msg, size,SOL_IP ,IP_RECVERR );while (1 ) {/* If there are pending notifications, do those - and nothing else */
Signature · 1 line
1.7.1
PATCH v3 5/7 rds: zerocopy Tx support.
In reply to Sowmini VaradhanIf the MSG_ZEROCOPY flag is specified with rds_sendmsg(), and, if the SO_ZEROCOPY socket option has been set on the PF_RDS socket, application pages sent down with rds_sendmsg() are pinned.
The pinning uses the accounting infrastructure added by Commit a91dbff551a6 ("sock: ulimit on MSG_ZEROCOPY pages")
The payload bytes in the message may not be modified for the duration that the message has been pinned. A multi-threaded application using this infrastructure may thus need to be notified about send-completion so that it can free/reuse the buffers passed to rds_sendmsg(). Notification of send-completion will identify each message-buffer by a cookie that the application must specify as ancillary data to rds_sendmsg().
The ancillary data in this case has cmsg_level == SOL_RDS and cmsg_type == RDS_CMSG_ZCOPY_COOKIE.
---
v2:
- remove unused data_len argument to rds_rm_size;
- unmap as necessary if we fail in the middle of zerocopy setup
v3: remove needless bzero of skb->cb[], consolidate err cleanup
include/uapi/linux/rds.h | 1 + net/rds/message.c | 51 +++++++++++++++++++++++++++++++++++++++++++++- net/rds/rds.h | 3 +- net/rds/send.c | 44 ++++++++++++++++++++++++++++++++++----- 4 files changed, 91 insertions(+), 8 deletions(-)
include/uapi/linux/rds.h +1 -0
@@ -103,6 +103,7 @@#define RDS_CMSG_MASKED_ATOMIC_FADD 8#define RDS_CMSG_MASKED_ATOMIC_CSWP 9#define RDS_CMSG_RXPATH_LATENCY 11 +#define RDS_CMSG_ZCOPY_COOKIE 12#define RDS_INFO_FIRST 10000#define RDS_INFO_COUNTERS 10000
net/rds/message.c +50 -1
68 lines not on this page · raw message
net/rds/rds.h +2 -1
@@ -785,7 +785,8 @@ void rds_for_each_conn_info(struct socket *sock, unsigned int len,/* message.c */ struct rds_message *rds_message_alloc (unsigned int nents,gfp_t gfp);struct scatterlist *rds_message_alloc_sgs (struct rds_message *rm,int nents); -int rds_message_copy_from_user (struct rds_message *rm,struct iov_iter *from); +int rds_message_copy_from_user (struct rds_message *rm,struct iov_iter *from, +bool zcopy);struct rds_message *rds_message_map_pages (unsigned long *page_addrs,unsigned int total_len);void rds_message_populate_header (struct rds_header *hdr,__be16 sport,__be16 dport,u64 seq);
net/rds/send.c +38 -6
105 lines not on this page · raw message
Signature · 1 line
1.7.1
Re: [PATCH v3 net-next 2/7] rds: hold a sock ref from rds_message to the rds_sock
In reply to Sowmini VaradhanQuoted 15 lines · Sowmini Varadhan
The existing model holds a reference from the
rds_sockto therds_message, but therds_messagedoes not itself hold asock_put()on therds_sock. Instead them_rsfield in therds_messageis assigned when the message is queued on the sock, and nulled when the message is dequeued from the sock.We want to be able to notify userspace when the
rds_messageis actually freed (fromrds_message_purge(), after the refcounts to therds_messagego to 0). At the time thatrds_message_purge()is called, the message is no longer on therds_sockretransmit queue. Thus the explicit reference for them_rsis needed to send a notification that will signal to userspace that it is now safe to free/reuse any pages that may have been pinned down for zerocopy.
Quoted 5 lines
This patch manages the
m_rsassignment in therds_messagewith the necessary refcount book-keeping.Signed-off-by Sowmini Varadhan <[email protected]>---
Re: [PATCH v3 net-next 4/7] rds: support for zcopy completion notification
In reply to Sowmini VaradhanQuoted 19 lines · Sowmini Varadhan
RDS removes a datagram (
rds_message) from the retransmit queue when an ACK is received. The ACK indicates that the receiver has queued the RDS datagram, so that the sender can safely forget the datagram. When all references to therds_messageare quiesced,rds_message_purgeis called to release resources used by therds_messageIf the datagram to be removed had pinned pages set up, add an entry to the
rs->rs_znotify_queueso that the notifcation will be sent up viards_rm_zerocopy_callback()when therds_messageis eventually freed byrds_message_purge.
rds_rm_zerocopy_callback()attempts to batch the number of cookies sent with each notification to a max ofSO_EE_ORIGIN_MAX_ZCOOKIES. This is achieved by checking the tail skb in thesk_error_queue:
if this has room for one more cookie, the cookie from the current notification is added; else a new skb is added to thesk_error_queue. Every invocation ofrds_rm_zerocopy_callback()will trigger a ->sk_error_report to notify the application.
Quoted 2 lines
Signed-off-by Sowmini Varadhan <[email protected]>---
Re: [PATCH v3 net-next 5/7] rds: zerocopy Tx support.
In reply to Sowmini VaradhanQuoted 17 lines · Sowmini Varadhan
If the
MSG_ZEROCOPYflag is specified withrds_sendmsg(), and, if theSO_ZEROCOPYsocket option has been set on thePF_RDSsocket, application pages sent down withrds_sendmsg()are pinned.The pinning uses the accounting infrastructure added by Commit
a91dbff551a6("sock: ulimit onMSG_ZEROCOPYpages")The payload bytes in the message may not be modified for the duration that the message has been pinned. A multi-threaded application using this infrastructure may thus need to be notified about send-completion so that it can free/reuse the buffers passed to
rds_sendmsg(). Notification of send-completion will identify each message-buffer by a cookie that the application must specify as ancillary data tords_sendmsg().
The ancillary data in this case hascmsg_level==SOL_RDSandcmsg_type==RDS_CMSG_ZCOPY_COOKIE.
Quoted 2 lines
Signed-off-by Sowmini Varadhan <[email protected]>---
v3 cover RDS: zerocopy support
This is version 3 of the series, following up on review comments for
http://patchwork.ozlabs.org/project/netdev/list/?series=28530
Review comments addressed
Patch 4
- fix fragile use of skb->cb[], do not set ee_code incorrectly.
Patch 5:
- remove needless bzero of skb->cb[], consolidate err cleanup
A brief overview of this feature follows.
This patch series provides support for MSG_ZERCOCOPY on a PF_RDS socket based on the APIs and infrastructure added by Commit f214f915e7db ("tcp: enable MSG_ZEROCOPY")
For single threaded rds-stress testing using rds-tcp with the ixgbe driver using 1M message sizes (-a 1M -q 1M) preliminary results show that there is a significant reduction in latency: about 90 usec with zerocopy, compared with 200 usec without zerocopy.
This patchset modifies the above for zerocopy in the following manner.
- if the MSG_ZEROCOPY flag is specified with rds_sendmsg(), and,
- if the SO_ZEROCOPY socket option has been set on the PF_RDS socket, application pages sent down with rds_sendmsg are pinned. The pinning uses the accounting infrastructure added by a91dbff551a6 ("sock: ulimit on MSG_ZEROCOPY pages"). The message is unpinned when all references to the message go down to 0, and the message is freed by rds_message_purge.
A multithreaded application using this infrastructure must send down a unique 32 bit cookie as ancillary data with each sendmsg invocation. The format of this ancillary data is described in Patch 5 of the series. The cookie is passed up to the application on the sk_error_queue when the message is unpinned, indicating to the application that it is now safe to free/reuse the message buffer. The details of the completion notification are provided in Patch 4 of this series.
Sowmini Varadhan (7):
skbuff: export mm_[un]account_pinned_pages for other modules
rds: hold a sock ref from rds_message to the rds_sock
sock: permit SO_ZEROCOPY on PF_RDS socket
rds: support for zcopy completion notification
rds: zerocopy Tx support.
selftests/net: add support for PF_RDS sockets selftests/net: add zerocopy support for PF_RDS test case
include/linux/skbuff.h | 3 + include/uapi/linux/errqueue.h | 2 + include/uapi/linux/rds.h | 1 + net/core/skbuff.c | 6 +- net/core/sock.c | 25 +++--- net/rds/af_rds.c | 2 + net/rds/message.c | 132 ++++++++++++++++++++++++++- net/rds/rds.h | 17 ++++- net/rds/recv.c | 2 + net/rds/send.c | 51 ++++++++--- tools/testing/selftests/net/msg_zerocopy.c | 133 ++++++++++++++++++++++++++- 11 files changed, 339 insertions(+), 35 deletions(-)
Re: [PATCH v3 net-next 1/7] skbuff: export mm_[un]account_pinned_pages for other modules
In reply to Sowmini VaradhanQuoted 4 lines · Sowmini Varadhan
RDS would like to use the helper functions for managing pinned pages added by Commit
a91dbff551a6("sock: ulimit onMSG_ZEROCOPYpages")Signed-off-by Sowmini Varadhan <[email protected]>
Re: [PATCH v3 net-next 3/7] sock: permit SO_ZEROCOPY on PF_RDS socket
In reply to Sowmini VaradhanQuoted 4 lines · Sowmini Varadhan
allow the application to set
SO_ZEROCOPYon the underlying sk of aPF_RDSsocketSigned-off-by Sowmini Varadhan <[email protected]>
Willem de Bruijn
Acked-byRe: [PATCH v3 net-next 4/7] rds: support for zcopy completion notification
In reply to Santosh ShilimkarQuoted 21 lines · Santosh Shilimkar
Quoted 20 lines · Sowmini Varadhan
RDS removes a datagram (
rds_message) from the retransmit queue when an ACK is received. The ACK indicates that the receiver has queued the RDS datagram, so that the sender can safely forget the datagram. When all references to therds_messageare quiesced,rds_message_purgeis called to release resources used by therds_messageIf the datagram to be removed had pinned pages set up, add an entry to the
rs->rs_znotify_queueso that the notifcation will be sent up viards_rm_zerocopy_callback()when therds_messageis eventually freed byrds_message_purge.
rds_rm_zerocopy_callback()attempts to batch the number of cookies sent with each notification to a max ofSO_EE_ORIGIN_MAX_ZCOOKIES. This is achieved by checking the tail skb in thesk_error_queue:
if this has room for one more cookie, the cookie from the current notification is added; else a new skb is added to thesk_error_queue. Every invocation ofrds_rm_zerocopy_callback()will trigger a ->sk_error_report to notify the application.
Quoted 4 lines
Quoted 2 lines
Signed-off-by Sowmini Varadhan <[email protected]>---
Willem de Bruijn
Acked-byRe: [PATCH v3 net-next 5/7] rds: zerocopy Tx support.
In reply to Santosh ShilimkarQuoted 19 lines · Santosh Shilimkar
Quoted 18 lines · Sowmini Varadhan
If the
MSG_ZEROCOPYflag is specified withrds_sendmsg(), and, if theSO_ZEROCOPYsocket option has been set on thePF_RDSsocket, application pages sent down withrds_sendmsg()are pinned.The pinning uses the accounting infrastructure added by Commit
a91dbff551a6("sock: ulimit onMSG_ZEROCOPYpages")The payload bytes in the message may not be modified for the duration that the message has been pinned. A multi-threaded application using this infrastructure may thus need to be notified about send-completion so that it can free/reuse the buffers passed to
rds_sendmsg(). Notification of send-completion will identify each message-buffer by a cookie that the application must specify as ancillary data tords_sendmsg().
The ancillary data in this case hascmsg_level==SOL_RDSandcmsg_type==RDS_CMSG_ZCOPY_COOKIE.
Quoted 5 lines
Quoted 2 lines
Signed-off-by Sowmini Varadhan <[email protected]>---
Re: [PATCH v3 net-next 6/7] selftests/net: add support for PF_RDS sockets
In reply to Sowmini VaradhanQuoted 3 lines · Sowmini Varadhan
Add support for basic
PF_RDSclient-server testing inmsg_zerocopySigned-off-by Sowmini Varadhan <[email protected]>
Re: [PATCH v3 net-next 7/7] selftests/net: add zerocopy support for PF_RDS test case
In reply to Sowmini VaradhanQuoted 4 lines · Sowmini Varadhan
Send a cookie with
sendmsg()onPF_RDSsockets, and process the returned batched cookies indo_recv_completion()Signed-off-by Sowmini Varadhan <[email protected]>
David Miller
maintainerFrom: Sowmini Varadhan <[email protected]>
Date: Thu, 15 Feb 2018 10:49:31 -0800
Quoted 28 lines
This is version 3 of the series, following up on review comments for
http://patchwork.ozlabs.org/project/netdev/list/?series=28530Review comments addressed
Patch 4
- fix fragile use of skb->cb[], do not setee_codeincorrectly.
Patch 5:
- remove needless bzero of skb->cb[], consolidate err cleanupA brief overview of this feature follows.
This patch series provides support for
MSG_ZERCOCOPYon aPF_RDSsocket based on the APIs and infrastructure added by Commitf214f915e7db("tcp: enableMSG_ZEROCOPY")For single threaded rds-stress testing using rds-tcp with the ixgbe driver using 1M message sizes (-a 1M -q 1M) preliminary results show that there is a significant reduction in latency: about 90 usec with zerocopy, compared with 200 usec without zerocopy.
This patchset modifies the above for zerocopy in the following manner.
- if theMSG_ZEROCOPYflag is specified withrds_sendmsg(), and,
- if theSO_ZEROCOPYsocket option has been set on thePF_RDSsocket, application pages sent down withrds_sendmsgare pinned. The pinning uses the accounting infrastructure added bya91dbff551a6("sock: ulimit onMSG_ZEROCOPYpages"). The message is unpinned when all references to the message go down to 0, and the message is freed byrds_message_purge.
Quoted 7 lines
A multithreaded application using this infrastructure must send down a unique 32 bit cookie as ancillary data with each sendmsg invocation. The format of this ancillary data is described in Patch 5 of the series. The cookie is passed up to the application on the
sk_error_queuewhen the message is unpinned, indicating to the application that it is now safe to free/reuse the message buffer. The details of the completion notification are provided in Patch 4 of this series.
Series applied, thanks a lot!