4 Unix SMB/CIFS implementation.
6 Copyright (C) Andrew Tridgell 1997-1998
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 #include "system/time.h"
25 #include "system/filesys.h"
26 #include "dlinklist.h"
27 #include "libcli/libcli.h"
28 #include "libcli/raw/libcliraw.h"
29 #include "torture/torture.h"
33 extern int nbench_line_count;
34 static int nbio_id = -1;
36 static BOOL bypass_io;
37 static struct timeval tv_start, tv_end;
38 static int warmup, timelimit;
39 static int in_cleanup;
42 struct ftable *next, *prev;
43 int fd; /* the fd that we got back from the server */
44 int handle; /* the handle in the load file */
47 static struct ftable *ftable;
50 double bytes, warmup_bytes;
55 double nbio_result(void)
59 for (i=0;i<nprocs;i++) {
60 total += children[i].bytes - children[i].warmup_bytes;
62 return 1.0e-6 * total / timeval_elapsed2(&tv_start, &tv_end);
67 return children[nbio_id].done;
71 void nb_alarm(int sig)
78 if (nbio_id != -1) return;
80 for (i=0;i<nprocs;i++) {
81 if (children[i].bytes == 0) {
84 lines += children[i].line;
87 t = timeval_elapsed(&tv_start);
89 if (!in_warmup && warmup>0 && t > warmup) {
90 tv_start = timeval_current();
92 for (i=0;i<nprocs;i++) {
93 children[i].warmup_bytes = children[i].bytes;
99 } else if (!in_warmup && !in_cleanup && t > timelimit) {
100 for (i=0;i<nprocs;i++) {
101 children[i].done = 1;
103 tv_end = timeval_current();
110 tv_end = timeval_current();
114 printf("%4d %8d %.2f MB/sec warmup %.0f sec \n",
115 nprocs, lines/nprocs,
117 } else if (in_cleanup) {
118 printf("%4d %8d %.2f MB/sec cleanup %.0f sec \n",
119 nprocs, lines/nprocs,
122 printf("%4d %8d %.2f MB/sec execute %.0f sec \n",
123 nprocs, lines/nprocs,
129 signal(SIGALRM, nb_alarm);
133 void nbio_shmem(int n, int t_timelimit, int t_warmup)
136 children = shm_setup(sizeof(*children) * nprocs);
138 printf("Failed to setup shared memory!\n");
141 memset(children, 0, sizeof(*children) * nprocs);
142 timelimit = t_timelimit;
145 tv_start = timeval_current();
148 static struct ftable *find_ftable(int handle)
152 for (f=ftable;f;f=f->next) {
153 if (f->handle == handle) return f;
158 static int find_handle(int handle)
162 children[nbio_id].line = nbench_line_count;
164 f = find_ftable(handle);
168 printf("(%d) ERROR: handle %d was not found\n",
169 nbench_line_count, handle);
172 return -1; /* Not reached */
177 static struct smbcli_state *c;
180 a handler function for oplock break requests
182 static BOOL oplock_handler(struct smbcli_transport *transport, uint16_t tid, uint16_t fnum, uint8_t level, void *private)
184 struct smbcli_tree *tree = private;
185 return smbcli_oplock_ack(tree, fnum, level);
188 void nb_setup(struct smbcli_state *cli, int id)
193 printf("skipping I/O\n");
196 smbcli_oplock_handler(cli->transport, oplock_handler, cli->tree);
201 static void check_status(const char *op, NTSTATUS status, NTSTATUS ret)
203 if (!NT_STATUS_IS_OK(status) && NT_STATUS_IS_OK(ret)) {
204 printf("[%d] Error: %s should have failed with %s\n",
205 nbench_line_count, op, nt_errstr(status));
209 if (NT_STATUS_IS_OK(status) && !NT_STATUS_IS_OK(ret)) {
210 printf("[%d] Error: %s should have succeeded - %s\n",
211 nbench_line_count, op, nt_errstr(ret));
215 if (!NT_STATUS_EQUAL(status, ret)) {
216 printf("[%d] Warning: got status %s but expected %s\n",
217 nbench_line_count, nt_errstr(ret), nt_errstr(status));
222 void nb_unlink(const char *fname, int attr, NTSTATUS status)
224 struct smb_unlink io;
227 io.in.pattern = fname;
229 io.in.attrib = FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
230 if (strchr(fname, '*') == 0) {
231 io.in.attrib |= FILE_ATTRIBUTE_DIRECTORY;
234 ret = smb_raw_unlink(c->tree, &io);
236 check_status("Unlink", status, ret);
240 void nb_createx(const char *fname,
241 uint_t create_options, uint_t create_disposition, int handle,
245 uint32_t desired_access;
251 mem_ctx = talloc_init("raw_open");
253 if (create_options & NTCREATEX_OPTIONS_DIRECTORY) {
254 desired_access = SEC_FILE_READ_DATA;
258 SEC_FILE_WRITE_DATA |
259 SEC_FILE_READ_ATTRIBUTE |
260 SEC_FILE_WRITE_ATTRIBUTE;
261 flags = NTCREATEX_FLAGS_EXTENDED |
262 NTCREATEX_FLAGS_REQUEST_OPLOCK |
263 NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
266 io.ntcreatex.level = RAW_OPEN_NTCREATEX;
267 io.ntcreatex.in.flags = flags;
268 io.ntcreatex.in.root_fid = 0;
269 io.ntcreatex.in.access_mask = desired_access;
270 io.ntcreatex.in.file_attr = 0;
271 io.ntcreatex.in.alloc_size = 0;
272 io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ|NTCREATEX_SHARE_ACCESS_WRITE;
273 io.ntcreatex.in.open_disposition = create_disposition;
274 io.ntcreatex.in.create_options = create_options;
275 io.ntcreatex.in.impersonation = 0;
276 io.ntcreatex.in.security_flags = 0;
277 io.ntcreatex.in.fname = fname;
279 ret = smb_raw_open(c->tree, mem_ctx, &io);
281 talloc_free(mem_ctx);
283 check_status("NTCreateX", status, ret);
285 if (!NT_STATUS_IS_OK(ret)) return;
287 f = malloc_p(struct ftable);
289 f->fd = io.ntcreatex.out.fnum;
291 DLIST_ADD_END(ftable, f, struct ftable *);
294 void nb_writex(int handle, int offset, int size, int ret_size, NTSTATUS status)
301 i = find_handle(handle);
303 if (bypass_io) return;
306 memset(buf, 0xab, size);
308 io.writex.level = RAW_WRITE_WRITEX;
309 io.writex.in.fnum = i;
310 io.writex.in.wmode = 0;
311 io.writex.in.remaining = 0;
312 io.writex.in.offset = offset;
313 io.writex.in.count = size;
314 io.writex.in.data = buf;
316 ret = smb_raw_write(c->tree, &io);
320 check_status("WriteX", status, ret);
322 if (NT_STATUS_IS_OK(ret) && io.writex.out.nwritten != ret_size) {
323 printf("[%d] Warning: WriteX got count %d expected %d\n",
325 io.writex.out.nwritten, ret_size);
328 children[nbio_id].bytes += ret_size;
331 void nb_write(int handle, int offset, int size, int ret_size, NTSTATUS status)
338 i = find_handle(handle);
340 if (bypass_io) return;
344 memset(buf, 0x12, size);
346 io.write.level = RAW_WRITE_WRITE;
347 io.write.in.fnum = i;
348 io.write.in.remaining = 0;
349 io.write.in.offset = offset;
350 io.write.in.count = size;
351 io.write.in.data = buf;
353 ret = smb_raw_write(c->tree, &io);
357 check_status("Write", status, ret);
359 if (NT_STATUS_IS_OK(ret) && io.write.out.nwritten != ret_size) {
360 printf("[%d] Warning: Write got count %d expected %d\n",
362 io.write.out.nwritten, ret_size);
365 children[nbio_id].bytes += ret_size;
369 void nb_lockx(int handle, uint_t offset, int size, NTSTATUS status)
374 struct smb_lock_entry lck;
376 i = find_handle(handle);
382 io.lockx.level = RAW_LOCK_LOCKX;
383 io.lockx.in.fnum = i;
384 io.lockx.in.mode = 0;
385 io.lockx.in.timeout = 0;
386 io.lockx.in.ulock_cnt = 0;
387 io.lockx.in.lock_cnt = 1;
388 io.lockx.in.locks = &lck;
390 ret = smb_raw_lock(c->tree, &io);
392 check_status("LockX", status, ret);
395 void nb_unlockx(int handle, uint_t offset, int size, NTSTATUS status)
400 struct smb_lock_entry lck;
402 i = find_handle(handle);
408 io.lockx.level = RAW_LOCK_LOCKX;
409 io.lockx.in.fnum = i;
410 io.lockx.in.mode = 0;
411 io.lockx.in.timeout = 0;
412 io.lockx.in.ulock_cnt = 1;
413 io.lockx.in.lock_cnt = 0;
414 io.lockx.in.locks = &lck;
416 ret = smb_raw_lock(c->tree, &io);
418 check_status("UnlockX", status, ret);
421 void nb_readx(int handle, int offset, int size, int ret_size, NTSTATUS status)
428 i = find_handle(handle);
430 if (bypass_io) return;
434 io.readx.level = RAW_READ_READX;
435 io.readx.in.fnum = i;
436 io.readx.in.offset = offset;
437 io.readx.in.mincnt = size;
438 io.readx.in.maxcnt = size;
439 io.readx.in.remaining = 0;
440 io.readx.out.data = buf;
442 ret = smb_raw_read(c->tree, &io);
446 check_status("ReadX", status, ret);
448 if (NT_STATUS_IS_OK(ret) && io.readx.out.nread != ret_size) {
449 printf("[%d] ERROR: ReadX got count %d expected %d\n",
451 io.readx.out.nread, ret_size);
455 children[nbio_id].bytes += ret_size;
458 void nb_close(int handle, NTSTATUS status)
464 i = find_handle(handle);
466 io.close.level = RAW_CLOSE_CLOSE;
467 io.close.in.fnum = i;
468 io.close.in.write_time = 0;
470 ret = smb_raw_close(c->tree, &io);
472 check_status("Close", status, ret);
474 if (NT_STATUS_IS_OK(ret)) {
475 struct ftable *f = find_ftable(handle);
476 DLIST_REMOVE(ftable, f);
481 void nb_rmdir(const char *dname, NTSTATUS status)
488 ret = smb_raw_rmdir(c->tree, &io);
490 check_status("Rmdir", status, ret);
493 void nb_mkdir(const char *dname, NTSTATUS status)
497 io.mkdir.level = RAW_MKDIR_MKDIR;
498 io.mkdir.in.path = dname;
500 /* NOTE! no error checking. Used for base fileset creation */
501 smb_raw_mkdir(c->tree, &io);
504 void nb_rename(const char *old, const char *new, NTSTATUS status)
509 io.generic.level = RAW_RENAME_RENAME;
510 io.rename.in.attrib = FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_DIRECTORY;
511 io.rename.in.pattern1 = old;
512 io.rename.in.pattern2 = new;
514 ret = smb_raw_rename(c->tree, &io);
516 check_status("Rename", status, ret);
520 void nb_qpathinfo(const char *fname, int level, NTSTATUS status)
522 union smb_fileinfo io;
526 mem_ctx = talloc_init("nb_qpathinfo");
528 io.generic.level = level;
529 io.generic.in.fname = fname;
531 ret = smb_raw_pathinfo(c->tree, mem_ctx, &io);
533 talloc_free(mem_ctx);
535 check_status("Pathinfo", status, ret);
539 void nb_qfileinfo(int fnum, int level, NTSTATUS status)
541 union smb_fileinfo io;
546 i = find_handle(fnum);
548 mem_ctx = talloc_init("nb_qfileinfo");
550 io.generic.level = level;
551 io.generic.in.fnum = i;
553 ret = smb_raw_fileinfo(c->tree, mem_ctx, &io);
555 talloc_free(mem_ctx);
557 check_status("Fileinfo", status, ret);
560 void nb_sfileinfo(int fnum, int level, NTSTATUS status)
562 union smb_setfileinfo io;
566 if (level != RAW_SFILEINFO_BASIC_INFORMATION) {
567 printf("[%d] Warning: setfileinfo level %d not handled\n", nbench_line_count, level);
573 i = find_handle(fnum);
575 io.generic.level = level;
576 io.generic.file.fnum = i;
577 unix_to_nt_time(&io.basic_info.in.create_time, time(NULL));
578 unix_to_nt_time(&io.basic_info.in.access_time, 0);
579 unix_to_nt_time(&io.basic_info.in.write_time, 0);
580 unix_to_nt_time(&io.basic_info.in.change_time, 0);
581 io.basic_info.in.attrib = 0;
583 ret = smb_raw_setfileinfo(c->tree, &io);
585 check_status("Setfileinfo", status, ret);
588 void nb_qfsinfo(int level, NTSTATUS status)
594 mem_ctx = talloc_init("smbcli_dskattr");
596 io.generic.level = level;
597 ret = smb_raw_fsinfo(c->tree, mem_ctx, &io);
599 talloc_free(mem_ctx);
601 check_status("Fsinfo", status, ret);
604 /* callback function used for trans2 search */
605 static BOOL findfirst_callback(void *private, union smb_search_data *file)
610 void nb_findfirst(const char *mask, int level, int maxcnt, int count, NTSTATUS status)
612 union smb_search_first io;
616 mem_ctx = talloc_init("smbcli_dskattr");
618 io.t2ffirst.level = level;
619 io.t2ffirst.in.max_count = maxcnt;
620 io.t2ffirst.in.search_attrib = FILE_ATTRIBUTE_DIRECTORY;
621 io.t2ffirst.in.pattern = mask;
622 io.t2ffirst.in.flags = FLAG_TRANS2_FIND_CLOSE;
623 io.t2ffirst.in.storage_type = 0;
625 ret = smb_raw_search_first(c->tree, mem_ctx, &io, NULL, findfirst_callback);
627 talloc_free(mem_ctx);
629 check_status("Search", status, ret);
631 if (NT_STATUS_IS_OK(ret) && io.t2ffirst.out.count != count) {
632 printf("[%d] Warning: got count %d expected %d\n",
634 io.t2ffirst.out.count, count);
638 void nb_flush(int fnum, NTSTATUS status)
643 i = find_handle(fnum);
647 ret = smb_raw_flush(c->tree, &io);
649 check_status("Flush", status, ret);
652 void nb_sleep(int usec, NTSTATUS status)
657 void nb_deltree(const char *dname)
661 smb_raw_exit(c->session);
664 struct ftable *f = ftable;
665 DLIST_REMOVE(ftable, f);
669 total_deleted = smbcli_deltree(c->tree, dname);
671 if (total_deleted == -1) {
672 printf("Failed to cleanup tree %s - exiting\n", dname);
676 smbcli_rmdir(c->tree, dname);