block/raw-format.c

   1 /* BlockDriver implementation for "raw" format driver
   2  *
   3  * Copyright (C) 2010-2016 Red Hat, Inc.
   4  * Copyright (C) 2010, Blue Swirl <blauwirbel@gmail.com>
   5  * Copyright (C) 2009, Anthony Liguori <aliguori@us.ibm.com>
   6  *
   7  * Author:
   8  *   Laszlo Ersek <lersek@redhat.com>
   9  *
  10  * Permission is hereby granted, free of charge, to any person obtaining a copy
  11  * of this software and associated documentation files (the "Software"), to
  12  * deal in the Software without restriction, including without limitation the
  13  * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
  14  * sell copies of the Software, and to permit persons to whom the Software is
  15  * furnished to do so, subject to the following conditions:
  16  *
  17  * The above copyright notice and this permission notice shall be included in
  18  * all copies or substantial portions of the Software.
  19  *
  20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  21  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  23  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  24  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  25  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  26  * IN THE SOFTWARE.
  27  */
  28
  29 #include "qemu/osdep.h"
  30 #include "block/block-io.h"
  31 #include "block/block_int.h"
  32 #include "qapi/error.h"
  33 #include "qemu/module.h"
  34 #include "qemu/option.h"
  35 #include "qemu/memalign.h"
  36
  37 typedef struct BDRVRawState {
  38     uint64_t offset;
  39     uint64_t size;
  40     bool has_size;
  41 } BDRVRawState;
  42
  43 static const char *const mutable_opts[] = { "offset", "size", NULL };
  44
  45 static QemuOptsList raw_runtime_opts = {
  46     .name = "raw",
  47     .head = QTAILQ_HEAD_INITIALIZER(raw_runtime_opts.head),
  48     .desc = {
  49         {
  50             .name = "offset",
  51             .type = QEMU_OPT_SIZE,
  52             .help = "offset in the disk where the image starts",
  53         },
  54         {
  55             .name = "size",
  56             .type = QEMU_OPT_SIZE,
  57             .help = "virtual disk size",
  58         },
  59         { /* end of list */ }
  60     },
  61 };
  62
  63 static QemuOptsList raw_create_opts = {
  64     .name = "raw-create-opts",
  65     .head = QTAILQ_HEAD_INITIALIZER(raw_create_opts.head),
  66     .desc = {
  67         {
  68             .name = BLOCK_OPT_SIZE,
  69             .type = QEMU_OPT_SIZE,
  70             .help = "Virtual disk size"
  71         },
  72         { /* end of list */ }
  73     }
  74 };
  75
  76 static int raw_read_options(QDict *options, uint64_t *offset, bool *has_size,
  77                             uint64_t *size, Error **errp)
  78 {
  79     QemuOpts *opts = NULL;
  80     int ret;
  81
  82     opts = qemu_opts_create(&raw_runtime_opts, NULL, 0, &error_abort);
  83     if (!qemu_opts_absorb_qdict(opts, options, errp)) {
  84         ret = -EINVAL;
  85         goto end;
  86     }
  87
  88     *offset = qemu_opt_get_size(opts, "offset", 0);
  89     *has_size = qemu_opt_find(opts, "size");
  90     *size = qemu_opt_get_size(opts, "size", 0);
  91
  92     ret = 0;
  93 end:
  94     qemu_opts_del(opts);
  95     return ret;
  96 }
  97
  98 static int raw_apply_options(BlockDriverState *bs, BDRVRawState *s,
  99                              uint64_t offset, bool has_size, uint64_t size,
 100                              Error **errp)
 101 {
 102     int64_t real_size = 0;
 103
 104     real_size = bdrv_getlength(bs->file->bs);
 105     if (real_size < 0) {
 106         error_setg_errno(errp, -real_size, "Could not get image size");
 107         return real_size;
 108     }
 109
 110     /* Check size and offset */
 111     if (offset > real_size) {
 112         error_setg(errp, "Offset (%" PRIu64 ") cannot be greater than "
 113                    "size of the containing file (%" PRId64 ")",
 114                    s->offset, real_size);
 115         return -EINVAL;
 116     }
 117
 118     if (has_size && (real_size - offset) < size) {
 119         error_setg(errp, "The sum of offset (%" PRIu64 ") and size "
 120                    "(%" PRIu64 ") has to be smaller or equal to the "
 121                    " actual size of the containing file (%" PRId64 ")",
 122                    s->offset, s->size, real_size);
 123         return -EINVAL;
 124     }
 125
 126     /* Make sure size is multiple of BDRV_SECTOR_SIZE to prevent rounding
 127      * up and leaking out of the specified area. */
 128     if (has_size && !QEMU_IS_ALIGNED(size, BDRV_SECTOR_SIZE)) {
 129         error_setg(errp, "Specified size is not multiple of %llu",
 130                    BDRV_SECTOR_SIZE);
 131         return -EINVAL;
 132     }
 133
 134     s->offset = offset;
 135     s->has_size = has_size;
 136     s->size = has_size ? size : real_size - offset;
 137
 138     return 0;
 139 }
 140
 141 static int raw_reopen_prepare(BDRVReopenState *reopen_state,
 142                               BlockReopenQueue *queue, Error **errp)
 143 {
 144     bool has_size;
 145     uint64_t offset, size;
 146     int ret;
 147
 148     assert(reopen_state != NULL);
 149     assert(reopen_state->bs != NULL);
 150
 151     reopen_state->opaque = g_new0(BDRVRawState, 1);
 152
 153     ret = raw_read_options(reopen_state->options, &offset, &has_size, &size,
 154                            errp);
 155     if (ret < 0) {
 156         return ret;
 157     }
 158
 159     ret = raw_apply_options(reopen_state->bs, reopen_state->opaque,
 160                             offset, has_size, size, errp);
 161     if (ret < 0) {
 162         return ret;
 163     }
 164
 165     return 0;
 166 }
 167
 168 static void raw_reopen_commit(BDRVReopenState *state)
 169 {
 170     BDRVRawState *new_s = state->opaque;
 171     BDRVRawState *s = state->bs->opaque;
 172
 173     memcpy(s, new_s, sizeof(BDRVRawState));
 174
 175     g_free(state->opaque);
 176     state->opaque = NULL;
 177 }
 178
 179 static void raw_reopen_abort(BDRVReopenState *state)
 180 {
 181     g_free(state->opaque);
 182     state->opaque = NULL;
 183 }
 184
 185 /* Check and adjust the offset, against 'offset' and 'size' options. */
 186 static inline int raw_adjust_offset(BlockDriverState *bs, int64_t *offset,
 187                                     int64_t bytes, bool is_write)
 188 {
 189     BDRVRawState *s = bs->opaque;
 190
 191     if (s->has_size && (*offset > s->size || bytes > (s->size - *offset))) {
 192         /* There's not enough space for the write, or the read request is
 193          * out-of-range. Don't read/write anything to prevent leaking out of
 194          * the size specified in options. */
 195         return is_write ? -ENOSPC : -EINVAL;
 196     }
 197
 198     if (*offset > INT64_MAX - s->offset) {
 199         return -EINVAL;
 200     }
 201     *offset += s->offset;
 202
 203     return 0;
 204 }
 205
 206 static int coroutine_fn GRAPH_RDLOCK
 207 raw_co_preadv(BlockDriverState *bs, int64_t offset, int64_t bytes,
 208               QEMUIOVector *qiov, BdrvRequestFlags flags)
 209 {
 210     int ret;
 211
 212     ret = raw_adjust_offset(bs, &offset, bytes, false);
 213     if (ret) {
 214         return ret;
 215     }
 216
 217     BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO);
 218     return bdrv_co_preadv(bs->file, offset, bytes, qiov, flags);
 219 }
 220
 221 static int coroutine_fn GRAPH_RDLOCK
 222 raw_co_pwritev(BlockDriverState *bs, int64_t offset, int64_t bytes,
 223                QEMUIOVector *qiov, BdrvRequestFlags flags)
 224 {
 225     void *buf = NULL;
 226     BlockDriver *drv;
 227     QEMUIOVector local_qiov;
 228     int ret;
 229
 230     if (bs->probed && offset < BLOCK_PROBE_BUF_SIZE && bytes) {
 231         /* Handling partial writes would be a pain - so we just
 232          * require that guests have 512-byte request alignment if
 233          * probing occurred */
 234         QEMU_BUILD_BUG_ON(BLOCK_PROBE_BUF_SIZE != 512);
 235         QEMU_BUILD_BUG_ON(BDRV_SECTOR_SIZE != 512);
 236         assert(offset == 0 && bytes >= BLOCK_PROBE_BUF_SIZE);
 237
 238         buf = qemu_try_blockalign(bs->file->bs, 512);
 239         if (!buf) {
 240             ret = -ENOMEM;
 241             goto fail;
 242         }
 243
 244         ret = qemu_iovec_to_buf(qiov, 0, buf, 512);
 245         if (ret != 512) {
 246             ret = -EINVAL;
 247             goto fail;
 248         }
 249
 250         drv = bdrv_probe_all(buf, 512, NULL);
 251         if (drv != bs->drv) {
 252             ret = -EPERM;
 253             goto fail;
 254         }
 255
 256         /* Use the checked buffer, a malicious guest might be overwriting its
 257          * original buffer in the background. */
 258         qemu_iovec_init(&local_qiov, qiov->niov + 1);
 259         qemu_iovec_add(&local_qiov, buf, 512);
 260         qemu_iovec_concat(&local_qiov, qiov, 512, qiov->size - 512);
 261         qiov = &local_qiov;
 262
 263         flags &= ~BDRV_REQ_REGISTERED_BUF;
 264     }
 265
 266     ret = raw_adjust_offset(bs, &offset, bytes, true);
 267     if (ret) {
 268         goto fail;
 269     }
 270
 271     BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO);
 272     ret = bdrv_co_pwritev(bs->file, offset, bytes, qiov, flags);
 273
 274 fail:
 275     if (qiov == &local_qiov) {
 276         qemu_iovec_destroy(&local_qiov);
 277     }
 278     qemu_vfree(buf);
 279     return ret;
 280 }
 281
 282 static int coroutine_fn raw_co_block_status(BlockDriverState *bs,
 283                                             bool want_zero, int64_t offset,
 284                                             int64_t bytes, int64_t *pnum,
 285                                             int64_t *map,
 286                                             BlockDriverState **file)
 287 {
 288     BDRVRawState *s = bs->opaque;
 289     *pnum = bytes;
 290     *file = bs->file->bs;
 291     *map = offset + s->offset;
 292     return BDRV_BLOCK_RAW | BDRV_BLOCK_OFFSET_VALID;
 293 }
 294
 295 static int coroutine_fn GRAPH_RDLOCK
 296 raw_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset, int64_t bytes,
 297                      BdrvRequestFlags flags)
 298 {
 299     int ret;
 300
 301     ret = raw_adjust_offset(bs, &offset, bytes, true);
 302     if (ret) {
 303         return ret;
 304     }
 305     return bdrv_co_pwrite_zeroes(bs->file, offset, bytes, flags);
 306 }
 307
 308 static int coroutine_fn GRAPH_RDLOCK
 309 raw_co_pdiscard(BlockDriverState *bs, int64_t offset, int64_t bytes)
 310 {
 311     int ret;
 312
 313     ret = raw_adjust_offset(bs, &offset, bytes, true);
 314     if (ret) {
 315         return ret;
 316     }
 317     return bdrv_co_pdiscard(bs->file, offset, bytes);
 318 }
 319
 320 static int coroutine_fn GRAPH_RDLOCK
 321 raw_co_zone_report(BlockDriverState *bs, int64_t offset,
 322                    unsigned int *nr_zones,
 323                    BlockZoneDescriptor *zones)
 324 {
 325     return bdrv_co_zone_report(bs->file->bs, offset, nr_zones, zones);
 326 }
 327
 328 static int coroutine_fn GRAPH_RDLOCK
 329 raw_co_zone_mgmt(BlockDriverState *bs, BlockZoneOp op,
 330                  int64_t offset, int64_t len)
 331 {
 332     return bdrv_co_zone_mgmt(bs->file->bs, op, offset, len);
 333 }
 334
 335 static int coroutine_fn GRAPH_RDLOCK
 336 raw_co_zone_append(BlockDriverState *bs,int64_t *offset, QEMUIOVector *qiov,
 337                    BdrvRequestFlags flags)
 338 {
 339     return bdrv_co_zone_append(bs->file->bs, offset, qiov, flags);
 340 }
 341
 342 static int64_t coroutine_fn GRAPH_RDLOCK
 343 raw_co_getlength(BlockDriverState *bs)
 344 {
 345     int64_t len;
 346     BDRVRawState *s = bs->opaque;
 347
 348     /* Update size. It should not change unless the file was externally
 349      * modified. */
 350     len = bdrv_co_getlength(bs->file->bs);
 351     if (len < 0) {
 352         return len;
 353     }
 354
 355     if (len < s->offset) {
 356         s->size = 0;
 357     } else {
 358         if (s->has_size) {
 359             /* Try to honour the size */
 360             s->size = MIN(s->size, len - s->offset);
 361         } else {
 362             s->size = len - s->offset;
 363         }
 364     }
 365
 366     return s->size;
 367 }
 368
 369 static BlockMeasureInfo *raw_measure(QemuOpts *opts, BlockDriverState *in_bs,
 370                                      Error **errp)
 371 {
 372     BlockMeasureInfo *info;
 373     int64_t required;
 374
 375     if (in_bs) {
 376         required = bdrv_getlength(in_bs);
 377         if (required < 0) {
 378             error_setg_errno(errp, -required, "Unable to get image size");
 379             return NULL;
 380         }
 381     } else {
 382         required = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
 383                             BDRV_SECTOR_SIZE);
 384     }
 385
 386     info = g_new0(BlockMeasureInfo, 1);
 387     info->required = required;
 388
 389     /* Unallocated sectors count towards the file size in raw images */
 390     info->fully_allocated = info->required;
 391     return info;
 392 }
 393
 394 static int coroutine_fn GRAPH_RDLOCK
 395 raw_co_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
 396 {
 397     return bdrv_co_get_info(bs->file->bs, bdi);
 398 }
 399
 400 static void raw_refresh_limits(BlockDriverState *bs, Error **errp)
 401 {
 402     bs->bl.has_variable_length = bs->file->bs->bl.has_variable_length;
 403
 404     if (bs->probed) {
 405         /* To make it easier to protect the first sector, any probed
 406          * image is restricted to read-modify-write on sub-sector
 407          * operations. */
 408         bs->bl.request_alignment = BDRV_SECTOR_SIZE;
 409     }
 410 }
 411
 412 static int coroutine_fn GRAPH_RDLOCK
 413 raw_co_truncate(BlockDriverState *bs, int64_t offset, bool exact,
 414                 PreallocMode prealloc, BdrvRequestFlags flags, Error **errp)
 415 {
 416     BDRVRawState *s = bs->opaque;
 417
 418     if (s->has_size) {
 419         error_setg(errp, "Cannot resize fixed-size raw disks");
 420         return -ENOTSUP;
 421     }
 422
 423     if (INT64_MAX - offset < s->offset) {
 424         error_setg(errp, "Disk size too large for the chosen offset");
 425         return -EINVAL;
 426     }
 427
 428     s->size = offset;
 429     offset += s->offset;
 430     return bdrv_co_truncate(bs->file, offset, exact, prealloc, flags, errp);
 431 }
 432
 433 static void coroutine_fn GRAPH_RDLOCK
 434 raw_co_eject(BlockDriverState *bs, bool eject_flag)
 435 {
 436     bdrv_co_eject(bs->file->bs, eject_flag);
 437 }
 438
 439 static void coroutine_fn GRAPH_RDLOCK
 440 raw_co_lock_medium(BlockDriverState *bs, bool locked)
 441 {
 442     bdrv_co_lock_medium(bs->file->bs, locked);
 443 }
 444
 445 static int coroutine_fn GRAPH_RDLOCK
 446 raw_co_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
 447 {
 448     BDRVRawState *s = bs->opaque;
 449     if (s->offset || s->has_size) {
 450         return -ENOTSUP;
 451     }
 452     return bdrv_co_ioctl(bs->file->bs, req, buf);
 453 }
 454
 455 static int raw_has_zero_init(BlockDriverState *bs)
 456 {
 457     return bdrv_has_zero_init(bs->file->bs);
 458 }
 459
 460 static int coroutine_fn GRAPH_UNLOCKED
 461 raw_co_create_opts(BlockDriver *drv, const char *filename,
 462                    QemuOpts *opts, Error **errp)
 463 {
 464     return bdrv_co_create_file(filename, opts, errp);
 465 }
 466
 467 static int raw_open(BlockDriverState *bs, QDict *options, int flags,
 468                     Error **errp)
 469 {
 470     BDRVRawState *s = bs->opaque;
 471     bool has_size;
 472     uint64_t offset, size;
 473     BdrvChildRole file_role;
 474     int ret;
 475
 476     ret = raw_read_options(options, &offset, &has_size, &size, errp);
 477     if (ret < 0) {
 478         return ret;
 479     }
 480
 481     /*
 482      * Without offset and a size limit, this driver behaves very much
 483      * like a filter.  With any such limit, it does not.
 484      */
 485     if (offset || has_size) {
 486         file_role = BDRV_CHILD_DATA | BDRV_CHILD_PRIMARY;
 487     } else {
 488         file_role = BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY;
 489     }
 490
 491     bdrv_open_child(NULL, options, "file", bs, &child_of_bds,
 492                     file_role, false, errp);
 493     if (!bs->file) {
 494         return -EINVAL;
 495     }
 496
 497     bs->sg = bdrv_is_sg(bs->file->bs);
 498     bs->supported_write_flags = BDRV_REQ_WRITE_UNCHANGED |
 499         (BDRV_REQ_FUA & bs->file->bs->supported_write_flags);
 500     bs->supported_zero_flags = BDRV_REQ_WRITE_UNCHANGED |
 501         ((BDRV_REQ_FUA | BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK) &
 502             bs->file->bs->supported_zero_flags);
 503     bs->supported_truncate_flags = bs->file->bs->supported_truncate_flags &
 504                                    BDRV_REQ_ZERO_WRITE;
 505
 506     if (bs->probed && !bdrv_is_read_only(bs)) {
 507         bdrv_refresh_filename(bs->file->bs);
 508         fprintf(stderr,
 509                 "WARNING: Image format was not specified for '%s' and probing "
 510                 "guessed raw.\n"
 511                 "         Automatically detecting the format is dangerous for "
 512                 "raw images, write operations on block 0 will be restricted.\n"
 513                 "         Specify the 'raw' format explicitly to remove the "
 514                 "restrictions.\n",
 515                 bs->file->bs->filename);
 516     }
 517
 518     ret = raw_apply_options(bs, s, offset, has_size, size, errp);
 519     if (ret < 0) {
 520         return ret;
 521     }
 522
 523     if (bdrv_is_sg(bs) && (s->offset || s->has_size)) {
 524         error_setg(errp, "Cannot use offset/size with SCSI generic devices");
 525         return -EINVAL;
 526     }
 527
 528     return 0;
 529 }
 530
 531 static int raw_probe(const uint8_t *buf, int buf_size, const char *filename)
 532 {
 533     /* smallest possible positive score so that raw is used if and only if no
 534      * other block driver works
 535      */
 536     return 1;
 537 }
 538
 539 static int raw_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz)
 540 {
 541     BDRVRawState *s = bs->opaque;
 542     int ret;
 543
 544     ret = bdrv_probe_blocksizes(bs->file->bs, bsz);
 545     if (ret < 0) {
 546         return ret;
 547     }
 548
 549     if (!QEMU_IS_ALIGNED(s->offset, MAX(bsz->log, bsz->phys))) {
 550         return -ENOTSUP;
 551     }
 552
 553     return 0;
 554 }
 555
 556 static int raw_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
 557 {
 558     BDRVRawState *s = bs->opaque;
 559     if (s->offset || s->has_size) {
 560         return -ENOTSUP;
 561     }
 562     return bdrv_probe_geometry(bs->file->bs, geo);
 563 }
 564
 565 static int coroutine_fn GRAPH_RDLOCK
 566 raw_co_copy_range_from(BlockDriverState *bs,
 567                        BdrvChild *src, int64_t src_offset,
 568                        BdrvChild *dst, int64_t dst_offset,
 569                        int64_t bytes, BdrvRequestFlags read_flags,
 570                        BdrvRequestFlags write_flags)
 571 {
 572     int ret;
 573
 574     ret = raw_adjust_offset(bs, &src_offset, bytes, false);
 575     if (ret) {
 576         return ret;
 577     }
 578     return bdrv_co_copy_range_from(bs->file, src_offset, dst, dst_offset,
 579                                    bytes, read_flags, write_flags);
 580 }
 581
 582 static int coroutine_fn GRAPH_RDLOCK
 583 raw_co_copy_range_to(BlockDriverState *bs,
 584                      BdrvChild *src, int64_t src_offset,
 585                      BdrvChild *dst, int64_t dst_offset,
 586                      int64_t bytes, BdrvRequestFlags read_flags,
 587                      BdrvRequestFlags write_flags)
 588 {
 589     int ret;
 590
 591     ret = raw_adjust_offset(bs, &dst_offset, bytes, true);
 592     if (ret) {
 593         return ret;
 594     }
 595     return bdrv_co_copy_range_to(src, src_offset, bs->file, dst_offset, bytes,
 596                                  read_flags, write_flags);
 597 }
 598
 599 static const char *const raw_strong_runtime_opts[] = {
 600     "offset",
 601     "size",
 602
 603     NULL
 604 };
 605
 606 static void raw_cancel_in_flight(BlockDriverState *bs)
 607 {
 608     bdrv_cancel_in_flight(bs->file->bs);
 609 }
 610
 611 static void raw_child_perm(BlockDriverState *bs, BdrvChild *c,
 612                            BdrvChildRole role,
 613                            BlockReopenQueue *reopen_queue,
 614                            uint64_t parent_perm, uint64_t parent_shared,
 615                            uint64_t *nperm, uint64_t *nshared)
 616 {
 617     bdrv_default_perms(bs, c, role, reopen_queue, parent_perm,
 618                        parent_shared, nperm, nshared);
 619
 620     /*
 621      * bdrv_default_perms() may add WRITE and/or RESIZE (see comment in
 622      * bdrv_default_perms_for_storage() for an explanation) but we only need
 623      * them if they are in parent_perm. Drop WRITE and RESIZE whenever possible
 624      * to avoid permission conflicts.
 625      */
 626     *nperm &= ~(BLK_PERM_WRITE | BLK_PERM_RESIZE);
 627     *nperm |= parent_perm & (BLK_PERM_WRITE | BLK_PERM_RESIZE);
 628 }
 629
 630 BlockDriver bdrv_raw = {
 631     .format_name          = "raw",
 632     .instance_size        = sizeof(BDRVRawState),
 633     .supports_zoned_children = true,
 634     .bdrv_probe           = &raw_probe,
 635     .bdrv_reopen_prepare  = &raw_reopen_prepare,
 636     .bdrv_reopen_commit   = &raw_reopen_commit,
 637     .bdrv_reopen_abort    = &raw_reopen_abort,
 638     .bdrv_open            = &raw_open,
 639     .bdrv_child_perm      = raw_child_perm,
 640     .bdrv_co_create_opts  = &raw_co_create_opts,
 641     .bdrv_co_preadv       = &raw_co_preadv,
 642     .bdrv_co_pwritev      = &raw_co_pwritev,
 643     .bdrv_co_pwrite_zeroes = &raw_co_pwrite_zeroes,
 644     .bdrv_co_pdiscard     = &raw_co_pdiscard,
 645     .bdrv_co_zone_report  = &raw_co_zone_report,
 646     .bdrv_co_zone_mgmt  = &raw_co_zone_mgmt,
 647     .bdrv_co_zone_append = &raw_co_zone_append,
 648     .bdrv_co_block_status = &raw_co_block_status,
 649     .bdrv_co_copy_range_from = &raw_co_copy_range_from,
 650     .bdrv_co_copy_range_to  = &raw_co_copy_range_to,
 651     .bdrv_co_truncate     = &raw_co_truncate,
 652     .bdrv_co_getlength    = &raw_co_getlength,
 653     .is_format            = true,
 654     .bdrv_measure         = &raw_measure,
 655     .bdrv_co_get_info     = &raw_co_get_info,
 656     .bdrv_refresh_limits  = &raw_refresh_limits,
 657     .bdrv_probe_blocksizes = &raw_probe_blocksizes,
 658     .bdrv_probe_geometry  = &raw_probe_geometry,
 659     .bdrv_co_eject        = &raw_co_eject,
 660     .bdrv_co_lock_medium  = &raw_co_lock_medium,
 661     .bdrv_co_ioctl        = &raw_co_ioctl,
 662     .create_opts          = &raw_create_opts,
 663     .bdrv_has_zero_init   = &raw_has_zero_init,
 664     .strong_runtime_opts  = raw_strong_runtime_opts,
 665     .mutable_opts         = mutable_opts,
 666     .bdrv_cancel_in_flight = raw_cancel_in_flight,
 667 };
 668
 669 static void bdrv_raw_init(void)
 670 {
 671     bdrv_register(&bdrv_raw);
 672 }
 673
 674 block_init(bdrv_raw_init);