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) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
23 * Copyright 2013 Nexenta Systems, Inc. All rights reserved.
24 */
25
26 /*
27 * Copyright (c) 2007, 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 /*
41 * The rpcib plugin. Implements the interface for RDMATF's
42 * interaction with IBTF.
43 */
44
45 #include <sys/param.h>
46 #include <sys/types.h>
47 #include <sys/user.h>
48 #include <sys/systm.h>
49 #include <sys/sysmacros.h>
50 #include <sys/proc.h>
51 #include <sys/socket.h>
52 #include <sys/file.h>
53 #include <sys/stream.h>
54 #include <sys/strsubr.h>
55 #include <sys/stropts.h>
56 #include <sys/errno.h>
57 #include <sys/kmem.h>
58 #include <sys/debug.h>
59 #include <sys/pathname.h>
60 #include <sys/kstat.h>
61 #include <sys/t_lock.h>
62 #include <sys/ddi.h>
63 #include <sys/cmn_err.h>
64 #include <sys/time.h>
65 #include <sys/isa_defs.h>
66 #include <sys/callb.h>
67 #include <sys/sunddi.h>
68 #include <sys/sunndi.h>
69 #include <sys/sdt.h>
70 #include <sys/ib/ibtl/ibti.h>
71 #include <rpc/rpc.h>
72 #include <rpc/ib.h>
73 #include <sys/modctl.h>
74 #include <sys/kstr.h>
75 #include <sys/sockio.h>
76 #include <sys/vnode.h>
77 #include <sys/tiuser.h>
78 #include <net/if.h>
79 #include <net/if_types.h>
80 #include <sys/cred.h>
81 #include <rpc/rpc_rdma.h>
82 #include <nfs/nfs.h>
83 #include <sys/atomic.h>
84
85 #define NFS_RDMA_PORT 20049
86
87
88 /*
89 * Convenience structures for connection management
90 */
91 typedef struct rpcib_ipaddrs {
92 void *ri_list; /* pointer to list of addresses */
93 uint_t ri_count; /* number of addresses in list */
94 uint_t ri_size; /* size of ri_list in bytes */
95 } rpcib_ipaddrs_t;
96
97
98 typedef struct rpcib_ping {
99 rib_hca_t *hca;
100 ibt_path_info_t path;
101 ibt_ip_addr_t srcip;
102 ibt_ip_addr_t dstip;
103 } rpcib_ping_t;
104
105 /*
106 * Prototype declarations for driver ops
107 */
108 static int rpcib_attach(dev_info_t *, ddi_attach_cmd_t);
109 static int rpcib_getinfo(dev_info_t *, ddi_info_cmd_t,
110 void *, void **);
111 static int rpcib_detach(dev_info_t *, ddi_detach_cmd_t);
112 static boolean_t rpcib_rdma_capable_interface(struct lifreq *);
113 static int rpcib_do_ip_ioctl(int, int, void *);
114 static boolean_t rpcib_get_ib_addresses(rpcib_ipaddrs_t *, rpcib_ipaddrs_t *);
115 static int rpcib_cache_kstat_update(kstat_t *, int);
116 static void rib_force_cleanup(void *);
117 static void rib_stop_hca_services(rib_hca_t *);
118 static void rib_attach_hca(void);
119 static int rib_find_hca_connection(rib_hca_t *hca, struct netbuf *s_svcaddr,
120 struct netbuf *d_svcaddr, CONN **conn);
121
122 struct {
123 kstat_named_t cache_limit;
124 kstat_named_t cache_allocation;
125 kstat_named_t cache_hits;
126 kstat_named_t cache_misses;
127 kstat_named_t cache_misses_above_the_limit;
128 } rpcib_kstat = {
129 {"cache_limit", KSTAT_DATA_UINT64 },
130 {"cache_allocation", KSTAT_DATA_UINT64 },
131 {"cache_hits", KSTAT_DATA_UINT64 },
132 {"cache_misses", KSTAT_DATA_UINT64 },
133 {"cache_misses_above_the_limit", KSTAT_DATA_UINT64 },
134 };
135
136 /* rpcib cb_ops */
137 static struct cb_ops rpcib_cbops = {
138 nulldev, /* open */
139 nulldev, /* close */
140 nodev, /* strategy */
141 nodev, /* print */
142 nodev, /* dump */
143 nodev, /* read */
144 nodev, /* write */
145 nodev, /* ioctl */
146 nodev, /* devmap */
147 nodev, /* mmap */
148 nodev, /* segmap */
149 nochpoll, /* poll */
150 ddi_prop_op, /* prop_op */
151 NULL, /* stream */
152 D_MP, /* cb_flag */
153 CB_REV, /* rev */
154 nodev, /* int (*cb_aread)() */
155 nodev /* int (*cb_awrite)() */
156 };
157
158 /*
159 * Device options
160 */
161 static struct dev_ops rpcib_ops = {
162 DEVO_REV, /* devo_rev, */
163 0, /* refcnt */
164 rpcib_getinfo, /* info */
165 nulldev, /* identify */
166 nulldev, /* probe */
167 rpcib_attach, /* attach */
168 rpcib_detach, /* detach */
169 nodev, /* reset */
170 &rpcib_cbops, /* driver ops - devctl interfaces */
171 NULL, /* bus operations */
172 NULL, /* power */
173 ddi_quiesce_not_needed, /* quiesce */
174 };
175
176 /*
177 * Module linkage information.
178 */
179
180 static struct modldrv rib_modldrv = {
181 &mod_driverops, /* Driver module */
182 "RPCIB plugin driver", /* Driver name and version */
183 &rpcib_ops, /* Driver ops */
184 };
185
186 static struct modlinkage rib_modlinkage = {
187 MODREV_1,
188 (void *)&rib_modldrv,
189 NULL
190 };
191
192 typedef struct rib_lrc_entry {
193 struct rib_lrc_entry *forw;
194 struct rib_lrc_entry *back;
195 char *lrc_buf;
196
197 uint32_t lrc_len;
198 void *avl_node;
199 bool_t registered;
200
201 struct mrc lrc_mhandle;
202 bool_t lrc_on_freed_list;
203 } rib_lrc_entry_t;
204
205 typedef struct cache_struct {
206 rib_lrc_entry_t r;
207 uint32_t len;
208 uint32_t elements;
209 kmutex_t node_lock;
210 avl_node_t avl_link;
211 } cache_avl_struct_t;
212
213 uint64_t cache_limit = 100 * 1024 * 1024;
214 static uint64_t cache_watermark = 80 * 1024 * 1024;
215 static bool_t stats_enabled = FALSE;
216
217 static uint64_t max_unsignaled_rws = 5;
218 int nfs_rdma_port = NFS_RDMA_PORT;
219
220 #define RIBNETID_TCP "tcp"
221 #define RIBNETID_TCP6 "tcp6"
222
223 /*
224 * rib_stat: private data pointer used when registering
225 * with the IBTF. It is returned to the consumer
226 * in all callbacks.
227 */
228 static rpcib_state_t *rib_stat = NULL;
229
230 #define RNR_RETRIES IBT_RNR_RETRY_1
231 #define MAX_PORTS 2
232 #define RDMA_DUMMY_WRID 0x4D3A1D4D3A1D
233 #define RDMA_CONN_REAP_RETRY 10 /* 10 secs */
234
235 int preposted_rbufs = RDMA_BUFS_GRANT;
236 int send_threshold = 1;
237
238 /*
239 * Old cards with Tavor driver have limited memory footprint
240 * when booted in 32bit. The rib_max_rbufs tunable can be
241 * tuned for more buffers if needed.
242 */
243
244 #if !defined(_ELF64) && !defined(__sparc)
245 int rib_max_rbufs = MAX_BUFS;
246 #else
247 int rib_max_rbufs = 10 * MAX_BUFS;
248 #endif /* !(_ELF64) && !(__sparc) */
249
250 int rib_conn_timeout = 60 * 12; /* 12 minutes */
251
252 /*
253 * State of the plugin.
254 * ACCEPT = accepting new connections and requests.
255 * NO_ACCEPT = not accepting new connection and requests.
256 * This should eventually move to rpcib_state_t structure, since this
257 * will tell in which state the plugin is for a particular type of service
258 * like NFS, NLM or v4 Callback deamon. The plugin might be in accept
259 * state for one and in no_accept state for the other.
260 */
261 int plugin_state;
262 kmutex_t plugin_state_lock;
263
264 ldi_ident_t rpcib_li;
265
266 /*
267 * RPCIB RDMATF operations
268 */
269 static rdma_stat rib_reachable(int addr_type, struct netbuf *, void **handle);
270 static rdma_stat rib_disconnect(CONN *conn);
271 static void rib_listen(struct rdma_svc_data *rd);
272 static void rib_listen_stop(struct rdma_svc_data *rd);
273 static rdma_stat rib_registermem(CONN *conn, caddr_t adsp, caddr_t buf,
274 uint_t buflen, struct mrc *buf_handle);
275 static rdma_stat rib_deregistermem(CONN *conn, caddr_t buf,
276 struct mrc buf_handle);
277 static rdma_stat rib_registermem_via_hca(rib_hca_t *hca, caddr_t adsp,
278 caddr_t buf, uint_t buflen, struct mrc *buf_handle);
279 static rdma_stat rib_deregistermem_via_hca(rib_hca_t *hca, caddr_t buf,
280 struct mrc buf_handle);
281 static rdma_stat rib_registermemsync(CONN *conn, caddr_t adsp, caddr_t buf,
282 uint_t buflen, struct mrc *buf_handle, RIB_SYNCMEM_HANDLE *sync_handle,
283 void *lrc);
284 static rdma_stat rib_deregistermemsync(CONN *conn, caddr_t buf,
285 struct mrc buf_handle, RIB_SYNCMEM_HANDLE sync_handle, void *);
286 static rdma_stat rib_syncmem(CONN *conn, RIB_SYNCMEM_HANDLE shandle,
287 caddr_t buf, int len, int cpu);
288
289 static rdma_stat rib_reg_buf_alloc(CONN *conn, rdma_buf_t *rdbuf);
290
291 static void rib_reg_buf_free(CONN *conn, rdma_buf_t *rdbuf);
292 static void *rib_rbuf_alloc(CONN *, rdma_buf_t *);
293
294 static void rib_rbuf_free(CONN *conn, int ptype, void *buf);
295
296 static rdma_stat rib_send(CONN *conn, struct clist *cl, uint32_t msgid);
297 static rdma_stat rib_send_resp(CONN *conn, struct clist *cl, uint32_t msgid);
298 static rdma_stat rib_post_resp(CONN *conn, struct clist *cl, uint32_t msgid);
299 static rdma_stat rib_post_resp_remove(CONN *conn, uint32_t msgid);
300 static rdma_stat rib_post_recv(CONN *conn, struct clist *cl);
301 static rdma_stat rib_recv(CONN *conn, struct clist **clp, uint32_t msgid);
302 static rdma_stat rib_read(CONN *conn, struct clist *cl, int wait);
303 static rdma_stat rib_write(CONN *conn, struct clist *cl, int wait);
304 static rdma_stat rib_ping_srv(int addr_type, struct netbuf *, rpcib_ping_t *);
305 static rdma_stat rib_conn_get(struct netbuf *, struct netbuf *,
306 int addr_type, void *, CONN **);
307 static rdma_stat rib_conn_release(CONN *conn);
308 static rdma_stat rib_connect(struct netbuf *, struct netbuf *, int,
309 rpcib_ping_t *, CONN **);
310 static rdma_stat rib_getinfo(rdma_info_t *info);
311
312 static rib_lrc_entry_t *rib_get_cache_buf(CONN *conn, uint32_t len);
313 static void rib_free_cache_buf(CONN *conn, rib_lrc_entry_t *buf);
314 static void rib_destroy_cache(rib_hca_t *hca);
315 static void rib_server_side_cache_reclaim(void *argp);
316 static int avl_compare(const void *t1, const void *t2);
317
318 static void rib_stop_services(rib_hca_t *);
319 static void rib_close_channels(rib_conn_list_t *);
320 static void rib_conn_close(void *);
321 static void rib_recv_rele(rib_qp_t *);
322 static rdma_stat rib_conn_release_locked(CONN *conn);
323
324 /*
325 * RPCIB addressing operations
326 */
327
328 /*
329 * RDMA operations the RPCIB module exports
330 */
331 static rdmaops_t rib_ops = {
332 rib_reachable,
333 rib_conn_get,
334 rib_conn_release,
335 rib_listen,
336 rib_listen_stop,
337 rib_registermem,
338 rib_deregistermem,
339 rib_registermemsync,
340 rib_deregistermemsync,
341 rib_syncmem,
342 rib_reg_buf_alloc,
343 rib_reg_buf_free,
344 rib_send,
345 rib_send_resp,
346 rib_post_resp,
347 rib_post_resp_remove,
348 rib_post_recv,
349 rib_recv,
350 rib_read,
351 rib_write,
352 rib_getinfo,
353 };
354
355 /*
356 * RDMATF RPCIB plugin details
357 */
358 static rdma_mod_t rib_mod = {
359 "ibtf", /* api name */
360 RDMATF_VERS_1,
361 0,
362 &rib_ops, /* rdma op vector for ibtf */
363 };
364
365 static rdma_stat rpcib_open_hcas(rpcib_state_t *);
366 static rdma_stat rib_qp_init(rib_qp_t *, int);
367 static void rib_svc_scq_handler(ibt_cq_hdl_t, void *);
368 static void rib_clnt_scq_handler(ibt_cq_hdl_t, void *);
369 static void rib_clnt_rcq_handler(ibt_cq_hdl_t, void *);
370 static void rib_svc_rcq_handler(ibt_cq_hdl_t, void *);
371 static rib_bufpool_t *rib_rbufpool_create(rib_hca_t *hca, int ptype, int num);
372 static rdma_stat rib_reg_mem(rib_hca_t *, caddr_t adsp, caddr_t, uint_t,
373 ibt_mr_flags_t, ibt_mr_hdl_t *, ibt_mr_desc_t *);
374 static rdma_stat rib_reg_mem_user(rib_hca_t *, caddr_t, uint_t, ibt_mr_flags_t,
375 ibt_mr_hdl_t *, ibt_mr_desc_t *, caddr_t);
376 static rdma_stat rib_conn_to_srv(rib_hca_t *, rib_qp_t *, rpcib_ping_t *);
377 static rdma_stat rib_clnt_create_chan(rib_hca_t *, struct netbuf *,
378 rib_qp_t **);
379 static rdma_stat rib_svc_create_chan(rib_hca_t *, caddr_t, uint8_t,
380 rib_qp_t **);
381 static rdma_stat rib_sendwait(rib_qp_t *, struct send_wid *);
382 static struct send_wid *rib_init_sendwait(uint32_t, int, rib_qp_t *);
383 static int rib_free_sendwait(struct send_wid *);
384 static struct rdma_done_list *rdma_done_add(rib_qp_t *qp, uint32_t xid);
385 static void rdma_done_rm(rib_qp_t *qp, struct rdma_done_list *rd);
386 static void rdma_done_rem_list(rib_qp_t *);
387 static void rdma_done_notify(rib_qp_t *qp, uint32_t xid);
388
389 static void rib_async_handler(void *,
390 ibt_hca_hdl_t, ibt_async_code_t, ibt_async_event_t *);
391 static rdma_stat rib_rem_rep(rib_qp_t *, struct reply *);
392 static struct svc_recv *rib_init_svc_recv(rib_qp_t *, ibt_wr_ds_t *);
393 static int rib_free_svc_recv(struct svc_recv *);
394 static struct recv_wid *rib_create_wid(rib_qp_t *, ibt_wr_ds_t *, uint32_t);
395 static void rib_free_wid(struct recv_wid *);
396 static rdma_stat rib_disconnect_channel(CONN *, rib_conn_list_t *);
397 static void rib_detach_hca(ibt_hca_hdl_t);
398 static void rib_close_a_channel(CONN *);
399 static void rib_send_hold(rib_qp_t *);
400 static void rib_send_rele(rib_qp_t *);
401
402 /*
403 * Registration with IBTF as a consumer
404 */
405 static struct ibt_clnt_modinfo_s rib_modinfo = {
406 IBTI_V_CURR,
407 IBT_GENERIC,
408 rib_async_handler, /* async event handler */
409 NULL, /* Memory Region Handler */
410 "nfs/ib"
411 };
412
413 /*
414 * Global strucuture
415 */
416
417 typedef struct rpcib_s {
418 dev_info_t *rpcib_dip;
419 kmutex_t rpcib_mutex;
420 } rpcib_t;
421
422 rpcib_t rpcib;
423
424 /*
425 * /etc/system controlled variable to control
426 * debugging in rpcib kernel module.
427 * Set it to values greater that 1 to control
428 * the amount of debugging messages required.
429 */
430 int rib_debug = 0;
431
432 int
433 _init(void)
434 {
435 int error;
436
437 error = mod_install((struct modlinkage *)&rib_modlinkage);
438 if (error != 0) {
439 /*
440 * Could not load module
441 */
442 return (error);
443 }
444 mutex_init(&plugin_state_lock, NULL, MUTEX_DRIVER, NULL);
445 return (0);
446 }
447
448 int
449 _fini()
450 {
451 int status;
452
453 /*
454 * Remove module
455 */
456 if ((status = mod_remove(&rib_modlinkage)) != 0) {
457 return (status);
458 }
459 mutex_destroy(&plugin_state_lock);
460 return (0);
461 }
462
463 int
464 _info(struct modinfo *modinfop)
465 {
466 return (mod_info(&rib_modlinkage, modinfop));
467 }
468
469 /*
470 * rpcib_getinfo()
471 * Given the device number, return the devinfo pointer or the
472 * instance number.
473 * Note: always succeed DDI_INFO_DEVT2INSTANCE, even before attach.
474 */
475
476 /*ARGSUSED*/
477 static int
478 rpcib_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **result)
479 {
480 int ret = DDI_SUCCESS;
481
482 switch (cmd) {
483 case DDI_INFO_DEVT2DEVINFO:
484 if (rpcib.rpcib_dip != NULL)
485 *result = rpcib.rpcib_dip;
486 else {
487 *result = NULL;
488 ret = DDI_FAILURE;
489 }
490 break;
491
492 case DDI_INFO_DEVT2INSTANCE:
493 *result = NULL;
494 break;
495
496 default:
497 ret = DDI_FAILURE;
498 }
499 return (ret);
500 }
501
502 static void
503 rpcib_free_hca_list()
504 {
505 rib_hca_t *hca, *hcap;
506
507 rw_enter(&rib_stat->hcas_list_lock, RW_WRITER);
508 hca = rib_stat->hcas_list;
509 rib_stat->hcas_list = NULL;
510 rw_exit(&rib_stat->hcas_list_lock);
511 while (hca != NULL) {
512 rw_enter(&hca->state_lock, RW_WRITER);
513 hcap = hca;
514 hca = hca->next;
515 rib_stat->nhca_inited--;
516 rib_mod.rdma_count--;
517 hcap->state = HCA_DETACHED;
518 rw_exit(&hcap->state_lock);
519 rib_stop_hca_services(hcap);
520
521 kmem_free(hcap, sizeof (*hcap));
522 }
523 }
524
525 static rdma_stat
526 rpcib_free_service_list()
527 {
528 rib_service_t *service;
529 ibt_status_t ret;
530
531 rw_enter(&rib_stat->service_list_lock, RW_WRITER);
532 while (rib_stat->service_list != NULL) {
533 service = rib_stat->service_list;
534 ret = ibt_unbind_all_services(service->srv_hdl);
535 if (ret != IBT_SUCCESS) {
536 rw_exit(&rib_stat->service_list_lock);
537 #ifdef DEBUG
538 cmn_err(CE_NOTE, "rpcib_free_service_list: "
539 "ibt_unbind_all_services failed (%d)\n", (int)ret);
540 #endif
541 return (RDMA_FAILED);
542 }
543 ret = ibt_deregister_service(rib_stat->ibt_clnt_hdl,
544 service->srv_hdl);
545 if (ret != IBT_SUCCESS) {
546 rw_exit(&rib_stat->service_list_lock);
547 #ifdef DEBUG
548 cmn_err(CE_NOTE, "rpcib_free_service_list: "
549 "ibt_deregister_service failed (%d)\n", (int)ret);
550 #endif
551 return (RDMA_FAILED);
552 }
553 rib_stat->service_list = service->next;
554 kmem_free(service, sizeof (rib_service_t));
555 }
556 rw_exit(&rib_stat->service_list_lock);
557
558 return (RDMA_SUCCESS);
559 }
560
561 static int
562 rpcib_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
563 {
564 ibt_status_t ibt_status;
565 rdma_stat r_status;
566
567 switch (cmd) {
568 case DDI_ATTACH:
569 break;
570 case DDI_RESUME:
571 return (DDI_SUCCESS);
572 default:
573 return (DDI_FAILURE);
574 }
575
576 mutex_init(&rpcib.rpcib_mutex, NULL, MUTEX_DRIVER, NULL);
577
578 mutex_enter(&rpcib.rpcib_mutex);
579 if (rpcib.rpcib_dip != NULL) {
580 mutex_exit(&rpcib.rpcib_mutex);
581 return (DDI_FAILURE);
582 }
583 rpcib.rpcib_dip = dip;
584 mutex_exit(&rpcib.rpcib_mutex);
585 /*
586 * Create the "rpcib" minor-node.
587 */
588 if (ddi_create_minor_node(dip,
589 "rpcib", S_IFCHR, 0, DDI_PSEUDO, 0) != DDI_SUCCESS) {
590 /* Error message, no cmn_err as they print on console */
591 return (DDI_FAILURE);
592 }
593
594 if (rib_stat == NULL) {
595 rib_stat = kmem_zalloc(sizeof (*rib_stat), KM_SLEEP);
596 mutex_init(&rib_stat->open_hca_lock, NULL, MUTEX_DRIVER, NULL);
597 rw_init(&rib_stat->hcas_list_lock, NULL, RW_DRIVER, NULL);
598 mutex_init(&rib_stat->listen_lock, NULL, MUTEX_DRIVER, NULL);
599 }
600
601 rib_stat->hca_count = ibt_get_hca_list(NULL);
602 if (rib_stat->hca_count < 1) {
603 mutex_destroy(&rib_stat->listen_lock);
604 rw_destroy(&rib_stat->hcas_list_lock);
605 mutex_destroy(&rib_stat->open_hca_lock);
606 kmem_free(rib_stat, sizeof (*rib_stat));
607 rib_stat = NULL;
608 return (DDI_FAILURE);
609 }
610
611 ibt_status = ibt_attach(&rib_modinfo, dip,
612 (void *)rib_stat, &rib_stat->ibt_clnt_hdl);
613
614 if (ibt_status != IBT_SUCCESS) {
615 mutex_destroy(&rib_stat->listen_lock);
616 rw_destroy(&rib_stat->hcas_list_lock);
617 mutex_destroy(&rib_stat->open_hca_lock);
618 kmem_free(rib_stat, sizeof (*rib_stat));
619 rib_stat = NULL;
620 return (DDI_FAILURE);
621 }
622
623 rib_stat->service_list = NULL;
624 rw_init(&rib_stat->service_list_lock, NULL, RW_DRIVER, NULL);
625 mutex_enter(&rib_stat->open_hca_lock);
626 if (rpcib_open_hcas(rib_stat) != RDMA_SUCCESS) {
627 mutex_exit(&rib_stat->open_hca_lock);
628 goto open_fail;
629 }
630 mutex_exit(&rib_stat->open_hca_lock);
631
632 if (ddi_prop_update_int(DDI_DEV_T_NONE, dip, DDI_NO_AUTODETACH, 1) !=
633 DDI_PROP_SUCCESS) {
634 cmn_err(CE_WARN, "rpcib_attach: ddi-no-autodetach prop update "
635 "failed.");
636 goto register_fail;
637 }
638
639 /*
640 * Register with rdmatf
641 */
642 r_status = rdma_register_mod(&rib_mod);
643 if (r_status != RDMA_SUCCESS && r_status != RDMA_REG_EXIST) {
644 cmn_err(CE_WARN, "rpcib_attach:rdma_register_mod failed, "
645 "status = %d", r_status);
646 goto register_fail;
647 }
648
649 return (DDI_SUCCESS);
650
651 register_fail:
652
653 open_fail:
654 (void) ibt_detach(rib_stat->ibt_clnt_hdl);
655 rpcib_free_hca_list();
656 (void) rpcib_free_service_list();
657 mutex_destroy(&rib_stat->listen_lock);
658 rw_destroy(&rib_stat->hcas_list_lock);
659 mutex_destroy(&rib_stat->open_hca_lock);
660 rw_destroy(&rib_stat->service_list_lock);
661 kmem_free(rib_stat, sizeof (*rib_stat));
662 rib_stat = NULL;
663 return (DDI_FAILURE);
664 }
665
666 /*ARGSUSED*/
667 static int
668 rpcib_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
669 {
670 switch (cmd) {
671
672 case DDI_DETACH:
673 break;
674
675 case DDI_SUSPEND:
676 default:
677 return (DDI_FAILURE);
678 }
679
680 /*
681 * Detach the hca and free resources
682 */
683 mutex_enter(&plugin_state_lock);
684 plugin_state = NO_ACCEPT;
685 mutex_exit(&plugin_state_lock);
686
687 if (rpcib_free_service_list() != RDMA_SUCCESS)
688 return (DDI_FAILURE);
689 rpcib_free_hca_list();
690
691 (void) ibt_detach(rib_stat->ibt_clnt_hdl);
692 mutex_destroy(&rib_stat->listen_lock);
693 rw_destroy(&rib_stat->hcas_list_lock);
694 mutex_destroy(&rib_stat->open_hca_lock);
695 rw_destroy(&rib_stat->service_list_lock);
696
697 kmem_free(rib_stat, sizeof (*rib_stat));
698 rib_stat = NULL;
699
700 mutex_enter(&rpcib.rpcib_mutex);
701 rpcib.rpcib_dip = NULL;
702 mutex_exit(&rpcib.rpcib_mutex);
703 mutex_destroy(&rpcib.rpcib_mutex);
704 return (DDI_SUCCESS);
705 }
706
707
708 static void rib_rbufpool_free(rib_hca_t *, int);
709 static void rib_rbufpool_deregister(rib_hca_t *, int);
710 static void rib_rbufpool_destroy(rib_hca_t *hca, int ptype);
711 static struct reply *rib_addreplylist(rib_qp_t *, uint32_t);
712 static rdma_stat rib_rem_replylist(rib_qp_t *);
713 static int rib_remreply(rib_qp_t *, struct reply *);
714 static rdma_stat rib_add_connlist(CONN *, rib_conn_list_t *);
715 static rdma_stat rib_rm_conn(CONN *, rib_conn_list_t *);
716
717
718 /*
719 * One CQ pair per HCA
720 */
721 static rdma_stat
722 rib_create_cq(rib_hca_t *hca, uint32_t cq_size, ibt_cq_handler_t cq_handler,
723 rib_cq_t **cqp)
724 {
725 rib_cq_t *cq;
726 ibt_cq_attr_t cq_attr;
727 uint32_t real_size;
728 ibt_status_t status;
729 rdma_stat error = RDMA_SUCCESS;
730
731 cq = kmem_zalloc(sizeof (rib_cq_t), KM_SLEEP);
732 cq->rib_hca = hca;
733 bzero(&cq_attr, sizeof (cq_attr));
734 cq_attr.cq_size = cq_size;
735 cq_attr.cq_flags = IBT_CQ_NO_FLAGS;
736 status = ibt_alloc_cq(hca->hca_hdl, &cq_attr, &cq->rib_cq_hdl,
737 &real_size);
738 if (status != IBT_SUCCESS) {
739 cmn_err(CE_WARN, "rib_create_cq: ibt_alloc_cq() failed,"
740 " status=%d", status);
741 error = RDMA_FAILED;
742 goto fail;
743 }
744 ibt_set_cq_handler(cq->rib_cq_hdl, cq_handler, hca);
745
746 /*
747 * Enable CQ callbacks. CQ Callbacks are single shot
748 * (e.g. you have to call ibt_enable_cq_notify()
749 * after each callback to get another one).
750 */
751 status = ibt_enable_cq_notify(cq->rib_cq_hdl, IBT_NEXT_COMPLETION);
752 if (status != IBT_SUCCESS) {
753 cmn_err(CE_WARN, "rib_create_cq: "
754 "enable_cq_notify failed, status %d", status);
755 error = RDMA_FAILED;
756 goto fail;
757 }
758 *cqp = cq;
759
760 return (error);
761 fail:
762 if (cq->rib_cq_hdl)
763 (void) ibt_free_cq(cq->rib_cq_hdl);
764 if (cq)
765 kmem_free(cq, sizeof (rib_cq_t));
766 return (error);
767 }
768
769 /*
770 * rpcib_find_hca
771 *
772 * Caller should have already locked the hcas_lock before calling
773 * this function.
774 */
775 static rib_hca_t *
776 rpcib_find_hca(rpcib_state_t *ribstat, ib_guid_t guid)
777 {
778 rib_hca_t *hca = ribstat->hcas_list;
779
780 while (hca && hca->hca_guid != guid)
781 hca = hca->next;
782
783 return (hca);
784 }
785
786 static rdma_stat
787 rpcib_open_hcas(rpcib_state_t *ribstat)
788 {
789 rib_hca_t *hca;
790 ibt_status_t ibt_status;
791 rdma_stat status;
792 ibt_hca_portinfo_t *pinfop;
793 ibt_pd_flags_t pd_flags = IBT_PD_NO_FLAGS;
794 uint_t size, cq_size;
795 int i;
796 kstat_t *ksp;
797 cache_avl_struct_t example_avl_node;
798 char rssc_name[32];
799 int old_nhca_inited = ribstat->nhca_inited;
800 ib_guid_t *hca_guids;
801
802 ASSERT(MUTEX_HELD(&ribstat->open_hca_lock));
803
804 ribstat->hca_count = ibt_get_hca_list(&hca_guids);
805 if (ribstat->hca_count == 0)
806 return (RDMA_FAILED);
807
808 rw_enter(&ribstat->hcas_list_lock, RW_WRITER);
809 /*
810 * Open a hca and setup for RDMA
811 */
812 for (i = 0; i < ribstat->hca_count; i++) {
813 if (rpcib_find_hca(ribstat, hca_guids[i]))
814 continue;
815 hca = kmem_zalloc(sizeof (rib_hca_t), KM_SLEEP);
816
817 ibt_status = ibt_open_hca(ribstat->ibt_clnt_hdl,
818 hca_guids[i], &hca->hca_hdl);
819 if (ibt_status != IBT_SUCCESS) {
820 kmem_free(hca, sizeof (rib_hca_t));
821 continue;
822 }
823 hca->hca_guid = hca_guids[i];
824 hca->ibt_clnt_hdl = ribstat->ibt_clnt_hdl;
825 hca->state = HCA_INITED;
826
827 /*
828 * query HCA info
829 */
830 ibt_status = ibt_query_hca(hca->hca_hdl, &hca->hca_attrs);
831 if (ibt_status != IBT_SUCCESS) {
832 goto fail1;
833 }
834
835 /*
836 * One PD (Protection Domain) per HCA.
837 * A qp is allowed to access a memory region
838 * only when it's in the same PD as that of
839 * the memory region.
840 */
841 ibt_status = ibt_alloc_pd(hca->hca_hdl, pd_flags, &hca->pd_hdl);
842 if (ibt_status != IBT_SUCCESS) {
843 goto fail1;
844 }
845
846 /*
847 * query HCA ports
848 */
849 ibt_status = ibt_query_hca_ports(hca->hca_hdl,
850 0, &pinfop, &hca->hca_nports, &size);
851 if (ibt_status != IBT_SUCCESS) {
852 goto fail2;
853 }
854 hca->hca_ports = pinfop;
855 hca->hca_pinfosz = size;
856 pinfop = NULL;
857
858 cq_size = DEF_CQ_SIZE; /* default cq size */
859 /*
860 * Create 2 pairs of cq's (1 pair for client
861 * and the other pair for server) on this hca.
862 * If number of qp's gets too large, then several
863 * cq's will be needed.
864 */
865 status = rib_create_cq(hca, cq_size, rib_svc_rcq_handler,
866 &hca->svc_rcq);
867 if (status != RDMA_SUCCESS) {
868 goto fail3;
869 }
870
871 status = rib_create_cq(hca, cq_size, rib_svc_scq_handler,
872 &hca->svc_scq);
873 if (status != RDMA_SUCCESS) {
874 goto fail3;
875 }
876
877 status = rib_create_cq(hca, cq_size, rib_clnt_rcq_handler,
878 &hca->clnt_rcq);
879 if (status != RDMA_SUCCESS) {
880 goto fail3;
881 }
882
883 status = rib_create_cq(hca, cq_size, rib_clnt_scq_handler,
884 &hca->clnt_scq);
885 if (status != RDMA_SUCCESS) {
886 goto fail3;
887 }
888
889 /*
890 * Create buffer pools.
891 * Note rib_rbuf_create also allocates memory windows.
892 */
893 hca->recv_pool = rib_rbufpool_create(hca,
894 RECV_BUFFER, rib_max_rbufs);
895 if (hca->recv_pool == NULL) {
896 goto fail3;
897 }
898
899 hca->send_pool = rib_rbufpool_create(hca,
900 SEND_BUFFER, rib_max_rbufs);
901 if (hca->send_pool == NULL) {
902 rib_rbufpool_destroy(hca, RECV_BUFFER);
903 goto fail3;
904 }
905
906 if (hca->server_side_cache == NULL) {
907 (void) sprintf(rssc_name,
908 "rib_srvr_cache_%llx",
909 (long long unsigned int) hca->hca_guid);
910 hca->server_side_cache = kmem_cache_create(
911 rssc_name,
912 sizeof (cache_avl_struct_t), 0,
913 NULL,
914 NULL,
915 rib_server_side_cache_reclaim,
916 hca, NULL, 0);
917 }
918
919 avl_create(&hca->avl_tree,
920 avl_compare,
921 sizeof (cache_avl_struct_t),
922 (uint_t)(uintptr_t)&example_avl_node.avl_link-
923 (uint_t)(uintptr_t)&example_avl_node);
924
925 rw_init(&hca->bound_services_lock, NULL, RW_DRIVER,
926 hca->iblock);
927 rw_init(&hca->state_lock, NULL, RW_DRIVER, hca->iblock);
928 rw_init(&hca->avl_rw_lock,
929 NULL, RW_DRIVER, hca->iblock);
930 mutex_init(&hca->cache_allocation_lock,
931 NULL, MUTEX_DRIVER, NULL);
932 hca->avl_init = TRUE;
933
934 /* Create kstats for the cache */
935 ASSERT(INGLOBALZONE(curproc));
936
937 if (!stats_enabled) {
938 ksp = kstat_create_zone("unix", 0, "rpcib_cache", "rpc",
939 KSTAT_TYPE_NAMED,
940 sizeof (rpcib_kstat) / sizeof (kstat_named_t),
941 KSTAT_FLAG_VIRTUAL | KSTAT_FLAG_WRITABLE,
942 GLOBAL_ZONEID);
943 if (ksp) {
944 ksp->ks_data = (void *) &rpcib_kstat;
945 ksp->ks_update = rpcib_cache_kstat_update;
946 kstat_install(ksp);
947 stats_enabled = TRUE;
948 }
949 }
950 if (hca->cleanup_helper == NULL) {
951 char tq_name[sizeof (hca->hca_guid) * 2 + 1];
952
953 (void) snprintf(tq_name, sizeof (tq_name), "%llX",
954 (unsigned long long int) hca->hca_guid);
955 hca->cleanup_helper = ddi_taskq_create(NULL,
956 tq_name, 1, TASKQ_DEFAULTPRI, 0);
957 }
958
959 mutex_init(&hca->cb_lock, NULL, MUTEX_DRIVER, hca->iblock);
960 cv_init(&hca->cb_cv, NULL, CV_DRIVER, NULL);
961 rw_init(&hca->cl_conn_list.conn_lock, NULL, RW_DRIVER,
962 hca->iblock);
963 rw_init(&hca->srv_conn_list.conn_lock, NULL, RW_DRIVER,
964 hca->iblock);
965 mutex_init(&hca->inuse_lock, NULL, MUTEX_DRIVER, hca->iblock);
966 hca->inuse = TRUE;
967
968 hca->next = ribstat->hcas_list;
969 ribstat->hcas_list = hca;
970 ribstat->nhca_inited++;
971 ibt_free_portinfo(hca->hca_ports, hca->hca_pinfosz);
972 continue;
973
974 fail3:
975 ibt_free_portinfo(hca->hca_ports, hca->hca_pinfosz);
976 fail2:
977 (void) ibt_free_pd(hca->hca_hdl, hca->pd_hdl);
978 fail1:
979 (void) ibt_close_hca(hca->hca_hdl);
980 kmem_free(hca, sizeof (rib_hca_t));
981 }
982 rw_exit(&ribstat->hcas_list_lock);
983 ibt_free_hca_list(hca_guids, ribstat->hca_count);
984 rib_mod.rdma_count = rib_stat->nhca_inited;
985
986 /*
987 * return success if at least one new hca has been configured.
988 */
989 if (ribstat->nhca_inited != old_nhca_inited)
990 return (RDMA_SUCCESS);
991 else
992 return (RDMA_FAILED);
993 }
994
995 /*
996 * Callback routines
997 */
998
999 /*
1000 * SCQ handlers
1001 */
1002 /* ARGSUSED */
1003 static void
1004 rib_clnt_scq_handler(ibt_cq_hdl_t cq_hdl, void *arg)
1005 {
1006 ibt_status_t ibt_status;
1007 ibt_wc_t wc;
1008 struct send_wid *wd;
1009 CONN *conn;
1010 rib_qp_t *qp;
1011 int i;
1012
1013 /*
1014 * Re-enable cq notify here to avoid missing any
1015 * completion queue notification.
1016 */
1017 (void) ibt_enable_cq_notify(cq_hdl, IBT_NEXT_COMPLETION);
1018
1019 ibt_status = IBT_SUCCESS;
1020 while (ibt_status != IBT_CQ_EMPTY) {
1021 bzero(&wc, sizeof (wc));
1022 ibt_status = ibt_poll_cq(cq_hdl, &wc, 1, NULL);
1023 if (ibt_status != IBT_SUCCESS)
1024 return;
1025
1026 /*
1027 * Got a send completion
1028 */
1029 if (wc.wc_id != RDMA_DUMMY_WRID) {
1030 wd = (struct send_wid *)(uintptr_t)wc.wc_id;
1031 qp = wd->qp;
1032 conn = qptoc(qp);
1033
1034 mutex_enter(&wd->sendwait_lock);
1035 switch (wc.wc_status) {
1036 case IBT_WC_SUCCESS:
1037 wd->status = RDMA_SUCCESS;
1038 break;
1039 default:
1040 /*
1041 * RC Send Q Error Code Local state Remote State
1042 * ==================== =========== ============
1043 * IBT_WC_BAD_RESPONSE_ERR ERROR None
1044 * IBT_WC_LOCAL_LEN_ERR ERROR None
1045 * IBT_WC_LOCAL_CHAN_OP_ERR ERROR None
1046 * IBT_WC_LOCAL_PROTECT_ERR ERROR None
1047 * IBT_WC_MEM_WIN_BIND_ERR ERROR None
1048 * IBT_WC_REMOTE_INVALID_REQ_ERR ERROR ERROR
1049 * IBT_WC_REMOTE_ACCESS_ERR ERROR ERROR
1050 * IBT_WC_REMOTE_OP_ERR ERROR ERROR
1051 * IBT_WC_RNR_NAK_TIMEOUT_ERR ERROR None
1052 * IBT_WC_TRANS_TIMEOUT_ERR ERROR None
1053 * IBT_WC_WR_FLUSHED_ERR ERROR None
1054 */
1055 /*
1056 * Channel in error state. Set connection to
1057 * ERROR and cleanup will happen either from
1058 * conn_release or from rib_conn_get
1059 */
1060 wd->status = RDMA_FAILED;
1061 mutex_enter(&conn->c_lock);
1062 if (conn->c_state != C_DISCONN_PEND)
1063 conn->c_state = C_ERROR_CONN;
1064 mutex_exit(&conn->c_lock);
1065 break;
1066 }
1067
1068 if (wd->cv_sig == 1) {
1069 /*
1070 * Notify poster
1071 */
1072 cv_signal(&wd->wait_cv);
1073 mutex_exit(&wd->sendwait_lock);
1074 } else {
1075 /*
1076 * Poster not waiting for notification.
1077 * Free the send buffers and send_wid
1078 */
1079 for (i = 0; i < wd->nsbufs; i++) {
1080 rib_rbuf_free(qptoc(wd->qp),
1081 SEND_BUFFER,
1082 (void *)(uintptr_t)wd->sbufaddr[i]);
1083 }
1084
1085 /* decrement the send ref count */
1086 rib_send_rele(qp);
1087
1088 mutex_exit(&wd->sendwait_lock);
1089 (void) rib_free_sendwait(wd);
1090 }
1091 }
1092 }
1093 }
1094
1095 /* ARGSUSED */
1096 static void
1097 rib_svc_scq_handler(ibt_cq_hdl_t cq_hdl, void *arg)
1098 {
1099 ibt_status_t ibt_status;
1100 ibt_wc_t wc;
1101 struct send_wid *wd;
1102 rib_qp_t *qp;
1103 CONN *conn;
1104 int i;
1105
1106 /*
1107 * Re-enable cq notify here to avoid missing any
1108 * completion queue notification.
1109 */
1110 (void) ibt_enable_cq_notify(cq_hdl, IBT_NEXT_COMPLETION);
1111
1112 ibt_status = IBT_SUCCESS;
1113 while (ibt_status != IBT_CQ_EMPTY) {
1114 bzero(&wc, sizeof (wc));
1115 ibt_status = ibt_poll_cq(cq_hdl, &wc, 1, NULL);
1116 if (ibt_status != IBT_SUCCESS)
1117 return;
1118
1119 /*
1120 * Got a send completion
1121 */
1122 if (wc.wc_id != RDMA_DUMMY_WRID) {
1123 wd = (struct send_wid *)(uintptr_t)wc.wc_id;
1124 qp = wd->qp;
1125 conn = qptoc(qp);
1126 mutex_enter(&wd->sendwait_lock);
1127
1128 switch (wc.wc_status) {
1129 case IBT_WC_SUCCESS:
1130 wd->status = RDMA_SUCCESS;
1131 break;
1132 default:
1133 /*
1134 * Channel in error state. Set connection to
1135 * ERROR and cleanup will happen either from
1136 * conn_release or conn timeout.
1137 */
1138 wd->status = RDMA_FAILED;
1139 mutex_enter(&conn->c_lock);
1140 if (conn->c_state != C_DISCONN_PEND)
1141 conn->c_state = C_ERROR_CONN;
1142 mutex_exit(&conn->c_lock);
1143 break;
1144 }
1145
1146 if (wd->cv_sig == 1) {
1147 /*
1148 * Update completion status and notify poster
1149 */
1150 cv_signal(&wd->wait_cv);
1151 mutex_exit(&wd->sendwait_lock);
1152 } else {
1153 /*
1154 * Poster not waiting for notification.
1155 * Free the send buffers and send_wid
1156 */
1157 for (i = 0; i < wd->nsbufs; i++) {
1158 rib_rbuf_free(qptoc(wd->qp),
1159 SEND_BUFFER,
1160 (void *)(uintptr_t)wd->sbufaddr[i]);
1161 }
1162
1163 /* decrement the send ref count */
1164 rib_send_rele(qp);
1165
1166 mutex_exit(&wd->sendwait_lock);
1167 (void) rib_free_sendwait(wd);
1168 }
1169 }
1170 }
1171 }
1172
1173 /*
1174 * RCQ handler
1175 */
1176 /* ARGSUSED */
1177 static void
1178 rib_clnt_rcq_handler(ibt_cq_hdl_t cq_hdl, void *arg)
1179 {
1180 rib_qp_t *qp;
1181 ibt_status_t ibt_status;
1182 ibt_wc_t wc;
1183 struct recv_wid *rwid;
1184
1185 /*
1186 * Re-enable cq notify here to avoid missing any
1187 * completion queue notification.
1188 */
1189 (void) ibt_enable_cq_notify(cq_hdl, IBT_NEXT_COMPLETION);
1190
1191 ibt_status = IBT_SUCCESS;
1192 while (ibt_status != IBT_CQ_EMPTY) {
1193 bzero(&wc, sizeof (wc));
1194 ibt_status = ibt_poll_cq(cq_hdl, &wc, 1, NULL);
1195 if (ibt_status != IBT_SUCCESS)
1196 return;
1197
1198 rwid = (struct recv_wid *)(uintptr_t)wc.wc_id;
1199 qp = rwid->qp;
1200
1201 if (wc.wc_status == IBT_WC_SUCCESS) {
1202 XDR inxdrs, *xdrs;
1203 uint_t xid, vers, op, find_xid = 0;
1204 struct reply *r;
1205 CONN *conn = qptoc(qp);
1206 uint32_t rdma_credit = 0;
1207
1208 xdrs = &inxdrs;
1209 xdrmem_create(xdrs, (caddr_t)(uintptr_t)rwid->addr,
1210 wc.wc_bytes_xfer, XDR_DECODE);
1211 /*
1212 * Treat xid as opaque (xid is the first entity
1213 * in the rpc rdma message).
1214 */
1215 xid = *(uint32_t *)(uintptr_t)rwid->addr;
1216
1217 /* Skip xid and set the xdr position accordingly. */
1218 XDR_SETPOS(xdrs, sizeof (uint32_t));
1219 (void) xdr_u_int(xdrs, &vers);
1220 (void) xdr_u_int(xdrs, &rdma_credit);
1221 (void) xdr_u_int(xdrs, &op);
1222 XDR_DESTROY(xdrs);
1223
1224 if (vers != RPCRDMA_VERS) {
1225 /*
1226 * Invalid RPC/RDMA version. Cannot
1227 * interoperate. Set connection to
1228 * ERROR state and bail out.
1229 */
1230 mutex_enter(&conn->c_lock);
1231 if (conn->c_state != C_DISCONN_PEND)
1232 conn->c_state = C_ERROR_CONN;
1233 mutex_exit(&conn->c_lock);
1234 rib_rbuf_free(conn, RECV_BUFFER,
1235 (void *)(uintptr_t)rwid->addr);
1236 rib_free_wid(rwid);
1237 rib_recv_rele(qp);
1238 continue;
1239 }
1240
1241 mutex_enter(&qp->replylist_lock);
1242 for (r = qp->replylist; r != NULL; r = r->next) {
1243 if (r->xid == xid) {
1244 find_xid = 1;
1245 switch (op) {
1246 case RDMA_MSG:
1247 case RDMA_NOMSG:
1248 case RDMA_MSGP:
1249 r->status = RDMA_SUCCESS;
1250 r->vaddr_cq = rwid->addr;
1251 r->bytes_xfer =
1252 wc.wc_bytes_xfer;
1253 cv_signal(&r->wait_cv);
1254 break;
1255 default:
1256 rib_rbuf_free(qptoc(qp),
1257 RECV_BUFFER,
1258 (void *)(uintptr_t)
1259 rwid->addr);
1260 break;
1261 }
1262 break;
1263 }
1264 }
1265 mutex_exit(&qp->replylist_lock);
1266 if (find_xid == 0) {
1267 /* RPC caller not waiting for reply */
1268
1269 DTRACE_PROBE1(rpcib__i__nomatchxid1,
1270 int, xid);
1271
1272 rib_rbuf_free(qptoc(qp), RECV_BUFFER,
1273 (void *)(uintptr_t)rwid->addr);
1274 }
1275 } else if (wc.wc_status == IBT_WC_WR_FLUSHED_ERR) {
1276 CONN *conn = qptoc(qp);
1277
1278 /*
1279 * Connection being flushed. Just free
1280 * the posted buffer
1281 */
1282 rib_rbuf_free(conn, RECV_BUFFER,
1283 (void *)(uintptr_t)rwid->addr);
1284 } else {
1285 CONN *conn = qptoc(qp);
1286 /*
1287 * RC Recv Q Error Code Local state Remote State
1288 * ==================== =========== ============
1289 * IBT_WC_LOCAL_ACCESS_ERR ERROR ERROR when NAK recvd
1290 * IBT_WC_LOCAL_LEN_ERR ERROR ERROR when NAK recvd
1291 * IBT_WC_LOCAL_PROTECT_ERR ERROR ERROR when NAK recvd
1292 * IBT_WC_LOCAL_CHAN_OP_ERR ERROR ERROR when NAK recvd
1293 * IBT_WC_REMOTE_INVALID_REQ_ERR ERROR ERROR when NAK recvd
1294 * IBT_WC_WR_FLUSHED_ERR None None
1295 */
1296 /*
1297 * Channel in error state. Set connection
1298 * in ERROR state.
1299 */
1300 mutex_enter(&conn->c_lock);
1301 if (conn->c_state != C_DISCONN_PEND)
1302 conn->c_state = C_ERROR_CONN;
1303 mutex_exit(&conn->c_lock);
1304 rib_rbuf_free(conn, RECV_BUFFER,
1305 (void *)(uintptr_t)rwid->addr);
1306 }
1307 rib_free_wid(rwid);
1308 rib_recv_rele(qp);
1309 }
1310 }
1311
1312 /* Server side */
1313 /* ARGSUSED */
1314 static void
1315 rib_svc_rcq_handler(ibt_cq_hdl_t cq_hdl, void *arg)
1316 {
1317 rdma_recv_data_t *rdp;
1318 rib_qp_t *qp;
1319 ibt_status_t ibt_status;
1320 ibt_wc_t wc;
1321 struct svc_recv *s_recvp;
1322 CONN *conn;
1323 mblk_t *mp;
1324
1325 /*
1326 * Re-enable cq notify here to avoid missing any
1327 * completion queue notification.
1328 */
1329 (void) ibt_enable_cq_notify(cq_hdl, IBT_NEXT_COMPLETION);
1330
1331 ibt_status = IBT_SUCCESS;
1332 while (ibt_status != IBT_CQ_EMPTY) {
1333 bzero(&wc, sizeof (wc));
1334 ibt_status = ibt_poll_cq(cq_hdl, &wc, 1, NULL);
1335 if (ibt_status != IBT_SUCCESS)
1336 return;
1337
1338 s_recvp = (struct svc_recv *)(uintptr_t)wc.wc_id;
1339 qp = s_recvp->qp;
1340 conn = qptoc(qp);
1341
1342 if (wc.wc_status == IBT_WC_SUCCESS) {
1343 XDR inxdrs, *xdrs;
1344 uint_t xid, vers, op;
1345 uint32_t rdma_credit;
1346
1347 xdrs = &inxdrs;
1348 /* s_recvp->vaddr stores data */
1349 xdrmem_create(xdrs, (caddr_t)(uintptr_t)s_recvp->vaddr,
1350 wc.wc_bytes_xfer, XDR_DECODE);
1351
1352 /*
1353 * Treat xid as opaque (xid is the first entity
1354 * in the rpc rdma message).
1355 */
1356 xid = *(uint32_t *)(uintptr_t)s_recvp->vaddr;
1357 /* Skip xid and set the xdr position accordingly. */
1358 XDR_SETPOS(xdrs, sizeof (uint32_t));
1359 if (!xdr_u_int(xdrs, &vers) ||
1360 !xdr_u_int(xdrs, &rdma_credit) ||
1361 !xdr_u_int(xdrs, &op)) {
1362 rib_rbuf_free(conn, RECV_BUFFER,
1363 (void *)(uintptr_t)s_recvp->vaddr);
1364 XDR_DESTROY(xdrs);
1365 rib_recv_rele(qp);
1366 (void) rib_free_svc_recv(s_recvp);
1367 continue;
1368 }
1369 XDR_DESTROY(xdrs);
1370
1371 if (vers != RPCRDMA_VERS) {
1372 /*
1373 * Invalid RPC/RDMA version.
1374 * Drop rpc rdma message.
1375 */
1376 rib_rbuf_free(conn, RECV_BUFFER,
1377 (void *)(uintptr_t)s_recvp->vaddr);
1378 rib_recv_rele(qp);
1379 (void) rib_free_svc_recv(s_recvp);
1380 continue;
1381 }
1382 /*
1383 * Is this for RDMA_DONE?
1384 */
1385 if (op == RDMA_DONE) {
1386 rib_rbuf_free(conn, RECV_BUFFER,
1387 (void *)(uintptr_t)s_recvp->vaddr);
1388 /*
1389 * Wake up the thread waiting on
1390 * a RDMA_DONE for xid
1391 */
1392 mutex_enter(&qp->rdlist_lock);
1393 rdma_done_notify(qp, xid);
1394 mutex_exit(&qp->rdlist_lock);
1395 rib_recv_rele(qp);
1396 (void) rib_free_svc_recv(s_recvp);
1397 continue;
1398 }
1399
1400 mutex_enter(&plugin_state_lock);
1401 mutex_enter(&conn->c_lock);
1402 if ((plugin_state == ACCEPT) &&
1403 (conn->c_state == C_CONNECTED)) {
1404 conn->c_ref++;
1405 mutex_exit(&conn->c_lock);
1406 while ((mp = allocb(sizeof (*rdp), BPRI_LO))
1407 == NULL)
1408 (void) strwaitbuf(
1409 sizeof (*rdp), BPRI_LO);
1410 /*
1411 * Plugin is in accept state, hence the master
1412 * transport queue for this is still accepting
1413 * requests. Hence we can call svc_queuereq to
1414 * queue this recieved msg.
1415 */
1416 rdp = (rdma_recv_data_t *)mp->b_rptr;
1417 rdp->conn = conn;
1418 rdp->rpcmsg.addr =
1419 (caddr_t)(uintptr_t)s_recvp->vaddr;
1420 rdp->rpcmsg.type = RECV_BUFFER;
1421 rdp->rpcmsg.len = wc.wc_bytes_xfer;
1422 rdp->status = wc.wc_status;
1423 mp->b_wptr += sizeof (*rdp);
1424 (void) svc_queuereq((queue_t *)rib_stat->q, mp,
1425 FALSE);
1426 mutex_exit(&plugin_state_lock);
1427 } else {
1428 /*
1429 * The master transport for this is going
1430 * away and the queue is not accepting anymore
1431 * requests for krpc, so don't do anything, just
1432 * free the msg.
1433 */
1434 mutex_exit(&conn->c_lock);
1435 mutex_exit(&plugin_state_lock);
1436 rib_rbuf_free(conn, RECV_BUFFER,
1437 (void *)(uintptr_t)s_recvp->vaddr);
1438 }
1439 } else {
1440 rib_rbuf_free(conn, RECV_BUFFER,
1441 (void *)(uintptr_t)s_recvp->vaddr);
1442 }
1443 rib_recv_rele(qp);
1444 (void) rib_free_svc_recv(s_recvp);
1445 }
1446 }
1447
1448 static void
1449 rib_attach_hca()
1450 {
1451 mutex_enter(&rib_stat->open_hca_lock);
1452 (void) rpcib_open_hcas(rib_stat);
1453 rib_listen(NULL);
1454 mutex_exit(&rib_stat->open_hca_lock);
1455 }
1456
1457 /*
1458 * Handles DR event of IBT_HCA_DETACH_EVENT.
1459 */
1460 /* ARGSUSED */
1461 static void
1462 rib_async_handler(void *clnt_private, ibt_hca_hdl_t hca_hdl,
1463 ibt_async_code_t code, ibt_async_event_t *event)
1464 {
1465 switch (code) {
1466 case IBT_HCA_ATTACH_EVENT:
1467 rib_attach_hca();
1468 break;
1469 case IBT_HCA_DETACH_EVENT:
1470 rib_detach_hca(hca_hdl);
1471 #ifdef DEBUG
1472 cmn_err(CE_NOTE, "rib_async_handler(): HCA being detached!\n");
1473 #endif
1474 break;
1475 case IBT_EVENT_PORT_UP:
1476 /*
1477 * A port is up. We should call rib_listen() since there is
1478 * a chance that rib_listen() may have failed during
1479 * rib_attach_hca() because the port had not been up yet.
1480 */
1481 rib_listen(NULL);
1482 #ifdef DEBUG
1483 cmn_err(CE_NOTE, "rib_async_handler(): IBT_EVENT_PORT_UP\n");
1484 #endif
1485 break;
1486 #ifdef DEBUG
1487 case IBT_EVENT_PATH_MIGRATED:
1488 cmn_err(CE_NOTE, "rib_async_handler(): "
1489 "IBT_EVENT_PATH_MIGRATED\n");
1490 break;
1491 case IBT_EVENT_SQD:
1492 cmn_err(CE_NOTE, "rib_async_handler(): IBT_EVENT_SQD\n");
1493 break;
1494 case IBT_EVENT_COM_EST:
1495 cmn_err(CE_NOTE, "rib_async_handler(): IBT_EVENT_COM_EST\n");
1496 break;
1497 case IBT_ERROR_CATASTROPHIC_CHAN:
1498 cmn_err(CE_NOTE, "rib_async_handler(): "
1499 "IBT_ERROR_CATASTROPHIC_CHAN\n");
1500 break;
1501 case IBT_ERROR_INVALID_REQUEST_CHAN:
1502 cmn_err(CE_NOTE, "rib_async_handler(): "
1503 "IBT_ERROR_INVALID_REQUEST_CHAN\n");
1504 break;
1505 case IBT_ERROR_ACCESS_VIOLATION_CHAN:
1506 cmn_err(CE_NOTE, "rib_async_handler(): "
1507 "IBT_ERROR_ACCESS_VIOLATION_CHAN\n");
1508 break;
1509 case IBT_ERROR_PATH_MIGRATE_REQ:
1510 cmn_err(CE_NOTE, "rib_async_handler(): "
1511 "IBT_ERROR_PATH_MIGRATE_REQ\n");
1512 break;
1513 case IBT_ERROR_CQ:
1514 cmn_err(CE_NOTE, "rib_async_handler(): IBT_ERROR_CQ\n");
1515 break;
1516 case IBT_ERROR_PORT_DOWN:
1517 cmn_err(CE_NOTE, "rib_async_handler(): IBT_ERROR_PORT_DOWN\n");
1518 break;
1519 case IBT_ASYNC_OPAQUE1:
1520 cmn_err(CE_NOTE, "rib_async_handler(): IBT_ASYNC_OPAQUE1\n");
1521 break;
1522 case IBT_ASYNC_OPAQUE2:
1523 cmn_err(CE_NOTE, "rib_async_handler(): IBT_ASYNC_OPAQUE2\n");
1524 break;
1525 case IBT_ASYNC_OPAQUE3:
1526 cmn_err(CE_NOTE, "rib_async_handler(): IBT_ASYNC_OPAQUE3\n");
1527 break;
1528 case IBT_ASYNC_OPAQUE4:
1529 cmn_err(CE_NOTE, "rib_async_handler(): IBT_ASYNC_OPAQUE4\n");
1530 break;
1531 #endif
1532 default:
1533 break;
1534 }
1535 }
1536
1537 /*
1538 * Client's reachable function.
1539 */
1540 static rdma_stat
1541 rib_reachable(int addr_type, struct netbuf *raddr, void **handle)
1542 {
1543 rdma_stat status;
1544 rpcib_ping_t rpt;
1545 struct netbuf saddr;
1546 CONN *conn;
1547
1548 bzero(&saddr, sizeof (struct netbuf));
1549 status = rib_connect(&saddr, raddr, addr_type, &rpt, &conn);
1550
1551 if (status == RDMA_SUCCESS) {
1552 *handle = (void *)rpt.hca;
1553 /* release the reference */
1554 (void) rib_conn_release(conn);
1555 return (RDMA_SUCCESS);
1556 } else {
1557 *handle = NULL;
1558 DTRACE_PROBE(rpcib__i__pingfailed);
1559 return (RDMA_FAILED);
1560 }
1561 }
1562
1563 /* Client side qp creation */
1564 static rdma_stat
1565 rib_clnt_create_chan(rib_hca_t *hca, struct netbuf *raddr, rib_qp_t **qp)
1566 {
1567 rib_qp_t *kqp = NULL;
1568 CONN *conn;
1569 rdma_clnt_cred_ctrl_t *cc_info;
1570
1571 ASSERT(qp != NULL);
1572 *qp = NULL;
1573
1574 kqp = kmem_zalloc(sizeof (rib_qp_t), KM_SLEEP);
1575 conn = qptoc(kqp);
1576 kqp->hca = hca;
1577 kqp->rdmaconn.c_rdmamod = &rib_mod;
1578 kqp->rdmaconn.c_private = (caddr_t)kqp;
1579
1580 kqp->mode = RIB_CLIENT;
1581 kqp->chan_flags = IBT_BLOCKING;
1582 conn->c_raddr.buf = kmem_alloc(raddr->len, KM_SLEEP);
1583 bcopy(raddr->buf, conn->c_raddr.buf, raddr->len);
1584 conn->c_raddr.len = conn->c_raddr.maxlen = raddr->len;
1585 /*
1586 * Initialize
1587 */
1588 cv_init(&kqp->cb_conn_cv, NULL, CV_DEFAULT, NULL);
1589 cv_init(&kqp->posted_rbufs_cv, NULL, CV_DEFAULT, NULL);
1590 mutex_init(&kqp->posted_rbufs_lock, NULL, MUTEX_DRIVER, hca->iblock);
1591 cv_init(&kqp->send_rbufs_cv, NULL, CV_DEFAULT, NULL);
1592 mutex_init(&kqp->send_rbufs_lock, NULL, MUTEX_DRIVER, hca->iblock);
1593 mutex_init(&kqp->replylist_lock, NULL, MUTEX_DRIVER, hca->iblock);
1594 mutex_init(&kqp->rdlist_lock, NULL, MUTEX_DEFAULT, hca->iblock);
1595 mutex_init(&kqp->cb_lock, NULL, MUTEX_DRIVER, hca->iblock);
1596 cv_init(&kqp->rdmaconn.c_cv, NULL, CV_DEFAULT, NULL);
1597 mutex_init(&kqp->rdmaconn.c_lock, NULL, MUTEX_DRIVER, hca->iblock);
1598 /*
1599 * Initialize the client credit control
1600 * portion of the rdmaconn struct.
1601 */
1602 kqp->rdmaconn.c_cc_type = RDMA_CC_CLNT;
1603 cc_info = &kqp->rdmaconn.rdma_conn_cred_ctrl_u.c_clnt_cc;
1604 cc_info->clnt_cc_granted_ops = 0;
1605 cc_info->clnt_cc_in_flight_ops = 0;
1606 cv_init(&cc_info->clnt_cc_cv, NULL, CV_DEFAULT, NULL);
1607
1608 *qp = kqp;
1609 return (RDMA_SUCCESS);
1610 }
1611
1612 /* Server side qp creation */
1613 static rdma_stat
1614 rib_svc_create_chan(rib_hca_t *hca, caddr_t q, uint8_t port, rib_qp_t **qp)
1615 {
1616 rib_qp_t *kqp = NULL;
1617 ibt_chan_sizes_t chan_sizes;
1618 ibt_rc_chan_alloc_args_t qp_attr;
1619 ibt_status_t ibt_status;
1620 rdma_srv_cred_ctrl_t *cc_info;
1621
1622 *qp = NULL;
1623
1624 kqp = kmem_zalloc(sizeof (rib_qp_t), KM_SLEEP);
1625 kqp->hca = hca;
1626 kqp->port_num = port;
1627 kqp->rdmaconn.c_rdmamod = &rib_mod;
1628 kqp->rdmaconn.c_private = (caddr_t)kqp;
1629
1630 /*
1631 * Create the qp handle
1632 */
1633 bzero(&qp_attr, sizeof (ibt_rc_chan_alloc_args_t));
1634 qp_attr.rc_scq = hca->svc_scq->rib_cq_hdl;
1635 qp_attr.rc_rcq = hca->svc_rcq->rib_cq_hdl;
1636 qp_attr.rc_pd = hca->pd_hdl;
1637 qp_attr.rc_hca_port_num = port;
1638 qp_attr.rc_sizes.cs_sq_sgl = DSEG_MAX;
1639 qp_attr.rc_sizes.cs_rq_sgl = RQ_DSEG_MAX;
1640 qp_attr.rc_sizes.cs_sq = DEF_SQ_SIZE;
1641 qp_attr.rc_sizes.cs_rq = DEF_RQ_SIZE;
1642 qp_attr.rc_clone_chan = NULL;
1643 qp_attr.rc_control = IBT_CEP_RDMA_RD | IBT_CEP_RDMA_WR;
1644 qp_attr.rc_flags = IBT_WR_SIGNALED;
1645
1646 rw_enter(&hca->state_lock, RW_READER);
1647 if (hca->state != HCA_DETACHED) {
1648 ibt_status = ibt_alloc_rc_channel(hca->hca_hdl,
1649 IBT_ACHAN_NO_FLAGS, &qp_attr, &kqp->qp_hdl,
1650 &chan_sizes);
1651 } else {
1652 rw_exit(&hca->state_lock);
1653 goto fail;
1654 }
1655 rw_exit(&hca->state_lock);
1656
1657 if (ibt_status != IBT_SUCCESS) {
1658 DTRACE_PROBE1(rpcib__i_svccreatechanfail,
1659 int, ibt_status);
1660 goto fail;
1661 }
1662
1663 kqp->mode = RIB_SERVER;
1664 kqp->chan_flags = IBT_BLOCKING;
1665 kqp->q = q; /* server ONLY */
1666
1667 cv_init(&kqp->cb_conn_cv, NULL, CV_DEFAULT, NULL);
1668 cv_init(&kqp->posted_rbufs_cv, NULL, CV_DEFAULT, NULL);
1669 mutex_init(&kqp->replylist_lock, NULL, MUTEX_DEFAULT, hca->iblock);
1670 mutex_init(&kqp->posted_rbufs_lock, NULL, MUTEX_DRIVER, hca->iblock);
1671 cv_init(&kqp->send_rbufs_cv, NULL, CV_DEFAULT, NULL);
1672 mutex_init(&kqp->send_rbufs_lock, NULL, MUTEX_DRIVER, hca->iblock);
1673 mutex_init(&kqp->rdlist_lock, NULL, MUTEX_DEFAULT, hca->iblock);
1674 mutex_init(&kqp->cb_lock, NULL, MUTEX_DRIVER, hca->iblock);
1675 cv_init(&kqp->rdmaconn.c_cv, NULL, CV_DEFAULT, NULL);
1676 mutex_init(&kqp->rdmaconn.c_lock, NULL, MUTEX_DRIVER, hca->iblock);
1677 /*
1678 * Set the private data area to qp to be used in callbacks
1679 */
1680 ibt_set_chan_private(kqp->qp_hdl, (void *)kqp);
1681 kqp->rdmaconn.c_state = C_CONNECTED;
1682
1683 /*
1684 * Initialize the server credit control
1685 * portion of the rdmaconn struct.
1686 */
1687 kqp->rdmaconn.c_cc_type = RDMA_CC_SRV;
1688 cc_info = &kqp->rdmaconn.rdma_conn_cred_ctrl_u.c_srv_cc;
1689 cc_info->srv_cc_buffers_granted = preposted_rbufs;
1690 cc_info->srv_cc_cur_buffers_used = 0;
1691 cc_info->srv_cc_posted = preposted_rbufs;
1692
1693 *qp = kqp;
1694
1695 return (RDMA_SUCCESS);
1696 fail:
1697 if (kqp)
1698 kmem_free(kqp, sizeof (rib_qp_t));
1699
1700 return (RDMA_FAILED);
1701 }
1702
1703 /* ARGSUSED */
1704 ibt_cm_status_t
1705 rib_clnt_cm_handler(void *clnt_hdl, ibt_cm_event_t *event,
1706 ibt_cm_return_args_t *ret_args, void *priv_data,
1707 ibt_priv_data_len_t len)
1708 {
1709 rib_hca_t *hca;
1710
1711 hca = (rib_hca_t *)clnt_hdl;
1712
1713 switch (event->cm_type) {
1714
1715 /* got a connection close event */
1716 case IBT_CM_EVENT_CONN_CLOSED:
1717 {
1718 CONN *conn;
1719 rib_qp_t *qp;
1720
1721 /* check reason why connection was closed */
1722 switch (event->cm_event.closed) {
1723 case IBT_CM_CLOSED_DREP_RCVD:
1724 case IBT_CM_CLOSED_DREQ_TIMEOUT:
1725 case IBT_CM_CLOSED_DUP:
1726 case IBT_CM_CLOSED_ABORT:
1727 case IBT_CM_CLOSED_ALREADY:
1728 /*
1729 * These cases indicate the local end initiated
1730 * the closing of the channel. Nothing to do here.
1731 */
1732 break;
1733 default:
1734 /*
1735 * Reason for CONN_CLOSED event must be one of
1736 * IBT_CM_CLOSED_DREQ_RCVD or IBT_CM_CLOSED_REJ_RCVD
1737 * or IBT_CM_CLOSED_STALE. These indicate cases were
1738 * the remote end is closing the channel. In these
1739 * cases free the channel and transition to error
1740 * state
1741 */
1742 qp = ibt_get_chan_private(event->cm_channel);
1743 conn = qptoc(qp);
1744 mutex_enter(&conn->c_lock);
1745 if (conn->c_state == C_DISCONN_PEND) {
1746 mutex_exit(&conn->c_lock);
1747 break;
1748 }
1749
1750 conn->c_state = C_ERROR_CONN;
1751
1752 /*
1753 * Free the conn if c_ref is down to 0 already
1754 */
1755 if (conn->c_ref == 0) {
1756 /*
1757 * Remove from list and free conn
1758 */
1759 conn->c_state = C_DISCONN_PEND;
1760 mutex_exit(&conn->c_lock);
1761 rw_enter(&hca->state_lock, RW_READER);
1762 if (hca->state != HCA_DETACHED)
1763 (void) rib_disconnect_channel(conn,
1764 &hca->cl_conn_list);
1765 rw_exit(&hca->state_lock);
1766 } else {
1767 /*
1768 * conn will be freed when c_ref goes to 0.
1769 * Indicate to cleaning thread not to close
1770 * the connection, but just free the channel.
1771 */
1772 conn->c_flags |= C_CLOSE_NOTNEEDED;
1773 mutex_exit(&conn->c_lock);
1774 }
1775 #ifdef DEBUG
1776 if (rib_debug)
1777 cmn_err(CE_NOTE, "rib_clnt_cm_handler: "
1778 "(CONN_CLOSED) channel disconnected");
1779 #endif
1780 break;
1781 }
1782 break;
1783 }
1784 default:
1785 break;
1786 }
1787 return (IBT_CM_ACCEPT);
1788 }
1789
1790 /*
1791 * Connect to the server.
1792 */
1793 rdma_stat
1794 rib_conn_to_srv(rib_hca_t *hca, rib_qp_t *qp, rpcib_ping_t *rptp)
1795 {
1796 ibt_chan_open_args_t chan_args; /* channel args */
1797 ibt_chan_sizes_t chan_sizes;
1798 ibt_rc_chan_alloc_args_t qp_attr;
1799 ibt_status_t ibt_status;
1800 ibt_rc_returns_t ret_args; /* conn reject info */
1801 int refresh = REFRESH_ATTEMPTS; /* refresh if IBT_CM_CONN_STALE */
1802 ibt_ip_cm_info_t ipcm_info;
1803 uint8_t cmp_ip_pvt[IBT_IP_HDR_PRIV_DATA_SZ];
1804
1805
1806 (void) bzero(&chan_args, sizeof (chan_args));
1807 (void) bzero(&qp_attr, sizeof (ibt_rc_chan_alloc_args_t));
1808 (void) bzero(&ipcm_info, sizeof (ibt_ip_cm_info_t));
1809
1810 ipcm_info.src_addr.family = rptp->srcip.family;
1811 switch (ipcm_info.src_addr.family) {
1812 case AF_INET:
1813 ipcm_info.src_addr.un.ip4addr = rptp->srcip.un.ip4addr;
1814 break;
1815 case AF_INET6:
1816 ipcm_info.src_addr.un.ip6addr = rptp->srcip.un.ip6addr;
1817 break;
1818 }
1819
1820 ipcm_info.dst_addr.family = rptp->srcip.family;
1821 switch (ipcm_info.dst_addr.family) {
1822 case AF_INET:
1823 ipcm_info.dst_addr.un.ip4addr = rptp->dstip.un.ip4addr;
1824 break;
1825 case AF_INET6:
1826 ipcm_info.dst_addr.un.ip6addr = rptp->dstip.un.ip6addr;
1827 break;
1828 }
1829
1830 ipcm_info.src_port = (in_port_t)nfs_rdma_port;
1831
1832 ibt_status = ibt_format_ip_private_data(&ipcm_info,
1833 IBT_IP_HDR_PRIV_DATA_SZ, cmp_ip_pvt);
1834
1835 if (ibt_status != IBT_SUCCESS) {
1836 cmn_err(CE_WARN, "ibt_format_ip_private_data failed\n");
1837 return (-1);
1838 }
1839
1840 qp_attr.rc_hca_port_num = rptp->path.pi_prim_cep_path.cep_hca_port_num;
1841 /* Alloc a RC channel */
1842 qp_attr.rc_scq = hca->clnt_scq->rib_cq_hdl;
1843 qp_attr.rc_rcq = hca->clnt_rcq->rib_cq_hdl;
1844 qp_attr.rc_pd = hca->pd_hdl;
1845 qp_attr.rc_sizes.cs_sq_sgl = DSEG_MAX;
1846 qp_attr.rc_sizes.cs_rq_sgl = RQ_DSEG_MAX;
1847 qp_attr.rc_sizes.cs_sq = DEF_SQ_SIZE;
1848 qp_attr.rc_sizes.cs_rq = DEF_RQ_SIZE;
1849 qp_attr.rc_clone_chan = NULL;
1850 qp_attr.rc_control = IBT_CEP_RDMA_RD | IBT_CEP_RDMA_WR;
1851 qp_attr.rc_flags = IBT_WR_SIGNALED;
1852
1853 rptp->path.pi_sid = ibt_get_ip_sid(IPPROTO_TCP, nfs_rdma_port);
1854 chan_args.oc_path = &rptp->path;
1855
1856 chan_args.oc_cm_handler = rib_clnt_cm_handler;
1857 chan_args.oc_cm_clnt_private = (void *)hca;
1858 chan_args.oc_rdma_ra_out = 4;
1859 chan_args.oc_rdma_ra_in = 4;
1860 chan_args.oc_path_retry_cnt = 2;
1861 chan_args.oc_path_rnr_retry_cnt = RNR_RETRIES;
1862 chan_args.oc_priv_data = cmp_ip_pvt;
1863 chan_args.oc_priv_data_len = IBT_IP_HDR_PRIV_DATA_SZ;
1864
1865 refresh:
1866 rw_enter(&hca->state_lock, RW_READER);
1867 if (hca->state != HCA_DETACHED) {
1868 ibt_status = ibt_alloc_rc_channel(hca->hca_hdl,
1869 IBT_ACHAN_NO_FLAGS,
1870 &qp_attr, &qp->qp_hdl,
1871 &chan_sizes);
1872 } else {
1873 rw_exit(&hca->state_lock);
1874 return (RDMA_FAILED);
1875 }
1876 rw_exit(&hca->state_lock);
1877
1878 if (ibt_status != IBT_SUCCESS) {
1879 DTRACE_PROBE1(rpcib__i_conntosrv,
1880 int, ibt_status);
1881 return (RDMA_FAILED);
1882 }
1883
1884 /* Connect to the Server */
1885 (void) bzero(&ret_args, sizeof (ret_args));
1886 mutex_enter(&qp->cb_lock);
1887 ibt_status = ibt_open_rc_channel(qp->qp_hdl, IBT_OCHAN_NO_FLAGS,
1888 IBT_BLOCKING, &chan_args, &ret_args);
1889 if (ibt_status != IBT_SUCCESS) {
1890 DTRACE_PROBE2(rpcib__i_openrctosrv,
1891 int, ibt_status, int, ret_args.rc_status);
1892
1893 (void) ibt_free_channel(qp->qp_hdl);
1894 qp->qp_hdl = NULL;
1895 mutex_exit(&qp->cb_lock);
1896 if (refresh-- && ibt_status == IBT_CM_FAILURE &&
1897 ret_args.rc_status == IBT_CM_CONN_STALE) {
1898 /*
1899 * Got IBT_CM_CONN_STALE probably because of stale
1900 * data on the passive end of a channel that existed
1901 * prior to reboot. Retry establishing a channel
1902 * REFRESH_ATTEMPTS times, during which time the
1903 * stale conditions on the server might clear up.
1904 */
1905 goto refresh;
1906 }
1907 return (RDMA_FAILED);
1908 }
1909 mutex_exit(&qp->cb_lock);
1910 /*
1911 * Set the private data area to qp to be used in callbacks
1912 */
1913 ibt_set_chan_private(qp->qp_hdl, (void *)qp);
1914 return (RDMA_SUCCESS);
1915 }
1916
1917 rdma_stat
1918 rib_ping_srv(int addr_type, struct netbuf *raddr, rpcib_ping_t *rptp)
1919 {
1920 uint_t i, addr_count;
1921 ibt_status_t ibt_status;
1922 uint8_t num_paths_p;
1923 ibt_ip_path_attr_t ipattr;
1924 ibt_path_ip_src_t srcip;
1925 rpcib_ipaddrs_t addrs4;
1926 rpcib_ipaddrs_t addrs6;
1927 struct sockaddr_in *sinp;
1928 struct sockaddr_in6 *sin6p;
1929 rdma_stat retval = RDMA_FAILED;
1930 rib_hca_t *hca;
1931
1932 if ((addr_type != AF_INET) && (addr_type != AF_INET6))
1933 return (RDMA_INVAL);
1934 ASSERT(raddr->buf != NULL);
1935
1936 bzero(&ipattr, sizeof (ibt_ip_path_attr_t));
1937
1938 if (!rpcib_get_ib_addresses(&addrs4, &addrs6) ||
1939 (addrs4.ri_count == 0 && addrs6.ri_count == 0)) {
1940 retval = RDMA_FAILED;
1941 goto done2;
1942 }
1943
1944 if (addr_type == AF_INET) {
1945 addr_count = addrs4.ri_count;
1946 sinp = (struct sockaddr_in *)raddr->buf;
1947 rptp->dstip.family = AF_INET;
1948 rptp->dstip.un.ip4addr = sinp->sin_addr.s_addr;
1949 sinp = addrs4.ri_list;
1950 } else {
1951 addr_count = addrs6.ri_count;
1952 sin6p = (struct sockaddr_in6 *)raddr->buf;
1953 rptp->dstip.family = AF_INET6;
1954 rptp->dstip.un.ip6addr = sin6p->sin6_addr;
1955 sin6p = addrs6.ri_list;
1956 }
1957
1958 rw_enter(&rib_stat->hcas_list_lock, RW_READER);
1959 for (hca = rib_stat->hcas_list; hca; hca = hca->next) {
1960 rw_enter(&hca->state_lock, RW_READER);
1961 if (hca->state == HCA_DETACHED) {
1962 rw_exit(&hca->state_lock);
1963 continue;
1964 }
1965
1966 ipattr.ipa_dst_ip = &rptp->dstip;
1967 ipattr.ipa_hca_guid = hca->hca_guid;
1968 ipattr.ipa_ndst = 1;
1969 ipattr.ipa_max_paths = 1;
1970 ipattr.ipa_src_ip.family = rptp->dstip.family;
1971 for (i = 0; i < addr_count; i++) {
1972 num_paths_p = 0;
1973 if (addr_type == AF_INET) {
1974 ipattr.ipa_src_ip.un.ip4addr =
1975 sinp[i].sin_addr.s_addr;
1976 } else {
1977 ipattr.ipa_src_ip.un.ip6addr =
1978 sin6p[i].sin6_addr;
1979 }
1980 bzero(&srcip, sizeof (ibt_path_ip_src_t));
1981
1982 ibt_status = ibt_get_ip_paths(rib_stat->ibt_clnt_hdl,
1983 IBT_PATH_NO_FLAGS, &ipattr, &rptp->path,
1984 &num_paths_p, &srcip);
1985 if (ibt_status == IBT_SUCCESS &&
1986 num_paths_p != 0 &&
1987 rptp->path.pi_hca_guid == hca->hca_guid) {
1988 rptp->hca = hca;
1989 rw_exit(&hca->state_lock);
1990 if (addr_type == AF_INET) {
1991 rptp->srcip.family = AF_INET;
1992 rptp->srcip.un.ip4addr =
1993 srcip.ip_primary.un.ip4addr;
1994 } else {
1995 rptp->srcip.family = AF_INET6;
1996 rptp->srcip.un.ip6addr =
1997 srcip.ip_primary.un.ip6addr;
1998
1999 }
2000 retval = RDMA_SUCCESS;
2001 goto done1;
2002 }
2003 }
2004 rw_exit(&hca->state_lock);
2005 }
2006 done1:
2007 rw_exit(&rib_stat->hcas_list_lock);
2008 done2:
2009 if (addrs4.ri_size > 0)
2010 kmem_free(addrs4.ri_list, addrs4.ri_size);
2011 if (addrs6.ri_size > 0)
2012 kmem_free(addrs6.ri_list, addrs6.ri_size);
2013 return (retval);
2014 }
2015
2016 /*
2017 * Close channel, remove from connection list and
2018 * free up resources allocated for that channel.
2019 */
2020 rdma_stat
2021 rib_disconnect_channel(CONN *conn, rib_conn_list_t *conn_list)
2022 {
2023 rib_qp_t *qp = ctoqp(conn);
2024 rib_hca_t *hca;
2025
2026 mutex_enter(&conn->c_lock);
2027 if (conn->c_timeout != NULL) {
2028 mutex_exit(&conn->c_lock);
2029 (void) untimeout(conn->c_timeout);
2030 mutex_enter(&conn->c_lock);
2031 }
2032
2033 while (conn->c_flags & C_CLOSE_PENDING) {
2034 cv_wait(&conn->c_cv, &conn->c_lock);
2035 }
2036 mutex_exit(&conn->c_lock);
2037
2038 /*
2039 * c_ref == 0 and connection is in C_DISCONN_PEND
2040 */
2041 hca = qp->hca;
2042 if (conn_list != NULL)
2043 (void) rib_rm_conn(conn, conn_list);
2044
2045 /*
2046 * There is only one case where we get here with
2047 * qp_hdl = NULL, which is during connection setup on
2048 * the client. In such a case there are no posted
2049 * send/recv buffers.
2050 */
2051 if (qp->qp_hdl != NULL) {
2052 mutex_enter(&qp->posted_rbufs_lock);
2053 while (qp->n_posted_rbufs)
2054 cv_wait(&qp->posted_rbufs_cv, &qp->posted_rbufs_lock);
2055 mutex_exit(&qp->posted_rbufs_lock);
2056
2057 mutex_enter(&qp->send_rbufs_lock);
2058 while (qp->n_send_rbufs)
2059 cv_wait(&qp->send_rbufs_cv, &qp->send_rbufs_lock);
2060 mutex_exit(&qp->send_rbufs_lock);
2061
2062 (void) ibt_free_channel(qp->qp_hdl);
2063 qp->qp_hdl = NULL;
2064 }
2065
2066 ASSERT(qp->rdlist == NULL);
2067
2068 if (qp->replylist != NULL) {
2069 (void) rib_rem_replylist(qp);
2070 }
2071
2072 cv_destroy(&qp->cb_conn_cv);
2073 cv_destroy(&qp->posted_rbufs_cv);
2074 cv_destroy(&qp->send_rbufs_cv);
2075 mutex_destroy(&qp->cb_lock);
2076 mutex_destroy(&qp->replylist_lock);
2077 mutex_destroy(&qp->posted_rbufs_lock);
2078 mutex_destroy(&qp->send_rbufs_lock);
2079 mutex_destroy(&qp->rdlist_lock);
2080
2081 cv_destroy(&conn->c_cv);
2082 mutex_destroy(&conn->c_lock);
2083
2084 if (conn->c_raddr.buf != NULL) {
2085 kmem_free(conn->c_raddr.buf, conn->c_raddr.len);
2086 }
2087 if (conn->c_laddr.buf != NULL) {
2088 kmem_free(conn->c_laddr.buf, conn->c_laddr.len);
2089 }
2090 if (conn->c_netid != NULL) {
2091 kmem_free(conn->c_netid, (strlen(conn->c_netid) + 1));
2092 }
2093 if (conn->c_addrmask.buf != NULL) {
2094 kmem_free(conn->c_addrmask.buf, conn->c_addrmask.len);
2095 }
2096
2097 /*
2098 * Credit control cleanup.
2099 */
2100 if (qp->rdmaconn.c_cc_type == RDMA_CC_CLNT) {
2101 rdma_clnt_cred_ctrl_t *cc_info;
2102 cc_info = &qp->rdmaconn.rdma_conn_cred_ctrl_u.c_clnt_cc;
2103 cv_destroy(&cc_info->clnt_cc_cv);
2104 }
2105
2106 kmem_free(qp, sizeof (rib_qp_t));
2107
2108 /*
2109 * If HCA has been DETACHED and the srv/clnt_conn_list is NULL,
2110 * then the hca is no longer being used.
2111 */
2112 if (conn_list != NULL) {
2113 rw_enter(&hca->state_lock, RW_READER);
2114 if (hca->state == HCA_DETACHED) {
2115 rw_enter(&hca->srv_conn_list.conn_lock, RW_READER);
2116 if (hca->srv_conn_list.conn_hd == NULL) {
2117 rw_enter(&hca->cl_conn_list.conn_lock,
2118 RW_READER);
2119
2120 if (hca->cl_conn_list.conn_hd == NULL) {
2121 mutex_enter(&hca->inuse_lock);
2122 hca->inuse = FALSE;
2123 cv_signal(&hca->cb_cv);
2124 mutex_exit(&hca->inuse_lock);
2125 }
2126 rw_exit(&hca->cl_conn_list.conn_lock);
2127 }
2128 rw_exit(&hca->srv_conn_list.conn_lock);
2129 }
2130 rw_exit(&hca->state_lock);
2131 }
2132
2133 return (RDMA_SUCCESS);
2134 }
2135
2136 /*
2137 * All sends are done under the protection of
2138 * the wdesc->sendwait_lock. n_send_rbufs count
2139 * is protected using the send_rbufs_lock.
2140 * lock ordering is:
2141 * sendwait_lock -> send_rbufs_lock
2142 */
2143
2144 void
2145 rib_send_hold(rib_qp_t *qp)
2146 {
2147 mutex_enter(&qp->send_rbufs_lock);
2148 qp->n_send_rbufs++;
2149 mutex_exit(&qp->send_rbufs_lock);
2150 }
2151
2152 void
2153 rib_send_rele(rib_qp_t *qp)
2154 {
2155 mutex_enter(&qp->send_rbufs_lock);
2156 qp->n_send_rbufs--;
2157 if (qp->n_send_rbufs == 0)
2158 cv_signal(&qp->send_rbufs_cv);
2159 mutex_exit(&qp->send_rbufs_lock);
2160 }
2161
2162 void
2163 rib_recv_rele(rib_qp_t *qp)
2164 {
2165 mutex_enter(&qp->posted_rbufs_lock);
2166 qp->n_posted_rbufs--;
2167 if (qp->n_posted_rbufs == 0)
2168 cv_signal(&qp->posted_rbufs_cv);
2169 mutex_exit(&qp->posted_rbufs_lock);
2170 }
2171
2172 /*
2173 * Wait for send completion notification. Only on receiving a
2174 * notification be it a successful or error completion, free the
2175 * send_wid.
2176 */
2177 static rdma_stat
2178 rib_sendwait(rib_qp_t *qp, struct send_wid *wd)
2179 {
2180 clock_t timout, cv_wait_ret;
2181 rdma_stat error = RDMA_SUCCESS;
2182 int i;
2183
2184 /*
2185 * Wait for send to complete
2186 */
2187 ASSERT(wd != NULL);
2188 mutex_enter(&wd->sendwait_lock);
2189 if (wd->status == (uint_t)SEND_WAIT) {
2190 timout = drv_usectohz(SEND_WAIT_TIME * 1000000) +
2191 ddi_get_lbolt();
2192
2193 if (qp->mode == RIB_SERVER) {
2194 while ((cv_wait_ret = cv_timedwait(&wd->wait_cv,
2195 &wd->sendwait_lock, timout)) > 0 &&
2196 wd->status == (uint_t)SEND_WAIT)
2197 ;
2198 switch (cv_wait_ret) {
2199 case -1: /* timeout */
2200 DTRACE_PROBE(rpcib__i__srvsendwait__timeout);
2201
2202 wd->cv_sig = 0; /* no signal needed */
2203 error = RDMA_TIMEDOUT;
2204 break;
2205 default: /* got send completion */
2206 break;
2207 }
2208 } else {
2209 while ((cv_wait_ret = cv_timedwait_sig(&wd->wait_cv,
2210 &wd->sendwait_lock, timout)) > 0 &&
2211 wd->status == (uint_t)SEND_WAIT)
2212 ;
2213 switch (cv_wait_ret) {
2214 case -1: /* timeout */
2215 DTRACE_PROBE(rpcib__i__clntsendwait__timeout);
2216
2217 wd->cv_sig = 0; /* no signal needed */
2218 error = RDMA_TIMEDOUT;
2219 break;
2220 case 0: /* interrupted */
2221 DTRACE_PROBE(rpcib__i__clntsendwait__intr);
2222
2223 wd->cv_sig = 0; /* no signal needed */
2224 error = RDMA_INTR;
2225 break;
2226 default: /* got send completion */
2227 break;
2228 }
2229 }
2230 }
2231
2232 if (wd->status != (uint_t)SEND_WAIT) {
2233 /* got send completion */
2234 if (wd->status != RDMA_SUCCESS) {
2235 switch (wd->status) {
2236 case RDMA_CONNLOST:
2237 error = RDMA_CONNLOST;
2238 break;
2239 default:
2240 error = RDMA_FAILED;
2241 break;
2242 }
2243 }
2244 for (i = 0; i < wd->nsbufs; i++) {
2245 rib_rbuf_free(qptoc(qp), SEND_BUFFER,
2246 (void *)(uintptr_t)wd->sbufaddr[i]);
2247 }
2248
2249 rib_send_rele(qp);
2250
2251 mutex_exit(&wd->sendwait_lock);
2252 (void) rib_free_sendwait(wd);
2253
2254 } else {
2255 mutex_exit(&wd->sendwait_lock);
2256 }
2257 return (error);
2258 }
2259
2260 static struct send_wid *
2261 rib_init_sendwait(uint32_t xid, int cv_sig, rib_qp_t *qp)
2262 {
2263 struct send_wid *wd;
2264
2265 wd = kmem_zalloc(sizeof (struct send_wid), KM_SLEEP);
2266 wd->xid = xid;
2267 wd->cv_sig = cv_sig;
2268 wd->qp = qp;
2269 cv_init(&wd->wait_cv, NULL, CV_DEFAULT, NULL);
2270 mutex_init(&wd->sendwait_lock, NULL, MUTEX_DRIVER, NULL);
2271 wd->status = (uint_t)SEND_WAIT;
2272
2273 return (wd);
2274 }
2275
2276 static int
2277 rib_free_sendwait(struct send_wid *wdesc)
2278 {
2279 cv_destroy(&wdesc->wait_cv);
2280 mutex_destroy(&wdesc->sendwait_lock);
2281 kmem_free(wdesc, sizeof (*wdesc));
2282
2283 return (0);
2284 }
2285
2286 static rdma_stat
2287 rib_rem_rep(rib_qp_t *qp, struct reply *rep)
2288 {
2289 mutex_enter(&qp->replylist_lock);
2290 if (rep != NULL) {
2291 (void) rib_remreply(qp, rep);
2292 mutex_exit(&qp->replylist_lock);
2293 return (RDMA_SUCCESS);
2294 }
2295 mutex_exit(&qp->replylist_lock);
2296 return (RDMA_FAILED);
2297 }
2298
2299 /*
2300 * Send buffers are freed here only in case of error in posting
2301 * on QP. If the post succeeded, the send buffers are freed upon
2302 * send completion in rib_sendwait() or in the scq_handler.
2303 */
2304 rdma_stat
2305 rib_send_and_wait(CONN *conn, struct clist *cl, uint32_t msgid,
2306 int send_sig, int cv_sig, caddr_t *swid)
2307 {
2308 struct send_wid *wdesc;
2309 struct clist *clp;
2310 ibt_status_t ibt_status = IBT_SUCCESS;
2311 rdma_stat ret = RDMA_SUCCESS;
2312 ibt_send_wr_t tx_wr;
2313 int i, nds;
2314 ibt_wr_ds_t sgl[DSEG_MAX];
2315 uint_t total_msg_size;
2316 rib_qp_t *qp;
2317
2318 qp = ctoqp(conn);
2319
2320 ASSERT(cl != NULL);
2321
2322 bzero(&tx_wr, sizeof (ibt_send_wr_t));
2323
2324 nds = 0;
2325 total_msg_size = 0;
2326 clp = cl;
2327 while (clp != NULL) {
2328 if (nds >= DSEG_MAX) {
2329 DTRACE_PROBE(rpcib__i__sendandwait_dsegmax_exceeded);
2330 return (RDMA_FAILED);
2331 }
2332 sgl[nds].ds_va = clp->w.c_saddr;
2333 sgl[nds].ds_key = clp->c_smemhandle.mrc_lmr; /* lkey */
2334 sgl[nds].ds_len = clp->c_len;
2335 total_msg_size += clp->c_len;
2336 clp = clp->c_next;
2337 nds++;
2338 }
2339
2340 if (send_sig) {
2341 /* Set SEND_SIGNAL flag. */
2342 tx_wr.wr_flags = IBT_WR_SEND_SIGNAL;
2343 wdesc = rib_init_sendwait(msgid, cv_sig, qp);
2344 *swid = (caddr_t)wdesc;
2345 tx_wr.wr_id = (ibt_wrid_t)(uintptr_t)wdesc;
2346 mutex_enter(&wdesc->sendwait_lock);
2347 wdesc->nsbufs = nds;
2348 for (i = 0; i < nds; i++) {
2349 wdesc->sbufaddr[i] = sgl[i].ds_va;
2350 }
2351 } else {
2352 tx_wr.wr_flags = IBT_WR_NO_FLAGS;
2353 *swid = NULL;
2354 tx_wr.wr_id = (ibt_wrid_t)RDMA_DUMMY_WRID;
2355 }
2356
2357 tx_wr.wr_opcode = IBT_WRC_SEND;
2358 tx_wr.wr_trans = IBT_RC_SRV;
2359 tx_wr.wr_nds = nds;
2360 tx_wr.wr_sgl = sgl;
2361
2362 mutex_enter(&conn->c_lock);
2363 if (conn->c_state == C_CONNECTED) {
2364 ibt_status = ibt_post_send(qp->qp_hdl, &tx_wr, 1, NULL);
2365 }
2366 if (conn->c_state != C_CONNECTED ||
2367 ibt_status != IBT_SUCCESS) {
2368 if (conn->c_state != C_DISCONN_PEND)
2369 conn->c_state = C_ERROR_CONN;
2370 mutex_exit(&conn->c_lock);
2371 if (send_sig) {
2372 for (i = 0; i < nds; i++) {
2373 rib_rbuf_free(conn, SEND_BUFFER,
2374 (void *)(uintptr_t)wdesc->sbufaddr[i]);
2375 }
2376 mutex_exit(&wdesc->sendwait_lock);
2377 (void) rib_free_sendwait(wdesc);
2378 }
2379 return (RDMA_CONNLOST);
2380 }
2381
2382 mutex_exit(&conn->c_lock);
2383
2384 if (send_sig) {
2385 rib_send_hold(qp);
2386 mutex_exit(&wdesc->sendwait_lock);
2387 if (cv_sig) {
2388 /*
2389 * cv_wait for send to complete.
2390 * We can fail due to a timeout or signal or
2391 * unsuccessful send.
2392 */
2393 ret = rib_sendwait(qp, wdesc);
2394
2395 return (ret);
2396 }
2397 }
2398
2399 return (RDMA_SUCCESS);
2400 }
2401
2402
2403 rdma_stat
2404 rib_send(CONN *conn, struct clist *cl, uint32_t msgid)
2405 {
2406 rdma_stat ret;
2407 caddr_t wd;
2408
2409 /* send-wait & cv_signal */
2410 ret = rib_send_and_wait(conn, cl, msgid, 1, 1, &wd);
2411 return (ret);
2412 }
2413
2414 /*
2415 * Deprecated/obsolete interface not used currently
2416 * but earlier used for READ-READ protocol.
2417 * Send RPC reply and wait for RDMA_DONE.
2418 */
2419 rdma_stat
2420 rib_send_resp(CONN *conn, struct clist *cl, uint32_t msgid)
2421 {
2422 rdma_stat ret = RDMA_SUCCESS;
2423 struct rdma_done_list *rd;
2424 clock_t cv_wait_ret;
2425 caddr_t *wid = NULL;
2426 rib_qp_t *qp = ctoqp(conn);
2427
2428 mutex_enter(&qp->rdlist_lock);
2429 rd = rdma_done_add(qp, msgid);
2430
2431 /* No cv_signal (whether send-wait or no-send-wait) */
2432 ret = rib_send_and_wait(conn, cl, msgid, 1, 0, wid);
2433
2434 if (ret != RDMA_SUCCESS) {
2435 rdma_done_rm(qp, rd);
2436 } else {
2437 /*
2438 * Wait for RDMA_DONE from remote end
2439 */
2440 cv_wait_ret = cv_reltimedwait(&rd->rdma_done_cv,
2441 &qp->rdlist_lock, drv_usectohz(REPLY_WAIT_TIME * 1000000),
2442 TR_CLOCK_TICK);
2443
2444 rdma_done_rm(qp, rd);
2445
2446 if (cv_wait_ret < 0) {
2447 ret = RDMA_TIMEDOUT;
2448 }
2449 }
2450
2451 mutex_exit(&qp->rdlist_lock);
2452 return (ret);
2453 }
2454
2455 static struct recv_wid *
2456 rib_create_wid(rib_qp_t *qp, ibt_wr_ds_t *sgl, uint32_t msgid)
2457 {
2458 struct recv_wid *rwid;
2459
2460 rwid = kmem_zalloc(sizeof (struct recv_wid), KM_SLEEP);
2461 rwid->xid = msgid;
2462 rwid->addr = sgl->ds_va;
2463 rwid->qp = qp;
2464
2465 return (rwid);
2466 }
2467
2468 static void
2469 rib_free_wid(struct recv_wid *rwid)
2470 {
2471 kmem_free(rwid, sizeof (struct recv_wid));
2472 }
2473
2474 rdma_stat
2475 rib_clnt_post(CONN* conn, struct clist *cl, uint32_t msgid)
2476 {
2477 rib_qp_t *qp = ctoqp(conn);
2478 struct clist *clp = cl;
2479 struct reply *rep;
2480 struct recv_wid *rwid;
2481 int nds;
2482 ibt_wr_ds_t sgl[DSEG_MAX];
2483 ibt_recv_wr_t recv_wr;
2484 rdma_stat ret;
2485 ibt_status_t ibt_status;
2486
2487 /*
2488 * rdma_clnt_postrecv uses RECV_BUFFER.
2489 */
2490
2491 nds = 0;
2492 while (cl != NULL) {
2493 if (nds >= DSEG_MAX) {
2494 ret = RDMA_FAILED;
2495 goto done;
2496 }
2497 sgl[nds].ds_va = cl->w.c_saddr;
2498 sgl[nds].ds_key = cl->c_smemhandle.mrc_lmr; /* lkey */
2499 sgl[nds].ds_len = cl->c_len;
2500 cl = cl->c_next;
2501 nds++;
2502 }
2503
2504 if (nds != 1) {
2505 ret = RDMA_FAILED;
2506 goto done;
2507 }
2508
2509 bzero(&recv_wr, sizeof (ibt_recv_wr_t));
2510 recv_wr.wr_nds = nds;
2511 recv_wr.wr_sgl = sgl;
2512
2513 rwid = rib_create_wid(qp, &sgl[0], msgid);
2514 if (rwid) {
2515 recv_wr.wr_id = (ibt_wrid_t)(uintptr_t)rwid;
2516 } else {
2517 ret = RDMA_NORESOURCE;
2518 goto done;
2519 }
2520 rep = rib_addreplylist(qp, msgid);
2521 if (!rep) {
2522 rib_free_wid(rwid);
2523 ret = RDMA_NORESOURCE;
2524 goto done;
2525 }
2526
2527 mutex_enter(&conn->c_lock);
2528
2529 if (conn->c_state == C_CONNECTED) {
2530 ibt_status = ibt_post_recv(qp->qp_hdl, &recv_wr, 1, NULL);
2531 }
2532
2533 if (conn->c_state != C_CONNECTED ||
2534 ibt_status != IBT_SUCCESS) {
2535 if (conn->c_state != C_DISCONN_PEND)
2536 conn->c_state = C_ERROR_CONN;
2537 mutex_exit(&conn->c_lock);
2538 rib_free_wid(rwid);
2539 (void) rib_rem_rep(qp, rep);
2540 ret = RDMA_CONNLOST;
2541 goto done;
2542 }
2543
2544 mutex_enter(&qp->posted_rbufs_lock);
2545 qp->n_posted_rbufs++;
2546 mutex_exit(&qp->posted_rbufs_lock);
2547
2548 mutex_exit(&conn->c_lock);
2549 return (RDMA_SUCCESS);
2550
2551 done:
2552 while (clp != NULL) {
2553 rib_rbuf_free(conn, RECV_BUFFER,
2554 (void *)(uintptr_t)clp->w.c_saddr3);
2555 clp = clp->c_next;
2556 }
2557 return (ret);
2558 }
2559
2560 rdma_stat
2561 rib_svc_post(CONN* conn, struct clist *cl)
2562 {
2563 rib_qp_t *qp = ctoqp(conn);
2564 struct svc_recv *s_recvp;
2565 int nds;
2566 ibt_wr_ds_t sgl[DSEG_MAX];
2567 ibt_recv_wr_t recv_wr;
2568 ibt_status_t ibt_status;
2569
2570 nds = 0;
2571 while (cl != NULL) {
2572 if (nds >= DSEG_MAX) {
2573 return (RDMA_FAILED);
2574 }
2575 sgl[nds].ds_va = cl->w.c_saddr;
2576 sgl[nds].ds_key = cl->c_smemhandle.mrc_lmr; /* lkey */
2577 sgl[nds].ds_len = cl->c_len;
2578 cl = cl->c_next;
2579 nds++;
2580 }
2581
2582 if (nds != 1) {
2583 rib_rbuf_free(conn, RECV_BUFFER,
2584 (caddr_t)(uintptr_t)sgl[0].ds_va);
2585
2586 return (RDMA_FAILED);
2587 }
2588
2589 bzero(&recv_wr, sizeof (ibt_recv_wr_t));
2590 recv_wr.wr_nds = nds;
2591 recv_wr.wr_sgl = sgl;
2592
2593 s_recvp = rib_init_svc_recv(qp, &sgl[0]);
2594 /* Use s_recvp's addr as wr id */
2595 recv_wr.wr_id = (ibt_wrid_t)(uintptr_t)s_recvp;
2596 mutex_enter(&conn->c_lock);
2597 if (conn->c_state == C_CONNECTED) {
2598 ibt_status = ibt_post_recv(qp->qp_hdl, &recv_wr, 1, NULL);
2599 }
2600 if (conn->c_state != C_CONNECTED ||
2601 ibt_status != IBT_SUCCESS) {
2602 if (conn->c_state != C_DISCONN_PEND)
2603 conn->c_state = C_ERROR_CONN;
2604 mutex_exit(&conn->c_lock);
2605 rib_rbuf_free(conn, RECV_BUFFER,
2606 (caddr_t)(uintptr_t)sgl[0].ds_va);
2607 (void) rib_free_svc_recv(s_recvp);
2608
2609 return (RDMA_CONNLOST);
2610 }
2611 mutex_exit(&conn->c_lock);
2612
2613 return (RDMA_SUCCESS);
2614 }
2615
2616 /* Client */
2617 rdma_stat
2618 rib_post_resp(CONN* conn, struct clist *cl, uint32_t msgid)
2619 {
2620 return (rib_clnt_post(conn, cl, msgid));
2621 }
2622
2623 /* Client */
2624 rdma_stat
2625 rib_post_resp_remove(CONN* conn, uint32_t msgid)
2626 {
2627 rib_qp_t *qp = ctoqp(conn);
2628 struct reply *rep;
2629
2630 mutex_enter(&qp->replylist_lock);
2631 for (rep = qp->replylist; rep != NULL; rep = rep->next) {
2632 if (rep->xid == msgid) {
2633 if (rep->vaddr_cq) {
2634 rib_rbuf_free(conn, RECV_BUFFER,
2635 (caddr_t)(uintptr_t)rep->vaddr_cq);
2636 }
2637 (void) rib_remreply(qp, rep);
2638 break;
2639 }
2640 }
2641 mutex_exit(&qp->replylist_lock);
2642
2643 return (RDMA_SUCCESS);
2644 }
2645
2646 /* Server */
2647 rdma_stat
2648 rib_post_recv(CONN *conn, struct clist *cl)
2649 {
2650 rib_qp_t *qp = ctoqp(conn);
2651
2652 if (rib_svc_post(conn, cl) == RDMA_SUCCESS) {
2653 mutex_enter(&qp->posted_rbufs_lock);
2654 qp->n_posted_rbufs++;
2655 mutex_exit(&qp->posted_rbufs_lock);
2656 return (RDMA_SUCCESS);
2657 }
2658 return (RDMA_FAILED);
2659 }
2660
2661 /*
2662 * Client side only interface to "recv" the rpc reply buf
2663 * posted earlier by rib_post_resp(conn, cl, msgid).
2664 */
2665 rdma_stat
2666 rib_recv(CONN *conn, struct clist **clp, uint32_t msgid)
2667 {
2668 struct reply *rep = NULL;
2669 clock_t timout, cv_wait_ret;
2670 rdma_stat ret = RDMA_SUCCESS;
2671 rib_qp_t *qp = ctoqp(conn);
2672
2673 /*
2674 * Find the reply structure for this msgid
2675 */
2676 mutex_enter(&qp->replylist_lock);
2677
2678 for (rep = qp->replylist; rep != NULL; rep = rep->next) {
2679 if (rep->xid == msgid)
2680 break;
2681 }
2682
2683 if (rep != NULL) {
2684 /*
2685 * If message not yet received, wait.
2686 */
2687 if (rep->status == (uint_t)REPLY_WAIT) {
2688 timout = ddi_get_lbolt() +
2689 drv_usectohz(REPLY_WAIT_TIME * 1000000);
2690
2691 while ((cv_wait_ret = cv_timedwait_sig(&rep->wait_cv,
2692 &qp->replylist_lock, timout)) > 0 &&
2693 rep->status == (uint_t)REPLY_WAIT)
2694 ;
2695
2696 switch (cv_wait_ret) {
2697 case -1: /* timeout */
2698 ret = RDMA_TIMEDOUT;
2699 break;
2700 case 0:
2701 ret = RDMA_INTR;
2702 break;
2703 default:
2704 break;
2705 }
2706 }
2707
2708 if (rep->status == RDMA_SUCCESS) {
2709 struct clist *cl = NULL;
2710
2711 /*
2712 * Got message successfully
2713 */
2714 clist_add(&cl, 0, rep->bytes_xfer, NULL,
2715 (caddr_t)(uintptr_t)rep->vaddr_cq, NULL, NULL);
2716 *clp = cl;
2717 } else {
2718 if (rep->status != (uint_t)REPLY_WAIT) {
2719 /*
2720 * Got error in reply message. Free
2721 * recv buffer here.
2722 */
2723 ret = rep->status;
2724 rib_rbuf_free(conn, RECV_BUFFER,
2725 (caddr_t)(uintptr_t)rep->vaddr_cq);
2726 }
2727 }
2728 (void) rib_remreply(qp, rep);
2729 } else {
2730 /*
2731 * No matching reply structure found for given msgid on the
2732 * reply wait list.
2733 */
2734 ret = RDMA_INVAL;
2735 DTRACE_PROBE(rpcib__i__nomatchxid2);
2736 }
2737
2738 /*
2739 * Done.
2740 */
2741 mutex_exit(&qp->replylist_lock);
2742 return (ret);
2743 }
2744
2745 /*
2746 * RDMA write a buffer to the remote address.
2747 */
2748 rdma_stat
2749 rib_write(CONN *conn, struct clist *cl, int wait)
2750 {
2751 ibt_send_wr_t tx_wr;
2752 int cv_sig;
2753 ibt_wr_ds_t sgl[DSEG_MAX];
2754 struct send_wid *wdesc;
2755 ibt_status_t ibt_status;
2756 rdma_stat ret = RDMA_SUCCESS;
2757 rib_qp_t *qp = ctoqp(conn);
2758 uint64_t n_writes = 0;
2759
2760 if (cl == NULL) {
2761 return (RDMA_FAILED);
2762 }
2763
2764 while ((cl != NULL)) {
2765 if (cl->c_len > 0) {
2766 bzero(&tx_wr, sizeof (ibt_send_wr_t));
2767 tx_wr.wr.rc.rcwr.rdma.rdma_raddr = cl->u.c_daddr;
2768 tx_wr.wr.rc.rcwr.rdma.rdma_rkey =
2769 cl->c_dmemhandle.mrc_rmr; /* rkey */
2770 sgl[0].ds_va = cl->w.c_saddr;
2771 sgl[0].ds_key = cl->c_smemhandle.mrc_lmr; /* lkey */
2772 sgl[0].ds_len = cl->c_len;
2773
2774 if (wait) {
2775 cv_sig = 1;
2776 } else {
2777 if (n_writes > max_unsignaled_rws) {
2778 n_writes = 0;
2779 cv_sig = 1;
2780 } else {
2781 cv_sig = 0;
2782 }
2783 }
2784
2785 if (cv_sig) {
2786 tx_wr.wr_flags = IBT_WR_SEND_SIGNAL;
2787 wdesc = rib_init_sendwait(0, cv_sig, qp);
2788 tx_wr.wr_id = (ibt_wrid_t)(uintptr_t)wdesc;
2789 mutex_enter(&wdesc->sendwait_lock);
2790 } else {
2791 tx_wr.wr_flags = IBT_WR_NO_FLAGS;
2792 tx_wr.wr_id = (ibt_wrid_t)RDMA_DUMMY_WRID;
2793 }
2794 tx_wr.wr_opcode = IBT_WRC_RDMAW;
2795 tx_wr.wr_trans = IBT_RC_SRV;
2796 tx_wr.wr_nds = 1;
2797 tx_wr.wr_sgl = sgl;
2798
2799 mutex_enter(&conn->c_lock);
2800 if (conn->c_state == C_CONNECTED) {
2801 ibt_status =
2802 ibt_post_send(qp->qp_hdl, &tx_wr, 1, NULL);
2803 }
2804 if (conn->c_state != C_CONNECTED ||
2805 ibt_status != IBT_SUCCESS) {
2806 if (conn->c_state != C_DISCONN_PEND)
2807 conn->c_state = C_ERROR_CONN;
2808 mutex_exit(&conn->c_lock);
2809 if (cv_sig) {
2810 mutex_exit(&wdesc->sendwait_lock);
2811 (void) rib_free_sendwait(wdesc);
2812 }
2813 return (RDMA_CONNLOST);
2814 }
2815
2816 mutex_exit(&conn->c_lock);
2817
2818 /*
2819 * Wait for send to complete
2820 */
2821 if (cv_sig) {
2822
2823 rib_send_hold(qp);
2824 mutex_exit(&wdesc->sendwait_lock);
2825
2826 ret = rib_sendwait(qp, wdesc);
2827 if (ret != 0)
2828 return (ret);
2829 }
2830 n_writes ++;
2831 }
2832 cl = cl->c_next;
2833 }
2834 return (RDMA_SUCCESS);
2835 }
2836
2837 /*
2838 * RDMA Read a buffer from the remote address.
2839 */
2840 rdma_stat
2841 rib_read(CONN *conn, struct clist *cl, int wait)
2842 {
2843 ibt_send_wr_t rx_wr;
2844 int cv_sig = 0;
2845 ibt_wr_ds_t sgl;
2846 struct send_wid *wdesc;
2847 ibt_status_t ibt_status = IBT_SUCCESS;
2848 rdma_stat ret = RDMA_SUCCESS;
2849 rib_qp_t *qp = ctoqp(conn);
2850
2851 if (cl == NULL) {
2852 return (RDMA_FAILED);
2853 }
2854
2855 while (cl != NULL) {
2856 bzero(&rx_wr, sizeof (ibt_send_wr_t));
2857 /*
2858 * Remote address is at the head chunk item in list.
2859 */
2860 rx_wr.wr.rc.rcwr.rdma.rdma_raddr = cl->w.c_saddr;
2861 rx_wr.wr.rc.rcwr.rdma.rdma_rkey = cl->c_smemhandle.mrc_rmr;
2862
2863 sgl.ds_va = cl->u.c_daddr;
2864 sgl.ds_key = cl->c_dmemhandle.mrc_lmr; /* lkey */
2865 sgl.ds_len = cl->c_len;
2866
2867 /*
2868 * If there are multiple chunks to be read, and
2869 * wait is set, ask for signal only for the last chunk
2870 * and wait only on the last chunk. The completion of
2871 * RDMA_READ on last chunk ensures that reads on all
2872 * previous chunks are also completed.
2873 */
2874 if (wait && (cl->c_next == NULL)) {
2875 cv_sig = 1;
2876 wdesc = rib_init_sendwait(0, cv_sig, qp);
2877 rx_wr.wr_flags = IBT_WR_SEND_SIGNAL;
2878 rx_wr.wr_id = (ibt_wrid_t)(uintptr_t)wdesc;
2879 mutex_enter(&wdesc->sendwait_lock);
2880 } else {
2881 rx_wr.wr_flags = IBT_WR_NO_FLAGS;
2882 rx_wr.wr_id = (ibt_wrid_t)RDMA_DUMMY_WRID;
2883 }
2884 rx_wr.wr_opcode = IBT_WRC_RDMAR;
2885 rx_wr.wr_trans = IBT_RC_SRV;
2886 rx_wr.wr_nds = 1;
2887 rx_wr.wr_sgl = &sgl;
2888
2889 mutex_enter(&conn->c_lock);
2890 if (conn->c_state == C_CONNECTED) {
2891 ibt_status = ibt_post_send(qp->qp_hdl, &rx_wr, 1, NULL);
2892 }
2893 if (conn->c_state != C_CONNECTED ||
2894 ibt_status != IBT_SUCCESS) {
2895 if (conn->c_state != C_DISCONN_PEND)
2896 conn->c_state = C_ERROR_CONN;
2897 mutex_exit(&conn->c_lock);
2898 if (wait && (cl->c_next == NULL)) {
2899 mutex_exit(&wdesc->sendwait_lock);
2900 (void) rib_free_sendwait(wdesc);
2901 }
2902 return (RDMA_CONNLOST);
2903 }
2904
2905 mutex_exit(&conn->c_lock);
2906
2907 /*
2908 * Wait for send to complete if this is the
2909 * last item in the list.
2910 */
2911 if (wait && cl->c_next == NULL) {
2912 rib_send_hold(qp);
2913 mutex_exit(&wdesc->sendwait_lock);
2914
2915 ret = rib_sendwait(qp, wdesc);
2916
2917 if (ret != 0)
2918 return (ret);
2919 }
2920 cl = cl->c_next;
2921 }
2922 return (RDMA_SUCCESS);
2923 }
2924
2925 /*
2926 * rib_srv_cm_handler()
2927 * Connection Manager callback to handle RC connection requests.
2928 */
2929 /* ARGSUSED */
2930 static ibt_cm_status_t
2931 rib_srv_cm_handler(void *any, ibt_cm_event_t *event,
2932 ibt_cm_return_args_t *ret_args, void *priv_data,
2933 ibt_priv_data_len_t len)
2934 {
2935 queue_t *q;
2936 rib_qp_t *qp;
2937 rib_hca_t *hca;
2938 rdma_stat status = RDMA_SUCCESS;
2939 int i;
2940 struct clist cl;
2941 rdma_buf_t rdbuf = {0};
2942 void *buf = NULL;
2943 CONN *conn;
2944 ibt_ip_cm_info_t ipinfo;
2945 struct sockaddr_in *s;
2946 struct sockaddr_in6 *s6;
2947 int sin_size = sizeof (struct sockaddr_in);
2948 int in_size = sizeof (struct in_addr);
2949 int sin6_size = sizeof (struct sockaddr_in6);
2950
2951 ASSERT(any != NULL);
2952 ASSERT(event != NULL);
2953
2954 hca = (rib_hca_t *)any;
2955
2956 /* got a connection request */
2957 switch (event->cm_type) {
2958 case IBT_CM_EVENT_REQ_RCV:
2959 /*
2960 * If the plugin is in the NO_ACCEPT state, bail out.
2961 */
2962 mutex_enter(&plugin_state_lock);
2963 if (plugin_state == NO_ACCEPT) {
2964 mutex_exit(&plugin_state_lock);
2965 return (IBT_CM_REJECT);
2966 }
2967 mutex_exit(&plugin_state_lock);
2968
2969 /*
2970 * Need to send a MRA MAD to CM so that it does not
2971 * timeout on us.
2972 */
2973 (void) ibt_cm_delay(IBT_CM_DELAY_REQ, event->cm_session_id,
2974 event->cm_event.req.req_timeout * 8, NULL, 0);
2975
2976 mutex_enter(&rib_stat->open_hca_lock);
2977 q = rib_stat->q;
2978 mutex_exit(&rib_stat->open_hca_lock);
2979
2980 status = rib_svc_create_chan(hca, (caddr_t)q,
2981 event->cm_event.req.req_prim_hca_port, &qp);
2982
2983 if (status) {
2984 return (IBT_CM_REJECT);
2985 }
2986
2987 ret_args->cm_ret.rep.cm_channel = qp->qp_hdl;
2988 ret_args->cm_ret.rep.cm_rdma_ra_out = 4;
2989 ret_args->cm_ret.rep.cm_rdma_ra_in = 4;
2990 ret_args->cm_ret.rep.cm_rnr_retry_cnt = RNR_RETRIES;
2991
2992 /*
2993 * Pre-posts RECV buffers
2994 */
2995 conn = qptoc(qp);
2996 for (i = 0; i < preposted_rbufs; i++) {
2997 bzero(&rdbuf, sizeof (rdbuf));
2998 rdbuf.type = RECV_BUFFER;
2999 buf = rib_rbuf_alloc(conn, &rdbuf);
3000 if (buf == NULL) {
3001 /*
3002 * A connection is not established yet.
3003 * Just flush the channel. Buffers
3004 * posted till now will error out with
3005 * IBT_WC_WR_FLUSHED_ERR.
3006 */
3007 (void) ibt_flush_channel(qp->qp_hdl);
3008 (void) rib_disconnect_channel(conn, NULL);
3009 return (IBT_CM_REJECT);
3010 }
3011
3012 bzero(&cl, sizeof (cl));
3013 cl.w.c_saddr3 = (caddr_t)rdbuf.addr;
3014 cl.c_len = rdbuf.len;
3015 cl.c_smemhandle.mrc_lmr =
3016 rdbuf.handle.mrc_lmr; /* lkey */
3017 cl.c_next = NULL;
3018 status = rib_post_recv(conn, &cl);
3019 if (status != RDMA_SUCCESS) {
3020 /*
3021 * A connection is not established yet.
3022 * Just flush the channel. Buffers
3023 * posted till now will error out with
3024 * IBT_WC_WR_FLUSHED_ERR.
3025 */
3026 (void) ibt_flush_channel(qp->qp_hdl);
3027 (void) rib_disconnect_channel(conn, NULL);
3028 return (IBT_CM_REJECT);
3029 }
3030 }
3031 (void) rib_add_connlist(conn, &hca->srv_conn_list);
3032
3033 /*
3034 * Get the address translation
3035 */
3036 rw_enter(&hca->state_lock, RW_READER);
3037 if (hca->state == HCA_DETACHED) {
3038 rw_exit(&hca->state_lock);
3039 return (IBT_CM_REJECT);
3040 }
3041 rw_exit(&hca->state_lock);
3042
3043 bzero(&ipinfo, sizeof (ibt_ip_cm_info_t));
3044
3045 if (ibt_get_ip_data(event->cm_priv_data_len,
3046 event->cm_priv_data,
3047 &ipinfo) != IBT_SUCCESS) {
3048
3049 return (IBT_CM_REJECT);
3050 }
3051
3052 switch (ipinfo.src_addr.family) {
3053 case AF_INET:
3054
3055 conn->c_netid = kmem_zalloc(strlen(RIBNETID_TCP) + 1,
3056 KM_SLEEP);
3057 (void) strcpy(conn->c_netid, RIBNETID_TCP);
3058
3059 conn->c_raddr.maxlen =
3060 conn->c_raddr.len = sin_size;
3061 conn->c_raddr.buf = kmem_zalloc(sin_size, KM_SLEEP);
3062
3063 s = (struct sockaddr_in *)conn->c_raddr.buf;
3064 s->sin_family = AF_INET;
3065 bcopy((void *)&ipinfo.src_addr.un.ip4addr,
3066 &s->sin_addr, in_size);
3067
3068 conn->c_laddr.maxlen =
3069 conn->c_laddr.len = sin_size;
3070 conn->c_laddr.buf = kmem_zalloc(sin_size, KM_SLEEP);
3071
3072 s = (struct sockaddr_in *)conn->c_laddr.buf;
3073 s->sin_family = AF_INET;
3074 bcopy((void *)&ipinfo.dst_addr.un.ip4addr,
3075 &s->sin_addr, in_size);
3076
3077 conn->c_addrmask.maxlen = conn->c_addrmask.len =
3078 sizeof (struct sockaddr_in);
3079 conn->c_addrmask.buf =
3080 kmem_zalloc(conn->c_addrmask.len, KM_SLEEP);
3081 ((struct sockaddr_in *)
3082 conn->c_addrmask.buf)->sin_addr.s_addr =
3083 (uint32_t)~0;
3084 ((struct sockaddr_in *)
3085 conn->c_addrmask.buf)->sin_family =
3086 (sa_family_t)~0;
3087 break;
3088
3089 case AF_INET6:
3090
3091 conn->c_netid = kmem_zalloc(strlen(RIBNETID_TCP6) + 1,
3092 KM_SLEEP);
3093 (void) strcpy(conn->c_netid, RIBNETID_TCP6);
3094
3095 conn->c_raddr.maxlen =
3096 conn->c_raddr.len = sin6_size;
3097 conn->c_raddr.buf = kmem_zalloc(sin6_size, KM_SLEEP);
3098
3099 s6 = (struct sockaddr_in6 *)conn->c_raddr.buf;
3100 s6->sin6_family = AF_INET6;
3101 bcopy((void *)&ipinfo.src_addr.un.ip6addr,
3102 &s6->sin6_addr,
3103 sizeof (struct in6_addr));
3104
3105 conn->c_laddr.maxlen =
3106 conn->c_laddr.len = sin6_size;
3107 conn->c_laddr.buf = kmem_zalloc(sin6_size, KM_SLEEP);
3108
3109 s6 = (struct sockaddr_in6 *)conn->c_laddr.buf;
3110 s6->sin6_family = AF_INET6;
3111 bcopy((void *)&ipinfo.dst_addr.un.ip6addr,
3112 &s6->sin6_addr,
3113 sizeof (struct in6_addr));
3114
3115 conn->c_addrmask.maxlen = conn->c_addrmask.len =
3116 sizeof (struct sockaddr_in6);
3117 conn->c_addrmask.buf =
3118 kmem_zalloc(conn->c_addrmask.len, KM_SLEEP);
3119 (void) memset(&((struct sockaddr_in6 *)
3120 conn->c_addrmask.buf)->sin6_addr, (uchar_t)~0,
3121 sizeof (struct in6_addr));
3122 ((struct sockaddr_in6 *)
3123 conn->c_addrmask.buf)->sin6_family =
3124 (sa_family_t)~0;
3125 break;
3126
3127 default:
3128 return (IBT_CM_REJECT);
3129 }
3130
3131 break;
3132
3133 case IBT_CM_EVENT_CONN_CLOSED:
3134 {
3135 CONN *conn;
3136 rib_qp_t *qp;
3137
3138 switch (event->cm_event.closed) {
3139 case IBT_CM_CLOSED_DREP_RCVD:
3140 case IBT_CM_CLOSED_DREQ_TIMEOUT:
3141 case IBT_CM_CLOSED_DUP:
3142 case IBT_CM_CLOSED_ABORT:
3143 case IBT_CM_CLOSED_ALREADY:
3144 /*
3145 * These cases indicate the local end initiated
3146 * the closing of the channel. Nothing to do here.
3147 */
3148 break;
3149 default:
3150 /*
3151 * Reason for CONN_CLOSED event must be one of
3152 * IBT_CM_CLOSED_DREQ_RCVD or IBT_CM_CLOSED_REJ_RCVD
3153 * or IBT_CM_CLOSED_STALE. These indicate cases were
3154 * the remote end is closing the channel. In these
3155 * cases free the channel and transition to error
3156 * state
3157 */
3158 qp = ibt_get_chan_private(event->cm_channel);
3159 conn = qptoc(qp);
3160 mutex_enter(&conn->c_lock);
3161 if (conn->c_state == C_DISCONN_PEND) {
3162 mutex_exit(&conn->c_lock);
3163 break;
3164 }
3165 conn->c_state = C_ERROR_CONN;
3166
3167 /*
3168 * Free the conn if c_ref goes down to 0
3169 */
3170 if (conn->c_ref == 0) {
3171 /*
3172 * Remove from list and free conn
3173 */
3174 conn->c_state = C_DISCONN_PEND;
3175 mutex_exit(&conn->c_lock);
3176 (void) rib_disconnect_channel(conn,
3177 &hca->srv_conn_list);
3178 } else {
3179 /*
3180 * conn will be freed when c_ref goes to 0.
3181 * Indicate to cleaning thread not to close
3182 * the connection, but just free the channel.
3183 */
3184 conn->c_flags |= C_CLOSE_NOTNEEDED;
3185 mutex_exit(&conn->c_lock);
3186 }
3187 DTRACE_PROBE(rpcib__i__srvcm_chandisconnect);
3188 break;
3189 }
3190 break;
3191 }
3192 case IBT_CM_EVENT_CONN_EST:
3193 /*
3194 * RTU received, hence connection established.
3195 */
3196 if (rib_debug > 1)
3197 cmn_err(CE_NOTE, "rib_srv_cm_handler: "
3198 "(CONN_EST) channel established");
3199 break;
3200
3201 default:
3202 if (rib_debug > 2) {
3203 /* Let CM handle the following events. */
3204 if (event->cm_type == IBT_CM_EVENT_REP_RCV) {
3205 cmn_err(CE_NOTE, "rib_srv_cm_handler: "
3206 "server recv'ed IBT_CM_EVENT_REP_RCV\n");
3207 } else if (event->cm_type == IBT_CM_EVENT_LAP_RCV) {
3208 cmn_err(CE_NOTE, "rib_srv_cm_handler: "
3209 "server recv'ed IBT_CM_EVENT_LAP_RCV\n");
3210 } else if (event->cm_type == IBT_CM_EVENT_MRA_RCV) {
3211 cmn_err(CE_NOTE, "rib_srv_cm_handler: "
3212 "server recv'ed IBT_CM_EVENT_MRA_RCV\n");
3213 } else if (event->cm_type == IBT_CM_EVENT_APR_RCV) {
3214 cmn_err(CE_NOTE, "rib_srv_cm_handler: "
3215 "server recv'ed IBT_CM_EVENT_APR_RCV\n");
3216 } else if (event->cm_type == IBT_CM_EVENT_FAILURE) {
3217 cmn_err(CE_NOTE, "rib_srv_cm_handler: "
3218 "server recv'ed IBT_CM_EVENT_FAILURE\n");
3219 }
3220 }
3221 return (IBT_CM_DEFAULT);
3222 }
3223
3224 /* accept all other CM messages (i.e. let the CM handle them) */
3225 return (IBT_CM_ACCEPT);
3226 }
3227
3228 static rdma_stat
3229 rib_register_service(rib_hca_t *hca, int service_type,
3230 uint8_t protocol_num, in_port_t dst_port)
3231 {
3232 ibt_srv_desc_t sdesc;
3233 ibt_hca_portinfo_t *port_infop;
3234 ib_svc_id_t srv_id;
3235 ibt_srv_hdl_t srv_hdl;
3236 uint_t port_size;
3237 uint_t pki, i, num_ports, nbinds;
3238 ibt_status_t ibt_status;
3239 rib_service_t *service;
3240 ib_pkey_t pkey;
3241
3242 /*
3243 * Query all ports for the given HCA
3244 */
3245 rw_enter(&hca->state_lock, RW_READER);
3246 if (hca->state != HCA_DETACHED) {
3247 ibt_status = ibt_query_hca_ports(hca->hca_hdl, 0, &port_infop,
3248 &num_ports, &port_size);
3249 rw_exit(&hca->state_lock);
3250 } else {
3251 rw_exit(&hca->state_lock);
3252 return (RDMA_FAILED);
3253 }
3254 if (ibt_status != IBT_SUCCESS) {
3255 return (RDMA_FAILED);
3256 }
3257
3258 DTRACE_PROBE1(rpcib__i__regservice_numports,
3259 int, num_ports);
3260
3261 for (i = 0; i < num_ports; i++) {
3262 if (port_infop[i].p_linkstate != IBT_PORT_ACTIVE) {
3263 DTRACE_PROBE1(rpcib__i__regservice__portinactive,
3264 int, i+1);
3265 } else if (port_infop[i].p_linkstate == IBT_PORT_ACTIVE) {
3266 DTRACE_PROBE1(rpcib__i__regservice__portactive,
3267 int, i+1);
3268 }
3269 }
3270
3271 /*
3272 * Get all the IP addresses on this system to register the
3273 * given "service type" on all DNS recognized IP addrs.
3274 * Each service type such as NFS will have all the systems
3275 * IP addresses as its different names. For now the only
3276 * type of service we support in RPCIB is NFS.
3277 */
3278 rw_enter(&rib_stat->service_list_lock, RW_WRITER);
3279 /*
3280 * Start registering and binding service to active
3281 * on active ports on this HCA.
3282 */
3283 nbinds = 0;
3284 for (service = rib_stat->service_list;
3285 service && (service->srv_type != service_type);
3286 service = service->next)
3287 ;
3288
3289 if (service == NULL) {
3290 /*
3291 * We use IP addresses as the service names for
3292 * service registration. Register each of them
3293 * with CM to obtain a svc_id and svc_hdl. We do not
3294 * register the service with machine's loopback address.
3295 */
3296 (void) bzero(&srv_id, sizeof (ib_svc_id_t));
3297 (void) bzero(&srv_hdl, sizeof (ibt_srv_hdl_t));
3298 (void) bzero(&sdesc, sizeof (ibt_srv_desc_t));
3299 sdesc.sd_handler = rib_srv_cm_handler;
3300 sdesc.sd_flags = 0;
3301 ibt_status = ibt_register_service(hca->ibt_clnt_hdl,
3302 &sdesc, ibt_get_ip_sid(protocol_num, dst_port),
3303 1, &srv_hdl, &srv_id);
3304 if ((ibt_status != IBT_SUCCESS) &&
3305 (ibt_status != IBT_CM_SERVICE_EXISTS)) {
3306 rw_exit(&rib_stat->service_list_lock);
3307 DTRACE_PROBE1(rpcib__i__regservice__ibtres,
3308 int, ibt_status);
3309 ibt_free_portinfo(port_infop, port_size);
3310 return (RDMA_FAILED);
3311 }
3312
3313 /*
3314 * Allocate and prepare a service entry
3315 */
3316 service = kmem_zalloc(sizeof (rib_service_t), KM_SLEEP);
3317
3318 service->srv_type = service_type;
3319 service->srv_hdl = srv_hdl;
3320 service->srv_id = srv_id;
3321
3322 service->next = rib_stat->service_list;
3323 rib_stat->service_list = service;
3324 DTRACE_PROBE1(rpcib__i__regservice__new__service,
3325 int, service->srv_type);
3326 } else {
3327 srv_hdl = service->srv_hdl;
3328 srv_id = service->srv_id;
3329 DTRACE_PROBE1(rpcib__i__regservice__existing__service,
3330 int, service->srv_type);
3331 }
3332
3333 for (i = 0; i < num_ports; i++) {
3334 ibt_sbind_hdl_t sbp;
3335 rib_hca_service_t *hca_srv;
3336 ib_gid_t gid;
3337
3338 if (port_infop[i].p_linkstate != IBT_PORT_ACTIVE)
3339 continue;
3340
3341 for (pki = 0; pki < port_infop[i].p_pkey_tbl_sz; pki++) {
3342 pkey = port_infop[i].p_pkey_tbl[pki];
3343
3344 rw_enter(&hca->bound_services_lock, RW_READER);
3345 gid = port_infop[i].p_sgid_tbl[0];
3346 for (hca_srv = hca->bound_services; hca_srv;
3347 hca_srv = hca_srv->next) {
3348 if ((hca_srv->srv_id == service->srv_id) &&
3349 (hca_srv->gid.gid_prefix ==
3350 gid.gid_prefix) &&
3351 (hca_srv->gid.gid_guid == gid.gid_guid))
3352 break;
3353 }
3354 rw_exit(&hca->bound_services_lock);
3355 if (hca_srv != NULL) {
3356 /*
3357 * port is alreay bound the the service
3358 */
3359 DTRACE_PROBE1(
3360 rpcib__i__regservice__already__bound,
3361 int, i+1);
3362 nbinds++;
3363 continue;
3364 }
3365
3366 if ((pkey & IBSRM_HB) &&
3367 (pkey != IB_PKEY_INVALID_FULL)) {
3368
3369 sbp = NULL;
3370 ibt_status = ibt_bind_service(srv_hdl,
3371 gid, NULL, hca, &sbp);
3372
3373 if (ibt_status == IBT_SUCCESS) {
3374 hca_srv = kmem_zalloc(
3375 sizeof (rib_hca_service_t),
3376 KM_SLEEP);
3377 hca_srv->srv_id = srv_id;
3378 hca_srv->gid = gid;
3379 hca_srv->sbind_hdl = sbp;
3380
3381 rw_enter(&hca->bound_services_lock,
3382 RW_WRITER);
3383 hca_srv->next = hca->bound_services;
3384 hca->bound_services = hca_srv;
3385 rw_exit(&hca->bound_services_lock);
3386 nbinds++;
3387 }
3388
3389 DTRACE_PROBE1(rpcib__i__regservice__bindres,
3390 int, ibt_status);
3391 }
3392 }
3393 }
3394 rw_exit(&rib_stat->service_list_lock);
3395
3396 ibt_free_portinfo(port_infop, port_size);
3397
3398 if (nbinds == 0) {
3399 return (RDMA_FAILED);
3400 } else {
3401 /*
3402 * Put this plugin into accept state, since atleast
3403 * one registration was successful.
3404 */
3405 mutex_enter(&plugin_state_lock);
3406 plugin_state = ACCEPT;
3407 mutex_exit(&plugin_state_lock);
3408 return (RDMA_SUCCESS);
3409 }
3410 }
3411
3412 void
3413 rib_listen(struct rdma_svc_data *rd)
3414 {
3415 rdma_stat status;
3416 int n_listening = 0;
3417 rib_hca_t *hca;
3418
3419 mutex_enter(&rib_stat->listen_lock);
3420 /*
3421 * if rd parameter is NULL then it means that rib_stat->q is
3422 * already initialized by a call from RDMA and we just want to
3423 * add a newly attached HCA to the same listening state as other
3424 * HCAs.
3425 */
3426 if (rd == NULL) {
3427 if (rib_stat->q == NULL) {
3428 mutex_exit(&rib_stat->listen_lock);
3429 return;
3430 }
3431 } else {
3432 rib_stat->q = &rd->q;
3433 }
3434 rw_enter(&rib_stat->hcas_list_lock, RW_READER);
3435 for (hca = rib_stat->hcas_list; hca; hca = hca->next) {
3436 /*
3437 * First check if a hca is still attached
3438 */
3439 rw_enter(&hca->state_lock, RW_READER);
3440 if (hca->state != HCA_INITED) {
3441 rw_exit(&hca->state_lock);
3442 continue;
3443 }
3444 rw_exit(&hca->state_lock);
3445
3446 /*
3447 * Right now the only service type is NFS. Hence
3448 * force feed this value. Ideally to communicate
3449 * the service type it should be passed down in
3450 * rdma_svc_data.
3451 */
3452 status = rib_register_service(hca, NFS,
3453 IPPROTO_TCP, nfs_rdma_port);
3454 if (status == RDMA_SUCCESS)
3455 n_listening++;
3456 }
3457 rw_exit(&rib_stat->hcas_list_lock);
3458
3459 /*
3460 * Service active on an HCA, check rd->err_code for more
3461 * explainable errors.
3462 */
3463 if (rd) {
3464 if (n_listening > 0) {
3465 rd->active = 1;
3466 rd->err_code = RDMA_SUCCESS;
3467 } else {
3468 rd->active = 0;
3469 rd->err_code = RDMA_FAILED;
3470 }
3471 }
3472 mutex_exit(&rib_stat->listen_lock);
3473 }
3474
3475 /* XXXX */
3476 /* ARGSUSED */
3477 static void
3478 rib_listen_stop(struct rdma_svc_data *svcdata)
3479 {
3480 rib_hca_t *hca;
3481
3482 mutex_enter(&rib_stat->listen_lock);
3483 /*
3484 * KRPC called the RDMATF to stop the listeners, this means
3485 * stop sending incomming or recieved requests to KRPC master
3486 * transport handle for RDMA-IB. This is also means that the
3487 * master transport handle, responsible for us, is going away.
3488 */
3489 mutex_enter(&plugin_state_lock);
3490 plugin_state = NO_ACCEPT;
3491 if (svcdata != NULL)
3492 svcdata->active = 0;
3493 mutex_exit(&plugin_state_lock);
3494
3495 rw_enter(&rib_stat->hcas_list_lock, RW_READER);
3496 for (hca = rib_stat->hcas_list; hca; hca = hca->next) {
3497 /*
3498 * First check if a hca is still attached
3499 */
3500 rw_enter(&hca->state_lock, RW_READER);
3501 if (hca->state == HCA_DETACHED) {
3502 rw_exit(&hca->state_lock);
3503 continue;
3504 }
3505 rib_close_channels(&hca->srv_conn_list);
3506 rib_stop_services(hca);
3507 rw_exit(&hca->state_lock);
3508 }
3509 rw_exit(&rib_stat->hcas_list_lock);
3510
3511 /*
3512 * Avoid rib_listen() using the stale q field.
3513 * This could happen if a port goes up after all services
3514 * are already unregistered.
3515 */
3516 rib_stat->q = NULL;
3517 mutex_exit(&rib_stat->listen_lock);
3518 }
3519
3520 /*
3521 * Traverse the HCA's service list to unbind and deregister services.
3522 * For each bound service of HCA to be removed, first find the corresponding
3523 * service handle (srv_hdl) and then unbind the service by calling
3524 * ibt_unbind_service().
3525 */
3526 static void
3527 rib_stop_services(rib_hca_t *hca)
3528 {
3529 rib_hca_service_t *srv_list, *to_remove;
3530
3531 /*
3532 * unbind and deregister the services for this service type.
3533 * Right now there is only one service type. In future it will
3534 * be passed down to this function.
3535 */
3536 rw_enter(&hca->bound_services_lock, RW_READER);
3537 srv_list = hca->bound_services;
3538 hca->bound_services = NULL;
3539 rw_exit(&hca->bound_services_lock);
3540
3541 while (srv_list != NULL) {
3542 rib_service_t *sc;
3543
3544 to_remove = srv_list;
3545 srv_list = to_remove->next;
3546 rw_enter(&rib_stat->service_list_lock, RW_READER);
3547 for (sc = rib_stat->service_list;
3548 sc && (sc->srv_id != to_remove->srv_id);
3549 sc = sc->next)
3550 ;
3551 /*
3552 * if sc is NULL then the service doesn't exist anymore,
3553 * probably just removed completely through rib_stat.
3554 */
3555 if (sc != NULL)
3556 (void) ibt_unbind_service(sc->srv_hdl,
3557 to_remove->sbind_hdl);
3558 rw_exit(&rib_stat->service_list_lock);
3559 kmem_free(to_remove, sizeof (rib_hca_service_t));
3560 }
3561 }
3562
3563 static struct svc_recv *
3564 rib_init_svc_recv(rib_qp_t *qp, ibt_wr_ds_t *sgl)
3565 {
3566 struct svc_recv *recvp;
3567
3568 recvp = kmem_zalloc(sizeof (struct svc_recv), KM_SLEEP);
3569 recvp->vaddr = sgl->ds_va;
3570 recvp->qp = qp;
3571 recvp->bytes_xfer = 0;
3572 return (recvp);
3573 }
3574
3575 static int
3576 rib_free_svc_recv(struct svc_recv *recvp)
3577 {
3578 kmem_free(recvp, sizeof (*recvp));
3579
3580 return (0);
3581 }
3582
3583 static struct reply *
3584 rib_addreplylist(rib_qp_t *qp, uint32_t msgid)
3585 {
3586 struct reply *rep;
3587
3588
3589 rep = kmem_zalloc(sizeof (struct reply), KM_NOSLEEP);
3590 if (rep == NULL) {
3591 DTRACE_PROBE(rpcib__i__addrreply__nomem);
3592 return (NULL);
3593 }
3594 rep->xid = msgid;
3595 rep->vaddr_cq = NULL;
3596 rep->bytes_xfer = 0;
3597 rep->status = (uint_t)REPLY_WAIT;
3598 rep->prev = NULL;
3599 cv_init(&rep->wait_cv, NULL, CV_DEFAULT, NULL);
3600
3601 mutex_enter(&qp->replylist_lock);
3602 if (qp->replylist) {
3603 rep->next = qp->replylist;
3604 qp->replylist->prev = rep;
3605 }
3606 qp->rep_list_size++;
3607
3608 DTRACE_PROBE1(rpcib__i__addrreply__listsize,
3609 int, qp->rep_list_size);
3610
3611 qp->replylist = rep;
3612 mutex_exit(&qp->replylist_lock);
3613
3614 return (rep);
3615 }
3616
3617 static rdma_stat
3618 rib_rem_replylist(rib_qp_t *qp)
3619 {
3620 struct reply *r, *n;
3621
3622 mutex_enter(&qp->replylist_lock);
3623 for (r = qp->replylist; r != NULL; r = n) {
3624 n = r->next;
3625 (void) rib_remreply(qp, r);
3626 }
3627 mutex_exit(&qp->replylist_lock);
3628
3629 return (RDMA_SUCCESS);
3630 }
3631
3632 static int
3633 rib_remreply(rib_qp_t *qp, struct reply *rep)
3634 {
3635
3636 ASSERT(MUTEX_HELD(&qp->replylist_lock));
3637 if (rep->prev) {
3638 rep->prev->next = rep->next;
3639 }
3640 if (rep->next) {
3641 rep->next->prev = rep->prev;
3642 }
3643 if (qp->replylist == rep)
3644 qp->replylist = rep->next;
3645
3646 cv_destroy(&rep->wait_cv);
3647 qp->rep_list_size--;
3648
3649 DTRACE_PROBE1(rpcib__i__remreply__listsize,
3650 int, qp->rep_list_size);
3651
3652 kmem_free(rep, sizeof (*rep));
3653
3654 return (0);
3655 }
3656
3657 rdma_stat
3658 rib_registermem(CONN *conn, caddr_t adsp, caddr_t buf, uint_t buflen,
3659 struct mrc *buf_handle)
3660 {
3661 ibt_mr_hdl_t mr_hdl = NULL; /* memory region handle */
3662 ibt_mr_desc_t mr_desc; /* vaddr, lkey, rkey */
3663 rdma_stat status;
3664 rib_hca_t *hca = (ctoqp(conn))->hca;
3665
3666 /*
3667 * Note: ALL buffer pools use the same memory type RDMARW.
3668 */
3669 status = rib_reg_mem(hca, adsp, buf, buflen, 0, &mr_hdl, &mr_desc);
3670 if (status == RDMA_SUCCESS) {
3671 buf_handle->mrc_linfo = (uintptr_t)mr_hdl;
3672 buf_handle->mrc_lmr = (uint32_t)mr_desc.md_lkey;
3673 buf_handle->mrc_rmr = (uint32_t)mr_desc.md_rkey;
3674 } else {
3675 buf_handle->mrc_linfo = NULL;
3676 buf_handle->mrc_lmr = 0;
3677 buf_handle->mrc_rmr = 0;
3678 }
3679 return (status);
3680 }
3681
3682 static rdma_stat
3683 rib_reg_mem(rib_hca_t *hca, caddr_t adsp, caddr_t buf, uint_t size,
3684 ibt_mr_flags_t spec,
3685 ibt_mr_hdl_t *mr_hdlp, ibt_mr_desc_t *mr_descp)
3686 {
3687 ibt_mr_attr_t mem_attr;
3688 ibt_status_t ibt_status;
3689 mem_attr.mr_vaddr = (uintptr_t)buf;
3690 mem_attr.mr_len = (ib_msglen_t)size;
3691 mem_attr.mr_as = (struct as *)(caddr_t)adsp;
3692 mem_attr.mr_flags = IBT_MR_SLEEP | IBT_MR_ENABLE_LOCAL_WRITE |
3693 IBT_MR_ENABLE_REMOTE_READ | IBT_MR_ENABLE_REMOTE_WRITE |
3694 IBT_MR_ENABLE_WINDOW_BIND | spec;
3695
3696 rw_enter(&hca->state_lock, RW_READER);
3697 if (hca->state != HCA_DETACHED) {
3698 ibt_status = ibt_register_mr(hca->hca_hdl, hca->pd_hdl,
3699 &mem_attr, mr_hdlp, mr_descp);
3700 rw_exit(&hca->state_lock);
3701 } else {
3702 rw_exit(&hca->state_lock);
3703 return (RDMA_FAILED);
3704 }
3705
3706 if (ibt_status != IBT_SUCCESS) {
3707 return (RDMA_FAILED);
3708 }
3709 return (RDMA_SUCCESS);
3710 }
3711
3712 rdma_stat
3713 rib_registermemsync(CONN *conn, caddr_t adsp, caddr_t buf, uint_t buflen,
3714 struct mrc *buf_handle, RIB_SYNCMEM_HANDLE *sync_handle, void *lrc)
3715 {
3716 ibt_mr_hdl_t mr_hdl = NULL; /* memory region handle */
3717 rib_lrc_entry_t *l;
3718 ibt_mr_desc_t mr_desc; /* vaddr, lkey, rkey */
3719 rdma_stat status;
3720 rib_hca_t *hca = (ctoqp(conn))->hca;
3721
3722 /*
3723 * Non-coherent memory registration.
3724 */
3725 l = (rib_lrc_entry_t *)lrc;
3726 if (l) {
3727 if (l->registered) {
3728 buf_handle->mrc_linfo =
3729 (uintptr_t)l->lrc_mhandle.mrc_linfo;
3730 buf_handle->mrc_lmr =
3731 (uint32_t)l->lrc_mhandle.mrc_lmr;
3732 buf_handle->mrc_rmr =
3733 (uint32_t)l->lrc_mhandle.mrc_rmr;
3734 *sync_handle = (RIB_SYNCMEM_HANDLE)
3735 (uintptr_t)l->lrc_mhandle.mrc_linfo;
3736 return (RDMA_SUCCESS);
3737 } else {
3738 /* Always register the whole buffer */
3739 buf = (caddr_t)l->lrc_buf;
3740 buflen = l->lrc_len;
3741 }
3742 }
3743 status = rib_reg_mem(hca, adsp, buf, buflen, 0, &mr_hdl, &mr_desc);
3744
3745 if (status == RDMA_SUCCESS) {
3746 if (l) {
3747 l->lrc_mhandle.mrc_linfo = (uintptr_t)mr_hdl;
3748 l->lrc_mhandle.mrc_lmr = (uint32_t)mr_desc.md_lkey;
3749 l->lrc_mhandle.mrc_rmr = (uint32_t)mr_desc.md_rkey;
3750 l->registered = TRUE;
3751 }
3752 buf_handle->mrc_linfo = (uintptr_t)mr_hdl;
3753 buf_handle->mrc_lmr = (uint32_t)mr_desc.md_lkey;
3754 buf_handle->mrc_rmr = (uint32_t)mr_desc.md_rkey;
3755 *sync_handle = (RIB_SYNCMEM_HANDLE)mr_hdl;
3756 } else {
3757 buf_handle->mrc_linfo = NULL;
3758 buf_handle->mrc_lmr = 0;
3759 buf_handle->mrc_rmr = 0;
3760 }
3761 return (status);
3762 }
3763
3764 /* ARGSUSED */
3765 rdma_stat
3766 rib_deregistermem(CONN *conn, caddr_t buf, struct mrc buf_handle)
3767 {
3768 rib_hca_t *hca = (ctoqp(conn))->hca;
3769 /*
3770 * Allow memory deregistration even if HCA is
3771 * getting detached. Need all outstanding
3772 * memory registrations to be deregistered
3773 * before HCA_DETACH_EVENT can be accepted.
3774 */
3775 (void) ibt_deregister_mr(hca->hca_hdl,
3776 (ibt_mr_hdl_t)(uintptr_t)buf_handle.mrc_linfo);
3777 return (RDMA_SUCCESS);
3778 }
3779
3780 /* ARGSUSED */
3781 rdma_stat
3782 rib_deregistermemsync(CONN *conn, caddr_t buf, struct mrc buf_handle,
3783 RIB_SYNCMEM_HANDLE sync_handle, void *lrc)
3784 {
3785 rib_lrc_entry_t *l;
3786 l = (rib_lrc_entry_t *)lrc;
3787 if (l)
3788 if (l->registered)
3789 return (RDMA_SUCCESS);
3790
3791 (void) rib_deregistermem(conn, buf, buf_handle);
3792
3793 return (RDMA_SUCCESS);
3794 }
3795
3796 /* ARGSUSED */
3797 rdma_stat
3798 rib_syncmem(CONN *conn, RIB_SYNCMEM_HANDLE shandle, caddr_t buf,
3799 int len, int cpu)
3800 {
3801 ibt_status_t status;
3802 rib_hca_t *hca = (ctoqp(conn))->hca;
3803 ibt_mr_sync_t mr_segment;
3804
3805 mr_segment.ms_handle = (ibt_mr_hdl_t)shandle;
3806 mr_segment.ms_vaddr = (ib_vaddr_t)(uintptr_t)buf;
3807 mr_segment.ms_len = (ib_memlen_t)len;
3808 if (cpu) {
3809 /* make incoming data visible to memory */
3810 mr_segment.ms_flags = IBT_SYNC_WRITE;
3811 } else {
3812 /* make memory changes visible to IO */
3813 mr_segment.ms_flags = IBT_SYNC_READ;
3814 }
3815 rw_enter(&hca->state_lock, RW_READER);
3816 if (hca->state != HCA_DETACHED) {
3817 status = ibt_sync_mr(hca->hca_hdl, &mr_segment, 1);
3818 rw_exit(&hca->state_lock);
3819 } else {
3820 rw_exit(&hca->state_lock);
3821 return (RDMA_FAILED);
3822 }
3823
3824 if (status == IBT_SUCCESS)
3825 return (RDMA_SUCCESS);
3826 else {
3827 return (RDMA_FAILED);
3828 }
3829 }
3830
3831 /*
3832 * XXXX ????
3833 */
3834 static rdma_stat
3835 rib_getinfo(rdma_info_t *info)
3836 {
3837 /*
3838 * XXXX Hack!
3839 */
3840 info->addrlen = 16;
3841 info->mts = 1000000;
3842 info->mtu = 1000000;
3843
3844 return (RDMA_SUCCESS);
3845 }
3846
3847 rib_bufpool_t *
3848 rib_rbufpool_create(rib_hca_t *hca, int ptype, int num)
3849 {
3850 rib_bufpool_t *rbp = NULL;
3851 bufpool_t *bp = NULL;
3852 caddr_t buf;
3853 ibt_mr_attr_t mem_attr;
3854 ibt_status_t ibt_status;
3855 int i, j;
3856
3857 rbp = (rib_bufpool_t *)kmem_zalloc(sizeof (rib_bufpool_t), KM_SLEEP);
3858
3859 bp = (bufpool_t *)kmem_zalloc(sizeof (bufpool_t) +
3860 num * sizeof (void *), KM_SLEEP);
3861
3862 mutex_init(&bp->buflock, NULL, MUTEX_DRIVER, hca->iblock);
3863 bp->numelems = num;
3864
3865
3866 switch (ptype) {
3867 case SEND_BUFFER:
3868 mem_attr.mr_flags = IBT_MR_SLEEP | IBT_MR_ENABLE_LOCAL_WRITE;
3869 bp->rsize = RPC_MSG_SZ;
3870 break;
3871 case RECV_BUFFER:
3872 mem_attr.mr_flags = IBT_MR_SLEEP | IBT_MR_ENABLE_LOCAL_WRITE;
3873 bp->rsize = RPC_BUF_SIZE;
3874 break;
3875 default:
3876 goto fail;
3877 }
3878
3879 /*
3880 * Register the pool.
3881 */
3882 bp->bufsize = num * bp->rsize;
3883 bp->buf = kmem_zalloc(bp->bufsize, KM_SLEEP);
3884 rbp->mr_hdl = (ibt_mr_hdl_t *)kmem_zalloc(num *
3885 sizeof (ibt_mr_hdl_t), KM_SLEEP);
3886 rbp->mr_desc = (ibt_mr_desc_t *)kmem_zalloc(num *
3887 sizeof (ibt_mr_desc_t), KM_SLEEP);
3888 rw_enter(&hca->state_lock, RW_READER);
3889
3890 if (hca->state == HCA_DETACHED) {
3891 rw_exit(&hca->state_lock);
3892 goto fail;
3893 }
3894
3895 for (i = 0, buf = bp->buf; i < num; i++, buf += bp->rsize) {
3896 bzero(&rbp->mr_desc[i], sizeof (ibt_mr_desc_t));
3897 mem_attr.mr_vaddr = (uintptr_t)buf;
3898 mem_attr.mr_len = (ib_msglen_t)bp->rsize;
3899 mem_attr.mr_as = NULL;
3900 ibt_status = ibt_register_mr(hca->hca_hdl,
3901 hca->pd_hdl, &mem_attr,
3902 &rbp->mr_hdl[i],
3903 &rbp->mr_desc[i]);
3904 if (ibt_status != IBT_SUCCESS) {
3905 for (j = 0; j < i; j++) {
3906 (void) ibt_deregister_mr(hca->hca_hdl,
3907 rbp->mr_hdl[j]);
3908 }
3909 rw_exit(&hca->state_lock);
3910 goto fail;
3911 }
3912 }
3913 rw_exit(&hca->state_lock);
3914 buf = (caddr_t)bp->buf;
3915 for (i = 0; i < num; i++, buf += bp->rsize) {
3916 bp->buflist[i] = (void *)buf;
3917 }
3918 bp->buffree = num - 1; /* no. of free buffers */
3919 rbp->bpool = bp;
3920
3921 return (rbp);
3922 fail:
3923 if (bp) {
3924 if (bp->buf)
3925 kmem_free(bp->buf, bp->bufsize);
3926 kmem_free(bp, sizeof (bufpool_t) + num*sizeof (void *));
3927 }
3928 if (rbp) {
3929 if (rbp->mr_hdl)
3930 kmem_free(rbp->mr_hdl, num*sizeof (ibt_mr_hdl_t));
3931 if (rbp->mr_desc)
3932 kmem_free(rbp->mr_desc, num*sizeof (ibt_mr_desc_t));
3933 kmem_free(rbp, sizeof (rib_bufpool_t));
3934 }
3935 return (NULL);
3936 }
3937
3938 static void
3939 rib_rbufpool_deregister(rib_hca_t *hca, int ptype)
3940 {
3941 int i;
3942 rib_bufpool_t *rbp = NULL;
3943 bufpool_t *bp;
3944
3945 /*
3946 * Obtain pool address based on type of pool
3947 */
3948 switch (ptype) {
3949 case SEND_BUFFER:
3950 rbp = hca->send_pool;
3951 break;
3952 case RECV_BUFFER:
3953 rbp = hca->recv_pool;
3954 break;
3955 default:
3956 return;
3957 }
3958 if (rbp == NULL)
3959 return;
3960
3961 bp = rbp->bpool;
3962
3963 /*
3964 * Deregister the pool memory and free it.
3965 */
3966 for (i = 0; i < bp->numelems; i++) {
3967 (void) ibt_deregister_mr(hca->hca_hdl, rbp->mr_hdl[i]);
3968 }
3969 }
3970
3971 static void
3972 rib_rbufpool_free(rib_hca_t *hca, int ptype)
3973 {
3974
3975 rib_bufpool_t *rbp = NULL;
3976 bufpool_t *bp;
3977
3978 /*
3979 * Obtain pool address based on type of pool
3980 */
3981 switch (ptype) {
3982 case SEND_BUFFER:
3983 rbp = hca->send_pool;
3984 break;
3985 case RECV_BUFFER:
3986 rbp = hca->recv_pool;
3987 break;
3988 default:
3989 return;
3990 }
3991 if (rbp == NULL)
3992 return;
3993
3994 bp = rbp->bpool;
3995
3996 /*
3997 * Free the pool memory.
3998 */
3999 if (rbp->mr_hdl)
4000 kmem_free(rbp->mr_hdl, bp->numelems*sizeof (ibt_mr_hdl_t));
4001
4002 if (rbp->mr_desc)
4003 kmem_free(rbp->mr_desc, bp->numelems*sizeof (ibt_mr_desc_t));
4004 if (bp->buf)
4005 kmem_free(bp->buf, bp->bufsize);
4006 mutex_destroy(&bp->buflock);
4007 kmem_free(bp, sizeof (bufpool_t) + bp->numelems*sizeof (void *));
4008 kmem_free(rbp, sizeof (rib_bufpool_t));
4009 }
4010
4011 void
4012 rib_rbufpool_destroy(rib_hca_t *hca, int ptype)
4013 {
4014 /*
4015 * Deregister the pool memory and free it.
4016 */
4017 rib_rbufpool_deregister(hca, ptype);
4018 rib_rbufpool_free(hca, ptype);
4019 }
4020
4021 /*
4022 * Fetch a buffer from the pool of type specified in rdbuf->type.
4023 */
4024 static rdma_stat
4025 rib_reg_buf_alloc(CONN *conn, rdma_buf_t *rdbuf)
4026 {
4027 rib_lrc_entry_t *rlep;
4028
4029 if (rdbuf->type == RDMA_LONG_BUFFER) {
4030 rlep = rib_get_cache_buf(conn, rdbuf->len);
4031 rdbuf->rb_private = (caddr_t)rlep;
4032 rdbuf->addr = rlep->lrc_buf;
4033 rdbuf->handle = rlep->lrc_mhandle;
4034 return (RDMA_SUCCESS);
4035 }
4036
4037 rdbuf->addr = rib_rbuf_alloc(conn, rdbuf);
4038 if (rdbuf->addr) {
4039 switch (rdbuf->type) {
4040 case SEND_BUFFER:
4041 rdbuf->len = RPC_MSG_SZ; /* 1K */
4042 break;
4043 case RECV_BUFFER:
4044 rdbuf->len = RPC_BUF_SIZE; /* 2K */
4045 break;
4046 default:
4047 rdbuf->len = 0;
4048 }
4049 return (RDMA_SUCCESS);
4050 } else
4051 return (RDMA_FAILED);
4052 }
4053
4054 /*
4055 * Fetch a buffer of specified type.
4056 * Note that rdbuf->handle is mw's rkey.
4057 */
4058 static void *
4059 rib_rbuf_alloc(CONN *conn, rdma_buf_t *rdbuf)
4060 {
4061 rib_qp_t *qp = ctoqp(conn);
4062 rib_hca_t *hca = qp->hca;
4063 rdma_btype ptype = rdbuf->type;
4064 void *buf;
4065 rib_bufpool_t *rbp = NULL;
4066 bufpool_t *bp;
4067 int i;
4068
4069 /*
4070 * Obtain pool address based on type of pool
4071 */
4072 switch (ptype) {
4073 case SEND_BUFFER:
4074 rbp = hca->send_pool;
4075 break;
4076 case RECV_BUFFER:
4077 rbp = hca->recv_pool;
4078 break;
4079 default:
4080 return (NULL);
4081 }
4082 if (rbp == NULL)
4083 return (NULL);
4084
4085 bp = rbp->bpool;
4086
4087 mutex_enter(&bp->buflock);
4088 if (bp->buffree < 0) {
4089 mutex_exit(&bp->buflock);
4090 return (NULL);
4091 }
4092
4093 /* XXXX put buf, rdbuf->handle.mrc_rmr, ... in one place. */
4094 buf = bp->buflist[bp->buffree];
4095 rdbuf->addr = buf;
4096 rdbuf->len = bp->rsize;
4097 for (i = bp->numelems - 1; i >= 0; i--) {
4098 if ((ib_vaddr_t)(uintptr_t)buf == rbp->mr_desc[i].md_vaddr) {
4099 rdbuf->handle.mrc_rmr =
4100 (uint32_t)rbp->mr_desc[i].md_rkey;
4101 rdbuf->handle.mrc_linfo =
4102 (uintptr_t)rbp->mr_hdl[i];
4103 rdbuf->handle.mrc_lmr =
4104 (uint32_t)rbp->mr_desc[i].md_lkey;
4105 bp->buffree--;
4106
4107 mutex_exit(&bp->buflock);
4108
4109 return (buf);
4110 }
4111 }
4112
4113 mutex_exit(&bp->buflock);
4114
4115 return (NULL);
4116 }
4117
4118 static void
4119 rib_reg_buf_free(CONN *conn, rdma_buf_t *rdbuf)
4120 {
4121
4122 if (rdbuf->type == RDMA_LONG_BUFFER) {
4123 rib_free_cache_buf(conn, (rib_lrc_entry_t *)rdbuf->rb_private);
4124 rdbuf->rb_private = NULL;
4125 return;
4126 }
4127 rib_rbuf_free(conn, rdbuf->type, rdbuf->addr);
4128 }
4129
4130 static void
4131 rib_rbuf_free(CONN *conn, int ptype, void *buf)
4132 {
4133 rib_qp_t *qp = ctoqp(conn);
4134 rib_hca_t *hca = qp->hca;
4135 rib_bufpool_t *rbp = NULL;
4136 bufpool_t *bp;
4137
4138 /*
4139 * Obtain pool address based on type of pool
4140 */
4141 switch (ptype) {
4142 case SEND_BUFFER:
4143 rbp = hca->send_pool;
4144 break;
4145 case RECV_BUFFER:
4146 rbp = hca->recv_pool;
4147 break;
4148 default:
4149 return;
4150 }
4151 if (rbp == NULL)
4152 return;
4153
4154 bp = rbp->bpool;
4155
4156 mutex_enter(&bp->buflock);
4157 if (++bp->buffree >= bp->numelems) {
4158 /*
4159 * Should never happen
4160 */
4161 bp->buffree--;
4162 } else {
4163 bp->buflist[bp->buffree] = buf;
4164 }
4165 mutex_exit(&bp->buflock);
4166 }
4167
4168 static rdma_stat
4169 rib_add_connlist(CONN *cn, rib_conn_list_t *connlist)
4170 {
4171 rw_enter(&connlist->conn_lock, RW_WRITER);
4172 if (connlist->conn_hd) {
4173 cn->c_next = connlist->conn_hd;
4174 connlist->conn_hd->c_prev = cn;
4175 }
4176 connlist->conn_hd = cn;
4177 rw_exit(&connlist->conn_lock);
4178
4179 return (RDMA_SUCCESS);
4180 }
4181
4182 static rdma_stat
4183 rib_rm_conn(CONN *cn, rib_conn_list_t *connlist)
4184 {
4185 rw_enter(&connlist->conn_lock, RW_WRITER);
4186 if (cn->c_prev) {
4187 cn->c_prev->c_next = cn->c_next;
4188 }
4189 if (cn->c_next) {
4190 cn->c_next->c_prev = cn->c_prev;
4191 }
4192 if (connlist->conn_hd == cn)
4193 connlist->conn_hd = cn->c_next;
4194 rw_exit(&connlist->conn_lock);
4195
4196 return (RDMA_SUCCESS);
4197 }
4198
4199 /* ARGSUSED */
4200 static rdma_stat
4201 rib_conn_get(struct netbuf *s_svcaddr, struct netbuf *d_svcaddr,
4202 int addr_type, void *handle, CONN **conn)
4203 {
4204 rdma_stat status;
4205 rpcib_ping_t rpt;
4206
4207 status = rib_connect(s_svcaddr, d_svcaddr, addr_type, &rpt, conn);
4208 return (status);
4209 }
4210
4211 /*
4212 * rib_find_hca_connection
4213 *
4214 * if there is an existing connection to the specified address then
4215 * it will be returned in conn, otherwise conn will be set to NULL.
4216 * Also cleans up any connection that is in error state.
4217 */
4218 static int
4219 rib_find_hca_connection(rib_hca_t *hca, struct netbuf *s_svcaddr,
4220 struct netbuf *d_svcaddr, CONN **conn)
4221 {
4222 CONN *cn;
4223 clock_t cv_stat, timout;
4224
4225 *conn = NULL;
4226 again:
4227 rw_enter(&hca->cl_conn_list.conn_lock, RW_READER);
4228 cn = hca->cl_conn_list.conn_hd;
4229 while (cn != NULL) {
4230 /*
4231 * First, clear up any connection in the ERROR state
4232 */
4233 mutex_enter(&cn->c_lock);
4234 if (cn->c_state == C_ERROR_CONN) {
4235 if (cn->c_ref == 0) {
4236 /*
4237 * Remove connection from list and destroy it.
4238 */
4239 cn->c_state = C_DISCONN_PEND;
4240 mutex_exit(&cn->c_lock);
4241 rw_exit(&hca->cl_conn_list.conn_lock);
4242 rib_conn_close((void *)cn);
4243 goto again;
4244 }
4245 mutex_exit(&cn->c_lock);
4246 cn = cn->c_next;
4247 continue;
4248 }
4249 if (cn->c_state == C_DISCONN_PEND) {
4250 mutex_exit(&cn->c_lock);
4251 cn = cn->c_next;
4252 continue;
4253 }
4254
4255 /*
4256 * source address is only checked for if there is one,
4257 * this is the case for retries.
4258 */
4259 if ((cn->c_raddr.len == d_svcaddr->len) &&
4260 (bcmp(d_svcaddr->buf, cn->c_raddr.buf,
4261 d_svcaddr->len) == 0) &&
4262 ((s_svcaddr->len == 0) ||
4263 ((cn->c_laddr.len == s_svcaddr->len) &&
4264 (bcmp(s_svcaddr->buf, cn->c_laddr.buf,
4265 s_svcaddr->len) == 0)))) {
4266 /*
4267 * Our connection. Give up conn list lock
4268 * as we are done traversing the list.
4269 */
4270 rw_exit(&hca->cl_conn_list.conn_lock);
4271 if (cn->c_state == C_CONNECTED) {
4272 cn->c_ref++; /* sharing a conn */
4273 mutex_exit(&cn->c_lock);
4274 *conn = cn;
4275 return (RDMA_SUCCESS);
4276 }
4277 if (cn->c_state == C_CONN_PEND) {
4278 /*
4279 * Hold a reference to this conn before
4280 * we give up the lock.
4281 */
4282 cn->c_ref++;
4283 timout = ddi_get_lbolt() +
4284 drv_usectohz(CONN_WAIT_TIME * 1000000);
4285 while ((cv_stat = cv_timedwait_sig(&cn->c_cv,
4286 &cn->c_lock, timout)) > 0 &&
4287 cn->c_state == C_CONN_PEND)
4288 ;
4289 if (cv_stat == 0) {
4290 (void) rib_conn_release_locked(cn);
4291 return (RDMA_INTR);
4292 }
4293 if (cv_stat < 0) {
4294 (void) rib_conn_release_locked(cn);
4295 return (RDMA_TIMEDOUT);
4296 }
4297 if (cn->c_state == C_CONNECTED) {
4298 *conn = cn;
4299 mutex_exit(&cn->c_lock);
4300 return (RDMA_SUCCESS);
4301 } else {
4302 (void) rib_conn_release_locked(cn);
4303 return (RDMA_TIMEDOUT);
4304 }
4305 }
4306 }
4307 mutex_exit(&cn->c_lock);
4308 cn = cn->c_next;
4309 }
4310 rw_exit(&hca->cl_conn_list.conn_lock);
4311 *conn = NULL;
4312 return (RDMA_FAILED);
4313 }
4314
4315 /*
4316 * Connection management.
4317 * IBTF does not support recycling of channels. So connections are only
4318 * in four states - C_CONN_PEND, or C_CONNECTED, or C_ERROR_CONN or
4319 * C_DISCONN_PEND state. No C_IDLE state.
4320 * C_CONN_PEND state: Connection establishment in progress to the server.
4321 * C_CONNECTED state: A connection when created is in C_CONNECTED state.
4322 * It has an RC channel associated with it. ibt_post_send/recv are allowed
4323 * only in this state.
4324 * C_ERROR_CONN state: A connection transitions to this state when WRs on the
4325 * channel are completed in error or an IBT_CM_EVENT_CONN_CLOSED event
4326 * happens on the channel or a IBT_HCA_DETACH_EVENT occurs on the HCA.
4327 * C_DISCONN_PEND state: When a connection is in C_ERROR_CONN state and when
4328 * c_ref drops to 0 (this indicates that RPC has no more references to this
4329 * connection), the connection should be destroyed. A connection transitions
4330 * into this state when it is being destroyed.
4331 */
4332 /* ARGSUSED */
4333 static rdma_stat
4334 rib_connect(struct netbuf *s_svcaddr, struct netbuf *d_svcaddr,
4335 int addr_type, rpcib_ping_t *rpt, CONN **conn)
4336 {
4337 CONN *cn;
4338 int status;
4339 rib_hca_t *hca;
4340 rib_qp_t *qp;
4341 int s_addr_len;
4342 char *s_addr_buf;
4343
4344 rw_enter(&rib_stat->hcas_list_lock, RW_READER);
4345 for (hca = rib_stat->hcas_list; hca; hca = hca->next) {
4346 rw_enter(&hca->state_lock, RW_READER);
4347 if (hca->state != HCA_DETACHED) {
4348 status = rib_find_hca_connection(hca, s_svcaddr,
4349 d_svcaddr, conn);
4350 rw_exit(&hca->state_lock);
4351 if ((status == RDMA_INTR) || (status == RDMA_SUCCESS)) {
4352 rw_exit(&rib_stat->hcas_list_lock);
4353 return (status);
4354 }
4355 } else
4356 rw_exit(&hca->state_lock);
4357 }
4358 rw_exit(&rib_stat->hcas_list_lock);
4359
4360 /*
4361 * No existing connection found, establish a new connection.
4362 */
4363 bzero(rpt, sizeof (rpcib_ping_t));
4364
4365 status = rib_ping_srv(addr_type, d_svcaddr, rpt);
4366 if (status != RDMA_SUCCESS) {
4367 return (RDMA_FAILED);
4368 }
4369 hca = rpt->hca;
4370
4371 if (rpt->srcip.family == AF_INET) {
4372 s_addr_len = sizeof (rpt->srcip.un.ip4addr);
4373 s_addr_buf = (char *)&rpt->srcip.un.ip4addr;
4374 } else if (rpt->srcip.family == AF_INET6) {
4375 s_addr_len = sizeof (rpt->srcip.un.ip6addr);
4376 s_addr_buf = (char *)&rpt->srcip.un.ip6addr;
4377 } else {
4378 return (RDMA_FAILED);
4379 }
4380
4381 /*
4382 * Channel to server doesn't exist yet, create one.
4383 */
4384 if (rib_clnt_create_chan(hca, d_svcaddr, &qp) != RDMA_SUCCESS) {
4385 return (RDMA_FAILED);
4386 }
4387 cn = qptoc(qp);
4388 cn->c_state = C_CONN_PEND;
4389 cn->c_ref = 1;
4390
4391 cn->c_laddr.buf = kmem_alloc(s_addr_len, KM_SLEEP);
4392 bcopy(s_addr_buf, cn->c_laddr.buf, s_addr_len);
4393 cn->c_laddr.len = cn->c_laddr.maxlen = s_addr_len;
4394
4395 if (rpt->srcip.family == AF_INET) {
4396 cn->c_netid = kmem_zalloc(strlen(RIBNETID_TCP) + 1, KM_SLEEP);
4397 (void) strcpy(cn->c_netid, RIBNETID_TCP);
4398
4399 cn->c_addrmask.len = cn->c_addrmask.maxlen =
4400 sizeof (struct sockaddr_in);
4401 cn->c_addrmask.buf = kmem_zalloc(cn->c_addrmask.len, KM_SLEEP);
4402
4403 ((struct sockaddr_in *)cn->c_addrmask.buf)->sin_addr.s_addr =
4404 (uint32_t)~0;
4405 ((struct sockaddr_in *)cn->c_addrmask.buf)->sin_family =
4406 (ushort_t)~0;
4407
4408 } else {
4409 cn->c_netid = kmem_zalloc(strlen(RIBNETID_TCP6) + 1, KM_SLEEP);
4410 (void) strcpy(cn->c_netid, RIBNETID_TCP6);
4411
4412 cn->c_addrmask.len = cn->c_addrmask.maxlen =
4413 sizeof (struct sockaddr_in6);
4414 cn->c_addrmask.buf = kmem_zalloc(cn->c_addrmask.len, KM_SLEEP);
4415
4416 (void) memset(
4417 &((struct sockaddr_in6 *)cn->c_addrmask.buf)->sin6_addr,
4418 (uchar_t)~0, sizeof (struct in6_addr));
4419 ((struct sockaddr_in6 *)cn->c_addrmask.buf)->sin6_family =
4420 (sa_family_t)~0;
4421 }
4422
4423 /*
4424 * Add to conn list.
4425 * We had given up the READER lock. In the time since then,
4426 * another thread might have created the connection we are
4427 * trying here. But for now, that is quiet alright - there
4428 * might be two connections between a pair of hosts instead
4429 * of one. If we really want to close that window,
4430 * then need to check the list after acquiring the
4431 * WRITER lock.
4432 */
4433 (void) rib_add_connlist(cn, &hca->cl_conn_list);
4434 status = rib_conn_to_srv(hca, qp, rpt);
4435 mutex_enter(&cn->c_lock);
4436
4437 if (cn->c_flags & C_CLOSE_PENDING) {
4438 /*
4439 * This handles a case where the module or
4440 * HCA detached in the time a connection is
4441 * established. In such a case close the
4442 * connection immediately if this is the
4443 * only reference.
4444 */
4445 if (cn->c_ref == 1) {
4446 cn->c_ref--;
4447 cn->c_state = C_DISCONN_PEND;
4448 mutex_exit(&cn->c_lock);
4449 rib_conn_close((void *)cn);
4450 return (RDMA_FAILED);
4451 }
4452
4453 /*
4454 * Connection to be closed later when c_ref = 0
4455 */
4456 status = RDMA_FAILED;
4457 }
4458
4459 if (status == RDMA_SUCCESS) {
4460 cn->c_state = C_CONNECTED;
4461 *conn = cn;
4462 } else {
4463 cn->c_state = C_ERROR_CONN;
4464 cn->c_ref--;
4465 }
4466 cv_signal(&cn->c_cv);
4467 mutex_exit(&cn->c_lock);
4468 return (status);
4469 }
4470
4471 static void
4472 rib_conn_close(void *rarg)
4473 {
4474 CONN *conn = (CONN *)rarg;
4475 rib_qp_t *qp = ctoqp(conn);
4476
4477 mutex_enter(&conn->c_lock);
4478 if (!(conn->c_flags & C_CLOSE_NOTNEEDED)) {
4479
4480 conn->c_flags |= (C_CLOSE_NOTNEEDED | C_CLOSE_PENDING);
4481
4482 /*
4483 * Live connection in CONNECTED state.
4484 */
4485 if (conn->c_state == C_CONNECTED) {
4486 conn->c_state = C_ERROR_CONN;
4487 }
4488 mutex_exit(&conn->c_lock);
4489
4490 rib_close_a_channel(conn);
4491
4492 mutex_enter(&conn->c_lock);
4493 conn->c_flags &= ~C_CLOSE_PENDING;
4494 }
4495
4496 mutex_exit(&conn->c_lock);
4497
4498 if (qp->mode == RIB_SERVER)
4499 (void) rib_disconnect_channel(conn,
4500 &qp->hca->srv_conn_list);
4501 else
4502 (void) rib_disconnect_channel(conn,
4503 &qp->hca->cl_conn_list);
4504 }
4505
4506 static void
4507 rib_conn_timeout_call(void *carg)
4508 {
4509 time_t idle_time;
4510 CONN *conn = (CONN *)carg;
4511 rib_hca_t *hca = ctoqp(conn)->hca;
4512 int error;
4513
4514 mutex_enter(&conn->c_lock);
4515 if ((conn->c_ref > 0) ||
4516 (conn->c_state == C_DISCONN_PEND)) {
4517 conn->c_timeout = NULL;
4518 mutex_exit(&conn->c_lock);
4519 return;
4520 }
4521
4522 idle_time = (gethrestime_sec() - conn->c_last_used);
4523
4524 if ((idle_time <= rib_conn_timeout) &&
4525 (conn->c_state != C_ERROR_CONN)) {
4526 /*
4527 * There was activity after the last timeout.
4528 * Extend the conn life. Unless the conn is
4529 * already in error state.
4530 */
4531 conn->c_timeout = timeout(rib_conn_timeout_call, conn,
4532 SEC_TO_TICK(rib_conn_timeout - idle_time));
4533 mutex_exit(&conn->c_lock);
4534 return;
4535 }
4536
4537 error = ddi_taskq_dispatch(hca->cleanup_helper, rib_conn_close,
4538 (void *)conn, DDI_NOSLEEP);
4539
4540 /*
4541 * If taskq dispatch fails above, then reset the timeout
4542 * to try again after 10 secs.
4543 */
4544
4545 if (error != DDI_SUCCESS) {
4546 conn->c_timeout = timeout(rib_conn_timeout_call, conn,
4547 SEC_TO_TICK(RDMA_CONN_REAP_RETRY));
4548 mutex_exit(&conn->c_lock);
4549 return;
4550 }
4551
4552 conn->c_state = C_DISCONN_PEND;
4553 mutex_exit(&conn->c_lock);
4554 }
4555
4556 static rdma_stat
4557 rib_conn_release(CONN *conn)
4558 {
4559 mutex_enter(&conn->c_lock);
4560 return (rib_conn_release_locked(conn));
4561 }
4562
4563 /*
4564 * Expects conn->c_lock to be held on entry.
4565 * c_lock released on return
4566 */
4567 static rdma_stat
4568 rib_conn_release_locked(CONN *conn)
4569 {
4570 conn->c_ref--;
4571
4572 conn->c_last_used = gethrestime_sec();
4573 if (conn->c_ref > 0) {
4574 mutex_exit(&conn->c_lock);
4575 return (RDMA_SUCCESS);
4576 }
4577
4578 /*
4579 * If a conn is C_ERROR_CONN, close the channel.
4580 */
4581 if (conn->c_ref == 0 && conn->c_state == C_ERROR_CONN) {
4582 conn->c_state = C_DISCONN_PEND;
4583 mutex_exit(&conn->c_lock);
4584 rib_conn_close((void *)conn);
4585 return (RDMA_SUCCESS);
4586 }
4587
4588 /*
4589 * c_ref == 0, set a timeout for conn release
4590 */
4591
4592 if (conn->c_timeout == NULL) {
4593 conn->c_timeout = timeout(rib_conn_timeout_call, conn,
4594 SEC_TO_TICK(rib_conn_timeout));
4595 }
4596
4597 mutex_exit(&conn->c_lock);
4598 return (RDMA_SUCCESS);
4599 }
4600
4601 /*
4602 * Add at front of list
4603 */
4604 static struct rdma_done_list *
4605 rdma_done_add(rib_qp_t *qp, uint32_t xid)
4606 {
4607 struct rdma_done_list *rd;
4608
4609 ASSERT(MUTEX_HELD(&qp->rdlist_lock));
4610
4611 rd = kmem_alloc(sizeof (*rd), KM_SLEEP);
4612 rd->xid = xid;
4613 cv_init(&rd->rdma_done_cv, NULL, CV_DEFAULT, NULL);
4614
4615 rd->prev = NULL;
4616 rd->next = qp->rdlist;
4617 if (qp->rdlist != NULL)
4618 qp->rdlist->prev = rd;
4619 qp->rdlist = rd;
4620
4621 return (rd);
4622 }
4623
4624 static void
4625 rdma_done_rm(rib_qp_t *qp, struct rdma_done_list *rd)
4626 {
4627 struct rdma_done_list *r;
4628
4629 ASSERT(MUTEX_HELD(&qp->rdlist_lock));
4630
4631 r = rd->next;
4632 if (r != NULL) {
4633 r->prev = rd->prev;
4634 }
4635
4636 r = rd->prev;
4637 if (r != NULL) {
4638 r->next = rd->next;
4639 } else {
4640 qp->rdlist = rd->next;
4641 }
4642
4643 cv_destroy(&rd->rdma_done_cv);
4644 kmem_free(rd, sizeof (*rd));
4645 }
4646
4647 static void
4648 rdma_done_rem_list(rib_qp_t *qp)
4649 {
4650 struct rdma_done_list *r, *n;
4651
4652 mutex_enter(&qp->rdlist_lock);
4653 for (r = qp->rdlist; r != NULL; r = n) {
4654 n = r->next;
4655 rdma_done_rm(qp, r);
4656 }
4657 mutex_exit(&qp->rdlist_lock);
4658 }
4659
4660 static void
4661 rdma_done_notify(rib_qp_t *qp, uint32_t xid)
4662 {
4663 struct rdma_done_list *r = qp->rdlist;
4664
4665 ASSERT(MUTEX_HELD(&qp->rdlist_lock));
4666
4667 while (r) {
4668 if (r->xid == xid) {
4669 cv_signal(&r->rdma_done_cv);
4670 return;
4671 } else {
4672 r = r->next;
4673 }
4674 }
4675 DTRACE_PROBE1(rpcib__i__donenotify__nomatchxid,
4676 int, xid);
4677 }
4678
4679 /*
4680 * Expects conn->c_lock to be held by the caller.
4681 */
4682
4683 static void
4684 rib_close_a_channel(CONN *conn)
4685 {
4686 rib_qp_t *qp;
4687 qp = ctoqp(conn);
4688
4689 if (qp->qp_hdl == NULL) {
4690 /* channel already freed */
4691 return;
4692 }
4693
4694 /*
4695 * Call ibt_close_rc_channel in blocking mode
4696 * with no callbacks.
4697 */
4698 (void) ibt_close_rc_channel(qp->qp_hdl, IBT_NOCALLBACKS,
4699 NULL, 0, NULL, NULL, 0);
4700 }
4701
4702 /*
4703 * Goes through all connections and closes the channel
4704 * This will cause all the WRs on those channels to be
4705 * flushed.
4706 */
4707 static void
4708 rib_close_channels(rib_conn_list_t *connlist)
4709 {
4710 CONN *conn, *tmp;
4711
4712 rw_enter(&connlist->conn_lock, RW_READER);
4713 conn = connlist->conn_hd;
4714 while (conn != NULL) {
4715 mutex_enter(&conn->c_lock);
4716 tmp = conn->c_next;
4717 if (!(conn->c_flags & C_CLOSE_NOTNEEDED)) {
4718
4719 if (conn->c_state == C_CONN_PEND) {
4720 conn->c_flags |= C_CLOSE_PENDING;
4721 goto next;
4722 }
4723
4724 conn->c_flags |= (C_CLOSE_NOTNEEDED | C_CLOSE_PENDING);
4725
4726 /*
4727 * Live connection in CONNECTED state.
4728 */
4729 if (conn->c_state == C_CONNECTED)
4730 conn->c_state = C_ERROR_CONN;
4731 mutex_exit(&conn->c_lock);
4732
4733 rib_close_a_channel(conn);
4734
4735 mutex_enter(&conn->c_lock);
4736 conn->c_flags &= ~C_CLOSE_PENDING;
4737 /* Signal a pending rib_disconnect_channel() */
4738 cv_signal(&conn->c_cv);
4739 }
4740 next:
4741 mutex_exit(&conn->c_lock);
4742 conn = tmp;
4743 }
4744 rw_exit(&connlist->conn_lock);
4745 }
4746
4747 /*
4748 * Frees up all connections that are no longer being referenced
4749 */
4750 static void
4751 rib_purge_connlist(rib_conn_list_t *connlist)
4752 {
4753 CONN *conn;
4754
4755 top:
4756 rw_enter(&connlist->conn_lock, RW_READER);
4757 conn = connlist->conn_hd;
4758 while (conn != NULL) {
4759 mutex_enter(&conn->c_lock);
4760
4761 /*
4762 * At this point connection is either in ERROR
4763 * or DISCONN_PEND state. If in DISCONN_PEND state
4764 * then some other thread is culling that connection.
4765 * If not and if c_ref is 0, then destroy the connection.
4766 */
4767 if (conn->c_ref == 0 &&
4768 conn->c_state != C_DISCONN_PEND) {
4769 /*
4770 * Cull the connection
4771 */
4772 conn->c_state = C_DISCONN_PEND;
4773 mutex_exit(&conn->c_lock);
4774 rw_exit(&connlist->conn_lock);
4775 (void) rib_disconnect_channel(conn, connlist);
4776 goto top;
4777 } else {
4778 /*
4779 * conn disconnect already scheduled or will
4780 * happen from conn_release when c_ref drops to 0.
4781 */
4782 mutex_exit(&conn->c_lock);
4783 }
4784 conn = conn->c_next;
4785 }
4786 rw_exit(&connlist->conn_lock);
4787
4788 /*
4789 * At this point, only connections with c_ref != 0 are on the list
4790 */
4791 }
4792
4793 /*
4794 * Free all the HCA resources and close
4795 * the hca.
4796 */
4797
4798 static void
4799 rib_free_hca(rib_hca_t *hca)
4800 {
4801 (void) ibt_free_cq(hca->clnt_rcq->rib_cq_hdl);
4802 (void) ibt_free_cq(hca->clnt_scq->rib_cq_hdl);
4803 (void) ibt_free_cq(hca->svc_rcq->rib_cq_hdl);
4804 (void) ibt_free_cq(hca->svc_scq->rib_cq_hdl);
4805
4806 kmem_free(hca->clnt_rcq, sizeof (rib_cq_t));
4807 kmem_free(hca->clnt_scq, sizeof (rib_cq_t));
4808 kmem_free(hca->svc_rcq, sizeof (rib_cq_t));
4809 kmem_free(hca->svc_scq, sizeof (rib_cq_t));
4810
4811 rib_rbufpool_destroy(hca, RECV_BUFFER);
4812 rib_rbufpool_destroy(hca, SEND_BUFFER);
4813 rib_destroy_cache(hca);
4814 if (rib_mod.rdma_count == 0)
4815 (void) rdma_unregister_mod(&rib_mod);
4816 (void) ibt_free_pd(hca->hca_hdl, hca->pd_hdl);
4817 (void) ibt_close_hca(hca->hca_hdl);
4818 hca->hca_hdl = NULL;
4819 }
4820
4821
4822 static void
4823 rib_stop_hca_services(rib_hca_t *hca)
4824 {
4825 rib_stop_services(hca);
4826 rib_close_channels(&hca->cl_conn_list);
4827 rib_close_channels(&hca->srv_conn_list);
4828
4829 rib_purge_connlist(&hca->cl_conn_list);
4830 rib_purge_connlist(&hca->srv_conn_list);
4831
4832 if ((rib_stat->hcas_list == NULL) && stats_enabled) {
4833 kstat_delete_byname_zone("unix", 0, "rpcib_cache",
4834 GLOBAL_ZONEID);
4835 stats_enabled = FALSE;
4836 }
4837
4838 rw_enter(&hca->srv_conn_list.conn_lock, RW_READER);
4839 rw_enter(&hca->cl_conn_list.conn_lock, RW_READER);
4840 if (hca->srv_conn_list.conn_hd == NULL &&
4841 hca->cl_conn_list.conn_hd == NULL) {
4842 /*
4843 * conn_lists are NULL, so destroy
4844 * buffers, close hca and be done.
4845 */
4846 rib_free_hca(hca);
4847 }
4848 rw_exit(&hca->cl_conn_list.conn_lock);
4849 rw_exit(&hca->srv_conn_list.conn_lock);
4850
4851 if (hca->hca_hdl != NULL) {
4852 mutex_enter(&hca->inuse_lock);
4853 while (hca->inuse)
4854 cv_wait(&hca->cb_cv, &hca->inuse_lock);
4855 mutex_exit(&hca->inuse_lock);
4856
4857 rib_free_hca(hca);
4858 }
4859 rw_destroy(&hca->bound_services_lock);
4860
4861 if (hca->cleanup_helper != NULL) {
4862 ddi_taskq_destroy(hca->cleanup_helper);
4863 hca->cleanup_helper = NULL;
4864 }
4865 }
4866
4867 /*
4868 * Cleans and closes up all uses of the HCA
4869 */
4870 static void
4871 rib_detach_hca(ibt_hca_hdl_t hca_hdl)
4872 {
4873 rib_hca_t *hca = NULL;
4874 rib_hca_t **hcap;
4875
4876 rw_enter(&rib_stat->hcas_list_lock, RW_WRITER);
4877 for (hcap = &rib_stat->hcas_list; *hcap; hcap = &(*hcap)->next) {
4878 hca = *hcap;
4879 rw_enter(&hca->state_lock, RW_WRITER);
4880 if (hca->hca_hdl == hca_hdl) {
4881 /*
4882 * Mark as detached and remove from
4883 * hca list.
4884 */
4885 hca->state = HCA_DETACHED;
4886 *hcap = hca->next;
4887 rib_stat->nhca_inited--;
4888 rib_mod.rdma_count--;
4889 rw_exit(&hca->state_lock);
4890 break;
4891 }
4892 rw_exit(&hca->state_lock);
4893 }
4894 rw_exit(&rib_stat->hcas_list_lock);
4895
4896 if (hca == NULL)
4897 return;
4898 ASSERT(hca->hca_hdl == hca_hdl);
4899
4900 /*
4901 * Stop all services on the HCA
4902 * Go through cl_conn_list and close all rc_channels
4903 * Go through svr_conn_list and close all rc_channels
4904 * Free connections whose c_ref has dropped to 0
4905 * Destroy all CQs
4906 * Deregister and released all buffer pool memory after all
4907 * connections are destroyed
4908 * Free the protection domain
4909 * ibt_close_hca()
4910 */
4911 rib_stop_hca_services(hca);
4912
4913 kmem_free(hca, sizeof (*hca));
4914 }
4915
4916 static void
4917 rib_server_side_cache_reclaim(void *argp)
4918 {
4919 cache_avl_struct_t *rcas;
4920 rib_lrc_entry_t *rb;
4921 rib_hca_t *hca = (rib_hca_t *)argp;
4922
4923 rw_enter(&hca->avl_rw_lock, RW_WRITER);
4924 rcas = avl_first(&hca->avl_tree);
4925 if (rcas != NULL)
4926 avl_remove(&hca->avl_tree, rcas);
4927
4928 while (rcas != NULL) {
4929 while (rcas->r.forw != &rcas->r) {
4930 rcas->elements--;
4931 rb = rcas->r.forw;
4932 remque(rb);
4933 if (rb->registered)
4934 (void) rib_deregistermem_via_hca(hca,
4935 rb->lrc_buf, rb->lrc_mhandle);
4936
4937 hca->cache_allocation -= rb->lrc_len;
4938 kmem_free(rb->lrc_buf, rb->lrc_len);
4939 kmem_free(rb, sizeof (rib_lrc_entry_t));
4940 }
4941 mutex_destroy(&rcas->node_lock);
4942 kmem_cache_free(hca->server_side_cache, rcas);
4943 rcas = avl_first(&hca->avl_tree);
4944 if (rcas != NULL)
4945 avl_remove(&hca->avl_tree, rcas);
4946 }
4947 rw_exit(&hca->avl_rw_lock);
4948 }
4949
4950 static void
4951 rib_server_side_cache_cleanup(void *argp)
4952 {
4953 cache_avl_struct_t *rcas;
4954 rib_lrc_entry_t *rb;
4955 rib_hca_t *hca = (rib_hca_t *)argp;
4956
4957 mutex_enter(&hca->cache_allocation_lock);
4958 if (hca->cache_allocation < cache_limit) {
4959 mutex_exit(&hca->cache_allocation_lock);
4960 return;
4961 }
4962 mutex_exit(&hca->cache_allocation_lock);
4963
4964 rw_enter(&hca->avl_rw_lock, RW_WRITER);
4965 rcas = avl_last(&hca->avl_tree);
4966 if (rcas != NULL)
4967 avl_remove(&hca->avl_tree, rcas);
4968
4969 while (rcas != NULL) {
4970 while (rcas->r.forw != &rcas->r) {
4971 rcas->elements--;
4972 rb = rcas->r.forw;
4973 remque(rb);
4974 if (rb->registered)
4975 (void) rib_deregistermem_via_hca(hca,
4976 rb->lrc_buf, rb->lrc_mhandle);
4977
4978 hca->cache_allocation -= rb->lrc_len;
4979
4980 kmem_free(rb->lrc_buf, rb->lrc_len);
4981 kmem_free(rb, sizeof (rib_lrc_entry_t));
4982 }
4983 mutex_destroy(&rcas->node_lock);
4984 if (hca->server_side_cache) {
4985 kmem_cache_free(hca->server_side_cache, rcas);
4986 }
4987
4988 if (hca->cache_allocation < cache_limit) {
4989 rw_exit(&hca->avl_rw_lock);
4990 return;
4991 }
4992
4993 rcas = avl_last(&hca->avl_tree);
4994 if (rcas != NULL)
4995 avl_remove(&hca->avl_tree, rcas);
4996 }
4997 rw_exit(&hca->avl_rw_lock);
4998 }
4999
5000 static int
5001 avl_compare(const void *t1, const void *t2)
5002 {
5003 if (((cache_avl_struct_t *)t1)->len == ((cache_avl_struct_t *)t2)->len)
5004 return (0);
5005
5006 if (((cache_avl_struct_t *)t1)->len < ((cache_avl_struct_t *)t2)->len)
5007 return (-1);
5008
5009 return (1);
5010 }
5011
5012 static void
5013 rib_destroy_cache(rib_hca_t *hca)
5014 {
5015 if (hca->avl_init) {
5016 rib_server_side_cache_reclaim((void *)hca);
5017 if (hca->server_side_cache) {
5018 kmem_cache_destroy(hca->server_side_cache);
5019 hca->server_side_cache = NULL;
5020 }
5021 avl_destroy(&hca->avl_tree);
5022 mutex_destroy(&hca->cache_allocation_lock);
5023 rw_destroy(&hca->avl_rw_lock);
5024 }
5025 hca->avl_init = FALSE;
5026 }
5027
5028 static void
5029 rib_force_cleanup(void *hca)
5030 {
5031 if (((rib_hca_t *)hca)->cleanup_helper != NULL)
5032 (void) ddi_taskq_dispatch(
5033 ((rib_hca_t *)hca)->cleanup_helper,
5034 rib_server_side_cache_cleanup,
5035 (void *)hca, DDI_NOSLEEP);
5036 }
5037
5038 static rib_lrc_entry_t *
5039 rib_get_cache_buf(CONN *conn, uint32_t len)
5040 {
5041 cache_avl_struct_t cas, *rcas;
5042 rib_hca_t *hca = (ctoqp(conn))->hca;
5043 rib_lrc_entry_t *reply_buf;
5044 avl_index_t where = NULL;
5045 uint64_t c_alloc = 0;
5046
5047 if (!hca->avl_init)
5048 goto error_alloc;
5049
5050 cas.len = len;
5051
5052 rw_enter(&hca->avl_rw_lock, RW_READER);
5053
5054 mutex_enter(&hca->cache_allocation_lock);
5055 c_alloc = hca->cache_allocation;
5056 mutex_exit(&hca->cache_allocation_lock);
5057
5058 if ((rcas = (cache_avl_struct_t *)avl_find(&hca->avl_tree, &cas,
5059 &where)) == NULL) {
5060 /* Am I above the cache limit */
5061 if ((c_alloc + len) >= cache_limit) {
5062 rib_force_cleanup((void *)hca);
5063 rw_exit(&hca->avl_rw_lock);
5064 mutex_enter(&hca->cache_allocation_lock);
5065 hca->cache_misses_above_the_limit ++;
5066 mutex_exit(&hca->cache_allocation_lock);
5067
5068 /* Allocate and register the buffer directly */
5069 goto error_alloc;
5070 }
5071
5072 rw_exit(&hca->avl_rw_lock);
5073 rw_enter(&hca->avl_rw_lock, RW_WRITER);
5074
5075 /* Recheck to make sure no other thread added the entry in */
5076 if ((rcas = (cache_avl_struct_t *)avl_find(&hca->avl_tree,
5077 &cas, &where)) == NULL) {
5078 /* Allocate an avl tree entry */
5079 rcas = (cache_avl_struct_t *)
5080 kmem_cache_alloc(hca->server_side_cache, KM_SLEEP);
5081
5082 bzero(rcas, sizeof (cache_avl_struct_t));
5083 rcas->elements = 0;
5084 rcas->r.forw = &rcas->r;
5085 rcas->r.back = &rcas->r;
5086 rcas->len = len;
5087 mutex_init(&rcas->node_lock, NULL, MUTEX_DEFAULT, NULL);
5088 avl_insert(&hca->avl_tree, rcas, where);
5089 }
5090 }
5091
5092 mutex_enter(&rcas->node_lock);
5093
5094 if (rcas->r.forw != &rcas->r && rcas->elements > 0) {
5095 reply_buf = rcas->r.forw;
5096 remque(reply_buf);
5097 rcas->elements--;
5098 mutex_exit(&rcas->node_lock);
5099 rw_exit(&hca->avl_rw_lock);
5100
5101 mutex_enter(&hca->cache_allocation_lock);
5102 hca->cache_hits++;
5103 hca->cache_allocation -= len;
5104 mutex_exit(&hca->cache_allocation_lock);
5105 } else {
5106 /* Am I above the cache limit */
5107 mutex_exit(&rcas->node_lock);
5108 if ((c_alloc + len) >= cache_limit) {
5109 rib_force_cleanup((void *)hca);
5110 rw_exit(&hca->avl_rw_lock);
5111
5112 mutex_enter(&hca->cache_allocation_lock);
5113 hca->cache_misses_above_the_limit++;
5114 mutex_exit(&hca->cache_allocation_lock);
5115 /* Allocate and register the buffer directly */
5116 goto error_alloc;
5117 }
5118 rw_exit(&hca->avl_rw_lock);
5119 mutex_enter(&hca->cache_allocation_lock);
5120 hca->cache_misses++;
5121 mutex_exit(&hca->cache_allocation_lock);
5122 /* Allocate a reply_buf entry */
5123 reply_buf = (rib_lrc_entry_t *)
5124 kmem_zalloc(sizeof (rib_lrc_entry_t), KM_SLEEP);
5125 bzero(reply_buf, sizeof (rib_lrc_entry_t));
5126 reply_buf->lrc_buf = kmem_alloc(len, KM_SLEEP);
5127 reply_buf->lrc_len = len;
5128 reply_buf->registered = FALSE;
5129 reply_buf->avl_node = (void *)rcas;
5130 }
5131
5132 return (reply_buf);
5133
5134 error_alloc:
5135 reply_buf = (rib_lrc_entry_t *)
5136 kmem_zalloc(sizeof (rib_lrc_entry_t), KM_SLEEP);
5137 bzero(reply_buf, sizeof (rib_lrc_entry_t));
5138 reply_buf->lrc_buf = kmem_alloc(len, KM_SLEEP);
5139 reply_buf->lrc_len = len;
5140 reply_buf->registered = FALSE;
5141 reply_buf->avl_node = NULL;
5142
5143 return (reply_buf);
5144 }
5145
5146 /*
5147 * Return a pre-registered back to the cache (without
5148 * unregistering the buffer)..
5149 */
5150
5151 static void
5152 rib_free_cache_buf(CONN *conn, rib_lrc_entry_t *reg_buf)
5153 {
5154 cache_avl_struct_t cas, *rcas;
5155 avl_index_t where = NULL;
5156 rib_hca_t *hca = (ctoqp(conn))->hca;
5157
5158 if (!hca->avl_init)
5159 goto error_free;
5160
5161 cas.len = reg_buf->lrc_len;
5162 rw_enter(&hca->avl_rw_lock, RW_READER);
5163 if ((rcas = (cache_avl_struct_t *)
5164 avl_find(&hca->avl_tree, &cas, &where)) == NULL) {
5165 rw_exit(&hca->avl_rw_lock);
5166 goto error_free;
5167 } else {
5168 cas.len = reg_buf->lrc_len;
5169 mutex_enter(&rcas->node_lock);
5170 insque(reg_buf, &rcas->r);
5171 rcas->elements ++;
5172 mutex_exit(&rcas->node_lock);
5173 rw_exit(&hca->avl_rw_lock);
5174 mutex_enter(&hca->cache_allocation_lock);
5175 hca->cache_allocation += cas.len;
5176 mutex_exit(&hca->cache_allocation_lock);
5177 }
5178
5179 return;
5180
5181 error_free:
5182
5183 if (reg_buf->registered)
5184 (void) rib_deregistermem_via_hca(hca,
5185 reg_buf->lrc_buf, reg_buf->lrc_mhandle);
5186 kmem_free(reg_buf->lrc_buf, reg_buf->lrc_len);
5187 kmem_free(reg_buf, sizeof (rib_lrc_entry_t));
5188 }
5189
5190 static rdma_stat
5191 rib_registermem_via_hca(rib_hca_t *hca, caddr_t adsp, caddr_t buf,
5192 uint_t buflen, struct mrc *buf_handle)
5193 {
5194 ibt_mr_hdl_t mr_hdl = NULL; /* memory region handle */
5195 ibt_mr_desc_t mr_desc; /* vaddr, lkey, rkey */
5196 rdma_stat status;
5197
5198
5199 /*
5200 * Note: ALL buffer pools use the same memory type RDMARW.
5201 */
5202 status = rib_reg_mem(hca, adsp, buf, buflen, 0, &mr_hdl, &mr_desc);
5203 if (status == RDMA_SUCCESS) {
5204 buf_handle->mrc_linfo = (uint64_t)(uintptr_t)mr_hdl;
5205 buf_handle->mrc_lmr = (uint32_t)mr_desc.md_lkey;
5206 buf_handle->mrc_rmr = (uint32_t)mr_desc.md_rkey;
5207 } else {
5208 buf_handle->mrc_linfo = NULL;
5209 buf_handle->mrc_lmr = 0;
5210 buf_handle->mrc_rmr = 0;
5211 }
5212 return (status);
5213 }
5214
5215 /* ARGSUSED */
5216 static rdma_stat
5217 rib_deregistermemsync_via_hca(rib_hca_t *hca, caddr_t buf,
5218 struct mrc buf_handle, RIB_SYNCMEM_HANDLE sync_handle)
5219 {
5220
5221 (void) rib_deregistermem_via_hca(hca, buf, buf_handle);
5222 return (RDMA_SUCCESS);
5223 }
5224
5225 /* ARGSUSED */
5226 static rdma_stat
5227 rib_deregistermem_via_hca(rib_hca_t *hca, caddr_t buf, struct mrc buf_handle)
5228 {
5229
5230 (void) ibt_deregister_mr(hca->hca_hdl,
5231 (ibt_mr_hdl_t)(uintptr_t)buf_handle.mrc_linfo);
5232 return (RDMA_SUCCESS);
5233 }
5234
5235 /*
5236 * Check if the IP interface named by `lifrp' is RDMA-capable.
5237 */
5238 static boolean_t
5239 rpcib_rdma_capable_interface(struct lifreq *lifrp)
5240 {
5241 char ifname[LIFNAMSIZ];
5242 char *cp;
5243
5244 if (lifrp->lifr_type == IFT_IB)
5245 return (B_TRUE);
5246
5247 /*
5248 * Strip off the logical interface portion before getting
5249 * intimate with the name.
5250 */
5251 (void) strlcpy(ifname, lifrp->lifr_name, LIFNAMSIZ);
5252 if ((cp = strchr(ifname, ':')) != NULL)
5253 *cp = '\0';
5254
5255 return (strcmp("lo0", ifname) == 0);
5256 }
5257
5258 static int
5259 rpcib_do_ip_ioctl(int cmd, int len, void *arg)
5260 {
5261 vnode_t *kkvp, *vp;
5262 TIUSER *tiptr;
5263 struct strioctl iocb;
5264 k_sigset_t smask;
5265 int err = 0;
5266
5267 if (lookupname("/dev/udp", UIO_SYSSPACE, FOLLOW, NULLVPP, &kkvp) == 0) {
5268 if (t_kopen(NULL, kkvp->v_rdev, FREAD|FWRITE,
5269 &tiptr, CRED()) == 0) {
5270 vp = tiptr->fp->f_vnode;
5271 } else {
5272 VN_RELE(kkvp);
5273 return (EPROTO);
5274 }
5275 } else {
5276 return (EPROTO);
5277 }
5278
5279 iocb.ic_cmd = cmd;
5280 iocb.ic_timout = 0;
5281 iocb.ic_len = len;
5282 iocb.ic_dp = (caddr_t)arg;
5283 sigintr(&smask, 0);
5284 err = kstr_ioctl(vp, I_STR, (intptr_t)&iocb);
5285 sigunintr(&smask);
5286 (void) t_kclose(tiptr, 0);
5287 VN_RELE(kkvp);
5288 return (err);
5289 }
5290
5291 /*
5292 * Issue an SIOCGLIFCONF down to IP and return the result in `lifcp'.
5293 * lifcp->lifc_buf is dynamically allocated to be *bufsizep bytes.
5294 */
5295 static int
5296 rpcib_do_lifconf(struct lifconf *lifcp, uint_t *bufsizep)
5297 {
5298 int err;
5299 struct lifnum lifn;
5300
5301 bzero(&lifn, sizeof (struct lifnum));
5302 lifn.lifn_family = AF_UNSPEC;
5303
5304 err = rpcib_do_ip_ioctl(SIOCGLIFNUM, sizeof (struct lifnum), &lifn);
5305 if (err != 0)
5306 return (err);
5307
5308 /*
5309 * Pad the interface count to account for additional interfaces that
5310 * may have been configured between the SIOCGLIFNUM and SIOCGLIFCONF.
5311 */
5312 lifn.lifn_count += 4;
5313
5314 bzero(lifcp, sizeof (struct lifconf));
5315 lifcp->lifc_family = AF_UNSPEC;
5316 lifcp->lifc_len = *bufsizep = lifn.lifn_count * sizeof (struct lifreq);
5317 lifcp->lifc_buf = kmem_zalloc(*bufsizep, KM_SLEEP);
5318
5319 err = rpcib_do_ip_ioctl(SIOCGLIFCONF, sizeof (struct lifconf), lifcp);
5320 if (err != 0) {
5321 kmem_free(lifcp->lifc_buf, *bufsizep);
5322 return (err);
5323 }
5324 return (0);
5325 }
5326
5327 static boolean_t
5328 rpcib_get_ib_addresses(rpcib_ipaddrs_t *addrs4, rpcib_ipaddrs_t *addrs6)
5329 {
5330 uint_t i, nifs;
5331 uint_t bufsize;
5332 struct lifconf lifc;
5333 struct lifreq *lifrp;
5334 struct sockaddr_in *sinp;
5335 struct sockaddr_in6 *sin6p;
5336
5337 bzero(addrs4, sizeof (rpcib_ipaddrs_t));
5338 bzero(addrs6, sizeof (rpcib_ipaddrs_t));
5339
5340 if (rpcib_do_lifconf(&lifc, &bufsize) != 0)
5341 return (B_FALSE);
5342
5343 if ((nifs = lifc.lifc_len / sizeof (struct lifreq)) == 0) {
5344 kmem_free(lifc.lifc_buf, bufsize);
5345 return (B_FALSE);
5346 }
5347
5348 /*
5349 * Worst case is that all of the addresses are IB-capable and have
5350 * the same address family, so size our buffers accordingly.
5351 */
5352 addrs4->ri_size = nifs * sizeof (struct sockaddr_in);
5353 addrs4->ri_list = kmem_zalloc(addrs4->ri_size, KM_SLEEP);
5354 addrs6->ri_size = nifs * sizeof (struct sockaddr_in6);
5355 addrs6->ri_list = kmem_zalloc(addrs6->ri_size, KM_SLEEP);
5356
5357 for (lifrp = lifc.lifc_req, i = 0; i < nifs; i++, lifrp++) {
5358 if (!rpcib_rdma_capable_interface(lifrp))
5359 continue;
5360
5361 if (lifrp->lifr_addr.ss_family == AF_INET) {
5362 sinp = addrs4->ri_list;
5363 bcopy(&lifrp->lifr_addr, &sinp[addrs4->ri_count++],
5364 sizeof (struct sockaddr_in));
5365 } else if (lifrp->lifr_addr.ss_family == AF_INET6) {
5366 sin6p = addrs6->ri_list;
5367 bcopy(&lifrp->lifr_addr, &sin6p[addrs6->ri_count++],
5368 sizeof (struct sockaddr_in6));
5369 }
5370 }
5371
5372 kmem_free(lifc.lifc_buf, bufsize);
5373 return (B_TRUE);
5374 }
5375
5376 /* ARGSUSED */
5377 static int
5378 rpcib_cache_kstat_update(kstat_t *ksp, int rw)
5379 {
5380 rib_hca_t *hca;
5381
5382 if (KSTAT_WRITE == rw) {
5383 return (EACCES);
5384 }
5385
5386 rpcib_kstat.cache_limit.value.ui64 =
5387 (uint64_t)cache_limit;
5388 rw_enter(&rib_stat->hcas_list_lock, RW_READER);
5389 for (hca = rib_stat->hcas_list; hca; hca = hca->next) {
5390 rpcib_kstat.cache_allocation.value.ui64 +=
5391 (uint64_t)hca->cache_allocation;
5392 rpcib_kstat.cache_hits.value.ui64 +=
5393 (uint64_t)hca->cache_hits;
5394 rpcib_kstat.cache_misses.value.ui64 +=
5395 (uint64_t)hca->cache_misses;
5396 rpcib_kstat.cache_misses_above_the_limit.value.ui64 +=
5397 (uint64_t)hca->cache_misses_above_the_limit;
5398 }
5399 rw_exit(&rib_stat->hcas_list_lock);
5400 return (0);
5401 }