4 * Copyright Igalia, S.L. 2016
7 * Alberto Garcia <berto@igalia.com>
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.
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"
19 static const BlockJobDriver test_block_job_driver
= {
21 .instance_size
= sizeof(BlockJob
),
22 .free
= block_job_free
,
23 .user_resume
= block_job_user_resume
,
24 .drain
= block_job_drain
,
28 static void block_job_cb(void *opaque
, int ret
)
32 static BlockJob
*mk_job(BlockBackend
*blk
, const char *id
,
33 const BlockJobDriver
*drv
, bool should_succeed
,
39 job
= block_job_create(id
, drv
, NULL
, blk_bs(blk
),
40 0, BLK_PERM_ALL
, 0, flags
, block_job_cb
,
44 g_assert_nonnull(job
);
46 g_assert_cmpstr(job
->job
.id
, ==, id
);
48 g_assert_cmpstr(job
->job
.id
, ==, blk_name(blk
));
51 g_assert_nonnull(errp
);
59 static BlockJob
*do_test_id(BlockBackend
*blk
, const char *id
,
62 return mk_job(blk
, id
, &test_block_job_driver
,
63 should_succeed
, JOB_DEFAULT
);
66 /* This creates a BlockBackend (optionally with a name) with a
67 * BlockDriverState inserted. */
68 static BlockBackend
*create_blk(const char *name
)
70 /* No I/O is performed on this device */
71 BlockBackend
*blk
= blk_new(0, BLK_PERM_ALL
);
74 bs
= bdrv_open("null-co://", NULL
, NULL
, 0, &error_abort
);
77 blk_insert_bs(blk
, bs
, &error_abort
);
82 monitor_add_blk(blk
, name
, &errp
);
89 /* This destroys the backend */
90 static void destroy_blk(BlockBackend
*blk
)
92 if (blk_name(blk
)[0] != '\0') {
93 monitor_remove_blk(blk
);
100 static void test_job_ids(void)
102 BlockBackend
*blk
[3];
105 blk
[0] = create_blk(NULL
);
106 blk
[1] = create_blk("drive1");
107 blk
[2] = create_blk("drive2");
109 /* No job ID provided and the block backend has no name */
110 job
[0] = do_test_id(blk
[0], NULL
, false);
112 /* These are all invalid job IDs */
113 job
[0] = do_test_id(blk
[0], "0id", false);
114 job
[0] = do_test_id(blk
[0], "", false);
115 job
[0] = do_test_id(blk
[0], " ", false);
116 job
[0] = do_test_id(blk
[0], "123", false);
117 job
[0] = do_test_id(blk
[0], "_id", false);
118 job
[0] = do_test_id(blk
[0], "-id", false);
119 job
[0] = do_test_id(blk
[0], ".id", false);
120 job
[0] = do_test_id(blk
[0], "#id", false);
122 /* This one is valid */
123 job
[0] = do_test_id(blk
[0], "id0", true);
125 /* We cannot have two jobs in the same BDS */
126 do_test_id(blk
[0], "id1", false);
128 /* Duplicate job IDs are not allowed */
129 job
[1] = do_test_id(blk
[1], "id0", false);
131 /* But once job[0] finishes we can reuse its ID */
132 job_early_fail(&job
[0]->job
);
133 job
[1] = do_test_id(blk
[1], "id0", true);
135 /* No job ID specified, defaults to the backend name ('drive1') */
136 job_early_fail(&job
[1]->job
);
137 job
[1] = do_test_id(blk
[1], NULL
, true);
139 /* Duplicate job ID */
140 job
[2] = do_test_id(blk
[2], "drive1", false);
142 /* The ID of job[2] would default to 'drive2' but it is already in use */
143 job
[0] = do_test_id(blk
[0], "drive2", true);
144 job
[2] = do_test_id(blk
[2], NULL
, false);
146 /* This one is valid */
147 job
[2] = do_test_id(blk
[2], "id_2", true);
149 job_early_fail(&job
[0]->job
);
150 job_early_fail(&job
[1]->job
);
151 job_early_fail(&job
[2]->job
);
158 typedef struct CancelJob
{
161 bool should_converge
;
162 bool should_complete
;
166 static void cancel_job_exit(Job
*job
)
168 CancelJob
*s
= container_of(job
, CancelJob
, common
.job
);
172 static void cancel_job_complete(Job
*job
, Error
**errp
)
174 CancelJob
*s
= container_of(job
, CancelJob
, common
.job
);
175 s
->should_complete
= true;
178 static int coroutine_fn
cancel_job_run(Job
*job
, Error
**errp
)
180 CancelJob
*s
= container_of(job
, CancelJob
, common
.job
);
182 while (!s
->should_complete
) {
183 if (job_is_cancelled(&s
->common
.job
)) {
187 if (!job_is_ready(&s
->common
.job
) && s
->should_converge
) {
188 job_transition_to_ready(&s
->common
.job
);
191 job_sleep_ns(&s
->common
.job
, 100000);
197 static const BlockJobDriver test_cancel_driver
= {
199 .instance_size
= sizeof(CancelJob
),
200 .free
= block_job_free
,
201 .user_resume
= block_job_user_resume
,
202 .drain
= block_job_drain
,
203 .run
= cancel_job_run
,
204 .exit
= cancel_job_exit
,
205 .complete
= cancel_job_complete
,
209 static CancelJob
*create_common(BlockJob
**pjob
)
215 blk
= create_blk(NULL
);
216 job
= mk_job(blk
, "Steve", &test_cancel_driver
, true,
217 JOB_MANUAL_FINALIZE
| JOB_MANUAL_DISMISS
);
219 assert(job
->job
.status
== JOB_STATUS_CREATED
);
220 s
= container_of(job
, CancelJob
, common
);
227 static void cancel_common(CancelJob
*s
)
229 BlockJob
*job
= &s
->common
;
230 BlockBackend
*blk
= s
->blk
;
231 JobStatus sts
= job
->job
.status
;
233 job_cancel_sync(&job
->job
);
234 if (sts
!= JOB_STATUS_CREATED
&& sts
!= JOB_STATUS_CONCLUDED
) {
235 Job
*dummy
= &job
->job
;
236 job_dismiss(&dummy
, &error_abort
);
238 assert(job
->job
.status
== JOB_STATUS_NULL
);
239 job_unref(&job
->job
);
243 static void test_cancel_created(void)
248 s
= create_common(&job
);
252 static void test_cancel_running(void)
257 s
= create_common(&job
);
259 job_start(&job
->job
);
260 assert(job
->job
.status
== JOB_STATUS_RUNNING
);
265 static void test_cancel_paused(void)
270 s
= create_common(&job
);
272 job_start(&job
->job
);
273 assert(job
->job
.status
== JOB_STATUS_RUNNING
);
275 job_user_pause(&job
->job
, &error_abort
);
276 job_enter(&job
->job
);
277 assert(job
->job
.status
== JOB_STATUS_PAUSED
);
282 static void test_cancel_ready(void)
287 s
= create_common(&job
);
289 job_start(&job
->job
);
290 assert(job
->job
.status
== JOB_STATUS_RUNNING
);
292 s
->should_converge
= true;
293 job_enter(&job
->job
);
294 assert(job
->job
.status
== JOB_STATUS_READY
);
299 static void test_cancel_standby(void)
304 s
= create_common(&job
);
306 job_start(&job
->job
);
307 assert(job
->job
.status
== JOB_STATUS_RUNNING
);
309 s
->should_converge
= true;
310 job_enter(&job
->job
);
311 assert(job
->job
.status
== JOB_STATUS_READY
);
313 job_user_pause(&job
->job
, &error_abort
);
314 job_enter(&job
->job
);
315 assert(job
->job
.status
== JOB_STATUS_STANDBY
);
320 static void test_cancel_pending(void)
325 s
= create_common(&job
);
327 job_start(&job
->job
);
328 assert(job
->job
.status
== JOB_STATUS_RUNNING
);
330 s
->should_converge
= true;
331 job_enter(&job
->job
);
332 assert(job
->job
.status
== JOB_STATUS_READY
);
334 job_complete(&job
->job
, &error_abort
);
335 job_enter(&job
->job
);
336 while (!s
->completed
) {
337 aio_poll(qemu_get_aio_context(), true);
339 assert(job
->job
.status
== JOB_STATUS_PENDING
);
344 static void test_cancel_concluded(void)
349 s
= create_common(&job
);
351 job_start(&job
->job
);
352 assert(job
->job
.status
== JOB_STATUS_RUNNING
);
354 s
->should_converge
= true;
355 job_enter(&job
->job
);
356 assert(job
->job
.status
== JOB_STATUS_READY
);
358 job_complete(&job
->job
, &error_abort
);
359 job_enter(&job
->job
);
360 while (!s
->completed
) {
361 aio_poll(qemu_get_aio_context(), true);
363 assert(job
->job
.status
== JOB_STATUS_PENDING
);
365 job_finalize(&job
->job
, &error_abort
);
366 assert(job
->job
.status
== JOB_STATUS_CONCLUDED
);
371 int main(int argc
, char **argv
)
373 qemu_init_main_loop(&error_abort
);
376 g_test_init(&argc
, &argv
, NULL
);
377 g_test_add_func("/blockjob/ids", test_job_ids
);
378 g_test_add_func("/blockjob/cancel/created", test_cancel_created
);
379 g_test_add_func("/blockjob/cancel/running", test_cancel_running
);
380 g_test_add_func("/blockjob/cancel/paused", test_cancel_paused
);
381 g_test_add_func("/blockjob/cancel/ready", test_cancel_ready
);
382 g_test_add_func("/blockjob/cancel/standby", test_cancel_standby
);
383 g_test_add_func("/blockjob/cancel/pending", test_cancel_pending
);
384 g_test_add_func("/blockjob/cancel/concluded", test_cancel_concluded
);