2012-09-28 17:22:47 +02:00
|
|
|
/*
|
|
|
|
* QEMU System Emulator block driver
|
|
|
|
*
|
|
|
|
* Copyright (c) 2011 IBM Corp.
|
|
|
|
* Copyright (c) 2012 Red Hat, Inc.
|
|
|
|
*
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
|
|
* in the Software without restriction, including without limitation the rights
|
|
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
|
|
* furnished to do so, subject to the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice shall be included in
|
|
|
|
* all copies or substantial portions of the Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
|
|
* THE SOFTWARE.
|
|
|
|
*/
|
|
|
|
|
2016-01-29 18:50:05 +01:00
|
|
|
#include "qemu/osdep.h"
|
2012-09-28 17:22:47 +02:00
|
|
|
#include "qemu-common.h"
|
|
|
|
#include "trace.h"
|
2012-12-17 18:19:44 +01:00
|
|
|
#include "block/block.h"
|
|
|
|
#include "block/blockjob.h"
|
|
|
|
#include "block/block_int.h"
|
2015-10-19 17:53:22 +02:00
|
|
|
#include "sysemu/block-backend.h"
|
2015-03-17 17:22:46 +01:00
|
|
|
#include "qapi/qmp/qerror.h"
|
2012-12-17 18:19:43 +01:00
|
|
|
#include "qapi/qmp/qjson.h"
|
2015-09-01 15:48:02 +02:00
|
|
|
#include "qemu/coroutine.h"
|
2016-07-05 16:28:56 +02:00
|
|
|
#include "qemu/id.h"
|
2012-09-28 17:22:47 +02:00
|
|
|
#include "qmp-commands.h"
|
2012-12-17 18:20:00 +01:00
|
|
|
#include "qemu/timer.h"
|
2014-06-18 08:43:45 +02:00
|
|
|
#include "qapi-event.h"
|
2012-09-28 17:22:47 +02:00
|
|
|
|
2015-11-06 00:13:15 +01:00
|
|
|
/* Transactional group of block jobs */
|
|
|
|
struct BlockJobTxn {
|
|
|
|
|
|
|
|
/* Is this txn being cancelled? */
|
|
|
|
bool aborting;
|
|
|
|
|
|
|
|
/* List of jobs */
|
|
|
|
QLIST_HEAD(, BlockJob) jobs;
|
|
|
|
|
|
|
|
/* Reference count */
|
|
|
|
int refcnt;
|
|
|
|
};
|
|
|
|
|
2016-04-04 15:43:51 +02:00
|
|
|
static QLIST_HEAD(, BlockJob) block_jobs = QLIST_HEAD_INITIALIZER(block_jobs);
|
|
|
|
|
|
|
|
BlockJob *block_job_next(BlockJob *job)
|
|
|
|
{
|
|
|
|
if (!job) {
|
|
|
|
return QLIST_FIRST(&block_jobs);
|
|
|
|
}
|
|
|
|
return QLIST_NEXT(job, job_list);
|
|
|
|
}
|
|
|
|
|
2016-07-05 16:28:54 +02:00
|
|
|
BlockJob *block_job_get(const char *id)
|
|
|
|
{
|
|
|
|
BlockJob *job;
|
|
|
|
|
|
|
|
QLIST_FOREACH(job, &block_jobs, job_list) {
|
|
|
|
if (!strcmp(id, job->id)) {
|
|
|
|
return job;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2016-06-16 18:56:25 +02:00
|
|
|
/* Normally the job runs in its BlockBackend's AioContext. The exception is
|
|
|
|
* block_job_defer_to_main_loop() where it runs in the QEMU main loop. Code
|
|
|
|
* that supports both cases uses this helper function.
|
|
|
|
*/
|
|
|
|
static AioContext *block_job_get_aio_context(BlockJob *job)
|
|
|
|
{
|
|
|
|
return job->deferred_to_main_loop ?
|
|
|
|
qemu_get_aio_context() :
|
|
|
|
blk_get_aio_context(job->blk);
|
|
|
|
}
|
|
|
|
|
2016-06-16 18:56:27 +02:00
|
|
|
static void block_job_attached_aio_context(AioContext *new_context,
|
|
|
|
void *opaque)
|
|
|
|
{
|
|
|
|
BlockJob *job = opaque;
|
|
|
|
|
|
|
|
if (job->driver->attached_aio_context) {
|
|
|
|
job->driver->attached_aio_context(job, new_context);
|
|
|
|
}
|
|
|
|
|
|
|
|
block_job_resume(job);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void block_job_detach_aio_context(void *opaque)
|
|
|
|
{
|
|
|
|
BlockJob *job = opaque;
|
|
|
|
|
|
|
|
/* In case the job terminates during aio_poll()... */
|
|
|
|
block_job_ref(job);
|
|
|
|
|
|
|
|
block_job_pause(job);
|
|
|
|
|
|
|
|
if (!job->paused) {
|
|
|
|
/* If job is !job->busy this kicks it into the next pause point. */
|
|
|
|
block_job_enter(job);
|
|
|
|
}
|
|
|
|
while (!job->paused && !job->completed) {
|
|
|
|
aio_poll(block_job_get_aio_context(job), true);
|
|
|
|
}
|
|
|
|
|
|
|
|
block_job_unref(job);
|
|
|
|
}
|
|
|
|
|
2016-07-05 16:28:56 +02:00
|
|
|
void *block_job_create(const char *job_id, const BlockJobDriver *driver,
|
|
|
|
BlockDriverState *bs, int64_t speed,
|
|
|
|
BlockCompletionFunc *cb, void *opaque, Error **errp)
|
2012-09-28 17:22:47 +02:00
|
|
|
{
|
2016-04-08 14:51:09 +02:00
|
|
|
BlockBackend *blk;
|
2012-09-28 17:22:47 +02:00
|
|
|
BlockJob *job;
|
|
|
|
|
2016-06-23 10:57:20 +02:00
|
|
|
assert(cb);
|
2014-05-23 15:29:44 +02:00
|
|
|
if (bs->job) {
|
2015-03-17 11:54:50 +01:00
|
|
|
error_setg(errp, QERR_DEVICE_IN_USE, bdrv_get_device_name(bs));
|
2012-09-28 17:22:47 +02:00
|
|
|
return NULL;
|
|
|
|
}
|
2016-04-08 14:51:09 +02:00
|
|
|
|
2016-07-05 16:28:56 +02:00
|
|
|
if (job_id == NULL) {
|
|
|
|
job_id = bdrv_get_device_name(bs);
|
2016-07-12 18:15:49 +02:00
|
|
|
if (!*job_id) {
|
|
|
|
error_setg(errp, "An explicit job ID is required for this node");
|
|
|
|
return NULL;
|
|
|
|
}
|
2016-07-05 16:28:56 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!id_wellformed(job_id)) {
|
|
|
|
error_setg(errp, "Invalid job ID '%s'", job_id);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (block_job_get(job_id)) {
|
|
|
|
error_setg(errp, "Job ID '%s' already in use", job_id);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2016-04-08 14:51:09 +02:00
|
|
|
blk = blk_new();
|
|
|
|
blk_insert_bs(blk, bs);
|
|
|
|
|
2013-10-08 11:29:38 +02:00
|
|
|
job = g_malloc0(driver->instance_size);
|
2014-05-23 15:29:43 +02:00
|
|
|
error_setg(&job->blocker, "block device is in use by block job: %s",
|
|
|
|
BlockJobType_lookup[driver->job_type]);
|
|
|
|
bdrv_op_block_all(bs, job->blocker);
|
2014-10-21 13:04:00 +02:00
|
|
|
bdrv_op_unblock(bs, BLOCK_OP_TYPE_DATAPLANE, job->blocker);
|
2014-05-23 15:29:43 +02:00
|
|
|
|
2013-10-08 11:29:38 +02:00
|
|
|
job->driver = driver;
|
2016-07-05 16:28:56 +02:00
|
|
|
job->id = g_strdup(job_id);
|
2016-04-08 14:51:09 +02:00
|
|
|
job->blk = blk;
|
2012-09-28 17:22:47 +02:00
|
|
|
job->cb = cb;
|
|
|
|
job->opaque = opaque;
|
|
|
|
job->busy = true;
|
2015-11-06 00:13:11 +01:00
|
|
|
job->refcnt = 1;
|
2012-09-28 17:22:47 +02:00
|
|
|
bs->job = job;
|
|
|
|
|
2016-04-04 15:43:51 +02:00
|
|
|
QLIST_INSERT_HEAD(&block_jobs, job, job_list);
|
|
|
|
|
2016-06-16 18:56:27 +02:00
|
|
|
blk_add_aio_context_notifier(blk, block_job_attached_aio_context,
|
|
|
|
block_job_detach_aio_context, job);
|
|
|
|
|
2012-09-28 17:22:47 +02:00
|
|
|
/* Only set speed when necessary to avoid NotSupported error */
|
|
|
|
if (speed != 0) {
|
|
|
|
Error *local_err = NULL;
|
|
|
|
|
|
|
|
block_job_set_speed(job, speed, &local_err);
|
2014-01-30 15:07:28 +01:00
|
|
|
if (local_err) {
|
2015-11-06 00:13:11 +01:00
|
|
|
block_job_unref(job);
|
2012-09-28 17:22:47 +02:00
|
|
|
error_propagate(errp, local_err);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return job;
|
|
|
|
}
|
|
|
|
|
2015-11-06 00:13:11 +01:00
|
|
|
void block_job_ref(BlockJob *job)
|
2012-09-28 17:22:47 +02:00
|
|
|
{
|
2015-11-06 00:13:11 +01:00
|
|
|
++job->refcnt;
|
|
|
|
}
|
2012-09-28 17:22:47 +02:00
|
|
|
|
2015-11-06 00:13:11 +01:00
|
|
|
void block_job_unref(BlockJob *job)
|
|
|
|
{
|
|
|
|
if (--job->refcnt == 0) {
|
2016-04-08 14:51:09 +02:00
|
|
|
BlockDriverState *bs = blk_bs(job->blk);
|
|
|
|
bs->job = NULL;
|
|
|
|
bdrv_op_unblock_all(bs, job->blocker);
|
2016-06-16 18:56:27 +02:00
|
|
|
blk_remove_aio_context_notifier(job->blk,
|
|
|
|
block_job_attached_aio_context,
|
|
|
|
block_job_detach_aio_context, job);
|
2016-04-08 14:51:09 +02:00
|
|
|
blk_unref(job->blk);
|
2015-11-06 00:13:11 +01:00
|
|
|
error_free(job->blocker);
|
|
|
|
g_free(job->id);
|
2016-04-04 15:43:51 +02:00
|
|
|
QLIST_REMOVE(job, job_list);
|
2015-11-06 00:13:11 +01:00
|
|
|
g_free(job);
|
|
|
|
}
|
2012-09-28 17:22:47 +02:00
|
|
|
}
|
|
|
|
|
2015-11-06 00:13:15 +01:00
|
|
|
static void block_job_completed_single(BlockJob *job)
|
|
|
|
{
|
|
|
|
if (!job->ret) {
|
|
|
|
if (job->driver->commit) {
|
|
|
|
job->driver->commit(job);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (job->driver->abort) {
|
|
|
|
job->driver->abort(job);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
job->cb(job->opaque, job->ret);
|
|
|
|
if (job->txn) {
|
|
|
|
block_job_txn_unref(job->txn);
|
|
|
|
}
|
|
|
|
block_job_unref(job);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void block_job_completed_txn_abort(BlockJob *job)
|
|
|
|
{
|
|
|
|
AioContext *ctx;
|
|
|
|
BlockJobTxn *txn = job->txn;
|
|
|
|
BlockJob *other_job, *next;
|
|
|
|
|
|
|
|
if (txn->aborting) {
|
|
|
|
/*
|
|
|
|
* We are cancelled by another job, which will handle everything.
|
|
|
|
*/
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
txn->aborting = true;
|
|
|
|
/* We are the first failed job. Cancel other jobs. */
|
|
|
|
QLIST_FOREACH(other_job, &txn->jobs, txn_list) {
|
2016-04-08 14:51:09 +02:00
|
|
|
ctx = blk_get_aio_context(other_job->blk);
|
2015-11-06 00:13:15 +01:00
|
|
|
aio_context_acquire(ctx);
|
|
|
|
}
|
|
|
|
QLIST_FOREACH(other_job, &txn->jobs, txn_list) {
|
|
|
|
if (other_job == job || other_job->completed) {
|
|
|
|
/* Other jobs are "effectively" cancelled by us, set the status for
|
|
|
|
* them; this job, however, may or may not be cancelled, depending
|
|
|
|
* on the caller, so leave it. */
|
|
|
|
if (other_job != job) {
|
|
|
|
other_job->cancelled = true;
|
|
|
|
}
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
block_job_cancel_sync(other_job);
|
|
|
|
assert(other_job->completed);
|
|
|
|
}
|
|
|
|
QLIST_FOREACH_SAFE(other_job, &txn->jobs, txn_list, next) {
|
2016-04-08 14:51:09 +02:00
|
|
|
ctx = blk_get_aio_context(other_job->blk);
|
2015-11-06 00:13:15 +01:00
|
|
|
block_job_completed_single(other_job);
|
|
|
|
aio_context_release(ctx);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void block_job_completed_txn_success(BlockJob *job)
|
|
|
|
{
|
|
|
|
AioContext *ctx;
|
|
|
|
BlockJobTxn *txn = job->txn;
|
|
|
|
BlockJob *other_job, *next;
|
|
|
|
/*
|
|
|
|
* Successful completion, see if there are other running jobs in this
|
|
|
|
* txn.
|
|
|
|
*/
|
|
|
|
QLIST_FOREACH(other_job, &txn->jobs, txn_list) {
|
|
|
|
if (!other_job->completed) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* We are the last completed job, commit the transaction. */
|
|
|
|
QLIST_FOREACH_SAFE(other_job, &txn->jobs, txn_list, next) {
|
2016-04-08 14:51:09 +02:00
|
|
|
ctx = blk_get_aio_context(other_job->blk);
|
2015-11-06 00:13:15 +01:00
|
|
|
aio_context_acquire(ctx);
|
|
|
|
assert(other_job->ret == 0);
|
|
|
|
block_job_completed_single(other_job);
|
|
|
|
aio_context_release(ctx);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-06-26 11:37:35 +02:00
|
|
|
void block_job_completed(BlockJob *job, int ret)
|
|
|
|
{
|
2016-04-08 14:51:09 +02:00
|
|
|
assert(blk_bs(job->blk)->job == job);
|
2015-11-06 00:13:13 +01:00
|
|
|
assert(!job->completed);
|
|
|
|
job->completed = true;
|
|
|
|
job->ret = ret;
|
2015-11-06 00:13:15 +01:00
|
|
|
if (!job->txn) {
|
|
|
|
block_job_completed_single(job);
|
|
|
|
} else if (ret < 0 || block_job_is_cancelled(job)) {
|
|
|
|
block_job_completed_txn_abort(job);
|
|
|
|
} else {
|
|
|
|
block_job_completed_txn_success(job);
|
|
|
|
}
|
2015-06-26 11:37:35 +02:00
|
|
|
}
|
|
|
|
|
2012-09-28 17:22:47 +02:00
|
|
|
void block_job_set_speed(BlockJob *job, int64_t speed, Error **errp)
|
|
|
|
{
|
|
|
|
Error *local_err = NULL;
|
|
|
|
|
2013-10-08 11:29:38 +02:00
|
|
|
if (!job->driver->set_speed) {
|
2015-03-17 11:54:50 +01:00
|
|
|
error_setg(errp, QERR_UNSUPPORTED);
|
2012-09-28 17:22:47 +02:00
|
|
|
return;
|
|
|
|
}
|
2013-10-08 11:29:38 +02:00
|
|
|
job->driver->set_speed(job, speed, &local_err);
|
2014-01-30 15:07:28 +01:00
|
|
|
if (local_err) {
|
2012-09-28 17:22:47 +02:00
|
|
|
error_propagate(errp, local_err);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
job->speed = speed;
|
|
|
|
}
|
|
|
|
|
2012-10-18 16:49:21 +02:00
|
|
|
void block_job_complete(BlockJob *job, Error **errp)
|
|
|
|
{
|
2015-04-03 16:05:18 +02:00
|
|
|
if (job->pause_count || job->cancelled || !job->driver->complete) {
|
2016-07-05 16:28:53 +02:00
|
|
|
error_setg(errp, "The active block job '%s' cannot be completed",
|
|
|
|
job->id);
|
2012-10-18 16:49:21 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-10-08 11:29:38 +02:00
|
|
|
job->driver->complete(job, errp);
|
2012-10-18 16:49:21 +02:00
|
|
|
}
|
|
|
|
|
2012-09-28 17:22:50 +02:00
|
|
|
void block_job_pause(BlockJob *job)
|
2012-09-28 17:22:47 +02:00
|
|
|
{
|
2015-04-03 16:05:18 +02:00
|
|
|
job->pause_count++;
|
2012-09-28 17:22:50 +02:00
|
|
|
}
|
|
|
|
|
2016-06-16 18:56:23 +02:00
|
|
|
static bool block_job_should_pause(BlockJob *job)
|
2012-09-28 17:22:50 +02:00
|
|
|
{
|
2015-04-03 16:05:18 +02:00
|
|
|
return job->pause_count > 0;
|
2012-09-28 17:22:50 +02:00
|
|
|
}
|
|
|
|
|
2016-06-16 18:56:24 +02:00
|
|
|
void coroutine_fn block_job_pause_point(BlockJob *job)
|
|
|
|
{
|
|
|
|
if (!block_job_should_pause(job)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (block_job_is_cancelled(job)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (job->driver->pause) {
|
|
|
|
job->driver->pause(job);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (block_job_should_pause(job) && !block_job_is_cancelled(job)) {
|
|
|
|
job->paused = true;
|
|
|
|
job->busy = false;
|
|
|
|
qemu_coroutine_yield(); /* wait for block_job_resume() */
|
|
|
|
job->busy = true;
|
|
|
|
job->paused = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (job->driver->resume) {
|
|
|
|
job->driver->resume(job);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-09-28 17:22:50 +02:00
|
|
|
void block_job_resume(BlockJob *job)
|
|
|
|
{
|
2015-04-03 16:05:18 +02:00
|
|
|
assert(job->pause_count > 0);
|
|
|
|
job->pause_count--;
|
|
|
|
if (job->pause_count) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
block_job_enter(job);
|
|
|
|
}
|
|
|
|
|
|
|
|
void block_job_enter(BlockJob *job)
|
|
|
|
{
|
2012-09-28 17:22:47 +02:00
|
|
|
if (job->co && !job->busy) {
|
coroutine: move entry argument to qemu_coroutine_create
In practice the entry argument is always known at creation time, and
it is confusing that sometimes qemu_coroutine_enter is used with a
non-NULL argument to re-enter a coroutine (this happens in
block/sheepdog.c and tests/test-coroutine.c). So pass the opaque value
at creation time, for consistency with e.g. aio_bh_new.
Mostly done with the following semantic patch:
@ entry1 @
expression entry, arg, co;
@@
- co = qemu_coroutine_create(entry);
+ co = qemu_coroutine_create(entry, arg);
...
- qemu_coroutine_enter(co, arg);
+ qemu_coroutine_enter(co);
@ entry2 @
expression entry, arg;
identifier co;
@@
- Coroutine *co = qemu_coroutine_create(entry);
+ Coroutine *co = qemu_coroutine_create(entry, arg);
...
- qemu_coroutine_enter(co, arg);
+ qemu_coroutine_enter(co);
@ entry3 @
expression entry, arg;
@@
- qemu_coroutine_enter(qemu_coroutine_create(entry), arg);
+ qemu_coroutine_enter(qemu_coroutine_create(entry, arg));
@ reentry @
expression co;
@@
- qemu_coroutine_enter(co, NULL);
+ qemu_coroutine_enter(co);
except for the aforementioned few places where the semantic patch
stumbled (as expected) and for test_co_queue, which would otherwise
produce an uninitialized variable warning.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2016-07-04 19:10:01 +02:00
|
|
|
qemu_coroutine_enter(job->co);
|
2012-09-28 17:22:47 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-09-28 17:22:50 +02:00
|
|
|
void block_job_cancel(BlockJob *job)
|
|
|
|
{
|
|
|
|
job->cancelled = true;
|
2016-06-16 18:56:22 +02:00
|
|
|
block_job_iostatus_reset(job);
|
2015-04-03 16:05:18 +02:00
|
|
|
block_job_enter(job);
|
2012-09-28 17:22:50 +02:00
|
|
|
}
|
|
|
|
|
2012-09-28 17:22:47 +02:00
|
|
|
bool block_job_is_cancelled(BlockJob *job)
|
|
|
|
{
|
|
|
|
return job->cancelled;
|
|
|
|
}
|
|
|
|
|
block: introduce block job error
The following behaviors are possible:
'report': The behavior is the same as in 1.1. An I/O error,
respectively during a read or a write, will complete the job immediately
with an error code.
'ignore': An I/O error, respectively during a read or a write, will be
ignored. For streaming, the job will complete with an error and the
backing file will be left in place. For mirroring, the sector will be
marked again as dirty and re-examined later.
'stop': The job will be paused and the job iostatus will be set to
failed or nospace, while the VM will keep running. This can only be
specified if the block device has rerror=stop and werror=stop or enospc.
'enospc': Behaves as 'stop' for ENOSPC errors, 'report' for others.
In all cases, even for 'report', the I/O error is reported as a QMP
event BLOCK_JOB_ERROR, with the same arguments as BLOCK_IO_ERROR.
It is possible that while stopping the VM a BLOCK_IO_ERROR event will be
reported and will clobber the event from BLOCK_JOB_ERROR, or vice versa.
This is not really avoidable since stopping the VM completes all pending
I/O requests. In fact, it is already possible now that a series of
BLOCK_IO_ERROR events are reported with rerror=stop, because vm_stop
calls bdrv_drain_all and this can generate further errors.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2012-09-28 17:22:58 +02:00
|
|
|
void block_job_iostatus_reset(BlockJob *job)
|
|
|
|
{
|
|
|
|
job->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
|
2013-10-08 11:29:38 +02:00
|
|
|
if (job->driver->iostatus_reset) {
|
|
|
|
job->driver->iostatus_reset(job);
|
2012-10-18 16:49:27 +02:00
|
|
|
}
|
block: introduce block job error
The following behaviors are possible:
'report': The behavior is the same as in 1.1. An I/O error,
respectively during a read or a write, will complete the job immediately
with an error code.
'ignore': An I/O error, respectively during a read or a write, will be
ignored. For streaming, the job will complete with an error and the
backing file will be left in place. For mirroring, the sector will be
marked again as dirty and re-examined later.
'stop': The job will be paused and the job iostatus will be set to
failed or nospace, while the VM will keep running. This can only be
specified if the block device has rerror=stop and werror=stop or enospc.
'enospc': Behaves as 'stop' for ENOSPC errors, 'report' for others.
In all cases, even for 'report', the I/O error is reported as a QMP
event BLOCK_JOB_ERROR, with the same arguments as BLOCK_IO_ERROR.
It is possible that while stopping the VM a BLOCK_IO_ERROR event will be
reported and will clobber the event from BLOCK_JOB_ERROR, or vice versa.
This is not really avoidable since stopping the VM completes all pending
I/O requests. In fact, it is already possible now that a series of
BLOCK_IO_ERROR events are reported with rerror=stop, because vm_stop
calls bdrv_drain_all and this can generate further errors.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2012-09-28 17:22:58 +02:00
|
|
|
}
|
|
|
|
|
2014-10-24 15:57:33 +02:00
|
|
|
static int block_job_finish_sync(BlockJob *job,
|
|
|
|
void (*finish)(BlockJob *, Error **errp),
|
|
|
|
Error **errp)
|
2012-09-28 17:22:47 +02:00
|
|
|
{
|
2014-10-24 15:57:33 +02:00
|
|
|
Error *local_err = NULL;
|
2015-11-06 00:13:14 +01:00
|
|
|
int ret;
|
2012-09-28 17:22:47 +02:00
|
|
|
|
2016-04-08 14:51:09 +02:00
|
|
|
assert(blk_bs(job->blk)->job == job);
|
2012-09-28 17:22:47 +02:00
|
|
|
|
2015-11-06 00:13:14 +01:00
|
|
|
block_job_ref(job);
|
2014-10-24 15:57:33 +02:00
|
|
|
finish(job, &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
2015-11-06 00:13:14 +01:00
|
|
|
block_job_unref(job);
|
2014-10-24 15:57:33 +02:00
|
|
|
return -EBUSY;
|
|
|
|
}
|
2015-11-06 00:13:14 +01:00
|
|
|
while (!job->completed) {
|
2016-06-16 18:56:25 +02:00
|
|
|
aio_poll(block_job_get_aio_context(job), true);
|
2012-09-28 17:22:47 +02:00
|
|
|
}
|
2015-11-06 00:13:14 +01:00
|
|
|
ret = (job->cancelled && job->ret == 0) ? -ECANCELED : job->ret;
|
|
|
|
block_job_unref(job);
|
|
|
|
return ret;
|
2012-09-28 17:22:47 +02:00
|
|
|
}
|
|
|
|
|
2014-10-24 15:57:33 +02:00
|
|
|
/* A wrapper around block_job_cancel() taking an Error ** parameter so it may be
|
|
|
|
* used with block_job_finish_sync() without the need for (rather nasty)
|
|
|
|
* function pointer casts there. */
|
|
|
|
static void block_job_cancel_err(BlockJob *job, Error **errp)
|
|
|
|
{
|
|
|
|
block_job_cancel(job);
|
|
|
|
}
|
|
|
|
|
|
|
|
int block_job_cancel_sync(BlockJob *job)
|
|
|
|
{
|
|
|
|
return block_job_finish_sync(job, &block_job_cancel_err, NULL);
|
|
|
|
}
|
|
|
|
|
2016-04-08 18:26:37 +02:00
|
|
|
void block_job_cancel_sync_all(void)
|
|
|
|
{
|
|
|
|
BlockJob *job;
|
|
|
|
AioContext *aio_context;
|
|
|
|
|
|
|
|
while ((job = QLIST_FIRST(&block_jobs))) {
|
2016-04-08 14:51:09 +02:00
|
|
|
aio_context = blk_get_aio_context(job->blk);
|
2016-04-08 18:26:37 +02:00
|
|
|
aio_context_acquire(aio_context);
|
|
|
|
block_job_cancel_sync(job);
|
|
|
|
aio_context_release(aio_context);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-10-24 15:57:33 +02:00
|
|
|
int block_job_complete_sync(BlockJob *job, Error **errp)
|
|
|
|
{
|
|
|
|
return block_job_finish_sync(job, &block_job_complete, errp);
|
|
|
|
}
|
|
|
|
|
2013-08-21 17:03:05 +02:00
|
|
|
void block_job_sleep_ns(BlockJob *job, QEMUClockType type, int64_t ns)
|
2012-09-28 17:22:47 +02:00
|
|
|
{
|
2012-09-28 17:22:50 +02:00
|
|
|
assert(job->busy);
|
|
|
|
|
2012-09-28 17:22:47 +02:00
|
|
|
/* Check cancellation *before* setting busy = false, too! */
|
2012-09-28 17:22:50 +02:00
|
|
|
if (block_job_is_cancelled(job)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
job->busy = false;
|
2016-06-16 18:56:23 +02:00
|
|
|
if (!block_job_should_pause(job)) {
|
2016-05-27 12:53:38 +02:00
|
|
|
co_aio_sleep_ns(blk_get_aio_context(job->blk), type, ns);
|
|
|
|
}
|
2012-09-28 17:22:50 +02:00
|
|
|
job->busy = true;
|
2016-06-16 18:56:24 +02:00
|
|
|
|
|
|
|
block_job_pause_point(job);
|
2012-09-28 17:22:47 +02:00
|
|
|
}
|
2012-09-28 17:22:48 +02:00
|
|
|
|
2014-06-24 14:26:35 +02:00
|
|
|
void block_job_yield(BlockJob *job)
|
|
|
|
{
|
|
|
|
assert(job->busy);
|
|
|
|
|
|
|
|
/* Check cancellation *before* setting busy = false, too! */
|
|
|
|
if (block_job_is_cancelled(job)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
job->busy = false;
|
2016-06-16 18:56:24 +02:00
|
|
|
if (!block_job_should_pause(job)) {
|
|
|
|
qemu_coroutine_yield();
|
|
|
|
}
|
2014-06-24 14:26:35 +02:00
|
|
|
job->busy = true;
|
2016-06-16 18:56:24 +02:00
|
|
|
|
|
|
|
block_job_pause_point(job);
|
2014-06-24 14:26:35 +02:00
|
|
|
}
|
|
|
|
|
2012-09-28 17:22:48 +02:00
|
|
|
BlockJobInfo *block_job_query(BlockJob *job)
|
|
|
|
{
|
|
|
|
BlockJobInfo *info = g_new0(BlockJobInfo, 1);
|
2013-10-08 11:29:40 +02:00
|
|
|
info->type = g_strdup(BlockJobType_lookup[job->driver->job_type]);
|
2015-09-16 13:34:54 +02:00
|
|
|
info->device = g_strdup(job->id);
|
block: introduce block job error
The following behaviors are possible:
'report': The behavior is the same as in 1.1. An I/O error,
respectively during a read or a write, will complete the job immediately
with an error code.
'ignore': An I/O error, respectively during a read or a write, will be
ignored. For streaming, the job will complete with an error and the
backing file will be left in place. For mirroring, the sector will be
marked again as dirty and re-examined later.
'stop': The job will be paused and the job iostatus will be set to
failed or nospace, while the VM will keep running. This can only be
specified if the block device has rerror=stop and werror=stop or enospc.
'enospc': Behaves as 'stop' for ENOSPC errors, 'report' for others.
In all cases, even for 'report', the I/O error is reported as a QMP
event BLOCK_JOB_ERROR, with the same arguments as BLOCK_IO_ERROR.
It is possible that while stopping the VM a BLOCK_IO_ERROR event will be
reported and will clobber the event from BLOCK_JOB_ERROR, or vice versa.
This is not really avoidable since stopping the VM completes all pending
I/O requests. In fact, it is already possible now that a series of
BLOCK_IO_ERROR events are reported with rerror=stop, because vm_stop
calls bdrv_drain_all and this can generate further errors.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2012-09-28 17:22:58 +02:00
|
|
|
info->len = job->len;
|
|
|
|
info->busy = job->busy;
|
2015-04-03 16:05:18 +02:00
|
|
|
info->paused = job->pause_count > 0;
|
block: introduce block job error
The following behaviors are possible:
'report': The behavior is the same as in 1.1. An I/O error,
respectively during a read or a write, will complete the job immediately
with an error code.
'ignore': An I/O error, respectively during a read or a write, will be
ignored. For streaming, the job will complete with an error and the
backing file will be left in place. For mirroring, the sector will be
marked again as dirty and re-examined later.
'stop': The job will be paused and the job iostatus will be set to
failed or nospace, while the VM will keep running. This can only be
specified if the block device has rerror=stop and werror=stop or enospc.
'enospc': Behaves as 'stop' for ENOSPC errors, 'report' for others.
In all cases, even for 'report', the I/O error is reported as a QMP
event BLOCK_JOB_ERROR, with the same arguments as BLOCK_IO_ERROR.
It is possible that while stopping the VM a BLOCK_IO_ERROR event will be
reported and will clobber the event from BLOCK_JOB_ERROR, or vice versa.
This is not really avoidable since stopping the VM completes all pending
I/O requests. In fact, it is already possible now that a series of
BLOCK_IO_ERROR events are reported with rerror=stop, because vm_stop
calls bdrv_drain_all and this can generate further errors.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2012-09-28 17:22:58 +02:00
|
|
|
info->offset = job->offset;
|
|
|
|
info->speed = job->speed;
|
|
|
|
info->io_status = job->iostatus;
|
2014-10-24 15:57:34 +02:00
|
|
|
info->ready = job->ready;
|
2012-09-28 17:22:48 +02:00
|
|
|
return info;
|
|
|
|
}
|
block: introduce block job error
The following behaviors are possible:
'report': The behavior is the same as in 1.1. An I/O error,
respectively during a read or a write, will complete the job immediately
with an error code.
'ignore': An I/O error, respectively during a read or a write, will be
ignored. For streaming, the job will complete with an error and the
backing file will be left in place. For mirroring, the sector will be
marked again as dirty and re-examined later.
'stop': The job will be paused and the job iostatus will be set to
failed or nospace, while the VM will keep running. This can only be
specified if the block device has rerror=stop and werror=stop or enospc.
'enospc': Behaves as 'stop' for ENOSPC errors, 'report' for others.
In all cases, even for 'report', the I/O error is reported as a QMP
event BLOCK_JOB_ERROR, with the same arguments as BLOCK_IO_ERROR.
It is possible that while stopping the VM a BLOCK_IO_ERROR event will be
reported and will clobber the event from BLOCK_JOB_ERROR, or vice versa.
This is not really avoidable since stopping the VM completes all pending
I/O requests. In fact, it is already possible now that a series of
BLOCK_IO_ERROR events are reported with rerror=stop, because vm_stop
calls bdrv_drain_all and this can generate further errors.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2012-09-28 17:22:58 +02:00
|
|
|
|
|
|
|
static void block_job_iostatus_set_err(BlockJob *job, int error)
|
|
|
|
{
|
|
|
|
if (job->iostatus == BLOCK_DEVICE_IO_STATUS_OK) {
|
|
|
|
job->iostatus = error == ENOSPC ? BLOCK_DEVICE_IO_STATUS_NOSPACE :
|
|
|
|
BLOCK_DEVICE_IO_STATUS_FAILED;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-06-18 08:43:47 +02:00
|
|
|
void block_job_event_cancelled(BlockJob *job)
|
|
|
|
{
|
|
|
|
qapi_event_send_block_job_cancelled(job->driver->job_type,
|
2015-09-16 13:34:54 +02:00
|
|
|
job->id,
|
2014-06-18 08:43:47 +02:00
|
|
|
job->len,
|
|
|
|
job->offset,
|
|
|
|
job->speed,
|
|
|
|
&error_abort);
|
|
|
|
}
|
block: introduce block job error
The following behaviors are possible:
'report': The behavior is the same as in 1.1. An I/O error,
respectively during a read or a write, will complete the job immediately
with an error code.
'ignore': An I/O error, respectively during a read or a write, will be
ignored. For streaming, the job will complete with an error and the
backing file will be left in place. For mirroring, the sector will be
marked again as dirty and re-examined later.
'stop': The job will be paused and the job iostatus will be set to
failed or nospace, while the VM will keep running. This can only be
specified if the block device has rerror=stop and werror=stop or enospc.
'enospc': Behaves as 'stop' for ENOSPC errors, 'report' for others.
In all cases, even for 'report', the I/O error is reported as a QMP
event BLOCK_JOB_ERROR, with the same arguments as BLOCK_IO_ERROR.
It is possible that while stopping the VM a BLOCK_IO_ERROR event will be
reported and will clobber the event from BLOCK_JOB_ERROR, or vice versa.
This is not really avoidable since stopping the VM completes all pending
I/O requests. In fact, it is already possible now that a series of
BLOCK_IO_ERROR events are reported with rerror=stop, because vm_stop
calls bdrv_drain_all and this can generate further errors.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2012-09-28 17:22:58 +02:00
|
|
|
|
2014-06-18 08:43:47 +02:00
|
|
|
void block_job_event_completed(BlockJob *job, const char *msg)
|
2012-07-23 15:15:47 +02:00
|
|
|
{
|
2014-06-18 08:43:47 +02:00
|
|
|
qapi_event_send_block_job_completed(job->driver->job_type,
|
2015-09-16 13:34:54 +02:00
|
|
|
job->id,
|
2014-06-18 08:43:47 +02:00
|
|
|
job->len,
|
|
|
|
job->offset,
|
|
|
|
job->speed,
|
|
|
|
!!msg,
|
|
|
|
msg,
|
|
|
|
&error_abort);
|
2012-07-23 15:15:47 +02:00
|
|
|
}
|
|
|
|
|
2014-06-18 08:43:47 +02:00
|
|
|
void block_job_event_ready(BlockJob *job)
|
2012-07-23 15:15:47 +02:00
|
|
|
{
|
2014-10-24 15:57:34 +02:00
|
|
|
job->ready = true;
|
|
|
|
|
2014-06-27 19:24:13 +02:00
|
|
|
qapi_event_send_block_job_ready(job->driver->job_type,
|
2015-09-16 13:34:54 +02:00
|
|
|
job->id,
|
2014-06-27 19:24:13 +02:00
|
|
|
job->len,
|
|
|
|
job->offset,
|
|
|
|
job->speed, &error_abort);
|
2012-07-23 15:15:47 +02:00
|
|
|
}
|
|
|
|
|
2016-04-18 11:36:38 +02:00
|
|
|
BlockErrorAction block_job_error_action(BlockJob *job, BlockdevOnError on_err,
|
block: introduce block job error
The following behaviors are possible:
'report': The behavior is the same as in 1.1. An I/O error,
respectively during a read or a write, will complete the job immediately
with an error code.
'ignore': An I/O error, respectively during a read or a write, will be
ignored. For streaming, the job will complete with an error and the
backing file will be left in place. For mirroring, the sector will be
marked again as dirty and re-examined later.
'stop': The job will be paused and the job iostatus will be set to
failed or nospace, while the VM will keep running. This can only be
specified if the block device has rerror=stop and werror=stop or enospc.
'enospc': Behaves as 'stop' for ENOSPC errors, 'report' for others.
In all cases, even for 'report', the I/O error is reported as a QMP
event BLOCK_JOB_ERROR, with the same arguments as BLOCK_IO_ERROR.
It is possible that while stopping the VM a BLOCK_IO_ERROR event will be
reported and will clobber the event from BLOCK_JOB_ERROR, or vice versa.
This is not really avoidable since stopping the VM completes all pending
I/O requests. In fact, it is already possible now that a series of
BLOCK_IO_ERROR events are reported with rerror=stop, because vm_stop
calls bdrv_drain_all and this can generate further errors.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2012-09-28 17:22:58 +02:00
|
|
|
int is_read, int error)
|
|
|
|
{
|
|
|
|
BlockErrorAction action;
|
|
|
|
|
|
|
|
switch (on_err) {
|
|
|
|
case BLOCKDEV_ON_ERROR_ENOSPC:
|
2016-06-29 17:41:35 +02:00
|
|
|
case BLOCKDEV_ON_ERROR_AUTO:
|
2014-06-18 08:43:30 +02:00
|
|
|
action = (error == ENOSPC) ?
|
|
|
|
BLOCK_ERROR_ACTION_STOP : BLOCK_ERROR_ACTION_REPORT;
|
block: introduce block job error
The following behaviors are possible:
'report': The behavior is the same as in 1.1. An I/O error,
respectively during a read or a write, will complete the job immediately
with an error code.
'ignore': An I/O error, respectively during a read or a write, will be
ignored. For streaming, the job will complete with an error and the
backing file will be left in place. For mirroring, the sector will be
marked again as dirty and re-examined later.
'stop': The job will be paused and the job iostatus will be set to
failed or nospace, while the VM will keep running. This can only be
specified if the block device has rerror=stop and werror=stop or enospc.
'enospc': Behaves as 'stop' for ENOSPC errors, 'report' for others.
In all cases, even for 'report', the I/O error is reported as a QMP
event BLOCK_JOB_ERROR, with the same arguments as BLOCK_IO_ERROR.
It is possible that while stopping the VM a BLOCK_IO_ERROR event will be
reported and will clobber the event from BLOCK_JOB_ERROR, or vice versa.
This is not really avoidable since stopping the VM completes all pending
I/O requests. In fact, it is already possible now that a series of
BLOCK_IO_ERROR events are reported with rerror=stop, because vm_stop
calls bdrv_drain_all and this can generate further errors.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2012-09-28 17:22:58 +02:00
|
|
|
break;
|
|
|
|
case BLOCKDEV_ON_ERROR_STOP:
|
2014-06-18 08:43:30 +02:00
|
|
|
action = BLOCK_ERROR_ACTION_STOP;
|
block: introduce block job error
The following behaviors are possible:
'report': The behavior is the same as in 1.1. An I/O error,
respectively during a read or a write, will complete the job immediately
with an error code.
'ignore': An I/O error, respectively during a read or a write, will be
ignored. For streaming, the job will complete with an error and the
backing file will be left in place. For mirroring, the sector will be
marked again as dirty and re-examined later.
'stop': The job will be paused and the job iostatus will be set to
failed or nospace, while the VM will keep running. This can only be
specified if the block device has rerror=stop and werror=stop or enospc.
'enospc': Behaves as 'stop' for ENOSPC errors, 'report' for others.
In all cases, even for 'report', the I/O error is reported as a QMP
event BLOCK_JOB_ERROR, with the same arguments as BLOCK_IO_ERROR.
It is possible that while stopping the VM a BLOCK_IO_ERROR event will be
reported and will clobber the event from BLOCK_JOB_ERROR, or vice versa.
This is not really avoidable since stopping the VM completes all pending
I/O requests. In fact, it is already possible now that a series of
BLOCK_IO_ERROR events are reported with rerror=stop, because vm_stop
calls bdrv_drain_all and this can generate further errors.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2012-09-28 17:22:58 +02:00
|
|
|
break;
|
|
|
|
case BLOCKDEV_ON_ERROR_REPORT:
|
2014-06-18 08:43:30 +02:00
|
|
|
action = BLOCK_ERROR_ACTION_REPORT;
|
block: introduce block job error
The following behaviors are possible:
'report': The behavior is the same as in 1.1. An I/O error,
respectively during a read or a write, will complete the job immediately
with an error code.
'ignore': An I/O error, respectively during a read or a write, will be
ignored. For streaming, the job will complete with an error and the
backing file will be left in place. For mirroring, the sector will be
marked again as dirty and re-examined later.
'stop': The job will be paused and the job iostatus will be set to
failed or nospace, while the VM will keep running. This can only be
specified if the block device has rerror=stop and werror=stop or enospc.
'enospc': Behaves as 'stop' for ENOSPC errors, 'report' for others.
In all cases, even for 'report', the I/O error is reported as a QMP
event BLOCK_JOB_ERROR, with the same arguments as BLOCK_IO_ERROR.
It is possible that while stopping the VM a BLOCK_IO_ERROR event will be
reported and will clobber the event from BLOCK_JOB_ERROR, or vice versa.
This is not really avoidable since stopping the VM completes all pending
I/O requests. In fact, it is already possible now that a series of
BLOCK_IO_ERROR events are reported with rerror=stop, because vm_stop
calls bdrv_drain_all and this can generate further errors.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2012-09-28 17:22:58 +02:00
|
|
|
break;
|
|
|
|
case BLOCKDEV_ON_ERROR_IGNORE:
|
2014-06-18 08:43:30 +02:00
|
|
|
action = BLOCK_ERROR_ACTION_IGNORE;
|
block: introduce block job error
The following behaviors are possible:
'report': The behavior is the same as in 1.1. An I/O error,
respectively during a read or a write, will complete the job immediately
with an error code.
'ignore': An I/O error, respectively during a read or a write, will be
ignored. For streaming, the job will complete with an error and the
backing file will be left in place. For mirroring, the sector will be
marked again as dirty and re-examined later.
'stop': The job will be paused and the job iostatus will be set to
failed or nospace, while the VM will keep running. This can only be
specified if the block device has rerror=stop and werror=stop or enospc.
'enospc': Behaves as 'stop' for ENOSPC errors, 'report' for others.
In all cases, even for 'report', the I/O error is reported as a QMP
event BLOCK_JOB_ERROR, with the same arguments as BLOCK_IO_ERROR.
It is possible that while stopping the VM a BLOCK_IO_ERROR event will be
reported and will clobber the event from BLOCK_JOB_ERROR, or vice versa.
This is not really avoidable since stopping the VM completes all pending
I/O requests. In fact, it is already possible now that a series of
BLOCK_IO_ERROR events are reported with rerror=stop, because vm_stop
calls bdrv_drain_all and this can generate further errors.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2012-09-28 17:22:58 +02:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
abort();
|
|
|
|
}
|
2015-09-16 13:34:54 +02:00
|
|
|
qapi_event_send_block_job_error(job->id,
|
2014-06-18 08:43:45 +02:00
|
|
|
is_read ? IO_OPERATION_TYPE_READ :
|
|
|
|
IO_OPERATION_TYPE_WRITE,
|
|
|
|
action, &error_abort);
|
2014-06-18 08:43:30 +02:00
|
|
|
if (action == BLOCK_ERROR_ACTION_STOP) {
|
2015-04-03 16:05:18 +02:00
|
|
|
/* make the pause user visible, which will be resumed from QMP. */
|
|
|
|
job->user_paused = true;
|
block: introduce block job error
The following behaviors are possible:
'report': The behavior is the same as in 1.1. An I/O error,
respectively during a read or a write, will complete the job immediately
with an error code.
'ignore': An I/O error, respectively during a read or a write, will be
ignored. For streaming, the job will complete with an error and the
backing file will be left in place. For mirroring, the sector will be
marked again as dirty and re-examined later.
'stop': The job will be paused and the job iostatus will be set to
failed or nospace, while the VM will keep running. This can only be
specified if the block device has rerror=stop and werror=stop or enospc.
'enospc': Behaves as 'stop' for ENOSPC errors, 'report' for others.
In all cases, even for 'report', the I/O error is reported as a QMP
event BLOCK_JOB_ERROR, with the same arguments as BLOCK_IO_ERROR.
It is possible that while stopping the VM a BLOCK_IO_ERROR event will be
reported and will clobber the event from BLOCK_JOB_ERROR, or vice versa.
This is not really avoidable since stopping the VM completes all pending
I/O requests. In fact, it is already possible now that a series of
BLOCK_IO_ERROR events are reported with rerror=stop, because vm_stop
calls bdrv_drain_all and this can generate further errors.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2012-09-28 17:22:58 +02:00
|
|
|
block_job_pause(job);
|
|
|
|
block_job_iostatus_set_err(job, error);
|
|
|
|
}
|
|
|
|
return action;
|
|
|
|
}
|
2014-10-21 13:03:54 +02:00
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
BlockJob *job;
|
|
|
|
QEMUBH *bh;
|
|
|
|
AioContext *aio_context;
|
|
|
|
BlockJobDeferToMainLoopFn *fn;
|
|
|
|
void *opaque;
|
|
|
|
} BlockJobDeferToMainLoopData;
|
|
|
|
|
|
|
|
static void block_job_defer_to_main_loop_bh(void *opaque)
|
|
|
|
{
|
|
|
|
BlockJobDeferToMainLoopData *data = opaque;
|
|
|
|
AioContext *aio_context;
|
|
|
|
|
|
|
|
qemu_bh_delete(data->bh);
|
|
|
|
|
|
|
|
/* Prevent race with block_job_defer_to_main_loop() */
|
|
|
|
aio_context_acquire(data->aio_context);
|
|
|
|
|
|
|
|
/* Fetch BDS AioContext again, in case it has changed */
|
2016-04-08 14:51:09 +02:00
|
|
|
aio_context = blk_get_aio_context(data->job->blk);
|
2014-10-21 13:03:54 +02:00
|
|
|
aio_context_acquire(aio_context);
|
|
|
|
|
2016-02-02 03:12:24 +01:00
|
|
|
data->job->deferred_to_main_loop = false;
|
2014-10-21 13:03:54 +02:00
|
|
|
data->fn(data->job, data->opaque);
|
|
|
|
|
|
|
|
aio_context_release(aio_context);
|
|
|
|
|
|
|
|
aio_context_release(data->aio_context);
|
|
|
|
|
|
|
|
g_free(data);
|
|
|
|
}
|
|
|
|
|
|
|
|
void block_job_defer_to_main_loop(BlockJob *job,
|
|
|
|
BlockJobDeferToMainLoopFn *fn,
|
|
|
|
void *opaque)
|
|
|
|
{
|
|
|
|
BlockJobDeferToMainLoopData *data = g_malloc(sizeof(*data));
|
|
|
|
data->job = job;
|
|
|
|
data->bh = qemu_bh_new(block_job_defer_to_main_loop_bh, data);
|
2016-04-08 14:51:09 +02:00
|
|
|
data->aio_context = blk_get_aio_context(job->blk);
|
2014-10-21 13:03:54 +02:00
|
|
|
data->fn = fn;
|
|
|
|
data->opaque = opaque;
|
2016-02-02 03:12:24 +01:00
|
|
|
job->deferred_to_main_loop = true;
|
2014-10-21 13:03:54 +02:00
|
|
|
|
|
|
|
qemu_bh_schedule(data->bh);
|
|
|
|
}
|
2015-11-06 00:13:15 +01:00
|
|
|
|
|
|
|
BlockJobTxn *block_job_txn_new(void)
|
|
|
|
{
|
|
|
|
BlockJobTxn *txn = g_new0(BlockJobTxn, 1);
|
|
|
|
QLIST_INIT(&txn->jobs);
|
|
|
|
txn->refcnt = 1;
|
|
|
|
return txn;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void block_job_txn_ref(BlockJobTxn *txn)
|
|
|
|
{
|
|
|
|
txn->refcnt++;
|
|
|
|
}
|
|
|
|
|
|
|
|
void block_job_txn_unref(BlockJobTxn *txn)
|
|
|
|
{
|
|
|
|
if (txn && --txn->refcnt == 0) {
|
|
|
|
g_free(txn);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void block_job_txn_add_job(BlockJobTxn *txn, BlockJob *job)
|
|
|
|
{
|
|
|
|
if (!txn) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
assert(!job->txn);
|
|
|
|
job->txn = txn;
|
|
|
|
|
|
|
|
QLIST_INSERT_HEAD(&txn->jobs, job, txn_list);
|
|
|
|
block_job_txn_ref(txn);
|
|
|
|
}
|