torture: use tevent_ functions names instead of the legacy event_ ones
[kai/samba.git] / source4 / torture / basic / misc.c
1 /* 
2    Unix SMB/CIFS implementation.
3    SMB torture tester
4    Copyright (C) Andrew Tridgell 1997-2003
5    Copyright (C) Jelmer Vernooij 2006
6    
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 3 of the License, or
10    (at your option) any later version.
11    
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16    
17    You should have received a copy of the GNU General Public License
18    along with this program.  If not, see <http://www.gnu.org/licenses/>.
19 */
20
21 #include "includes.h"
22 #include "libcli/raw/libcliraw.h"
23 #include "libcli/raw/raw_proto.h"
24 #include "system/time.h"
25 #include "system/wait.h"
26 #include "system/filesys.h"
27 #include "libcli/raw/ioctl.h"
28 #include "libcli/libcli.h"
29 #include "lib/events/events.h"
30 #include "libcli/resolve/resolve.h"
31 #include "torture/smbtorture.h"
32 #include "torture/util.h"
33 #include "libcli/smb_composite/smb_composite.h"
34 #include "libcli/composite/composite.h"
35 #include "param/param.h"
36 #include "torture/basic/proto.h"
37
38 extern struct cli_credentials *cmdline_credentials;
39         
40 static bool wait_lock(struct smbcli_state *c, int fnum, uint32_t offset, uint32_t len)
41 {
42         while (NT_STATUS_IS_ERR(smbcli_lock(c->tree, fnum, offset, len, -1, WRITE_LOCK))) {
43                 if (!check_error(__location__, c, ERRDOS, ERRlock, NT_STATUS_LOCK_NOT_GRANTED)) return false;
44         }
45         return true;
46 }
47
48
49 static bool rw_torture(struct torture_context *tctx, struct smbcli_state *c)
50 {
51         const char *lockfname = "\\torture.lck";
52         char *fname;
53         int fnum;
54         int fnum2;
55         pid_t pid2, pid = getpid();
56         int i, j;
57         uint8_t buf[1024];
58         bool correct = true;
59
60         fnum2 = smbcli_open(c->tree, lockfname, O_RDWR | O_CREAT | O_EXCL, 
61                          DENY_NONE);
62         if (fnum2 == -1)
63                 fnum2 = smbcli_open(c->tree, lockfname, O_RDWR, DENY_NONE);
64         if (fnum2 == -1) {
65                 torture_comment(tctx, "open of %s failed (%s)\n", lockfname, smbcli_errstr(c->tree));
66                 return false;
67         }
68
69         generate_random_buffer(buf, sizeof(buf));
70
71         for (i=0;i<torture_numops;i++) {
72                 unsigned int n = (unsigned int)random()%10;
73                 if (i % 10 == 0) {
74                         if (torture_setting_bool(tctx, "progress", true)) {
75                                 torture_comment(tctx, "%d\r", i);
76                                 fflush(stdout);
77                         }
78                 }
79                 asprintf(&fname, "\\torture.%u", n);
80
81                 if (!wait_lock(c, fnum2, n*sizeof(int), sizeof(int))) {
82                         return false;
83                 }
84
85                 fnum = smbcli_open(c->tree, fname, O_RDWR | O_CREAT | O_TRUNC, DENY_ALL);
86                 if (fnum == -1) {
87                         torture_comment(tctx, "open failed (%s)\n", smbcli_errstr(c->tree));
88                         correct = false;
89                         break;
90                 }
91
92                 if (smbcli_write(c->tree, fnum, 0, &pid, 0, sizeof(pid)) != sizeof(pid)) {
93                         torture_comment(tctx, "write failed (%s)\n", smbcli_errstr(c->tree));
94                         correct = false;
95                 }
96
97                 for (j=0;j<50;j++) {
98                         if (smbcli_write(c->tree, fnum, 0, buf, 
99                                       sizeof(pid)+(j*sizeof(buf)), 
100                                       sizeof(buf)) != sizeof(buf)) {
101                                 torture_comment(tctx, "write failed (%s)\n", smbcli_errstr(c->tree));
102                                 correct = false;
103                         }
104                 }
105
106                 pid2 = 0;
107
108                 if (smbcli_read(c->tree, fnum, &pid2, 0, sizeof(pid)) != sizeof(pid)) {
109                         torture_comment(tctx, "read failed (%s)\n", smbcli_errstr(c->tree));
110                         correct = false;
111                 }
112
113                 if (pid2 != pid) {
114                         torture_comment(tctx, "data corruption!\n");
115                         correct = false;
116                 }
117
118                 if (NT_STATUS_IS_ERR(smbcli_close(c->tree, fnum))) {
119                         torture_comment(tctx, "close failed (%s)\n", smbcli_errstr(c->tree));
120                         correct = false;
121                 }
122
123                 if (NT_STATUS_IS_ERR(smbcli_unlink(c->tree, fname))) {
124                         torture_comment(tctx, "unlink failed (%s)\n", smbcli_errstr(c->tree));
125                         correct = false;
126                 }
127
128                 if (NT_STATUS_IS_ERR(smbcli_unlock(c->tree, fnum2, n*sizeof(int), sizeof(int)))) {
129                         torture_comment(tctx, "unlock failed (%s)\n", smbcli_errstr(c->tree));
130                         correct = false;
131                 }
132                 free(fname);
133         }
134
135         smbcli_close(c->tree, fnum2);
136         smbcli_unlink(c->tree, lockfname);
137
138         torture_comment(tctx, "%d\n", i);
139
140         return correct;
141 }
142
143 bool run_torture(struct torture_context *tctx, struct smbcli_state *cli, int dummy)
144 {
145         return rw_torture(tctx, cli);
146 }
147
148
149 /*
150   see how many RPC pipes we can open at once
151 */
152 bool run_pipe_number(struct torture_context *tctx, 
153                                          struct smbcli_state *cli1)
154 {
155         const char *pipe_name = "\\WKSSVC";
156         int fnum;
157         int num_pipes = 0;
158
159         while(1) {
160                 fnum = smbcli_nt_create_full(cli1->tree, pipe_name, 0, SEC_FILE_READ_DATA, FILE_ATTRIBUTE_NORMAL,
161                                    NTCREATEX_SHARE_ACCESS_READ|NTCREATEX_SHARE_ACCESS_WRITE, NTCREATEX_DISP_OPEN_IF, 0, 0);
162
163                 if (fnum == -1) {
164                         torture_comment(tctx, "Open of pipe %s failed with error (%s)\n", pipe_name, smbcli_errstr(cli1->tree));
165                         break;
166                 }
167                 num_pipes++;
168                 if (torture_setting_bool(tctx, "progress", true)) {
169                         torture_comment(tctx, "%d\r", num_pipes);
170                         fflush(stdout);
171                 }
172         }
173
174         torture_comment(tctx, "pipe_number test - we can open %d %s pipes.\n", num_pipes, pipe_name );
175         return true;
176 }
177
178
179
180
181 /*
182   open N connections to the server and just hold them open
183   used for testing performance when there are N idle users
184   already connected
185  */
186 bool torture_holdcon(struct torture_context *tctx)
187 {
188         int i;
189         struct smbcli_state **cli;
190         int num_dead = 0;
191
192         torture_comment(tctx, "Opening %d connections\n", torture_numops);
193         
194         cli = malloc_array_p(struct smbcli_state *, torture_numops);
195
196         for (i=0;i<torture_numops;i++) {
197                 if (!torture_open_connection(&cli[i], tctx, i)) {
198                         return false;
199                 }
200                 if (torture_setting_bool(tctx, "progress", true)) {
201                         torture_comment(tctx, "opened %d connections\r", i);
202                         fflush(stdout);
203                 }
204         }
205
206         torture_comment(tctx, "\nStarting pings\n");
207
208         while (1) {
209                 for (i=0;i<torture_numops;i++) {
210                         NTSTATUS status;
211                         if (cli[i]) {
212                                 status = smbcli_chkpath(cli[i]->tree, "\\");
213                                 if (!NT_STATUS_IS_OK(status)) {
214                                         torture_comment(tctx, "Connection %d is dead\n", i);
215                                         cli[i] = NULL;
216                                         num_dead++;
217                                 }
218                                 usleep(100);
219                         }
220                 }
221
222                 if (num_dead == torture_numops) {
223                         torture_comment(tctx, "All connections dead - finishing\n");
224                         break;
225                 }
226
227                 torture_comment(tctx, ".");
228                 fflush(stdout);
229         }
230
231         return true;
232 }
233
234 /*
235   open a file N times on the server and just hold them open
236   used for testing performance when there are N file handles
237   alopenn
238  */
239 bool torture_holdopen(struct torture_context *tctx,
240                       struct smbcli_state *cli)
241 {
242         int i, fnum;
243         const char *fname = "\\holdopen.dat";
244         NTSTATUS status;
245
246         smbcli_unlink(cli->tree, fname);
247
248         fnum = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
249         if (fnum == -1) {
250                 torture_comment(tctx, "open of %s failed (%s)\n", fname, smbcli_errstr(cli->tree));
251                 return false;
252         }
253
254         smbcli_close(cli->tree, fnum);
255
256         for (i=0;i<torture_numops;i++) {
257                 union smb_open op;
258
259                 op.generic.level = RAW_OPEN_NTCREATEX;
260                 op.ntcreatex.in.root_fid.fnum = 0;
261                 op.ntcreatex.in.flags = 0;
262                 op.ntcreatex.in.access_mask = SEC_FILE_WRITE_DATA;
263                 op.ntcreatex.in.create_options = 0;
264                 op.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
265                 op.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_MASK;
266                 op.ntcreatex.in.alloc_size = 0;
267                 op.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
268                 op.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
269                 op.ntcreatex.in.security_flags = 0;
270                 op.ntcreatex.in.fname = fname;
271                 status = smb_raw_open(cli->tree, tctx, &op);
272                 if (!NT_STATUS_IS_OK(status)) {
273                         torture_warning(tctx, "open %d failed\n", i);
274                         continue;
275                 }
276
277                 if (torture_setting_bool(tctx, "progress", true)) {
278                         torture_comment(tctx, "opened %d file\r", i);
279                         fflush(stdout);
280                 }
281         }
282
283         torture_comment(tctx, "\nStarting pings\n");
284
285         while (1) {
286                 struct smb_echo ec;
287
288                 status = smb_raw_echo(cli->transport, &ec);
289                 torture_comment(tctx, ".");
290                 fflush(stdout);
291                 sleep(15);
292         }
293 }
294
295 /*
296 test how many open files this server supports on the one socket
297 */
298 bool run_maxfidtest(struct torture_context *tctx, struct smbcli_state *cli, int dummy)
299 {
300 #define MAXFID_TEMPLATE "\\maxfid\\fid%d\\maxfid.%d.%d"
301         char *fname;
302         int fnums[0x11000], i;
303         int retries=4, maxfid;
304         bool correct = true;
305
306         if (retries <= 0) {
307                 torture_comment(tctx, "failed to connect\n");
308                 return false;
309         }
310
311         if (smbcli_deltree(cli->tree, "\\maxfid") == -1) {
312                 torture_comment(tctx, "Failed to deltree \\maxfid - %s\n",
313                        smbcli_errstr(cli->tree));
314                 return false;
315         }
316         if (NT_STATUS_IS_ERR(smbcli_mkdir(cli->tree, "\\maxfid"))) {
317                 torture_comment(tctx, "Failed to mkdir \\maxfid, error=%s\n", 
318                        smbcli_errstr(cli->tree));
319                 return false;
320         }
321
322         torture_comment(tctx, "Testing maximum number of open files\n");
323
324         for (i=0; i<0x11000; i++) {
325                 if (i % 1000 == 0) {
326                         asprintf(&fname, "\\maxfid\\fid%d", i/1000);
327                         if (NT_STATUS_IS_ERR(smbcli_mkdir(cli->tree, fname))) {
328                                 torture_comment(tctx, "Failed to mkdir %s, error=%s\n", 
329                                        fname, smbcli_errstr(cli->tree));
330                                 return false;
331                         }
332                         free(fname);
333                 }
334                 asprintf(&fname, MAXFID_TEMPLATE, i/1000, i,(int)getpid());
335                 if ((fnums[i] = smbcli_open(cli->tree, fname, 
336                                         O_RDWR|O_CREAT|O_TRUNC, DENY_NONE)) ==
337                     -1) {
338                         torture_comment(tctx, "open of %s failed (%s)\n", 
339                                fname, smbcli_errstr(cli->tree));
340                         torture_comment(tctx, "maximum fnum is %d\n", i);
341                         break;
342                 }
343                 free(fname);
344                 if (torture_setting_bool(tctx, "progress", true)) {
345                         torture_comment(tctx, "%6d\r", i);
346                         fflush(stdout);
347                 }
348         }
349         torture_comment(tctx, "%6d\n", i);
350         i--;
351
352         maxfid = i;
353
354         torture_comment(tctx, "cleaning up\n");
355         for (i=0;i<maxfid/2;i++) {
356                 asprintf(&fname, MAXFID_TEMPLATE, i/1000, i,(int)getpid());
357                 if (NT_STATUS_IS_ERR(smbcli_close(cli->tree, fnums[i]))) {
358                         torture_comment(tctx, "Close of fnum %d failed - %s\n", fnums[i], smbcli_errstr(cli->tree));
359                 }
360                 if (NT_STATUS_IS_ERR(smbcli_unlink(cli->tree, fname))) {
361                         torture_comment(tctx, "unlink of %s failed (%s)\n", 
362                                fname, smbcli_errstr(cli->tree));
363                         correct = false;
364                 }
365                 free(fname);
366
367                 asprintf(&fname, MAXFID_TEMPLATE, (maxfid-i)/1000, maxfid-i,(int)getpid());
368                 if (NT_STATUS_IS_ERR(smbcli_close(cli->tree, fnums[maxfid-i]))) {
369                         torture_comment(tctx, "Close of fnum %d failed - %s\n", fnums[maxfid-i], smbcli_errstr(cli->tree));
370                 }
371                 if (NT_STATUS_IS_ERR(smbcli_unlink(cli->tree, fname))) {
372                         torture_comment(tctx, "unlink of %s failed (%s)\n", 
373                                fname, smbcli_errstr(cli->tree));
374                         correct = false;
375                 }
376                 free(fname);
377
378                 if (torture_setting_bool(tctx, "progress", true)) {
379                         torture_comment(tctx, "%6d %6d\r", i, maxfid-i);
380                         fflush(stdout);
381                 }
382         }
383         torture_comment(tctx, "%6d\n", 0);
384
385         if (smbcli_deltree(cli->tree, "\\maxfid") == -1) {
386                 torture_comment(tctx, "Failed to deltree \\maxfid - %s\n",
387                        smbcli_errstr(cli->tree));
388                 return false;
389         }
390
391         torture_comment(tctx, "maxfid test finished\n");
392         if (!torture_close_connection(cli)) {
393                 correct = false;
394         }
395         return correct;
396 #undef MAXFID_TEMPLATE
397 }
398
399
400
401 /*
402   sees what IOCTLs are supported
403  */
404 bool torture_ioctl_test(struct torture_context *tctx, 
405                                                 struct smbcli_state *cli)
406 {
407         uint16_t device, function;
408         int fnum;
409         const char *fname = "\\ioctl.dat";
410         NTSTATUS status;
411         union smb_ioctl parms;
412         TALLOC_CTX *mem_ctx;
413
414         mem_ctx = talloc_named_const(tctx, 0, "ioctl_test");
415
416         smbcli_unlink(cli->tree, fname);
417
418         fnum = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
419         if (fnum == -1) {
420                 torture_comment(tctx, "open of %s failed (%s)\n", fname, smbcli_errstr(cli->tree));
421                 return false;
422         }
423
424         parms.ioctl.level = RAW_IOCTL_IOCTL;
425         parms.ioctl.in.file.fnum = fnum;
426         parms.ioctl.in.request = IOCTL_QUERY_JOB_INFO;
427         status = smb_raw_ioctl(cli->tree, mem_ctx, &parms);
428         torture_comment(tctx, "ioctl job info: %s\n", smbcli_errstr(cli->tree));
429
430         for (device=0;device<0x100;device++) {
431                 torture_comment(tctx, "Testing device=0x%x\n", device);
432                 for (function=0;function<0x100;function++) {
433                         parms.ioctl.in.request = (device << 16) | function;
434                         status = smb_raw_ioctl(cli->tree, mem_ctx, &parms);
435
436                         if (NT_STATUS_IS_OK(status)) {
437                                 torture_comment(tctx, "ioctl device=0x%x function=0x%x OK : %d bytes\n", 
438                                         device, function, (int)parms.ioctl.out.blob.length);
439                         }
440                 }
441         }
442
443         return true;
444 }
445
446 static void benchrw_callback(struct smbcli_request *req);
447 enum benchrw_stage {
448         START,
449         OPEN_CONNECTION,
450         CLEANUP_TESTDIR,
451         MK_TESTDIR,
452         OPEN_FILE,
453         INITIAL_WRITE,
454         READ_WRITE_DATA,
455         MAX_OPS_REACHED,
456         ERROR,
457         CLOSE_FILE,
458         CLEANUP,
459         FINISHED
460 };
461
462 struct benchrw_state {
463         struct torture_context *tctx;
464         char *dname;
465         char *fname;
466         uint16_t fnum;
467         int nr;
468         struct smbcli_tree      *cli;           
469         uint8_t *buffer;
470         int writecnt;
471         int readcnt;
472         int completed;
473         int num_parallel_requests;
474         void *req_params;
475         enum benchrw_stage mode;
476         struct params{
477                 struct unclist{
478                         const char *host;
479                         const char *share;
480                 } **unc;
481                 const char *workgroup;
482                 int retry;
483                 unsigned int writeblocks;
484                 unsigned int blocksize;
485                 unsigned int writeratio;
486                 int num_parallel_requests;
487         } *lpcfg_params;
488 };
489
490 /* 
491         init params using lpcfg_parm_xxx
492         return number of unclist entries
493 */
494 static int init_benchrw_params(struct torture_context *tctx,
495                                struct params *lpar)
496 {
497         char **unc_list = NULL;
498         int num_unc_names = 0, conn_index=0, empty_lines=0;
499         const char *p;
500         lpar->retry = torture_setting_int(tctx, "retry",3);
501         lpar->blocksize = torture_setting_int(tctx, "blocksize",65535);
502         lpar->writeblocks = torture_setting_int(tctx, "writeblocks",15);
503         lpar->writeratio = torture_setting_int(tctx, "writeratio",5);
504         lpar->num_parallel_requests = torture_setting_int(
505                 tctx, "parallel_requests", 5);
506         lpar->workgroup = lpcfg_workgroup(tctx->lp_ctx);
507         
508         p = torture_setting_string(tctx, "unclist", NULL);
509         if (p) {
510                 char *h, *s;
511                 unc_list = file_lines_load(p, &num_unc_names, 0, NULL);
512                 if (!unc_list || num_unc_names <= 0) {
513                         torture_comment(tctx, "Failed to load unc names list "
514                                         "from '%s'\n", p);
515                         exit(1);
516                 }
517                 
518                 lpar->unc = talloc_array(tctx, struct unclist *,
519                                          (num_unc_names-empty_lines));
520                 for(conn_index = 0; conn_index < num_unc_names; conn_index++) {
521                         /* ignore empty lines */
522                         if(strlen(unc_list[conn_index % num_unc_names])==0){
523                                 empty_lines++;
524                                 continue;
525                         }
526                         if (!smbcli_parse_unc(
527                                     unc_list[conn_index % num_unc_names],
528                                     NULL, &h, &s)) {
529                                 torture_comment(
530                                         tctx, "Failed to parse UNC "
531                                         "name %s\n",
532                                         unc_list[conn_index % num_unc_names]);
533                                 exit(1);
534                         }
535                         lpar->unc[conn_index-empty_lines] =
536                                 talloc(tctx, struct unclist);
537                         lpar->unc[conn_index-empty_lines]->host = h;
538                         lpar->unc[conn_index-empty_lines]->share = s;   
539                 }
540                 return num_unc_names-empty_lines;
541         }else{
542                 lpar->unc = talloc_array(tctx, struct unclist *, 1);
543                 lpar->unc[0] = talloc(tctx,struct unclist);
544                 lpar->unc[0]->host  = torture_setting_string(tctx, "host",
545                                                              NULL);
546                 lpar->unc[0]->share = torture_setting_string(tctx, "share",
547                                                              NULL);
548                 return 1;
549         }
550 }
551
552 /*
553  Called when the reads & writes are finished. closes the file.
554 */
555 static NTSTATUS benchrw_close(struct torture_context *tctx,
556                               struct smbcli_request *req,
557                               struct benchrw_state *state)
558 {
559         union smb_close close_parms;
560         
561         NT_STATUS_NOT_OK_RETURN(req->status);
562         
563         torture_comment(tctx, "Close file %d (%d)\n",state->nr,state->fnum);
564         close_parms.close.level = RAW_CLOSE_CLOSE;
565         close_parms.close.in.file.fnum = state->fnum ;
566         close_parms.close.in.write_time = 0;
567         state->mode=CLOSE_FILE;
568         
569         req = smb_raw_close_send(state->cli, &close_parms);
570         NT_STATUS_HAVE_NO_MEMORY(req);
571         /*register the callback function!*/
572         req->async.fn = benchrw_callback;
573         req->async.private_data = state;
574         
575         return NT_STATUS_OK;
576 }
577
578 static NTSTATUS benchrw_readwrite(struct torture_context *tctx,
579                                   struct benchrw_state *state);
580 static void benchrw_callback(struct smbcli_request *req);
581
582 static void benchrw_rw_callback(struct smbcli_request *req)
583 {
584         struct benchrw_state *state = req->async.private_data;
585         struct torture_context *tctx = state->tctx;
586
587         if (!NT_STATUS_IS_OK(req->status)) {
588                 state->mode = ERROR;
589                 return;
590         }
591
592         state->completed++;
593         state->num_parallel_requests--;
594
595         if ((state->completed >= torture_numops)
596             && (state->num_parallel_requests == 0)) {
597                 benchrw_callback(req);
598                 talloc_free(req);
599                 return;
600         }
601
602         talloc_free(req);
603
604         if (state->completed + state->num_parallel_requests
605             < torture_numops) {
606                 benchrw_readwrite(tctx, state);
607         }
608 }
609
610 /*
611  Called when the initial write is completed is done. write or read a file.
612 */
613 static NTSTATUS benchrw_readwrite(struct torture_context *tctx,
614                                   struct benchrw_state *state)
615 {
616         struct smbcli_request *req;
617         union smb_read  rd;
618         union smb_write wr;
619         
620         /* randomize between writes and reads*/
621         if (random() % state->lpcfg_params->writeratio == 0) {
622                 torture_comment(tctx, "Callback WRITE file:%d (%d/%d)\n",
623                                 state->nr,state->completed,torture_numops);
624                 wr.generic.level = RAW_WRITE_WRITEX  ;
625                 wr.writex.in.file.fnum  = state->fnum ;
626                 wr.writex.in.offset     = 0;
627                 wr.writex.in.wmode      = 0             ;
628                 wr.writex.in.remaining  = 0;
629                 wr.writex.in.count      = state->lpcfg_params->blocksize;
630                 wr.writex.in.data       = state->buffer;
631                 state->readcnt=0;
632                 req = smb_raw_write_send(state->cli,&wr);
633         }
634         else {
635                 torture_comment(tctx,
636                                 "Callback READ file:%d (%d/%d) Offset:%d\n",
637                                 state->nr,state->completed,torture_numops,
638                                 (state->readcnt*state->lpcfg_params->blocksize));
639                 rd.generic.level = RAW_READ_READX;
640                 rd.readx.in.file.fnum   = state->fnum   ;
641                 rd.readx.in.offset      = state->readcnt*state->lpcfg_params->blocksize;
642                 rd.readx.in.mincnt      = state->lpcfg_params->blocksize;
643                 rd.readx.in.maxcnt      = rd.readx.in.mincnt;
644                 rd.readx.in.remaining   = 0     ;
645                 rd.readx.out.data       = state->buffer;
646                 rd.readx.in.read_for_execute = false;
647                 if(state->readcnt < state->lpcfg_params->writeblocks){
648                         state->readcnt++;       
649                 }else{
650                         /*start reading from beginn of file*/
651                         state->readcnt=0;
652                 }
653                 req = smb_raw_read_send(state->cli,&rd);
654         }
655         state->num_parallel_requests += 1;
656         NT_STATUS_HAVE_NO_MEMORY(req);
657         /*register the callback function!*/
658         req->async.fn = benchrw_rw_callback;
659         req->async.private_data = state;
660         
661         return NT_STATUS_OK;
662 }
663
664 /*
665  Called when the open is done. writes to the file.
666 */
667 static NTSTATUS benchrw_open(struct torture_context *tctx,
668                              struct smbcli_request *req,
669                              struct benchrw_state *state)
670 {
671         union smb_write wr;
672         if(state->mode == OPEN_FILE){
673                 NTSTATUS status;
674                 status = smb_raw_open_recv(req,tctx,(
675                                         union smb_open*)state->req_params);
676                 NT_STATUS_NOT_OK_RETURN(status);
677         
678                 state->fnum = ((union smb_open*)state->req_params)
679                                                 ->openx.out.file.fnum;
680                 torture_comment(tctx, "File opened (%d)\n",state->fnum);
681                 state->mode=INITIAL_WRITE;
682         }
683                 
684         torture_comment(tctx, "Write initial test file:%d (%d/%d)\n",state->nr,
685                 (state->writecnt+1)*state->lpcfg_params->blocksize,
686                 (state->lpcfg_params->writeblocks*state->lpcfg_params->blocksize));
687         wr.generic.level = RAW_WRITE_WRITEX  ;
688         wr.writex.in.file.fnum  = state->fnum ;
689         wr.writex.in.offset     = state->writecnt * 
690                                         state->lpcfg_params->blocksize;
691         wr.writex.in.wmode      = 0             ;
692         wr.writex.in.remaining  = (state->lpcfg_params->writeblocks *
693                                                 state->lpcfg_params->blocksize)-
694                                                 ((state->writecnt+1)*state->
695                                                 lpcfg_params->blocksize);
696         wr.writex.in.count      = state->lpcfg_params->blocksize;
697         wr.writex.in.data       = state->buffer;
698         state->writecnt++;
699         if(state->writecnt == state->lpcfg_params->writeblocks){
700                 state->mode=READ_WRITE_DATA;
701         }
702         req = smb_raw_write_send(state->cli,&wr);
703         NT_STATUS_HAVE_NO_MEMORY(req);
704         
705         /*register the callback function!*/
706         req->async.fn = benchrw_callback;
707         req->async.private_data = state;
708         return NT_STATUS_OK;
709
710
711 /*
712  Called when the mkdir is done. Opens a file.
713 */
714 static NTSTATUS benchrw_mkdir(struct torture_context *tctx,
715                               struct smbcli_request *req,
716                               struct benchrw_state *state)
717 {
718         union smb_open *open_parms;     
719         uint8_t *writedata;     
720                 
721         NT_STATUS_NOT_OK_RETURN(req->status);
722         
723         /* open/create the files */
724         torture_comment(tctx, "Open File %d/%d\n",state->nr+1,
725                         torture_setting_int(tctx, "nprocs", 4));
726         open_parms=talloc_zero(tctx, union smb_open);
727         NT_STATUS_HAVE_NO_MEMORY(open_parms);
728         open_parms->openx.level = RAW_OPEN_OPENX;
729         open_parms->openx.in.flags = 0;
730         open_parms->openx.in.open_mode = OPENX_MODE_ACCESS_RDWR;
731         open_parms->openx.in.search_attrs = 
732                         FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
733         open_parms->openx.in.file_attrs = 0;
734         open_parms->openx.in.write_time = 0;
735         open_parms->openx.in.open_func = OPENX_OPEN_FUNC_CREATE;
736         open_parms->openx.in.size = 0;
737         open_parms->openx.in.timeout = 0;
738         open_parms->openx.in.fname = state->fname;
739                 
740         writedata = talloc_size(tctx,state->lpcfg_params->blocksize);
741         NT_STATUS_HAVE_NO_MEMORY(writedata);
742         generate_random_buffer(writedata,state->lpcfg_params->blocksize);
743         state->buffer=writedata;
744         state->writecnt=1;
745         state->readcnt=0;
746         state->req_params=open_parms;           
747         state->mode=OPEN_FILE;  
748                         
749         req = smb_raw_open_send(state->cli,open_parms);
750         NT_STATUS_HAVE_NO_MEMORY(req);
751         
752         /*register the callback function!*/
753         req->async.fn = benchrw_callback;
754         req->async.private_data = state;
755                 
756         return NT_STATUS_OK;
757 }
758
759 /*
760  handler for completion of a sub-request of the bench-rw test
761 */
762 static void benchrw_callback(struct smbcli_request *req)
763 {
764         struct benchrw_state *state = req->async.private_data;
765         struct torture_context *tctx = state->tctx;
766         
767         /*dont send new requests when torture_numops is reached*/
768         if ((state->mode == READ_WRITE_DATA)
769             && (state->completed >= torture_numops)) {
770                 state->mode=MAX_OPS_REACHED;
771         }
772         
773         switch (state->mode) {
774         
775         case MK_TESTDIR:
776                 if (!NT_STATUS_IS_OK(benchrw_mkdir(tctx, req,state))) {
777                         torture_comment(tctx, "Failed to create the test "
778                                         "directory - %s\n", 
779                                         nt_errstr(req->status));
780                         state->mode=ERROR;
781                         return;
782                 }
783                 break;  
784         case OPEN_FILE:
785         case INITIAL_WRITE:
786                 if (!NT_STATUS_IS_OK(benchrw_open(tctx, req,state))){
787                         torture_comment(tctx, "Failed to open/write the "
788                                         "file - %s\n", 
789                                         nt_errstr(req->status));
790                         state->mode=ERROR;
791                         state->readcnt=0;
792                         return;
793                 }
794                 break;
795         case READ_WRITE_DATA:
796                 while (state->num_parallel_requests
797                        < state->lpcfg_params->num_parallel_requests) {
798                         NTSTATUS status;
799                         status = benchrw_readwrite(tctx,state);
800                         if (!NT_STATUS_IS_OK(status)){
801                                 torture_comment(tctx, "Failed to read/write "
802                                                 "the file - %s\n", 
803                                                 nt_errstr(req->status));
804                                 state->mode=ERROR;
805                                 return;
806                         }
807                 }
808                 break;
809         case MAX_OPS_REACHED:
810                 if (!NT_STATUS_IS_OK(benchrw_close(tctx,req,state))){
811                         torture_comment(tctx, "Failed to read/write/close "
812                                         "the file - %s\n", 
813                                         nt_errstr(req->status));
814                         state->mode=ERROR;
815                         return;
816                 }
817                 break;
818         case CLOSE_FILE:
819                 torture_comment(tctx, "File %d closed\n",state->nr);
820                 if (!NT_STATUS_IS_OK(req->status)) {
821                         torture_comment(tctx, "Failed to close the "
822                                         "file - %s\n",
823                                         nt_errstr(req->status));
824                         state->mode=ERROR;
825                         return;
826                 }
827                 state->mode=CLEANUP;
828                 return; 
829         default:
830                 break;
831         }
832         
833 }
834
835 /* open connection async callback function*/
836 static void async_open_callback(struct composite_context *con)
837 {
838         struct benchrw_state *state = con->async.private_data;
839         struct torture_context *tctx = state->tctx;
840         int retry = state->lpcfg_params->retry;
841                 
842         if (NT_STATUS_IS_OK(con->status)) {
843                 state->cli=((struct smb_composite_connect*)
844                                         state->req_params)->out.tree;
845                 state->mode=CLEANUP_TESTDIR;
846         }else{
847                 if(state->writecnt < retry){
848                         torture_comment(tctx, "Failed to open connection: "
849                                         "%d, Retry (%d/%d)\n",
850                                         state->nr,state->writecnt,retry);
851                         state->writecnt++;
852                         state->mode=START;
853                         usleep(1000);   
854                 }else{
855                         torture_comment(tctx, "Failed to open connection "
856                                         "(%d) - %s\n",
857                                         state->nr, nt_errstr(con->status));
858                         state->mode=ERROR;
859                 }
860                 return;
861         }       
862 }
863
864 /*
865  establishs a smbcli_tree from scratch (async)
866 */
867 static struct composite_context *torture_connect_async(
868                                 struct torture_context *tctx,
869                                 struct smb_composite_connect *smb,
870                                 TALLOC_CTX *mem_ctx,
871                                 struct tevent_context *ev,
872                                 const char *host,
873                                 const char *share,
874                                 const char *workgroup)
875 {
876         torture_comment(tctx, "Open Connection to %s/%s\n",host,share);
877         smb->in.dest_host=talloc_strdup(mem_ctx,host);
878         smb->in.service=talloc_strdup(mem_ctx,share);
879         smb->in.dest_ports=lpcfg_smb_ports(tctx->lp_ctx);
880         smb->in.socket_options = lpcfg_socket_options(tctx->lp_ctx);
881         smb->in.called_name = strupper_talloc(mem_ctx, host);
882         smb->in.service_type=NULL;
883         smb->in.credentials=cmdline_credentials;
884         smb->in.fallback_to_anonymous=false;
885         smb->in.gensec_settings = lpcfg_gensec_settings(mem_ctx, tctx->lp_ctx);
886         smb->in.workgroup=workgroup;
887         lpcfg_smbcli_options(tctx->lp_ctx, &smb->in.options);
888         lpcfg_smbcli_session_options(tctx->lp_ctx, &smb->in.session_options);
889         
890         return smb_composite_connect_send(smb,mem_ctx,
891                                           lpcfg_resolve_context(tctx->lp_ctx),ev);
892 }
893
894 bool run_benchrw(struct torture_context *tctx)
895 {
896         struct smb_composite_connect *smb_con;
897         const char *fname = "\\rwtest.dat";
898         struct smbcli_request *req;
899         struct benchrw_state **state;
900         int i , num_unc_names;
901         struct tevent_context   *ev     ;       
902         struct composite_context *req1;
903         struct params lpparams;
904         union smb_mkdir parms;
905         int finished = 0;
906         bool success=true;
907         int torture_nprocs = torture_setting_int(tctx, "nprocs", 4);
908         
909         torture_comment(tctx, "Start BENCH-READWRITE num_ops=%d "
910                         "num_nprocs=%d\n",
911                         torture_numops, torture_nprocs);
912
913         /*init talloc context*/
914         ev = tctx->ev;
915         state = talloc_array(tctx, struct benchrw_state *, torture_nprocs);
916
917         /* init params using lpcfg_parm_xxx */
918         num_unc_names = init_benchrw_params(tctx,&lpparams);
919         
920         /* init private data structs*/
921         for(i = 0; i<torture_nprocs;i++){
922                 state[i]=talloc(tctx,struct benchrw_state);
923                 state[i]->tctx = tctx;
924                 state[i]->completed=0;
925                 state[i]->num_parallel_requests=0;
926                 state[i]->lpcfg_params=&lpparams;
927                 state[i]->nr=i;
928                 state[i]->dname=talloc_asprintf(tctx,"benchrw%d",i);
929                 state[i]->fname=talloc_asprintf(tctx,"%s%s",
930                                                 state[i]->dname,fname); 
931                 state[i]->mode=START;
932                 state[i]->writecnt=0;
933         }
934         
935         torture_comment(tctx, "Starting async requests\n");     
936         while(finished != torture_nprocs){
937                 finished=0;
938                 for(i = 0; i<torture_nprocs;i++){
939                         switch (state[i]->mode){
940                         /*open multiple connections with the same userid */
941                         case START:
942                                 smb_con = talloc(
943                                         tctx,struct smb_composite_connect) ;
944                                 state[i]->req_params=smb_con; 
945                                 state[i]->mode=OPEN_CONNECTION;
946                                 req1 = torture_connect_async(
947                                         tctx, smb_con, tctx,ev,
948                                         lpparams.unc[i % num_unc_names]->host,
949                                         lpparams.unc[i % num_unc_names]->share,
950                                         lpparams.workgroup);
951                                 /* register callback fn + private data */
952                                 req1->async.fn = async_open_callback;
953                                 req1->async.private_data=state[i];
954                                 break;
955                         /*setup test dirs (sync)*/
956                         case CLEANUP_TESTDIR:
957                                 torture_comment(tctx, "Setup test dir %d\n",i);
958                                 smb_raw_exit(state[i]->cli->session);
959                                 if (smbcli_deltree(state[i]->cli, 
960                                                 state[i]->dname) == -1) {
961                                         torture_comment(
962                                                 tctx,
963                                                 "Unable to delete %s - %s\n", 
964                                                 state[i]->dname,
965                                                 smbcli_errstr(state[i]->cli));
966                                         state[i]->mode=ERROR;
967                                         break;
968                                 }
969                                 state[i]->mode=MK_TESTDIR;
970                                 parms.mkdir.level = RAW_MKDIR_MKDIR;
971                                 parms.mkdir.in.path = state[i]->dname;
972                                 req = smb_raw_mkdir_send(state[i]->cli,&parms);
973                                 /* register callback fn + private data */
974                                 req->async.fn = benchrw_callback;
975                                 req->async.private_data=state[i];
976                                 break;
977                         /* error occured , finish */
978                         case ERROR:
979                                 finished++;
980                                 success=false;
981                                 break;
982                         /* cleanup , close connection */
983                         case CLEANUP:
984                                 torture_comment(tctx, "Deleting test dir %s "
985                                                 "%d/%d\n",state[i]->dname,
986                                                 i+1,torture_nprocs);
987                                 smbcli_deltree(state[i]->cli,state[i]->dname);
988                                 if (NT_STATUS_IS_ERR(smb_tree_disconnect(
989                                                              state[i]->cli))) {
990                                         torture_comment(tctx, "ERROR: Tree "
991                                                         "disconnect failed");
992                                         state[i]->mode=ERROR;
993                                         break;
994                                 }
995                                 state[i]->mode=FINISHED;
996                         case FINISHED:
997                                 finished++;
998                                 break;
999                         default:
1000                                 tevent_loop_once(ev);
1001                         }
1002                 }
1003         }
1004                                 
1005         return success; 
1006 }
1007