xen-block.c (24950B)
1 /* 2 * Copyright (c) 2018 Citrix Systems Inc. 3 * (c) Gerd Hoffmann <kraxel@redhat.com> 4 * 5 * This program is free software; you can redistribute it and/or modify 6 * it under the terms of the GNU General Public License as published by 7 * the Free Software Foundation; under version 2 of the License. 8 * 9 * This program is distributed in the hope that it will be useful, 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 * GNU General Public License for more details. 13 * 14 * You should have received a copy of the GNU General Public License along 15 * with this program; if not, see <http://www.gnu.org/licenses/>. 16 * 17 * Contributions after 2012-01-13 are licensed under the terms of the 18 * GNU GPL, version 2 or (at your option) any later version. 19 */ 20 21 #include "qemu/osdep.h" 22 #include "qemu/error-report.h" 23 #include "qemu/main-loop.h" 24 #include "qemu/memalign.h" 25 #include "qapi/error.h" 26 #include "hw/xen/xen_common.h" 27 #include "hw/block/xen_blkif.h" 28 #include "sysemu/block-backend.h" 29 #include "sysemu/iothread.h" 30 #include "xen-block.h" 31 32 typedef struct XenBlockRequest { 33 blkif_request_t req; 34 int16_t status; 35 off_t start; 36 QEMUIOVector v; 37 void *buf; 38 size_t size; 39 int presync; 40 int aio_inflight; 41 int aio_errors; 42 XenBlockDataPlane *dataplane; 43 QLIST_ENTRY(XenBlockRequest) list; 44 BlockAcctCookie acct; 45 } XenBlockRequest; 46 47 struct XenBlockDataPlane { 48 XenDevice *xendev; 49 XenEventChannel *event_channel; 50 unsigned int *ring_ref; 51 unsigned int nr_ring_ref; 52 void *sring; 53 int protocol; 54 blkif_back_rings_t rings; 55 int more_work; 56 QLIST_HEAD(inflight_head, XenBlockRequest) inflight; 57 QLIST_HEAD(freelist_head, XenBlockRequest) freelist; 58 int requests_total; 59 int requests_inflight; 60 unsigned int max_requests; 61 BlockBackend *blk; 62 unsigned int sector_size; 63 QEMUBH *bh; 64 IOThread *iothread; 65 AioContext *ctx; 66 }; 67 68 static int xen_block_send_response(XenBlockRequest *request); 69 70 static void reset_request(XenBlockRequest *request) 71 { 72 memset(&request->req, 0, sizeof(request->req)); 73 request->status = 0; 74 request->start = 0; 75 request->size = 0; 76 request->presync = 0; 77 78 request->aio_inflight = 0; 79 request->aio_errors = 0; 80 81 request->dataplane = NULL; 82 memset(&request->list, 0, sizeof(request->list)); 83 memset(&request->acct, 0, sizeof(request->acct)); 84 85 qemu_iovec_reset(&request->v); 86 } 87 88 static XenBlockRequest *xen_block_start_request(XenBlockDataPlane *dataplane) 89 { 90 XenBlockRequest *request = NULL; 91 92 if (QLIST_EMPTY(&dataplane->freelist)) { 93 if (dataplane->requests_total >= dataplane->max_requests) { 94 goto out; 95 } 96 /* allocate new struct */ 97 request = g_malloc0(sizeof(*request)); 98 request->dataplane = dataplane; 99 /* 100 * We cannot need more pages per requests than this, and since we 101 * re-use requests, allocate the memory once here. It will be freed 102 * xen_block_dataplane_destroy() when the request list is freed. 103 */ 104 request->buf = qemu_memalign(XC_PAGE_SIZE, 105 BLKIF_MAX_SEGMENTS_PER_REQUEST * 106 XC_PAGE_SIZE); 107 dataplane->requests_total++; 108 qemu_iovec_init(&request->v, 1); 109 } else { 110 /* get one from freelist */ 111 request = QLIST_FIRST(&dataplane->freelist); 112 QLIST_REMOVE(request, list); 113 } 114 QLIST_INSERT_HEAD(&dataplane->inflight, request, list); 115 dataplane->requests_inflight++; 116 117 out: 118 return request; 119 } 120 121 static void xen_block_complete_request(XenBlockRequest *request) 122 { 123 XenBlockDataPlane *dataplane = request->dataplane; 124 125 if (xen_block_send_response(request)) { 126 Error *local_err = NULL; 127 128 xen_device_notify_event_channel(dataplane->xendev, 129 dataplane->event_channel, 130 &local_err); 131 if (local_err) { 132 error_report_err(local_err); 133 } 134 } 135 136 QLIST_REMOVE(request, list); 137 dataplane->requests_inflight--; 138 reset_request(request); 139 request->dataplane = dataplane; 140 QLIST_INSERT_HEAD(&dataplane->freelist, request, list); 141 } 142 143 /* 144 * translate request into iovec + start offset 145 * do sanity checks along the way 146 */ 147 static int xen_block_parse_request(XenBlockRequest *request) 148 { 149 XenBlockDataPlane *dataplane = request->dataplane; 150 size_t len; 151 int i; 152 153 switch (request->req.operation) { 154 case BLKIF_OP_READ: 155 break; 156 case BLKIF_OP_FLUSH_DISKCACHE: 157 request->presync = 1; 158 if (!request->req.nr_segments) { 159 return 0; 160 } 161 /* fall through */ 162 case BLKIF_OP_WRITE: 163 break; 164 case BLKIF_OP_DISCARD: 165 return 0; 166 default: 167 error_report("error: unknown operation (%d)", request->req.operation); 168 goto err; 169 }; 170 171 if (request->req.operation != BLKIF_OP_READ && 172 !blk_is_writable(dataplane->blk)) { 173 error_report("error: write req for ro device"); 174 goto err; 175 } 176 177 request->start = request->req.sector_number * dataplane->sector_size; 178 for (i = 0; i < request->req.nr_segments; i++) { 179 if (i == BLKIF_MAX_SEGMENTS_PER_REQUEST) { 180 error_report("error: nr_segments too big"); 181 goto err; 182 } 183 if (request->req.seg[i].first_sect > request->req.seg[i].last_sect) { 184 error_report("error: first > last sector"); 185 goto err; 186 } 187 if (request->req.seg[i].last_sect * dataplane->sector_size >= 188 XC_PAGE_SIZE) { 189 error_report("error: page crossing"); 190 goto err; 191 } 192 193 len = (request->req.seg[i].last_sect - 194 request->req.seg[i].first_sect + 1) * dataplane->sector_size; 195 request->size += len; 196 } 197 if (request->start + request->size > blk_getlength(dataplane->blk)) { 198 error_report("error: access beyond end of file"); 199 goto err; 200 } 201 return 0; 202 203 err: 204 request->status = BLKIF_RSP_ERROR; 205 return -1; 206 } 207 208 static int xen_block_copy_request(XenBlockRequest *request) 209 { 210 XenBlockDataPlane *dataplane = request->dataplane; 211 XenDevice *xendev = dataplane->xendev; 212 XenDeviceGrantCopySegment segs[BLKIF_MAX_SEGMENTS_PER_REQUEST]; 213 int i, count; 214 bool to_domain = (request->req.operation == BLKIF_OP_READ); 215 void *virt = request->buf; 216 Error *local_err = NULL; 217 218 if (request->req.nr_segments == 0) { 219 return 0; 220 } 221 222 count = request->req.nr_segments; 223 224 for (i = 0; i < count; i++) { 225 if (to_domain) { 226 segs[i].dest.foreign.ref = request->req.seg[i].gref; 227 segs[i].dest.foreign.offset = request->req.seg[i].first_sect * 228 dataplane->sector_size; 229 segs[i].source.virt = virt; 230 } else { 231 segs[i].source.foreign.ref = request->req.seg[i].gref; 232 segs[i].source.foreign.offset = request->req.seg[i].first_sect * 233 dataplane->sector_size; 234 segs[i].dest.virt = virt; 235 } 236 segs[i].len = (request->req.seg[i].last_sect - 237 request->req.seg[i].first_sect + 1) * 238 dataplane->sector_size; 239 virt += segs[i].len; 240 } 241 242 xen_device_copy_grant_refs(xendev, to_domain, segs, count, &local_err); 243 244 if (local_err) { 245 error_reportf_err(local_err, "failed to copy data: "); 246 247 request->aio_errors++; 248 return -1; 249 } 250 251 return 0; 252 } 253 254 static int xen_block_do_aio(XenBlockRequest *request); 255 256 static void xen_block_complete_aio(void *opaque, int ret) 257 { 258 XenBlockRequest *request = opaque; 259 XenBlockDataPlane *dataplane = request->dataplane; 260 261 aio_context_acquire(dataplane->ctx); 262 263 if (ret != 0) { 264 error_report("%s I/O error", 265 request->req.operation == BLKIF_OP_READ ? 266 "read" : "write"); 267 request->aio_errors++; 268 } 269 270 request->aio_inflight--; 271 if (request->presync) { 272 request->presync = 0; 273 xen_block_do_aio(request); 274 goto done; 275 } 276 if (request->aio_inflight > 0) { 277 goto done; 278 } 279 280 switch (request->req.operation) { 281 case BLKIF_OP_READ: 282 /* in case of failure request->aio_errors is increased */ 283 if (ret == 0) { 284 xen_block_copy_request(request); 285 } 286 break; 287 case BLKIF_OP_WRITE: 288 case BLKIF_OP_FLUSH_DISKCACHE: 289 default: 290 break; 291 } 292 293 request->status = request->aio_errors ? BLKIF_RSP_ERROR : BLKIF_RSP_OKAY; 294 295 switch (request->req.operation) { 296 case BLKIF_OP_WRITE: 297 case BLKIF_OP_FLUSH_DISKCACHE: 298 if (!request->req.nr_segments) { 299 break; 300 } 301 /* fall through */ 302 case BLKIF_OP_READ: 303 if (request->status == BLKIF_RSP_OKAY) { 304 block_acct_done(blk_get_stats(dataplane->blk), &request->acct); 305 } else { 306 block_acct_failed(blk_get_stats(dataplane->blk), &request->acct); 307 } 308 break; 309 case BLKIF_OP_DISCARD: 310 default: 311 break; 312 } 313 314 xen_block_complete_request(request); 315 316 if (dataplane->more_work) { 317 qemu_bh_schedule(dataplane->bh); 318 } 319 320 done: 321 aio_context_release(dataplane->ctx); 322 } 323 324 static bool xen_block_split_discard(XenBlockRequest *request, 325 blkif_sector_t sector_number, 326 uint64_t nr_sectors) 327 { 328 XenBlockDataPlane *dataplane = request->dataplane; 329 int64_t byte_offset; 330 int byte_chunk; 331 uint64_t byte_remaining; 332 uint64_t sec_start = sector_number; 333 uint64_t sec_count = nr_sectors; 334 335 /* Wrap around, or overflowing byte limit? */ 336 if (sec_start + sec_count < sec_count || 337 sec_start + sec_count > INT64_MAX / dataplane->sector_size) { 338 return false; 339 } 340 341 byte_offset = sec_start * dataplane->sector_size; 342 byte_remaining = sec_count * dataplane->sector_size; 343 344 do { 345 byte_chunk = byte_remaining > BDRV_REQUEST_MAX_BYTES ? 346 BDRV_REQUEST_MAX_BYTES : byte_remaining; 347 request->aio_inflight++; 348 blk_aio_pdiscard(dataplane->blk, byte_offset, byte_chunk, 349 xen_block_complete_aio, request); 350 byte_remaining -= byte_chunk; 351 byte_offset += byte_chunk; 352 } while (byte_remaining > 0); 353 354 return true; 355 } 356 357 static int xen_block_do_aio(XenBlockRequest *request) 358 { 359 XenBlockDataPlane *dataplane = request->dataplane; 360 361 if (request->req.nr_segments && 362 (request->req.operation == BLKIF_OP_WRITE || 363 request->req.operation == BLKIF_OP_FLUSH_DISKCACHE) && 364 xen_block_copy_request(request)) { 365 goto err; 366 } 367 368 request->aio_inflight++; 369 if (request->presync) { 370 blk_aio_flush(request->dataplane->blk, xen_block_complete_aio, 371 request); 372 return 0; 373 } 374 375 switch (request->req.operation) { 376 case BLKIF_OP_READ: 377 qemu_iovec_add(&request->v, request->buf, request->size); 378 block_acct_start(blk_get_stats(dataplane->blk), &request->acct, 379 request->v.size, BLOCK_ACCT_READ); 380 request->aio_inflight++; 381 blk_aio_preadv(dataplane->blk, request->start, &request->v, 0, 382 xen_block_complete_aio, request); 383 break; 384 case BLKIF_OP_WRITE: 385 case BLKIF_OP_FLUSH_DISKCACHE: 386 if (!request->req.nr_segments) { 387 break; 388 } 389 390 qemu_iovec_add(&request->v, request->buf, request->size); 391 block_acct_start(blk_get_stats(dataplane->blk), &request->acct, 392 request->v.size, 393 request->req.operation == BLKIF_OP_WRITE ? 394 BLOCK_ACCT_WRITE : BLOCK_ACCT_FLUSH); 395 request->aio_inflight++; 396 blk_aio_pwritev(dataplane->blk, request->start, &request->v, 0, 397 xen_block_complete_aio, request); 398 break; 399 case BLKIF_OP_DISCARD: 400 { 401 struct blkif_request_discard *req = (void *)&request->req; 402 if (!xen_block_split_discard(request, req->sector_number, 403 req->nr_sectors)) { 404 goto err; 405 } 406 break; 407 } 408 default: 409 /* unknown operation (shouldn't happen -- parse catches this) */ 410 goto err; 411 } 412 413 xen_block_complete_aio(request, 0); 414 415 return 0; 416 417 err: 418 request->status = BLKIF_RSP_ERROR; 419 xen_block_complete_request(request); 420 return -1; 421 } 422 423 static int xen_block_send_response(XenBlockRequest *request) 424 { 425 XenBlockDataPlane *dataplane = request->dataplane; 426 int send_notify = 0; 427 int have_requests = 0; 428 blkif_response_t *resp; 429 430 /* Place on the response ring for the relevant domain. */ 431 switch (dataplane->protocol) { 432 case BLKIF_PROTOCOL_NATIVE: 433 resp = (blkif_response_t *)RING_GET_RESPONSE( 434 &dataplane->rings.native, 435 dataplane->rings.native.rsp_prod_pvt); 436 break; 437 case BLKIF_PROTOCOL_X86_32: 438 resp = (blkif_response_t *)RING_GET_RESPONSE( 439 &dataplane->rings.x86_32_part, 440 dataplane->rings.x86_32_part.rsp_prod_pvt); 441 break; 442 case BLKIF_PROTOCOL_X86_64: 443 resp = (blkif_response_t *)RING_GET_RESPONSE( 444 &dataplane->rings.x86_64_part, 445 dataplane->rings.x86_64_part.rsp_prod_pvt); 446 break; 447 default: 448 return 0; 449 } 450 451 resp->id = request->req.id; 452 resp->operation = request->req.operation; 453 resp->status = request->status; 454 455 dataplane->rings.common.rsp_prod_pvt++; 456 457 RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(&dataplane->rings.common, 458 send_notify); 459 if (dataplane->rings.common.rsp_prod_pvt == 460 dataplane->rings.common.req_cons) { 461 /* 462 * Tail check for pending requests. Allows frontend to avoid 463 * notifications if requests are already in flight (lower 464 * overheads and promotes batching). 465 */ 466 RING_FINAL_CHECK_FOR_REQUESTS(&dataplane->rings.common, 467 have_requests); 468 } else if (RING_HAS_UNCONSUMED_REQUESTS(&dataplane->rings.common)) { 469 have_requests = 1; 470 } 471 472 if (have_requests) { 473 dataplane->more_work++; 474 } 475 return send_notify; 476 } 477 478 static int xen_block_get_request(XenBlockDataPlane *dataplane, 479 XenBlockRequest *request, RING_IDX rc) 480 { 481 switch (dataplane->protocol) { 482 case BLKIF_PROTOCOL_NATIVE: { 483 blkif_request_t *req = 484 RING_GET_REQUEST(&dataplane->rings.native, rc); 485 486 memcpy(&request->req, req, sizeof(request->req)); 487 break; 488 } 489 case BLKIF_PROTOCOL_X86_32: { 490 blkif_x86_32_request_t *req = 491 RING_GET_REQUEST(&dataplane->rings.x86_32_part, rc); 492 493 blkif_get_x86_32_req(&request->req, req); 494 break; 495 } 496 case BLKIF_PROTOCOL_X86_64: { 497 blkif_x86_64_request_t *req = 498 RING_GET_REQUEST(&dataplane->rings.x86_64_part, rc); 499 500 blkif_get_x86_64_req(&request->req, req); 501 break; 502 } 503 } 504 /* Prevent the compiler from accessing the on-ring fields instead. */ 505 barrier(); 506 return 0; 507 } 508 509 /* 510 * Threshold of in-flight requests above which we will start using 511 * blk_io_plug()/blk_io_unplug() to batch requests. 512 */ 513 #define IO_PLUG_THRESHOLD 1 514 515 static bool xen_block_handle_requests(XenBlockDataPlane *dataplane) 516 { 517 RING_IDX rc, rp; 518 XenBlockRequest *request; 519 int inflight_atstart = dataplane->requests_inflight; 520 int batched = 0; 521 bool done_something = false; 522 523 dataplane->more_work = 0; 524 525 rc = dataplane->rings.common.req_cons; 526 rp = dataplane->rings.common.sring->req_prod; 527 xen_rmb(); /* Ensure we see queued requests up to 'rp'. */ 528 529 /* 530 * If there was more than IO_PLUG_THRESHOLD requests in flight 531 * when we got here, this is an indication that there the bottleneck 532 * is below us, so it's worth beginning to batch up I/O requests 533 * rather than submitting them immediately. The maximum number 534 * of requests we're willing to batch is the number already in 535 * flight, so it can grow up to max_requests when the bottleneck 536 * is below us. 537 */ 538 if (inflight_atstart > IO_PLUG_THRESHOLD) { 539 blk_io_plug(dataplane->blk); 540 } 541 while (rc != rp) { 542 /* pull request from ring */ 543 if (RING_REQUEST_CONS_OVERFLOW(&dataplane->rings.common, rc)) { 544 break; 545 } 546 request = xen_block_start_request(dataplane); 547 if (request == NULL) { 548 dataplane->more_work++; 549 break; 550 } 551 xen_block_get_request(dataplane, request, rc); 552 dataplane->rings.common.req_cons = ++rc; 553 done_something = true; 554 555 /* parse them */ 556 if (xen_block_parse_request(request) != 0) { 557 switch (request->req.operation) { 558 case BLKIF_OP_READ: 559 block_acct_invalid(blk_get_stats(dataplane->blk), 560 BLOCK_ACCT_READ); 561 break; 562 case BLKIF_OP_WRITE: 563 block_acct_invalid(blk_get_stats(dataplane->blk), 564 BLOCK_ACCT_WRITE); 565 break; 566 case BLKIF_OP_FLUSH_DISKCACHE: 567 block_acct_invalid(blk_get_stats(dataplane->blk), 568 BLOCK_ACCT_FLUSH); 569 default: 570 break; 571 }; 572 573 xen_block_complete_request(request); 574 continue; 575 } 576 577 if (inflight_atstart > IO_PLUG_THRESHOLD && 578 batched >= inflight_atstart) { 579 blk_io_unplug(dataplane->blk); 580 } 581 xen_block_do_aio(request); 582 if (inflight_atstart > IO_PLUG_THRESHOLD) { 583 if (batched >= inflight_atstart) { 584 blk_io_plug(dataplane->blk); 585 batched = 0; 586 } else { 587 batched++; 588 } 589 } 590 } 591 if (inflight_atstart > IO_PLUG_THRESHOLD) { 592 blk_io_unplug(dataplane->blk); 593 } 594 595 return done_something; 596 } 597 598 static void xen_block_dataplane_bh(void *opaque) 599 { 600 XenBlockDataPlane *dataplane = opaque; 601 602 aio_context_acquire(dataplane->ctx); 603 xen_block_handle_requests(dataplane); 604 aio_context_release(dataplane->ctx); 605 } 606 607 static bool xen_block_dataplane_event(void *opaque) 608 { 609 XenBlockDataPlane *dataplane = opaque; 610 611 return xen_block_handle_requests(dataplane); 612 } 613 614 XenBlockDataPlane *xen_block_dataplane_create(XenDevice *xendev, 615 BlockBackend *blk, 616 unsigned int sector_size, 617 IOThread *iothread) 618 { 619 XenBlockDataPlane *dataplane = g_new0(XenBlockDataPlane, 1); 620 621 dataplane->xendev = xendev; 622 dataplane->blk = blk; 623 dataplane->sector_size = sector_size; 624 625 QLIST_INIT(&dataplane->inflight); 626 QLIST_INIT(&dataplane->freelist); 627 628 if (iothread) { 629 dataplane->iothread = iothread; 630 object_ref(OBJECT(dataplane->iothread)); 631 dataplane->ctx = iothread_get_aio_context(dataplane->iothread); 632 } else { 633 dataplane->ctx = qemu_get_aio_context(); 634 } 635 dataplane->bh = aio_bh_new(dataplane->ctx, xen_block_dataplane_bh, 636 dataplane); 637 638 return dataplane; 639 } 640 641 void xen_block_dataplane_destroy(XenBlockDataPlane *dataplane) 642 { 643 XenBlockRequest *request; 644 645 if (!dataplane) { 646 return; 647 } 648 649 while (!QLIST_EMPTY(&dataplane->freelist)) { 650 request = QLIST_FIRST(&dataplane->freelist); 651 QLIST_REMOVE(request, list); 652 qemu_iovec_destroy(&request->v); 653 qemu_vfree(request->buf); 654 g_free(request); 655 } 656 657 qemu_bh_delete(dataplane->bh); 658 if (dataplane->iothread) { 659 object_unref(OBJECT(dataplane->iothread)); 660 } 661 662 g_free(dataplane); 663 } 664 665 void xen_block_dataplane_stop(XenBlockDataPlane *dataplane) 666 { 667 XenDevice *xendev; 668 669 if (!dataplane) { 670 return; 671 } 672 673 xendev = dataplane->xendev; 674 675 aio_context_acquire(dataplane->ctx); 676 if (dataplane->event_channel) { 677 /* Only reason for failure is a NULL channel */ 678 xen_device_set_event_channel_context(xendev, dataplane->event_channel, 679 qemu_get_aio_context(), 680 &error_abort); 681 } 682 /* Xen doesn't have multiple users for nodes, so this can't fail */ 683 blk_set_aio_context(dataplane->blk, qemu_get_aio_context(), &error_abort); 684 aio_context_release(dataplane->ctx); 685 686 /* 687 * Now that the context has been moved onto the main thread, cancel 688 * further processing. 689 */ 690 qemu_bh_cancel(dataplane->bh); 691 692 if (dataplane->event_channel) { 693 Error *local_err = NULL; 694 695 xen_device_unbind_event_channel(xendev, dataplane->event_channel, 696 &local_err); 697 dataplane->event_channel = NULL; 698 699 if (local_err) { 700 error_report_err(local_err); 701 } 702 } 703 704 if (dataplane->sring) { 705 Error *local_err = NULL; 706 707 xen_device_unmap_grant_refs(xendev, dataplane->sring, 708 dataplane->nr_ring_ref, &local_err); 709 dataplane->sring = NULL; 710 711 if (local_err) { 712 error_report_err(local_err); 713 } 714 } 715 716 g_free(dataplane->ring_ref); 717 dataplane->ring_ref = NULL; 718 } 719 720 void xen_block_dataplane_start(XenBlockDataPlane *dataplane, 721 const unsigned int ring_ref[], 722 unsigned int nr_ring_ref, 723 unsigned int event_channel, 724 unsigned int protocol, 725 Error **errp) 726 { 727 ERRP_GUARD(); 728 XenDevice *xendev = dataplane->xendev; 729 AioContext *old_context; 730 unsigned int ring_size; 731 unsigned int i; 732 733 dataplane->nr_ring_ref = nr_ring_ref; 734 dataplane->ring_ref = g_new(unsigned int, nr_ring_ref); 735 736 for (i = 0; i < nr_ring_ref; i++) { 737 dataplane->ring_ref[i] = ring_ref[i]; 738 } 739 740 dataplane->protocol = protocol; 741 742 ring_size = XC_PAGE_SIZE * dataplane->nr_ring_ref; 743 switch (dataplane->protocol) { 744 case BLKIF_PROTOCOL_NATIVE: 745 { 746 dataplane->max_requests = __CONST_RING_SIZE(blkif, ring_size); 747 break; 748 } 749 case BLKIF_PROTOCOL_X86_32: 750 { 751 dataplane->max_requests = __CONST_RING_SIZE(blkif_x86_32, ring_size); 752 break; 753 } 754 case BLKIF_PROTOCOL_X86_64: 755 { 756 dataplane->max_requests = __CONST_RING_SIZE(blkif_x86_64, ring_size); 757 break; 758 } 759 default: 760 error_setg(errp, "unknown protocol %u", dataplane->protocol); 761 return; 762 } 763 764 xen_device_set_max_grant_refs(xendev, dataplane->nr_ring_ref, 765 errp); 766 if (*errp) { 767 goto stop; 768 } 769 770 dataplane->sring = xen_device_map_grant_refs(xendev, 771 dataplane->ring_ref, 772 dataplane->nr_ring_ref, 773 PROT_READ | PROT_WRITE, 774 errp); 775 if (*errp) { 776 goto stop; 777 } 778 779 switch (dataplane->protocol) { 780 case BLKIF_PROTOCOL_NATIVE: 781 { 782 blkif_sring_t *sring_native = dataplane->sring; 783 784 BACK_RING_INIT(&dataplane->rings.native, sring_native, ring_size); 785 break; 786 } 787 case BLKIF_PROTOCOL_X86_32: 788 { 789 blkif_x86_32_sring_t *sring_x86_32 = dataplane->sring; 790 791 BACK_RING_INIT(&dataplane->rings.x86_32_part, sring_x86_32, 792 ring_size); 793 break; 794 } 795 case BLKIF_PROTOCOL_X86_64: 796 { 797 blkif_x86_64_sring_t *sring_x86_64 = dataplane->sring; 798 799 BACK_RING_INIT(&dataplane->rings.x86_64_part, sring_x86_64, 800 ring_size); 801 break; 802 } 803 } 804 805 dataplane->event_channel = 806 xen_device_bind_event_channel(xendev, event_channel, 807 xen_block_dataplane_event, dataplane, 808 errp); 809 if (*errp) { 810 goto stop; 811 } 812 813 old_context = blk_get_aio_context(dataplane->blk); 814 aio_context_acquire(old_context); 815 /* If other users keep the BlockBackend in the iothread, that's ok */ 816 blk_set_aio_context(dataplane->blk, dataplane->ctx, NULL); 817 aio_context_release(old_context); 818 819 /* Only reason for failure is a NULL channel */ 820 aio_context_acquire(dataplane->ctx); 821 xen_device_set_event_channel_context(xendev, dataplane->event_channel, 822 dataplane->ctx, &error_abort); 823 aio_context_release(dataplane->ctx); 824 825 return; 826 827 stop: 828 xen_block_dataplane_stop(dataplane); 829 }