From 2d9a8bf0c93d0f4c8c02b3dfe074f59dba97009b Mon Sep 17 00:00:00 2001 From: Andrew Tridgell Date: Tue, 9 Mar 2004 02:13:13 +0000 Subject: 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) --- source4/torture/nbench/nbench.c | 192 +++++++++++++ source4/torture/nbench/nbio.c | 579 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 771 insertions(+) create mode 100644 source4/torture/nbench/nbench.c create mode 100644 source4/torture/nbench/nbio.c (limited to 'source4/torture/nbench') 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;itree, &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;itree, &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; +} -- cgit