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
27 /*
28 * hermon_stats.c
29 * Hermon IB Performance Statistics routines
30 *
31 * Implements all the routines necessary for setting up, querying, and
32 * (later) tearing down all the kstats necessary for implementing to
33 * the interfaces necessary to provide busstat(1M) access.
34 */
35
36 #include <sys/types.h>
37 #include <sys/conf.h>
38 #include <sys/ddi.h>
39 #include <sys/sunddi.h>
40 #include <sys/modctl.h>
41
42 #include <sys/ib/adapters/hermon/hermon.h>
43
44 static kstat_t *hermon_kstat_picN_create(hermon_state_t *state, int num_pic,
45 int num_evt, hermon_ks_mask_t *ev_array);
46 static kstat_t *hermon_kstat_cntr_create(hermon_state_t *state, int num_pic,
47 int (*update)(kstat_t *, int));
48 static int hermon_kstat_cntr_update(kstat_t *ksp, int rw);
49
50 void hermon_kstat_perfcntr64_create(hermon_state_t *state, uint_t port_num);
51 static int hermon_kstat_perfcntr64_read(hermon_state_t *state, uint_t port,
52 int reset);
53 static void hermon_kstat_perfcntr64_thread_exit(hermon_ks_info_t *ksi);
54 static int hermon_kstat_perfcntr64_update(kstat_t *ksp, int rw);
55
56 /*
57 * Hermon IB Performance Events structure
58 * This structure is read-only and is used to setup the individual kstats
59 * and to initialize the tki_ib_perfcnt[] array for each Hermon instance.
60 */
61 hermon_ks_mask_t hermon_ib_perfcnt_list[HERMON_CNTR_NUMENTRIES] = {
62 {"port_xmit_data", 0, 0},
63 {"port_recv_data", 0, 0},
64 {"port_xmit_pkts", 0, 0},
65 {"port_recv_pkts", 0, 0},
66 {"port_recv_err", 0, 0},
67 {"port_xmit_discards", 0, 0},
68 {"vl15_dropped", 0, 0},
69 {"port_xmit_wait", 0, 0},
70 {"port_recv_remote_phys_err", 0, 0},
71 {"port_xmit_constraint_err", 0, 0},
72 {"port_recv_constraint_err", 0, 0},
73 {"symbol_err_counter", 0, 0},
74 {"link_err_recovery_cnt", 0, 0},
75 {"link_downed_cnt", 0, 0},
76 {"excessive_buffer_overruns", 0, 0},
77 {"local_link_integrity_err", 0, 0},
78 {"clear_pic", 0, 0}
79 };
80
81 /*
82 * Return the maximum of (x) and (y)
83 */
84 #define MAX(x, y) (((x) > (y)) ? (x) : (y))
85
86 /*
87 * Set (x) to the maximum of (x) and (y)
88 */
89 #define SET_TO_MAX(x, y) \
90 { \
91 if ((x) < (y)) \
92 (x) = (y); \
93 }
94
95 /*
96 * hermon_kstat_init()
97 * Context: Only called from attach() path context
98 */
99 int
100 hermon_kstat_init(hermon_state_t *state)
101 {
102 hermon_ks_info_t *ksi;
103 uint_t numports;
104 int i;
105
106 /* Allocate a kstat info structure */
107 ksi = (hermon_ks_info_t *)kmem_zalloc(sizeof (hermon_ks_info_t),
108 KM_SLEEP);
109 if (ksi == NULL) {
110 return (DDI_FAILURE);
111 }
112 state->hs_ks_info = ksi;
113
114 /*
115 * Create as many "pic" and perfcntr64 kstats as we have IB ports.
116 * Enable all of the events specified in the "hermon_ib_perfcnt_list"
117 * structure.
118 */
119 numports = state->hs_cfg_profile->cp_num_ports;
120 for (i = 0; i < numports; i++) {
121 ksi->hki_picN_ksp[i] = hermon_kstat_picN_create(state, i,
122 HERMON_CNTR_NUMENTRIES, hermon_ib_perfcnt_list);
123 if (ksi->hki_picN_ksp[i] == NULL) {
124 goto kstat_init_fail;
125 }
126
127 hermon_kstat_perfcntr64_create(state, i + 1);
128 if (ksi->hki_perfcntr64[i].hki64_ksp == NULL) {
129 goto kstat_init_fail;
130 }
131 }
132
133 /* Create the "counters" kstat too */
134 ksi->hki_cntr_ksp = hermon_kstat_cntr_create(state, numports,
135 hermon_kstat_cntr_update);
136 if (ksi->hki_cntr_ksp == NULL) {
137 goto kstat_init_fail;
138 }
139
140 /* Initialize the control register and initial counter values */
141 ksi->hki_pcr = 0;
142 ksi->hki_pic0 = 0;
143 ksi->hki_pic1 = 0;
144
145 /*
146 * Initialize the Hermon hki_ib_perfcnt[] array values using the
147 * default values in hermon_ib_perfcnt_list[]
148 */
149 for (i = 0; i < HERMON_CNTR_NUMENTRIES; i++) {
150 ksi->hki_ib_perfcnt[i] = hermon_ib_perfcnt_list[i];
151 }
152
153 mutex_init(&ksi->hki_perfcntr64_lock, NULL, MUTEX_DRIVER, NULL);
154 cv_init(&ksi->hki_perfcntr64_cv, NULL, CV_DRIVER, NULL);
155
156 return (DDI_SUCCESS);
157
158
159 kstat_init_fail:
160
161 /* Delete all the previously created kstats */
162 if (ksi->hki_cntr_ksp != NULL) {
163 kstat_delete(ksi->hki_cntr_ksp);
164 }
165 for (i = 0; i < numports; i++) {
166 if (ksi->hki_picN_ksp[i] != NULL) {
167 kstat_delete(ksi->hki_picN_ksp[i]);
168 }
169 if (ksi->hki_perfcntr64[i].hki64_ksp != NULL) {
170 kstat_delete(ksi->hki_perfcntr64[i].hki64_ksp);
171 }
172 }
173
174 /* Free the kstat info structure */
175 kmem_free(ksi, sizeof (hermon_ks_info_t));
176
177 return (DDI_FAILURE);
178 }
179
180
181 /*
182 * hermon_kstat_init()
183 * Context: Only called from attach() and/or detach() path contexts
184 */
185 void
186 hermon_kstat_fini(hermon_state_t *state)
187 {
188 hermon_ks_info_t *ksi;
189 uint_t numports;
190 int i;
191
192 /* Get pointer to kstat info */
193 ksi = state->hs_ks_info;
194
195 /*
196 * Signal the perfcntr64_update_thread to exit and wait until the
197 * thread exits.
198 */
199 mutex_enter(&ksi->hki_perfcntr64_lock);
200 hermon_kstat_perfcntr64_thread_exit(ksi);
201 mutex_exit(&ksi->hki_perfcntr64_lock);
202
203 /* Delete all the "pic" and perfcntr64 kstats (one per port) */
204 numports = state->hs_cfg_profile->cp_num_ports;
205 for (i = 0; i < numports; i++) {
206 if (ksi->hki_picN_ksp[i] != NULL) {
207 kstat_delete(ksi->hki_picN_ksp[i]);
208 }
209
210 if (ksi->hki_perfcntr64[i].hki64_ksp != NULL) {
211 kstat_delete(ksi->hki_perfcntr64[i].hki64_ksp);
212 }
213 }
214
215 /* Delete the "counter" kstats (one per port) */
216 kstat_delete(ksi->hki_cntr_ksp);
217
218 cv_destroy(&ksi->hki_perfcntr64_cv);
219 mutex_destroy(&ksi->hki_perfcntr64_lock);
220
221 /* Free the kstat info structure */
222 kmem_free(ksi, sizeof (hermon_ks_info_t));
223 }
224
225
226 /*
227 * hermon_kstat_picN_create()
228 * Context: Only called from attach() path context
229 */
230 static kstat_t *
231 hermon_kstat_picN_create(hermon_state_t *state, int num_pic, int num_evt,
232 hermon_ks_mask_t *ev_array)
233 {
234 kstat_t *picN_ksp;
235 struct kstat_named *pic_named_data;
236 int drv_instance, i;
237 char *drv_name;
238 char pic_name[16];
239
240 /*
241 * Create the "picN" kstat. In the steps, below we will attach
242 * all of our named event types to it.
243 */
244 drv_name = (char *)ddi_driver_name(state->hs_dip);
245 drv_instance = ddi_get_instance(state->hs_dip);
246 (void) sprintf(pic_name, "pic%d", num_pic);
247 picN_ksp = kstat_create(drv_name, drv_instance, pic_name, "bus",
248 KSTAT_TYPE_NAMED, num_evt, NULL);
249 if (picN_ksp == NULL) {
250 return (NULL);
251 }
252 pic_named_data = (struct kstat_named *)(picN_ksp->ks_data);
253
254 /*
255 * Write event names and their associated pcr masks. The last entry
256 * in the array (clear_pic) is added separately below (as its pic
257 * value must be inverted).
258 */
259 for (i = 0; i < num_evt - 1; i++) {
260 pic_named_data[i].value.ui64 =
261 ((uint64_t)i << (num_pic * HERMON_CNTR_SIZE));
262 kstat_named_init(&pic_named_data[i], ev_array[i].ks_evt_name,
263 KSTAT_DATA_UINT64);
264 }
265
266 /* Add the "clear_pic" entry */
267 pic_named_data[i].value.ui64 =
268 ~((uint64_t)HERMON_CNTR_MASK << (num_pic * HERMON_CNTR_SIZE));
269 kstat_named_init(&pic_named_data[i], ev_array[i].ks_evt_name,
270 KSTAT_DATA_UINT64);
271
272 /* Install the kstat */
273 kstat_install(picN_ksp);
274
275 return (picN_ksp);
276 }
277
278
279 /*
280 * hermon_kstat_cntr_create()
281 * Context: Only called from attach() path context
282 */
283 static kstat_t *
284 hermon_kstat_cntr_create(hermon_state_t *state, int num_pic,
285 int (*update)(kstat_t *, int))
286 {
287 struct kstat *cntr_ksp;
288 struct kstat_named *cntr_named_data;
289 int drv_instance, i;
290 char *drv_name;
291 char pic_str[16];
292
293 /*
294 * Create the "counters" kstat. In the steps, below we will attach
295 * all of our "pic" to it. Note: The size of this kstat is
296 * num_pic + 1 because it also contains the "%pcr".
297 */
298 drv_name = (char *)ddi_driver_name(state->hs_dip);
299 drv_instance = ddi_get_instance(state->hs_dip);
300 cntr_ksp = kstat_create(drv_name, drv_instance, "counters", "bus",
301 KSTAT_TYPE_NAMED, num_pic + 1, KSTAT_FLAG_WRITABLE);
302 if (cntr_ksp == NULL) {
303 return (NULL);
304 }
305 cntr_named_data = (struct kstat_named *)(cntr_ksp->ks_data);
306
307 /*
308 * Initialize the named kstats (for the "pcr" and for the
309 * individual "pic" kstats)
310 */
311 kstat_named_init(&cntr_named_data[0], "pcr", KSTAT_DATA_UINT64);
312 for (i = 0; i < num_pic; i++) {
313 (void) sprintf(pic_str, "pic%d", i);
314 kstat_named_init(&cntr_named_data[i+1], pic_str,
315 KSTAT_DATA_UINT64);
316 }
317
318 /*
319 * Store the Hermon softstate pointer in the kstat's private field so
320 * that it is available to the update function.
321 */
322 cntr_ksp->ks_private = (void *)state;
323 cntr_ksp->ks_update = update;
324
325 /* Install the kstat */
326 kstat_install(cntr_ksp);
327
328 return (cntr_ksp);
329 }
330
331
332 /*
333 * hermon_kstat_cntr_update()
334 * Context: Called from the kstat context
335 */
336 static int
337 hermon_kstat_cntr_update(kstat_t *ksp, int rw)
338 {
339 hermon_state_t *state;
340 hermon_ks_mask_t *ib_perf;
341 hermon_ks_info_t *ksi;
342 struct kstat_named *data;
343 uint64_t pcr;
344 uint32_t tmp;
345 uint32_t oldval;
346 uint_t numports, indx;
347 int status;
348 hermon_hw_sm_perfcntr_t sm_perfcntr;
349
350 /*
351 * Extract the Hermon softstate pointer, kstat data, pointer to the
352 * kstat info structure, and pointer to the hki_ib_perfcnt[] array
353 * from the input parameters. Note: For warlock purposes, these
354 * parameters are all accessed only in this routine and are,
355 * therefore, protected by the lock used by the kstat framework.
356 */
357 state = ksp->ks_private;
358 data = (struct kstat_named *)(ksp->ks_data);
359 ksi = state->hs_ks_info;
360 ib_perf = &ksi->hki_ib_perfcnt[0];
361 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*ksi))
362 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*data))
363 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*ib_perf))
364
365 /*
366 * Depending on whether we are reading the "pic" counters or
367 * writing the "pcr" control register, we need to handle and
368 * fill in the kstat data appropriately.
369 *
370 * If this is a write to the "pcr", then extract the value from
371 * the kstat data and store it in the kstat info structure.
372 *
373 * Otherwise, if this is a read of the "pic" counter(s), then
374 * extract the register offset, size, and mask values from the
375 * ib_perf[] array. Then read the corresponding register and store
376 * it into the kstat data. Note: We only read/fill in pic1 if more
377 * than one port is configured.
378 */
379 numports = state->hs_cfg_profile->cp_num_ports;
380 if (rw == KSTAT_WRITE) {
381 /* Update the stored "pcr" value */
382 ksi->hki_pcr = data[0].value.ui64;
383 return (0);
384 } else {
385 /*
386 * Get the current "pcr" value and extract the lower
387 * portion (corresponding to the counters for "pic0")
388 */
389 pcr = ksi->hki_pcr;
390 indx = pcr & HERMON_CNTR_MASK;
391 data[0].value.ui64 = pcr;
392
393 /*
394 * Fill in the "pic0" counter, corresponding to port 1.
395 * This involves reading in the current value in the register
396 * and calculating how many events have happened since this
397 * register was last polled. Then we save away the current
398 * value for the counter and increment the "pic0" total by
399 * the number of new events.
400 */
401 oldval = ib_perf[indx].ks_old_pic0;
402
403 status = hermon_getperfcntr_cmd_post(state, 1,
404 HERMON_CMD_NOSLEEP_SPIN, &sm_perfcntr, 0);
405 if (status != HERMON_CMD_SUCCESS) {
406 return (-1);
407 }
408 switch (indx) {
409 case 0: /* port_xmit_data */
410 tmp = sm_perfcntr.portxmdata;
411 break;
412 case 1: /* port_recv_data */
413 tmp = sm_perfcntr.portrcdata;
414 break;
415 case 2: /* port_xmit_pkts */
416 tmp = sm_perfcntr.portxmpkts;
417 break;
418 case 3: /* port_recv_pkts */
419 tmp = sm_perfcntr.portrcpkts;
420 break;
421 case 4: /* port_recv_err */
422 tmp = sm_perfcntr.portrcv;
423 break;
424 case 5: /* port_xmit_discards */
425 tmp = sm_perfcntr.portxmdiscard;
426 break;
427 case 6: /* vl15_dropped */
428 tmp = sm_perfcntr.vl15drop;
429 break;
430 case 7: /* port_xmit_wait */
431 tmp = sm_perfcntr.portxmwait;
432 break;
433 case 8: /* port_recv_remote_phys_err */
434 tmp = sm_perfcntr.portrcvrem;
435 break;
436 case 9: /* port_xmit_constraint_err */
437 tmp = sm_perfcntr.portxmconstr;
438 break;
439 case 10: /* port_recv_constraint_err */
440 tmp = sm_perfcntr.portrcconstr;
441 break;
442 case 11: /* symbol_err_counter */
443 tmp = sm_perfcntr.symerr;
444 break;
445 case 12: /* link_err_recovery_cnt */
446 tmp = sm_perfcntr.linkerrrec;
447 break;
448 case 13: /* link_downed_cnt */
449 tmp = sm_perfcntr.linkdown;
450 break;
451 case 14: /* excessive_buffer_overruns */
452 tmp = sm_perfcntr.xsbuffovrun;
453 break;
454 case 15: /* local_link_integrity_err */
455 tmp = sm_perfcntr.locallinkint;
456 break;
457 case 16: /* clear_pic */
458 tmp = 0; /* XXX */
459 break;
460 default:
461 cmn_err(CE_CONT, "perf counter out of range\n");
462 }
463
464 ib_perf[indx].ks_old_pic0 = tmp;
465
466 tmp = tmp - oldval;
467 ksi->hki_pic0 += tmp;
468 data[1].value.ui64 = ksi->hki_pic0;
469
470 /*
471 * If necessary, fill in the "pic1" counter for port 2.
472 * This works the same as above except that we extract the
473 * upper bits (corresponding to the counters for "pic1")
474 */
475 if (numports == HERMON_MAX_PORTS) {
476 indx = pcr >> HERMON_CNTR_SIZE;
477 oldval = ib_perf[indx].ks_old_pic1;
478
479 status = hermon_getperfcntr_cmd_post(state, 2,
480 HERMON_CMD_NOSLEEP_SPIN, &sm_perfcntr, 0);
481 if (status != HERMON_CMD_SUCCESS) {
482 return (-1);
483 }
484 switch (indx) {
485 case 0: /* port_xmit_data */
486 tmp = sm_perfcntr.portxmdata;
487 break;
488 case 1: /* port_recv_data */
489 tmp = sm_perfcntr.portrcdata;
490 break;
491 case 2: /* port_xmit_pkts */
492 tmp = sm_perfcntr.portxmpkts;
493 break;
494 case 3: /* port_recv_pkts */
495 tmp = sm_perfcntr.portrcpkts;
496 break;
497 case 4: /* port_recv_err */
498 tmp = sm_perfcntr.portrcv;
499 break;
500 case 5: /* port_xmit_discards */
501 tmp = sm_perfcntr.portxmdiscard;
502 break;
503 case 6: /* vl15_dropped */
504 tmp = sm_perfcntr.vl15drop;
505 break;
506 case 7: /* port_xmit_wait */
507 tmp = sm_perfcntr.portxmwait;
508 break;
509 case 8: /* port_recv_remote_phys_err */
510 tmp = sm_perfcntr.portrcvrem;
511 break;
512 case 9: /* port_xmit_constraint_err */
513 tmp = sm_perfcntr.portxmconstr;
514 break;
515 case 10: /* port_recv_constraint_err */
516 tmp = sm_perfcntr.portrcconstr;
517 break;
518 case 11: /* symbol_err_counter */
519 tmp = sm_perfcntr.symerr;
520 break;
521 case 12: /* link_err_recovery_cnt */
522 tmp = sm_perfcntr.linkerrrec;
523 break;
524 case 13: /* link_downed_cnt */
525 tmp = sm_perfcntr.linkdown;
526 break;
527 case 14: /* excessive_buffer_overruns */
528 tmp = sm_perfcntr.xsbuffovrun;
529 break;
530 case 15: /* local_link_integrity_err */
531 tmp = sm_perfcntr.locallinkint;
532 break;
533 case 16: /* clear_pic */
534 tmp = 0; /* XXX */
535 break;
536 default:
537 cmn_err(CE_CONT, "perf counter out of range\n");
538 }
539
540 ib_perf[indx].ks_old_pic1 = tmp;
541
542 tmp = tmp - oldval;
543 ksi->hki_pic1 += tmp;
544 data[2].value.ui64 = ksi->hki_pic1;
545 }
546
547 return (0);
548 }
549 }
550
551 /*
552 * 64 bit kstats for performance counters:
553 *
554 * Export 64 bit performance counters in kstats.
555 *
556 * If the HCA hardware supports 64 bit extended port counters, we use the
557 * hardware based counters. If the HCA hardware does not support extended port
558 * counters, we maintain 64 bit performance counters in software using the
559 * 32 bit hardware port counters.
560 *
561 * The software based counters are maintained as follows:
562 *
563 * We create a thread that, every one second, reads the values of 32 bit
564 * hardware counters and adds them to the 64 bit software counters. Immediately
565 * after reading, it resets the 32 bit hardware counters to zero (so that they
566 * start counting from zero again). At any time the current value of a counter
567 * is going to be the sum of the 64 bit software counter and the 32 bit
568 * hardware counter.
569 *
570 * Since this work need not be done if there is no consumer, by default
571 * we do not maintain 64 bit software counters. To enable this the consumer
572 * needs to write a non-zero value to the "enable" component of the of
573 * perf_counters kstat. Writing zero to this component will disable this work.
574 * NOTE: The enabling or disabling applies to software based counters only.
575 * Hardware based counters counters are always enabled.
576 *
577 * If performance monitor is enabled in subnet manager, the SM could
578 * periodically reset the hardware counters by sending perf-MADs. So only
579 * one of either our software 64 bit counters or the SM performance monitor
580 * could be enabled at the same time. However, if both of them are enabled at
581 * the same time we still do our best by keeping track of the values of the
582 * last read 32 bit hardware counters. If the current read of a 32 bit hardware
583 * counter is less than the last read of the counter, we ignore the current
584 * value and go with the last read value.
585 */
586
587 /*
588 * hermon_kstat_perfcntr64_create()
589 * Context: Only called from attach() path context
590 *
591 * Create "port#/perf_counters" kstat for the specified port number.
592 */
593 void
594 hermon_kstat_perfcntr64_create(hermon_state_t *state, uint_t port_num)
595 {
596 hermon_ks_info_t *ksi = state->hs_ks_info;
597 struct kstat *cntr_ksp;
598 struct kstat_named *cntr_named_data;
599 int drv_instance;
600 char *drv_name;
601 char kname[32];
602 int status, ext_width_supported;
603
604 ASSERT(port_num != 0);
605
606 status = hermon_is_ext_port_counters_supported(state, port_num,
607 HERMON_CMD_NOSLEEP_SPIN, &ext_width_supported);
608 if (status == HERMON_CMD_SUCCESS) {
609 ksi->hki_perfcntr64[port_num - 1].
610 hki64_ext_port_counters_supported = ext_width_supported;
611 }
612
613 drv_name = (char *)ddi_driver_name(state->hs_dip);
614 drv_instance = ddi_get_instance(state->hs_dip);
615 (void) snprintf(kname, sizeof (kname), "port%u/perf_counters",
616 port_num);
617 cntr_ksp = kstat_create(drv_name, drv_instance, kname, "ib",
618 KSTAT_TYPE_NAMED, HERMON_PERFCNTR64_NUM_COUNTERS,
619 KSTAT_FLAG_WRITABLE);
620 if (cntr_ksp == NULL) {
621 return;
622 }
623 cntr_named_data = (struct kstat_named *)(cntr_ksp->ks_data);
624
625 kstat_named_init(&cntr_named_data[HERMON_PERFCNTR64_ENABLE_IDX],
626 "enable", KSTAT_DATA_UINT32);
627 kstat_named_init(&cntr_named_data[HERMON_PERFCNTR64_XMIT_DATA_IDX],
628 "xmit_data", KSTAT_DATA_UINT64);
629 kstat_named_init(&cntr_named_data[HERMON_PERFCNTR64_RECV_DATA_IDX],
630 "recv_data", KSTAT_DATA_UINT64);
631 kstat_named_init(&cntr_named_data[HERMON_PERFCNTR64_XMIT_PKTS_IDX],
632 "xmit_pkts", KSTAT_DATA_UINT64);
633 kstat_named_init(&cntr_named_data[HERMON_PERFCNTR64_RECV_PKTS_IDX],
634 "recv_pkts", KSTAT_DATA_UINT64);
635
636 ksi->hki_perfcntr64[port_num - 1].hki64_ksp = cntr_ksp;
637 ksi->hki_perfcntr64[port_num - 1].hki64_port_num = port_num;
638 ksi->hki_perfcntr64[port_num - 1].hki64_state = state;
639
640 cntr_ksp->ks_private = &ksi->hki_perfcntr64[port_num - 1];
641 cntr_ksp->ks_update = hermon_kstat_perfcntr64_update;
642
643 /* Install the kstat */
644 kstat_install(cntr_ksp);
645 }
646
647 /*
648 * hermon_kstat_perfcntr64_read()
649 *
650 * Read the values of 32 bit hardware counters.
651 *
652 * If reset is true, reset the 32 bit hardware counters. Add the values of the
653 * 32 bit hardware counters to the 64 bit software counters.
654 *
655 * If reset is false, just save the values read from the 32 bit hardware
656 * counters in hki64_last_read[].
657 *
658 * See the general comment on the 64 bit performance counters
659 * regarding the use of last read 32 bit hardware counter values.
660 */
661 static int
662 hermon_kstat_perfcntr64_read(hermon_state_t *state, uint_t port, int reset)
663 {
664 hermon_ks_info_t *ksi = state->hs_ks_info;
665 hermon_perfcntr64_ks_info_t *ksi64 = &ksi->hki_perfcntr64[port - 1];
666 int status, i;
667 uint32_t tmp;
668 hermon_hw_sm_perfcntr_t sm_perfcntr;
669
670 ASSERT(MUTEX_HELD(&ksi->hki_perfcntr64_lock));
671 ASSERT(port != 0);
672
673 /* read the 32 bit hardware counters */
674 status = hermon_getperfcntr_cmd_post(state, port,
675 HERMON_CMD_NOSLEEP_SPIN, &sm_perfcntr, 0);
676 if (status != HERMON_CMD_SUCCESS) {
677 return (status);
678 }
679
680 if (reset) {
681 /* reset the hardware counters */
682 status = hermon_getperfcntr_cmd_post(state, port,
683 HERMON_CMD_NOSLEEP_SPIN, NULL, 1);
684 if (status != HERMON_CMD_SUCCESS) {
685 return (status);
686 }
687
688 /*
689 * Update 64 bit software counters
690 */
691 tmp = MAX(sm_perfcntr.portxmdata,
692 ksi64->hki64_last_read[HERMON_PERFCNTR64_XMIT_DATA_IDX]);
693 ksi64->hki64_counters[HERMON_PERFCNTR64_XMIT_DATA_IDX] += tmp;
694
695 tmp = MAX(sm_perfcntr.portrcdata,
696 ksi64->hki64_last_read[HERMON_PERFCNTR64_RECV_DATA_IDX]);
697 ksi64->hki64_counters[HERMON_PERFCNTR64_RECV_DATA_IDX] += tmp;
698
699 tmp = MAX(sm_perfcntr.portxmpkts,
700 ksi64->hki64_last_read[HERMON_PERFCNTR64_XMIT_PKTS_IDX]);
701 ksi64->hki64_counters[HERMON_PERFCNTR64_XMIT_PKTS_IDX] += tmp;
702
703 tmp = MAX(sm_perfcntr.portrcpkts,
704 ksi64->hki64_last_read[HERMON_PERFCNTR64_RECV_PKTS_IDX]);
705 ksi64->hki64_counters[HERMON_PERFCNTR64_RECV_PKTS_IDX] += tmp;
706
707 for (i = 0; i < HERMON_PERFCNTR64_NUM_COUNTERS; i++)
708 ksi64->hki64_last_read[i] = 0;
709
710 } else {
711 /*
712 * Update ksi64->hki64_last_read[]
713 */
714 SET_TO_MAX(
715 ksi64->hki64_last_read[HERMON_PERFCNTR64_XMIT_DATA_IDX],
716 sm_perfcntr.portxmdata);
717
718 SET_TO_MAX(
719 ksi64->hki64_last_read[HERMON_PERFCNTR64_RECV_DATA_IDX],
720 sm_perfcntr.portrcdata);
721
722 SET_TO_MAX(
723 ksi64->hki64_last_read[HERMON_PERFCNTR64_XMIT_PKTS_IDX],
724 sm_perfcntr.portxmpkts);
725
726 SET_TO_MAX(
727 ksi64->hki64_last_read[HERMON_PERFCNTR64_RECV_PKTS_IDX],
728 sm_perfcntr.portrcpkts);
729 }
730
731 return (HERMON_CMD_SUCCESS);
732 }
733
734 /*
735 * hermon_kstat_perfcntr64_update_thread()
736 * Context: Entry point for a kernel thread
737 *
738 * Maintain 64 bit performance counters in software using the 32 bit
739 * hardware counters.
740 */
741 static void
742 hermon_kstat_perfcntr64_update_thread(void *arg)
743 {
744 hermon_state_t *state = (hermon_state_t *)arg;
745 hermon_ks_info_t *ksi = state->hs_ks_info;
746 uint_t i;
747 clock_t delta = drv_usectohz(1000000);
748
749 mutex_enter(&ksi->hki_perfcntr64_lock);
750 /*
751 * Every one second update the values 64 bit software counters
752 * for all ports. Exit if HERMON_PERFCNTR64_THREAD_EXIT flag is set.
753 */
754 while (!(ksi->hki_perfcntr64_flags & HERMON_PERFCNTR64_THREAD_EXIT)) {
755 for (i = 0; i < state->hs_cfg_profile->cp_num_ports; i++) {
756 if (ksi->hki_perfcntr64[i].hki64_enabled) {
757 (void) hermon_kstat_perfcntr64_read(state,
758 i + 1, 1);
759 }
760 }
761 /* sleep for a second */
762 (void) cv_reltimedwait(&ksi->hki_perfcntr64_cv,
763 &ksi->hki_perfcntr64_lock, delta, TR_CLOCK_TICK);
764 }
765 ksi->hki_perfcntr64_flags = 0;
766 mutex_exit(&ksi->hki_perfcntr64_lock);
767 }
768
769 /*
770 * hermon_kstat_perfcntr64_thread_create()
771 * Context: Called from the kstat context
772 *
773 * Create a thread that maintains 64 bit performance counters in software.
774 */
775 static void
776 hermon_kstat_perfcntr64_thread_create(hermon_state_t *state)
777 {
778 hermon_ks_info_t *ksi = state->hs_ks_info;
779 kthread_t *thr;
780
781 ASSERT(MUTEX_HELD(&ksi->hki_perfcntr64_lock));
782
783 /*
784 * One thread per hermon instance. Don't create a thread if already
785 * created.
786 */
787 if (!(ksi->hki_perfcntr64_flags & HERMON_PERFCNTR64_THREAD_CREATED)) {
788 thr = thread_create(NULL, 0,
789 hermon_kstat_perfcntr64_update_thread,
790 state, 0, &p0, TS_RUN, minclsyspri);
791 ksi->hki_perfcntr64_thread_id = thr->t_did;
792 ksi->hki_perfcntr64_flags |= HERMON_PERFCNTR64_THREAD_CREATED;
793 }
794 }
795
796 /*
797 * hermon_kstat_perfcntr64_thread_exit()
798 * Context: Called from attach, detach or kstat context
799 */
800 static void
801 hermon_kstat_perfcntr64_thread_exit(hermon_ks_info_t *ksi)
802 {
803 kt_did_t tid;
804
805 ASSERT(MUTEX_HELD(&ksi->hki_perfcntr64_lock));
806
807 if (ksi->hki_perfcntr64_flags & HERMON_PERFCNTR64_THREAD_CREATED) {
808 /*
809 * Signal the thread to exit and wait until the thread exits.
810 */
811 ksi->hki_perfcntr64_flags |= HERMON_PERFCNTR64_THREAD_EXIT;
812 tid = ksi->hki_perfcntr64_thread_id;
813 cv_signal(&ksi->hki_perfcntr64_cv);
814
815 mutex_exit(&ksi->hki_perfcntr64_lock);
816 thread_join(tid);
817 mutex_enter(&ksi->hki_perfcntr64_lock);
818 }
819 }
820
821 /*
822 * hermon_kstat_perfcntr64_update_ext()
823 * Context: Called from the kstat context
824 *
825 * Update perf_counters kstats with the values of the extended port counters
826 * from the hardware.
827 */
828 static int
829 hermon_kstat_perfcntr64_update_ext(hermon_perfcntr64_ks_info_t *ksi64, int rw,
830 struct kstat_named *data)
831 {
832 hermon_hw_sm_extperfcntr_t sm_extperfcntr;
833
834 /*
835 * The "enable" component of the kstat is the only writable kstat.
836 * It is a no-op when the hardware supports extended port counters.
837 */
838 if (rw == KSTAT_WRITE)
839 return (0);
840
841 /*
842 * Read the counters and update kstats.
843 */
844 if (hermon_getextperfcntr_cmd_post(ksi64->hki64_state,
845 ksi64->hki64_port_num, HERMON_CMD_NOSLEEP_SPIN, &sm_extperfcntr) !=
846 HERMON_CMD_SUCCESS) {
847 return (EIO);
848 }
849
850 data[HERMON_PERFCNTR64_ENABLE_IDX].value.ui32 = 1;
851
852 data[HERMON_PERFCNTR64_XMIT_DATA_IDX].value.ui64 =
853 sm_extperfcntr.portxmdata;
854
855 data[HERMON_PERFCNTR64_RECV_DATA_IDX].value.ui64 =
856 sm_extperfcntr.portrcdata;
857
858 data[HERMON_PERFCNTR64_XMIT_PKTS_IDX].value.ui64 =
859 sm_extperfcntr.portxmpkts;
860
861 data[HERMON_PERFCNTR64_RECV_PKTS_IDX].value.ui64 =
862 sm_extperfcntr.portrcpkts;
863
864 return (0);
865 }
866
867 /*
868 * hermon_kstat_perfcntr64_update()
869 * Context: Called from the kstat context
870 *
871 * See the general comment on 64 bit kstats for performance counters:
872 */
873 static int
874 hermon_kstat_perfcntr64_update(kstat_t *ksp, int rw)
875 {
876 hermon_state_t *state;
877 struct kstat_named *data;
878 hermon_ks_info_t *ksi;
879 hermon_perfcntr64_ks_info_t *ksi64;
880 int i, thr_exit;
881 int rv;
882
883 ksi64 = ksp->ks_private;
884 state = ksi64->hki64_state;
885 ksi = state->hs_ks_info;
886 data = (struct kstat_named *)(ksp->ks_data);
887
888 mutex_enter(&ksi->hki_perfcntr64_lock);
889
890 if (ksi64->hki64_ext_port_counters_supported) {
891 rv = hermon_kstat_perfcntr64_update_ext(ksi64, rw, data);
892 mutex_exit(&ksi->hki_perfcntr64_lock);
893 return (rv);
894 }
895
896 /*
897 * 64 bit performance counters maintained by the software is not
898 * enabled by default. Enable them upon a writing a non-zero value
899 * to "enable" kstat. Disable them upon a writing zero to the
900 * "enable" kstat.
901 */
902 if (rw == KSTAT_WRITE) {
903 if (data[HERMON_PERFCNTR64_ENABLE_IDX].value.ui32) {
904 if (ksi64->hki64_enabled == 0) {
905 /*
906 * Reset the hardware counters to ensure that
907 * the hardware counter doesn't max out
908 * (and hence stop counting) before we get
909 * a chance to reset the counter in
910 * hermon_kstat_perfcntr64_update_thread.
911 */
912 if (hermon_getperfcntr_cmd_post(state,
913 ksi64->hki64_port_num,
914 HERMON_CMD_NOSLEEP_SPIN, NULL, 1) !=
915 HERMON_CMD_SUCCESS) {
916 mutex_exit(&ksi->hki_perfcntr64_lock);
917 return (EIO);
918 }
919
920 /* Enable 64 bit software counters */
921 ksi64->hki64_enabled = 1;
922 for (i = 0;
923 i < HERMON_PERFCNTR64_NUM_COUNTERS; i++) {
924 ksi64->hki64_counters[i] = 0;
925 ksi64->hki64_last_read[i] = 0;
926 }
927 hermon_kstat_perfcntr64_thread_create(state);
928 }
929
930 } else if (ksi64->hki64_enabled) {
931 /* Disable 64 bit software counters */
932 ksi64->hki64_enabled = 0;
933 thr_exit = 1;
934 for (i = 0; i < state->hs_cfg_profile->cp_num_ports;
935 i++) {
936 if (ksi->hki_perfcntr64[i].hki64_enabled) {
937 thr_exit = 0;
938 break;
939 }
940 }
941 if (thr_exit)
942 hermon_kstat_perfcntr64_thread_exit(ksi);
943 }
944 } else if (ksi64->hki64_enabled) {
945 /*
946 * Read the counters and update kstats.
947 */
948 if (hermon_kstat_perfcntr64_read(state, ksi64->hki64_port_num,
949 0) != HERMON_CMD_SUCCESS) {
950 mutex_exit(&ksi->hki_perfcntr64_lock);
951 return (EIO);
952 }
953
954 data[HERMON_PERFCNTR64_ENABLE_IDX].value.ui32 = 1;
955
956 data[HERMON_PERFCNTR64_XMIT_DATA_IDX].value.ui64 =
957 ksi64->hki64_counters[HERMON_PERFCNTR64_XMIT_DATA_IDX] +
958 ksi64->hki64_last_read[HERMON_PERFCNTR64_XMIT_DATA_IDX];
959
960 data[HERMON_PERFCNTR64_RECV_DATA_IDX].value.ui64 =
961 ksi64->hki64_counters[HERMON_PERFCNTR64_RECV_DATA_IDX] +
962 ksi64->hki64_last_read[HERMON_PERFCNTR64_RECV_DATA_IDX];
963
964 data[HERMON_PERFCNTR64_XMIT_PKTS_IDX].value.ui64 =
965 ksi64->hki64_counters[HERMON_PERFCNTR64_XMIT_PKTS_IDX] +
966 ksi64->hki64_last_read[HERMON_PERFCNTR64_XMIT_PKTS_IDX];
967
968 data[HERMON_PERFCNTR64_RECV_PKTS_IDX].value.ui64 =
969 ksi64->hki64_counters[HERMON_PERFCNTR64_RECV_PKTS_IDX] +
970 ksi64->hki64_last_read[HERMON_PERFCNTR64_RECV_PKTS_IDX];
971
972 } else {
973 /* return 0 in kstats if not enabled */
974 data[HERMON_PERFCNTR64_ENABLE_IDX].value.ui32 = 0;
975 for (i = 1; i < HERMON_PERFCNTR64_NUM_COUNTERS; i++)
976 data[i].value.ui64 = 0;
977 }
978
979 mutex_exit(&ksi->hki_perfcntr64_lock);
980 return (0);
981 }