1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
24  * Copyright 2019 Nexenta by DDN, Inc. All rights reserved.
25  */
26 
27 #include <mdb/mdb_modapi.h>
28 #include <mdb/mdb_ks.h>
29 #include <mdb/mdb_ctf.h>
30 #include <sys/note.h>
31 #include <sys/thread.h>
32 #include <sys/taskq.h>
33 #include <smbsrv/smb_vops.h>
34 #include <smbsrv/smb.h>
35 #include <smbsrv/smb_ktypes.h>
36 #include <smbsrv/smb_token.h>
37 #include <smbsrv/smb_oplock.h>
38 
39 #ifndef _KMDB
40 #include "smbsrv_pcap.h"
41 #endif
42 
43 #ifdef _KERNEL
44 #define	SMBSRV_OBJNAME	"smbsrv"
45 #else
46 #define	SMBSRV_OBJNAME	"libfksmbsrv.so.1"
47 #endif
48 
49 #define	SMBSRV_SCOPE	SMBSRV_OBJNAME "`"
50 
51 #define	SMB_DCMD_INDENT		2
52 #define	ACE_TYPE_TABLEN		(ACE_ALL_TYPES + 1)
53 #define	ACE_TYPE_ENTRY(_v_)	{_v_, #_v_}
54 #define	SMB_COM_ENTRY(_v_, _x_)	{#_v_, _x_}
55 
56 #define	SMB_MDB_MAX_OPTS	10
57 
58 #define	SMB_OPT_SERVER		0x00000001
59 #define	SMB_OPT_SESSION		0x00000002
60 #define	SMB_OPT_REQUEST		0x00000004
61 #define	SMB_OPT_USER		0x00000008
62 #define	SMB_OPT_TREE		0x00000010
63 #define	SMB_OPT_OFILE		0x00000020
64 #define	SMB_OPT_ODIR		0x00000040
65 #define	SMB_OPT_WALK		0x00000100
66 #define	SMB_OPT_VERBOSE		0x00000200
67 #define	SMB_OPT_ALL_OBJ		0x000000FF
68 
69 /*
70  * Use CTF to set var = OFFSETOF(typ, mem) if possible, otherwise
71  * fall back to just OFFSETOF.  The fall back is more convenient
72  * than trying to return an error where this is used, and also
73  * let's us find out at compile time if we're referring to any
74  * typedefs or member names that don't exist.  Without that
75  * OFFSETOF fall back, we'd only find out at run time.
76  */
77 #define	GET_OFFSET(var, typ, mem) do {				\
78 	var = mdb_ctf_offsetof_by_name(#typ, #mem);		\
79 	if (var < 0) {						\
80 		mdb_warn("cannot lookup: " #typ " ." #mem);	\
81 		var = (int)OFFSETOF(typ, mem);			\
82 	}							\
83 _NOTE(CONSTCOND) } while (0)
84 
85 /*
86  * Structure associating an ACE type to a string.
87  */
88 typedef struct {
89 	uint8_t		ace_type_value;
90 	const char	*ace_type_sting;
91 } ace_type_entry_t;
92 
93 /*
94  * Structure containing strings describing an SMB command.
95  */
96 typedef struct {
97 	const char	*smb_com;
98 	const char	*smb_andx;
99 } smb_com_entry_t;
100 
101 /*
102  * Structure describing an object to be expanded (displayed).
103  */
104 typedef struct {
105 	uint_t		ex_mask;
106 	int		(*ex_offset)(void);
107 	const char	*ex_dcmd;
108 	const char	*ex_name;
109 } smb_exp_t;
110 
111 /*
112  * List of supported options. Ther order has the match the bits SMB_OPT_xxx.
113  */
114 typedef struct smb_mdb_opts {
115 	char		*o_name;
116 	uint32_t	o_value;
117 } smb_mdb_opts_t;
118 
119 static smb_mdb_opts_t smb_opts[SMB_MDB_MAX_OPTS] =
120 {
121 	{ "-s", SMB_OPT_SERVER	},
122 	{ "-e", SMB_OPT_SESSION	},
123 	{ "-r", SMB_OPT_REQUEST	},
124 	{ "-u", SMB_OPT_USER	},
125 	{ "-t", SMB_OPT_TREE	},
126 	{ "-f", SMB_OPT_OFILE	},
127 	{ "-d", SMB_OPT_ODIR	},
128 	{ "-w", SMB_OPT_WALK	},
129 	{ "-v", SMB_OPT_VERBOSE	}
130 };
131 
132 /*
133  * These access mask bits are generic enough they could move into the
134  * genunix mdb module or somewhere so they could be shared.
135  */
136 static const mdb_bitmask_t
137 nt_access_bits[] = {
138 	{ "READ_DATA",
139 	    FILE_READ_DATA,
140 	    FILE_READ_DATA },
141 	{ "WRITE_DATA",
142 	    FILE_WRITE_DATA,
143 	    FILE_WRITE_DATA },
144 	{ "APPEND_DATA",
145 	    FILE_APPEND_DATA,
146 	    FILE_APPEND_DATA },
147 	{ "READ_EA",
148 	    FILE_READ_EA,
149 	    FILE_READ_EA },
150 	{ "WRITE_EA",
151 	    FILE_WRITE_EA,
152 	    FILE_WRITE_EA },
153 	{ "EXECUTE",
154 	    FILE_EXECUTE,
155 	    FILE_EXECUTE },
156 	{ "DELETE_CHILD",
157 	    FILE_DELETE_CHILD,
158 	    FILE_DELETE_CHILD },
159 	{ "READ_ATTR",
160 	    FILE_READ_ATTRIBUTES,
161 	    FILE_READ_ATTRIBUTES },
162 	{ "WRITE_ATTR",
163 	    FILE_WRITE_ATTRIBUTES,
164 	    FILE_WRITE_ATTRIBUTES },
165 	{ "DELETE",
166 	    DELETE,
167 	    DELETE },
168 	{ "READ_CTRL",
169 	    READ_CONTROL,
170 	    READ_CONTROL },
171 	{ "WRITE_DAC",
172 	    WRITE_DAC,
173 	    WRITE_DAC },
174 	{ "WRITE_OWNER",
175 	    WRITE_OWNER,
176 	    WRITE_OWNER },
177 	{ "SYNCH",
178 	    SYNCHRONIZE,
179 	    SYNCHRONIZE },
180 	{ "ACC_SEC",
181 	    ACCESS_SYSTEM_SECURITY,
182 	    ACCESS_SYSTEM_SECURITY },
183 	{ "MAX_ALLOWED",
184 	    MAXIMUM_ALLOWED,
185 	    MAXIMUM_ALLOWED },
186 	{ "GEN_X",
187 	    GENERIC_EXECUTE,
188 	    GENERIC_EXECUTE },
189 	{ "GEN_W",
190 	    GENERIC_WRITE,
191 	    GENERIC_WRITE },
192 	{ "GEN_R",
193 	    GENERIC_READ,
194 	    GENERIC_READ },
195 	{ NULL, 0, 0 }
196 };
197 
198 static smb_com_entry_t	smb_com[256] =
199 {
200 	SMB_COM_ENTRY(SMB_COM_CREATE_DIRECTORY, "No"),
201 	SMB_COM_ENTRY(SMB_COM_DELETE_DIRECTORY, "No"),
202 	SMB_COM_ENTRY(SMB_COM_OPEN, "No"),
203 	SMB_COM_ENTRY(SMB_COM_CREATE, "No"),
204 	SMB_COM_ENTRY(SMB_COM_CLOSE, "No"),
205 	SMB_COM_ENTRY(SMB_COM_FLUSH, "No"),
206 	SMB_COM_ENTRY(SMB_COM_DELETE, "No"),
207 	SMB_COM_ENTRY(SMB_COM_RENAME, "No"),
208 	SMB_COM_ENTRY(SMB_COM_QUERY_INFORMATION, "No"),
209 	SMB_COM_ENTRY(SMB_COM_SET_INFORMATION, "No"),
210 	SMB_COM_ENTRY(SMB_COM_READ, "No"),
211 	SMB_COM_ENTRY(SMB_COM_WRITE, "No"),
212 	SMB_COM_ENTRY(SMB_COM_LOCK_BYTE_RANGE, "No"),
213 	SMB_COM_ENTRY(SMB_COM_UNLOCK_BYTE_RANGE, "No"),
214 	SMB_COM_ENTRY(SMB_COM_CREATE_TEMPORARY, "No"),
215 	SMB_COM_ENTRY(SMB_COM_CREATE_NEW, "No"),
216 	SMB_COM_ENTRY(SMB_COM_CHECK_DIRECTORY, "No"),
217 	SMB_COM_ENTRY(SMB_COM_PROCESS_EXIT, "No"),
218 	SMB_COM_ENTRY(SMB_COM_SEEK, "No"),
219 	SMB_COM_ENTRY(SMB_COM_LOCK_AND_READ, "No"),
220 	SMB_COM_ENTRY(SMB_COM_WRITE_AND_UNLOCK, "No"),
221 	SMB_COM_ENTRY(0x15, "?"),
222 	SMB_COM_ENTRY(0x16, "?"),
223 	SMB_COM_ENTRY(0x17, "?"),
224 	SMB_COM_ENTRY(0x18, "?"),
225 	SMB_COM_ENTRY(0x19, "?"),
226 	SMB_COM_ENTRY(SMB_COM_READ_RAW, "No"),
227 	SMB_COM_ENTRY(SMB_COM_READ_MPX, "No"),
228 	SMB_COM_ENTRY(SMB_COM_READ_MPX_SECONDARY, "No"),
229 	SMB_COM_ENTRY(SMB_COM_WRITE_RAW, "No"),
230 	SMB_COM_ENTRY(SMB_COM_WRITE_MPX, "No"),
231 	SMB_COM_ENTRY(SMB_COM_WRITE_MPX_SECONDARY, "No"),
232 	SMB_COM_ENTRY(SMB_COM_WRITE_COMPLETE, "No"),
233 	SMB_COM_ENTRY(SMB_COM_QUERY_SERVER, "No"),
234 	SMB_COM_ENTRY(SMB_COM_SET_INFORMATION2, "No"),
235 	SMB_COM_ENTRY(SMB_COM_QUERY_INFORMATION2, "No"),
236 	SMB_COM_ENTRY(SMB_COM_LOCKING_ANDX, "No"),
237 	SMB_COM_ENTRY(SMB_COM_TRANSACTION, "No"),
238 	SMB_COM_ENTRY(SMB_COM_TRANSACTION_SECONDARY, "No"),
239 	SMB_COM_ENTRY(SMB_COM_IOCTL, "No"),
240 	SMB_COM_ENTRY(SMB_COM_IOCTL_SECONDARY, "No"),
241 	SMB_COM_ENTRY(SMB_COM_COPY, "No"),
242 	SMB_COM_ENTRY(SMB_COM_MOVE, "No"),
243 	SMB_COM_ENTRY(SMB_COM_ECHO, "No"),
244 	SMB_COM_ENTRY(SMB_COM_WRITE_AND_CLOSE, "No"),
245 	SMB_COM_ENTRY(SMB_COM_OPEN_ANDX, "No"),
246 	SMB_COM_ENTRY(SMB_COM_READ_ANDX, "No"),
247 	SMB_COM_ENTRY(SMB_COM_WRITE_ANDX, "No"),
248 	SMB_COM_ENTRY(SMB_COM_NEW_FILE_SIZE, "No"),
249 	SMB_COM_ENTRY(SMB_COM_CLOSE_AND_TREE_DISC, "No"),
250 	SMB_COM_ENTRY(SMB_COM_TRANSACTION2, "No"),
251 	SMB_COM_ENTRY(SMB_COM_TRANSACTION2_SECONDARY, "No"),
252 	SMB_COM_ENTRY(SMB_COM_FIND_CLOSE2, "No"),
253 	SMB_COM_ENTRY(SMB_COM_FIND_NOTIFY_CLOSE, "No"),
254 	SMB_COM_ENTRY(0x36, "?"),
255 	SMB_COM_ENTRY(0x37, "?"),
256 	SMB_COM_ENTRY(0x38, "?"),
257 	SMB_COM_ENTRY(0x39, "?"),
258 	SMB_COM_ENTRY(0x3A, "?"),
259 	SMB_COM_ENTRY(0x3B, "?"),
260 	SMB_COM_ENTRY(0x3C, "?"),
261 	SMB_COM_ENTRY(0x3D, "?"),
262 	SMB_COM_ENTRY(0x3E, "?"),
263 	SMB_COM_ENTRY(0x3F, "?"),
264 	SMB_COM_ENTRY(0x40, "?"),
265 	SMB_COM_ENTRY(0x41, "?"),
266 	SMB_COM_ENTRY(0x42, "?"),
267 	SMB_COM_ENTRY(0x43, "?"),
268 	SMB_COM_ENTRY(0x44, "?"),
269 	SMB_COM_ENTRY(0x45, "?"),
270 	SMB_COM_ENTRY(0x46, "?"),
271 	SMB_COM_ENTRY(0x47, "?"),
272 	SMB_COM_ENTRY(0x48, "?"),
273 	SMB_COM_ENTRY(0x49, "?"),
274 	SMB_COM_ENTRY(0x4A, "?"),
275 	SMB_COM_ENTRY(0x4B, "?"),
276 	SMB_COM_ENTRY(0x4C, "?"),
277 	SMB_COM_ENTRY(0x4D, "?"),
278 	SMB_COM_ENTRY(0x4E, "?"),
279 	SMB_COM_ENTRY(0x4F, "?"),
280 	SMB_COM_ENTRY(0x50, "?"),
281 	SMB_COM_ENTRY(0x51, "?"),
282 	SMB_COM_ENTRY(0x52, "?"),
283 	SMB_COM_ENTRY(0x53, "?"),
284 	SMB_COM_ENTRY(0x54, "?"),
285 	SMB_COM_ENTRY(0x55, "?"),
286 	SMB_COM_ENTRY(0x56, "?"),
287 	SMB_COM_ENTRY(0x57, "?"),
288 	SMB_COM_ENTRY(0x58, "?"),
289 	SMB_COM_ENTRY(0x59, "?"),
290 	SMB_COM_ENTRY(0x5A, "?"),
291 	SMB_COM_ENTRY(0x5B, "?"),
292 	SMB_COM_ENTRY(0x5C, "?"),
293 	SMB_COM_ENTRY(0x5D, "?"),
294 	SMB_COM_ENTRY(0x5E, "?"),
295 	SMB_COM_ENTRY(0x5F, "?"),
296 	SMB_COM_ENTRY(0x60, "?"),
297 	SMB_COM_ENTRY(0x61, "?"),
298 	SMB_COM_ENTRY(0x62, "?"),
299 	SMB_COM_ENTRY(0x63, "?"),
300 	SMB_COM_ENTRY(0x64, "?"),
301 	SMB_COM_ENTRY(0x65, "?"),
302 	SMB_COM_ENTRY(0x66, "?"),
303 	SMB_COM_ENTRY(0x67, "?"),
304 	SMB_COM_ENTRY(0x68, "?"),
305 	SMB_COM_ENTRY(0x69, "?"),
306 	SMB_COM_ENTRY(0x6A, "?"),
307 	SMB_COM_ENTRY(0x6B, "?"),
308 	SMB_COM_ENTRY(0x6C, "?"),
309 	SMB_COM_ENTRY(0x6D, "?"),
310 	SMB_COM_ENTRY(0x6E, "?"),
311 	SMB_COM_ENTRY(0x6F, "?"),
312 	SMB_COM_ENTRY(SMB_COM_TREE_CONNECT, "No"),
313 	SMB_COM_ENTRY(SMB_COM_TREE_DISCONNECT, "No"),
314 	SMB_COM_ENTRY(SMB_COM_NEGOTIATE, "No"),
315 	SMB_COM_ENTRY(SMB_COM_SESSION_SETUP_ANDX, "No"),
316 	SMB_COM_ENTRY(SMB_COM_LOGOFF_ANDX, "No"),
317 	SMB_COM_ENTRY(SMB_COM_TREE_CONNECT_ANDX, "No"),
318 	SMB_COM_ENTRY(0x76, "?"),
319 	SMB_COM_ENTRY(0x77, "?"),
320 	SMB_COM_ENTRY(0x78, "?"),
321 	SMB_COM_ENTRY(0x79, "?"),
322 	SMB_COM_ENTRY(0x7A, "?"),
323 	SMB_COM_ENTRY(0x7B, "?"),
324 	SMB_COM_ENTRY(0x7C, "?"),
325 	SMB_COM_ENTRY(0x7D, "?"),
326 	SMB_COM_ENTRY(0x7E, "?"),
327 	SMB_COM_ENTRY(0x7F, "?"),
328 	SMB_COM_ENTRY(SMB_COM_QUERY_INFORMATION_DISK, "No"),
329 	SMB_COM_ENTRY(SMB_COM_SEARCH, "No"),
330 	SMB_COM_ENTRY(SMB_COM_FIND, "No"),
331 	SMB_COM_ENTRY(SMB_COM_FIND_UNIQUE, "No"),
332 	SMB_COM_ENTRY(SMB_COM_FIND_CLOSE, "No"),
333 	SMB_COM_ENTRY(0x85, "?"),
334 	SMB_COM_ENTRY(0x86, "?"),
335 	SMB_COM_ENTRY(0x87, "?"),
336 	SMB_COM_ENTRY(0x88, "?"),
337 	SMB_COM_ENTRY(0x89, "?"),
338 	SMB_COM_ENTRY(0x8A, "?"),
339 	SMB_COM_ENTRY(0x8B, "?"),
340 	SMB_COM_ENTRY(0x8C, "?"),
341 	SMB_COM_ENTRY(0x8D, "?"),
342 	SMB_COM_ENTRY(0x8E, "?"),
343 	SMB_COM_ENTRY(0x8F, "?"),
344 	SMB_COM_ENTRY(0x90, "?"),
345 	SMB_COM_ENTRY(0x91, "?"),
346 	SMB_COM_ENTRY(0x92, "?"),
347 	SMB_COM_ENTRY(0x93, "?"),
348 	SMB_COM_ENTRY(0x94, "?"),
349 	SMB_COM_ENTRY(0x95, "?"),
350 	SMB_COM_ENTRY(0x96, "?"),
351 	SMB_COM_ENTRY(0x97, "?"),
352 	SMB_COM_ENTRY(0x98, "?"),
353 	SMB_COM_ENTRY(0x99, "?"),
354 	SMB_COM_ENTRY(0x9A, "?"),
355 	SMB_COM_ENTRY(0x9B, "?"),
356 	SMB_COM_ENTRY(0x9C, "?"),
357 	SMB_COM_ENTRY(0x9D, "?"),
358 	SMB_COM_ENTRY(0x9E, "?"),
359 	SMB_COM_ENTRY(0x9F, "?"),
360 	SMB_COM_ENTRY(SMB_COM_NT_TRANSACT, "No"),
361 	SMB_COM_ENTRY(SMB_COM_NT_TRANSACT_SECONDARY, "No"),
362 	SMB_COM_ENTRY(SMB_COM_NT_CREATE_ANDX, "No"),
363 	SMB_COM_ENTRY(0xA3, "?"),
364 	SMB_COM_ENTRY(SMB_COM_NT_CANCEL, "No"),
365 	SMB_COM_ENTRY(SMB_COM_NT_RENAME, "No"),
366 	SMB_COM_ENTRY(0xA6, "?"),
367 	SMB_COM_ENTRY(0xA7, "?"),
368 	SMB_COM_ENTRY(0xA8, "?"),
369 	SMB_COM_ENTRY(0xA9, "?"),
370 	SMB_COM_ENTRY(0xAA, "?"),
371 	SMB_COM_ENTRY(0xAB, "?"),
372 	SMB_COM_ENTRY(0xAC, "?"),
373 	SMB_COM_ENTRY(0xAD, "?"),
374 	SMB_COM_ENTRY(0xAE, "?"),
375 	SMB_COM_ENTRY(0xAF, "?"),
376 	SMB_COM_ENTRY(0xB0, "?"),
377 	SMB_COM_ENTRY(0xB1, "?"),
378 	SMB_COM_ENTRY(0xB2, "?"),
379 	SMB_COM_ENTRY(0xB3, "?"),
380 	SMB_COM_ENTRY(0xB4, "?"),
381 	SMB_COM_ENTRY(0xB5, "?"),
382 	SMB_COM_ENTRY(0xB6, "?"),
383 	SMB_COM_ENTRY(0xB7, "?"),
384 	SMB_COM_ENTRY(0xB8, "?"),
385 	SMB_COM_ENTRY(0xB9, "?"),
386 	SMB_COM_ENTRY(0xBA, "?"),
387 	SMB_COM_ENTRY(0xBB, "?"),
388 	SMB_COM_ENTRY(0xBC, "?"),
389 	SMB_COM_ENTRY(0xBD, "?"),
390 	SMB_COM_ENTRY(0xBE, "?"),
391 	SMB_COM_ENTRY(0xBF, "?"),
392 	SMB_COM_ENTRY(SMB_COM_OPEN_PRINT_FILE, "No"),
393 	SMB_COM_ENTRY(SMB_COM_WRITE_PRINT_FILE, "No"),
394 	SMB_COM_ENTRY(SMB_COM_CLOSE_PRINT_FILE, "No"),
395 	SMB_COM_ENTRY(SMB_COM_GET_PRINT_QUEUE, "No"),
396 	SMB_COM_ENTRY(0xC4, "?"),
397 	SMB_COM_ENTRY(0xC5, "?"),
398 	SMB_COM_ENTRY(0xC6, "?"),
399 	SMB_COM_ENTRY(0xC7, "?"),
400 	SMB_COM_ENTRY(0xC8, "?"),
401 	SMB_COM_ENTRY(0xC9, "?"),
402 	SMB_COM_ENTRY(0xCA, "?"),
403 	SMB_COM_ENTRY(0xCB, "?"),
404 	SMB_COM_ENTRY(0xCC, "?"),
405 	SMB_COM_ENTRY(0xCD, "?"),
406 	SMB_COM_ENTRY(0xCE, "?"),
407 	SMB_COM_ENTRY(0xCF, "?"),
408 	SMB_COM_ENTRY(0xD0, "?"),
409 	SMB_COM_ENTRY(0xD1, "?"),
410 	SMB_COM_ENTRY(0xD2, "?"),
411 	SMB_COM_ENTRY(0xD3, "?"),
412 	SMB_COM_ENTRY(0xD4, "?"),
413 	SMB_COM_ENTRY(0xD5, "?"),
414 	SMB_COM_ENTRY(0xD6, "?"),
415 	SMB_COM_ENTRY(0xD7, "?"),
416 	SMB_COM_ENTRY(SMB_COM_READ_BULK, "No"),
417 	SMB_COM_ENTRY(SMB_COM_WRITE_BULK, "No"),
418 	SMB_COM_ENTRY(SMB_COM_WRITE_BULK_DATA, "No"),
419 	SMB_COM_ENTRY(0xDB, "?"),
420 	SMB_COM_ENTRY(0xDC, "?"),
421 	SMB_COM_ENTRY(0xDD, "?"),
422 	SMB_COM_ENTRY(0xDE, "?"),
423 	SMB_COM_ENTRY(0xDF, "?"),
424 	SMB_COM_ENTRY(0xE0, "?"),
425 	SMB_COM_ENTRY(0xE1, "?"),
426 	SMB_COM_ENTRY(0xE2, "?"),
427 	SMB_COM_ENTRY(0xE3, "?"),
428 	SMB_COM_ENTRY(0xE4, "?"),
429 	SMB_COM_ENTRY(0xE5, "?"),
430 	SMB_COM_ENTRY(0xE6, "?"),
431 	SMB_COM_ENTRY(0xE7, "?"),
432 	SMB_COM_ENTRY(0xE8, "?"),
433 	SMB_COM_ENTRY(0xE9, "?"),
434 	SMB_COM_ENTRY(0xEA, "?"),
435 	SMB_COM_ENTRY(0xEB, "?"),
436 	SMB_COM_ENTRY(0xEC, "?"),
437 	SMB_COM_ENTRY(0xED, "?"),
438 	SMB_COM_ENTRY(0xEE, "?"),
439 	SMB_COM_ENTRY(0xEF, "?"),
440 	SMB_COM_ENTRY(0xF0, "?"),
441 	SMB_COM_ENTRY(0xF1, "?"),
442 	SMB_COM_ENTRY(0xF2, "?"),
443 	SMB_COM_ENTRY(0xF3, "?"),
444 	SMB_COM_ENTRY(0xF4, "?"),
445 	SMB_COM_ENTRY(0xF5, "?"),
446 	SMB_COM_ENTRY(0xF6, "?"),
447 	SMB_COM_ENTRY(0xF7, "?"),
448 	SMB_COM_ENTRY(0xF8, "?"),
449 	SMB_COM_ENTRY(0xF9, "?"),
450 	SMB_COM_ENTRY(0xFA, "?"),
451 	SMB_COM_ENTRY(0xFB, "?"),
452 	SMB_COM_ENTRY(0xFC, "?"),
453 	SMB_COM_ENTRY(0xFD, "?"),
454 	SMB_COM_ENTRY(0xFE, "?"),
455 	SMB_COM_ENTRY(0xFF, "?")
456 };
457 
458 static const char *smb2_cmd_names[SMB2__NCMDS] = {
459 	"smb2_negotiate",
460 	"smb2_session_setup",
461 	"smb2_logoff",
462 	"smb2_tree_connect",
463 	"smb2_tree_disconn",
464 	"smb2_create",
465 	"smb2_close",
466 	"smb2_flush",
467 	"smb2_read",
468 	"smb2_write",
469 	"smb2_lock",
470 	"smb2_ioctl",
471 	"smb2_cancel",
472 	"smb2_echo",
473 	"smb2_query_dir",
474 	"smb2_change_notify",
475 	"smb2_query_info",
476 	"smb2_set_info",
477 	"smb2_oplock_break",
478 	"smb2_invalid_cmd"
479 };
480 
481 struct mdb_smb_oplock;
482 
483 static int smb_sid_print(uintptr_t);
484 static int smb_dcmd_getopt(uint_t *, int, const mdb_arg_t *);
485 static int smb_dcmd_setopt(uint_t, int, mdb_arg_t *);
486 static int smb_obj_expand(uintptr_t, uint_t, const smb_exp_t *, ulong_t);
487 static int smb_obj_list(const char *, uint_t, uint_t);
488 static int smb_worker_findstack(uintptr_t);
489 static int smb_node_get_oplock(uintptr_t, struct mdb_smb_oplock **);
490 static int smb_node_oplock_cnt(struct mdb_smb_oplock *);
491 static void smb_inaddr_ntop(smb_inaddr_t *, char *, size_t);
492 static void get_enum(char *, size_t, const char *, int, const char *);
493 
494 typedef int (*dump_func_t)(struct mbuf_chain *, int32_t,
495     smb_inaddr_t *, uint16_t, smb_inaddr_t *, uint16_t,
496     hrtime_t, boolean_t);
497 static int smb_req_dump(struct mbuf_chain *, int32_t,
498     smb_inaddr_t *, uint16_t, smb_inaddr_t *, uint16_t,
499     hrtime_t, boolean_t);
500 static int smb_req_dump_m(uintptr_t, const void *, void *);
501 
502 /*
503  * *****************************************************************************
504  * ****************************** Top level DCMD *******************************
505  * *****************************************************************************
506  */
507 
508 static void
smblist_help(void)509 smblist_help(void)
510 {
511 	mdb_printf(
512 	    "Displays the list of objects using an indented tree format.\n"
513 	    "If no option is specified the entire tree is displayed\n\n");
514 	(void) mdb_dec_indent(2);
515 	mdb_printf("%<b>OPTIONS%</b>\n");
516 	(void) mdb_inc_indent(2);
517 	mdb_printf(
518 	    "-v\tDisplay verbose information\n"
519 	    "-s\tDisplay the list of servers\n"
520 	    "-e\tDisplay the list of sessions\n"
521 	    "-r\tDisplay the list of smb requests\n"
522 	    "-u\tDisplay the list of users\n"
523 	    "-t\tDisplay the list of trees\n"
524 	    "-f\tDisplay the list of open files\n"
525 	    "-d\tDisplay the list of open searches\n");
526 }
527 
528 /*
529  * ::smblist
530  *
531  * This function lists the objects specified on the command line. If no object
532  * is specified the entire tree (server through ofile and odir) is displayed.
533  *
534  */
535 /*ARGSUSED*/
536 static int
smblist_dcmd(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)537 smblist_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
538 {
539 	GElf_Sym	sym;
540 	uint_t		opts = 0;
541 	int		new_argc;
542 	mdb_arg_t	new_argv[SMB_MDB_MAX_OPTS];
543 	int		ll_off;
544 
545 	if (smb_dcmd_getopt(&opts, argc, argv))
546 		return (DCMD_USAGE);
547 
548 	if (!(opts & ~(SMB_OPT_WALK | SMB_OPT_VERBOSE)))
549 		opts |= SMB_OPT_ALL_OBJ;
550 
551 	opts |= SMB_OPT_WALK;
552 
553 	new_argc = smb_dcmd_setopt(opts, SMB_MDB_MAX_OPTS, new_argv);
554 
555 	if (mdb_lookup_by_obj(SMBSRV_OBJNAME, "smb_servers", &sym) == -1) {
556 		mdb_warn("failed to find symbol smb_servers");
557 		return (DCMD_ERR);
558 	}
559 
560 	GET_OFFSET(ll_off, smb_llist_t, ll_list);
561 	addr = (uintptr_t)sym.st_value + ll_off;
562 
563 	if (mdb_pwalk_dcmd("list", "smbsrv", new_argc, new_argv, addr)) {
564 		mdb_warn("cannot walk smb_server list");
565 		return (DCMD_ERR);
566 	}
567 	return (DCMD_OK);
568 }
569 
570 /*
571  * *****************************************************************************
572  * ***************************** smb_server_t **********************************
573  * *****************************************************************************
574  */
575 
576 typedef struct mdb_smb_server {
577 	smb_server_state_t	sv_state;
578 	zoneid_t		sv_zid;
579 	smb_hash_t		*sv_persistid_ht;
580 } mdb_smb_server_t;
581 
582 static int
smb_server_exp_off_sv_list(void)583 smb_server_exp_off_sv_list(void)
584 {
585 	int svl_off, ll_off;
586 
587 	/* OFFSETOF(smb_server_t, sv_session_list.ll_list); */
588 	GET_OFFSET(svl_off, smb_server_t, sv_session_list);
589 	GET_OFFSET(ll_off, smb_llist_t, ll_list);
590 	return (svl_off + ll_off);
591 }
592 
593 static int
smb_server_exp_off_nbt_list(void)594 smb_server_exp_off_nbt_list(void)
595 {
596 	int svd_off, lds_off, ll_off;
597 
598 	/* OFFSETOF(smb_server_t, sv_nbt_daemon.ld_session_list.ll_list); */
599 	GET_OFFSET(svd_off, smb_server_t, sv_nbt_daemon);
600 	/*
601 	 * We can't do OFFSETOF() because the member doesn't exist,
602 	 * but we want backwards compatibility to old cores
603 	 */
604 	lds_off = mdb_ctf_offsetof_by_name("smb_listener_daemon_t",
605 	    "ld_session_list");
606 	if (lds_off < 0) {
607 		mdb_warn("cannot lookup: "
608 		    "smb_listener_daemon_t .ld_session_list");
609 		return (-1);
610 	}
611 	GET_OFFSET(ll_off, smb_llist_t, ll_list);
612 	return (svd_off + lds_off + ll_off);
613 }
614 
615 static int
smb_server_exp_off_tcp_list(void)616 smb_server_exp_off_tcp_list(void)
617 {
618 	int svd_off, lds_off, ll_off;
619 
620 	/* OFFSETOF(smb_server_t, sv_tcp_daemon.ld_session_list.ll_list); */
621 	GET_OFFSET(svd_off, smb_server_t, sv_tcp_daemon);
622 	/*
623 	 * We can't do OFFSETOF() because the member doesn't exist,
624 	 * but we want backwards compatibility to old cores
625 	 */
626 	lds_off = mdb_ctf_offsetof_by_name("smb_listener_daemon_t",
627 	    "ld_session_list");
628 	if (lds_off < 0) {
629 		mdb_warn("cannot lookup: "
630 		    "smb_listener_daemon_t .ld_session_list");
631 		return (-1);
632 	}
633 	GET_OFFSET(ll_off, smb_llist_t, ll_list);
634 	return (svd_off + lds_off + ll_off);
635 }
636 
637 /*
638  * List of objects that can be expanded under a server structure.
639  */
640 static const smb_exp_t smb_server_exp[] =
641 {
642 	{ SMB_OPT_ALL_OBJ,
643 	    smb_server_exp_off_sv_list,
644 	    "smbsess", "smb_session"},
645 	{ 0, 0, NULL, NULL }
646 };
647 
648 /* for backwards compatibility only */
649 static const smb_exp_t smb_server_exp_old[] =
650 {
651 	{ SMB_OPT_ALL_OBJ,
652 	    smb_server_exp_off_nbt_list,
653 	    "smbsess", "smb_session"},
654 	{ SMB_OPT_ALL_OBJ,
655 	    smb_server_exp_off_tcp_list,
656 	    "smbsess", "smb_session"},
657 	{ 0, 0, NULL, NULL }
658 };
659 
660 /*
661  * ::smbsrv
662  *
663  * smbsrv dcmd - Print out smb_server structures.
664  */
665 /*ARGSUSED*/
666 static int
smbsrv_dcmd(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)667 smbsrv_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
668 {
669 	uint_t		opts;
670 	ulong_t		indent = 0;
671 	const smb_exp_t	*sv_exp;
672 	mdb_ctf_id_t id;
673 	ulong_t off;
674 
675 	if (smb_dcmd_getopt(&opts, argc, argv))
676 		return (DCMD_USAGE);
677 
678 	if (!(flags & DCMD_ADDRSPEC))
679 		return (smb_obj_list("smb_server", opts | SMB_OPT_SERVER,
680 		    flags));
681 
682 	if (((opts & SMB_OPT_WALK) && (opts & SMB_OPT_SERVER)) ||
683 	    !(opts & SMB_OPT_WALK)) {
684 		mdb_smb_server_t *sv;
685 		char state[40];
686 
687 		sv = mdb_zalloc(sizeof (*sv), UM_SLEEP | UM_GC);
688 		if (mdb_ctf_vread(sv, SMBSRV_SCOPE "smb_server_t",
689 		    "mdb_smb_server_t", addr, 0) < 0) {
690 			mdb_warn("failed to read smb_server at %p", addr);
691 			return (DCMD_ERR);
692 		}
693 
694 		indent = SMB_DCMD_INDENT;
695 
696 		if (opts & SMB_OPT_VERBOSE) {
697 			mdb_arg_t	argv;
698 
699 			argv.a_type = MDB_TYPE_STRING;
700 			argv.a_un.a_str = "smb_server_t";
701 			if (mdb_call_dcmd("print", addr, flags, 1, &argv))
702 				return (DCMD_ERR);
703 		} else {
704 			if (DCMD_HDRSPEC(flags))
705 				mdb_printf(
706 				    "%<b>%<u>%-?s% "
707 				    "%-4s% "
708 				    "%-32s% "
709 				    "%</u>%</b>\n",
710 				    "SERVER", "ZONE", "STATE");
711 
712 			get_enum(state, sizeof (state),
713 			    "smb_server_state_t", sv->sv_state,
714 			    "SMB_SERVER_STATE_");
715 
716 			mdb_printf("%-?p %-4d %-32s \n",
717 			    addr, sv->sv_zid, state);
718 		}
719 	}
720 
721 	/* if we can't look up the type name, just error out */
722 	if (mdb_ctf_lookup_by_name("smb_server_t", &id) == -1)
723 		return (DCMD_ERR);
724 
725 	if (mdb_ctf_offsetof(id, "sv_session_list", &off) == -1)
726 		/* sv_session_list doesn't exist; old core */
727 		sv_exp = smb_server_exp_old;
728 	else
729 		sv_exp = smb_server_exp;
730 
731 	if (smb_obj_expand(addr, opts, sv_exp, indent))
732 		return (DCMD_ERR);
733 	return (DCMD_OK);
734 }
735 
736 /*
737  * *****************************************************************************
738  * ***************************** smb_session_t *********************************
739  * *****************************************************************************
740  */
741 
742 /*
743  * After some changes merged from upstream, "::smblist" was failing with
744  * "inexact match for union au_addr (au_addr)" because the CTF data for
745  * the target vs mdb were apparently not exactly the same (unknown why).
746  *
747  * As described above mdb_ctf_vread(), the recommended way to read a
748  * union is to use an mdb struct with only the union "arm" appropriate
749  * to the given type instance.  That's difficult in this case, so we
750  * use a local union with only the in6_addr_t union arm (otherwise
751  * identical to smb_inaddr_t) and just cast it to an smb_inaddr_t
752  */
753 
754 typedef struct mdb_smb_inaddr {
755 	union {
756 #if 0	/* The real smb_inaddr_t has these too. */
757 		in_addr_t au_ipv4;
758 		in6_addr_t au_ipv6;
759 #endif
760 		in6_addr_t au_ip;
761 	} au_addr;
762 	int a_family;
763 } mdb_smb_inaddr_t;
764 
765 typedef struct mdb_smb_session {
766 	uint64_t		s_kid;
767 	smb_session_state_t	s_state;
768 	uint32_t		s_flags;
769 	uint16_t		s_local_port;
770 	uint16_t		s_remote_port;
771 	mdb_smb_inaddr_t	ipaddr;
772 	mdb_smb_inaddr_t	local_ipaddr;
773 	int			dialect;
774 
775 	smb_slist_t		s_req_list;
776 	smb_llist_t		s_xa_list;
777 	smb_llist_t		s_user_list;
778 	smb_llist_t		s_tree_list;
779 
780 	volatile uint32_t	s_tree_cnt;
781 	volatile uint32_t	s_file_cnt;
782 	volatile uint32_t	s_dir_cnt;
783 
784 	char			workstation[SMB_PI_MAX_HOST];
785 } mdb_smb_session_t;
786 
787 static int
smb_session_exp_off_req_list(void)788 smb_session_exp_off_req_list(void)
789 {
790 	int rl_off, sl_off;
791 
792 	/* OFFSETOF(smb_session_t, s_req_list.sl_list); */
793 	GET_OFFSET(rl_off, smb_session_t, s_req_list);
794 	GET_OFFSET(sl_off, smb_slist_t, sl_list);
795 	return (rl_off + sl_off);
796 }
797 
798 static int
smb_session_exp_off_user_list(void)799 smb_session_exp_off_user_list(void)
800 {
801 	int ul_off, ll_off;
802 
803 	/* OFFSETOF(smb_session_t, s_user_list.ll_list); */
804 	GET_OFFSET(ul_off, smb_session_t, s_user_list);
805 	GET_OFFSET(ll_off, smb_llist_t, ll_list);
806 	return (ul_off + ll_off);
807 }
808 
809 static int
smb_session_exp_off_tree_list(void)810 smb_session_exp_off_tree_list(void)
811 {
812 	int tl_off, ll_off;
813 
814 	/* OFFSETOF(smb_session_t, s_tree_list.ll_list); */
815 	GET_OFFSET(tl_off, smb_session_t, s_tree_list);
816 	GET_OFFSET(ll_off, smb_llist_t, ll_list);
817 	return (tl_off + ll_off);
818 }
819 
820 /*
821  * List of objects that can be expanded under a session structure.
822  */
823 static const smb_exp_t smb_session_exp[] =
824 {
825 	{ SMB_OPT_USER,
826 	    smb_session_exp_off_user_list,
827 	    "smbuser", "smb_user"},
828 	{ SMB_OPT_TREE | SMB_OPT_OFILE | SMB_OPT_ODIR,
829 	    smb_session_exp_off_tree_list,
830 	    "smbtree", "smb_tree"},
831 	{ SMB_OPT_REQUEST,
832 	    smb_session_exp_off_req_list,
833 	    "smbreq", "smb_request"},
834 	{ 0, 0, NULL, NULL}
835 };
836 
837 static void
smbsess_help(void)838 smbsess_help(void)
839 {
840 	mdb_printf(
841 	    "Display the contents of smb_session_t, with optional"
842 	    " filtering.\n\n");
843 	(void) mdb_dec_indent(2);
844 	mdb_printf("%<b>OPTIONS%</b>\n");
845 	(void) mdb_inc_indent(2);
846 	mdb_printf(
847 	    "-v\tDisplay verbose smb_session information\n"
848 	    "-r\tDisplay the list of smb requests attached\n"
849 	    "-u\tDisplay the list of users attached\n");
850 }
851 
852 /*
853  * ::smbsess
854  *
855  * smbsess dcmd - Print out the smb_session structure.
856  */
857 static int
smbsess_dcmd(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)858 smbsess_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
859 {
860 	uint_t		opts;
861 	ulong_t		indent = 0;
862 
863 	if (smb_dcmd_getopt(&opts, argc, argv))
864 		return (DCMD_USAGE);
865 
866 	if (!(flags & DCMD_ADDRSPEC)) {
867 		opts |= SMB_OPT_SESSION;
868 		opts &= ~SMB_OPT_SERVER;
869 		return (smb_obj_list("smb_session", opts, flags));
870 	}
871 
872 	if (((opts & SMB_OPT_WALK) && (opts & SMB_OPT_SESSION)) ||
873 	    !(opts & SMB_OPT_WALK)) {
874 		char	cipaddr[INET6_ADDRSTRLEN];
875 		char	lipaddr[INET6_ADDRSTRLEN];
876 		int	ipaddrstrlen = INET6_ADDRSTRLEN;
877 		mdb_smb_session_t *se;
878 		char	state[40];
879 
880 		indent = SMB_DCMD_INDENT;
881 
882 		se = mdb_zalloc(sizeof (*se), UM_SLEEP | UM_GC);
883 		if (mdb_ctf_vread(se, SMBSRV_SCOPE "smb_session_t",
884 		    "mdb_smb_session_t", addr, 0) < 0) {
885 			mdb_warn("failed to read smb_session at %p", addr);
886 			return (DCMD_ERR);
887 		}
888 
889 		get_enum(state, sizeof (state),
890 		    "smb_session_state_t", se->s_state,
891 		    "SMB_SESSION_STATE_");
892 
893 		smb_inaddr_ntop((smb_inaddr_t *)&se->ipaddr,
894 		    cipaddr, ipaddrstrlen);
895 		smb_inaddr_ntop((smb_inaddr_t *)&se->local_ipaddr,
896 		    lipaddr, ipaddrstrlen);
897 
898 		if (opts & SMB_OPT_VERBOSE) {
899 			mdb_printf("%<b>%<u>SMB session information "
900 			    "(%p): %</u>%</b>\n", addr);
901 			mdb_printf("Client IP address: %s %d\n",
902 			    cipaddr, se->s_remote_port);
903 			mdb_printf("Local IP Address: %s %d\n",
904 			    lipaddr, se->s_local_port);
905 			mdb_printf("Session KID: %u\n", se->s_kid);
906 			mdb_printf("Workstation Name: %s\n",
907 			    se->workstation);
908 			mdb_printf("Session state: %u (%s)\n", se->s_state,
909 			    state);
910 			mdb_printf("Session dialect: %#x\n", se->dialect);
911 			mdb_printf("Number of Users: %u\n",
912 			    se->s_user_list.ll_count);
913 			mdb_printf("Number of Trees: %u\n", se->s_tree_cnt);
914 			mdb_printf("Number of Files: %u\n", se->s_file_cnt);
915 			mdb_printf("Number of Shares: %u\n", se->s_dir_cnt);
916 			mdb_printf("Number of active Transact.: %u\n\n",
917 			    se->s_xa_list.ll_count);
918 		} else {
919 			/*
920 			 * Use a reasonable mininum field width for the
921 			 * IP addr so the summary (usually) won't wrap.
922 			 */
923 			int ipwidth = 22;
924 
925 			if (DCMD_HDRSPEC(flags)) {
926 				mdb_printf(
927 			"%<b>%<u>%-?s %-*s %-8s %-8s %-12s%</u>%</b>\n",
928 				    "SESSION", ipwidth, "IP_ADDR",
929 				    "PORT", "DIALECT", "STATE");
930 			}
931 			mdb_printf("%-?p %-*s %-8d %-8#x %s\n",
932 			    addr, ipwidth, cipaddr,
933 			    se->s_remote_port, se->dialect, state);
934 		}
935 	}
936 	if (smb_obj_expand(addr, opts, smb_session_exp, indent))
937 		return (DCMD_ERR);
938 
939 	return (DCMD_OK);
940 }
941 
942 /*
943  * *****************************************************************************
944  * **************************** smb_request_t **********************************
945  * *****************************************************************************
946  */
947 
948 typedef struct mdb_smb_request {
949 	smb_req_state_t		sr_state;
950 	smb_session_t		*session;
951 	struct mbuf_chain	command;
952 	struct mbuf_chain	reply;
953 
954 	unsigned char		first_smb_com;
955 	unsigned char		smb_com;
956 
957 	uint16_t		smb_tid;
958 	uint32_t		smb_pid;
959 	uint16_t		smb_uid;
960 	uint16_t		smb_mid;
961 	uint16_t		smb_fid;
962 
963 	uint16_t		smb2_cmd_code;
964 	uint64_t		smb2_messageid;
965 	uint64_t		smb2_ssnid;
966 
967 	struct smb_tree		*tid_tree;
968 	struct smb_ofile	*fid_ofile;
969 	smb_user_t		*uid_user;
970 
971 	kthread_t		*sr_worker;
972 	hrtime_t		sr_time_submitted;
973 	hrtime_t		sr_time_active;
974 	hrtime_t		sr_time_start;
975 
976 } mdb_smb_request_t;
977 
978 #define	SMB_REQUEST_BANNER	\
979 	"%<b>%<u>%-?s %-14s %-?s %-16s %-16s%</u>%</b>\n"
980 #define	SMB_REQUEST_FORMAT	\
981 	"%-?p 0x%-12llx %-?p %-16s %s\n"
982 
983 /*
984  * ::smbreq
985  *
986  * smbreq dcmd - Print out smb_request_t
987  */
988 static int
smbreq_dcmd(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)989 smbreq_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
990 {
991 	uint_t		opts;
992 
993 	if (smb_dcmd_getopt(&opts, argc, argv))
994 		return (DCMD_USAGE);
995 
996 	if (!(flags & DCMD_ADDRSPEC)) {
997 		opts |= SMB_OPT_REQUEST;
998 		opts &= ~(SMB_OPT_SERVER | SMB_OPT_SESSION | SMB_OPT_USER);
999 		return (smb_obj_list("smb_request", opts, flags));
1000 	}
1001 
1002 	if (((opts & SMB_OPT_WALK) && (opts & SMB_OPT_REQUEST)) ||
1003 	    !(opts & SMB_OPT_WALK)) {
1004 		mdb_smb_request_t *sr;
1005 		char		state[40];
1006 		const char	*cur_cmd_name;
1007 		uint_t		cur_cmd_code;
1008 		uint64_t	msg_id;
1009 
1010 		sr = mdb_zalloc(sizeof (*sr), UM_SLEEP | UM_GC);
1011 		if (mdb_ctf_vread(sr, SMBSRV_SCOPE "smb_request_t",
1012 		    "mdb_smb_request_t", addr, 0) < 0) {
1013 			mdb_warn("failed to read smb_request at %p", addr);
1014 			return (DCMD_ERR);
1015 		}
1016 
1017 		get_enum(state, sizeof (state),
1018 		    "smb_req_state_t", sr->sr_state,
1019 		    "SMB_REQ_STATE_");
1020 
1021 		if (sr->smb2_cmd_code != 0) {
1022 			/* SMB2 request */
1023 			cur_cmd_code = sr->smb2_cmd_code;
1024 			if (cur_cmd_code > SMB2_INVALID_CMD)
1025 				cur_cmd_code = SMB2_INVALID_CMD;
1026 			cur_cmd_name = smb2_cmd_names[cur_cmd_code];
1027 			msg_id = sr->smb2_messageid;
1028 		} else {
1029 			/* SMB1 request */
1030 			cur_cmd_code = sr->smb_com & 0xFF;
1031 			cur_cmd_name = smb_com[cur_cmd_code].smb_com;
1032 			msg_id = sr->smb_mid;
1033 		}
1034 
1035 		if (opts & SMB_OPT_VERBOSE) {
1036 			mdb_printf(
1037 			    "%</b>%</u>SMB request information (%p):"
1038 			    "%</u>%</b>\n\n", addr);
1039 
1040 			if (sr->smb2_cmd_code == 0) {
1041 				/* SMB1 request */
1042 				mdb_printf(
1043 				    "first SMB COM: %u (%s)\n",
1044 				    sr->first_smb_com,
1045 				    smb_com[sr->first_smb_com].smb_com);
1046 			}
1047 
1048 			mdb_printf(
1049 			    "current SMB COM: %u (%s)\n",
1050 			    cur_cmd_code, cur_cmd_name);
1051 
1052 			mdb_printf(
1053 			    "state: %u (%s)\n",
1054 			    sr->sr_state, state);
1055 
1056 			if (sr->smb2_ssnid != 0) {
1057 				mdb_printf(
1058 				    "SSNID(user): 0x%llx (%p)\n",
1059 				    sr->smb2_ssnid, sr->uid_user);
1060 			} else {
1061 				mdb_printf(
1062 				    "UID(user): %u (%p)\n",
1063 				    sr->smb_uid, sr->uid_user);
1064 			}
1065 
1066 			mdb_printf(
1067 			    "TID(tree): %u (%p)\n",
1068 			    sr->smb_tid, sr->tid_tree);
1069 
1070 			mdb_printf(
1071 			    "FID(file): %u (%p)\n",
1072 			    sr->smb_fid, sr->fid_ofile);
1073 
1074 			mdb_printf(
1075 			    "PID: %u\n",
1076 			    sr->smb_pid);
1077 
1078 			mdb_printf(
1079 			    "MID: 0x%llx\n",
1080 			    msg_id);
1081 
1082 			/*
1083 			 * Note: mdb_gethrtime() is only available in kmdb
1084 			 */
1085 #ifdef	_KERNEL
1086 			if (sr->sr_time_submitted != 0) {
1087 				uint64_t	waiting = 0;
1088 				uint64_t	running = 0;
1089 
1090 				if (sr->sr_time_active != 0) {
1091 					waiting = sr->sr_time_active -
1092 					    sr->sr_time_submitted;
1093 					running = mdb_gethrtime() -
1094 					    sr->sr_time_active;
1095 				} else {
1096 					waiting = mdb_gethrtime() -
1097 					    sr->sr_time_submitted;
1098 				}
1099 				waiting /= NANOSEC;
1100 				running /= NANOSEC;
1101 
1102 				mdb_printf(
1103 				    "waiting time: %lld\n",
1104 				    waiting);
1105 
1106 				mdb_printf(
1107 				    "running time: %lld\n",
1108 				    running);
1109 			}
1110 #endif	/* _KERNEL */
1111 
1112 			mdb_printf(
1113 			    "worker thread: %p\n",
1114 			    sr->sr_worker);
1115 			if (sr->sr_worker != NULL) {
1116 				smb_worker_findstack((uintptr_t)sr->sr_worker);
1117 			}
1118 		} else {
1119 			if (DCMD_HDRSPEC(flags))
1120 				mdb_printf(
1121 				    SMB_REQUEST_BANNER,
1122 				    "REQUEST",
1123 				    "MSG_ID",
1124 				    "WORKER",
1125 				    "STATE",
1126 				    "COMMAND");
1127 
1128 			mdb_printf(
1129 			    SMB_REQUEST_FORMAT,
1130 			    addr,
1131 			    msg_id,
1132 			    sr->sr_worker,
1133 			    state,
1134 			    cur_cmd_name);
1135 		}
1136 	}
1137 	return (DCMD_OK);
1138 }
1139 
1140 static void
smbreq_dump_help(void)1141 smbreq_dump_help(void)
1142 {
1143 	mdb_printf(
1144 	    "Dump the network data for an smb_request_t, either"
1145 	    " command, reply, or (by default) both.  Optionally"
1146 	    " append data to a pcap file (mdb only, not kmdb).\n\n");
1147 	(void) mdb_dec_indent(2);
1148 	mdb_printf("%<b>OPTIONS%</b>\n");
1149 	(void) mdb_inc_indent(2);
1150 	mdb_printf(
1151 	    "-c\tDump only the SMB command message\n"
1152 	    "-r\tDump only the SMB reply message (if present)\n"
1153 	    "-o FILE\tOutput to FILE (append) in pcap format\n");
1154 }
1155 
1156 #define	SMB_RDOPT_COMMAND	1
1157 #define	SMB_RDOPT_REPLY		2
1158 #define	SMB_RDOPT_OUTFILE	4
1159 
1160 /*
1161  * Like "smbreq" but just dump the command/reply messages.
1162  * With the output file option, append to a pcap file.
1163  */
1164 static int
smbreq_dump_dcmd(uintptr_t rqaddr,uint_t flags,int argc,const mdb_arg_t * argv)1165 smbreq_dump_dcmd(uintptr_t rqaddr, uint_t flags, int argc,
1166     const mdb_arg_t *argv)
1167 {
1168 	mdb_smb_session_t *ssn;
1169 	mdb_smb_request_t *sr;
1170 	char		*outfile = NULL;
1171 	dump_func_t	dump_func;
1172 	uint64_t	msgid;
1173 	uintptr_t	ssnaddr;
1174 	uint_t		opts = 0;
1175 	int		rc = DCMD_OK;
1176 
1177 	if (!(flags & DCMD_ADDRSPEC))
1178 		return (DCMD_USAGE);
1179 
1180 	if (mdb_getopts(argc, argv,
1181 	    'c', MDB_OPT_SETBITS, SMB_RDOPT_COMMAND, &opts,
1182 	    'r', MDB_OPT_SETBITS, SMB_RDOPT_REPLY, &opts,
1183 	    'o', MDB_OPT_STR, &outfile,
1184 	    NULL) != argc)
1185 		return (DCMD_USAGE);
1186 #ifdef	_KMDB
1187 	if (outfile != NULL) {
1188 		mdb_warn("smbreq_dump -o option not supported in kmdb\n");
1189 		return (DCMD_ERR);
1190 	}
1191 #endif	/* _KMDB */
1192 
1193 	/*
1194 	 * Default without -c or -r is to dump both.
1195 	 */
1196 	if ((opts & (SMB_RDOPT_COMMAND | SMB_RDOPT_REPLY)) == 0)
1197 		opts |= SMB_RDOPT_COMMAND | SMB_RDOPT_REPLY;
1198 
1199 	/*
1200 	 * Get the smb_request_t, for the cmd/reply messages.
1201 	 */
1202 	sr = mdb_zalloc(sizeof (*sr), UM_SLEEP | UM_GC);
1203 	if (mdb_ctf_vread(sr, SMBSRV_SCOPE "smb_request_t",
1204 	    "mdb_smb_request_t", rqaddr, 0) < 0) {
1205 		mdb_warn("failed to read smb_request at %p", rqaddr);
1206 		return (DCMD_ERR);
1207 	}
1208 
1209 	/*
1210 	 * Get the session too, for the IP addresses & ports.
1211 	 */
1212 	ssnaddr = (uintptr_t)sr->session;
1213 	ssn = mdb_zalloc(sizeof (*ssn), UM_SLEEP | UM_GC);
1214 	if (mdb_ctf_vread(ssn, SMBSRV_SCOPE "smb_session_t",
1215 	    "mdb_smb_session_t", ssnaddr, 0) < 0) {
1216 		mdb_warn("failed to read smb_request at %p", ssnaddr);
1217 		return (DCMD_ERR);
1218 	}
1219 
1220 #ifndef	_KMDB
1221 	if (outfile != NULL) {
1222 		rc = smbsrv_pcap_open(outfile);
1223 		if (rc != DCMD_OK)
1224 			return (rc);
1225 		dump_func = smbsrv_pcap_dump;
1226 	} else
1227 #endif	/* _KMDB */
1228 	{
1229 		dump_func = smb_req_dump;
1230 	}
1231 
1232 	if (sr->smb2_messageid != 0)
1233 		msgid = sr->smb2_messageid;
1234 	else
1235 		msgid = sr->smb_mid;
1236 	mdb_printf("Dumping request %-?p, Msg_ID 0x%llx\n",
1237 	    rqaddr, msgid);
1238 
1239 	if (opts & SMB_RDOPT_COMMAND) {
1240 		/*
1241 		 * Dump the command, length=max_bytes
1242 		 * src=remote, dst=local
1243 		 */
1244 		rc = dump_func(&sr->command, sr->command.max_bytes,
1245 		    (smb_inaddr_t *)&ssn->ipaddr, ssn->s_remote_port,
1246 		    (smb_inaddr_t *)&ssn->local_ipaddr, ssn->s_local_port,
1247 		    sr->sr_time_submitted, B_FALSE);
1248 	}
1249 
1250 	if ((opts & SMB_RDOPT_REPLY) != 0 &&
1251 	    rc == DCMD_OK) {
1252 		/*
1253 		 * Dump the reply, length=chain_offset
1254 		 * src=local, dst=remote
1255 		 */
1256 		rc = dump_func(&sr->reply, sr->reply.chain_offset,
1257 		    (smb_inaddr_t *)&ssn->local_ipaddr, ssn->s_local_port,
1258 		    (smb_inaddr_t *)&ssn->ipaddr, ssn->s_remote_port,
1259 		    sr->sr_time_start, B_TRUE);
1260 	}
1261 
1262 #ifndef	_KMDB
1263 	if (outfile != NULL) {
1264 		smbsrv_pcap_close();
1265 	}
1266 #endif
1267 
1268 	return (DCMD_OK);
1269 }
1270 
1271 struct req_dump_state {
1272 	int32_t rem_len;
1273 };
1274 
1275 static int
smb_req_dump(struct mbuf_chain * mbc,int32_t smb_len,smb_inaddr_t * src_ip,uint16_t src_port,smb_inaddr_t * dst_ip,uint16_t dst_port,hrtime_t rqtime,boolean_t is_reply)1276 smb_req_dump(struct mbuf_chain *mbc, int32_t smb_len,
1277     smb_inaddr_t *src_ip, uint16_t src_port,
1278     smb_inaddr_t *dst_ip, uint16_t dst_port,
1279     hrtime_t rqtime, boolean_t is_reply)
1280 {
1281 	char	src_buf[INET6_ADDRSTRLEN];
1282 	char	dst_buf[INET6_ADDRSTRLEN];
1283 	struct req_dump_state dump_state;
1284 	_NOTE(ARGUNUSED(rqtime));
1285 
1286 	if (smb_len < 4)
1287 		return (DCMD_OK);
1288 	if (mbc->chain == NULL)
1289 		return (DCMD_ERR);
1290 
1291 	smb_inaddr_ntop(src_ip, src_buf, sizeof (src_buf));
1292 	smb_inaddr_ntop(dst_ip, dst_buf, sizeof (dst_buf));
1293 
1294 	mdb_printf("%-8s SRC: %s/%u  DST: %s/%u  LEN: %u\n",
1295 	    (is_reply) ? "Reply:" : "Call:",
1296 	    src_buf, src_port, dst_buf, dst_port, smb_len);
1297 
1298 	/*
1299 	 * Calling "smb_mbuf_dump" with a wrapper function
1300 	 * so we can set its length arg, and decrement
1301 	 * req_dump_state.rem_len as it goes.
1302 	 */
1303 	dump_state.rem_len = smb_len;
1304 	if (mdb_pwalk("smb_mbuf_walker", smb_req_dump_m,
1305 	    &dump_state, (uintptr_t)mbc->chain) == -1) {
1306 		mdb_warn("cannot walk smb_req mbuf_chain");
1307 		return (DCMD_ERR);
1308 	}
1309 	return (DCMD_OK);
1310 }
1311 
1312 static int
smb_req_dump_m(uintptr_t m_addr,const void * data,void * arg)1313 smb_req_dump_m(uintptr_t m_addr, const void *data, void *arg)
1314 {
1315 	struct req_dump_state *st = arg;
1316 	const struct mbuf *m = data;
1317 	mdb_arg_t	argv;
1318 	int cnt;
1319 
1320 	cnt = st->rem_len;
1321 	if (cnt > m->m_len)
1322 		cnt = m->m_len;
1323 	if (cnt <= 0)
1324 		return (WALK_DONE);
1325 
1326 	argv.a_type = MDB_TYPE_IMMEDIATE;
1327 	argv.a_un.a_val = cnt;
1328 	if (mdb_call_dcmd("smb_mbuf_dump", m_addr, 0, 1, &argv) < 0) {
1329 		mdb_warn("%p::smb_mbuf_dump failed\n", m_addr);
1330 		return (WALK_ERR);
1331 	}
1332 
1333 	st->rem_len -= cnt;
1334 	return (WALK_NEXT);
1335 }
1336 
1337 /*
1338  * *****************************************************************************
1339  * ****************************** smb_user_t ***********************************
1340  * *****************************************************************************
1341  */
1342 typedef struct mdb_smb_user {
1343 	smb_user_state_t	u_state;
1344 
1345 	struct smb_server	*u_server;
1346 	smb_session_t		*u_session;
1347 
1348 	uint16_t		u_name_len;
1349 	char			*u_name;
1350 	uint16_t		u_domain_len;
1351 	char			*u_domain;
1352 	time_t			u_logon_time;
1353 	cred_t			*u_cred;
1354 	cred_t			*u_privcred;
1355 
1356 	uint64_t		u_ssnid;
1357 	uint32_t		u_refcnt;
1358 	uint32_t		u_flags;
1359 	uint32_t		u_privileges;
1360 	uint16_t		u_uid;
1361 } mdb_smb_user_t;
1362 
1363 static const mdb_bitmask_t
1364 user_flag_bits[] = {
1365 	{ "ANON",
1366 	    SMB_USER_FLAG_ANON,
1367 	    SMB_USER_FLAG_ANON },
1368 	{ "GUEST",
1369 	    SMB_USER_FLAG_GUEST,
1370 	    SMB_USER_FLAG_GUEST },
1371 	{ "POWER_USER",
1372 	    SMB_USER_FLAG_POWER_USER,
1373 	    SMB_USER_FLAG_POWER_USER },
1374 	{ "BACKUP_OP",
1375 	    SMB_USER_FLAG_BACKUP_OPERATOR,
1376 	    SMB_USER_FLAG_BACKUP_OPERATOR },
1377 	{ "ADMIN",
1378 	    SMB_USER_FLAG_ADMIN,
1379 	    SMB_USER_FLAG_ADMIN },
1380 	{ NULL, 0, 0 }
1381 };
1382 
1383 static const mdb_bitmask_t
1384 user_priv_bits[] = {
1385 	/*
1386 	 * Old definitions of these bits, for when we're
1387 	 * looking at an older core file.  These happen to
1388 	 * have no overlap with the current definitions.
1389 	 */
1390 	{ "TAKE_OWNER",	1, 1 },
1391 	{ "BACKUP",	2, 2 },
1392 	{ "RESTORE",	4, 4 },
1393 	{ "SECURITY",	8, 8 },
1394 	/*
1395 	 * Current definitions
1396 	 */
1397 	{ "SECURITY",
1398 	    SMB_USER_PRIV_SECURITY,
1399 	    SMB_USER_PRIV_SECURITY },
1400 	{ "TAKE_OWNER",
1401 	    SMB_USER_PRIV_TAKE_OWNERSHIP,
1402 	    SMB_USER_PRIV_TAKE_OWNERSHIP },
1403 	{ "BACKUP",
1404 	    SMB_USER_PRIV_BACKUP,
1405 	    SMB_USER_PRIV_BACKUP },
1406 	{ "RESTORE",
1407 	    SMB_USER_PRIV_RESTORE,
1408 	    SMB_USER_PRIV_RESTORE },
1409 	{ "CHANGE_NOTIFY",
1410 	    SMB_USER_PRIV_CHANGE_NOTIFY,
1411 	    SMB_USER_PRIV_CHANGE_NOTIFY },
1412 	{ "READ_FILE",
1413 	    SMB_USER_PRIV_READ_FILE,
1414 	    SMB_USER_PRIV_READ_FILE },
1415 	{ "WRITE_FILE",
1416 	    SMB_USER_PRIV_WRITE_FILE,
1417 	    SMB_USER_PRIV_WRITE_FILE },
1418 	{ NULL, 0, 0 }
1419 };
1420 
1421 static void
smbuser_help(void)1422 smbuser_help(void)
1423 {
1424 	mdb_printf(
1425 	    "Display the contents of smb_user_t, with optional filtering.\n\n");
1426 	(void) mdb_dec_indent(2);
1427 	mdb_printf("%<b>OPTIONS%</b>\n");
1428 	(void) mdb_inc_indent(2);
1429 	mdb_printf(
1430 	    "-v\tDisplay verbose smb_user information\n");
1431 }
1432 
1433 static int
smbuser_dcmd(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)1434 smbuser_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1435 {
1436 	uint_t		opts;
1437 
1438 	if (smb_dcmd_getopt(&opts, argc, argv))
1439 		return (DCMD_USAGE);
1440 
1441 	if (!(flags & DCMD_ADDRSPEC)) {
1442 		opts |= SMB_OPT_USER;
1443 		opts &= ~(SMB_OPT_SERVER | SMB_OPT_SESSION | SMB_OPT_REQUEST);
1444 		return (smb_obj_list("smb_user", opts, flags));
1445 	}
1446 
1447 	if (((opts & SMB_OPT_WALK) && (opts & SMB_OPT_USER)) ||
1448 	    !(opts & SMB_OPT_WALK)) {
1449 		mdb_smb_user_t	*user;
1450 		char		*account;
1451 
1452 		user = mdb_zalloc(sizeof (*user), UM_SLEEP | UM_GC);
1453 		if (mdb_ctf_vread(user, SMBSRV_SCOPE "smb_user_t",
1454 		    "mdb_smb_user_t", addr, 0) < 0) {
1455 			mdb_warn("failed to read smb_user at %p", addr);
1456 			return (DCMD_ERR);
1457 		}
1458 		account = mdb_zalloc(user->u_domain_len + user->u_name_len + 2,
1459 		    UM_SLEEP | UM_GC);
1460 
1461 		if (user->u_domain_len)
1462 			(void) mdb_vread(account, user->u_domain_len,
1463 			    (uintptr_t)user->u_domain);
1464 
1465 		strcat(account, "\\");
1466 
1467 		if (user->u_name_len)
1468 			(void) mdb_vread(account + strlen(account),
1469 			    user->u_name_len, (uintptr_t)user->u_name);
1470 
1471 		if (opts & SMB_OPT_VERBOSE) {
1472 			char		state[40];
1473 
1474 			get_enum(state, sizeof (state),
1475 			    "smb_user_state_t", user->u_state,
1476 			    "SMB_USER_STATE_");
1477 
1478 			mdb_printf("%<b>%<u>SMB user information (%p):"
1479 			    "%</u>%</b>\n", addr);
1480 			mdb_printf("UID: %u\n", user->u_uid);
1481 			mdb_printf("SSNID: %llx\n", user->u_ssnid);
1482 			mdb_printf("State: %d (%s)\n", user->u_state, state);
1483 			mdb_printf("Flags: 0x%08x <%b>\n", user->u_flags,
1484 			    user->u_flags, user_flag_bits);
1485 			mdb_printf("Privileges: 0x%08x <%b>\n",
1486 			    user->u_privileges,
1487 			    user->u_privileges, user_priv_bits);
1488 			mdb_printf("Credential: %p\n", user->u_cred);
1489 			mdb_printf("Reference Count: %d\n", user->u_refcnt);
1490 			mdb_printf("User Account: %s\n\n", account);
1491 		} else {
1492 			if (DCMD_HDRSPEC(flags))
1493 				mdb_printf(
1494 				    "%<b>%<u>%?-s "
1495 				    "%-5s "
1496 				    "%-16s "
1497 				    "%-32s%</u>%</b>\n",
1498 				    "USER", "UID", "SSNID", "ACCOUNT");
1499 
1500 			mdb_printf("%-?p %-5u %-16llx %-32s\n",
1501 			    addr, user->u_uid, user->u_ssnid, account);
1502 		}
1503 	}
1504 	return (DCMD_OK);
1505 }
1506 
1507 /*
1508  * *****************************************************************************
1509  * ****************************** smb_tree_t ***********************************
1510  * *****************************************************************************
1511  */
1512 
1513 typedef struct mdb_smb_tree {
1514 	smb_tree_state_t	t_state;
1515 
1516 	smb_node_t		*t_snode;
1517 	smb_llist_t		t_ofile_list;
1518 	smb_llist_t		t_odir_list;
1519 
1520 	uint32_t		t_refcnt;
1521 	uint32_t		t_flags;
1522 	int32_t			t_res_type;
1523 	uint16_t		t_tid;
1524 	uint16_t		t_umask;
1525 	char			t_sharename[MAXNAMELEN];
1526 	char			t_resource[MAXPATHLEN];
1527 	char			t_typename[SMB_TYPENAMELEN];
1528 	char			t_volume[SMB_VOLNAMELEN];
1529 } mdb_smb_tree_t;
1530 
1531 static int
smb_tree_exp_off_ofile_list(void)1532 smb_tree_exp_off_ofile_list(void)
1533 {
1534 	int tf_off, ll_off;
1535 
1536 	/* OFFSETOF(smb_tree_t, t_ofile_list.ll_list); */
1537 	GET_OFFSET(tf_off, smb_tree_t, t_ofile_list);
1538 	GET_OFFSET(ll_off, smb_llist_t, ll_list);
1539 	return (tf_off + ll_off);
1540 }
1541 
1542 static int
smb_tree_exp_off_odir_list(void)1543 smb_tree_exp_off_odir_list(void)
1544 {
1545 	int td_off, ll_off;
1546 
1547 	/* OFFSETOF(smb_tree_t, t_odir_list.ll_list); */
1548 	GET_OFFSET(td_off, smb_tree_t, t_odir_list);
1549 	GET_OFFSET(ll_off, smb_llist_t, ll_list);
1550 	return (td_off + ll_off);
1551 }
1552 
1553 /*
1554  * List of objects that can be expanded under a tree structure.
1555  */
1556 static const smb_exp_t smb_tree_exp[] =
1557 {
1558 	{ SMB_OPT_OFILE,
1559 	    smb_tree_exp_off_ofile_list,
1560 	    "smbofile", "smb_ofile"},
1561 	{ SMB_OPT_ODIR,
1562 	    smb_tree_exp_off_odir_list,
1563 	    "smbodir", "smb_odir"},
1564 	{ 0, 0, NULL, NULL}
1565 };
1566 
1567 static const mdb_bitmask_t
1568 tree_flag_bits[] = {
1569 	{ "RO",
1570 	    SMB_TREE_READONLY,
1571 	    SMB_TREE_READONLY },
1572 	{ "ACLS",
1573 	    SMB_TREE_SUPPORTS_ACLS,
1574 	    SMB_TREE_SUPPORTS_ACLS },
1575 	{ "STREAMS",
1576 	    SMB_TREE_STREAMS,
1577 	    SMB_TREE_STREAMS },
1578 	{ "CI",
1579 	    SMB_TREE_CASEINSENSITIVE,
1580 	    SMB_TREE_CASEINSENSITIVE },
1581 	{ "NO_CS",
1582 	    SMB_TREE_NO_CASESENSITIVE,
1583 	    SMB_TREE_NO_CASESENSITIVE },
1584 	{ "NO_EXPORT",
1585 	    SMB_TREE_NO_EXPORT,
1586 	    SMB_TREE_NO_EXPORT },
1587 	{ "OPLOCKS",
1588 	    SMB_TREE_OPLOCKS,
1589 	    SMB_TREE_OPLOCKS },
1590 	{ "SHORTNAMES",
1591 	    SMB_TREE_SHORTNAMES,
1592 	    SMB_TREE_SHORTNAMES },
1593 	{ "XVATTR",
1594 	    SMB_TREE_XVATTR,
1595 	    SMB_TREE_XVATTR },
1596 	{ "DIRENTFLAGS",
1597 	    SMB_TREE_DIRENTFLAGS,
1598 	    SMB_TREE_DIRENTFLAGS },
1599 	{ "ACL_CR",
1600 	    SMB_TREE_ACLONCREATE,
1601 	    SMB_TREE_ACLONCREATE },
1602 	{ "ACEMASK",
1603 	    SMB_TREE_ACEMASKONACCESS,
1604 	    SMB_TREE_ACEMASKONACCESS },
1605 	{ "NFS_MNT",
1606 	    SMB_TREE_NFS_MOUNTED,
1607 	    SMB_TREE_NFS_MOUNTED },
1608 	{ "UNICODE",
1609 	    SMB_TREE_UNICODE_ON_DISK,
1610 	    SMB_TREE_UNICODE_ON_DISK },
1611 	{ "CATIA",
1612 	    SMB_TREE_CATIA,
1613 	    SMB_TREE_CATIA },
1614 	{ "ABE",
1615 	    SMB_TREE_ABE,
1616 	    SMB_TREE_ABE },
1617 	{ "QUOTA",
1618 	    SMB_TREE_QUOTA,
1619 	    SMB_TREE_QUOTA },
1620 	{ "DFSROOT",
1621 	    SMB_TREE_DFSROOT,
1622 	    SMB_TREE_DFSROOT },
1623 	{ "SPARSE",
1624 	    SMB_TREE_SPARSE,
1625 	    SMB_TREE_SPARSE },
1626 	{ "XMOUNTS",
1627 	    SMB_TREE_TRAVERSE_MOUNTS,
1628 	    SMB_TREE_TRAVERSE_MOUNTS },
1629 	{ "FORCE_L2_OPLOCK",
1630 	    SMB_TREE_FORCE_L2_OPLOCK,
1631 	    SMB_TREE_FORCE_L2_OPLOCK },
1632 	{ "CA",
1633 	    SMB_TREE_CA,
1634 	    SMB_TREE_CA },
1635 	{ NULL, 0, 0 }
1636 };
1637 
1638 static void
smbtree_help(void)1639 smbtree_help(void)
1640 {
1641 	mdb_printf(
1642 	    "Display the contents of smb_tree_t, with optional filtering.\n\n");
1643 	(void) mdb_dec_indent(2);
1644 	mdb_printf("%<b>OPTIONS%</b>\n");
1645 	(void) mdb_inc_indent(2);
1646 	mdb_printf(
1647 	    "-v\tDisplay verbose smb_tree information\n"
1648 	    "-d\tDisplay the list of smb_odirs attached\n"
1649 	    "-f\tDisplay the list of smb_ofiles attached\n");
1650 }
1651 
1652 static int
smbtree_dcmd(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)1653 smbtree_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1654 {
1655 	uint_t		opts;
1656 	ulong_t		indent = 0;
1657 
1658 	if (smb_dcmd_getopt(&opts, argc, argv))
1659 		return (DCMD_USAGE);
1660 
1661 	if (!(flags & DCMD_ADDRSPEC)) {
1662 		opts |= SMB_OPT_TREE;
1663 		opts &= ~(SMB_OPT_SERVER | SMB_OPT_SESSION | SMB_OPT_REQUEST |
1664 		    SMB_OPT_USER);
1665 		return (smb_obj_list("smb_tree", opts, flags));
1666 	}
1667 
1668 	if (((opts & SMB_OPT_WALK) && (opts & SMB_OPT_TREE)) ||
1669 	    !(opts & SMB_OPT_WALK)) {
1670 		mdb_smb_tree_t *tree;
1671 
1672 		indent = SMB_DCMD_INDENT;
1673 
1674 		tree = mdb_zalloc(sizeof (*tree), UM_SLEEP | UM_GC);
1675 		if (mdb_ctf_vread(tree, SMBSRV_SCOPE "smb_tree_t",
1676 		    "mdb_smb_tree_t", addr, 0) < 0) {
1677 			mdb_warn("failed to read smb_tree at %p", addr);
1678 			return (DCMD_ERR);
1679 		}
1680 		if (opts & SMB_OPT_VERBOSE) {
1681 			char		state[40];
1682 
1683 			get_enum(state, sizeof (state),
1684 			    "smb_tree_state_t", tree->t_state,
1685 			    "SMB_TREE_STATE_");
1686 
1687 			mdb_printf("%<b>%<u>SMB tree information (%p):"
1688 			    "%</u>%</b>\n\n", addr);
1689 			mdb_printf("TID: %04x\n", tree->t_tid);
1690 			mdb_printf("State: %d (%s)\n", tree->t_state, state);
1691 			mdb_printf("Share: %s\n", tree->t_sharename);
1692 			mdb_printf("Resource: %s\n", tree->t_resource);
1693 			mdb_printf("Type: %s\n", tree->t_typename);
1694 			mdb_printf("Volume: %s\n", tree->t_volume);
1695 			mdb_printf("Umask: %04x\n", tree->t_umask);
1696 			mdb_printf("Flags: %08x <%b>\n", tree->t_flags,
1697 			    tree->t_flags, tree_flag_bits);
1698 			mdb_printf("SMB Node: %llx\n", tree->t_snode);
1699 			mdb_printf("Reference Count: %d\n\n", tree->t_refcnt);
1700 		} else {
1701 			if (DCMD_HDRSPEC(flags))
1702 				mdb_printf(
1703 				    "%<b>%<u>%-?s %-5s %-16s %-32s%</u>%</b>\n",
1704 				    "TREE", "TID", "SHARE NAME", "RESOURCE");
1705 
1706 			mdb_printf("%-?p %-5u %-16s %-32s\n", addr,
1707 			    tree->t_tid, tree->t_sharename, tree->t_resource);
1708 		}
1709 	}
1710 	if (smb_obj_expand(addr, opts, smb_tree_exp, indent))
1711 		return (DCMD_ERR);
1712 	return (DCMD_OK);
1713 }
1714 
1715 /*
1716  * *****************************************************************************
1717  * ****************************** smb_odir_t ***********************************
1718  * *****************************************************************************
1719  */
1720 
1721 typedef struct mdb_smb_odir {
1722 	smb_odir_state_t	d_state;
1723 	smb_session_t		*d_session;
1724 	smb_user_t		*d_user;
1725 	smb_tree_t		*d_tree;
1726 	smb_node_t		*d_dnode;
1727 	uint16_t		d_odid;
1728 	uint32_t		d_refcnt;
1729 	char			d_pattern[MAXNAMELEN];
1730 } mdb_smb_odir_t;
1731 
1732 static int
smbodir_dcmd(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)1733 smbodir_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1734 {
1735 	uint_t		opts;
1736 
1737 	if (smb_dcmd_getopt(&opts, argc, argv))
1738 		return (DCMD_USAGE);
1739 
1740 	if (!(flags & DCMD_ADDRSPEC)) {
1741 		opts |= SMB_OPT_ODIR;
1742 		opts &= ~(SMB_OPT_SERVER | SMB_OPT_SESSION | SMB_OPT_REQUEST |
1743 		    SMB_OPT_USER | SMB_OPT_TREE | SMB_OPT_OFILE);
1744 		return (smb_obj_list("smb_odir", opts, flags));
1745 	}
1746 
1747 	if (((opts & SMB_OPT_WALK) && (opts & SMB_OPT_ODIR)) ||
1748 	    !(opts & SMB_OPT_WALK)) {
1749 		mdb_smb_odir_t *od;
1750 
1751 		od = mdb_zalloc(sizeof (*od), UM_SLEEP | UM_GC);
1752 		if (mdb_ctf_vread(od, SMBSRV_SCOPE "smb_odir_t",
1753 		    "mdb_smb_odir_t", addr, 0) < 0) {
1754 			mdb_warn("failed to read smb_odir at %p", addr);
1755 			return (DCMD_ERR);
1756 		}
1757 		if (opts & SMB_OPT_VERBOSE) {
1758 			char		state[40];
1759 
1760 			get_enum(state, sizeof (state),
1761 			    "smb_odir_state_t", od->d_state,
1762 			    "SMB_ODIR_STATE_");
1763 
1764 			mdb_printf(
1765 			    "%<b>%<u>SMB odir information (%p):%</u>%</b>\n\n",
1766 			    addr);
1767 			mdb_printf("State: %d (%s)\n", od->d_state, state);
1768 			mdb_printf("SID: %u\n", od->d_odid);
1769 			mdb_printf("User: %p\n", od->d_user);
1770 			mdb_printf("Tree: %p\n", od->d_tree);
1771 			mdb_printf("Reference Count: %d\n", od->d_refcnt);
1772 			mdb_printf("Pattern: %s\n", od->d_pattern);
1773 			mdb_printf("SMB Node: %p\n\n", od->d_dnode);
1774 		} else {
1775 			if (DCMD_HDRSPEC(flags))
1776 				mdb_printf(
1777 				    "%<b>%<u>%-?s "
1778 				    "%-5s "
1779 				    "%-?s "
1780 				    "%-16s%</u>%</b>\n",
1781 				    "ODIR", "SID", "VNODE", "PATTERN");
1782 
1783 			mdb_printf("%?p %-5u %-16p %s\n",
1784 			    addr, od->d_odid, od->d_dnode, od->d_pattern);
1785 		}
1786 	}
1787 	return (DCMD_OK);
1788 }
1789 
1790 /*
1791  * *****************************************************************************
1792  * ****************************** smb_ofile_t **********************************
1793  * *****************************************************************************
1794  */
1795 
1796 typedef struct mdb_smb_ofile {
1797 	smb_ofile_state_t	f_state;
1798 
1799 	struct smb_server	*f_server;
1800 	smb_session_t		*f_session;
1801 	smb_user_t		*f_user;
1802 	smb_tree_t		*f_tree;
1803 	smb_node_t		*f_node;
1804 	smb_odir_t		*f_odir;
1805 	smb_opipe_t		*f_pipe;
1806 
1807 	uint32_t		f_uniqid;
1808 	uint32_t		f_refcnt;
1809 	uint32_t		f_flags;
1810 	uint32_t		f_granted_access;
1811 	uint32_t		f_share_access;
1812 
1813 	uint16_t		f_fid;
1814 	uint16_t		f_ftype;
1815 	uint64_t		f_llf_pos;
1816 	int			f_mode;
1817 	cred_t			*f_cr;
1818 	pid_t			f_pid;
1819 	uintptr_t		f_lease;
1820 	smb_dh_vers_t		dh_vers;
1821 } mdb_smb_ofile_t;
1822 
1823 static const mdb_bitmask_t
1824 ofile_flag_bits[] = {
1825 	{ "RO", 1, 1 }, /* old SMB_OFLAGS_READONLY */
1826 	{ "EXEC",
1827 	    SMB_OFLAGS_EXECONLY,
1828 	    SMB_OFLAGS_EXECONLY },
1829 	{ "DELETE",
1830 	    SMB_OFLAGS_SET_DELETE_ON_CLOSE,
1831 	    SMB_OFLAGS_SET_DELETE_ON_CLOSE },
1832 	{ "POS_VALID",
1833 	    SMB_OFLAGS_LLF_POS_VALID,
1834 	    SMB_OFLAGS_LLF_POS_VALID },
1835 	{ NULL, 0, 0}
1836 };
1837 
1838 static const mdb_bitmask_t
1839 smb_sharemode_bits[] = {
1840 	{ "READ",
1841 	    FILE_SHARE_READ,
1842 	    FILE_SHARE_READ },
1843 	{ "WRITE",
1844 	    FILE_SHARE_WRITE,
1845 	    FILE_SHARE_WRITE },
1846 	{ "DELETE",
1847 	    FILE_SHARE_DELETE,
1848 	    FILE_SHARE_DELETE },
1849 	{ NULL, 0, 0}
1850 };
1851 
1852 static int
smbofile_dcmd(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)1853 smbofile_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1854 {
1855 	uint_t		opts;
1856 
1857 	if (smb_dcmd_getopt(&opts, argc, argv))
1858 		return (DCMD_USAGE);
1859 
1860 	if (!(flags & DCMD_ADDRSPEC)) {
1861 		opts |= SMB_OPT_OFILE;
1862 		opts &= ~(SMB_OPT_SERVER | SMB_OPT_SESSION | SMB_OPT_REQUEST |
1863 		    SMB_OPT_USER | SMB_OPT_TREE | SMB_OPT_ODIR);
1864 		return (smb_obj_list("smb_ofile", opts, flags));
1865 	}
1866 
1867 	if (((opts & SMB_OPT_WALK) && (opts & SMB_OPT_OFILE)) ||
1868 	    !(opts & SMB_OPT_WALK)) {
1869 		mdb_smb_ofile_t *of;
1870 
1871 		of = mdb_zalloc(sizeof (*of), UM_SLEEP | UM_GC);
1872 		if (mdb_ctf_vread(of, SMBSRV_SCOPE "smb_ofile_t",
1873 		    "mdb_smb_ofile_t", addr, 0) < 0) {
1874 			mdb_warn("failed to read smb_ofile at %p", addr);
1875 			return (DCMD_ERR);
1876 		}
1877 		if (opts & SMB_OPT_VERBOSE) {
1878 			char		state[40];
1879 			char		durable[40];
1880 
1881 			get_enum(state, sizeof (state),
1882 			    "smb_ofile_state_t", of->f_state,
1883 			    "SMB_OFILE_STATE_");
1884 
1885 			get_enum(durable, sizeof (durable),
1886 			    "smb_dh_vers_t", of->dh_vers,
1887 			    "SMB2_");
1888 
1889 			mdb_printf(
1890 			    "%<b>%<u>SMB ofile information (%p):%</u>%</b>\n\n",
1891 			    addr);
1892 			mdb_printf("FID: %u\n", of->f_fid);
1893 			mdb_printf("State: %d (%s)\n", of->f_state, state);
1894 			mdb_printf("DH Type: %d (%s)\n", of->dh_vers,
1895 			    durable);
1896 			mdb_printf("Lease: %p\n", of->f_lease);
1897 			mdb_printf("SMB Node: %p\n", of->f_node);
1898 			mdb_printf("LLF Offset: 0x%llx (%s)\n",
1899 			    of->f_llf_pos,
1900 			    ((of->f_flags & SMB_OFLAGS_LLF_POS_VALID) ?
1901 			    "Valid" : "Invalid"));
1902 			mdb_printf("Flags: 0x%08x <%b>\n", of->f_flags,
1903 			    of->f_flags, ofile_flag_bits);
1904 			mdb_printf("Granted Acc.: 0x%08x <%b>\n",
1905 			    of->f_granted_access,
1906 			    of->f_granted_access, nt_access_bits);
1907 			mdb_printf("Share Mode: 0x%08x <%b>\n",
1908 			    of->f_share_access,
1909 			    of->f_share_access, smb_sharemode_bits);
1910 			mdb_printf("User: %p\n", of->f_user);
1911 			mdb_printf("Tree: %p\n", of->f_tree);
1912 			mdb_printf("Credential: %p\n\n", of->f_cr);
1913 		} else {
1914 			if (DCMD_HDRSPEC(flags))
1915 				mdb_printf(
1916 				    "%<b>%<u>%-?s "
1917 				    "%-5s "
1918 				    "%-?s "
1919 				    "%-?s "
1920 				    "%-?s "
1921 				    "%</u>%</b>\n",
1922 				    "OFILE",
1923 				    "FID",
1924 				    "NODE",
1925 				    "CRED",
1926 				    "LEASE");
1927 
1928 			mdb_printf("%?p %-5u %-p %-p %-p\n", addr,
1929 			    of->f_fid, of->f_node, of->f_cr, of->f_lease);
1930 		}
1931 	}
1932 	return (DCMD_OK);
1933 }
1934 
1935 static int
smbdurable_dcmd(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)1936 smbdurable_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1937 {
1938 	mdb_smb_server_t *sv;
1939 
1940 	if (!(flags & DCMD_ADDRSPEC)) {
1941 		mdb_printf("require address of an smb_server_t\n");
1942 		return (WALK_ERR);
1943 	}
1944 
1945 	sv = mdb_zalloc(sizeof (*sv), UM_SLEEP | UM_GC);
1946 	if (mdb_ctf_vread(sv, SMBSRV_SCOPE "smb_server_t",
1947 	    "mdb_smb_server_t", addr, 0) < 0) {
1948 		mdb_warn("failed to read smb_server at %p", addr);
1949 		return (DCMD_ERR);
1950 	}
1951 
1952 	if (mdb_pwalk_dcmd("smb_hash_walker", "smbofile",
1953 	    argc, argv, (uintptr_t)sv->sv_persistid_ht) == -1) {
1954 		mdb_warn("failed to walk 'smb_ofile'");
1955 		return (DCMD_ERR);
1956 	}
1957 	return (DCMD_OK);
1958 }
1959 
1960 static int
smb_hash_walk_init(mdb_walk_state_t * wsp)1961 smb_hash_walk_init(mdb_walk_state_t *wsp)
1962 {
1963 	smb_hash_t hash;
1964 	int ll_off, sll_off, i;
1965 	uintptr_t addr = wsp->walk_addr;
1966 
1967 	if (addr == 0) {
1968 		mdb_printf("require address of an smb_hash_t\n");
1969 		return (WALK_ERR);
1970 	}
1971 
1972 	GET_OFFSET(sll_off, smb_bucket_t, b_list);
1973 	GET_OFFSET(ll_off, smb_llist_t, ll_list);
1974 
1975 	if (mdb_vread(&hash, sizeof (hash), addr) == -1) {
1976 		mdb_warn("failed to read smb_hash_t at %p", addr);
1977 		return (WALK_ERR);
1978 	}
1979 
1980 	for (i = 0; i < hash.num_buckets; i++) {
1981 		wsp->walk_addr = (uintptr_t)hash.buckets +
1982 		    (i * sizeof (smb_bucket_t)) + sll_off + ll_off;
1983 		if (mdb_layered_walk("list", wsp) == -1) {
1984 			mdb_warn("failed to walk 'list'");
1985 			return (WALK_ERR);
1986 		}
1987 	}
1988 
1989 	return (WALK_NEXT);
1990 }
1991 
1992 static int
smb_hash_walk_step(mdb_walk_state_t * wsp)1993 smb_hash_walk_step(mdb_walk_state_t *wsp)
1994 {
1995 	return (wsp->walk_callback(wsp->walk_addr, wsp->walk_layer,
1996 	    wsp->walk_cbdata));
1997 }
1998 
1999 static int
smbhashstat_cb(uintptr_t addr,const void * data,void * varg)2000 smbhashstat_cb(uintptr_t addr, const void *data, void *varg)
2001 {
2002 	_NOTE(ARGUNUSED(varg))
2003 	const smb_bucket_t *bucket = data;
2004 
2005 	mdb_printf("%-?p ", addr);	/* smb_bucket_t */
2006 	mdb_printf("%-6u ", bucket->b_list.ll_count);
2007 	mdb_printf("%-16u", bucket->b_max_seen);
2008 	mdb_printf("%-u\n", (bucket->b_list.ll_wrop +
2009 	    bucket->b_list.ll_count) / 2);
2010 	return (WALK_NEXT);
2011 }
2012 
2013 static int
smbhashstat_dcmd(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)2014 smbhashstat_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
2015 {
2016 	_NOTE(ARGUNUSED(argc, argv))
2017 	if (!(flags & DCMD_ADDRSPEC)) {
2018 		mdb_printf("require address of an smb_hash_t\n");
2019 		return (DCMD_USAGE);
2020 	}
2021 
2022 	if (DCMD_HDRSPEC(flags)) {
2023 		mdb_printf(
2024 		    "%<b>%<u>"
2025 		    "%-?s "
2026 		    "%-6s "
2027 		    "%-16s"
2028 		    "%-s"
2029 		    "%</u>%</b>\n",
2030 		    "smb_bucket_t", "count", "largest seen", "inserts");
2031 	}
2032 
2033 	if (mdb_pwalk("smb_hashstat_walker", smbhashstat_cb,
2034 	    NULL, addr) == -1) {
2035 		mdb_warn("failed to walk 'smb_ofile'");
2036 		return (DCMD_ERR);
2037 	}
2038 	return (DCMD_OK);
2039 }
2040 
2041 typedef struct smb_hash_wd {
2042 	smb_bucket_t	*bucket;
2043 	smb_bucket_t	*end;
2044 } smb_hash_wd_t;
2045 
2046 static int
smb_hashstat_walk_init(mdb_walk_state_t * wsp)2047 smb_hashstat_walk_init(mdb_walk_state_t *wsp)
2048 {
2049 	int sll_off, ll_off;
2050 	smb_hash_t hash;
2051 	smb_bucket_t *buckets;
2052 	uintptr_t addr = wsp->walk_addr;
2053 	uint32_t arr_sz;
2054 	smb_hash_wd_t *wd;
2055 
2056 	if (addr == 0) {
2057 		mdb_printf("require address of an smb_hash_t\n");
2058 		return (WALK_ERR);
2059 	}
2060 
2061 	GET_OFFSET(sll_off, smb_bucket_t, b_list);
2062 	GET_OFFSET(ll_off, smb_llist_t, ll_list);
2063 
2064 	if (mdb_vread(&hash, sizeof (hash), addr) == -1) {
2065 		mdb_warn("failed to read smb_hash_t at %p", addr);
2066 		return (WALK_ERR);
2067 	}
2068 
2069 	arr_sz = hash.num_buckets * sizeof (smb_bucket_t);
2070 	buckets = mdb_alloc(arr_sz, UM_SLEEP | UM_GC);
2071 	if (mdb_vread(buckets, arr_sz, (uintptr_t)hash.buckets) == -1) {
2072 		mdb_warn("failed to read smb_bucket_t array at %p",
2073 		    hash.buckets);
2074 		return (WALK_ERR);
2075 	}
2076 
2077 	wd = mdb_alloc(sizeof (*wd), UM_SLEEP | UM_GC);
2078 	wd->bucket = buckets;
2079 	wd->end = buckets + hash.num_buckets;
2080 
2081 	wsp->walk_addr = (uintptr_t)hash.buckets;
2082 	wsp->walk_data = wd;
2083 
2084 	return (WALK_NEXT);
2085 }
2086 
2087 static int
smb_hashstat_walk_step(mdb_walk_state_t * wsp)2088 smb_hashstat_walk_step(mdb_walk_state_t *wsp)
2089 {
2090 	int rc;
2091 	smb_hash_wd_t *wd = wsp->walk_data;
2092 
2093 	if (wd->bucket >= wd->end)
2094 		return (WALK_DONE);
2095 
2096 	rc = wsp->walk_callback(wsp->walk_addr, wd->bucket++,
2097 	    wsp->walk_cbdata);
2098 
2099 	wsp->walk_addr += sizeof (smb_bucket_t);
2100 	return (rc);
2101 }
2102 
2103 /*
2104  * smbsrv_leases
2105  */
2106 static int
smbsrv_leases_dcmd(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)2107 smbsrv_leases_dcmd(uintptr_t addr, uint_t flags, int argc,
2108     const mdb_arg_t *argv)
2109 {
2110 	uint_t		opts;
2111 	int		ht_off;
2112 	uintptr_t	ht_addr;
2113 
2114 	if (smb_dcmd_getopt(&opts, argc, argv))
2115 		return (DCMD_USAGE);
2116 
2117 	if (!(flags & DCMD_ADDRSPEC)) {
2118 		mdb_printf("require address of an smb_server_t\n");
2119 		return (DCMD_USAGE);
2120 	}
2121 
2122 	ht_off = mdb_ctf_offsetof_by_name("smb_server_t", "sv_lease_ht");
2123 	if (ht_off < 0) {
2124 		mdb_warn("No .sv_lease_ht in server (old kernel?)");
2125 		return (DCMD_ERR);
2126 	}
2127 	addr += ht_off;
2128 
2129 	if (mdb_vread(&ht_addr, sizeof (ht_addr), addr) <= 0) {
2130 		mdb_warn("failed to read server .sv_lease_ht");
2131 		return (DCMD_ERR);
2132 	}
2133 
2134 	if (mdb_pwalk_dcmd("smb_hash_walker", "smblease",
2135 	    argc, argv, ht_addr) == -1) {
2136 		mdb_warn("failed to walk 'smb_lease'");
2137 		return (DCMD_ERR);
2138 	}
2139 	return (DCMD_OK);
2140 }
2141 
2142 typedef struct mdb_smb_lease {
2143 	struct smb_node		*ls_node;
2144 	uint32_t		ls_refcnt;
2145 	uint16_t		ls_epoch;
2146 	uint8_t			ls_key[SMB_LEASE_KEY_SZ];
2147 } mdb_smb_lease_t;
2148 
2149 static int
smblease_dcmd(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)2150 smblease_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
2151 {
2152 	mdb_smb_lease_t *ls;
2153 	uint_t opts;
2154 	int i;
2155 
2156 	if (smb_dcmd_getopt(&opts, argc, argv))
2157 		return (DCMD_USAGE);
2158 
2159 	if (!(flags & DCMD_ADDRSPEC)) {
2160 		mdb_printf("require address of an smb_lease_t\n");
2161 		return (DCMD_USAGE);
2162 	}
2163 
2164 	if (((opts & SMB_OPT_WALK) && (opts & SMB_OPT_OFILE)) ||
2165 	    !(opts & SMB_OPT_WALK)) {
2166 
2167 		ls = mdb_zalloc(sizeof (*ls), UM_SLEEP | UM_GC);
2168 		if (mdb_ctf_vread(ls, SMBSRV_SCOPE "smb_lease_t",
2169 		    "mdb_smb_lease_t", addr, 0) < 0) {
2170 			mdb_warn("failed to read smb_lease_t at %p", addr);
2171 			return (DCMD_ERR);
2172 		}
2173 		if (opts & SMB_OPT_VERBOSE) {
2174 
2175 			mdb_printf(
2176 			    "%<b>%<u>SMB lease (%p):%</u>%</b>\n\n", addr);
2177 
2178 			mdb_printf("SMB Node: %p\n", ls->ls_node);
2179 			mdb_printf("Refcount: %u\n", ls->ls_refcnt);
2180 			mdb_printf("Epoch: %u\n", ls->ls_epoch);
2181 
2182 			mdb_printf("Key: [");
2183 			for (i = 0; i < SMB_LEASE_KEY_SZ; i++) {
2184 				mdb_printf(" %02x", ls->ls_key[i] & 0xFF);
2185 				if ((i & 3) == 3)
2186 					mdb_printf(" ");
2187 			}
2188 			mdb_printf(" ]\n");
2189 		} else {
2190 			if (DCMD_HDRSPEC(flags))
2191 				mdb_printf(
2192 				    "%<b>%<u>"
2193 				    "%-?s "
2194 				    "%-?s "
2195 				    "%-?s%</u>%</b>\n",
2196 				    "LEASE", "SMB NODE", "KEY");
2197 
2198 			mdb_printf("%?p %-p [", addr, ls->ls_node);
2199 			for (i = 0; i < 8; i++) {
2200 				mdb_printf(" %02x", ls->ls_key[i] & 0xFF);
2201 			}
2202 			mdb_printf(" ...]\n");
2203 		}
2204 	}
2205 
2206 	return (DCMD_OK);
2207 }
2208 
2209 /*
2210  * *****************************************************************************
2211  * ******************************** smb_kshare_t *******************************
2212  * *****************************************************************************
2213  */
2214 
2215 struct smb_kshare_cb_args {
2216 	uint_t		opts;
2217 	char name[MAXNAMELEN];
2218 	char path[MAXPATHLEN];
2219 };
2220 
2221 static int
smb_kshare_cb(uintptr_t addr,const void * data,void * varg)2222 smb_kshare_cb(uintptr_t addr, const void *data, void *varg)
2223 {
2224 	struct smb_kshare_cb_args *args = varg;
2225 	const smb_kshare_t *shr = data;
2226 
2227 	if (args->opts & SMB_OPT_VERBOSE) {
2228 		mdb_arg_t	argv;
2229 
2230 		argv.a_type = MDB_TYPE_STRING;
2231 		argv.a_un.a_str = "smb_kshare_t";
2232 		/* Don't fail the walk if this fails. */
2233 		mdb_printf("%-?p ", addr);
2234 		mdb_call_dcmd("print", addr, 0, 1, &argv);
2235 		return (WALK_NEXT);
2236 	}
2237 
2238 	/*
2239 	 * Summary line for an smb_kshare_t
2240 	 * Don't fail the walk if any of these fail.
2241 	 *
2242 	 * Get the shr_name and shr_path strings.
2243 	 */
2244 	if (mdb_readstr(args->name, sizeof (args->name),
2245 	    (uintptr_t)shr->shr_name) <= 0)
2246 		strcpy(args->name, "?");
2247 
2248 	if (mdb_readstr(args->path, sizeof (args->path),
2249 	    (uintptr_t)shr->shr_path) <= 0)
2250 		strcpy(args->path, "?");
2251 
2252 	mdb_printf("%-?p ", addr);	/* smb_kshare_t */
2253 	mdb_printf("%-16s ", args->name);
2254 	mdb_printf("%-s\n", args->path);
2255 
2256 	return (WALK_NEXT);
2257 }
2258 
2259 /*
2260  * ::smbshare
2261  *
2262  * smbshare dcmd - Print out smb_kshare structures.
2263  *	requires addr of an smb_server_t
2264  */
2265 /*ARGSUSED*/
2266 static int
smbshare_dcmd(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)2267 smbshare_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
2268 {
2269 	struct smb_kshare_cb_args *args;
2270 
2271 	args = mdb_zalloc(sizeof (*args), UM_SLEEP | UM_GC);
2272 	if (mdb_getopts(argc, argv,
2273 	    'v', MDB_OPT_SETBITS, SMB_OPT_VERBOSE, &args->opts,
2274 	    NULL) != argc)
2275 		return (DCMD_USAGE);
2276 
2277 	if (!(flags & DCMD_ADDRSPEC))
2278 		return (DCMD_USAGE);
2279 
2280 	if (DCMD_HDRSPEC(flags)) {
2281 		if ((args->opts & SMB_OPT_VERBOSE) != 0) {
2282 			mdb_printf("%<b>%<u>SMB kshares list:%</u>%</b>\n");
2283 		} else {
2284 			mdb_printf(
2285 			    "%<b>%<u>"
2286 			    "%-?s "
2287 			    "%-16s "
2288 			    "%-s"
2289 			    "%</u>%</b>\n",
2290 			    "smb_kshare_t", "name", "path");
2291 		}
2292 	}
2293 
2294 	if (mdb_pwalk("smbshare_walker", smb_kshare_cb, args, addr) == -1) {
2295 		mdb_warn("cannot walk smb_kshare avl");
2296 		return (DCMD_ERR);
2297 	}
2298 
2299 	return (DCMD_OK);
2300 }
2301 
2302 /*
2303  * Initialize the smb_kshare_t walker to point to the smb_export
2304  * in the specified smb_server_t instance.  (no global walks)
2305  */
2306 static int
smb_kshare_walk_init(mdb_walk_state_t * wsp)2307 smb_kshare_walk_init(mdb_walk_state_t *wsp)
2308 {
2309 	int sv_exp_off, ex_sha_off, avl_tr_off;
2310 
2311 	if (wsp->walk_addr == 0) {
2312 		mdb_printf("require address of an smb_server_t\n");
2313 		return (WALK_ERR);
2314 	}
2315 
2316 	/*
2317 	 * Using CTF to get the equivalent of:
2318 	 * OFFSETOF(smb_server_t, sv_export.e_share_avl.avl_tree);
2319 	 */
2320 	GET_OFFSET(sv_exp_off, smb_server_t, sv_export);
2321 	GET_OFFSET(ex_sha_off, smb_export_t, e_share_avl);
2322 	GET_OFFSET(avl_tr_off, smb_avl_t, avl_tree);
2323 	wsp->walk_addr += (sv_exp_off + ex_sha_off + avl_tr_off);
2324 
2325 	if (mdb_layered_walk("avl", wsp) == -1) {
2326 		mdb_warn("failed to walk list of smb_kshare_t");
2327 		return (WALK_ERR);
2328 	}
2329 
2330 	return (WALK_NEXT);
2331 }
2332 
2333 static int
smb_kshare_walk_step(mdb_walk_state_t * wsp)2334 smb_kshare_walk_step(mdb_walk_state_t *wsp)
2335 {
2336 	return (wsp->walk_callback(wsp->walk_addr, wsp->walk_layer,
2337 	    wsp->walk_cbdata));
2338 }
2339 
2340 /*
2341  * *****************************************************************************
2342  * ******************************** smb_vfs_t **********************************
2343  * *****************************************************************************
2344  */
2345 
2346 typedef struct mdb_smb_vfs {
2347 	list_node_t		sv_lnd;
2348 	uint32_t		sv_magic;
2349 	uint32_t		sv_refcnt;
2350 	vfs_t			*sv_vfsp;
2351 	vnode_t			*sv_rootvp;
2352 } mdb_smb_vfs_t;
2353 
2354 struct smb_vfs_cb_args {
2355 	uint_t		opts;
2356 	vnode_t		vn;
2357 	char		path[MAXPATHLEN];
2358 };
2359 
2360 /*ARGSUSED*/
2361 static int
smb_vfs_cb(uintptr_t addr,const void * data,void * varg)2362 smb_vfs_cb(uintptr_t addr, const void *data, void *varg)
2363 {
2364 	struct smb_vfs_cb_args *args = varg;
2365 	mdb_smb_vfs_t sf;
2366 
2367 	if (args->opts & SMB_OPT_VERBOSE) {
2368 		mdb_arg_t	argv;
2369 
2370 		argv.a_type = MDB_TYPE_STRING;
2371 		argv.a_un.a_str = "smb_vfs_t";
2372 		/* Don't fail the walk if this fails. */
2373 		mdb_printf("%-?p ", addr);
2374 		mdb_call_dcmd("print", addr, 0, 1, &argv);
2375 		return (WALK_NEXT);
2376 	}
2377 
2378 	/*
2379 	 * Summary line for an smb_vfs_t
2380 	 * Don't fail the walk if any of these fail.
2381 	 *
2382 	 * Get the vnode v_path string if we can.
2383 	 */
2384 	if (mdb_ctf_vread(&sf, SMBSRV_SCOPE "smb_vfs_t",
2385 	    "mdb_smb_vfs_t", addr, 0) < 0) {
2386 		mdb_warn("failed to read struct smb_vfs at %p", addr);
2387 		return (DCMD_ERR);
2388 	}
2389 	strcpy(args->path, "?");
2390 	if (mdb_vread(&args->vn, sizeof (args->vn),
2391 	    (uintptr_t)sf.sv_rootvp) == sizeof (args->vn))
2392 		(void) mdb_readstr(args->path, sizeof (args->path),
2393 		    (uintptr_t)args->vn.v_path);
2394 
2395 	mdb_printf("%-?p ", addr);
2396 	mdb_printf("%-10d ", sf.sv_refcnt);
2397 	mdb_printf("%-?p ", sf.sv_vfsp);
2398 	mdb_printf("%-?p ", sf.sv_rootvp);
2399 	mdb_printf("%-s\n", args->path);
2400 
2401 	return (WALK_NEXT);
2402 }
2403 
2404 /*
2405  * ::smbvfs
2406  *
2407  * smbvfs dcmd - Prints out smb_vfs structures.
2408  *	requires addr of an smb_server_t
2409  */
2410 /*ARGSUSED*/
2411 static int
smbvfs_dcmd(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)2412 smbvfs_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
2413 {
2414 	struct smb_vfs_cb_args *args;
2415 
2416 	args = mdb_zalloc(sizeof (*args), UM_SLEEP | UM_GC);
2417 	if (mdb_getopts(argc, argv,
2418 	    'v', MDB_OPT_SETBITS, SMB_OPT_VERBOSE, &args->opts,
2419 	    NULL) != argc)
2420 		return (DCMD_USAGE);
2421 
2422 	if (!(flags & DCMD_ADDRSPEC))
2423 		return (DCMD_USAGE);
2424 
2425 	if (DCMD_HDRSPEC(flags)) {
2426 		if ((args->opts & SMB_OPT_VERBOSE) != 0) {
2427 			mdb_printf("%<b>%<u>SMB VFS list:%</u>%</b>\n");
2428 		} else {
2429 			mdb_printf(
2430 			    "%<b>%<u>"
2431 			    "%-?s "
2432 			    "%-10s "
2433 			    "%-16s "
2434 			    "%-16s"
2435 			    "%-s"
2436 			    "%</u>%</b>\n",
2437 			    "SMB_VFS", "REFCNT", "VFS", "VNODE", "ROOT");
2438 		}
2439 	}
2440 
2441 	if (mdb_pwalk("smbvfs_walker", smb_vfs_cb, args, addr) == -1) {
2442 		mdb_warn("cannot walk smb_vfs list");
2443 		return (DCMD_ERR);
2444 	}
2445 
2446 	return (DCMD_OK);
2447 }
2448 
2449 /*
2450  * Initialize the smb_vfs_t walker to point to the smb_export
2451  * in the specified smb_server_t instance.  (no global walks)
2452  */
2453 static int
smb_vfs_walk_init(mdb_walk_state_t * wsp)2454 smb_vfs_walk_init(mdb_walk_state_t *wsp)
2455 {
2456 	int sv_exp_off, ex_vfs_off, ll_off;
2457 
2458 	if (wsp->walk_addr == 0) {
2459 		mdb_printf("require address of an smb_server_t\n");
2460 		return (WALK_ERR);
2461 	}
2462 
2463 	/*
2464 	 * Using CTF to get the equivalent of:
2465 	 * OFFSETOF(smb_server_t, sv_export.e_vfs_list.ll_list);
2466 	 */
2467 	GET_OFFSET(sv_exp_off, smb_server_t, sv_export);
2468 	/* GET_OFFSET(ex_vfs_off, smb_export_t, e_vfs_list); */
2469 	ex_vfs_off = mdb_ctf_offsetof_by_name("smb_export_t", "e_vfs_list");
2470 	if (ex_vfs_off < 0) {
2471 		mdb_warn("cannot lookup: smb_export_t .e_vfs_list");
2472 		return (WALK_ERR);
2473 	}
2474 	GET_OFFSET(ll_off, smb_llist_t, ll_list);
2475 	wsp->walk_addr += (sv_exp_off + ex_vfs_off + ll_off);
2476 
2477 	if (mdb_layered_walk("list", wsp) == -1) {
2478 		mdb_warn("failed to walk list of smb_vfs_t");
2479 		return (WALK_ERR);
2480 	}
2481 
2482 	return (WALK_NEXT);
2483 }
2484 
2485 static int
smb_vfs_walk_step(mdb_walk_state_t * wsp)2486 smb_vfs_walk_step(mdb_walk_state_t *wsp)
2487 {
2488 	return (wsp->walk_callback(wsp->walk_addr, wsp->walk_layer,
2489 	    wsp->walk_cbdata));
2490 }
2491 
2492 /*
2493  * *****************************************************************************
2494  * ******************************* smb_node_t **********************************
2495  * *****************************************************************************
2496  */
2497 
2498 typedef struct mdb_smb_node {
2499 	smb_node_state_t	n_state;
2500 	uint32_t		n_refcnt;
2501 	uint32_t		n_open_count;
2502 	uint32_t		n_opening_count;
2503 	smb_llist_t		n_ofile_list;
2504 	smb_llist_t		n_lock_list;
2505 	volatile int		flags;
2506 	struct smb_node		*n_dnode;
2507 	struct smb_node		*n_unode;
2508 	char			od_name[MAXNAMELEN];
2509 	vnode_t			*vp;
2510 	smb_audit_buf_node_t	*n_audit_buf;
2511 	/* Newer members (not in old kernels) - keep last! */
2512 	smb_llist_t		n_wlock_list;
2513 } mdb_smb_node_t;
2514 typedef struct mdb_smb_node_old {
2515 	/* Note: MUST be layout as above! */
2516 	smb_node_state_t	n_state;
2517 	uint32_t		n_refcnt;
2518 	uint32_t		n_open_count;
2519 	uint32_t		n_opening_count;
2520 	smb_llist_t		n_ofile_list;
2521 	smb_llist_t		n_lock_list;
2522 	volatile int		flags;
2523 	struct smb_node		*n_dnode;
2524 	struct smb_node		*n_unode;
2525 	char			od_name[MAXNAMELEN];
2526 	vnode_t			*vp;
2527 	smb_audit_buf_node_t	*n_audit_buf;
2528 	/* Newer members omitted from _old */
2529 } mdb_smb_node_old_t;
2530 
2531 static void
smbnode_help(void)2532 smbnode_help(void)
2533 {
2534 	mdb_printf(
2535 	    "Display the contents of smb_node_t, with optional filtering.\n\n");
2536 	(void) mdb_dec_indent(2);
2537 	mdb_printf("%<b>OPTIONS%</b>\n");
2538 	(void) mdb_inc_indent(2);
2539 	mdb_printf(
2540 	    "-v\tDisplay verbose smb_node information\n"
2541 	    "-p\tDisplay the full path of the vnode associated\n"
2542 	    "-s\tDisplay the stack of the last 16 calls that modified the "
2543 	    "reference\n\tcount\n");
2544 }
2545 
2546 /*
2547  * ::smbnode
2548  *
2549  * smb_node dcmd - Print out smb_node structure.
2550  */
2551 static int
smbnode_dcmd(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)2552 smbnode_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
2553 {
2554 	static smb_llist_t zero_llist = {0};
2555 	mdb_smb_node_t	node;
2556 	int		rc;
2557 	int		verbose = FALSE;
2558 	int		print_full_path = FALSE;
2559 	int		stack_trace = FALSE;
2560 	int		ol_cnt = 0;
2561 	vnode_t		vnode;
2562 	char		od_name[MAXNAMELEN];
2563 	char		path_name[1024];
2564 	uintptr_t	list_addr;
2565 	struct mdb_smb_oplock *node_oplock;
2566 
2567 	if (mdb_getopts(argc, argv,
2568 	    'v', MDB_OPT_SETBITS, TRUE, &verbose,
2569 	    'p', MDB_OPT_SETBITS, TRUE, &print_full_path,
2570 	    's', MDB_OPT_SETBITS, TRUE, &stack_trace,
2571 	    NULL) != argc)
2572 		return (DCMD_USAGE);
2573 
2574 	/*
2575 	 * If no smb_node address was specified on the command line, we can
2576 	 * print out all smb nodes by invoking the smb_node walker, using
2577 	 * this dcmd itself as the callback.
2578 	 */
2579 	if (!(flags & DCMD_ADDRSPEC)) {
2580 		if (mdb_walk_dcmd("smbnode_walker", "smbnode",
2581 		    argc, argv) == -1) {
2582 			mdb_warn("failed to walk 'smb_node'");
2583 			return (DCMD_ERR);
2584 		}
2585 		return (DCMD_OK);
2586 	}
2587 
2588 	/*
2589 	 * For each smb_node, we just need to read the smb_node_t struct, read
2590 	 * and then print out the following fields.
2591 	 */
2592 	if (mdb_ctf_vread(&node, SMBSRV_SCOPE "smb_node_t",
2593 	    "mdb_smb_node_t", addr, 0) < 0) {
2594 		/*
2595 		 * Fall-back handling for mdb_smb_node_old_t
2596 		 * Should remove after a while.
2597 		 */
2598 		if (mdb_ctf_vread(&node, SMBSRV_SCOPE "smb_node_t",
2599 		    "mdb_smb_node_old_t", addr, 0) < 0) {
2600 			mdb_warn("failed to read struct smb_node at %p", addr);
2601 			return (DCMD_ERR);
2602 		}
2603 		node.n_wlock_list = zero_llist;
2604 	}
2605 
2606 	(void) mdb_snprintf(od_name, sizeof (od_name), "%s",
2607 	    node.od_name);
2608 	if (print_full_path) {
2609 		if (mdb_vread(&vnode, sizeof (vnode_t),
2610 		    (uintptr_t)node.vp) == sizeof (vnode_t)) {
2611 			if (mdb_readstr(path_name, sizeof (path_name),
2612 			    (uintptr_t)vnode.v_path) <= 0) {
2613 				(void) mdb_snprintf(path_name,
2614 				    sizeof (path_name), "N/A");
2615 			}
2616 		}
2617 	}
2618 
2619 	rc = smb_node_get_oplock(addr, &node_oplock);
2620 	if (rc != DCMD_OK)
2621 		return (rc);
2622 	ol_cnt = smb_node_oplock_cnt(node_oplock);
2623 
2624 	if (verbose) {
2625 		int nol_off, nll_off, wll_off, ll_off;
2626 
2627 		GET_OFFSET(nol_off, smb_node_t, n_ofile_list);
2628 		GET_OFFSET(nll_off, smb_node_t, n_lock_list);
2629 		GET_OFFSET(ll_off, smb_llist_t, ll_list);
2630 		/* This one is optional (for now). */
2631 		/* GET_OFFSET(wll_off, smb_node_t, n_wlock_list); */
2632 		wll_off = mdb_ctf_offsetof_by_name(
2633 		    "smb_node_t", "n_wlock_list");
2634 
2635 		mdb_printf("%<b>%<u>SMB node information "
2636 		    "(%p):%</u>%</b>\n", addr);
2637 		mdb_printf("VP: %p\n", node.vp);
2638 		mdb_printf("Name: %s\n", od_name);
2639 		if (print_full_path)
2640 			mdb_printf("V-node Path: %s\n", path_name);
2641 		mdb_printf("Reference Count: %u\n", node.n_refcnt);
2642 		mdb_printf("Ofiles: %u\n", node.n_ofile_list.ll_count);
2643 		if (node.n_ofile_list.ll_count != 0 && nol_off != -1) {
2644 			(void) mdb_inc_indent(SMB_DCMD_INDENT);
2645 			list_addr = addr + nol_off + ll_off;
2646 			if (mdb_pwalk_dcmd("list", "smbofile", 0,
2647 			    NULL, list_addr)) {
2648 				mdb_warn("failed to walk node's ofiles");
2649 			}
2650 			(void) mdb_dec_indent(SMB_DCMD_INDENT);
2651 		}
2652 
2653 		mdb_printf("Granted Locks: %u\n",
2654 		    node.n_lock_list.ll_count);
2655 		if (node.n_lock_list.ll_count != 0) {
2656 			(void) mdb_inc_indent(SMB_DCMD_INDENT);
2657 			list_addr = addr + nll_off + ll_off;
2658 			if (mdb_pwalk_dcmd("list", "smblock", 0,
2659 			    NULL, list_addr)) {
2660 				mdb_warn("failed to walk node's granted"
2661 				    " locks");
2662 			}
2663 			(void) mdb_dec_indent(SMB_DCMD_INDENT);
2664 		}
2665 		mdb_printf("Waiting Locks: %u\n",
2666 		    node.n_wlock_list.ll_count);
2667 		if (node.n_wlock_list.ll_count != 0 && wll_off != -1) {
2668 			(void) mdb_inc_indent(SMB_DCMD_INDENT);
2669 			list_addr = addr + wll_off + ll_off;
2670 			if (mdb_pwalk_dcmd("list", "smblock", 0,
2671 			    NULL, list_addr)) {
2672 				mdb_warn("failed to walk node's waiting"
2673 				    " locks");
2674 			}
2675 			(void) mdb_dec_indent(SMB_DCMD_INDENT);
2676 		}
2677 		if (ol_cnt == 0) {
2678 			mdb_printf("Opportunistic Locks: (none)\n");
2679 		} else {
2680 			mdb_printf("Opportunistic Locks:\n");
2681 			(void) mdb_inc_indent(SMB_DCMD_INDENT);
2682 			/* Takes node address */
2683 			rc = mdb_call_dcmd("smbnode_oplock", addr,
2684 			    flags, argc, argv);
2685 			(void) mdb_dec_indent(SMB_DCMD_INDENT);
2686 			if (rc != DCMD_OK)
2687 				return (rc);
2688 		}
2689 	} else {
2690 		if (DCMD_HDRSPEC(flags)) {
2691 			mdb_printf(
2692 			    "%<b>%<u>%-?s "
2693 			    "%-?s "
2694 			    "%-18s "
2695 			    "%-6s "
2696 			    "%-6s "
2697 			    "%-8s "
2698 			    "%-8s "
2699 			    "%-6s%</u>%</b>\n",
2700 			    "ADDR", "VP", "NODE-NAME", "OFILES", "LOCKS",
2701 			    "WLOCKS", "OPLOCK", "REF");
2702 		}
2703 
2704 		mdb_printf("%-?p %-?p %-18s %-6d %-6d %-8d %-8d %-6d ",
2705 		    addr, node.vp, od_name, node.n_ofile_list.ll_count,
2706 		    node.n_lock_list.ll_count, node.n_wlock_list.ll_count,
2707 		    ol_cnt, node.n_refcnt);
2708 
2709 		if (print_full_path)
2710 			mdb_printf("\t%s\n", path_name);
2711 	}
2712 	if (stack_trace && node.n_audit_buf) {
2713 		int ctr;
2714 		smb_audit_buf_node_t *anb;
2715 
2716 		anb = mdb_alloc(sizeof (smb_audit_buf_node_t),
2717 		    UM_SLEEP | UM_GC);
2718 
2719 		if (mdb_vread(anb, sizeof (*anb),
2720 		    (uintptr_t)node.n_audit_buf) != sizeof (*anb)) {
2721 			mdb_warn("failed to read audit buffer");
2722 			return (DCMD_ERR);
2723 		}
2724 		ctr = anb->anb_max_index + 1;
2725 		anb->anb_index--;
2726 		anb->anb_index &= anb->anb_max_index;
2727 
2728 		while (ctr) {
2729 			smb_audit_record_node_t	*anr;
2730 
2731 			anr = anb->anb_records + anb->anb_index;
2732 
2733 			if (anr->anr_depth) {
2734 				char c[MDB_SYM_NAMLEN];
2735 				GElf_Sym sym;
2736 				int i;
2737 
2738 				mdb_printf("\nRefCnt: %u\t",
2739 				    anr->anr_refcnt);
2740 
2741 				for (i = 0;
2742 				    i < anr->anr_depth;
2743 				    i++) {
2744 					if (mdb_lookup_by_addr(
2745 					    anr->anr_stack[i],
2746 					    MDB_SYM_FUZZY,
2747 					    c, sizeof (c),
2748 					    &sym) == -1) {
2749 						continue;
2750 					}
2751 					mdb_printf("%s+0x%1x",
2752 					    c,
2753 					    anr->anr_stack[i] -
2754 					    (uintptr_t)sym.st_value);
2755 					++i;
2756 					break;
2757 				}
2758 
2759 				while (i < anr->anr_depth) {
2760 					if (mdb_lookup_by_addr(
2761 					    anr->anr_stack[i],
2762 					    MDB_SYM_FUZZY,
2763 					    c, sizeof (c),
2764 					    &sym) == -1) {
2765 						++i;
2766 						continue;
2767 					}
2768 					mdb_printf("\n\t\t%s+0x%1x",
2769 					    c,
2770 					    anr->anr_stack[i] -
2771 					    (uintptr_t)sym.st_value);
2772 					++i;
2773 				}
2774 				mdb_printf("\n");
2775 			}
2776 			anb->anb_index--;
2777 			anb->anb_index &= anb->anb_max_index;
2778 			ctr--;
2779 		}
2780 	}
2781 
2782 	return (DCMD_OK);
2783 }
2784 
2785 /*
2786  * Initialize the smb_node_t walker by reading the value of smb_node_hash_table
2787  * in the kernel's symbol table. Only global walk supported.
2788  */
2789 static int
smb_node_walk_init(mdb_walk_state_t * wsp)2790 smb_node_walk_init(mdb_walk_state_t *wsp)
2791 {
2792 	GElf_Sym	sym;
2793 	uintptr_t	node_hash_table_addr;
2794 	int		ll_off;
2795 	int		i;
2796 
2797 	if (wsp->walk_addr == 0) {
2798 		if (mdb_lookup_by_obj(SMBSRV_OBJNAME, "smb_node_hash_table",
2799 		    &sym) == -1) {
2800 			mdb_warn("failed to find 'smb_node_hash_table'");
2801 			return (WALK_ERR);
2802 		}
2803 		node_hash_table_addr = (uintptr_t)sym.st_value;
2804 	} else {
2805 		mdb_printf("smb_node walk only supports global walks\n");
2806 		return (WALK_ERR);
2807 	}
2808 
2809 	GET_OFFSET(ll_off, smb_llist_t, ll_list);
2810 
2811 	for (i = 0; i < SMBND_HASH_MASK + 1; i++) {
2812 		wsp->walk_addr = node_hash_table_addr +
2813 		    (i * sizeof (smb_llist_t)) + ll_off;
2814 		if (mdb_layered_walk("list", wsp) == -1) {
2815 			mdb_warn("failed to walk 'list'");
2816 			return (WALK_ERR);
2817 		}
2818 	}
2819 
2820 	return (WALK_NEXT);
2821 }
2822 
2823 static int
smb_node_walk_step(mdb_walk_state_t * wsp)2824 smb_node_walk_step(mdb_walk_state_t *wsp)
2825 {
2826 	return (wsp->walk_callback(wsp->walk_addr, wsp->walk_layer,
2827 	    wsp->walk_cbdata));
2828 }
2829 
2830 /*
2831  * *****************************************************************************
2832  * ****************************** smb_lock_t ***********************************
2833  * *****************************************************************************
2834  */
2835 
2836 typedef struct mdb_smb_lock {
2837 	smb_ofile_t		*l_file;
2838 	struct smb_lock		*l_blocked_by;
2839 	uint64_t		l_start;
2840 	uint64_t		l_length;
2841 	uint32_t		l_pid;
2842 	uint32_t		l_type;
2843 	uint32_t		l_flags;
2844 	/* Newer members (not in old kernels) - keep last! */
2845 	uint32_t		l_conflicts;
2846 } mdb_smb_lock_t;
2847 typedef struct mdb_smb_lock_old {
2848 	/* Note: MUST be same layout as above! */
2849 	smb_ofile_t		*l_file;
2850 	struct smb_lock		*l_blocked_by;
2851 	uint64_t		l_start;
2852 	uint64_t		l_length;
2853 	uint32_t		l_pid;
2854 	uint32_t		l_type;
2855 	uint32_t		l_flags;
2856 	/* Newer members omitted from _old */
2857 } mdb_smb_lock_old_t;
2858 
2859 static int
smblock_dcmd(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)2860 smblock_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
2861 {
2862 	mdb_smb_lock_t	lock;
2863 	int		verbose = FALSE;
2864 	char		*lock_type;
2865 
2866 	if (mdb_getopts(argc, argv,
2867 	    'v', MDB_OPT_SETBITS, TRUE, &verbose,
2868 	    NULL) != argc)
2869 		return (DCMD_USAGE);
2870 
2871 	/*
2872 	 * An smb_lock_t address must be specified.
2873 	 */
2874 	if (!(flags & DCMD_ADDRSPEC))
2875 		return (DCMD_USAGE);
2876 
2877 	if (mdb_ctf_vread(&lock, SMBSRV_SCOPE "smb_lock_t",
2878 	    "mdb_smb_lock_t", addr, 0) < 0) {
2879 		/*
2880 		 * Fall-back handling for mdb_smb_lock_old_t
2881 		 * Should remove after a while.
2882 		 */
2883 		if (mdb_ctf_vread(&lock, SMBSRV_SCOPE "smb_lock_t",
2884 		    "mdb_smb_lock_old_t", addr, 0) < 0) {
2885 			mdb_warn("failed to read struct smb_lock at %p", addr);
2886 			return (DCMD_ERR);
2887 		}
2888 		lock.l_conflicts = 0;
2889 	}
2890 
2891 	switch (lock.l_type) {
2892 	case SMB_LOCK_TYPE_READWRITE:
2893 		lock_type = "RW";
2894 		break;
2895 	case SMB_LOCK_TYPE_READONLY:
2896 		lock_type = "RO";
2897 		break;
2898 	default:
2899 		lock_type = "?";
2900 		break;
2901 	}
2902 	if (verbose) {
2903 		mdb_printf("%<b>%<u>SMB lock information "
2904 		    "(%p):%</u>%</b>\n", addr);
2905 
2906 		mdb_printf("Type             :\t%s (%u)\n",
2907 		    lock_type, lock.l_type);
2908 		mdb_printf("Start            :\t%llu\n",
2909 		    lock.l_start);
2910 		mdb_printf("Length           :\t%llu\n",
2911 		    lock.l_length);
2912 		mdb_printf("OFile            :\t%p\n",
2913 		    lock.l_file);
2914 		mdb_printf("Process ID       :\t%u\n",
2915 		    lock.l_pid);
2916 		mdb_printf("Conflicts        :\t%u\n",
2917 		    lock.l_conflicts);
2918 		mdb_printf("Blocked by       :\t%p\n",
2919 		    lock.l_blocked_by);
2920 		mdb_printf("Flags            :\t0x%x\n",
2921 		    lock.l_flags);
2922 		mdb_printf("\n");
2923 	} else {
2924 		if (DCMD_HDRSPEC(flags)) {
2925 			mdb_printf("%<u>%-?s %4s %16s %8s %9s %-?s%</u>\n",
2926 			    "Locks: ", "TYPE", "START", "LENGTH",
2927 			    "CONFLICTS", "BLOCKED-BY");
2928 		}
2929 		mdb_printf("%?p %4s %16llx %08llx %9u %?p",
2930 		    addr, lock_type, lock.l_start, lock.l_length,
2931 		    lock.l_conflicts, lock.l_blocked_by);
2932 	}
2933 
2934 	return (DCMD_OK);
2935 }
2936 
2937 /*
2938  * *****************************************************************************
2939  * ************************** smb_oplock_grant_t *******************************
2940  * *****************************************************************************
2941  */
2942 
2943 typedef struct mdb_smb_oplock_grant {
2944 	uint32_t		og_state;	/* latest sent to client */
2945 	uint8_t			onlist_II;
2946 	uint8_t			onlist_R;
2947 	uint8_t			onlist_RH;
2948 	uint8_t			onlist_RHBQ;
2949 	uint8_t			BreakingToRead;
2950 } mdb_smb_oplock_grant_t;
2951 
2952 static const mdb_bitmask_t
2953 oplock_bits[] = {
2954 	{  "READ_CACHING",
2955 	    READ_CACHING,
2956 	    READ_CACHING },
2957 	{  "HANDLE_CACHING",
2958 	    HANDLE_CACHING,
2959 	    HANDLE_CACHING },
2960 	{  "WRITE_CACHING",
2961 	    WRITE_CACHING,
2962 	    WRITE_CACHING },
2963 	{  "EXCLUSIVE",
2964 	    EXCLUSIVE,
2965 	    EXCLUSIVE },
2966 	{  "MIXED_R_AND_RH",
2967 	    MIXED_R_AND_RH,
2968 	    MIXED_R_AND_RH },
2969 	{  "LEVEL_TWO_OPLOCK",
2970 	    LEVEL_TWO_OPLOCK,
2971 	    LEVEL_TWO_OPLOCK },
2972 	{  "LEVEL_ONE_OPLOCK",
2973 	    LEVEL_ONE_OPLOCK,
2974 	    LEVEL_ONE_OPLOCK },
2975 	{  "BATCH_OPLOCK",
2976 	    BATCH_OPLOCK,
2977 	    BATCH_OPLOCK },
2978 	{  "BREAK_TO_TWO",
2979 	    BREAK_TO_TWO,
2980 	    BREAK_TO_TWO },
2981 	{  "BREAK_TO_NONE",
2982 	    BREAK_TO_NONE,
2983 	    BREAK_TO_NONE },
2984 	{  "BREAK_TO_TWO_TO_NONE",
2985 	    BREAK_TO_TWO_TO_NONE,
2986 	    BREAK_TO_TWO_TO_NONE },
2987 	{  "BREAK_TO_READ_CACHING",
2988 	    BREAK_TO_READ_CACHING,
2989 	    BREAK_TO_READ_CACHING },
2990 	{  "BREAK_TO_HANDLE_CACHING",
2991 	    BREAK_TO_HANDLE_CACHING,
2992 	    BREAK_TO_HANDLE_CACHING },
2993 	{  "BREAK_TO_WRITE_CACHING",
2994 	    BREAK_TO_WRITE_CACHING,
2995 	    BREAK_TO_WRITE_CACHING },
2996 	{  "BREAK_TO_NO_CACHING",
2997 	    BREAK_TO_NO_CACHING,
2998 	    BREAK_TO_NO_CACHING },
2999 	{  "NO_OPLOCK",
3000 	    NO_OPLOCK,
3001 	    NO_OPLOCK },
3002 	{  NULL, 0, 0 }
3003 };
3004 
3005 /*
3006  * Show smb_ofile_t oplock info
3007  * address is the ofile
3008  */
3009 
3010 /*ARGSUSED*/
3011 static int
smbofile_oplock_dcmd(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)3012 smbofile_oplock_dcmd(uintptr_t addr, uint_t flags, int argc,
3013     const mdb_arg_t *argv)
3014 {
3015 	mdb_smb_oplock_grant_t	og;
3016 	int verbose = FALSE;
3017 	static int og_off;
3018 
3019 	if (mdb_getopts(argc, argv,
3020 	    'v', MDB_OPT_SETBITS, TRUE, &verbose,
3021 	    NULL) != argc)
3022 		return (DCMD_USAGE);
3023 
3024 	if (!(flags & DCMD_ADDRSPEC))
3025 		return (DCMD_USAGE);
3026 
3027 	if (og_off <= 0) {
3028 		og_off = mdb_ctf_offsetof_by_name(
3029 		    "smb_ofile_t", "f_oplock");
3030 		if (og_off < 0) {
3031 			mdb_warn("cannot lookup: smb_ofile_t .f_oplock");
3032 			return (DCMD_ERR);
3033 		}
3034 	}
3035 
3036 	if (mdb_ctf_vread(&og, SMBSRV_SCOPE "smb_oplock_grant_t",
3037 	    "mdb_smb_oplock_grant_t", addr + og_off, 0) < 0) {
3038 		mdb_warn("failed to read oplock grant in ofile at %p", addr);
3039 		return (DCMD_ERR);
3040 	}
3041 
3042 	if (verbose) {
3043 		mdb_printf("%<b>%<u>SMB ofile (oplock_grant) "
3044 		    "(%p):%</u>%</b>\n", addr);
3045 		mdb_printf("State: 0x%x <%b>\n",
3046 		    og.og_state,
3047 		    og.og_state,
3048 		    oplock_bits);
3049 		mdb_printf("OnList_II: %d\n", og.onlist_II);
3050 		mdb_printf("OnList_R: %d\n", og.onlist_R);
3051 		mdb_printf("OnList_RH: %d\n", og.onlist_RH);
3052 		mdb_printf("OnList_RHBQ: %d\n", og.onlist_RHBQ);
3053 		mdb_printf("BrkToRead: %d\n", og.BreakingToRead);
3054 
3055 	} else {
3056 
3057 		if (DCMD_HDRSPEC(flags)) {
3058 			mdb_printf("%<u>%-16s %-10s %-16s%</u>\n",
3059 			    "OFILE", "STATE", "OnList...");
3060 		}
3061 
3062 		mdb_printf("%-16p", addr);
3063 		mdb_printf(" 0x%x", og.og_state);
3064 		if (og.onlist_II)
3065 			mdb_printf(" II");
3066 		if (og.onlist_R)
3067 			mdb_printf(" R");
3068 		if (og.onlist_RH)
3069 			mdb_printf(" RH");
3070 		if (og.onlist_RHBQ)
3071 			mdb_printf(" RHBQ");
3072 		if (og.BreakingToRead)
3073 			mdb_printf(" BrkToRd");
3074 		mdb_printf("\n");
3075 	}
3076 
3077 	return (DCMD_OK);
3078 }
3079 
3080 /*
3081  * *****************************************************************************
3082  * ***************************** smb_oplock_t **********************************
3083  * *****************************************************************************
3084  */
3085 
3086 typedef struct mdb_smb_oplock {
3087 	struct smb_ofile	*excl_open;
3088 	uint32_t		ol_state;
3089 	int32_t			cnt_II;
3090 	int32_t			cnt_R;
3091 	int32_t			cnt_RH;
3092 	int32_t			cnt_RHBQ;
3093 	int32_t			waiters;
3094 } mdb_smb_oplock_t;
3095 
3096 /*
3097  * Helpers for smbnode_dcmd and smbnode_oplock_dcmd
3098  */
3099 
3100 /*
3101  * Read the smb_oplock_t part of the node
3102  * addr is the smb_node
3103  */
3104 static int
smb_node_get_oplock(uintptr_t addr,struct mdb_smb_oplock ** ol_ret)3105 smb_node_get_oplock(uintptr_t addr, struct mdb_smb_oplock **ol_ret)
3106 {
3107 	mdb_smb_oplock_t *ol;
3108 	static int ol_off;
3109 
3110 	if (ol_off <= 0) {
3111 		ol_off = mdb_ctf_offsetof_by_name(
3112 		    "smb_node_t", "n_oplock");
3113 		if (ol_off < 0) {
3114 			mdb_warn("cannot lookup: smb_node_t .n_oplock");
3115 			return (DCMD_ERR);
3116 		}
3117 	}
3118 
3119 	ol = mdb_alloc(sizeof (*ol), UM_SLEEP | UM_GC);
3120 
3121 	if (mdb_ctf_vread(ol, SMBSRV_SCOPE "smb_oplock_t",
3122 	    "mdb_smb_oplock_t", addr + ol_off, 0) < 0) {
3123 		mdb_warn("failed to read smb_oplock in node at %p", addr);
3124 		return (DCMD_ERR);
3125 	}
3126 
3127 	*ol_ret = ol;
3128 	return (DCMD_OK);
3129 }
3130 
3131 /*
3132  * Return the oplock count
3133  */
3134 static int
smb_node_oplock_cnt(struct mdb_smb_oplock * ol)3135 smb_node_oplock_cnt(struct mdb_smb_oplock *ol)
3136 {
3137 	int ol_cnt = 0;
3138 
3139 	/* Compute total oplock count. */
3140 	if (ol->excl_open != NULL)
3141 		ol_cnt++;
3142 	ol_cnt += ol->cnt_II;
3143 	ol_cnt += ol->cnt_R;
3144 	ol_cnt += ol->cnt_RH;
3145 
3146 	return (ol_cnt);
3147 }
3148 
3149 /*
3150  * Show smb_node_t oplock info, and optionally the
3151  * list of ofiles with oplocks on this node.
3152  * Address is the smb_node_t.
3153  */
3154 
3155 /*ARGSUSED*/
3156 static int
smbnode_oplock_dcmd(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)3157 smbnode_oplock_dcmd(uintptr_t addr, uint_t flags, int argc,
3158     const mdb_arg_t *argv)
3159 {
3160 	mdb_smb_oplock_t *ol;
3161 	int verbose = FALSE;
3162 	int ol_cnt, rc;
3163 	int fl_off, ll_off;
3164 
3165 	if (mdb_getopts(argc, argv,
3166 	    'v', MDB_OPT_SETBITS, TRUE, &verbose,
3167 	    NULL) != argc)
3168 		return (DCMD_USAGE);
3169 
3170 	if (!(flags & DCMD_ADDRSPEC))
3171 		return (DCMD_USAGE);
3172 
3173 	rc = smb_node_get_oplock(addr, &ol);
3174 	if (rc != DCMD_OK)
3175 		return (rc);
3176 	ol_cnt = smb_node_oplock_cnt(ol);
3177 
3178 	if (verbose) {
3179 		mdb_printf("%<b>%<u>SMB node (oplock) "
3180 		    "(%p):%</u>%</b>\n", addr);
3181 		mdb_printf("State: 0x%x <%b>\n",
3182 		    ol->ol_state,
3183 		    ol->ol_state,
3184 		    oplock_bits);
3185 		mdb_printf("Exclusive Open: %p\n", ol->excl_open);
3186 		mdb_printf("cnt_II: %d\n", ol->cnt_II);
3187 		mdb_printf("cnt_R: %d\n", ol->cnt_R);
3188 		mdb_printf("cnt_RH: %d\n", ol->cnt_RH);
3189 		mdb_printf("cnt_RHBQ: %d\n", ol->cnt_RHBQ);
3190 		mdb_printf("waiters: %d\n", ol->waiters);
3191 	} else {
3192 		if (DCMD_HDRSPEC(flags)) {
3193 			mdb_printf("%<u>%-16s %-10s %-16s%</u>\n",
3194 			    "NODE", "STATE", "OPLOCKS");
3195 		}
3196 		mdb_printf("%-16p 0x%x %d\n",
3197 		    addr, ol->ol_state, ol_cnt);
3198 	}
3199 
3200 	if (ol_cnt == 0)
3201 		return (DCMD_OK);
3202 
3203 	GET_OFFSET(fl_off, smb_node_t, n_ofile_list);
3204 	GET_OFFSET(ll_off, smb_llist_t, ll_list);
3205 
3206 	(void) mdb_inc_indent(SMB_DCMD_INDENT);
3207 
3208 	if (mdb_pwalk_dcmd("list", "smbofile_oplock",
3209 	    argc, argv, addr + fl_off + ll_off)) {
3210 		mdb_warn("failed to walk ofile oplocks");
3211 	}
3212 
3213 	(void) mdb_dec_indent(SMB_DCMD_INDENT);
3214 
3215 	return (DCMD_OK);
3216 }
3217 
3218 /*
3219  * *******************************************************************
3220  * (smb) mbuf_t
3221  *
3222  * ::smb_mbuf_dump [max_len]
3223  * dcmd to dump the data portion of an mbuf_t
3224  * stop at max_len
3225  */
3226 static int
smb_mbuf_dump_dcmd(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)3227 smb_mbuf_dump_dcmd(uintptr_t addr, uint_t flags, int argc,
3228     const mdb_arg_t *argv)
3229 {
3230 	struct m_hdr mh;
3231 	uintptr_t mdata;
3232 	int len, max_len;
3233 	int dumpptr_flags;
3234 
3235 	if (mdb_vread(&mh, sizeof (mh), addr) < 0) {
3236 		mdb_warn("failed to read mbuf at %p", addr);
3237 		return (DCMD_ERR);
3238 	}
3239 	len = mh.mh_len;
3240 	mdata = (uintptr_t)mh.mh_data;
3241 
3242 	if (argc > 0) {
3243 		if (argv[0].a_type == MDB_TYPE_IMMEDIATE)
3244 			max_len = argv[0].a_un.a_val;
3245 		else
3246 			max_len = mdb_strtoull(argv[0].a_un.a_str);
3247 		if (len > max_len)
3248 			len = max_len;
3249 	}
3250 	if (len <= 0)
3251 		return (DCMD_OK);
3252 
3253 	if (DCMD_HDRSPEC(flags)) {
3254 		mdb_printf("%<u>%-16s %-16s %-12s%</u>\n",
3255 		    "mbuf_t", "m_data", "m_len");
3256 	}
3257 	mdb_printf("%-16p %-16p %-12u\n",
3258 	    addr, mdata, mh.mh_len);
3259 
3260 	dumpptr_flags = MDB_DUMP_RELATIVE | MDB_DUMP_ASCII | MDB_DUMP_HEADER;
3261 	if (mdb_dumpptr(mdata, len, dumpptr_flags, NULL, NULL) < 0)
3262 		return (DCMD_ERR);
3263 
3264 	return (DCMD_OK);
3265 }
3266 
3267 static int
smb_mbuf_walk_init(mdb_walk_state_t * wsp)3268 smb_mbuf_walk_init(mdb_walk_state_t *wsp)
3269 {
3270 	mbuf_t *m;
3271 
3272 	if (wsp->walk_addr == 0) {
3273 		mdb_printf("require address of an mbuf_t\n");
3274 		return (WALK_ERR);
3275 	}
3276 	m = mdb_alloc(sizeof (*m), UM_SLEEP | UM_GC);
3277 	wsp->walk_data = m;
3278 	return (WALK_NEXT);
3279 }
3280 
3281 static int
smb_mbuf_walk_step(mdb_walk_state_t * wsp)3282 smb_mbuf_walk_step(mdb_walk_state_t *wsp)
3283 {
3284 	uintptr_t addr = wsp->walk_addr;
3285 	mbuf_t *m = wsp->walk_data;
3286 	int rc;
3287 
3288 	if (wsp->walk_addr == 0)
3289 		return (WALK_DONE);
3290 
3291 	if (mdb_vread(m, sizeof (*m), addr) == -1) {
3292 		mdb_warn("failed to read mbuf_t at %p", addr);
3293 		return (WALK_ERR);
3294 	}
3295 
3296 	rc = wsp->walk_callback(addr, m, wsp->walk_cbdata);
3297 	wsp->walk_addr = (uintptr_t)m->m_next;
3298 
3299 	return (rc);
3300 }
3301 
3302 /*
3303  * *****************************************************************************
3304  * ******************************** smb_ace_t **********************************
3305  * *****************************************************************************
3306  */
3307 static const ace_type_entry_t	ace_types[ACE_TYPE_TABLEN] =
3308 {
3309 	ACE_TYPE_ENTRY(ACE_ACCESS_ALLOWED_ACE_TYPE),
3310 	ACE_TYPE_ENTRY(ACE_ACCESS_DENIED_ACE_TYPE),
3311 	ACE_TYPE_ENTRY(ACE_SYSTEM_AUDIT_ACE_TYPE),
3312 	ACE_TYPE_ENTRY(ACE_SYSTEM_ALARM_ACE_TYPE),
3313 	ACE_TYPE_ENTRY(ACE_ACCESS_ALLOWED_COMPOUND_ACE_TYPE),
3314 	ACE_TYPE_ENTRY(ACE_ACCESS_ALLOWED_OBJECT_ACE_TYPE),
3315 	ACE_TYPE_ENTRY(ACE_ACCESS_DENIED_OBJECT_ACE_TYPE),
3316 	ACE_TYPE_ENTRY(ACE_SYSTEM_AUDIT_OBJECT_ACE_TYPE),
3317 	ACE_TYPE_ENTRY(ACE_SYSTEM_ALARM_OBJECT_ACE_TYPE),
3318 	ACE_TYPE_ENTRY(ACE_ACCESS_ALLOWED_CALLBACK_ACE_TYPE),
3319 	ACE_TYPE_ENTRY(ACE_ACCESS_DENIED_CALLBACK_ACE_TYPE),
3320 	ACE_TYPE_ENTRY(ACE_ACCESS_ALLOWED_CALLBACK_OBJECT_ACE_TYPE),
3321 	ACE_TYPE_ENTRY(ACE_ACCESS_DENIED_CALLBACK_OBJECT_ACE_TYPE),
3322 	ACE_TYPE_ENTRY(ACE_SYSTEM_AUDIT_CALLBACK_ACE_TYPE),
3323 	ACE_TYPE_ENTRY(ACE_SYSTEM_ALARM_CALLBACK_ACE_TYPE),
3324 	ACE_TYPE_ENTRY(ACE_SYSTEM_AUDIT_CALLBACK_OBJECT_ACE_TYPE),
3325 	ACE_TYPE_ENTRY(ACE_SYSTEM_ALARM_CALLBACK_OBJECT_ACE_TYPE),
3326 	ACE_TYPE_ENTRY(0x11),
3327 	ACE_TYPE_ENTRY(0x12),
3328 	ACE_TYPE_ENTRY(0x13),
3329 	ACE_TYPE_ENTRY(0x14),
3330 	ACE_TYPE_ENTRY(0x15),
3331 	ACE_TYPE_ENTRY(0x16),
3332 	ACE_TYPE_ENTRY(0x17),
3333 	ACE_TYPE_ENTRY(0x18),
3334 	ACE_TYPE_ENTRY(0x19),
3335 	ACE_TYPE_ENTRY(0x1A),
3336 	ACE_TYPE_ENTRY(0x1B),
3337 	ACE_TYPE_ENTRY(0x1C),
3338 	ACE_TYPE_ENTRY(0x1D),
3339 	ACE_TYPE_ENTRY(0x1E),
3340 	ACE_TYPE_ENTRY(0x1F)
3341 };
3342 
3343 static const mdb_bitmask_t ace_flag_bits[] = {
3344 	{ "OBJECT_INHERIT_ACE", OBJECT_INHERIT_ACE, OBJECT_INHERIT_ACE },
3345 	{ "CONTAINER_INHERIT_ACE", CONTAINER_INHERIT_ACE,
3346 	    CONTAINER_INHERIT_ACE },
3347 	{ "NO_PROPOGATE_INHERIT_ACE", NO_PROPOGATE_INHERIT_ACE,
3348 	    NO_PROPOGATE_INHERIT_ACE },
3349 	{ "INHERIT_ONLY_ACE", INHERIT_ONLY_ACE, INHERIT_ONLY_ACE },
3350 	{ "INHERITED_ACE", INHERITED_ACE, INHERITED_ACE },
3351 	{ "SUCCESSFUL_ACCESS_ACE_FLAG", SUCCESSFUL_ACCESS_ACE_FLAG,
3352 	    SUCCESSFUL_ACCESS_ACE_FLAG },
3353 	{ "FAILED_ACCESS_ACE_FLAG", FAILED_ACCESS_ACE_FLAG,
3354 	    FAILED_ACCESS_ACE_FLAG },
3355 	{ NULL, 0, 0 }
3356 };
3357 
3358 /*
3359  * ::smbace
3360  */
3361 static int
smbace_dcmd(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)3362 smbace_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
3363 {
3364 	smb_ace_t	ace;
3365 	int		verbose = FALSE;
3366 	const char	*ptr;
3367 	int		rc;
3368 
3369 	if (mdb_getopts(argc, argv, 'v', MDB_OPT_SETBITS, TRUE, &verbose,
3370 	    NULL) != argc)
3371 		return (DCMD_USAGE);
3372 
3373 	/*
3374 	 * An smb_ace address is required.
3375 	 */
3376 	if (!(flags & DCMD_ADDRSPEC))
3377 		return (DCMD_USAGE);
3378 
3379 	if (mdb_vread(&ace, sizeof (ace), addr) != sizeof (ace)) {
3380 		mdb_warn("failed to read struct smb_ace at %p", addr);
3381 		return (DCMD_ERR);
3382 	}
3383 
3384 	if (verbose) {
3385 		if (ace.se_hdr.se_type < ACE_TYPE_TABLEN)
3386 			ptr = ace_types[ace.se_hdr.se_type].ace_type_sting;
3387 		else
3388 			ptr = "Unknown";
3389 
3390 		mdb_printf("ACE Type: 0x%02x (%s)\n", ace.se_hdr.se_type, ptr);
3391 		mdb_printf("ACE Flags: %b\n", (int)ace.se_hdr.se_flags,
3392 		    ace_flag_bits);
3393 		mdb_printf("ACE Wire Size: 0x%04x\n", ace.se_hdr.se_bsize);
3394 		mdb_printf("ACE Mask: 0x%08x\n", ace.se_mask);
3395 		mdb_printf("ACE SID: ");
3396 	} else {
3397 		if (DCMD_HDRSPEC(flags))
3398 			mdb_printf(
3399 			    "%<b>%<u>%?-s %-4s %-4s %-8s %s%</u>%</b>\n",
3400 			    "ACE", "TYPE", "FLAGS", "MASK", "SID");
3401 		mdb_printf("%?p 0x%02x 0x%02x 0x%08x ", addr,
3402 		    ace.se_hdr.se_type, ace.se_hdr.se_flags, ace.se_mask);
3403 	}
3404 	rc = smb_sid_print((uintptr_t)ace.se_sid);
3405 	mdb_printf("\n");
3406 	return (rc);
3407 }
3408 
3409 static int
smb_ace_walk_init(mdb_walk_state_t * wsp)3410 smb_ace_walk_init(mdb_walk_state_t *wsp)
3411 {
3412 	int sal_off;
3413 
3414 	if (wsp->walk_addr == 0) {
3415 		mdb_printf("smb_ace walk only supports local walks\n");
3416 		return (WALK_ERR);
3417 	}
3418 
3419 	GET_OFFSET(sal_off, smb_acl_t, sl_sorted);
3420 	wsp->walk_addr += sal_off;
3421 
3422 	if (mdb_layered_walk("list", wsp) == -1) {
3423 		mdb_warn("failed to walk list of ACEs");
3424 		return (WALK_ERR);
3425 	}
3426 
3427 	return (WALK_NEXT);
3428 }
3429 
3430 static int
smb_ace_walk_step(mdb_walk_state_t * wsp)3431 smb_ace_walk_step(mdb_walk_state_t *wsp)
3432 {
3433 	return (wsp->walk_callback(wsp->walk_addr, wsp->walk_layer,
3434 	    wsp->walk_cbdata));
3435 }
3436 
3437 /*
3438  * *****************************************************************************
3439  * ******************************** smb_acl_t **********************************
3440  * *****************************************************************************
3441  */
3442 
3443 /*
3444  * ::smbacl
3445  */
3446 static int
smbacl_dcmd(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)3447 smbacl_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
3448 {
3449 	smb_acl_t	acl;
3450 
3451 	/* An smb_acl address is required. */
3452 	if (!(flags & DCMD_ADDRSPEC))
3453 		return (DCMD_USAGE);
3454 
3455 	if (mdb_vread(&acl, sizeof (acl), addr) != sizeof (acl)) {
3456 		mdb_warn("failed to read struct smb_acl at %p", addr);
3457 		return (DCMD_ERR);
3458 	}
3459 
3460 	mdb_printf("ACL Revision: %d\n", acl.sl_revision);
3461 	mdb_printf("ACL Size on Wire: %d\n", acl.sl_bsize);
3462 	mdb_printf("ACL Number of ACEs: %d\n", acl.sl_acecnt);
3463 
3464 	(void) mdb_inc_indent(SMB_DCMD_INDENT);
3465 	if (mdb_pwalk_dcmd("smbace_walker", "smbace", argc, argv, addr)) {
3466 		(void) mdb_dec_indent(SMB_DCMD_INDENT);
3467 		mdb_warn("failed to walk list of ACEs for ACL %p", addr);
3468 		return (DCMD_ERR);
3469 	}
3470 	(void) mdb_dec_indent(SMB_DCMD_INDENT);
3471 	return (DCMD_OK);
3472 }
3473 
3474 /*
3475  * *****************************************************************************
3476  * ********************************* smb_sd_t **********************************
3477  * *****************************************************************************
3478  */
3479 
3480 /*
3481  * ::smbsd
3482  */
3483 static int
smbsd_dcmd(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)3484 smbsd_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
3485 {
3486 	smb_sd_t	sd;
3487 	int		rc;
3488 
3489 	/*
3490 	 * An smb_sid address is required.
3491 	 */
3492 	if (!(flags & DCMD_ADDRSPEC))
3493 		return (DCMD_USAGE);
3494 
3495 	if (mdb_vread(&sd, sizeof (sd), addr) != sizeof (sd)) {
3496 		mdb_warn("failed to read struct smb_sd at %p", addr);
3497 		return (DCMD_ERR);
3498 	}
3499 
3500 	mdb_printf("SD Revision: %d\n", sd.sd_revision);
3501 	mdb_printf("SD Control: %04x\n", sd.sd_control);
3502 	if (sd.sd_control & SE_OWNER_DEFAULTED)
3503 		mdb_printf("\t    SE_OWNER_DEFAULTED\n");
3504 	if (sd.sd_control & SE_GROUP_DEFAULTED)
3505 		mdb_printf("\t    SE_GROUP_DEFAULTED\n");
3506 	if (sd.sd_control & SE_DACL_PRESENT)
3507 		mdb_printf("\t    SE_DACL_PRESENT\n");
3508 	if (sd.sd_control & SE_DACL_DEFAULTED)
3509 		mdb_printf("\t    SE_DACL_DEFAULTED\n");
3510 	if (sd.sd_control & SE_SACL_PRESENT)
3511 		mdb_printf("\t    SE_SACL_PRESENT\n");
3512 	if (sd.sd_control & SE_SACL_DEFAULTED)
3513 		mdb_printf("\t    SE_SACL_DEFAULTED\n");
3514 	if (sd.sd_control & SE_DACL_AUTO_INHERIT_REQ)
3515 		mdb_printf("\t    SE_DACL_AUTO_INHERIT_REQ\n");
3516 	if (sd.sd_control & SE_SACL_AUTO_INHERIT_REQ)
3517 		mdb_printf("\t    SE_SACL_AUTO_INHERIT_REQ\n");
3518 	if (sd.sd_control & SE_DACL_AUTO_INHERITED)
3519 		mdb_printf("\t    SE_DACL_AUTO_INHERITED\n");
3520 	if (sd.sd_control & SE_SACL_AUTO_INHERITED)
3521 		mdb_printf("\t    SE_SACL_AUTO_INHERITED\n");
3522 	if (sd.sd_control & SE_DACL_PROTECTED)
3523 		mdb_printf("\t    SE_DACL_PROTECTED\n");
3524 	if (sd.sd_control & SE_SACL_PROTECTED)
3525 		mdb_printf("\t    SE_SACL_PROTECTED\n");
3526 	if (sd.sd_control & SE_SELF_RELATIVE)
3527 		mdb_printf("\t    SE_SELF_RELATIVE\n");
3528 
3529 	mdb_printf("SID of Owner: ");
3530 	rc = smb_sid_print((uintptr_t)sd.sd_owner);
3531 	if (rc != DCMD_OK)
3532 		return (rc);
3533 	mdb_printf("\nSID of Group: ");
3534 	rc = smb_sid_print((uintptr_t)sd.sd_group);
3535 	if (rc != DCMD_OK)
3536 		return (rc);
3537 	mdb_printf("\n");
3538 
3539 	if (sd.sd_control & SE_SACL_PRESENT && sd.sd_sacl) {
3540 		mdb_printf("%<b>%<u>System ACL%</u>%</b>\n");
3541 		(void) mdb_inc_indent(SMB_DCMD_INDENT);
3542 		rc = mdb_call_dcmd("smbacl", (uintptr_t)sd.sd_sacl, flags,
3543 		    argc, argv);
3544 		(void) mdb_dec_indent(SMB_DCMD_INDENT);
3545 		if (rc != DCMD_OK)
3546 			return (rc);
3547 	}
3548 	if (sd.sd_control & SE_DACL_PRESENT && sd.sd_dacl) {
3549 		mdb_printf("%<b>%<u>Discretionary ACL%</u>%</b>\n");
3550 		(void) mdb_inc_indent(SMB_DCMD_INDENT);
3551 		rc = mdb_call_dcmd("smbacl", (uintptr_t)sd.sd_dacl, flags,
3552 		    argc, argv);
3553 		(void) mdb_dec_indent(SMB_DCMD_INDENT);
3554 		if (rc != DCMD_OK)
3555 			return (rc);
3556 	}
3557 
3558 	return (DCMD_OK);
3559 }
3560 
3561 /*
3562  * *****************************************************************************
3563  * ********************************* smb_sid_t *********************************
3564  * *****************************************************************************
3565  */
3566 
3567 /*
3568  * ::smbsid
3569  */
3570 /*ARGSUSED*/
3571 static int
smbsid_dcmd(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)3572 smbsid_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
3573 {
3574 	/*
3575 	 * An smb_sid address is required.
3576 	 */
3577 	if (!(flags & DCMD_ADDRSPEC))
3578 		return (DCMD_USAGE);
3579 
3580 	return (smb_sid_print(addr));
3581 }
3582 
3583 /*
3584  * smb_sid_print
3585  */
3586 static int
smb_sid_print(uintptr_t addr)3587 smb_sid_print(uintptr_t addr)
3588 {
3589 	smb_sid_t	sid;
3590 	smb_sid_t	*psid;
3591 	size_t		sid_size;
3592 	uint64_t	authority;
3593 	int		ssa_off;
3594 	int		i;
3595 
3596 	GET_OFFSET(ssa_off, smb_sid_t, sid_subauth);
3597 	sid_size = ssa_off;
3598 
3599 	if (mdb_vread(&sid, sid_size, addr) != sid_size) {
3600 		mdb_warn("failed to read struct smb_sid at %p", addr);
3601 		return (DCMD_ERR);
3602 	}
3603 
3604 	sid_size += sid.sid_subauthcnt * sizeof (sid.sid_subauth[0]);
3605 
3606 	psid = mdb_zalloc(sid_size, UM_SLEEP | UM_GC);
3607 	if (mdb_vread(psid, sid_size, addr) != sid_size) {
3608 		mdb_warn("failed to read struct smb_sid at %p", addr);
3609 		return (DCMD_ERR);
3610 	}
3611 
3612 	mdb_printf("S-%d", psid->sid_revision);
3613 	authority = 0;
3614 	for (i = 0; i < NT_SID_AUTH_MAX; i++) {
3615 		authority += ((uint64_t)psid->sid_authority[i]) <<
3616 		    (8 * (NT_SID_AUTH_MAX - 1) - i);
3617 	}
3618 	mdb_printf("-%ll", authority);
3619 
3620 	for (i = 0; i < psid->sid_subauthcnt; i++)
3621 		mdb_printf("-%d", psid->sid_subauth[i]);
3622 
3623 	return (DCMD_OK);
3624 }
3625 
3626 /*
3627  * *****************************************************************************
3628  * ********************************* smb_fssd_t ********************************
3629  * *****************************************************************************
3630  */
3631 
3632 /*
3633  * ::smbfssd
3634  */
3635 static int
smbfssd_dcmd(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)3636 smbfssd_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
3637 {
3638 	smb_fssd_t	fssd;
3639 	int		rc;
3640 
3641 	/*
3642 	 * An smb_fssd address is required.
3643 	 */
3644 	if (!(flags & DCMD_ADDRSPEC))
3645 		return (DCMD_USAGE);
3646 
3647 	if (mdb_vread(&fssd, sizeof (fssd), addr) != sizeof (fssd)) {
3648 		mdb_warn("failed to read struct smb_fssd at %p", addr);
3649 		return (DCMD_ERR);
3650 	}
3651 
3652 	mdb_printf("FSSD secinfo: 0x%x\n", fssd.sd_secinfo);
3653 	if (fssd.sd_secinfo & SMB_OWNER_SECINFO)
3654 		mdb_printf("FSSD uid: %d\n", fssd.sd_uid);
3655 	if (fssd.sd_secinfo & SMB_GROUP_SECINFO)
3656 		mdb_printf("FSSD gid: %d\n", fssd.sd_gid);
3657 	if (fssd.sd_secinfo & SMB_SACL_SECINFO && fssd.sd_zsacl) {
3658 		mdb_printf("%<b>%<u>System ACL%</u>%</b>\n");
3659 		(void) mdb_inc_indent(SMB_DCMD_INDENT);
3660 		rc = mdb_call_dcmd("smbacl", (uintptr_t)fssd.sd_zsacl, flags,
3661 		    argc, argv);
3662 		(void) mdb_dec_indent(SMB_DCMD_INDENT);
3663 		if (rc != DCMD_OK)
3664 			return (rc);
3665 	}
3666 	if (fssd.sd_secinfo & SMB_DACL_SECINFO && fssd.sd_zdacl) {
3667 		mdb_printf("%<b>%<u>Discretionary ACL%</u>%</b>\n");
3668 		(void) mdb_inc_indent(SMB_DCMD_INDENT);
3669 		rc = mdb_call_dcmd("smbacl", (uintptr_t)fssd.sd_zdacl, flags,
3670 		    argc, argv);
3671 		(void)