travis: add whitespace between each major section & matrix entry
[qemu/ar7.git] / block / blkdebug.c
blob0759452925b892d2f12206f21ef825bc5bf87713
1 /*
2 * Block protocol for I/O error injection
4 * Copyright (C) 2016-2017 Red Hat, Inc.
5 * Copyright (c) 2010 Kevin Wolf <kwolf@redhat.com>
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:
14 * The above copyright notice and this permission notice shall be included in
15 * all copies or substantial portions of the Software.
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.
26 #include "qemu/osdep.h"
27 #include "qapi/error.h"
28 #include "qemu/cutils.h"
29 #include "qemu/config-file.h"
30 #include "block/block_int.h"
31 #include "qemu/module.h"
32 #include "qemu/option.h"
33 #include "qapi/qmp/qdict.h"
34 #include "qapi/qmp/qstring.h"
35 #include "sysemu/qtest.h"
37 typedef struct BDRVBlkdebugState {
38 int state;
39 int new_state;
40 uint64_t align;
41 uint64_t max_transfer;
42 uint64_t opt_write_zero;
43 uint64_t max_write_zero;
44 uint64_t opt_discard;
45 uint64_t max_discard;
47 /* For blkdebug_refresh_filename() */
48 char *config_file;
50 QLIST_HEAD(, BlkdebugRule) rules[BLKDBG__MAX];
51 QSIMPLEQ_HEAD(, BlkdebugRule) active_rules;
52 QLIST_HEAD(, BlkdebugSuspendedReq) suspended_reqs;
53 } BDRVBlkdebugState;
55 typedef struct BlkdebugAIOCB {
56 BlockAIOCB common;
57 int ret;
58 } BlkdebugAIOCB;
60 typedef struct BlkdebugSuspendedReq {
61 Coroutine *co;
62 char *tag;
63 QLIST_ENTRY(BlkdebugSuspendedReq) next;
64 } BlkdebugSuspendedReq;
66 enum {
67 ACTION_INJECT_ERROR,
68 ACTION_SET_STATE,
69 ACTION_SUSPEND,
72 typedef struct BlkdebugRule {
73 BlkdebugEvent event;
74 int action;
75 int state;
76 union {
77 struct {
78 int error;
79 int immediately;
80 int once;
81 int64_t offset;
82 } inject;
83 struct {
84 int new_state;
85 } set_state;
86 struct {
87 char *tag;
88 } suspend;
89 } options;
90 QLIST_ENTRY(BlkdebugRule) next;
91 QSIMPLEQ_ENTRY(BlkdebugRule) active_next;
92 } BlkdebugRule;
94 static QemuOptsList inject_error_opts = {
95 .name = "inject-error",
96 .head = QTAILQ_HEAD_INITIALIZER(inject_error_opts.head),
97 .desc = {
99 .name = "event",
100 .type = QEMU_OPT_STRING,
103 .name = "state",
104 .type = QEMU_OPT_NUMBER,
107 .name = "errno",
108 .type = QEMU_OPT_NUMBER,
111 .name = "sector",
112 .type = QEMU_OPT_NUMBER,
115 .name = "once",
116 .type = QEMU_OPT_BOOL,
119 .name = "immediately",
120 .type = QEMU_OPT_BOOL,
122 { /* end of list */ }
126 static QemuOptsList set_state_opts = {
127 .name = "set-state",
128 .head = QTAILQ_HEAD_INITIALIZER(set_state_opts.head),
129 .desc = {
131 .name = "event",
132 .type = QEMU_OPT_STRING,
135 .name = "state",
136 .type = QEMU_OPT_NUMBER,
139 .name = "new_state",
140 .type = QEMU_OPT_NUMBER,
142 { /* end of list */ }
146 static QemuOptsList *config_groups[] = {
147 &inject_error_opts,
148 &set_state_opts,
149 NULL
152 struct add_rule_data {
153 BDRVBlkdebugState *s;
154 int action;
157 static int add_rule(void *opaque, QemuOpts *opts, Error **errp)
159 struct add_rule_data *d = opaque;
160 BDRVBlkdebugState *s = d->s;
161 const char* event_name;
162 int event;
163 struct BlkdebugRule *rule;
164 int64_t sector;
166 /* Find the right event for the rule */
167 event_name = qemu_opt_get(opts, "event");
168 if (!event_name) {
169 error_setg(errp, "Missing event name for rule");
170 return -1;
172 event = qapi_enum_parse(&BlkdebugEvent_lookup, event_name, -1, errp);
173 if (event < 0) {
174 return -1;
177 /* Set attributes common for all actions */
178 rule = g_malloc0(sizeof(*rule));
179 *rule = (struct BlkdebugRule) {
180 .event = event,
181 .action = d->action,
182 .state = qemu_opt_get_number(opts, "state", 0),
185 /* Parse action-specific options */
186 switch (d->action) {
187 case ACTION_INJECT_ERROR:
188 rule->options.inject.error = qemu_opt_get_number(opts, "errno", EIO);
189 rule->options.inject.once = qemu_opt_get_bool(opts, "once", 0);
190 rule->options.inject.immediately =
191 qemu_opt_get_bool(opts, "immediately", 0);
192 sector = qemu_opt_get_number(opts, "sector", -1);
193 rule->options.inject.offset =
194 sector == -1 ? -1 : sector * BDRV_SECTOR_SIZE;
195 break;
197 case ACTION_SET_STATE:
198 rule->options.set_state.new_state =
199 qemu_opt_get_number(opts, "new_state", 0);
200 break;
202 case ACTION_SUSPEND:
203 rule->options.suspend.tag =
204 g_strdup(qemu_opt_get(opts, "tag"));
205 break;
208 /* Add the rule */
209 QLIST_INSERT_HEAD(&s->rules[event], rule, next);
211 return 0;
214 static void remove_rule(BlkdebugRule *rule)
216 switch (rule->action) {
217 case ACTION_INJECT_ERROR:
218 case ACTION_SET_STATE:
219 break;
220 case ACTION_SUSPEND:
221 g_free(rule->options.suspend.tag);
222 break;
225 QLIST_REMOVE(rule, next);
226 g_free(rule);
229 static int read_config(BDRVBlkdebugState *s, const char *filename,
230 QDict *options, Error **errp)
232 FILE *f = NULL;
233 int ret;
234 struct add_rule_data d;
235 Error *local_err = NULL;
237 if (filename) {
238 f = fopen(filename, "r");
239 if (f == NULL) {
240 error_setg_errno(errp, errno, "Could not read blkdebug config file");
241 return -errno;
244 ret = qemu_config_parse(f, config_groups, filename);
245 if (ret < 0) {
246 error_setg(errp, "Could not parse blkdebug config file");
247 goto fail;
251 qemu_config_parse_qdict(options, config_groups, &local_err);
252 if (local_err) {
253 error_propagate(errp, local_err);
254 ret = -EINVAL;
255 goto fail;
258 d.s = s;
259 d.action = ACTION_INJECT_ERROR;
260 qemu_opts_foreach(&inject_error_opts, add_rule, &d, &local_err);
261 if (local_err) {
262 error_propagate(errp, local_err);
263 ret = -EINVAL;
264 goto fail;
267 d.action = ACTION_SET_STATE;
268 qemu_opts_foreach(&set_state_opts, add_rule, &d, &local_err);
269 if (local_err) {
270 error_propagate(errp, local_err);
271 ret = -EINVAL;
272 goto fail;
275 ret = 0;
276 fail:
277 qemu_opts_reset(&inject_error_opts);
278 qemu_opts_reset(&set_state_opts);
279 if (f) {
280 fclose(f);
282 return ret;
285 /* Valid blkdebug filenames look like blkdebug:path/to/config:path/to/image */
286 static void blkdebug_parse_filename(const char *filename, QDict *options,
287 Error **errp)
289 const char *c;
291 /* Parse the blkdebug: prefix */
292 if (!strstart(filename, "blkdebug:", &filename)) {
293 /* There was no prefix; therefore, all options have to be already
294 present in the QDict (except for the filename) */
295 qdict_put_str(options, "x-image", filename);
296 return;
299 /* Parse config file path */
300 c = strchr(filename, ':');
301 if (c == NULL) {
302 error_setg(errp, "blkdebug requires both config file and image path");
303 return;
306 if (c != filename) {
307 QString *config_path;
308 config_path = qstring_from_substr(filename, 0, c - filename);
309 qdict_put(options, "config", config_path);
312 /* TODO Allow multi-level nesting and set file.filename here */
313 filename = c + 1;
314 qdict_put_str(options, "x-image", filename);
317 static QemuOptsList runtime_opts = {
318 .name = "blkdebug",
319 .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head),
320 .desc = {
322 .name = "config",
323 .type = QEMU_OPT_STRING,
324 .help = "Path to the configuration file",
327 .name = "x-image",
328 .type = QEMU_OPT_STRING,
329 .help = "[internal use only, will be removed]",
332 .name = "align",
333 .type = QEMU_OPT_SIZE,
334 .help = "Required alignment in bytes",
337 .name = "max-transfer",
338 .type = QEMU_OPT_SIZE,
339 .help = "Maximum transfer size in bytes",
342 .name = "opt-write-zero",
343 .type = QEMU_OPT_SIZE,
344 .help = "Optimum write zero alignment in bytes",
347 .name = "max-write-zero",
348 .type = QEMU_OPT_SIZE,
349 .help = "Maximum write zero size in bytes",
352 .name = "opt-discard",
353 .type = QEMU_OPT_SIZE,
354 .help = "Optimum discard alignment in bytes",
357 .name = "max-discard",
358 .type = QEMU_OPT_SIZE,
359 .help = "Maximum discard size in bytes",
361 { /* end of list */ }
365 static int blkdebug_open(BlockDriverState *bs, QDict *options, int flags,
366 Error **errp)
368 BDRVBlkdebugState *s = bs->opaque;
369 QemuOpts *opts;
370 Error *local_err = NULL;
371 int ret;
372 uint64_t align;
374 opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort);
375 qemu_opts_absorb_qdict(opts, options, &local_err);
376 if (local_err) {
377 error_propagate(errp, local_err);
378 ret = -EINVAL;
379 goto out;
382 /* Read rules from config file or command line options */
383 s->config_file = g_strdup(qemu_opt_get(opts, "config"));
384 ret = read_config(s, s->config_file, options, errp);
385 if (ret) {
386 goto out;
389 /* Set initial state */
390 s->state = 1;
392 /* Open the image file */
393 bs->file = bdrv_open_child(qemu_opt_get(opts, "x-image"), options, "image",
394 bs, &child_file, false, &local_err);
395 if (local_err) {
396 ret = -EINVAL;
397 error_propagate(errp, local_err);
398 goto out;
401 bs->supported_write_flags = BDRV_REQ_WRITE_UNCHANGED |
402 (BDRV_REQ_FUA & bs->file->bs->supported_write_flags);
403 bs->supported_zero_flags = BDRV_REQ_WRITE_UNCHANGED |
404 ((BDRV_REQ_FUA | BDRV_REQ_MAY_UNMAP) &
405 bs->file->bs->supported_zero_flags);
406 ret = -EINVAL;
408 /* Set alignment overrides */
409 s->align = qemu_opt_get_size(opts, "align", 0);
410 if (s->align && (s->align >= INT_MAX || !is_power_of_2(s->align))) {
411 error_setg(errp, "Cannot meet constraints with align %" PRIu64,
412 s->align);
413 goto out;
415 align = MAX(s->align, bs->file->bs->bl.request_alignment);
417 s->max_transfer = qemu_opt_get_size(opts, "max-transfer", 0);
418 if (s->max_transfer &&
419 (s->max_transfer >= INT_MAX ||
420 !QEMU_IS_ALIGNED(s->max_transfer, align))) {
421 error_setg(errp, "Cannot meet constraints with max-transfer %" PRIu64,
422 s->max_transfer);
423 goto out;
426 s->opt_write_zero = qemu_opt_get_size(opts, "opt-write-zero", 0);
427 if (s->opt_write_zero &&
428 (s->opt_write_zero >= INT_MAX ||
429 !QEMU_IS_ALIGNED(s->opt_write_zero, align))) {
430 error_setg(errp, "Cannot meet constraints with opt-write-zero %" PRIu64,
431 s->opt_write_zero);
432 goto out;
435 s->max_write_zero = qemu_opt_get_size(opts, "max-write-zero", 0);
436 if (s->max_write_zero &&
437 (s->max_write_zero >= INT_MAX ||
438 !QEMU_IS_ALIGNED(s->max_write_zero,
439 MAX(s->opt_write_zero, align)))) {
440 error_setg(errp, "Cannot meet constraints with max-write-zero %" PRIu64,
441 s->max_write_zero);
442 goto out;
445 s->opt_discard = qemu_opt_get_size(opts, "opt-discard", 0);
446 if (s->opt_discard &&
447 (s->opt_discard >= INT_MAX ||
448 !QEMU_IS_ALIGNED(s->opt_discard, align))) {
449 error_setg(errp, "Cannot meet constraints with opt-discard %" PRIu64,
450 s->opt_discard);
451 goto out;
454 s->max_discard = qemu_opt_get_size(opts, "max-discard", 0);
455 if (s->max_discard &&
456 (s->max_discard >= INT_MAX ||
457 !QEMU_IS_ALIGNED(s->max_discard,
458 MAX(s->opt_discard, align)))) {
459 error_setg(errp, "Cannot meet constraints with max-discard %" PRIu64,
460 s->max_discard);
461 goto out;
464 ret = 0;
465 out:
466 if (ret < 0) {
467 g_free(s->config_file);
469 qemu_opts_del(opts);
470 return ret;
473 static int rule_check(BlockDriverState *bs, uint64_t offset, uint64_t bytes)
475 BDRVBlkdebugState *s = bs->opaque;
476 BlkdebugRule *rule = NULL;
477 int error;
478 bool immediately;
480 QSIMPLEQ_FOREACH(rule, &s->active_rules, active_next) {
481 uint64_t inject_offset = rule->options.inject.offset;
483 if (inject_offset == -1 ||
484 (bytes && inject_offset >= offset &&
485 inject_offset < offset + bytes))
487 break;
491 if (!rule || !rule->options.inject.error) {
492 return 0;
495 immediately = rule->options.inject.immediately;
496 error = rule->options.inject.error;
498 if (rule->options.inject.once) {
499 QSIMPLEQ_REMOVE(&s->active_rules, rule, BlkdebugRule, active_next);
500 remove_rule(rule);
503 if (!immediately) {
504 aio_co_schedule(qemu_get_current_aio_context(), qemu_coroutine_self());
505 qemu_coroutine_yield();
508 return -error;
511 static int coroutine_fn
512 blkdebug_co_preadv(BlockDriverState *bs, uint64_t offset, uint64_t bytes,
513 QEMUIOVector *qiov, int flags)
515 int err;
517 /* Sanity check block layer guarantees */
518 assert(QEMU_IS_ALIGNED(offset, bs->bl.request_alignment));
519 assert(QEMU_IS_ALIGNED(bytes, bs->bl.request_alignment));
520 if (bs->bl.max_transfer) {
521 assert(bytes <= bs->bl.max_transfer);
524 err = rule_check(bs, offset, bytes);
525 if (err) {
526 return err;
529 return bdrv_co_preadv(bs->file, offset, bytes, qiov, flags);
532 static int coroutine_fn
533 blkdebug_co_pwritev(BlockDriverState *bs, uint64_t offset, uint64_t bytes,
534 QEMUIOVector *qiov, int flags)
536 int err;
538 /* Sanity check block layer guarantees */
539 assert(QEMU_IS_ALIGNED(offset, bs->bl.request_alignment));
540 assert(QEMU_IS_ALIGNED(bytes, bs->bl.request_alignment));
541 if (bs->bl.max_transfer) {
542 assert(bytes <= bs->bl.max_transfer);
545 err = rule_check(bs, offset, bytes);
546 if (err) {
547 return err;
550 return bdrv_co_pwritev(bs->file, offset, bytes, qiov, flags);
553 static int blkdebug_co_flush(BlockDriverState *bs)
555 int err = rule_check(bs, 0, 0);
557 if (err) {
558 return err;
561 return bdrv_co_flush(bs->file->bs);
564 static int coroutine_fn blkdebug_co_pwrite_zeroes(BlockDriverState *bs,
565 int64_t offset, int bytes,
566 BdrvRequestFlags flags)
568 uint32_t align = MAX(bs->bl.request_alignment,
569 bs->bl.pwrite_zeroes_alignment);
570 int err;
572 /* Only pass through requests that are larger than requested
573 * preferred alignment (so that we test the fallback to writes on
574 * unaligned portions), and check that the block layer never hands
575 * us anything unaligned that crosses an alignment boundary. */
576 if (bytes < align) {
577 assert(QEMU_IS_ALIGNED(offset, align) ||
578 QEMU_IS_ALIGNED(offset + bytes, align) ||
579 DIV_ROUND_UP(offset, align) ==
580 DIV_ROUND_UP(offset + bytes, align));
581 return -ENOTSUP;
583 assert(QEMU_IS_ALIGNED(offset, align));
584 assert(QEMU_IS_ALIGNED(bytes, align));
585 if (bs->bl.max_pwrite_zeroes) {
586 assert(bytes <= bs->bl.max_pwrite_zeroes);
589 err = rule_check(bs, offset, bytes);
590 if (err) {
591 return err;
594 return bdrv_co_pwrite_zeroes(bs->file, offset, bytes, flags);
597 static int coroutine_fn blkdebug_co_pdiscard(BlockDriverState *bs,
598 int64_t offset, int bytes)
600 uint32_t align = bs->bl.pdiscard_alignment;
601 int err;
603 /* Only pass through requests that are larger than requested
604 * minimum alignment, and ensure that unaligned requests do not
605 * cross optimum discard boundaries. */
606 if (bytes < bs->bl.request_alignment) {
607 assert(QEMU_IS_ALIGNED(offset, align) ||
608 QEMU_IS_ALIGNED(offset + bytes, align) ||
609 DIV_ROUND_UP(offset, align) ==
610 DIV_ROUND_UP(offset + bytes, align));
611 return -ENOTSUP;
613 assert(QEMU_IS_ALIGNED(offset, bs->bl.request_alignment));
614 assert(QEMU_IS_ALIGNED(bytes, bs->bl.request_alignment));
615 if (align && bytes >= align) {
616 assert(QEMU_IS_ALIGNED(offset, align));
617 assert(QEMU_IS_ALIGNED(bytes, align));
619 if (bs->bl.max_pdiscard) {
620 assert(bytes <= bs->bl.max_pdiscard);
623 err = rule_check(bs, offset, bytes);
624 if (err) {
625 return err;
628 return bdrv_co_pdiscard(bs->file, offset, bytes);
631 static int coroutine_fn blkdebug_co_block_status(BlockDriverState *bs,
632 bool want_zero,
633 int64_t offset,
634 int64_t bytes,
635 int64_t *pnum,
636 int64_t *map,
637 BlockDriverState **file)
639 assert(QEMU_IS_ALIGNED(offset | bytes, bs->bl.request_alignment));
640 return bdrv_co_block_status_from_file(bs, want_zero, offset, bytes,
641 pnum, map, file);
644 static void blkdebug_close(BlockDriverState *bs)
646 BDRVBlkdebugState *s = bs->opaque;
647 BlkdebugRule *rule, *next;
648 int i;
650 for (i = 0; i < BLKDBG__MAX; i++) {
651 QLIST_FOREACH_SAFE(rule, &s->rules[i], next, next) {
652 remove_rule(rule);
656 g_free(s->config_file);
659 static void suspend_request(BlockDriverState *bs, BlkdebugRule *rule)
661 BDRVBlkdebugState *s = bs->opaque;
662 BlkdebugSuspendedReq r;
664 r = (BlkdebugSuspendedReq) {
665 .co = qemu_coroutine_self(),
666 .tag = g_strdup(rule->options.suspend.tag),
669 remove_rule(rule);
670 QLIST_INSERT_HEAD(&s->suspended_reqs, &r, next);
672 if (!qtest_enabled()) {
673 printf("blkdebug: Suspended request '%s'\n", r.tag);
675 qemu_coroutine_yield();
676 if (!qtest_enabled()) {
677 printf("blkdebug: Resuming request '%s'\n", r.tag);
680 QLIST_REMOVE(&r, next);
681 g_free(r.tag);
684 static bool process_rule(BlockDriverState *bs, struct BlkdebugRule *rule,
685 bool injected)
687 BDRVBlkdebugState *s = bs->opaque;
689 /* Only process rules for the current state */
690 if (rule->state && rule->state != s->state) {
691 return injected;
694 /* Take the action */
695 switch (rule->action) {
696 case ACTION_INJECT_ERROR:
697 if (!injected) {
698 QSIMPLEQ_INIT(&s->active_rules);
699 injected = true;
701 QSIMPLEQ_INSERT_HEAD(&s->active_rules, rule, active_next);
702 break;
704 case ACTION_SET_STATE:
705 s->new_state = rule->options.set_state.new_state;
706 break;
708 case ACTION_SUSPEND:
709 suspend_request(bs, rule);
710 break;
712 return injected;
715 static void blkdebug_debug_event(BlockDriverState *bs, BlkdebugEvent event)
717 BDRVBlkdebugState *s = bs->opaque;
718 struct BlkdebugRule *rule, *next;
719 bool injected;
721 assert((int)event >= 0 && event < BLKDBG__MAX);
723 injected = false;
724 s->new_state = s->state;
725 QLIST_FOREACH_SAFE(rule, &s->rules[event], next, next) {
726 injected = process_rule(bs, rule, injected);
728 s->state = s->new_state;
731 static int blkdebug_debug_breakpoint(BlockDriverState *bs, const char *event,
732 const char *tag)
734 BDRVBlkdebugState *s = bs->opaque;
735 struct BlkdebugRule *rule;
736 int blkdebug_event;
738 blkdebug_event = qapi_enum_parse(&BlkdebugEvent_lookup, event, -1, NULL);
739 if (blkdebug_event < 0) {
740 return -ENOENT;
743 rule = g_malloc(sizeof(*rule));
744 *rule = (struct BlkdebugRule) {
745 .event = blkdebug_event,
746 .action = ACTION_SUSPEND,
747 .state = 0,
748 .options.suspend.tag = g_strdup(tag),
751 QLIST_INSERT_HEAD(&s->rules[blkdebug_event], rule, next);
753 return 0;
756 static int blkdebug_debug_resume(BlockDriverState *bs, const char *tag)
758 BDRVBlkdebugState *s = bs->opaque;
759 BlkdebugSuspendedReq *r, *next;
761 QLIST_FOREACH_SAFE(r, &s->suspended_reqs, next, next) {
762 if (!strcmp(r->tag, tag)) {
763 qemu_coroutine_enter(r->co);
764 return 0;
767 return -ENOENT;
770 static int blkdebug_debug_remove_breakpoint(BlockDriverState *bs,
771 const char *tag)
773 BDRVBlkdebugState *s = bs->opaque;
774 BlkdebugSuspendedReq *r, *r_next;
775 BlkdebugRule *rule, *next;
776 int i, ret = -ENOENT;
778 for (i = 0; i < BLKDBG__MAX; i++) {
779 QLIST_FOREACH_SAFE(rule, &s->rules[i], next, next) {
780 if (rule->action == ACTION_SUSPEND &&
781 !strcmp(rule->options.suspend.tag, tag)) {
782 remove_rule(rule);
783 ret = 0;
787 QLIST_FOREACH_SAFE(r, &s->suspended_reqs, next, r_next) {
788 if (!strcmp(r->tag, tag)) {
789 qemu_coroutine_enter(r->co);
790 ret = 0;
793 return ret;
796 static bool blkdebug_debug_is_suspended(BlockDriverState *bs, const char *tag)
798 BDRVBlkdebugState *s = bs->opaque;
799 BlkdebugSuspendedReq *r;
801 QLIST_FOREACH(r, &s->suspended_reqs, next) {
802 if (!strcmp(r->tag, tag)) {
803 return true;
806 return false;
809 static int64_t blkdebug_getlength(BlockDriverState *bs)
811 return bdrv_getlength(bs->file->bs);
814 static void blkdebug_refresh_filename(BlockDriverState *bs, QDict *options)
816 BDRVBlkdebugState *s = bs->opaque;
817 QDict *opts;
818 const QDictEntry *e;
819 bool force_json = false;
821 for (e = qdict_first(options); e; e = qdict_next(options, e)) {
822 if (strcmp(qdict_entry_key(e), "config") &&
823 strcmp(qdict_entry_key(e), "x-image"))
825 force_json = true;
826 break;
830 if (force_json && !bs->file->bs->full_open_options) {
831 /* The config file cannot be recreated, so creating a plain filename
832 * is impossible */
833 return;
836 if (!force_json && bs->file->bs->exact_filename[0]) {
837 int ret = snprintf(bs->exact_filename, sizeof(bs->exact_filename),
838 "blkdebug:%s:%s", s->config_file ?: "",
839 bs->file->bs->exact_filename);
840 if (ret >= sizeof(bs->exact_filename)) {
841 /* An overflow makes the filename unusable, so do not report any */
842 bs->exact_filename[0] = 0;
846 opts = qdict_new();
847 qdict_put_str(opts, "driver", "blkdebug");
849 qdict_put(opts, "image", qobject_ref(bs->file->bs->full_open_options));
851 for (e = qdict_first(options); e; e = qdict_next(options, e)) {
852 if (strcmp(qdict_entry_key(e), "x-image")) {
853 qdict_put_obj(opts, qdict_entry_key(e),
854 qobject_ref(qdict_entry_value(e)));
858 bs->full_open_options = opts;
861 static void blkdebug_refresh_limits(BlockDriverState *bs, Error **errp)
863 BDRVBlkdebugState *s = bs->opaque;
865 if (s->align) {
866 bs->bl.request_alignment = s->align;
868 if (s->max_transfer) {
869 bs->bl.max_transfer = s->max_transfer;
871 if (s->opt_write_zero) {
872 bs->bl.pwrite_zeroes_alignment = s->opt_write_zero;
874 if (s->max_write_zero) {
875 bs->bl.max_pwrite_zeroes = s->max_write_zero;
877 if (s->opt_discard) {
878 bs->bl.pdiscard_alignment = s->opt_discard;
880 if (s->max_discard) {
881 bs->bl.max_pdiscard = s->max_discard;
885 static int blkdebug_reopen_prepare(BDRVReopenState *reopen_state,
886 BlockReopenQueue *queue, Error **errp)
888 return 0;
891 static BlockDriver bdrv_blkdebug = {
892 .format_name = "blkdebug",
893 .protocol_name = "blkdebug",
894 .instance_size = sizeof(BDRVBlkdebugState),
895 .is_filter = true,
897 .bdrv_parse_filename = blkdebug_parse_filename,
898 .bdrv_file_open = blkdebug_open,
899 .bdrv_close = blkdebug_close,
900 .bdrv_reopen_prepare = blkdebug_reopen_prepare,
901 .bdrv_child_perm = bdrv_filter_default_perms,
903 .bdrv_getlength = blkdebug_getlength,
904 .bdrv_refresh_filename = blkdebug_refresh_filename,
905 .bdrv_refresh_limits = blkdebug_refresh_limits,
907 .bdrv_co_preadv = blkdebug_co_preadv,
908 .bdrv_co_pwritev = blkdebug_co_pwritev,
909 .bdrv_co_flush_to_disk = blkdebug_co_flush,
910 .bdrv_co_pwrite_zeroes = blkdebug_co_pwrite_zeroes,
911 .bdrv_co_pdiscard = blkdebug_co_pdiscard,
912 .bdrv_co_block_status = blkdebug_co_block_status,
914 .bdrv_debug_event = blkdebug_debug_event,
915 .bdrv_debug_breakpoint = blkdebug_debug_breakpoint,
916 .bdrv_debug_remove_breakpoint
917 = blkdebug_debug_remove_breakpoint,
918 .bdrv_debug_resume = blkdebug_debug_resume,
919 .bdrv_debug_is_suspended = blkdebug_debug_is_suspended,
922 static void bdrv_blkdebug_init(void)
924 bdrv_register(&bdrv_blkdebug);
927 block_init(bdrv_blkdebug_init);