xref: /onnv-gate/usr/src/cmd/mdb/common/modules/smbsrv/smbsrv.c (revision 7348:73b61202d5d6)
15331Samw /*
25331Samw  * CDDL HEADER START
35331Samw  *
45331Samw  * The contents of this file are subject to the terms of the
55331Samw  * Common Development and Distribution License (the "License").
65331Samw  * You may not use this file except in compliance with the License.
75331Samw  *
85331Samw  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
95331Samw  * or http://www.opensolaris.org/os/licensing.
105331Samw  * See the License for the specific language governing permissions
115331Samw  * and limitations under the License.
125331Samw  *
135331Samw  * When distributing Covered Code, include this CDDL HEADER in each
145331Samw  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
155331Samw  * If applicable, add the following below this CDDL HEADER, with the
165331Samw  * fields enclosed by brackets "[]" replaced with your own identifying
175331Samw  * information: Portions Copyright [yyyy] [name of copyright owner]
185331Samw  *
195331Samw  * CDDL HEADER END
205331Samw  */
215331Samw /*
225772Sas200622  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
235331Samw  * Use is subject to license terms.
245331Samw  */
255331Samw 
265331Samw #include <sys/mdb_modapi.h>
275331Samw #include <smbsrv/smb_vops.h>
285331Samw #include <smbsrv/smb.h>
295331Samw #include <smbsrv/mlsvc.h>
306139Sjb150015 #include <smbsrv/smb_ktypes.h>
315331Samw 
326432Sas200622 #define	SMB_DCMD_INDENT		2
336432Sas200622 #define	ACE_TYPE_TABLEN		(ACE_ALL_TYPES + 1)
346432Sas200622 #define	ACE_TYPE_ENTRY(_v_)	{_v_, #_v_}
356432Sas200622 #define	SMB_COM_ENTRY(_v_, _x_)	{#_v_, _x_}
366432Sas200622 
376432Sas200622 #define	SMB_MDB_MAX_OPTS	10
386432Sas200622 
396432Sas200622 #define	SMB_OPT_SERVER		0x00000001
406432Sas200622 #define	SMB_OPT_VFS		0x00000002
416432Sas200622 #define	SMB_OPT_SESSION		0x00000004
426432Sas200622 #define	SMB_OPT_REQUEST		0x00000008
436432Sas200622 #define	SMB_OPT_USER		0x00000010
446432Sas200622 #define	SMB_OPT_TREE		0x00000020
456432Sas200622 #define	SMB_OPT_OFILE		0x00000040
466432Sas200622 #define	SMB_OPT_ODIR		0x00000080
476432Sas200622 #define	SMB_OPT_WALK		0x00000100
486432Sas200622 #define	SMB_OPT_VERBOSE		0x00000200
496432Sas200622 #define	SMB_OPT_ALL_OBJ		0x000000FF
505331Samw 
516432Sas200622 /*
526432Sas200622  * Structure associating an ACE type to a string.
536432Sas200622  */
546432Sas200622 typedef struct {
556432Sas200622 	uint8_t		ace_type_value;
566432Sas200622 	const char	*ace_type_sting;
576432Sas200622 } ace_type_entry_t;
586432Sas200622 
596432Sas200622 /*
606432Sas200622  * Structure containing strings describing an SMB command.
616432Sas200622  */
626432Sas200622 typedef struct {
636432Sas200622 	const char	*smb_com;
646432Sas200622 	const char	*smb_andx;
656432Sas200622 } smb_com_entry_t;
666432Sas200622 
676432Sas200622 /*
686432Sas200622  * Structure describing an object to be expanded (displayed).
696432Sas200622  */
706432Sas200622 typedef struct {
716432Sas200622 	uint_t		ex_mask;
726432Sas200622 	size_t		ex_offset;
736432Sas200622 	const char	*ex_dcmd;
746432Sas200622 	const char	*ex_name;
756432Sas200622 } smb_exp_t;
765331Samw 
775331Samw /*
786432Sas200622  * List of supported options. Ther order has the match the bits SMB_OPT_xxx.
795331Samw  */
806432Sas200622 static const char *smb_opts[SMB_MDB_MAX_OPTS] =
816139Sjb150015 {
826432Sas200622 	"-s", "-m", "-e", "-r", "-u", "-t", "-f", "-d", "-w", "-v"
836432Sas200622 };
846139Sjb150015 
856432Sas200622 static smb_com_entry_t	smb_com[256] =
866139Sjb150015 {
876432Sas200622 	SMB_COM_ENTRY(SMB_COM_CREATE_DIRECTORY, "No"),
886432Sas200622 	SMB_COM_ENTRY(SMB_COM_DELETE_DIRECTORY, "No"),
896432Sas200622 	SMB_COM_ENTRY(SMB_COM_OPEN, "No"),
906432Sas200622 	SMB_COM_ENTRY(SMB_COM_CREATE, "No"),
916432Sas200622 	SMB_COM_ENTRY(SMB_COM_CLOSE, "No"),
926432Sas200622 	SMB_COM_ENTRY(SMB_COM_FLUSH, "No"),
936432Sas200622 	SMB_COM_ENTRY(SMB_COM_DELETE, "No"),
946432Sas200622 	SMB_COM_ENTRY(SMB_COM_RENAME, "No"),
956432Sas200622 	SMB_COM_ENTRY(SMB_COM_QUERY_INFORMATION, "No"),
966432Sas200622 	SMB_COM_ENTRY(SMB_COM_SET_INFORMATION, "No"),
976432Sas200622 	SMB_COM_ENTRY(SMB_COM_READ, "No"),
986432Sas200622 	SMB_COM_ENTRY(SMB_COM_WRITE, "No"),
996432Sas200622 	SMB_COM_ENTRY(SMB_COM_LOCK_BYTE_RANGE, "No"),
1006432Sas200622 	SMB_COM_ENTRY(SMB_COM_UNLOCK_BYTE_RANGE, "No"),
1016432Sas200622 	SMB_COM_ENTRY(SMB_COM_CREATE_TEMPORARY, "No"),
1026432Sas200622 	SMB_COM_ENTRY(SMB_COM_CREATE_NEW, "No"),
1036432Sas200622 	SMB_COM_ENTRY(SMB_COM_CHECK_DIRECTORY, "No"),
1046432Sas200622 	SMB_COM_ENTRY(SMB_COM_PROCESS_EXIT, "No"),
1056432Sas200622 	SMB_COM_ENTRY(SMB_COM_SEEK, "No"),
1066432Sas200622 	SMB_COM_ENTRY(SMB_COM_LOCK_AND_READ, "No"),
1076432Sas200622 	SMB_COM_ENTRY(SMB_COM_WRITE_AND_UNLOCK, "No"),
1086432Sas200622 	SMB_COM_ENTRY(0x15, "?"),
1096432Sas200622 	SMB_COM_ENTRY(0x16, "?"),
1106432Sas200622 	SMB_COM_ENTRY(0x17, "?"),
1116432Sas200622 	SMB_COM_ENTRY(0x18, "?"),
1126432Sas200622 	SMB_COM_ENTRY(0x19, "?"),
1136432Sas200622 	SMB_COM_ENTRY(SMB_COM_READ_RAW, "No"),
1146432Sas200622 	SMB_COM_ENTRY(SMB_COM_READ_MPX, "No"),
1156432Sas200622 	SMB_COM_ENTRY(SMB_COM_READ_MPX_SECONDARY, "No"),
1166432Sas200622 	SMB_COM_ENTRY(SMB_COM_WRITE_RAW, "No"),
1176432Sas200622 	SMB_COM_ENTRY(SMB_COM_WRITE_MPX, "No"),
1186432Sas200622 	SMB_COM_ENTRY(SMB_COM_WRITE_MPX_SECONDARY, "No"),
1196432Sas200622 	SMB_COM_ENTRY(SMB_COM_WRITE_COMPLETE, "No"),
1206432Sas200622 	SMB_COM_ENTRY(SMB_COM_QUERY_SERVER, "No"),
1216432Sas200622 	SMB_COM_ENTRY(SMB_COM_SET_INFORMATION2, "No"),
1226432Sas200622 	SMB_COM_ENTRY(SMB_COM_QUERY_INFORMATION2, "No"),
1236432Sas200622 	SMB_COM_ENTRY(SMB_COM_LOCKING_ANDX, "No"),
1246432Sas200622 	SMB_COM_ENTRY(SMB_COM_TRANSACTION, "No"),
1256432Sas200622 	SMB_COM_ENTRY(SMB_COM_TRANSACTION_SECONDARY, "No"),
1266432Sas200622 	SMB_COM_ENTRY(SMB_COM_IOCTL, "No"),
1276432Sas200622 	SMB_COM_ENTRY(SMB_COM_IOCTL_SECONDARY, "No"),
1286432Sas200622 	SMB_COM_ENTRY(SMB_COM_COPY, "No"),
1296432Sas200622 	SMB_COM_ENTRY(SMB_COM_MOVE, "No"),
1306432Sas200622 	SMB_COM_ENTRY(SMB_COM_ECHO, "No"),
1316432Sas200622 	SMB_COM_ENTRY(SMB_COM_WRITE_AND_CLOSE, "No"),
1326432Sas200622 	SMB_COM_ENTRY(SMB_COM_OPEN_ANDX, "No"),
1336432Sas200622 	SMB_COM_ENTRY(SMB_COM_READ_ANDX, "No"),
1346432Sas200622 	SMB_COM_ENTRY(SMB_COM_WRITE_ANDX, "No"),
1356432Sas200622 	SMB_COM_ENTRY(SMB_COM_NEW_FILE_SIZE, "No"),
1366432Sas200622 	SMB_COM_ENTRY(SMB_COM_CLOSE_AND_TREE_DISC, "No"),
1376432Sas200622 	SMB_COM_ENTRY(SMB_COM_TRANSACTION2, "No"),
1386432Sas200622 	SMB_COM_ENTRY(SMB_COM_TRANSACTION2_SECONDARY, "No"),
1396432Sas200622 	SMB_COM_ENTRY(SMB_COM_FIND_CLOSE2, "No"),
1406432Sas200622 	SMB_COM_ENTRY(SMB_COM_FIND_NOTIFY_CLOSE, "No"),
1416432Sas200622 	SMB_COM_ENTRY(0x36, "?"),
1426432Sas200622 	SMB_COM_ENTRY(0x37, "?"),
1436432Sas200622 	SMB_COM_ENTRY(0x38, "?"),
1446432Sas200622 	SMB_COM_ENTRY(0x39, "?"),
1456432Sas200622 	SMB_COM_ENTRY(0x3A, "?"),
1466432Sas200622 	SMB_COM_ENTRY(0x3B, "?"),
1476432Sas200622 	SMB_COM_ENTRY(0x3C, "?"),
1486432Sas200622 	SMB_COM_ENTRY(0x3D, "?"),
1496432Sas200622 	SMB_COM_ENTRY(0x3E, "?"),
1506432Sas200622 	SMB_COM_ENTRY(0x3F, "?"),
1516432Sas200622 	SMB_COM_ENTRY(0x40, "?"),
1526432Sas200622 	SMB_COM_ENTRY(0x41, "?"),
1536432Sas200622 	SMB_COM_ENTRY(0x42, "?"),
1546432Sas200622 	SMB_COM_ENTRY(0x43, "?"),
1556432Sas200622 	SMB_COM_ENTRY(0x44, "?"),
1566432Sas200622 	SMB_COM_ENTRY(0x45, "?"),
1576432Sas200622 	SMB_COM_ENTRY(0x46, "?"),
1586432Sas200622 	SMB_COM_ENTRY(0x47, "?"),
1596432Sas200622 	SMB_COM_ENTRY(0x48, "?"),
1606432Sas200622 	SMB_COM_ENTRY(0x49, "?"),
1616432Sas200622 	SMB_COM_ENTRY(0x4A, "?"),
1626432Sas200622 	SMB_COM_ENTRY(0x4B, "?"),
1636432Sas200622 	SMB_COM_ENTRY(0x4C, "?"),
1646432Sas200622 	SMB_COM_ENTRY(0x4D, "?"),
1656432Sas200622 	SMB_COM_ENTRY(0x4E, "?"),
1666432Sas200622 	SMB_COM_ENTRY(0x4F, "?"),
1676432Sas200622 	SMB_COM_ENTRY(0x50, "?"),
1686432Sas200622 	SMB_COM_ENTRY(0x51, "?"),
1696432Sas200622 	SMB_COM_ENTRY(0x52, "?"),
1706432Sas200622 	SMB_COM_ENTRY(0x53, "?"),
1716432Sas200622 	SMB_COM_ENTRY(0x54, "?"),
1726432Sas200622 	SMB_COM_ENTRY(0x55, "?"),
1736432Sas200622 	SMB_COM_ENTRY(0x56, "?"),
1746432Sas200622 	SMB_COM_ENTRY(0x57, "?"),
1756432Sas200622 	SMB_COM_ENTRY(0x58, "?"),
1766432Sas200622 	SMB_COM_ENTRY(0x59, "?"),
1776432Sas200622 	SMB_COM_ENTRY(0x5A, "?"),
1786432Sas200622 	SMB_COM_ENTRY(0x5B, "?"),
1796432Sas200622 	SMB_COM_ENTRY(0x5C, "?"),
1806432Sas200622 	SMB_COM_ENTRY(0x5D, "?"),
1816432Sas200622 	SMB_COM_ENTRY(0x5E, "?"),
1826432Sas200622 	SMB_COM_ENTRY(0x5F, "?"),
1836432Sas200622 	SMB_COM_ENTRY(0x60, "?"),
1846432Sas200622 	SMB_COM_ENTRY(0x61, "?"),
1856432Sas200622 	SMB_COM_ENTRY(0x62, "?"),
1866432Sas200622 	SMB_COM_ENTRY(0x63, "?"),
1876432Sas200622 	SMB_COM_ENTRY(0x64, "?"),
1886432Sas200622 	SMB_COM_ENTRY(0x65, "?"),
1896432Sas200622 	SMB_COM_ENTRY(0x66, "?"),
1906432Sas200622 	SMB_COM_ENTRY(0x67, "?"),
1916432Sas200622 	SMB_COM_ENTRY(0x68, "?"),
1926432Sas200622 	SMB_COM_ENTRY(0x69, "?"),
1936432Sas200622 	SMB_COM_ENTRY(0x6A, "?"),
1946432Sas200622 	SMB_COM_ENTRY(0x6B, "?"),
1956432Sas200622 	SMB_COM_ENTRY(0x6C, "?"),
1966432Sas200622 	SMB_COM_ENTRY(0x6D, "?"),
1976432Sas200622 	SMB_COM_ENTRY(0x6E, "?"),
1986432Sas200622 	SMB_COM_ENTRY(0x6F, "?"),
1996432Sas200622 	SMB_COM_ENTRY(SMB_COM_TREE_CONNECT, "No"),
2006432Sas200622 	SMB_COM_ENTRY(SMB_COM_TREE_DISCONNECT, "No"),
2016432Sas200622 	SMB_COM_ENTRY(SMB_COM_NEGOTIATE, "No"),
2026432Sas200622 	SMB_COM_ENTRY(SMB_COM_SESSION_SETUP_ANDX, "No"),
2036432Sas200622 	SMB_COM_ENTRY(SMB_COM_LOGOFF_ANDX, "No"),
2046432Sas200622 	SMB_COM_ENTRY(SMB_COM_TREE_CONNECT_ANDX, "No"),
2056432Sas200622 	SMB_COM_ENTRY(0x76, "?"),
2066432Sas200622 	SMB_COM_ENTRY(0x77, "?"),
2076432Sas200622 	SMB_COM_ENTRY(0x78, "?"),
2086432Sas200622 	SMB_COM_ENTRY(0x79, "?"),
2096432Sas200622 	SMB_COM_ENTRY(0x7A, "?"),
2106432Sas200622 	SMB_COM_ENTRY(0x7B, "?"),
2116432Sas200622 	SMB_COM_ENTRY(0x7C, "?"),
2126432Sas200622 	SMB_COM_ENTRY(0x7D, "?"),
2136432Sas200622 	SMB_COM_ENTRY(0x7E, "?"),
2146432Sas200622 	SMB_COM_ENTRY(0x7F, "?"),
2156432Sas200622 	SMB_COM_ENTRY(SMB_COM_QUERY_INFORMATION_DISK, "No"),
2166432Sas200622 	SMB_COM_ENTRY(SMB_COM_SEARCH, "No"),
2176432Sas200622 	SMB_COM_ENTRY(SMB_COM_FIND, "No"),
2186432Sas200622 	SMB_COM_ENTRY(SMB_COM_FIND_UNIQUE, "No"),
2196432Sas200622 	SMB_COM_ENTRY(SMB_COM_FIND_CLOSE, "No"),
2206432Sas200622 	SMB_COM_ENTRY(0x85, "?"),
2216432Sas200622 	SMB_COM_ENTRY(0x86, "?"),
2226432Sas200622 	SMB_COM_ENTRY(0x87, "?"),
2236432Sas200622 	SMB_COM_ENTRY(0x88, "?"),
2246432Sas200622 	SMB_COM_ENTRY(0x89, "?"),
2256432Sas200622 	SMB_COM_ENTRY(0x8A, "?"),
2266432Sas200622 	SMB_COM_ENTRY(0x8B, "?"),
2276432Sas200622 	SMB_COM_ENTRY(0x8C, "?"),
2286432Sas200622 	SMB_COM_ENTRY(0x8D, "?"),
2296432Sas200622 	SMB_COM_ENTRY(0x8E, "?"),
2306432Sas200622 	SMB_COM_ENTRY(0x8F, "?"),
2316432Sas200622 	SMB_COM_ENTRY(0x90, "?"),
2326432Sas200622 	SMB_COM_ENTRY(0x91, "?"),
2336432Sas200622 	SMB_COM_ENTRY(0x92, "?"),
2346432Sas200622 	SMB_COM_ENTRY(0x93, "?"),
2356432Sas200622 	SMB_COM_ENTRY(0x94, "?"),
2366432Sas200622 	SMB_COM_ENTRY(0x95, "?"),
2376432Sas200622 	SMB_COM_ENTRY(0x96, "?"),
2386432Sas200622 	SMB_COM_ENTRY(0x97, "?"),
2396432Sas200622 	SMB_COM_ENTRY(0x98, "?"),
2406432Sas200622 	SMB_COM_ENTRY(0x99, "?"),
2416432Sas200622 	SMB_COM_ENTRY(0x9A, "?"),
2426432Sas200622 	SMB_COM_ENTRY(0x9B, "?"),
2436432Sas200622 	SMB_COM_ENTRY(0x9C, "?"),
2446432Sas200622 	SMB_COM_ENTRY(0x9D, "?"),
2456432Sas200622 	SMB_COM_ENTRY(0x9E, "?"),
2466432Sas200622 	SMB_COM_ENTRY(0x9F, "?"),
2476432Sas200622 	SMB_COM_ENTRY(SMB_COM_NT_TRANSACT, "No"),
2486432Sas200622 	SMB_COM_ENTRY(SMB_COM_NT_TRANSACT_SECONDARY, "No"),
2496432Sas200622 	SMB_COM_ENTRY(SMB_COM_NT_CREATE_ANDX, "No"),
2506432Sas200622 	SMB_COM_ENTRY(SMB_COM_NT_CANCEL, "No"),
2516432Sas200622 	SMB_COM_ENTRY(SMB_COM_NT_RENAME, "No"),
2526432Sas200622 	SMB_COM_ENTRY(0xA6, "?"),
2536432Sas200622 	SMB_COM_ENTRY(0xA7, "?"),
2546432Sas200622 	SMB_COM_ENTRY(0xA8, "?"),
2556432Sas200622 	SMB_COM_ENTRY(0xA9, "?"),
2566432Sas200622 	SMB_COM_ENTRY(0xAA, "?"),
2576432Sas200622 	SMB_COM_ENTRY(0xAB, "?"),
2586432Sas200622 	SMB_COM_ENTRY(0xAC, "?"),
2596432Sas200622 	SMB_COM_ENTRY(0xAD, "?"),
2606432Sas200622 	SMB_COM_ENTRY(0xAE, "?"),
2616432Sas200622 	SMB_COM_ENTRY(0xAF, "?"),
2626432Sas200622 	SMB_COM_ENTRY(0xB0, "?"),
2636432Sas200622 	SMB_COM_ENTRY(0xB1, "?"),
2646432Sas200622 	SMB_COM_ENTRY(0xB2, "?"),
2656432Sas200622 	SMB_COM_ENTRY(0xB3, "?"),
2666432Sas200622 	SMB_COM_ENTRY(0xB4, "?"),
2676432Sas200622 	SMB_COM_ENTRY(0xB5, "?"),
2686432Sas200622 	SMB_COM_ENTRY(0xB6, "?"),
2696432Sas200622 	SMB_COM_ENTRY(0xB7, "?"),
2706432Sas200622 	SMB_COM_ENTRY(0xB8, "?"),
2716432Sas200622 	SMB_COM_ENTRY(0xB9, "?"),
2726432Sas200622 	SMB_COM_ENTRY(0xBA, "?"),
2736432Sas200622 	SMB_COM_ENTRY(0xBB, "?"),
2746432Sas200622 	SMB_COM_ENTRY(0xBC, "?"),
2756432Sas200622 	SMB_COM_ENTRY(0xBD, "?"),
2766432Sas200622 	SMB_COM_ENTRY(0xBE, "?"),
2776432Sas200622 	SMB_COM_ENTRY(0xBF, "?"),
2786432Sas200622 	SMB_COM_ENTRY(SMB_COM_OPEN_PRINT_FILE, "No"),
2796432Sas200622 	SMB_COM_ENTRY(SMB_COM_WRITE_PRINT_FILE, "No"),
2806432Sas200622 	SMB_COM_ENTRY(SMB_COM_CLOSE_PRINT_FILE, "No"),
2816432Sas200622 	SMB_COM_ENTRY(SMB_COM_GET_PRINT_QUEUE, "No"),
2826432Sas200622 	SMB_COM_ENTRY(0xC4, "?"),
2836432Sas200622 	SMB_COM_ENTRY(0xC5, "?"),
2846432Sas200622 	SMB_COM_ENTRY(0xC6, "?"),
2856432Sas200622 	SMB_COM_ENTRY(0xC7, "?"),
2866432Sas200622 	SMB_COM_ENTRY(0xC8, "?"),
2876432Sas200622 	SMB_COM_ENTRY(0xC9, "?"),
2886432Sas200622 	SMB_COM_ENTRY(0xCA, "?"),
2896432Sas200622 	SMB_COM_ENTRY(0xCB, "?"),
2906432Sas200622 	SMB_COM_ENTRY(0xCC, "?"),
2916432Sas200622 	SMB_COM_ENTRY(0xCD, "?"),
2926432Sas200622 	SMB_COM_ENTRY(0xCE, "?"),
2936432Sas200622 	SMB_COM_ENTRY(0xCF, "?"),
2946432Sas200622 	SMB_COM_ENTRY(0xD0, "?"),
2956432Sas200622 	SMB_COM_ENTRY(0xD1, "?"),
2966432Sas200622 	SMB_COM_ENTRY(0xD2, "?"),
2976432Sas200622 	SMB_COM_ENTRY(0xD3, "?"),
2986432Sas200622 	SMB_COM_ENTRY(0xD4, "?"),
2996432Sas200622 	SMB_COM_ENTRY(0xD5, "?"),
3006432Sas200622 	SMB_COM_ENTRY(0xD6, "?"),
3016432Sas200622 	SMB_COM_ENTRY(0xD7, "?"),
3026432Sas200622 	SMB_COM_ENTRY(SMB_COM_READ_BULK, "No"),
3036432Sas200622 	SMB_COM_ENTRY(SMB_COM_WRITE_BULK, "No"),
3046432Sas200622 	SMB_COM_ENTRY(SMB_COM_WRITE_BULK_DATA, "No"),
3056432Sas200622 	SMB_COM_ENTRY(0xDB, "?"),
3066432Sas200622 	SMB_COM_ENTRY(0xDC, "?"),
3076432Sas200622 	SMB_COM_ENTRY(0xDE, "?"),
3086432Sas200622 	SMB_COM_ENTRY(0xDF, "?"),
3096432Sas200622 	SMB_COM_ENTRY(0xE0, "?"),
3106432Sas200622 	SMB_COM_ENTRY(0xE1, "?"),
3116432Sas200622 	SMB_COM_ENTRY(0xE2, "?"),
3126432Sas200622 	SMB_COM_ENTRY(0xE3, "?"),
3136432Sas200622 	SMB_COM_ENTRY(0xE4, "?"),
3146432Sas200622 	SMB_COM_ENTRY(0xE5, "?"),
3156432Sas200622 	SMB_COM_ENTRY(0xE6, "?"),
3166432Sas200622 	SMB_COM_ENTRY(0xE7, "?"),
3176432Sas200622 	SMB_COM_ENTRY(0xE8, "?"),
3186432Sas200622 	SMB_COM_ENTRY(0xE9, "?"),
3196432Sas200622 	SMB_COM_ENTRY(0xEA, "?"),
3206432Sas200622 	SMB_COM_ENTRY(0xEB, "?"),
3216432Sas200622 	SMB_COM_ENTRY(0xEC, "?"),
3226432Sas200622 	SMB_COM_ENTRY(0xED, "?"),
3236432Sas200622 	SMB_COM_ENTRY(0xEE, "?"),
3246432Sas200622 	SMB_COM_ENTRY(0xEF, "?"),
3256432Sas200622 	SMB_COM_ENTRY(0xF0, "?"),
3266432Sas200622 	SMB_COM_ENTRY(0xF1, "?"),
3276432Sas200622 	SMB_COM_ENTRY(0xF2, "?"),
3286432Sas200622 	SMB_COM_ENTRY(0xF3, "?"),
3296432Sas200622 	SMB_COM_ENTRY(0xF4, "?"),
3306432Sas200622 	SMB_COM_ENTRY(0xF5, "?"),
3316432Sas200622 	SMB_COM_ENTRY(0xF6, "?"),
3326432Sas200622 	SMB_COM_ENTRY(0xF7, "?"),
3336432Sas200622 	SMB_COM_ENTRY(0xF8, "?"),
3346432Sas200622 	SMB_COM_ENTRY(0xF9, "?"),
3356432Sas200622 	SMB_COM_ENTRY(0xFA, "?"),
3366432Sas200622 	SMB_COM_ENTRY(0xFB, "?"),
3376432Sas200622 	SMB_COM_ENTRY(0xFC, "?"),
3386432Sas200622 	SMB_COM_ENTRY(0xFD, "?"),
3396432Sas200622 	SMB_COM_ENTRY(0xFE, "?"),
3406432Sas200622 	SMB_COM_ENTRY(0xFF, "?")
3416432Sas200622 };
3426139Sjb150015 
3436432Sas200622 static int smb_dcmd_list(uintptr_t, uint_t, int, const mdb_arg_t *);
3446432Sas200622 static void smb_dcmd_list_help(void);
3456432Sas200622 static int smb_dcmd_server(uintptr_t, uint_t, int, const mdb_arg_t *);
3466432Sas200622 static int smb_dcmd_vfs(uintptr_t, uint_t, int, const mdb_arg_t *);
3476432Sas200622 static void smb_dcmd_session_help(void);
3486432Sas200622 static int smb_dcmd_session(uintptr_t, uint_t, int, const mdb_arg_t *);
3496432Sas200622 static int smb_dcmd_request(uintptr_t, uint_t, int, const mdb_arg_t *);
3506432Sas200622 static void smb_dcmd_user_help(void);
3516432Sas200622 static int smb_dcmd_user(uintptr_t, uint_t, int, const mdb_arg_t *);
3526432Sas200622 static void smb_dcmd_tree_help(void);
3536432Sas200622 static int smb_dcmd_tree(uintptr_t, uint_t, int, const mdb_arg_t *);
3546432Sas200622 static int smb_dcmd_odir(uintptr_t, uint_t, int, const mdb_arg_t *);
3556432Sas200622 static int smb_dcmd_ofile(uintptr_t, uint_t, int, const mdb_arg_t *);
3566432Sas200622 static void smb_node_help(void);
3576432Sas200622 static int smb_node(uintptr_t, uint_t, int, const mdb_arg_t *);
3586432Sas200622 static int smb_node_walk_init(mdb_walk_state_t *);
3596432Sas200622 static int smb_node_walk_step(mdb_walk_state_t *);
3606432Sas200622 static int smb_lock(uintptr_t, uint_t, int, const mdb_arg_t *);
3616432Sas200622 static int smb_stats(uintptr_t, uint_t, int, const mdb_arg_t *);
3626432Sas200622 static int smb_ace(uintptr_t, uint_t, int, const mdb_arg_t *);
3636432Sas200622 static int smb_ace_walk_init(mdb_walk_state_t *);
3646432Sas200622 static int smb_ace_walk_step(mdb_walk_state_t *);
3656432Sas200622 static int smb_acl(uintptr_t, uint_t, int, const mdb_arg_t *);
3666432Sas200622 static int smb_sd(uintptr_t, uint_t, int, const mdb_arg_t *);
3676432Sas200622 static int smb_sid(uintptr_t, uint_t, int, const mdb_arg_t *);
3686432Sas200622 static int smb_sid_print(uintptr_t);
3696432Sas200622 static int smb_fssd(uintptr_t, uint_t, int, const mdb_arg_t *);
3706432Sas200622 static int smb_dcmd_getopt(uint_t *, int, const mdb_arg_t *);
3716432Sas200622 static int smb_dcmd_setopt(uint_t, int, mdb_arg_t *);
3726432Sas200622 static int smb_obj_expand(uintptr_t, uint_t, const smb_exp_t *, ulong_t);
3736432Sas200622 static int smb_obj_list(const char *, uint_t, uint_t);
3746139Sjb150015 
3756432Sas200622 /*
3766432Sas200622  * MDB module linkage information:
3776432Sas200622  *
3786432Sas200622  * We declare a list of structures describing our dcmds, a list of structures
3796432Sas200622  * describing our walkers and a function named _mdb_init to return a pointer
3806432Sas200622  * to our module information.
3816432Sas200622  */
3826432Sas200622 static const mdb_dcmd_t dcmds[] = {
3836432Sas200622 	{   "smblist",
3846432Sas200622 	    "[-seutfdwv]",
3856432Sas200622 	    "print tree of SMB objects",
3866432Sas200622 	    smb_dcmd_list,
3876432Sas200622 	    smb_dcmd_list_help },
3886432Sas200622 	{   "smbsrv",
3896432Sas200622 	    "[-seutfdwv]",
3906432Sas200622 	    "print smb_server information",
3916432Sas200622 	    smb_dcmd_server },
3926432Sas200622 	{   "smbvfs",
3936432Sas200622 	    "[-v]",
3946432Sas200622 	    "print smb_vfs information",
3956432Sas200622 	    smb_dcmd_vfs },
3966432Sas200622 	{   "smbnode",
3976432Sas200622 	    "?[-vps]",
3986432Sas200622 	    "print smb_node_t information",
3996432Sas200622 	    smb_node,
4006432Sas200622 	    smb_node_help },
4016432Sas200622 	{   "smbsess",
4026432Sas200622 	    "[-utfdwv]",
4036432Sas200622 	    "print smb_session_t information",
4046432Sas200622 	    smb_dcmd_session,
4056432Sas200622 	    smb_dcmd_session_help},
4066432Sas200622 	{   "smbreq",
4076432Sas200622 	    ":[-v]",
4086432Sas200622 	    "print smb_request_t information",
4096432Sas200622 	    smb_dcmd_request },
4106432Sas200622 	{   "smblock", ":[-v]",
4116432Sas200622 	    "print smb_lock_t information", smb_lock },
4126432Sas200622 	{   "smbuser",
4136432Sas200622 	    ":[-vdftq]",
4146432Sas200622 	    "print smb_user_t information",
4156432Sas200622 	    smb_dcmd_user,
4166432Sas200622 	    smb_dcmd_user_help },
4176432Sas200622 	{   "smbtree",
4186432Sas200622 	    ":[-vdf]",
4196432Sas200622 	    "print smb_tree_t information",
4206432Sas200622 	    smb_dcmd_tree,
4216432Sas200622 	    smb_dcmd_tree_help },
4226432Sas200622 	{   "smbodir",
4236432Sas200622 	    ":[-v]",
4246432Sas200622 	    "print smb_odir_t information",
4256432Sas200622 	    smb_dcmd_odir },
4266432Sas200622 	{   "smbofile",
4276432Sas200622 	    "[-v]",
4286432Sas200622 	    "print smb_odir_t information",
4296432Sas200622 	    smb_dcmd_ofile },
4306432Sas200622 	{   "smbstats", NULL,
4316432Sas200622 	    "print all smb dispatched requests statistics", smb_stats },
4326432Sas200622 	{   "smbace", "[-v]",
4336432Sas200622 	    "print smb_ace_t information", smb_ace },
4346432Sas200622 	{   "smbacl", "[-v]",
4356432Sas200622 	    "print smb_acl_t information", smb_acl },
4366432Sas200622 	{   "smbsid", "[-v]",
4376432Sas200622 	    "print smb_sid_t information", smb_sid },
4386432Sas200622 	{   "smbsd", "[-v]",
4396432Sas200622 	    "print smb_sd_t information", smb_sd },
4406432Sas200622 	{   "smbfssd", "[-v]",
4416432Sas200622 	    "print smb_fssd_t information", smb_fssd },
4426432Sas200622 	{ NULL }
4436432Sas200622 };
4445331Samw 
4456432Sas200622 static const mdb_walker_t walkers[] = {
4466432Sas200622 	{   "smbnode_walker",
4476432Sas200622 	    "walk list of smb_node_t structures",
4486432Sas200622 	    smb_node_walk_init,
4496432Sas200622 	    smb_node_walk_step,
4506432Sas200622 	    NULL,
4516432Sas200622 	    NULL },
4526432Sas200622 	{   "smbace_walker",
4536432Sas200622 	    "walk list of smb_ace_t structures",
4546432Sas200622 	    smb_ace_walk_init,
4556432Sas200622 	    smb_ace_walk_step,
4566432Sas200622 	    NULL,
4576432Sas200622 	    NULL },
4586432Sas200622 	{ NULL }
4596432Sas200622 };
4605331Samw 
4616432Sas200622 static const mdb_modinfo_t modinfo = {
4626432Sas200622 	MDB_API_VERSION, dcmds, walkers
4636432Sas200622 };
4646432Sas200622 
4656432Sas200622 const mdb_modinfo_t *
4666432Sas200622 _mdb_init(void)
4675331Samw {
4686432Sas200622 	return (&modinfo);
4695331Samw }
4705331Samw 
4715331Samw /*
4726432Sas200622  * *****************************************************************************
4736432Sas200622  * ****************************** Top level DCMD *******************************
4746432Sas200622  * *****************************************************************************
4755331Samw  */
4766432Sas200622 
4776432Sas200622 static void
4786432Sas200622 smb_dcmd_list_help(void)
4796432Sas200622 {
4806432Sas200622 	mdb_printf(
4816432Sas200622 	    "Displays the list of objects using an indented tree format.\n"
4826432Sas200622 	    "If no option is specified the entire tree is displayed\n\n");
4836432Sas200622 	(void) mdb_dec_indent(2);
4846432Sas200622 	mdb_printf("%<b>OPTIONS%</b>\n");
4856432Sas200622 	(void) mdb_inc_indent(2);
4866432Sas200622 	mdb_printf(
4876432Sas200622 	    "-v\tDisplay verbose information\n"
4886432Sas200622 	    "-s\tDisplay the list of servers\n"
4896432Sas200622 	    "-m\tDisplay the list of shared file systems\n"
4906432Sas200622 	    "-e\tDisplay the list of sessions\n"
4916432Sas200622 	    "-r\tDisplay the list of smb requests\n"
4926432Sas200622 	    "-u\tDisplay the list of users\n"
4936432Sas200622 	    "-t\tDisplay the list of trees\n"
4946432Sas200622 	    "-f\tDisplay the list of open files\n"
4956432Sas200622 	    "-d\tDisplay the list of open searches\n");
4966432Sas200622 }
4976432Sas200622 
4986432Sas200622 /*
4996432Sas200622  * ::smblist
5006432Sas200622  *
5016432Sas200622  * This function lists the objects specified on the command line. If no object
5026432Sas200622  * is specified the entire tree (server through ofile and odir) is displayed.
5036432Sas200622  *
5046432Sas200622  */
5056432Sas200622 /*ARGSUSED*/
5065331Samw static int
5076432Sas200622 smb_dcmd_list(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
5085331Samw {
5095331Samw 	GElf_Sym	sym;
5106432Sas200622 	uint_t		opts = 0;
5116432Sas200622 	int		new_argc;
5126432Sas200622 	mdb_arg_t	new_argv[SMB_MDB_MAX_OPTS];
5136432Sas200622 
5146432Sas200622 	if (smb_dcmd_getopt(&opts, argc, argv))
5156432Sas200622 		return (DCMD_USAGE);
5166432Sas200622 
5176432Sas200622 	if (!(opts & ~(SMB_OPT_WALK | SMB_OPT_VERBOSE)))
5186432Sas200622 		opts |= SMB_OPT_ALL_OBJ;
5196432Sas200622 
5206432Sas200622 	opts |= SMB_OPT_WALK;
5216432Sas200622 
5226432Sas200622 	new_argc = smb_dcmd_setopt(opts, SMB_MDB_MAX_OPTS, new_argv);
5236432Sas200622 
5246432Sas200622 	if (mdb_lookup_by_name("smb_servers", &sym) == -1) {
5256432Sas200622 		mdb_warn("failed to find symbol smb_servers");
5266432Sas200622 		return (DCMD_ERR);
5276432Sas200622 	}
5286432Sas200622 
5296432Sas200622 	addr = (uintptr_t)sym.st_value + offsetof(smb_llist_t, ll_list);
5306432Sas200622 
5316432Sas200622 	if (mdb_pwalk_dcmd("list", "smbsrv", new_argc, new_argv, addr))
5326432Sas200622 		return (DCMD_ERR);
5336432Sas200622 	return (DCMD_OK);
5346432Sas200622 }
5356432Sas200622 
5366432Sas200622 /*
5376432Sas200622  * *****************************************************************************
5386432Sas200622  * ***************************** smb_server_t **********************************
5396432Sas200622  * *****************************************************************************
5406432Sas200622  */
5416432Sas200622 
5426432Sas200622 static const char *smb_server_state[SMB_SERVER_STATE_SENTINEL] =
5436432Sas200622 {
5446432Sas200622 	"CREATED",
5456432Sas200622 	"CONFIGURED",
5466432Sas200622 	"RUNNING",
5476432Sas200622 	"DELETING"
5486432Sas200622 };
5496432Sas200622 
5506432Sas200622 /*
5516432Sas200622  * List of objects that can be expanded under a server structure.
5526432Sas200622  */
5536432Sas200622 static const smb_exp_t smb_server_exp[] =
5546432Sas200622 {
5556432Sas200622 	{ SMB_OPT_ALL_OBJ,
5566432Sas200622 	    offsetof(smb_server_t, sv_nbt_daemon.ld_session_list.se_rdy.lst),
5576432Sas200622 	    "smbsess", "smb_session"},
5586432Sas200622 	{ SMB_OPT_ALL_OBJ,
5596432Sas200622 	    offsetof(smb_server_t, sv_nbt_daemon.ld_session_list.se_act.lst),
5606432Sas200622 	    "smbsess", "smb_session"},
5616432Sas200622 	{ SMB_OPT_ALL_OBJ,
5626432Sas200622 	    offsetof(smb_server_t, sv_tcp_daemon.ld_session_list.se_rdy.lst),
5636432Sas200622 	    "smbsess", "smb_session"},
5646432Sas200622 	{ SMB_OPT_ALL_OBJ,
5656432Sas200622 	    offsetof(smb_server_t, sv_tcp_daemon.ld_session_list.se_act.lst),
5666432Sas200622 	    "smbsess", "smb_session"},
5676432Sas200622 	{ SMB_OPT_ALL_OBJ,
5686432Sas200622 	    offsetof(smb_server_t, sv_vfs_list.ll_list),
5696432Sas200622 	    "smbvfs", "smb_vfs"},
5706432Sas200622 	{ 0, 0, NULL, NULL }
5716432Sas200622 };
5726432Sas200622 
5736432Sas200622 /*
5746432Sas200622  * ::smbsrv
5756432Sas200622  *
5766432Sas200622  * smbsrv dcmd - Print out smb_server structures.
5776432Sas200622  */
5786432Sas200622 /*ARGSUSED*/
5796432Sas200622 static int
5806432Sas200622 smb_dcmd_server(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
5816432Sas200622 {
5826432Sas200622 	uint_t		opts;
5836432Sas200622 	ulong_t		indent = 0;
5845331Samw 
5856432Sas200622 	if (smb_dcmd_getopt(&opts, argc, argv))
5866432Sas200622 		return (DCMD_USAGE);
5876432Sas200622 
5886432Sas200622 	if (!(flags & DCMD_ADDRSPEC))
5896432Sas200622 		return (smb_obj_list("smb_server", opts | SMB_OPT_SERVER,
5906432Sas200622 		    flags));
5916432Sas200622 
5926432Sas200622 	if (((opts & SMB_OPT_WALK) && (opts & SMB_OPT_SERVER)) ||
5936432Sas200622 	    !(opts & SMB_OPT_WALK)) {
5946432Sas200622 		smb_server_t	*sv;
5956432Sas200622 		const char	*state;
5966432Sas200622 
5976432Sas200622 		sv = mdb_alloc(sizeof (smb_server_t), UM_SLEEP | UM_GC);
5986432Sas200622 		if (mdb_vread(sv, sizeof (smb_server_t), addr) == -1) {
5996432Sas200622 			mdb_warn("failed to read smb_server at %p", addr);
6006432Sas200622 			return (DCMD_ERR);
6015331Samw 		}
6026432Sas200622 
6036432Sas200622 		indent = SMB_DCMD_INDENT;
6046432Sas200622 
6056432Sas200622 		if (opts & SMB_OPT_VERBOSE) {
6066432Sas200622 			mdb_arg_t	argv;
6076432Sas200622 
6086432Sas200622 			argv.a_type = MDB_TYPE_STRING;
6096432Sas200622 			argv.a_un.a_str = "smb_server_t";
6106432Sas200622 			if (mdb_call_dcmd("print", addr, flags, 1, &argv))
6116432Sas200622 				return (DCMD_ERR);
6126432Sas200622 		} else {
6136432Sas200622 			if (DCMD_HDRSPEC(flags))
6146432Sas200622 				mdb_printf(
6156432Sas200622 				    "%<b>%<u>%-?s% "
6166432Sas200622 				    "%-4s% "
6176432Sas200622 				    "%-32s% "
6186432Sas200622 				    "%-6s% "
6196432Sas200622 				    "%-6s% "
6206432Sas200622 				    "%-6s%</u>%</b>\n",
6216432Sas200622 				    "SERVER", "ZONE", "STATE", "USERS",
6226432Sas200622 				    "TREES", "FILES");
6236432Sas200622 
6246432Sas200622 			if (sv->sv_state >= SMB_SERVER_STATE_SENTINEL)
6256432Sas200622 				state = "UNKNOWN";
6266432Sas200622 			else
6276432Sas200622 				state = smb_server_state[sv->sv_state];
6286432Sas200622 
6296432Sas200622 			mdb_printf("%-?p %-4d %-32s %-6d %-6d %-6d \n",
6306432Sas200622 			    addr, sv->sv_zid, state, sv->sv_open_users,
6316432Sas200622 			    sv->sv_open_trees, sv->sv_open_files);
6326432Sas200622 		}
6336432Sas200622 	}
6346432Sas200622 	if (smb_obj_expand(addr, opts, smb_server_exp, indent))
6356432Sas200622 		return (DCMD_ERR);
6366432Sas200622 	return (DCMD_OK);
6376432Sas200622 }
6386432Sas200622 
6396432Sas200622 /*
6406432Sas200622  * *****************************************************************************
6416432Sas200622  * ******************************** smb_vfs_t **********************************
6426432Sas200622  * *****************************************************************************
6436432Sas200622  */
6446432Sas200622 
6456432Sas200622 /*
6466432Sas200622  * ::smbvfs
6476432Sas200622  *
6486432Sas200622  * smbvfs dcmd - Prints out smb_vfs structures.
6496432Sas200622  */
6506432Sas200622 /*ARGSUSED*/
6516432Sas200622 static int
6526432Sas200622 smb_dcmd_vfs(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
6536432Sas200622 {
6546432Sas200622 
6556432Sas200622 	uint_t		opts;
6566432Sas200622 
6576432Sas200622 	if (smb_dcmd_getopt(&opts, argc, argv))
6586432Sas200622 		return (DCMD_USAGE);
6596432Sas200622 
6606432Sas200622 	if (!(flags & DCMD_ADDRSPEC)) {
6616432Sas200622 		return (smb_obj_list("smb_vfs", SMB_OPT_VFS, flags));
6625331Samw 	}
6635331Samw 
6646432Sas200622 	if (((opts & SMB_OPT_WALK) && (opts & SMB_OPT_VFS)) ||
6656432Sas200622 	    !(opts & SMB_OPT_WALK)) {
6666432Sas200622 		smb_vfs_t	*sf;
6676432Sas200622 		vnode_t		*vn;
6686432Sas200622 		char		*path;
6696432Sas200622 
6706432Sas200622 		sf = mdb_alloc(sizeof (*sf), UM_SLEEP | UM_GC);
6716432Sas200622 		if (mdb_vread(sf, sizeof (*sf), addr) == -1) {
6726432Sas200622 			mdb_warn("failed to read smb_vfs at %p", addr);
6736432Sas200622 			return (DCMD_ERR);
6746432Sas200622 		}
6756432Sas200622 		vn = mdb_alloc(sizeof (*vn), UM_SLEEP | UM_GC);
6766432Sas200622 		if (mdb_vread(vn, sizeof (*vn),
6776432Sas200622 		    (uintptr_t)sf->sv_rootvp) == -1) {
6786432Sas200622 			mdb_warn("failed to read vnode at %p", sf->sv_rootvp);
6796432Sas200622 			return (DCMD_ERR);
6806432Sas200622 		}
6816432Sas200622 		path = mdb_zalloc(MAXPATHLEN, UM_SLEEP | UM_GC);
6826432Sas200622 		(void) mdb_vread(path, MAXPATHLEN, (uintptr_t)vn->v_path);
6836432Sas200622 
6846432Sas200622 		if (DCMD_HDRSPEC(flags))
6856432Sas200622 			mdb_printf(
6866432Sas200622 			    "%<b>%<u>"
6876432Sas200622 			    "%-?s "
6886432Sas200622 			    "%-10s "
6896432Sas200622 			    "%-16s "
6906432Sas200622 			    "%-16s"
6916432Sas200622 			    "%-s"
6926432Sas200622 			    "%</u>%</b>\n",
6936432Sas200622 			    "SMB_VFS", "REFCNT", "VFS", "VNODE", "ROOT");
6946432Sas200622 		mdb_printf(
6956432Sas200622 		    "%-?p %-10d %-?p %-?p %-s\n", addr, sf->sv_refcnt,
6966432Sas200622 		    sf->sv_vfsp, sf->sv_rootvp, path);
6976432Sas200622 	}
6986432Sas200622 	return (DCMD_OK);
6996432Sas200622 }
7006432Sas200622 
7016432Sas200622 /*
7026432Sas200622  * *****************************************************************************
7036432Sas200622  * ***************************** smb_session_t *********************************
7046432Sas200622  * *****************************************************************************
7056432Sas200622  */
7066432Sas200622 
7076432Sas200622 static const char *smb_session_state[SMB_SESSION_STATE_SENTINEL] =
7086432Sas200622 {
7096432Sas200622 	"INITIALIZED",
7106432Sas200622 	"DISCONNECTED",
7116432Sas200622 	"CONNECTED",
7126432Sas200622 	"ESTABLISHED",
7136432Sas200622 	"NEGOTIATED",
7146432Sas200622 	"OPLOCK_BREAKING",
7156432Sas200622 	"WRITE_RAW_ACTIVE",
7166432Sas200622 	"TERMINATED"
7176432Sas200622 };
7186432Sas200622 
7196432Sas200622 /*
7206432Sas200622  * List of objects that can be expanded under a session structure.
7216432Sas200622  */
7226432Sas200622 static const smb_exp_t smb_session_exp[] =
7236432Sas200622 {
7246432Sas200622 	{ SMB_OPT_REQUEST,
7256432Sas200622 	    offsetof(smb_session_t, s_req_list.sl_list),
7266432Sas200622 	    "smbreq", "smb_request"},
7276432Sas200622 	{ SMB_OPT_USER | SMB_OPT_TREE | SMB_OPT_OFILE | SMB_OPT_ODIR,
7286432Sas200622 	    offsetof(smb_session_t, s_user_list.ll_list),
7296432Sas200622 	    "smbuser", "smb_user"},
7306432Sas200622 	{ 0, 0, NULL, NULL}
7316432Sas200622 };
7326432Sas200622 
7336432Sas200622 static void
7346432Sas200622 smb_dcmd_session_help(void)
7356432Sas200622 {
7366432Sas200622 	mdb_printf(
7376432Sas200622 	    "Display the contents of smb_session_t, with optional"
7386432Sas200622 	    " filtering.\n\n");
7396432Sas200622 	(void) mdb_dec_indent(2);
7406432Sas200622 	mdb_printf("%<b>OPTIONS%</b>\n");
7416432Sas200622 	(void) mdb_inc_indent(2);
7426432Sas200622 	mdb_printf(
7436432Sas200622 	    "-v\tDisplay verbose smb_session information\n"
7446432Sas200622 	    "-r\tDisplay the list of smb requests attached\n"
7456432Sas200622 	    "-u\tDisplay the list of users attached\n");
7466432Sas200622 }
7476432Sas200622 
7486432Sas200622 /*
7496432Sas200622  * ::smbsess
7506432Sas200622  *
7516432Sas200622  * smbsess dcmd - Print out the smb_session structure.
7526432Sas200622  */
7536432Sas200622 /*ARGSUSED*/
7546432Sas200622 static int
7556432Sas200622 smb_dcmd_session(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
7566432Sas200622 {
7576432Sas200622 	uint_t		opts;
7586432Sas200622 	ulong_t		indent = 0;
7596432Sas200622 
7606432Sas200622 	if (smb_dcmd_getopt(&opts, argc, argv))
7616432Sas200622 		return (DCMD_USAGE);
7626432Sas200622 
7636432Sas200622 	if (!(flags & DCMD_ADDRSPEC)) {
7646432Sas200622 		opts |= SMB_OPT_SESSION;
7656432Sas200622 		opts &= ~SMB_OPT_SERVER;
7666432Sas200622 		return (smb_obj_list("smb_session", opts, flags));
7676432Sas200622 	}
7686432Sas200622 
7696432Sas200622 	if (((opts & SMB_OPT_WALK) && (opts & SMB_OPT_SESSION)) ||
7706432Sas200622 	    !(opts & SMB_OPT_WALK)) {
7716432Sas200622 		smb_session_t	*se;
7726432Sas200622 		const char	*state;
7736432Sas200622 
7746432Sas200622 		indent = SMB_DCMD_INDENT;
7756432Sas200622 
7766432Sas200622 		se = mdb_alloc(sizeof (*se), UM_SLEEP | UM_GC);
7776432Sas200622 		if (mdb_vread(se, sizeof (*se), addr) == -1) {
7786432Sas200622 			mdb_warn("failed to read smb_session at %p", addr);
7796432Sas200622 			return (DCMD_ERR);
7806432Sas200622 		}
7816432Sas200622 
7826432Sas200622 		if (se->s_state >= SMB_SESSION_STATE_SENTINEL)
7836432Sas200622 			state = "INVALID";
7846432Sas200622 		else
7856432Sas200622 			state = smb_session_state[se->s_state];
7866432Sas200622 
7876432Sas200622 		if (opts & SMB_OPT_VERBOSE) {
7886432Sas200622 			mdb_printf("%<b>%<u>SMB session information "
7896432Sas200622 			    "(%p): %</u>%</b>\n", addr);
7906432Sas200622 			mdb_printf("Client IP address: %I\n", se->ipaddr);
7916432Sas200622 			mdb_printf("Local IP Address: %I\n", se->local_ipaddr);
7926432Sas200622 			mdb_printf("Session KID: %u\n", se->s_kid);
7936432Sas200622 			mdb_printf("Workstation Name: %s\n",
7946432Sas200622 			    se->workstation);
7956432Sas200622 			mdb_printf("Session state: %u (%s)\n", se->s_state,
7966432Sas200622 			    state);
7976432Sas200622 			mdb_printf("Number of Users: %u\n",
7986432Sas200622 			    se->s_user_list.ll_count);
7996432Sas200622 			mdb_printf("Number of Trees: %u\n", se->s_tree_cnt);
8006432Sas200622 			mdb_printf("Number of Files: %u\n", se->s_file_cnt);
8016432Sas200622 			mdb_printf("Number of Shares: %u\n", se->s_dir_cnt);
8026432Sas200622 			mdb_printf("Number of active Transact.: %u\n\n",
8036432Sas200622 			    se->s_xa_list.ll_count);
8046432Sas200622 		} else {
8056432Sas200622 			if (DCMD_HDRSPEC(flags))
8066432Sas200622 				mdb_printf(
8076432Sas200622 				    "%<b>%<u>%-?s "
8086432Sas200622 				    "%-16s "
8096432Sas200622 				    "%-16s%</u>\n",
8106432Sas200622 				    "SESSION", "CLIENT_IP_ADDR",
8116432Sas200622 				    "LOCAL_IP_ADDR");
8126432Sas200622 			mdb_printf(
8136432Sas200622 			    "%-?p %-16I %-16I\n", addr, se->ipaddr,
8146432Sas200622 			    se->local_ipaddr);
8155331Samw 		}
8165331Samw 	}
8176432Sas200622 	if (smb_obj_expand(addr, opts, smb_session_exp, indent))
8186432Sas200622 		return (DCMD_ERR);
8196432Sas200622 	return (DCMD_OK);
8206432Sas200622 }
8215331Samw 
8226432Sas200622 /*
8236432Sas200622  * *****************************************************************************
8246432Sas200622  * **************************** smb_request_t **********************************
8256432Sas200622  * *****************************************************************************
8266432Sas200622  */
8276432Sas200622 
8286432Sas200622 static const char *smb_request_state[SMB_REQ_STATE_SENTINEL] =
8296432Sas200622 {
8306432Sas200622 	"FREE",
8316432Sas200622 	"INITIALIZING",
8326432Sas200622 	"SUBMITTED",
8336432Sas200622 	"ACTIVE",
8346432Sas200622 	"WAITING_EVENT",
8356432Sas200622 	"EVENT_OCCURRED",
8366432Sas200622 	"WAITING_LOCK",
8376432Sas200622 	"COMPLETED",
8386432Sas200622 	"CANCELED",
8396432Sas200622 	"CLEANED_UP"
8406432Sas200622 };
8416432Sas200622 
8426432Sas200622 static int
8436432Sas200622 smb_dcmd_request(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
8446432Sas200622 {
8456432Sas200622 	uint_t		opts;
8466432Sas200622 
8476432Sas200622 	if (smb_dcmd_getopt(&opts, argc, argv))
8486432Sas200622 		return (DCMD_USAGE);
8496432Sas200622 
8506432Sas200622 	if (!(flags & DCMD_ADDRSPEC)) {
8516432Sas200622 		opts |= SMB_OPT_REQUEST;
8526432Sas200622 		opts &= ~(SMB_OPT_SERVER | SMB_OPT_SESSION | SMB_OPT_USER);
8536432Sas200622 		return (smb_obj_list("smb_request", opts, flags));
8546432Sas200622 	}
8556432Sas200622 
8566432Sas200622 	if (((opts & SMB_OPT_WALK) && (opts & SMB_OPT_REQUEST)) ||
8576432Sas200622 	    !(opts & SMB_OPT_WALK)) {
8586432Sas200622 		smb_request_t	*sr;
8596432Sas200622 		const char	*state;
8606432Sas200622 
8616432Sas200622 		sr = mdb_alloc(sizeof (*sr), UM_SLEEP | UM_GC);
8626432Sas200622 		if (mdb_vread(sr, sizeof (*sr), addr) == -1) {
8636432Sas200622 			mdb_warn("failed to read smb_request at %p", addr);
8646432Sas200622 			return (DCMD_ERR);
8656432Sas200622 		}
8666432Sas200622 
8676432Sas200622 		if (sr->sr_state >= SMB_REQ_STATE_SENTINEL)
8686432Sas200622 			state = "INVALID";
8696432Sas200622 		else
8706432Sas200622 			state = smb_request_state[sr->sr_state];
8716432Sas200622 
8726432Sas200622 		if (opts & SMB_OPT_VERBOSE) {
8736432Sas200622 			mdb_printf(
8746432Sas200622 			    "%<b>%<u>SMB request information (%p):"
8756432Sas200622 			    "%</u>%</b>\n\n", addr);
8766432Sas200622 			mdb_printf("First SMB COM: %u (%s)\n",
8776432Sas200622 			    sr->first_smb_com,
8786432Sas200622 			    smb_com[sr->first_smb_com]);
8796432Sas200622 			mdb_printf("State: %u (%s)\n", sr->sr_state, state);
8806432Sas200622 			mdb_printf("Tree: %u (%p)\n", sr->smb_tid,
8816432Sas200622 			    sr->tid_tree);
8826432Sas200622 			mdb_printf("User: %u (%p)\n", sr->smb_uid,
8836432Sas200622 			    sr->uid_user);
8846432Sas200622 			mdb_printf("File: %u (%p)\n",
8856432Sas200622 			    sr->smb_fid, sr->fid_ofile);
8866432Sas200622 			mdb_printf("Dir.: %u (%p)\n", sr->smb_sid,
8876432Sas200622 			    sr->sid_odir);
8886432Sas200622 			mdb_printf("PID: %u\n", sr->smb_pid);
8896432Sas200622 			mdb_printf("MID: %u\n\n", sr->smb_mid);
8906432Sas200622 		} else {
8916432Sas200622 			if (DCMD_HDRSPEC(flags))
8926432Sas200622 				mdb_printf(
8936432Sas200622 				    "%<b>%<u>"
8946432Sas200622 				    "%-?s "
8956432Sas200622 				    "%s%</u>%</b>\n"
8966432Sas200622 				    "ADDR", "COM");
8976432Sas200622 
8986432Sas200622 			mdb_printf("%-?p %s\n", addr, state,
8996432Sas200622 			    smb_com[sr->first_smb_com]);
9006432Sas200622 		}
9016432Sas200622 	}
9026432Sas200622 	return (DCMD_OK);
9036432Sas200622 }
9046432Sas200622 
9056432Sas200622 /*
9066432Sas200622  * *****************************************************************************
9076432Sas200622  * ****************************** smb_user_t ***********************************
9086432Sas200622  * *****************************************************************************
9096432Sas200622  */
9106432Sas200622 
9116432Sas200622 static const char *smb_user_state[SMB_USER_STATE_SENTINEL] =
9126432Sas200622 {
9136432Sas200622 	"LOGGED_IN",
9146432Sas200622 	"LOGGING_OFF",
9156432Sas200622 	"LOGGED_OFF"
9166432Sas200622 };
9176432Sas200622 
9186432Sas200622 /*
9196432Sas200622  * List of objects that can be expanded under a user structure.
9206432Sas200622  */
9216432Sas200622 static const smb_exp_t smb_user_exp[] =
9226432Sas200622 {
9236432Sas200622 	{ SMB_OPT_TREE | SMB_OPT_OFILE | SMB_OPT_ODIR,
9246432Sas200622 	    offsetof(smb_user_t, u_tree_list.ll_list),
9256432Sas200622 	    "smbtree", "smb_tree"},
9266432Sas200622 	{ 0, 0, NULL, NULL}
9276432Sas200622 };
9286432Sas200622 
9296432Sas200622 static void
9306432Sas200622 smb_dcmd_user_help(void)
9316432Sas200622 {
9326432Sas200622 	mdb_printf(
9336432Sas200622 	    "Display the contents of smb_user_t, with optional filtering.\n\n");
9346432Sas200622 	(void) mdb_dec_indent(2);
9356432Sas200622 	mdb_printf("%<b>OPTIONS%</b>\n");
9366432Sas200622 	(void) mdb_inc_indent(2);
9376432Sas200622 	mdb_printf(
9386432Sas200622 	    "-v\tDisplay verbose smb_user information\n"
9396432Sas200622 	    "-d\tDisplay the list of smb_odirs attached\n"
9406432Sas200622 	    "-f\tDisplay the list of smb_ofiles attached\n"
9416432Sas200622 	    "-t\tDisplay the list of smb_trees attached\n");
9425331Samw }
9435331Samw 
9445331Samw static int
9456432Sas200622 smb_dcmd_user(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
9465331Samw {
9476432Sas200622 	uint_t		opts;
9486432Sas200622 	ulong_t		indent = 0;
9496432Sas200622 
9506432Sas200622 	if (smb_dcmd_getopt(&opts, argc, argv))
9516432Sas200622 		return (DCMD_USAGE);
9526432Sas200622 
9536432Sas200622 	if (!(flags & DCMD_ADDRSPEC)) {
9546432Sas200622 		opts |= SMB_OPT_USER;
9556432Sas200622 		opts &= ~(SMB_OPT_SERVER | SMB_OPT_SESSION | SMB_OPT_REQUEST);
9566432Sas200622 		return (smb_obj_list("smb_user", opts, flags));
9576432Sas200622 	}
9586432Sas200622 
9596432Sas200622 	if (((opts & SMB_OPT_WALK) && (opts & SMB_OPT_USER)) ||
9606432Sas200622 	    !(opts & SMB_OPT_WALK)) {
9616432Sas200622 		smb_user_t	*user;
9626432Sas200622 		char		*account;
9636432Sas200622 
9646432Sas200622 		indent = SMB_DCMD_INDENT;
9656432Sas200622 
9666432Sas200622 		user = mdb_alloc(sizeof (*user), UM_SLEEP | UM_GC);
9676432Sas200622 		if (mdb_vread(user, sizeof (*user), addr) == -1) {
9686432Sas200622 			mdb_warn("failed to read smb_user at %p", addr);
9696432Sas200622 			return (DCMD_ERR);
9706432Sas200622 		}
9716432Sas200622 
9726432Sas200622 		account = mdb_zalloc(user->u_domain_len + user->u_name_len + 2,
9736432Sas200622 		    UM_SLEEP | UM_GC);
9746432Sas200622 
9756432Sas200622 		if (user->u_domain_len)
9766432Sas200622 			(void) mdb_vread(account, user->u_domain_len,
9776432Sas200622 			    (uintptr_t)user->u_domain);
9786432Sas200622 
9796432Sas200622 		strcat(account, "\\");
9806432Sas200622 
9816432Sas200622 		if (user->u_name_len)
9826432Sas200622 			(void) mdb_vread(account + strlen(account),
9836432Sas200622 			    user->u_name_len, (uintptr_t)user->u_name);
9846432Sas200622 
9856432Sas200622 		if (opts & SMB_OPT_VERBOSE) {
9866432Sas200622 			const char	*state;
9876432Sas200622 
9886432Sas200622 			if (user->u_state >= SMB_USER_STATE_SENTINEL)
9896432Sas200622 				state = "INVALID";
9906432Sas200622 			else
9916432Sas200622 				state = smb_user_state[user->u_state];
9926432Sas200622 
9936432Sas200622 			mdb_printf("%<b>%<u>SMB user information (%p):"
9946432Sas200622 			    "%</u>%</b>\n", addr);
9956432Sas200622 			mdb_printf("UID: %u\n", user->u_uid);
9966432Sas200622 			mdb_printf("State: %d (%s)\n", user->u_state, state);
9976432Sas200622 			mdb_printf("Flags: 0x%08x\n", user->u_flags);
9986432Sas200622 			mdb_printf("Privileges: 0x%08x\n", user->u_privileges);
9996432Sas200622 			mdb_printf("Credential: %p\n", user->u_cred);
10006432Sas200622 			mdb_printf("Reference Count: %d\n", user->u_refcnt);
10016432Sas200622 			mdb_printf("User Account: %s\n\n", account);
10026432Sas200622 		} else {
10036432Sas200622 			if (DCMD_HDRSPEC(flags))
10046432Sas200622 				mdb_printf(
10056432Sas200622 				    "%<b>%<u>%?-s "
10066432Sas200622 				    "%-5s "
10076432Sas200622 				    "%-32s%</u>%</b>\n",
10086432Sas200622 				    "USER", "UID", "ACCOUNT");
10096432Sas200622 
10106432Sas200622 			mdb_printf("%-?p %-5u %-32s\n", addr, user->u_uid,
10116432Sas200622 			    account);
10126432Sas200622 		}
10136432Sas200622 	}
10146432Sas200622 	if (smb_obj_expand(addr, opts, smb_user_exp, indent))
10156432Sas200622 		return (DCMD_ERR);
10166432Sas200622 	return (DCMD_OK);
10175331Samw }
10185331Samw 
10195331Samw /*
10206432Sas200622  * *****************************************************************************
10216432Sas200622  * ****************************** smb_tree_t ***********************************
10226432Sas200622  * *****************************************************************************
10235331Samw  */
10246432Sas200622 
10256432Sas200622 static const char *smb_tree_state[SMB_TREE_STATE_SENTINEL] =
10266432Sas200622 {
10276432Sas200622 	"CONNECTED",
10286432Sas200622 	"DISCONNECTING",
10296432Sas200622 	"DISCONNECTED"
10306432Sas200622 };
10316432Sas200622 
10326432Sas200622 /*
10336432Sas200622  * List of objects that can be expanded under a tree structure.
10346432Sas200622  */
10356432Sas200622 static const smb_exp_t smb_tree_exp[] =
10365331Samw {
10376432Sas200622 	{ SMB_OPT_OFILE,
10386432Sas200622 	    offsetof(smb_tree_t, t_ofile_list.ll_list),
10396432Sas200622 	    "smbofile", "smb_ofile"},
10406432Sas200622 	{ SMB_OPT_ODIR,
10416432Sas200622 	    offsetof(smb_tree_t, t_odir_list.ll_list),
10426432Sas200622 	    "smbodir", "smb_odir"},
10436432Sas200622 	{ 0, 0, NULL, NULL}
10446432Sas200622 };
10455331Samw 
10466432Sas200622 static void
10476432Sas200622 smb_dcmd_tree_help(void)
10486432Sas200622 {
10496432Sas200622 	mdb_printf(
10506432Sas200622 	    "Display the contents of smb_tree_t, with optional filtering.\n\n");
10516432Sas200622 	(void) mdb_dec_indent(2);
10526432Sas200622 	mdb_printf("%<b>OPTIONS%</b>\n");
10536432Sas200622 	(void) mdb_inc_indent(2);
10546432Sas200622 	mdb_printf(
10556432Sas200622 	    "-v\tDisplay verbose smb_tree information\n"
10566432Sas200622 	    "-d\tDisplay the list of smb_odirs attached\n"
10576432Sas200622 	    "-f\tDisplay the list of smb_ofiles attached\n");
10586432Sas200622 }
10596432Sas200622 
10606432Sas200622 static int
10616432Sas200622 smb_dcmd_tree(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
10626432Sas200622 {
10636432Sas200622 	uint_t		opts;
10646432Sas200622 	ulong_t		indent = 0;
10656432Sas200622 
10666432Sas200622 	if (smb_dcmd_getopt(&opts, argc, argv))
10675331Samw 		return (DCMD_USAGE);
10685331Samw 
10696432Sas200622 	if (!(flags & DCMD_ADDRSPEC)) {
10706432Sas200622 		opts |= SMB_OPT_TREE;
10716432Sas200622 		opts &= ~(SMB_OPT_SERVER | SMB_OPT_SESSION | SMB_OPT_REQUEST |
10726432Sas200622 		    SMB_OPT_USER);
10736432Sas200622 		return (smb_obj_list("smb_tree", opts, flags));
10746139Sjb150015 	}
10755331Samw 
10766432Sas200622 	if (((opts & SMB_OPT_WALK) && (opts & SMB_OPT_TREE)) ||
10776432Sas200622 	    !(opts & SMB_OPT_WALK)) {
10786432Sas200622 		smb_tree_t	*tree;
10796432Sas200622 
10806432Sas200622 		indent = SMB_DCMD_INDENT;
10816139Sjb150015 
10826432Sas200622 		tree = mdb_alloc(sizeof (*tree), UM_SLEEP | UM_GC);
10836432Sas200622 		if (mdb_vread(tree, sizeof (*tree), addr) == -1) {
10846432Sas200622 			mdb_warn("failed to read smb_tree at %p", addr);
10856432Sas200622 			return (DCMD_ERR);
10866432Sas200622 		}
10876139Sjb150015 
10886432Sas200622 		if (opts & SMB_OPT_VERBOSE) {
10896432Sas200622 			const char	*state;
10906432Sas200622 
10916432Sas200622 			if (tree->t_state >= SMB_TREE_STATE_SENTINEL)
10926432Sas200622 				state = "INVALID";
10936432Sas200622 			else
10946432Sas200622 				state = smb_tree_state[tree->t_state];
10955331Samw 
10966432Sas200622 			mdb_printf("%<b>%<u>SMB tree information (%p):"
10976432Sas200622 			    "%</u>%</b>\n\n", addr);
10986432Sas200622 			mdb_printf("TID: %04x\n", tree->t_tid);
10996432Sas200622 			mdb_printf("State: %d (%s)\n", tree->t_state, state);
1100*7348SJose.Borrego@Sun.COM 			mdb_printf("Share: %s\n", tree->t_sharename);
11016432Sas200622 			mdb_printf("Resource: %s\n", tree->t_resource);
1102*7348SJose.Borrego@Sun.COM 			mdb_printf("Type: %s\n", tree->t_typename);
1103*7348SJose.Borrego@Sun.COM 			mdb_printf("Volume: %s\n", tree->t_volume);
11046432Sas200622 			mdb_printf("Umask: %04x\n", tree->t_umask);
11056432Sas200622 			mdb_printf("Flags: %08x\n", tree->t_flags);
11066432Sas200622 			mdb_printf("SMB Node: %llx\n", tree->t_snode);
11076432Sas200622 			mdb_printf("Reference Count: %d\n\n", tree->t_refcnt);
11086432Sas200622 		} else {
11096432Sas200622 			if (DCMD_HDRSPEC(flags))
11106432Sas200622 				mdb_printf(
11116432Sas200622 				    "%<b>%<u>%-?s %-5s %-16s %-32s%</u>%</b>\n",
11126432Sas200622 				    "TREE", "TID", "SHARE NAME", "RESOURCE");
11136432Sas200622 
11146432Sas200622 			mdb_printf("%-?p %-5u %-16s %-32s\n", addr,
11156432Sas200622 			    tree->t_tid, tree->t_sharename, tree->t_resource);
11166432Sas200622 		}
11175331Samw 	}
11186432Sas200622 	if (smb_obj_expand(addr, opts, smb_tree_exp, indent))
11196432Sas200622 		return (DCMD_ERR);
11205331Samw 	return (DCMD_OK);
11215331Samw }
11225331Samw 
11236432Sas200622 /*
11246432Sas200622  * *****************************************************************************
11256432Sas200622  * ****************************** smb_odir_t ***********************************
11266432Sas200622  * *****************************************************************************
11276432Sas200622  */
11286432Sas200622 
11296432Sas200622 static const char *smb_odir_state[SMB_ODIR_STATE_SENTINEL] =
11305331Samw {
11316432Sas200622 	"OPEN",
11326432Sas200622 	"CLOSING",
11336432Sas200622 	"CLOSED"
11346432Sas200622 };
11355331Samw 
11366432Sas200622 static int
11376432Sas200622 smb_dcmd_odir(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
11386432Sas200622 {
11396432Sas200622 	uint_t		opts;
11406432Sas200622 
11416432Sas200622 	if (smb_dcmd_getopt(&opts, argc, argv))
11426432Sas200622 		return (DCMD_USAGE);
11436432Sas200622 
11446432Sas200622 	if (!(flags & DCMD_ADDRSPEC)) {
11456432Sas200622 		opts |= SMB_OPT_ODIR;
11466432Sas200622 		opts &= ~(SMB_OPT_SERVER | SMB_OPT_SESSION | SMB_OPT_REQUEST |
11476432Sas200622 		    SMB_OPT_USER | SMB_OPT_TREE | SMB_OPT_OFILE);
11486432Sas200622 		return (smb_obj_list("smb_odir", opts, flags));
11495331Samw 	}
11505331Samw 
11516432Sas200622 	if (((opts & SMB_OPT_WALK) && (opts & SMB_OPT_ODIR)) ||
11526432Sas200622 	    !(opts & SMB_OPT_WALK)) {
11536432Sas200622 		smb_odir_t	*od;
11546432Sas200622 
11556432Sas200622 		od = mdb_alloc(sizeof (*od), UM_SLEEP | UM_GC);
11566432Sas200622 		if (mdb_vread(od, sizeof (*od), addr) == -1) {
11576432Sas200622 			mdb_warn("failed to read smb_odir at %p", addr);
11586432Sas200622 			return (DCMD_ERR);
11596432Sas200622 		}
11606432Sas200622 
11616432Sas200622 		if (opts & SMB_OPT_VERBOSE) {
11626432Sas200622 			const char	*state;
11636432Sas200622 
11646432Sas200622 			if (od->d_state >= SMB_ODIR_STATE_SENTINEL)
11656432Sas200622 				state = "INVALID";
11666432Sas200622 			else
11676432Sas200622 				state = smb_odir_state[od->d_state];
11686432Sas200622 
11696432Sas200622 			mdb_printf(
11706432Sas200622 			    "%<b>%<u>SMB odir information (%p):%</u>%</b>\n\n",
11716432Sas200622 			    addr);
11726432Sas200622 			mdb_printf("State: %d (%s)\n", od->d_state, state);
11736432Sas200622 			mdb_printf("SID: %u\n", od->d_sid);
11746432Sas200622 			mdb_printf("Reference Count: %d\n", od->d_refcnt);
11756432Sas200622 			mdb_printf("Pattern: %s\n", od->d_pattern);
11766432Sas200622 			mdb_printf("SMB Node: %p\n\n", od->d_dir_snode);
11776432Sas200622 		} else {
11786432Sas200622 			if (DCMD_HDRSPEC(flags))
11796432Sas200622 				mdb_printf(
11806432Sas200622 				    "%<u>%-?s "
11816432Sas200622 				    "%-5s "
11826432Sas200622 				    "%-?s "
11836432Sas200622 				    "%-16s%</u>\n",
11846432Sas200622 				    "ODIR", "SID", "VNODE", "PATTERN");
11856432Sas200622 
11866432Sas200622 			mdb_printf("%?p %-5u %-16s %s\n",
11876432Sas200622 			    addr, od->d_sid, od->d_dir_snode, od->d_pattern);
11885331Samw 		}
11895331Samw 	}
11906432Sas200622 	return (DCMD_OK);
11915331Samw }
11925331Samw 
11936432Sas200622 /*
11946432Sas200622  * *****************************************************************************
11956432Sas200622  * ****************************** smb_ofile_t **********************************
11966432Sas200622  * *****************************************************************************
11976432Sas200622  */
11986432Sas200622 
11996432Sas200622 static const char *smb_ofile_state[SMB_OFILE_STATE_SENTINEL] =
12006432Sas200622 {
12016432Sas200622 	"OPEN",
12026432Sas200622 	"CLOSING",
12036432Sas200622 	"CLOSED"
12046432Sas200622 };
12056432Sas200622 
12066432Sas200622 static int
12076432Sas200622 smb_dcmd_ofile(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
12086432Sas200622 {
12096432Sas200622 	uint_t		opts;
12106432Sas200622 
12116432Sas200622 	if (smb_dcmd_getopt(&opts, argc, argv))
12126432Sas200622 		return (DCMD_USAGE);
12136432Sas200622 
12146432Sas200622 	if (!(flags & DCMD_ADDRSPEC)) {
12156432Sas200622 		opts |= SMB_OPT_OFILE;
12166432Sas200622 		opts &= ~(SMB_OPT_SERVER | SMB_OPT_SESSION | SMB_OPT_REQUEST |
12176432Sas200622 		    SMB_OPT_USER | SMB_OPT_TREE | SMB_OPT_ODIR);
12186432Sas200622 		return (smb_obj_list("smb_ofile", opts, flags));
12196432Sas200622 	}
12206432Sas200622 
12216432Sas200622 	if (((opts & SMB_OPT_WALK) && (opts & SMB_OPT_OFILE)) ||
12226432Sas200622 	    !(opts & SMB_OPT_WALK)) {
12236432Sas200622 		smb_ofile_t	*of;
12246432Sas200622 
12256432Sas200622 		of = mdb_alloc(sizeof (*of), UM_SLEEP | UM_GC);
12266432Sas200622 		if (mdb_vread(of, sizeof (*of), addr) == -1) {
12276432Sas200622 			mdb_warn("failed to read smb_ofile at %p", addr);
12286432Sas200622 			return (DCMD_ERR);
12296432Sas200622 		}
12306432Sas200622 
12316432Sas200622 		if (opts & SMB_OPT_VERBOSE) {
12326432Sas200622 			const char	*state;
12336432Sas200622 
12346432Sas200622 			if (of->f_state >= SMB_ODIR_STATE_SENTINEL)
12356432Sas200622 				state = "INVALID";
12366432Sas200622 			else
12376432Sas200622 				state = smb_ofile_state[of->f_state];
12386432Sas200622 
12396432Sas200622 			mdb_printf(
12406432Sas200622 			    "%<b>%<u>SMB ofile information (%p):%</u>%</b>\n\n",
12416432Sas200622 			    addr);
12426432Sas200622 			mdb_printf("FID: %u\n", of->f_fid);
12436432Sas200622 			mdb_printf("State: %d (%s)\n", of->f_state, state);
12446432Sas200622 			mdb_printf("SMB Node: %p\n", of->f_node);
12456432Sas200622 			mdb_printf("LLF Offset: 0x%llx (%s)\n",
12466432Sas200622 			    of->f_llf_pos,
12476432Sas200622 			    ((of->f_flags & SMB_OFLAGS_LLF_POS_VALID) ?
12486432Sas200622 			    "Valid" : "Invalid"));
12496432Sas200622 			mdb_printf("Flags: 0x%08x\n", of->f_flags);
12506432Sas200622 			mdb_printf("Credential: %p\n\n", of->f_cr);
12516432Sas200622 		} else {
12526432Sas200622 			if (DCMD_HDRSPEC(flags))
12536432Sas200622 				mdb_printf(
12546432Sas200622 				    "%<b>%<u>%-?s "
12556432Sas200622 				    "%-5s "
12566432Sas200622 				    "%-?s "
12576432Sas200622 				    "%-?s%</u>%</b>\n",
12586432Sas200622 				    "OFILE", "FID", "SMB NODE", "CRED");
12596432Sas200622 
12606432Sas200622 			mdb_printf("%?p %-5u %-p %p\n", addr,
12616432Sas200622 			    of->f_fid, of->f_node, of->f_cr);
12626432Sas200622 		}
12636432Sas200622 	}
12646432Sas200622 	return (DCMD_OK);
12656432Sas200622 }
12666432Sas200622 
12676432Sas200622 /*
12686432Sas200622  * *****************************************************************************
12696432Sas200622  * ******************************* smb_node_t **********************************
12706432Sas200622  * *****************************************************************************
12716432Sas200622  */
12726432Sas200622 
12735331Samw static void
12745331Samw smb_node_help(void)
12755331Samw {
12765331Samw 	mdb_printf(
12775331Samw 	    "Display the contents of smb_node_t, with optional filtering.\n\n");
12786432Sas200622 	(void) mdb_dec_indent(2);
12795331Samw 	mdb_printf("%<b>OPTIONS%</b>\n");
12806432Sas200622 	(void) mdb_inc_indent(2);
12815331Samw 	mdb_printf(
12825331Samw 	    "-v\tDisplay verbose smb_node information\n"
12835331Samw 	    "-p\tDisplay the full path of the vnode associated\n"
12845331Samw 	    "-s\tDisplay the stack of the last 16 calls that modified the "
12855331Samw 	    "reference\n\tcount\n");
12865331Samw }
12875331Samw 
12885331Samw /*
12896432Sas200622  * ::smbnode
12905331Samw  *
12915331Samw  * smb_node dcmd - Print out smb_node structure.
12925331Samw  */
12935331Samw static int
12945331Samw smb_node(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
12955331Samw {
12965331Samw 	smb_node_t	node;
12975331Samw 	int		verbose = FALSE;
12985331Samw 	int		print_full_path = FALSE;
12995331Samw 	int		stack_trace = FALSE;
13005331Samw 	vnode_t		vnode;
13015331Samw 	char		od_name[MAXNAMELEN];
13025331Samw 	char		path_name[1024];
13035331Samw 	uintptr_t	list_addr;
13045331Samw 
13055331Samw 	if (mdb_getopts(argc, argv,
13065331Samw 	    'v', MDB_OPT_SETBITS, TRUE, &verbose,
13075331Samw 	    'p', MDB_OPT_SETBITS, TRUE, &print_full_path,
13085331Samw 	    's', MDB_OPT_SETBITS, TRUE, &stack_trace,
13095331Samw 	    NULL) != argc)
13105331Samw 		return (DCMD_USAGE);
13115331Samw 
13125331Samw 	/*
13135331Samw 	 * If no smb_node address was specified on the command line, we can
13145331Samw 	 * print out all smb nodes by invoking the smb_node walker, using
13155331Samw 	 * this dcmd itself as the callback.
13165331Samw 	 */
13175331Samw 	if (!(flags & DCMD_ADDRSPEC)) {
13186432Sas200622 		if (mdb_walk_dcmd("smbnode_walker", "smbnode",
13195331Samw 		    argc, argv) == -1) {
13205331Samw 			mdb_warn("failed to walk 'smb_node'");
13215331Samw 			return (DCMD_ERR);
13225331Samw 		}
13235331Samw 		return (DCMD_OK);
13245331Samw 	}
13255331Samw 
13265331Samw 	/*
13275331Samw 	 * If this is the first invocation of the command, print a nice
13285331Samw 	 * header line for the output that will follow.
13295331Samw 	 */
13305331Samw 	if (DCMD_HDRSPEC(flags)) {
13316432Sas200622 		if (verbose) {
13326432Sas200622 			mdb_printf("%<b>%<u>SMB node information:%</u>%</b>\n");
13336432Sas200622 		} else {
13346432Sas200622 			mdb_printf(
13356432Sas200622 			    "%<b>%<u>%-?s "
13366432Sas200622 			    "%-?s "
13376432Sas200622 			    "%-18s "
13386432Sas200622 			    "%-6s "
13396432Sas200622 			    "%-6s "
13406432Sas200622 			    "%-6s%</u>%</b>\n",
13416432Sas200622 			    "ADDR", "VP", "NODE-NAME", "OFILES", "LOCKS",
13426432Sas200622 			    "REF");
13436432Sas200622 		}
13445331Samw 	}
13455331Samw 
13465331Samw 	/*
13476432Sas200622 	 * For each smb_node, we just need to read the smb_node_t struct, read
13486432Sas200622 	 * and then print out the following fields.
13495331Samw 	 */
13505331Samw 	if (mdb_vread(&node, sizeof (node), addr) == sizeof (node)) {
13516432Sas200622 		(void) mdb_snprintf(od_name, sizeof (od_name), "%s",
13526432Sas200622 		    node.od_name);
13535331Samw 		if (print_full_path) {
13545331Samw 			if (mdb_vread(&vnode, sizeof (vnode_t),
13556432Sas200622 			    (uintptr_t)node.vp) == sizeof (vnode_t)) {
13566432Sas200622 				if (mdb_readstr(path_name, sizeof (path_name),
13575331Samw 				    (uintptr_t)vnode.v_path) != 0) {
13585331Samw 					(void) mdb_snprintf(od_name,
13596432Sas200622 					    sizeof (od_name), "N/A");
13605331Samw 				}
13615331Samw 			}
13625331Samw 		}
13635331Samw 		if (verbose) {
13646432Sas200622 			mdb_printf("VP: %p\n", node.vp);
13656432Sas200622 			mdb_printf("Name: %s\n", od_name);
13666432Sas200622 			if (print_full_path)
13676432Sas200622 				mdb_printf("V-node Path: %s\n", path_name);
13686432Sas200622 			mdb_printf("Ofiles: %u\n", node.n_ofile_list.ll_count);
13696432Sas200622 			mdb_printf("Range Locks: %u\n",
13705331Samw 			    node.n_lock_list.ll_count);
13715331Samw 			if (node.n_lock_list.ll_count != 0) {
13725331Samw 				(void) mdb_inc_indent(SMB_DCMD_INDENT);
13735331Samw 				list_addr = addr +
13745331Samw 				    offsetof(smb_node_t, n_lock_list) +
13755331Samw 				    offsetof(smb_llist_t, ll_list);
13766432Sas200622 				if (mdb_pwalk_dcmd("list", "smblock", 0,
13776432Sas200622 				    NULL, list_addr)) {
13785331Samw 					mdb_warn("failed to walk node's active"
13795331Samw 					    " locks");
13805331Samw 				}
13815331Samw 				(void) mdb_dec_indent(SMB_DCMD_INDENT);
13825331Samw 			}
13836432Sas200622 			mdb_printf("Reference Count: %u\n\n", node.n_refcnt);
13845331Samw 		} else {
13856432Sas200622 			mdb_printf("%-?p %-?p %-18s %-6d %-6d %-6d\n",
13865331Samw 			    addr, node.vp, od_name, node.n_ofile_list.ll_count,
13875331Samw 			    node.n_lock_list.ll_count, node.n_refcnt);
13886432Sas200622 			if (print_full_path)
13896432Sas200622 				mdb_printf("\t%s\n", path_name);
13905331Samw 		}
13915331Samw 		if (stack_trace && node.n_audit_buf) {
13925331Samw 			int ctr;
13935331Samw 			smb_audit_buf_node_t *anb;
13945331Samw 
13955331Samw 			anb = mdb_alloc(sizeof (smb_audit_buf_node_t),
13966432Sas200622 			    UM_SLEEP | UM_GC);
13975331Samw 
13985331Samw 			if (mdb_vread(anb, sizeof (*anb),
13995331Samw 			    (uintptr_t)node.n_audit_buf) != sizeof (*anb)) {
14005331Samw 				mdb_warn("failed to read audit buffer");
14015331Samw 				return (DCMD_ERR);
14025331Samw 			}
14035331Samw 			ctr = anb->anb_max_index + 1;
14045331Samw 			anb->anb_index--;
14055331Samw 			anb->anb_index &= anb->anb_max_index;
14065331Samw 
14075331Samw 			while (ctr) {
14085331Samw 				smb_audit_record_node_t	*anr;
14095331Samw 
14105331Samw 				anr = anb->anb_records + anb->anb_index;
14115331Samw 
14125331Samw 				if (anr->anr_depth) {
14135331Samw 					char c[MDB_SYM_NAMLEN];
14145331Samw 					GElf_Sym sym;
14155331Samw 					int i;
14165331Samw 
14175331Samw 					mdb_printf("\nRefCnt: %u\t",
14185331Samw 					    anr->anr_refcnt);
14195331Samw 
14205331Samw 					for (i = 0;
14215331Samw 					    i < anr->anr_depth;
14225331Samw 					    i++) {
14235331Samw 						if (mdb_lookup_by_addr(
14245331Samw 						    anr->anr_stack[i],
14255331Samw 						    MDB_SYM_FUZZY,
14265331Samw 						    c, sizeof (c),
14275331Samw 						    &sym) == -1) {
14285331Samw 							continue;
14295331Samw 						}
14305331Samw 						mdb_printf("%s+0x%1x",
14315331Samw 						    c,
14325331Samw 						    anr->anr_stack[i] -
14335331Samw 						    (uintptr_t)sym.st_value);
14345331Samw 						++i;
14355331Samw 						break;
14365331Samw 					}
14375331Samw 
14385331Samw 					while (i < anr->anr_depth) {
14395331Samw 						if (mdb_lookup_by_addr(
14405331Samw 						    anr->anr_stack[i],
14415331Samw 						    MDB_SYM_FUZZY,
14425331Samw 						    c, sizeof (c),
14435331Samw 						    &sym) == -1) {
14445331Samw 							++i;
14455331Samw 							continue;
14465331Samw 						}
14475331Samw 						mdb_printf("\n\t\t%s+0x%1x",
14485331Samw 						    c,
14495331Samw 						    anr->anr_stack[i] -
14505331Samw 						    (uintptr_t)sym.st_value);
14515331Samw 						++i;
14525331Samw 					}
14535331Samw 					mdb_printf("\n");
14545331Samw 				}
14555331Samw 				anb->anb_index--;
14565331Samw 				anb->anb_index &= anb->anb_max_index;
14575331Samw 				ctr--;
14585331Samw 			}
14595331Samw 		}
14605331Samw 	} else {
14615331Samw 		mdb_warn("failed to read struct smb_node at %p", addr);
14625331Samw 		return (DCMD_ERR);
14635331Samw 	}
14645331Samw 
14655331Samw 	return (DCMD_OK);
14665331Samw }
14675331Samw 
14686432Sas200622 /*
14696432Sas200622  * Initialize the smb_node_t walker by reading the value of smb_node_hash_table
14706432Sas200622  * in the kernel's symbol table. Only global walk supported.
14716432Sas200622  */
14726432Sas200622 static int
14736432Sas200622 smb_node_walk_init(mdb_walk_state_t *wsp)
14745331Samw {
14756432Sas200622 	GElf_Sym	sym;
14766432Sas200622 	int		i;
14776432Sas200622 	uintptr_t	node_hash_table_addr;
14786432Sas200622 
14796432Sas200622 	if (wsp->walk_addr == NULL) {
14806432Sas200622 		if (mdb_lookup_by_name("smb_node_hash_table", &sym) == -1) {
14816432Sas200622 			mdb_warn("failed to find 'smb_node_hash_table'");
14826432Sas200622 			return (WALK_ERR);
14836432Sas200622 		}
14846432Sas200622 		node_hash_table_addr = (uintptr_t)sym.st_value;
14856432Sas200622 	} else {
14866432Sas200622 		mdb_printf("smb_node walk only supports global walks\n");
14876432Sas200622 		return (WALK_ERR);
14886432Sas200622 	}
14896432Sas200622 
14906432Sas200622 	for (i = 0; i < SMBND_HASH_MASK + 1; i++) {
14916432Sas200622 		wsp->walk_addr = node_hash_table_addr +
14926432Sas200622 		    (i * sizeof (smb_llist_t)) + offsetof(smb_llist_t, ll_list);
14936432Sas200622 		if (mdb_layered_walk("list", wsp) == -1) {
14946432Sas200622 			mdb_warn("failed to walk 'list'");
14956432Sas200622 			return (WALK_ERR);
14966432Sas200622 		}
14976432Sas200622 	}
14986432Sas200622 
14996432Sas200622 	return (WALK_NEXT);
15006432Sas200622 }
15016432Sas200622 
15026432Sas200622 static int
15036432Sas200622 smb_node_walk_step(mdb_walk_state_t *wsp)
15046432Sas200622 {
15056432Sas200622 	return (wsp->walk_callback(wsp->walk_addr, wsp->walk_layer,
15066432Sas200622 	    wsp->walk_cbdata));
15075331Samw }
15085331Samw 
15095331Samw /*
15106432Sas200622  * *****************************************************************************
15116432Sas200622  * ****************************** smb_lock_t ***********************************
15126432Sas200622  * *****************************************************************************
15135331Samw  */
15145331Samw 
15155331Samw static int
15165331Samw smb_lock(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
15175331Samw {
15185331Samw 	smb_lock_t	lock;
15195331Samw 	int		verbose = FALSE;
15205331Samw 	uintptr_t	list_addr;
15215331Samw 	char		*lock_type;
15225331Samw 
15235331Samw 	if (mdb_getopts(argc, argv,
15245331Samw 	    'v', MDB_OPT_SETBITS, TRUE, &verbose,
15255331Samw 	    NULL) != argc)
15265331Samw 		return (DCMD_USAGE);
15275331Samw 
15285331Samw 	/*
15295331Samw 	 * An smb_lock_t address must be specified.
15305331Samw 	 */
15315331Samw 	if (!(flags & DCMD_ADDRSPEC))
15325331Samw 		return (DCMD_USAGE);
15335331Samw 
15345331Samw 	/*
15355331Samw 	 * If this is the first invocation of the command, print a nice
15365331Samw 	 * header line for the output that will follow.
15375331Samw 	 */
15385331Samw 	if (DCMD_HDRSPEC(flags)) {
15395331Samw 		if (verbose)
15405331Samw 			mdb_printf("SMB lock information:\n\n");
15415331Samw 		else
15425331Samw 			mdb_printf("%<u>%-?s %4s %16s %8s %9s%</u>\n",
15435331Samw 			    "Locks: ", "TYPE", "START", "LENGTH",
15445331Samw 			    "CONFLICTS");
15455331Samw 	}
15465331Samw 
15475331Samw 	if (mdb_vread(&lock, sizeof (lock), addr) == sizeof (lock)) {
15485331Samw 		switch (lock.l_type) {
15495331Samw 		case SMB_LOCK_TYPE_READWRITE:
15505331Samw 			lock_type = "RW";
15515331Samw 			break;
15525331Samw 		case SMB_LOCK_TYPE_READONLY:
15535331Samw 			lock_type = "RO";
15545331Samw 			break;
15555331Samw 		default:
15565331Samw 			lock_type = "N/A";
15575331Samw 			break;
15585331Samw 		}
15595331Samw 		if (verbose) {
15605331Samw 			mdb_printf("Type             :\t%s (%u)\n",
15615331Samw 			    lock_type, lock.l_type);
15625331Samw 			mdb_printf("Start            :\t%llx\n",
15635331Samw 			    lock.l_start);
15645331Samw 			mdb_printf("Length           :\t%lx\n",
15655331Samw 			    lock.l_length);
15665331Samw 			mdb_printf("Session          :\t%p\n",
15675331Samw 			    lock.l_session);
15685331Samw 			mdb_printf("File             :\t%p\n",
15695331Samw 			    lock.l_file);
15705331Samw 			mdb_printf("User ID          :\t%u\n",
15715331Samw 			    lock.l_uid);
15725331Samw 			mdb_printf("Process ID       :\t%u\n",
15735331Samw 			    lock.l_pid);
15745331Samw 			mdb_printf("Conflicts        :\t%u\n",
15755331Samw 			    lock.l_conflict_list.sl_count);
15765331Samw 			if (lock.l_conflict_list.sl_count != 0) {
15775331Samw 				(void) mdb_inc_indent(SMB_DCMD_INDENT);
15785331Samw 				list_addr = addr +
15795331Samw 				    offsetof(smb_lock_t, l_conflict_list) +
15805331Samw 				    offsetof(smb_slist_t, sl_list);
15815331Samw 				if (mdb_pwalk_dcmd("list", "smb_lock",
15825331Samw 				    0, NULL, list_addr)) {
15835331Samw 					mdb_warn("failed to walk conflict "
15845331Samw 					    "locks ");
15855331Samw 				}
15865331Samw 				(void) mdb_dec_indent(SMB_DCMD_INDENT);
15875331Samw 			}
15885331Samw 			mdb_printf("Blocked by       :\t%p\n",
15895331Samw 			    lock.l_blocked_by);
15905331Samw 			mdb_printf("Flags            :\t0x%x\n",
15915331Samw 			    lock.l_flags);
15925331Samw 			mdb_printf("\n");
15935331Samw 		} else {
15945331Samw 			mdb_printf("%?p %4s %16llx %08lx %9x", addr,
15955331Samw 			    lock_type, lock.l_start, lock.l_length,
15965331Samw 			    lock.l_conflict_list.sl_count);
15975331Samw 		}
15985331Samw 	} else {
15995331Samw 		mdb_warn("failed to read struct smb_request at %p", addr);
16005331Samw 		return (DCMD_ERR);
16015331Samw 	}
16025331Samw 
16035331Samw 	return (DCMD_OK);
16045331Samw }
16055331Samw 
16065331Samw /*
16075331Samw  * ::smb_dispatch_stats
16085331Samw  *
16095331Samw  * smb_dispatch_stats dcmd - Prints all dispatched SMB requests statistics.
16105331Samw  */
16115331Samw /*ARGSUSED*/
16125331Samw static int
16136432Sas200622 smb_stats(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
16145331Samw {
16155331Samw 	smb_dispatch_table_t	*disp;
16165331Samw 	GElf_Sym		sym;
16175331Samw 	int			nstats = 0, i;
16185331Samw 
16195331Samw 	if ((flags & DCMD_ADDRSPEC) || argc != 0)
16205331Samw 		return (DCMD_USAGE);
16215331Samw 
16225331Samw 	if (mdb_lookup_by_obj(MDB_OBJ_EVERY, "dispatch", &sym)) {
16235331Samw 		mdb_warn("failed to find dispatch object");
16245331Samw 		return (DCMD_ERR);
16255331Samw 	}
16265331Samw 
16275331Samw 	disp = mdb_alloc(sym.st_size, UM_SLEEP | UM_GC);
16285331Samw 	if (mdb_vread(disp, sym.st_size, sym.st_value) == -1) {
16295331Samw 		mdb_warn("failed to read from dispatch object");
16305331Samw 		return (DCMD_ERR);
16315331Samw 	}
16325331Samw 
16335331Samw 	nstats = sym.st_size / sizeof (smb_dispatch_table_t);
16345331Samw 
16355331Samw 	mdb_printf("All dispatched SMB requests statistics:\n\n");
16365331Samw 	for (i = 0; i < nstats; i++) {
16375331Samw 		if (disp[i].sdt_function)
16385331Samw 			mdb_printf("    %40s\t: %lld\n",
16395331Samw 			    disp[i].sdt_dispatch_stats.name,
16405331Samw 			    disp[i].sdt_dispatch_stats.value.ui64);
16415331Samw 	}
16425331Samw 	return (DCMD_OK);
16435331Samw }
16445331Samw 
16455331Samw /*
16466432Sas200622  * *****************************************************************************
16476432Sas200622  * ******************************** smb_ace_t **********************************
16486432Sas200622  * *****************************************************************************
16495331Samw  */
16506432Sas200622 static const ace_type_entry_t	ace_types[ACE_TYPE_TABLEN] =
16516432Sas200622 {
16526432Sas200622 	ACE_TYPE_ENTRY(ACE_ACCESS_ALLOWED_ACE_TYPE),
16536432Sas200622 	ACE_TYPE_ENTRY(ACE_ACCESS_DENIED_ACE_TYPE),
16546432Sas200622 	ACE_TYPE_ENTRY(ACE_SYSTEM_AUDIT_ACE_TYPE),
16556432Sas200622 	ACE_TYPE_ENTRY(ACE_SYSTEM_ALARM_ACE_TYPE),
16566432Sas200622 	ACE_TYPE_ENTRY(ACE_ACCESS_ALLOWED_COMPOUND_ACE_TYPE),
16576432Sas200622 	ACE_TYPE_ENTRY(ACE_ACCESS_ALLOWED_OBJECT_ACE_TYPE),
16586432Sas200622 	ACE_TYPE_ENTRY(ACE_ACCESS_DENIED_OBJECT_ACE_TYPE),
16596432Sas200622 	ACE_TYPE_ENTRY(ACE_SYSTEM_AUDIT_OBJECT_ACE_TYPE),
16606432Sas200622 	ACE_TYPE_ENTRY(ACE_SYSTEM_ALARM_OBJECT_ACE_TYPE),
16616432Sas200622 	ACE_TYPE_ENTRY(ACE_ACCESS_ALLOWED_CALLBACK_ACE_TYPE),
16626432Sas200622 	ACE_TYPE_ENTRY(ACE_ACCESS_DENIED_CALLBACK_ACE_TYPE),
16636432Sas200622 	ACE_TYPE_ENTRY(ACE_ACCESS_ALLOWED_CALLBACK_OBJECT_ACE_TYPE),
16646432Sas200622 	ACE_TYPE_ENTRY(ACE_ACCESS_DENIED_CALLBACK_OBJECT_ACE_TYPE),
16656432Sas200622 	ACE_TYPE_ENTRY(ACE_SYSTEM_AUDIT_CALLBACK_ACE_TYPE),
16666432Sas200622 	ACE_TYPE_ENTRY(ACE_SYSTEM_ALARM_CALLBACK_ACE_TYPE),
16676432Sas200622 	ACE_TYPE_ENTRY(ACE_SYSTEM_AUDIT_CALLBACK_OBJECT_ACE_TYPE),
16686432Sas200622 	ACE_TYPE_ENTRY(ACE_SYSTEM_ALARM_CALLBACK_OBJECT_ACE_TYPE),
16696432Sas200622 	ACE_TYPE_ENTRY(0x11),
16706432Sas200622 	ACE_TYPE_ENTRY(0x12),
16716432Sas200622 	ACE_TYPE_ENTRY(0x13),
16726432Sas200622 	ACE_TYPE_ENTRY(0x14),
16736432Sas200622 	ACE_TYPE_ENTRY(0x15),
16746432Sas200622 	ACE_TYPE_ENTRY(0x16),
16756432Sas200622 	ACE_TYPE_ENTRY(0x17),
16766432Sas200622 	ACE_TYPE_ENTRY(0x18),
16776432Sas200622 	ACE_TYPE_ENTRY(0x19),
16786432Sas200622 	ACE_TYPE_ENTRY(0x1A),
16796432Sas200622 	ACE_TYPE_ENTRY(0x1B),
16806432Sas200622 	ACE_TYPE_ENTRY(0x1C),
16816432Sas200622 	ACE_TYPE_ENTRY(0x1D),
16826432Sas200622 	ACE_TYPE_ENTRY(0x1E),
16836432Sas200622 	ACE_TYPE_ENTRY(0x1F)
16846432Sas200622 };
16856432Sas200622 
16866432Sas200622 static const mdb_bitmask_t ace_flag_bits[] = {
16876432Sas200622 	{ "OBJECT_INHERIT_ACE", OBJECT_INHERIT_ACE, OBJECT_INHERIT_ACE },
16886432Sas200622 	{ "CONTAINER_INHERIT_ACE", CONTAINER_INHERIT_ACE,
16896432Sas200622 	    CONTAINER_INHERIT_ACE },
16906432Sas200622 	{ "NO_PROPOGATE_INHERIT_ACE", NO_PROPOGATE_INHERIT_ACE,
16916432Sas200622 	    NO_PROPOGATE_INHERIT_ACE },
16926432Sas200622 	{ "INHERIT_ONLY_ACE", INHERIT_ONLY_ACE, INHERIT_ONLY_ACE },
16936432Sas200622 	{ "INHERITED_ACE", INHERITED_ACE, INHERITED_ACE },
16946432Sas200622 	{ "SUCCESSFUL_ACCESS_ACE_FLAG", SUCCESSFUL_ACCESS_ACE_FLAG,
16956432Sas200622 	    SUCCESSFUL_ACCESS_ACE_FLAG },
16966432Sas200622 	{ "FAILED_ACCESS_ACE_FLAG", FAILED_ACCESS_ACE_FLAG,
16976432Sas200622 	    FAILED_ACCESS_ACE_FLAG },
16986432Sas200622 	{ NULL, 0, 0 }
16995331Samw };
17005331Samw 
17016432Sas200622 /*
17026432Sas200622  * ::smbace
17036432Sas200622  */
17046432Sas200622 static int
17056432Sas200622 smb_ace(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
17066432Sas200622 {
17076432Sas200622 	smb_ace_t	ace;
17086432Sas200622 	int		verbose = FALSE;
17096432Sas200622 	const char	*ptr;
17106432Sas200622 	int		rc;
17116432Sas200622 
17126432Sas200622 	if (mdb_getopts(argc, argv, 'v', MDB_OPT_SETBITS, TRUE, &verbose,
17136432Sas200622 	    NULL) != argc)
17146432Sas200622 		return (DCMD_USAGE);
17156432Sas200622 
17166432Sas200622 	/*
17176432Sas200622 	 * An smb_ace address is required.
17186432Sas200622 	 */
17196432Sas200622 	if (!(flags & DCMD_ADDRSPEC))
17206432Sas200622 		return (DCMD_USAGE);
17216432Sas200622 
17226432Sas200622 	if (mdb_vread(&ace, sizeof (ace), addr) != sizeof (ace)) {
17236432Sas200622 		mdb_warn("failed to read struct smb_ace at %p", addr);
17246432Sas200622 		return (DCMD_ERR);
17256432Sas200622 	}
17266432Sas200622 
17276432Sas200622 	if (verbose) {
17286432Sas200622 		if (ace.se_hdr.se_type < ACE_TYPE_TABLEN)
17296432Sas200622 			ptr = ace_types[ace.se_hdr.se_type].ace_type_sting;
17306432Sas200622 		else
17316432Sas200622 			ptr = "Unknown";
17326432Sas200622 
17336432Sas200622 		mdb_printf("ACE Type: 0x%02x (%s)\n", ace.se_hdr.se_type, ptr);
17346432Sas200622 		mdb_printf("ACE Flags: %b\n", (int)ace.se_hdr.se_flags,
17356432Sas200622 		    ace_flag_bits);
17366432Sas200622 		mdb_printf("ACE Wire Size: 0x%04x\n", ace.se_hdr.se_bsize);
17376432Sas200622 		mdb_printf("ACE Mask: 0x%08x\n", ace.se_mask);
17386432Sas200622 		mdb_printf("ACE SID: ");
17396432Sas200622 	} else {
17406432Sas200622 		if (DCMD_HDRSPEC(flags))
17416432Sas200622 			mdb_printf(
17426432Sas200622 			    "%<b>%<u>%?-s %-4s %-4s %-8s %s%</u>%</b>\n",
17436432Sas200622 			    "ACE", "TYPE", "FLAGS", "MASK", "SID");
17446432Sas200622 		mdb_printf("%?p 0x%02x 0x%02x 0x%08x ", addr,
17456432Sas200622 		    ace.se_hdr.se_type, ace.se_hdr.se_flags, ace.se_mask);
17466432Sas200622 	}
17476432Sas200622 	rc = smb_sid_print((uintptr_t)ace.se_sid);
17486432Sas200622 	mdb_printf("\n");
17496432Sas200622 	return (rc);
17506432Sas200622 }
17516432Sas200622 
17526432Sas200622 static int
17536432Sas200622 smb_ace_walk_init(mdb_walk_state_t *wsp)
17546432Sas200622 {
17556432Sas200622 	if (wsp->walk_addr == 0) {
17566432Sas200622 		mdb_printf("smb_ace walk only supports local walks\n");
17576432Sas200622 		return (WALK_ERR);
17586432Sas200622 	}
17596432Sas200622 
17606432Sas200622 	wsp->walk_addr += offsetof(smb_acl_t, sl_sorted);
17616432Sas200622 
17626432Sas200622 	if (mdb_layered_walk("list", wsp) == -1) {
17636432Sas200622 		mdb_warn("failed to walk list of ACEs");
17646432Sas200622 		return (WALK_ERR);
17656432Sas200622 	}
17666432Sas200622 
17676432Sas200622 	return (WALK_NEXT);
17686432Sas200622 }
17696432Sas200622 
17706432Sas200622 static int
17716432Sas200622 smb_ace_walk_step(mdb_walk_state_t *wsp)
17726432Sas200622 {
17736432Sas200622 	return (wsp->walk_callback(wsp->walk_addr, wsp->walk_layer,
17746432Sas200622 	    wsp->walk_cbdata));
17756432Sas200622 }
17766432Sas200622 
17776432Sas200622 /*
17786432Sas200622  * *****************************************************************************
17796432Sas200622  * ******************************** smb_acl_t **********************************
17806432Sas200622  * *****************************************************************************
17816432Sas200622  */
17826432Sas200622 
17836432Sas200622 /*
17846432Sas200622  * ::smbacl
17856432Sas200622  */
17866432Sas200622 static int
17876432Sas200622 smb_acl(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
17886432Sas200622 {
17896432Sas200622 	smb_acl_t	acl;
17906432Sas200622 
17916432Sas200622 	/* An smb_acl address is required. */
17926432Sas200622 	if (!(flags & DCMD_ADDRSPEC))
17936432Sas200622 		return (DCMD_USAGE);
17946432Sas200622 
17956432Sas200622 	if (mdb_vread(&acl, sizeof (acl), addr) != sizeof (acl)) {
17966432Sas200622 		mdb_warn("failed to read struct smb_acl at %p", addr);
17976432Sas200622 		return (DCMD_ERR);
17986432Sas200622 	}
17996432Sas200622 
18006432Sas200622 	mdb_printf("ACL Revision: %d\n", acl.sl_revision);
18016432Sas200622 	mdb_printf("ACL Size on Wire: %d\n", acl.sl_bsize);
18026432Sas200622 	mdb_printf("ACL Number of ACEs: %d\n", acl.sl_acecnt);
18036432Sas200622 
18046432Sas200622 	(void) mdb_inc_indent(SMB_DCMD_INDENT);
18056432Sas200622 	if (mdb_pwalk_dcmd("smbace_walker", "smbace", argc, argv, addr)) {
18066432Sas200622 		(void) mdb_dec_indent(SMB_DCMD_INDENT);
18076432Sas200622 		mdb_warn("failed to walk list of ACEs for ACL %p", addr);
18086432Sas200622 		return (DCMD_ERR);
18096432Sas200622 	}
18106432Sas200622 	(void) mdb_dec_indent(SMB_DCMD_INDENT);
18116432Sas200622 	return (DCMD_OK);
18126432Sas200622 }
18136432Sas200622 
18146432Sas200622 /*
18156432Sas200622  * *****************************************************************************
18166432Sas200622  * ********************************* smb_sd_t **********************************
18176432Sas200622  * *****************************************************************************
18186432Sas200622  */
18196432Sas200622 
18206432Sas200622 /*
18216432Sas200622  * ::smbsd
18226432Sas200622  */
18236432Sas200622 static int
18246432Sas200622 smb_sd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
18256432Sas200622 {
18266432Sas200622 	smb_sd_t	sd;
18276432Sas200622 	int		rc;
18286432Sas200622 
18296432Sas200622 	/*
18306432Sas200622 	 * An smb_sid address is required.
18316432Sas200622 	 */
18326432Sas200622 	if (!(flags & DCMD_ADDRSPEC))
18336432Sas200622 		return (DCMD_USAGE);
18346432Sas200622 
18356432Sas200622 	if (mdb_vread(&sd, sizeof (sd), addr) != sizeof (sd)) {
18366432Sas200622 		mdb_warn("failed to read struct smb_sd at %p", addr);
18376432Sas200622 		return (DCMD_ERR);
18386432Sas200622 	}
18396432Sas200622 
18406432Sas200622 	mdb_printf("SD Revision: %d\n", sd.sd_revision);
18416432Sas200622 	mdb_printf("SD Control: %04x\n", sd.sd_control);
18426432Sas200622 	if (sd.sd_control & SE_OWNER_DEFAULTED)
18436432Sas200622 		mdb_printf("\t    SE_OWNER_DEFAULTED\n");
18446432Sas200622 	if (sd.sd_control & SE_GROUP_DEFAULTED)
18456432Sas200622 		mdb_printf("\t    SE_GROUP_DEFAULTED\n");
18466432Sas200622 	if (sd.sd_control & SE_DACL_PRESENT)
18476432Sas200622 		mdb_printf("\t    SE_DACL_PRESENT\n");
18486432Sas200622 	if (sd.sd_control & SE_DACL_DEFAULTED)
18496432Sas200622 		mdb_printf("\t    SE_DACL_DEFAULTED\n");
18506432Sas200622 	if (sd.sd_control & SE_SACL_PRESENT)
18516432Sas200622 		mdb_printf("\t    SE_SACL_PRESENT\n");
18526432Sas200622 	if (sd.sd_control & SE_SACL_DEFAULTED)
18536432Sas200622 		mdb_printf("\t    SE_SACL_DEFAULTED\n");
18546432Sas200622 	if (sd.sd_control & SE_DACL_AUTO_INHERIT_REQ)
18556432Sas200622 		mdb_printf("\t    SE_DACL_AUTO_INHERIT_REQ\n");
18566432Sas200622 	if (sd.sd_control & SE_SACL_AUTO_INHERIT_REQ)
18576432Sas200622 		mdb_printf("\t    SE_SACL_AUTO_INHERIT_REQ\n");
18586432Sas200622 	if (sd.sd_control & SE_DACL_AUTO_INHERITED)
18596432Sas200622 		mdb_printf("\t    SE_DACL_AUTO_INHERITED\n");
18606432Sas200622 	if (sd.sd_control & SE_SACL_AUTO_INHERITED)
18616432Sas200622 		mdb_printf("\t    SE_SACL_AUTO_INHERITED\n");
18626432Sas200622 	if (sd.sd_control & SE_DACL_PROTECTED)
18636432Sas200622 		mdb_printf("\t    SE_DACL_PROTECTED\n");
18646432Sas200622 	if (sd.sd_control & SE_SACL_PROTECTED)
18656432Sas200622 		mdb_printf("\t    SE_SACL_PROTECTED\n");
18666432Sas200622 	if (sd.sd_control & SE_SELF_RELATIVE)
18676432Sas200622 		mdb_printf("\t    SE_SELF_RELATIVE\n");
18686432Sas200622 
18696432Sas200622 	mdb_printf("SID of Owner: ");
18706432Sas200622 	rc = smb_sid_print((uintptr_t)sd.sd_owner);
18716432Sas200622 	if (rc != DCMD_OK)
18726432Sas200622 		return (rc);
18736432Sas200622 	mdb_printf("\nSID of Group: ");
18746432Sas200622 	rc = smb_sid_print((uintptr_t)sd.sd_group);
18756432Sas200622 	if (rc != DCMD_OK)
18766432Sas200622 		return (rc);
18776432Sas200622 	mdb_printf("\n");
18786432Sas200622 
18796432Sas200622 	if (sd.sd_control & SE_SACL_PRESENT && sd.sd_sacl) {
18806432Sas200622 		mdb_printf("%<b>%<u>System ACL%</u>%</b>\n");
18816432Sas200622 		(void) mdb_inc_indent(SMB_DCMD_INDENT);
18826432Sas200622 		rc = mdb_call_dcmd("smbacl", (uintptr_t)sd.sd_sacl, flags,
18836432Sas200622 		    argc, argv);
18846432Sas200622 		(void) mdb_dec_indent(SMB_DCMD_INDENT);
18856432Sas200622 		if (rc != DCMD_OK)
18866432Sas200622 			return (rc);
18876432Sas200622 	}
18886432Sas200622 	if (sd.sd_control & SE_DACL_PRESENT && sd.sd_dacl) {
18896432Sas200622 		mdb_printf("%<b>%<u>Discretionary ACL%</u>%</b>\n");
18906432Sas200622 		(void) mdb_inc_indent(SMB_DCMD_INDENT);
18916432Sas200622 		rc = mdb_call_dcmd("smbacl", (uintptr_t)sd.sd_dacl, flags,
18926432Sas200622 		    argc, argv);
18936432Sas200622 		(void) mdb_dec_indent(SMB_DCMD_INDENT);
18946432Sas200622 		if (rc != DCMD_OK)
18956432Sas200622 			return (rc);
18966432Sas200622 	}
18976432Sas200622 
18986432Sas200622 	return (DCMD_OK);
18996432Sas200622 }
19006432Sas200622 
19016432Sas200622 /*
19026432Sas200622  * *****************************************************************************
19036432Sas200622  * ********************************* smb_sid_t *********************************
19046432Sas200622  * *****************************************************************************
19056432Sas200622  */
19066432Sas200622 
19076432Sas200622 /*
19086432Sas200622  * ::smbsid
19096432Sas200622  */
19106432Sas200622 /*ARGSUSED*/
19116432Sas200622 static int
19126432Sas200622 smb_sid(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
19136432Sas200622 {
19146432Sas200622 	/*
19156432Sas200622 	 * An smb_sid address is required.
19166432Sas200622 	 */
19176432Sas200622 	if (!(flags & DCMD_ADDRSPEC))
19186432Sas200622 		return (DCMD_USAGE);
19195331Samw 
19206432Sas200622 	return (smb_sid_print(addr));
19216432Sas200622 }
19226432Sas200622 
19236432Sas200622 /*
19246432Sas200622  * smb_sid_print
19256432Sas200622  */
19266432Sas200622 static int
19276432Sas200622 smb_sid_print(uintptr_t addr)
19286432Sas200622 {
19296432Sas200622 	smb_sid_t	sid;
19306432Sas200622 	smb_sid_t	*psid;
19316432Sas200622 	size_t		sid_size;
19326432Sas200622 	int		i;
19336432Sas200622 	uint64_t	authority;
19346432Sas200622 
19356432Sas200622 	sid_size = offsetof(smb_sid_t, sid_subauth);
19366432Sas200622 
19376432Sas200622 	if (mdb_vread(&sid, sid_size, addr) != sid_size) {
19386432Sas200622 		mdb_warn("failed to read struct smb_sid at %p", addr);
19396432Sas200622 		return (DCMD_ERR);
19406432Sas200622 	}
19416432Sas200622 
19426432Sas200622 	sid_size += sid.sid_subauthcnt * sizeof (sid.sid_subauth[0]);
19436432Sas200622 
19446432Sas200622 	psid = mdb_zalloc(sid_size, UM_SLEEP | UM_GC);
19456432Sas200622 	if (mdb_vread(psid, sid_size, addr) != sid_size) {
19466432Sas200622 		mdb_warn("failed to read struct smb_sid at %p", addr);
19476432Sas200622 		return (DCMD_ERR);
19486432Sas200622 	}
19496432Sas200622 
19506432Sas200622 	mdb_printf("S-%d", psid->sid_revision);
19516432Sas200622 	authority = 0;
19526432Sas200622 	for (i = 0; i < NT_SID_AUTH_MAX; i++) {
19536432Sas200622 		authority += ((uint64_t)psid->sid_authority[i]) <<
19546432Sas200622 		    (8 * (NT_SID_AUTH_MAX - 1) - i);
19556432Sas200622 	}
19566432Sas200622 	mdb_printf("-%ll", authority);
19576432Sas200622 
19586432Sas200622 	for (i = 0; i < psid->sid_subauthcnt; i++)
19596432Sas200622 		mdb_printf("-%d", psid->sid_subauth[i]);
19606432Sas200622 
19616432Sas200622 	return (DCMD_OK);
19626432Sas200622 }
19636432Sas200622 
19646432Sas200622 /*
19656432Sas200622  * *****************************************************************************
19666432Sas200622  * ********************************* smb_fssd_t ********************************
19676432Sas200622  * *****************************************************************************
19686432Sas200622  */
19696432Sas200622 
19706432Sas200622 /*
19716432Sas200622  * ::smbfssd
19726432Sas200622  */
19736432Sas200622 static int
19746432Sas200622 smb_fssd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
19756432Sas200622 {
19766432Sas200622 	smb_fssd_t	fssd;
19776432Sas200622 	int		rc;
19786432Sas200622 
19796432Sas200622 	/*
19806432Sas200622 	 * An smb_fssd address is required.
19816432Sas200622 	 */
19826432Sas200622 	if (!(flags & DCMD_ADDRSPEC))
19836432Sas200622 		return (DCMD_USAGE);
19846432Sas200622 
19856432Sas200622 	if (mdb_vread(&fssd, sizeof (fssd), addr) != sizeof (fssd)) {
19866432Sas200622 		mdb_warn("failed to read struct smb_fssd at %p", addr);
19876432Sas200622 		return (DCMD_ERR);
19886432Sas200622 	}
19896432Sas200622 
19906432Sas200622 	mdb_printf("FSSD secinfo: 0x%x\n", fssd.sd_secinfo);
19916432Sas200622 	if (fssd.sd_secinfo & SMB_OWNER_SECINFO)
19926432Sas200622 		mdb_printf("FSSD uid: %d\n", fssd.sd_uid);
19936432Sas200622 	if (fssd.sd_secinfo & SMB_GROUP_SECINFO)
19946432Sas200622 		mdb_printf("FSSD gid: %d\n", fssd.sd_gid);
19956432Sas200622 	if (fssd.sd_secinfo & SMB_SACL_SECINFO && fssd.sd_zsacl) {
19966432Sas200622 		mdb_printf("%<b>%<u>System ACL%</u>%</b>\n");
19976432Sas200622 		(void) mdb_inc_indent(SMB_DCMD_INDENT);
19986432Sas200622 		rc = mdb_call_dcmd("smbacl", (uintptr_t)fssd.sd_zsacl, flags,
19996432Sas200622 		    argc, argv);
20006432Sas200622 		(void) mdb_dec_indent(SMB_DCMD_INDENT);
20016432Sas200622 		if (rc != DCMD_OK)
20026432Sas200622 			return (rc);
20036432Sas200622 	}
20046432Sas200622 	if (fssd.sd_secinfo & SMB_DACL_SECINFO && fssd.sd_zdacl) {
20056432Sas200622 		mdb_printf("%<b>%<u>Discretionary ACL%</u>%</b>\n");
20066432Sas200622 		(void) mdb_inc_indent(SMB_DCMD_INDENT);
20076432Sas200622 		rc = mdb_call_dcmd("smbacl", (uintptr_t)fssd.sd_zdacl, flags,
20086432Sas200622 		    argc, argv);
20096432Sas200622 		(void) mdb_dec_indent(SMB_DCMD_INDENT);
20106432Sas200622 		if (rc != DCMD_OK)
20116432Sas200622 			return (rc);
20126432Sas200622 	}
20136432Sas200622 
20146432Sas200622 	return (DCMD_OK);
20156432Sas200622 }
20166432Sas200622 
20176432Sas200622 /*
20186432Sas200622  * *****************************************************************************
20196432Sas200622  * **************************** Utility Funcions *******************************
20206432Sas200622  * *****************************************************************************
20216432Sas200622  */
20225331Samw 
20236432Sas200622 /*
20246432Sas200622  * smb_dcmd_getopt
20256432Sas200622  *
20266432Sas200622  * This function analyzes the arguments passed in and sets the bit corresponding
20276432Sas200622  * to the options found in the opts variable.
20286432Sas200622  *
20296432Sas200622  * Return Value
20306432Sas200622  *
20316432Sas200622  *	-1	An error occured during the decoding
20326432Sas200622  *	0	The decoding was successful
20336432Sas200622  */
20346432Sas200622 static int
20356432Sas200622 smb_dcmd_getopt(uint_t *opts, int argc, const mdb_arg_t *argv)
20366432Sas200622 {
20376432Sas200622 	*opts = 0;
20386432Sas200622 
20396432Sas200622 	if (mdb_getopts(argc, argv,
20406432Sas200622 	    's', MDB_OPT_SETBITS, SMB_OPT_SERVER, opts,
20416432Sas200622 	    'm', MDB_OPT_SETBITS, SMB_OPT_VFS, opts,
20426432Sas200622 	    'e', MDB_OPT_SETBITS, SMB_OPT_SESSION, opts,
20436432Sas200622 	    'r', MDB_OPT_SETBITS, SMB_OPT_REQUEST, opts,
20446432Sas200622 	    'u', MDB_OPT_SETBITS, SMB_OPT_USER, opts,
20456432Sas200622 	    't', MDB_OPT_SETBITS, SMB_OPT_TREE, opts,
20466432Sas200622 	    'f', MDB_OPT_SETBITS, SMB_OPT_OFILE, opts,
20476432Sas200622 	    'd', MDB_OPT_SETBITS, SMB_OPT_ODIR, opts,
20486432Sas200622 	    'w', MDB_OPT_SETBITS, SMB_OPT_WALK, opts,
20496432Sas200622 	    'v', MDB_OPT_SETBITS, SMB_OPT_VERBOSE, opts,
20506432Sas200622 	    NULL) != argc)
20516432Sas200622 		return (-1);
20526432Sas200622 
20536432Sas200622 	return (0);
20546432Sas200622 }
20556432Sas200622 
20566432Sas200622 /*
20576432Sas200622  * smb_dcmd_setopt
20586432Sas200622  *
20596432Sas200622  * This function set the arguments corresponding to the bits set in opts.
20606432Sas200622  *
20616432Sas200622  * Return Value
20626432Sas200622  *
20636432Sas200622  *	Number of arguments set.
20646432Sas200622  */
20656432Sas200622 static int
20666432Sas200622 smb_dcmd_setopt(uint_t opts, int max_argc, mdb_arg_t *argv)
20675331Samw {
20686432Sas200622 	int	i;
20696432Sas200622 	uint_t	mask = 0x00000001;
20706432Sas200622 	int	argc = 0;
20716432Sas200622 
20726432Sas200622 	for (i = 0; i < SMB_MDB_MAX_OPTS; i++) {
20736432Sas200622 		if ((opts & mask) && (argc < max_argc)) {
20746432Sas200622 			argv->a_type = MDB_TYPE_STRING;
20756432Sas200622 			argv->a_un.a_str = smb_opts[i];
20766432Sas200622 			argc++;
20776432Sas200622 			argv++;
20786432Sas200622 		}
20796432Sas200622 		mask = mask << 1;
20806432Sas200622 	}
20816432Sas200622 	return (argc);
20825331Samw }
20836432Sas200622 
20846432Sas200622 /*
20856432Sas200622  * smb_obj_expand
20866432Sas200622  */
20876432Sas200622 static int
20886432Sas200622 smb_obj_expand(uintptr_t addr, uint_t opts, const smb_exp_t *x, ulong_t indent)
20896432Sas200622 {
20906432Sas200622 	int		rc = 0;
20916432Sas200622 	int		argc;
20926432Sas200622 	mdb_arg_t	argv[SMB_MDB_MAX_OPTS];
20936432Sas200622 
20946432Sas200622 	argc = smb_dcmd_setopt(opts | SMB_OPT_WALK, SMB_MDB_MAX_OPTS, argv);
20956432Sas200622 
20966432Sas200622 	(void) mdb_inc_indent(indent);
20976432Sas200622 	while (x->ex_dcmd) {
20986432Sas200622 		if (x->ex_mask & opts) {
20996432Sas200622 			rc = mdb_pwalk_dcmd("list", x->ex_dcmd, argc, argv,
21006432Sas200622 			    addr + x->ex_offset);
21016432Sas200622 
21026432Sas200622 			if (rc) {
21036432Sas200622 				mdb_warn("failed to walk the list of %s in %p",
21046432Sas200622 				    x->ex_name, addr + x->ex_offset);
21056432Sas200622 				break;
21066432Sas200622 			}
21076432Sas200622 		}
21086432Sas200622 		x++;
21096432Sas200622 	}
21106432Sas200622 	(void) mdb_dec_indent(indent);
21116432Sas200622 	return (rc);
21126432Sas200622 }
21136432Sas200622 
21146432Sas200622 /*
21156432Sas200622  * smb_obj_list
21166432Sas200622  *
21176432Sas200622  * Function called by the DCMDs when no address is provided. It expands the
21186432Sas200622  * tree under the object type associated with the calling DCMD (based on the
21196432Sas200622  * flags passed in).
21206432Sas200622  *
21216432Sas200622  * Return Value
21226432Sas200622  *
21236432Sas200622  *	DCMD_OK
21246432Sas200622  *	DCMD_ERR
21256432Sas200622  */
21266432Sas200622 static int
21276432Sas200622 smb_obj_list(const char *name, uint_t opts, uint_t flags)
21286432Sas200622 {
21296432Sas200622 	int		argc;
21306432Sas200622 	mdb_arg_t	argv[SMB_MDB_MAX_OPTS];
21316432Sas200622 
21326432Sas200622 	argc = smb_dcmd_setopt(opts, SMB_MDB_MAX_OPTS, argv);
21336432Sas200622 
21346432Sas200622 	if (mdb_call_dcmd("smblist", 0, flags, argc, argv)) {
21356432Sas200622 		mdb_warn("failed to list %s", name);
21366432Sas200622 		return (DCMD_ERR);
21376432Sas200622 	}
21386432Sas200622 	return (DCMD_OK);
21396432Sas200622 }
2140