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"
18 #include "qapi/qmp/qdict.h"
21 static const BlockJobDriver test_block_job_driver
= {
23 .instance_size
= sizeof(BlockJob
),
24 .free
= block_job_free
,
25 .user_resume
= block_job_user_resume
,
29 static void block_job_cb(void *opaque
, int ret
)
33 static BlockJob
*mk_job(BlockBackend
*blk
, const char *id
,
34 const BlockJobDriver
*drv
, bool should_succeed
,
40 job
= block_job_create(id
, drv
, NULL
, blk_bs(blk
),
41 0, BLK_PERM_ALL
, 0, flags
, block_job_cb
,
45 g_assert_nonnull(job
);
47 g_assert_cmpstr(job
->job
.id
, ==, id
);
49 g_assert_cmpstr(job
->job
.id
, ==, blk_name(blk
));
52 error_free_or_abort(&err
);
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(qemu_get_aio_context(), 0, BLK_PERM_ALL
);
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
);
79 blk_insert_bs(blk
, bs
, &error_abort
);
84 monitor_add_blk(blk
, name
, &err
);
91 /* This destroys the backend */
92 static void destroy_blk(BlockBackend
*blk
)
94 if (blk_name(blk
)[0] != '\0') {
95 monitor_remove_blk(blk
);
102 static void test_job_ids(void)
104 BlockBackend
*blk
[3];
107 blk
[0] = create_blk(NULL
);
108 blk
[1] = create_blk("drive1");
109 blk
[2] = create_blk("drive2");
111 /* No job ID provided and the block backend has no name */
112 job
[0] = do_test_id(blk
[0], NULL
, false);
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);
124 /* This one is valid */
125 job
[0] = do_test_id(blk
[0], "id0", true);
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
);
131 /* Duplicate job IDs are not allowed */
132 job
[1] = do_test_id(blk
[1], "id0", false);
134 /* But once job[0] finishes we can reuse its ID */
135 job_early_fail(&job
[0]->job
);
136 job
[1] = do_test_id(blk
[1], "id0", true);
138 /* No job ID specified, defaults to the backend name ('drive1') */
139 job_early_fail(&job
[1]->job
);
140 job
[1] = do_test_id(blk
[1], NULL
, true);
142 /* Duplicate job ID */
143 job
[2] = do_test_id(blk
[2], "drive1", false);
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);
149 /* This one is valid */
150 job
[2] = do_test_id(blk
[2], "id_2", true);
152 job_early_fail(&job
[0]->job
);
153 job_early_fail(&job
[1]->job
);
154 job_early_fail(&job
[2]->job
);
161 typedef struct CancelJob
{
164 bool should_converge
;
165 bool should_complete
;
168 static void cancel_job_complete(Job
*job
, Error
**errp
)
170 CancelJob
*s
= container_of(job
, CancelJob
, common
.job
);
171 s
->should_complete
= true;
174 static int coroutine_fn
cancel_job_run(Job
*job
, Error
**errp
)
176 CancelJob
*s
= container_of(job
, CancelJob
, common
.job
);
178 while (!s
->should_complete
) {
179 if (job_is_cancelled(&s
->common
.job
)) {
183 if (!job_is_ready(&s
->common
.job
) && s
->should_converge
) {
184 job_transition_to_ready(&s
->common
.job
);
187 job_sleep_ns(&s
->common
.job
, 100000);
193 static const BlockJobDriver test_cancel_driver
= {
195 .instance_size
= sizeof(CancelJob
),
196 .free
= block_job_free
,
197 .user_resume
= block_job_user_resume
,
198 .run
= cancel_job_run
,
199 .complete
= cancel_job_complete
,
203 static CancelJob
*create_common(Job
**pjob
)
210 blk
= create_blk(NULL
);
211 bjob
= mk_job(blk
, "Steve", &test_cancel_driver
, true,
212 JOB_MANUAL_FINALIZE
| JOB_MANUAL_DISMISS
);
214 WITH_JOB_LOCK_GUARD() {
216 assert(job
->status
== JOB_STATUS_CREATED
);
219 s
= container_of(bjob
, CancelJob
, common
);
226 static void cancel_common(CancelJob
*s
)
228 BlockJob
*job
= &s
->common
;
229 BlockBackend
*blk
= s
->blk
;
230 JobStatus sts
= job
->job
.status
;
232 job_cancel_sync(&job
->job
, true);
233 WITH_JOB_LOCK_GUARD() {
234 if (sts
!= JOB_STATUS_CREATED
&& sts
!= JOB_STATUS_CONCLUDED
) {
235 Job
*dummy
= &job
->job
;
236 job_dismiss_locked(&dummy
, &error_abort
);
238 assert(job
->job
.status
== JOB_STATUS_NULL
);
239 job_unref_locked(&job
->job
);
246 static void test_cancel_created(void)
251 s
= create_common(&job
);
255 static void assert_job_status_is(Job
*job
, int status
)
257 WITH_JOB_LOCK_GUARD() {
258 assert(job
->status
== status
);
262 static void test_cancel_running(void)
267 s
= create_common(&job
);
270 assert_job_status_is(job
, JOB_STATUS_RUNNING
);
275 static void test_cancel_paused(void)
280 s
= create_common(&job
);
283 WITH_JOB_LOCK_GUARD() {
284 assert(job
->status
== JOB_STATUS_RUNNING
);
285 job_user_pause_locked(job
, &error_abort
);
288 assert_job_status_is(job
, JOB_STATUS_PAUSED
);
293 static void test_cancel_ready(void)
298 s
= create_common(&job
);
301 assert_job_status_is(job
, JOB_STATUS_RUNNING
);
303 s
->should_converge
= true;
305 assert_job_status_is(job
, JOB_STATUS_READY
);
310 static void test_cancel_standby(void)
315 s
= create_common(&job
);
318 assert_job_status_is(job
, JOB_STATUS_RUNNING
);
320 s
->should_converge
= true;
322 WITH_JOB_LOCK_GUARD() {
323 assert(job
->status
== JOB_STATUS_READY
);
324 job_user_pause_locked(job
, &error_abort
);
327 assert_job_status_is(job
, JOB_STATUS_STANDBY
);
332 static void test_cancel_pending(void)
337 s
= create_common(&job
);
340 assert_job_status_is(job
, JOB_STATUS_RUNNING
);
342 s
->should_converge
= true;
344 WITH_JOB_LOCK_GUARD() {
345 assert(job
->status
== JOB_STATUS_READY
);
346 job_complete_locked(job
, &error_abort
);
349 while (!job
->deferred_to_main_loop
) {
350 aio_poll(qemu_get_aio_context(), true);
352 assert_job_status_is(job
, JOB_STATUS_READY
);
353 aio_poll(qemu_get_aio_context(), true);
354 assert_job_status_is(job
, JOB_STATUS_PENDING
);
359 static void test_cancel_concluded(void)
364 s
= create_common(&job
);
367 assert_job_status_is(job
, JOB_STATUS_RUNNING
);
369 s
->should_converge
= true;
371 WITH_JOB_LOCK_GUARD() {
372 assert(job
->status
== JOB_STATUS_READY
);
373 job_complete_locked(job
, &error_abort
);
376 while (!job
->deferred_to_main_loop
) {
377 aio_poll(qemu_get_aio_context(), true);
379 assert_job_status_is(job
, JOB_STATUS_READY
);
380 aio_poll(qemu_get_aio_context(), true);
381 assert_job_status_is(job
, JOB_STATUS_PENDING
);
383 WITH_JOB_LOCK_GUARD() {
384 job_finalize_locked(job
, &error_abort
);
385 assert(job
->status
== JOB_STATUS_CONCLUDED
);
391 int main(int argc
, char **argv
)
393 qemu_init_main_loop(&error_abort
);
396 g_test_init(&argc
, &argv
, NULL
);
397 g_test_add_func("/blockjob/ids", test_job_ids
);
398 g_test_add_func("/blockjob/cancel/created", test_cancel_created
);
399 g_test_add_func("/blockjob/cancel/running", test_cancel_running
);
400 g_test_add_func("/blockjob/cancel/paused", test_cancel_paused
);
401 g_test_add_func("/blockjob/cancel/ready", test_cancel_ready
);
402 g_test_add_func("/blockjob/cancel/standby", test_cancel_standby
);
403 g_test_add_func("/blockjob/cancel/pending", test_cancel_pending
);
404 g_test_add_func("/blockjob/cancel/concluded", test_cancel_concluded
);