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 return 0; 264 } 265 266 /* 267 * Attach device model @dev to @blk. 268 * @blk must not have a device model attached already. 269 * TODO qdevified devices don't use this, remove when devices are qdevified 270 */ 271 void blk_attach_dev_nofail(BlockBackend *blk, void *dev) 272 { 273 if (blk_attach_dev(blk, dev) < 0) { 274 abort(); 275 } 276 } 277 278 /* 279 * Detach device model @dev from @blk. 280 * @dev must be currently attached to @blk. 281 */ 282 void blk_detach_dev(BlockBackend *blk, void *dev) 283 /* TODO change to DeviceState *dev when all users are qdevified */ 284 { 285 assert(blk->dev == dev); 286 blk->dev = NULL; 287 blk->dev_ops = NULL; 288 blk->dev_opaque = NULL; 289 bdrv_set_guest_block_size(blk->bs, 512); 290 blk_unref(blk); 291 } 292 293 /* 294 * Return the device model attached to @blk if any, else null. 295 */ 296 void *blk_get_attached_dev(BlockBackend *blk) 297 /* TODO change to return DeviceState * when all users are qdevified */ 298 { 299 return blk->dev; 300 } 301 302 /* 303 * Set @blk's device model callbacks to @ops. 304 * @opaque is the opaque argument to pass to the callbacks. 305 * This is for use by device models. 306 */ 307 void blk_set_dev_ops(BlockBackend *blk, const BlockDevOps *ops, 308 void *opaque) 309 { 310 blk->dev_ops = ops; 311 blk->dev_opaque = opaque; 312 } 313 314 /* 315 * Notify @blk's attached device model of media change. 316 * If @load is true, notify of media load. 317 * Else, notify of media eject. 318 * Also send DEVICE_TRAY_MOVED events as appropriate. 319 */ 320 void blk_dev_change_media_cb(BlockBackend *blk, bool load) 321 { 322 if (blk->dev_ops && blk->dev_ops->change_media_cb) { 323 bool tray_was_closed = !blk_dev_is_tray_open(blk); 324 325 blk->dev_ops->change_media_cb(blk->dev_opaque, load); 326 if (tray_was_closed) { 327 /* tray open */ 328 qapi_event_send_device_tray_moved(blk_name(blk), 329 true, &error_abort); 330 } 331 if (load) { 332 /* tray close */ 333 qapi_event_send_device_tray_moved(blk_name(blk), 334 false, &error_abort); 335 } 336 } 337 } 338 339 /* 340 * Does @blk's attached device model have removable media? 341 * %true if no device model is attached. 342 */ 343 bool blk_dev_has_removable_media(BlockBackend *blk) 344 { 345 return !blk->dev || (blk->dev_ops && blk->dev_ops->change_media_cb); 346 } 347 348 /* 349 * Notify @blk's attached device model of a media eject request. 350 * If @force is true, the medium is about to be yanked out forcefully. 351 */ 352 void blk_dev_eject_request(BlockBackend *blk, bool force) 353 { 354 if (blk->dev_ops && blk->dev_ops->eject_request_cb) { 355 blk->dev_ops->eject_request_cb(blk->dev_opaque, force); 356 } 357 } 358 359 /* 360 * Does @blk's attached device model have a tray, and is it open? 361 */ 362 bool blk_dev_is_tray_open(BlockBackend *blk) 363 { 364 if (blk->dev_ops && blk->dev_ops->is_tray_open) { 365 return blk->dev_ops->is_tray_open(blk->dev_opaque); 366 } 367 return false; 368 } 369 370 /* 371 * Does @blk's attached device model have the medium locked? 372 * %false if the device model has no such lock. 373 */ 374 bool blk_dev_is_medium_locked(BlockBackend *blk) 375 { 376 if (blk->dev_ops && blk->dev_ops->is_medium_locked) { 377 return blk->dev_ops->is_medium_locked(blk->dev_opaque); 378 } 379 return false; 380 } 381 382 /* 383 * Notify @blk's attached device model of a backend size change. 384 */ 385 void blk_dev_resize_cb(BlockBackend *blk) 386 { 387 if (blk->dev_ops && blk->dev_ops->resize_cb) { 388 blk->dev_ops->resize_cb(blk->dev_opaque); 389 } 390 } 391 392 void blk_iostatus_enable(BlockBackend *blk) 393 { 394 bdrv_iostatus_enable(blk->bs); 395 } 396 397 int blk_read(BlockBackend *blk, int64_t sector_num, uint8_t *buf, 398 int nb_sectors) 399 { 400 return bdrv_read(blk->bs, sector_num, buf, nb_sectors); 401 } 402 403 int blk_read_unthrottled(BlockBackend *blk, int64_t sector_num, uint8_t *buf, 404 int nb_sectors) 405 { 406 return bdrv_read_unthrottled(blk->bs, sector_num, buf, nb_sectors); 407 } 408 409 int blk_write(BlockBackend *blk, int64_t sector_num, const uint8_t *buf, 410 int nb_sectors) 411 { 412 return bdrv_write(blk->bs, sector_num, buf, nb_sectors); 413 } 414 415 BlockAIOCB *blk_aio_write_zeroes(BlockBackend *blk, int64_t sector_num, 416 int nb_sectors, BdrvRequestFlags flags, 417 BlockCompletionFunc *cb, void *opaque) 418 { 419 return bdrv_aio_write_zeroes(blk->bs, sector_num, nb_sectors, flags, 420 cb, opaque); 421 } 422 423 int blk_pread(BlockBackend *blk, int64_t offset, void *buf, int count) 424 { 425 return bdrv_pread(blk->bs, offset, buf, count); 426 } 427 428 int blk_pwrite(BlockBackend *blk, int64_t offset, const void *buf, int count) 429 { 430 return bdrv_pwrite(blk->bs, offset, buf, count); 431 } 432 433 int64_t blk_getlength(BlockBackend *blk) 434 { 435 return bdrv_getlength(blk->bs); 436 } 437 438 void blk_get_geometry(BlockBackend *blk, uint64_t *nb_sectors_ptr) 439 { 440 bdrv_get_geometry(blk->bs, nb_sectors_ptr); 441 } 442 443 BlockAIOCB *blk_aio_readv(BlockBackend *blk, int64_t sector_num, 444 QEMUIOVector *iov, int nb_sectors, 445 BlockCompletionFunc *cb, void *opaque) 446 { 447 return bdrv_aio_readv(blk->bs, sector_num, iov, nb_sectors, cb, opaque); 448 } 449 450 BlockAIOCB *blk_aio_writev(BlockBackend *blk, int64_t sector_num, 451 QEMUIOVector *iov, int nb_sectors, 452 BlockCompletionFunc *cb, void *opaque) 453 { 454 return bdrv_aio_writev(blk->bs, sector_num, iov, nb_sectors, cb, opaque); 455 } 456 457 BlockAIOCB *blk_aio_flush(BlockBackend *blk, 458 BlockCompletionFunc *cb, void *opaque) 459 { 460 return bdrv_aio_flush(blk->bs, cb, opaque); 461 } 462 463 BlockAIOCB *blk_aio_discard(BlockBackend *blk, 464 int64_t sector_num, int nb_sectors, 465 BlockCompletionFunc *cb, void *opaque) 466 { 467 return bdrv_aio_discard(blk->bs, sector_num, nb_sectors, cb, opaque); 468 } 469 470 void blk_aio_cancel(BlockAIOCB *acb) 471 { 472 bdrv_aio_cancel(acb); 473 } 474 475 void blk_aio_cancel_async(BlockAIOCB *acb) 476 { 477 bdrv_aio_cancel_async(acb); 478 } 479 480 int blk_aio_multiwrite(BlockBackend *blk, BlockRequest *reqs, int num_reqs) 481 { 482 return bdrv_aio_multiwrite(blk->bs, reqs, num_reqs); 483 } 484 485 int blk_ioctl(BlockBackend *blk, unsigned long int req, void *buf) 486 { 487 return bdrv_ioctl(blk->bs, req, buf); 488 } 489 490 BlockAIOCB *blk_aio_ioctl(BlockBackend *blk, unsigned long int req, void *buf, 491 BlockCompletionFunc *cb, void *opaque) 492 { 493 return bdrv_aio_ioctl(blk->bs, req, buf, cb, opaque); 494 } 495 496 int blk_co_discard(BlockBackend *blk, int64_t sector_num, int nb_sectors) 497 { 498 return bdrv_co_discard(blk->bs, sector_num, nb_sectors); 499 } 500 501 int blk_co_flush(BlockBackend *blk) 502 { 503 return bdrv_co_flush(blk->bs); 504 } 505 506 int blk_flush(BlockBackend *blk) 507 { 508 return bdrv_flush(blk->bs); 509 } 510 511 int blk_flush_all(void) 512 { 513 return bdrv_flush_all(); 514 } 515 516 void blk_drain_all(void) 517 { 518 bdrv_drain_all(); 519 } 520 521 BlockdevOnError blk_get_on_error(BlockBackend *blk, bool is_read) 522 { 523 return bdrv_get_on_error(blk->bs, is_read); 524 } 525 526 BlockErrorAction blk_get_error_action(BlockBackend *blk, bool is_read, 527 int error) 528 { 529 return bdrv_get_error_action(blk->bs, is_read, error); 530 } 531 532 void blk_error_action(BlockBackend *blk, BlockErrorAction action, 533 bool is_read, int error) 534 { 535 bdrv_error_action(blk->bs, action, is_read, error); 536 } 537 538 int blk_is_read_only(BlockBackend *blk) 539 { 540 return bdrv_is_read_only(blk->bs); 541 } 542 543 int blk_is_sg(BlockBackend *blk) 544 { 545 return bdrv_is_sg(blk->bs); 546 } 547 548 int blk_enable_write_cache(BlockBackend *blk) 549 { 550 return bdrv_enable_write_cache(blk->bs); 551 } 552 553 void blk_set_enable_write_cache(BlockBackend *blk, bool wce) 554 { 555 bdrv_set_enable_write_cache(blk->bs, wce); 556 } 557 558 void blk_invalidate_cache(BlockBackend *blk, Error **errp) 559 { 560 bdrv_invalidate_cache(blk->bs, errp); 561 } 562 563 int blk_is_inserted(BlockBackend *blk) 564 { 565 return bdrv_is_inserted(blk->bs); 566 } 567 568 void blk_lock_medium(BlockBackend *blk, bool locked) 569 { 570 bdrv_lock_medium(blk->bs, locked); 571 } 572 573 void blk_eject(BlockBackend *blk, bool eject_flag) 574 { 575 bdrv_eject(blk->bs, eject_flag); 576 } 577 578 int blk_get_flags(BlockBackend *blk) 579 { 580 return bdrv_get_flags(blk->bs); 581 } 582 583 int blk_get_max_transfer_length(BlockBackend *blk) 584 { 585 return blk->bs->bl.max_transfer_length; 586 } 587 588 void blk_set_guest_block_size(BlockBackend *blk, int align) 589 { 590 bdrv_set_guest_block_size(blk->bs, align); 591 } 592 593 void *blk_blockalign(BlockBackend *blk, size_t size) 594 { 595 return qemu_blockalign(blk ? blk->bs : NULL, size); 596 } 597 598 bool blk_op_is_blocked(BlockBackend *blk, BlockOpType op, Error **errp) 599 { 600 return bdrv_op_is_blocked(blk->bs, op, errp); 601 } 602 603 void blk_op_unblock(BlockBackend *blk, BlockOpType op, Error *reason) 604 { 605 bdrv_op_unblock(blk->bs, op, reason); 606 } 607 608 void blk_op_block_all(BlockBackend *blk, Error *reason) 609 { 610 bdrv_op_block_all(blk->bs, reason); 611 } 612 613 void blk_op_unblock_all(BlockBackend *blk, Error *reason) 614 { 615 bdrv_op_unblock_all(blk->bs, reason); 616 } 617 618 AioContext *blk_get_aio_context(BlockBackend *blk) 619 { 620 return bdrv_get_aio_context(blk->bs); 621 } 622 623 void blk_set_aio_context(BlockBackend *blk, AioContext *new_context) 624 { 625 bdrv_set_aio_context(blk->bs, new_context); 626 } 627 628 void blk_add_aio_context_notifier(BlockBackend *blk, 629 void (*attached_aio_context)(AioContext *new_context, void *opaque), 630 void (*detach_aio_context)(void *opaque), void *opaque) 631 { 632 bdrv_add_aio_context_notifier(blk->bs, attached_aio_context, 633 detach_aio_context, opaque); 634 } 635 636 void blk_remove_aio_context_notifier(BlockBackend *blk, 637 void (*attached_aio_context)(AioContext *, 638 void *), 639 void (*detach_aio_context)(void *), 640 void *opaque) 641 { 642 bdrv_remove_aio_context_notifier(blk->bs, attached_aio_context, 643 detach_aio_context, opaque); 644 } 645 646 void blk_add_close_notifier(BlockBackend *blk, Notifier *notify) 647 { 648 bdrv_add_close_notifier(blk->bs, notify); 649 } 650 651 void blk_io_plug(BlockBackend *blk) 652 { 653 bdrv_io_plug(blk->bs); 654 } 655 656 void blk_io_unplug(BlockBackend *blk) 657 { 658 bdrv_io_unplug(blk->bs); 659 } 660 661 BlockAcctStats *blk_get_stats(BlockBackend *blk) 662 { 663 return bdrv_get_stats(blk->bs); 664 } 665 666 void *blk_aio_get(const AIOCBInfo *aiocb_info, BlockBackend *blk, 667 BlockCompletionFunc *cb, void *opaque) 668 { 669 return qemu_aio_get(aiocb_info, blk_bs(blk), cb, opaque); 670 } 671