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 2010 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 * Copyright 2018 Joyent, Inc.
25 */
26
27 /*
28 * MAC Services Module
29 */
30
31 #include <sys/types.h>
32 #include <sys/sysmacros.h>
33 #include <sys/stream.h>
34 #include <sys/kstat.h>
35 #include <sys/mac.h>
36 #include <sys/mac_impl.h>
37 #include <sys/mac_client_impl.h>
38 #include <sys/mac_stat.h>
39 #include <sys/mac_soft_ring.h>
40 #include <sys/vlan.h>
41
42 #define MAC_KSTAT_NAME "mac"
43 #define MAC_KSTAT_CLASS "net"
44
45 enum mac_stat {
46 MAC_STAT_LCL,
47 MAC_STAT_LCLBYTES,
48 MAC_STAT_INTRS,
49 MAC_STAT_INTRBYTES,
50 MAC_STAT_POLLS,
51 MAC_STAT_POLLBYTES,
52 MAC_STAT_RXSDROPS,
53 MAC_STAT_CHU10,
54 MAC_STAT_CH10T50,
55 MAC_STAT_CHO50,
56 MAC_STAT_BLOCK,
57 MAC_STAT_UNBLOCK,
58 MAC_STAT_TXSDROPS,
59 MAC_STAT_TX_ERRORS,
60 MAC_STAT_MACSPOOFED,
61 MAC_STAT_IPSPOOFED,
62 MAC_STAT_DHCPSPOOFED,
63 MAC_STAT_RESTRICTED,
64 MAC_STAT_DHCPDROPPED,
65 MAC_STAT_MULTIRCVBYTES,
66 MAC_STAT_BRDCSTRCVBYTES,
67 MAC_STAT_MULTIXMTBYTES,
68 MAC_STAT_BRDCSTXMTBYTES
69 };
70
71 static mac_stat_info_t i_mac_si[] = {
72 { MAC_STAT_IFSPEED, "ifspeed", KSTAT_DATA_UINT64, 0 },
73 { MAC_STAT_MULTIRCV, "multircv", KSTAT_DATA_UINT32, 0 },
74 { MAC_STAT_BRDCSTRCV, "brdcstrcv", KSTAT_DATA_UINT32, 0 },
75 { MAC_STAT_MULTIXMT, "multixmt", KSTAT_DATA_UINT32, 0 },
76 { MAC_STAT_BRDCSTXMT, "brdcstxmt", KSTAT_DATA_UINT32, 0 },
77 { MAC_STAT_NORCVBUF, "norcvbuf", KSTAT_DATA_UINT32, 0 },
78 { MAC_STAT_IERRORS, "ierrors", KSTAT_DATA_UINT32, 0 },
79 { MAC_STAT_UNKNOWNS, "unknowns", KSTAT_DATA_UINT32, 0 },
80 { MAC_STAT_NOXMTBUF, "noxmtbuf", KSTAT_DATA_UINT32, 0 },
81 { MAC_STAT_OERRORS, "oerrors", KSTAT_DATA_UINT32, 0 },
82 { MAC_STAT_COLLISIONS, "collisions", KSTAT_DATA_UINT32, 0 },
83 { MAC_STAT_UNDERFLOWS, "uflo", KSTAT_DATA_UINT32, 0 },
84 { MAC_STAT_OVERFLOWS, "oflo", KSTAT_DATA_UINT32, 0 },
85 { MAC_STAT_RBYTES, "rbytes", KSTAT_DATA_UINT32, 0 },
86 { MAC_STAT_IPACKETS, "ipackets", KSTAT_DATA_UINT32, 0 },
87 { MAC_STAT_OBYTES, "obytes", KSTAT_DATA_UINT32, 0 },
88 { MAC_STAT_OPACKETS, "opackets", KSTAT_DATA_UINT32, 0 },
89 { MAC_STAT_RBYTES, "rbytes64", KSTAT_DATA_UINT64, 0 },
90 { MAC_STAT_IPACKETS, "ipackets64", KSTAT_DATA_UINT64, 0 },
91 { MAC_STAT_OBYTES, "obytes64", KSTAT_DATA_UINT64, 0 },
92 { MAC_STAT_OPACKETS, "opackets64", KSTAT_DATA_UINT64, 0 }
93 };
94 #define MAC_NKSTAT \
95 (sizeof (i_mac_si) / sizeof (mac_stat_info_t))
96
97 static mac_stat_info_t i_mac_mod_si[] = {
98 { MAC_STAT_LINK_STATE, "link_state", KSTAT_DATA_UINT32,
99 (uint64_t)LINK_STATE_UNKNOWN },
100 { MAC_STAT_LINK_UP, "link_up", KSTAT_DATA_UINT32, 0 },
101 { MAC_STAT_PROMISC, "promisc", KSTAT_DATA_UINT32, 0 }
102 };
103 #define MAC_MOD_NKSTAT \
104 (sizeof (i_mac_mod_si) / sizeof (mac_stat_info_t))
105
106 #define MAC_MOD_KSTAT_OFFSET 0
107 #define MAC_KSTAT_OFFSET MAC_MOD_KSTAT_OFFSET + MAC_MOD_NKSTAT
108 #define MAC_TYPE_KSTAT_OFFSET MAC_KSTAT_OFFSET + MAC_NKSTAT
109
110 /*
111 * Definitions for per rx ring statistics
112 */
113 static mac_stat_info_t i_mac_rx_ring_si[] = {
114 { MAC_STAT_RBYTES, "rbytes", KSTAT_DATA_UINT64, 0},
115 { MAC_STAT_IPACKETS, "ipackets", KSTAT_DATA_UINT64, 0},
116 { MAC_STAT_HDROPS, "hdrops", KSTAT_DATA_UINT64, 0}
117 };
118 #define MAC_RX_RING_NKSTAT \
119 (sizeof (i_mac_rx_ring_si) / sizeof (mac_stat_info_t))
120
121 /*
122 * Definitions for per tx ring statistics
123 */
124 static mac_stat_info_t i_mac_tx_ring_si[] = {
125 { MAC_STAT_OBYTES, "obytes", KSTAT_DATA_UINT64, 0},
126 { MAC_STAT_OPACKETS, "opackets", KSTAT_DATA_UINT64, 0}
127 };
128 #define MAC_TX_RING_NKSTAT \
129 (sizeof (i_mac_tx_ring_si) / sizeof (mac_stat_info_t))
130
131
132 /*
133 * Definitions for per software lane tx statistics
134 */
135 static mac_stat_info_t i_mac_tx_swlane_si[] = {
136 { MAC_STAT_OBYTES, "obytes", KSTAT_DATA_UINT64, 0},
137 { MAC_STAT_OPACKETS, "opackets", KSTAT_DATA_UINT64, 0},
138 { MAC_STAT_OERRORS, "oerrors", KSTAT_DATA_UINT64, 0},
139 { MAC_STAT_BLOCK, "blockcnt", KSTAT_DATA_UINT64, 0},
140 { MAC_STAT_UNBLOCK, "unblockcnt", KSTAT_DATA_UINT64, 0},
141 { MAC_STAT_TXSDROPS, "txsdrops", KSTAT_DATA_UINT64, 0}
142 };
143 #define MAC_TX_SWLANE_NKSTAT \
144 (sizeof (i_mac_tx_swlane_si) / sizeof (mac_stat_info_t))
145
146 /*
147 * Definitions for per software lane rx statistics
148 */
149 static mac_stat_info_t i_mac_rx_swlane_si[] = {
150 { MAC_STAT_IPACKETS, "ipackets", KSTAT_DATA_UINT64, 0},
151 { MAC_STAT_RBYTES, "rbytes", KSTAT_DATA_UINT64, 0},
152 { MAC_STAT_LCL, "local", KSTAT_DATA_UINT64, 0},
153 { MAC_STAT_LCLBYTES, "localbytes", KSTAT_DATA_UINT64, 0},
154 { MAC_STAT_INTRS, "intrs", KSTAT_DATA_UINT64, 0},
155 { MAC_STAT_INTRBYTES, "intrbytes", KSTAT_DATA_UINT64, 0},
156 { MAC_STAT_RXSDROPS, "rxsdrops", KSTAT_DATA_UINT64, 0}
157 };
158 #define MAC_RX_SWLANE_NKSTAT \
159 (sizeof (i_mac_rx_swlane_si) / sizeof (mac_stat_info_t))
160
161 /*
162 * Definitions for per hardware lane rx statistics
163 */
164 static mac_stat_info_t i_mac_rx_hwlane_si[] = {
165 { MAC_STAT_IPACKETS, "ipackets", KSTAT_DATA_UINT64, 0},
166 { MAC_STAT_RBYTES, "rbytes", KSTAT_DATA_UINT64, 0},
167 { MAC_STAT_INTRS, "intrs", KSTAT_DATA_UINT64, 0},
168 { MAC_STAT_INTRBYTES, "intrbytes", KSTAT_DATA_UINT64, 0},
169 { MAC_STAT_POLLS, "polls", KSTAT_DATA_UINT64, 0},
170 { MAC_STAT_POLLBYTES, "pollbytes", KSTAT_DATA_UINT64, 0},
171 { MAC_STAT_RXSDROPS, "rxsdrops", KSTAT_DATA_UINT64, 0},
172 { MAC_STAT_CHU10, "chainunder10", KSTAT_DATA_UINT64, 0},
173 { MAC_STAT_CH10T50, "chain10to50", KSTAT_DATA_UINT64, 0},
174 { MAC_STAT_CHO50, "chainover50", KSTAT_DATA_UINT64, 0}
175 };
176 #define MAC_RX_HWLANE_NKSTAT \
177 (sizeof (i_mac_rx_hwlane_si) / sizeof (mac_stat_info_t))
178
179 /*
180 * Definitions for misc statistics
181 */
182 static mac_stat_info_t i_mac_misc_si[] = {
183 { MAC_STAT_MULTIRCV, "multircv", KSTAT_DATA_UINT64, 0},
184 { MAC_STAT_BRDCSTRCV, "brdcstrcv", KSTAT_DATA_UINT64, 0},
185 { MAC_STAT_MULTIXMT, "multixmt", KSTAT_DATA_UINT64, 0},
186 { MAC_STAT_BRDCSTXMT, "brdcstxmt", KSTAT_DATA_UINT64, 0},
187 { MAC_STAT_MULTIRCVBYTES, "multircvbytes", KSTAT_DATA_UINT64, 0},
188 { MAC_STAT_BRDCSTRCVBYTES, "brdcstrcvbytes", KSTAT_DATA_UINT64, 0},
189 { MAC_STAT_MULTIXMTBYTES, "multixmtbytes", KSTAT_DATA_UINT64, 0},
190 { MAC_STAT_BRDCSTXMTBYTES, "brdcstxmtbytes", KSTAT_DATA_UINT64, 0},
191 { MAC_STAT_TX_ERRORS, "txerrors", KSTAT_DATA_UINT64, 0},
192 { MAC_STAT_MACSPOOFED, "macspoofed", KSTAT_DATA_UINT64, 0},
193 { MAC_STAT_IPSPOOFED, "ipspoofed", KSTAT_DATA_UINT64, 0},
194 { MAC_STAT_DHCPSPOOFED, "dhcpspoofed", KSTAT_DATA_UINT64, 0},
195 { MAC_STAT_RESTRICTED, "restricted", KSTAT_DATA_UINT64, 0},
196 { MAC_STAT_DHCPDROPPED, "dhcpdropped", KSTAT_DATA_UINT64, 0},
197 { MAC_STAT_IPACKETS, "ipackets", KSTAT_DATA_UINT64, 0},
198 { MAC_STAT_RBYTES, "rbytes", KSTAT_DATA_UINT64, 0},
199 { MAC_STAT_LCL, "local", KSTAT_DATA_UINT64, 0},
200 { MAC_STAT_LCLBYTES, "localbytes", KSTAT_DATA_UINT64, 0},
201 { MAC_STAT_INTRS, "intrs", KSTAT_DATA_UINT64, 0},
202 { MAC_STAT_INTRBYTES, "intrbytes", KSTAT_DATA_UINT64, 0},
203 { MAC_STAT_POLLS, "polls", KSTAT_DATA_UINT64, 0},
204 { MAC_STAT_POLLBYTES, "pollbytes", KSTAT_DATA_UINT64, 0},
205 { MAC_STAT_RXSDROPS, "rxsdrops", KSTAT_DATA_UINT64, 0},
206 { MAC_STAT_CHU10, "chainunder10", KSTAT_DATA_UINT64, 0},
207 { MAC_STAT_CH10T50, "chain10to50", KSTAT_DATA_UINT64, 0},
208 { MAC_STAT_CHO50, "chainover50", KSTAT_DATA_UINT64, 0},
209 { MAC_STAT_OBYTES, "obytes", KSTAT_DATA_UINT64, 0},
210 { MAC_STAT_OPACKETS, "opackets", KSTAT_DATA_UINT64, 0},
211 { MAC_STAT_OERRORS, "oerrors", KSTAT_DATA_UINT64, 0},
212 { MAC_STAT_BLOCK, "blockcnt", KSTAT_DATA_UINT64, 0},
213 { MAC_STAT_UNBLOCK, "unblockcnt", KSTAT_DATA_UINT64, 0},
214 { MAC_STAT_TXSDROPS, "txsdrops", KSTAT_DATA_UINT64, 0}
215 };
216 #define MAC_SUMMARY_NKSTAT \
217 (sizeof (i_mac_misc_si) / sizeof (mac_stat_info_t))
218
219 /*
220 * Definitions for per hardware lane tx statistics
221 */
222 static mac_stat_info_t i_mac_tx_hwlane_si[] = {
223 { MAC_STAT_OBYTES, "obytes", KSTAT_DATA_UINT64, 0},
224 { MAC_STAT_OPACKETS, "opackets", KSTAT_DATA_UINT64, 0},
225 { MAC_STAT_OERRORS, "oerrors", KSTAT_DATA_UINT64, 0},
226 { MAC_STAT_BLOCK, "blockcnt", KSTAT_DATA_UINT64, 0},
227 { MAC_STAT_UNBLOCK, "unblockcnt", KSTAT_DATA_UINT64, 0},
228 { MAC_STAT_TXSDROPS, "txsdrops", KSTAT_DATA_UINT64, 0}
229 };
230 #define MAC_TX_HWLANE_NKSTAT \
231 (sizeof (i_mac_tx_hwlane_si) / sizeof (mac_stat_info_t))
232
233 /*
234 * Definitions for per fanout rx statistics
235 */
236 static mac_stat_info_t i_mac_rx_fanout_si[] = {
237 { MAC_STAT_RBYTES, "rbytes", KSTAT_DATA_UINT64, 0},
238 { MAC_STAT_IPACKETS, "ipackets", KSTAT_DATA_UINT64, 0},
239 };
240 #define MAC_RX_FANOUT_NKSTAT \
241 (sizeof (i_mac_rx_fanout_si) / sizeof (mac_stat_info_t))
242
243 /*
244 * Private functions.
245 */
246
247 typedef struct {
248 uint_t si_offset;
249 } stat_info_t;
250
251 #define RX_SRS_STAT_OFF(f) (offsetof(mac_rx_stats_t, f))
252 static stat_info_t rx_srs_stats_list[] = {
253 {RX_SRS_STAT_OFF(mrs_lclbytes)},
254 {RX_SRS_STAT_OFF(mrs_lclcnt)},
255 {RX_SRS_STAT_OFF(mrs_pollcnt)},
256 {RX_SRS_STAT_OFF(mrs_pollbytes)},
257 {RX_SRS_STAT_OFF(mrs_intrcnt)},
258 {RX_SRS_STAT_OFF(mrs_intrbytes)},
259 {RX_SRS_STAT_OFF(mrs_sdrops)},
260 {RX_SRS_STAT_OFF(mrs_chaincntundr10)},
261 {RX_SRS_STAT_OFF(mrs_chaincnt10to50)},
262 {RX_SRS_STAT_OFF(mrs_chaincntover50)},
263 {RX_SRS_STAT_OFF(mrs_ierrors)}
264 };
265 #define RX_SRS_STAT_SIZE \
266 (sizeof (rx_srs_stats_list) / sizeof (stat_info_t))
267
268 #define TX_SOFTRING_STAT_OFF(f) (offsetof(mac_tx_stats_t, f))
269 static stat_info_t tx_softring_stats_list[] = {
270 {TX_SOFTRING_STAT_OFF(mts_obytes)},
271 {TX_SOFTRING_STAT_OFF(mts_opackets)},
272 {TX_SOFTRING_STAT_OFF(mts_oerrors)},
273 {TX_SOFTRING_STAT_OFF(mts_blockcnt)},
274 {TX_SOFTRING_STAT_OFF(mts_unblockcnt)},
275 {TX_SOFTRING_STAT_OFF(mts_sdrops)},
276 };
277 #define TX_SOFTRING_STAT_SIZE \
278 (sizeof (tx_softring_stats_list) / sizeof (stat_info_t))
279
280 static void
281 i_mac_add_stats(void *sum, void *op1, void *op2,
282 stat_info_t stats_list[], uint_t size)
283 {
284 int i;
285
286 for (i = 0; i < size; i++) {
287 uint64_t *op1_val = (uint64_t *)
288 ((uchar_t *)op1 + stats_list[i].si_offset);
289 uint64_t *op2_val = (uint64_t *)
290 ((uchar_t *)op2 + stats_list[i].si_offset);
291 uint64_t *sum_val = (uint64_t *)
292 ((uchar_t *)sum + stats_list[i].si_offset);
293
294 *sum_val = *op1_val + *op2_val;
295 }
296 }
297
298 static int
299 i_mac_driver_stat_update(kstat_t *ksp, int rw)
300 {
301 mac_impl_t *mip = ksp->ks_private;
302 kstat_named_t *knp = ksp->ks_data;
303 uint_t i;
304 uint64_t val;
305 mac_stat_info_t *msi;
306 uint_t msi_index;
307
308 if (rw != KSTAT_READ)
309 return (EACCES);
310
311 for (i = 0; i < mip->mi_kstat_count; i++, msi_index++) {
312 if (i == MAC_MOD_KSTAT_OFFSET) {
313 msi_index = 0;
314 msi = i_mac_mod_si;
315 } else if (i == MAC_KSTAT_OFFSET) {
316 msi_index = 0;
317 msi = i_mac_si;
318 } else if (i == MAC_TYPE_KSTAT_OFFSET) {
319 msi_index = 0;
320 msi = mip->mi_type->mt_stats;
321 }
322
323 val = mac_stat_get((mac_handle_t)mip, msi[msi_index].msi_stat);
324 switch (msi[msi_index].msi_type) {
325 case KSTAT_DATA_UINT64:
326 knp->value.ui64 = val;
327 break;
328 case KSTAT_DATA_UINT32:
329 knp->value.ui32 = (uint32_t)val;
330 break;
331 default:
332 ASSERT(B_FALSE);
333 break;
334 }
335
336 knp++;
337 }
338
339 return (0);
340 }
341
342 static void
343 i_mac_kstat_init(kstat_named_t *knp, mac_stat_info_t *si, uint_t count)
344 {
345 int i;
346 for (i = 0; i < count; i++) {
347 kstat_named_init(knp, si[i].msi_name, si[i].msi_type);
348 knp++;
349 }
350 }
351
352 static int
353 i_mac_stat_update(kstat_t *ksp, int rw, uint64_t (*fn)(void *, uint_t),
354 mac_stat_info_t *msi, uint_t count)
355 {
356 kstat_named_t *knp = ksp->ks_data;
357 uint_t i;
358 uint64_t val;
359
360 if (rw != KSTAT_READ)
361 return (EACCES);
362
363 for (i = 0; i < count; i++) {
364 val = fn(ksp->ks_private, msi[i].msi_stat);
365
366 switch (msi[i].msi_type) {
367 case KSTAT_DATA_UINT64:
368 knp->value.ui64 = val;
369 break;
370 case KSTAT_DATA_UINT32:
371 knp->value.ui32 = (uint32_t)val;
372 break;
373 default:
374 ASSERT(B_FALSE);
375 break;
376 }
377 knp++;
378 }
379 return (0);
380 }
381
382 /*
383 * Create kstat with given name - statname, update function - fn
384 * and initialize it with given names - init_stat_info
385 */
386 static kstat_t *
387 i_mac_stat_create(void *handle, const char *modname, const char *statname,
388 int (*fn) (kstat_t *, int),
389 mac_stat_info_t *init_stat_info, uint_t count)
390 {
391 kstat_t *ksp;
392 kstat_named_t *knp;
393
394 ksp = kstat_create(modname, 0, statname, "net",
395 KSTAT_TYPE_NAMED, count, 0);
396
397 if (ksp == NULL)
398 return (NULL);
399
400 ksp->ks_update = fn;
401 ksp->ks_private = handle;
402
403 knp = (kstat_named_t *)ksp->ks_data;
404 i_mac_kstat_init(knp, init_stat_info, count);
405 kstat_install(ksp);
406
407 return (ksp);
408 }
409
410 /*
411 * Per rx ring statistics
412 */
413 uint64_t
414 mac_rx_ring_stat_get(void *handle, uint_t stat)
415 {
416 mac_ring_t *ring = (mac_ring_t *)handle;
417 uint64_t val = 0;
418
419 /*
420 * XXX Every ring-capable driver must implement an entry point to
421 * query per ring statistics. CR 6893122 tracks this work item.
422 * Once this bug is fixed, the framework should fail registration
423 * for a driver that does not implement this entry point and
424 * assert ring->mr_stat != NULL here.
425 */
426 if (ring->mr_stat != NULL)
427 ring->mr_stat(ring->mr_driver, stat, &val);
428
429 return (val);
430 }
431
432 static int
433 i_mac_rx_ring_stat_update(kstat_t *ksp, int rw)
434 {
435 return (i_mac_stat_update(ksp, rw, mac_rx_ring_stat_get,
436 i_mac_rx_ring_si, MAC_RX_RING_NKSTAT));
437 }
438
439 static void
440 i_mac_rx_ring_stat_create(mac_ring_t *ring, const char *modname,
441 const char *statname)
442 {
443 kstat_t *ksp;
444
445 ksp = i_mac_stat_create(ring, modname, statname,
446 i_mac_rx_ring_stat_update, i_mac_rx_ring_si, MAC_RX_RING_NKSTAT);
447
448 ring->mr_ksp = ksp;
449 }
450
451 /*
452 * Per tx ring statistics
453 */
454 uint64_t
455 mac_tx_ring_stat_get(void *handle, uint_t stat)
456 {
457 mac_ring_t *ring = (mac_ring_t *)handle;
458 uint64_t val = 0;
459
460 /*
461 * XXX Every ring-capable driver must implement an entry point to
462 * query per ring statistics. CR 6893122 tracks this work item.
463 * Once this bug is fixed, the framework should fail registration
464 * for a driver that does not implement this entry point and
465 * assert ring->mr_stat != NULL here.
466 */
467 if (ring->mr_stat != NULL)
468 ring->mr_stat(ring->mr_driver, stat, &val);
469
470 return (val);
471 }
472
473 static int
474 i_mac_tx_ring_stat_update(kstat_t *ksp, int rw)
475 {
476 return (i_mac_stat_update(ksp, rw, mac_tx_ring_stat_get,
477 i_mac_tx_ring_si, MAC_TX_RING_NKSTAT));
478 }
479
480 static void
481 i_mac_tx_ring_stat_create(mac_ring_t *ring, const char *modname,
482 const char *statname)
483 {
484 kstat_t *ksp;
485
486 ksp = i_mac_stat_create(ring, modname, statname,
487 i_mac_tx_ring_stat_update, i_mac_tx_ring_si, MAC_TX_RING_NKSTAT);
488
489 ring->mr_ksp = ksp;
490 }
491
492 /*
493 * Per software lane tx statistics
494 */
495 static uint64_t
496 i_mac_tx_swlane_stat_get(void *handle, uint_t stat)
497 {
498 mac_soft_ring_set_t *mac_srs = (mac_soft_ring_set_t *)handle;
499 mac_tx_stats_t *mac_tx_stat = &mac_srs->srs_tx.st_stat;
500
501 switch (stat) {
502 case MAC_STAT_OBYTES:
503 return (mac_tx_stat->mts_obytes);
504
505 case MAC_STAT_OPACKETS:
506 return (mac_tx_stat->mts_opackets);
507
508 case MAC_STAT_OERRORS:
509 return (mac_tx_stat->mts_oerrors);
510
511 case MAC_STAT_BLOCK:
512 return (mac_tx_stat->mts_blockcnt);
513
514 case MAC_STAT_UNBLOCK:
515 return (mac_tx_stat->mts_unblockcnt);
516
517 case MAC_STAT_TXSDROPS:
518 return (mac_tx_stat->mts_sdrops);
519
520 default:
521 return (0);
522 }
523 }
524
525 static int
526 i_mac_tx_swlane_stat_update(kstat_t *ksp, int rw)
527 {
528 return (i_mac_stat_update(ksp, rw, i_mac_tx_swlane_stat_get,
529 i_mac_tx_swlane_si, MAC_TX_SWLANE_NKSTAT));
530 }
531
532 static void
533 i_mac_tx_swlane_stat_create(mac_soft_ring_set_t *mac_srs, const char *modname,
534 const char *statname)
535 {
536 kstat_t *ksp;
537
538 ksp = i_mac_stat_create(mac_srs, modname, statname,
539 i_mac_tx_swlane_stat_update, i_mac_tx_swlane_si,
540 MAC_TX_SWLANE_NKSTAT);
541
542 mac_srs->srs_ksp = ksp;
543 }
544
545 /*
546 * Per software lane rx statistics
547 */
548 static uint64_t
549 i_mac_rx_swlane_stat_get(void *handle, uint_t stat)
550 {
551 mac_soft_ring_set_t *mac_srs = (mac_soft_ring_set_t *)handle;
552 mac_rx_stats_t *mac_rx_stat = &mac_srs->srs_rx.sr_stat;
553
554 switch (stat) {
555 case MAC_STAT_IPACKETS:
556 return (mac_rx_stat->mrs_intrcnt +
557 mac_rx_stat->mrs_lclcnt);
558
559 case MAC_STAT_RBYTES:
560 return (mac_rx_stat->mrs_intrbytes +
561 mac_rx_stat->mrs_lclbytes);
562
563 case MAC_STAT_LCL:
564 return (mac_rx_stat->mrs_lclcnt);
565
566 case MAC_STAT_LCLBYTES:
567 return (mac_rx_stat->mrs_lclbytes);
568
569 case MAC_STAT_INTRS:
570 return (mac_rx_stat->mrs_intrcnt);
571
572 case MAC_STAT_INTRBYTES:
573 return (mac_rx_stat->mrs_intrbytes);
574
575 case MAC_STAT_RXSDROPS:
576 return (mac_rx_stat->mrs_sdrops);
577
578 default:
579 return (0);
580 }
581 }
582
583 static int
584 i_mac_rx_swlane_stat_update(kstat_t *ksp, int rw)
585 {
586 return (i_mac_stat_update(ksp, rw, i_mac_rx_swlane_stat_get,
587 i_mac_rx_swlane_si, MAC_RX_SWLANE_NKSTAT));
588 }
589
590 static void
591 i_mac_rx_swlane_stat_create(mac_soft_ring_set_t *mac_srs, const char *modname,
592 const char *statname)
593 {
594 kstat_t *ksp;
595
596 ksp = i_mac_stat_create(mac_srs, modname, statname,
597 i_mac_rx_swlane_stat_update, i_mac_rx_swlane_si,
598 MAC_RX_SWLANE_NKSTAT);
599
600 mac_srs->srs_ksp = ksp;
601 }
602
603
604 /*
605 * Per hardware lane rx statistics
606 */
607 static uint64_t
608 i_mac_rx_hwlane_stat_get(void *handle, uint_t stat)
609 {
610 mac_soft_ring_set_t *mac_srs = (mac_soft_ring_set_t *)handle;
611 mac_rx_stats_t *mac_rx_stat = &mac_srs->srs_rx.sr_stat;
612
613 switch (stat) {
614 case MAC_STAT_IPACKETS:
615 return (mac_rx_stat->mrs_intrcnt +
616 mac_rx_stat->mrs_pollcnt);
617
618 case MAC_STAT_RBYTES:
619 return (mac_rx_stat->mrs_intrbytes +
620 mac_rx_stat->mrs_pollbytes);
621
622 case MAC_STAT_INTRS:
623 return (mac_rx_stat->mrs_intrcnt);
624
625 case MAC_STAT_INTRBYTES:
626 return (mac_rx_stat->mrs_intrbytes);
627
628 case MAC_STAT_POLLS:
629 return (mac_rx_stat->mrs_pollcnt);
630
631 case MAC_STAT_POLLBYTES:
632 return (mac_rx_stat->mrs_pollbytes);
633
634 case MAC_STAT_RXSDROPS:
635 return (mac_rx_stat->mrs_sdrops);
636
637 case MAC_STAT_CHU10:
638 return (mac_rx_stat->mrs_chaincntundr10);
639
640 case MAC_STAT_CH10T50:
641 return (mac_rx_stat->mrs_chaincnt10to50);
642
643 case MAC_STAT_CHO50:
644 return (mac_rx_stat->mrs_chaincntover50);
645
646 default:
647 return (0);
648 }
649 }
650
651 static int
652 i_mac_rx_hwlane_stat_update(kstat_t *ksp, int rw)
653 {
654 return (i_mac_stat_update(ksp, rw, i_mac_rx_hwlane_stat_get,
655 i_mac_rx_hwlane_si, MAC_RX_HWLANE_NKSTAT));
656 }
657
658 static void
659 i_mac_rx_hwlane_stat_create(mac_soft_ring_set_t *mac_srs, const char *modname,
660 const char *statname)
661 {
662 kstat_t *ksp;
663
664 ksp = i_mac_stat_create(mac_srs, modname, statname,
665 i_mac_rx_hwlane_stat_update, i_mac_rx_hwlane_si,
666 MAC_RX_HWLANE_NKSTAT);
667
668 mac_srs->srs_ksp = ksp;
669 }
670
671
672 /*
673 * Misc statistics
674 *
675 * Counts for
676 * - Multicast/broadcast Rx/Tx counts
677 * - Tx errors
678 */
679 static uint64_t
680 i_mac_misc_stat_get(void *handle, uint_t stat)
681 {
682 flow_entry_t *flent = handle;
683 mac_client_impl_t *mcip = flent->fe_mcip;
684 mac_misc_stats_t *mac_misc_stat = &mcip->mci_misc_stat;
685 mac_rx_stats_t *mac_rx_stat;
686 mac_tx_stats_t *mac_tx_stat;
687
688 mac_rx_stat = &mac_misc_stat->mms_defunctrxlanestats;
689 mac_tx_stat = &mac_misc_stat->mms_defuncttxlanestats;
690
691 switch (stat) {
692 case MAC_STAT_MULTIRCV:
693 return (mac_misc_stat->mms_multircv);
694
695 case MAC_STAT_BRDCSTRCV:
696 return (mac_misc_stat->mms_brdcstrcv);
697
698 case MAC_STAT_MULTIXMT:
699 return (mac_misc_stat->mms_multixmt);
700
701 case MAC_STAT_BRDCSTXMT:
702 return (mac_misc_stat->mms_brdcstxmt);
703
704 case MAC_STAT_MULTIRCVBYTES:
705 return (mac_misc_stat->mms_multircvbytes);
706
707 case MAC_STAT_BRDCSTRCVBYTES:
708 return (mac_misc_stat->mms_brdcstrcvbytes);
709
710 case MAC_STAT_MULTIXMTBYTES:
711 return (mac_misc_stat->mms_multixmtbytes);
712
713 case MAC_STAT_BRDCSTXMTBYTES:
714 return (mac_misc_stat->mms_brdcstxmtbytes);
715
716 case MAC_STAT_TX_ERRORS:
717 return (mac_misc_stat->mms_txerrors);
718
719 case MAC_STAT_MACSPOOFED:
720 return (mac_misc_stat->mms_macspoofed);
721
722 case MAC_STAT_IPSPOOFED:
723 return (mac_misc_stat->mms_ipspoofed);
724
725 case MAC_STAT_DHCPSPOOFED:
726 return (mac_misc_stat->mms_dhcpspoofed);
727
728 case MAC_STAT_RESTRICTED:
729 return (mac_misc_stat->mms_restricted);
730
731 case MAC_STAT_DHCPDROPPED:
732 return (mac_misc_stat->mms_dhcpdropped);
733
734 case MAC_STAT_IPACKETS:
735 return (mac_rx_stat->mrs_intrcnt +
736 mac_rx_stat->mrs_pollcnt);
737
738 case MAC_STAT_RBYTES:
739 return (mac_rx_stat->mrs_intrbytes +
740 mac_rx_stat->mrs_pollbytes);
741
742 case MAC_STAT_LCL:
743 return (mac_rx_stat->mrs_lclcnt);
744
745 case MAC_STAT_LCLBYTES:
746 return (mac_rx_stat->mrs_lclbytes);
747
748 case MAC_STAT_INTRS:
749 return (mac_rx_stat->mrs_intrcnt);
750
751 case MAC_STAT_INTRBYTES:
752 return (mac_rx_stat->mrs_intrbytes);
753
754 case MAC_STAT_POLLS:
755 return (mac_rx_stat->mrs_pollcnt);
756
757 case MAC_STAT_POLLBYTES:
758 return (mac_rx_stat->mrs_pollbytes);
759
760 case MAC_STAT_RXSDROPS:
761 return (mac_rx_stat->mrs_sdrops);
762
763 case MAC_STAT_CHU10:
764 return (mac_rx_stat->mrs_chaincntundr10);
765
766 case MAC_STAT_CH10T50:
767 return (mac_rx_stat->mrs_chaincnt10to50);
768
769 case MAC_STAT_CHO50:
770 return (mac_rx_stat->mrs_chaincntover50);
771
772 case MAC_STAT_OBYTES:
773 return (mac_tx_stat->mts_obytes);
774
775 case MAC_STAT_OPACKETS:
776 return (mac_tx_stat->mts_opackets);
777
778 case MAC_STAT_OERRORS:
779 return (mac_tx_stat->mts_oerrors);
780
781 case MAC_STAT_BLOCK:
782 return (mac_tx_stat->mts_blockcnt);
783
784 case MAC_STAT_UNBLOCK:
785 return (mac_tx_stat->mts_unblockcnt);
786
787 case MAC_STAT_TXSDROPS:
788 return (mac_tx_stat->mts_sdrops);
789
790 default:
791 return (0);
792 }
793 }
794
795 static int
796 i_mac_misc_stat_update(kstat_t *ksp, int rw)
797 {
798 return (i_mac_stat_update(ksp, rw, i_mac_misc_stat_get,
799 i_mac_misc_si, MAC_SUMMARY_NKSTAT));
800 }
801
802 static void
803 i_mac_misc_stat_create(flow_entry_t *flent, const char *modname,
804 const char *statname)
805 {
806 kstat_t *ksp;
807
808 ksp = i_mac_stat_create(flent, modname, statname,
809 i_mac_misc_stat_update, i_mac_misc_si,
810 MAC_SUMMARY_NKSTAT);
811
812 flent->fe_misc_stat_ksp = ksp;
813 }
814
815 /*
816 * Per hardware lane tx statistics
817 */
818 static uint64_t
819 i_mac_tx_hwlane_stat_get(void *handle, uint_t stat)
820 {
821 mac_soft_ring_t *ringp = (mac_soft_ring_t *)handle;
822 mac_tx_stats_t *mac_tx_stat = &ringp->s_st_stat;
823
824 switch (stat) {
825 case MAC_STAT_OBYTES:
826 return (mac_tx_stat->mts_obytes);
827
828 case MAC_STAT_OPACKETS:
829 return (mac_tx_stat->mts_opackets);
830
831 case MAC_STAT_OERRORS:
832 return (mac_tx_stat->mts_oerrors);
833
834 case MAC_STAT_BLOCK:
835 return (mac_tx_stat->mts_blockcnt);
836
837 case MAC_STAT_UNBLOCK:
838 return (mac_tx_stat->mts_unblockcnt);
839
840 case MAC_STAT_TXSDROPS:
841 return (mac_tx_stat->mts_sdrops);
842
843 default:
844 return (0);
845 }
846 }
847
848 static int
849 i_mac_tx_hwlane_stat_update(kstat_t *ksp, int rw)
850 {
851 return (i_mac_stat_update(ksp, rw, i_mac_tx_hwlane_stat_get,
852 i_mac_tx_hwlane_si, MAC_TX_HWLANE_NKSTAT));
853 }
854
855 static void
856 i_mac_tx_hwlane_stat_create(mac_soft_ring_t *ringp, const char *modname,
857 const char *statname)
858 {
859 kstat_t *ksp;
860
861 ksp = i_mac_stat_create(ringp, modname, statname,
862 i_mac_tx_hwlane_stat_update, i_mac_tx_hwlane_si,
863 MAC_TX_HWLANE_NKSTAT);
864
865 ringp->s_ring_ksp = ksp;
866 }
867
868 /*
869 * Per fanout rx statistics
870 */
871 static uint64_t
872 i_mac_rx_fanout_stat_get(void *handle, uint_t stat)
873 {
874 mac_soft_ring_t *tcp_ringp = (mac_soft_ring_t *)handle;
875 mac_soft_ring_t *udp_ringp = NULL, *oth_ringp = NULL;
876 mac_soft_ring_set_t *mac_srs = tcp_ringp->s_ring_set;
877 int index;
878 uint64_t val;
879
880 mutex_enter(&mac_srs->srs_lock);
881 /* Extract corresponding udp and oth ring pointers */
882 for (index = 0; mac_srs->srs_tcp_soft_rings[index] != NULL; index++) {
883 if (mac_srs->srs_tcp_soft_rings[index] == tcp_ringp) {
884 udp_ringp = mac_srs->srs_udp_soft_rings[index];
885 oth_ringp = mac_srs->srs_oth_soft_rings[index];
886 break;
887 }
888 }
889
890 ASSERT((udp_ringp != NULL) && (oth_ringp != NULL));
891
892 switch (stat) {
893 case MAC_STAT_RBYTES:
894 val = (tcp_ringp->s_ring_total_rbytes) +
895 (udp_ringp->s_ring_total_rbytes) +
896 (oth_ringp->s_ring_total_rbytes);
897 break;
898
899 case MAC_STAT_IPACKETS:
900 val = (tcp_ringp->s_ring_total_inpkt) +
901 (udp_ringp->s_ring_total_inpkt) +
902 (oth_ringp->s_ring_total_inpkt);
903 break;
904
905 default:
906 val = 0;
907 break;
908 }
909 mutex_exit(&mac_srs->srs_lock);
910 return (val);
911 }
912
913 static int
914 i_mac_rx_fanout_stat_update(kstat_t *ksp, int rw)
915 {
916 return (i_mac_stat_update(ksp, rw, i_mac_rx_fanout_stat_get,
917 i_mac_rx_fanout_si, MAC_RX_FANOUT_NKSTAT));
918 }
919
920 static void
921 i_mac_rx_fanout_stat_create(mac_soft_ring_t *ringp, const char *modname,
922 const char *statname)
923 {
924 kstat_t *ksp;
925
926 ksp = i_mac_stat_create(ringp, modname, statname,
927 i_mac_rx_fanout_stat_update, i_mac_rx_fanout_si,
928 MAC_RX_FANOUT_NKSTAT);
929
930 ringp->s_ring_ksp = ksp;
931 }
932
933 /*
934 * Exported functions.
935 */
936
937 /*
938 * Create the "mac" kstat. The "mac" kstat is comprised of three kinds of
939 * statistics: statistics maintained by the mac module itself, generic mac
940 * statistics maintained by the driver, and MAC-type specific statistics
941 * also maintained by the driver.
942 */
943 void
944 mac_driver_stat_create(mac_impl_t *mip)
945 {
946 kstat_t *ksp;
947 kstat_named_t *knp;
948 uint_t count;
949 major_t major = getmajor(mip->mi_phy_dev);
950
951 count = MAC_MOD_NKSTAT + MAC_NKSTAT + mip->mi_type->mt_statcount;
952 ksp = kstat_create((const char *)ddi_major_to_name(major),
953 getminor(mip->mi_phy_dev) - 1, MAC_KSTAT_NAME,
954 MAC_KSTAT_CLASS, KSTAT_TYPE_NAMED, count, 0);
955 if (ksp == NULL)
956 return;
957
958 ksp->ks_update = i_mac_driver_stat_update;
959 ksp->ks_private = mip;
960 mip->mi_ksp = ksp;
961 mip->mi_kstat_count = count;
962
963 knp = (kstat_named_t *)ksp->ks_data;
964 i_mac_kstat_init(knp, i_mac_mod_si, MAC_MOD_NKSTAT);
965 knp += MAC_MOD_NKSTAT;
966 i_mac_kstat_init(knp, i_mac_si, MAC_NKSTAT);
967 if (mip->mi_type->mt_statcount > 0) {
968 knp += MAC_NKSTAT;
969 i_mac_kstat_init(knp, mip->mi_type->mt_stats,
970 mip->mi_type->mt_statcount);
971 }
972
973 kstat_install(ksp);
974 }
975
976 /*ARGSUSED*/
977 void
978 mac_driver_stat_delete(mac_impl_t *mip)
979 {
980 if (mip->mi_ksp != NULL) {
981 kstat_delete(mip->mi_ksp);
982 mip->mi_ksp = NULL;
983 mip->mi_kstat_count = 0;
984 }
985 }
986
987 uint64_t
988 mac_driver_stat_default(mac_impl_t *mip, uint_t stat)
989 {
990 uint_t stat_index;
991
992 if (IS_MAC_STAT(stat)) {
993 stat_index = stat - MAC_STAT_MIN;
994 ASSERT(stat_index < MAC_NKSTAT);
995 return (i_mac_si[stat_index].msi_default);
996 }
997 ASSERT(IS_MACTYPE_STAT(stat));
998 stat_index = stat - MACTYPE_STAT_MIN;
999 ASSERT(stat_index < mip->mi_type->mt_statcount);
1000 return (mip->mi_type->mt_stats[stat_index].msi_default);
1001 }
1002
1003 void
1004 mac_ring_stat_create(mac_ring_t *ring)
1005 {
1006 mac_impl_t *mip = ring->mr_mip;
1007 mac_group_t *grp = (mac_group_t *)ring->mr_gh;
1008 char statname[MAXNAMELEN];
1009 char modname[MAXNAMELEN];
1010
1011 if (mip->mi_state_flags & MIS_IS_AGGR) {
1012 (void) strlcpy(modname, mip->mi_clients_list->mci_name,
1013 MAXNAMELEN);
1014 } else
1015 (void) strlcpy(modname, mip->mi_name, MAXNAMELEN);
1016
1017 switch (ring->mr_type) {
1018 case MAC_RING_TYPE_RX:
1019 (void) snprintf(statname, sizeof (statname),
1020 "mac_rx_ring_%d_%d", grp->mrg_index, ring->mr_index);
1021 i_mac_rx_ring_stat_create(ring, modname, statname);
1022 break;
1023
1024 case MAC_RING_TYPE_TX:
1025 (void) snprintf(statname, sizeof (statname), "mac_tx_ring%d",
1026 ring->mr_index);
1027 i_mac_tx_ring_stat_create(ring, modname, statname);
1028 break;
1029
1030 default:
1031 ASSERT(B_FALSE);
1032 break;
1033 }
1034 }
1035
1036 void
1037 mac_srs_stat_create(mac_soft_ring_set_t *mac_srs)
1038 {
1039 flow_entry_t *flent = mac_srs->srs_flent;
1040 char statname[MAXNAMELEN];
1041 boolean_t is_tx_srs;
1042
1043 /* No hardware/software lanes for user defined flows */
1044 if ((flent->fe_type & FLOW_USER) != 0)
1045 return;
1046
1047 is_tx_srs = ((mac_srs->srs_type & SRST_TX) != 0);
1048
1049 if (is_tx_srs) {
1050 mac_srs_tx_t *srs_tx = &mac_srs->srs_tx;
1051 mac_ring_t *ring = srs_tx->st_arg2;
1052
1053 if (ring != NULL) {
1054 (void) snprintf(statname, sizeof (statname),
1055 "mac_tx_hwlane%d", ring->mr_index);
1056 } else {
1057 (void) snprintf(statname, sizeof (statname),
1058 "mac_tx_swlane0");
1059 }
1060 i_mac_tx_swlane_stat_create(mac_srs, flent->fe_flow_name,
1061 statname);
1062 } else {
1063 mac_ring_t *ring = mac_srs->srs_ring;
1064
1065 if (ring == NULL) {
1066 (void) snprintf(statname, sizeof (statname),
1067 "mac_rx_swlane0");
1068 i_mac_rx_swlane_stat_create(mac_srs,
1069 flent->fe_flow_name, statname);
1070 } else {
1071 (void) snprintf(statname, sizeof (statname),
1072 "mac_rx_hwlane%d", ring->mr_index);
1073 i_mac_rx_hwlane_stat_create(mac_srs,
1074 flent->fe_flow_name, statname);
1075 }
1076 }
1077 }
1078
1079 void
1080 mac_misc_stat_create(flow_entry_t *flent)
1081 {
1082 char statname[MAXNAMELEN];
1083
1084 /* No misc stats for user defined or mcast/bcast flows */
1085 if (((flent->fe_type & FLOW_USER) != 0) ||
1086 ((flent->fe_type & FLOW_MCAST) != 0))
1087 return;
1088
1089 (void) snprintf(statname, sizeof (statname), "mac_misc_stat");
1090 i_mac_misc_stat_create(flent, flent->fe_flow_name, statname);
1091 }
1092
1093 void
1094 mac_soft_ring_stat_create(mac_soft_ring_t *ringp)
1095 {
1096 mac_soft_ring_set_t *mac_srs = ringp->s_ring_set;
1097 flow_entry_t *flent = ringp->s_ring_mcip->mci_flent;
1098 mac_ring_t *ring = (mac_ring_t *)ringp->s_ring_tx_arg2;
1099 boolean_t is_tx_srs;
1100 char statname[MAXNAMELEN];
1101
1102 /* No hardware/software lanes for user defined flows */
1103 if ((flent->fe_type & FLOW_USER) != 0)
1104 return;
1105
1106 is_tx_srs = ((mac_srs->srs_type & SRST_TX) != 0);
1107 if (is_tx_srs) { /* tx side hardware lane */
1108 ASSERT(ring != NULL);
1109 (void) snprintf(statname, sizeof (statname), "mac_tx_hwlane%d",
1110 ring->mr_index);
1111 i_mac_tx_hwlane_stat_create(ringp, flent->fe_flow_name,
1112 statname);
1113 } else { /* rx side fanout */
1114 /* Maintain single stat for (tcp, udp, oth) */
1115 if (ringp->s_ring_type & ST_RING_TCP) {
1116 int index;
1117 mac_soft_ring_t *softring;
1118
1119 for (index = 0, softring = mac_srs->srs_soft_ring_head;
1120 softring != NULL;
1121 index++, softring = softring->s_ring_next) {
1122 if (softring == ringp)
1123 break;
1124 }
1125
1126 if (mac_srs->srs_ring == NULL) {
1127 (void) snprintf(statname, sizeof (statname),
1128 "mac_rx_swlane0_fanout%d", index/3);
1129 } else {
1130 (void) snprintf(statname, sizeof (statname),
1131 "mac_rx_hwlane%d_fanout%d",
1132 mac_srs->srs_ring->mr_index, index/3);
1133 }
1134 i_mac_rx_fanout_stat_create(ringp, flent->fe_flow_name,
1135 statname);
1136 }
1137 }
1138 }
1139
1140 void
1141 mac_ring_stat_delete(mac_ring_t *ring)
1142 {
1143 if (ring->mr_ksp != NULL) {
1144 kstat_delete(ring->mr_ksp);
1145 ring->mr_ksp = NULL;
1146 }
1147 }
1148
1149 void
1150 mac_srs_stat_delete(mac_soft_ring_set_t *mac_srs)
1151 {
1152 boolean_t is_tx_srs;
1153
1154 is_tx_srs = ((mac_srs->srs_type & SRST_TX) != 0);
1155 if (!is_tx_srs) {
1156 /*
1157 * Rx ring has been taken away. Before destroying corresponding
1158 * SRS, save the stats recorded by that SRS.
1159 */
1160 mac_client_impl_t *mcip = mac_srs->srs_mcip;
1161 mac_misc_stats_t *mac_misc_stat = &mcip->mci_misc_stat;
1162 mac_rx_stats_t *mac_rx_stat = &mac_srs->srs_rx.sr_stat;
1163
1164 i_mac_add_stats(&mac_misc_stat->mms_defunctrxlanestats,
1165 mac_rx_stat, &mac_misc_stat->mms_defunctrxlanestats,
1166 rx_srs_stats_list, RX_SRS_STAT_SIZE);
1167 }
1168
1169 if (mac_srs->srs_ksp != NULL) {
1170 kstat_delete(mac_srs->srs_ksp);
1171 mac_srs->srs_ksp = NULL;
1172 }
1173 }
1174
1175 void
1176 mac_misc_stat_delete(flow_entry_t *flent)
1177 {
1178 if (flent->fe_misc_stat_ksp != NULL) {
1179 kstat_delete(flent->fe_misc_stat_ksp);
1180 flent->fe_misc_stat_ksp = NULL;
1181 }
1182 }
1183
1184 void
1185 mac_soft_ring_stat_delete(mac_soft_ring_t *ringp)
1186 {
1187 mac_soft_ring_set_t *mac_srs = ringp->s_ring_set;
1188 boolean_t is_tx_srs;
1189
1190 is_tx_srs = ((mac_srs->srs_type & SRST_TX) != 0);
1191 if (is_tx_srs) {
1192 /*
1193 * Tx ring has been taken away. Before destroying corresponding
1194 * soft ring, save the stats recorded by that soft ring.
1195 */
1196 mac_client_impl_t *mcip = mac_srs->srs_mcip;
1197 mac_misc_stats_t *mac_misc_stat = &mcip->mci_misc_stat;
1198 mac_tx_stats_t *mac_tx_stat = &ringp->s_st_stat;
1199
1200 i_mac_add_stats(&mac_misc_stat->mms_defuncttxlanestats,
1201 mac_tx_stat, &mac_misc_stat->mms_defuncttxlanestats,
1202 tx_softring_stats_list, TX_SOFTRING_STAT_SIZE);
1203 }
1204
1205 if (ringp->s_ring_ksp) {
1206 kstat_delete(ringp->s_ring_ksp);
1207 ringp->s_ring_ksp = NULL;
1208 }
1209 }
1210
1211 void
1212 mac_pseudo_ring_stat_rename(mac_impl_t *mip)
1213 {
1214 mac_group_t *group;
1215 mac_ring_t *ring;
1216
1217 /* Recreate pseudo rx ring kstats */
1218 for (group = mip->mi_rx_groups; group != NULL;
1219 group = group->mrg_next) {
1220 for (ring = group->mrg_rings; ring != NULL;
1221 ring = ring->mr_next) {
1222 mac_ring_stat_delete(ring);
1223 mac_ring_stat_create(ring);
1224 }
1225 }
1226
1227 /* Recreate pseudo tx ring kstats */
1228 for (group = mip->mi_tx_groups; group != NULL;
1229 group = group->mrg_next) {
1230 for (ring = group->mrg_rings; ring != NULL;
1231 ring = ring->mr_next) {
1232 mac_ring_stat_delete(ring);
1233 mac_ring_stat_create(ring);
1234 }
1235 }
1236 }
1237
1238 void
1239 mac_stat_rename(mac_client_impl_t *mcip)
1240 {
1241 flow_entry_t *flent = mcip->mci_flent;
1242 mac_soft_ring_set_t *mac_srs;
1243 mac_soft_ring_t *ringp;
1244 int i, j;
1245
1246 ASSERT(flent != NULL);
1247
1248 /* Recreate rx SRSes kstats */
1249 for (i = 0; i < flent->fe_rx_srs_cnt; i++) {
1250 mac_srs = (mac_soft_ring_set_t *)flent->fe_rx_srs[i];
1251 mac_srs_stat_delete(mac_srs);
1252 mac_srs_stat_create(mac_srs);
1253
1254 /* Recreate rx fanout kstats */
1255 for (j = 0; j < mac_srs->srs_tcp_ring_count; j++) {
1256 ringp = mac_srs->srs_tcp_soft_rings[j];
1257 mac_soft_ring_stat_delete(ringp);
1258 mac_soft_ring_stat_create(ringp);
1259 }
1260 }
1261
1262 /* Recreate tx SRS kstats */
1263 mac_srs = (mac_soft_ring_set_t *)flent->fe_tx_srs;
1264 mac_srs_stat_delete(mac_srs);
1265 mac_srs_stat_create(mac_srs);
1266
1267 /* Recreate tx sofring kstats */
1268 for (ringp = mac_srs->srs_soft_ring_head; ringp;
1269 ringp = ringp->s_ring_next) {
1270 mac_soft_ring_stat_delete(ringp);
1271 mac_soft_ring_stat_create(ringp);
1272 }
1273
1274 /* Recreate misc kstats */
1275 mac_misc_stat_delete(flent);
1276 mac_misc_stat_create(flent);
1277 }
1278
1279 void
1280 mac_tx_srs_stat_recreate(mac_soft_ring_set_t *tx_srs, boolean_t add_stats)
1281 {
1282 mac_client_impl_t *mcip = tx_srs->srs_mcip;
1283 mac_misc_stats_t *mac_misc_stat = &mcip->mci_misc_stat;
1284 mac_tx_stats_t *mac_tx_stat = &tx_srs->srs_tx.st_stat;
1285
1286 if (add_stats) {
1287 /* Add the stats to cumulative stats */
1288 i_mac_add_stats(&mac_misc_stat->mms_defuncttxlanestats,
1289 mac_tx_stat, &mac_misc_stat->mms_defuncttxlanestats,
1290 tx_softring_stats_list, TX_SOFTRING_STAT_SIZE);
1291 }
1292
1293 bzero(mac_tx_stat, sizeof (mac_tx_stats_t));
1294 mac_srs_stat_delete(tx_srs);
1295 mac_srs_stat_create(tx_srs);
1296 }