S3: New module interface for SMB message statistics gathering

This changelist allows for the addition of custom performance
monitoring modules through smb.conf. Entrypoints in the main message
processing code have been added to capture the command, subop, ioctl,
identity and message size statistics.

11 files changed, 278 insertions, 35 deletions

diff --git a/source3/smbd/aio.c b/source3/smbd/aio.c
index 64d512d675..75ce07d41a 100644
--- a/source3/smbd/aio.c
+++ b/source3/smbd/aio.c
@@ -301,7 +301,8 @@ bool schedule_aio_write_and_X(connection_struct *conn,
                 SSVAL(aio_ex->outbuf,smb_vwv4,(numtowrite>>16)&1);
 		show_msg(aio_ex->outbuf);
 		if (!srv_send_smb(smbd_server_fd(),aio_ex->outbuf,
-				IS_CONN_ENCRYPTED(fsp->conn))) {
+				IS_CONN_ENCRYPTED(fsp->conn),
+				&req->pcd)) {
 			exit_server_cleanly("handle_aio_write: srv_send_smb "
 					    "failed.");
 		}
@@ -375,7 +376,7 @@ static int handle_aio_read_complete(struct aio_extra *aio_ex)
 	smb_setlen(outbuf,outsize - 4);
 	show_msg(outbuf);
 	if (!srv_send_smb(smbd_server_fd(),outbuf,
-			IS_CONN_ENCRYPTED(aio_ex->fsp->conn))) {
+			IS_CONN_ENCRYPTED(aio_ex->fsp->conn), NULL)) {
 		exit_server_cleanly("handle_aio_read_complete: srv_send_smb "
 				    "failed.");
 	}
@@ -472,7 +473,8 @@ static int handle_aio_write_complete(struct aio_extra *aio_ex)
 	}
 
 	show_msg(outbuf);
-	if (!srv_send_smb(smbd_server_fd(),outbuf,IS_CONN_ENCRYPTED(fsp->conn))) {
+	if (!srv_send_smb(smbd_server_fd(),outbuf,IS_CONN_ENCRYPTED(fsp->conn),
+			  NULL)) {
 		exit_server_cleanly("handle_aio_write: srv_send_smb failed.");
 	}
 
diff --git a/source3/smbd/blocking.c b/source3/smbd/blocking.c
index ac1ff00858..659ef700cb 100644
--- a/source3/smbd/blocking.c
+++ b/source3/smbd/blocking.c
@@ -192,6 +192,7 @@ bool push_blocking_lock_request( struct byte_range_lock *br_lck,
 		return False;
 	}
 
+	SMB_PERFCOUNT_DEFER_OP(&req->pcd, &req->pcd);
 	blr->req = talloc_move(blr, &req);
 
 	DLIST_ADD_END(blocking_lock_queue, blr, blocking_lock_record *);
@@ -266,7 +267,7 @@ static void generic_blocking_lock_error(blocking_lock_record *blr, NTSTATUS stat
 
 	reply_nterror(blr->req, status);
 	if (!srv_send_smb(smbd_server_fd(), (char *)blr->req->outbuf,
-			  blr->req->encrypted)) {
+			  blr->req->encrypted, NULL)) {
 		exit_server_cleanly("generic_blocking_lock_error: srv_send_smb failed.");
 	}
 	TALLOC_FREE(blr->req->outbuf);
@@ -347,7 +348,8 @@ static void blocking_lock_reply_error(blocking_lock_record *blr, NTSTATUS status
 
 		if (!srv_send_smb(smbd_server_fd(),
 				  (char *)blr->req->outbuf,
-				  IS_CONN_ENCRYPTED(blr->fsp->conn))) {
+				  IS_CONN_ENCRYPTED(blr->fsp->conn),
+				  NULL)) {
 			exit_server_cleanly("blocking_lock_reply_error: "
 					    "srv_send_smb failed.");
 		}
diff --git a/source3/smbd/ipc.c b/source3/smbd/ipc.c
index 9c7528dfa7..d18b5debe0 100644
--- a/source3/smbd/ipc.c
+++ b/source3/smbd/ipc.c
@@ -134,7 +134,7 @@ void send_trans_reply(connection_struct *conn,
 
 	show_msg((char *)req->outbuf);
 	if (!srv_send_smb(smbd_server_fd(), (char *)req->outbuf,
-			  IS_CONN_ENCRYPTED(conn))) {
+			  IS_CONN_ENCRYPTED(conn), &req->pcd)) {
 		exit_server_cleanly("send_trans_reply: srv_send_smb failed.");
 	}
 
@@ -190,7 +190,7 @@ void send_trans_reply(connection_struct *conn,
 
 		show_msg((char *)req->outbuf);
 		if (!srv_send_smb(smbd_server_fd(), (char *)req->outbuf,
-				  IS_CONN_ENCRYPTED(conn)))
+				  IS_CONN_ENCRYPTED(conn), &req->pcd))
 			exit_server_cleanly("send_trans_reply: srv_send_smb "
 					    "failed.");
 
@@ -298,7 +298,8 @@ static void api_dcerpc_cmd_write_done(struct async_req *subreq)
  send:
 	if (!srv_send_smb(
 		    smbd_server_fd(), (char *)req->outbuf,
-		    IS_CONN_ENCRYPTED(req->conn) || req->encrypted)) {
+		    IS_CONN_ENCRYPTED(req->conn) || req->encrypted,
+		    &req->pcd)) {
 		exit_server_cleanly("construct_reply: srv_send_smb failed.");
 	}
 	TALLOC_FREE(req);
@@ -324,7 +325,7 @@ static void api_dcerpc_cmd_read_done(struct async_req *subreq)
 
 		if (!srv_send_smb(smbd_server_fd(), (char *)req->outbuf,
 				  IS_CONN_ENCRYPTED(req->conn)
-				  ||req->encrypted)) {
+				  ||req->encrypted, &req->pcd)) {
 			exit_server_cleanly("construct_reply: srv_send_smb "
 					    "failed.");
 		}
diff --git a/source3/smbd/notify.c b/source3/smbd/notify.c
index 7ffe62058c..1d4f5e8c5b 100644
--- a/source3/smbd/notify.c
+++ b/source3/smbd/notify.c
@@ -144,7 +144,7 @@ static void change_notify_reply_packet(connection_struct *conn,
 
 	show_msg((char *)req->outbuf);
 	if (!srv_send_smb(smbd_server_fd(), (char *)req->outbuf,
-			  req->encrypted)) {
+			  req->encrypted, &req->pcd)) {
 		exit_server_cleanly("change_notify_reply_packet: srv_send_smb "
 				    "failed.");
 	}
diff --git a/source3/smbd/nttrans.c b/source3/smbd/nttrans.c
index 0ad4df6e90..ad2366efae 100644
--- a/source3/smbd/nttrans.c
+++ b/source3/smbd/nttrans.c
@@ -230,7 +230,8 @@ void send_nt_replies(connection_struct *conn,
 		show_msg((char *)req->outbuf);
 		if (!srv_send_smb(smbd_server_fd(),
 				(char *)req->outbuf,
-				IS_CONN_ENCRYPTED(conn))) {
+				IS_CONN_ENCRYPTED(conn),
+				&req->pcd)) {
 			exit_server_cleanly("send_nt_replies: srv_send_smb failed.");
 		}
 
@@ -1823,6 +1824,8 @@ static void call_nt_transact_ioctl(connection_struct *conn,
 	   because I don't want to break anything... --metze
 	FSP_BELONGS_CONN(fsp,conn);*/
 
+	SMB_PERFCOUNT_SET_IOCTL(&req->pcd, function);
+
 	switch (function) {
 	case FSCTL_SET_SPARSE:
 		/* pretend this succeeded - tho strictly we should
@@ -2489,6 +2492,9 @@ static void handle_nttrans(connection_struct *conn,
 		SSVAL(req->inbuf,smb_flg2,req->flags2);
 	}
 
+
+	SMB_PERFCOUNT_SET_SUBOP(&req->pcd, state->call);
+
 	/* Now we must call the relevant NT_TRANS function */
 	switch(state->call) {
 		case NT_TRANSACT_CREATE:
diff --git a/source3/smbd/oplock.c b/source3/smbd/oplock.c
index 788d2f7238..3dac674c17 100644
--- a/source3/smbd/oplock.c
+++ b/source3/smbd/oplock.c
@@ -406,7 +406,8 @@ static void process_oplock_async_level2_break_message(struct messaging_context *
 	show_msg(break_msg);
 	if (!srv_send_smb(smbd_server_fd(),
 			break_msg,
-			IS_CONN_ENCRYPTED(fsp->conn))) {
+			IS_CONN_ENCRYPTED(fsp->conn),
+			NULL)) {
 		exit_server_cleanly("oplock_break: srv_send_smb failed.");
 	}
 
@@ -513,7 +514,8 @@ static void process_oplock_break_message(struct messaging_context *msg_ctx,
 	show_msg(break_msg);
 	if (!srv_send_smb(smbd_server_fd(),
 			break_msg,
-			IS_CONN_ENCRYPTED(fsp->conn))) {
+			IS_CONN_ENCRYPTED(fsp->conn),
+			NULL)) {
 		exit_server_cleanly("oplock_break: srv_send_smb failed.");
 	}
 
@@ -592,7 +594,8 @@ static void process_kernel_oplock_break(struct messaging_context *msg_ctx,
 	show_msg(break_msg);
 	if (!srv_send_smb(smbd_server_fd(),
 			break_msg,
-			IS_CONN_ENCRYPTED(fsp->conn))) {
+			IS_CONN_ENCRYPTED(fsp->conn),
+			NULL)) {
 		exit_server_cleanly("oplock_break: srv_send_smb failed.");
 	}
 
diff --git a/source3/smbd/perfcount.c b/source3/smbd/perfcount.c
new file mode 100644
index 0000000000..0ad706c46d
--- /dev/null
+++ b/source3/smbd/perfcount.c
@@ -0,0 +1,192 @@
+/*
+   Unix SMB/Netbios implementation.
+   Perfcounter initialization and support functions
+   Copyright (C) Todd Stecher 2009
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "includes.h"
+
+struct smb_perfcount_handlers *g_smb_perfcount_handlers = NULL;
+
+struct smb_perfcount_module {
+	char *name;
+	struct smb_perfcount_handlers *handlers;
+	struct smb_perfcount_module *prev, *next;
+};
+
+struct smb_perfcount_module *modules = NULL;
+
+
+/*
+ * a module is registered before it is actually loaded - keep a list
+ *
+ * @todo - currently perfcount modules are globally configured, so
+ * building the list is not strictly required.
+ * However, its a proven concept in VFS, and is here to allow a
+ * move to eventual per-service perfcount configuration.
+ *
+ * Note many pre-connection statistics are interesting
+ * (e.g. before binding to an individual share).
+ *
+ */
+static struct smb_perfcount_module *smb_perfcount_find_module(const char *name)
+{
+	struct smb_perfcount_module *entry = modules;
+
+	while (entry) {
+		if (strcmp(entry->name, name)==0)
+			return entry;
+
+		entry = entry->next;
+	}
+
+	return NULL;
+}
+NTSTATUS smb_register_perfcounter(int interface_version, const char *name,
+				  const struct smb_perfcount_handlers *handlers)
+{
+	struct smb_perfcount_module *entry = modules;
+
+	if ((interface_version != SMB_PERFCOUNTER_INTERFACE_VERSION)) {
+		DEBUG(0, ("Failed to register perfcount module.\n"
+		          "The module was compiled against "
+			  "SMB_PERFCOUNTER_INTERFACE_VERSION %d,\n"
+		          "current SMB_PERFCOUNTER_INTERFACE_VERSION is %d.\n"
+		          "Please recompile against the current Samba Version!\n",
+			  interface_version, SMB_PERFCOUNTER_INTERFACE_VERSION));
+		return NT_STATUS_OBJECT_TYPE_MISMATCH;
+	}
+
+	if (!name || !name[0] || !handlers) {
+		DEBUG(0,("smb_register_perfcounter() called with NULL pointer "
+			"or empty name!\n"));
+		return NT_STATUS_INVALID_PARAMETER;
+	}
+
+	if (smb_perfcount_find_module(name)) {
+		DEBUG(0,("Perfcount Module %s already loaded!\n", name));
+		return NT_STATUS_OK;
+	}
+
+	entry = SMB_XMALLOC_P(struct smb_perfcount_module);
+	entry->name = smb_xstrdup(name);
+	entry->handlers = (struct smb_perfcount_handlers*) handlers;
+
+	DLIST_ADD(modules, entry);
+	DEBUG(0, ("Successfully added perfcounter module '%s'\n", name));
+	return NT_STATUS_OK;
+}
+
+/****************************************************************************
+  initialise smb perf counters
+ ****************************************************************************/
+bool smb_load_perfcount_module(const char *name)
+{
+	char *module_path = NULL;
+	char *module_name = NULL;
+	char *module_param = NULL, *p;
+
+	const struct smb_perfcount_module *entry;
+
+	DEBUG(3, ("Initialising perfcounter module [%s]\n", name));
+
+	if (g_smb_perfcount_handlers) {
+		DEBUG(0,("Only 1 perfcount handler may be registered in "
+			"smb.conf\n"));
+		return true;
+	}
+
+	module_path = smb_xstrdup(name);
+
+	p = strchr_m(module_path, ':');
+
+	if (p) {
+		*p = 0;
+		module_param = p+1;
+		trim_char(module_param, ' ', ' ');
+	}
+
+	trim_char(module_path, ' ', ' ');
+
+	module_name = smb_xstrdup(module_path);
+
+	if (module_name[0] == '/') {
+
+		/*
+		 * Extract the module name from the path. Just use the base
+		 * name of the last path component.
+		 */
+
+		SAFE_FREE(module_name);
+		module_name = smb_xstrdup(strrchr_m(module_path, '/')+1);
+
+		p = strchr_m(module_name, '.');
+
+		if (p != NULL) {
+			*p = '\0';
+		}
+	}
+
+	/* load the perfcounter module */
+	if((entry = smb_perfcount_find_module(module_name)) ||
+	   (NT_STATUS_IS_OK(smb_probe_module("perfcount", module_path)) &&
+		(entry = smb_perfcount_find_module(module_name)))) {
+
+		DEBUG(0,("Successfully loaded perfcounter module [%s] \n", name));
+	} else {
+		DEBUG(0,("Can't find a perfcounter module [%s]\n",name));
+		goto fail;
+	}
+
+	g_smb_perfcount_handlers = entry->handlers;
+
+	SAFE_FREE(module_path);
+	SAFE_FREE(module_name);
+	return True;
+
+ fail:
+	SAFE_FREE(module_path);
+	SAFE_FREE(module_name);
+	return False;
+}
+
+void smb_init_perfcount_data(struct smb_perfcount_data *pcd)
+{
+
+	ZERO_STRUCTP(pcd);
+	pcd->handlers = g_smb_perfcount_handlers;
+}
+
+bool smb_perfcount_init(void)
+{
+	char *perfcount_object;
+
+	perfcount_object = lp_smb_perfcount_module();
+
+	/* don't init */
+	if (!perfcount_object || !perfcount_object[0])
+		return True;
+
+	if (!smb_load_perfcount_module(perfcount_object)) {
+		DEBUG(0, ("smbd_load_percount_module failed for %s\n",
+			perfcount_object));
+		return False;
+	}
+
+
+	return True;
+}
diff --git a/source3/smbd/pipes.c b/source3/smbd/pipes.c
index f287adc92d..6fd4031f3d 100644
--- a/source3/smbd/pipes.c
+++ b/source3/smbd/pipes.c
@@ -216,7 +216,8 @@ static void pipe_write_done(struct async_req *subreq)
 
  send:
 	if (!srv_send_smb(smbd_server_fd(), (char *)req->outbuf,
-			  IS_CONN_ENCRYPTED(req->conn)||req->encrypted)) {
+			  IS_CONN_ENCRYPTED(req->conn)||req->encrypted,
+			  &req->pcd)) {
 		exit_server_cleanly("construct_reply: srv_send_smb failed.");
 	}
 	TALLOC_FREE(req);
diff --git a/source3/smbd/process.c b/source3/smbd/process.c
index 8539e04bd5..1262d01840 100644
--- a/source3/smbd/process.c
+++ b/source3/smbd/process.c
@@ -32,9 +32,10 @@ static void construct_reply_common(struct smb_request *req, const char *inbuf,
  Send an smb to a fd.
 ****************************************************************************/
 
-bool srv_send_smb(int fd, char *buffer, bool do_encrypt)
+bool srv_send_smb(int fd, char *buffer, bool do_encrypt,
+	          struct smb_perfcount_data *pcd)
 {
-	size_t len;
+	size_t len = 0;
 	size_t nwritten=0;
 	ssize_t ret;
 	char *buf_out = buffer;
@@ -48,7 +49,7 @@ bool srv_send_smb(int fd, char *buffer, bool do_encrypt)
 			DEBUG(0, ("send_smb: SMB encryption failed "
 				"on outgoing packet! Error %s\n",
 				nt_errstr(status) ));
-			return false;
+			goto out;
 		}
 	}
 
@@ -60,12 +61,15 @@ bool srv_send_smb(int fd, char *buffer, bool do_encrypt)
 			DEBUG(0,("Error writing %d bytes to client. %d. (%s)\n",
 				(int)len,(int)ret, strerror(errno) ));
 			srv_free_enc_buffer(buf_out);
-			return false;
+			goto out;
 		}
 		nwritten += ret;
 	}
 
+	SMB_PERFCOUNT_SET_MSGLEN_OUT(pcd, len);
 	srv_free_enc_buffer(buf_out);
+out:
+	SMB_PERFCOUNT_END(pcd);
 	return true;
 }
 
@@ -373,6 +377,7 @@ void init_smb_request(struct smb_request *req,
 	req->conn = conn_find(req->tid);
 	req->chain_fsp = NULL;
 	req->chain_outbuf = NULL;
+	smb_init_perfcount_data(&req->pcd);
 
 	/* Ensure we have at least wct words and 2 bytes of bcc. */
 	if (smb_size + req->wct*2 > req_size) {
@@ -390,12 +395,13 @@ void init_smb_request(struct smb_request *req,
 			(unsigned int)req_size));
 		exit_server_cleanly("Invalid SMB request");
 	}
+
 	req->outbuf = NULL;
 }
 
 static void process_smb(struct smbd_server_connection *conn,
 			uint8_t *inbuf, size_t nread, size_t unread_bytes,
-			bool encrypted);
+			bool encrypted, struct smb_perfcount_data *deferred_pcd);
 
 static void smbd_deferred_open_timer(struct event_context *ev,
 				     struct timed_event *te,
@@ -421,7 +427,7 @@ static void smbd_deferred_open_timer(struct event_context *ev,
 
 	process_smb(smbd_server_conn, inbuf,
 		    msg->buf.length, 0,
-		    msg->encrypted);
+		    msg->encrypted, &msg->pcd);
 }
 
 /****************************************************************************
@@ -453,6 +459,7 @@ static bool push_queued_message(struct smb_request *req,
 
 	msg->request_time = request_time;
 	msg->encrypted = req->encrypted;
+	SMB_PERFCOUNT_DEFER_OP(&req->pcd, &msg->pcd);
 
 	if (private_data) {
 		msg->private_data = data_blob_talloc(msg, private_data,
@@ -1354,7 +1361,9 @@ static connection_struct *switch_message(uint8 type, struct smb_request *req, in
  Construct a reply to the incoming packet.
 ****************************************************************************/
 
-static void construct_reply(char *inbuf, int size, size_t unread_bytes, bool encrypted)
+static void construct_reply(char *inbuf, int size, size_t unread_bytes,
+			    bool encrypted,
+			    struct smb_perfcount_data *deferred_pcd)
 {
 	connection_struct *conn;
 	struct smb_request *req;
@@ -1362,9 +1371,19 @@ static void construct_reply(char *inbuf, int size, size_t unread_bytes, bool enc
 	if (!(req = talloc(talloc_tos(), struct smb_request))) {
 		smb_panic("could not allocate smb_request");
 	}
+
 	init_smb_request(req, (uint8 *)inbuf, unread_bytes, encrypted);
 	req->inbuf  = (uint8_t *)talloc_move(req, &inbuf);
 
+	/* we popped this message off the queue - keep original perf data */
+	if (deferred_pcd)
+		req->pcd = *deferred_pcd;
+	else {
+		SMB_PERFCOUNT_START(&req->pcd);
+		SMB_PERFCOUNT_SET_OP(&req->pcd, req->cmd);
+		SMB_PERFCOUNT_SET_MSGLEN_IN(&req->pcd, size);
+	}
+
 	conn = switch_message(req->cmd, req, size);
 
 	if (req->unread_bytes) {
@@ -1386,7 +1405,8 @@ static void construct_reply(char *inbuf, int size, size_t unread_bytes, bool enc
 
 	if (!srv_send_smb(smbd_server_fd(),
 			(char *)req->outbuf,
-			IS_CONN_ENCRYPTED(conn)||req->encrypted)) {
+			IS_CONN_ENCRYPTED(conn)||req->encrypted,
+			&req->pcd)) {
 		exit_server_cleanly("construct_reply: srv_send_smb failed.");
 	}
 
@@ -1398,10 +1418,9 @@ static void construct_reply(char *inbuf, int size, size_t unread_bytes, bool enc
 /****************************************************************************
  Process an smb from the client
 ****************************************************************************/
-
 static void process_smb(struct smbd_server_connection *conn,
 			uint8_t *inbuf, size_t nread, size_t unread_bytes,
-			bool encrypted)
+			bool encrypted, struct smb_perfcount_data *deferred_pcd)
 {
 	int msg_type = CVAL(inbuf,0);
 
@@ -1423,8 +1442,7 @@ static void process_smb(struct smbd_server_connection *conn,
 
 	show_msg((char *)inbuf);
 
-	construct_reply((char *)inbuf,nread,unread_bytes,encrypted);
-
+	construct_reply((char *)inbuf,nread,unread_bytes,encrypted,deferred_pcd);
 	trans_num++;
 
 done:
@@ -1617,16 +1635,24 @@ void chain_reply(struct smb_request *req)
 		 */
 		smb_setlen((char *)(req->chain_outbuf),
 			   talloc_get_size(req->chain_outbuf) - 4);
+
 		if (!srv_send_smb(smbd_server_fd(), (char *)req->chain_outbuf,
 				  IS_CONN_ENCRYPTED(req->conn)
-				  ||req->encrypted)) {
+				  ||req->encrypted,
+				  &req->pcd)) {
 			exit_server_cleanly("chain_reply: srv_send_smb "
 					    "failed.");
 		}
 		TALLOC_FREE(req);
+
 		return;
 	}
 
+	/* add a new perfcounter for this element of chain */
+	SMB_PERFCOUNT_ADD(&req->pcd);
+	SMB_PERFCOUNT_SET_OP(&req->pcd, chain_cmd);
+	SMB_PERFCOUNT_SET_MSGLEN_IN(&req->pcd, smblen);
+
 	/*
 	 * Check if the client tries to fool us. The request so far uses the
 	 * space to the end of the byte buffer in the request just
@@ -1735,7 +1761,8 @@ void chain_reply(struct smb_request *req)
 	show_msg((char *)(req->chain_outbuf));
 
 	if (!srv_send_smb(smbd_server_fd(), (char *)req->chain_outbuf,
-			  IS_CONN_ENCRYPTED(req->conn)||req->encrypted)) {
+			  IS_CONN_ENCRYPTED(req->conn)||req->encrypted,
+			  &req->pcd)) {
 		exit_server_cleanly("construct_reply: srv_send_smb failed.");
 	}
 	TALLOC_FREE(req);
@@ -1823,7 +1850,7 @@ static void smbd_server_connection_read_handler(struct smbd_server_connection *c
 	}
 
 process:
-	process_smb(conn, inbuf, inbuf_len, unread_bytes, encrypted);
+	process_smb(conn, inbuf, inbuf_len, unread_bytes, encrypted, NULL);
 }
 
 static void smbd_server_connection_handler(struct event_context *ev,
@@ -1988,7 +2015,7 @@ void smbd_process(void)
 		unsigned char buf[5] = {0x83, 0, 0, 1, 0x81};
 		DEBUG( 1, ("Connection denied from %s\n",
 			   client_addr(get_client_fd(),addr,sizeof(addr)) ) );
-		(void)srv_send_smb(smbd_server_fd(),(char *)buf,false);
+		(void)srv_send_smb(smbd_server_fd(),(char *)buf,false, NULL);
 		exit_server_cleanly("connection denied");
 	}
 
@@ -1996,6 +2023,8 @@ void smbd_process(void)
 
 	init_modules();
 
+	smb_perfcount_init();
+
 	if (!init_account_policy()) {
 		exit_server("Could not open account policy tdb.\n");
 	}
diff --git a/source3/smbd/reply.c b/source3/smbd/reply.c
index bb5fadd465..60e2e5dc7a 100644
--- a/source3/smbd/reply.c
+++ b/source3/smbd/reply.c
@@ -492,7 +492,7 @@ void reply_special(char *inbuf)
 	DEBUG(5,("init msg_type=0x%x msg_flags=0x%x\n",
 		    msg_type, msg_flags));
 
-	srv_send_smb(smbd_server_fd(), outbuf, false);
+	srv_send_smb(smbd_server_fd(), outbuf, false, NULL);
 	return;
 }
 
@@ -3293,6 +3293,8 @@ static void send_file_readX(connection_struct *conn, struct smb_request *req,
 
 		/* No outbuf here means successful sendfile. */
 		TALLOC_FREE(req->outbuf);
+		SMB_PERFCOUNT_SET_MSGLEN_OUT(&req->pcd, nread);
+		SMB_PERFCOUNT_END(&req->pcd);
 		return;
 	}
 #endif
@@ -3590,7 +3592,8 @@ void reply_writebraw(struct smb_request *req)
 	show_msg(buf);
 	if (!srv_send_smb(smbd_server_fd(),
 			buf,
-			IS_CONN_ENCRYPTED(conn))) {
+			IS_CONN_ENCRYPTED(conn),
+			&req->pcd)) {
 		exit_server_cleanly("reply_writebraw: srv_send_smb "
 			"failed.");
 	}
@@ -4647,7 +4650,8 @@ void reply_echo(struct smb_request *req)
 		show_msg((char *)req->outbuf);
 		if (!srv_send_smb(smbd_server_fd(),
 				(char *)req->outbuf,
-				IS_CONN_ENCRYPTED(conn)||req->encrypted))
+				IS_CONN_ENCRYPTED(conn)||req->encrypted,
+				&req->pcd))
 			exit_server_cleanly("reply_echo: srv_send_smb failed.");
 	}
 
diff --git a/source3/smbd/trans2.c b/source3/smbd/trans2.c
index 6c082a8273..6a6e59a581 100644
--- a/source3/smbd/trans2.c
+++ b/source3/smbd/trans2.c
@@ -832,7 +832,8 @@ void send_trans2_replies(connection_struct *conn,
 		show_msg((char *)req->outbuf);
 		if (!srv_send_smb(smbd_server_fd(),
 				(char *)req->outbuf,
-				IS_CONN_ENCRYPTED(conn)))
+				IS_CONN_ENCRYPTED(conn),
+				&req->pcd))
 			exit_server_cleanly("send_trans2_replies: srv_send_smb failed.");
 
 		TALLOC_FREE(req->outbuf);
@@ -7468,6 +7469,8 @@ static void handle_trans2(connection_struct *conn, struct smb_request *req,
 		}
 	}
 
+	SMB_PERFCOUNT_SET_SUBOP(&req->pcd, state->call);
+
 	/* Now we must call the relevant TRANS2 function */
 	switch(state->call)  {
 	case TRANSACT2_OPEN: