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 2008 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 #include <sys/types.h>
27 #include <sys/ksynch.h>
28 #include <sys/kmem.h>
29 #include <sys/errno.h>
30 #include <sys/ddi.h>
31
32 #include <sys/mdb_modapi.h>
33
34 #define __NSC_GEN__
35 #include <sys/nsc_thread.h>
36 #include <sys/nsctl/nsc_dev.h>
37 #include <sys/nsctl/nsc_gen.h>
38 #include <sys/nsctl/nsc_mem.h>
39 #include <sys/nsctl/nsctl.h>
40 #include <sys/nsctl/nsc_disk.h>
41
42
43 /*
44 * Data struct for the complex walks.
45 */
46
47 struct complex_args {
48 int argc;
49 mdb_arg_t *argv;
50 };
51
52
53 /*
54 * Bit definitions
55 */
56
57 #define NSC_RW_BITS \
58 { "NSC_READ", NSC_READ, NSC_READ }, \
59 { "NSC_WRITE", NSC_WRITE, NSC_WRITE }
60
61
62 static const mdb_bitmask_t nsc_bhflag_bits[] = {
63 NSC_RW_BITS,
64 { "NSC_PINNABLE", NSC_PINNABLE, NSC_PINNABLE },
65 { "NSC_NOBLOCK", NSC_NOBLOCK, NSC_NOBLOCK },
66 { "NSC_HALLOCATED", NSC_HALLOCATED, NSC_HALLOCATED },
67 { "NSC_HACTIVE", NSC_HACTIVE, NSC_HACTIVE },
68 { "NSC_BCOPY", NSC_BCOPY, NSC_BCOPY },
69 { "NSC_PAGEIO", NSC_PAGEIO, NSC_PAGEIO },
70 { "NSC_ABUF", NSC_ABUF, NSC_ABUF },
71 { "NSC_MIXED", NSC_MIXED, NSC_MIXED },
72 { "NSC_WRTHRU", NSC_WRTHRU, NSC_WRTHRU },
73 { "NSC_FORCED_WRTHRU", NSC_FORCED_WRTHRU, NSC_FORCED_WRTHRU },
74 { "NSC_NOCACHE", NSC_NOCACHE, NSC_NOCACHE },
75 { "NSC_QUEUE", NSC_QUEUE, NSC_QUEUE },
76 { "NSC_RDAHEAD", NSC_RDAHEAD, NSC_RDAHEAD },
77 { "NSC_NO_FORCED_WRTHRU", NSC_NO_FORCED_WRTHRU, NSC_NO_FORCED_WRTHRU },
78 { "NSC_METADATA", NSC_METADATA, NSC_METADATA },
79 { "NSC_SEQ_IO", NSC_SEQ_IO, NSC_SEQ_IO },
80 { NULL, 0, 0 }
81 };
82
83
84 static const mdb_bitmask_t nsc_fdflag_bits[] = {
85 NSC_RW_BITS,
86 { NULL, 0, 0 }
87 };
88
89
90 static const mdb_bitmask_t nsc_fdmode_bits[] = {
91 { "NSC_MULTI", NSC_MULTI, NSC_MULTI },
92 { NULL, 0, 0 }
93 };
94
95
96 static const mdb_bitmask_t nsc_type_bits[] = {
97 /* types */
98 { "NSC_NULL", NSC_NULL, NSC_NULL },
99 { "NSC_DEVICE", NSC_DEVICE, NSC_DEVICE },
100 { "NSC_FILE", NSC_FILE, NSC_FILE },
101 { "NSC_CACHE", NSC_CACHE, NSC_CACHE },
102 { "NSC_VCHR", NSC_VCHR, NSC_VCHR },
103 { "NSC_NCALL", NSC_NCALL, NSC_NCALL },
104
105 /* type flags */
106 { "NSC_ANON", NSC_ANON, NSC_ANON },
107
108 /* ids */
109 { "NSC_RAW_ID", NSC_RAW_ID, NSC_RAW_ID },
110 { "NSC_FILE_ID", NSC_FILE_ID, NSC_FILE_ID },
111 { "NSC_FREEZE_ID", NSC_FREEZE_ID, NSC_FREEZE_ID },
112 { "NSC_VCHR_ID", NSC_VCHR_ID, NSC_VCHR_ID },
113 { "NSC_NCALL_ID", NSC_NCALL_ID, NSC_NCALL_ID },
114 { "NSC_SDBC_ID", NSC_SDBC_ID, NSC_SDBC_ID },
115 { "NSC_RDCLR_ID", NSC_RDCLR_ID, NSC_RDCLR_ID },
116 { "NSC_RDCL_ID", NSC_RDCL_ID, NSC_RDCL_ID },
117 { "NSC_IIR_ID", NSC_IIR_ID, NSC_IIR_ID },
118 { "NSC_II_ID", NSC_II_ID, NSC_II_ID },
119 { "NSC_RDCHR_ID", NSC_RDCHR_ID, NSC_RDCHR_ID },
120 { "NSC_RDCH_ID", NSC_RDCH_ID, NSC_RDCH_ID },
121 { NULL, 0, 0 }
122 };
123
124
125 static const mdb_bitmask_t nsc_availpend_bits[] = {
126 NSC_RW_BITS,
127 { "_NSC_OPEN", _NSC_OPEN, _NSC_OPEN },
128 { "_NSC_CLOSE", _NSC_CLOSE, _NSC_CLOSE },
129 { "_NSC_PINNED", _NSC_PINNED, _NSC_PINNED },
130 { "_NSC_ATTACH", _NSC_ATTACH, _NSC_ATTACH },
131 { "_NSC_DETACH", _NSC_DETACH, _NSC_DETACH },
132 { "_NSC_OWNER", _NSC_OWNER, _NSC_OWNER },
133 { NULL, 0, 0 }
134 };
135
136
137 static const mdb_bitmask_t nsc_ioflag_bits[] = {
138 { "NSC_REFCNT", NSC_REFCNT, NSC_REFCNT },
139 { "NSC_FILTER", NSC_FILTER, NSC_FILTER },
140 { NULL, 0, 0 }
141 };
142
143
144 static const mdb_bitmask_t nstset_flag_bits[] = {
145 { "NST_SF_KILL", NST_SF_KILL, NST_SF_KILL },
146 { NULL, 0, 0 }
147 };
148
149
150 static const mdb_bitmask_t nst_flag_bits[] = {
151 { "NST_TF_INUSE", NST_TF_INUSE, NST_TF_INUSE },
152 { "NST_TF_ACTIVE", NST_TF_ACTIVE, NST_TF_ACTIVE },
153 { "NST_TF_PENDING", NST_TF_PENDING, NST_TF_PENDING },
154 { "NST_TF_DESTROY", NST_TF_DESTROY, NST_TF_DESTROY },
155 { "NST_TF_KILL", NST_TF_KILL, NST_TF_KILL },
156 { NULL, 0, 0 }
157 };
158
159
160 /*
161 * Global data.
162 */
163
164 static nsc_mem_t type_mem[20];
165 static int complex_walk;
166 static int complex_hdr;
167
168
169 /* ---------------------------------------------------------------------- */
170
171 /*
172 * Walker for an nsc_io chain.
173 * A global walk is assumed to start at _nsc_io_top.
174 */
175
176 static int
177 nsc_io_winit(mdb_walk_state_t *wsp)
178 {
179 if (wsp->walk_addr == NULL &&
180 mdb_readvar(&wsp->walk_addr, "_nsc_io_top") == -1) {
181 mdb_warn("unable to read '_nsc_io_top'");
182 return (WALK_ERR);
183 }
184
185 return (WALK_NEXT);
186 }
187
188
189 static int
190 nsc_io_wstep(mdb_walk_state_t *wsp)
191 {
192 uintptr_t next;
193 int status;
194
195 if (wsp->walk_addr == NULL)
196 return (WALK_DONE);
197
198 status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
199 wsp->walk_cbdata);
200
201 next = wsp->walk_addr + OFFSETOF(nsc_io_t, next);
202
203 if (mdb_vread(&wsp->walk_addr, sizeof (uintptr_t), next) == -1) {
204 mdb_warn("failed to read nsc_io_t.next at %p", next);
205 return (WALK_DONE);
206 }
207
208 return (status);
209 }
210
211
212 /* ---------------------------------------------------------------------- */
213
214 /*
215 * Walker for an nsc_dev chain.
216 * A global walk is assumed to start at _nsc_dev_top.
217 */
218
219 static int
220 nsc_dev_winit(mdb_walk_state_t *wsp)
221 {
222 if (wsp->walk_addr == NULL &&
223 mdb_readvar(&wsp->walk_addr, "_nsc_dev_top") == -1) {
224 mdb_warn("unable to read '_nsc_dev_top'");
225 return (WALK_ERR);
226 }
227
228 return (WALK_NEXT);
229 }
230
231
232 static int
233 nsc_dev_wstep(mdb_walk_state_t *wsp)
234 {
235 uintptr_t next;
236 int status;
237
238 if (wsp->walk_addr == NULL)
239 return (WALK_DONE);
240
241 status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
242 wsp->walk_cbdata);
243
244 next = wsp->walk_addr + OFFSETOF(nsc_dev_t, nsc_next);
245
246 if (mdb_vread(&wsp->walk_addr, sizeof (uintptr_t), next) == -1) {
247 mdb_warn("failed to read nsc_dev_t.nsc_next at %p", next);
248 return (WALK_DONE);
249 }
250
251 return (status);
252 }
253
254
255 /* ARGSUSED */
256
257 static void
258 nsc_dev_wfini(mdb_walk_state_t *wsp)
259 {
260 complex_walk = 0;
261 }
262
263
264 /* ---------------------------------------------------------------------- */
265
266 /*
267 * Walker for a chain of nsc_devval_t structures.
268 * Global walks start from _nsc_devval_top;
269 */
270
271 static int
272 nsc_devval_winit(mdb_walk_state_t *wsp)
273 {
274 if (wsp->walk_addr == NULL &&
275 mdb_readvar(&wsp->walk_addr, "_nsc_devval_top") == -1) {
276 mdb_warn("unable to read '_nsc_devval_top'");
277 return (WALK_ERR);
278 }
279
280 return (WALK_NEXT);
281 }
282
283
284 static int
285 nsc_devval_wstep(mdb_walk_state_t *wsp)
286 {
287 uintptr_t devval = wsp->walk_addr;
288 int status;
289
290 if (!devval)
291 return (WALK_DONE);
292
293 status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
294 wsp->walk_cbdata);
295
296 /* move on to next devval */
297
298 if (mdb_vread(&wsp->walk_addr, sizeof (wsp->walk_addr),
299 devval + OFFSETOF(nsc_devval_t, dv_next)) == -1) {
300 mdb_warn("failed to read nsc_devval_t.dv_next");
301 return (WALK_ERR);
302 }
303
304 return (status);
305 }
306
307
308 /* ---------------------------------------------------------------------- */
309
310 /*
311 * Walker for a chain of nsc_fd_t structures.
312 * No global walks.
313 */
314
315 static int
316 nsc_fd_winit(mdb_walk_state_t *wsp)
317 {
318 if (wsp->walk_addr == NULL) {
319 mdb_warn("nsc_fd doesn't support global walks");
320 return (WALK_ERR);
321 }
322
323 return (WALK_NEXT);
324 }
325
326
327 static int
328 nsc_fd_wstep(mdb_walk_state_t *wsp)
329 {
330 uintptr_t fd = wsp->walk_addr;
331 int status;
332
333 if (!fd)
334 return (WALK_DONE);
335
336 status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
337 wsp->walk_cbdata);
338
339 /* move on to next fd */
340
341 if (mdb_vread(&wsp->walk_addr, sizeof (wsp->walk_addr),
342 fd + OFFSETOF(nsc_fd_t, sf_next)) == -1) {
343 mdb_warn("failed to read nsc_fd_t.sf_next");
344 return (WALK_ERR);
345 }
346
347 return (status);
348 }
349
350
351 /* ---------------------------------------------------------------------- */
352
353 /*
354 * Walker for a chain of nsc_iodev_t structures.
355 * No global walks.
356 */
357
358 static int
359 nsc_iodev_winit(mdb_walk_state_t *wsp)
360 {
361 if (wsp->walk_addr == NULL) {
362 mdb_warn("nsc_iodev doesn't support global walks");
363 return (WALK_ERR);
364 }
365
366 return (WALK_NEXT);
367 }
368
369
370 static int
371 nsc_iodev_wstep(mdb_walk_state_t *wsp)
372 {
373 uintptr_t iodev = wsp->walk_addr;
374 int status;
375
376 if (!iodev)
377 return (WALK_DONE);
378
379 status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
380 wsp->walk_cbdata);
381
382 if (mdb_vread(&wsp->walk_addr, sizeof (wsp->walk_addr),
383 iodev + OFFSETOF(nsc_iodev_t, si_next)) == -1) {
384 mdb_warn("failed to read nsc_iodev_t.si_next");
385 return (WALK_ERR);
386 }
387
388 return (status);
389 }
390
391
392 /* ---------------------------------------------------------------------- */
393
394 /*
395 * Walker for a chain of nsc_service_t structures.
396 * Global walks start at _nsc_services.
397 */
398
399 static int
400 nsc_service_winit(mdb_walk_state_t *wsp)
401 {
402 if (wsp->walk_addr == NULL &&
403 mdb_readvar(&wsp->walk_addr, "_nsc_services") == -1) {
404 mdb_warn("unable to read '_nsc_services'");
405 return (WALK_ERR);
406 }
407
408 return (WALK_NEXT);
409 }
410
411
412 static int
413 nsc_service_wstep(mdb_walk_state_t *wsp)
414 {
415 uintptr_t service = wsp->walk_addr;
416 int status;
417
418 if (!service)
419 return (WALK_DONE);
420
421 status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
422 wsp->walk_cbdata);
423
424 /* move on to next service */
425
426 if (mdb_vread(&wsp->walk_addr, sizeof (wsp->walk_addr),
427 service + OFFSETOF(nsc_service_t, s_next)) == -1) {
428 mdb_warn("failed to read nsc_service_t.s_next");
429 return (WALK_ERR);
430 }
431
432 return (status);
433 }
434
435
436 /* ---------------------------------------------------------------------- */
437
438 /*
439 * Walker for a chain of nsc_svc_t structures.
440 * No global walks.
441 */
442
443 static int
444 nsc_svc_winit(mdb_walk_state_t *wsp)
445 {
446 if (wsp->walk_addr == NULL) {
447 mdb_warn("nsc_svc does not support global walks");
448 return (WALK_ERR);
449 }
450
451 return (WALK_NEXT);
452 }
453
454
455 static int
456 nsc_svc_wstep(mdb_walk_state_t *wsp)
457 {
458 uintptr_t svc = wsp->walk_addr;
459 int status;
460
461 if (!svc)
462 return (WALK_DONE);
463
464 status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
465 wsp->walk_cbdata);
466
467 /* move on to next svc */
468
469 if (mdb_vread(&wsp->walk_addr, sizeof (wsp->walk_addr),
470 svc + OFFSETOF(nsc_svc_t, svc_next)) == -1) {
471 mdb_warn("failed to read nsc_svc_t.svc_next");
472 return (WALK_ERR);
473 }
474
475 return (status);
476 }
477
478
479 /* ---------------------------------------------------------------------- */
480
481 /*
482 * Walker for a chain of nsc_val_t structures.
483 * No global walks.
484 */
485
486 static int
487 nsc_val_winit(mdb_walk_state_t *wsp)
488 {
489 if (wsp->walk_addr == NULL) {
490 mdb_warn("nsc_val doesn't support global walks");
491 return (WALK_ERR);
492 }
493
494 return (WALK_NEXT);
495 }
496
497
498 static int
499 nsc_val_wstep(mdb_walk_state_t *wsp)
500 {
501 uintptr_t val = wsp->walk_addr;
502 int status;
503
504 if (!val)
505 return (WALK_DONE);
506
507 status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
508 wsp->walk_cbdata);
509
510 /* move on to next val */
511
512 if (mdb_vread(&wsp->walk_addr, sizeof (wsp->walk_addr),
513 val + OFFSETOF(nsc_val_t, sv_next)) == -1) {
514 mdb_warn("failed to read nsc_val_t.sv_next");
515 return (WALK_ERR);
516 }
517
518 return (status);
519 }
520
521
522 /* ---------------------------------------------------------------------- */
523
524 /*
525 * Walker for a chain of nstset_t structures.
526 * Global walks start at _nst_sets.
527 */
528
529 static int
530 nstset_winit(mdb_walk_state_t *wsp)
531 {
532 if (wsp->walk_addr == NULL &&
533 mdb_readvar(&wsp->walk_addr, "nst_sets") == -1) {
534 mdb_warn("unable to read 'nst_sets'");
535 return (WALK_ERR);
536 }
537
538 return (WALK_NEXT);
539 }
540
541
542 static int
543 nstset_wstep(mdb_walk_state_t *wsp)
544 {
545 uintptr_t set = wsp->walk_addr;
546 int status;
547
548 if (!set)
549 return (WALK_DONE);
550
551 status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
552 wsp->walk_cbdata);
553
554 /* move on to next set */
555
556 if (mdb_vread(&wsp->walk_addr, sizeof (wsp->walk_addr),
557 set + OFFSETOF(nstset_t, set_next)) == -1) {
558 mdb_warn("failed to read nstset_t.set_next");
559 return (WALK_ERR);
560 }
561
562 return (status);
563 }
564
565
566 /* ---------------------------------------------------------------------- */
567
568 /*
569 * Walker for a chain of nsthread_t structures.
570 * No global walks.
571 */
572
573 static int
574 nsthread_winit(mdb_walk_state_t *wsp)
575 {
576 if (wsp->walk_addr == NULL) {
577 mdb_warn("nsthread does not support global walks");
578 return (WALK_ERR);
579 }
580
581 return (WALK_NEXT);
582 }
583
584
585 static int
586 nsthread_wstep(mdb_walk_state_t *wsp)
587 {
588 uintptr_t thread = wsp->walk_addr;
589 int status;
590
591 if (!thread)
592 return (WALK_DONE);
593
594 status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
595 wsp->walk_cbdata);
596
597 /* move on to next iodev */
598
599 if (mdb_vread(&wsp->walk_addr, sizeof (wsp->walk_addr),
600 thread + OFFSETOF(nsthread_t, tp_chain)) == -1) {
601 mdb_warn("failed to read nsthread_t.tp_chain");
602 return (WALK_ERR);
603 }
604
605 return (status);
606 }
607
608
609 /* ---------------------------------------------------------------------- */
610
611 /*
612 * Walker for nsthread_t free/reuse chain.
613 * No global walks.
614 */
615
616 static int
617 nst_free_winit(mdb_walk_state_t *wsp)
618 {
619 if (wsp->walk_addr == NULL) {
620 mdb_warn("nst_free does not support global walks");
621 return (WALK_ERR);
622 }
623
624 /* store starting address */
625
626 wsp->walk_data = (void *)wsp->walk_addr;
627
628 /* move on to next thread */
629
630 if (mdb_vread(&wsp->walk_addr, sizeof (wsp->walk_addr),
631 wsp->walk_addr + OFFSETOF(nsthread_t, tp_link.q_forw)) == -1) {
632 mdb_warn("failed to read nsthread_t.tp_link.q_forw");
633 return (WALK_ERR);
634 }
635
636 return (WALK_NEXT);
637 }
638
639
640 static int
641 nst_free_wstep(mdb_walk_state_t *wsp)
642 {
643 uintptr_t thread = wsp->walk_addr;
644 int status;
645
646 if (!thread)
647 return (WALK_DONE);
648
649 if (thread == (uintptr_t)wsp->walk_data)
650 return (WALK_DONE);
651
652 status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
653 wsp->walk_cbdata);
654
655 /* move on to next thread */
656
657 if (mdb_vread(&wsp->walk_addr, sizeof (wsp->walk_addr),
658 thread + OFFSETOF(nsthread_t, tp_link.q_forw)) == -1) {
659 mdb_warn("failed to read nsthread_t.tp_link.q_forw");
660 return (WALK_ERR);
661 }
662
663 return (status);
664 }
665
666
667 /* ---------------------------------------------------------------------- */
668
669 /*
670 * Walker for a chain of nsc_mem_t structures.
671 * Global walks start at _nsc_mem_top.
672 */
673
674 static int
675 nsc_mem_winit(mdb_walk_state_t *wsp)
676 {
677 if (wsp->walk_addr == NULL &&
678 mdb_readvar(&wsp->walk_addr, "_nsc_mem_top") == -1) {
679 mdb_warn("unable to read '_nsc_mem_top'");
680 return (WALK_ERR);
681 }
682
683 return (WALK_NEXT);
684 }
685
686
687 static int
688 nsc_mem_wstep(mdb_walk_state_t *wsp)
689 {
690 uintptr_t mem = wsp->walk_addr;
691 int status;
692
693 if (!mem)
694 return (WALK_DONE);
695
696 status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
697 wsp->walk_cbdata);
698
699 /* move on to next mem */
700
701 if (mdb_vread(&wsp->walk_addr, sizeof (wsp->walk_addr),
702 mem + OFFSETOF(nsc_mem_t, next)) == -1) {
703 mdb_warn("failed to read nsc_mem_t.next");
704 return (WALK_ERR);
705 }
706
707 return (status);
708 }
709
710
711 /* ---------------------------------------------------------------------- */
712
713 struct {
714 char *name;
715 int id;
716 } io_ids[] = {
717 { "NSC_RAW_ID", NSC_RAW_ID },
718 { "NSC_FILE_ID", NSC_FILE_ID },
719 { "NSC_FREEZE_ID", NSC_FREEZE_ID },
720 { "NSC_SDBC_ID", NSC_SDBC_ID },
721 { "NSC_RDCLR_ID", NSC_RDCLR_ID },
722 { "NSC_RDCL_ID", NSC_RDCL_ID },
723 { "NSC_IIR_ID", NSC_IIR_ID },
724 { "NSC_II_ID", NSC_II_ID },
725 { "NSC_RDCHR_ID", NSC_RDCHR_ID },
726 { "NSC_RDCH_ID", NSC_RDCH_ID },
727 { NULL, 0 }
728 };
729
730
731 static char *
732 nsc_io_id(const int id)
733 {
734 int i;
735
736 for (i = 0; io_ids[i].name != NULL; i++) {
737 if (io_ids[i].id == id) {
738 return (io_ids[i].name);
739 }
740 }
741
742 return ("unknown");
743 }
744
745
746 /*
747 * Display a single nsc_io_t structure.
748 * If called with no address, performs a global walk of all nsc_ios.
749 */
750 static int
751 nsc_io(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
752 {
753 char io_name[128];
754 nsc_io_t *io;
755 int v_opt;
756
757 v_opt = 0;
758
759 if (mdb_getopts(argc, argv,
760 'v', MDB_OPT_SETBITS, TRUE, &v_opt) != argc)
761 return (DCMD_USAGE);
762
763 if (!(flags & DCMD_ADDRSPEC)) {
764 if (mdb_walk_dcmd("nsctl`nsc_io",
765 "nsctl`nsc_io", argc, argv) == -1) {
766 mdb_warn("failed to walk 'nsc_io'");
767 return (DCMD_ERR);
768 }
769
770 return (DCMD_OK);
771 }
772
773 io = mdb_zalloc(sizeof (*io), UM_SLEEP | UM_GC);
774 memset(io_name, 0, sizeof (io_name));
775
776 if (mdb_vread(io, sizeof (*io), addr) != sizeof (*io)) {
777 mdb_warn("failed to read nsc_io at %p", addr);
778 return (DCMD_ERR);
779 }
780
781 if (io->name) {
782 if (mdb_readstr(io_name, sizeof (io_name),
783 (uintptr_t)io->name) == -1) {
784 mdb_warn("failed to read nsc_io_t.name");
785 return (DCMD_ERR);
786 }
787 }
788
789 if (DCMD_HDRSPEC(flags)) {
790 mdb_printf("%-?s %8Tid fl ref abuf name\n", "io");
791 }
792
793 mdb_printf("%0?p %8T%08x %2x %4d %4d %s\n",
794 addr, io->id, io->flag, io->refcnt, io->abufcnt, io_name);
795
796 if (!v_opt)
797 return (DCMD_OK);
798
799 mdb_inc_indent(4);
800
801 mdb_printf("id: %08x <%s>\n", io->id, nsc_io_id(io->id));
802
803 mdb_printf("provide: %08x <%b>\n", io->provide,
804 io->provide, nsc_type_bits);
805
806 mdb_printf("flag: %08x <%b>\n", io->flag, io->flag, nsc_ioflag_bits);
807
808 mdb_printf("pend: %d\n", io->pend);
809
810 mdb_dec_indent(4);
811
812 return (DCMD_OK);
813 }
814
815
816 /* ---------------------------------------------------------------------- */
817
818 /*
819 * Display a single nsc_dev_t structure.
820 * If called with no address, performs a global walk of all nsc_devs.
821 */
822 static int
823 nsc_dev(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
824 {
825 char path[NSC_MAXPATH+1];
826 nsc_devval_t *dv;
827 nsc_dev_t *dev;
828 uintptr_t dev_pend;
829 int a_opt, v_opt;
830
831 a_opt = v_opt = 0;
832
833 if (mdb_getopts(argc, argv,
834 'a', MDB_OPT_SETBITS, TRUE, &a_opt,
835 'v', MDB_OPT_SETBITS, TRUE, &v_opt) != argc)
836 return (DCMD_USAGE);
837
838 if (!(flags & DCMD_ADDRSPEC)) {
839 mdb_printf("Active device structures:\n");
840
841 if (mdb_walk_dcmd("nsctl`nsc_dev",
842 "nsctl`nsc_dev", argc, argv) == -1) {
843 mdb_warn("failed to walk 'nsc_dev'");
844 return (DCMD_ERR);
845 }
846
847 if (a_opt) {
848 if (mdb_readvar(&dev_pend, "_nsc_dev_pend") == -1) {
849 mdb_warn("failed to read _nsc_dev_pend");
850 return (DCMD_ERR);
851 }
852
853 mdb_printf("\nPending device structures:");
854
855 if (dev_pend) {
856 mdb_printf("\n");
857
858 if (mdb_pwalk_dcmd("nsctl`nsc_dev",
859 "nsctl`nsc_dev", argc, argv,
860 dev_pend) == -1) {
861 mdb_warn("failed to walk "
862 "pending dev structs");
863 return (DCMD_ERR);
864 }
865 } else {
866 mdb_printf(" none\n");
867 }
868 }
869
870 return (DCMD_OK);
871 }
872
873 memset(path, 0, sizeof (path));
874 dev = mdb_zalloc(sizeof (*dev), UM_SLEEP | UM_GC);
875
876 if (mdb_vread(dev, sizeof (*dev), addr) != sizeof (*dev)) {
877 mdb_warn("failed to read nsc_dev at %p", addr);
878 return (DCMD_ERR);
879 }
880
881 if (mdb_readstr(path, sizeof (path), (uintptr_t)dev->nsc_path) == -1) {
882 mdb_warn("failed to read nsc_path at %p", dev->nsc_path);
883 return (DCMD_ERR);
884 }
885
886 if (DCMD_HDRSPEC(flags)) {
887 mdb_printf("%-?s %8Tref pend rpnd wait path\n", "dev");
888 }
889
890 mdb_printf("%0?p %8T%3d %4d %4d %4d %s\n",
891 addr, dev->nsc_refcnt, dev->nsc_pend, dev->nsc_rpend,
892 dev->nsc_wait, path);
893
894 if (!v_opt)
895 return (DCMD_OK);
896
897 mdb_inc_indent(4);
898
899 mdb_printf("next: %0?p %8Tclose: %0?p\n",
900 dev->nsc_next, dev->nsc_close);
901
902 mdb_printf("list: %0?p %8Tlock: %0?p\n",
903 dev->nsc_list, addr + OFFSETOF(nsc_dev_t, nsc_lock));
904
905 mdb_printf("cv: %0?p %8Tpath: %0?p %8Tphash: %016llx\n",
906 addr + OFFSETOF(nsc_dev_t, nsc_cv),
907 dev->nsc_path, dev->nsc_phash);
908
909 mdb_printf("drop: %d %8Treopen: %d\n",
910 dev->nsc_drop, dev->nsc_reopen);
911
912 if (dev->nsc_values) {
913 dv = mdb_zalloc(sizeof (*dv), UM_SLEEP | UM_GC);
914 if (mdb_vread(dv, sizeof (*dv), (uintptr_t)dev->nsc_values) !=
915 sizeof (*dv)) {
916 mdb_warn("unable to read nsc_dev_t.nsc_values");
917 mdb_dec_indent(4);
918 return (DCMD_ERR);
919 }
920
921 if (dv->dv_values) {
922 mdb_printf("device/values: (nsc_devval: %0?p)\n",
923 dev->nsc_values);
924
925 mdb_inc_indent(4);
926
927 if (mdb_pwalk_dcmd("nsctl`nsc_val", "nsctl`nsc_val",
928 0, NULL, (uintptr_t)dv->dv_values) == -1) {
929 mdb_dec_indent(8);
930 return (DCMD_ERR);
931 }
932
933 mdb_dec_indent(4);
934 }
935 }
936
937 mdb_dec_indent(4);
938
939 return (DCMD_OK);
940 }
941
942
943 /* ---------------------------------------------------------------------- */
944
945 /*
946 * Display a single nsc_devval_t structure.
947 * If called with no address, performs a global walk of all nsc_devs.
948 */
949 static int
950 nsc_devval(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
951 {
952 nsc_devval_t *dv;
953 int a_opt;
954
955 a_opt = 0;
956
957 if (mdb_getopts(argc, argv,
958 'a', MDB_OPT_SETBITS, TRUE, &a_opt) != argc)
959 return (DCMD_USAGE);
960
961 if (!(flags & DCMD_ADDRSPEC)) {
962 if (mdb_walk_dcmd("nsctl`nsc_devval",
963 "nsctl`nsc_devval", argc, argv) == -1) {
964 mdb_warn("failed to walk 'nsc_devval'");
965 return (DCMD_ERR);
966 }
967
968 return (DCMD_OK);
969 }
970
971 dv = mdb_zalloc(sizeof (*dv), UM_SLEEP | UM_GC);
972
973 if (mdb_vread(dv, sizeof (*dv), addr) != sizeof (*dv)) {
974 mdb_warn("failed to read nsc_devval at %p", addr);
975 return (DCMD_ERR);
976 }
977
978 if (!a_opt && !dv->dv_values) {
979 return (DCMD_OK);
980 }
981
982 if (DCMD_HDRSPEC(flags)) {
983 mdb_printf("%-?s %8T%?-s %8Tpath\n", "devval", "phash");
984 }
985
986 mdb_printf("%0?p %8T%016llx %8T%s\n", addr,
987 dv->dv_phash, dv->dv_path);
988
989 mdb_inc_indent(4);
990
991 if (dv->dv_values) {
992 if (mdb_pwalk_dcmd("nsctl`nsc_val", "nsctl`nsc_val",
993 0, NULL, (uintptr_t)dv->dv_values) == -1) {
994 return (DCMD_ERR);
995 }
996 } else {
997 mdb_printf("No values\n");
998 }
999
1000 mdb_dec_indent(4);
1001
1002 return (DCMD_OK);
1003 }
1004
1005
1006 /* ---------------------------------------------------------------------- */
1007
1008 /*
1009 * Part 2 callback for the all devices and fds walk. Called per iodev.
1010 */
1011 /* ARGSUSED */
1012 static int
1013 nsc_fd_iodev(uintptr_t addr, const void *data, void *cbdata)
1014 {
1015 struct complex_args *fdall = cbdata;
1016 struct nsc_fd_t *fd;
1017
1018 if (mdb_vread(&fd, sizeof (fd),
1019 addr + OFFSETOF(nsc_iodev_t, si_open)) == -1) {
1020 mdb_warn("unable to read nsc_iodev_t.si_open");
1021 return (WALK_ERR);
1022 }
1023
1024 if (fd != NULL) {
1025 if (mdb_pwalk_dcmd("nsctl`nsc_fd", "nsctl`nsc_fd",
1026 fdall->argc, fdall->argv, (uintptr_t)fd) == -1)
1027 return (WALK_ERR);
1028 }
1029
1030 return (WALK_NEXT);
1031 }
1032
1033
1034 /*
1035 * Part 1 callback for the all devices and fds walk. Called per device.
1036 */
1037 /* ARGSUSED */
1038 static int
1039 nsc_fd_dev(uintptr_t addr, const void *data, void *cbdata)
1040 {
1041 struct complex_args *fdall = cbdata;
1042 nsc_iodev_t *iodev;
1043 nsc_fd_t *fd;
1044
1045 if (mdb_vread(&iodev, sizeof (iodev),
1046 addr + OFFSETOF(nsc_dev_t, nsc_list)) == -1) {
1047 mdb_warn("unable to read nsc_dev_t.nsc_list at %p", addr);
1048 return (WALK_ERR);
1049 }
1050
1051 /* walk iodev chains */
1052
1053 if (iodev != NULL) {
1054 if (mdb_pwalk("nsctl`nsc_iodev",
1055 nsc_fd_iodev, fdall, (uintptr_t)iodev) == -1)
1056 return (WALK_ERR);
1057 }
1058
1059 /* walk nsc_close (closing fds) chains */
1060
1061 if (mdb_vread(&fd, sizeof (fd),
1062 addr + OFFSETOF(nsc_dev_t, nsc_close)) == -1) {
1063 mdb_warn("unable to read nsc_dev_t.nsc_close at %p", addr);
1064 return (WALK_ERR);
1065 }
1066
1067 if (fd != NULL) {
1068 if (mdb_pwalk_dcmd("nsctl`nsc_fd", "nsctl`nsc_fd",
1069 fdall->argc, fdall->argv, (uintptr_t)fd) == -1)
1070 return (WALK_ERR);
1071 }
1072
1073 return (WALK_NEXT);
1074 }
1075
1076
1077 /*
1078 * Walk all devices and fds in the system.
1079 */
1080 static int
1081 nsc_fd_all(int argc, const mdb_arg_t *argv)
1082 {
1083 struct complex_args fdall;
1084
1085 fdall.argc = argc;
1086 fdall.argv = (mdb_arg_t *)argv;
1087
1088 complex_walk = 1;
1089 complex_hdr = 0;
1090
1091 if (mdb_walk("nsctl`nsc_dev", nsc_fd_dev, &fdall) == -1) {
1092 return (DCMD_ERR);
1093 }
1094
1095 return (DCMD_OK);
1096 }
1097
1098
1099
1100 /*
1101 * Display an nsd_fd_t structure, or walk all devices and fds in the system.
1102 */
1103 static int
1104 nsc_fd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1105 {
1106 char io_name[128], *io_namep;
1107 char path[NSC_MAXPATH+1];
1108 uintptr_t pathp;
1109 nsc_fd_t *fd;
1110 nsc_io_t *io;
1111 int v_opt;
1112 int hdr;
1113
1114 v_opt = 0;
1115
1116 if (mdb_getopts(argc, argv,
1117 'v', MDB_OPT_SETBITS, TRUE, &v_opt) != argc)
1118 return (DCMD_USAGE);
1119
1120 if (!(flags & DCMD_ADDRSPEC)) {
1121 return (nsc_fd_all(argc, argv));
1122 }
1123
1124 memset(path, 0, sizeof (path));
1125 fd = mdb_zalloc(sizeof (*fd), UM_SLEEP | UM_GC);
1126 memset(io_name, 0, sizeof (io_name));
1127
1128 if (mdb_vread(fd, sizeof (*fd), addr) != sizeof (*fd)) {
1129 mdb_warn("failed to read nsc_fd at %p", addr);
1130 return (DCMD_ERR);
1131 }
1132
1133 if (mdb_vread(&pathp, sizeof (pathp),
1134 (uintptr_t)fd->sf_dev + OFFSETOF(nsc_dev_t, nsc_path)) !=
1135 sizeof (pathp)) {
1136 mdb_warn("failed to read nsc_dev.nsc_path");
1137 return (DCMD_ERR);
1138 }
1139
1140 if (mdb_readstr(path, sizeof (path), pathp) == -1) {
1141 mdb_warn("failed to read nsc_path");
1142 return (DCMD_ERR);
1143 }
1144
1145 if (fd->sf_iodev) {
1146 if (mdb_vread(&io, sizeof (io),
1147 (uintptr_t)fd->sf_iodev + OFFSETOF(nsc_iodev_t, si_io)) !=
1148 sizeof (io)) {
1149 mdb_warn("failed to read nsc_iodev.si_io");
1150 return (DCMD_ERR);
1151 }
1152
1153 if (mdb_vread(&io_namep, sizeof (io_namep),
1154 (uintptr_t)io + OFFSETOF(nsc_io_t, name)) !=
1155 sizeof (io_namep)) {
1156 mdb_warn("failed to read nsc_io_t.name");
1157 return (DCMD_ERR);
1158 }
1159
1160 if (mdb_readstr(io_name, sizeof (io_name),
1161 (uintptr_t)io_namep) == -1) {
1162 mdb_warn("failed to read nsc_io_t.name string");
1163 return (DCMD_ERR);
1164 }
1165 }
1166
1167 hdr = 0;
1168 if (complex_walk) {
1169 if (!complex_hdr) {
1170 complex_hdr = 1;
1171 hdr = 1;
1172 }
1173 } else if (DCMD_HDRSPEC(flags)) {
1174 hdr = 1;
1175 }
1176
1177 if (hdr) {
1178 mdb_printf("%-?s %8T%-?s %8T%-8s %-?s\n",
1179 "fd", "dev", "io", "cd");
1180 mdb_printf(" %-?s %8Trv pend av path\n", "arg");
1181 }
1182
1183 mdb_printf("%0?p %8T%0?p %8T%-8s %p\n",
1184 addr, fd->sf_dev, io_name, fd->sf_cd);
1185 mdb_printf(" %0?p %8T%2d %4x %2x %s\n",
1186 fd->sf_arg, fd->sf_reserve, fd->sf_pend,
1187 fd->sf_avail, path);
1188
1189 if (!v_opt)
1190 return (DCMD_OK);
1191
1192 mdb_inc_indent(4);
1193
1194 mdb_printf("open type: %08x <%b>\n", fd->sf_type,
1195 fd->sf_type, nsc_type_bits);
1196
1197 mdb_printf("avail: %08x <%b>\n", fd->sf_avail,
1198 fd->sf_avail, nsc_availpend_bits);
1199
1200 mdb_printf("flag: %08x <%b>\n", fd->sf_flag,
1201 fd->sf_flag, nsc_fdflag_bits);
1202
1203 mdb_printf("rsrv mode: %08x <%b>\n", fd->sf_mode,
1204 fd->sf_mode, nsc_fdmode_bits);
1205
1206 mdb_printf("open lbolt: %?x %8Treopen: %d\n", fd->sf_lbolt,
1207 fd->sf_reopen);
1208
1209 mdb_dec_indent(4);
1210
1211 return (DCMD_OK);
1212 }
1213
1214
1215 /* ---------------------------------------------------------------------- */
1216
1217 /*
1218 * Callback for the all devices and iodevs walk. Called per device.
1219 */
1220 /* ARGSUSED */
1221 static int
1222 nsc_iodev_dev(uintptr_t addr, const void *data, void *cbdata)
1223 {
1224 struct complex_args *iodevall = cbdata;
1225 uintptr_t iodev;
1226
1227 if (mdb_vread(&iodev, sizeof (iodev),
1228 addr + OFFSETOF(nsc_dev_t, nsc_list)) == -1) {
1229 mdb_warn("unable to read nsc_dev_t.nsc_list at %p", addr);
1230 return (WALK_ERR);
1231 }
1232
1233 /* walk iodev chains */
1234
1235 if (iodev != NULL) {
1236 if (mdb_pwalk_dcmd("nsctl`nsc_iodev", "nsctl`nsc_iodev",
1237 iodevall->argc, iodevall->argv, iodev) == -1)
1238 return (WALK_ERR);
1239 }
1240
1241 return (WALK_NEXT);
1242 }
1243
1244
1245 /*
1246 * Walk all devices and iodevs in the system.
1247 */
1248 static int
1249 nsc_iodev_all(int argc, const mdb_arg_t *argv)
1250 {
1251 struct complex_args iodevall;
1252
1253 iodevall.argc = argc;
1254 iodevall.argv = (mdb_arg_t *)argv;
1255
1256 complex_walk = 1;
1257 complex_hdr = 0;
1258
1259 if (mdb_walk("nsctl`nsc_dev", nsc_iodev_dev, &iodevall) == -1) {
1260 return (DCMD_ERR);
1261 }
1262
1263 return (DCMD_OK);
1264 }
1265
1266
1267 /*
1268 * Display an nsc_iodev_t structure, or walk all devices and
1269 * iodevs in the system.
1270 */
1271 static int
1272 nsc_iodev(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1273 {
1274 char io_name[128], *io_namep;
1275 char path[NSC_MAXPATH+1];
1276 nsc_iodev_t *iodev;
1277 uintptr_t pathp;
1278 int v_opt;
1279 int hdr;
1280
1281 v_opt = 0;
1282
1283 if (mdb_getopts(argc, argv,
1284 'v', MDB_OPT_SETBITS, TRUE, &v_opt) != argc)
1285 return (DCMD_USAGE);
1286
1287 if (!(flags & DCMD_ADDRSPEC)) {
1288 return (nsc_iodev_all(argc, argv));
1289 }
1290
1291 memset(path, 0, sizeof (path));
1292 iodev = mdb_zalloc(sizeof (*iodev), UM_SLEEP | UM_GC);
1293 memset(io_name, 0, sizeof (io_name));
1294
1295 if (mdb_vread(iodev, sizeof (*iodev), addr) != sizeof (*iodev)) {
1296 mdb_warn("failed to read nsc_iodev at %p", addr);
1297 return (DCMD_ERR);
1298 }
1299
1300 if (mdb_vread(&pathp, sizeof (pathp),
1301 (uintptr_t)iodev->si_dev + OFFSETOF(nsc_dev_t, nsc_path)) !=
1302 sizeof (pathp)) {
1303 mdb_warn("failed to read nsc_dev.nsc_path");
1304 return (DCMD_ERR);
1305 }
1306
1307 if (mdb_readstr(path, sizeof (path), pathp) == -1) {
1308 mdb_warn("failed to read nsc_path");
1309 return (DCMD_ERR);
1310 }
1311
1312 if (mdb_vread(&io_namep, sizeof (io_namep),
1313 (uintptr_t)iodev->si_io + OFFSETOF(nsc_io_t, name)) !=
1314 sizeof (io_namep)) {
1315 mdb_warn("failed to read nsc_io_t.name");
1316 return (DCMD_ERR);
1317 }
1318
1319 if (mdb_readstr(io_name, sizeof (io_name),
1320 (uintptr_t)io_namep) == -1) {
1321 mdb_warn("failed to read nsc_io_t.name string");
1322 return (DCMD_ERR);
1323 }
1324
1325 hdr = 0;
1326 if (complex_walk) {
1327 if (!complex_hdr) {
1328 complex_hdr = 1;
1329 hdr = 1;
1330 }
1331 } else if (DCMD_HDRSPEC(flags)) {
1332 hdr = 1;
1333 }
1334
1335 if (hdr) {
1336 mdb_printf("%-?s %8T%-?s ref %-8s path\n",
1337 "iodev", "dev", "io");
1338 }
1339
1340 mdb_printf("%0?p %8T%0?p %3d %-8s %s\n",
1341 addr, iodev->si_dev, iodev->si_refcnt, io_name, path);
1342
1343 if (!v_opt)
1344 return (DCMD_OK);
1345
1346 mdb_inc_indent(4);
1347
1348 mdb_printf("open fds: %?p %8Tactive ios: %?p\n",
1349 iodev->si_open, iodev->si_active);
1350
1351 mdb_printf("busy: %d %8Trsrv pend: %d\n",
1352 iodev->si_busy, iodev->si_rpend);
1353
1354 mdb_printf("pend: %08x <%b>\n", iodev->si_pend,
1355 iodev->si_pend, nsc_availpend_bits);
1356
1357 mdb_printf("avail: %08x <%b>\n", iodev->si_avail,
1358 iodev->si_avail, nsc_availpend_bits);
1359
1360 mdb_dec_indent(4);
1361
1362 return (DCMD_OK);
1363 }
1364
1365
1366 /* ---------------------------------------------------------------------- */
1367
1368 /*
1369 * Display an nsc_service_t structure, or walk all services.
1370 */
1371 static int
1372 nsc_service(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1373 {
1374 nsc_service_t *service;
1375 char s_name[32];
1376 int v_opt;
1377
1378 v_opt = 0;
1379
1380 if (mdb_getopts(argc, argv,
1381 'v', MDB_OPT_SETBITS, TRUE, &v_opt) != argc)
1382 return (DCMD_USAGE);
1383
1384 if (!(flags & DCMD_ADDRSPEC)) {
1385 if (mdb_walk_dcmd("nsctl`nsc_service",
1386 "nsctl`nsc_service", argc, argv) == -1) {
1387 mdb_warn("failed to walk 'nsc_service'");
1388 return (DCMD_ERR);
1389 }
1390
1391 return (DCMD_OK);
1392 }
1393
1394 service = mdb_zalloc(sizeof (*service), UM_SLEEP | UM_GC);
1395
1396 if (mdb_vread(service, sizeof (*service), addr) != sizeof (*service)) {
1397 mdb_warn("failed to read nsc_service at %p", addr);
1398 return (DCMD_ERR);
1399 }
1400
1401 if (DCMD_HDRSPEC(flags)) {
1402 mdb_printf("%-?s %8Tname\n", "service");
1403 }
1404
1405 memset(s_name, 0, sizeof (s_name));
1406 if (service->s_name) {
1407 if (mdb_readstr(s_name, sizeof (s_name),
1408 (uintptr_t)service->s_name) == -1) {
1409 mdb_warn("failed to read nsc_io_t.name");
1410 return (DCMD_ERR);
1411 }
1412 }
1413
1414 mdb_printf("%0?p %8T%s\n", addr, s_name);
1415
1416 if (!v_opt)
1417 return (DCMD_OK);
1418
1419 mdb_inc_indent(4);
1420
1421 mdb_printf("servers:\n");
1422 if (service->s_servers == NULL) {
1423 mdb_printf("<none>\n");
1424 } else {
1425 mdb_inc_indent(4);
1426 if (mdb_pwalk_dcmd("nsctl`nsc_svc", "nsctl`nsc_svc",
1427 argc, argv, (uintptr_t)service->s_servers) == -1) {
1428 mdb_dec_indent(8);
1429 return (DCMD_ERR);
1430 }
1431 mdb_dec_indent(4);
1432 }
1433
1434 mdb_printf("clients:\n");
1435 if (service->s_clients == NULL) {
1436 mdb_printf("<none>\n");
1437 } else {
1438 mdb_inc_indent(4);
1439 if (mdb_pwalk_dcmd("nsctl`nsc_svc", "nsctl`nsc_svc",
1440 argc, argv, (uintptr_t)service->s_clients) == -1) {
1441 mdb_dec_indent(8);
1442 return (DCMD_ERR);
1443 }
1444 mdb_dec_indent(4);
1445 }
1446
1447 mdb_dec_indent(4);
1448
1449 return (DCMD_OK);
1450 }
1451
1452
1453 /* ---------------------------------------------------------------------- */
1454
1455 /*
1456 * Display an nsc_svc_t structure.
1457 */
1458 /*ARGSUSED*/
1459 static int
1460 nsc_svc(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1461 {
1462 nsc_svc_t *svc;
1463
1464 if (!(flags & DCMD_ADDRSPEC))
1465 return (DCMD_USAGE);
1466
1467 svc = mdb_zalloc(sizeof (*svc), UM_SLEEP | UM_GC);
1468
1469 if (mdb_vread(svc, sizeof (*svc), addr) != sizeof (*svc)) {
1470 mdb_warn("failed to read nsc_svc at %p", addr);
1471 return (DCMD_ERR);
1472 }
1473
1474 if (DCMD_HDRSPEC(flags)) {
1475 mdb_printf("%-?s %8T%-?s %8Tfunc\n", "svc", "service");
1476 }
1477
1478 mdb_printf("%0?p %8T%0?p %8T%a\n", addr, svc->svc_svc, svc->svc_fn);
1479 return (DCMD_OK);
1480 }
1481
1482
1483 /* ---------------------------------------------------------------------- */
1484
1485 /*
1486 * Display a single nsc_val_t structure.
1487 * If called with no address, performs a global walk of all nsc_devs.
1488 */
1489 /* ARGSUSED3 */
1490 static int
1491 nsc_val(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1492 {
1493 nsc_val_t *vp;
1494
1495 if (argc != 0)
1496 return (DCMD_USAGE);
1497
1498 if (!(flags & DCMD_ADDRSPEC)) {
1499 mdb_warn("nsc_val requires an address");
1500 return (DCMD_ERR);
1501 }
1502
1503 vp = mdb_zalloc(sizeof (*vp), UM_SLEEP | UM_GC);
1504
1505 if (mdb_vread(vp, sizeof (*vp), addr) != sizeof (*vp)) {
1506 mdb_warn("failed to read nsc_val at %p", addr);
1507 return (DCMD_ERR);
1508 }
1509
1510 if (DCMD_HDRSPEC(flags)) {
1511 mdb_printf("%-?s %8T%8-s %8Tname\n", "val", "value");
1512 }
1513
1514 mdb_printf("%0?p %8T%08x %8T%s\n", addr, vp->sv_value, vp->sv_name);
1515
1516 return (DCMD_OK);
1517 }
1518
1519
1520 /* ---------------------------------------------------------------------- */
1521
1522 /*
1523 * Display an nstset_t structure, or walk all sets.
1524 */
1525
1526 static int
1527 nstset(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1528 {
1529 nstset_t *set;
1530 int f_opt, r_opt, t_opt, v_opt;
1531
1532 f_opt = r_opt = t_opt = v_opt = 0;
1533
1534 if (mdb_getopts(argc, argv,
1535 'f', MDB_OPT_SETBITS, TRUE, &f_opt, /* free list */
1536 'r', MDB_OPT_SETBITS, TRUE, &r_opt, /* reuse list */
1537 't', MDB_OPT_SETBITS, TRUE, &t_opt, /* all threads */
1538 'v', MDB_OPT_SETBITS, TRUE, &v_opt) != argc)
1539 return (DCMD_USAGE);
1540
1541 /* displaying threads implies verbose */
1542 if (f_opt || r_opt || t_opt)
1543 v_opt = 1;
1544
1545 if (!(flags & DCMD_ADDRSPEC)) {
1546 if (mdb_walk_dcmd("nsctl`nstset",
1547 "nsctl`nstset", argc, argv) == -1) {
1548 mdb_warn("failed to walk 'nstset'");
1549 return (DCMD_ERR);
1550 }
1551
1552 return (DCMD_OK);
1553 }
1554
1555 set = mdb_zalloc(sizeof (*set), UM_SLEEP | UM_GC);
1556
1557 if (mdb_vread(set, sizeof (*set), addr) != sizeof (*set)) {
1558 mdb_warn("failed to read nstset at %p", addr);
1559 return (DCMD_ERR);
1560 }
1561
1562 if (DCMD_HDRSPEC(flags)) {
1563 mdb_printf("%-?s %8T live nthr flag name\n", "set");
1564 }
1565
1566 mdb_printf("%0?p %8T%6d %6d %4x %s\n", addr,
1567 set->set_nlive, set->set_nthread, set->set_flag, set->set_name);
1568
1569 if (!v_opt)
1570 return (DCMD_OK);
1571
1572 mdb_inc_indent(4);
1573
1574 mdb_printf("chain: %0?p %8Tpending: %4d res_cnt: %4d\n",
1575 set->set_chain, set->set_pending, set->set_res_cnt);
1576
1577 if (set->set_reuse.q_forw == set->set_reuse.q_back &&
1578 (uintptr_t)set->set_reuse.q_forw ==
1579 (addr + OFFSETOF(nstset_t, set_reuse))) {
1580 mdb_printf("reuse.forw: %-?s %8Treuse.back: %s\n",
1581 "empty", "empty");
1582 } else {
1583 mdb_printf("reuse.forw: %0?p %8Treuse.back: %0?p\n",
1584 set->set_reuse.q_forw, set->set_reuse.q_back);
1585
1586 /* display all threads in reuse list */
1587 if (r_opt &&
1588 mdb_pwalk_dcmd("nsctl`nst_free", "nsctl`nsthread",
1589 0, (const mdb_arg_t *)NULL,
1590 (addr + OFFSETOF(nstset_t, set_reuse))) == -1) {
1591 mdb_dec_indent(4);
1592 return (DCMD_ERR);
1593 }
1594 }
1595
1596 if (set->set_free.q_forw == set->set_free.q_back &&
1597 (uintptr_t)set->set_free.q_forw ==
1598 (addr + OFFSETOF(nstset_t, set_free))) {
1599 mdb_printf("free.forw: %-?s %8Tfree.back: %s\n",
1600 "empty", "empty");
1601 } else {
1602 mdb_printf("free.forw: %0?p %8Tfree.back: %0?p\n",
1603 set->set_free.q_forw, set->set_free.q_back);
1604
1605 /* display all threads in free list */
1606 if (f_opt &&
1607 mdb_pwalk_dcmd("nsctl`nst_free", "nsctl`nsthread",
1608 0, (const mdb_arg_t *)NULL,
1609 (addr + OFFSETOF(nstset_t, set_free))) == -1) {
1610 mdb_dec_indent(4);
1611 return (DCMD_ERR);
1612 }
1613 }
1614
1615 mdb_printf("flag: %08x <%b>\n",
1616 set->set_flag, set->set_flag, nstset_flag_bits);
1617
1618 /* display all threads in set */
1619 if (t_opt) {
1620 mdb_printf("all threads in set:\n");
1621 if (mdb_pwalk_dcmd("nsctl`nsthread", "nsctl`nsthread",
1622 0, (const mdb_arg_t *)NULL,
1623 (uintptr_t)set->set_chain) == -1) {
1624 mdb_dec_indent(4);
1625 return (DCMD_ERR);
1626 }
1627 }
1628
1629 mdb_dec_indent(4);
1630
1631 return (DCMD_OK);
1632 }
1633
1634
1635 /* ---------------------------------------------------------------------- */
1636
1637 /*
1638 * Callback for the all nstsets and threads walk. Called per set.
1639 */
1640 /* ARGSUSED */
1641 static int
1642 nst_thr_set(uintptr_t addr, const void *data, void *cbdata)
1643 {
1644 struct complex_args *thrall = cbdata;
1645 char set_name[48];
1646 uintptr_t tp;
1647
1648 if (mdb_vread(&tp, sizeof (tp),
1649 addr + OFFSETOF(nstset_t, set_chain)) == -1) {
1650 mdb_warn("unable to read nstset_t.set_chain at %p", addr);
1651 return (WALK_ERR);
1652 }
1653
1654 memset(set_name, 0, sizeof (set_name));
1655
1656 if (mdb_readstr(set_name, sizeof (set_name),
1657 addr + OFFSETOF(nstset_t, set_name)) == -1) {
1658 mdb_warn("unable to read nstset_t.set_name at %p", addr);
1659 }
1660
1661 mdb_printf("nstset: %0?p (%s)\n", addr, set_name);
1662
1663 /* walk thread chains */
1664
1665 if (tp != NULL) {
1666 if (mdb_pwalk_dcmd("nsctl`nsthread", "nsctl`nsthread",
1667 thrall->argc, thrall->argv, tp) == -1)
1668 return (WALK_ERR);
1669 } else
1670 mdb_printf(" no threads\n");
1671
1672 mdb_printf("\n");
1673
1674 return (WALK_NEXT);
1675 }
1676
1677
1678 /*
1679 * Walk all nstsets and threads in the system.
1680 */
1681 static int
1682 nst_thr_all(int argc, const mdb_arg_t *argv)
1683 {
1684 struct complex_args thrall;
1685
1686 thrall.argc = argc;
1687 thrall.argv = (mdb_arg_t *)argv;
1688
1689 if (mdb_walk("nsctl`nstset", nst_thr_set, &thrall) == -1)
1690 return (DCMD_ERR);
1691
1692 return (DCMD_OK);
1693 }
1694
1695
1696 /*
1697 * Display an nsthread_t structure, or walk all threads.
1698 */
1699
1700 static int
1701 nsthread(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1702 {
1703 uintptr_t thrpend;
1704 nsthread_t *tp;
1705 int a_opt, v_opt;
1706 int rc;
1707
1708 a_opt = v_opt = 0;
1709
1710 if (mdb_getopts(argc, argv,
1711 'a', MDB_OPT_SETBITS, TRUE, &a_opt,
1712 'v', MDB_OPT_SETBITS, TRUE, &v_opt) != argc)
1713 return (DCMD_USAGE);
1714
1715 if (!(flags & DCMD_ADDRSPEC)) {
1716 if ((rc = nst_thr_all(argc, argv)) != DCMD_OK)
1717 return (rc);
1718
1719 if (a_opt) {
1720 if (mdb_readvar(&thrpend, "nst_pending") == -1) {
1721 mdb_warn("unable to read 'nst_pending'");
1722 return (DCMD_ERR);
1723 }
1724
1725 if (thrpend) {
1726 mdb_printf("\nPending threads:\n");
1727
1728 if (mdb_pwalk_dcmd("nsctl`nsthread",
1729 "nsctl`nsthread", argc, argv,
1730 thrpend) == -1) {
1731 mdb_warn("failed to walk 'nsthread'");
1732 return (DCMD_ERR);
1733 }
1734 }
1735 }
1736
1737 return (DCMD_OK);
1738 }
1739
1740 tp = mdb_zalloc(sizeof (*tp), UM_SLEEP | UM_GC);
1741
1742 if (mdb_vread(tp, sizeof (*tp), addr) != sizeof (*tp)) {
1743 mdb_warn("failed to read nsthread at %p", addr);
1744 return (DCMD_ERR);
1745 }
1746
1747 if (DCMD_HDRSPEC(flags)) {
1748 mdb_printf("%-?s %8Tflag %-?s %8Tfunc\n", "thread", "arg");
1749 }
1750
1751 mdb_printf("%0?p %8T%4x %0?p %8T%a\n",
1752 addr, tp->tp_flag, tp->tp_arg, tp->tp_func);
1753
1754 if (!v_opt)
1755 return (DCMD_OK);
1756
1757 mdb_inc_indent(4);
1758
1759 mdb_printf("set: %0?p %8Tchain: %0?p\n",
1760 tp->tp_set, tp->tp_chain);
1761
1762 mdb_printf("link.forw: %0?p %8Tlink.back: %0?p\n",
1763 tp->tp_link.q_forw, tp->tp_link.q_back);
1764
1765 mdb_printf("flag: %08x <%b>\n",
1766 tp->tp_flag, tp->tp_flag, nst_flag_bits);
1767
1768 mdb_dec_indent(4);
1769
1770 return (DCMD_OK);
1771 }
1772
1773
1774 /* ---------------------------------------------------------------------- */
1775
1776 static void
1777 nsc_rmap(char *name)
1778 {
1779 nsc_rmmap_t slot;
1780 uintptr_t addr;
1781 int nslot;
1782 char *cp;
1783
1784 if (mdb_readvar(&addr, name) == -1) {
1785 mdb_warn("unable to read rmap '%s'", name);
1786 return;
1787 }
1788
1789 if (mdb_vread(&slot, sizeof (slot), addr) != sizeof (slot)) {
1790 mdb_warn("unable to read rmap '%s' slot 0", name);
1791 return;
1792 }
1793
1794 mdb_printf("\nmap name offset size nslot\n");
1795 mdb_printf("%16s %9d %9d %5d\n",
1796 slot.name, slot.offset, slot.size, slot.inuse);
1797
1798 nslot = slot.inuse;
1799 mdb_printf("\nslot name offset size inuse\n");
1800
1801 while (--nslot) {
1802 addr += sizeof (slot);
1803
1804 if (mdb_vread(&slot, sizeof (slot), addr) != sizeof (slot)) {
1805 mdb_warn("unable to read rmap '%s' slot @ %p",
1806 name, addr);
1807 return;
1808 }
1809
1810 if (!slot.inuse || !slot.size)
1811 continue;
1812
1813 for (cp = slot.name; *cp; cp++)
1814 if (*cp == ':')
1815 *cp = ' ';
1816
1817 mdb_printf("%16s %9d %9d %08x\n",
1818 slot.name, slot.offset, slot.size, slot.inuse);
1819 }
1820 }
1821
1822
1823 static void
1824 nsc_rmhdr(void)
1825 {
1826 nsc_rmhdr_t *rmhdr = mdb_zalloc(sizeof (*rmhdr), UM_SLEEP | UM_GC);
1827 uintptr_t addr;
1828
1829 if (mdb_readvar(&addr, "_nsc_rmhdr_ptr") == -1) {
1830 mdb_warn("unable to read _nsc_rmhdr_ptr");
1831 return;
1832 }
1833
1834 if (!addr) {
1835 mdb_printf("\n\nGlobal header not initialised\n");
1836 return;
1837 }
1838
1839 if (mdb_vread(rmhdr, sizeof (*rmhdr), addr) != sizeof (*rmhdr)) {
1840 mdb_warn("unable to read global header at %p", addr);
1841 return;
1842 }
1843
1844 mdb_printf("\n\nglobal header (magic %08x, version %d, size %d)\n",
1845 rmhdr->magic, rmhdr->ver, rmhdr->size);
1846
1847 nsc_rmap("_nsc_global_map");
1848 }
1849
1850
1851 static nsc_mem_t *
1852 memptr(int type, int flag)
1853 {
1854 int i;
1855
1856 type &= NSC_MEM_GLOBAL;
1857
1858 if (type)
1859 flag = 0;
1860
1861 if (!type && !flag)
1862 return (&type_mem[0]);
1863
1864 for (i = 1; i < (sizeof (type_mem) / sizeof (nsc_mem_t)); i++) {
1865 if (!type_mem[i].flag && !type_mem[i].type) {
1866 type_mem[i].flag = flag;
1867 type_mem[i].type = type;
1868 return (&type_mem[i]);
1869 }
1870
1871 if (type_mem[i].flag == flag && type_mem[i].type == type)
1872 return (&type_mem[i]);
1873 }
1874
1875 return (&type_mem[i]);
1876 }
1877
1878
1879 #define typename(t) \
1880 (((t) & NSC_MEM_GLOBAL) ? "gbl" : " - ")
1881
1882 #define memname(t) \
1883 (((t) & NSC_MEM_GLOBAL) ? "nsc_global" : "system kmem")
1884
1885 static void
1886 nsc_mem_type(const int first, nsc_mem_t *mp)
1887 {
1888 char *type, *name;
1889
1890 if (first) {
1891 mdb_printf("\nregion typ f ");
1892 mdb_printf("used hwm pgs alloc free\n");
1893 }
1894
1895 type = typename(mp->type);
1896 name = memname(mp->type);
1897
1898 mdb_printf("%16s %s %2x %9d %9d %6d %5d %5d\n",
1899 name, type, mp->flag, mp->used, mp->hwm, mp->pagehwm,
1900 mp->nalloc, mp->nfree);
1901 }
1902
1903
1904 static int
1905 nsc_mem_all(int argc, const mdb_arg_t *argv, int v_opt)
1906 {
1907 int first;
1908 int i;
1909
1910 memset(type_mem, 0, sizeof (type_mem));
1911
1912 if (mdb_walk_dcmd("nsctl`nsc_mem",
1913 "nsctl`nsc_mem", argc, argv) == -1) {
1914 mdb_warn("unable to walk 'nsc_mem'");
1915 return (DCMD_ERR);
1916 }
1917
1918 for (first = 1, i = 0;
1919 i < (sizeof (type_mem) / sizeof (nsc_mem_t)); first = 0, i++) {
1920 if (type_mem[i].nalloc || type_mem[i].hwm) {
1921 nsc_mem_type(first, &type_mem[i]);
1922 }
1923 }
1924
1925 if (v_opt)
1926 nsc_rmhdr();
1927
1928 return (DCMD_OK);
1929 }
1930
1931
1932 static int
1933 nsc_mem(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1934 {
1935 char name[16], *type, *cp;
1936 nsc_mem_t mem, *mp;
1937 int v_opt;
1938
1939 v_opt = 0;
1940
1941 if (mdb_getopts(argc, argv,
1942 'v', MDB_OPT_SETBITS, TRUE, &v_opt) != argc)
1943 return (DCMD_USAGE);
1944
1945 if (!(flags & DCMD_ADDRSPEC)) {
1946 return (nsc_mem_all(argc, argv, v_opt));
1947 }
1948
1949 if (mdb_vread(&mem, sizeof (mem), addr) != sizeof (mem)) {
1950 mdb_warn("failed to read nsc_mem_t at %p", addr);
1951 return (DCMD_ERR);
1952 }
1953
1954 if (mdb_readstr(name, sizeof (name), (uintptr_t)mem.name) == -1) {
1955 mdb_warn("failed to read nsc_mem_t.name at %p", addr);
1956 return (DCMD_ERR);
1957 }
1958
1959 if (!mem.nalloc && !mem.hwm && !v_opt)
1960 return (DCMD_OK);
1961
1962 if (DCMD_HDRSPEC(flags)) {
1963 mdb_printf("name typ f ");
1964 mdb_printf("used hwm pgs alloc free base\n");
1965 }
1966
1967 type = typename(mem.type);
1968 mp = memptr(mem.type, mem.flag);
1969
1970 for (cp = name; *cp; cp++)
1971 if (*cp == ':')
1972 *cp = ' ';
1973
1974 mdb_printf("%-16s %s %2x %9d %9d %5d %5d %5d %0?p\n",
1975 name, type, mem.flag, mem.used, mem.hwm, mem.pagehwm,
1976 mem.nalloc, mem.nfree, mem.base);
1977
1978 mp->used += mem.used;
1979 mp->hwm += mem.hwm;
1980 mp->pagehwm += mem.pagehwm;
1981 mp->nalloc += mem.nalloc;
1982 mp->nfree += mem.nfree;
1983
1984 return (DCMD_OK);
1985 }
1986
1987 /*ARGSUSED*/
1988 static int
1989 nsc_vec(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1990 {
1991 nsc_vec_t *vec;
1992
1993 vec = mdb_zalloc(sizeof (*vec), UM_SLEEP | UM_GC);
1994 if (mdb_vread(vec, sizeof (*vec), addr) != sizeof (*vec)) {
1995 mdb_warn("failed to read nsc_vec at %p", addr);
1996 return (DCMD_ERR);
1997 }
1998 mdb_printf("nsc_vec_t @ 0x%p = {\n", addr);
1999 mdb_inc_indent(4);
2000 mdb_printf("sv_addr: %p\n", vec->sv_addr);
2001 mdb_printf("sv_vme: %lu\n", vec->sv_vme);
2002 mdb_printf("sv_len: %d\n", vec->sv_len);
2003 mdb_dec_indent(4);
2004 mdb_printf("};\n");
2005 if (vec->sv_addr)
2006 return (DCMD_OK);
2007 else
2008 return (DCMD_ERR);
2009 }
2010
2011 /* ---------------------------------------------------------------------- */
2012 /*
2013 * Display an nsc_buf_t structure.
2014 */
2015
2016 #ifdef NSC_MULTI_TERABYTE
2017 #define STRCONV "ll"
2018 #else
2019 #define STRCONV ""
2020 #endif
2021
2022 /* ARGSUSED */
2023 static int
2024 nsc_buf(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
2025 {
2026 nsc_buf_t *bh;
2027 nsc_vec_t *v;
2028
2029 if (!(flags & DCMD_ADDRSPEC))
2030 return (DCMD_USAGE);
2031
2032 bh = mdb_zalloc(sizeof (*bh), UM_SLEEP | UM_GC);
2033
2034 if (mdb_vread(bh, sizeof (*bh), addr) != sizeof (*bh)) {
2035 mdb_warn("failed to read nsc_buf at %p", addr);
2036 return (DCMD_ERR);
2037 }
2038
2039 mdb_printf("nsc_buf_t @ 0x%p = {\n", addr);
2040 mdb_inc_indent(4);
2041 mdb_printf("sb_fd: 0x%p\n", bh->sb_fd);
2042 mdb_printf("sb_pos: 0x%" STRCONV "x\n", bh->sb_pos);
2043 mdb_printf("sb_len: 0x%" STRCONV "x\n", bh->sb_len);
2044 mdb_printf("sb_flag: 0x%08x <%b>\n", bh->sb_flag,
2045 bh->sb_flag, nsc_bhflag_bits);
2046 mdb_printf("sb_error: %d\n", bh->sb_error);
2047 #ifdef NSC_MULTI_TERABYTE
2048 mdb_printf("sb_user: 0x%p\n", bh->sb_user);
2049 #else
2050 mdb_printf("sb_user: 0x%x\n", bh->sb_user);
2051 #endif
2052 mdb_printf("sb_vec: 0x%p\n", bh->sb_vec);
2053 v = bh->sb_vec++;
2054 while (nsc_vec((uintptr_t)v, flags, argc, argv) == DCMD_OK)
2055 v++;
2056
2057 mdb_dec_indent(4);
2058 mdb_printf("};\n");
2059
2060 return (DCMD_OK);
2061 }
2062
2063 /* ---------------------------------------------------------------------- */
2064
2065 /* ARGSUSED */
2066 static int
2067 nsc_dbuf(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
2068 {
2069 nsc_dbuf_t *bh;
2070
2071 if (!(flags & DCMD_ADDRSPEC))
2072 return (DCMD_USAGE);
2073
2074 bh = mdb_zalloc(sizeof (*bh), UM_SLEEP | UM_GC);
2075
2076 if (mdb_vread(bh, sizeof (*bh), addr) != sizeof (*bh)) {
2077 mdb_warn("failed to read nsc_dbuf at %p", addr);
2078 return (DCMD_ERR);
2079 }
2080
2081 mdb_printf("nsc_dbuf_t @ 0x%p = {\n", addr);
2082 mdb_inc_indent(4);
2083 mdb_printf("db_disc: 0x%p\n", bh->db_disc);
2084 mdb_printf("db_addr: 0x%p\n", bh->db_addr);
2085 mdb_printf("db_next: 0x%p\n", bh->db_next);
2086 mdb_printf("db_maxfbas: 0x%d\n", bh->db_maxfbas);
2087
2088
2089 mdb_dec_indent(4);
2090 mdb_printf("};\n");
2091
2092 return (DCMD_OK);
2093 }
2094 /* ---------------------------------------------------------------------- */
2095
2096 /*
2097 * MDB module linkage information:
2098 */
2099
2100 static const mdb_dcmd_t dcmds[] = {
2101 #if 0
2102 { "nsctl", NULL, "display nsctl module info", nsctl },
2103 #endif
2104 { "nsc_buf", ":", "list nsc_buf structure", nsc_buf },
2105 { "nsc_dbuf", ":", "list nsc_dbuf structure", nsc_dbuf },
2106 { "nsc_dev", "?[-av]", "list nsc_dev structure", nsc_dev },
2107 { "nsc_devval", "?[-a]", "list nsc_devval structure", nsc_devval },
2108 { "nsc_fd", "?[-v]", "list nsc_fd structure", nsc_fd },
2109 { "nsc_iodev", "?[-v]", "list nsc_iodev structure", nsc_iodev },
2110 { "nsc_io", "?[-v]", "list nsc_io structure", nsc_io },
2111 { "nsc_mem", "?[-v]", "list nsc_mem structure", nsc_mem },
2112 { "nsc_svc", ":", "list nsc_svc structure", nsc_svc },
2113 { "nsc_service", "?[-v]", "list nsc_service structure", nsc_service },
2114 { "nsc_val", ":", "list nsc_val structure", nsc_val },
2115 { "nstset", "?[-frtv]", "list nstset structure", nstset },
2116 { "nsthread", "?[-av]", "list nsthread structure", nsthread },
2117 { NULL }
2118 };
2119
2120
2121 static const mdb_walker_t walkers[] = {
2122 { "nsc_dev", "walk nsc_dev chain",
2123 nsc_dev_winit, nsc_dev_wstep, nsc_dev_wfini, NULL },
2124 { "nsc_devval", "walk nsc_devval chain",
2125 nsc_devval_winit, nsc_devval_wstep, NULL, NULL },
2126 { "nsc_fd", "walk nsc_fd chain",
2127 nsc_fd_winit, nsc_fd_wstep, NULL, NULL },
2128 { "nsc_io", "walk nsc_io chain",
2129 nsc_io_winit, nsc_io_wstep, NULL, NULL },
2130 { "nsc_iodev", "walk nsc_iodev chain",
2131 nsc_iodev_winit, nsc_iodev_wstep, NULL, NULL },
2132 { "nsc_mem", "walk nsc_mem chain",
2133 nsc_mem_winit, nsc_mem_wstep, NULL, NULL },
2134 { "nsc_service", "walk nsc_service chain",
2135 nsc_service_winit, nsc_service_wstep, NULL, NULL },
2136 { "nsc_svc", "walk nsc_svc chain",
2137 nsc_svc_winit, nsc_svc_wstep, NULL, NULL },
2138 { "nsc_val", "walk nsc_val chain",
2139 nsc_val_winit, nsc_val_wstep, NULL, NULL },
2140 { "nstset", "walk nstset chain",
2141 nstset_winit, nstset_wstep, NULL, NULL },
2142 { "nsthread", "walk nsthread chain",
2143 nsthread_winit, nsthread_wstep, NULL, NULL },
2144 { "nst_free", "walk nsthread free/reuse list",
2145 nst_free_winit, nst_free_wstep, NULL, NULL },
2146 { NULL }
2147 };
2148
2149
2150 static const mdb_modinfo_t modinfo = {
2151 MDB_API_VERSION, dcmds, walkers
2152 };
2153
2154
2155 const mdb_modinfo_t *
2156 _mdb_init(void)
2157 {
2158 return (&modinfo);
2159 }