--- old/usr/src/cmd/smbsrv/dtrace/Makefile	Fri Mar 31 14:29:37 2017
+++ new/usr/src/cmd/smbsrv/dtrace/Makefile	Fri Mar 31 14:29:37 2017
@@ -22,11 +22,11 @@
 # Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 # Use is subject to license terms.
 #
-# Copyright 2014 Nexenta Systems, Inc.  All rights reserved.
+# Copyright 2017 Nexenta Systems, Inc.  All rights reserved.
 #
 
 SRCS=	smbd-all.d smbd-authsvc.d smbd-doorsvc.d smbd-pipesvc.d \
-	smbnode.d smbsrv.d smbvfs.d
+	smbnode.d smbsrv.d smbvfs.d smb-trace.d
 
 include ../../Makefile.cmd
 
--- /dev/null	Fri Mar 31 14:29:37 2017
+++ new/usr/src/cmd/smbsrv/dtrace/smb-trace.d	Fri Mar 31 14:29:37 2017
@@ -0,0 +1,166 @@
+/*
+ * This file and its contents are supplied under the terms of the
+ * Common Development and Distribution License ("CDDL"), version 1.0.
+ * You may only use this file in accordance with the terms of version
+ * 1.0 of the CDDL.
+ *
+ * A full copy of the text of the CDDL should have accompanied this
+ * source.  A copy of the CDDL is also available via the Internet at
+ * http://www.illumos.org/license/CDDL.
+ */
+
+/*
+ * Copyright 2017 Nexenta Systems, Inc.  All rights reserved.
+ */
+
+/*
+ * Example using the "smb" dtrace provider.
+ * Traces all SMB commands.
+ *
+ * All these probes provide:
+ *	args[0]  conninfo_t
+ *	args[1]  smbopinfo_t
+ * Some also provide one of: (not used here)
+ *	args[2]  smb_name_args_t
+ *	args[2]  smb_open_args_t
+ *	args[2]  smb_rw_args_t
+ */
+
+
+smb:::op-CheckDirectory-start,
+smb:::op-CloseAndTreeDisconnect-start,
+smb:::op-ClosePrintFile-start,
+smb:::op-Close-start,
+smb:::op-CreateDirectory-start,
+smb:::op-CreateNew-start,
+smb:::op-CreateTemporary-start,
+smb:::op-Create-start,
+smb:::op-DeleteDirectory-start,
+smb:::op-Delete-start,
+smb:::op-Echo-start,
+smb:::op-FindClose2-start,
+smb:::op-FindClose-start,
+smb:::op-FindUnique-start,
+smb:::op-Find-start,
+smb:::op-Flush-start,
+smb:::op-GetPrintQueue-start,
+smb:::op-Invalid-start,
+smb:::op-Ioctl-start,
+smb:::op-LockAndRead-start,
+smb:::op-LockByteRange-start,
+smb:::op-LockingX-start,
+smb:::op-LogoffX-start,
+smb:::op-Negotiate-start,
+smb:::op-NtCancel-start,
+smb:::op-NtCreateX-start,
+smb:::op-NtRename-start,
+smb:::op-NtTransactCreate-start,
+smb:::op-NtTransactSecondary-start,
+smb:::op-NtTransact-start,
+smb:::op-OpenPrintFile-start,
+smb:::op-OpenX-start,
+smb:::op-Open-start,
+smb:::op-ProcessExit-start,
+smb:::op-QueryInformation2-start,
+smb:::op-QueryInformationDisk-start,
+smb:::op-QueryInformation-start,
+smb:::op-ReadRaw-start,
+smb:::op-ReadX-start,
+smb:::op-Read-start,
+smb:::op-Rename-start,
+smb:::op-Search-start,
+smb:::op-Seek-start,
+smb:::op-SessionSetupX-start,
+smb:::op-SetInformation2-start,
+smb:::op-SetInformation-start,
+smb:::op-Transaction2Secondary-start,
+smb:::op-Transaction2-start,
+smb:::op-TransactionSecondary-start,
+smb:::op-Transaction-start,
+smb:::op-TreeConnectX-start,
+smb:::op-TreeConnect-start,
+smb:::op-TreeDisconnect-start,
+smb:::op-UnlockByteRange-start,
+smb:::op-WriteAndClose-start,
+smb:::op-WriteAndUnlock-start,
+smb:::op-WritePrintFile-start,
+smb:::op-WriteRaw-start,
+smb:::op-WriteX-start,
+smb:::op-Write-start
+{
+	printf("%s clnt=%s uid=0x%x tid=0x%x mid=0x%x\n",
+	       probename,
+	       args[0]->ci_remote,
+	       args[1]->soi_uid,
+	       args[1]->soi_tid,
+	       args[1]->soi_mid);
+}
+	
+
+smb:::op-Close-done,
+smb:::op-CloseAndTreeDisconnect-done,
+smb:::op-Transaction-done,
+smb:::op-TransactionSecondary-done,
+smb:::op-Ioctl-done,
+smb:::op-Transaction2-done,
+smb:::op-Transaction2Secondary-done,
+smb:::op-NtTransact-done,
+smb:::op-NtTransactSecondary-done,
+smb:::op-Create-done,
+smb:::op-CreateNew-done,
+smb:::op-CreateTemporary-done,
+smb:::op-Delete-done,
+smb:::op-CreateDirectory-done,
+smb:::op-DeleteDirectory-done,
+smb:::op-CheckDirectory-done,
+smb:::op-Invalid-done,
+smb:::op-Echo-done,
+smb:::op-Search-done,
+smb:::op-Find-done,
+smb:::op-FindClose-done,
+smb:::op-FindUnique-done,
+smb:::op-Flush-done,
+smb:::op-QueryInformationDisk-done,
+smb:::op-LockByteRange-done,
+smb:::op-LockingX-done,
+smb:::op-LogoffX-done,
+smb:::op-Negotiate-done,
+smb:::op-NtCancel-done,
+smb:::op-NtCreateX-done,
+smb:::op-NtTransactCreate-done,
+smb:::op-Open-done,
+smb:::op-OpenX-done,
+smb:::op-OpenPrintFile-done,
+smb:::op-ClosePrintFile-done,
+smb:::op-GetPrintQueue-done,
+smb:::op-WritePrintFile-done,
+smb:::op-ProcessExit-done,
+smb:::op-QueryInformation-done,
+smb:::op-QueryInformation2-done,
+smb:::op-Read-done,
+smb:::op-LockAndRead-done,
+smb:::op-ReadRaw-done,
+smb:::op-ReadX-done,
+smb:::op-Rename-done,
+smb:::op-NtRename-done,
+smb:::op-Seek-done,
+smb:::op-SessionSetupX-done,
+smb:::op-SetInformation-done,
+smb:::op-SetInformation2-done,
+smb:::op-FindClose2-done,
+smb:::op-TreeConnect-done,
+smb:::op-TreeConnectX-done,
+smb:::op-TreeDisconnect-done,
+smb:::op-UnlockByteRange-done,
+smb:::op-Write-done,
+smb:::op-WriteAndClose-done,
+smb:::op-WriteAndUnlock-done,
+smb:::op-WriteRaw-done,
+smb:::op-WriteX-done
+{
+	printf("%s clnt=%s mid=0x%x status=0x%x\n",
+	       probename,
+	       args[0]->ci_remote,
+	       args[1]->soi_mid,
+	       args[1]->soi_status);
+}
--- old/usr/src/lib/libdtrace/Makefile.com	Fri Mar 31 14:29:37 2017
+++ new/usr/src/lib/libdtrace/Makefile.com	Fri Mar 31 14:29:37 2017
@@ -94,6 +94,7 @@
 	sched.d \
 	signal.d \
 	scsi.d \
+	smb.d \
 	srp.d \
 	sysevent.d \
 	tcp.d \
--- /dev/null	Fri Mar 31 14:29:38 2017
+++ new/usr/src/lib/libdtrace/common/smb.d	Fri Mar 31 14:29:38 2017
@@ -0,0 +1,119 @@
+/*
+ * 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
+ * or http://www.opensolaris.org/os/licensing.
+ * 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
+ */
+
+/*
+ * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ *
+ * Copyright 2013 Nexenta Systems, Inc.  All rights reserved.
+ */
+
+#pragma	D depends_on library ip.d
+#pragma	D depends_on library net.d
+#pragma	D depends_on module genunix
+#pragma	D depends_on module smbsrv
+
+#pragma D binding "1.5" translator
+translator conninfo_t < struct smb_request *P > {
+	ci_protocol =
+	    P->session->ipaddr.a_family == AF_INET6 ? "tcp6" :
+	    P->session->ipaddr.a_family == AF_INET ? "tcp" :
+	    "<unknown>";
+	ci_local = "<any>"; /* not interesting */
+	ci_remote = P->session->ip_addr_str;
+};
+
+/*
+ * The smbopinfo_t structure describes the internal form of a
+ * single SMB request (SMB v1).
+ */
+typedef struct smbopinfo {
+	cred_t   *soi_cred;		/* credentials for operation */
+	string   soi_curpath;		/* file handle path (if any) */
+	uint64_t soi_sid;		/* session id */
+	uint32_t soi_pid;		/* process id */
+	uint32_t soi_status;		/* status */
+	uint16_t soi_tid;		/* tree id */
+	uint16_t soi_uid;		/* user id */
+	uint16_t soi_mid;		/* request id */
+	uint16_t soi_fid;		/* file id */
+	uint16_t soi_flags2;		/* flags2 */
+	uint8_t  soi_flags;		/* flags */
+} smbopinfo_t;
+
+#pragma D binding "1.5" translator
+translator smbopinfo_t < struct smb_request *P > {
+	soi_cred	= (cred_t *)P->user_cr;
+	soi_sid		= P->session->s_kid;
+	soi_pid		= P->smb_pid;
+ 	soi_status	= P->smb_error.status;
+	soi_tid		= P->smb_tid;
+	soi_uid		= P->smb_uid;
+	soi_mid		= P->smb_mid;
+	soi_fid		= P->smb_fid;
+	soi_flags2	= P->smb_flg2;
+	soi_flags	= P->smb_flg;
+
+	soi_curpath = (P->fid_ofile == NULL ||
+	    P->fid_ofile->f_node == NULL ||
+	    P->fid_ofile->f_node->vp == NULL ||
+	    P->fid_ofile->f_node->vp->v_path == NULL) ? "<NULL>" :
+	    P->fid_ofile->f_node->vp->v_path;
+};
+
+typedef struct smb_rw_args {
+	off_t	soa_offset;
+	uint_t	soa_count;
+} smb_rw_args_t;
+
+#pragma D binding "1.5" translator
+translator smb_rw_args_t < smb_request_t *P > {
+	soa_offset = P->arg.rw->rw_offset;
+	soa_count  = P->arg.rw->rw_count;
+};
+
+typedef struct smb_name_args {
+	string	soa_name;
+} smb_name_args_t;
+
+#pragma D binding "1.5" translator
+translator smb_name_args_t < smb_request_t *P > {
+	soa_name = (P->arg.dirop.fqi.fq_path.pn_path == NULL) ? "<NULL>" :
+	    P->arg.dirop.fqi.fq_path.pn_path;
+};
+
+typedef struct smb_open_args {
+	string		soa_name;
+	uint32_t	soa_desired_access;
+	uint32_t	soa_share_access;
+	uint32_t	soa_create_options;
+	uint32_t	soa_create_disposition;
+} smb_open_args_t;
+
+#pragma D binding "1.5" translator
+translator smb_open_args_t < smb_request_t *P > {
+	soa_name = (P->arg.open.fqi.fq_path.pn_path == NULL) ? "<NULL>" :
+	    P->arg.open.fqi.fq_path.pn_path;
+	soa_desired_access = P->arg.open.desired_access;
+	soa_share_access   = P->arg.open.share_access;
+	soa_create_options = P->arg.open.create_options;
+	soa_create_disposition = P->arg.open.create_disposition;
+};
--- old/usr/src/pkg/manifests/developer-dtrace.mf	Fri Mar 31 14:29:38 2017
+++ new/usr/src/pkg/manifests/developer-dtrace.mf	Fri Mar 31 14:29:38 2017
@@ -200,6 +200,7 @@
 file path=usr/lib/dtrace/sched.d mode=0444
 file path=usr/lib/dtrace/scsi.d mode=0444
 file path=usr/lib/dtrace/signal.d mode=0444
+file path=usr/lib/dtrace/smb.d mode=0444
 file path=usr/lib/dtrace/srp.d mode=0444
 file path=usr/lib/dtrace/sysevent.d mode=0444
 file path=usr/lib/dtrace/tcp.d mode=0444
--- old/usr/src/pkg/manifests/service-file-system-smb.mf	Fri Mar 31 14:29:38 2017
+++ new/usr/src/pkg/manifests/service-file-system-smb.mf	Fri Mar 31 14:29:38 2017
@@ -79,6 +79,7 @@
 $(i386_ONLY)file path=usr/lib/mdb/kvm/smbsrv.so group=sys mode=0555
 file path=usr/lib/reparse/libreparse_smb.so.1
 file path=usr/lib/security/pam_smb_passwd.so.1
+file path=usr/lib/smbsrv/dtrace/smb-trace.d mode=0555
 file path=usr/lib/smbsrv/dtrace/smbd-all.d mode=0555
 file path=usr/lib/smbsrv/dtrace/smbd-authsvc.d mode=0555
 file path=usr/lib/smbsrv/dtrace/smbd-doorsvc.d mode=0555
--- old/usr/src/uts/common/dtrace/sdt_subr.c	Fri Mar 31 14:29:38 2017
+++ new/usr/src/uts/common/dtrace/sdt_subr.c	Fri Mar 31 14:29:38 2017
@@ -21,6 +21,7 @@
 /*
  * Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved.
  * Copyright (c) 2012, Joyent, Inc. All rights reserved.
+ * Copyright 2013 Nexenta Systems, Inc.  All rights reserved.
  */
 
 #include <sys/sdt_impl.h>
@@ -113,6 +114,7 @@
 	{ "iscsi", "__iscsi_", &iscsi_attr },
 	{ "nfsv3", "__nfsv3_", &stab_attr },
 	{ "nfsv4", "__nfsv4_", &stab_attr },
+	{ "smb", "__smb_", &stab_attr },
 	{ "xpv", "__xpv_", &xpv_attr },
 	{ "fc", "__fc_", &fc_attr },
 	{ "srp", "__srp_", &fc_attr },
@@ -875,6 +877,342 @@
 	    "nfsv4cbinfo_t *" },
 	{ "nfsv4", "cb-recall-done", 2, 2, "CB_RECALL4res *" },
 
+	/* Tables like this get really ugly when line-wrapped. */
+	/* BEGIN CSTYLED */
+	{ "smb", "op-Close-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-Close-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-Close-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-Close-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+
+	{ "smb", "op-CloseAndTreeDisconnect-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-CloseAndTreeDisconnect-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-CloseAndTreeDisconnect-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-CloseAndTreeDisconnect-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+
+	{ "smb", "op-Transaction-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-Transaction-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-Transaction-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-Transaction-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+
+	{ "smb", "op-TransactionSecondary-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-TransactionSecondary-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-TransactionSecondary-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-TransactionSecondary-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+
+	{ "smb", "op-Ioctl-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-Ioctl-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-Ioctl-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-Ioctl-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+
+	{ "smb", "op-Transaction2-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-Transaction2-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-Transaction2-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-Transaction2-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+
+	{ "smb", "op-Transaction2Secondary-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-Transaction2Secondary-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-Transaction2Secondary-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-Transaction2Secondary-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+
+	{ "smb", "op-NtTransact-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-NtTransact-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-NtTransact-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-NtTransact-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+
+	{ "smb", "op-NtTransactSecondary-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-NtTransactSecondary-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-NtTransactSecondary-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-NtTransactSecondary-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+
+	{ "smb", "op-Create-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-Create-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-Create-start", 2, 0, "smb_request_t *", "smb_open_args_t *" },
+	{ "smb", "op-Create-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-Create-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+
+	{ "smb", "op-CreateNew-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-CreateNew-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-CreateNew-start", 2, 0, "smb_request_t *", "smb_open_args_t *" },
+	{ "smb", "op-CreateNew-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-CreateNew-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+
+	{ "smb", "op-CreateTemporary-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-CreateTemporary-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-CreateTemporary-start", 2, 0, "smb_request_t *", "smb_open_args_t *" },
+	{ "smb", "op-CreateTemporary-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-CreateTemporary-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+
+	{ "smb", "op-Delete-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-Delete-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-Delete-start", 2, 0, "smb_request_t *", "smb_name_args_t *" },
+	{ "smb", "op-Delete-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-Delete-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+
+	{ "smb", "op-CreateDirectory-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-CreateDirectory-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-CreateDirectory-start", 2, 0, "smb_request_t *", "smb_name_args_t *" },
+	{ "smb", "op-CreateDirectory-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-CreateDirectory-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+
+	{ "smb", "op-DeleteDirectory-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-DeleteDirectory-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-DeleteDirectory-start", 2, 0, "smb_request_t *", "smb_name_args_t *" },
+	{ "smb", "op-DeleteDirectory-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-DeleteDirectory-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+
+	{ "smb", "op-CheckDirectory-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-CheckDirectory-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-CheckDirectory-start", 2, 0, "smb_request_t *", "smb_name_args_t *" },
+	{ "smb", "op-CheckDirectory-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-CheckDirectory-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+
+	{ "smb", "op-Invalid-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-Invalid-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-Invalid-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-Invalid-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+
+	{ "smb", "op-Echo-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-Echo-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-Echo-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-Echo-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+
+	{ "smb", "op-Search-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-Search-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-Search-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-Search-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+
+	{ "smb", "op-Find-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-Find-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-Find-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-Find-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+
+	{ "smb", "op-FindClose-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-FindClose-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-FindClose-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-FindClose-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+
+	{ "smb", "op-FindUnique-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-FindUnique-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-FindUnique-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-FindUnique-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+
+	{ "smb", "op-Flush-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-Flush-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-Flush-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-Flush-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+
+	{ "smb", "op-QueryInformationDisk-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-QueryInformationDisk-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-QueryInformationDisk-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-QueryInformationDisk-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+
+	{ "smb", "op-LockByteRange-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-LockByteRange-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-LockByteRange-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-LockByteRange-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+
+	{ "smb", "op-LockingX-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-LockingX-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-LockingX-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-LockingX-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+
+	{ "smb", "op-LogoffX-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-LogoffX-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-LogoffX-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-LogoffX-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+
+	{ "smb", "op-Negotiate-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-Negotiate-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-Negotiate-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-Negotiate-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+
+	{ "smb", "op-NtCancel-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-NtCancel-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-NtCancel-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-NtCancel-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+
+	{ "smb", "op-NtCreateX-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-NtCreateX-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-NtCreateX-start", 2, 0, "smb_request_t *", "smb_open_args_t *" },
+	{ "smb", "op-NtCreateX-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-NtCreateX-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+
+	{ "smb", "op-NtTransactCreate-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-NtTransactCreate-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-NtTransactCreate-start", 2, 0, "smb_request_t *", "smb_open_args_t *" },
+	{ "smb", "op-NtTransactCreate-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-NtTransactCreate-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+
+	{ "smb", "op-Open-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-Open-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-Open-start", 2, 0, "smb_request_t *", "smb_open_args_t *" },
+	{ "smb", "op-Open-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-Open-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+
+	{ "smb", "op-OpenX-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-OpenX-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-OpenX-start", 2, 0, "smb_request_t *", "smb_open_args_t *" },
+	{ "smb", "op-OpenX-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-OpenX-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+
+	{ "smb", "op-OpenPrintFile-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-OpenPrintFile-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-OpenPrintFile-start", 2, 0, "smb_request_t *", "smb_open_args_t *" },
+	{ "smb", "op-OpenPrintFile-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-OpenPrintFile-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+
+	{ "smb", "op-ClosePrintFile-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-ClosePrintFile-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-ClosePrintFile-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-ClosePrintFile-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+
+	{ "smb", "op-GetPrintQueue-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-GetPrintQueue-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-GetPrintQueue-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-GetPrintQueue-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+
+	{ "smb", "op-WritePrintFile-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-WritePrintFile-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-WritePrintFile-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-WritePrintFile-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+
+	{ "smb", "op-ProcessExit-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-ProcessExit-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-ProcessExit-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-ProcessExit-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+
+	{ "smb", "op-QueryInformation-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-QueryInformation-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-QueryInformation-start", 2, 0, "smb_request_t *", "smb_name_args_t *" },
+	{ "smb", "op-QueryInformation-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-QueryInformation-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+
+	{ "smb", "op-QueryInformation2-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-QueryInformation2-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-QueryInformation2-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-QueryInformation2-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+
+	{ "smb", "op-Read-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-Read-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-Read-start", 2, 0, "smb_request_t *", "smb_rw_args_t *" },
+	{ "smb", "op-Read-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-Read-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-Read-done", 2, 0, "smb_request_t *", "smb_rw_args_t *" },
+
+	{ "smb", "op-LockAndRead-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-LockAndRead-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-LockAndRead-start", 2, 0, "smb_request_t *", "smb_rw_args_t *" },
+	{ "smb", "op-LockAndRead-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-LockAndRead-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-LockAndRead-done", 2, 0, "smb_request_t *", "smb_rw_args_t *" },
+
+	{ "smb", "op-ReadRaw-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-ReadRaw-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-ReadRaw-start", 2, 0, "smb_request_t *", "smb_rw_args_t *" },
+	{ "smb", "op-ReadRaw-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-ReadRaw-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-ReadRaw-done", 2, 0, "smb_request_t *", "smb_rw_args_t *" },
+
+	{ "smb", "op-ReadX-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-ReadX-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-ReadX-start", 2, 0, "smb_request_t *", "smb_rw_args_t *" },
+	{ "smb", "op-ReadX-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-ReadX-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-ReadX-done", 2, 0, "smb_request_t *", "smb_rw_args_t *" },
+
+	{ "smb", "op-Rename-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-Rename-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-Rename-start", 2, 0, "smb_request_t *", "smb_name_args_t *" },
+	{ "smb", "op-Rename-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-Rename-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+
+	{ "smb", "op-NtRename-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-NtRename-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-NtRename-start", 2, 0, "smb_request_t *", "smb_name_args_t *" },
+	{ "smb", "op-NtRename-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-NtRename-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+
+	{ "smb", "op-Seek-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-Seek-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-Seek-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-Seek-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+
+	{ "smb", "op-SessionSetupX-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-SessionSetupX-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-SessionSetupX-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-SessionSetupX-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+
+	{ "smb", "op-SetInformation-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-SetInformation-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-SetInformation-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-SetInformation-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+
+	{ "smb", "op-SetInformation2-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-SetInformation2-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-SetInformation2-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-SetInformation2-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+
+	{ "smb", "op-FindClose2-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-FindClose2-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-FindClose2-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-FindClose2-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+
+	{ "smb", "op-TreeConnect-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-TreeConnect-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-TreeConnect-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-TreeConnect-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+
+	{ "smb", "op-TreeConnectX-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-TreeConnectX-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-TreeConnectX-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-TreeConnectX-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+
+	{ "smb", "op-TreeDisconnect-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-TreeDisconnect-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-TreeDisconnect-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-TreeDisconnect-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+
+	{ "smb", "op-UnlockByteRange-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-UnlockByteRange-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-UnlockByteRange-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-UnlockByteRange-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+
+	{ "smb", "op-Write-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-Write-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-Write-start", 2, 0, "smb_request_t *", "smb_rw_args_t *" },
+	{ "smb", "op-Write-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-Write-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-Write-done", 2, 0, "smb_request_t *", "smb_rw_args_t *" },
+
+	{ "smb", "op-WriteAndClose-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-WriteAndClose-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-WriteAndClose-start", 2, 0, "smb_request_t *", "smb_rw_args_t *" },
+	{ "smb", "op-WriteAndClose-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-WriteAndClose-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-WriteAndClose-done", 2, 0, "smb_request_t *", "smb_rw_args_t *" },
+
+	{ "smb", "op-WriteAndUnlock-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-WriteAndUnlock-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-WriteAndUnlock-start", 2, 0, "smb_request_t *", "smb_rw_args_t *" },
+	{ "smb", "op-WriteAndUnlock-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-WriteAndUnlock-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-WriteAndUnlock-done", 2, 0, "smb_request_t *", "smb_rw_args_t *" },
+
+	{ "smb", "op-WriteRaw-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-WriteRaw-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-WriteRaw-start", 2, 0, "smb_request_t *", "smb_rw_args_t *" },
+	{ "smb", "op-WriteRaw-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-WriteRaw-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-WriteRaw-done", 2, 0, "smb_request_t *", "smb_rw_args_t *" },
+
+	{ "smb", "op-WriteX-start", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-WriteX-start", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-WriteX-start", 2, 0, "smb_request_t *", "smb_rw_args_t *" },
+	{ "smb", "op-WriteX-done", 0, 0, "smb_request_t *", "conninfo_t *" },
+	{ "smb", "op-WriteX-done", 1, 0, "smb_request_t *", "smbopinfo_t *" },
+	{ "smb", "op-WriteX-done", 2, 0, "smb_request_t *", "smb_rw_args_t *" },
+	/* END CSTYLED */
+
 	{ "ip", "send", 0, 0, "mblk_t *", "pktinfo_t *" },
 	{ "ip", "send", 1, 1, "conn_t *", "csinfo_t *" },
 	{ "ip", "send", 2, 2, "void_ip_t *", "ipinfo_t *" },
--- old/usr/src/uts/common/fs/smbsrv/smb_create.c	Fri Mar 31 14:29:39 2017
+++ new/usr/src/uts/common/fs/smbsrv/smb_create.c	Fri Mar 31 14:29:39 2017
@@ -47,8 +47,7 @@
 	op->create_disposition = FILE_OVERWRITE_IF;
 	op->create_options = FILE_NON_DIRECTORY_FILE;
 
-	DTRACE_SMB_2(op__Create__start, smb_request_t *, sr,
-	    struct open_param *, op);
+	DTRACE_SMB_1(op__Create__start, smb_request_t *, sr); /* arg.open */
 
 	return ((rc == 0) ? SDRC_SUCCESS : SDRC_ERROR);
 }
@@ -89,8 +88,7 @@
 
 	op->create_disposition = FILE_CREATE;
 
-	DTRACE_SMB_2(op__CreateNew__start, smb_request_t *, sr,
-	    struct open_param *, op);
+	DTRACE_SMB_1(op__CreateNew__start, smb_request_t *, sr); /* arg.open */
 
 	return ((rc == 0) ? SDRC_SUCCESS : SDRC_ERROR);
 }
@@ -132,8 +130,7 @@
 
 	op->create_disposition = FILE_CREATE;
 
-	DTRACE_SMB_2(op__CreateTemporary__start, smb_request_t *, sr,
-	    struct open_param *, op);
+	DTRACE_SMB_1(op__CreateTemporary__start, smb_request_t *, sr); /* arg.open */
 
 	return ((rc == 0) ? SDRC_SUCCESS : SDRC_ERROR);
 }
--- old/usr/src/uts/common/fs/smbsrv/smb_delete.c	Fri Mar 31 14:29:39 2017
+++ new/usr/src/uts/common/fs/smbsrv/smb_delete.c	Fri Mar 31 14:29:39 2017
@@ -104,7 +104,7 @@
 	if ((rc = smbsr_decode_vwv(sr, "w", &fqi->fq_sattr)) == 0)
 		rc = smbsr_decode_data(sr, "%S", sr, &fqi->fq_path.pn_path);
 
-	DTRACE_SMB_2(op__Delete__start, smb_request_t *, sr, smb_fqi_t *, fqi);
+	DTRACE_SMB_1(op__Delete__start, smb_request_t *, sr); /* arg.dirop */
 
 	return ((rc == 0) ? SDRC_SUCCESS : SDRC_ERROR);
 }
--- old/usr/src/uts/common/fs/smbsrv/smb_directory.c	Fri Mar 31 14:29:39 2017
+++ new/usr/src/uts/common/fs/smbsrv/smb_directory.c	Fri Mar 31 14:29:39 2017
@@ -59,8 +59,7 @@
 	rc = smbsr_decode_data(sr, "%S", sr,
 	    &sr->arg.dirop.fqi.fq_path.pn_path);
 
-	DTRACE_SMB_2(op__CreateDirectory__start, smb_request_t *, sr,
-	    struct dirop *, &sr->arg.dirop);
+	DTRACE_SMB_1(op__CreateDirectory__start, smb_request_t *, sr); /* arg.dirop */
 
 	return ((rc == 0) ? SDRC_SUCCESS : SDRC_ERROR);
 }
@@ -206,8 +205,7 @@
 	rc = smbsr_decode_data(sr, "%S", sr,
 	    &sr->arg.dirop.fqi.fq_path.pn_path);
 
-	DTRACE_SMB_2(op__DeleteDirectory__start, smb_request_t *, sr,
-	    struct dirop *, &sr->arg.dirop);
+	DTRACE_SMB_1(op__DeleteDirectory__start, smb_request_t *, sr); /* arg.dirop */
 
 	return ((rc == 0) ? SDRC_SUCCESS : SDRC_ERROR);
 }
@@ -361,8 +359,7 @@
 	rc = smbsr_decode_data(sr, "%S", sr,
 	    &sr->arg.dirop.fqi.fq_path.pn_path);
 
-	DTRACE_SMB_2(op__CheckDirectory__start, smb_request_t *, sr,
-	    struct dirop *, &sr->arg.dirop);
+	DTRACE_SMB_1(op__CheckDirectory__start, smb_request_t *, sr); /* arg.dirop */
 
 	return ((rc == 0) ? SDRC_SUCCESS : SDRC_ERROR);
 }
--- old/usr/src/uts/common/fs/smbsrv/smb_dispatch.c	Fri Mar 31 14:29:40 2017
+++ new/usr/src/uts/common/fs/smbsrv/smb_dispatch.c	Fri Mar 31 14:29:40 2017
@@ -195,10 +195,12 @@
 	{ "Invalid", SMB_SDT_OPS(invalid), 0x17, 0 },		/* 0x17 023 */
 	{ "Invalid", SMB_SDT_OPS(invalid), 0x18, 0 },		/* 0x18 024 */
 	{ "Invalid", SMB_SDT_OPS(invalid), 0x19, 0 },		/* 0x19 025 */
-	{ "SmbReadRaw", SMB_SDT_OPS(invalid), 0x1A, 0 },	/* 0x1A 026 */
+	{ "SmbReadRaw", SMB_SDT_OPS(read_raw),			/* 0x1A 026 */
+	    0x1A, LANMAN1_0 },
 	{ "Invalid", SMB_SDT_OPS(invalid), 0x1B, 0 },		/* 0x1B 027 */
 	{ "Invalid", SMB_SDT_OPS(invalid), 0x1C, 0 },		/* 0x1C 028 */
-	{ "SmbWriteRaw", SMB_SDT_OPS(invalid), 0x1D, 0 },	/* 0x1D 029 */
+	{ "SmbWriteRaw", SMB_SDT_OPS(write_raw),		/* 0x1D 029 */
+	    0x1D, LANMAN1_0 },
 	{ "Invalid", SMB_SDT_OPS(invalid), 0x1E, 0 },		/* 0x1E 030 */
 	{ "Invalid", SMB_SDT_OPS(invalid), 0x1F, 0 },		/* 0x1F 031 */
 	{ "Invalid", SMB_SDT_OPS(invalid), 0x20, 0 },		/* 0x20 032 */
@@ -833,9 +835,8 @@
 	sr->sr_time_start = gethrtime();
 	if ((sdrc = (*sdd->sdt_pre_op)(sr)) == SDRC_SUCCESS)
 		sdrc = (*sdd->sdt_function)(sr);
-
+	(*sdd->sdt_post_op)(sr);
 	if (sdrc != SDRC_SR_KEPT) {
-		(*sdd->sdt_post_op)(sr);
 		smbsr_cleanup(sr);
 	}
 
--- old/usr/src/uts/common/fs/smbsrv/smb_negotiate.c	Fri Mar 31 14:29:40 2017
+++ new/usr/src/uts/common/fs/smbsrv/smb_negotiate.c	Fri Mar 31 14:29:40 2017
@@ -382,8 +382,7 @@
 		}
 	}
 
-	DTRACE_SMB_2(op__Negotiate__start, smb_request_t *, sr,
-	    smb_arg_negotiate_t, negprot);
+	DTRACE_SMB_1(op__Negotiate__start, smb_request_t *, sr);
 
 	return ((rc == 0) ? SDRC_SUCCESS : SDRC_ERROR);
 }
@@ -393,8 +392,7 @@
 {
 	smb_arg_negotiate_t	*negprot = sr->sr_negprot;
 
-	DTRACE_SMB_2(op__Negotiate__done, smb_request_t *, sr,
-	    smb_arg_negotiate_t, negprot);
+	DTRACE_SMB_1(op__Negotiate__done, smb_request_t *, sr);
 
 	bzero(negprot, sizeof (smb_arg_negotiate_t));
 }
--- old/usr/src/uts/common/fs/smbsrv/smb_nt_create_andx.c	Fri Mar 31 14:29:40 2017
+++ new/usr/src/uts/common/fs/smbsrv/smb_nt_create_andx.c	Fri Mar 31 14:29:40 2017
@@ -212,8 +212,7 @@
 			op->op_oplock_level = SMB_OPLOCK_EXCLUSIVE;
 	}
 
-	DTRACE_SMB_2(op__NtCreateX__start, smb_request_t *, sr,
-	    struct open_param *, op);
+	DTRACE_SMB_1(op__NtCreateX__start, smb_request_t *, sr); /* arg.open */
 
 	return ((rc == 0) ? SDRC_SUCCESS : SDRC_ERROR);
 }
--- old/usr/src/uts/common/fs/smbsrv/smb_nt_transact_create.c	Fri Mar 31 14:29:41 2017
+++ new/usr/src/uts/common/fs/smbsrv/smb_nt_transact_create.c	Fri Mar 31 14:29:41 2017
@@ -115,8 +115,7 @@
 		op->sd = NULL;
 	}
 
-	DTRACE_SMB_2(op__NtTransactCreate__start, smb_request_t *, sr,
-	    struct open_param *, op);
+	DTRACE_SMB_1(op__NtTransactCreate__start, smb_request_t *, sr); /* arg.open */
 
 	return ((rc == 0) ? SDRC_SUCCESS : SDRC_ERROR);
 }
@@ -125,9 +124,9 @@
 smb_post_nt_transact_create(smb_request_t *sr, smb_xa_t *xa)
 {
 	smb_sd_t *sd = sr->arg.open.sd;
+	_NOTE(ARGUNUSED(xa))
 
-	DTRACE_SMB_2(op__NtTransactCreate__done, smb_request_t *, sr,
-	    smb_xa_t *, xa);
+	DTRACE_SMB_1(op__NtTransactCreate__done, smb_request_t *, sr);
 
 	if (sd) {
 		smb_sd_term(sd);
--- old/usr/src/uts/common/fs/smbsrv/smb_nt_transact_notify_change.c	Fri Mar 31 14:29:41 2017
+++ new/usr/src/uts/common/fs/smbsrv/smb_nt_transact_notify_change.c	Fri Mar 31 14:29:41 2017
@@ -226,6 +226,8 @@
 	    &xa->rep_data_mb);
 
 sendit:
+	DTRACE_SMB_1(op__NtTransactNotify__done2, smb_request_t *, sr);
+
 	sds = &sr->sr_server->sv_disp_stats1[sr->smb_com];
 	atomic_add_64(&sds->sdt_txb, (int64_t)sr->reply.chain_offset);
 
--- old/usr/src/uts/common/fs/smbsrv/smb_open_andx.c	Fri Mar 31 14:29:41 2017
+++ new/usr/src/uts/common/fs/smbsrv/smb_open_andx.c	Fri Mar 31 14:29:41 2017
@@ -227,8 +227,7 @@
 	if (rc == 0)
 		rc = smbsr_decode_data(sr, "%S", sr, &op->fqi.fq_path.pn_path);
 
-	DTRACE_SMB_2(op__Open__start, smb_request_t *, sr,
-	    struct open_param *, op);
+	DTRACE_SMB_1(op__Open__start, smb_request_t *, sr); /* arg.open */
 
 	return ((rc == 0) ? SDRC_SUCCESS : SDRC_ERROR);
 }
@@ -367,8 +366,7 @@
 		op->create_disposition = smb_ofun_to_crdisposition(op->ofun);
 	}
 
-	DTRACE_SMB_2(op__OpenX__start, smb_request_t *, sr,
-	    struct open_param *, op);
+	DTRACE_SMB_1(op__OpenX__start, smb_request_t *, sr); /* arg.open */
 
 	return ((rc == 0) ? SDRC_SUCCESS : SDRC_ERROR);
 }
--- old/usr/src/uts/common/fs/smbsrv/smb_print.c	Fri Mar 31 14:29:42 2017
+++ new/usr/src/uts/common/fs/smbsrv/smb_print.c	Fri Mar 31 14:29:42 2017
@@ -78,8 +78,7 @@
 
 	op->create_disposition = FILE_OVERWRITE_IF;
 	op->create_options = FILE_NON_DIRECTORY_FILE;
-	DTRACE_SMB_2(op__OpenPrintFile__start, smb_request_t *, sr,
-	    struct open_param *, op);
+	DTRACE_SMB_1(op__OpenPrintFile__start, smb_request_t *, sr); /* arg.open */
 
 	return ((rc == 0) ? SDRC_SUCCESS : SDRC_ERROR);
 }
--- old/usr/src/uts/common/fs/smbsrv/smb_query_fileinfo.c	Fri Mar 31 14:29:42 2017
+++ new/usr/src/uts/common/fs/smbsrv/smb_query_fileinfo.c	Fri Mar 31 14:29:42 2017
@@ -149,8 +149,7 @@
 
 	rc = smbsr_decode_data(sr, "%S", sr, &fqi->fq_path.pn_path);
 
-	DTRACE_SMB_2(op__QueryInformation__start, smb_request_t *, sr,
-	    smb_fqi_t *, fqi);
+	DTRACE_SMB_1(op__QueryInformation__start, smb_request_t *, sr); /* arg.dirop */
 
 	return ((rc == 0) ? SDRC_SUCCESS : SDRC_ERROR);
 }
--- old/usr/src/uts/common/fs/smbsrv/smb_read.c	Fri Mar 31 14:29:42 2017
+++ new/usr/src/uts/common/fs/smbsrv/smb_read.c	Fri Mar 31 14:29:42 2017
@@ -73,8 +73,7 @@
 	param->rw_count = (uint32_t)count;
 	param->rw_mincnt = 0;
 
-	DTRACE_SMB_2(op__Read__start, smb_request_t *, sr,
-	    smb_rw_param_t *, param);
+	DTRACE_SMB_1(op__Read__start, smb_request_t *, sr); /* arg.rw */
 
 	return ((rc == 0) ? SDRC_SUCCESS : SDRC_ERROR);
 }
@@ -82,8 +81,7 @@
 void
 smb_post_read(smb_request_t *sr)
 {
-	DTRACE_SMB_2(op__Read__done, smb_request_t *, sr,
-	    smb_rw_param_t *, sr->arg.rw);
+	DTRACE_SMB_1(op__Read__done, smb_request_t *, sr); /* arg.rw */
 
 	kmem_free(sr->arg.rw, sizeof (smb_rw_param_t));
 }
@@ -159,8 +157,7 @@
 	param->rw_count = (uint32_t)count;
 	param->rw_mincnt = 0;
 
-	DTRACE_SMB_2(op__LockAndRead__start, smb_request_t *, sr,
-	    smb_rw_param_t *, param);
+	DTRACE_SMB_1(op__LockAndRead__start, smb_request_t *, sr); /* arg.rw */
 
 	return ((rc == 0) ? SDRC_SUCCESS : SDRC_ERROR);
 }
@@ -168,8 +165,7 @@
 void
 smb_post_lock_and_read(smb_request_t *sr)
 {
-	DTRACE_SMB_2(op__LockAndRead__done, smb_request_t *, sr,
-	    smb_rw_param_t *, sr->arg.rw);
+	DTRACE_SMB_1(op__LockAndRead__done, smb_request_t *, sr); /* arg.rw */
 
 	kmem_free(sr->arg.rw, sizeof (smb_rw_param_t));
 }
@@ -223,6 +219,61 @@
 }
 
 /*
+ * The SMB_COM_READ_RAW protocol was a negotiated option introduced in
+ * SMB Core Plus to maximize performance when reading a large block
+ * of data from a server.  It's obsolete and no longer supported.
+ *
+ * We keep a handler for it so the dtrace provider can see if
+ * the client tried to use this command.
+ */
+smb_sdrc_t
+smb_pre_read_raw(smb_request_t *sr)
+{
+	smb_rw_param_t *param;
+	uint32_t off_low;
+	uint32_t off_high;
+	uint32_t timeout;
+	uint16_t count;
+	int rc;
+
+	param = kmem_zalloc(sizeof (smb_rw_param_t), KM_SLEEP);
+	sr->arg.rw = param;
+	if (sr->smb_wct == 8) {
+		rc = smbsr_decode_vwv(sr, "wlwwl2.", &sr->smb_fid,
+		    &off_low, &count, &param->rw_mincnt, &timeout);
+		if (rc == 0) {
+			param->rw_offset = (uint64_t)off_low;
+			param->rw_count = (uint32_t)count;
+		}
+	} else {
+		rc = smbsr_decode_vwv(sr, "wlwwl2.l", &sr->smb_fid,
+		    &off_low, &count, &param->rw_mincnt, &timeout, &off_high);
+		if (rc == 0) {
+			param->rw_offset = ((uint64_t)off_high << 32) | off_low;
+			param->rw_count = (uint32_t)count;
+		}
+	}
+	DTRACE_SMB_1(op__ReadRaw__start, smb_request_t *, sr); /* arg.rw */
+	return (SDRC_SUCCESS);
+}
+
+void
+smb_post_read_raw(smb_request_t *sr)
+{
+	DTRACE_SMB_1(op__ReadRaw__done, smb_request_t *, sr); /* arg.rw */
+
+	kmem_free(sr->arg.rw, sizeof (smb_rw_param_t));
+}
+
+smb_sdrc_t
+smb_com_read_raw(smb_request_t *sr)
+{
+	smbsr_error(sr, NT_STATUS_NOT_SUPPORTED, ERRDOS,
+	    ERROR_NOT_SUPPORTED);
+	return (SDRC_ERROR);
+}
+
+/*
  * Read bytes from a file (SMB Core).  This request was extended in
  * LM 0.12 to support 64-bit offsets, indicated by sending a wct of
  * 12 and including additional offset information.
@@ -272,8 +323,7 @@
 
 	param->rw_mincnt = 0;
 
-	DTRACE_SMB_2(op__ReadX__start, smb_request_t *, sr,
-	    smb_rw_param_t *, param);
+	DTRACE_SMB_1(op__ReadX__start, smb_request_t *, sr); /* arg.rw */
 
 	return ((rc == 0) ? SDRC_SUCCESS : SDRC_ERROR);
 }
@@ -281,8 +331,7 @@
 void
 smb_post_read_andx(smb_request_t *sr)
 {
-	DTRACE_SMB_2(op__ReadX__done, smb_request_t *, sr,
-	    smb_rw_param_t *, sr->arg.rw);
+	DTRACE_SMB_1(op__ReadX__done, smb_request_t *, sr); /* arg.rw */
 
 	kmem_free(sr->arg.rw, sizeof (smb_rw_param_t));
 }
--- old/usr/src/uts/common/fs/smbsrv/smb_rename.c	Fri Mar 31 14:29:43 2017
+++ new/usr/src/uts/common/fs/smbsrv/smb_rename.c	Fri Mar 31 14:29:43 2017
@@ -72,8 +72,7 @@
 		dst_fqi->fq_sattr = 0;
 	}
 
-	DTRACE_SMB_2(op__Rename__start, smb_request_t *, sr,
-	    struct dirop *, &sr->arg.dirop);
+	DTRACE_SMB_1(op__Rename__start, smb_request_t *, sr); /* arg.dirop */
 
 	return ((rc == 0) ? SDRC_SUCCESS : SDRC_ERROR);
 }
@@ -146,8 +145,7 @@
 		dst_fqi->fq_sattr = 0;
 	}
 
-	DTRACE_SMB_2(op__NtRename__start, smb_request_t *, sr,
-	    struct dirop *, &sr->arg.dirop);
+	DTRACE_SMB_1(op__NtRename__start, smb_request_t *, sr); /* arg.dirop */
 
 	return ((rc == 0) ? SDRC_SUCCESS : SDRC_ERROR);
 }
--- old/usr/src/uts/common/fs/smbsrv/smb_session_setup_andx.c	Fri Mar 31 14:29:43 2017
+++ new/usr/src/uts/common/fs/smbsrv/smb_session_setup_andx.c	Fri Mar 31 14:29:43 2017
@@ -189,8 +189,7 @@
 		    sr->session->ip_addr_str);
 	}
 
-	DTRACE_SMB_2(op__SessionSetupX__start, smb_request_t *, sr,
-	    smb_arg_sessionsetup_t, sinfo);
+	DTRACE_SMB_1(op__SessionSetupX__start, smb_request_t *, sr);
 	return ((rc == 0) ? SDRC_SUCCESS : SDRC_ERROR);
 }
 
@@ -199,8 +198,7 @@
 {
 	smb_arg_sessionsetup_t	*sinfo = sr->sr_ssetup;
 
-	DTRACE_SMB_2(op__SessionSetupX__done, smb_request_t *, sr,
-	    smb_arg_sessionsetup_t, sinfo);
+	DTRACE_SMB_1(op__SessionSetupX__done, smb_request_t *, sr);
 
 	if (sinfo->ssi_lmpwd != NULL)
 		bzero(sinfo->ssi_lmpwd, sinfo->ssi_lmpwlen);
--- old/usr/src/uts/common/fs/smbsrv/smb_tree_connect.c	Fri Mar 31 14:29:43 2017
+++ new/usr/src/uts/common/fs/smbsrv/smb_tree_connect.c	Fri Mar 31 14:29:43 2017
@@ -100,8 +100,7 @@
 	tcon->flags = 0;
 	tcon->optional_support = 0;
 
-	DTRACE_SMB_2(op__TreeConnect__start, smb_request_t *, sr,
-	    smb_arg_tcon_t *, tcon);
+	DTRACE_SMB_1(op__TreeConnect__start, smb_request_t *, sr);
 
 	return ((rc == 0) ? SDRC_SUCCESS : SDRC_ERROR);
 }
@@ -291,8 +290,7 @@
 
 	tcon->optional_support = 0;
 
-	DTRACE_SMB_2(op__TreeConnectX__start, smb_request_t *, sr,
-	    smb_arg_tcon_t *, tcon);
+	DTRACE_SMB_1(op__TreeConnectX__start, smb_request_t *, sr);
 
 	return ((rc == 0) ? SDRC_SUCCESS : SDRC_ERROR);
 }
--- old/usr/src/uts/common/fs/smbsrv/smb_write.c	Fri Mar 31 14:29:44 2017
+++ new/usr/src/uts/common/fs/smbsrv/smb_write.c	Fri Mar 31 14:29:44 2017
@@ -61,8 +61,7 @@
 	param->rw_offset = (uint64_t)off;
 	param->rw_vdb.vdb_uio.uio_loffset = (offset_t)param->rw_offset;
 
-	DTRACE_SMB_2(op__Write__start, smb_request_t *, sr,
-	    smb_rw_param_t *, param);
+	DTRACE_SMB_1(op__Write__start, smb_request_t *, sr); /* arg.rw */
 
 	return ((rc == 0) ? SDRC_SUCCESS : SDRC_ERROR);
 }
@@ -70,8 +69,7 @@
 void
 smb_post_write(smb_request_t *sr)
 {
-	DTRACE_SMB_2(op__Write__done, smb_request_t *, sr,
-	    smb_rw_param_t *, sr->arg.rw);
+	DTRACE_SMB_1(op__Write__done, smb_request_t *, sr); /* arg.rw */
 
 	kmem_free(sr->arg.rw, sizeof (smb_rw_param_t));
 }
@@ -151,8 +149,7 @@
 	param->rw_count = (uint32_t)count;
 	param->rw_offset = (uint64_t)off;
 
-	DTRACE_SMB_2(op__WriteAndClose__start, smb_request_t *, sr,
-	    smb_rw_param_t *, param);
+	DTRACE_SMB_1(op__WriteAndClose__start, smb_request_t *, sr); /* arg.rw */
 
 	return ((rc == 0) ? SDRC_SUCCESS : SDRC_ERROR);
 }
@@ -160,8 +157,7 @@
 void
 smb_post_write_and_close(smb_request_t *sr)
 {
-	DTRACE_SMB_2(op__WriteAndClose__done, smb_request_t *, sr,
-	    smb_rw_param_t *, sr->arg.rw);
+	DTRACE_SMB_1(op__WriteAndClose__done, smb_request_t *, sr); /* arg.rw */
 
 	kmem_free(sr->arg.rw, sizeof (smb_rw_param_t));
 }
@@ -249,8 +245,7 @@
 	param->rw_count = (uint32_t)count;
 	param->rw_offset = (uint64_t)off;
 
-	DTRACE_SMB_2(op__WriteAndUnlock__start, smb_request_t *, sr,
-	    smb_rw_param_t *, param);
+	DTRACE_SMB_1(op__WriteAndUnlock__start, smb_request_t *, sr); /* arg.rw */
 
 	return ((rc == 0) ? SDRC_SUCCESS : SDRC_ERROR);
 }
@@ -258,8 +253,7 @@
 void
 smb_post_write_and_unlock(smb_request_t *sr)
 {
-	DTRACE_SMB_2(op__WriteAndUnlock__done, smb_request_t *, sr,
-	    smb_rw_param_t *, sr->arg.rw);
+	DTRACE_SMB_1(op__WriteAndUnlock__done, smb_request_t *, sr); /* arg.rw */
 
 	kmem_free(sr->arg.rw, sizeof (smb_rw_param_t));
 }
@@ -325,6 +319,66 @@
 }
 
 /*
+ * The SMB_COM_WRITE_RAW protocol was a negotiated option introduced in
+ * SMB Core Plus to maximize performance when writing a large block
+ * of data to a server.  It's obsolete and no longer supported.
+ *
+ * We keep a handler for it so the dtrace provider can see if
+ * the client tried to use this command.
+ */
+smb_sdrc_t
+smb_pre_write_raw(smb_request_t *sr)
+{
+	smb_rw_param_t *param;
+	uint32_t off_low;
+	uint32_t timeout;
+	uint32_t off_high;
+	uint16_t datalen;
+	uint16_t total;
+	int rc;
+
+	param = kmem_zalloc(sizeof (smb_rw_param_t), KM_SLEEP);
+	sr->arg.rw = param;
+
+	if (sr->smb_wct == 12) {
+		rc = smbsr_decode_vwv(sr, "ww2.llw4.ww", &sr->smb_fid, &total,
+		    &off_low, &timeout, &param->rw_mode, &datalen,
+		    &param->rw_dsoff);
+
+		param->rw_offset = (uint64_t)off_low;
+	} else {
+		rc = smbsr_decode_vwv(sr, "ww2.llw4.wwl", &sr->smb_fid, &total,
+		    &off_low, &timeout, &param->rw_mode, &datalen,
+		    &param->rw_dsoff, &off_high);
+
+		param->rw_offset = ((uint64_t)off_high << 32) | off_low;
+	}
+
+	param->rw_count = (uint32_t)datalen;
+	param->rw_total = (uint32_t)total;
+
+	DTRACE_SMB_1(op__WriteRaw__start, smb_request_t *, sr); /* arg.rw */
+
+	return ((rc == 0) ? SDRC_SUCCESS : SDRC_ERROR);
+}
+
+void
+smb_post_write_raw(smb_request_t *sr)
+{
+	DTRACE_SMB_1(op__WriteRaw__done, smb_request_t *, sr); /* arg.rw */
+
+	kmem_free(sr->arg.rw, sizeof (smb_rw_param_t));
+}
+
+smb_sdrc_t
+smb_com_write_raw(struct smb_request *sr)
+{
+	smbsr_error(sr, NT_STATUS_NOT_SUPPORTED, ERRDOS,
+	    ERROR_NOT_SUPPORTED);
+	return (SDRC_ERROR);
+}
+
+/*
  * Write bytes to a file (SMB Core).  This request was extended in
  * LM 0.12 to support 64-bit offsets, indicated by sending a wct of
  * 14, instead of 12, and including additional offset information.
@@ -387,8 +441,7 @@
 	    (sr->smb_data.max_bytes > (sr->smb_data.chain_offset + 0xFFFF)))
 		param->rw_count |= ((uint32_t)datalen_high << 16);
 
-	DTRACE_SMB_2(op__WriteX__start, smb_request_t *, sr,
-	    smb_rw_param_t *, param);
+	DTRACE_SMB_1(op__WriteX__start, smb_request_t *, sr); /* arg.rw */
 
 	return ((rc == 0) ? SDRC_SUCCESS : SDRC_ERROR);
 }
@@ -396,8 +449,7 @@
 void
 smb_post_write_andx(smb_request_t *sr)
 {
-	DTRACE_SMB_2(op__WriteX__done, smb_request_t *, sr,
-	    smb_rw_param_t *, sr->arg.rw);
+	DTRACE_SMB_1(op__WriteX__done, smb_request_t *, sr); /* arg.rw */
 
 	kmem_free(sr->arg.rw, sizeof (smb_rw_param_t));
 }
--- old/usr/src/uts/common/smbsrv/smb_kproto.h	Fri Mar 31 14:29:44 2017
+++ new/usr/src/uts/common/smbsrv/smb_kproto.h	Fri Mar 31 14:29:44 2017
@@ -109,7 +109,6 @@
 extern	int smb_oplock_min_timeout;
 extern	int smb_shortnames;
 extern	int smb_sign_debug;
-extern	int smb_raw_mode;
 extern	uint_t smb_audit_flags;
 extern	int smb_ssetup_threshold;
 extern	int smb_tcon_threshold;
@@ -807,9 +806,6 @@
 struct mbuf *smb_mbuf_allocate(struct uio *uio);
 void smb_mbuf_trim(struct mbuf *mhead, int nbytes);
 
-void smb_check_status(void);
-int smb_handle_write_raw(smb_session_t *session, smb_request_t *sr);
-
 int32_t smb_time_gmt_to_local(smb_request_t *, int32_t);
 int32_t smb_time_local_to_gmt(smb_request_t *, int32_t);
 int32_t	smb_time_dos_to_unix(int16_t, int16_t);
--- old/usr/src/uts/common/sys/sdt.h	Fri Mar 31 14:29:44 2017
+++ new/usr/src/uts/common/sys/sdt.h	Fri Mar 31 14:29:44 2017
@@ -250,6 +250,12 @@
 #define	DTRACE_SMB_2(name, type1, arg1, type2, arg2) \
 	DTRACE_PROBE2(__smb_##name, type1, arg1, type2, arg2);
 
+#define	DTRACE_SMB2_1(name, type1, arg1) \
+	DTRACE_PROBE1(__smb2_##name, type1, arg1);
+
+#define	DTRACE_SMB2_2(name, type1, arg1, type2, arg2) \
+	DTRACE_PROBE2(__smb2_##name, type1, arg1, type2, arg2);
+
 #define	DTRACE_IP(name)						\
 	DTRACE_PROBE(__ip_##name);
 
