162 lines
3.8 KiB
C
162 lines
3.8 KiB
C
/*
|
|
* QEMU I/O task
|
|
*
|
|
* Copyright (c) 2015 Red Hat, Inc.
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2 of the License, or (at your option) any later version.
|
|
*
|
|
* This library 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
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
*/
|
|
|
|
#include "qemu/osdep.h"
|
|
#include "io/task.h"
|
|
#include "qapi/error.h"
|
|
#include "qemu/thread.h"
|
|
#include "trace.h"
|
|
|
|
struct QIOTask {
|
|
Object *source;
|
|
QIOTaskFunc func;
|
|
gpointer opaque;
|
|
GDestroyNotify destroy;
|
|
};
|
|
|
|
|
|
QIOTask *qio_task_new(Object *source,
|
|
QIOTaskFunc func,
|
|
gpointer opaque,
|
|
GDestroyNotify destroy)
|
|
{
|
|
QIOTask *task;
|
|
|
|
task = g_new0(QIOTask, 1);
|
|
|
|
task->source = source;
|
|
object_ref(source);
|
|
task->func = func;
|
|
task->opaque = opaque;
|
|
task->destroy = destroy;
|
|
|
|
trace_qio_task_new(task, source, func, opaque);
|
|
|
|
return task;
|
|
}
|
|
|
|
static void qio_task_free(QIOTask *task)
|
|
{
|
|
if (task->destroy) {
|
|
task->destroy(task->opaque);
|
|
}
|
|
object_unref(task->source);
|
|
|
|
g_free(task);
|
|
}
|
|
|
|
|
|
struct QIOTaskThreadData {
|
|
QIOTask *task;
|
|
QIOTaskWorker worker;
|
|
gpointer opaque;
|
|
GDestroyNotify destroy;
|
|
Error *err;
|
|
int ret;
|
|
};
|
|
|
|
|
|
static gboolean gio_task_thread_result(gpointer opaque)
|
|
{
|
|
struct QIOTaskThreadData *data = opaque;
|
|
|
|
trace_qio_task_thread_result(data->task);
|
|
if (data->ret == 0) {
|
|
qio_task_complete(data->task);
|
|
} else {
|
|
qio_task_abort(data->task, data->err);
|
|
}
|
|
|
|
error_free(data->err);
|
|
if (data->destroy) {
|
|
data->destroy(data->opaque);
|
|
}
|
|
|
|
g_free(data);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
static gpointer qio_task_thread_worker(gpointer opaque)
|
|
{
|
|
struct QIOTaskThreadData *data = opaque;
|
|
|
|
trace_qio_task_thread_run(data->task);
|
|
data->ret = data->worker(data->task, &data->err, data->opaque);
|
|
if (data->ret < 0 && data->err == NULL) {
|
|
error_setg(&data->err, "Task worker failed but did not set an error");
|
|
}
|
|
|
|
/* We're running in the background thread, and must only
|
|
* ever report the task results in the main event loop
|
|
* thread. So we schedule an idle callback to report
|
|
* the worker results
|
|
*/
|
|
trace_qio_task_thread_exit(data->task);
|
|
g_idle_add(gio_task_thread_result, data);
|
|
return NULL;
|
|
}
|
|
|
|
|
|
void qio_task_run_in_thread(QIOTask *task,
|
|
QIOTaskWorker worker,
|
|
gpointer opaque,
|
|
GDestroyNotify destroy)
|
|
{
|
|
struct QIOTaskThreadData *data = g_new0(struct QIOTaskThreadData, 1);
|
|
QemuThread thread;
|
|
|
|
data->task = task;
|
|
data->worker = worker;
|
|
data->opaque = opaque;
|
|
data->destroy = destroy;
|
|
|
|
trace_qio_task_thread_start(task, worker, opaque);
|
|
qemu_thread_create(&thread,
|
|
"io-task-worker",
|
|
qio_task_thread_worker,
|
|
data,
|
|
QEMU_THREAD_DETACHED);
|
|
}
|
|
|
|
|
|
void qio_task_complete(QIOTask *task)
|
|
{
|
|
task->func(task->source, NULL, task->opaque);
|
|
trace_qio_task_complete(task);
|
|
qio_task_free(task);
|
|
}
|
|
|
|
void qio_task_abort(QIOTask *task,
|
|
Error *err)
|
|
{
|
|
task->func(task->source, err, task->opaque);
|
|
trace_qio_task_abort(task);
|
|
qio_task_free(task);
|
|
}
|
|
|
|
|
|
Object *qio_task_get_source(QIOTask *task)
|
|
{
|
|
object_ref(task->source);
|
|
return task->source;
|
|
}
|