Stefan Hajnoczi | 6c6f312 | 2015-11-05 18:13:20 -0500 | [diff] [blame] | 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 | |
Peter Maydell | 681c28a | 2016-02-08 18:08:51 +0000 | [diff] [blame] | 13 | #include "qemu/osdep.h" |
Markus Armbruster | da34e65 | 2016-03-14 09:01:28 +0100 | [diff] [blame] | 14 | #include "qapi/error.h" |
Stefan Hajnoczi | 6c6f312 | 2015-11-05 18:13:20 -0500 | [diff] [blame] | 15 | #include "qemu/main-loop.h" |
John Snow | c87621e | 2016-10-27 12:07:00 -0400 | [diff] [blame] | 16 | #include "block/blockjob_int.h" |
Kevin Wolf | b75536c | 2016-04-18 17:30:17 +0200 | [diff] [blame] | 17 | #include "sysemu/block-backend.h" |
Andrey Shinkevich | ca1ef1e | 2019-07-29 15:46:00 +0300 | [diff] [blame] | 18 | #include "qapi/qmp/qdict.h" |
Stefan Hajnoczi | 6c6f312 | 2015-11-05 18:13:20 -0500 | [diff] [blame] | 19 | |
| 20 | typedef struct { |
| 21 | BlockJob common; |
| 22 | unsigned int iterations; |
| 23 | bool use_timer; |
| 24 | int rc; |
| 25 | int *result; |
| 26 | } TestBlockJob; |
| 27 | |
John Snow | e4dad42 | 2018-09-06 09:02:19 -0400 | [diff] [blame] | 28 | static void test_block_job_clean(Job *job) |
Stefan Hajnoczi | 6c6f312 | 2015-11-05 18:13:20 -0500 | [diff] [blame] | 29 | { |
Kevin Wolf | 1908a55 | 2018-04-17 16:41:17 +0200 | [diff] [blame] | 30 | BlockJob *bjob = container_of(job, BlockJob, job); |
| 31 | BlockDriverState *bs = blk_bs(bjob->blk); |
Stefan Hajnoczi | 6c6f312 | 2015-11-05 18:13:20 -0500 | [diff] [blame] | 32 | |
Stefan Hajnoczi | 6c6f312 | 2015-11-05 18:13:20 -0500 | [diff] [blame] | 33 | bdrv_unref(bs); |
| 34 | } |
| 35 | |
John Snow | f67432a | 2018-08-29 21:57:26 -0400 | [diff] [blame] | 36 | static int coroutine_fn test_block_job_run(Job *job, Error **errp) |
Stefan Hajnoczi | 6c6f312 | 2015-11-05 18:13:20 -0500 | [diff] [blame] | 37 | { |
John Snow | f67432a | 2018-08-29 21:57:26 -0400 | [diff] [blame] | 38 | TestBlockJob *s = container_of(job, TestBlockJob, common.job); |
Stefan Hajnoczi | 6c6f312 | 2015-11-05 18:13:20 -0500 | [diff] [blame] | 39 | |
| 40 | while (s->iterations--) { |
| 41 | if (s->use_timer) { |
John Snow | f67432a | 2018-08-29 21:57:26 -0400 | [diff] [blame] | 42 | job_sleep_ns(job, 0); |
Stefan Hajnoczi | 6c6f312 | 2015-11-05 18:13:20 -0500 | [diff] [blame] | 43 | } else { |
John Snow | f67432a | 2018-08-29 21:57:26 -0400 | [diff] [blame] | 44 | job_yield(job); |
Stefan Hajnoczi | 6c6f312 | 2015-11-05 18:13:20 -0500 | [diff] [blame] | 45 | } |
| 46 | |
John Snow | f67432a | 2018-08-29 21:57:26 -0400 | [diff] [blame] | 47 | if (job_is_cancelled(job)) { |
Stefan Hajnoczi | 6c6f312 | 2015-11-05 18:13:20 -0500 | [diff] [blame] | 48 | break; |
| 49 | } |
| 50 | } |
| 51 | |
John Snow | f67432a | 2018-08-29 21:57:26 -0400 | [diff] [blame] | 52 | return s->rc; |
Stefan Hajnoczi | 6c6f312 | 2015-11-05 18:13:20 -0500 | [diff] [blame] | 53 | } |
| 54 | |
| 55 | typedef struct { |
| 56 | TestBlockJob *job; |
| 57 | int *result; |
| 58 | } TestBlockJobCBData; |
| 59 | |
| 60 | static void test_block_job_cb(void *opaque, int ret) |
| 61 | { |
| 62 | TestBlockJobCBData *data = opaque; |
Kevin Wolf | daa7f2f | 2018-04-17 12:56:07 +0200 | [diff] [blame] | 63 | if (!ret && job_is_cancelled(&data->job->common.job)) { |
Stefan Hajnoczi | 6c6f312 | 2015-11-05 18:13:20 -0500 | [diff] [blame] | 64 | ret = -ECANCELED; |
| 65 | } |
| 66 | *data->result = ret; |
| 67 | g_free(data); |
| 68 | } |
| 69 | |
John Snow | 5ccac6f | 2016-11-08 01:50:37 -0500 | [diff] [blame] | 70 | static const BlockJobDriver test_block_job_driver = { |
Kevin Wolf | 33e9e9b | 2018-04-12 17:29:59 +0200 | [diff] [blame] | 71 | .job_driver = { |
| 72 | .instance_size = sizeof(TestBlockJob), |
Kevin Wolf | 80fa2c7 | 2018-04-13 18:50:05 +0200 | [diff] [blame] | 73 | .free = block_job_free, |
Kevin Wolf | b15de82 | 2018-04-18 17:10:26 +0200 | [diff] [blame] | 74 | .user_resume = block_job_user_resume, |
John Snow | f67432a | 2018-08-29 21:57:26 -0400 | [diff] [blame] | 75 | .run = test_block_job_run, |
John Snow | e4dad42 | 2018-09-06 09:02:19 -0400 | [diff] [blame] | 76 | .clean = test_block_job_clean, |
Kevin Wolf | 33e9e9b | 2018-04-12 17:29:59 +0200 | [diff] [blame] | 77 | }, |
John Snow | 5ccac6f | 2016-11-08 01:50:37 -0500 | [diff] [blame] | 78 | }; |
| 79 | |
Stefan Hajnoczi | 6c6f312 | 2015-11-05 18:13:20 -0500 | [diff] [blame] | 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, |
Kevin Wolf | 62c9e41 | 2018-04-19 16:09:52 +0200 | [diff] [blame] | 89 | int rc, int *result, JobTxn *txn) |
Stefan Hajnoczi | 6c6f312 | 2015-11-05 18:13:20 -0500 | [diff] [blame] | 90 | { |
| 91 | BlockDriverState *bs; |
| 92 | TestBlockJob *s; |
| 93 | TestBlockJobCBData *data; |
Alberto Garcia | 7f0317c | 2016-07-05 17:28:56 +0300 | [diff] [blame] | 94 | static unsigned counter; |
| 95 | char job_id[24]; |
Stefan Hajnoczi | 6c6f312 | 2015-11-05 18:13:20 -0500 | [diff] [blame] | 96 | |
| 97 | data = g_new0(TestBlockJobCBData, 1); |
Kevin Wolf | d185cf0 | 2017-01-16 17:17:38 +0100 | [diff] [blame] | 98 | |
Andrey Shinkevich | ca1ef1e | 2019-07-29 15:46:00 +0300 | [diff] [blame] | 99 | QDict *opt = qdict_new(); |
| 100 | qdict_put_str(opt, "file.read-zeroes", "on"); |
| 101 | bs = bdrv_open("null-co://", NULL, opt, 0, &error_abort); |
Kevin Wolf | d185cf0 | 2017-01-16 17:17:38 +0100 | [diff] [blame] | 102 | g_assert_nonnull(bs); |
| 103 | |
Alberto Garcia | 7f0317c | 2016-07-05 17:28:56 +0300 | [diff] [blame] | 104 | snprintf(job_id, sizeof(job_id), "job%u", counter++); |
John Snow | 75859b9 | 2018-03-10 03:27:27 -0500 | [diff] [blame] | 105 | s = block_job_create(job_id, &test_block_job_driver, txn, bs, |
Kevin Wolf | bb02b65 | 2018-04-19 17:54:56 +0200 | [diff] [blame] | 106 | 0, BLK_PERM_ALL, 0, JOB_DEFAULT, |
Kevin Wolf | c6cc12b | 2017-01-16 17:18:09 +0100 | [diff] [blame] | 107 | test_block_job_cb, data, &error_abort); |
Stefan Hajnoczi | 6c6f312 | 2015-11-05 18:13:20 -0500 | [diff] [blame] | 108 | s->iterations = iterations; |
| 109 | s->use_timer = use_timer; |
| 110 | s->rc = rc; |
| 111 | s->result = result; |
Stefan Hajnoczi | 6c6f312 | 2015-11-05 18:13:20 -0500 | [diff] [blame] | 112 | data->job = s; |
| 113 | data->result = result; |
Stefan Hajnoczi | 6c6f312 | 2015-11-05 18:13:20 -0500 | [diff] [blame] | 114 | return &s->common; |
| 115 | } |
| 116 | |
| 117 | static void test_single_job(int expected) |
| 118 | { |
| 119 | BlockJob *job; |
Kevin Wolf | 62c9e41 | 2018-04-19 16:09:52 +0200 | [diff] [blame] | 120 | JobTxn *txn; |
Stefan Hajnoczi | 6c6f312 | 2015-11-05 18:13:20 -0500 | [diff] [blame] | 121 | int result = -EINPROGRESS; |
| 122 | |
Kevin Wolf | 7eaa8fb | 2018-04-23 16:06:26 +0200 | [diff] [blame] | 123 | txn = job_txn_new(); |
John Snow | 75859b9 | 2018-03-10 03:27:27 -0500 | [diff] [blame] | 124 | job = test_block_job_start(1, true, expected, &result, txn); |
Kevin Wolf | da01ff7 | 2018-04-13 17:31:02 +0200 | [diff] [blame] | 125 | job_start(&job->job); |
Stefan Hajnoczi | 6c6f312 | 2015-11-05 18:13:20 -0500 | [diff] [blame] | 126 | |
| 127 | if (expected == -ECANCELED) { |
Kevin Wolf | 3d70ff5 | 2018-04-24 16:13:52 +0200 | [diff] [blame] | 128 | job_cancel(&job->job, false); |
Stefan Hajnoczi | 6c6f312 | 2015-11-05 18:13:20 -0500 | [diff] [blame] | 129 | } |
| 130 | |
| 131 | while (result == -EINPROGRESS) { |
| 132 | aio_poll(qemu_get_aio_context(), true); |
| 133 | } |
| 134 | g_assert_cmpint(result, ==, expected); |
| 135 | |
Kevin Wolf | 7eaa8fb | 2018-04-23 16:06:26 +0200 | [diff] [blame] | 136 | job_txn_unref(txn); |
Stefan Hajnoczi | 6c6f312 | 2015-11-05 18:13:20 -0500 | [diff] [blame] | 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; |
Kevin Wolf | 62c9e41 | 2018-04-19 16:09:52 +0200 | [diff] [blame] | 158 | JobTxn *txn; |
Stefan Hajnoczi | 6c6f312 | 2015-11-05 18:13:20 -0500 | [diff] [blame] | 159 | int result1 = -EINPROGRESS; |
| 160 | int result2 = -EINPROGRESS; |
| 161 | |
Kevin Wolf | 7eaa8fb | 2018-04-23 16:06:26 +0200 | [diff] [blame] | 162 | txn = job_txn_new(); |
John Snow | 75859b9 | 2018-03-10 03:27:27 -0500 | [diff] [blame] | 163 | job1 = test_block_job_start(1, true, expected1, &result1, txn); |
| 164 | job2 = test_block_job_start(2, true, expected2, &result2, txn); |
Kevin Wolf | da01ff7 | 2018-04-13 17:31:02 +0200 | [diff] [blame] | 165 | job_start(&job1->job); |
| 166 | job_start(&job2->job); |
Stefan Hajnoczi | 6c6f312 | 2015-11-05 18:13:20 -0500 | [diff] [blame] | 167 | |
Paolo Bonzini | 7e74a73 | 2017-05-08 16:13:08 +0200 | [diff] [blame] | 168 | /* Release our reference now to trigger as many nice |
| 169 | * use-after-free bugs as possible. |
| 170 | */ |
Kevin Wolf | 7eaa8fb | 2018-04-23 16:06:26 +0200 | [diff] [blame] | 171 | job_txn_unref(txn); |
Paolo Bonzini | 7e74a73 | 2017-05-08 16:13:08 +0200 | [diff] [blame] | 172 | |
Stefan Hajnoczi | 6c6f312 | 2015-11-05 18:13:20 -0500 | [diff] [blame] | 173 | if (expected1 == -ECANCELED) { |
Kevin Wolf | 3d70ff5 | 2018-04-24 16:13:52 +0200 | [diff] [blame] | 174 | job_cancel(&job1->job, false); |
Stefan Hajnoczi | 6c6f312 | 2015-11-05 18:13:20 -0500 | [diff] [blame] | 175 | } |
| 176 | if (expected2 == -ECANCELED) { |
Kevin Wolf | 3d70ff5 | 2018-04-24 16:13:52 +0200 | [diff] [blame] | 177 | job_cancel(&job2->job, false); |
Stefan Hajnoczi | 6c6f312 | 2015-11-05 18:13:20 -0500 | [diff] [blame] | 178 | } |
| 179 | |
| 180 | while (result1 == -EINPROGRESS || result2 == -EINPROGRESS) { |
| 181 | aio_poll(qemu_get_aio_context(), true); |
| 182 | } |
| 183 | |
| 184 | /* Failure or cancellation of one job cancels the other job */ |
| 185 | if (expected1 != 0) { |
| 186 | expected2 = -ECANCELED; |
| 187 | } else if (expected2 != 0) { |
| 188 | expected1 = -ECANCELED; |
| 189 | } |
| 190 | |
| 191 | g_assert_cmpint(result1, ==, expected1); |
| 192 | g_assert_cmpint(result2, ==, expected2); |
Stefan Hajnoczi | 6c6f312 | 2015-11-05 18:13:20 -0500 | [diff] [blame] | 193 | } |
| 194 | |
| 195 | static void test_pair_jobs_success(void) |
| 196 | { |
| 197 | test_pair_jobs(0, 0); |
| 198 | } |
| 199 | |
| 200 | static void test_pair_jobs_failure(void) |
| 201 | { |
| 202 | /* Test both orderings. The two jobs run for a different number of |
| 203 | * iterations so the code path is different depending on which job fails |
| 204 | * first. |
| 205 | */ |
| 206 | test_pair_jobs(-EIO, 0); |
| 207 | test_pair_jobs(0, -EIO); |
| 208 | } |
| 209 | |
| 210 | static void test_pair_jobs_cancel(void) |
| 211 | { |
| 212 | test_pair_jobs(-ECANCELED, 0); |
| 213 | test_pair_jobs(0, -ECANCELED); |
| 214 | } |
| 215 | |
| 216 | static void test_pair_jobs_fail_cancel_race(void) |
| 217 | { |
| 218 | BlockJob *job1; |
| 219 | BlockJob *job2; |
Kevin Wolf | 62c9e41 | 2018-04-19 16:09:52 +0200 | [diff] [blame] | 220 | JobTxn *txn; |
Stefan Hajnoczi | 6c6f312 | 2015-11-05 18:13:20 -0500 | [diff] [blame] | 221 | int result1 = -EINPROGRESS; |
| 222 | int result2 = -EINPROGRESS; |
| 223 | |
Kevin Wolf | 7eaa8fb | 2018-04-23 16:06:26 +0200 | [diff] [blame] | 224 | txn = job_txn_new(); |
John Snow | 75859b9 | 2018-03-10 03:27:27 -0500 | [diff] [blame] | 225 | job1 = test_block_job_start(1, true, -ECANCELED, &result1, txn); |
| 226 | job2 = test_block_job_start(2, false, 0, &result2, txn); |
Kevin Wolf | da01ff7 | 2018-04-13 17:31:02 +0200 | [diff] [blame] | 227 | job_start(&job1->job); |
| 228 | job_start(&job2->job); |
Stefan Hajnoczi | 6c6f312 | 2015-11-05 18:13:20 -0500 | [diff] [blame] | 229 | |
Kevin Wolf | 3d70ff5 | 2018-04-24 16:13:52 +0200 | [diff] [blame] | 230 | job_cancel(&job1->job, false); |
Stefan Hajnoczi | 6c6f312 | 2015-11-05 18:13:20 -0500 | [diff] [blame] | 231 | |
| 232 | /* Now make job2 finish before the main loop kicks jobs. This simulates |
| 233 | * the race between a pending kick and another job completing. |
| 234 | */ |
Kevin Wolf | 3d70ff5 | 2018-04-24 16:13:52 +0200 | [diff] [blame] | 235 | job_enter(&job2->job); |
| 236 | job_enter(&job2->job); |
Stefan Hajnoczi | 6c6f312 | 2015-11-05 18:13:20 -0500 | [diff] [blame] | 237 | |
| 238 | while (result1 == -EINPROGRESS || result2 == -EINPROGRESS) { |
| 239 | aio_poll(qemu_get_aio_context(), true); |
| 240 | } |
| 241 | |
| 242 | g_assert_cmpint(result1, ==, -ECANCELED); |
| 243 | g_assert_cmpint(result2, ==, -ECANCELED); |
| 244 | |
Kevin Wolf | 7eaa8fb | 2018-04-23 16:06:26 +0200 | [diff] [blame] | 245 | job_txn_unref(txn); |
Stefan Hajnoczi | 6c6f312 | 2015-11-05 18:13:20 -0500 | [diff] [blame] | 246 | } |
| 247 | |
| 248 | int main(int argc, char **argv) |
| 249 | { |
| 250 | qemu_init_main_loop(&error_abort); |
Kevin Wolf | d185cf0 | 2017-01-16 17:17:38 +0100 | [diff] [blame] | 251 | bdrv_init(); |
Stefan Hajnoczi | 6c6f312 | 2015-11-05 18:13:20 -0500 | [diff] [blame] | 252 | |
| 253 | g_test_init(&argc, &argv, NULL); |
| 254 | g_test_add_func("/single/success", test_single_job_success); |
| 255 | g_test_add_func("/single/failure", test_single_job_failure); |
| 256 | g_test_add_func("/single/cancel", test_single_job_cancel); |
| 257 | g_test_add_func("/pair/success", test_pair_jobs_success); |
| 258 | g_test_add_func("/pair/failure", test_pair_jobs_failure); |
| 259 | g_test_add_func("/pair/cancel", test_pair_jobs_cancel); |
| 260 | g_test_add_func("/pair/fail-cancel-race", test_pair_jobs_fail_cancel_race); |
| 261 | return g_test_run(); |
| 262 | } |