]>
Commit | Line | Data |
---|---|---|
9ef8112a AG |
1 | /* |
2 | * Blockjob tests | |
3 | * | |
4 | * Copyright Igalia, S.L. 2016 | |
5 | * | |
6 | * Authors: | |
7 | * Alberto Garcia <berto@igalia.com> | |
8 | * | |
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. | |
11 | */ | |
12 | ||
13 | #include "qemu/osdep.h" | |
14 | #include "qapi/error.h" | |
15 | #include "qemu/main-loop.h" | |
c87621ea | 16 | #include "block/blockjob_int.h" |
9ef8112a AG |
17 | #include "sysemu/block-backend.h" |
18 | ||
19 | static const BlockJobDriver test_block_job_driver = { | |
33e9e9bd KW |
20 | .job_driver = { |
21 | .instance_size = sizeof(BlockJob), | |
22 | }, | |
9ef8112a AG |
23 | }; |
24 | ||
25 | static void block_job_cb(void *opaque, int ret) | |
26 | { | |
27 | } | |
28 | ||
fb367e03 JS |
29 | static BlockJob *mk_job(BlockBackend *blk, const char *id, |
30 | const BlockJobDriver *drv, bool should_succeed, | |
31 | int flags) | |
9ef8112a AG |
32 | { |
33 | BlockJob *job; | |
34 | Error *errp = NULL; | |
35 | ||
fb367e03 JS |
36 | job = block_job_create(id, drv, NULL, blk_bs(blk), |
37 | 0, BLK_PERM_ALL, 0, flags, block_job_cb, | |
c6cc12bf | 38 | NULL, &errp); |
9ef8112a AG |
39 | if (should_succeed) { |
40 | g_assert_null(errp); | |
41 | g_assert_nonnull(job); | |
42 | if (id) { | |
33e9e9bd | 43 | g_assert_cmpstr(job->job.id, ==, id); |
9ef8112a | 44 | } else { |
33e9e9bd | 45 | g_assert_cmpstr(job->job.id, ==, blk_name(blk)); |
9ef8112a AG |
46 | } |
47 | } else { | |
48 | g_assert_nonnull(errp); | |
49 | g_assert_null(job); | |
50 | error_free(errp); | |
51 | } | |
52 | ||
53 | return job; | |
54 | } | |
55 | ||
fb367e03 JS |
56 | static BlockJob *do_test_id(BlockBackend *blk, const char *id, |
57 | bool should_succeed) | |
58 | { | |
59 | return mk_job(blk, id, &test_block_job_driver, | |
60 | should_succeed, BLOCK_JOB_DEFAULT); | |
61 | } | |
62 | ||
9ef8112a AG |
63 | /* This creates a BlockBackend (optionally with a name) with a |
64 | * BlockDriverState inserted. */ | |
65 | static BlockBackend *create_blk(const char *name) | |
66 | { | |
2807c0cd | 67 | /* No I/O is performed on this device */ |
6d0eb64d | 68 | BlockBackend *blk = blk_new(0, BLK_PERM_ALL); |
d185cf0e KW |
69 | BlockDriverState *bs; |
70 | ||
71 | bs = bdrv_open("null-co://", NULL, NULL, 0, &error_abort); | |
72 | g_assert_nonnull(bs); | |
9ef8112a | 73 | |
d7086422 | 74 | blk_insert_bs(blk, bs, &error_abort); |
9ef8112a AG |
75 | bdrv_unref(bs); |
76 | ||
77 | if (name) { | |
78 | Error *errp = NULL; | |
79 | monitor_add_blk(blk, name, &errp); | |
80 | g_assert_null(errp); | |
81 | } | |
82 | ||
83 | return blk; | |
84 | } | |
85 | ||
86 | /* This destroys the backend */ | |
87 | static void destroy_blk(BlockBackend *blk) | |
88 | { | |
89 | if (blk_name(blk)[0] != '\0') { | |
90 | monitor_remove_blk(blk); | |
91 | } | |
92 | ||
93 | blk_remove_bs(blk); | |
94 | blk_unref(blk); | |
95 | } | |
96 | ||
97 | static void test_job_ids(void) | |
98 | { | |
99 | BlockBackend *blk[3]; | |
100 | BlockJob *job[3]; | |
101 | ||
102 | blk[0] = create_blk(NULL); | |
103 | blk[1] = create_blk("drive1"); | |
104 | blk[2] = create_blk("drive2"); | |
105 | ||
106 | /* No job ID provided and the block backend has no name */ | |
107 | job[0] = do_test_id(blk[0], NULL, false); | |
108 | ||
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); | |
118 | ||
119 | /* This one is valid */ | |
120 | job[0] = do_test_id(blk[0], "id0", true); | |
121 | ||
122 | /* We cannot have two jobs in the same BDS */ | |
123 | do_test_id(blk[0], "id1", false); | |
124 | ||
125 | /* Duplicate job IDs are not allowed */ | |
126 | job[1] = do_test_id(blk[1], "id0", false); | |
127 | ||
128 | /* But once job[0] finishes we can reuse its ID */ | |
05b0d8e3 | 129 | block_job_early_fail(job[0]); |
9ef8112a AG |
130 | job[1] = do_test_id(blk[1], "id0", true); |
131 | ||
132 | /* No job ID specified, defaults to the backend name ('drive1') */ | |
05b0d8e3 | 133 | block_job_early_fail(job[1]); |
9ef8112a AG |
134 | job[1] = do_test_id(blk[1], NULL, true); |
135 | ||
136 | /* Duplicate job ID */ | |
137 | job[2] = do_test_id(blk[2], "drive1", false); | |
138 | ||
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); | |
142 | ||
143 | /* This one is valid */ | |
144 | job[2] = do_test_id(blk[2], "id_2", true); | |
145 | ||
05b0d8e3 PB |
146 | block_job_early_fail(job[0]); |
147 | block_job_early_fail(job[1]); | |
148 | block_job_early_fail(job[2]); | |
9ef8112a AG |
149 | |
150 | destroy_blk(blk[0]); | |
151 | destroy_blk(blk[1]); | |
152 | destroy_blk(blk[2]); | |
153 | } | |
154 | ||
fb367e03 JS |
155 | typedef struct CancelJob { |
156 | BlockJob common; | |
157 | BlockBackend *blk; | |
158 | bool should_converge; | |
159 | bool should_complete; | |
160 | bool completed; | |
161 | } CancelJob; | |
162 | ||
163 | static void cancel_job_completed(BlockJob *job, void *opaque) | |
164 | { | |
165 | CancelJob *s = opaque; | |
166 | s->completed = true; | |
167 | block_job_completed(job, 0); | |
168 | } | |
169 | ||
170 | static void cancel_job_complete(BlockJob *job, Error **errp) | |
171 | { | |
172 | CancelJob *s = container_of(job, CancelJob, common); | |
173 | s->should_complete = true; | |
174 | } | |
175 | ||
176 | static void coroutine_fn cancel_job_start(void *opaque) | |
177 | { | |
178 | CancelJob *s = opaque; | |
179 | ||
180 | while (!s->should_complete) { | |
181 | if (block_job_is_cancelled(&s->common)) { | |
182 | goto defer; | |
183 | } | |
184 | ||
185 | if (!s->common.ready && s->should_converge) { | |
186 | block_job_event_ready(&s->common); | |
187 | } | |
188 | ||
189 | block_job_sleep_ns(&s->common, 100000); | |
190 | } | |
191 | ||
192 | defer: | |
193 | block_job_defer_to_main_loop(&s->common, cancel_job_completed, s); | |
194 | } | |
195 | ||
196 | static const BlockJobDriver test_cancel_driver = { | |
33e9e9bd KW |
197 | .job_driver = { |
198 | .instance_size = sizeof(CancelJob), | |
199 | }, | |
fb367e03 JS |
200 | .start = cancel_job_start, |
201 | .complete = cancel_job_complete, | |
202 | }; | |
203 | ||
204 | static CancelJob *create_common(BlockJob **pjob) | |
205 | { | |
206 | BlockBackend *blk; | |
207 | BlockJob *job; | |
208 | CancelJob *s; | |
209 | ||
210 | blk = create_blk(NULL); | |
211 | job = mk_job(blk, "Steve", &test_cancel_driver, true, | |
212 | BLOCK_JOB_MANUAL_FINALIZE | BLOCK_JOB_MANUAL_DISMISS); | |
213 | block_job_ref(job); | |
a50c2ab8 | 214 | assert(job->job.status == JOB_STATUS_CREATED); |
fb367e03 JS |
215 | s = container_of(job, CancelJob, common); |
216 | s->blk = blk; | |
217 | ||
218 | *pjob = job; | |
219 | return s; | |
220 | } | |
221 | ||
222 | static void cancel_common(CancelJob *s) | |
223 | { | |
224 | BlockJob *job = &s->common; | |
225 | BlockBackend *blk = s->blk; | |
a50c2ab8 | 226 | JobStatus sts = job->job.status; |
fb367e03 JS |
227 | |
228 | block_job_cancel_sync(job); | |
a50c2ab8 | 229 | if (sts != JOB_STATUS_CREATED && sts != JOB_STATUS_CONCLUDED) { |
fb367e03 JS |
230 | BlockJob *dummy = job; |
231 | block_job_dismiss(&dummy, &error_abort); | |
232 | } | |
a50c2ab8 | 233 | assert(job->job.status == JOB_STATUS_NULL); |
fb367e03 JS |
234 | block_job_unref(job); |
235 | destroy_blk(blk); | |
236 | } | |
237 | ||
238 | static void test_cancel_created(void) | |
239 | { | |
240 | BlockJob *job; | |
241 | CancelJob *s; | |
242 | ||
243 | s = create_common(&job); | |
244 | cancel_common(s); | |
245 | } | |
246 | ||
247 | static void test_cancel_running(void) | |
248 | { | |
249 | BlockJob *job; | |
250 | CancelJob *s; | |
251 | ||
252 | s = create_common(&job); | |
253 | ||
254 | block_job_start(job); | |
a50c2ab8 | 255 | assert(job->job.status == JOB_STATUS_RUNNING); |
fb367e03 JS |
256 | |
257 | cancel_common(s); | |
258 | } | |
259 | ||
260 | static void test_cancel_paused(void) | |
261 | { | |
262 | BlockJob *job; | |
263 | CancelJob *s; | |
264 | ||
265 | s = create_common(&job); | |
266 | ||
267 | block_job_start(job); | |
a50c2ab8 | 268 | assert(job->job.status == JOB_STATUS_RUNNING); |
fb367e03 JS |
269 | |
270 | block_job_user_pause(job, &error_abort); | |
271 | block_job_enter(job); | |
a50c2ab8 | 272 | assert(job->job.status == JOB_STATUS_PAUSED); |
fb367e03 JS |
273 | |
274 | cancel_common(s); | |
275 | } | |
276 | ||
277 | static void test_cancel_ready(void) | |
278 | { | |
279 | BlockJob *job; | |
280 | CancelJob *s; | |
281 | ||
282 | s = create_common(&job); | |
283 | ||
284 | block_job_start(job); | |
a50c2ab8 | 285 | assert(job->job.status == JOB_STATUS_RUNNING); |
fb367e03 JS |
286 | |
287 | s->should_converge = true; | |
288 | block_job_enter(job); | |
a50c2ab8 | 289 | assert(job->job.status == JOB_STATUS_READY); |
fb367e03 JS |
290 | |
291 | cancel_common(s); | |
292 | } | |
293 | ||
294 | static void test_cancel_standby(void) | |
295 | { | |
296 | BlockJob *job; | |
297 | CancelJob *s; | |
298 | ||
299 | s = create_common(&job); | |
300 | ||
301 | block_job_start(job); | |
a50c2ab8 | 302 | assert(job->job.status == JOB_STATUS_RUNNING); |
fb367e03 JS |
303 | |
304 | s->should_converge = true; | |
305 | block_job_enter(job); | |
a50c2ab8 | 306 | assert(job->job.status == JOB_STATUS_READY); |
fb367e03 JS |
307 | |
308 | block_job_user_pause(job, &error_abort); | |
309 | block_job_enter(job); | |
a50c2ab8 | 310 | assert(job->job.status == JOB_STATUS_STANDBY); |
fb367e03 JS |
311 | |
312 | cancel_common(s); | |
313 | } | |
314 | ||
315 | static void test_cancel_pending(void) | |
316 | { | |
317 | BlockJob *job; | |
318 | CancelJob *s; | |
319 | ||
320 | s = create_common(&job); | |
321 | ||
322 | block_job_start(job); | |
a50c2ab8 | 323 | assert(job->job.status == JOB_STATUS_RUNNING); |
fb367e03 JS |
324 | |
325 | s->should_converge = true; | |
326 | block_job_enter(job); | |
a50c2ab8 | 327 | assert(job->job.status == JOB_STATUS_READY); |
fb367e03 JS |
328 | |
329 | block_job_complete(job, &error_abort); | |
330 | block_job_enter(job); | |
331 | while (!s->completed) { | |
332 | aio_poll(qemu_get_aio_context(), true); | |
333 | } | |
a50c2ab8 | 334 | assert(job->job.status == JOB_STATUS_PENDING); |
fb367e03 JS |
335 | |
336 | cancel_common(s); | |
337 | } | |
338 | ||
339 | static void test_cancel_concluded(void) | |
340 | { | |
341 | BlockJob *job; | |
342 | CancelJob *s; | |
343 | ||
344 | s = create_common(&job); | |
345 | ||
346 | block_job_start(job); | |
a50c2ab8 | 347 | assert(job->job.status == JOB_STATUS_RUNNING); |
fb367e03 JS |
348 | |
349 | s->should_converge = true; | |
350 | block_job_enter(job); | |
a50c2ab8 | 351 | assert(job->job.status == JOB_STATUS_READY); |
fb367e03 JS |
352 | |
353 | block_job_complete(job, &error_abort); | |
354 | block_job_enter(job); | |
355 | while (!s->completed) { | |
356 | aio_poll(qemu_get_aio_context(), true); | |
357 | } | |
a50c2ab8 | 358 | assert(job->job.status == JOB_STATUS_PENDING); |
fb367e03 JS |
359 | |
360 | block_job_finalize(job, &error_abort); | |
a50c2ab8 | 361 | assert(job->job.status == JOB_STATUS_CONCLUDED); |
fb367e03 JS |
362 | |
363 | cancel_common(s); | |
364 | } | |
365 | ||
9ef8112a AG |
366 | int main(int argc, char **argv) |
367 | { | |
368 | qemu_init_main_loop(&error_abort); | |
d185cf0e | 369 | bdrv_init(); |
9ef8112a AG |
370 | |
371 | g_test_init(&argc, &argv, NULL); | |
372 | g_test_add_func("/blockjob/ids", test_job_ids); | |
fb367e03 JS |
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); | |
9ef8112a AG |
380 | return g_test_run(); |
381 | } |