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