]> git.proxmox.com Git - mirror_qemu.git/blame - block/raw-format.c
block/monitor: Consolidate hmp_handle_error calls to reduce redundant code
[mirror_qemu.git] / block / raw-format.c
CommitLineData
2e6fc7eb 1/* BlockDriver implementation for "raw" format driver
e1c66c6d 2 *
ad82be2f 3 * Copyright (C) 2010-2016 Red Hat, Inc.
ff369a48 4 * Copyright (C) 2010, Blue Swirl <blauwirbel@gmail.com>
775d6afd 5 * Copyright (C) 2009, Anthony Liguori <aliguori@us.ibm.com>
e1c66c6d
LE
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
80c71a24 29#include "qemu/osdep.h"
e1c66c6d 30#include "block/block_int.h"
da34e65c 31#include "qapi/error.h"
0b8fa32f 32#include "qemu/module.h"
ff369a48
LE
33#include "qemu/option.h"
34
2fdc7045
TG
35typedef struct BDRVRawState {
36 uint64_t offset;
37 uint64_t size;
38 bool has_size;
39} BDRVRawState;
40
8a2ce0bc
AG
41static const char *const mutable_opts[] = { "offset", "size", NULL };
42
2fdc7045
TG
43static QemuOptsList raw_runtime_opts = {
44 .name = "raw",
45 .head = QTAILQ_HEAD_INITIALIZER(raw_runtime_opts.head),
46 .desc = {
47 {
48 .name = "offset",
49 .type = QEMU_OPT_SIZE,
50 .help = "offset in the disk where the image starts",
51 },
52 {
53 .name = "size",
54 .type = QEMU_OPT_SIZE,
55 .help = "virtual disk size",
56 },
57 { /* end of list */ }
58 },
59};
60
cd3a4cf6
CL
61static QemuOptsList raw_create_opts = {
62 .name = "raw-create-opts",
63 .head = QTAILQ_HEAD_INITIALIZER(raw_create_opts.head),
64 .desc = {
65 {
66 .name = BLOCK_OPT_SIZE,
67 .type = QEMU_OPT_SIZE,
68 .help = "Virtual disk size"
69 },
70 { /* end of list */ }
71 }
ff369a48 72};
e1c66c6d 73
500e2434
HR
74static int raw_read_options(QDict *options, uint64_t *offset, bool *has_size,
75 uint64_t *size, Error **errp)
2fdc7045 76{
2fdc7045 77 QemuOpts *opts = NULL;
2fdc7045
TG
78 int ret;
79
2fdc7045 80 opts = qemu_opts_create(&raw_runtime_opts, NULL, 0, &error_abort);
af175e85 81 if (!qemu_opts_absorb_qdict(opts, options, errp)) {
2fdc7045
TG
82 ret = -EINVAL;
83 goto end;
84 }
85
500e2434
HR
86 *offset = qemu_opt_get_size(opts, "offset", 0);
87 *has_size = qemu_opt_find(opts, "size");
88 *size = qemu_opt_get_size(opts, "size", 0);
40332872 89
500e2434
HR
90 ret = 0;
91end:
92 qemu_opts_del(opts);
93 return ret;
94}
95
96static int raw_apply_options(BlockDriverState *bs, BDRVRawState *s,
97 uint64_t offset, bool has_size, uint64_t size,
98 Error **errp)
99{
100 int64_t real_size = 0;
101
102 real_size = bdrv_getlength(bs->file->bs);
103 if (real_size < 0) {
104 error_setg_errno(errp, -real_size, "Could not get image size");
105 return real_size;
2fdc7045
TG
106 }
107
108 /* Check size and offset */
500e2434
HR
109 if (offset > real_size) {
110 error_setg(errp, "Offset (%" PRIu64 ") cannot be greater than "
111 "size of the containing file (%" PRId64 ")",
112 s->offset, real_size);
113 return -EINVAL;
114 }
115
116 if (has_size && (real_size - offset) < size) {
2fdc7045 117 error_setg(errp, "The sum of offset (%" PRIu64 ") and size "
500e2434
HR
118 "(%" PRIu64 ") has to be smaller or equal to the "
119 " actual size of the containing file (%" PRId64 ")",
120 s->offset, s->size, real_size);
121 return -EINVAL;
2fdc7045
TG
122 }
123
124 /* Make sure size is multiple of BDRV_SECTOR_SIZE to prevent rounding
125 * up and leaking out of the specified area. */
500e2434 126 if (has_size && !QEMU_IS_ALIGNED(size, BDRV_SECTOR_SIZE)) {
2fdc7045 127 error_setg(errp, "Specified size is not multiple of %llu",
500e2434
HR
128 BDRV_SECTOR_SIZE);
129 return -EINVAL;
2fdc7045
TG
130 }
131
500e2434
HR
132 s->offset = offset;
133 s->has_size = has_size;
134 s->size = has_size ? size : real_size - offset;
2fdc7045 135
500e2434 136 return 0;
2fdc7045
TG
137}
138
7a6d3fc5
LE
139static int raw_reopen_prepare(BDRVReopenState *reopen_state,
140 BlockReopenQueue *queue, Error **errp)
e1c66c6d 141{
500e2434
HR
142 bool has_size;
143 uint64_t offset, size;
144 int ret;
145
2fdc7045
TG
146 assert(reopen_state != NULL);
147 assert(reopen_state->bs != NULL);
148
149 reopen_state->opaque = g_new0(BDRVRawState, 1);
150
500e2434
HR
151 ret = raw_read_options(reopen_state->options, &offset, &has_size, &size,
152 errp);
153 if (ret < 0) {
154 return ret;
155 }
156
157 ret = raw_apply_options(reopen_state->bs, reopen_state->opaque,
158 offset, has_size, size, errp);
159 if (ret < 0) {
160 return ret;
161 }
162
163 return 0;
2fdc7045
TG
164}
165
166static void raw_reopen_commit(BDRVReopenState *state)
167{
168 BDRVRawState *new_s = state->opaque;
169 BDRVRawState *s = state->bs->opaque;
170
171 memcpy(s, new_s, sizeof(BDRVRawState));
172
173 g_free(state->opaque);
174 state->opaque = NULL;
175}
176
177static void raw_reopen_abort(BDRVReopenState *state)
178{
179 g_free(state->opaque);
180 state->opaque = NULL;
e1c66c6d
LE
181}
182
38445538
FZ
183/* Check and adjust the offset, against 'offset' and 'size' options. */
184static inline int raw_adjust_offset(BlockDriverState *bs, uint64_t *offset,
185 uint64_t bytes, bool is_write)
186{
187 BDRVRawState *s = bs->opaque;
188
189 if (s->has_size && (*offset > s->size || bytes > (s->size - *offset))) {
190 /* There's not enough space for the write, or the read request is
191 * out-of-range. Don't read/write anything to prevent leaking out of
192 * the size specified in options. */
6d6bcc46 193 return is_write ? -ENOSPC : -EINVAL;
38445538
FZ
194 }
195
196 if (*offset > INT64_MAX - s->offset) {
197 return -EINVAL;
198 }
199 *offset += s->offset;
200
201 return 0;
202}
203
decaeed7
EB
204static int coroutine_fn raw_co_preadv(BlockDriverState *bs, uint64_t offset,
205 uint64_t bytes, QEMUIOVector *qiov,
206 int flags)
e1c66c6d 207{
38445538 208 int ret;
2fdc7045 209
38445538
FZ
210 ret = raw_adjust_offset(bs, &offset, bytes, false);
211 if (ret) {
212 return ret;
2fdc7045 213 }
2fdc7045 214
9eaafd90 215 BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO);
decaeed7 216 return bdrv_co_preadv(bs->file, offset, bytes, qiov, flags);
e1c66c6d
LE
217}
218
decaeed7
EB
219static int coroutine_fn raw_co_pwritev(BlockDriverState *bs, uint64_t offset,
220 uint64_t bytes, QEMUIOVector *qiov,
221 int flags)
e1c66c6d 222{
38f3ef57
KW
223 void *buf = NULL;
224 BlockDriver *drv;
225 QEMUIOVector local_qiov;
226 int ret;
227
decaeed7
EB
228 if (bs->probed && offset < BLOCK_PROBE_BUF_SIZE && bytes) {
229 /* Handling partial writes would be a pain - so we just
230 * require that guests have 512-byte request alignment if
231 * probing occurred */
38f3ef57
KW
232 QEMU_BUILD_BUG_ON(BLOCK_PROBE_BUF_SIZE != 512);
233 QEMU_BUILD_BUG_ON(BDRV_SECTOR_SIZE != 512);
decaeed7 234 assert(offset == 0 && bytes >= BLOCK_PROBE_BUF_SIZE);
38f3ef57 235
9a4f4c31 236 buf = qemu_try_blockalign(bs->file->bs, 512);
38f3ef57
KW
237 if (!buf) {
238 ret = -ENOMEM;
239 goto fail;
240 }
241
242 ret = qemu_iovec_to_buf(qiov, 0, buf, 512);
243 if (ret != 512) {
244 ret = -EINVAL;
245 goto fail;
246 }
247
248 drv = bdrv_probe_all(buf, 512, NULL);
249 if (drv != bs->drv) {
250 ret = -EPERM;
251 goto fail;
252 }
253
254 /* Use the checked buffer, a malicious guest might be overwriting its
255 * original buffer in the background. */
256 qemu_iovec_init(&local_qiov, qiov->niov + 1);
257 qemu_iovec_add(&local_qiov, buf, 512);
258 qemu_iovec_concat(&local_qiov, qiov, 512, qiov->size - 512);
259 qiov = &local_qiov;
260 }
261
38445538
FZ
262 ret = raw_adjust_offset(bs, &offset, bytes, true);
263 if (ret) {
264 goto fail;
265 }
2fdc7045 266
9eaafd90 267 BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO);
decaeed7 268 ret = bdrv_co_pwritev(bs->file, offset, bytes, qiov, flags);
38f3ef57
KW
269
270fail:
271 if (qiov == &local_qiov) {
272 qemu_iovec_destroy(&local_qiov);
273 }
274 qemu_vfree(buf);
275 return ret;
e1c66c6d
LE
276}
277
d41aa7e3
EB
278static int coroutine_fn raw_co_block_status(BlockDriverState *bs,
279 bool want_zero, int64_t offset,
280 int64_t bytes, int64_t *pnum,
281 int64_t *map,
67a0fd2a 282 BlockDriverState **file)
e1c66c6d 283{
2fdc7045 284 BDRVRawState *s = bs->opaque;
d41aa7e3 285 *pnum = bytes;
02650acb 286 *file = bs->file->bs;
d41aa7e3
EB
287 *map = offset + s->offset;
288 return BDRV_BLOCK_RAW | BDRV_BLOCK_OFFSET_VALID;
e1c66c6d
LE
289}
290
39ad937e 291static int coroutine_fn raw_co_pwrite_zeroes(BlockDriverState *bs,
f5a5ca79 292 int64_t offset, int bytes,
39ad937e 293 BdrvRequestFlags flags)
e1c66c6d 294{
38445538
FZ
295 int ret;
296
297 ret = raw_adjust_offset(bs, (uint64_t *)&offset, bytes, true);
298 if (ret) {
299 return ret;
2fdc7045 300 }
f5a5ca79 301 return bdrv_co_pwrite_zeroes(bs->file, offset, bytes, flags);
e1c66c6d
LE
302}
303
5f61ad07 304static int coroutine_fn raw_co_pdiscard(BlockDriverState *bs,
f5a5ca79 305 int64_t offset, int bytes)
e1c66c6d 306{
38445538
FZ
307 int ret;
308
309 ret = raw_adjust_offset(bs, (uint64_t *)&offset, bytes, true);
310 if (ret) {
311 return ret;
2fdc7045 312 }
0b9fd3f4 313 return bdrv_co_pdiscard(bs->file, offset, bytes);
e1c66c6d
LE
314}
315
7a6d3fc5 316static int64_t raw_getlength(BlockDriverState *bs)
e1c66c6d 317{
2fdc7045
TG
318 int64_t len;
319 BDRVRawState *s = bs->opaque;
320
321 /* Update size. It should not change unless the file was externally
322 * modified. */
323 len = bdrv_getlength(bs->file->bs);
324 if (len < 0) {
325 return len;
326 }
327
328 if (len < s->offset) {
329 s->size = 0;
330 } else {
331 if (s->has_size) {
332 /* Try to honour the size */
333 s->size = MIN(s->size, len - s->offset);
334 } else {
335 s->size = len - s->offset;
336 }
337 }
338
339 return s->size;
e1c66c6d
LE
340}
341
a843a22a
SH
342static BlockMeasureInfo *raw_measure(QemuOpts *opts, BlockDriverState *in_bs,
343 Error **errp)
344{
345 BlockMeasureInfo *info;
346 int64_t required;
347
348 if (in_bs) {
349 required = bdrv_getlength(in_bs);
350 if (required < 0) {
351 error_setg_errno(errp, -required, "Unable to get image size");
352 return NULL;
353 }
354 } else {
355 required = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
356 BDRV_SECTOR_SIZE);
357 }
358
5d72c68b 359 info = g_new0(BlockMeasureInfo, 1);
a843a22a
SH
360 info->required = required;
361
362 /* Unallocated sectors count towards the file size in raw images */
363 info->fully_allocated = info->required;
364 return info;
365}
366
7a6d3fc5 367static int raw_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
e1c66c6d 368{
9a4f4c31 369 return bdrv_get_info(bs->file->bs, bdi);
e1c66c6d
LE
370}
371
decaeed7
EB
372static void raw_refresh_limits(BlockDriverState *bs, Error **errp)
373{
374 if (bs->probed) {
375 /* To make it easier to protect the first sector, any probed
376 * image is restricted to read-modify-write on sub-sector
377 * operations. */
378 bs->bl.request_alignment = BDRV_SECTOR_SIZE;
379 }
380}
381
061ca8a3 382static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,
c80d8b06 383 bool exact, PreallocMode prealloc,
92b92799 384 BdrvRequestFlags flags, Error **errp)
e1c66c6d 385{
2fdc7045
TG
386 BDRVRawState *s = bs->opaque;
387
388 if (s->has_size) {
f59adb32 389 error_setg(errp, "Cannot resize fixed-size raw disks");
2fdc7045
TG
390 return -ENOTSUP;
391 }
392
393 if (INT64_MAX - offset < s->offset) {
f59adb32 394 error_setg(errp, "Disk size too large for the chosen offset");
2fdc7045
TG
395 return -EINVAL;
396 }
397
398 s->size = offset;
399 offset += s->offset;
1ddaabae 400 return bdrv_co_truncate(bs->file, offset, exact, prealloc, flags, errp);
e1c66c6d
LE
401}
402
7a6d3fc5 403static void raw_eject(BlockDriverState *bs, bool eject_flag)
e1c66c6d 404{
9a4f4c31 405 bdrv_eject(bs->file->bs, eject_flag);
e1c66c6d
LE
406}
407
7a6d3fc5 408static void raw_lock_medium(BlockDriverState *bs, bool locked)
e1c66c6d 409{
9a4f4c31 410 bdrv_lock_medium(bs->file->bs, locked);
e1c66c6d
LE
411}
412
151a2930 413static int raw_co_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
e1c66c6d 414{
2fdc7045
TG
415 BDRVRawState *s = bs->opaque;
416 if (s->offset || s->has_size) {
417 return -ENOTSUP;
418 }
151a2930 419 return bdrv_co_ioctl(bs->file->bs, req, buf);
e1c66c6d
LE
420}
421
7a6d3fc5 422static int raw_has_zero_init(BlockDriverState *bs)
e1c66c6d 423{
9a4f4c31 424 return bdrv_has_zero_init(bs->file->bs);
e1c66c6d
LE
425}
426
b92902df
ML
427static int coroutine_fn raw_co_create_opts(BlockDriver *drv,
428 const char *filename,
429 QemuOpts *opts,
efc75e2a 430 Error **errp)
1565262c 431{
9be38598 432 return bdrv_create_file(filename, opts, errp);
1565262c 433}
01dd96d8 434
015a1036
HR
435static int raw_open(BlockDriverState *bs, QDict *options, int flags,
436 Error **errp)
01dd96d8 437{
2fdc7045 438 BDRVRawState *s = bs->opaque;
500e2434
HR
439 bool has_size;
440 uint64_t offset, size;
58944401 441 BdrvChildRole file_role;
2fdc7045
TG
442 int ret;
443
500e2434
HR
444 ret = raw_read_options(options, &offset, &has_size, &size, errp);
445 if (ret < 0) {
446 return ret;
447 }
448
58944401
HR
449 /*
450 * Without offset and a size limit, this driver behaves very much
451 * like a filter. With any such limit, it does not.
452 */
453 if (offset || has_size) {
454 file_role = BDRV_CHILD_DATA | BDRV_CHILD_PRIMARY;
455 } else {
456 file_role = BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY;
457 }
458
459 bs->file = bdrv_open_child(NULL, options, "file", bs, &child_of_bds,
460 file_role, false, errp);
4e4bf5c4
KW
461 if (!bs->file) {
462 return -EINVAL;
463 }
464
9a4f4c31 465 bs->sg = bs->file->bs->sg;
228345bf
HR
466 bs->supported_write_flags = BDRV_REQ_WRITE_UNCHANGED |
467 (BDRV_REQ_FUA & bs->file->bs->supported_write_flags);
468 bs->supported_zero_flags = BDRV_REQ_WRITE_UNCHANGED |
80f5c33f 469 ((BDRV_REQ_FUA | BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK) &
228345bf 470 bs->file->bs->supported_zero_flags);
1ddaabae
KW
471 bs->supported_truncate_flags = bs->file->bs->supported_truncate_flags &
472 BDRV_REQ_ZERO_WRITE;
38f3ef57
KW
473
474 if (bs->probed && !bdrv_is_read_only(bs)) {
f30c66ba 475 bdrv_refresh_filename(bs->file->bs);
38f3ef57
KW
476 fprintf(stderr,
477 "WARNING: Image format was not specified for '%s' and probing "
478 "guessed raw.\n"
479 " Automatically detecting the format is dangerous for "
480 "raw images, write operations on block 0 will be restricted.\n"
481 " Specify the 'raw' format explicitly to remove the "
482 "restrictions.\n",
9a4f4c31 483 bs->file->bs->filename);
38f3ef57
KW
484 }
485
500e2434 486 ret = raw_apply_options(bs, s, offset, has_size, size, errp);
2fdc7045
TG
487 if (ret < 0) {
488 return ret;
489 }
490
491 if (bs->sg && (s->offset || s->has_size)) {
492 error_setg(errp, "Cannot use offset/size with SCSI generic devices");
493 return -EINVAL;
494 }
495
01dd96d8
LE
496 return 0;
497}
498
7a6d3fc5 499static int raw_probe(const uint8_t *buf, int buf_size, const char *filename)
01dd96d8
LE
500{
501 /* smallest possible positive score so that raw is used if and only if no
502 * other block driver works
503 */
504 return 1;
505}
775d6afd 506
1a9335e4
ET
507static int raw_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz)
508{
2fdc7045
TG
509 BDRVRawState *s = bs->opaque;
510 int ret;
511
512 ret = bdrv_probe_blocksizes(bs->file->bs, bsz);
513 if (ret < 0) {
514 return ret;
515 }
516
517 if (!QEMU_IS_ALIGNED(s->offset, MAX(bsz->log, bsz->phys))) {
518 return -ENOTSUP;
519 }
520
521 return 0;
1a9335e4
ET
522}
523
524static int raw_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
525{
2fdc7045
TG
526 BDRVRawState *s = bs->opaque;
527 if (s->offset || s->has_size) {
528 return -ENOTSUP;
529 }
9a4f4c31 530 return bdrv_probe_geometry(bs->file->bs, geo);
1a9335e4
ET
531}
532
72d219e2 533static int coroutine_fn raw_co_copy_range_from(BlockDriverState *bs,
67b51fb9
VSO
534 BdrvChild *src,
535 uint64_t src_offset,
536 BdrvChild *dst,
537 uint64_t dst_offset,
538 uint64_t bytes,
539 BdrvRequestFlags read_flags,
540 BdrvRequestFlags write_flags)
72d219e2
FZ
541{
542 int ret;
543
544 ret = raw_adjust_offset(bs, &src_offset, bytes, false);
545 if (ret) {
546 return ret;
547 }
548 return bdrv_co_copy_range_from(bs->file, src_offset, dst, dst_offset,
67b51fb9 549 bytes, read_flags, write_flags);
72d219e2
FZ
550}
551
552static int coroutine_fn raw_co_copy_range_to(BlockDriverState *bs,
67b51fb9
VSO
553 BdrvChild *src,
554 uint64_t src_offset,
555 BdrvChild *dst,
556 uint64_t dst_offset,
557 uint64_t bytes,
558 BdrvRequestFlags read_flags,
559 BdrvRequestFlags write_flags)
72d219e2
FZ
560{
561 int ret;
562
563 ret = raw_adjust_offset(bs, &dst_offset, bytes, true);
564 if (ret) {
565 return ret;
566 }
567 return bdrv_co_copy_range_to(src, src_offset, bs->file, dst_offset, bytes,
67b51fb9 568 read_flags, write_flags);
72d219e2
FZ
569}
570
2654267c
HR
571static const char *const raw_strong_runtime_opts[] = {
572 "offset",
573 "size",
574
575 NULL
576};
577
3fc1ec37
VSO
578static void raw_cancel_in_flight(BlockDriverState *bs)
579{
580 bdrv_cancel_in_flight(bs->file->bs);
581}
582
5f535a94 583BlockDriver bdrv_raw = {
775d6afd 584 .format_name = "raw",
2fdc7045 585 .instance_size = sizeof(BDRVRawState),
775d6afd
LE
586 .bdrv_probe = &raw_probe,
587 .bdrv_reopen_prepare = &raw_reopen_prepare,
2fdc7045
TG
588 .bdrv_reopen_commit = &raw_reopen_commit,
589 .bdrv_reopen_abort = &raw_reopen_abort,
775d6afd 590 .bdrv_open = &raw_open,
69dca43d 591 .bdrv_child_perm = bdrv_default_perms,
efc75e2a 592 .bdrv_co_create_opts = &raw_co_create_opts,
decaeed7
EB
593 .bdrv_co_preadv = &raw_co_preadv,
594 .bdrv_co_pwritev = &raw_co_pwritev,
39ad937e 595 .bdrv_co_pwrite_zeroes = &raw_co_pwrite_zeroes,
5f61ad07 596 .bdrv_co_pdiscard = &raw_co_pdiscard,
d41aa7e3 597 .bdrv_co_block_status = &raw_co_block_status,
72d219e2
FZ
598 .bdrv_co_copy_range_from = &raw_co_copy_range_from,
599 .bdrv_co_copy_range_to = &raw_co_copy_range_to,
061ca8a3 600 .bdrv_co_truncate = &raw_co_truncate,
775d6afd 601 .bdrv_getlength = &raw_getlength,
d67066d8 602 .is_format = true,
b94a2610 603 .has_variable_length = true,
a843a22a 604 .bdrv_measure = &raw_measure,
775d6afd 605 .bdrv_get_info = &raw_get_info,
decaeed7 606 .bdrv_refresh_limits = &raw_refresh_limits,
1a9335e4
ET
607 .bdrv_probe_blocksizes = &raw_probe_blocksizes,
608 .bdrv_probe_geometry = &raw_probe_geometry,
775d6afd
LE
609 .bdrv_eject = &raw_eject,
610 .bdrv_lock_medium = &raw_lock_medium,
151a2930 611 .bdrv_co_ioctl = &raw_co_ioctl,
cd3a4cf6 612 .create_opts = &raw_create_opts,
2654267c
HR
613 .bdrv_has_zero_init = &raw_has_zero_init,
614 .strong_runtime_opts = raw_strong_runtime_opts,
8a2ce0bc 615 .mutable_opts = mutable_opts,
3fc1ec37 616 .bdrv_cancel_in_flight = raw_cancel_in_flight,
775d6afd
LE
617};
618
619static void bdrv_raw_init(void)
620{
621 bdrv_register(&bdrv_raw);
622}
623
624block_init(bdrv_raw_init);