* Simulate Posix AIO using Linux kernel AIO.
*
* Copyright (C) Jeremy Allison 2012
+ * Copyright (C) Volker Lendecke 2012
*
* 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
#include "system/filesys.h"
#include "smbd/smbd.h"
#include "smbd/globals.h"
+#include "lib/util/tevent_unix.h"
#include <sys/eventfd.h>
#include <libaio.h>
-struct aio_extra;
static int event_fd = -1;
static io_context_t io_ctx;
-static int aio_linux_requestid;
-static struct io_event *io_recv_events;
static struct fd_event *aio_read_event;
+static bool used;
+static unsigned num_busy;
-struct aio_private_data {
- struct aio_private_data *prev, *next;
- int requestid;
- SMB_STRUCT_AIOCB *aiocb;
- struct iocb *event_iocb;
- ssize_t ret_size;
- int ret_errno;
- bool cancelled;
-};
-
-/* List of outstanding requests we have. */
-static struct aio_private_data *pd_list;
-
-static void aio_linux_handle_completion(struct event_context *event_ctx,
- struct fd_event *event,
- uint16 flags,
- void *p);
+static void aio_linux_done(struct event_context *event_ctx,
+ struct fd_event *event,
+ uint16 flags, void *private_data);
/************************************************************************
Housekeeping. Cleanup if no activity for 30 seconds.
/* Remove this timed event handler. */
TALLOC_FREE(te);
- if (pd_list != NULL) {
+ if ((num_busy != 0) || used) {
+ used = false;
+
/* Still busy. Look again in 30 seconds. */
(void)tevent_add_timer(event_ctx,
NULL,
}
TALLOC_FREE(aio_read_event);
- TALLOC_FREE(io_recv_events);
}
/************************************************************************
}
/* Schedule a shutdown event for 30 seconds from now. */
- te = tevent_add_timer(server_event_context(),
+ te = tevent_add_timer(handle->conn->sconn->ev_ctx,
NULL,
timeval_current_ofs(30, 0),
aio_linux_housekeeping,
goto fail;
}
- /* Ensure we have enough space for aio_pending_size events. */
- io_recv_events = talloc_zero_array(NULL,
- struct io_event,
- aio_pending_size);
- if (io_recv_events == NULL) {
- goto fail;
- }
-
event_fd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
if (event_fd == -1) {
goto fail;
NULL,
event_fd,
TEVENT_FD_READ,
- aio_linux_handle_completion,
+ aio_linux_done,
NULL);
if (aio_read_event == NULL) {
goto fail;
DEBUG(10,("init_aio_linux: initialization failed\n"));
TALLOC_FREE(te);
- TALLOC_FREE(io_recv_events);
TALLOC_FREE(aio_read_event);
if (event_fd != -1) {
close(event_fd);
return false;
}
-/************************************************************************
- Private data destructor.
-***********************************************************************/
+struct aio_linux_state {
+ struct iocb event_iocb;
+ ssize_t ret;
+ int err;
+};
-static int pd_destructor(struct aio_private_data *pd)
+static struct tevent_req *aio_linux_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)
{
- DLIST_REMOVE(pd_list, pd);
- return 0;
-}
-
-/************************************************************************
- Create and initialize a private data struct.
-***********************************************************************/
+ struct tevent_req *req;
+ struct aio_linux_state *state;
+ struct iocb *piocb;
+ int ret;
-static struct aio_private_data *create_private_data(TALLOC_CTX *ctx,
- SMB_STRUCT_AIOCB *aiocb)
-{
- struct aio_private_data *pd = talloc_zero(ctx, struct aio_private_data);
- if (!pd) {
+ req = tevent_req_create(mem_ctx, &state, struct aio_linux_state);
+ if (req == NULL) {
return NULL;
}
- pd->event_iocb = talloc_zero(pd, struct iocb);
- pd->requestid = aio_linux_requestid++;
- pd->aiocb = aiocb;
- pd->ret_size = -1;
- pd->ret_errno = EINPROGRESS;
- talloc_set_destructor(pd, pd_destructor);
- DLIST_ADD_END(pd_list, pd, struct aio_private_data *);
- return pd;
-}
-
-/************************************************************************
- Initiate an asynchronous pread call.
-***********************************************************************/
-
-static int aio_linux_read(struct vfs_handle_struct *handle,
- struct files_struct *fsp,
- SMB_STRUCT_AIOCB *aiocb)
-{
- struct aio_extra *aio_ex = (struct aio_extra *)aiocb->aio_sigevent.sigev_value.sival_ptr;
- struct aio_private_data *pd = NULL;
- int ret;
-
if (!init_aio_linux(handle)) {
- return -1;
+ tevent_req_error(req, EIO);
+ return tevent_req_post(req, ev);
}
- pd = create_private_data(aio_ex, aiocb);
- if (pd == NULL) {
- DEBUG(10, ("aio_linux_read: Could not create private data.\n"));
- return -1;
- }
+ io_prep_pread(&state->event_iocb, fsp->fh->fd, data, n, offset);
+ io_set_eventfd(&state->event_iocb, event_fd);
+ state->event_iocb.data = req;
- io_prep_pread(pd->event_iocb,
- pd->aiocb->aio_fildes,
- discard_const(pd->aiocb->aio_buf),
- pd->aiocb->aio_nbytes,
- pd->aiocb->aio_offset);
- io_set_eventfd(pd->event_iocb, event_fd);
- /* Use the callback pointer as a private data ptr. */
- io_set_callback(pd->event_iocb, (io_callback_t)pd);
+ piocb = &state->event_iocb;
- ret = io_submit(io_ctx, 1, &pd->event_iocb);
+ ret = io_submit(io_ctx, 1, &piocb);
if (ret < 0) {
- errno = ret;
- return -1;
+ tevent_req_error(req, -ret);
+ return tevent_req_post(req, ev);
}
-
- DEBUG(10, ("aio_linux_read: requestid=%d read requested "
- "of %llu bytes at offset %llu\n",
- pd->requestid,
- (unsigned long long)pd->aiocb->aio_nbytes,
- (unsigned long long)pd->aiocb->aio_offset));
-
- return 0;
+ num_busy += 1;
+ used = true;
+ return req;
}
-/************************************************************************
- Initiate an asynchronous pwrite call.
-***********************************************************************/
-
-static int aio_linux_write(struct vfs_handle_struct *handle,
- struct files_struct *fsp,
- SMB_STRUCT_AIOCB *aiocb)
+static struct tevent_req *aio_linux_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 aio_extra *aio_ex = (struct aio_extra *)aiocb->aio_sigevent.sigev_value.sival_ptr;
- struct aio_private_data *pd = NULL;
+ struct tevent_req *req;
+ struct aio_linux_state *state;
+ struct iocb *piocb;
int ret;
+ req = tevent_req_create(mem_ctx, &state, struct aio_linux_state);
+ if (req == NULL) {
+ return NULL;
+ }
if (!init_aio_linux(handle)) {
- return -1;
+ tevent_req_error(req, EIO);
+ return tevent_req_post(req, ev);
}
- pd = create_private_data(aio_ex, aiocb);
- if (pd == NULL) {
- DEBUG(10, ("aio_linux_write: Could not create private data.\n"));
- return -1;
- }
+ io_prep_pwrite(&state->event_iocb, fsp->fh->fd, discard_const(data),
+ n, offset);
+ io_set_eventfd(&state->event_iocb, event_fd);
+ state->event_iocb.data = req;
- io_prep_pwrite(pd->event_iocb,
- pd->aiocb->aio_fildes,
- discard_const(pd->aiocb->aio_buf),
- pd->aiocb->aio_nbytes,
- pd->aiocb->aio_offset);
- io_set_eventfd(pd->event_iocb, event_fd);
- /* Use the callback pointer as a private data ptr. */
- io_set_callback(pd->event_iocb, (io_callback_t)pd);
+ piocb = &state->event_iocb;
- ret = io_submit(io_ctx, 1, &pd->event_iocb);
+ ret = io_submit(io_ctx, 1, &piocb);
if (ret < 0) {
- errno = ret;
- return -1;
+ tevent_req_error(req, -ret);
+ return tevent_req_post(req, ev);
}
-
- DEBUG(10, ("aio_linux_write: requestid=%d pwrite requested "
- "of %llu bytes at offset %llu\n",
- pd->requestid,
- (unsigned long long)pd->aiocb->aio_nbytes,
- (unsigned long long)pd->aiocb->aio_offset));
-
- return 0;
+ num_busy += 1;
+ used = true;
+ return req;
}
-/************************************************************************
- Save off the error / success conditions from the io_event.
- Is idempotent (can be called multiple times given the same ioev).
-***********************************************************************/
-
-static void aio_linux_setup_returns(struct io_event *ioev)
+static struct tevent_req *aio_linux_fsync_send(
+ struct vfs_handle_struct *handle, TALLOC_CTX *mem_ctx,
+ struct tevent_context *ev, struct files_struct *fsp)
{
- struct aio_private_data *pd = (struct aio_private_data *)ioev->data;
-
- /* ioev->res2 contains the -errno if error. */
- /* ioev->res contains the number of bytes sent/received. */
- if (ioev->res2) {
- pd->ret_size = -1;
- pd->ret_errno = -ioev->res2;
- } else {
- pd->ret_size = ioev->res;
- pd->ret_errno = 0;
- }
-}
-
-/************************************************************************
- Handle a single finished io.
-***********************************************************************/
+ struct tevent_req *req;
+ struct aio_linux_state *state;
+ struct iocb *piocb;
+ int ret;
-static void aio_linux_handle_io_finished(struct io_event *ioev)
-{
- struct aio_extra *aio_ex = NULL;
- struct aio_private_data *pd = (struct aio_private_data *)ioev->data;
+ req = tevent_req_create(mem_ctx, &state, struct aio_linux_state);
+ if (req == NULL) {
+ return NULL;
+ }
+ if (!init_aio_linux(handle)) {
+ tevent_req_error(req, EIO);
+ return tevent_req_post(req, ev);
+ }
- aio_linux_setup_returns(ioev);
+ io_prep_fsync(&state->event_iocb, fsp->fh->fd);
+ io_set_eventfd(&state->event_iocb, event_fd);
+ state->event_iocb.data = req;
- aio_ex = (struct aio_extra *)pd->aiocb->aio_sigevent.sigev_value.sival_ptr;
- smbd_aio_complete_aio_ex(aio_ex);
+ piocb = &state->event_iocb;
- DEBUG(10,("aio_linux_handle_io_finished: requestid %d completed\n",
- pd->requestid ));
- TALLOC_FREE(aio_ex);
+ ret = io_submit(io_ctx, 1, &piocb);
+ if (ret < 0) {
+ tevent_req_error(req, -ret);
+ return tevent_req_post(req, ev);
+ }
+ num_busy += 1;
+ used = true;
+ return req;
}
-/************************************************************************
- Callback when multiple IOs complete.
-***********************************************************************/
-
-static void aio_linux_handle_completion(struct event_context *event_ctx,
- struct fd_event *event,
- uint16 flags,
- void *p)
+static void aio_linux_done(struct event_context *event_ctx,
+ struct fd_event *event,
+ uint16 flags, void *private_data)
{
uint64_t num_events = 0;
- DEBUG(10, ("aio_linux_handle_completion called with flags=%d\n",
- (int)flags));
-
- if ((flags & EVENT_FD_READ) == 0) {
- return;
- }
+ DEBUG(10, ("aio_linux_done called with flags=%d\n",
+ (int)flags));
/* Read the number of events available. */
if (sys_read(event_fd, &num_events, sizeof(num_events)) !=
}
while (num_events > 0) {
- uint64_t events_to_read = MIN(num_events, aio_pending_size);
- struct timespec ts;
- int i;
+ struct timespec ts = { 0, };
+ struct io_event finished;
+ struct tevent_req *req;
+ struct aio_linux_state *state;
int ret;
- ts.tv_sec = 0;
- ts.tv_nsec = 0;
-
- ret = io_getevents(io_ctx,
- 1,
- (long)events_to_read,
- io_recv_events,
- &ts);
-
+ ret = io_getevents(io_ctx, 1, 1, &finished, &ts);
if (ret < 0) {
- errno = -ret;
- DEBUG(1, ("aio_linux_handle_completion: "
- "io_getevents error %s\n",
- strerror(errno) ));
+ DEBUG(1, ("aio_linux_done: io_getevents returned %s\n",
+ strerror(-ret)));
return;
}
-
if (ret == 0) {
- DEBUG(10, ("aio_linux_handle_completion: "
- "io_getevents returned 0\n"));
+ DEBUG(10, ("aio_linux_done: io_getvents returned "
+ "0\n"));
continue;
}
- /* ret is positive. */
- for (i = 0; i < ret; i++) {
- aio_linux_handle_io_finished(&io_recv_events[i]);
- }
-
- num_events -= ret;
- }
-}
-
-/************************************************************************
- Find the private data by aiocb.
-***********************************************************************/
+ num_busy -= 1;
-static struct aio_private_data *find_private_data_by_aiocb(SMB_STRUCT_AIOCB *aiocb)
-{
- struct aio_private_data *pd;
+ req = talloc_get_type_abort(finished.data,
+ struct tevent_req);
+ state = tevent_req_data(req, struct aio_linux_state);
- for (pd = pd_list; pd != NULL; pd = pd->next) {
- if (pd->aiocb == aiocb) {
- return pd;
+ if (finished.res < 0) {
+ state->ret = -1;
+ state->err = -finished.res;
+ } else {
+ state->ret = finished.res;
+ state->err = 0;
}
+ tevent_req_done(req);
+ num_events -= 1;
}
-
- return NULL;
}
-/************************************************************************
- Called to return the result of a completed AIO.
- Should only be called if aio_error returns something other than EINPROGRESS.
- Returns:
- Any other value - return from IO operation.
-***********************************************************************/
-
-static ssize_t aio_linux_return_fn(struct vfs_handle_struct *handle,
- struct files_struct *fsp,
- SMB_STRUCT_AIOCB *aiocb)
+static ssize_t aio_linux_recv(struct tevent_req *req, int *err)
{
- struct aio_private_data *pd = find_private_data_by_aiocb(aiocb);
+ struct aio_linux_state *state = tevent_req_data(
+ req, struct aio_linux_state);
- if (pd == NULL) {
- errno = EINVAL;
- DEBUG(0, ("aio_linux_return_fn: returning EINVAL\n"));
+ if (tevent_req_is_unix_error(req, err)) {
return -1;
}
-
- pd->aiocb = NULL;
-
- if (pd->ret_size == -1) {
- errno = pd->ret_errno;
- }
-
- return pd->ret_size;
-}
-
-/************************************************************************
- Called to check the result of an AIO.
- Returns:
- EINPROGRESS - still in progress.
- EINVAL - invalid aiocb.
- ECANCELED - request was cancelled.
- 0 - request completed successfully.
- Any other value - errno from IO operation.
-***********************************************************************/
-
-static int aio_linux_error_fn(struct vfs_handle_struct *handle,
- struct files_struct *fsp,
- SMB_STRUCT_AIOCB *aiocb)
-{
- struct aio_private_data *pd = find_private_data_by_aiocb(aiocb);
-
- if (pd == NULL) {
- return EINVAL;
- }
- if (pd->cancelled) {
- return ECANCELED;
- }
- return pd->ret_errno;
-}
-
-/************************************************************************
- Called to request the cancel of an AIO, or all of them on a specific
- fsp if aiocb == NULL.
-***********************************************************************/
-
-static int aio_linux_cancel(struct vfs_handle_struct *handle,
- struct files_struct *fsp,
- SMB_STRUCT_AIOCB *aiocb)
-{
- struct aio_private_data *pd = NULL;
-
- for (pd = pd_list; pd != NULL; pd = pd->next) {
- if (pd->aiocb == NULL) {
- continue;
- }
- if (pd->aiocb->aio_fildes != fsp->fh->fd) {
- continue;
- }
- if ((aiocb != NULL) && (pd->aiocb != aiocb)) {
- continue;
- }
-
- /*
- * We let the kernel do its job, but we discard the result when
- * it's finished. NB. Should I call io_cancel here ?
- */
-
- pd->cancelled = true;
- }
-
- return AIO_CANCELED;
-}
-
-/************************************************************************
- Callback for a previously detected job completion deferred to the main
- loop.
-***********************************************************************/
-
-static void aio_linux_handle_immediate(struct tevent_context *ctx,
- struct tevent_immediate *im,
- void *private_data)
-{
- struct io_event *ioev = (struct io_event *)private_data;
-
- aio_linux_handle_io_finished(ioev);
- TALLOC_FREE(ioev);
-}
-
-/************************************************************************
- Private data struct used in suspend completion code.
-***********************************************************************/
-
-struct suspend_private {
- int num_entries;
- int num_finished;
- const SMB_STRUCT_AIOCB * const *aiocb_array;
-};
-
-/************************************************************************
- Handle a single finished io from suspend.
-***********************************************************************/
-
-static void aio_linux_handle_suspend_io_finished(struct suspend_private *sp,
- struct io_event *ioev)
-{
- struct aio_private_data *pd = (struct aio_private_data *)ioev->data;
- struct io_event *new_ioev = NULL;
- struct tevent_immediate *im = NULL;
- int i;
-
- /* Is this a requestid with an aiocb we're interested in ? */
- for (i = 0; i < sp->num_entries; i++) {
- if (sp->aiocb_array[i] == pd->aiocb) {
- sp->num_finished++;
- /*
- * We don't call aio_linux_handle_io_finished()
- * here, but only the function that sets up the
- * return values. This allows
- * aio_linux_handle_io_finished() to be successfully
- * called from smbd/aio.c:wait_for_aio_completion()
- * once we return from here with all io's done.
- */
- aio_linux_setup_returns(ioev);
- return;
- }
- }
-
- /* Jobid completed we weren't waiting for.
- We must reshedule this as an immediate event
- on the main event context. */
- im = tevent_create_immediate(NULL);
- if (!im) {
- exit_server_cleanly("aio_linux_handle_suspend_completion: no memory");
- }
-
- new_ioev = (struct io_event *)talloc_memdup(NULL,
- ioev,
- sizeof(struct io_event));
- if (!new_ioev) {
- exit_server_cleanly("aio_linux_handle_suspend_completion: no memory");
- }
-
- DEBUG(10,("aio_linux_handle_suspend_completion: "
- "re-scheduling requestid %d\n",
- pd->requestid));
-
- tevent_schedule_immediate(im,
- server_event_context(),
- aio_linux_handle_immediate,
- (void *)new_ioev);
-}
-
-/************************************************************************
- Callback when an IO completes from a suspend call.
-***********************************************************************/
-
-static void aio_linux_handle_suspend_completion(struct event_context *event_ctx,
- struct fd_event *event,
- uint16 flags,
- void *p)
-{
- struct suspend_private *sp = (struct suspend_private *)p;
- uint64_t remaining_events = sp->num_entries - sp->num_finished;
- uint64_t num_events = 0;
-
- DEBUG(10, ("aio_linux_handle_suspend_completion called with flags=%d\n",
- (int)flags));
-
- if ((flags & EVENT_FD_READ) == 0) {
- return;
- }
-
- /* Read the number of events available. */
- if (sys_read(event_fd, &num_events, sizeof(num_events)) !=
- sizeof(num_events)) {
- smb_panic("aio_linux_handle_completion: invalid read");
- }
-
- while (num_events > 0) {
- uint64_t events_to_read = MIN(num_events, remaining_events);
- struct timespec ts;
- int i;
- int ret;
-
- ts.tv_sec = 0;
- ts.tv_nsec = 0;
-
- ret = io_getevents(io_ctx,
- 1,
- (long)events_to_read,
- io_recv_events,
- &ts);
-
- if (ret < 0) {
- errno = -ret;
- DEBUG(1, ("aio_linux_handle_suspend_completion: "
- "io_getevents error %s\n",
- strerror(errno) ));
- return;
- }
-
- if (ret == 0) {
- DEBUG(10, ("aio_linux_handle_suspend_completion: "
- "io_getevents returned 0\n"));
- continue;
- }
-
- /* ret is positive. */
- for (i = 0; i < ret; i++) {
- aio_linux_handle_suspend_io_finished(sp,
- &io_recv_events[i]);
- }
-
- num_events -= ret;
+ if (state->ret == -1) {
+ *err = state->err;
}
+ return state->ret;
}
-static void aio_linux_suspend_timed_out(struct tevent_context *event_ctx,
- struct tevent_timer *te,
- struct timeval now,
- void *private_data)
+static int aio_linux_int_recv(struct tevent_req *req, int *err)
{
- bool *timed_out = (bool *)private_data;
- /* Remove this timed event handler. */
- TALLOC_FREE(te);
- *timed_out = true;
-}
-
-/************************************************************************
- Called to request everything to stop until all IO is completed.
-***********************************************************************/
-
-static int aio_linux_suspend(struct vfs_handle_struct *handle,
- struct files_struct *fsp,
- const SMB_STRUCT_AIOCB * const aiocb_array[],
- int n,
- const struct timespec *timeout)
-{
- struct event_context *ev = NULL;
- struct fd_event *sock_event = NULL;
- int ret = -1;
- struct suspend_private sp;
- bool timed_out = false;
- TALLOC_CTX *frame = talloc_stackframe();
-
- /* This is a blocking call, and has to use a sub-event loop. */
- ev = event_context_init(frame);
- if (ev == NULL) {
- errno = ENOMEM;
- goto out;
- }
-
- if (timeout) {
- struct timeval tv = convert_timespec_to_timeval(*timeout);
- struct tevent_timer *te = tevent_add_timer(ev,
- frame,
- timeval_current_ofs(tv.tv_sec,
- tv.tv_usec),
- aio_linux_suspend_timed_out,
- &timed_out);
- if (!te) {
- errno = ENOMEM;
- goto out;
- }
- }
-
- ZERO_STRUCT(sp);
- sp.num_entries = n;
- sp.aiocb_array = aiocb_array;
- sp.num_finished = 0;
-
- sock_event = tevent_add_fd(ev,
- frame,
- event_fd,
- TEVENT_FD_READ,
- aio_linux_handle_suspend_completion,
- (void *)&sp);
- if (sock_event == NULL) {
- goto out;
- }
/*
- * We're going to cheat here. We know that smbd/aio.c
- * only calls this when it's waiting for every single
- * outstanding call to finish on a close, so just wait
- * individually for each IO to complete. We don't care
- * what order they finish - only that they all do. JRA.
+ * Use implicit conversion ssize_t->int
*/
- while (sp.num_entries != sp.num_finished) {
- if (tevent_loop_once(ev) == -1) {
- goto out;
- }
-
- if (timed_out) {
- errno = EAGAIN;
- goto out;
- }
- }
-
- ret = 0;
-
- out:
-
- TALLOC_FREE(frame);
- return ret;
+ return aio_linux_recv(req, err);
}
static int aio_linux_connect(vfs_handle_struct *handle, const char *service,
static struct vfs_fn_pointers vfs_aio_linux_fns = {
.connect_fn = aio_linux_connect,
- .aio_read_fn = aio_linux_read,
- .aio_write_fn = aio_linux_write,
- .aio_return_fn = aio_linux_return_fn,
- .aio_cancel_fn = aio_linux_cancel,
- .aio_error_fn = aio_linux_error_fn,
- .aio_suspend_fn = aio_linux_suspend,
+ .pread_send_fn = aio_linux_pread_send,
+ .pread_recv_fn = aio_linux_recv,
+ .pwrite_send_fn = aio_linux_pwrite_send,
+ .pwrite_recv_fn = aio_linux_recv,
+ .fsync_send_fn = aio_linux_fsync_send,
+ .fsync_recv_fn = aio_linux_int_recv,
};
NTSTATUS vfs_aio_linux_init(void)
git.samba.org / kai / samba.git / blobdiff