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 /*
23 * Copyright 2011 Nexenta Systems, Inc. All rights reserved.
24 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
25 * Use is subject to license terms.
26 */
27
28
29 #include <sys/mdb_modapi.h>
30 #include <mdb/mdb_ctf.h>
31 #include <sys/types.h>
32 #include <sys/socket.h>
33
34 #include <netsmb/smb_conn.h>
35 #include <netsmb/smb_rq.h>
36 #include <netsmb/smb_pass.h>
37
38 #define OPT_VERBOSE 0x0001 /* Be [-v]erbose in dcmd's */
39 #define OPT_RECURSE 0x0002 /* recursive display */
40
41 /*
42 * We need to read in a private copy
43 * of every string we want to print out.
44 */
45 void
46 print_str(uintptr_t addr)
47 {
48 char buf[32];
49 int len, mx = sizeof (buf) - 4;
50
51 if ((len = mdb_readstr(buf, sizeof (buf), addr)) <= 0) {
52 mdb_printf(" (%p)", addr);
53 } else {
54 if (len > mx)
55 strcpy(&buf[mx], "...");
56 mdb_printf(" %s", buf);
57 }
58 }
59
60
61 /*
62 * Walker for smb_connobj_t structures, including
63 * smb_vc_t and smb_share_t which "inherit" from it.
64 * Tricky: Exploit the "inheritance" of smb_connobj_t
65 * with common functions for walk_init, walk_next.
66 */
67 typedef struct smb_co_walk_data {
68 uintptr_t pp;
69 int level; /* SMBL_SM, SMBL_VC, SMBL_SHARE */
70 int size; /* sizeof (union member) */
71 union co_u {
72 smb_connobj_t co; /* copy of the list element */
73 smb_vc_t vc;
74 smb_share_t ss;
75 } u;
76 } smb_co_walk_data_t;
77
78 /*
79 * Common walk_init for walking structs inherited
80 * from smb_connobj_t (smb_vc_t, smb_share_t)
81 */
82 int
83 smb_co_walk_init(mdb_walk_state_t *wsp, int level)
84 {
85 smb_co_walk_data_t *smbw;
86 size_t psz;
87
88 if (wsp->walk_addr == NULL)
89 return (WALK_ERR);
90
91 smbw = mdb_alloc(sizeof (*smbw), UM_SLEEP | UM_GC);
92 wsp->walk_data = smbw;
93
94 /*
95 * Save the parent pointer for later checks, and
96 * the level so we know which union member it is.
97 * Also the size of this union member.
98 */
99 smbw->pp = wsp->walk_addr;
100 smbw->level = level;
101 switch (level) {
102 case SMBL_SM:
103 smbw->size = sizeof (smbw->u.co);
104 break;
105 case SMBL_VC:
106 smbw->size = sizeof (smbw->u.vc);
107 break;
108 case SMBL_SHARE:
109 smbw->size = sizeof (smbw->u.ss);
110 break;
111 default:
112 smbw->size = sizeof (smbw->u);
113 break;
114 }
115
116 /*
117 * Read in the parent object. Just need the
118 * invariant part (smb_connobj_t) so we can
119 * get the list of children below it.
120 */
121 psz = sizeof (smbw->u.co);
122 if (mdb_vread(&smbw->u.co, psz, smbw->pp) != psz) {
123 mdb_warn("cannot read connobj from %p", smbw->pp);
124 return (WALK_ERR);
125 }
126
127 /*
128 * Finally, setup to walk the list of children.
129 */
130 wsp->walk_addr = (uintptr_t)smbw->u.co.co_children.slh_first;
131
132 return (WALK_NEXT);
133 }
134
135 /*
136 * Walk the (global) VC list.
137 */
138 int
139 smb_vc_walk_init(mdb_walk_state_t *wsp)
140 {
141 GElf_Sym sym;
142
143 if (wsp->walk_addr != NULL) {
144 mdb_warn("::walk smb_vc only supports global walks\n");
145 return (WALK_ERR);
146 }
147
148 /* Locate the VC list head. */
149 if (mdb_lookup_by_obj("nsmb", "smb_vclist", &sym)) {
150 mdb_warn("failed to lookup `smb_vclist'\n");
151 return (WALK_ERR);
152 }
153 wsp->walk_addr = sym.st_value;
154
155 return (smb_co_walk_init(wsp, SMBL_VC));
156 }
157
158 /*
159 * Walk the share list below some VC.
160 */
161 int
162 smb_ss_walk_init(mdb_walk_state_t *wsp)
163 {
164
165 /*
166 * Initial walk_addr is address of parent (VC)
167 */
168 if (wsp->walk_addr == 0) {
169 mdb_warn("::walk smb_ss does not support global walks\n");
170 return (WALK_ERR);
171 }
172
173 return (smb_co_walk_init(wsp, SMBL_SHARE));
174 }
175
176 /*
177 * Common walk_step for walking structs inherited
178 * from smb_connobj_t (smb_vc_t, smb_share_t)
179 */
180 int
181 smb_co_walk_step(mdb_walk_state_t *wsp)
182 {
183 smb_co_walk_data_t *smbw = wsp->walk_data;
184 int status;
185
186 if (wsp->walk_addr == NULL)
187 return (WALK_DONE);
188
189 if (mdb_vread(&smbw->u, smbw->size, wsp->walk_addr)
190 != smbw->size) {
191 mdb_warn("cannot read connobj from %p", wsp->walk_addr);
192 return (WALK_ERR);
193 }
194
195 /* XXX: Sanity check level? parent pointer? */
196
197 status = wsp->walk_callback(wsp->walk_addr, &smbw->u,
198 wsp->walk_cbdata);
199
200 wsp->walk_addr = (uintptr_t)smbw->u.co.co_next.sle_next;
201
202 return (status);
203 }
204
205
206 /*
207 * Dcmd (and callback function) to print a summary of
208 * all VCs, and optionally all shares under each VC.
209 */
210
211 typedef struct smb_co_cbdata {
212 int flags; /* OPT_... */
213 int printed_header;
214 mdb_ctf_id_t ctf_id;
215 } smb_co_cbdata_t;
216
217 /*
218 * Call-back function for walking a share list.
219 */
220 int
221 smb_ss_cb(uintptr_t addr, const void *data, void *arg)
222 {
223 const smb_share_t *ssp = data;
224 smb_co_cbdata_t *cbd = arg;
225
226 mdb_printf(" %-p\t%s\n", addr, ssp->ss_name);
227
228 if (cbd->flags & OPT_VERBOSE) {
229 mdb_inc_indent(2);
230 /* Anything wanted here? */
231 mdb_dec_indent(2);
232 }
233
234 return (WALK_NEXT);
235 }
236
237 static const char *
238 vcstate_str(smb_co_cbdata_t *cbd, int stval)
239 {
240 static const char prefix[] = "SMBIOD_ST_";
241 int prefix_len = sizeof (prefix) - 1;
242 mdb_ctf_id_t vcst_enum;
243 const char *cp;
244
245 /* Got this in smb_vc_dcmd. */
246 vcst_enum = cbd->ctf_id;
247
248 /* Get the name for the enum value. */
249 if ((cp = mdb_ctf_enum_name(vcst_enum, stval)) == NULL)
250 return ("?");
251
252 /* Skip the prefix part. */
253 if (strncmp(cp, prefix, prefix_len) == 0)
254 cp += prefix_len;
255
256 return (cp);
257 }
258
259 /*
260 * Call-back function for walking the VC list.
261 */
262 int
263 smb_vc_cb(uintptr_t addr, const void *data, void *arg)
264 {
265 const smb_vc_t *vcp = data;
266 smb_co_cbdata_t *cbd = arg;
267
268 if (cbd->printed_header == 0) {
269 cbd->printed_header = 1;
270 mdb_printf("// smb_vc_t uid server \tuser\t\tstate\n");
271 }
272
273 mdb_printf("%-p", addr);
274 mdb_printf(" %7d", vcp->vc_owner);
275
276 switch (vcp->vc_srvaddr.sa.sa_family) {
277 case AF_INET:
278 mdb_printf(" %I", vcp->vc_srvaddr.sin.sin_addr);
279 break;
280 case AF_INET6:
281 mdb_printf(" %N", &vcp->vc_srvaddr.sin6.sin6_addr);
282 break;
283 default:
284 mdb_printf(" %15s", "(bad af)");
285 break;
286 }
287
288 if (vcp->vc_username[0] != '\0')
289 mdb_printf("\t%s", vcp->vc_username);
290 else
291 mdb_printf("\t%s", "(?)");
292
293 if (vcp->vc_domain[0] != '\0')
294 mdb_printf("@%s", vcp->vc_domain);
295
296 mdb_printf("\t%s\n", vcstate_str(cbd, vcp->vc_state));
297
298 if (cbd->flags & OPT_RECURSE) {
299 mdb_inc_indent(2);
300 if (mdb_pwalk("nsmb_ss", smb_ss_cb, cbd, addr) < 0) {
301 mdb_warn("failed to walk 'nsmb_ss'");
302 /* Don't: return (WALK_ERR); */
303 }
304 mdb_dec_indent(2);
305 }
306
307 return (WALK_NEXT);
308 }
309
310 int
311 smb_vc_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
312 {
313 smb_co_cbdata_t cbd;
314 smb_vc_t *vcp;
315 size_t vcsz;
316
317 memset(&cbd, 0, sizeof (cbd));
318
319 if (mdb_getopts(argc, argv,
320 'r', MDB_OPT_SETBITS, OPT_RECURSE, &cbd.flags,
321 'v', MDB_OPT_SETBITS, OPT_VERBOSE, &cbd.flags,
322 NULL) != argc) {
323 return (DCMD_USAGE);
324 }
325
326 if (mdb_ctf_lookup_by_name("enum smbiod_state", &cbd.ctf_id) == -1) {
327 mdb_warn("Could not find enum smbiod_state");
328 }
329
330 if (!(flags & DCMD_ADDRSPEC)) {
331 if (mdb_walk("nsmb_vc", smb_vc_cb, &cbd) == -1) {
332 mdb_warn("failed to walk 'nsmb_vc'");
333 return (DCMD_ERR);
334 }
335 return (DCMD_OK);
336 }
337
338 vcsz = sizeof (*vcp);
339 vcp = mdb_alloc(vcsz, UM_SLEEP | UM_GC);
340 if (mdb_vread(vcp, vcsz, addr) != vcsz) {
341 mdb_warn("cannot read VC from %p", addr);
342 return (DCMD_ERR);
343 }
344 smb_vc_cb(addr, vcp, &cbd);
345
346 return (DCMD_OK);
347 }
348
349 void
350 smb_vc_help(void)
351 {
352 mdb_printf("Options:\n"
353 " -r recursive display of share lists\n"
354 " -v be verbose when displaying smb_vc\n");
355 }
356
357 /*
358 * Walker for the request list on a VC,
359 * and dcmd to show a summary.
360 */
361 int
362 rqlist_walk_init(mdb_walk_state_t *wsp)
363 {
364 struct smb_rqhead rqh;
365 uintptr_t addr;
366
367 /*
368 * Initial walk_addr is the address of the VC.
369 * Add offsetof(iod_rqlist) to get the rqhead.
370 */
371 if (wsp->walk_addr == 0) {
372 mdb_warn("::walk smb_ss does not support global walks\n");
373 return (WALK_ERR);
374 }
375 addr = wsp->walk_addr;
376 addr += OFFSETOF(smb_vc_t, iod_rqlist);
377
378 if (mdb_vread(&rqh, sizeof (rqh), addr) == -1) {
379 mdb_warn("failed to read smb_rqhead at %p", addr);
380 return (WALK_ERR);
381 }
382 wsp->walk_addr = (uintptr_t)rqh.tqh_first;
383
384 return (WALK_NEXT);
385 }
386
387 int
388 rqlist_walk_step(mdb_walk_state_t *wsp)
389 {
390 smb_rq_t rq;
391 int status;
392
393 if (wsp->walk_addr == NULL)
394 return (WALK_DONE);
395
396 if (mdb_vread(&rq, sizeof (rq), wsp->walk_addr) == -1) {
397 mdb_warn("cannot read smb_rq from %p", wsp->walk_addr);
398 return (WALK_ERR);
399 }
400
401 status = wsp->walk_callback(wsp->walk_addr, &rq,
402 wsp->walk_cbdata);
403
404 wsp->walk_addr = (uintptr_t)rq.sr_link.tqe_next;
405
406 return (status);
407 }
408
409 typedef struct rqlist_cbdata {
410 int printed_header;
411 uintptr_t uid; /* optional filtering by UID */
412 } rqlist_cbdata_t;
413
414 int
415 rqlist_cb(uintptr_t addr, const void *data, void *arg)
416 {
417 const smb_rq_t *rq = data;
418 rqlist_cbdata_t *cbd = arg;
419
420 if (cbd->printed_header == 0) {
421 cbd->printed_header = 1;
422 mdb_printf("// smb_rq_t MID cmd sr_state sr_flags\n");
423 }
424
425 mdb_printf(" %-p", addr); /* smb_rq_t */
426 mdb_printf(" x%04x", rq->sr_mid);
427 mdb_printf(" x%02x", rq->sr_cmd);
428 mdb_printf(" %d", rq->sr_state);
429 mdb_printf(" x%x", rq->sr_flags);
430 mdb_printf("\n");
431
432 return (WALK_NEXT);
433 }
434
435 /*ARGSUSED*/
436 int
437 rqlist_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
438 {
439 rqlist_cbdata_t cbd;
440
441 memset(&cbd, 0, sizeof (cbd));
442
443 /*
444 * Initial walk_addr is address of parent (VC)
445 */
446 if (!(flags & DCMD_ADDRSPEC)) {
447 mdb_warn("address required\n");
448 return (DCMD_ERR);
449 }
450
451 if (mdb_pwalk("nsmb_rqlist", rqlist_cb, &cbd, addr) == -1) {
452 mdb_warn("failed to walk 'nsmb_rqlist'");
453 return (DCMD_ERR);
454 }
455
456 return (DCMD_OK);
457 }
458
459
460 /*
461 * AVL walker for the passwords AVL tree,
462 * and dcmd to show a summary.
463 */
464 static int
465 pwtree_walk_init(mdb_walk_state_t *wsp)
466 {
467 GElf_Sym sym;
468
469 if (wsp->walk_addr != NULL) {
470 mdb_warn("pwtree walk only supports global walks\n");
471 return (WALK_ERR);
472 }
473
474 if (mdb_lookup_by_obj("nsmb", "smb_ptd", &sym) == -1) {
475 mdb_warn("failed to find symbol 'smb_ptd'");
476 return (WALK_ERR);
477 }
478
479 wsp->walk_addr = (uintptr_t)sym.st_value;
480
481 if (mdb_layered_walk("avl", wsp) == -1) {
482 mdb_warn("failed to walk 'avl'\n");
483 return (WALK_ERR);
484 }
485
486 return (WALK_NEXT);
487 }
488
489 static int
490 pwtree_walk_step(mdb_walk_state_t *wsp)
491 {
492 smb_passid_t ptnode;
493
494 if (mdb_vread(&ptnode, sizeof (ptnode), wsp->walk_addr) == -1) {
495 mdb_warn("failed to read smb_passid_t at %p", wsp->walk_addr);
496 return (WALK_ERR);
497 }
498
499 return (wsp->walk_callback(wsp->walk_addr, &ptnode, wsp->walk_cbdata));
500 }
501
502 typedef struct pwtree_cbdata {
503 int printed_header;
504 uid_t uid; /* optional filtering by UID */
505 } pwtree_cbdata_t;
506
507 int
508 pwtree_cb(uintptr_t addr, const void *data, void *arg)
509 {
510 const smb_passid_t *ptn = data;
511 pwtree_cbdata_t *cbd = arg;
512
513 /* Optional filtering by UID. */
514 if (cbd->uid != (uid_t)-1 && cbd->uid != ptn->uid) {
515 return (WALK_NEXT);
516 }
517
518 if (cbd->printed_header == 0) {
519 cbd->printed_header = 1;
520 mdb_printf("// smb_passid_t UID domain user\n");
521 }
522
523 mdb_printf(" %-p", addr); /* smb_passid_t */
524 mdb_printf(" %d", (uintptr_t)ptn->uid);
525 print_str((uintptr_t)ptn->srvdom);
526 print_str((uintptr_t)ptn->username);
527 mdb_printf("\n");
528
529 return (WALK_NEXT);
530 }
531
532 /*ARGSUSED*/
533 int
534 pwtree_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
535 {
536 pwtree_cbdata_t cbd;
537 char *uid_str = NULL;
538 char buf[32];
539
540 memset(&cbd, 0, sizeof (cbd));
541
542 if (mdb_getopts(argc, argv,
543 'u', MDB_OPT_STR, &uid_str, NULL) != argc) {
544 return (DCMD_USAGE);
545 }
546 if (uid_str) {
547 /*
548 * Want the the default radix to be 10 here.
549 * If the string has some kind of radix prefix,
550 * just use that as-is, otherwise prepend "0t".
551 * Cheating on the "not a digit" test, but
552 * mdb_strtoull will do a real syntax check.
553 */
554 if (uid_str[0] == '0' && uid_str[1] > '9') {
555 cbd.uid = (uid_t)mdb_strtoull(uid_str);
556 } else {
557 strcpy(buf, "0t");
558 strlcat(buf, uid_str, sizeof (buf));
559 cbd.uid = (uid_t)mdb_strtoull(buf);
560 }
561 } else
562 cbd.uid = (uid_t)-1;
563
564 if (flags & DCMD_ADDRSPEC) {
565 mdb_warn("address not allowed\n");
566 return (DCMD_ERR);
567 }
568
569 if (mdb_pwalk("nsmb_pwtree", pwtree_cb, &cbd, 0) == -1) {
570 mdb_warn("failed to walk 'nsmb_pwtree'");
571 return (DCMD_ERR);
572 }
573
574 return (DCMD_OK);
575 }
576
577 void
578 pwtree_help(void)
579 {
580 mdb_printf("Options:\n"
581 " -u uid show only entries belonging to uid (decimal)\n");
582 }
583
584
585 static const mdb_dcmd_t dcmds[] = {
586 { "nsmb_vc", "?[-rv]",
587 "show smb_vc (or list)",
588 smb_vc_dcmd, smb_vc_help },
589 { "nsmb_rqlist", ":",
590 "show smb_rq list on a VC",
591 rqlist_dcmd, NULL },
592 { "nsmb_pwtree", "?[-u uid]",
593 "list smb_passid_t (password tree)",
594 pwtree_dcmd, pwtree_help },
595 {NULL}
596 };
597
598 static const mdb_walker_t walkers[] = {
599 { "nsmb_vc", "walk nsmb VC list",
600 smb_vc_walk_init, smb_co_walk_step, NULL },
601 { "nsmb_ss", "walk nsmb share list for some VC",
602 smb_ss_walk_init, smb_co_walk_step, NULL },
603 { "nsmb_rqlist", "walk request list for some VC",
604 rqlist_walk_init, rqlist_walk_step, NULL },
605 { "nsmb_pwtree", "walk passord AVL tree",
606 pwtree_walk_init, pwtree_walk_step, NULL },
607 {NULL}
608 };
609
610 static const mdb_modinfo_t modinfo = {
611 MDB_API_VERSION,
612 dcmds,
613 walkers
614 };
615
616 const mdb_modinfo_t *
617 _mdb_init(void)
618 {
619 return (&modinfo);
620 }