tests/test-blockjob-txn.c

   1 /*
   2  * Blockjob transactions tests
   3  *
   4  * Copyright Red Hat, Inc. 2015
   5  *
   6  * Authors:
   7  *  Stefan Hajnoczi    <stefanha@redhat.com>
   8  *
   9  * This work is licensed under the terms of the GNU LGPL, version 2 or later.
  10  * See the COPYING.LIB file in the top-level directory.
  11  */
  12
  13 #include "qemu/osdep.h"
  14 #include "qapi/error.h"
  15 #include "qemu/main-loop.h"
  16 #include "block/blockjob_int.h"
  17 #include "sysemu/block-backend.h"
  18
  19 typedef struct {
  20     BlockJob common;
  21     unsigned int iterations;
  22     bool use_timer;
  23     int rc;
  24     int *result;
  25 } TestBlockJob;
  26
  27 static void test_block_job_clean(Job *job)
  28 {
  29     BlockJob *bjob = container_of(job, BlockJob, job);
  30     BlockDriverState *bs = blk_bs(bjob->blk);
  31
  32     bdrv_unref(bs);
  33 }
  34
  35 static int coroutine_fn test_block_job_run(Job *job, Error **errp)
  36 {
  37     TestBlockJob *s = container_of(job, TestBlockJob, common.job);
  38
  39     while (s->iterations--) {
  40         if (s->use_timer) {
  41             job_sleep_ns(job, 0);
  42         } else {
  43             job_yield(job);
  44         }
  45
  46         if (job_is_cancelled(job)) {
  47             break;
  48         }
  49     }
  50
  51     return s->rc;
  52 }
  53
  54 typedef struct {
  55     TestBlockJob *job;
  56     int *result;
  57 } TestBlockJobCBData;
  58
  59 static void test_block_job_cb(void *opaque, int ret)
  60 {
  61     TestBlockJobCBData *data = opaque;
  62     if (!ret && job_is_cancelled(&data->job->common.job)) {
  63         ret = -ECANCELED;
  64     }
  65     *data->result = ret;
  66     g_free(data);
  67 }
  68
  69 static const BlockJobDriver test_block_job_driver = {
  70     .job_driver = {
  71         .instance_size = sizeof(TestBlockJob),
  72         .free          = block_job_free,
  73         .user_resume   = block_job_user_resume,
  74         .drain         = block_job_drain,
  75         .run           = test_block_job_run,
  76         .clean         = test_block_job_clean,
  77     },
  78 };
  79
  80 /* Create a block job that completes with a given return code after a given
  81  * number of event loop iterations.  The return code is stored in the given
  82  * result pointer.
  83  *
  84  * The event loop iterations can either be handled automatically with a 0 delay
  85  * timer, or they can be stepped manually by entering the coroutine.
  86  */
  87 static BlockJob *test_block_job_start(unsigned int iterations,
  88                                       bool use_timer,
  89                                       int rc, int *result, JobTxn *txn)
  90 {
  91     BlockDriverState *bs;
  92     TestBlockJob *s;
  93     TestBlockJobCBData *data;
  94     static unsigned counter;
  95     char job_id[24];
  96
  97     data = g_new0(TestBlockJobCBData, 1);
  98
  99     bs = bdrv_open("null-co://", NULL, NULL, 0, &error_abort);
 100     g_assert_nonnull(bs);
 101
 102     snprintf(job_id, sizeof(job_id), "job%u", counter++);
 103     s = block_job_create(job_id, &test_block_job_driver, txn, bs,
 104                          0, BLK_PERM_ALL, 0, JOB_DEFAULT,
 105                          test_block_job_cb, data, &error_abort);
 106     s->iterations = iterations;
 107     s->use_timer = use_timer;
 108     s->rc = rc;
 109     s->result = result;
 110     data->job = s;
 111     data->result = result;
 112     return &s->common;
 113 }
 114
 115 static void test_single_job(int expected)
 116 {
 117     BlockJob *job;
 118     JobTxn *txn;
 119     int result = -EINPROGRESS;
 120
 121     txn = job_txn_new();
 122     job = test_block_job_start(1, true, expected, &result, txn);
 123     job_start(&job->job);
 124
 125     if (expected == -ECANCELED) {
 126         job_cancel(&job->job, false);
 127     }
 128
 129     while (result == -EINPROGRESS) {
 130         aio_poll(qemu_get_aio_context(), true);
 131     }
 132     g_assert_cmpint(result, ==, expected);
 133
 134     job_txn_unref(txn);
 135 }
 136
 137 static void test_single_job_success(void)
 138 {
 139     test_single_job(0);
 140 }
 141
 142 static void test_single_job_failure(void)
 143 {
 144     test_single_job(-EIO);
 145 }
 146
 147 static void test_single_job_cancel(void)
 148 {
 149     test_single_job(-ECANCELED);
 150 }
 151
 152 static void test_pair_jobs(int expected1, int expected2)
 153 {
 154     BlockJob *job1;
 155     BlockJob *job2;
 156     JobTxn *txn;
 157     int result1 = -EINPROGRESS;
 158     int result2 = -EINPROGRESS;
 159
 160     txn = job_txn_new();
 161     job1 = test_block_job_start(1, true, expected1, &result1, txn);
 162     job2 = test_block_job_start(2, true, expected2, &result2, txn);
 163     job_start(&job1->job);
 164     job_start(&job2->job);
 165
 166     /* Release our reference now to trigger as many nice
 167      * use-after-free bugs as possible.
 168      */
 169     job_txn_unref(txn);
 170
 171     if (expected1 == -ECANCELED) {
 172         job_cancel(&job1->job, false);
 173     }
 174     if (expected2 == -ECANCELED) {
 175         job_cancel(&job2->job, false);
 176     }
 177
 178     while (result1 == -EINPROGRESS || result2 == -EINPROGRESS) {
 179         aio_poll(qemu_get_aio_context(), true);
 180     }
 181
 182     /* Failure or cancellation of one job cancels the other job */
 183     if (expected1 != 0) {
 184         expected2 = -ECANCELED;
 185     } else if (expected2 != 0) {
 186         expected1 = -ECANCELED;
 187     }
 188
 189     g_assert_cmpint(result1, ==, expected1);
 190     g_assert_cmpint(result2, ==, expected2);
 191 }
 192
 193 static void test_pair_jobs_success(void)
 194 {
 195     test_pair_jobs(0, 0);
 196 }
 197
 198 static void test_pair_jobs_failure(void)
 199 {
 200     /* Test both orderings.  The two jobs run for a different number of
 201      * iterations so the code path is different depending on which job fails
 202      * first.
 203      */
 204     test_pair_jobs(-EIO, 0);
 205     test_pair_jobs(0, -EIO);
 206 }
 207
 208 static void test_pair_jobs_cancel(void)
 209 {
 210     test_pair_jobs(-ECANCELED, 0);
 211     test_pair_jobs(0, -ECANCELED);
 212 }
 213
 214 static void test_pair_jobs_fail_cancel_race(void)
 215 {
 216     BlockJob *job1;
 217     BlockJob *job2;
 218     JobTxn *txn;
 219     int result1 = -EINPROGRESS;
 220     int result2 = -EINPROGRESS;
 221
 222     txn = job_txn_new();
 223     job1 = test_block_job_start(1, true, -ECANCELED, &result1, txn);
 224     job2 = test_block_job_start(2, false, 0, &result2, txn);
 225     job_start(&job1->job);
 226     job_start(&job2->job);
 227
 228     job_cancel(&job1->job, false);
 229
 230     /* Now make job2 finish before the main loop kicks jobs.  This simulates
 231      * the race between a pending kick and another job completing.
 232      */
 233     job_enter(&job2->job);
 234     job_enter(&job2->job);
 235
 236     while (result1 == -EINPROGRESS || result2 == -EINPROGRESS) {
 237         aio_poll(qemu_get_aio_context(), true);
 238     }
 239
 240     g_assert_cmpint(result1, ==, -ECANCELED);
 241     g_assert_cmpint(result2, ==, -ECANCELED);
 242
 243     job_txn_unref(txn);
 244 }
 245
 246 int main(int argc, char **argv)
 247 {
 248     qemu_init_main_loop(&error_abort);
 249     bdrv_init();
 250
 251     g_test_init(&argc, &argv, NULL);
 252     g_test_add_func("/single/success", test_single_job_success);
 253     g_test_add_func("/single/failure", test_single_job_failure);
 254     g_test_add_func("/single/cancel", test_single_job_cancel);
 255     g_test_add_func("/pair/success", test_pair_jobs_success);
 256     g_test_add_func("/pair/failure", test_pair_jobs_failure);
 257     g_test_add_func("/pair/cancel", test_pair_jobs_cancel);
 258     g_test_add_func("/pair/fail-cancel-race", test_pair_jobs_fail_cancel_race);
 259     return g_test_run();
 260 }