net/sunrpc/xprtrdma/xprt_rdma.h

   1 /*
   2  * Copyright (c) 2003-2007 Network Appliance, Inc. All rights reserved.
   3  *
   4  * This software is available to you under a choice of one of two
   5  * licenses.  You may choose to be licensed under the terms of the GNU
   6  * General Public License (GPL) Version 2, available from the file
   7  * COPYING in the main directory of this source tree, or the BSD-type
   8  * license below:
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  *
  14  *      Redistributions of source code must retain the above copyright
  15  *      notice, this list of conditions and the following disclaimer.
  16  *
  17  *      Redistributions in binary form must reproduce the above
  18  *      copyright notice, this list of conditions and the following
  19  *      disclaimer in the documentation and/or other materials provided
  20  *      with the distribution.
  21  *
  22  *      Neither the name of the Network Appliance, Inc. nor the names of
  23  *      its contributors may be used to endorse or promote products
  24  *      derived from this software without specific prior written
  25  *      permission.
  26  *
  27  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  28  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  29  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  30  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  31  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  32  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  33  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  34  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  35  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  36  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  37  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  38  */
  39
  40 #ifndef _LINUX_SUNRPC_XPRT_RDMA_H
  41 #define _LINUX_SUNRPC_XPRT_RDMA_H
  42
  43 #include <linux/wait.h>                 /* wait_queue_head_t, etc */
  44 #include <linux/spinlock.h>             /* spinlock_t, etc */
  45 #include <linux/atomic.h>                       /* atomic_t, etc */
  46 #include <linux/workqueue.h>            /* struct work_struct */
  47
  48 #include <rdma/rdma_cm.h>               /* RDMA connection api */
  49 #include <rdma/ib_verbs.h>              /* RDMA verbs api */
  50
  51 #include <linux/sunrpc/clnt.h>          /* rpc_xprt */
  52 #include <linux/sunrpc/rpc_rdma.h>      /* RPC/RDMA protocol */
  53 #include <linux/sunrpc/xprtrdma.h>      /* xprt parameters */
  54 #include <linux/sunrpc/svc.h>           /* RPCSVC_MAXPAYLOAD */
  55
  56 #define RDMA_RESOLVE_TIMEOUT    (5000)  /* 5 seconds */
  57 #define RDMA_CONNECT_RETRY_MAX  (2)     /* retries if no listener backlog */
  58
  59 /*
  60  * Interface Adapter -- one per transport instance
  61  */
  62 struct rpcrdma_ia {
  63         rwlock_t                ri_qplock;
  64         struct rdma_cm_id       *ri_id;
  65         struct ib_pd            *ri_pd;
  66         struct ib_mr            *ri_bind_mem;
  67         u32                     ri_dma_lkey;
  68         int                     ri_have_dma_lkey;
  69         struct completion       ri_done;
  70         int                     ri_async_rc;
  71         enum rpcrdma_memreg     ri_memreg_strategy;
  72         unsigned int            ri_max_frmr_depth;
  73         struct ib_device_attr   ri_devattr;
  74         struct ib_qp_attr       ri_qp_attr;
  75         struct ib_qp_init_attr  ri_qp_init_attr;
  76 };
  77
  78 /*
  79  * RDMA Endpoint -- one per transport instance
  80  */
  81
  82 #define RPCRDMA_WC_BUDGET       (128)
  83 #define RPCRDMA_POLLSIZE        (16)
  84
  85 struct rpcrdma_ep {
  86         atomic_t                rep_cqcount;
  87         int                     rep_cqinit;
  88         int                     rep_connected;
  89         struct ib_qp_init_attr  rep_attr;
  90         wait_queue_head_t       rep_connect_wait;
  91         struct rpcrdma_regbuf   *rep_padbuf;
  92         struct rdma_conn_param  rep_remote_cma;
  93         struct sockaddr_storage rep_remote_addr;
  94         struct delayed_work     rep_connect_worker;
  95         struct ib_wc            rep_send_wcs[RPCRDMA_POLLSIZE];
  96         struct ib_wc            rep_recv_wcs[RPCRDMA_POLLSIZE];
  97 };
  98
  99 /*
 100  * Force a signaled SEND Work Request every so often,
 101  * in case the provider needs to do some housekeeping.
 102  */
 103 #define RPCRDMA_MAX_UNSIGNALED_SENDS    (32)
 104
 105 #define INIT_CQCOUNT(ep) atomic_set(&(ep)->rep_cqcount, (ep)->rep_cqinit)
 106 #define DECR_CQCOUNT(ep) atomic_sub_return(1, &(ep)->rep_cqcount)
 107
 108 /* Registered buffer -- registered kmalloc'd memory for RDMA SEND/RECV
 109  *
 110  * The below structure appears at the front of a large region of kmalloc'd
 111  * memory, which always starts on a good alignment boundary.
 112  */
 113
 114 struct rpcrdma_regbuf {
 115         size_t                  rg_size;
 116         struct rpcrdma_req      *rg_owner;
 117         struct ib_mr            *rg_mr;
 118         struct ib_sge           rg_iov;
 119         __be32                  rg_base[0] __attribute__ ((aligned(256)));
 120 };
 121
 122 static inline u64
 123 rdmab_addr(struct rpcrdma_regbuf *rb)
 124 {
 125         return rb->rg_iov.addr;
 126 }
 127
 128 static inline u32
 129 rdmab_length(struct rpcrdma_regbuf *rb)
 130 {
 131         return rb->rg_iov.length;
 132 }
 133
 134 static inline u32
 135 rdmab_lkey(struct rpcrdma_regbuf *rb)
 136 {
 137         return rb->rg_iov.lkey;
 138 }
 139
 140 static inline struct rpcrdma_msg *
 141 rdmab_to_msg(struct rpcrdma_regbuf *rb)
 142 {
 143         return (struct rpcrdma_msg *)rb->rg_base;
 144 }
 145
 146 enum rpcrdma_chunktype {
 147         rpcrdma_noch = 0,
 148         rpcrdma_readch,
 149         rpcrdma_areadch,
 150         rpcrdma_writech,
 151         rpcrdma_replych
 152 };
 153
 154 /*
 155  * struct rpcrdma_rep -- this structure encapsulates state required to recv
 156  * and complete a reply, asychronously. It needs several pieces of
 157  * state:
 158  *   o recv buffer (posted to provider)
 159  *   o ib_sge (also donated to provider)
 160  *   o status of reply (length, success or not)
 161  *   o bookkeeping state to get run by tasklet (list, etc)
 162  *
 163  * These are allocated during initialization, per-transport instance;
 164  * however, the tasklet execution list itself is global, as it should
 165  * always be pretty short.
 166  *
 167  * N of these are associated with a transport instance, and stored in
 168  * struct rpcrdma_buffer. N is the max number of outstanding requests.
 169  */
 170
 171 /* temporary static scatter/gather max */
 172 #define RPCRDMA_MAX_DATA_SEGS   (64)    /* max scatter/gather */
 173 #define RPCRDMA_MAX_SEGS        (RPCRDMA_MAX_DATA_SEGS + 2) /* head+tail = 2 */
 174
 175 struct rpcrdma_buffer;
 176
 177 struct rpcrdma_rep {
 178         unsigned int            rr_len;
 179         struct rpcrdma_buffer   *rr_buffer;
 180         struct rpc_xprt         *rr_xprt;
 181         void                    (*rr_func)(struct rpcrdma_rep *);
 182         struct list_head        rr_list;
 183         struct rpcrdma_regbuf   *rr_rdmabuf;
 184 };
 185
 186 /*
 187  * struct rpcrdma_mw - external memory region metadata
 188  *
 189  * An external memory region is any buffer or page that is registered
 190  * on the fly (ie, not pre-registered).
 191  *
 192  * Each rpcrdma_buffer has a list of free MWs anchored in rb_mws. During
 193  * call_allocate, rpcrdma_buffer_get() assigns one to each segment in
 194  * an rpcrdma_req. Then rpcrdma_register_external() grabs these to keep
 195  * track of registration metadata while each RPC is pending.
 196  * rpcrdma_deregister_external() uses this metadata to unmap and
 197  * release these resources when an RPC is complete.
 198  */
 199 enum rpcrdma_frmr_state {
 200         FRMR_IS_INVALID,        /* ready to be used */
 201         FRMR_IS_VALID,          /* in use */
 202         FRMR_IS_STALE,          /* failed completion */
 203 };
 204
 205 struct rpcrdma_frmr {
 206         struct ib_fast_reg_page_list    *fr_pgl;
 207         struct ib_mr                    *fr_mr;
 208         enum rpcrdma_frmr_state         fr_state;
 209 };
 210
 211 struct rpcrdma_mw {
 212         union {
 213                 struct ib_fmr           *fmr;
 214                 struct rpcrdma_frmr     frmr;
 215         } r;
 216         struct list_head        mw_list;
 217         struct list_head        mw_all;
 218 };
 219
 220 /*
 221  * struct rpcrdma_req -- structure central to the request/reply sequence.
 222  *
 223  * N of these are associated with a transport instance, and stored in
 224  * struct rpcrdma_buffer. N is the max number of outstanding requests.
 225  *
 226  * It includes pre-registered buffer memory for send AND recv.
 227  * The recv buffer, however, is not owned by this structure, and
 228  * is "donated" to the hardware when a recv is posted. When a
 229  * reply is handled, the recv buffer used is given back to the
 230  * struct rpcrdma_req associated with the request.
 231  *
 232  * In addition to the basic memory, this structure includes an array
 233  * of iovs for send operations. The reason is that the iovs passed to
 234  * ib_post_{send,recv} must not be modified until the work request
 235  * completes.
 236  *
 237  * NOTES:
 238  *   o RPCRDMA_MAX_SEGS is the max number of addressible chunk elements we
 239  *     marshal. The number needed varies depending on the iov lists that
 240  *     are passed to us, the memory registration mode we are in, and if
 241  *     physical addressing is used, the layout.
 242  */
 243
 244 struct rpcrdma_mr_seg {         /* chunk descriptors */
 245         struct rpcrdma_mw *rl_mw;       /* registered MR */
 246         u64             mr_base;        /* registration result */
 247         u32             mr_rkey;        /* registration result */
 248         u32             mr_len;         /* length of chunk or segment */
 249         int             mr_nsegs;       /* number of segments in chunk or 0 */
 250         enum dma_data_direction mr_dir; /* segment mapping direction */
 251         dma_addr_t      mr_dma;         /* segment mapping address */
 252         size_t          mr_dmalen;      /* segment mapping length */
 253         struct page     *mr_page;       /* owning page, if any */
 254         char            *mr_offset;     /* kva if no page, else offset */
 255 };
 256
 257 struct rpcrdma_req {
 258         unsigned int    rl_niovs;       /* 0, 2 or 4 */
 259         unsigned int    rl_nchunks;     /* non-zero if chunks */
 260         unsigned int    rl_connect_cookie;      /* retry detection */
 261         enum rpcrdma_chunktype  rl_rtype, rl_wtype;
 262         struct rpcrdma_buffer *rl_buffer; /* home base for this structure */
 263         struct rpcrdma_rep      *rl_reply;/* holder for reply buffer */
 264         struct ib_sge   rl_send_iov[4]; /* for active requests */
 265         struct rpcrdma_regbuf *rl_rdmabuf;
 266         struct rpcrdma_regbuf *rl_sendbuf;
 267         struct rpcrdma_mr_seg rl_segments[RPCRDMA_MAX_SEGS];
 268 };
 269
 270 static inline struct rpcrdma_req *
 271 rpcr_to_rdmar(struct rpc_rqst *rqst)
 272 {
 273         void *buffer = rqst->rq_buffer;
 274         struct rpcrdma_regbuf *rb;
 275
 276         rb = container_of(buffer, struct rpcrdma_regbuf, rg_base);
 277         return rb->rg_owner;
 278 }
 279
 280 /*
 281  * struct rpcrdma_buffer -- holds list/queue of pre-registered memory for
 282  * inline requests/replies, and client/server credits.
 283  *
 284  * One of these is associated with a transport instance
 285  */
 286 struct rpcrdma_buffer {
 287         spinlock_t      rb_lock;        /* protects indexes */
 288         int             rb_max_requests;/* client max requests */
 289         struct list_head rb_mws;        /* optional memory windows/fmrs/frmrs */
 290         struct list_head rb_all;
 291         int             rb_send_index;
 292         struct rpcrdma_req      **rb_send_bufs;
 293         int             rb_recv_index;
 294         struct rpcrdma_rep      **rb_recv_bufs;
 295         char            *rb_pool;
 296 };
 297 #define rdmab_to_ia(b) (&container_of((b), struct rpcrdma_xprt, rx_buf)->rx_ia)
 298
 299 /*
 300  * Internal structure for transport instance creation. This
 301  * exists primarily for modularity.
 302  *
 303  * This data should be set with mount options
 304  */
 305 struct rpcrdma_create_data_internal {
 306         struct sockaddr_storage addr;   /* RDMA server address */
 307         unsigned int    max_requests;   /* max requests (slots) in flight */
 308         unsigned int    rsize;          /* mount rsize - max read hdr+data */
 309         unsigned int    wsize;          /* mount wsize - max write hdr+data */
 310         unsigned int    inline_rsize;   /* max non-rdma read data payload */
 311         unsigned int    inline_wsize;   /* max non-rdma write data payload */
 312         unsigned int    padding;        /* non-rdma write header padding */
 313 };
 314
 315 #define RPCRDMA_INLINE_READ_THRESHOLD(rq) \
 316         (rpcx_to_rdmad(rq->rq_xprt).inline_rsize)
 317
 318 #define RPCRDMA_INLINE_WRITE_THRESHOLD(rq)\
 319         (rpcx_to_rdmad(rq->rq_xprt).inline_wsize)
 320
 321 #define RPCRDMA_INLINE_PAD_VALUE(rq)\
 322         rpcx_to_rdmad(rq->rq_xprt).padding
 323
 324 /*
 325  * Statistics for RPCRDMA
 326  */
 327 struct rpcrdma_stats {
 328         unsigned long           read_chunk_count;
 329         unsigned long           write_chunk_count;
 330         unsigned long           reply_chunk_count;
 331
 332         unsigned long long      total_rdma_request;
 333         unsigned long long      total_rdma_reply;
 334
 335         unsigned long long      pullup_copy_count;
 336         unsigned long long      fixup_copy_count;
 337         unsigned long           hardway_register_count;
 338         unsigned long           failed_marshal_count;
 339         unsigned long           bad_reply_count;
 340 };
 341
 342 /*
 343  * RPCRDMA transport -- encapsulates the structures above for
 344  * integration with RPC.
 345  *
 346  * The contained structures are embedded, not pointers,
 347  * for convenience. This structure need not be visible externally.
 348  *
 349  * It is allocated and initialized during mount, and released
 350  * during unmount.
 351  */
 352 struct rpcrdma_xprt {
 353         struct rpc_xprt         rx_xprt;
 354         struct rpcrdma_ia       rx_ia;
 355         struct rpcrdma_ep       rx_ep;
 356         struct rpcrdma_buffer   rx_buf;
 357         struct rpcrdma_create_data_internal rx_data;
 358         struct delayed_work     rx_connect_worker;
 359         struct rpcrdma_stats    rx_stats;
 360 };
 361
 362 #define rpcx_to_rdmax(x) container_of(x, struct rpcrdma_xprt, rx_xprt)
 363 #define rpcx_to_rdmad(x) (rpcx_to_rdmax(x)->rx_data)
 364
 365 /* Setting this to 0 ensures interoperability with early servers.
 366  * Setting this to 1 enhances certain unaligned read/write performance.
 367  * Default is 0, see sysctl entry and rpc_rdma.c rpcrdma_convert_iovs() */
 368 extern int xprt_rdma_pad_optimize;
 369
 370 /*
 371  * Interface Adapter calls - xprtrdma/verbs.c
 372  */
 373 int rpcrdma_ia_open(struct rpcrdma_xprt *, struct sockaddr *, int);
 374 void rpcrdma_ia_close(struct rpcrdma_ia *);
 375
 376 /*
 377  * Endpoint calls - xprtrdma/verbs.c
 378  */
 379 int rpcrdma_ep_create(struct rpcrdma_ep *, struct rpcrdma_ia *,
 380                                 struct rpcrdma_create_data_internal *);
 381 void rpcrdma_ep_destroy(struct rpcrdma_ep *, struct rpcrdma_ia *);
 382 int rpcrdma_ep_connect(struct rpcrdma_ep *, struct rpcrdma_ia *);
 383 void rpcrdma_ep_disconnect(struct rpcrdma_ep *, struct rpcrdma_ia *);
 384
 385 int rpcrdma_ep_post(struct rpcrdma_ia *, struct rpcrdma_ep *,
 386                                 struct rpcrdma_req *);
 387 int rpcrdma_ep_post_recv(struct rpcrdma_ia *, struct rpcrdma_ep *,
 388                                 struct rpcrdma_rep *);
 389
 390 /*
 391  * Buffer calls - xprtrdma/verbs.c
 392  */
 393 int rpcrdma_buffer_create(struct rpcrdma_xprt *);
 394 void rpcrdma_buffer_destroy(struct rpcrdma_buffer *);
 395
 396 struct rpcrdma_req *rpcrdma_buffer_get(struct rpcrdma_buffer *);
 397 void rpcrdma_buffer_put(struct rpcrdma_req *);
 398 void rpcrdma_recv_buffer_get(struct rpcrdma_req *);
 399 void rpcrdma_recv_buffer_put(struct rpcrdma_rep *);
 400
 401 int rpcrdma_register_external(struct rpcrdma_mr_seg *,
 402                                 int, int, struct rpcrdma_xprt *);
 403 int rpcrdma_deregister_external(struct rpcrdma_mr_seg *,
 404                                 struct rpcrdma_xprt *);
 405
 406 struct rpcrdma_regbuf *rpcrdma_alloc_regbuf(struct rpcrdma_ia *,
 407                                             size_t, gfp_t);
 408 void rpcrdma_free_regbuf(struct rpcrdma_ia *,
 409                          struct rpcrdma_regbuf *);
 410
 411 /*
 412  * RPC/RDMA connection management calls - xprtrdma/rpc_rdma.c
 413  */
 414 void rpcrdma_connect_worker(struct work_struct *);
 415 void rpcrdma_conn_func(struct rpcrdma_ep *);
 416 void rpcrdma_reply_handler(struct rpcrdma_rep *);
 417
 418 /*
 419  * RPC/RDMA protocol calls - xprtrdma/rpc_rdma.c
 420  */
 421 ssize_t rpcrdma_marshal_chunks(struct rpc_rqst *, ssize_t);
 422 int rpcrdma_marshal_req(struct rpc_rqst *);
 423 size_t rpcrdma_max_payload(struct rpcrdma_xprt *);
 424
 425 /* Temporary NFS request map cache. Created in svc_rdma.c  */
 426 extern struct kmem_cache *svc_rdma_map_cachep;
 427 /* WR context cache. Created in svc_rdma.c  */
 428 extern struct kmem_cache *svc_rdma_ctxt_cachep;
 429 /* Workqueue created in svc_rdma.c */
 430 extern struct workqueue_struct *svc_rdma_wq;
 431
 432 #if RPCSVC_MAXPAYLOAD < (RPCRDMA_MAX_DATA_SEGS << PAGE_SHIFT)
 433 #define RPCSVC_MAXPAYLOAD_RDMA RPCSVC_MAXPAYLOAD
 434 #else
 435 #define RPCSVC_MAXPAYLOAD_RDMA (RPCRDMA_MAX_DATA_SEGS << PAGE_SHIFT)
 436 #endif
 437
 438 #endif                          /* _LINUX_SUNRPC_XPRT_RDMA_H */