r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules

the idea is that a passthru module can use ntvfs_async_state_push() before
calling ntvfs_next_*() and in the _send function it calls
ntvfs_async_state_pop() and then call the upper layer send_fn itself

- ntvfs_nbench is now fully async

- the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet

metze
(This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)

1 files changed, 385 insertions, 180 deletions

diff --git a/source4/ntvfs/nbench/vfs_nbench.c b/source4/ntvfs/nbench/vfs_nbench.c
index 482f0208a2..ab2d7af7b1 100644
--- a/source4/ntvfs/nbench/vfs_nbench.c
+++ b/source4/ntvfs/nbench/vfs_nbench.c
@@ -47,7 +47,7 @@ static void nbench_log(struct nbench_private *private,
 	vasprintf(&s, format, ap);
 	va_end(ap);
 
-	write(private->log_fd, s, strlen(s));
+	//write(private->log_fd, s, strlen(s));
 	free(s);
 }
 
@@ -58,11 +58,39 @@ static void nbench_log(struct nbench_private *private,
   async calls are a pain for the nbench module as it makes pulling the
   status code and any result parameters much harder.
 */
-#define PASS_THRU_REQ(ntvfs, req, op, args) do { \
-	req->control_flags &= ~REQ_CONTROL_MAY_ASYNC; \
+#define PASS_THRU_REQ_PRE_ASYNC(ntvfs, req, op, par1) do { \
+	status = ntvfs_async_state_push(req, par1, nbench_##op##_send, ntvfs); \
+	if (!NT_STATUS_IS_OK(status)) { \
+		return status; \
+	} \
+} while (0)
+
+#define PASS_THRU_REQ_POST_ASYNC(req) do { \
+	req->async_states->status = status; \
+	if (!(req->async_states->state & NTVFS_ASYNC_STATE_ASYNC)) { \
+DEBUG(0,("NBENCH S 0x%04X: %s: %s 0x%X\n", req->mid, __FUNCTION__, nt_errstr(status),req->async_states->state)); \
+		req->async_states->send_fn(req); \
+	} else { \
+DEBUG(0,("NBENCH A 0x%04X: %s: %s\n", req->mid, __FUNCTION__, nt_errstr(status))); \
+	} \
+} while (0)
+
+#define PASS_THRU_REQ(ntvfs, req, op, par1, args) do { \
+	PASS_THRU_REQ_PRE_ASYNC(ntvfs, req, op, par1); \
 	status = ntvfs_next_##op args; \
+	PASS_THRU_REQ_POST_ASYNC(req); \
 } while (0)
 
+#define PASS_THRU_REP_POST(req) do { \
+	ntvfs_async_state_pop(req); \
+	if (req->async_states->state & NTVFS_ASYNC_STATE_ASYNC) { \
+DEBUG(0,("NBENCH  A0x%04X: %s: %s\n", req->mid, __FUNCTION__, nt_errstr(req->async_states->status))); \
+		req->async_states->send_fn(req); \
+	} \
+} while (0)
+
+#define PASS_THRU_REP_PRE(req) \
+	struct nbench_private *nprivates = req->async_states->ntvfs->private_data
 
 /*
   connect to a share - used when a tree_connect operation comes in.
@@ -70,25 +98,25 @@ static void nbench_log(struct nbench_private *private,
 static NTSTATUS nbench_connect(struct ntvfs_module_context *ntvfs,
 			       struct smbsrv_request *req, const char *sharename)
 {
-	struct nbench_private *private;
+	struct nbench_private *nprivates;
 	NTSTATUS status;
 	char *logname = NULL;
 
-	private = talloc_p(req->tcon, struct nbench_private);
-	if (!private) {
+	nprivates = talloc_p(req->tcon, struct nbench_private);
+	if (!nprivates) {
 		return NT_STATUS_NO_MEMORY;
 	}
-
+#if 0
 	asprintf(&logname, "/tmp/nbenchlog%d.%u", ntvfs->depth, getpid());
-	private->log_fd = sys_open(logname, O_WRONLY|O_CREAT|O_APPEND, 0644);
+	nprivates->log_fd = sys_open(logname, O_WRONLY|O_CREAT|O_APPEND, 0644);
 	free(logname);
 
-	if (private->log_fd == -1) {
+	if (nprivates->log_fd == -1) {
 		DEBUG(0,("Failed to open nbench log\n"));
 		return NT_STATUS_UNSUCCESSFUL;
 	}
-
-	ntvfs->private_data = private;
+#endif
+	ntvfs->private_data = nprivates;
 
 	status = ntvfs_next_connect(ntvfs, req, sharename);
 
@@ -101,13 +129,13 @@ static NTSTATUS nbench_connect(struct ntvfs_module_context *ntvfs,
 static NTSTATUS nbench_disconnect(struct ntvfs_module_context *ntvfs,
 				  struct smbsrv_tcon *tcon)
 {
-	struct nbench_private *private = ntvfs->private_data;
+	struct nbench_private *nprivates = ntvfs->private_data;
 	NTSTATUS status;
 
-	close(private->log_fd);
+	close(nprivates->log_fd);
 
 	status = ntvfs_next_disconnect(ntvfs, tcon);
- 
+
 	return status;
 }
 
@@ -115,17 +143,24 @@ static NTSTATUS nbench_disconnect(struct ntvfs_module_context *ntvfs,
   delete a file - the dirtype specifies the file types to include in the search. 
   The name can contain CIFS wildcards, but rarely does (except with OS/2 clients)
 */
+static void nbench_unlink_send(struct smbsrv_request *req)
+{
+	PASS_THRU_REP_PRE(req);
+	struct smb_unlink *unl = req->async_states->private_data;
+
+	nbench_log(nprivates, "Unlink \"%s\" 0x%x %s\n", 
+		   unl->in.pattern, unl->in.attrib, 
+		   get_nt_error_c_code(req->async_states->status));
+
+	PASS_THRU_REP_POST(req);
+}
+
 static NTSTATUS nbench_unlink(struct ntvfs_module_context *ntvfs,
 			      struct smbsrv_request *req, struct smb_unlink *unl)
 {
-	struct nbench_private *private = ntvfs->private_data;
 	NTSTATUS status;
 
-	PASS_THRU_REQ(ntvfs, req, unlink, (ntvfs, req, unl));
-
-	nbench_log(private, "Unlink \"%s\" 0x%x %s\n", 
-		   unl->in.pattern, unl->in.attrib, 
-		   get_nt_error_c_code(status));
+	PASS_THRU_REQ(ntvfs, req, unlink, unl, (ntvfs, req, unl));
 
 	return status;
 }
@@ -133,15 +168,21 @@ static NTSTATUS nbench_unlink(struct ntvfs_module_context *ntvfs,
 /*
   ioctl interface
 */
+static void nbench_ioctl_send(struct smbsrv_request *req)
+{
+	PASS_THRU_REP_PRE(req);
+
+	nbench_log(nprivates, "Ioctl - NOT HANDLED\n");
+
+	PASS_THRU_REP_POST(req);
+}
+
 static NTSTATUS nbench_ioctl(struct ntvfs_module_context *ntvfs,
 			     struct smbsrv_request *req, union smb_ioctl *io)
 {
-	struct nbench_private *private = ntvfs->private_data;
 	NTSTATUS status;
 
-	PASS_THRU_REQ(ntvfs, req, ioctl, (ntvfs, req, io));
-
-	nbench_log(private, "Ioctl - NOT HANDLED\n");
+	PASS_THRU_REQ(ntvfs, req, ioctl, io, (ntvfs, req, io));
 
 	return status;
 }
@@ -149,17 +190,24 @@ static NTSTATUS nbench_ioctl(struct ntvfs_module_context *ntvfs,
 /*
   check if a directory exists
 */
+static void nbench_chkpath_send(struct smbsrv_request *req)
+{
+	PASS_THRU_REP_PRE(req);
+	struct smb_chkpath *cp = req->async_states->private_data;
+
+	nbench_log(nprivates, "Chkpath \"%s\" %s\n", 
+		   cp->in.path, 
+		   get_nt_error_c_code(req->async_states->status));
+
+	PASS_THRU_REP_POST(req);
+}
+
 static NTSTATUS nbench_chkpath(struct ntvfs_module_context *ntvfs,
 			       struct smbsrv_request *req, struct smb_chkpath *cp)
 {
-	struct nbench_private *private = ntvfs->private_data;
 	NTSTATUS status;
 
-	PASS_THRU_REQ(ntvfs, req, chkpath, (ntvfs, req, cp));
-
-	nbench_log(private, "Chkpath \"%s\" %s\n", 
-		   cp->in.path, 
-		   get_nt_error_c_code(status));
+	PASS_THRU_REQ(ntvfs, req, chkpath, cp, (ntvfs, req, cp));
 
 	return status;
 }
@@ -167,18 +215,25 @@ static NTSTATUS nbench_chkpath(struct ntvfs_module_context *ntvfs,
 /*
   return info on a pathname
 */
+static void nbench_qpathinfo_send(struct smbsrv_request *req)
+{
+	PASS_THRU_REP_PRE(req);
+	union smb_fileinfo *info = req->async_states->private_data;
+
+	nbench_log(nprivates, "QUERY_PATH_INFORMATION \"%s\" %d %s\n", 
+		   info->generic.in.fname, 
+		   info->generic.level,
+		   get_nt_error_c_code(req->async_states->status));
+
+	PASS_THRU_REP_POST(req);
+}
+
 static NTSTATUS nbench_qpathinfo(struct ntvfs_module_context *ntvfs,
 				 struct smbsrv_request *req, union smb_fileinfo *info)
 {
-	struct nbench_private *private = ntvfs->private_data;
 	NTSTATUS status;
 
-	PASS_THRU_REQ(ntvfs, req, qpathinfo, (ntvfs, req, info));
-
-	nbench_log(private, "QUERY_PATH_INFORMATION \"%s\" %d %s\n", 
-		   info->generic.in.fname, 
-		   info->generic.level,
-		   get_nt_error_c_code(status));
+	PASS_THRU_REQ(ntvfs, req, qpathinfo, info, (ntvfs, req, info));
 
 	return status;
 }
@@ -186,38 +241,51 @@ static NTSTATUS nbench_qpathinfo(struct ntvfs_module_context *ntvfs,
 /*
   query info on a open file
 */
+static void nbench_qfileinfo_send(struct smbsrv_request *req)
+{
+	PASS_THRU_REP_PRE(req);
+	union smb_fileinfo *info = req->async_states->private_data;
+
+	nbench_log(nprivates, "QUERY_FILE_INFORMATION %d %d %s\n", 
+		   info->generic.in.fnum, 
+		   info->generic.level,
+		   get_nt_error_c_code(req->async_states->status));
+
+	PASS_THRU_REP_POST(req);
+}
+
 static NTSTATUS nbench_qfileinfo(struct ntvfs_module_context *ntvfs,
 				 struct smbsrv_request *req, union smb_fileinfo *info)
 {
-	struct nbench_private *private = ntvfs->private_data;
 	NTSTATUS status;
 
-	PASS_THRU_REQ(ntvfs, req, qfileinfo, (ntvfs, req, info));
-
-	nbench_log(private, "QUERY_FILE_INFORMATION %d %d %s\n", 
-		   info->generic.in.fnum, 
-		   info->generic.level,
-		   get_nt_error_c_code(status));
+	PASS_THRU_REQ(ntvfs, req, qfileinfo, info, (ntvfs, req, info));
 
 	return status;
 }
 
-
 /*
   set info on a pathname
 */
+static void nbench_setpathinfo_send(struct smbsrv_request *req)
+{
+	PASS_THRU_REP_PRE(req);
+	union smb_setfileinfo *st = req->async_states->private_data;
+
+	nbench_log(nprivates, "SET_PATH_INFORMATION \"%s\" %d %s\n", 
+		   st->generic.file.fname, 
+		   st->generic.level,
+		   get_nt_error_c_code(req->async_states->status));
+
+	PASS_THRU_REP_POST(req);
+}
+
 static NTSTATUS nbench_setpathinfo(struct ntvfs_module_context *ntvfs,
 				   struct smbsrv_request *req, union smb_setfileinfo *st)
 {
-	struct nbench_private *private = ntvfs->private_data;
 	NTSTATUS status;
 
-	PASS_THRU_REQ(ntvfs, req, setpathinfo, (ntvfs, req, st));
-
-	nbench_log(private, "SET_PATH_INFORMATION \"%s\" %d %s\n", 
-		   st->generic.file.fname, 
-		   st->generic.level,
-		   get_nt_error_c_code(status));
+	PASS_THRU_REQ(ntvfs, req, setpathinfo, st, (ntvfs, req, st));
 
 	return status;
 }
@@ -225,47 +293,58 @@ static NTSTATUS nbench_setpathinfo(struct ntvfs_module_context *ntvfs,
 /*
   open a file
 */
-static NTSTATUS nbench_open(struct ntvfs_module_context *ntvfs,
-			    struct smbsrv_request *req, union smb_open *io)
+static void nbench_open_send(struct smbsrv_request *req)
 {
-	struct nbench_private *private = ntvfs->private_data;
-	NTSTATUS status;
-
-	PASS_THRU_REQ(ntvfs, req, open, (ntvfs, req, io));
-
-	DEBUG(0,("%d: %s\n", ntvfs->depth, get_nt_error_c_code(status)));
+	PASS_THRU_REP_PRE(req);
+	union smb_open *io = req->async_states->private_data;
 
 	switch (io->generic.level) {
 	case RAW_OPEN_NTCREATEX:
-		nbench_log(private, "NTCreateX \"%s\" 0x%x 0x%x %d %s\n", 
+		nbench_log(nprivates, "NTCreateX \"%s\" 0x%x 0x%x %d %s\n", 
 			   io->ntcreatex.in.fname, 
 			   io->ntcreatex.in.create_options, 
 			   io->ntcreatex.in.open_disposition, 
 			   io->ntcreatex.out.fnum,
-			   get_nt_error_c_code(status));
+			   get_nt_error_c_code(req->async_states->status));
 		break;
 
 	default:
-		nbench_log(private, "Open-%d - NOT HANDLED\n",
+		nbench_log(nprivates, "Open-%d - NOT HANDLED\n",
 			   io->generic.level);
 		break;
 	}
 
+	PASS_THRU_REP_POST(req);
+}
+
+static NTSTATUS nbench_open(struct ntvfs_module_context *ntvfs,
+			    struct smbsrv_request *req, union smb_open *io)
+{
+	NTSTATUS status;
+
+	PASS_THRU_REQ(ntvfs, req, open, io, (ntvfs, req, io));
+
 	return status;
 }
 
 /*
   create a directory
 */
+static void nbench_mkdir_send(struct smbsrv_request *req)
+{
+	PASS_THRU_REP_PRE(req);
+
+	nbench_log(nprivates, "Mkdir - NOT HANDLED\n");
+
+	PASS_THRU_REP_POST(req);
+}
+
 static NTSTATUS nbench_mkdir(struct ntvfs_module_context *ntvfs,
 			     struct smbsrv_request *req, union smb_mkdir *md)
 {
-	struct nbench_private *private = ntvfs->private_data;
 	NTSTATUS status;
 
-	PASS_THRU_REQ(ntvfs, req, mkdir, (ntvfs, req, md));
-
-	nbench_log(private, "Mkdir - NOT HANDLED\n");
+	PASS_THRU_REQ(ntvfs, req, mkdir, md, (ntvfs, req, md));
 
 	return status;
 }
@@ -273,17 +352,24 @@ static NTSTATUS nbench_mkdir(struct ntvfs_module_context *ntvfs,
 /*
   remove a directory
 */
+static void nbench_rmdir_send(struct smbsrv_request *req)
+{
+	PASS_THRU_REP_PRE(req);
+	struct smb_rmdir *rd = req->async_states->private_data;
+
+	nbench_log(nprivates, "Rmdir \"%s\" %s\n", 
+		   rd->in.path, 
+		   get_nt_error_c_code(req->async_states->status));
+
+	PASS_THRU_REP_POST(req);
+}
+
 static NTSTATUS nbench_rmdir(struct ntvfs_module_context *ntvfs,
 			     struct smbsrv_request *req, struct smb_rmdir *rd)
 {
-	struct nbench_private *private = ntvfs->private_data;
 	NTSTATUS status;
 
-	PASS_THRU_REQ(ntvfs, req, rmdir, (ntvfs, req, rd));
-
-	nbench_log(private, "Rmdir \"%s\" %s\n", 
-		   rd->in.path, 
-		   get_nt_error_c_code(status));
+	PASS_THRU_REQ(ntvfs, req, rmdir, rd, (ntvfs, req, rd));
 
 	return status;
 }
@@ -291,43 +377,56 @@ static NTSTATUS nbench_rmdir(struct ntvfs_module_context *ntvfs,
 /*
   rename a set of files
 */
-static NTSTATUS nbench_rename(struct ntvfs_module_context *ntvfs,
-			      struct smbsrv_request *req, union smb_rename *ren)
+static void nbench_rename_send(struct smbsrv_request *req)
 {
-	struct nbench_private *private = ntvfs->private_data;
-	NTSTATUS status;
-
-	PASS_THRU_REQ(ntvfs, req, rename, (ntvfs, req, ren));
+	PASS_THRU_REP_PRE(req);
+	union smb_rename *ren = req->async_states->private_data;
 
 	switch (ren->generic.level) {
 	case RAW_RENAME_RENAME:
-		nbench_log(private, "Rename \"%s\" \"%s\" %s\n", 
+		nbench_log(nprivates, "Rename \"%s\" \"%s\" %s\n", 
 			   ren->rename.in.pattern1, 
 			   ren->rename.in.pattern2, 
-			   get_nt_error_c_code(status));
+			   get_nt_error_c_code(req->async_states->status));
 		break;
 
 	default:
-		nbench_log(private, "Rename-%d - NOT HANDLED\n",
+		nbench_log(nprivates, "Rename-%d - NOT HANDLED\n",
 			   ren->generic.level);
 		break;
 	}
 
+	PASS_THRU_REP_POST(req);
+}
+
+static NTSTATUS nbench_rename(struct ntvfs_module_context *ntvfs,
+			      struct smbsrv_request *req, union smb_rename *ren)
+{
+	NTSTATUS status;
+
+	PASS_THRU_REQ(ntvfs, req, rename, ren, (ntvfs, req, ren));
+
 	return status;
 }
 
 /*
   copy a set of files
 */
+static void nbench_copy_send(struct smbsrv_request *req)
+{
+	PASS_THRU_REP_PRE(req);
+
+	nbench_log(nprivates, "Copy - NOT HANDLED\n");
+
+	PASS_THRU_REP_POST(req);
+}
+
 static NTSTATUS nbench_copy(struct ntvfs_module_context *ntvfs,
 			    struct smbsrv_request *req, struct smb_copy *cp)
 {
-	struct nbench_private *private = ntvfs->private_data;
 	NTSTATUS status;
 
-	PASS_THRU_REQ(ntvfs, req, copy, (ntvfs, req, cp));
-
-	nbench_log(private, "Copy - NOT HANDLED\n");
+	PASS_THRU_REQ(ntvfs, req, copy, cp, (ntvfs, req, cp));
 
 	return status;
 }
@@ -335,83 +434,103 @@ static NTSTATUS nbench_copy(struct ntvfs_module_context *ntvfs,
 /*
   read from a file
 */
-static NTSTATUS nbench_read(struct ntvfs_module_context *ntvfs,
-			    struct smbsrv_request *req, union smb_read *rd)
+static void nbench_read_send(struct smbsrv_request *req)
 {
-	struct nbench_private *private = ntvfs->private_data;
-	NTSTATUS status;
-
-	PASS_THRU_REQ(ntvfs, req, read, (ntvfs, req, rd));
+	PASS_THRU_REP_PRE(req);
+	union smb_read *rd = req->async_states->private_data;
 
 	switch (rd->generic.level) {
 	case RAW_READ_READX:
-		nbench_log(private, "ReadX %d %d %d %d %s\n", 
+		nbench_log(nprivates, "ReadX %d %d %d %d %s\n", 
 			   rd->readx.in.fnum, 
 			   (int)rd->readx.in.offset,
 			   rd->readx.in.maxcnt,
 			   rd->readx.out.nread,
-			   get_nt_error_c_code(status));
+			   get_nt_error_c_code(req->async_states->status));
 		break;
 	default:
-		nbench_log(private, "Read-%d - NOT HANDLED\n",
+		nbench_log(nprivates, "Read-%d - NOT HANDLED\n",
 			   rd->generic.level);
 		break;
 	}
 
+	PASS_THRU_REP_POST(req);
+}
+
+static NTSTATUS nbench_read(struct ntvfs_module_context *ntvfs,
+			    struct smbsrv_request *req, union smb_read *rd)
+{
+	NTSTATUS status;
+
+	PASS_THRU_REQ(ntvfs, req, read, rd, (ntvfs, req, rd));
+
 	return status;
 }
 
 /*
   write to a file
 */
-static NTSTATUS nbench_write(struct ntvfs_module_context *ntvfs,
-			     struct smbsrv_request *req, union smb_write *wr)
+static void nbench_write_send(struct smbsrv_request *req)
 {
-	struct nbench_private *private = ntvfs->private_data;
-	NTSTATUS status;
-
-	PASS_THRU_REQ(ntvfs, req, write, (ntvfs, req, wr));
+	PASS_THRU_REP_PRE(req);
+	union smb_write *wr = req->async_states->private_data;
 
 	switch (wr->generic.level) {
 	case RAW_WRITE_WRITEX:
-		nbench_log(private, "WriteX %d %d %d %d %s\n", 
+		nbench_log(nprivates, "WriteX %d %d %d %d %s\n", 
 			   wr->writex.in.fnum, 
 			   (int)wr->writex.in.offset,
 			   wr->writex.in.count,
 			   wr->writex.out.nwritten,
-			   get_nt_error_c_code(status));
+			   get_nt_error_c_code(req->async_states->status));
 		break;
 
 	case RAW_WRITE_WRITE:
-		nbench_log(private, "Write %d %d %d %d %s\n", 
+		nbench_log(nprivates, "Write %d %d %d %d %s\n", 
 			   wr->write.in.fnum, 
 			   wr->write.in.offset,
 			   wr->write.in.count,
 			   wr->write.out.nwritten,
-			   get_nt_error_c_code(status));
+			   get_nt_error_c_code(req->async_states->status));
 		break;
 
 	default:
-		nbench_log(private, "Write-%d - NOT HANDLED\n",
+		nbench_log(nprivates, "Write-%d - NOT HANDLED\n",
 			   wr->generic.level);
 		break;
 	}
 
+	PASS_THRU_REP_POST(req);
+}
+
+static NTSTATUS nbench_write(struct ntvfs_module_context *ntvfs,
+			     struct smbsrv_request *req, union smb_write *wr)
+{
+	NTSTATUS status;
+
+	PASS_THRU_REQ(ntvfs, req, write, wr, (ntvfs, req, wr));
+
 	return status;
 }
 
 /*
   seek in a file
 */
+static void nbench_seek_send(struct smbsrv_request *req)
+{
+	PASS_THRU_REP_PRE(req);
+
+	nbench_log(nprivates, "Seek - NOT HANDLED\n");
+
+	PASS_THRU_REP_POST(req);
+}
+
 static NTSTATUS nbench_seek(struct ntvfs_module_context *ntvfs,
 			    struct smbsrv_request *req, struct smb_seek *io)
 {
-	struct nbench_private *private = ntvfs->private_data;
 	NTSTATUS status;
 
-	PASS_THRU_REQ(ntvfs, req, seek, (ntvfs, req, io));
-
-	nbench_log(private, "Seek - NOT HANDLED\n");
+	PASS_THRU_REQ(ntvfs, req, seek, io, (ntvfs, req, io));
 
 	return status;
 }
@@ -419,17 +538,24 @@ static NTSTATUS nbench_seek(struct ntvfs_module_context *ntvfs,
 /*
   flush a file
 */
+static void nbench_flush_send(struct smbsrv_request *req)
+{
+	PASS_THRU_REP_PRE(req);
+	struct smb_flush *io = req->async_states->private_data;
+
+	nbench_log(nprivates, "Flush %d %s\n",
+		   io->in.fnum,
+		   get_nt_error_c_code(req->async_states->status));
+
+	PASS_THRU_REP_POST(req);
+}
+
 static NTSTATUS nbench_flush(struct ntvfs_module_context *ntvfs,
 			     struct smbsrv_request *req, struct smb_flush *io)
 {
-	struct nbench_private *private = ntvfs->private_data;
 	NTSTATUS status;
 
-	PASS_THRU_REQ(ntvfs, req, flush, (ntvfs, req, io));
-
-	nbench_log(private, "Flush %d %s\n",
-		   io->in.fnum,
-		   get_nt_error_c_code(status));
+	PASS_THRU_REQ(ntvfs, req, flush, io, (ntvfs, req, io));
 
 	return status;
 }
@@ -437,39 +563,55 @@ static NTSTATUS nbench_flush(struct ntvfs_module_context *ntvfs,
 /*
   close a file
 */
-static NTSTATUS nbench_close(struct ntvfs_module_context *ntvfs,
-			     struct smbsrv_request *req, union smb_close *io)
+static void nbench_close_send(struct smbsrv_request *req)
 {
-	struct nbench_private *private = ntvfs->private_data;
-	NTSTATUS status;
-
-	PASS_THRU_REQ(ntvfs, req, close, (ntvfs, req, io));
+	PASS_THRU_REP_PRE(req);
+	union smb_close *io = req->async_states->private_data;
 
 	switch (io->generic.level) {
 	case RAW_CLOSE_CLOSE:
-		nbench_log(private, "Close %d %s\n",
+		nbench_log(nprivates, "Close %d %s\n",
 			   io->close.in.fnum,
-			   get_nt_error_c_code(status));
+			   get_nt_error_c_code(req->async_states->status));
 		break;
 
 	default:
-		nbench_log(private, "Close-%d - NOT HANDLED\n",
+		nbench_log(nprivates, "Close-%d - NOT HANDLED\n",
 			   io->generic.level);
 		break;
 	}		
 
+	PASS_THRU_REP_POST(req);
+}
+
+static NTSTATUS nbench_close(struct ntvfs_module_context *ntvfs,
+			     struct smbsrv_request *req, union smb_close *io)
+{
+	NTSTATUS status;
+
+	PASS_THRU_REQ(ntvfs, req, close, io, (ntvfs, req, io));
+
 	return status;
 }
 
 /*
   exit - closing files
 */
+static void nbench_exit_send(struct smbsrv_request *req)
+{
+	PASS_THRU_REP_PRE(req);
+
+	nbench_log(nprivates, "Exit - NOT HANDLED\n");
+
+	PASS_THRU_REP_POST(req);
+}
+
 static NTSTATUS nbench_exit(struct ntvfs_module_context *ntvfs,
 			    struct smbsrv_request *req)
 {
 	NTSTATUS status;
 
-	PASS_THRU_REQ(ntvfs, req, exit, (ntvfs, req));
+	PASS_THRU_REQ(ntvfs, req, exit, NULL, (ntvfs, req));
 
 	return status;
 }
@@ -477,12 +619,21 @@ static NTSTATUS nbench_exit(struct ntvfs_module_context *ntvfs,
 /*
   logoff - closing files
 */
+static void nbench_logoff_send(struct smbsrv_request *req)
+{
+	PASS_THRU_REP_PRE(req);
+
+	nbench_log(nprivates, "Logoff - NOT HANDLED\n");
+
+	PASS_THRU_REP_POST(req);
+}
+
 static NTSTATUS nbench_logoff(struct ntvfs_module_context *ntvfs,
 			      struct smbsrv_request *req)
 {
 	NTSTATUS status;
 
-	PASS_THRU_REQ(ntvfs, req, logoff, (ntvfs, req));
+	PASS_THRU_REQ(ntvfs, req, logoff, NULL, (ntvfs, req));
 
 	return status;
 }
@@ -500,71 +651,91 @@ static NTSTATUS nbench_async_setup(struct ntvfs_module_context *ntvfs,
 /*
   lock a byte range
 */
-static NTSTATUS nbench_lock(struct ntvfs_module_context *ntvfs,
-			    struct smbsrv_request *req, union smb_lock *lck)
+static void nbench_lock_send(struct smbsrv_request *req)
 {
-	struct nbench_private *private = ntvfs->private_data;
-	NTSTATUS status;
-
-	PASS_THRU_REQ(ntvfs, req, lock, (ntvfs, req, lck));
+	PASS_THRU_REP_PRE(req);
+	union smb_lock *lck = req->async_states->private_data;
 
 	if (lck->generic.level == RAW_LOCK_LOCKX &&
 	    lck->lockx.in.lock_cnt == 1 &&
 	    lck->lockx.in.ulock_cnt == 0) {
-		nbench_log(private, "LockX %d %d %d %s\n", 
+		nbench_log(nprivates, "LockX %d %d %d %s\n", 
 			   lck->lockx.in.fnum,
 			   (int)lck->lockx.in.locks[0].offset,
 			   (int)lck->lockx.in.locks[0].count,
-			   get_nt_error_c_code(status));
+			   get_nt_error_c_code(req->async_states->status));
 	} else if (lck->generic.level == RAW_LOCK_LOCKX &&
 		   lck->lockx.in.ulock_cnt == 1) {
-		nbench_log(private, "UnlockX %d %d %d %s\n", 
+		nbench_log(nprivates, "UnlockX %d %d %d %s\n", 
 			   lck->lockx.in.fnum,
 			   (int)lck->lockx.in.locks[0].offset,
 			   (int)lck->lockx.in.locks[0].count,
-			   get_nt_error_c_code(status));
+			   get_nt_error_c_code(req->async_states->status));
 	} else {
-		nbench_log(private, "Lock-%d - NOT HANDLED\n", lck->generic.level);
+		nbench_log(nprivates, "Lock-%d - NOT HANDLED\n", lck->generic.level);
 	}
 
+	PASS_THRU_REP_POST(req);
+}
+
+static NTSTATUS nbench_lock(struct ntvfs_module_context *ntvfs,
+			    struct smbsrv_request *req, union smb_lock *lck)
+{
+	NTSTATUS status;
+
+	PASS_THRU_REQ(ntvfs, req, lock, lck, (ntvfs, req, lck));
+
 	return status;
 }
 
 /*
   set info on a open file
 */
+static void nbench_setfileinfo_send(struct smbsrv_request *req)
+{
+	PASS_THRU_REP_PRE(req);
+	union smb_setfileinfo *info = req->async_states->private_data;
+
+	nbench_log(nprivates, "SET_FILE_INFORMATION %d %d %s\n", 
+		   info->generic.file.fnum,
+		   info->generic.level,
+		   get_nt_error_c_code(req->async_states->status));
+
+	PASS_THRU_REP_POST(req);
+}
+
 static NTSTATUS nbench_setfileinfo(struct ntvfs_module_context *ntvfs,
 				   struct smbsrv_request *req, 
 				   union smb_setfileinfo *info)
 {
-	struct nbench_private *private = ntvfs->private_data;
 	NTSTATUS status;
 
-	PASS_THRU_REQ(ntvfs, req, setfileinfo, (ntvfs, req, info));
-
-	nbench_log(private, "SET_FILE_INFORMATION %d %d %s\n", 
-		   info->generic.file.fnum,
-		   info->generic.level,
-		   get_nt_error_c_code(status));
+	PASS_THRU_REQ(ntvfs, req, setfileinfo, info, (ntvfs, req, info));
 
 	return status;
 }
 
-
 /*
   return filesystem space info
 */
+static void nbench_fsinfo_send(struct smbsrv_request *req)
+{
+	PASS_THRU_REP_PRE(req);
+	union smb_fsinfo *fs = req->async_states->private_data;
+
+	nbench_log(nprivates, "QUERY_FS_INFORMATION %d %s\n", 
+		   fs->generic.level, 
+		   get_nt_error_c_code(req->async_states->status));
+
+	PASS_THRU_REP_POST(req);
+}
+
 static NTSTATUS nbench_fsinfo(struct ntvfs_module_context *ntvfs,
 			      struct smbsrv_request *req, union smb_fsinfo *fs)
 {
-	struct nbench_private *private = ntvfs->private_data;
 	NTSTATUS status;
 
-	PASS_THRU_REQ(ntvfs, req, fsinfo, (ntvfs, req, fs));
-
-	nbench_log(private, "QUERY_FS_INFORMATION %d %s\n", 
-		   fs->generic.level, 
-		   get_nt_error_c_code(status));
+	PASS_THRU_REQ(ntvfs, req, fsinfo, fs, (ntvfs, req, fs));
 
 	return status;
 }
@@ -572,15 +743,22 @@ static NTSTATUS nbench_fsinfo(struct ntvfs_module_context *ntvfs,
 /*
   return print queue info
 */
+static void nbench_lpq_send(struct smbsrv_request *req)
+{
+	PASS_THRU_REP_PRE(req);
+	union smb_lpq *lpq = req->async_states->private_data;
+
+	nbench_log(nprivates, "Lpq-%d - NOT HANDLED\n", lpq->generic.level);
+
+	PASS_THRU_REP_POST(req);
+}
+
 static NTSTATUS nbench_lpq(struct ntvfs_module_context *ntvfs,
 			   struct smbsrv_request *req, union smb_lpq *lpq)
 {
-	struct nbench_private *private = ntvfs->private_data;
 	NTSTATUS status;
 
-	PASS_THRU_REQ(ntvfs, req, lpq, (ntvfs, req, lpq));
-
-	nbench_log(private, "Lpq-%d - NOT HANDLED\n", lpq->generic.level);
+	PASS_THRU_REQ(ntvfs, req, lpq, lpq, (ntvfs, req, lpq));
 
 	return status;
 }
@@ -588,74 +766,101 @@ static NTSTATUS nbench_lpq(struct ntvfs_module_context *ntvfs,
 /* 
    list files in a directory matching a wildcard pattern
 */
-static NTSTATUS nbench_search_first(struct ntvfs_module_context *ntvfs,
-				    struct smbsrv_request *req, union smb_search_first *io, 
-				    void *search_private, 
-				    BOOL (*callback)(void *, union smb_search_data *))
+static void nbench_search_first_send(struct smbsrv_request *req)
 {
-	struct nbench_private *private = ntvfs->private_data;
-	NTSTATUS status;
-
-	PASS_THRU_REQ(ntvfs, req, search_first, (ntvfs, req, io, search_private, callback));
-
+	PASS_THRU_REP_PRE(req);
+	union smb_search_first *io = req->async_states->private_data;
+	
 	switch (io->generic.level) {
 	case RAW_SEARCH_BOTH_DIRECTORY_INFO:
-		nbench_log(private, "FIND_FIRST \"%s\" %d %d %d %s\n", 
+		nbench_log(nprivates, "FIND_FIRST \"%s\" %d %d %d %s\n", 
 			   io->t2ffirst.in.pattern,
 			   io->generic.level,
 			   io->t2ffirst.in.max_count,
 			   io->t2ffirst.out.count,
-			   get_nt_error_c_code(status));
+			   get_nt_error_c_code(req->async_states->status));
 		break;
 		
 	default:
-		nbench_log(private, "Search-%d - NOT HANDLED\n", io->generic.level);
+		nbench_log(nprivates, "Search-%d - NOT HANDLED\n", io->generic.level);
 		break;
 	}
 
+	PASS_THRU_REP_POST(req);
+}
+
+static NTSTATUS nbench_search_first(struct ntvfs_module_context *ntvfs,
+				    struct smbsrv_request *req, union smb_search_first *io, 
+				    void *search_private, 
+				    BOOL (*callback)(void *, union smb_search_data *))
+{
+	NTSTATUS status;
+
+	PASS_THRU_REQ(ntvfs, req, search_first, io, (ntvfs, req, io, search_private, callback));
+
 	return status;
 }
 
 /* continue a search */
+static void nbench_search_next_send(struct smbsrv_request *req)
+{
+	PASS_THRU_REP_PRE(req);
+	union smb_search_next *io = req->async_states->private_data;
+
+	nbench_log(nprivates, "Searchnext-%d - NOT HANDLED\n", io->generic.level);
+
+	PASS_THRU_REP_POST(req);
+}
+
 static NTSTATUS nbench_search_next(struct ntvfs_module_context *ntvfs,
 				   struct smbsrv_request *req, union smb_search_next *io, 
 				   void *search_private, 
 				   BOOL (*callback)(void *, union smb_search_data *))
 {
-	struct nbench_private *private = ntvfs->private_data;
 	NTSTATUS status;
 
-	PASS_THRU_REQ(ntvfs, req, search_next, (ntvfs, req, io, search_private, callback));
-
-	nbench_log(private, "Searchnext-%d - NOT HANDLED\n", io->generic.level);
+	PASS_THRU_REQ(ntvfs, req, search_next, io, (ntvfs, req, io, search_private, callback));
 
 	return status;
 }
 
 /* close a search */
+static void nbench_search_close_send(struct smbsrv_request *req)
+{
+	PASS_THRU_REP_PRE(req);
+	union smb_search_close *io = req->async_states->private_data;
+
+	nbench_log(nprivates, "Searchclose-%d - NOT HANDLED\n", io->generic.level);
+
+	PASS_THRU_REP_POST(req);
+}
+
 static NTSTATUS nbench_search_close(struct ntvfs_module_context *ntvfs,
 				    struct smbsrv_request *req, union smb_search_close *io)
 {
-	struct nbench_private *private = ntvfs->private_data;
 	NTSTATUS status;
 
-	PASS_THRU_REQ(ntvfs, req, search_close, (ntvfs, req, io));
-
-	nbench_log(private, "Searchclose-%d - NOT HANDLED\n", io->generic.level);
+	PASS_THRU_REQ(ntvfs, req, search_close, io, (ntvfs, req, io));
 
 	return status;
 }
 
 /* SMBtrans - not used on file shares */
+static void nbench_trans_send(struct smbsrv_request *req)
+{
+	PASS_THRU_REP_PRE(req);
+
+	nbench_log(nprivates, "Trans - NOT HANDLED\n");
+
+	PASS_THRU_REP_POST(req);
+}
+
 static NTSTATUS nbench_trans(struct ntvfs_module_context *ntvfs,
 			     struct smbsrv_request *req, struct smb_trans2 *trans2)
 {
-	struct nbench_private *private = ntvfs->private_data;
 	NTSTATUS status;
 
-	PASS_THRU_REQ(ntvfs, req, trans, (ntvfs, req, trans2));
-
-	nbench_log(private, "Trans - NOT HANDLED\n");
+	PASS_THRU_REQ(ntvfs, req, trans, trans2, (ntvfs, req, trans2));
 
 	return status;
 }