?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
9506 Want support for QLogic QL41000/45000 series devices
[unleashed.git] / usr / src / uts / common / io / qede / qede_kstat.c
blob008abfa5f739eedaa04c84534638f03f0f2d729e
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, v.1, (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://opensource.org/licenses/CDDL-1.0.
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 2014-2017 Cavium, Inc.
24 * The contents of this file are subject to the terms of the Common Development
25 * and Distribution License, v.1, (the "License").
26
27 * You may not use this file except in compliance with the License.
28
29 * You can obtain a copy of the License at available
30 * at http://opensource.org/licenses/CDDL-1.0
31
32 * See the License for the specific language governing permissions and
33 * limitations under the License.
34 */
35
36
37 #include "qede.h"
38
39 typedef struct _qede_kstat {
40 kstat_named_t qede_hi;
41 kstat_named_t qede_lo;
42 kstat_named_t version;
43 kstat_named_t versionFW;
44 kstat_named_t versionMFW;
45 kstat_named_t chipID;
46 kstat_named_t chipName;
47 kstat_named_t devBDF;
48 kstat_named_t devID;
49 kstat_named_t multiFunction;
50 kstat_named_t multiFunctionVnics;
51 kstat_named_t macAddr;
52 kstat_named_t hwInitDone;
53 kstat_named_t numVports;
54 kstat_named_t vportID;
55 kstat_named_t intrAlloc;
56 kstat_named_t intrFired;
57 kstat_named_t lroEnabled;
58 kstat_named_t lsoEnabled;
59 kstat_named_t jumboEnabled;
60 kstat_named_t txTotalPkts;
61 kstat_named_t txTotalBytes;
62 kstat_named_t txTotalDiscards;
63 kstat_named_t rxTotalPkts;
64 kstat_named_t rxTotalBytes;
65 kstat_named_t rxTotalDiscards;
66 kstat_named_t allocbFailures;
67 } qede_kstat_t;
68
69 #define QEDE_KSTAT_SIZE (sizeof (qede_kstat_t) / sizeof (kstat_named_t))
70
71 typedef struct _qede_kstat_link {
72 kstat_named_t vportID;
73 kstat_named_t uptime;
74 kstat_named_t mtuL2;
75 kstat_named_t speed;
76 kstat_named_t link;
77 kstat_named_t duplex;
78 kstat_named_t pauseRx;
79 kstat_named_t pauseTx;
80 } qede_kstat_link_t;
81
82 #define QEDE_KSTAT_LINK_SIZE \
83 (sizeof (qede_kstat_link_t) / sizeof (kstat_named_t))
84
85 typedef struct _qede_kstat_intr {
86 kstat_named_t intrAlloc;
87 kstat_named_t intrFired;
88 kstat_named_t sb_00;
89 kstat_named_t sb_01;
90 kstat_named_t sb_02;
91 kstat_named_t sb_03;
92 kstat_named_t sb_04;
93 kstat_named_t sb_05;
94 kstat_named_t sb_06;
95 kstat_named_t sb_nc_00;
96 kstat_named_t sb_nc_01;
97 kstat_named_t sb_nc_02;
98 kstat_named_t sb_nc_03;
99 kstat_named_t sb_nc_04;
100 kstat_named_t sb_nc_05;
101 kstat_named_t sb_nc_06;
102 kstat_named_t sb_poll_00;
103 kstat_named_t sb_poll_01;
104 kstat_named_t sb_poll_02;
105 kstat_named_t sb_poll_03;
106 kstat_named_t sb_poll_04;
107 kstat_named_t sb_poll_05;
108 kstat_named_t sb_poll_06;
109 kstat_named_t sb_poll_nc_00;
110 kstat_named_t sb_poll_nc_01;
111 kstat_named_t sb_poll_nc_02;
112 kstat_named_t sb_poll_nc_03;
113 kstat_named_t sb_poll_nc_04;
114 kstat_named_t sb_poll_nc_05;
115 kstat_named_t sb_poll_nc_06;
116 } qede_kstat_intr_t;
117
118 #define QEDE_KSTAT_INTR_SIZE \
119 (sizeof (qede_kstat_intr_t) / sizeof (kstat_named_t))
120
121 typedef struct _qede_kstat_vport_stats {
122 kstat_named_t rxUcastBytes;
123 kstat_named_t rxMcastBytes;
124 kstat_named_t rxBcastBytes;
125 kstat_named_t rxUcastPkts;
126 kstat_named_t rxMcastPkts;
127 kstat_named_t rxBcastPkts;
128 kstat_named_t txUcastBytes;
129 kstat_named_t txMcastBytes;
130 kstat_named_t txBcastBytes;
131 kstat_named_t txUcastPkts;
132 kstat_named_t txMcastPkts;
133 kstat_named_t txBcastPkts;
134 kstat_named_t rx64bytePkts;
135 kstat_named_t rx127bytePkts;
136 kstat_named_t rx255bytePkts;
137 kstat_named_t rx511bytePkts;
138 kstat_named_t rx1023bytePkts;
139 kstat_named_t rx1518bytePkts;
140 kstat_named_t rx1522bytePkts;
141 kstat_named_t rx2047bytePkts;
142 kstat_named_t rx4095bytePkts;
143 kstat_named_t rx9216bytePkts;
144 kstat_named_t rx16383bytePkts;
145 kstat_named_t tx64bytePkts;
146 kstat_named_t tx64to127bytePkts;
147 kstat_named_t tx128to255bytePkts;
148 kstat_named_t tx256to511bytePkts;
149 kstat_named_t tx512to1023bytePkts;
150 kstat_named_t tx1024to1518bytePkts;
151 kstat_named_t tx1519to2047bytePkts;
152 kstat_named_t tx2048to4095bytePkts;
153 kstat_named_t tx4096to9216bytePkts;
154 kstat_named_t tx9217to16383bytePkts;
155 kstat_named_t rxMacCtrlFrames;
156 kstat_named_t rxPauseFrames;
157 kstat_named_t txPauseFrames;
158 kstat_named_t rxCRCerrors;
159 kstat_named_t rxAlignErrors;
160 kstat_named_t rxCarrierErrors;
161 kstat_named_t rxOversizeErrors;
162 kstat_named_t rxJabbers;
163 kstat_named_t rxUndersizePkts;
164 kstat_named_t rxFragments;
165 kstat_named_t txLpiEntryCnt;
166 kstat_named_t txTotalCollisions;
167 kstat_named_t brbTruncates;
168 kstat_named_t noBuffDiscards;
169 kstat_named_t mftagFilterDiscards;
170 kstat_named_t macFilterDiscards;
171 kstat_named_t txErrDropPkts;
172 kstat_named_t coalescedPkts;
173 kstat_named_t coalescedEvents;
174 kstat_named_t coalescedAbortsNum;
175 kstat_named_t nonCoalescedPkts;
176 kstat_named_t coalescedBytes;
177 } qede_kstat_vport_stats_t;
178
179 #define QEDE_KSTAT_VPORT_STATS_SIZE \
180 (sizeof (qede_kstat_vport_stats_t) / sizeof (kstat_named_t))
181
182 typedef struct _qede_kstat_rxq {
183 kstat_named_t rxqBdTotal;
184 kstat_named_t rxqBdLeft;
185 kstat_named_t rxqBdPageCnt;
186 kstat_named_t rxqBdsPerPage;
187 kstat_named_t rxqBdSize;
188 kstat_named_t rxqBdProdIdx;
189 kstat_named_t rxqBdConsIdx;
190 kstat_named_t rcqBdTotal;
191 kstat_named_t rcqBdLeft;
192 kstat_named_t rcqBdPageCnt;
193 kstat_named_t rcqBdsPerPage;
194 kstat_named_t rcqBdSize;
195 kstat_named_t rcqBdProdIdx;
196 kstat_named_t rcqBdConsIdx;
197 kstat_named_t hwRcqConIdx;
198 kstat_named_t rxFreeDescs;
199 kstat_named_t rxActiveDescs;
200 kstat_named_t rxCopyPkts;
201 kstat_named_t rxDropPkts;
202 kstat_named_t rxBufUpInStack;
203 kstat_named_t rxLowWater;
204 kstat_named_t rxLowWaterCnt;
205 kstat_named_t inPollMode;
206 kstat_named_t rxPollCnt;
207 kstat_named_t intrDisableCnt;
208 kstat_named_t intrEnableCnt;
209 kstat_named_t genNumber;
210 kstat_named_t rxRegPkts;
211 kstat_named_t rxJumboPkts;
212 kstat_named_t rxLroPkts;
213 kstat_named_t rxRingTotalPkts;
214 kstat_named_t rxRingTotalBytes;
215 } qede_kstat_rxq_t;
216
217 #define QEDE_KSTAT_RXQ_SIZE \
218 (sizeof (qede_kstat_rxq_t) / sizeof (kstat_named_t))
219
220 typedef struct _qede_kstat_txq {
221 kstat_named_t txBdTotal;
222 kstat_named_t txBdLeft;
223 kstat_named_t txBdPageCnt;
224 kstat_named_t txBdsPerPage;
225 kstat_named_t txBdSize;
226 kstat_named_t hwTxqConIdx;
227 kstat_named_t txBdProdIdx;
228 kstat_named_t txBdConsIdx;
229 kstat_named_t txLowWater;
230 kstat_named_t txRingPause;
231 kstat_named_t txDropPkts;
232 kstat_named_t txCopyPkts;
233 kstat_named_t txBind;
234 kstat_named_t txBindFail;
235 kstat_named_t txPremapped;
236 kstat_named_t txPremappedFail;
237 kstat_named_t txTooManyCookies;
238 kstat_named_t txPullupPkts;
239 kstat_named_t txLsoPkts;
240 kstat_named_t txTooManyMblks;
241 kstat_named_t txMappedPkts;
242 kstat_named_t txJumboPkts;
243 kstat_named_t txRingTotalPkts;
244 kstat_named_t txRingTotalBytes;
245 } qede_kstat_txq_t;
246
247 #define QEDE_KSTAT_TXQ_SIZE \
248 (sizeof (qede_kstat_txq_t) / sizeof (kstat_named_t))
249
250
251 static int
252 qede_kstat_update(kstat_t *kstats,
253 int rw)
254 {
255
256 qede_kstat_t *pStats = (qede_kstat_t *)kstats->ks_data;
257 qede_t *qede = (qede_t *)kstats->ks_private;
258 struct ecore_dev *edev = &qede->edev;
259 qede_fastpath_t *fp = &qede->fp_array[0];
260 qede_rx_ring_t *rx_ring;
261 qede_tx_ring_t *tx_ring;
262 int i, j;
263 char buf[17];
264
265 if (rw == KSTAT_WRITE) {
266 return EACCES;
267 }
268
269 mutex_enter(&qede->kstat_lock);
270
271 snprintf(buf, sizeof (buf), "%16p", (void *)qede);
272 strncpy(pStats->qede_hi.value.c, &buf[0], 8);
273 pStats->qede_hi.value.c[8] = 0;
274 strncpy(pStats->qede_lo.value.c, &buf[8], 8);
275 pStats->qede_lo.value.c[8] = 0;
276
277
278 strncpy(pStats->version.value.c,
279 qede->version, sizeof (pStats->version.value.c));
280 strncpy(pStats->versionFW.value.c,
281 qede->versionFW, sizeof (pStats->versionFW.value.c));
282 strncpy(pStats->versionMFW.value.c,
283 qede->versionMFW, sizeof (pStats->versionMFW.value.c));
284
285 strncpy(pStats->chipName.value.c,
286 qede->chip_name, sizeof (pStats->chipName.value.c));
287 strncpy(pStats->chipID.value.c,
288 qede->chipID, sizeof (pStats->chipID.value.c));
289
290 strncpy(pStats->devBDF.value.c,
291 qede->bus_dev_func, sizeof (pStats->devBDF.value.c));
292 strncpy(pStats->devID.value.c,
293 qede->vendor_device, sizeof (pStats->devID.value.c));
294
295 strncpy(pStats->multiFunction.value.c,
296 ((edev->mf_mode == ECORE_MF_DEFAULT) ? "DEFAULT" :
297 (edev->mf_mode == ECORE_MF_OVLAN) ? "MF-OVLAN" : "Unknown"),
298 sizeof (pStats->multiFunction.value.c));
299
300 pStats->multiFunctionVnics.value.ui64 = 0;
301
302 snprintf(pStats->macAddr.value.c, 16, "%02x%02x%02x%02x%02x%02x",
303 qede->ether_addr[0],qede->ether_addr[1],
304 qede->ether_addr[2], qede->ether_addr[3],
305 qede->ether_addr[4],qede->ether_addr[5]);
306
307
308 pStats->hwInitDone.value.ui64 =
309 (qede->attach_resources & QEDE_ECORE_HW_INIT)? 1 : 0;
310 /*pStats->numVports.value.ui64 =
311 p_hwfn->hw_info.resc_num[ECORE_VPORT]; */
312 pStats->numVports.value.ui64 = edev->num_hwfns;
313 pStats->vportID.value.ui64 = qede->vport_params[0].vport_id;
314
315
316 strncpy(pStats->intrAlloc.value.c,
317 qede->intrAlloc, sizeof (pStats->intrAlloc.value.c));
318
319 pStats->intrFired.value.ui64 = qede->intrFired;
320 pStats->lroEnabled.value.ui64 = qede->lro_enable;
321 pStats->lsoEnabled.value.ui64 = qede->lso_enable;
322 pStats->jumboEnabled.value.ui64 = qede->jumbo_enable;
323
324 qede->rxTotalPkts = 0;
325 qede->rxTotalBytes = 0;
326 qede->rxTotalDiscards = 0;
327 qede->txTotalPkts = 0;
328 qede->txTotalBytes = 0;
329 qede->txTotalDiscards = 0;
330 qede->allocbFailures = 0;
331 for (i = 0; i < qede->num_fp; i++, fp++) {
332 rx_ring = fp->rx_ring;
333 qede->rxTotalPkts += rx_ring->rx_pkt_cnt;
334 qede->rxTotalBytes += rx_ring->rx_byte_cnt;
335 qede->rxTotalDiscards += rx_ring->rx_drop_cnt;
336 for (j = 0; j < qede->num_tc; j++) {
337 tx_ring = fp->tx_ring[j];
338 qede->txTotalPkts += tx_ring->tx_pkt_count;
339 qede->txTotalBytes += tx_ring->tx_byte_count;
340 qede->txTotalDiscards += tx_ring->tx_pkt_dropped;
341 }
342 }
343 pStats->rxTotalPkts.value.ui64 = qede->rxTotalPkts;
344 pStats->rxTotalBytes.value.ui64 = qede->rxTotalBytes;
345 pStats->rxTotalDiscards.value.ui64 = qede->rxTotalDiscards;
346 pStats->txTotalPkts.value.ui64 = qede->txTotalPkts;
347 pStats->txTotalBytes.value.ui64 = qede->txTotalBytes;
348 pStats->txTotalDiscards.value.ui64 = qede->txTotalDiscards;
349 pStats->allocbFailures.value.ui64 = qede->allocbFailures;
350
351 mutex_exit(&qede->kstat_lock);
352 return (0);
353
354 }
355
356 static int
357 qede_kstat_link_update(kstat_t *kstats, int rw)
358 {
359 qede_kstat_link_t *pStats = (qede_kstat_link_t *)kstats->ks_data;
360 qede_t *qede = (qede_t *)kstats->ks_private;
361 struct ecore_dev *edev = &qede->edev;
362
363 if (rw == KSTAT_WRITE) {
364 return EACCES;
365 }
366 mutex_enter(&qede->kstat_lock);
367
368 pStats->vportID.value.ui64 = qede->vport_params[0].vport_id;
369 pStats->uptime.value.ui64 = (qede->props.link_speed) ?
370 (ddi_get_time() - qede->props.uptime) : 0;
371 pStats->mtuL2.value.ui64 = qede->mtu;
372 pStats->speed.value.ui64 = qede->props.link_speed;
373 pStats->link.value.ui64 = qede->params.link_state;
374 pStats->duplex.value.ui64 = qede->props.link_duplex;
375 pStats->pauseRx.value.ui64 = qede->props.rx_pause;
376 pStats->pauseTx.value.ui64 = qede->props.tx_pause;
377
378 mutex_exit(&qede->kstat_lock);
379 return (0);
380 }
381
382 static int
383 qede_kstat_intr_update(kstat_t *kstats, int rw)
384 {
385
386 qede_kstat_intr_t * pStats = (qede_kstat_intr_t *)kstats->ks_data;
387 qede_t *qede = (qede_t *)kstats->ks_private;
388 struct ecore_dev *edev = &qede->edev;
389
390 if (rw == KSTAT_WRITE) {
391 return EACCES;
392 }
393
394 mutex_enter(&qede->kstat_lock);
395
396
397 strncpy(pStats->intrAlloc.value.c,
398 qede->intrAlloc, sizeof (pStats->intrAlloc.value.c));
399
400 pStats->intrFired.value.ui64 = qede->intrFired;
401
402 pStats->sb_00.value.ui64 = qede->intrSbCnt[0];
403 pStats->sb_01.value.ui64 = qede->intrSbCnt[1];
404 pStats->sb_02.value.ui64 = qede->intrSbCnt[2];
405 pStats->sb_03.value.ui64 = qede->intrSbCnt[3];
406 pStats->sb_04.value.ui64 = qede->intrSbCnt[4];
407 pStats->sb_05.value.ui64 = qede->intrSbCnt[5];
408 pStats->sb_06.value.ui64 = qede->intrSbCnt[6];
409
410 pStats->sb_nc_00.value.ui64 = qede->intrSbNoChangeCnt[0];
411 pStats->sb_nc_01.value.ui64 = qede->intrSbNoChangeCnt[1];
412 pStats->sb_nc_02.value.ui64 = qede->intrSbNoChangeCnt[2];
413 pStats->sb_nc_03.value.ui64 = qede->intrSbNoChangeCnt[3];
414 pStats->sb_nc_04.value.ui64 = qede->intrSbNoChangeCnt[4];
415 pStats->sb_nc_05.value.ui64 = qede->intrSbNoChangeCnt[5];
416 pStats->sb_nc_06.value.ui64 = qede->intrSbNoChangeCnt[6];
417
418
419 pStats->sb_poll_00.value.ui64 = qede->intrSbPollCnt[0];
420 pStats->sb_poll_01.value.ui64 = qede->intrSbPollCnt[1];
421 pStats->sb_poll_02.value.ui64 = qede->intrSbPollCnt[2];
422 pStats->sb_poll_03.value.ui64 = qede->intrSbPollCnt[3];
423 pStats->sb_poll_04.value.ui64 = qede->intrSbPollCnt[4];
424 pStats->sb_poll_05.value.ui64 = qede->intrSbPollCnt[5];
425 pStats->sb_poll_06.value.ui64 = qede->intrSbPollCnt[6];
426
427 pStats->sb_poll_nc_00.value.ui64 = qede->intrSbPollNoChangeCnt[0];
428 pStats->sb_poll_nc_01.value.ui64 = qede->intrSbPollNoChangeCnt[1];
429 pStats->sb_poll_nc_02.value.ui64 = qede->intrSbPollNoChangeCnt[2];
430 pStats->sb_poll_nc_03.value.ui64 = qede->intrSbPollNoChangeCnt[3];
431 pStats->sb_poll_nc_04.value.ui64 = qede->intrSbPollNoChangeCnt[4];
432 pStats->sb_poll_nc_05.value.ui64 = qede->intrSbPollNoChangeCnt[5];
433 pStats->sb_poll_nc_06.value.ui64 = qede->intrSbPollNoChangeCnt[6];
434
435
436 mutex_exit(&qede->kstat_lock);
437
438 return (0);
439 }
440
441 static int
442 qede_kstat_vport_stats_update(kstat_t *kstats, int rw)
443 {
444
445 qede_kstat_vport_stats_t *pStats =
446 (qede_kstat_vport_stats_t *)kstats->ks_data;
447 qede_t *qede = (qede_t *)kstats->ks_private;
448 struct ecore_dev * edev = &qede->edev;
449 struct ecore_eth_stats vstats;
450
451
452 if (rw == KSTAT_WRITE) {
453 return EACCES;
454 }
455
456
457 mutex_enter(&qede->kstat_lock);
458
459 memset(&vstats, 0, sizeof (struct ecore_eth_stats));
460 if(qede->qede_state == QEDE_STATE_STARTED) {
461 ecore_get_vport_stats(edev, &vstats);
462 memcpy(&qede->save_stats, &vstats,
463 sizeof (struct ecore_eth_stats));
464 }
465
466 pStats->rxUcastBytes.value.ui64 = vstats.common.rx_ucast_bytes;
467 pStats->rxMcastBytes.value.ui64 = vstats.common.rx_mcast_bytes;
468 pStats->rxBcastBytes.value.ui64 = vstats.common.rx_bcast_bytes;
469 pStats->rxUcastPkts.value.ui64 = vstats.common.rx_ucast_pkts;
470 pStats->rxMcastPkts.value.ui64 = vstats.common.rx_mcast_pkts;
471 pStats->rxBcastPkts.value.ui64 = vstats.common.rx_bcast_pkts;
472 pStats->txUcastBytes.value.ui64 = vstats.common.tx_ucast_bytes;
473 pStats->txMcastBytes.value.ui64 = vstats.common.tx_mcast_bytes;
474 pStats->txBcastBytes.value.ui64 = vstats.common.tx_bcast_bytes;
475 pStats->txUcastPkts.value.ui64 = vstats.common.tx_ucast_pkts;
476 pStats->txMcastPkts.value.ui64 = vstats.common.tx_mcast_pkts;
477 pStats->txBcastPkts.value.ui64 = vstats.common.tx_bcast_pkts;
478 pStats->rx64bytePkts.value.ui64 = vstats.common.rx_64_byte_packets;
479 pStats->rx127bytePkts.value.ui64 =
480 vstats.common.rx_65_to_127_byte_packets;
481 pStats->rx255bytePkts.value.ui64 =
482 vstats.common.rx_128_to_255_byte_packets;
483 pStats->rx511bytePkts.value.ui64 =
484 vstats.common.rx_256_to_511_byte_packets;
485 pStats->rx1023bytePkts.value.ui64 =
486 vstats.common.rx_512_to_1023_byte_packets;
487 pStats->rx1518bytePkts.value.ui64 =
488 vstats.common.rx_1024_to_1518_byte_packets;
489 pStats->rx1522bytePkts.value.ui64 =
490 vstats.bb.rx_1519_to_1522_byte_packets;
491 pStats->rx2047bytePkts.value.ui64 =
492 vstats.bb.rx_1519_to_2047_byte_packets;
493 pStats->rx4095bytePkts.value.ui64 =
494 vstats.bb.rx_2048_to_4095_byte_packets;
495 pStats->rx9216bytePkts.value.ui64 =
496 vstats.bb.rx_4096_to_9216_byte_packets;
497 pStats->rx16383bytePkts.value.ui64 =
498 vstats.bb.rx_9217_to_16383_byte_packets;
499 pStats->tx64bytePkts.value.ui64 =
500 vstats.common.tx_64_byte_packets;
501 pStats->tx64to127bytePkts.value.ui64 =
502 vstats.common.tx_65_to_127_byte_packets;
503 pStats->tx128to255bytePkts.value.ui64 =
504 vstats.common.tx_128_to_255_byte_packets;
505 pStats->tx256to511bytePkts.value.ui64 =
506 vstats.common.tx_256_to_511_byte_packets;
507 pStats->tx512to1023bytePkts.value.ui64 =
508 vstats.common.tx_512_to_1023_byte_packets;
509 pStats->tx1024to1518bytePkts.value.ui64 =
510 vstats.common.tx_1024_to_1518_byte_packets;
511 pStats->tx1519to2047bytePkts.value.ui64 =
512 vstats.bb.tx_1519_to_2047_byte_packets;
513 pStats->tx2048to4095bytePkts.value.ui64 =
514 vstats.bb.tx_2048_to_4095_byte_packets;
515 pStats->tx4096to9216bytePkts.value.ui64 =
516 vstats.bb.tx_4096_to_9216_byte_packets;
517 pStats->tx9217to16383bytePkts.value.ui64 =
518 vstats.bb.tx_9217_to_16383_byte_packets;
519 pStats->rxMacCtrlFrames.value.ui64 =
520 vstats.common.rx_mac_crtl_frames;
521 pStats->rxPauseFrames.value.ui64 =
522 vstats.common.rx_pause_frames;
523 pStats->txPauseFrames.value.ui64 =
524 vstats.common.tx_pause_frames;
525 pStats->rxCRCerrors.value.ui64 =
526 vstats.common.rx_crc_errors;
527 pStats->rxAlignErrors.value.ui64 =
528 vstats.common.rx_align_errors;
529 pStats->rxCarrierErrors.value.ui64 =
530 vstats.common.rx_carrier_errors;
531 pStats->rxOversizeErrors.value.ui64 =
532 vstats.common.rx_oversize_packets;
533 pStats->rxJabbers.value.ui64 =
534 vstats.common.rx_jabbers;
535 pStats->rxUndersizePkts.value.ui64 =
536 vstats.common.rx_undersize_packets;
537 pStats->rxFragments.value.ui64 =
538 vstats.common.rx_fragments;
539 pStats->txLpiEntryCnt.value.ui64 =
540 vstats.bb.tx_lpi_entry_count;
541 pStats->txTotalCollisions.value.ui64 =
542 vstats.bb.tx_total_collisions;
543 pStats->brbTruncates.value.ui64 =
544 vstats.common.brb_truncates;
545 pStats->noBuffDiscards.value.ui64 =
546 vstats.common.no_buff_discards;
547 pStats->mftagFilterDiscards.value.ui64 =
548 vstats.common.mftag_filter_discards;
549 pStats->macFilterDiscards.value.ui64 =
550 vstats.common.mac_filter_discards;
551 pStats->txErrDropPkts.value.ui64 =
552 vstats.common.tx_err_drop_pkts;
553 pStats->coalescedPkts.value.ui64 =
554 vstats.common.tpa_coalesced_pkts;
555 pStats->coalescedEvents.value.ui64 =
556 vstats.common.tpa_coalesced_events;
557 pStats->coalescedAbortsNum.value.ui64 =
558 vstats.common.tpa_aborts_num;
559 pStats->nonCoalescedPkts.value.ui64 =
560 vstats.common.tpa_not_coalesced_pkts;
561 pStats->coalescedBytes.value.ui64 =
562 vstats.common.tpa_coalesced_bytes;
563
564 mutex_exit(&qede->kstat_lock);
565
566 return (0);
567 }
568
569 static int
570 qede_kstat_rxq_update(kstat_t *kstats, int rw)
571 {
572
573 qede_kstat_rxq_t *pStats = (qede_kstat_rxq_t *)kstats->ks_data;
574 KstatRingMap *pMap = (KstatRingMap *)kstats->ks_private;
575 qede_t *qede = (qede_t *)pMap->qede;
576 int idx = pMap->idx;
577 struct ecore_dev *edev = &qede->edev;
578 qede_rx_ring_t *rx_ring = &qede->rx_array[idx];
579
580
581 if (rw == KSTAT_WRITE) {
582 return EACCES;
583 }
584
585
586 mutex_enter(&qede->kstat_lock);
587
588 pStats->rxqBdTotal.value.ui64 = qede->rx_ring_size;
589 pStats->rcqBdTotal.value.ui64 = qede->rx_ring_size;
590 pStats->rxLowWater.value.ui64 = rx_ring->rx_low_buffer_threshold;
591
592 if(qede->qede_state == QEDE_STATE_STARTED) {
593
594 pStats->rxqBdLeft.value.ui64 =
595 ecore_chain_get_elem_left(&rx_ring->rx_bd_ring);
596 pStats->rxqBdPageCnt.value.ui64 =
597 ECORE_CHAIN_PAGE_CNT(qede->rx_ring_size,
598 sizeof (struct eth_rx_bd), ECORE_CHAIN_MODE_NEXT_PTR);
599 pStats->rxqBdsPerPage.value.ui64 =
600 ELEMS_PER_PAGE(sizeof (struct eth_rx_bd));
601 pStats->rxqBdSize.value.ui64 = sizeof (struct eth_rx_bd);
602 pStats->rxqBdProdIdx.value.ui64 =
603 ecore_chain_get_prod_idx(&rx_ring->rx_bd_ring) &
604 (rx_ring->qede->rx_ring_size - 1);
605 pStats->rxqBdConsIdx.value.ui64 =
606 ecore_chain_get_cons_idx(&rx_ring->rx_bd_ring) &
607 (rx_ring->qede->rx_ring_size - 1);
608 pStats->rcqBdLeft.value.ui64 =
609 ecore_chain_get_elem_left(&rx_ring->rx_cqe_ring);
610 pStats->rcqBdPageCnt.value.ui64 =
611 ECORE_CHAIN_PAGE_CNT(qede->rx_ring_size,
612 sizeof (union eth_rx_cqe), ECORE_CHAIN_MODE_PBL);
613 pStats->rcqBdsPerPage.value.ui64 =
614 ELEMS_PER_PAGE(sizeof (union eth_rx_cqe));
615 pStats->rcqBdSize.value.ui64 = sizeof (union eth_rx_cqe);
616 pStats->rcqBdProdIdx.value.ui64 =
617 ecore_chain_get_prod_idx(&rx_ring->rx_cqe_ring) &
618 (rx_ring->qede->rx_ring_size - 1);
619 pStats->rcqBdConsIdx.value.ui64 =
620 ecore_chain_get_cons_idx(&rx_ring->rx_cqe_ring) &
621 (rx_ring->qede->rx_ring_size - 1);
622 pStats->hwRcqConIdx.value.ui64 =
623 (rx_ring->hw_cons_ptr != NULL) ?
624 HOST_TO_LE_16(*rx_ring->hw_cons_ptr) &
625 (rx_ring->qede->rx_ring_size - 1): 0;
626 pStats->rxFreeDescs.value.ui64 =
627 rx_ring->rx_buf_area->passive_buf_list.num_entries;
628 pStats->rxActiveDescs.value.ui64 =
629 rx_ring->rx_buf_area->active_buf_list.num_entries;
630 pStats->rxBufUpInStack.value.ui64 =
631 rx_ring->rx_buf_area->buf_upstream;
632 pStats->rxCopyPkts.value.ui64 =
633 rx_ring->rx_copy_cnt;
634 pStats->rxDropPkts.value.ui64 =
635 rx_ring->rx_drop_cnt;
636 pStats->rxLowWaterCnt.value.ui64 =
637 rx_ring->rx_low_water_cnt;
638 pStats->inPollMode.value.ui64 =
639 rx_ring->fp->disabled_by_poll;
640 pStats->rxPollCnt.value.ui64 =
641 rx_ring->rx_poll_cnt;;
642 pStats->intrDisableCnt.value.ui64 =
643 rx_ring->intrDisableCnt;
644 pStats->intrEnableCnt.value.ui64 =
645 rx_ring->intrEnableCnt;
646 pStats->genNumber.value.ui64 =
647 rx_ring->mr_gen_num;
648 pStats->rxLroPkts.value.ui64 =
649 rx_ring->rx_lro_pkt_cnt;
650 pStats->rxRingTotalPkts.value.ui64 =
651 rx_ring->rx_pkt_cnt;
652 pStats->rxRingTotalBytes.value.ui64 =
653 rx_ring->rx_byte_cnt;
654 pStats->rxRegPkts.value.ui64 =
655 rx_ring->rx_reg_pkt_cnt;
656 pStats->rxJumboPkts.value.ui64 =
657 rx_ring->rx_jumbo_pkt_cnt;
658
659 } else {
660
661 pStats->rxqBdLeft.value.ui64 = 0;
662 pStats->rxqBdPageCnt.value.ui64 = 0;
663 pStats->rxqBdsPerPage.value.ui64 = 0;
664 pStats->rxqBdSize.value.ui64 = 0;
665 pStats->rxqBdProdIdx.value.ui64 = 0;
666 pStats->rxqBdConsIdx.value.ui64 = 0;
667 pStats->rcqBdLeft.value.ui64 = 0;
668 pStats->rcqBdPageCnt.value.ui64 = 0;
669 pStats->rcqBdsPerPage.value.ui64 = 0;
670 pStats->rcqBdSize.value.ui64 = 0;
671 pStats->rcqBdProdIdx.value.ui64 = 0;
672 pStats->rcqBdConsIdx.value.ui64 = 0;
673 pStats->hwRcqConIdx.value.ui64 = 0;
674 pStats->rxFreeDescs.value.ui64 = 0;
675 pStats->rxActiveDescs.value.ui64 = 0;
676 pStats->rxBufUpInStack.value.ui64 = 0;
677 pStats->rxCopyPkts.value.ui64 = 0;
678 pStats->rxDropPkts.value.ui64 = 0;
679 pStats->rxLowWaterCnt.value.ui64 = 0;
680 pStats->inPollMode.value.ui64 = 0;
681 pStats->rxPollCnt.value.ui64 = 0;
682 pStats->intrDisableCnt.value.ui64 = 0;
683 pStats->intrEnableCnt.value.ui64 = 0;
684 pStats->genNumber.value.ui64 = 0;
685 pStats->rxLroPkts.value.ui64 = 0;
686 pStats->rxRingTotalPkts.value.ui64 = 0;
687 pStats->rxRingTotalBytes.value.ui64 = 0;
688 pStats->rxRegPkts.value.ui64 = 0;
689 pStats->rxJumboPkts.value.ui64 = 0;
690 }
691
692 mutex_exit(&qede->kstat_lock);
693 return (0);
694 }
695
696
697 static int
698 qede_kstat_txq_update(kstat_t *kstats, int rw)
699 {
700
701 qede_kstat_txq_t *pStats = (qede_kstat_txq_t *)kstats->ks_data;
702 KstatRingMap *pMap = (KstatRingMap *)kstats->ks_private;
703 qede_t *qede = (qede_t *)pMap->qede;
704 int idx = pMap->idx;
705 struct ecore_dev * edev = &qede->edev;
706 qede_tx_ring_t *tx_ring = &qede->tx_array[0][idx];
707
708
709 if (rw == KSTAT_WRITE) {
710 return EACCES;
711 }
712 mutex_enter(&qede->kstat_lock);
713
714 pStats->txBdTotal.value.ui64 = qede->tx_ring_size;
715 pStats->txBdSize.value.ui64 = sizeof (union eth_tx_bd_types);
716 pStats->txLowWater.value.ui64 = qede->tx_recycle_threshold;
717
718 if(qede->qede_state == QEDE_STATE_STARTED) {
719
720 pStats->txBdLeft.value.ui64 =
721 ecore_chain_get_elem_left(&tx_ring->tx_bd_ring);
722 pStats->txBdPageCnt.value.ui64 =
723 ECORE_CHAIN_PAGE_CNT(tx_ring->bd_ring_size,
724 sizeof (union eth_tx_bd_types), ECORE_CHAIN_MODE_PBL);
725 pStats->txBdsPerPage.value.ui64 =
726 ELEMS_PER_PAGE(sizeof (union eth_tx_bd_types));
727 pStats->hwTxqConIdx.value.ui64 =
728 (tx_ring->hw_cons_ptr != NULL) ?
729 HOST_TO_LE_16(*tx_ring->hw_cons_ptr) & TX_RING_MASK : 0;
730 pStats->txBdProdIdx.value.ui64 =
731 ecore_chain_get_prod_idx(&tx_ring->tx_bd_ring) & TX_RING_MASK;
732 pStats->txBdConsIdx.value.ui64 =
733 ecore_chain_get_cons_idx(&tx_ring->tx_bd_ring) & TX_RING_MASK;
734 pStats->txRingPause.value.ui64 =
735 tx_ring->tx_ring_pause;
736 pStats->txDropPkts.value.ui64 = tx_ring->tx_pkt_dropped;
737 pStats->txCopyPkts.value.ui64 = tx_ring->tx_copy_count;
738 pStats->txBind.value.ui64 = tx_ring->tx_bind_count;
739 pStats->txBindFail.value.ui64 = tx_ring->tx_bind_fail;
740 pStats->txPremapped.value.ui64 = tx_ring->tx_premap_count;
741 pStats->txPremappedFail.value.ui64 = tx_ring->tx_premap_fail;
742 pStats->txTooManyCookies.value.ui64 = tx_ring->tx_too_many_cookies;
743 pStats->txPullupPkts.value.ui64 = tx_ring->tx_pullup_count;
744 pStats->txLsoPkts.value.ui64 = tx_ring->tx_lso_pkt_count;
745 pStats->txTooManyMblks.value.ui64 = tx_ring->tx_too_many_mblks;
746 pStats->txMappedPkts.value.ui64 = tx_ring->tx_mapped_pkts;
747 pStats->txRingTotalPkts.value.ui64 = tx_ring->tx_pkt_count;
748 pStats->txRingTotalBytes.value.ui64 = tx_ring->tx_byte_count;
749 pStats->txJumboPkts.value.ui64 = tx_ring->tx_jumbo_pkt_count;
750
751
752 } else {
753
754
755 pStats->txBdLeft.value.ui64 = 0;
756 pStats->txBdPageCnt.value.ui64 = 0;
757 pStats->txBdsPerPage.value.ui64 = 0;
758 pStats->hwTxqConIdx.value.ui64 = 0;
759 pStats->txBdProdIdx.value.ui64 = 0;
760 pStats->txBdConsIdx.value.ui64 = 0;
761 pStats->txRingPause.value.ui64 = 0;
762 pStats->txDropPkts.value.ui64 = 0;
763 pStats->txCopyPkts.value.ui64 = 0;
764 pStats->txBind.value.ui64 = 0;
765 pStats->txBindFail.value.ui64 = 0;
766 pStats->txPremapped.value.ui64 = 0;
767 pStats->txPremappedFail.value.ui64 = 0;
768 pStats->txTooManyCookies.value.ui64 = 0;
769 pStats->txPullupPkts.value.ui64 = 0;
770 pStats->txLsoPkts.value.ui64 = 0;
771 pStats->txTooManyMblks.value.ui64 = 0;
772 pStats->txMappedPkts.value.ui64 = 0;
773 pStats->txJumboPkts.value.ui64 = 0;
774 pStats->txRingTotalPkts.value.ui64 = 0;
775 pStats->txRingTotalBytes.value.ui64 = 0;
776 }
777
778 mutex_exit(&qede->kstat_lock);
779 return (0);
780 }
781
782 boolean_t
783 qede_kstat_init_rxq(qede_t *qede, int idx)
784 {
785
786 char buf[32];
787
788 qede_kstat_rxq_t *pStatsRxq;
789
790 #define QEDE_KSTAT_RXQ(f, t) kstat_named_init(&pStatsRxq->f, #f, t)
791
792 snprintf(buf, sizeof (buf), "rxq%d", idx);
793
794 if ((qede->kstats_rxq[idx] = kstat_create("qede",
795 qede->instance,
796 buf,
797 "net",
798 KSTAT_TYPE_NAMED,
799 QEDE_KSTAT_RXQ_SIZE,
800 0)) == NULL)
801 {
802 /*BnxeLogWarn(qede, "Failed to create rxq%d kstat", idx);*/
803 cmn_err(CE_WARN, "Failed to create rxq%d kstat", idx);
804 return (B_FALSE);
805 }
806 pStatsRxq = (qede_kstat_rxq_t *)qede->kstats_rxq[idx]->ks_data;
807
808 QEDE_KSTAT_RXQ(rxqBdTotal, KSTAT_DATA_UINT64);
809 QEDE_KSTAT_RXQ(rxqBdLeft, KSTAT_DATA_UINT64);
810 QEDE_KSTAT_RXQ(rxqBdPageCnt, KSTAT_DATA_UINT64);
811 QEDE_KSTAT_RXQ(rxqBdsPerPage, KSTAT_DATA_UINT64);
812 QEDE_KSTAT_RXQ(rxqBdSize, KSTAT_DATA_UINT64);
813 QEDE_KSTAT_RXQ(rxqBdProdIdx, KSTAT_DATA_UINT64);
814 QEDE_KSTAT_RXQ(rxqBdConsIdx, KSTAT_DATA_UINT64);
815 QEDE_KSTAT_RXQ(rcqBdTotal, KSTAT_DATA_UINT64);
816 QEDE_KSTAT_RXQ(rcqBdLeft, KSTAT_DATA_UINT64);
817 QEDE_KSTAT_RXQ(rcqBdPageCnt, KSTAT_DATA_UINT64);
818 QEDE_KSTAT_RXQ(rcqBdsPerPage, KSTAT_DATA_UINT64);
819 QEDE_KSTAT_RXQ(rcqBdSize, KSTAT_DATA_UINT64);
820 QEDE_KSTAT_RXQ(rcqBdProdIdx, KSTAT_DATA_UINT64);
821 QEDE_KSTAT_RXQ(rcqBdConsIdx, KSTAT_DATA_UINT64);
822 QEDE_KSTAT_RXQ(hwRcqConIdx, KSTAT_DATA_UINT64);
823 QEDE_KSTAT_RXQ(rxFreeDescs, KSTAT_DATA_UINT64);
824 QEDE_KSTAT_RXQ(rxActiveDescs, KSTAT_DATA_UINT64);
825 QEDE_KSTAT_RXQ(rxCopyPkts, KSTAT_DATA_UINT64);
826 QEDE_KSTAT_RXQ(rxDropPkts, KSTAT_DATA_UINT64);
827 QEDE_KSTAT_RXQ(rxBufUpInStack, KSTAT_DATA_UINT64);
828 QEDE_KSTAT_RXQ(rxLowWater, KSTAT_DATA_UINT64);
829 QEDE_KSTAT_RXQ(rxLowWaterCnt, KSTAT_DATA_UINT64);
830 QEDE_KSTAT_RXQ(inPollMode, KSTAT_DATA_UINT64);
831 QEDE_KSTAT_RXQ(rxPollCnt, KSTAT_DATA_UINT64);
832 QEDE_KSTAT_RXQ(intrDisableCnt, KSTAT_DATA_UINT64);
833 QEDE_KSTAT_RXQ(intrEnableCnt, KSTAT_DATA_UINT64);
834 QEDE_KSTAT_RXQ(genNumber, KSTAT_DATA_UINT64);
835 QEDE_KSTAT_RXQ(rxRegPkts, KSTAT_DATA_UINT64);
836 QEDE_KSTAT_RXQ(rxJumboPkts, KSTAT_DATA_UINT64);
837 QEDE_KSTAT_RXQ(rxLroPkts, KSTAT_DATA_UINT64);
838 QEDE_KSTAT_RXQ(rxRingTotalPkts, KSTAT_DATA_UINT64);
839 QEDE_KSTAT_RXQ(rxRingTotalBytes, KSTAT_DATA_UINT64);
840
841
842 qede->kstats_rxq_map[idx].idx = idx;
843 qede->kstats_rxq_map[idx].qede = qede;
844
845 qede->kstats_rxq[idx]->ks_update = qede_kstat_rxq_update;
846 qede->kstats_rxq[idx]->ks_private = (void *)&qede->kstats_rxq_map[idx];
847
848 kstat_install(qede->kstats_rxq[idx]);
849
850 return (B_TRUE);
851 }
852
853
854 boolean_t
855 qede_kstat_init_txq(qede_t *qede, int idx)
856 {
857 char buf[32];
858
859 qede_kstat_txq_t *pStatsTxq;
860
861 #define QEDE_KSTAT_TXQ(f, t) kstat_named_init(&pStatsTxq->f, #f, t)
862
863 snprintf(buf, sizeof (buf), "txq%d", idx);
864
865 if ((qede->kstats_txq[idx] = kstat_create("qede",
866 qede->instance,
867 buf,
868 "net",
869 KSTAT_TYPE_NAMED,
870 QEDE_KSTAT_TXQ_SIZE,
871 0)) == NULL) {
872 /*BnxeLogWarn(qede, "Failed to create txq%d kstat", idx);*/
873 cmn_err(CE_WARN, "Failed to create txq%d kstat", idx);
874 return (B_FALSE);
875 }
876
877
878 pStatsTxq = (qede_kstat_txq_t *)qede->kstats_txq[idx]->ks_data;
879
880 QEDE_KSTAT_TXQ(txBdTotal, KSTAT_DATA_UINT64);
881 QEDE_KSTAT_TXQ(txBdLeft, KSTAT_DATA_UINT64);
882 QEDE_KSTAT_TXQ(txBdPageCnt, KSTAT_DATA_UINT64);
883 QEDE_KSTAT_TXQ(txBdsPerPage, KSTAT_DATA_UINT64);
884 QEDE_KSTAT_TXQ(txBdSize, KSTAT_DATA_UINT64);
885 QEDE_KSTAT_TXQ(hwTxqConIdx, KSTAT_DATA_UINT64);
886 QEDE_KSTAT_TXQ(txBdProdIdx, KSTAT_DATA_UINT64);
887 QEDE_KSTAT_TXQ(txBdConsIdx, KSTAT_DATA_UINT64);
888 QEDE_KSTAT_TXQ(txLowWater, KSTAT_DATA_UINT64);
889 QEDE_KSTAT_TXQ(txDropPkts, KSTAT_DATA_UINT64);
890 QEDE_KSTAT_TXQ(txCopyPkts, KSTAT_DATA_UINT64);
891 QEDE_KSTAT_TXQ(txRingPause, KSTAT_DATA_UINT64);
892 QEDE_KSTAT_TXQ(txDropPkts, KSTAT_DATA_UINT64);
893 QEDE_KSTAT_TXQ(txBind, KSTAT_DATA_UINT64);
894 QEDE_KSTAT_TXQ(txBindFail, KSTAT_DATA_UINT64);
895 QEDE_KSTAT_TXQ(txPremapped, KSTAT_DATA_UINT64);
896 QEDE_KSTAT_TXQ(txPremappedFail, KSTAT_DATA_UINT64);
897 QEDE_KSTAT_TXQ(txTooManyCookies, KSTAT_DATA_UINT64);
898 QEDE_KSTAT_TXQ(txPullupPkts, KSTAT_DATA_UINT64);
899 QEDE_KSTAT_TXQ(txLsoPkts, KSTAT_DATA_UINT64);
900 QEDE_KSTAT_TXQ(txTooManyMblks, KSTAT_DATA_UINT64);
901 QEDE_KSTAT_TXQ(txMappedPkts, KSTAT_DATA_UINT64);
902 QEDE_KSTAT_TXQ(txJumboPkts, KSTAT_DATA_UINT64);
903 QEDE_KSTAT_TXQ(txRingTotalPkts, KSTAT_DATA_UINT64);
904 QEDE_KSTAT_TXQ(txRingTotalBytes, KSTAT_DATA_UINT64);
905
906 qede->kstats_txq_map[idx].idx = idx;
907 qede->kstats_txq_map[idx].qede = qede;
908
909 qede->kstats_txq[idx]->ks_update = qede_kstat_txq_update;
910 qede->kstats_txq[idx]->ks_private = (void *)&qede->kstats_txq_map[idx];
911
912 kstat_install(qede->kstats_txq[idx]);
913
914 return (B_TRUE);
915
916 }
917
918 boolean_t
919 qede_kstat_init(qede_t *qede)
920 {
921 qede_kstat_t *pStats;
922 qede_kstat_link_t *pStatsLink;
923 qede_kstat_intr_t *pStatsIntr;
924 qede_kstat_vport_stats_t *pStatsVport;
925 int i;
926
927 #define QEDE_KSTAT(f, t) kstat_named_init(&pStats->f, #f, t)
928 #define QEDE_KSTAT_LINK(f, t) kstat_named_init(&pStatsLink->f, #f, t)
929 #define QEDE_KSTAT_INTR(f, t) kstat_named_init(&pStatsIntr->f, #f, t)
930 #define QEDE_KSTAT_VPORT(f,t) kstat_named_init(&pStatsVport->f, #f, t)
931
932
933 if ((qede->kstats = kstat_create("qede",
934 qede->instance,
935 "stats",
936 "net",
937 KSTAT_TYPE_NAMED,
938 QEDE_KSTAT_SIZE,
939 0)) == NULL) {
940 /*QedeLogWarn(qede, "Failed to create kstat");*/
941 cmn_err(CE_WARN, "Failed to create kstat");
942 return (B_FALSE);
943 }
944
945 pStats = (qede_kstat_t *)qede->kstats->ks_data;
946 QEDE_KSTAT(qede_hi, KSTAT_DATA_CHAR);
947 QEDE_KSTAT(qede_lo, KSTAT_DATA_CHAR);
948 QEDE_KSTAT(version, KSTAT_DATA_CHAR);
949 QEDE_KSTAT(versionFW, KSTAT_DATA_CHAR);
950 QEDE_KSTAT(versionMFW, KSTAT_DATA_CHAR);
951 QEDE_KSTAT(chipID, KSTAT_DATA_CHAR);
952 QEDE_KSTAT(chipName, KSTAT_DATA_CHAR);
953 QEDE_KSTAT(devBDF, KSTAT_DATA_CHAR);
954 QEDE_KSTAT(devID, KSTAT_DATA_CHAR);
955 QEDE_KSTAT(multiFunction, KSTAT_DATA_CHAR);
956 QEDE_KSTAT(multiFunctionVnics, KSTAT_DATA_UINT64);
957 QEDE_KSTAT(macAddr, KSTAT_DATA_CHAR);
958 QEDE_KSTAT(hwInitDone, KSTAT_DATA_UINT64);
959 QEDE_KSTAT(numVports, KSTAT_DATA_UINT64);
960 QEDE_KSTAT(vportID, KSTAT_DATA_UINT64);
961 QEDE_KSTAT(intrAlloc, KSTAT_DATA_CHAR);
962 QEDE_KSTAT(intrFired, KSTAT_DATA_UINT64);
963 QEDE_KSTAT(lroEnabled, KSTAT_DATA_UINT64);
964 QEDE_KSTAT(lsoEnabled, KSTAT_DATA_UINT64);
965 QEDE_KSTAT(jumboEnabled, KSTAT_DATA_UINT64);
966 QEDE_KSTAT(txTotalPkts, KSTAT_DATA_UINT64);
967 QEDE_KSTAT(txTotalBytes, KSTAT_DATA_UINT64);
968 QEDE_KSTAT(txTotalDiscards, KSTAT_DATA_UINT64);
969 QEDE_KSTAT(rxTotalPkts, KSTAT_DATA_UINT64);
970 QEDE_KSTAT(rxTotalBytes, KSTAT_DATA_UINT64);
971 QEDE_KSTAT(rxTotalDiscards, KSTAT_DATA_UINT64);
972 QEDE_KSTAT(allocbFailures, KSTAT_DATA_UINT64);
973
974 qede->kstats->ks_update = qede_kstat_update;
975 qede->kstats->ks_private = (void *)qede;
976
977 kstat_install(qede->kstats);
978
979 /****************************************************************/
980 if ((qede->kstats_link = kstat_create("qede",
981 qede->instance,
982 "link",
983 "net",
984 KSTAT_TYPE_NAMED,
985 QEDE_KSTAT_LINK_SIZE,
986 0)) == NULL) {
987 /*BnxeLogWarn(qede, "Failed to create link kstat");*/
988 cmn_err(CE_WARN, "Failed to create link kstat");
989 qede_kstat_fini(qede);
990 return (B_FALSE);
991 }
992
993 pStatsLink = (qede_kstat_link_t *)qede->kstats_link->ks_data;
994
995 QEDE_KSTAT_LINK(vportID, KSTAT_DATA_UINT64);
996 QEDE_KSTAT_LINK(uptime, KSTAT_DATA_UINT64);
997 QEDE_KSTAT_LINK(mtuL2, KSTAT_DATA_UINT64);
998 QEDE_KSTAT_LINK(speed, KSTAT_DATA_UINT64);
999 QEDE_KSTAT_LINK(link, KSTAT_DATA_UINT64);
1000 QEDE_KSTAT_LINK(duplex, KSTAT_DATA_UINT64);
1001 QEDE_KSTAT_LINK(pauseRx, KSTAT_DATA_UINT64);
1002 QEDE_KSTAT_LINK(pauseTx, KSTAT_DATA_UINT64);
1003
1004 qede->kstats_link->ks_update = qede_kstat_link_update;
1005 qede->kstats_link->ks_private = (void *)qede;
1006
1007 kstat_install(qede->kstats_link);
1008
1009 /****************************************************************/
1010
1011 if ((qede->kstats_intr = kstat_create("qede",
1012 qede->instance,
1013 "intr",
1014 "net",
1015 KSTAT_TYPE_NAMED,
1016 QEDE_KSTAT_INTR_SIZE,
1017 0)) == NULL) {
1018 /*BnxeLogWarn(qede, "Failed to create intr kstat");*/
1019 cmn_err(CE_WARN, "Failed to create intr kstat");
1020 qede_kstat_fini(qede);
1021 return (B_FALSE);
1022 }
1023
1024
1025 pStatsIntr = (qede_kstat_intr_t *)qede->kstats_intr->ks_data;
1026
1027 QEDE_KSTAT_INTR(intrAlloc, KSTAT_DATA_CHAR);
1028 QEDE_KSTAT_INTR(intrFired, KSTAT_DATA_UINT64);
1029 QEDE_KSTAT_INTR(sb_00, KSTAT_DATA_UINT64);
1030 QEDE_KSTAT_INTR(sb_01, KSTAT_DATA_UINT64);
1031 QEDE_KSTAT_INTR(sb_02, KSTAT_DATA_UINT64);
1032 QEDE_KSTAT_INTR(sb_03, KSTAT_DATA_UINT64);
1033 QEDE_KSTAT_INTR(sb_04, KSTAT_DATA_UINT64);
1034 QEDE_KSTAT_INTR(sb_05, KSTAT_DATA_UINT64);
1035 QEDE_KSTAT_INTR(sb_06, KSTAT_DATA_UINT64);
1036 QEDE_KSTAT_INTR(sb_nc_00, KSTAT_DATA_UINT64);
1037 QEDE_KSTAT_INTR(sb_nc_01, KSTAT_DATA_UINT64);
1038 QEDE_KSTAT_INTR(sb_nc_02, KSTAT_DATA_UINT64);
1039 QEDE_KSTAT_INTR(sb_nc_03, KSTAT_DATA_UINT64);
1040 QEDE_KSTAT_INTR(sb_nc_04, KSTAT_DATA_UINT64);
1041 QEDE_KSTAT_INTR(sb_nc_05, KSTAT_DATA_UINT64);
1042 QEDE_KSTAT_INTR(sb_nc_06, KSTAT_DATA_UINT64);
1043 QEDE_KSTAT_INTR(sb_poll_00, KSTAT_DATA_UINT64);
1044 QEDE_KSTAT_INTR(sb_poll_01, KSTAT_DATA_UINT64);
1045 QEDE_KSTAT_INTR(sb_poll_02, KSTAT_DATA_UINT64);
1046 QEDE_KSTAT_INTR(sb_poll_03, KSTAT_DATA_UINT64);
1047 QEDE_KSTAT_INTR(sb_poll_04, KSTAT_DATA_UINT64);
1048 QEDE_KSTAT_INTR(sb_poll_05, KSTAT_DATA_UINT64);
1049 QEDE_KSTAT_INTR(sb_poll_06, KSTAT_DATA_UINT64);
1050 QEDE_KSTAT_INTR(sb_poll_nc_00, KSTAT_DATA_UINT64);
1051 QEDE_KSTAT_INTR(sb_poll_nc_01, KSTAT_DATA_UINT64);
1052 QEDE_KSTAT_INTR(sb_poll_nc_02, KSTAT_DATA_UINT64);
1053 QEDE_KSTAT_INTR(sb_poll_nc_03, KSTAT_DATA_UINT64);
1054 QEDE_KSTAT_INTR(sb_poll_nc_04, KSTAT_DATA_UINT64);
1055 QEDE_KSTAT_INTR(sb_poll_nc_05, KSTAT_DATA_UINT64);
1056 QEDE_KSTAT_INTR(sb_poll_nc_06, KSTAT_DATA_UINT64);
1057
1058 qede->kstats_intr->ks_update = qede_kstat_intr_update;
1059 qede->kstats_intr->ks_private = (void *)qede;
1060
1061 kstat_install(qede->kstats_intr);
1062
1063
1064 /****************************************************************/
1065
1066 if ((qede->kstats_vport = kstat_create("qede",
1067 qede->instance,
1068 "L2Stats",
1069 "net",
1070 KSTAT_TYPE_NAMED,
1071 QEDE_KSTAT_VPORT_STATS_SIZE,
1072 0)) == NULL) {
1073 /*BnxeLogWarn(qede, "Failed to create l2chip kstat");*/
1074 cmn_err(CE_WARN, "Failed to create L2Stats kstat");
1075 qede_kstat_fini(qede);
1076 return (B_FALSE);
1077 }
1078
1079 pStatsVport = (qede_kstat_vport_stats_t *)qede->kstats_vport->ks_data;
1080
1081 QEDE_KSTAT_VPORT(rxUcastBytes, KSTAT_DATA_UINT64);
1082 QEDE_KSTAT_VPORT(rxMcastBytes, KSTAT_DATA_UINT64);
1083 QEDE_KSTAT_VPORT(rxBcastBytes, KSTAT_DATA_UINT64);
1084 QEDE_KSTAT_VPORT(rxUcastPkts, KSTAT_DATA_UINT64);
1085 QEDE_KSTAT_VPORT(rxMcastPkts, KSTAT_DATA_UINT64);
1086 QEDE_KSTAT_VPORT(rxBcastPkts, KSTAT_DATA_UINT64);
1087 QEDE_KSTAT_VPORT(txUcastBytes, KSTAT_DATA_UINT64);
1088 QEDE_KSTAT_VPORT(txMcastBytes, KSTAT_DATA_UINT64);
1089 QEDE_KSTAT_VPORT(txBcastBytes, KSTAT_DATA_UINT64);
1090 QEDE_KSTAT_VPORT(txUcastPkts, KSTAT_DATA_UINT64);
1091 QEDE_KSTAT_VPORT(txMcastPkts, KSTAT_DATA_UINT64);
1092 QEDE_KSTAT_VPORT(txBcastPkts, KSTAT_DATA_UINT64);
1093 QEDE_KSTAT_VPORT(rx64bytePkts, KSTAT_DATA_UINT64);
1094 QEDE_KSTAT_VPORT(rx127bytePkts, KSTAT_DATA_UINT64);
1095 QEDE_KSTAT_VPORT(rx255bytePkts, KSTAT_DATA_UINT64);
1096 QEDE_KSTAT_VPORT(rx511bytePkts, KSTAT_DATA_UINT64);
1097 QEDE_KSTAT_VPORT(rx1023bytePkts, KSTAT_DATA_UINT64);
1098 QEDE_KSTAT_VPORT(rx1518bytePkts, KSTAT_DATA_UINT64);
1099 QEDE_KSTAT_VPORT(rx1518bytePkts, KSTAT_DATA_UINT64);
1100 QEDE_KSTAT_VPORT(rx1522bytePkts, KSTAT_DATA_UINT64);
1101 QEDE_KSTAT_VPORT(rx2047bytePkts, KSTAT_DATA_UINT64);
1102 QEDE_KSTAT_VPORT(rx4095bytePkts, KSTAT_DATA_UINT64);
1103 QEDE_KSTAT_VPORT(rx9216bytePkts, KSTAT_DATA_UINT64);
1104 QEDE_KSTAT_VPORT(rx16383bytePkts, KSTAT_DATA_UINT64);
1105 QEDE_KSTAT_VPORT(tx64bytePkts, KSTAT_DATA_UINT64);
1106 QEDE_KSTAT_VPORT(tx64to127bytePkts, KSTAT_DATA_UINT64);
1107 QEDE_KSTAT_VPORT(tx128to255bytePkts, KSTAT_DATA_UINT64);
1108 QEDE_KSTAT_VPORT(tx256to511bytePkts, KSTAT_DATA_UINT64);
1109 QEDE_KSTAT_VPORT(tx512to1023bytePkts, KSTAT_DATA_UINT64);
1110 QEDE_KSTAT_VPORT(tx1024to1518bytePkts, KSTAT_DATA_UINT64);
1111 QEDE_KSTAT_VPORT(tx1519to2047bytePkts, KSTAT_DATA_UINT64);
1112 QEDE_KSTAT_VPORT(tx2048to4095bytePkts, KSTAT_DATA_UINT64);
1113 QEDE_KSTAT_VPORT(tx4096to9216bytePkts, KSTAT_DATA_UINT64);
1114 QEDE_KSTAT_VPORT(tx9217to16383bytePkts, KSTAT_DATA_UINT64);
1115 QEDE_KSTAT_VPORT(rxMacCtrlFrames, KSTAT_DATA_UINT64);
1116 QEDE_KSTAT_VPORT(rxPauseFrames, KSTAT_DATA_UINT64);
1117 QEDE_KSTAT_VPORT(txPauseFrames, KSTAT_DATA_UINT64);
1118 QEDE_KSTAT_VPORT(rxCRCerrors, KSTAT_DATA_UINT64);
1119 QEDE_KSTAT_VPORT(rxAlignErrors, KSTAT_DATA_UINT64);
1120 QEDE_KSTAT_VPORT(rxCarrierErrors, KSTAT_DATA_UINT64);
1121 QEDE_KSTAT_VPORT(rxOversizeErrors, KSTAT_DATA_UINT64);
1122 QEDE_KSTAT_VPORT(rxJabbers, KSTAT_DATA_UINT64);
1123 QEDE_KSTAT_VPORT(rxUndersizePkts, KSTAT_DATA_UINT64);
1124 QEDE_KSTAT_VPORT(rxFragments, KSTAT_DATA_UINT64);
1125 QEDE_KSTAT_VPORT(txLpiEntryCnt, KSTAT_DATA_UINT64);
1126 QEDE_KSTAT_VPORT(txTotalCollisions, KSTAT_DATA_UINT64);
1127 QEDE_KSTAT_VPORT(brbTruncates, KSTAT_DATA_UINT64);
1128
1129 QEDE_KSTAT_VPORT(noBuffDiscards, KSTAT_DATA_UINT64);
1130 QEDE_KSTAT_VPORT(mftagFilterDiscards, KSTAT_DATA_UINT64);
1131 QEDE_KSTAT_VPORT(macFilterDiscards, KSTAT_DATA_UINT64);
1132 QEDE_KSTAT_VPORT(txErrDropPkts, KSTAT_DATA_UINT64);
1133 QEDE_KSTAT_VPORT(coalescedPkts, KSTAT_DATA_UINT64);
1134 QEDE_KSTAT_VPORT(coalescedEvents, KSTAT_DATA_UINT64);
1135 QEDE_KSTAT_VPORT(coalescedAbortsNum, KSTAT_DATA_UINT64);
1136 QEDE_KSTAT_VPORT(nonCoalescedPkts, KSTAT_DATA_UINT64);
1137 QEDE_KSTAT_VPORT(coalescedBytes, KSTAT_DATA_UINT64);
1138
1139 qede->kstats_vport->ks_update = qede_kstat_vport_stats_update;
1140 qede->kstats_vport->ks_private = (void *)qede;
1141
1142 kstat_install(qede->kstats_vport);
1143 for (i = 0; i < qede->num_fp; i++) {
1144 if(!qede_kstat_init_rxq(qede,i))
1145 {
1146 qede_kstat_fini(qede);
1147 return (B_FALSE);
1148 }
1149 if(!qede_kstat_init_txq(qede,i))
1150 {
1151 qede_kstat_fini(qede);
1152 return (B_FALSE);
1153 }
1154
1155 }
1156
1157 return (B_TRUE);
1158
1159 }
1160
1161 void
1162 qede_kstat_fini(qede_t *qede)
1163 {
1164 int i;
1165
1166 if(qede->kstats) {
1167 kstat_delete(qede->kstats);
1168 qede->kstats = NULL;
1169 }
1170 if(qede->kstats_link) {
1171 kstat_delete(qede->kstats_link);
1172 qede->kstats_link = NULL;
1173 }
1174 if(qede->kstats_intr) {
1175 kstat_delete(qede->kstats_intr);
1176 qede->kstats_intr = NULL;
1177 }
1178 if(qede->kstats_vport) {
1179 kstat_delete(qede->kstats_vport);
1180 qede->kstats_vport = NULL;
1181 }
1182
1183
1184 for (i = 0; i < qede->num_fp; i++) {
1185 if(qede->kstats_rxq[i]) {
1186 kstat_delete(qede->kstats_rxq[i]);
1187 qede->kstats_rxq[i] = NULL;
1188 }
1189 qede->kstats_rxq_map[i].idx = 0;
1190 qede->kstats_rxq_map[i].qede = NULL;
1191 if(qede->kstats_txq[i]) {
1192 kstat_delete(qede->kstats_txq[i]);
1193 qede->kstats_txq[i] = NULL;
1194 }
1195 qede->kstats_txq_map[i].idx = 0;
1196 qede->kstats_txq_map[i].qede = NULL;
1197 }
1198 }
Unleashed OS