Adding upstream version 2:4.17.12+dfsg.upstream/2%4.17.12+dfsgupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 994 insertions, 0 deletions

diff --git a/source4/torture/nbench/nbio.c b/source4/torture/nbench/nbio.c
new file mode 100644
index 0000000..1de988e
--- /dev/null
+++ b/source4/torture/nbench/nbio.c
@@ -0,0 +1,994 @@
+/*
+  TODO: add splitting of writes for servers with signing
+*/
+
+
+/* 
+   Unix SMB/CIFS implementation.
+   SMB torture tester
+   Copyright (C) Andrew Tridgell 1997-1998
+   
+   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"
+#include "system/time.h"
+#include "system/filesys.h"
+#include "../lib/util/dlinklist.h"
+#include "libcli/libcli.h"
+#include "torture/util.h"
+#include "torture/nbench/proto.h"
+
+extern int nbench_line_count;
+static int nbio_id = -1;
+static int nprocs;
+static bool bypass_io;
+static struct timeval tv_start, tv_end;
+static int warmup, timelimit;
+static int in_cleanup;
+
+struct lock_info {
+	struct lock_info *next, *prev;
+	off_t offset;
+	int size;
+};
+
+struct createx_params {
+	char *fname;
+	unsigned int create_options;
+	unsigned int create_disposition;
+	int handle;
+};
+
+struct ftable {
+	struct ftable *next, *prev;
+	int fd;     /* the fd that we got back from the server */
+	int handle; /* the handle in the load file */
+	struct createx_params cp;
+	struct lock_info *locks;
+};
+
+static struct ftable *ftable;
+
+static struct {
+	double bytes, warmup_bytes;
+	int line;
+	int done;
+	bool connected;
+	double max_latency;
+	struct timeval starttime;
+} *children;
+
+static bool nb_do_createx(struct ftable *f,
+			  const char *fname,
+			  unsigned int create_options,
+			  unsigned int create_disposition,
+			  int handle,
+			  NTSTATUS status,
+			  bool retry);
+
+static bool nb_do_lockx(bool relock, int handle, off_t offset, int size, NTSTATUS status);
+
+static void nb_set_createx_params(struct ftable *f,
+				  const char *fname,
+				  unsigned int create_options,
+				  unsigned int create_disposition,
+				  int handle)
+{
+	struct createx_params *cp = &f->cp;
+
+	if (fname != NULL) {
+		cp->fname = talloc_strdup(f, fname);
+		if (cp->fname == NULL) {
+			perror("nb_set_createx_params: strdup");
+			nb_exit(1);
+		}
+	} else {
+		cp->fname = NULL;
+	}
+
+	cp->create_options = create_options;
+	cp->create_disposition = create_disposition;
+	cp->handle = handle;
+}
+
+static bool nb_reestablish_locks(struct ftable *f)
+{
+	struct lock_info *linfo = f->locks;
+
+	while (linfo != NULL) {
+		DEBUG(1,("nb_reestablish_locks: lock for file %d at %lu\n",
+			 f->handle, (unsigned long) linfo->offset));
+
+		if (!nb_do_lockx(true, f->handle, linfo->offset, linfo->size, NT_STATUS_OK)) {
+			printf("nb_reestablish_locks: failed to get lock for file %s at %lu\n",
+			       f->cp.fname, (unsigned long) linfo->offset);
+			return false;
+		}
+
+		linfo = linfo->next;
+	}
+
+	return true;
+}
+
+static bool nb_reopen_all_files(void)
+{
+	struct ftable *f = ftable;
+
+	while (f != NULL) {
+		DEBUG(1,("-- nb_reopen_all_files: opening %s (handle %d)\n",
+			 f->cp.fname, f->cp.handle));
+
+		if (!nb_do_createx(f,
+				   f->cp.fname,
+				   f->cp.create_options,
+				   f->cp.create_disposition,
+				   f->cp.handle,
+				   NT_STATUS_OK,
+				   true))
+		{
+			printf("-- nb_reopen_all_files: failed to open file %s\n", f->cp.fname);
+			return false;
+		}
+
+		if (!nb_reestablish_locks(f)) {
+			printf("--nb_reopen_all_files: failed to reestablish locks\n");
+			return false;
+		}
+
+		f = f->next;
+	}
+
+	return true;
+}
+
+bool nb_reconnect(struct smbcli_state **cli, struct torture_context *tctx, int client)
+{
+	children[client].connected = false;
+
+	if (*cli != NULL) {
+		talloc_free(*cli);
+	}
+
+	if (!torture_open_connection(cli, tctx, client)) {
+		printf("nb_reconnect: failed to connect\n");
+		*cli = NULL;
+		return false;
+	}
+
+	nb_setup(*cli, client);
+
+	if (!nb_reopen_all_files()) {
+		printf("nb_reconnect: failed to reopen files in client %d\n", client);
+		return false;
+	}
+
+	return true;
+}
+
+void nbio_target_rate(double rate)
+{
+	static double last_bytes;
+	static struct timeval last_time;
+	double tdelay;
+
+	if (last_bytes == 0) {
+		last_bytes = children[nbio_id].bytes;
+		last_time = timeval_current();
+		return;
+	}
+
+	tdelay = (children[nbio_id].bytes - last_bytes)/(1.0e6*rate) - timeval_elapsed(&last_time);
+	if (tdelay > 0) {
+		smb_msleep(tdelay*1000);
+	} else {
+		children[nbio_id].max_latency = MAX(children[nbio_id].max_latency, -tdelay);
+	}
+
+	last_time = timeval_current();
+	last_bytes = children[nbio_id].bytes;
+}
+
+void nbio_time_reset(void)
+{
+	children[nbio_id].starttime = timeval_current();	
+}
+
+void nbio_time_delay(double targett)
+{
+	double elapsed = timeval_elapsed(&children[nbio_id].starttime);
+	if (targett > elapsed) {
+		smb_msleep(1000*(targett - elapsed));
+	} else if (elapsed - targett > children[nbio_id].max_latency) {
+		children[nbio_id].max_latency = MAX(elapsed - targett, children[nbio_id].max_latency);
+	}
+}
+
+double nbio_result(void)
+{
+	int i;
+	double total = 0;
+	for (i=0;i<nprocs;i++) {
+		total += children[i].bytes - children[i].warmup_bytes;
+	}
+	return 1.0e-6 * total / timeval_elapsed2(&tv_start, &tv_end);
+}
+
+double nbio_latency(void)
+{
+	int i;
+	double max_latency = 0;
+	for (i=0;i<nprocs;i++) {
+		if (children[i].max_latency > max_latency) {
+			max_latency = children[i].max_latency;
+			children[i].max_latency = 0;
+		}
+	}
+	return max_latency;
+}
+
+bool nb_tick(void)
+{
+	return children[nbio_id].done;
+}
+
+
+void nb_alarm(int sig)
+{
+	int i;
+	int lines=0;
+	double t;
+	int in_warmup = 0;
+	int num_connected = 0;
+
+	if (nbio_id != -1) return;
+
+	for (i=0;i<nprocs;i++) {
+		if (children[i].connected) {
+			num_connected++;
+		}
+		if (children[i].bytes == 0) {
+			in_warmup = 1;
+		}
+		lines += children[i].line;
+	}
+
+	t = timeval_elapsed(&tv_start);
+
+	if (!in_warmup && warmup>0 && t > warmup) {
+		tv_start = timeval_current();
+		warmup = 0;
+		for (i=0;i<nprocs;i++) {
+			children[i].warmup_bytes = children[i].bytes;
+		}
+		goto next;
+	}
+	if (t < warmup) {
+		in_warmup = 1;
+	} else if (!in_warmup && !in_cleanup && t > timelimit) {
+		for (i=0;i<nprocs;i++) {
+			children[i].done = 1;
+		}
+		tv_end = timeval_current();
+		in_cleanup = 1;
+	}
+	if (t < 1) {
+		goto next;
+	}
+	if (!in_cleanup) {
+		tv_end = timeval_current();
+	}
+
+	if (in_warmup) {
+		printf("%4d  %8d  %.2f MB/sec  warmup %.0f sec   \n", 
+		       num_connected, lines/nprocs, 
+		       nbio_result(), t);
+	} else if (in_cleanup) {
+		printf("%4d  %8d  %.2f MB/sec  cleanup %.0f sec   \n", 
+		       num_connected, lines/nprocs, 
+		       nbio_result(), t);
+	} else {
+		printf("%4d  %8d  %.2f MB/sec  execute %.0f sec  latency %.2f msec \n", 
+		       num_connected, lines/nprocs, 
+		       nbio_result(), t, nbio_latency() * 1.0e3);
+	}
+
+	fflush(stdout);
+next:
+	signal(SIGALRM, nb_alarm);
+	alarm(1);	
+}
+
+void nbio_shmem(int n, int t_timelimit, int t_warmup)
+{
+	nprocs = n;
+	children = anonymous_shared_allocate(sizeof(*children) * nprocs);
+	if (!children) {
+		printf("Failed to setup shared memory!\n");
+		nb_exit(1);
+	}
+	memset(children, 0, sizeof(*children) * nprocs);
+	timelimit = t_timelimit;
+	warmup = t_warmup;
+	in_cleanup = 0;
+	tv_start = timeval_current();
+}
+
+static struct lock_info* find_lock(struct lock_info *linfo, off_t offset, int size)
+{
+	while (linfo != NULL) {
+		if (linfo->offset == offset &&
+		    linfo->size == size)
+		{
+			return linfo;
+		}
+
+		linfo = linfo->next;
+	}
+
+	return NULL;
+}
+
+static struct ftable *find_ftable(int handle)
+{
+	struct ftable *f;
+
+	for (f=ftable;f;f=f->next) {
+		if (f->handle == handle) return f;
+	}
+	return NULL;
+}
+
+static int find_handle(int handle, struct ftable **f_ret)
+{
+	struct ftable *f;
+
+	if (f_ret != NULL)
+		*f_ret = NULL;
+
+	children[nbio_id].line = nbench_line_count;
+
+	f = find_ftable(handle);
+	if (f) {
+		if (f_ret != NULL)
+			*f_ret = f;
+		return f->fd;
+	}
+	printf("(%d) ERROR: handle %d was not found\n", 
+	       nbench_line_count, handle);
+	nb_exit(1);
+
+	return -1;		/* Not reached */
+}
+
+
+
+static struct smbcli_state *c;
+
+/*
+  a handler function for oplock break requests
+*/
+static bool oplock_handler(struct smbcli_transport *transport, uint16_t tid, 
+			   uint16_t fnum, uint8_t level, void *private_data)
+{
+	struct smbcli_tree *tree = (struct smbcli_tree *)private_data;
+	return smbcli_oplock_ack(tree, fnum, OPLOCK_BREAK_TO_NONE);
+}
+
+void nb_setup(struct smbcli_state *cli, int id)
+{
+	nbio_id = id;
+	c = cli;
+	if (bypass_io)
+		printf("skipping I/O\n");
+
+	if (cli) {
+		smbcli_oplock_handler(cli->transport, oplock_handler, cli->tree);
+	}
+
+	children[id].connected = true;
+}
+
+
+static bool check_status(const char *op, NTSTATUS status, NTSTATUS ret)
+{
+	if ((NT_STATUS_EQUAL(ret, NT_STATUS_END_OF_FILE) ||
+	     NT_STATUS_EQUAL(ret, NT_STATUS_NET_WRITE_FAULT) ||
+	     NT_STATUS_EQUAL(ret, NT_STATUS_CONNECTION_RESET)) 
+		&& !NT_STATUS_EQUAL (status, ret))
+	{
+		return false;
+	}
+
+	if (!NT_STATUS_IS_OK(status) && NT_STATUS_IS_OK(ret)) {
+		printf("[%d] Error: %s should have failed with %s\n", 
+		       nbench_line_count, op, nt_errstr(status));
+		nb_exit(1);
+	}
+
+	if (NT_STATUS_IS_OK(status) && !NT_STATUS_IS_OK(ret)) {
+		printf("[%d] Error: %s should have succeeded - %s\n", 
+		       nbench_line_count, op, nt_errstr(ret));
+		nb_exit(1);
+	}
+
+	if (!NT_STATUS_EQUAL(status, ret)) {
+		printf("[%d] Warning: got status %s but expected %s\n",
+		       nbench_line_count, nt_errstr(ret), nt_errstr(status));
+	}
+
+	return true;
+}
+
+
+bool nb_unlink(const char *fname, int attr, NTSTATUS status, bool retry)
+{
+	union smb_unlink io;
+	NTSTATUS ret;
+
+	io.unlink.in.pattern = fname;
+
+	io.unlink.in.attrib = FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
+	if (strchr(fname, '*') == 0) {
+		io.unlink.in.attrib |= FILE_ATTRIBUTE_DIRECTORY;
+	}
+
+	ret = smb_raw_unlink(c->tree, &io);
+
+	if (!retry)
+		return check_status("Unlink", status, ret);
+
+	return true;
+}
+
+static bool nb_do_createx(struct ftable *f,
+			  const char *fname,
+			  unsigned int create_options,
+			  unsigned int create_disposition,
+			  int handle,
+			  NTSTATUS status,
+			  bool retry)
+{
+	union smb_open io;	
+	uint32_t desired_access;
+	NTSTATUS ret;
+	TALLOC_CTX *mem_ctx;
+	unsigned int flags = 0;
+
+	mem_ctx = talloc_init("raw_open");
+
+	if (create_options & NTCREATEX_OPTIONS_DIRECTORY) {
+		desired_access = SEC_FILE_READ_DATA;
+	} else {
+		desired_access = 
+			SEC_FILE_READ_DATA | 
+			SEC_FILE_WRITE_DATA |
+			SEC_FILE_READ_ATTRIBUTE |
+			SEC_FILE_WRITE_ATTRIBUTE;
+		flags = NTCREATEX_FLAGS_EXTENDED |
+			NTCREATEX_FLAGS_REQUEST_OPLOCK | 
+			NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
+	}
+
+	io.ntcreatex.level = RAW_OPEN_NTCREATEX;
+	io.ntcreatex.in.flags = flags;
+	io.ntcreatex.in.root_fid.fnum = 0;
+	io.ntcreatex.in.access_mask = desired_access;
+	io.ntcreatex.in.file_attr = 0;
+	io.ntcreatex.in.alloc_size = 0;
+	io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ|NTCREATEX_SHARE_ACCESS_WRITE;
+	io.ntcreatex.in.open_disposition = create_disposition;
+	io.ntcreatex.in.create_options = create_options;
+	io.ntcreatex.in.impersonation = 0;
+	io.ntcreatex.in.security_flags = 0;
+	io.ntcreatex.in.fname = fname;
+
+	if (retry) {
+		/* Reopening after a disconnect. */
+		io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
+	} else
+	if (f != NULL &&
+	    f->cp.create_disposition == NTCREATEX_DISP_CREATE &&
+	    NT_STATUS_IS_OK(status))
+	{
+		/* Reopening after nb_createx() error. */
+		io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
+	}
+
+	ret = smb_raw_open(c->tree, mem_ctx, &io);
+
+	talloc_free(mem_ctx);
+
+	if (!check_status("NTCreateX", status, ret))
+		return false;
+
+	if (!NT_STATUS_IS_OK(ret))
+		return true;
+
+	if (f == NULL) {
+		f = talloc (NULL, struct ftable);
+		f->locks = NULL;
+		nb_set_createx_params(f, fname, create_options, create_disposition, handle);
+		DLIST_ADD_END(ftable, f);
+	}
+
+	f->handle = handle;
+	f->fd = io.ntcreatex.out.file.fnum;
+
+	return true;
+}
+
+bool nb_createx(const char *fname, 
+	       unsigned int create_options, unsigned int create_disposition, int handle,
+	       NTSTATUS status)
+{
+	return nb_do_createx(NULL, fname, create_options, create_disposition, handle, status, false);
+}
+
+bool nb_writex(int handle, off_t offset, int size, int ret_size, NTSTATUS status)
+{
+	union smb_write io;
+	int i;
+	NTSTATUS ret;
+	uint8_t *buf;
+
+	i = find_handle(handle, NULL);
+
+	if (bypass_io)
+		return true;
+
+	buf = malloc(size);
+	memset(buf, 0xab, size);
+
+	io.writex.level = RAW_WRITE_WRITEX;
+	io.writex.in.file.fnum = i;
+	io.writex.in.wmode = 0;
+	io.writex.in.remaining = 0;
+	io.writex.in.offset = offset;
+	io.writex.in.count = size;
+	io.writex.in.data = buf;
+
+	ret = smb_raw_write(c->tree, &io);
+
+	free(buf);
+
+	if (!check_status("WriteX", status, ret))
+		return false;
+
+	if (NT_STATUS_IS_OK(ret) && io.writex.out.nwritten != ret_size) {
+		printf("[%d] Warning: WriteX got count %d expected %d\n", 
+		       nbench_line_count,
+		       io.writex.out.nwritten, ret_size);
+	}	
+
+	children[nbio_id].bytes += ret_size;
+
+	return true;
+}
+
+bool nb_write(int handle, off_t offset, int size, int ret_size, NTSTATUS status)
+{
+	union smb_write io;
+	int i;
+	NTSTATUS ret;
+	uint8_t *buf;
+
+	i = find_handle(handle, NULL);
+
+	if (bypass_io)
+		return true;
+
+	buf = malloc(size);
+
+	memset(buf, 0x12, size);
+
+	io.write.level = RAW_WRITE_WRITE;
+	io.write.in.file.fnum = i;
+	io.write.in.remaining = 0;
+	io.write.in.offset = offset;
+	io.write.in.count = size;
+	io.write.in.data = buf;
+
+	ret = smb_raw_write(c->tree, &io);
+
+	free(buf);
+
+	if (!check_status("Write", status, ret))
+		return false;
+
+	if (NT_STATUS_IS_OK(ret) && io.write.out.nwritten != ret_size) {
+		printf("[%d] Warning: Write got count %d expected %d\n", 
+		       nbench_line_count,
+		       io.write.out.nwritten, ret_size);
+	}	
+
+	children[nbio_id].bytes += ret_size;
+
+	return true;
+}
+
+static bool nb_do_lockx(bool relock, int handle, off_t offset, int size, NTSTATUS status)
+{
+	union smb_lock io;
+	int i;
+	NTSTATUS ret;
+	struct smb_lock_entry lck;
+	struct ftable *f;
+
+	i = find_handle(handle, &f);
+
+	lck.pid = getpid();
+	lck.offset = offset;
+	lck.count = size;
+
+	io.lockx.level = RAW_LOCK_LOCKX;
+	io.lockx.in.file.fnum = i;
+	io.lockx.in.mode = 0;
+	io.lockx.in.timeout = 0;
+	io.lockx.in.ulock_cnt = 0;
+	io.lockx.in.lock_cnt = 1;
+	io.lockx.in.locks = &lck;
+
+	ret = smb_raw_lock(c->tree, &io);
+
+	if (!check_status("LockX", status, ret))
+		return false;
+
+	if (f != NULL &&
+	    !relock)
+	{
+		struct lock_info *linfo;
+		linfo = talloc (f, struct lock_info);
+		linfo->offset = offset;
+		linfo->size = size;
+		DLIST_ADD_END(f->locks, linfo);
+	}
+
+	return true;
+}
+
+bool nb_lockx(int handle, off_t offset, int size, NTSTATUS status)
+{
+	return nb_do_lockx(false, handle, offset, size, status);
+}
+
+bool nb_unlockx(int handle, unsigned int offset, int size, NTSTATUS status)
+{
+	union smb_lock io;
+	int i;
+	NTSTATUS ret;
+	struct smb_lock_entry lck;
+	struct ftable *f;
+
+	i = find_handle(handle, &f);
+
+	lck.pid = getpid();
+	lck.offset = offset;
+	lck.count = size;
+
+	io.lockx.level = RAW_LOCK_LOCKX;
+	io.lockx.in.file.fnum = i;
+	io.lockx.in.mode = 0;
+	io.lockx.in.timeout = 0;
+	io.lockx.in.ulock_cnt = 1;
+	io.lockx.in.lock_cnt = 0;
+	io.lockx.in.locks = &lck;
+
+	ret = smb_raw_lock(c->tree, &io);
+
+	if (!check_status("UnlockX", status, ret))
+		return false;
+
+	if (f != NULL) {
+		struct lock_info *linfo;
+		linfo = find_lock(f->locks, offset, size);
+		if (linfo != NULL)
+			DLIST_REMOVE(f->locks, linfo);
+		else
+			printf("nb_unlockx: unknown lock (%d)\n", handle);
+	}
+
+	return true;
+}
+
+bool nb_readx(int handle, off_t offset, int size, int ret_size, NTSTATUS status)
+{
+	union smb_read io;
+	int i;
+	NTSTATUS ret;
+	uint8_t *buf;
+
+	i = find_handle(handle, NULL);
+
+	if (bypass_io)
+		return true;
+
+	buf = malloc(size);
+
+	io.readx.level = RAW_READ_READX;
+	io.readx.in.file.fnum = i;
+	io.readx.in.offset    = offset;
+	io.readx.in.mincnt    = size;
+	io.readx.in.maxcnt    = size;
+	io.readx.in.remaining = 0;
+	io.readx.in.read_for_execute = false;
+	io.readx.out.data     = buf;
+
+	ret = smb_raw_read(c->tree, &io);
+
+	free(buf);
+
+	if (!check_status("ReadX", status, ret))
+		return false;
+
+	if (NT_STATUS_IS_OK(ret) && io.readx.out.nread != ret_size) {
+		printf("[%d] ERROR: ReadX got count %d expected %d\n", 
+		       nbench_line_count,
+		       io.readx.out.nread, ret_size);
+		nb_exit(1);
+	}	
+
+	children[nbio_id].bytes += ret_size;
+
+	return true;
+}
+
+bool nb_close(int handle, NTSTATUS status)
+{
+	NTSTATUS ret;
+	union smb_close io;
+	int i;
+
+	i = find_handle(handle, NULL);
+
+	io.close.level = RAW_CLOSE_CLOSE;
+	io.close.in.file.fnum = i;
+	io.close.in.write_time = 0;
+
+	ret = smb_raw_close(c->tree, &io);
+
+	if (!check_status("Close", status, ret))
+		return false;
+
+	if (NT_STATUS_IS_OK(ret)) {
+		struct ftable *f = find_ftable(handle);
+		DLIST_REMOVE(ftable, f);
+		talloc_free(f);
+	}
+
+	return true;
+}
+
+bool nb_rmdir(const char *dname, NTSTATUS status, bool retry)
+{
+	NTSTATUS ret;
+	struct smb_rmdir io;
+
+	io.in.path = dname;
+
+	ret = smb_raw_rmdir(c->tree, &io);
+
+	if (!retry)
+		return check_status("Rmdir", status, ret);
+
+	return true;
+}
+
+bool nb_mkdir(const char *dname, NTSTATUS status, bool retry)
+{
+	union smb_mkdir io;
+
+	io.mkdir.level = RAW_MKDIR_MKDIR;
+	io.mkdir.in.path = dname;
+
+	/* NOTE! no error checking. Used for base fileset creation */
+	smb_raw_mkdir(c->tree, &io);
+
+	return true;
+}
+
+bool nb_rename(const char *o, const char *n, NTSTATUS status, bool retry)
+{
+	NTSTATUS ret;
+	union smb_rename io;
+
+	io.generic.level = RAW_RENAME_RENAME;
+	io.rename.in.attrib = FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_DIRECTORY;
+	io.rename.in.pattern1 = o;
+	io.rename.in.pattern2 = n;
+
+	ret = smb_raw_rename(c->tree, &io);
+
+	if (!retry)
+		return check_status("Rename", status, ret);
+
+	return true;
+}
+
+
+bool nb_qpathinfo(const char *fname, int level, NTSTATUS status)
+{
+	union smb_fileinfo io;
+	TALLOC_CTX *mem_ctx;
+	NTSTATUS ret;
+
+	mem_ctx = talloc_init("nb_qpathinfo");
+
+	io.generic.level = level;
+	io.generic.in.file.path = fname;
+
+	ret = smb_raw_pathinfo(c->tree, mem_ctx, &io);
+
+	talloc_free(mem_ctx);
+
+	return check_status("Pathinfo", status, ret);
+}
+
+
+bool nb_qfileinfo(int fnum, int level, NTSTATUS status)
+{
+	union smb_fileinfo io;
+	TALLOC_CTX *mem_ctx;
+	NTSTATUS ret;
+	int i;
+
+	i = find_handle(fnum, NULL);
+
+	mem_ctx = talloc_init("nb_qfileinfo");
+
+	io.generic.level = level;
+	io.generic.in.file.fnum = i;
+
+	ret = smb_raw_fileinfo(c->tree, mem_ctx, &io);
+
+	talloc_free(mem_ctx);
+
+	return check_status("Fileinfo", status, ret);
+}
+
+bool nb_sfileinfo(int fnum, int level, NTSTATUS status)
+{
+	union smb_setfileinfo io;
+	NTSTATUS ret;
+	int i;
+
+	if (level != RAW_SFILEINFO_BASIC_INFORMATION) {
+		printf("[%d] Warning: setfileinfo level %d not handled\n", nbench_line_count, level);
+		return true;
+	}
+
+	ZERO_STRUCT(io);
+
+	i = find_handle(fnum, NULL);
+
+	io.generic.level = level;
+	io.generic.in.file.fnum = i;
+	unix_to_nt_time(&io.basic_info.in.create_time, time(NULL));
+	unix_to_nt_time(&io.basic_info.in.access_time, 0);
+	unix_to_nt_time(&io.basic_info.in.write_time, 0);
+	unix_to_nt_time(&io.basic_info.in.change_time, 0);
+	io.basic_info.in.attrib = 0;
+
+	ret = smb_raw_setfileinfo(c->tree, &io);
+
+	return check_status("Setfileinfo", status, ret);
+}
+
+bool nb_qfsinfo(int level, NTSTATUS status)
+{
+	union smb_fsinfo io;
+	TALLOC_CTX *mem_ctx;
+	NTSTATUS ret;
+
+	mem_ctx = talloc_init("smbcli_dskattr");
+
+	io.generic.level = level;
+	ret = smb_raw_fsinfo(c->tree, mem_ctx, &io);
+
+	talloc_free(mem_ctx);
+	
+	return check_status("Fsinfo", status, ret);	
+}
+
+/* callback function used for trans2 search */
+static bool findfirst_callback(void *private_data, const union smb_search_data *file)
+{
+	return true;
+}
+
+bool nb_findfirst(const char *mask, int level, int maxcnt, int count, NTSTATUS status)
+{
+	union smb_search_first io;
+	TALLOC_CTX *mem_ctx;
+	NTSTATUS ret;
+
+	mem_ctx = talloc_init("smbcli_dskattr");
+
+	io.t2ffirst.level = RAW_SEARCH_TRANS2;
+	io.t2ffirst.data_level = level;
+	io.t2ffirst.in.max_count = maxcnt;
+	io.t2ffirst.in.search_attrib = FILE_ATTRIBUTE_DIRECTORY;
+	io.t2ffirst.in.pattern = mask;
+	io.t2ffirst.in.flags = FLAG_TRANS2_FIND_CLOSE;
+	io.t2ffirst.in.storage_type = 0;
+			
+	ret = smb_raw_search_first(c->tree, mem_ctx, &io, NULL, findfirst_callback);
+
+	talloc_free(mem_ctx);
+
+	if (!check_status("Search", status, ret))
+		return false;
+
+	if (NT_STATUS_IS_OK(ret) && io.t2ffirst.out.count != count) {
+		printf("[%d] Warning: got count %d expected %d\n", 
+		       nbench_line_count,
+		       io.t2ffirst.out.count, count);
+	}
+
+	return true;
+}
+
+bool nb_flush(int fnum, NTSTATUS status)
+{
+	union smb_flush io;
+	NTSTATUS ret;
+	int i;
+	i = find_handle(fnum, NULL);
+
+	io.flush.level		= RAW_FLUSH_FLUSH;
+	io.flush.in.file.fnum	= i;
+
+	ret = smb_raw_flush(c->tree, &io);
+
+	return check_status("Flush", status, ret);
+}
+
+void nb_sleep(int usec, NTSTATUS status)
+{
+	usleep(usec);
+}
+
+bool nb_deltree(const char *dname, bool retry)
+{
+	int total_deleted;
+
+	smb_raw_exit(c->session);
+
+	while (ftable) {
+		struct ftable *f = ftable;
+		DLIST_REMOVE(ftable, f);
+		talloc_free (f);
+	}
+
+	total_deleted = smbcli_deltree(c->tree, dname);
+
+	if (total_deleted == -1) {
+		printf("Failed to cleanup tree %s - exiting\n", dname);
+		nb_exit(1);
+	}
+
+	smbcli_rmdir(c->tree, dname);
+
+	return true;
+}
+
+
+void nb_exit(int status)
+{
+	children[nbio_id].connected = false;
+	printf("[%d] client %d exiting with status %d\n",
+	       nbench_line_count, nbio_id, status);
+	exit(status);
+}