1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
23 */
24
25 /*
26 * ibtl_impl.c
27 *
28 * This file contains the IBTF module's initialization and
29 * IBTF Clients/Modules registration routines.
30 */
31
32 #include <sys/modctl.h>
33 #include <sys/sunndi.h>
34 #include <sys/ib/ibtl/impl/ibtl.h>
35 #include <sys/ib/ibtl/impl/ibtl_ibnex.h>
36
37 /*
38 * Globals.
39 */
40 static char ibtf[] = "ibtl_impl";
41
42 extern ibtl_ibnex_callback_t ibtl_ibnex_callback_routine;
43
44 /*
45 * ibtl_clnt_list:
46 *
47 * Head of the list of IBT Client Instances. The IBT Client List
48 * is modified by IBTF on an IBT client's ibt_attach/ibt_detach call.
49 *
50 * ibtl_hca_list:
51 *
52 * Head of the list of HCA devices. The HCA List is modified by IBTF on
53 * a CI's ibc_attach/ibc_detach call.
54 * The datap of the list elements points to an ibtl_hca_devinfo_s
55 * structure.
56 *
57 * (ibc_attach)
58 * ibtl_hca_list -> ibtl_hca_devinfo_t--> ... -->ibtl_hca_devinfo_t
59 * [per-hca_dev] | ^ {nth HCA Dev}
60 * | |
61 * | ibtl_hca_t (ibt_open_hca)
62 * | ^ |
63 * | | |
64 * v | V
65 * ibtl_clnt_list -> ibtl_clnt_t--> ...--> {n'th Module}
66 * [per-client_instance] (ibt_attach)
67 *
68 */
69
70 /* Global List of IBT Client Instances, and associated mutex. */
71 struct ibtl_clnt_s *ibtl_clnt_list = NULL;
72 kmutex_t ibtl_clnt_list_mutex;
73
74 /* Lock for the race between the client and CM to free QPs. */
75 kmutex_t ibtl_free_qp_mutex;
76
77 /* Lock for the race between the client closing the HCA and QPN being freed. */
78 kcondvar_t ibtl_close_hca_cv;
79
80 /* Global List of HCA Devices, and associated mutex. */
81 struct ibtl_hca_devinfo_s *ibtl_hca_list = NULL;
82
83 /* Well-known async handlers and associated client private. */
84 ibt_async_handler_t ibtl_cm_async_handler;
85 ibt_async_handler_t ibtl_dm_async_handler;
86 ibt_async_handler_t ibtl_ibma_async_handler;
87 void *ibtl_cm_clnt_private;
88 void *ibtl_dm_clnt_private;
89 void *ibtl_ibma_clnt_private;
90
91 extern int ib_hw_status;
92 _NOTE(SCHEME_PROTECTS_DATA("Scheme protects data", ib_hw_status))
93
94 /*
95 * Misc Module Declarations.
96 */
97 extern struct mod_ops mod_miscops;
98 static struct modlmisc modlmisc = {
99 &mod_miscops, /* Type of module - misc. */
100 "IB Transport Layer" /* Name of the Module. */
101 };
102
103 static struct modlinkage modlinkage = {
104 MODREV_1, (void *)&modlmisc, NULL
105 };
106
107 static void ibtl_kstat_init(ibtl_hca_devinfo_t *);
108 static void ibtl_kstat_fini(ibtl_hca_devinfo_t *);
109 static void ibtl_kstat_stats_create(ibtl_hca_devinfo_t *, uint_t);
110 static void ibtl_kstat_pkeys_create(ibtl_hca_devinfo_t *, uint_t);
111
112 extern kmutex_t ibtl_part_attr_mutex;
113
114 /*
115 * IBTF Loadable Module Routines.
116 */
117
118 int
119 _init(void)
120 {
121 int rval;
122
123 if ((rval = mod_install(&modlinkage)) != 0)
124 return (rval);
125
126 /*
127 * initialize IBTL ib2usec table
128 */
129 ibtl_ib2usec_init();
130
131 /*
132 * Initialize Logging
133 */
134 ibtl_logging_initialization();
135
136 /*
137 * Initialize the Alloc QP States.
138 */
139 ibtl_init_cep_states();
140
141 /*
142 * Initialize all Global Link Lists.
143 */
144 mutex_init(&ibtl_clnt_list_mutex, NULL, MUTEX_DEFAULT, NULL);
145 mutex_init(&ibtl_free_qp_mutex, NULL, MUTEX_DEFAULT, NULL);
146 cv_init(&ibtl_close_hca_cv, NULL, CV_DEFAULT, NULL);
147
148 mutex_init(&ibtl_qp_mutex, NULL, MUTEX_DEFAULT, NULL);
149 cv_init(&ibtl_qp_cv, NULL, CV_DEFAULT, NULL);
150
151 mutex_init(&ibtl_part_attr_mutex, NULL, MUTEX_DEFAULT, NULL);
152
153 ibtl_thread_init();
154
155 return (rval);
156 }
157
158
159 int
160 _fini(void)
161 {
162 int rval;
163
164 if ((rval = mod_remove(&modlinkage)) != 0) {
165 return (rval);
166 }
167
168 ibtl_thread_fini();
169
170 mutex_destroy(&ibtl_clnt_list_mutex);
171 mutex_destroy(&ibtl_free_qp_mutex);
172 cv_destroy(&ibtl_close_hca_cv);
173 mutex_destroy(&ibtl_qp_mutex);
174 cv_destroy(&ibtl_qp_cv);
175 mutex_destroy(&ibtl_part_attr_mutex);
176
177 /*
178 * Stop Logging
179 */
180 ibtl_logging_destroy();
181
182 return (rval);
183 }
184
185
186 int
187 _info(struct modinfo *modinfop)
188 {
189 /* Return the Module Information. */
190 return (mod_info(&modlinkage, modinfop));
191 }
192
193
194 /*
195 * IBTF Client Registration Routines.
196 */
197
198 /*
199 * Function:
200 * ibt_attach
201 * Input:
202 * modinfop - Client Module info structure.
203 * arg - usually client's dip
204 * clnt_private - client's private data pointer.
205 * Output:
206 * ibt_hdl_p - pointer to client's specific IBT handle,
207 * which is opaque to clients.
208 * Returns:
209 * IBT_SUCCESS
210 * IBT_INVALID_PARAM
211 * Called by:
212 * IBTF Client module during its attach() to register its instance
213 * to IBTF.
214 * Description:
215 * Registers the IBTF client module instance and returns an opaque
216 * handler to the client to be used for future calls to IBTF.
217 * Adds this client module instance to ibtl_clnt_list list.
218 * Records well-known async handlers.
219 */
220 ibt_status_t
221 ibt_attach(ibt_clnt_modinfo_t *mod_infop, dev_info_t *arg, void *clnt_private,
222 ibt_clnt_hdl_t *ibt_hdl_p)
223 {
224 dev_info_t *pdip;
225 ibtl_clnt_t *clntp;
226
227 IBTF_DPRINTF_L3(ibtf, "ibt_attach(%p, %p, %p)",
228 mod_infop, arg, clnt_private);
229
230 if (mod_infop->mi_clnt_name == NULL) {
231 IBTF_DPRINTF_L1(ibtf, "ibt_attach: "
232 "IB client needs to specify its name");
233 return (IBT_INVALID_PARAM);
234 }
235
236 /*
237 * Validate the Transport API version.
238 */
239 if (mod_infop->mi_ibt_version != IBTI_V_CURR) {
240 IBTF_DPRINTF_L1(ibtf, "ibt_attach: IB client '%s' has an "
241 "invalid IB TI Version '%d'", mod_infop->mi_clnt_name,
242 mod_infop->mi_ibt_version);
243 return (IBT_NOT_SUPPORTED);
244 }
245
246 if (mod_infop->mi_async_handler == NULL) {
247 IBTF_DPRINTF_L2(ibtf, "ibt_attach: Client '%s' has not\n"
248 " provided an Asynchronous Event Handler.\n"
249 " This will be required soon.",
250 mod_infop->mi_clnt_name);
251 }
252
253 /*
254 * Check out Client's Class information. If it is not of mgmt class,
255 * we expect 'arg' to be Not NULL and point to client driver's
256 * device info struct.
257 */
258 if ((!IBT_MISCMOD_CLIENTS(mod_infop->mi_clnt_class)) &&
259 (arg == NULL)) {
260 IBTF_DPRINTF_L1(ibtf, "ibt_attach: "
261 "arg not set with driver's dip.");
262 return (IBT_INVALID_PARAM);
263 }
264
265 if (!IBT_MISCMOD_CLIENTS(mod_infop->mi_clnt_class)) {
266 pdip = ddi_get_parent(arg);
267 if (pdip == NULL ||
268 ibtl_ibnex_valid_hca_parent(pdip) != IBT_SUCCESS) {
269 IBTF_DPRINTF_L2(ibtf, "ibt_attach: "
270 "client %s is not a child of IB nexus driver.",
271 ddi_driver_name(arg));
272 return (IBT_INVALID_PARAM);
273 }
274 }
275
276 mutex_enter(&ibtl_clnt_list_mutex);
277 if (mod_infop->mi_clnt_class == IBT_CM) {
278 if (ibtl_cm_async_handler != NULL) {
279 IBTF_DPRINTF_L1(ibtf, "ibt_attach: "
280 "CM is already attached.");
281 mutex_exit(&ibtl_clnt_list_mutex);
282 return (IBT_INVALID_PARAM);
283 }
284 ibtl_cm_async_handler = mod_infop->mi_async_handler;
285 ibtl_cm_clnt_private = clnt_private;
286 } else if (mod_infop->mi_clnt_class == IBT_DM) {
287 if (ibtl_dm_async_handler != NULL) {
288 IBTF_DPRINTF_L1(ibtf, "ibt_attach: "
289 "DM is already attached.");
290 mutex_exit(&ibtl_clnt_list_mutex);
291 return (IBT_INVALID_PARAM);
292 }
293 ibtl_dm_async_handler = mod_infop->mi_async_handler;
294 ibtl_dm_clnt_private = clnt_private;
295 } else if (mod_infop->mi_clnt_class == IBT_IBMA) {
296 if (ibtl_ibma_async_handler != NULL) {
297 IBTF_DPRINTF_L1(ibtf, "ibt_attach: "
298 "IBMF is already attached.");
299 mutex_exit(&ibtl_clnt_list_mutex);
300 return (IBT_INVALID_PARAM);
301 }
302 ibtl_ibma_async_handler = mod_infop->mi_async_handler;
303 ibtl_ibma_clnt_private = clnt_private;
304 }
305
306 /* Allocate the memory for per-client-device info structure */
307 clntp = kmem_zalloc(sizeof (ibtl_clnt_t), KM_SLEEP);
308
309 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(clntp->clnt_modinfop,
310 clntp->clnt_dip, clntp->clnt_name, clntp->clnt_async_cnt,
311 clntp->clnt_private))
312 /* Update the Client info structure */
313 clntp->clnt_modinfop = mod_infop; /* IBT Client's Mod Info */
314 clntp->clnt_private = clnt_private; /* IBT Client's private */
315 clntp->clnt_dip = arg; /* IBT Client's dip */
316 clntp->clnt_async_cnt = 0;
317 /* using a count of 7 below guarantees it is NULL terminated */
318 (void) strncpy(clntp->clnt_name, mod_infop->mi_clnt_name, 7);
319 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(clntp->clnt_modinfop,
320 clntp->clnt_dip, clntp->clnt_name, clntp->clnt_async_cnt,
321 clntp->clnt_private))
322
323 /*
324 * Update Client Device Instance List.
325 */
326 clntp->clnt_list_link = ibtl_clnt_list;
327 ibtl_clnt_list = clntp;
328 mutex_exit(&ibtl_clnt_list_mutex);
329
330 /*
331 * The ibt_hdl_p is a opaque handle which is the address of
332 * ibt_clnt_t structure passed back to the clients.
333 * The client will pass on this handle in its future calls to IBTF.
334 */
335 *ibt_hdl_p = clntp;
336
337 return (IBT_SUCCESS);
338 }
339
340
341 /*
342 * Function:
343 * ibt_detach
344 * Input:
345 * ibt_hdl - IBT Handle as returned during ibt_attach call.
346 * Output:
347 * none
348 * Returns:
349 * IBT_SUCCESS
350 * IBT_INVALID_PARAM.
351 * Called by:
352 * IBTF Client module during its detach() to de-register its instance
353 * from IBTF.
354 * Description:
355 * Deregisters the IBTF client module instance from the IBTF.
356 * All resources and any reference to this ibt_hdl will be removed.
357 */
358 ibt_status_t
359 ibt_detach(ibt_clnt_hdl_t ibt_hdl)
360 {
361 ibtl_clnt_t **clntpp;
362
363 IBTF_DPRINTF_L3(ibtf, "ibt_detach(%p)", ibt_hdl);
364
365 mutex_enter(&ibtl_clnt_list_mutex);
366 clntpp = &ibtl_clnt_list;
367 for (; *clntpp != NULL; clntpp = &(*clntpp)->clnt_list_link)
368 if (*clntpp == ibt_hdl)
369 break;
370 if (*clntpp == NULL) {
371 IBTF_DPRINTF_L1(ibtf, "ibt_detach: Client @ %p Not Found",
372 ibt_hdl);
373 mutex_exit(&ibtl_clnt_list_mutex);
374 return (IBT_INVALID_PARAM);
375 }
376
377 /*
378 * Check out whether the client has freed all its resources.
379 * If not done, then fail the detach.
380 *
381 * viz. A client has to close all the HCA they have opened,
382 * i.e. the HCA List maintained for clients has to be empty.
383 * If this list is not empty, then the client has not performed
384 * complete clean-up, so fail the detach.
385 */
386 if (ibt_hdl->clnt_hca_list != NULL) {
387 mutex_exit(&ibtl_clnt_list_mutex);
388
389 IBTF_DPRINTF_L2(ibtf, "ibt_detach: "
390 "ERROR: Client '%s' has not closed all of its HCAs",
391 ibt_hdl->clnt_modinfop->mi_clnt_name);
392 cmn_err(CE_CONT, "IBT DETACH failed: resources not yet "
393 "freed by client '%s'\n",
394 ibt_hdl->clnt_modinfop->mi_clnt_name);
395 return (IBT_HCA_RESOURCES_NOT_FREED);
396 }
397
398 if (ibt_hdl->clnt_srv_cnt != 0) {
399 mutex_exit(&ibtl_clnt_list_mutex);
400 IBTF_DPRINTF_L2(ibtf, "ibt_detach: client '%s' still has "
401 "services or subnet_notices registered",
402 ibt_hdl->clnt_modinfop->mi_clnt_name);
403 cmn_err(CE_CONT, "IBT DETACH failed: resources not yet "
404 "freed by client '%s'\n",
405 ibt_hdl->clnt_modinfop->mi_clnt_name);
406 return (IBT_HCA_RESOURCES_NOT_FREED);
407 }
408
409 /*
410 * Delete the entry of this module from the ibtl_clnt_list List.
411 */
412 *clntpp = ibt_hdl->clnt_list_link; /* remove us */
413
414 /* make sure asyncs complete before freeing */
415 ibtl_free_clnt_async_check(ibt_hdl);
416
417 if (ibt_hdl->clnt_modinfop->mi_clnt_class == IBT_CM) {
418 ibtl_cm_async_handler = NULL;
419 ibtl_cm_clnt_private = NULL;
420 } else if (ibt_hdl->clnt_modinfop->mi_clnt_class == IBT_DM) {
421 ibtl_dm_async_handler = NULL;
422 ibtl_dm_clnt_private = NULL;
423 } else if (ibt_hdl->clnt_modinfop->mi_clnt_class == IBT_IBMA) {
424 ibtl_ibma_async_handler = NULL;
425 ibtl_ibma_clnt_private = NULL;
426 }
427 mutex_exit(&ibtl_clnt_list_mutex);
428
429 /* Free up the memory of per-client info struct. */
430 kmem_free(ibt_hdl, sizeof (ibtl_clnt_t));
431
432 return (IBT_SUCCESS);
433 }
434
435 static void
436 ibtl_set_ibhw_status()
437 {
438 ib_hw_status++;
439 }
440
441 static void
442 ibtl_clear_ibhw_status()
443 {
444 ib_hw_status--;
445 }
446
447 /*
448 * Function:
449 * ibc_init
450 * Input:
451 * modlp - Pointer to IBC client module linkage structure
452 * Output:
453 * None
454 * Returns:
455 * 0 always for now
456 * Called by:
457 * CI client calls IBTF during its _init() to register HCA with
458 * Solaris I/O framework.
459 * Description:
460 * Initializes the CI clients module linkage structure with
461 * default bus_ops structure
462 */
463 int
464 ibc_init(struct modlinkage *modlp)
465 {
466 ibtl_ibnex_cb_args_t cb_args;
467
468 mutex_enter(&ibtl_clnt_list_mutex);
469 cb_args.cb_flag = IBTL_IBNEX_IBC_INIT;
470 cb_args.cb_modlp = modlp;
471 if (ibtl_ibnex_callback_routine) {
472 (void) ((*ibtl_ibnex_callback_routine)(&cb_args));
473 }
474 mutex_exit(&ibtl_clnt_list_mutex);
475 return (0);
476 }
477
478
479 /*
480 * Function:
481 * ibc_fini
482 * Input:
483 * modlp - Pointer to IBC client module linkage structure
484 * Output:
485 * None
486 * Returns:
487 * None
488 * Called by:
489 * CI client calls IBTF during its _fini() to remove HCA with
490 * Solaris I/O framework.
491 * Description:
492 * Undo what is done during ibc_init
493 */
494 void
495 ibc_fini(struct modlinkage *modlp)
496 {
497 ibtl_ibnex_cb_args_t cb_args;
498
499 mutex_enter(&ibtl_clnt_list_mutex);
500 cb_args.cb_flag = IBTL_IBNEX_IBC_FINI;
501 cb_args.cb_modlp = modlp;
502 if (ibtl_ibnex_callback_routine) {
503 (void) ((*ibtl_ibnex_callback_routine)(&cb_args));
504 }
505 mutex_exit(&ibtl_clnt_list_mutex);
506 }
507
508 /*
509 * Function:
510 * ibc_attach
511 * Input:
512 * info_p - IBC HCA Info.
513 * Output:
514 * ibc_hdl_p - IBC Client's HCA Handle.
515 * Returns:
516 * IBC_SUCCESS
517 * IBC_FAILURE
518 * Called by:
519 * CI calls IBTF during its attach() to register HCA Device with IBTF.
520 * Description:
521 * Registers the presence of HCA device by providing the HCA device info
522 * structure and provides an opaque HCA handler for future calls to this
523 * HCA device.
524 */
525 ibc_status_t
526 ibc_attach(ibc_clnt_hdl_t *ibc_hdl_p, ibc_hca_info_t *info_p)
527 {
528 ibtl_hca_devinfo_t *hca_devp;
529 uint_t nports;
530 ibt_status_t status;
531
532 IBTF_DPRINTF_L2(ibtf, "ibc_attach(%p, %p)", ibc_hdl_p, info_p);
533
534 /* Validate the Transport API version */
535 if (info_p->hca_ci_vers != IBCI_V4) {
536 IBTF_DPRINTF_L1(ibtf, "ibc_attach: Invalid IB CI Version '%d'",
537 info_p->hca_ci_vers);
538 return (IBC_FAILURE);
539 }
540
541 if (info_p->hca_attr == NULL) {
542 IBTF_DPRINTF_L1(ibtf, "ibc_attach: "
543 "HCA Attributes must be specified.");
544 return (IBC_FAILURE);
545 }
546
547 nports = info_p->hca_attr->hca_nports;
548 if (nports == 0) {
549 IBTF_DPRINTF_L1(ibtf, "ibc_attach: "
550 "Number of ports must be valid");
551 return (IBC_FAILURE);
552 }
553
554 if (info_p->hca_attr->hca_max_port_pkey_tbl_sz == 0) {
555 IBTF_DPRINTF_L1(ibtf, "ibc_attach: "
556 "Number of Partitions must be at least 1");
557 return (IBC_FAILURE);
558 }
559
560 if ((info_p->hca_attr->hca_flags & IBT_HCA_CURRENT_QP_STATE) == 0) {
561 IBTF_DPRINTF_L1(ibtf, "ibc_attach: "
562 "HCA driver must support QP current state checking");
563 return (IBC_FAILURE);
564 }
565
566 if ((info_p->hca_attr->hca_flags & IBT_HCA_PORT_UP) == 0) {
567 IBTF_DPRINTF_L1(ibtf, "ibc_attach: "
568 "HCA driver must support PORT_UP async events");
569 return (IBC_FAILURE);
570 }
571
572 /*
573 * Install IB nexus driver (if not installed already)
574 */
575 ibtl_set_ibhw_status();
576 if (ndi_devi_config_vhci("ib", 0) == NULL) {
577 IBTF_DPRINTF_L2(ibtf, "ibc_attach: IB nexus attach failed");
578 ibtl_clear_ibhw_status();
579 return (IBC_FAILURE);
580 }
581
582 ibtl_thread_init2();
583
584 /* Allocate the memory for per-client info structure */
585 hca_devp = kmem_zalloc(sizeof (ibtl_hca_devinfo_t) +
586 (nports - 1) * sizeof (ibtl_async_port_event_t), KM_SLEEP);
587
588 mutex_enter(&ibtl_clnt_list_mutex);
589
590 /* Update HCA dev info structure */
591 hca_devp->hd_ibc_hca_hdl = info_p->hca_handle;
592 hca_devp->hd_ibc_ops = info_p->hca_ops;
593 hca_devp->hd_hca_attr = info_p->hca_attr;
594 hca_devp->hd_hca_dip = info_p->hca_attr->hca_dip;
595
596 status = ibtl_init_hca_portinfo(hca_devp);
597 if (status != IBT_SUCCESS) {
598 mutex_exit(&ibtl_clnt_list_mutex);
599 IBTF_DPRINTF_L1(ibtf, "ibc_attach: call to ibc_query_hca_ports "
600 "failed: status = %d", status);
601 kmem_free(hca_devp, sizeof (ibtl_hca_devinfo_t) +
602 (nports - 1) * sizeof (ibtl_async_port_event_t));
603 return (IBC_FAILURE);
604 }
605
606 /* Register the with MPxIO as PHCI */
607 if (ibtl_ibnex_phci_register(hca_devp->hd_hca_dip) != IBT_SUCCESS) {
608 mutex_exit(&ibtl_clnt_list_mutex);
609 IBTF_DPRINTF_L1(ibtf, "ibc_attach: MPxIO register failed");
610 kmem_free(hca_devp, sizeof (ibtl_hca_devinfo_t) +
611 (nports - 1) * sizeof (ibtl_async_port_event_t));
612 return (IBC_FAILURE);
613 }
614
615 /* Initialize the Client List for this HCA. */
616 hca_devp->hd_state = IBTL_HCA_DEV_ATTACHED;
617
618 /* lock out asyncs until after we announce the new HCA */
619 hca_devp->hd_async_busy = 1;
620
621 cv_init(&hca_devp->hd_async_task_cv, NULL, CV_DEFAULT, NULL);
622 cv_init(&hca_devp->hd_async_busy_cv, NULL, CV_DEFAULT, NULL);
623
624 /* init portinfo locking variables */
625 hca_devp->hd_portinfo_locked_port = 0;
626 cv_init(&hca_devp->hd_portinfo_cv, NULL, CV_DEFAULT, NULL);
627
628 ibtl_kstat_init(hca_devp);
629
630 mutex_exit(&ibtl_clnt_list_mutex);
631
632 /*
633 * The ibc_hdl_p points to an opaque handle which is the address
634 * of ibt_hca_devinfo_t structure passed back to the CI.
635 * The CI will pass on this handle in its future upcalls to IBTF.
636 */
637 *ibc_hdl_p = hca_devp;
638
639 return (IBC_SUCCESS);
640 }
641
642
643 /*
644 * Function:
645 * ibc_post_attach
646 * Input:
647 * ibc_hdl - IBC Client's HCA Handle.
648 * Returns:
649 * none
650 * Called by:
651 * CI calls IBTF during its attach() after a successful ibc_attach().
652 * Description:
653 * Announces to all known clients the existence of this HCA (by GUID).
654 */
655 void
656 ibc_post_attach(ibc_clnt_hdl_t ibc_hdl)
657 {
658 IBTF_DPRINTF_L2(ibtf, "ibc_post_attach(%p)", ibc_hdl);
659
660 /*
661 * Update the HCA Device List.
662 */
663 mutex_enter(&ibtl_clnt_list_mutex);
664 ibc_hdl->hd_hca_dev_link = ibtl_hca_list;
665 ibtl_hca_list = ibc_hdl;
666 mutex_exit(&ibtl_clnt_list_mutex);
667
668 /* notify all IBT Client Device Instances of the new HCA Device */
669 ibtl_announce_new_hca(ibc_hdl);
670 }
671
672
673 /*
674 * Function:
675 * ibc_pre_detach
676 * Input:
677 * ibc_clnt_hdl - IBC HCA Handle as returned during ibc_attach call.
678 * cmd - DDI_DETACH/DDI_SUSPEND command.
679 * Output:
680 * none
681 * Returns:
682 * IBC_SUCCESS
683 * IBC_FAILURE.
684 * Called by:
685 * CI to try to get all IBTF clients to close the HCA device.
686 * Description:
687 * Attempts to deregister the HCA device entry from the IBTF.
688 * If all resources are freed by the IBTF clients and this HCA
689 * is closed, then IBC_SUCCESS is returned.
690 */
691 ibc_status_t
692 ibc_pre_detach(ibc_clnt_hdl_t hca_devp, ddi_detach_cmd_t cmd)
693 {
694 ibtl_hca_devinfo_t **hcapp, *hcap;
695
696 IBTF_DPRINTF_L2(ibtf, "ibc_pre_detach(%p, 0x%x)", hca_devp, cmd);
697
698 /*
699 * Return failure, if command is not DDI_DETACH
700 */
701 switch (cmd) {
702 case DDI_DETACH:
703 break;
704 default:
705 return (IBC_FAILURE); /* TBD: DDI_FAILURE */
706 }
707
708 /* Make sure this HCA is on the HCA Device List. */
709 mutex_enter(&ibtl_clnt_list_mutex);
710 hcap = ibtl_hca_list;
711 while (hcap != NULL) {
712 if (hcap == hca_devp)
713 break;
714 hcap = hcap->hd_hca_dev_link;
715 }
716 if (hcap == NULL) {
717 mutex_exit(&ibtl_clnt_list_mutex);
718 return (IBC_FAILURE);
719 }
720
721 /*
722 * Initially set the state to "Detaching".
723 */
724 hca_devp->hd_state = IBTL_HCA_DEV_DETACHING;
725
726 /*
727 * Try to detach all IBTI clients, and continue only if all
728 * of the detaches succeed.
729 */
730 if (ibtl_detach_all_clients(hca_devp)) {
731 hca_devp->hd_state = IBTL_HCA_DEV_ATTACHED; /* fix hd_state */
732 mutex_exit(&ibtl_clnt_list_mutex);
733
734 return (IBC_FAILURE);
735 }
736
737 /*
738 * Check to see if all clients closed this HCA, or not.
739 * We only succeed if all clients cooperated.
740 */
741 if (hca_devp->hd_clnt_list != NULL) {
742 hca_devp->hd_state = IBTL_HCA_DEV_ATTACHED;
743 mutex_exit(&ibtl_clnt_list_mutex);
744 IBTF_DPRINTF_L2(ibtf, "ibc_pre_detach: HCA still has attached "
745 "clients");
746 return (IBC_FAILURE);
747 }
748
749 /*
750 * mark this device as detached
751 */
752 hca_devp->hd_state = IBTL_HCA_DEV_DETACHED;
753
754 /* Delete the entry for this hca_devp from hca_head_list */
755 hcapp = &ibtl_hca_list;
756 while (*hcapp != NULL) {
757 if (*hcapp == hca_devp)
758 break;
759 hcapp = &(*hcapp)->hd_hca_dev_link;
760 }
761
762 if (ibtl_ibnex_phci_unregister(hca_devp->hd_hca_dip) != IBT_SUCCESS) {
763 hca_devp->hd_state = IBTL_HCA_DEV_ATTACHED; /* fix hd_state */
764 mutex_exit(&ibtl_clnt_list_mutex);
765 IBTF_DPRINTF_L1(ibtf, "ibc_pre_detach: PHCI unregister failed");
766 return (IBC_FAILURE);
767 }
768
769 if (*hcapp == NULL) {
770 hca_devp->hd_state = IBTL_HCA_DEV_ATTACHED; /* fix hd_state */
771 mutex_exit(&ibtl_clnt_list_mutex);
772 IBTF_DPRINTF_L1(ibtf, "ibc_pre_detach: HCA not attached");
773 return (IBC_FAILURE);
774 }
775 *hcapp = hca_devp->hd_hca_dev_link;
776 ibtl_fast_gid_cache_valid = B_FALSE; /* invalidate fast_gid_cache */
777 mutex_exit(&ibtl_clnt_list_mutex);
778
779 return (IBC_SUCCESS);
780 }
781
782 /*
783 * Function:
784 * ibc_detach
785 * Input:
786 * ibc_clnt_hdl - IBC HCA Handle as returned during ibc_attach call.
787 * Output:
788 * none
789 * Returns:
790 * None
791 * Called by:
792 * CI to detach the HCA device from IBTF.
793 * Description:
794 * Do the second step of detaching the HCA, which is required
795 * after a successful ibc_pre_detach.
796 */
797 void
798 ibc_detach(ibc_clnt_hdl_t hca_devp)
799 {
800 IBTF_DPRINTF_L2(ibtf, "ibc_detach(%p)", hca_devp);
801
802 mutex_enter(&ibtl_clnt_list_mutex);
803 if (hca_devp->hd_state != IBTL_HCA_DEV_DETACHED) {
804 mutex_exit(&ibtl_clnt_list_mutex);
805 IBTF_DPRINTF_L0(ibtf, "ibc_detach: HCA has not successfully "
806 "pre-detached");
807 return;
808 }
809
810 cv_destroy(&hca_devp->hd_async_task_cv);
811 cv_destroy(&hca_devp->hd_async_busy_cv);
812 cv_destroy(&hca_devp->hd_portinfo_cv);
813
814 kmem_free(hca_devp->hd_portinfop, hca_devp->hd_portinfo_len);
815 mutex_exit(&ibtl_clnt_list_mutex);
816
817 ibtl_kstat_fini(hca_devp);
818
819 /* Free up the memory of per-client info struct */
820 kmem_free(hca_devp, sizeof (ibtl_hca_devinfo_t) +
821 (hca_devp->hd_hca_attr->hca_nports - 1) *
822 sizeof (ibtl_async_port_event_t));
823 ibtl_clear_ibhw_status();
824 }
825
826 /*
827 * Function:
828 * ibt_ci_data_in()
829 *
830 * Input:
831 * hca_hdl HCA Handle.
832 * flags IBT_COMPLETE_ALLOC - Finish a deferred alloc.
833 * object Identifies the type object pointed to by
834 * ibt_object_handle.
835 *
836 * ibt_object_handle The handle of the object to be associated with
837 * the data in/out
838 *
839 * data_p Pointer data passed in to the CI. The buffer
840 * should be allocated by the caller.
841 *
842 * data_sz The size of the buffer pointed to by
843 * data_p.
844 * Output:
845 *
846 * Returns:
847 * IBT_SUCCESS
848 * IBT_NOT_SUPPORTED Feature not supported.
849 * IBT_INVALID_PARAM Invalid object type specified.
850 * IBT_HCA_HDL_INVALID
851 * IBT_AH_HDL_INVALID/IBT_UD_DEST_HDL_INVALID
852 * IBT_CHAN_HDL_INVALID/IBT_QP_HDL_INVALID
853 * IBT_CQ_HDL_INVALID
854 * IBT_EEC_HDL_INVALID
855 * IBT_RDD_HDL_INVALID
856 * IBT_MW_HDL_INVALID
857 * IBT_PD_HDL_INVALID
858 * IBT_SRQ_HDL_INVALID
859 *
860 * Description:
861 * Exchange CI private data for the specified CI object.
862 */
863 ibt_status_t
864 ibt_ci_data_in(ibt_hca_hdl_t hca, ibt_ci_data_flags_t flags,
865 ibt_object_type_t object, void *ibt_object_handle, void *data_p,
866 size_t data_sz)
867 {
868 ibt_status_t retval;
869 void *ci_obj_hdl;
870
871 IBTF_DPRINTF_L3(ibtf, "ibt_ci_data_in(%p, %x, %d, %p, %p, %d)",
872 hca, flags, object, ibt_object_handle, data_p, data_sz);
873
874 switch (object) {
875 case IBT_HDL_HCA:
876 ci_obj_hdl = (void *)
877 (IBTL_HCA2CIHCA(((ibt_hca_hdl_t)ibt_object_handle)));
878 break;
879
880 case IBT_HDL_CHANNEL:
881 ci_obj_hdl = (void *)
882 (IBTL_CHAN2CIQP(((ibt_channel_hdl_t)ibt_object_handle)));
883 break;
884
885 case IBT_HDL_CQ:
886 ci_obj_hdl = (void *)
887 (((ibt_cq_hdl_t)(ibt_object_handle))->cq_ibc_cq_hdl);
888 break;
889
890 case IBT_HDL_EEC:
891 ci_obj_hdl = (void *)
892 (((ibt_eec_hdl_t)(ibt_object_handle))->eec_ibc_eec_hdl);
893 break;
894
895 case IBT_HDL_UD_DEST:
896 ci_obj_hdl = (void *)
897 (((ibt_ud_dest_hdl_t)(ibt_object_handle))->ud_ah);
898 break;
899
900 case IBT_HDL_SRQ:
901 ci_obj_hdl = (void *)
902 (((ibt_srq_hdl_t)(ibt_object_handle))->srq_ibc_srq_hdl);
903 break;
904
905 default:
906 ci_obj_hdl = ibt_object_handle;
907 break;
908 }
909
910 retval = (IBTL_HCA2CIHCAOPS_P(hca)->ibc_ci_data_in)(IBTL_HCA2CIHCA(hca),
911 flags, object, ci_obj_hdl, data_p, data_sz);
912
913 if (retval != IBT_SUCCESS) {
914 IBTF_DPRINTF_L2(ibtf, "ibt_ci_data_in: Failed : %d", retval);
915 }
916 return (retval);
917 }
918
919 /*
920 * Function:
921 * ibt_ci_data_out()
922 *
923 * Input:
924 * hca_hdl HCA Handle.
925 * flags IBT_COMPLETE_ALLOC - Finish a deferred alloc.
926 * object Identifies the type object pointed to by
927 * ibt_object_handle.
928 *
929 * ibt_object_handle The handle of the object to be associated with
930 * the data in/out
931 *
932 * data_p Pointer to a buffer in which to return the CI
933 * private data. The buffer should be allocated
934 * by the caller.
935 *
936 * data_sz The size of the buffer pointed to by
937 * data_p.
938 * Output:
939 *
940 * Returns:
941 * IBT_SUCCESS
942 * IBT_NOT_SUPPORTED Feature not supported.
943 * IBT_INSUFF_RESOURCE The buffer pointed to by data_p was too
944 * small to hold the data.
945 * IBT_INVALID_PARAM Invalid object type specified.
946 * IBT_HCA_HDL_INVALID
947 * IBT_AH_HDL_INVALID/IBT_UD_DEST_HDL_INVALID
948 * IBT_CHAN_HDL_INVALID/IBT_QP_HDL_INVALID
949 * IBT_CQ_HDL_INVALID
950 * IBT_EEC_HDL_INVALID
951 * IBT_RDD_HDL_INVALID
952 * IBT_MW_HDL_INVALID
953 * IBT_PD_HDL_INVALID
954 * IBT_SRQ_HDL_INVALID
955 *
956 * Description:
957 * Exchange CI private data for the specified CI object.
958 */
959 ibt_status_t
960 ibt_ci_data_out(ibt_hca_hdl_t hca, ibt_ci_data_flags_t flags,
961 ibt_object_type_t object, void *ibt_object_handle, void *data_p,
962 size_t data_sz)
963 {
964 ibt_status_t retval;
965 void *ci_obj_hdl;
966
967 IBTF_DPRINTF_L3(ibtf, "ibt_ci_data_out(%p, %x, %d, %p, %p, %d)",
968 hca, flags, object, ibt_object_handle, data_p, data_sz);
969
970 switch (object) {
971 case IBT_HDL_HCA:
972 ci_obj_hdl = (void *)
973 (IBTL_HCA2CIHCA(((ibt_hca_hdl_t)ibt_object_handle)));
974 break;
975
976 case IBT_HDL_CHANNEL:
977 ci_obj_hdl = (void *)
978 (IBTL_CHAN2CIQP(((ibt_channel_hdl_t)ibt_object_handle)));
979 break;
980
981 case IBT_HDL_CQ:
982 ci_obj_hdl = (void *)
983 (((ibt_cq_hdl_t)(ibt_object_handle))->cq_ibc_cq_hdl);
984 break;
985
986 case IBT_HDL_EEC:
987 ci_obj_hdl = (void *)
988 (((ibt_eec_hdl_t)(ibt_object_handle))->eec_ibc_eec_hdl);
989 break;
990
991 case IBT_HDL_UD_DEST:
992 ci_obj_hdl = (void *)
993 (((ibt_ud_dest_hdl_t)(ibt_object_handle))->ud_ah);
994 break;
995
996 case IBT_HDL_SRQ:
997 ci_obj_hdl = (void *)
998 (((ibt_srq_hdl_t)(ibt_object_handle))->srq_ibc_srq_hdl);
999 break;
1000
1001 default:
1002 ci_obj_hdl = ibt_object_handle;
1003 break;
1004 }
1005
1006 retval = (IBTL_HCA2CIHCAOPS_P(hca)->ibc_ci_data_out)
1007 (IBTL_HCA2CIHCA(hca), flags, object, ci_obj_hdl, data_p, data_sz);
1008
1009 if (retval != IBT_SUCCESS) {
1010 IBTF_DPRINTF_L2(ibtf, "ibt_ci_data_out: Failed : %d", retval);
1011 }
1012 return (retval);
1013 }
1014
1015
1016 /*
1017 * FMA Support functions.
1018 */
1019
1020 #define IBTL_ENA_MASK 0xC0000000
1021 #define IBTL_ENA_POSSIBLE 0x80000000
1022 #define IBTL_TYPE_SHIFT 27
1023
1024 /*
1025 * Function:
1026 * ibt_get_module_failure()
1027 *
1028 * Input:
1029 * type Identifies the failing IB module.
1030 * ena '0' or the data for Fault Management
1031 * Architecture (ENA).
1032 *
1033 * Returns:
1034 * status Special IB failure status.
1035 *
1036 * Description:
1037 * XXX Just stubbed out to return failures with no data for Fault
1038 * Management Architecture (ENAs) at the moment XXX
1039 */
1040 ibt_status_t
1041 ibt_get_module_failure(ibt_failure_type_t type, uint64_t ena)
1042 {
1043 ibt_status_t ret;
1044
1045 IBTF_DPRINTF_L3(ibtf, "ibt_get_module_failure(%d, 0x%llX)", type, ena);
1046
1047 switch (type) {
1048 case IBT_FAILURE_CI:
1049 case IBT_FAILURE_IBMF:
1050 case IBT_FAILURE_IBCM:
1051 case IBT_FAILURE_IBDM:
1052 case IBT_FAILURE_IBTL:
1053 case IBT_FAILURE_IBSM:
1054 ret = IBTL_ENA_POSSIBLE | (type << IBTL_TYPE_SHIFT);
1055 break;
1056 default:
1057 ret = IBT_FAILURE;
1058 }
1059 IBTF_DPRINTF_L3(ibtf, "ibt_get_module_failure: ret = 0x%lX", ret);
1060 return (ret);
1061 }
1062
1063
1064 /*
1065 * Function:
1066 * ibc_get_ci_failure()
1067 *
1068 * Input:
1069 * ena '0' or the data for Fault Management
1070 * Architecture (ENA).
1071 *
1072 * Returns:
1073 * status Special CI failure status.
1074 *
1075 * Description:
1076 * Just use the function above to do the job.
1077 */
1078 ibt_status_t
1079 ibc_get_ci_failure(uint64_t ena)
1080 {
1081 return (ibt_get_module_failure(IBT_FAILURE_CI, ena));
1082 }
1083
1084
1085 /*
1086 * ibt_check_failure()
1087 * Function to test for special case failures.
1088 *
1089 * status An ibt_status_t returned from an IBTF function call.
1090 *
1091 * reserved_p NULL, or a pointer to where we store the data for
1092 * Fault Management Architecture (ENA).
1093 *
1094 * Description:
1095 * XXX Still need to determine the data for Fault Management Architecture
1096 * (ENA), using 0 for now XXX
1097 */
1098 ibt_failure_type_t
1099 ibt_check_failure(ibt_status_t status, uint64_t *reserved_p)
1100 {
1101 ibt_failure_type_t type;
1102
1103 IBTF_DPRINTF_L3(ibtf, "ibt_check_failure(%X)", status);
1104
1105 if ((status & IBTL_ENA_MASK) == IBTL_ENA_POSSIBLE) {
1106 type = status & ~IBTL_ENA_POSSIBLE >> IBTL_TYPE_SHIFT;
1107
1108 /* XXX Need more work here... */
1109 if (reserved_p != NULL)
1110 *reserved_p = 0;
1111 } else {
1112 type = IBT_FAILURE_STANDARD;
1113 if (reserved_p != NULL)
1114 *reserved_p = 0; /* No FMA Data Available. */
1115 }
1116 IBTF_DPRINTF_L3(ibtf, "ibt_check_failure: type = 0x%X", type);
1117 return (type);
1118 }
1119
1120 /*
1121 * Initialize and create kstats.
1122 *
1123 * We create the following kstats on all ports of the HCA:
1124 * <hca_driver_name><instance_number>/port<port_num>/stats
1125 * <hca_driver_name><instance_number>/port<port_num>/pkeys
1126 */
1127 static void
1128 ibtl_kstat_init(ibtl_hca_devinfo_t *hca_devp)
1129 {
1130 uint_t nports = hca_devp->hd_hca_attr->hca_nports;
1131 ibtl_hca_port_kstat_t *pks;
1132 int i;
1133
1134 IBTF_DPRINTF_L3(ibtf, "ibtl_kstat_init(hca_devp = 0x%p)", hca_devp);
1135
1136 hca_devp->hd_hca_port_ks_info_len =
1137 sizeof (ibtl_hca_port_kstat_t) * nports;
1138 pks = kmem_zalloc(hca_devp->hd_hca_port_ks_info_len, KM_SLEEP);
1139 hca_devp->hd_hca_port_ks_info = pks;
1140
1141 for (i = 0; i < nports; i++, pks++) {
1142 pks->pks_hca_devp = hca_devp;
1143 pks->pks_port_num = i + 1;
1144 ibtl_kstat_stats_create(hca_devp, i + 1);
1145 ibtl_kstat_pkeys_create(hca_devp, i + 1);
1146 }
1147 }
1148
1149 /*
1150 * Delete kstats on all ports of the HCA.
1151 */
1152 static void
1153 ibtl_kstat_fini(ibtl_hca_devinfo_t *hca_devp)
1154 {
1155 ibtl_hca_port_kstat_t *pks;
1156 int i;
1157
1158 IBTF_DPRINTF_L3(ibtf, "ibtl_kstat_fini(hca_devp = 0x%p)", hca_devp);
1159
1160 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*hca_devp))
1161
1162 pks = hca_devp->hd_hca_port_ks_info;
1163 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*pks))
1164
1165 if (pks == NULL)
1166 return;
1167
1168 for (i = 0; i < hca_devp->hd_hca_attr->hca_nports; i++, pks++) {
1169 if (pks->pks_stats_ksp)
1170 kstat_delete(pks->pks_stats_ksp);
1171
1172 if (pks->pks_pkeys_ksp) {
1173 ASSERT(!MUTEX_HELD(&ibtl_clnt_list_mutex));
1174 kstat_delete(pks->pks_pkeys_ksp);
1175 }
1176 }
1177
1178 kmem_free(hca_devp->hd_hca_port_ks_info,
1179 hca_devp->hd_hca_port_ks_info_len);
1180 }
1181
1182 /*
1183 * Update "stats" kstat.
1184 * Called by kstat framework.
1185 */
1186 static int
1187 ibtl_kstat_stats_update(kstat_t *ksp, int rw)
1188 {
1189 ibtl_hca_port_kstat_t *pks;
1190 ibtl_hca_devinfo_t *hca_devp;
1191 ibt_hca_portinfo_t *p;
1192 struct kstat_named *data;
1193
1194 IBTF_DPRINTF_L4(ibtf, "ibtl_kstat_stats_update(ksp = 0x%p, rw = %d)",
1195 ksp, rw);
1196
1197 if (rw == KSTAT_WRITE)
1198 return (EACCES);
1199
1200 mutex_enter(&ibtl_clnt_list_mutex);
1201
1202 /*
1203 * Update the link_state kstat using the value from portinfo cache.
1204 */
1205 pks = ksp->ks_private;
1206 hca_devp = pks->pks_hca_devp;
1207 data = (struct kstat_named *)(ksp->ks_data);
1208 p = hca_devp->hd_portinfop + pks->pks_port_num - 1;
1209 data[0].value.ui32 = (uint32_t)p->p_linkstate;
1210
1211 mutex_exit(&ibtl_clnt_list_mutex);
1212
1213 return (0);
1214 }
1215
1216 /*
1217 * Create "stats" kstat for the specified HCA port in the form:
1218 * <hca_driver_name><instance_number>/port<port_num>/stats
1219 * At preset it contains only one named data of "link_state"
1220 */
1221 static void
1222 ibtl_kstat_stats_create(ibtl_hca_devinfo_t *hca_devp, uint_t port_num)
1223 {
1224 struct kstat *ksp;
1225 struct kstat_named *named_data;
1226 char *drv_name;
1227 int drv_instance;
1228 ibtl_hca_port_kstat_t *pks;
1229 char kname[40];
1230
1231 IBTF_DPRINTF_L3(ibtf, "ibtl_kstat_stats_create(hca_devp = 0x%p, "
1232 "port_num = 0x%u)", hca_devp, port_num);
1233
1234 drv_name = (char *)ddi_driver_name(hca_devp->hd_hca_dip);
1235 drv_instance = ddi_get_instance(hca_devp->hd_hca_dip);
1236 (void) snprintf(kname, sizeof (kname), "%s%d/port%d/stats",
1237 drv_name, drv_instance, port_num);
1238
1239 ksp = kstat_create("ibtf", 0, kname, "ib", KSTAT_TYPE_NAMED, 1, 0);
1240 if (ksp == NULL) {
1241 IBTF_DPRINTF_L2(ibtf,
1242 "ibtl_kstat_stats_create: kstat_create() failed");
1243 return;
1244 }
1245
1246 named_data = (struct kstat_named *)(ksp->ks_data);
1247 kstat_named_init(&named_data[0], "link_state", KSTAT_DATA_UINT32);
1248
1249 pks = hca_devp->hd_hca_port_ks_info + port_num - 1;
1250 pks->pks_stats_ksp = ksp;
1251
1252 ksp->ks_private = pks;
1253 ksp->ks_update = ibtl_kstat_stats_update;
1254
1255 /* Install the kstat */
1256 kstat_install(ksp);
1257 }
1258
1259 /*
1260 * Update "pkeys" kstat.
1261 *
1262 * Called by kstat framework. Since ks_lock was set to ibtl_clnt_list_mutex
1263 * at the time of the kstat creation, kstat framework will hold this lock
1264 * while calling this function.
1265 */
1266 static int
1267 ibtl_kstat_pkeys_update(kstat_t *ksp, int rw)
1268 {
1269 ibtl_hca_port_kstat_t *pks;
1270 ibtl_hca_devinfo_t *hca_devp;
1271 ibt_hca_portinfo_t *p;
1272
1273 IBTF_DPRINTF_L4(ibtf, "ibtl_kstat_pkeys_update(ksp = 0x%p, rw = %d)",
1274 ksp, rw);
1275
1276 #ifndef __lock_lint
1277 ASSERT(MUTEX_HELD(&ibtl_clnt_list_mutex));
1278 #endif
1279
1280 if (rw == KSTAT_WRITE)
1281 return (EACCES);
1282
1283 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*ksp))
1284
1285 pks = ksp->ks_private;
1286 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*pks))
1287
1288 hca_devp = pks->pks_hca_devp;
1289 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*hca_devp))
1290
1291 /*
1292 * Point kstat data to the pkey table in the portinfo cache.
1293 */
1294
1295 p = hca_devp->hd_portinfop + pks->pks_port_num - 1;
1296
1297 ksp->ks_data = p->p_pkey_tbl;
1298 ksp->ks_ndata = p->p_pkey_tbl_sz;
1299 ksp->ks_data_size = p->p_pkey_tbl_sz * sizeof (ib_pkey_t);
1300
1301 return (0);
1302 }
1303
1304 /*
1305 * Create "pkeys" kstat for the specified HCA port in the form:
1306 * <hca_driver_name><instance_number>/port<port_num>/pkeys
1307 *
1308 * Currently kstat framework allows only some fixed data types as named
1309 * data components under a named kstat. Due to this limitation it is not
1310 * possible to add "pkeys" as a named data under the "stats" kstat.
1311 */
1312 static void
1313 ibtl_kstat_pkeys_create(ibtl_hca_devinfo_t *hca_devp, uint_t port_num)
1314 {
1315 struct kstat *ksp;
1316 char *drv_name;
1317 int drv_instance;
1318 char kname[40];
1319 ibtl_hca_port_kstat_t *pks;
1320
1321 IBTF_DPRINTF_L3(ibtf, "ibtl_kstat_stats_create(hca_devp = 0x%p, "
1322 "port_num = 0x%u)", hca_devp, port_num);
1323
1324 drv_name = (char *)ddi_driver_name(hca_devp->hd_hca_dip);
1325 drv_instance = ddi_get_instance(hca_devp->hd_hca_dip);
1326 (void) snprintf(kname, sizeof (kname), "%s%d/port%d/pkeys",
1327 drv_name, drv_instance, port_num);
1328
1329 ksp = kstat_create("ibtf", 0, kname, "ib", KSTAT_TYPE_RAW, 0,
1330 KSTAT_FLAG_VAR_SIZE | KSTAT_FLAG_VIRTUAL);
1331 if (ksp == NULL) {
1332 IBTF_DPRINTF_L2(ibtf,
1333 "ibtl_kstat_pkeys_create: kstat_create() failed");
1334 return;
1335 }
1336
1337 pks = hca_devp->hd_hca_port_ks_info + port_num - 1;
1338 pks->pks_pkeys_ksp = ksp;
1339
1340 ksp->ks_private = pks;
1341 ksp->ks_update = ibtl_kstat_pkeys_update;
1342 ksp->ks_lock = &ibtl_clnt_list_mutex;
1343
1344 /*
1345 * We just go with the default_kstat_snapshot().
1346 * So there is no need to set ks_snapshot field.
1347 */
1348
1349 /* Install the kstat */
1350 kstat_install(ksp);
1351 }