1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29#include "qemu/osdep.h"
30#include "block/block_int.h"
31#include "qapi/error.h"
32#include "qemu/module.h"
33#include "qemu/option.h"
34
35typedef struct BDRVRawState {
36 uint64_t offset;
37 uint64_t size;
38 bool has_size;
39} BDRVRawState;
40
41static const char *const mutable_opts[] = { "offset", "size", NULL };
42
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 { }
58 },
59};
60
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 { }
71 }
72};
73
74static int raw_read_options(QDict *options, BlockDriverState *bs,
75 BDRVRawState *s, Error **errp)
76{
77 Error *local_err = NULL;
78 QemuOpts *opts = NULL;
79 int64_t real_size = 0;
80 int ret;
81
82 real_size = bdrv_getlength(bs->file->bs);
83 if (real_size < 0) {
84 error_setg_errno(errp, -real_size, "Could not get image size");
85 return real_size;
86 }
87
88 opts = qemu_opts_create(&raw_runtime_opts, NULL, 0, &error_abort);
89 qemu_opts_absorb_qdict(opts, options, &local_err);
90 if (local_err) {
91 error_propagate(errp, local_err);
92 ret = -EINVAL;
93 goto end;
94 }
95
96 s->offset = qemu_opt_get_size(opts, "offset", 0);
97 if (s->offset > real_size) {
98 error_setg(errp, "Offset (%" PRIu64 ") cannot be greater than "
99 "size of the containing file (%" PRId64 ")",
100 s->offset, real_size);
101 ret = -EINVAL;
102 goto end;
103 }
104
105 if (qemu_opt_find(opts, "size") != NULL) {
106 s->size = qemu_opt_get_size(opts, "size", 0);
107 s->has_size = true;
108 } else {
109 s->has_size = false;
110 s->size = real_size - s->offset;
111 }
112
113
114 if ((real_size - s->offset) < s->size) {
115 error_setg(errp, "The sum of offset (%" PRIu64 ") and size "
116 "(%" PRIu64 ") has to be smaller or equal to the "
117 " actual size of the containing file (%" PRId64 ")",
118 s->offset, s->size, real_size);
119 ret = -EINVAL;
120 goto end;
121 }
122
123
124
125 if (s->has_size && !QEMU_IS_ALIGNED(s->size, BDRV_SECTOR_SIZE)) {
126 error_setg(errp, "Specified size is not multiple of %llu",
127 BDRV_SECTOR_SIZE);
128 ret = -EINVAL;
129 goto end;
130 }
131
132 ret = 0;
133
134end:
135
136 qemu_opts_del(opts);
137
138 return ret;
139}
140
141static int raw_reopen_prepare(BDRVReopenState *reopen_state,
142 BlockReopenQueue *queue, Error **errp)
143{
144 assert(reopen_state != NULL);
145 assert(reopen_state->bs != NULL);
146
147 reopen_state->opaque = g_new0(BDRVRawState, 1);
148
149 return raw_read_options(
150 reopen_state->options,
151 reopen_state->bs,
152 reopen_state->opaque,
153 errp);
154}
155
156static void raw_reopen_commit(BDRVReopenState *state)
157{
158 BDRVRawState *new_s = state->opaque;
159 BDRVRawState *s = state->bs->opaque;
160
161 memcpy(s, new_s, sizeof(BDRVRawState));
162
163 g_free(state->opaque);
164 state->opaque = NULL;
165}
166
167static void raw_reopen_abort(BDRVReopenState *state)
168{
169 g_free(state->opaque);
170 state->opaque = NULL;
171}
172
173
174static inline int raw_adjust_offset(BlockDriverState *bs, uint64_t *offset,
175 uint64_t bytes, bool is_write)
176{
177 BDRVRawState *s = bs->opaque;
178
179 if (s->has_size && (*offset > s->size || bytes > (s->size - *offset))) {
180
181
182
183 return is_write ? -ENOSPC : -EINVAL;
184 }
185
186 if (*offset > INT64_MAX - s->offset) {
187 return -EINVAL;
188 }
189 *offset += s->offset;
190
191 return 0;
192}
193
194static int coroutine_fn raw_co_preadv(BlockDriverState *bs, uint64_t offset,
195 uint64_t bytes, QEMUIOVector *qiov,
196 int flags)
197{
198 int ret;
199
200 ret = raw_adjust_offset(bs, &offset, bytes, false);
201 if (ret) {
202 return ret;
203 }
204
205 BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO);
206 return bdrv_co_preadv(bs->file, offset, bytes, qiov, flags);
207}
208
209static int coroutine_fn raw_co_pwritev(BlockDriverState *bs, uint64_t offset,
210 uint64_t bytes, QEMUIOVector *qiov,
211 int flags)
212{
213 void *buf = NULL;
214 BlockDriver *drv;
215 QEMUIOVector local_qiov;
216 int ret;
217
218 if (bs->probed && offset < BLOCK_PROBE_BUF_SIZE && bytes) {
219
220
221
222 QEMU_BUILD_BUG_ON(BLOCK_PROBE_BUF_SIZE != 512);
223 QEMU_BUILD_BUG_ON(BDRV_SECTOR_SIZE != 512);
224 assert(offset == 0 && bytes >= BLOCK_PROBE_BUF_SIZE);
225
226 buf = qemu_try_blockalign(bs->file->bs, 512);
227 if (!buf) {
228 ret = -ENOMEM;
229 goto fail;
230 }
231
232 ret = qemu_iovec_to_buf(qiov, 0, buf, 512);
233 if (ret != 512) {
234 ret = -EINVAL;
235 goto fail;
236 }
237
238 drv = bdrv_probe_all(buf, 512, NULL);
239 if (drv != bs->drv) {
240 ret = -EPERM;
241 goto fail;
242 }
243
244
245
246 qemu_iovec_init(&local_qiov, qiov->niov + 1);
247 qemu_iovec_add(&local_qiov, buf, 512);
248 qemu_iovec_concat(&local_qiov, qiov, 512, qiov->size - 512);
249 qiov = &local_qiov;
250 }
251
252 ret = raw_adjust_offset(bs, &offset, bytes, true);
253 if (ret) {
254 goto fail;
255 }
256
257 BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO);
258 ret = bdrv_co_pwritev(bs->file, offset, bytes, qiov, flags);
259
260fail:
261 if (qiov == &local_qiov) {
262 qemu_iovec_destroy(&local_qiov);
263 }
264 qemu_vfree(buf);
265 return ret;
266}
267
268static int coroutine_fn raw_co_block_status(BlockDriverState *bs,
269 bool want_zero, int64_t offset,
270 int64_t bytes, int64_t *pnum,
271 int64_t *map,
272 BlockDriverState **file)
273{
274 BDRVRawState *s = bs->opaque;
275 *pnum = bytes;
276 *file = bs->file->bs;
277 *map = offset + s->offset;
278 return BDRV_BLOCK_RAW | BDRV_BLOCK_OFFSET_VALID;
279}
280
281static int coroutine_fn raw_co_pwrite_zeroes(BlockDriverState *bs,
282 int64_t offset, int bytes,
283 BdrvRequestFlags flags)
284{
285 int ret;
286
287 ret = raw_adjust_offset(bs, (uint64_t *)&offset, bytes, true);
288 if (ret) {
289 return ret;
290 }
291 return bdrv_co_pwrite_zeroes(bs->file, offset, bytes, flags);
292}
293
294static int coroutine_fn raw_co_pdiscard(BlockDriverState *bs,
295 int64_t offset, int bytes)
296{
297 int ret;
298
299 ret = raw_adjust_offset(bs, (uint64_t *)&offset, bytes, true);
300 if (ret) {
301 return ret;
302 }
303 return bdrv_co_pdiscard(bs->file, offset, bytes);
304}
305
306static int64_t raw_getlength(BlockDriverState *bs)
307{
308 int64_t len;
309 BDRVRawState *s = bs->opaque;
310
311
312
313 len = bdrv_getlength(bs->file->bs);
314 if (len < 0) {
315 return len;
316 }
317
318 if (len < s->offset) {
319 s->size = 0;
320 } else {
321 if (s->has_size) {
322
323 s->size = MIN(s->size, len - s->offset);
324 } else {
325 s->size = len - s->offset;
326 }
327 }
328
329 return s->size;
330}
331
332static BlockMeasureInfo *raw_measure(QemuOpts *opts, BlockDriverState *in_bs,
333 Error **errp)
334{
335 BlockMeasureInfo *info;
336 int64_t required;
337
338 if (in_bs) {
339 required = bdrv_getlength(in_bs);
340 if (required < 0) {
341 error_setg_errno(errp, -required, "Unable to get image size");
342 return NULL;
343 }
344 } else {
345 required = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
346 BDRV_SECTOR_SIZE);
347 }
348
349 info = g_new(BlockMeasureInfo, 1);
350 info->required = required;
351
352
353 info->fully_allocated = info->required;
354 return info;
355}
356
357static int raw_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
358{
359 return bdrv_get_info(bs->file->bs, bdi);
360}
361
362static void raw_refresh_limits(BlockDriverState *bs, Error **errp)
363{
364 if (bs->probed) {
365
366
367
368 bs->bl.request_alignment = BDRV_SECTOR_SIZE;
369 }
370}
371
372static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,
373 bool exact, PreallocMode prealloc,
374 Error **errp)
375{
376 BDRVRawState *s = bs->opaque;
377
378 if (s->has_size) {
379 error_setg(errp, "Cannot resize fixed-size raw disks");
380 return -ENOTSUP;
381 }
382
383 if (INT64_MAX - offset < s->offset) {
384 error_setg(errp, "Disk size too large for the chosen offset");
385 return -EINVAL;
386 }
387
388 s->size = offset;
389 offset += s->offset;
390 return bdrv_co_truncate(bs->file, offset, exact, prealloc, errp);
391}
392
393static void raw_eject(BlockDriverState *bs, bool eject_flag)
394{
395 bdrv_eject(bs->file->bs, eject_flag);
396}
397
398static void raw_lock_medium(BlockDriverState *bs, bool locked)
399{
400 bdrv_lock_medium(bs->file->bs, locked);
401}
402
403static int raw_co_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
404{
405 BDRVRawState *s = bs->opaque;
406 if (s->offset || s->has_size) {
407 return -ENOTSUP;
408 }
409 return bdrv_co_ioctl(bs->file->bs, req, buf);
410}
411
412static int raw_has_zero_init(BlockDriverState *bs)
413{
414 return bdrv_has_zero_init(bs->file->bs);
415}
416
417static int raw_has_zero_init_truncate(BlockDriverState *bs)
418{
419 return bdrv_has_zero_init_truncate(bs->file->bs);
420}
421
422static int coroutine_fn raw_co_create_opts(const char *filename, QemuOpts *opts,
423 Error **errp)
424{
425 return bdrv_create_file(filename, opts, errp);
426}
427
428static int raw_open(BlockDriverState *bs, QDict *options, int flags,
429 Error **errp)
430{
431 BDRVRawState *s = bs->opaque;
432 int ret;
433
434 bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
435 false, errp);
436 if (!bs->file) {
437 return -EINVAL;
438 }
439
440 bs->sg = bs->file->bs->sg;
441 bs->supported_write_flags = BDRV_REQ_WRITE_UNCHANGED |
442 (BDRV_REQ_FUA & bs->file->bs->supported_write_flags);
443 bs->supported_zero_flags = BDRV_REQ_WRITE_UNCHANGED |
444 ((BDRV_REQ_FUA | BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK) &
445 bs->file->bs->supported_zero_flags);
446
447 if (bs->probed && !bdrv_is_read_only(bs)) {
448 bdrv_refresh_filename(bs->file->bs);
449 fprintf(stderr,
450 "WARNING: Image format was not specified for '%s' and probing "
451 "guessed raw.\n"
452 " Automatically detecting the format is dangerous for "
453 "raw images, write operations on block 0 will be restricted.\n"
454 " Specify the 'raw' format explicitly to remove the "
455 "restrictions.\n",
456 bs->file->bs->filename);
457 }
458
459 ret = raw_read_options(options, bs, s, errp);
460 if (ret < 0) {
461 return ret;
462 }
463
464 if (bs->sg && (s->offset || s->has_size)) {
465 error_setg(errp, "Cannot use offset/size with SCSI generic devices");
466 return -EINVAL;
467 }
468
469 return 0;
470}
471
472static int raw_probe(const uint8_t *buf, int buf_size, const char *filename)
473{
474
475
476
477 return 1;
478}
479
480static int raw_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz)
481{
482 BDRVRawState *s = bs->opaque;
483 int ret;
484
485 ret = bdrv_probe_blocksizes(bs->file->bs, bsz);
486 if (ret < 0) {
487 return ret;
488 }
489
490 if (!QEMU_IS_ALIGNED(s->offset, MAX(bsz->log, bsz->phys))) {
491 return -ENOTSUP;
492 }
493
494 return 0;
495}
496
497static int raw_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
498{
499 BDRVRawState *s = bs->opaque;
500 if (s->offset || s->has_size) {
501 return -ENOTSUP;
502 }
503 return bdrv_probe_geometry(bs->file->bs, geo);
504}
505
506static int coroutine_fn raw_co_copy_range_from(BlockDriverState *bs,
507 BdrvChild *src,
508 uint64_t src_offset,
509 BdrvChild *dst,
510 uint64_t dst_offset,
511 uint64_t bytes,
512 BdrvRequestFlags read_flags,
513 BdrvRequestFlags write_flags)
514{
515 int ret;
516
517 ret = raw_adjust_offset(bs, &src_offset, bytes, false);
518 if (ret) {
519 return ret;
520 }
521 return bdrv_co_copy_range_from(bs->file, src_offset, dst, dst_offset,
522 bytes, read_flags, write_flags);
523}
524
525static int coroutine_fn raw_co_copy_range_to(BlockDriverState *bs,
526 BdrvChild *src,
527 uint64_t src_offset,
528 BdrvChild *dst,
529 uint64_t dst_offset,
530 uint64_t bytes,
531 BdrvRequestFlags read_flags,
532 BdrvRequestFlags write_flags)
533{
534 int ret;
535
536 ret = raw_adjust_offset(bs, &dst_offset, bytes, true);
537 if (ret) {
538 return ret;
539 }
540 return bdrv_co_copy_range_to(src, src_offset, bs->file, dst_offset, bytes,
541 read_flags, write_flags);
542}
543
544static const char *const raw_strong_runtime_opts[] = {
545 "offset",
546 "size",
547
548 NULL
549};
550
551BlockDriver bdrv_raw = {
552 .format_name = "raw",
553 .instance_size = sizeof(BDRVRawState),
554 .bdrv_probe = &raw_probe,
555 .bdrv_reopen_prepare = &raw_reopen_prepare,
556 .bdrv_reopen_commit = &raw_reopen_commit,
557 .bdrv_reopen_abort = &raw_reopen_abort,
558 .bdrv_open = &raw_open,
559 .bdrv_child_perm = bdrv_filter_default_perms,
560 .bdrv_co_create_opts = &raw_co_create_opts,
561 .bdrv_co_preadv = &raw_co_preadv,
562 .bdrv_co_pwritev = &raw_co_pwritev,
563 .bdrv_co_pwrite_zeroes = &raw_co_pwrite_zeroes,
564 .bdrv_co_pdiscard = &raw_co_pdiscard,
565 .bdrv_co_block_status = &raw_co_block_status,
566 .bdrv_co_copy_range_from = &raw_co_copy_range_from,
567 .bdrv_co_copy_range_to = &raw_co_copy_range_to,
568 .bdrv_co_truncate = &raw_co_truncate,
569 .bdrv_getlength = &raw_getlength,
570 .has_variable_length = true,
571 .bdrv_measure = &raw_measure,
572 .bdrv_get_info = &raw_get_info,
573 .bdrv_refresh_limits = &raw_refresh_limits,
574 .bdrv_probe_blocksizes = &raw_probe_blocksizes,
575 .bdrv_probe_geometry = &raw_probe_geometry,
576 .bdrv_eject = &raw_eject,
577 .bdrv_lock_medium = &raw_lock_medium,
578 .bdrv_co_ioctl = &raw_co_ioctl,
579 .create_opts = &raw_create_opts,
580 .bdrv_has_zero_init = &raw_has_zero_init,
581 .bdrv_has_zero_init_truncate = &raw_has_zero_init_truncate,
582 .strong_runtime_opts = raw_strong_runtime_opts,
583 .mutable_opts = mutable_opts,
584};
585
586static void bdrv_raw_init(void)
587{
588 bdrv_register(&bdrv_raw);
589}
590
591block_init(bdrv_raw_init);
592