smbsrv.c revision 148c5f43199ca0b43fc8e3b643aab11cd66ea327
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
*/
#include <mdb/mdb_modapi.h>
#include <sys/taskq_impl.h>
#include <smbsrv/smb_vops.h>
#include <smbsrv/smb_ktypes.h>
#define SMB_DCMD_INDENT 2
#define SMB_MDB_MAX_OPTS 9
#define SMB_OPT_SERVER 0x00000001
#define SMB_OPT_SESSION 0x00000002
#define SMB_OPT_REQUEST 0x00000004
#define SMB_OPT_USER 0x00000008
#define SMB_OPT_TREE 0x00000010
#define SMB_OPT_OFILE 0x00000020
#define SMB_OPT_ODIR 0x00000040
#define SMB_OPT_WALK 0x00000100
#define SMB_OPT_VERBOSE 0x00000200
#define SMB_OPT_ALL_OBJ 0x000000FF
/*
* Structure associating an ACE type to a string.
*/
typedef struct {
const char *ace_type_sting;
/*
* Structure containing strings describing an SMB command.
*/
typedef struct {
const char *smb_com;
const char *smb_andx;
/*
* Structure describing an object to be expanded (displayed).
*/
typedef struct {
const char *ex_dcmd;
const char *ex_name;
} smb_exp_t;
/*
* List of supported options. Ther order has the match the bits SMB_OPT_xxx.
*/
typedef struct smb_mdb_opts {
char *o_name;
{
{ "-s", SMB_OPT_SERVER },
{ "-e", SMB_OPT_SESSION },
{ "-r", SMB_OPT_REQUEST },
{ "-u", SMB_OPT_USER },
{ "-t", SMB_OPT_TREE },
{ "-f", SMB_OPT_OFILE },
{ "-d", SMB_OPT_ODIR },
{ "-w", SMB_OPT_WALK },
{ "-v", SMB_OPT_VERBOSE }
};
{
};
static void smb_dcmd_list_help(void);
static void smb_dcmd_session_help(void);
static void smb_dcmd_user_help(void);
static void smb_dcmd_tree_help(void);
static int smb_vfs_walk_init(mdb_walk_state_t *);
static int smb_vfs_walk_step(mdb_walk_state_t *);
static void smb_node_help(void);
static int smb_node_walk_init(mdb_walk_state_t *);
static int smb_node_walk_step(mdb_walk_state_t *);
static int smb_ace_walk_init(mdb_walk_state_t *);
static int smb_ace_walk_step(mdb_walk_state_t *);
static int smb_sid_print(uintptr_t);
static int smb_worker_findstack(uintptr_t);
/*
* MDB module linkage information:
*
* We declare a list of structures describing our dcmds, a list of structures
* describing our walkers and a function named _mdb_init to return a pointer
* to our module information.
*/
static const mdb_dcmd_t dcmds[] = {
{ "smblist",
"[-seutfdwv]",
"print tree of SMB objects",
{ "smbsrv",
"[-seutfdwv]",
"print smb_server information",
{ "smbvfs",
"[-v]",
"print smb_vfs information",
smb_vfs },
{ "smbnode",
"?[-vps]",
"print smb_node_t information",
{ "smbsess",
"[-utfdwv]",
"print smb_session_t information",
{ "smbreq",
":[-v]",
"print smb_request_t information",
{ "smblock", ":[-v]",
"print smb_lock_t information", smb_lock },
{ "smbuser",
":[-vdftq]",
"print smb_user_t information",
{ "smbtree",
":[-vdf]",
"print smb_tree_t information",
{ "smbodir",
":[-v]",
"print smb_odir_t information",
{ "smbofile",
"[-v]",
"print smb_odir_t information",
{ "smbstat", NULL,
"print all smb dispatched requests statistics",
smb_stats },
{ "smbace", "[-v]",
"print smb_ace_t information", smb_ace },
{ "smbacl", "[-v]",
"print smb_acl_t information", smb_acl },
{ "smbsid", "[-v]",
"print smb_sid_t information", smb_sid },
{ "smbsd", "[-v]",
"print smb_sd_t information", smb_sd },
{ "smbfssd", "[-v]",
"print smb_fssd_t information", smb_fssd },
{ NULL }
};
static const mdb_walker_t walkers[] = {
{ "smbnode_walker",
"walk list of smb_node_t structures",
NULL,
NULL },
{ "smbvfs_walker",
"walk list of smb_vfs_t structures",
NULL,
NULL },
{ "smbace_walker",
"walk list of smb_ace_t structures",
NULL,
NULL },
{ NULL }
};
static const mdb_modinfo_t modinfo = {
};
const mdb_modinfo_t *
_mdb_init(void)
{
return (&modinfo);
}
/*
* *****************************************************************************
* ****************************** Top level DCMD *******************************
* *****************************************************************************
*/
static void
smb_dcmd_list_help(void)
{
"Displays the list of objects using an indented tree format.\n"
"If no option is specified the entire tree is displayed\n\n");
(void) mdb_dec_indent(2);
mdb_printf("%<b>OPTIONS%</b>\n");
(void) mdb_inc_indent(2);
"-v\tDisplay verbose information\n"
"-s\tDisplay the list of servers\n"
"-e\tDisplay the list of sessions\n"
"-r\tDisplay the list of smb requests\n"
"-u\tDisplay the list of users\n"
"-t\tDisplay the list of trees\n"
"-f\tDisplay the list of open files\n"
"-d\tDisplay the list of open searches\n");
}
/*
* ::smblist
*
* This function lists the objects specified on the command line. If no object
* is specified the entire tree (server through ofile and odir) is displayed.
*
*/
/*ARGSUSED*/
static int
{
int new_argc;
return (DCMD_USAGE);
opts |= SMB_OPT_ALL_OBJ;
opts |= SMB_OPT_WALK;
mdb_warn("failed to find symbol smb_servers");
return (DCMD_ERR);
}
return (DCMD_ERR);
return (DCMD_OK);
}
/*
* *****************************************************************************
* ***************************** smb_server_t **********************************
* *****************************************************************************
*/
static const char *smb_server_state[SMB_SERVER_STATE_SENTINEL] =
{
"CREATED",
"CONFIGURED",
"RUNNING",
"STOPPING",
"DELETING"
};
/*
* List of objects that can be expanded under a server structure.
*/
static const smb_exp_t smb_server_exp[] =
{
"smbsess", "smb_session"},
"smbsess", "smb_session"},
"smbsess", "smb_session"},
"smbsess", "smb_session"},
};
/*
* ::smbsrv
*
* smbsrv dcmd - Print out smb_server structures.
*/
/*ARGSUSED*/
static int
{
return (DCMD_USAGE);
if (!(flags & DCMD_ADDRSPEC))
flags));
!(opts & SMB_OPT_WALK)) {
const char *state;
return (DCMD_ERR);
}
if (opts & SMB_OPT_VERBOSE) {
return (DCMD_ERR);
} else {
if (DCMD_HDRSPEC(flags))
"%<b>%<u>%-?s% "
"%-4s% "
"%-32s% "
"%</u>%</b>\n",
"SERVER", "ZONE", "STATE");
state = "UNKNOWN";
else
mdb_printf("%-?p %-4d %-32s \n",
}
}
return (DCMD_ERR);
return (DCMD_OK);
}
/*
* *****************************************************************************
* ***************************** smb_session_t *********************************
* *****************************************************************************
*/
static const char *smb_session_state[SMB_SESSION_STATE_SENTINEL] =
{
"INITIALIZED",
"DISCONNECTED",
"CONNECTED",
"ESTABLISHED",
"NEGOTIATED",
"OPLOCK_BREAKING",
"WRITE_RAW_ACTIVE",
"READ_RAW_ACTIVE",
"TERMINATED"
};
/*
* List of objects that can be expanded under a session structure.
*/
static const smb_exp_t smb_session_exp[] =
{
"smbreq", "smb_request"},
"smbuser", "smb_user"},
};
static void
smb_dcmd_session_help(void)
{
"Display the contents of smb_session_t, with optional"
" filtering.\n\n");
(void) mdb_dec_indent(2);
mdb_printf("%<b>OPTIONS%</b>\n");
(void) mdb_inc_indent(2);
"-v\tDisplay verbose smb_session information\n"
"-r\tDisplay the list of smb requests attached\n"
"-u\tDisplay the list of users attached\n");
}
/*
* ::smbsess
*
* smbsess dcmd - Print out the smb_session structure.
*/
/*ARGSUSED*/
static int
{
return (DCMD_USAGE);
if (!(flags & DCMD_ADDRSPEC)) {
opts |= SMB_OPT_SESSION;
opts &= ~SMB_OPT_SERVER;
}
!(opts & SMB_OPT_WALK)) {
const char *state;
return (DCMD_ERR);
}
state = "INVALID";
else
if (opts & SMB_OPT_VERBOSE) {
mdb_printf("%<b>%<u>SMB session information "
"(%p): %</u>%</b>\n", addr);
mdb_printf("Workstation Name: %s\n",
se->workstation);
state);
mdb_printf("Number of Users: %u\n",
mdb_printf("Number of active Transact.: %u\n\n",
} else {
if (DCMD_HDRSPEC(flags))
"%<b>%<u>%-?s "
"%-16s "
"%-16s %-16s%</u>%</b>\n",
"SESSION", "CLIENT_IP_ADDR",
"LOCAL_IP_ADDR", "STATE");
}
}
return (DCMD_ERR);
return (DCMD_OK);
}
/*
* *****************************************************************************
* **************************** smb_request_t **********************************
* *****************************************************************************
*/
static const char *smb_request_state[SMB_REQ_STATE_SENTINEL] =
{
"FREE",
"INITIALIZING",
"SUBMITTED",
"ACTIVE",
"WAITING_EVENT",
"EVENT_OCCURRED",
"WAITING_LOCK",
"COMPLETED",
"CANCELED",
"CLEANED_UP"
};
#define SMB_REQUEST_BANNER \
"%<b>%<u>%-?s %-?s %-14s %-14s %-16s %-32s%</u>%</b>\n"
#define SMB_REQUEST_FORMAT \
"%-?p %-?p %e %e %-16s %s\n"
static int
{
return (DCMD_USAGE);
if (!(flags & DCMD_ADDRSPEC)) {
opts |= SMB_OPT_REQUEST;
}
!(opts & SMB_OPT_WALK)) {
const char *state;
return (DCMD_ERR);
}
return (DCMD_ERR);
}
waiting = 0;
running = 0;
if (sr->sr_time_submitted != 0) {
if (sr->sr_time_active != 0) {
running = mdb_gethrtime() -
} else {
waiting = mdb_gethrtime() -
}
}
state = "INVALID";
else
if (opts & SMB_OPT_VERBOSE) {
"%</b>%</u>SMB request information (%p):"
"%</u>%</b>\n\n", addr);
"first SMB COM: %u (%s)\n"
"current SMB COM: %u (%s)\n"
"state: %u (%s)\n"
"TID(tree): %u (%p)\n"
"UID(user): %u (%p)\n"
"FID(file): %u (%p)\n"
"PID: %u\n"
"MID: %u\n\n"
"waiting time: %1.3e\n"
"running time: %1.3e",
running);
} else {
if (DCMD_HDRSPEC(flags))
"ADDR",
"WORKER",
"WAITING(s)",
"RUNNING(s)",
"STATE",
"COMMAND");
addr,
}
}
return (DCMD_OK);
}
/*
* *****************************************************************************
* ****************************** smb_user_t ***********************************
* *****************************************************************************
*/
static const char *smb_user_state[SMB_USER_STATE_SENTINEL] =
{
"LOGGED_IN",
"LOGGING_OFF",
"LOGGED_OFF"
};
/*
* List of objects that can be expanded under a user structure.
*/
static const smb_exp_t smb_user_exp[] =
{
"smbtree", "smb_tree"},
};
static void
smb_dcmd_user_help(void)
{
"Display the contents of smb_user_t, with optional filtering.\n\n");
(void) mdb_dec_indent(2);
mdb_printf("%<b>OPTIONS%</b>\n");
(void) mdb_inc_indent(2);
"-v\tDisplay verbose smb_user information\n"
"-d\tDisplay the list of smb_odirs attached\n"
"-f\tDisplay the list of smb_ofiles attached\n"
"-t\tDisplay the list of smb_trees attached\n");
}
static int
{
return (DCMD_USAGE);
if (!(flags & DCMD_ADDRSPEC)) {
opts |= SMB_OPT_USER;
}
!(opts & SMB_OPT_WALK)) {
char *account;
return (DCMD_ERR);
}
if (user->u_domain_len)
if (user->u_name_len)
if (opts & SMB_OPT_VERBOSE) {
const char *state;
state = "INVALID";
else
mdb_printf("%<b>%<u>SMB user information (%p):"
"%</u>%</b>\n", addr);
} else {
if (DCMD_HDRSPEC(flags))
"%<b>%<u>%?-s "
"%-5s "
"%-32s%</u>%</b>\n",
"USER", "UID", "ACCOUNT");
account);
}
}
return (DCMD_ERR);
return (DCMD_OK);
}
/*
* *****************************************************************************
* ****************************** smb_tree_t ***********************************
* *****************************************************************************
*/
static const char *smb_tree_state[SMB_TREE_STATE_SENTINEL] =
{
"CONNECTED",
"DISCONNECTING",
"DISCONNECTED"
};
/*
* List of objects that can be expanded under a tree structure.
*/
static const smb_exp_t smb_tree_exp[] =
{
"smbofile", "smb_ofile"},
{ SMB_OPT_ODIR,
"smbodir", "smb_odir"},
};
static void
smb_dcmd_tree_help(void)
{
"Display the contents of smb_tree_t, with optional filtering.\n\n");
(void) mdb_dec_indent(2);
mdb_printf("%<b>OPTIONS%</b>\n");
(void) mdb_inc_indent(2);
"-v\tDisplay verbose smb_tree information\n"
"-d\tDisplay the list of smb_odirs attached\n"
"-f\tDisplay the list of smb_ofiles attached\n");
}
static int
{
return (DCMD_USAGE);
if (!(flags & DCMD_ADDRSPEC)) {
opts |= SMB_OPT_TREE;
}
!(opts & SMB_OPT_WALK)) {
return (DCMD_ERR);
}
if (opts & SMB_OPT_VERBOSE) {
const char *state;
state = "INVALID";
else
mdb_printf("%<b>%<u>SMB tree information (%p):"
"%</u>%</b>\n\n", addr);
} else {
if (DCMD_HDRSPEC(flags))
"%<b>%<u>%-?s %-5s %-16s %-32s%</u>%</b>\n",
"TREE", "TID", "SHARE NAME", "RESOURCE");
}
}
return (DCMD_ERR);
return (DCMD_OK);
}
/*
* *****************************************************************************
* ****************************** smb_odir_t ***********************************
* *****************************************************************************
*/
static const char *smb_odir_state[SMB_ODIR_STATE_SENTINEL] =
{
"OPEN",
"IN_USE",
"CLOSING",
"CLOSED"
};
static int
{
return (DCMD_USAGE);
if (!(flags & DCMD_ADDRSPEC)) {
opts |= SMB_OPT_ODIR;
}
!(opts & SMB_OPT_WALK)) {
smb_odir_t *od;
return (DCMD_ERR);
}
if (opts & SMB_OPT_VERBOSE) {
const char *state;
state = "INVALID";
else
"%<b>%<u>SMB odir information (%p):%</u>%</b>\n\n",
addr);
} else {
if (DCMD_HDRSPEC(flags))
"%<b>%<u>%-?s "
"%-5s "
"%-?s "
"%-16s%</u>%</b>\n",
"ODIR", "SID", "VNODE", "PATTERN");
mdb_printf("%?p %-5u %-16p %s\n",
}
}
return (DCMD_OK);
}
/*
* *****************************************************************************
* ****************************** smb_ofile_t **********************************
* *****************************************************************************
*/
static const char *smb_ofile_state[SMB_OFILE_STATE_SENTINEL] =
{
"OPEN",
"CLOSING",
"CLOSED"
};
static int
{
return (DCMD_USAGE);
if (!(flags & DCMD_ADDRSPEC)) {
opts |= SMB_OPT_OFILE;
}
!(opts & SMB_OPT_WALK)) {
return (DCMD_ERR);
}
if (opts & SMB_OPT_VERBOSE) {
const char *state;
state = "INVALID";
else
"%<b>%<u>SMB ofile information (%p):%</u>%</b>\n\n",
addr);
mdb_printf("LLF Offset: 0x%llx (%s)\n",
"Valid" : "Invalid"));
} else {
if (DCMD_HDRSPEC(flags))
"%<b>%<u>%-?s "
"%-5s "
"%-?s "
"%-?s%</u>%</b>\n",
"OFILE", "FID", "SMB NODE", "CRED");
}
}
return (DCMD_OK);
}
/*
* *****************************************************************************
* ******************************** smb_vfs_t **********************************
* *****************************************************************************
*/
/*
* ::smbvfs
*
* smbvfs dcmd - Prints out smb_vfs structures.
*/
/*ARGSUSED*/
static int
{
char *path;
return (DCMD_USAGE);
/*
* If no smb_vfs address was specified on the command line, we can
* print out all smb_vfs by invoking the smb_vfs walker, using
* this dcmd itself as the callback.
*/
if (!(flags & DCMD_ADDRSPEC)) {
mdb_warn("failed to walk 'smb_vfs'");
return (DCMD_ERR);
}
return (DCMD_OK);
}
if (DCMD_HDRSPEC(flags)) {
"%<b>%<u>"
"%-?s "
"%-10s "
"%-16s "
"%-16s"
"%-s"
"%</u>%</b>\n",
"SMB_VFS", "REFCNT", "VFS", "VNODE", "ROOT");
}
return (DCMD_ERR);
}
return (DCMD_ERR);
}
return (DCMD_OK);
}
/*
* Initialize the smb_vfs_t walker by reading the value of smb_export
* in the kernel's symbol table. Only global walk supported.
*/
static int
{
mdb_printf("smb_vfs walk only supports global walks\n");
return (WALK_ERR);
}
mdb_warn("failed to find 'smb_export'");
return (WALK_ERR);
}
mdb_warn("failed to walk list of VFS");
return (WALK_ERR);
}
return (WALK_NEXT);
}
static int
{
wsp->walk_cbdata));
}
/*
* *****************************************************************************
* ******************************* smb_node_t **********************************
* *****************************************************************************
*/
static void
smb_node_help(void)
{
"Display the contents of smb_node_t, with optional filtering.\n\n");
(void) mdb_dec_indent(2);
mdb_printf("%<b>OPTIONS%</b>\n");
(void) mdb_inc_indent(2);
"-v\tDisplay verbose smb_node information\n"
"-p\tDisplay the full path of the vnode associated\n"
"-s\tDisplay the stack of the last 16 calls that modified the "
"reference\n\tcount\n");
}
/*
* ::smbnode
*
* smb_node dcmd - Print out smb_node structure.
*/
static int
{
int print_full_path = FALSE;
int stack_trace = FALSE;
char od_name[MAXNAMELEN];
char path_name[1024];
return (DCMD_USAGE);
/*
* If no smb_node address was specified on the command line, we can
* print out all smb nodes by invoking the smb_node walker, using
* this dcmd itself as the callback.
*/
if (!(flags & DCMD_ADDRSPEC)) {
mdb_warn("failed to walk 'smb_node'");
return (DCMD_ERR);
}
return (DCMD_OK);
}
/*
* If this is the first invocation of the command, print a nice
* header line for the output that will follow.
*/
if (DCMD_HDRSPEC(flags)) {
if (verbose) {
mdb_printf("%<b>%<u>SMB node information:%</u>%</b>\n");
} else {
"%<b>%<u>%-?s "
"%-?s "
"%-18s "
"%-6s "
"%-6s "
"%-6s%</u>%</b>\n",
"ADDR", "VP", "NODE-NAME", "OFILES", "LOCKS",
"REF");
}
}
/*
* For each smb_node, we just need to read the smb_node_t struct, read
* and then print out the following fields.
*/
if (print_full_path) {
(void) mdb_snprintf(od_name,
sizeof (od_name), "N/A");
}
}
}
if (verbose) {
if (print_full_path)
mdb_printf("Range Locks: %u\n",
(void) mdb_inc_indent(SMB_DCMD_INDENT);
mdb_warn("failed to walk node's active"
" locks");
}
(void) mdb_dec_indent(SMB_DCMD_INDENT);
}
} else {
mdb_printf("%-?p %-?p %-18s %-6d %-6d %-6d\n",
if (print_full_path)
}
int ctr;
mdb_warn("failed to read audit buffer");
return (DCMD_ERR);
}
while (ctr) {
char c[MDB_SYM_NAMLEN];
int i;
mdb_printf("\nRefCnt: %u\t",
anr->anr_refcnt);
for (i = 0;
i++) {
if (mdb_lookup_by_addr(
c, sizeof (c),
&sym) == -1) {
continue;
}
mdb_printf("%s+0x%1x",
c,
++i;
break;
}
if (mdb_lookup_by_addr(
c, sizeof (c),
&sym) == -1) {
++i;
continue;
}
mdb_printf("\n\t\t%s+0x%1x",
c,
++i;
}
mdb_printf("\n");
}
ctr--;
}
}
} else {
return (DCMD_ERR);
}
return (DCMD_OK);
}
/*
* Initialize the smb_node_t walker by reading the value of smb_node_hash_table
* in the kernel's symbol table. Only global walk supported.
*/
static int
{
int i;
mdb_warn("failed to find 'smb_node_hash_table'");
return (WALK_ERR);
}
} else {
mdb_printf("smb_node walk only supports global walks\n");
return (WALK_ERR);
}
for (i = 0; i < SMBND_HASH_MASK + 1; i++) {
mdb_warn("failed to walk 'list'");
return (WALK_ERR);
}
}
return (WALK_NEXT);
}
static int
{
wsp->walk_cbdata));
}
/*
* *****************************************************************************
* ****************************** smb_lock_t ***********************************
* *****************************************************************************
*/
static int
{
char *lock_type;
return (DCMD_USAGE);
/*
* An smb_lock_t address must be specified.
*/
if (!(flags & DCMD_ADDRSPEC))
return (DCMD_USAGE);
/*
* If this is the first invocation of the command, print a nice
* header line for the output that will follow.
*/
if (DCMD_HDRSPEC(flags)) {
if (verbose)
mdb_printf("SMB lock information:\n\n");
else
mdb_printf("%<u>%-?s %4s %16s %8s %9s%</u>\n",
"Locks: ", "TYPE", "START", "LENGTH",
"CONFLICTS");
}
case SMB_LOCK_TYPE_READWRITE:
lock_type = "RW";
break;
case SMB_LOCK_TYPE_READONLY:
lock_type = "RO";
break;
default:
lock_type = "N/A";
break;
}
if (verbose) {
mdb_printf("Type :\t%s (%u)\n",
mdb_printf("Start :\t%llx\n",
mdb_printf("Length :\t%lx\n",
mdb_printf("Session :\t%p\n",
mdb_printf("File :\t%p\n",
mdb_printf("User ID :\t%u\n",
mdb_printf("Process ID :\t%u\n",
mdb_printf("Conflicts :\t%u\n",
(void) mdb_inc_indent(SMB_DCMD_INDENT);
mdb_warn("failed to walk conflict "
"locks ");
}
(void) mdb_dec_indent(SMB_DCMD_INDENT);
}
mdb_printf("Blocked by :\t%p\n",
mdb_printf("Flags :\t0x%x\n",
mdb_printf("\n");
} else {
}
} else {
return (DCMD_ERR);
}
return (DCMD_OK);
}
/*
* ::smbstat
*
* Prints SMB requests statistics.
*/
/*ARGSUSED*/
static int
{
if (!(flags & DCMD_ADDRSPEC))
return (DCMD_USAGE);
return (DCMD_ERR);
}
return (DCMD_ERR);
}
"\n%<b> nbt tcp users trees files pipes%</b>\n"
"%5d %5d %5d %5d %5d %5d\n",
return (DCMD_OK);
}
/*
* *****************************************************************************
* ******************************** smb_ace_t **********************************
* *****************************************************************************
*/
{
ACE_TYPE_ENTRY(0x11),
ACE_TYPE_ENTRY(0x12),
ACE_TYPE_ENTRY(0x13),
ACE_TYPE_ENTRY(0x14),
ACE_TYPE_ENTRY(0x15),
ACE_TYPE_ENTRY(0x16),
ACE_TYPE_ENTRY(0x17),
ACE_TYPE_ENTRY(0x18),
ACE_TYPE_ENTRY(0x19),
ACE_TYPE_ENTRY(0x1A),
ACE_TYPE_ENTRY(0x1B),
ACE_TYPE_ENTRY(0x1C),
ACE_TYPE_ENTRY(0x1D),
ACE_TYPE_ENTRY(0x1E),
ACE_TYPE_ENTRY(0x1F)
};
static const mdb_bitmask_t ace_flag_bits[] = {
{ "CONTAINER_INHERIT_ACE", CONTAINER_INHERIT_ACE,
{ "NO_PROPOGATE_INHERIT_ACE", NO_PROPOGATE_INHERIT_ACE,
{ "SUCCESSFUL_ACCESS_ACE_FLAG", SUCCESSFUL_ACCESS_ACE_FLAG,
{ "FAILED_ACCESS_ACE_FLAG", FAILED_ACCESS_ACE_FLAG,
{ NULL, 0, 0 }
};
/*
* ::smbace
*/
static int
{
const char *ptr;
int rc;
return (DCMD_USAGE);
/*
* An smb_ace address is required.
*/
if (!(flags & DCMD_ADDRSPEC))
return (DCMD_USAGE);
return (DCMD_ERR);
}
if (verbose) {
else
ptr = "Unknown";
mdb_printf("ACE SID: ");
} else {
if (DCMD_HDRSPEC(flags))
"%<b>%<u>%?-s %-4s %-4s %-8s %s%</u>%</b>\n",
"ACE", "TYPE", "FLAGS", "MASK", "SID");
}
mdb_printf("\n");
return (rc);
}
static int
{
mdb_printf("smb_ace walk only supports local walks\n");
return (WALK_ERR);
}
mdb_warn("failed to walk list of ACEs");
return (WALK_ERR);
}
return (WALK_NEXT);
}
static int
{
wsp->walk_cbdata));
}
/*
* *****************************************************************************
* ******************************** smb_acl_t **********************************
* *****************************************************************************
*/
/*
* ::smbacl
*/
static int
{
/* An smb_acl address is required. */
if (!(flags & DCMD_ADDRSPEC))
return (DCMD_USAGE);
return (DCMD_ERR);
}
(void) mdb_inc_indent(SMB_DCMD_INDENT);
(void) mdb_dec_indent(SMB_DCMD_INDENT);
return (DCMD_ERR);
}
(void) mdb_dec_indent(SMB_DCMD_INDENT);
return (DCMD_OK);
}
/*
* *****************************************************************************
* ********************************* smb_sd_t **********************************
* *****************************************************************************
*/
/*
* ::smbsd
*/
static int
{
int rc;
/*
* An smb_sid address is required.
*/
if (!(flags & DCMD_ADDRSPEC))
return (DCMD_USAGE);
return (DCMD_ERR);
}
mdb_printf("\t SE_OWNER_DEFAULTED\n");
mdb_printf("\t SE_GROUP_DEFAULTED\n");
mdb_printf("\t SE_DACL_PRESENT\n");
mdb_printf("\t SE_DACL_DEFAULTED\n");
mdb_printf("\t SE_SACL_PRESENT\n");
mdb_printf("\t SE_SACL_DEFAULTED\n");
mdb_printf("\t SE_DACL_AUTO_INHERIT_REQ\n");
mdb_printf("\t SE_SACL_AUTO_INHERIT_REQ\n");
mdb_printf("\t SE_DACL_AUTO_INHERITED\n");
mdb_printf("\t SE_SACL_AUTO_INHERITED\n");
mdb_printf("\t SE_DACL_PROTECTED\n");
mdb_printf("\t SE_SACL_PROTECTED\n");
mdb_printf("\t SE_SELF_RELATIVE\n");
mdb_printf("SID of Owner: ");
return (rc);
mdb_printf("\nSID of Group: ");
return (rc);
mdb_printf("\n");
mdb_printf("%<b>%<u>System ACL%</u>%</b>\n");
(void) mdb_inc_indent(SMB_DCMD_INDENT);
(void) mdb_dec_indent(SMB_DCMD_INDENT);
return (rc);
}
mdb_printf("%<b>%<u>Discretionary ACL%</u>%</b>\n");
(void) mdb_inc_indent(SMB_DCMD_INDENT);
(void) mdb_dec_indent(SMB_DCMD_INDENT);
return (rc);
}
return (DCMD_OK);
}
/*
* *****************************************************************************
* ********************************* smb_sid_t *********************************
* *****************************************************************************
*/
/*
* ::smbsid
*/
/*ARGSUSED*/
static int
{
/*
* An smb_sid address is required.
*/
if (!(flags & DCMD_ADDRSPEC))
return (DCMD_USAGE);
return (smb_sid_print(addr));
}
/*
* smb_sid_print
*/
static int
{
int i;
return (DCMD_ERR);
}
return (DCMD_ERR);
}
authority = 0;
for (i = 0; i < NT_SID_AUTH_MAX; i++) {
}
for (i = 0; i < psid->sid_subauthcnt; i++)
return (DCMD_OK);
}
/*
* *****************************************************************************
* ********************************* smb_fssd_t ********************************
* *****************************************************************************
*/
/*
* ::smbfssd
*/
static int
{
int rc;
/*
* An smb_fssd address is required.
*/
if (!(flags & DCMD_ADDRSPEC))
return (DCMD_USAGE);
return (DCMD_ERR);
}
mdb_printf("%<b>%<u>System ACL%</u>%</b>\n");
(void) mdb_inc_indent(SMB_DCMD_INDENT);
(void) mdb_dec_indent(SMB_DCMD_INDENT);
return (rc);
}
mdb_printf("%<b>%<u>Discretionary ACL%</u>%</b>\n");
(void) mdb_inc_indent(SMB_DCMD_INDENT);
(void) mdb_dec_indent(SMB_DCMD_INDENT);
return (rc);
}
return (DCMD_OK);
}
/*
* *****************************************************************************
* **************************** Utility Funcions *******************************
* *****************************************************************************
*/
/*
* smb_dcmd_getopt
*
* This function analyzes the arguments passed in and sets the bit corresponding
* to the options found in the opts variable.
*
* Return Value
*
* -1 An error occured during the decoding
* 0 The decoding was successful
*/
static int
{
*opts = 0;
return (-1);
return (0);
}
/*
* smb_dcmd_setopt
*
* This function set the arguments corresponding to the bits set in opts.
*
* Return Value
*
* Number of arguments set.
*/
static int
{
int i;
int argc = 0;
for (i = 0; i < SMB_MDB_MAX_OPTS; i++) {
argc++;
argv++;
}
}
return (argc);
}
/*
* smb_obj_expand
*/
static int
{
int rc = 0;
int argc;
(void) mdb_inc_indent(indent);
while (x->ex_dcmd) {
if (rc) {
mdb_warn("failed to walk the list of %s in %p",
break;
}
}
x++;
}
(void) mdb_dec_indent(indent);
return (rc);
}
/*
* smb_obj_list
*
* Function called by the DCMDs when no address is provided. It expands the
* tree under the object type associated with the calling DCMD (based on the
* flags passed in).
*
* Return Value
*
* DCMD_OK
* DCMD_ERR
*/
static int
{
int argc;
return (DCMD_ERR);
}
return (DCMD_OK);
}
static int
{
kthread_t t;
char cmd[80];
return (DCMD_ERR);
}
mdb_inc_indent(2);
if (t.t_tid == 0) {
else
}
mdb_dec_indent(2);
mdb_printf("\n");
return (DCMD_OK);
}