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