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 NTSTATUS
ntvfs_nbench_init(void);
32 /* this is stored in ntvfs_private */
33 struct nbench_private
{
38 log one request to the nbench log
40 static void nbench_log(struct ntvfs_request
*req
,
41 const char *format
, ...) PRINTF_ATTRIBUTE(2, 3);
43 static void nbench_log(struct ntvfs_request
*req
,
44 const char *format
, ...)
46 struct nbench_private
*nprivates
= req
->async_states
->ntvfs
->private_data
;
51 vasprintf(&s
, format
, ap
);
54 write(nprivates
->log_fd
, s
, strlen(s
));
58 static char *nbench_ntvfs_handle_string(struct ntvfs_request
*req
, struct ntvfs_handle
*h
)
63 key
= ntvfs_handle_get_wire_key(h
, req
);
66 case 2: /* SMB fnum */
67 fnum
= SVAL(key
.data
, 0);
70 DEBUG(0,("%s: invalid wire handle size: %u\n",
71 __FUNCTION__
, (unsigned)key
.length
));
75 return talloc_asprintf(req
, "%u", fnum
);
79 this pass through macro operates on request contexts, and disables
82 async calls are a pain for the nbench module as it makes pulling the
83 status code and any result parameters much harder.
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)) { \
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); \
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); \
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); \
113 connect to a share - used when a tree_connect operation comes in.
115 static NTSTATUS
nbench_connect(struct ntvfs_module_context
*ntvfs
,
116 struct ntvfs_request
*req
,
119 struct nbench_private
*nprivates
;
121 char *logname
= NULL
;
123 nprivates
= talloc(ntvfs
, struct nbench_private
);
125 return NT_STATUS_NO_MEMORY
;
128 logname
= talloc_asprintf(req
, "/tmp/nbenchlog%d.%u", ntvfs
->depth
,
130 NT_STATUS_HAVE_NO_MEMORY(logname
);
131 nprivates
->log_fd
= open(logname
, O_WRONLY
|O_CREAT
|O_APPEND
, 0644);
132 talloc_free(logname
);
134 if (nprivates
->log_fd
== -1) {
135 DEBUG(0,("Failed to open nbench log\n"));
136 return NT_STATUS_UNSUCCESSFUL
;
139 ntvfs
->private_data
= nprivates
;
141 status
= ntvfs_next_connect(ntvfs
, req
, con
);
147 disconnect from a share
149 static NTSTATUS
nbench_disconnect(struct ntvfs_module_context
*ntvfs
)
151 struct nbench_private
*nprivates
= ntvfs
->private_data
;
154 close(nprivates
->log_fd
);
156 status
= ntvfs_next_disconnect(ntvfs
);
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)
165 static void nbench_unlink_send(struct ntvfs_request
*req
)
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
));
172 PASS_THRU_REP_POST(req
);
175 static NTSTATUS
nbench_unlink(struct ntvfs_module_context
*ntvfs
,
176 struct ntvfs_request
*req
,
177 union smb_unlink
*unl
)
181 PASS_THRU_REQ(ntvfs
, req
, unlink
, unl
, (ntvfs
, req
, unl
));
189 static void nbench_ioctl_send(struct ntvfs_request
*req
)
191 nbench_log(req
, "Ioctl - NOT HANDLED\n");
193 PASS_THRU_REP_POST(req
);
196 static NTSTATUS
nbench_ioctl(struct ntvfs_module_context
*ntvfs
,
197 struct ntvfs_request
*req
, union smb_ioctl
*io
)
201 PASS_THRU_REQ(ntvfs
, req
, ioctl
, io
, (ntvfs
, req
, io
));
207 check if a directory exists
209 static void nbench_chkpath_send(struct ntvfs_request
*req
)
211 union smb_chkpath
*cp
= req
->async_states
->private_data
;
213 nbench_log(req
, "Chkpath \"%s\" %s\n",
215 get_nt_error_c_code(req
, req
->async_states
->status
));
217 PASS_THRU_REP_POST(req
);
220 static NTSTATUS
nbench_chkpath(struct ntvfs_module_context
*ntvfs
,
221 struct ntvfs_request
*req
,
222 union smb_chkpath
*cp
)
226 PASS_THRU_REQ(ntvfs
, req
, chkpath
, cp
, (ntvfs
, req
, cp
));
232 return info on a pathname
234 static void nbench_qpathinfo_send(struct ntvfs_request
*req
)
236 union smb_fileinfo
*info
= req
->async_states
->private_data
;
238 nbench_log(req
, "QUERY_PATH_INFORMATION \"%s\" %d %s\n",
239 info
->generic
.in
.file
.path
,
241 get_nt_error_c_code(req
, req
->async_states
->status
));
243 PASS_THRU_REP_POST(req
);
246 static NTSTATUS
nbench_qpathinfo(struct ntvfs_module_context
*ntvfs
,
247 struct ntvfs_request
*req
, union smb_fileinfo
*info
)
251 PASS_THRU_REQ(ntvfs
, req
, qpathinfo
, info
, (ntvfs
, req
, info
));
257 query info on a open file
259 static void nbench_qfileinfo_send(struct ntvfs_request
*req
)
261 union smb_fileinfo
*info
= req
->async_states
->private_data
;
263 nbench_log(req
, "QUERY_FILE_INFORMATION %s %d %s\n",
264 nbench_ntvfs_handle_string(req
, info
->generic
.in
.file
.ntvfs
),
266 get_nt_error_c_code(req
, req
->async_states
->status
));
268 PASS_THRU_REP_POST(req
);
271 static NTSTATUS
nbench_qfileinfo(struct ntvfs_module_context
*ntvfs
,
272 struct ntvfs_request
*req
, union smb_fileinfo
*info
)
276 PASS_THRU_REQ(ntvfs
, req
, qfileinfo
, info
, (ntvfs
, req
, info
));
282 set info on a pathname
284 static void nbench_setpathinfo_send(struct ntvfs_request
*req
)
286 union smb_setfileinfo
*st
= req
->async_states
->private_data
;
288 nbench_log(req
, "SET_PATH_INFORMATION \"%s\" %d %s\n",
289 st
->generic
.in
.file
.path
,
291 get_nt_error_c_code(req
, req
->async_states
->status
));
293 PASS_THRU_REP_POST(req
);
296 static NTSTATUS
nbench_setpathinfo(struct ntvfs_module_context
*ntvfs
,
297 struct ntvfs_request
*req
, union smb_setfileinfo
*st
)
301 PASS_THRU_REQ(ntvfs
, req
, setpathinfo
, st
, (ntvfs
, req
, st
));
309 static void nbench_open_send(struct ntvfs_request
*req
)
311 union smb_open
*io
= req
->async_states
->private_data
;
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
);
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
));
327 nbench_log(req
, "Open-%d - NOT HANDLED\n",
332 PASS_THRU_REP_POST(req
);
335 static NTSTATUS
nbench_open(struct ntvfs_module_context
*ntvfs
,
336 struct ntvfs_request
*req
, union smb_open
*io
)
340 #undef open /* AIX defines open to be open64 */
341 PASS_THRU_REQ(ntvfs
, req
, open
, io
, (ntvfs
, req
, io
));
349 static void nbench_mkdir_send(struct ntvfs_request
*req
)
351 nbench_log(req
, "Mkdir - NOT HANDLED\n");
353 PASS_THRU_REP_POST(req
);
356 static NTSTATUS
nbench_mkdir(struct ntvfs_module_context
*ntvfs
,
357 struct ntvfs_request
*req
, union smb_mkdir
*md
)
361 PASS_THRU_REQ(ntvfs
, req
, mkdir
, md
, (ntvfs
, req
, md
));
369 static void nbench_rmdir_send(struct ntvfs_request
*req
)
371 struct smb_rmdir
*rd
= req
->async_states
->private_data
;
373 nbench_log(req
, "Rmdir \"%s\" %s\n",
375 get_nt_error_c_code(req
, req
->async_states
->status
));
377 PASS_THRU_REP_POST(req
);
380 static NTSTATUS
nbench_rmdir(struct ntvfs_module_context
*ntvfs
,
381 struct ntvfs_request
*req
, struct smb_rmdir
*rd
)
385 PASS_THRU_REQ(ntvfs
, req
, rmdir
, rd
, (ntvfs
, req
, rd
));
391 rename a set of files
393 static void nbench_rename_send(struct ntvfs_request
*req
)
395 union smb_rename
*ren
= req
->async_states
->private_data
;
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
));
406 nbench_log(req
, "Rename-%d - NOT HANDLED\n",
411 PASS_THRU_REP_POST(req
);
414 static NTSTATUS
nbench_rename(struct ntvfs_module_context
*ntvfs
,
415 struct ntvfs_request
*req
, union smb_rename
*ren
)
419 PASS_THRU_REQ(ntvfs
, req
, rename
, ren
, (ntvfs
, req
, ren
));
427 static void nbench_copy_send(struct ntvfs_request
*req
)
429 nbench_log(req
, "Copy - NOT HANDLED\n");
431 PASS_THRU_REP_POST(req
);
434 static NTSTATUS
nbench_copy(struct ntvfs_module_context
*ntvfs
,
435 struct ntvfs_request
*req
, struct smb_copy
*cp
)
439 PASS_THRU_REQ(ntvfs
, req
, copy
, cp
, (ntvfs
, req
, cp
));
447 static void nbench_read_send(struct ntvfs_request
*req
)
449 union smb_read
*rd
= req
->async_states
->private_data
;
451 switch (rd
->generic
.level
) {
453 if (!NT_STATUS_IS_OK(req
->async_states
->status
)) {
454 ZERO_STRUCT(rd
->readx
.out
);
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
,
461 get_nt_error_c_code(req
, req
->async_states
->status
));
464 nbench_log(req
, "Read-%d - NOT HANDLED\n",
469 PASS_THRU_REP_POST(req
);
472 static NTSTATUS
nbench_read(struct ntvfs_module_context
*ntvfs
,
473 struct ntvfs_request
*req
, union smb_read
*rd
)
477 PASS_THRU_REQ(ntvfs
, req
, read
, rd
, (ntvfs
, req
, rd
));
485 static void nbench_write_send(struct ntvfs_request
*req
)
487 union smb_write
*wr
= req
->async_states
->private_data
;
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
);
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
,
498 wr
->writex
.out
.nwritten
,
499 get_nt_error_c_code(req
, req
->async_states
->status
));
502 case RAW_WRITE_WRITE
:
503 if (!NT_STATUS_IS_OK(req
->async_states
->status
)) {
504 ZERO_STRUCT(wr
->write
.out
);
506 nbench_log(req
, "Write %s %d %d %d %s\n",
507 nbench_ntvfs_handle_string(req
, wr
->write
.in
.file
.ntvfs
),
510 wr
->write
.out
.nwritten
,
511 get_nt_error_c_code(req
, req
->async_states
->status
));
515 nbench_log(req
, "Write-%d - NOT HANDLED\n",
520 PASS_THRU_REP_POST(req
);
523 static NTSTATUS
nbench_write(struct ntvfs_module_context
*ntvfs
,
524 struct ntvfs_request
*req
, union smb_write
*wr
)
528 PASS_THRU_REQ(ntvfs
, req
, write
, wr
, (ntvfs
, req
, wr
));
536 static void nbench_seek_send(struct ntvfs_request
*req
)
538 nbench_log(req
, "Seek - NOT HANDLED\n");
540 PASS_THRU_REP_POST(req
);
543 static NTSTATUS
nbench_seek(struct ntvfs_module_context
*ntvfs
,
544 struct ntvfs_request
*req
,
549 PASS_THRU_REQ(ntvfs
, req
, seek
, io
, (ntvfs
, req
, io
));
557 static void nbench_flush_send(struct ntvfs_request
*req
)
559 union smb_flush
*io
= req
->async_states
->private_data
;
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
));
568 nbench_log(req
, "Flush %d %s\n",
570 get_nt_error_c_code(req
, req
->async_states
->status
));
573 nbench_log(req
, "Flush-%d - NOT HANDLED\n",
578 PASS_THRU_REP_POST(req
);
581 static NTSTATUS
nbench_flush(struct ntvfs_module_context
*ntvfs
,
582 struct ntvfs_request
*req
,
587 PASS_THRU_REQ(ntvfs
, req
, flush
, io
, (ntvfs
, req
, io
));
595 static void nbench_close_send(struct ntvfs_request
*req
)
597 union smb_close
*io
= req
->async_states
->private_data
;
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
));
607 nbench_log(req
, "Close-%d - NOT HANDLED\n",
612 PASS_THRU_REP_POST(req
);
615 static NTSTATUS
nbench_close(struct ntvfs_module_context
*ntvfs
,
616 struct ntvfs_request
*req
, union smb_close
*io
)
620 PASS_THRU_REQ(ntvfs
, req
, close
, io
, (ntvfs
, req
, io
));
628 static void nbench_exit_send(struct ntvfs_request
*req
)
630 nbench_log(req
, "Exit - NOT HANDLED\n");
632 PASS_THRU_REP_POST(req
);
635 static NTSTATUS
nbench_exit(struct ntvfs_module_context
*ntvfs
,
636 struct ntvfs_request
*req
)
640 PASS_THRU_REQ(ntvfs
, req
, exit
, NULL
, (ntvfs
, req
));
646 logoff - closing files
648 static void nbench_logoff_send(struct ntvfs_request
*req
)
650 nbench_log(req
, "Logoff - NOT HANDLED\n");
652 PASS_THRU_REP_POST(req
);
655 static NTSTATUS
nbench_logoff(struct ntvfs_module_context
*ntvfs
,
656 struct ntvfs_request
*req
)
660 PASS_THRU_REQ(ntvfs
, req
, logoff
, NULL
, (ntvfs
, req
));
666 async_setup - send fn
668 static void nbench_async_setup_send(struct ntvfs_request
*req
)
670 PASS_THRU_REP_POST(req
);
676 static NTSTATUS
nbench_async_setup(struct ntvfs_module_context
*ntvfs
,
677 struct ntvfs_request
*req
,
682 PASS_THRU_REQ(ntvfs
, req
, async_setup
, NULL
, (ntvfs
, req
, private_data
));
688 static void nbench_cancel_send(struct ntvfs_request
*req
)
690 PASS_THRU_REP_POST(req
);
694 cancel an existing async request
696 static NTSTATUS
nbench_cancel(struct ntvfs_module_context
*ntvfs
,
697 struct ntvfs_request
*req
)
701 PASS_THRU_REQ(ntvfs
, req
, cancel
, NULL
, (ntvfs
, req
));
709 static void nbench_lock_send(struct ntvfs_request
*req
)
711 union smb_lock
*lck
= req
->async_states
->private_data
;
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
));
729 nbench_log(req
, "Lock-%d - NOT HANDLED\n", lck
->generic
.level
);
732 PASS_THRU_REP_POST(req
);
735 static NTSTATUS
nbench_lock(struct ntvfs_module_context
*ntvfs
,
736 struct ntvfs_request
*req
, union smb_lock
*lck
)
740 PASS_THRU_REQ(ntvfs
, req
, lock
, lck
, (ntvfs
, req
, lck
));
746 set info on a open file
748 static void nbench_setfileinfo_send(struct ntvfs_request
*req
)
750 union smb_setfileinfo
*info
= req
->async_states
->private_data
;
752 nbench_log(req
, "SET_FILE_INFORMATION %s %d %s\n",
753 nbench_ntvfs_handle_string(req
, info
->generic
.in
.file
.ntvfs
),
755 get_nt_error_c_code(req
, req
->async_states
->status
));
757 PASS_THRU_REP_POST(req
);
760 static NTSTATUS
nbench_setfileinfo(struct ntvfs_module_context
*ntvfs
,
761 struct ntvfs_request
*req
,
762 union smb_setfileinfo
*info
)
766 PASS_THRU_REQ(ntvfs
, req
, setfileinfo
, info
, (ntvfs
, req
, info
));
772 return filesystem space info
774 static void nbench_fsinfo_send(struct ntvfs_request
*req
)
776 union smb_fsinfo
*fs
= req
->async_states
->private_data
;
778 nbench_log(req
, "QUERY_FS_INFORMATION %d %s\n",
780 get_nt_error_c_code(req
, req
->async_states
->status
));
782 PASS_THRU_REP_POST(req
);
785 static NTSTATUS
nbench_fsinfo(struct ntvfs_module_context
*ntvfs
,
786 struct ntvfs_request
*req
, union smb_fsinfo
*fs
)
790 PASS_THRU_REQ(ntvfs
, req
, fsinfo
, fs
, (ntvfs
, req
, fs
));
796 return print queue info
798 static void nbench_lpq_send(struct ntvfs_request
*req
)
800 union smb_lpq
*lpq
= req
->async_states
->private_data
;
802 nbench_log(req
, "Lpq-%d - NOT HANDLED\n", lpq
->generic
.level
);
804 PASS_THRU_REP_POST(req
);
807 static NTSTATUS
nbench_lpq(struct ntvfs_module_context
*ntvfs
,
808 struct ntvfs_request
*req
, union smb_lpq
*lpq
)
812 PASS_THRU_REQ(ntvfs
, req
, lpq
, lpq
, (ntvfs
, req
, lpq
));
818 list files in a directory matching a wildcard pattern
820 static void nbench_search_first_send(struct ntvfs_request
*req
)
822 union smb_search_first
*io
= req
->async_states
->private_data
;
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
);
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
));
838 nbench_log(req
, "Search-%d - NOT HANDLED\n", io
->generic
.level
);
842 PASS_THRU_REP_POST(req
);
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
*))
852 PASS_THRU_REQ(ntvfs
, req
, search_first
, io
, (ntvfs
, req
, io
, search_private
, callback
));
857 /* continue a search */
858 static void nbench_search_next_send(struct ntvfs_request
*req
)
860 union smb_search_next
*io
= req
->async_states
->private_data
;
862 nbench_log(req
, "Searchnext-%d - NOT HANDLED\n", io
->generic
.level
);
864 PASS_THRU_REP_POST(req
);
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
*))
874 PASS_THRU_REQ(ntvfs
, req
, search_next
, io
, (ntvfs
, req
, io
, search_private
, callback
));
880 static void nbench_search_close_send(struct ntvfs_request
*req
)
882 union smb_search_close
*io
= req
->async_states
->private_data
;
884 nbench_log(req
, "Searchclose-%d - NOT HANDLED\n", io
->generic
.level
);
886 PASS_THRU_REP_POST(req
);
889 static NTSTATUS
nbench_search_close(struct ntvfs_module_context
*ntvfs
,
890 struct ntvfs_request
*req
, union smb_search_close
*io
)
894 PASS_THRU_REQ(ntvfs
, req
, search_close
, io
, (ntvfs
, req
, io
));
899 /* SMBtrans - not used on file shares */
900 static void nbench_trans_send(struct ntvfs_request
*req
)
902 nbench_log(req
, "Trans - NOT HANDLED\n");
904 PASS_THRU_REP_POST(req
);
907 static NTSTATUS
nbench_trans(struct ntvfs_module_context
*ntvfs
,
908 struct ntvfs_request
*req
, struct smb_trans2
*trans2
)
912 PASS_THRU_REQ(ntvfs
, req
, trans
, trans2
, (ntvfs
, req
, trans2
));
918 initialise the nbench backend, registering ourselves with the ntvfs subsystem
920 NTSTATUS
ntvfs_nbench_init(void)
923 struct ntvfs_ops ops
;
924 NTVFS_CURRENT_CRITICAL_SIZES(vers
);
928 /* fill in the name and type */
930 ops
.type
= NTVFS_DISK
;
932 /* fill in all the operations */
933 ops
.connect_fn
= nbench_connect
;
934 ops
.disconnect_fn
= nbench_disconnect
;
935 ops
.unlink_fn
= nbench_unlink
;
936 ops
.chkpath_fn
= nbench_chkpath
;
937 ops
.qpathinfo_fn
= nbench_qpathinfo
;
938 ops
.setpathinfo_fn
= nbench_setpathinfo
;
939 ops
.open_fn
= nbench_open
;
940 ops
.mkdir_fn
= nbench_mkdir
;
941 ops
.rmdir_fn
= nbench_rmdir
;
942 ops
.rename_fn
= nbench_rename
;
943 ops
.copy_fn
= nbench_copy
;
944 ops
.ioctl_fn
= nbench_ioctl
;
945 ops
.read_fn
= nbench_read
;
946 ops
.write_fn
= nbench_write
;
947 ops
.seek_fn
= nbench_seek
;
948 ops
.flush_fn
= nbench_flush
;
949 ops
.close_fn
= nbench_close
;
950 ops
.exit_fn
= nbench_exit
;
951 ops
.lock_fn
= nbench_lock
;
952 ops
.setfileinfo_fn
= nbench_setfileinfo
;
953 ops
.qfileinfo_fn
= nbench_qfileinfo
;
954 ops
.fsinfo_fn
= nbench_fsinfo
;
955 ops
.lpq_fn
= nbench_lpq
;
956 ops
.search_first_fn
= nbench_search_first
;
957 ops
.search_next_fn
= nbench_search_next
;
958 ops
.search_close_fn
= nbench_search_close
;
959 ops
.trans_fn
= nbench_trans
;
960 ops
.logoff_fn
= nbench_logoff
;
961 ops
.async_setup_fn
= nbench_async_setup
;
962 ops
.cancel_fn
= nbench_cancel
;
964 /* we don't register a trans2 handler as we want to be able to
965 log individual trans2 requests */
966 ops
.trans2_fn
= NULL
;
968 /* register ourselves with the NTVFS subsystem. */
969 ret
= ntvfs_register(&ops
, &vers
);
971 if (!NT_STATUS_IS_OK(ret
)) {
972 DEBUG(0,("Failed to register nbench backend!\n"));