2 Unix SMB/CIFS implementation.
4 Copyright (C) Andrew Tridgell 1997-1998
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 #include "system/time.h"
23 #include "system/filesys.h"
24 #include "lib/util/dlinklist.h"
25 #include "libcli/libcli.h"
26 #include "libcli/raw/libcliraw.h"
27 #include "torture/torture.h"
28 #include "libcli/libcli.h"
29 #include "torture/util.h"
31 extern int nbench_line_count;
32 static int nbio_id = -1;
34 static BOOL bypass_io;
35 static struct timeval tv_start, tv_end;
36 static int warmup, timelimit;
37 static int in_cleanup;
40 struct ftable *next, *prev;
41 int fd; /* the fd that we got back from the server */
42 int handle; /* the handle in the load file */
45 static struct ftable *ftable;
48 double bytes, warmup_bytes;
53 double nbio_result(void)
57 for (i=0;i<nprocs;i++) {
58 total += children[i].bytes - children[i].warmup_bytes;
60 return 1.0e-6 * total / timeval_elapsed2(&tv_start, &tv_end);
65 return children[nbio_id].done;
69 void nb_alarm(int sig)
76 if (nbio_id != -1) return;
78 for (i=0;i<nprocs;i++) {
79 if (children[i].bytes == 0) {
82 lines += children[i].line;
85 t = timeval_elapsed(&tv_start);
87 if (!in_warmup && warmup>0 && t > warmup) {
88 tv_start = timeval_current();
90 for (i=0;i<nprocs;i++) {
91 children[i].warmup_bytes = children[i].bytes;
97 } else if (!in_warmup && !in_cleanup && t > timelimit) {
98 for (i=0;i<nprocs;i++) {
101 tv_end = timeval_current();
108 tv_end = timeval_current();
112 printf("%4d %8d %.2f MB/sec warmup %.0f sec \n",
113 nprocs, lines/nprocs,
115 } else if (in_cleanup) {
116 printf("%4d %8d %.2f MB/sec cleanup %.0f sec \n",
117 nprocs, lines/nprocs,
120 printf("%4d %8d %.2f MB/sec execute %.0f sec \n",
121 nprocs, lines/nprocs,
127 signal(SIGALRM, nb_alarm);
131 void nbio_shmem(int n, int t_timelimit, int t_warmup)
134 children = shm_setup(sizeof(*children) * nprocs);
136 printf("Failed to setup shared memory!\n");
139 memset(children, 0, sizeof(*children) * nprocs);
140 timelimit = t_timelimit;
143 tv_start = timeval_current();
146 static struct ftable *find_ftable(int handle)
150 for (f=ftable;f;f=f->next) {
151 if (f->handle == handle) return f;
156 static int find_handle(int handle)
160 children[nbio_id].line = nbench_line_count;
162 f = find_ftable(handle);
166 printf("(%d) ERROR: handle %d was not found\n",
167 nbench_line_count, handle);
170 return -1; /* Not reached */
175 static struct smbcli_state *c;
178 a handler function for oplock break requests
180 static BOOL oplock_handler(struct smbcli_transport *transport, uint16_t tid,
181 uint16_t fnum, uint8_t level, void *private)
183 struct smbcli_tree *tree = private;
184 return smbcli_oplock_ack(tree, fnum, OPLOCK_BREAK_TO_NONE);
187 void nb_setup(struct smbcli_state *cli, int id)
192 printf("skipping I/O\n");
195 smbcli_oplock_handler(cli->transport, oplock_handler, cli->tree);
200 static void check_status(const char *op, NTSTATUS status, NTSTATUS ret)
202 if (!NT_STATUS_IS_OK(status) && NT_STATUS_IS_OK(ret)) {
203 printf("[%d] Error: %s should have failed with %s\n",
204 nbench_line_count, op, nt_errstr(status));
208 if (NT_STATUS_IS_OK(status) && !NT_STATUS_IS_OK(ret)) {
209 printf("[%d] Error: %s should have succeeded - %s\n",
210 nbench_line_count, op, nt_errstr(ret));
214 if (!NT_STATUS_EQUAL(status, ret)) {
215 printf("[%d] Warning: got status %s but expected %s\n",
216 nbench_line_count, nt_errstr(ret), nt_errstr(status));
221 void nb_unlink(const char *fname, int attr, NTSTATUS status)
226 io.unlink.in.pattern = fname;
228 io.unlink.in.attrib = FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
229 if (strchr(fname, '*') == 0) {
230 io.unlink.in.attrib |= FILE_ATTRIBUTE_DIRECTORY;
233 ret = smb_raw_unlink(c->tree, &io);
235 check_status("Unlink", status, ret);
239 void nb_createx(const char *fname,
240 uint_t create_options, uint_t create_disposition, int handle,
244 uint32_t desired_access;
250 mem_ctx = talloc_init("raw_open");
252 if (create_options & NTCREATEX_OPTIONS_DIRECTORY) {
253 desired_access = SEC_FILE_READ_DATA;
257 SEC_FILE_WRITE_DATA |
258 SEC_FILE_READ_ATTRIBUTE |
259 SEC_FILE_WRITE_ATTRIBUTE;
260 flags = NTCREATEX_FLAGS_EXTENDED |
261 NTCREATEX_FLAGS_REQUEST_OPLOCK |
262 NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
265 io.ntcreatex.level = RAW_OPEN_NTCREATEX;
266 io.ntcreatex.in.flags = flags;
267 io.ntcreatex.in.root_fid = 0;
268 io.ntcreatex.in.access_mask = desired_access;
269 io.ntcreatex.in.file_attr = 0;
270 io.ntcreatex.in.alloc_size = 0;
271 io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ|NTCREATEX_SHARE_ACCESS_WRITE;
272 io.ntcreatex.in.open_disposition = create_disposition;
273 io.ntcreatex.in.create_options = create_options;
274 io.ntcreatex.in.impersonation = 0;
275 io.ntcreatex.in.security_flags = 0;
276 io.ntcreatex.in.fname = fname;
278 ret = smb_raw_open(c->tree, mem_ctx, &io);
280 talloc_free(mem_ctx);
282 check_status("NTCreateX", status, ret);
284 if (!NT_STATUS_IS_OK(ret)) return;
286 f = malloc_p(struct ftable);
288 f->fd = io.ntcreatex.out.file.fnum;
290 DLIST_ADD_END(ftable, f, struct ftable *);
293 void nb_writex(int handle, int offset, int size, int ret_size, NTSTATUS status)
300 i = find_handle(handle);
302 if (bypass_io) return;
305 memset(buf, 0xab, size);
307 io.writex.level = RAW_WRITE_WRITEX;
308 io.writex.in.file.fnum = i;
309 io.writex.in.wmode = 0;
310 io.writex.in.remaining = 0;
311 io.writex.in.offset = offset;
312 io.writex.in.count = size;
313 io.writex.in.data = buf;
315 ret = smb_raw_write(c->tree, &io);
319 check_status("WriteX", status, ret);
321 if (NT_STATUS_IS_OK(ret) && io.writex.out.nwritten != ret_size) {
322 printf("[%d] Warning: WriteX got count %d expected %d\n",
324 io.writex.out.nwritten, ret_size);
327 children[nbio_id].bytes += ret_size;
330 void nb_write(int handle, int offset, int size, int ret_size, NTSTATUS status)
337 i = find_handle(handle);
339 if (bypass_io) return;
343 memset(buf, 0x12, size);
345 io.write.level = RAW_WRITE_WRITE;
346 io.write.in.file.fnum = i;
347 io.write.in.remaining = 0;
348 io.write.in.offset = offset;
349 io.write.in.count = size;
350 io.write.in.data = buf;
352 ret = smb_raw_write(c->tree, &io);
356 check_status("Write", status, ret);
358 if (NT_STATUS_IS_OK(ret) && io.write.out.nwritten != ret_size) {
359 printf("[%d] Warning: Write got count %d expected %d\n",
361 io.write.out.nwritten, ret_size);
364 children[nbio_id].bytes += ret_size;
368 void nb_lockx(int handle, uint_t offset, int size, NTSTATUS status)
373 struct smb_lock_entry lck;
375 i = find_handle(handle);
381 io.lockx.level = RAW_LOCK_LOCKX;
382 io.lockx.in.file.fnum = i;
383 io.lockx.in.mode = 0;
384 io.lockx.in.timeout = 0;
385 io.lockx.in.ulock_cnt = 0;
386 io.lockx.in.lock_cnt = 1;
387 io.lockx.in.locks = &lck;
389 ret = smb_raw_lock(c->tree, &io);
391 check_status("LockX", status, ret);
394 void nb_unlockx(int handle, uint_t offset, int size, NTSTATUS status)
399 struct smb_lock_entry lck;
401 i = find_handle(handle);
407 io.lockx.level = RAW_LOCK_LOCKX;
408 io.lockx.in.file.fnum = i;
409 io.lockx.in.mode = 0;
410 io.lockx.in.timeout = 0;
411 io.lockx.in.ulock_cnt = 1;
412 io.lockx.in.lock_cnt = 0;
413 io.lockx.in.locks = &lck;
415 ret = smb_raw_lock(c->tree, &io);
417 check_status("UnlockX", status, ret);
420 void nb_readx(int handle, int offset, int size, int ret_size, NTSTATUS status)
427 i = find_handle(handle);
429 if (bypass_io) return;
433 io.readx.level = RAW_READ_READX;
434 io.readx.in.file.fnum = i;
435 io.readx.in.offset = offset;
436 io.readx.in.mincnt = size;
437 io.readx.in.maxcnt = size;
438 io.readx.in.remaining = 0;
439 io.readx.in.read_for_execute = False;
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.file.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.file.path = 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.file.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.in.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 = RAW_SEARCH_TRANS2;
619 io.t2ffirst.data_level = level;
620 io.t2ffirst.in.max_count = maxcnt;
621 io.t2ffirst.in.search_attrib = FILE_ATTRIBUTE_DIRECTORY;
622 io.t2ffirst.in.pattern = mask;
623 io.t2ffirst.in.flags = FLAG_TRANS2_FIND_CLOSE;
624 io.t2ffirst.in.storage_type = 0;
626 ret = smb_raw_search_first(c->tree, mem_ctx, &io, NULL, findfirst_callback);
628 talloc_free(mem_ctx);
630 check_status("Search", status, ret);
632 if (NT_STATUS_IS_OK(ret) && io.t2ffirst.out.count != count) {
633 printf("[%d] Warning: got count %d expected %d\n",
635 io.t2ffirst.out.count, count);
639 void nb_flush(int fnum, NTSTATUS status)
644 i = find_handle(fnum);
646 io.flush.level = RAW_FLUSH_FLUSH;
647 io.flush.in.file.fnum = i;
649 ret = smb_raw_flush(c->tree, &io);
651 check_status("Flush", status, ret);
654 void nb_sleep(int usec, NTSTATUS status)
659 void nb_deltree(const char *dname)
663 smb_raw_exit(c->session);
666 struct ftable *f = ftable;
667 DLIST_REMOVE(ftable, f);
671 total_deleted = smbcli_deltree(c->tree, dname);
673 if (total_deleted == -1) {
674 printf("Failed to cleanup tree %s - exiting\n", dname);
678 smbcli_rmdir(c->tree, dname);