xref: /openbmc/qemu/block/blkdebug.c (revision 9c5ce8db2e5c2769ed2fd3d91928dd1853b5ce7c)
1 /*
2  * Block protocol for I/O error injection
3  *
4  * Copyright (c) 2010 Kevin Wolf <kwolf@redhat.com>
5  *
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:
12  *
13  * The above copyright notice and this permission notice shall be included in
14  * all copies or substantial portions of the Software.
15  *
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
22  * THE SOFTWARE.
23  */
24 
25 #include "qemu/osdep.h"
26 #include "qapi/error.h"
27 #include "qemu/cutils.h"
28 #include "qemu/config-file.h"
29 #include "block/block_int.h"
30 #include "qemu/module.h"
31 #include "qapi/qmp/qbool.h"
32 #include "qapi/qmp/qdict.h"
33 #include "qapi/qmp/qint.h"
34 #include "qapi/qmp/qstring.h"
35 #include "sysemu/qtest.h"
36 
37 typedef struct BDRVBlkdebugState {
38     int state;
39     int new_state;
40     int align;
41 
42     /* For blkdebug_refresh_filename() */
43     char *config_file;
44 
45     QLIST_HEAD(, BlkdebugRule) rules[BLKDBG__MAX];
46     QSIMPLEQ_HEAD(, BlkdebugRule) active_rules;
47     QLIST_HEAD(, BlkdebugSuspendedReq) suspended_reqs;
48 } BDRVBlkdebugState;
49 
50 typedef struct BlkdebugAIOCB {
51     BlockAIOCB common;
52     QEMUBH *bh;
53     int ret;
54 } BlkdebugAIOCB;
55 
56 typedef struct BlkdebugSuspendedReq {
57     Coroutine *co;
58     char *tag;
59     QLIST_ENTRY(BlkdebugSuspendedReq) next;
60 } BlkdebugSuspendedReq;
61 
62 static const AIOCBInfo blkdebug_aiocb_info = {
63     .aiocb_size    = sizeof(BlkdebugAIOCB),
64 };
65 
66 enum {
67     ACTION_INJECT_ERROR,
68     ACTION_SET_STATE,
69     ACTION_SUSPEND,
70 };
71 
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 sector;
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;
93 
94 static QemuOptsList inject_error_opts = {
95     .name = "inject-error",
96     .head = QTAILQ_HEAD_INITIALIZER(inject_error_opts.head),
97     .desc = {
98         {
99             .name = "event",
100             .type = QEMU_OPT_STRING,
101         },
102         {
103             .name = "state",
104             .type = QEMU_OPT_NUMBER,
105         },
106         {
107             .name = "errno",
108             .type = QEMU_OPT_NUMBER,
109         },
110         {
111             .name = "sector",
112             .type = QEMU_OPT_NUMBER,
113         },
114         {
115             .name = "once",
116             .type = QEMU_OPT_BOOL,
117         },
118         {
119             .name = "immediately",
120             .type = QEMU_OPT_BOOL,
121         },
122         { /* end of list */ }
123     },
124 };
125 
126 static QemuOptsList set_state_opts = {
127     .name = "set-state",
128     .head = QTAILQ_HEAD_INITIALIZER(set_state_opts.head),
129     .desc = {
130         {
131             .name = "event",
132             .type = QEMU_OPT_STRING,
133         },
134         {
135             .name = "state",
136             .type = QEMU_OPT_NUMBER,
137         },
138         {
139             .name = "new_state",
140             .type = QEMU_OPT_NUMBER,
141         },
142         { /* end of list */ }
143     },
144 };
145 
146 static QemuOptsList *config_groups[] = {
147     &inject_error_opts,
148     &set_state_opts,
149     NULL
150 };
151 
152 static int get_event_by_name(const char *name, BlkdebugEvent *event)
153 {
154     int i;
155 
156     for (i = 0; i < BLKDBG__MAX; i++) {
157         if (!strcmp(BlkdebugEvent_lookup[i], name)) {
158             *event = i;
159             return 0;
160         }
161     }
162 
163     return -1;
164 }
165 
166 struct add_rule_data {
167     BDRVBlkdebugState *s;
168     int action;
169 };
170 
171 static int add_rule(void *opaque, QemuOpts *opts, Error **errp)
172 {
173     struct add_rule_data *d = opaque;
174     BDRVBlkdebugState *s = d->s;
175     const char* event_name;
176     BlkdebugEvent event;
177     struct BlkdebugRule *rule;
178 
179     /* Find the right event for the rule */
180     event_name = qemu_opt_get(opts, "event");
181     if (!event_name) {
182         error_setg(errp, "Missing event name for rule");
183         return -1;
184     } else if (get_event_by_name(event_name, &event) < 0) {
185         error_setg(errp, "Invalid event name \"%s\"", event_name);
186         return -1;
187     }
188 
189     /* Set attributes common for all actions */
190     rule = g_malloc0(sizeof(*rule));
191     *rule = (struct BlkdebugRule) {
192         .event  = event,
193         .action = d->action,
194         .state  = qemu_opt_get_number(opts, "state", 0),
195     };
196 
197     /* Parse action-specific options */
198     switch (d->action) {
199     case ACTION_INJECT_ERROR:
200         rule->options.inject.error = qemu_opt_get_number(opts, "errno", EIO);
201         rule->options.inject.once  = qemu_opt_get_bool(opts, "once", 0);
202         rule->options.inject.immediately =
203             qemu_opt_get_bool(opts, "immediately", 0);
204         rule->options.inject.sector = qemu_opt_get_number(opts, "sector", -1);
205         break;
206 
207     case ACTION_SET_STATE:
208         rule->options.set_state.new_state =
209             qemu_opt_get_number(opts, "new_state", 0);
210         break;
211 
212     case ACTION_SUSPEND:
213         rule->options.suspend.tag =
214             g_strdup(qemu_opt_get(opts, "tag"));
215         break;
216     };
217 
218     /* Add the rule */
219     QLIST_INSERT_HEAD(&s->rules[event], rule, next);
220 
221     return 0;
222 }
223 
224 static void remove_rule(BlkdebugRule *rule)
225 {
226     switch (rule->action) {
227     case ACTION_INJECT_ERROR:
228     case ACTION_SET_STATE:
229         break;
230     case ACTION_SUSPEND:
231         g_free(rule->options.suspend.tag);
232         break;
233     }
234 
235     QLIST_REMOVE(rule, next);
236     g_free(rule);
237 }
238 
239 static int read_config(BDRVBlkdebugState *s, const char *filename,
240                        QDict *options, Error **errp)
241 {
242     FILE *f = NULL;
243     int ret;
244     struct add_rule_data d;
245     Error *local_err = NULL;
246 
247     if (filename) {
248         f = fopen(filename, "r");
249         if (f == NULL) {
250             error_setg_errno(errp, errno, "Could not read blkdebug config file");
251             return -errno;
252         }
253 
254         ret = qemu_config_parse(f, config_groups, filename);
255         if (ret < 0) {
256             error_setg(errp, "Could not parse blkdebug config file");
257             ret = -EINVAL;
258             goto fail;
259         }
260     }
261 
262     qemu_config_parse_qdict(options, config_groups, &local_err);
263     if (local_err) {
264         error_propagate(errp, local_err);
265         ret = -EINVAL;
266         goto fail;
267     }
268 
269     d.s = s;
270     d.action = ACTION_INJECT_ERROR;
271     qemu_opts_foreach(&inject_error_opts, add_rule, &d, &local_err);
272     if (local_err) {
273         error_propagate(errp, local_err);
274         ret = -EINVAL;
275         goto fail;
276     }
277 
278     d.action = ACTION_SET_STATE;
279     qemu_opts_foreach(&set_state_opts, add_rule, &d, &local_err);
280     if (local_err) {
281         error_propagate(errp, local_err);
282         ret = -EINVAL;
283         goto fail;
284     }
285 
286     ret = 0;
287 fail:
288     qemu_opts_reset(&inject_error_opts);
289     qemu_opts_reset(&set_state_opts);
290     if (f) {
291         fclose(f);
292     }
293     return ret;
294 }
295 
296 /* Valid blkdebug filenames look like blkdebug:path/to/config:path/to/image */
297 static void blkdebug_parse_filename(const char *filename, QDict *options,
298                                     Error **errp)
299 {
300     const char *c;
301 
302     /* Parse the blkdebug: prefix */
303     if (!strstart(filename, "blkdebug:", &filename)) {
304         /* There was no prefix; therefore, all options have to be already
305            present in the QDict (except for the filename) */
306         qdict_put(options, "x-image", qstring_from_str(filename));
307         return;
308     }
309 
310     /* Parse config file path */
311     c = strchr(filename, ':');
312     if (c == NULL) {
313         error_setg(errp, "blkdebug requires both config file and image path");
314         return;
315     }
316 
317     if (c != filename) {
318         QString *config_path;
319         config_path = qstring_from_substr(filename, 0, c - filename - 1);
320         qdict_put(options, "config", config_path);
321     }
322 
323     /* TODO Allow multi-level nesting and set file.filename here */
324     filename = c + 1;
325     qdict_put(options, "x-image", qstring_from_str(filename));
326 }
327 
328 static QemuOptsList runtime_opts = {
329     .name = "blkdebug",
330     .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head),
331     .desc = {
332         {
333             .name = "config",
334             .type = QEMU_OPT_STRING,
335             .help = "Path to the configuration file",
336         },
337         {
338             .name = "x-image",
339             .type = QEMU_OPT_STRING,
340             .help = "[internal use only, will be removed]",
341         },
342         {
343             .name = "align",
344             .type = QEMU_OPT_SIZE,
345             .help = "Required alignment in bytes",
346         },
347         { /* end of list */ }
348     },
349 };
350 
351 static int blkdebug_open(BlockDriverState *bs, QDict *options, int flags,
352                          Error **errp)
353 {
354     BDRVBlkdebugState *s = bs->opaque;
355     QemuOpts *opts;
356     Error *local_err = NULL;
357     uint64_t align;
358     int ret;
359 
360     opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort);
361     qemu_opts_absorb_qdict(opts, options, &local_err);
362     if (local_err) {
363         error_propagate(errp, local_err);
364         ret = -EINVAL;
365         goto out;
366     }
367 
368     /* Read rules from config file or command line options */
369     s->config_file = g_strdup(qemu_opt_get(opts, "config"));
370     ret = read_config(s, s->config_file, options, errp);
371     if (ret) {
372         goto out;
373     }
374 
375     /* Set initial state */
376     s->state = 1;
377 
378     /* Open the image file */
379     bs->file = bdrv_open_child(qemu_opt_get(opts, "x-image"), options, "image",
380                                bs, &child_file, false, &local_err);
381     if (local_err) {
382         ret = -EINVAL;
383         error_propagate(errp, local_err);
384         goto out;
385     }
386 
387     /* Set request alignment */
388     align = qemu_opt_get_size(opts, "align", 0);
389     if (align < INT_MAX && is_power_of_2(align)) {
390         s->align = align;
391     } else if (align) {
392         error_setg(errp, "Invalid alignment");
393         ret = -EINVAL;
394         goto fail_unref;
395     }
396 
397     ret = 0;
398     goto out;
399 
400 fail_unref:
401     bdrv_unref_child(bs, bs->file);
402 out:
403     if (ret < 0) {
404         g_free(s->config_file);
405     }
406     qemu_opts_del(opts);
407     return ret;
408 }
409 
410 static void error_callback_bh(void *opaque)
411 {
412     struct BlkdebugAIOCB *acb = opaque;
413     qemu_bh_delete(acb->bh);
414     acb->common.cb(acb->common.opaque, acb->ret);
415     qemu_aio_unref(acb);
416 }
417 
418 static BlockAIOCB *inject_error(BlockDriverState *bs,
419     BlockCompletionFunc *cb, void *opaque, BlkdebugRule *rule)
420 {
421     BDRVBlkdebugState *s = bs->opaque;
422     int error = rule->options.inject.error;
423     struct BlkdebugAIOCB *acb;
424     QEMUBH *bh;
425     bool immediately = rule->options.inject.immediately;
426 
427     if (rule->options.inject.once) {
428         QSIMPLEQ_REMOVE(&s->active_rules, rule, BlkdebugRule, active_next);
429         remove_rule(rule);
430     }
431 
432     if (immediately) {
433         return NULL;
434     }
435 
436     acb = qemu_aio_get(&blkdebug_aiocb_info, bs, cb, opaque);
437     acb->ret = -error;
438 
439     bh = aio_bh_new(bdrv_get_aio_context(bs), error_callback_bh, acb);
440     acb->bh = bh;
441     qemu_bh_schedule(bh);
442 
443     return &acb->common;
444 }
445 
446 static BlockAIOCB *blkdebug_aio_readv(BlockDriverState *bs,
447     int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
448     BlockCompletionFunc *cb, void *opaque)
449 {
450     BDRVBlkdebugState *s = bs->opaque;
451     BlkdebugRule *rule = NULL;
452 
453     QSIMPLEQ_FOREACH(rule, &s->active_rules, active_next) {
454         if (rule->options.inject.sector == -1 ||
455             (rule->options.inject.sector >= sector_num &&
456              rule->options.inject.sector < sector_num + nb_sectors)) {
457             break;
458         }
459     }
460 
461     if (rule && rule->options.inject.error) {
462         return inject_error(bs, cb, opaque, rule);
463     }
464 
465     return bdrv_aio_readv(bs->file, sector_num, qiov, nb_sectors,
466                           cb, opaque);
467 }
468 
469 static BlockAIOCB *blkdebug_aio_writev(BlockDriverState *bs,
470     int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
471     BlockCompletionFunc *cb, void *opaque)
472 {
473     BDRVBlkdebugState *s = bs->opaque;
474     BlkdebugRule *rule = NULL;
475 
476     QSIMPLEQ_FOREACH(rule, &s->active_rules, active_next) {
477         if (rule->options.inject.sector == -1 ||
478             (rule->options.inject.sector >= sector_num &&
479              rule->options.inject.sector < sector_num + nb_sectors)) {
480             break;
481         }
482     }
483 
484     if (rule && rule->options.inject.error) {
485         return inject_error(bs, cb, opaque, rule);
486     }
487 
488     return bdrv_aio_writev(bs->file, sector_num, qiov, nb_sectors,
489                            cb, opaque);
490 }
491 
492 static BlockAIOCB *blkdebug_aio_flush(BlockDriverState *bs,
493     BlockCompletionFunc *cb, void *opaque)
494 {
495     BDRVBlkdebugState *s = bs->opaque;
496     BlkdebugRule *rule = NULL;
497 
498     QSIMPLEQ_FOREACH(rule, &s->active_rules, active_next) {
499         if (rule->options.inject.sector == -1) {
500             break;
501         }
502     }
503 
504     if (rule && rule->options.inject.error) {
505         return inject_error(bs, cb, opaque, rule);
506     }
507 
508     return bdrv_aio_flush(bs->file->bs, cb, opaque);
509 }
510 
511 
512 static void blkdebug_close(BlockDriverState *bs)
513 {
514     BDRVBlkdebugState *s = bs->opaque;
515     BlkdebugRule *rule, *next;
516     int i;
517 
518     for (i = 0; i < BLKDBG__MAX; i++) {
519         QLIST_FOREACH_SAFE(rule, &s->rules[i], next, next) {
520             remove_rule(rule);
521         }
522     }
523 
524     g_free(s->config_file);
525 }
526 
527 static void suspend_request(BlockDriverState *bs, BlkdebugRule *rule)
528 {
529     BDRVBlkdebugState *s = bs->opaque;
530     BlkdebugSuspendedReq r;
531 
532     r = (BlkdebugSuspendedReq) {
533         .co         = qemu_coroutine_self(),
534         .tag        = g_strdup(rule->options.suspend.tag),
535     };
536 
537     remove_rule(rule);
538     QLIST_INSERT_HEAD(&s->suspended_reqs, &r, next);
539 
540     if (!qtest_enabled()) {
541         printf("blkdebug: Suspended request '%s'\n", r.tag);
542     }
543     qemu_coroutine_yield();
544     if (!qtest_enabled()) {
545         printf("blkdebug: Resuming request '%s'\n", r.tag);
546     }
547 
548     QLIST_REMOVE(&r, next);
549     g_free(r.tag);
550 }
551 
552 static bool process_rule(BlockDriverState *bs, struct BlkdebugRule *rule,
553     bool injected)
554 {
555     BDRVBlkdebugState *s = bs->opaque;
556 
557     /* Only process rules for the current state */
558     if (rule->state && rule->state != s->state) {
559         return injected;
560     }
561 
562     /* Take the action */
563     switch (rule->action) {
564     case ACTION_INJECT_ERROR:
565         if (!injected) {
566             QSIMPLEQ_INIT(&s->active_rules);
567             injected = true;
568         }
569         QSIMPLEQ_INSERT_HEAD(&s->active_rules, rule, active_next);
570         break;
571 
572     case ACTION_SET_STATE:
573         s->new_state = rule->options.set_state.new_state;
574         break;
575 
576     case ACTION_SUSPEND:
577         suspend_request(bs, rule);
578         break;
579     }
580     return injected;
581 }
582 
583 static void blkdebug_debug_event(BlockDriverState *bs, BlkdebugEvent event)
584 {
585     BDRVBlkdebugState *s = bs->opaque;
586     struct BlkdebugRule *rule, *next;
587     bool injected;
588 
589     assert((int)event >= 0 && event < BLKDBG__MAX);
590 
591     injected = false;
592     s->new_state = s->state;
593     QLIST_FOREACH_SAFE(rule, &s->rules[event], next, next) {
594         injected = process_rule(bs, rule, injected);
595     }
596     s->state = s->new_state;
597 }
598 
599 static int blkdebug_debug_breakpoint(BlockDriverState *bs, const char *event,
600                                      const char *tag)
601 {
602     BDRVBlkdebugState *s = bs->opaque;
603     struct BlkdebugRule *rule;
604     BlkdebugEvent blkdebug_event;
605 
606     if (get_event_by_name(event, &blkdebug_event) < 0) {
607         return -ENOENT;
608     }
609 
610 
611     rule = g_malloc(sizeof(*rule));
612     *rule = (struct BlkdebugRule) {
613         .event  = blkdebug_event,
614         .action = ACTION_SUSPEND,
615         .state  = 0,
616         .options.suspend.tag = g_strdup(tag),
617     };
618 
619     QLIST_INSERT_HEAD(&s->rules[blkdebug_event], rule, next);
620 
621     return 0;
622 }
623 
624 static int blkdebug_debug_resume(BlockDriverState *bs, const char *tag)
625 {
626     BDRVBlkdebugState *s = bs->opaque;
627     BlkdebugSuspendedReq *r, *next;
628 
629     QLIST_FOREACH_SAFE(r, &s->suspended_reqs, next, next) {
630         if (!strcmp(r->tag, tag)) {
631             qemu_coroutine_enter(r->co);
632             return 0;
633         }
634     }
635     return -ENOENT;
636 }
637 
638 static int blkdebug_debug_remove_breakpoint(BlockDriverState *bs,
639                                             const char *tag)
640 {
641     BDRVBlkdebugState *s = bs->opaque;
642     BlkdebugSuspendedReq *r, *r_next;
643     BlkdebugRule *rule, *next;
644     int i, ret = -ENOENT;
645 
646     for (i = 0; i < BLKDBG__MAX; i++) {
647         QLIST_FOREACH_SAFE(rule, &s->rules[i], next, next) {
648             if (rule->action == ACTION_SUSPEND &&
649                 !strcmp(rule->options.suspend.tag, tag)) {
650                 remove_rule(rule);
651                 ret = 0;
652             }
653         }
654     }
655     QLIST_FOREACH_SAFE(r, &s->suspended_reqs, next, r_next) {
656         if (!strcmp(r->tag, tag)) {
657             qemu_coroutine_enter(r->co);
658             ret = 0;
659         }
660     }
661     return ret;
662 }
663 
664 static bool blkdebug_debug_is_suspended(BlockDriverState *bs, const char *tag)
665 {
666     BDRVBlkdebugState *s = bs->opaque;
667     BlkdebugSuspendedReq *r;
668 
669     QLIST_FOREACH(r, &s->suspended_reqs, next) {
670         if (!strcmp(r->tag, tag)) {
671             return true;
672         }
673     }
674     return false;
675 }
676 
677 static int64_t blkdebug_getlength(BlockDriverState *bs)
678 {
679     return bdrv_getlength(bs->file->bs);
680 }
681 
682 static int blkdebug_truncate(BlockDriverState *bs, int64_t offset)
683 {
684     return bdrv_truncate(bs->file->bs, offset);
685 }
686 
687 static void blkdebug_refresh_filename(BlockDriverState *bs, QDict *options)
688 {
689     BDRVBlkdebugState *s = bs->opaque;
690     QDict *opts;
691     const QDictEntry *e;
692     bool force_json = false;
693 
694     for (e = qdict_first(options); e; e = qdict_next(options, e)) {
695         if (strcmp(qdict_entry_key(e), "config") &&
696             strcmp(qdict_entry_key(e), "x-image"))
697         {
698             force_json = true;
699             break;
700         }
701     }
702 
703     if (force_json && !bs->file->bs->full_open_options) {
704         /* The config file cannot be recreated, so creating a plain filename
705          * is impossible */
706         return;
707     }
708 
709     if (!force_json && bs->file->bs->exact_filename[0]) {
710         snprintf(bs->exact_filename, sizeof(bs->exact_filename),
711                  "blkdebug:%s:%s", s->config_file ?: "",
712                  bs->file->bs->exact_filename);
713     }
714 
715     opts = qdict_new();
716     qdict_put_obj(opts, "driver", QOBJECT(qstring_from_str("blkdebug")));
717 
718     QINCREF(bs->file->bs->full_open_options);
719     qdict_put_obj(opts, "image", QOBJECT(bs->file->bs->full_open_options));
720 
721     for (e = qdict_first(options); e; e = qdict_next(options, e)) {
722         if (strcmp(qdict_entry_key(e), "x-image")) {
723             qobject_incref(qdict_entry_value(e));
724             qdict_put_obj(opts, qdict_entry_key(e), qdict_entry_value(e));
725         }
726     }
727 
728     bs->full_open_options = opts;
729 }
730 
731 static void blkdebug_refresh_limits(BlockDriverState *bs, Error **errp)
732 {
733     BDRVBlkdebugState *s = bs->opaque;
734 
735     if (s->align) {
736         bs->bl.request_alignment = s->align;
737     }
738 }
739 
740 static int blkdebug_reopen_prepare(BDRVReopenState *reopen_state,
741                                    BlockReopenQueue *queue, Error **errp)
742 {
743     return 0;
744 }
745 
746 static BlockDriver bdrv_blkdebug = {
747     .format_name            = "blkdebug",
748     .protocol_name          = "blkdebug",
749     .instance_size          = sizeof(BDRVBlkdebugState),
750 
751     .bdrv_parse_filename    = blkdebug_parse_filename,
752     .bdrv_file_open         = blkdebug_open,
753     .bdrv_close             = blkdebug_close,
754     .bdrv_reopen_prepare    = blkdebug_reopen_prepare,
755     .bdrv_getlength         = blkdebug_getlength,
756     .bdrv_truncate          = blkdebug_truncate,
757     .bdrv_refresh_filename  = blkdebug_refresh_filename,
758     .bdrv_refresh_limits    = blkdebug_refresh_limits,
759 
760     .bdrv_aio_readv         = blkdebug_aio_readv,
761     .bdrv_aio_writev        = blkdebug_aio_writev,
762     .bdrv_aio_flush         = blkdebug_aio_flush,
763 
764     .bdrv_debug_event           = blkdebug_debug_event,
765     .bdrv_debug_breakpoint      = blkdebug_debug_breakpoint,
766     .bdrv_debug_remove_breakpoint
767                                 = blkdebug_debug_remove_breakpoint,
768     .bdrv_debug_resume          = blkdebug_debug_resume,
769     .bdrv_debug_is_suspended    = blkdebug_debug_is_suspended,
770 };
771 
772 static void bdrv_blkdebug_init(void)
773 {
774     bdrv_register(&bdrv_blkdebug);
775 }
776 
777 block_init(bdrv_blkdebug_init);
778