summaryrefslogtreecommitdiff
path: root/source4/torture/nbench
diff options
context:
space:
mode:
authorAndrew Tridgell <tridge@samba.org>2004-03-09 02:13:13 +0000
committerAndrew Tridgell <tridge@samba.org>2004-03-09 02:13:13 +0000
commit2d9a8bf0c93d0f4c8c02b3dfe074f59dba97009b (patch)
tree0d5dd71caf5e51d941b36ad8b8b2aaa9150c3c3e /source4/torture/nbench
parent1b71c60c36f0e2dc70b83688194c7aa3512623e2 (diff)
downloadsamba-2d9a8bf0c93d0f4c8c02b3dfe074f59dba97009b.tar.gz
samba-2d9a8bf0c93d0f4c8c02b3dfe074f59dba97009b.tar.bz2
samba-2d9a8bf0c93d0f4c8c02b3dfe074f59dba97009b.zip
greatly improved NBENCH netbench simulator
- more accurate request simulation using Samba4 raw client library - now checks for correct status on all requests - timelimit based benchmarking, default of 600 seconds (This used to be commit a46c009c0459658784d7d7b3b0502dc20958043a)
Diffstat (limited to 'source4/torture/nbench')
-rw-r--r--source4/torture/nbench/nbench.c192
-rw-r--r--source4/torture/nbench/nbio.c579
2 files changed, 771 insertions, 0 deletions
diff --git a/source4/torture/nbench/nbench.c b/source4/torture/nbench/nbench.c
new file mode 100644
index 0000000000..6b0e78e1ab
--- /dev/null
+++ b/source4/torture/nbench/nbench.c
@@ -0,0 +1,192 @@
+/*
+ Unix SMB/CIFS implementation.
+ SMB torture tester - NBENCH test
+ Copyright (C) Andrew Tridgell 1997-2004
+
+ 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 2 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, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include "includes.h"
+
+int nbench_line_count = 0;
+static int timelimit = 300;
+static const char *loadfile;
+
+#define ival(s) strtol(s, NULL, 0)
+
+/* run a test that simulates an approximate netbench client load */
+static BOOL run_netbench(struct cli_state *cli, int client)
+{
+ int i;
+ pstring line;
+ char *cname;
+ FILE *f;
+ fstring params[20];
+ const char *p;
+ BOOL correct = True;
+
+ nb_setup(cli, client);
+
+ asprintf(&cname, "client%d", client);
+
+ f = fopen(loadfile, "r");
+
+ if (!f) {
+ perror(loadfile);
+ return False;
+ }
+
+again:
+ while (fgets(line, sizeof(line)-1, f)) {
+ NTSTATUS status;
+
+ if (end_timer() >= timelimit) {
+ goto done;
+ }
+
+ nbench_line_count++;
+
+ line[strlen(line)-1] = 0;
+
+ all_string_sub(line,"client1", cname, sizeof(line));
+
+ p = line;
+ for (i=0;
+ i<19 && next_token(&p, params[i], " ", sizeof(fstring));
+ i++) ;
+
+ params[i][0] = 0;
+
+ if (i < 2 || params[0][0] == '#') continue;
+
+ if (!strncmp(params[0],"SMB", 3)) {
+ printf("ERROR: You are using a dbench 1 load file\n");
+ exit(1);
+ }
+
+ if (strncmp(params[i-1], "NT_STATUS_", 10) != 0) {
+ printf("Badly formed status at line %d\n", nbench_line_count);
+ continue;
+ }
+
+ status = nt_status_string_to_code(params[i-1]);
+
+ DEBUG(9,("run_netbench(%d): %s %s\n", client, params[0], params[1]));
+
+ if (!strcmp(params[0],"NTCreateX")) {
+ nb_createx(params[1], ival(params[2]), ival(params[3]),
+ ival(params[4]), status);
+ } else if (!strcmp(params[0],"Close")) {
+ nb_close(ival(params[1]), status);
+ } else if (!strcmp(params[0],"Rename")) {
+ nb_rename(params[1], params[2], status);
+ } else if (!strcmp(params[0],"Unlink")) {
+ nb_unlink(params[1], ival(params[2]), status);
+ } else if (!strcmp(params[0],"Deltree")) {
+ nb_deltree(params[1]);
+ } else if (!strcmp(params[0],"Rmdir")) {
+ nb_rmdir(params[1], status);
+ } else if (!strcmp(params[0],"QUERY_PATH_INFORMATION")) {
+ nb_qpathinfo(params[1], ival(params[2]), status);
+ } else if (!strcmp(params[0],"QUERY_FILE_INFORMATION")) {
+ nb_qfileinfo(ival(params[1]), ival(params[2]), status);
+ } else if (!strcmp(params[0],"QUERY_FS_INFORMATION")) {
+ nb_qfsinfo(ival(params[1]), status);
+ } else if (!strcmp(params[0],"SET_FILE_INFORMATION")) {
+ nb_sfileinfo(ival(params[1]), ival(params[2]), status);
+ } else if (!strcmp(params[0],"FIND_FIRST")) {
+ nb_findfirst(params[1], ival(params[2]),
+ ival(params[3]), ival(params[4]), status);
+ } else if (!strcmp(params[0],"WriteX")) {
+ nb_writex(ival(params[1]),
+ ival(params[2]), ival(params[3]), ival(params[4]),
+ status);
+ } else if (!strcmp(params[0],"Write")) {
+ nb_write(ival(params[1]),
+ ival(params[2]), ival(params[3]), ival(params[4]),
+ status);
+ } else if (!strcmp(params[0],"LockX")) {
+ nb_lockx(ival(params[1]),
+ ival(params[2]), ival(params[3]), status);
+ } else if (!strcmp(params[0],"UnlockX")) {
+ nb_unlockx(ival(params[1]),
+ ival(params[2]), ival(params[3]), status);
+ } else if (!strcmp(params[0],"ReadX")) {
+ nb_readx(ival(params[1]),
+ ival(params[2]), ival(params[3]), ival(params[4]),
+ status);
+ } else if (!strcmp(params[0],"Flush")) {
+ nb_flush(ival(params[1]), status);
+ } else {
+ printf("[%d] Unknown operation %s\n", nbench_line_count, params[0]);
+ }
+ }
+
+ rewind(f);
+ goto again;
+
+done:
+ fclose(f);
+ nb_cleanup(cname);
+
+ if (!torture_close_connection(cli)) {
+ correct = False;
+ }
+
+ return correct;
+}
+
+
+/* run a test that simulates an approximate netbench client load */
+BOOL torture_nbench(int dummy)
+{
+ double t;
+ BOOL correct = True;
+ extern int torture_nprocs;
+ struct cli_state *cli;
+ char *p;
+
+ p = lp_parm_string(-1, "torture", "timelimit");
+ if (p && *p) {
+ timelimit = atoi(p);
+ }
+
+ loadfile = lp_parm_string(-1, "torture", "loadfile");
+ if (!loadfile || !*loadfile) {
+ loadfile = "client.txt";
+ }
+
+ if (!torture_open_connection(&cli)) {
+ return False;
+ }
+
+ nb_setup(cli, -1);
+ nb_deltree("\\clients");
+
+ nbio_shmem(torture_nprocs);
+
+ printf("Running for %d seconds with load '%s'\n", timelimit, loadfile);
+
+ signal(SIGALRM, SIGNAL_CAST nb_alarm);
+ alarm(1);
+ t = torture_create_procs(run_netbench, &correct);
+ alarm(0);
+
+ printf("\nThroughput %g MB/sec\n",
+ 1.0e-6 * nbio_total() / t);
+ return correct;
+}
+
+
diff --git a/source4/torture/nbench/nbio.c b/source4/torture/nbench/nbio.c
new file mode 100644
index 0000000000..819383b7d8
--- /dev/null
+++ b/source4/torture/nbench/nbio.c
@@ -0,0 +1,579 @@
+#define NBDEBUG 0
+
+/*
+ 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 2 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, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include "includes.h"
+
+#define MAX_FILES 1000
+
+extern int nbench_line_count;
+static int nbio_id;
+static int nprocs;
+static BOOL bypass_io;
+
+static struct {
+ int fd;
+ int handle;
+} ftable[MAX_FILES];
+
+static struct {
+ double bytes_in, bytes_out;
+ int line;
+ int done;
+} *children;
+
+double nbio_total(void)
+{
+ int i;
+ double total = 0;
+ for (i=0;i<nprocs;i++) {
+ total += children[i].bytes_out + children[i].bytes_in;
+ }
+ return total;
+}
+
+void nb_alarm(void)
+{
+ int i;
+ int lines=0, num_clients=0;
+ double t;
+
+ if (nbio_id != -1) return;
+
+ for (i=0;i<nprocs;i++) {
+ lines += children[i].line;
+ if (!children[i].done) num_clients++;
+ }
+
+ t = end_timer();
+
+ printf("%4d %8d %.2f MB/sec t=%.0f \r",
+ num_clients, lines/nprocs,
+ 1.0e-6 * nbio_total() / t,
+ t);
+
+ signal(SIGALRM, nb_alarm);
+ alarm(1);
+}
+
+void nbio_shmem(int n)
+{
+ nprocs = n;
+ children = shm_setup(sizeof(*children) * nprocs);
+ if (!children) {
+ printf("Failed to setup shared memory!\n");
+ exit(1);
+ }
+}
+
+static int find_handle(int handle)
+{
+ int i;
+ children[nbio_id].line = nbench_line_count;
+ for (i=0;i<MAX_FILES;i++) {
+ if (ftable[i].handle == handle) return i;
+ }
+ printf("(%d) ERROR: handle %d was not found\n",
+ nbench_line_count, handle);
+ exit(1);
+
+ return -1; /* Not reached */
+}
+
+
+static struct cli_state *c;
+
+void nb_setup(struct cli_state *cli, int id)
+{
+ nbio_id = id;
+ c = cli;
+ start_timer();
+ if (children) {
+ children[nbio_id].done = 0;
+ }
+ if (bypass_io)
+ printf("skipping I/O\n");
+}
+
+
+static void check_status(const char *op, NTSTATUS status, NTSTATUS ret)
+{
+ 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));
+ 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));
+ 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));
+ }
+}
+
+
+void nb_unlink(const char *fname, int attr, NTSTATUS status)
+{
+ struct smb_unlink io;
+ NTSTATUS ret;
+
+ io.in.pattern = fname;
+
+ io.in.attrib = FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
+ if (strchr(fname, '*') == 0) {
+ io.in.attrib |= FILE_ATTRIBUTE_DIRECTORY;
+ }
+
+ ret = smb_raw_unlink(c->tree, &io);
+
+ check_status("Unlink", status, ret);
+}
+
+
+void nb_createx(const char *fname,
+ unsigned create_options, unsigned create_disposition, int handle,
+ NTSTATUS status)
+{
+ union smb_open io;
+ int i;
+ uint32 desired_access;
+ NTSTATUS ret;
+ TALLOC_CTX *mem_ctx;
+
+ mem_ctx = talloc_init("raw_open");
+
+ if (create_options & NTCREATEX_OPTIONS_DIRECTORY) {
+ desired_access = SA_RIGHT_FILE_READ_DATA;
+ } else {
+ desired_access =
+ SA_RIGHT_FILE_READ_DATA |
+ SA_RIGHT_FILE_WRITE_DATA |
+ SA_RIGHT_FILE_READ_ATTRIBUTES |
+ SA_RIGHT_FILE_WRITE_ATTRIBUTES;
+ }
+
+ io.ntcreatex.level = RAW_OPEN_NTCREATEX;
+ io.ntcreatex.in.flags = 0;
+ io.ntcreatex.in.root_fid = 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;
+
+ ret = smb_raw_open(c->tree, mem_ctx, &io);
+
+ talloc_destroy(mem_ctx);
+
+ check_status("NTCreateX", status, ret);
+
+ if (!NT_STATUS_IS_OK(ret)) return;
+
+ for (i=0;i<MAX_FILES;i++) {
+ if (ftable[i].handle == 0) break;
+ }
+ if (i == MAX_FILES) {
+ printf("(%d) file table full for %s\n", nbench_line_count,
+ fname);
+ exit(1);
+ }
+ ftable[i].handle = handle;
+ ftable[i].fd = io.ntcreatex.out.fnum;
+}
+
+void nb_writex(int handle, int offset, int size, int ret_size, NTSTATUS status)
+{
+ union smb_write io;
+ int i;
+ NTSTATUS ret;
+ char *buf;
+
+ i = find_handle(handle);
+
+ if (bypass_io) return;
+
+ buf = malloc(size);
+ memset(buf, 0xab, size);
+
+ io.writex.level = RAW_WRITE_WRITEX;
+ io.writex.in.fnum = ftable[i].fd;
+ 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);
+
+ check_status("WriteX", status, ret);
+
+ if (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_out += ret_size;
+}
+
+
+void nb_write(int handle, int offset, int size, int ret_size, NTSTATUS status)
+{
+ union smb_write io;
+ int i;
+ NTSTATUS ret;
+ char *buf;
+
+ i = find_handle(handle);
+
+ if (bypass_io) return;
+
+ buf = malloc(size);
+
+ memset(buf, 0x12, size);
+
+ io.write.level = RAW_WRITE_WRITE;
+ io.write.in.fnum = ftable[i].fd;
+ 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);
+
+ check_status("Write", status, ret);
+
+ if (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_out += ret_size;
+}
+
+
+void nb_lockx(int handle, unsigned offset, int size, NTSTATUS status)
+{
+ union smb_lock io;
+ int i;
+ NTSTATUS ret;
+ struct smb_lock_entry lck;
+
+ i = find_handle(handle);
+
+ lck.pid = getpid();
+ lck.offset = offset;
+ lck.count = size;
+
+ io.lockx.level = RAW_LOCK_LOCKX;
+ io.lockx.in.fnum = ftable[i].fd;
+ 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);
+
+ check_status("LockX", status, ret);
+}
+
+void nb_unlockx(int handle, unsigned offset, int size, NTSTATUS status)
+{
+ union smb_lock io;
+ int i;
+ NTSTATUS ret;
+ struct smb_lock_entry lck;
+
+ i = find_handle(handle);
+
+ lck.pid = getpid();
+ lck.offset = offset;
+ lck.count = size;
+
+ io.lockx.level = RAW_LOCK_LOCKX;
+ io.lockx.in.fnum = ftable[i].fd;
+ 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);
+
+ check_status("UnlockX", status, ret);
+}
+
+void nb_readx(int handle, int offset, int size, int ret_size, NTSTATUS status)
+{
+ union smb_read io;
+ int i;
+ NTSTATUS ret;
+ char *buf;
+
+ i = find_handle(handle);
+
+ if (bypass_io) return;
+
+ buf = malloc(size);
+
+ io.readx.level = RAW_READ_READX;
+ io.readx.in.fnum = ftable[i].fd;
+ io.readx.in.offset = offset;
+ io.readx.in.mincnt = size;
+ io.readx.in.maxcnt = size;
+ io.readx.in.remaining = 0;
+ io.readx.out.data = buf;
+
+ ret = smb_raw_read(c->tree, &io);
+
+ free(buf);
+
+ check_status("ReadX", status, ret);
+
+ if (io.readx.out.nread != ret_size) {
+ printf("[%d] Warning: ReadX got count %d expected %d\n",
+ nbench_line_count,
+ io.readx.out.nread, ret_size);
+ }
+
+ children[nbio_id].bytes_in += ret_size;
+}
+
+void nb_close(int handle, NTSTATUS status)
+{
+ int i;
+ NTSTATUS ret;
+ union smb_close io;
+
+ i = find_handle(handle);
+
+ io.close.level = RAW_CLOSE_CLOSE;
+ io.close.in.fnum = ftable[i].fd;
+ io.close.in.write_time = 0;
+
+ ret = smb_raw_close(c->tree, &io);
+
+ check_status("Close", status, ret);
+
+ if (NT_STATUS_IS_OK(ret)) {
+ ftable[i].handle = 0;
+ }
+}
+
+void nb_rmdir(const char *dname, NTSTATUS status)
+{
+ NTSTATUS ret;
+ struct smb_rmdir io;
+
+ io.in.path = dname;
+
+ ret = smb_raw_rmdir(c->tree, &io);
+
+ check_status("Rmdir", status, ret);
+}
+
+void nb_rename(const char *old, const char *new, NTSTATUS status)
+{
+ 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 = old;
+ io.rename.in.pattern2 = new;
+
+ ret = smb_raw_rename(c->tree, &io);
+
+ check_status("Rename", status, ret);
+}
+
+
+void 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.fname = fname;
+
+ ret = smb_raw_pathinfo(c->tree, mem_ctx, &io);
+
+ talloc_destroy(mem_ctx);
+
+ check_status("Pathinfo", status, ret);
+}
+
+
+void nb_qfileinfo(int fnum, int level, NTSTATUS status)
+{
+ union smb_fileinfo io;
+ TALLOC_CTX *mem_ctx;
+ NTSTATUS ret;
+ int i;
+
+ i = find_handle(fnum);
+
+ mem_ctx = talloc_init("nb_qfileinfo");
+
+ io.generic.level = level;
+ io.generic.in.fnum = ftable[i].fd;
+
+ ret = smb_raw_fileinfo(c->tree, mem_ctx, &io);
+
+ talloc_destroy(mem_ctx);
+
+ check_status("Fileinfo", status, ret);
+}
+
+void 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;
+ }
+
+ ZERO_STRUCT(io);
+
+ i = find_handle(fnum);
+
+ io.generic.level = level;
+ io.generic.file.fnum = ftable[i].fd;
+ 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);
+
+ check_status("Setfileinfo", status, ret);
+}
+
+void nb_qfsinfo(int level, NTSTATUS status)
+{
+ union smb_fsinfo io;
+ TALLOC_CTX *mem_ctx;
+ NTSTATUS ret;
+
+ mem_ctx = talloc_init("cli_dskattr");
+
+ io.generic.level = level;
+ ret = smb_raw_fsinfo(c->tree, mem_ctx, &io);
+
+ talloc_destroy(mem_ctx);
+
+ check_status("Fsinfo", status, ret);
+}
+
+/* callback function used for trans2 search */
+static BOOL findfirst_callback(void *private, union smb_search_data *file)
+{
+ return True;
+}
+
+void 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("cli_dskattr");
+
+ io.t2ffirst.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_destroy(mem_ctx);
+
+ check_status("Search", status, ret);
+
+ if (io.t2ffirst.out.count != count) {
+ printf("[%d] Warning: got count %d expected %d\n",
+ nbench_line_count,
+ io.t2ffirst.out.count, count);
+ }
+}
+
+void nb_flush(int fnum, NTSTATUS status)
+{
+ struct smb_flush io;
+ NTSTATUS ret;
+ int i;
+ i = find_handle(fnum);
+
+ io.in.fnum = ftable[i].fd;
+
+ ret = smb_raw_flush(c->tree, &io);
+
+ check_status("Flush", status, ret);
+}
+
+void nb_deltree(const char *dname)
+{
+ int total_deleted;
+
+ total_deleted = cli_deltree(c->tree, dname);
+
+ if (total_deleted == -1) {
+ printf("Failed to cleanup tree %s - exiting\n", dname);
+ exit(1);
+ }
+
+ cli_rmdir(c->tree, dname);
+}
+
+void nb_cleanup(const char *cname)
+{
+ char *dname = NULL;
+ smb_raw_exit(c->session);
+ asprintf(&dname, "\\clients\\%s", cname);
+ nb_deltree(dname);
+ free(dname);
+ cli_rmdir(c->tree, "clients");
+ children[nbio_id].done = 1;
+}