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