]> git.proxmox.com Git - mirror_qemu.git/blame - block/file-posix.c
file-posix: Avoid aio_worker() for QEMU_AIO_FLUSH
[mirror_qemu.git] / block / file-posix.c
CommitLineData
83f64091 1/*
223d4670 2 * Block driver for RAW files (posix)
5fafdf24 3 *
83f64091 4 * Copyright (c) 2006 Fabrice Bellard
5fafdf24 5 *
83f64091
FB
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
922a01a0 24
80c71a24 25#include "qemu/osdep.h"
da34e65c 26#include "qapi/error.h"
f348b6d1 27#include "qemu/cutils.h"
d49b6836 28#include "qemu/error-report.h"
737e150e 29#include "block/block_int.h"
1de7afc9 30#include "qemu/module.h"
922a01a0 31#include "qemu/option.h"
de81a169 32#include "trace.h"
737e150e 33#include "block/thread-pool.h"
1de7afc9 34#include "qemu/iov.h"
0187f5c9 35#include "block/raw-aio.h"
452fcdbc 36#include "qapi/qmp/qdict.h"
d49b6836 37#include "qapi/qmp/qstring.h"
83f64091 38
7c9e5276
PB
39#include "scsi/pr-manager.h"
40#include "scsi/constants.h"
41
83affaa6 42#if defined(__APPLE__) && (__MACH__)
83f64091
FB
43#include <paths.h>
44#include <sys/param.h>
45#include <IOKit/IOKitLib.h>
46#include <IOKit/IOBSD.h>
47#include <IOKit/storage/IOMediaBSDClient.h>
48#include <IOKit/storage/IOMedia.h>
49#include <IOKit/storage/IOCDMedia.h>
50//#include <IOKit/storage/IOCDTypes.h>
d0855f12 51#include <IOKit/storage/IODVDMedia.h>
83f64091
FB
52#include <CoreFoundation/CoreFoundation.h>
53#endif
54
55#ifdef __sun__
2e9671da 56#define _POSIX_PTHREAD_SEMANTICS 1
83f64091
FB
57#include <sys/dkio.h>
58#endif
19cb3738
FB
59#ifdef __linux__
60#include <sys/ioctl.h>
05acda4d 61#include <sys/param.h>
1efad060 62#include <sys/syscall.h>
19cb3738
FB
63#include <linux/cdrom.h>
64#include <linux/fd.h>
5500316d 65#include <linux/fs.h>
1a9335e4 66#include <linux/hdreg.h>
3307ed7b 67#include <scsi/sg.h>
1a9335e4
ET
68#ifdef __s390__
69#include <asm/dasd.h>
70#endif
4ab15590
CL
71#ifndef FS_NOCOW_FL
72#define FS_NOCOW_FL 0x00800000 /* Do not cow file */
73#endif
5500316d 74#endif
b953f075 75#if defined(CONFIG_FALLOCATE_PUNCH_HOLE) || defined(CONFIG_FALLOCATE_ZERO_RANGE)
3d4fa43e
KK
76#include <linux/falloc.h>
77#endif
a167ba50 78#if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
1cb6c3fd 79#include <sys/disk.h>
9f23011a 80#include <sys/cdio.h>
1cb6c3fd 81#endif
83f64091 82
128ab2ff
BS
83#ifdef __OpenBSD__
84#include <sys/ioctl.h>
85#include <sys/disklabel.h>
86#include <sys/dkio.h>
87#endif
88
d1f6fd8d
CE
89#ifdef __NetBSD__
90#include <sys/ioctl.h>
91#include <sys/disklabel.h>
92#include <sys/dkio.h>
93#include <sys/disk.h>
94#endif
95
c5e97233
BS
96#ifdef __DragonFly__
97#include <sys/ioctl.h>
98#include <sys/diskslice.h>
99#endif
100
dce512de
CH
101#ifdef CONFIG_XFS
102#include <xfs/xfs.h>
103#endif
104
faf07963 105//#define DEBUG_BLOCK
bcb22555
DA
106
107#ifdef DEBUG_BLOCK
108# define DEBUG_BLOCK_PRINT 1
8c05dbf9 109#else
bcb22555 110# define DEBUG_BLOCK_PRINT 0
8c05dbf9 111#endif
bcb22555
DA
112#define DPRINTF(fmt, ...) \
113do { \
114 if (DEBUG_BLOCK_PRINT) { \
115 printf(fmt, ## __VA_ARGS__); \
116 } \
117} while (0)
8c05dbf9 118
f6465578
AL
119/* OS X does not have O_DSYNC */
120#ifndef O_DSYNC
1c27a8b3 121#ifdef O_SYNC
7ab064d2 122#define O_DSYNC O_SYNC
1c27a8b3
JA
123#elif defined(O_FSYNC)
124#define O_DSYNC O_FSYNC
125#endif
f6465578
AL
126#endif
127
9f7965c7
AL
128/* Approximate O_DIRECT with O_DSYNC if O_DIRECT isn't available */
129#ifndef O_DIRECT
130#define O_DIRECT O_DSYNC
131#endif
132
19cb3738
FB
133#define FTYPE_FILE 0
134#define FTYPE_CD 1
83f64091 135
581b9e29
CH
136#define MAX_BLOCKSIZE 4096
137
244a5668
FZ
138/* Posix file locking bytes. Libvirt takes byte 0, we start from higher bytes,
139 * leaving a few more bytes for its future use. */
140#define RAW_LOCK_PERM_BASE 100
141#define RAW_LOCK_SHARED_BASE 200
142
19cb3738
FB
143typedef struct BDRVRawState {
144 int fd;
244a5668 145 bool use_lock;
19cb3738 146 int type;
0e1d8f4c 147 int open_flags;
c25f53b0
PB
148 size_t buf_align;
149
244a5668
FZ
150 /* The current permissions. */
151 uint64_t perm;
152 uint64_t shared_perm;
153
2996ffad 154 /* The perms bits whose corresponding bytes are already locked in
f2e3af29 155 * s->fd. */
2996ffad
FZ
156 uint64_t locked_perm;
157 uint64_t locked_shared_perm;
158
dce512de 159#ifdef CONFIG_XFS
260a82e5 160 bool is_xfs:1;
dce512de 161#endif
260a82e5 162 bool has_discard:1;
97a2ae34 163 bool has_write_zeroes:1;
260a82e5 164 bool discard_zeroes:1;
0a4279d9 165 bool use_linux_aio:1;
e5bcf967 166 bool page_cache_inconsistent:1;
d50d8222 167 bool has_fallocate;
3cad8307 168 bool needs_alignment;
31be8a2a 169 bool check_cache_dropped;
7c9e5276
PB
170
171 PRManager *pr_mgr;
19cb3738
FB
172} BDRVRawState;
173
eeb6b45d
JC
174typedef struct BDRVRawReopenState {
175 int fd;
176 int open_flags;
31be8a2a 177 bool check_cache_dropped;
eeb6b45d
JC
178} BDRVRawReopenState;
179
19cb3738 180static int fd_open(BlockDriverState *bs);
22afa7b5 181static int64_t raw_getlength(BlockDriverState *bs);
83f64091 182
de81a169
PB
183typedef struct RawPosixAIOData {
184 BlockDriverState *bs;
d57c44d0 185 int aio_type;
de81a169 186 int aio_fildes;
d57c44d0 187
de81a169 188 off_t aio_offset;
d57c44d0
KW
189 uint64_t aio_nbytes;
190
93f4e2ff 191 union {
d57c44d0
KW
192 struct {
193 struct iovec *iov;
194 int niov;
195 } io;
196 struct {
197 uint64_t cmd;
198 void *buf;
199 } ioctl;
93f4e2ff
KW
200 struct {
201 int aio_fd2;
202 off_t aio_offset2;
d57c44d0 203 } copy_range;
93f4e2ff
KW
204 struct {
205 PreallocMode prealloc;
206 Error **errp;
d57c44d0 207 } truncate;
93f4e2ff 208 };
de81a169
PB
209} RawPosixAIOData;
210
a167ba50 211#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
f3a5d3f8 212static int cdrom_reopen(BlockDriverState *bs);
9f23011a
BS
213#endif
214
1de1ae0a 215#if defined(__NetBSD__)
db0754df 216static int raw_normalize_devicepath(const char **filename, Error **errp)
1de1ae0a
CE
217{
218 static char namebuf[PATH_MAX];
219 const char *dp, *fname;
220 struct stat sb;
221
222 fname = *filename;
223 dp = strrchr(fname, '/');
224 if (lstat(fname, &sb) < 0) {
db0754df 225 error_setg_errno(errp, errno, "%s: stat failed", fname);
1de1ae0a
CE
226 return -errno;
227 }
228
229 if (!S_ISBLK(sb.st_mode)) {
230 return 0;
231 }
232
233 if (dp == NULL) {
234 snprintf(namebuf, PATH_MAX, "r%s", fname);
235 } else {
236 snprintf(namebuf, PATH_MAX, "%.*s/r%s",
237 (int)(dp - fname), fname, dp + 1);
238 }
1de1ae0a 239 *filename = namebuf;
db0754df 240 warn_report("%s is a block device, using %s", fname, *filename);
1de1ae0a
CE
241
242 return 0;
243}
244#else
db0754df 245static int raw_normalize_devicepath(const char **filename, Error **errp)
1de1ae0a
CE
246{
247 return 0;
248}
249#endif
250
8a4ed0d1
ET
251/*
252 * Get logical block size via ioctl. On success store it in @sector_size_p.
253 */
254static int probe_logical_blocksize(int fd, unsigned int *sector_size_p)
c25f53b0 255{
c25f53b0 256 unsigned int sector_size;
8a4ed0d1 257 bool success = false;
700f9ce0 258 int i;
c25f53b0 259
8a4ed0d1 260 errno = ENOTSUP;
700f9ce0 261 static const unsigned long ioctl_list[] = {
c25f53b0 262#ifdef BLKSSZGET
700f9ce0 263 BLKSSZGET,
c25f53b0
PB
264#endif
265#ifdef DKIOCGETBLOCKSIZE
700f9ce0 266 DKIOCGETBLOCKSIZE,
c25f53b0
PB
267#endif
268#ifdef DIOCGSECTORSIZE
700f9ce0 269 DIOCGSECTORSIZE,
c25f53b0 270#endif
700f9ce0
PM
271 };
272
273 /* Try a few ioctls to get the right size */
274 for (i = 0; i < (int)ARRAY_SIZE(ioctl_list); i++) {
275 if (ioctl(fd, ioctl_list[i], &sector_size) >= 0) {
276 *sector_size_p = sector_size;
277 success = true;
278 }
279 }
8a4ed0d1
ET
280
281 return success ? 0 : -errno;
282}
283
1a9335e4
ET
284/**
285 * Get physical block size of @fd.
286 * On success, store it in @blk_size and return 0.
287 * On failure, return -errno.
288 */
289static int probe_physical_blocksize(int fd, unsigned int *blk_size)
290{
291#ifdef BLKPBSZGET
292 if (ioctl(fd, BLKPBSZGET, blk_size) < 0) {
293 return -errno;
294 }
295 return 0;
296#else
297 return -ENOTSUP;
298#endif
299}
300
22d182e8
SH
301/* Check if read is allowed with given memory buffer and length.
302 *
303 * This function is used to check O_DIRECT memory buffer and request alignment.
304 */
305static bool raw_is_io_aligned(int fd, void *buf, size_t len)
306{
307 ssize_t ret = pread(fd, buf, len, 0);
308
309 if (ret >= 0) {
310 return true;
311 }
312
313#ifdef __linux__
314 /* The Linux kernel returns EINVAL for misaligned O_DIRECT reads. Ignore
315 * other errors (e.g. real I/O error), which could happen on a failed
316 * drive, since we only care about probing alignment.
317 */
318 if (errno != EINVAL) {
319 return true;
320 }
321#endif
322
323 return false;
324}
325
8a4ed0d1
ET
326static void raw_probe_alignment(BlockDriverState *bs, int fd, Error **errp)
327{
328 BDRVRawState *s = bs->opaque;
329 char *buf;
459b4e66 330 size_t max_align = MAX(MAX_BLOCKSIZE, getpagesize());
8a4ed0d1 331
b192af8a 332 /* For SCSI generic devices the alignment is not really used.
8a4ed0d1 333 With buffered I/O, we don't have any restrictions. */
b192af8a 334 if (bdrv_is_sg(bs) || !s->needs_alignment) {
a5b8dd2c 335 bs->bl.request_alignment = 1;
8a4ed0d1
ET
336 s->buf_align = 1;
337 return;
338 }
339
a5b8dd2c 340 bs->bl.request_alignment = 0;
8a4ed0d1
ET
341 s->buf_align = 0;
342 /* Let's try to use the logical blocksize for the alignment. */
a5b8dd2c
EB
343 if (probe_logical_blocksize(fd, &bs->bl.request_alignment) < 0) {
344 bs->bl.request_alignment = 0;
8a4ed0d1 345 }
c25f53b0
PB
346#ifdef CONFIG_XFS
347 if (s->is_xfs) {
348 struct dioattr da;
df26a350 349 if (xfsctl(NULL, fd, XFS_IOC_DIOINFO, &da) >= 0) {
a5b8dd2c 350 bs->bl.request_alignment = da.d_miniosz;
c25f53b0
PB
351 /* The kernel returns wrong information for d_mem */
352 /* s->buf_align = da.d_mem; */
353 }
354 }
355#endif
356
357 /* If we could not get the sizes so far, we can only guess them */
358 if (!s->buf_align) {
359 size_t align;
459b4e66
DL
360 buf = qemu_memalign(max_align, 2 * max_align);
361 for (align = 512; align <= max_align; align <<= 1) {
362 if (raw_is_io_aligned(fd, buf + align, max_align)) {
c25f53b0
PB
363 s->buf_align = align;
364 break;
365 }
366 }
367 qemu_vfree(buf);
368 }
369
a5b8dd2c 370 if (!bs->bl.request_alignment) {
c25f53b0 371 size_t align;
459b4e66
DL
372 buf = qemu_memalign(s->buf_align, max_align);
373 for (align = 512; align <= max_align; align <<= 1) {
22d182e8 374 if (raw_is_io_aligned(fd, buf, align)) {
a5b8dd2c 375 bs->bl.request_alignment = align;
c25f53b0
PB
376 break;
377 }
378 }
379 qemu_vfree(buf);
380 }
df26a350 381
a5b8dd2c 382 if (!s->buf_align || !bs->bl.request_alignment) {
8cc9c6e9
EB
383 error_setg(errp, "Could not find working O_DIRECT alignment");
384 error_append_hint(errp, "Try cache.direct=off\n");
df26a350 385 }
c25f53b0
PB
386}
387
6a8dc042
JC
388static void raw_parse_flags(int bdrv_flags, int *open_flags)
389{
390 assert(open_flags != NULL);
391
392 *open_flags |= O_BINARY;
393 *open_flags &= ~O_ACCMODE;
394 if (bdrv_flags & BDRV_O_RDWR) {
395 *open_flags |= O_RDWR;
396 } else {
397 *open_flags |= O_RDONLY;
398 }
399
400 /* Use O_DSYNC for write-through caching, no flags for write-back caching,
401 * and O_DIRECT for no caching. */
402 if ((bdrv_flags & BDRV_O_NOCACHE)) {
403 *open_flags |= O_DIRECT;
404 }
6a8dc042
JC
405}
406
078896a9
HR
407static void raw_parse_filename(const char *filename, QDict *options,
408 Error **errp)
409{
03c320d8 410 bdrv_parse_filename_strip_prefix(filename, "file:", options);
078896a9
HR
411}
412
c66a6157
KW
413static QemuOptsList raw_runtime_opts = {
414 .name = "raw",
415 .head = QTAILQ_HEAD_INITIALIZER(raw_runtime_opts.head),
416 .desc = {
417 {
418 .name = "filename",
419 .type = QEMU_OPT_STRING,
420 .help = "File name of the image",
421 },
0a4279d9
KW
422 {
423 .name = "aio",
424 .type = QEMU_OPT_STRING,
425 .help = "host AIO implementation (threads, native)",
426 },
16b48d5d
FZ
427 {
428 .name = "locking",
429 .type = QEMU_OPT_STRING,
430 .help = "file locking mode (on/off/auto, default: auto)",
431 },
7c9e5276
PB
432 {
433 .name = "pr-manager",
434 .type = QEMU_OPT_STRING,
435 .help = "id of persistent reservation manager object (default: none)",
436 },
31be8a2a
SH
437 {
438 .name = "x-check-cache-dropped",
439 .type = QEMU_OPT_BOOL,
440 .help = "check that page cache was dropped on live migration (default: off)"
441 },
c66a6157
KW
442 { /* end of list */ }
443 },
444};
445
446static int raw_open_common(BlockDriverState *bs, QDict *options,
230ff739
JS
447 int bdrv_flags, int open_flags,
448 bool device, Error **errp)
83f64091
FB
449{
450 BDRVRawState *s = bs->opaque;
c66a6157
KW
451 QemuOpts *opts;
452 Error *local_err = NULL;
8bfea15d 453 const char *filename = NULL;
7c9e5276 454 const char *str;
0a4279d9 455 BlockdevAioOptions aio, aio_default;
0e1d8f4c 456 int fd, ret;
260a82e5 457 struct stat st;
244a5668 458 OnOffAuto locking;
83f64091 459
87ea75d5 460 opts = qemu_opts_create(&raw_runtime_opts, NULL, 0, &error_abort);
c66a6157 461 qemu_opts_absorb_qdict(opts, options, &local_err);
84d18f06 462 if (local_err) {
e428e439 463 error_propagate(errp, local_err);
c66a6157
KW
464 ret = -EINVAL;
465 goto fail;
466 }
467
468 filename = qemu_opt_get(opts, "filename");
469
db0754df 470 ret = raw_normalize_devicepath(&filename, errp);
1de1ae0a 471 if (ret != 0) {
c66a6157 472 goto fail;
1de1ae0a
CE
473 }
474
0a4279d9
KW
475 aio_default = (bdrv_flags & BDRV_O_NATIVE_AIO)
476 ? BLOCKDEV_AIO_OPTIONS_NATIVE
477 : BLOCKDEV_AIO_OPTIONS_THREADS;
f7abe0ec
MAL
478 aio = qapi_enum_parse(&BlockdevAioOptions_lookup,
479 qemu_opt_get(opts, "aio"),
06c60b6c 480 aio_default, &local_err);
0a4279d9
KW
481 if (local_err) {
482 error_propagate(errp, local_err);
483 ret = -EINVAL;
484 goto fail;
485 }
486 s->use_linux_aio = (aio == BLOCKDEV_AIO_OPTIONS_NATIVE);
487
f7abe0ec
MAL
488 locking = qapi_enum_parse(&OnOffAuto_lookup,
489 qemu_opt_get(opts, "locking"),
06c60b6c 490 ON_OFF_AUTO_AUTO, &local_err);
244a5668
FZ
491 if (local_err) {
492 error_propagate(errp, local_err);
493 ret = -EINVAL;
494 goto fail;
495 }
496 switch (locking) {
497 case ON_OFF_AUTO_ON:
498 s->use_lock = true;
2b218f5d 499 if (!qemu_has_ofd_lock()) {
db0754df
FZ
500 warn_report("File lock requested but OFD locking syscall is "
501 "unavailable, falling back to POSIX file locks");
502 error_printf("Due to the implementation, locks can be lost "
503 "unexpectedly.\n");
2b218f5d 504 }
244a5668
FZ
505 break;
506 case ON_OFF_AUTO_OFF:
507 s->use_lock = false;
508 break;
509 case ON_OFF_AUTO_AUTO:
2b218f5d 510 s->use_lock = qemu_has_ofd_lock();
244a5668
FZ
511 break;
512 default:
513 abort();
514 }
515
7c9e5276
PB
516 str = qemu_opt_get(opts, "pr-manager");
517 if (str) {
518 s->pr_mgr = pr_manager_lookup(str, &local_err);
519 if (local_err) {
520 error_propagate(errp, local_err);
521 ret = -EINVAL;
522 goto fail;
523 }
524 }
525
31be8a2a
SH
526 s->check_cache_dropped = qemu_opt_get_bool(opts, "x-check-cache-dropped",
527 false);
528
6a8dc042
JC
529 s->open_flags = open_flags;
530 raw_parse_flags(bdrv_flags, &s->open_flags);
83f64091 531
90babde0 532 s->fd = -1;
40ff6d7e 533 fd = qemu_open(filename, s->open_flags, 0644);
64107dc0
KW
534 ret = fd < 0 ? -errno : 0;
535
536 if (ret == -EACCES || ret == -EROFS) {
537 /* Try to degrade to read-only, but if it doesn't work, still use the
538 * normal error message. */
539 if (bdrv_apply_auto_read_only(bs, NULL, NULL) == 0) {
540 bdrv_flags &= ~BDRV_O_RDWR;
541 raw_parse_flags(bdrv_flags, &s->open_flags);
542 assert(!(s->open_flags & O_CREAT));
543 fd = qemu_open(filename, s->open_flags);
544 ret = fd < 0 ? -errno : 0;
545 }
546 }
547
548 if (ret < 0) {
549 error_setg_errno(errp, -ret, "Could not open '%s'", filename);
c66a6157 550 if (ret == -EROFS) {
19cb3738 551 ret = -EACCES;
c66a6157
KW
552 }
553 goto fail;
19cb3738 554 }
83f64091 555 s->fd = fd;
9ef91a67 556
244a5668
FZ
557 s->perm = 0;
558 s->shared_perm = BLK_PERM_ALL;
559
5c6c3a6c 560#ifdef CONFIG_LINUX_AIO
0a4279d9 561 /* Currently Linux does AIO only for files opened with O_DIRECT */
ed6e2161
NA
562 if (s->use_linux_aio) {
563 if (!(s->open_flags & O_DIRECT)) {
564 error_setg(errp, "aio=native was specified, but it requires "
565 "cache.direct=on, which was not specified.");
566 ret = -EINVAL;
567 goto fail;
568 }
569 if (!aio_setup_linux_aio(bdrv_get_aio_context(bs), errp)) {
570 error_prepend(errp, "Unable to use native AIO: ");
571 goto fail;
572 }
96518254 573 }
1501ecc1 574#else
0a4279d9 575 if (s->use_linux_aio) {
d657c0c2
KW
576 error_setg(errp, "aio=native was specified, but is not supported "
577 "in this build.");
578 ret = -EINVAL;
579 goto fail;
1501ecc1
SH
580 }
581#endif /* !defined(CONFIG_LINUX_AIO) */
9ef91a67 582
7ce21016 583 s->has_discard = true;
97a2ae34 584 s->has_write_zeroes = true;
3cad8307
RPM
585 if ((bs->open_flags & BDRV_O_NOCACHE) != 0) {
586 s->needs_alignment = true;
587 }
260a82e5
PB
588
589 if (fstat(s->fd, &st) < 0) {
01212d4e 590 ret = -errno;
260a82e5
PB
591 error_setg_errno(errp, errno, "Could not stat file");
592 goto fail;
593 }
230ff739
JS
594
595 if (!device) {
596 if (S_ISBLK(st.st_mode)) {
597 warn_report("Opening a block device as a file using the '%s' "
598 "driver is deprecated", bs->drv->format_name);
599 } else if (S_ISCHR(st.st_mode)) {
600 warn_report("Opening a character device as a file using the '%s' "
601 "driver is deprecated", bs->drv->format_name);
602 } else if (!S_ISREG(st.st_mode)) {
603 error_setg(errp, "A regular file was expected by the '%s' driver, "
604 "but something else was given", bs->drv->format_name);
605 ret = -EINVAL;
606 goto fail;
607 } else {
608 s->discard_zeroes = true;
609 s->has_fallocate = true;
610 }
611 } else {
612 if (!(S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode))) {
613 error_setg(errp, "'%s' driver expects either "
614 "a character or block device", bs->drv->format_name);
615 ret = -EINVAL;
616 goto fail;
617 }
260a82e5 618 }
230ff739 619
d0b4503e
PB
620 if (S_ISBLK(st.st_mode)) {
621#ifdef BLKDISCARDZEROES
622 unsigned int arg;
623 if (ioctl(s->fd, BLKDISCARDZEROES, &arg) == 0 && arg) {
624 s->discard_zeroes = true;
625 }
626#endif
627#ifdef __linux__
628 /* On Linux 3.10, BLKDISCARD leaves stale data in the page cache. Do
629 * not rely on the contents of discarded blocks unless using O_DIRECT.
97a2ae34 630 * Same for BLKZEROOUT.
d0b4503e
PB
631 */
632 if (!(bs->open_flags & BDRV_O_NOCACHE)) {
633 s->discard_zeroes = false;
97a2ae34 634 s->has_write_zeroes = false;
d0b4503e
PB
635 }
636#endif
637 }
3cad8307
RPM
638#ifdef __FreeBSD__
639 if (S_ISCHR(st.st_mode)) {
640 /*
641 * The file is a char device (disk), which on FreeBSD isn't behind
642 * a pager, so force all requests to be aligned. This is needed
643 * so QEMU makes sure all IO operations on the device are aligned
644 * to sector size, or else FreeBSD will reject them with EINVAL.
645 */
646 s->needs_alignment = true;
647 }
648#endif
260a82e5 649
dce512de
CH
650#ifdef CONFIG_XFS
651 if (platform_test_xfs_fd(s->fd)) {
7ce21016 652 s->is_xfs = true;
dce512de
CH
653 }
654#endif
655
34fa110e 656 bs->supported_zero_flags = BDRV_REQ_MAY_UNMAP;
c66a6157
KW
657 ret = 0;
658fail:
8bfea15d
KW
659 if (filename && (bdrv_flags & BDRV_O_TEMPORARY)) {
660 unlink(filename);
661 }
c66a6157
KW
662 qemu_opts_del(opts);
663 return ret;
83f64091
FB
664}
665
015a1036
HR
666static int raw_open(BlockDriverState *bs, QDict *options, int flags,
667 Error **errp)
90babde0
CH
668{
669 BDRVRawState *s = bs->opaque;
670
671 s->type = FTYPE_FILE;
230ff739 672 return raw_open_common(bs, options, flags, 0, false, errp);
90babde0
CH
673}
674
244a5668
FZ
675typedef enum {
676 RAW_PL_PREPARE,
677 RAW_PL_COMMIT,
678 RAW_PL_ABORT,
679} RawPermLockOp;
680
681#define PERM_FOREACH(i) \
682 for ((i) = 0; (1ULL << (i)) <= BLK_PERM_ALL; i++)
683
684/* Lock bytes indicated by @perm_lock_bits and @shared_perm_lock_bits in the
685 * file; if @unlock == true, also unlock the unneeded bytes.
686 * @shared_perm_lock_bits is the mask of all permissions that are NOT shared.
687 */
2996ffad 688static int raw_apply_lock_bytes(BDRVRawState *s, int fd,
244a5668
FZ
689 uint64_t perm_lock_bits,
690 uint64_t shared_perm_lock_bits,
691 bool unlock, Error **errp)
692{
693 int ret;
694 int i;
2996ffad
FZ
695 uint64_t locked_perm, locked_shared_perm;
696
697 if (s) {
698 locked_perm = s->locked_perm;
699 locked_shared_perm = s->locked_shared_perm;
700 } else {
701 /*
702 * We don't have the previous bits, just lock/unlock for each of the
703 * requested bits.
704 */
705 if (unlock) {
706 locked_perm = BLK_PERM_ALL;
707 locked_shared_perm = BLK_PERM_ALL;
708 } else {
709 locked_perm = 0;
710 locked_shared_perm = 0;
711 }
712 }
244a5668
FZ
713
714 PERM_FOREACH(i) {
715 int off = RAW_LOCK_PERM_BASE + i;
2996ffad
FZ
716 uint64_t bit = (1ULL << i);
717 if ((perm_lock_bits & bit) && !(locked_perm & bit)) {
d0a96155 718 ret = qemu_lock_fd(fd, off, 1, false);
244a5668
FZ
719 if (ret) {
720 error_setg(errp, "Failed to lock byte %d", off);
721 return ret;
2996ffad
FZ
722 } else if (s) {
723 s->locked_perm |= bit;
244a5668 724 }
2996ffad 725 } else if (unlock && (locked_perm & bit) && !(perm_lock_bits & bit)) {
d0a96155 726 ret = qemu_unlock_fd(fd, off, 1);
244a5668
FZ
727 if (ret) {
728 error_setg(errp, "Failed to unlock byte %d", off);
729 return ret;
2996ffad
FZ
730 } else if (s) {
731 s->locked_perm &= ~bit;
244a5668
FZ
732 }
733 }
734 }
735 PERM_FOREACH(i) {
736 int off = RAW_LOCK_SHARED_BASE + i;
2996ffad
FZ
737 uint64_t bit = (1ULL << i);
738 if ((shared_perm_lock_bits & bit) && !(locked_shared_perm & bit)) {
d0a96155 739 ret = qemu_lock_fd(fd, off, 1, false);
244a5668
FZ
740 if (ret) {
741 error_setg(errp, "Failed to lock byte %d", off);
742 return ret;
2996ffad
FZ
743 } else if (s) {
744 s->locked_shared_perm |= bit;
244a5668 745 }
2996ffad
FZ
746 } else if (unlock && (locked_shared_perm & bit) &&
747 !(shared_perm_lock_bits & bit)) {
d0a96155 748 ret = qemu_unlock_fd(fd, off, 1);
244a5668
FZ
749 if (ret) {
750 error_setg(errp, "Failed to unlock byte %d", off);
751 return ret;
2996ffad
FZ
752 } else if (s) {
753 s->locked_shared_perm &= ~bit;
244a5668
FZ
754 }
755 }
756 }
757 return 0;
758}
759
760/* Check "unshared" bytes implied by @perm and ~@shared_perm in the file. */
d0a96155 761static int raw_check_lock_bytes(int fd, uint64_t perm, uint64_t shared_perm,
244a5668
FZ
762 Error **errp)
763{
764 int ret;
765 int i;
766
767 PERM_FOREACH(i) {
768 int off = RAW_LOCK_SHARED_BASE + i;
769 uint64_t p = 1ULL << i;
770 if (perm & p) {
d0a96155 771 ret = qemu_lock_fd_test(fd, off, 1, true);
244a5668
FZ
772 if (ret) {
773 char *perm_name = bdrv_perm_names(p);
774 error_setg(errp,
775 "Failed to get \"%s\" lock",
776 perm_name);
777 g_free(perm_name);
244a5668
FZ
778 return ret;
779 }
780 }
781 }
782 PERM_FOREACH(i) {
783 int off = RAW_LOCK_PERM_BASE + i;
784 uint64_t p = 1ULL << i;
785 if (!(shared_perm & p)) {
d0a96155 786 ret = qemu_lock_fd_test(fd, off, 1, true);
244a5668
FZ
787 if (ret) {
788 char *perm_name = bdrv_perm_names(p);
789 error_setg(errp,
790 "Failed to get shared \"%s\" lock",
791 perm_name);
792 g_free(perm_name);
244a5668
FZ
793 return ret;
794 }
795 }
796 }
797 return 0;
798}
799
800static int raw_handle_perm_lock(BlockDriverState *bs,
801 RawPermLockOp op,
802 uint64_t new_perm, uint64_t new_shared,
803 Error **errp)
804{
805 BDRVRawState *s = bs->opaque;
806 int ret = 0;
807 Error *local_err = NULL;
808
809 if (!s->use_lock) {
810 return 0;
811 }
812
813 if (bdrv_get_flags(bs) & BDRV_O_INACTIVE) {
814 return 0;
815 }
816
244a5668
FZ
817 switch (op) {
818 case RAW_PL_PREPARE:
f2e3af29 819 ret = raw_apply_lock_bytes(s, s->fd, s->perm | new_perm,
244a5668
FZ
820 ~s->shared_perm | ~new_shared,
821 false, errp);
822 if (!ret) {
f2e3af29 823 ret = raw_check_lock_bytes(s->fd, new_perm, new_shared, errp);
244a5668
FZ
824 if (!ret) {
825 return 0;
826 }
b857431d
FZ
827 error_append_hint(errp,
828 "Is another process using the image [%s]?\n",
829 bs->filename);
244a5668
FZ
830 }
831 op = RAW_PL_ABORT;
832 /* fall through to unlock bytes. */
833 case RAW_PL_ABORT:
f2e3af29 834 raw_apply_lock_bytes(s, s->fd, s->perm, ~s->shared_perm,
d0a96155 835 true, &local_err);
244a5668
FZ
836 if (local_err) {
837 /* Theoretically the above call only unlocks bytes and it cannot
838 * fail. Something weird happened, report it.
839 */
db0754df 840 warn_report_err(local_err);
244a5668
FZ
841 }
842 break;
843 case RAW_PL_COMMIT:
f2e3af29 844 raw_apply_lock_bytes(s, s->fd, new_perm, ~new_shared,
d0a96155 845 true, &local_err);
244a5668
FZ
846 if (local_err) {
847 /* Theoretically the above call only unlocks bytes and it cannot
848 * fail. Something weird happened, report it.
849 */
db0754df 850 warn_report_err(local_err);
244a5668
FZ
851 }
852 break;
853 }
854 return ret;
855}
856
eeb6b45d
JC
857static int raw_reopen_prepare(BDRVReopenState *state,
858 BlockReopenQueue *queue, Error **errp)
859{
860 BDRVRawState *s;
4e6d13c9 861 BDRVRawReopenState *rs;
31be8a2a 862 QemuOpts *opts;
eeb6b45d 863 int ret = 0;
df26a350 864 Error *local_err = NULL;
eeb6b45d
JC
865
866 assert(state != NULL);
867 assert(state->bs != NULL);
868
869 s = state->bs->opaque;
870
5839e53b 871 state->opaque = g_new0(BDRVRawReopenState, 1);
4e6d13c9 872 rs = state->opaque;
31be8a2a
SH
873 rs->fd = -1;
874
875 /* Handle options changes */
876 opts = qemu_opts_create(&raw_runtime_opts, NULL, 0, &error_abort);
877 qemu_opts_absorb_qdict(opts, state->options, &local_err);
878 if (local_err) {
879 error_propagate(errp, local_err);
880 ret = -EINVAL;
881 goto out;
882 }
883
8d324575
AG
884 rs->check_cache_dropped =
885 qemu_opt_get_bool_del(opts, "x-check-cache-dropped", false);
886
887 /* This driver's reopen function doesn't currently allow changing
888 * other options, so let's put them back in the original QDict and
889 * bdrv_reopen_prepare() will detect changes and complain. */
890 qemu_opts_to_qdict(opts, state->options);
eeb6b45d 891
f709623b 892 if (s->type == FTYPE_CD) {
4e6d13c9 893 rs->open_flags |= O_NONBLOCK;
1bc6b705
JC
894 }
895
4e6d13c9 896 raw_parse_flags(state->flags, &rs->open_flags);
eeb6b45d 897
fdf263f6 898 int fcntl_flags = O_APPEND | O_NONBLOCK;
eeb6b45d
JC
899#ifdef O_NOATIME
900 fcntl_flags |= O_NOATIME;
901#endif
902
fdf263f6
AF
903#ifdef O_ASYNC
904 /* Not all operating systems have O_ASYNC, and those that don't
4e6d13c9 905 * will not let us track the state into rs->open_flags (typically
fdf263f6
AF
906 * you achieve the same effect with an ioctl, for example I_SETSIG
907 * on Solaris). But we do not use O_ASYNC, so that's fine.
908 */
909 assert((s->open_flags & O_ASYNC) == 0);
910#endif
911
4e6d13c9 912 if ((rs->open_flags & ~fcntl_flags) == (s->open_flags & ~fcntl_flags)) {
eeb6b45d 913 /* dup the original fd */
4e6d13c9
FZ
914 rs->fd = qemu_dup(s->fd);
915 if (rs->fd >= 0) {
916 ret = fcntl_setfl(rs->fd, rs->open_flags);
eeb6b45d 917 if (ret) {
4e6d13c9
FZ
918 qemu_close(rs->fd);
919 rs->fd = -1;
eeb6b45d
JC
920 }
921 }
922 }
923
924 /* If we cannot use fcntl, or fcntl failed, fall back to qemu_open() */
4e6d13c9 925 if (rs->fd == -1) {
bdd03cdf 926 const char *normalized_filename = state->bs->filename;
db0754df
FZ
927 ret = raw_normalize_devicepath(&normalized_filename, errp);
928 if (ret >= 0) {
4e6d13c9
FZ
929 assert(!(rs->open_flags & O_CREAT));
930 rs->fd = qemu_open(normalized_filename, rs->open_flags);
931 if (rs->fd == -1) {
bdd03cdf
HR
932 error_setg_errno(errp, errno, "Could not reopen file");
933 ret = -1;
934 }
eeb6b45d
JC
935 }
936 }
df26a350
KW
937
938 /* Fail already reopen_prepare() if we can't get a working O_DIRECT
939 * alignment with the new fd. */
4e6d13c9
FZ
940 if (rs->fd != -1) {
941 raw_probe_alignment(state->bs, rs->fd, &local_err);
df26a350 942 if (local_err) {
4e6d13c9
FZ
943 qemu_close(rs->fd);
944 rs->fd = -1;
df26a350
KW
945 error_propagate(errp, local_err);
946 ret = -EINVAL;
947 }
948 }
949
31be8a2a
SH
950out:
951 qemu_opts_del(opts);
eeb6b45d
JC
952 return ret;
953}
954
eeb6b45d
JC
955static void raw_reopen_commit(BDRVReopenState *state)
956{
4e6d13c9 957 BDRVRawReopenState *rs = state->opaque;
eeb6b45d 958 BDRVRawState *s = state->bs->opaque;
f2e3af29 959 Error *local_err = NULL;
eeb6b45d 960
31be8a2a 961 s->check_cache_dropped = rs->check_cache_dropped;
4e6d13c9 962 s->open_flags = rs->open_flags;
eeb6b45d 963
f2e3af29
FZ
964 /* Copy locks to the new fd before closing the old one. */
965 raw_apply_lock_bytes(NULL, rs->fd, s->locked_perm,
577a1339 966 s->locked_shared_perm, false, &local_err);
f2e3af29
FZ
967 if (local_err) {
968 /* shouldn't fail in a sane host, but report it just in case. */
969 error_report_err(local_err);
970 }
eeb6b45d 971 qemu_close(s->fd);
4e6d13c9 972 s->fd = rs->fd;
eeb6b45d
JC
973
974 g_free(state->opaque);
975 state->opaque = NULL;
976}
977
978
979static void raw_reopen_abort(BDRVReopenState *state)
980{
4e6d13c9 981 BDRVRawReopenState *rs = state->opaque;
eeb6b45d
JC
982
983 /* nothing to do if NULL, we didn't get far enough */
4e6d13c9 984 if (rs == NULL) {
eeb6b45d
JC
985 return;
986 }
987
4e6d13c9
FZ
988 if (rs->fd >= 0) {
989 qemu_close(rs->fd);
990 rs->fd = -1;
eeb6b45d
JC
991 }
992 g_free(state->opaque);
993 state->opaque = NULL;
994}
995
48265250 996static int hdev_get_max_transfer_length(BlockDriverState *bs, int fd)
6f607174
FZ
997{
998#ifdef BLKSECTGET
48265250
EF
999 int max_bytes = 0;
1000 short max_sectors = 0;
1001 if (bs->sg && ioctl(fd, BLKSECTGET, &max_bytes) == 0) {
1002 return max_bytes;
1003 } else if (!bs->sg && ioctl(fd, BLKSECTGET, &max_sectors) == 0) {
1004 return max_sectors << BDRV_SECTOR_BITS;
6f607174
FZ
1005 } else {
1006 return -errno;
1007 }
1008#else
1009 return -ENOSYS;
1010#endif
1011}
1012
9103f1ce
FZ
1013static int hdev_get_max_segments(const struct stat *st)
1014{
1015#ifdef CONFIG_LINUX
1016 char buf[32];
1017 const char *end;
1018 char *sysfspath;
1019 int ret;
1020 int fd = -1;
1021 long max_segments;
1022
1023 sysfspath = g_strdup_printf("/sys/dev/block/%u:%u/queue/max_segments",
1024 major(st->st_rdev), minor(st->st_rdev));
1025 fd = open(sysfspath, O_RDONLY);
1026 if (fd == -1) {
1027 ret = -errno;
1028 goto out;
1029 }
1030 do {
69583490 1031 ret = read(fd, buf, sizeof(buf) - 1);
9103f1ce
FZ
1032 } while (ret == -1 && errno == EINTR);
1033 if (ret < 0) {
1034 ret = -errno;
1035 goto out;
1036 } else if (ret == 0) {
1037 ret = -EIO;
1038 goto out;
1039 }
1040 buf[ret] = 0;
1041 /* The file is ended with '\n', pass 'end' to accept that. */
1042 ret = qemu_strtol(buf, &end, 10, &max_segments);
1043 if (ret == 0 && end && *end == '\n') {
1044 ret = max_segments;
1045 }
1046
1047out:
fed414df
FZ
1048 if (fd != -1) {
1049 close(fd);
1050 }
9103f1ce
FZ
1051 g_free(sysfspath);
1052 return ret;
1053#else
1054 return -ENOTSUP;
1055#endif
1056}
1057
3baca891 1058static void raw_refresh_limits(BlockDriverState *bs, Error **errp)
c25f53b0
PB
1059{
1060 BDRVRawState *s = bs->opaque;
6f607174
FZ
1061 struct stat st;
1062
1063 if (!fstat(s->fd, &st)) {
c4c41a0a 1064 if (S_ISBLK(st.st_mode) || S_ISCHR(st.st_mode)) {
48265250
EF
1065 int ret = hdev_get_max_transfer_length(bs, s->fd);
1066 if (ret > 0 && ret <= BDRV_REQUEST_MAX_BYTES) {
1067 bs->bl.max_transfer = pow2floor(ret);
6f607174 1068 }
9103f1ce
FZ
1069 ret = hdev_get_max_segments(&st);
1070 if (ret > 0) {
1071 bs->bl.max_transfer = MIN(bs->bl.max_transfer,
1072 ret * getpagesize());
1073 }
6f607174
FZ
1074 }
1075 }
eeb6b45d 1076
df26a350 1077 raw_probe_alignment(bs, s->fd, errp);
4196d2f0 1078 bs->bl.min_mem_alignment = s->buf_align;
459b4e66 1079 bs->bl.opt_mem_alignment = MAX(s->buf_align, getpagesize());
c25f53b0 1080}
83f64091 1081
1a9335e4
ET
1082static int check_for_dasd(int fd)
1083{
1084#ifdef BIODASDINFO2
1085 struct dasd_information2_t info = {0};
1086
1087 return ioctl(fd, BIODASDINFO2, &info);
1088#else
1089 return -1;
1090#endif
1091}
1092
1093/**
1094 * Try to get @bs's logical and physical block size.
1095 * On success, store them in @bsz and return zero.
1096 * On failure, return negative errno.
1097 */
1098static int hdev_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz)
1099{
1100 BDRVRawState *s = bs->opaque;
1101 int ret;
1102
1103 /* If DASD, get blocksizes */
1104 if (check_for_dasd(s->fd) < 0) {
1105 return -ENOTSUP;
1106 }
1107 ret = probe_logical_blocksize(s->fd, &bsz->log);
1108 if (ret < 0) {
1109 return ret;
1110 }
1111 return probe_physical_blocksize(s->fd, &bsz->phys);
1112}
1113
1114/**
1115 * Try to get @bs's geometry: cyls, heads, sectors.
1116 * On success, store them in @geo and return 0.
1117 * On failure return -errno.
1118 * (Allows block driver to assign default geometry values that guest sees)
1119 */
1120#ifdef __linux__
1121static int hdev_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
1122{
1123 BDRVRawState *s = bs->opaque;
1124 struct hd_geometry ioctl_geo = {0};
1a9335e4
ET
1125
1126 /* If DASD, get its geometry */
1127 if (check_for_dasd(s->fd) < 0) {
1128 return -ENOTSUP;
1129 }
1130 if (ioctl(s->fd, HDIO_GETGEO, &ioctl_geo) < 0) {
1131 return -errno;
1132 }
1133 /* HDIO_GETGEO may return success even though geo contains zeros
1134 (e.g. certain multipath setups) */
1135 if (!ioctl_geo.heads || !ioctl_geo.sectors || !ioctl_geo.cylinders) {
1136 return -ENOTSUP;
1137 }
1138 /* Do not return a geometry for partition */
1139 if (ioctl_geo.start != 0) {
1140 return -ENOTSUP;
1141 }
1142 geo->heads = ioctl_geo.heads;
1143 geo->sectors = ioctl_geo.sectors;
1a9335e4
ET
1144 geo->cylinders = ioctl_geo.cylinders;
1145
1146 return 0;
1147}
1148#else /* __linux__ */
1149static int hdev_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
1150{
1151 return -ENOTSUP;
1152}
1153#endif
1154
de81a169
PB
1155static ssize_t handle_aiocb_ioctl(RawPosixAIOData *aiocb)
1156{
1157 int ret;
1158
d57c44d0 1159 ret = ioctl(aiocb->aio_fildes, aiocb->ioctl.cmd, aiocb->ioctl.buf);
de81a169
PB
1160 if (ret == -1) {
1161 return -errno;
1162 }
1163
b608c8dc 1164 return 0;
de81a169
PB
1165}
1166
06dc9bd5 1167static int handle_aiocb_flush(void *opaque)
de81a169 1168{
06dc9bd5 1169 RawPosixAIOData *aiocb = opaque;
e5bcf967 1170 BDRVRawState *s = aiocb->bs->opaque;
de81a169
PB
1171 int ret;
1172
e5bcf967
KW
1173 if (s->page_cache_inconsistent) {
1174 return -EIO;
1175 }
1176
de81a169
PB
1177 ret = qemu_fdatasync(aiocb->aio_fildes);
1178 if (ret == -1) {
e5bcf967
KW
1179 /* There is no clear definition of the semantics of a failing fsync(),
1180 * so we may have to assume the worst. The sad truth is that this
1181 * assumption is correct for Linux. Some pages are now probably marked
1182 * clean in the page cache even though they are inconsistent with the
1183 * on-disk contents. The next fdatasync() call would succeed, but no
1184 * further writeback attempt will be made. We can't get back to a state
1185 * in which we know what is on disk (we would have to rewrite
1186 * everything that was touched since the last fdatasync() at least), so
1187 * make bdrv_flush() fail permanently. Given that the behaviour isn't
1188 * really defined, I have little hope that other OSes are doing better.
1189 *
1190 * Obviously, this doesn't affect O_DIRECT, which bypasses the page
1191 * cache. */
1192 if ((s->open_flags & O_DIRECT) == 0) {
1193 s->page_cache_inconsistent = true;
1194 }
de81a169
PB
1195 return -errno;
1196 }
1197 return 0;
1198}
1199
1200#ifdef CONFIG_PREADV
1201
1202static bool preadv_present = true;
1203
1204static ssize_t
1205qemu_preadv(int fd, const struct iovec *iov, int nr_iov, off_t offset)
1206{
1207 return preadv(fd, iov, nr_iov, offset);
1208}
1209
1210static ssize_t
1211qemu_pwritev(int fd, const struct iovec *iov, int nr_iov, off_t offset)
1212{
1213 return pwritev(fd, iov, nr_iov, offset);
1214}
1215
1216#else
1217
1218static bool preadv_present = false;
1219
1220static ssize_t
1221qemu_preadv(int fd, const struct iovec *iov, int nr_iov, off_t offset)
1222{
1223 return -ENOSYS;
1224}
1225
1226static ssize_t
1227qemu_pwritev(int fd, const struct iovec *iov, int nr_iov, off_t offset)
1228{
1229 return -ENOSYS;
1230}
1231
1232#endif
1233
1234static ssize_t handle_aiocb_rw_vector(RawPosixAIOData *aiocb)
1235{
1236 ssize_t len;
1237
1238 do {
1239 if (aiocb->aio_type & QEMU_AIO_WRITE)
1240 len = qemu_pwritev(aiocb->aio_fildes,
d57c44d0
KW
1241 aiocb->io.iov,
1242 aiocb->io.niov,
de81a169
PB
1243 aiocb->aio_offset);
1244 else
1245 len = qemu_preadv(aiocb->aio_fildes,
d57c44d0
KW
1246 aiocb->io.iov,
1247 aiocb->io.niov,
de81a169
PB
1248 aiocb->aio_offset);
1249 } while (len == -1 && errno == EINTR);
1250
1251 if (len == -1) {
1252 return -errno;
1253 }
1254 return len;
1255}
1256
1257/*
1258 * Read/writes the data to/from a given linear buffer.
1259 *
1260 * Returns the number of bytes handles or -errno in case of an error. Short
1261 * reads are only returned if the end of the file is reached.
1262 */
1263static ssize_t handle_aiocb_rw_linear(RawPosixAIOData *aiocb, char *buf)
1264{
1265 ssize_t offset = 0;
1266 ssize_t len;
1267
1268 while (offset < aiocb->aio_nbytes) {
1269 if (aiocb->aio_type & QEMU_AIO_WRITE) {
1270 len = pwrite(aiocb->aio_fildes,
1271 (const char *)buf + offset,
1272 aiocb->aio_nbytes - offset,
1273 aiocb->aio_offset + offset);
1274 } else {
1275 len = pread(aiocb->aio_fildes,
1276 buf + offset,
1277 aiocb->aio_nbytes - offset,
1278 aiocb->aio_offset + offset);
1279 }
1280 if (len == -1 && errno == EINTR) {
1281 continue;
61ed73cf
SH
1282 } else if (len == -1 && errno == EINVAL &&
1283 (aiocb->bs->open_flags & BDRV_O_NOCACHE) &&
1284 !(aiocb->aio_type & QEMU_AIO_WRITE) &&
1285 offset > 0) {
1286 /* O_DIRECT pread() may fail with EINVAL when offset is unaligned
1287 * after a short read. Assume that O_DIRECT short reads only occur
1288 * at EOF. Therefore this is a short read, not an I/O error.
1289 */
1290 break;
de81a169
PB
1291 } else if (len == -1) {
1292 offset = -errno;
1293 break;
1294 } else if (len == 0) {
1295 break;
1296 }
1297 offset += len;
1298 }
1299
1300 return offset;
1301}
1302
1303static ssize_t handle_aiocb_rw(RawPosixAIOData *aiocb)
1304{
1305 ssize_t nbytes;
1306 char *buf;
1307
1308 if (!(aiocb->aio_type & QEMU_AIO_MISALIGNED)) {
1309 /*
1310 * If there is just a single buffer, and it is properly aligned
1311 * we can just use plain pread/pwrite without any problems.
1312 */
d57c44d0
KW
1313 if (aiocb->io.niov == 1) {
1314 return handle_aiocb_rw_linear(aiocb, aiocb->io.iov->iov_base);
de81a169
PB
1315 }
1316 /*
1317 * We have more than one iovec, and all are properly aligned.
1318 *
1319 * Try preadv/pwritev first and fall back to linearizing the
1320 * buffer if it's not supported.
1321 */
1322 if (preadv_present) {
1323 nbytes = handle_aiocb_rw_vector(aiocb);
1324 if (nbytes == aiocb->aio_nbytes ||
1325 (nbytes < 0 && nbytes != -ENOSYS)) {
1326 return nbytes;
1327 }
1328 preadv_present = false;
1329 }
1330
1331 /*
1332 * XXX(hch): short read/write. no easy way to handle the reminder
1333 * using these interfaces. For now retry using plain
1334 * pread/pwrite?
1335 */
1336 }
1337
1338 /*
1339 * Ok, we have to do it the hard way, copy all segments into
1340 * a single aligned buffer.
1341 */
50d4a858
KW
1342 buf = qemu_try_blockalign(aiocb->bs, aiocb->aio_nbytes);
1343 if (buf == NULL) {
1344 return -ENOMEM;
1345 }
1346
de81a169
PB
1347 if (aiocb->aio_type & QEMU_AIO_WRITE) {
1348 char *p = buf;
1349 int i;
1350
d57c44d0
KW
1351 for (i = 0; i < aiocb->io.niov; ++i) {
1352 memcpy(p, aiocb->io.iov[i].iov_base, aiocb->io.iov[i].iov_len);
1353 p += aiocb->io.iov[i].iov_len;
de81a169 1354 }
8eb029c2 1355 assert(p - buf == aiocb->aio_nbytes);
de81a169
PB
1356 }
1357
1358 nbytes = handle_aiocb_rw_linear(aiocb, buf);
1359 if (!(aiocb->aio_type & QEMU_AIO_WRITE)) {
1360 char *p = buf;
1361 size_t count = aiocb->aio_nbytes, copy;
1362 int i;
1363
d57c44d0 1364 for (i = 0; i < aiocb->io.niov && count; ++i) {
de81a169 1365 copy = count;
d57c44d0
KW
1366 if (copy > aiocb->io.iov[i].iov_len) {
1367 copy = aiocb->io.iov[i].iov_len;
de81a169 1368 }
d57c44d0 1369 memcpy(aiocb->io.iov[i].iov_base, p, copy);
8eb029c2 1370 assert(count >= copy);
de81a169
PB
1371 p += copy;
1372 count -= copy;
1373 }
8eb029c2 1374 assert(count == 0);
de81a169
PB
1375 }
1376 qemu_vfree(buf);
1377
1378 return nbytes;
1379}
1380
8238010b 1381#ifdef CONFIG_XFS
97a2ae34
PB
1382static int xfs_write_zeroes(BDRVRawState *s, int64_t offset, uint64_t bytes)
1383{
1384 struct xfs_flock64 fl;
bcb22555 1385 int err;
97a2ae34
PB
1386
1387 memset(&fl, 0, sizeof(fl));
1388 fl.l_whence = SEEK_SET;
1389 fl.l_start = offset;
1390 fl.l_len = bytes;
1391
1392 if (xfsctl(NULL, s->fd, XFS_IOC_ZERO_RANGE, &fl) < 0) {
bcb22555
DA
1393 err = errno;
1394 DPRINTF("cannot write zero range (%s)\n", strerror(errno));
1395 return -err;
97a2ae34
PB
1396 }
1397
1398 return 0;
1399}
1400
8238010b
PB
1401static int xfs_discard(BDRVRawState *s, int64_t offset, uint64_t bytes)
1402{
1403 struct xfs_flock64 fl;
bcb22555 1404 int err;
8238010b
PB
1405
1406 memset(&fl, 0, sizeof(fl));
1407 fl.l_whence = SEEK_SET;
1408 fl.l_start = offset;
1409 fl.l_len = bytes;
1410
1411 if (xfsctl(NULL, s->fd, XFS_IOC_UNRESVSP64, &fl) < 0) {
bcb22555
DA
1412 err = errno;
1413 DPRINTF("cannot punch hole (%s)\n", strerror(errno));
1414 return -err;
8238010b
PB
1415 }
1416
1417 return 0;
1418}
1419#endif
1420
1486df0e
DL
1421static int translate_err(int err)
1422{
1423 if (err == -ENODEV || err == -ENOSYS || err == -EOPNOTSUPP ||
1424 err == -ENOTTY) {
1425 err = -ENOTSUP;
1426 }
1427 return err;
1428}
1429
d50d8222 1430#ifdef CONFIG_FALLOCATE
0b991712
DL
1431static int do_fallocate(int fd, int mode, off_t offset, off_t len)
1432{
1433 do {
1434 if (fallocate(fd, mode, offset, len) == 0) {
1435 return 0;
1436 }
1437 } while (errno == EINTR);
1438 return translate_err(-errno);
1439}
1440#endif
1441
37cc9f7f 1442static ssize_t handle_aiocb_write_zeroes_block(RawPosixAIOData *aiocb)
97a2ae34 1443{
37cc9f7f 1444 int ret = -ENOTSUP;
97a2ae34
PB
1445 BDRVRawState *s = aiocb->bs->opaque;
1446
37cc9f7f 1447 if (!s->has_write_zeroes) {
97a2ae34
PB
1448 return -ENOTSUP;
1449 }
1450
97a2ae34 1451#ifdef BLKZEROOUT
37cc9f7f
DL
1452 do {
1453 uint64_t range[2] = { aiocb->aio_offset, aiocb->aio_nbytes };
1454 if (ioctl(aiocb->aio_fildes, BLKZEROOUT, range) == 0) {
1455 return 0;
97a2ae34 1456 }
37cc9f7f
DL
1457 } while (errno == EINTR);
1458
1459 ret = translate_err(-errno);
97a2ae34 1460#endif
97a2ae34 1461
1486df0e 1462 if (ret == -ENOTSUP) {
97a2ae34 1463 s->has_write_zeroes = false;
97a2ae34
PB
1464 }
1465 return ret;
1466}
1467
7154d8ae 1468static int handle_aiocb_write_zeroes(void *opaque)
37cc9f7f 1469{
7154d8ae 1470 RawPosixAIOData *aiocb = opaque;
a6dcf097 1471#if defined(CONFIG_FALLOCATE) || defined(CONFIG_XFS)
37cc9f7f 1472 BDRVRawState *s = aiocb->bs->opaque;
a6dcf097 1473#endif
70d9110b
DL
1474#ifdef CONFIG_FALLOCATE
1475 int64_t len;
1476#endif
37cc9f7f
DL
1477
1478 if (aiocb->aio_type & QEMU_AIO_BLKDEV) {
1479 return handle_aiocb_write_zeroes_block(aiocb);
1480 }
1481
1482#ifdef CONFIG_XFS
1483 if (s->is_xfs) {
1484 return xfs_write_zeroes(s, aiocb->aio_offset, aiocb->aio_nbytes);
1485 }
1486#endif
1487
b953f075
DL
1488#ifdef CONFIG_FALLOCATE_ZERO_RANGE
1489 if (s->has_write_zeroes) {
1490 int ret = do_fallocate(s->fd, FALLOC_FL_ZERO_RANGE,
1491 aiocb->aio_offset, aiocb->aio_nbytes);
1492 if (ret == 0 || ret != -ENOTSUP) {
1493 return ret;
1494 }
1495 s->has_write_zeroes = false;
1496 }
1497#endif
1498
1cdc3239
DL
1499#ifdef CONFIG_FALLOCATE_PUNCH_HOLE
1500 if (s->has_discard && s->has_fallocate) {
1501 int ret = do_fallocate(s->fd,
1502 FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE,
1503 aiocb->aio_offset, aiocb->aio_nbytes);
1504 if (ret == 0) {
1505 ret = do_fallocate(s->fd, 0, aiocb->aio_offset, aiocb->aio_nbytes);
1506 if (ret == 0 || ret != -ENOTSUP) {
1507 return ret;
1508 }
1509 s->has_fallocate = false;
1510 } else if (ret != -ENOTSUP) {
1511 return ret;
1512 } else {
1513 s->has_discard = false;
1514 }
1515 }
1516#endif
1517
d50d8222 1518#ifdef CONFIG_FALLOCATE
70d9110b
DL
1519 /* Last resort: we are trying to extend the file with zeroed data. This
1520 * can be done via fallocate(fd, 0) */
1521 len = bdrv_getlength(aiocb->bs);
1522 if (s->has_fallocate && len >= 0 && aiocb->aio_offset >= len) {
d50d8222
DL
1523 int ret = do_fallocate(s->fd, 0, aiocb->aio_offset, aiocb->aio_nbytes);
1524 if (ret == 0 || ret != -ENOTSUP) {
1525 return ret;
1526 }
1527 s->has_fallocate = false;
1528 }
1529#endif
1530
37cc9f7f
DL
1531 return -ENOTSUP;
1532}
1533
7154d8ae 1534static int handle_aiocb_write_zeroes_unmap(void *opaque)
34fa110e 1535{
7154d8ae 1536 RawPosixAIOData *aiocb = opaque;
34fa110e
KW
1537 BDRVRawState *s G_GNUC_UNUSED = aiocb->bs->opaque;
1538 int ret;
1539
1540 /* First try to write zeros and unmap at the same time */
1541
1542#ifdef CONFIG_FALLOCATE_PUNCH_HOLE
1543 ret = do_fallocate(s->fd, FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE,
1544 aiocb->aio_offset, aiocb->aio_nbytes);
1545 if (ret != -ENOTSUP) {
1546 return ret;
1547 }
1548#endif
1549
1550#ifdef CONFIG_XFS
1551 if (s->is_xfs) {
1552 /* xfs_discard() guarantees that the discarded area reads as all-zero
1553 * afterwards, so we can use it here. */
1554 return xfs_discard(s, aiocb->aio_offset, aiocb->aio_nbytes);
1555 }
1556#endif
1557
1558 /* If we couldn't manage to unmap while guaranteed that the area reads as
1559 * all-zero afterwards, just write zeroes without unmapping */
1560 ret = handle_aiocb_write_zeroes(aiocb);
1561 return ret;
1562}
1563
1efad060
FZ
1564#ifndef HAVE_COPY_FILE_RANGE
1565static off_t copy_file_range(int in_fd, off_t *in_off, int out_fd,
1566 off_t *out_off, size_t len, unsigned int flags)
1567{
1568#ifdef __NR_copy_file_range
1569 return syscall(__NR_copy_file_range, in_fd, in_off, out_fd,
1570 out_off, len, flags);
1571#else
1572 errno = ENOSYS;
1573 return -1;
1574#endif
1575}
1576#endif
1577
58a209c4 1578static int handle_aiocb_copy_range(void *opaque)
1efad060 1579{
58a209c4 1580 RawPosixAIOData *aiocb = opaque;
1efad060
FZ
1581 uint64_t bytes = aiocb->aio_nbytes;
1582 off_t in_off = aiocb->aio_offset;
d57c44d0 1583 off_t out_off = aiocb->copy_range.aio_offset2;
1efad060
FZ
1584
1585 while (bytes) {
1586 ssize_t ret = copy_file_range(aiocb->aio_fildes, &in_off,
d57c44d0 1587 aiocb->copy_range.aio_fd2, &out_off,
1efad060 1588 bytes, 0);
ecc983a5 1589 trace_file_copy_file_range(aiocb->bs, aiocb->aio_fildes, in_off,
d57c44d0
KW
1590 aiocb->copy_range.aio_fd2, out_off, bytes,
1591 0, ret);
c436e3d0
FZ
1592 if (ret == 0) {
1593 /* No progress (e.g. when beyond EOF), let the caller fall back to
1594 * buffer I/O. */
1595 return -ENOSPC;
1efad060
FZ
1596 }
1597 if (ret < 0) {
c436e3d0
FZ
1598 switch (errno) {
1599 case ENOSYS:
1efad060 1600 return -ENOTSUP;
c436e3d0
FZ
1601 case EINTR:
1602 continue;
1603 default:
1efad060
FZ
1604 return -errno;
1605 }
1606 }
1efad060
FZ
1607 bytes -= ret;
1608 }
1609 return 0;
1610}
1611
46ee0f46 1612static int handle_aiocb_discard(void *opaque)
8238010b 1613{
46ee0f46 1614 RawPosixAIOData *aiocb = opaque;
8238010b
PB
1615 int ret = -EOPNOTSUPP;
1616 BDRVRawState *s = aiocb->bs->opaque;
1617
7ce21016
PB
1618 if (!s->has_discard) {
1619 return -ENOTSUP;
8238010b
PB
1620 }
1621
1622 if (aiocb->aio_type & QEMU_AIO_BLKDEV) {
1623#ifdef BLKDISCARD
1624 do {
1625 uint64_t range[2] = { aiocb->aio_offset, aiocb->aio_nbytes };
1626 if (ioctl(aiocb->aio_fildes, BLKDISCARD, range) == 0) {
1627 return 0;
1628 }
1629 } while (errno == EINTR);
1630
1631 ret = -errno;
1632#endif
1633 } else {
1634#ifdef CONFIG_XFS
1635 if (s->is_xfs) {
1636 return xfs_discard(s, aiocb->aio_offset, aiocb->aio_nbytes);
1637 }
1638#endif
1639
1640#ifdef CONFIG_FALLOCATE_PUNCH_HOLE
0b991712
DL
1641 ret = do_fallocate(s->fd, FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE,
1642 aiocb->aio_offset, aiocb->aio_nbytes);
8238010b
PB
1643#endif
1644 }
1645
1486df0e
DL
1646 ret = translate_err(ret);
1647 if (ret == -ENOTSUP) {
7ce21016 1648 s->has_discard = false;
8238010b
PB
1649 }
1650 return ret;
1651}
1652
29cb4c01 1653static int handle_aiocb_truncate(void *opaque)
93f4e2ff 1654{
29cb4c01 1655 RawPosixAIOData *aiocb = opaque;
93f4e2ff
KW
1656 int result = 0;
1657 int64_t current_length = 0;
1658 char *buf = NULL;
1659 struct stat st;
1660 int fd = aiocb->aio_fildes;
1661 int64_t offset = aiocb->aio_offset;
d57c44d0
KW
1662 PreallocMode prealloc = aiocb->truncate.prealloc;
1663 Error **errp = aiocb->truncate.errp;
93f4e2ff
KW
1664
1665 if (fstat(fd, &st) < 0) {
1666 result = -errno;
1667 error_setg_errno(errp, -result, "Could not stat file");
1668 return result;
1669 }
1670
1671 current_length = st.st_size;
d57c44d0 1672 if (current_length > offset && prealloc != PREALLOC_MODE_OFF) {
93f4e2ff
KW
1673 error_setg(errp, "Cannot use preallocation for shrinking files");
1674 return -ENOTSUP;
1675 }
1676
d57c44d0 1677 switch (prealloc) {
93f4e2ff
KW
1678#ifdef CONFIG_POSIX_FALLOCATE
1679 case PREALLOC_MODE_FALLOC:
1680 /*
1681 * Truncating before posix_fallocate() makes it about twice slower on
1682 * file systems that do not support fallocate(), trying to check if a
1683 * block is allocated before allocating it, so don't do that here.
1684 */
1685 if (offset != current_length) {
1686 result = -posix_fallocate(fd, current_length,
1687 offset - current_length);
1688 if (result != 0) {
1689 /* posix_fallocate() doesn't set errno. */
1690 error_setg_errno(errp, -result,
1691 "Could not preallocate new data");
1692 }
1693 } else {
1694 result = 0;
1695 }
1696 goto out;
1697#endif
1698 case PREALLOC_MODE_FULL:
1699 {
1700 int64_t num = 0, left = offset - current_length;
1701 off_t seek_result;
1702
1703 /*
1704 * Knowing the final size from the beginning could allow the file
1705 * system driver to do less allocations and possibly avoid
1706 * fragmentation of the file.
1707 */
1708 if (ftruncate(fd, offset) != 0) {
1709 result = -errno;
1710 error_setg_errno(errp, -result, "Could not resize file");
1711 goto out;
1712 }
1713
1714 buf = g_malloc0(65536);
1715
1716 seek_result = lseek(fd, current_length, SEEK_SET);
1717 if (seek_result < 0) {
1718 result = -errno;
1719 error_setg_errno(errp, -result,
1720 "Failed to seek to the old end of file");
1721 goto out;
1722 }
1723
1724 while (left > 0) {
1725 num = MIN(left, 65536);
1726 result = write(fd, buf, num);
1727 if (result < 0) {
a1c81f4f
FZ
1728 if (errno == EINTR) {
1729 continue;
1730 }
93f4e2ff
KW
1731 result = -errno;
1732 error_setg_errno(errp, -result,
1733 "Could not write zeros for preallocation");
1734 goto out;
1735 }
1736 left -= result;
1737 }
1738 if (result >= 0) {
1739 result = fsync(fd);
1740 if (result < 0) {
1741 result = -errno;
1742 error_setg_errno(errp, -result,
1743 "Could not flush file to disk");
1744 goto out;
1745 }
1746 }
1747 goto out;
1748 }
1749 case PREALLOC_MODE_OFF:
1750 if (ftruncate(fd, offset) != 0) {
1751 result = -errno;
1752 error_setg_errno(errp, -result, "Could not resize file");
1753 }
1754 return result;
1755 default:
1756 result = -ENOTSUP;
1757 error_setg(errp, "Unsupported preallocation mode: %s",
d57c44d0 1758 PreallocMode_str(prealloc));
93f4e2ff
KW
1759 return result;
1760 }
1761
1762out:
1763 if (result < 0) {
1764 if (ftruncate(fd, current_length) < 0) {
1765 error_report("Failed to restore old file length: %s",
1766 strerror(errno));
1767 }
1768 }
1769
1770 g_free(buf);
1771 return result;
1772}
1773
de81a169
PB
1774static int aio_worker(void *arg)
1775{
1776 RawPosixAIOData *aiocb = arg;
1777 ssize_t ret = 0;
1778
1779 switch (aiocb->aio_type & QEMU_AIO_TYPE_MASK) {
1780 case QEMU_AIO_READ:
1781 ret = handle_aiocb_rw(aiocb);
c0191e76 1782 if (ret >= 0 && ret < aiocb->aio_nbytes) {
d57c44d0 1783 iov_memset(aiocb->io.iov, aiocb->io.niov, ret,
de81a169
PB
1784 0, aiocb->aio_nbytes - ret);
1785
1786 ret = aiocb->aio_nbytes;
1787 }
1788 if (ret == aiocb->aio_nbytes) {
1789 ret = 0;
1790 } else if (ret >= 0 && ret < aiocb->aio_nbytes) {
1791 ret = -EINVAL;
1792 }
1793 break;
1794 case QEMU_AIO_WRITE:
1795 ret = handle_aiocb_rw(aiocb);
1796 if (ret == aiocb->aio_nbytes) {
1797 ret = 0;
1798 } else if (ret >= 0 && ret < aiocb->aio_nbytes) {
1799 ret = -EINVAL;
1800 }
1801 break;
de81a169
PB
1802 case QEMU_AIO_IOCTL:
1803 ret = handle_aiocb_ioctl(aiocb);
1804 break;
06dc9bd5 1805 case QEMU_AIO_FLUSH:
8238010b 1806 case QEMU_AIO_DISCARD:
97a2ae34 1807 case QEMU_AIO_WRITE_ZEROES:
34fa110e 1808 case QEMU_AIO_WRITE_ZEROES | QEMU_AIO_DISCARD:
1efad060 1809 case QEMU_AIO_COPY_RANGE:
93f4e2ff 1810 case QEMU_AIO_TRUNCATE:
29cb4c01 1811 g_assert_not_reached();
de81a169 1812 default:
db0754df 1813 error_report("invalid aio request (0x%x)", aiocb->aio_type);
de81a169
PB
1814 ret = -EINVAL;
1815 break;
1816 }
1817
c84b3192 1818 g_free(aiocb);
de81a169
PB
1819 return ret;
1820}
1821
5d5de250
KW
1822static int coroutine_fn raw_thread_pool_submit(BlockDriverState *bs,
1823 ThreadPoolFunc func, void *arg)
1824{
1825 /* @bs can be NULL, bdrv_get_aio_context() returns the main context then */
1826 ThreadPool *pool = aio_get_thread_pool(bdrv_get_aio_context(bs));
1827 return thread_pool_submit_co(pool, func, arg);
1828}
1829
1efad060
FZ
1830static int paio_submit_co_full(BlockDriverState *bs, int fd,
1831 int64_t offset, int fd2, int64_t offset2,
1832 QEMUIOVector *qiov,
1833 int bytes, int type)
260a82e5 1834{
c84b3192 1835 RawPosixAIOData *acb = g_new(RawPosixAIOData, 1);
260a82e5
PB
1836
1837 acb->bs = bs;
1838 acb->aio_type = type;
1839 acb->aio_fildes = fd;
1840
f5a5ca79 1841 acb->aio_nbytes = bytes;
2ffa76c2 1842 acb->aio_offset = offset;
8eb029c2 1843
260a82e5 1844 if (qiov) {
d57c44d0
KW
1845 acb->io.iov = qiov->iov;
1846 acb->io.niov = qiov->niov;
f5a5ca79 1847 assert(qiov->size == bytes);
d57c44d0
KW
1848 } else {
1849 acb->copy_range.aio_fd2 = fd2;
1850 acb->copy_range.aio_offset2 = offset2;
260a82e5 1851 }
260a82e5 1852
f8a30874 1853 trace_file_paio_submit_co(offset, bytes, type);
5d5de250 1854 return raw_thread_pool_submit(bs, aio_worker, acb);
260a82e5
PB
1855}
1856
1efad060
FZ
1857static inline int paio_submit_co(BlockDriverState *bs, int fd,
1858 int64_t offset, QEMUIOVector *qiov,
1859 int bytes, int type)
1860{
1861 return paio_submit_co_full(bs, fd, offset, -1, 0, qiov, bytes, type);
1862}
1863
9d52aa3c
KW
1864static int coroutine_fn raw_co_prw(BlockDriverState *bs, uint64_t offset,
1865 uint64_t bytes, QEMUIOVector *qiov, int type)
83f64091 1866{
ce1a14dc 1867 BDRVRawState *s = bs->opaque;
ce1a14dc 1868
19cb3738 1869 if (fd_open(bs) < 0)
2174f12b 1870 return -EIO;
19cb3738 1871
f141eafe 1872 /*
3cad8307
RPM
1873 * Check if the underlying device requires requests to be aligned,
1874 * and if the request we are trying to submit is aligned or not.
1875 * If this is the case tell the low-level driver that it needs
1876 * to copy the buffer.
f141eafe 1877 */
3cad8307 1878 if (s->needs_alignment) {
c53b1c51 1879 if (!bdrv_qiov_is_aligned(bs, qiov)) {
5c6c3a6c 1880 type |= QEMU_AIO_MISALIGNED;
e44bd6fc 1881#ifdef CONFIG_LINUX_AIO
0a4279d9 1882 } else if (s->use_linux_aio) {
0187f5c9 1883 LinuxAioState *aio = aio_get_linux_aio(bdrv_get_aio_context(bs));
9d52aa3c 1884 assert(qiov->size == bytes);
0187f5c9 1885 return laio_co_submit(bs, aio, s->fd, offset, qiov, type);
e44bd6fc 1886#endif
5c6c3a6c 1887 }
9ef91a67 1888 }
f141eafe 1889
9d52aa3c 1890 return paio_submit_co(bs, s->fd, offset, qiov, bytes, type);
2174f12b
KW
1891}
1892
9d52aa3c
KW
1893static int coroutine_fn raw_co_preadv(BlockDriverState *bs, uint64_t offset,
1894 uint64_t bytes, QEMUIOVector *qiov,
1895 int flags)
2174f12b 1896{
9d52aa3c 1897 return raw_co_prw(bs, offset, bytes, qiov, QEMU_AIO_READ);
2174f12b
KW
1898}
1899
9d52aa3c
KW
1900static int coroutine_fn raw_co_pwritev(BlockDriverState *bs, uint64_t offset,
1901 uint64_t bytes, QEMUIOVector *qiov,
1902 int flags)
2174f12b 1903{
9d52aa3c
KW
1904 assert(flags == 0);
1905 return raw_co_prw(bs, offset, bytes, qiov, QEMU_AIO_WRITE);
83f64091
FB
1906}
1907
1b3abdcc
ML
1908static void raw_aio_plug(BlockDriverState *bs)
1909{
1910#ifdef CONFIG_LINUX_AIO
0a4279d9
KW
1911 BDRVRawState *s = bs->opaque;
1912 if (s->use_linux_aio) {
0187f5c9
PB
1913 LinuxAioState *aio = aio_get_linux_aio(bdrv_get_aio_context(bs));
1914 laio_io_plug(bs, aio);
1b3abdcc
ML
1915 }
1916#endif
1917}
1918
1919static void raw_aio_unplug(BlockDriverState *bs)
1920{
1921#ifdef CONFIG_LINUX_AIO
0a4279d9
KW
1922 BDRVRawState *s = bs->opaque;
1923 if (s->use_linux_aio) {
0187f5c9
PB
1924 LinuxAioState *aio = aio_get_linux_aio(bdrv_get_aio_context(bs));
1925 laio_io_unplug(bs, aio);
1b3abdcc
ML
1926 }
1927#endif
1928}
1929
33d70fb6 1930static int raw_co_flush_to_disk(BlockDriverState *bs)
b2e12bc6
CH
1931{
1932 BDRVRawState *s = bs->opaque;
06dc9bd5 1933 RawPosixAIOData acb;
33d70fb6 1934 int ret;
b2e12bc6 1935
33d70fb6
KW
1936 ret = fd_open(bs);
1937 if (ret < 0) {
1938 return ret;
1939 }
b2e12bc6 1940
06dc9bd5
KW
1941 acb = (RawPosixAIOData) {
1942 .bs = bs,
1943 .aio_fildes = s->fd,
1944 .aio_type = QEMU_AIO_FLUSH,
1945 };
1946
1947 return raw_thread_pool_submit(bs, handle_aiocb_flush, &acb);
b2e12bc6
CH
1948}
1949
ed6e2161
NA
1950static void raw_aio_attach_aio_context(BlockDriverState *bs,
1951 AioContext *new_context)
1952{
1953#ifdef CONFIG_LINUX_AIO
1954 BDRVRawState *s = bs->opaque;
1955 if (s->use_linux_aio) {
1956 Error *local_err;
1957 if (!aio_setup_linux_aio(new_context, &local_err)) {
1958 error_reportf_err(local_err, "Unable to use native AIO, "
1959 "falling back to thread pool: ");
1960 s->use_linux_aio = false;
1961 }
1962 }
1963#endif
1964}
1965
83f64091
FB
1966static void raw_close(BlockDriverState *bs)
1967{
1968 BDRVRawState *s = bs->opaque;
c2f3426c 1969
19cb3738 1970 if (s->fd >= 0) {
2e1e79da 1971 qemu_close(s->fd);
19cb3738
FB
1972 s->fd = -1;
1973 }
83f64091
FB
1974}
1975
d0bc9e5d
HR
1976/**
1977 * Truncates the given regular file @fd to @offset and, when growing, fills the
1978 * new space according to @prealloc.
1979 *
1980 * Returns: 0 on success, -errno on failure.
1981 */
93f4e2ff
KW
1982static int coroutine_fn
1983raw_regular_truncate(BlockDriverState *bs, int fd, int64_t offset,
1984 PreallocMode prealloc, Error **errp)
9f63b07e 1985{
29cb4c01 1986 RawPosixAIOData acb;
d0bc9e5d 1987
29cb4c01 1988 acb = (RawPosixAIOData) {
93f4e2ff
KW
1989 .bs = bs,
1990 .aio_fildes = fd,
1991 .aio_type = QEMU_AIO_TRUNCATE,
1992 .aio_offset = offset,
d57c44d0
KW
1993 .truncate = {
1994 .prealloc = prealloc,
1995 .errp = errp,
1996 },
93f4e2ff 1997 };
d0bc9e5d 1998
29cb4c01 1999 return raw_thread_pool_submit(bs, handle_aiocb_truncate, &acb);
9f63b07e
HR
2000}
2001
061ca8a3
KW
2002static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,
2003 PreallocMode prealloc, Error **errp)
83f64091
FB
2004{
2005 BDRVRawState *s = bs->opaque;
55b949c8 2006 struct stat st;
f59adb32 2007 int ret;
55b949c8
CH
2008
2009 if (fstat(s->fd, &st)) {
f59adb32
HR
2010 ret = -errno;
2011 error_setg_errno(errp, -ret, "Failed to fstat() the file");
2012 return ret;
55b949c8
CH
2013 }
2014
2015 if (S_ISREG(st.st_mode)) {
93f4e2ff 2016 return raw_regular_truncate(bs, s->fd, offset, prealloc, errp);
35d72602
HR
2017 }
2018
2019 if (prealloc != PREALLOC_MODE_OFF) {
2020 error_setg(errp, "Preallocation mode '%s' unsupported for this "
977c736f 2021 "non-regular file", PreallocMode_str(prealloc));
35d72602
HR
2022 return -ENOTSUP;
2023 }
2024
2025 if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) {
f59adb32
HR
2026 if (offset > raw_getlength(bs)) {
2027 error_setg(errp, "Cannot grow device files");
2028 return -EINVAL;
2029 }
55b949c8 2030 } else {
f59adb32 2031 error_setg(errp, "Resizing this file is not supported");
55b949c8
CH
2032 return -ENOTSUP;
2033 }
2034
83f64091
FB
2035 return 0;
2036}
2037
128ab2ff
BS
2038#ifdef __OpenBSD__
2039static int64_t raw_getlength(BlockDriverState *bs)
2040{
2041 BDRVRawState *s = bs->opaque;
2042 int fd = s->fd;
2043 struct stat st;
2044
2045 if (fstat(fd, &st))
aa729704 2046 return -errno;
128ab2ff
BS
2047 if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) {
2048 struct disklabel dl;
2049
2050 if (ioctl(fd, DIOCGDINFO, &dl))
aa729704 2051 return -errno;
128ab2ff
BS
2052 return (uint64_t)dl.d_secsize *
2053 dl.d_partitions[DISKPART(st.st_rdev)].p_size;
2054 } else
2055 return st.st_size;
2056}
d1f6fd8d
CE
2057#elif defined(__NetBSD__)
2058static int64_t raw_getlength(BlockDriverState *bs)
2059{
2060 BDRVRawState *s = bs->opaque;
2061 int fd = s->fd;
2062 struct stat st;
2063
2064 if (fstat(fd, &st))
aa729704 2065 return -errno;
d1f6fd8d
CE
2066 if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) {
2067 struct dkwedge_info dkw;
2068
2069 if (ioctl(fd, DIOCGWEDGEINFO, &dkw) != -1) {
2070 return dkw.dkw_size * 512;
2071 } else {
2072 struct disklabel dl;
2073
2074 if (ioctl(fd, DIOCGDINFO, &dl))
aa729704 2075 return -errno;
d1f6fd8d
CE
2076 return (uint64_t)dl.d_secsize *
2077 dl.d_partitions[DISKPART(st.st_rdev)].p_size;
2078 }
2079 } else
2080 return st.st_size;
2081}
50779cc2
CH
2082#elif defined(__sun__)
2083static int64_t raw_getlength(BlockDriverState *bs)
2084{
2085 BDRVRawState *s = bs->opaque;
2086 struct dk_minfo minfo;
2087 int ret;
aa729704 2088 int64_t size;
50779cc2
CH
2089
2090 ret = fd_open(bs);
2091 if (ret < 0) {
2092 return ret;
2093 }
2094
2095 /*
2096 * Use the DKIOCGMEDIAINFO ioctl to read the size.
2097 */
2098 ret = ioctl(s->fd, DKIOCGMEDIAINFO, &minfo);
2099 if (ret != -1) {
2100 return minfo.dki_lbsize * minfo.dki_capacity;
2101 }
2102
2103 /*
2104 * There are reports that lseek on some devices fails, but
2105 * irc discussion said that contingency on contingency was overkill.
2106 */
aa729704
MA
2107 size = lseek(s->fd, 0, SEEK_END);
2108 if (size < 0) {
2109 return -errno;
2110 }
2111 return size;
50779cc2
CH
2112}
2113#elif defined(CONFIG_BSD)
2114static int64_t raw_getlength(BlockDriverState *bs)
83f64091
FB
2115{
2116 BDRVRawState *s = bs->opaque;
2117 int fd = s->fd;
2118 int64_t size;
83f64091 2119 struct stat sb;
a167ba50 2120#if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
9f23011a 2121 int reopened = 0;
83f64091 2122#endif
19cb3738
FB
2123 int ret;
2124
2125 ret = fd_open(bs);
2126 if (ret < 0)
2127 return ret;
83f64091 2128
a167ba50 2129#if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
9f23011a
BS
2130again:
2131#endif
83f64091
FB
2132 if (!fstat(fd, &sb) && (S_IFCHR & sb.st_mode)) {
2133#ifdef DIOCGMEDIASIZE
2134 if (ioctl(fd, DIOCGMEDIASIZE, (off_t *)&size))
c5e97233
BS
2135#elif defined(DIOCGPART)
2136 {
2137 struct partinfo pi;
2138 if (ioctl(fd, DIOCGPART, &pi) == 0)
2139 size = pi.media_size;
2140 else
2141 size = 0;
2142 }
2143 if (size == 0)
83f64091 2144#endif
83affaa6 2145#if defined(__APPLE__) && defined(__MACH__)
728dacbd
JA
2146 {
2147 uint64_t sectors = 0;
2148 uint32_t sector_size = 0;
2149
2150 if (ioctl(fd, DKIOCGETBLOCKCOUNT, &sectors) == 0
2151 && ioctl(fd, DKIOCGETBLOCKSIZE, &sector_size) == 0) {
2152 size = sectors * sector_size;
2153 } else {
2154 size = lseek(fd, 0LL, SEEK_END);
2155 if (size < 0) {
2156 return -errno;
2157 }
2158 }
2159 }
83f64091
FB
2160#else
2161 size = lseek(fd, 0LL, SEEK_END);
aa729704
MA
2162 if (size < 0) {
2163 return -errno;
2164 }
9f23011a 2165#endif
a167ba50 2166#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
9f23011a
BS
2167 switch(s->type) {
2168 case FTYPE_CD:
2169 /* XXX FreeBSD acd returns UINT_MAX sectors for an empty drive */
2170 if (size == 2048LL * (unsigned)-1)
2171 size = 0;
2172 /* XXX no disc? maybe we need to reopen... */
f3a5d3f8 2173 if (size <= 0 && !reopened && cdrom_reopen(bs) >= 0) {
9f23011a
BS
2174 reopened = 1;
2175 goto again;
2176 }
2177 }
83f64091 2178#endif
50779cc2 2179 } else {
83f64091 2180 size = lseek(fd, 0, SEEK_END);
aa729704
MA
2181 if (size < 0) {
2182 return -errno;
2183 }
83f64091 2184 }
83f64091
FB
2185 return size;
2186}
50779cc2
CH
2187#else
2188static int64_t raw_getlength(BlockDriverState *bs)
2189{
2190 BDRVRawState *s = bs->opaque;
2191 int ret;
aa729704 2192 int64_t size;
50779cc2
CH
2193
2194 ret = fd_open(bs);
2195 if (ret < 0) {
2196 return ret;
2197 }
2198
aa729704
MA
2199 size = lseek(s->fd, 0, SEEK_END);
2200 if (size < 0) {
2201 return -errno;
2202 }
2203 return size;
50779cc2 2204}
128ab2ff 2205#endif
83f64091 2206
4a1d5e1f
FZ
2207static int64_t raw_get_allocated_file_size(BlockDriverState *bs)
2208{
2209 struct stat st;
2210 BDRVRawState *s = bs->opaque;
2211
2212 if (fstat(s->fd, &st) < 0) {
2213 return -errno;
2214 }
2215 return (int64_t)st.st_blocks * 512;
2216}
2217
93f4e2ff
KW
2218static int coroutine_fn
2219raw_co_create(BlockdevCreateOptions *options, Error **errp)
83f64091 2220{
927f11e1 2221 BlockdevCreateOptionsFile *file_opts;
7c20c808 2222 Error *local_err = NULL;
83f64091 2223 int fd;
d815efca 2224 uint64_t perm, shared;
1e37d059 2225 int result = 0;
83f64091 2226
927f11e1
KW
2227 /* Validate options and set default values */
2228 assert(options->driver == BLOCKDEV_DRIVER_FILE);
2229 file_opts = &options->u.file;
464d9f64 2230
927f11e1
KW
2231 if (!file_opts->has_nocow) {
2232 file_opts->nocow = false;
2233 }
2234 if (!file_opts->has_preallocation) {
2235 file_opts->preallocation = PREALLOC_MODE_OFF;
06247428 2236 }
83f64091 2237
927f11e1 2238 /* Create file */
b8cf1913 2239 fd = qemu_open(file_opts->filename, O_RDWR | O_CREAT | O_BINARY, 0644);
1e37d059
SW
2240 if (fd < 0) {
2241 result = -errno;
e428e439 2242 error_setg_errno(errp, -result, "Could not create file");
06247428
HT
2243 goto out;
2244 }
2245
b8cf1913
HR
2246 /* Take permissions: We want to discard everything, so we need
2247 * BLK_PERM_WRITE; and truncation to the desired size requires
2248 * BLK_PERM_RESIZE.
2249 * On the other hand, we cannot share the RESIZE permission
2250 * because we promise that after this function, the file has the
2251 * size given in the options. If someone else were to resize it
2252 * concurrently, we could not guarantee that.
2253 * Note that after this function, we can no longer guarantee that
2254 * the file is not touched by a third party, so it may be resized
2255 * then. */
2256 perm = BLK_PERM_WRITE | BLK_PERM_RESIZE;
2257 shared = BLK_PERM_ALL & ~BLK_PERM_RESIZE;
2258
2259 /* Step one: Take locks */
2996ffad 2260 result = raw_apply_lock_bytes(NULL, fd, perm, ~shared, false, errp);
b8cf1913
HR
2261 if (result < 0) {
2262 goto out_close;
2263 }
2264
2265 /* Step two: Check that nobody else has taken conflicting locks */
2266 result = raw_check_lock_bytes(fd, perm, shared, errp);
2267 if (result < 0) {
b857431d
FZ
2268 error_append_hint(errp,
2269 "Is another process using the image [%s]?\n",
2270 file_opts->filename);
7c20c808 2271 goto out_unlock;
b8cf1913
HR
2272 }
2273
2274 /* Clear the file by truncating it to 0 */
93f4e2ff 2275 result = raw_regular_truncate(NULL, fd, 0, PREALLOC_MODE_OFF, errp);
b8cf1913 2276 if (result < 0) {
7c20c808 2277 goto out_unlock;
b8cf1913
HR
2278 }
2279
927f11e1 2280 if (file_opts->nocow) {
4ab15590 2281#ifdef __linux__
06247428
HT
2282 /* Set NOCOW flag to solve performance issue on fs like btrfs.
2283 * This is an optimisation. The FS_IOC_SETFLAGS ioctl return value
2284 * will be ignored since any failure of this operation should not
2285 * block the left work.
2286 */
2287 int attr;
2288 if (ioctl(fd, FS_IOC_GETFLAGS, &attr) == 0) {
2289 attr |= FS_NOCOW_FL;
2290 ioctl(fd, FS_IOC_SETFLAGS, &attr);
4ab15590 2291 }
06247428
HT
2292#endif
2293 }
2294
b8cf1913
HR
2295 /* Resize and potentially preallocate the file to the desired
2296 * final size */
93f4e2ff
KW
2297 result = raw_regular_truncate(NULL, fd, file_opts->size,
2298 file_opts->preallocation, errp);
9f63b07e 2299 if (result < 0) {
7c20c808
HR
2300 goto out_unlock;
2301 }
2302
2303out_unlock:
2996ffad 2304 raw_apply_lock_bytes(NULL, fd, 0, 0, true, &local_err);
7c20c808
HR
2305 if (local_err) {
2306 /* The above call should not fail, and if it does, that does
2307 * not mean the whole creation operation has failed. So
2308 * report it the user for their convenience, but do not report
2309 * it to the caller. */
db0754df 2310 warn_report_err(local_err);
1e37d059 2311 }
06247428 2312
5a1dad9d 2313out_close:
06247428
HT
2314 if (qemu_close(fd) != 0 && result == 0) {
2315 result = -errno;
2316 error_setg_errno(errp, -result, "Could not close the new file");
2317 }
2318out:
1e37d059 2319 return result;
83f64091
FB
2320}
2321
927f11e1
KW
2322static int coroutine_fn raw_co_create_opts(const char *filename, QemuOpts *opts,
2323 Error **errp)
2324{
2325 BlockdevCreateOptions options;
2326 int64_t total_size = 0;
2327 bool nocow = false;
2328 PreallocMode prealloc;
2329 char *buf = NULL;
2330 Error *local_err = NULL;
2331
2332 /* Skip file: protocol prefix */
2333 strstart(filename, "file:", &filename);
2334
2335 /* Read out options */
2336 total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
2337 BDRV_SECTOR_SIZE);
2338 nocow = qemu_opt_get_bool(opts, BLOCK_OPT_NOCOW, false);
2339 buf = qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC);
2340 prealloc = qapi_enum_parse(&PreallocMode_lookup, buf,
2341 PREALLOC_MODE_OFF, &local_err);
2342 g_free(buf);
2343 if (local_err) {
2344 error_propagate(errp, local_err);
2345 return -EINVAL;
2346 }
2347
2348 options = (BlockdevCreateOptions) {
2349 .driver = BLOCKDEV_DRIVER_FILE,
2350 .u.file = {
2351 .filename = (char *) filename,
2352 .size = total_size,
2353 .has_preallocation = true,
2354 .preallocation = prealloc,
2355 .has_nocow = true,
2356 .nocow = nocow,
2357 },
2358 };
2359 return raw_co_create(&options, errp);
2360}
2361
d1f06fe6
MA
2362/*
2363 * Find allocation range in @bs around offset @start.
2364 * May change underlying file descriptor's file offset.
2365 * If @start is not in a hole, store @start in @data, and the
2366 * beginning of the next hole in @hole, and return 0.
2367 * If @start is in a non-trailing hole, store @start in @hole and the
2368 * beginning of the next non-hole in @data, and return 0.
2369 * If @start is in a trailing hole or beyond EOF, return -ENXIO.
2370 * If we can't find out, return a negative errno other than -ENXIO.
2371 */
2372static int find_allocation(BlockDriverState *bs, off_t start,
2373 off_t *data, off_t *hole)
4f11aa8a
HR
2374{
2375#if defined SEEK_HOLE && defined SEEK_DATA
94282e71 2376 BDRVRawState *s = bs->opaque;
d1f06fe6 2377 off_t offs;
94282e71 2378
d1f06fe6
MA
2379 /*
2380 * SEEK_DATA cases:
2381 * D1. offs == start: start is in data
2382 * D2. offs > start: start is in a hole, next data at offs
2383 * D3. offs < 0, errno = ENXIO: either start is in a trailing hole
2384 * or start is beyond EOF
2385 * If the latter happens, the file has been truncated behind
2386 * our back since we opened it. All bets are off then.
2387 * Treating like a trailing hole is simplest.
2388 * D4. offs < 0, errno != ENXIO: we learned nothing
2389 */
2390 offs = lseek(s->fd, start, SEEK_DATA);
2391 if (offs < 0) {
2392 return -errno; /* D3 or D4 */
2393 }
a03083a0
JC
2394
2395 if (offs < start) {
2396 /* This is not a valid return by lseek(). We are safe to just return
2397 * -EIO in this case, and we'll treat it like D4. */
2398 return -EIO;
2399 }
d1f06fe6
MA
2400
2401 if (offs > start) {
2402 /* D2: in hole, next data at offs */
2403 *hole = start;
2404 *data = offs;
2405 return 0;
5500316d
PB
2406 }
2407
d1f06fe6
MA
2408 /* D1: in data, end not yet known */
2409
2410 /*
2411 * SEEK_HOLE cases:
2412 * H1. offs == start: start is in a hole
2413 * If this happens here, a hole has been dug behind our back
2414 * since the previous lseek().
2415 * H2. offs > start: either start is in data, next hole at offs,
2416 * or start is in trailing hole, EOF at offs
2417 * Linux treats trailing holes like any other hole: offs ==
2418 * start. Solaris seeks to EOF instead: offs > start (blech).
2419 * If that happens here, a hole has been dug behind our back
2420 * since the previous lseek().
2421 * H3. offs < 0, errno = ENXIO: start is beyond EOF
2422 * If this happens, the file has been truncated behind our
2423 * back since we opened it. Treat it like a trailing hole.
2424 * H4. offs < 0, errno != ENXIO: we learned nothing
2425 * Pretend we know nothing at all, i.e. "forget" about D1.
2426 */
2427 offs = lseek(s->fd, start, SEEK_HOLE);
2428 if (offs < 0) {
2429 return -errno; /* D1 and (H3 or H4) */
2430 }
a03083a0
JC
2431
2432 if (offs < start) {
2433 /* This is not a valid return by lseek(). We are safe to just return
2434 * -EIO in this case, and we'll treat it like H4. */
2435 return -EIO;
2436 }
d1f06fe6
MA
2437
2438 if (offs > start) {
2439 /*
2440 * D1 and H2: either in data, next hole at offs, or it was in
2441 * data but is now in a trailing hole. In the latter case,
2442 * all bets are off. Treating it as if it there was data all
2443 * the way to EOF is safe, so simply do that.
2444 */
4f11aa8a 2445 *data = start;
d1f06fe6
MA
2446 *hole = offs;
2447 return 0;
5500316d 2448 }
4f11aa8a 2449
d1f06fe6
MA
2450 /* D1 and H1 */
2451 return -EBUSY;
5500316d 2452#else
4f11aa8a 2453 return -ENOTSUP;
5500316d 2454#endif
4f11aa8a
HR
2455}
2456
2457/*
a290f085 2458 * Returns the allocation status of the specified offset.
4f11aa8a 2459 *
a290f085 2460 * The block layer guarantees 'offset' and 'bytes' are within bounds.
4f11aa8a 2461 *
a290f085
EB
2462 * 'pnum' is set to the number of bytes (including and immediately following
2463 * the specified offset) that are known to be in the same
4f11aa8a
HR
2464 * allocated/unallocated state.
2465 *
a290f085 2466 * 'bytes' is the max value 'pnum' should be set to.
4f11aa8a 2467 */
a290f085
EB
2468static int coroutine_fn raw_co_block_status(BlockDriverState *bs,
2469 bool want_zero,
2470 int64_t offset,
2471 int64_t bytes, int64_t *pnum,
2472 int64_t *map,
2473 BlockDriverState **file)
2474{
2475 off_t data = 0, hole = 0;
d7f62751 2476 int ret;
4f11aa8a
HR
2477
2478 ret = fd_open(bs);
2479 if (ret < 0) {
2480 return ret;
2481 }
2482
a290f085
EB
2483 if (!want_zero) {
2484 *pnum = bytes;
2485 *map = offset;
2486 *file = bs;
2487 return BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID;
e6d7ec32 2488 }
4f11aa8a 2489
a290f085 2490 ret = find_allocation(bs, offset, &data, &hole);
d1f06fe6
MA
2491 if (ret == -ENXIO) {
2492 /* Trailing hole */
a290f085 2493 *pnum = bytes;
d1f06fe6
MA
2494 ret = BDRV_BLOCK_ZERO;
2495 } else if (ret < 0) {
2496 /* No info available, so pretend there are no holes */
a290f085 2497 *pnum = bytes;
d1f06fe6 2498 ret = BDRV_BLOCK_DATA;
a290f085
EB
2499 } else if (data == offset) {
2500 /* On a data extent, compute bytes to the end of the extent,
f4a769ab 2501 * possibly including a partial sector at EOF. */
a290f085 2502 *pnum = MIN(bytes, hole - offset);
d1f06fe6 2503 ret = BDRV_BLOCK_DATA;
5500316d 2504 } else {
a290f085
EB
2505 /* On a hole, compute bytes to the beginning of the next extent. */
2506 assert(hole == offset);
2507 *pnum = MIN(bytes, data - offset);
d1f06fe6 2508 ret = BDRV_BLOCK_ZERO;
5500316d 2509 }
a290f085 2510 *map = offset;
02650acb 2511 *file = bs;
a290f085 2512 return ret | BDRV_BLOCK_OFFSET_VALID;
5500316d
PB
2513}
2514
31be8a2a
SH
2515#if defined(__linux__)
2516/* Verify that the file is not in the page cache */
2517static void check_cache_dropped(BlockDriverState *bs, Error **errp)
2518{
2519 const size_t window_size = 128 * 1024 * 1024;
2520 BDRVRawState *s = bs->opaque;
2521 void *window = NULL;
2522 size_t length = 0;
2523 unsigned char *vec;
2524 size_t page_size;
2525 off_t offset;
2526 off_t end;
2527
2528 /* mincore(2) page status information requires 1 byte per page */
2529 page_size = sysconf(_SC_PAGESIZE);
2530 vec = g_malloc(DIV_ROUND_UP(window_size, page_size));
2531
2532 end = raw_getlength(bs);
2533
2534 for (offset = 0; offset < end; offset += window_size) {
2535 void *new_window;
2536 size_t new_length;
2537 size_t vec_end;
2538 size_t i;
2539 int ret;
2540
2541 /* Unmap previous window if size has changed */
2542 new_length = MIN(end - offset, window_size);
2543 if (new_length != length) {
2544 munmap(window, length);
2545 window = NULL;
2546 length = 0;
2547 }
2548
2549 new_window = mmap(window, new_length, PROT_NONE, MAP_PRIVATE,
2550 s->fd, offset);
2551 if (new_window == MAP_FAILED) {
2552 error_setg_errno(errp, errno, "mmap failed");
2553 break;
2554 }
2555
2556 window = new_window;
2557 length = new_length;
2558
2559 ret = mincore(window, length, vec);
2560 if (ret < 0) {
2561 error_setg_errno(errp, errno, "mincore failed");
2562 break;
2563 }
2564
2565 vec_end = DIV_ROUND_UP(length, page_size);
2566 for (i = 0; i < vec_end; i++) {
2567 if (vec[i] & 0x1) {
2568 error_setg(errp, "page cache still in use!");
2569 break;
2570 }
2571 }
2572 }
2573
2574 if (window) {
2575 munmap(window, length);
2576 }
2577
2578 g_free(vec);
2579}
2580#endif /* __linux__ */
2581
dd577a26
SH
2582static void coroutine_fn raw_co_invalidate_cache(BlockDriverState *bs,
2583 Error **errp)
2584{
2585 BDRVRawState *s = bs->opaque;
2586 int ret;
2587
2588 ret = fd_open(bs);
2589 if (ret < 0) {
2590 error_setg_errno(errp, -ret, "The file descriptor is not open");
2591 return;
2592 }
2593
2594 if (s->open_flags & O_DIRECT) {
2595 return; /* No host kernel page cache */
2596 }
2597
2598#if defined(__linux__)
2599 /* This sets the scene for the next syscall... */
2600 ret = bdrv_co_flush(bs);
2601 if (ret < 0) {
2602 error_setg_errno(errp, -ret, "flush failed");
2603 return;
2604 }
2605
2606 /* Linux does not invalidate pages that are dirty, locked, or mmapped by a
2607 * process. These limitations are okay because we just fsynced the file,
2608 * we don't use mmap, and the file should not be in use by other processes.
2609 */
2610 ret = posix_fadvise(s->fd, 0, 0, POSIX_FADV_DONTNEED);
2611 if (ret != 0) { /* the return value is a positive errno */
2612 error_setg_errno(errp, ret, "fadvise failed");
2613 return;
2614 }
31be8a2a
SH
2615
2616 if (s->check_cache_dropped) {
2617 check_cache_dropped(bs, errp);
2618 }
dd577a26
SH
2619#else /* __linux__ */
2620 /* Do nothing. Live migration to a remote host with cache.direct=off is
2621 * unsupported on other host operating systems. Cache consistency issues
2622 * may occur but no error is reported here, partly because that's the
2623 * historical behavior and partly because it's hard to differentiate valid
2624 * configurations that should not cause errors.
2625 */
2626#endif /* !__linux__ */
2627}
2628
33d70fb6 2629static coroutine_fn int
46ee0f46 2630raw_do_pdiscard(BlockDriverState *bs, int64_t offset, int bytes, bool blkdev)
dce512de 2631{
dce512de 2632 BDRVRawState *s = bs->opaque;
46ee0f46
KW
2633 RawPosixAIOData acb;
2634
2635 acb = (RawPosixAIOData) {
2636 .bs = bs,
2637 .aio_fildes = s->fd,
2638 .aio_type = QEMU_AIO_DISCARD,
2639 .aio_offset = offset,
2640 .aio_nbytes = bytes,
2641 };
dce512de 2642
46ee0f46
KW
2643 if (blkdev) {
2644 acb.aio_type |= QEMU_AIO_BLKDEV;
2645 }
2646
2647 return raw_thread_pool_submit(bs, handle_aiocb_discard, &acb);
2648}
2649
2650static coroutine_fn int
2651raw_co_pdiscard(BlockDriverState *bs, int64_t offset, int bytes)
2652{
2653 return raw_do_pdiscard(bs, offset, bytes, false);
dce512de 2654}
0e7e1989 2655
7154d8ae
KW
2656static int coroutine_fn
2657raw_do_pwrite_zeroes(BlockDriverState *bs, int64_t offset, int bytes,
2658 BdrvRequestFlags flags, bool blkdev)
260a82e5
PB
2659{
2660 BDRVRawState *s = bs->opaque;
7154d8ae
KW
2661 RawPosixAIOData acb;
2662 ThreadPoolFunc *handler;
2663
2664 acb = (RawPosixAIOData) {
2665 .bs = bs,
2666 .aio_fildes = s->fd,
2667 .aio_type = QEMU_AIO_WRITE_ZEROES,
2668 .aio_offset = offset,
2669 .aio_nbytes = bytes,
2670 };
2671
2672 if (blkdev) {
2673 acb.aio_type |= QEMU_AIO_BLKDEV;
2674 }
260a82e5 2675
34fa110e 2676 if (flags & BDRV_REQ_MAY_UNMAP) {
7154d8ae
KW
2677 acb.aio_type |= QEMU_AIO_DISCARD;
2678 handler = handle_aiocb_write_zeroes_unmap;
2679 } else {
2680 handler = handle_aiocb_write_zeroes;
260a82e5 2681 }
34fa110e 2682
7154d8ae
KW
2683 return raw_thread_pool_submit(bs, handler, &acb);
2684}
2685
2686static int coroutine_fn raw_co_pwrite_zeroes(
2687 BlockDriverState *bs, int64_t offset,
2688 int bytes, BdrvRequestFlags flags)
2689{
2690 return raw_do_pwrite_zeroes(bs, offset, bytes, flags, false);
260a82e5
PB
2691}
2692
2693static int raw_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
2694{
2695 BDRVRawState *s = bs->opaque;
2696
2697 bdi->unallocated_blocks_are_zero = s->discard_zeroes;
260a82e5
PB
2698 return 0;
2699}
2700
6f482f74
CL
2701static QemuOptsList raw_create_opts = {
2702 .name = "raw-create-opts",
2703 .head = QTAILQ_HEAD_INITIALIZER(raw_create_opts.head),
2704 .desc = {
2705 {
2706 .name = BLOCK_OPT_SIZE,
2707 .type = QEMU_OPT_SIZE,
2708 .help = "Virtual disk size"
2709 },
4ab15590
CL
2710 {
2711 .name = BLOCK_OPT_NOCOW,
2712 .type = QEMU_OPT_BOOL,
2713 .help = "Turn off copy-on-write (valid only on btrfs)"
2714 },
06247428
HT
2715 {
2716 .name = BLOCK_OPT_PREALLOC,
2717 .type = QEMU_OPT_STRING,
2718 .help = "Preallocation mode (allowed values: off, falloc, full)"
2719 },
6f482f74
CL
2720 { /* end of list */ }
2721 }
0e7e1989
KW
2722};
2723
244a5668
FZ
2724static int raw_check_perm(BlockDriverState *bs, uint64_t perm, uint64_t shared,
2725 Error **errp)
2726{
2727 return raw_handle_perm_lock(bs, RAW_PL_PREPARE, perm, shared, errp);
2728}
2729
2730static void raw_set_perm(BlockDriverState *bs, uint64_t perm, uint64_t shared)
2731{
2732 BDRVRawState *s = bs->opaque;
2733 raw_handle_perm_lock(bs, RAW_PL_COMMIT, perm, shared, NULL);
2734 s->perm = perm;
2735 s->shared_perm = shared;
2736}
2737
2738static void raw_abort_perm_update(BlockDriverState *bs)
2739{
2740 raw_handle_perm_lock(bs, RAW_PL_ABORT, 0, 0, NULL);
2741}
2742
67b51fb9
VSO
2743static int coroutine_fn raw_co_copy_range_from(
2744 BlockDriverState *bs, BdrvChild *src, uint64_t src_offset,
2745 BdrvChild *dst, uint64_t dst_offset, uint64_t bytes,
2746 BdrvRequestFlags read_flags, BdrvRequestFlags write_flags)
1efad060 2747{
67b51fb9
VSO
2748 return bdrv_co_copy_range_to(src, src_offset, dst, dst_offset, bytes,
2749 read_flags, write_flags);
1efad060
FZ
2750}
2751
2752static int coroutine_fn raw_co_copy_range_to(BlockDriverState *bs,
67b51fb9
VSO
2753 BdrvChild *src,
2754 uint64_t src_offset,
2755 BdrvChild *dst,
2756 uint64_t dst_offset,
2757 uint64_t bytes,
2758 BdrvRequestFlags read_flags,
2759 BdrvRequestFlags write_flags)
1efad060 2760{
58a209c4 2761 RawPosixAIOData acb;
1efad060
FZ
2762 BDRVRawState *s = bs->opaque;
2763 BDRVRawState *src_s;
2764
2765 assert(dst->bs == bs);
2766 if (src->bs->drv->bdrv_co_copy_range_to != raw_co_copy_range_to) {
2767 return -ENOTSUP;
2768 }
2769
2770 src_s = src->bs->opaque;
9f850f67 2771 if (fd_open(src->bs) < 0 || fd_open(dst->bs) < 0) {
1efad060
FZ
2772 return -EIO;
2773 }
58a209c4
KW
2774
2775 acb = (RawPosixAIOData) {
2776 .bs = bs,
2777 .aio_type = QEMU_AIO_COPY_RANGE,
2778 .aio_fildes = src_s->fd,
2779 .aio_offset = src_offset,
2780 .aio_nbytes = bytes,
2781 .copy_range = {
2782 .aio_fd2 = s->fd,
2783 .aio_offset2 = dst_offset,
2784 },
2785 };
2786
2787 return raw_thread_pool_submit(bs, handle_aiocb_copy_range, &acb);
1efad060
FZ
2788}
2789
5f535a94 2790BlockDriver bdrv_file = {
84a12e66
CH
2791 .format_name = "file",
2792 .protocol_name = "file",
856ae5c3 2793 .instance_size = sizeof(BDRVRawState),
030be321 2794 .bdrv_needs_filename = true,
856ae5c3 2795 .bdrv_probe = NULL, /* no probe for protocols */
078896a9 2796 .bdrv_parse_filename = raw_parse_filename,
66f82cee 2797 .bdrv_file_open = raw_open,
eeb6b45d
JC
2798 .bdrv_reopen_prepare = raw_reopen_prepare,
2799 .bdrv_reopen_commit = raw_reopen_commit,
2800 .bdrv_reopen_abort = raw_reopen_abort,
856ae5c3 2801 .bdrv_close = raw_close,
927f11e1 2802 .bdrv_co_create = raw_co_create,
efc75e2a 2803 .bdrv_co_create_opts = raw_co_create_opts,
3ac21627 2804 .bdrv_has_zero_init = bdrv_has_zero_init_1,
a290f085 2805 .bdrv_co_block_status = raw_co_block_status,
dd577a26 2806 .bdrv_co_invalidate_cache = raw_co_invalidate_cache,
2ffa76c2 2807 .bdrv_co_pwrite_zeroes = raw_co_pwrite_zeroes,
3b46e624 2808
9d52aa3c
KW
2809 .bdrv_co_preadv = raw_co_preadv,
2810 .bdrv_co_pwritev = raw_co_pwritev,
33d70fb6
KW
2811 .bdrv_co_flush_to_disk = raw_co_flush_to_disk,
2812 .bdrv_co_pdiscard = raw_co_pdiscard,
1efad060
FZ
2813 .bdrv_co_copy_range_from = raw_co_copy_range_from,
2814 .bdrv_co_copy_range_to = raw_co_copy_range_to,
c25f53b0 2815 .bdrv_refresh_limits = raw_refresh_limits,
1b3abdcc
ML
2816 .bdrv_io_plug = raw_aio_plug,
2817 .bdrv_io_unplug = raw_aio_unplug,
ed6e2161 2818 .bdrv_attach_aio_context = raw_aio_attach_aio_context,
3c529d93 2819
061ca8a3 2820 .bdrv_co_truncate = raw_co_truncate,
83f64091 2821 .bdrv_getlength = raw_getlength,
260a82e5 2822 .bdrv_get_info = raw_get_info,
4a1d5e1f
FZ
2823 .bdrv_get_allocated_file_size
2824 = raw_get_allocated_file_size,
244a5668
FZ
2825 .bdrv_check_perm = raw_check_perm,
2826 .bdrv_set_perm = raw_set_perm,
2827 .bdrv_abort_perm_update = raw_abort_perm_update,
6f482f74 2828 .create_opts = &raw_create_opts,
83f64091
FB
2829};
2830
19cb3738
FB
2831/***********************************************/
2832/* host device */
2833
83affaa6 2834#if defined(__APPLE__) && defined(__MACH__)
98caa5bc
JA
2835static kern_return_t GetBSDPath(io_iterator_t mediaIterator, char *bsdPath,
2836 CFIndex maxPathSize, int flags);
d0855f12 2837static char *FindEjectableOpticalMedia(io_iterator_t *mediaIterator)
19cb3738 2838{
d0855f12 2839 kern_return_t kernResult = KERN_FAILURE;
19cb3738
FB
2840 mach_port_t masterPort;
2841 CFMutableDictionaryRef classesToMatch;
d0855f12
JA
2842 const char *matching_array[] = {kIODVDMediaClass, kIOCDMediaClass};
2843 char *mediaType = NULL;
19cb3738
FB
2844
2845 kernResult = IOMasterPort( MACH_PORT_NULL, &masterPort );
2846 if ( KERN_SUCCESS != kernResult ) {
2847 printf( "IOMasterPort returned %d\n", kernResult );
2848 }
3b46e624 2849
d0855f12
JA
2850 int index;
2851 for (index = 0; index < ARRAY_SIZE(matching_array); index++) {
2852 classesToMatch = IOServiceMatching(matching_array[index]);
2853 if (classesToMatch == NULL) {
2854 error_report("IOServiceMatching returned NULL for %s",
2855 matching_array[index]);
2856 continue;
2857 }
2858 CFDictionarySetValue(classesToMatch, CFSTR(kIOMediaEjectableKey),
2859 kCFBooleanTrue);
2860 kernResult = IOServiceGetMatchingServices(masterPort, classesToMatch,
2861 mediaIterator);
2862 if (kernResult != KERN_SUCCESS) {
2863 error_report("Note: IOServiceGetMatchingServices returned %d",
2864 kernResult);
2865 continue;
2866 }
3b46e624 2867
d0855f12
JA
2868 /* If a match was found, leave the loop */
2869 if (*mediaIterator != 0) {
2870 DPRINTF("Matching using %s\n", matching_array[index]);
2871 mediaType = g_strdup(matching_array[index]);
2872 break;
2873 }
2874 }
2875 return mediaType;
19cb3738
FB
2876}
2877
98caa5bc
JA
2878kern_return_t GetBSDPath(io_iterator_t mediaIterator, char *bsdPath,
2879 CFIndex maxPathSize, int flags)
19cb3738
FB
2880{
2881 io_object_t nextMedia;
2882 kern_return_t kernResult = KERN_FAILURE;
2883 *bsdPath = '\0';
2884 nextMedia = IOIteratorNext( mediaIterator );
2885 if ( nextMedia )
2886 {
2887 CFTypeRef bsdPathAsCFString;
2888 bsdPathAsCFString = IORegistryEntryCreateCFProperty( nextMedia, CFSTR( kIOBSDNameKey ), kCFAllocatorDefault, 0 );
2889 if ( bsdPathAsCFString ) {
2890 size_t devPathLength;
2891 strcpy( bsdPath, _PATH_DEV );
98caa5bc
JA
2892 if (flags & BDRV_O_NOCACHE) {
2893 strcat(bsdPath, "r");
2894 }
19cb3738
FB
2895 devPathLength = strlen( bsdPath );
2896 if ( CFStringGetCString( bsdPathAsCFString, bsdPath + devPathLength, maxPathSize - devPathLength, kCFStringEncodingASCII ) ) {
2897 kernResult = KERN_SUCCESS;
2898 }
2899 CFRelease( bsdPathAsCFString );
2900 }
2901 IOObjectRelease( nextMedia );
2902 }
3b46e624 2903
19cb3738
FB
2904 return kernResult;
2905}
2906
d0855f12
JA
2907/* Sets up a real cdrom for use in QEMU */
2908static bool setup_cdrom(char *bsd_path, Error **errp)
2909{
2910 int index, num_of_test_partitions = 2, fd;
2911 char test_partition[MAXPATHLEN];
2912 bool partition_found = false;
2913
2914 /* look for a working partition */
2915 for (index = 0; index < num_of_test_partitions; index++) {
2916 snprintf(test_partition, sizeof(test_partition), "%ss%d", bsd_path,
2917 index);
2918 fd = qemu_open(test_partition, O_RDONLY | O_BINARY | O_LARGEFILE);
2919 if (fd >= 0) {
2920 partition_found = true;
2921 qemu_close(fd);
2922 break;
2923 }
2924 }
2925
2926 /* if a working partition on the device was not found */
2927 if (partition_found == false) {
2928 error_setg(errp, "Failed to find a working partition on disc");
2929 } else {
2930 DPRINTF("Using %s as optical disc\n", test_partition);
2931 pstrcpy(bsd_path, MAXPATHLEN, test_partition);
2932 }
2933 return partition_found;
2934}
2935
2936/* Prints directions on mounting and unmounting a device */
2937static void print_unmounting_directions(const char *file_name)
2938{
2939 error_report("If device %s is mounted on the desktop, unmount"
2940 " it first before using it in QEMU", file_name);
2941 error_report("Command to unmount device: diskutil unmountDisk %s",
2942 file_name);
2943 error_report("Command to mount device: diskutil mountDisk %s", file_name);
2944}
2945
2946#endif /* defined(__APPLE__) && defined(__MACH__) */
19cb3738 2947
508c7cb3
CH
2948static int hdev_probe_device(const char *filename)
2949{
2950 struct stat st;
2951
2952 /* allow a dedicated CD-ROM driver to match with a higher priority */
2953 if (strstart(filename, "/dev/cdrom", NULL))
2954 return 50;
2955
2956 if (stat(filename, &st) >= 0 &&
2957 (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode))) {
2958 return 100;
2959 }
2960
2961 return 0;
2962}
2963
da888d37
SH
2964static int check_hdev_writable(BDRVRawState *s)
2965{
2966#if defined(BLKROGET)
2967 /* Linux block devices can be configured "read-only" using blockdev(8).
2968 * This is independent of device node permissions and therefore open(2)
2969 * with O_RDWR succeeds. Actual writes fail with EPERM.
2970 *
2971 * bdrv_open() is supposed to fail if the disk is read-only. Explicitly
2972 * check for read-only block devices so that Linux block devices behave
2973 * properly.
2974 */
2975 struct stat st;
2976 int readonly = 0;
2977
2978 if (fstat(s->fd, &st)) {
2979 return -errno;
2980 }
2981
2982 if (!S_ISBLK(st.st_mode)) {
2983 return 0;
2984 }
2985
2986 if (ioctl(s->fd, BLKROGET, &readonly) < 0) {
2987 return -errno;
2988 }
2989
2990 if (readonly) {
2991 return -EACCES;
2992 }
2993#endif /* defined(BLKROGET) */
2994 return 0;
2995}
2996
7af803d4
HR
2997static void hdev_parse_filename(const char *filename, QDict *options,
2998 Error **errp)
2999{
03c320d8 3000 bdrv_parse_filename_strip_prefix(filename, "host_device:", options);
7af803d4
HR
3001}
3002
3307ed7b
DA
3003static bool hdev_is_sg(BlockDriverState *bs)
3004{
3005
3006#if defined(__linux__)
3007
0d4377b3 3008 BDRVRawState *s = bs->opaque;
3307ed7b
DA
3009 struct stat st;
3010 struct sg_scsi_id scsiid;
3011 int sg_version;
0d4377b3
KW
3012 int ret;
3013
3014 if (stat(bs->filename, &st) < 0 || !S_ISCHR(st.st_mode)) {
3015 return false;
3016 }
3307ed7b 3017
0d4377b3
KW
3018 ret = ioctl(s->fd, SG_GET_VERSION_NUM, &sg_version);
3019 if (ret < 0) {
3020 return false;
3021 }
3022
3023 ret = ioctl(s->fd, SG_GET_SCSI_ID, &scsiid);
3024 if (ret >= 0) {
3307ed7b
DA
3025 DPRINTF("SG device found: type=%d, version=%d\n",
3026 scsiid.scsi_type, sg_version);
3027 return true;
3028 }
3029
3030#endif
3031
3032 return false;
3033}
3034
015a1036
HR
3035static int hdev_open(BlockDriverState *bs, QDict *options, int flags,
3036 Error **errp)
19cb3738
FB
3037{
3038 BDRVRawState *s = bs->opaque;
e428e439 3039 Error *local_err = NULL;
da888d37 3040 int ret;
a76bab49 3041
83affaa6 3042#if defined(__APPLE__) && defined(__MACH__)
129c7d1c
MA
3043 /*
3044 * Caution: while qdict_get_str() is fine, getting non-string types
3045 * would require more care. When @options come from -blockdev or
3046 * blockdev_add, its members are typed according to the QAPI
3047 * schema, but when they come from -drive, they're all QString.
3048 */
3307ed7b 3049 const char *filename = qdict_get_str(options, "filename");
d0855f12
JA
3050 char bsd_path[MAXPATHLEN] = "";
3051 bool error_occurred = false;
3052
3053 /* If using a real cdrom */
3054 if (strcmp(filename, "/dev/cdrom") == 0) {
3055 char *mediaType = NULL;
3056 kern_return_t ret_val;
3057 io_iterator_t mediaIterator = 0;
3058
3059 mediaType = FindEjectableOpticalMedia(&mediaIterator);
3060 if (mediaType == NULL) {
3061 error_setg(errp, "Please make sure your CD/DVD is in the optical"
3062 " drive");
3063 error_occurred = true;
3064 goto hdev_open_Mac_error;
3065 }
3307ed7b 3066
d0855f12
JA
3067 ret_val = GetBSDPath(mediaIterator, bsd_path, sizeof(bsd_path), flags);
3068 if (ret_val != KERN_SUCCESS) {
3069 error_setg(errp, "Could not get BSD path for optical drive");
3070 error_occurred = true;
3071 goto hdev_open_Mac_error;
3072 }
3073
3074 /* If a real optical drive was not found */
3075 if (bsd_path[0] == '\0') {
3076 error_setg(errp, "Failed to obtain bsd path for optical drive");
3077 error_occurred = true;
3078 goto hdev_open_Mac_error;
3079 }
3080
3081 /* If using a cdrom disc and finding a partition on the disc failed */
3082 if (strncmp(mediaType, kIOCDMediaClass, 9) == 0 &&
3083 setup_cdrom(bsd_path, errp) == false) {
3084 print_unmounting_directions(bsd_path);
3085 error_occurred = true;
3086 goto hdev_open_Mac_error;
19cb3738 3087 }
3b46e624 3088
46f5ac20 3089 qdict_put_str(options, "filename", bsd_path);
d0855f12
JA
3090
3091hdev_open_Mac_error:
3092 g_free(mediaType);
3093 if (mediaIterator) {
3094 IOObjectRelease(mediaIterator);
3095 }
3096 if (error_occurred) {
3097 return -ENOENT;
3098 }
19cb3738 3099 }
d0855f12 3100#endif /* defined(__APPLE__) && defined(__MACH__) */
19cb3738
FB
3101
3102 s->type = FTYPE_FILE;
90babde0 3103
230ff739 3104 ret = raw_open_common(bs, options, flags, 0, true, &local_err);
da888d37 3105 if (ret < 0) {
621ff94d 3106 error_propagate(errp, local_err);
d0855f12
JA
3107#if defined(__APPLE__) && defined(__MACH__)
3108 if (*bsd_path) {
3109 filename = bsd_path;
3110 }
3111 /* if a physical device experienced an error while being opened */
3112 if (strncmp(filename, "/dev/", 5) == 0) {
3113 print_unmounting_directions(filename);
3114 }
3115#endif /* defined(__APPLE__) && defined(__MACH__) */
da888d37
SH
3116 return ret;
3117 }
3118
3307ed7b
DA
3119 /* Since this does ioctl the device must be already opened */
3120 bs->sg = hdev_is_sg(bs);
3121
da888d37
SH
3122 if (flags & BDRV_O_RDWR) {
3123 ret = check_hdev_writable(s);
3124 if (ret < 0) {
3125 raw_close(bs);
e428e439 3126 error_setg_errno(errp, -ret, "The device is not writable");
da888d37
SH
3127 return ret;
3128 }
3129 }
3130
3131 return ret;
19cb3738
FB
3132}
3133
03ff3ca3 3134#if defined(__linux__)
221f715d 3135
7c84b1b8 3136static BlockAIOCB *hdev_aio_ioctl(BlockDriverState *bs,
221f715d 3137 unsigned long int req, void *buf,
097310b5 3138 BlockCompletionFunc *cb, void *opaque)
221f715d 3139{
f141eafe 3140 BDRVRawState *s = bs->opaque;
c208e8c2 3141 RawPosixAIOData *acb;
c4d9d196 3142 ThreadPool *pool;
221f715d 3143
f141eafe
AL
3144 if (fd_open(bs) < 0)
3145 return NULL;
c208e8c2 3146
7c9e5276
PB
3147 if (req == SG_IO && s->pr_mgr) {
3148 struct sg_io_hdr *io_hdr = buf;
3149 if (io_hdr->cmdp[0] == PERSISTENT_RESERVE_OUT ||
3150 io_hdr->cmdp[0] == PERSISTENT_RESERVE_IN) {
3151 return pr_manager_execute(s->pr_mgr, bdrv_get_aio_context(bs),
3152 s->fd, io_hdr, cb, opaque);
3153 }
3154 }
3155
c84b3192 3156 acb = g_new(RawPosixAIOData, 1);
c208e8c2
PB
3157 acb->bs = bs;
3158 acb->aio_type = QEMU_AIO_IOCTL;
3159 acb->aio_fildes = s->fd;
3160 acb->aio_offset = 0;
d57c44d0
KW
3161 acb->ioctl.buf = buf;
3162 acb->ioctl.cmd = req;
c4d9d196
SH
3163 pool = aio_get_thread_pool(bdrv_get_aio_context(bs));
3164 return thread_pool_submit_aio(pool, aio_worker, acb, cb, opaque);
221f715d 3165}
f709623b 3166#endif /* linux */
221f715d 3167
9f23011a
BS
3168static int fd_open(BlockDriverState *bs)
3169{
3170 BDRVRawState *s = bs->opaque;
3171
3172 /* this is just to ensure s->fd is sane (its called by io ops) */
3173 if (s->fd >= 0)
3174 return 0;
3175 return -EIO;
3176}
04eeb8b6 3177
33d70fb6
KW
3178static coroutine_fn int
3179hdev_co_pdiscard(BlockDriverState *bs, int64_t offset, int bytes)
c36dd8a0 3180{
33d70fb6 3181 int ret;
c36dd8a0 3182
33d70fb6
KW
3183 ret = fd_open(bs);
3184 if (ret < 0) {
3185 return ret;
c36dd8a0 3186 }
46ee0f46 3187 return raw_do_pdiscard(bs, offset, bytes, true);
c36dd8a0
AF
3188}
3189
2ffa76c2 3190static coroutine_fn int hdev_co_pwrite_zeroes(BlockDriverState *bs,
f5a5ca79 3191 int64_t offset, int bytes, BdrvRequestFlags flags)
d0b4503e 3192{
d0b4503e
PB
3193 int rc;
3194
3195 rc = fd_open(bs);
3196 if (rc < 0) {
3197 return rc;
3198 }
34fa110e 3199
7154d8ae 3200 return raw_do_pwrite_zeroes(bs, offset, bytes, flags, true);
d0b4503e
PB
3201}
3202
efc75e2a
SH
3203static int coroutine_fn hdev_co_create_opts(const char *filename, QemuOpts *opts,
3204 Error **errp)
93c65b47
AL
3205{
3206 int fd;
3207 int ret = 0;
3208 struct stat stat_buf;
0e7e1989 3209 int64_t total_size = 0;
cc28c6aa
HR
3210 bool has_prefix;
3211
f709623b
HR
3212 /* This function is used by both protocol block drivers and therefore either
3213 * of these prefixes may be given.
cc28c6aa
HR
3214 * The return value has to be stored somewhere, otherwise this is an error
3215 * due to -Werror=unused-value. */
3216 has_prefix =
3217 strstart(filename, "host_device:", &filename) ||
f709623b 3218 strstart(filename, "host_cdrom:" , &filename);
cc28c6aa
HR
3219
3220 (void)has_prefix;
93c65b47 3221
db0754df 3222 ret = raw_normalize_devicepath(&filename, errp);
bdd03cdf 3223 if (ret < 0) {
bdd03cdf
HR
3224 return ret;
3225 }
3226
0e7e1989 3227 /* Read out options */
180e9526
HT
3228 total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
3229 BDRV_SECTOR_SIZE);
93c65b47 3230
6165f4d8 3231 fd = qemu_open(filename, O_WRONLY | O_BINARY);
e428e439
HR
3232 if (fd < 0) {
3233 ret = -errno;
3234 error_setg_errno(errp, -ret, "Could not open device");
3235 return ret;
3236 }
93c65b47 3237
e428e439 3238 if (fstat(fd, &stat_buf) < 0) {
57e69b7d 3239 ret = -errno;
e428e439
HR
3240 error_setg_errno(errp, -ret, "Could not stat device");
3241 } else if (!S_ISBLK(stat_buf.st_mode) && !S_ISCHR(stat_buf.st_mode)) {
3242 error_setg(errp,
3243 "The given file is neither a block nor a character device");
57e69b7d 3244 ret = -ENODEV;
180e9526 3245 } else if (lseek(fd, 0, SEEK_END) < total_size) {
e428e439 3246 error_setg(errp, "Device is too small");
93c65b47 3247 ret = -ENOSPC;
e428e439 3248 }
93c65b47 3249
97ec9117
FZ
3250 if (!ret && total_size) {
3251 uint8_t buf[BDRV_SECTOR_SIZE] = { 0 };
3252 int64_t zero_size = MIN(BDRV_SECTOR_SIZE, total_size);
3253 if (lseek(fd, 0, SEEK_SET) == -1) {
3254 ret = -errno;
3255 } else {
3256 ret = qemu_write_full(fd, buf, zero_size);
3257 ret = ret == zero_size ? 0 : -errno;
3258 }
3259 }
2e1e79da 3260 qemu_close(fd);
93c65b47
AL
3261 return ret;
3262}
3263
5efa9d5a 3264static BlockDriver bdrv_host_device = {
0b4ce02e 3265 .format_name = "host_device",
84a12e66 3266 .protocol_name = "host_device",
0b4ce02e 3267 .instance_size = sizeof(BDRVRawState),
030be321 3268 .bdrv_needs_filename = true,
0b4ce02e 3269 .bdrv_probe_device = hdev_probe_device,
7af803d4 3270 .bdrv_parse_filename = hdev_parse_filename,
66f82cee 3271 .bdrv_file_open = hdev_open,
0b4ce02e 3272 .bdrv_close = raw_close,
1bc6b705
JC
3273 .bdrv_reopen_prepare = raw_reopen_prepare,
3274 .bdrv_reopen_commit = raw_reopen_commit,
3275 .bdrv_reopen_abort = raw_reopen_abort,
efc75e2a 3276 .bdrv_co_create_opts = hdev_co_create_opts,
6f482f74 3277 .create_opts = &raw_create_opts,
dd577a26 3278 .bdrv_co_invalidate_cache = raw_co_invalidate_cache,
2ffa76c2 3279 .bdrv_co_pwrite_zeroes = hdev_co_pwrite_zeroes,
3b46e624 3280
9d52aa3c
KW
3281 .bdrv_co_preadv = raw_co_preadv,
3282 .bdrv_co_pwritev = raw_co_pwritev,
33d70fb6
KW
3283 .bdrv_co_flush_to_disk = raw_co_flush_to_disk,
3284 .bdrv_co_pdiscard = hdev_co_pdiscard,
1efad060
FZ
3285 .bdrv_co_copy_range_from = raw_co_copy_range_from,
3286 .bdrv_co_copy_range_to = raw_co_copy_range_to,
c25f53b0 3287 .bdrv_refresh_limits = raw_refresh_limits,
1b3abdcc
ML
3288 .bdrv_io_plug = raw_aio_plug,
3289 .bdrv_io_unplug = raw_aio_unplug,
042b757c 3290 .bdrv_attach_aio_context = raw_aio_attach_aio_context,
3c529d93 3291
061ca8a3 3292 .bdrv_co_truncate = raw_co_truncate,
e60f469c 3293 .bdrv_getlength = raw_getlength,
260a82e5 3294 .bdrv_get_info = raw_get_info,
4a1d5e1f
FZ
3295 .bdrv_get_allocated_file_size
3296 = raw_get_allocated_file_size,
244a5668
FZ
3297 .bdrv_check_perm = raw_check_perm,
3298 .bdrv_set_perm = raw_set_perm,
3299 .bdrv_abort_perm_update = raw_abort_perm_update,
1a9335e4
ET
3300 .bdrv_probe_blocksizes = hdev_probe_blocksizes,
3301 .bdrv_probe_geometry = hdev_probe_geometry,
19cb3738 3302
f3a5d3f8 3303 /* generic scsi device */
63ec93db 3304#ifdef __linux__
63ec93db
CH
3305 .bdrv_aio_ioctl = hdev_aio_ioctl,
3306#endif
f3a5d3f8
CH
3307};
3308
18fa1c42
HR
3309#if defined(__linux__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
3310static void cdrom_parse_filename(const char *filename, QDict *options,
3311 Error **errp)
3312{
03c320d8 3313 bdrv_parse_filename_strip_prefix(filename, "host_cdrom:", options);
18fa1c42
HR
3314}
3315#endif
3316
3317#ifdef __linux__
015a1036
HR
3318static int cdrom_open(BlockDriverState *bs, QDict *options, int flags,
3319 Error **errp)
f3a5d3f8
CH
3320{
3321 BDRVRawState *s = bs->opaque;
3322
f3a5d3f8
CH
3323 s->type = FTYPE_CD;
3324
19a3da7f 3325 /* open will not fail even if no CD is inserted, so add O_NONBLOCK */
230ff739 3326 return raw_open_common(bs, options, flags, O_NONBLOCK, true, errp);
f3a5d3f8
CH
3327}
3328
508c7cb3
CH
3329static int cdrom_probe_device(const char *filename)
3330{
3baf720e
CR
3331 int fd, ret;
3332 int prio = 0;
343f8568 3333 struct stat st;
3baf720e 3334
6165f4d8 3335 fd = qemu_open(filename, O_RDONLY | O_NONBLOCK);
3baf720e
CR
3336 if (fd < 0) {
3337 goto out;
3338 }
343f8568
JS
3339 ret = fstat(fd, &st);
3340 if (ret == -1 || !S_ISBLK(st.st_mode)) {
3341 goto outc;
3342 }
3baf720e
CR
3343
3344 /* Attempt to detect via a CDROM specific ioctl */
3345 ret = ioctl(fd, CDROM_DRIVE_STATUS, CDSL_CURRENT);
3346 if (ret >= 0)
3347 prio = 100;
3348
343f8568 3349outc:
2e1e79da 3350 qemu_close(fd);
3baf720e
CR
3351out:
3352 return prio;
508c7cb3
CH
3353}
3354
e031f750 3355static bool cdrom_is_inserted(BlockDriverState *bs)
f3a5d3f8
CH
3356{
3357 BDRVRawState *s = bs->opaque;
3358 int ret;
3359
3360 ret = ioctl(s->fd, CDROM_DRIVE_STATUS, CDSL_CURRENT);
e031f750 3361 return ret == CDS_DISC_OK;
f3a5d3f8
CH
3362}
3363
f36f3949 3364static void cdrom_eject(BlockDriverState *bs, bool eject_flag)
f3a5d3f8
CH
3365{
3366 BDRVRawState *s = bs->opaque;
3367
3368 if (eject_flag) {
3369 if (ioctl(s->fd, CDROMEJECT, NULL) < 0)
3370 perror("CDROMEJECT");
3371 } else {
3372 if (ioctl(s->fd, CDROMCLOSETRAY, NULL) < 0)
3373 perror("CDROMEJECT");
3374 }
f3a5d3f8
CH
3375}
3376
025e849a 3377static void cdrom_lock_medium(BlockDriverState *bs, bool locked)
f3a5d3f8
CH
3378{
3379 BDRVRawState *s = bs->opaque;
3380
3381 if (ioctl(s->fd, CDROM_LOCKDOOR, locked) < 0) {
3382 /*
3383 * Note: an error can happen if the distribution automatically
3384 * mounts the CD-ROM
3385 */
3386 /* perror("CDROM_LOCKDOOR"); */
3387 }
f3a5d3f8
CH
3388}
3389
3390static BlockDriver bdrv_host_cdrom = {
3391 .format_name = "host_cdrom",
84a12e66 3392 .protocol_name = "host_cdrom",
f3a5d3f8 3393 .instance_size = sizeof(BDRVRawState),
030be321 3394 .bdrv_needs_filename = true,
508c7cb3 3395 .bdrv_probe_device = cdrom_probe_device,
18fa1c42 3396 .bdrv_parse_filename = cdrom_parse_filename,
66f82cee 3397 .bdrv_file_open = cdrom_open,
f3a5d3f8 3398 .bdrv_close = raw_close,
1bc6b705
JC
3399 .bdrv_reopen_prepare = raw_reopen_prepare,
3400 .bdrv_reopen_commit = raw_reopen_commit,
3401 .bdrv_reopen_abort = raw_reopen_abort,
efc75e2a 3402 .bdrv_co_create_opts = hdev_co_create_opts,
6f482f74 3403 .create_opts = &raw_create_opts,
dd577a26 3404 .bdrv_co_invalidate_cache = raw_co_invalidate_cache,
f3a5d3f8 3405
9d52aa3c
KW
3406
3407 .bdrv_co_preadv = raw_co_preadv,
3408 .bdrv_co_pwritev = raw_co_pwritev,
33d70fb6 3409 .bdrv_co_flush_to_disk = raw_co_flush_to_disk,
c25f53b0 3410 .bdrv_refresh_limits = raw_refresh_limits,
1b3abdcc
ML
3411 .bdrv_io_plug = raw_aio_plug,
3412 .bdrv_io_unplug = raw_aio_unplug,
042b757c 3413 .bdrv_attach_aio_context = raw_aio_attach_aio_context,
f3a5d3f8 3414
061ca8a3 3415 .bdrv_co_truncate = raw_co_truncate,
b94a2610
KW
3416 .bdrv_getlength = raw_getlength,
3417 .has_variable_length = true,
4a1d5e1f
FZ
3418 .bdrv_get_allocated_file_size
3419 = raw_get_allocated_file_size,
f3a5d3f8
CH
3420
3421 /* removable device support */
3422 .bdrv_is_inserted = cdrom_is_inserted,
3423 .bdrv_eject = cdrom_eject,
025e849a 3424 .bdrv_lock_medium = cdrom_lock_medium,
f3a5d3f8
CH
3425
3426 /* generic scsi device */
63ec93db 3427 .bdrv_aio_ioctl = hdev_aio_ioctl,
f3a5d3f8
CH
3428};
3429#endif /* __linux__ */
3430
a167ba50 3431#if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
511018e4
AT
3432static int cdrom_open(BlockDriverState *bs, QDict *options, int flags,
3433 Error **errp)
f3a5d3f8
CH
3434{
3435 BDRVRawState *s = bs->opaque;
e428e439 3436 Error *local_err = NULL;
f3a5d3f8
CH
3437 int ret;
3438
3439 s->type = FTYPE_CD;
3440
230ff739 3441 ret = raw_open_common(bs, options, flags, 0, true, &local_err);
e428e439 3442 if (ret) {
621ff94d 3443 error_propagate(errp, local_err);
f3a5d3f8 3444 return ret;
e428e439 3445 }
f3a5d3f8 3446
9b2260cb 3447 /* make sure the door isn't locked at this time */
f3a5d3f8
CH
3448 ioctl(s->fd, CDIOCALLOW);
3449 return 0;
3450}
3451
508c7cb3
CH
3452static int cdrom_probe_device(const char *filename)
3453{
3454 if (strstart(filename, "/dev/cd", NULL) ||
3455 strstart(filename, "/dev/acd", NULL))
3456 return 100;
3457 return 0;
3458}
3459
f3a5d3f8
CH
3460static int cdrom_reopen(BlockDriverState *bs)
3461{
3462 BDRVRawState *s = bs->opaque;
3463 int fd;
3464
3465 /*
3466 * Force reread of possibly changed/newly loaded disc,
3467 * FreeBSD seems to not notice sometimes...
3468 */
3469 if (s->fd >= 0)
2e1e79da 3470 qemu_close(s->fd);
6165f4d8 3471 fd = qemu_open(bs->filename, s->open_flags, 0644);
f3a5d3f8
CH
3472 if (fd < 0) {
3473 s->fd = -1;
3474 return -EIO;
3475 }
3476 s->fd = fd;
3477
9b2260cb 3478 /* make sure the door isn't locked at this time */
f3a5d3f8
CH
3479 ioctl(s->fd, CDIOCALLOW);
3480 return 0;
3481}
3482
e031f750 3483static bool cdrom_is_inserted(BlockDriverState *bs)
f3a5d3f8
CH
3484{
3485 return raw_getlength(bs) > 0;
3486}
3487
f36f3949 3488static void cdrom_eject(BlockDriverState *bs, bool eject_flag)
f3a5d3f8
CH
3489{
3490 BDRVRawState *s = bs->opaque;
3491
3492 if (s->fd < 0)
822e1cd1 3493 return;
f3a5d3f8
CH
3494
3495 (void) ioctl(s->fd, CDIOCALLOW);
3496
3497 if (eject_flag) {
3498 if (ioctl(s->fd, CDIOCEJECT) < 0)
3499 perror("CDIOCEJECT");
3500 } else {
3501 if (ioctl(s->fd, CDIOCCLOSE) < 0)
3502 perror("CDIOCCLOSE");
3503 }
3504
822e1cd1 3505 cdrom_reopen(bs);
f3a5d3f8
CH
3506}
3507
025e849a 3508static void cdrom_lock_medium(BlockDriverState *bs, bool locked)
f3a5d3f8
CH
3509{
3510 BDRVRawState *s = bs->opaque;
3511
3512 if (s->fd < 0)
7bf37fed 3513 return;
f3a5d3f8
CH
3514 if (ioctl(s->fd, (locked ? CDIOCPREVENT : CDIOCALLOW)) < 0) {
3515 /*
3516 * Note: an error can happen if the distribution automatically
3517 * mounts the CD-ROM
3518 */
3519 /* perror("CDROM_LOCKDOOR"); */
3520 }
f3a5d3f8
CH
3521}
3522
3523static BlockDriver bdrv_host_cdrom = {
3524 .format_name = "host_cdrom",
84a12e66 3525 .protocol_name = "host_cdrom",
f3a5d3f8 3526 .instance_size = sizeof(BDRVRawState),
030be321 3527 .bdrv_needs_filename = true,
508c7cb3 3528 .bdrv_probe_device = cdrom_probe_device,
18fa1c42 3529 .bdrv_parse_filename = cdrom_parse_filename,
66f82cee 3530 .bdrv_file_open = cdrom_open,
f3a5d3f8 3531 .bdrv_close = raw_close,
1bc6b705
JC
3532 .bdrv_reopen_prepare = raw_reopen_prepare,
3533 .bdrv_reopen_commit = raw_reopen_commit,
3534 .bdrv_reopen_abort = raw_reopen_abort,
efc75e2a 3535 .bdrv_co_create_opts = hdev_co_create_opts,
6f482f74 3536 .create_opts = &raw_create_opts,
f3a5d3f8 3537
9d52aa3c
KW
3538 .bdrv_co_preadv = raw_co_preadv,
3539 .bdrv_co_pwritev = raw_co_pwritev,
33d70fb6 3540 .bdrv_co_flush_to_disk = raw_co_flush_to_disk,
c25f53b0 3541 .bdrv_refresh_limits = raw_refresh_limits,
1b3abdcc
ML
3542 .bdrv_io_plug = raw_aio_plug,
3543 .bdrv_io_unplug = raw_aio_unplug,
042b757c 3544 .bdrv_attach_aio_context = raw_aio_attach_aio_context,
f3a5d3f8 3545
061ca8a3 3546 .bdrv_co_truncate = raw_co_truncate,
b94a2610
KW
3547 .bdrv_getlength = raw_getlength,
3548 .has_variable_length = true,
4a1d5e1f
FZ
3549 .bdrv_get_allocated_file_size
3550 = raw_get_allocated_file_size,
f3a5d3f8 3551
19cb3738 3552 /* removable device support */
f3a5d3f8
CH
3553 .bdrv_is_inserted = cdrom_is_inserted,
3554 .bdrv_eject = cdrom_eject,
025e849a 3555 .bdrv_lock_medium = cdrom_lock_medium,
19cb3738 3556};
f3a5d3f8 3557#endif /* __FreeBSD__ */
5efa9d5a 3558
84a12e66 3559static void bdrv_file_init(void)
5efa9d5a 3560{
508c7cb3
CH
3561 /*
3562 * Register all the drivers. Note that order is important, the driver
3563 * registered last will get probed first.
3564 */
84a12e66 3565 bdrv_register(&bdrv_file);
5efa9d5a 3566 bdrv_register(&bdrv_host_device);
f3a5d3f8 3567#ifdef __linux__
f3a5d3f8
CH
3568 bdrv_register(&bdrv_host_cdrom);
3569#endif
a167ba50 3570#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
f3a5d3f8
CH
3571 bdrv_register(&bdrv_host_cdrom);
3572#endif
5efa9d5a
AL
3573}
3574
84a12e66 3575block_init(bdrv_file_init);