microsoft
/
WSL2-Linux-Kernel
зеркало из https://github.com/microsoft/WSL2-Linux-Kernel.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

[PATCH] RPC: transport switch function naming 

Introduce block header comments and a function naming convention to the
 socket transport implementation.  Provide a debug setting for transports
 that is separate from RPCDBG_XPRT.  Eliminate xprt_default_timeout().

 Provide block comments for exposed interfaces in xprt.c, and eliminate
 the useless obvious comments.

 Convert printk's to dprintk's.

 Test-plan:
 Compile kernel with CONFIG_NFS enabled.

 Version: Thu, 11 Aug 2005 16:04:04 -0400

 Signed-off-by: Chuck Lever <cel@netapp.com>
 Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
This commit is contained in:
Chuck Lever 2005-08-11 16:25:26 -04:00 коммит произвёл Trond Myklebust
Родитель a246b0105b
Коммит 9903cd1c27
3 изменённых файлов: 312 добавлений и 302 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

1
include/linux/sunrpc/debug.h
Просмотреть файл

@ -32,6 +32,7 @@
#define RPCDBG_AUTH 0x0010
#define RPCDBG_PMAP 0x0020
#define RPCDBG_SCHED 0x0040
#define RPCDBG_TRANS 0x0080
#define RPCDBG_SVCSOCK 0x0100
#define RPCDBG_SVCDSP 0x0200
#define RPCDBG_MISC 0x0400

147
net/sunrpc/xprt.c
Просмотреть файл

@ -227,9 +227,6 @@ xprt_adjust_cwnd(struct rpc_xprt *xprt, int result)
xprt->cwnd = cwnd;
}
/*
* Reset the major timeout value
*/
static void xprt_reset_majortimeo(struct rpc_rqst *req)
{
struct rpc_timeout *to = &req->rq_xprt->timeout;
@ -244,8 +241,10 @@ static void xprt_reset_majortimeo(struct rpc_rqst *req)
req->rq_majortimeo += jiffies;
}
/*
* Adjust timeout values etc for next retransmit
/**
* xprt_adjust_timeout - adjust timeout values for next retransmit
* @req: RPC request containing parameters to use for the adjustment
*
*/
int xprt_adjust_timeout(struct rpc_rqst *req)
{
@ -291,8 +290,10 @@ xprt_socket_autoclose(void *args)
xprt_release_write(xprt, NULL);
}
/*
* Mark a transport as disconnected
/**
* xprt_disconnect - mark a transport as disconnected
* @xprt: transport to flag for disconnect
*
*/
void xprt_disconnect(struct rpc_xprt *xprt)
{
@ -303,9 +304,6 @@ void xprt_disconnect(struct rpc_xprt *xprt)
spin_unlock_bh(&xprt->sock_lock);
}
/*
* Used to allow disconnection when we've been idle
*/
static void
xprt_init_autodisconnect(unsigned long data)
{
@ -327,8 +325,9 @@ out_abort:
spin_unlock(&xprt->sock_lock);
}
/*
* Attempt to connect a TCP socket.
/**
* xprt_connect - schedule a transport connect operation
* @task: RPC task that is requesting the connect
*
*/
void xprt_connect(struct rpc_task *task)
@ -361,11 +360,7 @@ void xprt_connect(struct rpc_task *task)
return;
}
/*
* We arrive here when awoken from waiting on connection establishment.
*/
static void
xprt_connect_status(struct rpc_task *task)
static void xprt_connect_status(struct rpc_task *task)
{
struct rpc_xprt *xprt = task->tk_xprt;
@ -404,8 +399,11 @@ xprt_connect_status(struct rpc_task *task)
}
}
/*
* Look up the RPC request corresponding to a reply, and then lock it.
/**
* xprt_lookup_rqst - find an RPC request corresponding to an XID
* @xprt: transport on which the original request was transmitted
* @xid: RPC XID of incoming reply
*
*/
struct rpc_rqst *xprt_lookup_rqst(struct rpc_xprt *xprt, u32 xid)
{
@ -422,9 +420,12 @@ struct rpc_rqst *xprt_lookup_rqst(struct rpc_xprt *xprt, u32 xid)
return req;
}
/*
* Complete reply received.
* The TCP code relies on us to remove the request from xprt->pending.
/**
* xprt_complete_rqst - called when reply processing is complete
* @xprt: controlling transport
* @req: RPC request that just completed
* @copied: actual number of bytes received from the transport
*
*/
void xprt_complete_rqst(struct rpc_xprt *xprt, struct rpc_rqst *req, int copied)
{
@ -498,12 +499,12 @@ out:
spin_unlock(&xprt->sock_lock);
}
/*
* Place the actual RPC call.
* We have to copy the iovec because sendmsg fiddles with its contents.
/**
* xprt_prepare_transmit - reserve the transport before sending a request
* @task: RPC task about to send a request
*
*/
int
xprt_prepare_transmit(struct rpc_task *task)
int xprt_prepare_transmit(struct rpc_task *task)
{
struct rpc_rqst *req = task->tk_rqstp;
struct rpc_xprt *xprt = req->rq_xprt;
@ -533,8 +534,13 @@ out_unlock:
return err;
}
void
xprt_transmit(struct rpc_task *task)
/**
* xprt_transmit - send an RPC request on a transport
* @task: controlling RPC task
*
* We have to copy the iovec because sendmsg fiddles with its contents.
*/
void xprt_transmit(struct rpc_task *task)
{
struct rpc_clnt *clnt = task->tk_client;
struct rpc_rqst *req = task->tk_rqstp;
@ -604,11 +610,7 @@ xprt_transmit(struct rpc_task *task)
spin_unlock_bh(&xprt->sock_lock);
}
/*
* Reserve an RPC call slot.
*/
static inline void
do_xprt_reserve(struct rpc_task *task)
static inline void do_xprt_reserve(struct rpc_task *task)
{
struct rpc_xprt *xprt = task->tk_xprt;
@ -628,8 +630,14 @@ do_xprt_reserve(struct rpc_task *task)
rpc_sleep_on(&xprt->backlog, task, NULL, NULL);
}
void
xprt_reserve(struct rpc_task *task)
/**
* xprt_reserve - allocate an RPC request slot
* @task: RPC task requesting a slot allocation
*
* If no more slots are available, place the task on the transport's
* backlog queue.
*/
void xprt_reserve(struct rpc_task *task)
{
struct rpc_xprt *xprt = task->tk_xprt;
@ -641,9 +649,6 @@ xprt_reserve(struct rpc_task *task)
}
}
/*
* Allocate a 'unique' XID
*/
static inline u32 xprt_alloc_xid(struct rpc_xprt *xprt)
{
return xprt->xid++;
@ -654,11 +659,7 @@ static inline void xprt_init_xid(struct rpc_xprt *xprt)
get_random_bytes(&xprt->xid, sizeof(xprt->xid));
}
/*
* Initialize RPC request
*/
static void
xprt_request_init(struct rpc_task *task, struct rpc_xprt *xprt)
static void xprt_request_init(struct rpc_task *task, struct rpc_xprt *xprt)
{
struct rpc_rqst *req = task->tk_rqstp;
@ -670,11 +671,12 @@ xprt_request_init(struct rpc_task *task, struct rpc_xprt *xprt)
req, ntohl(req->rq_xid));
}
/*
* Release an RPC call slot
/**
* xprt_release - release an RPC request slot
* @task: task which is finished with the slot
*
*/
void
xprt_release(struct rpc_task *task)
void xprt_release(struct rpc_task *task)
{
struct rpc_xprt *xprt = task->tk_xprt;
struct rpc_rqst *req;
@ -702,11 +704,14 @@ xprt_release(struct rpc_task *task)
spin_unlock(&xprt->xprt_lock);
}
/*
* Set constant timeout
/**
* xprt_set_timeout - set constant RPC timeout
* @to: RPC timeout parameters to set up
* @retr: number of retries
* @incr: amount of increase after each retry
*
*/
void
xprt_set_timeout(struct rpc_timeout *to, unsigned int retr, unsigned long incr)
void xprt_set_timeout(struct rpc_timeout *to, unsigned int retr, unsigned long incr)
{
to->to_initval =
to->to_increment = incr;
@ -715,11 +720,7 @@ xprt_set_timeout(struct rpc_timeout *to, unsigned int retr, unsigned long incr)
to->to_exponential = 0;
}
/*
* Initialize an RPC client
*/
static struct rpc_xprt *
xprt_setup(int proto, struct sockaddr_in *ap, struct rpc_timeout *to)
static struct rpc_xprt *xprt_setup(int proto, struct sockaddr_in *ap, struct rpc_timeout *to)
{
int result;
struct rpc_xprt *xprt;
@ -778,11 +779,14 @@ xprt_setup(int proto, struct sockaddr_in *ap, struct rpc_timeout *to)
return xprt;
}
/*
* Create an RPC client transport given the protocol and peer address.
/**
* xprt_create_proto - create an RPC client transport
* @proto: requested transport protocol
* @sap: remote peer's address
* @to: timeout parameters for new transport
*
*/
struct rpc_xprt *
xprt_create_proto(int proto, struct sockaddr_in *sap, struct rpc_timeout *to)
struct rpc_xprt *xprt_create_proto(int proto, struct sockaddr_in *sap, struct rpc_timeout *to)
{
struct rpc_xprt *xprt;
@ -794,11 +798,7 @@ xprt_create_proto(int proto, struct sockaddr_in *sap, struct rpc_timeout *to)
return xprt;
}
/*
* Prepare for transport shutdown.
*/
static void
xprt_shutdown(struct rpc_xprt *xprt)
static void xprt_shutdown(struct rpc_xprt *xprt)
{
xprt->shutdown = 1;
rpc_wake_up(&xprt->sending);
@ -809,21 +809,18 @@ xprt_shutdown(struct rpc_xprt *xprt)
del_timer_sync(&xprt->timer);
}
/*
* Clear the xprt backlog queue
*/
static int
xprt_clear_backlog(struct rpc_xprt *xprt) {
static int xprt_clear_backlog(struct rpc_xprt *xprt) {
rpc_wake_up_next(&xprt->backlog);
wake_up(&xprt->cong_wait);
return 1;
}
/*
* Destroy an RPC transport, killing off all requests.
/**
* xprt_destroy - destroy an RPC transport, killing off all requests.
* @xprt: transport to destroy
*
*/
int
xprt_destroy(struct rpc_xprt *xprt)
int xprt_destroy(struct rpc_xprt *xprt)
{
dprintk("RPC: destroying transport %p\n", xprt);
xprt_shutdown(xprt);

466
net/sunrpc/xprtsock.c
Просмотреть файл

@ -33,23 +33,21 @@
#include <net/udp.h>
#include <net/tcp.h>
/*
* Maximum port number to use when requesting a reserved port.
*/
#define XS_MAX_RESVPORT (800U)
#ifdef RPC_DEBUG
# undef RPC_DEBUG_DATA
# define RPCDBG_FACILITY RPCDBG_XPRT
# define RPCDBG_FACILITY RPCDBG_TRANS
#endif
#define XPRT_MAX_RESVPORT (800)
#ifdef RPC_DEBUG_DATA
/*
* Print the buffer contents (first 128 bytes only--just enough for
* diropres return).
*/
static void
xprt_pktdump(char *msg, u32 *packet, unsigned int count)
static void xs_pktdump(char *msg, u32 *packet, unsigned int count)
{
u8 *buf = (u8 *) packet;
int j;
u8 *buf = (u8 *) packet;
int j;
dprintk("RPC: %s\n", msg);
for (j = 0; j < count && j < 128; j += 4) {
@ -64,25 +62,22 @@ xprt_pktdump(char *msg, u32 *packet, unsigned int count)
dprintk("\n");
}
#else
static inline void
xprt_pktdump(char *msg, u32 *packet, unsigned int count)
static inline void xs_pktdump(char *msg, u32 *packet, unsigned int count)
{
/* NOP */
}
#endif
/*
* Look up RPC transport given an INET socket
/**
* xs_sendpages - write pages directly to a socket
* @sock: socket to send on
* @addr: UDP only -- address of destination
* @addrlen: UDP only -- length of destination address
* @xdr: buffer containing this request
* @base: starting position in the buffer
*
*/
static inline struct rpc_xprt *
xprt_from_sock(struct sock *sk)
{
return (struct rpc_xprt *) sk->sk_user_data;
}
static int
xdr_sendpages(struct socket *sock, struct sockaddr *addr, int addrlen,
struct xdr_buf *xdr, unsigned int base, int msgflags)
static int xs_sendpages(struct socket *sock, struct sockaddr *addr, int addrlen, struct xdr_buf *xdr, unsigned int base, int msgflags)
{
struct page **ppage = xdr->pages;
unsigned int len, pglen = xdr->page_len;
@ -125,7 +120,7 @@ xdr_sendpages(struct socket *sock, struct sockaddr *addr, int addrlen,
}
if (base || xdr->page_base) {
pglen -= base;
base += xdr->page_base;
base += xdr->page_base;
ppage += base >> PAGE_CACHE_SHIFT;
base &= ~PAGE_CACHE_MASK;
}
@ -176,23 +171,25 @@ out:
return ret;
}
/*
* Write data to socket.
/**
* xs_sendmsg - write an RPC request to a socket
* @xprt: generic transport
* @req: the RPC request to write
*
*/
static inline int
xprt_sendmsg(struct rpc_xprt *xprt, struct rpc_rqst *req)
static int xs_sendmsg(struct rpc_xprt *xprt, struct rpc_rqst *req)
{
struct socket *sock = xprt->sock;
struct xdr_buf *xdr = &req->rq_snd_buf;
struct socket *sock = xprt->sock;
struct xdr_buf *xdr = &req->rq_snd_buf;
struct sockaddr *addr = NULL;
int addrlen = 0;
unsigned int skip;
int result;
unsigned int skip;
int result;
if (!sock)
return -ENOTCONN;
xprt_pktdump("packet data:",
xs_pktdump("packet data:",
req->rq_svec->iov_base,
req->rq_svec->iov_len);
@ -201,13 +198,13 @@ xprt_sendmsg(struct rpc_xprt *xprt, struct rpc_rqst *req)
addr = (struct sockaddr *) &xprt->addr;
addrlen = sizeof(xprt->addr);
}
/* Dont repeat bytes */
/* Don't repeat bytes */
skip = req->rq_bytes_sent;
clear_bit(SOCK_ASYNC_NOSPACE, &sock->flags);
result = xdr_sendpages(sock, addr, addrlen, xdr, skip, MSG_DONTWAIT);
result = xs_sendpages(sock, addr, addrlen, xdr, skip, MSG_DONTWAIT);
dprintk("RPC: xprt_sendmsg(%d) = %d\n", xdr->len - skip, result);
dprintk("RPC: xs_sendmsg(%d) = %d\n", xdr->len - skip, result);
if (result >= 0)
return result;
@ -215,8 +212,7 @@ xprt_sendmsg(struct rpc_xprt *xprt, struct rpc_rqst *req)
switch (result) {
case -ECONNREFUSED:
/* When the server has died, an ICMP port unreachable message
* prompts ECONNREFUSED.
*/
* prompts ECONNREFUSED. */
case -EAGAIN:
break;
case -ECONNRESET:
@ -227,13 +223,25 @@ xprt_sendmsg(struct rpc_xprt *xprt, struct rpc_rqst *req)
result = -ENOTCONN;
break;
default:
printk(KERN_NOTICE "RPC: sendmsg returned error %d\n", -result);
break;
}
return result;
}
static int
xprt_send_request(struct rpc_task *task)
/**
* xs_send_request - write an RPC request to a socket
* @task: address of RPC task that manages the state of an RPC request
*
* Return values:
* 0: The request has been sent
* EAGAIN: The socket was blocked, please call again later to
* complete the request
* other: Some other error occured, the request was not sent
*
* XXX: In the case of soft timeouts, should we eventually give up
* if the socket is not able to make progress?
*/
static int xs_send_request(struct rpc_task *task)
{
struct rpc_rqst *req = task->tk_rqstp;
struct rpc_xprt *xprt = req->rq_xprt;
@ -242,18 +250,18 @@ xprt_send_request(struct rpc_task *task)
/* set up everything as needed. */
/* Write the record marker */
if (xprt->stream) {
u32 *marker = req->rq_svec[0].iov_base;
u32 *marker = req->rq_svec[0].iov_base;
*marker = htonl(0x80000000|(req->rq_slen-sizeof(*marker)));
}
/* Continue transmitting the packet/record. We must be careful
* to cope with writespace callbacks arriving _after_ we have
* called xprt_sendmsg().
* called sendmsg().
*/
while (1) {
req->rq_xtime = jiffies;
status = xprt_sendmsg(xprt, req);
status = xs_sendmsg(xprt, req);
if (status < 0)
break;
@ -285,7 +293,7 @@ xprt_send_request(struct rpc_task *task)
if (status == -EAGAIN) {
if (test_bit(SOCK_ASYNC_NOSPACE, &xprt->sock->flags)) {
/* Protect against races with xprt_write_space */
/* Protect against races with xs_write_space */
spin_lock_bh(&xprt->sock_lock);
/* Don't race with disconnect */
if (!xprt_connected(xprt))
@ -303,65 +311,77 @@ xprt_send_request(struct rpc_task *task)
return status;
}
/*
* Close down a transport socket
/**
* xs_close - close a socket
* @xprt: transport
*
*/
static void
xprt_close(struct rpc_xprt *xprt)
static void xs_close(struct rpc_xprt *xprt)
{
struct socket *sock = xprt->sock;
struct sock *sk = xprt->inet;
struct socket *sock = xprt->sock;
struct sock *sk = xprt->inet;
if (!sk)
return;
dprintk("RPC: xs_close xprt %p\n", xprt);
write_lock_bh(&sk->sk_callback_lock);
xprt->inet = NULL;
xprt->sock = NULL;
sk->sk_user_data = NULL;
sk->sk_data_ready = xprt->old_data_ready;
sk->sk_user_data = NULL;
sk->sk_data_ready = xprt->old_data_ready;
sk->sk_state_change = xprt->old_state_change;
sk->sk_write_space = xprt->old_write_space;
sk->sk_write_space = xprt->old_write_space;
write_unlock_bh(&sk->sk_callback_lock);
sk->sk_no_check = 0;
sk->sk_no_check = 0;
sock_release(sock);
}
static void xprt_socket_destroy(struct rpc_xprt *xprt)
/**
* xs_destroy - prepare to shutdown a transport
* @xprt: doomed transport
*
*/
static void xs_destroy(struct rpc_xprt *xprt)
{
dprintk("RPC: xs_destroy xprt %p\n", xprt);
cancel_delayed_work(&xprt->sock_connect);
flush_scheduled_work();
xprt_disconnect(xprt);
xprt_close(xprt);
xs_close(xprt);
kfree(xprt->slot);
}
/*
* Input handler for RPC replies. Called from a bottom half and hence
* atomic.
*/
static void
udp_data_ready(struct sock *sk, int len)
static inline struct rpc_xprt *xprt_from_sock(struct sock *sk)
{
struct rpc_task *task;
struct rpc_xprt *xprt;
return (struct rpc_xprt *) sk->sk_user_data;
}
/**
* xs_udp_data_ready - "data ready" callback for UDP sockets
* @sk: socket with data to read
* @len: how much data to read
*
*/
static void xs_udp_data_ready(struct sock *sk, int len)
{
struct rpc_task *task;
struct rpc_xprt *xprt;
struct rpc_rqst *rovr;
struct sk_buff *skb;
struct sk_buff *skb;
int err, repsize, copied;
u32 _xid, *xp;
read_lock(&sk->sk_callback_lock);
dprintk("RPC: udp_data_ready...\n");
if (!(xprt = xprt_from_sock(sk))) {
printk("RPC: udp_data_ready request not found!\n");
dprintk("RPC: xs_udp_data_ready...\n");
if (!(xprt = xprt_from_sock(sk)))
goto out;
}
dprintk("RPC: udp_data_ready client %p\n", xprt);
if ((skb = skb_recv_datagram(sk, 0, 1, &err)) == NULL)
goto out;
@ -371,7 +391,7 @@ udp_data_ready(struct sock *sk, int len)
repsize = skb->len - sizeof(struct udphdr);
if (repsize < 4) {
printk("RPC: impossible RPC reply size %d!\n", repsize);
dprintk("RPC: impossible RPC reply size %d!\n", repsize);
goto dropit;
}
@ -410,11 +430,7 @@ udp_data_ready(struct sock *sk, int len)
read_unlock(&sk->sk_callback_lock);
}
/*
* Copy from an skb into memory and shrink the skb.
*/
static inline size_t
tcp_copy_data(skb_reader_t *desc, void *p, size_t len)
static inline size_t xs_tcp_copy_data(skb_reader_t *desc, void *p, size_t len)
{
if (len > desc->count)
len = desc->count;
@ -430,18 +446,14 @@ tcp_copy_data(skb_reader_t *desc, void *p, size_t len)
return len;
}
/*
* TCP read fragment marker
*/
static inline void
tcp_read_fraghdr(struct rpc_xprt *xprt, skb_reader_t *desc)
static inline void xs_tcp_read_fraghdr(struct rpc_xprt *xprt, skb_reader_t *desc)
{
size_t len, used;
char *p;
p = ((char *) &xprt->tcp_recm) + xprt->tcp_offset;
len = sizeof(xprt->tcp_recm) - xprt->tcp_offset;
used = tcp_copy_data(desc, p, len);
used = xs_tcp_copy_data(desc, p, len);
xprt->tcp_offset += used;
if (used != len)
return;
@ -455,15 +467,15 @@ tcp_read_fraghdr(struct rpc_xprt *xprt, skb_reader_t *desc)
xprt->tcp_offset = 0;
/* Sanity check of the record length */
if (xprt->tcp_reclen < 4) {
printk(KERN_ERR "RPC: Invalid TCP record fragment length\n");
dprintk("RPC: invalid TCP record fragment length\n");
xprt_disconnect(xprt);
return;
}
dprintk("RPC: reading TCP record fragment of length %d\n",
xprt->tcp_reclen);
}
static void
tcp_check_recm(struct rpc_xprt *xprt)
static void xs_tcp_check_recm(struct rpc_xprt *xprt)
{
dprintk("RPC: xprt = %p, tcp_copied = %lu, tcp_offset = %u, tcp_reclen = %u, tcp_flags = %lx\n",
xprt, xprt->tcp_copied, xprt->tcp_offset, xprt->tcp_reclen, xprt->tcp_flags);
@ -478,11 +490,7 @@ tcp_check_recm(struct rpc_xprt *xprt)
}
}
/*
* TCP read xid
*/
static inline void
tcp_read_xid(struct rpc_xprt *xprt, skb_reader_t *desc)
static inline void xs_tcp_read_xid(struct rpc_xprt *xprt, skb_reader_t *desc)
{
size_t len, used;
char *p;
@ -490,7 +498,7 @@ tcp_read_xid(struct rpc_xprt *xprt, skb_reader_t *desc)
len = sizeof(xprt->tcp_xid) - xprt->tcp_offset;
dprintk("RPC: reading XID (%Zu bytes)\n", len);
p = ((char *) &xprt->tcp_xid) + xprt->tcp_offset;
used = tcp_copy_data(desc, p, len);
used = xs_tcp_copy_data(desc, p, len);
xprt->tcp_offset += used;
if (used != len)
return;
@ -499,14 +507,10 @@ tcp_read_xid(struct rpc_xprt *xprt, skb_reader_t *desc)
xprt->tcp_copied = 4;
dprintk("RPC: reading reply for XID %08x\n",
ntohl(xprt->tcp_xid));
tcp_check_recm(xprt);
xs_tcp_check_recm(xprt);
}
/*
* TCP read and complete request
*/
static inline void
tcp_read_request(struct rpc_xprt *xprt, skb_reader_t *desc)
static inline void xs_tcp_read_request(struct rpc_xprt *xprt, skb_reader_t *desc)
{
struct rpc_rqst *req;
struct xdr_buf *rcvbuf;
@ -533,12 +537,12 @@ tcp_read_request(struct rpc_xprt *xprt, skb_reader_t *desc)
memcpy(&my_desc, desc, sizeof(my_desc));
my_desc.count = len;
r = xdr_partial_copy_from_skb(rcvbuf, xprt->tcp_copied,
&my_desc, tcp_copy_data);
&my_desc, xs_tcp_copy_data);
desc->count -= r;
desc->offset += r;
} else
r = xdr_partial_copy_from_skb(rcvbuf, xprt->tcp_copied,
desc, tcp_copy_data);
desc, xs_tcp_copy_data);
if (r > 0) {
xprt->tcp_copied += r;
@ -581,14 +585,10 @@ out:
xprt_complete_rqst(xprt, req, xprt->tcp_copied);
}
spin_unlock(&xprt->sock_lock);
tcp_check_recm(xprt);
xs_tcp_check_recm(xprt);
}
/*
* TCP discard extra bytes from a short read
*/
static inline void
tcp_read_discard(struct rpc_xprt *xprt, skb_reader_t *desc)
static inline void xs_tcp_read_discard(struct rpc_xprt *xprt, skb_reader_t *desc)
{
size_t len;
@ -599,16 +599,10 @@ tcp_read_discard(struct rpc_xprt *xprt, skb_reader_t *desc)
desc->offset += len;
xprt->tcp_offset += len;
dprintk("RPC: discarded %Zu bytes\n", len);
tcp_check_recm(xprt);
xs_tcp_check_recm(xprt);
}
/*
* TCP record receive routine
* We first have to grab the record marker, then the XID, then the data.
*/
static int
tcp_data_recv(read_descriptor_t *rd_desc, struct sk_buff *skb,
unsigned int offset, size_t len)
static int xs_tcp_data_recv(read_descriptor_t *rd_desc, struct sk_buff *skb, unsigned int offset, size_t len)
{
struct rpc_xprt *xprt = rd_desc->arg.data;
skb_reader_t desc = {
@ -616,64 +610,72 @@ tcp_data_recv(read_descriptor_t *rd_desc, struct sk_buff *skb,
.offset = offset,
.count = len,
.csum = 0
};
};
dprintk("RPC: tcp_data_recv\n");
dprintk("RPC: xs_tcp_data_recv started\n");
do {
/* Read in a new fragment marker if necessary */
/* Can we ever really expect to get completely empty fragments? */
if (xprt->tcp_flags & XPRT_COPY_RECM) {
tcp_read_fraghdr(xprt, &desc);
xs_tcp_read_fraghdr(xprt, &desc);
continue;
}
/* Read in the xid if necessary */
if (xprt->tcp_flags & XPRT_COPY_XID) {
tcp_read_xid(xprt, &desc);
xs_tcp_read_xid(xprt, &desc);
continue;
}
/* Read in the request data */
if (xprt->tcp_flags & XPRT_COPY_DATA) {
tcp_read_request(xprt, &desc);
xs_tcp_read_request(xprt, &desc);
continue;
}
/* Skip over any trailing bytes on short reads */
tcp_read_discard(xprt, &desc);
xs_tcp_read_discard(xprt, &desc);
} while (desc.count);
dprintk("RPC: tcp_data_recv done\n");
dprintk("RPC: xs_tcp_data_recv done\n");
return len - desc.count;
}
static void tcp_data_ready(struct sock *sk, int bytes)
/**
* xs_tcp_data_ready - "data ready" callback for TCP sockets
* @sk: socket with data to read
* @bytes: how much data to read
*
*/
static void xs_tcp_data_ready(struct sock *sk, int bytes)
{
struct rpc_xprt *xprt;
read_descriptor_t rd_desc;
read_lock(&sk->sk_callback_lock);
dprintk("RPC: tcp_data_ready...\n");
if (!(xprt = xprt_from_sock(sk))) {
printk("RPC: tcp_data_ready socket info not found!\n");
dprintk("RPC: xs_tcp_data_ready...\n");
if (!(xprt = xprt_from_sock(sk)))
goto out;
}
if (xprt->shutdown)
goto out;
/* We use rd_desc to pass struct xprt to tcp_data_recv */
/* We use rd_desc to pass struct xprt to xs_tcp_data_recv */
rd_desc.arg.data = xprt;
rd_desc.count = 65536;
tcp_read_sock(sk, &rd_desc, tcp_data_recv);
tcp_read_sock(sk, &rd_desc, xs_tcp_data_recv);
out:
read_unlock(&sk->sk_callback_lock);
}
static void
tcp_state_change(struct sock *sk)
/**
* xs_tcp_state_change - callback to handle TCP socket state changes
* @sk: socket whose state has changed
*
*/
static void xs_tcp_state_change(struct sock *sk)
{
struct rpc_xprt *xprt;
struct rpc_xprt *xprt;
read_lock(&sk->sk_callback_lock);
if (!(xprt = xprt_from_sock(sk)))
goto out;
dprintk("RPC: tcp_state_change client %p...\n", xprt);
dprintk("RPC: xs_tcp_state_change client %p...\n", xprt);
dprintk("RPC: state %x conn %d dead %d zapped %d\n",
sk->sk_state, xprt_connected(xprt),
sock_flag(sk, SOCK_DEAD),
@ -703,17 +705,20 @@ tcp_state_change(struct sock *sk)
read_unlock(&sk->sk_callback_lock);
}
/*
/**
* xs_write_space - callback invoked when socket buffer space becomes
* available
* @sk: socket whose state has changed
*
* Called when more output buffer space is available for this socket.
* We try not to wake our writers until they can make "significant"
* progress, otherwise we'll waste resources thrashing sock_sendmsg
* with a bunch of small requests.
*/
static void
xprt_write_space(struct sock *sk)
static void xs_write_space(struct sock *sk)
{
struct rpc_xprt *xprt;
struct socket *sock;
struct rpc_xprt *xprt;
struct socket *sock;
read_lock(&sk->sk_callback_lock);
if (!(xprt = xprt_from_sock(sk)) || !(sock = sk->sk_socket))
@ -743,11 +748,15 @@ out:
read_unlock(&sk->sk_callback_lock);
}
/*
* Set socket buffer length
/**
* xs_set_buffer_size - set send and receive limits
* @xprt: generic transport
*
* Set socket send and receive limits based on the
* sndsize and rcvsize fields in the generic transport
* structure. This applies only to UDP sockets.
*/
static void
xprt_sock_setbufsize(struct rpc_xprt *xprt)
static void xs_set_buffer_size(struct rpc_xprt *xprt)
{
struct sock *sk = xprt->inet;
@ -764,15 +773,12 @@ xprt_sock_setbufsize(struct rpc_xprt *xprt)
}
}
/*
* Bind to a reserved port
*/
static inline int xprt_bindresvport(struct rpc_xprt *xprt, struct socket *sock)
static int xs_bindresvport(struct rpc_xprt *xprt, struct socket *sock)
{
struct sockaddr_in myaddr = {
.sin_family = AF_INET,
};
int err, port;
int err, port;
/* Were we already bound to a given port? Try to reuse it */
port = xprt->port;
@ -782,20 +788,47 @@ static inline int xprt_bindresvport(struct rpc_xprt *xprt, struct socket *sock)
sizeof(myaddr));
if (err == 0) {
xprt->port = port;
dprintk("RPC: xs_bindresvport bound to port %u\n",
port);
return 0;
}
if (--port == 0)
port = XPRT_MAX_RESVPORT;
port = XS_MAX_RESVPORT;
} while (err == -EADDRINUSE && port != xprt->port);
printk("RPC: Can't bind to reserved port (%d).\n", -err);
dprintk("RPC: can't bind to reserved port (%d).\n", -err);
return err;
}
static void
xprt_bind_socket(struct rpc_xprt *xprt, struct socket *sock)
static struct socket *xs_create(struct rpc_xprt *xprt, int proto, int resvport)
{
struct sock *sk = sock->sk;
struct socket *sock;
int type, err;
dprintk("RPC: xs_create(%s %d)\n",
(proto == IPPROTO_UDP)? "udp" : "tcp", proto);
type = (proto == IPPROTO_UDP)? SOCK_DGRAM : SOCK_STREAM;
if ((err = sock_create_kern(PF_INET, type, proto, &sock)) < 0) {
dprintk("RPC: can't create socket (%d).\n", -err);
return NULL;
}
/* If the caller has the capability, bind to a reserved port */
if (resvport && xs_bindresvport(xprt, sock) < 0)
goto failed;
return sock;
failed:
sock_release(sock);
return NULL;
}
static void xs_bind(struct rpc_xprt *xprt, struct socket *sock)
{
struct sock *sk = sock->sk;
if (xprt->inet)
return;
@ -806,16 +839,16 @@ xprt_bind_socket(struct rpc_xprt *xprt, struct socket *sock)
xprt->old_state_change = sk->sk_state_change;
xprt->old_write_space = sk->sk_write_space;
if (xprt->prot == IPPROTO_UDP) {
sk->sk_data_ready = udp_data_ready;
sk->sk_data_ready = xs_udp_data_ready;
sk->sk_no_check = UDP_CSUM_NORCV;
xprt_set_connected(xprt);
} else {
tcp_sk(sk)->nonagle = 1; /* disable Nagle's algorithm */
sk->sk_data_ready = tcp_data_ready;
sk->sk_state_change = tcp_state_change;
sk->sk_data_ready = xs_tcp_data_ready;
sk->sk_state_change = xs_tcp_state_change;
xprt_clear_connected(xprt);
}
sk->sk_write_space = xprt_write_space;
sk->sk_write_space = xs_write_space;
/* Reset to new socket */
xprt->sock = sock;
@ -825,39 +858,13 @@ xprt_bind_socket(struct rpc_xprt *xprt, struct socket *sock)
return;
}
/*
* Datastream sockets are created here, but xprt_connect will create
* and connect stream sockets.
/**
* xs_connect_worker - try to connect a socket to a remote endpoint
* @args: RPC transport to connect
*
* Invoked by a work queue tasklet.
*/
static struct socket * xprt_create_socket(struct rpc_xprt *xprt, int proto, int resvport)
{
struct socket *sock;
int type, err;
dprintk("RPC: xprt_create_socket(%s %d)\n",
(proto == IPPROTO_UDP)? "udp" : "tcp", proto);
type = (proto == IPPROTO_UDP)? SOCK_DGRAM : SOCK_STREAM;
if ((err = sock_create_kern(PF_INET, type, proto, &sock)) < 0) {
printk("RPC: can't create socket (%d).\n", -err);
return NULL;
}
/* If the caller has the capability, bind to a reserved port */
if (resvport && xprt_bindresvport(xprt, sock) < 0) {
printk("RPC: can't bind to reserved port.\n");
goto failed;
}
return sock;
failed:
sock_release(sock);
return NULL;
}
static void xprt_socket_connect(void *args)
static void xs_connect_worker(void *args)
{
struct rpc_xprt *xprt = (struct rpc_xprt *)args;
struct socket *sock = xprt->sock;
@ -866,18 +873,20 @@ static void xprt_socket_connect(void *args)
if (xprt->shutdown || xprt->addr.sin_port == 0)
goto out;
dprintk("RPC: xs_connect_worker xprt %p\n", xprt);
/*
* Start by resetting any existing state
*/
xprt_close(xprt);
sock = xprt_create_socket(xprt, xprt->prot, xprt->resvport);
xs_close(xprt);
sock = xs_create(xprt, xprt->prot, xprt->resvport);
if (sock == NULL) {
/* couldn't create socket or bind to reserved port;
* this is likely a permanent error, so cause an abort */
goto out;
}
xprt_bind_socket(xprt, sock);
xprt_sock_setbufsize(xprt);
xs_bind(xprt, sock);
xs_set_buffer_size(xprt);
status = 0;
if (!xprt->stream)
@ -908,20 +917,23 @@ out_clear:
smp_mb__after_clear_bit();
}
static void
xprt_connect_sock(struct rpc_task *task)
/**
* xs_connect - connect a socket to a remote endpoint
* @task: address of RPC task that manages state of connect request
*
* TCP: If the remote end dropped the connection, delay reconnecting.
*/
static void xs_connect(struct rpc_task *task)
{
struct rpc_xprt *xprt = task->tk_xprt;
if (!test_and_set_bit(XPRT_CONNECTING, &xprt->sockstate)) {
/* Note: if we are here due to a dropped connection
* we delay reconnecting by RPC_REESTABLISH_TIMEOUT/HZ
* seconds
*/
if (xprt->sock != NULL)
if (xprt->sock != NULL) {
dprintk("RPC: xs_connect delayed xprt %p\n", xprt);
schedule_delayed_work(&xprt->sock_connect,
RPC_REESTABLISH_TIMEOUT);
else {
} else {
dprintk("RPC: xs_connect scheduled xprt %p\n", xprt);
schedule_work(&xprt->sock_connect);
/* flush_scheduled_work can sleep... */
if (!RPC_IS_ASYNC(task))
@ -930,29 +942,23 @@ xprt_connect_sock(struct rpc_task *task)
}
}
/*
* Set default timeout parameters
*/
static void
xprt_default_timeout(struct rpc_timeout *to, int proto)
{
if (proto == IPPROTO_UDP)
xprt_set_timeout(to, 5, 5 * HZ);
else
xprt_set_timeout(to, 2, 60 * HZ);
}
static struct rpc_xprt_ops xprt_socket_ops = {
.set_buffer_size = xprt_sock_setbufsize,
.connect = xprt_connect_sock,
.send_request = xprt_send_request,
.close = xprt_close,
.destroy = xprt_socket_destroy,
static struct rpc_xprt_ops xs_ops = {
.set_buffer_size = xs_set_buffer_size,
.connect = xs_connect,
.send_request = xs_send_request,
.close = xs_close,
.destroy = xs_destroy,
};
extern unsigned int xprt_udp_slot_table_entries;
extern unsigned int xprt_tcp_slot_table_entries;
/**
* xs_setup_udp - Set up transport to use a UDP socket
* @xprt: transport to set up
* @to: timeout parameters
*
*/
int xs_setup_udp(struct rpc_xprt *xprt, struct rpc_timeout *to)
{
size_t slot_table_size;
@ -967,7 +973,7 @@ int xs_setup_udp(struct rpc_xprt *xprt, struct rpc_timeout *to)
memset(xprt->slot, 0, slot_table_size);
xprt->prot = IPPROTO_UDP;
xprt->port = XPRT_MAX_RESVPORT;
xprt->port = XS_MAX_RESVPORT;
xprt->stream = 0;
xprt->nocong = 0;
xprt->cwnd = RPC_INITCWND;
@ -975,18 +981,24 @@ int xs_setup_udp(struct rpc_xprt *xprt, struct rpc_timeout *to)
/* XXX: header size can vary due to auth type, IPv6, etc. */
xprt->max_payload = (1U << 16) - (MAX_HEADER << 3);
INIT_WORK(&xprt->sock_connect, xprt_socket_connect, xprt);
INIT_WORK(&xprt->sock_connect, xs_connect_worker, xprt);
xprt->ops = &xprt_socket_ops;
xprt->ops = &xs_ops;
if (to)
xprt->timeout = *to;
else
xprt_default_timeout(to, xprt->prot);
xprt_set_timeout(&xprt->timeout, 5, 5 * HZ);
return 0;
}
/**
* xs_setup_tcp - Set up transport to use a TCP socket
* @xprt: transport to set up
* @to: timeout parameters
*
*/
int xs_setup_tcp(struct rpc_xprt *xprt, struct rpc_timeout *to)
{
size_t slot_table_size;
@ -1001,21 +1013,21 @@ int xs_setup_tcp(struct rpc_xprt *xprt, struct rpc_timeout *to)
memset(xprt->slot, 0, slot_table_size);
xprt->prot = IPPROTO_TCP;
xprt->port = XPRT_MAX_RESVPORT;
xprt->port = XS_MAX_RESVPORT;
xprt->stream = 1;
xprt->nocong = 1;
xprt->cwnd = RPC_MAXCWND(xprt);
xprt->resvport = capable(CAP_NET_BIND_SERVICE) ? 1 : 0;
xprt->max_payload = (1U << 31) - 1;
INIT_WORK(&xprt->sock_connect, xprt_socket_connect, xprt);
INIT_WORK(&xprt->sock_connect, xs_connect_worker, xprt);
xprt->ops = &xprt_socket_ops;
xprt->ops = &xs_ops;
if (to)
xprt->timeout = *to;
else
xprt_default_timeout(to, xprt->prot);
xprt_set_timeout(&xprt->timeout, 2, 60 * HZ);
return 0;
}