/*
   Unix SMB/CIFS implementation.
   Wrap disk only vfs functions to sidestep dodgy compilers.
   Copyright (C) Tim Potter 1998
   Copyright (C) Jeremy Allison 2007

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "includes.h"
#include "system/time.h"
#include "system/filesys.h"
#include "smbd/smbd.h"
#include "smbd/globals.h"
#include "ntioctl.h"
#include "smbprofile.h"
#include "../libcli/security/security.h"
#include "passdb/lookup_sid.h"
#include "source3/include/msdfs.h"
#include "librpc/gen_ndr/ndr_dfsblobs.h"
#include "lib/util/tevent_unix.h"
#include "lib/util/tevent_ntstatus.h"
#include "lib/util/sys_rw.h"
#include "lib/pthreadpool/pthreadpool_tevent.h"
#include "librpc/gen_ndr/ndr_ioctl.h"
#include "offload_token.h"
#include "util_reparse.h"
#include "lib/util/string_wrappers.h"

#undef DBGC_CLASS
#define DBGC_CLASS DBGC_VFS

/* Check for NULL pointer parameters in vfswrap_* functions */

/* We don't want to have NULL function pointers lying around.  Someone
   is sure to try and execute them.  These stubs are used to prevent
   this possibility. */

static int vfswrap_connect(vfs_handle_struct *handle, const char *service, const char *user)
{
	bool bval;

	handle->conn->have_proc_fds = sys_have_proc_fds();
#ifdef DISABLE_PROC_FDS
	handle->conn->have_proc_fds = false;
#endif

	/*
	 * assume the kernel will support openat2(),
	 * it will be reset on the first ENOSYS.
	 *
	 * Note that libreplace will always provide openat2(),
	 * but return -1/errno = ENOSYS...
	 *
	 * The option is only there to test the fallback code.
	 */
	bval = lp_parm_bool(SNUM(handle->conn),
			    "vfs_default",
			    "VFS_OPEN_HOW_RESOLVE_NO_SYMLINKS",
			    true);
	if (bval) {
		handle->conn->open_how_resolve |=
			VFS_OPEN_HOW_RESOLVE_NO_SYMLINKS;
	}
#ifdef DISABLE_VFS_OPEN_HOW_RESOLVE_NO_SYMLINKS
	handle->conn->open_how_resolve &= ~VFS_OPEN_HOW_RESOLVE_NO_SYMLINKS;
#endif

	return 0;    /* Return >= 0 for success */
}

static void vfswrap_disconnect(vfs_handle_struct *handle)
{
}

/* Disk operations */

static uint64_t vfswrap_disk_free(vfs_handle_struct *handle,
				const struct smb_filename *smb_fname,
				uint64_t *bsize,
				uint64_t *dfree,
				uint64_t *dsize)
{
	if (sys_fsusage(smb_fname->base_name, dfree, dsize) != 0) {
		return (uint64_t)-1;
	}

	*bsize = 512;
	return *dfree / 2;
}

static int vfswrap_get_quota(struct vfs_handle_struct *handle,
				const struct smb_filename *smb_fname,
				enum SMB_QUOTA_TYPE qtype,
				unid_t id,
				SMB_DISK_QUOTA *qt)
{
#ifdef HAVE_SYS_QUOTAS
	int result;

	START_PROFILE(syscall_get_quota);
	result = sys_get_quota(smb_fname->base_name, qtype, id, qt);
	END_PROFILE(syscall_get_quota);
	return result;
#else
	errno = ENOSYS;
	return -1;
#endif
}

static int vfswrap_set_quota(struct vfs_handle_struct *handle, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *qt)
{
#ifdef HAVE_SYS_QUOTAS
	int result;

	START_PROFILE(syscall_set_quota);
	result = sys_set_quota(handle->conn->connectpath, qtype, id, qt);
	END_PROFILE(syscall_set_quota);
	return result;
#else
	errno = ENOSYS;
	return -1;
#endif
}

static int vfswrap_get_shadow_copy_data(struct vfs_handle_struct *handle,
					struct files_struct *fsp,
					struct shadow_copy_data *shadow_copy_data,
					bool labels)
{
	errno = ENOSYS;
	return -1;  /* Not implemented. */
}

static int vfswrap_statvfs(struct vfs_handle_struct *handle,
			   const struct smb_filename *smb_fname,
			   struct vfs_statvfs_struct *statbuf)
{
	return sys_statvfs(smb_fname->base_name, statbuf);
}

static uint32_t vfswrap_fs_capabilities(struct vfs_handle_struct *handle,
		enum timestamp_set_resolution *p_ts_res)
{
	const struct loadparm_substitution *lp_sub =
		loadparm_s3_global_substitution();
	connection_struct *conn = handle->conn;
	uint32_t caps = FILE_CASE_SENSITIVE_SEARCH | FILE_CASE_PRESERVED_NAMES;
	struct smb_filename *smb_fname_cpath = NULL;
	struct vfs_statvfs_struct statbuf;
	int ret;

	smb_fname_cpath = synthetic_smb_fname(talloc_tos(),
					      conn->connectpath,
					      NULL,
					      NULL,
					      0,
					      0);
	if (smb_fname_cpath == NULL) {
		return caps;
	}

	ZERO_STRUCT(statbuf);
	ret = SMB_VFS_STATVFS(conn, smb_fname_cpath, &statbuf);
	if (ret == 0) {
		caps = statbuf.FsCapabilities;
	}

	*p_ts_res = TIMESTAMP_SET_SECONDS;

	/* Work out what timestamp resolution we can
	 * use when setting a timestamp. */

	ret = SMB_VFS_STAT(conn, smb_fname_cpath);
	if (ret == -1) {
		TALLOC_FREE(smb_fname_cpath);
		return caps;
	}

	if (smb_fname_cpath->st.st_ex_mtime.tv_nsec ||
			smb_fname_cpath->st.st_ex_atime.tv_nsec ||
			smb_fname_cpath->st.st_ex_ctime.tv_nsec) {
		/* If any of the normal UNIX directory timestamps
		 * have a non-zero tv_nsec component assume
		 * we might be able to set sub-second timestamps.
		 * See what filetime set primitives we have.
		 */
#if defined(HAVE_UTIMENSAT)
		*p_ts_res = TIMESTAMP_SET_NT_OR_BETTER;
#elif defined(HAVE_UTIMES)
		/* utimes allows msec timestamps to be set. */
		*p_ts_res = TIMESTAMP_SET_MSEC;
#elif defined(HAVE_UTIME)
		/* utime only allows sec timestamps to be set. */
		*p_ts_res = TIMESTAMP_SET_SECONDS;
#endif

		DBG_DEBUG("vfswrap_fs_capabilities: timestamp "
			"resolution of %s "
			"available on share %s, directory %s\n",
			*p_ts_res == TIMESTAMP_SET_MSEC ? "msec" : "sec",
			lp_servicename(talloc_tos(), lp_sub, conn->params->service),
			conn->connectpath );
	}
	TALLOC_FREE(smb_fname_cpath);
	return caps;
}

static NTSTATUS vfswrap_get_dfs_referrals(struct vfs_handle_struct *handle,
					  struct dfs_GetDFSReferral *r)
{
	struct junction_map *junction = NULL;
	size_t consumedcnt = 0;
	bool self_referral = false;
	char *pathnamep = NULL;
	char *local_dfs_path = NULL;
	NTSTATUS status;
	size_t i;
	uint16_t max_referral_level = r->in.req.max_referral_level;

	if (DEBUGLVL(DBGLVL_DEBUG)) {
		NDR_PRINT_IN_DEBUG(dfs_GetDFSReferral, r);
	}

	/* get the junction entry */
	if (r->in.req.servername == NULL) {
		return NT_STATUS_NOT_FOUND;
	}

	/*
	 * Trim pathname sent by client so it begins with only one backslash.
	 * Two backslashes confuse some dfs clients
	 */

	local_dfs_path = talloc_strdup(r, r->in.req.servername);
	if (local_dfs_path == NULL) {
		return NT_STATUS_NO_MEMORY;
	}
	pathnamep = local_dfs_path;
	while (IS_DIRECTORY_SEP(pathnamep[0]) &&
	       IS_DIRECTORY_SEP(pathnamep[1])) {
		pathnamep++;
	}

	junction = talloc_zero(r, struct junction_map);
	if (junction == NULL) {
		return NT_STATUS_NO_MEMORY;
	}

	/* The following call can change cwd. */
	status = get_referred_path(r,
				   handle->conn->session_info,
				   pathnamep,
				   handle->conn->sconn->remote_address,
				   handle->conn->sconn->local_address,
				   junction, &consumedcnt, &self_referral);
	if (!NT_STATUS_IS_OK(status)) {
		struct smb_filename connectpath_fname = {
			.base_name = handle->conn->connectpath
		};
		vfs_ChDir(handle->conn, &connectpath_fname);
		return status;
	}
	{
		struct smb_filename connectpath_fname = {
			.base_name = handle->conn->connectpath
		};
		vfs_ChDir(handle->conn, &connectpath_fname);
	}

	if (!self_referral) {
		pathnamep[consumedcnt] = '\0';

		if (DEBUGLVL(DBGLVL_INFO)) {
			dbgtext("Path %s to alternate path(s):",
				pathnamep);
			for (i=0; i < junction->referral_count; i++) {
				dbgtext(" %s",
				junction->referral_list[i].alternate_path);
			}
			dbgtext(".\n");
		}
	}

	if (r->in.req.max_referral_level <= 2) {
		max_referral_level = 2;
	}
	if (r->in.req.max_referral_level >= 3) {
		max_referral_level = 3;
	}

	r->out.resp = talloc_zero(r, struct dfs_referral_resp);
	if (r->out.resp == NULL) {
		return NT_STATUS_NO_MEMORY;
	}

	r->out.resp->path_consumed = strlen_m(pathnamep) * 2;
	r->out.resp->nb_referrals = junction->referral_count;

	r->out.resp->header_flags = DFS_HEADER_FLAG_STORAGE_SVR;
	if (self_referral) {
		r->out.resp->header_flags |= DFS_HEADER_FLAG_REFERAL_SVR;
	}

	r->out.resp->referral_entries = talloc_zero_array(r,
				struct dfs_referral_type,
				r->out.resp->nb_referrals);
	if (r->out.resp->referral_entries == NULL) {
		return NT_STATUS_NO_MEMORY;
	}

	switch (max_referral_level) {
	case 2:
		for(i=0; i < junction->referral_count; i++) {
			struct referral *ref = &junction->referral_list[i];
			TALLOC_CTX *mem_ctx = r->out.resp->referral_entries;
			struct dfs_referral_type *t =
				&r->out.resp->referral_entries[i];
			struct dfs_referral_v2 *v2 = &t->referral.v2;

			t->version = 2;
			v2->size = VERSION2_REFERRAL_SIZE;
			if (self_referral) {
				v2->server_type = DFS_SERVER_ROOT;
			} else {
				v2->server_type = DFS_SERVER_NON_ROOT;
			}
			v2->entry_flags = 0;
			v2->proximity = ref->proximity;
			v2->ttl = ref->ttl;
			v2->DFS_path = talloc_strdup(mem_ctx, pathnamep);
			if (v2->DFS_path == NULL) {
				return NT_STATUS_NO_MEMORY;
			}
			v2->DFS_alt_path = talloc_strdup(mem_ctx, pathnamep);
			if (v2->DFS_alt_path == NULL) {
				return NT_STATUS_NO_MEMORY;
			}
			v2->netw_address = talloc_strdup(mem_ctx,
							 ref->alternate_path);
			if (v2->netw_address == NULL) {
				return NT_STATUS_NO_MEMORY;
			}
		}

		break;
	case 3:
		for(i=0; i < junction->referral_count; i++) {
			struct referral *ref = &junction->referral_list[i];
			TALLOC_CTX *mem_ctx = r->out.resp->referral_entries;
			struct dfs_referral_type *t =
				&r->out.resp->referral_entries[i];
			struct dfs_referral_v3 *v3 = &t->referral.v3;
			struct dfs_normal_referral *r1 = &v3->referrals.r1;

			t->version = 3;
			v3->size = VERSION3_REFERRAL_SIZE;
			if (self_referral) {
				v3->server_type = DFS_SERVER_ROOT;
			} else {
				v3->server_type = DFS_SERVER_NON_ROOT;
			}
			v3->entry_flags = 0;
			v3->ttl = ref->ttl;
			r1->DFS_path = talloc_strdup(mem_ctx, pathnamep);
			if (r1->DFS_path == NULL) {
				return NT_STATUS_NO_MEMORY;
			}
			r1->DFS_alt_path = talloc_strdup(mem_ctx, pathnamep);
			if (r1->DFS_alt_path == NULL) {
				return NT_STATUS_NO_MEMORY;
			}
			r1->netw_address = talloc_strdup(mem_ctx,
							 ref->alternate_path);
			if (r1->netw_address == NULL) {
				return NT_STATUS_NO_MEMORY;
			}
		}
		break;
	default:
		DBG_ERR("Invalid dfs referral version: %d\n",
			max_referral_level);
		return NT_STATUS_INVALID_LEVEL;
	}

	if (DEBUGLVL(DBGLVL_DEBUG)) {
		NDR_PRINT_OUT_DEBUG(dfs_GetDFSReferral, r);
	}

	return NT_STATUS_OK;
}

static NTSTATUS vfswrap_create_dfs_pathat(struct vfs_handle_struct *handle,
				struct files_struct *dirfsp,
				const struct smb_filename *smb_fname,
				const struct referral *reflist,
				size_t referral_count)
{
	TALLOC_CTX *frame = talloc_stackframe();
	NTSTATUS status = NT_STATUS_NO_MEMORY;
	int ret;
	char *msdfs_link = NULL;

	/* Form the msdfs_link contents */
	msdfs_link = msdfs_link_string(frame,
					reflist,
					referral_count);
	if (msdfs_link == NULL) {
		goto out;
	}

	ret = symlinkat(msdfs_link,
			fsp_get_pathref_fd(dirfsp),
			smb_fname->base_name);
	if (ret == 0) {
		status = NT_STATUS_OK;
	} else {
		status = map_nt_error_from_unix(errno);
	}

  out:

	TALLOC_FREE(frame);
	return status;
}

/*
 * Read and return the contents of a DFS redirect given a
 * pathname. A caller can pass in NULL for ppreflist and
 * preferral_count but still determine if this was a
 * DFS redirect point by getting NT_STATUS_OK back
 * without incurring the overhead of reading and parsing
 * the referral contents.
 */

static NTSTATUS vfswrap_read_dfs_pathat(struct vfs_handle_struct *handle,
				TALLOC_CTX *mem_ctx,
				struct files_struct *dirfsp,
				struct smb_filename *smb_fname,
				struct referral **ppreflist,
				size_t *preferral_count)
{
	NTSTATUS status = NT_STATUS_NO_MEMORY;
	size_t bufsize;
	char *link_target = NULL;
	int referral_len;
	bool ok;
#if defined(HAVE_BROKEN_READLINK)
	char link_target_buf[PATH_MAX];
#else
	char link_target_buf[7];
#endif
	int ret;

	if (is_named_stream(smb_fname)) {
		status = NT_STATUS_OBJECT_NAME_NOT_FOUND;
		goto err;
	}

	if (ppreflist == NULL && preferral_count == NULL) {
		/*
		 * We're only checking if this is a DFS
		 * redirect. We don't need to return data.
		 */
		bufsize = sizeof(link_target_buf);
		link_target = link_target_buf;
	} else {
		bufsize = PATH_MAX;
		link_target = talloc_array(mem_ctx, char, bufsize);
		if (!link_target) {
			goto err;
		}
	}

	referral_len = readlinkat(fsp_get_pathref_fd(dirfsp),
				smb_fname->base_name,
				link_target,
				bufsize - 1);
	if (referral_len == -1) {
		if (errno == EINVAL) {
			/*
			 * If the path isn't a link, readlinkat
			 * returns EINVAL. Allow the caller to
			 * detect this.
			 */
			DBG_INFO("%s is not a link.\n", smb_fname->base_name);
			status = NT_STATUS_OBJECT_TYPE_MISMATCH;
		} else {
			status = map_nt_error_from_unix(errno);
			if (errno == ENOENT) {
				DBG_NOTICE("Error reading "
					 "msdfs link %s: %s\n",
					 smb_fname->base_name,
					 strerror(errno));
			} else {
				DBG_ERR("Error reading "
					"msdfs link %s: %s\n",
					smb_fname->base_name,
					strerror(errno));
			}
		}
                goto err;
        }
	link_target[referral_len] = '\0';

	DBG_INFO("%s -> %s\n",
			smb_fname->base_name,
			link_target);

	if (!strnequal(link_target, "msdfs:", 6)) {
		status = NT_STATUS_OBJECT_TYPE_MISMATCH;
		goto err;
	}

       ret = sys_fstatat(fsp_get_pathref_fd(dirfsp),
			 smb_fname->base_name,
			 &smb_fname->st,
			 AT_SYMLINK_NOFOLLOW,
			 lp_fake_directory_create_times(SNUM(handle->conn)));
	if (ret < 0) {
		status = map_nt_error_from_unix(errno);
		goto err;
	}

	if (ppreflist == NULL && preferral_count == NULL) {
		/* Early return for checking if this is a DFS link. */
		return NT_STATUS_OK;
	}

	ok = parse_msdfs_symlink(mem_ctx,
			lp_msdfs_shuffle_referrals(SNUM(handle->conn)),
			link_target,
			ppreflist,
			preferral_count);

	if (ok) {
		status = NT_STATUS_OK;
	} else {
		status = NT_STATUS_NO_MEMORY;
	}

  err:

	if (link_target != link_target_buf) {
		TALLOC_FREE(link_target);
	}
	return status;
}

static NTSTATUS vfswrap_snap_check_path(struct vfs_handle_struct *handle,
					TALLOC_CTX *mem_ctx,
					const char *service_path,
					char **base_volume)
{
	return NT_STATUS_NOT_SUPPORTED;
}

static NTSTATUS vfswrap_snap_create(struct vfs_handle_struct *handle,
				    TALLOC_CTX *mem_ctx,
				    const char *base_volume,
				    time_t *tstamp,
				    bool rw,
				    char **base_path,
				    char **snap_path)
{
	return NT_STATUS_NOT_SUPPORTED;
}

static NTSTATUS vfswrap_snap_delete(struct vfs_handle_struct *handle,
				    TALLOC_CTX *mem_ctx,
				    char *base_path,
				    char *snap_path)
{
	return NT_STATUS_NOT_SUPPORTED;
}

/* Directory operations */

static DIR *vfswrap_fdopendir(vfs_handle_struct *handle,
			files_struct *fsp,
			const char *mask,
			uint32_t attr)
{
	DIR *result;

	START_PROFILE(syscall_fdopendir);
	result = sys_fdopendir(fsp_get_io_fd(fsp));
	END_PROFILE(syscall_fdopendir);
	return result;
}

static struct dirent *vfswrap_readdir(vfs_handle_struct *handle,
				      struct files_struct *dirfsp,
				      DIR *dirp)
{
	struct dirent *result;

	START_PROFILE(syscall_readdir);

	result = readdir(dirp);
	END_PROFILE(syscall_readdir);

	return result;
}

static NTSTATUS vfswrap_freaddir_attr(struct vfs_handle_struct *handle,
				      struct files_struct *fsp,
				      TALLOC_CTX *mem_ctx,
				      struct readdir_attr_data **attr_data)
{
	return NT_STATUS_NOT_SUPPORTED;
}

static void vfswrap_rewinddir(vfs_handle_struct *handle, DIR *dirp)
{
	START_PROFILE(syscall_rewinddir);
	rewinddir(dirp);
	END_PROFILE(syscall_rewinddir);
}

static int vfswrap_mkdirat(vfs_handle_struct *handle,
			struct files_struct *dirfsp,
			const struct smb_filename *smb_fname,
			mode_t mode)
{
	int result;

	START_PROFILE(syscall_mkdirat);

	result = mkdirat(fsp_get_pathref_fd(dirfsp), smb_fname->base_name, mode);

	END_PROFILE(syscall_mkdirat);
	return result;
}

static int vfswrap_closedir(vfs_handle_struct *handle, DIR *dirp)
{
	int result;

	START_PROFILE(syscall_closedir);
	result = closedir(dirp);
	END_PROFILE(syscall_closedir);
	return result;
}

/* File operations */

static int vfswrap_openat(vfs_handle_struct *handle,
			  const struct files_struct *dirfsp,
			  const struct smb_filename *smb_fname,
			  files_struct *fsp,
			  const struct vfs_open_how *how)
{
	int flags = how->flags;
	mode_t mode = how->mode;
	bool have_opath = false;
	bool became_root = false;
	int result;

	START_PROFILE(syscall_openat);

	if (how->resolve & ~(VFS_OPEN_HOW_RESOLVE_NO_SYMLINKS |
			     VFS_OPEN_HOW_WITH_BACKUP_INTENT)) {
		errno = ENOSYS;
		result = -1;
		goto out;
	}

	SMB_ASSERT(!is_named_stream(smb_fname));

#ifdef O_PATH
	have_opath = true;
	if (fsp->fsp_flags.is_pathref) {
		flags |= O_PATH;
	}
	if (flags & O_PATH) {
		/*
		 * From "man 2 openat":
		 *
		 *   When O_PATH is specified in flags, flag bits other than
		 *   O_CLOEXEC, O_DIRECTORY, and O_NOFOLLOW are ignored.
		 *
		 * From "man 2 openat2":
		 *
		 *   Whereas  openat(2)  ignores  unknown  bits  in  its  flags
		 *   argument, openat2() returns an error if unknown or
		 *   conflicting flags are specified in how.flags.
		 *
		 * So we better clear ignored/invalid flags
		 * and only keep the expected ones.
		 */
		flags &= (O_PATH|O_CLOEXEC|O_DIRECTORY|O_NOFOLLOW);
	}
#endif

	if (how->resolve & VFS_OPEN_HOW_RESOLVE_NO_SYMLINKS) {
		struct open_how linux_how = {
			.flags = flags,
			.mode = mode,
			.resolve = RESOLVE_NO_SYMLINKS,
		};

		result = openat2(fsp_get_pathref_fd(dirfsp),
				 smb_fname->base_name,
				 &linux_how,
				 sizeof(linux_how));
		if (result == -1) {
			if (errno == ENOSYS) {
				/*
				 * The kernel doesn't support
				 * openat2(), so indicate to
				 * the callers that
				 * VFS_OPEN_HOW_RESOLVE_NO_SYMLINKS
				 * would just be a waste of time.
				 */
				fsp->conn->open_how_resolve &=
					~VFS_OPEN_HOW_RESOLVE_NO_SYMLINKS;
			}
			goto out;
		}

		goto done;
	}

	if (fsp->fsp_flags.is_pathref && !have_opath) {
		become_root();
		became_root = true;
	}

	result = openat(fsp_get_pathref_fd(dirfsp),
			smb_fname->base_name,
			flags,
			mode);

	if (became_root) {
		int err = errno;
		unbecome_root();
		errno = err;
	}

done:
	if (result >= 0) {
		fsp->fsp_flags.have_proc_fds = fsp->conn->have_proc_fds;
	} else {
		/*
		 * "/proc/self/fd/-1" never exists. Indicate to upper
		 * layers that for this fsp a possible name-based
		 * fallback is the only way to go.
		 */
		fsp->fsp_flags.have_proc_fds = false;
	}

out:
	END_PROFILE(syscall_openat);
	return result;
}
static NTSTATUS vfswrap_create_file(vfs_handle_struct *handle,
				    struct smb_request *req,
				    struct files_struct *dirfsp,
				    struct smb_filename *smb_fname,
				    uint32_t access_mask,
				    uint32_t share_access,
				    uint32_t create_disposition,
				    uint32_t create_options,
				    uint32_t file_attributes,
				    uint32_t oplock_request,
				    const struct smb2_lease *lease,
				    uint64_t allocation_size,
				    uint32_t private_flags,
				    struct security_descriptor *sd,
				    struct ea_list *ea_list,
				    files_struct **result,
				    int *pinfo,
				    const struct smb2_create_blobs *in_context_blobs,
				    struct smb2_create_blobs *out_context_blobs)
{
	return create_file_default(handle->conn, req, dirfsp, smb_fname,
				   access_mask, share_access,
				   create_disposition, create_options,
				   file_attributes, oplock_request, lease,
				   allocation_size, private_flags,
				   sd, ea_list, result,
				   pinfo, in_context_blobs, out_context_blobs);
}

static int vfswrap_close(vfs_handle_struct *handle, files_struct *fsp)
{
	int result;

	START_PROFILE(syscall_close);
	result = fd_close_posix(fsp);
	END_PROFILE(syscall_close);
	return result;
}

static ssize_t vfswrap_pread(vfs_handle_struct *handle, files_struct *fsp, void *data,
			size_t n, off_t offset)
{
	ssize_t result;

#if defined(HAVE_PREAD) || defined(HAVE_PREAD64)
	START_PROFILE_BYTES(syscall_pread, n);
	result = sys_pread_full(fsp_get_io_fd(fsp), data, n, offset);
	END_PROFILE_BYTES(syscall_pread);

	if (result == -1 && errno == ESPIPE) {
		/* Maintain the fiction that pipes can be seeked (sought?) on. */
		result = sys_read(fsp_get_io_fd(fsp), data, n);
		fh_set_pos(fsp->fh, 0);
	}

#else /* HAVE_PREAD */
	errno = ENOSYS;
	result = -1;
#endif /* HAVE_PREAD */

	return result;
}

static ssize_t vfswrap_pwrite(vfs_handle_struct *handle, files_struct *fsp, const void *data,
			size_t n, off_t offset)
{
	ssize_t result;

#if defined(HAVE_PWRITE) || defined(HAVE_PRWITE64)
	START_PROFILE_BYTES(syscall_pwrite, n);
	result = sys_pwrite_full(fsp_get_io_fd(fsp), data, n, offset);
	END_PROFILE_BYTES(syscall_pwrite);

	if (result == -1 && errno == ESPIPE) {
		/* Maintain the fiction that pipes can be sought on. */
		result = sys_write(fsp_get_io_fd(fsp), data, n);
	}

#else /* HAVE_PWRITE */
	errno = ENOSYS;
	result = -1;
#endif /* HAVE_PWRITE */

	return result;
}

struct vfswrap_pread_state {
	ssize_t ret;
	int fd;
	void *buf;
	size_t count;
	off_t offset;

	struct vfs_aio_state vfs_aio_state;
	SMBPROFILE_BYTES_ASYNC_STATE(profile_bytes);
};

static void vfs_pread_do(void *private_data);
static void vfs_pread_done(struct tevent_req *subreq);
static int vfs_pread_state_destructor(struct vfswrap_pread_state *state);

static struct tevent_req *vfswrap_pread_send(struct vfs_handle_struct *handle,
					     TALLOC_CTX *mem_ctx,
					     struct tevent_context *ev,
					     struct files_struct *fsp,
					     void *data,
					     size_t n, off_t offset)
{
	struct tevent_req *req, *subreq;
	struct vfswrap_pread_state *state;

	req = tevent_req_create(mem_ctx, &state, struct vfswrap_pread_state);
	if (req == NULL) {
		return NULL;
	}

	state->ret = -1;
	state->fd = fsp_get_io_fd(fsp);
	state->buf = data;
	state->count = n;
	state->offset = offset;

	SMBPROFILE_BYTES_ASYNC_START(syscall_asys_pread, profile_p,
				     state->profile_bytes, n);
	SMBPROFILE_BYTES_ASYNC_SET_IDLE(state->profile_bytes);

	subreq = pthreadpool_tevent_job_send(
		state, ev, handle->conn->sconn->pool,
		vfs_pread_do, state);
	if (tevent_req_nomem(subreq, req)) {
		return tevent_req_post(req, ev);
	}
	tevent_req_set_callback(subreq, vfs_pread_done, req);

	talloc_set_destructor(state, vfs_pread_state_destructor);

	return req;
}

static void vfs_pread_do(void *private_data)
{
	struct vfswrap_pread_state *state = talloc_get_type_abort(
		private_data, struct vfswrap_pread_state);
	struct timespec start_time;
	struct timespec end_time;

	SMBPROFILE_BYTES_ASYNC_SET_BUSY(state->profile_bytes);

	PROFILE_TIMESTAMP(&start_time);

	state->ret = sys_pread_full(state->fd,
				    state->buf,
				    state->count,
				    state->offset);

	if (state->ret == -1) {
		state->vfs_aio_state.error = errno;
	}

	PROFILE_TIMESTAMP(&end_time);

	state->vfs_aio_state.duration = nsec_time_diff(&end_time, &start_time);

	SMBPROFILE_BYTES_ASYNC_SET_IDLE(state->profile_bytes);
}

static int vfs_pread_state_destructor(struct vfswrap_pread_state *state)
{
	return -1;
}

static void vfs_pread_done(struct tevent_req *subreq)
{
	struct tevent_req *req = tevent_req_callback_data(
		subreq, struct tevent_req);
	struct vfswrap_pread_state *state = tevent_req_data(
		req, struct vfswrap_pread_state);
	int ret;

	ret = pthreadpool_tevent_job_recv(subreq);
	TALLOC_FREE(subreq);
	SMBPROFILE_BYTES_ASYNC_END(state->profile_bytes);
	talloc_set_destructor(state, NULL);
	if (ret != 0) {
		if (ret != EAGAIN) {
			tevent_req_error(req, ret);
			return;
		}
		/*
		 * If we get EAGAIN from pthreadpool_tevent_job_recv() this
		 * means the lower level pthreadpool failed to create a new
		 * thread. Fallback to sync processing in that case to allow
		 * some progress for the client.
		 */
		vfs_pread_do(state);
	}

	tevent_req_done(req);
}

static ssize_t vfswrap_pread_recv(struct tevent_req *req,
				  struct vfs_aio_state *vfs_aio_state)
{
	struct vfswrap_pread_state *state = tevent_req_data(
		req, struct vfswrap_pread_state);

	if (tevent_req_is_unix_error(req, &vfs_aio_state->error)) {
		return -1;
	}

	*vfs_aio_state = state->vfs_aio_state;
	return state->ret;
}

struct vfswrap_pwrite_state {
	ssize_t ret;
	int fd;
	const void *buf;
	size_t count;
	off_t offset;

	struct vfs_aio_state vfs_aio_state;
	SMBPROFILE_BYTES_ASYNC_STATE(profile_bytes);
};

static void vfs_pwrite_do(void *private_data);
static void vfs_pwrite_done(struct tevent_req *subreq);
static int vfs_pwrite_state_destructor(struct vfswrap_pwrite_state *state);

static struct tevent_req *vfswrap_pwrite_send(struct vfs_handle_struct *handle,
					      TALLOC_CTX *mem_ctx,
					      struct tevent_context *ev,
					      struct files_struct *fsp,
					      const void *data,
					      size_t n, off_t offset)
{
	struct tevent_req *req, *subreq;
	struct vfswrap_pwrite_state *state;

	req = tevent_req_create(mem_ctx, &state, struct vfswrap_pwrite_state);
	if (req == NULL) {
		return NULL;
	}

	state->ret = -1;
	state->fd = fsp_get_io_fd(fsp);
	state->buf = data;
	state->count = n;
	state->offset = offset;

	SMBPROFILE_BYTES_ASYNC_START(syscall_asys_pwrite, profile_p,
				     state->profile_bytes, n);
	SMBPROFILE_BYTES_ASYNC_SET_IDLE(state->profile_bytes);

	subreq = pthreadpool_tevent_job_send(
		state, ev, handle->conn->sconn->pool,
		vfs_pwrite_do, state);
	if (tevent_req_nomem(subreq, req)) {
		return tevent_req_post(req, ev);
	}
	tevent_req_set_callback(subreq, vfs_pwrite_done, req);

	talloc_set_destructor(state, vfs_pwrite_state_destructor);

	return req;
}

static void vfs_pwrite_do(void *private_data)
{
	struct vfswrap_pwrite_state *state = talloc_get_type_abort(
		private_data, struct vfswrap_pwrite_state);
	struct timespec start_time;
	struct timespec end_time;

	SMBPROFILE_BYTES_ASYNC_SET_BUSY(state->profile_bytes);

	PROFILE_TIMESTAMP(&start_time);

	state->ret = sys_pwrite_full(state->fd,
				     state->buf,
				     state->count,
				     state->offset);

	if (state->ret == -1) {
		state->vfs_aio_state.error = errno;
	}

	PROFILE_TIMESTAMP(&end_time);

	state->vfs_aio_state.duration = nsec_time_diff(&end_time, &start_time);

	SMBPROFILE_BYTES_ASYNC_SET_IDLE(state->profile_bytes);
}

static int vfs_pwrite_state_destructor(struct vfswrap_pwrite_state *state)
{
	return -1;
}

static void vfs_pwrite_done(struct tevent_req *subreq)
{
	struct tevent_req *req = tevent_req_callback_data(
		subreq, struct tevent_req);
	struct vfswrap_pwrite_state *state = tevent_req_data(
		req, struct vfswrap_pwrite_state);
	int ret;

	ret = pthreadpool_tevent_job_recv(subreq);
	TALLOC_FREE(subreq);
	SMBPROFILE_BYTES_ASYNC_END(state->profile_bytes);
	talloc_set_destructor(state, NULL);
	if (ret != 0) {
		if (ret != EAGAIN) {
			tevent_req_error(req, ret);
			return;
		}
		/*
		 * If we get EAGAIN from pthreadpool_tevent_job_recv() this
		 * means the lower level pthreadpool failed to create a new
		 * thread. Fallback to sync processing in that case to allow
		 * some progress for the client.
		 */
		vfs_pwrite_do(state);
	}

	tevent_req_done(req);
}

static ssize_t vfswrap_pwrite_recv(struct tevent_req *req,
				   struct vfs_aio_state *vfs_aio_state)
{
	struct vfswrap_pwrite_state *state = tevent_req_data(
		req, struct vfswrap_pwrite_state);

	if (tevent_req_is_unix_error(req, &vfs_aio_state->error)) {
		return -1;
	}

	*vfs_aio_state = state->vfs_aio_state;
	return state->ret;
}

struct vfswrap_fsync_state {
	ssize_t ret;
	int fd;

	struct vfs_aio_state vfs_aio_state;
	SMBPROFILE_BYTES_ASYNC_STATE(profile_bytes);
};

static void vfs_fsync_do(void *private_data);
static void vfs_fsync_done(struct tevent_req *subreq);
static int vfs_fsync_state_destructor(struct vfswrap_fsync_state *state);

static struct tevent_req *vfswrap_fsync_send(struct vfs_handle_struct *handle,
					     TALLOC_CTX *mem_ctx,
					     struct tevent_context *ev,
					     struct files_struct *fsp)
{
	struct tevent_req *req, *subreq;
	struct vfswrap_fsync_state *state;

	req = tevent_req_create(mem_ctx, &state, struct vfswrap_fsync_state);
	if (req == NULL) {
		return NULL;
	}

	state->ret = -1;
	state->fd = fsp_get_io_fd(fsp);

	SMBPROFILE_BYTES_ASYNC_START(syscall_asys_fsync, profile_p,
				     state->profile_bytes, 0);
	SMBPROFILE_BYTES_ASYNC_SET_IDLE(state->profile_bytes);

	subreq = pthreadpool_tevent_job_send(
		state, ev, handle->conn->sconn->pool, vfs_fsync_do, state);
	if (tevent_req_nomem(subreq, req)) {
		return tevent_req_post(req, ev);
	}
	tevent_req_set_callback(subreq, vfs_fsync_done, req);

	talloc_set_destructor(state, vfs_fsync_state_destructor);

	return req;
}

static void vfs_fsync_do(void *private_data)
{
	struct vfswrap_fsync_state *state = talloc_get_type_abort(
		private_data, struct vfswrap_fsync_state);
	struct timespec start_time;
	struct timespec end_time;

	SMBPROFILE_BYTES_ASYNC_SET_BUSY(state->profile_bytes);

	PROFILE_TIMESTAMP(&start_time);

	do {
		state->ret = fsync(state->fd);
	} while ((state->ret == -1) && (errno == EINTR));

	if (state->ret == -1) {
		state->vfs_aio_state.error = errno;
	}

	PROFILE_TIMESTAMP(&end_time);

	state->vfs_aio_state.duration = nsec_time_diff(&end_time, &start_time);

	SMBPROFILE_BYTES_ASYNC_SET_IDLE(state->profile_bytes);
}

static int vfs_fsync_state_destructor(struct vfswrap_fsync_state *state)
{
	return -1;
}

static void vfs_fsync_done(struct tevent_req *subreq)
{
	struct tevent_req *req = tevent_req_callback_data(
		subreq, struct tevent_req);
	struct vfswrap_fsync_state *state = tevent_req_data(
		req, struct vfswrap_fsync_state);
	int ret;

	ret = pthreadpool_tevent_job_recv(subreq);
	TALLOC_FREE(subreq);
	SMBPROFILE_BYTES_ASYNC_END(state->profile_bytes);
	talloc_set_destructor(state, NULL);
	if (ret != 0) {
		if (ret != EAGAIN) {
			tevent_req_error(req, ret);
			return;
		}
		/*
		 * If we get EAGAIN from pthreadpool_tevent_job_recv() this
		 * means the lower level pthreadpool failed to create a new
		 * thread. Fallback to sync processing in that case to allow
		 * some progress for the client.
		 */
		vfs_fsync_do(state);
	}

	tevent_req_done(req);
}

static int vfswrap_fsync_recv(struct tevent_req *req,
			      struct vfs_aio_state *vfs_aio_state)
{
	struct vfswrap_fsync_state *state = tevent_req_data(
		req, struct vfswrap_fsync_state);

	if (tevent_req_is_unix_error(req, &vfs_aio_state->error)) {
		return -1;
	}

	*vfs_aio_state = state->vfs_aio_state;
	return state->ret;
}

static off_t vfswrap_lseek(vfs_handle_struct *handle, files_struct *fsp, off_t offset, int whence)
{
	off_t result = 0;

	START_PROFILE(syscall_lseek);

	result = lseek(fsp_get_io_fd(fsp), offset, whence);
	/*
	 * We want to maintain the fiction that we can seek
	 * on a fifo for file system purposes. This allows
	 * people to set up UNIX fifo's that feed data to Windows
	 * applications. JRA.
	 */

	if((result == -1) && (errno == ESPIPE)) {
		result = 0;
		errno = 0;
	}

	END_PROFILE(syscall_lseek);
	return result;
}

static ssize_t vfswrap_sendfile(vfs_handle_struct *handle, int tofd, files_struct *fromfsp, const DATA_BLOB *hdr,
			off_t offset, size_t n)
{
	ssize_t result;

	START_PROFILE_BYTES(syscall_sendfile, n);
	result = sys_sendfile(tofd, fsp_get_io_fd(fromfsp), hdr, offset, n);
	END_PROFILE_BYTES(syscall_sendfile);
	return result;
}

static ssize_t vfswrap_recvfile(vfs_handle_struct *handle,
			int fromfd,
			files_struct *tofsp,
			off_t offset,
			size_t n)
{
	ssize_t result;

	START_PROFILE_BYTES(syscall_recvfile, n);
	result = sys_recvfile(fromfd, fsp_get_io_fd(tofsp), offset, n);
	END_PROFILE_BYTES(syscall_recvfile);
	return result;
}

static int vfswrap_renameat(vfs_handle_struct *handle,
			  files_struct *srcfsp,
			  const struct smb_filename *smb_fname_src,
			  files_struct *dstfsp,
			  const struct smb_filename *smb_fname_dst)
{
	int result = -1;

	START_PROFILE(syscall_renameat);

	SMB_ASSERT(!is_named_stream(smb_fname_src));
	SMB_ASSERT(!is_named_stream(smb_fname_dst));

	result = renameat(fsp_get_pathref_fd(srcfsp),
			smb_fname_src->base_name,
			fsp_get_pathref_fd(dstfsp),
			smb_fname_dst->base_name);

	END_PROFILE(syscall_renameat);
	return result;
}

static int vfswrap_stat(vfs_handle_struct *handle,
			struct smb_filename *smb_fname)
{
	int result = -1;

	START_PROFILE(syscall_stat);

	SMB_ASSERT(!is_named_stream(smb_fname));

	result = sys_stat(smb_fname->base_name, &smb_fname->st,
			  lp_fake_directory_create_times(SNUM(handle->conn)));

	END_PROFILE(syscall_stat);
	return result;
}

static int vfswrap_fstat(vfs_handle_struct *handle, files_struct *fsp, SMB_STRUCT_STAT *sbuf)
{
	int result;

	START_PROFILE(syscall_fstat);
	result = sys_fstat(fsp_get_pathref_fd(fsp),
			   sbuf, lp_fake_directory_create_times(SNUM(handle->conn)));
	END_PROFILE(syscall_fstat);
	return result;
}

static int vfswrap_lstat(vfs_handle_struct *handle,
			 struct smb_filename *smb_fname)
{
	int result = -1;

	START_PROFILE(syscall_lstat);

	SMB_ASSERT(!is_named_stream(smb_fname));

	result = sys_lstat(smb_fname->base_name, &smb_fname->st,
			   lp_fake_directory_create_times(SNUM(handle->conn)));

	END_PROFILE(syscall_lstat);
	return result;
}

static int vfswrap_fstatat(
	struct vfs_handle_struct *handle,
	const struct files_struct *dirfsp,
	const struct smb_filename *smb_fname,
	SMB_STRUCT_STAT *sbuf,
	int flags)
{
	int result = -1;

	START_PROFILE(syscall_fstatat);

	SMB_ASSERT(!is_named_stream(smb_fname));

	result = sys_fstatat(
		fsp_get_pathref_fd(dirfsp),
		smb_fname->base_name,
		sbuf,
		flags,
		lp_fake_directory_create_times(SNUM(handle->conn)));

	END_PROFILE(syscall_fstatat);
	return result;
}

static NTSTATUS vfswrap_translate_name(struct vfs_handle_struct *handle,
				       const char *name,
				       enum vfs_translate_direction direction,
				       TALLOC_CTX *mem_ctx,
				       char **mapped_name)
{
	return NT_STATUS_NONE_MAPPED;
}

/**
 * Return allocated parent directory and basename of path
 *
 * Note: if requesting atname, it is returned as talloc child of the
 * parent. Freeing the parent is thus sufficient to free both.
 */
static NTSTATUS vfswrap_parent_pathname(struct vfs_handle_struct *handle,
					TALLOC_CTX *mem_ctx,
					const struct smb_filename *smb_fname_in,
					struct smb_filename **parent_dir_out,
					struct smb_filename **atname_out)
{
	struct smb_filename *parent = NULL;
	struct smb_filename *name = NULL;
	char *p = NULL;

	parent = cp_smb_filename_nostream(mem_ctx, smb_fname_in);
	if (parent == NULL) {
		return NT_STATUS_NO_MEMORY;
	}
	SET_STAT_INVALID(parent->st);

	p = strrchr_m(parent->base_name, '/'); /* Find final '/', if any */
	if (p == NULL) {
		TALLOC_FREE(parent->base_name);
		parent->base_name = talloc_strdup(parent, ".");
		if (parent->base_name == NULL) {
			TALLOC_FREE(parent);
			return NT_STATUS_NO_MEMORY;
		}
		p = smb_fname_in->base_name;
	} else {
		*p = '\0';
		p++;
	}

	if (atname_out == NULL) {
		*parent_dir_out = parent;
		return NT_STATUS_OK;
	}

	name = synthetic_smb_fname(
		parent,
		p,
		smb_fname_in->stream_name,
		&smb_fname_in->st,
		smb_fname_in->twrp,
		smb_fname_in->flags);
	if (name == NULL) {
		return NT_STATUS_NO_MEMORY;
	}

	*parent_dir_out = parent;
	*atname_out = name;
	return NT_STATUS_OK;
}

/*
 * Implement the default fsctl operation.
 */
static bool vfswrap_logged_ioctl_message = false;

static NTSTATUS vfswrap_fsctl(struct vfs_handle_struct *handle,
			      struct files_struct *fsp,
			      TALLOC_CTX *ctx,
			      uint32_t function,
			      uint16_t req_flags, /* Needed for UNICODE ... */
			      const uint8_t *_in_data,
			      uint32_t in_len,
			      uint8_t **_out_data,
			      uint32_t max_out_len,
			      uint32_t *out_len)
{
	const char *in_data = (const char *)_in_data;
	char **out_data = (char **)_out_data;
	NTSTATUS status;

	/*
	 * Currently all fsctls operate on the base
	 * file if given an alternate data stream.
	 * Revisit this if we implement fsctls later
	 * that need access to the ADS handle.
	 */
	fsp = metadata_fsp(fsp);

	switch (function) {
	case FSCTL_SET_SPARSE:
	{
		bool set_sparse = true;

		if (in_len >= 1 && in_data[0] == 0) {
			set_sparse = false;
		}

		status = file_set_sparse(handle->conn, fsp, set_sparse);

		DEBUG(NT_STATUS_IS_OK(status) ? 10 : 9,
		      ("FSCTL_SET_SPARSE: fname[%s] set[%u] - %s\n",
		       smb_fname_str_dbg(fsp->fsp_name), set_sparse,
		       nt_errstr(status)));

		return status;
	}

	case FSCTL_CREATE_OR_GET_OBJECT_ID:
	{
		unsigned char objid[16];
		char *return_data = NULL;

		/* This should return the object-id on this file.
		 * I think I'll make this be the inode+dev. JRA.
		 */

		DBG_DEBUG("FSCTL_CREATE_OR_GET_OBJECT_ID: called on %s\n",
			  fsp_fnum_dbg(fsp));

		*out_len = MIN(max_out_len, 64);

		/* Hmmm, will this cause problems if less data asked for? */
		return_data = talloc_array(ctx, char, 64);
		if (return_data == NULL) {
			return NT_STATUS_NO_MEMORY;
		}

		/* For backwards compatibility only store the dev/inode. */
		push_file_id_16(return_data, &fsp->file_id);
		memcpy(return_data+16,create_volume_objectid(fsp->conn,objid),16);
		push_file_id_16(return_data+32, &fsp->file_id);
		memset(return_data+48, 0, 16);
		*out_data = return_data;
		return NT_STATUS_OK;
	}

	case FSCTL_GET_REPARSE_POINT:
	{
		status = fsctl_get_reparse_point(
			fsp, ctx, out_data, max_out_len, out_len);
		return status;
	}

	case FSCTL_SET_REPARSE_POINT:
	{
		status = fsctl_set_reparse_point(fsp, ctx, _in_data, in_len);
		return status;
	}

	case FSCTL_DELETE_REPARSE_POINT:
	{
		status = fsctl_del_reparse_point(fsp, ctx, _in_data, in_len);
		return status;
	}

	case FSCTL_GET_SHADOW_COPY_DATA:
	{
		/*
		 * This is called to retrieve the number of Shadow Copies (a.k.a. snapshots)
		 * and return their volume names.  If max_data_count is 16, then it is just
		 * asking for the number of volumes and length of the combined names.
		 *
		 * pdata is the data allocated by our caller, but that uses
		 * total_data_count (which is 0 in our case) rather than max_data_count.
		 * Allocate the correct amount and return the pointer to let
		 * it be deallocated when we return.
		 */
		struct shadow_copy_data *shadow_data = NULL;
		bool labels = False;
		uint32_t labels_data_count = 0;
		uint32_t i;
		char *cur_pdata = NULL;

		if (max_out_len < 16) {
			DBG_ERR("FSCTL_GET_SHADOW_COPY_DATA: max_data_count(%u) < 16 is invalid!\n",
				max_out_len);
			return NT_STATUS_INVALID_PARAMETER;
		}

		if (max_out_len > 16) {
			labels = True;
		}

		shadow_data = talloc_zero(ctx, struct shadow_copy_data);
		if (shadow_data == NULL) {
			DBG_ERR("TALLOC_ZERO() failed!\n");
			return NT_STATUS_NO_MEMORY;
		}

		/*
		 * Call the VFS routine to actually do the work.
		 */
		if (SMB_VFS_GET_SHADOW_COPY_DATA(fsp, shadow_data, labels)!=0) {
			int log_lev = DBGLVL_ERR;
			if (errno == 0) {
				/* broken module didn't set errno on error */
				status = NT_STATUS_UNSUCCESSFUL;
			} else {
				status = map_nt_error_from_unix(errno);
				if (NT_STATUS_EQUAL(status,
						    NT_STATUS_NOT_SUPPORTED)) {
					log_lev = DBGLVL_INFO;
				}
			}
			DEBUG(log_lev, ("FSCTL_GET_SHADOW_COPY_DATA: "
					"connectpath %s, failed - %s.\n",
					fsp->conn->connectpath,
					nt_errstr(status)));
			TALLOC_FREE(shadow_data);
			return status;
		}

		labels_data_count = (shadow_data->num_volumes * 2 *
					sizeof(SHADOW_COPY_LABEL)) + 2;

		if (!labels) {
			*out_len = 16;
		} else {
			*out_len = 12 + labels_data_count;
		}

		if (max_out_len < *out_len) {
			DBG_ERR("FSCTL_GET_SHADOW_COPY_DATA: max_data_count(%u) too small (%u) bytes needed!\n",
				max_out_len, *out_len);
			TALLOC_FREE(shadow_data);
			return NT_STATUS_BUFFER_TOO_SMALL;
		}

		cur_pdata = talloc_zero_array(ctx, char, *out_len);
		if (cur_pdata == NULL) {
			TALLOC_FREE(shadow_data);
			return NT_STATUS_NO_MEMORY;
		}

		*out_data = cur_pdata;

		/* num_volumes 4 bytes */
		SIVAL(cur_pdata, 0, shadow_data->num_volumes);

		if (labels) {
			/* num_labels 4 bytes */
			SIVAL(cur_pdata, 4, shadow_data->num_volumes);
		}

		/* needed_data_count 4 bytes */
		SIVAL(cur_pdata, 8, labels_data_count);

		cur_pdata += 12;

		DBG_DEBUG("FSCTL_GET_SHADOW_COPY_DATA: %u volumes for path[%s].\n",
			  shadow_data->num_volumes, fsp_str_dbg(fsp));
		if (labels && shadow_data->labels) {
			for (i=0; i<shadow_data->num_volumes; i++) {
				size_t len = 0;
				status = srvstr_push(cur_pdata, req_flags,
					    cur_pdata, shadow_data->labels[i],
					    2 * sizeof(SHADOW_COPY_LABEL),
					    STR_UNICODE|STR_TERMINATE, &len);
				if (!NT_STATUS_IS_OK(status)) {
					TALLOC_FREE(*out_data);
					TALLOC_FREE(shadow_data);
					return status;
				}
				cur_pdata += 2 * sizeof(SHADOW_COPY_LABEL);
				DEBUGADD(DBGLVL_DEBUG,("Label[%u]: '%s'\n",i,shadow_data->labels[i]));
			}
		}

		TALLOC_FREE(shadow_data);

		return NT_STATUS_OK;
	}

	case FSCTL_FIND_FILES_BY_SID:
	{
		/* pretend this succeeded -
		 *
		 * we have to send back a list with all files owned by this SID
		 *
		 * but I have to check that --metze
		 */
		ssize_t ret;
		struct dom_sid sid;
		struct dom_sid_buf buf;
		uid_t uid;
		size_t sid_len;

		DBG_DEBUG("FSCTL_FIND_FILES_BY_SID: called on %s\n",
			   fsp_fnum_dbg(fsp));

		if (in_len < 8) {
			/* NT_STATUS_BUFFER_TOO_SMALL maybe? */
			return NT_STATUS_INVALID_PARAMETER;
		}

		sid_len = MIN(in_len - 4,SID_MAX_SIZE);

		/* unknown 4 bytes: this is not the length of the sid :-(  */
		/*unknown = IVAL(pdata,0);*/

		ret = sid_parse(_in_data + 4, sid_len, &sid);
		if (ret == -1) {
			return NT_STATUS_INVALID_PARAMETER;
		}
		DEBUGADD(DBGLVL_DEBUG, ("for SID: %s\n",
			      dom_sid_str_buf(&sid, &buf)));

		if (!sid_to_uid(&sid, &uid)) {
			DBG_ERR("sid_to_uid: failed, sid[%s] sid_len[%lu]\n",
				 dom_sid_str_buf(&sid, &buf),
				 (unsigned long)sid_len);
			uid = (-1);
		}

		/* we can take a look at the find source :-)
		 *
		 * find ./ -uid $uid  -name '*'   is what we need here
		 *
		 *
		 * and send 4bytes len and then NULL terminated unicode strings
		 * for each file
		 *
		 * but I don't know how to deal with the paged results
		 * (maybe we can hang the result anywhere in the fsp struct)
		 *
		 * but I don't know how to deal with the paged results
		 * (maybe we can hang the result anywhere in the fsp struct)
		 *
		 * we don't send all files at once
		 * and at the next we should *not* start from the beginning,
		 * so we have to cache the result
		 *
		 * --metze
		 */

		/* this works for now... */
		return NT_STATUS_OK;
	}

	case FSCTL_QUERY_ALLOCATED_RANGES:
	{
		/* FIXME: This is just a dummy reply, telling that all of the
		 * file is allocated. MKS cp needs that.
		 * Adding the real allocated ranges via FIEMAP on Linux
		 * and SEEK_DATA/SEEK_HOLE on Solaris is needed to make
		 * this FSCTL correct for sparse files.
		 */
		uint64_t offset, length;
		char *out_data_tmp = NULL;

		if (in_len != 16) {
			DBG_ERR("FSCTL_QUERY_ALLOCATED_RANGES: data_count(%u) != 16 is invalid!\n",
				in_len);
			return NT_STATUS_INVALID_PARAMETER;
		}

		if (max_out_len < 16) {
			DBG_ERR("FSCTL_QUERY_ALLOCATED_RANGES: max_out_len (%u) < 16 is invalid!\n",
				max_out_len);
			return NT_STATUS_INVALID_PARAMETER;
		}

		offset = BVAL(in_data,0);
		length = BVAL(in_data,8);

		if (offset + length < offset) {
			/* No 64-bit integer wrap. */
			return NT_STATUS_INVALID_PARAMETER;
		}

		/* Shouldn't this be SMB_VFS_STAT ... ? */
		status = vfs_stat_fsp(fsp);
		if (!NT_STATUS_IS_OK(status)) {
			return status;
		}

		*out_len = 16;
		out_data_tmp = talloc_array(ctx, char, *out_len);
		if (out_data_tmp == NULL) {
			DBG_DEBUG("unable to allocate memory for response\n");
			return NT_STATUS_NO_MEMORY;
		}

		if (offset > fsp->fsp_name->st.st_ex_size ||
				fsp->fsp_name->st.st_ex_size == 0 ||
				length == 0) {
			memset(out_data_tmp, 0, *out_len);
		} else {
			uint64_t end = offset + length;
			end = MIN(end, fsp->fsp_name->st.st_ex_size);
			SBVAL(out_data_tmp, 0, 0);
			SBVAL(out_data_tmp, 8, end);
		}

		*out_data = out_data_tmp;

		return NT_STATUS_OK;
	}

	case FSCTL_IS_VOLUME_DIRTY:
	{
		DBG_DEBUG("FSCTL_IS_VOLUME_DIRTY: called on %s "
			  "(but remotely not supported)\n", fsp_fnum_dbg(fsp));
		/*
		 * http://msdn.microsoft.com/en-us/library/cc232128%28PROT.10%29.aspx
		 * says we have to respond with NT_STATUS_INVALID_PARAMETER
		 */
		return NT_STATUS_INVALID_PARAMETER;
	}

	default:
		/*
		 * Only print once ... unfortunately there could be lots of
		 * different FSCTLs that are called.
		 */
		if (!vfswrap_logged_ioctl_message) {
			vfswrap_logged_ioctl_message = true;
			DBG_NOTICE("%s (0x%x): Currently not implemented.\n",
			__func__, function);
		}
	}

	return NT_STATUS_NOT_SUPPORTED;
}

static bool vfswrap_is_offline(struct connection_struct *conn,
			       const struct smb_filename *fname);

struct vfswrap_get_dos_attributes_state {
	struct vfs_aio_state aio_state;
	connection_struct *conn;
	TALLOC_CTX *mem_ctx;
	struct tevent_context *ev;
	files_struct *dir_fsp;
	struct smb_filename *smb_fname;
	uint32_t dosmode;
	bool as_root;
};

static void vfswrap_get_dos_attributes_getxattr_done(struct tevent_req *subreq);

static struct tevent_req *vfswrap_get_dos_attributes_send(
			TALLOC_CTX *mem_ctx,
			struct tevent_context *ev,
			struct vfs_handle_struct *handle,
			files_struct *dir_fsp,
			struct smb_filename *smb_fname)
{
	struct tevent_req *req = NULL;
	struct tevent_req *subreq = NULL;
	struct vfswrap_get_dos_attributes_state *state = NULL;

	SMB_ASSERT(!is_named_stream(smb_fname));

	req = tevent_req_create(mem_ctx, &state,
				struct vfswrap_get_dos_attributes_state);
	if (req == NULL) {
		return NULL;
	}

	*state = (struct vfswrap_get_dos_attributes_state) {
		.conn = dir_fsp->conn,
		.mem_ctx = mem_ctx,
		.ev = ev,
		.dir_fsp = dir_fsp,
		.smb_fname = smb_fname,
	};

	if (!lp_store_dos_attributes(SNUM(dir_fsp->conn))) {
		DBG_ERR("%s: \"smbd async dosmode\" enabled, but "
			"\"store dos attributes\" is disabled\n",
			dir_fsp->conn->connectpath);
		tevent_req_nterror(req, NT_STATUS_NOT_IMPLEMENTED);
		return tevent_req_post(req, ev);
	}

	subreq = SMB_VFS_GETXATTRAT_SEND(state,
					 ev,
					 dir_fsp,
					 smb_fname,
					 SAMBA_XATTR_DOS_ATTRIB,
					 sizeof(fstring));
	if (tevent_req_nomem(subreq, req)) {
		return tevent_req_post(req, ev);
	}
	tevent_req_set_callback(subreq,
				vfswrap_get_dos_attributes_getxattr_done,
				req);

	return req;
}

static void vfswrap_get_dos_attributes_getxattr_done(struct tevent_req *subreq)
{
	struct tevent_req *req =
		tevent_req_callback_data(subreq,
		struct tevent_req);
	struct vfswrap_get_dos_attributes_state *state =
		tevent_req_data(req,
		struct vfswrap_get_dos_attributes_state);
	ssize_t xattr_size;
	DATA_BLOB blob = {0};
	char *path = NULL;
	char *tofree = NULL;
	char pathbuf[PATH_MAX+1];
	ssize_t pathlen;
	struct smb_filename smb_fname;
	bool offline;
	NTSTATUS status;

	xattr_size = SMB_VFS_GETXATTRAT_RECV(subreq,
					     &state->aio_state,
					     state,
					     &blob.data);
	TALLOC_FREE(subreq);
	if (xattr_size == -1) {
		status = map_nt_error_from_unix(state->aio_state.error);

		if (state->as_root) {
			tevent_req_nterror(req, status);
			return;
		}
		if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
			tevent_req_nterror(req, status);
			return;
		}

		state->as_root = true;

		become_root();
		subreq = SMB_VFS_GETXATTRAT_SEND(state,
						 state->ev,
						 state->dir_fsp,
						 state->smb_fname,
						 SAMBA_XATTR_DOS_ATTRIB,
						 sizeof(fstring));
		unbecome_root();
		if (tevent_req_nomem(subreq, req)) {
			return;
		}
		tevent_req_set_callback(subreq,
					vfswrap_get_dos_attributes_getxattr_done,
					req);
		return;
	}

	blob.length = xattr_size;

	status = parse_dos_attribute_blob(state->smb_fname,
					  blob,
					  &state->dosmode);
	if (!NT_STATUS_IS_OK(status)) {
		tevent_req_nterror(req, status);
		return;
	}

	pathlen = full_path_tos(state->dir_fsp->fsp_name->base_name,
				state->smb_fname->base_name,
				pathbuf,
				sizeof(pathbuf),
				&path,
				&tofree);
	if (pathlen == -1) {
		tevent_req_nterror(req, NT_STATUS_NO_MEMORY);
		return;
	}

	smb_fname = (struct smb_filename) {
		.base_name = path,
		.st = state->smb_fname->st,
		.flags = state->smb_fname->flags,
		.twrp = state->smb_fname->twrp,
	};

	offline = vfswrap_is_offline(state->conn, &smb_fname);
	if (offline) {
		state->dosmode |= FILE_ATTRIBUTE_OFFLINE;
	}
	TALLOC_FREE(tofree);

	tevent_req_done(req);
	return;
}

static NTSTATUS vfswrap_get_dos_attributes_recv(struct tevent_req *req,
						struct vfs_aio_state *aio_state,
						uint32_t *dosmode)
{
	struct vfswrap_get_dos_attributes_state *state =
		tevent_req_data(req,
		struct vfswrap_get_dos_attributes_state);
	NTSTATUS status;

	if (tevent_req_is_nterror(req, &status)) {
		tevent_req_received(req);
		return status;
	}

	*aio_state = state->aio_state;
	*dosmode = state->dosmode;
	tevent_req_received(req);
	return NT_STATUS_OK;
}

static NTSTATUS vfswrap_fget_dos_attributes(struct vfs_handle_struct *handle,
					    struct files_struct *fsp,
					    uint32_t *dosmode)
{
	bool offline;

	SMB_ASSERT(!fsp_is_alternate_stream(fsp));

	offline = vfswrap_is_offline(handle->conn, fsp->fsp_name);
	if (offline) {
		*dosmode |= FILE_ATTRIBUTE_OFFLINE;
	}

	return fget_ea_dos_attribute(fsp, dosmode);
}

static NTSTATUS vfswrap_fset_dos_attributes(struct vfs_handle_struct *handle,
					    struct files_struct *fsp,
					    uint32_t dosmode)
{
	SMB_ASSERT(!fsp_is_alternate_stream(fsp));

	return set_ea_dos_attribute(handle->conn, fsp->fsp_name, dosmode);
}

static struct vfs_offload_ctx *vfswrap_offload_ctx;

struct vfswrap_offload_read_state {
	DATA_BLOB token;
};

static struct tevent_req *vfswrap_offload_read_send(
	TALLOC_CTX *mem_ctx,
	struct tevent_context *ev,
	struct vfs_handle_struct *handle,
	struct files_struct *fsp,
	uint32_t fsctl,
	uint32_t ttl,
	off_t offset,
	size_t to_copy)
{
	struct tevent_req *req = NULL;
	struct vfswrap_offload_read_state *state = NULL;
	NTSTATUS status;

	req = tevent_req_create(mem_ctx, &state,
				struct vfswrap_offload_read_state);
	if (req == NULL) {
		return NULL;
	}

	status = vfs_offload_token_ctx_init(fsp->conn->sconn->client,
					    &vfswrap_offload_ctx);
	if (tevent_req_nterror(req, status)) {
		return tevent_req_post(req, ev);
	}

	if (fsctl != FSCTL_SRV_REQUEST_RESUME_KEY) {
		tevent_req_nterror(req, NT_STATUS_INVALID_DEVICE_REQUEST);
		return tevent_req_post(req, ev);
	}

	status = vfs_offload_token_create_blob(state, fsp, fsctl,
					       &state->token);
	if (tevent_req_nterror(req, status)) {
		return tevent_req_post(req, ev);
	}

	status = vfs_offload_token_db_store_fsp(vfswrap_offload_ctx, fsp,
						&state->token);
	if (tevent_req_nterror(req, status)) {
		return tevent_req_post(req, ev);
	}

	tevent_req_done(req);
	return tevent_req_post(req, ev);
}

static NTSTATUS vfswrap_offload_read_recv(struct tevent_req *req,
					  struct vfs_handle_struct *handle,
					  TALLOC_CTX *mem_ctx,
					  uint32_t *flags,
					  uint64_t *xferlen,
					  DATA_BLOB *token)
{
	struct vfswrap_offload_read_state *state = tevent_req_data(
		req, struct vfswrap_offload_read_state);
	NTSTATUS status;

	if (tevent_req_is_nterror(req, &status)) {
		tevent_req_received(req);
		return status;
	}

	*flags = 0;
	*xferlen = 0;
	token->length = state->token.length;
	token->data = talloc_move(mem_ctx, &state->token.data);

	tevent_req_received(req);
	return NT_STATUS_OK;
}

struct vfswrap_offload_write_state {
	uint8_t *buf;
	bool read_lck_locked;
	bool write_lck_locked;
	DATA_BLOB *token;
	struct tevent_context *src_ev;
	struct files_struct *src_fsp;
	off_t src_off;
	struct tevent_context *dst_ev;
	struct files_struct *dst_fsp;
	off_t dst_off;
	off_t to_copy;
	off_t remaining;
	off_t copied;
	size_t next_io_size;
};

static void vfswrap_offload_write_cleanup(struct tevent_req *req,
					  enum tevent_req_state req_state)
{
	struct vfswrap_offload_write_state *state = tevent_req_data(
		req, struct vfswrap_offload_write_state);
	bool ok;

	if (state->dst_fsp == NULL) {
		return;
	}

	ok = change_to_user_and_service_by_fsp(state->dst_fsp);
	SMB_ASSERT(ok);
	state->dst_fsp = NULL;
}

static NTSTATUS vfswrap_offload_copy_file_range(struct tevent_req *req);
static NTSTATUS vfswrap_offload_write_loop(struct tevent_req *req);

static struct tevent_req *vfswrap_offload_write_send(
	struct vfs_handle_struct *handle,
	TALLOC_CTX *mem_ctx,
	struct tevent_context *ev,
	uint32_t fsctl,
	DATA_BLOB *token,
	off_t transfer_offset,
	struct files_struct *dest_fsp,
	off_t dest_off,
	off_t to_copy)
{
	struct tevent_req *req;
	struct vfswrap_offload_write_state *state = NULL;
	/* off_t is signed! */
	off_t max_offset = INT64_MAX - to_copy;
	size_t num = MIN(to_copy, COPYCHUNK_MAX_TOTAL_LEN);
	files_struct *src_fsp = NULL;
	NTSTATUS status;
	bool ok;

	req = tevent_req_create(mem_ctx, &state,
				struct vfswrap_offload_write_state);
	if (req == NULL) {
		return NULL;
	}

	*state = (struct vfswrap_offload_write_state) {
		.token = token,
		.src_off = transfer_offset,
		.dst_ev = ev,
		.dst_fsp = dest_fsp,
		.dst_off = dest_off,
		.to_copy = to_copy,
		.remaining = to_copy,
	};

	tevent_req_set_cleanup_fn(req, vfswrap_offload_write_cleanup);

	switch (fsctl) {
	case FSCTL_SRV_COPYCHUNK:
	case FSCTL_SRV_COPYCHUNK_WRITE:
		break;

	case FSCTL_OFFLOAD_WRITE:
		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);
	}

	/*
	 * From here on we assume a copy-chunk fsctl
	 */

	if (to_copy == 0) {
		tevent_req_done(req);
		return tevent_req_post(req, ev);
	}

	if (state->src_off > max_offset) {
		/*
		 * Protect integer checks below.
		 */
		tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
		return tevent_req_post(req, ev);
	}
	if (state->src_off < 0) {
		/*
		 * Protect integer checks below.
		 */
		tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
		return tevent_req_post(req, ev);
	}
	if (state->dst_off > max_offset) {
		/*
		 * Protect integer checks below.
		 */
		tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
		return tevent_req_post(req, ev);
	}
	if (state->dst_off < 0) {
		/*
		 * Protect integer checks below.
		 */
		tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
		return tevent_req_post(req, ev);
	}

	status = vfs_offload_token_db_fetch_fsp(vfswrap_offload_ctx,
						token, &src_fsp);
	if (tevent_req_nterror(req, status)) {
		return tevent_req_post(req, ev);
	}

	DBG_DEBUG("server side copy chunk of length %" PRIu64 "\n", to_copy);

	status = vfs_offload_token_check_handles(fsctl, src_fsp, dest_fsp);
	if (!NT_STATUS_IS_OK(status)) {
		tevent_req_nterror(req, status);
		return tevent_req_post(req, ev);
	}

	ok = change_to_user_and_service_by_fsp(src_fsp);
	if (!ok) {
		tevent_req_nterror(req, NT_STATUS_ACCESS_DENIED);
		return tevent_req_post(req, ev);
	}

	state->src_ev = src_fsp->conn->sconn->ev_ctx;
	state->src_fsp = src_fsp;

	status = vfs_stat_fsp(src_fsp);
	if (tevent_req_nterror(req, status)) {
		return tevent_req_post(req, ev);
	}

	if (src_fsp->fsp_name->st.st_ex_size < state->src_off + to_copy) {
		/*
		 * [MS-SMB2] 3.3.5.15.6 Handling a Server-Side Data Copy Request
		 *   If the SourceOffset or SourceOffset + Length extends beyond
		 *   the end of file, the server SHOULD<240> treat this as a
		 *   STATUS_END_OF_FILE error.
		 * ...
		 *   <240> Section 3.3.5.15.6: Windows servers will return
		 *   STATUS_INVALID_VIEW_SIZE instead of STATUS_END_OF_FILE.
		 */
		tevent_req_nterror(req, NT_STATUS_INVALID_VIEW_SIZE);
		return tevent_req_post(req, ev);
	}

	status = vfswrap_offload_copy_file_range(req);
	if (NT_STATUS_IS_OK(status)) {
		tevent_req_done(req);
		return tevent_req_post(req, ev);
	}
	if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
		tevent_req_nterror(req, status);
		return tevent_req_post(req, ev);
	}

	state->buf = talloc_array(state, uint8_t, num);
	if (tevent_req_nomem(state->buf, req)) {
		return tevent_req_post(req, ev);
	}

	status = vfswrap_offload_write_loop(req);
	if (!NT_STATUS_IS_OK(status)) {
		tevent_req_nterror(req, status);
		return tevent_req_post(req, ev);
	}

	return req;
}

static NTSTATUS vfswrap_offload_copy_file_range(struct tevent_req *req)
{
	struct vfswrap_offload_write_state *state = tevent_req_data(
		req, struct vfswrap_offload_write_state);
	struct lock_struct lck;
	ssize_t nwritten;
	NTSTATUS status;
	bool same_file;
	bool ok;
	static bool try_copy_file_range = true;

	if (!try_copy_file_range) {
		return NT_STATUS_MORE_PROCESSING_REQUIRED;
	}

	same_file = file_id_equal(&state->src_fsp->file_id,
				  &state->dst_fsp->file_id);
	if (same_file &&
	    sys_io_ranges_overlap(state->remaining,
				  state->src_off,
				  state->remaining,
				  state->dst_off))
	{
		return NT_STATUS_MORE_PROCESSING_REQUIRED;
	}

	if (fsp_is_alternate_stream(state->src_fsp) ||
	    fsp_is_alternate_stream(state->dst_fsp))
	{
		return NT_STATUS_MORE_PROCESSING_REQUIRED;
	}

	init_strict_lock_struct(state->src_fsp,
				state->src_fsp->op->global->open_persistent_id,
				state->src_off,
				state->remaining,
				READ_LOCK,
				lp_posix_cifsu_locktype(state->src_fsp),
				&lck);

	ok = SMB_VFS_STRICT_LOCK_CHECK(state->src_fsp->conn,
				 state->src_fsp,
				 &lck);
	if (!ok) {
		return NT_STATUS_FILE_LOCK_CONFLICT;
	}

	ok = change_to_user_and_service_by_fsp(state->dst_fsp);
	if (!ok) {
		return NT_STATUS_INTERNAL_ERROR;
	}

	init_strict_lock_struct(state->dst_fsp,
				state->dst_fsp->op->global->open_persistent_id,
				state->dst_off,
				state->remaining,
				WRITE_LOCK,
				lp_posix_cifsu_locktype(state->dst_fsp),
				&lck);

	ok = SMB_VFS_STRICT_LOCK_CHECK(state->dst_fsp->conn,
				       state->dst_fsp,
				       &lck);
	if (!ok) {
		return NT_STATUS_FILE_LOCK_CONFLICT;
	}

	while (state->remaining > 0) {
		nwritten = copy_file_range(fsp_get_io_fd(state->src_fsp),
					   &state->src_off,
					   fsp_get_io_fd(state->dst_fsp),
					   &state->dst_off,
					   state->remaining,
					   0);
		if (nwritten == -1) {
			DBG_DEBUG("copy_file_range src [%s]:[%jd] dst [%s]:[%jd] "
				  "n [%jd] failed: %s\n",
				  fsp_str_dbg(state->src_fsp),
				  (intmax_t)state->src_off,
				  fsp_str_dbg(state->dst_fsp),
				  (intmax_t)state->dst_off,
				  (intmax_t)state->remaining,
				  strerror(errno));
			switch (errno) {
			case EOPNOTSUPP:
			case ENOSYS:
				try_copy_file_range = false;
				status = NT_STATUS_MORE_PROCESSING_REQUIRED;
				break;
			case EXDEV:
				status = NT_STATUS_MORE_PROCESSING_REQUIRED;
				break;
			default:
				status = map_nt_error_from_unix(errno);
				if (NT_STATUS_EQUAL(
					    status,
					    NT_STATUS_MORE_PROCESSING_REQUIRED))
				{
					/* Avoid triggering the fallback */
					status = NT_STATUS_INTERNAL_ERROR;
				}
				break;
			}
			return status;
		}

		if (state->remaining < nwritten) {
			DBG_DEBUG("copy_file_range src [%s] dst [%s] "
				  "n [%jd] remaining [%jd]\n",
				  fsp_str_dbg(state->src_fsp),
				  fsp_str_dbg(state->dst_fsp),
				  (intmax_t)nwritten,
				  (intmax_t)state->remaining);
			return NT_STATUS_INTERNAL_ERROR;
		}

		if (nwritten == 0) {
			break;
		}
		state->copied += nwritten;
		state->remaining -= nwritten;
	}

	/*
	 * Tell the req cleanup function there's no need to call
	 * change_to_user_and_service_by_fsp() on the dst handle.
	 */
	state->dst_fsp = NULL;
	return NT_STATUS_OK;
}

static void vfswrap_offload_write_read_done(struct tevent_req *subreq);

static NTSTATUS vfswrap_offload_write_loop(struct tevent_req *req)
{
	struct vfswrap_offload_write_state *state = tevent_req_data(
		req, struct vfswrap_offload_write_state);
	struct tevent_req *subreq = NULL;
	struct lock_struct read_lck;
	bool ok;

	/*
	 * This is called under the context of state->src_fsp.
	 */

	state->next_io_size = MIN(state->remaining, talloc_array_length(state->buf));

	init_strict_lock_struct(state->src_fsp,
				state->src_fsp->op->global->open_persistent_id,
				state->src_off,
				state->next_io_size,
				READ_LOCK,
				lp_posix_cifsu_locktype(state->src_fsp),
				&read_lck);

	ok = SMB_VFS_STRICT_LOCK_CHECK(state->src_fsp->conn,
				 state->src_fsp,
				 &read_lck);
	if (!ok) {
		return NT_STATUS_FILE_LOCK_CONFLICT;
	}

	subreq = SMB_VFS_PREAD_SEND(state,
				    state->src_ev,
				    state->src_fsp,
				    state->buf,
				    state->next_io_size,
				    state->src_off);
	if (subreq == NULL) {
		return NT_STATUS_NO_MEMORY;
	}
	tevent_req_set_callback(subreq, vfswrap_offload_write_read_done, req);

	return NT_STATUS_OK;
}

static void vfswrap_offload_write_write_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 vfswrap_offload_write_state *state = tevent_req_data(
		req, struct vfswrap_offload_write_state);
	struct vfs_aio_state aio_state;
	struct lock_struct write_lck;
	ssize_t nread;
	bool ok;

	nread = SMB_VFS_PREAD_RECV(subreq, &aio_state);
	TALLOC_FREE(subreq);
	if (nread == -1) {
		DBG_ERR("read failed: %s\n", strerror(aio_state.error));
		tevent_req_nterror(req, map_nt_error_from_unix(aio_state.error));
		return;
	}
	if (nread != state->next_io_size) {
		DBG_ERR("Short read, only %zd of %zu\n",
			nread, state->next_io_size);
		tevent_req_nterror(req, NT_STATUS_IO_DEVICE_ERROR);
		return;
	}

	state->src_off += nread;

	ok = change_to_user_and_service_by_fsp(state->dst_fsp);
	if (!ok) {
		tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
		return;
	}

	init_strict_lock_struct(state->dst_fsp,
				state->dst_fsp->op->global->open_persistent_id,
				state->dst_off,
				state->next_io_size,
				WRITE_LOCK,
				lp_posix_cifsu_locktype(state->dst_fsp),
				&write_lck);

	ok = SMB_VFS_STRICT_LOCK_CHECK(state->dst_fsp->conn,
				 state->dst_fsp,
				 &write_lck);
	if (!ok) {
		tevent_req_nterror(req, NT_STATUS_FILE_LOCK_CONFLICT);
		return;
	}

	subreq = SMB_VFS_PWRITE_SEND(state,
				     state->dst_ev,
				     state->dst_fsp,
				     state->buf,
				     state->next_io_size,
				     state->dst_off);
	if (subreq == NULL) {
		tevent_req_nterror(req, NT_STATUS_NO_MEMORY);
		return;
	}
	tevent_req_set_callback(subreq, vfswrap_offload_write_write_done, req);
}

static void vfswrap_offload_write_write_done(struct tevent_req *subreq)
{
	struct tevent_req *req = tevent_req_callback_data(
		subreq, struct tevent_req);
	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;
	bool ok;

	nwritten = SMB_VFS_PWRITE_RECV(subreq, &aio_state);
	TALLOC_FREE(subreq);
	if (nwritten == -1) {
		DBG_ERR("write failed: %s\n", strerror(aio_state.error));
		tevent_req_nterror(req, map_nt_error_from_unix(aio_state.error));
		return;
	}
	if (nwritten != state->next_io_size) {
		DBG_ERR("Short write, only %zd of %zu\n", nwritten, state->next_io_size);
		tevent_req_nterror(req, NT_STATUS_IO_DEVICE_ERROR);
		return;
	}

	state->dst_off += nwritten;

	if (state->remaining < nwritten) {
		/* Paranoia check */
		tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
		return;
	}
	state->copied += nwritten;
	state->remaining -= nwritten;
	if (state->remaining == 0) {
		tevent_req_done(req);
		return;
	}

	ok = change_to_user_and_service_by_fsp(state->src_fsp);
	if (!ok) {
		tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
		return;
	}

	status = vfswrap_offload_write_loop(req);
	if (!NT_STATUS_IS_OK(status)) {
		tevent_req_nterror(req, status);
		return;
	}

	return;
}

static NTSTATUS vfswrap_offload_write_recv(struct vfs_handle_struct *handle,
					struct tevent_req *req,
					off_t *copied)
{
	struct vfswrap_offload_write_state *state = tevent_req_data(
		req, struct vfswrap_offload_write_state);
	NTSTATUS status;

	if (tevent_req_is_nterror(req, &status)) {
		DBG_DEBUG("copy chunk failed: %s\n", nt_errstr(status));
		*copied = 0;
		tevent_req_received(req);
		return status;
	}

	*copied = state->copied;
	DBG_DEBUG("copy chunk copied %lu\n", (unsigned long)*copied);
	tevent_req_received(req);

	return NT_STATUS_OK;
}

static NTSTATUS vfswrap_fget_compression(struct vfs_handle_struct *handle,
					TALLOC_CTX *mem_ctx,
					struct files_struct *fsp,
					uint16_t *_compression_fmt)
{
	return NT_STATUS_INVALID_DEVICE_REQUEST;
}

static NTSTATUS vfswrap_set_compression(struct vfs_handle_struct *handle,
					TALLOC_CTX *mem_ctx,
					struct files_struct *fsp,
					uint16_t compression_fmt)
{
	return NT_STATUS_INVALID_DEVICE_REQUEST;
}

/********************************************************************
 Given a stat buffer return the allocated size on disk, taking into
 account sparse files.
********************************************************************/
static uint64_t vfswrap_get_alloc_size(vfs_handle_struct *handle,
				       struct files_struct *fsp,
				       const SMB_STRUCT_STAT *sbuf)
{
	uint64_t result;

	START_PROFILE(syscall_get_alloc_size);

	if(S_ISDIR(sbuf->st_ex_mode)) {
		result = 0;
		goto out;
	}

#if defined(HAVE_STAT_ST_BLOCKS) && defined(STAT_ST_BLOCKSIZE)
	/* The type of st_blocksize is blkcnt_t which *MUST* be
	   signed (according to POSIX) and can be less than 64-bits.
	   Ensure when we're converting to 64 bits wide we don't
	   sign extend. */
#if defined(SIZEOF_BLKCNT_T_8)
	result = (uint64_t)STAT_ST_BLOCKSIZE * (uint64_t)sbuf->st_ex_blocks;
#elif defined(SIZEOF_BLKCNT_T_4)
	{
		uint64_t bs = ((uint64_t)sbuf->st_ex_blocks) & 0xFFFFFFFFLL;
		result = (uint64_t)STAT_ST_BLOCKSIZE * bs;
	}
#else
#error SIZEOF_BLKCNT_T_NOT_A_SUPPORTED_VALUE
#endif
	if (result == 0) {
		/*
		 * Some file systems do not allocate a block for very
		 * small files. But for non-empty file should report a
		 * positive size.
		 */

		uint64_t filesize = get_file_size_stat(sbuf);
		if (filesize > 0) {
			result = MIN((uint64_t)STAT_ST_BLOCKSIZE, filesize);
		}
	}
#else
	result = get_file_size_stat(sbuf);
#endif

	if (fsp && fsp->initial_allocation_size)
		result = MAX(result,fsp->initial_allocation_size);

	result = smb_roundup(handle->conn, result);

 out:
	END_PROFILE(syscall_get_alloc_size);
	return result;
}

static int vfswrap_unlinkat(vfs_handle_struct *handle,
			struct files_struct *dirfsp,
			const struct smb_filename *smb_fname,
			int flags)
{
	int result = -1;

	START_PROFILE(syscall_unlinkat);

	SMB_ASSERT(!is_named_stream(smb_fname));

	result = unlinkat(fsp_get_pathref_fd(dirfsp),
			smb_fname->base_name,
			flags);

	END_PROFILE(syscall_unlinkat);
	return result;
}

static int vfswrap_fchmod(vfs_handle_struct *handle, files_struct *fsp, mode_t mode)
{
	int result;

	START_PROFILE(syscall_fchmod);

	if (!fsp->fsp_flags.is_pathref) {
		result = fchmod(fsp_get_io_fd(fsp), mode);
		END_PROFILE(syscall_fchmod);
		return result;
	}

	if (fsp->fsp_flags.have_proc_fds) {
		int fd = fsp_get_pathref_fd(fsp);
		struct sys_proc_fd_path_buf buf;

		result = chmod(sys_proc_fd_path(fd, &buf), mode);

		END_PROFILE(syscall_fchmod);
		return result;
	}

	/*
	 * This is no longer a handle based call.
	 */
	result = chmod(fsp->fsp_name->base_name, mode);

	END_PROFILE(syscall_fchmod);
	return result;
}

static int vfswrap_fchown(vfs_handle_struct *handle, files_struct *fsp, uid_t uid, gid_t gid)
{
#ifdef HAVE_FCHOWN
	int result;

	START_PROFILE(syscall_fchown);
	if (!fsp->fsp_flags.is_pathref) {
		result = fchown(fsp_get_io_fd(fsp), uid, gid);
		END_PROFILE(syscall_fchown);
		return result;
	}

	if (fsp->fsp_flags.have_proc_fds) {
		int fd = fsp_get_pathref_fd(fsp);
		struct sys_proc_fd_path_buf buf;

		result = chown(sys_proc_fd_path(fd, &buf), uid, gid);

		END_PROFILE(syscall_fchown);
		return result;
	}

	/*
	 * This is no longer a handle based call.
	 */
	result = chown(fsp->fsp_name->base_name, uid, gid);
	END_PROFILE(syscall_fchown);
	return result;
#else
	errno = ENOSYS;
	return -1;
#endif
}

static int vfswrap_lchown(vfs_handle_struct *handle,
			const struct smb_filename *smb_fname,
			uid_t uid,
			gid_t gid)
{
	int result;

	START_PROFILE(syscall_lchown);
	result = lchown(smb_fname->base_name, uid, gid);
	END_PROFILE(syscall_lchown);
	return result;
}

static int vfswrap_chdir(vfs_handle_struct *handle,
			const struct smb_filename *smb_fname)
{
	int result;

	START_PROFILE(syscall_chdir);
	result = chdir(smb_fname->base_name);
	END_PROFILE(syscall_chdir);
	return result;
}

static struct smb_filename *vfswrap_getwd(vfs_handle_struct *handle,
				TALLOC_CTX *ctx)
{
	char *result;
	struct smb_filename *smb_fname = NULL;

	START_PROFILE(syscall_getwd);
	result = sys_getwd();
	END_PROFILE(syscall_getwd);

	if (result == NULL) {
		return NULL;
	}
	smb_fname = synthetic_smb_fname(ctx,
				result,
				NULL,
				NULL,
				0,
				0);
	/*
	 * sys_getwd() *always* returns malloced memory.
	 * We must free here to avoid leaks:
	 * BUG:https://bugzilla.samba.org/show_bug.cgi?id=13372
	 */
	SAFE_FREE(result);
	return smb_fname;
}

/*********************************************************************
 nsec timestamp resolution call. Convert down to whatever the underlying
 system will support.
**********************************************************************/

static int vfswrap_fntimes(vfs_handle_struct *handle,
			   files_struct *fsp,
			   struct smb_file_time *ft)
{
	int result = -1;
	struct timespec ts[2];
	struct timespec *times = NULL;

	START_PROFILE(syscall_fntimes);

	if (fsp_is_alternate_stream(fsp)) {
		errno = ENOENT;
		goto out;
	}

	if (ft != NULL) {
		if (is_omit_timespec(&ft->atime)) {
			ft->atime = fsp->fsp_name->st.st_ex_atime;
		}

		if (is_omit_timespec(&ft->mtime)) {
			ft->mtime = fsp->fsp_name->st.st_ex_mtime;
		}

		if (!is_omit_timespec(&ft->create_time)) {
			set_create_timespec_ea(fsp,
					       ft->create_time);
		}

		if ((timespec_compare(&ft->atime,
				      &fsp->fsp_name->st.st_ex_atime) == 0) &&
		    (timespec_compare(&ft->mtime,
				      &fsp->fsp_name->st.st_ex_mtime) == 0)) {
			result = 0;
			goto out;
		}

		ts[0] = ft->atime;
		ts[1] = ft->mtime;
		times = ts;
	} else {
		times = NULL;
	}

	if (!fsp->fsp_flags.is_pathref) {
		result = futimens(fsp_get_io_fd(fsp), times);
		goto out;
	}

	if (fsp->fsp_flags.have_proc_fds) {
		int fd = fsp_get_pathref_fd(fsp);
		struct sys_proc_fd_path_buf buf;

		result = utimensat(AT_FDCWD,
				   sys_proc_fd_path(fd, &buf),
				   times,
				   0);

		goto out;
	}

	/*
	 * The fd is a pathref (opened with O_PATH) and there isn't fd to
	 * path translation mechanism. Fallback to path based call.
	 */
	result = utimensat(AT_FDCWD, fsp->fsp_name->base_name, times, 0);

out:
	END_PROFILE(syscall_fntimes);

	return result;
}


/*********************************************************************
 A version of ftruncate that will write the space on disk if strict
 allocate is set.
**********************************************************************/

static int strict_allocate_ftruncate(vfs_handle_struct *handle, files_struct *fsp, off_t len)
{
	off_t space_to_write;
	uint64_t space_avail;
	uint64_t bsize,dfree,dsize;
	int ret;
	NTSTATUS status;
	SMB_STRUCT_STAT *pst;
	bool ok;

	ok = vfs_valid_pwrite_range(len, 0);
	if (!ok) {
		errno = EINVAL;
		return -1;
	}

	status = vfs_stat_fsp(fsp);
	if (!NT_STATUS_IS_OK(status)) {
		return -1;
	}
	pst = &fsp->fsp_name->st;

#ifdef S_ISFIFO
	if (S_ISFIFO(pst->st_ex_mode))
		return 0;
#endif

	if (pst->st_ex_size == len)
		return 0;

	/* Shrink - just ftruncate. */
	if (pst->st_ex_size > len)
		return ftruncate(fsp_get_io_fd(fsp), len);

	space_to_write = len - pst->st_ex_size;

	/* for allocation try fallocate first. This can fail on some
	   platforms e.g. when the filesystem doesn't support it and no
	   emulation is being done by the libc (like on AIX with JFS1). In that
	   case we do our own emulation. fallocate implementations can
	   return ENOTSUP or EINVAL in cases like that. */
	ret = SMB_VFS_FALLOCATE(fsp, 0, pst->st_ex_size, space_to_write);
	if (ret == -1 && errno == ENOSPC) {
		return -1;
	}
	if (ret == 0) {
		return 0;
	}
	DBG_DEBUG("strict_allocate_ftruncate: SMB_VFS_FALLOCATE failed with "
		"error %d. Falling back to slow manual allocation\n", errno);

	/* available disk space is enough or not? */
	space_avail =
	    get_dfree_info(fsp->conn, fsp->fsp_name, &bsize, &dfree, &dsize);
	/* space_avail is 1k blocks */
	if (space_avail == (uint64_t)-1 ||
			((uint64_t)space_to_write/1024 > space_avail) ) {
		errno = ENOSPC;
		return -1;
	}

	/* Write out the real space on disk. */
	ret = vfs_slow_fallocate(fsp, pst->st_ex_size, space_to_write);
	if (ret != 0) {
		return -1;
	}

	return 0;
}

static int vfswrap_ftruncate(vfs_handle_struct *handle, files_struct *fsp, off_t len)
{
	int result = -1;
	SMB_STRUCT_STAT *pst;
	NTSTATUS status;
	char c = 0;

	START_PROFILE(syscall_ftruncate);

	if (lp_strict_allocate(SNUM(fsp->conn)) && !fsp->fsp_flags.is_sparse) {
		result = strict_allocate_ftruncate(handle, fsp, len);
		END_PROFILE(syscall_ftruncate);
		return result;
	}

	/* we used to just check HAVE_FTRUNCATE_EXTEND and only use
	   ftruncate if the system supports it. Then I discovered that
	   you can have some filesystems that support ftruncate
	   expansion and some that don't! On Linux fat can't do
	   ftruncate extend but ext2 can. */

	result = ftruncate(fsp_get_io_fd(fsp), len);

	/* According to W. R. Stevens advanced UNIX prog. Pure 4.3 BSD cannot
	   extend a file with ftruncate. Provide alternate implementation
	   for this */

	/* Do an fstat to see if the file is longer than the requested
	   size in which case the ftruncate above should have
	   succeeded or shorter, in which case seek to len - 1 and
	   write 1 byte of zero */
	status = vfs_stat_fsp(fsp);
	if (!NT_STATUS_IS_OK(status)) {
		goto done;
	}

	/* We need to update the files_struct after successful ftruncate */
	if (result == 0) {
		goto done;
	}

	pst = &fsp->fsp_name->st;

#ifdef S_ISFIFO
	if (S_ISFIFO(pst->st_ex_mode)) {
		result = 0;
		goto done;
	}
#endif

	if (pst->st_ex_size == len) {
		result = 0;
		goto done;
	}

	if (pst->st_ex_size > len) {
		/* the ftruncate should have worked */
		goto done;
	}

	if (SMB_VFS_PWRITE(fsp, &c, 1, len-1)!=1) {
		goto done;
	}

	result = 0;

  done:

	END_PROFILE(syscall_ftruncate);
	return result;
}

static int vfswrap_fallocate(vfs_handle_struct *handle,
			files_struct *fsp,
			uint32_t mode,
			off_t offset,
			off_t len)
{
	int result;

	START_PROFILE(syscall_fallocate);
	if (mode == 0) {
		result = sys_posix_fallocate(fsp_get_io_fd(fsp), offset, len);
		/*
		 * posix_fallocate returns 0 on success, errno on error
		 * and doesn't set errno. Make it behave like fallocate()
		 * which returns -1, and sets errno on failure.
		 */
		if (result != 0) {
			errno = result;
			result = -1;
		}
	} else {
		/* sys_fallocate handles filtering of unsupported mode flags */
		result = sys_fallocate(fsp_get_io_fd(fsp), mode, offset, len);
	}
	END_PROFILE(syscall_fallocate);
	return result;
}

static bool vfswrap_lock(vfs_handle_struct *handle, files_struct *fsp, int op, off_t offset, off_t count, int type)
{
	bool result;

	START_PROFILE(syscall_fcntl_lock);

	if (fsp->fsp_flags.use_ofd_locks) {
		op = map_process_lock_to_ofd_lock(op);
	}

	result =  fcntl_lock(fsp_get_io_fd(fsp), op, offset, count, type);
	END_PROFILE(syscall_fcntl_lock);
	return result;
}

static int vfswrap_filesystem_sharemode(vfs_handle_struct *handle,
					files_struct *fsp,
					uint32_t share_access,
					uint32_t access_mask)
{
	errno = ENOTSUP;
	return -1;
}

static int vfswrap_fcntl(vfs_handle_struct *handle, files_struct *fsp, int cmd,
			 va_list cmd_arg)
{
	void *argp;
	va_list dup_cmd_arg;
	int result;
	int val;

	START_PROFILE(syscall_fcntl);

	va_copy(dup_cmd_arg, cmd_arg);

	switch(cmd) {
	case F_SETLK:
	case F_SETLKW:
	case F_GETLK:
#if defined(HAVE_OFD_LOCKS)
	case F_OFD_SETLK:
	case F_OFD_SETLKW:
	case F_OFD_GETLK:
#endif
#if defined(HAVE_F_OWNER_EX)
	case F_GETOWN_EX:
	case F_SETOWN_EX:
#endif
#if defined(HAVE_RW_HINTS)
	case F_GET_RW_HINT:
	case F_SET_RW_HINT:
	case F_GET_FILE_RW_HINT:
	case F_SET_FILE_RW_HINT:
#endif
		argp = va_arg(dup_cmd_arg, void *);
		result = sys_fcntl_ptr(fsp_get_io_fd(fsp), cmd, argp);
		break;
	default:
		val = va_arg(dup_cmd_arg, int);
		result = sys_fcntl_int(fsp_get_io_fd(fsp), cmd, val);
	}

	va_end(dup_cmd_arg);

	END_PROFILE(syscall_fcntl);
	return result;
}

static bool vfswrap_getlock(vfs_handle_struct *handle, files_struct *fsp, off_t *poffset, off_t *pcount, int *ptype, pid_t *ppid)
{
	bool result;
	int op = F_GETLK;

	START_PROFILE(syscall_fcntl_getlock);

	if (fsp->fsp_flags.use_ofd_locks) {
		op = map_process_lock_to_ofd_lock(op);
	}

	result = fcntl_getlock(fsp_get_io_fd(fsp), op, poffset, pcount, ptype, ppid);
	END_PROFILE(syscall_fcntl_getlock);
	return result;
}

static int vfswrap_linux_setlease(vfs_handle_struct *handle, files_struct *fsp,
				int leasetype)
{
	int result = -1;

	START_PROFILE(syscall_linux_setlease);

	SMB_ASSERT(!fsp_is_alternate_stream(fsp));

#ifdef HAVE_KERNEL_OPLOCKS_LINUX
	result = linux_setlease(fsp_get_io_fd(fsp), leasetype);
#else
	errno = ENOSYS;
#endif
	END_PROFILE(syscall_linux_setlease);
	return result;
}

static int vfswrap_symlinkat(vfs_handle_struct *handle,
			const struct smb_filename *link_target,
			struct files_struct *dirfsp,
			const struct smb_filename *new_smb_fname)
{
	int result;

	START_PROFILE(syscall_symlinkat);

	SMB_ASSERT(!is_named_stream(new_smb_fname));

	result = symlinkat(link_target->base_name,
			fsp_get_pathref_fd(dirfsp),
			new_smb_fname->base_name);
	END_PROFILE(syscall_symlinkat);
	return result;
}

static int vfswrap_readlinkat(vfs_handle_struct *handle,
			const struct files_struct *dirfsp,
			const struct smb_filename *smb_fname,
			char *buf,
			size_t bufsiz)
{
	int result;

	START_PROFILE(syscall_readlinkat);

	SMB_ASSERT(!is_named_stream(smb_fname));

	result = readlinkat(fsp_get_pathref_fd(dirfsp),
			smb_fname->base_name,
			buf,
			bufsiz);

	END_PROFILE(syscall_readlinkat);
	return result;
}

static int vfswrap_linkat(vfs_handle_struct *handle,
			files_struct *srcfsp,
			const struct smb_filename *old_smb_fname,
			files_struct *dstfsp,
			const struct smb_filename *new_smb_fname,
			int flags)
{
	int result;

	START_PROFILE(syscall_linkat);

	SMB_ASSERT(!is_named_stream(old_smb_fname));
	SMB_ASSERT(!is_named_stream(new_smb_fname));

	result = linkat(fsp_get_pathref_fd(srcfsp),
			old_smb_fname->base_name,
			fsp_get_pathref_fd(dstfsp),
			new_smb_fname->base_name,
			flags);

	END_PROFILE(syscall_linkat);
	return result;
}

static int vfswrap_mknodat(vfs_handle_struct *handle,
			files_struct *dirfsp,
			const struct smb_filename *smb_fname,
			mode_t mode,
			SMB_DEV_T dev)
{
	int result;

	START_PROFILE(syscall_mknodat);

	SMB_ASSERT(!is_named_stream(smb_fname));

	result = sys_mknodat(fsp_get_pathref_fd(dirfsp),
			smb_fname->base_name,
			mode,
			dev);

	END_PROFILE(syscall_mknodat);
	return result;
}

static struct smb_filename *vfswrap_realpath(vfs_handle_struct *handle,
			TALLOC_CTX *ctx,
			const struct smb_filename *smb_fname)
{
	char *result;
	struct smb_filename *result_fname = NULL;

	START_PROFILE(syscall_realpath);
	result = sys_realpath(smb_fname->base_name);
	END_PROFILE(syscall_realpath);
	if (result) {
		result_fname = synthetic_smb_fname(ctx,
						   result,
						   NULL,
						   NULL,
						   0,
						   0);
		SAFE_FREE(result);
	}
	return result_fname;
}

static int vfswrap_fchflags(vfs_handle_struct *handle,
			struct files_struct *fsp,
			unsigned int flags)
{
#ifdef HAVE_FCHFLAGS
	int fd = fsp_get_pathref_fd(fsp);

	SMB_ASSERT(!fsp_is_alternate_stream(fsp));

	if (!fsp->fsp_flags.is_pathref) {
		return fchflags(fd, flags);
	}

	if (fsp->fsp_flags.have_proc_fds) {
		struct sys_proc_fd_path_buf buf;

		return chflags(sys_proc_fd_path(fd, &buf), flags);
	}

	/*
	 * This is no longer a handle based call.
	 */
	return chflags(fsp->fsp_name->base_name, flags);
#else
	errno = ENOSYS;
	return -1;
#endif
}

static struct file_id vfswrap_file_id_create(struct vfs_handle_struct *handle,
					     const SMB_STRUCT_STAT *sbuf)
{
	struct file_id key;

	/* the ZERO_STRUCT ensures padding doesn't break using the key as a
	 * blob */
	ZERO_STRUCT(key);

	key.devid = sbuf->st_ex_dev;
	key.inode = sbuf->st_ex_ino;
	/* key.extid is unused by default. */

	return key;
}

static uint64_t vfswrap_fs_file_id(struct vfs_handle_struct *handle,
				   const SMB_STRUCT_STAT *psbuf)
{
	uint64_t file_id;

	if (handle->conn->base_share_dev == psbuf->st_ex_dev) {
		return (uint64_t)psbuf->st_ex_ino;
	}

	/* FileIDLow */
	file_id = ((psbuf->st_ex_ino) & UINT32_MAX);

	/* FileIDHigh */
	file_id |= ((uint64_t)((psbuf->st_ex_dev) & UINT32_MAX)) << 32;

	return file_id;
}

static NTSTATUS vfswrap_fstreaminfo(vfs_handle_struct *handle,
				   struct files_struct *fsp,
				   TALLOC_CTX *mem_ctx,
				   unsigned int *pnum_streams,
				   struct stream_struct **pstreams)
{
	struct stream_struct *tmp_streams = NULL;
	unsigned int num_streams = *pnum_streams;
	struct stream_struct *streams = *pstreams;
	NTSTATUS status;

	SMB_ASSERT(!fsp_is_alternate_stream(fsp));

	if (fsp->fsp_flags.is_directory) {
		/*
		 * No default streams on directories
		 */
		goto done;
	}
	status = vfs_stat_fsp(fsp);
	if (!NT_STATUS_IS_OK(status)) {
		return status;
	}

	if (num_streams + 1 < 1) {
		/* Integer wrap. */
		return NT_STATUS_INVALID_PARAMETER;
	}

	tmp_streams = talloc_realloc(mem_ctx,
					streams,
					struct stream_struct,
					num_streams + 1);
	if (tmp_streams == NULL) {
		return NT_STATUS_NO_MEMORY;
	}
	tmp_streams[num_streams].name = talloc_strdup(tmp_streams, "::$DATA");
	if (tmp_streams[num_streams].name == NULL) {
		return NT_STATUS_NO_MEMORY;
	}
	tmp_streams[num_streams].size = fsp->fsp_name->st.st_ex_size;
	tmp_streams[num_streams].alloc_size = SMB_VFS_GET_ALLOC_SIZE(
						handle->conn,
						fsp,
						&fsp->fsp_name->st);
	num_streams += 1;

	*pnum_streams = num_streams;
	*pstreams = tmp_streams;
 done:
	return NT_STATUS_OK;
}

static NTSTATUS vfswrap_get_real_filename_at(
	struct vfs_handle_struct *handle,
	struct files_struct *dirfsp,
	const char *name,
	TALLOC_CTX *mem_ctx,
	char **found_name)
{
	/*
	 * Don't fall back to get_real_filename so callers can differentiate
	 * between a full directory scan and an actual case-insensitive stat.
	 */
	return NT_STATUS_NOT_SUPPORTED;
}

static const char *vfswrap_connectpath(struct vfs_handle_struct *handle,
				   const struct files_struct *dirfsp,
				   const struct smb_filename *smb_fname)
{
	return handle->conn->connectpath;
}

static NTSTATUS vfswrap_brl_lock_windows(struct vfs_handle_struct *handle,
					 struct byte_range_lock *br_lck,
					 struct lock_struct *plock)
{
	SMB_ASSERT(plock->lock_flav == WINDOWS_LOCK);

	/* Note: blr is not used in the default implementation. */
	return brl_lock_windows_default(br_lck, plock);
}

static bool vfswrap_brl_unlock_windows(struct vfs_handle_struct *handle,
				       struct byte_range_lock *br_lck,
			               const struct lock_struct *plock)
{
	SMB_ASSERT(plock->lock_flav == WINDOWS_LOCK);

	return brl_unlock_windows_default(br_lck, plock);
}

static bool vfswrap_strict_lock_check(struct vfs_handle_struct *handle,
				      files_struct *fsp,
				      struct lock_struct *plock)
{
	SMB_ASSERT(plock->lock_type == READ_LOCK ||
	    plock->lock_type == WRITE_LOCK);

	return strict_lock_check_default(fsp, plock);
}

/* NT ACL operations. */

static NTSTATUS vfswrap_fget_nt_acl(vfs_handle_struct *handle,
				    files_struct *fsp,
				    uint32_t security_info,
				    TALLOC_CTX *mem_ctx,
				    struct security_descriptor **ppdesc)
{
	NTSTATUS result;

	START_PROFILE(fget_nt_acl);

	SMB_ASSERT(!fsp_is_alternate_stream(fsp));

	result = posix_fget_nt_acl(fsp, security_info,
				   mem_ctx, ppdesc);
	END_PROFILE(fget_nt_acl);
	return result;
}

static NTSTATUS vfswrap_fset_nt_acl(vfs_handle_struct *handle, files_struct *fsp, uint32_t security_info_sent, const struct security_descriptor *psd)
{
	NTSTATUS result;

	START_PROFILE(fset_nt_acl);

	SMB_ASSERT(!fsp_is_alternate_stream(fsp));

	result = set_nt_acl(fsp, security_info_sent, psd);
	END_PROFILE(fset_nt_acl);
	return result;
}

static NTSTATUS vfswrap_audit_file(struct vfs_handle_struct *handle,
				   struct smb_filename *file,
				   struct security_acl *sacl,
				   uint32_t access_requested,
				   uint32_t access_denied)
{
	return NT_STATUS_OK; /* Nothing to do here ... */
}

static SMB_ACL_T vfswrap_sys_acl_get_fd(vfs_handle_struct *handle,
					files_struct *fsp,
					SMB_ACL_TYPE_T type,
					TALLOC_CTX *mem_ctx)
{
	SMB_ASSERT(!fsp_is_alternate_stream(fsp));

	return sys_acl_get_fd(handle, fsp, type, mem_ctx);
}

static int vfswrap_sys_acl_set_fd(vfs_handle_struct *handle,
				  files_struct *fsp,
				  SMB_ACL_TYPE_T type,
				  SMB_ACL_T theacl)
{
	SMB_ASSERT(!fsp_is_alternate_stream(fsp));

	return sys_acl_set_fd(handle, fsp, type, theacl);
}

static int vfswrap_sys_acl_delete_def_fd(vfs_handle_struct *handle,
					 files_struct *fsp)
{
	SMB_ASSERT(!fsp_is_alternate_stream(fsp));

	return sys_acl_delete_def_fd(handle, fsp);
}

/****************************************************************
 Extended attribute operations.
*****************************************************************/

static ssize_t vfswrap_fgetxattr(struct vfs_handle_struct *handle,
				 struct files_struct *fsp,
				 const char *name,
				 void *value,
				 size_t size)
{
	int fd = fsp_get_pathref_fd(fsp);

	SMB_ASSERT(!fsp_is_alternate_stream(fsp));

	if (!fsp->fsp_flags.is_pathref) {
		return fgetxattr(fd, name, value, size);
	}

	if (fsp->fsp_flags.have_proc_fds) {
		struct sys_proc_fd_path_buf buf;

		return getxattr(sys_proc_fd_path(fd, &buf), name, value, size);
	}

	/*
	 * This is no longer a handle based call.
	 */
	return getxattr(fsp->fsp_name->base_name, name, value, size);
}

struct vfswrap_getxattrat_state {
	struct tevent_context *ev;
	struct vfs_handle_struct *handle;
	files_struct *dir_fsp;
	const struct smb_filename *smb_fname;

	/*
	 * The following variables are talloced off "state" which is protected
	 * by a destructor and thus are guaranteed to be safe to be used in the
	 * job function in the worker thread.
	 */
	char *name;
	const char *xattr_name;
	uint8_t *xattr_value;
	struct security_unix_token *token;

	ssize_t xattr_size;
	struct vfs_aio_state vfs_aio_state;
	SMBPROFILE_BYTES_ASYNC_STATE(profile_bytes);
};

static int vfswrap_getxattrat_state_destructor(
		struct vfswrap_getxattrat_state *state)
{
	return -1;
}

static void vfswrap_getxattrat_do_sync(struct tevent_req *req);
static void vfswrap_getxattrat_do_async(void *private_data);
static void vfswrap_getxattrat_done(struct tevent_req *subreq);

static struct tevent_req *vfswrap_getxattrat_send(
			TALLOC_CTX *mem_ctx,
			struct tevent_context *ev,
			struct vfs_handle_struct *handle,
			files_struct *dir_fsp,
			const struct smb_filename *smb_fname,
			const char *xattr_name,
			size_t alloc_hint)
{
	struct tevent_req *req = NULL;
	struct tevent_req *subreq = NULL;
	struct vfswrap_getxattrat_state *state = NULL;
	size_t max_threads = 0;
	bool have_per_thread_cwd = false;
	bool have_per_thread_creds = false;
	bool do_async = false;

	SMB_ASSERT(!is_named_stream(smb_fname));

	req = tevent_req_create(mem_ctx, &state,
				struct vfswrap_getxattrat_state);
	if (req == NULL) {
		return NULL;
	}
	*state = (struct vfswrap_getxattrat_state) {
		.ev = ev,
		.handle = handle,
		.dir_fsp = dir_fsp,
		.smb_fname = smb_fname,
	};

	max_threads = pthreadpool_tevent_max_threads(dir_fsp->conn->sconn->pool);
	if (max_threads >= 1) {
		/*
		 * We need a non sync threadpool!
		 */
		have_per_thread_cwd = per_thread_cwd_supported();
	}
#ifdef HAVE_LINUX_THREAD_CREDENTIALS
	have_per_thread_creds = true;
#endif
	if (have_per_thread_cwd && have_per_thread_creds) {
		do_async = true;
	}

	SMBPROFILE_BYTES_ASYNC_START(syscall_asys_getxattrat, profile_p,
				     state->profile_bytes, 0);

	if (fsp_get_pathref_fd(dir_fsp) == -1) {
		DBG_ERR("Need a valid directory fd\n");
		tevent_req_error(req, EINVAL);
		return tevent_req_post(req, ev);
	}

	if (alloc_hint > 0) {
		state->xattr_value = talloc_zero_array(state,
						       uint8_t,
						       alloc_hint);
		if (tevent_req_nomem(state->xattr_value, req)) {
			return tevent_req_post(req, ev);
		}
	}

	if (!do_async) {
		vfswrap_getxattrat_do_sync(req);
		return tevent_req_post(req, ev);
	}

	/*
	 * Now allocate all parameters from a memory context that won't go away
	 * no matter what. These parameters will get used in threads and we
	 * can't reliably cancel threads, so all buffers passed to the threads
	 * must not be freed before all referencing threads terminate.
	 */

	state->name = talloc_strdup(state, smb_fname->base_name);
	if (tevent_req_nomem(state->name, req)) {
		return tevent_req_post(req, ev);
	}

	state->xattr_name = talloc_strdup(state, xattr_name);
	if (tevent_req_nomem(state->xattr_name, req)) {
		return tevent_req_post(req, ev);
	}

	/*
	 * This is a hot codepath so at first glance one might think we should
	 * somehow optimize away the token allocation and do a
	 * talloc_reference() or similar black magic instead. But due to the
	 * talloc_stackframe pool per SMB2 request this should be a simple copy
	 * without a malloc in most cases.
	 */
	if (geteuid() == sec_initial_uid()) {
		state->token = root_unix_token(state);
	} else {
		state->token = copy_unix_token(
					state,
					dir_fsp->conn->session_info->unix_token);
	}
	if (tevent_req_nomem(state->token, req)) {
		return tevent_req_post(req, ev);
	}

	SMBPROFILE_BYTES_ASYNC_SET_IDLE(state->profile_bytes);

	subreq = pthreadpool_tevent_job_send(
			state,
			ev,
			dir_fsp->conn->sconn->pool,
			vfswrap_getxattrat_do_async,
			state);
	if (tevent_req_nomem(subreq, req)) {
		return tevent_req_post(req, ev);
	}
	tevent_req_set_callback(subreq, vfswrap_getxattrat_done, req);

	talloc_set_destructor(state, vfswrap_getxattrat_state_destructor);

	return req;
}

static void vfswrap_getxattrat_do_sync(struct tevent_req *req)
{
	struct vfswrap_getxattrat_state *state = tevent_req_data(
		req, struct vfswrap_getxattrat_state);

	state->xattr_size = vfswrap_fgetxattr(state->handle,
					      state->smb_fname->fsp,
					      state->xattr_name,
					      state->xattr_value,
					      talloc_array_length(state->xattr_value));
	if (state->xattr_size == -1) {
		tevent_req_error(req, errno);
		return;
	}

	tevent_req_done(req);
	return;
}

static void vfswrap_getxattrat_do_async(void *private_data)
{
	struct vfswrap_getxattrat_state *state = talloc_get_type_abort(
		private_data, struct vfswrap_getxattrat_state);
	struct timespec start_time;
	struct timespec end_time;
	int ret;

	PROFILE_TIMESTAMP(&start_time);
	SMBPROFILE_BYTES_ASYNC_SET_BUSY(state->profile_bytes);

	/*
	 * Here we simulate a getxattrat()
	 * call using fchdir();getxattr()
	 */

	per_thread_cwd_activate();

	/* Become the correct credential on this thread. */
	ret = set_thread_credentials(state->token->uid,
				     state->token->gid,
				     (size_t)state->token->ngroups,
				     state->token->groups);
	if (ret != 0) {
		state->xattr_size = -1;
		state->vfs_aio_state.error = errno;
		goto end_profile;
	}

	state->xattr_size = vfswrap_fgetxattr(state->handle,
					      state->smb_fname->fsp,
					      state->xattr_name,
					      state->xattr_value,
					      talloc_array_length(state->xattr_value));
	if (state->xattr_size == -1) {
		state->vfs_aio_state.error = errno;
	}

end_profile:
	PROFILE_TIMESTAMP(&end_time);
	state->vfs_aio_state.duration = nsec_time_diff(&end_time, &start_time);
	SMBPROFILE_BYTES_ASYNC_SET_IDLE(state->profile_bytes);
}

static void vfswrap_getxattrat_done(struct tevent_req *subreq)
{
	struct tevent_req *req = tevent_req_callback_data(
		subreq, struct tevent_req);
	struct vfswrap_getxattrat_state *state = tevent_req_data(
		req, struct vfswrap_getxattrat_state);
	int ret;
	bool ok;

	/*
	 * Make sure we run as the user again
	 */
	ok = change_to_user_and_service_by_fsp(state->dir_fsp);
	SMB_ASSERT(ok);

	ret = pthreadpool_tevent_job_recv(subreq);
	TALLOC_FREE(subreq);
	SMBPROFILE_BYTES_ASYNC_END(state->profile_bytes);
	talloc_set_destructor(state, NULL);
	if (ret != 0) {
		if (ret != EAGAIN) {
			tevent_req_error(req, ret);
			return;
		}
		/*
		 * If we get EAGAIN from pthreadpool_tevent_job_recv() this
		 * means the lower level pthreadpool failed to create a new
		 * thread. Fallback to sync processing in that case to allow
		 * some progress for the client.
		 */
		vfswrap_getxattrat_do_sync(req);
		return;
	}

	if (state->xattr_size == -1) {
		tevent_req_error(req, state->vfs_aio_state.error);
		return;
	}

	if (state->xattr_value == NULL) {
		/*
		 * The caller only wanted the size.
		 */
		tevent_req_done(req);
		return;
	}

	/*
	 * shrink the buffer to the returned size.
	 * (can't fail). It means NULL if size is 0.
	 */
	state->xattr_value = talloc_realloc(state,
					    state->xattr_value,
					    uint8_t,
					    state->xattr_size);

	tevent_req_done(req);
}

static ssize_t vfswrap_getxattrat_recv(struct tevent_req *req,
				       struct vfs_aio_state *aio_state,
				       TALLOC_CTX *mem_ctx,
				       uint8_t **xattr_value)
{
	struct vfswrap_getxattrat_state *state = tevent_req_data(
		req, struct vfswrap_getxattrat_state);
	ssize_t xattr_size;

	if (tevent_req_is_unix_error(req, &aio_state->error)) {
		tevent_req_received(req);
		return -1;
	}

	*aio_state = state->vfs_aio_state;
	xattr_size = state->xattr_size;
	if (xattr_value != NULL) {
		*xattr_value = talloc_move(mem_ctx, &state->xattr_value);
	}

	tevent_req_received(req);
	return xattr_size;
}

static ssize_t vfswrap_flistxattr(struct vfs_handle_struct *handle, struct files_struct *fsp, char *list, size_t size)
{
	int fd = fsp_get_pathref_fd(fsp);

	SMB_ASSERT(!fsp_is_alternate_stream(fsp));

	if (!fsp->fsp_flags.is_pathref) {
		return flistxattr(fd, list, size);
	}

	if (fsp->fsp_flags.have_proc_fds) {
		struct sys_proc_fd_path_buf buf;

		return listxattr(sys_proc_fd_path(fd, &buf), list, size);
	}

	/*
	 * This is no longer a handle based call.
	 */
	return listxattr(fsp->fsp_name->base_name, list, size);
}

static int vfswrap_fremovexattr(struct vfs_handle_struct *handle, struct files_struct *fsp, const char *name)
{
	int fd = fsp_get_pathref_fd(fsp);

	SMB_ASSERT(!fsp_is_alternate_stream(fsp));

	if (!fsp->fsp_flags.is_pathref) {
		return fremovexattr(fd, name);
	}

	if (fsp->fsp_flags.have_proc_fds) {
		struct sys_proc_fd_path_buf buf;

		return removexattr(sys_proc_fd_path(fd, &buf), name);
	}

	/*
	 * This is no longer a handle based call.
	 */
	return removexattr(fsp->fsp_name->base_name, name);
}

static int vfswrap_fsetxattr(struct vfs_handle_struct *handle, struct files_struct *fsp, const char *name, const void *value, size_t size, int flags)
{
	int fd = fsp_get_pathref_fd(fsp);

	SMB_ASSERT(!fsp_is_alternate_stream(fsp));

	if (!fsp->fsp_flags.is_pathref) {
		return fsetxattr(fd, name, value, size, flags);
	}

	if (fsp->fsp_flags.have_proc_fds) {
		struct sys_proc_fd_path_buf buf;

		return setxattr(sys_proc_fd_path(fd, &buf),
				name,
				value,
				size,
				flags);
	}

	/*
	 * This is no longer a handle based call.
	 */
	return setxattr(fsp->fsp_name->base_name, name, value, size, flags);
}

static bool vfswrap_aio_force(struct vfs_handle_struct *handle, struct files_struct *fsp)
{
	return false;
}

static bool vfswrap_is_offline(struct connection_struct *conn,
			       const struct smb_filename *fname)
{
	NTSTATUS status;
	char *path;
	bool offline = false;

        if (ISDOT(fname->base_name) || ISDOTDOT(fname->base_name)) {
		return false;
	}

	if (!lp_dmapi_support(SNUM(conn)) || !dmapi_have_session()) {
#if defined(ENOTSUP)
		errno = ENOTSUP;
#endif
		return false;
	}

        status = get_full_smb_filename(talloc_tos(), fname, &path);
        if (!NT_STATUS_IS_OK(status)) {
                errno = map_errno_from_nt_status(status);
                return false;
        }

	offline = (dmapi_file_flags(path) & FILE_ATTRIBUTE_OFFLINE) != 0;

	TALLOC_FREE(path);

	return offline;
}

static NTSTATUS vfswrap_durable_cookie(struct vfs_handle_struct *handle,
				       struct files_struct *fsp,
				       TALLOC_CTX *mem_ctx,
				       DATA_BLOB *cookie)
{
	return vfs_default_durable_cookie(fsp, mem_ctx, cookie);
}

static NTSTATUS vfswrap_durable_disconnect(struct vfs_handle_struct *handle,
					   struct files_struct *fsp,
					   const DATA_BLOB old_cookie,
					   TALLOC_CTX *mem_ctx,
					   DATA_BLOB *new_cookie)
{
	return vfs_default_durable_disconnect(fsp, old_cookie, mem_ctx,
					      new_cookie);
}

static NTSTATUS vfswrap_durable_reconnect(struct vfs_handle_struct *handle,
					  struct smb_request *smb1req,
					  struct smbXsrv_open *op,
					  const DATA_BLOB old_cookie,
					  TALLOC_CTX *mem_ctx,
					  struct files_struct **fsp,
					  DATA_BLOB *new_cookie)
{
	return vfs_default_durable_reconnect(handle->conn, smb1req, op,
					     old_cookie, mem_ctx,
					     fsp, new_cookie);
}

static struct vfs_fn_pointers vfs_default_fns = {
	/* Disk operations */

	.connect_fn = vfswrap_connect,
	.disconnect_fn = vfswrap_disconnect,
	.disk_free_fn = vfswrap_disk_free,
	.get_quota_fn = vfswrap_get_quota,
	.set_quota_fn = vfswrap_set_quota,
	.get_shadow_copy_data_fn = vfswrap_get_shadow_copy_data,
	.statvfs_fn = vfswrap_statvfs,
	.fs_capabilities_fn = vfswrap_fs_capabilities,
	.get_dfs_referrals_fn = vfswrap_get_dfs_referrals,
	.create_dfs_pathat_fn = vfswrap_create_dfs_pathat,
	.read_dfs_pathat_fn = vfswrap_read_dfs_pathat,
	.snap_check_path_fn = vfswrap_snap_check_path,
	.snap_create_fn = vfswrap_snap_create,
	.snap_delete_fn = vfswrap_snap_delete,

	/* Directory operations */

	.fdopendir_fn = vfswrap_fdopendir,
	.readdir_fn = vfswrap_readdir,
	.freaddir_attr_fn = vfswrap_freaddir_attr,
	.rewind_dir_fn = vfswrap_rewinddir,
	.mkdirat_fn = vfswrap_mkdirat,
	.closedir_fn = vfswrap_closedir,

	/* File operations */

	.openat_fn = vfswrap_openat,
	.create_file_fn = vfswrap_create_file,
	.close_fn = vfswrap_close,
	.pread_fn = vfswrap_pread,
	.pread_send_fn = vfswrap_pread_send,
	.pread_recv_fn = vfswrap_pread_recv,
	.pwrite_fn = vfswrap_pwrite,
	.pwrite_send_fn = vfswrap_pwrite_send,
	.pwrite_recv_fn = vfswrap_pwrite_recv,
	.lseek_fn = vfswrap_lseek,
	.sendfile_fn = vfswrap_sendfile,
	.recvfile_fn = vfswrap_recvfile,
	.renameat_fn = vfswrap_renameat,
	.fsync_send_fn = vfswrap_fsync_send,
	.fsync_recv_fn = vfswrap_fsync_recv,
	.stat_fn = vfswrap_stat,
	.fstat_fn = vfswrap_fstat,
	.lstat_fn = vfswrap_lstat,
	.fstatat_fn = vfswrap_fstatat,
	.get_alloc_size_fn = vfswrap_get_alloc_size,
	.unlinkat_fn = vfswrap_unlinkat,
	.fchmod_fn = vfswrap_fchmod,
	.fchown_fn = vfswrap_fchown,
	.lchown_fn = vfswrap_lchown,
	.chdir_fn = vfswrap_chdir,
	.getwd_fn = vfswrap_getwd,
	.fntimes_fn = vfswrap_fntimes,
	.ftruncate_fn = vfswrap_ftruncate,
	.fallocate_fn = vfswrap_fallocate,
	.lock_fn = vfswrap_lock,
	.filesystem_sharemode_fn = vfswrap_filesystem_sharemode,
	.fcntl_fn = vfswrap_fcntl,
	.linux_setlease_fn = vfswrap_linux_setlease,
	.getlock_fn = vfswrap_getlock,
	.symlinkat_fn = vfswrap_symlinkat,
	.readlinkat_fn = vfswrap_readlinkat,
	.linkat_fn = vfswrap_linkat,
	.mknodat_fn = vfswrap_mknodat,
	.realpath_fn = vfswrap_realpath,
	.fchflags_fn = vfswrap_fchflags,
	.file_id_create_fn = vfswrap_file_id_create,
	.fs_file_id_fn = vfswrap_fs_file_id,
	.fstreaminfo_fn = vfswrap_fstreaminfo,
	.get_real_filename_at_fn = vfswrap_get_real_filename_at,
	.connectpath_fn = vfswrap_connectpath,
	.brl_lock_windows_fn = vfswrap_brl_lock_windows,
	.brl_unlock_windows_fn = vfswrap_brl_unlock_windows,
	.strict_lock_check_fn = vfswrap_strict_lock_check,
	.translate_name_fn = vfswrap_translate_name,
	.parent_pathname_fn = vfswrap_parent_pathname,
	.fsctl_fn = vfswrap_fsctl,
	.fset_dos_attributes_fn = vfswrap_fset_dos_attributes,
	.get_dos_attributes_send_fn = vfswrap_get_dos_attributes_send,
	.get_dos_attributes_recv_fn = vfswrap_get_dos_attributes_recv,
	.fget_dos_attributes_fn = vfswrap_fget_dos_attributes,
	.offload_read_send_fn = vfswrap_offload_read_send,
	.offload_read_recv_fn = vfswrap_offload_read_recv,
	.offload_write_send_fn = vfswrap_offload_write_send,
	.offload_write_recv_fn = vfswrap_offload_write_recv,
	.fget_compression_fn = vfswrap_fget_compression,
	.set_compression_fn = vfswrap_set_compression,

	/* NT ACL operations. */

	.fget_nt_acl_fn = vfswrap_fget_nt_acl,
	.fset_nt_acl_fn = vfswrap_fset_nt_acl,
	.audit_file_fn = vfswrap_audit_file,

	/* POSIX ACL operations. */

	.sys_acl_get_fd_fn = vfswrap_sys_acl_get_fd,
	.sys_acl_blob_get_fd_fn = posix_sys_acl_blob_get_fd,
	.sys_acl_set_fd_fn = vfswrap_sys_acl_set_fd,
	.sys_acl_delete_def_fd_fn = vfswrap_sys_acl_delete_def_fd,

	/* EA operations. */
	.getxattrat_send_fn = vfswrap_getxattrat_send,
	.getxattrat_recv_fn = vfswrap_getxattrat_recv,
	.fgetxattr_fn = vfswrap_fgetxattr,
	.flistxattr_fn = vfswrap_flistxattr,
	.fremovexattr_fn = vfswrap_fremovexattr,
	.fsetxattr_fn = vfswrap_fsetxattr,

	/* aio operations */
	.aio_force_fn = vfswrap_aio_force,

	/* durable handle operations */
	.durable_cookie_fn = vfswrap_durable_cookie,
	.durable_disconnect_fn = vfswrap_durable_disconnect,
	.durable_reconnect_fn = vfswrap_durable_reconnect,
};

static_decl_vfs;
NTSTATUS vfs_default_init(TALLOC_CTX *ctx)
{
	/*
	 * Here we need to implement every call!
	 *
	 * As this is the end of the vfs module chain.
	 */
	smb_vfs_assert_all_fns(&vfs_default_fns, DEFAULT_VFS_MODULE_NAME);
	return smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
				DEFAULT_VFS_MODULE_NAME, &vfs_default_fns);
}