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 55 #define RDMA_RESOLVE_TIMEOUT (5000) /* 5 seconds */ 56 #define RDMA_CONNECT_RETRY_MAX (2) /* retries if no listener backlog */ 57 58 #define RPCRDMA_BIND_TO (60U * HZ) 59 #define RPCRDMA_INIT_REEST_TO (5U * HZ) 60 #define RPCRDMA_MAX_REEST_TO (30U * HZ) 61 #define RPCRDMA_IDLE_DISC_TO (5U * 60 * HZ) 62 63 /* 64 * Interface Adapter -- one per transport instance 65 */ 66 struct rpcrdma_ia { 67 const struct rpcrdma_memreg_ops *ri_ops; 68 struct ib_device *ri_device; 69 struct rdma_cm_id *ri_id; 70 struct ib_pd *ri_pd; 71 struct ib_mr *ri_dma_mr; 72 struct completion ri_done; 73 int ri_async_rc; 74 unsigned int ri_max_frmr_depth; 75 unsigned int ri_max_inline_write; 76 unsigned int ri_max_inline_read; 77 struct ib_qp_attr ri_qp_attr; 78 struct ib_qp_init_attr ri_qp_init_attr; 79 }; 80 81 /* 82 * RDMA Endpoint -- one per transport instance 83 */ 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 rdma_conn_param rep_remote_cma; 92 struct sockaddr_storage rep_remote_addr; 93 struct delayed_work rep_connect_worker; 94 }; 95 96 #define INIT_CQCOUNT(ep) atomic_set(&(ep)->rep_cqcount, (ep)->rep_cqinit) 97 #define DECR_CQCOUNT(ep) atomic_sub_return(1, &(ep)->rep_cqcount) 98 99 /* Pre-allocate extra Work Requests for handling backward receives 100 * and sends. This is a fixed value because the Work Queues are 101 * allocated when the forward channel is set up. 102 */ 103 #if defined(CONFIG_SUNRPC_BACKCHANNEL) 104 #define RPCRDMA_BACKWARD_WRS (8) 105 #else 106 #define RPCRDMA_BACKWARD_WRS (0) 107 #endif 108 109 /* Registered buffer -- registered kmalloc'd memory for RDMA SEND/RECV 110 * 111 * The below structure appears at the front of a large region of kmalloc'd 112 * memory, which always starts on a good alignment boundary. 113 */ 114 115 struct rpcrdma_regbuf { 116 size_t rg_size; 117 struct rpcrdma_req *rg_owner; 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 #define RPCRDMA_DEF_GFP (GFP_NOIO | __GFP_NOWARN) 147 148 /* To ensure a transport can always make forward progress, 149 * the number of RDMA segments allowed in header chunk lists 150 * is capped at 8. This prevents less-capable devices and 151 * memory registrations from overrunning the Send buffer 152 * while building chunk lists. 153 * 154 * Elements of the Read list take up more room than the 155 * Write list or Reply chunk. 8 read segments means the Read 156 * list (or Write list or Reply chunk) cannot consume more 157 * than 158 * 159 * ((8 + 2) * read segment size) + 1 XDR words, or 244 bytes. 160 * 161 * And the fixed part of the header is another 24 bytes. 162 * 163 * The smallest inline threshold is 1024 bytes, ensuring that 164 * at least 750 bytes are available for RPC messages. 165 */ 166 #define RPCRDMA_MAX_HDR_SEGS (8) 167 168 /* 169 * struct rpcrdma_rep -- this structure encapsulates state required to recv 170 * and complete a reply, asychronously. It needs several pieces of 171 * state: 172 * o recv buffer (posted to provider) 173 * o ib_sge (also donated to provider) 174 * o status of reply (length, success or not) 175 * o bookkeeping state to get run by tasklet (list, etc) 176 * 177 * These are allocated during initialization, per-transport instance; 178 * however, the tasklet execution list itself is global, as it should 179 * always be pretty short. 180 * 181 * N of these are associated with a transport instance, and stored in 182 * struct rpcrdma_buffer. N is the max number of outstanding requests. 183 */ 184 185 #define RPCRDMA_MAX_DATA_SEGS ((1 * 1024 * 1024) / PAGE_SIZE) 186 187 /* data segments + head/tail for Call + head/tail for Reply */ 188 #define RPCRDMA_MAX_SEGS (RPCRDMA_MAX_DATA_SEGS + 4) 189 190 struct rpcrdma_buffer; 191 192 struct rpcrdma_rep { 193 struct ib_cqe rr_cqe; 194 unsigned int rr_len; 195 struct ib_device *rr_device; 196 struct rpcrdma_xprt *rr_rxprt; 197 struct work_struct rr_work; 198 struct list_head rr_list; 199 struct rpcrdma_regbuf *rr_rdmabuf; 200 }; 201 202 #define RPCRDMA_BAD_LEN (~0U) 203 204 /* 205 * struct rpcrdma_mw - external memory region metadata 206 * 207 * An external memory region is any buffer or page that is registered 208 * on the fly (ie, not pre-registered). 209 * 210 * Each rpcrdma_buffer has a list of free MWs anchored in rb_mws. During 211 * call_allocate, rpcrdma_buffer_get() assigns one to each segment in 212 * an rpcrdma_req. Then rpcrdma_register_external() grabs these to keep 213 * track of registration metadata while each RPC is pending. 214 * rpcrdma_deregister_external() uses this metadata to unmap and 215 * release these resources when an RPC is complete. 216 */ 217 enum rpcrdma_frmr_state { 218 FRMR_IS_INVALID, /* ready to be used */ 219 FRMR_IS_VALID, /* in use */ 220 FRMR_IS_STALE, /* failed completion */ 221 }; 222 223 struct rpcrdma_frmr { 224 struct scatterlist *fr_sg; 225 int fr_nents; 226 enum dma_data_direction fr_dir; 227 struct ib_mr *fr_mr; 228 struct ib_cqe fr_cqe; 229 enum rpcrdma_frmr_state fr_state; 230 struct completion fr_linv_done; 231 union { 232 struct ib_reg_wr fr_regwr; 233 struct ib_send_wr fr_invwr; 234 }; 235 }; 236 237 struct rpcrdma_fmr { 238 struct ib_fmr *fmr; 239 u64 *physaddrs; 240 }; 241 242 struct rpcrdma_mw { 243 union { 244 struct rpcrdma_fmr fmr; 245 struct rpcrdma_frmr frmr; 246 }; 247 struct work_struct mw_work; 248 struct rpcrdma_xprt *mw_xprt; 249 struct list_head mw_list; 250 struct list_head mw_all; 251 }; 252 253 /* 254 * struct rpcrdma_req -- structure central to the request/reply sequence. 255 * 256 * N of these are associated with a transport instance, and stored in 257 * struct rpcrdma_buffer. N is the max number of outstanding requests. 258 * 259 * It includes pre-registered buffer memory for send AND recv. 260 * The recv buffer, however, is not owned by this structure, and 261 * is "donated" to the hardware when a recv is posted. When a 262 * reply is handled, the recv buffer used is given back to the 263 * struct rpcrdma_req associated with the request. 264 * 265 * In addition to the basic memory, this structure includes an array 266 * of iovs for send operations. The reason is that the iovs passed to 267 * ib_post_{send,recv} must not be modified until the work request 268 * completes. 269 * 270 * NOTES: 271 * o RPCRDMA_MAX_SEGS is the max number of addressible chunk elements we 272 * marshal. The number needed varies depending on the iov lists that 273 * are passed to us, the memory registration mode we are in, and if 274 * physical addressing is used, the layout. 275 */ 276 277 struct rpcrdma_mr_seg { /* chunk descriptors */ 278 struct rpcrdma_mw *rl_mw; /* registered MR */ 279 u64 mr_base; /* registration result */ 280 u32 mr_rkey; /* registration result */ 281 u32 mr_len; /* length of chunk or segment */ 282 int mr_nsegs; /* number of segments in chunk or 0 */ 283 enum dma_data_direction mr_dir; /* segment mapping direction */ 284 dma_addr_t mr_dma; /* segment mapping address */ 285 size_t mr_dmalen; /* segment mapping length */ 286 struct page *mr_page; /* owning page, if any */ 287 char *mr_offset; /* kva if no page, else offset */ 288 }; 289 290 #define RPCRDMA_MAX_IOVS (2) 291 292 struct rpcrdma_req { 293 struct list_head rl_free; 294 unsigned int rl_niovs; 295 unsigned int rl_nchunks; 296 unsigned int rl_connect_cookie; 297 struct rpc_task *rl_task; 298 struct rpcrdma_buffer *rl_buffer; 299 struct rpcrdma_rep *rl_reply;/* holder for reply buffer */ 300 struct ib_sge rl_send_iov[RPCRDMA_MAX_IOVS]; 301 struct rpcrdma_regbuf *rl_rdmabuf; 302 struct rpcrdma_regbuf *rl_sendbuf; 303 struct rpcrdma_mr_seg rl_segments[RPCRDMA_MAX_SEGS]; 304 struct rpcrdma_mr_seg *rl_nextseg; 305 306 struct ib_cqe rl_cqe; 307 struct list_head rl_all; 308 bool rl_backchannel; 309 }; 310 311 static inline struct rpcrdma_req * 312 rpcr_to_rdmar(struct rpc_rqst *rqst) 313 { 314 void *buffer = rqst->rq_buffer; 315 struct rpcrdma_regbuf *rb; 316 317 rb = container_of(buffer, struct rpcrdma_regbuf, rg_base); 318 return rb->rg_owner; 319 } 320 321 /* 322 * struct rpcrdma_buffer -- holds list/queue of pre-registered memory for 323 * inline requests/replies, and client/server credits. 324 * 325 * One of these is associated with a transport instance 326 */ 327 struct rpcrdma_buffer { 328 spinlock_t rb_mwlock; /* protect rb_mws list */ 329 struct list_head rb_mws; 330 struct list_head rb_all; 331 char *rb_pool; 332 333 spinlock_t rb_lock; /* protect buf lists */ 334 struct list_head rb_send_bufs; 335 struct list_head rb_recv_bufs; 336 u32 rb_max_requests; 337 atomic_t rb_credits; /* most recent credit grant */ 338 339 u32 rb_bc_srv_max_requests; 340 spinlock_t rb_reqslock; /* protect rb_allreqs */ 341 struct list_head rb_allreqs; 342 343 u32 rb_bc_max_requests; 344 }; 345 #define rdmab_to_ia(b) (&container_of((b), struct rpcrdma_xprt, rx_buf)->rx_ia) 346 347 /* 348 * Internal structure for transport instance creation. This 349 * exists primarily for modularity. 350 * 351 * This data should be set with mount options 352 */ 353 struct rpcrdma_create_data_internal { 354 struct sockaddr_storage addr; /* RDMA server address */ 355 unsigned int max_requests; /* max requests (slots) in flight */ 356 unsigned int rsize; /* mount rsize - max read hdr+data */ 357 unsigned int wsize; /* mount wsize - max write hdr+data */ 358 unsigned int inline_rsize; /* max non-rdma read data payload */ 359 unsigned int inline_wsize; /* max non-rdma write data payload */ 360 unsigned int padding; /* non-rdma write header padding */ 361 }; 362 363 #define RPCRDMA_INLINE_READ_THRESHOLD(rq) \ 364 (rpcx_to_rdmad(rq->rq_xprt).inline_rsize) 365 366 #define RPCRDMA_INLINE_WRITE_THRESHOLD(rq)\ 367 (rpcx_to_rdmad(rq->rq_xprt).inline_wsize) 368 369 #define RPCRDMA_INLINE_PAD_VALUE(rq)\ 370 rpcx_to_rdmad(rq->rq_xprt).padding 371 372 /* 373 * Statistics for RPCRDMA 374 */ 375 struct rpcrdma_stats { 376 unsigned long read_chunk_count; 377 unsigned long write_chunk_count; 378 unsigned long reply_chunk_count; 379 380 unsigned long long total_rdma_request; 381 unsigned long long total_rdma_reply; 382 383 unsigned long long pullup_copy_count; 384 unsigned long long fixup_copy_count; 385 unsigned long hardway_register_count; 386 unsigned long failed_marshal_count; 387 unsigned long bad_reply_count; 388 unsigned long nomsg_call_count; 389 unsigned long bcall_count; 390 }; 391 392 /* 393 * Per-registration mode operations 394 */ 395 struct rpcrdma_xprt; 396 struct rpcrdma_memreg_ops { 397 int (*ro_map)(struct rpcrdma_xprt *, 398 struct rpcrdma_mr_seg *, int, bool); 399 void (*ro_unmap_sync)(struct rpcrdma_xprt *, 400 struct rpcrdma_req *); 401 void (*ro_unmap_safe)(struct rpcrdma_xprt *, 402 struct rpcrdma_req *, bool); 403 int (*ro_open)(struct rpcrdma_ia *, 404 struct rpcrdma_ep *, 405 struct rpcrdma_create_data_internal *); 406 size_t (*ro_maxpages)(struct rpcrdma_xprt *); 407 int (*ro_init)(struct rpcrdma_xprt *); 408 void (*ro_destroy)(struct rpcrdma_buffer *); 409 const char *ro_displayname; 410 }; 411 412 extern const struct rpcrdma_memreg_ops rpcrdma_fmr_memreg_ops; 413 extern const struct rpcrdma_memreg_ops rpcrdma_frwr_memreg_ops; 414 extern const struct rpcrdma_memreg_ops rpcrdma_physical_memreg_ops; 415 416 /* 417 * RPCRDMA transport -- encapsulates the structures above for 418 * integration with RPC. 419 * 420 * The contained structures are embedded, not pointers, 421 * for convenience. This structure need not be visible externally. 422 * 423 * It is allocated and initialized during mount, and released 424 * during unmount. 425 */ 426 struct rpcrdma_xprt { 427 struct rpc_xprt rx_xprt; 428 struct rpcrdma_ia rx_ia; 429 struct rpcrdma_ep rx_ep; 430 struct rpcrdma_buffer rx_buf; 431 struct rpcrdma_create_data_internal rx_data; 432 struct delayed_work rx_connect_worker; 433 struct rpcrdma_stats rx_stats; 434 }; 435 436 #define rpcx_to_rdmax(x) container_of(x, struct rpcrdma_xprt, rx_xprt) 437 #define rpcx_to_rdmad(x) (rpcx_to_rdmax(x)->rx_data) 438 439 /* Setting this to 0 ensures interoperability with early servers. 440 * Setting this to 1 enhances certain unaligned read/write performance. 441 * Default is 0, see sysctl entry and rpc_rdma.c rpcrdma_convert_iovs() */ 442 extern int xprt_rdma_pad_optimize; 443 444 /* 445 * Interface Adapter calls - xprtrdma/verbs.c 446 */ 447 int rpcrdma_ia_open(struct rpcrdma_xprt *, struct sockaddr *, int); 448 void rpcrdma_ia_close(struct rpcrdma_ia *); 449 450 /* 451 * Endpoint calls - xprtrdma/verbs.c 452 */ 453 int rpcrdma_ep_create(struct rpcrdma_ep *, struct rpcrdma_ia *, 454 struct rpcrdma_create_data_internal *); 455 void rpcrdma_ep_destroy(struct rpcrdma_ep *, struct rpcrdma_ia *); 456 int rpcrdma_ep_connect(struct rpcrdma_ep *, struct rpcrdma_ia *); 457 void rpcrdma_ep_disconnect(struct rpcrdma_ep *, struct rpcrdma_ia *); 458 459 int rpcrdma_ep_post(struct rpcrdma_ia *, struct rpcrdma_ep *, 460 struct rpcrdma_req *); 461 int rpcrdma_ep_post_recv(struct rpcrdma_ia *, struct rpcrdma_ep *, 462 struct rpcrdma_rep *); 463 464 /* 465 * Buffer calls - xprtrdma/verbs.c 466 */ 467 struct rpcrdma_req *rpcrdma_create_req(struct rpcrdma_xprt *); 468 struct rpcrdma_rep *rpcrdma_create_rep(struct rpcrdma_xprt *); 469 void rpcrdma_destroy_req(struct rpcrdma_ia *, struct rpcrdma_req *); 470 int rpcrdma_buffer_create(struct rpcrdma_xprt *); 471 void rpcrdma_buffer_destroy(struct rpcrdma_buffer *); 472 473 struct rpcrdma_mw *rpcrdma_get_mw(struct rpcrdma_xprt *); 474 void rpcrdma_put_mw(struct rpcrdma_xprt *, struct rpcrdma_mw *); 475 struct rpcrdma_req *rpcrdma_buffer_get(struct rpcrdma_buffer *); 476 void rpcrdma_buffer_put(struct rpcrdma_req *); 477 void rpcrdma_recv_buffer_get(struct rpcrdma_req *); 478 void rpcrdma_recv_buffer_put(struct rpcrdma_rep *); 479 480 struct rpcrdma_regbuf *rpcrdma_alloc_regbuf(struct rpcrdma_ia *, 481 size_t, gfp_t); 482 void rpcrdma_free_regbuf(struct rpcrdma_ia *, 483 struct rpcrdma_regbuf *); 484 485 int rpcrdma_ep_post_extra_recv(struct rpcrdma_xprt *, unsigned int); 486 487 int frwr_alloc_recovery_wq(void); 488 void frwr_destroy_recovery_wq(void); 489 490 int rpcrdma_alloc_wq(void); 491 void rpcrdma_destroy_wq(void); 492 493 /* 494 * Wrappers for chunk registration, shared by read/write chunk code. 495 */ 496 497 void rpcrdma_mapping_error(struct rpcrdma_mr_seg *); 498 499 static inline enum dma_data_direction 500 rpcrdma_data_dir(bool writing) 501 { 502 return writing ? DMA_FROM_DEVICE : DMA_TO_DEVICE; 503 } 504 505 static inline void 506 rpcrdma_map_one(struct ib_device *device, struct rpcrdma_mr_seg *seg, 507 enum dma_data_direction direction) 508 { 509 seg->mr_dir = direction; 510 seg->mr_dmalen = seg->mr_len; 511 512 if (seg->mr_page) 513 seg->mr_dma = ib_dma_map_page(device, 514 seg->mr_page, offset_in_page(seg->mr_offset), 515 seg->mr_dmalen, seg->mr_dir); 516 else 517 seg->mr_dma = ib_dma_map_single(device, 518 seg->mr_offset, 519 seg->mr_dmalen, seg->mr_dir); 520 521 if (ib_dma_mapping_error(device, seg->mr_dma)) 522 rpcrdma_mapping_error(seg); 523 } 524 525 static inline void 526 rpcrdma_unmap_one(struct ib_device *device, struct rpcrdma_mr_seg *seg) 527 { 528 if (seg->mr_page) 529 ib_dma_unmap_page(device, 530 seg->mr_dma, seg->mr_dmalen, seg->mr_dir); 531 else 532 ib_dma_unmap_single(device, 533 seg->mr_dma, seg->mr_dmalen, seg->mr_dir); 534 } 535 536 /* 537 * RPC/RDMA connection management calls - xprtrdma/rpc_rdma.c 538 */ 539 void rpcrdma_connect_worker(struct work_struct *); 540 void rpcrdma_conn_func(struct rpcrdma_ep *); 541 void rpcrdma_reply_handler(struct rpcrdma_rep *); 542 543 /* 544 * RPC/RDMA protocol calls - xprtrdma/rpc_rdma.c 545 */ 546 int rpcrdma_marshal_req(struct rpc_rqst *); 547 void rpcrdma_set_max_header_sizes(struct rpcrdma_ia *, 548 struct rpcrdma_create_data_internal *, 549 unsigned int); 550 551 /* RPC/RDMA module init - xprtrdma/transport.c 552 */ 553 extern unsigned int xprt_rdma_max_inline_read; 554 void xprt_rdma_format_addresses(struct rpc_xprt *xprt, struct sockaddr *sap); 555 void xprt_rdma_free_addresses(struct rpc_xprt *xprt); 556 void xprt_rdma_print_stats(struct rpc_xprt *xprt, struct seq_file *seq); 557 int xprt_rdma_init(void); 558 void xprt_rdma_cleanup(void); 559 560 /* Backchannel calls - xprtrdma/backchannel.c 561 */ 562 #if defined(CONFIG_SUNRPC_BACKCHANNEL) 563 int xprt_rdma_bc_setup(struct rpc_xprt *, unsigned int); 564 int xprt_rdma_bc_up(struct svc_serv *, struct net *); 565 size_t xprt_rdma_bc_maxpayload(struct rpc_xprt *); 566 int rpcrdma_bc_post_recv(struct rpcrdma_xprt *, unsigned int); 567 void rpcrdma_bc_receive_call(struct rpcrdma_xprt *, struct rpcrdma_rep *); 568 int rpcrdma_bc_marshal_reply(struct rpc_rqst *); 569 void xprt_rdma_bc_free_rqst(struct rpc_rqst *); 570 void xprt_rdma_bc_destroy(struct rpc_xprt *, unsigned int); 571 #endif /* CONFIG_SUNRPC_BACKCHANNEL */ 572 573 extern struct xprt_class xprt_rdma_bc; 574 575 #endif /* _LINUX_SUNRPC_XPRT_RDMA_H */ 576