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