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