Eric Blake | 2e6fc7e | 2016-12-02 13:48:53 -0600 | [diff] [blame] | 1 | /* BlockDriver implementation for "raw" format driver |
Laszlo Ersek | e1c66c6 | 2013-08-21 12:41:17 +0200 | [diff] [blame] | 2 | * |
Eric Blake | ad82be2 | 2016-06-23 16:37:22 -0600 | [diff] [blame] | 3 | * Copyright (C) 2010-2016 Red Hat, Inc. |
Laszlo Ersek | ff369a4 | 2013-08-21 12:41:21 +0200 | [diff] [blame] | 4 | * Copyright (C) 2010, Blue Swirl <blauwirbel@gmail.com> |
Laszlo Ersek | 775d6af | 2013-08-21 12:41:22 +0200 | [diff] [blame] | 5 | * Copyright (C) 2009, Anthony Liguori <aliguori@us.ibm.com> |
Laszlo Ersek | e1c66c6 | 2013-08-21 12:41:17 +0200 | [diff] [blame] | 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 | |
Peter Maydell | 80c71a2 | 2016-01-18 18:01:42 +0000 | [diff] [blame] | 29 | #include "qemu/osdep.h" |
Laszlo Ersek | e1c66c6 | 2013-08-21 12:41:17 +0200 | [diff] [blame] | 30 | #include "block/block_int.h" |
Markus Armbruster | da34e65 | 2016-03-14 09:01:28 +0100 | [diff] [blame] | 31 | #include "qapi/error.h" |
Markus Armbruster | 0b8fa32 | 2019-05-23 16:35:07 +0200 | [diff] [blame] | 32 | #include "qemu/module.h" |
Laszlo Ersek | ff369a4 | 2013-08-21 12:41:21 +0200 | [diff] [blame] | 33 | #include "qemu/option.h" |
Peter Maydell | 5df022c | 2022-02-26 18:07:23 +0000 | [diff] [blame] | 34 | #include "qemu/memalign.h" |
Laszlo Ersek | ff369a4 | 2013-08-21 12:41:21 +0200 | [diff] [blame] | 35 | |
Tomáš Golembiovský | 2fdc704 | 2016-10-31 11:27:40 +0100 | [diff] [blame] | 36 | typedef struct BDRVRawState { |
| 37 | uint64_t offset; |
| 38 | uint64_t size; |
| 39 | bool has_size; |
| 40 | } BDRVRawState; |
| 41 | |
Alberto Garcia | 8a2ce0b | 2019-03-12 18:48:48 +0200 | [diff] [blame] | 42 | static const char *const mutable_opts[] = { "offset", "size", NULL }; |
| 43 | |
Tomáš Golembiovský | 2fdc704 | 2016-10-31 11:27:40 +0100 | [diff] [blame] | 44 | static QemuOptsList raw_runtime_opts = { |
| 45 | .name = "raw", |
| 46 | .head = QTAILQ_HEAD_INITIALIZER(raw_runtime_opts.head), |
| 47 | .desc = { |
| 48 | { |
| 49 | .name = "offset", |
| 50 | .type = QEMU_OPT_SIZE, |
| 51 | .help = "offset in the disk where the image starts", |
| 52 | }, |
| 53 | { |
| 54 | .name = "size", |
| 55 | .type = QEMU_OPT_SIZE, |
| 56 | .help = "virtual disk size", |
| 57 | }, |
| 58 | { /* end of list */ } |
| 59 | }, |
| 60 | }; |
| 61 | |
Chunyan Liu | cd3a4cf | 2014-06-05 17:21:03 +0800 | [diff] [blame] | 62 | static QemuOptsList raw_create_opts = { |
| 63 | .name = "raw-create-opts", |
| 64 | .head = QTAILQ_HEAD_INITIALIZER(raw_create_opts.head), |
| 65 | .desc = { |
| 66 | { |
| 67 | .name = BLOCK_OPT_SIZE, |
| 68 | .type = QEMU_OPT_SIZE, |
| 69 | .help = "Virtual disk size" |
| 70 | }, |
| 71 | { /* end of list */ } |
| 72 | } |
Laszlo Ersek | ff369a4 | 2013-08-21 12:41:21 +0200 | [diff] [blame] | 73 | }; |
Laszlo Ersek | e1c66c6 | 2013-08-21 12:41:17 +0200 | [diff] [blame] | 74 | |
Max Reitz | 500e243 | 2020-05-13 13:05:30 +0200 | [diff] [blame] | 75 | static int raw_read_options(QDict *options, uint64_t *offset, bool *has_size, |
| 76 | uint64_t *size, Error **errp) |
Tomáš Golembiovský | 2fdc704 | 2016-10-31 11:27:40 +0100 | [diff] [blame] | 77 | { |
Tomáš Golembiovský | 2fdc704 | 2016-10-31 11:27:40 +0100 | [diff] [blame] | 78 | QemuOpts *opts = NULL; |
Tomáš Golembiovský | 2fdc704 | 2016-10-31 11:27:40 +0100 | [diff] [blame] | 79 | int ret; |
| 80 | |
Tomáš Golembiovský | 2fdc704 | 2016-10-31 11:27:40 +0100 | [diff] [blame] | 81 | opts = qemu_opts_create(&raw_runtime_opts, NULL, 0, &error_abort); |
Markus Armbruster | af175e8 | 2020-07-07 18:06:03 +0200 | [diff] [blame] | 82 | if (!qemu_opts_absorb_qdict(opts, options, errp)) { |
Tomáš Golembiovský | 2fdc704 | 2016-10-31 11:27:40 +0100 | [diff] [blame] | 83 | ret = -EINVAL; |
| 84 | goto end; |
| 85 | } |
| 86 | |
Max Reitz | 500e243 | 2020-05-13 13:05:30 +0200 | [diff] [blame] | 87 | *offset = qemu_opt_get_size(opts, "offset", 0); |
| 88 | *has_size = qemu_opt_find(opts, "size"); |
| 89 | *size = qemu_opt_get_size(opts, "size", 0); |
Tomáš Golembiovský | 4033287 | 2016-11-03 14:47:48 +0100 | [diff] [blame] | 90 | |
Max Reitz | 500e243 | 2020-05-13 13:05:30 +0200 | [diff] [blame] | 91 | ret = 0; |
| 92 | end: |
| 93 | qemu_opts_del(opts); |
| 94 | return ret; |
| 95 | } |
| 96 | |
| 97 | static int raw_apply_options(BlockDriverState *bs, BDRVRawState *s, |
| 98 | uint64_t offset, bool has_size, uint64_t size, |
| 99 | Error **errp) |
| 100 | { |
| 101 | int64_t real_size = 0; |
| 102 | |
| 103 | real_size = bdrv_getlength(bs->file->bs); |
| 104 | if (real_size < 0) { |
| 105 | error_setg_errno(errp, -real_size, "Could not get image size"); |
| 106 | return real_size; |
Tomáš Golembiovský | 2fdc704 | 2016-10-31 11:27:40 +0100 | [diff] [blame] | 107 | } |
| 108 | |
| 109 | /* Check size and offset */ |
Max Reitz | 500e243 | 2020-05-13 13:05:30 +0200 | [diff] [blame] | 110 | if (offset > real_size) { |
| 111 | error_setg(errp, "Offset (%" PRIu64 ") cannot be greater than " |
| 112 | "size of the containing file (%" PRId64 ")", |
| 113 | s->offset, real_size); |
| 114 | return -EINVAL; |
| 115 | } |
| 116 | |
| 117 | if (has_size && (real_size - offset) < size) { |
Tomáš Golembiovský | 2fdc704 | 2016-10-31 11:27:40 +0100 | [diff] [blame] | 118 | error_setg(errp, "The sum of offset (%" PRIu64 ") and size " |
Max Reitz | 500e243 | 2020-05-13 13:05:30 +0200 | [diff] [blame] | 119 | "(%" PRIu64 ") has to be smaller or equal to the " |
| 120 | " actual size of the containing file (%" PRId64 ")", |
| 121 | s->offset, s->size, real_size); |
| 122 | return -EINVAL; |
Tomáš Golembiovský | 2fdc704 | 2016-10-31 11:27:40 +0100 | [diff] [blame] | 123 | } |
| 124 | |
| 125 | /* Make sure size is multiple of BDRV_SECTOR_SIZE to prevent rounding |
| 126 | * up and leaking out of the specified area. */ |
Max Reitz | 500e243 | 2020-05-13 13:05:30 +0200 | [diff] [blame] | 127 | if (has_size && !QEMU_IS_ALIGNED(size, BDRV_SECTOR_SIZE)) { |
Tomáš Golembiovský | 2fdc704 | 2016-10-31 11:27:40 +0100 | [diff] [blame] | 128 | error_setg(errp, "Specified size is not multiple of %llu", |
Max Reitz | 500e243 | 2020-05-13 13:05:30 +0200 | [diff] [blame] | 129 | BDRV_SECTOR_SIZE); |
| 130 | return -EINVAL; |
Tomáš Golembiovský | 2fdc704 | 2016-10-31 11:27:40 +0100 | [diff] [blame] | 131 | } |
| 132 | |
Max Reitz | 500e243 | 2020-05-13 13:05:30 +0200 | [diff] [blame] | 133 | s->offset = offset; |
| 134 | s->has_size = has_size; |
| 135 | s->size = has_size ? size : real_size - offset; |
Tomáš Golembiovský | 2fdc704 | 2016-10-31 11:27:40 +0100 | [diff] [blame] | 136 | |
Max Reitz | 500e243 | 2020-05-13 13:05:30 +0200 | [diff] [blame] | 137 | return 0; |
Tomáš Golembiovský | 2fdc704 | 2016-10-31 11:27:40 +0100 | [diff] [blame] | 138 | } |
| 139 | |
Laszlo Ersek | 7a6d3fc | 2013-08-21 12:41:23 +0200 | [diff] [blame] | 140 | static int raw_reopen_prepare(BDRVReopenState *reopen_state, |
| 141 | BlockReopenQueue *queue, Error **errp) |
Laszlo Ersek | e1c66c6 | 2013-08-21 12:41:17 +0200 | [diff] [blame] | 142 | { |
Max Reitz | 500e243 | 2020-05-13 13:05:30 +0200 | [diff] [blame] | 143 | bool has_size; |
| 144 | uint64_t offset, size; |
| 145 | int ret; |
| 146 | |
Tomáš Golembiovský | 2fdc704 | 2016-10-31 11:27:40 +0100 | [diff] [blame] | 147 | assert(reopen_state != NULL); |
| 148 | assert(reopen_state->bs != NULL); |
| 149 | |
| 150 | reopen_state->opaque = g_new0(BDRVRawState, 1); |
| 151 | |
Max Reitz | 500e243 | 2020-05-13 13:05:30 +0200 | [diff] [blame] | 152 | ret = raw_read_options(reopen_state->options, &offset, &has_size, &size, |
| 153 | errp); |
| 154 | if (ret < 0) { |
| 155 | return ret; |
| 156 | } |
| 157 | |
| 158 | ret = raw_apply_options(reopen_state->bs, reopen_state->opaque, |
| 159 | offset, has_size, size, errp); |
| 160 | if (ret < 0) { |
| 161 | return ret; |
| 162 | } |
| 163 | |
| 164 | return 0; |
Tomáš Golembiovský | 2fdc704 | 2016-10-31 11:27:40 +0100 | [diff] [blame] | 165 | } |
| 166 | |
| 167 | static void raw_reopen_commit(BDRVReopenState *state) |
| 168 | { |
| 169 | BDRVRawState *new_s = state->opaque; |
| 170 | BDRVRawState *s = state->bs->opaque; |
| 171 | |
| 172 | memcpy(s, new_s, sizeof(BDRVRawState)); |
| 173 | |
| 174 | g_free(state->opaque); |
| 175 | state->opaque = NULL; |
| 176 | } |
| 177 | |
| 178 | static void raw_reopen_abort(BDRVReopenState *state) |
| 179 | { |
| 180 | g_free(state->opaque); |
| 181 | state->opaque = NULL; |
Laszlo Ersek | e1c66c6 | 2013-08-21 12:41:17 +0200 | [diff] [blame] | 182 | } |
| 183 | |
Fam Zheng | 3844553 | 2018-06-01 17:26:40 +0800 | [diff] [blame] | 184 | /* Check and adjust the offset, against 'offset' and 'size' options. */ |
Vladimir Sementsov-Ogievskiy | f7ef38d | 2021-09-03 13:27:59 +0300 | [diff] [blame] | 185 | static inline int raw_adjust_offset(BlockDriverState *bs, int64_t *offset, |
| 186 | int64_t bytes, bool is_write) |
Fam Zheng | 3844553 | 2018-06-01 17:26:40 +0800 | [diff] [blame] | 187 | { |
| 188 | BDRVRawState *s = bs->opaque; |
| 189 | |
| 190 | if (s->has_size && (*offset > s->size || bytes > (s->size - *offset))) { |
| 191 | /* There's not enough space for the write, or the read request is |
| 192 | * out-of-range. Don't read/write anything to prevent leaking out of |
| 193 | * the size specified in options. */ |
Fam Zheng | 6d6bcc4 | 2018-07-02 10:58:36 +0800 | [diff] [blame] | 194 | return is_write ? -ENOSPC : -EINVAL; |
Fam Zheng | 3844553 | 2018-06-01 17:26:40 +0800 | [diff] [blame] | 195 | } |
| 196 | |
| 197 | if (*offset > INT64_MAX - s->offset) { |
| 198 | return -EINVAL; |
| 199 | } |
| 200 | *offset += s->offset; |
| 201 | |
| 202 | return 0; |
| 203 | } |
| 204 | |
Vladimir Sementsov-Ogievskiy | f7ef38d | 2021-09-03 13:27:59 +0300 | [diff] [blame] | 205 | static int coroutine_fn raw_co_preadv(BlockDriverState *bs, int64_t offset, |
| 206 | int64_t bytes, QEMUIOVector *qiov, |
| 207 | BdrvRequestFlags flags) |
Laszlo Ersek | e1c66c6 | 2013-08-21 12:41:17 +0200 | [diff] [blame] | 208 | { |
Fam Zheng | 3844553 | 2018-06-01 17:26:40 +0800 | [diff] [blame] | 209 | int ret; |
Tomáš Golembiovský | 2fdc704 | 2016-10-31 11:27:40 +0100 | [diff] [blame] | 210 | |
Fam Zheng | 3844553 | 2018-06-01 17:26:40 +0800 | [diff] [blame] | 211 | ret = raw_adjust_offset(bs, &offset, bytes, false); |
| 212 | if (ret) { |
| 213 | return ret; |
Tomáš Golembiovský | 2fdc704 | 2016-10-31 11:27:40 +0100 | [diff] [blame] | 214 | } |
Tomáš Golembiovský | 2fdc704 | 2016-10-31 11:27:40 +0100 | [diff] [blame] | 215 | |
Laszlo Ersek | 9eaafd9 | 2013-08-21 12:41:18 +0200 | [diff] [blame] | 216 | BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO); |
Eric Blake | decaeed | 2016-07-15 17:23:08 -0600 | [diff] [blame] | 217 | return bdrv_co_preadv(bs->file, offset, bytes, qiov, flags); |
Laszlo Ersek | e1c66c6 | 2013-08-21 12:41:17 +0200 | [diff] [blame] | 218 | } |
| 219 | |
Vladimir Sementsov-Ogievskiy | e75abed | 2021-09-03 13:28:00 +0300 | [diff] [blame] | 220 | static int coroutine_fn raw_co_pwritev(BlockDriverState *bs, int64_t offset, |
| 221 | int64_t bytes, QEMUIOVector *qiov, |
| 222 | BdrvRequestFlags flags) |
Laszlo Ersek | e1c66c6 | 2013-08-21 12:41:17 +0200 | [diff] [blame] | 223 | { |
Kevin Wolf | 38f3ef5 | 2014-11-20 16:27:12 +0100 | [diff] [blame] | 224 | void *buf = NULL; |
| 225 | BlockDriver *drv; |
| 226 | QEMUIOVector local_qiov; |
| 227 | int ret; |
| 228 | |
Eric Blake | decaeed | 2016-07-15 17:23:08 -0600 | [diff] [blame] | 229 | if (bs->probed && offset < BLOCK_PROBE_BUF_SIZE && bytes) { |
| 230 | /* Handling partial writes would be a pain - so we just |
| 231 | * require that guests have 512-byte request alignment if |
| 232 | * probing occurred */ |
Kevin Wolf | 38f3ef5 | 2014-11-20 16:27:12 +0100 | [diff] [blame] | 233 | QEMU_BUILD_BUG_ON(BLOCK_PROBE_BUF_SIZE != 512); |
| 234 | QEMU_BUILD_BUG_ON(BDRV_SECTOR_SIZE != 512); |
Eric Blake | decaeed | 2016-07-15 17:23:08 -0600 | [diff] [blame] | 235 | assert(offset == 0 && bytes >= BLOCK_PROBE_BUF_SIZE); |
Kevin Wolf | 38f3ef5 | 2014-11-20 16:27:12 +0100 | [diff] [blame] | 236 | |
Kevin Wolf | 9a4f4c3 | 2015-06-16 14:19:22 +0200 | [diff] [blame] | 237 | buf = qemu_try_blockalign(bs->file->bs, 512); |
Kevin Wolf | 38f3ef5 | 2014-11-20 16:27:12 +0100 | [diff] [blame] | 238 | if (!buf) { |
| 239 | ret = -ENOMEM; |
| 240 | goto fail; |
| 241 | } |
| 242 | |
| 243 | ret = qemu_iovec_to_buf(qiov, 0, buf, 512); |
| 244 | if (ret != 512) { |
| 245 | ret = -EINVAL; |
| 246 | goto fail; |
| 247 | } |
| 248 | |
| 249 | drv = bdrv_probe_all(buf, 512, NULL); |
| 250 | if (drv != bs->drv) { |
| 251 | ret = -EPERM; |
| 252 | goto fail; |
| 253 | } |
| 254 | |
| 255 | /* Use the checked buffer, a malicious guest might be overwriting its |
| 256 | * original buffer in the background. */ |
| 257 | qemu_iovec_init(&local_qiov, qiov->niov + 1); |
| 258 | qemu_iovec_add(&local_qiov, buf, 512); |
| 259 | qemu_iovec_concat(&local_qiov, qiov, 512, qiov->size - 512); |
| 260 | qiov = &local_qiov; |
| 261 | } |
| 262 | |
Vladimir Sementsov-Ogievskiy | e75abed | 2021-09-03 13:28:00 +0300 | [diff] [blame] | 263 | ret = raw_adjust_offset(bs, &offset, bytes, true); |
Fam Zheng | 3844553 | 2018-06-01 17:26:40 +0800 | [diff] [blame] | 264 | if (ret) { |
| 265 | goto fail; |
| 266 | } |
Tomáš Golembiovský | 2fdc704 | 2016-10-31 11:27:40 +0100 | [diff] [blame] | 267 | |
Laszlo Ersek | 9eaafd9 | 2013-08-21 12:41:18 +0200 | [diff] [blame] | 268 | BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO); |
Eric Blake | decaeed | 2016-07-15 17:23:08 -0600 | [diff] [blame] | 269 | ret = bdrv_co_pwritev(bs->file, offset, bytes, qiov, flags); |
Kevin Wolf | 38f3ef5 | 2014-11-20 16:27:12 +0100 | [diff] [blame] | 270 | |
| 271 | fail: |
| 272 | if (qiov == &local_qiov) { |
| 273 | qemu_iovec_destroy(&local_qiov); |
| 274 | } |
| 275 | qemu_vfree(buf); |
| 276 | return ret; |
Laszlo Ersek | e1c66c6 | 2013-08-21 12:41:17 +0200 | [diff] [blame] | 277 | } |
| 278 | |
Eric Blake | d41aa7e | 2018-02-13 14:26:54 -0600 | [diff] [blame] | 279 | static int coroutine_fn raw_co_block_status(BlockDriverState *bs, |
| 280 | bool want_zero, int64_t offset, |
| 281 | int64_t bytes, int64_t *pnum, |
| 282 | int64_t *map, |
Fam Zheng | 67a0fd2 | 2016-01-26 11:58:48 +0800 | [diff] [blame] | 283 | BlockDriverState **file) |
Laszlo Ersek | e1c66c6 | 2013-08-21 12:41:17 +0200 | [diff] [blame] | 284 | { |
Tomáš Golembiovský | 2fdc704 | 2016-10-31 11:27:40 +0100 | [diff] [blame] | 285 | BDRVRawState *s = bs->opaque; |
Eric Blake | d41aa7e | 2018-02-13 14:26:54 -0600 | [diff] [blame] | 286 | *pnum = bytes; |
Fam Zheng | 02650ac | 2016-01-26 11:58:51 +0800 | [diff] [blame] | 287 | *file = bs->file->bs; |
Eric Blake | d41aa7e | 2018-02-13 14:26:54 -0600 | [diff] [blame] | 288 | *map = offset + s->offset; |
| 289 | return BDRV_BLOCK_RAW | BDRV_BLOCK_OFFSET_VALID; |
Laszlo Ersek | e1c66c6 | 2013-08-21 12:41:17 +0200 | [diff] [blame] | 290 | } |
| 291 | |
Eric Blake | 39ad937 | 2016-06-01 15:10:11 -0600 | [diff] [blame] | 292 | static int coroutine_fn raw_co_pwrite_zeroes(BlockDriverState *bs, |
Vladimir Sementsov-Ogievskiy | f34b2bc | 2021-09-03 13:28:03 +0300 | [diff] [blame] | 293 | int64_t offset, int64_t bytes, |
Eric Blake | 39ad937 | 2016-06-01 15:10:11 -0600 | [diff] [blame] | 294 | BdrvRequestFlags flags) |
Laszlo Ersek | e1c66c6 | 2013-08-21 12:41:17 +0200 | [diff] [blame] | 295 | { |
Fam Zheng | 3844553 | 2018-06-01 17:26:40 +0800 | [diff] [blame] | 296 | int ret; |
| 297 | |
Vladimir Sementsov-Ogievskiy | f7ef38d | 2021-09-03 13:27:59 +0300 | [diff] [blame] | 298 | ret = raw_adjust_offset(bs, &offset, bytes, true); |
Fam Zheng | 3844553 | 2018-06-01 17:26:40 +0800 | [diff] [blame] | 299 | if (ret) { |
| 300 | return ret; |
Tomáš Golembiovský | 2fdc704 | 2016-10-31 11:27:40 +0100 | [diff] [blame] | 301 | } |
Manos Pitsidianakis | f5a5ca7 | 2017-06-09 13:18:08 +0300 | [diff] [blame] | 302 | return bdrv_co_pwrite_zeroes(bs->file, offset, bytes, flags); |
Laszlo Ersek | e1c66c6 | 2013-08-21 12:41:17 +0200 | [diff] [blame] | 303 | } |
| 304 | |
Eric Blake | 5f61ad0 | 2016-07-15 17:23:04 -0600 | [diff] [blame] | 305 | static int coroutine_fn raw_co_pdiscard(BlockDriverState *bs, |
Vladimir Sementsov-Ogievskiy | 0c80228 | 2021-09-03 13:28:06 +0300 | [diff] [blame] | 306 | int64_t offset, int64_t bytes) |
Laszlo Ersek | e1c66c6 | 2013-08-21 12:41:17 +0200 | [diff] [blame] | 307 | { |
Fam Zheng | 3844553 | 2018-06-01 17:26:40 +0800 | [diff] [blame] | 308 | int ret; |
| 309 | |
Vladimir Sementsov-Ogievskiy | f7ef38d | 2021-09-03 13:27:59 +0300 | [diff] [blame] | 310 | ret = raw_adjust_offset(bs, &offset, bytes, true); |
Fam Zheng | 3844553 | 2018-06-01 17:26:40 +0800 | [diff] [blame] | 311 | if (ret) { |
| 312 | return ret; |
Tomáš Golembiovský | 2fdc704 | 2016-10-31 11:27:40 +0100 | [diff] [blame] | 313 | } |
Fam Zheng | 0b9fd3f | 2018-07-10 14:31:17 +0800 | [diff] [blame] | 314 | return bdrv_co_pdiscard(bs->file, offset, bytes); |
Laszlo Ersek | e1c66c6 | 2013-08-21 12:41:17 +0200 | [diff] [blame] | 315 | } |
| 316 | |
Laszlo Ersek | 7a6d3fc | 2013-08-21 12:41:23 +0200 | [diff] [blame] | 317 | static int64_t raw_getlength(BlockDriverState *bs) |
Laszlo Ersek | e1c66c6 | 2013-08-21 12:41:17 +0200 | [diff] [blame] | 318 | { |
Tomáš Golembiovský | 2fdc704 | 2016-10-31 11:27:40 +0100 | [diff] [blame] | 319 | int64_t len; |
| 320 | BDRVRawState *s = bs->opaque; |
| 321 | |
| 322 | /* Update size. It should not change unless the file was externally |
| 323 | * modified. */ |
| 324 | len = bdrv_getlength(bs->file->bs); |
| 325 | if (len < 0) { |
| 326 | return len; |
| 327 | } |
| 328 | |
| 329 | if (len < s->offset) { |
| 330 | s->size = 0; |
| 331 | } else { |
| 332 | if (s->has_size) { |
| 333 | /* Try to honour the size */ |
| 334 | s->size = MIN(s->size, len - s->offset); |
| 335 | } else { |
| 336 | s->size = len - s->offset; |
| 337 | } |
| 338 | } |
| 339 | |
| 340 | return s->size; |
Laszlo Ersek | e1c66c6 | 2013-08-21 12:41:17 +0200 | [diff] [blame] | 341 | } |
| 342 | |
Stefan Hajnoczi | a843a22 | 2017-07-05 13:57:31 +0100 | [diff] [blame] | 343 | static BlockMeasureInfo *raw_measure(QemuOpts *opts, BlockDriverState *in_bs, |
| 344 | Error **errp) |
| 345 | { |
| 346 | BlockMeasureInfo *info; |
| 347 | int64_t required; |
| 348 | |
| 349 | if (in_bs) { |
| 350 | required = bdrv_getlength(in_bs); |
| 351 | if (required < 0) { |
| 352 | error_setg_errno(errp, -required, "Unable to get image size"); |
| 353 | return NULL; |
| 354 | } |
| 355 | } else { |
| 356 | required = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0), |
| 357 | BDRV_SECTOR_SIZE); |
| 358 | } |
| 359 | |
Eric Blake | 5d72c68 | 2020-05-21 14:21:34 -0500 | [diff] [blame] | 360 | info = g_new0(BlockMeasureInfo, 1); |
Stefan Hajnoczi | a843a22 | 2017-07-05 13:57:31 +0100 | [diff] [blame] | 361 | info->required = required; |
| 362 | |
| 363 | /* Unallocated sectors count towards the file size in raw images */ |
| 364 | info->fully_allocated = info->required; |
| 365 | return info; |
| 366 | } |
| 367 | |
Laszlo Ersek | 7a6d3fc | 2013-08-21 12:41:23 +0200 | [diff] [blame] | 368 | static int raw_get_info(BlockDriverState *bs, BlockDriverInfo *bdi) |
Laszlo Ersek | e1c66c6 | 2013-08-21 12:41:17 +0200 | [diff] [blame] | 369 | { |
Kevin Wolf | 9a4f4c3 | 2015-06-16 14:19:22 +0200 | [diff] [blame] | 370 | return bdrv_get_info(bs->file->bs, bdi); |
Laszlo Ersek | e1c66c6 | 2013-08-21 12:41:17 +0200 | [diff] [blame] | 371 | } |
| 372 | |
Eric Blake | decaeed | 2016-07-15 17:23:08 -0600 | [diff] [blame] | 373 | static void raw_refresh_limits(BlockDriverState *bs, Error **errp) |
| 374 | { |
| 375 | if (bs->probed) { |
| 376 | /* To make it easier to protect the first sector, any probed |
| 377 | * image is restricted to read-modify-write on sub-sector |
| 378 | * operations. */ |
| 379 | bs->bl.request_alignment = BDRV_SECTOR_SIZE; |
| 380 | } |
| 381 | } |
| 382 | |
Kevin Wolf | 061ca8a | 2018-06-21 17:54:35 +0200 | [diff] [blame] | 383 | static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset, |
Max Reitz | c80d8b0 | 2019-09-18 11:51:40 +0200 | [diff] [blame] | 384 | bool exact, PreallocMode prealloc, |
Kevin Wolf | 92b9279 | 2020-04-24 14:54:39 +0200 | [diff] [blame] | 385 | BdrvRequestFlags flags, Error **errp) |
Laszlo Ersek | e1c66c6 | 2013-08-21 12:41:17 +0200 | [diff] [blame] | 386 | { |
Tomáš Golembiovský | 2fdc704 | 2016-10-31 11:27:40 +0100 | [diff] [blame] | 387 | BDRVRawState *s = bs->opaque; |
| 388 | |
| 389 | if (s->has_size) { |
Max Reitz | f59adb3 | 2017-03-28 22:51:29 +0200 | [diff] [blame] | 390 | error_setg(errp, "Cannot resize fixed-size raw disks"); |
Tomáš Golembiovský | 2fdc704 | 2016-10-31 11:27:40 +0100 | [diff] [blame] | 391 | return -ENOTSUP; |
| 392 | } |
| 393 | |
| 394 | if (INT64_MAX - offset < s->offset) { |
Max Reitz | f59adb3 | 2017-03-28 22:51:29 +0200 | [diff] [blame] | 395 | error_setg(errp, "Disk size too large for the chosen offset"); |
Tomáš Golembiovský | 2fdc704 | 2016-10-31 11:27:40 +0100 | [diff] [blame] | 396 | return -EINVAL; |
| 397 | } |
| 398 | |
| 399 | s->size = offset; |
| 400 | offset += s->offset; |
Kevin Wolf | 1ddaaba | 2020-04-24 14:54:43 +0200 | [diff] [blame] | 401 | return bdrv_co_truncate(bs->file, offset, exact, prealloc, flags, errp); |
Laszlo Ersek | e1c66c6 | 2013-08-21 12:41:17 +0200 | [diff] [blame] | 402 | } |
| 403 | |
Laszlo Ersek | 7a6d3fc | 2013-08-21 12:41:23 +0200 | [diff] [blame] | 404 | static void raw_eject(BlockDriverState *bs, bool eject_flag) |
Laszlo Ersek | e1c66c6 | 2013-08-21 12:41:17 +0200 | [diff] [blame] | 405 | { |
Kevin Wolf | 9a4f4c3 | 2015-06-16 14:19:22 +0200 | [diff] [blame] | 406 | bdrv_eject(bs->file->bs, eject_flag); |
Laszlo Ersek | e1c66c6 | 2013-08-21 12:41:17 +0200 | [diff] [blame] | 407 | } |
| 408 | |
Laszlo Ersek | 7a6d3fc | 2013-08-21 12:41:23 +0200 | [diff] [blame] | 409 | static void raw_lock_medium(BlockDriverState *bs, bool locked) |
Laszlo Ersek | e1c66c6 | 2013-08-21 12:41:17 +0200 | [diff] [blame] | 410 | { |
Kevin Wolf | 9a4f4c3 | 2015-06-16 14:19:22 +0200 | [diff] [blame] | 411 | bdrv_lock_medium(bs->file->bs, locked); |
Laszlo Ersek | e1c66c6 | 2013-08-21 12:41:17 +0200 | [diff] [blame] | 412 | } |
| 413 | |
Kevin Wolf | 151a293 | 2016-10-20 15:09:36 +0200 | [diff] [blame] | 414 | static int raw_co_ioctl(BlockDriverState *bs, unsigned long int req, void *buf) |
Laszlo Ersek | e1c66c6 | 2013-08-21 12:41:17 +0200 | [diff] [blame] | 415 | { |
Tomáš Golembiovský | 2fdc704 | 2016-10-31 11:27:40 +0100 | [diff] [blame] | 416 | BDRVRawState *s = bs->opaque; |
| 417 | if (s->offset || s->has_size) { |
| 418 | return -ENOTSUP; |
| 419 | } |
Kevin Wolf | 151a293 | 2016-10-20 15:09:36 +0200 | [diff] [blame] | 420 | return bdrv_co_ioctl(bs->file->bs, req, buf); |
Laszlo Ersek | e1c66c6 | 2013-08-21 12:41:17 +0200 | [diff] [blame] | 421 | } |
| 422 | |
Laszlo Ersek | 7a6d3fc | 2013-08-21 12:41:23 +0200 | [diff] [blame] | 423 | static int raw_has_zero_init(BlockDriverState *bs) |
Laszlo Ersek | e1c66c6 | 2013-08-21 12:41:17 +0200 | [diff] [blame] | 424 | { |
Kevin Wolf | 9a4f4c3 | 2015-06-16 14:19:22 +0200 | [diff] [blame] | 425 | return bdrv_has_zero_init(bs->file->bs); |
Laszlo Ersek | e1c66c6 | 2013-08-21 12:41:17 +0200 | [diff] [blame] | 426 | } |
| 427 | |
Maxim Levitsky | b92902d | 2020-03-26 03:12:17 +0200 | [diff] [blame] | 428 | static int coroutine_fn raw_co_create_opts(BlockDriver *drv, |
| 429 | const char *filename, |
| 430 | QemuOpts *opts, |
Stefan Hajnoczi | efc75e2 | 2018-01-18 13:43:45 +0100 | [diff] [blame] | 431 | Error **errp) |
Laszlo Ersek | 1565262 | 2013-08-21 12:41:19 +0200 | [diff] [blame] | 432 | { |
Eduardo Habkost | 9be3859 | 2016-06-13 18:57:58 -0300 | [diff] [blame] | 433 | return bdrv_create_file(filename, opts, errp); |
Laszlo Ersek | 1565262 | 2013-08-21 12:41:19 +0200 | [diff] [blame] | 434 | } |
Laszlo Ersek | 01dd96d | 2013-08-21 12:41:20 +0200 | [diff] [blame] | 435 | |
Max Reitz | 015a103 | 2013-09-05 14:22:29 +0200 | [diff] [blame] | 436 | static int raw_open(BlockDriverState *bs, QDict *options, int flags, |
| 437 | Error **errp) |
Laszlo Ersek | 01dd96d | 2013-08-21 12:41:20 +0200 | [diff] [blame] | 438 | { |
Tomáš Golembiovský | 2fdc704 | 2016-10-31 11:27:40 +0100 | [diff] [blame] | 439 | BDRVRawState *s = bs->opaque; |
Max Reitz | 500e243 | 2020-05-13 13:05:30 +0200 | [diff] [blame] | 440 | bool has_size; |
| 441 | uint64_t offset, size; |
Max Reitz | 5894440 | 2020-05-13 13:05:37 +0200 | [diff] [blame] | 442 | BdrvChildRole file_role; |
Tomáš Golembiovský | 2fdc704 | 2016-10-31 11:27:40 +0100 | [diff] [blame] | 443 | int ret; |
| 444 | |
Max Reitz | 500e243 | 2020-05-13 13:05:30 +0200 | [diff] [blame] | 445 | ret = raw_read_options(options, &offset, &has_size, &size, errp); |
| 446 | if (ret < 0) { |
| 447 | return ret; |
| 448 | } |
| 449 | |
Max Reitz | 5894440 | 2020-05-13 13:05:37 +0200 | [diff] [blame] | 450 | /* |
| 451 | * Without offset and a size limit, this driver behaves very much |
| 452 | * like a filter. With any such limit, it does not. |
| 453 | */ |
| 454 | if (offset || has_size) { |
| 455 | file_role = BDRV_CHILD_DATA | BDRV_CHILD_PRIMARY; |
| 456 | } else { |
| 457 | file_role = BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY; |
| 458 | } |
| 459 | |
| 460 | bs->file = bdrv_open_child(NULL, options, "file", bs, &child_of_bds, |
| 461 | file_role, false, errp); |
Kevin Wolf | 4e4bf5c | 2016-12-16 18:52:37 +0100 | [diff] [blame] | 462 | if (!bs->file) { |
| 463 | return -EINVAL; |
| 464 | } |
| 465 | |
Denis V. Lunev | 006e196 | 2022-08-17 10:37:35 +0200 | [diff] [blame] | 466 | bs->sg = bdrv_is_sg(bs->file->bs); |
Max Reitz | 228345b | 2018-04-21 15:29:26 +0200 | [diff] [blame] | 467 | bs->supported_write_flags = BDRV_REQ_WRITE_UNCHANGED | |
| 468 | (BDRV_REQ_FUA & bs->file->bs->supported_write_flags); |
| 469 | bs->supported_zero_flags = BDRV_REQ_WRITE_UNCHANGED | |
Kevin Wolf | 80f5c33 | 2019-03-22 13:42:39 +0100 | [diff] [blame] | 470 | ((BDRV_REQ_FUA | BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK) & |
Max Reitz | 228345b | 2018-04-21 15:29:26 +0200 | [diff] [blame] | 471 | bs->file->bs->supported_zero_flags); |
Kevin Wolf | 1ddaaba | 2020-04-24 14:54:43 +0200 | [diff] [blame] | 472 | bs->supported_truncate_flags = bs->file->bs->supported_truncate_flags & |
| 473 | BDRV_REQ_ZERO_WRITE; |
Kevin Wolf | 38f3ef5 | 2014-11-20 16:27:12 +0100 | [diff] [blame] | 474 | |
| 475 | if (bs->probed && !bdrv_is_read_only(bs)) { |
Max Reitz | f30c66b | 2019-02-01 20:29:05 +0100 | [diff] [blame] | 476 | bdrv_refresh_filename(bs->file->bs); |
Kevin Wolf | 38f3ef5 | 2014-11-20 16:27:12 +0100 | [diff] [blame] | 477 | fprintf(stderr, |
| 478 | "WARNING: Image format was not specified for '%s' and probing " |
| 479 | "guessed raw.\n" |
| 480 | " Automatically detecting the format is dangerous for " |
| 481 | "raw images, write operations on block 0 will be restricted.\n" |
| 482 | " Specify the 'raw' format explicitly to remove the " |
| 483 | "restrictions.\n", |
Kevin Wolf | 9a4f4c3 | 2015-06-16 14:19:22 +0200 | [diff] [blame] | 484 | bs->file->bs->filename); |
Kevin Wolf | 38f3ef5 | 2014-11-20 16:27:12 +0100 | [diff] [blame] | 485 | } |
| 486 | |
Max Reitz | 500e243 | 2020-05-13 13:05:30 +0200 | [diff] [blame] | 487 | ret = raw_apply_options(bs, s, offset, has_size, size, errp); |
Tomáš Golembiovský | 2fdc704 | 2016-10-31 11:27:40 +0100 | [diff] [blame] | 488 | if (ret < 0) { |
| 489 | return ret; |
| 490 | } |
| 491 | |
Denis V. Lunev | 006e196 | 2022-08-17 10:37:35 +0200 | [diff] [blame] | 492 | if (bdrv_is_sg(bs) && (s->offset || s->has_size)) { |
Tomáš Golembiovský | 2fdc704 | 2016-10-31 11:27:40 +0100 | [diff] [blame] | 493 | error_setg(errp, "Cannot use offset/size with SCSI generic devices"); |
| 494 | return -EINVAL; |
| 495 | } |
| 496 | |
Laszlo Ersek | 01dd96d | 2013-08-21 12:41:20 +0200 | [diff] [blame] | 497 | return 0; |
| 498 | } |
| 499 | |
Laszlo Ersek | 7a6d3fc | 2013-08-21 12:41:23 +0200 | [diff] [blame] | 500 | static int raw_probe(const uint8_t *buf, int buf_size, const char *filename) |
Laszlo Ersek | 01dd96d | 2013-08-21 12:41:20 +0200 | [diff] [blame] | 501 | { |
| 502 | /* smallest possible positive score so that raw is used if and only if no |
| 503 | * other block driver works |
| 504 | */ |
| 505 | return 1; |
| 506 | } |
Laszlo Ersek | 775d6af | 2013-08-21 12:41:22 +0200 | [diff] [blame] | 507 | |
Ekaterina Tumanova | 1a9335e | 2015-02-16 12:47:56 +0100 | [diff] [blame] | 508 | static int raw_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz) |
| 509 | { |
Tomáš Golembiovský | 2fdc704 | 2016-10-31 11:27:40 +0100 | [diff] [blame] | 510 | BDRVRawState *s = bs->opaque; |
| 511 | int ret; |
| 512 | |
| 513 | ret = bdrv_probe_blocksizes(bs->file->bs, bsz); |
| 514 | if (ret < 0) { |
| 515 | return ret; |
| 516 | } |
| 517 | |
| 518 | if (!QEMU_IS_ALIGNED(s->offset, MAX(bsz->log, bsz->phys))) { |
| 519 | return -ENOTSUP; |
| 520 | } |
| 521 | |
| 522 | return 0; |
Ekaterina Tumanova | 1a9335e | 2015-02-16 12:47:56 +0100 | [diff] [blame] | 523 | } |
| 524 | |
| 525 | static int raw_probe_geometry(BlockDriverState *bs, HDGeometry *geo) |
| 526 | { |
Tomáš Golembiovský | 2fdc704 | 2016-10-31 11:27:40 +0100 | [diff] [blame] | 527 | BDRVRawState *s = bs->opaque; |
| 528 | if (s->offset || s->has_size) { |
| 529 | return -ENOTSUP; |
| 530 | } |
Kevin Wolf | 9a4f4c3 | 2015-06-16 14:19:22 +0200 | [diff] [blame] | 531 | return bdrv_probe_geometry(bs->file->bs, geo); |
Ekaterina Tumanova | 1a9335e | 2015-02-16 12:47:56 +0100 | [diff] [blame] | 532 | } |
| 533 | |
Fam Zheng | 72d219e | 2018-06-01 17:26:41 +0800 | [diff] [blame] | 534 | static int coroutine_fn raw_co_copy_range_from(BlockDriverState *bs, |
Vladimir Sementsov-Ogievskiy | 67b51fb | 2018-07-09 19:37:17 +0300 | [diff] [blame] | 535 | BdrvChild *src, |
Vladimir Sementsov-Ogievskiy | 4853504 | 2021-09-03 13:28:01 +0300 | [diff] [blame] | 536 | int64_t src_offset, |
Vladimir Sementsov-Ogievskiy | 67b51fb | 2018-07-09 19:37:17 +0300 | [diff] [blame] | 537 | BdrvChild *dst, |
Vladimir Sementsov-Ogievskiy | 4853504 | 2021-09-03 13:28:01 +0300 | [diff] [blame] | 538 | int64_t dst_offset, |
| 539 | int64_t bytes, |
Vladimir Sementsov-Ogievskiy | 67b51fb | 2018-07-09 19:37:17 +0300 | [diff] [blame] | 540 | BdrvRequestFlags read_flags, |
| 541 | BdrvRequestFlags write_flags) |
Fam Zheng | 72d219e | 2018-06-01 17:26:41 +0800 | [diff] [blame] | 542 | { |
| 543 | int ret; |
| 544 | |
Vladimir Sementsov-Ogievskiy | 4853504 | 2021-09-03 13:28:01 +0300 | [diff] [blame] | 545 | ret = raw_adjust_offset(bs, &src_offset, bytes, false); |
Fam Zheng | 72d219e | 2018-06-01 17:26:41 +0800 | [diff] [blame] | 546 | if (ret) { |
| 547 | return ret; |
| 548 | } |
| 549 | return bdrv_co_copy_range_from(bs->file, src_offset, dst, dst_offset, |
Vladimir Sementsov-Ogievskiy | 67b51fb | 2018-07-09 19:37:17 +0300 | [diff] [blame] | 550 | bytes, read_flags, write_flags); |
Fam Zheng | 72d219e | 2018-06-01 17:26:41 +0800 | [diff] [blame] | 551 | } |
| 552 | |
| 553 | static int coroutine_fn raw_co_copy_range_to(BlockDriverState *bs, |
Vladimir Sementsov-Ogievskiy | 67b51fb | 2018-07-09 19:37:17 +0300 | [diff] [blame] | 554 | BdrvChild *src, |
Vladimir Sementsov-Ogievskiy | 4853504 | 2021-09-03 13:28:01 +0300 | [diff] [blame] | 555 | int64_t src_offset, |
Vladimir Sementsov-Ogievskiy | 67b51fb | 2018-07-09 19:37:17 +0300 | [diff] [blame] | 556 | BdrvChild *dst, |
Vladimir Sementsov-Ogievskiy | 4853504 | 2021-09-03 13:28:01 +0300 | [diff] [blame] | 557 | int64_t dst_offset, |
| 558 | int64_t bytes, |
Vladimir Sementsov-Ogievskiy | 67b51fb | 2018-07-09 19:37:17 +0300 | [diff] [blame] | 559 | BdrvRequestFlags read_flags, |
| 560 | BdrvRequestFlags write_flags) |
Fam Zheng | 72d219e | 2018-06-01 17:26:41 +0800 | [diff] [blame] | 561 | { |
| 562 | int ret; |
| 563 | |
Vladimir Sementsov-Ogievskiy | 4853504 | 2021-09-03 13:28:01 +0300 | [diff] [blame] | 564 | ret = raw_adjust_offset(bs, &dst_offset, bytes, true); |
Fam Zheng | 72d219e | 2018-06-01 17:26:41 +0800 | [diff] [blame] | 565 | if (ret) { |
| 566 | return ret; |
| 567 | } |
| 568 | return bdrv_co_copy_range_to(src, src_offset, bs->file, dst_offset, bytes, |
Vladimir Sementsov-Ogievskiy | 67b51fb | 2018-07-09 19:37:17 +0300 | [diff] [blame] | 569 | read_flags, write_flags); |
Fam Zheng | 72d219e | 2018-06-01 17:26:41 +0800 | [diff] [blame] | 570 | } |
| 571 | |
Max Reitz | 2654267 | 2019-02-01 20:29:25 +0100 | [diff] [blame] | 572 | static const char *const raw_strong_runtime_opts[] = { |
| 573 | "offset", |
| 574 | "size", |
| 575 | |
| 576 | NULL |
| 577 | }; |
| 578 | |
Vladimir Sementsov-Ogievskiy | 3fc1ec3 | 2021-02-05 19:37:13 +0300 | [diff] [blame] | 579 | static void raw_cancel_in_flight(BlockDriverState *bs) |
| 580 | { |
| 581 | bdrv_cancel_in_flight(bs->file->bs); |
| 582 | } |
| 583 | |
Stefan Hajnoczi | b68ce82 | 2021-07-26 13:28:39 +0100 | [diff] [blame] | 584 | static void raw_child_perm(BlockDriverState *bs, BdrvChild *c, |
| 585 | BdrvChildRole role, |
| 586 | BlockReopenQueue *reopen_queue, |
| 587 | uint64_t parent_perm, uint64_t parent_shared, |
| 588 | uint64_t *nperm, uint64_t *nshared) |
| 589 | { |
| 590 | bdrv_default_perms(bs, c, role, reopen_queue, parent_perm, |
| 591 | parent_shared, nperm, nshared); |
| 592 | |
| 593 | /* |
| 594 | * bdrv_default_perms() may add WRITE and/or RESIZE (see comment in |
| 595 | * bdrv_default_perms_for_storage() for an explanation) but we only need |
| 596 | * them if they are in parent_perm. Drop WRITE and RESIZE whenever possible |
| 597 | * to avoid permission conflicts. |
| 598 | */ |
| 599 | *nperm &= ~(BLK_PERM_WRITE | BLK_PERM_RESIZE); |
| 600 | *nperm |= parent_perm & (BLK_PERM_WRITE | BLK_PERM_RESIZE); |
| 601 | } |
| 602 | |
Max Reitz | 5f535a9 | 2014-12-02 18:32:41 +0100 | [diff] [blame] | 603 | BlockDriver bdrv_raw = { |
Laszlo Ersek | 775d6af | 2013-08-21 12:41:22 +0200 | [diff] [blame] | 604 | .format_name = "raw", |
Tomáš Golembiovský | 2fdc704 | 2016-10-31 11:27:40 +0100 | [diff] [blame] | 605 | .instance_size = sizeof(BDRVRawState), |
Laszlo Ersek | 775d6af | 2013-08-21 12:41:22 +0200 | [diff] [blame] | 606 | .bdrv_probe = &raw_probe, |
| 607 | .bdrv_reopen_prepare = &raw_reopen_prepare, |
Tomáš Golembiovský | 2fdc704 | 2016-10-31 11:27:40 +0100 | [diff] [blame] | 608 | .bdrv_reopen_commit = &raw_reopen_commit, |
| 609 | .bdrv_reopen_abort = &raw_reopen_abort, |
Laszlo Ersek | 775d6af | 2013-08-21 12:41:22 +0200 | [diff] [blame] | 610 | .bdrv_open = &raw_open, |
Stefan Hajnoczi | b68ce82 | 2021-07-26 13:28:39 +0100 | [diff] [blame] | 611 | .bdrv_child_perm = raw_child_perm, |
Stefan Hajnoczi | efc75e2 | 2018-01-18 13:43:45 +0100 | [diff] [blame] | 612 | .bdrv_co_create_opts = &raw_co_create_opts, |
Eric Blake | decaeed | 2016-07-15 17:23:08 -0600 | [diff] [blame] | 613 | .bdrv_co_preadv = &raw_co_preadv, |
| 614 | .bdrv_co_pwritev = &raw_co_pwritev, |
Eric Blake | 39ad937 | 2016-06-01 15:10:11 -0600 | [diff] [blame] | 615 | .bdrv_co_pwrite_zeroes = &raw_co_pwrite_zeroes, |
Eric Blake | 5f61ad0 | 2016-07-15 17:23:04 -0600 | [diff] [blame] | 616 | .bdrv_co_pdiscard = &raw_co_pdiscard, |
Eric Blake | d41aa7e | 2018-02-13 14:26:54 -0600 | [diff] [blame] | 617 | .bdrv_co_block_status = &raw_co_block_status, |
Fam Zheng | 72d219e | 2018-06-01 17:26:41 +0800 | [diff] [blame] | 618 | .bdrv_co_copy_range_from = &raw_co_copy_range_from, |
| 619 | .bdrv_co_copy_range_to = &raw_co_copy_range_to, |
Kevin Wolf | 061ca8a | 2018-06-21 17:54:35 +0200 | [diff] [blame] | 620 | .bdrv_co_truncate = &raw_co_truncate, |
Laszlo Ersek | 775d6af | 2013-08-21 12:41:22 +0200 | [diff] [blame] | 621 | .bdrv_getlength = &raw_getlength, |
Max Reitz | d67066d | 2020-05-13 13:05:12 +0200 | [diff] [blame] | 622 | .is_format = true, |
Kevin Wolf | b94a261 | 2013-10-29 12:18:58 +0100 | [diff] [blame] | 623 | .has_variable_length = true, |
Stefan Hajnoczi | a843a22 | 2017-07-05 13:57:31 +0100 | [diff] [blame] | 624 | .bdrv_measure = &raw_measure, |
Laszlo Ersek | 775d6af | 2013-08-21 12:41:22 +0200 | [diff] [blame] | 625 | .bdrv_get_info = &raw_get_info, |
Eric Blake | decaeed | 2016-07-15 17:23:08 -0600 | [diff] [blame] | 626 | .bdrv_refresh_limits = &raw_refresh_limits, |
Ekaterina Tumanova | 1a9335e | 2015-02-16 12:47:56 +0100 | [diff] [blame] | 627 | .bdrv_probe_blocksizes = &raw_probe_blocksizes, |
| 628 | .bdrv_probe_geometry = &raw_probe_geometry, |
Laszlo Ersek | 775d6af | 2013-08-21 12:41:22 +0200 | [diff] [blame] | 629 | .bdrv_eject = &raw_eject, |
| 630 | .bdrv_lock_medium = &raw_lock_medium, |
Kevin Wolf | 151a293 | 2016-10-20 15:09:36 +0200 | [diff] [blame] | 631 | .bdrv_co_ioctl = &raw_co_ioctl, |
Chunyan Liu | cd3a4cf | 2014-06-05 17:21:03 +0800 | [diff] [blame] | 632 | .create_opts = &raw_create_opts, |
Max Reitz | 2654267 | 2019-02-01 20:29:25 +0100 | [diff] [blame] | 633 | .bdrv_has_zero_init = &raw_has_zero_init, |
| 634 | .strong_runtime_opts = raw_strong_runtime_opts, |
Alberto Garcia | 8a2ce0b | 2019-03-12 18:48:48 +0200 | [diff] [blame] | 635 | .mutable_opts = mutable_opts, |
Vladimir Sementsov-Ogievskiy | 3fc1ec3 | 2021-02-05 19:37:13 +0300 | [diff] [blame] | 636 | .bdrv_cancel_in_flight = raw_cancel_in_flight, |
Laszlo Ersek | 775d6af | 2013-08-21 12:41:22 +0200 | [diff] [blame] | 637 | }; |
| 638 | |
| 639 | static void bdrv_raw_init(void) |
| 640 | { |
| 641 | bdrv_register(&bdrv_raw); |
| 642 | } |
| 643 | |
| 644 | block_init(bdrv_raw_init); |