*/
#include "includes.h"
+#include "system/time.h"
+#include "system/filesys.h"
+#include "dlinklist.h"
+#include "libcli/libcli.h"
+#include "libcli/raw/libcliraw.h"
+#include "torture/torture.h"
#define MAX_FILES 100
extern int nbench_line_count;
-static int nbio_id;
+static int nbio_id = -1;
static int nprocs;
static BOOL bypass_io;
-static int warmup;
+static struct timeval tv_start, tv_end;
+static int warmup, timelimit;
+static int in_cleanup;
struct ftable {
struct ftable *next, *prev;
static struct ftable *ftable;
static struct {
- double bytes_in, bytes_out;
+ double bytes, warmup_bytes;
int line;
int done;
} *children;
-double nbio_total(void)
+double nbio_result(void)
{
int i;
double total = 0;
for (i=0;i<nprocs;i++) {
- total += children[i].bytes_out + children[i].bytes_in;
+ total += children[i].bytes - children[i].warmup_bytes;
}
- return total;
+ return 1.0e-6 * total / timeval_elapsed2(&tv_start, &tv_end);
}
-void nb_warmup_done(void)
+BOOL nb_tick(void)
{
- children[nbio_id].bytes_out = 0;
- children[nbio_id].bytes_in = 0;
+ return children[nbio_id].done;
}
-void nb_alarm(void)
+void nb_alarm(int sig)
{
int i;
- int lines=0, num_clients=0;
+ int lines=0;
double t;
+ int in_warmup = 0;
if (nbio_id != -1) return;
for (i=0;i<nprocs;i++) {
+ if (children[i].bytes == 0) {
+ in_warmup = 1;
+ }
lines += children[i].line;
- if (!children[i].done) num_clients++;
}
- t = end_timer();
+ t = timeval_elapsed(&tv_start);
- if (warmup) {
+ 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_clients, lines/nprocs,
- 1.0e-6 * nbio_total() / t,
- t);
+ nprocs, lines/nprocs,
+ nbio_result(), t);
+ } else if (in_cleanup) {
+ printf("%4d %8d %.2f MB/sec cleanup %.0f sec \n",
+ nprocs, lines/nprocs,
+ nbio_result(), t);
} else {
printf("%4d %8d %.2f MB/sec execute %.0f sec \n",
- num_clients, lines/nprocs,
- 1.0e-6 * nbio_total() / t,
- t);
- }
-
- if (warmup && t >= warmup) {
- start_timer();
- warmup = 0;
+ nprocs, lines/nprocs,
+ nbio_result(), t);
}
fflush(stdout);
-
+next:
signal(SIGALRM, nb_alarm);
alarm(1);
}
-void nbio_shmem(int n)
+void nbio_shmem(int n, int t_timelimit, int t_warmup)
{
nprocs = n;
children = shm_setup(sizeof(*children) * nprocs);
printf("Failed to setup shared memory!\n");
exit(1);
}
+ memset(children, 0, sizeof(*children) * nprocs);
+ timelimit = t_timelimit;
+ warmup = t_warmup;
+ in_cleanup = 0;
+ tv_start = timeval_current();
}
static struct ftable *find_ftable(int handle)
return smbcli_oplock_ack(tree, fnum, level);
}
-void nb_setup(struct smbcli_state *cli, int id, int warmupt)
+void nb_setup(struct smbcli_state *cli, int id)
{
- warmup = warmupt;
nbio_id = id;
c = cli;
- start_timer();
- if (children) {
- children[nbio_id].done = 0;
- }
if (bypass_io)
printf("skipping I/O\n");
void nb_unlink(const char *fname, int attr, NTSTATUS status)
{
- struct smb_unlink io;
+ union smb_unlink io;
NTSTATUS ret;
- io.in.pattern = fname;
+ io.unlink.in.pattern = fname;
- io.in.attrib = FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
+ io.unlink.in.attrib = FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
if (strchr(fname, '*') == 0) {
- io.in.attrib |= FILE_ATTRIBUTE_DIRECTORY;
+ io.unlink.in.attrib |= FILE_ATTRIBUTE_DIRECTORY;
}
ret = smb_raw_unlink(c->tree, &io);
mem_ctx = talloc_init("raw_open");
if (create_options & NTCREATEX_OPTIONS_DIRECTORY) {
- desired_access = SA_RIGHT_FILE_READ_DATA;
+ desired_access = SEC_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;
+ 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;
ret = smb_raw_open(c->tree, mem_ctx, &io);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
check_status("NTCreateX", status, ret);
if (!NT_STATUS_IS_OK(ret)) return;
- f = malloc(sizeof(struct ftable));
+ f = malloc_p(struct ftable);
f->handle = handle;
- f->fd = io.ntcreatex.out.fnum;
+ f->fd = io.ntcreatex.file.fnum;
DLIST_ADD_END(ftable, f, struct ftable *);
}
union smb_write io;
int i;
NTSTATUS ret;
- char *buf;
+ uint8_t *buf;
i = find_handle(handle);
memset(buf, 0xab, size);
io.writex.level = RAW_WRITE_WRITEX;
- io.writex.in.fnum = i;
+ io.writex.file.fnum = i;
io.writex.in.wmode = 0;
io.writex.in.remaining = 0;
io.writex.in.offset = offset;
io.writex.out.nwritten, ret_size);
}
- children[nbio_id].bytes_out += ret_size;
+ children[nbio_id].bytes += 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;
+ uint8_t *buf;
i = find_handle(handle);
memset(buf, 0x12, size);
io.write.level = RAW_WRITE_WRITE;
- io.write.in.fnum = i;
+ io.write.file.fnum = i;
io.write.in.remaining = 0;
io.write.in.offset = offset;
io.write.in.count = size;
io.write.out.nwritten, ret_size);
}
- children[nbio_id].bytes_out += ret_size;
+ children[nbio_id].bytes += ret_size;
}
lck.count = size;
io.lockx.level = RAW_LOCK_LOCKX;
- io.lockx.in.fnum = i;
+ io.lockx.file.fnum = i;
io.lockx.in.mode = 0;
io.lockx.in.timeout = 0;
io.lockx.in.ulock_cnt = 0;
lck.count = size;
io.lockx.level = RAW_LOCK_LOCKX;
- io.lockx.in.fnum = i;
+ io.lockx.file.fnum = i;
io.lockx.in.mode = 0;
io.lockx.in.timeout = 0;
io.lockx.in.ulock_cnt = 1;
union smb_read io;
int i;
NTSTATUS ret;
- char *buf;
+ uint8_t *buf;
i = find_handle(handle);
buf = malloc(size);
io.readx.level = RAW_READ_READX;
- io.readx.in.fnum = i;
+ io.readx.file.fnum = i;
io.readx.in.offset = offset;
io.readx.in.mincnt = size;
io.readx.in.maxcnt = size;
exit(1);
}
- children[nbio_id].bytes_in += ret_size;
+ children[nbio_id].bytes += ret_size;
}
void nb_close(int handle, NTSTATUS status)
i = find_handle(handle);
io.close.level = RAW_CLOSE_CLOSE;
- io.close.in.fnum = i;
+ io.close.file.fnum = i;
io.close.in.write_time = 0;
ret = smb_raw_close(c->tree, &io);
mem_ctx = talloc_init("nb_qpathinfo");
io.generic.level = level;
- io.generic.in.fname = fname;
+ io.generic.file.path = fname;
ret = smb_raw_pathinfo(c->tree, mem_ctx, &io);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
check_status("Pathinfo", status, ret);
}
mem_ctx = talloc_init("nb_qfileinfo");
io.generic.level = level;
- io.generic.in.fnum = i;
+ io.generic.file.fnum = i;
ret = smb_raw_fileinfo(c->tree, mem_ctx, &io);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
check_status("Fileinfo", status, ret);
}
io.generic.level = level;
ret = smb_raw_fsinfo(c->tree, mem_ctx, &io);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
check_status("Fsinfo", status, ret);
}
ret = smb_raw_search_first(c->tree, mem_ctx, &io, NULL, findfirst_callback);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
check_status("Search", status, ret);
void nb_flush(int fnum, NTSTATUS status)
{
- struct smb_flush io;
+ union smb_flush io;
NTSTATUS ret;
int i;
i = find_handle(fnum);
- io.in.fnum = i;
+ io.flush.file.fnum = i;
ret = smb_raw_flush(c->tree, &io);
check_status("Flush", status, ret);
}
+void nb_sleep(int usec, NTSTATUS status)
+{
+ usleep(usec);
+}
+
void nb_deltree(const char *dname)
{
int total_deleted;
smbcli_rmdir(c->tree, dname);
}
-void nb_cleanup(const char *cname)
-{
- char *dname = NULL;
- asprintf(&dname, "\\clients\\%s", cname);
- nb_deltree(dname);
- free(dname);
- smbcli_rmdir(c->tree, "clients");
- children[nbio_id].done = 1;
-}
git.samba.org / jelmer / samba4-debian.git / blobdiff