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_complete(BlockJob *job, void *opaque)
  28 {
  29     BlockDriverState *bs = blk_bs(job->blk);
  30     int rc = (intptr_t)opaque;
  31
  32     if (block_job_is_cancelled(job)) {
  33         rc = -ECANCELED;
  34     }
  35
  36     block_job_completed(job, rc);
  37     bdrv_unref(bs);
  38 }
  39
  40 static void coroutine_fn test_block_job_run(void *opaque)
  41 {
  42     TestBlockJob *s = opaque;
  43     BlockJob *job = &s->common;
  44
  45     while (s->iterations--) {
  46         if (s->use_timer) {
  47             block_job_sleep_ns(job, 0);
  48         } else {
  49             block_job_yield(job);
  50         }
  51
  52         if (block_job_is_cancelled(job)) {
  53             break;
  54         }
  55     }
  56
  57     block_job_defer_to_main_loop(job, test_block_job_complete,
  58                                  (void *)(intptr_t)s->rc);
  59 }
  60
  61 typedef struct {
  62     TestBlockJob *job;
  63     int *result;
  64 } TestBlockJobCBData;
  65
  66 static void test_block_job_cb(void *opaque, int ret)
  67 {
  68     TestBlockJobCBData *data = opaque;
  69     if (!ret && block_job_is_cancelled(&data->job->common)) {
  70         ret = -ECANCELED;
  71     }
  72     *data->result = ret;
  73     g_free(data);
  74 }
  75
  76 static const BlockJobDriver test_block_job_driver = {
  77     .instance_size = sizeof(TestBlockJob),
  78     .start = test_block_job_run,
  79 };
  80
  81 /* Create a block job that completes with a given return code after a given
  82  * number of event loop iterations.  The return code is stored in the given
  83  * result pointer.
  84  *
  85  * The event loop iterations can either be handled automatically with a 0 delay
  86  * timer, or they can be stepped manually by entering the coroutine.
  87  */
  88 static BlockJob *test_block_job_start(unsigned int iterations,
  89                                       bool use_timer,
  90                                       int rc, int *result)
  91 {
  92     BlockDriverState *bs;
  93     TestBlockJob *s;
  94     TestBlockJobCBData *data;
  95     static unsigned counter;
  96     char job_id[24];
  97
  98     data = g_new0(TestBlockJobCBData, 1);
  99
 100     bs = bdrv_open("null-co://", NULL, NULL, 0, &error_abort);
 101     g_assert_nonnull(bs);
 102
 103     snprintf(job_id, sizeof(job_id), "job%u", counter++);
 104     s = block_job_create(job_id, &test_block_job_driver, bs,
 105                          0, BLK_PERM_ALL, 0, BLOCK_JOB_DEFAULT,
 106                          test_block_job_cb, data, &error_abort);
 107     s->iterations = iterations;
 108     s->use_timer = use_timer;
 109     s->rc = rc;
 110     s->result = result;
 111     data->job = s;
 112     data->result = result;
 113     return &s->common;
 114 }
 115
 116 static void test_single_job(int expected)
 117 {
 118     BlockJob *job;
 119     BlockJobTxn *txn;
 120     int result = -EINPROGRESS;
 121
 122     txn = block_job_txn_new();
 123     job = test_block_job_start(1, true, expected, &result);
 124     block_job_txn_add_job(txn, job);
 125     block_job_start(job);
 126
 127     if (expected == -ECANCELED) {
 128         block_job_cancel(job);
 129     }
 130
 131     while (result == -EINPROGRESS) {
 132         aio_poll(qemu_get_aio_context(), true);
 133     }
 134     g_assert_cmpint(result, ==, expected);
 135
 136     block_job_txn_unref(txn);
 137 }
 138
 139 static void test_single_job_success(void)
 140 {
 141     test_single_job(0);
 142 }
 143
 144 static void test_single_job_failure(void)
 145 {
 146     test_single_job(-EIO);
 147 }
 148
 149 static void test_single_job_cancel(void)
 150 {
 151     test_single_job(-ECANCELED);
 152 }
 153
 154 static void test_pair_jobs(int expected1, int expected2)
 155 {
 156     BlockJob *job1;
 157     BlockJob *job2;
 158     BlockJobTxn *txn;
 159     int result1 = -EINPROGRESS;
 160     int result2 = -EINPROGRESS;
 161
 162     txn = block_job_txn_new();
 163     job1 = test_block_job_start(1, true, expected1, &result1);
 164     block_job_txn_add_job(txn, job1);
 165     job2 = test_block_job_start(2, true, expected2, &result2);
 166     block_job_txn_add_job(txn, job2);
 167     block_job_start(job1);
 168     block_job_start(job2);
 169
 170     /* Release our reference now to trigger as many nice
 171      * use-after-free bugs as possible.
 172      */
 173     block_job_txn_unref(txn);
 174
 175     if (expected1 == -ECANCELED) {
 176         block_job_cancel(job1);
 177     }
 178     if (expected2 == -ECANCELED) {
 179         block_job_cancel(job2);
 180     }
 181
 182     while (result1 == -EINPROGRESS || result2 == -EINPROGRESS) {
 183         aio_poll(qemu_get_aio_context(), true);
 184     }
 185
 186     /* Failure or cancellation of one job cancels the other job */
 187     if (expected1 != 0) {
 188         expected2 = -ECANCELED;
 189     } else if (expected2 != 0) {
 190         expected1 = -ECANCELED;
 191     }
 192
 193     g_assert_cmpint(result1, ==, expected1);
 194     g_assert_cmpint(result2, ==, expected2);
 195 }
 196
 197 static void test_pair_jobs_success(void)
 198 {
 199     test_pair_jobs(0, 0);
 200 }
 201
 202 static void test_pair_jobs_failure(void)
 203 {
 204     /* Test both orderings.  The two jobs run for a different number of
 205      * iterations so the code path is different depending on which job fails
 206      * first.
 207      */
 208     test_pair_jobs(-EIO, 0);
 209     test_pair_jobs(0, -EIO);
 210 }
 211
 212 static void test_pair_jobs_cancel(void)
 213 {
 214     test_pair_jobs(-ECANCELED, 0);
 215     test_pair_jobs(0, -ECANCELED);
 216 }
 217
 218 static void test_pair_jobs_fail_cancel_race(void)
 219 {
 220     BlockJob *job1;
 221     BlockJob *job2;
 222     BlockJobTxn *txn;
 223     int result1 = -EINPROGRESS;
 224     int result2 = -EINPROGRESS;
 225
 226     txn = block_job_txn_new();
 227     job1 = test_block_job_start(1, true, -ECANCELED, &result1);
 228     block_job_txn_add_job(txn, job1);
 229     job2 = test_block_job_start(2, false, 0, &result2);
 230     block_job_txn_add_job(txn, job2);
 231     block_job_start(job1);
 232     block_job_start(job2);
 233
 234     block_job_cancel(job1);
 235
 236     /* Now make job2 finish before the main loop kicks jobs.  This simulates
 237      * the race between a pending kick and another job completing.
 238      */
 239     block_job_enter(job2);
 240     block_job_enter(job2);
 241
 242     while (result1 == -EINPROGRESS || result2 == -EINPROGRESS) {
 243         aio_poll(qemu_get_aio_context(), true);
 244     }
 245
 246     g_assert_cmpint(result1, ==, -ECANCELED);
 247     g_assert_cmpint(result2, ==, -ECANCELED);
 248
 249     block_job_txn_unref(txn);
 250 }
 251
 252 int main(int argc, char **argv)
 253 {
 254     qemu_init_main_loop(&error_abort);
 255     bdrv_init();
 256
 257     g_test_init(&argc, &argv, NULL);
 258     g_test_add_func("/single/success", test_single_job_success);
 259     g_test_add_func("/single/failure", test_single_job_failure);
 260     g_test_add_func("/single/cancel", test_single_job_cancel);
 261     g_test_add_func("/pair/success", test_pair_jobs_success);
 262     g_test_add_func("/pair/failure", test_pair_jobs_failure);
 263     g_test_add_func("/pair/cancel", test_pair_jobs_cancel);
 264     g_test_add_func("/pair/fail-cancel-race", test_pair_jobs_fail_cancel_race);
 265     return g_test_run();
 266 }