mirror of
https://github.com/qemu/qemu.git
synced 2024-12-15 07:23:52 +08:00
b660a84bbb
All callers of job_txn_apply hold a single job's lock, but different jobs within a transaction can have different contexts, thus we need to lock each one individually before applying the callback function. Similar to job_completed_txn_abort this also requires releasing the caller's context before and reacquiring it after to avoid recursive locks which might break AIO_WAIT_WHILE in the callback. This is safe, since existing code would already have to take this into account, lest job_completed_txn_abort might have broken. This also brings to light a different issue: When a callback function in job_txn_apply moves it's job to a different AIO context, callers will try to release the wrong lock (now that we re-acquire the lock correctly, previously it would just continue with the old lock, leaving the job unlocked for the rest of the return path). Fix this by not caching the job's context. This is only necessary for qmp_block_job_finalize, qmp_job_finalize and job_exit, since everyone else calls through job_exit. One test needed adapting, since it calls job_finalize directly, so it manually needs to acquire the correct context. Signed-off-by: Stefan Reiter <s.reiter@proxmox.com> Message-Id: <20200407115651.69472-2-s.reiter@proxmox.com> Signed-off-by: Kevin Wolf <kwolf@redhat.com>
394 lines
9.4 KiB
C
394 lines
9.4 KiB
C
/*
|
|
* Blockjob tests
|
|
*
|
|
* Copyright Igalia, S.L. 2016
|
|
*
|
|
* Authors:
|
|
* Alberto Garcia <berto@igalia.com>
|
|
*
|
|
* This work is licensed under the terms of the GNU LGPL, version 2 or later.
|
|
* See the COPYING.LIB file in the top-level directory.
|
|
*/
|
|
|
|
#include "qemu/osdep.h"
|
|
#include "qapi/error.h"
|
|
#include "qemu/main-loop.h"
|
|
#include "block/blockjob_int.h"
|
|
#include "sysemu/block-backend.h"
|
|
#include "qapi/qmp/qdict.h"
|
|
|
|
static const BlockJobDriver test_block_job_driver = {
|
|
.job_driver = {
|
|
.instance_size = sizeof(BlockJob),
|
|
.free = block_job_free,
|
|
.user_resume = block_job_user_resume,
|
|
},
|
|
};
|
|
|
|
static void block_job_cb(void *opaque, int ret)
|
|
{
|
|
}
|
|
|
|
static BlockJob *mk_job(BlockBackend *blk, const char *id,
|
|
const BlockJobDriver *drv, bool should_succeed,
|
|
int flags)
|
|
{
|
|
BlockJob *job;
|
|
Error *err = NULL;
|
|
|
|
job = block_job_create(id, drv, NULL, blk_bs(blk),
|
|
0, BLK_PERM_ALL, 0, flags, block_job_cb,
|
|
NULL, &err);
|
|
if (should_succeed) {
|
|
g_assert_null(err);
|
|
g_assert_nonnull(job);
|
|
if (id) {
|
|
g_assert_cmpstr(job->job.id, ==, id);
|
|
} else {
|
|
g_assert_cmpstr(job->job.id, ==, blk_name(blk));
|
|
}
|
|
} else {
|
|
error_free_or_abort(&err);
|
|
g_assert_null(job);
|
|
}
|
|
|
|
return job;
|
|
}
|
|
|
|
static BlockJob *do_test_id(BlockBackend *blk, const char *id,
|
|
bool should_succeed)
|
|
{
|
|
return mk_job(blk, id, &test_block_job_driver,
|
|
should_succeed, JOB_DEFAULT);
|
|
}
|
|
|
|
/* This creates a BlockBackend (optionally with a name) with a
|
|
* BlockDriverState inserted. */
|
|
static BlockBackend *create_blk(const char *name)
|
|
{
|
|
/* No I/O is performed on this device */
|
|
BlockBackend *blk = blk_new(qemu_get_aio_context(), 0, BLK_PERM_ALL);
|
|
BlockDriverState *bs;
|
|
|
|
QDict *opt = qdict_new();
|
|
qdict_put_str(opt, "file.read-zeroes", "on");
|
|
bs = bdrv_open("null-co://", NULL, opt, 0, &error_abort);
|
|
g_assert_nonnull(bs);
|
|
|
|
blk_insert_bs(blk, bs, &error_abort);
|
|
bdrv_unref(bs);
|
|
|
|
if (name) {
|
|
Error *err = NULL;
|
|
monitor_add_blk(blk, name, &err);
|
|
g_assert_null(err);
|
|
}
|
|
|
|
return blk;
|
|
}
|
|
|
|
/* This destroys the backend */
|
|
static void destroy_blk(BlockBackend *blk)
|
|
{
|
|
if (blk_name(blk)[0] != '\0') {
|
|
monitor_remove_blk(blk);
|
|
}
|
|
|
|
blk_remove_bs(blk);
|
|
blk_unref(blk);
|
|
}
|
|
|
|
static void test_job_ids(void)
|
|
{
|
|
BlockBackend *blk[3];
|
|
BlockJob *job[3];
|
|
|
|
blk[0] = create_blk(NULL);
|
|
blk[1] = create_blk("drive1");
|
|
blk[2] = create_blk("drive2");
|
|
|
|
/* No job ID provided and the block backend has no name */
|
|
job[0] = do_test_id(blk[0], NULL, false);
|
|
|
|
/* These are all invalid job IDs */
|
|
job[0] = do_test_id(blk[0], "0id", false);
|
|
job[0] = do_test_id(blk[0], "", false);
|
|
job[0] = do_test_id(blk[0], " ", false);
|
|
job[0] = do_test_id(blk[0], "123", false);
|
|
job[0] = do_test_id(blk[0], "_id", false);
|
|
job[0] = do_test_id(blk[0], "-id", false);
|
|
job[0] = do_test_id(blk[0], ".id", false);
|
|
job[0] = do_test_id(blk[0], "#id", false);
|
|
|
|
/* This one is valid */
|
|
job[0] = do_test_id(blk[0], "id0", true);
|
|
|
|
/* We can have two jobs in the same BDS */
|
|
job[1] = do_test_id(blk[0], "id1", true);
|
|
job_early_fail(&job[1]->job);
|
|
|
|
/* Duplicate job IDs are not allowed */
|
|
job[1] = do_test_id(blk[1], "id0", false);
|
|
|
|
/* But once job[0] finishes we can reuse its ID */
|
|
job_early_fail(&job[0]->job);
|
|
job[1] = do_test_id(blk[1], "id0", true);
|
|
|
|
/* No job ID specified, defaults to the backend name ('drive1') */
|
|
job_early_fail(&job[1]->job);
|
|
job[1] = do_test_id(blk[1], NULL, true);
|
|
|
|
/* Duplicate job ID */
|
|
job[2] = do_test_id(blk[2], "drive1", false);
|
|
|
|
/* The ID of job[2] would default to 'drive2' but it is already in use */
|
|
job[0] = do_test_id(blk[0], "drive2", true);
|
|
job[2] = do_test_id(blk[2], NULL, false);
|
|
|
|
/* This one is valid */
|
|
job[2] = do_test_id(blk[2], "id_2", true);
|
|
|
|
job_early_fail(&job[0]->job);
|
|
job_early_fail(&job[1]->job);
|
|
job_early_fail(&job[2]->job);
|
|
|
|
destroy_blk(blk[0]);
|
|
destroy_blk(blk[1]);
|
|
destroy_blk(blk[2]);
|
|
}
|
|
|
|
typedef struct CancelJob {
|
|
BlockJob common;
|
|
BlockBackend *blk;
|
|
bool should_converge;
|
|
bool should_complete;
|
|
} CancelJob;
|
|
|
|
static void cancel_job_complete(Job *job, Error **errp)
|
|
{
|
|
CancelJob *s = container_of(job, CancelJob, common.job);
|
|
s->should_complete = true;
|
|
}
|
|
|
|
static int coroutine_fn cancel_job_run(Job *job, Error **errp)
|
|
{
|
|
CancelJob *s = container_of(job, CancelJob, common.job);
|
|
|
|
while (!s->should_complete) {
|
|
if (job_is_cancelled(&s->common.job)) {
|
|
return 0;
|
|
}
|
|
|
|
if (!job_is_ready(&s->common.job) && s->should_converge) {
|
|
job_transition_to_ready(&s->common.job);
|
|
}
|
|
|
|
job_sleep_ns(&s->common.job, 100000);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static const BlockJobDriver test_cancel_driver = {
|
|
.job_driver = {
|
|
.instance_size = sizeof(CancelJob),
|
|
.free = block_job_free,
|
|
.user_resume = block_job_user_resume,
|
|
.run = cancel_job_run,
|
|
.complete = cancel_job_complete,
|
|
},
|
|
};
|
|
|
|
static CancelJob *create_common(Job **pjob)
|
|
{
|
|
BlockBackend *blk;
|
|
Job *job;
|
|
BlockJob *bjob;
|
|
CancelJob *s;
|
|
|
|
blk = create_blk(NULL);
|
|
bjob = mk_job(blk, "Steve", &test_cancel_driver, true,
|
|
JOB_MANUAL_FINALIZE | JOB_MANUAL_DISMISS);
|
|
job = &bjob->job;
|
|
job_ref(job);
|
|
assert(job->status == JOB_STATUS_CREATED);
|
|
s = container_of(bjob, CancelJob, common);
|
|
s->blk = blk;
|
|
|
|
*pjob = job;
|
|
return s;
|
|
}
|
|
|
|
static void cancel_common(CancelJob *s)
|
|
{
|
|
BlockJob *job = &s->common;
|
|
BlockBackend *blk = s->blk;
|
|
JobStatus sts = job->job.status;
|
|
AioContext *ctx;
|
|
|
|
ctx = job->job.aio_context;
|
|
aio_context_acquire(ctx);
|
|
|
|
job_cancel_sync(&job->job);
|
|
if (sts != JOB_STATUS_CREATED && sts != JOB_STATUS_CONCLUDED) {
|
|
Job *dummy = &job->job;
|
|
job_dismiss(&dummy, &error_abort);
|
|
}
|
|
assert(job->job.status == JOB_STATUS_NULL);
|
|
job_unref(&job->job);
|
|
destroy_blk(blk);
|
|
|
|
aio_context_release(ctx);
|
|
}
|
|
|
|
static void test_cancel_created(void)
|
|
{
|
|
Job *job;
|
|
CancelJob *s;
|
|
|
|
s = create_common(&job);
|
|
cancel_common(s);
|
|
}
|
|
|
|
static void test_cancel_running(void)
|
|
{
|
|
Job *job;
|
|
CancelJob *s;
|
|
|
|
s = create_common(&job);
|
|
|
|
job_start(job);
|
|
assert(job->status == JOB_STATUS_RUNNING);
|
|
|
|
cancel_common(s);
|
|
}
|
|
|
|
static void test_cancel_paused(void)
|
|
{
|
|
Job *job;
|
|
CancelJob *s;
|
|
|
|
s = create_common(&job);
|
|
|
|
job_start(job);
|
|
assert(job->status == JOB_STATUS_RUNNING);
|
|
|
|
job_user_pause(job, &error_abort);
|
|
job_enter(job);
|
|
assert(job->status == JOB_STATUS_PAUSED);
|
|
|
|
cancel_common(s);
|
|
}
|
|
|
|
static void test_cancel_ready(void)
|
|
{
|
|
Job *job;
|
|
CancelJob *s;
|
|
|
|
s = create_common(&job);
|
|
|
|
job_start(job);
|
|
assert(job->status == JOB_STATUS_RUNNING);
|
|
|
|
s->should_converge = true;
|
|
job_enter(job);
|
|
assert(job->status == JOB_STATUS_READY);
|
|
|
|
cancel_common(s);
|
|
}
|
|
|
|
static void test_cancel_standby(void)
|
|
{
|
|
Job *job;
|
|
CancelJob *s;
|
|
|
|
s = create_common(&job);
|
|
|
|
job_start(job);
|
|
assert(job->status == JOB_STATUS_RUNNING);
|
|
|
|
s->should_converge = true;
|
|
job_enter(job);
|
|
assert(job->status == JOB_STATUS_READY);
|
|
|
|
job_user_pause(job, &error_abort);
|
|
job_enter(job);
|
|
assert(job->status == JOB_STATUS_STANDBY);
|
|
|
|
cancel_common(s);
|
|
}
|
|
|
|
static void test_cancel_pending(void)
|
|
{
|
|
Job *job;
|
|
CancelJob *s;
|
|
|
|
s = create_common(&job);
|
|
|
|
job_start(job);
|
|
assert(job->status == JOB_STATUS_RUNNING);
|
|
|
|
s->should_converge = true;
|
|
job_enter(job);
|
|
assert(job->status == JOB_STATUS_READY);
|
|
|
|
job_complete(job, &error_abort);
|
|
job_enter(job);
|
|
while (!job->deferred_to_main_loop) {
|
|
aio_poll(qemu_get_aio_context(), true);
|
|
}
|
|
assert(job->status == JOB_STATUS_READY);
|
|
aio_poll(qemu_get_aio_context(), true);
|
|
assert(job->status == JOB_STATUS_PENDING);
|
|
|
|
cancel_common(s);
|
|
}
|
|
|
|
static void test_cancel_concluded(void)
|
|
{
|
|
Job *job;
|
|
CancelJob *s;
|
|
|
|
s = create_common(&job);
|
|
|
|
job_start(job);
|
|
assert(job->status == JOB_STATUS_RUNNING);
|
|
|
|
s->should_converge = true;
|
|
job_enter(job);
|
|
assert(job->status == JOB_STATUS_READY);
|
|
|
|
job_complete(job, &error_abort);
|
|
job_enter(job);
|
|
while (!job->deferred_to_main_loop) {
|
|
aio_poll(qemu_get_aio_context(), true);
|
|
}
|
|
assert(job->status == JOB_STATUS_READY);
|
|
aio_poll(qemu_get_aio_context(), true);
|
|
assert(job->status == JOB_STATUS_PENDING);
|
|
|
|
aio_context_acquire(job->aio_context);
|
|
job_finalize(job, &error_abort);
|
|
aio_context_release(job->aio_context);
|
|
assert(job->status == JOB_STATUS_CONCLUDED);
|
|
|
|
cancel_common(s);
|
|
}
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
qemu_init_main_loop(&error_abort);
|
|
bdrv_init();
|
|
|
|
g_test_init(&argc, &argv, NULL);
|
|
g_test_add_func("/blockjob/ids", test_job_ids);
|
|
g_test_add_func("/blockjob/cancel/created", test_cancel_created);
|
|
g_test_add_func("/blockjob/cancel/running", test_cancel_running);
|
|
g_test_add_func("/blockjob/cancel/paused", test_cancel_paused);
|
|
g_test_add_func("/blockjob/cancel/ready", test_cancel_ready);
|
|
g_test_add_func("/blockjob/cancel/standby", test_cancel_standby);
|
|
g_test_add_func("/blockjob/cancel/pending", test_cancel_pending);
|
|
g_test_add_func("/blockjob/cancel/concluded", test_cancel_concluded);
|
|
return g_test_run();
|
|
}
|