xlnx-zynqmp-rtc: Initial commit
[qemu/ar7.git] / block / blkdebug.c
blobd83f23febd7fad1d588a86af42060408100052d5
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 - 1);
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_FUA &
402 bs->file->bs->supported_write_flags;
403 bs->supported_zero_flags = (BDRV_REQ_FUA | BDRV_REQ_MAY_UNMAP) &
404 bs->file->bs->supported_zero_flags;
405 ret = -EINVAL;
407 /* Set alignment overrides */
408 s->align = qemu_opt_get_size(opts, "align", 0);
409 if (s->align && (s->align >= INT_MAX || !is_power_of_2(s->align))) {
410 error_setg(errp, "Cannot meet constraints with align %" PRIu64,
411 s->align);
412 goto out;
414 align = MAX(s->align, bs->file->bs->bl.request_alignment);
416 s->max_transfer = qemu_opt_get_size(opts, "max-transfer", 0);
417 if (s->max_transfer &&
418 (s->max_transfer >= INT_MAX ||
419 !QEMU_IS_ALIGNED(s->max_transfer, align))) {
420 error_setg(errp, "Cannot meet constraints with max-transfer %" PRIu64,
421 s->max_transfer);
422 goto out;
425 s->opt_write_zero = qemu_opt_get_size(opts, "opt-write-zero", 0);
426 if (s->opt_write_zero &&
427 (s->opt_write_zero >= INT_MAX ||
428 !QEMU_IS_ALIGNED(s->opt_write_zero, align))) {
429 error_setg(errp, "Cannot meet constraints with opt-write-zero %" PRIu64,
430 s->opt_write_zero);
431 goto out;
434 s->max_write_zero = qemu_opt_get_size(opts, "max-write-zero", 0);
435 if (s->max_write_zero &&
436 (s->max_write_zero >= INT_MAX ||
437 !QEMU_IS_ALIGNED(s->max_write_zero,
438 MAX(s->opt_write_zero, align)))) {
439 error_setg(errp, "Cannot meet constraints with max-write-zero %" PRIu64,
440 s->max_write_zero);
441 goto out;
444 s->opt_discard = qemu_opt_get_size(opts, "opt-discard", 0);
445 if (s->opt_discard &&
446 (s->opt_discard >= INT_MAX ||
447 !QEMU_IS_ALIGNED(s->opt_discard, align))) {
448 error_setg(errp, "Cannot meet constraints with opt-discard %" PRIu64,
449 s->opt_discard);
450 goto out;
453 s->max_discard = qemu_opt_get_size(opts, "max-discard", 0);
454 if (s->max_discard &&
455 (s->max_discard >= INT_MAX ||
456 !QEMU_IS_ALIGNED(s->max_discard,
457 MAX(s->opt_discard, align)))) {
458 error_setg(errp, "Cannot meet constraints with max-discard %" PRIu64,
459 s->max_discard);
460 goto out;
463 ret = 0;
464 out:
465 if (ret < 0) {
466 g_free(s->config_file);
468 qemu_opts_del(opts);
469 return ret;
472 static int rule_check(BlockDriverState *bs, uint64_t offset, uint64_t bytes)
474 BDRVBlkdebugState *s = bs->opaque;
475 BlkdebugRule *rule = NULL;
476 int error;
477 bool immediately;
479 QSIMPLEQ_FOREACH(rule, &s->active_rules, active_next) {
480 uint64_t inject_offset = rule->options.inject.offset;
482 if (inject_offset == -1 ||
483 (bytes && inject_offset >= offset &&
484 inject_offset < offset + bytes))
486 break;
490 if (!rule || !rule->options.inject.error) {
491 return 0;
494 immediately = rule->options.inject.immediately;
495 error = rule->options.inject.error;
497 if (rule->options.inject.once) {
498 QSIMPLEQ_REMOVE(&s->active_rules, rule, BlkdebugRule, active_next);
499 remove_rule(rule);
502 if (!immediately) {
503 aio_co_schedule(qemu_get_current_aio_context(), qemu_coroutine_self());
504 qemu_coroutine_yield();
507 return -error;
510 static int coroutine_fn
511 blkdebug_co_preadv(BlockDriverState *bs, uint64_t offset, uint64_t bytes,
512 QEMUIOVector *qiov, int flags)
514 int err;
516 /* Sanity check block layer guarantees */
517 assert(QEMU_IS_ALIGNED(offset, bs->bl.request_alignment));
518 assert(QEMU_IS_ALIGNED(bytes, bs->bl.request_alignment));
519 if (bs->bl.max_transfer) {
520 assert(bytes <= bs->bl.max_transfer);
523 err = rule_check(bs, offset, bytes);
524 if (err) {
525 return err;
528 return bdrv_co_preadv(bs->file, offset, bytes, qiov, flags);
531 static int coroutine_fn
532 blkdebug_co_pwritev(BlockDriverState *bs, uint64_t offset, uint64_t bytes,
533 QEMUIOVector *qiov, int flags)
535 int err;
537 /* Sanity check block layer guarantees */
538 assert(QEMU_IS_ALIGNED(offset, bs->bl.request_alignment));
539 assert(QEMU_IS_ALIGNED(bytes, bs->bl.request_alignment));
540 if (bs->bl.max_transfer) {
541 assert(bytes <= bs->bl.max_transfer);
544 err = rule_check(bs, offset, bytes);
545 if (err) {
546 return err;
549 return bdrv_co_pwritev(bs->file, offset, bytes, qiov, flags);
552 static int blkdebug_co_flush(BlockDriverState *bs)
554 int err = rule_check(bs, 0, 0);
556 if (err) {
557 return err;
560 return bdrv_co_flush(bs->file->bs);
563 static int coroutine_fn blkdebug_co_pwrite_zeroes(BlockDriverState *bs,
564 int64_t offset, int bytes,
565 BdrvRequestFlags flags)
567 uint32_t align = MAX(bs->bl.request_alignment,
568 bs->bl.pwrite_zeroes_alignment);
569 int err;
571 /* Only pass through requests that are larger than requested
572 * preferred alignment (so that we test the fallback to writes on
573 * unaligned portions), and check that the block layer never hands
574 * us anything unaligned that crosses an alignment boundary. */
575 if (bytes < align) {
576 assert(QEMU_IS_ALIGNED(offset, align) ||
577 QEMU_IS_ALIGNED(offset + bytes, align) ||
578 DIV_ROUND_UP(offset, align) ==
579 DIV_ROUND_UP(offset + bytes, align));
580 return -ENOTSUP;
582 assert(QEMU_IS_ALIGNED(offset, align));
583 assert(QEMU_IS_ALIGNED(bytes, align));
584 if (bs->bl.max_pwrite_zeroes) {
585 assert(bytes <= bs->bl.max_pwrite_zeroes);
588 err = rule_check(bs, offset, bytes);
589 if (err) {
590 return err;
593 return bdrv_co_pwrite_zeroes(bs->file, offset, bytes, flags);
596 static int coroutine_fn blkdebug_co_pdiscard(BlockDriverState *bs,
597 int64_t offset, int bytes)
599 uint32_t align = bs->bl.pdiscard_alignment;
600 int err;
602 /* Only pass through requests that are larger than requested
603 * minimum alignment, and ensure that unaligned requests do not
604 * cross optimum discard boundaries. */
605 if (bytes < bs->bl.request_alignment) {
606 assert(QEMU_IS_ALIGNED(offset, align) ||
607 QEMU_IS_ALIGNED(offset + bytes, align) ||
608 DIV_ROUND_UP(offset, align) ==
609 DIV_ROUND_UP(offset + bytes, align));
610 return -ENOTSUP;
612 assert(QEMU_IS_ALIGNED(offset, bs->bl.request_alignment));
613 assert(QEMU_IS_ALIGNED(bytes, bs->bl.request_alignment));
614 if (align && bytes >= align) {
615 assert(QEMU_IS_ALIGNED(offset, align));
616 assert(QEMU_IS_ALIGNED(bytes, align));
618 if (bs->bl.max_pdiscard) {
619 assert(bytes <= bs->bl.max_pdiscard);
622 err = rule_check(bs, offset, bytes);
623 if (err) {
624 return err;
627 return bdrv_co_pdiscard(bs->file->bs, offset, bytes);
630 static int64_t coroutine_fn blkdebug_co_get_block_status(
631 BlockDriverState *bs, int64_t sector_num, int nb_sectors, int *pnum,
632 BlockDriverState **file)
634 assert(QEMU_IS_ALIGNED(sector_num | nb_sectors,
635 DIV_ROUND_UP(bs->bl.request_alignment,
636 BDRV_SECTOR_SIZE)));
637 return bdrv_co_get_block_status_from_file(bs, sector_num, nb_sectors,
638 pnum, file);
641 static void blkdebug_close(BlockDriverState *bs)
643 BDRVBlkdebugState *s = bs->opaque;
644 BlkdebugRule *rule, *next;
645 int i;
647 for (i = 0; i < BLKDBG__MAX; i++) {
648 QLIST_FOREACH_SAFE(rule, &s->rules[i], next, next) {
649 remove_rule(rule);
653 g_free(s->config_file);
656 static void suspend_request(BlockDriverState *bs, BlkdebugRule *rule)
658 BDRVBlkdebugState *s = bs->opaque;
659 BlkdebugSuspendedReq r;
661 r = (BlkdebugSuspendedReq) {
662 .co = qemu_coroutine_self(),
663 .tag = g_strdup(rule->options.suspend.tag),
666 remove_rule(rule);
667 QLIST_INSERT_HEAD(&s->suspended_reqs, &r, next);
669 if (!qtest_enabled()) {
670 printf("blkdebug: Suspended request '%s'\n", r.tag);
672 qemu_coroutine_yield();
673 if (!qtest_enabled()) {
674 printf("blkdebug: Resuming request '%s'\n", r.tag);
677 QLIST_REMOVE(&r, next);
678 g_free(r.tag);
681 static bool process_rule(BlockDriverState *bs, struct BlkdebugRule *rule,
682 bool injected)
684 BDRVBlkdebugState *s = bs->opaque;
686 /* Only process rules for the current state */
687 if (rule->state && rule->state != s->state) {
688 return injected;
691 /* Take the action */
692 switch (rule->action) {
693 case ACTION_INJECT_ERROR:
694 if (!injected) {
695 QSIMPLEQ_INIT(&s->active_rules);
696 injected = true;
698 QSIMPLEQ_INSERT_HEAD(&s->active_rules, rule, active_next);
699 break;
701 case ACTION_SET_STATE:
702 s->new_state = rule->options.set_state.new_state;
703 break;
705 case ACTION_SUSPEND:
706 suspend_request(bs, rule);
707 break;
709 return injected;
712 static void blkdebug_debug_event(BlockDriverState *bs, BlkdebugEvent event)
714 BDRVBlkdebugState *s = bs->opaque;
715 struct BlkdebugRule *rule, *next;
716 bool injected;
718 assert((int)event >= 0 && event < BLKDBG__MAX);
720 injected = false;
721 s->new_state = s->state;
722 QLIST_FOREACH_SAFE(rule, &s->rules[event], next, next) {
723 injected = process_rule(bs, rule, injected);
725 s->state = s->new_state;
728 static int blkdebug_debug_breakpoint(BlockDriverState *bs, const char *event,
729 const char *tag)
731 BDRVBlkdebugState *s = bs->opaque;
732 struct BlkdebugRule *rule;
733 int blkdebug_event;
735 blkdebug_event = qapi_enum_parse(&BlkdebugEvent_lookup, event, -1, NULL);
736 if (blkdebug_event < 0) {
737 return -ENOENT;
740 rule = g_malloc(sizeof(*rule));
741 *rule = (struct BlkdebugRule) {
742 .event = blkdebug_event,
743 .action = ACTION_SUSPEND,
744 .state = 0,
745 .options.suspend.tag = g_strdup(tag),
748 QLIST_INSERT_HEAD(&s->rules[blkdebug_event], rule, next);
750 return 0;
753 static int blkdebug_debug_resume(BlockDriverState *bs, const char *tag)
755 BDRVBlkdebugState *s = bs->opaque;
756 BlkdebugSuspendedReq *r, *next;
758 QLIST_FOREACH_SAFE(r, &s->suspended_reqs, next, next) {
759 if (!strcmp(r->tag, tag)) {
760 qemu_coroutine_enter(r->co);
761 return 0;
764 return -ENOENT;
767 static int blkdebug_debug_remove_breakpoint(BlockDriverState *bs,
768 const char *tag)
770 BDRVBlkdebugState *s = bs->opaque;
771 BlkdebugSuspendedReq *r, *r_next;
772 BlkdebugRule *rule, *next;
773 int i, ret = -ENOENT;
775 for (i = 0; i < BLKDBG__MAX; i++) {
776 QLIST_FOREACH_SAFE(rule, &s->rules[i], next, next) {
777 if (rule->action == ACTION_SUSPEND &&
778 !strcmp(rule->options.suspend.tag, tag)) {
779 remove_rule(rule);
780 ret = 0;
784 QLIST_FOREACH_SAFE(r, &s->suspended_reqs, next, r_next) {
785 if (!strcmp(r->tag, tag)) {
786 qemu_coroutine_enter(r->co);
787 ret = 0;
790 return ret;
793 static bool blkdebug_debug_is_suspended(BlockDriverState *bs, const char *tag)
795 BDRVBlkdebugState *s = bs->opaque;
796 BlkdebugSuspendedReq *r;
798 QLIST_FOREACH(r, &s->suspended_reqs, next) {
799 if (!strcmp(r->tag, tag)) {
800 return true;
803 return false;
806 static int64_t blkdebug_getlength(BlockDriverState *bs)
808 return bdrv_getlength(bs->file->bs);
811 static void blkdebug_refresh_filename(BlockDriverState *bs, QDict *options)
813 BDRVBlkdebugState *s = bs->opaque;
814 QDict *opts;
815 const QDictEntry *e;
816 bool force_json = false;
818 for (e = qdict_first(options); e; e = qdict_next(options, e)) {
819 if (strcmp(qdict_entry_key(e), "config") &&
820 strcmp(qdict_entry_key(e), "x-image"))
822 force_json = true;
823 break;
827 if (force_json && !bs->file->bs->full_open_options) {
828 /* The config file cannot be recreated, so creating a plain filename
829 * is impossible */
830 return;
833 if (!force_json && bs->file->bs->exact_filename[0]) {
834 int ret = snprintf(bs->exact_filename, sizeof(bs->exact_filename),
835 "blkdebug:%s:%s", s->config_file ?: "",
836 bs->file->bs->exact_filename);
837 if (ret >= sizeof(bs->exact_filename)) {
838 /* An overflow makes the filename unusable, so do not report any */
839 bs->exact_filename[0] = 0;
843 opts = qdict_new();
844 qdict_put_str(opts, "driver", "blkdebug");
846 QINCREF(bs->file->bs->full_open_options);
847 qdict_put(opts, "image", bs->file->bs->full_open_options);
849 for (e = qdict_first(options); e; e = qdict_next(options, e)) {
850 if (strcmp(qdict_entry_key(e), "x-image")) {
851 qobject_incref(qdict_entry_value(e));
852 qdict_put_obj(opts, qdict_entry_key(e), qdict_entry_value(e));
856 bs->full_open_options = opts;
859 static void blkdebug_refresh_limits(BlockDriverState *bs, Error **errp)
861 BDRVBlkdebugState *s = bs->opaque;
863 if (s->align) {
864 bs->bl.request_alignment = s->align;
866 if (s->max_transfer) {
867 bs->bl.max_transfer = s->max_transfer;
869 if (s->opt_write_zero) {
870 bs->bl.pwrite_zeroes_alignment = s->opt_write_zero;
872 if (s->max_write_zero) {
873 bs->bl.max_pwrite_zeroes = s->max_write_zero;
875 if (s->opt_discard) {
876 bs->bl.pdiscard_alignment = s->opt_discard;
878 if (s->max_discard) {
879 bs->bl.max_pdiscard = s->max_discard;
883 static int blkdebug_reopen_prepare(BDRVReopenState *reopen_state,
884 BlockReopenQueue *queue, Error **errp)
886 return 0;
889 static BlockDriver bdrv_blkdebug = {
890 .format_name = "blkdebug",
891 .protocol_name = "blkdebug",
892 .instance_size = sizeof(BDRVBlkdebugState),
893 .is_filter = true,
895 .bdrv_parse_filename = blkdebug_parse_filename,
896 .bdrv_file_open = blkdebug_open,
897 .bdrv_close = blkdebug_close,
898 .bdrv_reopen_prepare = blkdebug_reopen_prepare,
899 .bdrv_child_perm = bdrv_filter_default_perms,
901 .bdrv_getlength = blkdebug_getlength,
902 .bdrv_refresh_filename = blkdebug_refresh_filename,
903 .bdrv_refresh_limits = blkdebug_refresh_limits,
905 .bdrv_co_preadv = blkdebug_co_preadv,
906 .bdrv_co_pwritev = blkdebug_co_pwritev,
907 .bdrv_co_flush_to_disk = blkdebug_co_flush,
908 .bdrv_co_pwrite_zeroes = blkdebug_co_pwrite_zeroes,
909 .bdrv_co_pdiscard = blkdebug_co_pdiscard,
910 .bdrv_co_get_block_status = blkdebug_co_get_block_status,
912 .bdrv_debug_event = blkdebug_debug_event,
913 .bdrv_debug_breakpoint = blkdebug_debug_breakpoint,
914 .bdrv_debug_remove_breakpoint
915 = blkdebug_debug_remove_breakpoint,
916 .bdrv_debug_resume = blkdebug_debug_resume,
917 .bdrv_debug_is_suspended = blkdebug_debug_is_suspended,
920 static void bdrv_blkdebug_init(void)
922 bdrv_register(&bdrv_blkdebug);
925 block_init(bdrv_blkdebug_init);