sin/samba-mirror
1
0
Fork 0
mirror of https://github.com/samba-team/samba.git synced 2025-01-27 14:04:05 +03:00
Code
samba-mirror/source4/ntvfs/nbench/vfs_nbench.c

940 lines
21 KiB
C
Raw Normal View History

added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
/*
Unix SMB/CIFS implementation.
a pass-thru NTVFS module to record a NBENCH load file
Copyright (C) Andrew Tridgell 2004
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
/*
"passthru" in this module refers to the next level of NTVFS being used
*/
#include "includes.h"
r5298: - got rid of pstring.h from includes.h. This at least makes it a bit less likely that anyone will use pstring for new code - got rid of winbind_client.h from includes.h. This one triggered a huge change, as winbind_client.h was including system/filesys.h and defining the old uint32 and uint16 types, as well as its own pstring and fstring. (This used to be commit 9db6c79e902ec538108d6b7d3324039aabe1704f)
2005-02-10 05:09:35 +00:00
#include "system/filesys.h"
r3466: split out request.h, signing.h, and smb_server.h (This used to be commit 7c4e6ebf05790dd6e29896dd316db0fff613aa4e)
2004-11-02 07:18:24 +00:00
#include "smb_server/smb_server.h"
r12528: Add seperate proto headers for ntvfs, tdr, smb_server and nbt_server. (This used to be commit 87f665a1d5ba74289974bf9d8f9441c162e6f1b1)
2005-12-27 22:51:30 +00:00
#include "ntvfs/ntvfs.h"
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
/* this is stored in ntvfs_private */
struct nbench_private {
int log_fd;
};
/*
log one request to the nbench log
*/
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
static void nbench_log(struct ntvfs_request *req,
r2055: Add PRINTF_ATTRIBUTE to many more parts of the code, and a new --enable-developer warning for when they are missing. Andrew Bartlett (This used to be commit 8115e44d47bcd65edba08d10117180ae508cdbc1)
2004-08-25 07:15:21 +00:00
const char *format, ...) PRINTF_ATTRIBUTE(2, 3);
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
static void nbench_log(struct ntvfs_request *req,
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
const char *format, ...)
{
r3346: - simplified vfs_nbench.c a bit, by using req->async_state->ntvfs inside nbench_log() instead of declaring nprivates every time. - added correct async_setup pass-thru in nbench (This used to be commit 8d79bceeca4528ab31cff1adc7706faa075013ac)
2004-10-29 00:51:41 +00:00
struct nbench_private *private = req->async_states->ntvfs->private_data;
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
va_list ap;
char *s = NULL;
va_start(ap, format);
vasprintf(&s, format, ap);
va_end(ap);
r3337: remove debug code and reanable the reall logging:-) metze (This used to be commit 00b285e5a815e6d53ede7d102dee4e5b79d47f52)
2004-10-28 22:18:52 +00:00
write(private->log_fd, s, strlen(s));
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
free(s);
}
/*
this pass through macro operates on request contexts, and disables
async calls.
async calls are a pain for the nbench module as it makes pulling the
status code and any result parameters much harder.
*/
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
#define PASS_THRU_REQ_PRE_ASYNC(ntvfs, req, op, par1) do { \
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
status = ntvfs_async_state_push(ntvfs, req, par1, nbench_##op##_send); \
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
if (!NT_STATUS_IS_OK(status)) { \
return status; \
} \
} while (0)
#define PASS_THRU_REQ_POST_ASYNC(req) do { \
req->async_states->status = status; \
if (!(req->async_states->state & NTVFS_ASYNC_STATE_ASYNC)) { \
req->async_states->send_fn(req); \
} \
} while (0)
#define PASS_THRU_REQ(ntvfs, req, op, par1, args) do { \
PASS_THRU_REQ_PRE_ASYNC(ntvfs, req, op, par1); \
r2751: this is a new ntvfs design which tries to solve: - the stacking of modules - finding the modules private data - hide the ntvfs details from the calling layer - I set NTVFS_INTERFACE_VERSION 0 till we are closer to release (because we need to solve some async problems with the module stacking) metze (This used to be commit 3ff03b5cb21bb79afdd3b1609be9635f6688a539)
2004-09-29 13:17:09 +00:00
status = ntvfs_next_##op args; \
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
PASS_THRU_REQ_POST_ASYNC(req); \
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
} while (0)
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
#define PASS_THRU_REP_POST(req) do { \
ntvfs_async_state_pop(req); \
if (req->async_states->state & NTVFS_ASYNC_STATE_ASYNC) { \
req->async_states->send_fn(req); \
} \
} while (0)
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
/*
connect to a share - used when a tree_connect operation comes in.
*/
r2751: this is a new ntvfs design which tries to solve: - the stacking of modules - finding the modules private data - hide the ntvfs details from the calling layer - I set NTVFS_INTERFACE_VERSION 0 till we are closer to release (because we need to solve some async problems with the module stacking) metze (This used to be commit 3ff03b5cb21bb79afdd3b1609be9635f6688a539)
2004-09-29 13:17:09 +00:00
static NTSTATUS nbench_connect(struct ntvfs_module_context *ntvfs,
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
struct ntvfs_request *req, const char *sharename)
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
{
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
struct nbench_private *nprivates;
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
NTSTATUS status;
char *logname = NULL;
r13129: fix the memory hierachie metze (This used to be commit 19205b8d89d3d7e99a65938f59412e0c4e8ac5fe)
2006-01-25 12:19:49 +00:00
nprivates = talloc(ntvfs, struct nbench_private);
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
if (!nprivates) {
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
return NT_STATUS_NO_MEMORY;
}
r3337: remove debug code and reanable the reall logging:-) metze (This used to be commit 00b285e5a815e6d53ede7d102dee4e5b79d47f52)
2004-10-28 22:18:52 +00:00
r2751: this is a new ntvfs design which tries to solve: - the stacking of modules - finding the modules private data - hide the ntvfs details from the calling layer - I set NTVFS_INTERFACE_VERSION 0 till we are closer to release (because we need to solve some async problems with the module stacking) metze (This used to be commit 3ff03b5cb21bb79afdd3b1609be9635f6688a539)
2004-09-29 13:17:09 +00:00
asprintf(&logname, "/tmp/nbenchlog%d.%u", ntvfs->depth, getpid());
r3441: some include file cleanups and general housekeeping (This used to be commit 73ea8ee6c268371d05cf74160f2ad451dd2ae699)
2004-11-01 20:21:54 +00:00
nprivates->log_fd = open(logname, O_WRONLY|O_CREAT|O_APPEND, 0644);
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
free(logname);
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
if (nprivates->log_fd == -1) {
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
DEBUG(0,("Failed to open nbench log\n"));
return NT_STATUS_UNSUCCESSFUL;
}
r3337: remove debug code and reanable the reall logging:-) metze (This used to be commit 00b285e5a815e6d53ede7d102dee4e5b79d47f52)
2004-10-28 22:18:52 +00:00
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
ntvfs->private_data = nprivates;
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
r2751: this is a new ntvfs design which tries to solve: - the stacking of modules - finding the modules private data - hide the ntvfs details from the calling layer - I set NTVFS_INTERFACE_VERSION 0 till we are closer to release (because we need to solve some async problems with the module stacking) metze (This used to be commit 3ff03b5cb21bb79afdd3b1609be9635f6688a539)
2004-09-29 13:17:09 +00:00
status = ntvfs_next_connect(ntvfs, req, sharename);
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
return status;
}
/*
disconnect from a share
*/
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
static NTSTATUS nbench_disconnect(struct ntvfs_module_context *ntvfs)
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
{
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
struct nbench_private *nprivates = ntvfs->private_data;
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
NTSTATUS status;
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
close(nprivates->log_fd);
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
status = ntvfs_next_disconnect(ntvfs);
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
return status;
}
/*
delete a file - the dirtype specifies the file types to include in the search.
The name can contain CIFS wildcards, but rarely does (except with OS/2 clients)
*/
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
static void nbench_unlink_send(struct ntvfs_request *req)
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
{
r14173: change smb interface structures to always use a union smb_file, to abtract - const char *path fot qpathinfo and setpathinfo - uint16_t fnum for SMB - smb2_handle handle for SMB2 the idea is to later add a struct ntvfs_handle *ntvfs so that the ntvfs subsystem don't need to know the difference between SMB and SMB2 metze (This used to be commit 2ef3f5970901b5accdb50f0d0115b5d46b0c788f)
2006-03-10 20:49:20 +00:00
union smb_unlink *unl = req->async_states->private_data;
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
r3346: - simplified vfs_nbench.c a bit, by using req->async_state->ntvfs inside nbench_log() instead of declaring nprivates every time. - added correct async_setup pass-thru in nbench (This used to be commit 8d79bceeca4528ab31cff1adc7706faa075013ac)
2004-10-29 00:51:41 +00:00
nbench_log(req, "Unlink \"%s\" 0x%x %s\n",
r14173: change smb interface structures to always use a union smb_file, to abtract - const char *path fot qpathinfo and setpathinfo - uint16_t fnum for SMB - smb2_handle handle for SMB2 the idea is to later add a struct ntvfs_handle *ntvfs so that the ntvfs subsystem don't need to know the difference between SMB and SMB2 metze (This used to be commit 2ef3f5970901b5accdb50f0d0115b5d46b0c788f)
2006-03-10 20:49:20 +00:00
unl->unlink.in.pattern, unl->unlink.in.attrib,
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
get_nt_error_c_code(req->async_states->status));
PASS_THRU_REP_POST(req);
}
r2751: this is a new ntvfs design which tries to solve: - the stacking of modules - finding the modules private data - hide the ntvfs details from the calling layer - I set NTVFS_INTERFACE_VERSION 0 till we are closer to release (because we need to solve some async problems with the module stacking) metze (This used to be commit 3ff03b5cb21bb79afdd3b1609be9635f6688a539)
2004-09-29 13:17:09 +00:00
static NTSTATUS nbench_unlink(struct ntvfs_module_context *ntvfs,
r14173: change smb interface structures to always use a union smb_file, to abtract - const char *path fot qpathinfo and setpathinfo - uint16_t fnum for SMB - smb2_handle handle for SMB2 the idea is to later add a struct ntvfs_handle *ntvfs so that the ntvfs subsystem don't need to know the difference between SMB and SMB2 metze (This used to be commit 2ef3f5970901b5accdb50f0d0115b5d46b0c788f)
2006-03-10 20:49:20 +00:00
struct ntvfs_request *req,
union smb_unlink *unl)
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
{
NTSTATUS status;
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
PASS_THRU_REQ(ntvfs, req, unlink, unl, (ntvfs, req, unl));
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
return status;
}
/*
ioctl interface
*/
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
static void nbench_ioctl_send(struct ntvfs_request *req)
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
{
r3346: - simplified vfs_nbench.c a bit, by using req->async_state->ntvfs inside nbench_log() instead of declaring nprivates every time. - added correct async_setup pass-thru in nbench (This used to be commit 8d79bceeca4528ab31cff1adc7706faa075013ac)
2004-10-29 00:51:41 +00:00
nbench_log(req, "Ioctl - NOT HANDLED\n");
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
PASS_THRU_REP_POST(req);
}
r2751: this is a new ntvfs design which tries to solve: - the stacking of modules - finding the modules private data - hide the ntvfs details from the calling layer - I set NTVFS_INTERFACE_VERSION 0 till we are closer to release (because we need to solve some async problems with the module stacking) metze (This used to be commit 3ff03b5cb21bb79afdd3b1609be9635f6688a539)
2004-09-29 13:17:09 +00:00
static NTSTATUS nbench_ioctl(struct ntvfs_module_context *ntvfs,
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
struct ntvfs_request *req, union smb_ioctl *io)
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
{
NTSTATUS status;
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
PASS_THRU_REQ(ntvfs, req, ioctl, io, (ntvfs, req, io));
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
return status;
}
/*
check if a directory exists
*/
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
static void nbench_chkpath_send(struct ntvfs_request *req)
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
{
r14173: change smb interface structures to always use a union smb_file, to abtract - const char *path fot qpathinfo and setpathinfo - uint16_t fnum for SMB - smb2_handle handle for SMB2 the idea is to later add a struct ntvfs_handle *ntvfs so that the ntvfs subsystem don't need to know the difference between SMB and SMB2 metze (This used to be commit 2ef3f5970901b5accdb50f0d0115b5d46b0c788f)
2006-03-10 20:49:20 +00:00
union smb_chkpath *cp = req->async_states->private_data;
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
r3346: - simplified vfs_nbench.c a bit, by using req->async_state->ntvfs inside nbench_log() instead of declaring nprivates every time. - added correct async_setup pass-thru in nbench (This used to be commit 8d79bceeca4528ab31cff1adc7706faa075013ac)
2004-10-29 00:51:41 +00:00
nbench_log(req, "Chkpath \"%s\" %s\n",
r14173: change smb interface structures to always use a union smb_file, to abtract - const char *path fot qpathinfo and setpathinfo - uint16_t fnum for SMB - smb2_handle handle for SMB2 the idea is to later add a struct ntvfs_handle *ntvfs so that the ntvfs subsystem don't need to know the difference between SMB and SMB2 metze (This used to be commit 2ef3f5970901b5accdb50f0d0115b5d46b0c788f)
2006-03-10 20:49:20 +00:00
cp->chkpath.in.path,
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
get_nt_error_c_code(req->async_states->status));
PASS_THRU_REP_POST(req);
}
r2751: this is a new ntvfs design which tries to solve: - the stacking of modules - finding the modules private data - hide the ntvfs details from the calling layer - I set NTVFS_INTERFACE_VERSION 0 till we are closer to release (because we need to solve some async problems with the module stacking) metze (This used to be commit 3ff03b5cb21bb79afdd3b1609be9635f6688a539)
2004-09-29 13:17:09 +00:00
static NTSTATUS nbench_chkpath(struct ntvfs_module_context *ntvfs,
r14173: change smb interface structures to always use a union smb_file, to abtract - const char *path fot qpathinfo and setpathinfo - uint16_t fnum for SMB - smb2_handle handle for SMB2 the idea is to later add a struct ntvfs_handle *ntvfs so that the ntvfs subsystem don't need to know the difference between SMB and SMB2 metze (This used to be commit 2ef3f5970901b5accdb50f0d0115b5d46b0c788f)
2006-03-10 20:49:20 +00:00
struct ntvfs_request *req,
union smb_chkpath *cp)
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
{
NTSTATUS status;
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
PASS_THRU_REQ(ntvfs, req, chkpath, cp, (ntvfs, req, cp));
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
return status;
}
/*
return info on a pathname
*/
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
static void nbench_qpathinfo_send(struct ntvfs_request *req)
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
{
union smb_fileinfo *info = req->async_states->private_data;
r3346: - simplified vfs_nbench.c a bit, by using req->async_state->ntvfs inside nbench_log() instead of declaring nprivates every time. - added correct async_setup pass-thru in nbench (This used to be commit 8d79bceeca4528ab31cff1adc7706faa075013ac)
2004-10-29 00:51:41 +00:00
nbench_log(req, "QUERY_PATH_INFORMATION \"%s\" %d %s\n",
r14256: - rename smb_file -> smb_handle - move it into the in/out substructs again - allow file.path only on smb_fileinfo/smb_setfileinfo metze (This used to be commit be6d5298a2cdb7e7c61d70471bad445645af5963)
2006-03-12 22:48:25 +00:00
info->generic.in.file.path,
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
info->generic.level,
get_nt_error_c_code(req->async_states->status));
PASS_THRU_REP_POST(req);
}
r2751: this is a new ntvfs design which tries to solve: - the stacking of modules - finding the modules private data - hide the ntvfs details from the calling layer - I set NTVFS_INTERFACE_VERSION 0 till we are closer to release (because we need to solve some async problems with the module stacking) metze (This used to be commit 3ff03b5cb21bb79afdd3b1609be9635f6688a539)
2004-09-29 13:17:09 +00:00
static NTSTATUS nbench_qpathinfo(struct ntvfs_module_context *ntvfs,
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
struct ntvfs_request *req, union smb_fileinfo *info)
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
{
NTSTATUS status;
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
PASS_THRU_REQ(ntvfs, req, qpathinfo, info, (ntvfs, req, info));
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
return status;
}
/*
query info on a open file
*/
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
static void nbench_qfileinfo_send(struct ntvfs_request *req)
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
{
union smb_fileinfo *info = req->async_states->private_data;
r3346: - simplified vfs_nbench.c a bit, by using req->async_state->ntvfs inside nbench_log() instead of declaring nprivates every time. - added correct async_setup pass-thru in nbench (This used to be commit 8d79bceeca4528ab31cff1adc7706faa075013ac)
2004-10-29 00:51:41 +00:00
nbench_log(req, "QUERY_FILE_INFORMATION %d %d %s\n",
r14256: - rename smb_file -> smb_handle - move it into the in/out substructs again - allow file.path only on smb_fileinfo/smb_setfileinfo metze (This used to be commit be6d5298a2cdb7e7c61d70471bad445645af5963)
2006-03-12 22:48:25 +00:00
info->generic.in.file.fnum,
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
info->generic.level,
get_nt_error_c_code(req->async_states->status));
PASS_THRU_REP_POST(req);
}
r2751: this is a new ntvfs design which tries to solve: - the stacking of modules - finding the modules private data - hide the ntvfs details from the calling layer - I set NTVFS_INTERFACE_VERSION 0 till we are closer to release (because we need to solve some async problems with the module stacking) metze (This used to be commit 3ff03b5cb21bb79afdd3b1609be9635f6688a539)
2004-09-29 13:17:09 +00:00
static NTSTATUS nbench_qfileinfo(struct ntvfs_module_context *ntvfs,
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
struct ntvfs_request *req, union smb_fileinfo *info)
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
{
NTSTATUS status;
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
PASS_THRU_REQ(ntvfs, req, qfileinfo, info, (ntvfs, req, info));
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
return status;
}
/*
set info on a pathname
*/
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
static void nbench_setpathinfo_send(struct ntvfs_request *req)
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
{
union smb_setfileinfo *st = req->async_states->private_data;
r3346: - simplified vfs_nbench.c a bit, by using req->async_state->ntvfs inside nbench_log() instead of declaring nprivates every time. - added correct async_setup pass-thru in nbench (This used to be commit 8d79bceeca4528ab31cff1adc7706faa075013ac)
2004-10-29 00:51:41 +00:00
nbench_log(req, "SET_PATH_INFORMATION \"%s\" %d %s\n",
r14256: - rename smb_file -> smb_handle - move it into the in/out substructs again - allow file.path only on smb_fileinfo/smb_setfileinfo metze (This used to be commit be6d5298a2cdb7e7c61d70471bad445645af5963)
2006-03-12 22:48:25 +00:00
st->generic.in.file.path,
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
st->generic.level,
get_nt_error_c_code(req->async_states->status));
PASS_THRU_REP_POST(req);
}
r2751: this is a new ntvfs design which tries to solve: - the stacking of modules - finding the modules private data - hide the ntvfs details from the calling layer - I set NTVFS_INTERFACE_VERSION 0 till we are closer to release (because we need to solve some async problems with the module stacking) metze (This used to be commit 3ff03b5cb21bb79afdd3b1609be9635f6688a539)
2004-09-29 13:17:09 +00:00
static NTSTATUS nbench_setpathinfo(struct ntvfs_module_context *ntvfs,
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
struct ntvfs_request *req, union smb_setfileinfo *st)
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
{
NTSTATUS status;
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
PASS_THRU_REQ(ntvfs, req, setpathinfo, st, (ntvfs, req, st));
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
return status;
}
/*
open a file
*/
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
static void nbench_open_send(struct ntvfs_request *req)
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
{
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
union smb_open *io = req->async_states->private_data;
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
switch (io->generic.level) {
case RAW_OPEN_NTCREATEX:
r3349: fixed more uninitialised variable problems with the nbench module (This used to be commit 915faf49350b29a46f39354cbac746455d70c92c)
2004-10-29 01:22:47 +00:00
if (!NT_STATUS_IS_OK(req->async_states->status)) {
ZERO_STRUCT(io->ntcreatex.out);
}
r3346: - simplified vfs_nbench.c a bit, by using req->async_state->ntvfs inside nbench_log() instead of declaring nprivates every time. - added correct async_setup pass-thru in nbench (This used to be commit 8d79bceeca4528ab31cff1adc7706faa075013ac)
2004-10-29 00:51:41 +00:00
nbench_log(req, "NTCreateX \"%s\" 0x%x 0x%x %d %s\n",
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
io->ntcreatex.in.fname,
io->ntcreatex.in.create_options,
io->ntcreatex.in.open_disposition,
r14256: - rename smb_file -> smb_handle - move it into the in/out substructs again - allow file.path only on smb_fileinfo/smb_setfileinfo metze (This used to be commit be6d5298a2cdb7e7c61d70471bad445645af5963)
2006-03-12 22:48:25 +00:00
io->ntcreatex.out.file.fnum,
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
get_nt_error_c_code(req->async_states->status));
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
break;
default:
r3346: - simplified vfs_nbench.c a bit, by using req->async_state->ntvfs inside nbench_log() instead of declaring nprivates every time. - added correct async_setup pass-thru in nbench (This used to be commit 8d79bceeca4528ab31cff1adc7706faa075013ac)
2004-10-29 00:51:41 +00:00
nbench_log(req, "Open-%d - NOT HANDLED\n",
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
io->generic.level);
break;
}
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
PASS_THRU_REP_POST(req);
}
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
static NTSTATUS nbench_open(struct ntvfs_module_context *ntvfs,
struct ntvfs_request *req, union smb_open *io)
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
{
NTSTATUS status;
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
PASS_THRU_REQ(ntvfs, req, open, io, (ntvfs, req, io));
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
return status;
}
/*
create a directory
*/
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
static void nbench_mkdir_send(struct ntvfs_request *req)
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
{
r3346: - simplified vfs_nbench.c a bit, by using req->async_state->ntvfs inside nbench_log() instead of declaring nprivates every time. - added correct async_setup pass-thru in nbench (This used to be commit 8d79bceeca4528ab31cff1adc7706faa075013ac)
2004-10-29 00:51:41 +00:00
nbench_log(req, "Mkdir - NOT HANDLED\n");
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
PASS_THRU_REP_POST(req);
}
r2751: this is a new ntvfs design which tries to solve: - the stacking of modules - finding the modules private data - hide the ntvfs details from the calling layer - I set NTVFS_INTERFACE_VERSION 0 till we are closer to release (because we need to solve some async problems with the module stacking) metze (This used to be commit 3ff03b5cb21bb79afdd3b1609be9635f6688a539)
2004-09-29 13:17:09 +00:00
static NTSTATUS nbench_mkdir(struct ntvfs_module_context *ntvfs,
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
struct ntvfs_request *req, union smb_mkdir *md)
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
{
NTSTATUS status;
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
PASS_THRU_REQ(ntvfs, req, mkdir, md, (ntvfs, req, md));
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
return status;
}
/*
remove a directory
*/
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
static void nbench_rmdir_send(struct ntvfs_request *req)
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
{
struct smb_rmdir *rd = req->async_states->private_data;
r3346: - simplified vfs_nbench.c a bit, by using req->async_state->ntvfs inside nbench_log() instead of declaring nprivates every time. - added correct async_setup pass-thru in nbench (This used to be commit 8d79bceeca4528ab31cff1adc7706faa075013ac)
2004-10-29 00:51:41 +00:00
nbench_log(req, "Rmdir \"%s\" %s\n",
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
rd->in.path,
get_nt_error_c_code(req->async_states->status));
PASS_THRU_REP_POST(req);
}
r2751: this is a new ntvfs design which tries to solve: - the stacking of modules - finding the modules private data - hide the ntvfs details from the calling layer - I set NTVFS_INTERFACE_VERSION 0 till we are closer to release (because we need to solve some async problems with the module stacking) metze (This used to be commit 3ff03b5cb21bb79afdd3b1609be9635f6688a539)
2004-09-29 13:17:09 +00:00
static NTSTATUS nbench_rmdir(struct ntvfs_module_context *ntvfs,
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
struct ntvfs_request *req, struct smb_rmdir *rd)
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
{
NTSTATUS status;
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
PASS_THRU_REQ(ntvfs, req, rmdir, rd, (ntvfs, req, rd));
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
return status;
}
/*
rename a set of files
*/
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
static void nbench_rename_send(struct ntvfs_request *req)
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
{
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
union smb_rename *ren = req->async_states->private_data;
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
switch (ren->generic.level) {
case RAW_RENAME_RENAME:
r3346: - simplified vfs_nbench.c a bit, by using req->async_state->ntvfs inside nbench_log() instead of declaring nprivates every time. - added correct async_setup pass-thru in nbench (This used to be commit 8d79bceeca4528ab31cff1adc7706faa075013ac)
2004-10-29 00:51:41 +00:00
nbench_log(req, "Rename \"%s\" \"%s\" %s\n",
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
ren->rename.in.pattern1,
ren->rename.in.pattern2,
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
get_nt_error_c_code(req->async_states->status));
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
break;
default:
r3346: - simplified vfs_nbench.c a bit, by using req->async_state->ntvfs inside nbench_log() instead of declaring nprivates every time. - added correct async_setup pass-thru in nbench (This used to be commit 8d79bceeca4528ab31cff1adc7706faa075013ac)
2004-10-29 00:51:41 +00:00
nbench_log(req, "Rename-%d - NOT HANDLED\n",
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
ren->generic.level);
break;
}
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
PASS_THRU_REP_POST(req);
}
static NTSTATUS nbench_rename(struct ntvfs_module_context *ntvfs,
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
struct ntvfs_request *req, union smb_rename *ren)
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
{
NTSTATUS status;
PASS_THRU_REQ(ntvfs, req, rename, ren, (ntvfs, req, ren));
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
return status;
}
/*
copy a set of files
*/
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
static void nbench_copy_send(struct ntvfs_request *req)
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
{
r3346: - simplified vfs_nbench.c a bit, by using req->async_state->ntvfs inside nbench_log() instead of declaring nprivates every time. - added correct async_setup pass-thru in nbench (This used to be commit 8d79bceeca4528ab31cff1adc7706faa075013ac)
2004-10-29 00:51:41 +00:00
nbench_log(req, "Copy - NOT HANDLED\n");
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
PASS_THRU_REP_POST(req);
}
r2751: this is a new ntvfs design which tries to solve: - the stacking of modules - finding the modules private data - hide the ntvfs details from the calling layer - I set NTVFS_INTERFACE_VERSION 0 till we are closer to release (because we need to solve some async problems with the module stacking) metze (This used to be commit 3ff03b5cb21bb79afdd3b1609be9635f6688a539)
2004-09-29 13:17:09 +00:00
static NTSTATUS nbench_copy(struct ntvfs_module_context *ntvfs,
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
struct ntvfs_request *req, struct smb_copy *cp)
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
{
NTSTATUS status;
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
PASS_THRU_REQ(ntvfs, req, copy, cp, (ntvfs, req, cp));
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
return status;
}
/*
read from a file
*/
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
static void nbench_read_send(struct ntvfs_request *req)
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
{
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
union smb_read *rd = req->async_states->private_data;
r3347: fixed an uninitialised variable bug. Surprisingly hard to track down, as valgrind got a corrupt stack when trying to debug it. (This used to be commit 58cabaa7022e5521961551462d31fbd90e4183e4)
2004-10-29 01:07:07 +00:00
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
switch (rd->generic.level) {
case RAW_READ_READX:
r3349: fixed more uninitialised variable problems with the nbench module (This used to be commit 915faf49350b29a46f39354cbac746455d70c92c)
2004-10-29 01:22:47 +00:00
if (!NT_STATUS_IS_OK(req->async_states->status)) {
ZERO_STRUCT(rd->readx.out);
r3347: fixed an uninitialised variable bug. Surprisingly hard to track down, as valgrind got a corrupt stack when trying to debug it. (This used to be commit 58cabaa7022e5521961551462d31fbd90e4183e4)
2004-10-29 01:07:07 +00:00
}
r3346: - simplified vfs_nbench.c a bit, by using req->async_state->ntvfs inside nbench_log() instead of declaring nprivates every time. - added correct async_setup pass-thru in nbench (This used to be commit 8d79bceeca4528ab31cff1adc7706faa075013ac)
2004-10-29 00:51:41 +00:00
nbench_log(req, "ReadX %d %d %d %d %s\n",
r14256: - rename smb_file -> smb_handle - move it into the in/out substructs again - allow file.path only on smb_fileinfo/smb_setfileinfo metze (This used to be commit be6d5298a2cdb7e7c61d70471bad445645af5963)
2006-03-12 22:48:25 +00:00
rd->readx.in.file.fnum,
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
(int)rd->readx.in.offset,
rd->readx.in.maxcnt,
r3349: fixed more uninitialised variable problems with the nbench module (This used to be commit 915faf49350b29a46f39354cbac746455d70c92c)
2004-10-29 01:22:47 +00:00
rd->readx.out.nread,
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
get_nt_error_c_code(req->async_states->status));
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
break;
default:
r3346: - simplified vfs_nbench.c a bit, by using req->async_state->ntvfs inside nbench_log() instead of declaring nprivates every time. - added correct async_setup pass-thru in nbench (This used to be commit 8d79bceeca4528ab31cff1adc7706faa075013ac)
2004-10-29 00:51:41 +00:00
nbench_log(req, "Read-%d - NOT HANDLED\n",
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
rd->generic.level);
break;
}
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
PASS_THRU_REP_POST(req);
}
static NTSTATUS nbench_read(struct ntvfs_module_context *ntvfs,
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
struct ntvfs_request *req, union smb_read *rd)
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
{
NTSTATUS status;
PASS_THRU_REQ(ntvfs, req, read, rd, (ntvfs, req, rd));
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
return status;
}
/*
write to a file
*/
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
static void nbench_write_send(struct ntvfs_request *req)
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
{
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
union smb_write *wr = req->async_states->private_data;
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
switch (wr->generic.level) {
case RAW_WRITE_WRITEX:
r3349: fixed more uninitialised variable problems with the nbench module (This used to be commit 915faf49350b29a46f39354cbac746455d70c92c)
2004-10-29 01:22:47 +00:00
if (!NT_STATUS_IS_OK(req->async_states->status)) {
ZERO_STRUCT(wr->writex.out);
}
r3346: - simplified vfs_nbench.c a bit, by using req->async_state->ntvfs inside nbench_log() instead of declaring nprivates every time. - added correct async_setup pass-thru in nbench (This used to be commit 8d79bceeca4528ab31cff1adc7706faa075013ac)
2004-10-29 00:51:41 +00:00
nbench_log(req, "WriteX %d %d %d %d %s\n",
r14256: - rename smb_file -> smb_handle - move it into the in/out substructs again - allow file.path only on smb_fileinfo/smb_setfileinfo metze (This used to be commit be6d5298a2cdb7e7c61d70471bad445645af5963)
2006-03-12 22:48:25 +00:00
wr->writex.in.file.fnum,
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
(int)wr->writex.in.offset,
wr->writex.in.count,
wr->writex.out.nwritten,
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
get_nt_error_c_code(req->async_states->status));
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
break;
case RAW_WRITE_WRITE:
r3349: fixed more uninitialised variable problems with the nbench module (This used to be commit 915faf49350b29a46f39354cbac746455d70c92c)
2004-10-29 01:22:47 +00:00
if (!NT_STATUS_IS_OK(req->async_states->status)) {
ZERO_STRUCT(wr->write.out);
}
r3346: - simplified vfs_nbench.c a bit, by using req->async_state->ntvfs inside nbench_log() instead of declaring nprivates every time. - added correct async_setup pass-thru in nbench (This used to be commit 8d79bceeca4528ab31cff1adc7706faa075013ac)
2004-10-29 00:51:41 +00:00
nbench_log(req, "Write %d %d %d %d %s\n",
r14256: - rename smb_file -> smb_handle - move it into the in/out substructs again - allow file.path only on smb_fileinfo/smb_setfileinfo metze (This used to be commit be6d5298a2cdb7e7c61d70471bad445645af5963)
2006-03-12 22:48:25 +00:00
wr->write.in.file.fnum,
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
wr->write.in.offset,
wr->write.in.count,
wr->write.out.nwritten,
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
get_nt_error_c_code(req->async_states->status));
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
break;
default:
r3346: - simplified vfs_nbench.c a bit, by using req->async_state->ntvfs inside nbench_log() instead of declaring nprivates every time. - added correct async_setup pass-thru in nbench (This used to be commit 8d79bceeca4528ab31cff1adc7706faa075013ac)
2004-10-29 00:51:41 +00:00
nbench_log(req, "Write-%d - NOT HANDLED\n",
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
wr->generic.level);
break;
}
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
PASS_THRU_REP_POST(req);
}
static NTSTATUS nbench_write(struct ntvfs_module_context *ntvfs,
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
struct ntvfs_request *req, union smb_write *wr)
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
{
NTSTATUS status;
PASS_THRU_REQ(ntvfs, req, write, wr, (ntvfs, req, wr));
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
return status;
}
/*
seek in a file
*/
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
static void nbench_seek_send(struct ntvfs_request *req)
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
{
r3346: - simplified vfs_nbench.c a bit, by using req->async_state->ntvfs inside nbench_log() instead of declaring nprivates every time. - added correct async_setup pass-thru in nbench (This used to be commit 8d79bceeca4528ab31cff1adc7706faa075013ac)
2004-10-29 00:51:41 +00:00
nbench_log(req, "Seek - NOT HANDLED\n");
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
PASS_THRU_REP_POST(req);
}
r2751: this is a new ntvfs design which tries to solve: - the stacking of modules - finding the modules private data - hide the ntvfs details from the calling layer - I set NTVFS_INTERFACE_VERSION 0 till we are closer to release (because we need to solve some async problems with the module stacking) metze (This used to be commit 3ff03b5cb21bb79afdd3b1609be9635f6688a539)
2004-09-29 13:17:09 +00:00
static NTSTATUS nbench_seek(struct ntvfs_module_context *ntvfs,
r14173: change smb interface structures to always use a union smb_file, to abtract - const char *path fot qpathinfo and setpathinfo - uint16_t fnum for SMB - smb2_handle handle for SMB2 the idea is to later add a struct ntvfs_handle *ntvfs so that the ntvfs subsystem don't need to know the difference between SMB and SMB2 metze (This used to be commit 2ef3f5970901b5accdb50f0d0115b5d46b0c788f)
2006-03-10 20:49:20 +00:00
struct ntvfs_request *req,
union smb_seek *io)
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
{
NTSTATUS status;
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
PASS_THRU_REQ(ntvfs, req, seek, io, (ntvfs, req, io));
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
return status;
}
/*
flush a file
*/
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
static void nbench_flush_send(struct ntvfs_request *req)
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
{
r14173: change smb interface structures to always use a union smb_file, to abtract - const char *path fot qpathinfo and setpathinfo - uint16_t fnum for SMB - smb2_handle handle for SMB2 the idea is to later add a struct ntvfs_handle *ntvfs so that the ntvfs subsystem don't need to know the difference between SMB and SMB2 metze (This used to be commit 2ef3f5970901b5accdb50f0d0115b5d46b0c788f)
2006-03-10 20:49:20 +00:00
union smb_flush *io = req->async_states->private_data;
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
r3346: - simplified vfs_nbench.c a bit, by using req->async_state->ntvfs inside nbench_log() instead of declaring nprivates every time. - added correct async_setup pass-thru in nbench (This used to be commit 8d79bceeca4528ab31cff1adc7706faa075013ac)
2004-10-29 00:51:41 +00:00
nbench_log(req, "Flush %d %s\n",
r14256: - rename smb_file -> smb_handle - move it into the in/out substructs again - allow file.path only on smb_fileinfo/smb_setfileinfo metze (This used to be commit be6d5298a2cdb7e7c61d70471bad445645af5963)
2006-03-12 22:48:25 +00:00
io->flush.in.file.fnum,
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
get_nt_error_c_code(req->async_states->status));
PASS_THRU_REP_POST(req);
}
r2751: this is a new ntvfs design which tries to solve: - the stacking of modules - finding the modules private data - hide the ntvfs details from the calling layer - I set NTVFS_INTERFACE_VERSION 0 till we are closer to release (because we need to solve some async problems with the module stacking) metze (This used to be commit 3ff03b5cb21bb79afdd3b1609be9635f6688a539)
2004-09-29 13:17:09 +00:00
static NTSTATUS nbench_flush(struct ntvfs_module_context *ntvfs,
r14173: change smb interface structures to always use a union smb_file, to abtract - const char *path fot qpathinfo and setpathinfo - uint16_t fnum for SMB - smb2_handle handle for SMB2 the idea is to later add a struct ntvfs_handle *ntvfs so that the ntvfs subsystem don't need to know the difference between SMB and SMB2 metze (This used to be commit 2ef3f5970901b5accdb50f0d0115b5d46b0c788f)
2006-03-10 20:49:20 +00:00
struct ntvfs_request *req,
union smb_flush *io)
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
{
NTSTATUS status;
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
PASS_THRU_REQ(ntvfs, req, flush, io, (ntvfs, req, io));
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
return status;
}
/*
close a file
*/
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
static void nbench_close_send(struct ntvfs_request *req)
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
{
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
union smb_close *io = req->async_states->private_data;
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
switch (io->generic.level) {
case RAW_CLOSE_CLOSE:
r3346: - simplified vfs_nbench.c a bit, by using req->async_state->ntvfs inside nbench_log() instead of declaring nprivates every time. - added correct async_setup pass-thru in nbench (This used to be commit 8d79bceeca4528ab31cff1adc7706faa075013ac)
2004-10-29 00:51:41 +00:00
nbench_log(req, "Close %d %s\n",
r14256: - rename smb_file -> smb_handle - move it into the in/out substructs again - allow file.path only on smb_fileinfo/smb_setfileinfo metze (This used to be commit be6d5298a2cdb7e7c61d70471bad445645af5963)
2006-03-12 22:48:25 +00:00
io->close.in.file.fnum,
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
get_nt_error_c_code(req->async_states->status));
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
break;
default:
r3346: - simplified vfs_nbench.c a bit, by using req->async_state->ntvfs inside nbench_log() instead of declaring nprivates every time. - added correct async_setup pass-thru in nbench (This used to be commit 8d79bceeca4528ab31cff1adc7706faa075013ac)
2004-10-29 00:51:41 +00:00
nbench_log(req, "Close-%d - NOT HANDLED\n",
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
io->generic.level);
break;
}
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
PASS_THRU_REP_POST(req);
}
static NTSTATUS nbench_close(struct ntvfs_module_context *ntvfs,
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
struct ntvfs_request *req, union smb_close *io)
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
{
NTSTATUS status;
PASS_THRU_REQ(ntvfs, req, close, io, (ntvfs, req, io));
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
return status;
}
/*
exit - closing files
*/
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
static void nbench_exit_send(struct ntvfs_request *req)
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
{
r3346: - simplified vfs_nbench.c a bit, by using req->async_state->ntvfs inside nbench_log() instead of declaring nprivates every time. - added correct async_setup pass-thru in nbench (This used to be commit 8d79bceeca4528ab31cff1adc7706faa075013ac)
2004-10-29 00:51:41 +00:00
nbench_log(req, "Exit - NOT HANDLED\n");
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
PASS_THRU_REP_POST(req);
}
r2751: this is a new ntvfs design which tries to solve: - the stacking of modules - finding the modules private data - hide the ntvfs details from the calling layer - I set NTVFS_INTERFACE_VERSION 0 till we are closer to release (because we need to solve some async problems with the module stacking) metze (This used to be commit 3ff03b5cb21bb79afdd3b1609be9635f6688a539)
2004-09-29 13:17:09 +00:00
static NTSTATUS nbench_exit(struct ntvfs_module_context *ntvfs,
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
struct ntvfs_request *req)
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
{
NTSTATUS status;
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
PASS_THRU_REQ(ntvfs, req, exit, NULL, (ntvfs, req));
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
return status;
}
r2660: - converted the libcli/raw/ library to use talloc_increase_ref_count() rather than manual reference counts - properly support SMBexit in the cifs and posix backends - added a logoff method to all backends With these changes the RAW-CONTEXT test now passes against the posix backend (This used to be commit c315d6ac1cc40546fde1474702a6d66d07ee13c8)
2004-09-26 11:30:20 +00:00
/*
logoff - closing files
*/
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
static void nbench_logoff_send(struct ntvfs_request *req)
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
{
r3346: - simplified vfs_nbench.c a bit, by using req->async_state->ntvfs inside nbench_log() instead of declaring nprivates every time. - added correct async_setup pass-thru in nbench (This used to be commit 8d79bceeca4528ab31cff1adc7706faa075013ac)
2004-10-29 00:51:41 +00:00
nbench_log(req, "Logoff - NOT HANDLED\n");
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
PASS_THRU_REP_POST(req);
}
r2751: this is a new ntvfs design which tries to solve: - the stacking of modules - finding the modules private data - hide the ntvfs details from the calling layer - I set NTVFS_INTERFACE_VERSION 0 till we are closer to release (because we need to solve some async problems with the module stacking) metze (This used to be commit 3ff03b5cb21bb79afdd3b1609be9635f6688a539)
2004-09-29 13:17:09 +00:00
static NTSTATUS nbench_logoff(struct ntvfs_module_context *ntvfs,
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
struct ntvfs_request *req)
r2660: - converted the libcli/raw/ library to use talloc_increase_ref_count() rather than manual reference counts - properly support SMBexit in the cifs and posix backends - added a logoff method to all backends With these changes the RAW-CONTEXT test now passes against the posix backend (This used to be commit c315d6ac1cc40546fde1474702a6d66d07ee13c8)
2004-09-26 11:30:20 +00:00
{
NTSTATUS status;
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
PASS_THRU_REQ(ntvfs, req, logoff, NULL, (ntvfs, req));
r2660: - converted the libcli/raw/ library to use talloc_increase_ref_count() rather than manual reference counts - properly support SMBexit in the cifs and posix backends - added a logoff method to all backends With these changes the RAW-CONTEXT test now passes against the posix backend (This used to be commit c315d6ac1cc40546fde1474702a6d66d07ee13c8)
2004-09-26 11:30:20 +00:00
return status;
}
r3346: - simplified vfs_nbench.c a bit, by using req->async_state->ntvfs inside nbench_log() instead of declaring nprivates every time. - added correct async_setup pass-thru in nbench (This used to be commit 8d79bceeca4528ab31cff1adc7706faa075013ac)
2004-10-29 00:51:41 +00:00
/*
async_setup - send fn
*/
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
static void nbench_async_setup_send(struct ntvfs_request *req)
r3346: - simplified vfs_nbench.c a bit, by using req->async_state->ntvfs inside nbench_log() instead of declaring nprivates every time. - added correct async_setup pass-thru in nbench (This used to be commit 8d79bceeca4528ab31cff1adc7706faa075013ac)
2004-10-29 00:51:41 +00:00
{
PASS_THRU_REP_POST(req);
}
r3039: This solves the problem of async handlers in ntvfs backends not being in the right state when called. For example, when we use the unixuid handler in the chain of handlers, and a backend decides to continue a call asynchronously then we need to ensure that the continuation happens with the right security context. The solution is to add a new ntvfs operation ntvfs_async_setup(), which calls all the way down through the layers, setting up anything that is required, and takes a private pointer. The backend wanting to make a async calls can use ntvfs_async_setup() to ensure that the modules above it are called when doing async processing. (This used to be commit a256e71029727fa1659ade6257085df537308c7d)
2004-10-18 13:27:22 +00:00
/*
async setup
*/
static NTSTATUS nbench_async_setup(struct ntvfs_module_context *ntvfs,
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
struct ntvfs_request *req,
r3039: This solves the problem of async handlers in ntvfs backends not being in the right state when called. For example, when we use the unixuid handler in the chain of handlers, and a backend decides to continue a call asynchronously then we need to ensure that the continuation happens with the right security context. The solution is to add a new ntvfs operation ntvfs_async_setup(), which calls all the way down through the layers, setting up anything that is required, and takes a private pointer. The backend wanting to make a async calls can use ntvfs_async_setup() to ensure that the modules above it are called when doing async processing. (This used to be commit a256e71029727fa1659ade6257085df537308c7d)
2004-10-18 13:27:22 +00:00
void *private)
{
r3346: - simplified vfs_nbench.c a bit, by using req->async_state->ntvfs inside nbench_log() instead of declaring nprivates every time. - added correct async_setup pass-thru in nbench (This used to be commit 8d79bceeca4528ab31cff1adc7706faa075013ac)
2004-10-29 00:51:41 +00:00
NTSTATUS status;
PASS_THRU_REQ(ntvfs, req, async_setup, NULL, (ntvfs, req, private));
return status;
r3039: This solves the problem of async handlers in ntvfs backends not being in the right state when called. For example, when we use the unixuid handler in the chain of handlers, and a backend decides to continue a call asynchronously then we need to ensure that the continuation happens with the right security context. The solution is to add a new ntvfs operation ntvfs_async_setup(), which calls all the way down through the layers, setting up anything that is required, and takes a private pointer. The backend wanting to make a async calls can use ntvfs_async_setup() to ensure that the modules above it are called when doing async processing. (This used to be commit a256e71029727fa1659ade6257085df537308c7d)
2004-10-18 13:27:22 +00:00
}
r3528: added support for the SMBntcancel() operation, which cancels any outstanding async operation (triggering an immediate timeout). pvfs now passes the RAW-MUX test (This used to be commit 3423e2f41461d054067ef168b9b986f62cc8f77c)
2004-11-04 11:28:38 +00:00
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
static void nbench_cancel_send(struct ntvfs_request *req)
r3528: added support for the SMBntcancel() operation, which cancels any outstanding async operation (triggering an immediate timeout). pvfs now passes the RAW-MUX test (This used to be commit 3423e2f41461d054067ef168b9b986f62cc8f77c)
2004-11-04 11:28:38 +00:00
{
PASS_THRU_REP_POST(req);
}
/*
cancel an existing async request
*/
static NTSTATUS nbench_cancel(struct ntvfs_module_context *ntvfs,
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
struct ntvfs_request *req)
r3528: added support for the SMBntcancel() operation, which cancels any outstanding async operation (triggering an immediate timeout). pvfs now passes the RAW-MUX test (This used to be commit 3423e2f41461d054067ef168b9b986f62cc8f77c)
2004-11-04 11:28:38 +00:00
{
NTSTATUS status;
PASS_THRU_REQ(ntvfs, req, cancel, NULL, (ntvfs, req));
return status;
}
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
/*
lock a byte range
*/
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
static void nbench_lock_send(struct ntvfs_request *req)
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
{
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
union smb_lock *lck = req->async_states->private_data;
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
if (lck->generic.level == RAW_LOCK_LOCKX &&
lck->lockx.in.lock_cnt == 1 &&
lck->lockx.in.ulock_cnt == 0) {
r3346: - simplified vfs_nbench.c a bit, by using req->async_state->ntvfs inside nbench_log() instead of declaring nprivates every time. - added correct async_setup pass-thru in nbench (This used to be commit 8d79bceeca4528ab31cff1adc7706faa075013ac)
2004-10-29 00:51:41 +00:00
nbench_log(req, "LockX %d %d %d %s\n",
r14256: - rename smb_file -> smb_handle - move it into the in/out substructs again - allow file.path only on smb_fileinfo/smb_setfileinfo metze (This used to be commit be6d5298a2cdb7e7c61d70471bad445645af5963)
2006-03-12 22:48:25 +00:00
lck->lockx.in.file.fnum,
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
(int)lck->lockx.in.locks[0].offset,
(int)lck->lockx.in.locks[0].count,
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
get_nt_error_c_code(req->async_states->status));
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
} else if (lck->generic.level == RAW_LOCK_LOCKX &&
lck->lockx.in.ulock_cnt == 1) {
r3346: - simplified vfs_nbench.c a bit, by using req->async_state->ntvfs inside nbench_log() instead of declaring nprivates every time. - added correct async_setup pass-thru in nbench (This used to be commit 8d79bceeca4528ab31cff1adc7706faa075013ac)
2004-10-29 00:51:41 +00:00
nbench_log(req, "UnlockX %d %d %d %s\n",
r14256: - rename smb_file -> smb_handle - move it into the in/out substructs again - allow file.path only on smb_fileinfo/smb_setfileinfo metze (This used to be commit be6d5298a2cdb7e7c61d70471bad445645af5963)
2006-03-12 22:48:25 +00:00
lck->lockx.in.file.fnum,
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
(int)lck->lockx.in.locks[0].offset,
(int)lck->lockx.in.locks[0].count,
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
get_nt_error_c_code(req->async_states->status));
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
} else {
r3346: - simplified vfs_nbench.c a bit, by using req->async_state->ntvfs inside nbench_log() instead of declaring nprivates every time. - added correct async_setup pass-thru in nbench (This used to be commit 8d79bceeca4528ab31cff1adc7706faa075013ac)
2004-10-29 00:51:41 +00:00
nbench_log(req, "Lock-%d - NOT HANDLED\n", lck->generic.level);
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
}
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
PASS_THRU_REP_POST(req);
}
static NTSTATUS nbench_lock(struct ntvfs_module_context *ntvfs,
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
struct ntvfs_request *req, union smb_lock *lck)
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
{
NTSTATUS status;
PASS_THRU_REQ(ntvfs, req, lock, lck, (ntvfs, req, lck));
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
return status;
}
/*
set info on a open file
*/
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
static void nbench_setfileinfo_send(struct ntvfs_request *req)
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
{
union smb_setfileinfo *info = req->async_states->private_data;
r3346: - simplified vfs_nbench.c a bit, by using req->async_state->ntvfs inside nbench_log() instead of declaring nprivates every time. - added correct async_setup pass-thru in nbench (This used to be commit 8d79bceeca4528ab31cff1adc7706faa075013ac)
2004-10-29 00:51:41 +00:00
nbench_log(req, "SET_FILE_INFORMATION %d %d %s\n",
r14256: - rename smb_file -> smb_handle - move it into the in/out substructs again - allow file.path only on smb_fileinfo/smb_setfileinfo metze (This used to be commit be6d5298a2cdb7e7c61d70471bad445645af5963)
2006-03-12 22:48:25 +00:00
info->generic.in.file.fnum,
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
info->generic.level,
get_nt_error_c_code(req->async_states->status));
PASS_THRU_REP_POST(req);
}
r2751: this is a new ntvfs design which tries to solve: - the stacking of modules - finding the modules private data - hide the ntvfs details from the calling layer - I set NTVFS_INTERFACE_VERSION 0 till we are closer to release (because we need to solve some async problems with the module stacking) metze (This used to be commit 3ff03b5cb21bb79afdd3b1609be9635f6688a539)
2004-09-29 13:17:09 +00:00
static NTSTATUS nbench_setfileinfo(struct ntvfs_module_context *ntvfs,
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
struct ntvfs_request *req,
r2751: this is a new ntvfs design which tries to solve: - the stacking of modules - finding the modules private data - hide the ntvfs details from the calling layer - I set NTVFS_INTERFACE_VERSION 0 till we are closer to release (because we need to solve some async problems with the module stacking) metze (This used to be commit 3ff03b5cb21bb79afdd3b1609be9635f6688a539)
2004-09-29 13:17:09 +00:00
union smb_setfileinfo *info)
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
{
NTSTATUS status;
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
PASS_THRU_REQ(ntvfs, req, setfileinfo, info, (ntvfs, req, info));
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
return status;
}
/*
return filesystem space info
*/
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
static void nbench_fsinfo_send(struct ntvfs_request *req)
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
{
union smb_fsinfo *fs = req->async_states->private_data;
r3346: - simplified vfs_nbench.c a bit, by using req->async_state->ntvfs inside nbench_log() instead of declaring nprivates every time. - added correct async_setup pass-thru in nbench (This used to be commit 8d79bceeca4528ab31cff1adc7706faa075013ac)
2004-10-29 00:51:41 +00:00
nbench_log(req, "QUERY_FS_INFORMATION %d %s\n",
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
fs->generic.level,
get_nt_error_c_code(req->async_states->status));
PASS_THRU_REP_POST(req);
}
r2751: this is a new ntvfs design which tries to solve: - the stacking of modules - finding the modules private data - hide the ntvfs details from the calling layer - I set NTVFS_INTERFACE_VERSION 0 till we are closer to release (because we need to solve some async problems with the module stacking) metze (This used to be commit 3ff03b5cb21bb79afdd3b1609be9635f6688a539)
2004-09-29 13:17:09 +00:00
static NTSTATUS nbench_fsinfo(struct ntvfs_module_context *ntvfs,
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
struct ntvfs_request *req, union smb_fsinfo *fs)
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
{
NTSTATUS status;
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
PASS_THRU_REQ(ntvfs, req, fsinfo, fs, (ntvfs, req, fs));
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
return status;
}
/*
return print queue info
*/
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
static void nbench_lpq_send(struct ntvfs_request *req)
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
{
union smb_lpq *lpq = req->async_states->private_data;
r3346: - simplified vfs_nbench.c a bit, by using req->async_state->ntvfs inside nbench_log() instead of declaring nprivates every time. - added correct async_setup pass-thru in nbench (This used to be commit 8d79bceeca4528ab31cff1adc7706faa075013ac)
2004-10-29 00:51:41 +00:00
nbench_log(req, "Lpq-%d - NOT HANDLED\n", lpq->generic.level);
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
PASS_THRU_REP_POST(req);
}
r2751: this is a new ntvfs design which tries to solve: - the stacking of modules - finding the modules private data - hide the ntvfs details from the calling layer - I set NTVFS_INTERFACE_VERSION 0 till we are closer to release (because we need to solve some async problems with the module stacking) metze (This used to be commit 3ff03b5cb21bb79afdd3b1609be9635f6688a539)
2004-09-29 13:17:09 +00:00
static NTSTATUS nbench_lpq(struct ntvfs_module_context *ntvfs,
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
struct ntvfs_request *req, union smb_lpq *lpq)
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
{
NTSTATUS status;
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
PASS_THRU_REQ(ntvfs, req, lpq, lpq, (ntvfs, req, lpq));
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
return status;
}
/*
list files in a directory matching a wildcard pattern
*/
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
static void nbench_search_first_send(struct ntvfs_request *req)
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
{
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
union smb_search_first *io = req->async_states->private_data;
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
switch (io->generic.level) {
case RAW_SEARCH_BOTH_DIRECTORY_INFO:
r3349: fixed more uninitialised variable problems with the nbench module (This used to be commit 915faf49350b29a46f39354cbac746455d70c92c)
2004-10-29 01:22:47 +00:00
if (NT_STATUS_IS_ERR(req->async_states->status)) {
ZERO_STRUCT(io->t2ffirst.out);
}
r3346: - simplified vfs_nbench.c a bit, by using req->async_state->ntvfs inside nbench_log() instead of declaring nprivates every time. - added correct async_setup pass-thru in nbench (This used to be commit 8d79bceeca4528ab31cff1adc7706faa075013ac)
2004-10-29 00:51:41 +00:00
nbench_log(req, "FIND_FIRST \"%s\" %d %d %d %s\n",
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
io->t2ffirst.in.pattern,
io->generic.level,
io->t2ffirst.in.max_count,
io->t2ffirst.out.count,
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
get_nt_error_c_code(req->async_states->status));
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
break;
default:
r3346: - simplified vfs_nbench.c a bit, by using req->async_state->ntvfs inside nbench_log() instead of declaring nprivates every time. - added correct async_setup pass-thru in nbench (This used to be commit 8d79bceeca4528ab31cff1adc7706faa075013ac)
2004-10-29 00:51:41 +00:00
nbench_log(req, "Search-%d - NOT HANDLED\n", io->generic.level);
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
break;
}
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
PASS_THRU_REP_POST(req);
}
static NTSTATUS nbench_search_first(struct ntvfs_module_context *ntvfs,
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
struct ntvfs_request *req, union smb_search_first *io,
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
void *search_private,
BOOL (*callback)(void *, union smb_search_data *))
{
NTSTATUS status;
PASS_THRU_REQ(ntvfs, req, search_first, io, (ntvfs, req, io, search_private, callback));
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
return status;
}
/* continue a search */
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
static void nbench_search_next_send(struct ntvfs_request *req)
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
{
union smb_search_next *io = req->async_states->private_data;
r3346: - simplified vfs_nbench.c a bit, by using req->async_state->ntvfs inside nbench_log() instead of declaring nprivates every time. - added correct async_setup pass-thru in nbench (This used to be commit 8d79bceeca4528ab31cff1adc7706faa075013ac)
2004-10-29 00:51:41 +00:00
nbench_log(req, "Searchnext-%d - NOT HANDLED\n", io->generic.level);
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
PASS_THRU_REP_POST(req);
}
r2751: this is a new ntvfs design which tries to solve: - the stacking of modules - finding the modules private data - hide the ntvfs details from the calling layer - I set NTVFS_INTERFACE_VERSION 0 till we are closer to release (because we need to solve some async problems with the module stacking) metze (This used to be commit 3ff03b5cb21bb79afdd3b1609be9635f6688a539)
2004-09-29 13:17:09 +00:00
static NTSTATUS nbench_search_next(struct ntvfs_module_context *ntvfs,
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
struct ntvfs_request *req, union smb_search_next *io,
r2751: this is a new ntvfs design which tries to solve: - the stacking of modules - finding the modules private data - hide the ntvfs details from the calling layer - I set NTVFS_INTERFACE_VERSION 0 till we are closer to release (because we need to solve some async problems with the module stacking) metze (This used to be commit 3ff03b5cb21bb79afdd3b1609be9635f6688a539)
2004-09-29 13:17:09 +00:00
void *search_private,
BOOL (*callback)(void *, union smb_search_data *))
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
{
NTSTATUS status;
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
PASS_THRU_REQ(ntvfs, req, search_next, io, (ntvfs, req, io, search_private, callback));
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
return status;
}
/* close a search */
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
static void nbench_search_close_send(struct ntvfs_request *req)
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
{
union smb_search_close *io = req->async_states->private_data;
r3346: - simplified vfs_nbench.c a bit, by using req->async_state->ntvfs inside nbench_log() instead of declaring nprivates every time. - added correct async_setup pass-thru in nbench (This used to be commit 8d79bceeca4528ab31cff1adc7706faa075013ac)
2004-10-29 00:51:41 +00:00
nbench_log(req, "Searchclose-%d - NOT HANDLED\n", io->generic.level);
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
PASS_THRU_REP_POST(req);
}
r2751: this is a new ntvfs design which tries to solve: - the stacking of modules - finding the modules private data - hide the ntvfs details from the calling layer - I set NTVFS_INTERFACE_VERSION 0 till we are closer to release (because we need to solve some async problems with the module stacking) metze (This used to be commit 3ff03b5cb21bb79afdd3b1609be9635f6688a539)
2004-09-29 13:17:09 +00:00
static NTSTATUS nbench_search_close(struct ntvfs_module_context *ntvfs,
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
struct ntvfs_request *req, union smb_search_close *io)
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
{
NTSTATUS status;
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
PASS_THRU_REQ(ntvfs, req, search_close, io, (ntvfs, req, io));
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
return status;
}
/* SMBtrans - not used on file shares */
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
static void nbench_trans_send(struct ntvfs_request *req)
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
{
r3346: - simplified vfs_nbench.c a bit, by using req->async_state->ntvfs inside nbench_log() instead of declaring nprivates every time. - added correct async_setup pass-thru in nbench (This used to be commit 8d79bceeca4528ab31cff1adc7706faa075013ac)
2004-10-29 00:51:41 +00:00
nbench_log(req, "Trans - NOT HANDLED\n");
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
PASS_THRU_REP_POST(req);
}
r2751: this is a new ntvfs design which tries to solve: - the stacking of modules - finding the modules private data - hide the ntvfs details from the calling layer - I set NTVFS_INTERFACE_VERSION 0 till we are closer to release (because we need to solve some async problems with the module stacking) metze (This used to be commit 3ff03b5cb21bb79afdd3b1609be9635f6688a539)
2004-09-29 13:17:09 +00:00
static NTSTATUS nbench_trans(struct ntvfs_module_context *ntvfs,
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
struct ntvfs_request *req, struct smb_trans2 *trans2)
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
{
NTSTATUS status;
r3336: use a struct ntvfs_async_state to be able to do async chaning of ntvfs modules the idea is that a passthru module can use ntvfs_async_state_push() before calling ntvfs_next_*() and in the _send function it calls ntvfs_async_state_pop() and then call the upper layer send_fn itself - ntvfs_nbench is now fully async - the ntvfs_map_*() functions and the trans(2) mapping functions are not converted yet metze (This used to be commit fde64c0dc142b53d128c8ba09af048dc58d8ef3a)
2004-10-28 21:48:53 +00:00
PASS_THRU_REQ(ntvfs, req, trans, trans2, (ntvfs, req, trans2));
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
return status;
}
/*
initialise the nbench backend, registering ourselves with the ntvfs subsystem
*/
NTSTATUS ntvfs_nbench_init(void)
{
NTSTATUS ret;
struct ntvfs_ops ops;
ZERO_STRUCT(ops);
/* fill in the name and type */
ops.name = "nbench";
ops.type = NTVFS_DISK;
/* fill in all the operations */
ops.connect = nbench_connect;
ops.disconnect = nbench_disconnect;
ops.unlink = nbench_unlink;
ops.chkpath = nbench_chkpath;
ops.qpathinfo = nbench_qpathinfo;
ops.setpathinfo = nbench_setpathinfo;
r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191)
2006-03-10 14:31:17 +00:00
ops.open = nbench_open;
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
ops.mkdir = nbench_mkdir;
ops.rmdir = nbench_rmdir;
ops.rename = nbench_rename;
ops.copy = nbench_copy;
ops.ioctl = nbench_ioctl;
ops.read = nbench_read;
ops.write = nbench_write;
ops.seek = nbench_seek;
ops.flush = nbench_flush;
ops.close = nbench_close;
ops.exit = nbench_exit;
ops.lock = nbench_lock;
ops.setfileinfo = nbench_setfileinfo;
ops.qfileinfo = nbench_qfileinfo;
ops.fsinfo = nbench_fsinfo;
ops.lpq = nbench_lpq;
ops.search_first = nbench_search_first;
ops.search_next = nbench_search_next;
ops.search_close = nbench_search_close;
ops.trans = nbench_trans;
r2660: - converted the libcli/raw/ library to use talloc_increase_ref_count() rather than manual reference counts - properly support SMBexit in the cifs and posix backends - added a logoff method to all backends With these changes the RAW-CONTEXT test now passes against the posix backend (This used to be commit c315d6ac1cc40546fde1474702a6d66d07ee13c8)
2004-09-26 11:30:20 +00:00
ops.logoff = nbench_logoff;
r3039: This solves the problem of async handlers in ntvfs backends not being in the right state when called. For example, when we use the unixuid handler in the chain of handlers, and a backend decides to continue a call asynchronously then we need to ensure that the continuation happens with the right security context. The solution is to add a new ntvfs operation ntvfs_async_setup(), which calls all the way down through the layers, setting up anything that is required, and takes a private pointer. The backend wanting to make a async calls can use ntvfs_async_setup() to ensure that the modules above it are called when doing async processing. (This used to be commit a256e71029727fa1659ade6257085df537308c7d)
2004-10-18 13:27:22 +00:00
ops.async_setup = nbench_async_setup;
r3528: added support for the SMBntcancel() operation, which cancels any outstanding async operation (triggering an immediate timeout). pvfs now passes the RAW-MUX test (This used to be commit 3423e2f41461d054067ef168b9b986f62cc8f77c)
2004-11-04 11:28:38 +00:00
ops.cancel = nbench_cancel;
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
/* we don't register a trans2 handler as we want to be able to
log individual trans2 requests */
ops.trans2 = NULL;
/* register ourselves with the NTVFS subsystem. */
r3737: - Get rid of the register_subsystem() and register_backend() functions. - Re-disable tdbtool (it was building fine on my Debian box but other machines were having problems) (This used to be commit 0d7bb2c40b7a9ed59df3f8944133ea562697e814)
2004-11-14 22:23:23 +00:00
ret = ntvfs_register(&ops);
added the "nbench" ntvfs backend. This is used to capture NBENCH load files, and also serves as an example of how to write a NTVFS filter module for Samba4. (This used to be commit 04f8996dd32d92c5df1b6b1b27c6e71e99bc77da)
2004-03-08 07:17:15 +00:00
if (!NT_STATUS_IS_OK(ret)) {
DEBUG(0,("Failed to register nbench backend!\n"));
}
return ret;
}
Copy Permalink