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 */
25
26 #include <sys/mdb_modapi.h>
27 #include <sys/types.h>
28 #include <inet/ip.h>
29 #include <inet/ip6.h>
30
31 #include <sys/mac.h>
32 #include <sys/mac_provider.h>
33 #include <sys/mac_client.h>
34 #include <sys/mac_client_impl.h>
35 #include <sys/mac_flow_impl.h>
36 #include <sys/mac_soft_ring.h>
37 #include <sys/mac_stat.h>
38
39 #define STRSIZE 64
40 #define MAC_RX_SRS_SIZE (MAX_RINGS_PER_GROUP * sizeof (uintptr_t))
41
42 #define LAYERED_WALKER_FOR_FLOW "flow_entry_cache"
43 #define LAYERED_WALKER_FOR_SRS "mac_srs_cache"
44 #define LAYERED_WALKER_FOR_RING "mac_ring_cache"
45 #define LAYERED_WALKER_FOR_GROUP "mac_impl_cache"
46
47 /* arguments passed to mac_flow dee-command */
48 #define MAC_FLOW_NONE 0x01
49 #define MAC_FLOW_ATTR 0x02
50 #define MAC_FLOW_PROP 0x04
51 #define MAC_FLOW_RX 0x08
52 #define MAC_FLOW_TX 0x10
53 #define MAC_FLOW_USER 0x20
54 #define MAC_FLOW_STATS 0x40
55 #define MAC_FLOW_MISC 0x80
56
57 /* arguments passed to mac_srs dee-command */
58 #define MAC_SRS_NONE 0x00
59 #define MAC_SRS_RX 0x01
60 #define MAC_SRS_TX 0x02
61 #define MAC_SRS_STAT 0x04
62 #define MAC_SRS_CPU 0x08
63 #define MAC_SRS_VERBOSE 0x10
64 #define MAC_SRS_INTR 0x20
65 #define MAC_SRS_RXSTAT (MAC_SRS_RX|MAC_SRS_STAT)
66 #define MAC_SRS_TXSTAT (MAC_SRS_TX|MAC_SRS_STAT)
67 #define MAC_SRS_RXCPU (MAC_SRS_RX|MAC_SRS_CPU)
68 #define MAC_SRS_TXCPU (MAC_SRS_TX|MAC_SRS_CPU)
69 #define MAC_SRS_RXCPUVERBOSE (MAC_SRS_RXCPU|MAC_SRS_VERBOSE)
70 #define MAC_SRS_TXCPUVERBOSE (MAC_SRS_TXCPU|MAC_SRS_VERBOSE)
71 #define MAC_SRS_RXINTR (MAC_SRS_RX|MAC_SRS_INTR)
72 #define MAC_SRS_TXINTR (MAC_SRS_TX|MAC_SRS_INTR)
73
74 /* arguments passed to mac_group dcmd */
75 #define MAC_GROUP_NONE 0x00
76 #define MAC_GROUP_RX 0x01
77 #define MAC_GROUP_TX 0x02
78 #define MAC_GROUP_UNINIT 0x04
79
80 static char *
81 mac_flow_proto2str(uint8_t protocol)
82 {
83 switch (protocol) {
84 case IPPROTO_TCP:
85 return ("tcp");
86 case IPPROTO_UDP:
87 return ("udp");
88 case IPPROTO_SCTP:
89 return ("sctp");
90 case IPPROTO_ICMP:
91 return ("icmp");
92 case IPPROTO_ICMPV6:
93 return ("icmpv6");
94 default:
95 return ("--");
96 }
97 }
98
99 static char *
100 mac_flow_priority2str(mac_priority_level_t prio)
101 {
102 switch (prio) {
103 case MPL_LOW:
104 return ("low");
105 case MPL_MEDIUM:
106 return ("medium");
107 case MPL_HIGH:
108 return ("high");
109 case MPL_RESET:
110 return ("reset");
111 default:
112 return ("--");
113 }
114 }
115
116 /*
117 * Convert bandwidth in bps to a string in Mbps.
118 */
119 static char *
120 mac_flow_bw2str(uint64_t bw, char *buf, ssize_t len)
121 {
122 int kbps, mbps;
123
124 kbps = (bw % 1000000)/1000;
125 mbps = bw/1000000;
126 if ((mbps == 0) && (kbps != 0))
127 mdb_snprintf(buf, len, "0.%03u", kbps);
128 else
129 mdb_snprintf(buf, len, "%5u", mbps);
130 return (buf);
131 }
132
133 static void
134 mac_flow_print_header(uint_t args)
135 {
136 switch (args) {
137 case MAC_FLOW_NONE:
138 mdb_printf("%?s %-20s %4s %?s %?s %-16s\n",
139 "", "", "LINK", "", "", "MIP");
140 mdb_printf("%<u>%?s %-20s %4s %?s %?s %-16s%</u>\n",
141 "ADDR", "FLOW NAME", "ID", "MCIP", "MIP", "NAME");
142 break;
143 case MAC_FLOW_ATTR:
144 mdb_printf("%<u>%?s %-32s %-7s %6s "
145 "%-9s %s%</u>\n",
146 "ADDR", "FLOW NAME", "PROTO", "PORT",
147 "DSFLD:MSK", "IPADDR");
148 break;
149 case MAC_FLOW_PROP:
150 mdb_printf("%<u>%?s %-32s %8s %9s%</u>\n",
151 "ADDR", "FLOW NAME", "MAXBW(M)", "PRIORITY");
152 break;
153 case MAC_FLOW_MISC:
154 mdb_printf("%<u>%?s %-24s %10s %10s "
155 "%20s %4s%</u>\n",
156 "ADDR", "FLOW NAME", "TYPE", "FLAGS",
157 "MATCH_FN", "ZONE");
158 break;
159 case MAC_FLOW_RX:
160 mdb_printf("%?s %-24s %3s %s\n", "", "", "SRS", "RX");
161 mdb_printf("%<u>%?s %-24s %3s %s%</u>\n",
162 "ADDR", "FLOW NAME", "CNT", "SRS");
163 break;
164 case MAC_FLOW_TX:
165 mdb_printf("%<u>%?s %-32s %?s %</u>\n",
166 "ADDR", "FLOW NAME", "TX_SRS");
167 break;
168 case MAC_FLOW_STATS:
169 mdb_printf("%<u>%?s %-32s %16s %16s%</u>\n",
170 "ADDR", "FLOW NAME", "RBYTES", "OBYTES");
171 break;
172 }
173 }
174
175 /*
176 * Display selected fields of the flow_entry_t structure
177 */
178 static int
179 mac_flow_dcmd_output(uintptr_t addr, uint_t flags, uint_t args)
180 {
181 static const mdb_bitmask_t flow_type_bits[] = {
182 {"P", FLOW_PRIMARY_MAC, FLOW_PRIMARY_MAC},
183 {"V", FLOW_VNIC_MAC, FLOW_VNIC_MAC},
184 {"M", FLOW_MCAST, FLOW_MCAST},
185 {"O", FLOW_OTHER, FLOW_OTHER},
186 {"U", FLOW_USER, FLOW_USER},
187 {"V", FLOW_VNIC, FLOW_VNIC},
188 {"NS", FLOW_NO_STATS, FLOW_NO_STATS},
189 { NULL, 0, 0 }
190 };
191 #define FLOW_MAX_TYPE (sizeof (flow_type_bits) / sizeof (mdb_bitmask_t))
192
193 static const mdb_bitmask_t flow_flag_bits[] = {
194 {"Q", FE_QUIESCE, FE_QUIESCE},
195 {"W", FE_WAITER, FE_WAITER},
196 {"T", FE_FLOW_TAB, FE_FLOW_TAB},
197 {"G", FE_G_FLOW_HASH, FE_G_FLOW_HASH},
198 {"I", FE_INCIPIENT, FE_INCIPIENT},
199 {"C", FE_CONDEMNED, FE_CONDEMNED},
200 {"NU", FE_UF_NO_DATAPATH, FE_UF_NO_DATAPATH},
201 {"NC", FE_MC_NO_DATAPATH, FE_MC_NO_DATAPATH},
202 { NULL, 0, 0 }
203 };
204 #define FLOW_MAX_FLAGS (sizeof (flow_flag_bits) / sizeof (mdb_bitmask_t))
205 flow_entry_t fe;
206 mac_client_impl_t mcip;
207 mac_impl_t mip;
208
209 if (mdb_vread(&fe, sizeof (fe), addr) == -1) {
210 mdb_warn("failed to read struct flow_entry_s at %p", addr);
211 return (DCMD_ERR);
212 }
213 if (args & MAC_FLOW_USER) {
214 args &= ~MAC_FLOW_USER;
215 if (fe.fe_type & FLOW_MCAST) {
216 if (DCMD_HDRSPEC(flags))
217 mac_flow_print_header(args);
218 return (DCMD_OK);
219 }
220 }
221 if (DCMD_HDRSPEC(flags))
222 mac_flow_print_header(args);
223 bzero(&mcip, sizeof (mcip));
224 bzero(&mip, sizeof (mip));
225 if (fe.fe_mcip != NULL && mdb_vread(&mcip, sizeof (mcip),
226 (uintptr_t)fe.fe_mcip) == sizeof (mcip)) {
227 (void) mdb_vread(&mip, sizeof (mip), (uintptr_t)mcip.mci_mip);
228 }
229 switch (args) {
230 case MAC_FLOW_NONE: {
231 mdb_printf("%?p %-20s %4d %?p "
232 "%?p %-16s\n",
233 addr, fe.fe_flow_name, fe.fe_link_id, fe.fe_mcip,
234 mcip.mci_mip, mip.mi_name);
235 break;
236 }
237 case MAC_FLOW_ATTR: {
238 struct in_addr in4;
239 uintptr_t desc_addr;
240 flow_desc_t fdesc;
241
242 desc_addr = addr + OFFSETOF(flow_entry_t, fe_flow_desc);
243 if (mdb_vread(&fdesc, sizeof (fdesc), desc_addr) == -1) {
244 mdb_warn("failed to read struct flow_description at %p",
245 desc_addr);
246 return (DCMD_ERR);
247 }
248 mdb_printf("%?p %-32s "
249 "%-7s %6d "
250 "%4d:%-4d ",
251 addr, fe.fe_flow_name,
252 mac_flow_proto2str(fdesc.fd_protocol), fdesc.fd_local_port,
253 fdesc.fd_dsfield, fdesc.fd_dsfield_mask);
254 if (fdesc.fd_ipversion == IPV4_VERSION) {
255 IN6_V4MAPPED_TO_INADDR(&fdesc.fd_local_addr, &in4);
256 mdb_printf("%I", in4.s_addr);
257 } else if (fdesc.fd_ipversion == IPV6_VERSION) {
258 mdb_printf("%N", &fdesc.fd_local_addr);
259 } else {
260 mdb_printf("%s", "--");
261 }
262 mdb_printf("\n");
263 break;
264 }
265 case MAC_FLOW_PROP: {
266 uintptr_t prop_addr;
267 char bwstr[STRSIZE];
268 mac_resource_props_t fprop;
269
270 prop_addr = addr + OFFSETOF(flow_entry_t, fe_resource_props);
271 if (mdb_vread(&fprop, sizeof (fprop), prop_addr) == -1) {
272 mdb_warn("failed to read struct mac_resoource_props "
273 "at %p", prop_addr);
274 return (DCMD_ERR);
275 }
276 mdb_printf("%?p %-32s "
277 "%8s %9s\n",
278 addr, fe.fe_flow_name,
279 mac_flow_bw2str(fprop.mrp_maxbw, bwstr, STRSIZE),
280 mac_flow_priority2str(fprop.mrp_priority));
281 break;
282 }
283 case MAC_FLOW_MISC: {
284 char flow_flags[2 * FLOW_MAX_FLAGS];
285 char flow_type[2 * FLOW_MAX_TYPE];
286 GElf_Sym sym;
287 char func_name[MDB_SYM_NAMLEN] = "";
288 uintptr_t func, match_addr;
289
290 match_addr = addr + OFFSETOF(flow_entry_t, fe_match);
291 (void) mdb_vread(&func, sizeof (func), match_addr);
292 (void) mdb_lookup_by_addr(func, MDB_SYM_EXACT, func_name,
293 MDB_SYM_NAMLEN, &sym);
294 mdb_snprintf(flow_flags, 2 * FLOW_MAX_FLAGS, "%hb",
295 fe.fe_flags, flow_flag_bits);
296 mdb_snprintf(flow_type, 2 * FLOW_MAX_TYPE, "%hb",
297 fe.fe_type, flow_type_bits);
298 mdb_printf("%?p %-24s %10s %10s %20s\n",
299 addr, fe.fe_flow_name, flow_type, flow_flags, func_name);
300 break;
301 }
302 case MAC_FLOW_RX: {
303 uintptr_t rxaddr, rx_srs[MAX_RINGS_PER_GROUP] = {0};
304 int i;
305
306 rxaddr = addr + OFFSETOF(flow_entry_t, fe_rx_srs);
307 (void) mdb_vread(rx_srs, MAC_RX_SRS_SIZE, rxaddr);
308 mdb_printf("%?p %-24s %3d ",
309 addr, fe.fe_flow_name, fe.fe_rx_srs_cnt);
310 for (i = 0; i < MAX_RINGS_PER_GROUP; i++) {
311 if (rx_srs[i] == 0)
312 continue;
313 mdb_printf("%p ", rx_srs[i]);
314 }
315 mdb_printf("\n");
316 break;
317 }
318 case MAC_FLOW_TX: {
319 uintptr_t tx_srs = 0, txaddr;
320
321 txaddr = addr + OFFSETOF(flow_entry_t, fe_tx_srs);
322 (void) mdb_vread(&tx_srs, sizeof (uintptr_t), txaddr);
323 mdb_printf("%?p %-32s %?p\n",
324 addr, fe.fe_flow_name, fe.fe_tx_srs);
325 break;
326 }
327 case MAC_FLOW_STATS: {
328 uint64_t totibytes = 0;
329 uint64_t totobytes = 0;
330 mac_soft_ring_set_t *mac_srs;
331 mac_rx_stats_t mac_rx_stat;
332 mac_tx_stats_t mac_tx_stat;
333 int i;
334
335 /*
336 * Sum bytes for all Rx SRS.
337 */
338 for (i = 0; i < fe.fe_rx_srs_cnt; i++) {
339 mac_srs = (mac_soft_ring_set_t *)(fe.fe_rx_srs[i]);
340 if (mdb_vread(&mac_rx_stat, sizeof (mac_rx_stats_t),
341 (uintptr_t)&mac_srs->srs_rx.sr_stat) == -1) {
342 mdb_warn("failed to read mac_rx_stats_t at %p",
343 &mac_srs->srs_rx.sr_stat);
344 return (DCMD_ERR);
345 }
346
347 totibytes += mac_rx_stat.mrs_intrbytes +
348 mac_rx_stat.mrs_pollbytes +
349 mac_rx_stat.mrs_lclbytes;
350 }
351
352 /*
353 * Sum bytes for Tx SRS.
354 */
355 mac_srs = (mac_soft_ring_set_t *)(fe.fe_tx_srs);
356 if (mac_srs != NULL) {
357 if (mdb_vread(&mac_tx_stat, sizeof (mac_tx_stats_t),
358 (uintptr_t)&mac_srs->srs_tx.st_stat) == -1) {
359 mdb_warn("failed to read max_tx_stats_t at %p",
360 &mac_srs->srs_tx.st_stat);
361 return (DCMD_ERR);
362 }
363
364 totobytes = mac_tx_stat.mts_obytes;
365 }
366
367 mdb_printf("%?p %-32s %16llu %16llu\n",
368 addr, fe.fe_flow_name, totibytes, totobytes);
369
370 break;
371 }
372 }
373 return (DCMD_OK);
374 }
375
376 /*
377 * Parse the arguments passed to the dcmd and print all or one flow_entry_t
378 * structures
379 */
380 static int
381 mac_flow_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
382 {
383 uint_t args = 0;
384
385 if (!(flags & DCMD_ADDRSPEC)) {
386 if (mdb_walk_dcmd("mac_flow", "mac_flow", argc, argv) == -1) {
387 mdb_warn("failed to walk 'mac_flow'");
388 return (DCMD_ERR);
389 }
390 return (DCMD_OK);
391 }
392 if ((mdb_getopts(argc, argv,
393 'a', MDB_OPT_SETBITS, MAC_FLOW_ATTR, &args,
394 'p', MDB_OPT_SETBITS, MAC_FLOW_PROP, &args,
395 'm', MDB_OPT_SETBITS, MAC_FLOW_MISC, &args,
396 'r', MDB_OPT_SETBITS, MAC_FLOW_RX, &args,
397 't', MDB_OPT_SETBITS, MAC_FLOW_TX, &args,
398 's', MDB_OPT_SETBITS, MAC_FLOW_STATS, &args,
399 'u', MDB_OPT_SETBITS, MAC_FLOW_USER, &args,
400 NULL) != argc)) {
401 return (DCMD_USAGE);
402 }
403 if (argc > 2 || (argc == 2 && !(args & MAC_FLOW_USER)))
404 return (DCMD_USAGE);
405 /*
406 * If no arguments was specified or just "-u" was specified then
407 * we default to printing basic information of flows.
408 */
409 if (args == 0 || args == MAC_FLOW_USER)
410 args |= MAC_FLOW_NONE;
411
412 return (mac_flow_dcmd_output(addr, flags, args));
413 }
414
415 static void
416 mac_flow_help(void)
417 {
418 mdb_printf("If an address is specified, then flow_entry structure at "
419 "that address is printed. Otherwise all the flows in the system "
420 "are printed.\n");
421 mdb_printf("Options:\n"
422 "\t-u\tdisplay user defined link & vnic flows.\n"
423 "\t-a\tdisplay flow attributes\n"
424 "\t-p\tdisplay flow properties\n"
425 "\t-r\tdisplay rx side information\n"
426 "\t-t\tdisplay tx side information\n"
427 "\t-s\tdisplay flow statistics\n"
428 "\t-m\tdisplay miscellaneous flow information\n\n");
429 mdb_printf("%<u>Interpreting Flow type and Flow flags output.%</u>\n");
430 mdb_printf("Flow Types:\n");
431 mdb_printf("\t P --> FLOW_PRIMARY_MAC\n");
432 mdb_printf("\t V --> FLOW_VNIC_MAC\n");
433 mdb_printf("\t M --> FLOW_MCAST\n");
434 mdb_printf("\t O --> FLOW_OTHER\n");
435 mdb_printf("\t U --> FLOW_USER\n");
436 mdb_printf("\t NS --> FLOW_NO_STATS\n\n");
437 mdb_printf("Flow Flags:\n");
438 mdb_printf("\t Q --> FE_QUIESCE\n");
439 mdb_printf("\t W --> FE_WAITER\n");
440 mdb_printf("\t T --> FE_FLOW_TAB\n");
441 mdb_printf("\t G --> FE_G_FLOW_HASH\n");
442 mdb_printf("\t I --> FE_INCIPIENT\n");
443 mdb_printf("\t C --> FE_CONDEMNED\n");
444 mdb_printf("\t NU --> FE_UF_NO_DATAPATH\n");
445 mdb_printf("\t NC --> FE_MC_NO_DATAPATH\n");
446 }
447
448 /*
449 * called once by the debugger when the mac_flow walk begins.
450 */
451 static int
452 mac_flow_walk_init(mdb_walk_state_t *wsp)
453 {
454 if (mdb_layered_walk(LAYERED_WALKER_FOR_FLOW, wsp) == -1) {
455 mdb_warn("failed to walk 'mac_flow'");
456 return (WALK_ERR);
457 }
458 return (WALK_NEXT);
459 }
460
461 /*
462 * Common walker step funciton for flow_entry_t, mac_soft_ring_set_t and
463 * mac_ring_t.
464 *
465 * Steps through each flow_entry_t and calls the callback function. If the
466 * user executed ::walk mac_flow, it just prints the address or if the user
467 * executed ::mac_flow it displays selected fields of flow_entry_t structure
468 * by calling "mac_flow_dcmd"
469 */
470 static int
471 mac_common_walk_step(mdb_walk_state_t *wsp)
472 {
473 int status;
474
475 if (wsp->walk_addr == 0)
476 return (WALK_DONE);
477
478 status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
479 wsp->walk_cbdata);
480
481 return (status);
482 }
483
484 static char *
485 mac_srs_txmode2str(mac_tx_srs_mode_t mode)
486 {
487 switch (mode) {
488 case SRS_TX_DEFAULT:
489 return ("DEF");
490 case SRS_TX_SERIALIZE:
491 return ("SER");
492 case SRS_TX_FANOUT:
493 return ("FO");
494 case SRS_TX_BW:
495 return ("BW");
496 case SRS_TX_BW_FANOUT:
497 return ("BWFO");
498 case SRS_TX_AGGR:
499 return ("AG");
500 case SRS_TX_BW_AGGR:
501 return ("BWAG");
502 }
503 return ("--");
504 }
505
506 static void
507 mac_srs_help(void)
508 {
509 mdb_printf("If an address is specified, then mac_soft_ring_set "
510 "structure at that address is printed. Otherwise all the "
511 "SRS in the system are printed.\n");
512 mdb_printf("Options:\n"
513 "\t-r\tdisplay recieve side SRS structures\n"
514 "\t-t\tdisplay transmit side SRS structures\n"
515 "\t-s\tdisplay statistics for RX or TX side\n"
516 "\t-c\tdisplay CPU binding for RX or TX side\n"
517 "\t-v\tverbose flag for CPU binding to list cpus\n"
518 "\t-i\tdisplay mac_ring_t and interrupt information\n"
519 "Note: use -r or -t (to specify RX or TX side respectively) along "
520 "with -c or -s\n");
521 mdb_printf("\n%<u>Interpreting TX Modes%</u>\n");
522 mdb_printf("\t DEF --> Default\n");
523 mdb_printf("\t SER --> Serialize\n");
524 mdb_printf("\t FO --> Fanout\n");
525 mdb_printf("\t BW --> Bandwidth\n");
526 mdb_printf("\tBWFO --> Bandwidth Fanout\n");
527 mdb_printf("\t AG --> Aggr\n");
528 mdb_printf("\tBWAG --> Bandwidth Aggr\n");
529 }
530
531 /*
532 * In verbose mode "::mac_srs -rcv or ::mac_srs -tcv", we print the CPUs
533 * assigned to a link and CPUS assigned to the soft rings.
534 * 'len' is used for formatting the output and represents the number of
535 * spaces between CPU list and Fanout CPU list in the output.
536 */
537 static boolean_t
538 mac_srs_print_cpu(int *i, uint32_t cnt, uint32_t *cpu_list, int *len)
539 {
540 int num = 0;
541
542 if (*i == 0)
543 mdb_printf("(");
544 else
545 mdb_printf(" ");
546 while (*i < cnt) {
547 /* We print 6 CPU's at a time to keep display within 80 cols */
548 if (((num + 1) % 7) == 0) {
549 if (len != NULL)
550 *len = 2;
551 return (B_FALSE);
552 }
553 mdb_printf("%02x%c", cpu_list[*i], ((*i == cnt - 1)?')':','));
554 ++*i;
555 ++num;
556 }
557 if (len != NULL)
558 *len = (7 - num) * 3;
559 return (B_TRUE);
560 }
561
562 static int
563 mac_srs_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
564 {
565 uint_t args = MAC_SRS_NONE;
566 mac_soft_ring_set_t srs;
567 mac_client_impl_t mci;
568
569 if (!(flags & DCMD_ADDRSPEC)) {
570 if (mdb_walk_dcmd("mac_srs", "mac_srs", argc, argv) == -1) {
571 mdb_warn("failed to walk 'mac_srs'");
572 return (DCMD_ERR);
573 }
574 return (DCMD_OK);
575 }
576 if (mdb_getopts(argc, argv,
577 'r', MDB_OPT_SETBITS, MAC_SRS_RX, &args,
578 't', MDB_OPT_SETBITS, MAC_SRS_TX, &args,
579 'c', MDB_OPT_SETBITS, MAC_SRS_CPU, &args,
580 'v', MDB_OPT_SETBITS, MAC_SRS_VERBOSE, &args,
581 'i', MDB_OPT_SETBITS, MAC_SRS_INTR, &args,
582 's', MDB_OPT_SETBITS, MAC_SRS_STAT, &args,
583 NULL) != argc) {
584 return (DCMD_USAGE);
585 }
586
587 if (argc > 2)
588 return (DCMD_USAGE);
589
590 if (mdb_vread(&srs, sizeof (srs), addr) == -1) {
591 mdb_warn("failed to read struct mac_soft_ring_set_s at %p",
592 addr);
593 return (DCMD_ERR);
594 }
595 if (mdb_vread(&mci, sizeof (mci), (uintptr_t)srs.srs_mcip) == -1) {
596 mdb_warn("failed to read struct mac_client_impl_t at %p "
597 "for SRS %p", srs.srs_mcip, addr);
598 return (DCMD_ERR);
599 }
600
601 switch (args) {
602 case MAC_SRS_RX: {
603 if (DCMD_HDRSPEC(flags)) {
604 mdb_printf("%?s %-20s %-8s %-8s %8s "
605 "%8s %3s\n",
606 "", "", "", "", "MBLK",
607 "Q", "SR");
608 mdb_printf("%<u>%?s %-20s %-8s %-8s %8s "
609 "%8s %3s%</u>\n",
610 "ADDR", "LINK_NAME", "STATE", "TYPE", "CNT",
611 "BYTES", "CNT");
612 }
613 if (srs.srs_type & SRST_TX)
614 return (DCMD_OK);
615 mdb_printf("%?p %-20s %08x %08x "
616 "%8d %8d %3d\n",
617 addr, mci.mci_name, srs.srs_state, srs.srs_type,
618 srs.srs_count, srs.srs_size, srs.srs_soft_ring_count);
619 break;
620 }
621 case MAC_SRS_TX: {
622 if (DCMD_HDRSPEC(flags)) {
623 mdb_printf("%?s %-16s %-4s %-8s "
624 "%-8s %8s %8s %3s\n",
625 "", "", "TX", "",
626 "", "MBLK", "Q", "SR");
627 mdb_printf("%<u>%?s %-16s %-4s %-8s "
628 "%-8s %8s %8s %3s%</u>\n",
629 "ADDR", "LINK_NAME", "MODE", "STATE",
630 "TYPE", "CNT", "BYTES", "CNT");
631 }
632 if (!(srs.srs_type & SRST_TX))
633 return (DCMD_OK);
634
635 mdb_printf("%?p %-16s %-4s "
636 "%08x %08x %8d %8d %3d\n",
637 addr, mci.mci_name, mac_srs_txmode2str(srs.srs_tx.st_mode),
638 srs.srs_state, srs.srs_type, srs.srs_count, srs.srs_size,
639 srs.srs_tx_ring_count);
640 break;
641 }
642 case MAC_SRS_RXCPU: {
643 mac_cpus_t mc = srs.srs_cpu;
644
645 if (DCMD_HDRSPEC(flags)) {
646 mdb_printf("%?s %-20s %-4s %-4s "
647 "%-6s %-4s %-7s\n",
648 "", "", "NUM", "POLL",
649 "WORKER", "INTR", "FANOUT");
650 mdb_printf("%<u>%?s %-20s %-4s %-4s "
651 "%-6s %-4s %-7s%</u>\n",
652 "ADDR", "LINK_NAME", "CPUS", "CPU",
653 "CPU", "CPU", "CPU_CNT");
654 }
655 if ((args & MAC_SRS_RX) && (srs.srs_type & SRST_TX))
656 return (DCMD_OK);
657 mdb_printf("%?p %-20s %-4d %-4d "
658 "%-6d %-4d %-7d\n",
659 addr, mci.mci_name, mc.mc_ncpus, mc.mc_rx_pollid,
660 mc.mc_rx_workerid, mc.mc_rx_intr_cpu, mc.mc_rx_fanout_cnt);
661 break;
662
663 }
664 case MAC_SRS_TXCPU: {
665 mac_cpus_t mc = srs.srs_cpu;
666 mac_soft_ring_t *s_ringp, s_ring;
667 boolean_t first = B_TRUE;
668 int i;
669
670 if (DCMD_HDRSPEC(flags)) {
671 mdb_printf("%?s %-12s %?s %8s %8s %8s\n",
672 "", "", "SOFT", "WORKER", "INTR", "RETARGETED");
673 mdb_printf("%<u>%?s %-12s %?s %8s %8s %8s%</u>\n",
674 "ADDR", "LINK_NAME", "RING", "CPU", "CPU", "CPU");
675 }
676 if (!(srs.srs_type & SRST_TX))
677 return (DCMD_OK);
678
679 mdb_printf("%?p %-12s ", addr, mci.mci_name);
680
681 /*
682 * Case of no soft rings, print the info from
683 * mac_srs_tx_t.
684 */
685 if (srs.srs_tx_ring_count == 0) {
686 mdb_printf("%?p %8d %8d %8d\n",
687 0, mc.mc_tx_fanout_cpus[0],
688 mc.mc_tx_intr_cpu[0],
689 mc.mc_tx_retargeted_cpu[0]);
690 break;
691 }
692
693 for (s_ringp = srs.srs_soft_ring_head, i = 0; s_ringp != NULL;
694 s_ringp = s_ring.s_ring_next, i++) {
695 (void) mdb_vread(&s_ring, sizeof (s_ring),
696 (uintptr_t)s_ringp);
697 if (first) {
698 mdb_printf("%?p %8d %8d %8d\n",
699 s_ringp, mc.mc_tx_fanout_cpus[i],
700 mc.mc_tx_intr_cpu[i],
701 mc.mc_tx_retargeted_cpu[i]);
702 first = B_FALSE;
703 continue;
704 }
705 mdb_printf("%?s %-12s %?p %8d %8d %8d\n",
706 "", "", s_ringp, mc.mc_tx_fanout_cpus[i],
707 mc.mc_tx_intr_cpu[i], mc.mc_tx_retargeted_cpu[i]);
708 }
709 break;
710 }
711 case MAC_SRS_TXINTR: {
712 mac_cpus_t mc = srs.srs_cpu;
713 mac_soft_ring_t *s_ringp, s_ring;
714 mac_ring_t *m_ringp, m_ring;
715 boolean_t first = B_TRUE;
716 int i;
717
718 if (DCMD_HDRSPEC(flags)) {
719 mdb_printf("%?s %-12s %?s %8s %?s %6s %6s\n",
720 "", "", "SOFT", "WORKER", "MAC", "", "INTR");
721 mdb_printf("%<u>%?s %-12s %?s %8s %?s %6s %6s%</u>\n",
722 "ADDR", "LINK_NAME", "RING", "CPU", "RING",
723 "SHARED", "CPU");
724 }
725 if (!(srs.srs_type & SRST_TX))
726 return (DCMD_OK);
727
728 mdb_printf("%?p %-12s ", addr, mci.mci_name);
729
730 /*
731 * Case of no soft rings, print the info from
732 * mac_srs_tx_t.
733 */
734 if (srs.srs_tx_ring_count == 0) {
735 m_ringp = srs.srs_tx.st_arg2;
736 if (m_ringp != NULL) {
737 (void) mdb_vread(&m_ring, sizeof (m_ring),
738 (uintptr_t)m_ringp);
739 mdb_printf("%?p %8d %?p %6d %6d\n",
740 0, mc.mc_tx_fanout_cpus[0], m_ringp,
741 m_ring.mr_info.mri_intr.mi_ddi_shared,
742 mc.mc_tx_retargeted_cpu[0]);
743 } else {
744 mdb_printf("%?p %8d %?p %6d %6d\n",
745 0, mc.mc_tx_fanout_cpus[0], 0,
746 0, mc.mc_tx_retargeted_cpu[0]);
747 }
748 break;
749 }
750
751 for (s_ringp = srs.srs_soft_ring_head, i = 0; s_ringp != NULL;
752 s_ringp = s_ring.s_ring_next, i++) {
753 (void) mdb_vread(&s_ring, sizeof (s_ring),
754 (uintptr_t)s_ringp);
755 m_ringp = s_ring.s_ring_tx_arg2;
756 (void) mdb_vread(&m_ring, sizeof (m_ring),
757 (uintptr_t)m_ringp);
758 if (first) {
759 mdb_printf("%?p %8d %?p %6d %6d\n",
760 s_ringp, mc.mc_tx_fanout_cpus[i],
761 m_ringp,
762 m_ring.mr_info.mri_intr.mi_ddi_shared,
763 mc.mc_tx_retargeted_cpu[i]);
764 first = B_FALSE;
765 continue;
766 }
767 mdb_printf("%?s %-12s %?p %8d %?p %6d %6d\n",
768 "", "", s_ringp, mc.mc_tx_fanout_cpus[i],
769 m_ringp, m_ring.mr_info.mri_intr.mi_ddi_shared,
770 mc.mc_tx_retargeted_cpu[i]);
771 }
772 break;
773 }
774 case MAC_SRS_RXINTR: {
775 mac_cpus_t mc = srs.srs_cpu;
776 mac_ring_t *m_ringp, m_ring;
777
778 if (DCMD_HDRSPEC(flags)) {
779 mdb_printf("%?s %-12s %?s %8s %6s %6s\n",
780 "", "", "MAC", "", "POLL", "INTR");
781 mdb_printf("%<u>%?s %-12s %?s %8s %6s %6s%</u>\n",
782 "ADDR", "LINK_NAME", "RING", "SHARED", "CPU",
783 "CPU");
784 }
785 if ((args & MAC_SRS_RX) && (srs.srs_type & SRST_TX))
786 return (DCMD_OK);
787
788 mdb_printf("%?p %-12s ", addr, mci.mci_name);
789
790 m_ringp = srs.srs_ring;
791 if (m_ringp != NULL) {
792 (void) mdb_vread(&m_ring, sizeof (m_ring),
793 (uintptr_t)m_ringp);
794 mdb_printf("%?p %8d %6d %6d\n",
795 m_ringp, m_ring.mr_info.mri_intr.mi_ddi_shared,
796 mc.mc_rx_pollid, mc.mc_rx_intr_cpu);
797 } else {
798 mdb_printf("%?p %8d %6d %6d\n",
799 0, 0, mc.mc_rx_pollid, mc.mc_rx_intr_cpu);
800 }
801 break;
802 }
803 case MAC_SRS_RXCPUVERBOSE:
804 case MAC_SRS_TXCPUVERBOSE: {
805 mac_cpus_t mc = srs.srs_cpu;
806 int cpu_index = 0, fanout_index = 0, len = 0;
807 boolean_t cpu_done = B_FALSE, fanout_done = B_FALSE;
808
809 if (DCMD_HDRSPEC(flags)) {
810 mdb_printf("%?s %-20s %-20s %-20s\n",
811 "", "", "CPU_COUNT", "FANOUT_CPU_COUNT");
812 mdb_printf("%<u>%?s %-20s "
813 "%-20s %-20s%</u>\n",
814 "ADDR", "LINK_NAME",
815 "(CPU_LIST)", "(CPU_LIST)");
816 }
817 if (((args & MAC_SRS_TX) && !(srs.srs_type & SRST_TX)) ||
818 ((args & MAC_SRS_RX) && (srs.srs_type & SRST_TX)))
819 return (DCMD_OK);
820 mdb_printf("%?p %-20s %-20d %-20d\n", addr, mci.mci_name,
821 mc.mc_ncpus, mc.mc_rx_fanout_cnt);
822 if (mc.mc_ncpus == 0 && mc.mc_rx_fanout_cnt == 0)
823 break;
824 /* print all cpus and cpus for soft rings */
825 while (!cpu_done || !fanout_done) {
826 boolean_t old_value = cpu_done;
827
828 if (!cpu_done) {
829 mdb_printf("%?s %20s ", "", "");
830 cpu_done = mac_srs_print_cpu(&cpu_index,
831 mc.mc_ncpus, mc.mc_cpus, &len);
832 }
833 if (!fanout_done) {
834 if (old_value)
835 mdb_printf("%?s %-40s", "", "");
836 else
837 mdb_printf("%*s", len, "");
838 fanout_done = mac_srs_print_cpu(&fanout_index,
839 mc.mc_rx_fanout_cnt,
840 mc.mc_rx_fanout_cpus, NULL);
841 }
842 mdb_printf("\n");
843 }
844 break;
845 }
846 case MAC_SRS_RXSTAT: {
847 mac_rx_stats_t *mac_rx_stat = &srs.srs_rx.sr_stat;
848
849 if (DCMD_HDRSPEC(flags)) {
850 mdb_printf("%?s %-16s %8s %8s "
851 "%8s %8s %8s\n",
852 "", "", "INTR", "POLL",
853 "CHAIN", "CHAIN", "CHAIN");
854 mdb_printf("%<u>%?s %-16s %8s %8s "
855 "%8s %8s %8s%</u>\n",
856 "ADDR", "LINK_NAME", "COUNT", "COUNT",
857 "<10", "10-50", ">50");
858 }
859 if (srs.srs_type & SRST_TX)
860 return (DCMD_OK);
861 mdb_printf("%?p %-16s %8d "
862 "%8d %8d "
863 "%8d %8d\n",
864 addr, mci.mci_name, mac_rx_stat->mrs_intrcnt,
865 mac_rx_stat->mrs_pollcnt, mac_rx_stat->mrs_chaincntundr10,
866 mac_rx_stat->mrs_chaincnt10to50,
867 mac_rx_stat->mrs_chaincntover50);
868 break;
869 }
870 case MAC_SRS_TXSTAT: {
871 mac_tx_stats_t *mac_tx_stat = &srs.srs_tx.st_stat;
872 mac_soft_ring_t *s_ringp, s_ring;
873 boolean_t first = B_TRUE;
874
875 if (DCMD_HDRSPEC(flags)) {
876 mdb_printf("%?s %-20s %?s %8s %8s %8s\n",
877 "", "", "SOFT", "DROP", "BLOCK", "UNBLOCK");
878 mdb_printf("%<u>%?s %-20s %?s %8s %8s %8s%</u>\n",
879 "ADDR", "LINK_NAME", "RING", "COUNT", "COUNT",
880 "COUNT");
881 }
882 if (!(srs.srs_type & SRST_TX))
883 return (DCMD_OK);
884
885 mdb_printf("%?p %-20s ", addr, mci.mci_name);
886
887 /*
888 * Case of no soft rings, print the info from
889 * mac_srs_tx_t.
890 */
891 if (srs.srs_tx_ring_count == 0) {
892 mdb_printf("%?p %8d %8d %8d\n",
893 0, mac_tx_stat->mts_sdrops,
894 mac_tx_stat->mts_blockcnt,
895 mac_tx_stat->mts_unblockcnt);
896 break;
897 }
898
899 for (s_ringp = srs.srs_soft_ring_head; s_ringp != NULL;
900 s_ringp = s_ring.s_ring_next) {
901 (void) mdb_vread(&s_ring, sizeof (s_ring),
902 (uintptr_t)s_ringp);
903 mac_tx_stat = &s_ring.s_st_stat;
904 if (first) {
905 mdb_printf("%?p %8d %8d %8d\n",
906 s_ringp, mac_tx_stat->mts_sdrops,
907 mac_tx_stat->mts_blockcnt,
908 mac_tx_stat->mts_unblockcnt);
909 first = B_FALSE;
910 continue;
911 }
912 mdb_printf("%?s %-20s %?p %8d %8d %8d\n",
913 "", "", s_ringp, mac_tx_stat->mts_sdrops,
914 mac_tx_stat->mts_blockcnt,
915 mac_tx_stat->mts_unblockcnt);
916 }
917 break;
918 }
919 case MAC_SRS_NONE: {
920 if (DCMD_HDRSPEC(flags)) {
921 mdb_printf("%<u>%?s %-20s %?s %?s %-3s%</u>\n",
922 "ADDR", "LINK_NAME", "FLENT", "HW RING", "DIR");
923 }
924 mdb_printf("%?p %-20s %?p %?p "
925 "%-3s ",
926 addr, mci.mci_name, srs.srs_flent, srs.srs_ring,
927 (srs.srs_type & SRST_TX ? "TX" : "RX"));
928 break;
929 }
930 default:
931 return (DCMD_USAGE);
932 }
933 return (DCMD_OK);
934 }
935
936 static int
937 mac_srs_walk_init(mdb_walk_state_t *wsp)
938 {
939 if (mdb_layered_walk(LAYERED_WALKER_FOR_SRS, wsp) == -1) {
940 mdb_warn("failed to walk 'mac_srs'");
941 return (WALK_ERR);
942 }
943 return (WALK_NEXT);
944 }
945
946 static char *
947 mac_ring_state2str(mac_ring_state_t state)
948 {
949 switch (state) {
950 case MR_FREE:
951 return ("free");
952 case MR_NEWLY_ADDED:
953 return ("new");
954 case MR_INUSE:
955 return ("inuse");
956 }
957 return ("--");
958 }
959
960 static char *
961 mac_ring_classify2str(mac_classify_type_t classify)
962 {
963 switch (classify) {
964 case MAC_NO_CLASSIFIER:
965 return ("no");
966 case MAC_SW_CLASSIFIER:
967 return ("sw");
968 case MAC_HW_CLASSIFIER:
969 return ("hw");
970 }
971 return ("--");
972 }
973
974 static int
975 mac_ring_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
976 {
977 mac_ring_t ring;
978 mac_group_t group;
979 flow_entry_t flent;
980 mac_soft_ring_set_t srs;
981
982 if (!(flags & DCMD_ADDRSPEC)) {
983 if (mdb_walk_dcmd("mac_ring", "mac_ring", argc, argv) == -1) {
984 mdb_warn("failed to walk 'mac_ring'");
985 return (DCMD_ERR);
986 }
987 return (DCMD_OK);
988 }
989 if (mdb_vread(&ring, sizeof (ring), addr) == -1) {
990 mdb_warn("failed to read struct mac_ring_s at %p", addr);
991 return (DCMD_ERR);
992 }
993 bzero(&flent, sizeof (flent));
994 if (mdb_vread(&srs, sizeof (srs), (uintptr_t)ring.mr_srs) != -1) {
995 (void) mdb_vread(&flent, sizeof (flent),
996 (uintptr_t)srs.srs_flent);
997 }
998 (void) mdb_vread(&group, sizeof (group), (uintptr_t)ring.mr_gh);
999 if (DCMD_HDRSPEC(flags)) {
1000 mdb_printf("%<u>%?s %4s %5s %4s %?s "
1001 "%5s %?s %?s %s %</u>\n",
1002 "ADDR", "TYPE", "STATE", "FLAG", "GROUP",
1003 "CLASS", "MIP", "SRS", "FLOW NAME");
1004 }
1005 mdb_printf("%?p %-4s "
1006 "%5s %04x "
1007 "%?p %-5s "
1008 "%?p %?p %s\n",
1009 addr, ((ring.mr_type == 1)? "RX" : "TX"),
1010 mac_ring_state2str(ring.mr_state), ring.mr_flag,
1011 ring.mr_gh, mac_ring_classify2str(ring.mr_classify_type),
1012 group.mrg_mh, ring.mr_srs, flent.fe_flow_name);
1013 return (DCMD_OK);
1014 }
1015
1016 static int
1017 mac_ring_walk_init(mdb_walk_state_t *wsp)
1018 {
1019 if (mdb_layered_walk(LAYERED_WALKER_FOR_RING, wsp) == -1) {
1020 mdb_warn("failed to walk `mac_ring`");
1021 return (WALK_ERR);
1022 }
1023 return (WALK_NEXT);
1024 }
1025
1026 static void
1027 mac_ring_help(void)
1028 {
1029 mdb_printf("If an address is specified, then mac_ring_t "
1030 "structure at that address is printed. Otherwise all the "
1031 "hardware rings in the system are printed.\n");
1032 }
1033
1034 /*
1035 * To walk groups we have to have our own somewhat-complicated state machine. We
1036 * basically start by walking the mac_impl_t walker as all groups are stored off
1037 * of the various mac_impl_t in the system. The tx and rx rings are kept
1038 * separately. So we'll need to walk through all the rx rings and then all of
1039 * the tx rings.
1040 */
1041 static int
1042 mac_group_walk_init(mdb_walk_state_t *wsp)
1043 {
1044 int ret;
1045
1046 if (wsp->walk_addr != 0) {
1047 mdb_warn("non-global walks are not supported\n");
1048 return (WALK_ERR);
1049 }
1050
1051 if ((ret = mdb_layered_walk(LAYERED_WALKER_FOR_GROUP, wsp)) == -1) {
1052 mdb_warn("couldn't walk '%s'", LAYERED_WALKER_FOR_GROUP);
1053 return (ret);
1054 }
1055
1056 return (WALK_NEXT);
1057 }
1058
1059 static int
1060 mac_group_walk_step(mdb_walk_state_t *wsp)
1061 {
1062 int ret;
1063 mac_impl_t mi;
1064 mac_group_t mg;
1065 uintptr_t mgp;
1066
1067 /*
1068 * Nothing to do if we can't find the layer above us. But the kmem
1069 * walkers are a bit unsporting, they don't actually read in the data
1070 * for us.
1071 */
1072 if (wsp->walk_addr == 0)
1073 return (WALK_DONE);
1074
1075 if (mdb_vread(&mi, sizeof (mac_impl_t), wsp->walk_addr) == -1) {
1076 mdb_warn("failed to read mac_impl_t at %p", wsp->walk_addr);
1077 return (DCMD_ERR);
1078 }
1079
1080 /*
1081 * First go for rx groups, then tx groups.
1082 */
1083 mgp = (uintptr_t)mi.mi_rx_groups;
1084 while (mgp != 0) {
1085 if (mdb_vread(&mg, sizeof (mac_group_t), mgp) == -1) {
1086 mdb_warn("failed to read mac_group_t at %p", mgp);
1087 return (WALK_ERR);
1088 }
1089
1090 ret = wsp->walk_callback(mgp, &mg, wsp->walk_cbdata);
1091 if (ret != WALK_NEXT)
1092 return (ret);
1093 mgp = (uintptr_t)mg.mrg_next;
1094 }
1095
1096 mgp = (uintptr_t)mi.mi_tx_groups;
1097 while (mgp != 0) {
1098 if (mdb_vread(&mg, sizeof (mac_group_t), mgp) == -1) {
1099 mdb_warn("failed to read mac_group_t at %p", mgp);
1100 return (WALK_ERR);
1101 }
1102
1103 ret = wsp->walk_callback(mgp, &mg, wsp->walk_cbdata);
1104 if (ret != WALK_NEXT)
1105 return (ret);
1106 mgp = (uintptr_t)mg.mrg_next;
1107 }
1108
1109 return (WALK_NEXT);
1110 }
1111
1112 static int
1113 mac_group_count_clients(mac_group_t *mgp)
1114 {
1115 int clients = 0;
1116 uintptr_t mcp = (uintptr_t)mgp->mrg_clients;
1117
1118 while (mcp != 0) {
1119 mac_grp_client_t c;
1120
1121 if (mdb_vread(&c, sizeof (c), mcp) == -1) {
1122 mdb_warn("failed to read mac_grp_client_t at %p", mcp);
1123 return (-1);
1124 }
1125 clients++;
1126 mcp = (uintptr_t)c.mgc_next;
1127 }
1128
1129 return (clients);
1130 }
1131
1132 static const char *
1133 mac_group_type(mac_group_t *mgp)
1134 {
1135 const char *ret;
1136
1137 switch (mgp->mrg_type) {
1138 case MAC_RING_TYPE_RX:
1139 ret = "RECEIVE";
1140 break;
1141 case MAC_RING_TYPE_TX:
1142 ret = "TRANSMIT";
1143 break;
1144 default:
1145 ret = "UNKNOWN";
1146 break;
1147 }
1148
1149 return (ret);
1150 }
1151
1152 static const char *
1153 mac_group_state(mac_group_t *mgp)
1154 {
1155 const char *ret;
1156
1157 switch (mgp->mrg_state) {
1158 case MAC_GROUP_STATE_UNINIT:
1159 ret = "UNINT";
1160 break;
1161 case MAC_GROUP_STATE_REGISTERED:
1162 ret = "REGISTERED";
1163 break;
1164 case MAC_GROUP_STATE_RESERVED:
1165 ret = "RESERVED";
1166 break;
1167 case MAC_GROUP_STATE_SHARED:
1168 ret = "SHARED";
1169 break;
1170 default:
1171 ret = "UNKNOWN";
1172 break;
1173 }
1174
1175 return (ret);
1176 }
1177
1178 static int
1179 mac_group_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1180 {
1181 uint_t args = MAC_SRS_NONE;
1182 mac_group_t mg;
1183 int clients;
1184
1185 if (!(flags & DCMD_ADDRSPEC)) {
1186 if (mdb_walk_dcmd("mac_group", "mac_group", argc, argv) == -1) {
1187 mdb_warn("failed to walk 'mac_group'");
1188 return (DCMD_ERR);
1189 }
1190
1191 return (DCMD_OK);
1192 }
1193
1194 if (mdb_getopts(argc, argv,
1195 'r', MDB_OPT_SETBITS, MAC_GROUP_RX, &args,
1196 't', MDB_OPT_SETBITS, MAC_GROUP_TX, &args,
1197 'u', MDB_OPT_SETBITS, MAC_GROUP_UNINIT, &args,
1198 NULL) != argc)
1199 return (DCMD_USAGE);
1200
1201 if (mdb_vread(&mg, sizeof (mac_group_t), addr) == -1) {
1202 mdb_warn("failed to read mac_group_t at %p", addr);
1203 return (DCMD_ERR);
1204 }
1205
1206 if (DCMD_HDRSPEC(flags) && !(flags & DCMD_PIPE_OUT)) {
1207 mdb_printf("%<u>%-?s %-8s %-10s %6s %8s %-?s%</u>\n",
1208 "ADDR", "TYPE", "STATE", "NRINGS", "NCLIENTS", "RINGS");
1209 }
1210
1211 if ((args & MAC_GROUP_RX) != 0 && mg.mrg_type != MAC_RING_TYPE_RX)
1212 return (DCMD_OK);
1213 if ((args & MAC_GROUP_TX) != 0 && mg.mrg_type != MAC_RING_TYPE_TX)
1214 return (DCMD_OK);
1215
1216 /*
1217 * By default, don't show uninitialized groups. They're not very
1218 * interesting. They have no rings and no clients.
1219 */
1220 if (mg.mrg_state == MAC_GROUP_STATE_UNINIT &&
1221 (args & MAC_GROUP_UNINIT) == 0)
1222 return (DCMD_OK);
1223
1224 if (flags & DCMD_PIPE_OUT) {
1225 mdb_printf("%lr\n", addr);
1226 return (DCMD_OK);
1227 }
1228
1229 clients = mac_group_count_clients(&mg);
1230 mdb_printf("%?p %-8s %-10s %6d %8d %?p\n", addr, mac_group_type(&mg),
1231 mac_group_state(&mg), mg.mrg_cur_count, clients, mg.mrg_rings);
1232
1233 return (DCMD_OK);
1234 }
1235
1236 /* Supported dee-commands */
1237 static const mdb_dcmd_t dcmds[] = {
1238 {"mac_flow", "?[-u] [-aprtsm]", "display Flow Entry structures",
1239 mac_flow_dcmd, mac_flow_help},
1240 {"mac_group", "?[-rtu]", "display MAC Ring Groups", mac_group_dcmd,
1241 NULL },
1242 {"mac_srs", "?[ -r[i|s|c[v]] | -t[i|s|c[v]] ]",
1243 "display MAC Soft Ring Set" " structures", mac_srs_dcmd,
1244 mac_srs_help},
1245 {"mac_ring", "?", "display MAC ring (hardware) structures",
1246 mac_ring_dcmd, mac_ring_help},
1247 { NULL }
1248 };
1249
1250 /* Supported walkers */
1251 static const mdb_walker_t walkers[] = {
1252 {"mac_flow", "walk list of flow entry structures", mac_flow_walk_init,
1253 mac_common_walk_step, NULL, NULL},
1254 {"mac_group", "walk list of ring group structures", mac_group_walk_init,
1255 mac_group_walk_step, NULL, NULL},
1256 {"mac_srs", "walk list of mac soft ring set structures",
1257 mac_srs_walk_init, mac_common_walk_step, NULL, NULL},
1258 {"mac_ring", "walk list of mac ring structures", mac_ring_walk_init,
1259 mac_common_walk_step, NULL, NULL},
1260 { NULL }
1261 };
1262
1263 static const mdb_modinfo_t modinfo = { MDB_API_VERSION, dcmds, walkers };
1264
1265 const mdb_modinfo_t *
1266 _mdb_init(void)
1267 {
1268 return (&modinfo);
1269 }