block: Rename raw-{posix,win32} to file-*.c
[qemu.git] / blockjob.c
1 /*
2 * QEMU System Emulator block driver
3 *
4 * Copyright (c) 2011 IBM Corp.
5 * Copyright (c) 2012 Red Hat, Inc.
6 *
7 * Permission is hereby granted, free of charge, to any person obtaining a copy
8 * of this software and associated documentation files (the "Software"), to deal
9 * in the Software without restriction, including without limitation the rights
10 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11 * copies of the Software, and to permit persons to whom the Software is
12 * furnished to do so, subject to the following conditions:
13 *
14 * The above copyright notice and this permission notice shall be included in
15 * all copies or substantial portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
23 * THE SOFTWARE.
24 */
25
26 #include "qemu/osdep.h"
27 #include "qemu-common.h"
28 #include "trace.h"
29 #include "block/block.h"
30 #include "block/blockjob_int.h"
31 #include "block/block_int.h"
32 #include "sysemu/block-backend.h"
33 #include "qapi/qmp/qerror.h"
34 #include "qapi/qmp/qjson.h"
35 #include "qemu/coroutine.h"
36 #include "qemu/id.h"
37 #include "qmp-commands.h"
38 #include "qemu/timer.h"
39 #include "qapi-event.h"
40
41 static void block_job_event_cancelled(BlockJob *job);
42 static void block_job_event_completed(BlockJob *job, const char *msg);
43
44 /* Transactional group of block jobs */
45 struct BlockJobTxn {
46
47 /* Is this txn being cancelled? */
48 bool aborting;
49
50 /* List of jobs */
51 QLIST_HEAD(, BlockJob) jobs;
52
53 /* Reference count */
54 int refcnt;
55 };
56
57 static QLIST_HEAD(, BlockJob) block_jobs = QLIST_HEAD_INITIALIZER(block_jobs);
58
59 BlockJob *block_job_next(BlockJob *job)
60 {
61 if (!job) {
62 return QLIST_FIRST(&block_jobs);
63 }
64 return QLIST_NEXT(job, job_list);
65 }
66
67 BlockJob *block_job_get(const char *id)
68 {
69 BlockJob *job;
70
71 QLIST_FOREACH(job, &block_jobs, job_list) {
72 if (job->id && !strcmp(id, job->id)) {
73 return job;
74 }
75 }
76
77 return NULL;
78 }
79
80 static void block_job_attached_aio_context(AioContext *new_context,
81 void *opaque)
82 {
83 BlockJob *job = opaque;
84
85 if (job->driver->attached_aio_context) {
86 job->driver->attached_aio_context(job, new_context);
87 }
88
89 block_job_resume(job);
90 }
91
92 static void block_job_drain(BlockJob *job)
93 {
94 /* If job is !job->busy this kicks it into the next pause point. */
95 block_job_enter(job);
96
97 blk_drain(job->blk);
98 if (job->driver->drain) {
99 job->driver->drain(job);
100 }
101 }
102
103 static void block_job_detach_aio_context(void *opaque)
104 {
105 BlockJob *job = opaque;
106
107 /* In case the job terminates during aio_poll()... */
108 block_job_ref(job);
109
110 block_job_pause(job);
111
112 while (!job->paused && !job->completed) {
113 block_job_drain(job);
114 }
115
116 block_job_unref(job);
117 }
118
119 void block_job_add_bdrv(BlockJob *job, BlockDriverState *bs)
120 {
121 job->nodes = g_slist_prepend(job->nodes, bs);
122 bdrv_ref(bs);
123 bdrv_op_block_all(bs, job->blocker);
124 }
125
126 void *block_job_create(const char *job_id, const BlockJobDriver *driver,
127 BlockDriverState *bs, int64_t speed, int flags,
128 BlockCompletionFunc *cb, void *opaque, Error **errp)
129 {
130 BlockBackend *blk;
131 BlockJob *job;
132
133 if (bs->job) {
134 error_setg(errp, QERR_DEVICE_IN_USE, bdrv_get_device_name(bs));
135 return NULL;
136 }
137
138 if (job_id == NULL && !(flags & BLOCK_JOB_INTERNAL)) {
139 job_id = bdrv_get_device_name(bs);
140 if (!*job_id) {
141 error_setg(errp, "An explicit job ID is required for this node");
142 return NULL;
143 }
144 }
145
146 if (job_id) {
147 if (flags & BLOCK_JOB_INTERNAL) {
148 error_setg(errp, "Cannot specify job ID for internal block job");
149 return NULL;
150 }
151
152 if (!id_wellformed(job_id)) {
153 error_setg(errp, "Invalid job ID '%s'", job_id);
154 return NULL;
155 }
156
157 if (block_job_get(job_id)) {
158 error_setg(errp, "Job ID '%s' already in use", job_id);
159 return NULL;
160 }
161 }
162
163 blk = blk_new();
164 blk_insert_bs(blk, bs);
165
166 job = g_malloc0(driver->instance_size);
167 error_setg(&job->blocker, "block device is in use by block job: %s",
168 BlockJobType_lookup[driver->job_type]);
169 block_job_add_bdrv(job, bs);
170 bdrv_op_unblock(bs, BLOCK_OP_TYPE_DATAPLANE, job->blocker);
171
172 job->driver = driver;
173 job->id = g_strdup(job_id);
174 job->blk = blk;
175 job->cb = cb;
176 job->opaque = opaque;
177 job->busy = false;
178 job->paused = true;
179 job->pause_count = 1;
180 job->refcnt = 1;
181 bs->job = job;
182
183 QLIST_INSERT_HEAD(&block_jobs, job, job_list);
184
185 blk_add_aio_context_notifier(blk, block_job_attached_aio_context,
186 block_job_detach_aio_context, job);
187
188 /* Only set speed when necessary to avoid NotSupported error */
189 if (speed != 0) {
190 Error *local_err = NULL;
191
192 block_job_set_speed(job, speed, &local_err);
193 if (local_err) {
194 block_job_unref(job);
195 error_propagate(errp, local_err);
196 return NULL;
197 }
198 }
199 return job;
200 }
201
202 bool block_job_is_internal(BlockJob *job)
203 {
204 return (job->id == NULL);
205 }
206
207 static bool block_job_started(BlockJob *job)
208 {
209 return job->co;
210 }
211
212 void block_job_start(BlockJob *job)
213 {
214 assert(job && !block_job_started(job) && job->paused &&
215 !job->busy && job->driver->start);
216 job->co = qemu_coroutine_create(job->driver->start, job);
217 if (--job->pause_count == 0) {
218 job->paused = false;
219 job->busy = true;
220 qemu_coroutine_enter(job->co);
221 }
222 }
223
224 void block_job_ref(BlockJob *job)
225 {
226 ++job->refcnt;
227 }
228
229 void block_job_unref(BlockJob *job)
230 {
231 if (--job->refcnt == 0) {
232 GSList *l;
233 BlockDriverState *bs = blk_bs(job->blk);
234 bs->job = NULL;
235 for (l = job->nodes; l; l = l->next) {
236 bs = l->data;
237 bdrv_op_unblock_all(bs, job->blocker);
238 bdrv_unref(bs);
239 }
240 g_slist_free(job->nodes);
241 blk_remove_aio_context_notifier(job->blk,
242 block_job_attached_aio_context,
243 block_job_detach_aio_context, job);
244 blk_unref(job->blk);
245 error_free(job->blocker);
246 g_free(job->id);
247 QLIST_REMOVE(job, job_list);
248 g_free(job);
249 }
250 }
251
252 static void block_job_completed_single(BlockJob *job)
253 {
254 if (!job->ret) {
255 if (job->driver->commit) {
256 job->driver->commit(job);
257 }
258 } else {
259 if (job->driver->abort) {
260 job->driver->abort(job);
261 }
262 }
263 if (job->driver->clean) {
264 job->driver->clean(job);
265 }
266
267 if (job->cb) {
268 job->cb(job->opaque, job->ret);
269 }
270
271 /* Emit events only if we actually started */
272 if (block_job_started(job)) {
273 if (block_job_is_cancelled(job)) {
274 block_job_event_cancelled(job);
275 } else {
276 const char *msg = NULL;
277 if (job->ret < 0) {
278 msg = strerror(-job->ret);
279 }
280 block_job_event_completed(job, msg);
281 }
282 }
283
284 if (job->txn) {
285 QLIST_REMOVE(job, txn_list);
286 block_job_txn_unref(job->txn);
287 }
288 block_job_unref(job);
289 }
290
291 static void block_job_completed_txn_abort(BlockJob *job)
292 {
293 AioContext *ctx;
294 BlockJobTxn *txn = job->txn;
295 BlockJob *other_job, *next;
296
297 if (txn->aborting) {
298 /*
299 * We are cancelled by another job, which will handle everything.
300 */
301 return;
302 }
303 txn->aborting = true;
304 /* We are the first failed job. Cancel other jobs. */
305 QLIST_FOREACH(other_job, &txn->jobs, txn_list) {
306 ctx = blk_get_aio_context(other_job->blk);
307 aio_context_acquire(ctx);
308 }
309 QLIST_FOREACH(other_job, &txn->jobs, txn_list) {
310 if (other_job == job || other_job->completed) {
311 /* Other jobs are "effectively" cancelled by us, set the status for
312 * them; this job, however, may or may not be cancelled, depending
313 * on the caller, so leave it. */
314 if (other_job != job) {
315 other_job->cancelled = true;
316 }
317 continue;
318 }
319 block_job_cancel_sync(other_job);
320 assert(other_job->completed);
321 }
322 QLIST_FOREACH_SAFE(other_job, &txn->jobs, txn_list, next) {
323 ctx = blk_get_aio_context(other_job->blk);
324 block_job_completed_single(other_job);
325 aio_context_release(ctx);
326 }
327 }
328
329 static void block_job_completed_txn_success(BlockJob *job)
330 {
331 AioContext *ctx;
332 BlockJobTxn *txn = job->txn;
333 BlockJob *other_job, *next;
334 /*
335 * Successful completion, see if there are other running jobs in this
336 * txn.
337 */
338 QLIST_FOREACH(other_job, &txn->jobs, txn_list) {
339 if (!other_job->completed) {
340 return;
341 }
342 }
343 /* We are the last completed job, commit the transaction. */
344 QLIST_FOREACH_SAFE(other_job, &txn->jobs, txn_list, next) {
345 ctx = blk_get_aio_context(other_job->blk);
346 aio_context_acquire(ctx);
347 assert(other_job->ret == 0);
348 block_job_completed_single(other_job);
349 aio_context_release(ctx);
350 }
351 }
352
353 void block_job_completed(BlockJob *job, int ret)
354 {
355 assert(blk_bs(job->blk)->job == job);
356 assert(!job->completed);
357 job->completed = true;
358 job->ret = ret;
359 if (!job->txn) {
360 block_job_completed_single(job);
361 } else if (ret < 0 || block_job_is_cancelled(job)) {
362 block_job_completed_txn_abort(job);
363 } else {
364 block_job_completed_txn_success(job);
365 }
366 }
367
368 void block_job_set_speed(BlockJob *job, int64_t speed, Error **errp)
369 {
370 Error *local_err = NULL;
371
372 if (!job->driver->set_speed) {
373 error_setg(errp, QERR_UNSUPPORTED);
374 return;
375 }
376 job->driver->set_speed(job, speed, &local_err);
377 if (local_err) {
378 error_propagate(errp, local_err);
379 return;
380 }
381
382 job->speed = speed;
383 }
384
385 void block_job_complete(BlockJob *job, Error **errp)
386 {
387 /* Should not be reachable via external interface for internal jobs */
388 assert(job->id);
389 if (job->pause_count || job->cancelled ||
390 !block_job_started(job) || !job->driver->complete) {
391 error_setg(errp, "The active block job '%s' cannot be completed",
392 job->id);
393 return;
394 }
395
396 job->driver->complete(job, errp);
397 }
398
399 void block_job_pause(BlockJob *job)
400 {
401 job->pause_count++;
402 }
403
404 void block_job_user_pause(BlockJob *job)
405 {
406 job->user_paused = true;
407 block_job_pause(job);
408 }
409
410 static bool block_job_should_pause(BlockJob *job)
411 {
412 return job->pause_count > 0;
413 }
414
415 bool block_job_user_paused(BlockJob *job)
416 {
417 return job ? job->user_paused : 0;
418 }
419
420 void coroutine_fn block_job_pause_point(BlockJob *job)
421 {
422 assert(job && block_job_started(job));
423
424 if (!block_job_should_pause(job)) {
425 return;
426 }
427 if (block_job_is_cancelled(job)) {
428 return;
429 }
430
431 if (job->driver->pause) {
432 job->driver->pause(job);
433 }
434
435 if (block_job_should_pause(job) && !block_job_is_cancelled(job)) {
436 job->paused = true;
437 job->busy = false;
438 qemu_coroutine_yield(); /* wait for block_job_resume() */
439 job->busy = true;
440 job->paused = false;
441 }
442
443 if (job->driver->resume) {
444 job->driver->resume(job);
445 }
446 }
447
448 void block_job_resume(BlockJob *job)
449 {
450 assert(job->pause_count > 0);
451 job->pause_count--;
452 if (job->pause_count) {
453 return;
454 }
455 block_job_enter(job);
456 }
457
458 void block_job_user_resume(BlockJob *job)
459 {
460 if (job && job->user_paused && job->pause_count > 0) {
461 job->user_paused = false;
462 block_job_resume(job);
463 }
464 }
465
466 void block_job_enter(BlockJob *job)
467 {
468 if (job->co && !job->busy) {
469 qemu_coroutine_enter(job->co);
470 }
471 }
472
473 void block_job_cancel(BlockJob *job)
474 {
475 if (block_job_started(job)) {
476 job->cancelled = true;
477 block_job_iostatus_reset(job);
478 block_job_enter(job);
479 } else {
480 block_job_completed(job, -ECANCELED);
481 }
482 }
483
484 bool block_job_is_cancelled(BlockJob *job)
485 {
486 return job->cancelled;
487 }
488
489 void block_job_iostatus_reset(BlockJob *job)
490 {
491 job->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
492 if (job->driver->iostatus_reset) {
493 job->driver->iostatus_reset(job);
494 }
495 }
496
497 static int block_job_finish_sync(BlockJob *job,
498 void (*finish)(BlockJob *, Error **errp),
499 Error **errp)
500 {
501 Error *local_err = NULL;
502 int ret;
503
504 assert(blk_bs(job->blk)->job == job);
505
506 block_job_ref(job);
507
508 finish(job, &local_err);
509 if (local_err) {
510 error_propagate(errp, local_err);
511 block_job_unref(job);
512 return -EBUSY;
513 }
514 /* block_job_drain calls block_job_enter, and it should be enough to
515 * induce progress until the job completes or moves to the main thread.
516 */
517 while (!job->deferred_to_main_loop && !job->completed) {
518 block_job_drain(job);
519 }
520 while (!job->completed) {
521 aio_poll(qemu_get_aio_context(), true);
522 }
523 ret = (job->cancelled && job->ret == 0) ? -ECANCELED : job->ret;
524 block_job_unref(job);
525 return ret;
526 }
527
528 /* A wrapper around block_job_cancel() taking an Error ** parameter so it may be
529 * used with block_job_finish_sync() without the need for (rather nasty)
530 * function pointer casts there. */
531 static void block_job_cancel_err(BlockJob *job, Error **errp)
532 {
533 block_job_cancel(job);
534 }
535
536 int block_job_cancel_sync(BlockJob *job)
537 {
538 return block_job_finish_sync(job, &block_job_cancel_err, NULL);
539 }
540
541 void block_job_cancel_sync_all(void)
542 {
543 BlockJob *job;
544 AioContext *aio_context;
545
546 while ((job = QLIST_FIRST(&block_jobs))) {
547 aio_context = blk_get_aio_context(job->blk);
548 aio_context_acquire(aio_context);
549 block_job_cancel_sync(job);
550 aio_context_release(aio_context);
551 }
552 }
553
554 int block_job_complete_sync(BlockJob *job, Error **errp)
555 {
556 return block_job_finish_sync(job, &block_job_complete, errp);
557 }
558
559 void block_job_sleep_ns(BlockJob *job, QEMUClockType type, int64_t ns)
560 {
561 assert(job->busy);
562
563 /* Check cancellation *before* setting busy = false, too! */
564 if (block_job_is_cancelled(job)) {
565 return;
566 }
567
568 job->busy = false;
569 if (!block_job_should_pause(job)) {
570 co_aio_sleep_ns(blk_get_aio_context(job->blk), type, ns);
571 }
572 job->busy = true;
573
574 block_job_pause_point(job);
575 }
576
577 void block_job_yield(BlockJob *job)
578 {
579 assert(job->busy);
580
581 /* Check cancellation *before* setting busy = false, too! */
582 if (block_job_is_cancelled(job)) {
583 return;
584 }
585
586 job->busy = false;
587 if (!block_job_should_pause(job)) {
588 qemu_coroutine_yield();
589 }
590 job->busy = true;
591
592 block_job_pause_point(job);
593 }
594
595 BlockJobInfo *block_job_query(BlockJob *job, Error **errp)
596 {
597 BlockJobInfo *info;
598
599 if (block_job_is_internal(job)) {
600 error_setg(errp, "Cannot query QEMU internal jobs");
601 return NULL;
602 }
603 info = g_new0(BlockJobInfo, 1);
604 info->type = g_strdup(BlockJobType_lookup[job->driver->job_type]);
605 info->device = g_strdup(job->id);
606 info->len = job->len;
607 info->busy = job->busy;
608 info->paused = job->pause_count > 0;
609 info->offset = job->offset;
610 info->speed = job->speed;
611 info->io_status = job->iostatus;
612 info->ready = job->ready;
613 return info;
614 }
615
616 static void block_job_iostatus_set_err(BlockJob *job, int error)
617 {
618 if (job->iostatus == BLOCK_DEVICE_IO_STATUS_OK) {
619 job->iostatus = error == ENOSPC ? BLOCK_DEVICE_IO_STATUS_NOSPACE :
620 BLOCK_DEVICE_IO_STATUS_FAILED;
621 }
622 }
623
624 static void block_job_event_cancelled(BlockJob *job)
625 {
626 if (block_job_is_internal(job)) {
627 return;
628 }
629
630 qapi_event_send_block_job_cancelled(job->driver->job_type,
631 job->id,
632 job->len,
633 job->offset,
634 job->speed,
635 &error_abort);
636 }
637
638 static void block_job_event_completed(BlockJob *job, const char *msg)
639 {
640 if (block_job_is_internal(job)) {
641 return;
642 }
643
644 qapi_event_send_block_job_completed(job->driver->job_type,
645 job->id,
646 job->len,
647 job->offset,
648 job->speed,
649 !!msg,
650 msg,
651 &error_abort);
652 }
653
654 void block_job_event_ready(BlockJob *job)
655 {
656 job->ready = true;
657
658 if (block_job_is_internal(job)) {
659 return;
660 }
661
662 qapi_event_send_block_job_ready(job->driver->job_type,
663 job->id,
664 job->len,
665 job->offset,
666 job->speed, &error_abort);
667 }
668
669 BlockErrorAction block_job_error_action(BlockJob *job, BlockdevOnError on_err,
670 int is_read, int error)
671 {
672 BlockErrorAction action;
673
674 switch (on_err) {
675 case BLOCKDEV_ON_ERROR_ENOSPC:
676 case BLOCKDEV_ON_ERROR_AUTO:
677 action = (error == ENOSPC) ?
678 BLOCK_ERROR_ACTION_STOP : BLOCK_ERROR_ACTION_REPORT;
679 break;
680 case BLOCKDEV_ON_ERROR_STOP:
681 action = BLOCK_ERROR_ACTION_STOP;
682 break;
683 case BLOCKDEV_ON_ERROR_REPORT:
684 action = BLOCK_ERROR_ACTION_REPORT;
685 break;
686 case BLOCKDEV_ON_ERROR_IGNORE:
687 action = BLOCK_ERROR_ACTION_IGNORE;
688 break;
689 default:
690 abort();
691 }
692 if (!block_job_is_internal(job)) {
693 qapi_event_send_block_job_error(job->id,
694 is_read ? IO_OPERATION_TYPE_READ :
695 IO_OPERATION_TYPE_WRITE,
696 action, &error_abort);
697 }
698 if (action == BLOCK_ERROR_ACTION_STOP) {
699 /* make the pause user visible, which will be resumed from QMP. */
700 block_job_user_pause(job);
701 block_job_iostatus_set_err(job, error);
702 }
703 return action;
704 }
705
706 typedef struct {
707 BlockJob *job;
708 AioContext *aio_context;
709 BlockJobDeferToMainLoopFn *fn;
710 void *opaque;
711 } BlockJobDeferToMainLoopData;
712
713 static void block_job_defer_to_main_loop_bh(void *opaque)
714 {
715 BlockJobDeferToMainLoopData *data = opaque;
716 AioContext *aio_context;
717
718 /* Prevent race with block_job_defer_to_main_loop() */
719 aio_context_acquire(data->aio_context);
720
721 /* Fetch BDS AioContext again, in case it has changed */
722 aio_context = blk_get_aio_context(data->job->blk);
723 aio_context_acquire(aio_context);
724
725 data->job->deferred_to_main_loop = false;
726 data->fn(data->job, data->opaque);
727
728 aio_context_release(aio_context);
729
730 aio_context_release(data->aio_context);
731
732 g_free(data);
733 }
734
735 void block_job_defer_to_main_loop(BlockJob *job,
736 BlockJobDeferToMainLoopFn *fn,
737 void *opaque)
738 {
739 BlockJobDeferToMainLoopData *data = g_malloc(sizeof(*data));
740 data->job = job;
741 data->aio_context = blk_get_aio_context(job->blk);
742 data->fn = fn;
743 data->opaque = opaque;
744 job->deferred_to_main_loop = true;
745
746 aio_bh_schedule_oneshot(qemu_get_aio_context(),
747 block_job_defer_to_main_loop_bh, data);
748 }
749
750 BlockJobTxn *block_job_txn_new(void)
751 {
752 BlockJobTxn *txn = g_new0(BlockJobTxn, 1);
753 QLIST_INIT(&txn->jobs);
754 txn->refcnt = 1;
755 return txn;
756 }
757
758 static void block_job_txn_ref(BlockJobTxn *txn)
759 {
760 txn->refcnt++;
761 }
762
763 void block_job_txn_unref(BlockJobTxn *txn)
764 {
765 if (txn && --txn->refcnt == 0) {
766 g_free(txn);
767 }
768 }
769
770 void block_job_txn_add_job(BlockJobTxn *txn, BlockJob *job)
771 {
772 if (!txn) {
773 return;
774 }
775
776 assert(!job->txn);
777 job->txn = txn;
778
779 QLIST_INSERT_HEAD(&txn->jobs, job, txn_list);
780 block_job_txn_ref(txn);
781 }