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