2 Unix SMB/CIFS implementation.
4 a pass-thru NTVFS module to record a NBENCH load file
6 Copyright (C) Andrew Tridgell 2004
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.
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.
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/>.
23 "passthru" in this module refers to the next level of NTVFS being used
27 #include "ntvfs/ntvfs.h"
28 #include "system/filesys.h"
30 /* this is stored in ntvfs_private */
31 struct nbench_private {
36 log one request to the nbench log
38 static void nbench_log(struct ntvfs_request *req,
39 const char *format, ...) PRINTF_ATTRIBUTE(2, 3);
41 static void nbench_log(struct ntvfs_request *req,
42 const char *format, ...)
44 struct nbench_private *nprivates = req->async_states->ntvfs->private_data;
49 vasprintf(&s, format, ap);
52 write(nprivates->log_fd, s, strlen(s));
56 static char *nbench_ntvfs_handle_string(struct ntvfs_request *req, struct ntvfs_handle *h)
61 key = ntvfs_handle_get_wire_key(h, req);
64 case 2: /* SMB fnum */
65 fnum = SVAL(key.data, 0);
68 DEBUG(0,("%s: invalid wire handle size: %u\n",
69 __FUNCTION__, (unsigned)key.length));
73 return talloc_asprintf(req, "%u", fnum);
77 this pass through macro operates on request contexts, and disables
80 async calls are a pain for the nbench module as it makes pulling the
81 status code and any result parameters much harder.
83 #define PASS_THRU_REQ_PRE_ASYNC(ntvfs, req, op, par1) do { \
84 status = ntvfs_async_state_push(ntvfs, req, par1, nbench_##op##_send); \
85 if (!NT_STATUS_IS_OK(status)) { \
90 #define PASS_THRU_REQ_POST_ASYNC(req) do { \
91 req->async_states->status = status; \
92 if (!(req->async_states->state & NTVFS_ASYNC_STATE_ASYNC)) { \
93 req->async_states->send_fn(req); \
97 #define PASS_THRU_REQ(ntvfs, req, op, par1, args) do { \
98 PASS_THRU_REQ_PRE_ASYNC(ntvfs, req, op, par1); \
99 status = ntvfs_next_##op args; \
100 PASS_THRU_REQ_POST_ASYNC(req); \
103 #define PASS_THRU_REP_POST(req) do { \
104 ntvfs_async_state_pop(req); \
105 if (req->async_states->state & NTVFS_ASYNC_STATE_ASYNC) { \
106 req->async_states->send_fn(req); \
111 connect to a share - used when a tree_connect operation comes in.
113 static NTSTATUS nbench_connect(struct ntvfs_module_context *ntvfs,
114 struct ntvfs_request *req,
117 struct nbench_private *nprivates;
119 char *logname = NULL;
121 nprivates = talloc(ntvfs, struct nbench_private);
123 return NT_STATUS_NO_MEMORY;
126 asprintf(&logname, "/tmp/nbenchlog%d.%u", ntvfs->depth, getpid());
127 nprivates->log_fd = open(logname, O_WRONLY|O_CREAT|O_APPEND, 0644);
130 if (nprivates->log_fd == -1) {
131 DEBUG(0,("Failed to open nbench log\n"));
132 return NT_STATUS_UNSUCCESSFUL;
135 ntvfs->private_data = nprivates;
137 status = ntvfs_next_connect(ntvfs, req, con);
143 disconnect from a share
145 static NTSTATUS nbench_disconnect(struct ntvfs_module_context *ntvfs)
147 struct nbench_private *nprivates = ntvfs->private_data;
150 close(nprivates->log_fd);
152 status = ntvfs_next_disconnect(ntvfs);
158 delete a file - the dirtype specifies the file types to include in the search.
159 The name can contain CIFS wildcards, but rarely does (except with OS/2 clients)
161 static void nbench_unlink_send(struct ntvfs_request *req)
163 union smb_unlink *unl = req->async_states->private_data;
165 nbench_log(req, "Unlink \"%s\" 0x%x %s\n",
166 unl->unlink.in.pattern, unl->unlink.in.attrib,
167 get_nt_error_c_code(req->async_states->status));
169 PASS_THRU_REP_POST(req);
172 static NTSTATUS nbench_unlink(struct ntvfs_module_context *ntvfs,
173 struct ntvfs_request *req,
174 union smb_unlink *unl)
178 PASS_THRU_REQ(ntvfs, req, unlink, unl, (ntvfs, req, unl));
186 static void nbench_ioctl_send(struct ntvfs_request *req)
188 nbench_log(req, "Ioctl - NOT HANDLED\n");
190 PASS_THRU_REP_POST(req);
193 static NTSTATUS nbench_ioctl(struct ntvfs_module_context *ntvfs,
194 struct ntvfs_request *req, union smb_ioctl *io)
198 PASS_THRU_REQ(ntvfs, req, ioctl, io, (ntvfs, req, io));
204 check if a directory exists
206 static void nbench_chkpath_send(struct ntvfs_request *req)
208 union smb_chkpath *cp = req->async_states->private_data;
210 nbench_log(req, "Chkpath \"%s\" %s\n",
212 get_nt_error_c_code(req->async_states->status));
214 PASS_THRU_REP_POST(req);
217 static NTSTATUS nbench_chkpath(struct ntvfs_module_context *ntvfs,
218 struct ntvfs_request *req,
219 union smb_chkpath *cp)
223 PASS_THRU_REQ(ntvfs, req, chkpath, cp, (ntvfs, req, cp));
229 return info on a pathname
231 static void nbench_qpathinfo_send(struct ntvfs_request *req)
233 union smb_fileinfo *info = req->async_states->private_data;
235 nbench_log(req, "QUERY_PATH_INFORMATION \"%s\" %d %s\n",
236 info->generic.in.file.path,
238 get_nt_error_c_code(req->async_states->status));
240 PASS_THRU_REP_POST(req);
243 static NTSTATUS nbench_qpathinfo(struct ntvfs_module_context *ntvfs,
244 struct ntvfs_request *req, union smb_fileinfo *info)
248 PASS_THRU_REQ(ntvfs, req, qpathinfo, info, (ntvfs, req, info));
254 query info on a open file
256 static void nbench_qfileinfo_send(struct ntvfs_request *req)
258 union smb_fileinfo *info = req->async_states->private_data;
260 nbench_log(req, "QUERY_FILE_INFORMATION %s %d %s\n",
261 nbench_ntvfs_handle_string(req, info->generic.in.file.ntvfs),
263 get_nt_error_c_code(req->async_states->status));
265 PASS_THRU_REP_POST(req);
268 static NTSTATUS nbench_qfileinfo(struct ntvfs_module_context *ntvfs,
269 struct ntvfs_request *req, union smb_fileinfo *info)
273 PASS_THRU_REQ(ntvfs, req, qfileinfo, info, (ntvfs, req, info));
279 set info on a pathname
281 static void nbench_setpathinfo_send(struct ntvfs_request *req)
283 union smb_setfileinfo *st = req->async_states->private_data;
285 nbench_log(req, "SET_PATH_INFORMATION \"%s\" %d %s\n",
286 st->generic.in.file.path,
288 get_nt_error_c_code(req->async_states->status));
290 PASS_THRU_REP_POST(req);
293 static NTSTATUS nbench_setpathinfo(struct ntvfs_module_context *ntvfs,
294 struct ntvfs_request *req, union smb_setfileinfo *st)
298 PASS_THRU_REQ(ntvfs, req, setpathinfo, st, (ntvfs, req, st));
306 static void nbench_open_send(struct ntvfs_request *req)
308 union smb_open *io = req->async_states->private_data;
310 switch (io->generic.level) {
311 case RAW_OPEN_NTCREATEX:
312 if (!NT_STATUS_IS_OK(req->async_states->status)) {
313 ZERO_STRUCT(io->ntcreatex.out);
315 nbench_log(req, "NTCreateX \"%s\" 0x%x 0x%x %s %s\n",
316 io->ntcreatex.in.fname,
317 io->ntcreatex.in.create_options,
318 io->ntcreatex.in.open_disposition,
319 nbench_ntvfs_handle_string(req, io->ntcreatex.out.file.ntvfs),
320 get_nt_error_c_code(req->async_states->status));
324 nbench_log(req, "Open-%d - NOT HANDLED\n",
329 PASS_THRU_REP_POST(req);
332 static NTSTATUS nbench_open(struct ntvfs_module_context *ntvfs,
333 struct ntvfs_request *req, union smb_open *io)
337 #undef open /* AIX defines open to be open64 */
338 PASS_THRU_REQ(ntvfs, req, open, io, (ntvfs, req, io));
346 static void nbench_mkdir_send(struct ntvfs_request *req)
348 nbench_log(req, "Mkdir - NOT HANDLED\n");
350 PASS_THRU_REP_POST(req);
353 static NTSTATUS nbench_mkdir(struct ntvfs_module_context *ntvfs,
354 struct ntvfs_request *req, union smb_mkdir *md)
358 PASS_THRU_REQ(ntvfs, req, mkdir, md, (ntvfs, req, md));
366 static void nbench_rmdir_send(struct ntvfs_request *req)
368 struct smb_rmdir *rd = req->async_states->private_data;
370 nbench_log(req, "Rmdir \"%s\" %s\n",
372 get_nt_error_c_code(req->async_states->status));
374 PASS_THRU_REP_POST(req);
377 static NTSTATUS nbench_rmdir(struct ntvfs_module_context *ntvfs,
378 struct ntvfs_request *req, struct smb_rmdir *rd)
382 PASS_THRU_REQ(ntvfs, req, rmdir, rd, (ntvfs, req, rd));
388 rename a set of files
390 static void nbench_rename_send(struct ntvfs_request *req)
392 union smb_rename *ren = req->async_states->private_data;
394 switch (ren->generic.level) {
395 case RAW_RENAME_RENAME:
396 nbench_log(req, "Rename \"%s\" \"%s\" %s\n",
397 ren->rename.in.pattern1,
398 ren->rename.in.pattern2,
399 get_nt_error_c_code(req->async_states->status));
403 nbench_log(req, "Rename-%d - NOT HANDLED\n",
408 PASS_THRU_REP_POST(req);
411 static NTSTATUS nbench_rename(struct ntvfs_module_context *ntvfs,
412 struct ntvfs_request *req, union smb_rename *ren)
416 PASS_THRU_REQ(ntvfs, req, rename, ren, (ntvfs, req, ren));
424 static void nbench_copy_send(struct ntvfs_request *req)
426 nbench_log(req, "Copy - NOT HANDLED\n");
428 PASS_THRU_REP_POST(req);
431 static NTSTATUS nbench_copy(struct ntvfs_module_context *ntvfs,
432 struct ntvfs_request *req, struct smb_copy *cp)
436 PASS_THRU_REQ(ntvfs, req, copy, cp, (ntvfs, req, cp));
444 static void nbench_read_send(struct ntvfs_request *req)
446 union smb_read *rd = req->async_states->private_data;
448 switch (rd->generic.level) {
450 if (!NT_STATUS_IS_OK(req->async_states->status)) {
451 ZERO_STRUCT(rd->readx.out);
453 nbench_log(req, "ReadX %s %d %d %d %s\n",
454 nbench_ntvfs_handle_string(req, rd->readx.in.file.ntvfs),
455 (int)rd->readx.in.offset,
458 get_nt_error_c_code(req->async_states->status));
461 nbench_log(req, "Read-%d - NOT HANDLED\n",
466 PASS_THRU_REP_POST(req);
469 static NTSTATUS nbench_read(struct ntvfs_module_context *ntvfs,
470 struct ntvfs_request *req, union smb_read *rd)
474 PASS_THRU_REQ(ntvfs, req, read, rd, (ntvfs, req, rd));
482 static void nbench_write_send(struct ntvfs_request *req)
484 union smb_write *wr = req->async_states->private_data;
486 switch (wr->generic.level) {
487 case RAW_WRITE_WRITEX:
488 if (!NT_STATUS_IS_OK(req->async_states->status)) {
489 ZERO_STRUCT(wr->writex.out);
491 nbench_log(req, "WriteX %s %d %d %d %s\n",
492 nbench_ntvfs_handle_string(req, wr->writex.in.file.ntvfs),
493 (int)wr->writex.in.offset,
495 wr->writex.out.nwritten,
496 get_nt_error_c_code(req->async_states->status));
499 case RAW_WRITE_WRITE:
500 if (!NT_STATUS_IS_OK(req->async_states->status)) {
501 ZERO_STRUCT(wr->write.out);
503 nbench_log(req, "Write %s %d %d %d %s\n",
504 nbench_ntvfs_handle_string(req, wr->write.in.file.ntvfs),
507 wr->write.out.nwritten,
508 get_nt_error_c_code(req->async_states->status));
512 nbench_log(req, "Write-%d - NOT HANDLED\n",
517 PASS_THRU_REP_POST(req);
520 static NTSTATUS nbench_write(struct ntvfs_module_context *ntvfs,
521 struct ntvfs_request *req, union smb_write *wr)
525 PASS_THRU_REQ(ntvfs, req, write, wr, (ntvfs, req, wr));
533 static void nbench_seek_send(struct ntvfs_request *req)
535 nbench_log(req, "Seek - NOT HANDLED\n");
537 PASS_THRU_REP_POST(req);
540 static NTSTATUS nbench_seek(struct ntvfs_module_context *ntvfs,
541 struct ntvfs_request *req,
546 PASS_THRU_REQ(ntvfs, req, seek, io, (ntvfs, req, io));
554 static void nbench_flush_send(struct ntvfs_request *req)
556 union smb_flush *io = req->async_states->private_data;
558 switch (io->generic.level) {
559 case RAW_FLUSH_FLUSH:
560 nbench_log(req, "Flush %s %s\n",
561 nbench_ntvfs_handle_string(req, io->flush.in.file.ntvfs),
562 get_nt_error_c_code(req->async_states->status));
565 nbench_log(req, "Flush %d %s\n",
567 get_nt_error_c_code(req->async_states->status));
570 nbench_log(req, "Flush-%d - NOT HANDLED\n",
575 PASS_THRU_REP_POST(req);
578 static NTSTATUS nbench_flush(struct ntvfs_module_context *ntvfs,
579 struct ntvfs_request *req,
584 PASS_THRU_REQ(ntvfs, req, flush, io, (ntvfs, req, io));
592 static void nbench_close_send(struct ntvfs_request *req)
594 union smb_close *io = req->async_states->private_data;
596 switch (io->generic.level) {
597 case RAW_CLOSE_CLOSE:
598 nbench_log(req, "Close %s %s\n",
599 nbench_ntvfs_handle_string(req, io->close.in.file.ntvfs),
600 get_nt_error_c_code(req->async_states->status));
604 nbench_log(req, "Close-%d - NOT HANDLED\n",
609 PASS_THRU_REP_POST(req);
612 static NTSTATUS nbench_close(struct ntvfs_module_context *ntvfs,
613 struct ntvfs_request *req, union smb_close *io)
617 PASS_THRU_REQ(ntvfs, req, close, io, (ntvfs, req, io));
625 static void nbench_exit_send(struct ntvfs_request *req)
627 nbench_log(req, "Exit - NOT HANDLED\n");
629 PASS_THRU_REP_POST(req);
632 static NTSTATUS nbench_exit(struct ntvfs_module_context *ntvfs,
633 struct ntvfs_request *req)
637 PASS_THRU_REQ(ntvfs, req, exit, NULL, (ntvfs, req));
643 logoff - closing files
645 static void nbench_logoff_send(struct ntvfs_request *req)
647 nbench_log(req, "Logoff - NOT HANDLED\n");
649 PASS_THRU_REP_POST(req);
652 static NTSTATUS nbench_logoff(struct ntvfs_module_context *ntvfs,
653 struct ntvfs_request *req)
657 PASS_THRU_REQ(ntvfs, req, logoff, NULL, (ntvfs, req));
663 async_setup - send fn
665 static void nbench_async_setup_send(struct ntvfs_request *req)
667 PASS_THRU_REP_POST(req);
673 static NTSTATUS nbench_async_setup(struct ntvfs_module_context *ntvfs,
674 struct ntvfs_request *req,
679 PASS_THRU_REQ(ntvfs, req, async_setup, NULL, (ntvfs, req, private_data));
685 static void nbench_cancel_send(struct ntvfs_request *req)
687 PASS_THRU_REP_POST(req);
691 cancel an existing async request
693 static NTSTATUS nbench_cancel(struct ntvfs_module_context *ntvfs,
694 struct ntvfs_request *req)
698 PASS_THRU_REQ(ntvfs, req, cancel, NULL, (ntvfs, req));
706 static void nbench_lock_send(struct ntvfs_request *req)
708 union smb_lock *lck = req->async_states->private_data;
710 if (lck->generic.level == RAW_LOCK_LOCKX &&
711 lck->lockx.in.lock_cnt == 1 &&
712 lck->lockx.in.ulock_cnt == 0) {
713 nbench_log(req, "LockX %s %d %d %s\n",
714 nbench_ntvfs_handle_string(req, lck->lockx.in.file.ntvfs),
715 (int)lck->lockx.in.locks[0].offset,
716 (int)lck->lockx.in.locks[0].count,
717 get_nt_error_c_code(req->async_states->status));
718 } else if (lck->generic.level == RAW_LOCK_LOCKX &&
719 lck->lockx.in.ulock_cnt == 1) {
720 nbench_log(req, "UnlockX %s %d %d %s\n",
721 nbench_ntvfs_handle_string(req, lck->lockx.in.file.ntvfs),
722 (int)lck->lockx.in.locks[0].offset,
723 (int)lck->lockx.in.locks[0].count,
724 get_nt_error_c_code(req->async_states->status));
726 nbench_log(req, "Lock-%d - NOT HANDLED\n", lck->generic.level);
729 PASS_THRU_REP_POST(req);
732 static NTSTATUS nbench_lock(struct ntvfs_module_context *ntvfs,
733 struct ntvfs_request *req, union smb_lock *lck)
737 PASS_THRU_REQ(ntvfs, req, lock, lck, (ntvfs, req, lck));
743 set info on a open file
745 static void nbench_setfileinfo_send(struct ntvfs_request *req)
747 union smb_setfileinfo *info = req->async_states->private_data;
749 nbench_log(req, "SET_FILE_INFORMATION %s %d %s\n",
750 nbench_ntvfs_handle_string(req, info->generic.in.file.ntvfs),
752 get_nt_error_c_code(req->async_states->status));
754 PASS_THRU_REP_POST(req);
757 static NTSTATUS nbench_setfileinfo(struct ntvfs_module_context *ntvfs,
758 struct ntvfs_request *req,
759 union smb_setfileinfo *info)
763 PASS_THRU_REQ(ntvfs, req, setfileinfo, info, (ntvfs, req, info));
769 return filesystem space info
771 static void nbench_fsinfo_send(struct ntvfs_request *req)
773 union smb_fsinfo *fs = req->async_states->private_data;
775 nbench_log(req, "QUERY_FS_INFORMATION %d %s\n",
777 get_nt_error_c_code(req->async_states->status));
779 PASS_THRU_REP_POST(req);
782 static NTSTATUS nbench_fsinfo(struct ntvfs_module_context *ntvfs,
783 struct ntvfs_request *req, union smb_fsinfo *fs)
787 PASS_THRU_REQ(ntvfs, req, fsinfo, fs, (ntvfs, req, fs));
793 return print queue info
795 static void nbench_lpq_send(struct ntvfs_request *req)
797 union smb_lpq *lpq = req->async_states->private_data;
799 nbench_log(req, "Lpq-%d - NOT HANDLED\n", lpq->generic.level);
801 PASS_THRU_REP_POST(req);
804 static NTSTATUS nbench_lpq(struct ntvfs_module_context *ntvfs,
805 struct ntvfs_request *req, union smb_lpq *lpq)
809 PASS_THRU_REQ(ntvfs, req, lpq, lpq, (ntvfs, req, lpq));
815 list files in a directory matching a wildcard pattern
817 static void nbench_search_first_send(struct ntvfs_request *req)
819 union smb_search_first *io = req->async_states->private_data;
821 switch (io->generic.level) {
822 case RAW_SEARCH_TRANS2:
823 if (NT_STATUS_IS_ERR(req->async_states->status)) {
824 ZERO_STRUCT(io->t2ffirst.out);
826 nbench_log(req, "FIND_FIRST \"%s\" %d %d %d %s\n",
827 io->t2ffirst.in.pattern,
828 io->t2ffirst.data_level,
829 io->t2ffirst.in.max_count,
830 io->t2ffirst.out.count,
831 get_nt_error_c_code(req->async_states->status));
835 nbench_log(req, "Search-%d - NOT HANDLED\n", io->generic.level);
839 PASS_THRU_REP_POST(req);
842 static NTSTATUS nbench_search_first(struct ntvfs_module_context *ntvfs,
843 struct ntvfs_request *req, union smb_search_first *io,
844 void *search_private,
845 bool (*callback)(void *, const union smb_search_data *))
849 PASS_THRU_REQ(ntvfs, req, search_first, io, (ntvfs, req, io, search_private, callback));
854 /* continue a search */
855 static void nbench_search_next_send(struct ntvfs_request *req)
857 union smb_search_next *io = req->async_states->private_data;
859 nbench_log(req, "Searchnext-%d - NOT HANDLED\n", io->generic.level);
861 PASS_THRU_REP_POST(req);
864 static NTSTATUS nbench_search_next(struct ntvfs_module_context *ntvfs,
865 struct ntvfs_request *req, union smb_search_next *io,
866 void *search_private,
867 bool (*callback)(void *, const union smb_search_data *))
871 PASS_THRU_REQ(ntvfs, req, search_next, io, (ntvfs, req, io, search_private, callback));
877 static void nbench_search_close_send(struct ntvfs_request *req)
879 union smb_search_close *io = req->async_states->private_data;
881 nbench_log(req, "Searchclose-%d - NOT HANDLED\n", io->generic.level);
883 PASS_THRU_REP_POST(req);
886 static NTSTATUS nbench_search_close(struct ntvfs_module_context *ntvfs,
887 struct ntvfs_request *req, union smb_search_close *io)
891 PASS_THRU_REQ(ntvfs, req, search_close, io, (ntvfs, req, io));
896 /* SMBtrans - not used on file shares */
897 static void nbench_trans_send(struct ntvfs_request *req)
899 nbench_log(req, "Trans - NOT HANDLED\n");
901 PASS_THRU_REP_POST(req);
904 static NTSTATUS nbench_trans(struct ntvfs_module_context *ntvfs,
905 struct ntvfs_request *req, struct smb_trans2 *trans2)
909 PASS_THRU_REQ(ntvfs, req, trans, trans2, (ntvfs, req, trans2));
915 initialise the nbench backend, registering ourselves with the ntvfs subsystem
917 NTSTATUS ntvfs_nbench_init(void)
920 struct ntvfs_ops ops;
921 NTVFS_CURRENT_CRITICAL_SIZES(vers);
925 /* fill in the name and type */
927 ops.type = NTVFS_DISK;
929 /* fill in all the operations */
930 ops.connect = nbench_connect;
931 ops.disconnect = nbench_disconnect;
932 ops.unlink = nbench_unlink;
933 ops.chkpath = nbench_chkpath;
934 ops.qpathinfo = nbench_qpathinfo;
935 ops.setpathinfo = nbench_setpathinfo;
936 ops.open = nbench_open;
937 ops.mkdir = nbench_mkdir;
938 ops.rmdir = nbench_rmdir;
939 ops.rename = nbench_rename;
940 ops.copy = nbench_copy;
941 ops.ioctl = nbench_ioctl;
942 ops.read = nbench_read;
943 ops.write = nbench_write;
944 ops.seek = nbench_seek;
945 ops.flush = nbench_flush;
946 ops.close = nbench_close;
947 ops.exit = nbench_exit;
948 ops.lock = nbench_lock;
949 ops.setfileinfo = nbench_setfileinfo;
950 ops.qfileinfo = nbench_qfileinfo;
951 ops.fsinfo = nbench_fsinfo;
952 ops.lpq = nbench_lpq;
953 ops.search_first = nbench_search_first;
954 ops.search_next = nbench_search_next;
955 ops.search_close = nbench_search_close;
956 ops.trans = nbench_trans;
957 ops.logoff = nbench_logoff;
958 ops.async_setup = nbench_async_setup;
959 ops.cancel = nbench_cancel;
961 /* we don't register a trans2 handler as we want to be able to
962 log individual trans2 requests */
965 /* register ourselves with the NTVFS subsystem. */
966 ret = ntvfs_register(&ops, &vers);
968 if (!NT_STATUS_IS_OK(ret)) {
969 DEBUG(0,("Failed to register nbench backend!\n"));