Adding upstream version 2:4.20.0+dfsg.upstream/2%4.20.0+dfsg

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 608 insertions, 0 deletions

diff --git a/source3/smbd/smb2_aio.c b/source3/smbd/smb2_aio.c
new file mode 100644
index 0000000..88aa68d
--- /dev/null
+++ b/source3/smbd/smb2_aio.c
@@ -0,0 +1,608 @@
+/*
+   Unix SMB/Netbios implementation.
+   Version 3.0
+   async_io read handling using POSIX async io.
+   Copyright (C) Jeremy Allison 2005.
+
+   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 "smbd/smbd.h"
+#include "smbd/globals.h"
+#include "../lib/util/tevent_ntstatus.h"
+#include "../lib/util/tevent_unix.h"
+
+/****************************************************************************
+ Accessor function to return write_through state.
+*****************************************************************************/
+
+bool aio_write_through_requested(struct aio_extra *aio_ex)
+{
+	return aio_ex->write_through;
+}
+
+/****************************************************************************
+ Create the extended aio struct we must keep around for the lifetime
+ of the aio call.
+*****************************************************************************/
+
+struct aio_extra *create_aio_extra(TALLOC_CTX *mem_ctx,
+				   files_struct *fsp,
+				   size_t buflen)
+{
+	struct aio_extra *aio_ex = talloc_zero(mem_ctx, struct aio_extra);
+
+	if (!aio_ex) {
+		return NULL;
+	}
+
+	/* The output buffer stored in the aio_ex is the start of
+	   the smb return buffer. The buffer used in the acb
+	   is the start of the reply data portion of that buffer. */
+
+	if (buflen) {
+		aio_ex->outbuf = data_blob_talloc(aio_ex, NULL, buflen);
+		if (!aio_ex->outbuf.data) {
+			TALLOC_FREE(aio_ex);
+			return NULL;
+		}
+	}
+	aio_ex->fsp = fsp;
+	return aio_ex;
+}
+
+struct aio_req_fsp_link {
+#ifdef DEVELOPER
+	struct smbd_server_connection *sconn;
+#endif
+	files_struct *fsp;
+	struct tevent_req *req;
+};
+
+static int aio_del_req_from_fsp(struct aio_req_fsp_link *lnk)
+{
+	unsigned i;
+	files_struct *fsp = lnk->fsp;
+	struct tevent_req *req = lnk->req;
+
+#ifdef DEVELOPER
+	struct files_struct *ifsp = NULL;
+	bool found = false;
+
+	/*
+	 * When this is called, lnk->fsp must still exist
+	 * on the files list for this connection. Panic if not.
+	 */
+	for (ifsp = lnk->sconn->files; ifsp; ifsp = ifsp->next) {
+		if (ifsp == fsp) {
+			found = true;
+		}
+	}
+	if (!found) {
+		smb_panic("orphaned lnk on fsp aio list.\n");
+	}
+#endif
+
+	for (i=0; i<fsp->num_aio_requests; i++) {
+		if (fsp->aio_requests[i] == req) {
+			break;
+		}
+	}
+	if (i == fsp->num_aio_requests) {
+		DEBUG(1, ("req %p not found in fsp %p\n", req, fsp));
+		return 0;
+	}
+	fsp->num_aio_requests -= 1;
+	fsp->aio_requests[i] = fsp->aio_requests[fsp->num_aio_requests];
+
+	if (fsp->num_aio_requests == 0) {
+		TALLOC_FREE(fsp->aio_requests);
+	}
+	return 0;
+}
+
+bool aio_add_req_to_fsp(files_struct *fsp, struct tevent_req *req)
+{
+	size_t array_len;
+	struct aio_req_fsp_link *lnk;
+
+	lnk = talloc(req, struct aio_req_fsp_link);
+	if (lnk == NULL) {
+		return false;
+	}
+
+	array_len = talloc_array_length(fsp->aio_requests);
+	if (array_len <= fsp->num_aio_requests) {
+		struct tevent_req **tmp;
+
+		if (fsp->num_aio_requests + 10 < 10) {
+			/* Integer wrap. */
+			TALLOC_FREE(lnk);
+			return false;
+		}
+
+		/*
+		 * Allocate in blocks of 10 so we don't allocate
+		 * on every aio request.
+		 */
+		tmp = talloc_realloc(
+			fsp, fsp->aio_requests, struct tevent_req *,
+			fsp->num_aio_requests+10);
+		if (tmp == NULL) {
+			TALLOC_FREE(lnk);
+			return false;
+		}
+		fsp->aio_requests = tmp;
+	}
+	fsp->aio_requests[fsp->num_aio_requests] = req;
+	fsp->num_aio_requests += 1;
+
+	lnk->fsp = fsp;
+	lnk->req = req;
+#ifdef DEVELOPER
+	lnk->sconn = fsp->conn->sconn;
+#endif
+	talloc_set_destructor(lnk, aio_del_req_from_fsp);
+
+	return true;
+}
+
+struct pwrite_fsync_state {
+	struct tevent_context *ev;
+	files_struct *fsp;
+	bool write_through;
+	ssize_t nwritten;
+};
+
+static void pwrite_fsync_write_done(struct tevent_req *subreq);
+static void pwrite_fsync_sync_done(struct tevent_req *subreq);
+
+struct tevent_req *pwrite_fsync_send(TALLOC_CTX *mem_ctx,
+				     struct tevent_context *ev,
+				     struct files_struct *fsp,
+				     const void *data,
+				     size_t n, off_t offset,
+				     bool write_through)
+{
+	struct tevent_req *req, *subreq;
+	struct pwrite_fsync_state *state;
+	bool ok;
+
+	req = tevent_req_create(mem_ctx, &state, struct pwrite_fsync_state);
+	if (req == NULL) {
+		return NULL;
+	}
+	state->ev = ev;
+	state->fsp = fsp;
+	state->write_through = write_through;
+
+	ok = vfs_valid_pwrite_range(offset, n);
+	if (!ok) {
+		tevent_req_error(req, EINVAL);
+		return tevent_req_post(req, ev);
+	}
+
+	if (n == 0) {
+		tevent_req_done(req);
+		return tevent_req_post(req, ev);
+	}
+
+	subreq = SMB_VFS_PWRITE_SEND(state, ev, fsp, data, n, offset);
+	if (tevent_req_nomem(subreq, req)) {
+		return tevent_req_post(req, ev);
+	}
+	tevent_req_set_callback(subreq, pwrite_fsync_write_done, req);
+	return req;
+}
+
+static void pwrite_fsync_write_done(struct tevent_req *subreq)
+{
+	struct tevent_req *req = tevent_req_callback_data(
+		subreq, struct tevent_req);
+	struct pwrite_fsync_state *state = tevent_req_data(
+		req, struct pwrite_fsync_state);
+	connection_struct *conn = state->fsp->conn;
+	bool do_sync;
+	struct vfs_aio_state vfs_aio_state;
+
+	state->nwritten = SMB_VFS_PWRITE_RECV(subreq, &vfs_aio_state);
+	TALLOC_FREE(subreq);
+	if (state->nwritten == -1) {
+		tevent_req_error(req, vfs_aio_state.error);
+		return;
+	}
+
+	do_sync = (lp_strict_sync(SNUM(conn)) &&
+		   (lp_sync_always(SNUM(conn)) || state->write_through));
+	if (!do_sync) {
+		tevent_req_done(req);
+		return;
+	}
+
+	subreq = SMB_VFS_FSYNC_SEND(state, state->ev, state->fsp);
+	if (tevent_req_nomem(subreq, req)) {
+		return;
+	}
+	tevent_req_set_callback(subreq, pwrite_fsync_sync_done, req);
+}
+
+static void pwrite_fsync_sync_done(struct tevent_req *subreq)
+{
+	struct tevent_req *req = tevent_req_callback_data(
+		subreq, struct tevent_req);
+	int ret;
+	struct vfs_aio_state vfs_aio_state;
+
+	ret = SMB_VFS_FSYNC_RECV(subreq, &vfs_aio_state);
+	TALLOC_FREE(subreq);
+	if (ret == -1) {
+		tevent_req_error(req, vfs_aio_state.error);
+		return;
+	}
+	tevent_req_done(req);
+}
+
+ssize_t pwrite_fsync_recv(struct tevent_req *req, int *perr)
+{
+	struct pwrite_fsync_state *state = tevent_req_data(
+		req, struct pwrite_fsync_state);
+
+	if (tevent_req_is_unix_error(req, perr)) {
+		return -1;
+	}
+	return state->nwritten;
+}
+
+bool cancel_smb2_aio(struct smb_request *smbreq)
+{
+	struct smbd_smb2_request *smb2req = smbreq->smb2req;
+	struct aio_extra *aio_ex = NULL;
+
+	if (smb2req) {
+		aio_ex = talloc_get_type(smbreq->async_priv,
+					 struct aio_extra);
+	}
+
+	if (aio_ex == NULL) {
+		return false;
+	}
+
+	if (aio_ex->fsp == NULL) {
+		return false;
+	}
+
+	/*
+	 * We let the aio request run and don't try to cancel it which means
+	 * processing of the SMB2 request must continue as normal, cf MS-SMB2
+	 * 3.3.5.16:
+	 *
+	 *   If the target request is not successfully canceled, processing of
+	 *   the target request MUST continue and no response is sent to the
+	 *   cancel request.
+	 */
+
+	return false;
+}
+
+static void aio_pread_smb2_done(struct tevent_req *req);
+
+/****************************************************************************
+ Set up an aio request from a SMB2 read call.
+*****************************************************************************/
+
+NTSTATUS schedule_smb2_aio_read(connection_struct *conn,
+				struct smb_request *smbreq,
+				files_struct *fsp,
+				TALLOC_CTX *ctx,
+				DATA_BLOB *preadbuf,
+				off_t startpos,
+				size_t smb_maxcnt)
+{
+	struct aio_extra *aio_ex;
+	size_t min_aio_read_size = lp_aio_read_size(SNUM(conn));
+	struct tevent_req *req;
+	bool is_compound = false;
+	bool is_last_in_compound = false;
+	bool ok;
+
+	ok = vfs_valid_pread_range(startpos, smb_maxcnt);
+	if (!ok) {
+		return NT_STATUS_INVALID_PARAMETER;
+	}
+
+	if (fsp_is_alternate_stream(fsp)) {
+		DEBUG(10, ("AIO on streams not yet supported\n"));
+		return NT_STATUS_RETRY;
+	}
+
+	if (fsp->op == NULL) {
+		/* No AIO on internal opens. */
+		return NT_STATUS_RETRY;
+	}
+
+	if ((!min_aio_read_size || (smb_maxcnt < min_aio_read_size))
+	    && !SMB_VFS_AIO_FORCE(fsp)) {
+		/* Too small a read for aio request. */
+		DEBUG(10,("smb2: read size (%u) too small "
+			"for minimum aio_read of %u\n",
+			(unsigned int)smb_maxcnt,
+			(unsigned int)min_aio_read_size ));
+		return NT_STATUS_RETRY;
+	}
+
+	is_compound = smbd_smb2_is_compound(smbreq->smb2req);
+	is_last_in_compound = smbd_smb2_is_last_in_compound(smbreq->smb2req);
+
+	if (is_compound && !is_last_in_compound) {
+		/*
+		 * Only allow going async if this is the last
+		 * request in a compound.
+		 */
+		return NT_STATUS_RETRY;
+	}
+
+	/* Create the out buffer. */
+	*preadbuf = data_blob_talloc(ctx, NULL, smb_maxcnt);
+	if (preadbuf->data == NULL) {
+		return NT_STATUS_NO_MEMORY;
+	}
+
+	if (!(aio_ex = create_aio_extra(smbreq->smb2req, fsp, 0))) {
+		return NT_STATUS_NO_MEMORY;
+	}
+
+	init_strict_lock_struct(fsp,
+			fsp->op->global->open_persistent_id,
+			(uint64_t)startpos,
+			(uint64_t)smb_maxcnt,
+			READ_LOCK,
+			lp_posix_cifsu_locktype(fsp),
+			&aio_ex->lock);
+
+	/* Take the lock until the AIO completes. */
+	if (!SMB_VFS_STRICT_LOCK_CHECK(conn, fsp, &aio_ex->lock)) {
+		TALLOC_FREE(aio_ex);
+		return NT_STATUS_FILE_LOCK_CONFLICT;
+	}
+
+	aio_ex->nbyte = smb_maxcnt;
+	aio_ex->offset = startpos;
+
+	req = SMB_VFS_PREAD_SEND(aio_ex, fsp->conn->sconn->ev_ctx, fsp,
+				 preadbuf->data, smb_maxcnt, startpos);
+	if (req == NULL) {
+		DEBUG(0, ("smb2: SMB_VFS_PREAD_SEND failed. "
+			  "Error %s\n", strerror(errno)));
+		TALLOC_FREE(aio_ex);
+		return NT_STATUS_RETRY;
+	}
+	tevent_req_set_callback(req, aio_pread_smb2_done, aio_ex);
+
+	if (!aio_add_req_to_fsp(fsp, req)) {
+		DEBUG(1, ("Could not add req to fsp\n"));
+		TALLOC_FREE(aio_ex);
+		return NT_STATUS_RETRY;
+	}
+
+	/* We don't need talloc_move here as both aio_ex and
+	 * smbreq are children of smbreq->smb2req. */
+	aio_ex->smbreq = smbreq;
+	smbreq->async_priv = aio_ex;
+
+	DEBUG(10,("smb2: scheduled aio_read for file %s, "
+		"offset %.0f, len = %u (mid = %u)\n",
+		fsp_str_dbg(fsp), (double)startpos, (unsigned int)smb_maxcnt,
+		(unsigned int)aio_ex->smbreq->mid ));
+
+	return NT_STATUS_OK;
+}
+
+static void aio_pread_smb2_done(struct tevent_req *req)
+{
+	struct aio_extra *aio_ex = tevent_req_callback_data(
+		req, struct aio_extra);
+	struct tevent_req *subreq = aio_ex->smbreq->smb2req->subreq;
+	files_struct *fsp = aio_ex->fsp;
+	NTSTATUS status;
+	ssize_t nread;
+	struct vfs_aio_state vfs_aio_state = { 0 };
+
+	nread = SMB_VFS_PREAD_RECV(req, &vfs_aio_state);
+	TALLOC_FREE(req);
+
+	DEBUG(10, ("pread_recv returned %d, err = %s\n", (int)nread,
+		   (nread == -1) ? strerror(vfs_aio_state.error) : "no error"));
+
+	/* Common error or success code processing for async or sync
+	   read returns. */
+
+	status = smb2_read_complete(subreq, nread, vfs_aio_state.error);
+
+	if (nread > 0) {
+		fh_set_pos(fsp->fh, aio_ex->offset + nread);
+		fh_set_position_information(fsp->fh,
+						fh_get_pos(fsp->fh));
+	}
+
+	DEBUG(10, ("smb2: scheduled aio_read completed "
+		   "for file %s, offset %.0f, len = %u "
+		   "(errcode = %d, NTSTATUS = %s)\n",
+		   fsp_str_dbg(aio_ex->fsp),
+		   (double)aio_ex->offset,
+		   (unsigned int)nread,
+		   vfs_aio_state.error, nt_errstr(status)));
+
+	if (tevent_req_nterror(subreq, status)) {
+		return;
+	}
+	tevent_req_done(subreq);
+}
+
+static void aio_pwrite_smb2_done(struct tevent_req *req);
+
+/****************************************************************************
+ Set up an aio request from a SMB2write call.
+*****************************************************************************/
+
+NTSTATUS schedule_aio_smb2_write(connection_struct *conn,
+				struct smb_request *smbreq,
+				files_struct *fsp,
+				uint64_t in_offset,
+				DATA_BLOB in_data,
+				bool write_through)
+{
+	struct aio_extra *aio_ex = NULL;
+	size_t min_aio_write_size = lp_aio_write_size(SNUM(conn));
+	struct tevent_req *req;
+	bool is_compound = false;
+	bool is_last_in_compound = false;
+
+	if (fsp_is_alternate_stream(fsp)) {
+		/* No AIO on streams yet */
+		DEBUG(10, ("AIO on streams not yet supported\n"));
+		return NT_STATUS_RETRY;
+	}
+
+	if (fsp->op == NULL) {
+		/* No AIO on internal opens. */
+		return NT_STATUS_RETRY;
+	}
+
+	if ((!min_aio_write_size || (in_data.length < min_aio_write_size))
+	    && !SMB_VFS_AIO_FORCE(fsp)) {
+		/* Too small a write for aio request. */
+		DEBUG(10,("smb2: write size (%u) too "
+			"small for minimum aio_write of %u\n",
+			(unsigned int)in_data.length,
+			(unsigned int)min_aio_write_size ));
+		return NT_STATUS_RETRY;
+	}
+
+	is_compound = smbd_smb2_is_compound(smbreq->smb2req);
+	is_last_in_compound = smbd_smb2_is_last_in_compound(smbreq->smb2req);
+
+	if (is_compound && !is_last_in_compound) {
+		/*
+		 * Only allow going async if this is the last
+		 * request in a compound.
+		 */
+		return NT_STATUS_RETRY;
+	}
+
+	if (smbreq->unread_bytes) {
+		/* Can't do async with recvfile. */
+		return NT_STATUS_RETRY;
+	}
+
+	if (!(aio_ex = create_aio_extra(smbreq->smb2req, fsp, 0))) {
+		return NT_STATUS_NO_MEMORY;
+	}
+
+	aio_ex->write_through = write_through;
+
+	init_strict_lock_struct(fsp,
+			fsp->op->global->open_persistent_id,
+			in_offset,
+			(uint64_t)in_data.length,
+			WRITE_LOCK,
+			lp_posix_cifsu_locktype(fsp),
+			&aio_ex->lock);
+
+	/* Take the lock until the AIO completes. */
+	if (!SMB_VFS_STRICT_LOCK_CHECK(conn, fsp, &aio_ex->lock)) {
+		TALLOC_FREE(aio_ex);
+		return NT_STATUS_FILE_LOCK_CONFLICT;
+	}
+
+	aio_ex->nbyte = in_data.length;
+	aio_ex->offset = in_offset;
+
+	req = pwrite_fsync_send(aio_ex, fsp->conn->sconn->ev_ctx, fsp,
+				in_data.data, in_data.length, in_offset,
+				write_through);
+	if (req == NULL) {
+		DEBUG(3, ("smb2: SMB_VFS_PWRITE_SEND failed. "
+			  "Error %s\n", strerror(errno)));
+		TALLOC_FREE(aio_ex);
+		return NT_STATUS_RETRY;
+	}
+	tevent_req_set_callback(req, aio_pwrite_smb2_done, aio_ex);
+
+	if (!aio_add_req_to_fsp(fsp, req)) {
+		DEBUG(1, ("Could not add req to fsp\n"));
+		TALLOC_FREE(aio_ex);
+		return NT_STATUS_RETRY;
+	}
+
+	/* We don't need talloc_move here as both aio_ex and
+	* smbreq are children of smbreq->smb2req. */
+	aio_ex->smbreq = smbreq;
+	smbreq->async_priv = aio_ex;
+
+	/* This should actually be improved to span the write. */
+	contend_level2_oplocks_begin(fsp, LEVEL2_CONTEND_WRITE);
+	contend_level2_oplocks_end(fsp, LEVEL2_CONTEND_WRITE);
+
+	/*
+	 * We don't want to do write behind due to ownership
+	 * issues of the request structs. Maybe add it if I
+	 * figure those out. JRA.
+	 */
+
+	DEBUG(10,("smb2: scheduled aio_write for file "
+		"%s, offset %.0f, len = %u (mid = %u)\n",
+		fsp_str_dbg(fsp),
+		(double)in_offset,
+		(unsigned int)in_data.length,
+		(unsigned int)aio_ex->smbreq->mid));
+
+	return NT_STATUS_OK;
+}
+
+static void aio_pwrite_smb2_done(struct tevent_req *req)
+{
+	struct aio_extra *aio_ex = tevent_req_callback_data(
+		req, struct aio_extra);
+	ssize_t numtowrite = aio_ex->nbyte;
+	struct tevent_req *subreq = aio_ex->smbreq->smb2req->subreq;
+	files_struct *fsp = aio_ex->fsp;
+	NTSTATUS status;
+	ssize_t nwritten;
+	int err = 0;
+
+	nwritten = pwrite_fsync_recv(req, &err);
+	TALLOC_FREE(req);
+
+	DEBUG(10, ("pwrite_recv returned %d, err = %s\n", (int)nwritten,
+		   (nwritten == -1) ? strerror(err) : "no error"));
+
+	mark_file_modified(fsp);
+
+        status = smb2_write_complete_nosync(subreq, nwritten, err);
+
+	DEBUG(10, ("smb2: scheduled aio_write completed "
+		   "for file %s, offset %.0f, requested %u, "
+		   "written = %u (errcode = %d, NTSTATUS = %s)\n",
+		   fsp_str_dbg(fsp),
+		   (double)aio_ex->offset,
+		   (unsigned int)numtowrite,
+		   (unsigned int)nwritten,
+		   err, nt_errstr(status)));
+
+	if (tevent_req_nterror(subreq, status)) {
+		return;
+	}
+	tevent_req_done(subreq);
+}