]>
Commit | Line | Data |
---|---|---|
6a143727 KW |
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" | |
1de7afc9 | 26 | #include "qemu/config-file.h" |
737e150e | 27 | #include "block/block_int.h" |
1de7afc9 | 28 | #include "qemu/module.h" |
6a143727 KW |
29 | |
30 | typedef struct BDRVBlkdebugState { | |
571cd43e | 31 | int state; |
8f96b5be | 32 | int new_state; |
3c90c65d | 33 | |
571cd43e PB |
34 | QLIST_HEAD(, BlkdebugRule) rules[BLKDBG_EVENT_MAX]; |
35 | QSIMPLEQ_HEAD(, BlkdebugRule) active_rules; | |
3c90c65d | 36 | QLIST_HEAD(, BlkdebugSuspendedReq) suspended_reqs; |
6a143727 KW |
37 | } BDRVBlkdebugState; |
38 | ||
b9f66d96 KW |
39 | typedef struct BlkdebugAIOCB { |
40 | BlockDriverAIOCB common; | |
41 | QEMUBH *bh; | |
42 | int ret; | |
43 | } BlkdebugAIOCB; | |
44 | ||
3c90c65d KW |
45 | typedef struct BlkdebugSuspendedReq { |
46 | Coroutine *co; | |
47 | char *tag; | |
48 | QLIST_ENTRY(BlkdebugSuspendedReq) next; | |
49 | } BlkdebugSuspendedReq; | |
50 | ||
b9f66d96 KW |
51 | static void blkdebug_aio_cancel(BlockDriverAIOCB *blockacb); |
52 | ||
d7331bed | 53 | static const AIOCBInfo blkdebug_aiocb_info = { |
b9f66d96 KW |
54 | .aiocb_size = sizeof(BlkdebugAIOCB), |
55 | .cancel = blkdebug_aio_cancel, | |
56 | }; | |
57 | ||
8b9b0cc2 KW |
58 | enum { |
59 | ACTION_INJECT_ERROR, | |
60 | ACTION_SET_STATE, | |
3c90c65d | 61 | ACTION_SUSPEND, |
8b9b0cc2 KW |
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; | |
e4780db4 | 73 | int64_t sector; |
8b9b0cc2 KW |
74 | } inject; |
75 | struct { | |
76 | int new_state; | |
77 | } set_state; | |
3c90c65d KW |
78 | struct { |
79 | char *tag; | |
80 | } suspend; | |
8b9b0cc2 KW |
81 | } options; |
82 | QLIST_ENTRY(BlkdebugRule) next; | |
571cd43e | 83 | QSIMPLEQ_ENTRY(BlkdebugRule) active_next; |
8b9b0cc2 KW |
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 | }, | |
e4780db4 PB |
102 | { |
103 | .name = "sector", | |
104 | .type = QEMU_OPT_NUMBER, | |
105 | }, | |
8b9b0cc2 KW |
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", | |
327cdad4 | 120 | .head = QTAILQ_HEAD_INITIALIZER(set_state_opts.head), |
8b9b0cc2 KW |
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] = { | |
8252278a KW |
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 | ||
8252278a | 156 | [BLKDBG_READ_AIO] = "read_aio", |
8252278a KW |
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", | |
afa50193 | 171 | [BLKDBG_REFTABLE_UPDATE] = "reftable_update", |
8252278a KW |
172 | |
173 | [BLKDBG_REFBLOCK_LOAD] = "refblock_load", | |
174 | [BLKDBG_REFBLOCK_UPDATE] = "refblock_update", | |
175 | [BLKDBG_REFBLOCK_UPDATE_PART] = "refblock_update_part", | |
176 | [BLKDBG_REFBLOCK_ALLOC] = "refblock_alloc", | |
177 | [BLKDBG_REFBLOCK_ALLOC_HOOKUP] = "refblock_alloc.hookup", | |
178 | [BLKDBG_REFBLOCK_ALLOC_WRITE] = "refblock_alloc.write", | |
179 | [BLKDBG_REFBLOCK_ALLOC_WRITE_BLOCKS] = "refblock_alloc.write_blocks", | |
180 | [BLKDBG_REFBLOCK_ALLOC_WRITE_TABLE] = "refblock_alloc.write_table", | |
181 | [BLKDBG_REFBLOCK_ALLOC_SWITCH_TABLE] = "refblock_alloc.switch_table", | |
182 | ||
183 | [BLKDBG_CLUSTER_ALLOC] = "cluster_alloc", | |
184 | [BLKDBG_CLUSTER_ALLOC_BYTES] = "cluster_alloc_bytes", | |
185 | [BLKDBG_CLUSTER_FREE] = "cluster_free", | |
bf736fe3 KW |
186 | |
187 | [BLKDBG_FLUSH_TO_OS] = "flush_to_os", | |
188 | [BLKDBG_FLUSH_TO_DISK] = "flush_to_disk", | |
8b9b0cc2 KW |
189 | }; |
190 | ||
191 | static int get_event_by_name(const char *name, BlkDebugEvent *event) | |
192 | { | |
193 | int i; | |
194 | ||
195 | for (i = 0; i < BLKDBG_EVENT_MAX; i++) { | |
196 | if (!strcmp(event_names[i], name)) { | |
197 | *event = i; | |
198 | return 0; | |
199 | } | |
200 | } | |
201 | ||
202 | return -1; | |
203 | } | |
204 | ||
205 | struct add_rule_data { | |
206 | BDRVBlkdebugState *s; | |
207 | int action; | |
208 | }; | |
209 | ||
210 | static int add_rule(QemuOpts *opts, void *opaque) | |
211 | { | |
212 | struct add_rule_data *d = opaque; | |
213 | BDRVBlkdebugState *s = d->s; | |
214 | const char* event_name; | |
215 | BlkDebugEvent event; | |
216 | struct BlkdebugRule *rule; | |
217 | ||
218 | /* Find the right event for the rule */ | |
219 | event_name = qemu_opt_get(opts, "event"); | |
220 | if (!event_name || get_event_by_name(event_name, &event) < 0) { | |
221 | return -1; | |
222 | } | |
223 | ||
224 | /* Set attributes common for all actions */ | |
7267c094 | 225 | rule = g_malloc0(sizeof(*rule)); |
8b9b0cc2 KW |
226 | *rule = (struct BlkdebugRule) { |
227 | .event = event, | |
228 | .action = d->action, | |
229 | .state = qemu_opt_get_number(opts, "state", 0), | |
230 | }; | |
231 | ||
232 | /* Parse action-specific options */ | |
233 | switch (d->action) { | |
234 | case ACTION_INJECT_ERROR: | |
235 | rule->options.inject.error = qemu_opt_get_number(opts, "errno", EIO); | |
236 | rule->options.inject.once = qemu_opt_get_bool(opts, "once", 0); | |
237 | rule->options.inject.immediately = | |
238 | qemu_opt_get_bool(opts, "immediately", 0); | |
e4780db4 | 239 | rule->options.inject.sector = qemu_opt_get_number(opts, "sector", -1); |
8b9b0cc2 KW |
240 | break; |
241 | ||
242 | case ACTION_SET_STATE: | |
243 | rule->options.set_state.new_state = | |
244 | qemu_opt_get_number(opts, "new_state", 0); | |
245 | break; | |
3c90c65d KW |
246 | |
247 | case ACTION_SUSPEND: | |
248 | rule->options.suspend.tag = | |
249 | g_strdup(qemu_opt_get(opts, "tag")); | |
250 | break; | |
8b9b0cc2 KW |
251 | }; |
252 | ||
253 | /* Add the rule */ | |
254 | QLIST_INSERT_HEAD(&s->rules[event], rule, next); | |
255 | ||
256 | return 0; | |
257 | } | |
258 | ||
9e35542b KW |
259 | static void remove_rule(BlkdebugRule *rule) |
260 | { | |
261 | switch (rule->action) { | |
262 | case ACTION_INJECT_ERROR: | |
263 | case ACTION_SET_STATE: | |
264 | break; | |
3c90c65d KW |
265 | case ACTION_SUSPEND: |
266 | g_free(rule->options.suspend.tag); | |
267 | break; | |
9e35542b KW |
268 | } |
269 | ||
270 | QLIST_REMOVE(rule, next); | |
271 | g_free(rule); | |
272 | } | |
273 | ||
466b49f2 | 274 | static int read_config(BDRVBlkdebugState *s, const char *filename, Error **errp) |
8b9b0cc2 KW |
275 | { |
276 | FILE *f; | |
277 | int ret; | |
278 | struct add_rule_data d; | |
279 | ||
280 | f = fopen(filename, "r"); | |
281 | if (f == NULL) { | |
466b49f2 | 282 | error_setg_errno(errp, errno, "Could not read blkdebug config file"); |
8b9b0cc2 KW |
283 | return -errno; |
284 | } | |
285 | ||
286 | ret = qemu_config_parse(f, config_groups, filename); | |
287 | if (ret < 0) { | |
466b49f2 HR |
288 | error_setg(errp, "Could not parse blkdebug config file"); |
289 | ret = -EINVAL; | |
8b9b0cc2 KW |
290 | goto fail; |
291 | } | |
292 | ||
293 | d.s = s; | |
294 | d.action = ACTION_INJECT_ERROR; | |
295 | qemu_opts_foreach(&inject_error_opts, add_rule, &d, 0); | |
296 | ||
297 | d.action = ACTION_SET_STATE; | |
298 | qemu_opts_foreach(&set_state_opts, add_rule, &d, 0); | |
299 | ||
300 | ret = 0; | |
301 | fail: | |
698f0d52 KW |
302 | qemu_opts_reset(&inject_error_opts); |
303 | qemu_opts_reset(&set_state_opts); | |
8b9b0cc2 KW |
304 | fclose(f); |
305 | return ret; | |
306 | } | |
307 | ||
308 | /* Valid blkdebug filenames look like blkdebug:path/to/config:path/to/image */ | |
f4681212 KW |
309 | static void blkdebug_parse_filename(const char *filename, QDict *options, |
310 | Error **errp) | |
6a143727 | 311 | { |
f4681212 | 312 | const char *c; |
6a143727 | 313 | |
8b9b0cc2 | 314 | /* Parse the blkdebug: prefix */ |
f4681212 KW |
315 | if (!strstart(filename, "blkdebug:", &filename)) { |
316 | error_setg(errp, "File name string must start with 'blkdebug:'"); | |
317 | return; | |
6a143727 | 318 | } |
6a143727 | 319 | |
f4681212 | 320 | /* Parse config file path */ |
8b9b0cc2 KW |
321 | c = strchr(filename, ':'); |
322 | if (c == NULL) { | |
f4681212 KW |
323 | error_setg(errp, "blkdebug requires both config file and image path"); |
324 | return; | |
8b9b0cc2 KW |
325 | } |
326 | ||
f4681212 KW |
327 | if (c != filename) { |
328 | QString *config_path; | |
329 | config_path = qstring_from_substr(filename, 0, c - filename - 1); | |
330 | qdict_put(options, "config", config_path); | |
8b9b0cc2 | 331 | } |
f4681212 KW |
332 | |
333 | /* TODO Allow multi-level nesting and set file.filename here */ | |
8b9b0cc2 | 334 | filename = c + 1; |
f4681212 KW |
335 | qdict_put(options, "x-image", qstring_from_str(filename)); |
336 | } | |
337 | ||
338 | static QemuOptsList runtime_opts = { | |
339 | .name = "blkdebug", | |
340 | .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head), | |
341 | .desc = { | |
342 | { | |
343 | .name = "config", | |
344 | .type = QEMU_OPT_STRING, | |
345 | .help = "Path to the configuration file", | |
346 | }, | |
347 | { | |
348 | .name = "x-image", | |
349 | .type = QEMU_OPT_STRING, | |
350 | .help = "[internal use only, will be removed]", | |
351 | }, | |
352 | { /* end of list */ } | |
353 | }, | |
354 | }; | |
355 | ||
015a1036 HR |
356 | static int blkdebug_open(BlockDriverState *bs, QDict *options, int flags, |
357 | Error **errp) | |
f4681212 KW |
358 | { |
359 | BDRVBlkdebugState *s = bs->opaque; | |
360 | QemuOpts *opts; | |
361 | Error *local_err = NULL; | |
362 | const char *filename, *config; | |
363 | int ret; | |
364 | ||
87ea75d5 | 365 | opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort); |
f4681212 KW |
366 | qemu_opts_absorb_qdict(opts, options, &local_err); |
367 | if (error_is_set(&local_err)) { | |
10ffa72f | 368 | error_propagate(errp, local_err); |
f4681212 KW |
369 | ret = -EINVAL; |
370 | goto fail; | |
371 | } | |
372 | ||
373 | /* Read rules from config file */ | |
374 | config = qemu_opt_get(opts, "config"); | |
375 | if (config) { | |
466b49f2 HR |
376 | ret = read_config(s, config, errp); |
377 | if (ret) { | |
f4681212 KW |
378 | goto fail; |
379 | } | |
380 | } | |
8b9b0cc2 | 381 | |
8db520ce | 382 | /* Set initial state */ |
571cd43e | 383 | s->state = 1; |
8db520ce | 384 | |
8b9b0cc2 | 385 | /* Open the backing file */ |
f4681212 KW |
386 | filename = qemu_opt_get(opts, "x-image"); |
387 | if (filename == NULL) { | |
10ffa72f | 388 | error_setg(errp, "Could not retrieve image file name"); |
f4681212 KW |
389 | ret = -EINVAL; |
390 | goto fail; | |
391 | } | |
392 | ||
34b5d2c6 | 393 | ret = bdrv_file_open(&bs->file, filename, NULL, flags, &local_err); |
8b9b0cc2 | 394 | if (ret < 0) { |
10ffa72f | 395 | error_propagate(errp, local_err); |
f4681212 | 396 | goto fail; |
8b9b0cc2 KW |
397 | } |
398 | ||
f4681212 KW |
399 | ret = 0; |
400 | fail: | |
401 | qemu_opts_del(opts); | |
402 | return ret; | |
6a143727 KW |
403 | } |
404 | ||
b9f66d96 KW |
405 | static void error_callback_bh(void *opaque) |
406 | { | |
407 | struct BlkdebugAIOCB *acb = opaque; | |
408 | qemu_bh_delete(acb->bh); | |
409 | acb->common.cb(acb->common.opaque, acb->ret); | |
410 | qemu_aio_release(acb); | |
411 | } | |
412 | ||
413 | static void blkdebug_aio_cancel(BlockDriverAIOCB *blockacb) | |
414 | { | |
b666d239 | 415 | BlkdebugAIOCB *acb = container_of(blockacb, BlkdebugAIOCB, common); |
b9f66d96 KW |
416 | qemu_aio_release(acb); |
417 | } | |
418 | ||
419 | static BlockDriverAIOCB *inject_error(BlockDriverState *bs, | |
571cd43e | 420 | BlockDriverCompletionFunc *cb, void *opaque, BlkdebugRule *rule) |
b9f66d96 KW |
421 | { |
422 | BDRVBlkdebugState *s = bs->opaque; | |
571cd43e | 423 | int error = rule->options.inject.error; |
b9f66d96 KW |
424 | struct BlkdebugAIOCB *acb; |
425 | QEMUBH *bh; | |
426 | ||
571cd43e PB |
427 | if (rule->options.inject.once) { |
428 | QSIMPLEQ_INIT(&s->active_rules); | |
b9f66d96 KW |
429 | } |
430 | ||
571cd43e | 431 | if (rule->options.inject.immediately) { |
b9f66d96 KW |
432 | return NULL; |
433 | } | |
434 | ||
d7331bed | 435 | acb = qemu_aio_get(&blkdebug_aiocb_info, bs, cb, opaque); |
b9f66d96 KW |
436 | acb->ret = -error; |
437 | ||
438 | bh = qemu_bh_new(error_callback_bh, acb); | |
439 | acb->bh = bh; | |
440 | qemu_bh_schedule(bh); | |
441 | ||
b666d239 | 442 | return &acb->common; |
b9f66d96 KW |
443 | } |
444 | ||
6a143727 KW |
445 | static BlockDriverAIOCB *blkdebug_aio_readv(BlockDriverState *bs, |
446 | int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, | |
447 | BlockDriverCompletionFunc *cb, void *opaque) | |
448 | { | |
449 | BDRVBlkdebugState *s = bs->opaque; | |
e4780db4 PB |
450 | BlkdebugRule *rule = NULL; |
451 | ||
452 | QSIMPLEQ_FOREACH(rule, &s->active_rules, active_next) { | |
453 | if (rule->options.inject.sector == -1 || | |
454 | (rule->options.inject.sector >= sector_num && | |
455 | rule->options.inject.sector < sector_num + nb_sectors)) { | |
456 | break; | |
457 | } | |
458 | } | |
b9f66d96 | 459 | |
571cd43e PB |
460 | if (rule && rule->options.inject.error) { |
461 | return inject_error(bs, cb, opaque, rule); | |
b9f66d96 KW |
462 | } |
463 | ||
368e8dd1 | 464 | return bdrv_aio_readv(bs->file, sector_num, qiov, nb_sectors, cb, opaque); |
6a143727 KW |
465 | } |
466 | ||
467 | static BlockDriverAIOCB *blkdebug_aio_writev(BlockDriverState *bs, | |
468 | int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, | |
469 | BlockDriverCompletionFunc *cb, void *opaque) | |
470 | { | |
471 | BDRVBlkdebugState *s = bs->opaque; | |
e4780db4 PB |
472 | BlkdebugRule *rule = NULL; |
473 | ||
474 | QSIMPLEQ_FOREACH(rule, &s->active_rules, active_next) { | |
475 | if (rule->options.inject.sector == -1 || | |
476 | (rule->options.inject.sector >= sector_num && | |
477 | rule->options.inject.sector < sector_num + nb_sectors)) { | |
478 | break; | |
479 | } | |
480 | } | |
b9f66d96 | 481 | |
571cd43e PB |
482 | if (rule && rule->options.inject.error) { |
483 | return inject_error(bs, cb, opaque, rule); | |
b9f66d96 KW |
484 | } |
485 | ||
368e8dd1 | 486 | return bdrv_aio_writev(bs->file, sector_num, qiov, nb_sectors, cb, opaque); |
6a143727 KW |
487 | } |
488 | ||
3c90c65d | 489 | |
6a143727 KW |
490 | static void blkdebug_close(BlockDriverState *bs) |
491 | { | |
492 | BDRVBlkdebugState *s = bs->opaque; | |
8b9b0cc2 KW |
493 | BlkdebugRule *rule, *next; |
494 | int i; | |
495 | ||
496 | for (i = 0; i < BLKDBG_EVENT_MAX; i++) { | |
497 | QLIST_FOREACH_SAFE(rule, &s->rules[i], next, next) { | |
9e35542b | 498 | remove_rule(rule); |
8b9b0cc2 KW |
499 | } |
500 | } | |
6a143727 KW |
501 | } |
502 | ||
3c90c65d KW |
503 | static void suspend_request(BlockDriverState *bs, BlkdebugRule *rule) |
504 | { | |
505 | BDRVBlkdebugState *s = bs->opaque; | |
506 | BlkdebugSuspendedReq r; | |
507 | ||
508 | r = (BlkdebugSuspendedReq) { | |
509 | .co = qemu_coroutine_self(), | |
510 | .tag = g_strdup(rule->options.suspend.tag), | |
511 | }; | |
512 | ||
513 | remove_rule(rule); | |
514 | QLIST_INSERT_HEAD(&s->suspended_reqs, &r, next); | |
515 | ||
516 | printf("blkdebug: Suspended request '%s'\n", r.tag); | |
517 | qemu_coroutine_yield(); | |
518 | printf("blkdebug: Resuming request '%s'\n", r.tag); | |
519 | ||
520 | QLIST_REMOVE(&r, next); | |
521 | g_free(r.tag); | |
522 | } | |
523 | ||
571cd43e | 524 | static bool process_rule(BlockDriverState *bs, struct BlkdebugRule *rule, |
8f96b5be | 525 | bool injected) |
8b9b0cc2 KW |
526 | { |
527 | BDRVBlkdebugState *s = bs->opaque; | |
8b9b0cc2 KW |
528 | |
529 | /* Only process rules for the current state */ | |
8f96b5be | 530 | if (rule->state && rule->state != s->state) { |
571cd43e | 531 | return injected; |
8b9b0cc2 KW |
532 | } |
533 | ||
534 | /* Take the action */ | |
535 | switch (rule->action) { | |
536 | case ACTION_INJECT_ERROR: | |
571cd43e PB |
537 | if (!injected) { |
538 | QSIMPLEQ_INIT(&s->active_rules); | |
539 | injected = true; | |
540 | } | |
541 | QSIMPLEQ_INSERT_HEAD(&s->active_rules, rule, active_next); | |
8b9b0cc2 KW |
542 | break; |
543 | ||
544 | case ACTION_SET_STATE: | |
8f96b5be | 545 | s->new_state = rule->options.set_state.new_state; |
8b9b0cc2 | 546 | break; |
3c90c65d KW |
547 | |
548 | case ACTION_SUSPEND: | |
549 | suspend_request(bs, rule); | |
550 | break; | |
8b9b0cc2 | 551 | } |
571cd43e | 552 | return injected; |
8b9b0cc2 KW |
553 | } |
554 | ||
555 | static void blkdebug_debug_event(BlockDriverState *bs, BlkDebugEvent event) | |
556 | { | |
557 | BDRVBlkdebugState *s = bs->opaque; | |
3c90c65d | 558 | struct BlkdebugRule *rule, *next; |
571cd43e | 559 | bool injected; |
8b9b0cc2 | 560 | |
95ee3914 | 561 | assert((int)event >= 0 && event < BLKDBG_EVENT_MAX); |
8b9b0cc2 | 562 | |
571cd43e | 563 | injected = false; |
8f96b5be | 564 | s->new_state = s->state; |
3c90c65d | 565 | QLIST_FOREACH_SAFE(rule, &s->rules[event], next, next) { |
8f96b5be | 566 | injected = process_rule(bs, rule, injected); |
8b9b0cc2 | 567 | } |
8f96b5be | 568 | s->state = s->new_state; |
8b9b0cc2 KW |
569 | } |
570 | ||
3c90c65d KW |
571 | static int blkdebug_debug_breakpoint(BlockDriverState *bs, const char *event, |
572 | const char *tag) | |
573 | { | |
574 | BDRVBlkdebugState *s = bs->opaque; | |
575 | struct BlkdebugRule *rule; | |
576 | BlkDebugEvent blkdebug_event; | |
577 | ||
578 | if (get_event_by_name(event, &blkdebug_event) < 0) { | |
579 | return -ENOENT; | |
580 | } | |
581 | ||
582 | ||
583 | rule = g_malloc(sizeof(*rule)); | |
584 | *rule = (struct BlkdebugRule) { | |
585 | .event = blkdebug_event, | |
586 | .action = ACTION_SUSPEND, | |
587 | .state = 0, | |
588 | .options.suspend.tag = g_strdup(tag), | |
589 | }; | |
590 | ||
591 | QLIST_INSERT_HEAD(&s->rules[blkdebug_event], rule, next); | |
592 | ||
593 | return 0; | |
594 | } | |
595 | ||
596 | static int blkdebug_debug_resume(BlockDriverState *bs, const char *tag) | |
597 | { | |
598 | BDRVBlkdebugState *s = bs->opaque; | |
c547e564 | 599 | BlkdebugSuspendedReq *r, *next; |
3c90c65d | 600 | |
c547e564 | 601 | QLIST_FOREACH_SAFE(r, &s->suspended_reqs, next, next) { |
3c90c65d KW |
602 | if (!strcmp(r->tag, tag)) { |
603 | qemu_coroutine_enter(r->co, NULL); | |
604 | return 0; | |
605 | } | |
606 | } | |
607 | return -ENOENT; | |
608 | } | |
609 | ||
4cc70e93 FZ |
610 | static int blkdebug_debug_remove_breakpoint(BlockDriverState *bs, |
611 | const char *tag) | |
612 | { | |
613 | BDRVBlkdebugState *s = bs->opaque; | |
c547e564 | 614 | BlkdebugSuspendedReq *r, *r_next; |
4cc70e93 FZ |
615 | BlkdebugRule *rule, *next; |
616 | int i, ret = -ENOENT; | |
617 | ||
618 | for (i = 0; i < BLKDBG_EVENT_MAX; i++) { | |
619 | QLIST_FOREACH_SAFE(rule, &s->rules[i], next, next) { | |
620 | if (rule->action == ACTION_SUSPEND && | |
621 | !strcmp(rule->options.suspend.tag, tag)) { | |
622 | remove_rule(rule); | |
623 | ret = 0; | |
624 | } | |
625 | } | |
626 | } | |
c547e564 | 627 | QLIST_FOREACH_SAFE(r, &s->suspended_reqs, next, r_next) { |
4cc70e93 FZ |
628 | if (!strcmp(r->tag, tag)) { |
629 | qemu_coroutine_enter(r->co, NULL); | |
630 | ret = 0; | |
631 | } | |
632 | } | |
633 | return ret; | |
634 | } | |
3c90c65d KW |
635 | |
636 | static bool blkdebug_debug_is_suspended(BlockDriverState *bs, const char *tag) | |
637 | { | |
638 | BDRVBlkdebugState *s = bs->opaque; | |
639 | BlkdebugSuspendedReq *r; | |
640 | ||
641 | QLIST_FOREACH(r, &s->suspended_reqs, next) { | |
642 | if (!strcmp(r->tag, tag)) { | |
643 | return true; | |
644 | } | |
645 | } | |
646 | return false; | |
647 | } | |
648 | ||
e1302255 PB |
649 | static int64_t blkdebug_getlength(BlockDriverState *bs) |
650 | { | |
651 | return bdrv_getlength(bs->file); | |
652 | } | |
653 | ||
6a143727 | 654 | static BlockDriver bdrv_blkdebug = { |
f4681212 KW |
655 | .format_name = "blkdebug", |
656 | .protocol_name = "blkdebug", | |
657 | .instance_size = sizeof(BDRVBlkdebugState), | |
6a143727 | 658 | |
f4681212 KW |
659 | .bdrv_parse_filename = blkdebug_parse_filename, |
660 | .bdrv_file_open = blkdebug_open, | |
661 | .bdrv_close = blkdebug_close, | |
662 | .bdrv_getlength = blkdebug_getlength, | |
6a143727 | 663 | |
f4681212 KW |
664 | .bdrv_aio_readv = blkdebug_aio_readv, |
665 | .bdrv_aio_writev = blkdebug_aio_writev, | |
8b9b0cc2 | 666 | |
3c90c65d KW |
667 | .bdrv_debug_event = blkdebug_debug_event, |
668 | .bdrv_debug_breakpoint = blkdebug_debug_breakpoint, | |
4cc70e93 FZ |
669 | .bdrv_debug_remove_breakpoint |
670 | = blkdebug_debug_remove_breakpoint, | |
3c90c65d KW |
671 | .bdrv_debug_resume = blkdebug_debug_resume, |
672 | .bdrv_debug_is_suspended = blkdebug_debug_is_suspended, | |
6a143727 KW |
673 | }; |
674 | ||
675 | static void bdrv_blkdebug_init(void) | |
676 | { | |
677 | bdrv_register(&bdrv_blkdebug); | |
678 | } | |
679 | ||
680 | block_init(bdrv_blkdebug_init); |