Alberto Garcia | 9ef8112 | 2016-07-29 17:31:41 +0300 | [diff] [blame] | 1 | /* |
| 2 | * Blockjob tests |
| 3 | * |
| 4 | * Copyright Igalia, S.L. 2016 |
| 5 | * |
| 6 | * Authors: |
| 7 | * Alberto Garcia <berto@igalia.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" |
John Snow | c87621e | 2016-10-27 12:07:00 -0400 | [diff] [blame] | 16 | #include "block/blockjob_int.h" |
Alberto Garcia | 9ef8112 | 2016-07-29 17:31:41 +0300 | [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" |
Max Reitz | c2c731a | 2021-04-09 14:04:21 +0200 | [diff] [blame] | 19 | #include "iothread.h" |
Alberto Garcia | 9ef8112 | 2016-07-29 17:31:41 +0300 | [diff] [blame] | 20 | |
| 21 | static const BlockJobDriver test_block_job_driver = { |
Kevin Wolf | 33e9e9b | 2018-04-12 17:29:59 +0200 | [diff] [blame] | 22 | .job_driver = { |
| 23 | .instance_size = sizeof(BlockJob), |
Kevin Wolf | 80fa2c7 | 2018-04-13 18:50:05 +0200 | [diff] [blame] | 24 | .free = block_job_free, |
Kevin Wolf | b15de82 | 2018-04-18 17:10:26 +0200 | [diff] [blame] | 25 | .user_resume = block_job_user_resume, |
Kevin Wolf | 33e9e9b | 2018-04-12 17:29:59 +0200 | [diff] [blame] | 26 | }, |
Alberto Garcia | 9ef8112 | 2016-07-29 17:31:41 +0300 | [diff] [blame] | 27 | }; |
| 28 | |
| 29 | static void block_job_cb(void *opaque, int ret) |
| 30 | { |
| 31 | } |
| 32 | |
John Snow | fb367e0 | 2018-03-10 03:27:46 -0500 | [diff] [blame] | 33 | static BlockJob *mk_job(BlockBackend *blk, const char *id, |
| 34 | const BlockJobDriver *drv, bool should_succeed, |
| 35 | int flags) |
Alberto Garcia | 9ef8112 | 2016-07-29 17:31:41 +0300 | [diff] [blame] | 36 | { |
| 37 | BlockJob *job; |
Markus Armbruster | 8ca63ba | 2019-12-04 10:36:23 +0100 | [diff] [blame] | 38 | Error *err = NULL; |
Alberto Garcia | 9ef8112 | 2016-07-29 17:31:41 +0300 | [diff] [blame] | 39 | |
John Snow | fb367e0 | 2018-03-10 03:27:46 -0500 | [diff] [blame] | 40 | job = block_job_create(id, drv, NULL, blk_bs(blk), |
| 41 | 0, BLK_PERM_ALL, 0, flags, block_job_cb, |
Markus Armbruster | 8ca63ba | 2019-12-04 10:36:23 +0100 | [diff] [blame] | 42 | NULL, &err); |
Alberto Garcia | 9ef8112 | 2016-07-29 17:31:41 +0300 | [diff] [blame] | 43 | if (should_succeed) { |
Markus Armbruster | 8ca63ba | 2019-12-04 10:36:23 +0100 | [diff] [blame] | 44 | g_assert_null(err); |
Alberto Garcia | 9ef8112 | 2016-07-29 17:31:41 +0300 | [diff] [blame] | 45 | g_assert_nonnull(job); |
| 46 | if (id) { |
Kevin Wolf | 33e9e9b | 2018-04-12 17:29:59 +0200 | [diff] [blame] | 47 | g_assert_cmpstr(job->job.id, ==, id); |
Alberto Garcia | 9ef8112 | 2016-07-29 17:31:41 +0300 | [diff] [blame] | 48 | } else { |
Kevin Wolf | 33e9e9b | 2018-04-12 17:29:59 +0200 | [diff] [blame] | 49 | g_assert_cmpstr(job->job.id, ==, blk_name(blk)); |
Alberto Garcia | 9ef8112 | 2016-07-29 17:31:41 +0300 | [diff] [blame] | 50 | } |
| 51 | } else { |
Markus Armbruster | 0cf9e2b | 2019-12-04 10:36:25 +0100 | [diff] [blame] | 52 | error_free_or_abort(&err); |
Alberto Garcia | 9ef8112 | 2016-07-29 17:31:41 +0300 | [diff] [blame] | 53 | g_assert_null(job); |
Alberto Garcia | 9ef8112 | 2016-07-29 17:31:41 +0300 | [diff] [blame] | 54 | } |
| 55 | |
| 56 | return job; |
| 57 | } |
| 58 | |
John Snow | fb367e0 | 2018-03-10 03:27:46 -0500 | [diff] [blame] | 59 | static BlockJob *do_test_id(BlockBackend *blk, const char *id, |
| 60 | bool should_succeed) |
| 61 | { |
| 62 | return mk_job(blk, id, &test_block_job_driver, |
Kevin Wolf | bb02b65 | 2018-04-19 17:54:56 +0200 | [diff] [blame] | 63 | should_succeed, JOB_DEFAULT); |
John Snow | fb367e0 | 2018-03-10 03:27:46 -0500 | [diff] [blame] | 64 | } |
| 65 | |
Alberto Garcia | 9ef8112 | 2016-07-29 17:31:41 +0300 | [diff] [blame] | 66 | /* This creates a BlockBackend (optionally with a name) with a |
| 67 | * BlockDriverState inserted. */ |
| 68 | static BlockBackend *create_blk(const char *name) |
| 69 | { |
Kevin Wolf | 2807c0c | 2017-02-09 15:48:04 +0100 | [diff] [blame] | 70 | /* No I/O is performed on this device */ |
Kevin Wolf | d861ab3 | 2019-04-25 14:25:10 +0200 | [diff] [blame] | 71 | BlockBackend *blk = blk_new(qemu_get_aio_context(), 0, BLK_PERM_ALL); |
Kevin Wolf | d185cf0 | 2017-01-16 17:17:38 +0100 | [diff] [blame] | 72 | BlockDriverState *bs; |
| 73 | |
Andrey Shinkevich | ca1ef1e | 2019-07-29 15:46:00 +0300 | [diff] [blame] | 74 | QDict *opt = qdict_new(); |
| 75 | qdict_put_str(opt, "file.read-zeroes", "on"); |
| 76 | bs = bdrv_open("null-co://", NULL, opt, 0, &error_abort); |
Kevin Wolf | d185cf0 | 2017-01-16 17:17:38 +0100 | [diff] [blame] | 77 | g_assert_nonnull(bs); |
Alberto Garcia | 9ef8112 | 2016-07-29 17:31:41 +0300 | [diff] [blame] | 78 | |
Kevin Wolf | d708642 | 2017-01-13 19:02:32 +0100 | [diff] [blame] | 79 | blk_insert_bs(blk, bs, &error_abort); |
Alberto Garcia | 9ef8112 | 2016-07-29 17:31:41 +0300 | [diff] [blame] | 80 | bdrv_unref(bs); |
| 81 | |
| 82 | if (name) { |
Markus Armbruster | 8ca63ba | 2019-12-04 10:36:23 +0100 | [diff] [blame] | 83 | Error *err = NULL; |
| 84 | monitor_add_blk(blk, name, &err); |
| 85 | g_assert_null(err); |
Alberto Garcia | 9ef8112 | 2016-07-29 17:31:41 +0300 | [diff] [blame] | 86 | } |
| 87 | |
| 88 | return blk; |
| 89 | } |
| 90 | |
| 91 | /* This destroys the backend */ |
| 92 | static void destroy_blk(BlockBackend *blk) |
| 93 | { |
| 94 | if (blk_name(blk)[0] != '\0') { |
| 95 | monitor_remove_blk(blk); |
| 96 | } |
| 97 | |
| 98 | blk_remove_bs(blk); |
| 99 | blk_unref(blk); |
| 100 | } |
| 101 | |
| 102 | static void test_job_ids(void) |
| 103 | { |
| 104 | BlockBackend *blk[3]; |
| 105 | BlockJob *job[3]; |
| 106 | |
| 107 | blk[0] = create_blk(NULL); |
| 108 | blk[1] = create_blk("drive1"); |
| 109 | blk[2] = create_blk("drive2"); |
| 110 | |
| 111 | /* No job ID provided and the block backend has no name */ |
| 112 | job[0] = do_test_id(blk[0], NULL, false); |
| 113 | |
| 114 | /* These are all invalid job IDs */ |
| 115 | job[0] = do_test_id(blk[0], "0id", false); |
| 116 | job[0] = do_test_id(blk[0], "", false); |
| 117 | job[0] = do_test_id(blk[0], " ", false); |
| 118 | job[0] = do_test_id(blk[0], "123", false); |
| 119 | job[0] = do_test_id(blk[0], "_id", false); |
| 120 | job[0] = do_test_id(blk[0], "-id", false); |
| 121 | job[0] = do_test_id(blk[0], ".id", false); |
| 122 | job[0] = do_test_id(blk[0], "#id", false); |
| 123 | |
| 124 | /* This one is valid */ |
| 125 | job[0] = do_test_id(blk[0], "id0", true); |
| 126 | |
Vladimir Sementsov-Ogievskiy | b23c580 | 2019-06-06 18:41:32 +0300 | [diff] [blame] | 127 | /* We can have two jobs in the same BDS */ |
| 128 | job[1] = do_test_id(blk[0], "id1", true); |
| 129 | job_early_fail(&job[1]->job); |
Alberto Garcia | 9ef8112 | 2016-07-29 17:31:41 +0300 | [diff] [blame] | 130 | |
| 131 | /* Duplicate job IDs are not allowed */ |
| 132 | job[1] = do_test_id(blk[1], "id0", false); |
| 133 | |
| 134 | /* But once job[0] finishes we can reuse its ID */ |
Kevin Wolf | 4ad3518 | 2018-04-19 17:30:16 +0200 | [diff] [blame] | 135 | job_early_fail(&job[0]->job); |
Alberto Garcia | 9ef8112 | 2016-07-29 17:31:41 +0300 | [diff] [blame] | 136 | job[1] = do_test_id(blk[1], "id0", true); |
| 137 | |
| 138 | /* No job ID specified, defaults to the backend name ('drive1') */ |
Kevin Wolf | 4ad3518 | 2018-04-19 17:30:16 +0200 | [diff] [blame] | 139 | job_early_fail(&job[1]->job); |
Alberto Garcia | 9ef8112 | 2016-07-29 17:31:41 +0300 | [diff] [blame] | 140 | job[1] = do_test_id(blk[1], NULL, true); |
| 141 | |
| 142 | /* Duplicate job ID */ |
| 143 | job[2] = do_test_id(blk[2], "drive1", false); |
| 144 | |
| 145 | /* The ID of job[2] would default to 'drive2' but it is already in use */ |
| 146 | job[0] = do_test_id(blk[0], "drive2", true); |
| 147 | job[2] = do_test_id(blk[2], NULL, false); |
| 148 | |
| 149 | /* This one is valid */ |
| 150 | job[2] = do_test_id(blk[2], "id_2", true); |
| 151 | |
Kevin Wolf | 4ad3518 | 2018-04-19 17:30:16 +0200 | [diff] [blame] | 152 | job_early_fail(&job[0]->job); |
| 153 | job_early_fail(&job[1]->job); |
| 154 | job_early_fail(&job[2]->job); |
Alberto Garcia | 9ef8112 | 2016-07-29 17:31:41 +0300 | [diff] [blame] | 155 | |
| 156 | destroy_blk(blk[0]); |
| 157 | destroy_blk(blk[1]); |
| 158 | destroy_blk(blk[2]); |
| 159 | } |
| 160 | |
John Snow | fb367e0 | 2018-03-10 03:27:46 -0500 | [diff] [blame] | 161 | typedef struct CancelJob { |
| 162 | BlockJob common; |
| 163 | BlockBackend *blk; |
| 164 | bool should_converge; |
| 165 | bool should_complete; |
John Snow | fb367e0 | 2018-03-10 03:27:46 -0500 | [diff] [blame] | 166 | } CancelJob; |
| 167 | |
Kevin Wolf | 3453d97 | 2018-04-23 12:24:16 +0200 | [diff] [blame] | 168 | static void cancel_job_complete(Job *job, Error **errp) |
John Snow | fb367e0 | 2018-03-10 03:27:46 -0500 | [diff] [blame] | 169 | { |
Kevin Wolf | 3453d97 | 2018-04-23 12:24:16 +0200 | [diff] [blame] | 170 | CancelJob *s = container_of(job, CancelJob, common.job); |
John Snow | fb367e0 | 2018-03-10 03:27:46 -0500 | [diff] [blame] | 171 | s->should_complete = true; |
| 172 | } |
| 173 | |
John Snow | f67432a | 2018-08-29 21:57:26 -0400 | [diff] [blame] | 174 | static int coroutine_fn cancel_job_run(Job *job, Error **errp) |
John Snow | fb367e0 | 2018-03-10 03:27:46 -0500 | [diff] [blame] | 175 | { |
John Snow | f67432a | 2018-08-29 21:57:26 -0400 | [diff] [blame] | 176 | CancelJob *s = container_of(job, CancelJob, common.job); |
John Snow | fb367e0 | 2018-03-10 03:27:46 -0500 | [diff] [blame] | 177 | |
| 178 | while (!s->should_complete) { |
Kevin Wolf | daa7f2f | 2018-04-17 12:56:07 +0200 | [diff] [blame] | 179 | if (job_is_cancelled(&s->common.job)) { |
John Snow | eb23654 | 2018-08-29 21:57:31 -0400 | [diff] [blame] | 180 | return 0; |
John Snow | fb367e0 | 2018-03-10 03:27:46 -0500 | [diff] [blame] | 181 | } |
| 182 | |
Kevin Wolf | df956ae | 2018-04-25 15:09:58 +0200 | [diff] [blame] | 183 | if (!job_is_ready(&s->common.job) && s->should_converge) { |
Kevin Wolf | 2e1795b | 2018-04-25 14:56:09 +0200 | [diff] [blame] | 184 | job_transition_to_ready(&s->common.job); |
John Snow | fb367e0 | 2018-03-10 03:27:46 -0500 | [diff] [blame] | 185 | } |
| 186 | |
Kevin Wolf | 5d43e86 | 2018-04-18 16:32:20 +0200 | [diff] [blame] | 187 | job_sleep_ns(&s->common.job, 100000); |
John Snow | fb367e0 | 2018-03-10 03:27:46 -0500 | [diff] [blame] | 188 | } |
| 189 | |
John Snow | f67432a | 2018-08-29 21:57:26 -0400 | [diff] [blame] | 190 | return 0; |
John Snow | fb367e0 | 2018-03-10 03:27:46 -0500 | [diff] [blame] | 191 | } |
| 192 | |
| 193 | static const BlockJobDriver test_cancel_driver = { |
Kevin Wolf | 33e9e9b | 2018-04-12 17:29:59 +0200 | [diff] [blame] | 194 | .job_driver = { |
| 195 | .instance_size = sizeof(CancelJob), |
Kevin Wolf | 80fa2c7 | 2018-04-13 18:50:05 +0200 | [diff] [blame] | 196 | .free = block_job_free, |
Kevin Wolf | b15de82 | 2018-04-18 17:10:26 +0200 | [diff] [blame] | 197 | .user_resume = block_job_user_resume, |
John Snow | f67432a | 2018-08-29 21:57:26 -0400 | [diff] [blame] | 198 | .run = cancel_job_run, |
Kevin Wolf | 3453d97 | 2018-04-23 12:24:16 +0200 | [diff] [blame] | 199 | .complete = cancel_job_complete, |
Kevin Wolf | 33e9e9b | 2018-04-12 17:29:59 +0200 | [diff] [blame] | 200 | }, |
John Snow | fb367e0 | 2018-03-10 03:27:46 -0500 | [diff] [blame] | 201 | }; |
| 202 | |
John Snow | 0cc4643 | 2018-09-06 09:02:17 -0400 | [diff] [blame] | 203 | static CancelJob *create_common(Job **pjob) |
John Snow | fb367e0 | 2018-03-10 03:27:46 -0500 | [diff] [blame] | 204 | { |
| 205 | BlockBackend *blk; |
John Snow | 0cc4643 | 2018-09-06 09:02:17 -0400 | [diff] [blame] | 206 | Job *job; |
| 207 | BlockJob *bjob; |
John Snow | fb367e0 | 2018-03-10 03:27:46 -0500 | [diff] [blame] | 208 | CancelJob *s; |
| 209 | |
| 210 | blk = create_blk(NULL); |
John Snow | 0cc4643 | 2018-09-06 09:02:17 -0400 | [diff] [blame] | 211 | bjob = mk_job(blk, "Steve", &test_cancel_driver, true, |
| 212 | JOB_MANUAL_FINALIZE | JOB_MANUAL_DISMISS); |
| 213 | job = &bjob->job; |
Emanuele Giuseppe Esposito | 191e7af | 2022-09-26 05:32:02 -0400 | [diff] [blame] | 214 | WITH_JOB_LOCK_GUARD() { |
| 215 | job_ref_locked(job); |
| 216 | assert(job->status == JOB_STATUS_CREATED); |
| 217 | } |
| 218 | |
John Snow | 0cc4643 | 2018-09-06 09:02:17 -0400 | [diff] [blame] | 219 | s = container_of(bjob, CancelJob, common); |
John Snow | fb367e0 | 2018-03-10 03:27:46 -0500 | [diff] [blame] | 220 | s->blk = blk; |
| 221 | |
| 222 | *pjob = job; |
| 223 | return s; |
| 224 | } |
| 225 | |
| 226 | static void cancel_common(CancelJob *s) |
| 227 | { |
| 228 | BlockJob *job = &s->common; |
| 229 | BlockBackend *blk = s->blk; |
Kevin Wolf | a50c2ab | 2018-04-13 17:19:31 +0200 | [diff] [blame] | 230 | JobStatus sts = job->job.status; |
Emanuele Giuseppe Esposito | 6f592e5 | 2022-09-26 05:32:11 -0400 | [diff] [blame] | 231 | AioContext *ctx = job->job.aio_context; |
John Snow | fb367e0 | 2018-03-10 03:27:46 -0500 | [diff] [blame] | 232 | |
Hanna Reitz | 4cfb3f0 | 2021-10-06 17:19:32 +0200 | [diff] [blame] | 233 | job_cancel_sync(&job->job, true); |
Emanuele Giuseppe Esposito | 191e7af | 2022-09-26 05:32:02 -0400 | [diff] [blame] | 234 | WITH_JOB_LOCK_GUARD() { |
| 235 | if (sts != JOB_STATUS_CREATED && sts != JOB_STATUS_CONCLUDED) { |
| 236 | Job *dummy = &job->job; |
| 237 | job_dismiss_locked(&dummy, &error_abort); |
| 238 | } |
| 239 | assert(job->job.status == JOB_STATUS_NULL); |
| 240 | job_unref_locked(&job->job); |
John Snow | fb367e0 | 2018-03-10 03:27:46 -0500 | [diff] [blame] | 241 | } |
Kevin Wolf | 30c070a | 2018-08-17 17:29:08 +0200 | [diff] [blame] | 242 | |
Emanuele Giuseppe Esposito | 6f592e5 | 2022-09-26 05:32:11 -0400 | [diff] [blame] | 243 | aio_context_acquire(ctx); |
| 244 | destroy_blk(blk); |
Kevin Wolf | 30c070a | 2018-08-17 17:29:08 +0200 | [diff] [blame] | 245 | aio_context_release(ctx); |
Emanuele Giuseppe Esposito | 6f592e5 | 2022-09-26 05:32:11 -0400 | [diff] [blame] | 246 | |
John Snow | fb367e0 | 2018-03-10 03:27:46 -0500 | [diff] [blame] | 247 | } |
| 248 | |
| 249 | static void test_cancel_created(void) |
| 250 | { |
John Snow | 0cc4643 | 2018-09-06 09:02:17 -0400 | [diff] [blame] | 251 | Job *job; |
John Snow | fb367e0 | 2018-03-10 03:27:46 -0500 | [diff] [blame] | 252 | CancelJob *s; |
| 253 | |
| 254 | s = create_common(&job); |
| 255 | cancel_common(s); |
| 256 | } |
| 257 | |
Emanuele Giuseppe Esposito | 191e7af | 2022-09-26 05:32:02 -0400 | [diff] [blame] | 258 | static void assert_job_status_is(Job *job, int status) |
| 259 | { |
| 260 | WITH_JOB_LOCK_GUARD() { |
| 261 | assert(job->status == status); |
| 262 | } |
| 263 | } |
| 264 | |
John Snow | fb367e0 | 2018-03-10 03:27:46 -0500 | [diff] [blame] | 265 | static void test_cancel_running(void) |
| 266 | { |
John Snow | 0cc4643 | 2018-09-06 09:02:17 -0400 | [diff] [blame] | 267 | Job *job; |
John Snow | fb367e0 | 2018-03-10 03:27:46 -0500 | [diff] [blame] | 268 | CancelJob *s; |
| 269 | |
| 270 | s = create_common(&job); |
| 271 | |
John Snow | 0cc4643 | 2018-09-06 09:02:17 -0400 | [diff] [blame] | 272 | job_start(job); |
Emanuele Giuseppe Esposito | 191e7af | 2022-09-26 05:32:02 -0400 | [diff] [blame] | 273 | assert_job_status_is(job, JOB_STATUS_RUNNING); |
John Snow | fb367e0 | 2018-03-10 03:27:46 -0500 | [diff] [blame] | 274 | |
| 275 | cancel_common(s); |
| 276 | } |
| 277 | |
| 278 | static void test_cancel_paused(void) |
| 279 | { |
John Snow | 0cc4643 | 2018-09-06 09:02:17 -0400 | [diff] [blame] | 280 | Job *job; |
John Snow | fb367e0 | 2018-03-10 03:27:46 -0500 | [diff] [blame] | 281 | CancelJob *s; |
| 282 | |
| 283 | s = create_common(&job); |
| 284 | |
John Snow | 0cc4643 | 2018-09-06 09:02:17 -0400 | [diff] [blame] | 285 | job_start(job); |
Emanuele Giuseppe Esposito | 191e7af | 2022-09-26 05:32:02 -0400 | [diff] [blame] | 286 | WITH_JOB_LOCK_GUARD() { |
| 287 | assert(job->status == JOB_STATUS_RUNNING); |
| 288 | job_user_pause_locked(job, &error_abort); |
| 289 | } |
John Snow | 0cc4643 | 2018-09-06 09:02:17 -0400 | [diff] [blame] | 290 | job_enter(job); |
Emanuele Giuseppe Esposito | 191e7af | 2022-09-26 05:32:02 -0400 | [diff] [blame] | 291 | assert_job_status_is(job, JOB_STATUS_PAUSED); |
John Snow | fb367e0 | 2018-03-10 03:27:46 -0500 | [diff] [blame] | 292 | |
| 293 | cancel_common(s); |
| 294 | } |
| 295 | |
| 296 | static void test_cancel_ready(void) |
| 297 | { |
John Snow | 0cc4643 | 2018-09-06 09:02:17 -0400 | [diff] [blame] | 298 | Job *job; |
John Snow | fb367e0 | 2018-03-10 03:27:46 -0500 | [diff] [blame] | 299 | CancelJob *s; |
| 300 | |
| 301 | s = create_common(&job); |
| 302 | |
John Snow | 0cc4643 | 2018-09-06 09:02:17 -0400 | [diff] [blame] | 303 | job_start(job); |
Emanuele Giuseppe Esposito | 191e7af | 2022-09-26 05:32:02 -0400 | [diff] [blame] | 304 | assert_job_status_is(job, JOB_STATUS_RUNNING); |
John Snow | fb367e0 | 2018-03-10 03:27:46 -0500 | [diff] [blame] | 305 | |
| 306 | s->should_converge = true; |
John Snow | 0cc4643 | 2018-09-06 09:02:17 -0400 | [diff] [blame] | 307 | job_enter(job); |
Emanuele Giuseppe Esposito | 191e7af | 2022-09-26 05:32:02 -0400 | [diff] [blame] | 308 | assert_job_status_is(job, JOB_STATUS_READY); |
John Snow | fb367e0 | 2018-03-10 03:27:46 -0500 | [diff] [blame] | 309 | |
| 310 | cancel_common(s); |
| 311 | } |
| 312 | |
| 313 | static void test_cancel_standby(void) |
| 314 | { |
John Snow | 0cc4643 | 2018-09-06 09:02:17 -0400 | [diff] [blame] | 315 | Job *job; |
John Snow | fb367e0 | 2018-03-10 03:27:46 -0500 | [diff] [blame] | 316 | CancelJob *s; |
| 317 | |
| 318 | s = create_common(&job); |
| 319 | |
John Snow | 0cc4643 | 2018-09-06 09:02:17 -0400 | [diff] [blame] | 320 | job_start(job); |
Emanuele Giuseppe Esposito | 191e7af | 2022-09-26 05:32:02 -0400 | [diff] [blame] | 321 | assert_job_status_is(job, JOB_STATUS_RUNNING); |
John Snow | fb367e0 | 2018-03-10 03:27:46 -0500 | [diff] [blame] | 322 | |
| 323 | s->should_converge = true; |
John Snow | 0cc4643 | 2018-09-06 09:02:17 -0400 | [diff] [blame] | 324 | job_enter(job); |
Emanuele Giuseppe Esposito | 191e7af | 2022-09-26 05:32:02 -0400 | [diff] [blame] | 325 | WITH_JOB_LOCK_GUARD() { |
| 326 | assert(job->status == JOB_STATUS_READY); |
| 327 | job_user_pause_locked(job, &error_abort); |
| 328 | } |
John Snow | 0cc4643 | 2018-09-06 09:02:17 -0400 | [diff] [blame] | 329 | job_enter(job); |
Emanuele Giuseppe Esposito | 191e7af | 2022-09-26 05:32:02 -0400 | [diff] [blame] | 330 | assert_job_status_is(job, JOB_STATUS_STANDBY); |
John Snow | fb367e0 | 2018-03-10 03:27:46 -0500 | [diff] [blame] | 331 | |
| 332 | cancel_common(s); |
| 333 | } |
| 334 | |
| 335 | static void test_cancel_pending(void) |
| 336 | { |
John Snow | 0cc4643 | 2018-09-06 09:02:17 -0400 | [diff] [blame] | 337 | Job *job; |
John Snow | fb367e0 | 2018-03-10 03:27:46 -0500 | [diff] [blame] | 338 | CancelJob *s; |
| 339 | |
| 340 | s = create_common(&job); |
| 341 | |
John Snow | 0cc4643 | 2018-09-06 09:02:17 -0400 | [diff] [blame] | 342 | job_start(job); |
Emanuele Giuseppe Esposito | 191e7af | 2022-09-26 05:32:02 -0400 | [diff] [blame] | 343 | assert_job_status_is(job, JOB_STATUS_RUNNING); |
John Snow | fb367e0 | 2018-03-10 03:27:46 -0500 | [diff] [blame] | 344 | |
| 345 | s->should_converge = true; |
John Snow | 0cc4643 | 2018-09-06 09:02:17 -0400 | [diff] [blame] | 346 | job_enter(job); |
Emanuele Giuseppe Esposito | 191e7af | 2022-09-26 05:32:02 -0400 | [diff] [blame] | 347 | WITH_JOB_LOCK_GUARD() { |
| 348 | assert(job->status == JOB_STATUS_READY); |
| 349 | job_complete_locked(job, &error_abort); |
| 350 | } |
John Snow | 0cc4643 | 2018-09-06 09:02:17 -0400 | [diff] [blame] | 351 | job_enter(job); |
John Snow | 977d26f | 2018-09-06 09:02:18 -0400 | [diff] [blame] | 352 | while (!job->deferred_to_main_loop) { |
John Snow | fb367e0 | 2018-03-10 03:27:46 -0500 | [diff] [blame] | 353 | aio_poll(qemu_get_aio_context(), true); |
| 354 | } |
Emanuele Giuseppe Esposito | 191e7af | 2022-09-26 05:32:02 -0400 | [diff] [blame] | 355 | assert_job_status_is(job, JOB_STATUS_READY); |
John Snow | 977d26f | 2018-09-06 09:02:18 -0400 | [diff] [blame] | 356 | aio_poll(qemu_get_aio_context(), true); |
Emanuele Giuseppe Esposito | 191e7af | 2022-09-26 05:32:02 -0400 | [diff] [blame] | 357 | assert_job_status_is(job, JOB_STATUS_PENDING); |
John Snow | fb367e0 | 2018-03-10 03:27:46 -0500 | [diff] [blame] | 358 | |
| 359 | cancel_common(s); |
| 360 | } |
| 361 | |
| 362 | static void test_cancel_concluded(void) |
| 363 | { |
John Snow | 0cc4643 | 2018-09-06 09:02:17 -0400 | [diff] [blame] | 364 | Job *job; |
John Snow | fb367e0 | 2018-03-10 03:27:46 -0500 | [diff] [blame] | 365 | CancelJob *s; |
| 366 | |
| 367 | s = create_common(&job); |
| 368 | |
John Snow | 0cc4643 | 2018-09-06 09:02:17 -0400 | [diff] [blame] | 369 | job_start(job); |
Emanuele Giuseppe Esposito | 191e7af | 2022-09-26 05:32:02 -0400 | [diff] [blame] | 370 | assert_job_status_is(job, JOB_STATUS_RUNNING); |
John Snow | fb367e0 | 2018-03-10 03:27:46 -0500 | [diff] [blame] | 371 | |
| 372 | s->should_converge = true; |
John Snow | 0cc4643 | 2018-09-06 09:02:17 -0400 | [diff] [blame] | 373 | job_enter(job); |
Emanuele Giuseppe Esposito | 191e7af | 2022-09-26 05:32:02 -0400 | [diff] [blame] | 374 | WITH_JOB_LOCK_GUARD() { |
| 375 | assert(job->status == JOB_STATUS_READY); |
| 376 | job_complete_locked(job, &error_abort); |
| 377 | } |
John Snow | 0cc4643 | 2018-09-06 09:02:17 -0400 | [diff] [blame] | 378 | job_enter(job); |
John Snow | 977d26f | 2018-09-06 09:02:18 -0400 | [diff] [blame] | 379 | while (!job->deferred_to_main_loop) { |
John Snow | fb367e0 | 2018-03-10 03:27:46 -0500 | [diff] [blame] | 380 | aio_poll(qemu_get_aio_context(), true); |
| 381 | } |
Emanuele Giuseppe Esposito | 191e7af | 2022-09-26 05:32:02 -0400 | [diff] [blame] | 382 | assert_job_status_is(job, JOB_STATUS_READY); |
John Snow | 977d26f | 2018-09-06 09:02:18 -0400 | [diff] [blame] | 383 | aio_poll(qemu_get_aio_context(), true); |
Emanuele Giuseppe Esposito | 191e7af | 2022-09-26 05:32:02 -0400 | [diff] [blame] | 384 | assert_job_status_is(job, JOB_STATUS_PENDING); |
John Snow | fb367e0 | 2018-03-10 03:27:46 -0500 | [diff] [blame] | 385 | |
Emanuele Giuseppe Esposito | 191e7af | 2022-09-26 05:32:02 -0400 | [diff] [blame] | 386 | WITH_JOB_LOCK_GUARD() { |
| 387 | job_finalize_locked(job, &error_abort); |
Emanuele Giuseppe Esposito | 6f592e5 | 2022-09-26 05:32:11 -0400 | [diff] [blame] | 388 | assert(job->status == JOB_STATUS_CONCLUDED); |
Emanuele Giuseppe Esposito | 191e7af | 2022-09-26 05:32:02 -0400 | [diff] [blame] | 389 | } |
John Snow | fb367e0 | 2018-03-10 03:27:46 -0500 | [diff] [blame] | 390 | |
| 391 | cancel_common(s); |
| 392 | } |
| 393 | |
Max Reitz | c2c731a | 2021-04-09 14:04:21 +0200 | [diff] [blame] | 394 | /* (See test_yielding_driver for the job description) */ |
| 395 | typedef struct YieldingJob { |
| 396 | BlockJob common; |
| 397 | bool should_complete; |
| 398 | } YieldingJob; |
| 399 | |
| 400 | static void yielding_job_complete(Job *job, Error **errp) |
| 401 | { |
| 402 | YieldingJob *s = container_of(job, YieldingJob, common.job); |
| 403 | s->should_complete = true; |
| 404 | job_enter(job); |
| 405 | } |
| 406 | |
| 407 | static int coroutine_fn yielding_job_run(Job *job, Error **errp) |
| 408 | { |
| 409 | YieldingJob *s = container_of(job, YieldingJob, common.job); |
| 410 | |
| 411 | job_transition_to_ready(job); |
| 412 | |
| 413 | while (!s->should_complete) { |
| 414 | job_yield(job); |
| 415 | } |
| 416 | |
| 417 | return 0; |
| 418 | } |
| 419 | |
| 420 | /* |
| 421 | * This job transitions immediately to the READY state, and then |
| 422 | * yields until it is to complete. |
| 423 | */ |
| 424 | static const BlockJobDriver test_yielding_driver = { |
| 425 | .job_driver = { |
| 426 | .instance_size = sizeof(YieldingJob), |
| 427 | .free = block_job_free, |
| 428 | .user_resume = block_job_user_resume, |
| 429 | .run = yielding_job_run, |
| 430 | .complete = yielding_job_complete, |
| 431 | }, |
| 432 | }; |
| 433 | |
| 434 | /* |
Emanuele Giuseppe Esposito | 9bd4d3c | 2022-09-26 05:32:14 -0400 | [diff] [blame] | 435 | * Test that job_complete_locked() works even on jobs that are in a paused |
Max Reitz | c2c731a | 2021-04-09 14:04:21 +0200 | [diff] [blame] | 436 | * state (i.e., STANDBY). |
| 437 | * |
| 438 | * To do this, run YieldingJob in an IO thread, get it into the READY |
| 439 | * state, then have a drained section. Before ending the section, |
| 440 | * acquire the context so the job will not be entered and will thus |
| 441 | * remain on STANDBY. |
| 442 | * |
Emanuele Giuseppe Esposito | 9bd4d3c | 2022-09-26 05:32:14 -0400 | [diff] [blame] | 443 | * job_complete_locked() should still work without error. |
Max Reitz | c2c731a | 2021-04-09 14:04:21 +0200 | [diff] [blame] | 444 | * |
| 445 | * Note that on the QMP interface, it is impossible to lock an IO |
| 446 | * thread before a drained section ends. In practice, the |
| 447 | * bdrv_drain_all_end() and the aio_context_acquire() will be |
| 448 | * reversed. However, that makes for worse reproducibility here: |
| 449 | * Sometimes, the job would no longer be in STANDBY then but already |
| 450 | * be started. We cannot prevent that, because the IO thread runs |
| 451 | * concurrently. We can only prevent it by taking the lock before |
| 452 | * ending the drained section, so we do that. |
| 453 | * |
| 454 | * (You can reverse the order of operations and most of the time the |
| 455 | * test will pass, but sometimes the assert(status == STANDBY) will |
| 456 | * fail.) |
| 457 | */ |
| 458 | static void test_complete_in_standby(void) |
| 459 | { |
| 460 | BlockBackend *blk; |
| 461 | IOThread *iothread; |
| 462 | AioContext *ctx; |
| 463 | Job *job; |
| 464 | BlockJob *bjob; |
| 465 | |
| 466 | /* Create a test drive, move it to an IO thread */ |
| 467 | blk = create_blk(NULL); |
| 468 | iothread = iothread_new(); |
| 469 | |
| 470 | ctx = iothread_get_aio_context(iothread); |
| 471 | blk_set_aio_context(blk, ctx, &error_abort); |
| 472 | |
| 473 | /* Create our test job */ |
| 474 | bjob = mk_job(blk, "job", &test_yielding_driver, true, |
| 475 | JOB_MANUAL_FINALIZE | JOB_MANUAL_DISMISS); |
| 476 | job = &bjob->job; |
Emanuele Giuseppe Esposito | 191e7af | 2022-09-26 05:32:02 -0400 | [diff] [blame] | 477 | assert_job_status_is(job, JOB_STATUS_CREATED); |
Max Reitz | c2c731a | 2021-04-09 14:04:21 +0200 | [diff] [blame] | 478 | |
| 479 | /* Wait for the job to become READY */ |
| 480 | job_start(job); |
Emanuele Giuseppe Esposito | 191e7af | 2022-09-26 05:32:02 -0400 | [diff] [blame] | 481 | /* |
| 482 | * Here we are waiting for the status to change, so don't bother |
| 483 | * protecting the read every time. |
| 484 | */ |
Emanuele Giuseppe Esposito | 6f592e5 | 2022-09-26 05:32:11 -0400 | [diff] [blame] | 485 | AIO_WAIT_WHILE_UNLOCKED(ctx, job->status != JOB_STATUS_READY); |
Max Reitz | c2c731a | 2021-04-09 14:04:21 +0200 | [diff] [blame] | 486 | |
| 487 | /* Begin the drained section, pausing the job */ |
| 488 | bdrv_drain_all_begin(); |
Emanuele Giuseppe Esposito | 191e7af | 2022-09-26 05:32:02 -0400 | [diff] [blame] | 489 | assert_job_status_is(job, JOB_STATUS_STANDBY); |
| 490 | |
Max Reitz | c2c731a | 2021-04-09 14:04:21 +0200 | [diff] [blame] | 491 | /* Lock the IO thread to prevent the job from being run */ |
| 492 | aio_context_acquire(ctx); |
| 493 | /* This will schedule the job to resume it */ |
| 494 | bdrv_drain_all_end(); |
Emanuele Giuseppe Esposito | 6f592e5 | 2022-09-26 05:32:11 -0400 | [diff] [blame] | 495 | aio_context_release(ctx); |
Max Reitz | c2c731a | 2021-04-09 14:04:21 +0200 | [diff] [blame] | 496 | |
Emanuele Giuseppe Esposito | 191e7af | 2022-09-26 05:32:02 -0400 | [diff] [blame] | 497 | WITH_JOB_LOCK_GUARD() { |
| 498 | /* But the job cannot run, so it will remain on standby */ |
| 499 | assert(job->status == JOB_STATUS_STANDBY); |
Max Reitz | c2c731a | 2021-04-09 14:04:21 +0200 | [diff] [blame] | 500 | |
Emanuele Giuseppe Esposito | 191e7af | 2022-09-26 05:32:02 -0400 | [diff] [blame] | 501 | /* Even though the job is on standby, this should work */ |
| 502 | job_complete_locked(job, &error_abort); |
Max Reitz | c2c731a | 2021-04-09 14:04:21 +0200 | [diff] [blame] | 503 | |
Emanuele Giuseppe Esposito | 191e7af | 2022-09-26 05:32:02 -0400 | [diff] [blame] | 504 | /* The test is done now, clean up. */ |
| 505 | job_finish_sync_locked(job, NULL, &error_abort); |
| 506 | assert(job->status == JOB_STATUS_PENDING); |
Max Reitz | c2c731a | 2021-04-09 14:04:21 +0200 | [diff] [blame] | 507 | |
Emanuele Giuseppe Esposito | 191e7af | 2022-09-26 05:32:02 -0400 | [diff] [blame] | 508 | job_finalize_locked(job, &error_abort); |
| 509 | assert(job->status == JOB_STATUS_CONCLUDED); |
Max Reitz | c2c731a | 2021-04-09 14:04:21 +0200 | [diff] [blame] | 510 | |
Emanuele Giuseppe Esposito | 191e7af | 2022-09-26 05:32:02 -0400 | [diff] [blame] | 511 | job_dismiss_locked(&job, &error_abort); |
| 512 | } |
Max Reitz | c2c731a | 2021-04-09 14:04:21 +0200 | [diff] [blame] | 513 | |
Emanuele Giuseppe Esposito | 6f592e5 | 2022-09-26 05:32:11 -0400 | [diff] [blame] | 514 | aio_context_acquire(ctx); |
Max Reitz | c2c731a | 2021-04-09 14:04:21 +0200 | [diff] [blame] | 515 | destroy_blk(blk); |
| 516 | aio_context_release(ctx); |
| 517 | iothread_join(iothread); |
| 518 | } |
| 519 | |
Alberto Garcia | 9ef8112 | 2016-07-29 17:31:41 +0300 | [diff] [blame] | 520 | int main(int argc, char **argv) |
| 521 | { |
| 522 | qemu_init_main_loop(&error_abort); |
Kevin Wolf | d185cf0 | 2017-01-16 17:17:38 +0100 | [diff] [blame] | 523 | bdrv_init(); |
Alberto Garcia | 9ef8112 | 2016-07-29 17:31:41 +0300 | [diff] [blame] | 524 | |
| 525 | g_test_init(&argc, &argv, NULL); |
| 526 | g_test_add_func("/blockjob/ids", test_job_ids); |
John Snow | fb367e0 | 2018-03-10 03:27:46 -0500 | [diff] [blame] | 527 | g_test_add_func("/blockjob/cancel/created", test_cancel_created); |
| 528 | g_test_add_func("/blockjob/cancel/running", test_cancel_running); |
| 529 | g_test_add_func("/blockjob/cancel/paused", test_cancel_paused); |
| 530 | g_test_add_func("/blockjob/cancel/ready", test_cancel_ready); |
| 531 | g_test_add_func("/blockjob/cancel/standby", test_cancel_standby); |
| 532 | g_test_add_func("/blockjob/cancel/pending", test_cancel_pending); |
| 533 | g_test_add_func("/blockjob/cancel/concluded", test_cancel_concluded); |
Peter Maydell | b6903cb | 2023-03-17 14:35:34 +0000 | [diff] [blame] | 534 | |
| 535 | /* |
| 536 | * This test is flaky and sometimes fails in CI and otherwise: |
| 537 | * don't run unless user opts in via environment variable. |
| 538 | */ |
| 539 | if (getenv("QEMU_TEST_FLAKY_TESTS")) { |
| 540 | g_test_add_func("/blockjob/complete_in_standby", test_complete_in_standby); |
| 541 | } |
Alberto Garcia | 9ef8112 | 2016-07-29 17:31:41 +0300 | [diff] [blame] | 542 | return g_test_run(); |
| 543 | } |