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
,
27 static void block_job_cb(void *opaque
, int ret
)
31 static BlockJob
*mk_job(BlockBackend
*blk
, const char *id
,
32 const BlockJobDriver
*drv
, bool should_succeed
,
38 job
= block_job_create(id
, drv
, NULL
, blk_bs(blk
),
39 0, BLK_PERM_ALL
, 0, flags
, block_job_cb
,
43 g_assert_nonnull(job
);
45 g_assert_cmpstr(job
->job
.id
, ==, id
);
47 g_assert_cmpstr(job
->job
.id
, ==, blk_name(blk
));
50 g_assert_nonnull(errp
);
58 static BlockJob
*do_test_id(BlockBackend
*blk
, const char *id
,
61 return mk_job(blk
, id
, &test_block_job_driver
,
62 should_succeed
, JOB_DEFAULT
);
65 /* This creates a BlockBackend (optionally with a name) with a
66 * BlockDriverState inserted. */
67 static BlockBackend
*create_blk(const char *name
)
69 /* No I/O is performed on this device */
70 BlockBackend
*blk
= blk_new(0, BLK_PERM_ALL
);
73 bs
= bdrv_open("null-co://", NULL
, NULL
, 0, &error_abort
);
76 blk_insert_bs(blk
, bs
, &error_abort
);
81 monitor_add_blk(blk
, name
, &errp
);
88 /* This destroys the backend */
89 static void destroy_blk(BlockBackend
*blk
)
91 if (blk_name(blk
)[0] != '\0') {
92 monitor_remove_blk(blk
);
99 static void test_job_ids(void)
101 BlockBackend
*blk
[3];
104 blk
[0] = create_blk(NULL
);
105 blk
[1] = create_blk("drive1");
106 blk
[2] = create_blk("drive2");
108 /* No job ID provided and the block backend has no name */
109 job
[0] = do_test_id(blk
[0], NULL
, false);
111 /* These are all invalid job IDs */
112 job
[0] = do_test_id(blk
[0], "0id", false);
113 job
[0] = do_test_id(blk
[0], "", false);
114 job
[0] = do_test_id(blk
[0], " ", false);
115 job
[0] = do_test_id(blk
[0], "123", false);
116 job
[0] = do_test_id(blk
[0], "_id", 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);
121 /* This one is valid */
122 job
[0] = do_test_id(blk
[0], "id0", true);
124 /* We cannot have two jobs in the same BDS */
125 do_test_id(blk
[0], "id1", false);
127 /* Duplicate job IDs are not allowed */
128 job
[1] = do_test_id(blk
[1], "id0", false);
130 /* But once job[0] finishes we can reuse its ID */
131 job_early_fail(&job
[0]->job
);
132 job
[1] = do_test_id(blk
[1], "id0", true);
134 /* No job ID specified, defaults to the backend name ('drive1') */
135 job_early_fail(&job
[1]->job
);
136 job
[1] = do_test_id(blk
[1], NULL
, true);
138 /* Duplicate job ID */
139 job
[2] = do_test_id(blk
[2], "drive1", false);
141 /* The ID of job[2] would default to 'drive2' but it is already in use */
142 job
[0] = do_test_id(blk
[0], "drive2", true);
143 job
[2] = do_test_id(blk
[2], NULL
, false);
145 /* This one is valid */
146 job
[2] = do_test_id(blk
[2], "id_2", true);
148 job_early_fail(&job
[0]->job
);
149 job_early_fail(&job
[1]->job
);
150 job_early_fail(&job
[2]->job
);
157 typedef struct CancelJob
{
160 bool should_converge
;
161 bool should_complete
;
165 static void cancel_job_completed(Job
*job
, void *opaque
)
167 BlockJob
*bjob
= container_of(job
, BlockJob
, job
);
168 CancelJob
*s
= opaque
;
170 block_job_completed(bjob
, 0);
173 static void cancel_job_complete(BlockJob
*job
, Error
**errp
)
175 CancelJob
*s
= container_of(job
, CancelJob
, common
);
176 s
->should_complete
= true;
179 static void coroutine_fn
cancel_job_start(void *opaque
)
181 CancelJob
*s
= opaque
;
183 while (!s
->should_complete
) {
184 if (job_is_cancelled(&s
->common
.job
)) {
188 if (!s
->common
.ready
&& s
->should_converge
) {
189 block_job_event_ready(&s
->common
);
192 job_sleep_ns(&s
->common
.job
, 100000);
196 job_defer_to_main_loop(&s
->common
.job
, cancel_job_completed
, s
);
199 static const BlockJobDriver test_cancel_driver
= {
201 .instance_size
= sizeof(CancelJob
),
202 .free
= block_job_free
,
203 .user_resume
= block_job_user_resume
,
204 .start
= cancel_job_start
,
206 .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 block_job_cancel_sync(job
);
234 if (sts
!= JOB_STATUS_CREATED
&& sts
!= JOB_STATUS_CONCLUDED
) {
235 BlockJob
*dummy
= job
;
236 block_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 block_job_enter(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 block_job_enter(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 block_job_enter(job
);
311 assert(job
->job
.status
== JOB_STATUS_READY
);
313 job_user_pause(&job
->job
, &error_abort
);
314 block_job_enter(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 block_job_enter(job
);
332 assert(job
->job
.status
== JOB_STATUS_READY
);
334 block_job_complete(job
, &error_abort
);
335 block_job_enter(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 block_job_enter(job
);
356 assert(job
->job
.status
== JOB_STATUS_READY
);
358 block_job_complete(job
, &error_abort
);
359 block_job_enter(job
);
360 while (!s
->completed
) {
361 aio_poll(qemu_get_aio_context(), true);
363 assert(job
->job
.status
== JOB_STATUS_PENDING
);
365 block_job_finalize(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
);