xref: /illumos-gate/usr/src/uts/common/io/ib/ibtl/ibtl_impl.c (revision 6a634c9dca3093f3922e4b7ab826d7bdf17bf78e)
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
_init(void)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
_fini(void)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
_info(struct modinfo * modinfop)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
ibt_attach(ibt_clnt_modinfo_t * mod_infop,dev_info_t * arg,void * clnt_private,ibt_clnt_hdl_t * ibt_hdl_p)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
ibt_detach(ibt_clnt_hdl_t ibt_hdl)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
ibtl_set_ibhw_status()436 ibtl_set_ibhw_status()
437 {
438 	ib_hw_status++;
439 }
440 
441 static void
ibtl_clear_ibhw_status()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
ibc_init(struct modlinkage * modlp)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
ibc_fini(struct modlinkage * modlp)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
ibc_attach(ibc_clnt_hdl_t * ibc_hdl_p,ibc_hca_info_t * info_p)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
ibc_post_attach(ibc_clnt_hdl_t ibc_hdl)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
ibc_pre_detach(ibc_clnt_hdl_t hca_devp,ddi_detach_cmd_t cmd)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
ibc_detach(ibc_clnt_hdl_t hca_devp)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
ibt_ci_data_in(ibt_hca_hdl_t hca,ibt_ci_data_flags_t flags,ibt_object_type_t object,void * ibt_object_handle,void * data_p,size_t data_sz)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
ibt_ci_data_out(ibt_hca_hdl_t hca,ibt_ci_data_flags_t flags,ibt_object_type_t object,void * ibt_object_handle,void * data_p,size_t data_sz)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
ibt_get_module_failure(ibt_failure_type_t type,uint64_t ena)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
ibc_get_ci_failure(uint64_t ena)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
ibt_check_failure(ibt_status_t status,uint64_t * reserved_p)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
ibtl_kstat_init(ibtl_hca_devinfo_t * hca_devp)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
ibtl_kstat_fini(ibtl_hca_devinfo_t * hca_devp)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
ibtl_kstat_stats_update(kstat_t * ksp,int rw)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
ibtl_kstat_stats_create(ibtl_hca_devinfo_t * hca_devp,uint_t port_num)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
ibtl_kstat_pkeys_update(kstat_t * ksp,int rw)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
ibtl_kstat_pkeys_create(ibtl_hca_devinfo_t * hca_devp,uint_t port_num)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 }
1352