mirror of
https://github.com/samba-team/samba.git
synced 2025-01-12 09:18:10 +03:00
s3/vfs: rename SMB_VFS_COPY_CHUNK_SEND/RECV to SMB_VFS_OFFLOAD_WRITE_SEND/RECV
No change in behaviour, just a rename in preperation of more changes to SMB_VFS_OFFLOAD_WRITE_SEND. It helps keeping the diff of the actual changes smaller. Signed-off-by: Ralph Boehme <slow@samba.org> Reviewed-by: Stefan Metzmacher <metze@samba.org>
This commit is contained in:
parent
67ed1edba7
commit
64bedefa11
@ -582,7 +582,7 @@ static NTSTATUS skel_offload_read_recv(struct tevent_req *req,
|
||||
struct skel_cc_state {
|
||||
uint64_t unused;
|
||||
};
|
||||
static struct tevent_req *skel_copy_chunk_send(struct vfs_handle_struct *handle,
|
||||
static struct tevent_req *skel_offload_write_send(struct vfs_handle_struct *handle,
|
||||
TALLOC_CTX *mem_ctx,
|
||||
struct tevent_context *ev,
|
||||
struct files_struct *src_fsp,
|
||||
@ -604,7 +604,7 @@ static struct tevent_req *skel_copy_chunk_send(struct vfs_handle_struct *handle,
|
||||
return tevent_req_post(req, ev);
|
||||
}
|
||||
|
||||
static NTSTATUS skel_copy_chunk_recv(struct vfs_handle_struct *handle,
|
||||
static NTSTATUS skel_offload_write_recv(struct vfs_handle_struct *handle,
|
||||
struct tevent_req *req,
|
||||
off_t *copied)
|
||||
{
|
||||
@ -1011,8 +1011,8 @@ struct vfs_fn_pointers skel_opaque_fns = {
|
||||
.file_id_create_fn = skel_file_id_create,
|
||||
.offload_read_send_fn = skel_offload_read_send,
|
||||
.offload_read_recv_fn = skel_offload_read_recv,
|
||||
.copy_chunk_send_fn = skel_copy_chunk_send,
|
||||
.copy_chunk_recv_fn = skel_copy_chunk_recv,
|
||||
.offload_write_send_fn = skel_offload_write_send,
|
||||
.offload_write_recv_fn = skel_offload_write_recv,
|
||||
.get_compression_fn = skel_get_compression,
|
||||
.set_compression_fn = skel_set_compression,
|
||||
|
||||
|
@ -710,13 +710,13 @@ static NTSTATUS skel_offload_read_recv(struct tevent_req *req,
|
||||
return NT_STATUS_OK;
|
||||
}
|
||||
|
||||
struct skel_cc_state {
|
||||
struct skel_offload_write_state {
|
||||
struct vfs_handle_struct *handle;
|
||||
off_t copied;
|
||||
};
|
||||
static void skel_copy_chunk_done(struct tevent_req *subreq);
|
||||
static void skel_offload_write_done(struct tevent_req *subreq);
|
||||
|
||||
static struct tevent_req *skel_copy_chunk_send(struct vfs_handle_struct *handle,
|
||||
static struct tevent_req *skel_offload_write_send(struct vfs_handle_struct *handle,
|
||||
TALLOC_CTX *mem_ctx,
|
||||
struct tevent_context *ev,
|
||||
struct files_struct *src_fsp,
|
||||
@ -728,36 +728,36 @@ static struct tevent_req *skel_copy_chunk_send(struct vfs_handle_struct *handle,
|
||||
{
|
||||
struct tevent_req *req;
|
||||
struct tevent_req *subreq;
|
||||
struct skel_cc_state *cc_state;
|
||||
struct skel_offload_write_state *state;
|
||||
|
||||
req = tevent_req_create(mem_ctx, &cc_state, struct skel_cc_state);
|
||||
req = tevent_req_create(mem_ctx, &state, struct skel_offload_write_state);
|
||||
if (req == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
cc_state->handle = handle;
|
||||
subreq = SMB_VFS_NEXT_COPY_CHUNK_SEND(handle, cc_state, ev,
|
||||
state->handle = handle;
|
||||
subreq = SMB_VFS_NEXT_OFFLOAD_WRITE_SEND(handle, state, ev,
|
||||
src_fsp, src_off,
|
||||
dest_fsp, dest_off, num, flags);
|
||||
if (tevent_req_nomem(subreq, req)) {
|
||||
return tevent_req_post(req, ev);
|
||||
}
|
||||
|
||||
tevent_req_set_callback(subreq, skel_copy_chunk_done, req);
|
||||
tevent_req_set_callback(subreq, skel_offload_write_done, req);
|
||||
return req;
|
||||
}
|
||||
|
||||
static void skel_copy_chunk_done(struct tevent_req *subreq)
|
||||
static void skel_offload_write_done(struct tevent_req *subreq)
|
||||
{
|
||||
struct tevent_req *req = tevent_req_callback_data(
|
||||
subreq, struct tevent_req);
|
||||
struct skel_cc_state *cc_state
|
||||
= tevent_req_data(req, struct skel_cc_state);
|
||||
struct skel_offload_write_state *state
|
||||
= tevent_req_data(req, struct skel_offload_write_state);
|
||||
NTSTATUS status;
|
||||
|
||||
status = SMB_VFS_NEXT_COPY_CHUNK_RECV(cc_state->handle,
|
||||
status = SMB_VFS_NEXT_OFFLOAD_WRITE_RECV(state->handle,
|
||||
subreq,
|
||||
&cc_state->copied);
|
||||
&state->copied);
|
||||
TALLOC_FREE(subreq);
|
||||
if (tevent_req_nterror(req, status)) {
|
||||
return;
|
||||
@ -765,15 +765,15 @@ static void skel_copy_chunk_done(struct tevent_req *subreq)
|
||||
tevent_req_done(req);
|
||||
}
|
||||
|
||||
static NTSTATUS skel_copy_chunk_recv(struct vfs_handle_struct *handle,
|
||||
static NTSTATUS skel_offload_write_recv(struct vfs_handle_struct *handle,
|
||||
struct tevent_req *req,
|
||||
off_t *copied)
|
||||
{
|
||||
struct skel_cc_state *cc_state
|
||||
= tevent_req_data(req, struct skel_cc_state);
|
||||
struct skel_offload_write_state *state
|
||||
= tevent_req_data(req, struct skel_offload_write_state);
|
||||
NTSTATUS status;
|
||||
|
||||
*copied = cc_state->copied;
|
||||
*copied = state->copied;
|
||||
if (tevent_req_is_nterror(req, &status)) {
|
||||
tevent_req_received(req);
|
||||
return status;
|
||||
@ -1184,8 +1184,8 @@ struct vfs_fn_pointers skel_transparent_fns = {
|
||||
.file_id_create_fn = skel_file_id_create,
|
||||
.offload_read_send_fn = skel_offload_read_send,
|
||||
.offload_read_recv_fn = skel_offload_read_recv,
|
||||
.copy_chunk_send_fn = skel_copy_chunk_send,
|
||||
.copy_chunk_recv_fn = skel_copy_chunk_recv,
|
||||
.offload_write_send_fn = skel_offload_write_send,
|
||||
.offload_write_recv_fn = skel_offload_write_recv,
|
||||
.get_compression_fn = skel_get_compression,
|
||||
.set_compression_fn = skel_set_compression,
|
||||
|
||||
|
@ -239,6 +239,8 @@
|
||||
/* Version 37 - Change connectpath from char *
|
||||
to struct smb_filename * */
|
||||
/* Version 37 - Add SMB_VFS_OFFLOAD_READ_SEND/RECV */
|
||||
/* Version 37 - Rename SMB_VFS_COPY_CHUNK_SEND/RECV to
|
||||
SMB_VFS_OFFLOAD_READ_SEND/RECV */
|
||||
|
||||
#define SMB_VFS_INTERFACE_VERSION 37
|
||||
|
||||
@ -592,17 +594,17 @@ enum vfs_fallocate_flags {
|
||||
};
|
||||
|
||||
/*
|
||||
* @VFS_COPY_CHUNK_FL_MUST_CLONE: indicates that copy_chunk_send_fn() copy must
|
||||
* @VFS_OFFLOAD_WRITE_FL_MUST_CLONE: indicates that offload_write_send_fn() copy must
|
||||
* be handled as a COW clone, AKA reflink.
|
||||
* @VFS_COPY_CHUNK_FL_MASK_ALL: all valid copychunk flags.
|
||||
* @VFS_OFFLOAD_WRITE_FL_MASK_ALL: all valid flags.
|
||||
*/
|
||||
enum vfs_copy_chunk_flags {
|
||||
VFS_COPY_CHUNK_FL_MUST_CLONE = 0x0001,
|
||||
VFS_COPY_CHUNK_FL_IGNORE_LOCKS = 0x0002,
|
||||
enum vfs_offload_write_flags {
|
||||
VFS_OFFLOAD_WRITE_FL_MUST_CLONE = 0x0001,
|
||||
VFS_OFFLOAD_WRITE_FL_IGNORE_LOCKS = 0x0002,
|
||||
|
||||
VFS_COPY_CHUNK_FL_MASK_ALL =
|
||||
(VFS_COPY_CHUNK_FL_MUST_CLONE
|
||||
| VFS_COPY_CHUNK_FL_IGNORE_LOCKS),
|
||||
VFS_OFFLOAD_WRITE_FL_MASK_ALL =
|
||||
(VFS_OFFLOAD_WRITE_FL_MUST_CLONE
|
||||
| VFS_OFFLOAD_WRITE_FL_IGNORE_LOCKS),
|
||||
};
|
||||
|
||||
struct vfs_aio_state {
|
||||
@ -794,18 +796,18 @@ struct vfs_fn_pointers {
|
||||
struct vfs_handle_struct *handle,
|
||||
TALLOC_CTX *mem_ctx,
|
||||
DATA_BLOB *token_blob);
|
||||
struct tevent_req *(*copy_chunk_send_fn)(struct vfs_handle_struct *handle,
|
||||
TALLOC_CTX *mem_ctx,
|
||||
struct tevent_context *ev,
|
||||
struct files_struct *src_fsp,
|
||||
off_t src_off,
|
||||
struct files_struct *dest_fsp,
|
||||
off_t dest_off,
|
||||
off_t to_copy,
|
||||
uint32_t flags);
|
||||
NTSTATUS (*copy_chunk_recv_fn)(struct vfs_handle_struct *handle,
|
||||
struct tevent_req *req,
|
||||
off_t *copied);
|
||||
struct tevent_req *(*offload_write_send_fn)(struct vfs_handle_struct *handle,
|
||||
TALLOC_CTX *mem_ctx,
|
||||
struct tevent_context *ev,
|
||||
struct files_struct *src_fsp,
|
||||
off_t src_off,
|
||||
struct files_struct *dest_fsp,
|
||||
off_t dest_off,
|
||||
off_t to_copy,
|
||||
uint32_t flags);
|
||||
NTSTATUS (*offload_write_recv_fn)(struct vfs_handle_struct *handle,
|
||||
struct tevent_req *req,
|
||||
off_t *copied);
|
||||
NTSTATUS (*get_compression_fn)(struct vfs_handle_struct *handle,
|
||||
TALLOC_CTX *mem_ctx,
|
||||
struct files_struct *fsp,
|
||||
@ -1374,18 +1376,18 @@ NTSTATUS smb_vfs_call_offload_read_recv(struct tevent_req *req,
|
||||
struct vfs_handle_struct *handle,
|
||||
TALLOC_CTX *mem_ctx,
|
||||
DATA_BLOB *token_blob);
|
||||
struct tevent_req *smb_vfs_call_copy_chunk_send(struct vfs_handle_struct *handle,
|
||||
TALLOC_CTX *mem_ctx,
|
||||
struct tevent_context *ev,
|
||||
struct files_struct *src_fsp,
|
||||
off_t src_off,
|
||||
struct files_struct *dest_fsp,
|
||||
off_t dest_off,
|
||||
off_t num,
|
||||
uint32_t flags);
|
||||
NTSTATUS smb_vfs_call_copy_chunk_recv(struct vfs_handle_struct *handle,
|
||||
struct tevent_req *req,
|
||||
off_t *copied);
|
||||
struct tevent_req *smb_vfs_call_offload_write_send(struct vfs_handle_struct *handle,
|
||||
TALLOC_CTX *mem_ctx,
|
||||
struct tevent_context *ev,
|
||||
struct files_struct *src_fsp,
|
||||
off_t src_off,
|
||||
struct files_struct *dest_fsp,
|
||||
off_t dest_off,
|
||||
off_t num,
|
||||
uint32_t flags);
|
||||
NTSTATUS smb_vfs_call_offload_write_recv(struct vfs_handle_struct *handle,
|
||||
struct tevent_req *req,
|
||||
off_t *copied);
|
||||
NTSTATUS smb_vfs_call_get_compression(struct vfs_handle_struct *handle,
|
||||
TALLOC_CTX *mem_ctx,
|
||||
struct files_struct *fsp,
|
||||
|
@ -425,15 +425,15 @@
|
||||
#define SMB_VFS_NEXT_OFFLOAD_READ_RECV(req, handle, mem_ctx, token_blob) \
|
||||
smb_vfs_call_offload_read_recv((req), (handle)->next, (mem_ctx), (token_blob))
|
||||
|
||||
#define SMB_VFS_COPY_CHUNK_SEND(conn, mem_ctx, ev, src_fsp, src_off, dest_fsp, dest_off, num, flags) \
|
||||
smb_vfs_call_copy_chunk_send((conn)->vfs_handles, (mem_ctx), (ev), (src_fsp), (src_off), (dest_fsp), (dest_off), (num), (flags))
|
||||
#define SMB_VFS_NEXT_COPY_CHUNK_SEND(handle, mem_ctx, ev, src_fsp, src_off, dest_fsp, dest_off, num, flags) \
|
||||
smb_vfs_call_copy_chunk_send((handle)->next, (mem_ctx), (ev), (src_fsp), (src_off), (dest_fsp), (dest_off), (num), (flags))
|
||||
#define SMB_VFS_OFFLOAD_WRITE_SEND(conn, mem_ctx, ev, src_fsp, src_off, dest_fsp, dest_off, num, flags) \
|
||||
smb_vfs_call_offload_write_send((conn)->vfs_handles, (mem_ctx), (ev), (src_fsp), (src_off), (dest_fsp), (dest_off), (num), (flags))
|
||||
#define SMB_VFS_NEXT_OFFLOAD_WRITE_SEND(handle, mem_ctx, ev, src_fsp, src_off, dest_fsp, dest_off, num, flags) \
|
||||
smb_vfs_call_offload_write_send((handle)->next, (mem_ctx), (ev), (src_fsp), (src_off), (dest_fsp), (dest_off), (num), (flags))
|
||||
|
||||
#define SMB_VFS_COPY_CHUNK_RECV(conn, req, copied) \
|
||||
smb_vfs_call_copy_chunk_recv((conn)->vfs_handles, (req), (copied))
|
||||
#define SMB_VFS_NEXT_COPY_CHUNK_RECV(handle, req, copied) \
|
||||
smb_vfs_call_copy_chunk_recv((handle)->next, (req), (copied))
|
||||
#define SMB_VFS_OFFLOAD_WRITE_RECV(conn, req, copied) \
|
||||
smb_vfs_call_offload_write_recv((conn)->vfs_handles, (req), (copied))
|
||||
#define SMB_VFS_NEXT_OFFLOAD_WRITE_RECV(handle, req, copied) \
|
||||
smb_vfs_call_offload_write_recv((handle)->next, (req), (copied))
|
||||
|
||||
#define SMB_VFS_GET_COMPRESSION(conn, mem_ctx, fsp, smb_fname, _compression_fmt) \
|
||||
smb_vfs_call_get_compression((conn)->vfs_handles, (mem_ctx), (fsp), (smb_fname), (_compression_fmt))
|
||||
|
@ -201,9 +201,9 @@ struct btrfs_cc_state {
|
||||
off_t copied;
|
||||
struct tevent_req *subreq; /* non-null if passed to next VFS fn */
|
||||
};
|
||||
static void btrfs_copy_chunk_done(struct tevent_req *subreq);
|
||||
static void btrfs_offload_write_done(struct tevent_req *subreq);
|
||||
|
||||
static struct tevent_req *btrfs_copy_chunk_send(struct vfs_handle_struct *handle,
|
||||
static struct tevent_req *btrfs_offload_write_send(struct vfs_handle_struct *handle,
|
||||
TALLOC_CTX *mem_ctx,
|
||||
struct tevent_context *ev,
|
||||
struct files_struct *src_fsp,
|
||||
@ -226,7 +226,7 @@ static struct tevent_req *btrfs_copy_chunk_send(struct vfs_handle_struct *handle
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (flags & ~VFS_COPY_CHUNK_FL_MASK_ALL) {
|
||||
if (flags & ~VFS_OFFLOAD_WRITE_FL_MASK_ALL) {
|
||||
tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
|
||||
return tevent_req_post(req, ev);
|
||||
}
|
||||
@ -239,7 +239,7 @@ static struct tevent_req *btrfs_copy_chunk_send(struct vfs_handle_struct *handle
|
||||
* all data from @src_offset->EOF! This is certainly not what
|
||||
* the caller expects, and not what vfs_default does.
|
||||
*/
|
||||
cc_state->subreq = SMB_VFS_NEXT_COPY_CHUNK_SEND(handle,
|
||||
cc_state->subreq = SMB_VFS_NEXT_OFFLOAD_WRITE_SEND(handle,
|
||||
cc_state, ev,
|
||||
src_fsp,
|
||||
src_off,
|
||||
@ -250,7 +250,7 @@ static struct tevent_req *btrfs_copy_chunk_send(struct vfs_handle_struct *handle
|
||||
return tevent_req_post(req, ev);
|
||||
}
|
||||
tevent_req_set_callback(cc_state->subreq,
|
||||
btrfs_copy_chunk_done,
|
||||
btrfs_offload_write_done,
|
||||
req);
|
||||
return req;
|
||||
}
|
||||
@ -271,7 +271,7 @@ static struct tevent_req *btrfs_copy_chunk_send(struct vfs_handle_struct *handle
|
||||
return tevent_req_post(req, ev);
|
||||
}
|
||||
|
||||
if (!(flags & VFS_COPY_CHUNK_FL_IGNORE_LOCKS)) {
|
||||
if (!(flags & VFS_OFFLOAD_WRITE_FL_IGNORE_LOCKS)) {
|
||||
init_strict_lock_struct(src_fsp,
|
||||
src_fsp->op->global->open_persistent_id,
|
||||
src_off,
|
||||
@ -303,7 +303,7 @@ static struct tevent_req *btrfs_copy_chunk_send(struct vfs_handle_struct *handle
|
||||
cr_args.src_length = (uint64_t)num;
|
||||
|
||||
ret = ioctl(dest_fsp->fh->fd, BTRFS_IOC_CLONE_RANGE, &cr_args);
|
||||
if (!(flags & VFS_COPY_CHUNK_FL_IGNORE_LOCKS)) {
|
||||
if (!(flags & VFS_OFFLOAD_WRITE_FL_IGNORE_LOCKS)) {
|
||||
SMB_VFS_STRICT_UNLOCK(dest_fsp->conn, dest_fsp, &dest_lck);
|
||||
SMB_VFS_STRICT_UNLOCK(src_fsp->conn, src_fsp, &src_lck);
|
||||
}
|
||||
@ -321,7 +321,7 @@ static struct tevent_req *btrfs_copy_chunk_send(struct vfs_handle_struct *handle
|
||||
(unsigned long long)cr_args.src_offset,
|
||||
dest_fsp->fh->fd,
|
||||
(unsigned long long)cr_args.dest_offset));
|
||||
cc_state->subreq = SMB_VFS_NEXT_COPY_CHUNK_SEND(handle,
|
||||
cc_state->subreq = SMB_VFS_NEXT_OFFLOAD_WRITE_SEND(handle,
|
||||
cc_state, ev,
|
||||
src_fsp,
|
||||
src_off,
|
||||
@ -333,7 +333,7 @@ static struct tevent_req *btrfs_copy_chunk_send(struct vfs_handle_struct *handle
|
||||
}
|
||||
/* wait for subreq completion */
|
||||
tevent_req_set_callback(cc_state->subreq,
|
||||
btrfs_copy_chunk_done,
|
||||
btrfs_offload_write_done,
|
||||
req);
|
||||
return req;
|
||||
}
|
||||
@ -346,7 +346,7 @@ static struct tevent_req *btrfs_copy_chunk_send(struct vfs_handle_struct *handle
|
||||
}
|
||||
|
||||
/* only used if the request is passed through to next VFS module */
|
||||
static void btrfs_copy_chunk_done(struct tevent_req *subreq)
|
||||
static void btrfs_offload_write_done(struct tevent_req *subreq)
|
||||
{
|
||||
struct tevent_req *req = tevent_req_callback_data(
|
||||
subreq, struct tevent_req);
|
||||
@ -354,7 +354,7 @@ static void btrfs_copy_chunk_done(struct tevent_req *subreq)
|
||||
struct btrfs_cc_state);
|
||||
NTSTATUS status;
|
||||
|
||||
status = SMB_VFS_NEXT_COPY_CHUNK_RECV(cc_state->handle,
|
||||
status = SMB_VFS_NEXT_OFFLOAD_WRITE_RECV(cc_state->handle,
|
||||
cc_state->subreq,
|
||||
&cc_state->copied);
|
||||
if (tevent_req_nterror(req, status)) {
|
||||
@ -363,7 +363,7 @@ static void btrfs_copy_chunk_done(struct tevent_req *subreq)
|
||||
tevent_req_done(req);
|
||||
}
|
||||
|
||||
static NTSTATUS btrfs_copy_chunk_recv(struct vfs_handle_struct *handle,
|
||||
static NTSTATUS btrfs_offload_write_recv(struct vfs_handle_struct *handle,
|
||||
struct tevent_req *req,
|
||||
off_t *copied)
|
||||
{
|
||||
@ -800,8 +800,8 @@ static struct vfs_fn_pointers btrfs_fns = {
|
||||
.fs_capabilities_fn = btrfs_fs_capabilities,
|
||||
.offload_read_send_fn = btrfs_offload_read_send,
|
||||
.offload_read_recv_fn = btrfs_offload_read_recv,
|
||||
.copy_chunk_send_fn = btrfs_copy_chunk_send,
|
||||
.copy_chunk_recv_fn = btrfs_copy_chunk_recv,
|
||||
.offload_write_send_fn = btrfs_offload_write_send,
|
||||
.offload_write_recv_fn = btrfs_offload_write_recv,
|
||||
.get_compression_fn = btrfs_get_compression,
|
||||
.set_compression_fn = btrfs_set_compression,
|
||||
.snap_check_path_fn = btrfs_snap_check_path,
|
||||
|
@ -1682,7 +1682,7 @@ static NTSTATUS vfswrap_offload_read_recv(struct tevent_req *req,
|
||||
return NT_STATUS_OK;
|
||||
}
|
||||
|
||||
struct vfs_cc_state {
|
||||
struct vfswrap_offload_write_state {
|
||||
struct tevent_context *ev;
|
||||
uint8_t *buf;
|
||||
bool read_lck_locked;
|
||||
@ -1699,42 +1699,44 @@ struct vfs_cc_state {
|
||||
uint32_t flags;
|
||||
};
|
||||
|
||||
static NTSTATUS copy_chunk_loop(struct tevent_req *req);
|
||||
static NTSTATUS vfswrap_offload_write_loop(struct tevent_req *req);
|
||||
|
||||
static struct tevent_req *vfswrap_copy_chunk_send(struct vfs_handle_struct *handle,
|
||||
TALLOC_CTX *mem_ctx,
|
||||
struct tevent_context *ev,
|
||||
struct files_struct *src_fsp,
|
||||
off_t src_off,
|
||||
struct files_struct *dest_fsp,
|
||||
off_t dest_off,
|
||||
off_t to_copy,
|
||||
uint32_t flags)
|
||||
static struct tevent_req *vfswrap_offload_write_send(
|
||||
struct vfs_handle_struct *handle,
|
||||
TALLOC_CTX *mem_ctx,
|
||||
struct tevent_context *ev,
|
||||
struct files_struct *src_fsp,
|
||||
off_t src_off,
|
||||
struct files_struct *dest_fsp,
|
||||
off_t dest_off,
|
||||
off_t to_copy,
|
||||
uint32_t flags)
|
||||
{
|
||||
struct tevent_req *req;
|
||||
struct vfs_cc_state *state = NULL;
|
||||
struct vfswrap_offload_write_state *state = NULL;
|
||||
size_t num = MIN(to_copy, COPYCHUNK_MAX_TOTAL_LEN);
|
||||
NTSTATUS status;
|
||||
|
||||
DBG_DEBUG("server side copy chunk of length %" PRIu64 "\n", to_copy);
|
||||
|
||||
req = tevent_req_create(mem_ctx, &state, struct vfs_cc_state);
|
||||
req = tevent_req_create(mem_ctx, &state,
|
||||
struct vfswrap_offload_write_state);
|
||||
if (req == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (flags & ~VFS_COPY_CHUNK_FL_MASK_ALL) {
|
||||
if (flags & ~VFS_OFFLOAD_WRITE_FL_MASK_ALL) {
|
||||
tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
|
||||
return tevent_req_post(req, ev);
|
||||
}
|
||||
|
||||
if (flags & VFS_COPY_CHUNK_FL_MUST_CLONE) {
|
||||
if (flags & VFS_OFFLOAD_WRITE_FL_MUST_CLONE) {
|
||||
DEBUG(10, ("COW clones not supported by vfs_default\n"));
|
||||
tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
|
||||
return tevent_req_post(req, ev);
|
||||
}
|
||||
|
||||
*state = (struct vfs_cc_state) {
|
||||
*state = (struct vfswrap_offload_write_state) {
|
||||
.ev = ev,
|
||||
.src_fsp = src_fsp,
|
||||
.src_off = src_off,
|
||||
@ -1778,7 +1780,7 @@ static struct tevent_req *vfswrap_copy_chunk_send(struct vfs_handle_struct *hand
|
||||
return tevent_req_post(req, ev);
|
||||
}
|
||||
|
||||
status = copy_chunk_loop(req);
|
||||
status = vfswrap_offload_write_loop(req);
|
||||
if (!NT_STATUS_IS_OK(status)) {
|
||||
tevent_req_nterror(req, status);
|
||||
return tevent_req_post(req, ev);
|
||||
@ -1787,17 +1789,18 @@ static struct tevent_req *vfswrap_copy_chunk_send(struct vfs_handle_struct *hand
|
||||
return req;
|
||||
}
|
||||
|
||||
static void vfswrap_copy_chunk_read_done(struct tevent_req *subreq);
|
||||
static void vfswrap_offload_write_read_done(struct tevent_req *subreq);
|
||||
|
||||
static NTSTATUS copy_chunk_loop(struct tevent_req *req)
|
||||
static NTSTATUS vfswrap_offload_write_loop(struct tevent_req *req)
|
||||
{
|
||||
struct vfs_cc_state *state = tevent_req_data(req, struct vfs_cc_state);
|
||||
struct vfswrap_offload_write_state *state = tevent_req_data(
|
||||
req, struct vfswrap_offload_write_state);
|
||||
struct tevent_req *subreq = NULL;
|
||||
bool ok;
|
||||
|
||||
state->next_io_size = MIN(state->remaining, talloc_array_length(state->buf));
|
||||
|
||||
if (!(state->flags & VFS_COPY_CHUNK_FL_IGNORE_LOCKS)) {
|
||||
if (!(state->flags & VFS_OFFLOAD_WRITE_FL_IGNORE_LOCKS)) {
|
||||
init_strict_lock_struct(state->src_fsp,
|
||||
state->src_fsp->op->global->open_persistent_id,
|
||||
state->src_off,
|
||||
@ -1822,23 +1825,24 @@ static NTSTATUS copy_chunk_loop(struct tevent_req *req)
|
||||
if (subreq == NULL) {
|
||||
return NT_STATUS_NO_MEMORY;
|
||||
}
|
||||
tevent_req_set_callback(subreq, vfswrap_copy_chunk_read_done, req);
|
||||
tevent_req_set_callback(subreq, vfswrap_offload_write_read_done, req);
|
||||
|
||||
return NT_STATUS_OK;
|
||||
}
|
||||
|
||||
static void vfswrap_copy_chunk_write_done(struct tevent_req *subreq);
|
||||
static void vfswrap_offload_write_write_done(struct tevent_req *subreq);
|
||||
|
||||
static void vfswrap_copy_chunk_read_done(struct tevent_req *subreq)
|
||||
static void vfswrap_offload_write_read_done(struct tevent_req *subreq)
|
||||
{
|
||||
struct tevent_req *req = tevent_req_callback_data(
|
||||
subreq, struct tevent_req);
|
||||
struct vfs_cc_state *state = tevent_req_data(req, struct vfs_cc_state);
|
||||
struct vfswrap_offload_write_state *state = tevent_req_data(
|
||||
req, struct vfswrap_offload_write_state);
|
||||
struct vfs_aio_state aio_state;
|
||||
ssize_t nread;
|
||||
bool ok;
|
||||
|
||||
if (!(state->flags & VFS_COPY_CHUNK_FL_IGNORE_LOCKS)) {
|
||||
if (!(state->flags & VFS_OFFLOAD_WRITE_FL_IGNORE_LOCKS)) {
|
||||
SMB_VFS_STRICT_UNLOCK(state->src_fsp->conn,
|
||||
state->src_fsp,
|
||||
&state->read_lck);
|
||||
@ -1861,7 +1865,7 @@ static void vfswrap_copy_chunk_read_done(struct tevent_req *subreq)
|
||||
|
||||
state->src_off += nread;
|
||||
|
||||
if (!(state->flags & VFS_COPY_CHUNK_FL_IGNORE_LOCKS)) {
|
||||
if (!(state->flags & VFS_OFFLOAD_WRITE_FL_IGNORE_LOCKS)) {
|
||||
init_strict_lock_struct(state->dst_fsp,
|
||||
state->dst_fsp->op->global->open_persistent_id,
|
||||
state->dst_off,
|
||||
@ -1888,19 +1892,20 @@ static void vfswrap_copy_chunk_read_done(struct tevent_req *subreq)
|
||||
tevent_req_nterror(req, NT_STATUS_NO_MEMORY);
|
||||
return;
|
||||
}
|
||||
tevent_req_set_callback(subreq, vfswrap_copy_chunk_write_done, req);
|
||||
tevent_req_set_callback(subreq, vfswrap_offload_write_write_done, req);
|
||||
}
|
||||
|
||||
static void vfswrap_copy_chunk_write_done(struct tevent_req *subreq)
|
||||
static void vfswrap_offload_write_write_done(struct tevent_req *subreq)
|
||||
{
|
||||
struct tevent_req *req = tevent_req_callback_data(
|
||||
subreq, struct tevent_req);
|
||||
struct vfs_cc_state *state = tevent_req_data(req, struct vfs_cc_state);
|
||||
struct vfswrap_offload_write_state *state = tevent_req_data(
|
||||
req, struct vfswrap_offload_write_state);
|
||||
struct vfs_aio_state aio_state;
|
||||
ssize_t nwritten;
|
||||
NTSTATUS status;
|
||||
|
||||
if (!(state->flags & VFS_COPY_CHUNK_FL_IGNORE_LOCKS)) {
|
||||
if (!(state->flags & VFS_OFFLOAD_WRITE_FL_IGNORE_LOCKS)) {
|
||||
SMB_VFS_STRICT_UNLOCK(state->dst_fsp->conn,
|
||||
state->dst_fsp,
|
||||
&state->write_lck);
|
||||
@ -1933,7 +1938,7 @@ static void vfswrap_copy_chunk_write_done(struct tevent_req *subreq)
|
||||
return;
|
||||
}
|
||||
|
||||
status = copy_chunk_loop(req);
|
||||
status = vfswrap_offload_write_loop(req);
|
||||
if (!NT_STATUS_IS_OK(status)) {
|
||||
tevent_req_nterror(req, status);
|
||||
return;
|
||||
@ -1942,11 +1947,12 @@ static void vfswrap_copy_chunk_write_done(struct tevent_req *subreq)
|
||||
return;
|
||||
}
|
||||
|
||||
static NTSTATUS vfswrap_copy_chunk_recv(struct vfs_handle_struct *handle,
|
||||
static NTSTATUS vfswrap_offload_write_recv(struct vfs_handle_struct *handle,
|
||||
struct tevent_req *req,
|
||||
off_t *copied)
|
||||
{
|
||||
struct vfs_cc_state *state = tevent_req_data(req, struct vfs_cc_state);
|
||||
struct vfswrap_offload_write_state *state = tevent_req_data(
|
||||
req, struct vfswrap_offload_write_state);
|
||||
NTSTATUS status;
|
||||
|
||||
if (tevent_req_is_nterror(req, &status)) {
|
||||
@ -3079,8 +3085,8 @@ static struct vfs_fn_pointers vfs_default_fns = {
|
||||
.fget_dos_attributes_fn = vfswrap_fget_dos_attributes,
|
||||
.offload_read_send_fn = vfswrap_offload_read_send,
|
||||
.offload_read_recv_fn = vfswrap_offload_read_recv,
|
||||
.copy_chunk_send_fn = vfswrap_copy_chunk_send,
|
||||
.copy_chunk_recv_fn = vfswrap_copy_chunk_recv,
|
||||
.offload_write_send_fn = vfswrap_offload_write_send,
|
||||
.offload_write_recv_fn = vfswrap_offload_write_recv,
|
||||
.get_compression_fn = vfswrap_get_compression,
|
||||
.set_compression_fn = vfswrap_set_compression,
|
||||
|
||||
|
@ -5473,7 +5473,7 @@ static NTSTATUS fruit_offload_read_recv(struct tevent_req *req,
|
||||
return NT_STATUS_OK;
|
||||
}
|
||||
|
||||
struct fruit_copy_chunk_state {
|
||||
struct fruit_offload_write_state {
|
||||
struct vfs_handle_struct *handle;
|
||||
off_t copied;
|
||||
struct files_struct *src_fsp;
|
||||
@ -5481,8 +5481,8 @@ struct fruit_copy_chunk_state {
|
||||
bool is_copyfile;
|
||||
};
|
||||
|
||||
static void fruit_copy_chunk_done(struct tevent_req *subreq);
|
||||
static struct tevent_req *fruit_copy_chunk_send(struct vfs_handle_struct *handle,
|
||||
static void fruit_offload_write_done(struct tevent_req *subreq);
|
||||
static struct tevent_req *fruit_offload_write_send(struct vfs_handle_struct *handle,
|
||||
TALLOC_CTX *mem_ctx,
|
||||
struct tevent_context *ev,
|
||||
struct files_struct *src_fsp,
|
||||
@ -5493,7 +5493,7 @@ static struct tevent_req *fruit_copy_chunk_send(struct vfs_handle_struct *handle
|
||||
uint32_t flags)
|
||||
{
|
||||
struct tevent_req *req, *subreq;
|
||||
struct fruit_copy_chunk_state *fruit_copy_chunk_state;
|
||||
struct fruit_offload_write_state *state;
|
||||
NTSTATUS status;
|
||||
struct fruit_config_data *config;
|
||||
off_t to_copy = num;
|
||||
@ -5505,19 +5505,19 @@ static struct tevent_req *fruit_copy_chunk_send(struct vfs_handle_struct *handle
|
||||
struct fruit_config_data,
|
||||
return NULL);
|
||||
|
||||
req = tevent_req_create(mem_ctx, &fruit_copy_chunk_state,
|
||||
struct fruit_copy_chunk_state);
|
||||
req = tevent_req_create(mem_ctx, &state,
|
||||
struct fruit_offload_write_state);
|
||||
if (req == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
fruit_copy_chunk_state->handle = handle;
|
||||
fruit_copy_chunk_state->src_fsp = src_fsp;
|
||||
fruit_copy_chunk_state->dst_fsp = dest_fsp;
|
||||
state->handle = handle;
|
||||
state->src_fsp = src_fsp;
|
||||
state->dst_fsp = dest_fsp;
|
||||
|
||||
/*
|
||||
* Check if this a OS X copyfile style copychunk request with
|
||||
* a requested chunk count of 0 that was translated to a
|
||||
* copy_chunk_send VFS call overloading the parameters src_off
|
||||
* offload_write_send VFS call overloading the parameters src_off
|
||||
* = dest_off = num = 0.
|
||||
*/
|
||||
if ((src_off == 0) && (dest_off == 0) && (num == 0) &&
|
||||
@ -5530,10 +5530,10 @@ static struct tevent_req *fruit_copy_chunk_send(struct vfs_handle_struct *handle
|
||||
}
|
||||
|
||||
to_copy = src_fsp->fsp_name->st.st_ex_size;
|
||||
fruit_copy_chunk_state->is_copyfile = true;
|
||||
state->is_copyfile = true;
|
||||
}
|
||||
|
||||
subreq = SMB_VFS_NEXT_COPY_CHUNK_SEND(handle,
|
||||
subreq = SMB_VFS_NEXT_OFFLOAD_WRITE_SEND(handle,
|
||||
mem_ctx,
|
||||
ev,
|
||||
src_fsp,
|
||||
@ -5546,16 +5546,16 @@ static struct tevent_req *fruit_copy_chunk_send(struct vfs_handle_struct *handle
|
||||
return tevent_req_post(req, ev);
|
||||
}
|
||||
|
||||
tevent_req_set_callback(subreq, fruit_copy_chunk_done, req);
|
||||
tevent_req_set_callback(subreq, fruit_offload_write_done, req);
|
||||
return req;
|
||||
}
|
||||
|
||||
static void fruit_copy_chunk_done(struct tevent_req *subreq)
|
||||
static void fruit_offload_write_done(struct tevent_req *subreq)
|
||||
{
|
||||
struct tevent_req *req = tevent_req_callback_data(
|
||||
subreq, struct tevent_req);
|
||||
struct fruit_copy_chunk_state *state = tevent_req_data(
|
||||
req, struct fruit_copy_chunk_state);
|
||||
struct fruit_offload_write_state *state = tevent_req_data(
|
||||
req, struct fruit_offload_write_state);
|
||||
NTSTATUS status;
|
||||
unsigned int num_streams = 0;
|
||||
struct stream_struct *streams = NULL;
|
||||
@ -5563,7 +5563,7 @@ static void fruit_copy_chunk_done(struct tevent_req *subreq)
|
||||
struct smb_filename *src_fname_tmp = NULL;
|
||||
struct smb_filename *dst_fname_tmp = NULL;
|
||||
|
||||
status = SMB_VFS_NEXT_COPY_CHUNK_RECV(state->handle,
|
||||
status = SMB_VFS_NEXT_OFFLOAD_WRITE_RECV(state->handle,
|
||||
subreq,
|
||||
&state->copied);
|
||||
TALLOC_FREE(subreq);
|
||||
@ -5651,12 +5651,12 @@ static void fruit_copy_chunk_done(struct tevent_req *subreq)
|
||||
tevent_req_done(req);
|
||||
}
|
||||
|
||||
static NTSTATUS fruit_copy_chunk_recv(struct vfs_handle_struct *handle,
|
||||
static NTSTATUS fruit_offload_write_recv(struct vfs_handle_struct *handle,
|
||||
struct tevent_req *req,
|
||||
off_t *copied)
|
||||
{
|
||||
struct fruit_copy_chunk_state *fruit_copy_chunk_state = tevent_req_data(
|
||||
req, struct fruit_copy_chunk_state);
|
||||
struct fruit_offload_write_state *state = tevent_req_data(
|
||||
req, struct fruit_offload_write_state);
|
||||
NTSTATUS status;
|
||||
|
||||
if (tevent_req_is_nterror(req, &status)) {
|
||||
@ -5667,7 +5667,7 @@ static NTSTATUS fruit_copy_chunk_recv(struct vfs_handle_struct *handle,
|
||||
return status;
|
||||
}
|
||||
|
||||
*copied = fruit_copy_chunk_state->copied;
|
||||
*copied = state->copied;
|
||||
tevent_req_received(req);
|
||||
|
||||
return NT_STATUS_OK;
|
||||
@ -5700,8 +5700,8 @@ static struct vfs_fn_pointers vfs_fruit_fns = {
|
||||
.readdir_attr_fn = fruit_readdir_attr,
|
||||
.offload_read_send_fn = fruit_offload_read_send,
|
||||
.offload_read_recv_fn = fruit_offload_read_recv,
|
||||
.copy_chunk_send_fn = fruit_copy_chunk_send,
|
||||
.copy_chunk_recv_fn = fruit_copy_chunk_recv,
|
||||
.offload_write_send_fn = fruit_offload_write_send,
|
||||
.offload_write_recv_fn = fruit_offload_write_recv,
|
||||
|
||||
/* NT ACL operations */
|
||||
.fget_nt_acl_fn = fruit_fget_nt_acl,
|
||||
|
@ -170,8 +170,8 @@ typedef enum _vfs_op_type {
|
||||
SMB_VFS_OP_FSCTL,
|
||||
SMB_VFS_OP_OFFLOAD_READ_SEND,
|
||||
SMB_VFS_OP_OFFLOAD_READ_RECV,
|
||||
SMB_VFS_OP_COPY_CHUNK_SEND,
|
||||
SMB_VFS_OP_COPY_CHUNK_RECV,
|
||||
SMB_VFS_OP_OFFLOAD_WRITE_SEND,
|
||||
SMB_VFS_OP_OFFLOAD_WRITE_RECV,
|
||||
SMB_VFS_OP_GET_COMPRESSION,
|
||||
SMB_VFS_OP_SET_COMPRESSION,
|
||||
SMB_VFS_OP_SNAP_CHECK_PATH,
|
||||
@ -314,8 +314,8 @@ static struct {
|
||||
{ SMB_VFS_OP_FSCTL, "fsctl" },
|
||||
{ SMB_VFS_OP_OFFLOAD_READ_SEND, "offload_read_send" },
|
||||
{ SMB_VFS_OP_OFFLOAD_READ_RECV, "offload_read_recv" },
|
||||
{ SMB_VFS_OP_COPY_CHUNK_SEND, "copy_chunk_send" },
|
||||
{ SMB_VFS_OP_COPY_CHUNK_RECV, "copy_chunk_recv" },
|
||||
{ SMB_VFS_OP_OFFLOAD_WRITE_SEND, "offload_write_send" },
|
||||
{ SMB_VFS_OP_OFFLOAD_WRITE_RECV, "offload_write_recv" },
|
||||
{ SMB_VFS_OP_GET_COMPRESSION, "get_compression" },
|
||||
{ SMB_VFS_OP_SET_COMPRESSION, "set_compression" },
|
||||
{ SMB_VFS_OP_SNAP_CHECK_PATH, "snap_check_path" },
|
||||
@ -1941,7 +1941,7 @@ static NTSTATUS smb_full_audit_offload_read_recv(
|
||||
return status;
|
||||
}
|
||||
|
||||
static struct tevent_req *smb_full_audit_copy_chunk_send(struct vfs_handle_struct *handle,
|
||||
static struct tevent_req *smb_full_audit_offload_write_send(struct vfs_handle_struct *handle,
|
||||
TALLOC_CTX *mem_ctx,
|
||||
struct tevent_context *ev,
|
||||
struct files_struct *src_fsp,
|
||||
@ -1953,24 +1953,24 @@ static struct tevent_req *smb_full_audit_copy_chunk_send(struct vfs_handle_struc
|
||||
{
|
||||
struct tevent_req *req;
|
||||
|
||||
req = SMB_VFS_NEXT_COPY_CHUNK_SEND(handle, mem_ctx, ev, src_fsp,
|
||||
req = SMB_VFS_NEXT_OFFLOAD_WRITE_SEND(handle, mem_ctx, ev, src_fsp,
|
||||
src_off, dest_fsp, dest_off, num,
|
||||
flags);
|
||||
|
||||
do_log(SMB_VFS_OP_COPY_CHUNK_SEND, req, handle, "");
|
||||
do_log(SMB_VFS_OP_OFFLOAD_WRITE_SEND, req, handle, "");
|
||||
|
||||
return req;
|
||||
}
|
||||
|
||||
static NTSTATUS smb_full_audit_copy_chunk_recv(struct vfs_handle_struct *handle,
|
||||
static NTSTATUS smb_full_audit_offload_write_recv(struct vfs_handle_struct *handle,
|
||||
struct tevent_req *req,
|
||||
off_t *copied)
|
||||
{
|
||||
NTSTATUS result;
|
||||
|
||||
result = SMB_VFS_NEXT_COPY_CHUNK_RECV(handle, req, copied);
|
||||
result = SMB_VFS_NEXT_OFFLOAD_WRITE_RECV(handle, req, copied);
|
||||
|
||||
do_log(SMB_VFS_OP_COPY_CHUNK_RECV, NT_STATUS_IS_OK(result), handle, "");
|
||||
do_log(SMB_VFS_OP_OFFLOAD_WRITE_RECV, NT_STATUS_IS_OK(result), handle, "");
|
||||
|
||||
return result;
|
||||
}
|
||||
@ -2576,8 +2576,8 @@ static struct vfs_fn_pointers vfs_full_audit_fns = {
|
||||
.file_id_create_fn = smb_full_audit_file_id_create,
|
||||
.offload_read_send_fn = smb_full_audit_offload_read_send,
|
||||
.offload_read_recv_fn = smb_full_audit_offload_read_recv,
|
||||
.copy_chunk_send_fn = smb_full_audit_copy_chunk_send,
|
||||
.copy_chunk_recv_fn = smb_full_audit_copy_chunk_recv,
|
||||
.offload_write_send_fn = smb_full_audit_offload_write_send,
|
||||
.offload_write_recv_fn = smb_full_audit_offload_write_recv,
|
||||
.get_compression_fn = smb_full_audit_get_compression,
|
||||
.set_compression_fn = smb_full_audit_set_compression,
|
||||
.snap_check_path_fn = smb_full_audit_snap_check_path,
|
||||
|
@ -1473,8 +1473,6 @@ static struct vfs_fn_pointers glusterfs_fns = {
|
||||
.realpath_fn = vfs_gluster_realpath,
|
||||
.chflags_fn = vfs_gluster_chflags,
|
||||
.file_id_create_fn = NULL,
|
||||
.copy_chunk_send_fn = NULL,
|
||||
.copy_chunk_recv_fn = NULL,
|
||||
.streaminfo_fn = NULL,
|
||||
.get_real_filename_fn = vfs_gluster_get_real_filename,
|
||||
.connectpath_fn = vfs_gluster_connectpath,
|
||||
|
@ -1995,14 +1995,14 @@ static NTSTATUS smb_time_audit_offload_read_recv(
|
||||
return NT_STATUS_OK;
|
||||
}
|
||||
|
||||
struct time_audit_cc_state {
|
||||
struct time_audit_offload_write_state {
|
||||
struct timespec ts_send;
|
||||
struct vfs_handle_struct *handle;
|
||||
off_t copied;
|
||||
};
|
||||
static void smb_time_audit_copy_chunk_done(struct tevent_req *subreq);
|
||||
static void smb_time_audit_offload_write_done(struct tevent_req *subreq);
|
||||
|
||||
static struct tevent_req *smb_time_audit_copy_chunk_send(struct vfs_handle_struct *handle,
|
||||
static struct tevent_req *smb_time_audit_offload_write_send(struct vfs_handle_struct *handle,
|
||||
TALLOC_CTX *mem_ctx,
|
||||
struct tevent_context *ev,
|
||||
struct files_struct *src_fsp,
|
||||
@ -2014,37 +2014,38 @@ static struct tevent_req *smb_time_audit_copy_chunk_send(struct vfs_handle_struc
|
||||
{
|
||||
struct tevent_req *req;
|
||||
struct tevent_req *subreq;
|
||||
struct time_audit_cc_state *cc_state;
|
||||
struct time_audit_offload_write_state *state;
|
||||
|
||||
req = tevent_req_create(mem_ctx, &cc_state, struct time_audit_cc_state);
|
||||
req = tevent_req_create(mem_ctx, &state,
|
||||
struct time_audit_offload_write_state);
|
||||
if (req == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
cc_state->handle = handle;
|
||||
clock_gettime_mono(&cc_state->ts_send);
|
||||
subreq = SMB_VFS_NEXT_COPY_CHUNK_SEND(handle, cc_state, ev,
|
||||
state->handle = handle;
|
||||
clock_gettime_mono(&state->ts_send);
|
||||
subreq = SMB_VFS_NEXT_OFFLOAD_WRITE_SEND(handle, state, ev,
|
||||
src_fsp, src_off,
|
||||
dest_fsp, dest_off, num, flags);
|
||||
if (tevent_req_nomem(subreq, req)) {
|
||||
return tevent_req_post(req, ev);
|
||||
}
|
||||
|
||||
tevent_req_set_callback(subreq, smb_time_audit_copy_chunk_done, req);
|
||||
tevent_req_set_callback(subreq, smb_time_audit_offload_write_done, req);
|
||||
return req;
|
||||
}
|
||||
|
||||
static void smb_time_audit_copy_chunk_done(struct tevent_req *subreq)
|
||||
static void smb_time_audit_offload_write_done(struct tevent_req *subreq)
|
||||
{
|
||||
struct tevent_req *req = tevent_req_callback_data(
|
||||
subreq, struct tevent_req);
|
||||
struct time_audit_cc_state *cc_state
|
||||
= tevent_req_data(req, struct time_audit_cc_state);
|
||||
struct time_audit_offload_write_state *state = tevent_req_data(
|
||||
req, struct time_audit_offload_write_state);
|
||||
NTSTATUS status;
|
||||
|
||||
status = SMB_VFS_NEXT_COPY_CHUNK_RECV(cc_state->handle,
|
||||
status = SMB_VFS_NEXT_OFFLOAD_WRITE_RECV(state->handle,
|
||||
subreq,
|
||||
&cc_state->copied);
|
||||
&state->copied);
|
||||
TALLOC_FREE(subreq);
|
||||
if (tevent_req_nterror(req, status)) {
|
||||
return;
|
||||
@ -2052,23 +2053,23 @@ static void smb_time_audit_copy_chunk_done(struct tevent_req *subreq)
|
||||
tevent_req_done(req);
|
||||
}
|
||||
|
||||
static NTSTATUS smb_time_audit_copy_chunk_recv(struct vfs_handle_struct *handle,
|
||||
static NTSTATUS smb_time_audit_offload_write_recv(struct vfs_handle_struct *handle,
|
||||
struct tevent_req *req,
|
||||
off_t *copied)
|
||||
{
|
||||
struct time_audit_cc_state *cc_state
|
||||
= tevent_req_data(req, struct time_audit_cc_state);
|
||||
struct time_audit_offload_write_state *state = tevent_req_data(
|
||||
req, struct time_audit_offload_write_state);
|
||||
struct timespec ts_recv;
|
||||
double timediff;
|
||||
NTSTATUS status;
|
||||
|
||||
clock_gettime_mono(&ts_recv);
|
||||
timediff = nsec_time_diff(&ts_recv, &cc_state->ts_send)*1.0e-9;
|
||||
timediff = nsec_time_diff(&ts_recv, &state->ts_send)*1.0e-9;
|
||||
if (timediff > audit_timeout) {
|
||||
smb_time_audit_log("copy_chunk", timediff);
|
||||
smb_time_audit_log("offload_write", timediff);
|
||||
}
|
||||
|
||||
*copied = cc_state->copied;
|
||||
*copied = state->copied;
|
||||
if (tevent_req_is_nterror(req, &status)) {
|
||||
tevent_req_received(req);
|
||||
return status;
|
||||
@ -2771,8 +2772,8 @@ static struct vfs_fn_pointers vfs_time_audit_fns = {
|
||||
.file_id_create_fn = smb_time_audit_file_id_create,
|
||||
.offload_read_send_fn = smb_time_audit_offload_read_send,
|
||||
.offload_read_recv_fn = smb_time_audit_offload_read_recv,
|
||||
.copy_chunk_send_fn = smb_time_audit_copy_chunk_send,
|
||||
.copy_chunk_recv_fn = smb_time_audit_copy_chunk_recv,
|
||||
.offload_write_send_fn = smb_time_audit_offload_write_send,
|
||||
.offload_write_recv_fn = smb_time_audit_offload_write_recv,
|
||||
.get_compression_fn = smb_time_audit_get_compression,
|
||||
.set_compression_fn = smb_time_audit_set_compression,
|
||||
.snap_check_path_fn = smb_time_audit_snap_check_path,
|
||||
|
@ -289,16 +289,16 @@ static void fsctl_dup_extents_offload_read_done(struct tevent_req *subreq)
|
||||
}
|
||||
|
||||
/* tell the VFS to ignore locks across the clone, matching ReFS */
|
||||
subreq = SMB_VFS_COPY_CHUNK_SEND(state->dst_fsp->conn,
|
||||
state,
|
||||
state->ev,
|
||||
state->src_fsp,
|
||||
state->dup_extents.source_off,
|
||||
state->dst_fsp,
|
||||
state->dup_extents.target_off,
|
||||
state->dup_extents.byte_count,
|
||||
VFS_COPY_CHUNK_FL_MUST_CLONE
|
||||
| VFS_COPY_CHUNK_FL_IGNORE_LOCKS);
|
||||
subreq = SMB_VFS_OFFLOAD_WRITE_SEND(state->dst_fsp->conn,
|
||||
state,
|
||||
state->ev,
|
||||
state->src_fsp,
|
||||
state->dup_extents.source_off,
|
||||
state->dst_fsp,
|
||||
state->dup_extents.target_off,
|
||||
state->dup_extents.byte_count,
|
||||
VFS_OFFLOAD_WRITE_FL_MUST_CLONE
|
||||
| VFS_OFFLOAD_WRITE_FL_IGNORE_LOCKS);
|
||||
if (tevent_req_nomem(subreq, req)) {
|
||||
return;
|
||||
}
|
||||
@ -315,7 +315,7 @@ static void fsctl_dup_extents_vfs_done(struct tevent_req *subreq)
|
||||
off_t nb_chunk;
|
||||
NTSTATUS status;
|
||||
|
||||
status = SMB_VFS_COPY_CHUNK_RECV(state->conn, subreq, &nb_chunk);
|
||||
status = SMB_VFS_OFFLOAD_WRITE_RECV(state->conn, subreq, &nb_chunk);
|
||||
TALLOC_FREE(subreq);
|
||||
if (tevent_req_nterror(req, status)) {
|
||||
return;
|
||||
|
@ -340,7 +340,7 @@ static NTSTATUS fsctl_srv_copychunk_loop(struct tevent_req *req)
|
||||
}
|
||||
state->aapl_copyfile = true;
|
||||
|
||||
subreq = SMB_VFS_COPY_CHUNK_SEND(state->dst_fsp->conn,
|
||||
subreq = SMB_VFS_OFFLOAD_WRITE_SEND(state->dst_fsp->conn,
|
||||
state,
|
||||
state->ev,
|
||||
state->src_fsp,
|
||||
@ -360,7 +360,7 @@ static NTSTATUS fsctl_srv_copychunk_loop(struct tevent_req *req)
|
||||
chunk = &state->cc_copy.chunks[state->current_chunk];
|
||||
length = next_merged_io(state);
|
||||
|
||||
subreq = SMB_VFS_COPY_CHUNK_SEND(state->dst_fsp->conn,
|
||||
subreq = SMB_VFS_OFFLOAD_WRITE_SEND(state->dst_fsp->conn,
|
||||
state,
|
||||
state->ev,
|
||||
state->src_fsp,
|
||||
@ -386,7 +386,7 @@ static void fsctl_srv_copychunk_vfs_done(struct tevent_req *subreq)
|
||||
off_t chunk_nwritten;
|
||||
NTSTATUS status;
|
||||
|
||||
status = SMB_VFS_COPY_CHUNK_RECV(state->conn, subreq,
|
||||
status = SMB_VFS_OFFLOAD_WRITE_RECV(state->conn, subreq,
|
||||
&chunk_nwritten);
|
||||
TALLOC_FREE(subreq);
|
||||
if (!NT_STATUS_IS_OK(status)) {
|
||||
|
@ -2374,28 +2374,28 @@ NTSTATUS smb_vfs_call_offload_read_recv(struct tevent_req *req,
|
||||
return handle->fns->offload_read_recv_fn(req, handle, mem_ctx, token_blob);
|
||||
}
|
||||
|
||||
struct tevent_req *smb_vfs_call_copy_chunk_send(struct vfs_handle_struct *handle,
|
||||
TALLOC_CTX *mem_ctx,
|
||||
struct tevent_context *ev,
|
||||
struct files_struct *src_fsp,
|
||||
off_t src_off,
|
||||
struct files_struct *dest_fsp,
|
||||
off_t dest_off,
|
||||
off_t num,
|
||||
uint32_t flags)
|
||||
struct tevent_req *smb_vfs_call_offload_write_send(struct vfs_handle_struct *handle,
|
||||
TALLOC_CTX *mem_ctx,
|
||||
struct tevent_context *ev,
|
||||
struct files_struct *src_fsp,
|
||||
off_t src_off,
|
||||
struct files_struct *dest_fsp,
|
||||
off_t dest_off,
|
||||
off_t num,
|
||||
uint32_t flags)
|
||||
{
|
||||
VFS_FIND(copy_chunk_send);
|
||||
return handle->fns->copy_chunk_send_fn(handle, mem_ctx, ev, src_fsp,
|
||||
VFS_FIND(offload_write_send);
|
||||
return handle->fns->offload_write_send_fn(handle, mem_ctx, ev, src_fsp,
|
||||
src_off, dest_fsp, dest_off, num,
|
||||
flags);
|
||||
}
|
||||
|
||||
NTSTATUS smb_vfs_call_copy_chunk_recv(struct vfs_handle_struct *handle,
|
||||
struct tevent_req *req,
|
||||
off_t *copied)
|
||||
NTSTATUS smb_vfs_call_offload_write_recv(struct vfs_handle_struct *handle,
|
||||
struct tevent_req *req,
|
||||
off_t *copied)
|
||||
{
|
||||
VFS_FIND(copy_chunk_recv);
|
||||
return handle->fns->copy_chunk_recv_fn(handle, req, copied);
|
||||
VFS_FIND(offload_write_recv);
|
||||
return handle->fns->offload_write_recv_fn(handle, req, copied);
|
||||
}
|
||||
|
||||
NTSTATUS smb_vfs_call_get_compression(vfs_handle_struct *handle,
|
||||
|
Loading…
Reference in New Issue
Block a user