cregit-Linux how code gets into the kernel

Release 4.8 net/sunrpc/xprt.c

Directory: net/sunrpc
/*
 *  linux/net/sunrpc/xprt.c
 *
 *  This is a generic RPC call interface supporting congestion avoidance,
 *  and asynchronous calls.
 *
 *  The interface works like this:
 *
 *  -   When a process places a call, it allocates a request slot if
 *      one is available. Otherwise, it sleeps on the backlog queue
 *      (xprt_reserve).
 *  -   Next, the caller puts together the RPC message, stuffs it into
 *      the request struct, and calls xprt_transmit().
 *  -   xprt_transmit sends the message and installs the caller on the
 *      transport's wait list. At the same time, if a reply is expected,
 *      it installs a timer that is run after the packet's timeout has
 *      expired.
 *  -   When a packet arrives, the data_ready handler walks the list of
 *      pending requests for that transport. If a matching XID is found, the
 *      caller is woken up, and the timer removed.
 *  -   When no reply arrives within the timeout interval, the timer is
 *      fired by the kernel and runs xprt_timer(). It either adjusts the
 *      timeout values (minor timeout) or wakes up the caller with a status
 *      of -ETIMEDOUT.
 *  -   When the caller receives a notification from RPC that a reply arrived,
 *      it should release the RPC slot, and process the reply.
 *      If the call timed out, it may choose to retry the operation by
 *      adjusting the initial timeout value, and simply calling rpc_call
 *      again.
 *
 *  Support for async RPC is done through a set of RPC-specific scheduling
 *  primitives that `transparently' work for processes as well as async
 *  tasks that rely on callbacks.
 *
 *  Copyright (C) 1995-1997, Olaf Kirch <okir@monad.swb.de>
 *
 *  Transport switch API copyright (C) 2005, Chuck Lever <cel@netapp.com>
 */

#include <linux/module.h>

#include <linux/types.h>
#include <linux/interrupt.h>
#include <linux/workqueue.h>
#include <linux/net.h>
#include <linux/ktime.h>

#include <linux/sunrpc/clnt.h>
#include <linux/sunrpc/metrics.h>
#include <linux/sunrpc/bc_xprt.h>
#include <linux/rcupdate.h>

#include <trace/events/sunrpc.h>

#include "sunrpc.h"

/*
 * Local variables
 */

#if IS_ENABLED(CONFIG_SUNRPC_DEBUG)

# define RPCDBG_FACILITY	RPCDBG_XPRT
#endif

/*
 * Local functions
 */
static void	 xprt_init(struct rpc_xprt *xprt, struct net *net);
static void	xprt_request_init(struct rpc_task *, struct rpc_xprt *);
static void	xprt_connect_status(struct rpc_task *task);
static int      __xprt_get_cong(struct rpc_xprt *, struct rpc_task *);
static void     __xprt_put_cong(struct rpc_xprt *, struct rpc_rqst *);
static void	 xprt_destroy(struct rpc_xprt *xprt);

static DEFINE_SPINLOCK(xprt_list_lock);
static LIST_HEAD(xprt_list);

/**
 * xprt_register_transport - register a transport implementation
 * @transport: transport to register
 *
 * If a transport implementation is loaded as a kernel module, it can
 * call this interface to make itself known to the RPC client.
 *
 * Returns:
 * 0:           transport successfully registered
 * -EEXIST:     transport already registered
 * -EINVAL:     transport module being unloaded
 */

int xprt_register_transport(struct xprt_class *transport) { struct xprt_class *t; int result; result = -EEXIST; spin_lock(&xprt_list_lock); list_for_each_entry(t, &xprt_list, list) { /* don't register the same transport class twice */ if (t->ident == transport->ident) goto out; } list_add_tail(&transport->list, &xprt_list); printk(KERN_INFO "RPC: Registered %s transport module.\n", transport->name); result = 0; out: spin_unlock(&xprt_list_lock); return result; }

Contributors

PersonTokensPropCommitsCommitProp
thomas talpeythomas talpey89100.00%2100.00%
Total89100.00%2100.00%

EXPORT_SYMBOL_GPL(xprt_register_transport); /** * xprt_unregister_transport - unregister a transport implementation * @transport: transport to unregister * * Returns: * 0: transport successfully unregistered * -ENOENT: transport never registered */
int xprt_unregister_transport(struct xprt_class *transport) { struct xprt_class *t; int result; result = 0; spin_lock(&xprt_list_lock); list_for_each_entry(t, &xprt_list, list) { if (t == transport) { printk(KERN_INFO "RPC: Unregistered %s transport module.\n", transport->name); list_del_init(&transport->list); goto out; } } result = -ENOENT; out: spin_unlock(&xprt_list_lock); return result; }

Contributors

PersonTokensPropCommitsCommitProp
thomas talpeythomas talpey83100.00%1100.00%
Total83100.00%1100.00%

EXPORT_SYMBOL_GPL(xprt_unregister_transport); /** * xprt_load_transport - load a transport implementation * @transport_name: transport to load * * Returns: * 0: transport successfully loaded * -ENOENT: transport module not available */
int xprt_load_transport(const char *transport_name) { struct xprt_class *t; int result; result = 0; spin_lock(&xprt_list_lock); list_for_each_entry(t, &xprt_list, list) { if (strcmp(t->name, transport_name) == 0) { spin_unlock(&xprt_list_lock); goto out; } } spin_unlock(&xprt_list_lock); result = request_module("xprt%s", transport_name); out: return result; }

Contributors

PersonTokensPropCommitsCommitProp
tom talpeytom talpey7996.34%150.00%
alex riesenalex riesen33.66%150.00%
Total82100.00%2100.00%

EXPORT_SYMBOL_GPL(xprt_load_transport); /** * xprt_reserve_xprt - serialize write access to transports * @task: task that is requesting access to the transport * @xprt: pointer to the target transport * * This prevents mixing the payload of separate requests, and prevents * transport connects from colliding with writes. No congestion control * is provided. */
int xprt_reserve_xprt(struct rpc_xprt *xprt, struct rpc_task *task) { struct rpc_rqst *req = task->tk_rqstp; int priority; if (test_and_set_bit(XPRT_LOCKED, &xprt->state)) { if (task == xprt->snd_task) return 1; goto out_sleep; } xprt->snd_task = task; if (req != NULL) req->rq_ntrans++; return 1; out_sleep: dprintk("RPC: %5u failed to lock transport %p\n", task->tk_pid, xprt); task->tk_timeout = 0; task->tk_status = -EAGAIN; if (req == NULL) priority = RPC_PRIORITY_LOW; else if (!req->rq_ntrans) priority = RPC_PRIORITY_NORMAL; else priority = RPC_PRIORITY_HIGH; rpc_sleep_on_priority(&xprt->sending, task, NULL, priority); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
chuck leverchuck lever10471.72%342.86%
trond myklebusttrond myklebust3624.83%228.57%
rahul iyerrahul iyer32.07%114.29%
pre-gitpre-git21.38%114.29%
Total145100.00%7100.00%

EXPORT_SYMBOL_GPL(xprt_reserve_xprt);
static void xprt_clear_locked(struct rpc_xprt *xprt) { xprt->snd_task = NULL; if (!test_bit(XPRT_CLOSE_WAIT, &xprt->state)) { smp_mb__before_atomic(); clear_bit(XPRT_LOCKED, &xprt->state); smp_mb__after_atomic(); } else queue_work(xprtiod_workqueue, &xprt->task_cleanup); }

Contributors

PersonTokensPropCommitsCommitProp
trond myklebusttrond myklebust5796.61%375.00%
peter zijlstrapeter zijlstra23.39%125.00%
Total59100.00%4100.00%

/* * xprt_reserve_xprt_cong - serialize write access to transports * @task: task that is requesting access to the transport * * Same as xprt_reserve_xprt, but Van Jacobson congestion control is * integrated into the decision of whether a request is allowed to be * woken up and given access to the transport. */
int xprt_reserve_xprt_cong(struct rpc_xprt *xprt, struct rpc_task *task) { struct rpc_rqst *req = task->tk_rqstp; int priority; if (test_and_set_bit(XPRT_LOCKED, &xprt->state)) { if (task == xprt->snd_task) return 1; goto out_sleep; } if (req == NULL) { xprt->snd_task = task; return 1; } if (__xprt_get_cong(xprt, task)) { xprt->snd_task = task; req->rq_ntrans++; return 1; } xprt_clear_locked(xprt); out_sleep: if (req) __xprt_put_cong(xprt, req); dprintk("RPC: %5u failed to lock transport %p\n", task->tk_pid, xprt); task->tk_timeout = 0; task->tk_status = -EAGAIN; if (req == NULL) priority = RPC_PRIORITY_LOW; else if (!req->rq_ntrans) priority = RPC_PRIORITY_NORMAL; else priority = RPC_PRIORITY_HIGH; rpc_sleep_on_priority(&xprt->sending, task, NULL, priority); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
trond myklebusttrond myklebust6233.88%853.33%
chuck leverchuck lever6032.79%426.67%
linus torvaldslinus torvalds2614.21%16.67%
pre-gitpre-git2413.11%16.67%
neil brownneil brown116.01%16.67%
Total183100.00%15100.00%

EXPORT_SYMBOL_GPL(xprt_reserve_xprt_cong);
static inline int xprt_lock_write(struct rpc_xprt *xprt, struct rpc_task *task) { int retval; spin_lock_bh(&xprt->transport_lock); retval = xprt->ops->reserve_xprt(xprt, task); spin_unlock_bh(&xprt->transport_lock); return retval; }

Contributors

PersonTokensPropCommitsCommitProp
trond myklebusttrond myklebust3363.46%240.00%
linus torvaldslinus torvalds1223.08%120.00%
chuck leverchuck lever713.46%240.00%
Total52100.00%5100.00%


static bool __xprt_lock_write_func(struct rpc_task *task, void *data) { struct rpc_xprt *xprt = data; struct rpc_rqst *req; req = task->tk_rqstp; xprt->snd_task = task; if (req) req->rq_ntrans++; return true; }

Contributors

PersonTokensPropCommitsCommitProp
chuck leverchuck lever2752.94%125.00%
trond myklebusttrond myklebust1835.29%250.00%
linus torvaldslinus torvalds611.76%125.00%
Total51100.00%4100.00%


static void __xprt_lock_write_next(struct rpc_xprt *xprt) { if (test_and_set_bit(XPRT_LOCKED, &xprt->state)) return; if (rpc_wake_up_first_on_wq(xprtiod_workqueue, &xprt->sending, __xprt_lock_write_func, xprt)) return; xprt_clear_locked(xprt); }

Contributors

PersonTokensPropCommitsCommitProp
chuck leverchuck lever2452.17%120.00%
trond myklebusttrond myklebust1839.13%360.00%
linus torvaldslinus torvalds48.70%120.00%
Total46100.00%5100.00%


static bool __xprt_lock_write_cong_func(struct rpc_task *task, void *data) { struct rpc_xprt *xprt = data; struct rpc_rqst *req; req = task->tk_rqstp; if (req == NULL) { xprt->snd_task = task; return true; } if (__xprt_get_cong(xprt, task)) { xprt->snd_task = task; req->rq_ntrans++; return true; } return false; }

Contributors

PersonTokensPropCommitsCommitProp
trond myklebusttrond myklebust78100.00%6100.00%
Total78100.00%6100.00%


static void __xprt_lock_write_next_cong(struct rpc_xprt *xprt) { if (test_and_set_bit(XPRT_LOCKED, &xprt->state)) return; if (RPCXPRT_CONGESTED(xprt)) goto out_unlock; if (rpc_wake_up_first_on_wq(xprtiod_workqueue, &xprt->sending, __xprt_lock_write_cong_func, xprt)) return; out_unlock: xprt_clear_locked(xprt); }

Contributors

PersonTokensPropCommitsCommitProp
trond myklebusttrond myklebust58100.00%5100.00%
Total58100.00%5100.00%


static void xprt_task_clear_bytes_sent(struct rpc_task *task) { if (task != NULL) { struct rpc_rqst *req = task->tk_rqstp; if (req != NULL) req->rq_bytes_sent = 0; } }

Contributors

PersonTokensPropCommitsCommitProp
trond myklebusttrond myklebust40100.00%3100.00%
Total40100.00%3100.00%

/** * xprt_release_xprt - allow other requests to use a transport * @xprt: transport with other tasks potentially waiting * @task: task that is releasing access to the transport * * Note that "task" can be NULL. No congestion control is provided. */
void xprt_release_xprt(struct rpc_xprt *xprt, struct rpc_task *task) { if (xprt->snd_task == task) { xprt_task_clear_bytes_sent(task); xprt_clear_locked(xprt); __xprt_lock_write_next(xprt); } }

Contributors

PersonTokensPropCommitsCommitProp
trond myklebusttrond myklebust40100.00%4100.00%
Total40100.00%4100.00%

EXPORT_SYMBOL_GPL(xprt_release_xprt); /** * xprt_release_xprt_cong - allow other requests to use a transport * @xprt: transport with other tasks potentially waiting * @task: task that is releasing access to the transport * * Note that "task" can be NULL. Another task is awoken to use the * transport if the transport's congestion window allows it. */
void xprt_release_xprt_cong(struct rpc_xprt *xprt, struct rpc_task *task) { if (xprt->snd_task == task) { xprt_task_clear_bytes_sent(task); xprt_clear_locked(xprt); __xprt_lock_write_next_cong(xprt); } }

Contributors

PersonTokensPropCommitsCommitProp
chuck leverchuck lever3485.00%125.00%
trond myklebusttrond myklebust615.00%375.00%
Total40100.00%4100.00%

EXPORT_SYMBOL_GPL(xprt_release_xprt_cong);
static inline void xprt_release_write(struct rpc_xprt *xprt, struct rpc_task *task) { spin_lock_bh(&xprt->transport_lock); xprt->ops->release_xprt(xprt, task); spin_unlock_bh(&xprt->transport_lock); }

Contributors

PersonTokensPropCommitsCommitProp
trond myklebusttrond myklebust2352.27%125.00%
linus torvaldslinus torvalds1431.82%125.00%
chuck leverchuck lever715.91%250.00%
Total44100.00%4100.00%

/* * Van Jacobson congestion avoidance. Check if the congestion window * overflowed. Put the task to sleep if this is the case. */
static int __xprt_get_cong(struct rpc_xprt *xprt, struct rpc_task *task) { struct rpc_rqst *req = task->tk_rqstp; if (req->rq_cong) return 1; dprintk("RPC: %5u xprt_cwnd_limited cong = %lu cwnd = %lu\n", task->tk_pid, xprt->cong, xprt->cwnd); if (RPCXPRT_CONGESTED(xprt)) return 0; req->rq_cong = 1; xprt->cong += RPC_CWNDSCALE; return 1; }

Contributors

PersonTokensPropCommitsCommitProp
chuck leverchuck lever2938.16%225.00%
pre-gitpre-git2735.53%337.50%
trond myklebusttrond myklebust2026.32%337.50%
Total76100.00%8100.00%

/* * Adjust the congestion window, and wake up the next task * that has been sleeping due to congestion */
static void __xprt_put_cong(struct rpc_xprt *xprt, struct rpc_rqst *req) { if (!req->rq_cong) return; req->rq_cong = 0; xprt->cong -= RPC_CWNDSCALE; __xprt_lock_write_next_cong(xprt); }

Contributors

PersonTokensPropCommitsCommitProp
trond myklebusttrond myklebust4097.56%150.00%
chuck leverchuck lever12.44%150.00%
Total41100.00%2100.00%

/** * xprt_release_rqst_cong - housekeeping when request is complete * @task: RPC request that recently completed * * Useful for transports that require congestion control. */
void xprt_release_rqst_cong(struct rpc_task *task) { struct rpc_rqst *req = task->tk_rqstp; __xprt_put_cong(req->rq_xprt, req); }

Contributors

PersonTokensPropCommitsCommitProp
chuck leverchuck lever1657.14%150.00%
trond myklebusttrond myklebust1242.86%150.00%
Total28100.00%2100.00%

EXPORT_SYMBOL_GPL(xprt_release_rqst_cong); /** * xprt_adjust_cwnd - adjust transport congestion window * @xprt: pointer to xprt * @task: recently completed RPC request used to adjust window * @result: result code of completed RPC request * * The transport code maintains an estimate on the maximum number of out- * standing RPC requests, using a smoothed version of the congestion * avoidance implemented in 44BSD. This is basically the Van Jacobson * congestion algorithm: If a retransmit occurs, the congestion window is * halved; otherwise, it is incremented by 1/cwnd when * * - a reply is received and * - a full number of requests are outstanding and * - the congestion window hasn't been updated recently. */
void xprt_adjust_cwnd(struct rpc_xprt *xprt, struct rpc_task *task, int result) { struct rpc_rqst *req = task->tk_rqstp; unsigned long cwnd = xprt->cwnd; if (result >= 0 && cwnd <= xprt->cong) { /* The (cwnd >> 1) term makes sure * the result gets rounded properly. */ cwnd += (RPC_CWNDSCALE * RPC_CWNDSCALE + (cwnd >> 1)) / cwnd; if (cwnd > RPC_MAXCWND(xprt)) cwnd = RPC_MAXCWND(xprt); __xprt_lock_write_next_cong(xprt); } else if (result == -ETIMEDOUT) { cwnd >>= 1; if (cwnd < RPC_CWNDSCALE) cwnd = RPC_CWNDSCALE; } dprintk("RPC: cong %ld, cwnd was %ld, now %ld\n", xprt->cong, xprt->cwnd, cwnd); xprt->cwnd = cwnd; __xprt_put_cong(xprt, req); }

Contributors

PersonTokensPropCommitsCommitProp
pre-gitpre-git9669.06%222.22%
chuck leverchuck lever2316.55%333.33%
trond myklebusttrond myklebust2014.39%444.44%
Total139100.00%9100.00%

EXPORT_SYMBOL_GPL(xprt_adjust_cwnd); /** * xprt_wake_pending_tasks - wake all tasks on a transport's pending queue * @xprt: transport with waiting tasks * @status: result code to plant in each task before waking it * */
void xprt_wake_pending_tasks(struct rpc_xprt *xprt, int status) { if (status < 0) rpc_wake_up_status(&xprt->pending, status); else rpc_wake_up(&xprt->pending); }

Contributors

PersonTokensPropCommitsCommitProp
chuck leverchuck lever38100.00%1100.00%
Total38100.00%1100.00%

EXPORT_SYMBOL_GPL(xprt_wake_pending_tasks); /** * xprt_wait_for_buffer_space - wait for transport output buffer to clear * @task: task to be put to sleep * @action: function pointer to be executed after wait * * Note that we only set the timer for the case of RPC_IS_SOFT(), since * we don't in general want to force a socket disconnection due to * an incomplete RPC call transmission. */
void xprt_wait_for_buffer_space(struct rpc_task *task, rpc_action action) { struct rpc_rqst *req = task->tk_rqstp; struct rpc_xprt *xprt = req->rq_xprt; task->tk_timeout = RPC_IS_SOFT(task) ? req->rq_timeout : 0; rpc_sleep_on(&xprt->pending, task, action); }

Contributors

PersonTokensPropCommitsCommitProp
chuck leverchuck lever4781.03%133.33%
trond myklebusttrond myklebust1118.97%266.67%
Total58100.00%3100.00%

EXPORT_SYMBOL_GPL(xprt_wait_for_buffer_space); /** * xprt_write_space - wake the task waiting for transport output buffer space * @xprt: transport with waiting tasks * * Can be called in a soft IRQ context, so xprt_write_space never sleeps. */
void xprt_write_space(struct rpc_xprt *xprt) { spin_lock_bh(&xprt->transport_lock); if (xprt->snd_task) { dprintk("RPC: write space: waking waiting task on " "xprt %p\n", xprt); rpc_wake_up_queued_task(&xprt->pending, xprt->snd_task); } spin_unlock_bh(&xprt->transport_lock); }

Contributors

PersonTokensPropCommitsCommitProp
chuck leverchuck lever4888.89%266.67%
trond myklebusttrond myklebust611.11%133.33%
Total54100.00%3100.00%

EXPORT_SYMBOL_GPL(xprt_write_space); /** * xprt_set_retrans_timeout_def - set a request's retransmit timeout * @task: task whose timeout is to be set * * Set a request's retransmit timeout based on the transport's * default timeout parameters. Used by transports that don't adjust * the retransmit timeout based on round-trip time estimation. */
void xprt_set_retrans_timeout_def(struct rpc_task *task) { task->tk_timeout = task->tk_rqstp->rq_timeout; }

Contributors

PersonTokensPropCommitsCommitProp
chuck leverchuck lever20100.00%1100.00%
Total20100.00%1100.00%

EXPORT_SYMBOL_GPL(xprt_set_retrans_timeout_def); /** * xprt_set_retrans_timeout_rtt - set a request's retransmit timeout * @task: task whose timeout is to be set * * Set a request's retransmit timeout using the RTT estimator. */
void xprt_set_retrans_timeout_rtt(struct rpc_task *task) { int timer = task->tk_msg.rpc_proc->p_timer; struct rpc_clnt *clnt = task->tk_client; struct rpc_rtt *rtt = clnt->cl_rtt; struct rpc_rqst *req = task->tk_rqstp; unsigned long max_timeout = clnt->cl_timeout->to_maxval; task->tk_timeout = rpc_calc_rto(rtt, timer); task->tk_timeout <<= rpc_ntimeo(rtt, timer) + req->rq_retries; if (task->tk_timeout > max_timeout || task->tk_timeout == 0) task->tk_timeout = max_timeout; }

Contributors

PersonTokensPropCommitsCommitProp
chuck leverchuck lever9389.42%150.00%
trond myklebusttrond myklebust1110.58%150.00%
Total104100.00%2100.00%

EXPORT_SYMBOL_GPL(xprt_set_retrans_timeout_rtt);
static void xprt_reset_majortimeo(struct rpc_rqst *req) { const struct rpc_timeout *to = req->rq_task->tk_client->cl_timeout; req->rq_majortimeo = req->rq_timeout; if (to->to_exponential) req->rq_majortimeo <<= to->to_retries; else req->rq_majortimeo += to->to_increment * to->to_retries; if (req->rq_majortimeo > to->to_maxval || req->rq_majortimeo == 0) req->rq_majortimeo = to->to_maxval; req->rq_majortimeo += jiffies; }

Contributors

PersonTokensPropCommitsCommitProp
trond myklebusttrond myklebust5358.89%250.00%
pre-gitpre-git3741.11%250.00%
Total90100.00%4100.00%

/** * 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) { struct rpc_xprt *xprt = req->rq_xprt; const struct rpc_timeout *to = req->rq_task->tk_client->cl_timeout; int status = 0; if (time_before(jiffies, req->rq_majortimeo)) { if (to->to_exponential) req->rq_timeout <<= 1; else req->rq_timeout += to->to_increment; if (to->to_maxval && req->rq_timeout >= to->to_maxval) req->rq_timeout = to->to_maxval; req->rq_retries++; } else { req->rq_timeout = to->to_initval; req->rq_retries = 0; xprt_reset_majortimeo(req); /* Reset the RTT counters == "slow start" */ spin_lock_bh(&xprt->transport_lock); rpc_init_rtt(req->rq_task->tk_client->cl_rtt, to->to_initval); spin_unlock_bh(&xprt->transport_lock); status = -ETIMEDOUT; } if (req->rq_timeout == 0) { printk(KERN_WARNING "xprt_adjust_timeout: rq_timeout = 0!\n"); req->rq_timeout = 5 * HZ; } return status; }

Contributors

PersonTokensPropCommitsCommitProp
trond myklebusttrond myklebust11964.32%240.00%
pre-gitpre-git6434.59%240.00%
chuck leverchuck lever21.08%120.00%
Total185100.00%5100.00%


static void xprt_autoclose(struct work_struct *work) { struct rpc_xprt *xprt = container_of(work, struct rpc_xprt, task_cleanup); clear_bit(XPRT_CLOSE_WAIT, &xprt->state); xprt->ops->close(xprt); xprt_release_write(xprt, NULL); wake_up_bit(&xprt->state, XPRT_LOCKED); }

Contributors

PersonTokensPropCommitsCommitProp
trond myklebusttrond myklebust2946.77%337.50%
pre-gitpre-git1524.19%225.00%
david howellsdavid howells1016.13%112.50%
chuck leverchuck lever812.90%225.00%
Total62100.00%8100.00%

/** * xprt_disconnect_done - mark a transport as disconnected * @xprt: transport to flag for disconnect * */
void xprt_disconnect_done(struct rpc_xprt *xprt) { dprintk("RPC: disconnected transport %p\n", xprt); spin_lock_bh(&xprt->transport_lock); xprt_clear_connected(xprt); xprt_wake_pending_tasks(xprt, -EAGAIN); spin_unlock_bh(&xprt->transport_lock); }

Contributors

PersonTokensPropCommitsCommitProp
pre-gitpre-git2554.35%330.00%
trond myklebusttrond myklebust1736.96%440.00%
chuck leverchuck lever48.70%330.00%
Total46100.00%10100.00%

EXPORT_SYMBOL_GPL(xprt_disconnect_done); /** * xprt_force_disconnect - force a transport to disconnect * @xprt: transport to disconnect * */
void xprt_force_disconnect(struct rpc_xprt *xprt) { /* Don't race with the test_bit() in xprt_clear_locked() */ spin_lock_bh(&xprt->transport_lock); set_bit(XPRT_CLOSE_WAIT, &xprt->state); /* Try to schedule an autoclose RPC call */ if (test_and_set_bit(XPRT_LOCKED, &xprt->state) == 0) queue_work(xprtiod_workqueue, &xprt->task_cleanup); xprt_wake_pending_tasks(xprt, -EAGAIN); spin_unlock_bh(&xprt->transport_lock); }

Contributors

PersonTokensPropCommitsCommitProp
trond myklebusttrond myklebust70100.00%4100.00%
Total70100.00%4100.00%

/** * xprt_conditional_disconnect - force a transport to disconnect * @xprt: transport to disconnect * @cookie: 'connection cookie' * * This attempts to break the connection if and only if 'cookie' matches * the current transport 'connection cookie'. It ensures that we don't * try to break the connection more than once when we need to retransmit * a batch of RPC requests. * */
void xprt_conditional_disconnect(struct rpc_xprt *xprt, unsigned int cookie) { /* Don't race with the test_bit() in xprt_clear_locked() */ spin_lock_bh(&xprt->transport_lock); if (cookie != xprt->connect_cookie) goto out; if (test_bit(XPRT_CLOSING, &xprt->state) || !xprt_connected(xprt)) goto out; set_bit(XPRT_CLOSE_WAIT, &xprt->state); /* Try to schedule an autoclose RPC call */ if (test_and_set_bit(XPRT_LOCKED, &xprt->state) == 0) queue_work(xprtiod_workqueue, &xprt->task_cleanup); xprt_wake_pending_tasks(xprt, -EAGAIN); out: spin_unlock_bh(&xprt->transport_lock); }

Contributors

PersonTokensPropCommitsCommitProp
trond myklebusttrond myklebust108100.00%3100.00%
Total108100.00%3100.00%


static bool xprt_has_timer(const struct rpc_xprt *xprt) { return xprt->idle_timeout != 0; }

Contributors

PersonTokensPropCommitsCommitProp
trond myklebusttrond myklebust19100.00%2100.00%
Total19100.00%2100.00%


static void xprt_schedule_autodisconnect(struct rpc_xprt *xprt) __must_hold(&xprt->transport_lock

Contributors

PersonTokensPropCommitsCommitProp
trond myklebusttrond myklebust12100.00%1100.00%
Total12100.00%1100.00%

) { if (list_empty(&xprt->recv) && xprt_has_timer(xprt)) mod_timer(&xprt->timer, xprt->last_used + xprt->idle_timeout); }
static void xprt_init_autodisconnect(unsigned long data) { struct rpc_xprt *xprt = (struct rpc_xprt *)data; spin_lock(&xprt->transport_lock); if (!list_empty(&xprt->recv)) goto out_abort; /* Reset xprt->last_used to avoid connect/autodisconnect cycling */ xprt->last_used = jiffies; if (test_and_set_bit(XPRT_LOCKED, &xprt->state)) goto out_abort; spin_unlock(&xprt->transport_lock); queue_work(xprtiod_workqueue, &xprt->task_cleanup); return; out_abort: spin_unlock(&xprt->transport_lock); }

Contributors

PersonTokensPropCommitsCommitProp
trond myklebusttrond myklebust9195.79%466.67%
chuck leverchuck lever44.21%233.33%
Total95100.00%6100.00%


bool xprt_lock_connect(struct rpc_xprt *xprt, struct rpc_task *task, void *cookie) { bool ret = false; spin_lock_bh(&xprt->transport_lock); if (!test_bit(XPRT_LOCKED, &xprt->state)) goto out; if (xprt->snd_task != task) goto out; xprt_task_clear_bytes_sent(task); xprt->snd_task = cookie; ret = true; out: spin_unlock_bh(&xprt->transport_lock); return ret; }

Contributors

PersonTokensPropCommitsCommitProp
trond myklebusttrond myklebust87100.00%2100.00%
Total87100.00%2100.00%


void xprt_unlock_connect(struct rpc_xprt *xprt, void *cookie) { spin_lock_bh(&xprt->transport_lock); if (xprt->snd_task != cookie) goto out; if (!test_bit(XPRT_LOCKED, &xprt->state)) goto out; xprt->snd_task =NULL; xprt->ops->release_xprt(xprt, NULL); xprt_schedule_autodisconnect(xprt); out: spin_unlock_bh(&xprt->transport_lock); wake_up_bit(&xprt->state, XPRT_LOCKED); }

Contributors

PersonTokensPropCommitsCommitProp
trond myklebusttrond myklebust91100.00%3100.00%
Total91100.00%3100.00%

/** * xprt_connect - schedule a transport connect operation * @task: RPC task that is requesting the connect * */
void xprt_connect(struct rpc_task *task) { struct rpc_xprt *xprt = task->tk_rqstp->rq_xprt; dprintk("RPC: %5u xprt_connect xprt %p %s connected\n", task->tk_pid, xprt,