mirror of
https://github.com/samba-team/samba.git
synced 2024-12-23 17:34:34 +03:00
3b1c02e469
aio.c now contians only smb2 code Signed-off-by: David Mulder <dmulder@suse.com> Reviewed-by: Jeremy Allison <jra@samba.org>
569 lines
14 KiB
C
569 lines
14 KiB
C
/*
|
|
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 {
|
|
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;
|
|
|
|
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;
|
|
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 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;
|
|
}
|
|
|
|
if (smbd_smb2_is_compound(smbreq->smb2req)) {
|
|
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 (!NT_STATUS_IS_OK(status)) {
|
|
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;
|
|
|
|
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;
|
|
}
|
|
|
|
if (smbd_smb2_is_compound(smbreq->smb2req)) {
|
|
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 (!NT_STATUS_IS_OK(status)) {
|
|
tevent_req_nterror(subreq, status);
|
|
return;
|
|
}
|
|
tevent_req_done(subreq);
|
|
}
|