summaryrefslogtreecommitdiffstats
path: root/source4/torture/nbench
diff options
context:
space:
mode:
Diffstat (limited to 'source4/torture/nbench')
-rw-r--r--source4/torture/nbench/nbench.c309
-rw-r--r--source4/torture/nbench/nbio.c994
2 files changed, 1303 insertions, 0 deletions
diff --git a/source4/torture/nbench/nbench.c b/source4/torture/nbench/nbench.c
new file mode 100644
index 0000000..05ff3ab
--- /dev/null
+++ b/source4/torture/nbench/nbench.c
@@ -0,0 +1,309 @@
+/*
+ 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 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 "libcli/libcli.h"
+#include "torture/util.h"
+#include "torture/smbtorture.h"
+#include "system/filesys.h"
+#include "system/locale.h"
+#include "lib/util/smb_strtox.h"
+
+#include "torture/nbench/proto.h"
+
+int nbench_line_count = 0;
+static int timelimit = 600;
+static int warmup;
+static const char *loadfile;
+static int read_only;
+
+#define ival(s) strtoll(s, NULL, 0)
+
+static unsigned long nb_max_retries;
+
+#define NB_RETRY(op) \
+ for (n=0;n<=nb_max_retries && !op;n++) do_reconnect(&cli, tctx, client)
+
+static void do_reconnect(struct smbcli_state **cli, struct torture_context *tctx, int client)
+{
+ int n;
+ printf("[%d] Reconnecting client %d\n", nbench_line_count, client);
+ for (n=0;n<nb_max_retries;n++) {
+ if (nb_reconnect(cli, tctx, client)) {
+ printf("[%d] Reconnected client %d\n", nbench_line_count, client);
+ return;
+ }
+ }
+ printf("[%d] Failed to reconnect client %d\n", nbench_line_count, client);
+ nb_exit(1);
+}
+
+/* run a test that simulates an approximate netbench client load */
+static bool run_netbench(struct torture_context *tctx, struct smbcli_state *cli, int client)
+{
+ int torture_nprocs = torture_setting_int(tctx, "nprocs", 4);
+ int i;
+ char line[1024];
+ char *cname;
+ FILE *f;
+ bool correct = true;
+ double target_rate = torture_setting_double(tctx, "targetrate", 0);
+ int n = 0;
+ int ret;
+
+ if (target_rate != 0 && client == 0) {
+ printf("Targeting %.4f MByte/sec\n", target_rate);
+ }
+
+ nb_setup(cli, client);
+
+ if (torture_nprocs == 1) {
+ if (!read_only) {
+ NB_RETRY(torture_setup_dir(cli, "\\clients"));
+ }
+ }
+
+ ret = asprintf(&cname, "client%d", client+1);
+ if (ret == -1) {
+ return false;
+ }
+
+ f = fopen(loadfile, "r");
+
+ if (!f) {
+ perror(loadfile);
+ return false;
+ }
+
+again:
+ nbio_time_reset();
+
+ while (fgets(line, sizeof(line)-1, f)) {
+ NTSTATUS status;
+ const char **params0, **params;
+ unsigned long int tmp;
+ int error = 0;
+
+ nbench_line_count++;
+
+ if ((strlen(line) > 0) && line[strlen(line)-1] == '\n') {
+ line[strlen(line)-1] = 0;
+ }
+
+ all_string_sub(line, "client1", cname, sizeof(line));
+
+ params = params0 = const_str_list(
+ str_list_make_shell(NULL, line, " "));
+ i = str_list_length(params);
+
+ if (i > 0 && isdigit(params[0][0])) {
+ double targett = strtod(params[0], NULL);
+ if (target_rate != 0) {
+ nbio_target_rate(target_rate);
+ } else {
+ nbio_time_delay(targett);
+ }
+ params++;
+ i--;
+ } else if (target_rate != 0) {
+ nbio_target_rate(target_rate);
+ }
+
+ if (i < 2 || params[0][0] == '#') continue;
+
+ if (!strncmp(params[0],"SMB", 3)) {
+ printf("ERROR: You are using a dbench 1 load file\n");
+ nb_exit(1);
+ }
+
+ if (strncmp(params[i-1], "NT_STATUS_", 10) != 0 &&
+ strncmp(params[i-1], "0x", 2) != 0) {
+ printf("Badly formed status at line %d\n", nbench_line_count);
+ talloc_free(params);
+ continue;
+ }
+
+ /* accept numeric or string status codes */
+ if (strncmp(params[i-1], "0x", 2) == 0) {
+ tmp = smb_strtoul(params[i-1],
+ NULL,
+ 16,
+ &error,
+ SMB_STR_STANDARD);
+ if (error != 0) {
+ tmp = error;
+ }
+ status = NT_STATUS(tmp);
+ } else {
+ 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_RETRY(nb_createx(params[1], ival(params[2]), ival(params[3]),
+ ival(params[4]), status));
+ } else if (!strcmp(params[0],"Close")) {
+ NB_RETRY(nb_close(ival(params[1]), status));
+ } else if (!read_only && !strcmp(params[0],"Rename")) {
+ NB_RETRY(nb_rename(params[1], params[2], status, n>0));
+ } else if (!read_only && !strcmp(params[0],"Unlink")) {
+ NB_RETRY(nb_unlink(params[1], ival(params[2]), status, n>0));
+ } else if (!read_only && !strcmp(params[0],"Deltree")) {
+ NB_RETRY(nb_deltree(params[1], n>0));
+ } else if (!read_only && !strcmp(params[0],"Rmdir")) {
+ NB_RETRY(nb_rmdir(params[1], status, n>0));
+ } else if (!read_only && !strcmp(params[0],"Mkdir")) {
+ NB_RETRY(nb_mkdir(params[1], status, n>0));
+ } else if (!strcmp(params[0],"QUERY_PATH_INFORMATION")) {
+ NB_RETRY(nb_qpathinfo(params[1], ival(params[2]), status));
+ } else if (!strcmp(params[0],"QUERY_FILE_INFORMATION")) {
+ NB_RETRY(nb_qfileinfo(ival(params[1]), ival(params[2]), status));
+ } else if (!strcmp(params[0],"QUERY_FS_INFORMATION")) {
+ NB_RETRY(nb_qfsinfo(ival(params[1]), status));
+ } else if (!read_only && !strcmp(params[0],"SET_FILE_INFORMATION")) {
+ NB_RETRY(nb_sfileinfo(ival(params[1]), ival(params[2]), status));
+ } else if (!strcmp(params[0],"FIND_FIRST")) {
+ NB_RETRY(nb_findfirst(params[1], ival(params[2]),
+ ival(params[3]), ival(params[4]), status));
+ } else if (!read_only && !strcmp(params[0],"WriteX")) {
+ NB_RETRY(nb_writex(ival(params[1]),
+ ival(params[2]), ival(params[3]), ival(params[4]),
+ status));
+ } else if (!read_only && !strcmp(params[0],"Write")) {
+ NB_RETRY(nb_write(ival(params[1]),
+ ival(params[2]), ival(params[3]), ival(params[4]),
+ status));
+ } else if (!strcmp(params[0],"LockX")) {
+ NB_RETRY(nb_lockx(ival(params[1]),
+ ival(params[2]), ival(params[3]), status));
+ } else if (!strcmp(params[0],"UnlockX")) {
+ NB_RETRY(nb_unlockx(ival(params[1]),
+ ival(params[2]), ival(params[3]), status));
+ } else if (!strcmp(params[0],"ReadX")) {
+ NB_RETRY(nb_readx(ival(params[1]),
+ ival(params[2]), ival(params[3]), ival(params[4]),
+ status));
+ } else if (!strcmp(params[0],"Flush")) {
+ NB_RETRY(nb_flush(ival(params[1]), status));
+ } else if (!strcmp(params[0],"Sleep")) {
+ nb_sleep(ival(params[1]), status);
+ } else {
+ printf("[%d] Unknown operation %s\n", nbench_line_count, params[0]);
+ }
+
+ if (n > nb_max_retries) {
+ printf("Maximum reconnect retries reached for op '%s'\n", params[0]);
+ nb_exit(1);
+ }
+
+ talloc_free(params0);
+
+ if (nb_tick()) goto done;
+ }
+
+ rewind(f);
+ goto again;
+
+done:
+ fclose(f);
+
+ if (!read_only && torture_nprocs == 1) {
+ smbcli_deltree(cli->tree, "\\clients");
+ }
+ if (!torture_close_connection(cli)) {
+ correct = false;
+ }
+
+ return correct;
+}
+
+
+/* run a test that simulates an approximate netbench client load */
+bool torture_nbench(struct torture_context *torture)
+{
+ bool correct = true;
+ int torture_nprocs = torture_setting_int(torture, "nprocs", 4);
+ struct smbcli_state *cli;
+ const char *p;
+
+ read_only = torture_setting_bool(torture, "readonly", false);
+
+ nb_max_retries = torture_setting_int(torture, "nretries", 1);
+
+ p = torture_setting_string(torture, "timelimit", NULL);
+ if (p && *p) {
+ timelimit = atoi(p);
+ }
+
+ warmup = timelimit / 20;
+
+ loadfile = torture_setting_string(torture, "loadfile", NULL);
+ if (!loadfile || !*loadfile) {
+ loadfile = "client.txt";
+ }
+
+ if (torture_nprocs > 1) {
+ if (!torture_open_connection(&cli, torture, 0)) {
+ return false;
+ }
+
+ if (!read_only && !torture_setup_dir(cli, "\\clients")) {
+ return false;
+ }
+ }
+
+ nbio_shmem(torture_nprocs, timelimit, warmup);
+
+ printf("Running for %d seconds with load '%s' and warmup %d secs\n",
+ timelimit, loadfile, warmup);
+
+ /* we need to reset SIGCHLD here as the name resolution
+ library may have changed it. We rely on correct signals
+ from children in the main torture code which reaps
+ children. This is why smbtorture BENCH-NBENCH was sometimes
+ failing */
+ signal(SIGCHLD, SIG_DFL);
+
+
+ signal(SIGALRM, nb_alarm);
+ alarm(1);
+ torture_create_procs(torture, run_netbench, &correct);
+ alarm(0);
+
+ if (!read_only && torture_nprocs > 1) {
+ smbcli_deltree(cli->tree, "\\clients");
+ }
+
+ printf("\nThroughput %g MB/sec\n", nbio_result());
+ return correct;
+}
+
+NTSTATUS torture_nbench_init(TALLOC_CTX *ctx)
+{
+ struct torture_suite *suite = torture_suite_create(
+ ctx, "bench");
+
+ torture_suite_add_simple_test(suite, "nbench", torture_nbench);
+
+ suite->description = talloc_strdup(suite, "Benchmarks");
+
+ torture_register_suite(ctx, suite);
+ return NT_STATUS_OK;
+}
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);
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-06-10 11:15:30 +0000