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