blob: c7278e348ea5990af858e53284d0f6b17c1b0a55 [file] [log] [blame]
Eric Blake2e6fc7e2016-12-02 13:48:53 -06001/* BlockDriver implementation for "raw" format driver
Laszlo Erseke1c66c62013-08-21 12:41:17 +02002 *
Eric Blakead82be22016-06-23 16:37:22 -06003 * Copyright (C) 2010-2016 Red Hat, Inc.
Laszlo Ersekff369a42013-08-21 12:41:21 +02004 * Copyright (C) 2010, Blue Swirl <blauwirbel@gmail.com>
Laszlo Ersek775d6af2013-08-21 12:41:22 +02005 * Copyright (C) 2009, Anthony Liguori <aliguori@us.ibm.com>
Laszlo Erseke1c66c62013-08-21 12:41:17 +02006 *
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 Maydell80c71a22016-01-18 18:01:42 +000029#include "qemu/osdep.h"
Laszlo Erseke1c66c62013-08-21 12:41:17 +020030#include "block/block_int.h"
Markus Armbrusterda34e652016-03-14 09:01:28 +010031#include "qapi/error.h"
Markus Armbruster0b8fa322019-05-23 16:35:07 +020032#include "qemu/module.h"
Laszlo Ersekff369a42013-08-21 12:41:21 +020033#include "qemu/option.h"
Peter Maydell5df022c2022-02-26 18:07:23 +000034#include "qemu/memalign.h"
Laszlo Ersekff369a42013-08-21 12:41:21 +020035
Tomáš Golembiovský2fdc7042016-10-31 11:27:40 +010036typedef struct BDRVRawState {
37 uint64_t offset;
38 uint64_t size;
39 bool has_size;
40} BDRVRawState;
41
Alberto Garcia8a2ce0b2019-03-12 18:48:48 +020042static const char *const mutable_opts[] = { "offset", "size", NULL };
43
Tomáš Golembiovský2fdc7042016-10-31 11:27:40 +010044static 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 Liucd3a4cf2014-06-05 17:21:03 +080062static 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 Ersekff369a42013-08-21 12:41:21 +020073};
Laszlo Erseke1c66c62013-08-21 12:41:17 +020074
Max Reitz500e2432020-05-13 13:05:30 +020075static int raw_read_options(QDict *options, uint64_t *offset, bool *has_size,
76 uint64_t *size, Error **errp)
Tomáš Golembiovský2fdc7042016-10-31 11:27:40 +010077{
Tomáš Golembiovský2fdc7042016-10-31 11:27:40 +010078 QemuOpts *opts = NULL;
Tomáš Golembiovský2fdc7042016-10-31 11:27:40 +010079 int ret;
80
Tomáš Golembiovský2fdc7042016-10-31 11:27:40 +010081 opts = qemu_opts_create(&raw_runtime_opts, NULL, 0, &error_abort);
Markus Armbrusteraf175e82020-07-07 18:06:03 +020082 if (!qemu_opts_absorb_qdict(opts, options, errp)) {
Tomáš Golembiovský2fdc7042016-10-31 11:27:40 +010083 ret = -EINVAL;
84 goto end;
85 }
86
Max Reitz500e2432020-05-13 13:05:30 +020087 *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ý40332872016-11-03 14:47:48 +010090
Max Reitz500e2432020-05-13 13:05:30 +020091 ret = 0;
92end:
93 qemu_opts_del(opts);
94 return ret;
95}
96
97static 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ý2fdc7042016-10-31 11:27:40 +0100107 }
108
109 /* Check size and offset */
Max Reitz500e2432020-05-13 13:05:30 +0200110 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ý2fdc7042016-10-31 11:27:40 +0100118 error_setg(errp, "The sum of offset (%" PRIu64 ") and size "
Max Reitz500e2432020-05-13 13:05:30 +0200119 "(%" 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ý2fdc7042016-10-31 11:27:40 +0100123 }
124
125 /* Make sure size is multiple of BDRV_SECTOR_SIZE to prevent rounding
126 * up and leaking out of the specified area. */
Max Reitz500e2432020-05-13 13:05:30 +0200127 if (has_size && !QEMU_IS_ALIGNED(size, BDRV_SECTOR_SIZE)) {
Tomáš Golembiovský2fdc7042016-10-31 11:27:40 +0100128 error_setg(errp, "Specified size is not multiple of %llu",
Max Reitz500e2432020-05-13 13:05:30 +0200129 BDRV_SECTOR_SIZE);
130 return -EINVAL;
Tomáš Golembiovský2fdc7042016-10-31 11:27:40 +0100131 }
132
Max Reitz500e2432020-05-13 13:05:30 +0200133 s->offset = offset;
134 s->has_size = has_size;
135 s->size = has_size ? size : real_size - offset;
Tomáš Golembiovský2fdc7042016-10-31 11:27:40 +0100136
Max Reitz500e2432020-05-13 13:05:30 +0200137 return 0;
Tomáš Golembiovský2fdc7042016-10-31 11:27:40 +0100138}
139
Laszlo Ersek7a6d3fc2013-08-21 12:41:23 +0200140static int raw_reopen_prepare(BDRVReopenState *reopen_state,
141 BlockReopenQueue *queue, Error **errp)
Laszlo Erseke1c66c62013-08-21 12:41:17 +0200142{
Max Reitz500e2432020-05-13 13:05:30 +0200143 bool has_size;
144 uint64_t offset, size;
145 int ret;
146
Tomáš Golembiovský2fdc7042016-10-31 11:27:40 +0100147 assert(reopen_state != NULL);
148 assert(reopen_state->bs != NULL);
149
150 reopen_state->opaque = g_new0(BDRVRawState, 1);
151
Max Reitz500e2432020-05-13 13:05:30 +0200152 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ý2fdc7042016-10-31 11:27:40 +0100165}
166
167static 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
178static void raw_reopen_abort(BDRVReopenState *state)
179{
180 g_free(state->opaque);
181 state->opaque = NULL;
Laszlo Erseke1c66c62013-08-21 12:41:17 +0200182}
183
Fam Zheng38445532018-06-01 17:26:40 +0800184/* Check and adjust the offset, against 'offset' and 'size' options. */
Vladimir Sementsov-Ogievskiyf7ef38d2021-09-03 13:27:59 +0300185static inline int raw_adjust_offset(BlockDriverState *bs, int64_t *offset,
186 int64_t bytes, bool is_write)
Fam Zheng38445532018-06-01 17:26:40 +0800187{
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 Zheng6d6bcc42018-07-02 10:58:36 +0800194 return is_write ? -ENOSPC : -EINVAL;
Fam Zheng38445532018-06-01 17:26:40 +0800195 }
196
197 if (*offset > INT64_MAX - s->offset) {
198 return -EINVAL;
199 }
200 *offset += s->offset;
201
202 return 0;
203}
204
Vladimir Sementsov-Ogievskiyf7ef38d2021-09-03 13:27:59 +0300205static int coroutine_fn raw_co_preadv(BlockDriverState *bs, int64_t offset,
206 int64_t bytes, QEMUIOVector *qiov,
207 BdrvRequestFlags flags)
Laszlo Erseke1c66c62013-08-21 12:41:17 +0200208{
Fam Zheng38445532018-06-01 17:26:40 +0800209 int ret;
Tomáš Golembiovský2fdc7042016-10-31 11:27:40 +0100210
Fam Zheng38445532018-06-01 17:26:40 +0800211 ret = raw_adjust_offset(bs, &offset, bytes, false);
212 if (ret) {
213 return ret;
Tomáš Golembiovský2fdc7042016-10-31 11:27:40 +0100214 }
Tomáš Golembiovský2fdc7042016-10-31 11:27:40 +0100215
Laszlo Ersek9eaafd92013-08-21 12:41:18 +0200216 BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO);
Eric Blakedecaeed2016-07-15 17:23:08 -0600217 return bdrv_co_preadv(bs->file, offset, bytes, qiov, flags);
Laszlo Erseke1c66c62013-08-21 12:41:17 +0200218}
219
Vladimir Sementsov-Ogievskiye75abed2021-09-03 13:28:00 +0300220static int coroutine_fn raw_co_pwritev(BlockDriverState *bs, int64_t offset,
221 int64_t bytes, QEMUIOVector *qiov,
222 BdrvRequestFlags flags)
Laszlo Erseke1c66c62013-08-21 12:41:17 +0200223{
Kevin Wolf38f3ef52014-11-20 16:27:12 +0100224 void *buf = NULL;
225 BlockDriver *drv;
226 QEMUIOVector local_qiov;
227 int ret;
228
Eric Blakedecaeed2016-07-15 17:23:08 -0600229 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 Wolf38f3ef52014-11-20 16:27:12 +0100233 QEMU_BUILD_BUG_ON(BLOCK_PROBE_BUF_SIZE != 512);
234 QEMU_BUILD_BUG_ON(BDRV_SECTOR_SIZE != 512);
Eric Blakedecaeed2016-07-15 17:23:08 -0600235 assert(offset == 0 && bytes >= BLOCK_PROBE_BUF_SIZE);
Kevin Wolf38f3ef52014-11-20 16:27:12 +0100236
Kevin Wolf9a4f4c32015-06-16 14:19:22 +0200237 buf = qemu_try_blockalign(bs->file->bs, 512);
Kevin Wolf38f3ef52014-11-20 16:27:12 +0100238 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-Ogievskiye75abed2021-09-03 13:28:00 +0300263 ret = raw_adjust_offset(bs, &offset, bytes, true);
Fam Zheng38445532018-06-01 17:26:40 +0800264 if (ret) {
265 goto fail;
266 }
Tomáš Golembiovský2fdc7042016-10-31 11:27:40 +0100267
Laszlo Ersek9eaafd92013-08-21 12:41:18 +0200268 BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO);
Eric Blakedecaeed2016-07-15 17:23:08 -0600269 ret = bdrv_co_pwritev(bs->file, offset, bytes, qiov, flags);
Kevin Wolf38f3ef52014-11-20 16:27:12 +0100270
271fail:
272 if (qiov == &local_qiov) {
273 qemu_iovec_destroy(&local_qiov);
274 }
275 qemu_vfree(buf);
276 return ret;
Laszlo Erseke1c66c62013-08-21 12:41:17 +0200277}
278
Eric Blaked41aa7e2018-02-13 14:26:54 -0600279static 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 Zheng67a0fd22016-01-26 11:58:48 +0800283 BlockDriverState **file)
Laszlo Erseke1c66c62013-08-21 12:41:17 +0200284{
Tomáš Golembiovský2fdc7042016-10-31 11:27:40 +0100285 BDRVRawState *s = bs->opaque;
Eric Blaked41aa7e2018-02-13 14:26:54 -0600286 *pnum = bytes;
Fam Zheng02650ac2016-01-26 11:58:51 +0800287 *file = bs->file->bs;
Eric Blaked41aa7e2018-02-13 14:26:54 -0600288 *map = offset + s->offset;
289 return BDRV_BLOCK_RAW | BDRV_BLOCK_OFFSET_VALID;
Laszlo Erseke1c66c62013-08-21 12:41:17 +0200290}
291
Eric Blake39ad9372016-06-01 15:10:11 -0600292static int coroutine_fn raw_co_pwrite_zeroes(BlockDriverState *bs,
Vladimir Sementsov-Ogievskiyf34b2bc2021-09-03 13:28:03 +0300293 int64_t offset, int64_t bytes,
Eric Blake39ad9372016-06-01 15:10:11 -0600294 BdrvRequestFlags flags)
Laszlo Erseke1c66c62013-08-21 12:41:17 +0200295{
Fam Zheng38445532018-06-01 17:26:40 +0800296 int ret;
297
Vladimir Sementsov-Ogievskiyf7ef38d2021-09-03 13:27:59 +0300298 ret = raw_adjust_offset(bs, &offset, bytes, true);
Fam Zheng38445532018-06-01 17:26:40 +0800299 if (ret) {
300 return ret;
Tomáš Golembiovský2fdc7042016-10-31 11:27:40 +0100301 }
Manos Pitsidianakisf5a5ca72017-06-09 13:18:08 +0300302 return bdrv_co_pwrite_zeroes(bs->file, offset, bytes, flags);
Laszlo Erseke1c66c62013-08-21 12:41:17 +0200303}
304
Eric Blake5f61ad02016-07-15 17:23:04 -0600305static int coroutine_fn raw_co_pdiscard(BlockDriverState *bs,
Vladimir Sementsov-Ogievskiy0c802282021-09-03 13:28:06 +0300306 int64_t offset, int64_t bytes)
Laszlo Erseke1c66c62013-08-21 12:41:17 +0200307{
Fam Zheng38445532018-06-01 17:26:40 +0800308 int ret;
309
Vladimir Sementsov-Ogievskiyf7ef38d2021-09-03 13:27:59 +0300310 ret = raw_adjust_offset(bs, &offset, bytes, true);
Fam Zheng38445532018-06-01 17:26:40 +0800311 if (ret) {
312 return ret;
Tomáš Golembiovský2fdc7042016-10-31 11:27:40 +0100313 }
Fam Zheng0b9fd3f2018-07-10 14:31:17 +0800314 return bdrv_co_pdiscard(bs->file, offset, bytes);
Laszlo Erseke1c66c62013-08-21 12:41:17 +0200315}
316
Laszlo Ersek7a6d3fc2013-08-21 12:41:23 +0200317static int64_t raw_getlength(BlockDriverState *bs)
Laszlo Erseke1c66c62013-08-21 12:41:17 +0200318{
Tomáš Golembiovský2fdc7042016-10-31 11:27:40 +0100319 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 Erseke1c66c62013-08-21 12:41:17 +0200341}
342
Stefan Hajnoczia843a222017-07-05 13:57:31 +0100343static 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 Blake5d72c682020-05-21 14:21:34 -0500360 info = g_new0(BlockMeasureInfo, 1);
Stefan Hajnoczia843a222017-07-05 13:57:31 +0100361 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 Ersek7a6d3fc2013-08-21 12:41:23 +0200368static int raw_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
Laszlo Erseke1c66c62013-08-21 12:41:17 +0200369{
Kevin Wolf9a4f4c32015-06-16 14:19:22 +0200370 return bdrv_get_info(bs->file->bs, bdi);
Laszlo Erseke1c66c62013-08-21 12:41:17 +0200371}
372
Eric Blakedecaeed2016-07-15 17:23:08 -0600373static 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 Wolf061ca8a2018-06-21 17:54:35 +0200383static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,
Max Reitzc80d8b02019-09-18 11:51:40 +0200384 bool exact, PreallocMode prealloc,
Kevin Wolf92b92792020-04-24 14:54:39 +0200385 BdrvRequestFlags flags, Error **errp)
Laszlo Erseke1c66c62013-08-21 12:41:17 +0200386{
Tomáš Golembiovský2fdc7042016-10-31 11:27:40 +0100387 BDRVRawState *s = bs->opaque;
388
389 if (s->has_size) {
Max Reitzf59adb32017-03-28 22:51:29 +0200390 error_setg(errp, "Cannot resize fixed-size raw disks");
Tomáš Golembiovský2fdc7042016-10-31 11:27:40 +0100391 return -ENOTSUP;
392 }
393
394 if (INT64_MAX - offset < s->offset) {
Max Reitzf59adb32017-03-28 22:51:29 +0200395 error_setg(errp, "Disk size too large for the chosen offset");
Tomáš Golembiovský2fdc7042016-10-31 11:27:40 +0100396 return -EINVAL;
397 }
398
399 s->size = offset;
400 offset += s->offset;
Kevin Wolf1ddaaba2020-04-24 14:54:43 +0200401 return bdrv_co_truncate(bs->file, offset, exact, prealloc, flags, errp);
Laszlo Erseke1c66c62013-08-21 12:41:17 +0200402}
403
Laszlo Ersek7a6d3fc2013-08-21 12:41:23 +0200404static void raw_eject(BlockDriverState *bs, bool eject_flag)
Laszlo Erseke1c66c62013-08-21 12:41:17 +0200405{
Kevin Wolf9a4f4c32015-06-16 14:19:22 +0200406 bdrv_eject(bs->file->bs, eject_flag);
Laszlo Erseke1c66c62013-08-21 12:41:17 +0200407}
408
Laszlo Ersek7a6d3fc2013-08-21 12:41:23 +0200409static void raw_lock_medium(BlockDriverState *bs, bool locked)
Laszlo Erseke1c66c62013-08-21 12:41:17 +0200410{
Kevin Wolf9a4f4c32015-06-16 14:19:22 +0200411 bdrv_lock_medium(bs->file->bs, locked);
Laszlo Erseke1c66c62013-08-21 12:41:17 +0200412}
413
Kevin Wolf151a2932016-10-20 15:09:36 +0200414static int raw_co_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
Laszlo Erseke1c66c62013-08-21 12:41:17 +0200415{
Tomáš Golembiovský2fdc7042016-10-31 11:27:40 +0100416 BDRVRawState *s = bs->opaque;
417 if (s->offset || s->has_size) {
418 return -ENOTSUP;
419 }
Kevin Wolf151a2932016-10-20 15:09:36 +0200420 return bdrv_co_ioctl(bs->file->bs, req, buf);
Laszlo Erseke1c66c62013-08-21 12:41:17 +0200421}
422
Laszlo Ersek7a6d3fc2013-08-21 12:41:23 +0200423static int raw_has_zero_init(BlockDriverState *bs)
Laszlo Erseke1c66c62013-08-21 12:41:17 +0200424{
Kevin Wolf9a4f4c32015-06-16 14:19:22 +0200425 return bdrv_has_zero_init(bs->file->bs);
Laszlo Erseke1c66c62013-08-21 12:41:17 +0200426}
427
Maxim Levitskyb92902d2020-03-26 03:12:17 +0200428static int coroutine_fn raw_co_create_opts(BlockDriver *drv,
429 const char *filename,
430 QemuOpts *opts,
Stefan Hajnocziefc75e22018-01-18 13:43:45 +0100431 Error **errp)
Laszlo Ersek15652622013-08-21 12:41:19 +0200432{
Eduardo Habkost9be38592016-06-13 18:57:58 -0300433 return bdrv_create_file(filename, opts, errp);
Laszlo Ersek15652622013-08-21 12:41:19 +0200434}
Laszlo Ersek01dd96d2013-08-21 12:41:20 +0200435
Max Reitz015a1032013-09-05 14:22:29 +0200436static int raw_open(BlockDriverState *bs, QDict *options, int flags,
437 Error **errp)
Laszlo Ersek01dd96d2013-08-21 12:41:20 +0200438{
Tomáš Golembiovský2fdc7042016-10-31 11:27:40 +0100439 BDRVRawState *s = bs->opaque;
Max Reitz500e2432020-05-13 13:05:30 +0200440 bool has_size;
441 uint64_t offset, size;
Max Reitz58944402020-05-13 13:05:37 +0200442 BdrvChildRole file_role;
Tomáš Golembiovský2fdc7042016-10-31 11:27:40 +0100443 int ret;
444
Max Reitz500e2432020-05-13 13:05:30 +0200445 ret = raw_read_options(options, &offset, &has_size, &size, errp);
446 if (ret < 0) {
447 return ret;
448 }
449
Max Reitz58944402020-05-13 13:05:37 +0200450 /*
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 Wolf4e4bf5c2016-12-16 18:52:37 +0100462 if (!bs->file) {
463 return -EINVAL;
464 }
465
Denis V. Lunev006e1962022-08-17 10:37:35 +0200466 bs->sg = bdrv_is_sg(bs->file->bs);
Max Reitz228345b2018-04-21 15:29:26 +0200467 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 Wolf80f5c332019-03-22 13:42:39 +0100470 ((BDRV_REQ_FUA | BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK) &
Max Reitz228345b2018-04-21 15:29:26 +0200471 bs->file->bs->supported_zero_flags);
Kevin Wolf1ddaaba2020-04-24 14:54:43 +0200472 bs->supported_truncate_flags = bs->file->bs->supported_truncate_flags &
473 BDRV_REQ_ZERO_WRITE;
Kevin Wolf38f3ef52014-11-20 16:27:12 +0100474
475 if (bs->probed && !bdrv_is_read_only(bs)) {
Max Reitzf30c66b2019-02-01 20:29:05 +0100476 bdrv_refresh_filename(bs->file->bs);
Kevin Wolf38f3ef52014-11-20 16:27:12 +0100477 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 Wolf9a4f4c32015-06-16 14:19:22 +0200484 bs->file->bs->filename);
Kevin Wolf38f3ef52014-11-20 16:27:12 +0100485 }
486
Max Reitz500e2432020-05-13 13:05:30 +0200487 ret = raw_apply_options(bs, s, offset, has_size, size, errp);
Tomáš Golembiovský2fdc7042016-10-31 11:27:40 +0100488 if (ret < 0) {
489 return ret;
490 }
491
Denis V. Lunev006e1962022-08-17 10:37:35 +0200492 if (bdrv_is_sg(bs) && (s->offset || s->has_size)) {
Tomáš Golembiovský2fdc7042016-10-31 11:27:40 +0100493 error_setg(errp, "Cannot use offset/size with SCSI generic devices");
494 return -EINVAL;
495 }
496
Laszlo Ersek01dd96d2013-08-21 12:41:20 +0200497 return 0;
498}
499
Laszlo Ersek7a6d3fc2013-08-21 12:41:23 +0200500static int raw_probe(const uint8_t *buf, int buf_size, const char *filename)
Laszlo Ersek01dd96d2013-08-21 12:41:20 +0200501{
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 Ersek775d6af2013-08-21 12:41:22 +0200507
Ekaterina Tumanova1a9335e2015-02-16 12:47:56 +0100508static int raw_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz)
509{
Tomáš Golembiovský2fdc7042016-10-31 11:27:40 +0100510 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 Tumanova1a9335e2015-02-16 12:47:56 +0100523}
524
525static int raw_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
526{
Tomáš Golembiovský2fdc7042016-10-31 11:27:40 +0100527 BDRVRawState *s = bs->opaque;
528 if (s->offset || s->has_size) {
529 return -ENOTSUP;
530 }
Kevin Wolf9a4f4c32015-06-16 14:19:22 +0200531 return bdrv_probe_geometry(bs->file->bs, geo);
Ekaterina Tumanova1a9335e2015-02-16 12:47:56 +0100532}
533
Fam Zheng72d219e2018-06-01 17:26:41 +0800534static int coroutine_fn raw_co_copy_range_from(BlockDriverState *bs,
Vladimir Sementsov-Ogievskiy67b51fb2018-07-09 19:37:17 +0300535 BdrvChild *src,
Vladimir Sementsov-Ogievskiy48535042021-09-03 13:28:01 +0300536 int64_t src_offset,
Vladimir Sementsov-Ogievskiy67b51fb2018-07-09 19:37:17 +0300537 BdrvChild *dst,
Vladimir Sementsov-Ogievskiy48535042021-09-03 13:28:01 +0300538 int64_t dst_offset,
539 int64_t bytes,
Vladimir Sementsov-Ogievskiy67b51fb2018-07-09 19:37:17 +0300540 BdrvRequestFlags read_flags,
541 BdrvRequestFlags write_flags)
Fam Zheng72d219e2018-06-01 17:26:41 +0800542{
543 int ret;
544
Vladimir Sementsov-Ogievskiy48535042021-09-03 13:28:01 +0300545 ret = raw_adjust_offset(bs, &src_offset, bytes, false);
Fam Zheng72d219e2018-06-01 17:26:41 +0800546 if (ret) {
547 return ret;
548 }
549 return bdrv_co_copy_range_from(bs->file, src_offset, dst, dst_offset,
Vladimir Sementsov-Ogievskiy67b51fb2018-07-09 19:37:17 +0300550 bytes, read_flags, write_flags);
Fam Zheng72d219e2018-06-01 17:26:41 +0800551}
552
553static int coroutine_fn raw_co_copy_range_to(BlockDriverState *bs,
Vladimir Sementsov-Ogievskiy67b51fb2018-07-09 19:37:17 +0300554 BdrvChild *src,
Vladimir Sementsov-Ogievskiy48535042021-09-03 13:28:01 +0300555 int64_t src_offset,
Vladimir Sementsov-Ogievskiy67b51fb2018-07-09 19:37:17 +0300556 BdrvChild *dst,
Vladimir Sementsov-Ogievskiy48535042021-09-03 13:28:01 +0300557 int64_t dst_offset,
558 int64_t bytes,
Vladimir Sementsov-Ogievskiy67b51fb2018-07-09 19:37:17 +0300559 BdrvRequestFlags read_flags,
560 BdrvRequestFlags write_flags)
Fam Zheng72d219e2018-06-01 17:26:41 +0800561{
562 int ret;
563
Vladimir Sementsov-Ogievskiy48535042021-09-03 13:28:01 +0300564 ret = raw_adjust_offset(bs, &dst_offset, bytes, true);
Fam Zheng72d219e2018-06-01 17:26:41 +0800565 if (ret) {
566 return ret;
567 }
568 return bdrv_co_copy_range_to(src, src_offset, bs->file, dst_offset, bytes,
Vladimir Sementsov-Ogievskiy67b51fb2018-07-09 19:37:17 +0300569 read_flags, write_flags);
Fam Zheng72d219e2018-06-01 17:26:41 +0800570}
571
Max Reitz26542672019-02-01 20:29:25 +0100572static const char *const raw_strong_runtime_opts[] = {
573 "offset",
574 "size",
575
576 NULL
577};
578
Vladimir Sementsov-Ogievskiy3fc1ec32021-02-05 19:37:13 +0300579static void raw_cancel_in_flight(BlockDriverState *bs)
580{
581 bdrv_cancel_in_flight(bs->file->bs);
582}
583
Stefan Hajnoczib68ce822021-07-26 13:28:39 +0100584static 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 Reitz5f535a92014-12-02 18:32:41 +0100603BlockDriver bdrv_raw = {
Laszlo Ersek775d6af2013-08-21 12:41:22 +0200604 .format_name = "raw",
Tomáš Golembiovský2fdc7042016-10-31 11:27:40 +0100605 .instance_size = sizeof(BDRVRawState),
Laszlo Ersek775d6af2013-08-21 12:41:22 +0200606 .bdrv_probe = &raw_probe,
607 .bdrv_reopen_prepare = &raw_reopen_prepare,
Tomáš Golembiovský2fdc7042016-10-31 11:27:40 +0100608 .bdrv_reopen_commit = &raw_reopen_commit,
609 .bdrv_reopen_abort = &raw_reopen_abort,
Laszlo Ersek775d6af2013-08-21 12:41:22 +0200610 .bdrv_open = &raw_open,
Stefan Hajnoczib68ce822021-07-26 13:28:39 +0100611 .bdrv_child_perm = raw_child_perm,
Stefan Hajnocziefc75e22018-01-18 13:43:45 +0100612 .bdrv_co_create_opts = &raw_co_create_opts,
Eric Blakedecaeed2016-07-15 17:23:08 -0600613 .bdrv_co_preadv = &raw_co_preadv,
614 .bdrv_co_pwritev = &raw_co_pwritev,
Eric Blake39ad9372016-06-01 15:10:11 -0600615 .bdrv_co_pwrite_zeroes = &raw_co_pwrite_zeroes,
Eric Blake5f61ad02016-07-15 17:23:04 -0600616 .bdrv_co_pdiscard = &raw_co_pdiscard,
Eric Blaked41aa7e2018-02-13 14:26:54 -0600617 .bdrv_co_block_status = &raw_co_block_status,
Fam Zheng72d219e2018-06-01 17:26:41 +0800618 .bdrv_co_copy_range_from = &raw_co_copy_range_from,
619 .bdrv_co_copy_range_to = &raw_co_copy_range_to,
Kevin Wolf061ca8a2018-06-21 17:54:35 +0200620 .bdrv_co_truncate = &raw_co_truncate,
Laszlo Ersek775d6af2013-08-21 12:41:22 +0200621 .bdrv_getlength = &raw_getlength,
Max Reitzd67066d2020-05-13 13:05:12 +0200622 .is_format = true,
Kevin Wolfb94a2612013-10-29 12:18:58 +0100623 .has_variable_length = true,
Stefan Hajnoczia843a222017-07-05 13:57:31 +0100624 .bdrv_measure = &raw_measure,
Laszlo Ersek775d6af2013-08-21 12:41:22 +0200625 .bdrv_get_info = &raw_get_info,
Eric Blakedecaeed2016-07-15 17:23:08 -0600626 .bdrv_refresh_limits = &raw_refresh_limits,
Ekaterina Tumanova1a9335e2015-02-16 12:47:56 +0100627 .bdrv_probe_blocksizes = &raw_probe_blocksizes,
628 .bdrv_probe_geometry = &raw_probe_geometry,
Laszlo Ersek775d6af2013-08-21 12:41:22 +0200629 .bdrv_eject = &raw_eject,
630 .bdrv_lock_medium = &raw_lock_medium,
Kevin Wolf151a2932016-10-20 15:09:36 +0200631 .bdrv_co_ioctl = &raw_co_ioctl,
Chunyan Liucd3a4cf2014-06-05 17:21:03 +0800632 .create_opts = &raw_create_opts,
Max Reitz26542672019-02-01 20:29:25 +0100633 .bdrv_has_zero_init = &raw_has_zero_init,
634 .strong_runtime_opts = raw_strong_runtime_opts,
Alberto Garcia8a2ce0b2019-03-12 18:48:48 +0200635 .mutable_opts = mutable_opts,
Vladimir Sementsov-Ogievskiy3fc1ec32021-02-05 19:37:13 +0300636 .bdrv_cancel_in_flight = raw_cancel_in_flight,
Laszlo Ersek775d6af2013-08-21 12:41:22 +0200637};
638
639static void bdrv_raw_init(void)
640{
641 bdrv_register(&bdrv_raw);
642}
643
644block_init(bdrv_raw_init);