7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22 /*
23 * Copyright 2005 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 #ifndef _RPC_RPC_RDMA_H
28 #define _RPC_RPC_RDMA_H
29
30 #pragma ident "@(#)rpc_rdma.h 1.9 05/06/08 SMI"
31
32 #include <rpc/rpc.h>
33 #include <rpc/rpc_sztypes.h>
34 #include <sys/sunddi.h>
35 #include <sys/sunldi.h>
36
37 #ifdef __cplusplus
38 extern "C" {
39 #endif
40
41 #define RPCRDMA_VERS 0 /* Version of the RPC over RDMA protocol */
42 #define RDMATF_VERS 1 /* Version of the API used by RPC for RDMA */
43 #define RDMATF_VERS_1 1 /* Current version of RDMATF */
44
45 /*
46 * The size of an RPC call or reply message
47 */
48 #define RPC_MSG_SZ 1024
49
50 /*
51 * Storage for a chunk list
52 */
53 #define RPC_CL_SZ 1024
54
55 /*
56 * Chunk size
57 */
58 #define MINCHUNK 1024
59
60 /*
61 * Size of receive buffer
62 */
63 #define RPC_BUF_SIZE 2048
64
65 #define NOWAIT 0 /* don't wait for operation of complete */
66 #define WAIT 1 /* wait and ensure that operation is complete */
67
68 /*
69 * RDMA xdr buffer control and other control flags. Add new flags here,
70 * set them in private structure for xdr over RDMA in xdr_rdma.c
71 */
72 #define RDMA_NOCHUNK 0x1
73
74 /*
75 * Return codes from RDMA operations
76 */
77 typedef enum {
78
79 RDMA_SUCCESS = 0, /* successful operation */
80
81 RDMA_INVAL = 1, /* invalid parameter */
82 RDMA_TIMEDOUT = 2, /* operation timed out */
83 RDMA_INTR = 3, /* operation interrupted */
84 RDMA_NORESOURCE = 4, /* insufficient resource */
85 /*
86 * connection errors
87 */
88 RDMA_REJECT = 5, /* connection req rejected */
89 RDMA_NOLISTENER = 6, /* no listener on server */
90 RDMA_UNREACHABLE = 7, /* host unreachable */
91 RDMA_CONNLOST = 8, /* connection lost */
92
93 RDMA_XPRTFAILED = 9, /* RDMA transport failed */
94 RDMA_PROTECTERR = 10, /* memory protection error */
108 */
109 RDMA_FAILED = 18 /* generic error */
110 } rdma_stat;
111
112 /*
113 * Memory region context. This is an RDMA provider generated
114 * handle for a registered arbitrary size contiguous virtual
115 * memory. The RDMA Interface Adapter needs this for local or
116 * remote memory access.
117 *
118 * The mrc_rmr field holds the remote memory region context
119 * which is sent over-the-wire to provide the remote host
120 * with RDMA access to the memory region.
121 */
122 struct mrc {
123 uint32_t mrc_rmr; /* Remote MR context, sent OTW */
124 union {
125 struct mr {
126 uint32_t lmr; /* Local MR context */
127 uint64_t linfo; /* Local memory info */
128 } mr;
129 } lhdl;
130 };
131
132 #define mrc_lmr lhdl.mr.lmr
133 #define mrc_linfo lhdl.mr.linfo
134
135 /*
136 * The XDR offset value is used by the XDR
137 * routine to identify the position in the
138 * RPC message where the opaque object would
139 * normally occur. Neither the data content
140 * of the chunk, nor its size field are included
141 * in the RPC message. The XDR offset is calculated
142 * as if the chunks were present.
143 *
144 * The remaining fields identify the chunk of data
145 * on the sender. The c_memhandle identifies a
146 * registered RDMA memory region and the c_addr
147 * and c_len fields identify the chunk within it.
148 */
149 struct clist {
150 uint32 c_xdroff; /* XDR offset */
151 uint32 c_len; /* Length */
152 struct mrc c_smemhandle; /* src memory handle */
153 uint64 c_ssynchandle; /* src sync handle */
154 uint64 c_saddr; /* src address */
155 struct mrc c_dmemhandle; /* dst memory handle */
156 uint64 c_dsynchandle; /* dst sync handle */
157 uint64 c_daddr; /* dst address */
158 struct clist *c_next; /* Next chunk */
159 };
160
161 typedef struct clist clist;
162
163 enum rdma_proc {
164 RDMA_MSG = 0, /* chunk list and RPC msg follow */
165 RDMA_NOMSG = 1, /* only chunk list follows */
166 RDMA_MSGP = 2, /* chunk list and RPC msg with padding follow */
167 RDMA_DONE = 3 /* signal completion of chunk transfer */
168 };
169
170 /*
171 * Listener information for a service
172 */
173 struct rdma_svc_data {
174 queue_t q; /* queue_t to place incoming pkts */
175 int active; /* If active, after registeration startup */
176 rdma_stat err_code; /* Error code from plugin layer */
177 int32_t svcid; /* RDMA based service identifier */
178 };
179
180 /*
181 * Per RDMA plugin module information.
182 * Will be populated by each plugin
209 /*
210 * RDMA Connection information
211 */
212 typedef struct conn {
213 rdma_mod_t *c_rdmamod; /* RDMA transport info for conn */
214 struct netbuf c_raddr; /* remote address */
215 struct netbuf c_laddr; /* local address */
216 int c_ref; /* no. of clients of connection */
217 struct conn *c_next; /* next in list of connections */
218 struct conn *c_prev; /* prev in list of connections */
219 caddr_t c_private; /* transport specific stuff */
220
221 #define C_IDLE 0x80000000
222 #define C_CONN_PEND 0x40000000
223 #define C_CONNECTED 0x20000000
224 #define C_ERROR 0x10000000
225 #define C_DISCONN_PEND 0x08000000
226 #define C_REMOTE_DOWN 0x04000000
227
228 uint_t c_state; /* state of connection */
229 kmutex_t c_lock; /* protect c_state and c_ref fields */
230 kcondvar_t c_cv; /* to signal when pending is done */
231 } CONN;
232
233
234 /*
235 * Memory management for the RDMA buffers
236 */
237 /*
238 * RDMA buffer types
239 */
240 typedef enum {
241 SEND_BUFFER, /* buf for send msg */
242 SEND_DESCRIPTOR, /* buf used for send msg descriptor in plugins only */
243 RECV_BUFFER, /* buf for recv msg */
244 RECV_DESCRIPTOR, /* buf used for recv msg descriptor in plugins only */
245 CHUNK_BUFFER /* chunk buf used in RDMATF only and not in plugins */
246 } rdma_btype;
247
248 /*
249 * RDMA buffer information
250 */
251 typedef struct rdma_buf {
252 rdma_btype type; /* buffer type */
253 int len; /* length of buffer */
254 caddr_t addr; /* buffer address */
255 struct mrc handle; /* buffer registration handle */
256 } rdma_buf_t;
257
258 /*
259 * Data transferred from plugin interrupt to svc_queuereq()
260 */
261 struct recv_data {
262 CONN *conn;
263 int status;
264 rdma_buf_t rpcmsg;
265 };
266
267 /*
268 * Operations vector for RDMA transports.
269 */
270 typedef struct rdmaops {
271 /* Network */
272 rdma_stat (*rdma_reachable)(int addr_type, struct netbuf *,
273 void **handle);
274 /* Connection */
275 rdma_stat (*rdma_get_conn)(struct netbuf *, int addr_type,
276 void *, CONN **);
277 rdma_stat (*rdma_rel_conn)(CONN *);
278 /* Server side listner start and stop routines */
279 void (*rdma_svc_listen)(struct rdma_svc_data *);
280 void (*rdma_svc_stop)(struct rdma_svc_data *);
281 /* Memory */
282 rdma_stat (*rdma_regmem)(CONN *, caddr_t, uint_t, struct mrc *);
283 rdma_stat (*rdma_deregmem)(CONN *, caddr_t, struct mrc);
284 rdma_stat (*rdma_regmemsync)(CONN *, caddr_t, uint_t,
285 struct mrc *, void **);
286 rdma_stat (*rdma_deregmemsync)(CONN *, caddr_t, struct mrc,
287 void *);
288 rdma_stat (*rdma_syncmem)(CONN *, void *, caddr_t, int, int);
289 /* Buffer */
290 rdma_stat (*rdma_buf_alloc)(CONN *, rdma_buf_t *);
291 void (*rdma_buf_free)(CONN *, rdma_buf_t *);
292 /* Transfer */
293 rdma_stat (*rdma_send)(CONN *, clist *, uint32_t);
294 rdma_stat (*rdma_send_resp)(CONN *, clist *, uint32_t);
295 rdma_stat (*rdma_clnt_recvbuf)(CONN *, clist *, uint32_t);
296 rdma_stat (*rdma_svc_recvbuf)(CONN *, clist *);
297 rdma_stat (*rdma_recv)(CONN *, clist **, uint32_t);
298 /* RDMA */
299 rdma_stat (*rdma_read)(CONN *, clist *, int);
300 rdma_stat (*rdma_write)(CONN *, clist *, int);
301 /* INFO */
302 rdma_stat (*rdma_getinfo)(rdma_info_t *info);
303
304 } rdmaops_t;
305
306 /*
307 * RDMA operations.
308 */
309 #define RDMA_REACHABLE(rdma_ops, addr_type, addr, handle) \
310 (*(rdma_ops)->rdma_reachable)(addr_type, addr, handle)
311
312 #define RDMA_GET_CONN(rdma_ops, addr, addr_type, handle, conn) \
313 (*(rdma_ops)->rdma_get_conn)(addr, addr_type, handle, conn)
314
315 #define RDMA_REL_CONN(conn) \
316 (*(conn)->c_rdmamod->rdma_ops->rdma_rel_conn)(conn)
317
318 #define RDMA_REGMEM(conn, buff, len, handle) \
319 (*(conn)->c_rdmamod->rdma_ops->rdma_regmem)(conn, buff, len, handle)
320
321 #define RDMA_DEREGMEM(conn, buff, handle) \
322 (*(conn)->c_rdmamod->rdma_ops->rdma_deregmem)(conn, buff, handle)
323
324 #define RDMA_REGMEMSYNC(conn, buff, len, handle, synchandle) \
325 (*(conn)->c_rdmamod->rdma_ops->rdma_regmemsync)(conn, buff, \
326 len, handle, synchandle)
327
328 #define RDMA_DEREGMEMSYNC(conn, buff, handle, synchandle) \
329 (*(conn)->c_rdmamod->rdma_ops->rdma_deregmemsync)(conn, buff, \
330 handle, synchandle)
331
332 #define RDMA_SYNCMEM(conn, handle, buff, len, direction) \
333 (*(conn)->c_rdmamod->rdma_ops->rdma_syncmem)(conn, handle, \
334 buff, len, direction)
335
336 #define RDMA_BUF_ALLOC(conn, rbuf) \
337 (*(conn)->c_rdmamod->rdma_ops->rdma_buf_alloc)(conn, rbuf)
338
339 #define RDMA_BUF_FREE(conn, rbuf) \
340 (*(conn)->c_rdmamod->rdma_ops->rdma_buf_free)(conn, rbuf)
341
342 #define RDMA_SEND(conn, sendlist, xid) \
343 (*(conn)->c_rdmamod->rdma_ops->rdma_send)(conn, sendlist, xid)
344
345 #define RDMA_SEND_RESP(conn, sendlist, xid) \
346 (*(conn)->c_rdmamod->rdma_ops->rdma_send_resp)(conn, sendlist, xid)
347
348 #define RDMA_CLNT_RECVBUF(conn, cl, xid) \
349 (*(conn)->c_rdmamod->rdma_ops->rdma_clnt_recvbuf)(conn, cl, xid)
350
351 #define RDMA_SVC_RECVBUF(conn, cl) \
352 (*(conn)->c_rdmamod->rdma_ops->rdma_svc_recvbuf)(conn, cl)
353
354 #define RDMA_RECV(conn, recvlist, xid) \
355 (*(conn)->c_rdmamod->rdma_ops->rdma_recv)(conn, recvlist, xid)
356
357 #define RDMA_READ(conn, cl, wait) \
358 (*(conn)->c_rdmamod->rdma_ops->rdma_read)(conn, cl, wait)
359
360 #define RDMA_WRITE(conn, cl, wait) \
361 (*(conn)->c_rdmamod->rdma_ops->rdma_write)(conn, cl, wait)
362
363 #define RDMA_GETINFO(rdma_mod, info) \
364 (*(rdma_mod)->rdma_ops->rdma_getinfo)(info)
365
366 #ifdef _KERNEL
367 extern rdma_registry_t *rdma_mod_head;
368 extern krwlock_t rdma_lock; /* protects rdma_mod_head list */
369 extern int rdma_modloaded; /* flag for loading RDMA plugins */
370 extern int rdma_dev_available; /* rdma device is loaded or not */
371 extern kmutex_t rdma_modload_lock; /* protects rdma_modloaded flag */
372 extern uint_t rdma_minchunk;
373 extern ldi_ident_t rpcmod_li; /* needed by layed driver framework */
374
375 /*
376 * General RDMA routines
377 */
378 extern void clist_add(struct clist **clp, uint32_t xdroff, int len,
379 struct mrc *shandle, caddr_t saddr,
380 struct mrc *dhandle, caddr_t daddr);
381 extern void clist_free(struct clist *cl);
382 extern int clist_register(CONN *conn, struct clist *cl, bool_t src);
383 extern int clist_deregister(CONN *conn, struct clist *cl, bool_t src);
384 rdma_stat rdma_clnt_postrecv(CONN *conn, uint32_t xid);
385 rdma_stat rdma_svc_postrecv(CONN *conn);
386 extern rdma_stat clist_syncmem(CONN *conn, struct clist *cl, bool_t src);
387 extern rdma_stat rdma_register_mod(rdma_mod_t *mod);
388 extern rdma_stat rdma_unregister_mod(rdma_mod_t *mod);
389 extern void rdma_buf_free(CONN *conn, rdma_buf_t *rbuf);
390 extern int rdma_modload();
391
392 /*
393 * RDMA XDR
394 */
395 extern void xdrrdma_create(XDR *, caddr_t, uint_t, int, struct clist *,
396 enum xdr_op, CONN *);
397 extern void xdrrdma_destroy(XDR *);
398 extern struct clist *xdrrdma_clist(XDR *);
399 extern uint_t xdrrdma_getpos(XDR *);
400 extern bool_t xdrrdma_setpos(XDR *, uint_t);
401 extern bool_t xdr_clist(XDR *, clist *);
402 extern bool_t xdr_do_clist(XDR *, clist **);
403 extern uint_t xdr_getbufsize(XDR *);
404 unsigned int xdrrdma_sizeof(xdrproc_t func, void *data, int min_chunk);
405 unsigned int xdrrdma_authsize(AUTH *auth, struct cred *cred, int min_chunk);
406 #endif /* _KERNEL */
407
408 #ifdef __cplusplus
409 }
410 #endif
411
412 #endif /* _RPC_RPC_RDMA_H */
|
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22 /*
23 * Copyright 2005 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 /* Copyright (c) 2006, The Ohio State University. All rights reserved.
28 *
29 * Portions of this source code is developed by the team members of
30 * The Ohio State University's Network-Based Computing Laboratory (NBCL),
31 * headed by Professor Dhabaleswar K. (DK) Panda.
32 *
33 * Acknowledgements to contributions from developors:
34 * Ranjit Noronha: noronha@cse.ohio-state.edu
35 * Lei Chai : chail@cse.ohio-state.edu
36 * Weikuan Yu : yuw@cse.ohio-state.edu
37 *
38 */
39
40 #ifndef _RPC_RPC_RDMA_H
41 #define _RPC_RPC_RDMA_H
42
43 #pragma ident "@(#)rpc_rdma.h 1.9 05/06/08 SMI"
44
45 #include <rpc/rpc.h>
46 #include <rpc/rpc_sztypes.h>
47 #include <sys/sunddi.h>
48 #include <sys/sunldi.h>
49
50 #ifdef __cplusplus
51 extern "C" {
52 #endif
53
54 #define RPCRDMA_VERS 1 /* Version of the RPC over RDMA protocol */
55 #define RDMATF_VERS 1 /* Version of the API used by RPC for RDMA */
56 #define RDMATF_VERS_1 1 /* Current version of RDMATF */
57
58 /* #define DYNAMIC_CREDIT_CONTROL 1 */
59 #define SERVER_REG_CACHE
60 /*#define ASYNC_SERVER_DEREG */
61 #define ASYNC_CLIENT_DEREG
62 /*#define RPC_RDMA_INLINE */
63 #ifdef RPC_RDMA_INLINE /* Increase to some super-large values */
64 #define RDMA_MINCHUNK 262144
65 #define RPC_MSG_SZ 262144
66 #define RPC_CL_SZ 262144
67 #define MINCHUNK 262144
68 #define RPC_BUF_SIZE 262144*2
69 #else
70 /*
71 * RDMA chunk size
72 */
73 #define RDMA_MINCHUNK 1024
74 /*
75 * The size of an RPC call or reply message
76 */
77 #define RPC_MSG_SZ 1024
78
79 /*
80 * Storage for a chunk list
81 */
82 #define RPC_CL_SZ 1024
83
84 /*
85 * Chunk size
86 */
87 #define MINCHUNK 1024
88
89 /*
90 * Size of receive buffer
91 */
92 #define RPC_BUF_SIZE 2048
93 #endif
94
95 #define NOWAIT 0 /* don't wait for operation of complete */
96 #define WAIT 1 /* wait and ensure that operation is complete */
97
98 /*
99 * RDMA xdr buffer control and other control flags. Add new flags here,
100 * set them in private structure for xdr over RDMA in xdr_rdma.c
101 */
102 #define RDMA_NOCHUNK 0x1
103
104 #define LONG_REPLY_LEN 65536
105
106 extern int credit_control_debug;
107 extern int rib_long_reply_debug;
108 extern int rdma_long_reply_debug;
109 extern int rdma_xdr_long_reply_debug;
110 extern int rdma_wlist_xdr_debug;
111 extern int rdma_wlist_clnt_debug;
112 extern int rdma_wlist_svc_debug;
113 extern int rdma_wlist_memreg_debug;
114 extern int rdma_wlist_verbose_debug;
115
116
117 #define RDMA_BUFS_RQST 128 /* Num bufs requested by client */
118 #define RDMA_BUFS_GRANT 126 /* Num bufs granted by server */
119
120 /*
121 * Credit Control Structures.
122 */
123 typedef enum rdma_cc_type {
124 RDMA_CC_CLNT, /* CONN is for a client */
125 RDMA_CC_SRV /* CONN is for a server */
126 } rdma_cc_type_t;
127
128 /*
129 * Client side credit control data structure.
130 */
131 typedef struct rdma_clnt_cred_ctrl {
132 uint32_t clnt_cc_granted_ops;
133 uint32_t clnt_cc_in_flight_ops;
134 kcondvar_t clnt_cc_cv;
135 } rdma_clnt_cred_ctrl_t;
136
137 /*
138 * Server side credit control data structure.
139 */
140 typedef struct rdma_srv_cred_ctrl {
141 uint32_t srv_cc_buffers_granted;
142 uint32_t srv_cc_cur_buffers_used;
143 uint32_t srv_cc_posted;
144 uint32_t srv_cc_max_buf_size; /* to be determined by CCP */
145 uint32_t srv_cc_cur_buf_size; /* to be determined by CCP */
146 } rdma_srv_cred_ctrl_t;
147
148 typedef enum {
149 RPCCALL_RCHUNK,
150 RPCCALL_NORCHUNK
151 }rpccall_read_t;
152
153 typedef enum {
154 RPCCALL_WLIST,
155 RPCCALL_WCHUNK,
156 RPCCALL_NOWRITE
157 }rpccall_write_t;
158
159 /*
160 * Return codes from RDMA operations
161 */
162 typedef enum {
163
164 RDMA_SUCCESS = 0, /* successful operation */
165
166 RDMA_INVAL = 1, /* invalid parameter */
167 RDMA_TIMEDOUT = 2, /* operation timed out */
168 RDMA_INTR = 3, /* operation interrupted */
169 RDMA_NORESOURCE = 4, /* insufficient resource */
170 /*
171 * connection errors
172 */
173 RDMA_REJECT = 5, /* connection req rejected */
174 RDMA_NOLISTENER = 6, /* no listener on server */
175 RDMA_UNREACHABLE = 7, /* host unreachable */
176 RDMA_CONNLOST = 8, /* connection lost */
177
178 RDMA_XPRTFAILED = 9, /* RDMA transport failed */
179 RDMA_PROTECTERR = 10, /* memory protection error */
193 */
194 RDMA_FAILED = 18 /* generic error */
195 } rdma_stat;
196
197 /*
198 * Memory region context. This is an RDMA provider generated
199 * handle for a registered arbitrary size contiguous virtual
200 * memory. The RDMA Interface Adapter needs this for local or
201 * remote memory access.
202 *
203 * The mrc_rmr field holds the remote memory region context
204 * which is sent over-the-wire to provide the remote host
205 * with RDMA access to the memory region.
206 */
207 struct mrc {
208 uint32_t mrc_rmr; /* Remote MR context, sent OTW */
209 union {
210 struct mr {
211 uint32_t lmr; /* Local MR context */
212 uint64_t linfo; /* Local memory info */
213 uint64_t lma; /* Local Mem Area Hdl */
214 } mr;
215 } lhdl;
216 };
217
218 #define mrc_lmr lhdl.mr.lmr
219 #define mrc_linfo lhdl.mr.linfo
220 #define mrc_lma lhdl.mr.lma /* FMR : Mem Area Hdl */
221 /*
222 * The XDR offset value is used by the XDR
223 * routine to identify the position in the
224 * RPC message where the opaque object would
225 * normally occur. Neither the data content
226 * of the chunk, nor its size field are included
227 * in the RPC message. The XDR offset is calculated
228 * as if the chunks were present.
229 *
230 * The remaining fields identify the chunk of data
231 * on the sender. The c_memhandle identifies a
232 * registered RDMA memory region and the c_addr
233 * and c_len fields identify the chunk within it.
234 */
235
236 #ifdef SERVER_REG_CACHE
237 typedef struct rib_lrc_entry {
238 struct rib_lrc_entry *forw;
239 struct rib_lrc_entry *back;
240 char *lrc_buf;
241
242 uint32_t lrc_len;
243 void *avl_node;
244 bool_t registered;
245
246 struct mrc lrc_mhandle;
247 bool_t lrc_on_freed_list;
248 } rib_lrc_entry_t;
249 #endif
250
251 struct clist {
252 uint32 c_xdroff; /* XDR offset */
253 uint32 c_len; /* Length */
254 struct mrc c_smemhandle; /* src memory handle */
255 uint64 c_ssynchandle; /* src sync handle */
256 uint64 c_saddr; /* src address */
257 struct mrc c_dmemhandle; /* dst memory handle */
258 uint64 c_dsynchandle; /* dst sync handle */
259 uint64 c_daddr; /* dst address */
260 struct as *c_adspc; /* address space for saddr/daddr */
261 page_t **c_dpplist; /* page list for dest vaddr */
262 uint64 long_reply_buf;
263 struct clist *c_next; /* Next chunk */
264 };
265
266 typedef struct clist clist;
267
268 extern struct clist empty_cl;
269
270 /*
271 * FTDO: max 4 meg wlist xfer size
272 * This is defined because the rfs3_tsize service requires
273 * svc_req struct (which we don't have that in krecv).
274 */
275 #define MAX_SVC_XFER_SIZE (4*1024*1024)
276
277 enum rdma_proc {
278 RDMA_MSG = 0, /* chunk list and RPC msg follow */
279 RDMA_NOMSG = 1, /* only chunk list follows */
280 RDMA_MSGP = 2, /* chunk list and RPC msg with padding follow */
281 RDMA_DONE = 3 /* signal completion of chunk transfer */
282 };
283
284 /*
285 * Listener information for a service
286 */
287 struct rdma_svc_data {
288 queue_t q; /* queue_t to place incoming pkts */
289 int active; /* If active, after registeration startup */
290 rdma_stat err_code; /* Error code from plugin layer */
291 int32_t svcid; /* RDMA based service identifier */
292 };
293
294 /*
295 * Per RDMA plugin module information.
296 * Will be populated by each plugin
323 /*
324 * RDMA Connection information
325 */
326 typedef struct conn {
327 rdma_mod_t *c_rdmamod; /* RDMA transport info for conn */
328 struct netbuf c_raddr; /* remote address */
329 struct netbuf c_laddr; /* local address */
330 int c_ref; /* no. of clients of connection */
331 struct conn *c_next; /* next in list of connections */
332 struct conn *c_prev; /* prev in list of connections */
333 caddr_t c_private; /* transport specific stuff */
334
335 #define C_IDLE 0x80000000
336 #define C_CONN_PEND 0x40000000
337 #define C_CONNECTED 0x20000000
338 #define C_ERROR 0x10000000
339 #define C_DISCONN_PEND 0x08000000
340 #define C_REMOTE_DOWN 0x04000000
341
342 uint_t c_state; /* state of connection */
343 rdma_cc_type_t c_cc_type; /* client or server, for credit cntrl */
344 union {
345 rdma_clnt_cred_ctrl_t c_clnt_cc;
346 rdma_srv_cred_ctrl_t c_srv_cc;
347 } rdma_conn_cred_ctrl_u;
348 kmutex_t c_lock; /* protect c_state and c_ref fields */
349 kcondvar_t c_cv; /* to signal when pending is done */
350 #if defined (CLNT_INTERRUPT_COAL)
351 uint_t c_count;
352 #endif
353 } CONN;
354
355
356 /*
357 * Memory management for the RDMA buffers
358 */
359 /*
360 * RDMA buffer types
361 */
362 typedef enum {
363 SEND_BUFFER, /* buf for send msg */
364 SEND_DESCRIPTOR, /* buf used for send msg descriptor in plugins only */
365 RECV_BUFFER, /* buf for recv msg */
366 RECV_DESCRIPTOR, /* buf used for recv msg descriptor in plugins only */
367 CHUNK_BUFFER /* chunk buf used in RDMATF only and not in plugins */
368 } rdma_btype;
369
370 /*
371 * RDMA buffer information
372 */
373 typedef struct rdma_buf {
374 rdma_btype type; /* buffer type */
375 int len; /* length of buffer */
376 caddr_t addr; /* buffer address */
377 struct mrc handle; /* buffer registration handle */
378 #ifdef SERVER_REG_CACHE
379 rib_lrc_entry_t *long_reply_buf;
380 #endif
381 } rdma_buf_t;
382
383 /*
384 * Data transferred from plugin interrupt to svc_queuereq()
385 */
386 struct recv_data {
387 CONN *conn;
388 int status;
389 rdma_buf_t rpcmsg;
390 };
391
392 /*
393 * Operations vector for RDMA transports.
394 */
395 typedef struct rdmaops {
396 /* Network */
397 rdma_stat (*rdma_reachable)(int addr_type, struct netbuf *,
398 void **handle);
399 /* Connection */
400 rdma_stat (*rdma_get_conn)(struct netbuf *, int addr_type,
401 void *, CONN **);
402 rdma_stat (*rdma_rel_conn)(CONN *);
403 /* Server side listner start and stop routines */
404 void (*rdma_svc_listen)(struct rdma_svc_data *);
405 void (*rdma_svc_stop)(struct rdma_svc_data *);
406 /* Memory */
407 rdma_stat (*rdma_regmem)(CONN *, caddr_t , caddr_t, uint_t, struct mrc *);
408 rdma_stat (*rdma_deregmem)(CONN *, caddr_t, struct mrc);
409 #ifdef SERVER_REG_CACHE
410 rdma_stat (*rdma_regmemsync)(CONN *, caddr_t ,caddr_t, uint_t,
411 struct mrc *, void **, void *);
412 rdma_stat (*rdma_deregmemsync)(CONN *, caddr_t, struct mrc,
413 void *, void *);
414 #else
415 rdma_stat (*rdma_regmemsync)(CONN *, caddr_t ,caddr_t, uint_t,
416 struct mrc *, void **);
417 rdma_stat (*rdma_deregmemsync)(CONN *, caddr_t, struct mrc,
418 void *);
419
420 #endif
421 rdma_stat (*rdma_syncmem)(CONN *, void *, caddr_t, int, int);
422 /* Buffer */
423 rdma_stat (*rdma_buf_alloc)(CONN *, rdma_buf_t *);
424 void (*rdma_buf_free)(CONN *, rdma_buf_t *);
425 /* Transfer */
426 rdma_stat (*rdma_send)(CONN *, clist *, uint32_t);
427 #if defined (CLNT_INTERRUPT_COAL)
428 rdma_stat (*rdma_send_bl)(CONN *, clist *, uint32_t);
429 #endif
430 #if defined(ASYNC_SERVER_DEREG)
431 rdma_stat (*rdma_send_nw)(CONN *, clist *, uint32_t, caddr_t, caddr_t , int, caddr_t ,int, int, int);
432 #endif
433 rdma_stat (*rdma_send_resp)(CONN *, clist *, uint32_t);
434 rdma_stat (*rdma_clnt_recvbuf)(CONN *, clist *, uint32_t);
435 rdma_stat (*rdma_svc_recvbuf)(CONN *, clist *);
436 rdma_stat (*rdma_recv)(CONN *, clist **, uint32_t);
437 /* RDMA */
438 rdma_stat (*rdma_read)(CONN *, clist *, int);
439 rdma_stat (*rdma_write)(CONN *, clist *, int);
440 /* INFO */
441 rdma_stat (*rdma_getinfo)(rdma_info_t *info);
442 #ifdef SERVER_REG_CACHE
443 rib_lrc_entry_t *(*rdma_get_server_cache_buf)(CONN *,uint32_t);
444 void (*rdma_free_server_cache_buf)(CONN *, rib_lrc_entry_t *);
445 #endif
446 #ifdef DYNAMIC_CREDIT_CONTROL
447 void (*rdma_get_resource_info)(CONN *, int *, int *);
448 #endif
449 #if defined(ASYNC_CLIENT_DEREG)
450 void (*insert_queue)(CONN *, clist *);
451 #endif
452
453 } rdmaops_t;
454
455 /*
456 * RDMA operations.
457 */
458 #define RDMA_REACHABLE(rdma_ops, addr_type, addr, handle) \
459 (*(rdma_ops)->rdma_reachable)(addr_type, addr, handle)
460
461 #define RDMA_GET_CONN(rdma_ops, addr, addr_type, handle, conn) \
462 (*(rdma_ops)->rdma_get_conn)(addr, addr_type, handle, conn)
463
464 #define RDMA_REL_CONN(conn) \
465 (*(conn)->c_rdmamod->rdma_ops->rdma_rel_conn)(conn)
466
467 #define RDMA_REGMEM(conn, adsp, buff, len, handle) \
468 (*(conn)->c_rdmamod->rdma_ops->rdma_regmem)(conn, adsp, buff, len, handle)
469
470 #define RDMA_DEREGMEM(conn, buff, handle) \
471 (*(conn)->c_rdmamod->rdma_ops->rdma_deregmem)(conn, buff, handle)
472
473 #ifdef SERVER_REG_CACHE
474 #define RDMA_REGMEMSYNC(conn, adsp, buff, len, handle, synchandle, lrc) \
475 (*(conn)->c_rdmamod->rdma_ops->rdma_regmemsync)(conn, adsp, buff, \
476 len, handle, synchandle, lrc)
477
478 #define RDMA_DEREGMEMSYNC(conn, buff, handle, synchandle, lrc) \
479 (*(conn)->c_rdmamod->rdma_ops->rdma_deregmemsync)(conn, buff, \
480 handle, synchandle, lrc)
481 #else
482 #define RDMA_REGMEMSYNC(conn, adsp, buff, len, handle, synchandle) \
483 (*(conn)->c_rdmamod->rdma_ops->rdma_regmemsync)(conn, adsp, buff, \
484 len, handle, synchandle)
485
486 #define RDMA_DEREGMEMSYNC(conn, buff, handle, synchandle) \
487 (*(conn)->c_rdmamod->rdma_ops->rdma_deregmemsync)(conn, buff, \
488 handle, synchandle)
489
490 #endif
491 #define RDMA_SYNCMEM(conn, handle, buff, len, direction) \
492 (*(conn)->c_rdmamod->rdma_ops->rdma_syncmem)(conn, handle, \
493 buff, len, direction)
494
495 #define RDMA_BUF_ALLOC(conn, rbuf) \
496 (*(conn)->c_rdmamod->rdma_ops->rdma_buf_alloc)(conn, rbuf)
497
498 #define RDMA_BUF_FREE(conn, rbuf) \
499 (*(conn)->c_rdmamod->rdma_ops->rdma_buf_free)(conn, rbuf)
500
501 #define RDMA_SEND(conn, sendlist, xid) \
502 (*(conn)->c_rdmamod->rdma_ops->rdma_send)(conn, sendlist, xid)
503 #if defined (CLNT_INTERRUPT_COAL)
504 #define RDMA_SEND_BL(conn, sendlist, xid) \
505 (*(conn)->c_rdmamod->rdma_ops->rdma_send_bl)(conn, sendlist, xid)
506
507 #endif
508 #if defined(ASYNC_SERVER_DEREG)
509 #define RDMA_SEND_NW(conn, sendlist, xid, c, c1, c2, c3, c4, c5, c6) \
510 (*(conn)->c_rdmamod->rdma_ops->rdma_send_nw)(conn, sendlist, xid, c, c1, c2, c3, c4, c5, c6)
511 #endif
512 #if defined(ASYNC_CLIENT_DEREG)
513 #define INSERT_QUEUE(conn,rwc) \
514 (*(conn)->c_rdmamod->rdma_ops->insert_queue)(conn,rwc)
515 #endif
516
517 #define RDMA_SEND_RESP(conn, sendlist, xid) \
518 (*(conn)->c_rdmamod->rdma_ops->rdma_send_resp)(conn, sendlist, xid)
519
520 #define RDMA_CLNT_RECVBUF(conn, cl, xid) \
521 (*(conn)->c_rdmamod->rdma_ops->rdma_clnt_recvbuf)(conn, cl, xid)
522
523 #define RDMA_SVC_RECVBUF(conn, cl) \
524 (*(conn)->c_rdmamod->rdma_ops->rdma_svc_recvbuf)(conn, cl)
525
526 #define RDMA_RECV(conn, recvlist, xid) \
527 (*(conn)->c_rdmamod->rdma_ops->rdma_recv)(conn, recvlist, xid)
528
529 #define RDMA_READ(conn, cl, wait) \
530 (*(conn)->c_rdmamod->rdma_ops->rdma_read)(conn, cl, wait)
531
532 #define RDMA_WRITE(conn, cl, wait) \
533 (*(conn)->c_rdmamod->rdma_ops->rdma_write)(conn, cl, wait)
534
535 #define RDMA_GETINFO(rdma_mod, info) \
536 (*(rdma_mod)->rdma_ops->rdma_getinfo)(info)
537
538
539 #ifdef SERVER_REG_CACHE
540 #define RDMA_GET_SERVER_CACHE_BUF(conn, len) \
541 (*(conn)->c_rdmamod->rdma_ops->rdma_get_server_cache_buf)(conn, len)
542
543 #define RDMA_FREE_SERVER_CACHE_BUF(conn, buf) \
544 (*(conn)->c_rdmamod->rdma_ops->rdma_free_server_cache_buf)(conn, buf)
545 #endif
546
547 #ifdef DYNAMIC_CREDIT_CONTROL
548 #define RDMA_GET_RESOURCE_INFO(conn, num, avail) \
549 (*(conn)->c_rdmamod->rdma_ops->rdma_get_resource_info)(conn, num, avail)
550 #endif
551
552 #ifdef _KERNEL
553 extern rdma_registry_t *rdma_mod_head;
554 extern krwlock_t rdma_lock; /* protects rdma_mod_head list */
555 extern int rdma_modloaded; /* flag for loading RDMA plugins */
556 extern int rdma_dev_available; /* rdma device is loaded or not */
557 extern kmutex_t rdma_modload_lock; /* protects rdma_modloaded flag */
558 extern uint_t rdma_minchunk;
559 extern ldi_ident_t rpcmod_li; /* needed by layed driver framework */
560 /*
561 * General RDMA routines
562 */
563 extern void clist_add(struct clist **clp, uint32_t xdroff, int len,
564 struct mrc *shandle, caddr_t saddr,
565 struct mrc *dhandle, caddr_t daddr);
566 extern void clist_free(struct clist *cl);
567 extern int clist_register(CONN *conn, struct clist *cl, bool_t src);
568 extern int clist_deregister(CONN *conn, struct clist *cl, bool_t src);
569 rdma_stat rdma_clnt_postrecv(CONN *conn, uint32_t xid);
570 rdma_stat rdma_svc_postrecv(CONN *conn);
571 extern rdma_stat clist_syncmem(CONN *conn, struct clist *cl, bool_t src);
572 extern rdma_stat rdma_register_mod(rdma_mod_t *mod);
573 extern rdma_stat rdma_unregister_mod(rdma_mod_t *mod);
574 extern void rdma_buf_free(CONN *conn, rdma_buf_t *rbuf);
575 extern int rdma_modload();
576
577 /*
578 * RDMA XDR
579 */
580 extern void xdrrdma_create(XDR *, caddr_t, uint_t, int, struct clist *,
581 enum xdr_op, CONN *);
582 extern void xdrrdma_destroy(XDR *);
583 extern struct clist *xdrrdma_clist(XDR *);
584 extern uint_t xdrrdma_getpos(XDR *);
585 extern bool_t xdrrdma_setpos(XDR *, uint_t);
586 extern bool_t xdr_clist(XDR *, clist *);
587 extern bool_t xdr_do_clist(XDR *, clist **);
588 extern uint_t xdr_getbufsize(XDR *);
589 unsigned int xdrrdma_sizeof(xdrproc_t func, void *data, int min_chunk);
590 unsigned int xdrrdma_authsize(AUTH *auth, struct cred *cred, int min_chunk);
591
592 extern bool_t xdr_decode_reply_wchunk(XDR *, struct clist **,CONN *conn);
593 extern bool_t xdr_decode_wlist(XDR *xdrs, struct clist **, bool_t *);
594 extern bool_t xdr_decode_wlist_new(XDR *xdrs, struct clist **, bool_t *,
595 uint32_t *,CONN *);
596
597 extern bool_t xdr_encode_wlist(XDR *, clist *, uint_t);
598 extern bool_t xdr_encode_reply_wchunk(XDR *, struct clist *, uint32_t seg_array_len);
599
600 #endif /* _KERNEL */
601
602 #ifdef __cplusplus
603 }
604 #endif
605
606 #endif /* _RPC_RPC_RDMA_H */
|