Coverage Report

Created: 2026-11-20 08:13

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