2 * Block protocol for I/O error injection
4 * Copyright (c) 2010 Kevin Wolf <kwolf@redhat.com>
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
25 #include "qemu-common.h"
26 #include "qemu/config-file.h"
27 #include "block/block_int.h"
28 #include "qemu/module.h"
29 #include "qapi/qmp/qbool.h"
30 #include "qapi/qmp/qdict.h"
31 #include "qapi/qmp/qint.h"
32 #include "qapi/qmp/qstring.h"
34 typedef struct BDRVBlkdebugState
{
38 QLIST_HEAD(, BlkdebugRule
) rules
[BLKDBG_EVENT_MAX
];
39 QSIMPLEQ_HEAD(, BlkdebugRule
) active_rules
;
40 QLIST_HEAD(, BlkdebugSuspendedReq
) suspended_reqs
;
43 typedef struct BlkdebugAIOCB
{
44 BlockDriverAIOCB common
;
49 typedef struct BlkdebugSuspendedReq
{
52 QLIST_ENTRY(BlkdebugSuspendedReq
) next
;
53 } BlkdebugSuspendedReq
;
55 static void blkdebug_aio_cancel(BlockDriverAIOCB
*blockacb
);
57 static const AIOCBInfo blkdebug_aiocb_info
= {
58 .aiocb_size
= sizeof(BlkdebugAIOCB
),
59 .cancel
= blkdebug_aio_cancel
,
68 typedef struct BlkdebugRule
{
86 QLIST_ENTRY(BlkdebugRule
) next
;
87 QSIMPLEQ_ENTRY(BlkdebugRule
) active_next
;
90 static QemuOptsList inject_error_opts
= {
91 .name
= "inject-error",
92 .head
= QTAILQ_HEAD_INITIALIZER(inject_error_opts
.head
),
96 .type
= QEMU_OPT_STRING
,
100 .type
= QEMU_OPT_NUMBER
,
104 .type
= QEMU_OPT_NUMBER
,
108 .type
= QEMU_OPT_NUMBER
,
112 .type
= QEMU_OPT_BOOL
,
115 .name
= "immediately",
116 .type
= QEMU_OPT_BOOL
,
118 { /* end of list */ }
122 static QemuOptsList set_state_opts
= {
124 .head
= QTAILQ_HEAD_INITIALIZER(set_state_opts
.head
),
128 .type
= QEMU_OPT_STRING
,
132 .type
= QEMU_OPT_NUMBER
,
136 .type
= QEMU_OPT_NUMBER
,
138 { /* end of list */ }
142 static QemuOptsList
*config_groups
[] = {
148 static const char *event_names
[BLKDBG_EVENT_MAX
] = {
149 [BLKDBG_L1_UPDATE
] = "l1_update",
150 [BLKDBG_L1_GROW_ALLOC_TABLE
] = "l1_grow.alloc_table",
151 [BLKDBG_L1_GROW_WRITE_TABLE
] = "l1_grow.write_table",
152 [BLKDBG_L1_GROW_ACTIVATE_TABLE
] = "l1_grow.activate_table",
154 [BLKDBG_L2_LOAD
] = "l2_load",
155 [BLKDBG_L2_UPDATE
] = "l2_update",
156 [BLKDBG_L2_UPDATE_COMPRESSED
] = "l2_update_compressed",
157 [BLKDBG_L2_ALLOC_COW_READ
] = "l2_alloc.cow_read",
158 [BLKDBG_L2_ALLOC_WRITE
] = "l2_alloc.write",
160 [BLKDBG_READ_AIO
] = "read_aio",
161 [BLKDBG_READ_BACKING_AIO
] = "read_backing_aio",
162 [BLKDBG_READ_COMPRESSED
] = "read_compressed",
164 [BLKDBG_WRITE_AIO
] = "write_aio",
165 [BLKDBG_WRITE_COMPRESSED
] = "write_compressed",
167 [BLKDBG_VMSTATE_LOAD
] = "vmstate_load",
168 [BLKDBG_VMSTATE_SAVE
] = "vmstate_save",
170 [BLKDBG_COW_READ
] = "cow_read",
171 [BLKDBG_COW_WRITE
] = "cow_write",
173 [BLKDBG_REFTABLE_LOAD
] = "reftable_load",
174 [BLKDBG_REFTABLE_GROW
] = "reftable_grow",
175 [BLKDBG_REFTABLE_UPDATE
] = "reftable_update",
177 [BLKDBG_REFBLOCK_LOAD
] = "refblock_load",
178 [BLKDBG_REFBLOCK_UPDATE
] = "refblock_update",
179 [BLKDBG_REFBLOCK_UPDATE_PART
] = "refblock_update_part",
180 [BLKDBG_REFBLOCK_ALLOC
] = "refblock_alloc",
181 [BLKDBG_REFBLOCK_ALLOC_HOOKUP
] = "refblock_alloc.hookup",
182 [BLKDBG_REFBLOCK_ALLOC_WRITE
] = "refblock_alloc.write",
183 [BLKDBG_REFBLOCK_ALLOC_WRITE_BLOCKS
] = "refblock_alloc.write_blocks",
184 [BLKDBG_REFBLOCK_ALLOC_WRITE_TABLE
] = "refblock_alloc.write_table",
185 [BLKDBG_REFBLOCK_ALLOC_SWITCH_TABLE
] = "refblock_alloc.switch_table",
187 [BLKDBG_CLUSTER_ALLOC
] = "cluster_alloc",
188 [BLKDBG_CLUSTER_ALLOC_BYTES
] = "cluster_alloc_bytes",
189 [BLKDBG_CLUSTER_FREE
] = "cluster_free",
191 [BLKDBG_FLUSH_TO_OS
] = "flush_to_os",
192 [BLKDBG_FLUSH_TO_DISK
] = "flush_to_disk",
194 [BLKDBG_PWRITEV_RMW_HEAD
] = "pwritev_rmw.head",
195 [BLKDBG_PWRITEV_RMW_AFTER_HEAD
] = "pwritev_rmw.after_head",
196 [BLKDBG_PWRITEV_RMW_TAIL
] = "pwritev_rmw.tail",
197 [BLKDBG_PWRITEV_RMW_AFTER_TAIL
] = "pwritev_rmw.after_tail",
198 [BLKDBG_PWRITEV
] = "pwritev",
199 [BLKDBG_PWRITEV_ZERO
] = "pwritev_zero",
200 [BLKDBG_PWRITEV_DONE
] = "pwritev_done",
203 static int get_event_by_name(const char *name
, BlkDebugEvent
*event
)
207 for (i
= 0; i
< BLKDBG_EVENT_MAX
; i
++) {
208 if (!strcmp(event_names
[i
], name
)) {
217 struct add_rule_data
{
218 BDRVBlkdebugState
*s
;
222 static int add_rule(QemuOpts
*opts
, void *opaque
)
224 struct add_rule_data
*d
= opaque
;
225 BDRVBlkdebugState
*s
= d
->s
;
226 const char* event_name
;
228 struct BlkdebugRule
*rule
;
230 /* Find the right event for the rule */
231 event_name
= qemu_opt_get(opts
, "event");
232 if (!event_name
|| get_event_by_name(event_name
, &event
) < 0) {
236 /* Set attributes common for all actions */
237 rule
= g_malloc0(sizeof(*rule
));
238 *rule
= (struct BlkdebugRule
) {
241 .state
= qemu_opt_get_number(opts
, "state", 0),
244 /* Parse action-specific options */
246 case ACTION_INJECT_ERROR
:
247 rule
->options
.inject
.error
= qemu_opt_get_number(opts
, "errno", EIO
);
248 rule
->options
.inject
.once
= qemu_opt_get_bool(opts
, "once", 0);
249 rule
->options
.inject
.immediately
=
250 qemu_opt_get_bool(opts
, "immediately", 0);
251 rule
->options
.inject
.sector
= qemu_opt_get_number(opts
, "sector", -1);
254 case ACTION_SET_STATE
:
255 rule
->options
.set_state
.new_state
=
256 qemu_opt_get_number(opts
, "new_state", 0);
260 rule
->options
.suspend
.tag
=
261 g_strdup(qemu_opt_get(opts
, "tag"));
266 QLIST_INSERT_HEAD(&s
->rules
[event
], rule
, next
);
271 static void remove_rule(BlkdebugRule
*rule
)
273 switch (rule
->action
) {
274 case ACTION_INJECT_ERROR
:
275 case ACTION_SET_STATE
:
278 g_free(rule
->options
.suspend
.tag
);
282 QLIST_REMOVE(rule
, next
);
286 static int read_config(BDRVBlkdebugState
*s
, const char *filename
,
287 QDict
*options
, Error
**errp
)
291 struct add_rule_data d
;
292 Error
*local_err
= NULL
;
295 f
= fopen(filename
, "r");
297 error_setg_errno(errp
, errno
, "Could not read blkdebug config file");
301 ret
= qemu_config_parse(f
, config_groups
, filename
);
303 error_setg(errp
, "Could not parse blkdebug config file");
309 qemu_config_parse_qdict(options
, config_groups
, &local_err
);
311 error_propagate(errp
, local_err
);
317 d
.action
= ACTION_INJECT_ERROR
;
318 qemu_opts_foreach(&inject_error_opts
, add_rule
, &d
, 0);
320 d
.action
= ACTION_SET_STATE
;
321 qemu_opts_foreach(&set_state_opts
, add_rule
, &d
, 0);
325 qemu_opts_reset(&inject_error_opts
);
326 qemu_opts_reset(&set_state_opts
);
333 /* Valid blkdebug filenames look like blkdebug:path/to/config:path/to/image */
334 static void blkdebug_parse_filename(const char *filename
, QDict
*options
,
339 /* Parse the blkdebug: prefix */
340 if (!strstart(filename
, "blkdebug:", &filename
)) {
341 /* There was no prefix; therefore, all options have to be already
342 present in the QDict (except for the filename) */
343 qdict_put(options
, "x-image", qstring_from_str(filename
));
347 /* Parse config file path */
348 c
= strchr(filename
, ':');
350 error_setg(errp
, "blkdebug requires both config file and image path");
355 QString
*config_path
;
356 config_path
= qstring_from_substr(filename
, 0, c
- filename
- 1);
357 qdict_put(options
, "config", config_path
);
360 /* TODO Allow multi-level nesting and set file.filename here */
362 qdict_put(options
, "x-image", qstring_from_str(filename
));
365 static QemuOptsList runtime_opts
= {
367 .head
= QTAILQ_HEAD_INITIALIZER(runtime_opts
.head
),
371 .type
= QEMU_OPT_STRING
,
372 .help
= "Path to the configuration file",
376 .type
= QEMU_OPT_STRING
,
377 .help
= "[internal use only, will be removed]",
381 .type
= QEMU_OPT_SIZE
,
382 .help
= "Required alignment in bytes",
384 { /* end of list */ }
388 static int blkdebug_open(BlockDriverState
*bs
, QDict
*options
, int flags
,
391 BDRVBlkdebugState
*s
= bs
->opaque
;
393 Error
*local_err
= NULL
;
398 opts
= qemu_opts_create(&runtime_opts
, NULL
, 0, &error_abort
);
399 qemu_opts_absorb_qdict(opts
, options
, &local_err
);
401 error_propagate(errp
, local_err
);
406 /* Read rules from config file or command line options */
407 config
= qemu_opt_get(opts
, "config");
408 ret
= read_config(s
, config
, options
, errp
);
413 /* Set initial state */
416 /* Open the backing file */
417 assert(bs
->file
== NULL
);
418 ret
= bdrv_open_image(&bs
->file
, qemu_opt_get(opts
, "x-image"), options
, "image",
419 flags
| BDRV_O_PROTOCOL
, false, &local_err
);
421 error_propagate(errp
, local_err
);
425 /* Set request alignment */
426 align
= qemu_opt_get_size(opts
, "align", bs
->request_alignment
);
427 if (align
> 0 && align
< INT_MAX
&& !(align
& (align
- 1))) {
428 bs
->request_alignment
= align
;
430 error_setg(errp
, "Invalid alignment");
439 bdrv_unref(bs
->file
);
445 static void error_callback_bh(void *opaque
)
447 struct BlkdebugAIOCB
*acb
= opaque
;
448 qemu_bh_delete(acb
->bh
);
449 acb
->common
.cb(acb
->common
.opaque
, acb
->ret
);
450 qemu_aio_release(acb
);
453 static void blkdebug_aio_cancel(BlockDriverAIOCB
*blockacb
)
455 BlkdebugAIOCB
*acb
= container_of(blockacb
, BlkdebugAIOCB
, common
);
457 qemu_bh_delete(acb
->bh
);
460 qemu_aio_release(acb
);
463 static BlockDriverAIOCB
*inject_error(BlockDriverState
*bs
,
464 BlockDriverCompletionFunc
*cb
, void *opaque
, BlkdebugRule
*rule
)
466 BDRVBlkdebugState
*s
= bs
->opaque
;
467 int error
= rule
->options
.inject
.error
;
468 struct BlkdebugAIOCB
*acb
;
471 if (rule
->options
.inject
.once
) {
472 QSIMPLEQ_INIT(&s
->active_rules
);
475 if (rule
->options
.inject
.immediately
) {
479 acb
= qemu_aio_get(&blkdebug_aiocb_info
, bs
, cb
, opaque
);
482 bh
= aio_bh_new(bdrv_get_aio_context(bs
), error_callback_bh
, acb
);
484 qemu_bh_schedule(bh
);
489 static BlockDriverAIOCB
*blkdebug_aio_readv(BlockDriverState
*bs
,
490 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
491 BlockDriverCompletionFunc
*cb
, void *opaque
)
493 BDRVBlkdebugState
*s
= bs
->opaque
;
494 BlkdebugRule
*rule
= NULL
;
496 QSIMPLEQ_FOREACH(rule
, &s
->active_rules
, active_next
) {
497 if (rule
->options
.inject
.sector
== -1 ||
498 (rule
->options
.inject
.sector
>= sector_num
&&
499 rule
->options
.inject
.sector
< sector_num
+ nb_sectors
)) {
504 if (rule
&& rule
->options
.inject
.error
) {
505 return inject_error(bs
, cb
, opaque
, rule
);
508 return bdrv_aio_readv(bs
->file
, sector_num
, qiov
, nb_sectors
, cb
, opaque
);
511 static BlockDriverAIOCB
*blkdebug_aio_writev(BlockDriverState
*bs
,
512 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
513 BlockDriverCompletionFunc
*cb
, void *opaque
)
515 BDRVBlkdebugState
*s
= bs
->opaque
;
516 BlkdebugRule
*rule
= NULL
;
518 QSIMPLEQ_FOREACH(rule
, &s
->active_rules
, active_next
) {
519 if (rule
->options
.inject
.sector
== -1 ||
520 (rule
->options
.inject
.sector
>= sector_num
&&
521 rule
->options
.inject
.sector
< sector_num
+ nb_sectors
)) {
526 if (rule
&& rule
->options
.inject
.error
) {
527 return inject_error(bs
, cb
, opaque
, rule
);
530 return bdrv_aio_writev(bs
->file
, sector_num
, qiov
, nb_sectors
, cb
, opaque
);
533 static BlockDriverAIOCB
*blkdebug_aio_flush(BlockDriverState
*bs
,
534 BlockDriverCompletionFunc
*cb
, void *opaque
)
536 BDRVBlkdebugState
*s
= bs
->opaque
;
537 BlkdebugRule
*rule
= NULL
;
539 QSIMPLEQ_FOREACH(rule
, &s
->active_rules
, active_next
) {
540 if (rule
->options
.inject
.sector
== -1) {
545 if (rule
&& rule
->options
.inject
.error
) {
546 return inject_error(bs
, cb
, opaque
, rule
);
549 return bdrv_aio_flush(bs
->file
, cb
, opaque
);
553 static void blkdebug_close(BlockDriverState
*bs
)
555 BDRVBlkdebugState
*s
= bs
->opaque
;
556 BlkdebugRule
*rule
, *next
;
559 for (i
= 0; i
< BLKDBG_EVENT_MAX
; i
++) {
560 QLIST_FOREACH_SAFE(rule
, &s
->rules
[i
], next
, next
) {
566 static void suspend_request(BlockDriverState
*bs
, BlkdebugRule
*rule
)
568 BDRVBlkdebugState
*s
= bs
->opaque
;
569 BlkdebugSuspendedReq r
;
571 r
= (BlkdebugSuspendedReq
) {
572 .co
= qemu_coroutine_self(),
573 .tag
= g_strdup(rule
->options
.suspend
.tag
),
577 QLIST_INSERT_HEAD(&s
->suspended_reqs
, &r
, next
);
579 printf("blkdebug: Suspended request '%s'\n", r
.tag
);
580 qemu_coroutine_yield();
581 printf("blkdebug: Resuming request '%s'\n", r
.tag
);
583 QLIST_REMOVE(&r
, next
);
587 static bool process_rule(BlockDriverState
*bs
, struct BlkdebugRule
*rule
,
590 BDRVBlkdebugState
*s
= bs
->opaque
;
592 /* Only process rules for the current state */
593 if (rule
->state
&& rule
->state
!= s
->state
) {
597 /* Take the action */
598 switch (rule
->action
) {
599 case ACTION_INJECT_ERROR
:
601 QSIMPLEQ_INIT(&s
->active_rules
);
604 QSIMPLEQ_INSERT_HEAD(&s
->active_rules
, rule
, active_next
);
607 case ACTION_SET_STATE
:
608 s
->new_state
= rule
->options
.set_state
.new_state
;
612 suspend_request(bs
, rule
);
618 static void blkdebug_debug_event(BlockDriverState
*bs
, BlkDebugEvent event
)
620 BDRVBlkdebugState
*s
= bs
->opaque
;
621 struct BlkdebugRule
*rule
, *next
;
624 assert((int)event
>= 0 && event
< BLKDBG_EVENT_MAX
);
627 s
->new_state
= s
->state
;
628 QLIST_FOREACH_SAFE(rule
, &s
->rules
[event
], next
, next
) {
629 injected
= process_rule(bs
, rule
, injected
);
631 s
->state
= s
->new_state
;
634 static int blkdebug_debug_breakpoint(BlockDriverState
*bs
, const char *event
,
637 BDRVBlkdebugState
*s
= bs
->opaque
;
638 struct BlkdebugRule
*rule
;
639 BlkDebugEvent blkdebug_event
;
641 if (get_event_by_name(event
, &blkdebug_event
) < 0) {
646 rule
= g_malloc(sizeof(*rule
));
647 *rule
= (struct BlkdebugRule
) {
648 .event
= blkdebug_event
,
649 .action
= ACTION_SUSPEND
,
651 .options
.suspend
.tag
= g_strdup(tag
),
654 QLIST_INSERT_HEAD(&s
->rules
[blkdebug_event
], rule
, next
);
659 static int blkdebug_debug_resume(BlockDriverState
*bs
, const char *tag
)
661 BDRVBlkdebugState
*s
= bs
->opaque
;
662 BlkdebugSuspendedReq
*r
, *next
;
664 QLIST_FOREACH_SAFE(r
, &s
->suspended_reqs
, next
, next
) {
665 if (!strcmp(r
->tag
, tag
)) {
666 qemu_coroutine_enter(r
->co
, NULL
);
673 static int blkdebug_debug_remove_breakpoint(BlockDriverState
*bs
,
676 BDRVBlkdebugState
*s
= bs
->opaque
;
677 BlkdebugSuspendedReq
*r
, *r_next
;
678 BlkdebugRule
*rule
, *next
;
679 int i
, ret
= -ENOENT
;
681 for (i
= 0; i
< BLKDBG_EVENT_MAX
; i
++) {
682 QLIST_FOREACH_SAFE(rule
, &s
->rules
[i
], next
, next
) {
683 if (rule
->action
== ACTION_SUSPEND
&&
684 !strcmp(rule
->options
.suspend
.tag
, tag
)) {
690 QLIST_FOREACH_SAFE(r
, &s
->suspended_reqs
, next
, r_next
) {
691 if (!strcmp(r
->tag
, tag
)) {
692 qemu_coroutine_enter(r
->co
, NULL
);
699 static bool blkdebug_debug_is_suspended(BlockDriverState
*bs
, const char *tag
)
701 BDRVBlkdebugState
*s
= bs
->opaque
;
702 BlkdebugSuspendedReq
*r
;
704 QLIST_FOREACH(r
, &s
->suspended_reqs
, next
) {
705 if (!strcmp(r
->tag
, tag
)) {
712 static int64_t blkdebug_getlength(BlockDriverState
*bs
)
714 return bdrv_getlength(bs
->file
);
717 static void blkdebug_refresh_filename(BlockDriverState
*bs
)
719 BDRVBlkdebugState
*s
= bs
->opaque
;
720 struct BlkdebugRule
*rule
;
722 QList
*inject_error_list
= NULL
, *set_state_list
= NULL
;
723 QList
*suspend_list
= NULL
;
726 if (!bs
->file
->full_open_options
) {
727 /* The config file cannot be recreated, so creating a plain filename
733 qdict_put_obj(opts
, "driver", QOBJECT(qstring_from_str("blkdebug")));
735 QINCREF(bs
->file
->full_open_options
);
736 qdict_put_obj(opts
, "image", QOBJECT(bs
->file
->full_open_options
));
738 for (event
= 0; event
< BLKDBG_EVENT_MAX
; event
++) {
739 QLIST_FOREACH(rule
, &s
->rules
[event
], next
) {
740 if (rule
->action
== ACTION_INJECT_ERROR
) {
741 QDict
*inject_error
= qdict_new();
743 qdict_put_obj(inject_error
, "event", QOBJECT(qstring_from_str(
744 BlkdebugEvent_lookup
[rule
->event
])));
745 qdict_put_obj(inject_error
, "state",
746 QOBJECT(qint_from_int(rule
->state
)));
747 qdict_put_obj(inject_error
, "errno", QOBJECT(qint_from_int(
748 rule
->options
.inject
.error
)));
749 qdict_put_obj(inject_error
, "sector", QOBJECT(qint_from_int(
750 rule
->options
.inject
.sector
)));
751 qdict_put_obj(inject_error
, "once", QOBJECT(qbool_from_int(
752 rule
->options
.inject
.once
)));
753 qdict_put_obj(inject_error
, "immediately",
754 QOBJECT(qbool_from_int(
755 rule
->options
.inject
.immediately
)));
757 if (!inject_error_list
) {
758 inject_error_list
= qlist_new();
761 qlist_append_obj(inject_error_list
, QOBJECT(inject_error
));
762 } else if (rule
->action
== ACTION_SET_STATE
) {
763 QDict
*set_state
= qdict_new();
765 qdict_put_obj(set_state
, "event", QOBJECT(qstring_from_str(
766 BlkdebugEvent_lookup
[rule
->event
])));
767 qdict_put_obj(set_state
, "state",
768 QOBJECT(qint_from_int(rule
->state
)));
769 qdict_put_obj(set_state
, "new_state", QOBJECT(qint_from_int(
770 rule
->options
.set_state
.new_state
)));
772 if (!set_state_list
) {
773 set_state_list
= qlist_new();
776 qlist_append_obj(set_state_list
, QOBJECT(set_state
));
777 } else if (rule
->action
== ACTION_SUSPEND
) {
778 QDict
*suspend
= qdict_new();
780 qdict_put_obj(suspend
, "event", QOBJECT(qstring_from_str(
781 BlkdebugEvent_lookup
[rule
->event
])));
782 qdict_put_obj(suspend
, "state",
783 QOBJECT(qint_from_int(rule
->state
)));
784 qdict_put_obj(suspend
, "tag", QOBJECT(qstring_from_str(
785 rule
->options
.suspend
.tag
)));
788 suspend_list
= qlist_new();
791 qlist_append_obj(suspend_list
, QOBJECT(suspend
));
796 if (inject_error_list
) {
797 qdict_put_obj(opts
, "inject-error", QOBJECT(inject_error_list
));
799 if (set_state_list
) {
800 qdict_put_obj(opts
, "set-state", QOBJECT(set_state_list
));
803 qdict_put_obj(opts
, "suspend", QOBJECT(suspend_list
));
806 bs
->full_open_options
= opts
;
809 static BlockDriver bdrv_blkdebug
= {
810 .format_name
= "blkdebug",
811 .protocol_name
= "blkdebug",
812 .instance_size
= sizeof(BDRVBlkdebugState
),
814 .bdrv_parse_filename
= blkdebug_parse_filename
,
815 .bdrv_file_open
= blkdebug_open
,
816 .bdrv_close
= blkdebug_close
,
817 .bdrv_getlength
= blkdebug_getlength
,
818 .bdrv_refresh_filename
= blkdebug_refresh_filename
,
820 .bdrv_aio_readv
= blkdebug_aio_readv
,
821 .bdrv_aio_writev
= blkdebug_aio_writev
,
822 .bdrv_aio_flush
= blkdebug_aio_flush
,
824 .bdrv_debug_event
= blkdebug_debug_event
,
825 .bdrv_debug_breakpoint
= blkdebug_debug_breakpoint
,
826 .bdrv_debug_remove_breakpoint
827 = blkdebug_debug_remove_breakpoint
,
828 .bdrv_debug_resume
= blkdebug_debug_resume
,
829 .bdrv_debug_is_suspended
= blkdebug_debug_is_suspended
,
832 static void bdrv_blkdebug_init(void)
834 bdrv_register(&bdrv_blkdebug
);
837 block_init(bdrv_blkdebug_init
);