nbd/client: Work around 3.0 bug for listing meta contexts
[qemu/ar7.git] / tests / test-blockjob.c
blob652d1e83598fc6a381bfc21d6f2c0b8d424f3eda
1 /*
2 * Blockjob tests
4 * Copyright Igalia, S.L. 2016
6 * Authors:
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 = {
20 .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,
34 int flags)
36 BlockJob *job;
37 Error *errp = NULL;
39 job = block_job_create(id, drv, NULL, blk_bs(blk),
40 0, BLK_PERM_ALL, 0, flags, block_job_cb,
41 NULL, &errp);
42 if (should_succeed) {
43 g_assert_null(errp);
44 g_assert_nonnull(job);
45 if (id) {
46 g_assert_cmpstr(job->job.id, ==, id);
47 } else {
48 g_assert_cmpstr(job->job.id, ==, blk_name(blk));
50 } else {
51 g_assert_nonnull(errp);
52 g_assert_null(job);
53 error_free(errp);
56 return job;
59 static BlockJob *do_test_id(BlockBackend *blk, const char *id,
60 bool should_succeed)
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);
72 BlockDriverState *bs;
74 bs = bdrv_open("null-co://", NULL, NULL, 0, &error_abort);
75 g_assert_nonnull(bs);
77 blk_insert_bs(blk, bs, &error_abort);
78 bdrv_unref(bs);
80 if (name) {
81 Error *errp = NULL;
82 monitor_add_blk(blk, name, &errp);
83 g_assert_null(errp);
86 return blk;
89 /* This destroys the backend */
90 static void destroy_blk(BlockBackend *blk)
92 if (blk_name(blk)[0] != '\0') {
93 monitor_remove_blk(blk);
96 blk_remove_bs(blk);
97 blk_unref(blk);
100 static void test_job_ids(void)
102 BlockBackend *blk[3];
103 BlockJob *job[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);
153 destroy_blk(blk[0]);
154 destroy_blk(blk[1]);
155 destroy_blk(blk[2]);
158 typedef struct CancelJob {
159 BlockJob common;
160 BlockBackend *blk;
161 bool should_converge;
162 bool should_complete;
163 } CancelJob;
165 static void cancel_job_complete(Job *job, Error **errp)
167 CancelJob *s = container_of(job, CancelJob, common.job);
168 s->should_complete = true;
171 static int coroutine_fn cancel_job_run(Job *job, Error **errp)
173 CancelJob *s = container_of(job, CancelJob, common.job);
175 while (!s->should_complete) {
176 if (job_is_cancelled(&s->common.job)) {
177 return 0;
180 if (!job_is_ready(&s->common.job) && s->should_converge) {
181 job_transition_to_ready(&s->common.job);
184 job_sleep_ns(&s->common.job, 100000);
187 return 0;
190 static const BlockJobDriver test_cancel_driver = {
191 .job_driver = {
192 .instance_size = sizeof(CancelJob),
193 .free = block_job_free,
194 .user_resume = block_job_user_resume,
195 .drain = block_job_drain,
196 .run = cancel_job_run,
197 .complete = cancel_job_complete,
201 static CancelJob *create_common(Job **pjob)
203 BlockBackend *blk;
204 Job *job;
205 BlockJob *bjob;
206 CancelJob *s;
208 blk = create_blk(NULL);
209 bjob = mk_job(blk, "Steve", &test_cancel_driver, true,
210 JOB_MANUAL_FINALIZE | JOB_MANUAL_DISMISS);
211 job = &bjob->job;
212 job_ref(job);
213 assert(job->status == JOB_STATUS_CREATED);
214 s = container_of(bjob, CancelJob, common);
215 s->blk = blk;
217 *pjob = job;
218 return s;
221 static void cancel_common(CancelJob *s)
223 BlockJob *job = &s->common;
224 BlockBackend *blk = s->blk;
225 JobStatus sts = job->job.status;
226 AioContext *ctx;
228 ctx = job->job.aio_context;
229 aio_context_acquire(ctx);
231 job_cancel_sync(&job->job);
232 if (sts != JOB_STATUS_CREATED && sts != JOB_STATUS_CONCLUDED) {
233 Job *dummy = &job->job;
234 job_dismiss(&dummy, &error_abort);
236 assert(job->job.status == JOB_STATUS_NULL);
237 job_unref(&job->job);
238 destroy_blk(blk);
240 aio_context_release(ctx);
243 static void test_cancel_created(void)
245 Job *job;
246 CancelJob *s;
248 s = create_common(&job);
249 cancel_common(s);
252 static void test_cancel_running(void)
254 Job *job;
255 CancelJob *s;
257 s = create_common(&job);
259 job_start(job);
260 assert(job->status == JOB_STATUS_RUNNING);
262 cancel_common(s);
265 static void test_cancel_paused(void)
267 Job *job;
268 CancelJob *s;
270 s = create_common(&job);
272 job_start(job);
273 assert(job->status == JOB_STATUS_RUNNING);
275 job_user_pause(job, &error_abort);
276 job_enter(job);
277 assert(job->status == JOB_STATUS_PAUSED);
279 cancel_common(s);
282 static void test_cancel_ready(void)
284 Job *job;
285 CancelJob *s;
287 s = create_common(&job);
289 job_start(job);
290 assert(job->status == JOB_STATUS_RUNNING);
292 s->should_converge = true;
293 job_enter(job);
294 assert(job->status == JOB_STATUS_READY);
296 cancel_common(s);
299 static void test_cancel_standby(void)
301 Job *job;
302 CancelJob *s;
304 s = create_common(&job);
306 job_start(job);
307 assert(job->status == JOB_STATUS_RUNNING);
309 s->should_converge = true;
310 job_enter(job);
311 assert(job->status == JOB_STATUS_READY);
313 job_user_pause(job, &error_abort);
314 job_enter(job);
315 assert(job->status == JOB_STATUS_STANDBY);
317 cancel_common(s);
320 static void test_cancel_pending(void)
322 Job *job;
323 CancelJob *s;
325 s = create_common(&job);
327 job_start(job);
328 assert(job->status == JOB_STATUS_RUNNING);
330 s->should_converge = true;
331 job_enter(job);
332 assert(job->status == JOB_STATUS_READY);
334 job_complete(job, &error_abort);
335 job_enter(job);
336 while (!job->deferred_to_main_loop) {
337 aio_poll(qemu_get_aio_context(), true);
339 assert(job->status == JOB_STATUS_READY);
340 aio_poll(qemu_get_aio_context(), true);
341 assert(job->status == JOB_STATUS_PENDING);
343 cancel_common(s);
346 static void test_cancel_concluded(void)
348 Job *job;
349 CancelJob *s;
351 s = create_common(&job);
353 job_start(job);
354 assert(job->status == JOB_STATUS_RUNNING);
356 s->should_converge = true;
357 job_enter(job);
358 assert(job->status == JOB_STATUS_READY);
360 job_complete(job, &error_abort);
361 job_enter(job);
362 while (!job->deferred_to_main_loop) {
363 aio_poll(qemu_get_aio_context(), true);
365 assert(job->status == JOB_STATUS_READY);
366 aio_poll(qemu_get_aio_context(), true);
367 assert(job->status == JOB_STATUS_PENDING);
369 job_finalize(job, &error_abort);
370 assert(job->status == JOB_STATUS_CONCLUDED);
372 cancel_common(s);
375 int main(int argc, char **argv)
377 qemu_init_main_loop(&error_abort);
378 bdrv_init();
380 g_test_init(&argc, &argv, NULL);
381 g_test_add_func("/blockjob/ids", test_job_ids);
382 g_test_add_func("/blockjob/cancel/created", test_cancel_created);
383 g_test_add_func("/blockjob/cancel/running", test_cancel_running);
384 g_test_add_func("/blockjob/cancel/paused", test_cancel_paused);
385 g_test_add_func("/blockjob/cancel/ready", test_cancel_ready);
386 g_test_add_func("/blockjob/cancel/standby", test_cancel_standby);
387 g_test_add_func("/blockjob/cancel/pending", test_cancel_pending);
388 g_test_add_func("/blockjob/cancel/concluded", test_cancel_concluded);
389 return g_test_run();