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/mdb_modapi.h>
28 #include <sys/ddi.h>
29 #include <sys/sunddi.h>
30 #include <sys/sunldi.h>
31
32 #include <sys/nsctl/nsctl.h>
33 #include <sys/unistat/spcs_s.h>
34 #include <sys/unistat/spcs_s_k.h>
35
36 #include <sys/nsctl/sv.h>
37 #include <sys/nsctl/sv_impl.h>
38
39 #include <sys/nsctl/nsvers.h>
40
41 /*
42 * Walker for an array of sv_dev_t structures.
43 * A global walk is assumed to start at sv_devs.
44 */
45
46 struct sv_dev_winfo {
47 uintptr_t start;
48 uintptr_t end;
49 };
50
51
52 static int
53 sv_dev_winit(mdb_walk_state_t *wsp)
54 {
55 struct sv_dev_winfo *winfo;
56 sv_dev_t *sv_devs;
57 int sv_max_devices;
58
59 winfo = mdb_zalloc(sizeof (struct sv_dev_winfo), UM_SLEEP);
60
61 if (mdb_readvar(&sv_devs, "sv_devs") == -1) {
62 mdb_warn("failed to read 'sv_devs'");
63 mdb_free(winfo, sizeof (struct sv_dev_winfo));
64 return (WALK_ERR);
65 }
66
67 if (mdb_readvar(&sv_max_devices, "sv_max_devices") == -1) {
68 mdb_warn("failed to read 'sv_max_devices'");
69 mdb_free(winfo, sizeof (struct sv_dev_winfo));
70 return (WALK_ERR);
71 }
72
73 winfo->start = (uintptr_t)sv_devs;
74 winfo->end = (uintptr_t)(sv_devs + sv_max_devices);
75
76 if (wsp->walk_addr == NULL)
77 wsp->walk_addr = winfo->start;
78
79 wsp->walk_data = winfo;
80 return (WALK_NEXT);
81 }
82
83
84 static int
85 sv_dev_wstep(mdb_walk_state_t *wsp)
86 {
87 struct sv_dev_winfo *winfo = wsp->walk_data;
88 int status;
89
90 if (wsp->walk_addr == NULL)
91 return (WALK_DONE);
92
93 if (wsp->walk_addr >= winfo->end)
94 return (WALK_DONE);
95
96 status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
97 wsp->walk_cbdata);
98
99 wsp->walk_addr += sizeof (sv_dev_t);
100 return (status);
101 }
102
103
104 static void
105 sv_dev_wfini(mdb_walk_state_t *wsp)
106 {
107 mdb_free(wsp->walk_data, sizeof (struct sv_dev_winfo));
108 }
109
110
111 /*
112 * Walker for an sv hash chain.
113 * Global walks are disallowed.
114 */
115
116 static int
117 sv_hash_winit(mdb_walk_state_t *wsp)
118 {
119 if (wsp->walk_addr == NULL)
120 return (WALK_ERR);
121
122 wsp->walk_data = mdb_zalloc(sizeof (sv_dev_t), UM_SLEEP);
123
124 return (WALK_NEXT);
125 }
126
127
128 static int
129 sv_hash_wstep(mdb_walk_state_t *wsp)
130 {
131 int status;
132
133 if (wsp->walk_addr == NULL)
134 return (WALK_DONE);
135
136 if (mdb_vread(wsp->walk_data,
137 sizeof (sv_dev_t), wsp->walk_addr) == -1) {
138 mdb_warn("failed to read sv_dev at %p", wsp->walk_addr);
139 return (WALK_DONE);
140 }
141
142 status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
143 wsp->walk_cbdata);
144
145 wsp->walk_addr = (uintptr_t)(((sv_dev_t *)wsp->walk_data)->sv_hash);
146 return (status);
147 }
148
149
150 static void
151 sv_hash_wfini(mdb_walk_state_t *wsp)
152 {
153 mdb_free(wsp->walk_data, sizeof (sv_dev_t));
154 }
155
156
157 /*
158 * Walker for an array of sv_maj_t structures.
159 * A global walk is assumed to start at sv_majors.
160 */
161
162 sv_maj_t *sv_majors[SV_MAJOR_HASH_CNT + 1] = {0};
163
164 static int
165 sv_maj_winit(mdb_walk_state_t *wsp)
166 {
167 if (wsp->walk_addr == NULL) {
168 if (mdb_readvar(&sv_majors, "sv_majors") == -1) {
169 mdb_warn("failed to read 'sv_majors'");
170 return (WALK_ERR);
171 }
172 } else {
173 sv_majors[0] = (sv_maj_t *)wsp->walk_addr;
174 }
175
176 wsp->walk_addr = (uintptr_t)&sv_majors[0];
177 wsp->walk_data = mdb_zalloc(sizeof (sv_maj_t), UM_SLEEP);
178
179 return (WALK_NEXT);
180 }
181
182
183 static int
184 sv_maj_wstep(mdb_walk_state_t *wsp)
185 {
186 uintptr_t addr;
187 int status = DCMD_OK;
188
189 if (wsp->walk_addr == NULL)
190 return (WALK_DONE);
191
192 if (wsp->walk_addr >= (uintptr_t)&sv_majors[SV_MAJOR_HASH_CNT])
193 return (WALK_DONE);
194
195 for (addr = *(uintptr_t *)wsp->walk_addr; addr;
196 addr = (uintptr_t)(((sv_maj_t *)wsp->walk_data)->sm_next)) {
197
198 if (mdb_vread(wsp->walk_data, sizeof (sv_maj_t), addr)
199 != sizeof (sv_maj_t)) {
200 mdb_warn("failed to read sv_maj at %p", addr);
201 status = DCMD_ERR;
202 break;
203 }
204
205 status = wsp->walk_callback(addr, wsp->walk_data,
206 wsp->walk_cbdata);
207 if (status != DCMD_OK)
208 break;
209 }
210
211 wsp->walk_addr += sizeof (sv_maj_t *);
212 return (status);
213 }
214
215
216 static void
217 sv_maj_wfini(mdb_walk_state_t *wsp)
218 {
219 mdb_free(wsp->walk_data, sizeof (sv_maj_t));
220 }
221
222
223 /*
224 * Walker for an sv gclient chain.
225 * A global walk is assumed to start at sv_gclients.
226 */
227
228 static int
229 sv_gclient_winit(mdb_walk_state_t *wsp)
230 {
231 if (wsp->walk_addr == NULL &&
232 mdb_readvar(&wsp->walk_addr, "sv_gclients") == -1) {
233 mdb_warn("unable to read 'sv_gclients'");
234 return (WALK_ERR);
235 }
236
237 wsp->walk_data = mdb_zalloc(sizeof (sv_gclient_t), UM_SLEEP);
238
239 return (WALK_NEXT);
240 }
241
242
243 static int
244 sv_gclient_wstep(mdb_walk_state_t *wsp)
245 {
246 int status;
247
248 if (wsp->walk_addr == NULL)
249 return (WALK_DONE);
250
251 if (mdb_vread(wsp->walk_data,
252 sizeof (sv_gclient_t), wsp->walk_addr) == -1) {
253 mdb_warn("failed to read sv_gclient at %p", wsp->walk_addr);
254 return (WALK_DONE);
255 }
256
257 status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
258 wsp->walk_cbdata);
259
260 wsp->walk_addr = (uintptr_t)(((sv_gclient_t *)wsp->walk_data)->sg_next);
261 return (status);
262 }
263
264
265 static void
266 sv_gclient_wfini(mdb_walk_state_t *wsp)
267 {
268 mdb_free(wsp->walk_data, sizeof (sv_gclient_t));
269 }
270
271
272 /*
273 * Display a single sv_glcient_t structure.
274 * If called with no address, performs a global walk of all sv_gclients.
275 */
276 static int
277 sv_gclient(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
278 {
279 sv_gclient_t sg;
280 char name[64];
281
282 if (argc != 0)
283 return (DCMD_USAGE);
284
285 if (!(flags & DCMD_ADDRSPEC)) {
286 /*
287 * paranoid mode on: qualify walker name with module name
288 * using '`' syntax.
289 */
290 if (mdb_walk_dcmd("sv`sv_gclient",
291 "sv`sv_gclient", argc, argv) == -1) {
292 mdb_warn("failed to walk 'sv_gclient'");
293 return (DCMD_ERR);
294 }
295 return (DCMD_OK);
296 }
297
298 if (mdb_vread(&sg, sizeof (sg), addr) != sizeof (sg)) {
299 mdb_warn("failed to read sv_gclient at %p", addr);
300 return (DCMD_ERR);
301 }
302
303 if (DCMD_HDRSPEC(flags)) {
304 mdb_printf("%-?s %8T%-?s %8T%-16s %8T%s\n",
305 "ADDR", "NEXT", "ID", "NAME");
306 }
307
308 if (mdb_readstr(name, sizeof (name), (uintptr_t)sg.sg_name) == -1) {
309 mdb_warn("failed to read sv_gclient name at %p", addr);
310 return (DCMD_ERR);
311 }
312
313 mdb_printf("%p %8T%p %8T%llx %8T%s",
314 addr, sg.sg_next, sg.sg_id, name);
315
316 return (DCMD_OK);
317 }
318
319
320 /*
321 * Display a single sv_maj_t structure.
322 * If called with no address, performs a global walk of all sv_majs.
323 * -a : all (i.e. display all devices, even if disabled
324 * -v : verbose
325 */
326 static int
327 sv_maj(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
328 {
329 sv_maj_t *maj;
330 int a_opt, v_opt;
331 int i;
332
333 a_opt = v_opt = FALSE;
334
335 if (mdb_getopts(argc, argv,
336 'a', MDB_OPT_SETBITS, TRUE, &a_opt,
337 'v', MDB_OPT_SETBITS, TRUE, &v_opt) != argc)
338 return (DCMD_USAGE);
339
340 if (!(flags & DCMD_ADDRSPEC)) {
341 /*
342 * paranoid mode on: qualify walker name with module name
343 * using '`' syntax.
344 */
345 if (mdb_walk_dcmd("sv`sv_maj", "sv`sv_maj", argc, argv) == -1) {
346 mdb_warn("failed to walk 'sv_maj'");
347 return (DCMD_ERR);
348 }
349 return (DCMD_OK);
350 }
351
352 if (DCMD_HDRSPEC(flags)) {
353 mdb_printf("%-?s %8T%s\n", "ADDR", "INUSE");
354 }
355
356 maj = mdb_zalloc(sizeof (*maj), UM_GC);
357 if (mdb_vread(maj, sizeof (*maj), addr) != sizeof (*maj)) {
358 mdb_warn("failed to read sv_maj at %p", addr);
359 return (DCMD_ERR);
360 }
361
362 if (!a_opt && maj->sm_inuse == 0)
363 return (DCMD_OK);
364
365 mdb_printf("%?p %8T%d\n", addr, maj->sm_inuse);
366
367 if (!v_opt)
368 return (DCMD_OK);
369
370 /*
371 * verbose - print the rest of the structure as well.
372 */
373
374 mdb_inc_indent(4);
375 mdb_printf("\n");
376
377 mdb_printf("dev_ops: %a (%p)\n", maj->sm_dev_ops, maj->sm_dev_ops);
378 mdb_printf("flag: %08x %8Tsequence: %d %8Tmajor: %d\n",
379 maj->sm_flag, maj->sm_seq, maj->sm_major);
380
381 mdb_printf("function pointers:\n");
382 mdb_inc_indent(4);
383 mdb_printf("%-20a%-20a%\n%-20a%-20a%\n%-20a%-20a%\n%-20a%-20a%\n",
384 maj->sm_open, maj->sm_close,
385 maj->sm_read, maj->sm_write,
386 maj->sm_aread, maj->sm_awrite,
387 maj->sm_strategy, maj->sm_ioctl);
388 mdb_dec_indent(4);
389
390
391 mdb_printf("hash chain:\n");
392 mdb_inc_indent(4);
393 for (i = 0; i < SV_MINOR_HASH_CNT; i++) {
394 mdb_printf("%?p", maj->sm_hash[i]);
395 mdb_printf(((i % 4) == 3) ? "\n" : " %8T");
396 }
397 mdb_printf("\n\n");
398 mdb_dec_indent(4);
399 mdb_dec_indent(4);
400 return (DCMD_OK);
401 }
402
403
404 /*
405 * Display a sv_dev_t hash chain.
406 * Requires an address.
407 * Same options as sv_dev().
408 */
409 static int
410 sv_hash(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
411 {
412 if (!(flags & DCMD_ADDRSPEC))
413 return (DCMD_USAGE);
414
415 /*
416 * paranoid mode on: qualify walker name with module name
417 * using '`' syntax.
418 */
419 if (mdb_pwalk_dcmd("sv`sv_hash", "sv`sv_dev", argc, argv, addr) == -1) {
420 mdb_warn("failed to walk sv_dev hash chain");
421 return (DCMD_ERR);
422 }
423
424 return (DCMD_OK);
425 }
426
427
428 /*
429 * Display a single sv_dev_t structure.
430 * If called with no address, performs a global walk of all sv_devs.
431 * -a : all (i.e. display all devices, even if disabled
432 * -v : verbose
433 */
434
435 const mdb_bitmask_t sv_flag_bits[] = {
436 { "NSC_DEVICE", NSC_DEVICE, NSC_DEVICE },
437 { "NSC_CACHE", NSC_CACHE, NSC_CACHE },
438 { NULL, 0, 0 }
439 };
440
441 static int
442 sv_dev(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
443 {
444 sv_dev_t *svp;
445 int a_opt, v_opt;
446 int dev_t_chars;
447
448 a_opt = v_opt = FALSE;
449 dev_t_chars = sizeof (dev_t) * 2; /* # chars to display dev_t */
450
451 if (mdb_getopts(argc, argv,
452 'a', MDB_OPT_SETBITS, TRUE, &a_opt,
453 'v', MDB_OPT_SETBITS, TRUE, &v_opt) != argc)
454 return (DCMD_USAGE);
455
456 svp = mdb_zalloc(sizeof (*svp), UM_GC);
457
458 if (!(flags & DCMD_ADDRSPEC)) {
459 /*
460 * paranoid mode on: qualify walker name with module name
461 * using '`' syntax.
462 */
463 if (mdb_walk_dcmd("sv`sv_dev", "sv`sv_dev", argc, argv) == -1) {
464 mdb_warn("failed to walk 'sv_dev'");
465 return (DCMD_ERR);
466 }
467 return (DCMD_OK);
468 }
469
470 if (DCMD_HDRSPEC(flags)) {
471 mdb_printf("%-?s %8T%-*s %8T%s\n", "ADDR",
472 dev_t_chars, "DEV", "STATE");
473 }
474
475 if (mdb_vread(svp, sizeof (*svp), addr) != sizeof (*svp)) {
476 mdb_warn("failed to read sv_dev at %p", addr);
477 return (DCMD_ERR);
478 }
479
480 if (!a_opt && svp->sv_state == SV_DISABLE)
481 return (DCMD_OK);
482
483 mdb_printf("%?p %8T%0*lx %8T", addr, dev_t_chars, svp->sv_dev);
484
485 if (svp->sv_state == SV_DISABLE)
486 mdb_printf("disabled");
487 else if (svp->sv_state == SV_PENDING)
488 mdb_printf("pending");
489 else if (svp->sv_state == SV_ENABLE)
490 mdb_printf("enabled");
491
492 mdb_printf("\n");
493
494 if (!v_opt)
495 return (DCMD_OK);
496
497 /*
498 * verbose - print the rest of the structure as well.
499 */
500
501 mdb_inc_indent(4);
502 mdb_printf("\n");
503
504 mdb_printf("hash chain: 0x%p %8Tlock: 0x%p %8Tolock: 0x%p\n",
505 svp->sv_hash,
506 addr + OFFSETOF(sv_dev_t, sv_lock),
507 addr + OFFSETOF(sv_dev_t, sv_olock));
508
509 mdb_printf("fd: 0x%p %8T\n", svp->sv_fd);
510
511 mdb_printf("maxfbas: %d %8Tnblocks: %d %8Tstate: %d\n",
512 svp->sv_maxfbas, svp->sv_nblocks, svp->sv_state);
513
514 mdb_printf("gclients: 0x%llx %8Tgkernel: 0x%llx\n",
515 svp->sv_gclients, svp->sv_gkernel);
516
517 mdb_printf("openlcnt: %d %8Ttimestamp: 0x%lx\n",
518 svp->sv_openlcnt, svp->sv_timestamp);
519
520 mdb_printf("flags: 0x%08x <%b>\n",
521 svp->sv_flag, svp->sv_flag, sv_flag_bits);
522
523 mdb_printf("lh: 0x%p %8Tpending: 0x%p\n",
524 svp->sv_lh, svp->sv_pending);
525
526 mdb_dec_indent(4);
527 return (DCMD_OK);
528 }
529
530
531 /*
532 * Display general sv module information.
533 */
534
535 #define sv_get_print(kvar, str, fmt, val) \
536 if (mdb_readvar(&(val), #kvar) == -1) { \
537 mdb_dec_indent(4); \
538 mdb_warn("unable to read '" #kvar "'"); \
539 return (DCMD_ERR); \
540 } \
541 mdb_printf("%-20s" fmt "\n", str ":", val)
542
543 /* ARGSUSED */
544 static int
545 sv(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
546 {
547 clock_t clock;
548 int maj, min, mic, baseline, i;
549
550 if (argc != 0)
551 return (DCMD_USAGE);
552
553 if (mdb_readvar(&maj, "sv_major_rev") == -1) {
554 mdb_warn("unable to read 'sv_major_rev'");
555 return (DCMD_ERR);
556 }
557
558 if (mdb_readvar(&min, "sv_minor_rev") == -1) {
559 mdb_warn("unable to read 'sv_minor_rev'");
560 return (DCMD_ERR);
561 }
562
563 if (mdb_readvar(&mic, "sv_micro_rev") == -1) {
564 mdb_warn("unable to read 'sv_micro_rev'");
565 return (DCMD_ERR);
566 }
567
568 if (mdb_readvar(&baseline, "sv_baseline_rev") == -1) {
569 mdb_warn("unable to read 'sv_baseline_rev'");
570 return (DCMD_ERR);
571 }
572
573 mdb_printf("SV module version: kernel %d.%d.%d.%d; mdb %d.%d.%d.%d\n",
574 maj, min, mic, baseline,
575 ISS_VERSION_MAJ, ISS_VERSION_MIN, ISS_VERSION_MIC, ISS_VERSION_NUM);
576 mdb_inc_indent(4);
577
578 sv_get_print(sv_config_time, "last config time", "0x%lx", clock);
579 sv_get_print(sv_stats_on, "stats on", "%d", i);
580 sv_get_print(sv_debug, "debug", "%d", i);
581 sv_get_print(sv_max_devices, "max sv devices", "%d", i);
582
583 mdb_dec_indent(4);
584 return (DCMD_OK);
585 }
586
587
588 /*
589 * MDB module linkage information:
590 */
591
592 static const mdb_dcmd_t dcmds[] = {
593 { "sv", NULL, "display sv module info", sv },
594 { "sv_dev", "?[-av]", "list sv_dev structure", sv_dev },
595 { "sv_gclient", "?", "list sv_gclient structure", sv_gclient },
596 { "sv_hash", ":[-av]", "display sv_dev hash chain", sv_hash },
597 { "sv_maj", "?[-av]", "list sv_maj structure", sv_maj },
598 { NULL }
599 };
600
601
602 static const mdb_walker_t walkers[] = {
603 { "sv_dev", "walk array of sv_dev structures",
604 sv_dev_winit, sv_dev_wstep, sv_dev_wfini },
605 { "sv_gclient", "walk sb_gclient chain",
606 sv_gclient_winit, sv_gclient_wstep, sv_gclient_wfini },
607 { "sv_hash", "walk sv_dev hash chain",
608 sv_hash_winit, sv_hash_wstep, sv_hash_wfini },
609 { "sv_maj", "walk array of sv_maj structures",
610 sv_maj_winit, sv_maj_wstep, sv_maj_wfini },
611 { NULL }
612 };
613
614
615 static const mdb_modinfo_t modinfo = {
616 MDB_API_VERSION, dcmds, walkers
617 };
618
619
620 const mdb_modinfo_t *
621 _mdb_init(void)
622 {
623 return (&modinfo);
624 }