Branch data     Line data    Source code

       1                 :            : /* SPDX-License-Identifier: GPL-2.0 */
       2                 :            : /*
       3                 :            :  *  linux/include/linux/sunrpc/xprt.h
       4                 :            :  *
       5                 :            :  *  Declarations for the RPC transport interface.
       6                 :            :  *
       7                 :            :  *  Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de>
       8                 :            :  */
       9                 :            : 
      10                 :            : #ifndef _LINUX_SUNRPC_XPRT_H
      11                 :            : #define _LINUX_SUNRPC_XPRT_H
      12                 :            : 
      13                 :            : #include <linux/uio.h>
      14                 :            : #include <linux/socket.h>
      15                 :            : #include <linux/in.h>
      16                 :            : #include <linux/ktime.h>
      17                 :            : #include <linux/kref.h>
      18                 :            : #include <linux/sunrpc/sched.h>
      19                 :            : #include <linux/sunrpc/xdr.h>
      20                 :            : #include <linux/sunrpc/msg_prot.h>
      21                 :            : 
      22                 :            : #ifdef __KERNEL__
      23                 :            : 
      24                 :            : #define RPC_MIN_SLOT_TABLE      (2U)
      25                 :            : #define RPC_DEF_SLOT_TABLE      (16U)
      26                 :            : #define RPC_MAX_SLOT_TABLE_LIMIT        (65536U)
      27                 :            : #define RPC_MAX_SLOT_TABLE      RPC_MAX_SLOT_TABLE_LIMIT
      28                 :            : 
      29                 :            : #define RPC_CWNDSHIFT           (8U)
      30                 :            : #define RPC_CWNDSCALE           (1U << RPC_CWNDSHIFT)
      31                 :            : #define RPC_INITCWND            RPC_CWNDSCALE
      32                 :            : #define RPC_MAXCWND(xprt)       ((xprt)->max_reqs << RPC_CWNDSHIFT)
      33                 :            : #define RPCXPRT_CONGESTED(xprt) ((xprt)->cong >= (xprt)->cwnd)
      34                 :            : 
      35                 :            : /*
      36                 :            :  * This describes a timeout strategy
      37                 :            :  */
      38                 :            : struct rpc_timeout {
      39                 :            :         unsigned long           to_initval,             /* initial timeout */
      40                 :            :                                 to_maxval,              /* max timeout */
      41                 :            :                                 to_increment;           /* if !exponential */
      42                 :            :         unsigned int            to_retries;             /* max # of retries */
      43                 :            :         unsigned char           to_exponential;
      44                 :            : };
      45                 :            : 
      46                 :            : enum rpc_display_format_t {
      47                 :            :         RPC_DISPLAY_ADDR = 0,
      48                 :            :         RPC_DISPLAY_PORT,
      49                 :            :         RPC_DISPLAY_PROTO,
      50                 :            :         RPC_DISPLAY_HEX_ADDR,
      51                 :            :         RPC_DISPLAY_HEX_PORT,
      52                 :            :         RPC_DISPLAY_NETID,
      53                 :            :         RPC_DISPLAY_MAX,
      54                 :            : };
      55                 :            : 
      56                 :            : struct rpc_task;
      57                 :            : struct rpc_xprt;
      58                 :            : struct seq_file;
      59                 :            : struct svc_serv;
      60                 :            : struct net;
      61                 :            : 
      62                 :            : /*
      63                 :            :  * This describes a complete RPC request
      64                 :            :  */
      65                 :            : struct rpc_rqst {
      66                 :            :         /*
      67                 :            :          * This is the user-visible part
      68                 :            :          */
      69                 :            :         struct rpc_xprt *       rq_xprt;                /* RPC client */
      70                 :            :         struct xdr_buf          rq_snd_buf;             /* send buffer */
      71                 :            :         struct xdr_buf          rq_rcv_buf;             /* recv buffer */
      72                 :            : 
      73                 :            :         /*
      74                 :            :          * This is the private part
      75                 :            :          */
      76                 :            :         struct rpc_task *       rq_task;        /* RPC task data */
      77                 :            :         struct rpc_cred *       rq_cred;        /* Bound cred */
      78                 :            :         __be32                  rq_xid;         /* request XID */
      79                 :            :         int                     rq_cong;        /* has incremented xprt->cong */
      80                 :            :         u32                     rq_seqno;       /* gss seq no. used on req. */
      81                 :            :         int                     rq_enc_pages_num;
      82                 :            :         struct page             **rq_enc_pages; /* scratch pages for use by
      83                 :            :                                                    gss privacy code */
      84                 :            :         void (*rq_release_snd_buf)(struct rpc_rqst *); /* release rq_enc_pages */
      85                 :            : 
      86                 :            :         union {
      87                 :            :                 struct list_head        rq_list;        /* Slot allocation list */
      88                 :            :                 struct rb_node          rq_recv;        /* Receive queue */
      89                 :            :         };
      90                 :            : 
      91                 :            :         struct list_head        rq_xmit;        /* Send queue */
      92                 :            :         struct list_head        rq_xmit2;       /* Send queue */
      93                 :            : 
      94                 :            :         void                    *rq_buffer;     /* Call XDR encode buffer */
      95                 :            :         size_t                  rq_callsize;
      96                 :            :         void                    *rq_rbuffer;    /* Reply XDR decode buffer */
      97                 :            :         size_t                  rq_rcvsize;
      98                 :            :         size_t                  rq_xmit_bytes_sent;     /* total bytes sent */
      99                 :            :         size_t                  rq_reply_bytes_recvd;   /* total reply bytes */
     100                 :            :                                                         /* received */
     101                 :            : 
     102                 :            :         struct xdr_buf          rq_private_buf;         /* The receive buffer
     103                 :            :                                                          * used in the softirq.
     104                 :            :                                                          */
     105                 :            :         unsigned long           rq_majortimeo;  /* major timeout alarm */
     106                 :            :         unsigned long           rq_timeout;     /* Current timeout value */
     107                 :            :         ktime_t                 rq_rtt;         /* round-trip time */
     108                 :            :         unsigned int            rq_retries;     /* # of retries */
     109                 :            :         unsigned int            rq_connect_cookie;
     110                 :            :                                                 /* A cookie used to track the
     111                 :            :                                                    state of the transport
     112                 :            :                                                    connection */
     113                 :            :         atomic_t                rq_pin;
     114                 :            :         
     115                 :            :         /*
     116                 :            :          * Partial send handling
     117                 :            :          */
     118                 :            :         u32                     rq_bytes_sent;  /* Bytes we have sent */
     119                 :            : 
     120                 :            :         ktime_t                 rq_xtime;       /* transmit time stamp */
     121                 :            :         int                     rq_ntrans;
     122                 :            : 
     123                 :            : #if defined(CONFIG_SUNRPC_BACKCHANNEL)
     124                 :            :         struct list_head        rq_bc_list;     /* Callback service list */
     125                 :            :         unsigned long           rq_bc_pa_state; /* Backchannel prealloc state */
     126                 :            :         struct list_head        rq_bc_pa_list;  /* Backchannel prealloc list */
     127                 :            : #endif /* CONFIG_SUNRPC_BACKCHANEL */
     128                 :            : };
     129                 :            : #define rq_svec                 rq_snd_buf.head
     130                 :            : #define rq_slen                 rq_snd_buf.len
     131                 :            : 
     132                 :            : struct rpc_xprt_ops {
     133                 :            :         void            (*set_buffer_size)(struct rpc_xprt *xprt, size_t sndsize, size_t rcvsize);
     134                 :            :         int             (*reserve_xprt)(struct rpc_xprt *xprt, struct rpc_task *task);
     135                 :            :         void            (*release_xprt)(struct rpc_xprt *xprt, struct rpc_task *task);
     136                 :            :         void            (*alloc_slot)(struct rpc_xprt *xprt, struct rpc_task *task);
     137                 :            :         void            (*free_slot)(struct rpc_xprt *xprt,
     138                 :            :                                      struct rpc_rqst *req);
     139                 :            :         void            (*rpcbind)(struct rpc_task *task);
     140                 :            :         void            (*set_port)(struct rpc_xprt *xprt, unsigned short port);
     141                 :            :         void            (*connect)(struct rpc_xprt *xprt, struct rpc_task *task);
     142                 :            :         int             (*buf_alloc)(struct rpc_task *task);
     143                 :            :         void            (*buf_free)(struct rpc_task *task);
     144                 :            :         void            (*prepare_request)(struct rpc_rqst *req);
     145                 :            :         int             (*send_request)(struct rpc_rqst *req);
     146                 :            :         void            (*wait_for_reply_request)(struct rpc_task *task);
     147                 :            :         void            (*timer)(struct rpc_xprt *xprt, struct rpc_task *task);
     148                 :            :         void            (*release_request)(struct rpc_task *task);
     149                 :            :         void            (*close)(struct rpc_xprt *xprt);
     150                 :            :         void            (*destroy)(struct rpc_xprt *xprt);
     151                 :            :         void            (*set_connect_timeout)(struct rpc_xprt *xprt,
     152                 :            :                                         unsigned long connect_timeout,
     153                 :            :                                         unsigned long reconnect_timeout);
     154                 :            :         void            (*print_stats)(struct rpc_xprt *xprt, struct seq_file *seq);
     155                 :            :         int             (*enable_swap)(struct rpc_xprt *xprt);
     156                 :            :         void            (*disable_swap)(struct rpc_xprt *xprt);
     157                 :            :         void            (*inject_disconnect)(struct rpc_xprt *xprt);
     158                 :            :         int             (*bc_setup)(struct rpc_xprt *xprt,
     159                 :            :                                     unsigned int min_reqs);
     160                 :            :         size_t          (*bc_maxpayload)(struct rpc_xprt *xprt);
     161                 :            :         unsigned int    (*bc_num_slots)(struct rpc_xprt *xprt);
     162                 :            :         void            (*bc_free_rqst)(struct rpc_rqst *rqst);
     163                 :            :         void            (*bc_destroy)(struct rpc_xprt *xprt,
     164                 :            :                                       unsigned int max_reqs);
     165                 :            : };
     166                 :            : 
     167                 :            : /*
     168                 :            :  * RPC transport identifiers
     169                 :            :  *
     170                 :            :  * To preserve compatibility with the historical use of raw IP protocol
     171                 :            :  * id's for transport selection, UDP and TCP identifiers are specified
     172                 :            :  * with the previous values. No such restriction exists for new transports,
     173                 :            :  * except that they may not collide with these values (17 and 6,
     174                 :            :  * respectively).
     175                 :            :  */
     176                 :            : #define XPRT_TRANSPORT_BC       (1 << 31)
     177                 :            : enum xprt_transports {
     178                 :            :         XPRT_TRANSPORT_UDP      = IPPROTO_UDP,
     179                 :            :         XPRT_TRANSPORT_TCP      = IPPROTO_TCP,
     180                 :            :         XPRT_TRANSPORT_BC_TCP   = IPPROTO_TCP | XPRT_TRANSPORT_BC,
     181                 :            :         XPRT_TRANSPORT_RDMA     = 256,
     182                 :            :         XPRT_TRANSPORT_BC_RDMA  = XPRT_TRANSPORT_RDMA | XPRT_TRANSPORT_BC,
     183                 :            :         XPRT_TRANSPORT_LOCAL    = 257,
     184                 :            : };
     185                 :            : 
     186                 :            : struct rpc_xprt {
     187                 :            :         struct kref             kref;           /* Reference count */
     188                 :            :         const struct rpc_xprt_ops *ops;         /* transport methods */
     189                 :            : 
     190                 :            :         const struct rpc_timeout *timeout;      /* timeout parms */
     191                 :            :         struct sockaddr_storage addr;           /* server address */
     192                 :            :         size_t                  addrlen;        /* size of server address */
     193                 :            :         int                     prot;           /* IP protocol */
     194                 :            : 
     195                 :            :         unsigned long           cong;           /* current congestion */
     196                 :            :         unsigned long           cwnd;           /* congestion window */
     197                 :            : 
     198                 :            :         size_t                  max_payload;    /* largest RPC payload size,
     199                 :            :                                                    in bytes */
     200                 :            : 
     201                 :            :         struct rpc_wait_queue   binding;        /* requests waiting on rpcbind */
     202                 :            :         struct rpc_wait_queue   sending;        /* requests waiting to send */
     203                 :            :         struct rpc_wait_queue   pending;        /* requests in flight */
     204                 :            :         struct rpc_wait_queue   backlog;        /* waiting for slot */
     205                 :            :         struct list_head        free;           /* free slots */
     206                 :            :         unsigned int            max_reqs;       /* max number of slots */
     207                 :            :         unsigned int            min_reqs;       /* min number of slots */
     208                 :            :         unsigned int            num_reqs;       /* total slots */
     209                 :            :         unsigned long           state;          /* transport state */
     210                 :            :         unsigned char           resvport   : 1; /* use a reserved port */
     211                 :            :         atomic_t                swapper;        /* we're swapping over this
     212                 :            :                                                    transport */
     213                 :            :         unsigned int            bind_index;     /* bind function index */
     214                 :            : 
     215                 :            :         /*
     216                 :            :          * Multipath
     217                 :            :          */
     218                 :            :         struct list_head        xprt_switch;
     219                 :            : 
     220                 :            :         /*
     221                 :            :          * Connection of transports
     222                 :            :          */
     223                 :            :         unsigned long           bind_timeout,
     224                 :            :                                 reestablish_timeout;
     225                 :            :         unsigned int            connect_cookie; /* A cookie that gets bumped
     226                 :            :                                                    every time the transport
     227                 :            :                                                    is reconnected */
     228                 :            : 
     229                 :            :         /*
     230                 :            :          * Disconnection of idle transports
     231                 :            :          */
     232                 :            :         struct work_struct      task_cleanup;
     233                 :            :         struct timer_list       timer;
     234                 :            :         unsigned long           last_used,
     235                 :            :                                 idle_timeout,
     236                 :            :                                 connect_timeout,
     237                 :            :                                 max_reconnect_timeout;
     238                 :            : 
     239                 :            :         /*
     240                 :            :          * Send stuff
     241                 :            :          */
     242                 :            :         atomic_long_t           queuelen;
     243                 :            :         spinlock_t              transport_lock; /* lock transport info */
     244                 :            :         spinlock_t              reserve_lock;   /* lock slot table */
     245                 :            :         spinlock_t              queue_lock;     /* send/receive queue lock */
     246                 :            :         u32                     xid;            /* Next XID value to use */
     247                 :            :         struct rpc_task *       snd_task;       /* Task blocked in send */
     248                 :            : 
     249                 :            :         struct list_head        xmit_queue;     /* Send queue */
     250                 :            : 
     251                 :            :         struct svc_xprt         *bc_xprt;       /* NFSv4.1 backchannel */
     252                 :            : #if defined(CONFIG_SUNRPC_BACKCHANNEL)
     253                 :            :         struct svc_serv         *bc_serv;       /* The RPC service which will */
     254                 :            :                                                 /* process the callback */
     255                 :            :         unsigned int            bc_alloc_max;
     256                 :            :         unsigned int            bc_alloc_count; /* Total number of preallocs */
     257                 :            :         atomic_t                bc_slot_count;  /* Number of allocated slots */
     258                 :            :         spinlock_t              bc_pa_lock;     /* Protects the preallocated
     259                 :            :                                                  * items */
     260                 :            :         struct list_head        bc_pa_list;     /* List of preallocated
     261                 :            :                                                  * backchannel rpc_rqst's */
     262                 :            : #endif /* CONFIG_SUNRPC_BACKCHANNEL */
     263                 :            : 
     264                 :            :         struct rb_root          recv_queue;     /* Receive queue */
     265                 :            : 
     266                 :            :         struct {
     267                 :            :                 unsigned long           bind_count,     /* total number of binds */
     268                 :            :                                         connect_count,  /* total number of connects */
     269                 :            :                                         connect_start,  /* connect start timestamp */
     270                 :            :                                         connect_time,   /* jiffies waiting for connect */
     271                 :            :                                         sends,          /* how many complete requests */
     272                 :            :                                         recvs,          /* how many complete requests */
     273                 :            :                                         bad_xids,       /* lookup_rqst didn't find XID */
     274                 :            :                                         max_slots;      /* max rpc_slots used */
     275                 :            : 
     276                 :            :                 unsigned long long      req_u,          /* average requests on the wire */
     277                 :            :                                         bklog_u,        /* backlog queue utilization */
     278                 :            :                                         sending_u,      /* send q utilization */
     279                 :            :                                         pending_u;      /* pend q utilization */
     280                 :            :         } stat;
     281                 :            : 
     282                 :            :         struct net              *xprt_net;
     283                 :            :         const char              *servername;
     284                 :            :         const char              *address_strings[RPC_DISPLAY_MAX];
     285                 :            : #if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
     286                 :            :         struct dentry           *debugfs;               /* debugfs directory */
     287                 :            :         atomic_t                inject_disconnect;
     288                 :            : #endif
     289                 :            :         struct rcu_head         rcu;
     290                 :            : };
     291                 :            : 
     292                 :            : #if defined(CONFIG_SUNRPC_BACKCHANNEL)
     293                 :            : /*
     294                 :            :  * Backchannel flags
     295                 :            :  */
     296                 :            : #define RPC_BC_PA_IN_USE        0x0001          /* Preallocated backchannel */
     297                 :            :                                                 /* buffer in use */
     298                 :            : #endif /* CONFIG_SUNRPC_BACKCHANNEL */
     299                 :            : 
     300                 :            : #if defined(CONFIG_SUNRPC_BACKCHANNEL)
     301                 :            : static inline int bc_prealloc(struct rpc_rqst *req)
     302                 :            : {
     303                 :            :         return test_bit(RPC_BC_PA_IN_USE, &req->rq_bc_pa_state);
     304                 :            : }
     305                 :            : #else
     306                 :            : static inline int bc_prealloc(struct rpc_rqst *req)
     307                 :            : {
     308                 :            :         return 0;
     309                 :            : }
     310                 :            : #endif /* CONFIG_SUNRPC_BACKCHANNEL */
     311                 :            : 
     312                 :            : #define XPRT_CREATE_INFINITE_SLOTS      (1U)
     313                 :            : #define XPRT_CREATE_NO_IDLE_TIMEOUT     (1U << 1)
     314                 :            : 
     315                 :            : struct xprt_create {
     316                 :            :         int                     ident;          /* XPRT_TRANSPORT identifier */
     317                 :            :         struct net *            net;
     318                 :            :         struct sockaddr *       srcaddr;        /* optional local address */
     319                 :            :         struct sockaddr *       dstaddr;        /* remote peer address */
     320                 :            :         size_t                  addrlen;
     321                 :            :         const char              *servername;
     322                 :            :         struct svc_xprt         *bc_xprt;       /* NFSv4.1 backchannel */
     323                 :            :         struct rpc_xprt_switch  *bc_xps;
     324                 :            :         unsigned int            flags;
     325                 :            : };
     326                 :            : 
     327                 :            : struct xprt_class {
     328                 :            :         struct list_head        list;
     329                 :            :         int                     ident;          /* XPRT_TRANSPORT identifier */
     330                 :            :         struct rpc_xprt *       (*setup)(struct xprt_create *);
     331                 :            :         struct module           *owner;
     332                 :            :         char                    name[32];
     333                 :            : };
     334                 :            : 
     335                 :            : /*
     336                 :            :  * Generic internal transport functions
     337                 :            :  */
     338                 :            : struct rpc_xprt         *xprt_create_transport(struct xprt_create *args);
     339                 :            : void                    xprt_connect(struct rpc_task *task);
     340                 :            : unsigned long           xprt_reconnect_delay(const struct rpc_xprt *xprt);
     341                 :            : void                    xprt_reconnect_backoff(struct rpc_xprt *xprt,
     342                 :            :                                                unsigned long init_to);
     343                 :            : void                    xprt_reserve(struct rpc_task *task);
     344                 :            : void                    xprt_retry_reserve(struct rpc_task *task);
     345                 :            : int                     xprt_reserve_xprt(struct rpc_xprt *xprt, struct rpc_task *task);
     346                 :            : int                     xprt_reserve_xprt_cong(struct rpc_xprt *xprt, struct rpc_task *task);
     347                 :            : void                    xprt_alloc_slot(struct rpc_xprt *xprt, struct rpc_task *task);
     348                 :            : void                    xprt_free_slot(struct rpc_xprt *xprt,
     349                 :            :                                        struct rpc_rqst *req);
     350                 :            : void                    xprt_request_prepare(struct rpc_rqst *req);
     351                 :            : bool                    xprt_prepare_transmit(struct rpc_task *task);
     352                 :            : void                    xprt_request_enqueue_transmit(struct rpc_task *task);
     353                 :            : void                    xprt_request_enqueue_receive(struct rpc_task *task);
     354                 :            : void                    xprt_request_wait_receive(struct rpc_task *task);
     355                 :            : void                    xprt_request_dequeue_xprt(struct rpc_task *task);
     356                 :            : bool                    xprt_request_need_retransmit(struct rpc_task *task);
     357                 :            : void                    xprt_transmit(struct rpc_task *task);
     358                 :            : void                    xprt_end_transmit(struct rpc_task *task);
     359                 :            : int                     xprt_adjust_timeout(struct rpc_rqst *req);
     360                 :            : void                    xprt_release_xprt(struct rpc_xprt *xprt, struct rpc_task *task);
     361                 :            : void                    xprt_release_xprt_cong(struct rpc_xprt *xprt, struct rpc_task *task);
     362                 :            : void                    xprt_release(struct rpc_task *task);
     363                 :            : struct rpc_xprt *       xprt_get(struct rpc_xprt *xprt);
     364                 :            : void                    xprt_put(struct rpc_xprt *xprt);
     365                 :            : struct rpc_xprt *       xprt_alloc(struct net *net, size_t size,
     366                 :            :                                 unsigned int num_prealloc,
     367                 :            :                                 unsigned int max_req);
     368                 :            : void                    xprt_free(struct rpc_xprt *);
     369                 :            : 
     370                 :            : static inline int
     371                 :            : xprt_enable_swap(struct rpc_xprt *xprt)
     372                 :            : {
     373                 :          0 :         return xprt->ops->enable_swap(xprt);
     374                 :            : }
     375                 :            : 
     376                 :            : static inline void
     377                 :            : xprt_disable_swap(struct rpc_xprt *xprt)
     378                 :            : {
     379                 :          0 :         xprt->ops->disable_swap(xprt);
     380                 :            : }
     381                 :            : 
     382                 :            : /*
     383                 :            :  * Transport switch helper functions
     384                 :            :  */
     385                 :            : int                     xprt_register_transport(struct xprt_class *type);
     386                 :            : int                     xprt_unregister_transport(struct xprt_class *type);
     387                 :            : int                     xprt_load_transport(const char *);
     388                 :            : void                    xprt_wait_for_reply_request_def(struct rpc_task *task);
     389                 :            : void                    xprt_wait_for_reply_request_rtt(struct rpc_task *task);
     390                 :            : void                    xprt_wake_pending_tasks(struct rpc_xprt *xprt, int status);
     391                 :            : void                    xprt_wait_for_buffer_space(struct rpc_xprt *xprt);
     392                 :            : bool                    xprt_write_space(struct rpc_xprt *xprt);
     393                 :            : void                    xprt_adjust_cwnd(struct rpc_xprt *xprt, struct rpc_task *task, int result);
     394                 :            : struct rpc_rqst *       xprt_lookup_rqst(struct rpc_xprt *xprt, __be32 xid);
     395                 :            : void                    xprt_update_rtt(struct rpc_task *task);
     396                 :            : void                    xprt_complete_rqst(struct rpc_task *task, int copied);
     397                 :            : void                    xprt_pin_rqst(struct rpc_rqst *req);
     398                 :            : void                    xprt_unpin_rqst(struct rpc_rqst *req);
     399                 :            : void                    xprt_release_rqst_cong(struct rpc_task *task);
     400                 :            : bool                    xprt_request_get_cong(struct rpc_xprt *xprt, struct rpc_rqst *req);
     401                 :            : void                    xprt_disconnect_done(struct rpc_xprt *xprt);
     402                 :            : void                    xprt_force_disconnect(struct rpc_xprt *xprt);
     403                 :            : void                    xprt_conditional_disconnect(struct rpc_xprt *xprt, unsigned int cookie);
     404                 :            : 
     405                 :            : bool                    xprt_lock_connect(struct rpc_xprt *, struct rpc_task *, void *);
     406                 :            : void                    xprt_unlock_connect(struct rpc_xprt *, void *);
     407                 :            : 
     408                 :            : /*
     409                 :            :  * Reserved bit positions in xprt->state
     410                 :            :  */
     411                 :            : #define XPRT_LOCKED             (0)
     412                 :            : #define XPRT_CONNECTED          (1)
     413                 :            : #define XPRT_CONNECTING         (2)
     414                 :            : #define XPRT_CLOSE_WAIT         (3)
     415                 :            : #define XPRT_BOUND              (4)
     416                 :            : #define XPRT_BINDING            (5)
     417                 :            : #define XPRT_CLOSING            (6)
     418                 :            : #define XPRT_CONGESTED          (9)
     419                 :            : #define XPRT_CWND_WAIT          (10)
     420                 :            : #define XPRT_WRITE_SPACE        (11)
     421                 :            : 
     422                 :            : static inline void xprt_set_connected(struct rpc_xprt *xprt)
     423                 :            : {
     424                 :          0 :         set_bit(XPRT_CONNECTED, &xprt->state);
     425                 :            : }
     426                 :            : 
     427                 :            : static inline void xprt_clear_connected(struct rpc_xprt *xprt)
     428                 :            : {
     429                 :          0 :         clear_bit(XPRT_CONNECTED, &xprt->state);
     430                 :            : }
     431                 :            : 
     432                 :            : static inline int xprt_connected(struct rpc_xprt *xprt)
     433                 :            : {
     434                 :            :         return test_bit(XPRT_CONNECTED, &xprt->state);
     435                 :            : }
     436                 :            : 
     437                 :            : static inline int xprt_test_and_set_connected(struct rpc_xprt *xprt)
     438                 :            : {
     439                 :          0 :         return test_and_set_bit(XPRT_CONNECTED, &xprt->state);
     440                 :            : }
     441                 :            : 
     442                 :            : static inline int xprt_test_and_clear_connected(struct rpc_xprt *xprt)
     443                 :            : {
     444                 :            :         return test_and_clear_bit(XPRT_CONNECTED, &xprt->state);
     445                 :            : }
     446                 :            : 
     447                 :            : static inline void xprt_clear_connecting(struct rpc_xprt *xprt)
     448                 :            : {
     449                 :          0 :         smp_mb__before_atomic();
     450                 :          0 :         clear_bit(XPRT_CONNECTING, &xprt->state);
     451                 :          0 :         smp_mb__after_atomic();
     452                 :            : }
     453                 :            : 
     454                 :            : static inline int xprt_connecting(struct rpc_xprt *xprt)
     455                 :            : {
     456                 :            :         return test_bit(XPRT_CONNECTING, &xprt->state);
     457                 :            : }
     458                 :            : 
     459                 :            : static inline int xprt_test_and_set_connecting(struct rpc_xprt *xprt)
     460                 :            : {
     461                 :          0 :         return test_and_set_bit(XPRT_CONNECTING, &xprt->state);
     462                 :            : }
     463                 :            : 
     464                 :            : static inline void xprt_set_bound(struct rpc_xprt *xprt)
     465                 :            : {
     466                 :          0 :         test_and_set_bit(XPRT_BOUND, &xprt->state);
     467                 :            : }
     468                 :            : 
     469                 :            : static inline int xprt_bound(struct rpc_xprt *xprt)
     470                 :            : {
     471                 :            :         return test_bit(XPRT_BOUND, &xprt->state);
     472                 :            : }
     473                 :            : 
     474                 :            : static inline void xprt_clear_bound(struct rpc_xprt *xprt)
     475                 :            : {
     476                 :          0 :         clear_bit(XPRT_BOUND, &xprt->state);
     477                 :            : }
     478                 :            : 
     479                 :            : static inline void xprt_clear_binding(struct rpc_xprt *xprt)
     480                 :            : {
     481                 :          0 :         smp_mb__before_atomic();
     482                 :          0 :         clear_bit(XPRT_BINDING, &xprt->state);
     483                 :          0 :         smp_mb__after_atomic();
     484                 :            : }
     485                 :            : 
     486                 :            : static inline int xprt_test_and_set_binding(struct rpc_xprt *xprt)
     487                 :            : {
     488                 :          0 :         return test_and_set_bit(XPRT_BINDING, &xprt->state);
     489                 :            : }
     490                 :            : 
     491                 :            : #if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
     492                 :            : extern unsigned int rpc_inject_disconnect;
     493                 :            : static inline void xprt_inject_disconnect(struct rpc_xprt *xprt)
     494                 :            : {
     495                 :            :         if (!rpc_inject_disconnect)
     496                 :            :                 return;
     497                 :            :         if (atomic_dec_return(&xprt->inject_disconnect))
     498                 :            :                 return;
     499                 :            :         atomic_set(&xprt->inject_disconnect, rpc_inject_disconnect);
     500                 :            :         xprt->ops->inject_disconnect(xprt);
     501                 :            : }
     502                 :            : #else
     503                 :            : static inline void xprt_inject_disconnect(struct rpc_xprt *xprt)
     504                 :            : {
     505                 :            : }
     506                 :            : #endif
     507                 :            : 
     508                 :            : #endif /* __KERNEL__*/
     509                 :            : 
     510                 :            : #endif /* _LINUX_SUNRPC_XPRT_H */