hw/block/dataplane/xen-block.c

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