xref: /titanic_41/usr/src/uts/common/rpc/rpc_rdma.h (revision 0a4b08109ed53cd50c90d18c62198d62eec19da0)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
23  */
24 
25 /*
26  * Copyright (c) 2007, The Ohio State University. All rights reserved.
27  *
28  * Portions of this source code is developed by the team members of
29  * The Ohio State University's Network-Based Computing Laboratory (NBCL),
30  * headed by Professor Dhabaleswar K. (DK) Panda.
31  *
32  * Acknowledgements to contributions from developors:
33  *   Ranjit Noronha: noronha@cse.ohio-state.edu
34  *   Lei Chai      : chail@cse.ohio-state.edu
35  *   Weikuan Yu    : yuw@cse.ohio-state.edu
36  *
37  */
38 
39 #ifndef	_RPC_RPC_RDMA_H
40 #define	_RPC_RPC_RDMA_H
41 
42 #include <rpc/rpc.h>
43 #include <rpc/rpc_sztypes.h>
44 #include <sys/sunddi.h>
45 #include <sys/sunldi.h>
46 
47 #ifdef __cplusplus
48 extern "C" {
49 #endif
50 
51 #define	RPCRDMA_VERS	1	/* Version of the RPC over RDMA protocol */
52 #define	RDMATF_VERS	1	/* Version of the API used by RPC for RDMA */
53 #define	RDMATF_VERS_1	1	/* Current version of RDMATF */
54 
55 /*
56  * The size of an RPC call or reply message
57  */
58 #define	RPC_MSG_SZ	1024
59 
60 /*
61  * RDMA chunk size
62  */
63 #define	RDMA_MINCHUNK	1024
64 
65 /*
66  * Storage for a chunk list
67  */
68 #define	RPC_CL_SZ  1024
69 
70 /*
71  * Chunk size
72  */
73 #define	MINCHUNK  1024
74 
75 /*
76  * Size of receive buffer
77  */
78 #define	RPC_BUF_SIZE	2048
79 
80 #define	NOWAIT	0	/* don't wait for operation of complete */
81 #define	WAIT	1	/* wait and ensure that operation is complete */
82 
83 /*
84  * RDMA xdr buffer control and other control flags. Add new flags here,
85  * set them in private structure for xdr over RDMA in xdr_rdma.c
86  */
87 #define	XDR_RDMA_CHUNK			0x1
88 #define	XDR_RDMA_WLIST_REG		0x2
89 #define	XDR_RDMA_RLIST_REG		0x4
90 
91 #define	LONG_REPLY_LEN	65536
92 #define	WCL_BUF_LEN	32768
93 #define	RCL_BUF_LEN	32768
94 
95 
96 #define	RDMA_BUFS_RQST	34	/* Num bufs requested by client */
97 #define	RDMA_BUFS_GRANT	32	/* Num bufs granted by server */
98 
99 struct xdr_ops *xdrrdma_xops(void);
100 
101 /*
102  * Credit Control Structures.
103  */
104 typedef enum rdma_cc_type {
105 	RDMA_CC_CLNT,	/* CONN is for a client */
106 	RDMA_CC_SRV	/* CONN is for a server */
107 } rdma_cc_type_t;
108 
109 /*
110  * Client side credit control data structure.
111  */
112 typedef struct rdma_clnt_cred_ctrl {
113 	uint32_t	clnt_cc_granted_ops;
114 	uint32_t	clnt_cc_in_flight_ops;
115 	kcondvar_t	clnt_cc_cv;
116 } rdma_clnt_cred_ctrl_t;
117 
118 /*
119  * Server side credit control data structure.
120  */
121 typedef struct rdma_srv_cred_ctrl {
122 	uint32_t	srv_cc_buffers_granted;
123 	uint32_t	srv_cc_cur_buffers_used;
124 	uint32_t	srv_cc_posted;
125 	uint32_t	srv_cc_max_buf_size;	/* to be determined by CCP */
126 	uint32_t	srv_cc_cur_buf_size;	/* to be determined by CCP */
127 } rdma_srv_cred_ctrl_t;
128 
129 typedef enum {
130     RPCCALL_WLIST,
131     RPCCALL_WCHUNK,
132     RPCCALL_NOWRITE
133 }rpccall_write_t;
134 
135 typedef enum {
136 	CLIST_REG_SOURCE = 1,
137 	CLIST_REG_DST
138 } clist_dstsrc;
139 
140 /*
141  * Return codes from RDMA operations
142  */
143 typedef enum {
144 
145 	RDMA_SUCCESS = 0,	/* successful operation */
146 
147 	RDMA_INVAL = 1,		/* invalid parameter */
148 	RDMA_TIMEDOUT = 2,	/* operation timed out */
149 	RDMA_INTR = 3,		/* operation interrupted */
150 	RDMA_NORESOURCE = 4,	/* insufficient resource */
151 	/*
152 	 * connection errors
153 	 */
154 	RDMA_REJECT = 5,	/* connection req rejected */
155 	RDMA_NOLISTENER = 6,	/* no listener on server */
156 	RDMA_UNREACHABLE = 7,	/* host unreachable */
157 	RDMA_CONNLOST = 8,	/* connection lost */
158 
159 	RDMA_XPRTFAILED = 9,	/* RDMA transport failed */
160 	RDMA_PROTECTERR = 10,	/* memory protection error */
161 	RDMA_OVERRUN = 11,	/* transport overrun */
162 	RDMA_RECVQEMPTY = 12,	/* incoming pkt dropped, recv q empty */
163 	RDMA_PROTFAILED = 13,	/* RDMA protocol failed */
164 	RDMA_NOTSUPP = 14,	/* requested feature not supported */
165 	RDMA_REMOTERR = 15,	/* error at remote end */
166 	/*
167 	 * RDMATF errors
168 	 */
169 	RDMA_BADVERS = 16,	/* mismatch RDMATF versions */
170 	RDMA_REG_EXIST = 17,	/* RDMATF registration already exists */
171 	RDMA_HCA_ATTACH = 18,
172 	RDMA_HCA_DETACH = 19,
173 
174 	/*
175 	 * fallback error
176 	 */
177 	RDMA_FAILED = 20	/* generic error */
178 } rdma_stat;
179 
180 /*
181  * Memory region context. This is an RDMA provider generated
182  * handle for a registered arbitrary size contiguous virtual
183  * memory. The RDMA Interface Adapter needs this for local or
184  * remote memory access.
185  *
186  * The mrc_rmr field holds the remote memory region context
187  * which is sent over-the-wire to provide the remote host
188  * with RDMA access to the memory region.
189  */
190 struct mrc {
191 	uint32_t	mrc_rmr;	/* Remote MR context, sent OTW */
192 	union {
193 		struct mr {
194 			uint32_t	lmr; 	/* Local MR context */
195 			uint64_t	linfo;	/* Local memory info */
196 		} mr;
197 	} lhdl;
198 };
199 
200 #define	mrc_lmr		lhdl.mr.lmr
201 #define	mrc_linfo	lhdl.mr.linfo
202 
203 /*
204  * Memory management for the RDMA buffers
205  */
206 /*
207  * RDMA buffer types
208  */
209 typedef enum {
210 	SEND_BUFFER,	/* buf for send msg */
211 	SEND_DESCRIPTOR, /* buf used for send msg descriptor in plugins only */
212 	RECV_BUFFER,	/* buf for recv msg */
213 	RECV_DESCRIPTOR, /* buf used for recv msg descriptor in plugins only */
214 	RDMA_LONG_BUFFER /* chunk buf used in RDMATF only and not in plugins */
215 } rdma_btype;
216 
217 /*
218  * RDMA buffer information
219  */
220 typedef struct rdma_buf {
221 	rdma_btype	type;	/* buffer type */
222 	uint_t		len;	/* length of buffer */
223 	caddr_t		addr;	/* buffer address */
224 	struct mrc	handle;	/* buffer registration handle */
225 	caddr_t		rb_private;
226 } rdma_buf_t;
227 
228 
229 /*
230  * The XDR offset value is used by the XDR
231  * routine to identify the position in the
232  * RPC message where the opaque object would
233  * normally occur. Neither the data content
234  * of the chunk, nor its size field are included
235  * in the RPC message.  The XDR offset is calculated
236  * as if the chunks were present.
237  *
238  * The remaining fields identify the chunk of data
239  * on the sender.  The c_memhandle identifies a
240  * registered RDMA memory region and the c_addr
241  * and c_len fields identify the chunk within it.
242  */
243 struct clist {
244 	uint32		c_xdroff;	/* XDR offset */
245 	uint32		c_len;		/* Length */
246 	clist_dstsrc	c_regtype;	/* type of registration */
247 	struct mrc	c_smemhandle;	/* src memory handle */
248 	uint64 		c_ssynchandle;	/* src sync handle */
249 	union {
250 		uint64		c_saddr;	/* src address */
251 		caddr_t 	c_saddr3;
252 	} w;
253 	struct mrc	c_dmemhandle;	/* dst memory handle */
254 	uint64		c_dsynchandle;	/* dst sync handle */
255 	union {
256 		uint64	c_daddr;	/* dst address */
257 		caddr_t	c_daddr3;
258 	} u;
259 	struct as	*c_adspc;	/* address space for saddr/daddr */
260 	rdma_buf_t	rb_longbuf;	/* used for long requests/replies */
261 	struct clist	*c_next;	/* Next chunk */
262 };
263 
264 typedef struct clist clist;
265 
266 /*
267  * max 4M wlist xfer size
268  * This is defined because the rfs3_tsize service requires
269  * svc_req struct (which we don't have that in krecv).
270  */
271 #define	MAX_SVC_XFER_SIZE (4*1024*1024)
272 
273 enum rdma_proc {
274 	RDMA_MSG	= 0,	/* chunk list and RPC msg follow */
275 	RDMA_NOMSG	= 1,	/* only chunk list follows */
276 	RDMA_MSGP	= 2,	/* chunk list and RPC msg with padding follow */
277 	RDMA_DONE	= 3	/* signal completion of chunk transfer */
278 };
279 
280 /*
281  * Listener information for a service
282  */
283 struct rdma_svc_data {
284 	queue_t		q;	/* queue_t to place incoming pkts */
285 	int		active;	/* If active, after registeration startup */
286 	rdma_stat	err_code;	/* Error code from plugin layer */
287 	int32_t		svcid;		/* RDMA based service identifier */
288 };
289 
290 /*
291  * Per RDMA plugin module information.
292  * Will be populated by each plugin
293  * module during its initialization.
294  */
295 typedef struct rdma_mod {
296 	char 		*rdma_api;		/* "kvipl", "ibtf", etc */
297 	uint_t 		rdma_version;		/* RDMATF API version */
298 	int		rdma_count;		/* # of devices */
299 	struct rdmaops 	*rdma_ops;		/* rdma op vector for api */
300 } rdma_mod_t;
301 
302 /*
303  * Registry of RDMA plugins
304  */
305 typedef struct rdma_registry {
306 	rdma_mod_t	*r_mod;		/* plugin mod info */
307 	uint32_t	r_mod_state;
308 	struct rdma_registry *r_next;	/* next registered RDMA plugin */
309 } rdma_registry_t;
310 
311 /*
312  * RDMA MODULE state flags (r_mod_state).
313  */
314 #define	RDMA_MOD_ACTIVE		1
315 #define	RDMA_MOD_INACTIVE	0
316 
317 /*
318  * RDMA transport information
319  */
320 typedef struct rdma_info {
321 	uint_t	addrlen;	/* address length */
322 	uint_t  mts;		/* max transfer size */
323 	uint_t  mtu;		/* native mtu size of unlerlying network */
324 } rdma_info_t;
325 
326 typedef enum {
327 	C_IDLE		= 0x00000001,
328 	C_CONN_PEND	= 0x00000002,
329 	C_CONNECTED	= 0x00000004,
330 	C_ERROR_CONN	= 0x00000008,
331 	C_DISCONN_PEND	= 0x00000010,
332 	C_REMOTE_DOWN	= 0x00000020
333 } conn_c_state;
334 
335 /* c_flags */
336 #define	C_CLOSE_NOTNEEDED	0x00000001	/* just free the channel */
337 #define	C_CLOSE_PENDING		0x00000002	/* a close in progress */
338 
339 /*
340  * RDMA Connection information
341  */
342 typedef struct conn {
343 	rdma_mod_t	*c_rdmamod;	/* RDMA transport info for conn */
344 	char 		*c_netid;	/* tcp or tcp6 token */
345 	struct netbuf	c_raddr;	/* remote address */
346 	struct netbuf	c_laddr;	/* local address */
347 	struct netbuf	c_addrmask;	/* Address Mask */
348 	int		c_ref;		/* no. of clients of connection */
349 	struct conn	*c_next;	/* next in list of connections */
350 	struct conn	*c_prev;	/* prev in list of connections */
351 	caddr_t		c_private;	/* transport specific stuff */
352 	conn_c_state	c_state;	/* state of connection */
353 	int		c_flags;	/* flags for connection management */
354 	rdma_cc_type_t	c_cc_type;	/* client or server, for credit cntrl */
355 	union {
356 		rdma_clnt_cred_ctrl_t	c_clnt_cc;
357 		rdma_srv_cred_ctrl_t	c_srv_cc;
358 	} rdma_conn_cred_ctrl_u;
359 	kmutex_t	c_lock;		/* protect c_state and c_ref fields */
360 	kcondvar_t	c_cv;		/* to signal when pending is done */
361 	timeout_id_t	c_timeout;	/* timeout id for untimeout() */
362 	time_t		c_last_used;	/* last time any activity on the conn */
363 } CONN;
364 
365 
366 /*
367  * Data transferred from plugin interrupt to svc_queuereq()
368  */
369 typedef struct rdma_recv_data {
370 	CONN		*conn;
371 	int		status;
372 	rdma_buf_t	rpcmsg;
373 } rdma_recv_data_t;
374 
375 /* structure used to pass information for READ over rdma write */
376 typedef enum {
377 	RCI_WRITE_UIO_CHUNK = 1,
378 	RCI_WRITE_ADDR_CHUNK = 2,
379 	RCI_REPLY_CHUNK = 3
380 } rci_type_t;
381 
382 typedef struct {
383 	rci_type_t rci_type;
384 	union {
385 		struct uio *rci_uiop;
386 		caddr_t    rci_addr;
387 	} rci_a;
388 	uint32	rci_len;
389 	struct clist	**rci_clpp; /* point to write chunk list in readargs */
390 } rdma_chunkinfo_t;
391 
392 typedef struct {
393 	uint_t rcil_len;
394 	uint_t rcil_len_alt;
395 } rdma_chunkinfo_lengths_t;
396 
397 typedef struct {
398 	struct	clist	*rwci_wlist;
399 	CONN		*rwci_conn;
400 } rdma_wlist_conn_info_t;
401 
402 /*
403  * Operations vector for RDMA transports.
404  */
405 typedef struct rdmaops {
406 	/* Network */
407 	rdma_stat	(*rdma_reachable)(int addr_type, struct netbuf *,
408 						void **handle);
409 	/* Connection */
410 	rdma_stat	(*rdma_get_conn)(struct netbuf *, struct netbuf *,
411 					int addr_type, void *, CONN **);
412 	rdma_stat	(*rdma_rel_conn)(CONN *);
413 	/* Server side listner start and stop routines */
414 	void		(*rdma_svc_listen)(struct rdma_svc_data *);
415 	void		(*rdma_svc_stop)(struct rdma_svc_data *);
416 	/* Memory */
417 	rdma_stat	(*rdma_regmem)(CONN *, caddr_t, caddr_t,
418 			    uint_t, struct mrc *);
419 	rdma_stat	(*rdma_deregmem)(CONN *, caddr_t, struct mrc);
420 	rdma_stat	(*rdma_regmemsync)(CONN *, caddr_t, caddr_t, uint_t,
421 				struct mrc *, void **, void *);
422 	rdma_stat	(*rdma_deregmemsync)(CONN *, caddr_t, struct mrc,
423 			    void *, void *);
424 	rdma_stat	(*rdma_syncmem)(CONN *, void *, caddr_t, int, int);
425 	/* Buffer */
426 	rdma_stat	(*rdma_buf_alloc)(CONN *, rdma_buf_t *);
427 	void		(*rdma_buf_free)(CONN *, rdma_buf_t *);
428 	/* Transfer */
429 	rdma_stat	(*rdma_send)(CONN *, clist *, uint32_t);
430 	rdma_stat	(*rdma_send_resp)(CONN *, clist *, uint32_t);
431 	rdma_stat	(*rdma_clnt_recvbuf)(CONN *, clist *, uint32_t);
432 	rdma_stat	(*rdma_clnt_recvbuf_remove)(CONN *, uint32_t);
433 	rdma_stat	(*rdma_svc_recvbuf)(CONN *, clist *);
434 	rdma_stat	(*rdma_recv)(CONN *, clist **, uint32_t);
435 	/* RDMA */
436 	rdma_stat	(*rdma_read)(CONN *, clist *, int);
437 	rdma_stat	(*rdma_write)(CONN *, clist *, int);
438 	/* INFO */
439 	rdma_stat	(*rdma_getinfo)(rdma_info_t *info);
440 } rdmaops_t;
441 
442 typedef struct rdma_svc_wait {
443 	kmutex_t svc_lock;
444 	kcondvar_t svc_cv;
445 	rdma_stat svc_stat;
446 } rdma_svc_wait_t;
447 
448 extern rdma_svc_wait_t rdma_wait;
449 
450 /*
451  * RDMA operations.
452  */
453 #define	RDMA_REACHABLE(rdma_ops, addr_type, addr, handle)	\
454 	(*(rdma_ops)->rdma_reachable)(addr_type, addr, handle)
455 
456 #define	RDMA_GET_CONN(rdma_ops, saddr, daddr, addr_type, handle, conn)	\
457 	(*(rdma_ops)->rdma_get_conn)(saddr, daddr, addr_type, handle, conn)
458 
459 #define	RDMA_REL_CONN(conn)	\
460 	(*(conn)->c_rdmamod->rdma_ops->rdma_rel_conn)(conn)
461 
462 #define	RDMA_REGMEM(conn, adsp, buff, len, handle)	\
463 	(*(conn)->c_rdmamod->rdma_ops->rdma_regmem)(conn, adsp,	\
464 		buff, len, handle)
465 
466 #define	RDMA_DEREGMEM(conn, buff, handle)	\
467 	(*(conn)->c_rdmamod->rdma_ops->rdma_deregmem)(conn, buff, handle)
468 
469 #define	RDMA_REGMEMSYNC(conn, adsp, buff, len, handle, synchandle, lrc)	\
470 	(*(conn)->c_rdmamod->rdma_ops->rdma_regmemsync)(conn, adsp, buff, \
471 	len, handle, synchandle, lrc)
472 
473 #define	RDMA_DEREGMEMSYNC(conn, buff, handle, synchandle, lrc)	\
474 	(*(conn)->c_rdmamod->rdma_ops->rdma_deregmemsync)(conn, buff,	\
475 	handle, synchandle, lrc)
476 
477 #define	RDMA_SYNCMEM(conn, handle, buff, len, direction)	\
478 	(*(conn)->c_rdmamod->rdma_ops->rdma_syncmem)(conn, handle, \
479 	    buff, len, direction)
480 
481 #define	RDMA_BUF_ALLOC(conn, rbuf)	\
482 	(*(conn)->c_rdmamod->rdma_ops->rdma_buf_alloc)(conn, rbuf)
483 
484 #define	RDMA_BUF_FREE(conn, rbuf)	\
485 	(*(conn)->c_rdmamod->rdma_ops->rdma_buf_free)(conn, rbuf)
486 
487 #define	RDMA_SEND(conn, sendlist, xid)	\
488 	(*(conn)->c_rdmamod->rdma_ops->rdma_send)(conn, sendlist, xid)
489 
490 #define	RDMA_SEND_RESP(conn, sendlist, xid)	\
491 	(*(conn)->c_rdmamod->rdma_ops->rdma_send_resp)(conn, sendlist, xid)
492 
493 #define	RDMA_CLNT_RECVBUF(conn, cl, xid)	\
494 	(*(conn)->c_rdmamod->rdma_ops->rdma_clnt_recvbuf)(conn, cl, xid)
495 
496 #define	RDMA_CLNT_RECVBUF_REMOVE(conn, xid)	\
497 	(*(conn)->c_rdmamod->rdma_ops->rdma_clnt_recvbuf_remove)(conn, xid)
498 
499 #define	RDMA_SVC_RECVBUF(conn, cl)	\
500 	(*(conn)->c_rdmamod->rdma_ops->rdma_svc_recvbuf)(conn, cl)
501 
502 #define	RDMA_RECV(conn, recvlist, xid)	\
503 	(*(conn)->c_rdmamod->rdma_ops->rdma_recv)(conn, recvlist, xid)
504 
505 #define	RDMA_READ(conn, cl, wait)	\
506 	(*(conn)->c_rdmamod->rdma_ops->rdma_read)(conn, cl, wait)
507 
508 #define	RDMA_WRITE(conn, cl, wait)	\
509 	(*(conn)->c_rdmamod->rdma_ops->rdma_write)(conn, cl, wait)
510 
511 #define	RDMA_GETINFO(rdma_mod, info)	\
512 	(*(rdma_mod)->rdma_ops->rdma_getinfo)(info)
513 
514 #ifdef _KERNEL
515 extern rdma_registry_t	*rdma_mod_head;
516 extern krwlock_t rdma_lock;		/* protects rdma_mod_head list */
517 extern int rdma_modloaded;		/* flag for loading RDMA plugins */
518 extern int rdma_dev_available;		/* rdma device is loaded or not */
519 extern kmutex_t rdma_modload_lock;	/* protects rdma_modloaded flag */
520 extern uint_t rdma_minchunk;
521 extern ldi_ident_t rpcmod_li; 		/* needed by layed driver framework */
522 
523 /*
524  * General RDMA routines
525  */
526 extern struct clist *clist_alloc(void);
527 extern void clist_add(struct clist **, uint32_t, int,
528 	struct mrc *, caddr_t, struct mrc *, caddr_t);
529 extern void clist_free(struct clist *);
530 extern uint32_t clist_len(struct clist *);
531 extern void clist_zero_len(struct clist *);
532 extern rdma_stat clist_register(CONN *conn, struct clist *cl, clist_dstsrc);
533 extern rdma_stat clist_deregister(CONN *conn, struct clist *cl);
534 extern rdma_stat clist_syncmem(CONN *conn, struct clist *cl, clist_dstsrc);
535 extern rdma_stat rdma_clnt_postrecv(CONN *conn, uint32_t xid);
536 extern rdma_stat rdma_clnt_postrecv_remove(CONN *conn, uint32_t xid);
537 extern rdma_stat rdma_svc_postrecv(CONN *conn);
538 extern rdma_stat rdma_register_mod(rdma_mod_t *mod);
539 extern rdma_stat rdma_unregister_mod(rdma_mod_t *mod);
540 extern rdma_stat rdma_buf_alloc(CONN *, rdma_buf_t *);
541 extern void rdma_buf_free(CONN *, rdma_buf_t *);
542 extern int rdma_modload();
543 extern bool_t   rdma_get_wchunk(struct svc_req *, iovec_t *, struct clist *);
544 extern rdma_stat rdma_kwait(void);
545 extern int rdma_setup_read_chunks(struct clist *, uint32_t, int *);
546 
547 /*
548  * RDMA XDR
549  */
550 extern void xdrrdma_create(XDR *, caddr_t, uint_t, int, struct clist *,
551 	enum xdr_op, CONN *);
552 extern void xdrrdma_destroy(XDR *);
553 
554 extern uint_t xdrrdma_getpos(XDR *);
555 extern bool_t xdrrdma_setpos(XDR *, uint_t);
556 extern bool_t xdr_clist(XDR *, clist *);
557 extern bool_t xdr_do_clist(XDR *, clist **);
558 extern uint_t xdr_getbufsize(XDR *);
559 extern unsigned int xdrrdma_sizeof(xdrproc_t, void *, int, uint_t *, uint_t *);
560 extern unsigned int xdrrdma_authsize(AUTH *, struct cred *, int);
561 
562 extern void xdrrdma_store_wlist(XDR *, struct clist *);
563 extern struct clist *xdrrdma_wclist(XDR *);
564 extern bool_t xdr_decode_reply_wchunk(XDR *, struct clist **);
565 extern bool_t xdr_decode_wlist(XDR *xdrs, struct clist **, bool_t *);
566 extern bool_t xdr_decode_wlist_svc(XDR *xdrs, struct clist **, bool_t *,
567 	uint32_t *, CONN *);
568 extern bool_t xdr_encode_rlist_svc(XDR *, clist *);
569 extern bool_t xdr_encode_wlist(XDR *, clist *);
570 extern bool_t xdr_encode_reply_wchunk(XDR *, struct clist *,
571 		uint32_t seg_array_len);
572 bool_t xdrrdma_getrdmablk(XDR *, struct clist **, uint_t *,
573 	CONN **conn, const uint_t);
574 bool_t xdrrdma_read_from_client(struct clist *, CONN **, uint_t);
575 bool_t xdrrdma_send_read_data(XDR *, uint_t, struct clist *);
576 bool_t xdrrdma_free_clist(CONN *, struct clist *);
577 #endif /* _KERNEL */
578 
579 #ifdef __cplusplus
580 }
581 #endif
582 
583 #endif	/* _RPC_RPC_RDMA_H */
584