2012-09-28 19:22:47 +04: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 20:50:05 +03:00
|
|
|
#include "qemu/osdep.h"
|
2012-09-28 19:22:47 +04:00
|
|
|
#include "qemu-common.h"
|
2012-12-17 21:19:44 +04:00
|
|
|
#include "block/block.h"
|
2016-10-27 19:07:00 +03:00
|
|
|
#include "block/blockjob_int.h"
|
2012-12-17 21:19:44 +04:00
|
|
|
#include "block/block_int.h"
|
2018-03-10 11:27:30 +03:00
|
|
|
#include "block/trace.h"
|
2015-10-19 18:53:22 +03:00
|
|
|
#include "sysemu/block-backend.h"
|
2018-02-01 14:18:31 +03:00
|
|
|
#include "qapi/error.h"
|
2018-02-11 12:36:01 +03:00
|
|
|
#include "qapi/qapi-events-block-core.h"
|
2015-03-17 19:22:46 +03:00
|
|
|
#include "qapi/qmp/qerror.h"
|
2015-09-01 16:48:02 +03:00
|
|
|
#include "qemu/coroutine.h"
|
2012-12-17 21:20:00 +04:00
|
|
|
#include "qemu/timer.h"
|
2012-09-28 19:22:47 +04:00
|
|
|
|
2017-05-08 17:13:04 +03:00
|
|
|
/*
|
|
|
|
* The block job API is composed of two categories of functions.
|
|
|
|
*
|
|
|
|
* The first includes functions used by the monitor. The monitor is
|
|
|
|
* peculiar in that it accesses the block job list with block_job_get, and
|
|
|
|
* therefore needs consistency across block_job_get and the actual operation
|
|
|
|
* (e.g. block_job_set_speed). The consistency is achieved with
|
|
|
|
* aio_context_acquire/release. These functions are declared in blockjob.h.
|
|
|
|
*
|
|
|
|
* The second includes functions used by the block job drivers and sometimes
|
|
|
|
* by the core block layer. These do not care about locking, because the
|
|
|
|
* whole coroutine runs under the AioContext lock, and are declared in
|
|
|
|
* blockjob_int.h.
|
|
|
|
*/
|
|
|
|
|
2018-04-12 18:54:37 +03:00
|
|
|
static bool is_block_job(Job *job)
|
2016-04-04 16:43:51 +03:00
|
|
|
{
|
2018-04-12 18:54:37 +03:00
|
|
|
return job_type(job) == JOB_TYPE_BACKUP ||
|
|
|
|
job_type(job) == JOB_TYPE_COMMIT ||
|
|
|
|
job_type(job) == JOB_TYPE_MIRROR ||
|
|
|
|
job_type(job) == JOB_TYPE_STREAM;
|
|
|
|
}
|
|
|
|
|
|
|
|
BlockJob *block_job_next(BlockJob *bjob)
|
|
|
|
{
|
|
|
|
Job *job = bjob ? &bjob->job : NULL;
|
|
|
|
|
|
|
|
do {
|
|
|
|
job = job_next(job);
|
|
|
|
} while (job && !is_block_job(job));
|
|
|
|
|
|
|
|
return job ? container_of(job, BlockJob, job) : NULL;
|
2016-04-04 16:43:51 +03:00
|
|
|
}
|
|
|
|
|
2016-07-05 17:28:54 +03:00
|
|
|
BlockJob *block_job_get(const char *id)
|
|
|
|
{
|
2018-04-12 18:54:37 +03:00
|
|
|
Job *job = job_get(id);
|
2016-07-05 17:28:54 +03:00
|
|
|
|
2018-04-12 18:54:37 +03:00
|
|
|
if (job && is_block_job(job)) {
|
|
|
|
return container_of(job, BlockJob, job);
|
|
|
|
} else {
|
|
|
|
return NULL;
|
2016-07-05 17:28:54 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-05-08 17:13:02 +03:00
|
|
|
static void block_job_attached_aio_context(AioContext *new_context,
|
|
|
|
void *opaque);
|
|
|
|
static void block_job_detach_aio_context(void *opaque);
|
|
|
|
|
2018-04-13 19:50:05 +03:00
|
|
|
void block_job_free(Job *job)
|
2017-05-08 17:13:02 +03:00
|
|
|
{
|
2018-04-13 19:50:05 +03:00
|
|
|
BlockJob *bjob = container_of(job, BlockJob, job);
|
|
|
|
BlockDriverState *bs = blk_bs(bjob->blk);
|
|
|
|
|
|
|
|
bs->job = NULL;
|
|
|
|
block_job_remove_all_bdrv(bjob);
|
|
|
|
blk_remove_aio_context_notifier(bjob->blk,
|
|
|
|
block_job_attached_aio_context,
|
|
|
|
block_job_detach_aio_context, bjob);
|
|
|
|
blk_unref(bjob->blk);
|
|
|
|
error_free(bjob->blocker);
|
2017-05-08 17:13:02 +03:00
|
|
|
}
|
|
|
|
|
2016-06-16 19:56:27 +03:00
|
|
|
static void block_job_attached_aio_context(AioContext *new_context,
|
|
|
|
void *opaque)
|
|
|
|
{
|
|
|
|
BlockJob *job = opaque;
|
2018-05-14 15:51:21 +03:00
|
|
|
const JobDriver *drv = job->job.driver;
|
|
|
|
BlockJobDriver *bjdrv = container_of(drv, BlockJobDriver, job_driver);
|
2016-06-16 19:56:27 +03:00
|
|
|
|
2018-04-17 14:49:33 +03:00
|
|
|
job->job.aio_context = new_context;
|
2018-05-14 15:51:21 +03:00
|
|
|
if (bjdrv->attached_aio_context) {
|
|
|
|
bjdrv->attached_aio_context(job, new_context);
|
2016-06-16 19:56:27 +03:00
|
|
|
}
|
|
|
|
|
2018-04-18 18:10:26 +03:00
|
|
|
job_resume(&job->job);
|
2016-06-16 19:56:27 +03:00
|
|
|
}
|
|
|
|
|
2018-04-20 18:00:29 +03:00
|
|
|
void block_job_drain(Job *job)
|
2016-10-27 13:48:50 +03:00
|
|
|
{
|
2018-04-20 18:00:29 +03:00
|
|
|
BlockJob *bjob = container_of(job, BlockJob, job);
|
2018-05-14 15:51:21 +03:00
|
|
|
const JobDriver *drv = job->driver;
|
|
|
|
BlockJobDriver *bjdrv = container_of(drv, BlockJobDriver, job_driver);
|
2016-10-27 13:48:50 +03:00
|
|
|
|
2018-04-20 18:00:29 +03:00
|
|
|
blk_drain(bjob->blk);
|
2018-05-14 15:51:21 +03:00
|
|
|
if (bjdrv->drain) {
|
|
|
|
bjdrv->drain(bjob);
|
2016-10-27 13:48:50 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-06-16 19:56:27 +03:00
|
|
|
static void block_job_detach_aio_context(void *opaque)
|
|
|
|
{
|
|
|
|
BlockJob *job = opaque;
|
|
|
|
|
|
|
|
/* In case the job terminates during aio_poll()... */
|
2018-04-13 19:50:05 +03:00
|
|
|
job_ref(&job->job);
|
2016-06-16 19:56:27 +03:00
|
|
|
|
2018-04-18 18:10:26 +03:00
|
|
|
job_pause(&job->job);
|
2016-06-16 19:56:27 +03:00
|
|
|
|
2018-04-19 14:04:01 +03:00
|
|
|
while (!job->job.paused && !job_is_completed(&job->job)) {
|
2018-04-20 18:00:29 +03:00
|
|
|
job_drain(&job->job);
|
2016-06-16 19:56:27 +03:00
|
|
|
}
|
|
|
|
|
2018-04-17 14:49:33 +03:00
|
|
|
job->job.aio_context = NULL;
|
2018-04-13 19:50:05 +03:00
|
|
|
job_unref(&job->job);
|
2016-06-16 19:56:27 +03:00
|
|
|
}
|
|
|
|
|
2017-05-08 17:13:03 +03:00
|
|
|
static char *child_job_get_parent_desc(BdrvChild *c)
|
|
|
|
{
|
|
|
|
BlockJob *job = c->opaque;
|
2018-04-12 18:57:08 +03:00
|
|
|
return g_strdup_printf("%s job '%s'", job_type_str(&job->job), job->job.id);
|
2017-05-08 17:13:03 +03:00
|
|
|
}
|
|
|
|
|
2017-12-12 21:04:28 +03:00
|
|
|
static void child_job_drained_begin(BdrvChild *c)
|
2017-05-08 17:13:03 +03:00
|
|
|
{
|
2017-12-12 21:04:28 +03:00
|
|
|
BlockJob *job = c->opaque;
|
2018-04-18 18:10:26 +03:00
|
|
|
job_pause(&job->job);
|
2017-05-08 17:13:03 +03:00
|
|
|
}
|
|
|
|
|
2018-03-22 16:11:20 +03:00
|
|
|
static bool child_job_drained_poll(BdrvChild *c)
|
|
|
|
{
|
|
|
|
BlockJob *bjob = c->opaque;
|
|
|
|
Job *job = &bjob->job;
|
|
|
|
const BlockJobDriver *drv = block_job_driver(bjob);
|
|
|
|
|
|
|
|
/* An inactive or completed job doesn't have any pending requests. Jobs
|
|
|
|
* with !job->busy are either already paused or have a pause point after
|
|
|
|
* being reentered, so no job driver code will run before they pause. */
|
|
|
|
if (!job->busy || job_is_completed(job) || job->deferred_to_main_loop) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Otherwise, assume that it isn't fully stopped yet, but allow the job to
|
|
|
|
* override this assumption. */
|
|
|
|
if (drv->drained_poll) {
|
|
|
|
return drv->drained_poll(bjob);
|
|
|
|
} else {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-12-12 21:04:28 +03:00
|
|
|
static void child_job_drained_end(BdrvChild *c)
|
2017-05-08 17:13:03 +03:00
|
|
|
{
|
2017-12-12 21:04:28 +03:00
|
|
|
BlockJob *job = c->opaque;
|
2018-04-18 18:10:26 +03:00
|
|
|
job_resume(&job->job);
|
2017-05-08 17:13:03 +03:00
|
|
|
}
|
|
|
|
|
2017-12-12 21:04:28 +03:00
|
|
|
static const BdrvChildRole child_job = {
|
|
|
|
.get_parent_desc = child_job_get_parent_desc,
|
|
|
|
.drained_begin = child_job_drained_begin,
|
2018-03-22 16:11:20 +03:00
|
|
|
.drained_poll = child_job_drained_poll,
|
2017-12-12 21:04:28 +03:00
|
|
|
.drained_end = child_job_drained_end,
|
|
|
|
.stay_at_node = true,
|
2017-05-08 17:13:03 +03:00
|
|
|
};
|
|
|
|
|
2017-02-28 14:45:58 +03:00
|
|
|
void block_job_remove_all_bdrv(BlockJob *job)
|
|
|
|
{
|
|
|
|
GSList *l;
|
|
|
|
for (l = job->nodes; l; l = l->next) {
|
|
|
|
BdrvChild *c = l->data;
|
|
|
|
bdrv_op_unblock_all(c->bs, job->blocker);
|
|
|
|
bdrv_root_unref_child(c);
|
|
|
|
}
|
|
|
|
g_slist_free(job->nodes);
|
|
|
|
job->nodes = NULL;
|
|
|
|
}
|
|
|
|
|
2017-01-17 13:56:42 +03:00
|
|
|
int block_job_add_bdrv(BlockJob *job, const char *name, BlockDriverState *bs,
|
|
|
|
uint64_t perm, uint64_t shared_perm, Error **errp)
|
2016-10-28 10:08:04 +03:00
|
|
|
{
|
2017-01-17 13:56:42 +03:00
|
|
|
BdrvChild *c;
|
|
|
|
|
|
|
|
c = bdrv_root_attach_child(bs, name, &child_job, perm, shared_perm,
|
|
|
|
job, errp);
|
|
|
|
if (c == NULL) {
|
|
|
|
return -EPERM;
|
|
|
|
}
|
|
|
|
|
|
|
|
job->nodes = g_slist_prepend(job->nodes, c);
|
2016-10-28 10:08:04 +03:00
|
|
|
bdrv_ref(bs);
|
|
|
|
bdrv_op_block_all(bs, job->blocker);
|
2017-01-17 13:56:42 +03:00
|
|
|
|
|
|
|
return 0;
|
2016-10-28 10:08:04 +03:00
|
|
|
}
|
|
|
|
|
2016-10-27 19:06:55 +03:00
|
|
|
bool block_job_is_internal(BlockJob *job)
|
|
|
|
{
|
2018-04-12 18:29:59 +03:00
|
|
|
return (job->job.id == NULL);
|
2016-10-27 19:06:55 +03:00
|
|
|
}
|
|
|
|
|
2018-01-19 17:54:40 +03:00
|
|
|
const BlockJobDriver *block_job_driver(BlockJob *job)
|
|
|
|
{
|
2018-05-14 15:51:21 +03:00
|
|
|
return container_of(job->job.driver, BlockJobDriver, job_driver);
|
2018-01-19 17:54:40 +03:00
|
|
|
}
|
|
|
|
|
2018-04-13 18:31:02 +03:00
|
|
|
/* Assumes the job_mutex is held */
|
|
|
|
static bool job_timer_pending(Job *job)
|
|
|
|
{
|
|
|
|
return timer_pending(&job->sleep_timer);
|
|
|
|
}
|
|
|
|
|
2012-09-28 19:22:47 +04:00
|
|
|
void block_job_set_speed(BlockJob *job, int64_t speed, Error **errp)
|
|
|
|
{
|
2017-12-13 23:46:11 +03:00
|
|
|
int64_t old_speed = job->speed;
|
2012-09-28 19:22:47 +04:00
|
|
|
|
2018-04-13 18:19:31 +03:00
|
|
|
if (job_apply_verb(&job->job, JOB_VERB_SET_SPEED, errp)) {
|
blockjobs: add block_job_verb permission table
Which commands ("verbs") are appropriate for jobs in which state is
also somewhat burdensome to keep track of.
As of this commit, it looks rather useless, but begins to look more
interesting the more states we add to the STM table.
A recurring theme is that no verb will apply to an 'undefined' job.
Further, it's not presently possible to restrict the "pause" or "resume"
verbs any more than they are in this commit because of the asynchronous
nature of how jobs enter the PAUSED state; justifications for some
seemingly erroneous applications are given below.
=====
Verbs
=====
Cancel: Any state except undefined.
Pause: Any state except undefined;
'created': Requests that the job pauses as it starts.
'running': Normal usage. (PAUSED)
'paused': The job may be paused for internal reasons,
but the user may wish to force an indefinite
user-pause, so this is allowed.
'ready': Normal usage. (STANDBY)
'standby': Same logic as above.
Resume: Any state except undefined;
'created': Will lift a user's pause-on-start request.
'running': Will lift a pause request before it takes effect.
'paused': Normal usage.
'ready': Will lift a pause request before it takes effect.
'standby': Normal usage.
Set-speed: Any state except undefined, though ready may not be meaningful.
Complete: Only a 'ready' job may accept a complete request.
=======
Changes
=======
(1)
To facilitate "nice" error checking, all five major block-job verb
interfaces in blockjob.c now support an errp parameter:
- block_job_user_cancel is added as a new interface.
- block_job_user_pause gains an errp paramter
- block_job_user_resume gains an errp parameter
- block_job_set_speed already had an errp parameter.
- block_job_complete already had an errp parameter.
(2)
block-job-pause and block-job-resume will no longer no-op when trying
to pause an already paused job, or trying to resume a job that isn't
paused. These functions will now report that they did not perform the
action requested because it was not possible.
iotests have been adjusted to address this new behavior.
(3)
block-job-complete doesn't worry about checking !block_job_started,
because the permission table guards against this.
(4)
test-bdrv-drain's job implementation needs to announce that it is
'ready' now, in order to be completed.
Signed-off-by: John Snow <jsnow@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2018-03-10 11:27:32 +03:00
|
|
|
return;
|
|
|
|
}
|
2018-01-18 22:25:40 +03:00
|
|
|
if (speed < 0) {
|
|
|
|
error_setg(errp, QERR_INVALID_PARAMETER, "speed");
|
2012-09-28 19:22:47 +04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2018-01-18 22:25:40 +03:00
|
|
|
ratelimit_set_speed(&job->limit, speed, BLOCK_JOB_SLICE_TIME);
|
|
|
|
|
2012-09-28 19:22:47 +04:00
|
|
|
job->speed = speed;
|
2018-03-10 11:27:26 +03:00
|
|
|
if (speed && speed <= old_speed) {
|
2017-12-13 23:46:11 +03:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* kick only if a timer is pending */
|
2018-04-13 18:31:02 +03:00
|
|
|
job_enter_cond(&job->job, job_timer_pending);
|
2012-09-28 19:22:47 +04:00
|
|
|
}
|
|
|
|
|
2018-01-18 23:19:38 +03:00
|
|
|
int64_t block_job_ratelimit_get_delay(BlockJob *job, uint64_t n)
|
|
|
|
{
|
|
|
|
if (!job->speed) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ratelimit_calculate_delay(&job->limit, n);
|
|
|
|
}
|
|
|
|
|
2016-10-27 19:06:55 +03:00
|
|
|
BlockJobInfo *block_job_query(BlockJob *job, Error **errp)
|
2012-09-28 19:22:48 +04:00
|
|
|
{
|
2016-10-27 19:06:55 +03:00
|
|
|
BlockJobInfo *info;
|
|
|
|
|
|
|
|
if (block_job_is_internal(job)) {
|
|
|
|
error_setg(errp, "Cannot query QEMU internal jobs");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
info = g_new0(BlockJobInfo, 1);
|
2018-04-12 18:57:08 +03:00
|
|
|
info->type = g_strdup(job_type_str(&job->job));
|
2018-04-12 18:29:59 +03:00
|
|
|
info->device = g_strdup(job->job.id);
|
2018-04-13 18:31:02 +03:00
|
|
|
info->busy = atomic_read(&job->job.busy);
|
|
|
|
info->paused = job->job.pause_count > 0;
|
2018-05-04 13:17:20 +03:00
|
|
|
info->offset = job->job.progress_current;
|
|
|
|
info->len = job->job.progress_total;
|
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 19:22:58 +04:00
|
|
|
info->speed = job->speed;
|
|
|
|
info->io_status = job->iostatus;
|
2018-04-25 16:09:58 +03:00
|
|
|
info->ready = job_is_ready(&job->job),
|
2018-04-13 18:19:31 +03:00
|
|
|
info->status = job->job.status;
|
2018-04-19 18:54:56 +03:00
|
|
|
info->auto_finalize = job->job.auto_finalize;
|
|
|
|
info->auto_dismiss = job->job.auto_dismiss;
|
2018-04-19 18:30:16 +03:00
|
|
|
info->has_error = job->job.ret != 0;
|
|
|
|
info->error = job->job.ret ? g_strdup(strerror(-job->job.ret)) : NULL;
|
2012-09-28 19:22:48 +04: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 19:22:58 +04: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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-04-23 19:04:57 +03:00
|
|
|
static void block_job_event_cancelled(Notifier *n, void *opaque)
|
2014-06-18 10:43:47 +04:00
|
|
|
{
|
2018-04-23 19:04:57 +03:00
|
|
|
BlockJob *job = opaque;
|
|
|
|
|
2016-10-27 19:06:55 +03:00
|
|
|
if (block_job_is_internal(job)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2018-04-12 18:57:08 +03:00
|
|
|
qapi_event_send_block_job_cancelled(job_type(&job->job),
|
2018-04-12 18:29:59 +03:00
|
|
|
job->job.id,
|
2018-05-04 13:17:20 +03:00
|
|
|
job->job.progress_total,
|
|
|
|
job->job.progress_current,
|
2018-08-15 16:37:37 +03:00
|
|
|
job->speed);
|
2014-06-18 10:43:47 +04: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 19:22:58 +04:00
|
|
|
|
2018-04-23 19:04:57 +03:00
|
|
|
static void block_job_event_completed(Notifier *n, void *opaque)
|
2012-07-23 17:15:47 +04:00
|
|
|
{
|
2018-04-23 19:04:57 +03:00
|
|
|
BlockJob *job = opaque;
|
|
|
|
const char *msg = NULL;
|
|
|
|
|
2016-10-27 19:06:55 +03:00
|
|
|
if (block_job_is_internal(job)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2018-04-19 18:30:16 +03:00
|
|
|
if (job->job.ret < 0) {
|
|
|
|
msg = strerror(-job->job.ret);
|
2018-04-23 19:04:57 +03:00
|
|
|
}
|
|
|
|
|
2018-04-12 18:57:08 +03:00
|
|
|
qapi_event_send_block_job_completed(job_type(&job->job),
|
2018-04-12 18:29:59 +03:00
|
|
|
job->job.id,
|
2018-05-04 13:17:20 +03:00
|
|
|
job->job.progress_total,
|
|
|
|
job->job.progress_current,
|
2014-06-18 10:43:47 +04:00
|
|
|
job->speed,
|
|
|
|
!!msg,
|
2018-08-15 16:37:37 +03:00
|
|
|
msg);
|
2012-07-23 17:15:47 +04:00
|
|
|
}
|
|
|
|
|
2018-04-23 19:04:57 +03:00
|
|
|
static void block_job_event_pending(Notifier *n, void *opaque)
|
2018-03-10 11:27:42 +03:00
|
|
|
{
|
2018-04-23 19:04:57 +03:00
|
|
|
BlockJob *job = opaque;
|
|
|
|
|
2018-04-23 18:09:42 +03:00
|
|
|
if (block_job_is_internal(job)) {
|
|
|
|
return;
|
2018-03-10 11:27:42 +03:00
|
|
|
}
|
2018-04-23 18:09:42 +03:00
|
|
|
|
|
|
|
qapi_event_send_block_job_pending(job_type(&job->job),
|
2018-08-15 16:37:37 +03:00
|
|
|
job->job.id);
|
2018-03-10 11:27:42 +03:00
|
|
|
}
|
|
|
|
|
2018-04-25 15:56:09 +03:00
|
|
|
static void block_job_event_ready(Notifier *n, void *opaque)
|
|
|
|
{
|
|
|
|
BlockJob *job = opaque;
|
|
|
|
|
|
|
|
if (block_job_is_internal(job)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
qapi_event_send_block_job_ready(job_type(&job->job),
|
|
|
|
job->job.id,
|
2018-05-04 13:17:20 +03:00
|
|
|
job->job.progress_total,
|
|
|
|
job->job.progress_current,
|
2018-08-15 16:37:37 +03:00
|
|
|
job->speed);
|
2018-04-25 15:56:09 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2017-05-08 17:13:04 +03:00
|
|
|
/*
|
|
|
|
* API for block job drivers and the block layer. These functions are
|
|
|
|
* declared in blockjob_int.h.
|
|
|
|
*/
|
|
|
|
|
|
|
|
void *block_job_create(const char *job_id, const BlockJobDriver *driver,
|
2018-04-19 17:09:52 +03:00
|
|
|
JobTxn *txn, BlockDriverState *bs, uint64_t perm,
|
2017-05-08 17:13:04 +03:00
|
|
|
uint64_t shared_perm, int64_t speed, int flags,
|
|
|
|
BlockCompletionFunc *cb, void *opaque, Error **errp)
|
|
|
|
{
|
|
|
|
BlockBackend *blk;
|
|
|
|
BlockJob *job;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (bs->job) {
|
|
|
|
error_setg(errp, QERR_DEVICE_IN_USE, bdrv_get_device_name(bs));
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2018-04-19 18:54:56 +03:00
|
|
|
if (job_id == NULL && !(flags & JOB_INTERNAL)) {
|
2017-05-08 17:13:04 +03:00
|
|
|
job_id = bdrv_get_device_name(bs);
|
|
|
|
}
|
|
|
|
|
|
|
|
blk = blk_new(perm, shared_perm);
|
|
|
|
ret = blk_insert_bs(blk, bs, errp);
|
|
|
|
if (ret < 0) {
|
|
|
|
blk_unref(blk);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2018-04-23 17:06:26 +03:00
|
|
|
job = job_create(job_id, &driver->job_driver, txn, blk_get_aio_context(blk),
|
2018-04-19 18:30:16 +03:00
|
|
|
flags, cb, opaque, errp);
|
2018-04-12 18:29:59 +03:00
|
|
|
if (job == NULL) {
|
|
|
|
blk_unref(blk);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2018-04-12 18:54:37 +03:00
|
|
|
assert(is_block_job(&job->job));
|
2018-04-13 19:50:05 +03:00
|
|
|
assert(job->job.driver->free == &block_job_free);
|
2018-04-18 18:10:26 +03:00
|
|
|
assert(job->job.driver->user_resume == &block_job_user_resume);
|
2018-04-20 18:00:29 +03:00
|
|
|
assert(job->job.driver->drain == &block_job_drain);
|
2018-04-12 18:54:37 +03:00
|
|
|
|
2018-05-14 15:51:21 +03:00
|
|
|
job->blk = blk;
|
2017-05-08 17:13:04 +03:00
|
|
|
|
2018-04-23 19:04:57 +03:00
|
|
|
job->finalize_cancelled_notifier.notify = block_job_event_cancelled;
|
|
|
|
job->finalize_completed_notifier.notify = block_job_event_completed;
|
|
|
|
job->pending_notifier.notify = block_job_event_pending;
|
2018-04-25 15:56:09 +03:00
|
|
|
job->ready_notifier.notify = block_job_event_ready;
|
2018-04-23 19:04:57 +03:00
|
|
|
|
|
|
|
notifier_list_add(&job->job.on_finalize_cancelled,
|
|
|
|
&job->finalize_cancelled_notifier);
|
|
|
|
notifier_list_add(&job->job.on_finalize_completed,
|
|
|
|
&job->finalize_completed_notifier);
|
|
|
|
notifier_list_add(&job->job.on_pending, &job->pending_notifier);
|
2018-04-25 15:56:09 +03:00
|
|
|
notifier_list_add(&job->job.on_ready, &job->ready_notifier);
|
2018-04-23 19:04:57 +03:00
|
|
|
|
2017-05-08 17:13:04 +03:00
|
|
|
error_setg(&job->blocker, "block device is in use by block job: %s",
|
2018-04-12 18:57:08 +03:00
|
|
|
job_type_str(&job->job));
|
2017-05-08 17:13:04 +03:00
|
|
|
block_job_add_bdrv(job, "main node", bs, 0, BLK_PERM_ALL, &error_abort);
|
|
|
|
bs->job = job;
|
|
|
|
|
|
|
|
bdrv_op_unblock(bs, BLOCK_OP_TYPE_DATAPLANE, job->blocker);
|
|
|
|
|
|
|
|
blk_add_aio_context_notifier(blk, block_job_attached_aio_context,
|
|
|
|
block_job_detach_aio_context, job);
|
|
|
|
|
|
|
|
/* Only set speed when necessary to avoid NotSupported error */
|
|
|
|
if (speed != 0) {
|
|
|
|
Error *local_err = NULL;
|
|
|
|
|
|
|
|
block_job_set_speed(job, speed, &local_err);
|
|
|
|
if (local_err) {
|
2018-04-19 18:30:16 +03:00
|
|
|
job_early_fail(&job->job);
|
2017-05-08 17:13:04 +03:00
|
|
|
error_propagate(errp, local_err);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
2018-03-10 11:27:27 +03:00
|
|
|
|
2017-05-08 17:13:04 +03:00
|
|
|
return job;
|
|
|
|
}
|
|
|
|
|
2017-05-08 17:13:05 +03:00
|
|
|
void block_job_iostatus_reset(BlockJob *job)
|
|
|
|
{
|
2017-05-08 17:13:06 +03:00
|
|
|
if (job->iostatus == BLOCK_DEVICE_IO_STATUS_OK) {
|
|
|
|
return;
|
|
|
|
}
|
2018-04-18 18:10:26 +03:00
|
|
|
assert(job->job.user_paused && job->job.pause_count > 0);
|
2017-05-08 17:13:05 +03:00
|
|
|
job->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
|
|
|
|
}
|
|
|
|
|
2018-04-18 18:10:26 +03:00
|
|
|
void block_job_user_resume(Job *job)
|
|
|
|
{
|
|
|
|
BlockJob *bjob = container_of(job, BlockJob, job);
|
|
|
|
block_job_iostatus_reset(bjob);
|
|
|
|
}
|
|
|
|
|
2016-04-18 12:36:38 +03: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 19:22:58 +04:00
|
|
|
int is_read, int error)
|
|
|
|
{
|
|
|
|
BlockErrorAction action;
|
|
|
|
|
|
|
|
switch (on_err) {
|
|
|
|
case BLOCKDEV_ON_ERROR_ENOSPC:
|
2016-06-29 18:41:35 +03:00
|
|
|
case BLOCKDEV_ON_ERROR_AUTO:
|
2014-06-18 10:43:30 +04: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 19:22:58 +04:00
|
|
|
break;
|
|
|
|
case BLOCKDEV_ON_ERROR_STOP:
|
2014-06-18 10:43:30 +04: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 19:22:58 +04:00
|
|
|
break;
|
|
|
|
case BLOCKDEV_ON_ERROR_REPORT:
|
2014-06-18 10:43:30 +04: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 19:22:58 +04:00
|
|
|
break;
|
|
|
|
case BLOCKDEV_ON_ERROR_IGNORE:
|
2014-06-18 10:43:30 +04: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 19:22:58 +04:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
abort();
|
|
|
|
}
|
2016-10-27 19:06:55 +03:00
|
|
|
if (!block_job_is_internal(job)) {
|
2018-04-12 18:29:59 +03:00
|
|
|
qapi_event_send_block_job_error(job->job.id,
|
2016-10-27 19:06:55 +03:00
|
|
|
is_read ? IO_OPERATION_TYPE_READ :
|
|
|
|
IO_OPERATION_TYPE_WRITE,
|
2018-08-15 16:37:37 +03:00
|
|
|
action);
|
2016-10-27 19:06:55 +03:00
|
|
|
}
|
2014-06-18 10:43:30 +04:00
|
|
|
if (action == BLOCK_ERROR_ACTION_STOP) {
|
2018-04-18 18:10:26 +03:00
|
|
|
job_pause(&job->job);
|
2015-04-03 17:05:18 +03:00
|
|
|
/* make the pause user visible, which will be resumed from QMP. */
|
2018-04-18 18:10:26 +03:00
|
|
|
job->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 19:22:58 +04:00
|
|
|
block_job_iostatus_set_err(job, error);
|
|
|
|
}
|
|
|
|
return action;
|
|
|
|
}
|