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