r23531: added optional latency reporting in BENCH-NBENCH. To use it, you need
[samba.git] / source / torture / nbench / nbio.c
1 /*
2   TODO: add splitting of writes for servers with signing
3 */
4
5
6 /* 
7    Unix SMB/CIFS implementation.
8    SMB torture tester
9    Copyright (C) Andrew Tridgell 1997-1998
10    
11    This program is free software; you can redistribute it and/or modify
12    it under the terms of the GNU General Public License as published by
13    the Free Software Foundation; either version 2 of the License, or
14    (at your option) any later version.
15    
16    This program is distributed in the hope that it will be useful,
17    but WITHOUT ANY WARRANTY; without even the implied warranty of
18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19    GNU General Public License for more details.
20    
21    You should have received a copy of the GNU General Public License
22    along with this program; if not, write to the Free Software
23    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 */
25
26 #include "includes.h"
27 #include "system/time.h"
28 #include "system/filesys.h"
29 #include "lib/util/dlinklist.h"
30 #include "libcli/libcli.h"
31 #include "libcli/raw/libcliraw.h"
32 #include "torture/torture.h"
33 #include "libcli/libcli.h"
34 #include "torture/util.h"
35
36 extern int nbench_line_count;
37 static int nbio_id = -1;
38 static int nprocs;
39 static BOOL bypass_io;
40 static struct timeval tv_start, tv_end;
41 static int warmup, timelimit;
42 static int in_cleanup;
43
44 struct ftable {
45         struct ftable *next, *prev;
46         int fd;     /* the fd that we got back from the server */
47         int handle; /* the handle in the load file */
48 };
49
50 static struct ftable *ftable;
51
52 static struct {
53         double bytes, warmup_bytes;
54         int line;
55         int done;
56         double max_latency;
57         struct timeval starttime;
58 } *children;
59
60 void nbio_time_reset(void)
61 {
62         children[nbio_id].starttime = timeval_current();        
63 }
64
65 void nbio_time_delay(double targett)
66 {
67         double elapsed = timeval_elapsed(&children[nbio_id].starttime);
68         if (targett > elapsed) {
69                 msleep(1000*(targett - elapsed));
70         } else if (elapsed - targett > children[nbio_id].max_latency) {
71                 children[nbio_id].max_latency = elapsed - targett;
72         }
73 }
74
75 double nbio_result(void)
76 {
77         int i;
78         double total = 0;
79         for (i=0;i<nprocs;i++) {
80                 total += children[i].bytes - children[i].warmup_bytes;
81         }
82         return 1.0e-6 * total / timeval_elapsed2(&tv_start, &tv_end);
83 }
84
85 double nbio_latency(void)
86 {
87         int i;
88         double max_latency = 0;
89         for (i=0;i<nprocs;i++) {
90                 if (children[i].max_latency > max_latency) {
91                         max_latency = children[i].max_latency;
92                         children[i].max_latency = 0;
93                 }
94         }
95         return max_latency;
96 }
97
98 BOOL nb_tick(void)
99 {
100         return children[nbio_id].done;
101 }
102
103
104 void nb_alarm(int sig)
105 {
106         int i;
107         int lines=0;
108         double t;
109         int in_warmup = 0;
110
111         if (nbio_id != -1) return;
112
113         for (i=0;i<nprocs;i++) {
114                 if (children[i].bytes == 0) {
115                         in_warmup = 1;
116                 }
117                 lines += children[i].line;
118         }
119
120         t = timeval_elapsed(&tv_start);
121
122         if (!in_warmup && warmup>0 && t > warmup) {
123                 tv_start = timeval_current();
124                 warmup = 0;
125                 for (i=0;i<nprocs;i++) {
126                         children[i].warmup_bytes = children[i].bytes;
127                 }
128                 goto next;
129         }
130         if (t < warmup) {
131                 in_warmup = 1;
132         } else if (!in_warmup && !in_cleanup && t > timelimit) {
133                 for (i=0;i<nprocs;i++) {
134                         children[i].done = 1;
135                 }
136                 tv_end = timeval_current();
137                 in_cleanup = 1;
138         }
139         if (t < 1) {
140                 goto next;
141         }
142         if (!in_cleanup) {
143                 tv_end = timeval_current();
144         }
145
146         if (in_warmup) {
147                 printf("%4d  %8d  %.2f MB/sec  warmup %.0f sec   \n", 
148                        nprocs, lines/nprocs, 
149                        nbio_result(), t);
150         } else if (in_cleanup) {
151                 printf("%4d  %8d  %.2f MB/sec  cleanup %.0f sec   \n", 
152                        nprocs, lines/nprocs, 
153                        nbio_result(), t);
154         } else {
155                 printf("%4d  %8d  %.2f MB/sec  execute %.0f sec  latency %.2f msec \n", 
156                        nprocs, lines/nprocs, 
157                        nbio_result(), t, nbio_latency() * 1.0e3);
158         }
159
160         fflush(stdout);
161 next:
162         signal(SIGALRM, nb_alarm);
163         alarm(1);       
164 }
165
166 void nbio_shmem(int n, int t_timelimit, int t_warmup)
167 {
168         nprocs = n;
169         children = shm_setup(sizeof(*children) * nprocs);
170         if (!children) {
171                 printf("Failed to setup shared memory!\n");
172                 exit(1);
173         }
174         memset(children, 0, sizeof(*children) * nprocs);
175         timelimit = t_timelimit;
176         warmup = t_warmup;
177         in_cleanup = 0;
178         tv_start = timeval_current();
179 }
180
181 static struct ftable *find_ftable(int handle)
182 {
183         struct ftable *f;
184
185         for (f=ftable;f;f=f->next) {
186                 if (f->handle == handle) return f;
187         }
188         return NULL;
189 }
190
191 static int find_handle(int handle)
192 {
193         struct ftable *f;
194
195         children[nbio_id].line = nbench_line_count;
196
197         f = find_ftable(handle);
198         if (f) {
199                 return f->fd;
200         }
201         printf("(%d) ERROR: handle %d was not found\n", 
202                nbench_line_count, handle);
203         exit(1);
204
205         return -1;              /* Not reached */
206 }
207
208
209
210 static struct smbcli_state *c;
211
212 /*
213   a handler function for oplock break requests
214 */
215 static BOOL oplock_handler(struct smbcli_transport *transport, uint16_t tid, 
216                            uint16_t fnum, uint8_t level, void *private)
217 {
218         struct smbcli_tree *tree = private;
219         return smbcli_oplock_ack(tree, fnum, OPLOCK_BREAK_TO_NONE);
220 }
221
222 void nb_setup(struct smbcli_state *cli, int id)
223 {
224         nbio_id = id;
225         c = cli;
226         if (bypass_io)
227                 printf("skipping I/O\n");
228
229         if (cli) {
230                 smbcli_oplock_handler(cli->transport, oplock_handler, cli->tree);
231         }
232 }
233
234
235 static void check_status(const char *op, NTSTATUS status, NTSTATUS ret)
236 {
237         if (!NT_STATUS_IS_OK(status) && NT_STATUS_IS_OK(ret)) {
238                 printf("[%d] Error: %s should have failed with %s\n", 
239                        nbench_line_count, op, nt_errstr(status));
240                 exit(1);
241         }
242
243         if (NT_STATUS_IS_OK(status) && !NT_STATUS_IS_OK(ret)) {
244                 printf("[%d] Error: %s should have succeeded - %s\n", 
245                        nbench_line_count, op, nt_errstr(ret));
246                 exit(1);
247         }
248
249         if (!NT_STATUS_EQUAL(status, ret)) {
250                 printf("[%d] Warning: got status %s but expected %s\n",
251                        nbench_line_count, nt_errstr(ret), nt_errstr(status));
252         }
253 }
254
255
256 void nb_unlink(const char *fname, int attr, NTSTATUS status)
257 {
258         union smb_unlink io;
259         NTSTATUS ret;
260
261         io.unlink.in.pattern = fname;
262
263         io.unlink.in.attrib = FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
264         if (strchr(fname, '*') == 0) {
265                 io.unlink.in.attrib |= FILE_ATTRIBUTE_DIRECTORY;
266         }
267
268         ret = smb_raw_unlink(c->tree, &io);
269
270         check_status("Unlink", status, ret);
271 }
272
273
274 void nb_createx(const char *fname, 
275                 uint_t create_options, uint_t create_disposition, int handle,
276                 NTSTATUS status)
277 {
278         union smb_open io;      
279         uint32_t desired_access;
280         NTSTATUS ret;
281         TALLOC_CTX *mem_ctx;
282         uint_t flags = 0;
283         struct ftable *f;
284
285         mem_ctx = talloc_init("raw_open");
286
287         if (create_options & NTCREATEX_OPTIONS_DIRECTORY) {
288                 desired_access = SEC_FILE_READ_DATA;
289         } else {
290                 desired_access = 
291                         SEC_FILE_READ_DATA | 
292                         SEC_FILE_WRITE_DATA |
293                         SEC_FILE_READ_ATTRIBUTE |
294                         SEC_FILE_WRITE_ATTRIBUTE;
295                 flags = NTCREATEX_FLAGS_EXTENDED |
296                         NTCREATEX_FLAGS_REQUEST_OPLOCK | 
297                         NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
298         }
299
300         io.ntcreatex.level = RAW_OPEN_NTCREATEX;
301         io.ntcreatex.in.flags = flags;
302         io.ntcreatex.in.root_fid = 0;
303         io.ntcreatex.in.access_mask = desired_access;
304         io.ntcreatex.in.file_attr = 0;
305         io.ntcreatex.in.alloc_size = 0;
306         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ|NTCREATEX_SHARE_ACCESS_WRITE;
307         io.ntcreatex.in.open_disposition = create_disposition;
308         io.ntcreatex.in.create_options = create_options;
309         io.ntcreatex.in.impersonation = 0;
310         io.ntcreatex.in.security_flags = 0;
311         io.ntcreatex.in.fname = fname;
312
313         ret = smb_raw_open(c->tree, mem_ctx, &io);
314
315         talloc_free(mem_ctx);
316
317         check_status("NTCreateX", status, ret);
318
319         if (!NT_STATUS_IS_OK(ret)) return;
320
321         f = malloc_p(struct ftable);
322         f->handle = handle;
323         f->fd = io.ntcreatex.out.file.fnum;
324
325         DLIST_ADD_END(ftable, f, struct ftable *);
326 }
327
328 void nb_writex(int handle, off_t offset, int size, int ret_size, NTSTATUS status)
329 {
330         union smb_write io;
331         int i;
332         NTSTATUS ret;
333         uint8_t *buf;
334
335         i = find_handle(handle);
336
337         if (bypass_io) return;
338
339         buf = malloc(size);
340         memset(buf, 0xab, size);
341
342         io.writex.level = RAW_WRITE_WRITEX;
343         io.writex.in.file.fnum = i;
344         io.writex.in.wmode = 0;
345         io.writex.in.remaining = 0;
346         io.writex.in.offset = offset;
347         io.writex.in.count = size;
348         io.writex.in.data = buf;
349
350         ret = smb_raw_write(c->tree, &io);
351
352         free(buf);
353
354         check_status("WriteX", status, ret);
355
356         if (NT_STATUS_IS_OK(ret) && io.writex.out.nwritten != ret_size) {
357                 printf("[%d] Warning: WriteX got count %d expected %d\n", 
358                        nbench_line_count,
359                        io.writex.out.nwritten, ret_size);
360         }       
361
362         children[nbio_id].bytes += ret_size;
363 }
364
365 void nb_write(int handle, off_t offset, int size, int ret_size, NTSTATUS status)
366 {
367         union smb_write io;
368         int i;
369         NTSTATUS ret;
370         uint8_t *buf;
371
372         i = find_handle(handle);
373
374         if (bypass_io) return;
375
376         buf = malloc(size);
377
378         memset(buf, 0x12, size);
379
380         io.write.level = RAW_WRITE_WRITE;
381         io.write.in.file.fnum = i;
382         io.write.in.remaining = 0;
383         io.write.in.offset = offset;
384         io.write.in.count = size;
385         io.write.in.data = buf;
386
387         ret = smb_raw_write(c->tree, &io);
388
389         free(buf);
390
391         check_status("Write", status, ret);
392
393         if (NT_STATUS_IS_OK(ret) && io.write.out.nwritten != ret_size) {
394                 printf("[%d] Warning: Write got count %d expected %d\n", 
395                        nbench_line_count,
396                        io.write.out.nwritten, ret_size);
397         }       
398
399         children[nbio_id].bytes += ret_size;
400 }
401
402
403 void nb_lockx(int handle, off_t offset, int size, NTSTATUS status)
404 {
405         union smb_lock io;
406         int i;
407         NTSTATUS ret;
408         struct smb_lock_entry lck;
409
410         i = find_handle(handle);
411
412         lck.pid = getpid();
413         lck.offset = offset;
414         lck.count = size;
415
416         io.lockx.level = RAW_LOCK_LOCKX;
417         io.lockx.in.file.fnum = i;
418         io.lockx.in.mode = 0;
419         io.lockx.in.timeout = 0;
420         io.lockx.in.ulock_cnt = 0;
421         io.lockx.in.lock_cnt = 1;
422         io.lockx.in.locks = &lck;
423
424         ret = smb_raw_lock(c->tree, &io);
425
426         check_status("LockX", status, ret);
427 }
428
429 void nb_unlockx(int handle, uint_t offset, int size, NTSTATUS status)
430 {
431         union smb_lock io;
432         int i;
433         NTSTATUS ret;
434         struct smb_lock_entry lck;
435
436         i = find_handle(handle);
437
438         lck.pid = getpid();
439         lck.offset = offset;
440         lck.count = size;
441
442         io.lockx.level = RAW_LOCK_LOCKX;
443         io.lockx.in.file.fnum = i;
444         io.lockx.in.mode = 0;
445         io.lockx.in.timeout = 0;
446         io.lockx.in.ulock_cnt = 1;
447         io.lockx.in.lock_cnt = 0;
448         io.lockx.in.locks = &lck;
449
450         ret = smb_raw_lock(c->tree, &io);
451
452         check_status("UnlockX", status, ret);
453 }
454
455 void nb_readx(int handle, off_t offset, int size, int ret_size, NTSTATUS status)
456 {
457         union smb_read io;
458         int i;
459         NTSTATUS ret;
460         uint8_t *buf;
461
462         i = find_handle(handle);
463
464         if (bypass_io) return;
465
466         buf = malloc(size);
467
468         io.readx.level = RAW_READ_READX;
469         io.readx.in.file.fnum = i;
470         io.readx.in.offset    = offset;
471         io.readx.in.mincnt    = size;
472         io.readx.in.maxcnt    = size;
473         io.readx.in.remaining = 0;
474         io.readx.in.read_for_execute = False;
475         io.readx.out.data     = buf;
476         
477         ret = smb_raw_read(c->tree, &io);
478
479         free(buf);
480
481         check_status("ReadX", status, ret);
482
483         if (NT_STATUS_IS_OK(ret) && io.readx.out.nread != ret_size) {
484                 printf("[%d] ERROR: ReadX got count %d expected %d\n", 
485                        nbench_line_count,
486                        io.readx.out.nread, ret_size);
487                 exit(1);
488         }       
489
490         children[nbio_id].bytes += ret_size;
491 }
492
493 void nb_close(int handle, NTSTATUS status)
494 {
495         NTSTATUS ret;
496         union smb_close io;
497         int i;
498
499         i = find_handle(handle);
500
501         io.close.level = RAW_CLOSE_CLOSE;
502         io.close.in.file.fnum = i;
503         io.close.in.write_time = 0;
504
505         ret = smb_raw_close(c->tree, &io);
506
507         check_status("Close", status, ret);
508
509         if (NT_STATUS_IS_OK(ret)) {
510                 struct ftable *f = find_ftable(handle);
511                 DLIST_REMOVE(ftable, f);
512                 free(f);
513         }
514 }
515
516 void nb_rmdir(const char *dname, NTSTATUS status)
517 {
518         NTSTATUS ret;
519         struct smb_rmdir io;
520
521         io.in.path = dname;
522
523         ret = smb_raw_rmdir(c->tree, &io);
524
525         check_status("Rmdir", status, ret);
526 }
527
528 void nb_mkdir(const char *dname, NTSTATUS status)
529 {
530         union smb_mkdir io;
531
532         io.mkdir.level = RAW_MKDIR_MKDIR;
533         io.mkdir.in.path = dname;
534
535         /* NOTE! no error checking. Used for base fileset creation */
536         smb_raw_mkdir(c->tree, &io);
537 }
538
539 void nb_rename(const char *old, const char *new, NTSTATUS status)
540 {
541         NTSTATUS ret;
542         union smb_rename io;
543
544         io.generic.level = RAW_RENAME_RENAME;
545         io.rename.in.attrib = FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_DIRECTORY;
546         io.rename.in.pattern1 = old;
547         io.rename.in.pattern2 = new;
548
549         ret = smb_raw_rename(c->tree, &io);
550
551         check_status("Rename", status, ret);
552 }
553
554
555 void nb_qpathinfo(const char *fname, int level, NTSTATUS status)
556 {
557         union smb_fileinfo io;
558         TALLOC_CTX *mem_ctx;
559         NTSTATUS ret;
560
561         mem_ctx = talloc_init("nb_qpathinfo");
562
563         io.generic.level = level;
564         io.generic.in.file.path = fname;
565
566         ret = smb_raw_pathinfo(c->tree, mem_ctx, &io);
567
568         talloc_free(mem_ctx);
569
570         check_status("Pathinfo", status, ret);
571 }
572
573
574 void nb_qfileinfo(int fnum, int level, NTSTATUS status)
575 {
576         union smb_fileinfo io;
577         TALLOC_CTX *mem_ctx;
578         NTSTATUS ret;
579         int i;
580
581         i = find_handle(fnum);
582
583         mem_ctx = talloc_init("nb_qfileinfo");
584
585         io.generic.level = level;
586         io.generic.in.file.fnum = i;
587
588         ret = smb_raw_fileinfo(c->tree, mem_ctx, &io);
589
590         talloc_free(mem_ctx);
591
592         check_status("Fileinfo", status, ret);
593 }
594
595 void nb_sfileinfo(int fnum, int level, NTSTATUS status)
596 {
597         union smb_setfileinfo io;
598         NTSTATUS ret;
599         int i;
600
601         if (level != RAW_SFILEINFO_BASIC_INFORMATION) {
602                 printf("[%d] Warning: setfileinfo level %d not handled\n", nbench_line_count, level);
603                 return;
604         }
605
606         ZERO_STRUCT(io);
607
608         i = find_handle(fnum);
609
610         io.generic.level = level;
611         io.generic.in.file.fnum = i;
612         unix_to_nt_time(&io.basic_info.in.create_time, time(NULL));
613         unix_to_nt_time(&io.basic_info.in.access_time, 0);
614         unix_to_nt_time(&io.basic_info.in.write_time, 0);
615         unix_to_nt_time(&io.basic_info.in.change_time, 0);
616         io.basic_info.in.attrib = 0;
617
618         ret = smb_raw_setfileinfo(c->tree, &io);
619
620         check_status("Setfileinfo", status, ret);
621 }
622
623 void nb_qfsinfo(int level, NTSTATUS status)
624 {
625         union smb_fsinfo io;
626         TALLOC_CTX *mem_ctx;
627         NTSTATUS ret;
628
629         mem_ctx = talloc_init("smbcli_dskattr");
630
631         io.generic.level = level;
632         ret = smb_raw_fsinfo(c->tree, mem_ctx, &io);
633
634         talloc_free(mem_ctx);
635         
636         check_status("Fsinfo", status, ret);    
637 }
638
639 /* callback function used for trans2 search */
640 static BOOL findfirst_callback(void *private, const union smb_search_data *file)
641 {
642         return True;
643 }
644
645 void nb_findfirst(const char *mask, int level, int maxcnt, int count, NTSTATUS status)
646 {
647         union smb_search_first io;
648         TALLOC_CTX *mem_ctx;
649         NTSTATUS ret;
650
651         mem_ctx = talloc_init("smbcli_dskattr");
652
653         io.t2ffirst.level = RAW_SEARCH_TRANS2;
654         io.t2ffirst.data_level = level;
655         io.t2ffirst.in.max_count = maxcnt;
656         io.t2ffirst.in.search_attrib = FILE_ATTRIBUTE_DIRECTORY;
657         io.t2ffirst.in.pattern = mask;
658         io.t2ffirst.in.flags = FLAG_TRANS2_FIND_CLOSE;
659         io.t2ffirst.in.storage_type = 0;
660                         
661         ret = smb_raw_search_first(c->tree, mem_ctx, &io, NULL, findfirst_callback);
662
663         talloc_free(mem_ctx);
664
665         check_status("Search", status, ret);
666
667         if (NT_STATUS_IS_OK(ret) && io.t2ffirst.out.count != count) {
668                 printf("[%d] Warning: got count %d expected %d\n", 
669                        nbench_line_count,
670                        io.t2ffirst.out.count, count);
671         }
672 }
673
674 void nb_flush(int fnum, NTSTATUS status)
675 {
676         union smb_flush io;
677         NTSTATUS ret;
678         int i;
679         i = find_handle(fnum);
680
681         io.flush.level          = RAW_FLUSH_FLUSH;
682         io.flush.in.file.fnum   = i;
683
684         ret = smb_raw_flush(c->tree, &io);
685
686         check_status("Flush", status, ret);
687 }
688
689 void nb_sleep(int usec, NTSTATUS status)
690 {
691         usleep(usec);
692 }
693
694 void nb_deltree(const char *dname)
695 {
696         int total_deleted;
697
698         smb_raw_exit(c->session);
699
700         while (ftable) {
701                 struct ftable *f = ftable;
702                 DLIST_REMOVE(ftable, f);
703                 free(f);
704         }
705
706         total_deleted = smbcli_deltree(c->tree, dname);
707
708         if (total_deleted == -1) {
709                 printf("Failed to cleanup tree %s - exiting\n", dname);
710                 exit(1);
711         }
712
713         smbcli_rmdir(c->tree, dname);
714 }
715