block/block-backend.c

   1 /*
   2  * QEMU Block backends
   3  *
   4  * Copyright (C) 2014 Red Hat, Inc.
   5  *
   6  * Authors:
   7  *  Markus Armbruster <armbru@redhat.com>,
   8  *
   9  * This work is licensed under the terms of the GNU LGPL, version 2.1
  10  * or later.  See the COPYING.LIB file in the top-level directory.
  11  */
  12
  13 #include "sysemu/block-backend.h"
  14 #include "block/block_int.h"
  15 #include "sysemu/blockdev.h"
  16 #include "qapi-event.h"
  17
  18 /* Number of coroutines to reserve per attached device model */
  19 #define COROUTINE_POOL_RESERVATION 64
  20
  21 struct BlockBackend {
  22     char *name;
  23     int refcnt;
  24     BlockDriverState *bs;
  25     DriveInfo *legacy_dinfo;    /* null unless created by drive_new() */
  26     QTAILQ_ENTRY(BlockBackend) link; /* for blk_backends */
  27
  28     void *dev;                  /* attached device model, if any */
  29     /* TODO change to DeviceState when all users are qdevified */
  30     const BlockDevOps *dev_ops;
  31     void *dev_opaque;
  32 };
  33
  34 static void drive_info_del(DriveInfo *dinfo);
  35
  36 /* All the BlockBackends (except for hidden ones) */
  37 static QTAILQ_HEAD(, BlockBackend) blk_backends =
  38     QTAILQ_HEAD_INITIALIZER(blk_backends);
  39
  40 /*
  41  * Create a new BlockBackend with @name, with a reference count of one.
  42  * @name must not be null or empty.
  43  * Fail if a BlockBackend with this name already exists.
  44  * Store an error through @errp on failure, unless it's null.
  45  * Return the new BlockBackend on success, null on failure.
  46  */
  47 BlockBackend *blk_new(const char *name, Error **errp)
  48 {
  49     BlockBackend *blk;
  50
  51     assert(name && name[0]);
  52     if (!id_wellformed(name)) {
  53         error_setg(errp, "Invalid device name");
  54         return NULL;
  55     }
  56     if (blk_by_name(name)) {
  57         error_setg(errp, "Device with id '%s' already exists", name);
  58         return NULL;
  59     }
  60     if (bdrv_find_node(name)) {
  61         error_setg(errp,
  62                    "Device name '%s' conflicts with an existing node name",
  63                    name);
  64         return NULL;
  65     }
  66
  67     blk = g_new0(BlockBackend, 1);
  68     blk->name = g_strdup(name);
  69     blk->refcnt = 1;
  70     QTAILQ_INSERT_TAIL(&blk_backends, blk, link);
  71     return blk;
  72 }
  73
  74 /*
  75  * Create a new BlockBackend with a new BlockDriverState attached.
  76  * Otherwise just like blk_new(), which see.
  77  */
  78 BlockBackend *blk_new_with_bs(const char *name, Error **errp)
  79 {
  80     BlockBackend *blk;
  81     BlockDriverState *bs;
  82
  83     blk = blk_new(name, errp);
  84     if (!blk) {
  85         return NULL;
  86     }
  87
  88     bs = bdrv_new_root();
  89     blk->bs = bs;
  90     bs->blk = blk;
  91     return blk;
  92 }
  93
  94 static void blk_delete(BlockBackend *blk)
  95 {
  96     assert(!blk->refcnt);
  97     assert(!blk->dev);
  98     if (blk->bs) {
  99         assert(blk->bs->blk == blk);
 100         blk->bs->blk = NULL;
 101         bdrv_unref(blk->bs);
 102         blk->bs = NULL;
 103     }
 104     /* Avoid double-remove after blk_hide_on_behalf_of_do_drive_del() */
 105     if (blk->name[0]) {
 106         QTAILQ_REMOVE(&blk_backends, blk, link);
 107     }
 108     g_free(blk->name);
 109     drive_info_del(blk->legacy_dinfo);
 110     g_free(blk);
 111 }
 112
 113 static void drive_info_del(DriveInfo *dinfo)
 114 {
 115     if (!dinfo) {
 116         return;
 117     }
 118     qemu_opts_del(dinfo->opts);
 119     g_free(dinfo->serial);
 120     g_free(dinfo);
 121 }
 122
 123 /*
 124  * Increment @blk's reference count.
 125  * @blk must not be null.
 126  */
 127 void blk_ref(BlockBackend *blk)
 128 {
 129     blk->refcnt++;
 130 }
 131
 132 /*
 133  * Decrement @blk's reference count.
 134  * If this drops it to zero, destroy @blk.
 135  * For convenience, do nothing if @blk is null.
 136  */
 137 void blk_unref(BlockBackend *blk)
 138 {
 139     if (blk) {
 140         assert(blk->refcnt > 0);
 141         if (!--blk->refcnt) {
 142             blk_delete(blk);
 143         }
 144     }
 145 }
 146
 147 /*
 148  * Return the BlockBackend after @blk.
 149  * If @blk is null, return the first one.
 150  * Else, return @blk's next sibling, which may be null.
 151  *
 152  * To iterate over all BlockBackends, do
 153  * for (blk = blk_next(NULL); blk; blk = blk_next(blk)) {
 154  *     ...
 155  * }
 156  */
 157 BlockBackend *blk_next(BlockBackend *blk)
 158 {
 159     return blk ? QTAILQ_NEXT(blk, link) : QTAILQ_FIRST(&blk_backends);
 160 }
 161
 162 /*
 163  * Return @blk's name, a non-null string.
 164  * Wart: the name is empty iff @blk has been hidden with
 165  * blk_hide_on_behalf_of_do_drive_del().
 166  */
 167 const char *blk_name(BlockBackend *blk)
 168 {
 169     return blk->name;
 170 }
 171
 172 /*
 173  * Return the BlockBackend with name @name if it exists, else null.
 174  * @name must not be null.
 175  */
 176 BlockBackend *blk_by_name(const char *name)
 177 {
 178     BlockBackend *blk;
 179
 180     assert(name);
 181     QTAILQ_FOREACH(blk, &blk_backends, link) {
 182         if (!strcmp(name, blk->name)) {
 183             return blk;
 184         }
 185     }
 186     return NULL;
 187 }
 188
 189 /*
 190  * Return the BlockDriverState attached to @blk if any, else null.
 191  */
 192 BlockDriverState *blk_bs(BlockBackend *blk)
 193 {
 194     return blk->bs;
 195 }
 196
 197 /*
 198  * Return @blk's DriveInfo if any, else null.
 199  */
 200 DriveInfo *blk_legacy_dinfo(BlockBackend *blk)
 201 {
 202     return blk->legacy_dinfo;
 203 }
 204
 205 /*
 206  * Set @blk's DriveInfo to @dinfo, and return it.
 207  * @blk must not have a DriveInfo set already.
 208  * No other BlockBackend may have the same DriveInfo set.
 209  */
 210 DriveInfo *blk_set_legacy_dinfo(BlockBackend *blk, DriveInfo *dinfo)
 211 {
 212     assert(!blk->legacy_dinfo);
 213     return blk->legacy_dinfo = dinfo;
 214 }
 215
 216 /*
 217  * Return the BlockBackend with DriveInfo @dinfo.
 218  * It must exist.
 219  */
 220 BlockBackend *blk_by_legacy_dinfo(DriveInfo *dinfo)
 221 {
 222     BlockBackend *blk;
 223
 224     QTAILQ_FOREACH(blk, &blk_backends, link) {
 225         if (blk->legacy_dinfo == dinfo) {
 226             return blk;
 227         }
 228     }
 229     abort();
 230 }
 231
 232 /*
 233  * Hide @blk.
 234  * @blk must not have been hidden already.
 235  * Make attached BlockDriverState, if any, anonymous.
 236  * Once hidden, @blk is invisible to all functions that don't receive
 237  * it as argument.  For example, blk_by_name() won't return it.
 238  * Strictly for use by do_drive_del().
 239  * TODO get rid of it!
 240  */
 241 void blk_hide_on_behalf_of_do_drive_del(BlockBackend *blk)
 242 {
 243     QTAILQ_REMOVE(&blk_backends, blk, link);
 244     blk->name[0] = 0;
 245     if (blk->bs) {
 246         bdrv_make_anon(blk->bs);
 247     }
 248 }
 249
 250 /*
 251  * Attach device model @dev to @blk.
 252  * Return 0 on success, -EBUSY when a device model is attached already.
 253  */
 254 int blk_attach_dev(BlockBackend *blk, void *dev)
 255 /* TODO change to DeviceState *dev when all users are qdevified */
 256 {
 257     if (blk->dev) {
 258         return -EBUSY;
 259     }
 260     blk_ref(blk);
 261     blk->dev = dev;
 262     bdrv_iostatus_reset(blk->bs);
 263
 264     /* We're expecting I/O from the device so bump up coroutine pool size */
 265     qemu_coroutine_adjust_pool_size(COROUTINE_POOL_RESERVATION);
 266     return 0;
 267 }
 268
 269 /*
 270  * Attach device model @dev to @blk.
 271  * @blk must not have a device model attached already.
 272  * TODO qdevified devices don't use this, remove when devices are qdevified
 273  */
 274 void blk_attach_dev_nofail(BlockBackend *blk, void *dev)
 275 {
 276     if (blk_attach_dev(blk, dev) < 0) {
 277         abort();
 278     }
 279 }
 280
 281 /*
 282  * Detach device model @dev from @blk.
 283  * @dev must be currently attached to @blk.
 284  */
 285 void blk_detach_dev(BlockBackend *blk, void *dev)
 286 /* TODO change to DeviceState *dev when all users are qdevified */
 287 {
 288     assert(blk->dev == dev);
 289     blk->dev = NULL;
 290     blk->dev_ops = NULL;
 291     blk->dev_opaque = NULL;
 292     bdrv_set_guest_block_size(blk->bs, 512);
 293     qemu_coroutine_adjust_pool_size(-COROUTINE_POOL_RESERVATION);
 294     blk_unref(blk);
 295 }
 296
 297 /*
 298  * Return the device model attached to @blk if any, else null.
 299  */
 300 void *blk_get_attached_dev(BlockBackend *blk)
 301 /* TODO change to return DeviceState * when all users are qdevified */
 302 {
 303     return blk->dev;
 304 }
 305
 306 /*
 307  * Set @blk's device model callbacks to @ops.
 308  * @opaque is the opaque argument to pass to the callbacks.
 309  * This is for use by device models.
 310  */
 311 void blk_set_dev_ops(BlockBackend *blk, const BlockDevOps *ops,
 312                      void *opaque)
 313 {
 314     blk->dev_ops = ops;
 315     blk->dev_opaque = opaque;
 316 }
 317
 318 /*
 319  * Notify @blk's attached device model of media change.
 320  * If @load is true, notify of media load.
 321  * Else, notify of media eject.
 322  * Also send DEVICE_TRAY_MOVED events as appropriate.
 323  */
 324 void blk_dev_change_media_cb(BlockBackend *blk, bool load)
 325 {
 326     if (blk->dev_ops && blk->dev_ops->change_media_cb) {
 327         bool tray_was_closed = !blk_dev_is_tray_open(blk);
 328
 329         blk->dev_ops->change_media_cb(blk->dev_opaque, load);
 330         if (tray_was_closed) {
 331             /* tray open */
 332             qapi_event_send_device_tray_moved(blk_name(blk),
 333                                               true, &error_abort);
 334         }
 335         if (load) {
 336             /* tray close */
 337             qapi_event_send_device_tray_moved(blk_name(blk),
 338                                               false, &error_abort);
 339         }
 340     }
 341 }
 342
 343 /*
 344  * Does @blk's attached device model have removable media?
 345  * %true if no device model is attached.
 346  */
 347 bool blk_dev_has_removable_media(BlockBackend *blk)
 348 {
 349     return !blk->dev || (blk->dev_ops && blk->dev_ops->change_media_cb);
 350 }
 351
 352 /*
 353  * Notify @blk's attached device model of a media eject request.
 354  * If @force is true, the medium is about to be yanked out forcefully.
 355  */
 356 void blk_dev_eject_request(BlockBackend *blk, bool force)
 357 {
 358     if (blk->dev_ops && blk->dev_ops->eject_request_cb) {
 359         blk->dev_ops->eject_request_cb(blk->dev_opaque, force);
 360     }
 361 }
 362
 363 /*
 364  * Does @blk's attached device model have a tray, and is it open?
 365  */
 366 bool blk_dev_is_tray_open(BlockBackend *blk)
 367 {
 368     if (blk->dev_ops && blk->dev_ops->is_tray_open) {
 369         return blk->dev_ops->is_tray_open(blk->dev_opaque);
 370     }
 371     return false;
 372 }
 373
 374 /*
 375  * Does @blk's attached device model have the medium locked?
 376  * %false if the device model has no such lock.
 377  */
 378 bool blk_dev_is_medium_locked(BlockBackend *blk)
 379 {
 380     if (blk->dev_ops && blk->dev_ops->is_medium_locked) {
 381         return blk->dev_ops->is_medium_locked(blk->dev_opaque);
 382     }
 383     return false;
 384 }
 385
 386 /*
 387  * Notify @blk's attached device model of a backend size change.
 388  */
 389 void blk_dev_resize_cb(BlockBackend *blk)
 390 {
 391     if (blk->dev_ops && blk->dev_ops->resize_cb) {
 392         blk->dev_ops->resize_cb(blk->dev_opaque);
 393     }
 394 }
 395
 396 void blk_iostatus_enable(BlockBackend *blk)
 397 {
 398     bdrv_iostatus_enable(blk->bs);
 399 }
 400
 401 int blk_read(BlockBackend *blk, int64_t sector_num, uint8_t *buf,
 402              int nb_sectors)
 403 {
 404     return bdrv_read(blk->bs, sector_num, buf, nb_sectors);
 405 }
 406
 407 int blk_read_unthrottled(BlockBackend *blk, int64_t sector_num, uint8_t *buf,
 408                          int nb_sectors)
 409 {
 410     return bdrv_read_unthrottled(blk->bs, sector_num, buf, nb_sectors);
 411 }
 412
 413 int blk_write(BlockBackend *blk, int64_t sector_num, const uint8_t *buf,
 414               int nb_sectors)
 415 {
 416     return bdrv_write(blk->bs, sector_num, buf, nb_sectors);
 417 }
 418
 419 BlockAIOCB *blk_aio_write_zeroes(BlockBackend *blk, int64_t sector_num,
 420                                  int nb_sectors, BdrvRequestFlags flags,
 421                                  BlockCompletionFunc *cb, void *opaque)
 422 {
 423     return bdrv_aio_write_zeroes(blk->bs, sector_num, nb_sectors, flags,
 424                                  cb, opaque);
 425 }
 426
 427 int blk_pread(BlockBackend *blk, int64_t offset, void *buf, int count)
 428 {
 429     return bdrv_pread(blk->bs, offset, buf, count);
 430 }
 431
 432 int blk_pwrite(BlockBackend *blk, int64_t offset, const void *buf, int count)
 433 {
 434     return bdrv_pwrite(blk->bs, offset, buf, count);
 435 }
 436
 437 int64_t blk_getlength(BlockBackend *blk)
 438 {
 439     return bdrv_getlength(blk->bs);
 440 }
 441
 442 void blk_get_geometry(BlockBackend *blk, uint64_t *nb_sectors_ptr)
 443 {
 444     bdrv_get_geometry(blk->bs, nb_sectors_ptr);
 445 }
 446
 447 BlockAIOCB *blk_aio_readv(BlockBackend *blk, int64_t sector_num,
 448                           QEMUIOVector *iov, int nb_sectors,
 449                           BlockCompletionFunc *cb, void *opaque)
 450 {
 451     return bdrv_aio_readv(blk->bs, sector_num, iov, nb_sectors, cb, opaque);
 452 }
 453
 454 BlockAIOCB *blk_aio_writev(BlockBackend *blk, int64_t sector_num,
 455                            QEMUIOVector *iov, int nb_sectors,
 456                            BlockCompletionFunc *cb, void *opaque)
 457 {
 458     return bdrv_aio_writev(blk->bs, sector_num, iov, nb_sectors, cb, opaque);
 459 }
 460
 461 BlockAIOCB *blk_aio_flush(BlockBackend *blk,
 462                           BlockCompletionFunc *cb, void *opaque)
 463 {
 464     return bdrv_aio_flush(blk->bs, cb, opaque);
 465 }
 466
 467 BlockAIOCB *blk_aio_discard(BlockBackend *blk,
 468                             int64_t sector_num, int nb_sectors,
 469                             BlockCompletionFunc *cb, void *opaque)
 470 {
 471     return bdrv_aio_discard(blk->bs, sector_num, nb_sectors, cb, opaque);
 472 }
 473
 474 void blk_aio_cancel(BlockAIOCB *acb)
 475 {
 476     bdrv_aio_cancel(acb);
 477 }
 478
 479 void blk_aio_cancel_async(BlockAIOCB *acb)
 480 {
 481     bdrv_aio_cancel_async(acb);
 482 }
 483
 484 int blk_aio_multiwrite(BlockBackend *blk, BlockRequest *reqs, int num_reqs)
 485 {
 486     return bdrv_aio_multiwrite(blk->bs, reqs, num_reqs);
 487 }
 488
 489 int blk_ioctl(BlockBackend *blk, unsigned long int req, void *buf)
 490 {
 491     return bdrv_ioctl(blk->bs, req, buf);
 492 }
 493
 494 BlockAIOCB *blk_aio_ioctl(BlockBackend *blk, unsigned long int req, void *buf,
 495                           BlockCompletionFunc *cb, void *opaque)
 496 {
 497     return bdrv_aio_ioctl(blk->bs, req, buf, cb, opaque);
 498 }
 499
 500 int blk_co_discard(BlockBackend *blk, int64_t sector_num, int nb_sectors)
 501 {
 502     return bdrv_co_discard(blk->bs, sector_num, nb_sectors);
 503 }
 504
 505 int blk_co_flush(BlockBackend *blk)
 506 {
 507     return bdrv_co_flush(blk->bs);
 508 }
 509
 510 int blk_flush(BlockBackend *blk)
 511 {
 512     return bdrv_flush(blk->bs);
 513 }
 514
 515 int blk_flush_all(void)
 516 {
 517     return bdrv_flush_all();
 518 }
 519
 520 void blk_drain_all(void)
 521 {
 522     bdrv_drain_all();
 523 }
 524
 525 BlockdevOnError blk_get_on_error(BlockBackend *blk, bool is_read)
 526 {
 527     return bdrv_get_on_error(blk->bs, is_read);
 528 }
 529
 530 BlockErrorAction blk_get_error_action(BlockBackend *blk, bool is_read,
 531                                       int error)
 532 {
 533     return bdrv_get_error_action(blk->bs, is_read, error);
 534 }
 535
 536 void blk_error_action(BlockBackend *blk, BlockErrorAction action,
 537                       bool is_read, int error)
 538 {
 539     bdrv_error_action(blk->bs, action, is_read, error);
 540 }
 541
 542 int blk_is_read_only(BlockBackend *blk)
 543 {
 544     return bdrv_is_read_only(blk->bs);
 545 }
 546
 547 int blk_is_sg(BlockBackend *blk)
 548 {
 549     return bdrv_is_sg(blk->bs);
 550 }
 551
 552 int blk_enable_write_cache(BlockBackend *blk)
 553 {
 554     return bdrv_enable_write_cache(blk->bs);
 555 }
 556
 557 void blk_set_enable_write_cache(BlockBackend *blk, bool wce)
 558 {
 559     bdrv_set_enable_write_cache(blk->bs, wce);
 560 }
 561
 562 void blk_invalidate_cache(BlockBackend *blk, Error **errp)
 563 {
 564     bdrv_invalidate_cache(blk->bs, errp);
 565 }
 566
 567 int blk_is_inserted(BlockBackend *blk)
 568 {
 569     return bdrv_is_inserted(blk->bs);
 570 }
 571
 572 void blk_lock_medium(BlockBackend *blk, bool locked)
 573 {
 574     bdrv_lock_medium(blk->bs, locked);
 575 }
 576
 577 void blk_eject(BlockBackend *blk, bool eject_flag)
 578 {
 579     bdrv_eject(blk->bs, eject_flag);
 580 }
 581
 582 int blk_get_flags(BlockBackend *blk)
 583 {
 584     return bdrv_get_flags(blk->bs);
 585 }
 586
 587 void blk_set_guest_block_size(BlockBackend *blk, int align)
 588 {
 589     bdrv_set_guest_block_size(blk->bs, align);
 590 }
 591
 592 void *blk_blockalign(BlockBackend *blk, size_t size)
 593 {
 594     return qemu_blockalign(blk ? blk->bs : NULL, size);
 595 }
 596
 597 bool blk_op_is_blocked(BlockBackend *blk, BlockOpType op, Error **errp)
 598 {
 599     return bdrv_op_is_blocked(blk->bs, op, errp);
 600 }
 601
 602 void blk_op_unblock(BlockBackend *blk, BlockOpType op, Error *reason)
 603 {
 604     bdrv_op_unblock(blk->bs, op, reason);
 605 }
 606
 607 void blk_op_block_all(BlockBackend *blk, Error *reason)
 608 {
 609     bdrv_op_block_all(blk->bs, reason);
 610 }
 611
 612 void blk_op_unblock_all(BlockBackend *blk, Error *reason)
 613 {
 614     bdrv_op_unblock_all(blk->bs, reason);
 615 }
 616
 617 AioContext *blk_get_aio_context(BlockBackend *blk)
 618 {
 619     return bdrv_get_aio_context(blk->bs);
 620 }
 621
 622 void blk_set_aio_context(BlockBackend *blk, AioContext *new_context)
 623 {
 624     bdrv_set_aio_context(blk->bs, new_context);
 625 }
 626
 627 void blk_add_aio_context_notifier(BlockBackend *blk,
 628         void (*attached_aio_context)(AioContext *new_context, void *opaque),
 629         void (*detach_aio_context)(void *opaque), void *opaque)
 630 {
 631     bdrv_add_aio_context_notifier(blk->bs, attached_aio_context,
 632                                   detach_aio_context, opaque);
 633 }
 634
 635 void blk_remove_aio_context_notifier(BlockBackend *blk,
 636                                      void (*attached_aio_context)(AioContext *,
 637                                                                   void *),
 638                                      void (*detach_aio_context)(void *),
 639                                      void *opaque)
 640 {
 641     bdrv_remove_aio_context_notifier(blk->bs, attached_aio_context,
 642                                      detach_aio_context, opaque);
 643 }
 644
 645 void blk_add_close_notifier(BlockBackend *blk, Notifier *notify)
 646 {
 647     bdrv_add_close_notifier(blk->bs, notify);
 648 }
 649
 650 void blk_io_plug(BlockBackend *blk)
 651 {
 652     bdrv_io_plug(blk->bs);
 653 }
 654
 655 void blk_io_unplug(BlockBackend *blk)
 656 {
 657     bdrv_io_unplug(blk->bs);
 658 }
 659
 660 BlockAcctStats *blk_get_stats(BlockBackend *blk)
 661 {
 662     return bdrv_get_stats(blk->bs);
 663 }
 664
 665 void *blk_aio_get(const AIOCBInfo *aiocb_info, BlockBackend *blk,
 666                   BlockCompletionFunc *cb, void *opaque)
 667 {
 668     return qemu_aio_get(aiocb_info, blk_bs(blk), cb, opaque);
 669 }