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