LCOV - code coverage report
Current view: top level - net/sunrpc - xprt.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 14 860 1.6 %
Date: 2022-03-28 16:04:14 Functions: 1 78 1.3 %
Branches: 3 352 0.9 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0-only
       2                 :            : /*
       3                 :            :  *  linux/net/sunrpc/xprt.c
       4                 :            :  *
       5                 :            :  *  This is a generic RPC call interface supporting congestion avoidance,
       6                 :            :  *  and asynchronous calls.
       7                 :            :  *
       8                 :            :  *  The interface works like this:
       9                 :            :  *
      10                 :            :  *  -   When a process places a call, it allocates a request slot if
      11                 :            :  *      one is available. Otherwise, it sleeps on the backlog queue
      12                 :            :  *      (xprt_reserve).
      13                 :            :  *  -   Next, the caller puts together the RPC message, stuffs it into
      14                 :            :  *      the request struct, and calls xprt_transmit().
      15                 :            :  *  -   xprt_transmit sends the message and installs the caller on the
      16                 :            :  *      transport's wait list. At the same time, if a reply is expected,
      17                 :            :  *      it installs a timer that is run after the packet's timeout has
      18                 :            :  *      expired.
      19                 :            :  *  -   When a packet arrives, the data_ready handler walks the list of
      20                 :            :  *      pending requests for that transport. If a matching XID is found, the
      21                 :            :  *      caller is woken up, and the timer removed.
      22                 :            :  *  -   When no reply arrives within the timeout interval, the timer is
      23                 :            :  *      fired by the kernel and runs xprt_timer(). It either adjusts the
      24                 :            :  *      timeout values (minor timeout) or wakes up the caller with a status
      25                 :            :  *      of -ETIMEDOUT.
      26                 :            :  *  -   When the caller receives a notification from RPC that a reply arrived,
      27                 :            :  *      it should release the RPC slot, and process the reply.
      28                 :            :  *      If the call timed out, it may choose to retry the operation by
      29                 :            :  *      adjusting the initial timeout value, and simply calling rpc_call
      30                 :            :  *      again.
      31                 :            :  *
      32                 :            :  *  Support for async RPC is done through a set of RPC-specific scheduling
      33                 :            :  *  primitives that `transparently' work for processes as well as async
      34                 :            :  *  tasks that rely on callbacks.
      35                 :            :  *
      36                 :            :  *  Copyright (C) 1995-1997, Olaf Kirch <okir@monad.swb.de>
      37                 :            :  *
      38                 :            :  *  Transport switch API copyright (C) 2005, Chuck Lever <cel@netapp.com>
      39                 :            :  */
      40                 :            : 
      41                 :            : #include <linux/module.h>
      42                 :            : 
      43                 :            : #include <linux/types.h>
      44                 :            : #include <linux/interrupt.h>
      45                 :            : #include <linux/workqueue.h>
      46                 :            : #include <linux/net.h>
      47                 :            : #include <linux/ktime.h>
      48                 :            : 
      49                 :            : #include <linux/sunrpc/clnt.h>
      50                 :            : #include <linux/sunrpc/metrics.h>
      51                 :            : #include <linux/sunrpc/bc_xprt.h>
      52                 :            : #include <linux/rcupdate.h>
      53                 :            : #include <linux/sched/mm.h>
      54                 :            : 
      55                 :            : #include <trace/events/sunrpc.h>
      56                 :            : 
      57                 :            : #include "sunrpc.h"
      58                 :            : 
      59                 :            : /*
      60                 :            :  * Local variables
      61                 :            :  */
      62                 :            : 
      63                 :            : #if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
      64                 :            : # define RPCDBG_FACILITY        RPCDBG_XPRT
      65                 :            : #endif
      66                 :            : 
      67                 :            : /*
      68                 :            :  * Local functions
      69                 :            :  */
      70                 :            : static void      xprt_init(struct rpc_xprt *xprt, struct net *net);
      71                 :            : static __be32   xprt_alloc_xid(struct rpc_xprt *xprt);
      72                 :            : static void      xprt_destroy(struct rpc_xprt *xprt);
      73                 :            : 
      74                 :            : static DEFINE_SPINLOCK(xprt_list_lock);
      75                 :            : static LIST_HEAD(xprt_list);
      76                 :            : 
      77                 :          0 : static unsigned long xprt_request_timeout(const struct rpc_rqst *req)
      78                 :            : {
      79                 :          0 :         unsigned long timeout = jiffies + req->rq_timeout;
      80                 :            : 
      81                 :          0 :         if (time_before(timeout, req->rq_majortimeo))
      82                 :          0 :                 return timeout;
      83                 :            :         return req->rq_majortimeo;
      84                 :            : }
      85                 :            : 
      86                 :            : /**
      87                 :            :  * xprt_register_transport - register a transport implementation
      88                 :            :  * @transport: transport to register
      89                 :            :  *
      90                 :            :  * If a transport implementation is loaded as a kernel module, it can
      91                 :            :  * call this interface to make itself known to the RPC client.
      92                 :            :  *
      93                 :            :  * Returns:
      94                 :            :  * 0:           transport successfully registered
      95                 :            :  * -EEXIST:     transport already registered
      96                 :            :  * -EINVAL:     transport module being unloaded
      97                 :            :  */
      98                 :         52 : int xprt_register_transport(struct xprt_class *transport)
      99                 :            : {
     100                 :         52 :         struct xprt_class *t;
     101                 :         52 :         int result;
     102                 :            : 
     103                 :         52 :         result = -EEXIST;
     104                 :         52 :         spin_lock(&xprt_list_lock);
     105         [ +  + ]:        130 :         list_for_each_entry(t, &xprt_list, list) {
     106                 :            :                 /* don't register the same transport class twice */
     107         [ -  + ]:         78 :                 if (t->ident == transport->ident)
     108                 :          0 :                         goto out;
     109                 :            :         }
     110                 :            : 
     111                 :         52 :         list_add_tail(&transport->list, &xprt_list);
     112                 :         52 :         printk(KERN_INFO "RPC: Registered %s transport module.\n",
     113                 :         52 :                transport->name);
     114                 :         52 :         result = 0;
     115                 :            : 
     116                 :         52 : out:
     117                 :         52 :         spin_unlock(&xprt_list_lock);
     118                 :         52 :         return result;
     119                 :            : }
     120                 :            : EXPORT_SYMBOL_GPL(xprt_register_transport);
     121                 :            : 
     122                 :            : /**
     123                 :            :  * xprt_unregister_transport - unregister a transport implementation
     124                 :            :  * @transport: transport to unregister
     125                 :            :  *
     126                 :            :  * Returns:
     127                 :            :  * 0:           transport successfully unregistered
     128                 :            :  * -ENOENT:     transport never registered
     129                 :            :  */
     130                 :          0 : int xprt_unregister_transport(struct xprt_class *transport)
     131                 :            : {
     132                 :          0 :         struct xprt_class *t;
     133                 :          0 :         int result;
     134                 :            : 
     135                 :          0 :         result = 0;
     136                 :          0 :         spin_lock(&xprt_list_lock);
     137         [ #  # ]:          0 :         list_for_each_entry(t, &xprt_list, list) {
     138         [ #  # ]:          0 :                 if (t == transport) {
     139                 :          0 :                         printk(KERN_INFO
     140                 :            :                                 "RPC: Unregistered %s transport module.\n",
     141                 :          0 :                                 transport->name);
     142                 :          0 :                         list_del_init(&transport->list);
     143                 :          0 :                         goto out;
     144                 :            :                 }
     145                 :            :         }
     146                 :            :         result = -ENOENT;
     147                 :            : 
     148                 :          0 : out:
     149                 :          0 :         spin_unlock(&xprt_list_lock);
     150                 :          0 :         return result;
     151                 :            : }
     152                 :            : EXPORT_SYMBOL_GPL(xprt_unregister_transport);
     153                 :            : 
     154                 :            : /**
     155                 :            :  * xprt_load_transport - load a transport implementation
     156                 :            :  * @transport_name: transport to load
     157                 :            :  *
     158                 :            :  * Returns:
     159                 :            :  * 0:           transport successfully loaded
     160                 :            :  * -ENOENT:     transport module not available
     161                 :            :  */
     162                 :          0 : int xprt_load_transport(const char *transport_name)
     163                 :            : {
     164                 :          0 :         struct xprt_class *t;
     165                 :          0 :         int result;
     166                 :            : 
     167                 :          0 :         result = 0;
     168                 :          0 :         spin_lock(&xprt_list_lock);
     169         [ #  # ]:          0 :         list_for_each_entry(t, &xprt_list, list) {
     170         [ #  # ]:          0 :                 if (strcmp(t->name, transport_name) == 0) {
     171                 :          0 :                         spin_unlock(&xprt_list_lock);
     172                 :          0 :                         goto out;
     173                 :            :                 }
     174                 :            :         }
     175                 :          0 :         spin_unlock(&xprt_list_lock);
     176                 :          0 :         result = request_module("xprt%s", transport_name);
     177                 :          0 : out:
     178                 :          0 :         return result;
     179                 :            : }
     180                 :            : EXPORT_SYMBOL_GPL(xprt_load_transport);
     181                 :            : 
     182                 :          0 : static void xprt_clear_locked(struct rpc_xprt *xprt)
     183                 :            : {
     184                 :          0 :         xprt->snd_task = NULL;
     185         [ #  # ]:          0 :         if (!test_bit(XPRT_CLOSE_WAIT, &xprt->state)) {
     186                 :          0 :                 smp_mb__before_atomic();
     187                 :          0 :                 clear_bit(XPRT_LOCKED, &xprt->state);
     188                 :          0 :                 smp_mb__after_atomic();
     189                 :            :         } else
     190                 :          0 :                 queue_work(xprtiod_workqueue, &xprt->task_cleanup);
     191                 :          0 : }
     192                 :            : 
     193                 :            : /**
     194                 :            :  * xprt_reserve_xprt - serialize write access to transports
     195                 :            :  * @task: task that is requesting access to the transport
     196                 :            :  * @xprt: pointer to the target transport
     197                 :            :  *
     198                 :            :  * This prevents mixing the payload of separate requests, and prevents
     199                 :            :  * transport connects from colliding with writes.  No congestion control
     200                 :            :  * is provided.
     201                 :            :  */
     202                 :          0 : int xprt_reserve_xprt(struct rpc_xprt *xprt, struct rpc_task *task)
     203                 :            : {
     204                 :          0 :         struct rpc_rqst *req = task->tk_rqstp;
     205                 :            : 
     206         [ #  # ]:          0 :         if (test_and_set_bit(XPRT_LOCKED, &xprt->state)) {
     207         [ #  # ]:          0 :                 if (task == xprt->snd_task)
     208                 :          0 :                         goto out_locked;
     209                 :          0 :                 goto out_sleep;
     210                 :            :         }
     211         [ #  # ]:          0 :         if (test_bit(XPRT_WRITE_SPACE, &xprt->state))
     212                 :          0 :                 goto out_unlock;
     213                 :          0 :         xprt->snd_task = task;
     214                 :            : 
     215                 :          0 : out_locked:
     216                 :          0 :         trace_xprt_reserve_xprt(xprt, task);
     217                 :          0 :         return 1;
     218                 :            : 
     219                 :            : out_unlock:
     220                 :          0 :         xprt_clear_locked(xprt);
     221                 :          0 : out_sleep:
     222                 :          0 :         task->tk_status = -EAGAIN;
     223         [ #  # ]:          0 :         if  (RPC_IS_SOFT(task))
     224         [ #  # ]:          0 :                 rpc_sleep_on_timeout(&xprt->sending, task, NULL,
     225                 :            :                                 xprt_request_timeout(req));
     226                 :            :         else
     227                 :          0 :                 rpc_sleep_on(&xprt->sending, task, NULL);
     228                 :            :         return 0;
     229                 :            : }
     230                 :            : EXPORT_SYMBOL_GPL(xprt_reserve_xprt);
     231                 :            : 
     232                 :            : static bool
     233                 :          0 : xprt_need_congestion_window_wait(struct rpc_xprt *xprt)
     234                 :            : {
     235                 :          0 :         return test_bit(XPRT_CWND_WAIT, &xprt->state);
     236                 :            : }
     237                 :            : 
     238                 :            : static void
     239                 :            : xprt_set_congestion_window_wait(struct rpc_xprt *xprt)
     240                 :            : {
     241                 :            :         if (!list_empty(&xprt->xmit_queue)) {
     242                 :            :                 /* Peek at head of queue to see if it can make progress */
     243                 :            :                 if (list_first_entry(&xprt->xmit_queue, struct rpc_rqst,
     244                 :            :                                         rq_xmit)->rq_cong)
     245                 :            :                         return;
     246                 :            :         }
     247                 :            :         set_bit(XPRT_CWND_WAIT, &xprt->state);
     248                 :            : }
     249                 :            : 
     250                 :            : static void
     251                 :            : xprt_test_and_clear_congestion_window_wait(struct rpc_xprt *xprt)
     252                 :            : {
     253                 :            :         if (!RPCXPRT_CONGESTED(xprt))
     254                 :            :                 clear_bit(XPRT_CWND_WAIT, &xprt->state);
     255                 :            : }
     256                 :            : 
     257                 :            : /*
     258                 :            :  * xprt_reserve_xprt_cong - serialize write access to transports
     259                 :            :  * @task: task that is requesting access to the transport
     260                 :            :  *
     261                 :            :  * Same as xprt_reserve_xprt, but Van Jacobson congestion control is
     262                 :            :  * integrated into the decision of whether a request is allowed to be
     263                 :            :  * woken up and given access to the transport.
     264                 :            :  * Note that the lock is only granted if we know there are free slots.
     265                 :            :  */
     266                 :          0 : int xprt_reserve_xprt_cong(struct rpc_xprt *xprt, struct rpc_task *task)
     267                 :            : {
     268                 :          0 :         struct rpc_rqst *req = task->tk_rqstp;
     269                 :            : 
     270         [ #  # ]:          0 :         if (test_and_set_bit(XPRT_LOCKED, &xprt->state)) {
     271         [ #  # ]:          0 :                 if (task == xprt->snd_task)
     272                 :          0 :                         goto out_locked;
     273                 :          0 :                 goto out_sleep;
     274                 :            :         }
     275         [ #  # ]:          0 :         if (req == NULL) {
     276                 :          0 :                 xprt->snd_task = task;
     277                 :          0 :                 goto out_locked;
     278                 :            :         }
     279         [ #  # ]:          0 :         if (test_bit(XPRT_WRITE_SPACE, &xprt->state))
     280                 :          0 :                 goto out_unlock;
     281         [ #  # ]:          0 :         if (!xprt_need_congestion_window_wait(xprt)) {
     282                 :          0 :                 xprt->snd_task = task;
     283                 :          0 :                 goto out_locked;
     284                 :            :         }
     285                 :          0 : out_unlock:
     286                 :          0 :         xprt_clear_locked(xprt);
     287                 :          0 : out_sleep:
     288                 :          0 :         task->tk_status = -EAGAIN;
     289         [ #  # ]:          0 :         if (RPC_IS_SOFT(task))
     290         [ #  # ]:          0 :                 rpc_sleep_on_timeout(&xprt->sending, task, NULL,
     291                 :            :                                 xprt_request_timeout(req));
     292                 :            :         else
     293                 :          0 :                 rpc_sleep_on(&xprt->sending, task, NULL);
     294                 :            :         return 0;
     295                 :          0 : out_locked:
     296                 :          0 :         trace_xprt_reserve_cong(xprt, task);
     297                 :          0 :         return 1;
     298                 :            : }
     299                 :            : EXPORT_SYMBOL_GPL(xprt_reserve_xprt_cong);
     300                 :            : 
     301                 :          0 : static inline int xprt_lock_write(struct rpc_xprt *xprt, struct rpc_task *task)
     302                 :            : {
     303                 :          0 :         int retval;
     304                 :            : 
     305   [ #  #  #  # ]:          0 :         if (test_bit(XPRT_LOCKED, &xprt->state) && xprt->snd_task == task)
     306                 :            :                 return 1;
     307                 :          0 :         spin_lock(&xprt->transport_lock);
     308                 :          0 :         retval = xprt->ops->reserve_xprt(xprt, task);
     309                 :          0 :         spin_unlock(&xprt->transport_lock);
     310                 :          0 :         return retval;
     311                 :            : }
     312                 :            : 
     313                 :          0 : static bool __xprt_lock_write_func(struct rpc_task *task, void *data)
     314                 :            : {
     315                 :          0 :         struct rpc_xprt *xprt = data;
     316                 :            : 
     317                 :          0 :         xprt->snd_task = task;
     318                 :          0 :         return true;
     319                 :            : }
     320                 :            : 
     321                 :          0 : static void __xprt_lock_write_next(struct rpc_xprt *xprt)
     322                 :            : {
     323         [ #  # ]:          0 :         if (test_and_set_bit(XPRT_LOCKED, &xprt->state))
     324                 :            :                 return;
     325         [ #  # ]:          0 :         if (test_bit(XPRT_WRITE_SPACE, &xprt->state))
     326                 :          0 :                 goto out_unlock;
     327         [ #  # ]:          0 :         if (rpc_wake_up_first_on_wq(xprtiod_workqueue, &xprt->sending,
     328                 :            :                                 __xprt_lock_write_func, xprt))
     329                 :            :                 return;
     330                 :          0 : out_unlock:
     331                 :          0 :         xprt_clear_locked(xprt);
     332                 :            : }
     333                 :            : 
     334                 :          0 : static void __xprt_lock_write_next_cong(struct rpc_xprt *xprt)
     335                 :            : {
     336         [ #  # ]:          0 :         if (test_and_set_bit(XPRT_LOCKED, &xprt->state))
     337                 :            :                 return;
     338         [ #  # ]:          0 :         if (test_bit(XPRT_WRITE_SPACE, &xprt->state))
     339                 :          0 :                 goto out_unlock;
     340         [ #  # ]:          0 :         if (xprt_need_congestion_window_wait(xprt))
     341                 :          0 :                 goto out_unlock;
     342         [ #  # ]:          0 :         if (rpc_wake_up_first_on_wq(xprtiod_workqueue, &xprt->sending,
     343                 :            :                                 __xprt_lock_write_func, xprt))
     344                 :            :                 return;
     345                 :          0 : out_unlock:
     346                 :          0 :         xprt_clear_locked(xprt);
     347                 :            : }
     348                 :            : 
     349                 :            : /**
     350                 :            :  * xprt_release_xprt - allow other requests to use a transport
     351                 :            :  * @xprt: transport with other tasks potentially waiting
     352                 :            :  * @task: task that is releasing access to the transport
     353                 :            :  *
     354                 :            :  * Note that "task" can be NULL.  No congestion control is provided.
     355                 :            :  */
     356                 :          0 : void xprt_release_xprt(struct rpc_xprt *xprt, struct rpc_task *task)
     357                 :            : {
     358         [ #  # ]:          0 :         if (xprt->snd_task == task) {
     359                 :          0 :                 xprt_clear_locked(xprt);
     360                 :          0 :                 __xprt_lock_write_next(xprt);
     361                 :            :         }
     362                 :          0 :         trace_xprt_release_xprt(xprt, task);
     363                 :          0 : }
     364                 :            : EXPORT_SYMBOL_GPL(xprt_release_xprt);
     365                 :            : 
     366                 :            : /**
     367                 :            :  * xprt_release_xprt_cong - allow other requests to use a transport
     368                 :            :  * @xprt: transport with other tasks potentially waiting
     369                 :            :  * @task: task that is releasing access to the transport
     370                 :            :  *
     371                 :            :  * Note that "task" can be NULL.  Another task is awoken to use the
     372                 :            :  * transport if the transport's congestion window allows it.
     373                 :            :  */
     374                 :          0 : void xprt_release_xprt_cong(struct rpc_xprt *xprt, struct rpc_task *task)
     375                 :            : {
     376         [ #  # ]:          0 :         if (xprt->snd_task == task) {
     377                 :          0 :                 xprt_clear_locked(xprt);
     378                 :          0 :                 __xprt_lock_write_next_cong(xprt);
     379                 :            :         }
     380                 :          0 :         trace_xprt_release_cong(xprt, task);
     381                 :          0 : }
     382                 :            : EXPORT_SYMBOL_GPL(xprt_release_xprt_cong);
     383                 :            : 
     384                 :          0 : static inline void xprt_release_write(struct rpc_xprt *xprt, struct rpc_task *task)
     385                 :            : {
     386         [ #  # ]:          0 :         if (xprt->snd_task != task)
     387                 :            :                 return;
     388                 :          0 :         spin_lock(&xprt->transport_lock);
     389                 :          0 :         xprt->ops->release_xprt(xprt, task);
     390                 :          0 :         spin_unlock(&xprt->transport_lock);
     391                 :            : }
     392                 :            : 
     393                 :            : /*
     394                 :            :  * Van Jacobson congestion avoidance. Check if the congestion window
     395                 :            :  * overflowed. Put the task to sleep if this is the case.
     396                 :            :  */
     397                 :            : static int
     398                 :            : __xprt_get_cong(struct rpc_xprt *xprt, struct rpc_rqst *req)
     399                 :            : {
     400                 :            :         if (req->rq_cong)
     401                 :            :                 return 1;
     402                 :            :         trace_xprt_get_cong(xprt, req->rq_task);
     403                 :            :         if (RPCXPRT_CONGESTED(xprt)) {
     404                 :            :                 xprt_set_congestion_window_wait(xprt);
     405                 :            :                 return 0;
     406                 :            :         }
     407                 :            :         req->rq_cong = 1;
     408                 :            :         xprt->cong += RPC_CWNDSCALE;
     409                 :            :         return 1;
     410                 :            : }
     411                 :            : 
     412                 :            : /*
     413                 :            :  * Adjust the congestion window, and wake up the next task
     414                 :            :  * that has been sleeping due to congestion
     415                 :            :  */
     416                 :            : static void
     417                 :            : __xprt_put_cong(struct rpc_xprt *xprt, struct rpc_rqst *req)
     418                 :            : {
     419                 :            :         if (!req->rq_cong)
     420                 :            :                 return;
     421                 :            :         req->rq_cong = 0;
     422                 :            :         xprt->cong -= RPC_CWNDSCALE;
     423                 :            :         xprt_test_and_clear_congestion_window_wait(xprt);
     424                 :            :         trace_xprt_put_cong(xprt, req->rq_task);
     425                 :            :         __xprt_lock_write_next_cong(xprt);
     426                 :            : }
     427                 :            : 
     428                 :            : /**
     429                 :            :  * xprt_request_get_cong - Request congestion control credits
     430                 :            :  * @xprt: pointer to transport
     431                 :            :  * @req: pointer to RPC request
     432                 :            :  *
     433                 :            :  * Useful for transports that require congestion control.
     434                 :            :  */
     435                 :            : bool
     436                 :          0 : xprt_request_get_cong(struct rpc_xprt *xprt, struct rpc_rqst *req)
     437                 :            : {
     438                 :          0 :         bool ret = false;
     439                 :            : 
     440         [ #  # ]:          0 :         if (req->rq_cong)
     441                 :            :                 return true;
     442                 :          0 :         spin_lock(&xprt->transport_lock);
     443                 :          0 :         ret = __xprt_get_cong(xprt, req) != 0;
     444                 :          0 :         spin_unlock(&xprt->transport_lock);
     445                 :          0 :         return ret;
     446                 :            : }
     447                 :            : EXPORT_SYMBOL_GPL(xprt_request_get_cong);
     448                 :            : 
     449                 :            : /**
     450                 :            :  * xprt_release_rqst_cong - housekeeping when request is complete
     451                 :            :  * @task: RPC request that recently completed
     452                 :            :  *
     453                 :            :  * Useful for transports that require congestion control.
     454                 :            :  */
     455                 :          0 : void xprt_release_rqst_cong(struct rpc_task *task)
     456                 :            : {
     457                 :          0 :         struct rpc_rqst *req = task->tk_rqstp;
     458                 :            : 
     459                 :          0 :         __xprt_put_cong(req->rq_xprt, req);
     460                 :          0 : }
     461                 :            : EXPORT_SYMBOL_GPL(xprt_release_rqst_cong);
     462                 :            : 
     463                 :          0 : static void xprt_clear_congestion_window_wait_locked(struct rpc_xprt *xprt)
     464                 :            : {
     465         [ #  # ]:          0 :         if (test_and_clear_bit(XPRT_CWND_WAIT, &xprt->state))
     466                 :          0 :                 __xprt_lock_write_next_cong(xprt);
     467                 :          0 : }
     468                 :            : 
     469                 :            : /*
     470                 :            :  * Clear the congestion window wait flag and wake up the next
     471                 :            :  * entry on xprt->sending
     472                 :            :  */
     473                 :            : static void
     474                 :          0 : xprt_clear_congestion_window_wait(struct rpc_xprt *xprt)
     475                 :            : {
     476         [ #  # ]:          0 :         if (test_and_clear_bit(XPRT_CWND_WAIT, &xprt->state)) {
     477                 :          0 :                 spin_lock(&xprt->transport_lock);
     478                 :          0 :                 __xprt_lock_write_next_cong(xprt);
     479                 :          0 :                 spin_unlock(&xprt->transport_lock);
     480                 :            :         }
     481                 :          0 : }
     482                 :            : 
     483                 :            : /**
     484                 :            :  * xprt_adjust_cwnd - adjust transport congestion window
     485                 :            :  * @xprt: pointer to xprt
     486                 :            :  * @task: recently completed RPC request used to adjust window
     487                 :            :  * @result: result code of completed RPC request
     488                 :            :  *
     489                 :            :  * The transport code maintains an estimate on the maximum number of out-
     490                 :            :  * standing RPC requests, using a smoothed version of the congestion
     491                 :            :  * avoidance implemented in 44BSD. This is basically the Van Jacobson
     492                 :            :  * congestion algorithm: If a retransmit occurs, the congestion window is
     493                 :            :  * halved; otherwise, it is incremented by 1/cwnd when
     494                 :            :  *
     495                 :            :  *      -       a reply is received and
     496                 :            :  *      -       a full number of requests are outstanding and
     497                 :            :  *      -       the congestion window hasn't been updated recently.
     498                 :            :  */
     499                 :          0 : void xprt_adjust_cwnd(struct rpc_xprt *xprt, struct rpc_task *task, int result)
     500                 :            : {
     501                 :          0 :         struct rpc_rqst *req = task->tk_rqstp;
     502                 :          0 :         unsigned long cwnd = xprt->cwnd;
     503                 :            : 
     504   [ #  #  #  # ]:          0 :         if (result >= 0 && cwnd <= xprt->cong) {
     505                 :            :                 /* The (cwnd >> 1) term makes sure
     506                 :            :                  * the result gets rounded properly. */
     507                 :          0 :                 cwnd += (RPC_CWNDSCALE * RPC_CWNDSCALE + (cwnd >> 1)) / cwnd;
     508                 :          0 :                 if (cwnd > RPC_MAXCWND(xprt))
     509                 :            :                         cwnd = RPC_MAXCWND(xprt);
     510                 :          0 :                 __xprt_lock_write_next_cong(xprt);
     511         [ #  # ]:          0 :         } else if (result == -ETIMEDOUT) {
     512                 :          0 :                 cwnd >>= 1;
     513                 :          0 :                 if (cwnd < RPC_CWNDSCALE)
     514                 :            :                         cwnd = RPC_CWNDSCALE;
     515                 :            :         }
     516                 :          0 :         dprintk("RPC:       cong %ld, cwnd was %ld, now %ld\n",
     517                 :            :                         xprt->cong, xprt->cwnd, cwnd);
     518                 :          0 :         xprt->cwnd = cwnd;
     519                 :          0 :         __xprt_put_cong(xprt, req);
     520                 :          0 : }
     521                 :            : EXPORT_SYMBOL_GPL(xprt_adjust_cwnd);
     522                 :            : 
     523                 :            : /**
     524                 :            :  * xprt_wake_pending_tasks - wake all tasks on a transport's pending queue
     525                 :            :  * @xprt: transport with waiting tasks
     526                 :            :  * @status: result code to plant in each task before waking it
     527                 :            :  *
     528                 :            :  */
     529                 :          0 : void xprt_wake_pending_tasks(struct rpc_xprt *xprt, int status)
     530                 :            : {
     531         [ #  # ]:          0 :         if (status < 0)
     532                 :          0 :                 rpc_wake_up_status(&xprt->pending, status);
     533                 :            :         else
     534                 :          0 :                 rpc_wake_up(&xprt->pending);
     535                 :          0 : }
     536                 :            : EXPORT_SYMBOL_GPL(xprt_wake_pending_tasks);
     537                 :            : 
     538                 :            : /**
     539                 :            :  * xprt_wait_for_buffer_space - wait for transport output buffer to clear
     540                 :            :  * @xprt: transport
     541                 :            :  *
     542                 :            :  * Note that we only set the timer for the case of RPC_IS_SOFT(), since
     543                 :            :  * we don't in general want to force a socket disconnection due to
     544                 :            :  * an incomplete RPC call transmission.
     545                 :            :  */
     546                 :          0 : void xprt_wait_for_buffer_space(struct rpc_xprt *xprt)
     547                 :            : {
     548                 :          0 :         set_bit(XPRT_WRITE_SPACE, &xprt->state);
     549                 :          0 : }
     550                 :            : EXPORT_SYMBOL_GPL(xprt_wait_for_buffer_space);
     551                 :            : 
     552                 :            : static bool
     553                 :          0 : xprt_clear_write_space_locked(struct rpc_xprt *xprt)
     554                 :            : {
     555         [ #  # ]:          0 :         if (test_and_clear_bit(XPRT_WRITE_SPACE, &xprt->state)) {
     556                 :          0 :                 __xprt_lock_write_next(xprt);
     557                 :          0 :                 dprintk("RPC:       write space: waking waiting task on "
     558                 :            :                                 "xprt %p\n", xprt);
     559                 :          0 :                 return true;
     560                 :            :         }
     561                 :            :         return false;
     562                 :            : }
     563                 :            : 
     564                 :            : /**
     565                 :            :  * xprt_write_space - wake the task waiting for transport output buffer space
     566                 :            :  * @xprt: transport with waiting tasks
     567                 :            :  *
     568                 :            :  * Can be called in a soft IRQ context, so xprt_write_space never sleeps.
     569                 :            :  */
     570                 :          0 : bool xprt_write_space(struct rpc_xprt *xprt)
     571                 :            : {
     572                 :          0 :         bool ret;
     573                 :            : 
     574         [ #  # ]:          0 :         if (!test_bit(XPRT_WRITE_SPACE, &xprt->state))
     575                 :            :                 return false;
     576                 :          0 :         spin_lock(&xprt->transport_lock);
     577                 :          0 :         ret = xprt_clear_write_space_locked(xprt);
     578                 :          0 :         spin_unlock(&xprt->transport_lock);
     579                 :          0 :         return ret;
     580                 :            : }
     581                 :            : EXPORT_SYMBOL_GPL(xprt_write_space);
     582                 :            : 
     583                 :          0 : static unsigned long xprt_abs_ktime_to_jiffies(ktime_t abstime)
     584                 :            : {
     585         [ #  # ]:          0 :         s64 delta = ktime_to_ns(ktime_get() - abstime);
     586                 :          0 :         return likely(delta >= 0) ?
     587         [ #  # ]:          0 :                 jiffies - nsecs_to_jiffies(delta) :
     588                 :          0 :                 jiffies + nsecs_to_jiffies(-delta);
     589                 :            : }
     590                 :            : 
     591                 :          0 : static unsigned long xprt_calc_majortimeo(struct rpc_rqst *req)
     592                 :            : {
     593                 :          0 :         const struct rpc_timeout *to = req->rq_task->tk_client->cl_timeout;
     594                 :          0 :         unsigned long majortimeo = req->rq_timeout;
     595                 :            : 
     596                 :          0 :         if (to->to_exponential)
     597                 :          0 :                 majortimeo <<= to->to_retries;
     598                 :            :         else
     599                 :          0 :                 majortimeo += to->to_increment * to->to_retries;
     600   [ #  #  #  # ]:          0 :         if (majortimeo > to->to_maxval || majortimeo == 0)
     601                 :          0 :                 majortimeo = to->to_maxval;
     602                 :          0 :         return majortimeo;
     603                 :            : }
     604                 :            : 
     605                 :          0 : static void xprt_reset_majortimeo(struct rpc_rqst *req)
     606                 :            : {
     607         [ #  # ]:          0 :         req->rq_majortimeo += xprt_calc_majortimeo(req);
     608                 :          0 : }
     609                 :            : 
     610                 :            : static void xprt_init_majortimeo(struct rpc_task *task, struct rpc_rqst *req)
     611                 :            : {
     612                 :            :         unsigned long time_init;
     613                 :            :         struct rpc_xprt *xprt = req->rq_xprt;
     614                 :            : 
     615                 :            :         if (likely(xprt && xprt_connected(xprt)))
     616                 :            :                 time_init = jiffies;
     617                 :            :         else
     618                 :            :                 time_init = xprt_abs_ktime_to_jiffies(task->tk_start);
     619                 :            :         req->rq_timeout = task->tk_client->cl_timeout->to_initval;
     620                 :            :         req->rq_majortimeo = time_init + xprt_calc_majortimeo(req);
     621                 :            : }
     622                 :            : 
     623                 :            : /**
     624                 :            :  * xprt_adjust_timeout - adjust timeout values for next retransmit
     625                 :            :  * @req: RPC request containing parameters to use for the adjustment
     626                 :            :  *
     627                 :            :  */
     628                 :          0 : int xprt_adjust_timeout(struct rpc_rqst *req)
     629                 :            : {
     630                 :          0 :         struct rpc_xprt *xprt = req->rq_xprt;
     631                 :          0 :         const struct rpc_timeout *to = req->rq_task->tk_client->cl_timeout;
     632                 :          0 :         int status = 0;
     633                 :            : 
     634         [ #  # ]:          0 :         if (time_before(jiffies, req->rq_majortimeo)) {
     635         [ #  # ]:          0 :                 if (to->to_exponential)
     636                 :          0 :                         req->rq_timeout <<= 1;
     637                 :            :                 else
     638                 :          0 :                         req->rq_timeout += to->to_increment;
     639   [ #  #  #  # ]:          0 :                 if (to->to_maxval && req->rq_timeout >= to->to_maxval)
     640                 :          0 :                         req->rq_timeout = to->to_maxval;
     641                 :          0 :                 req->rq_retries++;
     642                 :            :         } else {
     643                 :          0 :                 req->rq_timeout = to->to_initval;
     644                 :          0 :                 req->rq_retries = 0;
     645                 :          0 :                 xprt_reset_majortimeo(req);
     646                 :            :                 /* Reset the RTT counters == "slow start" */
     647                 :          0 :                 spin_lock(&xprt->transport_lock);
     648                 :          0 :                 rpc_init_rtt(req->rq_task->tk_client->cl_rtt, to->to_initval);
     649                 :          0 :                 spin_unlock(&xprt->transport_lock);
     650                 :          0 :                 status = -ETIMEDOUT;
     651                 :            :         }
     652                 :            : 
     653         [ #  # ]:          0 :         if (req->rq_timeout == 0) {
     654                 :          0 :                 printk(KERN_WARNING "xprt_adjust_timeout: rq_timeout = 0!\n");
     655                 :          0 :                 req->rq_timeout = 5 * HZ;
     656                 :            :         }
     657                 :          0 :         return status;
     658                 :            : }
     659                 :            : 
     660                 :          0 : static void xprt_autoclose(struct work_struct *work)
     661                 :            : {
     662                 :          0 :         struct rpc_xprt *xprt =
     663                 :          0 :                 container_of(work, struct rpc_xprt, task_cleanup);
     664                 :          0 :         unsigned int pflags = memalloc_nofs_save();
     665                 :            : 
     666                 :          0 :         clear_bit(XPRT_CLOSE_WAIT, &xprt->state);
     667                 :          0 :         xprt->ops->close(xprt);
     668                 :          0 :         xprt_release_write(xprt, NULL);
     669                 :          0 :         wake_up_bit(&xprt->state, XPRT_LOCKED);
     670                 :          0 :         memalloc_nofs_restore(pflags);
     671                 :          0 : }
     672                 :            : 
     673                 :            : /**
     674                 :            :  * xprt_disconnect_done - mark a transport as disconnected
     675                 :            :  * @xprt: transport to flag for disconnect
     676                 :            :  *
     677                 :            :  */
     678                 :          0 : void xprt_disconnect_done(struct rpc_xprt *xprt)
     679                 :            : {
     680                 :          0 :         dprintk("RPC:       disconnected transport %p\n", xprt);
     681                 :          0 :         spin_lock(&xprt->transport_lock);
     682                 :          0 :         xprt_clear_connected(xprt);
     683                 :          0 :         xprt_clear_write_space_locked(xprt);
     684                 :          0 :         xprt_clear_congestion_window_wait_locked(xprt);
     685                 :          0 :         xprt_wake_pending_tasks(xprt, -ENOTCONN);
     686                 :          0 :         spin_unlock(&xprt->transport_lock);
     687                 :          0 : }
     688                 :            : EXPORT_SYMBOL_GPL(xprt_disconnect_done);
     689                 :            : 
     690                 :            : /**
     691                 :            :  * xprt_force_disconnect - force a transport to disconnect
     692                 :            :  * @xprt: transport to disconnect
     693                 :            :  *
     694                 :            :  */
     695                 :          0 : void xprt_force_disconnect(struct rpc_xprt *xprt)
     696                 :            : {
     697                 :            :         /* Don't race with the test_bit() in xprt_clear_locked() */
     698                 :          0 :         spin_lock(&xprt->transport_lock);
     699                 :          0 :         set_bit(XPRT_CLOSE_WAIT, &xprt->state);
     700                 :            :         /* Try to schedule an autoclose RPC call */
     701         [ #  # ]:          0 :         if (test_and_set_bit(XPRT_LOCKED, &xprt->state) == 0)
     702                 :          0 :                 queue_work(xprtiod_workqueue, &xprt->task_cleanup);
     703         [ #  # ]:          0 :         else if (xprt->snd_task)
     704                 :          0 :                 rpc_wake_up_queued_task_set_status(&xprt->pending,
     705                 :            :                                 xprt->snd_task, -ENOTCONN);
     706                 :          0 :         spin_unlock(&xprt->transport_lock);
     707                 :          0 : }
     708                 :            : EXPORT_SYMBOL_GPL(xprt_force_disconnect);
     709                 :            : 
     710                 :            : static unsigned int
     711                 :          0 : xprt_connect_cookie(struct rpc_xprt *xprt)
     712                 :            : {
     713                 :          0 :         return READ_ONCE(xprt->connect_cookie);
     714                 :            : }
     715                 :            : 
     716                 :            : static bool
     717                 :            : xprt_request_retransmit_after_disconnect(struct rpc_task *task)
     718                 :            : {
     719                 :            :         struct rpc_rqst *req = task->tk_rqstp;
     720                 :            :         struct rpc_xprt *xprt = req->rq_xprt;
     721                 :            : 
     722                 :            :         return req->rq_connect_cookie != xprt_connect_cookie(xprt) ||
     723                 :            :                 !xprt_connected(xprt);
     724                 :            : }
     725                 :            : 
     726                 :            : /**
     727                 :            :  * xprt_conditional_disconnect - force a transport to disconnect
     728                 :            :  * @xprt: transport to disconnect
     729                 :            :  * @cookie: 'connection cookie'
     730                 :            :  *
     731                 :            :  * This attempts to break the connection if and only if 'cookie' matches
     732                 :            :  * the current transport 'connection cookie'. It ensures that we don't
     733                 :            :  * try to break the connection more than once when we need to retransmit
     734                 :            :  * a batch of RPC requests.
     735                 :            :  *
     736                 :            :  */
     737                 :          0 : void xprt_conditional_disconnect(struct rpc_xprt *xprt, unsigned int cookie)
     738                 :            : {
     739                 :            :         /* Don't race with the test_bit() in xprt_clear_locked() */
     740                 :          0 :         spin_lock(&xprt->transport_lock);
     741         [ #  # ]:          0 :         if (cookie != xprt->connect_cookie)
     742                 :          0 :                 goto out;
     743         [ #  # ]:          0 :         if (test_bit(XPRT_CLOSING, &xprt->state))
     744                 :          0 :                 goto out;
     745                 :          0 :         set_bit(XPRT_CLOSE_WAIT, &xprt->state);
     746                 :            :         /* Try to schedule an autoclose RPC call */
     747         [ #  # ]:          0 :         if (test_and_set_bit(XPRT_LOCKED, &xprt->state) == 0)
     748                 :          0 :                 queue_work(xprtiod_workqueue, &xprt->task_cleanup);
     749                 :          0 :         xprt_wake_pending_tasks(xprt, -EAGAIN);
     750                 :          0 : out:
     751                 :          0 :         spin_unlock(&xprt->transport_lock);
     752                 :          0 : }
     753                 :            : 
     754                 :            : static bool
     755                 :          0 : xprt_has_timer(const struct rpc_xprt *xprt)
     756                 :            : {
     757                 :          0 :         return xprt->idle_timeout != 0;
     758                 :            : }
     759                 :            : 
     760                 :            : static void
     761                 :          0 : xprt_schedule_autodisconnect(struct rpc_xprt *xprt)
     762                 :            :         __must_hold(&xprt->transport_lock)
     763                 :            : {
     764                 :          0 :         xprt->last_used = jiffies;
     765   [ #  #  #  # ]:          0 :         if (RB_EMPTY_ROOT(&xprt->recv_queue) && xprt_has_timer(xprt))
     766                 :          0 :                 mod_timer(&xprt->timer, xprt->last_used + xprt->idle_timeout);
     767                 :          0 : }
     768                 :            : 
     769                 :            : static void
     770                 :          0 : xprt_init_autodisconnect(struct timer_list *t)
     771                 :            : {
     772                 :          0 :         struct rpc_xprt *xprt = from_timer(xprt, t, timer);
     773                 :            : 
     774         [ #  # ]:          0 :         if (!RB_EMPTY_ROOT(&xprt->recv_queue))
     775                 :            :                 return;
     776                 :            :         /* Reset xprt->last_used to avoid connect/autodisconnect cycling */
     777                 :          0 :         xprt->last_used = jiffies;
     778         [ #  # ]:          0 :         if (test_and_set_bit(XPRT_LOCKED, &xprt->state))
     779                 :            :                 return;
     780                 :          0 :         queue_work(xprtiod_workqueue, &xprt->task_cleanup);
     781                 :            : }
     782                 :            : 
     783                 :          0 : bool xprt_lock_connect(struct rpc_xprt *xprt,
     784                 :            :                 struct rpc_task *task,
     785                 :            :                 void *cookie)
     786                 :            : {
     787                 :          0 :         bool ret = false;
     788                 :            : 
     789                 :          0 :         spin_lock(&xprt->transport_lock);
     790         [ #  # ]:          0 :         if (!test_bit(XPRT_LOCKED, &xprt->state))
     791                 :          0 :                 goto out;
     792         [ #  # ]:          0 :         if (xprt->snd_task != task)
     793                 :          0 :                 goto out;
     794                 :          0 :         xprt->snd_task = cookie;
     795                 :          0 :         ret = true;
     796                 :          0 : out:
     797                 :          0 :         spin_unlock(&xprt->transport_lock);
     798                 :          0 :         return ret;
     799                 :            : }
     800                 :            : 
     801                 :          0 : void xprt_unlock_connect(struct rpc_xprt *xprt, void *cookie)
     802                 :            : {
     803                 :          0 :         spin_lock(&xprt->transport_lock);
     804         [ #  # ]:          0 :         if (xprt->snd_task != cookie)
     805                 :          0 :                 goto out;
     806         [ #  # ]:          0 :         if (!test_bit(XPRT_LOCKED, &xprt->state))
     807                 :          0 :                 goto out;
     808                 :          0 :         xprt->snd_task =NULL;
     809                 :          0 :         xprt->ops->release_xprt(xprt, NULL);
     810                 :          0 :         xprt_schedule_autodisconnect(xprt);
     811                 :          0 : out:
     812                 :          0 :         spin_unlock(&xprt->transport_lock);
     813                 :          0 :         wake_up_bit(&xprt->state, XPRT_LOCKED);
     814                 :          0 : }
     815                 :            : 
     816                 :            : /**
     817                 :            :  * xprt_connect - schedule a transport connect operation
     818                 :            :  * @task: RPC task that is requesting the connect
     819                 :            :  *
     820                 :            :  */
     821                 :          0 : void xprt_connect(struct rpc_task *task)
     822                 :            : {
     823                 :          0 :         struct rpc_xprt *xprt = task->tk_rqstp->rq_xprt;
     824                 :            : 
     825                 :          0 :         dprintk("RPC: %5u xprt_connect xprt %p %s connected\n", task->tk_pid,
     826                 :            :                         xprt, (xprt_connected(xprt) ? "is" : "is not"));
     827                 :            : 
     828         [ #  # ]:          0 :         if (!xprt_bound(xprt)) {
     829                 :          0 :                 task->tk_status = -EAGAIN;
     830                 :          0 :                 return;
     831                 :            :         }
     832         [ #  # ]:          0 :         if (!xprt_lock_write(xprt, task))
     833                 :            :                 return;
     834                 :            : 
     835         [ #  # ]:          0 :         if (test_and_clear_bit(XPRT_CLOSE_WAIT, &xprt->state))
     836                 :          0 :                 xprt->ops->close(xprt);
     837                 :            : 
     838         [ #  # ]:          0 :         if (!xprt_connected(xprt)) {
     839                 :          0 :                 task->tk_rqstp->rq_connect_cookie = xprt->connect_cookie;
     840                 :          0 :                 rpc_sleep_on_timeout(&xprt->pending, task, NULL,
     841         [ #  # ]:          0 :                                 xprt_request_timeout(task->tk_rqstp));
     842                 :            : 
     843         [ #  # ]:          0 :                 if (test_bit(XPRT_CLOSING, &xprt->state))
     844                 :            :                         return;
     845         [ #  # ]:          0 :                 if (xprt_test_and_set_connecting(xprt))
     846                 :            :                         return;
     847                 :            :                 /* Race breaker */
     848         [ #  # ]:          0 :                 if (!xprt_connected(xprt)) {
     849                 :          0 :                         xprt->stat.connect_start = jiffies;
     850                 :          0 :                         xprt->ops->connect(xprt, task);
     851                 :            :                 } else {
     852                 :          0 :                         xprt_clear_connecting(xprt);
     853                 :          0 :                         task->tk_status = 0;
     854                 :          0 :                         rpc_wake_up_queued_task(&xprt->pending, task);
     855                 :            :                 }
     856                 :            :         }
     857                 :          0 :         xprt_release_write(xprt, task);
     858                 :            : }
     859                 :            : 
     860                 :            : /**
     861                 :            :  * xprt_reconnect_delay - compute the wait before scheduling a connect
     862                 :            :  * @xprt: transport instance
     863                 :            :  *
     864                 :            :  */
     865                 :          0 : unsigned long xprt_reconnect_delay(const struct rpc_xprt *xprt)
     866                 :            : {
     867                 :          0 :         unsigned long start, now = jiffies;
     868                 :            : 
     869                 :          0 :         start = xprt->stat.connect_start + xprt->reestablish_timeout;
     870         [ #  # ]:          0 :         if (time_after(start, now))
     871                 :          0 :                 return start - now;
     872                 :            :         return 0;
     873                 :            : }
     874                 :            : EXPORT_SYMBOL_GPL(xprt_reconnect_delay);
     875                 :            : 
     876                 :            : /**
     877                 :            :  * xprt_reconnect_backoff - compute the new re-establish timeout
     878                 :            :  * @xprt: transport instance
     879                 :            :  * @init_to: initial reestablish timeout
     880                 :            :  *
     881                 :            :  */
     882                 :          0 : void xprt_reconnect_backoff(struct rpc_xprt *xprt, unsigned long init_to)
     883                 :            : {
     884                 :          0 :         xprt->reestablish_timeout <<= 1;
     885         [ #  # ]:          0 :         if (xprt->reestablish_timeout > xprt->max_reconnect_timeout)
     886                 :          0 :                 xprt->reestablish_timeout = xprt->max_reconnect_timeout;
     887         [ #  # ]:          0 :         if (xprt->reestablish_timeout < init_to)
     888                 :          0 :                 xprt->reestablish_timeout = init_to;
     889                 :          0 : }
     890                 :            : EXPORT_SYMBOL_GPL(xprt_reconnect_backoff);
     891                 :            : 
     892                 :            : enum xprt_xid_rb_cmp {
     893                 :            :         XID_RB_EQUAL,
     894                 :            :         XID_RB_LEFT,
     895                 :            :         XID_RB_RIGHT,
     896                 :            : };
     897                 :            : static enum xprt_xid_rb_cmp
     898                 :          0 : xprt_xid_cmp(__be32 xid1, __be32 xid2)
     899                 :            : {
     900                 :          0 :         if (xid1 == xid2)
     901                 :            :                 return XID_RB_EQUAL;
     902   [ #  #  #  # ]:          0 :         if ((__force u32)xid1 < (__force u32)xid2)
     903                 :          0 :                 return XID_RB_LEFT;
     904                 :            :         return XID_RB_RIGHT;
     905                 :            : }
     906                 :            : 
     907                 :            : static struct rpc_rqst *
     908                 :          0 : xprt_request_rb_find(struct rpc_xprt *xprt, __be32 xid)
     909                 :            : {
     910                 :          0 :         struct rb_node *n = xprt->recv_queue.rb_node;
     911                 :          0 :         struct rpc_rqst *req;
     912                 :            : 
     913         [ #  # ]:          0 :         while (n != NULL) {
     914                 :          0 :                 req = rb_entry(n, struct rpc_rqst, rq_recv);
     915         [ #  # ]:          0 :                 switch (xprt_xid_cmp(xid, req->rq_xid)) {
     916                 :            :                 case XID_RB_LEFT:
     917                 :          0 :                         n = n->rb_left;
     918                 :          0 :                         break;
     919                 :            :                 case XID_RB_RIGHT:
     920                 :          0 :                         n = n->rb_right;
     921                 :          0 :                         break;
     922                 :            :                 case XID_RB_EQUAL:
     923                 :            :                         return req;
     924                 :            :                 }
     925                 :            :         }
     926                 :            :         return NULL;
     927                 :            : }
     928                 :            : 
     929                 :            : static void
     930                 :          0 : xprt_request_rb_insert(struct rpc_xprt *xprt, struct rpc_rqst *new)
     931                 :            : {
     932                 :          0 :         struct rb_node **p = &xprt->recv_queue.rb_node;
     933                 :          0 :         struct rb_node *n = NULL;
     934                 :          0 :         struct rpc_rqst *req;
     935                 :            : 
     936         [ #  # ]:          0 :         while (*p != NULL) {
     937                 :          0 :                 n = *p;
     938                 :          0 :                 req = rb_entry(n, struct rpc_rqst, rq_recv);
     939   [ #  #  #  #  :          0 :                 switch(xprt_xid_cmp(new->rq_xid, req->rq_xid)) {
                      # ]
     940                 :          0 :                 case XID_RB_LEFT:
     941                 :          0 :                         p = &n->rb_left;
     942                 :          0 :                         break;
     943                 :          0 :                 case XID_RB_RIGHT:
     944                 :          0 :                         p = &n->rb_right;
     945                 :          0 :                         break;
     946                 :          0 :                 case XID_RB_EQUAL:
     947         [ #  # ]:          0 :                         WARN_ON_ONCE(new != req);
     948                 :            :                         return;
     949                 :            :                 }
     950                 :            :         }
     951                 :          0 :         rb_link_node(&new->rq_recv, n, p);
     952                 :          0 :         rb_insert_color(&new->rq_recv, &xprt->recv_queue);
     953                 :            : }
     954                 :            : 
     955                 :            : static void
     956                 :          0 : xprt_request_rb_remove(struct rpc_xprt *xprt, struct rpc_rqst *req)
     957                 :            : {
     958                 :          0 :         rb_erase(&req->rq_recv, &xprt->recv_queue);
     959                 :          0 : }
     960                 :            : 
     961                 :            : /**
     962                 :            :  * xprt_lookup_rqst - find an RPC request corresponding to an XID
     963                 :            :  * @xprt: transport on which the original request was transmitted
     964                 :            :  * @xid: RPC XID of incoming reply
     965                 :            :  *
     966                 :            :  * Caller holds xprt->queue_lock.
     967                 :            :  */
     968                 :          0 : struct rpc_rqst *xprt_lookup_rqst(struct rpc_xprt *xprt, __be32 xid)
     969                 :            : {
     970                 :          0 :         struct rpc_rqst *entry;
     971                 :            : 
     972                 :          0 :         entry = xprt_request_rb_find(xprt, xid);
     973         [ #  # ]:          0 :         if (entry != NULL) {
     974                 :          0 :                 trace_xprt_lookup_rqst(xprt, xid, 0);
     975                 :          0 :                 entry->rq_rtt = ktime_sub(ktime_get(), entry->rq_xtime);
     976                 :          0 :                 return entry;
     977                 :            :         }
     978                 :            : 
     979                 :          0 :         dprintk("RPC:       xprt_lookup_rqst did not find xid %08x\n",
     980                 :            :                         ntohl(xid));
     981                 :          0 :         trace_xprt_lookup_rqst(xprt, xid, -ENOENT);
     982                 :          0 :         xprt->stat.bad_xids++;
     983                 :          0 :         return NULL;
     984                 :            : }
     985                 :            : EXPORT_SYMBOL_GPL(xprt_lookup_rqst);
     986                 :            : 
     987                 :            : static bool
     988                 :          0 : xprt_is_pinned_rqst(struct rpc_rqst *req)
     989                 :            : {
     990                 :          0 :         return atomic_read(&req->rq_pin) != 0;
     991                 :            : }
     992                 :            : 
     993                 :            : /**
     994                 :            :  * xprt_pin_rqst - Pin a request on the transport receive list
     995                 :            :  * @req: Request to pin
     996                 :            :  *
     997                 :            :  * Caller must ensure this is atomic with the call to xprt_lookup_rqst()
     998                 :            :  * so should be holding xprt->queue_lock.
     999                 :            :  */
    1000                 :          0 : void xprt_pin_rqst(struct rpc_rqst *req)
    1001                 :            : {
    1002                 :          0 :         atomic_inc(&req->rq_pin);
    1003                 :          0 : }
    1004                 :            : EXPORT_SYMBOL_GPL(xprt_pin_rqst);
    1005                 :            : 
    1006                 :            : /**
    1007                 :            :  * xprt_unpin_rqst - Unpin a request on the transport receive list
    1008                 :            :  * @req: Request to pin
    1009                 :            :  *
    1010                 :            :  * Caller should be holding xprt->queue_lock.
    1011                 :            :  */
    1012                 :          0 : void xprt_unpin_rqst(struct rpc_rqst *req)
    1013                 :            : {
    1014         [ #  # ]:          0 :         if (!test_bit(RPC_TASK_MSG_PIN_WAIT, &req->rq_task->tk_runstate)) {
    1015                 :          0 :                 atomic_dec(&req->rq_pin);
    1016                 :          0 :                 return;
    1017                 :            :         }
    1018         [ #  # ]:          0 :         if (atomic_dec_and_test(&req->rq_pin))
    1019                 :          0 :                 wake_up_var(&req->rq_pin);
    1020                 :            : }
    1021                 :            : EXPORT_SYMBOL_GPL(xprt_unpin_rqst);
    1022                 :            : 
    1023                 :          0 : static void xprt_wait_on_pinned_rqst(struct rpc_rqst *req)
    1024                 :            : {
    1025   [ #  #  #  # ]:          0 :         wait_var_event(&req->rq_pin, !xprt_is_pinned_rqst(req));
    1026                 :          0 : }
    1027                 :            : 
    1028                 :            : static bool
    1029                 :          0 : xprt_request_data_received(struct rpc_task *task)
    1030                 :            : {
    1031   [ #  #  #  # ]:          0 :         return !test_bit(RPC_TASK_NEED_RECV, &task->tk_runstate) &&
    1032         [ #  # ]:          0 :                 READ_ONCE(task->tk_rqstp->rq_reply_bytes_recvd) != 0;
    1033                 :            : }
    1034                 :            : 
    1035                 :            : static bool
    1036                 :          0 : xprt_request_need_enqueue_receive(struct rpc_task *task, struct rpc_rqst *req)
    1037                 :            : {
    1038   [ #  #  #  # ]:          0 :         return !test_bit(RPC_TASK_NEED_RECV, &task->tk_runstate) &&
    1039         [ #  # ]:          0 :                 READ_ONCE(task->tk_rqstp->rq_reply_bytes_recvd) == 0;
    1040                 :            : }
    1041                 :            : 
    1042                 :            : /**
    1043                 :            :  * xprt_request_enqueue_receive - Add an request to the receive queue
    1044                 :            :  * @task: RPC task
    1045                 :            :  *
    1046                 :            :  */
    1047                 :            : void
    1048                 :          0 : xprt_request_enqueue_receive(struct rpc_task *task)
    1049                 :            : {
    1050                 :          0 :         struct rpc_rqst *req = task->tk_rqstp;
    1051                 :          0 :         struct rpc_xprt *xprt = req->rq_xprt;
    1052                 :            : 
    1053         [ #  # ]:          0 :         if (!xprt_request_need_enqueue_receive(task, req))
    1054                 :            :                 return;
    1055                 :            : 
    1056                 :          0 :         xprt_request_prepare(task->tk_rqstp);
    1057                 :          0 :         spin_lock(&xprt->queue_lock);
    1058                 :            : 
    1059                 :            :         /* Update the softirq receive buffer */
    1060                 :          0 :         memcpy(&req->rq_private_buf, &req->rq_rcv_buf,
    1061                 :            :                         sizeof(req->rq_private_buf));
    1062                 :            : 
    1063                 :            :         /* Add request to the receive list */
    1064                 :          0 :         xprt_request_rb_insert(xprt, req);
    1065                 :          0 :         set_bit(RPC_TASK_NEED_RECV, &task->tk_runstate);
    1066                 :          0 :         spin_unlock(&xprt->queue_lock);
    1067                 :            : 
    1068                 :            :         /* Turn off autodisconnect */
    1069                 :          0 :         del_singleshot_timer_sync(&xprt->timer);
    1070                 :            : }
    1071                 :            : 
    1072                 :            : /**
    1073                 :            :  * xprt_request_dequeue_receive_locked - Remove a request from the receive queue
    1074                 :            :  * @task: RPC task
    1075                 :            :  *
    1076                 :            :  * Caller must hold xprt->queue_lock.
    1077                 :            :  */
    1078                 :            : static void
    1079                 :          0 : xprt_request_dequeue_receive_locked(struct rpc_task *task)
    1080                 :            : {
    1081                 :          0 :         struct rpc_rqst *req = task->tk_rqstp;
    1082                 :            : 
    1083         [ #  # ]:          0 :         if (test_and_clear_bit(RPC_TASK_NEED_RECV, &task->tk_runstate))
    1084                 :          0 :                 xprt_request_rb_remove(req->rq_xprt, req);
    1085                 :          0 : }
    1086                 :            : 
    1087                 :            : /**
    1088                 :            :  * xprt_update_rtt - Update RPC RTT statistics
    1089                 :            :  * @task: RPC request that recently completed
    1090                 :            :  *
    1091                 :            :  * Caller holds xprt->queue_lock.
    1092                 :            :  */
    1093                 :          0 : void xprt_update_rtt(struct rpc_task *task)
    1094                 :            : {
    1095                 :          0 :         struct rpc_rqst *req = task->tk_rqstp;
    1096                 :          0 :         struct rpc_rtt *rtt = task->tk_client->cl_rtt;
    1097                 :          0 :         unsigned int timer = task->tk_msg.rpc_proc->p_timer;
    1098         [ #  # ]:          0 :         long m = usecs_to_jiffies(ktime_to_us(req->rq_rtt));
    1099                 :            : 
    1100         [ #  # ]:          0 :         if (timer) {
    1101         [ #  # ]:          0 :                 if (req->rq_ntrans == 1)
    1102                 :          0 :                         rpc_update_rtt(rtt, timer, m);
    1103         [ #  # ]:          0 :                 rpc_set_timeo(rtt, timer, req->rq_ntrans - 1);
    1104                 :            :         }
    1105                 :          0 : }
    1106                 :            : EXPORT_SYMBOL_GPL(xprt_update_rtt);
    1107                 :            : 
    1108                 :            : /**
    1109                 :            :  * xprt_complete_rqst - called when reply processing is complete
    1110                 :            :  * @task: RPC request that recently completed
    1111                 :            :  * @copied: actual number of bytes received from the transport
    1112                 :            :  *
    1113                 :            :  * Caller holds xprt->queue_lock.
    1114                 :            :  */
    1115                 :          0 : void xprt_complete_rqst(struct rpc_task *task, int copied)
    1116                 :            : {
    1117                 :          0 :         struct rpc_rqst *req = task->tk_rqstp;
    1118                 :          0 :         struct rpc_xprt *xprt = req->rq_xprt;
    1119                 :            : 
    1120                 :          0 :         dprintk("RPC: %5u xid %08x complete (%d bytes received)\n",
    1121                 :            :                         task->tk_pid, ntohl(req->rq_xid), copied);
    1122                 :          0 :         trace_xprt_complete_rqst(xprt, req->rq_xid, copied);
    1123                 :            : 
    1124                 :          0 :         xprt->stat.recvs++;
    1125                 :            : 
    1126                 :          0 :         req->rq_private_buf.len = copied;
    1127                 :            :         /* Ensure all writes are done before we update */
    1128                 :            :         /* req->rq_reply_bytes_recvd */
    1129                 :          0 :         smp_wmb();
    1130                 :          0 :         req->rq_reply_bytes_recvd = copied;
    1131                 :          0 :         xprt_request_dequeue_receive_locked(task);
    1132                 :          0 :         rpc_wake_up_queued_task(&xprt->pending, task);
    1133                 :          0 : }
    1134                 :            : EXPORT_SYMBOL_GPL(xprt_complete_rqst);
    1135                 :            : 
    1136                 :          0 : static void xprt_timer(struct rpc_task *task)
    1137                 :            : {
    1138                 :          0 :         struct rpc_rqst *req = task->tk_rqstp;
    1139                 :          0 :         struct rpc_xprt *xprt = req->rq_xprt;
    1140                 :            : 
    1141         [ #  # ]:          0 :         if (task->tk_status != -ETIMEDOUT)
    1142                 :            :                 return;
    1143                 :            : 
    1144                 :          0 :         trace_xprt_timer(xprt, req->rq_xid, task->tk_status);
    1145         [ #  # ]:          0 :         if (!req->rq_reply_bytes_recvd) {
    1146         [ #  # ]:          0 :                 if (xprt->ops->timer)
    1147                 :          0 :                         xprt->ops->timer(xprt, task);
    1148                 :            :         } else
    1149                 :          0 :                 task->tk_status = 0;
    1150                 :            : }
    1151                 :            : 
    1152                 :            : /**
    1153                 :            :  * xprt_wait_for_reply_request_def - wait for reply
    1154                 :            :  * @task: pointer to rpc_task
    1155                 :            :  *
    1156                 :            :  * Set a request's retransmit timeout based on the transport's
    1157                 :            :  * default timeout parameters.  Used by transports that don't adjust
    1158                 :            :  * the retransmit timeout based on round-trip time estimation,
    1159                 :            :  * and put the task to sleep on the pending queue.
    1160                 :            :  */
    1161                 :          0 : void xprt_wait_for_reply_request_def(struct rpc_task *task)
    1162                 :            : {
    1163                 :          0 :         struct rpc_rqst *req = task->tk_rqstp;
    1164                 :            : 
    1165         [ #  # ]:          0 :         rpc_sleep_on_timeout(&req->rq_xprt->pending, task, xprt_timer,
    1166                 :            :                         xprt_request_timeout(req));
    1167                 :          0 : }
    1168                 :            : EXPORT_SYMBOL_GPL(xprt_wait_for_reply_request_def);
    1169                 :            : 
    1170                 :            : /**
    1171                 :            :  * xprt_wait_for_reply_request_rtt - wait for reply using RTT estimator
    1172                 :            :  * @task: pointer to rpc_task
    1173                 :            :  *
    1174                 :            :  * Set a request's retransmit timeout using the RTT estimator,
    1175                 :            :  * and put the task to sleep on the pending queue.
    1176                 :            :  */
    1177                 :          0 : void xprt_wait_for_reply_request_rtt(struct rpc_task *task)
    1178                 :            : {
    1179                 :          0 :         int timer = task->tk_msg.rpc_proc->p_timer;
    1180                 :          0 :         struct rpc_clnt *clnt = task->tk_client;
    1181                 :          0 :         struct rpc_rtt *rtt = clnt->cl_rtt;
    1182                 :          0 :         struct rpc_rqst *req = task->tk_rqstp;
    1183                 :          0 :         unsigned long max_timeout = clnt->cl_timeout->to_maxval;
    1184                 :          0 :         unsigned long timeout;
    1185                 :            : 
    1186                 :          0 :         timeout = rpc_calc_rto(rtt, timer);
    1187         [ #  # ]:          0 :         timeout <<= rpc_ntimeo(rtt, timer) + req->rq_retries;
    1188         [ #  # ]:          0 :         if (timeout > max_timeout || timeout == 0)
    1189                 :          0 :                 timeout = max_timeout;
    1190                 :          0 :         rpc_sleep_on_timeout(&req->rq_xprt->pending, task, xprt_timer,
    1191                 :            :                         jiffies + timeout);
    1192                 :          0 : }
    1193                 :            : EXPORT_SYMBOL_GPL(xprt_wait_for_reply_request_rtt);
    1194                 :            : 
    1195                 :            : /**
    1196                 :            :  * xprt_request_wait_receive - wait for the reply to an RPC request
    1197                 :            :  * @task: RPC task about to send a request
    1198                 :            :  *
    1199                 :            :  */
    1200                 :          0 : void xprt_request_wait_receive(struct rpc_task *task)
    1201                 :            : {
    1202                 :          0 :         struct rpc_rqst *req = task->tk_rqstp;
    1203                 :          0 :         struct rpc_xprt *xprt = req->rq_xprt;
    1204                 :            : 
    1205         [ #  # ]:          0 :         if (!test_bit(RPC_TASK_NEED_RECV, &task->tk_runstate))
    1206                 :            :                 return;
    1207                 :            :         /*
    1208                 :            :          * Sleep on the pending queue if we're expecting a reply.
    1209                 :            :          * The spinlock ensures atomicity between the test of
    1210                 :            :          * req->rq_reply_bytes_recvd, and the call to rpc_sleep_on().
    1211                 :            :          */
    1212                 :          0 :         spin_lock(&xprt->queue_lock);
    1213         [ #  # ]:          0 :         if (test_bit(RPC_TASK_NEED_RECV, &task->tk_runstate)) {
    1214                 :          0 :                 xprt->ops->wait_for_reply_request(task);
    1215                 :            :                 /*
    1216                 :            :                  * Send an extra queue wakeup call if the
    1217                 :            :                  * connection was dropped in case the call to
    1218                 :            :                  * rpc_sleep_on() raced.
    1219                 :            :                  */
    1220         [ #  # ]:          0 :                 if (xprt_request_retransmit_after_disconnect(task))
    1221                 :          0 :                         rpc_wake_up_queued_task_set_status(&xprt->pending,
    1222                 :            :                                         task, -ENOTCONN);
    1223                 :            :         }
    1224                 :          0 :         spin_unlock(&xprt->queue_lock);
    1225                 :            : }
    1226                 :            : 
    1227                 :            : static bool
    1228                 :          0 : xprt_request_need_enqueue_transmit(struct rpc_task *task, struct rpc_rqst *req)
    1229                 :            : {
    1230                 :          0 :         return !test_bit(RPC_TASK_NEED_XMIT, &task->tk_runstate);
    1231                 :            : }
    1232                 :            : 
    1233                 :            : /**
    1234                 :            :  * xprt_request_enqueue_transmit - queue a task for transmission
    1235                 :            :  * @task: pointer to rpc_task
    1236                 :            :  *
    1237                 :            :  * Add a task to the transmission queue.
    1238                 :            :  */
    1239                 :            : void
    1240                 :          0 : xprt_request_enqueue_transmit(struct rpc_task *task)
    1241                 :            : {
    1242                 :          0 :         struct rpc_rqst *pos, *req = task->tk_rqstp;
    1243                 :          0 :         struct rpc_xprt *xprt = req->rq_xprt;
    1244                 :            : 
    1245         [ #  # ]:          0 :         if (xprt_request_need_enqueue_transmit(task, req)) {
    1246                 :          0 :                 req->rq_bytes_sent = 0;
    1247                 :          0 :                 spin_lock(&xprt->queue_lock);
    1248                 :            :                 /*
    1249                 :            :                  * Requests that carry congestion control credits are added
    1250                 :            :                  * to the head of the list to avoid starvation issues.
    1251                 :            :                  */
    1252         [ #  # ]:          0 :                 if (req->rq_cong) {
    1253                 :          0 :                         xprt_clear_congestion_window_wait(xprt);
    1254         [ #  # ]:          0 :                         list_for_each_entry(pos, &xprt->xmit_queue, rq_xmit) {
    1255         [ #  # ]:          0 :                                 if (pos->rq_cong)
    1256                 :          0 :                                         continue;
    1257                 :            :                                 /* Note: req is added _before_ pos */
    1258                 :          0 :                                 list_add_tail(&req->rq_xmit, &pos->rq_xmit);
    1259                 :          0 :                                 INIT_LIST_HEAD(&req->rq_xmit2);
    1260                 :          0 :                                 trace_xprt_enq_xmit(task, 1);
    1261                 :          0 :                                 goto out;
    1262                 :            :                         }
    1263         [ #  # ]:          0 :                 } else if (RPC_IS_SWAPPER(task)) {
    1264         [ #  # ]:          0 :                         list_for_each_entry(pos, &xprt->xmit_queue, rq_xmit) {
    1265   [ #  #  #  # ]:          0 :                                 if (pos->rq_cong || pos->rq_bytes_sent)
    1266                 :          0 :                                         continue;
    1267         [ #  # ]:          0 :                                 if (RPC_IS_SWAPPER(pos->rq_task))
    1268                 :          0 :                                         continue;
    1269                 :            :                                 /* Note: req is added _before_ pos */
    1270                 :          0 :                                 list_add_tail(&req->rq_xmit, &pos->rq_xmit);
    1271                 :          0 :                                 INIT_LIST_HEAD(&req->rq_xmit2);
    1272                 :          0 :                                 trace_xprt_enq_xmit(task, 2);
    1273                 :          0 :                                 goto out;
    1274                 :            :                         }
    1275         [ #  # ]:          0 :                 } else if (!req->rq_seqno) {
    1276         [ #  # ]:          0 :                         list_for_each_entry(pos, &xprt->xmit_queue, rq_xmit) {
    1277         [ #  # ]:          0 :                                 if (pos->rq_task->tk_owner != task->tk_owner)
    1278                 :          0 :                                         continue;
    1279                 :          0 :                                 list_add_tail(&req->rq_xmit2, &pos->rq_xmit2);
    1280                 :          0 :                                 INIT_LIST_HEAD(&req->rq_xmit);
    1281                 :          0 :                                 trace_xprt_enq_xmit(task, 3);
    1282                 :          0 :                                 goto out;
    1283                 :            :                         }
    1284                 :            :                 }
    1285                 :          0 :                 list_add_tail(&req->rq_xmit, &xprt->xmit_queue);
    1286                 :          0 :                 INIT_LIST_HEAD(&req->rq_xmit2);
    1287                 :          0 :                 trace_xprt_enq_xmit(task, 4);
    1288                 :          0 : out:
    1289                 :          0 :                 set_bit(RPC_TASK_NEED_XMIT, &task->tk_runstate);
    1290                 :          0 :                 spin_unlock(&xprt->queue_lock);
    1291                 :            :         }
    1292                 :          0 : }
    1293                 :            : 
    1294                 :            : /**
    1295                 :            :  * xprt_request_dequeue_transmit_locked - remove a task from the transmission queue
    1296                 :            :  * @task: pointer to rpc_task
    1297                 :            :  *
    1298                 :            :  * Remove a task from the transmission queue
    1299                 :            :  * Caller must hold xprt->queue_lock
    1300                 :            :  */
    1301                 :            : static void
    1302                 :          0 : xprt_request_dequeue_transmit_locked(struct rpc_task *task)
    1303                 :            : {
    1304                 :          0 :         struct rpc_rqst *req = task->tk_rqstp;
    1305                 :            : 
    1306         [ #  # ]:          0 :         if (!test_and_clear_bit(RPC_TASK_NEED_XMIT, &task->tk_runstate))
    1307                 :            :                 return;
    1308         [ #  # ]:          0 :         if (!list_empty(&req->rq_xmit)) {
    1309         [ #  # ]:          0 :                 list_del(&req->rq_xmit);
    1310         [ #  # ]:          0 :                 if (!list_empty(&req->rq_xmit2)) {
    1311                 :          0 :                         struct rpc_rqst *next = list_first_entry(&req->rq_xmit2,
    1312                 :            :                                         struct rpc_rqst, rq_xmit2);
    1313                 :          0 :                         list_del(&req->rq_xmit2);
    1314                 :          0 :                         list_add_tail(&next->rq_xmit, &next->rq_xprt->xmit_queue);
    1315                 :            :                 }
    1316                 :            :         } else
    1317                 :          0 :                 list_del(&req->rq_xmit2);
    1318                 :            : }
    1319                 :            : 
    1320                 :            : /**
    1321                 :            :  * xprt_request_dequeue_transmit - remove a task from the transmission queue
    1322                 :            :  * @task: pointer to rpc_task
    1323                 :            :  *
    1324                 :            :  * Remove a task from the transmission queue
    1325                 :            :  */
    1326                 :            : static void
    1327                 :          0 : xprt_request_dequeue_transmit(struct rpc_task *task)
    1328                 :            : {
    1329                 :          0 :         struct rpc_rqst *req = task->tk_rqstp;
    1330                 :          0 :         struct rpc_xprt *xprt = req->rq_xprt;
    1331                 :            : 
    1332                 :          0 :         spin_lock(&xprt->queue_lock);
    1333                 :          0 :         xprt_request_dequeue_transmit_locked(task);
    1334                 :          0 :         spin_unlock(&xprt->queue_lock);
    1335                 :          0 : }
    1336                 :            : 
    1337                 :            : /**
    1338                 :            :  * xprt_request_dequeue_xprt - remove a task from the transmit+receive queue
    1339                 :            :  * @task: pointer to rpc_task
    1340                 :            :  *
    1341                 :            :  * Remove a task from the transmit and receive queues, and ensure that
    1342                 :            :  * it is not pinned by the receive work item.
    1343                 :            :  */
    1344                 :            : void
    1345                 :          0 : xprt_request_dequeue_xprt(struct rpc_task *task)
    1346                 :            : {
    1347                 :          0 :         struct rpc_rqst *req = task->tk_rqstp;
    1348                 :          0 :         struct rpc_xprt *xprt = req->rq_xprt;
    1349                 :            : 
    1350   [ #  #  #  # ]:          0 :         if (test_bit(RPC_TASK_NEED_XMIT, &task->tk_runstate) ||
    1351         [ #  # ]:          0 :             test_bit(RPC_TASK_NEED_RECV, &task->tk_runstate) ||
    1352                 :            :             xprt_is_pinned_rqst(req)) {
    1353                 :          0 :                 spin_lock(&xprt->queue_lock);
    1354                 :          0 :                 xprt_request_dequeue_transmit_locked(task);
    1355                 :          0 :                 xprt_request_dequeue_receive_locked(task);
    1356         [ #  # ]:          0 :                 while (xprt_is_pinned_rqst(req)) {
    1357                 :          0 :                         set_bit(RPC_TASK_MSG_PIN_WAIT, &task->tk_runstate);
    1358                 :          0 :                         spin_unlock(&xprt->queue_lock);
    1359                 :          0 :                         xprt_wait_on_pinned_rqst(req);
    1360                 :          0 :                         spin_lock(&xprt->queue_lock);
    1361                 :          0 :                         clear_bit(RPC_TASK_MSG_PIN_WAIT, &task->tk_runstate);
    1362                 :            :                 }
    1363                 :          0 :                 spin_unlock(&xprt->queue_lock);
    1364                 :            :         }
    1365                 :          0 : }
    1366                 :            : 
    1367                 :            : /**
    1368                 :            :  * xprt_request_prepare - prepare an encoded request for transport
    1369                 :            :  * @req: pointer to rpc_rqst
    1370                 :            :  *
    1371                 :            :  * Calls into the transport layer to do whatever is needed to prepare
    1372                 :            :  * the request for transmission or receive.
    1373                 :            :  */
    1374                 :            : void
    1375                 :          0 : xprt_request_prepare(struct rpc_rqst *req)
    1376                 :            : {
    1377                 :          0 :         struct rpc_xprt *xprt = req->rq_xprt;
    1378                 :            : 
    1379   [ #  #  #  # ]:          0 :         if (xprt->ops->prepare_request)
    1380                 :          0 :                 xprt->ops->prepare_request(req);
    1381                 :          0 : }
    1382                 :            : 
    1383                 :            : /**
    1384                 :            :  * xprt_request_need_retransmit - Test if a task needs retransmission
    1385                 :            :  * @task: pointer to rpc_task
    1386                 :            :  *
    1387                 :            :  * Test for whether a connection breakage requires the task to retransmit
    1388                 :            :  */
    1389                 :            : bool
    1390                 :          0 : xprt_request_need_retransmit(struct rpc_task *task)
    1391                 :            : {
    1392                 :          0 :         return xprt_request_retransmit_after_disconnect(task);
    1393                 :            : }
    1394                 :            : 
    1395                 :            : /**
    1396                 :            :  * xprt_prepare_transmit - reserve the transport before sending a request
    1397                 :            :  * @task: RPC task about to send a request
    1398                 :            :  *
    1399                 :            :  */
    1400                 :          0 : bool xprt_prepare_transmit(struct rpc_task *task)
    1401                 :            : {
    1402                 :          0 :         struct rpc_rqst *req = task->tk_rqstp;
    1403                 :          0 :         struct rpc_xprt *xprt = req->rq_xprt;
    1404                 :            : 
    1405                 :          0 :         dprintk("RPC: %5u xprt_prepare_transmit\n", task->tk_pid);
    1406                 :            : 
    1407         [ #  # ]:          0 :         if (!xprt_lock_write(xprt, task)) {
    1408                 :            :                 /* Race breaker: someone may have transmitted us */
    1409         [ #  # ]:          0 :                 if (!test_bit(RPC_TASK_NEED_XMIT, &task->tk_runstate))
    1410                 :          0 :                         rpc_wake_up_queued_task_set_status(&xprt->sending,
    1411                 :            :                                         task, 0);
    1412                 :          0 :                 return false;
    1413                 :            : 
    1414                 :            :         }
    1415                 :            :         return true;
    1416                 :            : }
    1417                 :            : 
    1418                 :          0 : void xprt_end_transmit(struct rpc_task *task)
    1419                 :            : {
    1420                 :          0 :         xprt_release_write(task->tk_rqstp->rq_xprt, task);
    1421                 :          0 : }
    1422                 :            : 
    1423                 :            : /**
    1424                 :            :  * xprt_request_transmit - send an RPC request on a transport
    1425                 :            :  * @req: pointer to request to transmit
    1426                 :            :  * @snd_task: RPC task that owns the transport lock
    1427                 :            :  *
    1428                 :            :  * This performs the transmission of a single request.
    1429                 :            :  * Note that if the request is not the same as snd_task, then it
    1430                 :            :  * does need to be pinned.
    1431                 :            :  * Returns '0' on success.
    1432                 :            :  */
    1433                 :            : static int
    1434                 :            : xprt_request_transmit(struct rpc_rqst *req, struct rpc_task *snd_task)
    1435                 :            : {
    1436                 :            :         struct rpc_xprt *xprt = req->rq_xprt;
    1437                 :            :         struct rpc_task *task = req->rq_task;
    1438                 :            :         unsigned int connect_cookie;
    1439                 :            :         int is_retrans = RPC_WAS_SENT(task);
    1440                 :            :         int status;
    1441                 :            : 
    1442                 :            :         if (!req->rq_bytes_sent) {
    1443                 :            :                 if (xprt_request_data_received(task)) {
    1444                 :            :                         status = 0;
    1445                 :            :                         goto out_dequeue;
    1446                 :            :                 }
    1447                 :            :                 /* Verify that our message lies in the RPCSEC_GSS window */
    1448                 :            :                 if (rpcauth_xmit_need_reencode(task)) {
    1449                 :            :                         status = -EBADMSG;
    1450                 :            :                         goto out_dequeue;
    1451                 :            :                 }
    1452                 :            :                 if (RPC_SIGNALLED(task)) {
    1453                 :            :                         status = -ERESTARTSYS;
    1454                 :            :                         goto out_dequeue;
    1455                 :            :                 }
    1456                 :            :         }
    1457                 :            : 
    1458                 :            :         /*
    1459                 :            :          * Update req->rq_ntrans before transmitting to avoid races with
    1460                 :            :          * xprt_update_rtt(), which needs to know that it is recording a
    1461                 :            :          * reply to the first transmission.
    1462                 :            :          */
    1463                 :            :         req->rq_ntrans++;
    1464                 :            : 
    1465                 :            :         connect_cookie = xprt->connect_cookie;
    1466                 :            :         status = xprt->ops->send_request(req);
    1467                 :            :         if (status != 0) {
    1468                 :            :                 req->rq_ntrans--;
    1469                 :            :                 trace_xprt_transmit(req, status);
    1470                 :            :                 return status;
    1471                 :            :         }
    1472                 :            : 
    1473                 :            :         if (is_retrans)
    1474                 :            :                 task->tk_client->cl_stats->rpcretrans++;
    1475                 :            : 
    1476                 :            :         xprt_inject_disconnect(xprt);
    1477                 :            : 
    1478                 :            :         task->tk_flags |= RPC_TASK_SENT;
    1479                 :            :         spin_lock(&xprt->transport_lock);
    1480                 :            : 
    1481                 :            :         xprt->stat.sends++;
    1482                 :            :         xprt->stat.req_u += xprt->stat.sends - xprt->stat.recvs;
    1483                 :            :         xprt->stat.bklog_u += xprt->backlog.qlen;
    1484                 :            :         xprt->stat.sending_u += xprt->sending.qlen;
    1485                 :            :         xprt->stat.pending_u += xprt->pending.qlen;
    1486                 :            :         spin_unlock(&xprt->transport_lock);
    1487                 :            : 
    1488                 :            :         req->rq_connect_cookie = connect_cookie;
    1489                 :            : out_dequeue:
    1490                 :            :         trace_xprt_transmit(req, status);
    1491                 :            :         xprt_request_dequeue_transmit(task);
    1492                 :            :         rpc_wake_up_queued_task_set_status(&xprt->sending, task, status);
    1493                 :            :         return status;
    1494                 :            : }
    1495                 :            : 
    1496                 :            : /**
    1497                 :            :  * xprt_transmit - send an RPC request on a transport
    1498                 :            :  * @task: controlling RPC task
    1499                 :            :  *
    1500                 :            :  * Attempts to drain the transmit queue. On exit, either the transport
    1501                 :            :  * signalled an error that needs to be handled before transmission can
    1502                 :            :  * resume, or @task finished transmitting, and detected that it already
    1503                 :            :  * received a reply.
    1504                 :            :  */
    1505                 :            : void
    1506                 :          0 : xprt_transmit(struct rpc_task *task)
    1507                 :            : {
    1508                 :          0 :         struct rpc_rqst *next, *req = task->tk_rqstp;
    1509                 :          0 :         struct rpc_xprt *xprt = req->rq_xprt;
    1510                 :          0 :         int status;
    1511                 :            : 
    1512                 :          0 :         spin_lock(&xprt->queue_lock);
    1513         [ #  # ]:          0 :         while (!list_empty(&xprt->xmit_queue)) {
    1514                 :          0 :                 next = list_first_entry(&xprt->xmit_queue,
    1515                 :            :                                 struct rpc_rqst, rq_xmit);
    1516                 :          0 :                 xprt_pin_rqst(next);
    1517                 :          0 :                 spin_unlock(&xprt->queue_lock);
    1518                 :          0 :                 status = xprt_request_transmit(next, task);
    1519         [ #  # ]:          0 :                 if (status == -EBADMSG && next != req)
    1520                 :          0 :                         status = 0;
    1521                 :          0 :                 cond_resched();
    1522                 :          0 :                 spin_lock(&xprt->queue_lock);
    1523                 :          0 :                 xprt_unpin_rqst(next);
    1524         [ #  # ]:          0 :                 if (status == 0) {
    1525   [ #  #  #  # ]:          0 :                         if (!xprt_request_data_received(task) ||
    1526                 :            :                             test_bit(RPC_TASK_NEED_XMIT, &task->tk_runstate))
    1527                 :          0 :                                 continue;
    1528         [ #  # ]:          0 :                 } else if (test_bit(RPC_TASK_NEED_XMIT, &task->tk_runstate))
    1529                 :          0 :                         task->tk_status = status;
    1530                 :            :                 break;
    1531                 :            :         }
    1532                 :          0 :         spin_unlock(&xprt->queue_lock);
    1533                 :          0 : }
    1534                 :            : 
    1535                 :          0 : static void xprt_add_backlog(struct rpc_xprt *xprt, struct rpc_task *task)
    1536                 :            : {
    1537                 :          0 :         set_bit(XPRT_CONGESTED, &xprt->state);
    1538                 :          0 :         rpc_sleep_on(&xprt->backlog, task, NULL);
    1539                 :          0 : }
    1540                 :            : 
    1541                 :          0 : static void xprt_wake_up_backlog(struct rpc_xprt *xprt)
    1542                 :            : {
    1543         [ #  # ]:          0 :         if (rpc_wake_up_next(&xprt->backlog) == NULL)
    1544                 :          0 :                 clear_bit(XPRT_CONGESTED, &xprt->state);
    1545                 :          0 : }
    1546                 :            : 
    1547                 :          0 : static bool xprt_throttle_congested(struct rpc_xprt *xprt, struct rpc_task *task)
    1548                 :            : {
    1549                 :          0 :         bool ret = false;
    1550                 :            : 
    1551         [ #  # ]:          0 :         if (!test_bit(XPRT_CONGESTED, &xprt->state))
    1552                 :          0 :                 goto out;
    1553                 :          0 :         spin_lock(&xprt->reserve_lock);
    1554         [ #  # ]:          0 :         if (test_bit(XPRT_CONGESTED, &xprt->state)) {
    1555                 :          0 :                 rpc_sleep_on(&xprt->backlog, task, NULL);
    1556                 :          0 :                 ret = true;
    1557                 :            :         }
    1558                 :          0 :         spin_unlock(&xprt->reserve_lock);
    1559                 :          0 : out:
    1560                 :          0 :         return ret;
    1561                 :            : }
    1562                 :            : 
    1563                 :          0 : static struct rpc_rqst *xprt_dynamic_alloc_slot(struct rpc_xprt *xprt)
    1564                 :            : {
    1565         [ #  # ]:          0 :         struct rpc_rqst *req = ERR_PTR(-EAGAIN);
    1566                 :            : 
    1567         [ #  # ]:          0 :         if (xprt->num_reqs >= xprt->max_reqs)
    1568                 :          0 :                 goto out;
    1569                 :          0 :         ++xprt->num_reqs;
    1570                 :          0 :         spin_unlock(&xprt->reserve_lock);
    1571                 :          0 :         req = kzalloc(sizeof(struct rpc_rqst), GFP_NOFS);
    1572                 :          0 :         spin_lock(&xprt->reserve_lock);
    1573         [ #  # ]:          0 :         if (req != NULL)
    1574                 :          0 :                 goto out;
    1575                 :          0 :         --xprt->num_reqs;
    1576                 :          0 :         req = ERR_PTR(-ENOMEM);
    1577                 :          0 : out:
    1578                 :          0 :         return req;
    1579                 :            : }
    1580                 :            : 
    1581                 :          0 : static bool xprt_dynamic_free_slot(struct rpc_xprt *xprt, struct rpc_rqst *req)
    1582                 :            : {
    1583                 :          0 :         if (xprt->num_reqs > xprt->min_reqs) {
    1584                 :          0 :                 --xprt->num_reqs;
    1585                 :          0 :                 kfree(req);
    1586                 :          0 :                 return true;
    1587                 :            :         }
    1588                 :            :         return false;
    1589                 :            : }
    1590                 :            : 
    1591                 :          0 : void xprt_alloc_slot(struct rpc_xprt *xprt, struct rpc_task *task)
    1592                 :            : {
    1593                 :          0 :         struct rpc_rqst *req;
    1594                 :            : 
    1595                 :          0 :         spin_lock(&xprt->reserve_lock);
    1596         [ #  # ]:          0 :         if (!list_empty(&xprt->free)) {
    1597                 :          0 :                 req = list_entry(xprt->free.next, struct rpc_rqst, rq_list);
    1598                 :          0 :                 list_del(&req->rq_list);
    1599                 :          0 :                 goto out_init_req;
    1600                 :            :         }
    1601                 :          0 :         req = xprt_dynamic_alloc_slot(xprt);
    1602         [ #  # ]:          0 :         if (!IS_ERR(req))
    1603                 :          0 :                 goto out_init_req;
    1604      [ #  #  # ]:          0 :         switch (PTR_ERR(req)) {
    1605                 :          0 :         case -ENOMEM:
    1606                 :          0 :                 dprintk("RPC:       dynamic allocation of request slot "
    1607                 :            :                                 "failed! Retrying\n");
    1608                 :          0 :                 task->tk_status = -ENOMEM;
    1609                 :          0 :                 break;
    1610                 :            :         case -EAGAIN:
    1611                 :          0 :                 xprt_add_backlog(xprt, task);
    1612                 :          0 :                 dprintk("RPC:       waiting for request slot\n");
    1613                 :            :                 /* fall through */
    1614                 :          0 :         default:
    1615                 :          0 :                 task->tk_status = -EAGAIN;
    1616                 :            :         }
    1617                 :          0 :         spin_unlock(&xprt->reserve_lock);
    1618                 :            :         return;
    1619                 :          0 : out_init_req:
    1620                 :          0 :         xprt->stat.max_slots = max_t(unsigned int, xprt->stat.max_slots,
    1621                 :            :                                      xprt->num_reqs);
    1622                 :          0 :         spin_unlock(&xprt->reserve_lock);
    1623                 :            : 
    1624                 :          0 :         task->tk_status = 0;
    1625                 :          0 :         task->tk_rqstp = req;
    1626                 :            : }
    1627                 :            : EXPORT_SYMBOL_GPL(xprt_alloc_slot);
    1628                 :            : 
    1629                 :          0 : void xprt_free_slot(struct rpc_xprt *xprt, struct rpc_rqst *req)
    1630                 :            : {
    1631                 :          0 :         spin_lock(&xprt->reserve_lock);
    1632         [ #  # ]:          0 :         if (!xprt_dynamic_free_slot(xprt, req)) {
    1633                 :          0 :                 memset(req, 0, sizeof(*req));   /* mark unused */
    1634                 :          0 :                 list_add(&req->rq_list, &xprt->free);
    1635                 :            :         }
    1636                 :          0 :         xprt_wake_up_backlog(xprt);
    1637                 :          0 :         spin_unlock(&xprt->reserve_lock);
    1638                 :          0 : }
    1639                 :            : EXPORT_SYMBOL_GPL(xprt_free_slot);
    1640                 :            : 
    1641                 :          0 : static void xprt_free_all_slots(struct rpc_xprt *xprt)
    1642                 :            : {
    1643                 :          0 :         struct rpc_rqst *req;
    1644         [ #  # ]:          0 :         while (!list_empty(&xprt->free)) {
    1645                 :          0 :                 req = list_first_entry(&xprt->free, struct rpc_rqst, rq_list);
    1646                 :          0 :                 list_del(&req->rq_list);
    1647                 :          0 :                 kfree(req);
    1648                 :            :         }
    1649                 :          0 : }
    1650                 :            : 
    1651                 :          0 : struct rpc_xprt *xprt_alloc(struct net *net, size_t size,
    1652                 :            :                 unsigned int num_prealloc,
    1653                 :            :                 unsigned int max_alloc)
    1654                 :            : {
    1655                 :          0 :         struct rpc_xprt *xprt;
    1656                 :          0 :         struct rpc_rqst *req;
    1657                 :          0 :         int i;
    1658                 :            : 
    1659                 :          0 :         xprt = kzalloc(size, GFP_KERNEL);
    1660         [ #  # ]:          0 :         if (xprt == NULL)
    1661                 :          0 :                 goto out;
    1662                 :            : 
    1663                 :          0 :         xprt_init(xprt, net);
    1664                 :            : 
    1665         [ #  # ]:          0 :         for (i = 0; i < num_prealloc; i++) {
    1666                 :          0 :                 req = kzalloc(sizeof(struct rpc_rqst), GFP_KERNEL);
    1667         [ #  # ]:          0 :                 if (!req)
    1668                 :          0 :                         goto out_free;
    1669                 :          0 :                 list_add(&req->rq_list, &xprt->free);
    1670                 :            :         }
    1671         [ #  # ]:          0 :         if (max_alloc > num_prealloc)
    1672                 :          0 :                 xprt->max_reqs = max_alloc;
    1673                 :            :         else
    1674                 :          0 :                 xprt->max_reqs = num_prealloc;
    1675                 :          0 :         xprt->min_reqs = num_prealloc;
    1676                 :          0 :         xprt->num_reqs = num_prealloc;
    1677                 :            : 
    1678                 :          0 :         return xprt;
    1679                 :            : 
    1680                 :            : out_free:
    1681                 :          0 :         xprt_free(xprt);
    1682                 :            : out:
    1683                 :            :         return NULL;
    1684                 :            : }
    1685                 :            : EXPORT_SYMBOL_GPL(xprt_alloc);
    1686                 :            : 
    1687                 :          0 : void xprt_free(struct rpc_xprt *xprt)
    1688                 :            : {
    1689                 :          0 :         put_net(xprt->xprt_net);
    1690                 :          0 :         xprt_free_all_slots(xprt);
    1691         [ #  # ]:          0 :         kfree_rcu(xprt, rcu);
    1692                 :          0 : }
    1693                 :            : EXPORT_SYMBOL_GPL(xprt_free);
    1694                 :            : 
    1695                 :            : static void
    1696                 :          0 : xprt_init_connect_cookie(struct rpc_rqst *req, struct rpc_xprt *xprt)
    1697                 :            : {
    1698                 :          0 :         req->rq_connect_cookie = xprt_connect_cookie(xprt) - 1;
    1699                 :            : }
    1700                 :            : 
    1701                 :            : static __be32
    1702                 :          0 : xprt_alloc_xid(struct rpc_xprt *xprt)
    1703                 :            : {
    1704                 :          0 :         __be32 xid;
    1705                 :            : 
    1706                 :          0 :         spin_lock(&xprt->reserve_lock);
    1707                 :          0 :         xid = (__force __be32)xprt->xid++;
    1708                 :          0 :         spin_unlock(&xprt->reserve_lock);
    1709                 :          0 :         return xid;
    1710                 :            : }
    1711                 :            : 
    1712                 :            : static void
    1713                 :          0 : xprt_init_xid(struct rpc_xprt *xprt)
    1714                 :            : {
    1715                 :          0 :         xprt->xid = prandom_u32();
    1716                 :            : }
    1717                 :            : 
    1718                 :            : static void
    1719                 :          0 : xprt_request_init(struct rpc_task *task)
    1720                 :            : {
    1721                 :          0 :         struct rpc_xprt *xprt = task->tk_xprt;
    1722                 :          0 :         struct rpc_rqst *req = task->tk_rqstp;
    1723                 :            : 
    1724                 :          0 :         req->rq_task = task;
    1725                 :          0 :         req->rq_xprt    = xprt;
    1726                 :          0 :         req->rq_buffer  = NULL;
    1727                 :          0 :         req->rq_xid  = xprt_alloc_xid(xprt);
    1728                 :          0 :         xprt_init_connect_cookie(req, xprt);
    1729                 :          0 :         req->rq_snd_buf.len = 0;
    1730                 :          0 :         req->rq_snd_buf.buflen = 0;
    1731                 :          0 :         req->rq_rcv_buf.len = 0;
    1732                 :          0 :         req->rq_rcv_buf.buflen = 0;
    1733                 :          0 :         req->rq_snd_buf.bvec = NULL;
    1734                 :          0 :         req->rq_rcv_buf.bvec = NULL;
    1735                 :          0 :         req->rq_release_snd_buf = NULL;
    1736                 :          0 :         xprt_init_majortimeo(task, req);
    1737                 :          0 :         dprintk("RPC: %5u reserved req %p xid %08x\n", task->tk_pid,
    1738                 :            :                         req, ntohl(req->rq_xid));
    1739                 :          0 : }
    1740                 :            : 
    1741                 :            : static void
    1742                 :          0 : xprt_do_reserve(struct rpc_xprt *xprt, struct rpc_task *task)
    1743                 :            : {
    1744                 :          0 :         xprt->ops->alloc_slot(xprt, task);
    1745         [ #  # ]:          0 :         if (task->tk_rqstp != NULL)
    1746                 :          0 :                 xprt_request_init(task);
    1747                 :          0 : }
    1748                 :            : 
    1749                 :            : /**
    1750                 :            :  * xprt_reserve - allocate an RPC request slot
    1751                 :            :  * @task: RPC task requesting a slot allocation
    1752                 :            :  *
    1753                 :            :  * If the transport is marked as being congested, or if no more
    1754                 :            :  * slots are available, place the task on the transport's
    1755                 :            :  * backlog queue.
    1756                 :            :  */
    1757                 :          0 : void xprt_reserve(struct rpc_task *task)
    1758                 :            : {
    1759                 :          0 :         struct rpc_xprt *xprt = task->tk_xprt;
    1760                 :            : 
    1761                 :          0 :         task->tk_status = 0;
    1762         [ #  # ]:          0 :         if (task->tk_rqstp != NULL)
    1763                 :            :                 return;
    1764                 :            : 
    1765                 :          0 :         task->tk_status = -EAGAIN;
    1766         [ #  # ]:          0 :         if (!xprt_throttle_congested(xprt, task))
    1767                 :          0 :                 xprt_do_reserve(xprt, task);
    1768                 :            : }
    1769                 :            : 
    1770                 :            : /**
    1771                 :            :  * xprt_retry_reserve - allocate an RPC request slot
    1772                 :            :  * @task: RPC task requesting a slot allocation
    1773                 :            :  *
    1774                 :            :  * If no more slots are available, place the task on the transport's
    1775                 :            :  * backlog queue.
    1776                 :            :  * Note that the only difference with xprt_reserve is that we now
    1777                 :            :  * ignore the value of the XPRT_CONGESTED flag.
    1778                 :            :  */
    1779                 :          0 : void xprt_retry_reserve(struct rpc_task *task)
    1780                 :            : {
    1781                 :          0 :         struct rpc_xprt *xprt = task->tk_xprt;
    1782                 :            : 
    1783                 :          0 :         task->tk_status = 0;
    1784         [ #  # ]:          0 :         if (task->tk_rqstp != NULL)
    1785                 :            :                 return;
    1786                 :            : 
    1787                 :          0 :         task->tk_status = -EAGAIN;
    1788                 :          0 :         xprt_do_reserve(xprt, task);
    1789                 :            : }
    1790                 :            : 
    1791                 :            : /**
    1792                 :            :  * xprt_release - release an RPC request slot
    1793                 :            :  * @task: task which is finished with the slot
    1794                 :            :  *
    1795                 :            :  */
    1796                 :          0 : void xprt_release(struct rpc_task *task)
    1797                 :            : {
    1798                 :          0 :         struct rpc_xprt *xprt;
    1799                 :          0 :         struct rpc_rqst *req = task->tk_rqstp;
    1800                 :            : 
    1801         [ #  # ]:          0 :         if (req == NULL) {
    1802         [ #  # ]:          0 :                 if (task->tk_client) {
    1803                 :          0 :                         xprt = task->tk_xprt;
    1804                 :          0 :                         xprt_release_write(xprt, task);
    1805                 :            :                 }
    1806                 :          0 :                 return;
    1807                 :            :         }
    1808                 :            : 
    1809                 :          0 :         xprt = req->rq_xprt;
    1810                 :          0 :         xprt_request_dequeue_xprt(task);
    1811                 :          0 :         spin_lock(&xprt->transport_lock);
    1812                 :          0 :         xprt->ops->release_xprt(xprt, task);
    1813         [ #  # ]:          0 :         if (xprt->ops->release_request)
    1814                 :          0 :                 xprt->ops->release_request(task);
    1815                 :          0 :         xprt_schedule_autodisconnect(xprt);
    1816                 :          0 :         spin_unlock(&xprt->transport_lock);
    1817         [ #  # ]:          0 :         if (req->rq_buffer)
    1818                 :          0 :                 xprt->ops->buf_free(task);
    1819                 :          0 :         xprt_inject_disconnect(xprt);
    1820                 :          0 :         xdr_free_bvec(&req->rq_rcv_buf);
    1821                 :          0 :         xdr_free_bvec(&req->rq_snd_buf);
    1822         [ #  # ]:          0 :         if (req->rq_cred != NULL)
    1823                 :          0 :                 put_rpccred(req->rq_cred);
    1824                 :          0 :         task->tk_rqstp = NULL;
    1825         [ #  # ]:          0 :         if (req->rq_release_snd_buf)
    1826                 :          0 :                 req->rq_release_snd_buf(req);
    1827                 :            : 
    1828                 :          0 :         dprintk("RPC: %5u release request %p\n", task->tk_pid, req);
    1829                 :          0 :         if (likely(!bc_prealloc(req)))
    1830                 :          0 :                 xprt->ops->free_slot(xprt, req);
    1831                 :            :         else
    1832                 :            :                 xprt_free_bc_request(req);
    1833                 :            : }
    1834                 :            : 
    1835                 :            : #ifdef CONFIG_SUNRPC_BACKCHANNEL
    1836                 :            : void
    1837                 :            : xprt_init_bc_request(struct rpc_rqst *req, struct rpc_task *task)
    1838                 :            : {
    1839                 :            :         struct xdr_buf *xbufp = &req->rq_snd_buf;
    1840                 :            : 
    1841                 :            :         task->tk_rqstp = req;
    1842                 :            :         req->rq_task = task;
    1843                 :            :         xprt_init_connect_cookie(req, req->rq_xprt);
    1844                 :            :         /*
    1845                 :            :          * Set up the xdr_buf length.
    1846                 :            :          * This also indicates that the buffer is XDR encoded already.
    1847                 :            :          */
    1848                 :            :         xbufp->len = xbufp->head[0].iov_len + xbufp->page_len +
    1849                 :            :                 xbufp->tail[0].iov_len;
    1850                 :            : }
    1851                 :            : #endif
    1852                 :            : 
    1853                 :          0 : static void xprt_init(struct rpc_xprt *xprt, struct net *net)
    1854                 :            : {
    1855                 :          0 :         kref_init(&xprt->kref);
    1856                 :            : 
    1857                 :          0 :         spin_lock_init(&xprt->transport_lock);
    1858                 :          0 :         spin_lock_init(&xprt->reserve_lock);
    1859                 :          0 :         spin_lock_init(&xprt->queue_lock);
    1860                 :            : 
    1861                 :          0 :         INIT_LIST_HEAD(&xprt->free);
    1862                 :          0 :         xprt->recv_queue = RB_ROOT;
    1863                 :          0 :         INIT_LIST_HEAD(&xprt->xmit_queue);
    1864                 :            : #if defined(CONFIG_SUNRPC_BACKCHANNEL)
    1865                 :            :         spin_lock_init(&xprt->bc_pa_lock);
    1866                 :            :         INIT_LIST_HEAD(&xprt->bc_pa_list);
    1867                 :            : #endif /* CONFIG_SUNRPC_BACKCHANNEL */
    1868                 :          0 :         INIT_LIST_HEAD(&xprt->xprt_switch);
    1869                 :            : 
    1870                 :          0 :         xprt->last_used = jiffies;
    1871                 :          0 :         xprt->cwnd = RPC_INITCWND;
    1872                 :          0 :         xprt->bind_index = 0;
    1873                 :            : 
    1874                 :          0 :         rpc_init_wait_queue(&xprt->binding, "xprt_binding");
    1875                 :          0 :         rpc_init_wait_queue(&xprt->pending, "xprt_pending");
    1876                 :          0 :         rpc_init_wait_queue(&xprt->sending, "xprt_sending");
    1877                 :          0 :         rpc_init_priority_wait_queue(&xprt->backlog, "xprt_backlog");
    1878                 :            : 
    1879                 :          0 :         xprt_init_xid(xprt);
    1880                 :            : 
    1881                 :          0 :         xprt->xprt_net = get_net(net);
    1882                 :          0 : }
    1883                 :            : 
    1884                 :            : /**
    1885                 :            :  * xprt_create_transport - create an RPC transport
    1886                 :            :  * @args: rpc transport creation arguments
    1887                 :            :  *
    1888                 :            :  */
    1889                 :          0 : struct rpc_xprt *xprt_create_transport(struct xprt_create *args)
    1890                 :            : {
    1891                 :          0 :         struct rpc_xprt *xprt;
    1892                 :          0 :         struct xprt_class *t;
    1893                 :            : 
    1894                 :          0 :         spin_lock(&xprt_list_lock);
    1895         [ #  # ]:          0 :         list_for_each_entry(t, &xprt_list, list) {
    1896         [ #  # ]:          0 :                 if (t->ident == args->ident) {
    1897                 :          0 :                         spin_unlock(&xprt_list_lock);
    1898                 :          0 :                         goto found;
    1899                 :            :                 }
    1900                 :            :         }
    1901                 :          0 :         spin_unlock(&xprt_list_lock);
    1902                 :          0 :         dprintk("RPC: transport (%d) not supported\n", args->ident);
    1903                 :          0 :         return ERR_PTR(-EIO);
    1904                 :            : 
    1905                 :            : found:
    1906                 :          0 :         xprt = t->setup(args);
    1907         [ #  # ]:          0 :         if (IS_ERR(xprt)) {
    1908                 :          0 :                 dprintk("RPC:       xprt_create_transport: failed, %ld\n",
    1909                 :            :                                 -PTR_ERR(xprt));
    1910                 :          0 :                 goto out;
    1911                 :            :         }
    1912         [ #  # ]:          0 :         if (args->flags & XPRT_CREATE_NO_IDLE_TIMEOUT)
    1913                 :          0 :                 xprt->idle_timeout = 0;
    1914         [ #  # ]:          0 :         INIT_WORK(&xprt->task_cleanup, xprt_autoclose);
    1915         [ #  # ]:          0 :         if (xprt_has_timer(xprt))
    1916                 :          0 :                 timer_setup(&xprt->timer, xprt_init_autodisconnect, 0);
    1917                 :            :         else
    1918                 :          0 :                 timer_setup(&xprt->timer, NULL, 0);
    1919                 :            : 
    1920         [ #  # ]:          0 :         if (strlen(args->servername) > RPC_MAXNETNAMELEN) {
    1921                 :          0 :                 xprt_destroy(xprt);
    1922                 :          0 :                 return ERR_PTR(-EINVAL);
    1923                 :            :         }
    1924                 :          0 :         xprt->servername = kstrdup(args->servername, GFP_KERNEL);
    1925         [ #  # ]:          0 :         if (xprt->servername == NULL) {
    1926                 :          0 :                 xprt_destroy(xprt);
    1927                 :          0 :                 return ERR_PTR(-ENOMEM);
    1928                 :            :         }
    1929                 :            : 
    1930                 :            :         rpc_xprt_debugfs_register(xprt);
    1931                 :            : 
    1932                 :            :         dprintk("RPC:       created transport %p with %u slots\n", xprt,
    1933                 :            :                         xprt->max_reqs);
    1934                 :            : out:
    1935                 :            :         return xprt;
    1936                 :            : }
    1937                 :            : 
    1938                 :          0 : static void xprt_destroy_cb(struct work_struct *work)
    1939                 :            : {
    1940                 :          0 :         struct rpc_xprt *xprt =
    1941                 :          0 :                 container_of(work, struct rpc_xprt, task_cleanup);
    1942                 :            : 
    1943                 :          0 :         rpc_xprt_debugfs_unregister(xprt);
    1944                 :          0 :         rpc_destroy_wait_queue(&xprt->binding);
    1945                 :          0 :         rpc_destroy_wait_queue(&xprt->pending);
    1946                 :          0 :         rpc_destroy_wait_queue(&xprt->sending);
    1947                 :          0 :         rpc_destroy_wait_queue(&xprt->backlog);
    1948                 :          0 :         kfree(xprt->servername);
    1949                 :            :         /*
    1950                 :            :          * Destroy any existing back channel
    1951                 :            :          */
    1952                 :          0 :         xprt_destroy_backchannel(xprt, UINT_MAX);
    1953                 :            : 
    1954                 :            :         /*
    1955                 :            :          * Tear down transport state and free the rpc_xprt
    1956                 :            :          */
    1957                 :          0 :         xprt->ops->destroy(xprt);
    1958                 :          0 : }
    1959                 :            : 
    1960                 :            : /**
    1961                 :            :  * xprt_destroy - destroy an RPC transport, killing off all requests.
    1962                 :            :  * @xprt: transport to destroy
    1963                 :            :  *
    1964                 :            :  */
    1965                 :          0 : static void xprt_destroy(struct rpc_xprt *xprt)
    1966                 :            : {
    1967                 :          0 :         dprintk("RPC:       destroying transport %p\n", xprt);
    1968                 :            : 
    1969                 :            :         /*
    1970                 :            :          * Exclude transport connect/disconnect handlers and autoclose
    1971                 :            :          */
    1972                 :          0 :         wait_on_bit_lock(&xprt->state, XPRT_LOCKED, TASK_UNINTERRUPTIBLE);
    1973                 :            : 
    1974                 :          0 :         del_timer_sync(&xprt->timer);
    1975                 :            : 
    1976                 :            :         /*
    1977                 :            :          * Destroy sockets etc from the system workqueue so they can
    1978                 :            :          * safely flush receive work running on rpciod.
    1979                 :            :          */
    1980                 :          0 :         INIT_WORK(&xprt->task_cleanup, xprt_destroy_cb);
    1981                 :          0 :         schedule_work(&xprt->task_cleanup);
    1982                 :          0 : }
    1983                 :            : 
    1984                 :          0 : static void xprt_destroy_kref(struct kref *kref)
    1985                 :            : {
    1986                 :          0 :         xprt_destroy(container_of(kref, struct rpc_xprt, kref));
    1987                 :          0 : }
    1988                 :            : 
    1989                 :            : /**
    1990                 :            :  * xprt_get - return a reference to an RPC transport.
    1991                 :            :  * @xprt: pointer to the transport
    1992                 :            :  *
    1993                 :            :  */
    1994                 :          0 : struct rpc_xprt *xprt_get(struct rpc_xprt *xprt)
    1995                 :            : {
    1996   [ #  #  #  # ]:          0 :         if (xprt != NULL && kref_get_unless_zero(&xprt->kref))
    1997                 :          0 :                 return xprt;
    1998                 :            :         return NULL;
    1999                 :            : }
    2000                 :            : EXPORT_SYMBOL_GPL(xprt_get);
    2001                 :            : 
    2002                 :            : /**
    2003                 :            :  * xprt_put - release a reference to an RPC transport.
    2004                 :            :  * @xprt: pointer to the transport
    2005                 :            :  *
    2006                 :            :  */
    2007                 :          0 : void xprt_put(struct rpc_xprt *xprt)
    2008                 :            : {
    2009         [ #  # ]:          0 :         if (xprt != NULL)
    2010                 :          0 :                 kref_put(&xprt->kref, xprt_destroy_kref);
    2011                 :          0 : }
    2012                 :            : EXPORT_SYMBOL_GPL(xprt_put);

Generated by: LCOV version 1.14