off_t transfer_offset,
struct files_struct *dest_fsp,
off_t dest_off,
- off_t num,
- uint32_t flags)
+ off_t num)
{
struct tevent_req *req;
struct skel_cc_state *cc_state;
off_t transfer_offset,
struct files_struct *dest_fsp,
off_t dest_off,
- off_t num,
- uint32_t flags)
+ off_t num)
{
struct tevent_req *req;
struct tevent_req *subreq;
state->handle = handle;
subreq = SMB_VFS_NEXT_OFFLOAD_WRITE_SEND(handle, state, ev,
fsctl, token, transfer_offset,
- dest_fsp, dest_off, num, flags);
+ dest_fsp, dest_off, num);
if (tevent_req_nomem(subreq, req)) {
return tevent_req_post(req, ev);
}
VFS_FALLOCATE_FL_PUNCH_HOLE = 0x0002,
};
-/*
- * @VFS_OFFLOAD_WRITE_FL_MUST_CLONE: indicates that offload_write_send_fn() copy must
- * be handled as a COW clone, AKA reflink.
- * @VFS_OFFLOAD_WRITE_FL_MASK_ALL: all valid flags.
- */
-enum vfs_offload_write_flags {
- VFS_OFFLOAD_WRITE_FL_MUST_CLONE = 0x0001,
- VFS_OFFLOAD_WRITE_FL_IGNORE_LOCKS = 0x0002,
-
- VFS_OFFLOAD_WRITE_FL_MASK_ALL =
- (VFS_OFFLOAD_WRITE_FL_MUST_CLONE
- | VFS_OFFLOAD_WRITE_FL_IGNORE_LOCKS),
-};
-
struct vfs_aio_state {
int error;
uint64_t duration;
off_t transfer_offset,
struct files_struct *dest_fsp,
off_t dest_off,
- off_t to_copy,
- uint32_t flags);
+ off_t to_copy);
NTSTATUS (*offload_write_recv_fn)(struct vfs_handle_struct *handle,
struct tevent_req *req,
off_t *copied);
off_t transfer_offset,
struct files_struct *dest_fsp,
off_t dest_off,
- off_t num,
- uint32_t flags);
+ off_t num);
NTSTATUS smb_vfs_call_offload_write_recv(struct vfs_handle_struct *handle,
struct tevent_req *req,
off_t *copied);
#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_OFFLOAD_WRITE_SEND(conn, mem_ctx, ev, fsctl, token, transfer_offset, dest_fsp, dest_off, num, flags) \
- smb_vfs_call_offload_write_send((conn)->vfs_handles, (mem_ctx), (ev), (fsctl), (token), (transfer_offset), (dest_fsp), (dest_off), (num), (flags))
-#define SMB_VFS_NEXT_OFFLOAD_WRITE_SEND(handle, mem_ctx, ev, fsctl, token, transfer_offset, dest_fsp, dest_off, num, flags) \
- smb_vfs_call_offload_write_send((handle)->next, (mem_ctx), (ev), (fsctl), (token), (transfer_offset), (dest_fsp), (dest_off), (num), (flags))
+#define SMB_VFS_OFFLOAD_WRITE_SEND(conn, mem_ctx, ev, fsctl, token, transfer_offset, dest_fsp, dest_off, num) \
+ smb_vfs_call_offload_write_send((conn)->vfs_handles, (mem_ctx), (ev), (fsctl), (token), (transfer_offset), (dest_fsp), (dest_off), (num))
+#define SMB_VFS_NEXT_OFFLOAD_WRITE_SEND(handle, mem_ctx, ev, fsctl, token, transfer_offset, dest_fsp, dest_off, num) \
+ smb_vfs_call_offload_write_send((handle)->next, (mem_ctx), (ev), (fsctl), (token), (transfer_offset), (dest_fsp), (dest_off), (num))
#define SMB_VFS_OFFLOAD_WRITE_RECV(conn, req, copied) \
smb_vfs_call_offload_write_recv((conn)->vfs_handles, (req), (copied))
off_t transfer_offset,
struct files_struct *dest_fsp,
off_t dest_off,
- off_t num,
- uint32_t flags)
+ off_t num)
{
struct tevent_req *req;
struct btrfs_cc_state *cc_state;
files_struct *src_fsp = NULL;
int ret;
bool handle_offload_write = true;
+ bool do_locking = false;
NTSTATUS status;
req = tevent_req_create(mem_ctx, &cc_state, struct btrfs_cc_state);
return NULL;
}
- if (flags & ~VFS_OFFLOAD_WRITE_FL_MASK_ALL) {
- tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
- return tevent_req_post(req, ev);
- }
-
cc_state->handle = handle;
status = vfs_offload_token_db_fetch_fsp(btrfs_offload_ctx,
switch (fsctl) {
case FSCTL_SRV_COPYCHUNK:
case FSCTL_SRV_COPYCHUNK_WRITE:
+ do_locking = true;
+ break;
+
case FSCTL_DUP_EXTENTS_TO_FILE:
+ /* dup extents does not use locking */
break;
default:
transfer_offset,
dest_fsp,
dest_off,
- num, flags);
+ num);
if (tevent_req_nomem(cc_state->subreq, req)) {
return tevent_req_post(req, ev);
}
return tevent_req_post(req, ev);
}
- if (!(flags & VFS_OFFLOAD_WRITE_FL_IGNORE_LOCKS)) {
+ if (do_locking) {
init_strict_lock_struct(src_fsp,
src_fsp->op->global->open_persistent_id,
src_off,
cr_args.src_length = (uint64_t)num;
ret = ioctl(dest_fsp->fh->fd, BTRFS_IOC_CLONE_RANGE, &cr_args);
- if (!(flags & VFS_OFFLOAD_WRITE_FL_IGNORE_LOCKS)) {
+ if (do_locking) {
SMB_VFS_STRICT_UNLOCK(dest_fsp->conn, dest_fsp, &dest_lck);
SMB_VFS_STRICT_UNLOCK(src_fsp->conn, src_fsp, &src_lck);
}
transfer_offset,
dest_fsp,
dest_off,
- num, flags);
+ num);
if (tevent_req_nomem(cc_state->subreq, req)) {
return tevent_req_post(req, ev);
}
off_t to_copy;
off_t remaining;
size_t next_io_size;
- uint32_t flags;
};
static NTSTATUS vfswrap_offload_write_loop(struct tevent_req *req);
off_t transfer_offset,
struct files_struct *dest_fsp,
off_t dest_off,
- off_t to_copy,
- uint32_t flags)
+ off_t to_copy)
{
struct tevent_req *req;
struct vfswrap_offload_write_state *state = NULL;
return NULL;
}
- 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_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 vfswrap_offload_write_state) {
.ev = ev,
.token = token,
.dst_off = dest_off,
.to_copy = to_copy,
.remaining = to_copy,
- .flags = flags,
};
switch (fsctl) {
tevent_req_nterror(req, NT_STATUS_NOT_IMPLEMENTED);
return tevent_req_post(req, ev);
+ case FSCTL_DUP_EXTENTS_TO_FILE:
+ DBG_DEBUG("COW clones not supported by vfs_default\n");
+ tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
+ return tevent_req_post(req, ev);
+
default:
tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
return tevent_req_post(req, ev);
state->next_io_size = MIN(state->remaining, talloc_array_length(state->buf));
- 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_off,
- state->next_io_size,
- READ_LOCK,
- &state->read_lck);
-
- ok = SMB_VFS_STRICT_LOCK(state->src_fsp->conn,
- state->src_fsp,
- &state->read_lck);
- if (!ok) {
- return NT_STATUS_FILE_LOCK_CONFLICT;
- }
+ state->src_off,
+ state->next_io_size,
+ READ_LOCK,
+ &state->read_lck);
+
+ ok = SMB_VFS_STRICT_LOCK(state->src_fsp->conn,
+ state->src_fsp,
+ &state->read_lck);
+ if (!ok) {
+ return NT_STATUS_FILE_LOCK_CONFLICT;
}
subreq = SMB_VFS_PREAD_SEND(state,
ssize_t nread;
bool ok;
- if (!(state->flags & VFS_OFFLOAD_WRITE_FL_IGNORE_LOCKS)) {
- SMB_VFS_STRICT_UNLOCK(state->src_fsp->conn,
- state->src_fsp,
- &state->read_lck);
- ZERO_STRUCT(state->read_lck);
- }
+ SMB_VFS_STRICT_UNLOCK(state->src_fsp->conn,
+ state->src_fsp,
+ &state->read_lck);
+ ZERO_STRUCT(state->read_lck);
nread = SMB_VFS_PREAD_RECV(subreq, &aio_state);
TALLOC_FREE(subreq);
state->src_off += nread;
- 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_off,
- state->next_io_size,
- WRITE_LOCK,
- &state->write_lck);
-
- ok = SMB_VFS_STRICT_LOCK(state->dst_fsp->conn,
- state->dst_fsp,
- &state->write_lck);
- if (!ok) {
- tevent_req_nterror(req, NT_STATUS_FILE_LOCK_CONFLICT);
- return;
- }
+ state->dst_off,
+ state->next_io_size,
+ WRITE_LOCK,
+ &state->write_lck);
+
+ ok = SMB_VFS_STRICT_LOCK(state->dst_fsp->conn,
+ state->dst_fsp,
+ &state->write_lck);
+ if (!ok) {
+ tevent_req_nterror(req, NT_STATUS_FILE_LOCK_CONFLICT);
+ return;
}
subreq = SMB_VFS_PWRITE_SEND(state,
ssize_t nwritten;
NTSTATUS status;
- if (!(state->flags & VFS_OFFLOAD_WRITE_FL_IGNORE_LOCKS)) {
- SMB_VFS_STRICT_UNLOCK(state->dst_fsp->conn,
- state->dst_fsp,
- &state->write_lck);
- ZERO_STRUCT(state->write_lck);
- }
+ SMB_VFS_STRICT_UNLOCK(state->dst_fsp->conn,
+ state->dst_fsp,
+ &state->write_lck);
+ ZERO_STRUCT(state->write_lck);
nwritten = SMB_VFS_PWRITE_RECV(subreq, &aio_state);
TALLOC_FREE(subreq);
off_t transfer_offset,
struct files_struct *dest_fsp,
off_t dest_off,
- off_t num,
- uint32_t flags)
+ off_t num)
{
struct tevent_req *req, *subreq;
struct fruit_offload_write_state *state;
transfer_offset,
dest_fsp,
dest_off,
- to_copy,
- flags);
+ to_copy);
if (tevent_req_nomem(subreq, req)) {
return tevent_req_post(req, ev);
}
off_t transfer_offset,
struct files_struct *dest_fsp,
off_t dest_off,
- off_t num,
- uint32_t flags)
+ off_t num)
{
struct tevent_req *req;
req = SMB_VFS_NEXT_OFFLOAD_WRITE_SEND(handle, mem_ctx, ev,
fsctl, token, transfer_offset,
- dest_fsp, dest_off, num,
- flags);
+ dest_fsp, dest_off, num);
do_log(SMB_VFS_OP_OFFLOAD_WRITE_SEND, req, handle, "");
off_t transfer_offset,
struct files_struct *dest_fsp,
off_t dest_off,
- off_t num,
- uint32_t flags)
+ off_t num)
{
struct tevent_req *req;
struct tevent_req *subreq;
clock_gettime_mono(&state->ts_send);
subreq = SMB_VFS_NEXT_OFFLOAD_WRITE_SEND(handle, state, ev,
fsctl, token, transfer_offset,
- dest_fsp, dest_off, num, flags);
+ dest_fsp, dest_off, num);
if (tevent_req_nomem(subreq, req)) {
return tevent_req_post(req, ev);
}
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);
+ state->dup_extents.byte_count);
if (tevent_req_nomem(subreq, req)) {
return;
}
source_off,
state->dst_fsp,
target_off,
- length,
- 0);
+ length);
if (tevent_req_nomem(subreq, req)) {
return NT_STATUS_NO_MEMORY;
}
off_t transfer_offset,
struct files_struct *dest_fsp,
off_t dest_off,
- off_t num,
- uint32_t flags)
+ off_t num)
{
VFS_FIND(offload_write_send);
return handle->fns->offload_write_send_fn(handle, mem_ctx, ev, fsctl,
token, transfer_offset,
- dest_fsp, dest_off, num,
- flags);
+ dest_fsp, dest_off, num);
}
NTSTATUS smb_vfs_call_offload_write_recv(struct vfs_handle_struct *handle,