sin/samba-mirror
1
0
Fork 0
mirror of https://github.com/samba-team/samba.git synced 2025-01-26 10:04:02 +03:00
Code

s3/vfs: rename SMB_VFS_COPY_CHUNK_SEND/RECV to SMB_VFS_OFFLOAD_WRITE_SEND/RECV

Browse Source 
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:
Ralph Boehme 2017-06-04 13:50:33 +02:00
parent 67ed1edba7
commit 64bedefa11
13 changed files with 209 additions and 202 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
examples/VFS/skel_opaque.c
View File

@ -582,7 +582,7 @@ static NTSTATUS skel_offload_read_recv(struct tevent_req *req,
struct skel_cc_state { struct skel_cc_state {
uint64_t unused; 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, TALLOC_CTX *mem_ctx,
struct tevent_context *ev, struct tevent_context *ev,
struct files_struct *src_fsp, 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); 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, struct tevent_req *req,
off_t *copied) off_t *copied)
{ {
@ -1011,8 +1011,8 @@ struct vfs_fn_pointers skel_opaque_fns = {
.file_id_create_fn = skel_file_id_create, .file_id_create_fn = skel_file_id_create,
.offload_read_send_fn = skel_offload_read_send, .offload_read_send_fn = skel_offload_read_send,
.offload_read_recv_fn = skel_offload_read_recv, .offload_read_recv_fn = skel_offload_read_recv,
.copy_chunk_send_fn = skel_copy_chunk_send, .offload_write_send_fn = skel_offload_write_send,
.copy_chunk_recv_fn = skel_copy_chunk_recv, .offload_write_recv_fn = skel_offload_write_recv,
.get_compression_fn = skel_get_compression, .get_compression_fn = skel_get_compression,
.set_compression_fn = skel_set_compression, .set_compression_fn = skel_set_compression,

38
examples/VFS/skel_transparent.c
View File

@ -710,13 +710,13 @@ static NTSTATUS skel_offload_read_recv(struct tevent_req *req,
return NT_STATUS_OK; return NT_STATUS_OK;
} }
struct skel_cc_state { struct skel_offload_write_state {
struct vfs_handle_struct *handle; struct vfs_handle_struct *handle;
off_t copied; 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, TALLOC_CTX *mem_ctx,
struct tevent_context *ev, struct tevent_context *ev,
struct files_struct *src_fsp, 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 *req;
struct tevent_req *subreq; 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) { if (req == NULL) {
return NULL; return NULL;
} }
cc_state->handle = handle; state->handle = handle;
subreq = SMB_VFS_NEXT_COPY_CHUNK_SEND(handle, cc_state, ev, subreq = SMB_VFS_NEXT_OFFLOAD_WRITE_SEND(handle, state, ev,
src_fsp, src_off, src_fsp, src_off,
dest_fsp, dest_off, num, flags); dest_fsp, dest_off, num, flags);
if (tevent_req_nomem(subreq, req)) { if (tevent_req_nomem(subreq, req)) {
return tevent_req_post(req, ev); 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; 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( struct tevent_req *req = tevent_req_callback_data(
subreq, struct tevent_req); subreq, struct tevent_req);
struct skel_cc_state *cc_state struct skel_offload_write_state *state
= tevent_req_data(req, struct skel_cc_state); = tevent_req_data(req, struct skel_offload_write_state);
NTSTATUS status; NTSTATUS status;
status = SMB_VFS_NEXT_COPY_CHUNK_RECV(cc_state->handle, status = SMB_VFS_NEXT_OFFLOAD_WRITE_RECV(state->handle,
subreq, subreq,
&cc_state->copied); &state->copied);
TALLOC_FREE(subreq); TALLOC_FREE(subreq);
if (tevent_req_nterror(req, status)) { if (tevent_req_nterror(req, status)) {
return; return;
@ -765,15 +765,15 @@ static void skel_copy_chunk_done(struct tevent_req *subreq)
tevent_req_done(req); 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, struct tevent_req *req,
off_t *copied) off_t *copied)
{ {
struct skel_cc_state *cc_state struct skel_offload_write_state *state
= tevent_req_data(req, struct skel_cc_state); = tevent_req_data(req, struct skel_offload_write_state);
NTSTATUS status; NTSTATUS status;
*copied = cc_state->copied; *copied = state->copied;
if (tevent_req_is_nterror(req, &status)) { if (tevent_req_is_nterror(req, &status)) {
tevent_req_received(req); tevent_req_received(req);
return status; return status;
@ -1184,8 +1184,8 @@ struct vfs_fn_pointers skel_transparent_fns = {
.file_id_create_fn = skel_file_id_create, .file_id_create_fn = skel_file_id_create,
.offload_read_send_fn = skel_offload_read_send, .offload_read_send_fn = skel_offload_read_send,
.offload_read_recv_fn = skel_offload_read_recv, .offload_read_recv_fn = skel_offload_read_recv,
.copy_chunk_send_fn = skel_copy_chunk_send, .offload_write_send_fn = skel_offload_write_send,
.copy_chunk_recv_fn = skel_copy_chunk_recv, .offload_write_recv_fn = skel_offload_write_recv,
.get_compression_fn = skel_get_compression, .get_compression_fn = skel_get_compression,
.set_compression_fn = skel_set_compression, .set_compression_fn = skel_set_compression,

66
source3/include/vfs.h
View File

@ -239,6 +239,8 @@
/* Version 37 - Change connectpath from char * /* Version 37 - Change connectpath from char *
to struct smb_filename * */ to struct smb_filename * */
/* Version 37 - Add SMB_VFS_OFFLOAD_READ_SEND/RECV */ /* 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 #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. * 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 { enum vfs_offload_write_flags {
VFS_COPY_CHUNK_FL_MUST_CLONE = 0x0001, VFS_OFFLOAD_WRITE_FL_MUST_CLONE = 0x0001,
VFS_COPY_CHUNK_FL_IGNORE_LOCKS = 0x0002, VFS_OFFLOAD_WRITE_FL_IGNORE_LOCKS = 0x0002,
VFS_COPY_CHUNK_FL_MASK_ALL = VFS_OFFLOAD_WRITE_FL_MASK_ALL =
(VFS_COPY_CHUNK_FL_MUST_CLONE (VFS_OFFLOAD_WRITE_FL_MUST_CLONE
| VFS_COPY_CHUNK_FL_IGNORE_LOCKS), | VFS_OFFLOAD_WRITE_FL_IGNORE_LOCKS),
}; };
struct vfs_aio_state { struct vfs_aio_state {
@ -794,18 +796,18 @@ struct vfs_fn_pointers {
struct vfs_handle_struct *handle, struct vfs_handle_struct *handle,
TALLOC_CTX *mem_ctx, TALLOC_CTX *mem_ctx,
DATA_BLOB *token_blob); DATA_BLOB *token_blob);
struct tevent_req *(*copy_chunk_send_fn)(struct vfs_handle_struct *handle, struct tevent_req *(*offload_write_send_fn)(struct vfs_handle_struct *handle,
TALLOC_CTX *mem_ctx, TALLOC_CTX *mem_ctx,
struct tevent_context *ev, struct tevent_context *ev,
struct files_struct *src_fsp, struct files_struct *src_fsp,
off_t src_off, off_t src_off,
struct files_struct *dest_fsp, struct files_struct *dest_fsp,
off_t dest_off, off_t dest_off,
off_t to_copy, off_t to_copy,
uint32_t flags); uint32_t flags);
NTSTATUS (*copy_chunk_recv_fn)(struct vfs_handle_struct *handle, NTSTATUS (*offload_write_recv_fn)(struct vfs_handle_struct *handle,
struct tevent_req *req, struct tevent_req *req,
off_t *copied); off_t *copied);
NTSTATUS (*get_compression_fn)(struct vfs_handle_struct *handle, NTSTATUS (*get_compression_fn)(struct vfs_handle_struct *handle,
TALLOC_CTX *mem_ctx, TALLOC_CTX *mem_ctx,
struct files_struct *fsp, struct files_struct *fsp,
@ -1374,18 +1376,18 @@ NTSTATUS smb_vfs_call_offload_read_recv(struct tevent_req *req,
struct vfs_handle_struct *handle, struct vfs_handle_struct *handle,
TALLOC_CTX *mem_ctx, TALLOC_CTX *mem_ctx,
DATA_BLOB *token_blob); DATA_BLOB *token_blob);
struct tevent_req *smb_vfs_call_copy_chunk_send(struct vfs_handle_struct *handle, struct tevent_req *smb_vfs_call_offload_write_send(struct vfs_handle_struct *handle,
TALLOC_CTX *mem_ctx, TALLOC_CTX *mem_ctx,
struct tevent_context *ev, struct tevent_context *ev,
struct files_struct *src_fsp, struct files_struct *src_fsp,
off_t src_off, off_t src_off,
struct files_struct *dest_fsp, struct files_struct *dest_fsp,
off_t dest_off, off_t dest_off,
off_t num, off_t num,
uint32_t flags); uint32_t flags);
NTSTATUS smb_vfs_call_copy_chunk_recv(struct vfs_handle_struct *handle, NTSTATUS smb_vfs_call_offload_write_recv(struct vfs_handle_struct *handle,
struct tevent_req *req, struct tevent_req *req,
off_t *copied); off_t *copied);
NTSTATUS smb_vfs_call_get_compression(struct vfs_handle_struct *handle, NTSTATUS smb_vfs_call_get_compression(struct vfs_handle_struct *handle,
TALLOC_CTX *mem_ctx, TALLOC_CTX *mem_ctx,
struct files_struct *fsp, struct files_struct *fsp,

16
source3/include/vfs_macros.h
View File

@ -425,15 +425,15 @@
#define SMB_VFS_NEXT_OFFLOAD_READ_RECV(req, handle, mem_ctx, token_blob) \ #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)) 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) \ #define SMB_VFS_OFFLOAD_WRITE_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)) 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_COPY_CHUNK_SEND(handle, 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_copy_chunk_send((handle)->next, (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) \ #define SMB_VFS_OFFLOAD_WRITE_RECV(conn, req, copied) \
smb_vfs_call_copy_chunk_recv((conn)->vfs_handles, (req), (copied)) smb_vfs_call_offload_write_recv((conn)->vfs_handles, (req), (copied))
#define SMB_VFS_NEXT_COPY_CHUNK_RECV(handle, req, copied) \ #define SMB_VFS_NEXT_OFFLOAD_WRITE_RECV(handle, req, copied) \
smb_vfs_call_copy_chunk_recv((handle)->next, (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) \ #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)) smb_vfs_call_get_compression((conn)->vfs_handles, (mem_ctx), (fsp), (smb_fname), (_compression_fmt))

28
source3/modules/vfs_btrfs.c
View File

@ -201,9 +201,9 @@ struct btrfs_cc_state {
off_t copied; off_t copied;
struct tevent_req *subreq; /* non-null if passed to next VFS fn */ 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, TALLOC_CTX *mem_ctx,
struct tevent_context *ev, struct tevent_context *ev,
struct files_struct *src_fsp, struct files_struct *src_fsp,
@ -226,7 +226,7 @@ static struct tevent_req *btrfs_copy_chunk_send(struct vfs_handle_struct *handle
return 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); tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
return tevent_req_post(req, ev); 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 * all data from @src_offset->EOF! This is certainly not what
* the caller expects, and not what vfs_default does. * 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, cc_state, ev,
src_fsp, src_fsp,
src_off, 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); return tevent_req_post(req, ev);
} }
tevent_req_set_callback(cc_state->subreq, tevent_req_set_callback(cc_state->subreq,
btrfs_copy_chunk_done, btrfs_offload_write_done,
req); req);
return 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); 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, init_strict_lock_struct(src_fsp,
src_fsp->op->global->open_persistent_id, src_fsp->op->global->open_persistent_id,
src_off, 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; cr_args.src_length = (uint64_t)num;
ret = ioctl(dest_fsp->fh->fd, BTRFS_IOC_CLONE_RANGE, &cr_args); 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(dest_fsp->conn, dest_fsp, &dest_lck);
SMB_VFS_STRICT_UNLOCK(src_fsp->conn, src_fsp, &src_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, (unsigned long long)cr_args.src_offset,
dest_fsp->fh->fd, dest_fsp->fh->fd,
(unsigned long long)cr_args.dest_offset)); (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, cc_state, ev,
src_fsp, src_fsp,
src_off, src_off,
@ -333,7 +333,7 @@ static struct tevent_req *btrfs_copy_chunk_send(struct vfs_handle_struct *handle
} }
/* wait for subreq completion */ /* wait for subreq completion */
tevent_req_set_callback(cc_state->subreq, tevent_req_set_callback(cc_state->subreq,
btrfs_copy_chunk_done, btrfs_offload_write_done,
req); req);
return 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 */ /* 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( struct tevent_req *req = tevent_req_callback_data(
subreq, struct tevent_req); subreq, struct tevent_req);
@ -354,7 +354,7 @@ static void btrfs_copy_chunk_done(struct tevent_req *subreq)
struct btrfs_cc_state); struct btrfs_cc_state);
NTSTATUS status; 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->subreq,
&cc_state->copied); &cc_state->copied);
if (tevent_req_nterror(req, status)) { if (tevent_req_nterror(req, status)) {
@ -363,7 +363,7 @@ static void btrfs_copy_chunk_done(struct tevent_req *subreq)
tevent_req_done(req); 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, struct tevent_req *req,
off_t *copied) off_t *copied)
{ {
@ -800,8 +800,8 @@ static struct vfs_fn_pointers btrfs_fns = {
.fs_capabilities_fn = btrfs_fs_capabilities, .fs_capabilities_fn = btrfs_fs_capabilities,
.offload_read_send_fn = btrfs_offload_read_send, .offload_read_send_fn = btrfs_offload_read_send,
.offload_read_recv_fn = btrfs_offload_read_recv, .offload_read_recv_fn = btrfs_offload_read_recv,
.copy_chunk_send_fn = btrfs_copy_chunk_send, .offload_write_send_fn = btrfs_offload_write_send,
.copy_chunk_recv_fn = btrfs_copy_chunk_recv, .offload_write_recv_fn = btrfs_offload_write_recv,
.get_compression_fn = btrfs_get_compression, .get_compression_fn = btrfs_get_compression,
.set_compression_fn = btrfs_set_compression, .set_compression_fn = btrfs_set_compression,
.snap_check_path_fn = btrfs_snap_check_path, .snap_check_path_fn = btrfs_snap_check_path,

78
source3/modules/vfs_default.c
View File

@ -1682,7 +1682,7 @@ static NTSTATUS vfswrap_offload_read_recv(struct tevent_req *req,
return NT_STATUS_OK; return NT_STATUS_OK;
} }
struct vfs_cc_state { struct vfswrap_offload_write_state {
struct tevent_context *ev; struct tevent_context *ev;
uint8_t *buf; uint8_t *buf;
bool read_lck_locked; bool read_lck_locked;
@ -1699,42 +1699,44 @@ struct vfs_cc_state {
uint32_t flags; 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, static struct tevent_req *vfswrap_offload_write_send(
TALLOC_CTX *mem_ctx, struct vfs_handle_struct *handle,
struct tevent_context *ev, TALLOC_CTX *mem_ctx,
struct files_struct *src_fsp, struct tevent_context *ev,
off_t src_off, struct files_struct *src_fsp,
struct files_struct *dest_fsp, off_t src_off,
off_t dest_off, struct files_struct *dest_fsp,
off_t to_copy, off_t dest_off,
uint32_t flags) off_t to_copy,
uint32_t flags)
{ {
struct tevent_req *req; 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); size_t num = MIN(to_copy, COPYCHUNK_MAX_TOTAL_LEN);
NTSTATUS status; NTSTATUS status;
DBG_DEBUG("server side copy chunk of length %" PRIu64 "\n", to_copy); 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) { if (req == NULL) {
return 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); tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
return tevent_req_post(req, ev); 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")); DEBUG(10, ("COW clones not supported by vfs_default\n"));
tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER); tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
return tevent_req_post(req, ev); return tevent_req_post(req, ev);
} }
*state = (struct vfs_cc_state) { *state = (struct vfswrap_offload_write_state) {
.ev = ev, .ev = ev,
.src_fsp = src_fsp, .src_fsp = src_fsp,
.src_off = src_off, .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); return tevent_req_post(req, ev);
} }
status = copy_chunk_loop(req); status = vfswrap_offload_write_loop(req);
if (!NT_STATUS_IS_OK(status)) { if (!NT_STATUS_IS_OK(status)) {
tevent_req_nterror(req, status); tevent_req_nterror(req, status);
return tevent_req_post(req, ev); 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; 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; struct tevent_req *subreq = NULL;
bool ok; bool ok;
state->next_io_size = MIN(state->remaining, talloc_array_length(state->buf)); 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, init_strict_lock_struct(state->src_fsp,
state->src_fsp->op->global->open_persistent_id, state->src_fsp->op->global->open_persistent_id,
state->src_off, state->src_off,
@ -1822,23 +1825,24 @@ static NTSTATUS copy_chunk_loop(struct tevent_req *req)
if (subreq == NULL) { if (subreq == NULL) {
return NT_STATUS_NO_MEMORY; 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; 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( struct tevent_req *req = tevent_req_callback_data(
subreq, struct tevent_req); 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; struct vfs_aio_state aio_state;
ssize_t nread; ssize_t nread;
bool ok; 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, SMB_VFS_STRICT_UNLOCK(state->src_fsp->conn,
state->src_fsp, state->src_fsp,
&state->read_lck); &state->read_lck);
@ -1861,7 +1865,7 @@ static void vfswrap_copy_chunk_read_done(struct tevent_req *subreq)
state->src_off += nread; 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, init_strict_lock_struct(state->dst_fsp,
state->dst_fsp->op->global->open_persistent_id, state->dst_fsp->op->global->open_persistent_id,
state->dst_off, 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); tevent_req_nterror(req, NT_STATUS_NO_MEMORY);
return; 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( struct tevent_req *req = tevent_req_callback_data(
subreq, struct tevent_req); 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; struct vfs_aio_state aio_state;
ssize_t nwritten; ssize_t nwritten;
NTSTATUS status; 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, SMB_VFS_STRICT_UNLOCK(state->dst_fsp->conn,
state->dst_fsp, state->dst_fsp,
&state->write_lck); &state->write_lck);
@ -1933,7 +1938,7 @@ static void vfswrap_copy_chunk_write_done(struct tevent_req *subreq)
return; return;
} }
status = copy_chunk_loop(req); status = vfswrap_offload_write_loop(req);
if (!NT_STATUS_IS_OK(status)) { if (!NT_STATUS_IS_OK(status)) {
tevent_req_nterror(req, status); tevent_req_nterror(req, status);
return; return;
@ -1942,11 +1947,12 @@ static void vfswrap_copy_chunk_write_done(struct tevent_req *subreq)
return; 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, struct tevent_req *req,
off_t *copied) 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; NTSTATUS status;
if (tevent_req_is_nterror(req, &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, .fget_dos_attributes_fn = vfswrap_fget_dos_attributes,
.offload_read_send_fn = vfswrap_offload_read_send, .offload_read_send_fn = vfswrap_offload_read_send,
.offload_read_recv_fn = vfswrap_offload_read_recv, .offload_read_recv_fn = vfswrap_offload_read_recv,
.copy_chunk_send_fn = vfswrap_copy_chunk_send, .offload_write_send_fn = vfswrap_offload_write_send,
.copy_chunk_recv_fn = vfswrap_copy_chunk_recv, .offload_write_recv_fn = vfswrap_offload_write_recv,
.get_compression_fn = vfswrap_get_compression, .get_compression_fn = vfswrap_get_compression,
.set_compression_fn = vfswrap_set_compression, .set_compression_fn = vfswrap_set_compression,

46
source3/modules/vfs_fruit.c
View File

@ -5473,7 +5473,7 @@ static NTSTATUS fruit_offload_read_recv(struct tevent_req *req,
return NT_STATUS_OK; return NT_STATUS_OK;
} }
struct fruit_copy_chunk_state { struct fruit_offload_write_state {
struct vfs_handle_struct *handle; struct vfs_handle_struct *handle;
off_t copied; off_t copied;
struct files_struct *src_fsp; struct files_struct *src_fsp;
@ -5481,8 +5481,8 @@ struct fruit_copy_chunk_state {
bool is_copyfile; bool is_copyfile;
}; };
static void fruit_copy_chunk_done(struct tevent_req *subreq); static void fruit_offload_write_done(struct tevent_req *subreq);
static struct tevent_req *fruit_copy_chunk_send(struct vfs_handle_struct *handle, static struct tevent_req *fruit_offload_write_send(struct vfs_handle_struct *handle,
TALLOC_CTX *mem_ctx, TALLOC_CTX *mem_ctx,
struct tevent_context *ev, struct tevent_context *ev,
struct files_struct *src_fsp, 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) uint32_t flags)
{ {
struct tevent_req *req, *subreq; struct tevent_req *req, *subreq;
struct fruit_copy_chunk_state *fruit_copy_chunk_state; struct fruit_offload_write_state *state;
NTSTATUS status; NTSTATUS status;
struct fruit_config_data *config; struct fruit_config_data *config;
off_t to_copy = num; 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, struct fruit_config_data,
return NULL); return NULL);
req = tevent_req_create(mem_ctx, &fruit_copy_chunk_state, req = tevent_req_create(mem_ctx, &state,
struct fruit_copy_chunk_state); struct fruit_offload_write_state);
if (req == NULL) { if (req == NULL) {
return NULL; return NULL;
} }
fruit_copy_chunk_state->handle = handle; state->handle = handle;
fruit_copy_chunk_state->src_fsp = src_fsp; state->src_fsp = src_fsp;
fruit_copy_chunk_state->dst_fsp = dest_fsp; state->dst_fsp = dest_fsp;
/* /*
* Check if this a OS X copyfile style copychunk request with * Check if this a OS X copyfile style copychunk request with
* a requested chunk count of 0 that was translated to a * 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. * = dest_off = num = 0.
*/ */
if ((src_off == 0) && (dest_off == 0) && (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; 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, mem_ctx,
ev, ev,
src_fsp, 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); 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; 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( struct tevent_req *req = tevent_req_callback_data(
subreq, struct tevent_req); subreq, struct tevent_req);
struct fruit_copy_chunk_state *state = tevent_req_data( struct fruit_offload_write_state *state = tevent_req_data(
req, struct fruit_copy_chunk_state); req, struct fruit_offload_write_state);
NTSTATUS status; NTSTATUS status;
unsigned int num_streams = 0; unsigned int num_streams = 0;
struct stream_struct *streams = NULL; 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 *src_fname_tmp = NULL;
struct smb_filename *dst_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, subreq,
&state->copied); &state->copied);
TALLOC_FREE(subreq); TALLOC_FREE(subreq);
@ -5651,12 +5651,12 @@ static void fruit_copy_chunk_done(struct tevent_req *subreq)
tevent_req_done(req); 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, struct tevent_req *req,
off_t *copied) off_t *copied)
{ {
struct fruit_copy_chunk_state *fruit_copy_chunk_state = tevent_req_data( struct fruit_offload_write_state *state = tevent_req_data(
req, struct fruit_copy_chunk_state); req, struct fruit_offload_write_state);
NTSTATUS status; NTSTATUS status;
if (tevent_req_is_nterror(req, &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; return status;
} }
*copied = fruit_copy_chunk_state->copied; *copied = state->copied;
tevent_req_received(req); tevent_req_received(req);
return NT_STATUS_OK; return NT_STATUS_OK;
@ -5700,8 +5700,8 @@ static struct vfs_fn_pointers vfs_fruit_fns = {
.readdir_attr_fn = fruit_readdir_attr, .readdir_attr_fn = fruit_readdir_attr,
.offload_read_send_fn = fruit_offload_read_send, .offload_read_send_fn = fruit_offload_read_send,
.offload_read_recv_fn = fruit_offload_read_recv, .offload_read_recv_fn = fruit_offload_read_recv,
.copy_chunk_send_fn = fruit_copy_chunk_send, .offload_write_send_fn = fruit_offload_write_send,
.copy_chunk_recv_fn = fruit_copy_chunk_recv, .offload_write_recv_fn = fruit_offload_write_recv,
/* NT ACL operations */ /* NT ACL operations */
.fget_nt_acl_fn = fruit_fget_nt_acl, .fget_nt_acl_fn = fruit_fget_nt_acl,

24
source3/modules/vfs_full_audit.c
View File

@ -170,8 +170,8 @@ typedef enum _vfs_op_type {
SMB_VFS_OP_FSCTL, SMB_VFS_OP_FSCTL,
SMB_VFS_OP_OFFLOAD_READ_SEND, SMB_VFS_OP_OFFLOAD_READ_SEND,
SMB_VFS_OP_OFFLOAD_READ_RECV, SMB_VFS_OP_OFFLOAD_READ_RECV,
SMB_VFS_OP_COPY_CHUNK_SEND, SMB_VFS_OP_OFFLOAD_WRITE_SEND,
SMB_VFS_OP_COPY_CHUNK_RECV, SMB_VFS_OP_OFFLOAD_WRITE_RECV,
SMB_VFS_OP_GET_COMPRESSION, SMB_VFS_OP_GET_COMPRESSION,
SMB_VFS_OP_SET_COMPRESSION, SMB_VFS_OP_SET_COMPRESSION,
SMB_VFS_OP_SNAP_CHECK_PATH, SMB_VFS_OP_SNAP_CHECK_PATH,
@ -314,8 +314,8 @@ static struct {
{ SMB_VFS_OP_FSCTL, "fsctl" }, { SMB_VFS_OP_FSCTL, "fsctl" },
{ SMB_VFS_OP_OFFLOAD_READ_SEND, "offload_read_send" }, { SMB_VFS_OP_OFFLOAD_READ_SEND, "offload_read_send" },
{ SMB_VFS_OP_OFFLOAD_READ_RECV, "offload_read_recv" }, { SMB_VFS_OP_OFFLOAD_READ_RECV, "offload_read_recv" },
{ SMB_VFS_OP_COPY_CHUNK_SEND, "copy_chunk_send" }, { SMB_VFS_OP_OFFLOAD_WRITE_SEND, "offload_write_send" },
{ SMB_VFS_OP_COPY_CHUNK_RECV, "copy_chunk_recv" }, { SMB_VFS_OP_OFFLOAD_WRITE_RECV, "offload_write_recv" },
{ SMB_VFS_OP_GET_COMPRESSION, "get_compression" }, { SMB_VFS_OP_GET_COMPRESSION, "get_compression" },
{ SMB_VFS_OP_SET_COMPRESSION, "set_compression" }, { SMB_VFS_OP_SET_COMPRESSION, "set_compression" },
{ SMB_VFS_OP_SNAP_CHECK_PATH, "snap_check_path" }, { SMB_VFS_OP_SNAP_CHECK_PATH, "snap_check_path" },
@ -1941,7 +1941,7 @@ static NTSTATUS smb_full_audit_offload_read_recv(
return status; 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, TALLOC_CTX *mem_ctx,
struct tevent_context *ev, struct tevent_context *ev,
struct files_struct *src_fsp, 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; 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, src_off, dest_fsp, dest_off, num,
flags); flags);
do_log(SMB_VFS_OP_COPY_CHUNK_SEND, req, handle, ""); do_log(SMB_VFS_OP_OFFLOAD_WRITE_SEND, req, handle, "");
return req; 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, struct tevent_req *req,
off_t *copied) off_t *copied)
{ {
NTSTATUS result; 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; 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, .file_id_create_fn = smb_full_audit_file_id_create,
.offload_read_send_fn = smb_full_audit_offload_read_send, .offload_read_send_fn = smb_full_audit_offload_read_send,
.offload_read_recv_fn = smb_full_audit_offload_read_recv, .offload_read_recv_fn = smb_full_audit_offload_read_recv,
.copy_chunk_send_fn = smb_full_audit_copy_chunk_send, .offload_write_send_fn = smb_full_audit_offload_write_send,
.copy_chunk_recv_fn = smb_full_audit_copy_chunk_recv, .offload_write_recv_fn = smb_full_audit_offload_write_recv,
.get_compression_fn = smb_full_audit_get_compression, .get_compression_fn = smb_full_audit_get_compression,
.set_compression_fn = smb_full_audit_set_compression, .set_compression_fn = smb_full_audit_set_compression,
.snap_check_path_fn = smb_full_audit_snap_check_path, .snap_check_path_fn = smb_full_audit_snap_check_path,

2
source3/modules/vfs_glusterfs.c
View File

@ -1473,8 +1473,6 @@ static struct vfs_fn_pointers glusterfs_fns = {
.realpath_fn = vfs_gluster_realpath, .realpath_fn = vfs_gluster_realpath,
.chflags_fn = vfs_gluster_chflags, .chflags_fn = vfs_gluster_chflags,
.file_id_create_fn = NULL, .file_id_create_fn = NULL,
.copy_chunk_send_fn = NULL,
.copy_chunk_recv_fn = NULL,
.streaminfo_fn = NULL, .streaminfo_fn = NULL,
.get_real_filename_fn = vfs_gluster_get_real_filename, .get_real_filename_fn = vfs_gluster_get_real_filename,
.connectpath_fn = vfs_gluster_connectpath, .connectpath_fn = vfs_gluster_connectpath,

45
source3/modules/vfs_time_audit.c
View File

@ -1995,14 +1995,14 @@ static NTSTATUS smb_time_audit_offload_read_recv(
return NT_STATUS_OK; return NT_STATUS_OK;
} }
struct time_audit_cc_state { struct time_audit_offload_write_state {
struct timespec ts_send; struct timespec ts_send;
struct vfs_handle_struct *handle; struct vfs_handle_struct *handle;
off_t copied; 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, TALLOC_CTX *mem_ctx,
struct tevent_context *ev, struct tevent_context *ev,
struct files_struct *src_fsp, 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 *req;
struct tevent_req *subreq; 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) { if (req == NULL) {
return NULL; return NULL;
} }
cc_state->handle = handle; state->handle = handle;
clock_gettime_mono(&cc_state->ts_send); clock_gettime_mono(&state->ts_send);
subreq = SMB_VFS_NEXT_COPY_CHUNK_SEND(handle, cc_state, ev, subreq = SMB_VFS_NEXT_OFFLOAD_WRITE_SEND(handle, state, ev,
src_fsp, src_off, src_fsp, src_off,
dest_fsp, dest_off, num, flags); dest_fsp, dest_off, num, flags);
if (tevent_req_nomem(subreq, req)) { if (tevent_req_nomem(subreq, req)) {
return tevent_req_post(req, ev); 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; 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( struct tevent_req *req = tevent_req_callback_data(
subreq, struct tevent_req); subreq, struct tevent_req);
struct time_audit_cc_state *cc_state struct time_audit_offload_write_state *state = tevent_req_data(
= tevent_req_data(req, struct time_audit_cc_state); req, struct time_audit_offload_write_state);
NTSTATUS status; NTSTATUS status;
status = SMB_VFS_NEXT_COPY_CHUNK_RECV(cc_state->handle, status = SMB_VFS_NEXT_OFFLOAD_WRITE_RECV(state->handle,
subreq, subreq,
&cc_state->copied); &state->copied);
TALLOC_FREE(subreq); TALLOC_FREE(subreq);
if (tevent_req_nterror(req, status)) { if (tevent_req_nterror(req, status)) {
return; return;
@ -2052,23 +2053,23 @@ static void smb_time_audit_copy_chunk_done(struct tevent_req *subreq)
tevent_req_done(req); 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, struct tevent_req *req,
off_t *copied) off_t *copied)
{ {
struct time_audit_cc_state *cc_state struct time_audit_offload_write_state *state = tevent_req_data(
= tevent_req_data(req, struct time_audit_cc_state); req, struct time_audit_offload_write_state);
struct timespec ts_recv; struct timespec ts_recv;
double timediff; double timediff;
NTSTATUS status; NTSTATUS status;
clock_gettime_mono(&ts_recv); 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) { 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)) { if (tevent_req_is_nterror(req, &status)) {
tevent_req_received(req); tevent_req_received(req);
return status; 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, .file_id_create_fn = smb_time_audit_file_id_create,
.offload_read_send_fn = smb_time_audit_offload_read_send, .offload_read_send_fn = smb_time_audit_offload_read_send,
.offload_read_recv_fn = smb_time_audit_offload_read_recv, .offload_read_recv_fn = smb_time_audit_offload_read_recv,
.copy_chunk_send_fn = smb_time_audit_copy_chunk_send, .offload_write_send_fn = smb_time_audit_offload_write_send,
.copy_chunk_recv_fn = smb_time_audit_copy_chunk_recv, .offload_write_recv_fn = smb_time_audit_offload_write_recv,
.get_compression_fn = smb_time_audit_get_compression, .get_compression_fn = smb_time_audit_get_compression,
.set_compression_fn = smb_time_audit_set_compression, .set_compression_fn = smb_time_audit_set_compression,
.snap_check_path_fn = smb_time_audit_snap_check_path, .snap_check_path_fn = smb_time_audit_snap_check_path,

22
source3/smbd/smb2_ioctl_filesys.c
View File

@ -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 */ /* tell the VFS to ignore locks across the clone, matching ReFS */
subreq = SMB_VFS_COPY_CHUNK_SEND(state->dst_fsp->conn, subreq = SMB_VFS_OFFLOAD_WRITE_SEND(state->dst_fsp->conn,
state, state,
state->ev, state->ev,
state->src_fsp, state->src_fsp,
state->dup_extents.source_off, state->dup_extents.source_off,
state->dst_fsp, state->dst_fsp,
state->dup_extents.target_off, state->dup_extents.target_off,
state->dup_extents.byte_count, state->dup_extents.byte_count,
VFS_COPY_CHUNK_FL_MUST_CLONE VFS_OFFLOAD_WRITE_FL_MUST_CLONE
| VFS_COPY_CHUNK_FL_IGNORE_LOCKS); | VFS_OFFLOAD_WRITE_FL_IGNORE_LOCKS);
if (tevent_req_nomem(subreq, req)) { if (tevent_req_nomem(subreq, req)) {
return; return;
} }
@ -315,7 +315,7 @@ static void fsctl_dup_extents_vfs_done(struct tevent_req *subreq)
off_t nb_chunk; off_t nb_chunk;
NTSTATUS status; 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); TALLOC_FREE(subreq);
if (tevent_req_nterror(req, status)) { if (tevent_req_nterror(req, status)) {
return; return;

6
source3/smbd/smb2_ioctl_network_fs.c
View File

@ -340,7 +340,7 @@ static NTSTATUS fsctl_srv_copychunk_loop(struct tevent_req *req)
} }
state->aapl_copyfile = true; 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,
state->ev, state->ev,
state->src_fsp, 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]; chunk = &state->cc_copy.chunks[state->current_chunk];
length = next_merged_io(state); 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,
state->ev, state->ev,
state->src_fsp, state->src_fsp,
@ -386,7 +386,7 @@ static void fsctl_srv_copychunk_vfs_done(struct tevent_req *subreq)
off_t chunk_nwritten; off_t chunk_nwritten;
NTSTATUS status; NTSTATUS status;
status = SMB_VFS_COPY_CHUNK_RECV(state->conn, subreq, status = SMB_VFS_OFFLOAD_WRITE_RECV(state->conn, subreq,
&chunk_nwritten); &chunk_nwritten);
TALLOC_FREE(subreq); TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) { if (!NT_STATUS_IS_OK(status)) {

32
source3/smbd/vfs.c
View File

@ -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); 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, struct tevent_req *smb_vfs_call_offload_write_send(struct vfs_handle_struct *handle,
TALLOC_CTX *mem_ctx, TALLOC_CTX *mem_ctx,
struct tevent_context *ev, struct tevent_context *ev,
struct files_struct *src_fsp, struct files_struct *src_fsp,
off_t src_off, off_t src_off,
struct files_struct *dest_fsp, struct files_struct *dest_fsp,
off_t dest_off, off_t dest_off,
off_t num, off_t num,
uint32_t flags) uint32_t flags)
{ {
VFS_FIND(copy_chunk_send); VFS_FIND(offload_write_send);
return handle->fns->copy_chunk_send_fn(handle, mem_ctx, ev, src_fsp, return handle->fns->offload_write_send_fn(handle, mem_ctx, ev, src_fsp,
src_off, dest_fsp, dest_off, num, src_off, dest_fsp, dest_off, num,
flags); flags);
} }
NTSTATUS smb_vfs_call_copy_chunk_recv(struct vfs_handle_struct *handle, NTSTATUS smb_vfs_call_offload_write_recv(struct vfs_handle_struct *handle,
struct tevent_req *req, struct tevent_req *req,
off_t *copied) off_t *copied)
{ {
VFS_FIND(copy_chunk_recv); VFS_FIND(offload_write_recv);
return handle->fns->copy_chunk_recv_fn(handle, req, copied); return handle->fns->offload_write_recv_fn(handle, req, copied);
} }
NTSTATUS smb_vfs_call_get_compression(vfs_handle_struct *handle, NTSTATUS smb_vfs_call_get_compression(vfs_handle_struct *handle,