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