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