svc: SVC Transport Switch
Subsystems (3)
cover svc: SVC Transport Switch
The Server Side Transport switch implements a pluggable transport provider layer for RPC servers. This allows network transport drivers to be dynamically loaded and registered, thereby extending the set of transports that can carry RPC. This patchset includes a transport provider driver for TCP and UDP sockets.
This version of the patchset is functionally equivalent to the preceding patchset and includes the following improvements:
- Fixed a bug in svc_create_socket that resulted in svc_xprt_received being called without holding the XPT_BUSY bit.
- Added a BUG_ON in svc_xprt_received to catch providers calling svc_xprt_received without holding the XPT_BUSY bit.
- Removed code setting the XPT_BUSY bit in the create path and moved this logic to common code.
- Cleaned up the SMP locking strategy comment and moved it to svc_xprt.c
- Changed return type of svc_unreg_xprt_class to void
- Simplified transport class removal logic
- Fixed a white-space abuse issue
- Made some style changes to the patch comments
- Created a separate patch that moves the connection limit code to generic logic
- Created a separate patch that moves the call to svc_xprt_received out of tcp_accept and into common logic
- Created a separate patch for removal of unnecessary call to svc_sock_enqueue in svc_tcp_accept function
- Removed silly BUG_ON from kref svc_xprt_free callback function
- Moved unlock of svc_xprt_class list to after the try_module_lock call.
- Refactored svc_create_xprt logic
- Removed unnecessary call to svc_find_xprt in portlist code
Signature · 1 line
Signed-off-by: Tom Tucker <[email protected]>
A message that is not in the archive (sent off-list or not yet received): 20071231030712.8430.45576.stgit-gUwIgmpLGaKNDNWfRnPdfg@public.gmane.org
PATCH 1/40 svc: Add an svc transport class
The transport class (svc_xprt_class) represents a type of transport, e.g. udp, tcp, rdma. A transport class has a unique name and a set of transport operations kept in the svc_xprt_ops structure.
A transport class can be dynamically registered and unregisterd. The svc_xprt_class represents the module that implements the transport type and keeps reference counts on the module to avoid unloading while there are active users.
The endpoint (svc_xprt) is a generic, transport independent endpoint that can be used to send and receive data for an RPC service. It inherits it's operations from the transport class.
A transport driver module registers and unregisters itself with svc sunrpc by calling svc_reg_xprt_class, and svc_unreg_xprt_class respectively.
---
include/linux/sunrpc/debug.h | 1 include/linux/sunrpc/svc_xprt.h | 31 +++++++++++++++ net/sunrpc/Makefile | 3 + net/sunrpc/svc_xprt.c | 83 +++++++++++++++++++++++++++++++++++++++ 4 files changed, 117 insertions(+), 1 deletions(-)
include/linux/sunrpc/debug.h +1 -0
@@ -21,6 +21,7 @@#define RPCDBG_SCHED 0x0040#define RPCDBG_TRANS 0x0080#define RPCDBG_SVCSOCK 0x0100 +#define RPCDBG_SVCXPRT 0x0100#define RPCDBG_SVCDSP 0x0200#define RPCDBG_MISC 0x0400#define RPCDBG_CACHE 0x0800
include/linux/sunrpc/svc_xprt.h new file +31 -0
@@ -0,0 +1,31 @@ +/* +* linux/include/linux/sunrpc/svc_xprt.h +* +* RPC server transport I/O +*/ + +#ifndef SUNRPC_SVC_XPRT_H +#define SUNRPC_SVC_XPRT_H + +#include <linux/sunrpc/svc.h> + +struct svc_xprt_ops { +}; + +struct svc_xprt_class { +const char *xcl_name; +struct module *xcl_owner; +struct svc_xprt_ops *xcl_ops; +struct list_head xcl_list; +}; + +struct svc_xprt { +struct svc_xprt_class *xpt_class; +struct svc_xprt_ops *xpt_ops; +}; + +int svc_reg_xprt_class (struct svc_xprt_class *); +void svc_unreg_xprt_class (struct svc_xprt_class *); +void svc_xprt_init (struct svc_xprt_class *,struct svc_xprt *); + +#endif /* SUNRPC_SVC_XPRT_H */
net/sunrpc/Makefile +2 -1
@@ -11,6 +11,7 @@ sunrpc-y := clnt.o xprt.o socklib.o xprtsock.o sched.o \ auth.o auth_null.o auth_unix.o \ svc.o svcsock.o svcauth.o svcauth_unix.o \ rpcb_clnt.o timer.o xdr.o \ - sunrpc_syms.o cache.o rpc_pipe.o + sunrpc_syms.o cache.o rpc_pipe.o \ + svc_xprt.o sunrpc-$(CONFIG_PROC_FS) += stats.o sunrpc-$(CONFIG_SYSCTL) += sysctl.o
net/sunrpc/svc_xprt.c new file +83 -0
83 lines not on this page · raw message
PATCH 2/40 svc: Make svc_sock the tcp/udp transport
In reply to a message not in the archiveMake TCP and UDP svc_sock transports, and register them with the svc transport core.
A transport type (svc_sock) has an svc_xprt as its first member, and calls svc_xprt_init to initialize this field.
---
include/linux/sunrpc/debug.h | 1 - include/linux/sunrpc/svcsock.h | 4 ++++ net/sunrpc/sunrpc_syms.c | 4 +++- net/sunrpc/svcsock.c | 32 +++++++++++++++++++++++++++++++- 4 files changed, 38 insertions(+), 3 deletions(-)
include/linux/sunrpc/debug.h +0 -1
@@ -20,7 +20,6 @@#define RPCDBG_BIND 0x0020#define RPCDBG_SCHED 0x0040#define RPCDBG_TRANS 0x0080 -#define RPCDBG_SVCSOCK 0x0100#define RPCDBG_SVCXPRT 0x0100#define RPCDBG_SVCDSP 0x0200#define RPCDBG_MISC 0x0400
include/linux/sunrpc/svcsock.h +4 -0
@@ -10,11 +10,13 @@#define SUNRPC_SVCSOCK_H #include <linux/sunrpc/svc.h> +#include <linux/sunrpc/svc_xprt.h> /* * RPC server socket. */ struct svc_sock { +struct svc_xprt sk_xprt;struct list_head sk_ready;/* list of ready sockets */ struct list_head sk_list;/* list of all sockets */ struct socket * sk_sock;/* berkeley socket layer */
@@ -78,6 +80,8 @@ int svc_addsock(struct svc_serv *serv,int fd, char *name_return, int *proto); +void svc_init_xprt_sock (void ); +void svc_cleanup_xprt_sock (void );/* * svc_makesock socket characteristics
net/sunrpc/sunrpc_syms.c +3 -1
@@ -151,7 +151,8 @@ init_sunrpc(void)#endif cache_register (&ip_map_cache);cache_register (&unix_gid_cache); -init_socket_xprt (); +svc_init_xprt_sock ();/* svc sock transport */ +init_socket_xprt ();/* clnt sock transport */ rpcauth_init_module (); out:return err;
@@ -162,6 +163,7 @@ cleanup_sunrpc(void) {rpcauth_remove_module ();cleanup_socket_xprt (); +svc_cleanup_xprt_sock ();unregister_rpc_pipefs ();rpc_destroy_mempool ();if (cache_unregister (&ip_map_cache))
net/sunrpc/svcsock.c +31 -1
@@ -75,7 +75,7 @@* */ -#define RPCDBG_FACILITY RPCDBG_SVCSOCK +#define RPCDBG_FACILITY RPCDBG_SVCXPRT static struct svc_sock *svc_setup_socket(struct svc_serv *, struct socket *,
@@ -900,12 +900,21 @@ svc_udp_sendto(struct svc_rqst *rqstp)return error; } +static struct svc_xprt_ops svc_udp_ops = { +}; + +static struct svc_xprt_class svc_udp_class = { + .xcl_name ="udp" , + .xcl_ops = &svc_udp_ops, +}; +static void svc_udp_init (struct svc_sock *svsk) {int one =1 ;mm_segment_t oldfs; +svc_xprt_init (&svc_udp_class, &svsk->sk_xprt); svsk->sk_sk->sk_data_ready = svc_udp_data_ready; svsk->sk_sk->sk_write_space = svc_write_space; svsk->sk_recvfrom = svc_udp_recvfrom;
@@ -1344,12 +1353,33 @@ svc_tcp_sendto(struct svc_rqst *rqstp)return sent; } +static struct svc_xprt_ops svc_tcp_ops = { +}; + +static struct svc_xprt_class svc_tcp_class = { + .xcl_name ="tcp" , + .xcl_ops = &svc_tcp_ops, +}; + +void svc_init_xprt_sock (void ) +{ +svc_reg_xprt_class (&svc_tcp_class); +svc_reg_xprt_class (&svc_udp_class); +} + +void svc_cleanup_xprt_sock (void ) +{ +svc_unreg_xprt_class (&svc_tcp_class); +svc_unreg_xprt_class (&svc_udp_class); +} +static void svc_tcp_init (struct svc_sock *svsk) {struct sock *sk = svsk->sk_sk;struct tcp_sock *tp =tcp_sk (sk); +svc_xprt_init (&svc_tcp_class, &svsk->sk_xprt); svsk->sk_recvfrom = svc_tcp_recvfrom; svsk->sk_sendto = svc_tcp_sendto;
PATCH 3/40 svc: Change the svc_sock in the rqstp structure to a transport
In reply to a message not in the archiveThe rqstp structure contains a pointer to the transport for the RPC request. This functionaly trivial patch adds an unamed union with pointers to both svc_sock and svc_xprt. Ultimately the union will be removed and only the rq_xprt field will remain. This allows incrementally extracting transport independent interfaces without one gigundo patch.
---
include/linux/sunrpc/svc.h | 5 ++++- 1 files changed, 4 insertions(+), 1 deletions(-)
include/linux/sunrpc/svc.h +4 -1
@@ -204,7 +204,10 @@ union svc_addr_u {struct svc_rqst {struct list_head rq_list;/* idle list */ struct list_head rq_all;/* all threads list */ -struct svc_sock * rq_sock;/* socket */ +union { +struct svc_xprt * rq_xprt;/* transport ptr */ +struct svc_sock * rq_sock;/* socket ptr */ + };struct sockaddr_storage rq_addr;/* peer address */ size_t rq_addrlen;
PATCH 4/40 svc: Add a max payload value to the transport
In reply to a message not in the archiveThe svc_max_payload function currently looks at the socket type to determine the max payload. Add a max payload value to svc_xprt_class so it can be returned directly.
---
include/linux/sunrpc/svc_xprt.h | 1 + net/sunrpc/svc.c | 4 +--- net/sunrpc/svcsock.c | 2 ++ 3 files changed, 4 insertions(+), 3 deletions(-)
include/linux/sunrpc/svc_xprt.h +1 -0
@@ -17,6 +17,7 @@ struct svc_xprt_class {struct module *xcl_owner;struct svc_xprt_ops *xcl_ops;struct list_head xcl_list; +u32 xcl_max_payload; };struct svc_xprt {
net/sunrpc/svc.c +1 -3
@@ -1054,10 +1054,8 @@ err_bad:*/ u32 svc_max_payload (const struct svc_rqst *rqstp) { -int max =RPCSVC_MAXPAYLOAD_TCP ; +u32 max = rqstp->rq_xprt->xpt_class->xcl_max_payload; -if (rqstp->rq_sock->sk_sock->type ==SOCK_DGRAM ) - max =RPCSVC_MAXPAYLOAD_UDP ;if (rqstp->rq_server->sv_max_payload < max) max = rqstp->rq_server->sv_max_payload;return max;
net/sunrpc/svcsock.c +2 -0
@@ -906,6 +906,7 @@ static struct svc_xprt_ops svc_udp_ops = {static struct svc_xprt_class svc_udp_class = { .xcl_name ="udp" , .xcl_ops = &svc_udp_ops, + .xcl_max_payload =RPCSVC_MAXPAYLOAD_UDP , }; static void
@@ -1359,6 +1360,7 @@ static struct svc_xprt_ops svc_tcp_ops = {static struct svc_xprt_class svc_tcp_class = { .xcl_name ="tcp" , .xcl_ops = &svc_tcp_ops, + .xcl_max_payload =RPCSVC_MAXPAYLOAD_TCP , };void svc_init_xprt_sock (void )
PATCH 5/40 svc: Move sk_sendto and sk_recvfrom to svc_xprt_class
In reply to a message not in the archiveThe sk_sendto and sk_recvfrom are function pointers that allow svc_sock to be used for both UDP and TCP. Move these function pointers to the svc_xprt_ops structure.
---
include/linux/sunrpc/svc_xprt.h | 2 ++ include/linux/sunrpc/svcsock.h | 3 --- net/sunrpc/svcsock.c | 12 ++++++------ 3 files changed, 8 insertions(+), 9 deletions(-)
include/linux/sunrpc/svc_xprt.h +2 -0
@@ -10,6 +10,8 @@#include <linux/sunrpc/svc.h> struct svc_xprt_ops { +int (*xpo_recvfrom)(struct svc_rqst *); +int (*xpo_sendto)(struct svc_rqst *); };struct svc_xprt_class {
include/linux/sunrpc/svcsock.h +0 -3
@@ -45,9 +45,6 @@ struct svc_sock {* be revisted */ struct mutex sk_mutex;/* to serialize sending data */ -int (*sk_recvfrom)(struct svc_rqst *rqstp); -int (*sk_sendto)(struct svc_rqst *rqstp); -/* We keep the old state_change and data_ready CB's here */ void (*sk_ostate)(struct sock *);void (*sk_odata)(struct sock *,int bytes);
net/sunrpc/svcsock.c +6 -6
@@ -901,6 +901,8 @@ svc_udp_sendto(struct svc_rqst *rqstp) }static struct svc_xprt_ops svc_udp_ops = { + .xpo_recvfrom = svc_udp_recvfrom, + .xpo_sendto = svc_udp_sendto, };static struct svc_xprt_class svc_udp_class = {
@@ -918,8 +920,6 @@ svc_udp_init(struct svc_sock *svsk)svc_xprt_init (&svc_udp_class, &svsk->sk_xprt); svsk->sk_sk->sk_data_ready = svc_udp_data_ready; svsk->sk_sk->sk_write_space = svc_write_space; - svsk->sk_recvfrom = svc_udp_recvfrom; - svsk->sk_sendto = svc_udp_sendto;/* initialise setting must have enough space to * receive and respond to one request.
@@ -1355,6 +1355,8 @@ svc_tcp_sendto(struct svc_rqst *rqstp) }static struct svc_xprt_ops svc_tcp_ops = { + .xpo_recvfrom = svc_tcp_recvfrom, + .xpo_sendto = svc_tcp_sendto, };static struct svc_xprt_class svc_tcp_class = {
@@ -1382,8 +1384,6 @@ svc_tcp_init(struct svc_sock *svsk)struct tcp_sock *tp =tcp_sk (sk);svc_xprt_init (&svc_tcp_class, &svsk->sk_xprt); - svsk->sk_recvfrom = svc_tcp_recvfrom; - svsk->sk_sendto = svc_tcp_sendto;if (sk->sk_state ==TCP_LISTEN ) {dprintk ("setting up TCP socket for listening\n" );
@@ -1531,7 +1531,7 @@ svc_recv(struct svc_rqst *rqstp, long timeout)dprintk ("svc: server %p, pool %u, socket %p, inuse=%d\n" , rqstp, pool->sp_id, svsk,atomic_read (&svsk->sk_inuse)); - len = svsk->sk_recvfrom (rqstp); + len = svsk->sk_xprt.xpt_ops->xpo_recvfrom (rqstp);dprintk ("svc: got len=%d\n" , len);/* No data, incomplete (TCP) read, or accept() */
@@ -1591,7 +1591,7 @@ svc_send(struct svc_rqst *rqstp)if (test_bit (SK_DEAD , &svsk->sk_flags)) len = -ENOTCONN ;else - len = svsk->sk_sendto (rqstp); + len = svsk->sk_xprt.xpt_ops->xpo_sendto (rqstp);mutex_unlock (&svsk->sk_mutex);svc_sock_release (rqstp);
PATCH 6/40 svc: Add transport specific xpo_release function
In reply to a message not in the archiveThe svc_sock_release function releases pages allocated to a thread. For UDP this frees the receive skb. For RDMA it will post a receive WR and bump the client credit count.
---
include/linux/sunrpc/svc.h | 2 +- include/linux/sunrpc/svc_xprt.h | 1 + net/sunrpc/svcsock.c | 17 +++++++++-------- 3 files changed, 11 insertions(+), 9 deletions(-)
include/linux/sunrpc/svc.h +1 -1
@@ -217,7 +217,7 @@ struct svc_rqst {struct auth_ops * rq_authop;/* authentication flavour */ u32 rq_flavor;/* pseudoflavor */ struct svc_cred rq_cred;/* auth info */ -struct sk_buff * rq_skbuff;/* fast recv inet buffer */ +void * rq_xprt_ctxt;/* transport specific context ptr */ struct svc_deferred_req *rq_deferred;/* deferred request we are replaying */ struct xdr_buf rq_arg;
include/linux/sunrpc/svc_xprt.h +1 -0
@@ -12,6 +12,7 @@struct svc_xprt_ops {int (*xpo_recvfrom)(struct svc_rqst *);int (*xpo_sendto)(struct svc_rqst *); +void (*xpo_release_rqst)(struct svc_rqst *); };struct svc_xprt_class {
net/sunrpc/svcsock.c +9 -8
@@ -185,14 +185,13 @@ svc_thread_dequeue(struct svc_pool *pool, struct svc_rqst *rqstp)/* * Release an skbuff after use */ -static inline void -svc_release_skb (struct svc_rqst *rqstp) +static void svc_release_skb (struct svc_rqst *rqstp) { -struct sk_buff *skb = rqstp->rq_skbuff; +struct sk_buff *skb = rqstp->rq_xprt_ctxt;struct svc_deferred_req *dr = rqstp->rq_deferred;if (skb) { - rqstp->rq_skbuff =NULL ; + rqstp->rq_xprt_ctxt =NULL ;dprintk ("svc: service %p, releasing skb %p\n" , rqstp, skb);skb_free_datagram (rqstp->rq_sock->sk_sk, skb);
@@ -395,7 +394,7 @@ svc_sock_release(struct svc_rqst *rqstp) {struct svc_sock *svsk = rqstp->rq_sock; -svc_release_skb (rqstp); + rqstp->rq_xprt->xpt_ops->xpo_release_rqst (rqstp);svc_free_res_pages (rqstp); rqstp->rq_res.page_len =0 ;
@@ -867,7 +866,7 @@ svc_udp_recvfrom(struct svc_rqst *rqstp)skb_free_datagram (svsk->sk_sk, skb);return 0 ; } - rqstp->rq_skbuff = skb; + rqstp->rq_xprt_ctxt = skb; } rqstp->rq_arg.page_base =0 ;
@@ -903,6 +902,7 @@ svc_udp_sendto(struct svc_rqst *rqstp)static struct svc_xprt_ops svc_udp_ops = { .xpo_recvfrom = svc_udp_recvfrom, .xpo_sendto = svc_udp_sendto, + .xpo_release_rqst = svc_release_skb, };static struct svc_xprt_class svc_udp_class = {
@@ -1291,7 +1291,7 @@ svc_tcp_recvfrom(struct svc_rqst *rqstp) rqstp->rq_arg.page_len = len - rqstp->rq_arg.head[0 ].iov_len; } - rqstp->rq_skbuff =NULL ; + rqstp->rq_xprt_ctxt =NULL ; rqstp->rq_prot =IPPROTO_TCP ;/* Reset TCP read info */
@@ -1357,6 +1357,7 @@ svc_tcp_sendto(struct svc_rqst *rqstp)static struct svc_xprt_ops svc_tcp_ops = { .xpo_recvfrom = svc_tcp_recvfrom, .xpo_sendto = svc_tcp_sendto, + .xpo_release_rqst = svc_release_skb, };static struct svc_xprt_class svc_tcp_class = {
@@ -1578,7 +1579,7 @@ svc_send(struct svc_rqst *rqstp) }/* release the receive skb before sending the reply */ -svc_release_skb (rqstp); + rqstp->rq_xprt->xpt_ops->xpo_release_rqst (rqstp);/* calculate over-all length */ xb = & rqstp->rq_res;
PATCH 7/40 svc: Add per-transport delete functions
In reply to a message not in the archiveAdd transport specific xpo_detach and xpo_free functions. The xpo_detach function causes the transport to stop delivering data-ready events and enqueing the transport for I/O.
The xpo_free function frees all resources associated with the particular transport instance.
---
include/linux/sunrpc/svc_xprt.h | 2 + net/sunrpc/svcsock.c | 56 ++++++++++++++++++++++++++++++--------- 2 files changed, 45 insertions(+), 13 deletions(-)
include/linux/sunrpc/svc_xprt.h +2 -0
@@ -13,6 +13,8 @@ struct svc_xprt_ops {int (*xpo_recvfrom)(struct svc_rqst *);int (*xpo_sendto)(struct svc_rqst *);void (*xpo_release_rqst)(struct svc_rqst *); +void (*xpo_detach)(struct svc_xprt *); +void (*xpo_free)(struct svc_xprt *); };struct svc_xprt_class {
net/sunrpc/svcsock.c +43 -13
92 lines not on this page · raw message
PATCH 8/40 svc: Add xpo_prep_reply_hdr
In reply to a message not in the archiveSome transports add fields to the RPC header for replies, e.g. the TCP record length. This function is called when preparing the reply header to allow each transport to add whatever fields it requires.
---
include/linux/sunrpc/svc_xprt.h | 1 + net/sunrpc/svc.c | 6 +++--- net/sunrpc/svcsock.c | 17 +++++++++++++++++ 3 files changed, 21 insertions(+), 3 deletions(-)
include/linux/sunrpc/svc_xprt.h +1 -0
@@ -11,6 +11,7 @@struct svc_xprt_ops {int (*xpo_recvfrom)(struct svc_rqst *); +void (*xpo_prep_reply_hdr)(struct svc_rqst *);int (*xpo_sendto)(struct svc_rqst *);void (*xpo_release_rqst)(struct svc_rqst *);void (*xpo_detach)(struct svc_xprt *);
net/sunrpc/svc.c +3 -3
@@ -839,9 +839,9 @@ svc_process(struct svc_rqst *rqstp) rqstp->rq_res.tail[0 ].iov_len =0 ;/* Will be turned off only in gss privacy case: */ rqstp->rq_splice_ok =1 ; -/* tcp needs a space for the record length... */ -if (rqstp->rq_prot ==IPPROTO_TCP ) -svc_putnl (resv,0 ); + +/* Setup reply header */ + rqstp->rq_xprt->xpt_ops->xpo_prep_reply_hdr (rqstp); rqstp->rq_xid =svc_getu32 (argv);svc_putu32 (resv, rqstp->rq_xid);
net/sunrpc/svcsock.c +17 -0
@@ -893,12 +893,17 @@ svc_udp_sendto(struct svc_rqst *rqstp)return error; } +static void svc_udp_prep_reply_hdr (struct svc_rqst *rqstp) +{ +} +static struct svc_xprt_ops svc_udp_ops = { .xpo_recvfrom = svc_udp_recvfrom, .xpo_sendto = svc_udp_sendto, .xpo_release_rqst = svc_release_skb, .xpo_detach = svc_sock_detach, .xpo_free = svc_sock_free, + .xpo_prep_reply_hdr = svc_udp_prep_reply_hdr, };static struct svc_xprt_class svc_udp_class = {
@@ -1350,12 +1355,24 @@ svc_tcp_sendto(struct svc_rqst *rqstp)return sent; } +/* +* Setup response header. TCP has a 4B record length field. +*/ +static void svc_tcp_prep_reply_hdr (struct svc_rqst *rqstp) +{ +struct kvec *resv = &rqstp->rq_res.head[0 ]; + +/* tcp needs a space for the record length... */ +svc_putnl (resv,0 ); +} +static struct svc_xprt_ops svc_tcp_ops = { .xpo_recvfrom = svc_tcp_recvfrom, .xpo_sendto = svc_tcp_sendto, .xpo_release_rqst = svc_release_skb, .xpo_detach = svc_sock_detach, .xpo_free = svc_sock_free, + .xpo_prep_reply_hdr = svc_tcp_prep_reply_hdr, };static struct svc_xprt_class svc_tcp_class = {
PATCH 9/40 svc: Add a transport function that checks for write space
In reply to a message not in the archiveIn order to avoid blocking a service thread, the receive side checks to see if there is sufficient write space to reply to the request. Each transport has a different mechanism for determining if there is enough write space to reply.
The code that checked for write space was coupled with code that checked for CLOSE and CONN. These checks have been broken out into separate statements to make the code easier to read.
---
include/linux/sunrpc/svc_xprt.h | 1 net/sunrpc/svcsock.c | 82 +++++++++++++++++++++++++++------------ 2 files changed, 57 insertions(+), 26 deletions(-)
include/linux/sunrpc/svc_xprt.h +1 -0
@@ -10,6 +10,7 @@#include <linux/sunrpc/svc.h> struct svc_xprt_ops { +int (*xpo_has_wspace)(struct svc_xprt *);int (*xpo_recvfrom)(struct svc_rqst *);void (*xpo_prep_reply_hdr)(struct svc_rqst *);int (*xpo_sendto)(struct svc_rqst *);
net/sunrpc/svcsock.c +56 -26
124 lines not on this page · raw message
PATCH 10/40 svc: Move close processing to a single place
In reply to a message not in the archiveClose handling was duplicated in the UDP and TCP recvfrom methods. This code has been moved to the transport independent svc_recv function.
---
net/sunrpc/svcsock.c | 26 +++++++++++--------------- 1 files changed, 11 insertions(+), 15 deletions(-)
net/sunrpc/svcsock.c +11 -15
@@ -776,11 +776,6 @@ svc_udp_recvfrom(struct svc_rqst *rqstp)return svc_deferred_recv (rqstp); } -if (test_bit (SK_CLOSE , &svsk->sk_flags)) { -svc_delete_socket (svsk); -return 0 ; - } -clear_bit (SK_DATA , &svsk->sk_flags); skb =NULL ; err = kernel_recvmsg(svsk->sk_sock, &msg, NULL,
@@ -1181,11 +1176,6 @@ svc_tcp_recvfrom(struct svc_rqst *rqstp)return svc_deferred_recv (rqstp); } -if (test_bit (SK_CLOSE , &svsk->sk_flags)) { -svc_delete_socket (svsk); -return 0 ; - } -if (svsk->sk_sk->sk_state ==TCP_LISTEN ) {svc_tcp_accept (svsk);svc_sock_received (svsk);
@@ -1311,7 +1301,7 @@ svc_tcp_recvfrom(struct svc_rqst *rqstp)return len; err_delete: -svc_delete_socket (svsk); +set_bit (SK_CLOSE , &svsk->sk_flags);return -EAGAIN ; error:
@@ -1575,10 +1565,16 @@ svc_recv(struct svc_rqst *rqstp, long timeout) }spin_unlock_bh (&pool->sp_lock); -dprintk ("svc: server %p, pool %u, socket %p, inuse=%d\n" , - rqstp, pool->sp_id, svsk,atomic_read (&svsk->sk_inuse)); - len = svsk->sk_xprt.xpt_ops->xpo_recvfrom (rqstp); -dprintk ("svc: got len=%d\n" , len); + len =0 ; +if (test_bit (SK_CLOSE , &svsk->sk_flags)) { +dprintk ("svc_recv: found SK_CLOSE\n" ); +svc_delete_socket (svsk); + }else { +dprintk ("svc: server %p, pool %u, socket %p, inuse=%d\n" , + rqstp, pool->sp_id, svsk,atomic_read (&svsk->sk_inuse)); + len = svsk->sk_xprt.xpt_ops->xpo_recvfrom (rqstp); +dprintk ("svc: got len=%d\n" , len); + }/* No data, incomplete (TCP) read, or accept() */ if (len ==0 || len == -EAGAIN ) {
PATCH 11/40 svc: Add xpo_accept transport function
In reply to a message not in the archivePreviously, the accept logic looked into the socket state to determine whether to call accept or recv when data-ready was indicated on an endpoint. Since some transports don't use sockets, this logic now uses a flag bit (SK_LISTENER) to identify listening endpoints. A transport function (xpo_accept) allows each transport to define its own accept processing. A transport's initialization logic is reponsible for setting the SK_LISTENER bit. I didn't see any way to do this in transport independent logic since the passive side of a UDP connection doesn't listen and always recv's.
In the svc_recv function, if the SK_LISTENER bit is set, the transport xpo_accept function is called to handle accept processing.
Note that all functions are defined even if they don't make sense for a given transport. For example, accept doesn't mean anything for UDP. The function is defined anyway and bug checks if called. The UDP transport should never set the SK_LISTENER bit.
---
include/linux/sunrpc/svc_xprt.h | 1 + include/linux/sunrpc/svcsock.h | 1 + net/sunrpc/svcsock.c | 31 +++++++++++++++++++------------ 3 files changed, 21 insertions(+), 12 deletions(-)
include/linux/sunrpc/svc_xprt.h +1 -0
@@ -10,6 +10,7 @@#include <linux/sunrpc/svc.h> struct svc_xprt_ops { +struct svc_xprt *(*xpo_accept)(struct svc_xprt *);int (*xpo_has_wspace)(struct svc_xprt *);int (*xpo_recvfrom)(struct svc_rqst *);void (*xpo_prep_reply_hdr)(struct svc_rqst *);
include/linux/sunrpc/svcsock.h +1 -0
@@ -36,6 +36,7 @@ struct svc_sock {#define SK_DEFERRED 8/* request on sk_deferred */ #define SK_OLD 9/* used for temp socket aging mark+sweep */ #define SK_DETACHED 10/* detached from tempsocks list */ +#define SK_LISTENER 11/* listening endpoint */ atomic_t sk_reserved;/* space on outq that is reserved */
net/sunrpc/svcsock.c +19 -12
@@ -896,6 +896,12 @@ static int svc_udp_has_wspace(struct svc_xprt *xprt)return 1 ; } +static struct svc_xprt *svc_udp_accept (struct svc_xprt *xprt) +{ +BUG (); +return NULL ; +} +static struct svc_xprt_ops svc_udp_ops = { .xpo_recvfrom = svc_udp_recvfrom, .xpo_sendto = svc_udp_sendto,
@@ -904,6 +910,7 @@ static struct svc_xprt_ops svc_udp_ops = { .xpo_free = svc_sock_free, .xpo_prep_reply_hdr = svc_udp_prep_reply_hdr, .xpo_has_wspace = svc_udp_has_wspace, + .xpo_accept = svc_udp_accept, };static struct svc_xprt_class svc_udp_class = {
@@ -1028,9 +1035,9 @@ static inline int svc_port_is_privileged(struct sockaddr *sin)/* * Accept a TCP connection */ -static void -svc_tcp_accept (struct svc_sock *svsk) +static struct svc_xprt *svc_tcp_accept (struct svc_xprt *xprt) { + struct svc_sock *svsk = container_of(xprt, struct svc_sock, sk_xprt);struct sockaddr_storage addr;struct sockaddr *sin = (struct sockaddr *) &addr;struct svc_serv *serv = svsk->sk_server;
@@ -1042,7 +1049,7 @@ svc_tcp_accept(struct svc_sock *svsk)dprintk ("svc: tcp_accept %p sock %p\n" , svsk, sock);if (!sock) -return ; +return NULL ;clear_bit (SK_CONN , &svsk->sk_flags); err =kernel_accept (sock, &newsock,O_NONBLOCK );
@@ -1053,7 +1060,7 @@ svc_tcp_accept(struct svc_sock *svsk)else if (err != -EAGAIN &&net_ratelimit ())printk (KERN_WARNING "%s: accept failed (err %d)!\n" , serv->sv_name, -err); -return ; +return NULL ; }set_bit (SK_CONN , &svsk->sk_flags);
@@ -1147,11 +1154,11 @@ svc_tcp_accept(struct svc_sock *svsk)if (serv->sv_stats) serv->sv_stats->nettcpconn++; -return ; +return &newsvsk->sk_xprt; failed:sock_release (newsock); -return ; +return NULL ; }/*
@@ -1176,12 +1183,6 @@ svc_tcp_recvfrom(struct svc_rqst *rqstp)return svc_deferred_recv (rqstp); } -if (svsk->sk_sk->sk_state ==TCP_LISTEN ) { -svc_tcp_accept (svsk); -svc_sock_received (svsk); -return 0 ; - } -if (test_and_clear_bit (SK_CHNGBUF , &svsk->sk_flags))/* sndbuf needs to have room for one request * per thread, otherwise we can stall even when the
@@ -1393,6 +1394,7 @@ static struct svc_xprt_ops svc_tcp_ops = { .xpo_free = svc_sock_free, .xpo_prep_reply_hdr = svc_tcp_prep_reply_hdr, .xpo_has_wspace = svc_tcp_has_wspace, + .xpo_accept = svc_tcp_accept, };static struct svc_xprt_class svc_tcp_class = {
@@ -1423,6 +1425,7 @@ svc_tcp_init(struct svc_sock *svsk)if (sk->sk_state ==TCP_LISTEN ) {dprintk ("setting up TCP socket for listening\n" ); +set_bit (SK_LISTENER , &svsk->sk_flags); sk->sk_data_ready = svc_tcp_listen_data_ready;set_bit (SK_CONN , &svsk->sk_flags); }else {
@@ -1569,6 +1572,10 @@ svc_recv(struct svc_rqst *rqstp, long timeout)if (test_bit (SK_CLOSE , &svsk->sk_flags)) {dprintk ("svc_recv: found SK_CLOSE\n" );svc_delete_socket (svsk); + }else if (test_bit (SK_LISTENER , &svsk->sk_flags)) { +struct svc_xprt *newxpt; + newxpt = svsk->sk_xprt.xpt_ops->xpo_accept (&svsk->sk_xprt); +svc_sock_received (svsk); }else {dprintk ("svc: server %p, pool %u, socket %p, inuse=%d\n" , rqstp, pool->sp_id, svsk,atomic_read (&svsk->sk_inuse));
PATCH 12/40 svc: Remove unnecessary call to svc_sock_enqueue
In reply to a message not in the archiveThe svc_tcp_accept function calls svc_sock_enqueue after setting the SK_CONN bit. This doesn't actually do anything because the SK_BUSY bit is still set. The call is unnecessary anyway because the generic code in svc_recv calls svc_sock_received after calling the accept function.
---
net/sunrpc/svcsock.c | 1 - 1 files changed, 0 insertions(+), 1 deletions(-)
net/sunrpc/svcsock.c +0 -1
@@ -1064,7 +1064,6 @@ static struct svc_xprt *svc_tcp_accept(struct svc_xprt *xprt) }set_bit (SK_CONN , &svsk->sk_flags); -svc_sock_enqueue (svsk); err =kernel_getpeername (newsock, sin, &slen);if (err <0 ) {
PATCH 13/40 svc: Move connection limit checking to its own function
In reply to a message not in the archiveMove the code that poaches connections when the connection limit is hit to a subroutine to make the accept logic path easier to follow. Since this is in the new connection path, it should not be a performance issue.
---
net/sunrpc/svcsock.c | 57 +++++++++++++++++++++++++------------------------- 1 files changed, 29 insertions(+), 28 deletions(-)
net/sunrpc/svcsock.c +29 -28
@@ -1105,17 +1105,30 @@ static struct svc_xprt *svc_tcp_accept(struct svc_xprt *xprt)svc_sock_received (newsvsk); -/* make sure that we don't have too many active connections. -* If we have, something must be dropped. -* -* There's no point in trying to do random drop here for -* DoS prevention. The NFS clients does 1 reconnect in 15 -* seconds. An attacker can easily beat that. -* -* The only somewhat efficient mechanism would be if drop -* old connections from the same IP first. But right now -* we don't even record the client IP in svc_sock. -*/ +if (serv->sv_stats) + serv->sv_stats->nettcpconn++; + +return &newsvsk->sk_xprt; + +failed: +sock_release (newsock); +return NULL ; +} + +/* +* Make sure that we don't have too many active connections. If we +* have, something must be dropped. +* +* There's no point in trying to do random drop here for DoS +* prevention. The NFS clients does 1 reconnect in 15 seconds. An +* attacker can easily beat that. +* +* The only somewhat efficient mechanism would be if drop old +* connections from the same IP first. But right now we don't even +* record the client IP in svc_sock. +*/ +static void svc_check_conn_limits (struct svc_serv *serv) +{if (serv->sv_tmpcnt > (serv->sv_nrthreads+3 )*20 ) {struct svc_sock *svsk =NULL ;spin_lock_bh (&serv->sv_lock);
@@ -1123,13 +1136,9 @@ static struct svc_xprt *svc_tcp_accept(struct svc_xprt *xprt)if (net_ratelimit ()) {/* Try to help the admin */ printk (KERN_NOTICE "%s: too many open TCP " -"sockets, consider increasing the " -"number of nfsd threads\n" , - serv->sv_name); -printk (KERN_NOTICE -"%s: last TCP connect from %s\n" , - serv->sv_name,__svc_print_addr (sin, - buf,sizeof (buf))); +"sockets, consider increasing the " +"number of nfsd threads\n" , + serv->sv_name); }/* * Always select the oldest socket. It's not fair,
@@ -1147,17 +1156,7 @@ static struct svc_xprt *svc_tcp_accept(struct svc_xprt *xprt)svc_sock_enqueue (svsk);svc_sock_put (svsk); } - } - -if (serv->sv_stats) - serv->sv_stats->nettcpconn++; - -return &newsvsk->sk_xprt; - -failed: -sock_release (newsock); -return NULL ; }/*
@@ -1574,6 +1573,8 @@ svc_recv(struct svc_rqst *rqstp, long timeout) }else if (test_bit (SK_LISTENER , &svsk->sk_flags)) {struct svc_xprt *newxpt; newxpt = svsk->sk_xprt.xpt_ops->xpo_accept (&svsk->sk_xprt); +if (newxpt) +svc_check_conn_limits (svsk->sk_server);svc_sock_received (svsk); }else { dprintk("svc: server %p, pool %u, socket %p, inuse=%d\n",
PATCH 14/40 svc: Add a generic transport svc_create_xprt function
In reply to a message not in the archiveThe svc_create_xprt function is a transport independent version of the svc_makesock function.
Since transport instance creation contains transport dependent and independent components, add an xpo_create transport function. The transport implementation of this function allocates the memory for the endpoint, implements the transport dependent initialization logic, and calls svc_xprt_init to initialize the transport independent field (svc_xprt) in it's data structure.
---
include/linux/sunrpc/svc_xprt.h | 4 +++ net/sunrpc/svc_xprt.c | 37 ++++++++++++++++++++++++ net/sunrpc/svcsock.c | 59 +++++++++++++++++++++++++++++---------- 3 files changed, 85 insertions(+), 15 deletions(-)
include/linux/sunrpc/svc_xprt.h +4 -0
@@ -10,6 +10,9 @@#include <linux/sunrpc/svc.h> struct svc_xprt_ops { +struct svc_xprt *(*xpo_create)(struct svc_serv *, +struct sockaddr *,int , +int );struct svc_xprt *(*xpo_accept)(struct svc_xprt *);int (*xpo_has_wspace)(struct svc_xprt *);int (*xpo_recvfrom)(struct svc_rqst *);
@@ -36,5 +39,6 @@ struct svc_xprt {int svc_reg_xprt_class (struct svc_xprt_class *);void svc_unreg_xprt_class (struct svc_xprt_class *);void svc_xprt_init (struct svc_xprt_class *,struct svc_xprt *); +int svc_create_xprt (struct svc_serv *,char *,unsigned short ,int );#endif /* SUNRPC_SVC_XPRT_H */
net/sunrpc/svc_xprt.c +37 -0
@@ -81,3 +81,40 @@ void svc_xprt_init(struct svc_xprt_class *xcl, struct svc_xprt *xprt) xprt->xpt_ops = xcl->xcl_ops; }EXPORT_SYMBOL_GPL (svc_xprt_init); + +int svc_create_xprt (struct svc_serv *serv,char *xprt_name,unsigned short port, +int flags) +{ +struct svc_xprt_class *xcl; +int ret = -ENOENT ; +struct sockaddr_in sin = { + .sin_family =AF_INET , + .sin_addr.s_addr =INADDR_ANY , + .sin_port =htons (port), + }; +dprintk ("svc: creating transport %s[%d]\n" , xprt_name, port); +spin_lock (&svc_xprt_class_lock); +list_for_each_entry (xcl, &svc_xprt_class_list, xcl_list) { +if (strcmp (xprt_name, xcl->xcl_name) ==0 ) { +spin_unlock (&svc_xprt_class_lock); +if (try_module_get (xcl->xcl_owner)) { +struct svc_xprt *newxprt; + ret =0 ; + newxprt = xcl->xcl_ops->xpo_create + (serv, + (struct sockaddr *)&sin,sizeof (sin), + flags); +if (IS_ERR (newxprt)) { +module_put (xcl->xcl_owner); + ret =PTR_ERR (newxprt); + } + } + goto out; + } + } +spin_unlock (&svc_xprt_class_lock); +dprintk ("svc: transport %s not found\n" , xprt_name); + out: +return ret; +} +EXPORT_SYMBOL_GPL (svc_create_xprt);
net/sunrpc/svcsock.c +44 -15
139 lines not on this page · raw message
PATCH 15/40 svc: Change services to use new svc_create_xprt service
In reply to a message not in the archiveModify the various kernel RPC svcs to use the svc_create_xprt service.
---
fs/lockd/svc.c | 17 ++++++++--------- fs/nfs/callback.c | 4 ++-- fs/nfsd/nfssvc.c | 4 ++-- include/linux/sunrpc/svcsock.h | 1 - net/sunrpc/sunrpc_syms.c | 1 - net/sunrpc/svcsock.c | 22 ---------------------- 6 files changed, 12 insertions(+), 37 deletions(-)
fs/lockd/svc.c +8 -9
@@ -219,13 +219,12 @@ lockd(struct svc_rqst *rqstp)module_put_and_exit (0 ); } - -static int find_socket (struct svc_serv *serv,int proto) +static int find_xprt (struct svc_serv *serv,char *proto) {struct svc_sock *svsk;int found =0 ;list_for_each_entry (svsk, &serv->sv_permsocks, sk_list) -if (svsk->sk_sk->sk_protocol == proto) { +if (strcmp (svsk->sk_xprt.xpt_class->xcl_name, proto) ==0 ) { found =1 ;break ; }
@@ -243,13 +242,13 @@ static int make_socks(struct svc_serv *serv, int proto)int err =0 ;if (proto ==IPPROTO_UDP || nlm_udpport) -if (!find_socket (serv,IPPROTO_UDP )) - err =svc_makesock (serv,IPPROTO_UDP , nlm_udpport, -SVC_SOCK_DEFAULTS ); +if (!find_xprt (serv,"udp" )) + err =svc_create_xprt (serv,"udp" , nlm_udpport, +SVC_SOCK_DEFAULTS );if (err >=0 && (proto ==IPPROTO_TCP || nlm_tcpport)) -if (!find_socket (serv,IPPROTO_TCP )) - err =svc_makesock (serv,IPPROTO_TCP , nlm_tcpport, -SVC_SOCK_DEFAULTS ); +if (!find_xprt (serv,"tcp" )) + err =svc_create_xprt (serv,"tcp" , nlm_tcpport, +SVC_SOCK_DEFAULTS );if (err >=0 ) { warned =0 ;
fs/nfs/callback.c +2 -2
@@ -123,8 +123,8 @@ int nfs_callback_up(void)if (!serv) goto out_err; - ret =svc_makesock (serv,IPPROTO_TCP , nfs_callback_set_tcpport, -SVC_SOCK_ANONYMOUS ); + ret =svc_create_xprt (serv,"tcp" , nfs_callback_set_tcpport, +SVC_SOCK_ANONYMOUS );if (ret <=0 ) goto out_destroy; nfs_callback_tcpport = ret;
fs/nfsd/nfssvc.c +2 -2
@@ -236,7 +236,7 @@ static int nfsd_init_socks(int port) error =lockd_up (IPPROTO_UDP );if (error >=0 ) { - error =svc_makesock (nfsd_serv,IPPROTO_UDP , port, + error =svc_create_xprt (nfsd_serv,"udp" , port,SVC_SOCK_DEFAULTS );if (error <0 )lockd_down ();
@@ -247,7 +247,7 @@ static int nfsd_init_socks(int port)#ifdef CONFIG_NFSD_TCP error =lockd_up (IPPROTO_TCP );if (error >=0 ) { - error =svc_makesock (nfsd_serv,IPPROTO_TCP , port, + error =svc_create_xprt (nfsd_serv,"tcp" , port,SVC_SOCK_DEFAULTS );if (error <0 )lockd_down ();
include/linux/sunrpc/svcsock.h +0 -1
@@ -67,7 +67,6 @@ struct svc_sock {/* * Function prototypes. */ -int svc_makesock (struct svc_serv *,int ,unsigned short ,int flags);void svc_force_close_socket (struct svc_sock *);int svc_recv (struct svc_rqst *,long );int svc_send (struct svc_rqst *);
net/sunrpc/sunrpc_syms.c +0 -1
@@ -72,7 +72,6 @@ EXPORT_SYMBOL(svc_drop);EXPORT_SYMBOL (svc_process);EXPORT_SYMBOL (svc_recv);EXPORT_SYMBOL (svc_wake_up); -EXPORT_SYMBOL (svc_makesock);EXPORT_SYMBOL (svc_reserve);EXPORT_SYMBOL (svc_auth_register);EXPORT_SYMBOL (auth_domain_lookup);
net/sunrpc/svcsock.c +0 -22
@@ -1988,28 +1988,6 @@ void svc_force_close_socket(struct svc_sock *svsk)svc_close_socket (svsk); } -/** -* svc_makesock - Make a socket for nfsd and lockd -* @serv: RPC server structure -* @protocol: transport protocol to use -* @port: port to use -* @flags: requested socket characteristics -* -*/ -int svc_makesock (struct svc_serv *serv,int protocol,unsigned short port, -int flags) -{ -dprintk ("svc: creating socket proto = %d\n" , protocol); -switch (protocol) { -case IPPROTO_TCP : -return svc_create_xprt (serv,"tcp" , port, flags); -case IPPROTO_UDP : -return svc_create_xprt (serv,"udp" , port, flags); -default : -return -EINVAL ; - } -} -/* * Handle defer and revisit of requests */
PATCH 16/40 svc: Change sk_inuse to a kref
In reply to a message not in the archiveChange the atomic_t reference count to a kref and move it to the transport indepenent svc_xprt structure. Change the reference count wrapper names to be generic.
---
include/linux/sunrpc/svc_xprt.h | 8 ++ include/linux/sunrpc/svcsock.h | 1 net/sunrpc/svc_xprt.c | 16 +++++ net/sunrpc/svcsock.c | 138 ++++++++++++++++++--------------------- 4 files changed, 87 insertions(+), 76 deletions(-)
include/linux/sunrpc/svc_xprt.h +8 -0
@@ -8,6 +8,7 @@#define SUNRPC_SVC_XPRT_H #include <linux/sunrpc/svc.h> +#include <linux/module.h> struct svc_xprt_ops { struct svc_xprt *(*xpo_create)(struct svc_serv *,
@@ -34,11 +35,18 @@ struct svc_xprt_class {struct svc_xprt {struct svc_xprt_class *xpt_class;struct svc_xprt_ops *xpt_ops; +struct kref xpt_ref; };int svc_reg_xprt_class (struct svc_xprt_class *);void svc_unreg_xprt_class (struct svc_xprt_class *);void svc_xprt_init (struct svc_xprt_class *,struct svc_xprt *);int svc_create_xprt (struct svc_serv *,char *,unsigned short ,int ); +void svc_xprt_put (struct svc_xprt *xprt); + +static inline void svc_xprt_get (struct svc_xprt *xprt) +{ +kref_get (&xprt->xpt_ref); +}#endif /* SUNRPC_SVC_XPRT_H */
include/linux/sunrpc/svcsock.h +0 -1
@@ -24,7 +24,6 @@ struct svc_sock {struct svc_pool * sk_pool;/* current pool iff queued */ struct svc_serv * sk_server;/* service for this socket */ -atomic_t sk_inuse;/* use count */ unsigned long sk_flags;#define SK_BUSY 0/* enqueued/receiving */ #define SK_CONN 1/* conn pending */
net/sunrpc/svc_xprt.c +16 -0
@@ -70,6 +70,21 @@ void svc_unreg_xprt_class(struct svc_xprt_class *xcl) }EXPORT_SYMBOL_GPL (svc_unreg_xprt_class); +static void svc_xprt_free (struct kref *kref) +{ +struct svc_xprt *xprt = + container_of(kref, struct svc_xprt, xpt_ref); +struct module *owner = xprt->xpt_class->xcl_owner; + xprt->xpt_ops->xpo_free (xprt); +module_put (owner); +} + +void svc_xprt_put (struct svc_xprt *xprt) +{ +kref_put (&xprt->xpt_ref, svc_xprt_free); +} +EXPORT_SYMBOL_GPL (svc_xprt_put); +/* * Called by transport drivers to initialize the transport independent * portion of the transport instance.
@@ -79,6 +94,7 @@ void svc_xprt_init(struct svc_xprt_class *xcl, struct svc_xprt *xprt)memset (xprt,0 ,sizeof (*xprt)); xprt->xpt_class = xcl; xprt->xpt_ops = xcl->xcl_ops; +kref_init (&xprt->xpt_ref); }EXPORT_SYMBOL_GPL (svc_xprt_init);
net/sunrpc/svcsock.c +63 -75
245 lines not on this page · raw message
PATCH 17/40 svc: Move sk_flags to the svc_xprt structure
In reply to a message not in the archiveThis functionally trivial change moves the transport independent sk_flags field to the transport independent svc_xprt structure.
---
include/linux/sunrpc/svc_xprt.h | 12 +++ include/linux/sunrpc/svcsock.h | 13 --- net/sunrpc/svcsock.c | 151 ++++++++++++++++++++------------------- 3 files changed, 88 insertions(+), 88 deletions(-)
include/linux/sunrpc/svc_xprt.h +12 -0
@@ -36,6 +36,18 @@ struct svc_xprt {struct svc_xprt_class *xpt_class;struct svc_xprt_ops *xpt_ops;struct kref xpt_ref; +unsigned long xpt_flags; +#define XPT_BUSY 0/* enqueued/receiving */ +#define XPT_CONN 1/* conn pending */ +#define XPT_CLOSE 2/* dead or dying */ +#define XPT_DATA 3/* data pending */ +#define XPT_TEMP 4/* connected transport */ +#define XPT_DEAD 6/* transport closed */ +#define XPT_CHNGBUF 7/* need to change snd/rcv buf sizes */ +#define XPT_DEFERRED 8/* deferred request pending */ +#define XPT_OLD 9/* used for xprt aging mark+sweep */ +#define XPT_DETACHED 10/* detached from tempsocks list */ +#define XPT_LISTENER 11/* listening endpoint */ };int svc_reg_xprt_class (struct svc_xprt_class *);
include/linux/sunrpc/svcsock.h +0 -13
@@ -24,19 +24,6 @@ struct svc_sock {struct svc_pool * sk_pool;/* current pool iff queued */ struct svc_serv * sk_server;/* service for this socket */ -unsigned long sk_flags; -#define SK_BUSY 0/* enqueued/receiving */ -#define SK_CONN 1/* conn pending */ -#define SK_CLOSE 2/* dead or dying */ -#define SK_DATA 3/* data pending */ -#define SK_TEMP 4/* temp (TCP) socket */ -#define SK_DEAD 6/* socket closed */ -#define SK_CHNGBUF 7/* need to change snd/rcv buffer sizes */ -#define SK_DEFERRED 8/* request on sk_deferred */ -#define SK_OLD 9/* used for temp socket aging mark+sweep */ -#define SK_DETACHED 10/* detached from tempsocks list */ -#define SK_LISTENER 11/* listening endpoint */ -atomic_t sk_reserved;/* space on outq that is reserved */ spinlock_t sk_lock;/* protects sk_deferred and
net/sunrpc/svcsock.c +76 -75
464 lines not on this page · raw message
PATCH 18/40 svc: Move sk_server and sk_pool to svc_xprt
In reply to a message not in the archiveThis is another incremental change that moves transport independent fields from svc_sock to the svc_xprt structure. The changes should be functionally null.
---
include/linux/sunrpc/svc_xprt.h | 6 +++- include/linux/sunrpc/svcsock.h | 2 - net/sunrpc/svc_xprt.c | 4 ++- net/sunrpc/svcsock.c | 57 ++++++++++++++++++--------------------- 4 files changed, 35 insertions(+), 34 deletions(-)
include/linux/sunrpc/svc_xprt.h +5 -1
@@ -48,11 +48,15 @@ struct svc_xprt {#define XPT_OLD 9/* used for xprt aging mark+sweep */ #define XPT_DETACHED 10/* detached from tempsocks list */ #define XPT_LISTENER 11/* listening endpoint */ + +struct svc_pool *xpt_pool;/* current pool iff queued */ +struct svc_serv *xpt_server;/* service for transport */ };int svc_reg_xprt_class (struct svc_xprt_class *);void svc_unreg_xprt_class (struct svc_xprt_class *); -void svc_xprt_init (struct svc_xprt_class *,struct svc_xprt *); +void svc_xprt_init (struct svc_xprt_class *,struct svc_xprt *, +struct svc_serv *);int svc_create_xprt (struct svc_serv *,char *,unsigned short ,int );void svc_xprt_put (struct svc_xprt *xprt);
include/linux/sunrpc/svcsock.h +0 -2
@@ -22,8 +22,6 @@ struct svc_sock {struct socket * sk_sock;/* berkeley socket layer */ struct sock * sk_sk;/* INET layer */ -struct svc_pool * sk_pool;/* current pool iff queued */ -struct svc_serv * sk_server;/* service for this socket */ atomic_t sk_reserved;/* space on outq that is reserved */ spinlock_t sk_lock;/* protects sk_deferred and
net/sunrpc/svc_xprt.c +3 -1
@@ -89,12 +89,14 @@ EXPORT_SYMBOL_GPL(svc_xprt_put);* Called by transport drivers to initialize the transport independent * portion of the transport instance. */ -void svc_xprt_init (struct svc_xprt_class *xcl,struct svc_xprt *xprt) +void svc_xprt_init (struct svc_xprt_class *xcl,struct svc_xprt *xprt, +struct svc_serv *serv) {memset (xprt,0 ,sizeof (*xprt)); xprt->xpt_class = xcl; xprt->xpt_ops = xcl->xcl_ops;kref_init (&xprt->xpt_ref); + xprt->xpt_server = serv; }EXPORT_SYMBOL_GPL (svc_xprt_init);
net/sunrpc/svcsock.c +27 -30
196 lines not on this page · raw message
PATCH 19/40 svc: Make close transport independent
In reply to a message not in the archiveMove sk_list and sk_ready to svc_xprt. This involves close because these lists are walked by svcs when closing all their transports. So I combined the moving of these lists to svc_xprt with making close transport independent.
The svc_force_sock_close has been changed to svc_close_all and takes a list as an argument. This removes some svc internals knowledge from the svcs.
This code races with module removal and transport addition.
---
fs/lockd/svc.c | 6 +- fs/nfsd/nfssvc.c | 4 +- include/linux/sunrpc/svc_xprt.h | 2 + include/linux/sunrpc/svcsock.h | 4 -- net/sunrpc/svc.c | 9 +-- net/sunrpc/svc_xprt.c | 2 + net/sunrpc/svcsock.c | 102 +++++++++++++++++++-------------------- 7 files changed, 61 insertions(+), 68 deletions(-)
fs/lockd/svc.c +3 -3
@@ -221,10 +221,10 @@ lockd(struct svc_rqst *rqstp)static int find_xprt (struct svc_serv *serv,char *proto) { -struct svc_sock *svsk; +struct svc_xprt *xprt;int found =0 ; -list_for_each_entry (svsk, &serv->sv_permsocks, sk_list) -if (strcmp (svsk->sk_xprt.xpt_class->xcl_name, proto) ==0 ) { +list_for_each_entry (xprt, &serv->sv_permsocks, xpt_list) +if (strcmp (xprt->xpt_class->xcl_name, proto) ==0 ) { found =1 ;break ; }
fs/nfsd/nfssvc.c +2 -2
@@ -155,8 +155,8 @@ static int killsig; /* signal that was used to kill last nfsd */static void nfsd_last_thread (struct svc_serv *serv) {/* When last nfsd thread exits we need to do some clean-up */ -struct svc_sock *svsk; -list_for_each_entry (svsk, &serv->sv_permsocks, sk_list) +struct svc_xprt *xprt; +list_for_each_entry (xprt, &serv->sv_permsocks, xpt_list)lockd_down (); nfsd_serv =NULL ;nfsd_racache_shutdown ();
include/linux/sunrpc/svc_xprt.h +2 -0
@@ -36,6 +36,8 @@ struct svc_xprt {struct svc_xprt_class *xpt_class;struct svc_xprt_ops *xpt_ops;struct kref xpt_ref; +struct list_head xpt_list; +struct list_head xpt_ready;unsigned long xpt_flags;#define XPT_BUSY 0/* enqueued/receiving */ #define XPT_CONN 1/* conn pending */
include/linux/sunrpc/svcsock.h +1 -3
@@ -17,8 +17,6 @@*/ struct svc_sock {struct svc_xprt sk_xprt; -struct list_head sk_ready;/* list of ready sockets */ -struct list_head sk_list;/* list of all sockets */ struct socket * sk_sock;/* berkeley socket layer */ struct sock * sk_sk;/* INET layer */
@@ -51,7 +49,7 @@ struct svc_sock {/* * Function prototypes. */ -void svc_force_close_socket (struct svc_sock *); +void svc_close_all (struct list_head *);int svc_recv (struct svc_rqst *,long );int svc_send (struct svc_rqst *);void svc_drop (struct svc_rqst *);
net/sunrpc/svc.c +2 -7
@@ -458,9 +458,6 @@ svc_create_pooled(struct svc_program *prog, unsigned int bufsize,void svc_destroy (struct svc_serv *serv) { -struct svc_sock *svsk; -struct svc_sock *tmp; -dprintk ("svc: svc_destroy(%s, %d)\n" , serv->sv_program->pg_name, serv->sv_nrthreads);
@@ -475,14 +472,12 @@ svc_destroy(struct svc_serv *serv)del_timer_sync (&serv->sv_temptimer); -list_for_each_entry_safe (svsk, tmp, &serv->sv_tempsocks, sk_list) -svc_force_close_socket (svsk); +svc_close_all (&serv->sv_tempsocks);if (serv->sv_shutdown) serv->sv_shutdown (serv); -list_for_each_entry_safe (svsk, tmp, &serv->sv_permsocks, sk_list) -svc_force_close_socket (svsk); +svc_close_all (&serv->sv_permsocks);BUG_ON (!list_empty (&serv->sv_permsocks));BUG_ON (!list_empty (&serv->sv_tempsocks));
net/sunrpc/svc_xprt.c +2 -0
@@ -97,6 +97,8 @@ void svc_xprt_init(struct svc_xprt_class *xcl, struct svc_xprt *xprt, xprt->xpt_ops = xcl->xcl_ops;kref_init (&xprt->xpt_ref); xprt->xpt_server = serv; +INIT_LIST_HEAD (&xprt->xpt_list); +INIT_LIST_HEAD (&xprt->xpt_ready); }EXPORT_SYMBOL_GPL (svc_xprt_init);
net/sunrpc/svcsock.c +49 -53
218 lines not on this page · raw message
PATCH 20/40 svc: Move sk_reserved to svc_xprt
In reply to a message not in the archiveThis functionally trivial patch moves the sk_reserved field to the transport independent svc_xprt structure.
---
include/linux/sunrpc/svc_xprt.h | 1 + include/linux/sunrpc/svcsock.h | 2 -- net/sunrpc/svcsock.c | 10 +++++----- 3 files changed, 6 insertions(+), 7 deletions(-)
include/linux/sunrpc/svc_xprt.h +1 -0
@@ -53,6 +53,7 @@ struct svc_xprt {struct svc_pool *xpt_pool;/* current pool iff queued */ struct svc_serv *xpt_server;/* service for transport */ +atomic_t xpt_reserved;/* space on outq that is rsvd */ };int svc_reg_xprt_class (struct svc_xprt_class *);
include/linux/sunrpc/svcsock.h +0 -2
@@ -20,8 +20,6 @@ struct svc_sock {struct socket * sk_sock;/* berkeley socket layer */ struct sock * sk_sk;/* INET layer */ -atomic_t sk_reserved;/* space on outq that is reserved */ -spinlock_t sk_lock;/* protects sk_deferred and * sk_info_authunix */ struct list_head sk_deferred;/* deferred requests that need to
net/sunrpc/svcsock.c +5 -5
@@ -288,7 +288,7 @@ svc_sock_enqueue(struct svc_sock *svsk) rqstp->rq_sock = svsk;svc_xprt_get (&svsk->sk_xprt); rqstp->rq_reserved = serv->sv_max_mesg; -atomic_add (rqstp->rq_reserved, &svsk->sk_reserved); +atomic_add (rqstp->rq_reserved, &svsk->sk_xprt.xpt_reserved);BUG_ON (svsk->sk_xprt.xpt_pool != pool);wake_up (&rqstp->rq_wait); }else {
@@ -353,7 +353,7 @@ void svc_reserve(struct svc_rqst *rqstp, int space)if (space < rqstp->rq_reserved) {struct svc_sock *svsk = rqstp->rq_sock; -atomic_sub ((rqstp->rq_reserved - space), &svsk->sk_reserved); +atomic_sub ((rqstp->rq_reserved - space), &svsk->sk_xprt.xpt_reserved); rqstp->rq_reserved = space;svc_sock_enqueue (svsk);
@@ -881,7 +881,7 @@ static int svc_udp_has_wspace(struct svc_xprt *xprt)* sock space. */ set_bit (SOCK_NOSPACE , &svsk->sk_sock->flags); - required =atomic_read (&svsk->sk_reserved) + serv->sv_max_mesg; + required =atomic_read (&svsk->sk_xprt.xpt_reserved) + serv->sv_max_mesg;if (required*2 >sock_wspace (svsk->sk_sk))return 0 ;clear_bit (SOCK_NOSPACE , &svsk->sk_sock->flags);
@@ -1327,7 +1327,7 @@ static int svc_tcp_has_wspace(struct svc_xprt *xprt)* sock space. */ set_bit (SOCK_NOSPACE , &svsk->sk_sock->flags); - required =atomic_read (&svsk->sk_reserved) + serv->sv_max_mesg; + required =atomic_read (&svsk->sk_xprt.xpt_reserved) + serv->sv_max_mesg; wspace =sk_stream_wspace (svsk->sk_sk);if (wspace <sk_stream_min_wspace (svsk->sk_sk))
@@ -1544,7 +1544,7 @@ svc_recv(struct svc_rqst *rqstp, long timeout) rqstp->rq_sock = svsk;svc_xprt_get (&svsk->sk_xprt); rqstp->rq_reserved = serv->sv_max_mesg; -atomic_add (rqstp->rq_reserved, &svsk->sk_reserved); +atomic_add (rqstp->rq_reserved, &svsk->sk_xprt.xpt_reserved); }else {/* No data pending. Go to sleep */ svc_thread_enqueue (pool, rqstp);
PATCH 21/40 svc: Make the enqueue service transport neutral and export it.
In reply to a message not in the archiveThe svc_sock_enqueue function is now transport independent since all of the fields it touches have been moved to the transport independent svc_xprt structure. Change the function to use the svc_xprt structure directly instead of the transport specific svc_sock structure.
Transport specific data-ready handlers need to call this function, so export it.
---
net/sunrpc/svcsock.c | 94 ++++++++++++++++++++++++++------------------------ 1 files changed, 48 insertions(+), 46 deletions(-)
net/sunrpc/svcsock.c +48 -46
@@ -5,7 +5,7 @@* * The server scheduling algorithm does not always distribute the load * evenly when servicing a single client. May need to modify the -* svc_sock_enqueue procedure... +* svc_xprt_enqueue procedure... * * TCP support is largely untested and may be a little slow. The problem * is that we currently do two separate recvfrom's, one for the 4-byte
@@ -63,7 +63,7 @@* providing that certain rules are followed: * * XPT_CONN, XPT_DATA, can be set or cleared at any time. -* after a set, svc_sock_enqueue must be called. +* after a set, svc_xprt_enqueue must be called. * after a clear, the socket must be read/accepted * if this succeeds, it must be set again. * XPT_CLOSE can set at any time. It is never cleared.
@@ -212,22 +212,21 @@ static void svc_release_skb(struct svc_rqst *rqstp)* processes, wake 'em up. * */ -static void -svc_sock_enqueue (struct svc_sock *svsk) +void svc_xprt_enqueue (struct svc_xprt *xprt) { -struct svc_serv *serv = svsk->sk_xprt.xpt_server; +struct svc_serv *serv = xprt->xpt_server;struct svc_pool *pool;struct svc_rqst *rqstp;int cpu; -if (!(svsk->sk_xprt.xpt_flags & +if (!(xprt->xpt_flags & ((1 <<XPT_CONN )|(1 <<XPT_DATA )|(1 <<XPT_CLOSE )|(1 <<XPT_DEFERRED ))))return ; -if (test_bit (XPT_DEAD , &svsk->sk_xprt.xpt_flags)) +if (test_bit (XPT_DEAD , &xprt->xpt_flags))return ; cpu =get_cpu (); - pool =svc_pool_for_cpu (svsk->sk_xprt.xpt_server, cpu); + pool =svc_pool_for_cpu (xprt->xpt_server, cpu);put_cpu ();spin_lock_bh (&pool->sp_lock);
@@ -235,11 +234,12 @@ svc_sock_enqueue(struct svc_sock *svsk)if (!list_empty (&pool->sp_threads) && !list_empty (&pool->sp_sockets))printk (KERN_ERR -"svc_sock_enqueue: threads and sockets both waiting??\n" ); +"svc_xprt_enqueue: " +"threads and transports both waiting??\n" ); -if (test_bit (XPT_DEAD , &svsk->sk_xprt.xpt_flags)) { +if (test_bit (XPT_DEAD , &xprt->xpt_flags)) {/* Don't enqueue dead sockets */ -dprintk ("svc: socket %p is dead, not enqueued\n" , svsk->sk_sk); +dprintk ("svc: transport %p is dead, not enqueued\n" , xprt); goto out_unlock; }
@@ -248,28 +248,29 @@ svc_sock_enqueue(struct svc_sock *svsk)* on the idle list. We update XPT_BUSY atomically because * it also guards against trying to enqueue the svc_sock twice. */ -if (test_and_set_bit (XPT_BUSY , &svsk->sk_xprt.xpt_flags)) { +if (test_and_set_bit (XPT_BUSY , &xprt->xpt_flags)) {/* Don't enqueue socket while already enqueued */ -dprintk ("svc: socket %p busy, not enqueued\n" , svsk->sk_sk); +dprintk ("svc: transport %p busy, not enqueued\n" , xprt); goto out_unlock; } -BUG_ON (svsk->sk_xprt.xpt_pool !=NULL ); - svsk->sk_xprt.xpt_pool = pool; +BUG_ON (xprt->xpt_pool !=NULL ); + xprt->xpt_pool = pool;/* Handle pending connection */ -if (test_bit (XPT_CONN , &svsk->sk_xprt.xpt_flags)) +if (test_bit (XPT_CONN , &xprt->xpt_flags)) goto process;/* Handle close in-progress */ -if (test_bit (XPT_CLOSE , &svsk->sk_xprt.xpt_flags)) +if (test_bit (XPT_CLOSE , &xprt->xpt_flags)) goto process;/* Check if we have space to reply to a request */ -if (!svsk->sk_xprt.xpt_ops->xpo_has_wspace (&svsk->sk_xprt)) { +if (!xprt->xpt_ops->xpo_has_wspace (xprt)) {/* Don't enqueue while not enough space for reply */ -dprintk ("svc: no write space, socket %p not enqueued\n" , svsk); - svsk->sk_xprt.xpt_pool =NULL ; -clear_bit (XPT_BUSY , &svsk->sk_xprt.xpt_flags); +dprintk ("svc: no write space, transport %p not enqueued\n" , + xprt); + xprt->xpt_pool =NULL ; +clear_bit (XPT_BUSY , &xprt->xpt_flags); goto out_unlock; }
@@ -278,28 +279,29 @@ svc_sock_enqueue(struct svc_sock *svsk) rqstp =list_entry (pool->sp_threads.next, struct svc_rqst, rq_list); -dprintk ("svc: socket %p served by daemon %p\n" , - svsk->sk_sk, rqstp); +dprintk ("svc: transport %p served by daemon %p\n" , + xprt, rqstp);svc_thread_dequeue (pool, rqstp); -if (rqstp->rq_sock) +if (rqstp->rq_xprt)printk (KERN_ERR -"svc_sock_enqueue: server %p, rq_sock=%p!\n" , - rqstp, rqstp->rq_sock); - rqstp->rq_sock = svsk; -svc_xprt_get (&svsk->sk_xprt); +"svc_xprt_enqueue: server %p, rq_xprt=%p!\n" , + rqstp, rqstp->rq_xprt); + rqstp->rq_xprt = xprt; +svc_xprt_get (xprt); rqstp->rq_reserved = serv->sv_max_mesg; -atomic_add (rqstp->rq_reserved, &svsk->sk_xprt.xpt_reserved); -BUG_ON (svsk->sk_xprt.xpt_pool != pool); +atomic_add (rqstp->rq_reserved, &xprt->xpt_reserved); +BUG_ON (xprt->xpt_pool != pool);wake_up (&rqstp->rq_wait); }else { -dprintk ("svc: socket %p put into queue\n" , svsk->sk_sk); -list_add_tail (&svsk->sk_xprt.xpt_ready, &pool->sp_sockets); -BUG_ON (svsk->sk_xprt.xpt_pool != pool); +dprintk ("svc: transport %p put into queue\n" , xprt); +list_add_tail (&xprt->xpt_ready, &pool->sp_sockets); +BUG_ON (xprt->xpt_pool != pool); } out_unlock:spin_unlock_bh (&pool->sp_lock); } +EXPORT_SYMBOL_GPL (svc_xprt_enqueue);/* * Dequeue the first socket. Must be called with the pool->sp_lock held.
@@ -333,7 +335,7 @@ svc_sock_received(struct svc_sock *svsk) { svsk->sk_xprt.xpt_pool =NULL ;clear_bit (XPT_BUSY , &svsk->sk_xprt.xpt_flags); -svc_sock_enqueue (svsk); +svc_xprt_enqueue (&svsk->sk_xprt); }
@@ -352,11 +354,11 @@ void svc_reserve(struct svc_rqst *rqstp, int space) space += rqstp->rq_res.head[0 ].iov_len;if (space < rqstp->rq_reserved) { -struct svc_sock *svsk = rqstp->rq_sock; -atomic_sub ((rqstp->rq_reserved - space), &svsk->sk_xprt.xpt_reserved); +struct svc_xprt *xprt = rqstp->rq_xprt; +atomic_sub ((rqstp->rq_reserved - space), &xprt->xpt_reserved); rqstp->rq_reserved = space; -svc_sock_enqueue (svsk); +svc_xprt_enqueue (xprt); } }
@@ -684,7 +686,7 @@ svc_udp_data_ready(struct sock *sk, int count) svsk, sk, count, test_bit(XPT_BUSY, &svsk->sk_xprt.xpt_flags));set_bit (XPT_DATA , &svsk->sk_xprt.xpt_flags); -svc_sock_enqueue (svsk); +svc_xprt_enqueue (&svsk->sk_xprt); }if (sk->sk_sleep &&waitqueue_active (sk->sk_sleep))wake_up_interruptible (sk->sk_sleep);
@@ -701,7 +703,7 @@ svc_write_space(struct sock *sk)if (svsk) {dprintk ("svc: socket %p(inet %p), write_space busy=%d\n" , svsk, sk,test_bit (XPT_BUSY , &svsk->sk_xprt.xpt_flags)); -svc_sock_enqueue (svsk); +svc_xprt_enqueue (&svsk->sk_xprt); }if (sk->sk_sleep &&waitqueue_active (sk->sk_sleep)) {
@@ -973,7 +975,7 @@ svc_tcp_listen_data_ready(struct sock *sk, int count_unused)if (sk->sk_state ==TCP_LISTEN ) {if (svsk) {set_bit (XPT_CONN , &svsk->sk_xprt.xpt_flags); -svc_sock_enqueue (svsk); +svc_xprt_enqueue (&svsk->sk_xprt); }else printk ("svc: socket %p: no user data\n" , sk); }
@@ -997,7 +999,7 @@ svc_tcp_state_change(struct sock *sk)printk ("svc: socket %p: no user data\n" , sk); else {set_bit (XPT_CLOSE , &svsk->sk_xprt.xpt_flags); -svc_sock_enqueue (svsk); +svc_xprt_enqueue (&svsk->sk_xprt); }if (sk->sk_sleep &&waitqueue_active (sk->sk_sleep))wake_up_interruptible_all (sk->sk_sleep);
@@ -1012,7 +1014,7 @@ svc_tcp_data_ready(struct sock *sk, int count) sk, sk->sk_user_data);if (svsk) {set_bit (XPT_DATA , &svsk->sk_xprt.xpt_flags); -svc_sock_enqueue (svsk); +svc_xprt_enqueue (&svsk->sk_xprt); }if (sk->sk_sleep &&waitqueue_active (sk->sk_sleep))wake_up_interruptible (sk->sk_sleep);
@@ -1298,7 +1300,7 @@ svc_tcp_sendto(struct svc_rqst *rqstp) (sent<0 )?"got error" :"sent only" , sent, xbufp->len);set_bit (XPT_CLOSE , &rqstp->rq_sock->sk_xprt.xpt_flags); -svc_sock_enqueue (rqstp->rq_sock); +svc_xprt_enqueue (rqstp->rq_xprt); sent = -EAGAIN ; }return sent;
@@ -1476,7 +1478,7 @@ static void svc_check_conn_limits(struct svc_serv *serv)spin_unlock_bh (&serv->sv_lock);if (svsk) { -svc_sock_enqueue (svsk); +svc_xprt_enqueue (&svsk->sk_xprt);svc_xprt_put (&svsk->sk_xprt); } }
@@ -1709,7 +1711,7 @@ svc_age_temp_sockets(unsigned long closure) svsk, get_seconds() - svsk->sk_lastrecv);/* a thread will dequeue and close it soon */ -svc_sock_enqueue (svsk); +svc_xprt_enqueue (&svsk->sk_xprt);svc_xprt_put (&svsk->sk_xprt); }
@@ -1991,7 +1993,7 @@ static void svc_revisit(struct cache_deferred_req *dreq, int too_many)list_add (&dr->handle.recent, &svsk->sk_deferred);spin_unlock (&svsk->sk_lock);set_bit (XPT_DEFERRED , &svsk->sk_xprt.xpt_flags); -svc_sock_enqueue (svsk); +svc_xprt_enqueue (&svsk->sk_xprt);svc_xprt_put (&svsk->sk_xprt); }
PATCH 22/40 svc: Make svc_send transport neutral
In reply to a message not in the archiveMove the sk_mutex field to the transport independent svc_xprt structure. Now all the fields that svc_send touches are transport neutral. Change the svc_send function to use the transport independent svc_xprt directly instead of the transport dependent svc_sock structure.
---
include/linux/sunrpc/svc_xprt.h | 1 + include/linux/sunrpc/svcsock.h | 1 - net/sunrpc/svc_xprt.c | 1 + net/sunrpc/svcsock.c | 19 ++++++++----------- 4 files changed, 10 insertions(+), 12 deletions(-)
include/linux/sunrpc/svc_xprt.h +1 -0
@@ -54,6 +54,7 @@ struct svc_xprt {struct svc_pool *xpt_pool;/* current pool iff queued */ struct svc_serv *xpt_server;/* service for transport */ atomic_t xpt_reserved;/* space on outq that is rsvd */ +struct mutex xpt_mutex;/* to serialize sending data */ };int svc_reg_xprt_class (struct svc_xprt_class *);
include/linux/sunrpc/svcsock.h +0 -1
@@ -24,7 +24,6 @@ struct svc_sock {* sk_info_authunix */ struct list_head sk_deferred;/* deferred requests that need to * be revisted */ -struct mutex sk_mutex;/* to serialize sending data */ /* We keep the old state_change and data_ready CB's here */ void (*sk_ostate)(struct sock *);
net/sunrpc/svc_xprt.c +1 -0
@@ -99,6 +99,7 @@ void svc_xprt_init(struct svc_xprt_class *xcl, struct svc_xprt *xprt, xprt->xpt_server = serv;INIT_LIST_HEAD (&xprt->xpt_list);INIT_LIST_HEAD (&xprt->xpt_ready); +mutex_init (&xprt->xpt_mutex); }EXPORT_SYMBOL_GPL (svc_xprt_init);
net/sunrpc/svcsock.c +8 -11
@@ -1632,15 +1632,13 @@ svc_drop(struct svc_rqst *rqstp)int svc_send (struct svc_rqst *rqstp) { -struct svc_sock *svsk; +struct svc_xprt *xprt;int len;struct xdr_buf *xb; -if ((svsk = rqstp->rq_sock) ==NULL ) { -printk (KERN_WARNING "NULL socket pointer in %s:%d\n" , - __FILE__, __LINE__); + xprt = rqstp->rq_xprt; +if (!xprt)return -EFAULT ; - }/* release the receive skb before sending the reply */ rqstp->rq_xprt->xpt_ops->xpo_release_rqst (rqstp);
@@ -1651,13 +1649,13 @@ svc_send(struct svc_rqst *rqstp) xb->page_len + xb->tail[0 ].iov_len; -/* Grab svsk->sk_mutex to serialize outgoing data. */ -mutex_lock (&svsk->sk_mutex); -if (test_bit (XPT_DEAD , &svsk->sk_xprt.xpt_flags)) +/* Grab mutex to serialize outgoing data. */ +mutex_lock (&xprt->xpt_mutex); +if (test_bit (XPT_DEAD , &xprt->xpt_flags)) len = -ENOTCONN ;else - len = svsk->sk_xprt.xpt_ops->xpo_sendto (rqstp); -mutex_unlock (&svsk->sk_mutex); + len = xprt->xpt_ops->xpo_sendto (rqstp); +mutex_unlock (&xprt->xpt_mutex);svc_sock_release (rqstp);if (len == -ECONNREFUSED || len == -ENOTCONN || len == -EAGAIN )
@@ -1759,7 +1757,6 @@ static struct svc_sock *svc_setup_socket(struct svc_serv *serv, svsk->sk_lastrecv =get_seconds ();spin_lock_init (&svsk->sk_lock);INIT_LIST_HEAD (&svsk->sk_deferred); -mutex_init (&svsk->sk_mutex);/* Initialize the socket */ if (sock->type ==SOCK_DGRAM )
PATCH 23/40 svc: Change svc_sock_received to svc_xprt_received and export it
In reply to a message not in the archiveAll fields touched by svc_sock_received are now transport independent. Change it to use svc_xprt directly. This function is called from transport dependent code, so export it.
Update the comment to clearly state the rules for calling this function.
---
include/linux/sunrpc/svc_xprt.h | 2 +- net/sunrpc/svcsock.c | 46 ++++++++++++++++++++------------------- 2 files changed, 25 insertions(+), 23 deletions(-)
include/linux/sunrpc/svc_xprt.h +1 -1
@@ -62,8 +62,8 @@ void svc_unreg_xprt_class(struct svc_xprt_class *);void svc_xprt_init (struct svc_xprt_class *,struct svc_xprt *,struct svc_serv *);int svc_create_xprt (struct svc_serv *,char *,unsigned short ,int ); +void svc_xprt_received (struct svc_xprt *);void svc_xprt_put (struct svc_xprt *xprt); -static inline void svc_xprt_get (struct svc_xprt *xprt) {kref_get (&xprt->xpt_ref);
net/sunrpc/svcsock.c +24 -22
127 lines not on this page · raw message
PATCH 24/40 svc: Move accept call to svc_xprt_received to common code
In reply to a message not in the archiveNow that the svc_xprt_received function handles transports, the call to svc_xprt_received in the xpo_tcp_accept function can be moved to common code.
---
net/sunrpc/svcsock.c | 3 +-- 1 files changed, 1 insertions(+), 2 deletions(-)
net/sunrpc/svcsock.c +1 -2
@@ -1106,8 +1106,6 @@ static struct svc_xprt *svc_tcp_accept(struct svc_xprt *xprt) }memcpy (&newsvsk->sk_local, sin, slen); -svc_xprt_received (&newsvsk->sk_xprt); -if (serv->sv_stats) serv->sv_stats->nettcpconn++;
@@ -1591,6 +1589,7 @@ svc_recv(struct svc_rqst *rqstp, long timeout)*/ __module_get (newxpt->xpt_class->xcl_owner);svc_check_conn_limits (svsk->sk_xprt.xpt_server); +svc_xprt_received (newxpt); }svc_xprt_received (&svsk->sk_xprt); }else {
PATCH 25/40 svc: Remove sk_lastrecv
In reply to a message not in the archiveWith the implementation of the new mark and sweep algorithm for shutting down old connections, the sk_lastrecv field is no longer needed.
---
include/linux/sunrpc/svcsock.h | 1 - net/sunrpc/svcsock.c | 5 +---- 2 files changed, 1 insertions(+), 5 deletions(-)
include/linux/sunrpc/svcsock.h +0 -1
@@ -33,7 +33,6 @@ struct svc_sock {/* private TCP part */ int sk_reclen;/* length of record */ int sk_tcplen;/* current read length */ -time_t sk_lastrecv;/* time of last received request */ /* cache of various info for TCP sockets */ void *sk_info_authunix;
net/sunrpc/svcsock.c +1 -4
@@ -1606,7 +1606,6 @@ svc_recv(struct svc_rqst *rqstp, long timeout)svc_sock_release (rqstp);return -EAGAIN ; } - svsk->sk_lastrecv =get_seconds ();clear_bit (XPT_OLD , &svsk->sk_xprt.xpt_flags); rqstp->rq_secure =svc_port_is_privileged (svc_addr (rqstp));
@@ -1706,8 +1705,7 @@ svc_age_temp_sockets(unsigned long closure)list_del_init (le); svsk = list_entry(le, struct svc_sock, sk_xprt.xpt_list); -dprintk ("queuing svsk %p for closing, %lu seconds old\n" , - svsk,get_seconds () - svsk->sk_lastrecv); +dprintk ("queuing svsk %p for closing\n" , svsk);/* a thread will dequeue and close it soon */ svc_xprt_enqueue (&svsk->sk_xprt);
@@ -1755,7 +1753,6 @@ static struct svc_sock *svc_setup_socket(struct svc_serv *serv, svsk->sk_ostate = inet->sk_state_change; svsk->sk_odata = inet->sk_data_ready; svsk->sk_owspace = inet->sk_write_space; - svsk->sk_lastrecv =get_seconds ();spin_lock_init (&svsk->sk_lock);INIT_LIST_HEAD (&svsk->sk_deferred);
PATCH 26/40 svc: Move the authinfo cache to svc_xprt.
In reply to a message not in the archiveMove the authinfo cache to svc_xprt. This allows both the TCP and RDMA transports to share this logic. A flag bit is used to determine if auth information is to be cached or not. Previously, this code looked at the transport protocol.
I've also changed the spin_lock/unlock logic so that a lock is not taken for transports that are not caching auth info.
---
include/linux/sunrpc/svc_xprt.h | 4 +++ include/linux/sunrpc/svcsock.h | 5 ---- net/sunrpc/svc_xprt.c | 4 +++ net/sunrpc/svcauth_unix.c | 54 +++++++++++++++++++++------------------ net/sunrpc/svcsock.c | 22 +++++++++------- 5 files changed, 49 insertions(+), 40 deletions(-)
include/linux/sunrpc/svc_xprt.h +4 -0
@@ -50,11 +50,15 @@ struct svc_xprt {#define XPT_OLD 9/* used for xprt aging mark+sweep */ #define XPT_DETACHED 10/* detached from tempsocks list */ #define XPT_LISTENER 11/* listening endpoint */ +#define XPT_CACHE_AUTH 12/* cache auth info */ struct svc_pool *xpt_pool;/* current pool iff queued */ struct svc_serv *xpt_server;/* service for transport */ atomic_t xpt_reserved;/* space on outq that is rsvd */ struct mutex xpt_mutex;/* to serialize sending data */ +spinlock_t xpt_lock;/* protects sk_deferred +* and xpt_auth_cache */ +void *xpt_auth_cache;/* auth cache */ };int svc_reg_xprt_class (struct svc_xprt_class *);
include/linux/sunrpc/svcsock.h +0 -5
@@ -20,8 +20,6 @@ struct svc_sock {struct socket * sk_sock;/* berkeley socket layer */ struct sock * sk_sk;/* INET layer */ -spinlock_t sk_lock;/* protects sk_deferred and -* sk_info_authunix */ struct list_head sk_deferred;/* deferred requests that need to * be revisted */
@@ -34,9 +32,6 @@ struct svc_sock {int sk_reclen;/* length of record */ int sk_tcplen;/* current read length */ -/* cache of various info for TCP sockets */ -void *sk_info_authunix; -struct sockaddr_storage sk_local;/* local address */ struct sockaddr_storage sk_remote;/* remote peer's address */ int sk_remotelen;/* length of address */
net/sunrpc/svc_xprt.c +4 -0
@@ -75,6 +75,9 @@ static void svc_xprt_free(struct kref *kref)struct svc_xprt *xprt = container_of(kref, struct svc_xprt, xpt_ref);struct module *owner = xprt->xpt_class->xcl_owner; +if (test_bit (XPT_CACHE_AUTH , &xprt->xpt_flags) + && xprt->xpt_auth_cache !=NULL ) +svcauth_unix_info_release (xprt->xpt_auth_cache); xprt->xpt_ops->xpo_free (xprt);module_put (owner); }
@@ -100,6 +103,7 @@ void svc_xprt_init(struct svc_xprt_class *xcl, struct svc_xprt *xprt,INIT_LIST_HEAD (&xprt->xpt_list);INIT_LIST_HEAD (&xprt->xpt_ready);mutex_init (&xprt->xpt_mutex); +spin_lock_init (&xprt->xpt_lock); }EXPORT_SYMBOL_GPL (svc_xprt_init);
net/sunrpc/svcauth_unix.c +29 -25
70 lines not on this page · raw message
net/sunrpc/svcsock.c +12 -10
@@ -113,12 +113,16 @@ static inline void svc_reclassify_socket(struct socket *sock)switch (sk->sk_family) {case AF_INET :sock_lock_init_class_and_name (sk,"slock-AF_INET-NFSD" , - &svc_slock_key[0 ],"sk_lock-AF_INET-NFSD" , &svc_key[0 ]); + &svc_slock_key[0 ], +"sk_xprt.xpt_lock-AF_INET-NFSD" , + &svc_key[0 ]);break ;case AF_INET6 :sock_lock_init_class_and_name (sk,"slock-AF_INET6-NFSD" , - &svc_slock_key[1 ],"sk_lock-AF_INET6-NFSD" , &svc_key[1 ]); + &svc_slock_key[1 ], +"sk_xprt.xpt_lock-AF_INET6-NFSD" , + &svc_key[1 ]);break ;default :
@@ -930,6 +934,7 @@ static void svc_udp_init(struct svc_sock *svsk, struct svc_serv *serv)mm_segment_t oldfs;svc_xprt_init (&svc_udp_class, &svsk->sk_xprt, serv); +clear_bit (XPT_CACHE_AUTH , &svsk->sk_xprt.xpt_flags); svsk->sk_sk->sk_data_ready = svc_udp_data_ready; svsk->sk_sk->sk_write_space = svc_write_space;
@@ -1385,7 +1390,7 @@ static void svc_tcp_init(struct svc_sock *svsk, struct svc_serv *serv)struct tcp_sock *tp =tcp_sk (sk);svc_xprt_init (&svc_tcp_class, &svsk->sk_xprt, serv); - +set_bit (XPT_CACHE_AUTH , &svsk->sk_xprt.xpt_flags);if (sk->sk_state ==TCP_LISTEN ) {dprintk ("setting up TCP socket for listening\n" );set_bit (XPT_LISTENER , &svsk->sk_xprt.xpt_flags);
@@ -1753,7 +1758,6 @@ static struct svc_sock *svc_setup_socket(struct svc_serv *serv, svsk->sk_ostate = inet->sk_state_change; svsk->sk_odata = inet->sk_data_ready; svsk->sk_owspace = inet->sk_write_space; -spin_lock_init (&svsk->sk_lock);INIT_LIST_HEAD (&svsk->sk_deferred);/* Initialize the socket */
@@ -1898,8 +1902,6 @@ static void svc_sock_free(struct svc_xprt *xprt) struct svc_sock *svsk = container_of(xprt, struct svc_sock, sk_xprt);dprintk ("svc: svc_sock_free(%p)\n" , svsk); -if (svsk->sk_info_authunix !=NULL ) -svcauth_unix_info_release (svsk->sk_info_authunix);if (svsk->sk_sock->file)sockfd_put (svsk->sk_sock);else
@@ -1984,9 +1986,9 @@ static void svc_revisit(struct cache_deferred_req *dreq, int too_many)dprintk ("revisit queued\n" ); svsk = dr->svsk; dr->svsk =NULL ; -spin_lock (&svsk->sk_lock); +spin_lock (&svsk->sk_xprt.xpt_lock);list_add (&dr->handle.recent, &svsk->sk_deferred); -spin_unlock (&svsk->sk_lock); +spin_unlock (&svsk->sk_xprt.xpt_lock);set_bit (XPT_DEFERRED , &svsk->sk_xprt.xpt_flags);svc_xprt_enqueue (&svsk->sk_xprt);svc_xprt_put (&svsk->sk_xprt);
@@ -2052,7 +2054,7 @@ static struct svc_deferred_req *svc_deferred_dequeue(struct svc_sock *svsk)if (!test_bit (XPT_DEFERRED , &svsk->sk_xprt.xpt_flags))return NULL ; -spin_lock (&svsk->sk_lock); +spin_lock (&svsk->sk_xprt.xpt_lock);clear_bit (XPT_DEFERRED , &svsk->sk_xprt.xpt_flags);if (!list_empty (&svsk->sk_deferred)) { dr = list_entry(svsk->sk_deferred.next,
@@ -2061,6 +2063,6 @@ static struct svc_deferred_req *svc_deferred_dequeue(struct svc_sock *svsk)list_del_init (&dr->handle.recent);set_bit (XPT_DEFERRED , &svsk->sk_xprt.xpt_flags); } -spin_unlock (&svsk->sk_lock); +spin_unlock (&svsk->sk_xprt.xpt_lock);return dr; }
PATCH 27/40 svc: Make deferral processing xprt independent
In reply to a message not in the archiveThis patch moves the transport independent sk_deferred list to the svc_xprt structure and updates the svc_deferred_req structure to keep pointers to svc_xprt's directly. The deferral processing code is also moved out of the transport dependent recvfrom functions and into the generic svc_recv path.
---
include/linux/sunrpc/svc.h | 2 + include/linux/sunrpc/svc_xprt.h | 2 + include/linux/sunrpc/svcsock.h | 3 -- net/sunrpc/svc_xprt.c | 1 + net/sunrpc/svcsock.c | 57 +++++++++++++++++---------------------- 5 files changed, 29 insertions(+), 36 deletions(-)
include/linux/sunrpc/svc.h +1 -1
@@ -320,7 +320,7 @@ static inline void svc_free_res_pages(struct svc_rqst *rqstp)struct svc_deferred_req {u32 prot;/* protocol (UDP or TCP) */ -struct svc_sock *svsk; +struct svc_xprt *xprt;struct sockaddr_storage addr;/* where reply must go */ size_t addrlen;union svc_addr_u daddr;/* where reply must come from */
include/linux/sunrpc/svc_xprt.h +2 -0
@@ -59,6 +59,8 @@ struct svc_xprt {spinlock_t xpt_lock;/* protects sk_deferred * and xpt_auth_cache */ void *xpt_auth_cache;/* auth cache */ +struct list_head xpt_deferred;/* deferred requests that need +* to be revisted */ };int svc_reg_xprt_class (struct svc_xprt_class *);
include/linux/sunrpc/svcsock.h +0 -3
@@ -20,9 +20,6 @@ struct svc_sock {struct socket * sk_sock;/* berkeley socket layer */ struct sock * sk_sk;/* INET layer */ -struct list_head sk_deferred;/* deferred requests that need to -* be revisted */ -/* We keep the old state_change and data_ready CB's here */ void (*sk_ostate)(struct sock *);void (*sk_odata)(struct sock *,int bytes);
net/sunrpc/svc_xprt.c +1 -0
@@ -102,6 +102,7 @@ void svc_xprt_init(struct svc_xprt_class *xcl, struct svc_xprt *xprt, xprt->xpt_server = serv;INIT_LIST_HEAD (&xprt->xpt_list);INIT_LIST_HEAD (&xprt->xpt_ready); +INIT_LIST_HEAD (&xprt->xpt_deferred);mutex_init (&xprt->xpt_mutex);spin_lock_init (&xprt->xpt_lock); }
net/sunrpc/svcsock.c +25 -32
118 lines not on this page · raw message
PATCH 28/40 svc: Move the sockaddr information to svc_xprt
In reply to a message not in the archiveThis patch moves the transport sockaddr to the svc_xprt structure. Convenience functions are added to set and get the local and remote addresses of a transport from the transport provider as well as determine the length of a sockaddr.
A transport is responsible for setting the xpt_local and xpt_remote addresses in the svc_xprt structure as part of transport creation and xpo_accept processing. This cannot be done in a generic way and in fact varies between TCP, UDP and RDMA. A set of xpo_ functions (e.g. getlocalname, getremotename) could have been added but this would have resulted in additional caching and copying of the addresses around. Note that the xpt_local address should also be set on listening endpoints; for TCP/RDMA this is done as part of endpoint creation.
For connected transports like TCP and RDMA, the addresses never change and can be set once and copied into the rqstp structure for each request. For UDP, however, the local and remote addresses may change for each request. In this case, the address information is obtained from the UDP recvmsg info and copied into the rqstp structure from there.
A svc_xprt_local_port function was also added that returns the local port given a transport. This is used by svc_create_xprt when returning the port associated with a newly created transport, and later when creating a generic find transport service to check if a service is already listening on a given port.
---
include/linux/sunrpc/svc_xprt.h | 51 ++++++++++++++++++++++++++++++++++++ include/linux/sunrpc/svcsock.h | 4 --- net/sunrpc/svc_xprt.c | 31 ++++++++++++++++++++-- net/sunrpc/svcsock.c | 56 +++++++++++++++++++++------------------ 4 files changed, 110 insertions(+), 32 deletions(-)
include/linux/sunrpc/svc_xprt.h +51 -0
@@ -61,6 +61,10 @@ struct svc_xprt {void *xpt_auth_cache;/* auth cache */ struct list_head xpt_deferred;/* deferred requests that need * to be revisted */ +struct sockaddr_storage xpt_local;/* local address */ +size_t xpt_locallen;/* length of address */ +struct sockaddr_storage xpt_remote;/* remote peer's address */ +size_t xpt_remotelen;/* length of address */ };int svc_reg_xprt_class (struct svc_xprt_class *);
@@ -70,9 +74,56 @@ void svc_xprt_init(struct svc_xprt_class *, struct svc_xprt *,int svc_create_xprt (struct svc_serv *,char *,unsigned short ,int );void svc_xprt_received (struct svc_xprt *);void svc_xprt_put (struct svc_xprt *xprt); +void svc_xprt_copy_addrs (struct svc_rqst *rqstp,struct svc_xprt *xprt);static inline void svc_xprt_get (struct svc_xprt *xprt) {kref_get (&xprt->xpt_ref); } +static inline void svc_xprt_set_local (struct svc_xprt *xprt, +struct sockaddr *sa,int salen) +{ +memcpy (&xprt->xpt_local, sa, salen); + xprt->xpt_locallen = salen; +} +static inline void svc_xprt_set_remote (struct svc_xprt *xprt, +struct sockaddr *sa,int salen) +{ +memcpy (&xprt->xpt_remote, sa, salen); + xprt->xpt_remotelen = salen; +} +static inline unsigned short svc_addr_port (struct sockaddr *sa) +{ +unsigned short ret =0 ; +switch (sa->sa_family) { +case AF_INET : + ret =ntohs (((struct sockaddr_in *)sa)->sin_port); +break ; +case AF_INET6 : + ret =ntohs (((struct sockaddr_in6 *)sa)->sin6_port); +break ; + } +return ret; +} + +static inline size_t svc_addr_len (struct sockaddr *sa) +{ +switch (sa->sa_family) { +case AF_INET : +return sizeof (struct sockaddr_in ); +case AF_INET6 : +return sizeof (struct sockaddr_in6 ); + } +return -EAFNOSUPPORT ; +} + +static inline unsigned short svc_xprt_local_port (struct svc_xprt *xprt) +{ +return svc_addr_port ((struct sockaddr *)&xprt->xpt_local); +} + +static inline unsigned short svc_xprt_remote_port (struct svc_xprt *xprt) +{ +return svc_addr_port ((struct sockaddr *)&xprt->xpt_remote); +}#endif /* SUNRPC_SVC_XPRT_H */
include/linux/sunrpc/svcsock.h +0 -4
@@ -28,10 +28,6 @@ struct svc_sock {/* private TCP part */ int sk_reclen;/* length of record */ int sk_tcplen;/* current read length */ - -struct sockaddr_storage sk_local;/* local address */ -struct sockaddr_storage sk_remote;/* remote peer's address */ -int sk_remotelen;/* length of address */ };/*
net/sunrpc/svc_xprt.c +29 -2
@@ -125,7 +125,6 @@ int svc_create_xprt(struct svc_serv *serv, char *xprt_name, unsigned short port,spin_unlock (&svc_xprt_class_lock);if (try_module_get (xcl->xcl_owner)) {struct svc_xprt *newxprt; - ret =0 ; newxprt = xcl->xcl_ops->xpo_create (serv, (struct sockaddr *)&sin, sizeof(sin),
@@ -133,7 +132,8 @@ int svc_create_xprt(struct svc_serv *serv, char *xprt_name, unsigned short port,if (IS_ERR (newxprt)) {module_put (xcl->xcl_owner); ret =PTR_ERR (newxprt); - } + }else + ret =svc_xprt_local_port (newxprt); } goto out; }
@@ -144,3 +144,30 @@ int svc_create_xprt(struct svc_serv *serv, char *xprt_name, unsigned short port,return ret; }EXPORT_SYMBOL_GPL (svc_create_xprt); + +/* +* Copy the local and remote xprt addresses to the rqstp structure +*/ +void svc_xprt_copy_addrs (struct svc_rqst *rqstp,struct svc_xprt *xprt) +{ +struct sockaddr *sin; + +memcpy (&rqstp->rq_addr, &xprt->xpt_remote, xprt->xpt_remotelen); + rqstp->rq_addrlen = xprt->xpt_remotelen; + +/* +* Destination address in request is needed for binding the +* source address in RPC replies/callbacks later. +*/ + sin = (struct sockaddr *)&xprt->xpt_local; +switch (sin->sa_family) { +case AF_INET : + rqstp->rq_daddr.addr = ((struct sockaddr_in *)sin)->sin_addr; +break ; +case AF_INET6 : + rqstp->rq_daddr.addr6 = ((struct sockaddr_in6 *)sin)->sin6_addr; +break ; + } +} +EXPORT_SYMBOL_GPL (svc_xprt_copy_addrs); +
net/sunrpc/svcsock.c +30 -26
122 lines not on this page · raw message
PATCH 29/40 svc: Make svc_sock_release svc_xprt_release
In reply to a message not in the archiveThe svc_sock_release function only touches transport independent fields. Change the function to manipulate svc_xprt directly instead of the transport dependent svc_sock structure.
---
net/sunrpc/svcsock.c | 16 +++++++--------- 1 files changed, 7 insertions(+), 9 deletions(-)
net/sunrpc/svcsock.c +7 -9
@@ -368,10 +368,9 @@ void svc_reserve(struct svc_rqst *rqstp, int space) } } -static void -svc_sock_release (struct svc_rqst *rqstp) +static void svc_xprt_release (struct svc_rqst *rqstp) { -struct svc_sock *svsk = rqstp->rq_sock; +struct svc_xprt *xprt = rqstp->rq_xprt; rqstp->rq_xprt->xpt_ops->xpo_release_rqst (rqstp);
@@ -379,7 +378,6 @@ svc_sock_release(struct svc_rqst *rqstp) rqstp->rq_res.page_len =0 ; rqstp->rq_res.page_base =0 ; -/* Reset response buffer and release * the reservation. * But first, check that enough space was reserved
@@ -392,9 +390,9 @@ svc_sock_release(struct svc_rqst *rqstp) rqstp->rq_res.head[0 ].iov_len =0 ;svc_reserve (rqstp,0 ); - rqstp->rq_sock =NULL ; + rqstp->rq_xprt =NULL ; -svc_xprt_put (&svsk->sk_xprt); +svc_xprt_put (xprt); }/*
@@ -1593,7 +1591,7 @@ svc_recv(struct svc_rqst *rqstp, long timeout)/* No data, incomplete (TCP) read, or accept() */ if (len ==0 || len == -EAGAIN ) { rqstp->rq_res.len =0 ; -svc_sock_release (rqstp); +svc_xprt_release (rqstp);return -EAGAIN ; }clear_bit (XPT_OLD , &svsk->sk_xprt.xpt_flags);
@@ -1613,7 +1611,7 @@ void svc_drop(struct svc_rqst *rqstp) {dprintk ("svc: socket %p dropped request\n" , rqstp->rq_sock); -svc_sock_release (rqstp); +svc_xprt_release (rqstp); }/*
@@ -1646,7 +1644,7 @@ svc_send(struct svc_rqst *rqstp)else len = xprt->xpt_ops->xpo_sendto (rqstp);mutex_unlock (&xprt->xpt_mutex); -svc_sock_release (rqstp); +svc_xprt_release (rqstp);if (len == -ECONNREFUSED || len == -ENOTCONN || len == -EAGAIN )return 0 ;
PATCH 30/40 svc: Make svc_recv transport neutral
In reply to a message not in the archiveAll of the transport field and functions used by svc_recv are now transport independent. Change the svc_recv function to use the svc_xprt structure directly instead of the transport specific svc_sock structure.
---
net/sunrpc/svcsock.c | 61 +++++++++++++++++++++++++------------------------- 1 files changed, 31 insertions(+), 30 deletions(-)
net/sunrpc/svcsock.c +31 -30
@@ -310,22 +310,21 @@ EXPORT_SYMBOL_GPL(svc_xprt_enqueue);/* * Dequeue the first socket. Must be called with the pool->sp_lock held. */ -static inline struct svc_sock * -svc_sock_dequeue (struct svc_pool *pool) +static struct svc_xprt *svc_xprt_dequeue (struct svc_pool *pool) { -struct svc_sock *svsk; +struct svc_xprt *xprt;if (list_empty (&pool->sp_sockets))return NULL ; - svsk =list_entry (pool->sp_sockets.next, - struct svc_sock, sk_xprt.xpt_ready); -list_del_init (&svsk->sk_xprt.xpt_ready); + xprt =list_entry (pool->sp_sockets.next, + struct svc_xprt, xpt_ready); +list_del_init (&xprt->xpt_ready); -dprintk ("svc: socket %p dequeued, inuse=%d\n" , - svsk->sk_sk,atomic_read (&svsk->sk_xprt.xpt_ref.refcount)); +dprintk ("svc: transport %p dequeued, inuse=%d\n" , + xprt,atomic_read (&xprt->xpt_ref.refcount)); -return svsk; +return xprt; }/*
@@ -1475,20 +1474,20 @@ static void svc_check_conn_limits(struct svc_serv *serv)int svc_recv (struct svc_rqst *rqstp,long timeout) { -struct svc_sock *svsk =NULL ; +struct svc_xprt *xprt =NULL ;struct svc_serv *serv = rqstp->rq_server;struct svc_pool *pool = rqstp->rq_pool;int len, i; -int pages; +int pages;struct xdr_buf *arg;DECLARE_WAITQUEUE (wait, current);dprintk ("svc: server %p waiting for data (to = %ld)\n" , rqstp, timeout); -if (rqstp->rq_sock) +if (rqstp->rq_xprt)printk (KERN_ERR -"svc_recv: service %p, socket not NULL!\n" , +"svc_recv: service %p, transport not NULL!\n" , rqstp);if (waitqueue_active (&rqstp->rq_wait)) printk(KERN_ERR
@@ -1525,11 +1524,12 @@ svc_recv(struct svc_rqst *rqstp, long timeout)return -EINTR ;spin_lock_bh (&pool->sp_lock); -if ((svsk =svc_sock_dequeue (pool)) !=NULL ) { - rqstp->rq_sock = svsk; -svc_xprt_get (&svsk->sk_xprt); + xprt =svc_xprt_dequeue (pool); +if (xprt) { + rqstp->rq_xprt = xprt; +svc_xprt_get (xprt); rqstp->rq_reserved = serv->sv_max_mesg; -atomic_add (rqstp->rq_reserved, &svsk->sk_xprt.xpt_reserved); +atomic_add (rqstp->rq_reserved, &xprt->xpt_reserved); }else {/* No data pending. Go to sleep */ svc_thread_enqueue (pool, rqstp);
@@ -1549,7 +1549,8 @@ svc_recv(struct svc_rqst *rqstp, long timeout)spin_lock_bh (&pool->sp_lock);remove_wait_queue (&rqstp->rq_wait, &wait); -if (!(svsk = rqstp->rq_sock)) { + xprt = rqstp->rq_xprt; +if (!xprt) {svc_thread_dequeue (pool, rqstp);spin_unlock_bh (&pool->sp_lock);dprintk ("svc: server %p, no data yet\n" , rqstp);
@@ -1559,12 +1560,12 @@ svc_recv(struct svc_rqst *rqstp, long timeout)spin_unlock_bh (&pool->sp_lock); len =0 ; -if (test_bit (XPT_CLOSE , &svsk->sk_xprt.xpt_flags)) { +if (test_bit (XPT_CLOSE , &xprt->xpt_flags)) {dprintk ("svc_recv: found XPT_CLOSE\n" ); -svc_delete_xprt (&svsk->sk_xprt); - }else if (test_bit (XPT_LISTENER , &svsk->sk_xprt.xpt_flags)) { +svc_delete_xprt (xprt); + }else if (test_bit (XPT_LISTENER , &xprt->xpt_flags)) {struct svc_xprt *newxpt; - newxpt = svsk->sk_xprt.xpt_ops->xpo_accept (&svsk->sk_xprt); + newxpt = xprt->xpt_ops->xpo_accept (xprt);if (newxpt) {/* * We know this module_get will succeed because the
@@ -1574,17 +1575,17 @@ svc_recv(struct svc_rqst *rqstp, long timeout)svc_check_conn_limits (svsk->sk_xprt.xpt_server);svc_xprt_received (newxpt); } -svc_xprt_received (&svsk->sk_xprt); +svc_xprt_received (xprt); }else { -dprintk ("svc: server %p, pool %u, socket %p, inuse=%d\n" , - rqstp, pool->sp_id, svsk, -atomic_read (&svsk->sk_xprt.xpt_ref.refcount)); - rqstp->rq_deferred =svc_deferred_dequeue (&svsk->sk_xprt); +dprintk ("svc: server %p, pool %u, transport %p, inuse=%d\n" , + rqstp, pool->sp_id, xprt, +atomic_read (&xprt->xpt_ref.refcount)); + rqstp->rq_deferred =svc_deferred_dequeue (xprt);if (rqstp->rq_deferred) { -svc_xprt_received (&svsk->sk_xprt); +svc_xprt_received (xprt); len =svc_deferred_recv (rqstp); }else - len = svsk->sk_xprt.xpt_ops->xpo_recvfrom (rqstp); + len = xprt->xpt_ops->xpo_recvfrom (rqstp);dprintk ("svc: got len=%d\n" , len); }
@@ -1594,7 +1595,7 @@ svc_recv(struct svc_rqst *rqstp, long timeout)svc_xprt_release (rqstp);return -EAGAIN ; } -clear_bit (XPT_OLD , &svsk->sk_xprt.xpt_flags); +clear_bit (XPT_OLD , &xprt->xpt_flags); rqstp->rq_secure =svc_port_is_privileged (svc_addr (rqstp)); rqstp->rq_chandle.defer = svc_defer;
PATCH 31/40 svc: Make svc_age_temp_sockets svc_age_temp_transports
In reply to a message not in the archiveThis function is transport independent. Change it to use svc_xprt directly and change it's name to reflect this.
---
net/sunrpc/svcsock.c | 37 +++++++++++++++++++------------------ 1 files changed, 19 insertions(+), 18 deletions(-)
net/sunrpc/svcsock.c +19 -18
@@ -1656,49 +1656,50 @@ svc_send(struct svc_rqst *rqstp)* Timer function to close old temporary sockets, using * a mark-and-sweep algorithm. */ -static void -svc_age_temp_sockets (unsigned long closure) +static void svc_age_temp_xprts (unsigned long closure) {struct svc_serv *serv = (struct svc_serv *)closure; -struct svc_sock *svsk; +struct svc_xprt *xprt;struct list_head *le, *next;LIST_HEAD (to_be_aged); -dprintk ("svc_age_temp_sockets\n" ); +dprintk ("svc_age_temp_xprts\n" );if (!spin_trylock_bh (&serv->sv_lock)) {/* busy, try again 1 sec later */ -dprintk ("svc_age_temp_sockets: busy\n" ); +dprintk ("svc_age_temp_xprts: busy\n" );mod_timer (&serv->sv_temptimer, jiffies +HZ );return ; }list_for_each_safe (le, next, &serv->sv_tempsocks) { - svsk = list_entry(le, struct svc_sock, sk_xprt.xpt_list); + xprt = list_entry(le, struct svc_xprt, xpt_list); -if (!test_and_set_bit (XPT_OLD , &svsk->sk_xprt.xpt_flags)) +/* First time through, just mark it OLD. Second time +* through, close it. */ +if (!test_and_set_bit (XPT_OLD , &xprt->xpt_flags))continue ; -if (atomic_read (&svsk->sk_xprt.xpt_ref.refcount) >1 - ||test_bit (XPT_BUSY , &svsk->sk_xprt.xpt_flags)) +if (atomic_read (&xprt->xpt_ref.refcount) >1 + ||test_bit (XPT_BUSY , &xprt->xpt_flags))continue ; -svc_xprt_get (&svsk->sk_xprt); +svc_xprt_get (xprt);list_move (le, &to_be_aged); -set_bit (XPT_CLOSE , &svsk->sk_xprt.xpt_flags); -set_bit (XPT_DETACHED , &svsk->sk_xprt.xpt_flags); +set_bit (XPT_CLOSE , &xprt->xpt_flags); +set_bit (XPT_DETACHED , &xprt->xpt_flags); }spin_unlock_bh (&serv->sv_lock);while (!list_empty (&to_be_aged)) { le = to_be_aged.next; -/* fiddling the sk_xprt.xpt_list node is safe 'cos we're XPT_DETACHED */ +/* fiddling the xpt_list node is safe 'cos we're XPT_DETACHED */ list_del_init (le); - svsk = list_entry(le, struct svc_sock, sk_xprt.xpt_list); + xprt = list_entry(le, struct svc_xprt, xpt_list); -dprintk ("queuing svsk %p for closing\n" , svsk); +dprintk ("queuing xprt %p for closing\n" , xprt);/* a thread will dequeue and close it soon */ -svc_xprt_enqueue (&svsk->sk_xprt); -svc_xprt_put (&svsk->sk_xprt); +svc_xprt_enqueue (xprt); +svc_xprt_put (xprt); }mod_timer (&serv->sv_temptimer, jiffies + svc_conn_age_period *HZ );
@@ -1756,7 +1757,7 @@ static struct svc_sock *svc_setup_socket(struct svc_serv *serv, serv->sv_tmpcnt++;if (serv->sv_temptimer.function ==NULL ) {/* setup timer to age temp sockets */ -setup_timer (&serv->sv_temptimer, svc_age_temp_sockets, +setup_timer (&serv->sv_temptimer, svc_age_temp_xprts, (unsigned long )serv);mod_timer (&serv->sv_temptimer, jiffies + svc_conn_age_period *HZ );
PATCH 32/40 svc: Move create logic to common code
In reply to a message not in the archiveMove the svc transport list logic into common transport creation code. Refactor this code path to make the flow of control easier to read.
Move the setting and clearing of the BUSY_BIT during transport creation to common code.
---
net/sunrpc/svc_xprt.c | 43 +++++++++++++++++++++++++------------------ net/sunrpc/svcsock.c | 41 +++++++++++++++++++---------------------- 2 files changed, 44 insertions(+), 40 deletions(-)
net/sunrpc/svc_xprt.c +25 -18
@@ -105,6 +105,7 @@ void svc_xprt_init(struct svc_xprt_class *xcl, struct svc_xprt *xprt,INIT_LIST_HEAD (&xprt->xpt_deferred);mutex_init (&xprt->xpt_mutex);spin_lock_init (&xprt->xpt_lock); +set_bit (XPT_BUSY , &xprt->xpt_flags); }EXPORT_SYMBOL_GPL (svc_xprt_init);
@@ -112,7 +113,6 @@ int svc_create_xprt(struct svc_serv *serv, char *xprt_name, unsigned short port, int flags) {struct svc_xprt_class *xcl; -int ret = -ENOENT ;struct sockaddr_in sin = { .sin_family =AF_INET , .sin_addr.s_addr =INADDR_ANY ,
@@ -121,27 +121,34 @@ int svc_create_xprt(struct svc_serv *serv, char *xprt_name, unsigned short port,dprintk ("svc: creating transport %s[%d]\n" , xprt_name, port);spin_lock (&svc_xprt_class_lock);list_for_each_entry (xcl, &svc_xprt_class_list, xcl_list) { -if (strcmp (xprt_name, xcl->xcl_name) ==0 ) { -spin_unlock (&svc_xprt_class_lock); -if (try_module_get (xcl->xcl_owner)) { -struct svc_xprt *newxprt; - newxprt = xcl->xcl_ops->xpo_create - (serv, - (struct sockaddr *)&sin,sizeof (sin), - flags); -if (IS_ERR (newxprt)) { -module_put (xcl->xcl_owner); - ret =PTR_ERR (newxprt); - }else - ret =svc_xprt_local_port (newxprt); - } - goto out; +struct svc_xprt *newxprt; + +if (strcmp (xprt_name, xcl->xcl_name)) +continue ; + +if (!try_module_get (xcl->xcl_owner)) + goto err; + +spin_unlock (&svc_xprt_class_lock); + newxprt = xcl->xcl_ops-> +xpo_create (serv, (struct sockaddr *)&sin,sizeof (sin), + flags); +if (IS_ERR (newxprt)) { +module_put (xcl->xcl_owner); +return PTR_ERR (newxprt); } + +clear_bit (XPT_TEMP , &newxprt->xpt_flags); +spin_lock_bh (&serv->sv_lock); +list_add (&newxprt->xpt_list, &serv->sv_permsocks); +spin_unlock_bh (&serv->sv_lock); +clear_bit (XPT_BUSY , &newxprt->xpt_flags); +return svc_xprt_local_port (newxprt); } + err:spin_unlock (&svc_xprt_class_lock);dprintk ("svc: transport %s not found\n" , xprt_name); - out: -return ret; +return -ENOENT ; }EXPORT_SYMBOL_GPL (svc_create_xprt);
net/sunrpc/svcsock.c +19 -22
83 lines not on this page · raw message
PATCH 33/40 svc: Removing remaining references to rq_sock in rqstp
In reply to a message not in the archiveThis functionally empty patch removes rq_sock and unamed union from rqstp structure.
---
include/linux/sunrpc/svc.h | 5 +---- net/sunrpc/svcsock.c | 38 ++++++++++++++++++++++++-------------- 2 files changed, 25 insertions(+), 18 deletions(-)
include/linux/sunrpc/svc.h +1 -4
@@ -204,10 +204,7 @@ union svc_addr_u {struct svc_rqst {struct list_head rq_list;/* idle list */ struct list_head rq_all;/* all threads list */ -union { -struct svc_xprt * rq_xprt;/* transport ptr */ -struct svc_sock * rq_sock;/* socket ptr */ - }; +struct svc_xprt * rq_xprt;/* transport ptr */ struct sockaddr_storage rq_addr;/* peer address */ size_t rq_addrlen;
net/sunrpc/svcsock.c +24 -14
@@ -201,10 +201,12 @@ static void svc_release_skb(struct svc_rqst *rqstp)struct svc_deferred_req *dr = rqstp->rq_deferred;if (skb) { +struct svc_sock *svsk = + container_of(rqstp->rq_xprt, struct svc_sock, sk_xprt); rqstp->rq_xprt_ctxt =NULL ;dprintk ("svc: service %p, releasing skb %p\n" , rqstp, skb); -skb_free_datagram (rqstp->rq_sock->sk_sk, skb); +skb_free_datagram (svsk->sk_sk, skb); }if (dr) { rqstp->rq_deferred =NULL ;
@@ -418,7 +420,7 @@ svc_wake_up(struct svc_serv *serv)dprintk ("svc: daemon %p woken up.\n" , rqstp);/* svc_thread_dequeue(pool, rqstp); -rqstp->rq_sock = NULL; +rqstp->rq_xprt = NULL; */ wake_up (&rqstp->rq_wait); }
@@ -435,7 +437,9 @@ union svc_pktinfo_u {static void svc_set_cmsg_data (struct svc_rqst *rqstp,struct cmsghdr *cmh) { -switch (rqstp->rq_sock->sk_sk->sk_family) { +struct svc_sock *svsk = + container_of(rqstp->rq_xprt, struct svc_sock, sk_xprt); +switch (svsk->sk_sk->sk_family) {case AF_INET : {struct in_pktinfo *pki =CMSG_DATA (cmh);
@@ -468,7 +472,8 @@ static void svc_set_cmsg_data(struct svc_rqst *rqstp, struct cmsghdr *cmh)static int svc_sendto (struct svc_rqst *rqstp,struct xdr_buf *xdr) { -struct svc_sock *svsk = rqstp->rq_sock; +struct svc_sock *svsk = + container_of(rqstp->rq_xprt, struct svc_sock, sk_xprt);struct socket *sock = svsk->sk_sock;int slen;union {
@@ -541,7 +546,7 @@ svc_sendto(struct svc_rqst *rqstp, struct xdr_buf *xdr) } out:dprintk ("svc: socket %p sendto([%p %Zu... ], %d) = %d (addr %s)\n" , - rqstp->rq_sock, xdr->head[0 ].iov_base, xdr->head[0 ].iov_len, + svsk, xdr->head[0 ].iov_base, xdr->head[0 ].iov_len, xdr->len, len,svc_print_addr (rqstp, buf,sizeof (buf)));return len;
@@ -617,7 +622,8 @@ svc_recv_available(struct svc_sock *svsk)static int svc_recvfrom (struct svc_rqst *rqstp,struct kvec *iov,int nr,int buflen) { -struct svc_sock *svsk = rqstp->rq_sock; +struct svc_sock *svsk = + container_of(rqstp->rq_xprt, struct svc_sock, sk_xprt);struct msghdr msg = { .msg_flags =MSG_DONTWAIT , };
@@ -707,7 +713,9 @@ svc_write_space(struct sock *sk)static void svc_udp_get_dest_address (struct svc_rqst *rqstp,struct cmsghdr *cmh) { -switch (rqstp->rq_sock->sk_sk->sk_family) { +struct svc_sock *svsk = + container_of(rqstp->rq_xprt, struct svc_sock, sk_xprt); +switch (svsk->sk_sk->sk_family) {case AF_INET : {struct in_pktinfo *pki =CMSG_DATA (cmh); rqstp->rq_daddr.addr.s_addr = pki->ipi_spec_dst.s_addr;
@@ -727,7 +735,8 @@ static void svc_udp_get_dest_address(struct svc_rqst *rqstp,static int svc_udp_recvfrom (struct svc_rqst *rqstp) { -struct svc_sock *svsk = rqstp->rq_sock; +struct svc_sock *svsk = + container_of(rqstp->rq_xprt, struct svc_sock, sk_xprt);struct svc_serv *serv = svsk->sk_xprt.xpt_server;struct sk_buff *skb;union {
@@ -1109,7 +1118,8 @@ failed:static int svc_tcp_recvfrom (struct svc_rqst *rqstp) { -struct svc_sock *svsk = rqstp->rq_sock; +struct svc_sock *svsk = + container_of(rqstp->rq_xprt, struct svc_sock, sk_xprt);struct svc_serv *serv = svsk->sk_xprt.xpt_server;int len;struct kvec *vec;
@@ -1273,16 +1283,16 @@ svc_tcp_sendto(struct svc_rqst *rqstp) reclen =htonl (0x80000000 |((xbufp->len ) -4 ));memcpy (xbufp->head[0 ].iov_base, &reclen,4 ); -if (test_bit (XPT_DEAD , &rqstp->rq_sock->sk_xprt.xpt_flags)) +if (test_bit (XPT_DEAD , &rqstp->rq_xprt->xpt_flags))return -ENOTCONN ; sent =svc_sendto (rqstp, &rqstp->rq_res);if (sent != xbufp->len) {printk (KERN_NOTICE "rpc-srv/tcp: %s: %s %d when sending %d bytes - shutting down socket\n" , - rqstp->rq_sock->sk_xprt.xpt_server->sv_name, + rqstp->rq_xprt->xpt_server->sv_name, (sent<0 )?"got error" :"sent only" , sent, xbufp->len); -set_bit (XPT_CLOSE , &rqstp->rq_sock->sk_xprt.xpt_flags); +set_bit (XPT_CLOSE , &rqstp->rq_xprt->xpt_flags);svc_xprt_enqueue (rqstp->rq_xprt); sent = -EAGAIN ; }
@@ -1302,7 +1312,7 @@ static void svc_tcp_prep_reply_hdr(struct svc_rqst *rqstp)static int svc_tcp_has_wspace (struct svc_xprt *xprt) { - struct svc_sock *svsk = container_of(xprt, struct svc_sock, sk_xprt); + struct svc_sock *svsk = container_of(xprt, struct svc_sock, sk_xprt);struct svc_serv *serv = svsk->sk_xprt.xpt_server;int required;int wspace;
@@ -1625,7 +1635,7 @@ svc_recv(struct svc_rqst *rqstp, long timeout)void svc_drop (struct svc_rqst *rqstp) { -dprintk ("svc: socket %p dropped request\n" , rqstp->rq_sock); +dprintk ("svc: xprt %p dropped request\n" , rqstp->rq_xprt);svc_xprt_release (rqstp); }
PATCH 34/40 svc: Make svc_check_conn_limits xprt independent
In reply to a message not in the archiveThe svc_check_conn_limits function only manipulates xprt fields. Change references to svc_sock->sk_xprt to svc_xprt directly.
---
net/sunrpc/svcsock.c | 24 ++++++++++++------------ 1 files changed, 12 insertions(+), 12 deletions(-)
net/sunrpc/svcsock.c +12 -12
@@ -1448,31 +1448,31 @@ svc_sock_update_bufs(struct svc_serv *serv)static void svc_check_conn_limits (struct svc_serv *serv) {if (serv->sv_tmpcnt > (serv->sv_nrthreads+3 )*20 ) { -struct svc_sock *svsk =NULL ; +struct svc_xprt *xprt =NULL ;spin_lock_bh (&serv->sv_lock);if (!list_empty (&serv->sv_tempsocks)) {if (net_ratelimit ()) {/* Try to help the admin */ -printk (KERN_NOTICE "%s: too many open TCP " -"sockets, consider increasing the " +printk (KERN_NOTICE "%s: too many open " +"connections, consider increasing the " "number of nfsd threads\n" , serv->sv_name); }/* -* Always select the oldest socket. It's not fair, +* Always select the oldest connection. It's not fair, * but so is life */ - svsk =list_entry (serv->sv_tempsocks.prev, - struct svc_sock, - sk_xprt.xpt_list); -set_bit (XPT_CLOSE , &svsk->sk_xprt.xpt_flags); -svc_xprt_get (&svsk->sk_xprt); + xprt =list_entry (serv->sv_tempsocks.prev, + struct svc_xprt, + xpt_list); +set_bit (XPT_CLOSE , &xprt->xpt_flags); +svc_xprt_get (xprt); }spin_unlock_bh (&serv->sv_lock); -if (svsk) { -svc_xprt_enqueue (&svsk->sk_xprt); -svc_xprt_put (&svsk->sk_xprt); +if (xprt) { +svc_xprt_enqueue (xprt); +svc_xprt_put (xprt); } } }
PATCH 35/40 svc: Move the xprt independent code to the svc_xprt.c file
In reply to a message not in the archiveThis functionally trivial patch moves all of the transport independent functions from the svcsock.c file to the transport independent svc_xprt.c file.
In addition the following formatting changes were made:
- White space cleanup
- Function signatures on single line
- The inline directive was removed
- Lines over 80 columns were reformatted
- The term 'socket' was changed to 'transport' in comments
- The SMP comment was moved and updated.
---
include/linux/sunrpc/svc_xprt.h | 27 + net/sunrpc/svc_xprt.c | 753 +++++++++++++++++++++++++++++++++++ net/sunrpc/svcsock.c | 834 +-------------------------------------- 3 files changed, 804 insertions(+), 810 deletions(-)
include/linux/sunrpc/svc_xprt.h +27 -0
@@ -72,9 +72,14 @@ void svc_unreg_xprt_class(struct svc_xprt_class *);void svc_xprt_init (struct svc_xprt_class *,struct svc_xprt *,struct svc_serv *);int svc_create_xprt (struct svc_serv *,char *,unsigned short ,int ); +void svc_xprt_enqueue (struct svc_xprt *xprt);void svc_xprt_received (struct svc_xprt *);void svc_xprt_put (struct svc_xprt *xprt);void svc_xprt_copy_addrs (struct svc_rqst *rqstp,struct svc_xprt *xprt); +void svc_close_xprt (struct svc_xprt *xprt); +void svc_delete_xprt (struct svc_xprt *xprt); +int svc_port_is_privileged (struct sockaddr *sin); +static inline void svc_xprt_get (struct svc_xprt *xprt) {kref_get (&xprt->xpt_ref);
@@ -126,4 +131,26 @@ static inline unsigned short svc_xprt_remote_port(struct svc_xprt *xprt)return svc_addr_port ((struct sockaddr *)&xprt->xpt_remote); } +static inline char *__svc_print_addr (struct sockaddr *addr, +char *buf,size_t len) +{ +switch (addr->sa_family) { +case AF_INET : +snprintf (buf, len,"%u.%u.%u.%u, port=%u" , +NIPQUAD (((struct sockaddr_in *) addr)->sin_addr), +ntohs (((struct sockaddr_in *) addr)->sin_port)); +break ; + +case AF_INET6 : +snprintf (buf, len,"%x:%x:%x:%x:%x:%x:%x:%x, port=%u" , +NIP6 (((struct sockaddr_in6 *) addr)->sin6_addr), +ntohs (((struct sockaddr_in6 *) addr)->sin6_port)); +break ; + +default : +snprintf (buf, len,"unknown address type: %d" , addr->sa_family); +break ; + } +return buf; +}#endif /* SUNRPC_SVC_XPRT_H */
net/sunrpc/svc_xprt.c +753 -0
766 lines not on this page · raw message
net/sunrpc/svcsock.c +24 -810
984 lines not on this page · raw message
A message that is not in the archive (sent off-list or not yet received): 20071231030827.8430.76850.stgit-gUwIgmpLGaKNDNWfRnPdfg@public.gmane.org
Re: [PATCH 35/40] svc: Move the xprt independent code to the svc_xprt.c file
Quoted 526 lines · Tom Tucker
net/sunrpc/svcsock.c +20
-354@@ -48,66 +48,24 @@#include <linux/sunrpc/svcsock.h> #include <linux/sunrpc/stats.h> -/* SMP locking strategy: -* -* svc_pool->sp_lock protects most of the fields of that pool. -* svc_serv->sv_lock protects sv_tempsocks, sv_permsocks, sv_tmpcnt. -* when both need to be taken (rare), svc_serv->sv_lock is first. -* BKL protects svc_serv->sv_nrthread. -* svc_sock->sk_lock protects the svc_sock->sk_deferred list -* and the ->sk_info_authunix cache. -* svc_sock->sk_xprt.xpt_flags.XPT_BUSY prevents a svc_sock being -* enqueued multiply. -* -* Some flags can be set to certain values at any time -* providing that certain rules are followed: -* -* XPT_CONN, XPT_DATA, can be set or cleared at any time. -* after a set, svc_xprt_enqueue must be called. -* after a clear, the socket must be read/accepted -* if this succeeds, it must be set again. -* XPT_CLOSE can set at any time. It is never cleared. -* xpt_ref contains a bias of '1' until XPT_DEAD is set. -* so when xprt_ref hits zero, we know the transport is dead -* and no-one is using it. -* XPT_DEAD can only be set while XPT_BUSY is held which ensures -* no other thread will be using the socket or will try to -* set XPT_DEAD. -* -*/ -#define RPCDBG_FACILITY RPCDBG_SVCXPRTstatic struct svc_sock *svc_setup_socket (struct svc_serv *,struct socket *,int *errp,int flags); -static void svc_delete_xprt (struct svc_xprt *xprt);static void svc_udp_data_ready (struct sock *,int );static int svc_udp_recvfrom (struct svc_rqst *);static int svc_udp_sendto (struct svc_rqst *); -static void svc_close_xprt (struct svc_xprt *xprt);static void svc_sock_detach (struct svc_xprt *);static void svc_sock_free (struct svc_xprt *); -static struct svc_deferred_req *svc_deferred_dequeue (struct svc_xprt *xprt); -static int svc_deferred_recv (struct svc_rqst *rqstp); -static struct cache_deferred_req *svc_defer (struct cache_req *req);static struct svc_xprt *svc_create_socket (struct svc_serv *,int ,struct sockaddr *,int ,int ); -static void svc_age_temp_xprts (unsigned long closure); - -/* apparently the "standard" is that clients close -* idle connections after 5 minutes, servers after -* 6 minutes -* http://www.connectathon.org/talks96/nfstcp.pdf -*/ -static int svc_conn_age_period =6 *60 ; -#ifdef CONFIG_DEBUG_LOCK_ALLOC static struct lock_class_key svc_key[2 ];static struct lock_class_key svc_slock_key[2 ]; -static inline void svc_reclassify_socket (struct socket *sock) +static void svc_reclassify_socket (struct socket *sock) {struct sock *sk = sock->sk;BUG_ON (sock_owned_by_user (sk));@@ -131,67 +89,11 @@ static inline void svc_reclassify_socket(struct socket *sock) } }#else -static inline void svc_reclassify_socket (struct socket *sock) +static void svc_reclassify_socket (struct socket *sock) { }#endif -static char *__svc_print_addr (struct sockaddr *addr,char *buf,size_t len) -{ -switch (addr->sa_family) { -case AF_INET : -snprintf (buf, len,"%u.%u.%u.%u, port=%u" , -NIPQUAD (((struct sockaddr_in *) addr)->sin_addr), -ntohs (((struct sockaddr_in *) addr)->sin_port)); -break ; - -case AF_INET6 : -snprintf (buf, len,"%x:%x:%x:%x:%x:%x:%x:%x, port=%u" , -NIP6 (((struct sockaddr_in6 *) addr)->sin6_addr), -ntohs (((struct sockaddr_in6 *) addr)->sin6_port)); -break ; - -default : -snprintf (buf, len,"unknown address type: %d" , addr->sa_family); -break ; - } -return buf; -} - -/** -* svc_print_addr - Format rq_addr field for printing -* @rqstp: svc_rqst struct containing address to print -* @buf: target buffer for formatted address -* @len: length of target buffer -* -*/ -char *svc_print_addr (struct svc_rqst *rqstp,char *buf,size_t len) -{ -return __svc_print_addr (svc_addr (rqstp), buf, len); -} -EXPORT_SYMBOL_GPL (svc_print_addr); - -/* -* Queue up an idle server thread. Must have pool->sp_lock held. -* Note: this is really a stack rather than a queue, so that we only -* use as many different threads as we need, and the rest don't pollute -* the cache. -*/ -static inline void -svc_thread_enqueue (struct svc_pool *pool,struct svc_rqst *rqstp) -{ -list_add (&rqstp->rq_list, &pool->sp_threads); -} - -/* -* Dequeue an nfsd thread. Must have pool->sp_lock held. -*/ -static inline void -svc_thread_dequeue (struct svc_pool *pool,struct svc_rqst *rqstp) -{ -list_del (&rqstp->rq_list); -} -/* * Release an skbuff after use */ @@ -214,220 +116,6 @@ static void svc_release_skb(struct svc_rqst *rqstp) } } -/* -* Queue up a socket with data pending. If there are idle nfsd -* processes, wake 'em up. -* -*/ -void svc_xprt_enqueue (struct svc_xprt *xprt) -{ -struct svc_serv *serv = xprt->xpt_server; -struct svc_pool *pool; -struct svc_rqst *rqstp; -int cpu; - -if (!(xprt->xpt_flags & - ((1 <<XPT_CONN )|(1 <<XPT_DATA )|(1 <<XPT_CLOSE )|(1 <<XPT_DEFERRED )))) -return ; -if (test_bit (XPT_DEAD , &xprt->xpt_flags)) -return ; - - cpu =get_cpu (); - pool =svc_pool_for_cpu (xprt->xpt_server, cpu); -put_cpu (); - -spin_lock_bh (&pool->sp_lock); - -if (!list_empty (&pool->sp_threads) && - !list_empty (&pool->sp_sockets)) -printk (KERN_ERR -"svc_xprt_enqueue: " -"threads and transports both waiting??\n" ); - -if (test_bit (XPT_DEAD , &xprt->xpt_flags)) { -/* Don't enqueue dead sockets */ -dprintk ("svc: transport %p is dead, not enqueued\n" , xprt); - goto out_unlock; - } - -/* Mark socket as busy. It will remain in this state until the -* server has processed all pending data and put the socket back -* on the idle list. We update XPT_BUSY atomically because -* it also guards against trying to enqueue the svc_sock twice. -*/ -if (test_and_set_bit (XPT_BUSY , &xprt->xpt_flags)) { -/* Don't enqueue socket while already enqueued */ -dprintk ("svc: transport %p busy, not enqueued\n" , xprt); - goto out_unlock; - } -BUG_ON (xprt->xpt_pool !=NULL ); - xprt->xpt_pool = pool; - -/* Handle pending connection */ -if (test_bit (XPT_CONN , &xprt->xpt_flags)) - goto process; - -/* Handle close in-progress */ -if (test_bit (XPT_CLOSE , &xprt->xpt_flags)) - goto process; - -/* Check if we have space to reply to a request */ -if (!xprt->xpt_ops->xpo_has_wspace (xprt)) { -/* Don't enqueue while not enough space for reply */ -dprintk ("svc: no write space, transport %p not enqueued\n" , - xprt); - xprt->xpt_pool =NULL ; -clear_bit (XPT_BUSY , &xprt->xpt_flags); - goto out_unlock; - } - - process: -if (!list_empty (&pool->sp_threads)) { - rqstp =list_entry (pool->sp_threads.next, - struct svc_rqst, - rq_list); -dprintk ("svc: transport %p served by daemon %p\n" , - xprt, rqstp); -svc_thread_dequeue (pool, rqstp); -if (rqstp->rq_xprt) -printk (KERN_ERR -"svc_xprt_enqueue: server %p, rq_xprt=%p!\n" , - rqstp, rqstp->rq_xprt); - rqstp->rq_xprt = xprt; -svc_xprt_get (xprt); - rqstp->rq_reserved = serv->sv_max_mesg; -atomic_add (rqstp->rq_reserved, &xprt->xpt_reserved); -BUG_ON (xprt->xpt_pool != pool); -wake_up (&rqstp->rq_wait); - }else { -dprintk ("svc: transport %p put into queue\n" , xprt); -list_add_tail (&xprt->xpt_ready, &pool->sp_sockets); -BUG_ON (xprt->xpt_pool != pool); - } - -out_unlock: -spin_unlock_bh (&pool->sp_lock); -} -EXPORT_SYMBOL_GPL (svc_xprt_enqueue); - -/* -* Dequeue the first socket. Must be called with the pool->sp_lock held. -*/ -static struct svc_xprt *svc_xprt_dequeue (struct svc_pool *pool) -{ -struct svc_xprt *xprt; - -if (list_empty (&pool->sp_sockets)) -return NULL ; - - xprt =list_entry (pool->sp_sockets.next, - struct svc_xprt, xpt_ready); -list_del_init (&xprt->xpt_ready); - -dprintk ("svc: transport %p dequeued, inuse=%d\n" , - xprt,atomic_read (&xprt->xpt_ref.refcount)); - -return xprt; -} - -/* -* svc_xprt_received conditionally queues the transport for processing -* by another thread. The caller must hold the XPT_BUSY bit and must -* not thereafter touch transport data. -* -* Note: XPT_DATA only gets cleared when a read-attempt finds no (or -* insufficient) data. -*/ -void svc_xprt_received (struct svc_xprt *xprt) -{ -BUG_ON (!test_bit (XPT_BUSY , &xprt->xpt_flags)); - xprt->xpt_pool =NULL ; -clear_bit (XPT_BUSY , &xprt->xpt_flags); -svc_xprt_enqueue (xprt); -} -EXPORT_SYMBOL_GPL (svc_xprt_received); - -/** -* svc_reserve - change the space reserved for the reply to a request. -* @rqstp: The request in question -* @space: new max space to reserve -* -* Each request reserves some space on the output queue of the socket -* to make sure the reply fits. This function reduces that reserved -* space to be the amount of space used already, plus @space. -* -*/ -void svc_reserve (struct svc_rqst *rqstp,int space) -{ - space += rqstp->rq_res.head[0 ].iov_len; - -if (space < rqstp->rq_reserved) { -struct svc_xprt *xprt = rqstp->rq_xprt; -atomic_sub ((rqstp->rq_reserved - space), &xprt->xpt_reserved); - rqstp->rq_reserved = space; - -svc_xprt_enqueue (xprt); - } -} - -static void svc_xprt_release (struct svc_rqst *rqstp) -{ -struct svc_xprt *xprt = rqstp->rq_xprt; - - rqstp->rq_xprt->xpt_ops->xpo_release_rqst (rqstp); - -svc_free_res_pages (rqstp); - rqstp->rq_res.page_len =0 ; - rqstp->rq_res.page_base =0 ; - -/* Reset response buffer and release -* the reservation. -* But first, check that enough space was reserved -* for the reply, otherwise we have a bug! -*/ -if ((rqstp->rq_res.len) > rqstp->rq_reserved) -printk (KERN_ERR "RPC request reserved %d but used %d\n" , - rqstp->rq_reserved, - rqstp->rq_res.len); - - rqstp->rq_res.head[0 ].iov_len =0 ; -svc_reserve (rqstp,0 ); - rqstp->rq_xprt =NULL ; - -svc_xprt_put (xprt); -} - -/* -* External function to wake up a server waiting for data -* This really only makes sense for services like lockd -* which have exactly one thread anyway. -*/ -void -svc_wake_up (struct svc_serv *serv) -{ -struct svc_rqst *rqstp; -unsigned int i; -struct svc_pool *pool; - -for (i =0 ; i < serv->sv_nrpools; i++) { - pool = &serv->sv_pools[i]; - -spin_lock_bh (&pool->sp_lock); -if (!list_empty (&pool->sp_threads)) { - rqstp =list_entry (pool->sp_threads.next, - struct svc_rqst, - rq_list); -dprintk ("svc: daemon %p woken up.\n" , rqstp); -/* -svc_thread_dequeue(pool, rqstp); -rqstp->rq_xprt = NULL; -*/ -wake_up (&rqstp->rq_wait); - } -spin_unlock_bh (&pool->sp_lock); - } -} -union svc_pktinfo_u {struct in_pktinfo pkti;struct in6_pktinfo pkti6;@@ -469,8 +157,7 @@ static void svc_set_cmsg_data(struct svc_rqst *rqstp, struct cmsghdr *cmh)/* * Generic sendto routine */ -static int -svc_sendto (struct svc_rqst *rqstp,struct xdr_buf *xdr) +static int svc_sendto (struct svc_rqst *rqstp,struct xdr_buf *xdr) {struct svc_sock *svsk = container_of(rqstp->rq_xprt, struct svc_sock, sk_xprt);@@ -605,8 +292,7 @@ EXPORT_SYMBOL(svc_sock_names);/* * Check input queue length */ -static int -svc_recv_available (struct svc_sock *svsk) +static int svc_recv_available (struct svc_sock *svsk) {struct socket *sock = svsk->sk_sock;int avail, err;@@ -619,8 +305,8 @@ svc_recv_available(struct svc_sock *svsk)/* * Generic recvfrom routine. */ -static int -svc_recvfrom (struct svc_rqst *rqstp,struct kvec *iov,int nr,int buflen) +static int svc_recvfrom (struct svc_rqst *rqstp,struct kvec *iov,int nr, +int buflen) {struct svc_sock *svsk = container_of(rqstp->rq_xprt, struct svc_sock, sk_xprt);@@ -640,8 +326,8 @@ svc_recvfrom(struct svc_rqst *rqstp, struct kvec *iov, int nr, int buflen)/* * Set socket snd and rcv buffer lengths */ -static inline void -svc_sock_setbufsize (struct socket *sock,unsigned int snd,unsigned int rcv) +static void svc_sock_setbufsize (struct socket *sock,unsigned int snd, +unsigned int rcv) {#if 0 mm_segment_t oldfs;@@ -666,8 +352,7 @@ svc_sock_setbufsize(struct socket *sock, unsigned int snd, unsigned int rcv)/* * INET callback when data has been received on the socket. */ -static void -svc_udp_data_ready (struct sock *sk,int count) +static void svc_udp_data_ready (struct sock *sk,int count) {struct svc_sock *svsk = (struct svc_sock *)sk->sk_user_data;@@ -685,8 +370,7 @@ svc_udp_data_ready(struct sock *sk, int count)/* * INET callback when space is newly available on the socket. */ -static void -svc_write_space (struct sock *sk) +static void svc_write_space (struct sock *sk) {struct svc_sock *svsk = (struct svc_sock *)(sk->sk_user_data);@@ -732,8 +416,7 @@ static void svc_udp_get_dest_address(struct svc_rqst *rqstp,/* * Receive a datagram from a UDP socket. */ -static int -svc_udp_recvfrom (struct svc_rqst *rqstp) +static int svc_udp_recvfrom (struct svc_rqst *rqstp) {struct svc_sock *svsk = container_of(rqstp->rq_xprt, struct svc_sock, sk_xprt);@@ -827,7 +510,8 @@ svc_udp_recvfrom(struct svc_rqst *rqstp)skb_free_datagram (svsk->sk_sk, skb); }else {/* we can use it in-place */ - rqstp->rq_arg.head[0 ].iov_base = skb->data +sizeof (struct udphdr ); + rqstp->rq_arg.head[0 ].iov_base = skb->data + +sizeof (struct udphdr ); rqstp->rq_arg.head[0 ].iov_len = len;if (skb_checksum_complete (skb)) {skb_free_datagram (svsk->sk_sk, skb);@@ -938,7 +622,8 @@ static void svc_udp_init(struct svc_sock *svsk, struct svc_serv *serv)3 * svsk->sk_xprt.xpt_server->sv_max_mesg, 3 * svsk->sk_xprt.xpt_server->sv_max_mesg); -set_bit (XPT_DATA , &svsk->sk_xprt.xpt_flags);/* might have come in before data_ready set up */ +/* data might have come in before data_ready set up */ +set_bit (XPT_DATA , &svsk->sk_xprt.xpt_flags);set_bit (XPT_CHNGBUF , &svsk->sk_xprt.xpt_flags); oldfs =get_fs ();@@ -953,8 +638,7 @@ static void svc_udp_init(struct svc_sock *svsk, struct svc_serv *serv)* A data_ready event on a listening socket means there's a connection * pending. Do not use state_change as a substitute for it. */ -static void -svc_tcp_listen_data_ready (struct sock *sk,int count_unused) +static void svc_tcp_listen_data_ready (struct sock *sk,int count_unused) {struct svc_sock *svsk = (struct svc_sock *)sk->sk_user_data;@@ -986,8 +670,7 @@ svc_tcp_listen_data_ready(struct sock *sk, int count_unused)/* * A state change on a connected socket means it's dying or dead. */ -static void -svc_tcp_state_change (struct sock *sk) +static void svc_tcp_state_change (struct sock *sk) {struct svc_sock *svsk = (struct svc_sock *)sk->sk_user_data;@@ -1004,8 +687,7 @@ svc_tcp_state_change(struct sock *sk)wake_up_interruptible_all (sk->sk_sleep); } -static void -svc_tcp_data_ready (struct sock *sk,int count) +static void svc_tcp_data_ready (struct sock *sk,int count) {struct svc_sock *svsk = (struct svc_sock *)sk->sk_user_data;@@ -1019,20 +701,6 @@ svc_tcp_data_ready(struct sock *sk, int count)wake_up_interruptible (sk->sk_sleep); } -static inline int svc_port_is_privileged (struct sockaddr *sin) -{ -switch (sin->sa_family) { -case AF_INET : -return ntohs (((struct sockaddr_in *)sin)->sin_port) - <PROT_SOCK ; -case AF_INET6 : -return ntohs (((struct sockaddr_in6 *)sin)->sin6_port) - <PROT_SOCK ; -default : -return 0 ; - } -} -/* * Accept a TCP connection */ @@ -1115,8 +783,7 @@ failed:/* * Receive data from a TCP socket. */ -static int -svc_tcp_recvfrom (struct svc_rqst *rqstp) +static int svc_tcp_recvfrom (struct svc_rqst *rqstp) {struct svc_sock *svsk = container_of(rqstp->rq_xprt, struct svc_sock, sk_xprt);@@ -1269,8 +936,7 @@ svc_tcp_recvfrom(struct svc_rqst *rqstp)/* * Send out data on TCP socket. */ -static int -svc_tcp_sendto (struct svc_rqst *rqstp) +static int svc_tcp_sendto (struct svc_rqst *rqstp) {struct xdr_buf *xbufp = &rqstp->rq_res;int sent;
net/sunrpc/svcsock.c svc_tcp_sendto(struct svc_rqst *rqstp) · line 957
Quoted 5 lines
net/sunrpc/svcsock.c +1
-1@@ -1288,7 +954,9 @@ svc_tcp_sendto(struct svc_rqst *rqstp) sent =svc_sendto (rqstp, &rqstp->rq_res);if (sent != xbufp->len) { - printk(KERN_NOTICE "rpc-srv/tcp: %s: %s %d when sending %d bytes - shutting down socket\n", + printk(KERN_NOTICE
Nit--git complained about trailing whitespace here; fixed in my version.
--b.
PATCH 36/40 svc: Add transport hdr size for defer/revisit
In reply to a message not in the archiveSome transports have a header in front of the RPC header. The current defer/revisit processing considers only the iov_len and arg_len to determine how much to back up when saving the original request to revisit. Add a field to the rqstp structure to save the size of the transport header so svc_defer can correctly compute the start of a request.
---
include/linux/sunrpc/svc.h | 2 ++ net/sunrpc/svc_xprt.c | 36 +++++++++++++++++++++++++++--------- net/sunrpc/svcsock.c | 2 ++ 3 files changed, 31 insertions(+), 9 deletions(-)
include/linux/sunrpc/svc.h +2 -0
@@ -217,6 +217,7 @@ struct svc_rqst {void * rq_xprt_ctxt;/* transport specific context ptr */ struct svc_deferred_req *rq_deferred;/* deferred request we are replaying */ +size_t rq_xprt_hlen;/* xprt header len */ struct xdr_buf rq_arg;struct xdr_buf rq_res;struct page * rq_pages[RPCSVC_MAXPAGES ];
@@ -322,6 +323,7 @@ struct svc_deferred_req {size_t addrlen;union svc_addr_u daddr;/* where reply must come from */ struct cache_deferred_req handle; +size_t xprt_hlen;int argslen;__be32 args[0 ]; };
net/sunrpc/svc_xprt.c +27 -9
@@ -29,7 +29,6 @@#include <linux/sunrpc/types.h> #include <linux/sunrpc/clnt.h> #include <linux/sunrpc/xdr.h> -#include <linux/sunrpc/svcsock.h> #include <linux/sunrpc/stats.h> #include <linux/sunrpc/svc_xprt.h>
@@ -859,10 +858,18 @@ static void svc_revisit(struct cache_deferred_req *dreq, int too_many)svc_xprt_put (xprt); } +/* +* Save the request off for later processing. The request buffer looks +* like this: +* +* <xprt-header><rpc-header><rpc-pagelist><rpc-tail> +* +* This code can only handle requests that consist of an xprt-header +* and rpc-header. +*/ static struct cache_deferred_req *svc_defer (struct cache_req *req) { struct svc_rqst *rqstp = container_of(req, struct svc_rqst, rq_chandle); -int size =sizeof (struct svc_deferred_req ) + (rqstp->rq_arg.len);struct svc_deferred_req *dr;if (rqstp->rq_arg.page_len)
@@ -871,8 +878,10 @@ static struct cache_deferred_req *svc_defer(struct cache_req *req) dr = rqstp->rq_deferred; rqstp->rq_deferred =NULL ; }else { -int skip = rqstp->rq_arg.len - rqstp->rq_arg.head[0 ].iov_len; +size_t skip; +size_t size;/* FIXME maybe discard if size too large */ + size =sizeof (struct svc_deferred_req ) + rqstp->rq_arg.len; dr =kmalloc (size,GFP_KERNEL );if (dr ==NULL )return NULL ;
@@ -883,8 +892,12 @@ static struct cache_deferred_req *svc_defer(struct cache_req *req) dr->addrlen = rqstp->rq_addrlen; dr->daddr = rqstp->rq_daddr; dr->argslen = rqstp->rq_arg.len >>2 ; -memcpy (dr->args, rqstp->rq_arg.head[0 ].iov_base-skip, - dr->argslen<<2 ); + dr->xprt_hlen = rqstp->rq_xprt_hlen; + +/* back up head to the start of the buffer and copy */ + skip = rqstp->rq_arg.len - rqstp->rq_arg.head[0 ].iov_len; +memcpy (dr->args, rqstp->rq_arg.head[0 ].iov_base - skip, + dr->argslen <<2 ); }svc_xprt_get (rqstp->rq_xprt); dr->xprt = rqstp->rq_xprt;
@@ -900,16 +913,21 @@ static int svc_deferred_recv(struct svc_rqst *rqstp) {struct svc_deferred_req *dr = rqstp->rq_deferred; - rqstp->rq_arg.head[0 ].iov_base = dr->args; - rqstp->rq_arg.head[0 ].iov_len = dr->argslen<<2 ; +/* setup iov_base past transport header */ + rqstp->rq_arg.head[0 ].iov_base = dr->args + (dr->xprt_hlen>>2 ); +/* The iov_len does not include the transport header bytes */ + rqstp->rq_arg.head[0 ].iov_len = (dr->argslen<<2 ) - dr->xprt_hlen; rqstp->rq_arg.page_len =0 ; - rqstp->rq_arg.len = dr->argslen<<2 ; +/* The rq_arg.len includes the transport header bytes */ + rqstp->rq_arg.len = dr->argslen<<2 ; rqstp->rq_prot = dr->prot;memcpy (&rqstp->rq_addr, &dr->addr, dr->addrlen); rqstp->rq_addrlen = dr->addrlen; +/* Save off transport header len in case we get deferred again */ + rqstp->rq_xprt_hlen = dr->xprt_hlen; rqstp->rq_daddr = dr->daddr; rqstp->rq_respages = rqstp->rq_pages; -return dr->argslen<<2 ; +return (dr->argslen<<2 ) - dr->xprt_hlen; }
net/sunrpc/svcsock.c +2 -0
@@ -315,6 +315,8 @@ static int svc_recvfrom(struct svc_rqst *rqstp, struct kvec *iov, int nr, };int len; + rqstp->rq_xprt_hlen =0 ; + len =kernel_recvmsg (svsk->sk_sock, &msg, iov, nr, buflen, msg.msg_flags);
PATCH 37/40 svc: Add /proc/sys/sunrpc/transport files
In reply to a message not in the archiveAdd a file that when read lists the set of registered svc transports.
---
include/linux/sunrpc/svc_xprt.h | 1 + net/sunrpc/svc_xprt.c | 28 ++++++++++++++++++++++++++++ net/sunrpc/sysctl.c | 31 +++++++++++++++++++++++++++++++ 3 files changed, 60 insertions(+), 0 deletions(-)
include/linux/sunrpc/svc_xprt.h +1 -0
@@ -79,6 +79,7 @@ void svc_xprt_copy_addrs(struct svc_rqst *rqstp, struct svc_xprt *xprt);void svc_close_xprt (struct svc_xprt *xprt);void svc_delete_xprt (struct svc_xprt *xprt);int svc_port_is_privileged (struct sockaddr *sin); +int svc_print_xprts (char *buf,int maxlen);static inline void svc_xprt_get (struct svc_xprt *xprt) {
net/sunrpc/svc_xprt.c +28 -0
@@ -112,6 +112,34 @@ void svc_unreg_xprt_class(struct svc_xprt_class *xcl) }EXPORT_SYMBOL_GPL (svc_unreg_xprt_class); +/* +* Format the transport list for printing +*/ +int svc_print_xprts (char *buf,int maxlen) +{ +struct list_head *le; +char tmpstr[80 ]; +int len =0 ; + buf[0 ] ='\0' ; + +spin_lock (&svc_xprt_class_lock); +list_for_each (le, &svc_xprt_class_list) { +int slen; +struct svc_xprt_class *xcl = + list_entry(le, struct svc_xprt_class, xcl_list); + +sprintf (tmpstr,"%s %d\n" , xcl->xcl_name, xcl->xcl_max_payload); + slen =strlen (tmpstr); +if (len + slen > maxlen) +break ; + len += slen; +strcat (buf, tmpstr); + } +spin_unlock (&svc_xprt_class_lock); + +return len; +} +static void svc_xprt_free (struct kref *kref) { struct svc_xprt *xprt =
net/sunrpc/sysctl.c +31 -0
@@ -18,6 +18,7 @@#include <linux/sunrpc/types.h> #include <linux/sunrpc/sched.h> #include <linux/sunrpc/stats.h> +#include <linux/sunrpc/svc_xprt.h> /* * Declare the debug flags here
@@ -48,6 +49,30 @@ rpc_unregister_sysctl(void) } } +static int proc_do_xprt (ctl_table *table,int write,struct file *file, +void __user *buffer,size_t *lenp,loff_t *ppos) +{ +char tmpbuf[256 ]; +int len; +if ((*ppos && !write) || !*lenp) { + *lenp =0 ; +return 0 ; + } +if (write) +return -EINVAL ; +else { + len =svc_print_xprts (tmpbuf,sizeof (tmpbuf)); +if (!access_ok (VERIFY_WRITE , buffer, len)) +return -EFAULT ; + +if (__copy_to_user (buffer, tmpbuf, len)) +return -EFAULT ; + } + *lenp -= len; + *ppos += len; +return 0 ; +} +static int proc_dodebug (ctl_table *table,int write,struct file *file,void __user *buffer,size_t *lenp,loff_t *ppos)
@@ -140,6 +165,12 @@ static ctl_table debug_table[] = { .mode = 0644, .proc_handler = &proc_dodebug }, + { + .procname = "transports", + .maxlen = 256, + .mode = 0444, + .proc_handler = &proc_do_xprt, + }, { .ctl_name = 0 } };
PATCH 38/40 svc: Add svc API that queries for a transport instance
In reply to a message not in the archiveAdd a new svc function that allows a service to query whether a transport instance has already been created. This is used in lockd to determine whether or not a transport needs to be created when a lockd instance is brought up.
Specifying 0 for the address family or port is effectively a wild-card, and will result in matching the first transport in the service's list that has a matching class name.
---
fs/lockd/svc.c | 16 ++-------------- include/linux/sunrpc/svc_xprt.h | 1 + net/sunrpc/svc_xprt.c | 35 +++++++++++++++++++++++++++++++++++ 3 files changed, 38 insertions(+), 14 deletions(-)
fs/lockd/svc.c +2 -14
@@ -219,18 +219,6 @@ lockd(struct svc_rqst *rqstp)module_put_and_exit (0 ); } -static int find_xprt (struct svc_serv *serv,char *proto) -{ -struct svc_xprt *xprt; -int found =0 ; -list_for_each_entry (xprt, &serv->sv_permsocks, xpt_list) -if (strcmp (xprt->xpt_class->xcl_name, proto) ==0 ) { - found =1 ; -break ; - } -return found; -} -/* * Make any sockets that are needed but not present. * If nlm_udpport or nlm_tcpport were set as module
@@ -242,11 +230,11 @@ static int make_socks(struct svc_serv *serv, int proto)int err =0 ;if (proto ==IPPROTO_UDP || nlm_udpport) -if (!find_xprt (serv,"udp" )) +if (!svc_find_xprt (serv,"udp" ,0 ,0 )) err =svc_create_xprt (serv,"udp" , nlm_udpport,SVC_SOCK_DEFAULTS );if (err >=0 && (proto ==IPPROTO_TCP || nlm_tcpport)) -if (!find_xprt (serv,"tcp" )) +if (!svc_find_xprt (serv,"tcp" ,0 ,0 )) err =svc_create_xprt (serv,"tcp" , nlm_tcpport,SVC_SOCK_DEFAULTS );
include/linux/sunrpc/svc_xprt.h +1 -0
@@ -80,6 +80,7 @@ void svc_close_xprt(struct svc_xprt *xprt);void svc_delete_xprt (struct svc_xprt *xprt);int svc_port_is_privileged (struct sockaddr *sin);int svc_print_xprts (char *buf,int maxlen); +struct svc_xprt *svc_find_xprt (struct svc_serv *,char *,int ,int );static inline void svc_xprt_get (struct svc_xprt *xprt) {
net/sunrpc/svc_xprt.c +35 -0
@@ -977,3 +977,38 @@ static struct svc_deferred_req *svc_deferred_dequeue(struct svc_xprt *xprt)spin_unlock (&xprt->xpt_lock);return dr; } + +/* +* Return the transport instance pointer for the endpoint accepting +* connections/peer traffic from the specified transport class, +* address family and port. +* +* Specifying 0 for the address family or port is effectively a +* wild-card, and will result in matching the first transport in the +* service's list that has a matching class name. +*/ +struct svc_xprt *svc_find_xprt (struct svc_serv *serv,char *xcl_name, +int af,int port) +{ +struct svc_xprt *xprt; +struct svc_xprt *found =NULL ; + +/* Sanity check the args */ +if (!serv || !xcl_name) +return found; + +spin_lock_bh (&serv->sv_lock); +list_for_each_entry (xprt, &serv->sv_permsocks, xpt_list) { +if (strcmp (xprt->xpt_class->xcl_name, xcl_name)) +continue ; +if (af !=AF_UNSPEC && af != xprt->xpt_local.ss_family) +continue ; +if (port && port !=svc_xprt_local_port (xprt)) +continue ; + found = xprt; +break ; + } +spin_unlock_bh (&serv->sv_lock); +return found; +} +EXPORT_SYMBOL_GPL (svc_find_xprt);
PATCH 39/40 knfsd: Support adding transports by writing portlist file
In reply to a message not in the archiveUpdate the write handler for the portlist file to allow creating new listening endpoints on a transport. The general form of the string is:
<transport_name><space><port number>
For example:
echo "tcp 2049" > /proc/fs/nfsd/portlist
This is intended to support the creation of a listening endpoint for RDMA transports without adding #ifdef code to the nfssvc.c file.
Transports can also be removed as follows:
'-'<transport_name><space><port number>
For example:
echo "-tcp 2049" > /proc/fs/nfsd/portlist
Attempting to add a listener with an invalid transport string results in EPROTONOSUPPORT and a perror string of "Protocol not supported".
Attempting to remove an non-existent listener (.e.g. bad proto or port) results in ENOTCONN and a perror string of
"Transport endpoint is not connected"
---
fs/nfsd/nfsctl.c | 48 +++++++++++++++++++++++++++++++++++++++++++++++- net/sunrpc/svc_xprt.c | 1 + 2 files changed, 48 insertions(+), 1 deletions(-)
fs/nfsd/nfsctl.c +47 -1
@@ -540,7 +540,7 @@ static ssize_t write_ports(struct file *file, char *buf, size_t size) }return err <0 ? err :0 ; } -if (buf[0 ] =='-' ) { +if (buf[0 ] =='-' &&isdigit (buf[1 ])) {char *toclose =kstrdup (buf+1 ,GFP_KERNEL );int len =0 ;if (!toclose)
@@ -554,6 +554,52 @@ static ssize_t write_ports(struct file *file, char *buf, size_t size)kfree (toclose);return len; } +/* +* Add a transport listener by writing it's transport name +*/ +if (isalpha (buf[0 ])) { +int err; +char transport[16 ]; +int port; +if (sscanf (buf,"%15s %4d" , transport, &port) ==2 ) { + err =nfsd_create_serv (); +if (!err) { + err =svc_create_xprt (nfsd_serv, + transport, port, +SVC_SOCK_ANONYMOUS ); +if (err == -ENOENT ) +/* Give a reasonable perror msg for +* bad transport string */ + err = -EPROTONOSUPPORT ; + } +return err <0 ? err :0 ; + } + } +/* +* Remove a transport by writing it's transport name and port number +*/ +if (buf[0 ] =='-' &&isalpha (buf[1 ])) { +struct svc_xprt *xprt; +int err = -EINVAL ; +char transport[16 ]; +int port; +if (sscanf (&buf[1 ],"%15s %4d" , transport, &port) ==2 ) { +if (port ==0 ) +return -EINVAL ; +lock_kernel (); +if (nfsd_serv) { + xprt =svc_find_xprt (nfsd_serv, transport, +AF_UNSPEC , port); +if (xprt) { +svc_close_xprt (xprt); + err =0 ; + }else + err = -ENOTCONN ; + } +unlock_kernel (); +return err <0 ? err :0 ; + } + }return -EINVAL ; }
net/sunrpc/svc_xprt.c +1 -0
@@ -842,6 +842,7 @@ void svc_close_xprt(struct svc_xprt *xprt)clear_bit (XPT_BUSY , &xprt->xpt_flags);svc_xprt_put (xprt); } +EXPORT_SYMBOL_GPL (svc_close_xprt);void svc_close_all (struct list_head *xprt_list) {
PATCH 40/40 svc: Add svc_xprt_names service to replace svc_sock_names
In reply to a message not in the archiveCreate a transport independent version of the svc_sock_names function.
The toclose capability of the svc_sock_names service can be implemented using the svc_xprt_find and svc_xprt_close services.
---
fs/nfsd/nfsctl.c | 2 +- include/linux/sunrpc/svc_xprt.h | 1 + net/sunrpc/svc_xprt.c | 35 +++++++++++++++++++++++++++++++++++ 3 files changed, 37 insertions(+), 1 deletions(-)
fs/nfsd/nfsctl.c +1 -1
@@ -503,7 +503,7 @@ static ssize_t write_ports(struct file *file, char *buf, size_t size)int len =0 ;lock_kernel ();if (nfsd_serv) - len =svc_sock_names (buf, nfsd_serv,NULL ); + len =svc_xprt_names (nfsd_serv, buf,0 );unlock_kernel ();return len; }
include/linux/sunrpc/svc_xprt.h +1 -0
@@ -81,6 +81,7 @@ void svc_delete_xprt(struct svc_xprt *xprt);int svc_port_is_privileged (struct sockaddr *sin);int svc_print_xprts (char *buf,int maxlen);struct svc_xprt *svc_find_xprt (struct svc_serv *,char *,int ,int ); +int svc_xprt_names (struct svc_serv *serv,char *buf,int buflen);static inline void svc_xprt_get (struct svc_xprt *xprt) {
net/sunrpc/svc_xprt.c +35 -0
@@ -1013,3 +1013,38 @@ struct svc_xprt *svc_find_xprt(struct svc_serv *serv, char *xcl_name,return found; }EXPORT_SYMBOL_GPL (svc_find_xprt); + +/* +* Format a buffer with a list of the active transports. A zero for +* the buflen parameter disables target buffer overflow checking. +*/ +int svc_xprt_names (struct svc_serv *serv,char *buf,int buflen) +{ +struct svc_xprt *xprt; +char xprt_str[64 ]; +int totlen =0 ; +int len; + +/* Sanity check args */ +if (!serv) +return 0 ; + +spin_lock_bh (&serv->sv_lock); +list_for_each_entry (xprt, &serv->sv_permsocks, xpt_list) { + len =snprintf (xprt_str,sizeof (xprt_str), +"%s %d\n" , xprt->xpt_class->xcl_name, +svc_xprt_local_port (xprt)); +/* If the string was truncated, replace with error string */ +if (len >=sizeof (xprt_str)) +strcpy (xprt_str,"name-too-long\n" ); +/* Don't overflow buffer */ + len =strlen (xprt_str); +if (buflen && (len + totlen >= buflen)) +break ; +strcpy (buf+totlen, xprt_str); + totlen += len; + } +spin_unlock_bh (&serv->sv_lock); +return totlen; +} +EXPORT_SYMBOL_GPL (svc_xprt_names);
Quoted 10 lines · Tom Tucker
The Server Side Transport switch implements a pluggable transport provider layer for RPC servers. This allows network transport drivers to be dynamically loaded and registered, thereby extending the set of transports that can carry RPC. This patchset includes a transport provider driver for TCP and UDP sockets.
This version of the patchset is functionally equivalent to the preceding patchset and includes the following improvements:
Thanks! Got it.
--b.
Quoted 41 lines
- Fixed a bug in
svc_create_socketthat resulted insvc_xprt_receivedbeing called without holding theXPT_BUSYbit.- Added a
BUG_ONinsvc_xprt_receivedto catch providers callingsvc_xprt_receivedwithout holding theXPT_BUSYbit.- Removed code setting the
XPT_BUSYbit in the create path and moved this logic to common code.- Cleaned up the SMP locking strategy comment and moved it to
svc_xprt.c- Changed return type of
svc_unreg_xprt_classto void- Simplified transport class removal logic
- Fixed a white-space abuse issue
- Made some style changes to the patch comments
- Created a separate patch that moves the connection limit code to generic logic
- Created a separate patch that moves the call to
svc_xprt_receivedout oftcp_acceptand into common logic- Created a separate patch for removal of unnecessary call to
svc_sock_enqueueinsvc_tcp_acceptfunction- Removed silly
BUG_ONfrom krefsvc_xprt_freecallback function- Moved unlock of
svc_xprt_classlist to after thetry_module_lockcall.- Refactored
svc_create_xprtlogic- Removed unnecessary call to
svc_find_xprtin portlist codeSignature · 1 line
Signed-off-by: Tom Tucker <[email protected]>