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 /*
23 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 *
26 * UDAPL kernel agent
27 */
28
29 #include <sys/types.h>
30 #include <sys/errno.h>
31 #include <sys/debug.h>
32 #include <sys/stropts.h>
33 #include <sys/stream.h>
34 #include <sys/strlog.h>
35 #include <sys/cmn_err.h>
36 #include <sys/kmem.h>
37 #include <sys/conf.h>
38 #include <sys/stat.h>
39 #include <sys/modctl.h>
40 #include <sys/kstat.h>
41 #include <sys/ddi.h>
42 #include <sys/sunddi.h>
43 #include <sys/strsun.h>
44 #include <sys/taskq.h>
45 #include <sys/open.h>
46 #include <sys/uio.h>
47 #include <sys/cpuvar.h>
48 #include <sys/atomic.h>
49 #include <sys/sysmacros.h>
50 #include <sys/esunddi.h>
51 #include <sys/avl.h>
52 #include <sys/cred.h>
53 #include <sys/note.h>
54 #include <sys/ib/ibtl/ibti.h>
55 #include <sys/socket.h>
56 #include <netinet/in.h>
57 #include <daplt_if.h>
58 #include <daplt.h>
59
60 /*
61 * The following variables support the debug log buffer scheme.
62 */
63 #ifdef DEBUG
64 static char daplka_dbgbuf[0x80000];
65 #else /* DEBUG */
66 static char daplka_dbgbuf[0x4000];
67 #endif /* DEBUG */
68 static int daplka_dbgsize = sizeof (daplka_dbgbuf);
69 static size_t daplka_dbgnext;
70 static int daplka_dbginit = 0;
71 static kmutex_t daplka_dbglock;
72 _NOTE(MUTEX_PROTECTS_DATA(daplka_dbglock,
73 daplka_dbgbuf
74 daplka_dbgnext))
75
76 static int daplka_dbg = 0x0103;
77 static void daplka_console(const char *, ...);
78 static void daplka_debug(const char *, ...);
79 static int daplka_apm = 0x1; /* default enable */
80 static int daplka_failback = 0x1; /* default enable */
81 static int daplka_query_aft_setaltpath = 10;
82
83 #define DERR \
84 if (daplka_dbg & 0x100) \
85 daplka_debug
86
87 #ifdef DEBUG
88
89 #define DINFO \
90 daplka_console
91
92 #define D1 \
93 if (daplka_dbg & 0x01) \
94 daplka_debug
95 #define D2 \
96 if (daplka_dbg & 0x02) \
97 daplka_debug
98 #define D3 \
99 if (daplka_dbg & 0x04) \
100 daplka_debug
101 #define D4 \
102 if (daplka_dbg & 0x08) \
103 daplka_debug
104
105 #else /* DEBUG */
106
107 #define DINFO if (0) printf
108 #define D1 if (0) printf
109 #define D2 if (0) printf
110 #define D3 if (0) printf
111 #define D4 if (0) printf
112
113 #endif /* DEBUG */
114
115 /*
116 * driver entry points
117 */
118 static int daplka_open(dev_t *, int, int, struct cred *);
119 static int daplka_close(dev_t, int, int, struct cred *);
120 static int daplka_attach(dev_info_t *, ddi_attach_cmd_t);
121 static int daplka_detach(dev_info_t *, ddi_detach_cmd_t);
122 static int daplka_info(dev_info_t *, ddi_info_cmd_t, void *, void **);
123 static int daplka_ioctl(dev_t, int, intptr_t, int, cred_t *, int *);
124
125 /*
126 * types of ioctls
127 */
128 static int daplka_common_ioctl(int, minor_t, intptr_t, int, cred_t *, int *);
129 static int daplka_misc_ioctl(int, daplka_ia_resource_t *, intptr_t, int,
130 cred_t *, int *);
131 static int daplka_ep_ioctl(int, daplka_ia_resource_t *, intptr_t, int,
132 cred_t *, int *);
133 static int daplka_evd_ioctl(int, daplka_ia_resource_t *, intptr_t, int,
134 cred_t *, int *);
135 static int daplka_mr_ioctl(int, daplka_ia_resource_t *, intptr_t, int,
136 cred_t *, int *);
137 static int daplka_cno_ioctl(int, daplka_ia_resource_t *, intptr_t, int,
138 cred_t *, int *);
139 static int daplka_pd_ioctl(int, daplka_ia_resource_t *, intptr_t, int,
140 cred_t *, int *);
141 static int daplka_sp_ioctl(int, daplka_ia_resource_t *, intptr_t, int,
142 cred_t *, int *);
143 static int daplka_srq_ioctl(int, daplka_ia_resource_t *, intptr_t, int,
144 cred_t *, int *);
145
146 /*
147 * common ioctls and supporting functions
148 */
149 static int daplka_ia_create(minor_t, intptr_t, int, cred_t *, int *);
150 static int daplka_ia_destroy(daplka_resource_t *);
151
152 /*
153 * EP ioctls and supporting functions
154 */
155 static int daplka_ep_create(daplka_ia_resource_t *, intptr_t, int,
156 cred_t *, int *);
157 static int daplka_ep_modify(daplka_ia_resource_t *, intptr_t, int,
158 cred_t *, int *);
159 static int daplka_ep_free(daplka_ia_resource_t *, intptr_t, int,
160 cred_t *, int *);
161 static int daplka_ep_connect(daplka_ia_resource_t *, intptr_t, int,
162 cred_t *, int *);
163 static int daplka_ep_disconnect(daplka_ia_resource_t *, intptr_t, int,
164 cred_t *, int *);
165 static int daplka_ep_reinit(daplka_ia_resource_t *, intptr_t, int,
166 cred_t *, int *);
167 static int daplka_ep_destroy(daplka_resource_t *);
168 static void daplka_hash_ep_free(void *);
169 static int daplka_ep_failback(void *objp, void *arg);
170 static int daplka_ep_altpath(daplka_ep_resource_t *, ib_gid_t *);
171
172 static uint32_t daplka_ep_get_state(daplka_ep_resource_t *);
173 static void daplka_ep_set_state(daplka_ep_resource_t *, uint32_t, uint32_t);
174 static boolean_t daplka_ep_transition_is_valid(uint32_t, uint32_t);
175 static daplka_timer_info_t *daplka_timer_info_alloc(daplka_ep_resource_t *);
176 static void daplka_timer_info_free(daplka_timer_info_t *);
177 static void daplka_timer_handler(void *);
178 static void daplka_timer_dispatch(void *);
179 static void daplka_timer_thread(void *);
180 static int daplka_cancel_timer(daplka_ep_resource_t *);
181 static void daplka_hash_timer_free(void *);
182
183 /*
184 * EVD ioctls and supporting functions
185 */
186 static int daplka_evd_create(daplka_ia_resource_t *, intptr_t, int,
187 cred_t *, int *);
188 static int daplka_cq_resize(daplka_ia_resource_t *, intptr_t, int,
189 cred_t *, int *);
190 static int daplka_evd_free(daplka_ia_resource_t *, intptr_t, int,
191 cred_t *, int *);
192 static int daplka_event_poll(daplka_ia_resource_t *, intptr_t, int,
193 cred_t *, int *);
194 static int daplka_evd_destroy(daplka_resource_t *);
195 static void daplka_cq_handler(ibt_cq_hdl_t, void *);
196 static void daplka_evd_wakeup(daplka_evd_resource_t *,
197 daplka_evd_event_list_t *, daplka_evd_event_t *);
198 static void daplka_evd_event_enqueue(daplka_evd_event_list_t *,
199 daplka_evd_event_t *);
200 static daplka_evd_event_t *daplka_evd_event_dequeue(daplka_evd_event_list_t *);
201 static void daplka_hash_evd_free(void *);
202
203
204 /*
205 * SRQ ioctls and supporting functions
206 */
207 static int daplka_srq_create(daplka_ia_resource_t *, intptr_t, int,
208 cred_t *, int *);
209 static int daplka_srq_resize(daplka_ia_resource_t *, intptr_t, int,
210 cred_t *, int *);
211 static int daplka_srq_free(daplka_ia_resource_t *, intptr_t, int,
212 cred_t *, int *);
213 static int daplka_srq_destroy(daplka_resource_t *);
214 static void daplka_hash_srq_free(void *);
215
216 /*
217 * Miscellaneous ioctls
218 */
219 static int daplka_cr_accept(daplka_ia_resource_t *, intptr_t, int,
220 cred_t *, int *);
221 static int daplka_cr_reject(daplka_ia_resource_t *, intptr_t, int,
222 cred_t *, int *);
223 static int daplka_cr_handoff(daplka_ia_resource_t *, intptr_t, int,
224 cred_t *, int *);
225 static int daplka_ia_query(daplka_ia_resource_t *, intptr_t, int,
226 cred_t *, int *);
227
228 /*
229 * PD ioctls and supporting functions
230 */
231 static int daplka_pd_alloc(daplka_ia_resource_t *, intptr_t, int,
232 cred_t *, int *);
233 static int daplka_pd_free(daplka_ia_resource_t *, intptr_t, int,
234 cred_t *, int *);
235 static int daplka_pd_destroy(daplka_resource_t *);
236 static void daplka_hash_pd_free(void *);
237
238 /*
239 * SP ioctls and supporting functions
240 */
241 static int daplka_service_register(daplka_ia_resource_t *, intptr_t, int,
242 cred_t *, int *);
243 static int daplka_service_deregister(daplka_ia_resource_t *, intptr_t, int,
244 cred_t *, int *);
245 static int daplka_sp_destroy(daplka_resource_t *);
246 static void daplka_hash_sp_free(void *);
247 static void daplka_hash_sp_unref(void *);
248
249 /*
250 * MR ioctls and supporting functions
251 */
252 static int daplka_mr_register(daplka_ia_resource_t *, intptr_t, int,
253 cred_t *, int *);
254 static int daplka_mr_register_lmr(daplka_ia_resource_t *, intptr_t, int,
255 cred_t *, int *);
256 static int daplka_mr_register_shared(daplka_ia_resource_t *, intptr_t, int,
257 cred_t *, int *);
258 static int daplka_mr_deregister(daplka_ia_resource_t *, intptr_t, int,
259 cred_t *, int *);
260 static int daplka_mr_sync(daplka_ia_resource_t *, intptr_t, int,
261 cred_t *, int *);
262 static int daplka_mr_destroy(daplka_resource_t *);
263 static void daplka_hash_mr_free(void *);
264 static void daplka_shared_mr_free(daplka_mr_resource_t *);
265
266 /*
267 * MW ioctls and supporting functions
268 */
269 static int daplka_mw_alloc(daplka_ia_resource_t *, intptr_t, int,
270 cred_t *, int *);
271 static int daplka_mw_free(daplka_ia_resource_t *, intptr_t, int,
272 cred_t *, int *);
273 static int daplka_mw_destroy(daplka_resource_t *);
274 static void daplka_hash_mw_free(void *);
275
276 /*
277 * CNO ioctls and supporting functions
278 */
279 static int daplka_cno_alloc(daplka_ia_resource_t *, intptr_t, int,
280 cred_t *, int *);
281 static int daplka_cno_free(daplka_ia_resource_t *, intptr_t, int,
282 cred_t *, int *);
283 static int daplka_cno_wait(daplka_ia_resource_t *, intptr_t, int,
284 cred_t *, int *);
285 static int daplka_cno_destroy(daplka_resource_t *);
286 static void daplka_hash_cno_free(void *);
287
288 /*
289 * CM handlers
290 */
291 static ibt_cm_status_t daplka_cm_rc_handler(void *, ibt_cm_event_t *,
292 ibt_cm_return_args_t *, void *, ibt_priv_data_len_t);
293
294 static ibt_cm_status_t daplka_cm_service_handler(void *, ibt_cm_event_t *,
295 ibt_cm_return_args_t *, void *, ibt_priv_data_len_t);
296
297 static ibt_cm_status_t daplka_cm_service_req(daplka_sp_resource_t *,
298 ibt_cm_event_t *, ibt_cm_return_args_t *, void *, ibt_priv_data_len_t);
299
300 /*
301 * resource management routines
302 */
303 static int daplka_resource_reserve(minor_t *);
304 static int daplka_resource_insert(minor_t, daplka_resource_t *);
305 static daplka_resource_t *daplka_resource_remove(minor_t rnum);
306 static daplka_resource_t *daplka_resource_lookup(minor_t);
307 static void daplka_resource_init(void);
308 static void daplka_resource_fini(void);
309 static struct daplka_resource_table daplka_resource;
310
311 /*
312 * hash table routines
313 */
314 static int daplka_hash_insert(daplka_hash_table_t *, uint64_t *, void *);
315 static int daplka_hash_remove(daplka_hash_table_t *, uint64_t, void **);
316 static void daplka_hash_walk(daplka_hash_table_t *, int (*)(void *, void *),
317 void *, krw_t);
318 static void *daplka_hash_lookup(daplka_hash_table_t *, uint64_t);
319 static int daplka_hash_create(daplka_hash_table_t *, uint_t,
320 void (*)(void *), void (*)(void *));
321 static void daplka_hash_destroy(daplka_hash_table_t *);
322 static uint32_t daplka_hash_getsize(daplka_hash_table_t *);
323 static void daplka_hash_generic_lookup(void *);
324
325 static uint32_t daplka_timer_hkey_gen();
326
327 /*
328 * async event handlers
329 */
330 static void daplka_async_event_create(ibt_async_code_t, ibt_async_event_t *,
331 uint64_t, daplka_ia_resource_t *);
332 static void daplka_rc_async_handler(void *, ibt_hca_hdl_t, ibt_async_code_t,
333 ibt_async_event_t *);
334 static void daplka_cq_async_handler(void *, ibt_hca_hdl_t, ibt_async_code_t,
335 ibt_async_event_t *);
336 static void daplka_un_async_handler(void *, ibt_hca_hdl_t, ibt_async_code_t,
337 ibt_async_event_t *);
338 static void daplka_async_handler(void *, ibt_hca_hdl_t, ibt_async_code_t,
339 ibt_async_event_t *);
340 static void daplka_sm_notice_handler(void *, ib_gid_t, ibt_subnet_event_code_t,
341 ibt_subnet_event_t *event);
342 static void daplka_sm_gid_avail(ib_gid_t *, ib_gid_t *);
343
344 /*
345 * IBTF wrappers and default limits used for resource accounting
346 */
347 static boolean_t daplka_accounting_enabled = B_TRUE;
348 static uint32_t daplka_max_qp_percent = 100;
349 static uint32_t daplka_max_cq_percent = 100;
350 static uint32_t daplka_max_pd_percent = 100;
351 static uint32_t daplka_max_mw_percent = 100;
352 static uint32_t daplka_max_mr_percent = 100;
353 static uint32_t daplka_max_srq_percent = 100;
354
355 static ibt_status_t
356 daplka_ibt_alloc_rc_channel(daplka_ep_resource_t *, ibt_hca_hdl_t,
357 ibt_chan_alloc_flags_t, ibt_rc_chan_alloc_args_t *,
358 ibt_channel_hdl_t *, ibt_chan_sizes_t *);
359
360 static ibt_status_t
361 daplka_ibt_free_channel(daplka_ep_resource_t *, ibt_channel_hdl_t);
362
363 static ibt_status_t
364 daplka_ibt_alloc_cq(daplka_evd_resource_t *, ibt_hca_hdl_t,
365 ibt_cq_attr_t *, ibt_cq_hdl_t *, uint_t *);
366
367 static ibt_status_t
368 daplka_ibt_free_cq(daplka_evd_resource_t *, ibt_cq_hdl_t);
369
370 static ibt_status_t
371 daplka_ibt_alloc_pd(daplka_pd_resource_t *, ibt_hca_hdl_t,
372 ibt_pd_flags_t, ibt_pd_hdl_t *);
373
374 static ibt_status_t
375 daplka_ibt_free_pd(daplka_pd_resource_t *, ibt_hca_hdl_t, ibt_pd_hdl_t);
376
377 static ibt_status_t
378 daplka_ibt_alloc_mw(daplka_mw_resource_t *, ibt_hca_hdl_t, ibt_pd_hdl_t,
379 ibt_mw_flags_t, ibt_mw_hdl_t *, ibt_rkey_t *);
380
381 static ibt_status_t
382 daplka_ibt_free_mw(daplka_mw_resource_t *, ibt_hca_hdl_t, ibt_mw_hdl_t);
383
384 static ibt_status_t
385 daplka_ibt_register_mr(daplka_mr_resource_t *, ibt_hca_hdl_t, ibt_pd_hdl_t,
386 ibt_mr_attr_t *, ibt_mr_hdl_t *, ibt_mr_desc_t *);
387
388 static ibt_status_t
389 daplka_ibt_register_shared_mr(daplka_mr_resource_t *, ibt_hca_hdl_t,
390 ibt_mr_hdl_t, ibt_pd_hdl_t, ibt_smr_attr_t *, ibt_mr_hdl_t *,
391 ibt_mr_desc_t *);
392
393 static ibt_status_t
394 daplka_ibt_deregister_mr(daplka_mr_resource_t *, ibt_hca_hdl_t, ibt_mr_hdl_t);
395
396 static ibt_status_t
397 daplka_ibt_alloc_srq(daplka_srq_resource_t *, ibt_hca_hdl_t, ibt_srq_flags_t,
398 ibt_pd_hdl_t, ibt_srq_sizes_t *, ibt_srq_hdl_t *, ibt_srq_sizes_t *);
399
400 static ibt_status_t
401 daplka_ibt_free_srq(daplka_srq_resource_t *, ibt_srq_hdl_t);
402
403 /*
404 * macros for manipulating resource objects.
405 * these macros can be used on objects that begin with a
406 * daplka_resource_t header.
407 */
408 #define DAPLKA_RS_REFCNT(rp) ((rp)->header.rs_refcnt)
409
410 #define DAPLKA_RS_REF(rp) { \
411 mutex_enter(&(rp)->header.rs_reflock); \
412 (rp)->header.rs_refcnt++; \
413 ASSERT((rp)->header.rs_refcnt != 0); \
414 mutex_exit(&(rp)->header.rs_reflock); \
415 }
416
417 #define DAPLKA_RS_UNREF(rp) { \
418 mutex_enter(&(rp)->header.rs_reflock); \
419 ASSERT((rp)->header.rs_refcnt != 0); \
420 if (--(rp)->header.rs_refcnt == 0) { \
421 ASSERT((rp)->header.rs_free != NULL); \
422 mutex_exit(&(rp)->header.rs_reflock); \
423 (rp)->header.rs_free((daplka_resource_t *)rp); \
424 } else { \
425 mutex_exit(&(rp)->header.rs_reflock); \
426 } \
427 }
428
429 #define DAPLKA_RS_INIT(rp, type, rnum, free_func) { \
430 (rp)->header.rs_refcnt = 1; \
431 (rp)->header.rs_type = (type); \
432 (rp)->header.rs_rnum = (rnum); \
433 (rp)->header.rs_charged = 0; \
434 (rp)->header.rs_free = (free_func); \
435 mutex_init(&(rp)->header.rs_reflock, NULL, \
436 MUTEX_DRIVER, NULL); \
437 }
438
439 #define DAPLKA_RS_FINI(rp) { \
440 mutex_destroy(&(rp)->header.rs_reflock); \
441 }
442
443 #define DAPLKA_RS_ACCT_INC(rp, cnt) { \
444 atomic_add_32(&(rp)->header.rs_charged, (cnt)); \
445 }
446 #define DAPLKA_RS_ACCT_DEC(rp, cnt) { \
447 atomic_add_32(&(rp)->header.rs_charged, -(cnt)); \
448 }
449 #define DAPLKA_RS_ACCT_CHARGED(rp) ((rp)->header.rs_charged)
450
451 #define DAPLKA_RS_RNUM(rp) ((rp)->header.rs_rnum)
452 #define DAPLKA_RS_TYPE(rp) ((rp)->header.rs_type)
453 #define DAPLKA_RS_RESERVED(rp) ((intptr_t)(rp) == DAPLKA_RC_RESERVED)
454
455 /*
456 * depending on the timeout value does a cv_wait_sig or cv_timedwait_sig
457 */
458 #define DAPLKA_EVD_WAIT(cvp, mp, timeout) \
459 ((timeout) == LONG_MAX) ? cv_wait_sig((cvp), (mp)) : \
460 cv_timedwait_sig((cvp), (mp), (timeout))
461
462 #define DAPLKA_HOLD_HCA_WITHOUT_LOCK(hca) ((hca)->hca_ref_cnt++)
463 #define DAPLKA_RELE_HCA_WITHOUT_LOCK(hca) ((hca)->hca_ref_cnt--)
464
465 #define DAPLKA_HOLD_HCA(dp, hca) { \
466 mutex_enter(&(dp)->daplka_mutex); \
467 DAPLKA_HOLD_HCA_WITHOUT_LOCK(hca); \
468 mutex_exit(&(dp)->daplka_mutex); \
469 }
470
471 #define DAPLKA_RELE_HCA(dp, hca) { \
472 mutex_enter(&(dp)->daplka_mutex); \
473 DAPLKA_RELE_HCA_WITHOUT_LOCK(hca); \
474 mutex_exit(&(dp)->daplka_mutex); \
475 }
476
477 #define DAPLKA_HCA_BUSY(hca) \
478 ((hca)->hca_ref_cnt != 0 || \
479 (hca)->hca_qp_count != 0 || \
480 (hca)->hca_cq_count != 0 || \
481 (hca)->hca_pd_count != 0 || \
482 (hca)->hca_mw_count != 0 || \
483 (hca)->hca_mr_count != 0)
484
485
486 static struct cb_ops daplka_cb_ops = {
487 daplka_open, /* cb_open */
488 daplka_close, /* cb_close */
489 nodev, /* cb_strategy */
490 nodev, /* cb_print */
491 nodev, /* cb_dump */
492 nodev, /* cb_read */
493 nodev, /* cb_write */
494 daplka_ioctl, /* cb_ioctl */
495 nodev, /* cb_devmap */
496 nodev, /* cb_mmap */
497 nodev, /* cb_segmap */
498 nochpoll, /* cb_chpoll */
499 ddi_prop_op, /* cb_prop_op */
500 NULL, /* cb_stream */
501 D_NEW | D_MP, /* cb_flag */
502 CB_REV, /* rev */
503 nodev, /* int (*cb_aread)() */
504 nodev /* int (*cb_awrite)() */
505 };
506
507 static struct dev_ops daplka_ops = {
508 DEVO_REV, /* devo_rev */
509 0, /* devo_refcnt */
510 daplka_info, /* devo_getinfo */
511 nulldev, /* devo_identify */
512 nulldev, /* devo_probe */
513 daplka_attach, /* devo_attach */
514 daplka_detach, /* devo_detach */
515 nodev, /* devo_reset */
516 &daplka_cb_ops, /* devo_cb_ops */
517 (struct bus_ops *)NULL, /* devo_bus_ops */
518 nulldev, /* power */
519 ddi_quiesce_not_needed, /* devo_quiesce */
520 };
521
522 /*
523 * Module linkage information for the kernel.
524 */
525 static struct modldrv modldrv = {
526 &mod_driverops,
527 "uDAPL Service Driver",
528 &daplka_ops,
529 };
530
531 static struct modlinkage modlinkage = {
532 #ifdef _LP64
533 MODREV_1, { (void *) &modldrv, NULL, NULL, NULL, NULL, NULL, NULL }
534 #else
535 MODREV_1, { (void *) &modldrv, NULL, NULL, NULL }
536 #endif
537 };
538
539 /*
540 * daplka_dev holds global driver state and a list of HCAs
541 */
542 static daplka_t *daplka_dev = NULL;
543 static void *daplka_state = NULL;
544
545 /*
546 * global SP hash table
547 */
548 static daplka_hash_table_t daplka_global_sp_htbl;
549
550 /*
551 * timer_info hash table
552 */
553 static daplka_hash_table_t daplka_timer_info_htbl;
554 static uint32_t daplka_timer_hkey = 0;
555
556 /*
557 * shared MR avl tree
558 */
559 static avl_tree_t daplka_shared_mr_tree;
560 static kmutex_t daplka_shared_mr_lock;
561 static int daplka_shared_mr_cmp(const void *, const void *);
562 _NOTE(MUTEX_PROTECTS_DATA(daplka_shared_mr_lock,
563 daplka_shared_mr_tree))
564
565 /*
566 * default kmem flags used by this driver
567 */
568 static int daplka_km_flags = KM_SLEEP;
569
570 /*
571 * taskq used for handling background tasks
572 */
573 static taskq_t *daplka_taskq = NULL;
574
575 /*
576 * daplka_cm_delay is the length of time the active
577 * side needs to wait before timing out on the REP message.
578 */
579 static clock_t daplka_cm_delay = 60000000;
580
581 /*
582 * modunload will fail if pending_close is non-zero
583 */
584 static uint32_t daplka_pending_close = 0;
585
586 static struct ibt_clnt_modinfo_s daplka_clnt_modinfo = {
587 IBTI_V_CURR,
588 IBT_USER,
589 daplka_async_handler,
590 NULL,
591 DAPLKA_DRV_NAME
592 };
593
594 /*
595 * Module Installation
596 */
597 int
598 _init(void)
599 {
600 int status;
601
602 status = ddi_soft_state_init(&daplka_state, sizeof (daplka_t), 1);
603 if (status != 0) {
604 return (status);
605 }
606
607 mutex_init(&daplka_dbglock, NULL, MUTEX_DRIVER, NULL);
608 bzero(daplka_dbgbuf, sizeof (daplka_dbgbuf));
609 daplka_dbgnext = 0;
610 daplka_dbginit = 1;
611
612 daplka_resource_init();
613
614 status = mod_install(&modlinkage);
615 if (status != DDI_SUCCESS) {
616 /* undo inits done before mod_install */
617 daplka_resource_fini();
618 mutex_destroy(&daplka_dbglock);
619 ddi_soft_state_fini(&daplka_state);
620 }
621 return (status);
622 }
623
624 /*
625 * Module Removal
626 */
627 int
628 _fini(void)
629 {
630 int status;
631
632 /*
633 * mod_remove causes detach to be called
634 */
635 if ((status = mod_remove(&modlinkage)) != 0) {
636 DERR("fini: mod_remove failed: 0x%x\n", status);
637 return (status);
638 }
639
640 daplka_resource_fini();
641 mutex_destroy(&daplka_dbglock);
642 ddi_soft_state_fini(&daplka_state);
643
644 return (status);
645 }
646
647 /*
648 * Return Module Info.
649 */
650 int
651 _info(struct modinfo *modinfop)
652 {
653 return (mod_info(&modlinkage, modinfop));
654 }
655
656 static void
657 daplka_enqueue_hca(daplka_t *dp, daplka_hca_t *hca)
658 {
659 daplka_hca_t *h;
660
661 ASSERT(mutex_owned(&dp->daplka_mutex));
662
663 if (dp->daplka_hca_list_head == NULL) {
664 dp->daplka_hca_list_head = hca;
665 } else {
666 h = dp->daplka_hca_list_head;
667 while (h->hca_next != NULL)
668 h = h->hca_next;
669
670 h->hca_next = hca;
671 }
672 }
673
674 static void
675 daplka_dequeue_hca(daplka_t *dp, daplka_hca_t *hca)
676 {
677 daplka_hca_t *h;
678
679 ASSERT(mutex_owned(&dp->daplka_mutex));
680
681 if (dp->daplka_hca_list_head == hca)
682 dp->daplka_hca_list_head = hca->hca_next;
683 else {
684 h = dp->daplka_hca_list_head;
685 while (h->hca_next != hca)
686 h = h->hca_next;
687 h->hca_next = hca->hca_next;
688 }
689 }
690
691 static int
692 daplka_init_hca(daplka_t *dp, ib_guid_t hca_guid)
693 {
694 daplka_hca_t *hca;
695 ibt_hca_portinfo_t *pinfop;
696 uint_t size;
697 int j;
698 ibt_status_t status;
699
700 hca = kmem_zalloc(sizeof (daplka_hca_t), KM_SLEEP);
701
702 hca->hca_guid = hca_guid;
703
704 /*
705 * open the HCA for use
706 */
707 status = ibt_open_hca(dp->daplka_clnt_hdl, hca_guid, &hca->hca_hdl);
708 if (status != IBT_SUCCESS) {
709 if (status == IBT_HCA_IN_USE) {
710 DERR("ibt_open_hca() returned IBT_HCA_IN_USE\n");
711 } else {
712 DERR("ibt_open_hca() returned %d\n", status);
713 }
714 kmem_free(hca, sizeof (daplka_hca_t));
715 return (status);
716 }
717
718 /*
719 * query HCA to get its info
720 */
721 status = ibt_query_hca(hca->hca_hdl, &hca->hca_attr);
722 if (status != IBT_SUCCESS) {
723 DERR("ibt_query_hca returned %d (hca_guid 0x%llx)\n",
724 status, (longlong_t)hca_guid);
725 goto out;
726 }
727
728 /*
729 * query HCA to get info of all ports
730 */
731 status = ibt_query_hca_ports(hca->hca_hdl,
732 0, &pinfop, &hca->hca_nports, &size);
733 if (status != IBT_SUCCESS) {
734 DERR("ibt_query_all_ports returned %d "
735 "(hca_guid 0x%llx)\n", status,
736 (longlong_t)hca_guid);
737 goto out;
738 }
739 hca->hca_ports = pinfop;
740 hca->hca_pinfosz = size;
741
742 DERR("hca guid 0x%llx, nports %d\n",
743 (longlong_t)hca_guid, hca->hca_nports);
744 for (j = 0; j < hca->hca_nports; j++) {
745 DERR("port %d: state %d prefix 0x%016llx "
746 "guid %016llx\n",
747 pinfop[j].p_port_num, pinfop[j].p_linkstate,
748 (longlong_t)pinfop[j].p_sgid_tbl[0].gid_prefix,
749 (longlong_t)pinfop[j].p_sgid_tbl[0].gid_guid);
750 }
751
752 mutex_enter(&dp->daplka_mutex);
753 daplka_enqueue_hca(dp, hca);
754 mutex_exit(&dp->daplka_mutex);
755
756 return (IBT_SUCCESS);
757
758 out:
759 (void) ibt_close_hca(hca->hca_hdl);
760 kmem_free(hca, sizeof (daplka_hca_t));
761 return (status);
762 }
763
764 /*
765 * this function obtains the list of HCAs from IBTF.
766 * the HCAs are then opened and the returned handles
767 * and attributes are stored into the global daplka_dev
768 * structure.
769 */
770 static int
771 daplka_init_hcas(daplka_t *dp)
772 {
773 int i;
774 ib_guid_t *hca_guids;
775 uint32_t hca_count;
776
777 /*
778 * get the num & list of HCAs present
779 */
780 hca_count = ibt_get_hca_list(&hca_guids);
781 DERR("No. of HCAs present %d\n", hca_count);
782
783 if (hca_count != 0) {
784 /*
785 * get the info for each available HCA
786 */
787 for (i = 0; i < hca_count; i++)
788 (void) daplka_init_hca(dp, hca_guids[i]);
789
790 ibt_free_hca_list(hca_guids, hca_count);
791 }
792
793 if (dp->daplka_hca_list_head != NULL)
794 return (IBT_SUCCESS);
795 else
796 return (IBT_FAILURE);
797 }
798
799 static int
800 daplka_fini_hca(daplka_t *dp, daplka_hca_t *hca)
801 {
802 ibt_status_t status;
803
804 if (hca->hca_hdl != NULL) {
805 status = ibt_close_hca(hca->hca_hdl);
806 if (status != IBT_SUCCESS) {
807 DERR("ibt_close_hca returned %d"
808 " (hca_guid 0x%llx)\n", status,
809 (longlong_t)hca->hca_guid);
810
811 mutex_enter(&dp->daplka_mutex);
812 daplka_enqueue_hca(dp, hca);
813 mutex_exit(&dp->daplka_mutex);
814
815 return (status);
816 }
817 }
818
819 if (hca->hca_ports != NULL)
820 ibt_free_portinfo(hca->hca_ports, hca->hca_pinfosz);
821
822 kmem_free(hca, sizeof (daplka_hca_t));
823 return (IBT_SUCCESS);
824 }
825
826 /*
827 * closes all HCAs and frees up the HCA list
828 */
829 static int
830 daplka_fini_hcas(daplka_t *dp)
831 {
832 ibt_status_t status;
833 daplka_hca_t *hca;
834
835 mutex_enter(&daplka_dev->daplka_mutex);
836 while ((hca = dp->daplka_hca_list_head) != NULL) {
837 if (DAPLKA_HCA_BUSY(hca)) {
838 mutex_exit(&daplka_dev->daplka_mutex);
839 return (IBT_HCA_RESOURCES_NOT_FREED);
840 }
841 daplka_dequeue_hca(daplka_dev, hca);
842 mutex_exit(&daplka_dev->daplka_mutex);
843
844 if ((status = daplka_fini_hca(dp, hca)) != IBT_SUCCESS)
845 return (status);
846
847 mutex_enter(&daplka_dev->daplka_mutex);
848 }
849 mutex_exit(&daplka_dev->daplka_mutex);
850
851 DERR("dapl kernel agent unloaded\n");
852 return (IBT_SUCCESS);
853 }
854
855
856 /*
857 * Attach the device, create and fill in daplka_dev
858 */
859 static int
860 daplka_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
861 {
862 daplka_t *dp;
863 int instance, retval, err;
864 boolean_t sp_htbl_allocated = B_FALSE;
865 boolean_t timer_htbl_allocated = B_FALSE;
866 boolean_t shared_mr_tree_allocated = B_FALSE;
867
868 switch (cmd) {
869 case DDI_ATTACH:
870 break;
871 case DDI_RESUME:
872 return (DDI_SUCCESS);
873 default:
874 return (DDI_FAILURE);
875 }
876
877 /*
878 * Allocate soft data structure
879 */
880 instance = ddi_get_instance(dip);
881 if (ddi_soft_state_zalloc(daplka_state, instance) != DDI_SUCCESS) {
882 DERR("attach: bad state zalloc\n");
883 return (DDI_FAILURE);
884 }
885
886 dp = ddi_get_soft_state(daplka_state, instance);
887 if (dp == NULL) {
888 ddi_soft_state_free(daplka_state, instance);
889 DERR("attach: cannot get soft state\n");
890 return (DDI_FAILURE);
891 }
892 /*
893 * Stuff private info into dip.
894 */
895 dp->daplka_dip = dip;
896 ddi_set_driver_private(dip, dp);
897 daplka_dev = dp;
898 mutex_init(&dp->daplka_mutex, NULL, MUTEX_DRIVER, NULL);
899
900 /*
901 * Register driver with IBTF
902 */
903 retval = ibt_attach(&daplka_clnt_modinfo, dip, dp,
904 &dp->daplka_clnt_hdl);
905 if (retval != IBT_SUCCESS) {
906 DERR("attach: ibt_attach failed: error = %d\n", retval);
907 retval = DDI_FAILURE;
908 goto error;
909 }
910 /* Register to receive SM events */
911 ibt_register_subnet_notices(dp->daplka_clnt_hdl,
912 daplka_sm_notice_handler, NULL);
913
914 retval = daplka_init_hcas(dp);
915 if (retval != IBT_SUCCESS) {
916 DERR("attach: hca_init failed: error = %d\n", retval);
917 retval = DDI_FAILURE;
918 goto error;
919 }
920 /*
921 * this table is used by cr_handoff
922 */
923 retval = daplka_hash_create(&daplka_global_sp_htbl,
924 DAPLKA_G_SP_HTBL_SZ, daplka_hash_sp_unref,
925 daplka_hash_generic_lookup);
926 if (retval != 0) {
927 DERR("attach: cannot create sp hash table\n");
928 retval = DDI_FAILURE;
929 goto error;
930 }
931 sp_htbl_allocated = B_TRUE;
932
933 /*
934 * this table stores per EP timer information.
935 * timer_info_t objects are inserted into this table whenever
936 * a EP timer is set. timers get removed when they expire
937 * or when they get cancelled.
938 */
939 retval = daplka_hash_create(&daplka_timer_info_htbl,
940 DAPLKA_TIMER_HTBL_SZ, daplka_hash_timer_free, NULL);
941 if (retval != 0) {
942 DERR("attach: cannot create timer hash table\n");
943 retval = DDI_FAILURE;
944 goto error;
945 }
946 timer_htbl_allocated = B_TRUE;
947
948 /*
949 * this taskq is currently only used for processing timers.
950 * other processing may also use this taskq in the future.
951 */
952 daplka_taskq = taskq_create(DAPLKA_DRV_NAME, DAPLKA_TQ_NTHREADS,
953 maxclsyspri, 1, DAPLKA_TQ_NTHREADS, TASKQ_DYNAMIC);
954 if (daplka_taskq == NULL) {
955 DERR("attach: cannot create daplka_taskq\n");
956 retval = DDI_FAILURE;
957 goto error;
958 }
959
960 /*
961 * daplka_shared_mr_tree holds daplka_shared_mr_t objects that
962 * gets retrieved or created when daplka_mr_register_shared is
963 * called.
964 */
965 mutex_init(&daplka_shared_mr_lock, NULL, MUTEX_DRIVER, NULL);
966
967 avl_create(&daplka_shared_mr_tree, daplka_shared_mr_cmp,
968 sizeof (daplka_shared_mr_t),
969 offsetof(daplka_shared_mr_t, smr_node));
970 shared_mr_tree_allocated = B_TRUE;
971
972 /*
973 * Create the filesystem device node.
974 */
975 if (ddi_create_minor_node(dip, DAPLKA_MINOR_NAME, S_IFCHR,
976 0, DDI_PSEUDO, NULL) != DDI_SUCCESS) {
977 DERR("attach: bad create_minor_node\n");
978 retval = DDI_FAILURE;
979 goto error;
980 }
981 dp->daplka_status = DAPLKA_STATE_ATTACHED;
982 ddi_report_dev(dip);
983 return (DDI_SUCCESS);
984
985 error:
986 if (shared_mr_tree_allocated) {
987 avl_destroy(&daplka_shared_mr_tree);
988 mutex_destroy(&daplka_shared_mr_lock);
989 }
990
991 if (daplka_taskq) {
992 taskq_destroy(daplka_taskq);
993 daplka_taskq = NULL;
994 }
995
996 if (timer_htbl_allocated) {
997 daplka_hash_destroy(&daplka_timer_info_htbl);
998 }
999
1000 if (sp_htbl_allocated) {
1001 daplka_hash_destroy(&daplka_global_sp_htbl);
1002 }
1003
1004 err = daplka_fini_hcas(dp);
1005 if (err != IBT_SUCCESS) {
1006 DERR("attach: hca_fini returned %d\n", err);
1007 }
1008
1009 if (dp->daplka_clnt_hdl != NULL) {
1010 /* unregister SM event notification */
1011 ibt_register_subnet_notices(dp->daplka_clnt_hdl,
1012 (ibt_sm_notice_handler_t)NULL, NULL);
1013 err = ibt_detach(dp->daplka_clnt_hdl);
1014
1015 if (err != IBT_SUCCESS) {
1016 DERR("attach: ibt_detach returned %d\n", err);
1017 }
1018 }
1019 mutex_destroy(&dp->daplka_mutex);
1020
1021 if (dp->daplka_status == DAPLKA_STATE_ATTACHED) {
1022 ddi_remove_minor_node(dip, NULL);
1023 }
1024 ddi_soft_state_free(daplka_state, instance);
1025 return (retval);
1026 }
1027
1028 /*
1029 * Detach - Free resources allocated in attach
1030 */
1031 /* ARGSUSED */
1032 static int
1033 daplka_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
1034 {
1035 int instance, err;
1036 void *cookie = NULL;
1037 daplka_t *dp;
1038
1039 if (cmd != DDI_DETACH) {
1040 return (DDI_FAILURE);
1041 }
1042 if (daplka_resource.daplka_rc_cnt > 0 ||
1043 daplka_pending_close > 0) {
1044 DERR("detach: driver in use\n");
1045 return (DDI_FAILURE);
1046 }
1047
1048 instance = ddi_get_instance(dip);
1049 dp = ddi_get_soft_state(daplka_state, instance);
1050 if (dp == NULL) {
1051 DERR("detach: cannot get soft state\n");
1052 return (DDI_FAILURE);
1053 }
1054 err = daplka_fini_hcas(dp);
1055 if (err != IBT_SUCCESS) {
1056 DERR("detach: hca_fini returned %d\n", err);
1057 return (DDI_FAILURE);
1058 }
1059 if (dp->daplka_clnt_hdl != NULL) {
1060 /* unregister SM event notification */
1061 ibt_register_subnet_notices(dp->daplka_clnt_hdl,
1062 (ibt_sm_notice_handler_t)NULL, NULL);
1063 err = ibt_detach(dp->daplka_clnt_hdl);
1064 if (err != IBT_SUCCESS) {
1065 DERR("detach: ibt_detach returned %d\n", err);
1066 return (DDI_FAILURE);
1067 }
1068 dp->daplka_clnt_hdl = NULL;
1069 }
1070 mutex_destroy(&dp->daplka_mutex);
1071 if (dp->daplka_status == DAPLKA_STATE_ATTACHED) {
1072 ddi_remove_minor_node(dip, NULL);
1073 }
1074 dp->daplka_status = DAPLKA_STATE_DETACHED;
1075 ddi_soft_state_free(daplka_state, instance);
1076 daplka_dev = NULL;
1077
1078 /*
1079 * by the time we get here, all clients of dapl should
1080 * have exited and completed their cleanup properly.
1081 * we can assert that all global data structures are now
1082 * empty.
1083 */
1084 ASSERT(avl_destroy_nodes(&daplka_shared_mr_tree, &cookie) == NULL);
1085 avl_destroy(&daplka_shared_mr_tree);
1086 mutex_destroy(&daplka_shared_mr_lock);
1087
1088 ASSERT(daplka_hash_getsize(&daplka_timer_info_htbl) == 0);
1089 daplka_hash_destroy(&daplka_timer_info_htbl);
1090
1091 ASSERT(daplka_hash_getsize(&daplka_global_sp_htbl) == 0);
1092 daplka_hash_destroy(&daplka_global_sp_htbl);
1093
1094 taskq_destroy(daplka_taskq);
1095
1096 return (DDI_SUCCESS);
1097 }
1098
1099 /* ARGSUSED */
1100 static int
1101 daplka_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
1102 {
1103 switch (infocmd) {
1104 case DDI_INFO_DEVT2DEVINFO:
1105 if (daplka_dev != NULL) {
1106 *result = daplka_dev->daplka_dip;
1107 return (DDI_SUCCESS);
1108 } else {
1109 return (DDI_FAILURE);
1110 }
1111
1112 case DDI_INFO_DEVT2INSTANCE:
1113 *result = 0;
1114 return (DDI_SUCCESS);
1115
1116 default:
1117 return (DDI_FAILURE);
1118 }
1119 }
1120
1121 /*
1122 * creates a EP resource.
1123 * A EP resource contains a RC channel. A EP resource holds a
1124 * reference to a send_evd (for the send CQ), recv_evd (for the
1125 * recv CQ), a connection evd and a PD. These references ensure
1126 * that the referenced resources are not freed until the EP itself
1127 * gets freed.
1128 */
1129 /* ARGSUSED */
1130 static int
1131 daplka_ep_create(daplka_ia_resource_t *ia_rp, intptr_t arg, int mode,
1132 cred_t *cred, int *rvalp)
1133 {
1134 daplka_ep_resource_t *ep_rp;
1135 daplka_pd_resource_t *pd_rp;
1136 dapl_ep_create_t args;
1137 ibt_rc_chan_alloc_args_t chan_args;
1138 ibt_chan_alloc_flags_t achan_flags;
1139 ibt_chan_sizes_t chan_real_sizes;
1140 ibt_hca_attr_t *hca_attrp;
1141 uint64_t ep_hkey = 0;
1142 boolean_t inserted = B_FALSE;
1143 uint32_t old_state, new_state;
1144 int retval;
1145 ibt_status_t status;
1146
1147 D3("ep_create: enter\n");
1148 retval = ddi_copyin((void *)arg, &args, sizeof (dapl_ep_create_t),
1149 mode);
1150 if (retval != 0) {
1151 DERR("ep_create: copyin error %d\n", retval);
1152 return (EFAULT);
1153 }
1154 ep_rp = kmem_zalloc(sizeof (daplka_ep_resource_t), daplka_km_flags);
1155 if (ep_rp == NULL) {
1156 DERR("ep_create: cannot allocate ep_rp\n");
1157 return (ENOMEM);
1158 }
1159 DAPLKA_RS_INIT(ep_rp, DAPL_TYPE_EP,
1160 DAPLKA_RS_RNUM(ia_rp), daplka_ep_destroy);
1161
1162 mutex_init(&ep_rp->ep_lock, NULL, MUTEX_DRIVER, NULL);
1163 cv_init(&ep_rp->ep_cv, NULL, CV_DRIVER, NULL);
1164 ep_rp->ep_hca = ia_rp->ia_hca;
1165 ep_rp->ep_cookie = args.ep_cookie;
1166 ep_rp->ep_timer_hkey = 0;
1167
1168 /*
1169 * we don't have to use ep_get_state here because ep_rp is not in
1170 * ep_htbl yet. refer to the description of daplka_ep_set_state
1171 * for details about the EP state machine.
1172 */
1173 ep_rp->ep_state = DAPLKA_EP_STATE_TRANSITIONING;
1174 new_state = old_state = DAPLKA_EP_STATE_CLOSED;
1175
1176 /* get reference to send evd and get cq handle */
1177 ep_rp->ep_snd_evd = (daplka_evd_resource_t *)
1178 daplka_hash_lookup(&ia_rp->ia_evd_htbl, args.ep_snd_evd_hkey);
1179 if (ep_rp->ep_snd_evd == NULL) {
1180 DERR("ep_create: ep_snd_evd %llx not found\n",
1181 args.ep_snd_evd_hkey);
1182 retval = EINVAL;
1183 goto cleanup;
1184 }
1185 chan_args.rc_scq = ep_rp->ep_snd_evd->evd_cq_hdl;
1186 if (chan_args.rc_scq == NULL) {
1187 DERR("ep_create: ep_snd_evd cq invalid\n");
1188 retval = EINVAL;
1189 goto cleanup;
1190 }
1191
1192 /* get reference to recv evd and get cq handle */
1193 ep_rp->ep_rcv_evd = (daplka_evd_resource_t *)
1194 daplka_hash_lookup(&ia_rp->ia_evd_htbl, args.ep_rcv_evd_hkey);
1195 if (ep_rp->ep_rcv_evd == NULL) {
1196 DERR("ep_create: ep_rcv_evd %llx not found\n",
1197 args.ep_rcv_evd_hkey);
1198 retval = EINVAL;
1199 goto cleanup;
1200 }
1201 chan_args.rc_rcq = ep_rp->ep_rcv_evd->evd_cq_hdl;
1202 if (chan_args.rc_rcq == NULL) {
1203 DERR("ep_create: ep_rcv_evd cq invalid\n");
1204 retval = EINVAL;
1205 goto cleanup;
1206 }
1207
1208 /* get reference to conn evd */
1209 ep_rp->ep_conn_evd = (daplka_evd_resource_t *)
1210 daplka_hash_lookup(&ia_rp->ia_evd_htbl, args.ep_conn_evd_hkey);
1211 if (ep_rp->ep_conn_evd == NULL) {
1212 DERR("ep_create: ep_conn_evd %llx not found\n",
1213 args.ep_conn_evd_hkey);
1214 retval = EINVAL;
1215 goto cleanup;
1216 }
1217
1218 /* get reference to SRQ if needed */
1219 if (args.ep_srq_attached) {
1220 ep_rp->ep_srq_res = (daplka_srq_resource_t *)daplka_hash_lookup(
1221 &ia_rp->ia_srq_htbl, args.ep_srq_hkey);
1222 if (ep_rp->ep_srq_res == NULL) {
1223 DERR("ep_create: ep_srq %llx not found\n",
1224 (longlong_t)args.ep_srq_hkey);
1225 retval = EINVAL;
1226 goto cleanup;
1227 }
1228 ASSERT(DAPLKA_RS_TYPE(ep_rp->ep_srq_res) == DAPL_TYPE_SRQ);
1229 D3("ep_create: ep_srq %p %llx\n", ep_rp->ep_srq_res,
1230 (longlong_t)args.ep_srq_hkey);
1231 } else {
1232 ep_rp->ep_srq_res = NULL;
1233 }
1234
1235 /* get pd handle */
1236 pd_rp = (daplka_pd_resource_t *)
1237 daplka_hash_lookup(&ia_rp->ia_pd_htbl, args.ep_pd_hkey);
1238 if (pd_rp == NULL) {
1239 DERR("ep_create: cannot find pd resource\n");
1240 retval = EINVAL;
1241 goto cleanup;
1242 }
1243 ASSERT(DAPLKA_RS_TYPE(pd_rp) == DAPL_TYPE_PD);
1244 ep_rp->ep_pd_res = pd_rp;
1245 chan_args.rc_pd = pd_rp->pd_hdl;
1246
1247
1248 /*
1249 * these checks ensure that the requested channel sizes
1250 * are within the limits supported by the chosen HCA.
1251 */
1252 hca_attrp = &ia_rp->ia_hca->hca_attr;
1253 if (args.ep_ch_sizes.dcs_sq_sgl > hca_attrp->hca_max_sgl) {
1254 DERR("ep_create: invalid cs_sq_sgl %d\n",
1255 args.ep_ch_sizes.dcs_sq_sgl);
1256 retval = EINVAL;
1257 goto cleanup;
1258 }
1259 if (args.ep_ch_sizes.dcs_rq_sgl > hca_attrp->hca_max_sgl) {
1260 DERR("ep_create: invalid cs_rq_sgl %d\n",
1261 args.ep_ch_sizes.dcs_rq_sgl);
1262 retval = EINVAL;
1263 goto cleanup;
1264 }
1265 if (args.ep_ch_sizes.dcs_sq > hca_attrp->hca_max_chan_sz) {
1266 DERR("ep_create: invalid cs_sq %d\n",
1267 args.ep_ch_sizes.dcs_sq);
1268 retval = EINVAL;
1269 goto cleanup;
1270 }
1271 if (args.ep_ch_sizes.dcs_rq > hca_attrp->hca_max_chan_sz) {
1272 DERR("ep_create: invalid cs_rq %d\n",
1273 args.ep_ch_sizes.dcs_rq);
1274 retval = EINVAL;
1275 goto cleanup;
1276 }
1277
1278 chan_args.rc_sizes.cs_sq_sgl = args.ep_ch_sizes.dcs_sq_sgl;
1279 chan_args.rc_sizes.cs_rq_sgl = args.ep_ch_sizes.dcs_rq_sgl;
1280 chan_args.rc_sizes.cs_sq = args.ep_ch_sizes.dcs_sq;
1281 chan_args.rc_sizes.cs_rq = args.ep_ch_sizes.dcs_rq;
1282 chan_args.rc_flags = IBT_WR_SIGNALED;
1283 chan_args.rc_control = IBT_CEP_RDMA_RD | IBT_CEP_RDMA_WR;
1284 chan_args.rc_hca_port_num = ia_rp->ia_port_num;
1285 chan_args.rc_clone_chan = NULL;
1286 if (args.ep_srq_attached) {
1287 chan_args.rc_srq = ep_rp->ep_srq_res->srq_hdl;
1288 } else {
1289 chan_args.rc_srq = NULL;
1290 }
1291
1292 D3("ep_create: sq_sgl %d, rq_sgl %d, sq %d, rq %d, "
1293 "sig_type 0x%x, control 0x%x, portnum %d, clone_chan 0x%p\n",
1294 args.ep_ch_sizes.dcs_sq_sgl, args.ep_ch_sizes.dcs_rq_sgl,
1295 args.ep_ch_sizes.dcs_sq, args.ep_ch_sizes.dcs_rq,
1296 chan_args.rc_flags, chan_args.rc_control,
1297 chan_args.rc_hca_port_num, chan_args.rc_clone_chan);
1298
1299 if (args.ep_srq_attached) {
1300 achan_flags = IBT_ACHAN_USER_MAP | IBT_ACHAN_USES_SRQ;
1301 } else {
1302 achan_flags = IBT_ACHAN_USER_MAP;
1303 }
1304 /* create rc channel */
1305 status = daplka_ibt_alloc_rc_channel(ep_rp, ia_rp->ia_hca_hdl,
1306 achan_flags, &chan_args, &ep_rp->ep_chan_hdl,
1307 &chan_real_sizes);
1308 if (status != IBT_SUCCESS) {
1309 DERR("ep_create: alloc_rc_channel returned %d\n", status);
1310 *rvalp = (int)status;
1311 retval = 0;
1312 goto cleanup;
1313 }
1314
1315 args.ep_ch_real_sizes.dcs_sq = chan_real_sizes.cs_sq;
1316 args.ep_ch_real_sizes.dcs_rq = chan_real_sizes.cs_rq;
1317 args.ep_ch_real_sizes.dcs_sq_sgl = chan_real_sizes.cs_sq_sgl;
1318 args.ep_ch_real_sizes.dcs_rq_sgl = chan_real_sizes.cs_rq_sgl;
1319
1320 /*
1321 * store ep ptr with chan_hdl.
1322 * this ep_ptr is used by the CM handlers (both active and
1323 * passive)
1324 * mutex is only needed for race of "destroy" and "async"
1325 */
1326 mutex_enter(&daplka_dev->daplka_mutex);
1327 ibt_set_chan_private(ep_rp->ep_chan_hdl, (void *)ep_rp);
1328 mutex_exit(&daplka_dev->daplka_mutex);
1329
1330 /* Get HCA-specific data_out info */
1331 status = ibt_ci_data_out(ia_rp->ia_hca_hdl,
1332 IBT_CI_NO_FLAGS, IBT_HDL_CHANNEL, (void *)ep_rp->ep_chan_hdl,
1333 &args.ep_qp_data_out, sizeof (args.ep_qp_data_out));
1334
1335 if (status != IBT_SUCCESS) {
1336 DERR("ep_create: ibt_ci_data_out error(%d)\n",
1337 status);
1338 *rvalp = (int)status;
1339 retval = 0;
1340 goto cleanup;
1341 }
1342
1343 /* insert into ep hash table */
1344 retval = daplka_hash_insert(&ia_rp->ia_ep_htbl,
1345 &ep_hkey, (void *)ep_rp);
1346 if (retval != 0) {
1347 DERR("ep_create: cannot insert ep resource into ep_htbl\n");
1348 goto cleanup;
1349 }
1350 inserted = B_TRUE;
1351
1352 /*
1353 * at this point, the ep_rp can be looked up by other threads
1354 * if they manage to guess the correct hkey. but they are not
1355 * permitted to operate on ep_rp until we transition to the
1356 * CLOSED state.
1357 */
1358
1359 /* return hkey to library */
1360 args.ep_hkey = ep_hkey;
1361
1362 retval = ddi_copyout(&args, (void *)arg, sizeof (dapl_ep_create_t),
1363 mode);
1364 if (retval != 0) {
1365 DERR("ep_create: copyout error %d\n", retval);
1366 retval = EFAULT;
1367 goto cleanup;
1368 }
1369
1370 daplka_ep_set_state(ep_rp, old_state, new_state);
1371 D3("ep_create: exit\n");
1372 return (0);
1373
1374 cleanup:
1375 if (inserted) {
1376 daplka_ep_resource_t *free_rp = NULL;
1377
1378 (void) daplka_hash_remove(&ia_rp->ia_ep_htbl, ep_hkey,
1379 (void **)&free_rp);
1380 if (free_rp != ep_rp) {
1381 /*
1382 * this case is impossible because ep_free will
1383 * wait until our state transition is complete.
1384 */
1385 DERR("ep_create: cannot remove ep from hash table\n");
1386 ASSERT(B_FALSE);
1387 return (retval);
1388 }
1389 }
1390 new_state = DAPLKA_EP_STATE_FREED;
1391 daplka_ep_set_state(ep_rp, old_state, new_state);
1392 DAPLKA_RS_UNREF(ep_rp);
1393 return (retval);
1394 }
1395
1396 /*
1397 * daplka_ep_get_state retrieves the current state of the EP and
1398 * sets the state to TRANSITIONING. if the current state is already
1399 * TRANSITIONING, this function will wait until the state becomes one
1400 * of the other EP states. Most of the EP related ioctls follow the
1401 * call sequence:
1402 *
1403 * new_state = old_state = daplka_ep_get_state(ep_rp);
1404 * ...
1405 * ...some code that affects the EP
1406 * ...
1407 * new_state = <NEW_STATE>;
1408 * daplka_ep_set_state(ep_rp, old_state, new_state);
1409 *
1410 * this call sequence ensures that only one thread may access the EP
1411 * during the time ep_state is in TRANSITIONING. daplka_ep_set_state
1412 * transitions ep_state to new_state and wakes up any waiters blocking
1413 * on ep_cv.
1414 *
1415 */
1416 static uint32_t
1417 daplka_ep_get_state(daplka_ep_resource_t *ep_rp)
1418 {
1419 uint32_t old_state = 0;
1420
1421 mutex_enter(&ep_rp->ep_lock);
1422 while (ep_rp->ep_state == DAPLKA_EP_STATE_TRANSITIONING) {
1423 D2("get_state: wait for state transition to complete\n");
1424 cv_wait(&ep_rp->ep_cv, &ep_rp->ep_lock);
1425 D2("get_state: done, curr state = %d\n", ep_rp->ep_state);
1426 }
1427 ASSERT(ep_rp->ep_state != DAPLKA_EP_STATE_TRANSITIONING);
1428 old_state = ep_rp->ep_state;
1429
1430 /*
1431 * an ep that is in the FREED state cannot transition
1432 * back to any of the regular states
1433 */
1434 if (old_state != DAPLKA_EP_STATE_FREED) {
1435 ep_rp->ep_state = DAPLKA_EP_STATE_TRANSITIONING;
1436 }
1437 mutex_exit(&ep_rp->ep_lock);
1438 return (old_state);
1439 }
1440
1441 /*
1442 * EP state transition diagram
1443 *
1444 * CLOSED<-------------------
1445 * | |
1446 * | |
1447 * ------------------------ |
1448 * | | |
1449 * | | |
1450 * v v |
1451 * CONNECTING ACCEPTING |
1452 * | | | | | |
1453 * | | | | | |
1454 * | | | | | |
1455 * | | |_______|_______| |
1456 * | | | | | |
1457 * | |___________| | | |
1458 * | | | | |
1459 * | v | |---->DISCONNECTED
1460 * | CONNECTED | ^
1461 * v | | |
1462 * ABORTING |---------|--------------|
1463 * | | | |
1464 * | | v |
1465 * | |-------->DISCONNECTING--|
1466 * | |
1467 * |---------------------------------|
1468 *
1469 * *not shown in this diagram:
1470 * -loopback transitions
1471 * -transitions to the FREED state
1472 */
1473 static boolean_t
1474 daplka_ep_transition_is_valid(uint32_t old_state, uint32_t new_state)
1475 {
1476 boolean_t valid = B_FALSE;
1477
1478 /*
1479 * reseting to the same state is a no-op and is always
1480 * permitted. transitioning to the FREED state indicates
1481 * that the ep is about to be freed and no further operation
1482 * is allowed on it. to support abrupt close, the ep is
1483 * permitted to transition to the FREED state from any state.
1484 */
1485 if (old_state == new_state ||
1486 new_state == DAPLKA_EP_STATE_FREED) {
1487 return (B_TRUE);
1488 }
1489
1490 switch (old_state) {
1491 case DAPLKA_EP_STATE_CLOSED:
1492 /*
1493 * this is the initial ep_state.
1494 * a transition to CONNECTING or ACCEPTING may occur
1495 * upon calling daplka_ep_connect or daplka_cr_accept,
1496 * respectively.
1497 */
1498 if (new_state == DAPLKA_EP_STATE_CONNECTING ||
1499 new_state == DAPLKA_EP_STATE_ACCEPTING) {
1500 valid = B_TRUE;
1501 }
1502 break;
1503 case DAPLKA_EP_STATE_CONNECTING:
1504 /*
1505 * we transition to this state if daplka_ep_connect
1506 * is successful. from this state, we can transition
1507 * to CONNECTED if daplka_cm_rc_conn_est gets called;
1508 * or to DISCONNECTED if daplka_cm_rc_conn_closed or
1509 * daplka_cm_rc_event_failure gets called. If the
1510 * client calls daplka_ep_disconnect, we transition
1511 * to DISCONNECTING. If a timer was set at ep_connect
1512 * time and if the timer expires prior to any of the
1513 * CM callbacks, we transition to ABORTING and then
1514 * to DISCONNECTED.
1515 */
1516 if (new_state == DAPLKA_EP_STATE_CONNECTED ||
1517 new_state == DAPLKA_EP_STATE_DISCONNECTING ||
1518 new_state == DAPLKA_EP_STATE_DISCONNECTED ||
1519 new_state == DAPLKA_EP_STATE_ABORTING) {
1520 valid = B_TRUE;
1521 }
1522 break;
1523 case DAPLKA_EP_STATE_ACCEPTING:
1524 /*
1525 * we transition to this state if daplka_cr_accept
1526 * is successful. from this state, we can transition
1527 * to CONNECTED if daplka_cm_service_conn_est gets called;
1528 * or to DISCONNECTED if daplka_cm_service_conn_closed or
1529 * daplka_cm_service_event_failure gets called. If the
1530 * client calls daplka_ep_disconnect, we transition to
1531 * DISCONNECTING.
1532 */
1533 if (new_state == DAPLKA_EP_STATE_CONNECTED ||
1534 new_state == DAPLKA_EP_STATE_DISCONNECTING ||
1535 new_state == DAPLKA_EP_STATE_DISCONNECTED) {
1536 valid = B_TRUE;
1537 }
1538 break;
1539 case DAPLKA_EP_STATE_CONNECTED:
1540 /*
1541 * we transition to this state if a active or passive
1542 * connection gets established. if the client calls
1543 * daplka_ep_disconnect, we transition to the
1544 * DISCONNECTING state. subsequent CM callbacks will
1545 * cause ep_state to be set to DISCONNECTED. If the
1546 * remote peer terminates the connection before we do,
1547 * it is possible for us to transition directly from
1548 * CONNECTED to DISCONNECTED.
1549 */
1550 if (new_state == DAPLKA_EP_STATE_DISCONNECTING ||
1551 new_state == DAPLKA_EP_STATE_DISCONNECTED) {
1552 valid = B_TRUE;
1553 }
1554 break;
1555 case DAPLKA_EP_STATE_DISCONNECTING:
1556 /*
1557 * we transition to this state if the client calls
1558 * daplka_ep_disconnect.
1559 */
1560 if (new_state == DAPLKA_EP_STATE_DISCONNECTED) {
1561 valid = B_TRUE;
1562 }
1563 break;
1564 case DAPLKA_EP_STATE_ABORTING:
1565 /*
1566 * we transition to this state if the active side
1567 * EP timer has expired. this is only a transient
1568 * state that is set during timer processing. when
1569 * timer processing completes, ep_state will become
1570 * DISCONNECTED.
1571 */
1572 if (new_state == DAPLKA_EP_STATE_DISCONNECTED) {
1573 valid = B_TRUE;
1574 }
1575 break;
1576 case DAPLKA_EP_STATE_DISCONNECTED:
1577 /*
1578 * we transition to this state if we get a closed
1579 * or event_failure CM callback. an expired timer
1580 * can also cause us to be in this state. this
1581 * is the only state in which we permit the
1582 * ep_reinit operation.
1583 */
1584 if (new_state == DAPLKA_EP_STATE_CLOSED) {
1585 valid = B_TRUE;
1586 }
1587 break;
1588 default:
1589 break;
1590 }
1591
1592 if (!valid) {
1593 DERR("ep_transition: invalid state change %d -> %d\n",
1594 old_state, new_state);
1595 }
1596 return (valid);
1597 }
1598
1599 /*
1600 * first check if the transition is valid. then set ep_state
1601 * to new_state and wake up all waiters.
1602 */
1603 static void
1604 daplka_ep_set_state(daplka_ep_resource_t *ep_rp, uint32_t old_state,
1605 uint32_t new_state)
1606 {
1607 boolean_t valid;
1608
1609 ASSERT(new_state != DAPLKA_EP_STATE_TRANSITIONING);
1610
1611 valid = daplka_ep_transition_is_valid(old_state, new_state);
1612 mutex_enter(&ep_rp->ep_lock);
1613 if (ep_rp->ep_state != DAPLKA_EP_STATE_FREED) {
1614 if (valid) {
1615 ep_rp->ep_state = new_state;
1616 } else {
1617 /*
1618 * this case is impossible.
1619 * we have a serious problem if we get here.
1620 * instead of panicing, we reset the state to
1621 * old_state. doing this would at least prevent
1622 * threads from hanging due to ep_state being
1623 * stuck in TRANSITIONING.
1624 */
1625 ep_rp->ep_state = old_state;
1626 ASSERT(B_FALSE);
1627 }
1628 }
1629 cv_broadcast(&ep_rp->ep_cv);
1630 mutex_exit(&ep_rp->ep_lock);
1631 }
1632
1633 /*
1634 * modifies RC channel attributes.
1635 * currently, only the rdma_in and rdma_out attributes may
1636 * be modified. the channel must be in quiescent state when
1637 * this function is called.
1638 */
1639 /* ARGSUSED */
1640 static int
1641 daplka_ep_modify(daplka_ia_resource_t *ia_rp, intptr_t arg, int mode,
1642 cred_t *cred, int *rvalp)
1643 {
1644 daplka_ep_resource_t *ep_rp = NULL;
1645 ibt_cep_modify_flags_t good_flags;
1646 ibt_rc_chan_modify_attr_t rcm_attr;
1647 ibt_hca_attr_t *hca_attrp;
1648 dapl_ep_modify_t args;
1649 ibt_status_t status;
1650 uint32_t old_state, new_state;
1651 int retval = 0;
1652
1653 retval = ddi_copyin((void *)arg, &args, sizeof (dapl_ep_modify_t),
1654 mode);
1655 if (retval != 0) {
1656 DERR("ep_modify: copyin error %d\n", retval);
1657 return (EFAULT);
1658 }
1659 ep_rp = (daplka_ep_resource_t *)
1660 daplka_hash_lookup(&ia_rp->ia_ep_htbl, args.epm_hkey);
1661 if (ep_rp == NULL) {
1662 DERR("ep_modify: cannot find ep resource\n");
1663 return (EINVAL);
1664 }
1665 ASSERT(DAPLKA_RS_TYPE(ep_rp) == DAPL_TYPE_EP);
1666 new_state = old_state = daplka_ep_get_state(ep_rp);
1667
1668 if (old_state != DAPLKA_EP_STATE_CLOSED &&
1669 old_state != DAPLKA_EP_STATE_DISCONNECTED) {
1670 DERR("ep_modify: invalid state %d\n", old_state);
1671 retval = EINVAL;
1672 goto cleanup;
1673 }
1674
1675 good_flags = IBT_CEP_SET_RDMARA_OUT | IBT_CEP_SET_RDMARA_IN;
1676 if ((args.epm_flags & ~good_flags) != 0) {
1677 DERR("ep_modify: invalid flags 0x%x\n", args.epm_flags);
1678 retval = EINVAL;
1679 goto cleanup;
1680 }
1681
1682 hca_attrp = &ia_rp->ia_hca->hca_attr;
1683
1684 bzero(&rcm_attr, sizeof (ibt_rc_chan_modify_attr_t));
1685 if ((args.epm_flags & IBT_CEP_SET_RDMARA_OUT) != 0) {
1686 if (args.epm_rdma_ra_out > hca_attrp->hca_max_rdma_out_chan) {
1687 DERR("ep_modify: invalid epm_rdma_ra_out %d\n",
1688 args.epm_rdma_ra_out);
1689 retval = EINVAL;
1690 goto cleanup;
1691 }
1692 rcm_attr.rc_rdma_ra_out = args.epm_rdma_ra_out;
1693 }
1694 if ((args.epm_flags & IBT_CEP_SET_RDMARA_IN) != 0) {
1695 if (args.epm_rdma_ra_in > hca_attrp->hca_max_rdma_in_chan) {
1696 DERR("ep_modify: epm_rdma_ra_in %d\n",
1697 args.epm_rdma_ra_in);
1698 retval = EINVAL;
1699 goto cleanup;
1700 }
1701 rcm_attr.rc_rdma_ra_in = args.epm_rdma_ra_in;
1702 }
1703 status = ibt_modify_rc_channel(ep_rp->ep_chan_hdl, args.epm_flags,
1704 &rcm_attr, NULL);
1705 if (status != IBT_SUCCESS) {
1706 DERR("ep_modify: modify_rc_channel returned %d\n", status);
1707 *rvalp = (int)status;
1708 retval = 0;
1709 goto cleanup;
1710 }
1711
1712 /*
1713 * ep_modify does not change ep_state
1714 */
1715 cleanup:;
1716 daplka_ep_set_state(ep_rp, old_state, new_state);
1717 DAPLKA_RS_UNREF(ep_rp);
1718 return (retval);
1719 }
1720
1721 /*
1722 * Frees a EP resource.
1723 * a EP may only be freed when it is in the CLOSED or
1724 * DISCONNECTED state.
1725 */
1726 /* ARGSUSED */
1727 static int
1728 daplka_ep_free(daplka_ia_resource_t *ia_rp, intptr_t arg, int mode,
1729 cred_t *cred, int *rvalp)
1730 {
1731 daplka_ep_resource_t *ep_rp = NULL;
1732 dapl_ep_free_t args;
1733 uint32_t old_state, new_state;
1734 int retval;
1735
1736 retval = ddi_copyin((void *)arg, &args, sizeof (dapl_ep_free_t), mode);
1737 if (retval != 0) {
1738 DERR("ep_free: copyin error %d\n", retval);
1739 return (EFAULT);
1740 }
1741 ep_rp = (daplka_ep_resource_t *)
1742 daplka_hash_lookup(&ia_rp->ia_ep_htbl, args.epf_hkey);
1743 if (ep_rp == NULL) {
1744 DERR("ep_free: cannot find ep resource\n");
1745 return (EINVAL);
1746 }
1747 ASSERT(DAPLKA_RS_TYPE(ep_rp) == DAPL_TYPE_EP);
1748 new_state = old_state = daplka_ep_get_state(ep_rp);
1749
1750 /*
1751 * ep cannot be freed if it is in an invalid state.
1752 */
1753 if (old_state != DAPLKA_EP_STATE_CLOSED &&
1754 old_state != DAPLKA_EP_STATE_DISCONNECTED) {
1755 DERR("ep_free: invalid state %d\n", old_state);
1756 retval = EINVAL;
1757 goto cleanup;
1758 }
1759 ep_rp = NULL;
1760 retval = daplka_hash_remove(&ia_rp->ia_ep_htbl,
1761 args.epf_hkey, (void **)&ep_rp);
1762 if (retval != 0 || ep_rp == NULL) {
1763 /*
1764 * this is only possible if we have two threads
1765 * calling ep_free in parallel.
1766 */
1767 DERR("ep_free: cannot find ep resource\n");
1768 goto cleanup;
1769 }
1770 /* there should not be any outstanding timers */
1771 ASSERT(ep_rp->ep_timer_hkey == 0);
1772
1773 new_state = DAPLKA_EP_STATE_FREED;
1774 daplka_ep_set_state(ep_rp, old_state, new_state);
1775
1776 /* remove reference obtained by lookup */
1777 DAPLKA_RS_UNREF(ep_rp);
1778
1779 /* UNREF calls the actual free function when refcnt is zero */
1780 DAPLKA_RS_UNREF(ep_rp);
1781 return (0);
1782
1783 cleanup:;
1784 daplka_ep_set_state(ep_rp, old_state, new_state);
1785
1786 /* remove reference obtained by lookup */
1787 DAPLKA_RS_UNREF(ep_rp);
1788 return (retval);
1789 }
1790
1791 /*
1792 * The following routines supports the timeout feature of ep_connect.
1793 * Refer to the description of ep_connect for details.
1794 */
1795
1796 /*
1797 * this is the timer processing thread.
1798 */
1799 static void
1800 daplka_timer_thread(void *arg)
1801 {
1802 daplka_timer_info_t *timerp = (daplka_timer_info_t *)arg;
1803 daplka_ep_resource_t *ep_rp;
1804 daplka_evd_event_t *disc_ev = NULL;
1805 ibt_status_t status;
1806 int old_state, new_state;
1807
1808 ep_rp = timerp->ti_ep_res;
1809 ASSERT(ep_rp != NULL);
1810 ASSERT(timerp->ti_tmo_id != 0);
1811 timerp->ti_tmo_id = 0;
1812
1813 new_state = old_state = daplka_ep_get_state(ep_rp);
1814 if (old_state != DAPLKA_EP_STATE_CONNECTING) {
1815 /* unblock hash_ep_free */
1816 mutex_enter(&ep_rp->ep_lock);
1817 ASSERT(ep_rp->ep_timer_hkey != 0);
1818 ep_rp->ep_timer_hkey = 0;
1819 cv_broadcast(&ep_rp->ep_cv);
1820 mutex_exit(&ep_rp->ep_lock);
1821
1822 /* reset state to original state */
1823 daplka_ep_set_state(ep_rp, old_state, new_state);
1824
1825 /* this function will also unref ep_rp */
1826 daplka_timer_info_free(timerp);
1827 return;
1828 }
1829
1830 ASSERT(ep_rp->ep_timer_hkey != 0);
1831 ep_rp->ep_timer_hkey = 0;
1832
1833 /*
1834 * we cannot keep ep_state in TRANSITIONING if we call
1835 * ibt_close_rc_channel in blocking mode. this would cause
1836 * a deadlock because the cm callbacks will be blocked and
1837 * will not be able to wake us up.
1838 */
1839 new_state = DAPLKA_EP_STATE_ABORTING;
1840 daplka_ep_set_state(ep_rp, old_state, new_state);
1841
1842 /*
1843 * when we return from close_rc_channel, all callbacks should have
1844 * completed. we can also be certain that these callbacks did not
1845 * enqueue any events to conn_evd.
1846 */
1847 status = ibt_close_rc_channel(ep_rp->ep_chan_hdl, IBT_BLOCKING,
1848 NULL, 0, NULL, NULL, NULL);
1849 if (status != IBT_SUCCESS) {
1850 DERR("timer_thread: ibt_close_rc_channel returned %d\n",
1851 status);
1852 }
1853 old_state = daplka_ep_get_state(ep_rp);
1854
1855 /*
1856 * this is the only thread that can transition ep_state out
1857 * of ABORTING. all other ep operations would fail when
1858 * ep_state is in ABORTING.
1859 */
1860 ASSERT(old_state == DAPLKA_EP_STATE_ABORTING);
1861
1862 disc_ev = kmem_zalloc(sizeof (daplka_evd_event_t), KM_SLEEP);
1863 ASSERT(disc_ev != NULL);
1864
1865 disc_ev->ee_cmev.ec_cm_ev_type = DAPL_IB_CME_TIMED_OUT;
1866 disc_ev->ee_cmev.ec_cm_cookie = ep_rp->ep_cookie;
1867 disc_ev->ee_cmev.ec_cm_is_passive = B_FALSE;
1868 disc_ev->ee_cmev.ec_cm_psep_cookie = 0;
1869 disc_ev->ee_cmev.ec_cm_ev_priv_data = NULL;
1870 disc_ev->ee_cmev.ec_cm_ev_priv_data_len = 0;
1871
1872 D2("timer_thread: enqueue event(%p) evdp(%p)\n",
1873 disc_ev, ep_rp->ep_conn_evd);
1874
1875 new_state = DAPLKA_EP_STATE_DISCONNECTED;
1876 daplka_ep_set_state(ep_rp, old_state, new_state);
1877
1878 daplka_evd_wakeup(ep_rp->ep_conn_evd,
1879 &ep_rp->ep_conn_evd->evd_conn_events, disc_ev);
1880
1881 /* this function will also unref ep_rp */
1882 daplka_timer_info_free(timerp);
1883 }
1884
1885 /*
1886 * dispatches a thread to continue with timer processing.
1887 */
1888 static void
1889 daplka_timer_dispatch(void *arg)
1890 {
1891 /*
1892 * keep rescheduling this function until
1893 * taskq_dispatch succeeds.
1894 */
1895 if (taskq_dispatch(daplka_taskq,
1896 daplka_timer_thread, arg, TQ_NOSLEEP) == 0) {
1897 DERR("timer_dispatch: taskq_dispatch failed, retrying...\n");
1898 (void) timeout(daplka_timer_dispatch, arg, 10);
1899 }
1900 }
1901
1902 /*
1903 * this function is called by the kernel's callout thread.
1904 * we first attempt to remove the timer object from the
1905 * global timer table. if it is found, we dispatch a thread
1906 * to continue processing the timer object. if it is not
1907 * found, that means the timer has been cancelled by someone
1908 * else.
1909 */
1910 static void
1911 daplka_timer_handler(void *arg)
1912 {
1913 uint64_t timer_hkey = (uintptr_t)arg;
1914 daplka_timer_info_t *timerp = NULL;
1915
1916 D2("timer_handler: timer_hkey 0x%llx\n", (longlong_t)timer_hkey);
1917
1918 (void) daplka_hash_remove(&daplka_timer_info_htbl,
1919 timer_hkey, (void **)&timerp);
1920 if (timerp == NULL) {
1921 D2("timer_handler: timer already cancelled\n");
1922 return;
1923 }
1924 daplka_timer_dispatch((void *)timerp);
1925 }
1926
1927 /*
1928 * allocates a timer_info object.
1929 * a reference to a EP is held by this object. this ensures
1930 * that the EP stays valid when a timer is outstanding.
1931 */
1932 static daplka_timer_info_t *
1933 daplka_timer_info_alloc(daplka_ep_resource_t *ep_rp)
1934 {
1935 daplka_timer_info_t *timerp;
1936
1937 timerp = kmem_zalloc(sizeof (*timerp), daplka_km_flags);
1938 if (timerp == NULL) {
1939 DERR("timer_info_alloc: cannot allocate timer info\n");
1940 return (NULL);
1941 }
1942 timerp->ti_ep_res = ep_rp;
1943 timerp->ti_tmo_id = 0;
1944
1945 return (timerp);
1946 }
1947
1948 /*
1949 * Frees the timer_info object.
1950 * we release the EP reference before freeing the object.
1951 */
1952 static void
1953 daplka_timer_info_free(daplka_timer_info_t *timerp)
1954 {
1955 ASSERT(timerp->ti_ep_res != NULL);
1956 DAPLKA_RS_UNREF(timerp->ti_ep_res);
1957 timerp->ti_ep_res = NULL;
1958 ASSERT(timerp->ti_tmo_id == 0);
1959 kmem_free(timerp, sizeof (*timerp));
1960 }
1961
1962 /*
1963 * cancels the timer set by ep_connect.
1964 * returns -1 if timer handling is in progress
1965 * and 0 otherwise.
1966 */
1967 static int
1968 daplka_cancel_timer(daplka_ep_resource_t *ep_rp)
1969 {
1970 /*
1971 * this function can only be called when ep_state
1972 * is frozen.
1973 */
1974 ASSERT(ep_rp->ep_state == DAPLKA_EP_STATE_TRANSITIONING);
1975 if (ep_rp->ep_timer_hkey != 0) {
1976 daplka_timer_info_t *timerp = NULL;
1977
1978 (void) daplka_hash_remove(&daplka_timer_info_htbl,
1979 ep_rp->ep_timer_hkey, (void **)&timerp);
1980 if (timerp == NULL) {
1981 /*
1982 * this is possible if the timer_handler has
1983 * removed the timerp but the taskq thread has
1984 * not transitioned the ep_state to DISCONNECTED.
1985 * we need to reset the ep_state to allow the
1986 * taskq thread to continue with its work. the
1987 * taskq thread will set the ep_timer_hkey to 0
1988 * so we don't have to do it here.
1989 */
1990 DERR("cancel_timer: timer is being processed\n");
1991 return (-1);
1992 }
1993 /*
1994 * we got the timer object. if the handler fires at
1995 * this point, it will not be able to find the object
1996 * and will return immediately. normally, ti_tmo_id gets
1997 * cleared when the handler fires.
1998 */
1999 ASSERT(timerp->ti_tmo_id != 0);
2000
2001 /*
2002 * note that untimeout can possibly call the handler.
2003 * we are safe because the handler will be a no-op.
2004 */
2005 (void) untimeout(timerp->ti_tmo_id);
2006 timerp->ti_tmo_id = 0;
2007 daplka_timer_info_free(timerp);
2008 ep_rp->ep_timer_hkey = 0;
2009 }
2010 return (0);
2011 }
2012
2013 /*
2014 * this function is called by daplka_hash_destroy for
2015 * freeing timer_info objects
2016 */
2017 static void
2018 daplka_hash_timer_free(void *obj)
2019 {
2020 daplka_timer_info_free((daplka_timer_info_t *)obj);
2021 }
2022
2023 /* ARGSUSED */
2024 static uint16_t
2025 daplka_hellomsg_cksum(DAPL_PRIVATE *dp)
2026 {
2027 uint8_t *bp;
2028 int i;
2029 uint16_t cksum = 0;
2030
2031 bp = (uint8_t *)dp;
2032 for (i = 0; i < sizeof (DAPL_PRIVATE); i++) {
2033 cksum += bp[i];
2034 }
2035 return (cksum);
2036 }
2037
2038 /*
2039 * ep_connect is called by the client to initiate a connection to a
2040 * remote service point. It is a non-blocking call. If a non-zero
2041 * timeout is specified by the client, a timer will be set just before
2042 * returning from ep_connect. Upon a successful return from ep_connect,
2043 * the client will call evd_wait to wait for the connection to complete.
2044 * If the connection is rejected or has failed due to an error, the
2045 * client will be notified with an event containing the appropriate error
2046 * code. If the connection is accepted, the client will be notified with
2047 * the CONN_ESTABLISHED event. If the timer expires before either of the
2048 * above events (error or established), a TIMED_OUT event will be delivered
2049 * to the client.
2050 *
2051 * the complicated part of the timer logic is the handling of race
2052 * conditions with CM callbacks. we need to ensure that either the CM or
2053 * the timer thread gets to deliver an event, but not both. when the
2054 * CM callback is about to deliver an event, it always tries to cancel
2055 * the outstanding timer. if cancel_timer indicates a that the timer is
2056 * already being processed, the CM callback will simply return without
2057 * delivering an event. when the timer thread executes, it tries to check
2058 * if the EP is still in CONNECTING state (timers only work on the active
2059 * side). if the EP is not in this state, the timer thread will return
2060 * without delivering an event.
2061 */
2062 /* ARGSUSED */
2063 static int
2064 daplka_ep_connect(daplka_ia_resource_t *ia_rp, intptr_t arg, int mode,
2065 cred_t *cred, int *rvalp)
2066 {
2067 daplka_ep_resource_t *ep_rp = NULL;
2068 dapl_ep_connect_t args;
2069 daplka_timer_info_t *timerp = NULL;
2070 uint32_t old_state, new_state;
2071 boolean_t timer_inserted = B_FALSE;
2072 uint64_t timer_hkey = 0;
2073 ibt_path_info_t path_info;
2074 ibt_path_attr_t path_attr;
2075 ibt_hca_attr_t *hca_attrp;
2076 ibt_chan_open_args_t chan_args;
2077 ibt_status_t status = IBT_SUCCESS;
2078 uint8_t num_paths;
2079 void *priv_data;
2080 DAPL_PRIVATE *dp;
2081 int retval = 0;
2082 ib_gid_t *sgid;
2083 ib_gid_t *dgid;
2084 uint64_t dgid_ored;
2085 ibt_ar_t ar_query_s;
2086 ibt_ar_t ar_result_s;
2087 ibt_path_flags_t pathflags;
2088
2089 D3("ep_connect: enter\n");
2090 retval = ddi_copyin((void *)arg, &args, sizeof (dapl_ep_connect_t),
2091 mode);
2092 if (retval != 0) {
2093 DERR("ep_connect: copyin error %d\n", retval);
2094 return (EFAULT);
2095 }
2096 ep_rp = (daplka_ep_resource_t *)
2097 daplka_hash_lookup(&ia_rp->ia_ep_htbl, args.epc_hkey);
2098 if (ep_rp == NULL) {
2099 DERR("ep_connect: cannot find ep resource\n");
2100 return (EINVAL);
2101 }
2102 ASSERT(DAPLKA_RS_TYPE(ep_rp) == DAPL_TYPE_EP);
2103
2104 new_state = old_state = daplka_ep_get_state(ep_rp);
2105 if (old_state != DAPLKA_EP_STATE_CLOSED) {
2106 DERR("ep_connect: invalid state %d\n", old_state);
2107 retval = EINVAL;
2108 goto cleanup;
2109 }
2110 if (args.epc_priv_sz > DAPL_MAX_PRIVATE_DATA_SIZE) {
2111 DERR("ep_connect: private data len (%d) exceeded "
2112 "max size %d\n", args.epc_priv_sz,
2113 DAPL_MAX_PRIVATE_DATA_SIZE);
2114 retval = EINVAL;
2115 goto cleanup;
2116 }
2117
2118 /*
2119 * check for remote ipaddress to dgid resolution needs ATS
2120 */
2121 dgid = &args.epc_dgid;
2122 dgid_ored = dgid->gid_guid | dgid->gid_prefix;
2123 #if defined(DAPLKA_DEBUG_FORCE_ATS)
2124 dgid_ored = 0ULL;
2125 #endif /* DAPLKA_DEBUG_FORCE_ATS */
2126 /* check for unidentified dgid */
2127 if (dgid_ored == 0ULL) {
2128 /*
2129 * setup for ibt_query_ar()
2130 */
2131 sgid = &ia_rp->ia_hca_sgid;
2132 ar_query_s.ar_gid.gid_guid = 0ULL;
2133 ar_query_s.ar_gid.gid_prefix = 0ULL;
2134 ar_query_s.ar_pkey = 0;
2135 bcopy(args.epc_raddr_sadata.iad_sadata,
2136 ar_query_s.ar_data, DAPL_ATS_NBYTES);
2137 #define UR(b) ar_query_s.ar_data[(b)]
2138 D3("daplka_ep_connect: SA[8] %d.%d.%d.%d\n",
2139 UR(8), UR(9), UR(10), UR(11));
2140 D3("daplka_ep_connect: SA[12] %d.%d.%d.%d\n",
2141 UR(12), UR(13), UR(14), UR(15));
2142 status = ibt_query_ar(sgid, &ar_query_s, &ar_result_s);
2143 if (status != IBT_SUCCESS) {
2144 DERR("ep_connect: ibt_query_ar returned %d\n", status);
2145 *rvalp = (int)status;
2146 retval = 0;
2147 goto cleanup;
2148 }
2149 /*
2150 * dgid identified from SA record
2151 */
2152 dgid = &ar_result_s.ar_gid;
2153 D2("daplka_ep_connect: ATS dgid=%llx:%llx\n",
2154 (longlong_t)dgid->gid_prefix, (longlong_t)dgid->gid_guid);
2155 }
2156
2157 bzero(&path_info, sizeof (ibt_path_info_t));
2158 bzero(&path_attr, sizeof (ibt_path_attr_t));
2159 bzero(&chan_args, sizeof (ibt_chan_open_args_t));
2160
2161 path_attr.pa_dgids = dgid;
2162 path_attr.pa_num_dgids = 1;
2163 /*
2164 * don't set sid in path_attr saves 1 SA query
2165 * Also makes server side not to write the service record
2166 */
2167 path_attr.pa_sgid = ia_rp->ia_hca_sgid;
2168 path_attr.pa_pkey = ia_rp->ia_port_pkey;
2169
2170 /* save the connection ep - struct copy */
2171 ep_rp->ep_sgid = ia_rp->ia_hca_sgid;
2172 ep_rp->ep_dgid = *dgid;
2173
2174 num_paths = 0;
2175 pathflags = IBT_PATH_PKEY;
2176 /* enable APM on remote port but not on loopback case */
2177 if (daplka_apm && ((dgid->gid_prefix != path_attr.pa_sgid.gid_prefix) ||
2178 (dgid->gid_guid != path_attr.pa_sgid.gid_guid))) {
2179 pathflags |= IBT_PATH_APM;
2180 }
2181 status = ibt_get_paths(daplka_dev->daplka_clnt_hdl,
2182 pathflags, &path_attr, 1, &path_info, &num_paths);
2183
2184 if (status != IBT_SUCCESS && status != IBT_INSUFF_DATA) {
2185 DERR("ep_connect: ibt_get_paths returned %d paths %d\n",
2186 status, num_paths);
2187 *rvalp = (int)status;
2188 retval = 0;
2189 goto cleanup;
2190 }
2191 /* fill in the sid directly to path_info */
2192 path_info.pi_sid = args.epc_sid;
2193 hca_attrp = &ia_rp->ia_hca->hca_attr;
2194
2195 /* fill in open channel args */
2196 chan_args.oc_path = &path_info;
2197 chan_args.oc_cm_handler = daplka_cm_rc_handler;
2198 chan_args.oc_cm_clnt_private = (void *)ep_rp;
2199 chan_args.oc_rdma_ra_out = hca_attrp->hca_max_rdma_out_chan;
2200 chan_args.oc_rdma_ra_in = hca_attrp->hca_max_rdma_in_chan;
2201 chan_args.oc_path_retry_cnt = 7; /* 3-bit field */
2202 chan_args.oc_path_rnr_retry_cnt = IBT_RNR_INFINITE_RETRY;
2203
2204 ASSERT(args.epc_priv_sz > 0);
2205 priv_data = (void *)args.epc_priv;
2206
2207 chan_args.oc_priv_data_len = args.epc_priv_sz;
2208 chan_args.oc_priv_data = priv_data;
2209
2210 /*
2211 * calculate checksum value of hello message and
2212 * put hello message in networking byte order
2213 */
2214 dp = (DAPL_PRIVATE *)priv_data;
2215 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*dp))
2216 dp->hello_msg.hi_port = htons(dp->hello_msg.hi_port);
2217 dp->hello_msg.hi_checksum = 0;
2218 dp->hello_msg.hi_checksum = htons(daplka_hellomsg_cksum(dp));
2219 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*dp))
2220
2221 if (args.epc_timeout > 0) {
2222 /*
2223 * increment refcnt before passing reference to
2224 * timer_info_alloc.
2225 */
2226 DAPLKA_RS_REF(ep_rp);
2227 timerp = daplka_timer_info_alloc(ep_rp);
2228 if (timerp == NULL) {
2229 DERR("ep_connect: cannot allocate timer\n");
2230 /*
2231 * we need to remove the reference if
2232 * allocation failed.
2233 */
2234 DAPLKA_RS_UNREF(ep_rp);
2235 retval = ENOMEM;
2236 goto cleanup;
2237 }
2238 /*
2239 * We generate our own hkeys so that timer_hkey can fit
2240 * into a pointer and passed as an arg to timeout()
2241 */
2242 timer_hkey = (uint64_t)daplka_timer_hkey_gen();
2243 retval = daplka_hash_insert(&daplka_timer_info_htbl,
2244 &timer_hkey, (void *)timerp);
2245 if (retval != 0) {
2246 DERR("ep_connect: cannot insert timer info\n");
2247 goto cleanup;
2248 }
2249 ASSERT(ep_rp->ep_timer_hkey == 0);
2250 ep_rp->ep_timer_hkey = timer_hkey;
2251 timer_inserted = B_TRUE;
2252 D2("ep_connect: timer_hkey = 0x%llx\n",
2253 (longlong_t)timer_hkey);
2254 }
2255 status = ibt_open_rc_channel(ep_rp->ep_chan_hdl, IBT_OCHAN_NO_FLAGS,
2256 IBT_NONBLOCKING, &chan_args, NULL);
2257
2258 if (status != IBT_SUCCESS) {
2259 DERR("ep_connect: ibt_open_rc_channel returned %d\n", status);
2260 *rvalp = (int)status;
2261 retval = 0;
2262 goto cleanup;
2263 }
2264 /*
2265 * if a cm callback gets called at this point, it'll have to wait until
2266 * ep_state becomes connecting (or some other state if another thread
2267 * manages to get ahead of the callback). this guarantees that the
2268 * callback will not touch the timer until it gets set.
2269 */
2270 if (timerp != NULL) {
2271 clock_t tmo;
2272
2273 tmo = drv_usectohz((clock_t)args.epc_timeout);
2274 /*
2275 * We generate our own 32 bit timer_hkey so that it can fit
2276 * into a pointer
2277 */
2278 ASSERT(timer_hkey != 0);
2279 timerp->ti_tmo_id = timeout(daplka_timer_handler,
2280 (void *)(uintptr_t)timer_hkey, tmo);
2281 }
2282 new_state = DAPLKA_EP_STATE_CONNECTING;
2283
2284 cleanup:;
2285 if (timerp != NULL && (retval != 0 || status != IBT_SUCCESS)) {
2286 /*
2287 * if ibt_open_rc_channel failed, the timerp must still
2288 * be in daplka_timer_info_htbl because neither the cm
2289 * callback nor the timer_handler will be called.
2290 */
2291 if (timer_inserted) {
2292 daplka_timer_info_t *new_timerp = NULL;
2293
2294 ASSERT(timer_hkey != 0);
2295 (void) daplka_hash_remove(&daplka_timer_info_htbl,
2296 timer_hkey, (void **)&new_timerp);
2297 ASSERT(new_timerp == timerp);
2298 ep_rp->ep_timer_hkey = 0;
2299 }
2300 daplka_timer_info_free(timerp);
2301 }
2302 daplka_ep_set_state(ep_rp, old_state, new_state);
2303 DAPLKA_RS_UNREF(ep_rp);
2304 D3("ep_connect: exit\n");
2305 return (retval);
2306 }
2307
2308 /*
2309 * ep_disconnect closes a connection with a remote peer.
2310 * if a connection has not been established, ep_disconnect
2311 * will instead flush all recv bufs posted to this channel.
2312 * if the EP state is CONNECTED, CONNECTING or ACCEPTING upon
2313 * entry to ep_disconnect, the EP state will transition to
2314 * DISCONNECTING upon exit. the CM callbacks triggered by
2315 * ibt_close_rc_channel will cause EP state to become
2316 * DISCONNECTED. This function is a no-op if EP state is
2317 * DISCONNECTED.
2318 */
2319 /* ARGSUSED */
2320 static int
2321 daplka_ep_disconnect(daplka_ia_resource_t *ia_rp, intptr_t arg, int mode,
2322 cred_t *cred, int *rvalp)
2323 {
2324 daplka_ep_resource_t *ep_rp = NULL;
2325 dapl_ep_disconnect_t args;
2326 ibt_status_t status;
2327 uint32_t old_state, new_state;
2328 int retval = 0;
2329
2330 retval = ddi_copyin((void *)arg, &args, sizeof (dapl_ep_disconnect_t),
2331 mode);
2332 if (retval != 0) {
2333 DERR("ep_disconnect: copyin error %d\n", retval);
2334 return (EFAULT);
2335 }
2336 ep_rp = (daplka_ep_resource_t *)
2337 daplka_hash_lookup(&ia_rp->ia_ep_htbl, args.epd_hkey);
2338 if (ep_rp == NULL) {
2339 DERR("ep_disconnect: cannot find ep resource\n");
2340 return (EINVAL);
2341 }
2342 ASSERT(DAPLKA_RS_TYPE(ep_rp) == DAPL_TYPE_EP);
2343
2344 new_state = old_state = daplka_ep_get_state(ep_rp);
2345 if (old_state != DAPLKA_EP_STATE_CONNECTED &&
2346 old_state != DAPLKA_EP_STATE_CONNECTING &&
2347 old_state != DAPLKA_EP_STATE_ACCEPTING &&
2348 old_state != DAPLKA_EP_STATE_DISCONNECTED &&
2349 old_state != DAPLKA_EP_STATE_DISCONNECTING &&
2350 old_state != DAPLKA_EP_STATE_CLOSED) {
2351 DERR("ep_disconnect: invalid state %d\n", old_state);
2352 retval = EINVAL;
2353 goto cleanup;
2354 }
2355
2356 if ((old_state == DAPLKA_EP_STATE_DISCONNECTED) ||
2357 (old_state == DAPLKA_EP_STATE_DISCONNECTING)) {
2358 D2("ep_disconnect: ep already disconnected\n");
2359 retval = 0;
2360 /* we leave the state as DISCONNECTED */
2361 goto cleanup;
2362 }
2363 if (old_state == DAPLKA_EP_STATE_CONNECTING ||
2364 old_state == DAPLKA_EP_STATE_ACCEPTING) {
2365 D2("ep_disconnect: aborting, old_state = %d\n", old_state);
2366 }
2367
2368 /*
2369 * according to the udapl spec, ep_disconnect should
2370 * flush the channel if the channel is not CONNECTED.
2371 */
2372 if (old_state == DAPLKA_EP_STATE_CLOSED) {
2373 status = ibt_flush_channel(ep_rp->ep_chan_hdl);
2374 if (status != IBT_SUCCESS) {
2375 DERR("ep_disconnect: ibt_flush_channel failed %d\n",
2376 status);
2377 *rvalp = (int)status;
2378 }
2379 retval = 0;
2380 /* we leave the state as CLOSED */
2381 goto cleanup;
2382 }
2383
2384 new_state = DAPLKA_EP_STATE_DISCONNECTING;
2385 daplka_ep_set_state(ep_rp, old_state, new_state);
2386 status = ibt_close_rc_channel(ep_rp->ep_chan_hdl, IBT_NONBLOCKING,
2387 NULL, 0, NULL, NULL, NULL);
2388
2389 if (status == IBT_SUCCESS) {
2390 DAPLKA_RS_UNREF(ep_rp);
2391 return (retval);
2392 } else {
2393 DERR("ep_disconnect: ibt_close_rc_channel returned %d\n",
2394 status);
2395 *rvalp = (int)status;
2396 retval = 0;
2397 new_state = old_state;
2398 }
2399
2400 cleanup:;
2401 daplka_ep_set_state(ep_rp, old_state, new_state);
2402 DAPLKA_RS_UNREF(ep_rp);
2403 return (retval);
2404 }
2405
2406 /*
2407 * this function resets the EP to a usable state (ie. from
2408 * DISCONNECTED to CLOSED). this function is best implemented using
2409 * the ibt_recycle_channel interface. until that is available, we will
2410 * instead clone and tear down the existing channel and replace the
2411 * existing channel with the cloned one.
2412 */
2413 /* ARGSUSED */
2414 static int
2415 daplka_ep_reinit(daplka_ia_resource_t *ia_rp, intptr_t arg, int mode,
2416 cred_t *cred, int *rvalp)
2417 {
2418 daplka_ep_resource_t *ep_rp = NULL;
2419 dapl_ep_reinit_t args;
2420 ibt_status_t status;
2421 uint32_t old_state, new_state;
2422 int retval = 0;
2423
2424 retval = ddi_copyin((void *)arg, &args, sizeof (dapl_ep_reinit_t),
2425 mode);
2426 if (retval != 0) {
2427 DERR("reinit: copyin error %d\n", retval);
2428 return (EFAULT);
2429 }
2430 ep_rp = (daplka_ep_resource_t *)
2431 daplka_hash_lookup(&ia_rp->ia_ep_htbl, args.epri_hkey);
2432 if (ep_rp == NULL) {
2433 DERR("reinit: cannot find ep resource\n");
2434 return (EINVAL);
2435 }
2436 ASSERT(DAPLKA_RS_TYPE(ep_rp) == DAPL_TYPE_EP);
2437 new_state = old_state = daplka_ep_get_state(ep_rp);
2438 if ((old_state != DAPLKA_EP_STATE_CLOSED) &&
2439 (old_state != DAPLKA_EP_STATE_DISCONNECTED)) {
2440 DERR("reinit: invalid state %d\n", old_state);
2441 retval = EINVAL;
2442 goto cleanup;
2443 }
2444
2445 status = ibt_recycle_rc(ep_rp->ep_chan_hdl,
2446 IBT_CEP_RDMA_RD|IBT_CEP_RDMA_WR,
2447 ia_rp->ia_port_num, NULL, NULL);
2448 if (status != IBT_SUCCESS) {
2449 DERR("reinit: unable to clone channel\n");
2450 *rvalp = (int)status;
2451 retval = 0;
2452 goto cleanup;
2453 }
2454 new_state = DAPLKA_EP_STATE_CLOSED;
2455
2456 cleanup:;
2457 daplka_ep_set_state(ep_rp, old_state, new_state);
2458 DAPLKA_RS_UNREF(ep_rp);
2459 return (retval);
2460 }
2461
2462 /*
2463 * destroys a EP resource.
2464 * called when refcnt drops to zero.
2465 */
2466 static int
2467 daplka_ep_destroy(daplka_resource_t *gen_rp)
2468 {
2469 daplka_ep_resource_t *ep_rp = (daplka_ep_resource_t *)gen_rp;
2470 ibt_status_t status;
2471
2472 ASSERT(DAPLKA_RS_REFCNT(ep_rp) == 0);
2473 ASSERT(ep_rp->ep_state == DAPLKA_EP_STATE_FREED);
2474
2475 /*
2476 * by the time we get here, we can be sure that
2477 * there is no outstanding timer.
2478 */
2479 ASSERT(ep_rp->ep_timer_hkey == 0);
2480
2481 D3("ep_destroy: entering, ep_rp 0x%p, rnum %d\n",
2482 ep_rp, DAPLKA_RS_RNUM(ep_rp));
2483 /*
2484 * free rc channel
2485 */
2486 if (ep_rp->ep_chan_hdl != NULL) {
2487 mutex_enter(&daplka_dev->daplka_mutex);
2488 ibt_set_chan_private(ep_rp->ep_chan_hdl, NULL);
2489 mutex_exit(&daplka_dev->daplka_mutex);
2490 status = daplka_ibt_free_channel(ep_rp, ep_rp->ep_chan_hdl);
2491 if (status != IBT_SUCCESS) {
2492 DERR("ep_free: ibt_free_channel returned %d\n",
2493 status);
2494 }
2495 ep_rp->ep_chan_hdl = NULL;
2496 D3("ep_destroy: qp freed, rnum %d\n", DAPLKA_RS_RNUM(ep_rp));
2497 }
2498 /*
2499 * release all references
2500 */
2501 if (ep_rp->ep_snd_evd != NULL) {
2502 DAPLKA_RS_UNREF(ep_rp->ep_snd_evd);
2503 ep_rp->ep_snd_evd = NULL;
2504 }
2505 if (ep_rp->ep_rcv_evd != NULL) {
2506 DAPLKA_RS_UNREF(ep_rp->ep_rcv_evd);
2507 ep_rp->ep_rcv_evd = NULL;
2508 }
2509 if (ep_rp->ep_conn_evd != NULL) {
2510 DAPLKA_RS_UNREF(ep_rp->ep_conn_evd);
2511 ep_rp->ep_conn_evd = NULL;
2512 }
2513 if (ep_rp->ep_srq_res != NULL) {
2514 DAPLKA_RS_UNREF(ep_rp->ep_srq_res);
2515 ep_rp->ep_srq_res = NULL;
2516 }
2517 if (ep_rp->ep_pd_res != NULL) {
2518 DAPLKA_RS_UNREF(ep_rp->ep_pd_res);
2519 ep_rp->ep_pd_res = NULL;
2520 }
2521 cv_destroy(&ep_rp->ep_cv);
2522 mutex_destroy(&ep_rp->ep_lock);
2523
2524 DAPLKA_RS_FINI(ep_rp);
2525 kmem_free(ep_rp, sizeof (daplka_ep_resource_t));
2526 D3("ep_destroy: exiting, ep_rp 0x%p\n", ep_rp);
2527 return (0);
2528 }
2529
2530 /*
2531 * this function is called by daplka_hash_destroy for
2532 * freeing EP resource objects
2533 */
2534 static void
2535 daplka_hash_ep_free(void *obj)
2536 {
2537 daplka_ep_resource_t *ep_rp = (daplka_ep_resource_t *)obj;
2538 ibt_status_t status;
2539 uint32_t old_state, new_state;
2540 int retval;
2541
2542 old_state = daplka_ep_get_state(ep_rp);
2543 retval = daplka_cancel_timer(ep_rp);
2544 new_state = DAPLKA_EP_STATE_FREED;
2545 daplka_ep_set_state(ep_rp, old_state, new_state);
2546
2547 if (retval != 0) {
2548 D2("hash_ep_free: ep_rp 0x%p "
2549 "timer is still being processed\n", ep_rp);
2550 mutex_enter(&ep_rp->ep_lock);
2551 if (ep_rp->ep_timer_hkey != 0) {
2552 D2("hash_ep_free: ep_rp 0x%p "
2553 "waiting for timer_hkey to be 0\n", ep_rp);
2554 cv_wait(&ep_rp->ep_cv, &ep_rp->ep_lock);
2555 }
2556 mutex_exit(&ep_rp->ep_lock);
2557 }
2558
2559 /* call ibt_close_rc_channel regardless of what state we are in */
2560 status = ibt_close_rc_channel(ep_rp->ep_chan_hdl, IBT_BLOCKING,
2561 NULL, 0, NULL, NULL, NULL);
2562 if (status != IBT_SUCCESS) {
2563 if (old_state == DAPLKA_EP_STATE_CONNECTED ||
2564 old_state == DAPLKA_EP_STATE_CONNECTING ||
2565 old_state == DAPLKA_EP_STATE_ACCEPTING) {
2566 DERR("hash_ep_free: ep_rp 0x%p state %d "
2567 "unexpected error %d from close_rc_channel\n",
2568 ep_rp, old_state, status);
2569 }
2570 D2("hash_ep_free: close_rc_channel, status %d\n", status);
2571 }
2572
2573 DAPLKA_RS_UNREF(ep_rp);
2574 }
2575
2576 /*
2577 * creates a EVD resource.
2578 * a EVD is used by the client to wait for events from one
2579 * or more sources.
2580 */
2581 /* ARGSUSED */
2582 static int
2583 daplka_evd_create(daplka_ia_resource_t *ia_rp, intptr_t arg, int mode,
2584 cred_t *cred, int *rvalp)
2585 {
2586 daplka_evd_resource_t *evd_rp = NULL;
2587 daplka_async_evd_hkey_t *async_evd;
2588 ibt_hca_attr_t *hca_attrp;
2589 ibt_cq_attr_t cq_attr;
2590 dapl_evd_create_t args;
2591 uint64_t evd_hkey = 0;
2592 boolean_t inserted = B_FALSE;
2593 int retval = 0;
2594 ibt_status_t status;
2595
2596 retval = ddi_copyin((void *)arg, &args, sizeof (dapl_evd_create_t),
2597 mode);
2598 if (retval != 0) {
2599 DERR("evd_create: copyin error %d", retval);
2600 return (EFAULT);
2601 }
2602 if ((args.evd_flags &
2603 ~(DAT_EVD_DEFAULT_FLAG | DAT_EVD_SOFTWARE_FLAG)) != 0) {
2604 DERR("evd_create: invalid flags 0x%x\n", args.evd_flags);
2605 return (EINVAL);
2606 }
2607
2608 evd_rp = kmem_zalloc(sizeof (daplka_evd_resource_t), daplka_km_flags);
2609 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*evd_rp))
2610 DAPLKA_RS_INIT(evd_rp, DAPL_TYPE_EVD,
2611 DAPLKA_RS_RNUM(ia_rp), daplka_evd_destroy);
2612
2613 mutex_init(&evd_rp->evd_lock, NULL, MUTEX_DRIVER, NULL);
2614 cv_init(&evd_rp->evd_cv, NULL, CV_DRIVER, NULL);
2615 evd_rp->evd_hca = ia_rp->ia_hca;
2616 evd_rp->evd_flags = args.evd_flags;
2617 evd_rp->evd_hca_hdl = ia_rp->ia_hca_hdl;
2618 evd_rp->evd_cookie = args.evd_cookie;
2619 evd_rp->evd_cno_res = NULL;
2620 evd_rp->evd_cr_events.eel_event_type = DAPLKA_EVD_CM_EVENTS;
2621 evd_rp->evd_conn_events.eel_event_type = DAPLKA_EVD_CM_EVENTS;
2622 evd_rp->evd_async_events.eel_event_type = DAPLKA_EVD_ASYNC_EVENTS;
2623
2624 /*
2625 * if the client specified a non-zero cno_hkey, we
2626 * lookup the cno and save the reference for later use.
2627 */
2628 if (args.evd_cno_hkey > 0) {
2629 daplka_cno_resource_t *cno_rp;
2630
2631 cno_rp = (daplka_cno_resource_t *)
2632 daplka_hash_lookup(&ia_rp->ia_cno_htbl,
2633 args.evd_cno_hkey);
2634 if (cno_rp == NULL) {
2635 DERR("evd_create: cannot find cno resource\n");
2636 goto cleanup;
2637 }
2638 ASSERT(DAPLKA_RS_TYPE(cno_rp) == DAPL_TYPE_CNO);
2639 evd_rp->evd_cno_res = cno_rp;
2640 }
2641 hca_attrp = &ia_rp->ia_hca->hca_attr;
2642 if ((evd_rp->evd_flags &
2643 (DAT_EVD_DTO_FLAG | DAT_EVD_RMR_BIND_FLAG)) != 0) {
2644 if (args.evd_cq_size > hca_attrp->hca_max_cq_sz) {
2645 DERR("evd_create: invalid cq size %d",
2646 args.evd_cq_size);
2647 retval = EINVAL;
2648 goto cleanup;
2649 }
2650 cq_attr.cq_size = args.evd_cq_size;
2651 cq_attr.cq_sched = NULL;
2652 cq_attr.cq_flags = IBT_CQ_USER_MAP;
2653
2654 status = daplka_ibt_alloc_cq(evd_rp, evd_rp->evd_hca_hdl,
2655 &cq_attr, &evd_rp->evd_cq_hdl, &evd_rp->evd_cq_real_size);
2656
2657 if (status != IBT_SUCCESS) {
2658 DERR("evd_create: ibt_alloc_cq returned %d", status);
2659 *rvalp = (int)status;
2660 retval = 0;
2661 goto cleanup;
2662 }
2663
2664 /*
2665 * store evd ptr with cq_hdl
2666 * mutex is only needed for race of "destroy" and "async"
2667 */
2668 mutex_enter(&daplka_dev->daplka_mutex);
2669 ibt_set_cq_private(evd_rp->evd_cq_hdl, (void *)evd_rp);
2670 mutex_exit(&daplka_dev->daplka_mutex);
2671
2672 /* Get HCA-specific data_out info */
2673 status = ibt_ci_data_out(evd_rp->evd_hca_hdl,
2674 IBT_CI_NO_FLAGS, IBT_HDL_CQ, (void *)evd_rp->evd_cq_hdl,
2675 &args.evd_cq_data_out, sizeof (args.evd_cq_data_out));
2676
2677 if (status != IBT_SUCCESS) {
2678 DERR("evd_create: ibt_ci_data_out error(%d)", status);
2679 *rvalp = (int)status;
2680 retval = 0;
2681 goto cleanup;
2682 }
2683
2684 args.evd_cq_real_size = evd_rp->evd_cq_real_size;
2685
2686 ibt_set_cq_handler(evd_rp->evd_cq_hdl, daplka_cq_handler,
2687 (void *)evd_rp);
2688 }
2689
2690 retval = daplka_hash_insert(&ia_rp->ia_evd_htbl,
2691 &evd_hkey, (void *)evd_rp);
2692 if (retval != 0) {
2693 DERR("evd_ceate: cannot insert evd %d\n", retval);
2694 goto cleanup;
2695 }
2696 inserted = B_TRUE;
2697 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*evd_rp))
2698
2699 /*
2700 * If this evd handles async events need to add to the IA resource
2701 * async evd list
2702 */
2703 if (evd_rp->evd_flags & DAT_EVD_ASYNC_FLAG) {
2704 async_evd = kmem_zalloc(sizeof (daplka_async_evd_hkey_t),
2705 daplka_km_flags);
2706 /* add the evd to the head of the list */
2707 mutex_enter(&ia_rp->ia_lock);
2708 async_evd->aeh_evd_hkey = evd_hkey;
2709 async_evd->aeh_next = ia_rp->ia_async_evd_hkeys;
2710 ia_rp->ia_async_evd_hkeys = async_evd;
2711 mutex_exit(&ia_rp->ia_lock);
2712 }
2713
2714 args.evd_hkey = evd_hkey;
2715 retval = copyout(&args, (void *)arg, sizeof (dapl_evd_create_t));
2716 if (retval != 0) {
2717 DERR("evd_create: copyout error %d\n", retval);
2718 retval = EFAULT;
2719 goto cleanup;
2720 }
2721 return (0);
2722
2723 cleanup:;
2724 if (inserted) {
2725 daplka_evd_resource_t *free_rp = NULL;
2726
2727 (void) daplka_hash_remove(&ia_rp->ia_evd_htbl, evd_hkey,
2728 (void **)&free_rp);
2729 if (free_rp != evd_rp) {
2730 DERR("evd_create: cannot remove evd\n");
2731 /*
2732 * we can only get here if another thread
2733 * has completed the cleanup in evd_free
2734 */
2735 return (retval);
2736 }
2737 }
2738 DAPLKA_RS_UNREF(evd_rp);
2739 return (retval);
2740 }
2741
2742 /*
2743 * resizes CQ and returns new mapping info to library.
2744 */
2745 /* ARGSUSED */
2746 static int
2747 daplka_cq_resize(daplka_ia_resource_t *ia_rp, intptr_t arg, int mode,
2748 cred_t *cred, int *rvalp)
2749 {
2750 daplka_evd_resource_t *evd_rp = NULL;
2751 ibt_hca_attr_t *hca_attrp;
2752 dapl_cq_resize_t args;
2753 ibt_status_t status;
2754 int retval = 0;
2755
2756 retval = ddi_copyin((void *)arg, &args, sizeof (dapl_cq_resize_t),
2757 mode);
2758 if (retval != 0) {
2759 DERR("cq_resize: copyin error %d\n", retval);
2760 return (EFAULT);
2761 }
2762
2763 /* get evd resource */
2764 evd_rp = (daplka_evd_resource_t *)
2765 daplka_hash_lookup(&ia_rp->ia_evd_htbl, args.cqr_evd_hkey);
2766 if (evd_rp == NULL) {
2767 DERR("cq_resize: cannot find evd resource\n");
2768 return (EINVAL);
2769 }
2770 ASSERT(DAPLKA_RS_TYPE(evd_rp) == DAPL_TYPE_EVD);
2771
2772 hca_attrp = &ia_rp->ia_hca->hca_attr;
2773 if (args.cqr_cq_new_size > hca_attrp->hca_max_cq_sz) {
2774 DERR("cq_resize: invalid cq size %d", args.cqr_cq_new_size);
2775 retval = EINVAL;
2776 goto cleanup;
2777 }
2778 /*
2779 * If ibt_resize_cq fails that it is primarily due to resource
2780 * shortage. Per IB spec resize will never loose events and
2781 * a resize error leaves the CQ intact. Therefore even if the
2782 * resize request fails we proceed and get the mapping data
2783 * from the CQ so that the library can mmap it.
2784 */
2785 status = ibt_resize_cq(evd_rp->evd_cq_hdl, args.cqr_cq_new_size,
2786 &args.cqr_cq_real_size);
2787 if (status != IBT_SUCCESS) {
2788 /* we return the size of the old CQ if resize fails */
2789 args.cqr_cq_real_size = evd_rp->evd_cq_real_size;
2790 ASSERT(status != IBT_CQ_HDL_INVALID);
2791 DERR("cq_resize: ibt_resize_cq failed:%d\n", status);
2792 } else {
2793 mutex_enter(&evd_rp->evd_lock);
2794 evd_rp->evd_cq_real_size = args.cqr_cq_real_size;
2795 mutex_exit(&evd_rp->evd_lock);
2796 }
2797
2798 D2("cq_resize(%d): done new_sz(%u) real_sz(%u)\n",
2799 DAPLKA_RS_RNUM(evd_rp),
2800 args.cqr_cq_new_size, args.cqr_cq_real_size);
2801
2802 /* Get HCA-specific data_out info */
2803 status = ibt_ci_data_out(evd_rp->evd_hca_hdl,
2804 IBT_CI_NO_FLAGS, IBT_HDL_CQ, (void *)evd_rp->evd_cq_hdl,
2805 &args.cqr_cq_data_out, sizeof (args.cqr_cq_data_out));
2806 if (status != IBT_SUCCESS) {
2807 DERR("cq_resize: ibt_ci_data_out error(%d)\n", status);
2808 /* return ibt_ci_data_out status */
2809 *rvalp = (int)status;
2810 retval = 0;
2811 goto cleanup;
2812 }
2813
2814 retval = ddi_copyout(&args, (void *)arg, sizeof (dapl_cq_resize_t),
2815 mode);
2816 if (retval != 0) {
2817 DERR("cq_resize: copyout error %d\n", retval);
2818 retval = EFAULT;
2819 goto cleanup;
2820 }
2821
2822 cleanup:;
2823 if (evd_rp != NULL) {
2824 DAPLKA_RS_UNREF(evd_rp);
2825 }
2826 return (retval);
2827 }
2828
2829 /*
2830 * Routine to copyin the event poll message so that 32 bit libraries
2831 * can be safely supported
2832 */
2833 int
2834 daplka_event_poll_copyin(intptr_t inarg, dapl_event_poll_t *outarg, int mode)
2835 {
2836 int retval;
2837
2838 #ifdef _MULTI_DATAMODEL
2839 if ((mode & DATAMODEL_MASK) == DATAMODEL_ILP32) {
2840 dapl_event_poll32_t args32;
2841
2842 retval = ddi_copyin((void *)inarg, &args32,
2843 sizeof (dapl_event_poll32_t), mode);
2844 if (retval != 0) {
2845 DERR("event_poll_copyin: 32bit error %d\n", retval);
2846 return (EFAULT);
2847 }
2848
2849 outarg->evp_evd_hkey = args32.evp_evd_hkey;
2850 outarg->evp_threshold = args32.evp_threshold;
2851 outarg->evp_timeout = args32.evp_timeout;
2852 outarg->evp_ep = (dapl_ib_event_t *)(uintptr_t)args32.evp_ep;
2853 outarg->evp_num_ev = args32.evp_num_ev;
2854 outarg->evp_num_polled = args32.evp_num_polled;
2855 return (0);
2856 }
2857 #endif
2858 retval = ddi_copyin((void *)inarg, outarg, sizeof (dapl_event_poll_t),
2859 mode);
2860 if (retval != 0) {
2861 DERR("event_poll: copyin error %d\n", retval);
2862 return (EFAULT);
2863 }
2864
2865 return (0);
2866 }
2867
2868 /*
2869 * Routine to copyout the event poll message so that 32 bit libraries
2870 * can be safely supported
2871 */
2872 int
2873 daplka_event_poll_copyout(dapl_event_poll_t *inarg, intptr_t outarg, int mode)
2874 {
2875 int retval;
2876
2877 #ifdef _MULTI_DATAMODEL
2878 if ((mode & DATAMODEL_MASK) == DATAMODEL_ILP32) {
2879 dapl_event_poll32_t args32;
2880
2881 args32.evp_evd_hkey = inarg->evp_evd_hkey;
2882 args32.evp_threshold = inarg->evp_threshold;
2883 args32.evp_timeout = inarg->evp_timeout;
2884 args32.evp_ep = (caddr32_t)(uintptr_t)inarg->evp_ep;
2885 args32.evp_num_ev = inarg->evp_num_ev;
2886 args32.evp_num_polled = inarg->evp_num_polled;
2887
2888 retval = ddi_copyout((void *)&args32, (void *)outarg,
2889 sizeof (dapl_event_poll32_t), mode);
2890 if (retval != 0) {
2891 DERR("event_poll_copyout: 32bit error %d\n", retval);
2892 return (EFAULT);
2893 }
2894 return (0);
2895 }
2896 #endif
2897 retval = ddi_copyout((void *)inarg, (void *)outarg,
2898 sizeof (dapl_event_poll_t), mode);
2899 if (retval != 0) {
2900 DERR("event_poll_copyout: error %d\n", retval);
2901 return (EFAULT);
2902 }
2903
2904 return (0);
2905 }
2906
2907 /*
2908 * fucntion to handle CM REQ RCV private data from Solaris or third parties
2909 */
2910 /* ARGSUSED */
2911 static void
2912 daplka_crevent_privdata_post(daplka_ia_resource_t *ia_rp,
2913 dapl_ib_event_t *evd_rp, daplka_evd_event_t *cr_ev)
2914 {
2915 DAPL_PRIVATE *dp;
2916 ib_gid_t *lgid;
2917 ibt_ar_t ar_query_s;
2918 ibt_ar_t ar_result_s;
2919 DAPL_HELLO_MSG *hip;
2920 uint32_t ipaddr_ord;
2921 ibt_priv_data_len_t clen;
2922 ibt_priv_data_len_t olen;
2923 ibt_status_t status;
2924 uint16_t cksum;
2925
2926 /*
2927 * get private data and len
2928 */
2929 dp = (DAPL_PRIVATE *)cr_ev->ee_cmev.ec_cm_ev_priv_data;
2930 clen = cr_ev->ee_cmev.ec_cm_ev_priv_data_len;
2931 #if defined(DAPLKA_DEBUG_FORCE_ATS)
2932 /* skip the DAPL_PRIVATE chekcsum check */
2933 #else
2934 /* for remote connects */
2935 /* look up hello message in the CM private data area */
2936 if (clen >= sizeof (DAPL_PRIVATE) &&
2937 (dp->hello_msg.hi_vers == DAPL_HELLO_MSG_VERS)) {
2938 cksum = ntohs(dp->hello_msg.hi_checksum);
2939 dp->hello_msg.hi_checksum = 0;
2940 if (daplka_hellomsg_cksum(dp) == cksum) {
2941 D2("daplka_crevent_privdata_post: Solaris msg\n");
2942 evd_rp->ibe_ce.ibce_priv_data_size = clen;
2943 dp->hello_msg.hi_checksum = DAPL_CHECKSUM;
2944 dp->hello_msg.hi_port = ntohs(dp->hello_msg.hi_port);
2945 bcopy(dp, evd_rp->ibe_ce.ibce_priv_data_ptr, clen);
2946 kmem_free(dp, clen);
2947 return;
2948 }
2949 }
2950 #endif /* DAPLKA_DEBUG_FORCE_ATS */
2951
2952 D2("daplka_crevent_privdata_post: 3rd party msg\n");
2953 /* transpose CM private data into hello message */
2954 if (clen) {
2955 olen = clen;
2956 if (clen > DAPL_CONSUMER_MAX_PRIVATE_DATA_SIZE) {
2957 clen = DAPL_CONSUMER_MAX_PRIVATE_DATA_SIZE;
2958 }
2959 bcopy(dp, evd_rp->ibe_ce.ibce_priv_data_ptr, clen);
2960 kmem_free(dp, olen);
2961 } else {
2962 bzero(evd_rp->ibe_ce.ibce_priv_data_ptr,
2963 DAPL_CONSUMER_MAX_PRIVATE_DATA_SIZE);
2964 }
2965 evd_rp->ibe_ce.ibce_priv_data_size = sizeof (DAPL_PRIVATE);
2966 dp = (DAPL_PRIVATE *)evd_rp->ibe_ce.ibce_priv_data_ptr;
2967 /*
2968 * fill in hello message
2969 */
2970 hip = &dp->hello_msg;
2971 hip->hi_checksum = DAPL_CHECKSUM;
2972 hip->hi_clen = clen;
2973 hip->hi_mid = 0;
2974 hip->hi_vers = DAPL_HELLO_MSG_VERS;
2975 hip->hi_port = 0;
2976
2977 /* assign sgid and dgid */
2978 lgid = &ia_rp->ia_hca_sgid;
2979 ar_query_s.ar_gid.gid_prefix =
2980 cr_ev->ee_cmev.ec_cm_req_prim_addr.gid_prefix;
2981 ar_query_s.ar_gid.gid_guid =
2982 cr_ev->ee_cmev.ec_cm_req_prim_addr.gid_guid;
2983 ar_query_s.ar_pkey = ia_rp->ia_port_pkey;
2984 bzero(ar_query_s.ar_data, DAPL_ATS_NBYTES);
2985
2986 /* reverse ip address lookup through ATS */
2987 status = ibt_query_ar(lgid, &ar_query_s, &ar_result_s);
2988 if (status == IBT_SUCCESS) {
2989 bcopy(ar_result_s.ar_data, hip->hi_saaddr, DAPL_ATS_NBYTES);
2990 /* determine the address families */
2991 ipaddr_ord = hip->hi_v4pad[0] | hip->hi_v4pad[1] |
2992 hip->hi_v4pad[2];
2993 if (ipaddr_ord == 0) {
2994 hip->hi_ipv = AF_INET;
2995 } else {
2996 hip->hi_ipv = AF_INET6;
2997 }
2998
2999 #define UL(b) ar_result_s.ar_data[(b)]
3000 D3("daplka_privdata_post: family=%d :SA[8] %d.%d.%d.%d\n",
3001 hip->hi_ipv, UL(8), UL(9), UL(10), UL(11));
3002 D3("daplka_privdata_post: SA[12] %d.%d.%d.%d\n",
3003 UL(12), UL(13), UL(14), UL(15));
3004 } else {
3005 /* non-conformed third parties */
3006 hip->hi_ipv = AF_UNSPEC;
3007 bzero(hip->hi_saaddr, DAPL_ATS_NBYTES);
3008 }
3009 }
3010
3011 /*
3012 * this function is called by evd_wait and evd_dequeue to wait for
3013 * connection events and CQ notifications. typically this function
3014 * is called when the userland CQ is empty and the client has
3015 * specified a non-zero timeout to evd_wait. if the client is
3016 * interested in CQ events, the CQ must be armed in userland prior
3017 * to calling this function.
3018 */
3019 /* ARGSUSED */
3020 static int
3021 daplka_event_poll(daplka_ia_resource_t *ia_rp, intptr_t arg, int mode,
3022 cred_t *cred, int *rvalp)
3023 {
3024 daplka_evd_resource_t *evd_rp = NULL;
3025 dapl_event_poll_t args;
3026 daplka_evd_event_t *head;
3027 dapl_ib_event_t evp_arr[NUM_EVENTS_PER_POLL];
3028 dapl_ib_event_t *evp;
3029 dapl_ib_event_t *evp_start;
3030 size_t evp_size;
3031 int threshold;
3032 clock_t timeout;
3033 uint32_t max_events;
3034 uint32_t num_events = 0;
3035 void *pd;
3036 ibt_priv_data_len_t n;
3037 int retval = 0;
3038 int rc;
3039
3040 retval = daplka_event_poll_copyin(arg, &args, mode);
3041 if (retval != 0) {
3042 return (EFAULT);
3043 }
3044
3045 if ((args.evp_num_ev > 0) && (args.evp_ep == NULL)) {
3046 DERR("event_poll: evp_ep cannot be NULL if num_wc=%d",
3047 args.evp_num_ev);
3048 return (EINVAL);
3049 }
3050 /*
3051 * Note: dequeue requests have a threshold = 0, timeout = 0
3052 */
3053 threshold = args.evp_threshold;
3054
3055 max_events = args.evp_num_ev;
3056 /* ensure library is passing sensible values */
3057 if (max_events < threshold) {
3058 DERR("event_poll: max_events(%d) < threshold(%d)\n",
3059 max_events, threshold);
3060 return (EINVAL);
3061 }
3062 /* Do a sanity check to avoid excessive memory allocation */
3063 if (max_events > DAPL_EVD_MAX_EVENTS) {
3064 DERR("event_poll: max_events(%d) > %d",
3065 max_events, DAPL_EVD_MAX_EVENTS);
3066 return (EINVAL);
3067 }
3068 D4("event_poll: threshold(%d) timeout(0x%llx) max_events(%d)\n",
3069 threshold, (longlong_t)args.evp_timeout, max_events);
3070
3071 /* get evd resource */
3072 evd_rp = (daplka_evd_resource_t *)
3073 daplka_hash_lookup(&ia_rp->ia_evd_htbl, args.evp_evd_hkey);
3074 if (evd_rp == NULL) {
3075 DERR("event_poll: cannot find evd resource\n");
3076 return (EINVAL);
3077 }
3078 ASSERT(DAPLKA_RS_TYPE(evd_rp) == DAPL_TYPE_EVD);
3079
3080 /*
3081 * Use event array on the stack if possible
3082 */
3083 if (max_events <= NUM_EVENTS_PER_POLL) {
3084 evp_start = evp = &evp_arr[0];
3085 } else {
3086 evp_size = max_events * sizeof (dapl_ib_event_t);
3087 evp_start = evp = kmem_zalloc(evp_size, daplka_km_flags);
3088 if (evp == NULL) {
3089 DERR("event_poll: kmem_zalloc failed, evp_size %d",
3090 evp_size);
3091 retval = ENOMEM;
3092 goto cleanup;
3093 }
3094 }
3095
3096 /*
3097 * The Event poll algorithm is as follows -
3098 * The library passes a buffer big enough to hold "max_events"
3099 * events. max_events is >= threshold. If at any stage we get
3100 * max_events no. of events we bail. The events are polled in
3101 * the following order -
3102 * 1) Check for CR events in the evd_cr_events list
3103 * 2) Check for Connection events in the evd_connection_events list
3104 *
3105 * If after the above 2 steps we don't have enough(>= threshold) events
3106 * we block for CQ notification and sleep. Upon being woken up we start
3107 * at step 1 again.
3108 */
3109
3110 /*
3111 * Note: this could be 0 or INFINITE or anyother value in microsec
3112 */
3113 if (args.evp_timeout > 0) {
3114 if (args.evp_timeout >= LONG_MAX) {
3115 timeout = LONG_MAX;
3116 } else {
3117 clock_t curr_time = ddi_get_lbolt();
3118
3119 timeout = curr_time +
3120 drv_usectohz((clock_t)args.evp_timeout);
3121 /*
3122 * use the max value if we wrapped around
3123 */
3124 if (timeout <= curr_time) {
3125 timeout = LONG_MAX;
3126 }
3127 }
3128 } else {
3129 timeout = 0;
3130 }
3131
3132 mutex_enter(&evd_rp->evd_lock);
3133 for (;;) {
3134 /*
3135 * If this evd is waiting for CM events check that now.
3136 */
3137 if ((evd_rp->evd_flags & DAT_EVD_CR_FLAG) &&
3138 (evd_rp->evd_cr_events.eel_num_elements > 0)) {
3139 /* dequeue events from evd_cr_events list */
3140 while (head = daplka_evd_event_dequeue(
3141 &evd_rp->evd_cr_events)) {
3142 /*
3143 * populate the evp array
3144 */
3145 evp[num_events].ibe_ev_family = DAPL_CR_EVENTS;
3146 evp[num_events].ibe_ce.ibce_event =
3147 head->ee_cmev.ec_cm_ev_type;
3148 evp[num_events].ibe_ce.ibce_cookie =
3149 (uint64_t)head->ee_cmev.ec_cm_cookie;
3150 evp[num_events].ibe_ce.ibce_psep_cookie =
3151 head->ee_cmev.ec_cm_psep_cookie;
3152 daplka_crevent_privdata_post(ia_rp,
3153 &evp[num_events], head);
3154 kmem_free(head, sizeof (daplka_evd_event_t));
3155
3156 if (++num_events == max_events) {
3157 mutex_exit(&evd_rp->evd_lock);
3158 goto maxevent_reached;
3159 }
3160 }
3161 }
3162
3163 if ((evd_rp->evd_flags & DAT_EVD_CONNECTION_FLAG) &&
3164 (evd_rp->evd_conn_events.eel_num_elements > 0)) {
3165 /* dequeue events from evd_connection_events list */
3166 while ((head = daplka_evd_event_dequeue
3167 (&evd_rp->evd_conn_events))) {
3168 /*
3169 * populate the evp array -
3170 *
3171 */
3172 if (head->ee_cmev.ec_cm_is_passive) {
3173 evp[num_events].ibe_ev_family =
3174 DAPL_PASSIVE_CONNECTION_EVENTS;
3175 } else {
3176 evp[num_events].ibe_ev_family =
3177 DAPL_ACTIVE_CONNECTION_EVENTS;
3178 }
3179 evp[num_events].ibe_ce.ibce_event =
3180 head->ee_cmev.ec_cm_ev_type;
3181 evp[num_events].ibe_ce.ibce_cookie =
3182 (uint64_t)head->ee_cmev.ec_cm_cookie;
3183 evp[num_events].ibe_ce.ibce_psep_cookie =
3184 head->ee_cmev.ec_cm_psep_cookie;
3185
3186 if (head->ee_cmev.ec_cm_ev_priv_data_len > 0) {
3187 pd = head->ee_cmev.ec_cm_ev_priv_data;
3188 n = head->
3189 ee_cmev.ec_cm_ev_priv_data_len;
3190 bcopy(pd, (void *)evp[num_events].
3191 ibe_ce.ibce_priv_data_ptr, n);
3192 evp[num_events].ibe_ce.
3193 ibce_priv_data_size = n;
3194 kmem_free(pd, n);
3195 }
3196
3197 kmem_free(head, sizeof (daplka_evd_event_t));
3198
3199 if (++num_events == max_events) {
3200 mutex_exit(&evd_rp->evd_lock);
3201 goto maxevent_reached;
3202 }
3203 }
3204 }
3205
3206 if ((evd_rp->evd_flags & DAT_EVD_ASYNC_FLAG) &&
3207 (evd_rp->evd_async_events.eel_num_elements > 0)) {
3208 /* dequeue events from evd_async_events list */
3209 while (head = daplka_evd_event_dequeue(
3210 &evd_rp->evd_async_events)) {
3211 /*
3212 * populate the evp array
3213 */
3214 evp[num_events].ibe_ev_family =
3215 DAPL_ASYNC_EVENTS;
3216 evp[num_events].ibe_async.ibae_type =
3217 head->ee_aev.ibae_type;
3218 evp[num_events].ibe_async.ibae_hca_guid =
3219 head->ee_aev.ibae_hca_guid;
3220 evp[num_events].ibe_async.ibae_cookie =
3221 head->ee_aev.ibae_cookie;
3222 evp[num_events].ibe_async.ibae_port =
3223 head->ee_aev.ibae_port;
3224
3225 kmem_free(head, sizeof (daplka_evd_event_t));
3226
3227 if (++num_events == max_events) {
3228 break;
3229 }
3230 }
3231 }
3232
3233 /*
3234 * We have sufficient events for this call so no need to wait
3235 */
3236 if ((threshold > 0) && (num_events >= threshold)) {
3237 mutex_exit(&evd_rp->evd_lock);
3238 break;
3239 }
3240
3241 evd_rp->evd_waiters++;
3242 /*
3243 * There are no new events and a timeout was specified.
3244 * Note: for CQ events threshold is 0 but timeout is
3245 * not necessarily 0.
3246 */
3247 while ((evd_rp->evd_newevents == DAPLKA_EVD_NO_EVENTS) &&
3248 timeout) {
3249 retval = DAPLKA_EVD_WAIT(&evd_rp->evd_cv,
3250 &evd_rp->evd_lock, timeout);
3251 if (retval == 0) {
3252 retval = EINTR;
3253 break;
3254 } else if (retval == -1) {
3255 retval = ETIME;
3256 break;
3257 } else {
3258 retval = 0;
3259 continue;
3260 }
3261 }
3262 evd_rp->evd_waiters--;
3263 if (evd_rp->evd_newevents != DAPLKA_EVD_NO_EVENTS) {
3264 /*
3265 * If we got woken up by the CQ handler due to events
3266 * in the CQ. Need to go to userland to check for
3267 * CQ events. Or if we were woken up due to S/W events
3268 */
3269
3270 /* check for userland events only */
3271 if (!(evd_rp->evd_newevents &
3272 ~DAPLKA_EVD_ULAND_EVENTS)) {
3273 evd_rp->evd_newevents = DAPLKA_EVD_NO_EVENTS;
3274 mutex_exit(&evd_rp->evd_lock);
3275 break;
3276 }
3277 /*
3278 * Clear newevents since we are going to loopback
3279 * back and check for both CM and CQ events
3280 */
3281 evd_rp->evd_newevents = DAPLKA_EVD_NO_EVENTS;
3282 } else { /* error */
3283 mutex_exit(&evd_rp->evd_lock);
3284 break;
3285 }
3286 }
3287
3288 maxevent_reached:
3289 args.evp_num_polled = num_events;
3290
3291 /*
3292 * At this point retval might have a value that we want to return
3293 * back to the user. So the copyouts shouldn't tamper retval.
3294 */
3295 if (args.evp_num_polled > 0) { /* copyout the events */
3296 rc = ddi_copyout(evp, args.evp_ep, args.evp_num_polled *
3297 sizeof (dapl_ib_event_t), mode);
3298 if (rc != 0) { /* XXX: we are losing events here */
3299 DERR("event_poll: event array copyout error %d", rc);
3300 retval = EFAULT;
3301 goto cleanup;
3302 }
3303 rc = daplka_event_poll_copyout(&args, arg, mode);
3304 if (rc != 0) { /* XXX: we are losing events here */
3305 DERR("event_poll: copyout error %d\n", rc);
3306 retval = EFAULT;
3307 goto cleanup;
3308 }
3309 }
3310
3311 cleanup:;
3312 if ((max_events > NUM_EVENTS_PER_POLL) && (evp_start != NULL)) {
3313 kmem_free(evp_start, evp_size);
3314 }
3315
3316 if (evd_rp != NULL) {
3317 DAPLKA_RS_UNREF(evd_rp);
3318 }
3319 return (retval);
3320 }
3321
3322 /* ARGSUSED */
3323 static int
3324 daplka_event_wakeup(daplka_ia_resource_t *ia_rp, intptr_t arg, int mode,
3325 cred_t *cred, int *rvalp)
3326 {
3327 dapl_event_wakeup_t args;
3328 daplka_evd_resource_t *evd_rp;
3329 int retval;
3330
3331 retval = ddi_copyin((void *)arg, &args, sizeof (dapl_event_wakeup_t),
3332 mode);
3333 if (retval != 0) {
3334 DERR("event_wakeup: copyin error %d\n", retval);
3335 return (EFAULT);
3336 }
3337
3338 /* get evd resource */
3339 evd_rp = (daplka_evd_resource_t *)
3340 daplka_hash_lookup(&ia_rp->ia_evd_htbl, args.evw_hkey);
3341 if (evd_rp == NULL) {
3342 DERR("event_wakeup: cannot find evd resource\n");
3343 return (EINVAL);
3344 }
3345 ASSERT(DAPLKA_RS_TYPE(evd_rp) == DAPL_TYPE_EVD);
3346
3347 daplka_evd_wakeup(evd_rp, NULL, NULL);
3348
3349 DAPLKA_RS_UNREF(evd_rp);
3350
3351 return (retval);
3352 }
3353
3354 /* ARGSUSED */
3355 static int
3356 daplka_evd_modify_cno(daplka_ia_resource_t *ia_rp, intptr_t arg, int mode,
3357 cred_t *cred, int *rvalp)
3358 {
3359 dapl_evd_modify_cno_t args;
3360 daplka_evd_resource_t *evd_rp;
3361 daplka_cno_resource_t *cno_rp;
3362 daplka_cno_resource_t *old_cno_rp;
3363 int retval;
3364
3365 retval = ddi_copyin((void *)arg, &args, sizeof (dapl_evd_modify_cno_t),
3366 mode);
3367 if (retval != 0) {
3368 DERR("evd_modify_cno: copyin error %d\n", retval);
3369 return (EFAULT);
3370 }
3371
3372 /* get evd resource */
3373 evd_rp = (daplka_evd_resource_t *)
3374 daplka_hash_lookup(&ia_rp->ia_evd_htbl, args.evmc_hkey);
3375 if (evd_rp == NULL) {
3376 DERR("evd_modify_cno: cannot find evd resource\n");
3377 retval = EINVAL;
3378 goto cleanup;
3379 }
3380 ASSERT(DAPLKA_RS_TYPE(evd_rp) == DAPL_TYPE_EVD);
3381
3382 if (args.evmc_cno_hkey > 0) {
3383 /* get cno resource corresponding to the new CNO */
3384 cno_rp = (daplka_cno_resource_t *)
3385 daplka_hash_lookup(&ia_rp->ia_cno_htbl,
3386 args.evmc_cno_hkey);
3387 if (cno_rp == NULL) {
3388 DERR("evd_modify_cno: cannot find CNO resource\n");
3389 retval = EINVAL;
3390 goto cleanup;
3391 }
3392 ASSERT(DAPLKA_RS_TYPE(cno_rp) == DAPL_TYPE_CNO);
3393 } else {
3394 cno_rp = NULL;
3395 }
3396
3397 mutex_enter(&evd_rp->evd_lock);
3398 old_cno_rp = evd_rp->evd_cno_res;
3399 evd_rp->evd_cno_res = cno_rp;
3400 mutex_exit(&evd_rp->evd_lock);
3401
3402 /*
3403 * drop the refcnt on the old CNO, the refcnt on the new CNO is
3404 * retained since the evd holds a reference to it.
3405 */
3406 if (old_cno_rp) {
3407 DAPLKA_RS_UNREF(old_cno_rp);
3408 }
3409
3410 cleanup:
3411 if (evd_rp) {
3412 DAPLKA_RS_UNREF(evd_rp);
3413 }
3414
3415 return (retval);
3416 }
3417
3418 /*
3419 * Frees the EVD and associated resources.
3420 * If there are other threads still using this EVD, the destruction
3421 * will defer until the EVD's refcnt drops to zero.
3422 */
3423 /* ARGSUSED */
3424 static int
3425 daplka_evd_free(daplka_ia_resource_t *ia_rp, intptr_t arg, int mode,
3426 cred_t *cred, int *rvalp)
3427 {
3428 daplka_evd_resource_t *evd_rp = NULL;
3429 daplka_async_evd_hkey_t *curr;
3430 daplka_async_evd_hkey_t *prev;
3431 dapl_evd_free_t args;
3432 int retval = 0;
3433
3434 retval = ddi_copyin((void *)arg, &args, sizeof (dapl_evd_free_t), mode);
3435 if (retval != 0) {
3436 DERR("evd_free: copyin error %d\n", retval);
3437 return (EFAULT);
3438 }
3439 retval = daplka_hash_remove(&ia_rp->ia_evd_htbl, args.evf_hkey,
3440 (void **)&evd_rp);
3441 if (retval != 0 || evd_rp == NULL) {
3442 DERR("evd_free: cannot find evd resource\n");
3443 return (EINVAL);
3444 }
3445 ASSERT(DAPLKA_RS_TYPE(evd_rp) == DAPL_TYPE_EVD);
3446
3447 /* If this is an async evd remove it from the IA's async evd list */
3448 if (evd_rp->evd_flags & DAT_EVD_ASYNC_FLAG) {
3449 mutex_enter(&ia_rp->ia_lock);
3450 curr = prev = ia_rp->ia_async_evd_hkeys;
3451 while (curr != NULL) {
3452 if (curr->aeh_evd_hkey == args.evf_hkey) {
3453 /* unlink curr from the list */
3454 if (curr == prev) {
3455 /*
3456 * if first element in the list update
3457 * the list head
3458 */
3459 ia_rp->ia_async_evd_hkeys =
3460 curr->aeh_next;
3461 } else {
3462 prev->aeh_next = curr->aeh_next;
3463 }
3464 break;
3465 }
3466 prev = curr;
3467 curr = curr->aeh_next;
3468 }
3469 mutex_exit(&ia_rp->ia_lock);
3470 /* free the curr entry */
3471 kmem_free(curr, sizeof (daplka_async_evd_hkey_t));
3472 }
3473
3474 /* UNREF calls the actual free function when refcnt is zero */
3475 DAPLKA_RS_UNREF(evd_rp);
3476 return (0);
3477 }
3478
3479 /*
3480 * destroys EVD resource.
3481 * called when refcnt drops to zero.
3482 */
3483 static int
3484 daplka_evd_destroy(daplka_resource_t *gen_rp)
3485 {
3486 daplka_evd_resource_t *evd_rp = (daplka_evd_resource_t *)gen_rp;
3487 ibt_status_t status;
3488 daplka_evd_event_t *evt;
3489 ibt_priv_data_len_t len;
3490
3491 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*evd_rp))
3492 D3("evd_destroy: entering, evd_rp 0x%p, rnum %d\n",
3493 evd_rp, DAPLKA_RS_RNUM(evd_rp));
3494 /*
3495 * free CQ
3496 */
3497 if (evd_rp->evd_cq_hdl) {
3498 ibt_set_cq_handler(evd_rp->evd_cq_hdl, NULL, NULL);
3499 mutex_enter(&daplka_dev->daplka_mutex);
3500 ibt_set_cq_private(evd_rp->evd_cq_hdl, NULL);
3501 mutex_exit(&daplka_dev->daplka_mutex);
3502
3503 status = daplka_ibt_free_cq(evd_rp, evd_rp->evd_cq_hdl);
3504 if (status != IBT_SUCCESS) {
3505 DERR("evd_destroy: ibt_free_cq returned %d\n", status);
3506 }
3507 evd_rp->evd_cq_hdl = NULL;
3508 D2("evd_destroy: cq freed, rnum %d\n", DAPLKA_RS_RNUM(evd_rp));
3509 }
3510
3511 /*
3512 * release reference on CNO
3513 */
3514 if (evd_rp->evd_cno_res != NULL) {
3515 mutex_enter(&evd_rp->evd_cno_res->cno_lock);
3516 if (evd_rp->evd_cno_res->cno_evd_cookie ==
3517 evd_rp->evd_cookie) {
3518 evd_rp->evd_cno_res->cno_evd_cookie = 0;
3519 }
3520 mutex_exit(&evd_rp->evd_cno_res->cno_lock);
3521 DAPLKA_RS_UNREF(evd_rp->evd_cno_res);
3522 evd_rp->evd_cno_res = NULL;
3523 }
3524
3525 /*
3526 * discard all remaining events
3527 */
3528 mutex_enter(&evd_rp->evd_lock);
3529 while ((evt = daplka_evd_event_dequeue(&evd_rp->evd_cr_events))) {
3530 D2("evd_destroy: discarding CR event: %d\n",
3531 evt->ee_cmev.ec_cm_ev_type);
3532 len = evt->ee_cmev.ec_cm_ev_priv_data_len;
3533 if (len > 0) {
3534 kmem_free(evt->ee_cmev.ec_cm_ev_priv_data, len);
3535 evt->ee_cmev.ec_cm_ev_priv_data = NULL;
3536 evt->ee_cmev.ec_cm_ev_priv_data_len = 0;
3537 }
3538 kmem_free(evt, sizeof (*evt));
3539 }
3540 ASSERT(evd_rp->evd_cr_events.eel_num_elements == 0);
3541
3542 while ((evt = daplka_evd_event_dequeue(&evd_rp->evd_conn_events))) {
3543 D2("evd_destroy: discarding CONN event: %d\n",
3544 evt->ee_cmev.ec_cm_ev_type);
3545 len = evt->ee_cmev.ec_cm_ev_priv_data_len;
3546 if (len > 0) {
3547 kmem_free(evt->ee_cmev.ec_cm_ev_priv_data, len);
3548 evt->ee_cmev.ec_cm_ev_priv_data = NULL;
3549 evt->ee_cmev.ec_cm_ev_priv_data_len = 0;
3550 }
3551 kmem_free(evt, sizeof (*evt));
3552 }
3553 ASSERT(evd_rp->evd_conn_events.eel_num_elements == 0);
3554
3555 while ((evt = daplka_evd_event_dequeue(&evd_rp->evd_async_events))) {
3556 DERR("evd_destroy: discarding ASYNC event: %d\n",
3557 evt->ee_aev.ibae_type);
3558 kmem_free(evt, sizeof (*evt));
3559 }
3560 ASSERT(evd_rp->evd_async_events.eel_num_elements == 0);
3561 mutex_exit(&evd_rp->evd_lock);
3562
3563 mutex_destroy(&evd_rp->evd_lock);
3564 DAPLKA_RS_FINI(evd_rp);
3565 kmem_free(evd_rp, sizeof (daplka_evd_resource_t));
3566 D3("evd_destroy: exiting, evd_rp 0x%p\n", evd_rp);
3567 return (0);
3568 }
3569
3570 static void
3571 daplka_hash_evd_free(void *obj)
3572 {
3573 daplka_evd_resource_t *evd_rp = (daplka_evd_resource_t *)obj;
3574
3575 ASSERT(DAPLKA_RS_TYPE(evd_rp) == DAPL_TYPE_EVD);
3576 DAPLKA_RS_UNREF(evd_rp);
3577 }
3578
3579 /*
3580 * this handler fires when new completions arrive.
3581 */
3582 /* ARGSUSED */
3583 static void
3584 daplka_cq_handler(ibt_cq_hdl_t ibt_cq, void *arg)
3585 {
3586 D3("cq_handler: fired setting evd_newevents\n");
3587 daplka_evd_wakeup((daplka_evd_resource_t *)arg, NULL, NULL);
3588 }
3589
3590 /*
3591 * this routine wakes up a client from evd_wait. if evtq and evt
3592 * are non-null, the event evt will be enqueued prior to waking
3593 * up the client. if the evd is associated with a CNO and if there
3594 * are no waiters on the evd, the CNO will be notified.
3595 */
3596 static void
3597 daplka_evd_wakeup(daplka_evd_resource_t *evd_rp, daplka_evd_event_list_t *evtq,
3598 daplka_evd_event_t *evt)
3599 {
3600 uint32_t waiters = 0;
3601
3602 mutex_enter(&evd_rp->evd_lock);
3603 if (evtq != NULL && evt != NULL) {
3604 ASSERT(evtq == &evd_rp->evd_cr_events ||
3605 evtq == &evd_rp->evd_conn_events ||
3606 evtq == &evd_rp->evd_async_events);
3607 daplka_evd_event_enqueue(evtq, evt);
3608 ASSERT((evtq->eel_event_type == DAPLKA_EVD_CM_EVENTS) ||
3609 (evtq->eel_event_type == DAPLKA_EVD_ASYNC_EVENTS));
3610 evd_rp->evd_newevents |= evtq->eel_event_type;
3611 } else {
3612 evd_rp->evd_newevents |= DAPLKA_EVD_ULAND_EVENTS;
3613 }
3614 waiters = evd_rp->evd_waiters;
3615 cv_broadcast(&evd_rp->evd_cv);
3616 mutex_exit(&evd_rp->evd_lock);
3617
3618 /*
3619 * only wakeup the CNO if there are no waiters on this evd.
3620 */
3621 if (evd_rp->evd_cno_res != NULL && waiters == 0) {
3622 mutex_enter(&evd_rp->evd_cno_res->cno_lock);
3623 evd_rp->evd_cno_res->cno_evd_cookie = evd_rp->evd_cookie;
3624 cv_broadcast(&evd_rp->evd_cno_res->cno_cv);
3625 mutex_exit(&evd_rp->evd_cno_res->cno_lock);
3626 }
3627 }
3628
3629 /*
3630 * daplka_evd_event_enqueue adds elem to the end of the event list
3631 * The caller is expected to acquire appropriate locks before
3632 * calling enqueue
3633 */
3634 static void
3635 daplka_evd_event_enqueue(daplka_evd_event_list_t *evlist,
3636 daplka_evd_event_t *elem)
3637 {
3638 if (evlist->eel_tail) {
3639 evlist->eel_tail->ee_next = elem;
3640 evlist->eel_tail = elem;
3641 } else {
3642 /* list is empty */
3643 ASSERT(evlist->eel_head == NULL);
3644 evlist->eel_head = elem;
3645 evlist->eel_tail = elem;
3646 }
3647 evlist->eel_num_elements++;
3648 }
3649
3650 /*
3651 * daplka_evd_event_dequeue removes and returns the first element of event
3652 * list. NULL is returned if the list is empty. The caller is expected to
3653 * acquire appropriate locks before calling enqueue.
3654 */
3655 static daplka_evd_event_t *
3656 daplka_evd_event_dequeue(daplka_evd_event_list_t *evlist)
3657 {
3658 daplka_evd_event_t *head;
3659
3660 head = evlist->eel_head;
3661 if (head == NULL) {
3662 return (NULL);
3663 }
3664
3665 evlist->eel_head = head->ee_next;
3666 evlist->eel_num_elements--;
3667 /* if it was the last element update the tail pointer too */
3668 if (evlist->eel_head == NULL) {
3669 ASSERT(evlist->eel_num_elements == 0);
3670 evlist->eel_tail = NULL;
3671 }
3672 return (head);
3673 }
3674
3675 /*
3676 * A CNO allows the client to wait for notifications from multiple EVDs.
3677 * To use a CNO, the client needs to follow the procedure below:
3678 * 1. allocate a CNO. this returns a cno_hkey that identifies the CNO.
3679 * 2. create one or more EVDs using the returned cno_hkey.
3680 * 3. call cno_wait. when one of the associated EVDs get notified, the
3681 * CNO will also get notified. cno_wait will then return with a
3682 * evd_cookie identifying the EVD that triggered the event.
3683 *
3684 * A note about cno_wait:
3685 * -unlike a EVD, a CNO does not maintain a queue of notifications. For
3686 * example, suppose multiple EVDs triggered a CNO before the client calls
3687 * cno_wait; when the client calls cno_wait, it will return with the
3688 * evd_cookie that identifies the *last* EVD that triggered the CNO. It
3689 * is the responsibility of the client, upon returning from cno_wait, to
3690 * check on all EVDs that can potentially trigger the CNO. the returned
3691 * evd_cookie is only meant to be a hint. there is no guarantee that the
3692 * EVD identified by the evd_cookie still contains an event or still
3693 * exists by the time cno_wait returns.
3694 */
3695
3696 /*
3697 * allocates a CNO.
3698 * the returned cno_hkey may subsequently be used in evd_create.
3699 */
3700 /* ARGSUSED */
3701 static int
3702 daplka_cno_alloc(daplka_ia_resource_t *ia_rp, intptr_t arg, int mode,
3703 cred_t *cred, int *rvalp)
3704 {
3705 dapl_cno_alloc_t args;
3706 daplka_cno_resource_t *cno_rp = NULL;
3707 uint64_t cno_hkey = 0;
3708 boolean_t inserted = B_FALSE;
3709 int retval = 0;
3710
3711 cno_rp = kmem_zalloc(sizeof (*cno_rp), daplka_km_flags);
3712 if (cno_rp == NULL) {
3713 DERR("cno_alloc: cannot allocate cno resource\n");
3714 return (ENOMEM);
3715 }
3716 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*cno_rp))
3717 DAPLKA_RS_INIT(cno_rp, DAPL_TYPE_CNO,
3718 DAPLKA_RS_RNUM(ia_rp), daplka_cno_destroy);
3719
3720 mutex_init(&cno_rp->cno_lock, NULL, MUTEX_DRIVER, NULL);
3721 cv_init(&cno_rp->cno_cv, NULL, CV_DRIVER, NULL);
3722 cno_rp->cno_evd_cookie = 0;
3723
3724 /* insert into cno hash table */
3725 retval = daplka_hash_insert(&ia_rp->ia_cno_htbl,
3726 &cno_hkey, (void *)cno_rp);
3727 if (retval != 0) {
3728 DERR("cno_alloc: cannot insert cno resource\n");
3729 goto cleanup;
3730 }
3731 inserted = B_TRUE;
3732 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*cno_rp))
3733
3734 /* return hkey to library */
3735 args.cno_hkey = cno_hkey;
3736
3737 retval = ddi_copyout(&args, (void *)arg, sizeof (dapl_cno_alloc_t),
3738 mode);
3739 if (retval != 0) {
3740 DERR("cno_alloc: copyout error %d\n", retval);
3741 retval = EFAULT;
3742 goto cleanup;
3743 }
3744 return (0);
3745
3746 cleanup:;
3747 if (inserted) {
3748 daplka_cno_resource_t *free_rp = NULL;
3749
3750 (void) daplka_hash_remove(&ia_rp->ia_cno_htbl, cno_hkey,
3751 (void **)&free_rp);
3752 if (free_rp != cno_rp) {
3753 DERR("cno_alloc: cannot remove cno\n");
3754 /*
3755 * we can only get here if another thread
3756 * has completed the cleanup in cno_free
3757 */
3758 return (retval);
3759 }
3760 }
3761 DAPLKA_RS_UNREF(cno_rp);
3762 return (retval);
3763 }
3764
3765 /*
3766 * destroys a CNO.
3767 * this gets called when a CNO resource's refcnt drops to zero.
3768 */
3769 static int
3770 daplka_cno_destroy(daplka_resource_t *gen_rp)
3771 {
3772 daplka_cno_resource_t *cno_rp = (daplka_cno_resource_t *)gen_rp;
3773
3774 ASSERT(DAPLKA_RS_REFCNT(cno_rp) == 0);
3775 D2("cno_destroy: entering, cno_rp %p, rnum %d\n",
3776 cno_rp, DAPLKA_RS_RNUM(cno_rp));
3777
3778 ASSERT(DAPLKA_RS_TYPE(cno_rp) == DAPL_TYPE_CNO);
3779 cv_destroy(&cno_rp->cno_cv);
3780 mutex_destroy(&cno_rp->cno_lock);
3781
3782 DAPLKA_RS_FINI(cno_rp);
3783 kmem_free(cno_rp, sizeof (daplka_cno_resource_t));
3784 D2("cno_destroy: exiting, cno_rp %p\n", cno_rp);
3785 return (0);
3786 }
3787
3788 static void
3789 daplka_hash_cno_free(void *obj)
3790 {
3791 daplka_cno_resource_t *cno_rp = (daplka_cno_resource_t *)obj;
3792
3793 ASSERT(DAPLKA_RS_TYPE(cno_rp) == DAPL_TYPE_CNO);
3794 DAPLKA_RS_UNREF(cno_rp);
3795 }
3796
3797 /*
3798 * removes the CNO from the cno hash table and frees the CNO
3799 * if there are no references to it. if there are references to
3800 * it, the CNO will be destroyed when the last of the references
3801 * is released. once the CNO is removed from the cno hash table,
3802 * the client will no longer be able to call cno_wait on the CNO.
3803 */
3804 /* ARGSUSED */
3805 static int
3806 daplka_cno_free(daplka_ia_resource_t *ia_rp, intptr_t arg, int mode,
3807 cred_t *cred, int *rvalp)
3808 {
3809 daplka_cno_resource_t *cno_rp = NULL;
3810 dapl_cno_free_t args;
3811 int retval = 0;
3812
3813 retval = ddi_copyin((void *)arg, &args, sizeof (dapl_cno_free_t), mode);
3814 if (retval != 0) {
3815 DERR("cno_free: copyin error %d\n", retval);
3816 return (EINVAL);
3817 }
3818
3819 retval = daplka_hash_remove(&ia_rp->ia_cno_htbl,
3820 args.cnf_hkey, (void **)&cno_rp);
3821 if (retval != 0 || cno_rp == NULL) {
3822 DERR("cno_free: cannot find cno resource\n");
3823 return (EINVAL);
3824 }
3825 ASSERT(DAPLKA_RS_TYPE(cno_rp) == DAPL_TYPE_CNO);
3826
3827 /* UNREF calls the actual free function when refcnt is zero */
3828 DAPLKA_RS_UNREF(cno_rp);
3829 return (0);
3830 }
3831
3832 /*
3833 * wait for a notification from one of the associated EVDs.
3834 */
3835 /* ARGSUSED */
3836 static int
3837 daplka_cno_wait(daplka_ia_resource_t *ia_rp, intptr_t arg, int mode,
3838 cred_t *cred, int *rvalp)
3839 {
3840 daplka_cno_resource_t *cno_rp = NULL;
3841 dapl_cno_wait_t args;
3842 int retval = 0;
3843 uint64_t evd_cookie = 0;
3844 clock_t timeout, curr_time;
3845
3846 retval = ddi_copyin((void *)arg, &args, sizeof (dapl_cno_wait_t), mode);
3847 if (retval != 0) {
3848 DERR("cno_wait: copyin error %d\n", retval);
3849 return (EINVAL);
3850 }
3851 /* get cno resource */
3852 cno_rp = (daplka_cno_resource_t *)
3853 daplka_hash_lookup(&ia_rp->ia_cno_htbl, args.cnw_hkey);
3854 if (cno_rp == NULL) {
3855 DERR("cno_wait: cannot find cno resource\n");
3856 return (EINVAL);
3857 }
3858 ASSERT(DAPLKA_RS_TYPE(cno_rp) == DAPL_TYPE_CNO);
3859
3860 curr_time = ddi_get_lbolt();
3861 timeout = curr_time + drv_usectohz(args.cnw_timeout);
3862
3863 /*
3864 * use the max value if we wrapped around
3865 */
3866 if (args.cnw_timeout > 0 && timeout <= curr_time) {
3867 /*
3868 * clock_t (size long) changes between 32 and 64-bit kernels
3869 */
3870 timeout = LONG_MAX >> 4;
3871 }
3872 mutex_enter(&cno_rp->cno_lock);
3873 while (cno_rp->cno_evd_cookie == 0) {
3874 int rval = 0;
3875
3876 rval = cv_timedwait_sig(&cno_rp->cno_cv,
3877 &cno_rp->cno_lock, timeout);
3878 if (rval == 0) {
3879 DERR("cno_wait: interrupted\n");
3880 mutex_exit(&cno_rp->cno_lock);
3881 retval = EINTR;
3882 goto cleanup;
3883 } else if (rval == -1) {
3884 DERR("cno_wait: timed out\n");
3885 mutex_exit(&cno_rp->cno_lock);
3886 retval = ETIME;
3887 goto cleanup;
3888 }
3889 }
3890 evd_cookie = cno_rp->cno_evd_cookie;
3891 cno_rp->cno_evd_cookie = 0;
3892 mutex_exit(&cno_rp->cno_lock);
3893
3894 ASSERT(evd_cookie != 0);
3895 D2("cno_wait: returning evd_cookie 0x%p\n",
3896 (void *)(uintptr_t)evd_cookie);
3897 args.cnw_evd_cookie = evd_cookie;
3898 retval = ddi_copyout((void *)&args, (void *)arg,
3899 sizeof (dapl_cno_wait_t), mode);
3900 if (retval != 0) {
3901 DERR("cno_wait: copyout error %d\n", retval);
3902 retval = EFAULT;
3903 goto cleanup;
3904 }
3905
3906 cleanup:;
3907 if (cno_rp != NULL) {
3908 DAPLKA_RS_UNREF(cno_rp);
3909 }
3910 return (retval);
3911 }
3912
3913 /*
3914 * this function is called by the client when it decides to
3915 * accept a connection request. a connection request is generated
3916 * when the active side generates REQ MAD to a service point on
3917 * the destination node. this causes the CM service handler
3918 * (daplka_cm_service_req) on the passive side to be callee. This
3919 * handler will then enqueue this connection request to the backlog
3920 * array of the service point. A connection event containing the
3921 * backlog array index and connection request private data is passed
3922 * to the client's service point EVD (sp_evd_res). once the event
3923 * is passed up to the userland, the client may examine the request
3924 * to decide whether to call daplka_cr_accept or dapka_cr_reject.
3925 */
3926 /* ARGSUSED */
3927 static int
3928 daplka_cr_accept(daplka_ia_resource_t *ia_rp, intptr_t arg, int mode,
3929 cred_t *cred, int *rvalp)
3930 {
3931 daplka_ep_resource_t *ep_rp = NULL;
3932 daplka_sp_resource_t *sp_rp = NULL;
3933 dapl_cr_accept_t args;
3934 daplka_sp_conn_pend_t *conn;
3935 ibt_cm_proceed_reply_t proc_reply;
3936 ibt_status_t status;
3937 uint16_t bkl_index;
3938 uint32_t old_state, new_state;
3939 int retval = 0;
3940 void *priv_data = NULL, *sid;
3941
3942 retval = ddi_copyin((void *)arg, &args, sizeof (dapl_cr_accept_t),
3943 mode);
3944 if (retval != 0) {
3945 DERR("cr_accept: copyin error %d\n", retval);
3946 return (EFAULT);
3947 }
3948 if (args.cra_priv_sz > DAPL_MAX_PRIVATE_DATA_SIZE) {
3949 DERR("cr_accept: private data len (%d) exceeded "
3950 "max size %d\n", args.cra_priv_sz,
3951 DAPL_MAX_PRIVATE_DATA_SIZE);
3952 return (EINVAL);
3953 }
3954 priv_data = (args.cra_priv_sz > 0) ? (void *)args.cra_priv : NULL;
3955
3956 D2("cr_accept: priv(0x%p) priv_len(%u) psep(0x%llx)\n", priv_data,
3957 args.cra_priv_sz, (longlong_t)args.cra_bkl_cookie);
3958
3959 /* get sp resource */
3960 sp_rp = (daplka_sp_resource_t *)daplka_hash_lookup(&ia_rp->ia_sp_htbl,
3961 args.cra_sp_hkey);
3962 if (sp_rp == NULL) {
3963 DERR("cr_accept: cannot find sp resource\n");
3964 return (EINVAL);
3965 }
3966 ASSERT(DAPLKA_RS_TYPE(sp_rp) == DAPL_TYPE_SP);
3967
3968 /* get ep resource */
3969 ep_rp = (daplka_ep_resource_t *)daplka_hash_lookup(&ia_rp->ia_ep_htbl,
3970 args.cra_ep_hkey);
3971 if (ep_rp == NULL) {
3972 DERR("cr_accept: cannot find ep resource\n");
3973 retval = EINVAL;
3974 goto cleanup;
3975 }
3976 ASSERT(DAPLKA_RS_TYPE(ep_rp) == DAPL_TYPE_EP);
3977
3978 /*
3979 * accept is only allowed if ep_state is CLOSED.
3980 * note that after this point, the ep_state is frozen
3981 * (i.e. TRANSITIONING) until we transition ep_state
3982 * to ACCEPTING or back to CLOSED if we get an error.
3983 */
3984 new_state = old_state = daplka_ep_get_state(ep_rp);
3985 if (old_state != DAPLKA_EP_STATE_CLOSED) {
3986 DERR("cr_accept: invalid ep state %d\n", old_state);
3987 retval = EINVAL;
3988 goto cleanup;
3989 }
3990
3991 mutex_enter(&sp_rp->sp_lock);
3992 bkl_index = DAPLKA_GET_PSEP_INDEX(args.cra_bkl_cookie);
3993 /*
3994 * make sure the backlog index is not bogus.
3995 */
3996 if (bkl_index >= sp_rp->sp_backlog_size) {
3997 DERR("cr_accept: invalid backlog index 0x%llx %d\n",
3998 (longlong_t)args.cra_bkl_cookie, bkl_index);
3999 mutex_exit(&sp_rp->sp_lock);
4000 retval = EINVAL;
4001 goto cleanup;
4002 }
4003 /*
4004 * make sure the backlog index indeed refers
4005 * to a pending connection.
4006 */
4007 conn = &sp_rp->sp_backlog[bkl_index];
4008 if (conn->spcp_state != DAPLKA_SPCP_PENDING) {
4009 DERR("cr_accept: invalid conn state %d\n",
4010 conn->spcp_state);
4011 mutex_exit(&sp_rp->sp_lock);
4012 retval = EINVAL;
4013 goto cleanup;
4014 }
4015 if (conn->spcp_sid == NULL) {
4016 DERR("cr_accept: sid == NULL\n");
4017 mutex_exit(&sp_rp->sp_lock);
4018 retval = EINVAL;
4019 goto cleanup;
4020 }
4021 if (ep_rp->ep_chan_hdl == NULL) {
4022 /*
4023 * a ep_rp with a NULL chan_hdl is impossible.
4024 */
4025 DERR("cr_accept: ep_chan_hdl == NULL\n");
4026 mutex_exit(&sp_rp->sp_lock);
4027 ASSERT(B_FALSE);
4028 retval = EINVAL;
4029 goto cleanup;
4030 }
4031 proc_reply.rep.cm_channel = ep_rp->ep_chan_hdl;
4032 proc_reply.rep.cm_rdma_ra_out = conn->spcp_rdma_ra_out;
4033 proc_reply.rep.cm_rdma_ra_in = conn->spcp_rdma_ra_in;
4034 proc_reply.rep.cm_rnr_retry_cnt = IBT_RNR_INFINITE_RETRY;
4035 sid = conn->spcp_sid;
4036
4037 /*
4038 * this clears our slot in the backlog array.
4039 * this slot may now be used by other pending connections.
4040 */
4041 conn->spcp_sid = NULL;
4042 conn->spcp_state = DAPLKA_SPCP_INIT;
4043 conn->spcp_req_len = 0;
4044 mutex_exit(&sp_rp->sp_lock);
4045
4046 /*
4047 * Set the unique cookie corresponding to the CR to this EP
4048 * so that is can be used in passive side CM callbacks
4049 */
4050 ep_rp->ep_psep_cookie = args.cra_bkl_cookie;
4051
4052 status = ibt_cm_proceed(IBT_CM_EVENT_REQ_RCV, sid, IBT_CM_ACCEPT,
4053 &proc_reply, priv_data, (ibt_priv_data_len_t)args.cra_priv_sz);
4054
4055 if (status != IBT_SUCCESS) {
4056 DERR("cr_accept: ibt_cm_proceed returned %d\n", status);
4057 *rvalp = (int)status;
4058 retval = 0;
4059 }
4060 /*
4061 * note that the CM handler may actually be called at this
4062 * point. but since ep_state is still in TRANSITIONING, the
4063 * handler will wait until we transition to ACCEPTING. this
4064 * prevents the case where we set ep_state to ACCEPTING after
4065 * daplka_service_conn_est sets ep_state to CONNECTED.
4066 */
4067 new_state = DAPLKA_EP_STATE_ACCEPTING;
4068
4069 cleanup:;
4070 if (sp_rp != NULL) {
4071 DAPLKA_RS_UNREF(sp_rp);
4072 }
4073 if (ep_rp != NULL) {
4074 daplka_ep_set_state(ep_rp, old_state, new_state);
4075 DAPLKA_RS_UNREF(ep_rp);
4076 }
4077 return (retval);
4078 }
4079
4080 /*
4081 * this function is called by the client to reject a
4082 * connection request.
4083 */
4084 /* ARGSUSED */
4085 static int
4086 daplka_cr_reject(daplka_ia_resource_t *ia_rp, intptr_t arg, int mode,
4087 cred_t *cred, int *rvalp)
4088 {
4089 dapl_cr_reject_t args;
4090 daplka_sp_resource_t *sp_rp = NULL;
4091 daplka_sp_conn_pend_t *conn;
4092 ibt_cm_proceed_reply_t proc_reply;
4093 ibt_cm_status_t proc_status;
4094 ibt_status_t status;
4095 uint16_t bkl_index;
4096 int retval = 0;
4097 void *sid;
4098
4099 retval = ddi_copyin((void *)arg, &args, sizeof (dapl_cr_reject_t),
4100 mode);
4101 if (retval != 0) {
4102 DERR("cr_reject: copyin error %d\n", retval);
4103 return (EFAULT);
4104 }
4105 /* get sp resource */
4106 sp_rp = (daplka_sp_resource_t *)daplka_hash_lookup(&ia_rp->ia_sp_htbl,
4107 args.crr_sp_hkey);
4108 if (sp_rp == NULL) {
4109 DERR("cr_reject: cannot find sp resource\n");
4110 return (EINVAL);
4111 }
4112 ASSERT(DAPLKA_RS_TYPE(sp_rp) == DAPL_TYPE_SP);
4113
4114 D2("cr_reject: psep(0x%llx)\n", (longlong_t)args.crr_bkl_cookie);
4115
4116 mutex_enter(&sp_rp->sp_lock);
4117 bkl_index = DAPLKA_GET_PSEP_INDEX(args.crr_bkl_cookie);
4118 /*
4119 * make sure the backlog index is not bogus.
4120 */
4121 if (bkl_index >= sp_rp->sp_backlog_size) {
4122 DERR("cr_reject: invalid backlog index 0x%llx %d\n",
4123 (longlong_t)args.crr_bkl_cookie, bkl_index);
4124 mutex_exit(&sp_rp->sp_lock);
4125 retval = EINVAL;
4126 goto cleanup;
4127 }
4128 /*
4129 * make sure the backlog index indeed refers
4130 * to a pending connection.
4131 */
4132 conn = &sp_rp->sp_backlog[bkl_index];
4133 if (conn->spcp_state != DAPLKA_SPCP_PENDING) {
4134 DERR("cr_reject: invalid conn state %d\n",
4135 conn->spcp_state);
4136 mutex_exit(&sp_rp->sp_lock);
4137 retval = EINVAL;
4138 goto cleanup;
4139 }
4140 if (conn->spcp_sid == NULL) {
4141 DERR("cr_reject: sid == NULL\n");
4142 mutex_exit(&sp_rp->sp_lock);
4143 retval = EINVAL;
4144 goto cleanup;
4145 }
4146 bzero(&proc_reply, sizeof (proc_reply));
4147 sid = conn->spcp_sid;
4148
4149 /*
4150 * this clears our slot in the backlog array.
4151 * this slot may now be used by other pending connections.
4152 */
4153 conn->spcp_sid = NULL;
4154 conn->spcp_state = DAPLKA_SPCP_INIT;
4155 conn->spcp_req_len = 0;
4156
4157 switch (args.crr_reason) {
4158 case DAPL_IB_CM_REJ_REASON_CONSUMER_REJ:
4159 /* results in IBT_CM_CONSUMER as the reason for reject */
4160 proc_status = IBT_CM_REJECT;
4161 break;
4162 case DAPL_IB_CME_LOCAL_FAILURE:
4163 /*FALLTHRU*/
4164 case DAPL_IB_CME_DESTINATION_UNREACHABLE:
4165 /* results in IBT_CM_NO_RESC as the reason for reject */
4166 proc_status = IBT_CM_NO_RESOURCE;
4167 break;
4168 default:
4169 /* unexpect reason code */
4170 ASSERT(!"unexpected reject reason code");
4171 proc_status = IBT_CM_NO_RESOURCE;
4172 break;
4173 }
4174
4175 mutex_exit(&sp_rp->sp_lock);
4176
4177 status = ibt_cm_proceed(IBT_CM_EVENT_REQ_RCV, sid, proc_status,
4178 &proc_reply, NULL, 0);
4179
4180 if (status != IBT_SUCCESS) {
4181 DERR("cr_reject: ibt_cm_proceed returned %d\n", status);
4182 *rvalp = (int)status;
4183 retval = 0;
4184 }
4185
4186 cleanup:;
4187 if (sp_rp != NULL) {
4188 DAPLKA_RS_UNREF(sp_rp);
4189 }
4190 return (retval);
4191 }
4192
4193
4194 /*
4195 * daplka_sp_match is used by daplka_hash_walk for finding SPs
4196 */
4197 typedef struct daplka_sp_match_s {
4198 uint64_t spm_conn_qual;
4199 daplka_sp_resource_t *spm_sp_rp;
4200 } daplka_sp_match_t;
4201 _NOTE(SCHEME_PROTECTS_DATA("daplka", daplka_sp_match_s::spm_sp_rp))
4202
4203 static int
4204 daplka_sp_match(void *objp, void *arg)
4205 {
4206 daplka_sp_resource_t *sp_rp = (daplka_sp_resource_t *)objp;
4207
4208 ASSERT(DAPLKA_RS_TYPE(sp_rp) == DAPL_TYPE_SP);
4209 if (sp_rp->sp_conn_qual ==
4210 ((daplka_sp_match_t *)arg)->spm_conn_qual) {
4211 ((daplka_sp_match_t *)arg)->spm_sp_rp = sp_rp;
4212 D2("daplka_sp_match: found sp, conn_qual %016llu\n",
4213 (longlong_t)((daplka_sp_match_t *)arg)->spm_conn_qual);
4214 DAPLKA_RS_REF(sp_rp);
4215 return (1);
4216 }
4217 return (0);
4218 }
4219
4220 /*
4221 * cr_handoff allows the client to handoff a connection request from
4222 * one service point to another.
4223 */
4224 /* ARGSUSED */
4225 static int
4226 daplka_cr_handoff(daplka_ia_resource_t *ia_rp, intptr_t arg, int mode,
4227 cred_t *cred, int *rvalp)
4228 {
4229 dapl_cr_handoff_t args;
4230 daplka_sp_resource_t *sp_rp = NULL, *new_sp_rp = NULL;
4231 daplka_sp_conn_pend_t *conn;
4232 daplka_sp_match_t sp_match;
4233 ibt_cm_event_t fake_event;
4234 ibt_cm_status_t cm_status;
4235 ibt_status_t status;
4236 uint16_t bkl_index;
4237 void *sid, *priv = NULL;
4238 int retval = 0, priv_len = 0;
4239
4240 D3("cr_handoff: entering\n");
4241 retval = ddi_copyin((void *)arg, &args, sizeof (dapl_cr_handoff_t),
4242 mode);
4243 if (retval != 0) {
4244 DERR("cr_handoff: copyin error %d\n", retval);
4245 return (EFAULT);
4246 }
4247 /* get sp resource */
4248 sp_rp = (daplka_sp_resource_t *)daplka_hash_lookup(&ia_rp->ia_sp_htbl,
4249 args.crh_sp_hkey);
4250 if (sp_rp == NULL) {
4251 DERR("cr_handoff: cannot find sp resource\n");
4252 return (EINVAL);
4253 }
4254 ASSERT(DAPLKA_RS_TYPE(sp_rp) == DAPL_TYPE_SP);
4255
4256 /*
4257 * find the destination service point.
4258 */
4259 sp_match.spm_conn_qual = args.crh_conn_qual;
4260 sp_match.spm_sp_rp = NULL;
4261 daplka_hash_walk(&daplka_global_sp_htbl, daplka_sp_match,
4262 (void *)&sp_match, RW_READER);
4263
4264 /*
4265 * return if we cannot find the service point
4266 */
4267 if (sp_match.spm_sp_rp == NULL) {
4268 DERR("cr_handoff: new sp not found, conn qual = %llu\n",
4269 (longlong_t)args.crh_conn_qual);
4270 retval = EINVAL;
4271 goto cleanup;
4272 }
4273 new_sp_rp = sp_match.spm_sp_rp;
4274
4275 /*
4276 * the spec does not discuss the security implications of this
4277 * function. to be safe, we currently only allow processes
4278 * owned by the same user to handoff connection requests
4279 * to each other.
4280 */
4281 if (crgetruid(cred) != new_sp_rp->sp_ruid) {
4282 DERR("cr_handoff: permission denied\n");
4283 retval = EPERM;
4284 goto cleanup;
4285 }
4286
4287 D2("cr_handoff: psep(0x%llx)\n", (longlong_t)args.crh_bkl_cookie);
4288
4289 mutex_enter(&sp_rp->sp_lock);
4290 bkl_index = DAPLKA_GET_PSEP_INDEX(args.crh_bkl_cookie);
4291 /*
4292 * make sure the backlog index is not bogus.
4293 */
4294 if (bkl_index >= sp_rp->sp_backlog_size) {
4295 DERR("cr_handoff: invalid backlog index 0x%llx %d\n",
4296 (longlong_t)args.crh_bkl_cookie, bkl_index);
4297 mutex_exit(&sp_rp->sp_lock);
4298 retval = EINVAL;
4299 goto cleanup;
4300 }
4301 /*
4302 * make sure the backlog index indeed refers
4303 * to a pending connection.
4304 */
4305 conn = &sp_rp->sp_backlog[bkl_index];
4306 if (conn->spcp_state != DAPLKA_SPCP_PENDING) {
4307 DERR("cr_handoff: invalid conn state %d\n",
4308 conn->spcp_state);
4309 mutex_exit(&sp_rp->sp_lock);
4310 retval = EINVAL;
4311 goto cleanup;
4312 }
4313 if (conn->spcp_sid == NULL) {
4314 DERR("cr_handoff: sid == NULL\n");
4315 mutex_exit(&sp_rp->sp_lock);
4316 retval = EINVAL;
4317 goto cleanup;
4318 }
4319 sid = conn->spcp_sid;
4320 priv = NULL;
4321 priv_len = conn->spcp_req_len;
4322 if (priv_len > 0) {
4323 priv = kmem_zalloc(priv_len, daplka_km_flags);
4324 if (priv == NULL) {
4325 mutex_exit(&sp_rp->sp_lock);
4326 retval = ENOMEM;
4327 goto cleanup;
4328 }
4329 bcopy(conn->spcp_req_data, priv, priv_len);
4330 }
4331 /*
4332 * this clears our slot in the backlog array.
4333 * this slot may now be used by other pending connections.
4334 */
4335 conn->spcp_sid = NULL;
4336 conn->spcp_state = DAPLKA_SPCP_INIT;
4337 conn->spcp_req_len = 0;
4338 mutex_exit(&sp_rp->sp_lock);
4339
4340 /* fill fake_event and call service_req handler */
4341 bzero(&fake_event, sizeof (fake_event));
4342 fake_event.cm_type = IBT_CM_EVENT_REQ_RCV;
4343 fake_event.cm_session_id = sid;
4344 fake_event.cm_priv_data_len = priv_len;
4345 fake_event.cm_priv_data = priv;
4346
4347 cm_status = daplka_cm_service_req(new_sp_rp,
4348 &fake_event, NULL, priv, (ibt_priv_data_len_t)priv_len);
4349 if (cm_status != IBT_CM_DEFER) {
4350 ibt_cm_proceed_reply_t proc_reply;
4351
4352 DERR("cr_handoff: service_req returned %d\n", cm_status);
4353 /*
4354 * if for some reason cm_service_req failed, we
4355 * reject the connection.
4356 */
4357 bzero(&proc_reply, sizeof (proc_reply));
4358
4359 status = ibt_cm_proceed(IBT_CM_EVENT_REQ_RCV, sid,
4360 IBT_CM_NO_RESOURCE, &proc_reply, NULL, 0);
4361 if (status != IBT_SUCCESS) {
4362 DERR("cr_handoff: ibt_cm_proceed returned %d\n",
4363 status);
4364 }
4365 *rvalp = (int)status;
4366 retval = 0;
4367 }
4368
4369 cleanup:;
4370 if (priv_len > 0 && priv != NULL) {
4371 kmem_free(priv, priv_len);
4372 }
4373 if (new_sp_rp != NULL) {
4374 DAPLKA_RS_UNREF(new_sp_rp);
4375 }
4376 if (sp_rp != NULL) {
4377 DAPLKA_RS_UNREF(sp_rp);
4378 }
4379 D3("cr_handoff: exiting\n");
4380 return (retval);
4381 }
4382
4383 /*
4384 * returns a list of hca attributes
4385 */
4386 /* ARGSUSED */
4387 static int
4388 daplka_ia_query(daplka_ia_resource_t *ia_rp, intptr_t arg, int mode,
4389 cred_t *cred, int *rvalp)
4390 {
4391 dapl_ia_query_t args;
4392 int retval;
4393 ibt_hca_attr_t *hcap;
4394
4395 hcap = &ia_rp->ia_hca->hca_attr;
4396
4397 /*
4398 * Take the ibt_hca_attr_t and stuff them into dapl_hca_attr_t
4399 */
4400 args.hca_attr.dhca_vendor_id = hcap->hca_vendor_id;
4401 args.hca_attr.dhca_device_id = hcap->hca_device_id;
4402 args.hca_attr.dhca_version_id = hcap->hca_version_id;
4403 args.hca_attr.dhca_max_chans = hcap->hca_max_chans;
4404 args.hca_attr.dhca_max_chan_sz = hcap->hca_max_chan_sz;
4405 args.hca_attr.dhca_max_sgl = hcap->hca_max_sgl;
4406 args.hca_attr.dhca_max_cq = hcap->hca_max_cq;
4407 args.hca_attr.dhca_max_cq_sz = hcap->hca_max_cq_sz;
4408 args.hca_attr.dhca_max_memr = hcap->hca_max_memr;
4409 args.hca_attr.dhca_max_memr_len = hcap->hca_max_memr_len;
4410 args.hca_attr.dhca_max_mem_win = hcap->hca_max_mem_win;
4411 args.hca_attr.dhca_max_rdma_in_chan = hcap->hca_max_rdma_in_chan;
4412 args.hca_attr.dhca_max_rdma_out_chan = hcap->hca_max_rdma_out_chan;
4413 args.hca_attr.dhca_max_partitions = hcap->hca_max_partitions;
4414 args.hca_attr.dhca_nports = hcap->hca_nports;
4415 args.hca_attr.dhca_node_guid = hcap->hca_node_guid;
4416 args.hca_attr.dhca_max_pd = hcap->hca_max_pd;
4417 args.hca_attr.dhca_max_srqs = hcap->hca_max_srqs;
4418 args.hca_attr.dhca_max_srqs_sz = hcap->hca_max_srqs_sz;
4419 args.hca_attr.dhca_max_srq_sgl = hcap->hca_max_srq_sgl;
4420
4421 retval = ddi_copyout(&args, (void *)arg, sizeof (dapl_ia_query_t),
4422 mode);
4423 if (retval != 0) {
4424 DERR("ia_query: copyout error %d\n", retval);
4425 return (EFAULT);
4426 }
4427 return (0);
4428 }
4429
4430 /*
4431 * This routine is passed to hash walk in the daplka_pre_mr_cleanup_callback,
4432 * it frees the mw embedded in the mw resource object.
4433 */
4434
4435 /* ARGSUSED */
4436 static int
4437 daplka_mr_cb_freemw(void *objp, void *arg)
4438 {
4439 daplka_mw_resource_t *mw_rp = (daplka_mw_resource_t *)objp;
4440 ibt_mw_hdl_t mw_hdl;
4441 ibt_status_t status;
4442
4443 D3("mr_cb_freemw: entering, mw_rp 0x%p\n", mw_rp);
4444 DAPLKA_RS_REF(mw_rp);
4445
4446 mutex_enter(&mw_rp->mw_lock);
4447 mw_hdl = mw_rp->mw_hdl;
4448 /*
4449 * we set mw_hdl to NULL so it won't get freed again
4450 */
4451 mw_rp->mw_hdl = NULL;
4452 mutex_exit(&mw_rp->mw_lock);
4453
4454 if (mw_hdl != NULL) {
4455 status = daplka_ibt_free_mw(mw_rp, mw_rp->mw_hca_hdl, mw_hdl);
4456 if (status != IBT_SUCCESS) {
4457 DERR("mr_cb_freemw: ibt_free_mw returned %d\n", status);
4458 }
4459 D3("mr_cb_freemw: mw freed\n");
4460 }
4461
4462 DAPLKA_RS_UNREF(mw_rp);
4463 return (0);
4464 }
4465
4466 /*
4467 * This routine is called from HCA driver's umem lock undo callback
4468 * when the memory associated with an MR is being unmapped. In this callback
4469 * we free all the MW associated with the IA and post an unaffiliated
4470 * async event to tell the app that there was a catastrophic event.
4471 * This allows the HCA to deregister the MR in its callback processing.
4472 */
4473 static void
4474 daplka_pre_mr_cleanup_callback(void *arg1, void *arg2 /*ARGSUSED*/)
4475 {
4476 daplka_mr_resource_t *mr_rp;
4477 daplka_ia_resource_t *ia_rp;
4478 #ifdef _THROW_ASYNC_EVENT_FROM_MRUNLOCKCB
4479 ibt_async_event_t event;
4480 ibt_hca_attr_t *hca_attrp;
4481 #endif
4482 minor_t rnum;
4483
4484 mr_rp = (daplka_mr_resource_t *)arg1;
4485 rnum = DAPLKA_RS_RNUM(mr_rp);
4486 daplka_shared_mr_free(mr_rp);
4487
4488 ia_rp = (daplka_ia_resource_t *)daplka_resource_lookup(rnum);
4489 if (ia_rp == NULL) {
4490 DERR("daplka_mr_unlock_callback: resource not found, rnum %d\n",
4491 rnum);
4492 return;
4493 }
4494
4495 DERR("daplka_mr_unlock_callback: resource(%p) rnum(%d)\n", ia_rp, rnum);
4496
4497 mutex_enter(&ia_rp->ia_lock);
4498 /*
4499 * MW is being alloced OR MW freeze has already begun. In
4500 * both these cases we wait for that to complete before
4501 * continuing.
4502 */
4503 while ((ia_rp->ia_state == DAPLKA_IA_MW_ALLOC_IN_PROGRESS) ||
4504 (ia_rp->ia_state == DAPLKA_IA_MW_FREEZE_IN_PROGRESS)) {
4505 cv_wait(&ia_rp->ia_cv, &ia_rp->ia_lock);
4506 }
4507
4508 switch (ia_rp->ia_state) {
4509 case DAPLKA_IA_INIT:
4510 ia_rp->ia_state = DAPLKA_IA_MW_FREEZE_IN_PROGRESS;
4511 mutex_exit(&ia_rp->ia_lock);
4512 break;
4513 case DAPLKA_IA_MW_FROZEN:
4514 /* the mw on this ia have been freed */
4515 D2("daplka_mr_unlock_callback: ia_state %d nothing to do\n",
4516 ia_rp->ia_state);
4517 mutex_exit(&ia_rp->ia_lock);
4518 goto cleanup;
4519 default:
4520 ASSERT(!"daplka_mr_unlock_callback: IA state invalid");
4521 DERR("daplka_mr_unlock_callback: invalid ia_state %d\n",
4522 ia_rp->ia_state);
4523 mutex_exit(&ia_rp->ia_lock);
4524 goto cleanup;
4525 }
4526
4527 /*
4528 * Walk the mw hash table and free the mws. Acquire a writer
4529 * lock since we don't want anyone else traversing this tree
4530 * while we are freeing the MW.
4531 */
4532 daplka_hash_walk(&ia_rp->ia_mw_htbl, daplka_mr_cb_freemw, NULL,
4533 RW_WRITER);
4534
4535 mutex_enter(&ia_rp->ia_lock);
4536 ASSERT(ia_rp->ia_state == DAPLKA_IA_MW_FREEZE_IN_PROGRESS);
4537 ia_rp->ia_state = DAPLKA_IA_MW_FROZEN;
4538 cv_broadcast(&ia_rp->ia_cv);
4539 mutex_exit(&ia_rp->ia_lock);
4540
4541 /*
4542 * Currently commented out because Oracle skgxp is incapable
4543 * of handling async events correctly.
4544 */
4545 #ifdef _THROW_ASYNC_EVENT_FROM_MRUNLOCKCB
4546 /*
4547 * Enqueue an unaffiliated async error event to indicate this
4548 * IA has encountered a problem that caused the MW to freed up
4549 */
4550
4551 /* Create a fake event, only relevant field is the hca_guid */
4552 bzero(&event, sizeof (ibt_async_event_t));
4553 hca_attrp = &ia_rp->ia_hca->hca_attr;
4554 event.ev_hca_guid = hca_attrp->hca_node_guid;
4555
4556 daplka_async_event_create(IBT_ERROR_LOCAL_CATASTROPHIC, &event, 0,
4557 ia_rp);
4558 #endif /* _THROW_ASYNC_EVENT_FROM_MRUNLOCKCB */
4559
4560 cleanup:;
4561 D2("daplka_mr_unlock_callback: resource(%p) done\n", ia_rp);
4562 DAPLKA_RS_UNREF(ia_rp);
4563 }
4564
4565 /*
4566 * registers a memory region.
4567 * memory locking will be done by the HCA driver.
4568 */
4569 /* ARGSUSED */
4570 static int
4571 daplka_mr_register(daplka_ia_resource_t *ia_rp, intptr_t arg, int mode,
4572 cred_t *cred, int *rvalp)
4573 {
4574 boolean_t inserted = B_FALSE;
4575 daplka_mr_resource_t *mr_rp;
4576 daplka_pd_resource_t *pd_rp;
4577 dapl_mr_register_t args;
4578 ibt_mr_data_in_t mr_cb_data_in;
4579 uint64_t mr_hkey = 0;
4580 ibt_status_t status;
4581 int retval;
4582
4583 retval = ddi_copyin((void *)arg, &args, sizeof (dapl_mr_register_t),
4584 mode);
4585 if (retval != 0) {
4586 DERR("mr_register: copyin error %d\n", retval);
4587 return (EINVAL);
4588 }
4589 mr_rp = kmem_zalloc(sizeof (daplka_mr_resource_t), daplka_km_flags);
4590 if (mr_rp == NULL) {
4591 DERR("mr_register: cannot allocate mr resource\n");
4592 return (ENOMEM);
4593 }
4594 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*mr_rp))
4595 DAPLKA_RS_INIT(mr_rp, DAPL_TYPE_MR,
4596 DAPLKA_RS_RNUM(ia_rp), daplka_mr_destroy);
4597
4598 mutex_init(&mr_rp->mr_lock, NULL, MUTEX_DRIVER, NULL);
4599 mr_rp->mr_hca = ia_rp->ia_hca;
4600 mr_rp->mr_hca_hdl = ia_rp->ia_hca_hdl;
4601 mr_rp->mr_next = NULL;
4602 mr_rp->mr_shared_mr = NULL;
4603
4604 /* get pd handle */
4605 pd_rp = (daplka_pd_resource_t *)
4606 daplka_hash_lookup(&ia_rp->ia_pd_htbl, args.mr_pd_hkey);
4607 if (pd_rp == NULL) {
4608 DERR("mr_register: cannot find pd resource\n");
4609 retval = EINVAL;
4610 goto cleanup;
4611 }
4612 ASSERT(DAPLKA_RS_TYPE(pd_rp) == DAPL_TYPE_PD);
4613 mr_rp->mr_pd_res = pd_rp;
4614
4615 mr_rp->mr_attr.mr_vaddr = args.mr_vaddr;
4616 mr_rp->mr_attr.mr_len = args.mr_len;
4617 mr_rp->mr_attr.mr_as = curproc->p_as;
4618 mr_rp->mr_attr.mr_flags = args.mr_flags | IBT_MR_NOSLEEP;
4619
4620 D3("mr_register: mr_vaddr %p, mr_len %llu, mr_flags 0x%x\n",
4621 (void *)(uintptr_t)mr_rp->mr_attr.mr_vaddr,
4622 (longlong_t)mr_rp->mr_attr.mr_len,
4623 mr_rp->mr_attr.mr_flags);
4624
4625 status = daplka_ibt_register_mr(mr_rp, ia_rp->ia_hca_hdl,
4626 mr_rp->mr_pd_res->pd_hdl, &mr_rp->mr_attr, &mr_rp->mr_hdl,
4627 &mr_rp->mr_desc);
4628
4629 if (status != IBT_SUCCESS) {
4630 DERR("mr_register: ibt_register_mr error %d\n", status);
4631 *rvalp = (int)status;
4632 retval = 0;
4633 goto cleanup;
4634 }
4635
4636 mr_cb_data_in.mr_rev = IBT_MR_DATA_IN_IF_VERSION;
4637 mr_cb_data_in.mr_func = daplka_pre_mr_cleanup_callback;
4638 mr_cb_data_in.mr_arg1 = (void *)mr_rp;
4639 mr_cb_data_in.mr_arg2 = NULL;
4640
4641 /* Pass the service driver mr cleanup handler to the hca driver */
4642 status = ibt_ci_data_in(ia_rp->ia_hca_hdl,
4643 IBT_CI_NO_FLAGS, IBT_HDL_MR, (void *)mr_rp->mr_hdl,
4644 &mr_cb_data_in, sizeof (mr_cb_data_in));
4645
4646 if (status != IBT_SUCCESS) {
4647 DERR("mr_register: ibt_ci_data_in error(%d) ver(%d)",
4648 status, mr_cb_data_in.mr_rev);
4649 *rvalp = (int)status;
4650 retval = 0;
4651 goto cleanup;
4652 }
4653
4654 /* insert into mr hash table */
4655 retval = daplka_hash_insert(&ia_rp->ia_mr_htbl,
4656 &mr_hkey, (void *)mr_rp);
4657 if (retval != 0) {
4658 DERR("mr_register: cannot insert mr resource into mr_htbl\n");
4659 goto cleanup;
4660 }
4661 inserted = B_TRUE;
4662 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*mr_rp))
4663
4664 args.mr_lkey = mr_rp->mr_desc.md_lkey;
4665 args.mr_rkey = mr_rp->mr_desc.md_rkey;
4666 args.mr_hkey = mr_hkey;
4667
4668 retval = ddi_copyout((void *)&args, (void *)arg,
4669 sizeof (dapl_mr_register_t), mode);
4670 if (retval != 0) {
4671 DERR("mr_register: copyout error %d\n", retval);
4672 retval = EFAULT;
4673 goto cleanup;
4674 }
4675 return (0);
4676
4677 cleanup:;
4678 if (inserted) {
4679 daplka_mr_resource_t *free_rp = NULL;
4680
4681 (void) daplka_hash_remove(&ia_rp->ia_mr_htbl, mr_hkey,
4682 (void **)&free_rp);
4683 if (free_rp != mr_rp) {
4684 DERR("mr_register: cannot remove mr from hash table\n");
4685 /*
4686 * we can only get here if another thread
4687 * has completed the cleanup in mr_deregister
4688 */
4689 return (retval);
4690 }
4691 }
4692 DAPLKA_RS_UNREF(mr_rp);
4693 return (retval);
4694 }
4695
4696 /*
4697 * registers a shared memory region.
4698 * the client calls this function with the intention to share the memory
4699 * region with other clients. it is assumed that, prior to calling this
4700 * function, the client(s) are already sharing parts of their address
4701 * space using a mechanism such as SYSV shared memory. the first client
4702 * that calls this function will create and insert a daplka_shared_mr_t
4703 * object into the global daplka_shared_mr_tree. this shared mr object
4704 * will be identified by a unique 40-byte key and will maintain a list
4705 * of mr resources. every time this function gets called with the same
4706 * 40-byte key, a new mr resource (containing a new mr handle generated
4707 * by ibt_register_mr or ibt_register_shared_mr) is created and inserted
4708 * into this list. similarly, every time a shared mr gets deregistered
4709 * or invalidated by a callback, the mr resource gets removed from this
4710 * list. the shared mr object has a reference count. when it drops to
4711 * zero, the shared mr object will be removed from the global avl tree
4712 * and be freed.
4713 */
4714 /* ARGSUSED */
4715 static int
4716 daplka_mr_register_shared(daplka_ia_resource_t *ia_rp, intptr_t arg, int mode,
4717 cred_t *cred, int *rvalp)
4718 {
4719 dapl_mr_register_shared_t args;
4720 daplka_shared_mr_t *smrp = NULL;
4721 daplka_shared_mr_t tmp_smr;
4722 ibt_mr_data_in_t mr_cb_data_in;
4723 avl_index_t where;
4724 boolean_t inserted = B_FALSE;
4725 daplka_mr_resource_t *mr_rp = NULL;
4726 daplka_pd_resource_t *pd_rp;
4727 uint64_t mr_hkey = 0;
4728 ibt_status_t status;
4729 int retval;
4730
4731 retval = ddi_copyin((void *)arg, &args,
4732 sizeof (dapl_mr_register_shared_t), mode);
4733 if (retval != 0) {
4734 DERR("mr_register_shared: copyin error %d\n", retval);
4735 return (EINVAL);
4736 }
4737
4738 mutex_enter(&daplka_shared_mr_lock);
4739 /*
4740 * find smrp from the global avl tree.
4741 * the 40-byte key is used as the lookup key.
4742 */
4743 tmp_smr.smr_cookie = args.mrs_shm_cookie;
4744 smrp = (daplka_shared_mr_t *)
4745 avl_find(&daplka_shared_mr_tree, &tmp_smr, &where);
4746 if (smrp != NULL) {
4747 D2("mr_register_shared: smrp 0x%p, found cookie:\n"
4748 "0x%016llx%016llx%016llx%016llx%016llx\n", smrp,
4749 (longlong_t)tmp_smr.smr_cookie.mc_uint_arr[4],
4750 (longlong_t)tmp_smr.smr_cookie.mc_uint_arr[3],
4751 (longlong_t)tmp_smr.smr_cookie.mc_uint_arr[2],
4752 (longlong_t)tmp_smr.smr_cookie.mc_uint_arr[1],
4753 (longlong_t)tmp_smr.smr_cookie.mc_uint_arr[0]);
4754
4755 /*
4756 * if the smrp exists, other threads could still be
4757 * accessing it. we wait until they are done before
4758 * we continue.
4759 */
4760 smrp->smr_refcnt++;
4761 while (smrp->smr_state == DAPLKA_SMR_TRANSITIONING) {
4762 D2("mr_register_shared: smrp 0x%p, "
4763 "waiting in transitioning state, refcnt %d\n",
4764 smrp, smrp->smr_refcnt);
4765 cv_wait(&smrp->smr_cv, &daplka_shared_mr_lock);
4766 }
4767 ASSERT(smrp->smr_state == DAPLKA_SMR_READY);
4768 D2("mr_register_shared: smrp 0x%p, refcnt %d, ready\n",
4769 smrp, smrp->smr_refcnt);
4770
4771 /*
4772 * we set smr_state to TRANSITIONING to temporarily
4773 * prevent other threads from trying to access smrp.
4774 */
4775 smrp->smr_state = DAPLKA_SMR_TRANSITIONING;
4776 } else {
4777 D2("mr_register_shared: cannot find cookie:\n"
4778 "0x%016llx%016llx%016llx%016llx%016llx\n",
4779 (longlong_t)tmp_smr.smr_cookie.mc_uint_arr[4],
4780 (longlong_t)tmp_smr.smr_cookie.mc_uint_arr[3],
4781 (longlong_t)tmp_smr.smr_cookie.mc_uint_arr[2],
4782 (longlong_t)tmp_smr.smr_cookie.mc_uint_arr[1],
4783 (longlong_t)tmp_smr.smr_cookie.mc_uint_arr[0]);
4784
4785 /*
4786 * if we cannot find smrp, we need to create and
4787 * insert one into daplka_shared_mr_tree
4788 */
4789 smrp = kmem_zalloc(sizeof (daplka_shared_mr_t),
4790 daplka_km_flags);
4791 if (smrp == NULL) {
4792 retval = ENOMEM;
4793 mutex_exit(&daplka_shared_mr_lock);
4794 goto cleanup;
4795 }
4796 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*smrp))
4797 smrp->smr_refcnt = 1;
4798 smrp->smr_cookie = args.mrs_shm_cookie;
4799 smrp->smr_state = DAPLKA_SMR_TRANSITIONING;
4800 smrp->smr_mr_list = NULL;
4801 cv_init(&smrp->smr_cv, NULL, CV_DRIVER, NULL);
4802 avl_insert(&daplka_shared_mr_tree, smrp, where);
4803 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*smrp))
4804 }
4805 mutex_exit(&daplka_shared_mr_lock);
4806
4807 mr_rp = kmem_zalloc(sizeof (daplka_mr_resource_t), daplka_km_flags);
4808 if (mr_rp == NULL) {
4809 DERR("mr_register_shared: cannot allocate mr resource\n");
4810 goto cleanup;
4811 }
4812 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*mr_rp))
4813 DAPLKA_RS_INIT(mr_rp, DAPL_TYPE_MR,
4814 DAPLKA_RS_RNUM(ia_rp), daplka_mr_destroy);
4815
4816 mutex_init(&mr_rp->mr_lock, NULL, MUTEX_DRIVER, NULL);
4817 mr_rp->mr_hca = ia_rp->ia_hca;
4818 mr_rp->mr_hca_hdl = ia_rp->ia_hca_hdl;
4819 mr_rp->mr_next = NULL;
4820 mr_rp->mr_shared_mr = NULL;
4821
4822 /* get pd handle */
4823 pd_rp = (daplka_pd_resource_t *)
4824 daplka_hash_lookup(&ia_rp->ia_pd_htbl, args.mrs_pd_hkey);
4825 if (pd_rp == NULL) {
4826 DERR("mr_register_shared: cannot find pd resource\n");
4827 retval = EINVAL;
4828 goto cleanup;
4829 }
4830 ASSERT(DAPLKA_RS_TYPE(pd_rp) == DAPL_TYPE_PD);
4831 mr_rp->mr_pd_res = pd_rp;
4832
4833 mr_rp->mr_attr.mr_vaddr = args.mrs_vaddr;
4834 mr_rp->mr_attr.mr_len = args.mrs_len;
4835 mr_rp->mr_attr.mr_flags = args.mrs_flags | IBT_MR_NOSLEEP;
4836 mr_rp->mr_attr.mr_as = curproc->p_as;
4837
4838 D2("mr_register_shared: mr_vaddr 0x%p, mr_len %llu, "
4839 "mr_flags 0x%x, mr_as 0x%p, mr_exists %d, smrp 0x%p\n",
4840 (void *)(uintptr_t)mr_rp->mr_attr.mr_vaddr,
4841 (longlong_t)mr_rp->mr_attr.mr_len,
4842 mr_rp->mr_attr.mr_flags, mr_rp->mr_attr.mr_as,
4843 (int)(smrp->smr_mr_list != NULL), smrp);
4844
4845 /*
4846 * since we are in TRANSITIONING state, we are guaranteed
4847 * that we have exclusive access to smr_mr_list.
4848 */
4849 if (smrp->smr_mr_list != NULL) {
4850 ibt_smr_attr_t mem_sattr;
4851
4852 /*
4853 * a non-null smr_mr_list indicates that someone
4854 * else has already inserted an mr_resource into
4855 * smr_mr_list. we use the mr_handle from the first
4856 * element as an arg to ibt_register_shared_mr.
4857 */
4858 mem_sattr.mr_vaddr = smrp->smr_mr_list->mr_desc.md_vaddr;
4859 mem_sattr.mr_flags = mr_rp->mr_attr.mr_flags;
4860
4861 D2("mr_register_shared: mem_sattr vaddr 0x%p flags 0x%x\n",
4862 (void *)(uintptr_t)mem_sattr.mr_vaddr, mem_sattr.mr_flags);
4863 status = daplka_ibt_register_shared_mr(mr_rp, ia_rp->ia_hca_hdl,
4864 smrp->smr_mr_list->mr_hdl, mr_rp->mr_pd_res->pd_hdl,
4865 &mem_sattr, &mr_rp->mr_hdl, &mr_rp->mr_desc);
4866
4867 if (status != IBT_SUCCESS) {
4868 DERR("mr_register_shared: "
4869 "ibt_register_shared_mr error %d\n", status);
4870 *rvalp = (int)status;
4871 retval = 0;
4872 goto cleanup;
4873 }
4874 } else {
4875 /*
4876 * an mr does not exist yet. we need to create one
4877 * using ibt_register_mr.
4878 */
4879 status = daplka_ibt_register_mr(mr_rp, ia_rp->ia_hca_hdl,
4880 mr_rp->mr_pd_res->pd_hdl, &mr_rp->mr_attr,
4881 &mr_rp->mr_hdl, &mr_rp->mr_desc);
4882
4883 if (status != IBT_SUCCESS) {
4884 DERR("mr_register_shared: "
4885 "ibt_register_mr error %d\n", status);
4886 *rvalp = (int)status;
4887 retval = 0;
4888 goto cleanup;
4889 }
4890 }
4891
4892 mr_cb_data_in.mr_rev = IBT_MR_DATA_IN_IF_VERSION;
4893 mr_cb_data_in.mr_func = daplka_pre_mr_cleanup_callback;
4894 mr_cb_data_in.mr_arg1 = (void *)mr_rp;
4895 mr_cb_data_in.mr_arg2 = NULL;
4896
4897 /* Pass the service driver mr cleanup handler to the hca driver */
4898 status = ibt_ci_data_in(ia_rp->ia_hca_hdl,
4899 IBT_CI_NO_FLAGS, IBT_HDL_MR, (void *)mr_rp->mr_hdl,
4900 &mr_cb_data_in, sizeof (mr_cb_data_in));
4901
4902 if (status != IBT_SUCCESS) {
4903 DERR("mr_register_shared: ibt_ci_data_in error(%d) ver(%d)",
4904 status, mr_cb_data_in.mr_rev);
4905 *rvalp = (int)status;
4906 retval = 0;
4907 goto cleanup;
4908 }
4909
4910 /*
4911 * we bump reference of mr_rp and enqueue it onto smrp.
4912 */
4913 DAPLKA_RS_REF(mr_rp);
4914 mr_rp->mr_next = smrp->smr_mr_list;
4915 smrp->smr_mr_list = mr_rp;
4916 mr_rp->mr_shared_mr = smrp;
4917
4918 /* insert into mr hash table */
4919 retval = daplka_hash_insert(&ia_rp->ia_mr_htbl,
4920 &mr_hkey, (void *)mr_rp);
4921 if (retval != 0) {
4922 DERR("mr_register_shared: cannot insert mr resource\n");
4923 goto cleanup;
4924 }
4925 inserted = B_TRUE;
4926 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*mr_rp))
4927
4928 /*
4929 * at this point, there are two references to our mr resource.
4930 * one is kept in ia_mr_htbl. the other is kept in the list
4931 * within this shared mr object (smrp). when we deregister this
4932 * mr or when a callback invalidates this mr, the reference kept
4933 * by this shared mr object will be removed.
4934 */
4935
4936 args.mrs_lkey = mr_rp->mr_desc.md_lkey;
4937 args.mrs_rkey = mr_rp->mr_desc.md_rkey;
4938 args.mrs_hkey = mr_hkey;
4939
4940 retval = ddi_copyout((void *)&args, (void *)arg,
4941 sizeof (dapl_mr_register_shared_t), mode);
4942 if (retval != 0) {
4943 DERR("mr_register_shared: copyout error %d\n", retval);
4944 retval = EFAULT;
4945 goto cleanup;
4946 }
4947
4948 /*
4949 * set the state to READY to allow others to continue
4950 */
4951 mutex_enter(&daplka_shared_mr_lock);
4952 smrp->smr_state = DAPLKA_SMR_READY;
4953 cv_broadcast(&smrp->smr_cv);
4954 mutex_exit(&daplka_shared_mr_lock);
4955 return (0);
4956
4957 cleanup:;
4958 if (inserted) {
4959 daplka_mr_resource_t *free_rp = NULL;
4960
4961 (void) daplka_hash_remove(&ia_rp->ia_mr_htbl, mr_hkey,
4962 (void **)&free_rp);
4963 if (free_rp != mr_rp) {
4964 DERR("mr_register_shared: "
4965 "cannot remove mr from hash table\n");
4966 /*
4967 * we can only get here if another thread
4968 * has completed the cleanup in mr_deregister
4969 */
4970 return (retval);
4971 }
4972 }
4973 if (smrp != NULL) {
4974 mutex_enter(&daplka_shared_mr_lock);
4975 ASSERT(smrp->smr_refcnt > 0);
4976 smrp->smr_refcnt--;
4977
4978 if (smrp->smr_refcnt == 0) {
4979 DERR("mr_register_shared: freeing smrp 0x%p\n", smrp);
4980 avl_remove(&daplka_shared_mr_tree, smrp);
4981 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*smrp))
4982 if (smrp->smr_mr_list != NULL) {
4983 /*
4984 * the refcnt is 0. if there is anything
4985 * left on the list, it must be ours.
4986 */
4987 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*mr_rp))
4988 ASSERT(smrp->smr_mr_list == mr_rp);
4989 DAPLKA_RS_UNREF(mr_rp);
4990 smrp->smr_mr_list = NULL;
4991 ASSERT(mr_rp->mr_shared_mr == smrp);
4992 mr_rp->mr_shared_mr = NULL;
4993 ASSERT(mr_rp->mr_next == NULL);
4994 }
4995 smrp->smr_state = DAPLKA_SMR_FREED;
4996 cv_destroy(&smrp->smr_cv);
4997 kmem_free(smrp, sizeof (daplka_shared_mr_t));
4998 } else {
4999 DERR("mr_register_shared: resetting smr_state "
5000 "smrp 0x%p, %d waiters remain\n", smrp,
5001 smrp->smr_refcnt);
5002 ASSERT(smrp->smr_state == DAPLKA_SMR_TRANSITIONING);
5003 if (smrp->smr_mr_list != NULL && mr_rp != NULL) {
5004 daplka_mr_resource_t **mpp;
5005
5006 /*
5007 * search and remove mr_rp from smr_mr_list
5008 */
5009 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*mr_rp))
5010 mpp = &smrp->smr_mr_list;
5011 while (*mpp != NULL) {
5012 if (*mpp == mr_rp) {
5013 *mpp = (*mpp)->mr_next;
5014 DAPLKA_RS_UNREF(mr_rp);
5015 ASSERT(mr_rp->mr_shared_mr ==
5016 smrp);
5017 mr_rp->mr_shared_mr = NULL;
5018 mr_rp->mr_next = NULL;
5019 break;
5020 }
5021 mpp = &(*mpp)->mr_next;
5022 }
5023 }
5024 /*
5025 * note that smr_state == READY does not necessarily
5026 * mean that smr_mr_list is non empty. for this case,
5027 * we are doing cleanup because of a failure. we set
5028 * the state to READY to allow other threads to
5029 * continue.
5030 */
5031 smrp->smr_state = DAPLKA_SMR_READY;
5032 cv_broadcast(&smrp->smr_cv);
5033 }
5034 mutex_exit(&daplka_shared_mr_lock);
5035 }
5036 if (mr_rp != NULL) {
5037 DAPLKA_RS_UNREF(mr_rp);
5038 }
5039 return (retval);
5040 }
5041
5042 /*
5043 * registers a memory region using the attributes of an
5044 * existing region.
5045 */
5046 /* ARGSUSED */
5047 static int
5048 daplka_mr_register_lmr(daplka_ia_resource_t *ia_rp, intptr_t arg, int mode,
5049 cred_t *cred, int *rvalp)
5050 {
5051 boolean_t inserted = B_FALSE;
5052 dapl_mr_register_lmr_t args;
5053 ibt_mr_data_in_t mr_cb_data_in;
5054 daplka_mr_resource_t *orig_mr_rp = NULL;
5055 daplka_mr_resource_t *mr_rp;
5056 ibt_smr_attr_t mem_sattr;
5057 uint64_t mr_hkey = 0;
5058 ibt_status_t status;
5059 int retval;
5060
5061 retval = ddi_copyin((void *)arg, &args,
5062 sizeof (dapl_mr_register_lmr_t), mode);
5063 if (retval != 0) {
5064 DERR("mr_register_lmr: copyin error %d\n", retval);
5065 return (EINVAL);
5066 }
5067 orig_mr_rp = (daplka_mr_resource_t *)
5068 daplka_hash_lookup(&ia_rp->ia_mr_htbl, args.mrl_orig_hkey);
5069 if (orig_mr_rp == NULL) {
5070 DERR("mr_register_lmr: cannot find mr resource\n");
5071 return (EINVAL);
5072 }
5073 ASSERT(DAPLKA_RS_TYPE(orig_mr_rp) == DAPL_TYPE_MR);
5074
5075 mr_rp = kmem_zalloc(sizeof (daplka_mr_resource_t), daplka_km_flags);
5076 if (mr_rp == NULL) {
5077 DERR("mr_register_lmr: cannot allocate mr resource\n");
5078 retval = ENOMEM;
5079 goto cleanup;
5080 }
5081 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*mr_rp))
5082 DAPLKA_RS_INIT(mr_rp, DAPL_TYPE_MR,
5083 DAPLKA_RS_RNUM(ia_rp), daplka_mr_destroy);
5084
5085 mutex_init(&mr_rp->mr_lock, NULL, MUTEX_DRIVER, NULL);
5086 mr_rp->mr_hca = ia_rp->ia_hca;
5087 mr_rp->mr_hca_hdl = ia_rp->ia_hca_hdl;
5088 mr_rp->mr_next = NULL;
5089 mr_rp->mr_shared_mr = NULL;
5090
5091 DAPLKA_RS_REF(orig_mr_rp->mr_pd_res);
5092 mr_rp->mr_pd_res = orig_mr_rp->mr_pd_res;
5093 mr_rp->mr_attr = orig_mr_rp->mr_attr;
5094
5095 /* Pass the IO addr that was returned while allocating the orig MR */
5096 mem_sattr.mr_vaddr = orig_mr_rp->mr_desc.md_vaddr;
5097 mem_sattr.mr_flags = args.mrl_flags | IBT_MR_NOSLEEP;
5098
5099 status = daplka_ibt_register_shared_mr(mr_rp, ia_rp->ia_hca_hdl,
5100 orig_mr_rp->mr_hdl, mr_rp->mr_pd_res->pd_hdl, &mem_sattr,
5101 &mr_rp->mr_hdl, &mr_rp->mr_desc);
5102
5103 if (status != IBT_SUCCESS) {
5104 DERR("mr_register_lmr: ibt_register_shared_mr error %d\n",
5105 status);
5106 *rvalp = (int)status;
5107 retval = 0;
5108 goto cleanup;
5109 }
5110
5111 mr_cb_data_in.mr_rev = IBT_MR_DATA_IN_IF_VERSION;
5112 mr_cb_data_in.mr_func = daplka_pre_mr_cleanup_callback;
5113 mr_cb_data_in.mr_arg1 = (void *)mr_rp;
5114 mr_cb_data_in.mr_arg2 = NULL;
5115
5116 /* Pass the service driver mr cleanup handler to the hca driver */
5117 status = ibt_ci_data_in(ia_rp->ia_hca_hdl,
5118 IBT_CI_NO_FLAGS, IBT_HDL_MR, (void *)mr_rp->mr_hdl,
5119 &mr_cb_data_in, sizeof (mr_cb_data_in));
5120
5121 if (status != IBT_SUCCESS) {
5122 DERR("mr_register_lmr: ibt_ci_data_in error(%d) ver(%d)",
5123 status, mr_cb_data_in.mr_rev);
5124 *rvalp = (int)status;
5125 retval = 0;
5126 goto cleanup;
5127 }
5128 mr_rp->mr_attr.mr_len = orig_mr_rp->mr_attr.mr_len;
5129 mr_rp->mr_attr.mr_flags = mem_sattr.mr_flags;
5130
5131 /* insert into mr hash table */
5132 retval = daplka_hash_insert(&ia_rp->ia_mr_htbl, &mr_hkey,
5133 (void *)mr_rp);
5134 if (retval != 0) {
5135 DERR("mr_register: cannot insert mr resource into mr_htbl\n");
5136 goto cleanup;
5137 }
5138 inserted = B_TRUE;
5139 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*mr_rp))
5140
5141 args.mrl_lkey = mr_rp->mr_desc.md_lkey;
5142 args.mrl_rkey = mr_rp->mr_desc.md_rkey;
5143 args.mrl_hkey = mr_hkey;
5144
5145 retval = ddi_copyout((void *)&args, (void *)arg,
5146 sizeof (dapl_mr_register_lmr_t), mode);
5147 if (retval != 0) {
5148 DERR("mr_register_lmr: copyout error %d\n", retval);
5149 retval = EFAULT;
5150 goto cleanup;
5151 }
5152 if (orig_mr_rp != NULL) {
5153 DAPLKA_RS_UNREF(orig_mr_rp);
5154 }
5155 return (0);
5156
5157 cleanup:;
5158 if (inserted) {
5159 daplka_mr_resource_t *free_rp = NULL;
5160
5161 (void) daplka_hash_remove(&ia_rp->ia_mr_htbl, mr_hkey,
5162 (void **)&free_rp);
5163 if (free_rp != mr_rp) {
5164 DERR("mr_register: cannot remove mr from hash table\n");
5165 /*
5166 * we can only get here if another thread
5167 * has completed the cleanup in mr_deregister
5168 */
5169 return (retval);
5170 }
5171 }
5172 if (orig_mr_rp != NULL) {
5173 DAPLKA_RS_UNREF(orig_mr_rp);
5174 }
5175 if (mr_rp != NULL) {
5176 DAPLKA_RS_UNREF(mr_rp);
5177 }
5178 return (retval);
5179 }
5180
5181 /*
5182 * this function is called by mr_deregister and mr_cleanup_callback to
5183 * remove a mr resource from the shared mr object mr_rp->mr_shared_mr.
5184 * if mr_shared_mr is already NULL, that means the region being
5185 * deregistered or invalidated is not a shared mr region and we can
5186 * return immediately.
5187 */
5188 static void
5189 daplka_shared_mr_free(daplka_mr_resource_t *mr_rp)
5190 {
5191 daplka_shared_mr_t *smrp;
5192
5193 /*
5194 * we need a lock because mr_callback also checks this field.
5195 * for the rare case that mr_deregister and mr_cleanup_callback
5196 * gets called simultaneously, we are guaranteed that smrp won't
5197 * be dereferenced twice because either function will find
5198 * mr_shared_mr to be NULL.
5199 */
5200 mutex_enter(&mr_rp->mr_lock);
5201 smrp = mr_rp->mr_shared_mr;
5202 mr_rp->mr_shared_mr = NULL;
5203 mutex_exit(&mr_rp->mr_lock);
5204
5205 if (smrp != NULL) {
5206 daplka_mr_resource_t **mpp;
5207 boolean_t mr_found = B_FALSE;
5208
5209 mutex_enter(&daplka_shared_mr_lock);
5210 ASSERT(smrp->smr_refcnt > 0);
5211 while (smrp->smr_state == DAPLKA_SMR_TRANSITIONING) {
5212 cv_wait(&smrp->smr_cv, &daplka_shared_mr_lock);
5213 }
5214 ASSERT(smrp->smr_state == DAPLKA_SMR_READY);
5215 smrp->smr_state = DAPLKA_SMR_TRANSITIONING;
5216 smrp->smr_refcnt--;
5217
5218 /*
5219 * search and remove mr_rp from smr_mr_list.
5220 * also UNREF mr_rp because it is no longer
5221 * on the list.
5222 */
5223 mpp = &smrp->smr_mr_list;
5224 while (*mpp != NULL) {
5225 if (*mpp == mr_rp) {
5226 *mpp = (*mpp)->mr_next;
5227 DAPLKA_RS_UNREF(mr_rp);
5228 mr_rp->mr_next = NULL;
5229 mr_found = B_TRUE;
5230 break;
5231 }
5232 mpp = &(*mpp)->mr_next;
5233 }
5234 /*
5235 * since mr_clean_callback may not touch smr_mr_list
5236 * at this time (due to smr_state), we can be sure
5237 * that we can find and remove mr_rp from smr_mr_list
5238 */
5239 ASSERT(mr_found);
5240 if (smrp->smr_refcnt == 0) {
5241 D3("shared_mr_free: freeing smrp 0x%p\n", smrp);
5242 avl_remove(&daplka_shared_mr_tree, smrp);
5243 ASSERT(smrp->smr_mr_list == NULL);
5244 smrp->smr_state = DAPLKA_SMR_FREED;
5245 cv_destroy(&smrp->smr_cv);
5246 kmem_free(smrp, sizeof (daplka_shared_mr_t));
5247 } else {
5248 D3("shared_mr_free: smrp 0x%p, refcnt %d\n",
5249 smrp, smrp->smr_refcnt);
5250 smrp->smr_state = DAPLKA_SMR_READY;
5251 cv_broadcast(&smrp->smr_cv);
5252 }
5253 mutex_exit(&daplka_shared_mr_lock);
5254 }
5255 }
5256
5257 /*
5258 * deregisters a memory region.
5259 * if mr is shared, remove reference from global shared mr object.
5260 * release the initial reference to the mr. if the mr's refcnt is
5261 * zero, call mr_destroy to free mr.
5262 */
5263 /* ARGSUSED */
5264 static int
5265 daplka_mr_deregister(daplka_ia_resource_t *ia_rp, intptr_t arg, int mode,
5266 cred_t *cred, int *rvalp)
5267 {
5268 daplka_mr_resource_t *mr_rp;
5269 dapl_mr_deregister_t args;
5270 int retval;
5271
5272 retval = ddi_copyin((void *)arg, &args, sizeof (dapl_mr_deregister_t),
5273 mode);
5274 if (retval != 0) {
5275 DERR("mr_deregister: copyin error %d\n", retval);
5276 return (EINVAL);
5277 }
5278 retval = daplka_hash_remove(&ia_rp->ia_mr_htbl,
5279 args.mrd_hkey, (void **)&mr_rp);
5280 if (retval != 0 || mr_rp == NULL) {
5281 DERR("mr_deregister: cannot find mr resource\n");
5282 return (EINVAL);
5283 }
5284 ASSERT(DAPLKA_RS_TYPE(mr_rp) == DAPL_TYPE_MR);
5285
5286 daplka_shared_mr_free(mr_rp);
5287 DAPLKA_RS_UNREF(mr_rp);
5288 return (0);
5289 }
5290
5291 /*
5292 * sync local memory regions on RDMA read or write.
5293 */
5294 /* ARGSUSED */
5295 static int
5296 daplka_mr_sync(daplka_ia_resource_t *ia_rp, intptr_t arg, int mode,
5297 cred_t *cred, int *rvalp)
5298 {
5299 dapl_mr_sync_t args;
5300 daplka_mr_resource_t *mr_rp[DAPL_MR_PER_SYNC];
5301 ibt_mr_sync_t mrs[DAPL_MR_PER_SYNC];
5302 uint32_t sync_direction_flags;
5303 ibt_status_t status;
5304 int i, j;
5305 int retval;
5306
5307 retval = ddi_copyin((void *)arg, &args, sizeof (dapl_mr_sync_t), mode);
5308 if (retval != 0) {
5309 DERR("mr_sync: copyin error %d\n", retval);
5310 return (EFAULT);
5311 }
5312
5313 /* number of segments bound check */
5314 if (args.mrs_numseg > DAPL_MR_PER_SYNC) {
5315 DERR("mr_sync: number of segments too large\n");
5316 return (EINVAL);
5317 }
5318
5319 /* translate MR sync direction flag */
5320 if (args.mrs_flags == DAPL_MR_SYNC_RDMA_RD) {
5321 sync_direction_flags = IBT_SYNC_READ;
5322 } else if (args.mrs_flags == DAPL_MR_SYNC_RDMA_WR) {
5323 sync_direction_flags = IBT_SYNC_WRITE;
5324 } else {
5325 DERR("mr_sync: unknown flags\n");
5326 return (EINVAL);
5327 }
5328
5329 /*
5330 * all the segments are going to be sync'd by ibtl together
5331 */
5332 for (i = 0; i < args.mrs_numseg; i++) {
5333 mr_rp[i] = (daplka_mr_resource_t *)daplka_hash_lookup(
5334 &ia_rp->ia_mr_htbl, args.mrs_vec[i].mrsv_hkey);
5335 if (mr_rp[i] == NULL) {
5336 for (j = 0; j < i; j++) {
5337 DAPLKA_RS_UNREF(mr_rp[j]);
5338 }
5339 DERR("mr_sync: lookup error\n");
5340 return (EINVAL);
5341 }
5342 ASSERT(DAPLKA_RS_TYPE(mr_rp[i]) == DAPL_TYPE_MR);
5343 mrs[i].ms_handle = mr_rp[i]->mr_hdl;
5344 mrs[i].ms_vaddr = args.mrs_vec[i].mrsv_va;
5345 mrs[i].ms_len = args.mrs_vec[i].mrsv_len;
5346 mrs[i].ms_flags = sync_direction_flags;
5347 }
5348
5349 status = ibt_sync_mr(ia_rp->ia_hca_hdl, mrs, args.mrs_numseg);
5350 if (status != IBT_SUCCESS) {
5351 DERR("mr_sync: ibt_sync_mr error %d\n", status);
5352 *rvalp = (int)status;
5353 }
5354 for (i = 0; i < args.mrs_numseg; i++) {
5355 DAPLKA_RS_UNREF(mr_rp[i]);
5356 }
5357 return (0);
5358 }
5359
5360 /*
5361 * destroys a memory region.
5362 * called when refcnt drops to zero.
5363 */
5364 static int
5365 daplka_mr_destroy(daplka_resource_t *gen_rp)
5366 {
5367 daplka_mr_resource_t *mr_rp = (daplka_mr_resource_t *)gen_rp;
5368 ibt_status_t status;
5369
5370 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*mr_rp))
5371 ASSERT(DAPLKA_RS_REFCNT(mr_rp) == 0);
5372 ASSERT(mr_rp->mr_shared_mr == NULL);
5373 D3("mr_destroy: entering, mr_rp 0x%p, rnum %d\n",
5374 mr_rp, DAPLKA_RS_RNUM(mr_rp));
5375
5376 /*
5377 * deregister mr
5378 */
5379 if (mr_rp->mr_hdl) {
5380 status = daplka_ibt_deregister_mr(mr_rp, mr_rp->mr_hca_hdl,
5381 mr_rp->mr_hdl);
5382 if (status != IBT_SUCCESS) {
5383 DERR("mr_destroy: ibt_deregister_mr returned %d\n",
5384 status);
5385 }
5386 mr_rp->mr_hdl = NULL;
5387 D3("mr_destroy: mr deregistered\n");
5388 }
5389 mr_rp->mr_attr.mr_vaddr = NULL;
5390
5391 /*
5392 * release reference on PD
5393 */
5394 if (mr_rp->mr_pd_res != NULL) {
5395 DAPLKA_RS_UNREF(mr_rp->mr_pd_res);
5396 mr_rp->mr_pd_res = NULL;
5397 }
5398 mutex_destroy(&mr_rp->mr_lock);
5399 DAPLKA_RS_FINI(mr_rp);
5400 kmem_free(mr_rp, sizeof (daplka_mr_resource_t));
5401 D3("mr_destroy: exiting, mr_rp 0x%p\n", mr_rp);
5402 return (0);
5403 }
5404
5405 /*
5406 * this function is called by daplka_hash_destroy for
5407 * freeing MR resource objects
5408 */
5409 static void
5410 daplka_hash_mr_free(void *obj)
5411 {
5412 daplka_mr_resource_t *mr_rp = (daplka_mr_resource_t *)obj;
5413
5414 daplka_shared_mr_free(mr_rp);
5415 DAPLKA_RS_UNREF(mr_rp);
5416 }
5417
5418 /*
5419 * comparison function used for finding a shared mr object
5420 * from the global shared mr avl tree.
5421 */
5422 static int
5423 daplka_shared_mr_cmp(const void *smr1, const void *smr2)
5424 {
5425 daplka_shared_mr_t *s1 = (daplka_shared_mr_t *)smr1;
5426 daplka_shared_mr_t *s2 = (daplka_shared_mr_t *)smr2;
5427 int i;
5428
5429 for (i = 4; i >= 0; i--) {
5430 if (s1->smr_cookie.mc_uint_arr[i] <
5431 s2->smr_cookie.mc_uint_arr[i]) {
5432 return (-1);
5433 }
5434 if (s1->smr_cookie.mc_uint_arr[i] >
5435 s2->smr_cookie.mc_uint_arr[i]) {
5436 return (1);
5437 }
5438 }
5439 return (0);
5440 }
5441
5442 /*
5443 * allocates a protection domain.
5444 */
5445 /* ARGSUSED */
5446 static int
5447 daplka_pd_alloc(daplka_ia_resource_t *ia_rp, intptr_t arg, int mode,
5448 cred_t *cred, int *rvalp)
5449 {
5450 dapl_pd_alloc_t args;
5451 daplka_pd_resource_t *pd_rp;
5452 ibt_status_t status;
5453 uint64_t pd_hkey = 0;
5454 boolean_t inserted = B_FALSE;
5455 int retval;
5456
5457 pd_rp = kmem_zalloc(sizeof (*pd_rp), daplka_km_flags);
5458 if (pd_rp == NULL) {
5459 DERR("pd_alloc: cannot allocate pd resource\n");
5460 return (ENOMEM);
5461 }
5462 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*pd_rp))
5463 DAPLKA_RS_INIT(pd_rp, DAPL_TYPE_PD,
5464 DAPLKA_RS_RNUM(ia_rp), daplka_pd_destroy);
5465
5466 pd_rp->pd_hca = ia_rp->ia_hca;
5467 pd_rp->pd_hca_hdl = ia_rp->ia_hca_hdl;
5468 status = daplka_ibt_alloc_pd(pd_rp, pd_rp->pd_hca_hdl,
5469 IBT_PD_NO_FLAGS, &pd_rp->pd_hdl);
5470 if (status != IBT_SUCCESS) {
5471 DERR("pd_alloc: ibt_alloc_pd returned %d\n", status);
5472 *rvalp = (int)status;
5473 retval = 0;
5474 goto cleanup;
5475 }
5476
5477 /* insert into pd hash table */
5478 retval = daplka_hash_insert(&ia_rp->ia_pd_htbl,
5479 &pd_hkey, (void *)pd_rp);
5480 if (retval != 0) {
5481 DERR("pd_alloc: cannot insert pd resource into pd_htbl\n");
5482 goto cleanup;
5483 }
5484 inserted = B_TRUE;
5485 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*pd_rp))
5486
5487 /* return hkey to library */
5488 args.pda_hkey = pd_hkey;
5489
5490 retval = ddi_copyout(&args, (void *)arg, sizeof (dapl_pd_alloc_t),
5491 mode);
5492 if (retval != 0) {
5493 DERR("pd_alloc: copyout error %d\n", retval);
5494 retval = EFAULT;
5495 goto cleanup;
5496 }
5497 return (0);
5498
5499 cleanup:;
5500 if (inserted) {
5501 daplka_pd_resource_t *free_rp = NULL;
5502
5503 (void) daplka_hash_remove(&ia_rp->ia_pd_htbl, pd_hkey,
5504 (void **)&free_rp);
5505 if (free_rp != pd_rp) {
5506 DERR("pd_alloc: cannot remove pd from hash table\n");
5507 /*
5508 * we can only get here if another thread
5509 * has completed the cleanup in pd_free
5510 */
5511 return (retval);
5512 }
5513 }
5514 DAPLKA_RS_UNREF(pd_rp);
5515 return (retval);
5516 }
5517
5518 /*
5519 * destroys a protection domain.
5520 * called when refcnt drops to zero.
5521 */
5522 static int
5523 daplka_pd_destroy(daplka_resource_t *gen_rp)
5524 {
5525 daplka_pd_resource_t *pd_rp = (daplka_pd_resource_t *)gen_rp;
5526 ibt_status_t status;
5527
5528 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*pd_rp))
5529 ASSERT(DAPLKA_RS_REFCNT(pd_rp) == 0);
5530 D3("pd_destroy: entering, pd_rp %p, rnum %d\n",
5531 pd_rp, DAPLKA_RS_RNUM(pd_rp));
5532
5533 ASSERT(DAPLKA_RS_TYPE(pd_rp) == DAPL_TYPE_PD);
5534 if (pd_rp->pd_hdl != NULL) {
5535 status = daplka_ibt_free_pd(pd_rp, pd_rp->pd_hca_hdl,
5536 pd_rp->pd_hdl);
5537 if (status != IBT_SUCCESS) {
5538 DERR("pd_destroy: ibt_free_pd returned %d\n", status);
5539 }
5540 }
5541 DAPLKA_RS_FINI(pd_rp);
5542 kmem_free(pd_rp, sizeof (daplka_pd_resource_t));
5543 D3("pd_destroy: exiting, pd_rp %p\n", pd_rp);
5544 return (0);
5545 }
5546
5547 static void
5548 daplka_hash_pd_free(void *obj)
5549 {
5550 daplka_pd_resource_t *pd_rp = (daplka_pd_resource_t *)obj;
5551
5552 ASSERT(DAPLKA_RS_TYPE(pd_rp) == DAPL_TYPE_PD);
5553 DAPLKA_RS_UNREF(pd_rp);
5554 }
5555
5556 /*
5557 * removes the pd reference from ia_pd_htbl and releases the
5558 * initial reference to the pd. also destroys the pd if the refcnt
5559 * is zero.
5560 */
5561 /* ARGSUSED */
5562 static int
5563 daplka_pd_free(daplka_ia_resource_t *ia_rp, intptr_t arg, int mode,
5564 cred_t *cred, int *rvalp)
5565 {
5566 daplka_pd_resource_t *pd_rp;
5567 dapl_pd_free_t args;
5568 int retval;
5569
5570 retval = ddi_copyin((void *)arg, &args, sizeof (dapl_pd_free_t), mode);
5571 if (retval != 0) {
5572 DERR("pd_free: copyin error %d\n", retval);
5573 return (EINVAL);
5574 }
5575
5576 retval = daplka_hash_remove(&ia_rp->ia_pd_htbl,
5577 args.pdf_hkey, (void **)&pd_rp);
5578 if (retval != 0 || pd_rp == NULL) {
5579 DERR("pd_free: cannot find pd resource\n");
5580 return (EINVAL);
5581 }
5582 ASSERT(DAPLKA_RS_TYPE(pd_rp) == DAPL_TYPE_PD);
5583
5584 /* UNREF calls the actual free function when refcnt is zero */
5585 DAPLKA_RS_UNREF(pd_rp);
5586 return (0);
5587 }
5588
5589 /*
5590 * allocates a memory window
5591 */
5592 /* ARGSUSED */
5593 static int
5594 daplka_mw_alloc(daplka_ia_resource_t *ia_rp, intptr_t arg, int mode,
5595 cred_t *cred, int *rvalp)
5596 {
5597 daplka_pd_resource_t *pd_rp;
5598 daplka_mw_resource_t *mw_rp;
5599 dapl_mw_alloc_t args;
5600 ibt_status_t status;
5601 boolean_t inserted = B_FALSE;
5602 uint64_t mw_hkey;
5603 ibt_rkey_t mw_rkey;
5604 int retval;
5605
5606 retval = ddi_copyin((void *)arg, &args, sizeof (dapl_mw_alloc_t), mode);
5607 if (retval != 0) {
5608 DERR("mw_alloc: copyin error %d\n", retval);
5609 return (EFAULT);
5610 }
5611
5612 /*
5613 * Allocate and initialize a MW resource
5614 */
5615 mw_rp = kmem_zalloc(sizeof (daplka_mw_resource_t), daplka_km_flags);
5616 if (mw_rp == NULL) {
5617 DERR("mw_alloc: cannot allocate mw resource\n");
5618 return (ENOMEM);
5619 }
5620 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*mw_rp))
5621 DAPLKA_RS_INIT(mw_rp, DAPL_TYPE_MW,
5622 DAPLKA_RS_RNUM(ia_rp), daplka_mw_destroy);
5623
5624 mutex_init(&mw_rp->mw_lock, NULL, MUTEX_DRIVER, NULL);
5625 mw_rp->mw_hca = ia_rp->ia_hca;
5626 mw_rp->mw_hca_hdl = ia_rp->ia_hca_hdl;
5627
5628 /* get pd handle */
5629 pd_rp = (daplka_pd_resource_t *)
5630 daplka_hash_lookup(&ia_rp->ia_pd_htbl, args.mw_pd_hkey);
5631 if (pd_rp == NULL) {
5632 DERR("mw_alloc: cannot find pd resource\n");
5633 goto cleanup;
5634 }
5635 ASSERT(DAPLKA_RS_TYPE(pd_rp) == DAPL_TYPE_PD);
5636
5637 mw_rp->mw_pd_res = pd_rp;
5638
5639 status = daplka_ibt_alloc_mw(mw_rp, mw_rp->mw_hca_hdl,
5640 pd_rp->pd_hdl, IBT_MW_NOSLEEP, &mw_rp->mw_hdl, &mw_rkey);
5641
5642 if (status != IBT_SUCCESS) {
5643 DERR("mw_alloc: ibt_alloc_mw returned %d\n", status);
5644 *rvalp = (int)status;
5645 retval = 0;
5646 goto cleanup;
5647 }
5648
5649 mutex_enter(&ia_rp->ia_lock);
5650 switch (ia_rp->ia_state) {
5651 case DAPLKA_IA_INIT:
5652 ia_rp->ia_state = DAPLKA_IA_MW_ALLOC_IN_PROGRESS;
5653 ia_rp->ia_mw_alloccnt++;
5654 retval = 0;
5655 break;
5656 case DAPLKA_IA_MW_ALLOC_IN_PROGRESS:
5657 /* another mw_alloc is already in progress increase cnt */
5658 ia_rp->ia_mw_alloccnt++;
5659 retval = 0;
5660 break;
5661 case DAPLKA_IA_MW_FREEZE_IN_PROGRESS:
5662 /* FALLTHRU */
5663 case DAPLKA_IA_MW_FROZEN:
5664 /*
5665 * IA is being or already frozen don't allow more MWs to be
5666 * allocated.
5667 */
5668 DERR("mw_alloc: IA is freezing MWs (state=%d)\n",
5669 ia_rp->ia_state);
5670 retval = EINVAL;
5671 break;
5672 default:
5673 ASSERT(!"Invalid IA state in mw_alloc");
5674 DERR("mw_alloc: IA state=%d invalid\n", ia_rp->ia_state);
5675 retval = EINVAL;
5676 break;
5677 }
5678 mutex_exit(&ia_rp->ia_lock);
5679 /* retval is 0 when ia_mw_alloccnt is incremented */
5680 if (retval != 0) {
5681 goto cleanup;
5682 }
5683
5684 /* insert into mw hash table */
5685 mw_hkey = 0;
5686 retval = daplka_hash_insert(&ia_rp->ia_mw_htbl, &mw_hkey,
5687 (void *)mw_rp);
5688 if (retval != 0) {
5689 DERR("mw_alloc: cannot insert mw resource into mw_htbl\n");
5690 mutex_enter(&ia_rp->ia_lock);
5691 ASSERT(ia_rp->ia_state == DAPLKA_IA_MW_ALLOC_IN_PROGRESS);
5692 ia_rp->ia_mw_alloccnt--;
5693 if (ia_rp->ia_mw_alloccnt == 0) {
5694 ia_rp->ia_state = DAPLKA_IA_INIT;
5695 cv_broadcast(&ia_rp->ia_cv);
5696 }
5697 mutex_exit(&ia_rp->ia_lock);
5698 goto cleanup;
5699 }
5700 inserted = B_TRUE;
5701 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*mw_rp))
5702
5703 D3("mw_alloc: ibt_alloc_mw mw_hdl(%p) mw_rkey(0x%llx)\n",
5704 mw_rp->mw_hdl, (longlong_t)mw_rkey);
5705
5706 mutex_enter(&ia_rp->ia_lock);
5707 /*
5708 * We are done with mw_alloc if this was the last mw_alloc
5709 * change state back to DAPLKA_IA_INIT and wake up waiters
5710 * specifically the unlock callback.
5711 */
5712 ASSERT(ia_rp->ia_state == DAPLKA_IA_MW_ALLOC_IN_PROGRESS);
5713 ia_rp->ia_mw_alloccnt--;
5714 if (ia_rp->ia_mw_alloccnt == 0) {
5715 ia_rp->ia_state = DAPLKA_IA_INIT;
5716 cv_broadcast(&ia_rp->ia_cv);
5717 }
5718 mutex_exit(&ia_rp->ia_lock);
5719
5720 args.mw_hkey = mw_hkey;
5721 args.mw_rkey = mw_rkey;
5722
5723 retval = ddi_copyout(&args, (void *)arg, sizeof (dapl_mw_alloc_t),
5724 mode);
5725 if (retval != 0) {
5726 DERR("mw_alloc: copyout error %d\n", retval);
5727 retval = EFAULT;
5728 goto cleanup;
5729 }
5730 return (0);
5731
5732 cleanup:;
5733 if (inserted) {
5734 daplka_mw_resource_t *free_rp = NULL;
5735
5736 (void) daplka_hash_remove(&ia_rp->ia_mw_htbl, mw_hkey,
5737 (void **)&free_rp);
5738 if (free_rp != mw_rp) {
5739 DERR("mw_alloc: cannot remove mw from hash table\n");
5740 /*
5741 * we can only get here if another thread
5742 * has completed the cleanup in mw_free
5743 */
5744 return (retval);
5745 }
5746 }
5747 DAPLKA_RS_UNREF(mw_rp);
5748 return (retval);
5749 }
5750
5751 /*
5752 * removes the mw reference from ia_mw_htbl and releases the
5753 * initial reference to the mw. also destroys the mw if the refcnt
5754 * is zero.
5755 */
5756 /* ARGSUSED */
5757 static int
5758 daplka_mw_free(daplka_ia_resource_t *ia_rp, intptr_t arg, int mode,
5759 cred_t *cred, int *rvalp)
5760 {
5761 daplka_mw_resource_t *mw_rp = NULL;
5762 dapl_mw_free_t args;
5763 int retval = 0;
5764
5765 retval = ddi_copyin((void *)arg, &args, sizeof (dapl_mw_free_t), mode);
5766 if (retval != 0) {
5767 DERR("mw_free: copyin error %d\n", retval);
5768 return (EFAULT);
5769 }
5770
5771 retval = daplka_hash_remove(&ia_rp->ia_mw_htbl, args.mw_hkey,
5772 (void **)&mw_rp);
5773 if (retval != 0 || mw_rp == NULL) {
5774 DERR("mw_free: cannot find mw resrc (0x%llx)\n",
5775 (longlong_t)args.mw_hkey);
5776 return (EINVAL);
5777 }
5778
5779 ASSERT(DAPLKA_RS_TYPE(mw_rp) == DAPL_TYPE_MW);
5780
5781 /* UNREF calls the actual free function when refcnt is zero */
5782 DAPLKA_RS_UNREF(mw_rp);
5783 return (retval);
5784 }
5785
5786 /*
5787 * destroys the memory window.
5788 * called when refcnt drops to zero.
5789 */
5790 static int
5791 daplka_mw_destroy(daplka_resource_t *gen_rp)
5792 {
5793 daplka_mw_resource_t *mw_rp = (daplka_mw_resource_t *)gen_rp;
5794 ibt_status_t status;
5795
5796 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*mw_rp))
5797 ASSERT(DAPLKA_RS_REFCNT(mw_rp) == 0);
5798 D3("mw_destroy: entering, mw_rp 0x%p, rnum %d\n",
5799 mw_rp, DAPLKA_RS_RNUM(mw_rp));
5800
5801 /*
5802 * free memory window
5803 */
5804 if (mw_rp->mw_hdl) {
5805 status = daplka_ibt_free_mw(mw_rp, mw_rp->mw_hca_hdl,
5806 mw_rp->mw_hdl);
5807 if (status != IBT_SUCCESS) {
5808 DERR("mw_destroy: ibt_free_mw returned %d\n", status);
5809 }
5810 mw_rp->mw_hdl = NULL;
5811 D3("mw_destroy: mw freed\n");
5812 }
5813
5814 /*
5815 * release reference on PD
5816 */
5817 if (mw_rp->mw_pd_res != NULL) {
5818 DAPLKA_RS_UNREF(mw_rp->mw_pd_res);
5819 mw_rp->mw_pd_res = NULL;
5820 }
5821 mutex_destroy(&mw_rp->mw_lock);
5822 DAPLKA_RS_FINI(mw_rp);
5823 kmem_free(mw_rp, sizeof (daplka_mw_resource_t));
5824 D3("mw_destroy: exiting, mw_rp 0x%p\n", mw_rp);
5825 return (0);
5826 }
5827
5828 static void
5829 daplka_hash_mw_free(void *obj)
5830 {
5831 daplka_mw_resource_t *mw_rp = (daplka_mw_resource_t *)obj;
5832
5833 ASSERT(DAPLKA_RS_TYPE(mw_rp) == DAPL_TYPE_MW);
5834 DAPLKA_RS_UNREF(mw_rp);
5835 }
5836
5837 /*
5838 * SRQ ioctls and supporting functions
5839 */
5840 /* ARGSUSED */
5841 static int
5842 daplka_srq_create(daplka_ia_resource_t *ia_rp, intptr_t arg, int mode,
5843 cred_t *cred, int *rvalp)
5844 {
5845 daplka_srq_resource_t *srq_rp;
5846 daplka_pd_resource_t *pd_rp;
5847 dapl_srq_create_t args;
5848 ibt_srq_sizes_t srq_sizes;
5849 ibt_srq_sizes_t srq_real_sizes;
5850 ibt_hca_attr_t *hca_attrp;
5851 uint64_t srq_hkey = 0;
5852 boolean_t inserted = B_FALSE;
5853 int retval;
5854 ibt_status_t status;
5855
5856 D3("srq_create: enter\n");
5857 retval = ddi_copyin((void *)arg, &args, sizeof (dapl_srq_create_t),
5858 mode);
5859 if (retval != 0) {
5860 DERR("srq_create: copyin error %d\n", retval);
5861 return (EFAULT);
5862 }
5863 srq_rp = kmem_zalloc(sizeof (daplka_srq_resource_t), daplka_km_flags);
5864 if (srq_rp == NULL) {
5865 DERR("srq_create: cannot allocate ep_rp\n");
5866 return (ENOMEM);
5867 }
5868 DAPLKA_RS_INIT(srq_rp, DAPL_TYPE_SRQ,
5869 DAPLKA_RS_RNUM(ia_rp), daplka_srq_destroy);
5870
5871 srq_rp->srq_hca = ia_rp->ia_hca;
5872 srq_rp->srq_hca_hdl = ia_rp->ia_hca_hdl;
5873 mutex_init(&srq_rp->srq_lock, NULL, MUTEX_DRIVER, NULL);
5874
5875 /* get pd handle */
5876 pd_rp = (daplka_pd_resource_t *)
5877 daplka_hash_lookup(&ia_rp->ia_pd_htbl, args.srqc_pd_hkey);
5878 if (pd_rp == NULL) {
5879 DERR("srq_create: cannot find pd resource\n");
5880 retval = EINVAL;
5881 goto cleanup;
5882 }
5883 ASSERT(DAPLKA_RS_TYPE(pd_rp) == DAPL_TYPE_PD);
5884 srq_rp->srq_pd_res = pd_rp;
5885
5886 /*
5887 * these checks ensure that the requested SRQ sizes
5888 * are within the limits supported by the chosen HCA.
5889 */
5890 hca_attrp = &ia_rp->ia_hca->hca_attr;
5891 if (args.srqc_sizes.srqs_sz > hca_attrp->hca_max_srqs_sz) {
5892 DERR("srq_create: invalid srqs_sz %d\n",
5893 args.srqc_sizes.srqs_sz);
5894 retval = EINVAL;
5895 goto cleanup;
5896 }
5897 if (args.srqc_sizes.srqs_sgl > hca_attrp->hca_max_srq_sgl) {
5898 DERR("srq_create: invalid srqs_sgl %d\n",
5899 args.srqc_sizes.srqs_sgl);
5900 retval = EINVAL;
5901 goto cleanup;
5902 }
5903
5904 D3("srq_create: srq_sgl %d, srq_sz %d\n",
5905 args.srqc_sizes.srqs_sgl, args.srqc_sizes.srqs_sz);
5906
5907 srq_sizes.srq_wr_sz = args.srqc_sizes.srqs_sz;
5908 srq_sizes.srq_sgl_sz = args.srqc_sizes.srqs_sgl;
5909
5910 /* create srq */
5911 status = daplka_ibt_alloc_srq(srq_rp, ia_rp->ia_hca_hdl,
5912 IBT_SRQ_USER_MAP, pd_rp->pd_hdl, &srq_sizes, &srq_rp->srq_hdl,
5913 &srq_real_sizes);
5914 if (status != IBT_SUCCESS) {
5915 DERR("srq_create: alloc_srq returned %d\n", status);
5916 *rvalp = (int)status;
5917 retval = 0;
5918 goto cleanup;
5919 }
5920
5921 args.srqc_real_sizes.srqs_sz = srq_real_sizes.srq_wr_sz;
5922 args.srqc_real_sizes.srqs_sgl = srq_real_sizes.srq_sgl_sz;
5923
5924 /* Get HCA-specific data_out info */
5925 status = ibt_ci_data_out(ia_rp->ia_hca_hdl,
5926 IBT_CI_NO_FLAGS, IBT_HDL_SRQ, (void *)srq_rp->srq_hdl,
5927 &args.srqc_data_out, sizeof (args.srqc_data_out));
5928
5929 if (status != IBT_SUCCESS) {
5930 DERR("srq_create: ibt_ci_data_out error(%d)\n", status);
5931 *rvalp = (int)status;
5932 retval = 0;
5933 goto cleanup;
5934 }
5935
5936 srq_rp->srq_real_size = srq_real_sizes.srq_wr_sz;
5937
5938 /* preparing to copyout map_data back to the library */
5939 args.srqc_real_sizes.srqs_sz = srq_real_sizes.srq_wr_sz;
5940 args.srqc_real_sizes.srqs_sgl = srq_real_sizes.srq_sgl_sz;
5941
5942 /* insert into srq hash table */
5943 retval = daplka_hash_insert(&ia_rp->ia_srq_htbl,
5944 &srq_hkey, (void *)srq_rp);
5945 if (retval != 0) {
5946 DERR("srq_create: cannot insert srq resource into srq_htbl\n");
5947 goto cleanup;
5948 }
5949 inserted = B_TRUE;
5950
5951 /* return hkey to library */
5952 args.srqc_hkey = srq_hkey;
5953
5954 retval = ddi_copyout(&args, (void *)arg, sizeof (dapl_srq_create_t),
5955 mode);
5956 if (retval != 0) {
5957 DERR("srq_create: copyout error %d\n", retval);
5958 retval = EFAULT;
5959 goto cleanup;
5960 }
5961
5962 D3("srq_create: %p, 0x%llx\n", srq_rp->srq_hdl, (longlong_t)srq_hkey);
5963 D3(" sz(%d) sgl(%d)\n",
5964 args.srqc_real_sizes.srqs_sz, args.srqc_real_sizes.srqs_sgl);
5965 D3("srq_create: exit\n");
5966 return (0);
5967
5968 cleanup:
5969 if (inserted) {
5970 daplka_srq_resource_t *free_rp = NULL;
5971
5972 (void) daplka_hash_remove(&ia_rp->ia_srq_htbl, srq_hkey,
5973 (void **)&free_rp);
5974 if (free_rp != srq_rp) {
5975 /*
5976 * this case is impossible because ep_free will
5977 * wait until our state transition is complete.
5978 */
5979 DERR("srq_create: cannot remove srq from hash table\n");
5980 ASSERT(B_FALSE);
5981 return (retval);
5982 }
5983 }
5984 DAPLKA_RS_UNREF(srq_rp);
5985 return (retval);
5986 }
5987
5988 /*
5989 * Resize an existing SRQ
5990 */
5991 /* ARGSUSED */
5992 static int
5993 daplka_srq_resize(daplka_ia_resource_t *ia_rp, intptr_t arg, int mode,
5994 cred_t *cred, int *rvalp)
5995 {
5996 daplka_srq_resource_t *srq_rp = NULL;
5997 ibt_hca_attr_t *hca_attrp;
5998 dapl_srq_resize_t args;
5999 ibt_status_t status;
6000 int retval = 0;
6001
6002 retval = ddi_copyin((void *)arg, &args, sizeof (dapl_srq_resize_t),
6003 mode);
6004 if (retval != 0) {
6005 DERR("srq_resize: copyin error %d\n", retval);
6006 return (EFAULT);
6007 }
6008
6009 /* get srq resource */
6010 srq_rp = (daplka_srq_resource_t *)
6011 daplka_hash_lookup(&ia_rp->ia_srq_htbl, args.srqr_hkey);
6012 if (srq_rp == NULL) {
6013 DERR("srq_resize: cannot find srq resource\n");
6014 return (EINVAL);
6015 }
6016 ASSERT(DAPLKA_RS_TYPE(srq_rp) == DAPL_TYPE_SRQ);
6017
6018 hca_attrp = &ia_rp->ia_hca->hca_attr;
6019 if (args.srqr_new_size > hca_attrp->hca_max_srqs_sz) {
6020 DERR("srq_resize: invalid srq size %d", args.srqr_new_size);
6021 retval = EINVAL;
6022 goto cleanup;
6023 }
6024
6025 mutex_enter(&srq_rp->srq_lock);
6026 /*
6027 * If ibt_resize_srq fails that it is primarily due to resource
6028 * shortage. Per IB spec resize will never loose events and
6029 * a resize error leaves the SRQ intact. Therefore even if the
6030 * resize request fails we proceed and get the mapping data
6031 * from the SRQ so that the library can mmap it.
6032 */
6033 status = ibt_modify_srq(srq_rp->srq_hdl, IBT_SRQ_SET_SIZE,
6034 args.srqr_new_size, 0, &args.srqr_real_size);
6035 if (status != IBT_SUCCESS) {
6036 /* we return the size of the old CQ if resize fails */
6037 args.srqr_real_size = srq_rp->srq_real_size;
6038 ASSERT(status != IBT_SRQ_HDL_INVALID);
6039 DERR("srq_resize: ibt_modify_srq failed:%d\n", status);
6040 } else {
6041 srq_rp->srq_real_size = args.srqr_real_size;
6042 }
6043 mutex_exit(&srq_rp->srq_lock);
6044
6045
6046 D2("srq_resize(%d): done new_sz(%u) real_sz(%u)\n",
6047 DAPLKA_RS_RNUM(srq_rp), args.srqr_new_size, args.srqr_real_size);
6048
6049 /* Get HCA-specific data_out info */
6050 status = ibt_ci_data_out(srq_rp->srq_hca_hdl,
6051 IBT_CI_NO_FLAGS, IBT_HDL_SRQ, (void *)srq_rp->srq_hdl,
6052 &args.srqr_data_out, sizeof (args.srqr_data_out));
6053 if (status != IBT_SUCCESS) {
6054 DERR("srq_resize: ibt_ci_data_out error(%d)\n", status);
6055 /* return ibt_ci_data_out status */
6056 *rvalp = (int)status;
6057 retval = 0;
6058 goto cleanup;
6059 }
6060
6061 retval = ddi_copyout(&args, (void *)arg, sizeof (dapl_srq_resize_t),
6062 mode);
6063 if (retval != 0) {
6064 DERR("srq_resize: copyout error %d\n", retval);
6065 retval = EFAULT;
6066 goto cleanup;
6067 }
6068
6069 cleanup:;
6070 if (srq_rp != NULL) {
6071 DAPLKA_RS_UNREF(srq_rp);
6072 }
6073 return (retval);
6074 }
6075
6076 /*
6077 * Frees an SRQ resource.
6078 */
6079 /* ARGSUSED */
6080 static int
6081 daplka_srq_free(daplka_ia_resource_t *ia_rp, intptr_t arg, int mode,
6082 cred_t *cred, int *rvalp)
6083 {
6084 daplka_srq_resource_t *srq_rp = NULL;
6085 dapl_srq_free_t args;
6086 int retval;
6087
6088 retval = ddi_copyin((void *)arg, &args, sizeof (dapl_srq_free_t), mode);
6089 if (retval != 0) {
6090 DERR("srq_free: copyin error %d\n", retval);
6091 return (EFAULT);
6092 }
6093
6094 retval = daplka_hash_remove(&ia_rp->ia_srq_htbl,
6095 args.srqf_hkey, (void **)&srq_rp);
6096 if (retval != 0 || srq_rp == NULL) {
6097 /*
6098 * this is only possible if we have two threads
6099 * calling ep_free in parallel.
6100 */
6101 DERR("srq_free: cannot find resource retval(%d) 0x%llx\n",
6102 retval, args.srqf_hkey);
6103 return (EINVAL);
6104 }
6105
6106 /* UNREF calls the actual free function when refcnt is zero */
6107 DAPLKA_RS_UNREF(srq_rp);
6108 return (0);
6109 }
6110
6111 /*
6112 * destroys a SRQ resource.
6113 * called when refcnt drops to zero.
6114 */
6115 static int
6116 daplka_srq_destroy(daplka_resource_t *gen_rp)
6117 {
6118 daplka_srq_resource_t *srq_rp = (daplka_srq_resource_t *)gen_rp;
6119 ibt_status_t status;
6120
6121 ASSERT(DAPLKA_RS_REFCNT(srq_rp) == 0);
6122
6123 D3("srq_destroy: entering, srq_rp 0x%p, rnum %d\n",
6124 srq_rp, DAPLKA_RS_RNUM(srq_rp));
6125 /*
6126 * destroy the srq
6127 */
6128 if (srq_rp->srq_hdl != NULL) {
6129 status = daplka_ibt_free_srq(srq_rp, srq_rp->srq_hdl);
6130 if (status != IBT_SUCCESS) {
6131 DERR("srq_destroy: ibt_free_srq returned %d\n",
6132 status);
6133 }
6134 srq_rp->srq_hdl = NULL;
6135 D3("srq_destroy: srq freed, rnum %d\n", DAPLKA_RS_RNUM(srq_rp));
6136 }
6137 /*
6138 * release all references
6139 */
6140 if (srq_rp->srq_pd_res != NULL) {
6141 DAPLKA_RS_UNREF(srq_rp->srq_pd_res);
6142 srq_rp->srq_pd_res = NULL;
6143 }
6144
6145 mutex_destroy(&srq_rp->srq_lock);
6146 DAPLKA_RS_FINI(srq_rp);
6147 kmem_free(srq_rp, sizeof (daplka_srq_resource_t));
6148 D3("srq_destroy: exiting, srq_rp 0x%p\n", srq_rp);
6149 return (0);
6150 }
6151
6152 static void
6153 daplka_hash_srq_free(void *obj)
6154 {
6155 daplka_srq_resource_t *srq_rp = (daplka_srq_resource_t *)obj;
6156
6157 ASSERT(DAPLKA_RS_TYPE(srq_rp) == DAPL_TYPE_SRQ);
6158 DAPLKA_RS_UNREF(srq_rp);
6159 }
6160
6161 /*
6162 * This function tells the CM to start listening on a service id.
6163 * It must be called by the passive side client before the client
6164 * can receive connection requests from remote endpoints. If the
6165 * client specifies a non-zero service id (connection qualifier in
6166 * dapl terms), this function will attempt to bind to this service
6167 * id and return an error if the id is already in use. If the client
6168 * specifies zero as the service id, this function will try to find
6169 * the next available service id and return it back to the client.
6170 * To support the cr_handoff function, this function will, in addition
6171 * to creating and inserting an SP resource into the per-IA SP hash
6172 * table, insert the SP resource into a global SP table. This table
6173 * maintains all active service points created by all dapl clients.
6174 * CR handoff locates the target SP by iterating through this global
6175 * table.
6176 */
6177 /* ARGSUSED */
6178 static int
6179 daplka_service_register(daplka_ia_resource_t *ia_rp, intptr_t arg, int mode,
6180 cred_t *cred, int *rvalp)
6181 {
6182 daplka_evd_resource_t *evd_rp = NULL;
6183 daplka_sp_resource_t *sp_rp = NULL;
6184 dapl_service_register_t args;
6185 ibt_srv_desc_t sd_args;
6186 ibt_srv_bind_t sb_args;
6187 ibt_status_t status;
6188 ib_svc_id_t retsid = 0;
6189 uint64_t sp_hkey = 0;
6190 boolean_t bumped = B_FALSE;
6191 int backlog_size;
6192 int retval = 0;
6193
6194 retval = ddi_copyin((void *)arg, &args,
6195 sizeof (dapl_service_register_t), mode);
6196 if (retval != 0) {
6197 DERR("service_register: copyin error %d\n", retval);
6198 return (EINVAL);
6199 }
6200
6201 sp_rp = kmem_zalloc(sizeof (*sp_rp), daplka_km_flags);
6202 if (sp_rp == NULL) {
6203 DERR("service_register: cannot allocate sp resource\n");
6204 return (ENOMEM);
6205 }
6206 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*sp_rp))
6207 DAPLKA_RS_INIT(sp_rp, DAPL_TYPE_SP,
6208 DAPLKA_RS_RNUM(ia_rp), daplka_sp_destroy);
6209
6210 /* check if evd exists */
6211 evd_rp = (daplka_evd_resource_t *)
6212 daplka_hash_lookup(&ia_rp->ia_evd_htbl, args.sr_evd_hkey);
6213 if (evd_rp == NULL) {
6214 DERR("service_register: evd resource not found\n");
6215 retval = EINVAL;
6216 goto cleanup;
6217 }
6218 /*
6219 * initialize backlog size
6220 */
6221 if (evd_rp && evd_rp->evd_cq_real_size > 0) {
6222 backlog_size = evd_rp->evd_cq_real_size + 1;
6223 } else {
6224 backlog_size = DAPLKA_DEFAULT_SP_BACKLOG;
6225 }
6226 D2("service_register: args.sr_sid = %llu\n", (longlong_t)args.sr_sid);
6227
6228 /* save the userland sp ptr */
6229 sp_rp->sp_cookie = args.sr_sp_cookie;
6230 sp_rp->sp_backlog_size = backlog_size;
6231 D3("service_register: backlog set to %d\n", sp_rp->sp_backlog_size);
6232 sp_rp->sp_backlog = kmem_zalloc(sp_rp->sp_backlog_size *
6233 sizeof (daplka_sp_conn_pend_t), daplka_km_flags);
6234
6235 /* save evd resource pointer */
6236 sp_rp->sp_evd_res = evd_rp;
6237
6238 /*
6239 * save ruid here so that we can do a comparison later
6240 * when someone does cr_handoff. the check will prevent
6241 * a malicious app from passing a CR to us.
6242 */
6243 sp_rp->sp_ruid = crgetruid(cred);
6244
6245 /* fill in args for register_service */
6246 sd_args.sd_ud_handler = NULL;
6247 sd_args.sd_handler = daplka_cm_service_handler;
6248 sd_args.sd_flags = IBT_SRV_NO_FLAGS;
6249
6250 status = ibt_register_service(daplka_dev->daplka_clnt_hdl,
6251 &sd_args, args.sr_sid, 1, &sp_rp->sp_srv_hdl, &retsid);
6252
6253 if (status != IBT_SUCCESS) {
6254 DERR("service_register: ibt_register_service returned %d\n",
6255 status);
6256 *rvalp = (int)status;
6257 retval = 0;
6258 goto cleanup;
6259 }
6260 /* save returned sid */
6261 sp_rp->sp_conn_qual = retsid;
6262 args.sr_retsid = retsid;
6263
6264 /* fill in args for bind_service */
6265 sb_args.sb_pkey = ia_rp->ia_port_pkey;
6266 sb_args.sb_lease = 0xffffffff;
6267 sb_args.sb_key[0] = 0x1234;
6268 sb_args.sb_key[1] = 0x5678;
6269 sb_args.sb_name = DAPLKA_DRV_NAME;
6270
6271 D2("service_register: bind(0x%llx:0x%llx)\n",
6272 (longlong_t)ia_rp->ia_hca_sgid.gid_prefix,
6273 (longlong_t)ia_rp->ia_hca_sgid.gid_guid);
6274
6275 status = ibt_bind_service(sp_rp->sp_srv_hdl, ia_rp->ia_hca_sgid,
6276 &sb_args, (void *)sp_rp, &sp_rp->sp_bind_hdl);
6277 if (status != IBT_SUCCESS) {
6278 DERR("service_register: ibt_bind_service returned %d\n",
6279 status);
6280 *rvalp = (int)status;
6281 retval = 0;
6282 goto cleanup;
6283 }
6284
6285 /*
6286 * need to bump refcnt because the global hash table will
6287 * have a reference to sp_rp
6288 */
6289 DAPLKA_RS_REF(sp_rp);
6290 bumped = B_TRUE;
6291
6292 /* insert into global sp hash table */
6293 sp_rp->sp_global_hkey = 0;
6294 retval = daplka_hash_insert(&daplka_global_sp_htbl,
6295 &sp_rp->sp_global_hkey, (void *)sp_rp);
6296 if (retval != 0) {
6297 DERR("service_register: cannot insert sp resource\n");
6298 goto cleanup;
6299 }
6300 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*sp_rp))
6301
6302 /* insert into per-IA sp hash table */
6303 retval = daplka_hash_insert(&ia_rp->ia_sp_htbl,
6304 &sp_hkey, (void *)sp_rp);
6305 if (retval != 0) {
6306 DERR("service_register: cannot insert sp resource\n");
6307 goto cleanup;
6308 }
6309
6310 /* pass index to application */
6311 args.sr_sp_hkey = sp_hkey;
6312 retval = ddi_copyout(&args, (void *)arg,
6313 sizeof (dapl_service_register_t), mode);
6314 if (retval != 0) {
6315 DERR("service_register: copyout error %d\n", retval);
6316 retval = EFAULT;
6317 goto cleanup;
6318 }
6319 return (0);
6320
6321 cleanup:;
6322 ASSERT(sp_rp != NULL);
6323 /* remove from ia table */
6324 if (sp_hkey != 0) {
6325 daplka_sp_resource_t *free_rp = NULL;
6326
6327 (void) daplka_hash_remove(&ia_rp->ia_sp_htbl,
6328 sp_hkey, (void **)&free_rp);
6329 if (free_rp != sp_rp) {
6330 DERR("service_register: cannot remove sp\n");
6331 /*
6332 * we can only get here if another thread
6333 * has completed the cleanup in svc_deregister
6334 */
6335 return (retval);
6336 }
6337 }
6338
6339 /* remove from global table */
6340 if (sp_rp->sp_global_hkey != 0) {
6341 daplka_sp_resource_t *free_rp = NULL;
6342
6343 /*
6344 * we get here if either the hash_insert into
6345 * ia_sp_htbl failed or the ddi_copyout failed.
6346 * hash_insert failure implies that we are the
6347 * only thread with a reference to sp. ddi_copyout
6348 * failure implies that svc_deregister could have
6349 * picked up the sp and destroyed it. but since
6350 * we got to this point, we must have removed
6351 * the sp ourselves in hash_remove above and
6352 * that the sp can be destroyed by us.
6353 */
6354 (void) daplka_hash_remove(&daplka_global_sp_htbl,
6355 sp_rp->sp_global_hkey, (void **)&free_rp);
6356 if (free_rp != sp_rp) {
6357 DERR("service_register: cannot remove sp\n");
6358 /*
6359 * this case is impossible. see explanation above.
6360 */
6361 ASSERT(B_FALSE);
6362 return (retval);
6363 }
6364 sp_rp->sp_global_hkey = 0;
6365 }
6366 /* unreference sp */
6367 if (bumped) {
6368 DAPLKA_RS_UNREF(sp_rp);
6369 }
6370
6371 /* destroy sp resource */
6372 DAPLKA_RS_UNREF(sp_rp);
6373 return (retval);
6374 }
6375
6376 /*
6377 * deregisters the service and removes SP from the global table.
6378 */
6379 /* ARGSUSED */
6380 static int
6381 daplka_service_deregister(daplka_ia_resource_t *ia_rp, intptr_t arg, int mode,
6382 cred_t *cred, int *rvalp)
6383 {
6384 dapl_service_deregister_t args;
6385 daplka_sp_resource_t *sp_rp = NULL, *g_sp_rp = NULL;
6386 int retval;
6387
6388 retval = ddi_copyin((void *)arg, &args,
6389 sizeof (dapl_service_deregister_t), mode);
6390
6391 if (retval != 0) {
6392 DERR("service_deregister: copyin error %d\n", retval);
6393 return (EINVAL);
6394 }
6395
6396 retval = daplka_hash_remove(&ia_rp->ia_sp_htbl,
6397 args.sdr_sp_hkey, (void **)&sp_rp);
6398 if (retval != 0 || sp_rp == NULL) {
6399 DERR("service_deregister: cannot find sp resource\n");
6400 return (EINVAL);
6401 }
6402
6403 retval = daplka_hash_remove(&daplka_global_sp_htbl,
6404 sp_rp->sp_global_hkey, (void **)&g_sp_rp);
6405 if (retval != 0 || g_sp_rp == NULL) {
6406 DERR("service_deregister: cannot find sp resource\n");
6407 }
6408
6409 /* remove the global reference */
6410 if (g_sp_rp == sp_rp) {
6411 DAPLKA_RS_UNREF(g_sp_rp);
6412 }
6413
6414 DAPLKA_RS_UNREF(sp_rp);
6415 return (0);
6416 }
6417
6418 /*
6419 * destroys a service point.
6420 * called when the refcnt drops to zero.
6421 */
6422 static int
6423 daplka_sp_destroy(daplka_resource_t *gen_rp)
6424 {
6425 daplka_sp_resource_t *sp_rp = (daplka_sp_resource_t *)gen_rp;
6426 ibt_status_t status;
6427
6428 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*sp_rp))
6429 ASSERT(DAPLKA_RS_REFCNT(sp_rp) == 0);
6430 D3("sp_destroy: entering, sp_rp %p, rnum %d\n",
6431 sp_rp, DAPLKA_RS_RNUM(sp_rp));
6432
6433 /*
6434 * it is possible for pending connections to remain
6435 * on an SP. We need to clean them up here.
6436 */
6437 if (sp_rp->sp_backlog != NULL) {
6438 ibt_cm_proceed_reply_t proc_reply;
6439 int i, cnt = 0;
6440 void *spcp_sidp;
6441
6442 for (i = 0; i < sp_rp->sp_backlog_size; i++) {
6443 if (sp_rp->sp_backlog[i].spcp_state ==
6444 DAPLKA_SPCP_PENDING) {
6445 cnt++;
6446 if (sp_rp->sp_backlog[i].spcp_sid == NULL) {
6447 DERR("sp_destroy: "
6448 "spcp_sid == NULL!\n");
6449 continue;
6450 }
6451 mutex_enter(&sp_rp->sp_lock);
6452 spcp_sidp = sp_rp->sp_backlog[i].spcp_sid;
6453 sp_rp->sp_backlog[i].spcp_state =
6454 DAPLKA_SPCP_INIT;
6455 sp_rp->sp_backlog[i].spcp_sid = NULL;
6456 sp_rp->sp_backlog[i].spcp_req_len = 0;
6457 mutex_exit(&sp_rp->sp_lock);
6458 status = ibt_cm_proceed(IBT_CM_EVENT_REQ_RCV,
6459 spcp_sidp,
6460 IBT_CM_NO_RESOURCE, &proc_reply, NULL, 0);
6461 if (status != IBT_SUCCESS) {
6462 DERR("sp_destroy: proceed failed %d\n",
6463 status);
6464 }
6465 }
6466 }
6467 if (cnt > 0) {
6468 DERR("sp_destroy: found %d pending "
6469 "connections\n", cnt);
6470 }
6471 }
6472
6473 if (sp_rp->sp_srv_hdl != NULL && sp_rp->sp_bind_hdl != NULL) {
6474 status = ibt_unbind_service(sp_rp->sp_srv_hdl,
6475 sp_rp->sp_bind_hdl);
6476 if (status != IBT_SUCCESS) {
6477 DERR("sp_destroy: ibt_unbind_service "
6478 "failed: %d\n", status);
6479 }
6480 }
6481
6482 if (sp_rp->sp_srv_hdl != NULL) {
6483 status = ibt_deregister_service(daplka_dev->daplka_clnt_hdl,
6484 sp_rp->sp_srv_hdl);
6485 if (status != IBT_SUCCESS) {
6486 DERR("sp_destroy: ibt_deregister_service "
6487 "failed: %d\n", status);
6488 }
6489 }
6490 if (sp_rp->sp_backlog != NULL) {
6491 kmem_free(sp_rp->sp_backlog,
6492 sp_rp->sp_backlog_size * sizeof (daplka_sp_conn_pend_t));
6493 sp_rp->sp_backlog = NULL;
6494 sp_rp->sp_backlog_size = 0;
6495 }
6496
6497 /*
6498 * release reference to evd
6499 */
6500 if (sp_rp->sp_evd_res != NULL) {
6501 DAPLKA_RS_UNREF(sp_rp->sp_evd_res);
6502 }
6503 sp_rp->sp_bind_hdl = NULL;
6504 sp_rp->sp_srv_hdl = NULL;
6505 DAPLKA_RS_FINI(sp_rp);
6506 kmem_free(sp_rp, sizeof (*sp_rp));
6507 D3("sp_destroy: exiting, sp_rp %p\n", sp_rp);
6508 return (0);
6509 }
6510
6511 /*
6512 * this function is called by daplka_hash_destroy for
6513 * freeing SP resource objects
6514 */
6515 static void
6516 daplka_hash_sp_free(void *obj)
6517 {
6518 daplka_sp_resource_t *sp_rp = (daplka_sp_resource_t *)obj;
6519 daplka_sp_resource_t *g_sp_rp;
6520 int retval;
6521
6522 ASSERT(DAPLKA_RS_TYPE(sp_rp) == DAPL_TYPE_SP);
6523
6524 retval = daplka_hash_remove(&daplka_global_sp_htbl,
6525 sp_rp->sp_global_hkey, (void **)&g_sp_rp);
6526 if (retval != 0 || g_sp_rp == NULL) {
6527 DERR("sp_free: cannot find sp resource\n");
6528 }
6529 if (g_sp_rp == sp_rp) {
6530 DAPLKA_RS_UNREF(g_sp_rp);
6531 }
6532
6533 DAPLKA_RS_UNREF(sp_rp);
6534 }
6535
6536 static void
6537 daplka_hash_sp_unref(void *obj)
6538 {
6539 daplka_sp_resource_t *sp_rp = (daplka_sp_resource_t *)obj;
6540
6541 ASSERT(DAPLKA_RS_TYPE(sp_rp) == DAPL_TYPE_SP);
6542 DAPLKA_RS_UNREF(sp_rp);
6543 }
6544
6545 /*
6546 * Passive side CM handlers
6547 */
6548
6549 /*
6550 * processes the REQ_RCV event
6551 */
6552 /* ARGSUSED */
6553 static ibt_cm_status_t
6554 daplka_cm_service_req(daplka_sp_resource_t *spp, ibt_cm_event_t *event,
6555 ibt_cm_return_args_t *ret_args, void *pr_data, ibt_priv_data_len_t pr_len)
6556 {
6557 daplka_sp_conn_pend_t *conn = NULL;
6558 daplka_evd_event_t *cr_ev = NULL;
6559 ibt_cm_status_t cm_status = IBT_CM_DEFAULT;
6560 uint16_t bkl_index;
6561 ibt_status_t status;
6562
6563 /*
6564 * acquire a slot in the connection backlog of this service point
6565 */
6566 mutex_enter(&spp->sp_lock);
6567 for (bkl_index = 0; bkl_index < spp->sp_backlog_size; bkl_index++) {
6568 if (spp->sp_backlog[bkl_index].spcp_state == DAPLKA_SPCP_INIT) {
6569 conn = &spp->sp_backlog[bkl_index];
6570 ASSERT(conn->spcp_sid == NULL);
6571 conn->spcp_state = DAPLKA_SPCP_PENDING;
6572 conn->spcp_sid = event->cm_session_id;
6573 break;
6574 }
6575 }
6576 mutex_exit(&spp->sp_lock);
6577
6578 /*
6579 * too many pending connections
6580 */
6581 if (bkl_index == spp->sp_backlog_size) {
6582 DERR("service_req: connection pending exceeded %d limit\n",
6583 spp->sp_backlog_size);
6584 return (IBT_CM_NO_RESOURCE);
6585 }
6586 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*conn))
6587
6588 /*
6589 * save data for cr_handoff
6590 */
6591 if (pr_data != NULL && pr_len > 0) {
6592 int trunc_len = pr_len;
6593
6594 if (trunc_len > DAPL_MAX_PRIVATE_DATA_SIZE) {
6595 DERR("service_req: private data truncated\n");
6596 trunc_len = DAPL_MAX_PRIVATE_DATA_SIZE;
6597 }
6598 conn->spcp_req_len = trunc_len;
6599 bcopy(pr_data, conn->spcp_req_data, trunc_len);
6600 } else {
6601 conn->spcp_req_len = 0;
6602 }
6603 conn->spcp_rdma_ra_in = event->cm_event.req.req_rdma_ra_in;
6604 conn->spcp_rdma_ra_out = event->cm_event.req.req_rdma_ra_out;
6605
6606 /*
6607 * create a CR event
6608 */
6609 cr_ev = kmem_zalloc(sizeof (daplka_evd_event_t), KM_NOSLEEP);
6610 if (cr_ev == NULL) {
6611 DERR("service_req: could not alloc cr_ev\n");
6612 cm_status = IBT_CM_NO_RESOURCE;
6613 goto cleanup;
6614 }
6615
6616 cr_ev->ee_next = NULL;
6617 cr_ev->ee_cmev.ec_cm_cookie = spp->sp_cookie;
6618 cr_ev->ee_cmev.ec_cm_is_passive = B_TRUE;
6619 cr_ev->ee_cmev.ec_cm_psep_cookie = DAPLKA_CREATE_PSEP_COOKIE(bkl_index);
6620 /*
6621 * save the requestor gid
6622 * daplka_event_poll needs this if this is a third party REQ_RCV
6623 */
6624 cr_ev->ee_cmev.ec_cm_req_prim_addr.gid_prefix =
6625 event->cm_event.req.req_prim_addr.av_dgid.gid_prefix;
6626 cr_ev->ee_cmev.ec_cm_req_prim_addr.gid_guid =
6627 event->cm_event.req.req_prim_addr.av_dgid.gid_guid;
6628
6629 /*
6630 * set event type
6631 */
6632 if (pr_len == 0) {
6633 cr_ev->ee_cmev.ec_cm_ev_type =
6634 DAPL_IB_CME_CONNECTION_REQUEST_PENDING;
6635 } else {
6636 cr_ev->ee_cmev.ec_cm_ev_priv_data =
6637 kmem_zalloc(pr_len, KM_NOSLEEP);
6638 if (cr_ev->ee_cmev.ec_cm_ev_priv_data == NULL) {
6639 DERR("service_req: could not alloc priv\n");
6640 cm_status = IBT_CM_NO_RESOURCE;
6641 goto cleanup;
6642 }
6643 bcopy(pr_data, cr_ev->ee_cmev.ec_cm_ev_priv_data, pr_len);
6644 cr_ev->ee_cmev.ec_cm_ev_type =
6645 DAPL_IB_CME_CONNECTION_REQUEST_PENDING_PRIVATE_DATA;
6646 }
6647 cr_ev->ee_cmev.ec_cm_ev_priv_data_len = pr_len;
6648
6649 /*
6650 * tell the active side to expect the processing time to be
6651 * at most equal to daplka_cm_delay
6652 */
6653 status = ibt_cm_delay(IBT_CM_DELAY_REQ, event->cm_session_id,
6654 daplka_cm_delay, NULL, 0);
6655 if (status != IBT_SUCCESS) {
6656 DERR("service_req: ibt_cm_delay failed %d\n", status);
6657 cm_status = IBT_CM_NO_RESOURCE;
6658 goto cleanup;
6659 }
6660
6661 /*
6662 * enqueue cr_ev onto the cr_events list of the EVD
6663 * corresponding to the SP
6664 */
6665 D2("service_req: enqueue event(%p) evdp(%p) priv_data(%p) "
6666 "priv_len(%d) psep(0x%llx)\n", cr_ev, spp->sp_evd_res,
6667 cr_ev->ee_cmev.ec_cm_ev_priv_data,
6668 (int)cr_ev->ee_cmev.ec_cm_ev_priv_data_len,
6669 (longlong_t)cr_ev->ee_cmev.ec_cm_psep_cookie);
6670
6671 daplka_evd_wakeup(spp->sp_evd_res,
6672 &spp->sp_evd_res->evd_cr_events, cr_ev);
6673
6674 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*conn))
6675 return (IBT_CM_DEFER);
6676
6677 cleanup:;
6678 /*
6679 * free the cr event
6680 */
6681 if (cr_ev != NULL) {
6682 if (cr_ev->ee_cmev.ec_cm_ev_priv_data != NULL) {
6683 kmem_free(cr_ev->ee_cmev.ec_cm_ev_priv_data, pr_len);
6684 cr_ev->ee_cmev.ec_cm_ev_priv_data = NULL;
6685 cr_ev->ee_cmev.ec_cm_ev_priv_data_len = 0;
6686 }
6687 kmem_free(cr_ev, sizeof (daplka_evd_event_t));
6688 }
6689 /*
6690 * release our slot in the backlog array
6691 */
6692 if (conn != NULL) {
6693 mutex_enter(&spp->sp_lock);
6694 ASSERT(conn->spcp_state == DAPLKA_SPCP_PENDING);
6695 ASSERT(conn->spcp_sid == event->cm_session_id);
6696 conn->spcp_state = DAPLKA_SPCP_INIT;
6697 conn->spcp_req_len = 0;
6698 conn->spcp_sid = NULL;
6699 mutex_exit(&spp->sp_lock);
6700 }
6701 return (cm_status);
6702 }
6703
6704 /*
6705 * processes the CONN_CLOSED event
6706 */
6707 /* ARGSUSED */
6708 static ibt_cm_status_t
6709 daplka_cm_service_conn_closed(daplka_sp_resource_t *sp_rp,
6710 ibt_cm_event_t *event, ibt_cm_return_args_t *ret_args,
6711 void *priv_data, ibt_priv_data_len_t len)
6712 {
6713 daplka_ep_resource_t *ep_rp;
6714 daplka_evd_event_t *disc_ev;
6715 uint32_t old_state, new_state;
6716
6717 ep_rp = (daplka_ep_resource_t *)
6718 ibt_get_chan_private(event->cm_channel);
6719 if (ep_rp == NULL) {
6720 DERR("service_conn_closed: ep_rp == NULL\n");
6721 return (IBT_CM_ACCEPT);
6722 }
6723
6724 /*
6725 * verify that the ep_state is either CONNECTED or
6726 * DISCONNECTING. if it is not in either states return
6727 * without generating an event.
6728 */
6729 new_state = old_state = daplka_ep_get_state(ep_rp);
6730 if (old_state != DAPLKA_EP_STATE_CONNECTED &&
6731 old_state != DAPLKA_EP_STATE_DISCONNECTING) {
6732 /*
6733 * we can get here if the connection is being aborted
6734 */
6735 D2("service_conn_closed: conn aborted, state = %d, "
6736 "closed = %d\n", old_state, (int)event->cm_event.closed);
6737 daplka_ep_set_state(ep_rp, old_state, new_state);
6738 return (IBT_CM_ACCEPT);
6739 }
6740
6741 /*
6742 * create a DAPL_IB_CME_DISCONNECTED event
6743 */
6744 disc_ev = kmem_zalloc(sizeof (daplka_evd_event_t), KM_NOSLEEP);
6745 if (disc_ev == NULL) {
6746 DERR("service_conn_closed: cannot alloc disc_ev\n");
6747 daplka_ep_set_state(ep_rp, old_state, new_state);
6748 return (IBT_CM_ACCEPT);
6749 }
6750
6751 disc_ev->ee_cmev.ec_cm_ev_type = DAPL_IB_CME_DISCONNECTED;
6752 disc_ev->ee_cmev.ec_cm_cookie = sp_rp->sp_cookie;
6753 disc_ev->ee_cmev.ec_cm_is_passive = B_TRUE;
6754 disc_ev->ee_cmev.ec_cm_psep_cookie = ep_rp->ep_psep_cookie;
6755 disc_ev->ee_cmev.ec_cm_ev_priv_data = NULL;
6756 disc_ev->ee_cmev.ec_cm_ev_priv_data_len = 0;
6757
6758 D2("service_conn_closed: enqueue event(%p) evdp(%p) psep(0x%llx)\n",
6759 disc_ev, sp_rp->sp_evd_res, (longlong_t)ep_rp->ep_psep_cookie);
6760
6761 /*
6762 * transition ep_state to DISCONNECTED
6763 */
6764 new_state = DAPLKA_EP_STATE_DISCONNECTED;
6765 daplka_ep_set_state(ep_rp, old_state, new_state);
6766
6767 /*
6768 * enqueue event onto the conn_evd owned by ep_rp
6769 */
6770 daplka_evd_wakeup(ep_rp->ep_conn_evd,
6771 &ep_rp->ep_conn_evd->evd_conn_events, disc_ev);
6772
6773 return (IBT_CM_ACCEPT);
6774 }
6775
6776 /*
6777 * processes the CONN_EST event
6778 */
6779 /* ARGSUSED */
6780 static ibt_cm_status_t
6781 daplka_cm_service_conn_est(daplka_sp_resource_t *sp_rp, ibt_cm_event_t *event,
6782 ibt_cm_return_args_t *ret_args, void *priv_data, ibt_priv_data_len_t len)
6783 {
6784 daplka_ep_resource_t *ep_rp;
6785 daplka_evd_event_t *conn_ev;
6786 void *pr_data = event->cm_priv_data;
6787 ibt_priv_data_len_t pr_len = event->cm_priv_data_len;
6788 uint32_t old_state, new_state;
6789
6790 ep_rp = (daplka_ep_resource_t *)
6791 ibt_get_chan_private(event->cm_channel);
6792 if (ep_rp == NULL) {
6793 DERR("service_conn_est: ep_rp == NULL\n");
6794 return (IBT_CM_ACCEPT);
6795 }
6796
6797 /*
6798 * verify that ep_state is ACCEPTING. if it is not in this
6799 * state, return without generating an event.
6800 */
6801 new_state = old_state = daplka_ep_get_state(ep_rp);
6802 if (old_state != DAPLKA_EP_STATE_ACCEPTING) {
6803 /*
6804 * we can get here if the connection is being aborted
6805 */
6806 DERR("service_conn_est: conn aborted, state = %d\n",
6807 old_state);
6808 daplka_ep_set_state(ep_rp, old_state, new_state);
6809 return (IBT_CM_ACCEPT);
6810 }
6811
6812 /*
6813 * create a DAPL_IB_CME_CONNECTED event
6814 */
6815 conn_ev = kmem_zalloc(sizeof (daplka_evd_event_t), KM_NOSLEEP);
6816 if (conn_ev == NULL) {
6817 DERR("service_conn_est: conn_ev alloc failed\n");
6818 daplka_ep_set_state(ep_rp, old_state, new_state);
6819 return (IBT_CM_ACCEPT);
6820 }
6821
6822 conn_ev->ee_cmev.ec_cm_ev_type = DAPL_IB_CME_CONNECTED;
6823 conn_ev->ee_cmev.ec_cm_cookie = sp_rp->sp_cookie;
6824 conn_ev->ee_cmev.ec_cm_is_passive = B_TRUE;
6825 conn_ev->ee_cmev.ec_cm_psep_cookie = ep_rp->ep_psep_cookie;
6826
6827 /*
6828 * copy private data into event
6829 */
6830 if (pr_len > 0) {
6831 conn_ev->ee_cmev.ec_cm_ev_priv_data =
6832 kmem_zalloc(pr_len, KM_NOSLEEP);
6833 if (conn_ev->ee_cmev.ec_cm_ev_priv_data == NULL) {
6834 DERR("service_conn_est: pr_data alloc failed\n");
6835 daplka_ep_set_state(ep_rp, old_state, new_state);
6836 kmem_free(conn_ev, sizeof (daplka_evd_event_t));
6837 return (IBT_CM_ACCEPT);
6838 }
6839 bcopy(pr_data, conn_ev->ee_cmev.ec_cm_ev_priv_data, pr_len);
6840 }
6841 conn_ev->ee_cmev.ec_cm_ev_priv_data_len = pr_len;
6842
6843 D2("service_conn_est: enqueue event(%p) evdp(%p)\n",
6844 conn_ev, ep_rp->ep_conn_evd);
6845
6846 /*
6847 * transition ep_state to CONNECTED
6848 */
6849 new_state = DAPLKA_EP_STATE_CONNECTED;
6850 daplka_ep_set_state(ep_rp, old_state, new_state);
6851
6852 /*
6853 * enqueue event onto the conn_evd owned by ep_rp
6854 */
6855 daplka_evd_wakeup(ep_rp->ep_conn_evd,
6856 &ep_rp->ep_conn_evd->evd_conn_events, conn_ev);
6857
6858 return (IBT_CM_ACCEPT);
6859 }
6860
6861 /*
6862 * processes the FAILURE event
6863 */
6864 /* ARGSUSED */
6865 static ibt_cm_status_t
6866 daplka_cm_service_event_failure(daplka_sp_resource_t *sp_rp,
6867 ibt_cm_event_t *event, ibt_cm_return_args_t *ret_args, void *priv_data,
6868 ibt_priv_data_len_t len)
6869 {
6870 daplka_evd_event_t *disc_ev;
6871 daplka_ep_resource_t *ep_rp;
6872 uint32_t old_state, new_state;
6873 ibt_rc_chan_query_attr_t chan_attrs;
6874 ibt_status_t status;
6875
6876 /*
6877 * check that we still have a valid cm_channel before continuing
6878 */
6879 if (event->cm_channel == NULL) {
6880 DERR("serice_event_failure: event->cm_channel == NULL\n");
6881 return (IBT_CM_ACCEPT);
6882 }
6883 ep_rp = (daplka_ep_resource_t *)
6884 ibt_get_chan_private(event->cm_channel);
6885 if (ep_rp == NULL) {
6886 DERR("service_event_failure: ep_rp == NULL\n");
6887 return (IBT_CM_ACCEPT);
6888 }
6889
6890 /*
6891 * verify that ep_state is ACCEPTING or DISCONNECTING. if it
6892 * is not in either state, return without generating an event.
6893 */
6894 new_state = old_state = daplka_ep_get_state(ep_rp);
6895 if (old_state != DAPLKA_EP_STATE_ACCEPTING &&
6896 old_state != DAPLKA_EP_STATE_DISCONNECTING) {
6897 /*
6898 * we can get here if the connection is being aborted
6899 */
6900 DERR("service_event_failure: conn aborted, state = %d, "
6901 "cf_code = %d, cf_msg = %d, cf_reason = %d\n", old_state,
6902 (int)event->cm_event.failed.cf_code,
6903 (int)event->cm_event.failed.cf_msg,
6904 (int)event->cm_event.failed.cf_reason);
6905
6906 daplka_ep_set_state(ep_rp, old_state, new_state);
6907 return (IBT_CM_ACCEPT);
6908 }
6909
6910 bzero(&chan_attrs, sizeof (ibt_rc_chan_query_attr_t));
6911 status = ibt_query_rc_channel(ep_rp->ep_chan_hdl, &chan_attrs);
6912
6913 if ((status == IBT_SUCCESS) &&
6914 (chan_attrs.rc_state != IBT_STATE_ERROR)) {
6915 DERR("service_event_failure: conn abort qpn %d state %d\n",
6916 chan_attrs.rc_qpn, chan_attrs.rc_state);
6917
6918 /* explicit transition the QP to ERROR state */
6919 status = ibt_flush_channel(ep_rp->ep_chan_hdl);
6920 }
6921
6922 /*
6923 * create an event
6924 */
6925 disc_ev = kmem_zalloc(sizeof (daplka_evd_event_t), KM_NOSLEEP);
6926 if (disc_ev == NULL) {
6927 DERR("service_event_failure: cannot alloc disc_ev\n");
6928 daplka_ep_set_state(ep_rp, old_state, new_state);
6929 return (IBT_CM_ACCEPT);
6930 }
6931
6932 /*
6933 * fill in the appropriate event type
6934 */
6935 if (event->cm_event.failed.cf_code == IBT_CM_FAILURE_TIMEOUT) {
6936 disc_ev->ee_cmev.ec_cm_ev_type = DAPL_IB_CME_TIMED_OUT;
6937 } else if (event->cm_event.failed.cf_code == IBT_CM_FAILURE_REJ_RCV) {
6938 switch (event->cm_event.failed.cf_reason) {
6939 case IBT_CM_INVALID_CID:
6940 disc_ev->ee_cmev.ec_cm_ev_type =
6941 DAPL_IB_CME_DESTINATION_REJECT;
6942 break;
6943 default:
6944 disc_ev->ee_cmev.ec_cm_ev_type =
6945 DAPL_IB_CME_LOCAL_FAILURE;
6946 break;
6947 }
6948 } else {
6949 disc_ev->ee_cmev.ec_cm_ev_type = DAPL_IB_CME_LOCAL_FAILURE;
6950 }
6951 disc_ev->ee_cmev.ec_cm_cookie = sp_rp->sp_cookie;
6952 disc_ev->ee_cmev.ec_cm_is_passive = B_TRUE;
6953 disc_ev->ee_cmev.ec_cm_psep_cookie = ep_rp->ep_psep_cookie;
6954 disc_ev->ee_cmev.ec_cm_ev_priv_data_len = 0;
6955 disc_ev->ee_cmev.ec_cm_ev_priv_data = NULL;
6956
6957 D2("service_event_failure: enqueue event(%p) evdp(%p) cf_code(%d) "
6958 "cf_msg(%d) cf_reason(%d) psep(0x%llx)\n", disc_ev,
6959 ep_rp->ep_conn_evd, (int)event->cm_event.failed.cf_code,
6960 (int)event->cm_event.failed.cf_msg,
6961 (int)event->cm_event.failed.cf_reason,
6962 (longlong_t)ep_rp->ep_psep_cookie);
6963
6964 /*
6965 * transition ep_state to DISCONNECTED
6966 */
6967 new_state = DAPLKA_EP_STATE_DISCONNECTED;
6968 daplka_ep_set_state(ep_rp, old_state, new_state);
6969
6970 /*
6971 * enqueue event onto the conn_evd owned by ep_rp
6972 */
6973 daplka_evd_wakeup(ep_rp->ep_conn_evd,
6974 &ep_rp->ep_conn_evd->evd_conn_events, disc_ev);
6975
6976 return (IBT_CM_ACCEPT);
6977 }
6978
6979 /*
6980 * this is the passive side CM handler. it gets registered
6981 * when an SP resource is created in daplka_service_register.
6982 */
6983 static ibt_cm_status_t
6984 daplka_cm_service_handler(void *cm_private, ibt_cm_event_t *event,
6985 ibt_cm_return_args_t *ret_args, void *priv_data, ibt_priv_data_len_t len)
6986 {
6987 daplka_sp_resource_t *sp_rp = (daplka_sp_resource_t *)cm_private;
6988
6989 if (sp_rp == NULL) {
6990 DERR("service_handler: sp_rp == NULL\n");
6991 return (IBT_CM_NO_RESOURCE);
6992 }
6993 /*
6994 * default is not to return priv data
6995 */
6996 if (ret_args != NULL) {
6997 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*ret_args))
6998 ret_args->cm_ret_len = 0;
6999 }
7000
7001 switch (event->cm_type) {
7002 case IBT_CM_EVENT_REQ_RCV:
7003 D2("service_handler: IBT_CM_EVENT_REQ_RCV\n");
7004 return (daplka_cm_service_req(sp_rp, event, ret_args,
7005 event->cm_priv_data, event->cm_priv_data_len));
7006
7007 case IBT_CM_EVENT_REP_RCV:
7008 /* passive side should not receive this event */
7009 D2("service_handler: IBT_CM_EVENT_REP_RCV\n");
7010 return (IBT_CM_DEFAULT);
7011
7012 case IBT_CM_EVENT_CONN_CLOSED:
7013 D2("service_handler: IBT_CM_EVENT_CONN_CLOSED %d\n",
7014 event->cm_event.closed);
7015 return (daplka_cm_service_conn_closed(sp_rp, event, ret_args,
7016 priv_data, len));
7017
7018 case IBT_CM_EVENT_MRA_RCV:
7019 /* passive side does default processing MRA event */
7020 D2("service_handler: IBT_CM_EVENT_MRA_RCV\n");
7021 return (IBT_CM_DEFAULT);
7022
7023 case IBT_CM_EVENT_CONN_EST:
7024 D2("service_handler: IBT_CM_EVENT_CONN_EST\n");
7025 return (daplka_cm_service_conn_est(sp_rp, event, ret_args,
7026 priv_data, len));
7027
7028 case IBT_CM_EVENT_FAILURE:
7029 D2("service_handler: IBT_CM_EVENT_FAILURE\n");
7030 return (daplka_cm_service_event_failure(sp_rp, event, ret_args,
7031 priv_data, len));
7032 case IBT_CM_EVENT_LAP_RCV:
7033 /* active side had initiated a path migration operation */
7034 D2("service_handler: IBT_CM_EVENT_LAP_RCV\n");
7035 return (IBT_CM_ACCEPT);
7036 default:
7037 DERR("service_handler: invalid event %d\n", event->cm_type);
7038 break;
7039 }
7040 return (IBT_CM_DEFAULT);
7041 }
7042
7043 /*
7044 * Active side CM handlers
7045 */
7046
7047 /*
7048 * Processes the REP_RCV event. When the passive side accepts the
7049 * connection, this handler is called. We make a copy of the private
7050 * data into the ep so that it can be passed back to userland in when
7051 * the CONN_EST event occurs.
7052 */
7053 /* ARGSUSED */
7054 static ibt_cm_status_t
7055 daplka_cm_rc_rep_rcv(daplka_ep_resource_t *ep_rp, ibt_cm_event_t *event,
7056 ibt_cm_return_args_t *ret_args, void *priv_data, ibt_priv_data_len_t len)
7057 {
7058 void *pr_data = event->cm_priv_data;
7059 ibt_priv_data_len_t pr_len = event->cm_priv_data_len;
7060 uint32_t old_state, new_state;
7061
7062 D2("rc_rep_rcv: pr_data(0x%p), pr_len(%d)\n", pr_data,
7063 (int)pr_len);
7064
7065 ASSERT(ep_rp != NULL);
7066 new_state = old_state = daplka_ep_get_state(ep_rp);
7067 if (old_state != DAPLKA_EP_STATE_CONNECTING) {
7068 /*
7069 * we can get here if the connection is being aborted
7070 */
7071 DERR("rc_rep_rcv: conn aborted, state = %d\n", old_state);
7072 daplka_ep_set_state(ep_rp, old_state, new_state);
7073 return (IBT_CM_NO_CHANNEL);
7074 }
7075
7076 /*
7077 * we do not cancel the timer here because the connection
7078 * handshake is still in progress.
7079 */
7080
7081 /*
7082 * save the private data. it will be passed up when
7083 * the connection is established.
7084 */
7085 if (pr_len > 0) {
7086 ep_rp->ep_priv_len = pr_len;
7087 bcopy(pr_data, ep_rp->ep_priv_data, (size_t)pr_len);
7088 }
7089
7090 /*
7091 * we do not actually transition to a different state.
7092 * the state will change when we get a conn_est, failure,
7093 * closed, or timeout event.
7094 */
7095 daplka_ep_set_state(ep_rp, old_state, new_state);
7096 return (IBT_CM_ACCEPT);
7097 }
7098
7099 /*
7100 * Processes the CONN_CLOSED event. This gets called when either
7101 * the active or passive side closes the rc channel.
7102 */
7103 /* ARGSUSED */
7104 static ibt_cm_status_t
7105 daplka_cm_rc_conn_closed(daplka_ep_resource_t *ep_rp, ibt_cm_event_t *event,
7106 ibt_cm_return_args_t *ret_args, void *priv_data, ibt_priv_data_len_t len)
7107 {
7108 daplka_evd_event_t *disc_ev;
7109 uint32_t old_state, new_state;
7110
7111 ASSERT(ep_rp != NULL);
7112 old_state = new_state = daplka_ep_get_state(ep_rp);
7113 if (old_state != DAPLKA_EP_STATE_CONNECTED &&
7114 old_state != DAPLKA_EP_STATE_DISCONNECTING) {
7115 /*
7116 * we can get here if the connection is being aborted
7117 */
7118 D2("rc_conn_closed: conn aborted, state = %d, "
7119 "closed = %d\n", old_state, (int)event->cm_event.closed);
7120 daplka_ep_set_state(ep_rp, old_state, new_state);
7121 return (IBT_CM_ACCEPT);
7122 }
7123
7124 /*
7125 * it's ok for the timer to fire at this point. the
7126 * taskq thread that processes the timer will just wait
7127 * until we are done with our state transition.
7128 */
7129 if (daplka_cancel_timer(ep_rp) != 0) {
7130 /*
7131 * daplka_cancel_timer returns -1 if the timer is
7132 * being processed and 0 for all other cases.
7133 * we need to reset ep_state to allow timer processing
7134 * to continue.
7135 */
7136 DERR("rc_conn_closed: timer is being processed\n");
7137 daplka_ep_set_state(ep_rp, old_state, new_state);
7138 return (IBT_CM_ACCEPT);
7139 }
7140
7141 /*
7142 * create a DAPL_IB_CME_DISCONNECTED event
7143 */
7144 disc_ev = kmem_zalloc(sizeof (daplka_evd_event_t), KM_NOSLEEP);
7145 if (disc_ev == NULL) {
7146 DERR("rc_conn_closed: could not alloc ev\n");
7147 daplka_ep_set_state(ep_rp, old_state, new_state);
7148 return (IBT_CM_ACCEPT);
7149 }
7150
7151 disc_ev->ee_cmev.ec_cm_ev_type = DAPL_IB_CME_DISCONNECTED;
7152 disc_ev->ee_cmev.ec_cm_cookie = ep_rp->ep_cookie;
7153 disc_ev->ee_cmev.ec_cm_is_passive = B_FALSE;
7154 disc_ev->ee_cmev.ec_cm_psep_cookie = 0;
7155 disc_ev->ee_cmev.ec_cm_ev_priv_data = NULL;
7156 disc_ev->ee_cmev.ec_cm_ev_priv_data_len = 0;
7157
7158 D2("rc_conn_closed: enqueue event(%p) evdp(%p) closed(%d)\n",
7159 disc_ev, ep_rp->ep_conn_evd, (int)event->cm_event.closed);
7160
7161 /*
7162 * transition ep_state to DISCONNECTED
7163 */
7164 new_state = DAPLKA_EP_STATE_DISCONNECTED;
7165 daplka_ep_set_state(ep_rp, old_state, new_state);
7166
7167 /*
7168 * enqueue event onto the conn_evd owned by ep_rp
7169 */
7170 daplka_evd_wakeup(ep_rp->ep_conn_evd,
7171 &ep_rp->ep_conn_evd->evd_conn_events, disc_ev);
7172
7173 return (IBT_CM_ACCEPT);
7174 }
7175
7176 /*
7177 * processes the CONN_EST event
7178 */
7179 /* ARGSUSED */
7180 static ibt_cm_status_t
7181 daplka_cm_rc_conn_est(daplka_ep_resource_t *ep_rp, ibt_cm_event_t *event,
7182 ibt_cm_return_args_t *ret_args, void *priv_data, ibt_priv_data_len_t len)
7183 {
7184 daplka_evd_event_t *conn_ev;
7185 uint32_t old_state, new_state;
7186
7187 ASSERT(ep_rp != NULL);
7188 old_state = new_state = daplka_ep_get_state(ep_rp);
7189 if (old_state != DAPLKA_EP_STATE_CONNECTING) {
7190 /*
7191 * we can get here if the connection is being aborted
7192 */
7193 DERR("rc_conn_est: conn aborted, state = %d\n", old_state);
7194 daplka_ep_set_state(ep_rp, old_state, new_state);
7195 return (IBT_CM_ACCEPT);
7196 }
7197
7198 /*
7199 * it's ok for the timer to fire at this point. the
7200 * taskq thread that processes the timer will just wait
7201 * until we are done with our state transition.
7202 */
7203 if (daplka_cancel_timer(ep_rp) != 0) {
7204 /*
7205 * daplka_cancel_timer returns -1 if the timer is
7206 * being processed and 0 for all other cases.
7207 * we need to reset ep_state to allow timer processing
7208 * to continue.
7209 */
7210 DERR("rc_conn_est: timer is being processed\n");
7211 daplka_ep_set_state(ep_rp, old_state, new_state);
7212 return (IBT_CM_ACCEPT);
7213 }
7214
7215 /*
7216 * create a DAPL_IB_CME_CONNECTED event
7217 */
7218 conn_ev = kmem_zalloc(sizeof (daplka_evd_event_t), KM_NOSLEEP);
7219 if (conn_ev == NULL) {
7220 DERR("rc_conn_est: could not alloc ev\n");
7221 daplka_ep_set_state(ep_rp, old_state, new_state);
7222 return (IBT_CM_ACCEPT);
7223 }
7224
7225 conn_ev->ee_cmev.ec_cm_ev_type = DAPL_IB_CME_CONNECTED;
7226 conn_ev->ee_cmev.ec_cm_cookie = ep_rp->ep_cookie;
7227 conn_ev->ee_cmev.ec_cm_is_passive = B_FALSE;
7228 conn_ev->ee_cmev.ec_cm_psep_cookie = 0;
7229
7230 /*
7231 * The private data passed back in the connection established
7232 * event is what was recvd in the daplka_cm_rc_rep_rcv handler and
7233 * saved in ep resource structure.
7234 */
7235 if (ep_rp->ep_priv_len > 0) {
7236 conn_ev->ee_cmev.ec_cm_ev_priv_data =
7237 kmem_zalloc(ep_rp->ep_priv_len, KM_NOSLEEP);
7238
7239 if (conn_ev->ee_cmev.ec_cm_ev_priv_data == NULL) {
7240 DERR("rc_conn_est: could not alloc pr_data\n");
7241 kmem_free(conn_ev, sizeof (daplka_evd_event_t));
7242 daplka_ep_set_state(ep_rp, old_state, new_state);
7243 return (IBT_CM_ACCEPT);
7244 }
7245 bcopy(ep_rp->ep_priv_data, conn_ev->ee_cmev.ec_cm_ev_priv_data,
7246 ep_rp->ep_priv_len);
7247 }
7248 conn_ev->ee_cmev.ec_cm_ev_priv_data_len = ep_rp->ep_priv_len;
7249
7250 D2("rc_conn_est: enqueue event(%p) evdp(%p) pr_data(0x%p), "
7251 "pr_len(%d)\n", conn_ev, ep_rp->ep_conn_evd,
7252 conn_ev->ee_cmev.ec_cm_ev_priv_data,
7253 (int)conn_ev->ee_cmev.ec_cm_ev_priv_data_len);
7254
7255 /*
7256 * transition ep_state to CONNECTED
7257 */
7258 new_state = DAPLKA_EP_STATE_CONNECTED;
7259 daplka_ep_set_state(ep_rp, old_state, new_state);
7260
7261 /*
7262 * enqueue event onto the conn_evd owned by ep_rp
7263 */
7264 daplka_evd_wakeup(ep_rp->ep_conn_evd,
7265 &ep_rp->ep_conn_evd->evd_conn_events, conn_ev);
7266
7267 return (IBT_CM_ACCEPT);
7268 }
7269
7270 /*
7271 * processes the FAILURE event
7272 */
7273 /* ARGSUSED */
7274 static ibt_cm_status_t
7275 daplka_cm_rc_event_failure(daplka_ep_resource_t *ep_rp, ibt_cm_event_t *event,
7276 ibt_cm_return_args_t *ret_args, void *priv_data, ibt_priv_data_len_t len)
7277 {
7278 daplka_evd_event_t *disc_ev;
7279 ibt_priv_data_len_t pr_len = event->cm_priv_data_len;
7280 void *pr_data = event->cm_priv_data;
7281 uint32_t old_state, new_state;
7282 ibt_rc_chan_query_attr_t chan_attrs;
7283 ibt_status_t status;
7284
7285 ASSERT(ep_rp != NULL);
7286 old_state = new_state = daplka_ep_get_state(ep_rp);
7287 if (old_state != DAPLKA_EP_STATE_CONNECTING &&
7288 old_state != DAPLKA_EP_STATE_DISCONNECTING) {
7289 /*
7290 * we can get here if the connection is being aborted
7291 */
7292 DERR("rc_event_failure: conn aborted, state = %d, "
7293 "cf_code = %d, cf_msg = %d, cf_reason = %d\n", old_state,
7294 (int)event->cm_event.failed.cf_code,
7295 (int)event->cm_event.failed.cf_msg,
7296 (int)event->cm_event.failed.cf_reason);
7297
7298 daplka_ep_set_state(ep_rp, old_state, new_state);
7299 return (IBT_CM_ACCEPT);
7300 }
7301
7302 /*
7303 * it's ok for the timer to fire at this point. the
7304 * taskq thread that processes the timer will just wait
7305 * until we are done with our state transition.
7306 */
7307 if (daplka_cancel_timer(ep_rp) != 0) {
7308 /*
7309 * daplka_cancel_timer returns -1 if the timer is
7310 * being processed and 0 for all other cases.
7311 * we need to reset ep_state to allow timer processing
7312 * to continue.
7313 */
7314 DERR("rc_event_failure: timer is being processed\n");
7315 daplka_ep_set_state(ep_rp, old_state, new_state);
7316 return (IBT_CM_ACCEPT);
7317 }
7318
7319 bzero(&chan_attrs, sizeof (ibt_rc_chan_query_attr_t));
7320 status = ibt_query_rc_channel(ep_rp->ep_chan_hdl, &chan_attrs);
7321
7322 if ((status == IBT_SUCCESS) &&
7323 (chan_attrs.rc_state != IBT_STATE_ERROR)) {
7324 DERR("rc_event_failure: conn abort qpn %d state %d\n",
7325 chan_attrs.rc_qpn, chan_attrs.rc_state);
7326
7327 /* explicit transition the QP to ERROR state */
7328 status = ibt_flush_channel(ep_rp->ep_chan_hdl);
7329 }
7330
7331 /*
7332 * create an event
7333 */
7334 disc_ev = kmem_zalloc(sizeof (daplka_evd_event_t), KM_NOSLEEP);
7335 if (disc_ev == NULL) {
7336 DERR("rc_event_failure: cannot alloc disc_ev\n");
7337 daplka_ep_set_state(ep_rp, old_state, new_state);
7338 return (IBT_CM_ACCEPT);
7339 }
7340
7341 /*
7342 * copy private data into event
7343 */
7344 if (pr_len > 0) {
7345 disc_ev->ee_cmev.ec_cm_ev_priv_data =
7346 kmem_zalloc(pr_len, KM_NOSLEEP);
7347
7348 if (disc_ev->ee_cmev.ec_cm_ev_priv_data == NULL) {
7349 DERR("rc_event_failure: cannot alloc pr data\n");
7350 kmem_free(disc_ev, sizeof (daplka_evd_event_t));
7351 daplka_ep_set_state(ep_rp, old_state, new_state);
7352 return (IBT_CM_ACCEPT);
7353 }
7354 bcopy(pr_data, disc_ev->ee_cmev.ec_cm_ev_priv_data, pr_len);
7355 }
7356 disc_ev->ee_cmev.ec_cm_ev_priv_data_len = pr_len;
7357
7358 /*
7359 * fill in the appropriate event type
7360 */
7361 if (event->cm_event.failed.cf_code == IBT_CM_FAILURE_REJ_RCV) {
7362 switch (event->cm_event.failed.cf_reason) {
7363 case IBT_CM_CONSUMER:
7364 disc_ev->ee_cmev.ec_cm_ev_type =
7365 DAPL_IB_CME_DESTINATION_REJECT_PRIVATE_DATA;
7366 break;
7367 case IBT_CM_NO_CHAN:
7368 case IBT_CM_NO_RESC:
7369 disc_ev->ee_cmev.ec_cm_ev_type =
7370 DAPL_IB_CME_DESTINATION_REJECT;
7371 break;
7372 default:
7373 disc_ev->ee_cmev.ec_cm_ev_type =
7374 DAPL_IB_CME_DESTINATION_REJECT;
7375 break;
7376 }
7377 } else if (event->cm_event.failed.cf_code == IBT_CM_FAILURE_TIMEOUT) {
7378 disc_ev->ee_cmev.ec_cm_ev_type = DAPL_IB_CME_TIMED_OUT;
7379 } else {
7380 /* others we'll mark as local failure */
7381 disc_ev->ee_cmev.ec_cm_ev_type = DAPL_IB_CME_LOCAL_FAILURE;
7382 }
7383 disc_ev->ee_cmev.ec_cm_cookie = ep_rp->ep_cookie;
7384 disc_ev->ee_cmev.ec_cm_is_passive = B_FALSE;
7385 disc_ev->ee_cmev.ec_cm_psep_cookie = 0;
7386
7387 D2("rc_event_failure: enqueue event(%p) evdp(%p) cf_code(%d) "
7388 "cf_msg(%d) cf_reason(%d)\n", disc_ev, ep_rp->ep_conn_evd,
7389 (int)event->cm_event.failed.cf_code,
7390 (int)event->cm_event.failed.cf_msg,
7391 (int)event->cm_event.failed.cf_reason);
7392
7393 /*
7394 * transition ep_state to DISCONNECTED
7395 */
7396 new_state = DAPLKA_EP_STATE_DISCONNECTED;
7397 daplka_ep_set_state(ep_rp, old_state, new_state);
7398
7399 /*
7400 * enqueue event onto the conn_evd owned by ep_rp
7401 */
7402 daplka_evd_wakeup(ep_rp->ep_conn_evd,
7403 &ep_rp->ep_conn_evd->evd_conn_events, disc_ev);
7404
7405 return (IBT_CM_ACCEPT);
7406 }
7407
7408 /*
7409 * This is the active side CM handler. It gets registered when
7410 * ibt_open_rc_channel is called.
7411 */
7412 static ibt_cm_status_t
7413 daplka_cm_rc_handler(void *cm_private, ibt_cm_event_t *event,
7414 ibt_cm_return_args_t *ret_args, void *priv_data, ibt_priv_data_len_t len)
7415 {
7416 daplka_ep_resource_t *ep_rp = (daplka_ep_resource_t *)cm_private;
7417
7418 if (ep_rp == NULL) {
7419 DERR("rc_handler: ep_rp == NULL\n");
7420 return (IBT_CM_NO_CHANNEL);
7421 }
7422 /*
7423 * default is not to return priv data
7424 */
7425 if (ret_args != NULL) {
7426 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*ret_args))
7427 ret_args->cm_ret_len = 0;
7428 }
7429
7430 switch (event->cm_type) {
7431 case IBT_CM_EVENT_REQ_RCV:
7432 /* active side should not receive this event */
7433 D2("rc_handler: IBT_CM_EVENT_REQ_RCV\n");
7434 break;
7435
7436 case IBT_CM_EVENT_REP_RCV:
7437 /* connection accepted by passive side */
7438 D2("rc_handler: IBT_CM_EVENT_REP_RCV\n");
7439 return (daplka_cm_rc_rep_rcv(ep_rp, event, ret_args,
7440 priv_data, len));
7441
7442 case IBT_CM_EVENT_CONN_CLOSED:
7443 D2("rc_handler: IBT_CM_EVENT_CONN_CLOSED %d\n",
7444 event->cm_event.closed);
7445 return (daplka_cm_rc_conn_closed(ep_rp, event, ret_args,
7446 priv_data, len));
7447
7448 case IBT_CM_EVENT_MRA_RCV:
7449 /* passive side does default processing MRA event */
7450 D2("rc_handler: IBT_CM_EVENT_MRA_RCV\n");
7451 return (IBT_CM_DEFAULT);
7452
7453 case IBT_CM_EVENT_CONN_EST:
7454 D2("rc_handler: IBT_CM_EVENT_CONN_EST\n");
7455 return (daplka_cm_rc_conn_est(ep_rp, event, ret_args,
7456 priv_data, len));
7457
7458 case IBT_CM_EVENT_FAILURE:
7459 D2("rc_handler: IBT_CM_EVENT_FAILURE\n");
7460 return (daplka_cm_rc_event_failure(ep_rp, event, ret_args,
7461 priv_data, len));
7462
7463 default:
7464 D2("rc_handler: invalid event %d\n", event->cm_type);
7465 break;
7466 }
7467 return (IBT_CM_DEFAULT);
7468 }
7469
7470 /*
7471 * creates an IA resource and inserts it into the global resource table.
7472 */
7473 /* ARGSUSED */
7474 static int
7475 daplka_ia_create(minor_t rnum, intptr_t arg, int mode,
7476 cred_t *cred, int *rvalp)
7477 {
7478 daplka_ia_resource_t *ia_rp, *tmp_rp;
7479 boolean_t inserted = B_FALSE;
7480 dapl_ia_create_t args;
7481 ibt_hca_hdl_t hca_hdl;
7482 ibt_status_t status;
7483 ib_gid_t sgid;
7484 int retval;
7485 ibt_hca_portinfo_t *pinfop;
7486 uint_t pinfon;
7487 uint_t size;
7488 ibt_ar_t ar_s;
7489 daplka_hca_t *hca;
7490
7491 retval = ddi_copyin((void *)arg, &args, sizeof (dapl_ia_create_t),
7492 mode);
7493 if (retval != 0) {
7494 DERR("ia_create: copyin error %d\n", retval);
7495 return (EFAULT);
7496 }
7497 if (args.ia_version != DAPL_IF_VERSION) {
7498 DERR("ia_create: invalid version %d, expected version %d\n",
7499 args.ia_version, DAPL_IF_VERSION);
7500 return (EINVAL);
7501 }
7502
7503 /*
7504 * find the hca with the matching guid
7505 */
7506 mutex_enter(&daplka_dev->daplka_mutex);
7507 for (hca = daplka_dev->daplka_hca_list_head; hca != NULL;
7508 hca = hca->hca_next) {
7509 if (hca->hca_guid == args.ia_guid) {
7510 DAPLKA_HOLD_HCA_WITHOUT_LOCK(hca);
7511 break;
7512 }
7513 }
7514 mutex_exit(&daplka_dev->daplka_mutex);
7515
7516 if (hca == NULL) {
7517 DERR("ia_create: guid 0x%016llx not found\n",
7518 (longlong_t)args.ia_guid);
7519 return (EINVAL);
7520 }
7521
7522 /*
7523 * check whether port number is valid and whether it is up
7524 */
7525 if (args.ia_port > hca->hca_nports) {
7526 DERR("ia_create: invalid hca_port %d\n", args.ia_port);
7527 DAPLKA_RELE_HCA(daplka_dev, hca);
7528 return (EINVAL);
7529 }
7530 hca_hdl = hca->hca_hdl;
7531 if (hca_hdl == NULL) {
7532 DERR("ia_create: hca_hdl == NULL\n");
7533 DAPLKA_RELE_HCA(daplka_dev, hca);
7534 return (EINVAL);
7535 }
7536 status = ibt_query_hca_ports(hca_hdl, (uint8_t)args.ia_port,
7537 &pinfop, &pinfon, &size);
7538 if (status != IBT_SUCCESS) {
7539 DERR("ia_create: ibt_query_hca_ports returned %d\n", status);
7540 *rvalp = (int)status;
7541 DAPLKA_RELE_HCA(daplka_dev, hca);
7542 return (0);
7543 }
7544 sgid = pinfop->p_sgid_tbl[0];
7545 ibt_free_portinfo(pinfop, size);
7546
7547 ia_rp = kmem_zalloc(sizeof (daplka_ia_resource_t), daplka_km_flags);
7548 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*ia_rp))
7549 DAPLKA_RS_INIT(ia_rp, DAPL_TYPE_IA, rnum, daplka_ia_destroy);
7550
7551 mutex_init(&ia_rp->ia_lock, NULL, MUTEX_DRIVER, NULL);
7552 cv_init(&ia_rp->ia_cv, NULL, CV_DRIVER, NULL);
7553 ia_rp->ia_hca_hdl = hca_hdl;
7554 ia_rp->ia_hca_sgid = sgid;
7555 ia_rp->ia_hca = hca;
7556 ia_rp->ia_port_num = args.ia_port;
7557 ia_rp->ia_port_pkey = args.ia_pkey;
7558 ia_rp->ia_pid = ddi_get_pid();
7559 ia_rp->ia_async_evd_hkeys = NULL;
7560 ia_rp->ia_ar_registered = B_FALSE;
7561 bcopy(args.ia_sadata, ia_rp->ia_sadata, DAPL_ATS_NBYTES);
7562
7563 /* register Address Record */
7564 ar_s.ar_gid = ia_rp->ia_hca_sgid;
7565 ar_s.ar_pkey = ia_rp->ia_port_pkey;
7566 bcopy(ia_rp->ia_sadata, ar_s.ar_data, DAPL_ATS_NBYTES);
7567 #define UC(b) ar_s.ar_data[(b)]
7568 D3("daplka_ia_create: SA[8] %d.%d.%d.%d\n",
7569 UC(8), UC(9), UC(10), UC(11));
7570 D3("daplka_ia_create: SA[12] %d.%d.%d.%d\n",
7571 UC(12), UC(13), UC(14), UC(15));
7572 retval = ibt_register_ar(daplka_dev->daplka_clnt_hdl, &ar_s);
7573 if (retval != IBT_SUCCESS) {
7574 DERR("ia_create: failed to register Address Record.\n");
7575 retval = EINVAL;
7576 goto cleanup;
7577 }
7578 ia_rp->ia_ar_registered = B_TRUE;
7579
7580 /*
7581 * create hash tables for all object types
7582 */
7583 retval = daplka_hash_create(&ia_rp->ia_ep_htbl, DAPLKA_EP_HTBL_SZ,
7584 daplka_hash_ep_free, daplka_hash_generic_lookup);
7585 if (retval != 0) {
7586 DERR("ia_create: cannot create ep hash table\n");
7587 goto cleanup;
7588 }
7589 retval = daplka_hash_create(&ia_rp->ia_mr_htbl, DAPLKA_MR_HTBL_SZ,
7590 daplka_hash_mr_free, daplka_hash_generic_lookup);
7591 if (retval != 0) {
7592 DERR("ia_create: cannot create mr hash table\n");
7593 goto cleanup;
7594 }
7595 retval = daplka_hash_create(&ia_rp->ia_mw_htbl, DAPLKA_MW_HTBL_SZ,
7596 daplka_hash_mw_free, daplka_hash_generic_lookup);
7597 if (retval != 0) {
7598 DERR("ia_create: cannot create mw hash table\n");
7599 goto cleanup;
7600 }
7601 retval = daplka_hash_create(&ia_rp->ia_pd_htbl, DAPLKA_PD_HTBL_SZ,
7602 daplka_hash_pd_free, daplka_hash_generic_lookup);
7603 if (retval != 0) {
7604 DERR("ia_create: cannot create pd hash table\n");
7605 goto cleanup;
7606 }
7607 retval = daplka_hash_create(&ia_rp->ia_evd_htbl, DAPLKA_EVD_HTBL_SZ,
7608 daplka_hash_evd_free, daplka_hash_generic_lookup);
7609 if (retval != 0) {
7610 DERR("ia_create: cannot create evd hash table\n");
7611 goto cleanup;
7612 }
7613 retval = daplka_hash_create(&ia_rp->ia_cno_htbl, DAPLKA_CNO_HTBL_SZ,
7614 daplka_hash_cno_free, daplka_hash_generic_lookup);
7615 if (retval != 0) {
7616 DERR("ia_create: cannot create cno hash table\n");
7617 goto cleanup;
7618 }
7619 retval = daplka_hash_create(&ia_rp->ia_sp_htbl, DAPLKA_SP_HTBL_SZ,
7620 daplka_hash_sp_free, daplka_hash_generic_lookup);
7621 if (retval != 0) {
7622 DERR("ia_create: cannot create sp hash table\n");
7623 goto cleanup;
7624 }
7625 retval = daplka_hash_create(&ia_rp->ia_srq_htbl, DAPLKA_SRQ_HTBL_SZ,
7626 daplka_hash_srq_free, daplka_hash_generic_lookup);
7627 if (retval != 0) {
7628 DERR("ia_create: cannot create srq hash table\n");
7629 goto cleanup;
7630 }
7631 /*
7632 * insert ia_rp into the global resource table
7633 */
7634 retval = daplka_resource_insert(rnum, (daplka_resource_t *)ia_rp);
7635 if (retval != 0) {
7636 DERR("ia_create: cannot insert resource\n");
7637 goto cleanup;
7638 }
7639 inserted = B_TRUE;
7640 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*ia_rp))
7641
7642 args.ia_resnum = rnum;
7643 retval = copyout(&args, (void *)arg, sizeof (dapl_ia_create_t));
7644 if (retval != 0) {
7645 DERR("ia_create: copyout error %d\n", retval);
7646 retval = EFAULT;
7647 goto cleanup;
7648 }
7649 return (0);
7650
7651 cleanup:;
7652 if (inserted) {
7653 tmp_rp = (daplka_ia_resource_t *)daplka_resource_remove(rnum);
7654 if (tmp_rp != ia_rp) {
7655 /*
7656 * we can return here because another thread must
7657 * have freed up the resource
7658 */
7659 DERR("ia_create: cannot remove resource\n");
7660 return (retval);
7661 }
7662 }
7663 DAPLKA_RS_UNREF(ia_rp);
7664 return (retval);
7665 }
7666
7667 /*
7668 * destroys an IA resource
7669 */
7670 static int
7671 daplka_ia_destroy(daplka_resource_t *gen_rp)
7672 {
7673 daplka_ia_resource_t *ia_rp = (daplka_ia_resource_t *)gen_rp;
7674 daplka_async_evd_hkey_t *hkp;
7675 int cnt;
7676 ibt_ar_t ar_s;
7677
7678 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*ia_rp))
7679 D3("ia_destroy: entering, ia_rp 0x%p\n", ia_rp);
7680
7681 /* deregister Address Record */
7682 if (ia_rp->ia_ar_registered) {
7683 ar_s.ar_gid = ia_rp->ia_hca_sgid;
7684 ar_s.ar_pkey = ia_rp->ia_port_pkey;
7685 bcopy(ia_rp->ia_sadata, ar_s.ar_data, DAPL_ATS_NBYTES);
7686 (void) ibt_deregister_ar(daplka_dev->daplka_clnt_hdl, &ar_s);
7687 ia_rp->ia_ar_registered = B_FALSE;
7688 }
7689
7690 /*
7691 * destroy hash tables. make sure resources are
7692 * destroyed in the correct order.
7693 */
7694 daplka_hash_destroy(&ia_rp->ia_mw_htbl);
7695 daplka_hash_destroy(&ia_rp->ia_mr_htbl);
7696 daplka_hash_destroy(&ia_rp->ia_ep_htbl);
7697 daplka_hash_destroy(&ia_rp->ia_srq_htbl);
7698 daplka_hash_destroy(&ia_rp->ia_evd_htbl);
7699 daplka_hash_destroy(&ia_rp->ia_cno_htbl);
7700 daplka_hash_destroy(&ia_rp->ia_pd_htbl);
7701 daplka_hash_destroy(&ia_rp->ia_sp_htbl);
7702
7703 /*
7704 * free the async evd list
7705 */
7706 cnt = 0;
7707 hkp = ia_rp->ia_async_evd_hkeys;
7708 while (hkp != NULL) {
7709 daplka_async_evd_hkey_t *free_hkp;
7710
7711 cnt++;
7712 free_hkp = hkp;
7713 hkp = hkp->aeh_next;
7714 kmem_free(free_hkp, sizeof (*free_hkp));
7715 }
7716 if (cnt > 0) {
7717 D3("ia_destroy: freed %d hkeys\n", cnt);
7718 }
7719 mutex_destroy(&ia_rp->ia_lock);
7720 cv_destroy(&ia_rp->ia_cv);
7721 ia_rp->ia_hca_hdl = NULL;
7722
7723 DAPLKA_RS_FINI(ia_rp);
7724
7725 if (ia_rp->ia_hca)
7726 DAPLKA_RELE_HCA(daplka_dev, ia_rp->ia_hca);
7727
7728 kmem_free(ia_rp, sizeof (daplka_ia_resource_t));
7729 D3("ia_destroy: exiting, ia_rp 0x%p\n", ia_rp);
7730 return (0);
7731 }
7732
7733 static void
7734 daplka_async_event_create(ibt_async_code_t code, ibt_async_event_t *event,
7735 uint64_t cookie, daplka_ia_resource_t *ia_rp)
7736 {
7737 daplka_evd_event_t *evp;
7738 daplka_evd_resource_t *async_evd;
7739 daplka_async_evd_hkey_t *curr;
7740
7741 mutex_enter(&ia_rp->ia_lock);
7742 curr = ia_rp->ia_async_evd_hkeys;
7743 while (curr != NULL) {
7744 /*
7745 * Note: this allocation does not zero out the buffer
7746 * since we init all the fields.
7747 */
7748 evp = kmem_alloc(sizeof (daplka_evd_event_t), KM_NOSLEEP);
7749 if (evp == NULL) {
7750 DERR("async_event_enqueue: event alloc failed"
7751 "!found\n", ia_rp, curr->aeh_evd_hkey);
7752 curr = curr->aeh_next;
7753 continue;
7754 }
7755 evp->ee_next = NULL;
7756 evp->ee_aev.ibae_type = code;
7757 evp->ee_aev.ibae_hca_guid = event->ev_hca_guid;
7758 evp->ee_aev.ibae_cookie = cookie;
7759 evp->ee_aev.ibae_port = event->ev_port;
7760
7761 /*
7762 * Lookup the async evd corresponding to this ia and enqueue
7763 * evp and wakeup any waiter.
7764 */
7765 async_evd = (daplka_evd_resource_t *)
7766 daplka_hash_lookup(&ia_rp->ia_evd_htbl, curr->aeh_evd_hkey);
7767 if (async_evd == NULL) { /* async evd is being freed */
7768 DERR("async_event_enqueue: ia_rp(%p) asycn_evd %llx "
7769 "!found\n", ia_rp, (longlong_t)curr->aeh_evd_hkey);
7770 kmem_free(evp, sizeof (daplka_evd_event_t));
7771 curr = curr->aeh_next;
7772 continue;
7773 }
7774 daplka_evd_wakeup(async_evd, &async_evd->evd_async_events, evp);
7775
7776 /* decrement refcnt on async_evd */
7777 DAPLKA_RS_UNREF(async_evd);
7778 curr = curr->aeh_next;
7779 }
7780 mutex_exit(&ia_rp->ia_lock);
7781 }
7782 /*
7783 * This routine is called in kernel context
7784 */
7785
7786 /* ARGSUSED */
7787 static void
7788 daplka_rc_async_handler(void *clnt_private, ibt_hca_hdl_t hca_hdl,
7789 ibt_async_code_t code, ibt_async_event_t *event)
7790 {
7791 daplka_ep_resource_t *epp;
7792 daplka_ia_resource_t *ia_rp;
7793 minor_t ia_rnum;
7794
7795 if (event->ev_chan_hdl == NULL) {
7796 DERR("daplka_rc_async_handler: ev_chan_hdl is NULL\n");
7797 return;
7798 }
7799
7800 mutex_enter(&daplka_dev->daplka_mutex);
7801 epp = ibt_get_chan_private(event->ev_chan_hdl);
7802 if (epp == NULL) {
7803 mutex_exit(&daplka_dev->daplka_mutex);
7804 DERR("daplka_rc_async_handler: chan_private is NULL\n");
7805 return;
7806 }
7807
7808 /* grab a reference to this ep */
7809 DAPLKA_RS_REF(epp);
7810 mutex_exit(&daplka_dev->daplka_mutex);
7811
7812 /*
7813 * The endpoint resource has the resource number corresponding to
7814 * the IA resource. Use that to lookup the ia resource entry
7815 */
7816 ia_rnum = DAPLKA_RS_RNUM(epp);
7817 ia_rp = (daplka_ia_resource_t *)daplka_resource_lookup(ia_rnum);
7818 if ((ia_rp == NULL) || DAPLKA_RS_RESERVED(ia_rp)) {
7819 D2("daplka_rc_async_handler: resource (%d) not found\n",
7820 ia_rnum);
7821 DAPLKA_RS_UNREF(epp);
7822 return;
7823 }
7824
7825 /*
7826 * Create an async event and chain it to the async evd
7827 */
7828 daplka_async_event_create(code, event, epp->ep_cookie, ia_rp);
7829
7830 DAPLKA_RS_UNREF(ia_rp);
7831 DAPLKA_RS_UNREF(epp);
7832 }
7833
7834 /*
7835 * This routine is called in kernel context
7836 */
7837
7838 /* ARGSUSED */
7839 static void
7840 daplka_cq_async_handler(void *clnt_private, ibt_hca_hdl_t hca_hdl,
7841 ibt_async_code_t code, ibt_async_event_t *event)
7842 {
7843 daplka_evd_resource_t *evdp;
7844 daplka_ia_resource_t *ia_rp;
7845 minor_t ia_rnum;
7846
7847 if (event->ev_cq_hdl == NULL)
7848 return;
7849
7850 mutex_enter(&daplka_dev->daplka_mutex);
7851 evdp = ibt_get_cq_private(event->ev_cq_hdl);
7852 if (evdp == NULL) {
7853 mutex_exit(&daplka_dev->daplka_mutex);
7854 DERR("daplka_cq_async_handler: get cq private(%p) failed\n",
7855 event->ev_cq_hdl);
7856 return;
7857 }
7858 /* grab a reference to this evd resource */
7859 DAPLKA_RS_REF(evdp);
7860 mutex_exit(&daplka_dev->daplka_mutex);
7861
7862 /*
7863 * The endpoint resource has the resource number corresponding to
7864 * the IA resource. Use that to lookup the ia resource entry
7865 */
7866 ia_rnum = DAPLKA_RS_RNUM(evdp);
7867 ia_rp = (daplka_ia_resource_t *)daplka_resource_lookup(ia_rnum);
7868 if ((ia_rp == NULL) || DAPLKA_RS_RESERVED(ia_rp)) {
7869 DERR("daplka_cq_async_handler: resource (%d) not found\n",
7870 ia_rnum);
7871 DAPLKA_RS_UNREF(evdp);
7872 return;
7873 }
7874
7875 /*
7876 * Create an async event and chain it to the async evd
7877 */
7878 daplka_async_event_create(code, event, evdp->evd_cookie, ia_rp);
7879
7880 /* release all the refcount that were acquired */
7881 DAPLKA_RS_UNREF(ia_rp);
7882 DAPLKA_RS_UNREF(evdp);
7883 }
7884
7885 /*
7886 * This routine is called in kernel context, handles unaffiliated async errors
7887 */
7888
7889 /* ARGSUSED */
7890 static void
7891 daplka_un_async_handler(void *clnt_private, ibt_hca_hdl_t hca_hdl,
7892 ibt_async_code_t code, ibt_async_event_t *event)
7893 {
7894 int i, j;
7895 daplka_resource_blk_t *blk;
7896 daplka_resource_t *rp;
7897 daplka_ia_resource_t *ia_rp;
7898
7899 /*
7900 * Walk the resource table looking for an ia that matches the
7901 * hca_hdl.
7902 */
7903 rw_enter(&daplka_resource.daplka_rct_lock, RW_READER);
7904 for (i = 0; i < daplka_resource.daplka_rc_len; i++) {
7905 blk = daplka_resource.daplka_rc_root[i];
7906 if (blk == NULL)
7907 continue;
7908 for (j = 0; j < DAPLKA_RC_BLKSZ; j++) {
7909 rp = blk->daplka_rcblk_blks[j];
7910 if ((rp == NULL) ||
7911 ((intptr_t)rp == DAPLKA_RC_RESERVED) ||
7912 (rp->rs_type != DAPL_TYPE_IA)) {
7913 continue;
7914 }
7915 /*
7916 * rp is an IA resource check if it belongs
7917 * to the hca/port for which we got the event
7918 */
7919 ia_rp = (daplka_ia_resource_t *)rp;
7920 DAPLKA_RS_REF(ia_rp);
7921 if ((hca_hdl == ia_rp->ia_hca_hdl) &&
7922 (event->ev_port == ia_rp->ia_port_num)) {
7923 /*
7924 * walk the ep hash table. Acquire a
7925 * reader lock. NULL dgid indicates
7926 * local port up event.
7927 */
7928 daplka_hash_walk(&ia_rp->ia_ep_htbl,
7929 daplka_ep_failback, NULL, RW_READER);
7930 }
7931 DAPLKA_RS_UNREF(ia_rp);
7932 }
7933 }
7934 rw_exit(&daplka_resource.daplka_rct_lock);
7935 }
7936
7937 static int
7938 daplka_handle_hca_detach_event(ibt_async_event_t *event)
7939 {
7940 daplka_hca_t *hca;
7941
7942 /*
7943 * find the hca with the matching guid
7944 */
7945 mutex_enter(&daplka_dev->daplka_mutex);
7946 for (hca = daplka_dev->daplka_hca_list_head; hca != NULL;
7947 hca = hca->hca_next) {
7948 if (hca->hca_guid == event->ev_hca_guid) {
7949 if (DAPLKA_HCA_BUSY(hca)) {
7950 mutex_exit(&daplka_dev->daplka_mutex);
7951 return (IBT_HCA_RESOURCES_NOT_FREED);
7952 }
7953 daplka_dequeue_hca(daplka_dev, hca);
7954 break;
7955 }
7956 }
7957 mutex_exit(&daplka_dev->daplka_mutex);
7958
7959 if (hca == NULL)
7960 return (IBT_FAILURE);
7961
7962 return (daplka_fini_hca(daplka_dev, hca));
7963 }
7964
7965 /*
7966 * This routine is called in kernel context
7967 */
7968 static void
7969 daplka_async_handler(void *clnt_private, ibt_hca_hdl_t hca_hdl,
7970 ibt_async_code_t code, ibt_async_event_t *event)
7971 {
7972 switch (code) {
7973 case IBT_ERROR_CATASTROPHIC_CHAN:
7974 case IBT_ERROR_INVALID_REQUEST_CHAN:
7975 case IBT_ERROR_ACCESS_VIOLATION_CHAN:
7976 case IBT_ERROR_PATH_MIGRATE_REQ:
7977 D2("daplka_async_handler(): Channel affiliated=0x%x\n", code);
7978 /* These events are affiliated with a the RC channel */
7979 daplka_rc_async_handler(clnt_private, hca_hdl, code, event);
7980 break;
7981 case IBT_ERROR_CQ:
7982 /* This event is affiliated with a the CQ */
7983 D2("daplka_async_handler(): IBT_ERROR_CQ\n");
7984 daplka_cq_async_handler(clnt_private, hca_hdl, code, event);
7985 break;
7986 case IBT_ERROR_PORT_DOWN:
7987 D2("daplka_async_handler(): IBT_PORT_DOWN\n");
7988 break;
7989 case IBT_EVENT_PORT_UP:
7990 D2("daplka_async_handler(): IBT_PORT_UP\n");
7991 if (daplka_apm) {
7992 daplka_un_async_handler(clnt_private, hca_hdl, code,
7993 event);
7994 }
7995 break;
7996 case IBT_HCA_ATTACH_EVENT:
7997 /*
7998 * NOTE: In some error recovery paths, it is possible to
7999 * receive IBT_HCA_ATTACH_EVENTs on already known HCAs.
8000 */
8001 D2("daplka_async_handler(): IBT_HCA_ATTACH\n");
8002 (void) daplka_init_hca(daplka_dev, event->ev_hca_guid);
8003 break;
8004 case IBT_HCA_DETACH_EVENT:
8005 D2("daplka_async_handler(): IBT_HCA_DETACH\n");
8006 /* Free all hca resources and close the HCA. */
8007 (void) daplka_handle_hca_detach_event(event);
8008 break;
8009 case IBT_EVENT_PATH_MIGRATED:
8010 /* This event is affiliated with APM */
8011 D2("daplka_async_handler(): IBT_PATH_MIGRATED.\n");
8012 break;
8013 default:
8014 D2("daplka_async_handler(): unhandled code = 0x%x\n", code);
8015 break;
8016 }
8017 }
8018
8019 /*
8020 * This routine is called in kernel context related to Subnet events
8021 */
8022 /*ARGSUSED*/
8023 static void
8024 daplka_sm_notice_handler(void *arg, ib_gid_t gid, ibt_subnet_event_code_t code,
8025 ibt_subnet_event_t *event)
8026 {
8027 ib_gid_t *sgid = &gid;
8028 ib_gid_t *dgid;
8029
8030 dgid = &event->sm_notice_gid;
8031 switch (code) {
8032 case IBT_SM_EVENT_GID_AVAIL:
8033 /* This event is affiliated with remote port up */
8034 D2("daplka_sm_notice_handler(): IBT_SM_EVENT_GID_AVAIL\n");
8035 if (daplka_apm)
8036 daplka_sm_gid_avail(sgid, dgid);
8037 return;
8038 case IBT_SM_EVENT_GID_UNAVAIL:
8039 /* This event is affiliated with remote port down */
8040 D2("daplka_sm_notice_handler(): IBT_SM_EVENT_GID_UNAVAIL\n");
8041 return;
8042 default:
8043 D2("daplka_sm_notice_handler(): unhandled IBT_SM_EVENT_[%d]\n",
8044 code);
8045 return;
8046 }
8047 }
8048
8049 /*
8050 * This routine is called in kernel context, handles Subnet GID avail events
8051 * which correspond to remote port up. Setting up alternate path or path
8052 * migration (failback) has to be initiated from the active side of the
8053 * original connect.
8054 */
8055 static void
8056 daplka_sm_gid_avail(ib_gid_t *sgid, ib_gid_t *dgid)
8057 {
8058 int i, j;
8059 daplka_resource_blk_t *blk;
8060 daplka_resource_t *rp;
8061 daplka_ia_resource_t *ia_rp;
8062
8063 D2("daplka_sm_gid_avail: sgid=%llx:%llx dgid=%llx:%llx\n",
8064 (longlong_t)sgid->gid_prefix, (longlong_t)sgid->gid_guid,
8065 (longlong_t)dgid->gid_prefix, (longlong_t)dgid->gid_guid);
8066
8067 /*
8068 * Walk the resource table looking for an ia that matches the sgid
8069 */
8070 rw_enter(&daplka_resource.daplka_rct_lock, RW_READER);
8071 for (i = 0; i < daplka_resource.daplka_rc_len; i++) {
8072 blk = daplka_resource.daplka_rc_root[i];
8073 if (blk == NULL)
8074 continue;
8075 for (j = 0; j < DAPLKA_RC_BLKSZ; j++) {
8076 rp = blk->daplka_rcblk_blks[j];
8077 if ((rp == NULL) ||
8078 ((intptr_t)rp == DAPLKA_RC_RESERVED) ||
8079 (rp->rs_type != DAPL_TYPE_IA)) {
8080 continue;
8081 }
8082 /*
8083 * rp is an IA resource check if its gid
8084 * matches with the calling sgid
8085 */
8086 ia_rp = (daplka_ia_resource_t *)rp;
8087 DAPLKA_RS_REF(ia_rp);
8088 if ((sgid->gid_prefix ==
8089 ia_rp->ia_hca_sgid.gid_prefix) &&
8090 (sgid->gid_guid == ia_rp->ia_hca_sgid.gid_guid)) {
8091 /*
8092 * walk the ep hash table. Acquire a
8093 * reader lock.
8094 */
8095 daplka_hash_walk(&ia_rp->ia_ep_htbl,
8096 daplka_ep_failback,
8097 (void *)dgid, RW_READER);
8098 }
8099 DAPLKA_RS_UNREF(ia_rp);
8100 }
8101 }
8102 rw_exit(&daplka_resource.daplka_rct_lock);
8103 }
8104
8105 /*
8106 * This routine is called in kernel context to get and set an alternate path
8107 */
8108 static int
8109 daplka_ep_altpath(daplka_ep_resource_t *ep_rp, ib_gid_t *dgid)
8110 {
8111 ibt_alt_path_info_t path_info;
8112 ibt_alt_path_attr_t path_attr;
8113 ibt_ap_returns_t ap_rets;
8114 ibt_status_t status;
8115
8116 D2("daplka_ep_altpath : ibt_get_alt_path()\n");
8117 bzero(&path_info, sizeof (ibt_alt_path_info_t));
8118 bzero(&path_attr, sizeof (ibt_alt_path_attr_t));
8119 if (dgid != NULL) {
8120 path_attr.apa_sgid = ep_rp->ep_sgid;
8121 path_attr.apa_dgid = *dgid;
8122 }
8123 status = ibt_get_alt_path(ep_rp->ep_chan_hdl, IBT_PATH_AVAIL,
8124 &path_attr, &path_info);
8125 if (status != IBT_SUCCESS) {
8126 DERR("daplka_ep_altpath : ibt_get_alt_path failed %d\n",
8127 status);
8128 return (1);
8129 }
8130
8131 D2("daplka_ep_altpath : ibt_set_alt_path()\n");
8132 bzero(&ap_rets, sizeof (ibt_ap_returns_t));
8133 status = ibt_set_alt_path(ep_rp->ep_chan_hdl, IBT_BLOCKING,
8134 &path_info, NULL, 0, &ap_rets);
8135 if ((status != IBT_SUCCESS) ||
8136 (ap_rets.ap_status != IBT_CM_AP_LOADED)) {
8137 DERR("daplka_ep_altpath : ibt_set_alt_path failed "
8138 "status %d ap_status %d\n", status, ap_rets.ap_status);
8139 return (1);
8140 }
8141 return (0);
8142 }
8143
8144 /*
8145 * This routine is called in kernel context to failback to the original path
8146 */
8147 static int
8148 daplka_ep_failback(void *objp, void *arg)
8149 {
8150 daplka_ep_resource_t *ep_rp = (daplka_ep_resource_t *)objp;
8151 ib_gid_t *dgid;
8152 ibt_status_t status;
8153 ibt_rc_chan_query_attr_t chan_attrs;
8154 int i;
8155
8156 ASSERT(DAPLKA_RS_TYPE(ep_rp) == DAPL_TYPE_EP);
8157 D2("daplka_ep_failback ep : sgid=%llx:%llx dgid=%llx:%llx\n",
8158 (longlong_t)ep_rp->ep_sgid.gid_prefix,
8159 (longlong_t)ep_rp->ep_sgid.gid_guid,
8160 (longlong_t)ep_rp->ep_dgid.gid_prefix,
8161 (longlong_t)ep_rp->ep_dgid.gid_guid);
8162
8163 /*
8164 * daplka_ep_failback is called from daplka_hash_walk
8165 * which holds the read lock on hash table to protect
8166 * the endpoint resource from removal
8167 */
8168 mutex_enter(&ep_rp->ep_lock);
8169 /* check for unconnected endpoints */
8170 /* first check for ep state */
8171 if (ep_rp->ep_state != DAPLKA_EP_STATE_CONNECTED) {
8172 mutex_exit(&ep_rp->ep_lock);
8173 D2("daplka_ep_failback : endpoints not connected\n");
8174 return (0);
8175 }
8176
8177 /* second check for gids */
8178 if (((ep_rp->ep_sgid.gid_prefix == 0) &&
8179 (ep_rp->ep_sgid.gid_guid == 0)) ||
8180 ((ep_rp->ep_dgid.gid_prefix == 0) &&
8181 (ep_rp->ep_dgid.gid_guid == 0))) {
8182 mutex_exit(&ep_rp->ep_lock);
8183 D2("daplka_ep_failback : skip unconnected endpoints\n");
8184 return (0);
8185 }
8186
8187 /*
8188 * matching destination ep
8189 * when dgid is NULL, the async event is a local port up.
8190 * dgid becomes wild card, i.e. all endpoints match
8191 */
8192 dgid = (ib_gid_t *)arg;
8193 if (dgid == NULL) {
8194 /* ignore loopback ep */
8195 if ((ep_rp->ep_sgid.gid_prefix == ep_rp->ep_dgid.gid_prefix) &&
8196 (ep_rp->ep_sgid.gid_guid == ep_rp->ep_dgid.gid_guid)) {
8197 mutex_exit(&ep_rp->ep_lock);
8198 D2("daplka_ep_failback : skip loopback endpoints\n");
8199 return (0);
8200 }
8201 } else {
8202 /* matching remote ep */
8203 if ((ep_rp->ep_dgid.gid_prefix != dgid->gid_prefix) ||
8204 (ep_rp->ep_dgid.gid_guid != dgid->gid_guid)) {
8205 mutex_exit(&ep_rp->ep_lock);
8206 D2("daplka_ep_failback : unrelated endpoints\n");
8207 return (0);
8208 }
8209 }
8210
8211 /* call get and set altpath with original dgid used in ep_connect */
8212 if (daplka_ep_altpath(ep_rp, &ep_rp->ep_dgid)) {
8213 mutex_exit(&ep_rp->ep_lock);
8214 return (0);
8215 }
8216
8217 /*
8218 * wait for migration state to be ARMed
8219 * e.g. a post_send msg will transit mig_state from REARM to ARM
8220 */
8221 for (i = 0; i < daplka_query_aft_setaltpath; i++) {
8222 bzero(&chan_attrs, sizeof (ibt_rc_chan_query_attr_t));
8223 status = ibt_query_rc_channel(ep_rp->ep_chan_hdl, &chan_attrs);
8224 if (status != IBT_SUCCESS) {
8225 mutex_exit(&ep_rp->ep_lock);
8226 DERR("daplka_ep_altpath : ibt_query_rc_channel err\n");
8227 return (0);
8228 }
8229 if (chan_attrs.rc_mig_state == IBT_STATE_ARMED)
8230 break;
8231 }
8232
8233 D2("daplka_ep_altpath : query[%d] mig_st=%d\n",
8234 i, chan_attrs.rc_mig_state);
8235 D2("daplka_ep_altpath : P sgid=%llx:%llx dgid=%llx:%llx\n",
8236 (longlong_t)
8237 chan_attrs.rc_prim_path.cep_adds_vect.av_sgid.gid_prefix,
8238 (longlong_t)chan_attrs.rc_prim_path.cep_adds_vect.av_sgid.gid_guid,
8239 (longlong_t)
8240 chan_attrs.rc_prim_path.cep_adds_vect.av_dgid.gid_prefix,
8241 (longlong_t)chan_attrs.rc_prim_path.cep_adds_vect.av_dgid.gid_guid);
8242 D2("daplka_ep_altpath : A sgid=%llx:%llx dgid=%llx:%llx\n",
8243 (longlong_t)chan_attrs.rc_alt_path.cep_adds_vect.av_sgid.gid_prefix,
8244 (longlong_t)chan_attrs.rc_alt_path.cep_adds_vect.av_sgid.gid_guid,
8245 (longlong_t)chan_attrs.rc_alt_path.cep_adds_vect.av_dgid.gid_prefix,
8246 (longlong_t)chan_attrs.rc_alt_path.cep_adds_vect.av_dgid.gid_guid);
8247
8248 /* skip failback on ARMed state not reached or env override */
8249 if ((i >= daplka_query_aft_setaltpath) || (daplka_failback == 0)) {
8250 mutex_exit(&ep_rp->ep_lock);
8251 DERR("daplka_ep_altpath : ARMed state not reached\n");
8252 return (0);
8253 }
8254
8255 D2("daplka_ep_failback : ibt_migrate_path() to original ep\n");
8256 status = ibt_migrate_path(ep_rp->ep_chan_hdl);
8257 if (status != IBT_SUCCESS) {
8258 mutex_exit(&ep_rp->ep_lock);
8259 DERR("daplka_ep_failback : migration failed "
8260 "status %d\n", status);
8261 return (0);
8262 }
8263
8264 /* call get and altpath with NULL dgid to indicate unspecified dgid */
8265 (void) daplka_ep_altpath(ep_rp, NULL);
8266 mutex_exit(&ep_rp->ep_lock);
8267 return (0);
8268 }
8269
8270 /*
8271 * IBTF wrappers used for resource accounting
8272 */
8273 static ibt_status_t
8274 daplka_ibt_alloc_rc_channel(daplka_ep_resource_t *ep_rp, ibt_hca_hdl_t hca_hdl,
8275 ibt_chan_alloc_flags_t flags, ibt_rc_chan_alloc_args_t *args,
8276 ibt_channel_hdl_t *chan_hdl_p, ibt_chan_sizes_t *sizes)
8277 {
8278 daplka_hca_t *hca_p;
8279 uint32_t max_qps;
8280 boolean_t acct_enabled;
8281 ibt_status_t status;
8282
8283 acct_enabled = daplka_accounting_enabled;
8284 hca_p = ep_rp->ep_hca;
8285 max_qps = daplka_max_qp_percent * hca_p->hca_attr.hca_max_chans / 100;
8286
8287 if (acct_enabled) {
8288 if (daplka_max_qp_percent != 0 &&
8289 max_qps <= hca_p->hca_qp_count) {
8290 DERR("ibt_alloc_rc_channel: resource limit exceeded "
8291 "(limit %d, count %d)\n", max_qps,
8292 hca_p->hca_qp_count);
8293 return (IBT_INSUFF_RESOURCE);
8294 }
8295 DAPLKA_RS_ACCT_INC(ep_rp, 1);
8296 atomic_inc_32(&hca_p->hca_qp_count);
8297 }
8298 status = ibt_alloc_rc_channel(hca_hdl, flags, args, chan_hdl_p, sizes);
8299
8300 if (status != IBT_SUCCESS && acct_enabled) {
8301 DAPLKA_RS_ACCT_DEC(ep_rp, 1);
8302 atomic_dec_32(&hca_p->hca_qp_count);
8303 }
8304 return (status);
8305 }
8306
8307 static ibt_status_t
8308 daplka_ibt_free_channel(daplka_ep_resource_t *ep_rp, ibt_channel_hdl_t chan_hdl)
8309 {
8310 daplka_hca_t *hca_p;
8311 ibt_status_t status;
8312
8313 hca_p = ep_rp->ep_hca;
8314
8315 status = ibt_free_channel(chan_hdl);
8316 if (status != IBT_SUCCESS) {
8317 return (status);
8318 }
8319 if (DAPLKA_RS_ACCT_CHARGED(ep_rp) > 0) {
8320 DAPLKA_RS_ACCT_DEC(ep_rp, 1);
8321 atomic_dec_32(&hca_p->hca_qp_count);
8322 }
8323 return (status);
8324 }
8325
8326 static ibt_status_t
8327 daplka_ibt_alloc_cq(daplka_evd_resource_t *evd_rp, ibt_hca_hdl_t hca_hdl,
8328 ibt_cq_attr_t *cq_attr, ibt_cq_hdl_t *ibt_cq_p, uint32_t *real_size)
8329 {
8330 daplka_hca_t *hca_p;
8331 uint32_t max_cqs;
8332 boolean_t acct_enabled;
8333 ibt_status_t status;
8334
8335 acct_enabled = daplka_accounting_enabled;
8336 hca_p = evd_rp->evd_hca;
8337 max_cqs = daplka_max_cq_percent * hca_p->hca_attr.hca_max_cq / 100;
8338
8339 if (acct_enabled) {
8340 if (daplka_max_cq_percent != 0 &&
8341 max_cqs <= hca_p->hca_cq_count) {
8342 DERR("ibt_alloc_cq: resource limit exceeded "
8343 "(limit %d, count %d)\n", max_cqs,
8344 hca_p->hca_cq_count);
8345 return (IBT_INSUFF_RESOURCE);
8346 }
8347 DAPLKA_RS_ACCT_INC(evd_rp, 1);
8348 atomic_inc_32(&hca_p->hca_cq_count);
8349 }
8350 status = ibt_alloc_cq(hca_hdl, cq_attr, ibt_cq_p, real_size);
8351
8352 if (status != IBT_SUCCESS && acct_enabled) {
8353 DAPLKA_RS_ACCT_DEC(evd_rp, 1);
8354 atomic_dec_32(&hca_p->hca_cq_count);
8355 }
8356 return (status);
8357 }
8358
8359 static ibt_status_t
8360 daplka_ibt_free_cq(daplka_evd_resource_t *evd_rp, ibt_cq_hdl_t cq_hdl)
8361 {
8362 daplka_hca_t *hca_p;
8363 ibt_status_t status;
8364
8365 hca_p = evd_rp->evd_hca;
8366
8367 status = ibt_free_cq(cq_hdl);
8368 if (status != IBT_SUCCESS) {
8369 return (status);
8370 }
8371 if (DAPLKA_RS_ACCT_CHARGED(evd_rp) > 0) {
8372 DAPLKA_RS_ACCT_DEC(evd_rp, 1);
8373 atomic_dec_32(&hca_p->hca_cq_count);
8374 }
8375 return (status);
8376 }
8377
8378 static ibt_status_t
8379 daplka_ibt_alloc_pd(daplka_pd_resource_t *pd_rp, ibt_hca_hdl_t hca_hdl,
8380 ibt_pd_flags_t flags, ibt_pd_hdl_t *pd_hdl_p)
8381 {
8382 daplka_hca_t *hca_p;
8383 uint32_t max_pds;
8384 boolean_t acct_enabled;
8385 ibt_status_t status;
8386
8387 acct_enabled = daplka_accounting_enabled;
8388 hca_p = pd_rp->pd_hca;
8389 max_pds = daplka_max_pd_percent * hca_p->hca_attr.hca_max_pd / 100;
8390
8391 if (acct_enabled) {
8392 if (daplka_max_pd_percent != 0 &&
8393 max_pds <= hca_p->hca_pd_count) {
8394 DERR("ibt_alloc_pd: resource limit exceeded "
8395 "(limit %d, count %d)\n", max_pds,
8396 hca_p->hca_pd_count);
8397 return (IBT_INSUFF_RESOURCE);
8398 }
8399 DAPLKA_RS_ACCT_INC(pd_rp, 1);
8400 atomic_inc_32(&hca_p->hca_pd_count);
8401 }
8402 status = ibt_alloc_pd(hca_hdl, flags, pd_hdl_p);
8403
8404 if (status != IBT_SUCCESS && acct_enabled) {
8405 DAPLKA_RS_ACCT_DEC(pd_rp, 1);
8406 atomic_dec_32(&hca_p->hca_pd_count);
8407 }
8408 return (status);
8409 }
8410
8411 static ibt_status_t
8412 daplka_ibt_free_pd(daplka_pd_resource_t *pd_rp, ibt_hca_hdl_t hca_hdl,
8413 ibt_pd_hdl_t pd_hdl)
8414 {
8415 daplka_hca_t *hca_p;
8416 ibt_status_t status;
8417
8418 hca_p = pd_rp->pd_hca;
8419
8420 status = ibt_free_pd(hca_hdl, pd_hdl);
8421 if (status != IBT_SUCCESS) {
8422 return (status);
8423 }
8424 if (DAPLKA_RS_ACCT_CHARGED(pd_rp) > 0) {
8425 DAPLKA_RS_ACCT_DEC(pd_rp, 1);
8426 atomic_dec_32(&hca_p->hca_pd_count);
8427 }
8428 return (status);
8429 }
8430
8431 static ibt_status_t
8432 daplka_ibt_alloc_mw(daplka_mw_resource_t *mw_rp, ibt_hca_hdl_t hca_hdl,
8433 ibt_pd_hdl_t pd_hdl, ibt_mw_flags_t flags, ibt_mw_hdl_t *mw_hdl_p,
8434 ibt_rkey_t *rkey_p)
8435 {
8436 daplka_hca_t *hca_p;
8437 uint32_t max_mws;
8438 boolean_t acct_enabled;
8439 ibt_status_t status;
8440
8441 acct_enabled = daplka_accounting_enabled;
8442 hca_p = mw_rp->mw_hca;
8443 max_mws = daplka_max_mw_percent * hca_p->hca_attr.hca_max_mem_win / 100;
8444
8445 if (acct_enabled) {
8446 if (daplka_max_mw_percent != 0 &&
8447 max_mws <= hca_p->hca_mw_count) {
8448 DERR("ibt_alloc_mw: resource limit exceeded "
8449 "(limit %d, count %d)\n", max_mws,
8450 hca_p->hca_mw_count);
8451 return (IBT_INSUFF_RESOURCE);
8452 }
8453 DAPLKA_RS_ACCT_INC(mw_rp, 1);
8454 atomic_inc_32(&hca_p->hca_mw_count);
8455 }
8456 status = ibt_alloc_mw(hca_hdl, pd_hdl, flags, mw_hdl_p, rkey_p);
8457
8458 if (status != IBT_SUCCESS && acct_enabled) {
8459 DAPLKA_RS_ACCT_DEC(mw_rp, 1);
8460 atomic_dec_32(&hca_p->hca_mw_count);
8461 }
8462 return (status);
8463 }
8464
8465 static ibt_status_t
8466 daplka_ibt_free_mw(daplka_mw_resource_t *mw_rp, ibt_hca_hdl_t hca_hdl,
8467 ibt_mw_hdl_t mw_hdl)
8468 {
8469 daplka_hca_t *hca_p;
8470 ibt_status_t status;
8471
8472 hca_p = mw_rp->mw_hca;
8473
8474 status = ibt_free_mw(hca_hdl, mw_hdl);
8475 if (status != IBT_SUCCESS) {
8476 return (status);
8477 }
8478 if (DAPLKA_RS_ACCT_CHARGED(mw_rp) > 0) {
8479 DAPLKA_RS_ACCT_DEC(mw_rp, 1);
8480 atomic_dec_32(&hca_p->hca_mw_count);
8481 }
8482 return (status);
8483 }
8484
8485 static ibt_status_t
8486 daplka_ibt_register_mr(daplka_mr_resource_t *mr_rp, ibt_hca_hdl_t hca_hdl,
8487 ibt_pd_hdl_t pd_hdl, ibt_mr_attr_t *mr_attr, ibt_mr_hdl_t *mr_hdl_p,
8488 ibt_mr_desc_t *mr_desc_p)
8489 {
8490 daplka_hca_t *hca_p;
8491 uint32_t max_mrs;
8492 boolean_t acct_enabled;
8493 ibt_status_t status;
8494
8495 acct_enabled = daplka_accounting_enabled;
8496 hca_p = mr_rp->mr_hca;
8497 max_mrs = daplka_max_mr_percent * hca_p->hca_attr.hca_max_memr / 100;
8498
8499 if (acct_enabled) {
8500 if (daplka_max_mr_percent != 0 &&
8501 max_mrs <= hca_p->hca_mr_count) {
8502 DERR("ibt_register_mr: resource limit exceeded "
8503 "(limit %d, count %d)\n", max_mrs,
8504 hca_p->hca_mr_count);
8505 return (IBT_INSUFF_RESOURCE);
8506 }
8507 DAPLKA_RS_ACCT_INC(mr_rp, 1);
8508 atomic_inc_32(&hca_p->hca_mr_count);
8509 }
8510 status = ibt_register_mr(hca_hdl, pd_hdl, mr_attr, mr_hdl_p, mr_desc_p);
8511
8512 if (status != IBT_SUCCESS && acct_enabled) {
8513 DAPLKA_RS_ACCT_DEC(mr_rp, 1);
8514 atomic_dec_32(&hca_p->hca_mr_count);
8515 }
8516 return (status);
8517 }
8518
8519 static ibt_status_t
8520 daplka_ibt_register_shared_mr(daplka_mr_resource_t *mr_rp,
8521 ibt_hca_hdl_t hca_hdl, ibt_mr_hdl_t mr_hdl, ibt_pd_hdl_t pd_hdl,
8522 ibt_smr_attr_t *smr_attr_p, ibt_mr_hdl_t *mr_hdl_p,
8523 ibt_mr_desc_t *mr_desc_p)
8524 {
8525 daplka_hca_t *hca_p;
8526 uint32_t max_mrs;
8527 boolean_t acct_enabled;
8528 ibt_status_t status;
8529
8530 acct_enabled = daplka_accounting_enabled;
8531 hca_p = mr_rp->mr_hca;
8532 max_mrs = daplka_max_mr_percent * hca_p->hca_attr.hca_max_memr / 100;
8533
8534 if (acct_enabled) {
8535 if (daplka_max_mr_percent != 0 &&
8536 max_mrs <= hca_p->hca_mr_count) {
8537 DERR("ibt_register_shared_mr: resource limit exceeded "
8538 "(limit %d, count %d)\n", max_mrs,
8539 hca_p->hca_mr_count);
8540 return (IBT_INSUFF_RESOURCE);
8541 }
8542 DAPLKA_RS_ACCT_INC(mr_rp, 1);
8543 atomic_inc_32(&hca_p->hca_mr_count);
8544 }
8545 status = ibt_register_shared_mr(hca_hdl, mr_hdl, pd_hdl,
8546 smr_attr_p, mr_hdl_p, mr_desc_p);
8547
8548 if (status != IBT_SUCCESS && acct_enabled) {
8549 DAPLKA_RS_ACCT_DEC(mr_rp, 1);
8550 atomic_dec_32(&hca_p->hca_mr_count);
8551 }
8552 return (status);
8553 }
8554
8555 static ibt_status_t
8556 daplka_ibt_deregister_mr(daplka_mr_resource_t *mr_rp, ibt_hca_hdl_t hca_hdl,
8557 ibt_mr_hdl_t mr_hdl)
8558 {
8559 daplka_hca_t *hca_p;
8560 ibt_status_t status;
8561
8562 hca_p = mr_rp->mr_hca;
8563
8564 status = ibt_deregister_mr(hca_hdl, mr_hdl);
8565 if (status != IBT_SUCCESS) {
8566 return (status);
8567 }
8568 if (DAPLKA_RS_ACCT_CHARGED(mr_rp) > 0) {
8569 DAPLKA_RS_ACCT_DEC(mr_rp, 1);
8570 atomic_dec_32(&hca_p->hca_mr_count);
8571 }
8572 return (status);
8573 }
8574
8575 static ibt_status_t
8576 daplka_ibt_alloc_srq(daplka_srq_resource_t *srq_rp, ibt_hca_hdl_t hca_hdl,
8577 ibt_srq_flags_t flags, ibt_pd_hdl_t pd, ibt_srq_sizes_t *reqsz,
8578 ibt_srq_hdl_t *srq_hdl_p, ibt_srq_sizes_t *realsz)
8579 {
8580 daplka_hca_t *hca_p;
8581 uint32_t max_srqs;
8582 boolean_t acct_enabled;
8583 ibt_status_t status;
8584
8585 acct_enabled = daplka_accounting_enabled;
8586 hca_p = srq_rp->srq_hca;
8587 max_srqs = daplka_max_srq_percent * hca_p->hca_attr.hca_max_srqs / 100;
8588
8589 if (acct_enabled) {
8590 if (daplka_max_srq_percent != 0 &&
8591 max_srqs <= hca_p->hca_srq_count) {
8592 DERR("ibt_alloc_srq: resource limit exceeded "
8593 "(limit %d, count %d)\n", max_srqs,
8594 hca_p->hca_srq_count);
8595 return (IBT_INSUFF_RESOURCE);
8596 }
8597 DAPLKA_RS_ACCT_INC(srq_rp, 1);
8598 atomic_inc_32(&hca_p->hca_srq_count);
8599 }
8600 status = ibt_alloc_srq(hca_hdl, flags, pd, reqsz, srq_hdl_p, realsz);
8601
8602 if (status != IBT_SUCCESS && acct_enabled) {
8603 DAPLKA_RS_ACCT_DEC(srq_rp, 1);
8604 atomic_dec_32(&hca_p->hca_srq_count);
8605 }
8606 return (status);
8607 }
8608
8609 static ibt_status_t
8610 daplka_ibt_free_srq(daplka_srq_resource_t *srq_rp, ibt_srq_hdl_t srq_hdl)
8611 {
8612 daplka_hca_t *hca_p;
8613 ibt_status_t status;
8614
8615 hca_p = srq_rp->srq_hca;
8616
8617 D3("ibt_free_srq: %p %p\n", srq_rp, srq_hdl);
8618
8619 status = ibt_free_srq(srq_hdl);
8620 if (status != IBT_SUCCESS) {
8621 return (status);
8622 }
8623 if (DAPLKA_RS_ACCT_CHARGED(srq_rp) > 0) {
8624 DAPLKA_RS_ACCT_DEC(srq_rp, 1);
8625 atomic_dec_32(&hca_p->hca_srq_count);
8626 }
8627 return (status);
8628 }
8629
8630
8631 static int
8632 daplka_common_ioctl(int cmd, minor_t rnum, intptr_t arg, int mode,
8633 cred_t *cred, int *rvalp)
8634 {
8635 int error;
8636
8637 switch (cmd) {
8638 case DAPL_IA_CREATE:
8639 error = daplka_ia_create(rnum, arg, mode, cred, rvalp);
8640 break;
8641
8642 /* can potentially add other commands here */
8643
8644 default:
8645 DERR("daplka_common_ioctl: cmd not supported\n");
8646 error = DDI_FAILURE;
8647 }
8648 return (error);
8649 }
8650
8651 static int
8652 daplka_evd_ioctl(int cmd, daplka_ia_resource_t *rp, intptr_t arg, int mode,
8653 cred_t *cred, int *rvalp)
8654 {
8655 int error;
8656
8657 switch (cmd) {
8658 case DAPL_EVD_CREATE:
8659 error = daplka_evd_create(rp, arg, mode, cred, rvalp);
8660 break;
8661
8662 case DAPL_CQ_RESIZE:
8663 error = daplka_cq_resize(rp, arg, mode, cred, rvalp);
8664 break;
8665
8666 case DAPL_EVENT_POLL:
8667 error = daplka_event_poll(rp, arg, mode, cred, rvalp);
8668 break;
8669
8670 case DAPL_EVENT_WAKEUP:
8671 error = daplka_event_wakeup(rp, arg, mode, cred, rvalp);
8672 break;
8673
8674 case DAPL_EVD_MODIFY_CNO:
8675 error = daplka_evd_modify_cno(rp, arg, mode, cred, rvalp);
8676 break;
8677
8678 case DAPL_EVD_FREE:
8679 error = daplka_evd_free(rp, arg, mode, cred, rvalp);
8680 break;
8681
8682 default:
8683 DERR("daplka_evd_ioctl: cmd not supported\n");
8684 error = DDI_FAILURE;
8685 }
8686 return (error);
8687 }
8688
8689 static int
8690 daplka_ep_ioctl(int cmd, daplka_ia_resource_t *rp, intptr_t arg, int mode,
8691 cred_t *cred, int *rvalp)
8692 {
8693 int error;
8694
8695 switch (cmd) {
8696 case DAPL_EP_MODIFY:
8697 error = daplka_ep_modify(rp, arg, mode, cred, rvalp);
8698 break;
8699
8700 case DAPL_EP_FREE:
8701 error = daplka_ep_free(rp, arg, mode, cred, rvalp);
8702 break;
8703
8704 case DAPL_EP_CONNECT:
8705 error = daplka_ep_connect(rp, arg, mode, cred, rvalp);
8706 break;
8707
8708 case DAPL_EP_DISCONNECT:
8709 error = daplka_ep_disconnect(rp, arg, mode, cred, rvalp);
8710 break;
8711
8712 case DAPL_EP_REINIT:
8713 error = daplka_ep_reinit(rp, arg, mode, cred, rvalp);
8714 break;
8715
8716 case DAPL_EP_CREATE:
8717 error = daplka_ep_create(rp, arg, mode, cred, rvalp);
8718 break;
8719
8720 default:
8721 DERR("daplka_ep_ioctl: cmd not supported\n");
8722 error = DDI_FAILURE;
8723 }
8724 return (error);
8725 }
8726
8727 static int
8728 daplka_mr_ioctl(int cmd, daplka_ia_resource_t *rp, intptr_t arg, int mode,
8729 cred_t *cred, int *rvalp)
8730 {
8731 int error;
8732
8733 switch (cmd) {
8734 case DAPL_MR_REGISTER:
8735 error = daplka_mr_register(rp, arg, mode, cred, rvalp);
8736 break;
8737
8738 case DAPL_MR_REGISTER_LMR:
8739 error = daplka_mr_register_lmr(rp, arg, mode, cred, rvalp);
8740 break;
8741
8742 case DAPL_MR_REGISTER_SHARED:
8743 error = daplka_mr_register_shared(rp, arg, mode, cred, rvalp);
8744 break;
8745
8746 case DAPL_MR_DEREGISTER:
8747 error = daplka_mr_deregister(rp, arg, mode, cred, rvalp);
8748 break;
8749
8750 case DAPL_MR_SYNC:
8751 error = daplka_mr_sync(rp, arg, mode, cred, rvalp);
8752 break;
8753
8754 default:
8755 DERR("daplka_mr_ioctl: cmd not supported\n");
8756 error = DDI_FAILURE;
8757 }
8758 return (error);
8759 }
8760
8761 static int
8762 daplka_mw_ioctl(int cmd, daplka_ia_resource_t *rp, intptr_t arg, int mode,
8763 cred_t *cred, int *rvalp)
8764 {
8765 int error;
8766
8767 switch (cmd) {
8768 case DAPL_MW_ALLOC:
8769 error = daplka_mw_alloc(rp, arg, mode, cred, rvalp);
8770 break;
8771
8772 case DAPL_MW_FREE:
8773 error = daplka_mw_free(rp, arg, mode, cred, rvalp);
8774 break;
8775
8776 default:
8777 DERR("daplka_mw_ioctl: cmd not supported\n");
8778 error = DDI_FAILURE;
8779 }
8780 return (error);
8781 }
8782
8783 static int
8784 daplka_cno_ioctl(int cmd, daplka_ia_resource_t *rp, intptr_t arg, int mode,
8785 cred_t *cred, int *rvalp)
8786 {
8787 int error;
8788
8789 switch (cmd) {
8790 case DAPL_CNO_ALLOC:
8791 error = daplka_cno_alloc(rp, arg, mode, cred, rvalp);
8792 break;
8793
8794 case DAPL_CNO_FREE:
8795 error = daplka_cno_free(rp, arg, mode, cred, rvalp);
8796 break;
8797
8798 case DAPL_CNO_WAIT:
8799 error = daplka_cno_wait(rp, arg, mode, cred, rvalp);
8800 break;
8801
8802 default:
8803 DERR("daplka_cno_ioctl: cmd not supported\n");
8804 error = DDI_FAILURE;
8805 }
8806 return (error);
8807 }
8808
8809 static int
8810 daplka_pd_ioctl(int cmd, daplka_ia_resource_t *rp, intptr_t arg, int mode,
8811 cred_t *cred, int *rvalp)
8812 {
8813 int error;
8814
8815 switch (cmd) {
8816 case DAPL_PD_ALLOC:
8817 error = daplka_pd_alloc(rp, arg, mode, cred, rvalp);
8818 break;
8819
8820 case DAPL_PD_FREE:
8821 error = daplka_pd_free(rp, arg, mode, cred, rvalp);
8822 break;
8823
8824 default:
8825 DERR("daplka_pd_ioctl: cmd not supported\n");
8826 error = DDI_FAILURE;
8827 }
8828 return (error);
8829 }
8830
8831 static int
8832 daplka_sp_ioctl(int cmd, daplka_ia_resource_t *rp, intptr_t arg, int mode,
8833 cred_t *cred, int *rvalp)
8834 {
8835 int error;
8836
8837 switch (cmd) {
8838 case DAPL_SERVICE_REGISTER:
8839 error = daplka_service_register(rp, arg, mode, cred, rvalp);
8840 break;
8841
8842 case DAPL_SERVICE_DEREGISTER:
8843 error = daplka_service_deregister(rp, arg, mode, cred, rvalp);
8844 break;
8845
8846 default:
8847 DERR("daplka_sp_ioctl: cmd not supported\n");
8848 error = DDI_FAILURE;
8849 }
8850 return (error);
8851 }
8852
8853 static int
8854 daplka_srq_ioctl(int cmd, daplka_ia_resource_t *rp, intptr_t arg, int mode,
8855 cred_t *cred, int *rvalp)
8856 {
8857 int error;
8858
8859 switch (cmd) {
8860 case DAPL_SRQ_CREATE:
8861 error = daplka_srq_create(rp, arg, mode, cred, rvalp);
8862 break;
8863
8864 case DAPL_SRQ_RESIZE:
8865 error = daplka_srq_resize(rp, arg, mode, cred, rvalp);
8866 break;
8867
8868 case DAPL_SRQ_FREE:
8869 error = daplka_srq_free(rp, arg, mode, cred, rvalp);
8870 break;
8871
8872 default:
8873 DERR("daplka_srq_ioctl: cmd(%d) not supported\n", cmd);
8874 error = DDI_FAILURE;
8875 break;
8876 }
8877 return (error);
8878 }
8879
8880 static int
8881 daplka_misc_ioctl(int cmd, daplka_ia_resource_t *rp, intptr_t arg, int mode,
8882 cred_t *cred, int *rvalp)
8883 {
8884 int error;
8885
8886 switch (cmd) {
8887 case DAPL_CR_ACCEPT:
8888 error = daplka_cr_accept(rp, arg, mode, cred, rvalp);
8889 break;
8890
8891 case DAPL_CR_REJECT:
8892 error = daplka_cr_reject(rp, arg, mode, cred, rvalp);
8893 break;
8894
8895 case DAPL_IA_QUERY:
8896 error = daplka_ia_query(rp, arg, mode, cred, rvalp);
8897 break;
8898
8899 case DAPL_CR_HANDOFF:
8900 error = daplka_cr_handoff(rp, arg, mode, cred, rvalp);
8901 break;
8902
8903 default:
8904 DERR("daplka_misc_ioctl: cmd not supported\n");
8905 error = DDI_FAILURE;
8906 }
8907 return (error);
8908 }
8909
8910 /*ARGSUSED*/
8911 static int
8912 daplka_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *cred,
8913 int *rvalp)
8914 {
8915 daplka_ia_resource_t *ia_rp;
8916 minor_t rnum;
8917 int error = 0;
8918
8919 rnum = getminor(dev);
8920 ia_rp = (daplka_ia_resource_t *)daplka_resource_lookup(rnum);
8921 if (ia_rp == NULL) {
8922 DERR("ioctl: resource not found, rnum %d\n", rnum);
8923 return (ENXIO);
8924 }
8925
8926 D4("ioctl: rnum = %d, cmd = 0x%x\n", rnum, cmd);
8927 if (DAPLKA_RS_RESERVED(ia_rp)) {
8928 error = daplka_common_ioctl(cmd, rnum, arg, mode, cred, rvalp);
8929 return (error);
8930 }
8931 if (DAPLKA_RS_TYPE(ia_rp) != DAPL_TYPE_IA) {
8932 DERR("ioctl: invalid type %d\n", DAPLKA_RS_TYPE(ia_rp));
8933 error = EINVAL;
8934 goto cleanup;
8935 }
8936 if (ia_rp->ia_pid != ddi_get_pid()) {
8937 DERR("ioctl: ia_pid %d != pid %d\n",
8938 ia_rp->ia_pid, ddi_get_pid());
8939 error = EINVAL;
8940 goto cleanup;
8941 }
8942
8943 switch (cmd & DAPL_TYPE_MASK) {
8944 case DAPL_TYPE_EVD:
8945 error = daplka_evd_ioctl(cmd, ia_rp, arg, mode, cred, rvalp);
8946 break;
8947
8948 case DAPL_TYPE_EP:
8949 error = daplka_ep_ioctl(cmd, ia_rp, arg, mode, cred, rvalp);
8950 break;
8951
8952 case DAPL_TYPE_MR:
8953 error = daplka_mr_ioctl(cmd, ia_rp, arg, mode, cred, rvalp);
8954 break;
8955
8956 case DAPL_TYPE_MW:
8957 error = daplka_mw_ioctl(cmd, ia_rp, arg, mode, cred, rvalp);
8958 break;
8959
8960 case DAPL_TYPE_PD:
8961 error = daplka_pd_ioctl(cmd, ia_rp, arg, mode, cred, rvalp);
8962 break;
8963
8964 case DAPL_TYPE_SP:
8965 error = daplka_sp_ioctl(cmd, ia_rp, arg, mode, cred, rvalp);
8966 break;
8967
8968 case DAPL_TYPE_CNO:
8969 error = daplka_cno_ioctl(cmd, ia_rp, arg, mode, cred, rvalp);
8970 break;
8971
8972 case DAPL_TYPE_MISC:
8973 error = daplka_misc_ioctl(cmd, ia_rp, arg, mode, cred, rvalp);
8974 break;
8975
8976 case DAPL_TYPE_SRQ:
8977 error = daplka_srq_ioctl(cmd, ia_rp, arg, mode, cred, rvalp);
8978 break;
8979
8980 default:
8981 DERR("ioctl: invalid dapl type = %d\n", DAPLKA_RS_TYPE(ia_rp));
8982 error = DDI_FAILURE;
8983 }
8984
8985 cleanup:;
8986 DAPLKA_RS_UNREF(ia_rp);
8987 return (error);
8988 }
8989
8990 /* ARGSUSED */
8991 static int
8992 daplka_open(dev_t *devp, int flag, int otyp, struct cred *cred)
8993 {
8994 minor_t rnum;
8995
8996 /*
8997 * Char only
8998 */
8999 if (otyp != OTYP_CHR) {
9000 return (EINVAL);
9001 }
9002
9003 /*
9004 * Only zero can be opened, clones are used for resources.
9005 */
9006 if (getminor(*devp) != DAPLKA_DRIVER_MINOR) {
9007 DERR("daplka_open: bad minor %d\n", getminor(*devp));
9008 return (ENODEV);
9009 }
9010
9011 /*
9012 * - allocate new minor number
9013 * - update devp argument to new device
9014 */
9015 if (daplka_resource_reserve(&rnum) == 0) {
9016 *devp = makedevice(getmajor(*devp), rnum);
9017 } else {
9018 return (ENOMEM);
9019 }
9020
9021 return (DDI_SUCCESS);
9022 }
9023
9024 /* ARGSUSED */
9025 static int
9026 daplka_close(dev_t dev, int flag, int otyp, struct cred *cred)
9027 {
9028 daplka_ia_resource_t *ia_rp;
9029 minor_t rnum = getminor(dev);
9030
9031 /*
9032 * Char only
9033 */
9034 if (otyp != OTYP_CHR) {
9035 return (EINVAL);
9036 }
9037 D2("daplka_close: closing rnum = %d\n", rnum);
9038 atomic_inc_32(&daplka_pending_close);
9039
9040 /*
9041 * remove from resource table.
9042 */
9043 ia_rp = (daplka_ia_resource_t *)daplka_resource_remove(rnum);
9044
9045 /*
9046 * remove the initial reference
9047 */
9048 if (ia_rp != NULL) {
9049 DAPLKA_RS_UNREF(ia_rp);
9050 }
9051 atomic_dec_32(&daplka_pending_close);
9052 return (DDI_SUCCESS);
9053 }
9054
9055
9056 /*
9057 * Resource management routines
9058 *
9059 * We start with no resource array. Each time we run out of slots, we
9060 * reallocate a new larger array and copy the pointer to the new array and
9061 * a new resource blk is allocated and added to the hash table.
9062 *
9063 * The resource control block contains:
9064 * root - array of pointer of resource blks
9065 * sz - current size of array.
9066 * len - last valid entry in array.
9067 *
9068 * A search operation based on a resource number is as follows:
9069 * index = rnum / RESOURCE_BLKSZ;
9070 * ASSERT(index < resource_block.len);
9071 * ASSERT(index < resource_block.sz);
9072 * offset = rnum % RESOURCE_BLKSZ;
9073 * ASSERT(offset >= resource_block.root[index]->base);
9074 * ASSERT(offset < resource_block.root[index]->base + RESOURCE_BLKSZ);
9075 * return resource_block.root[index]->blks[offset];
9076 *
9077 * A resource blk is freed when its used count reaches zero.
9078 */
9079
9080 /*
9081 * initializes the global resource table
9082 */
9083 static void
9084 daplka_resource_init(void)
9085 {
9086 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(daplka_resource))
9087 rw_init(&daplka_resource.daplka_rct_lock, NULL, RW_DRIVER, NULL);
9088 daplka_resource.daplka_rc_len = 0;
9089 daplka_resource.daplka_rc_sz = 0;
9090 daplka_resource.daplka_rc_cnt = 0;
9091 daplka_resource.daplka_rc_flag = 0;
9092 daplka_resource.daplka_rc_root = NULL;
9093 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(daplka_resource))
9094 }
9095
9096 /*
9097 * destroys the global resource table
9098 */
9099 static void
9100 daplka_resource_fini(void)
9101 {
9102 int i;
9103
9104 rw_enter(&daplka_resource.daplka_rct_lock, RW_WRITER);
9105 for (i = 0; i < daplka_resource.daplka_rc_len; i++) {
9106 daplka_resource_blk_t *blk;
9107 int j;
9108
9109 blk = daplka_resource.daplka_rc_root[i];
9110 if (blk == NULL) {
9111 continue;
9112 }
9113 for (j = 0; j < DAPLKA_RC_BLKSZ; j++) {
9114 if (blk->daplka_rcblk_blks[j] != NULL) {
9115 DERR("resource_fini: non-null slot %d, %p\n",
9116 j, blk->daplka_rcblk_blks[j]);
9117 }
9118 }
9119 kmem_free(blk, sizeof (*blk));
9120 daplka_resource.daplka_rc_root[i] = NULL;
9121 }
9122 if (daplka_resource.daplka_rc_root != NULL) {
9123 uint_t sz;
9124
9125 sz = daplka_resource.daplka_rc_sz *
9126 sizeof (daplka_resource_blk_t *);
9127 kmem_free(daplka_resource.daplka_rc_root, (uint_t)sz);
9128 daplka_resource.daplka_rc_root = NULL;
9129 daplka_resource.daplka_rc_len = 0;
9130 daplka_resource.daplka_rc_sz = 0;
9131 }
9132 rw_exit(&daplka_resource.daplka_rct_lock);
9133 rw_destroy(&daplka_resource.daplka_rct_lock);
9134 }
9135
9136 /*
9137 * reserves a slot in the global resource table.
9138 * this is called by the open() syscall. it is needed because
9139 * at open() time, we do not have sufficient information to
9140 * create an IA resource. the library needs to subsequently
9141 * call daplka_ia_create to insert an IA resource into this
9142 * reserved slot.
9143 */
9144 static int
9145 daplka_resource_reserve(minor_t *rnum)
9146 {
9147 int i, j, empty = -1;
9148 daplka_resource_blk_t *blk;
9149
9150 rw_enter(&daplka_resource.daplka_rct_lock, RW_WRITER);
9151 /*
9152 * Try to find an empty slot
9153 */
9154 for (i = 0; i < daplka_resource.daplka_rc_len; i++) {
9155 blk = daplka_resource.daplka_rc_root[i];
9156 if (blk != NULL && blk->daplka_rcblk_avail > 0) {
9157
9158 D3("resource_alloc: available blks %d\n",
9159 blk->daplka_rcblk_avail);
9160
9161 /*
9162 * found an empty slot in this blk
9163 */
9164 for (j = 0; j < DAPLKA_RC_BLKSZ; j++) {
9165 if (blk->daplka_rcblk_blks[j] == NULL) {
9166 *rnum = (minor_t)
9167 (j + (i * DAPLKA_RC_BLKSZ));
9168 blk->daplka_rcblk_blks[j] =
9169 (daplka_resource_t *)
9170 DAPLKA_RC_RESERVED;
9171 blk->daplka_rcblk_avail--;
9172 daplka_resource.daplka_rc_cnt++;
9173 rw_exit(&daplka_resource.
9174 daplka_rct_lock);
9175 return (0);
9176 }
9177 }
9178 } else if (blk == NULL && empty < 0) {
9179 /*
9180 * remember first empty slot
9181 */
9182 empty = i;
9183 }
9184 }
9185
9186 /*
9187 * Couldn't find anything, allocate a new blk
9188 * Do we need to reallocate the root array
9189 */
9190 if (empty < 0) {
9191 if (daplka_resource.daplka_rc_len ==
9192 daplka_resource.daplka_rc_sz) {
9193 /*
9194 * Allocate new array and copy current stuff into it
9195 */
9196 daplka_resource_blk_t **p;
9197 uint_t newsz = (uint_t)daplka_resource.daplka_rc_sz +
9198 DAPLKA_RC_BLKSZ;
9199
9200 D3("resource_alloc: increasing no. of buckets to %d\n",
9201 newsz);
9202
9203 p = kmem_zalloc(newsz * sizeof (*p), daplka_km_flags);
9204
9205 if (daplka_resource.daplka_rc_root) {
9206 uint_t oldsz;
9207
9208 oldsz = (uint_t)(daplka_resource.daplka_rc_sz *
9209 (int)sizeof (*p));
9210
9211 /*
9212 * Copy old data into new space and
9213 * free old stuff
9214 */
9215 bcopy(daplka_resource.daplka_rc_root, p, oldsz);
9216 kmem_free(daplka_resource.daplka_rc_root,
9217 oldsz);
9218 }
9219
9220 daplka_resource.daplka_rc_root = p;
9221 daplka_resource.daplka_rc_sz = (int)newsz;
9222 }
9223
9224 empty = daplka_resource.daplka_rc_len;
9225 daplka_resource.daplka_rc_len++;
9226
9227 D3("resource_alloc: daplka_rc_len %d\n",
9228 daplka_resource.daplka_rc_len);
9229 }
9230
9231 /*
9232 * Allocate a new blk
9233 */
9234 blk = kmem_zalloc(sizeof (*blk), daplka_km_flags);
9235 ASSERT(daplka_resource.daplka_rc_root[empty] == NULL);
9236 daplka_resource.daplka_rc_root[empty] = blk;
9237 blk->daplka_rcblk_avail = DAPLKA_RC_BLKSZ - 1;
9238
9239 /*
9240 * Allocate slot
9241 */
9242 *rnum = (minor_t)(empty * DAPLKA_RC_BLKSZ);
9243 blk->daplka_rcblk_blks[0] = (daplka_resource_t *)DAPLKA_RC_RESERVED;
9244 daplka_resource.daplka_rc_cnt++;
9245 rw_exit(&daplka_resource.daplka_rct_lock);
9246
9247 return (0);
9248 }
9249
9250 /*
9251 * removes resource from global resource table
9252 */
9253 static daplka_resource_t *
9254 daplka_resource_remove(minor_t rnum)
9255 {
9256 int i, j;
9257 daplka_resource_blk_t *blk;
9258 daplka_resource_t *p;
9259
9260 i = (int)(rnum / DAPLKA_RC_BLKSZ);
9261 j = (int)(rnum % DAPLKA_RC_BLKSZ);
9262
9263 rw_enter(&daplka_resource.daplka_rct_lock, RW_WRITER);
9264 if (i >= daplka_resource.daplka_rc_len) {
9265 rw_exit(&daplka_resource.daplka_rct_lock);
9266 DERR("resource_remove: invalid rnum %d\n", rnum);
9267 return (NULL);
9268 }
9269
9270 ASSERT(daplka_resource.daplka_rc_root);
9271 ASSERT(i < daplka_resource.daplka_rc_len);
9272 ASSERT(i < daplka_resource.daplka_rc_sz);
9273 blk = daplka_resource.daplka_rc_root[i];
9274 if (blk == NULL) {
9275 rw_exit(&daplka_resource.daplka_rct_lock);
9276 DERR("resource_remove: invalid rnum %d\n", rnum);
9277 return (NULL);
9278 }
9279
9280 if (blk->daplka_rcblk_blks[j] == NULL) {
9281 rw_exit(&daplka_resource.daplka_rct_lock);
9282 DERR("resource_remove: blk->daplka_rcblk_blks[j] == NULL\n");
9283 return (NULL);
9284 }
9285 p = blk->daplka_rcblk_blks[j];
9286 blk->daplka_rcblk_blks[j] = NULL;
9287 blk->daplka_rcblk_avail++;
9288 if (blk->daplka_rcblk_avail == DAPLKA_RC_BLKSZ) {
9289 /*
9290 * free this blk
9291 */
9292 kmem_free(blk, sizeof (*blk));
9293 daplka_resource.daplka_rc_root[i] = NULL;
9294 }
9295 daplka_resource.daplka_rc_cnt--;
9296 rw_exit(&daplka_resource.daplka_rct_lock);
9297
9298 if ((intptr_t)p == DAPLKA_RC_RESERVED) {
9299 return (NULL);
9300 } else {
9301 return (p);
9302 }
9303 }
9304
9305 /*
9306 * inserts resource into the slot designated by rnum
9307 */
9308 static int
9309 daplka_resource_insert(minor_t rnum, daplka_resource_t *rp)
9310 {
9311 int i, j, error = -1;
9312 daplka_resource_blk_t *blk;
9313
9314 /*
9315 * Find resource and lock it in WRITER mode
9316 * search for available resource slot
9317 */
9318
9319 i = (int)(rnum / DAPLKA_RC_BLKSZ);
9320 j = (int)(rnum % DAPLKA_RC_BLKSZ);
9321
9322 rw_enter(&daplka_resource.daplka_rct_lock, RW_WRITER);
9323 if (i >= daplka_resource.daplka_rc_len) {
9324 rw_exit(&daplka_resource.daplka_rct_lock);
9325 DERR("resource_insert: resource %d not found\n", rnum);
9326 return (-1);
9327 }
9328
9329 blk = daplka_resource.daplka_rc_root[i];
9330 if (blk != NULL) {
9331 ASSERT(i < daplka_resource.daplka_rc_len);
9332 ASSERT(i < daplka_resource.daplka_rc_sz);
9333
9334 if ((intptr_t)blk->daplka_rcblk_blks[j] == DAPLKA_RC_RESERVED) {
9335 blk->daplka_rcblk_blks[j] = rp;
9336 error = 0;
9337 } else {
9338 DERR("resource_insert: %d not reserved, blk = %p\n",
9339 rnum, blk->daplka_rcblk_blks[j]);
9340 }
9341 } else {
9342 DERR("resource_insert: resource %d not found\n", rnum);
9343 }
9344 rw_exit(&daplka_resource.daplka_rct_lock);
9345 return (error);
9346 }
9347
9348 /*
9349 * finds resource using minor device number
9350 */
9351 static daplka_resource_t *
9352 daplka_resource_lookup(minor_t rnum)
9353 {
9354 int i, j;
9355 daplka_resource_blk_t *blk;
9356 daplka_resource_t *rp;
9357
9358 /*
9359 * Find resource and lock it in READER mode
9360 * search for available resource slot
9361 */
9362
9363 i = (int)(rnum / DAPLKA_RC_BLKSZ);
9364 j = (int)(rnum % DAPLKA_RC_BLKSZ);
9365
9366 rw_enter(&daplka_resource.daplka_rct_lock, RW_READER);
9367 if (i >= daplka_resource.daplka_rc_len) {
9368 rw_exit(&daplka_resource.daplka_rct_lock);
9369 DERR("resource_lookup: resource %d not found\n", rnum);
9370 return (NULL);
9371 }
9372
9373 blk = daplka_resource.daplka_rc_root[i];
9374 if (blk != NULL) {
9375 ASSERT(i < daplka_resource.daplka_rc_len);
9376 ASSERT(i < daplka_resource.daplka_rc_sz);
9377
9378 rp = blk->daplka_rcblk_blks[j];
9379 if (rp == NULL || (intptr_t)rp == DAPLKA_RC_RESERVED) {
9380 D3("resource_lookup: %d not found, blk = %p\n",
9381 rnum, blk->daplka_rcblk_blks[j]);
9382 } else {
9383 DAPLKA_RS_REF((daplka_ia_resource_t *)rp);
9384 }
9385 } else {
9386 DERR("resource_lookup: resource %d not found\n", rnum);
9387 rp = NULL;
9388 }
9389 rw_exit(&daplka_resource.daplka_rct_lock);
9390 return (rp);
9391 }
9392
9393 /*
9394 * generic hash table implementation
9395 */
9396
9397 /*
9398 * daplka_hash_create:
9399 * initializes a hash table with the specified parameters
9400 *
9401 * input:
9402 * htblp pointer to hash table
9403 *
9404 * nbuckets number of buckets (must be power of 2)
9405 *
9406 * free_func this function is called on each hash
9407 * table element when daplka_hash_destroy
9408 * is called
9409 *
9410 * lookup_func if daplka_hash_lookup is able to find
9411 * the desired object, this function is
9412 * applied on the object before
9413 * daplka_hash_lookup returns
9414 * output:
9415 * none
9416 *
9417 * return value(s):
9418 * EINVAL nbuckets is not a power of 2
9419 * ENOMEM cannot allocate buckets
9420 * 0 success
9421 */
9422 static int
9423 daplka_hash_create(daplka_hash_table_t *htblp, uint_t nbuckets,
9424 void (*free_func)(void *), void (*lookup_func)(void *))
9425 {
9426 int i;
9427
9428 if ((nbuckets & ~(nbuckets - 1)) != nbuckets) {
9429 DERR("hash_create: nbuckets not power of 2\n");
9430 return (EINVAL);
9431 }
9432 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*htblp))
9433
9434 htblp->ht_buckets =
9435 kmem_zalloc(sizeof (daplka_hash_bucket_t) * nbuckets,
9436 daplka_km_flags);
9437 if (htblp->ht_buckets == NULL) {
9438 DERR("hash_create: cannot allocate buckets\n");
9439 return (ENOMEM);
9440 }
9441 for (i = 0; i < nbuckets; i++) {
9442 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(htblp->ht_buckets[i]))
9443 htblp->ht_buckets[i].hb_count = 0;
9444 htblp->ht_buckets[i].hb_entries = NULL;
9445 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(htblp->ht_buckets[i]))
9446 }
9447 rw_init(&htblp->ht_table_lock, NULL, RW_DRIVER, NULL);
9448 mutex_init(&htblp->ht_key_lock, NULL, MUTEX_DRIVER, NULL);
9449
9450 htblp->ht_count = 0;
9451 htblp->ht_next_hkey = (uint64_t)gethrtime();
9452 htblp->ht_nbuckets = nbuckets;
9453 htblp->ht_free_func = free_func;
9454 htblp->ht_lookup_func = lookup_func;
9455 htblp->ht_initialized = B_TRUE;
9456 D3("hash_create: done, buckets = %d\n", nbuckets);
9457 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*htblp))
9458 return (0);
9459 }
9460
9461 /*
9462 * daplka_hash_insert:
9463 * inserts an object into a hash table
9464 *
9465 * input:
9466 * htblp pointer to hash table
9467 *
9468 * hkeyp pointer to hash key.
9469 * *hkeyp being non-zero means that the caller
9470 * has generated its own hkey. if *hkeyp is zero,
9471 * this function will generate an hkey for the
9472 * caller. it is recommended that the caller
9473 * leave the hkey generation to this function
9474 * because the hkey is more likely to be evenly
9475 * distributed.
9476 *
9477 * objp pointer to object to be inserted into
9478 * hash table
9479 *
9480 * output:
9481 * hkeyp the generated hkey is returned via this pointer
9482 *
9483 * return value(s):
9484 * EINVAL invalid parameter
9485 * ENOMEM cannot allocate hash entry
9486 * 0 successful
9487 */
9488 static int
9489 daplka_hash_insert(daplka_hash_table_t *htblp, uint64_t *hkeyp, void *objp)
9490 {
9491 daplka_hash_entry_t *hep, *curr_hep;
9492 daplka_hash_bucket_t *hbp;
9493 uint32_t bucket;
9494 uint64_t hkey;
9495
9496 if (hkeyp == NULL) {
9497 DERR("hash_insert: hkeyp == NULL\n");
9498 return (EINVAL);
9499 }
9500 hep = kmem_zalloc(sizeof (*hep), daplka_km_flags);
9501 if (hep == NULL) {
9502 DERR("hash_insert: cannot alloc hash_entry\n");
9503 return (ENOMEM);
9504 }
9505 if (*hkeyp == 0) {
9506 /* generate a new key */
9507 mutex_enter(&htblp->ht_key_lock);
9508 hkey = ++htblp->ht_next_hkey;
9509 if (hkey == 0) {
9510 hkey = htblp->ht_next_hkey = (uint64_t)gethrtime();
9511 }
9512 mutex_exit(&htblp->ht_key_lock);
9513 } else {
9514 /* use user generated key */
9515 hkey = *hkeyp;
9516 }
9517
9518 /* only works if ht_nbuckets is a power of 2 */
9519 bucket = (uint32_t)(hkey & (htblp->ht_nbuckets - 1));
9520 ASSERT(objp != NULL);
9521 ASSERT(bucket < htblp->ht_nbuckets);
9522
9523 rw_enter(&htblp->ht_table_lock, RW_WRITER);
9524 hep->he_hkey = hkey;
9525 hep->he_objp = objp;
9526
9527 /* look for duplicate entries */
9528 hbp = &htblp->ht_buckets[bucket];
9529 curr_hep = hbp->hb_entries;
9530 while (curr_hep != NULL) {
9531 if (curr_hep->he_hkey == hep->he_hkey) {
9532 break;
9533 }
9534 curr_hep = curr_hep->he_next;
9535 }
9536 if (curr_hep != NULL) {
9537 DERR("hash_insert: found duplicate hash entry: "
9538 "bucket %d, hkey 0x%016llx\n",
9539 bucket, (longlong_t)hep->he_hkey);
9540 kmem_free(hep, sizeof (*hep));
9541 rw_exit(&htblp->ht_table_lock);
9542 return (EINVAL);
9543 }
9544 hep->he_next = hbp->hb_entries;
9545 hbp->hb_entries = hep;
9546 hbp->hb_count++;
9547 htblp->ht_count++;
9548 rw_exit(&htblp->ht_table_lock);
9549
9550 if (*hkeyp == 0) {
9551 *hkeyp = hkey;
9552 ASSERT(*hkeyp != 0);
9553 }
9554 D3("hash_insert: htblp 0x%p, hkey = 0x%016llx, bucket = %d\n",
9555 htblp, (longlong_t)*hkeyp, bucket);
9556 return (0);
9557 }
9558
9559 /*
9560 * daplka_hash_remove:
9561 * removes object identified by hkey from hash table
9562 *
9563 * input:
9564 * htblp pointer to hash table
9565 *
9566 * hkey hkey that identifies the object to be removed
9567 *
9568 * output:
9569 * objpp pointer to pointer to object.
9570 * if remove is successful, the removed object
9571 * will be returned via *objpp.
9572 *
9573 * return value(s):
9574 * EINVAL cannot find hash entry
9575 * 0 successful
9576 */
9577 static int
9578 daplka_hash_remove(daplka_hash_table_t *htblp, uint64_t hkey, void **objpp)
9579 {
9580 daplka_hash_entry_t *free_hep, **curr_hepp;
9581 daplka_hash_bucket_t *hbp;
9582 uint32_t bucket;
9583
9584 bucket = (uint32_t)(hkey & (htblp->ht_nbuckets - 1));
9585
9586 rw_enter(&htblp->ht_table_lock, RW_WRITER);
9587 hbp = &htblp->ht_buckets[bucket];
9588
9589 curr_hepp = &hbp->hb_entries;
9590 while (*curr_hepp != NULL) {
9591 if ((*curr_hepp)->he_hkey == hkey) {
9592 break;
9593 }
9594 curr_hepp = &(*curr_hepp)->he_next;
9595 }
9596 if (*curr_hepp == NULL) {
9597 DERR("hash_remove: cannot find hash entry: "
9598 "bucket %d, hkey 0x%016llx\n", bucket, (longlong_t)hkey);
9599 rw_exit(&htblp->ht_table_lock);
9600 return (EINVAL);
9601 } else {
9602 if (objpp != NULL) {
9603 *objpp = (*curr_hepp)->he_objp;
9604 }
9605 free_hep = *curr_hepp;
9606 *curr_hepp = (*curr_hepp)->he_next;
9607 kmem_free(free_hep, sizeof (*free_hep));
9608 }
9609 hbp->hb_count--;
9610 htblp->ht_count--;
9611 D3("hash_remove: removed entry, hkey 0x%016llx, bucket %d, "
9612 "hb_count %d, hb_count %d\n",
9613 (longlong_t)hkey, bucket, hbp->hb_count, htblp->ht_count);
9614 rw_exit(&htblp->ht_table_lock);
9615 return (0);
9616 }
9617
9618 /*
9619 * daplka_hash_walk:
9620 * walks through the entire hash table. applying func on each of
9621 * the inserted objects. stops walking if func returns non-zero.
9622 *
9623 * input:
9624 * htblp pointer to hash table
9625 *
9626 * func function to be applied on each object
9627 *
9628 * farg second argument to func
9629 *
9630 * lockmode can be RW_WRITER or RW_READER. this
9631 * allows the caller to choose what type
9632 * of lock to acquire before walking the
9633 * table.
9634 *
9635 * output:
9636 * none
9637 *
9638 * return value(s):
9639 * none
9640 */
9641 static void
9642 daplka_hash_walk(daplka_hash_table_t *htblp, int (*func)(void *, void *),
9643 void *farg, krw_t lockmode)
9644 {
9645 daplka_hash_entry_t *curr_hep;
9646 daplka_hash_bucket_t *hbp;
9647 uint32_t bucket, retval = 0;
9648
9649 ASSERT(lockmode == RW_WRITER || lockmode == RW_READER);
9650
9651 /* needed for warlock */
9652 if (lockmode == RW_WRITER) {
9653 rw_enter(&htblp->ht_table_lock, RW_WRITER);
9654 } else {
9655 rw_enter(&htblp->ht_table_lock, RW_READER);
9656 }
9657 for (bucket = 0; bucket < htblp->ht_nbuckets && retval == 0; bucket++) {
9658 hbp = &htblp->ht_buckets[bucket];
9659 curr_hep = hbp->hb_entries;
9660 while (curr_hep != NULL) {
9661 retval = (*func)(curr_hep->he_objp, farg);
9662 if (retval != 0) {
9663 break;
9664 }
9665 curr_hep = curr_hep->he_next;
9666 }
9667 }
9668 rw_exit(&htblp->ht_table_lock);
9669 }
9670
9671 /*
9672 * daplka_hash_lookup:
9673 * finds object from hkey
9674 *
9675 * input:
9676 * htblp pointer to hash table
9677 *
9678 * hkey hkey that identifies the object to be looked up
9679 *
9680 * output:
9681 * none
9682 *
9683 * return value(s):
9684 * NULL if not found
9685 * object pointer if found
9686 */
9687 static void *
9688 daplka_hash_lookup(daplka_hash_table_t *htblp, uint64_t hkey)
9689 {
9690 daplka_hash_entry_t *curr_hep;
9691 uint32_t bucket;
9692 void *objp;
9693
9694 bucket = (uint32_t)(hkey & (htblp->ht_nbuckets - 1));
9695
9696 rw_enter(&htblp->ht_table_lock, RW_READER);
9697 curr_hep = htblp->ht_buckets[bucket].hb_entries;
9698 while (curr_hep != NULL) {
9699 if (curr_hep->he_hkey == hkey) {
9700 break;
9701 }
9702 curr_hep = curr_hep->he_next;
9703 }
9704 if (curr_hep == NULL) {
9705 DERR("hash_lookup: cannot find hash entry: "
9706 "bucket %d, hkey 0x%016llx\n", bucket, (longlong_t)hkey);
9707 rw_exit(&htblp->ht_table_lock);
9708 return (NULL);
9709 }
9710 objp = curr_hep->he_objp;
9711 ASSERT(objp != NULL);
9712 if (htblp->ht_lookup_func != NULL) {
9713 (*htblp->ht_lookup_func)(objp);
9714 }
9715 rw_exit(&htblp->ht_table_lock);
9716 return (objp);
9717 }
9718
9719 /*
9720 * daplka_hash_destroy:
9721 * destroys hash table. applies free_func on all inserted objects.
9722 *
9723 * input:
9724 * htblp pointer to hash table
9725 *
9726 * output:
9727 * none
9728 *
9729 * return value(s):
9730 * none
9731 */
9732 static void
9733 daplka_hash_destroy(daplka_hash_table_t *htblp)
9734 {
9735 daplka_hash_entry_t *curr_hep, *free_hep;
9736 daplka_hash_entry_t *free_list = NULL;
9737 daplka_hash_bucket_t *hbp;
9738 uint32_t bucket, cnt, total = 0;
9739
9740 if (!htblp->ht_initialized) {
9741 DERR("hash_destroy: not initialized\n");
9742 return;
9743 }
9744 /* free all elements from hash table */
9745 rw_enter(&htblp->ht_table_lock, RW_WRITER);
9746 for (bucket = 0; bucket < htblp->ht_nbuckets; bucket++) {
9747 hbp = &htblp->ht_buckets[bucket];
9748
9749 /* build list of elements to be freed */
9750 curr_hep = hbp->hb_entries;
9751 cnt = 0;
9752 while (curr_hep != NULL) {
9753 cnt++;
9754 free_hep = curr_hep;
9755 curr_hep = curr_hep->he_next;
9756
9757 free_hep->he_next = free_list;
9758 free_list = free_hep;
9759 }
9760 ASSERT(cnt == hbp->hb_count);
9761 total += cnt;
9762 hbp->hb_count = 0;
9763 hbp->hb_entries = NULL;
9764 }
9765 ASSERT(total == htblp->ht_count);
9766 D3("hash_destroy: htblp 0x%p, nbuckets %d, freed %d hash entries\n",
9767 htblp, htblp->ht_nbuckets, total);
9768 rw_exit(&htblp->ht_table_lock);
9769
9770 /* free all objects, now without holding the hash table lock */
9771 cnt = 0;
9772 while (free_list != NULL) {
9773 cnt++;
9774 free_hep = free_list;
9775 free_list = free_list->he_next;
9776 if (htblp->ht_free_func != NULL) {
9777 (*htblp->ht_free_func)(free_hep->he_objp);
9778 }
9779 kmem_free(free_hep, sizeof (*free_hep));
9780 }
9781 ASSERT(total == cnt);
9782
9783 /* free hash buckets and destroy locks */
9784 kmem_free(htblp->ht_buckets,
9785 sizeof (daplka_hash_bucket_t) * htblp->ht_nbuckets);
9786
9787 rw_enter(&htblp->ht_table_lock, RW_WRITER);
9788 htblp->ht_buckets = NULL;
9789 htblp->ht_count = 0;
9790 htblp->ht_nbuckets = 0;
9791 htblp->ht_free_func = NULL;
9792 htblp->ht_lookup_func = NULL;
9793 htblp->ht_initialized = B_FALSE;
9794 rw_exit(&htblp->ht_table_lock);
9795
9796 mutex_destroy(&htblp->ht_key_lock);
9797 rw_destroy(&htblp->ht_table_lock);
9798 }
9799
9800 /*
9801 * daplka_hash_getsize:
9802 * return the number of objects in hash table
9803 *
9804 * input:
9805 * htblp pointer to hash table
9806 *
9807 * output:
9808 * none
9809 *
9810 * return value(s):
9811 * number of objects in hash table
9812 */
9813 static uint32_t
9814 daplka_hash_getsize(daplka_hash_table_t *htblp)
9815 {
9816 uint32_t sz;
9817
9818 rw_enter(&htblp->ht_table_lock, RW_READER);
9819 sz = htblp->ht_count;
9820 rw_exit(&htblp->ht_table_lock);
9821
9822 return (sz);
9823 }
9824
9825 /*
9826 * this function is used as ht_lookup_func above when lookup is called.
9827 * other types of objs may use a more elaborate lookup_func.
9828 */
9829 static void
9830 daplka_hash_generic_lookup(void *obj)
9831 {
9832 daplka_resource_t *rp = (daplka_resource_t *)obj;
9833
9834 mutex_enter(&rp->rs_reflock);
9835 rp->rs_refcnt++;
9836 ASSERT(rp->rs_refcnt != 0);
9837 mutex_exit(&rp->rs_reflock);
9838 }
9839
9840 /*
9841 * Generates a non-zero 32 bit hash key used for the timer hash table.
9842 */
9843 static uint32_t
9844 daplka_timer_hkey_gen()
9845 {
9846 uint32_t new_hkey;
9847
9848 do {
9849 new_hkey = atomic_inc_32_nv(&daplka_timer_hkey);
9850 } while (new_hkey == 0);
9851
9852 return (new_hkey);
9853 }
9854
9855
9856 /*
9857 * The DAPL KA debug logging routines
9858 */
9859
9860 /*
9861 * Add the string str to the end of the debug log, followed by a newline.
9862 */
9863 static void
9864 daplka_dbglog(char *str)
9865 {
9866 size_t length;
9867 size_t remlen;
9868
9869 /*
9870 * If this is the first time we've written to the log, initialize it.
9871 */
9872 if (!daplka_dbginit) {
9873 return;
9874 }
9875 mutex_enter(&daplka_dbglock);
9876 /*
9877 * Note the log is circular; if this string would run over the end,
9878 * we copy the first piece to the end and then the last piece to
9879 * the beginning of the log.
9880 */
9881 length = strlen(str);
9882
9883 remlen = (size_t)sizeof (daplka_dbgbuf) - daplka_dbgnext - 1;
9884
9885 if (length > remlen) {
9886 if (remlen)
9887 bcopy(str, daplka_dbgbuf + daplka_dbgnext, remlen);
9888 daplka_dbgbuf[sizeof (daplka_dbgbuf) - 1] = (char)NULL;
9889 str += remlen;
9890 length -= remlen;
9891 daplka_dbgnext = 0;
9892 }
9893 bcopy(str, daplka_dbgbuf + daplka_dbgnext, length);
9894 daplka_dbgnext += length;
9895
9896 if (daplka_dbgnext >= sizeof (daplka_dbgbuf))
9897 daplka_dbgnext = 0;
9898 mutex_exit(&daplka_dbglock);
9899 }
9900
9901
9902 /*
9903 * Add a printf-style message to whichever debug logs we're currently using.
9904 */
9905 static void
9906 daplka_debug(const char *fmt, ...)
9907 {
9908 char buff[512];
9909 va_list ap;
9910 /*
9911 * The system prepends the thread id and high resolution time
9912 * (nanoseconds are dropped and so are the upper digits)
9913 * to the specified string.
9914 * The unit for timestamp is 10 microseconds.
9915 * It wraps around every 10000 seconds.
9916 * Ex: gethrtime() = X ns = X/1000 us = X/10000 10 micro sec.
9917 */
9918 int micro_time = (int)((gethrtime() / 10000) % 1000000000);
9919 (void) sprintf(buff, "th %p tm %9d: ", (void *)curthread, micro_time);
9920
9921 va_start(ap, fmt);
9922 (void) vsprintf(buff+strlen(buff), fmt, ap);
9923 va_end(ap);
9924
9925 daplka_dbglog(buff);
9926 }
9927
9928 static void
9929 daplka_console(const char *fmt, ...)
9930 {
9931 char buff[512];
9932 va_list ap;
9933
9934 va_start(ap, fmt);
9935 (void) vsprintf(buff, fmt, ap);
9936 va_end(ap);
9937
9938 cmn_err(CE_CONT, "%s", buff);
9939 }