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
,
26 static void block_job_cb(void *opaque
, int ret
)
30 static BlockJob
*mk_job(BlockBackend
*blk
, const char *id
,
31 const BlockJobDriver
*drv
, bool should_succeed
,
37 job
= block_job_create(id
, drv
, NULL
, blk_bs(blk
),
38 0, BLK_PERM_ALL
, 0, flags
, block_job_cb
,
42 g_assert_nonnull(job
);
44 g_assert_cmpstr(job
->job
.id
, ==, id
);
46 g_assert_cmpstr(job
->job
.id
, ==, blk_name(blk
));
49 g_assert_nonnull(errp
);
57 static BlockJob
*do_test_id(BlockBackend
*blk
, const char *id
,
60 return mk_job(blk
, id
, &test_block_job_driver
,
61 should_succeed
, BLOCK_JOB_DEFAULT
);
64 /* This creates a BlockBackend (optionally with a name) with a
65 * BlockDriverState inserted. */
66 static BlockBackend
*create_blk(const char *name
)
68 /* No I/O is performed on this device */
69 BlockBackend
*blk
= blk_new(0, BLK_PERM_ALL
);
72 bs
= bdrv_open("null-co://", NULL
, NULL
, 0, &error_abort
);
75 blk_insert_bs(blk
, bs
, &error_abort
);
80 monitor_add_blk(blk
, name
, &errp
);
87 /* This destroys the backend */
88 static void destroy_blk(BlockBackend
*blk
)
90 if (blk_name(blk
)[0] != '\0') {
91 monitor_remove_blk(blk
);
98 static void test_job_ids(void)
100 BlockBackend
*blk
[3];
103 blk
[0] = create_blk(NULL
);
104 blk
[1] = create_blk("drive1");
105 blk
[2] = create_blk("drive2");
107 /* No job ID provided and the block backend has no name */
108 job
[0] = do_test_id(blk
[0], NULL
, false);
110 /* These are all invalid job IDs */
111 job
[0] = do_test_id(blk
[0], "0id", false);
112 job
[0] = do_test_id(blk
[0], "", false);
113 job
[0] = do_test_id(blk
[0], " ", false);
114 job
[0] = do_test_id(blk
[0], "123", 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);
118 job
[0] = do_test_id(blk
[0], "#id", false);
120 /* This one is valid */
121 job
[0] = do_test_id(blk
[0], "id0", true);
123 /* We cannot have two jobs in the same BDS */
124 do_test_id(blk
[0], "id1", false);
126 /* Duplicate job IDs are not allowed */
127 job
[1] = do_test_id(blk
[1], "id0", false);
129 /* But once job[0] finishes we can reuse its ID */
130 block_job_early_fail(job
[0]);
131 job
[1] = do_test_id(blk
[1], "id0", true);
133 /* No job ID specified, defaults to the backend name ('drive1') */
134 block_job_early_fail(job
[1]);
135 job
[1] = do_test_id(blk
[1], NULL
, true);
137 /* Duplicate job ID */
138 job
[2] = do_test_id(blk
[2], "drive1", false);
140 /* The ID of job[2] would default to 'drive2' but it is already in use */
141 job
[0] = do_test_id(blk
[0], "drive2", true);
142 job
[2] = do_test_id(blk
[2], NULL
, false);
144 /* This one is valid */
145 job
[2] = do_test_id(blk
[2], "id_2", true);
147 block_job_early_fail(job
[0]);
148 block_job_early_fail(job
[1]);
149 block_job_early_fail(job
[2]);
156 typedef struct CancelJob
{
159 bool should_converge
;
160 bool should_complete
;
164 static void cancel_job_completed(Job
*job
, void *opaque
)
166 BlockJob
*bjob
= container_of(job
, BlockJob
, job
);
167 CancelJob
*s
= opaque
;
169 block_job_completed(bjob
, 0);
172 static void cancel_job_complete(BlockJob
*job
, Error
**errp
)
174 CancelJob
*s
= container_of(job
, CancelJob
, common
);
175 s
->should_complete
= true;
178 static void coroutine_fn
cancel_job_start(void *opaque
)
180 CancelJob
*s
= opaque
;
182 while (!s
->should_complete
) {
183 if (job_is_cancelled(&s
->common
.job
)) {
187 if (!s
->common
.ready
&& s
->should_converge
) {
188 block_job_event_ready(&s
->common
);
191 job_sleep_ns(&s
->common
.job
, 100000);
195 job_defer_to_main_loop(&s
->common
.job
, cancel_job_completed
, s
);
198 static const BlockJobDriver test_cancel_driver
= {
200 .instance_size
= sizeof(CancelJob
),
201 .free
= block_job_free
,
202 .start
= cancel_job_start
,
204 .complete
= cancel_job_complete
,
207 static CancelJob
*create_common(BlockJob
**pjob
)
213 blk
= create_blk(NULL
);
214 job
= mk_job(blk
, "Steve", &test_cancel_driver
, true,
215 BLOCK_JOB_MANUAL_FINALIZE
| BLOCK_JOB_MANUAL_DISMISS
);
217 assert(job
->job
.status
== JOB_STATUS_CREATED
);
218 s
= container_of(job
, CancelJob
, common
);
225 static void cancel_common(CancelJob
*s
)
227 BlockJob
*job
= &s
->common
;
228 BlockBackend
*blk
= s
->blk
;
229 JobStatus sts
= job
->job
.status
;
231 block_job_cancel_sync(job
);
232 if (sts
!= JOB_STATUS_CREATED
&& sts
!= JOB_STATUS_CONCLUDED
) {
233 BlockJob
*dummy
= job
;
234 block_job_dismiss(&dummy
, &error_abort
);
236 assert(job
->job
.status
== JOB_STATUS_NULL
);
237 job_unref(&job
->job
);
241 static void test_cancel_created(void)
246 s
= create_common(&job
);
250 static void test_cancel_running(void)
255 s
= create_common(&job
);
257 job_start(&job
->job
);
258 assert(job
->job
.status
== JOB_STATUS_RUNNING
);
263 static void test_cancel_paused(void)
268 s
= create_common(&job
);
270 job_start(&job
->job
);
271 assert(job
->job
.status
== JOB_STATUS_RUNNING
);
273 block_job_user_pause(job
, &error_abort
);
274 block_job_enter(job
);
275 assert(job
->job
.status
== JOB_STATUS_PAUSED
);
280 static void test_cancel_ready(void)
285 s
= create_common(&job
);
287 job_start(&job
->job
);
288 assert(job
->job
.status
== JOB_STATUS_RUNNING
);
290 s
->should_converge
= true;
291 block_job_enter(job
);
292 assert(job
->job
.status
== JOB_STATUS_READY
);
297 static void test_cancel_standby(void)
302 s
= create_common(&job
);
304 job_start(&job
->job
);
305 assert(job
->job
.status
== JOB_STATUS_RUNNING
);
307 s
->should_converge
= true;
308 block_job_enter(job
);
309 assert(job
->job
.status
== JOB_STATUS_READY
);
311 block_job_user_pause(job
, &error_abort
);
312 block_job_enter(job
);
313 assert(job
->job
.status
== JOB_STATUS_STANDBY
);
318 static void test_cancel_pending(void)
323 s
= create_common(&job
);
325 job_start(&job
->job
);
326 assert(job
->job
.status
== JOB_STATUS_RUNNING
);
328 s
->should_converge
= true;
329 block_job_enter(job
);
330 assert(job
->job
.status
== JOB_STATUS_READY
);
332 block_job_complete(job
, &error_abort
);
333 block_job_enter(job
);
334 while (!s
->completed
) {
335 aio_poll(qemu_get_aio_context(), true);
337 assert(job
->job
.status
== JOB_STATUS_PENDING
);
342 static void test_cancel_concluded(void)
347 s
= create_common(&job
);
349 job_start(&job
->job
);
350 assert(job
->job
.status
== JOB_STATUS_RUNNING
);
352 s
->should_converge
= true;
353 block_job_enter(job
);
354 assert(job
->job
.status
== JOB_STATUS_READY
);
356 block_job_complete(job
, &error_abort
);
357 block_job_enter(job
);
358 while (!s
->completed
) {
359 aio_poll(qemu_get_aio_context(), true);
361 assert(job
->job
.status
== JOB_STATUS_PENDING
);
363 block_job_finalize(job
, &error_abort
);
364 assert(job
->job
.status
== JOB_STATUS_CONCLUDED
);
369 int main(int argc
, char **argv
)
371 qemu_init_main_loop(&error_abort
);
374 g_test_init(&argc
, &argv
, NULL
);
375 g_test_add_func("/blockjob/ids", test_job_ids
);
376 g_test_add_func("/blockjob/cancel/created", test_cancel_created
);
377 g_test_add_func("/blockjob/cancel/running", test_cancel_running
);
378 g_test_add_func("/blockjob/cancel/paused", test_cancel_paused
);
379 g_test_add_func("/blockjob/cancel/ready", test_cancel_ready
);
380 g_test_add_func("/blockjob/cancel/standby", test_cancel_standby
);
381 g_test_add_func("/blockjob/cancel/pending", test_cancel_pending
);
382 g_test_add_func("/blockjob/cancel/concluded", test_cancel_concluded
);