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-common.h" 26 #include "qemu/config-file.h" 27 #include "block/block_int.h" 28 #include "qemu/module.h" 29 30 typedef struct BDRVBlkdebugState { 31 int state; 32 int new_state; 33 34 QLIST_HEAD(, BlkdebugRule) rules[BLKDBG_EVENT_MAX]; 35 QSIMPLEQ_HEAD(, BlkdebugRule) active_rules; 36 QLIST_HEAD(, BlkdebugSuspendedReq) suspended_reqs; 37 } BDRVBlkdebugState; 38 39 typedef struct BlkdebugAIOCB { 40 BlockDriverAIOCB common; 41 QEMUBH *bh; 42 int ret; 43 } BlkdebugAIOCB; 44 45 typedef struct BlkdebugSuspendedReq { 46 Coroutine *co; 47 char *tag; 48 QLIST_ENTRY(BlkdebugSuspendedReq) next; 49 } BlkdebugSuspendedReq; 50 51 static void blkdebug_aio_cancel(BlockDriverAIOCB *blockacb); 52 53 static const AIOCBInfo blkdebug_aiocb_info = { 54 .aiocb_size = sizeof(BlkdebugAIOCB), 55 .cancel = blkdebug_aio_cancel, 56 }; 57 58 enum { 59 ACTION_INJECT_ERROR, 60 ACTION_SET_STATE, 61 ACTION_SUSPEND, 62 }; 63 64 typedef struct BlkdebugRule { 65 BlkDebugEvent event; 66 int action; 67 int state; 68 union { 69 struct { 70 int error; 71 int immediately; 72 int once; 73 int64_t sector; 74 } inject; 75 struct { 76 int new_state; 77 } set_state; 78 struct { 79 char *tag; 80 } suspend; 81 } options; 82 QLIST_ENTRY(BlkdebugRule) next; 83 QSIMPLEQ_ENTRY(BlkdebugRule) active_next; 84 } BlkdebugRule; 85 86 static QemuOptsList inject_error_opts = { 87 .name = "inject-error", 88 .head = QTAILQ_HEAD_INITIALIZER(inject_error_opts.head), 89 .desc = { 90 { 91 .name = "event", 92 .type = QEMU_OPT_STRING, 93 }, 94 { 95 .name = "state", 96 .type = QEMU_OPT_NUMBER, 97 }, 98 { 99 .name = "errno", 100 .type = QEMU_OPT_NUMBER, 101 }, 102 { 103 .name = "sector", 104 .type = QEMU_OPT_NUMBER, 105 }, 106 { 107 .name = "once", 108 .type = QEMU_OPT_BOOL, 109 }, 110 { 111 .name = "immediately", 112 .type = QEMU_OPT_BOOL, 113 }, 114 { /* end of list */ } 115 }, 116 }; 117 118 static QemuOptsList set_state_opts = { 119 .name = "set-state", 120 .head = QTAILQ_HEAD_INITIALIZER(set_state_opts.head), 121 .desc = { 122 { 123 .name = "event", 124 .type = QEMU_OPT_STRING, 125 }, 126 { 127 .name = "state", 128 .type = QEMU_OPT_NUMBER, 129 }, 130 { 131 .name = "new_state", 132 .type = QEMU_OPT_NUMBER, 133 }, 134 { /* end of list */ } 135 }, 136 }; 137 138 static QemuOptsList *config_groups[] = { 139 &inject_error_opts, 140 &set_state_opts, 141 NULL 142 }; 143 144 static const char *event_names[BLKDBG_EVENT_MAX] = { 145 [BLKDBG_L1_UPDATE] = "l1_update", 146 [BLKDBG_L1_GROW_ALLOC_TABLE] = "l1_grow.alloc_table", 147 [BLKDBG_L1_GROW_WRITE_TABLE] = "l1_grow.write_table", 148 [BLKDBG_L1_GROW_ACTIVATE_TABLE] = "l1_grow.activate_table", 149 150 [BLKDBG_L2_LOAD] = "l2_load", 151 [BLKDBG_L2_UPDATE] = "l2_update", 152 [BLKDBG_L2_UPDATE_COMPRESSED] = "l2_update_compressed", 153 [BLKDBG_L2_ALLOC_COW_READ] = "l2_alloc.cow_read", 154 [BLKDBG_L2_ALLOC_WRITE] = "l2_alloc.write", 155 156 [BLKDBG_READ_AIO] = "read_aio", 157 [BLKDBG_READ_BACKING_AIO] = "read_backing_aio", 158 [BLKDBG_READ_COMPRESSED] = "read_compressed", 159 160 [BLKDBG_WRITE_AIO] = "write_aio", 161 [BLKDBG_WRITE_COMPRESSED] = "write_compressed", 162 163 [BLKDBG_VMSTATE_LOAD] = "vmstate_load", 164 [BLKDBG_VMSTATE_SAVE] = "vmstate_save", 165 166 [BLKDBG_COW_READ] = "cow_read", 167 [BLKDBG_COW_WRITE] = "cow_write", 168 169 [BLKDBG_REFTABLE_LOAD] = "reftable_load", 170 [BLKDBG_REFTABLE_GROW] = "reftable_grow", 171 172 [BLKDBG_REFBLOCK_LOAD] = "refblock_load", 173 [BLKDBG_REFBLOCK_UPDATE] = "refblock_update", 174 [BLKDBG_REFBLOCK_UPDATE_PART] = "refblock_update_part", 175 [BLKDBG_REFBLOCK_ALLOC] = "refblock_alloc", 176 [BLKDBG_REFBLOCK_ALLOC_HOOKUP] = "refblock_alloc.hookup", 177 [BLKDBG_REFBLOCK_ALLOC_WRITE] = "refblock_alloc.write", 178 [BLKDBG_REFBLOCK_ALLOC_WRITE_BLOCKS] = "refblock_alloc.write_blocks", 179 [BLKDBG_REFBLOCK_ALLOC_WRITE_TABLE] = "refblock_alloc.write_table", 180 [BLKDBG_REFBLOCK_ALLOC_SWITCH_TABLE] = "refblock_alloc.switch_table", 181 182 [BLKDBG_CLUSTER_ALLOC] = "cluster_alloc", 183 [BLKDBG_CLUSTER_ALLOC_BYTES] = "cluster_alloc_bytes", 184 [BLKDBG_CLUSTER_FREE] = "cluster_free", 185 }; 186 187 static int get_event_by_name(const char *name, BlkDebugEvent *event) 188 { 189 int i; 190 191 for (i = 0; i < BLKDBG_EVENT_MAX; i++) { 192 if (!strcmp(event_names[i], name)) { 193 *event = i; 194 return 0; 195 } 196 } 197 198 return -1; 199 } 200 201 struct add_rule_data { 202 BDRVBlkdebugState *s; 203 int action; 204 }; 205 206 static int add_rule(QemuOpts *opts, void *opaque) 207 { 208 struct add_rule_data *d = opaque; 209 BDRVBlkdebugState *s = d->s; 210 const char* event_name; 211 BlkDebugEvent event; 212 struct BlkdebugRule *rule; 213 214 /* Find the right event for the rule */ 215 event_name = qemu_opt_get(opts, "event"); 216 if (!event_name || get_event_by_name(event_name, &event) < 0) { 217 return -1; 218 } 219 220 /* Set attributes common for all actions */ 221 rule = g_malloc0(sizeof(*rule)); 222 *rule = (struct BlkdebugRule) { 223 .event = event, 224 .action = d->action, 225 .state = qemu_opt_get_number(opts, "state", 0), 226 }; 227 228 /* Parse action-specific options */ 229 switch (d->action) { 230 case ACTION_INJECT_ERROR: 231 rule->options.inject.error = qemu_opt_get_number(opts, "errno", EIO); 232 rule->options.inject.once = qemu_opt_get_bool(opts, "once", 0); 233 rule->options.inject.immediately = 234 qemu_opt_get_bool(opts, "immediately", 0); 235 rule->options.inject.sector = qemu_opt_get_number(opts, "sector", -1); 236 break; 237 238 case ACTION_SET_STATE: 239 rule->options.set_state.new_state = 240 qemu_opt_get_number(opts, "new_state", 0); 241 break; 242 243 case ACTION_SUSPEND: 244 rule->options.suspend.tag = 245 g_strdup(qemu_opt_get(opts, "tag")); 246 break; 247 }; 248 249 /* Add the rule */ 250 QLIST_INSERT_HEAD(&s->rules[event], rule, next); 251 252 return 0; 253 } 254 255 static void remove_rule(BlkdebugRule *rule) 256 { 257 switch (rule->action) { 258 case ACTION_INJECT_ERROR: 259 case ACTION_SET_STATE: 260 break; 261 case ACTION_SUSPEND: 262 g_free(rule->options.suspend.tag); 263 break; 264 } 265 266 QLIST_REMOVE(rule, next); 267 g_free(rule); 268 } 269 270 static int read_config(BDRVBlkdebugState *s, const char *filename) 271 { 272 FILE *f; 273 int ret; 274 struct add_rule_data d; 275 276 /* Allow usage without config file */ 277 if (!*filename) { 278 return 0; 279 } 280 281 f = fopen(filename, "r"); 282 if (f == NULL) { 283 return -errno; 284 } 285 286 ret = qemu_config_parse(f, config_groups, filename); 287 if (ret < 0) { 288 goto fail; 289 } 290 291 d.s = s; 292 d.action = ACTION_INJECT_ERROR; 293 qemu_opts_foreach(&inject_error_opts, add_rule, &d, 0); 294 295 d.action = ACTION_SET_STATE; 296 qemu_opts_foreach(&set_state_opts, add_rule, &d, 0); 297 298 ret = 0; 299 fail: 300 qemu_opts_reset(&inject_error_opts); 301 qemu_opts_reset(&set_state_opts); 302 fclose(f); 303 return ret; 304 } 305 306 /* Valid blkdebug filenames look like blkdebug:path/to/config:path/to/image */ 307 static int blkdebug_open(BlockDriverState *bs, const char *filename, 308 QDict *options, int flags) 309 { 310 BDRVBlkdebugState *s = bs->opaque; 311 int ret; 312 char *config, *c; 313 314 /* Parse the blkdebug: prefix */ 315 if (strncmp(filename, "blkdebug:", strlen("blkdebug:"))) { 316 return -EINVAL; 317 } 318 filename += strlen("blkdebug:"); 319 320 /* Read rules from config file */ 321 c = strchr(filename, ':'); 322 if (c == NULL) { 323 return -EINVAL; 324 } 325 326 config = g_strdup(filename); 327 config[c - filename] = '\0'; 328 ret = read_config(s, config); 329 g_free(config); 330 if (ret < 0) { 331 return ret; 332 } 333 filename = c + 1; 334 335 /* Set initial state */ 336 s->state = 1; 337 338 /* Open the backing file */ 339 ret = bdrv_file_open(&bs->file, filename, NULL, flags); 340 if (ret < 0) { 341 return ret; 342 } 343 344 return 0; 345 } 346 347 static void error_callback_bh(void *opaque) 348 { 349 struct BlkdebugAIOCB *acb = opaque; 350 qemu_bh_delete(acb->bh); 351 acb->common.cb(acb->common.opaque, acb->ret); 352 qemu_aio_release(acb); 353 } 354 355 static void blkdebug_aio_cancel(BlockDriverAIOCB *blockacb) 356 { 357 BlkdebugAIOCB *acb = container_of(blockacb, BlkdebugAIOCB, common); 358 qemu_aio_release(acb); 359 } 360 361 static BlockDriverAIOCB *inject_error(BlockDriverState *bs, 362 BlockDriverCompletionFunc *cb, void *opaque, BlkdebugRule *rule) 363 { 364 BDRVBlkdebugState *s = bs->opaque; 365 int error = rule->options.inject.error; 366 struct BlkdebugAIOCB *acb; 367 QEMUBH *bh; 368 369 if (rule->options.inject.once) { 370 QSIMPLEQ_INIT(&s->active_rules); 371 } 372 373 if (rule->options.inject.immediately) { 374 return NULL; 375 } 376 377 acb = qemu_aio_get(&blkdebug_aiocb_info, bs, cb, opaque); 378 acb->ret = -error; 379 380 bh = qemu_bh_new(error_callback_bh, acb); 381 acb->bh = bh; 382 qemu_bh_schedule(bh); 383 384 return &acb->common; 385 } 386 387 static BlockDriverAIOCB *blkdebug_aio_readv(BlockDriverState *bs, 388 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, 389 BlockDriverCompletionFunc *cb, void *opaque) 390 { 391 BDRVBlkdebugState *s = bs->opaque; 392 BlkdebugRule *rule = NULL; 393 394 QSIMPLEQ_FOREACH(rule, &s->active_rules, active_next) { 395 if (rule->options.inject.sector == -1 || 396 (rule->options.inject.sector >= sector_num && 397 rule->options.inject.sector < sector_num + nb_sectors)) { 398 break; 399 } 400 } 401 402 if (rule && rule->options.inject.error) { 403 return inject_error(bs, cb, opaque, rule); 404 } 405 406 return bdrv_aio_readv(bs->file, sector_num, qiov, nb_sectors, cb, opaque); 407 } 408 409 static BlockDriverAIOCB *blkdebug_aio_writev(BlockDriverState *bs, 410 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, 411 BlockDriverCompletionFunc *cb, void *opaque) 412 { 413 BDRVBlkdebugState *s = bs->opaque; 414 BlkdebugRule *rule = NULL; 415 416 QSIMPLEQ_FOREACH(rule, &s->active_rules, active_next) { 417 if (rule->options.inject.sector == -1 || 418 (rule->options.inject.sector >= sector_num && 419 rule->options.inject.sector < sector_num + nb_sectors)) { 420 break; 421 } 422 } 423 424 if (rule && rule->options.inject.error) { 425 return inject_error(bs, cb, opaque, rule); 426 } 427 428 return bdrv_aio_writev(bs->file, sector_num, qiov, nb_sectors, cb, opaque); 429 } 430 431 432 static void blkdebug_close(BlockDriverState *bs) 433 { 434 BDRVBlkdebugState *s = bs->opaque; 435 BlkdebugRule *rule, *next; 436 int i; 437 438 for (i = 0; i < BLKDBG_EVENT_MAX; i++) { 439 QLIST_FOREACH_SAFE(rule, &s->rules[i], next, next) { 440 remove_rule(rule); 441 } 442 } 443 } 444 445 static void suspend_request(BlockDriverState *bs, BlkdebugRule *rule) 446 { 447 BDRVBlkdebugState *s = bs->opaque; 448 BlkdebugSuspendedReq r; 449 450 r = (BlkdebugSuspendedReq) { 451 .co = qemu_coroutine_self(), 452 .tag = g_strdup(rule->options.suspend.tag), 453 }; 454 455 remove_rule(rule); 456 QLIST_INSERT_HEAD(&s->suspended_reqs, &r, next); 457 458 printf("blkdebug: Suspended request '%s'\n", r.tag); 459 qemu_coroutine_yield(); 460 printf("blkdebug: Resuming request '%s'\n", r.tag); 461 462 QLIST_REMOVE(&r, next); 463 g_free(r.tag); 464 } 465 466 static bool process_rule(BlockDriverState *bs, struct BlkdebugRule *rule, 467 bool injected) 468 { 469 BDRVBlkdebugState *s = bs->opaque; 470 471 /* Only process rules for the current state */ 472 if (rule->state && rule->state != s->state) { 473 return injected; 474 } 475 476 /* Take the action */ 477 switch (rule->action) { 478 case ACTION_INJECT_ERROR: 479 if (!injected) { 480 QSIMPLEQ_INIT(&s->active_rules); 481 injected = true; 482 } 483 QSIMPLEQ_INSERT_HEAD(&s->active_rules, rule, active_next); 484 break; 485 486 case ACTION_SET_STATE: 487 s->new_state = rule->options.set_state.new_state; 488 break; 489 490 case ACTION_SUSPEND: 491 suspend_request(bs, rule); 492 break; 493 } 494 return injected; 495 } 496 497 static void blkdebug_debug_event(BlockDriverState *bs, BlkDebugEvent event) 498 { 499 BDRVBlkdebugState *s = bs->opaque; 500 struct BlkdebugRule *rule, *next; 501 bool injected; 502 503 assert((int)event >= 0 && event < BLKDBG_EVENT_MAX); 504 505 injected = false; 506 s->new_state = s->state; 507 QLIST_FOREACH_SAFE(rule, &s->rules[event], next, next) { 508 injected = process_rule(bs, rule, injected); 509 } 510 s->state = s->new_state; 511 } 512 513 static int blkdebug_debug_breakpoint(BlockDriverState *bs, const char *event, 514 const char *tag) 515 { 516 BDRVBlkdebugState *s = bs->opaque; 517 struct BlkdebugRule *rule; 518 BlkDebugEvent blkdebug_event; 519 520 if (get_event_by_name(event, &blkdebug_event) < 0) { 521 return -ENOENT; 522 } 523 524 525 rule = g_malloc(sizeof(*rule)); 526 *rule = (struct BlkdebugRule) { 527 .event = blkdebug_event, 528 .action = ACTION_SUSPEND, 529 .state = 0, 530 .options.suspend.tag = g_strdup(tag), 531 }; 532 533 QLIST_INSERT_HEAD(&s->rules[blkdebug_event], rule, next); 534 535 return 0; 536 } 537 538 static int blkdebug_debug_resume(BlockDriverState *bs, const char *tag) 539 { 540 BDRVBlkdebugState *s = bs->opaque; 541 BlkdebugSuspendedReq *r; 542 543 QLIST_FOREACH(r, &s->suspended_reqs, next) { 544 if (!strcmp(r->tag, tag)) { 545 qemu_coroutine_enter(r->co, NULL); 546 return 0; 547 } 548 } 549 return -ENOENT; 550 } 551 552 553 static bool blkdebug_debug_is_suspended(BlockDriverState *bs, const char *tag) 554 { 555 BDRVBlkdebugState *s = bs->opaque; 556 BlkdebugSuspendedReq *r; 557 558 QLIST_FOREACH(r, &s->suspended_reqs, next) { 559 if (!strcmp(r->tag, tag)) { 560 return true; 561 } 562 } 563 return false; 564 } 565 566 static int64_t blkdebug_getlength(BlockDriverState *bs) 567 { 568 return bdrv_getlength(bs->file); 569 } 570 571 static BlockDriver bdrv_blkdebug = { 572 .format_name = "blkdebug", 573 .protocol_name = "blkdebug", 574 575 .instance_size = sizeof(BDRVBlkdebugState), 576 577 .bdrv_file_open = blkdebug_open, 578 .bdrv_close = blkdebug_close, 579 .bdrv_getlength = blkdebug_getlength, 580 581 .bdrv_aio_readv = blkdebug_aio_readv, 582 .bdrv_aio_writev = blkdebug_aio_writev, 583 584 .bdrv_debug_event = blkdebug_debug_event, 585 .bdrv_debug_breakpoint = blkdebug_debug_breakpoint, 586 .bdrv_debug_resume = blkdebug_debug_resume, 587 .bdrv_debug_is_suspended = blkdebug_debug_is_suspended, 588 }; 589 590 static void bdrv_blkdebug_init(void) 591 { 592 bdrv_register(&bdrv_blkdebug); 593 } 594 595 block_init(bdrv_blkdebug_init); 596