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
),
25 static void block_job_cb(void *opaque
, int ret
)
29 static BlockJob
*mk_job(BlockBackend
*blk
, const char *id
,
30 const BlockJobDriver
*drv
, bool should_succeed
,
36 job
= block_job_create(id
, drv
, NULL
, blk_bs(blk
),
37 0, BLK_PERM_ALL
, 0, flags
, block_job_cb
,
41 g_assert_nonnull(job
);
43 g_assert_cmpstr(job
->job
.id
, ==, id
);
45 g_assert_cmpstr(job
->job
.id
, ==, blk_name(blk
));
48 g_assert_nonnull(errp
);
56 static BlockJob
*do_test_id(BlockBackend
*blk
, const char *id
,
59 return mk_job(blk
, id
, &test_block_job_driver
,
60 should_succeed
, BLOCK_JOB_DEFAULT
);
63 /* This creates a BlockBackend (optionally with a name) with a
64 * BlockDriverState inserted. */
65 static BlockBackend
*create_blk(const char *name
)
67 /* No I/O is performed on this device */
68 BlockBackend
*blk
= blk_new(0, BLK_PERM_ALL
);
71 bs
= bdrv_open("null-co://", NULL
, NULL
, 0, &error_abort
);
74 blk_insert_bs(blk
, bs
, &error_abort
);
79 monitor_add_blk(blk
, name
, &errp
);
86 /* This destroys the backend */
87 static void destroy_blk(BlockBackend
*blk
)
89 if (blk_name(blk
)[0] != '\0') {
90 monitor_remove_blk(blk
);
97 static void test_job_ids(void)
102 blk
[0] = create_blk(NULL
);
103 blk
[1] = create_blk("drive1");
104 blk
[2] = create_blk("drive2");
106 /* No job ID provided and the block backend has no name */
107 job
[0] = do_test_id(blk
[0], NULL
, false);
109 /* These are all invalid job IDs */
110 job
[0] = do_test_id(blk
[0], "0id", false);
111 job
[0] = do_test_id(blk
[0], "", false);
112 job
[0] = do_test_id(blk
[0], " ", false);
113 job
[0] = do_test_id(blk
[0], "123", false);
114 job
[0] = do_test_id(blk
[0], "_id", false);
115 job
[0] = do_test_id(blk
[0], "-id", false);
116 job
[0] = do_test_id(blk
[0], ".id", false);
117 job
[0] = do_test_id(blk
[0], "#id", false);
119 /* This one is valid */
120 job
[0] = do_test_id(blk
[0], "id0", true);
122 /* We cannot have two jobs in the same BDS */
123 do_test_id(blk
[0], "id1", false);
125 /* Duplicate job IDs are not allowed */
126 job
[1] = do_test_id(blk
[1], "id0", false);
128 /* But once job[0] finishes we can reuse its ID */
129 block_job_early_fail(job
[0]);
130 job
[1] = do_test_id(blk
[1], "id0", true);
132 /* No job ID specified, defaults to the backend name ('drive1') */
133 block_job_early_fail(job
[1]);
134 job
[1] = do_test_id(blk
[1], NULL
, true);
136 /* Duplicate job ID */
137 job
[2] = do_test_id(blk
[2], "drive1", false);
139 /* The ID of job[2] would default to 'drive2' but it is already in use */
140 job
[0] = do_test_id(blk
[0], "drive2", true);
141 job
[2] = do_test_id(blk
[2], NULL
, false);
143 /* This one is valid */
144 job
[2] = do_test_id(blk
[2], "id_2", true);
146 block_job_early_fail(job
[0]);
147 block_job_early_fail(job
[1]);
148 block_job_early_fail(job
[2]);
155 typedef struct CancelJob
{
158 bool should_converge
;
159 bool should_complete
;
163 static void cancel_job_completed(BlockJob
*job
, void *opaque
)
165 CancelJob
*s
= opaque
;
167 block_job_completed(job
, 0);
170 static void cancel_job_complete(BlockJob
*job
, Error
**errp
)
172 CancelJob
*s
= container_of(job
, CancelJob
, common
);
173 s
->should_complete
= true;
176 static void coroutine_fn
cancel_job_start(void *opaque
)
178 CancelJob
*s
= opaque
;
180 while (!s
->should_complete
) {
181 if (block_job_is_cancelled(&s
->common
)) {
185 if (!s
->common
.ready
&& s
->should_converge
) {
186 block_job_event_ready(&s
->common
);
189 block_job_sleep_ns(&s
->common
, 100000);
193 block_job_defer_to_main_loop(&s
->common
, cancel_job_completed
, s
);
196 static const BlockJobDriver test_cancel_driver
= {
198 .instance_size
= sizeof(CancelJob
),
200 .start
= cancel_job_start
,
201 .complete
= cancel_job_complete
,
204 static CancelJob
*create_common(BlockJob
**pjob
)
210 blk
= create_blk(NULL
);
211 job
= mk_job(blk
, "Steve", &test_cancel_driver
, true,
212 BLOCK_JOB_MANUAL_FINALIZE
| BLOCK_JOB_MANUAL_DISMISS
);
214 assert(job
->job
.status
== JOB_STATUS_CREATED
);
215 s
= container_of(job
, CancelJob
, common
);
222 static void cancel_common(CancelJob
*s
)
224 BlockJob
*job
= &s
->common
;
225 BlockBackend
*blk
= s
->blk
;
226 JobStatus sts
= job
->job
.status
;
228 block_job_cancel_sync(job
);
229 if (sts
!= JOB_STATUS_CREATED
&& sts
!= JOB_STATUS_CONCLUDED
) {
230 BlockJob
*dummy
= job
;
231 block_job_dismiss(&dummy
, &error_abort
);
233 assert(job
->job
.status
== JOB_STATUS_NULL
);
234 block_job_unref(job
);
238 static void test_cancel_created(void)
243 s
= create_common(&job
);
247 static void test_cancel_running(void)
252 s
= create_common(&job
);
254 block_job_start(job
);
255 assert(job
->job
.status
== JOB_STATUS_RUNNING
);
260 static void test_cancel_paused(void)
265 s
= create_common(&job
);
267 block_job_start(job
);
268 assert(job
->job
.status
== JOB_STATUS_RUNNING
);
270 block_job_user_pause(job
, &error_abort
);
271 block_job_enter(job
);
272 assert(job
->job
.status
== JOB_STATUS_PAUSED
);
277 static void test_cancel_ready(void)
282 s
= create_common(&job
);
284 block_job_start(job
);
285 assert(job
->job
.status
== JOB_STATUS_RUNNING
);
287 s
->should_converge
= true;
288 block_job_enter(job
);
289 assert(job
->job
.status
== JOB_STATUS_READY
);
294 static void test_cancel_standby(void)
299 s
= create_common(&job
);
301 block_job_start(job
);
302 assert(job
->job
.status
== JOB_STATUS_RUNNING
);
304 s
->should_converge
= true;
305 block_job_enter(job
);
306 assert(job
->job
.status
== JOB_STATUS_READY
);
308 block_job_user_pause(job
, &error_abort
);
309 block_job_enter(job
);
310 assert(job
->job
.status
== JOB_STATUS_STANDBY
);
315 static void test_cancel_pending(void)
320 s
= create_common(&job
);
322 block_job_start(job
);
323 assert(job
->job
.status
== JOB_STATUS_RUNNING
);
325 s
->should_converge
= true;
326 block_job_enter(job
);
327 assert(job
->job
.status
== JOB_STATUS_READY
);
329 block_job_complete(job
, &error_abort
);
330 block_job_enter(job
);
331 while (!s
->completed
) {
332 aio_poll(qemu_get_aio_context(), true);
334 assert(job
->job
.status
== JOB_STATUS_PENDING
);
339 static void test_cancel_concluded(void)
344 s
= create_common(&job
);
346 block_job_start(job
);
347 assert(job
->job
.status
== JOB_STATUS_RUNNING
);
349 s
->should_converge
= true;
350 block_job_enter(job
);
351 assert(job
->job
.status
== JOB_STATUS_READY
);
353 block_job_complete(job
, &error_abort
);
354 block_job_enter(job
);
355 while (!s
->completed
) {
356 aio_poll(qemu_get_aio_context(), true);
358 assert(job
->job
.status
== JOB_STATUS_PENDING
);
360 block_job_finalize(job
, &error_abort
);
361 assert(job
->job
.status
== JOB_STATUS_CONCLUDED
);
366 int main(int argc
, char **argv
)
368 qemu_init_main_loop(&error_abort
);
371 g_test_init(&argc
, &argv
, NULL
);
372 g_test_add_func("/blockjob/ids", test_job_ids
);
373 g_test_add_func("/blockjob/cancel/created", test_cancel_created
);
374 g_test_add_func("/blockjob/cancel/running", test_cancel_running
);
375 g_test_add_func("/blockjob/cancel/paused", test_cancel_paused
);
376 g_test_add_func("/blockjob/cancel/ready", test_cancel_ready
);
377 g_test_add_func("/blockjob/cancel/standby", test_cancel_standby
);
378 g_test_add_func("/blockjob/cancel/pending", test_cancel_pending
);
379 g_test_add_func("/blockjob/cancel/concluded", test_cancel_concluded
);