source4/ntvfs/nbench/vfs_nbench.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    a pass-thru NTVFS module to record a NBENCH load file
   5
   6    Copyright (C) Andrew Tridgell 2004
   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 3 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, see <http://www.gnu.org/licenses/>.
  20 */
  21
  22 /*
  23   "passthru" in this module refers to the next level of NTVFS being used
  24 */
  25
  26 #include "includes.h"
  27 #include "ntvfs/ntvfs.h"
  28 #include "system/filesys.h"
  29
  30 NTSTATUS ntvfs_nbench_init(void);
  31
  32 /* this is stored in ntvfs_private */
  33 struct nbench_private {
  34         int log_fd;
  35 };
  36
  37 /*
  38   log one request to the nbench log
  39 */
  40 static void nbench_log(struct ntvfs_request *req,
  41                        const char *format, ...) PRINTF_ATTRIBUTE(2, 3);
  42
  43 static void nbench_log(struct ntvfs_request *req,
  44                        const char *format, ...)
  45 {
  46         struct nbench_private *nprivates = req->async_states->ntvfs->private_data;
  47         va_list ap;
  48         char *s = NULL;
  49
  50         va_start(ap, format);
  51         vasprintf(&s, format, ap);
  52         va_end(ap);
  53
  54         write(nprivates->log_fd, s, strlen(s));
  55         free(s);
  56 }
  57
  58 static char *nbench_ntvfs_handle_string(struct ntvfs_request *req, struct ntvfs_handle *h)
  59 {
  60         DATA_BLOB key;
  61         uint16_t fnum = 0;
  62
  63         key = ntvfs_handle_get_wire_key(h, req);
  64
  65         switch (key.length) {
  66         case 2: /* SMB fnum */
  67                 fnum = SVAL(key.data, 0);
  68                 break;
  69         default:
  70                 DEBUG(0,("%s: invalid wire handle size: %u\n",
  71                         __FUNCTION__, (unsigned)key.length));
  72                 break;
  73         }
  74
  75         return talloc_asprintf(req, "%u", fnum);
  76 }
  77
  78 /*
  79   this pass through macro operates on request contexts, and disables
  80   async calls.
  81
  82   async calls are a pain for the nbench module as it makes pulling the
  83   status code and any result parameters much harder.
  84 */
  85 #define PASS_THRU_REQ_PRE_ASYNC(ntvfs, req, op, par1) do { \
  86         status = ntvfs_async_state_push(ntvfs, req, par1, nbench_##op##_send); \
  87         if (!NT_STATUS_IS_OK(status)) { \
  88                 return status; \
  89         } \
  90 } while (0)
  91
  92 #define PASS_THRU_REQ_POST_ASYNC(req) do { \
  93         req->async_states->status = status; \
  94         if (!(req->async_states->state & NTVFS_ASYNC_STATE_ASYNC)) { \
  95                 req->async_states->send_fn(req); \
  96         } \
  97 } while (0)
  98
  99 #define PASS_THRU_REQ(ntvfs, req, op, par1, args) do { \
 100         PASS_THRU_REQ_PRE_ASYNC(ntvfs, req, op, par1); \
 101         status = ntvfs_next_##op args; \
 102         PASS_THRU_REQ_POST_ASYNC(req); \
 103 } while (0)
 104
 105 #define PASS_THRU_REP_POST(req) do { \
 106         ntvfs_async_state_pop(req); \
 107         if (req->async_states->state & NTVFS_ASYNC_STATE_ASYNC) { \
 108                 req->async_states->send_fn(req); \
 109         } \
 110 } while (0)
 111
 112 /*
 113   connect to a share - used when a tree_connect operation comes in.
 114 */
 115 static NTSTATUS nbench_connect(struct ntvfs_module_context *ntvfs,
 116                                struct ntvfs_request *req,
 117                                union smb_tcon* con)
 118 {
 119         struct nbench_private *nprivates;
 120         NTSTATUS status;
 121         char *logname = NULL;
 122
 123         nprivates = talloc(ntvfs, struct nbench_private);
 124         if (!nprivates) {
 125                 return NT_STATUS_NO_MEMORY;
 126         }
 127
 128         logname = talloc_asprintf(req, "/tmp/nbenchlog%d.%u", ntvfs->depth,
 129                                   getpid());
 130         NT_STATUS_HAVE_NO_MEMORY(logname);
 131         nprivates->log_fd = open(logname, O_WRONLY|O_CREAT|O_APPEND, 0644);
 132         talloc_free(logname);
 133
 134         if (nprivates->log_fd == -1) {
 135                 DEBUG(0,("Failed to open nbench log\n"));
 136                 return NT_STATUS_UNSUCCESSFUL;
 137         }
 138
 139         ntvfs->private_data = nprivates;
 140
 141         status = ntvfs_next_connect(ntvfs, req, con);
 142
 143         return status;
 144 }
 145
 146 /*
 147   disconnect from a share
 148 */
 149 static NTSTATUS nbench_disconnect(struct ntvfs_module_context *ntvfs)
 150 {
 151         struct nbench_private *nprivates = ntvfs->private_data;
 152         NTSTATUS status;
 153
 154         close(nprivates->log_fd);
 155
 156         status = ntvfs_next_disconnect(ntvfs);
 157
 158         return status;
 159 }
 160
 161 /*
 162   delete a file - the dirtype specifies the file types to include in the search.
 163   The name can contain CIFS wildcards, but rarely does (except with OS/2 clients)
 164 */
 165 static void nbench_unlink_send(struct ntvfs_request *req)
 166 {
 167         union smb_unlink *unl = req->async_states->private_data;
 168         nbench_log(req, "Unlink \"%s\" 0x%x %s\n",
 169                    unl->unlink.in.pattern, unl->unlink.in.attrib,
 170                    get_nt_error_c_code(req, req->async_states->status));
 171
 172         PASS_THRU_REP_POST(req);
 173 }
 174
 175 static NTSTATUS nbench_unlink(struct ntvfs_module_context *ntvfs,
 176                               struct ntvfs_request *req,
 177                               union smb_unlink *unl)
 178 {
 179         NTSTATUS status;
 180
 181         PASS_THRU_REQ(ntvfs, req, unlink, unl, (ntvfs, req, unl));
 182
 183         return status;
 184 }
 185
 186 /*
 187   ioctl interface
 188 */
 189 static void nbench_ioctl_send(struct ntvfs_request *req)
 190 {
 191         nbench_log(req, "Ioctl - NOT HANDLED\n");
 192
 193         PASS_THRU_REP_POST(req);
 194 }
 195
 196 static NTSTATUS nbench_ioctl(struct ntvfs_module_context *ntvfs,
 197                              struct ntvfs_request *req, union smb_ioctl *io)
 198 {
 199         NTSTATUS status;
 200
 201         PASS_THRU_REQ(ntvfs, req, ioctl, io, (ntvfs, req, io));
 202
 203         return status;
 204 }
 205
 206 /*
 207   check if a directory exists
 208 */
 209 static void nbench_chkpath_send(struct ntvfs_request *req)
 210 {
 211         union smb_chkpath *cp = req->async_states->private_data;
 212
 213         nbench_log(req, "Chkpath \"%s\" %s\n",
 214                    cp->chkpath.in.path,
 215                    get_nt_error_c_code(req, req->async_states->status));
 216
 217         PASS_THRU_REP_POST(req);
 218 }
 219
 220 static NTSTATUS nbench_chkpath(struct ntvfs_module_context *ntvfs,
 221                                struct ntvfs_request *req,
 222                                union smb_chkpath *cp)
 223 {
 224         NTSTATUS status;
 225
 226         PASS_THRU_REQ(ntvfs, req, chkpath, cp, (ntvfs, req, cp));
 227
 228         return status;
 229 }
 230
 231 /*
 232   return info on a pathname
 233 */
 234 static void nbench_qpathinfo_send(struct ntvfs_request *req)
 235 {
 236         union smb_fileinfo *info = req->async_states->private_data;
 237
 238         nbench_log(req, "QUERY_PATH_INFORMATION \"%s\" %d %s\n",
 239                    info->generic.in.file.path,
 240                    info->generic.level,
 241                    get_nt_error_c_code(req, req->async_states->status));
 242
 243         PASS_THRU_REP_POST(req);
 244 }
 245
 246 static NTSTATUS nbench_qpathinfo(struct ntvfs_module_context *ntvfs,
 247                                  struct ntvfs_request *req, union smb_fileinfo *info)
 248 {
 249         NTSTATUS status;
 250
 251         PASS_THRU_REQ(ntvfs, req, qpathinfo, info, (ntvfs, req, info));
 252
 253         return status;
 254 }
 255
 256 /*
 257   query info on a open file
 258 */
 259 static void nbench_qfileinfo_send(struct ntvfs_request *req)
 260 {
 261         union smb_fileinfo *info = req->async_states->private_data;
 262
 263         nbench_log(req, "QUERY_FILE_INFORMATION %s %d %s\n",
 264                    nbench_ntvfs_handle_string(req, info->generic.in.file.ntvfs),
 265                    info->generic.level,
 266                    get_nt_error_c_code(req, req->async_states->status));
 267
 268         PASS_THRU_REP_POST(req);
 269 }
 270
 271 static NTSTATUS nbench_qfileinfo(struct ntvfs_module_context *ntvfs,
 272                                  struct ntvfs_request *req, union smb_fileinfo *info)
 273 {
 274         NTSTATUS status;
 275
 276         PASS_THRU_REQ(ntvfs, req, qfileinfo, info, (ntvfs, req, info));
 277
 278         return status;
 279 }
 280
 281 /*
 282   set info on a pathname
 283 */
 284 static void nbench_setpathinfo_send(struct ntvfs_request *req)
 285 {
 286         union smb_setfileinfo *st = req->async_states->private_data;
 287
 288         nbench_log(req, "SET_PATH_INFORMATION \"%s\" %d %s\n",
 289                    st->generic.in.file.path,
 290                    st->generic.level,
 291                    get_nt_error_c_code(req, req->async_states->status));
 292
 293         PASS_THRU_REP_POST(req);
 294 }
 295
 296 static NTSTATUS nbench_setpathinfo(struct ntvfs_module_context *ntvfs,
 297                                    struct ntvfs_request *req, union smb_setfileinfo *st)
 298 {
 299         NTSTATUS status;
 300
 301         PASS_THRU_REQ(ntvfs, req, setpathinfo, st, (ntvfs, req, st));
 302
 303         return status;
 304 }
 305
 306 /*
 307   open a file
 308 */
 309 static void nbench_open_send(struct ntvfs_request *req)
 310 {
 311         union smb_open *io = req->async_states->private_data;
 312
 313         switch (io->generic.level) {
 314         case RAW_OPEN_NTCREATEX:
 315                 if (!NT_STATUS_IS_OK(req->async_states->status)) {
 316                         ZERO_STRUCT(io->ntcreatex.out);
 317                 }
 318                 nbench_log(req, "NTCreateX \"%s\" 0x%x 0x%x %s %s\n",
 319                            io->ntcreatex.in.fname,
 320                            io->ntcreatex.in.create_options,
 321                            io->ntcreatex.in.open_disposition,
 322                            nbench_ntvfs_handle_string(req, io->ntcreatex.out.file.ntvfs),
 323                            get_nt_error_c_code(req, req->async_states->status));
 324                 break;
 325
 326         default:
 327                 nbench_log(req, "Open-%d - NOT HANDLED\n",
 328                            io->generic.level);
 329                 break;
 330         }
 331
 332         PASS_THRU_REP_POST(req);
 333 }
 334
 335 static NTSTATUS nbench_open(struct ntvfs_module_context *ntvfs,
 336                             struct ntvfs_request *req, union smb_open *io)
 337 {
 338         NTSTATUS status;
 339
 340 #undef open /* AIX defines open to be open64 */
 341         PASS_THRU_REQ(ntvfs, req, open, io, (ntvfs, req, io));
 342
 343         return status;
 344 }
 345
 346 /*
 347   create a directory
 348 */
 349 static void nbench_mkdir_send(struct ntvfs_request *req)
 350 {
 351         nbench_log(req, "Mkdir - NOT HANDLED\n");
 352
 353         PASS_THRU_REP_POST(req);
 354 }
 355
 356 static NTSTATUS nbench_mkdir(struct ntvfs_module_context *ntvfs,
 357                              struct ntvfs_request *req, union smb_mkdir *md)
 358 {
 359         NTSTATUS status;
 360
 361         PASS_THRU_REQ(ntvfs, req, mkdir, md, (ntvfs, req, md));
 362
 363         return status;
 364 }
 365
 366 /*
 367   remove a directory
 368 */
 369 static void nbench_rmdir_send(struct ntvfs_request *req)
 370 {
 371         struct smb_rmdir *rd = req->async_states->private_data;
 372
 373         nbench_log(req, "Rmdir \"%s\" %s\n",
 374                    rd->in.path,
 375                    get_nt_error_c_code(req, req->async_states->status));
 376
 377         PASS_THRU_REP_POST(req);
 378 }
 379
 380 static NTSTATUS nbench_rmdir(struct ntvfs_module_context *ntvfs,
 381                              struct ntvfs_request *req, struct smb_rmdir *rd)
 382 {
 383         NTSTATUS status;
 384
 385         PASS_THRU_REQ(ntvfs, req, rmdir, rd, (ntvfs, req, rd));
 386
 387         return status;
 388 }
 389
 390 /*
 391   rename a set of files
 392 */
 393 static void nbench_rename_send(struct ntvfs_request *req)
 394 {
 395         union smb_rename *ren = req->async_states->private_data;
 396
 397         switch (ren->generic.level) {
 398         case RAW_RENAME_RENAME:
 399                 nbench_log(req, "Rename \"%s\" \"%s\" %s\n",
 400                            ren->rename.in.pattern1,
 401                            ren->rename.in.pattern2,
 402                            get_nt_error_c_code(req, req->async_states->status));
 403                 break;
 404
 405         default:
 406                 nbench_log(req, "Rename-%d - NOT HANDLED\n",
 407                            ren->generic.level);
 408                 break;
 409         }
 410
 411         PASS_THRU_REP_POST(req);
 412 }
 413
 414 static NTSTATUS nbench_rename(struct ntvfs_module_context *ntvfs,
 415                               struct ntvfs_request *req, union smb_rename *ren)
 416 {
 417         NTSTATUS status;
 418
 419         PASS_THRU_REQ(ntvfs, req, rename, ren, (ntvfs, req, ren));
 420
 421         return status;
 422 }
 423
 424 /*
 425   copy a set of files
 426 */
 427 static void nbench_copy_send(struct ntvfs_request *req)
 428 {
 429         nbench_log(req, "Copy - NOT HANDLED\n");
 430
 431         PASS_THRU_REP_POST(req);
 432 }
 433
 434 static NTSTATUS nbench_copy(struct ntvfs_module_context *ntvfs,
 435                             struct ntvfs_request *req, struct smb_copy *cp)
 436 {
 437         NTSTATUS status;
 438
 439         PASS_THRU_REQ(ntvfs, req, copy, cp, (ntvfs, req, cp));
 440
 441         return status;
 442 }
 443
 444 /*
 445   read from a file
 446 */
 447 static void nbench_read_send(struct ntvfs_request *req)
 448 {
 449         union smb_read *rd = req->async_states->private_data;
 450
 451         switch (rd->generic.level) {
 452         case RAW_READ_READX:
 453                 if (!NT_STATUS_IS_OK(req->async_states->status)) {
 454                         ZERO_STRUCT(rd->readx.out);
 455                 }
 456                 nbench_log(req, "ReadX %s %d %d %d %s\n",
 457                            nbench_ntvfs_handle_string(req, rd->readx.in.file.ntvfs),
 458                            (int)rd->readx.in.offset,
 459                            rd->readx.in.maxcnt,
 460                            rd->readx.out.nread,
 461                            get_nt_error_c_code(req, req->async_states->status));
 462                 break;
 463         default:
 464                 nbench_log(req, "Read-%d - NOT HANDLED\n",
 465                            rd->generic.level);
 466                 break;
 467         }
 468
 469         PASS_THRU_REP_POST(req);
 470 }
 471
 472 static NTSTATUS nbench_read(struct ntvfs_module_context *ntvfs,
 473                             struct ntvfs_request *req, union smb_read *rd)
 474 {
 475         NTSTATUS status;
 476
 477         PASS_THRU_REQ(ntvfs, req, read, rd, (ntvfs, req, rd));
 478
 479         return status;
 480 }
 481
 482 /*
 483   write to a file
 484 */
 485 static void nbench_write_send(struct ntvfs_request *req)
 486 {
 487         union smb_write *wr = req->async_states->private_data;
 488
 489         switch (wr->generic.level) {
 490         case RAW_WRITE_WRITEX:
 491                 if (!NT_STATUS_IS_OK(req->async_states->status)) {
 492                         ZERO_STRUCT(wr->writex.out);
 493                 }
 494                 nbench_log(req, "WriteX %s %d %d %d %s\n",
 495                            nbench_ntvfs_handle_string(req, wr->writex.in.file.ntvfs),
 496                            (int)wr->writex.in.offset,
 497                            wr->writex.in.count,
 498                            wr->writex.out.nwritten,
 499                            get_nt_error_c_code(req, req->async_states->status));
 500                 break;
 501
 502         case RAW_WRITE_WRITE:
 503                 if (!NT_STATUS_IS_OK(req->async_states->status)) {
 504                         ZERO_STRUCT(wr->write.out);
 505                 }
 506                 nbench_log(req, "Write %s %d %d %d %s\n",
 507                            nbench_ntvfs_handle_string(req, wr->write.in.file.ntvfs),
 508                            wr->write.in.offset,
 509                            wr->write.in.count,
 510                            wr->write.out.nwritten,
 511                            get_nt_error_c_code(req, req->async_states->status));
 512                 break;
 513
 514         default:
 515                 nbench_log(req, "Write-%d - NOT HANDLED\n",
 516                            wr->generic.level);
 517                 break;
 518         }
 519
 520         PASS_THRU_REP_POST(req);
 521 }
 522
 523 static NTSTATUS nbench_write(struct ntvfs_module_context *ntvfs,
 524                              struct ntvfs_request *req, union smb_write *wr)
 525 {
 526         NTSTATUS status;
 527
 528         PASS_THRU_REQ(ntvfs, req, write, wr, (ntvfs, req, wr));
 529
 530         return status;
 531 }
 532
 533 /*
 534   seek in a file
 535 */
 536 static void nbench_seek_send(struct ntvfs_request *req)
 537 {
 538         nbench_log(req, "Seek - NOT HANDLED\n");
 539
 540         PASS_THRU_REP_POST(req);
 541 }
 542
 543 static NTSTATUS nbench_seek(struct ntvfs_module_context *ntvfs,
 544                             struct ntvfs_request *req,
 545                             union smb_seek *io)
 546 {
 547         NTSTATUS status;
 548
 549         PASS_THRU_REQ(ntvfs, req, seek, io, (ntvfs, req, io));
 550
 551         return status;
 552 }
 553
 554 /*
 555   flush a file
 556 */
 557 static void nbench_flush_send(struct ntvfs_request *req)
 558 {
 559         union smb_flush *io = req->async_states->private_data;
 560
 561         switch (io->generic.level) {
 562         case RAW_FLUSH_FLUSH:
 563                 nbench_log(req, "Flush %s %s\n",
 564                            nbench_ntvfs_handle_string(req, io->flush.in.file.ntvfs),
 565                            get_nt_error_c_code(req, req->async_states->status));
 566                 break;
 567         case RAW_FLUSH_ALL:
 568                 nbench_log(req, "Flush %d %s\n",
 569                            0xFFFF,
 570                            get_nt_error_c_code(req, req->async_states->status));
 571                 break;
 572         default:
 573                 nbench_log(req, "Flush-%d - NOT HANDLED\n",
 574                            io->generic.level);
 575                 break;
 576         }
 577
 578         PASS_THRU_REP_POST(req);
 579 }
 580
 581 static NTSTATUS nbench_flush(struct ntvfs_module_context *ntvfs,
 582                              struct ntvfs_request *req,
 583                              union smb_flush *io)
 584 {
 585         NTSTATUS status;
 586
 587         PASS_THRU_REQ(ntvfs, req, flush, io, (ntvfs, req, io));
 588
 589         return status;
 590 }
 591
 592 /*
 593   close a file
 594 */
 595 static void nbench_close_send(struct ntvfs_request *req)
 596 {
 597         union smb_close *io = req->async_states->private_data;
 598
 599         switch (io->generic.level) {
 600         case RAW_CLOSE_CLOSE:
 601                 nbench_log(req, "Close %s %s\n",
 602                            nbench_ntvfs_handle_string(req, io->close.in.file.ntvfs),
 603                            get_nt_error_c_code(req, req->async_states->status));
 604                 break;
 605
 606         default:
 607                 nbench_log(req, "Close-%d - NOT HANDLED\n",
 608                            io->generic.level);
 609                 break;
 610         }
 611
 612         PASS_THRU_REP_POST(req);
 613 }
 614
 615 static NTSTATUS nbench_close(struct ntvfs_module_context *ntvfs,
 616                              struct ntvfs_request *req, union smb_close *io)
 617 {
 618         NTSTATUS status;
 619
 620         PASS_THRU_REQ(ntvfs, req, close, io, (ntvfs, req, io));
 621
 622         return status;
 623 }
 624
 625 /*
 626   exit - closing files
 627 */
 628 static void nbench_exit_send(struct ntvfs_request *req)
 629 {
 630         nbench_log(req, "Exit - NOT HANDLED\n");
 631
 632         PASS_THRU_REP_POST(req);
 633 }
 634
 635 static NTSTATUS nbench_exit(struct ntvfs_module_context *ntvfs,
 636                             struct ntvfs_request *req)
 637 {
 638         NTSTATUS status;
 639
 640         PASS_THRU_REQ(ntvfs, req, exit, NULL, (ntvfs, req));
 641
 642         return status;
 643 }
 644
 645 /*
 646   logoff - closing files
 647 */
 648 static void nbench_logoff_send(struct ntvfs_request *req)
 649 {
 650         nbench_log(req, "Logoff - NOT HANDLED\n");
 651
 652         PASS_THRU_REP_POST(req);
 653 }
 654
 655 static NTSTATUS nbench_logoff(struct ntvfs_module_context *ntvfs,
 656                               struct ntvfs_request *req)
 657 {
 658         NTSTATUS status;
 659
 660         PASS_THRU_REQ(ntvfs, req, logoff, NULL, (ntvfs, req));
 661
 662         return status;
 663 }
 664
 665 /*
 666   async_setup - send fn
 667 */
 668 static void nbench_async_setup_send(struct ntvfs_request *req)
 669 {
 670         PASS_THRU_REP_POST(req);
 671 }
 672
 673 /*
 674   async setup
 675 */
 676 static NTSTATUS nbench_async_setup(struct ntvfs_module_context *ntvfs,
 677                                    struct ntvfs_request *req,
 678                                    void *private_data)
 679 {
 680         NTSTATUS status;
 681
 682         PASS_THRU_REQ(ntvfs, req, async_setup, NULL, (ntvfs, req, private_data));
 683
 684         return status;
 685 }
 686
 687
 688 static void nbench_cancel_send(struct ntvfs_request *req)
 689 {
 690         PASS_THRU_REP_POST(req);
 691 }
 692
 693 /*
 694   cancel an existing async request
 695 */
 696 static NTSTATUS nbench_cancel(struct ntvfs_module_context *ntvfs,
 697                               struct ntvfs_request *req)
 698 {
 699         NTSTATUS status;
 700
 701         PASS_THRU_REQ(ntvfs, req, cancel, NULL, (ntvfs, req));
 702
 703         return status;
 704 }
 705
 706 /*
 707   lock a byte range
 708 */
 709 static void nbench_lock_send(struct ntvfs_request *req)
 710 {
 711         union smb_lock *lck = req->async_states->private_data;
 712
 713         if (lck->generic.level == RAW_LOCK_LOCKX &&
 714             lck->lockx.in.lock_cnt == 1 &&
 715             lck->lockx.in.ulock_cnt == 0) {
 716                 nbench_log(req, "LockX %s %d %d %s\n",
 717                            nbench_ntvfs_handle_string(req, lck->lockx.in.file.ntvfs),
 718                            (int)lck->lockx.in.locks[0].offset,
 719                            (int)lck->lockx.in.locks[0].count,
 720                            get_nt_error_c_code(req, req->async_states->status));
 721         } else if (lck->generic.level == RAW_LOCK_LOCKX &&
 722                    lck->lockx.in.ulock_cnt == 1) {
 723                 nbench_log(req, "UnlockX %s %d %d %s\n",
 724                            nbench_ntvfs_handle_string(req, lck->lockx.in.file.ntvfs),
 725                            (int)lck->lockx.in.locks[0].offset,
 726                            (int)lck->lockx.in.locks[0].count,
 727                            get_nt_error_c_code(req, req->async_states->status));
 728         } else {
 729                 nbench_log(req, "Lock-%d - NOT HANDLED\n", lck->generic.level);
 730         }
 731
 732         PASS_THRU_REP_POST(req);
 733 }
 734
 735 static NTSTATUS nbench_lock(struct ntvfs_module_context *ntvfs,
 736                             struct ntvfs_request *req, union smb_lock *lck)
 737 {
 738         NTSTATUS status;
 739
 740         PASS_THRU_REQ(ntvfs, req, lock, lck, (ntvfs, req, lck));
 741
 742         return status;
 743 }
 744
 745 /*
 746   set info on a open file
 747 */
 748 static void nbench_setfileinfo_send(struct ntvfs_request *req)
 749 {
 750         union smb_setfileinfo *info = req->async_states->private_data;
 751
 752         nbench_log(req, "SET_FILE_INFORMATION %s %d %s\n",
 753                    nbench_ntvfs_handle_string(req, info->generic.in.file.ntvfs),
 754                    info->generic.level,
 755                    get_nt_error_c_code(req, req->async_states->status));
 756
 757         PASS_THRU_REP_POST(req);
 758 }
 759
 760 static NTSTATUS nbench_setfileinfo(struct ntvfs_module_context *ntvfs,
 761                                    struct ntvfs_request *req,
 762                                    union smb_setfileinfo *info)
 763 {
 764         NTSTATUS status;
 765
 766         PASS_THRU_REQ(ntvfs, req, setfileinfo, info, (ntvfs, req, info));
 767
 768         return status;
 769 }
 770
 771 /*
 772   return filesystem space info
 773 */
 774 static void nbench_fsinfo_send(struct ntvfs_request *req)
 775 {
 776         union smb_fsinfo *fs = req->async_states->private_data;
 777
 778         nbench_log(req, "QUERY_FS_INFORMATION %d %s\n",
 779                    fs->generic.level,
 780                    get_nt_error_c_code(req, req->async_states->status));
 781
 782         PASS_THRU_REP_POST(req);
 783 }
 784
 785 static NTSTATUS nbench_fsinfo(struct ntvfs_module_context *ntvfs,
 786                               struct ntvfs_request *req, union smb_fsinfo *fs)
 787 {
 788         NTSTATUS status;
 789
 790         PASS_THRU_REQ(ntvfs, req, fsinfo, fs, (ntvfs, req, fs));
 791
 792         return status;
 793 }
 794
 795 /*
 796   return print queue info
 797 */
 798 static void nbench_lpq_send(struct ntvfs_request *req)
 799 {
 800         union smb_lpq *lpq = req->async_states->private_data;
 801
 802         nbench_log(req, "Lpq-%d - NOT HANDLED\n", lpq->generic.level);
 803
 804         PASS_THRU_REP_POST(req);
 805 }
 806
 807 static NTSTATUS nbench_lpq(struct ntvfs_module_context *ntvfs,
 808                            struct ntvfs_request *req, union smb_lpq *lpq)
 809 {
 810         NTSTATUS status;
 811
 812         PASS_THRU_REQ(ntvfs, req, lpq, lpq, (ntvfs, req, lpq));
 813
 814         return status;
 815 }
 816
 817 /*
 818    list files in a directory matching a wildcard pattern
 819 */
 820 static void nbench_search_first_send(struct ntvfs_request *req)
 821 {
 822         union smb_search_first *io = req->async_states->private_data;
 823
 824         switch (io->generic.level) {
 825         case RAW_SEARCH_TRANS2:
 826                 if (NT_STATUS_IS_ERR(req->async_states->status)) {
 827                         ZERO_STRUCT(io->t2ffirst.out);
 828                 }
 829                 nbench_log(req, "FIND_FIRST \"%s\" %d %d %d %s\n",
 830                            io->t2ffirst.in.pattern,
 831                            io->t2ffirst.data_level,
 832                            io->t2ffirst.in.max_count,
 833                            io->t2ffirst.out.count,
 834                            get_nt_error_c_code(req, req->async_states->status));
 835                 break;
 836
 837         default:
 838                 nbench_log(req, "Search-%d - NOT HANDLED\n", io->generic.level);
 839                 break;
 840         }
 841
 842         PASS_THRU_REP_POST(req);
 843 }
 844
 845 static NTSTATUS nbench_search_first(struct ntvfs_module_context *ntvfs,
 846                                     struct ntvfs_request *req, union smb_search_first *io,
 847                                     void *search_private,
 848                                     bool (*callback)(void *, const union smb_search_data *))
 849 {
 850         NTSTATUS status;
 851
 852         PASS_THRU_REQ(ntvfs, req, search_first, io, (ntvfs, req, io, search_private, callback));
 853
 854         return status;
 855 }
 856
 857 /* continue a search */
 858 static void nbench_search_next_send(struct ntvfs_request *req)
 859 {
 860         union smb_search_next *io = req->async_states->private_data;
 861
 862         nbench_log(req, "Searchnext-%d - NOT HANDLED\n", io->generic.level);
 863
 864         PASS_THRU_REP_POST(req);
 865 }
 866
 867 static NTSTATUS nbench_search_next(struct ntvfs_module_context *ntvfs,
 868                                    struct ntvfs_request *req, union smb_search_next *io,
 869                                    void *search_private,
 870                                    bool (*callback)(void *, const union smb_search_data *))
 871 {
 872         NTSTATUS status;
 873
 874         PASS_THRU_REQ(ntvfs, req, search_next, io, (ntvfs, req, io, search_private, callback));
 875
 876         return status;
 877 }
 878
 879 /* close a search */
 880 static void nbench_search_close_send(struct ntvfs_request *req)
 881 {
 882         union smb_search_close *io = req->async_states->private_data;
 883
 884         nbench_log(req, "Searchclose-%d - NOT HANDLED\n", io->generic.level);
 885
 886         PASS_THRU_REP_POST(req);
 887 }
 888
 889 static NTSTATUS nbench_search_close(struct ntvfs_module_context *ntvfs,
 890                                     struct ntvfs_request *req, union smb_search_close *io)
 891 {
 892         NTSTATUS status;
 893
 894         PASS_THRU_REQ(ntvfs, req, search_close, io, (ntvfs, req, io));
 895
 896         return status;
 897 }
 898
 899 /* SMBtrans - not used on file shares */
 900 static void nbench_trans_send(struct ntvfs_request *req)
 901 {
 902         nbench_log(req, "Trans - NOT HANDLED\n");
 903
 904         PASS_THRU_REP_POST(req);
 905 }
 906
 907 static NTSTATUS nbench_trans(struct ntvfs_module_context *ntvfs,
 908                              struct ntvfs_request *req, struct smb_trans2 *trans2)
 909 {
 910         NTSTATUS status;
 911
 912         PASS_THRU_REQ(ntvfs, req, trans, trans2, (ntvfs, req, trans2));
 913
 914         return status;
 915 }
 916
 917 /*
 918   initialise the nbench backend, registering ourselves with the ntvfs subsystem
 919  */
 920 NTSTATUS ntvfs_nbench_init(void)
 921 {
 922         NTSTATUS ret;
 923         struct ntvfs_ops ops;
 924         NTVFS_CURRENT_CRITICAL_SIZES(vers);
 925
 926         ZERO_STRUCT(ops);
 927
 928         /* fill in the name and type */
 929         ops.name = "nbench";
 930         ops.type = NTVFS_DISK;
 931
 932         /* fill in all the operations */
 933         ops.connect = nbench_connect;
 934         ops.disconnect = nbench_disconnect;
 935         ops.unlink = nbench_unlink;
 936         ops.chkpath = nbench_chkpath;
 937         ops.qpathinfo = nbench_qpathinfo;
 938         ops.setpathinfo = nbench_setpathinfo;
 939         ops.open = nbench_open;
 940         ops.mkdir = nbench_mkdir;
 941         ops.rmdir = nbench_rmdir;
 942         ops.rename = nbench_rename;
 943         ops.copy = nbench_copy;
 944         ops.ioctl = nbench_ioctl;
 945         ops.read = nbench_read;
 946         ops.write = nbench_write;
 947         ops.seek = nbench_seek;
 948         ops.flush = nbench_flush;
 949         ops.close = nbench_close;
 950         ops.exit = nbench_exit;
 951         ops.lock = nbench_lock;
 952         ops.setfileinfo = nbench_setfileinfo;
 953         ops.qfileinfo = nbench_qfileinfo;
 954         ops.fsinfo = nbench_fsinfo;
 955         ops.lpq = nbench_lpq;
 956         ops.search_first = nbench_search_first;
 957         ops.search_next = nbench_search_next;
 958         ops.search_close = nbench_search_close;
 959         ops.trans = nbench_trans;
 960         ops.logoff = nbench_logoff;
 961         ops.async_setup = nbench_async_setup;
 962         ops.cancel = nbench_cancel;
 963
 964         /* we don't register a trans2 handler as we want to be able to
 965            log individual trans2 requests */
 966         ops.trans2 = NULL;
 967
 968         /* register ourselves with the NTVFS subsystem. */
 969         ret = ntvfs_register(&ops, &vers);
 970
 971         if (!NT_STATUS_IS_OK(ret)) {
 972                 DEBUG(0,("Failed to register nbench backend!\n"));
 973         }
 974
 975         return ret;
 976 }