1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25#include "qemu/osdep.h"
26#include "qapi/error.h"
27#include "qemu/cutils.h"
28#include "qemu/error-report.h"
29#include "block/block-io.h"
30#include "block/block_int.h"
31#include "qemu/module.h"
32#include "qemu/option.h"
33#include "qemu/units.h"
34#include "qemu/memalign.h"
35#include "trace.h"
36#include "block/thread-pool.h"
37#include "qemu/iov.h"
38#include "block/raw-aio.h"
39#include "qapi/qmp/qdict.h"
40#include "qapi/qmp/qstring.h"
41
42#include "scsi/pr-manager.h"
43#include "scsi/constants.h"
44
45#if defined(__APPLE__) && (__MACH__)
46#include <sys/ioctl.h>
47#if defined(HAVE_HOST_BLOCK_DEVICE)
48#include <paths.h>
49#include <sys/param.h>
50#include <sys/mount.h>
51#include <IOKit/IOKitLib.h>
52#include <IOKit/IOBSD.h>
53#include <IOKit/storage/IOMediaBSDClient.h>
54#include <IOKit/storage/IOMedia.h>
55#include <IOKit/storage/IOCDMedia.h>
56
57#include <IOKit/storage/IODVDMedia.h>
58#include <CoreFoundation/CoreFoundation.h>
59#endif
60#endif
61
62#ifdef __sun__
63#define _POSIX_PTHREAD_SEMANTICS 1
64#include <sys/dkio.h>
65#endif
66#ifdef __linux__
67#include <sys/ioctl.h>
68#include <sys/param.h>
69#include <sys/syscall.h>
70#include <sys/vfs.h>
71#if defined(CONFIG_BLKZONED)
72#include <linux/blkzoned.h>
73#endif
74#include <linux/cdrom.h>
75#include <linux/fd.h>
76#include <linux/fs.h>
77#include <linux/hdreg.h>
78#include <linux/magic.h>
79#include <scsi/sg.h>
80#ifdef __s390__
81#include <asm/dasd.h>
82#endif
83#ifndef FS_NOCOW_FL
84#define FS_NOCOW_FL 0x00800000
85#endif
86#endif
87#if defined(CONFIG_FALLOCATE_PUNCH_HOLE) || defined(CONFIG_FALLOCATE_ZERO_RANGE)
88#include <linux/falloc.h>
89#endif
90#if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
91#include <sys/disk.h>
92#include <sys/cdio.h>
93#endif
94
95#ifdef __OpenBSD__
96#include <sys/ioctl.h>
97#include <sys/disklabel.h>
98#include <sys/dkio.h>
99#endif
100
101#ifdef __NetBSD__
102#include <sys/ioctl.h>
103#include <sys/disklabel.h>
104#include <sys/dkio.h>
105#include <sys/disk.h>
106#endif
107
108#ifdef __DragonFly__
109#include <sys/ioctl.h>
110#include <sys/diskslice.h>
111#endif
112
113
114#ifndef O_DSYNC
115#ifdef O_SYNC
116#define O_DSYNC O_SYNC
117#elif defined(O_FSYNC)
118#define O_DSYNC O_FSYNC
119#endif
120#endif
121
122
123#ifndef O_DIRECT
124#define O_DIRECT O_DSYNC
125#endif
126
127#define FTYPE_FILE 0
128#define FTYPE_CD 1
129
130#define MAX_BLOCKSIZE 4096
131
132
133
134#define RAW_LOCK_PERM_BASE 100
135#define RAW_LOCK_SHARED_BASE 200
136
137typedef struct BDRVRawState {
138 int fd;
139 bool use_lock;
140 int type;
141 int open_flags;
142 size_t buf_align;
143
144
145 uint64_t perm;
146 uint64_t shared_perm;
147
148
149
150 uint64_t locked_perm;
151 uint64_t locked_shared_perm;
152
153 uint64_t aio_max_batch;
154
155 int perm_change_fd;
156 int perm_change_flags;
157 BDRVReopenState *reopen_state;
158
159 bool has_discard:1;
160 bool has_write_zeroes:1;
161 bool use_linux_aio:1;
162 bool use_linux_io_uring:1;
163 int64_t *offset;
164 int page_cache_inconsistent;
165 bool has_fallocate;
166 bool needs_alignment;
167 bool force_alignment;
168 bool drop_cache;
169 bool check_cache_dropped;
170 struct {
171 uint64_t discard_nb_ok;
172 uint64_t discard_nb_failed;
173 uint64_t discard_bytes_ok;
174 } stats;
175
176 PRManager *pr_mgr;
177} BDRVRawState;
178
179typedef struct BDRVRawReopenState {
180 int open_flags;
181 bool drop_cache;
182 bool check_cache_dropped;
183} BDRVRawReopenState;
184
185static int fd_open(BlockDriverState *bs)
186{
187 BDRVRawState *s = bs->opaque;
188
189
190 if (s->fd >= 0) {
191 return 0;
192 }
193 return -EIO;
194}
195
196static int64_t raw_getlength(BlockDriverState *bs);
197
198typedef struct RawPosixAIOData {
199 BlockDriverState *bs;
200 int aio_type;
201 int aio_fildes;
202
203 off_t aio_offset;
204 uint64_t aio_nbytes;
205
206 union {
207 struct {
208 struct iovec *iov;
209 int niov;
210 } io;
211 struct {
212 uint64_t cmd;
213 void *buf;
214 } ioctl;
215 struct {
216 int aio_fd2;
217 off_t aio_offset2;
218 } copy_range;
219 struct {
220 PreallocMode prealloc;
221 Error **errp;
222 } truncate;
223 struct {
224 unsigned int *nr_zones;
225 BlockZoneDescriptor *zones;
226 } zone_report;
227 struct {
228 unsigned long op;
229 } zone_mgmt;
230 };
231} RawPosixAIOData;
232
233#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
234static int cdrom_reopen(BlockDriverState *bs);
235#endif
236
237
238
239
240
241
242#define raw_lock_error_setg_errno(errp, err, fmt, ...) \
243 do { \
244 if ((err) == EAGAIN || (err) == EACCES) { \
245 error_setg((errp), (fmt), ## __VA_ARGS__); \
246 } else { \
247 error_setg_errno((errp), (err), (fmt), ## __VA_ARGS__); \
248 } \
249 } while (0)
250
251#if defined(__NetBSD__)
252static int raw_normalize_devicepath(const char **filename, Error **errp)
253{
254 static char namebuf[PATH_MAX];
255 const char *dp, *fname;
256 struct stat sb;
257
258 fname = *filename;
259 dp = strrchr(fname, '/');
260 if (lstat(fname, &sb) < 0) {
261 error_setg_file_open(errp, errno, fname);
262 return -errno;
263 }
264
265 if (!S_ISBLK(sb.st_mode)) {
266 return 0;
267 }
268
269 if (dp == NULL) {
270 snprintf(namebuf, PATH_MAX, "r%s", fname);
271 } else {
272 snprintf(namebuf, PATH_MAX, "%.*s/r%s",
273 (int)(dp - fname), fname, dp + 1);
274 }
275 *filename = namebuf;
276 warn_report("%s is a block device, using %s", fname, *filename);
277
278 return 0;
279}
280#else
281static int raw_normalize_devicepath(const char **filename, Error **errp)
282{
283 return 0;
284}
285#endif
286
287
288
289
290static int probe_logical_blocksize(int fd, unsigned int *sector_size_p)
291{
292 unsigned int sector_size;
293 bool success = false;
294 int i;
295
296 errno = ENOTSUP;
297 static const unsigned long ioctl_list[] = {
298#ifdef BLKSSZGET
299 BLKSSZGET,
300#endif
301#ifdef DKIOCGETBLOCKSIZE
302 DKIOCGETBLOCKSIZE,
303#endif
304#ifdef DIOCGSECTORSIZE
305 DIOCGSECTORSIZE,
306#endif
307 };
308
309
310 for (i = 0; i < (int)ARRAY_SIZE(ioctl_list); i++) {
311 if (ioctl(fd, ioctl_list[i], §or_size) >= 0) {
312 *sector_size_p = sector_size;
313 success = true;
314 }
315 }
316
317 return success ? 0 : -errno;
318}
319
320
321
322
323
324
325static int probe_physical_blocksize(int fd, unsigned int *blk_size)
326{
327#ifdef BLKPBSZGET
328 if (ioctl(fd, BLKPBSZGET, blk_size) < 0) {
329 return -errno;
330 }
331 return 0;
332#else
333 return -ENOTSUP;
334#endif
335}
336
337
338
339
340
341
342
343
344
345static bool dio_byte_aligned(int fd)
346{
347#ifdef __linux__
348 struct statfs buf;
349 int ret;
350
351 ret = fstatfs(fd, &buf);
352 if (ret == 0 && buf.f_type == NFS_SUPER_MAGIC) {
353 return true;
354 }
355#endif
356 return false;
357}
358
359static bool raw_needs_alignment(BlockDriverState *bs)
360{
361 BDRVRawState *s = bs->opaque;
362
363 if ((bs->open_flags & BDRV_O_NOCACHE) != 0 && !dio_byte_aligned(s->fd)) {
364 return true;
365 }
366
367 return s->force_alignment;
368}
369
370
371
372
373
374static bool raw_is_io_aligned(int fd, void *buf, size_t len)
375{
376 ssize_t ret = pread(fd, buf, len, 0);
377
378 if (ret >= 0) {
379 return true;
380 }
381
382#ifdef __linux__
383
384
385
386
387 if (errno != EINVAL) {
388 return true;
389 }
390#endif
391
392 return false;
393}
394
395static void raw_probe_alignment(BlockDriverState *bs, int fd, Error **errp)
396{
397 BDRVRawState *s = bs->opaque;
398 char *buf;
399 size_t max_align = MAX(MAX_BLOCKSIZE, qemu_real_host_page_size());
400 size_t alignments[] = {1, 512, 1024, 2048, 4096};
401
402
403
404 if (bdrv_is_sg(bs) || !s->needs_alignment) {
405 bs->bl.request_alignment = 1;
406 s->buf_align = 1;
407 return;
408 }
409
410 bs->bl.request_alignment = 0;
411 s->buf_align = 0;
412
413 if (probe_logical_blocksize(fd, &bs->bl.request_alignment) < 0) {
414 bs->bl.request_alignment = 0;
415 }
416
417#ifdef __linux__
418
419
420
421
422
423 struct xfs_dioattr {
424 uint32_t d_mem;
425 uint32_t d_miniosz;
426 uint32_t d_maxiosz;
427 } da;
428 if (ioctl(fd, _IOR('X', 30, struct xfs_dioattr), &da) >= 0) {
429 bs->bl.request_alignment = da.d_miniosz;
430
431
432 }
433#endif
434
435
436
437
438
439
440
441
442
443 if (!bs->bl.request_alignment) {
444 int i;
445 size_t align;
446 buf = qemu_memalign(max_align, max_align);
447 for (i = 0; i < ARRAY_SIZE(alignments); i++) {
448 align = alignments[i];
449 if (raw_is_io_aligned(fd, buf, align)) {
450
451 bs->bl.request_alignment = (align != 1) ? align : max_align;
452 break;
453 }
454 }
455 qemu_vfree(buf);
456 }
457
458 if (!s->buf_align) {
459 int i;
460 size_t align;
461 buf = qemu_memalign(max_align, 2 * max_align);
462 for (i = 0; i < ARRAY_SIZE(alignments); i++) {
463 align = alignments[i];
464 if (raw_is_io_aligned(fd, buf + align, max_align)) {
465
466 s->buf_align = (align != 1) ? align : bs->bl.request_alignment;
467 break;
468 }
469 }
470 qemu_vfree(buf);
471 }
472
473 if (!s->buf_align || !bs->bl.request_alignment) {
474 error_setg(errp, "Could not find working O_DIRECT alignment");
475 error_append_hint(errp, "Try cache.direct=off\n");
476 }
477}
478
479static int check_hdev_writable(int fd)
480{
481#if defined(BLKROGET)
482
483
484
485
486
487
488
489
490 struct stat st;
491 int readonly = 0;
492
493 if (fstat(fd, &st)) {
494 return -errno;
495 }
496
497 if (!S_ISBLK(st.st_mode)) {
498 return 0;
499 }
500
501 if (ioctl(fd, BLKROGET, &readonly) < 0) {
502 return -errno;
503 }
504
505 if (readonly) {
506 return -EACCES;
507 }
508#endif
509 return 0;
510}
511
512static void raw_parse_flags(int bdrv_flags, int *open_flags, bool has_writers)
513{
514 bool read_write = false;
515 assert(open_flags != NULL);
516
517 *open_flags |= O_BINARY;
518 *open_flags &= ~O_ACCMODE;
519
520 if (bdrv_flags & BDRV_O_AUTO_RDONLY) {
521 read_write = has_writers;
522 } else if (bdrv_flags & BDRV_O_RDWR) {
523 read_write = true;
524 }
525
526 if (read_write) {
527 *open_flags |= O_RDWR;
528 } else {
529 *open_flags |= O_RDONLY;
530 }
531
532
533
534 if ((bdrv_flags & BDRV_O_NOCACHE)) {
535 *open_flags |= O_DIRECT;
536 }
537}
538
539static void raw_parse_filename(const char *filename, QDict *options,
540 Error **errp)
541{
542 bdrv_parse_filename_strip_prefix(filename, "file:", options);
543}
544
545static QemuOptsList raw_runtime_opts = {
546 .name = "raw",
547 .head = QTAILQ_HEAD_INITIALIZER(raw_runtime_opts.head),
548 .desc = {
549 {
550 .name = "filename",
551 .type = QEMU_OPT_STRING,
552 .help = "File name of the image",
553 },
554 {
555 .name = "aio",
556 .type = QEMU_OPT_STRING,
557 .help = "host AIO implementation (threads, native, io_uring)",
558 },
559 {
560 .name = "aio-max-batch",
561 .type = QEMU_OPT_NUMBER,
562 .help = "AIO max batch size (0 = auto handled by AIO backend, default: 0)",
563 },
564 {
565 .name = "locking",
566 .type = QEMU_OPT_STRING,
567 .help = "file locking mode (on/off/auto, default: auto)",
568 },
569 {
570 .name = "pr-manager",
571 .type = QEMU_OPT_STRING,
572 .help = "id of persistent reservation manager object (default: none)",
573 },
574#if defined(__linux__)
575 {
576 .name = "drop-cache",
577 .type = QEMU_OPT_BOOL,
578 .help = "invalidate page cache during live migration (default: on)",
579 },
580#endif
581 {
582 .name = "x-check-cache-dropped",
583 .type = QEMU_OPT_BOOL,
584 .help = "check that page cache was dropped on live migration (default: off)"
585 },
586 { }
587 },
588};
589
590static const char *const mutable_opts[] = { "x-check-cache-dropped", NULL };
591
592static int raw_open_common(BlockDriverState *bs, QDict *options,
593 int bdrv_flags, int open_flags,
594 bool device, Error **errp)
595{
596 BDRVRawState *s = bs->opaque;
597 QemuOpts *opts;
598 Error *local_err = NULL;
599 const char *filename = NULL;
600 const char *str;
601 BlockdevAioOptions aio, aio_default;
602 int fd, ret;
603 struct stat st;
604 OnOffAuto locking;
605
606 opts = qemu_opts_create(&raw_runtime_opts, NULL, 0, &error_abort);
607 if (!qemu_opts_absorb_qdict(opts, options, errp)) {
608 ret = -EINVAL;
609 goto fail;
610 }
611
612 filename = qemu_opt_get(opts, "filename");
613
614 ret = raw_normalize_devicepath(&filename, errp);
615 if (ret != 0) {
616 goto fail;
617 }
618
619 if (bdrv_flags & BDRV_O_NATIVE_AIO) {
620 aio_default = BLOCKDEV_AIO_OPTIONS_NATIVE;
621#ifdef CONFIG_LINUX_IO_URING
622 } else if (bdrv_flags & BDRV_O_IO_URING) {
623 aio_default = BLOCKDEV_AIO_OPTIONS_IO_URING;
624#endif
625 } else {
626 aio_default = BLOCKDEV_AIO_OPTIONS_THREADS;
627 }
628
629 aio = qapi_enum_parse(&BlockdevAioOptions_lookup,
630 qemu_opt_get(opts, "aio"),
631 aio_default, &local_err);
632 if (local_err) {
633 error_propagate(errp, local_err);
634 ret = -EINVAL;
635 goto fail;
636 }
637
638 s->use_linux_aio = (aio == BLOCKDEV_AIO_OPTIONS_NATIVE);
639#ifdef CONFIG_LINUX_IO_URING
640 s->use_linux_io_uring = (aio == BLOCKDEV_AIO_OPTIONS_IO_URING);
641#endif
642
643 s->aio_max_batch = qemu_opt_get_number(opts, "aio-max-batch", 0);
644
645 locking = qapi_enum_parse(&OnOffAuto_lookup,
646 qemu_opt_get(opts, "locking"),
647 ON_OFF_AUTO_AUTO, &local_err);
648 if (local_err) {
649 error_propagate(errp, local_err);
650 ret = -EINVAL;
651 goto fail;
652 }
653 switch (locking) {
654 case ON_OFF_AUTO_ON:
655 s->use_lock = true;
656 if (!qemu_has_ofd_lock()) {
657 warn_report("File lock requested but OFD locking syscall is "
658 "unavailable, falling back to POSIX file locks");
659 error_printf("Due to the implementation, locks can be lost "
660 "unexpectedly.\n");
661 }
662 break;
663 case ON_OFF_AUTO_OFF:
664 s->use_lock = false;
665 break;
666 case ON_OFF_AUTO_AUTO:
667 s->use_lock = qemu_has_ofd_lock();
668 break;
669 default:
670 abort();
671 }
672
673 str = qemu_opt_get(opts, "pr-manager");
674 if (str) {
675 s->pr_mgr = pr_manager_lookup(str, &local_err);
676 if (local_err) {
677 error_propagate(errp, local_err);
678 ret = -EINVAL;
679 goto fail;
680 }
681 }
682
683 s->drop_cache = qemu_opt_get_bool(opts, "drop-cache", true);
684 s->check_cache_dropped = qemu_opt_get_bool(opts, "x-check-cache-dropped",
685 false);
686
687 s->open_flags = open_flags;
688 raw_parse_flags(bdrv_flags, &s->open_flags, false);
689
690 s->fd = -1;
691 fd = qemu_open(filename, s->open_flags, errp);
692 ret = fd < 0 ? -errno : 0;
693
694 if (ret < 0) {
695 if (ret == -EROFS) {
696 ret = -EACCES;
697 }
698 goto fail;
699 }
700 s->fd = fd;
701
702
703 if (s->open_flags & O_RDWR) {
704 ret = check_hdev_writable(s->fd);
705 if (ret < 0) {
706 error_setg_errno(errp, -ret, "The device is not writable");
707 goto fail;
708 }
709 }
710
711 s->perm = 0;
712 s->shared_perm = BLK_PERM_ALL;
713
714#ifdef CONFIG_LINUX_AIO
715
716 if (s->use_linux_aio) {
717 if (!(s->open_flags & O_DIRECT)) {
718 error_setg(errp, "aio=native was specified, but it requires "
719 "cache.direct=on, which was not specified.");
720 ret = -EINVAL;
721 goto fail;
722 }
723 if (!aio_setup_linux_aio(bdrv_get_aio_context(bs), errp)) {
724 error_prepend(errp, "Unable to use native AIO: ");
725 goto fail;
726 }
727 }
728#else
729 if (s->use_linux_aio) {
730 error_setg(errp, "aio=native was specified, but is not supported "
731 "in this build.");
732 ret = -EINVAL;
733 goto fail;
734 }
735#endif
736
737#ifdef CONFIG_LINUX_IO_URING
738 if (s->use_linux_io_uring) {
739 if (!aio_setup_linux_io_uring(bdrv_get_aio_context(bs), errp)) {
740 error_prepend(errp, "Unable to use io_uring: ");
741 goto fail;
742 }
743 }
744#else
745 if (s->use_linux_io_uring) {
746 error_setg(errp, "aio=io_uring was specified, but is not supported "
747 "in this build.");
748 ret = -EINVAL;
749 goto fail;
750 }
751#endif
752
753 s->has_discard = true;
754 s->has_write_zeroes = true;
755
756 if (fstat(s->fd, &st) < 0) {
757 ret = -errno;
758 error_setg_errno(errp, errno, "Could not stat file");
759 goto fail;
760 }
761
762 if (!device) {
763 if (!S_ISREG(st.st_mode)) {
764 error_setg(errp, "'%s' driver requires '%s' to be a regular file",
765 bs->drv->format_name, bs->filename);
766 ret = -EINVAL;
767 goto fail;
768 } else {
769 s->has_fallocate = true;
770 }
771 } else {
772 if (!(S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode))) {
773 error_setg(errp, "'%s' driver requires '%s' to be either "
774 "a character or block device",
775 bs->drv->format_name, bs->filename);
776 ret = -EINVAL;
777 goto fail;
778 }
779 }
780#ifdef CONFIG_BLKZONED
781
782
783
784
785 if ((bs->bl.zoned != BLK_Z_NONE) &&
786 (!(s->open_flags & O_DIRECT))) {
787 error_setg(errp, "The driver supports zoned devices, and it requires "
788 "cache.direct=on, which was not specified.");
789 return -EINVAL;
790 }
791#endif
792
793 if (S_ISBLK(st.st_mode)) {
794#ifdef __linux__
795
796
797
798
799 if (!(bs->open_flags & BDRV_O_NOCACHE)) {
800 s->has_write_zeroes = false;
801 }
802#endif
803 }
804#ifdef __FreeBSD__
805 if (S_ISCHR(st.st_mode)) {
806
807
808
809
810
811
812 s->force_alignment = true;
813 }
814#endif
815 s->needs_alignment = raw_needs_alignment(bs);
816
817 bs->supported_zero_flags = BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK;
818 if (S_ISREG(st.st_mode)) {
819
820 bs->supported_truncate_flags = BDRV_REQ_ZERO_WRITE;
821 }
822 ret = 0;
823fail:
824 if (ret < 0 && s->fd != -1) {
825 qemu_close(s->fd);
826 }
827 if (filename && (bdrv_flags & BDRV_O_TEMPORARY)) {
828 unlink(filename);
829 }
830 qemu_opts_del(opts);
831 return ret;
832}
833
834static int raw_open(BlockDriverState *bs, QDict *options, int flags,
835 Error **errp)
836{
837 BDRVRawState *s = bs->opaque;
838
839 s->type = FTYPE_FILE;
840 return raw_open_common(bs, options, flags, 0, false, errp);
841}
842
843typedef enum {
844 RAW_PL_PREPARE,
845 RAW_PL_COMMIT,
846 RAW_PL_ABORT,
847} RawPermLockOp;
848
849#define PERM_FOREACH(i) \
850 for ((i) = 0; (1ULL << (i)) <= BLK_PERM_ALL; i++)
851
852
853
854
855
856static int raw_apply_lock_bytes(BDRVRawState *s, int fd,
857 uint64_t perm_lock_bits,
858 uint64_t shared_perm_lock_bits,
859 bool unlock, Error **errp)
860{
861 int ret;
862 int i;
863 uint64_t locked_perm, locked_shared_perm;
864
865 if (s) {
866 locked_perm = s->locked_perm;
867 locked_shared_perm = s->locked_shared_perm;
868 } else {
869
870
871
872
873 if (unlock) {
874 locked_perm = BLK_PERM_ALL;
875 locked_shared_perm = BLK_PERM_ALL;
876 } else {
877 locked_perm = 0;
878 locked_shared_perm = 0;
879 }
880 }
881
882 PERM_FOREACH(i) {
883 int off = RAW_LOCK_PERM_BASE + i;
884 uint64_t bit = (1ULL << i);
885 if ((perm_lock_bits & bit) && !(locked_perm & bit)) {
886 ret = qemu_lock_fd(fd, off, 1, false);
887 if (ret) {
888 raw_lock_error_setg_errno(errp, -ret, "Failed to lock byte %d",
889 off);
890 return ret;
891 } else if (s) {
892 s->locked_perm |= bit;
893 }
894 } else if (unlock && (locked_perm & bit) && !(perm_lock_bits & bit)) {
895 ret = qemu_unlock_fd(fd, off, 1);
896 if (ret) {
897 error_setg_errno(errp, -ret, "Failed to unlock byte %d", off);
898 return ret;
899 } else if (s) {
900 s->locked_perm &= ~bit;
901 }
902 }
903 }
904 PERM_FOREACH(i) {
905 int off = RAW_LOCK_SHARED_BASE + i;
906 uint64_t bit = (1ULL << i);
907 if ((shared_perm_lock_bits & bit) && !(locked_shared_perm & bit)) {
908 ret = qemu_lock_fd(fd, off, 1, false);
909 if (ret) {
910 raw_lock_error_setg_errno(errp, -ret, "Failed to lock byte %d",
911 off);
912 return ret;
913 } else if (s) {
914 s->locked_shared_perm |= bit;
915 }
916 } else if (unlock && (locked_shared_perm & bit) &&
917 !(shared_perm_lock_bits & bit)) {
918 ret = qemu_unlock_fd(fd, off, 1);
919 if (ret) {
920 error_setg_errno(errp, -ret, "Failed to unlock byte %d", off);
921 return ret;
922 } else if (s) {
923 s->locked_shared_perm &= ~bit;
924 }
925 }
926 }
927 return 0;
928}
929
930
931static int raw_check_lock_bytes(int fd, uint64_t perm, uint64_t shared_perm,
932 Error **errp)
933{
934 int ret;
935 int i;
936
937 PERM_FOREACH(i) {
938 int off = RAW_LOCK_SHARED_BASE + i;
939 uint64_t p = 1ULL << i;
940 if (perm & p) {
941 ret = qemu_lock_fd_test(fd, off, 1, true);
942 if (ret) {
943 char *perm_name = bdrv_perm_names(p);
944
945 raw_lock_error_setg_errno(errp, -ret,
946 "Failed to get \"%s\" lock",
947 perm_name);
948 g_free(perm_name);
949 return ret;
950 }
951 }
952 }
953 PERM_FOREACH(i) {
954 int off = RAW_LOCK_PERM_BASE + i;
955 uint64_t p = 1ULL << i;
956 if (!(shared_perm & p)) {
957 ret = qemu_lock_fd_test(fd, off, 1, true);
958 if (ret) {
959 char *perm_name = bdrv_perm_names(p);
960
961 raw_lock_error_setg_errno(errp, -ret,
962 "Failed to get shared \"%s\" lock",
963 perm_name);
964 g_free(perm_name);
965 return ret;
966 }
967 }
968 }
969 return 0;
970}
971
972static int raw_handle_perm_lock(BlockDriverState *bs,
973 RawPermLockOp op,
974 uint64_t new_perm, uint64_t new_shared,
975 Error **errp)
976{
977 BDRVRawState *s = bs->opaque;
978 int ret = 0;
979 Error *local_err = NULL;
980
981 if (!s->use_lock) {
982 return 0;
983 }
984
985 if (bdrv_get_flags(bs) & BDRV_O_INACTIVE) {
986 return 0;
987 }
988
989 switch (op) {
990 case RAW_PL_PREPARE:
991 if ((s->perm | new_perm) == s->perm &&
992 (s->shared_perm & new_shared) == s->shared_perm)
993 {
994
995
996
997
998
999
1000
1001 return 0;
1002 }
1003 ret = raw_apply_lock_bytes(s, s->fd, s->perm | new_perm,
1004 ~s->shared_perm | ~new_shared,
1005 false, errp);
1006 if (!ret) {
1007 ret = raw_check_lock_bytes(s->fd, new_perm, new_shared, errp);
1008 if (!ret) {
1009 return 0;
1010 }
1011 error_append_hint(errp,
1012 "Is another process using the image [%s]?\n",
1013 bs->filename);
1014 }
1015
1016 case RAW_PL_ABORT:
1017 raw_apply_lock_bytes(s, s->fd, s->perm, ~s->shared_perm,
1018 true, &local_err);
1019 if (local_err) {
1020
1021
1022
1023 warn_report_err(local_err);
1024 }
1025 break;
1026 case RAW_PL_COMMIT:
1027 raw_apply_lock_bytes(s, s->fd, new_perm, ~new_shared,
1028 true, &local_err);
1029 if (local_err) {
1030
1031
1032
1033 warn_report_err(local_err);
1034 }
1035 break;
1036 }
1037 return ret;
1038}
1039
1040
1041static int fcntl_setfl(int fd, int flag)
1042{
1043 int flags;
1044
1045 flags = fcntl(fd, F_GETFL);
1046 if (flags == -1) {
1047 return -errno;
1048 }
1049 if (fcntl(fd, F_SETFL, flags | flag) == -1) {
1050 return -errno;
1051 }
1052 return 0;
1053}
1054
1055static int raw_reconfigure_getfd(BlockDriverState *bs, int flags,
1056 int *open_flags, uint64_t perm, bool force_dup,
1057 Error **errp)
1058{
1059 BDRVRawState *s = bs->opaque;
1060 int fd = -1;
1061 int ret;
1062 bool has_writers = perm &
1063 (BLK_PERM_WRITE | BLK_PERM_WRITE_UNCHANGED | BLK_PERM_RESIZE);
1064 int fcntl_flags = O_APPEND | O_NONBLOCK;
1065#ifdef O_NOATIME
1066 fcntl_flags |= O_NOATIME;
1067#endif
1068
1069 *open_flags = 0;
1070 if (s->type == FTYPE_CD) {
1071 *open_flags |= O_NONBLOCK;
1072 }
1073
1074 raw_parse_flags(flags, open_flags, has_writers);
1075
1076#ifdef O_ASYNC
1077
1078
1079
1080
1081
1082 assert((s->open_flags & O_ASYNC) == 0);
1083#endif
1084
1085 if (!force_dup && *open_flags == s->open_flags) {
1086
1087 return s->fd;
1088 }
1089
1090 if ((*open_flags & ~fcntl_flags) == (s->open_flags & ~fcntl_flags)) {
1091
1092 fd = qemu_dup(s->fd);
1093 if (fd >= 0) {
1094 ret = fcntl_setfl(fd, *open_flags);
1095 if (ret) {
1096 qemu_close(fd);
1097 fd = -1;
1098 }
1099 }
1100 }
1101
1102
1103 if (fd == -1) {
1104 const char *normalized_filename = bs->filename;
1105 ret = raw_normalize_devicepath(&normalized_filename, errp);
1106 if (ret >= 0) {
1107 fd = qemu_open(normalized_filename, *open_flags, errp);
1108 if (fd == -1) {
1109 return -1;
1110 }
1111 }
1112 }
1113
1114 if (fd != -1 && (*open_flags & O_RDWR)) {
1115 ret = check_hdev_writable(fd);
1116 if (ret < 0) {
1117 qemu_close(fd);
1118 error_setg_errno(errp, -ret, "The device is not writable");
1119 return -1;
1120 }
1121 }
1122
1123 return fd;
1124}
1125
1126static int raw_reopen_prepare(BDRVReopenState *state,
1127 BlockReopenQueue *queue, Error **errp)
1128{
1129 BDRVRawState *s;
1130 BDRVRawReopenState *rs;
1131 QemuOpts *opts;
1132 int ret;
1133
1134 assert(state != NULL);
1135 assert(state->bs != NULL);
1136
1137 s = state->bs->opaque;
1138
1139 state->opaque = g_new0(BDRVRawReopenState, 1);
1140 rs = state->opaque;
1141
1142
1143 opts = qemu_opts_create(&raw_runtime_opts, NULL, 0, &error_abort);
1144 if (!qemu_opts_absorb_qdict(opts, state->options, errp)) {
1145 ret = -EINVAL;
1146 goto out;
1147 }
1148
1149 rs->drop_cache = qemu_opt_get_bool_del(opts, "drop-cache", true);
1150 rs->check_cache_dropped =
1151 qemu_opt_get_bool_del(opts, "x-check-cache-dropped", false);
1152
1153
1154
1155
1156 qemu_opts_to_qdict(opts, state->options);
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167 s->reopen_state = state;
1168 ret = 0;
1169
1170out:
1171 qemu_opts_del(opts);
1172 return ret;
1173}
1174
1175static void raw_reopen_commit(BDRVReopenState *state)
1176{
1177 BDRVRawReopenState *rs = state->opaque;
1178 BDRVRawState *s = state->bs->opaque;
1179
1180 s->drop_cache = rs->drop_cache;
1181 s->check_cache_dropped = rs->check_cache_dropped;
1182 s->open_flags = rs->open_flags;
1183 g_free(state->opaque);
1184 state->opaque = NULL;
1185
1186 assert(s->reopen_state == state);
1187 s->reopen_state = NULL;
1188}
1189
1190
1191static void raw_reopen_abort(BDRVReopenState *state)
1192{
1193 BDRVRawReopenState *rs = state->opaque;
1194 BDRVRawState *s = state->bs->opaque;
1195
1196
1197 if (rs == NULL) {
1198 return;
1199 }
1200
1201 g_free(state->opaque);
1202 state->opaque = NULL;
1203
1204 assert(s->reopen_state == state);
1205 s->reopen_state = NULL;
1206}
1207
1208static int hdev_get_max_hw_transfer(int fd, struct stat *st)
1209{
1210#ifdef BLKSECTGET
1211 if (S_ISBLK(st->st_mode)) {
1212 unsigned short max_sectors = 0;
1213 if (ioctl(fd, BLKSECTGET, &max_sectors) == 0) {
1214 return max_sectors * 512;
1215 }
1216 } else {
1217 int max_bytes = 0;
1218 if (ioctl(fd, BLKSECTGET, &max_bytes) == 0) {
1219 return max_bytes;
1220 }
1221 }
1222 return -errno;
1223#else
1224 return -ENOSYS;
1225#endif
1226}
1227
1228
1229
1230
1231#ifdef CONFIG_LINUX
1232static int get_sysfs_str_val(struct stat *st, const char *attribute,
1233 char **val) {
1234 g_autofree char *sysfspath = NULL;
1235 size_t len;
1236
1237 if (!S_ISBLK(st->st_mode)) {
1238 return -ENOTSUP;
1239 }
1240
1241 sysfspath = g_strdup_printf("/sys/dev/block/%u:%u/queue/%s",
1242 major(st->st_rdev), minor(st->st_rdev),
1243 attribute);
1244 if (!g_file_get_contents(sysfspath, val, &len, NULL)) {
1245 return -ENOENT;
1246 }
1247
1248
1249 char *p;
1250 p = *val;
1251 if (*(p + len - 1) == '\n') {
1252 *(p + len - 1) = '\0';
1253 }
1254 return 0;
1255}
1256#endif
1257
1258#if defined(CONFIG_BLKZONED)
1259static int get_sysfs_zoned_model(struct stat *st, BlockZoneModel *zoned)
1260{
1261 g_autofree char *val = NULL;
1262 int ret;
1263
1264 ret = get_sysfs_str_val(st, "zoned", &val);
1265 if (ret < 0) {
1266 return ret;
1267 }
1268
1269 if (strcmp(val, "host-managed") == 0) {
1270 *zoned = BLK_Z_HM;
1271 } else if (strcmp(val, "host-aware") == 0) {
1272 *zoned = BLK_Z_HA;
1273 } else if (strcmp(val, "none") == 0) {
1274 *zoned = BLK_Z_NONE;
1275 } else {
1276 return -ENOTSUP;
1277 }
1278 return 0;
1279}
1280#endif
1281
1282
1283
1284
1285#ifdef CONFIG_LINUX
1286static long get_sysfs_long_val(struct stat *st, const char *attribute)
1287{
1288 g_autofree char *str = NULL;
1289 const char *end;
1290 long val;
1291 int ret;
1292
1293 ret = get_sysfs_str_val(st, attribute, &str);
1294 if (ret < 0) {
1295 return ret;
1296 }
1297
1298
1299 ret = qemu_strtol(str, &end, 10, &val);
1300 if (ret == 0 && end && *end == '\0') {
1301 ret = val;
1302 }
1303 return ret;
1304}
1305#endif
1306
1307static int hdev_get_max_segments(int fd, struct stat *st)
1308{
1309#ifdef CONFIG_LINUX
1310 int ret;
1311
1312 if (S_ISCHR(st->st_mode)) {
1313 if (ioctl(fd, SG_GET_SG_TABLESIZE, &ret) == 0) {
1314 return ret;
1315 }
1316 return -ENOTSUP;
1317 }
1318 return get_sysfs_long_val(st, "max_segments");
1319#else
1320 return -ENOTSUP;
1321#endif
1322}
1323
1324#if defined(CONFIG_BLKZONED)
1325
1326
1327
1328
1329
1330static int get_zones_wp(BlockDriverState *bs, int fd, int64_t offset,
1331 unsigned int nrz, bool reset_all)
1332{
1333 struct blk_zone *blkz;
1334 size_t rep_size;
1335 uint64_t sector = offset >> BDRV_SECTOR_BITS;
1336 BlockZoneWps *wps = bs->wps;
1337 unsigned int j = offset / bs->bl.zone_size;
1338 unsigned int n = 0, i = 0;
1339 int ret;
1340 rep_size = sizeof(struct blk_zone_report) + nrz * sizeof(struct blk_zone);
1341 g_autofree struct blk_zone_report *rep = NULL;
1342
1343 rep = g_malloc(rep_size);
1344 blkz = (struct blk_zone *)(rep + 1);
1345 while (n < nrz) {
1346 memset(rep, 0, rep_size);
1347 rep->sector = sector;
1348 rep->nr_zones = nrz - n;
1349
1350 do {
1351 ret = ioctl(fd, BLKREPORTZONE, rep);
1352 } while (ret != 0 && errno == EINTR);
1353 if (ret != 0) {
1354 error_report("%d: ioctl BLKREPORTZONE at %" PRId64 " failed %d",
1355 fd, offset, errno);
1356 return -errno;
1357 }
1358
1359 if (!rep->nr_zones) {
1360 break;
1361 }
1362
1363 for (i = 0; i < rep->nr_zones; ++i, ++n, ++j) {
1364
1365
1366
1367
1368
1369
1370
1371 if (blkz[i].type == BLK_ZONE_TYPE_CONVENTIONAL) {
1372 wps->wp[j] |= 1ULL << 63;
1373 } else {
1374 switch(blkz[i].cond) {
1375 case BLK_ZONE_COND_FULL:
1376 case BLK_ZONE_COND_READONLY:
1377
1378 wps->wp[j] = (blkz[i].start + blkz[i].len) << BDRV_SECTOR_BITS;
1379 break;
1380 case BLK_ZONE_COND_OFFLINE:
1381
1382 wps->wp[j] = (blkz[i].start) << BDRV_SECTOR_BITS;
1383 break;
1384 default:
1385 if (reset_all) {
1386 wps->wp[j] = blkz[i].start << BDRV_SECTOR_BITS;
1387 } else {
1388 wps->wp[j] = blkz[i].wp << BDRV_SECTOR_BITS;
1389 }
1390 break;
1391 }
1392 }
1393 }
1394 sector = blkz[i - 1].start + blkz[i - 1].len;
1395 }
1396
1397 return 0;
1398}
1399
1400static void update_zones_wp(BlockDriverState *bs, int fd, int64_t offset,
1401 unsigned int nrz)
1402{
1403 if (get_zones_wp(bs, fd, offset, nrz, 0) < 0) {
1404 error_report("update zone wp failed");
1405 }
1406}
1407
1408static void raw_refresh_zoned_limits(BlockDriverState *bs, struct stat *st,
1409 Error **errp)
1410{
1411 BDRVRawState *s = bs->opaque;
1412 BlockZoneModel zoned;
1413 int ret;
1414
1415 bs->bl.zoned = BLK_Z_NONE;
1416
1417 ret = get_sysfs_zoned_model(st, &zoned);
1418 if (ret < 0 || zoned == BLK_Z_NONE) {
1419 return;
1420 }
1421 bs->bl.zoned = zoned;
1422
1423 ret = get_sysfs_long_val(st, "max_open_zones");
1424 if (ret >= 0) {
1425 bs->bl.max_open_zones = ret;
1426 }
1427
1428 ret = get_sysfs_long_val(st, "max_active_zones");
1429 if (ret >= 0) {
1430 bs->bl.max_active_zones = ret;
1431 }
1432
1433
1434
1435
1436 ret = get_sysfs_long_val(st, "chunk_sectors");
1437 if (ret < 0) {
1438 error_setg_errno(errp, -ret, "Unable to read chunk_sectors "
1439 "sysfs attribute");
1440 return;
1441 } else if (!ret) {
1442 error_setg(errp, "Read 0 from chunk_sectors sysfs attribute");
1443 return;
1444 }
1445 bs->bl.zone_size = ret << BDRV_SECTOR_BITS;
1446
1447 ret = get_sysfs_long_val(st, "nr_zones");
1448 if (ret < 0) {
1449 error_setg_errno(errp, -ret, "Unable to read nr_zones "
1450 "sysfs attribute");
1451 return;
1452 } else if (!ret) {
1453 error_setg(errp, "Read 0 from nr_zones sysfs attribute");
1454 return;
1455 }
1456 bs->bl.nr_zones = ret;
1457
1458 ret = get_sysfs_long_val(st, "zone_append_max_bytes");
1459 if (ret > 0) {
1460 bs->bl.max_append_sectors = ret >> BDRV_SECTOR_BITS;
1461 }
1462
1463 ret = get_sysfs_long_val(st, "physical_block_size");
1464 if (ret >= 0) {
1465 bs->bl.write_granularity = ret;
1466 }
1467
1468
1469 g_free(bs->wps);
1470 bs->wps = g_malloc(sizeof(BlockZoneWps) +
1471 sizeof(int64_t) * bs->bl.nr_zones);
1472 ret = get_zones_wp(bs, s->fd, 0, bs->bl.nr_zones, 0);
1473 if (ret < 0) {
1474 error_setg_errno(errp, -ret, "report wps failed");
1475 bs->wps = NULL;
1476 return;
1477 }
1478 qemu_co_mutex_init(&bs->wps->colock);
1479}
1480#else
1481static void raw_refresh_zoned_limits(BlockDriverState *bs, struct stat *st,
1482 Error **errp)
1483{
1484 bs->bl.zoned = BLK_Z_NONE;
1485}
1486#endif
1487
1488static void raw_refresh_limits(BlockDriverState *bs, Error **errp)
1489{
1490 BDRVRawState *s = bs->opaque;
1491 struct stat st;
1492
1493 s->needs_alignment = raw_needs_alignment(bs);
1494 raw_probe_alignment(bs, s->fd, errp);
1495
1496 bs->bl.min_mem_alignment = s->buf_align;
1497 bs->bl.opt_mem_alignment = MAX(s->buf_align, qemu_real_host_page_size());
1498
1499
1500
1501
1502
1503
1504 if (fstat(s->fd, &st)) {
1505 return;
1506 }
1507
1508#if defined(__APPLE__) && (__MACH__)
1509 struct statfs buf;
1510
1511 if (!fstatfs(s->fd, &buf)) {
1512 bs->bl.opt_transfer = buf.f_iosize;
1513 bs->bl.pdiscard_alignment = buf.f_bsize;
1514 }
1515#endif
1516
1517 if (bdrv_is_sg(bs) || S_ISBLK(st.st_mode)) {
1518 int ret = hdev_get_max_hw_transfer(s->fd, &st);
1519
1520 if (ret > 0 && ret <= BDRV_REQUEST_MAX_BYTES) {
1521 bs->bl.max_hw_transfer = ret;
1522 }
1523
1524 ret = hdev_get_max_segments(s->fd, &st);
1525 if (ret > 0) {
1526 bs->bl.max_hw_iov = ret;
1527 }
1528 }
1529
1530 raw_refresh_zoned_limits(bs, &st, errp);
1531}
1532
1533static int check_for_dasd(int fd)
1534{
1535#ifdef BIODASDINFO2
1536 struct dasd_information2_t info = {0};
1537
1538 return ioctl(fd, BIODASDINFO2, &info);
1539#else
1540 return -1;
1541#endif
1542}
1543
1544
1545
1546
1547
1548
1549static int hdev_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz)
1550{
1551 BDRVRawState *s = bs->opaque;
1552 int ret;
1553
1554
1555 if (check_for_dasd(s->fd) < 0) {
1556
1557 if (bs->bl.zoned == BLK_Z_NONE) {
1558 return -ENOTSUP;
1559 }
1560 }
1561 ret = probe_logical_blocksize(s->fd, &bsz->log);
1562 if (ret < 0) {
1563 return ret;
1564 }
1565 return probe_physical_blocksize(s->fd, &bsz->phys);
1566}
1567
1568
1569
1570
1571
1572
1573
1574#ifdef __linux__
1575static int hdev_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
1576{
1577 BDRVRawState *s = bs->opaque;
1578 struct hd_geometry ioctl_geo = {0};
1579
1580
1581 if (check_for_dasd(s->fd) < 0) {
1582 return -ENOTSUP;
1583 }
1584 if (ioctl(s->fd, HDIO_GETGEO, &ioctl_geo) < 0) {
1585 return -errno;
1586 }
1587
1588
1589 if (!ioctl_geo.heads || !ioctl_geo.sectors || !ioctl_geo.cylinders) {
1590 return -ENOTSUP;
1591 }
1592
1593 if (ioctl_geo.start != 0) {
1594 return -ENOTSUP;
1595 }
1596 geo->heads = ioctl_geo.heads;
1597 geo->sectors = ioctl_geo.sectors;
1598 geo->cylinders = ioctl_geo.cylinders;
1599
1600 return 0;
1601}
1602#else
1603static int hdev_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
1604{
1605 return -ENOTSUP;
1606}
1607#endif
1608
1609#if defined(__linux__)
1610static int handle_aiocb_ioctl(void *opaque)
1611{
1612 RawPosixAIOData *aiocb = opaque;
1613 int ret;
1614
1615 ret = RETRY_ON_EINTR(
1616 ioctl(aiocb->aio_fildes, aiocb->ioctl.cmd, aiocb->ioctl.buf)
1617 );
1618 if (ret == -1) {
1619 return -errno;
1620 }
1621
1622 return 0;
1623}
1624#endif
1625
1626static int handle_aiocb_flush(void *opaque)
1627{
1628 RawPosixAIOData *aiocb = opaque;
1629 BDRVRawState *s = aiocb->bs->opaque;
1630 int ret;
1631
1632 if (s->page_cache_inconsistent) {
1633 return -s->page_cache_inconsistent;
1634 }
1635
1636 ret = qemu_fdatasync(aiocb->aio_fildes);
1637 if (ret == -1) {
1638 trace_file_flush_fdatasync_failed(errno);
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653 if ((s->open_flags & O_DIRECT) == 0) {
1654 s->page_cache_inconsistent = errno;
1655 }
1656 return -errno;
1657 }
1658 return 0;
1659}
1660
1661#ifdef CONFIG_PREADV
1662
1663static bool preadv_present = true;
1664
1665static ssize_t
1666qemu_preadv(int fd, const struct iovec *iov, int nr_iov, off_t offset)
1667{
1668 return preadv(fd, iov, nr_iov, offset);
1669}
1670
1671static ssize_t
1672qemu_pwritev(int fd, const struct iovec *iov, int nr_iov, off_t offset)
1673{
1674 return pwritev(fd, iov, nr_iov, offset);
1675}
1676
1677#else
1678
1679static bool preadv_present = false;
1680
1681static ssize_t
1682qemu_preadv(int fd, const struct iovec *iov, int nr_iov, off_t offset)
1683{
1684 return -ENOSYS;
1685}
1686
1687static ssize_t
1688qemu_pwritev(int fd, const struct iovec *iov, int nr_iov, off_t offset)
1689{
1690 return -ENOSYS;
1691}
1692
1693#endif
1694
1695static ssize_t handle_aiocb_rw_vector(RawPosixAIOData *aiocb)
1696{
1697 ssize_t len;
1698
1699 len = RETRY_ON_EINTR(
1700 (aiocb->aio_type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND)) ?
1701 qemu_pwritev(aiocb->aio_fildes,
1702 aiocb->io.iov,
1703 aiocb->io.niov,
1704 aiocb->aio_offset) :
1705 qemu_preadv(aiocb->aio_fildes,
1706 aiocb->io.iov,
1707 aiocb->io.niov,
1708 aiocb->aio_offset)
1709 );
1710
1711 if (len == -1) {
1712 return -errno;
1713 }
1714 return len;
1715}
1716
1717
1718
1719
1720
1721
1722
1723static ssize_t handle_aiocb_rw_linear(RawPosixAIOData *aiocb, char *buf)
1724{
1725 ssize_t offset = 0;
1726 ssize_t len;
1727
1728 while (offset < aiocb->aio_nbytes) {
1729 if (aiocb->aio_type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND)) {
1730 len = pwrite(aiocb->aio_fildes,
1731 (const char *)buf + offset,
1732 aiocb->aio_nbytes - offset,
1733 aiocb->aio_offset + offset);
1734 } else {
1735 len = pread(aiocb->aio_fildes,
1736 buf + offset,
1737 aiocb->aio_nbytes - offset,
1738 aiocb->aio_offset + offset);
1739 }
1740 if (len == -1 && errno == EINTR) {
1741 continue;
1742 } else if (len == -1 && errno == EINVAL &&
1743 (aiocb->bs->open_flags & BDRV_O_NOCACHE) &&
1744 !(aiocb->aio_type & QEMU_AIO_WRITE) &&
1745 offset > 0) {
1746
1747
1748
1749
1750 break;
1751 } else if (len == -1) {
1752 offset = -errno;
1753 break;
1754 } else if (len == 0) {
1755 break;
1756 }
1757 offset += len;
1758 }
1759
1760 return offset;
1761}
1762
1763static int handle_aiocb_rw(void *opaque)
1764{
1765 RawPosixAIOData *aiocb = opaque;
1766 ssize_t nbytes;
1767 char *buf;
1768
1769 if (!(aiocb->aio_type & QEMU_AIO_MISALIGNED)) {
1770
1771
1772
1773
1774 if (aiocb->io.niov == 1) {
1775 nbytes = handle_aiocb_rw_linear(aiocb, aiocb->io.iov->iov_base);
1776 goto out;
1777 }
1778
1779
1780
1781
1782
1783
1784 if (preadv_present) {
1785 nbytes = handle_aiocb_rw_vector(aiocb);
1786 if (nbytes == aiocb->aio_nbytes ||
1787 (nbytes < 0 && nbytes != -ENOSYS)) {
1788 goto out;
1789 }
1790 preadv_present = false;
1791 }
1792
1793
1794
1795
1796
1797
1798 }
1799
1800
1801
1802
1803
1804 buf = qemu_try_blockalign(aiocb->bs, aiocb->aio_nbytes);
1805 if (buf == NULL) {
1806 nbytes = -ENOMEM;
1807 goto out;
1808 }
1809
1810 if (aiocb->aio_type & QEMU_AIO_WRITE) {
1811 char *p = buf;
1812 int i;
1813
1814 for (i = 0; i < aiocb->io.niov; ++i) {
1815 memcpy(p, aiocb->io.iov[i].iov_base, aiocb->io.iov[i].iov_len);
1816 p += aiocb->io.iov[i].iov_len;
1817 }
1818 assert(p - buf == aiocb->aio_nbytes);
1819 }
1820
1821 nbytes = handle_aiocb_rw_linear(aiocb, buf);
1822 if (!(aiocb->aio_type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND))) {
1823 char *p = buf;
1824 size_t count = aiocb->aio_nbytes, copy;
1825 int i;
1826
1827 for (i = 0; i < aiocb->io.niov && count; ++i) {
1828 copy = count;
1829 if (copy > aiocb->io.iov[i].iov_len) {
1830 copy = aiocb->io.iov[i].iov_len;
1831 }
1832 memcpy(aiocb->io.iov[i].iov_base, p, copy);
1833 assert(count >= copy);
1834 p += copy;
1835 count -= copy;
1836 }
1837 assert(count == 0);
1838 }
1839 qemu_vfree(buf);
1840
1841out:
1842 if (nbytes == aiocb->aio_nbytes) {
1843 return 0;
1844 } else if (nbytes >= 0 && nbytes < aiocb->aio_nbytes) {
1845 if (aiocb->aio_type & QEMU_AIO_WRITE) {
1846 return -EINVAL;
1847 } else {
1848 iov_memset(aiocb->io.iov, aiocb->io.niov, nbytes,
1849 0, aiocb->aio_nbytes - nbytes);
1850 return 0;
1851 }
1852 } else {
1853 assert(nbytes < 0);
1854 return nbytes;
1855 }
1856}
1857
1858#if defined(CONFIG_FALLOCATE) || defined(BLKZEROOUT) || defined(BLKDISCARD)
1859static int translate_err(int err)
1860{
1861 if (err == -ENODEV || err == -ENOSYS || err == -EOPNOTSUPP ||
1862 err == -ENOTTY) {
1863 err = -ENOTSUP;
1864 }
1865 return err;
1866}
1867#endif
1868
1869#ifdef CONFIG_FALLOCATE
1870static int do_fallocate(int fd, int mode, off_t offset, off_t len)
1871{
1872 do {
1873 if (fallocate(fd, mode, offset, len) == 0) {
1874 return 0;
1875 }
1876 } while (errno == EINTR);
1877 return translate_err(-errno);
1878}
1879#endif
1880
1881static ssize_t handle_aiocb_write_zeroes_block(RawPosixAIOData *aiocb)
1882{
1883 int ret = -ENOTSUP;
1884 BDRVRawState *s = aiocb->bs->opaque;
1885
1886 if (!s->has_write_zeroes) {
1887 return -ENOTSUP;
1888 }
1889
1890#ifdef BLKZEROOUT
1891
1892
1893
1894 if (!(aiocb->aio_type & QEMU_AIO_NO_FALLBACK)) {
1895 do {
1896 uint64_t range[2] = { aiocb->aio_offset, aiocb->aio_nbytes };
1897 if (ioctl(aiocb->aio_fildes, BLKZEROOUT, range) == 0) {
1898 return 0;
1899 }
1900 } while (errno == EINTR);
1901
1902 ret = translate_err(-errno);
1903 if (ret == -ENOTSUP) {
1904 s->has_write_zeroes = false;
1905 }
1906 }
1907#endif
1908
1909 return ret;
1910}
1911
1912static int handle_aiocb_write_zeroes(void *opaque)
1913{
1914 RawPosixAIOData *aiocb = opaque;
1915#ifdef CONFIG_FALLOCATE
1916 BDRVRawState *s = aiocb->bs->opaque;
1917 int64_t len;
1918#endif
1919
1920 if (aiocb->aio_type & QEMU_AIO_BLKDEV) {
1921 return handle_aiocb_write_zeroes_block(aiocb);
1922 }
1923
1924#ifdef CONFIG_FALLOCATE_ZERO_RANGE
1925 if (s->has_write_zeroes) {
1926 int ret = do_fallocate(s->fd, FALLOC_FL_ZERO_RANGE,
1927 aiocb->aio_offset, aiocb->aio_nbytes);
1928 if (ret == -ENOTSUP) {
1929 s->has_write_zeroes = false;
1930 } else if (ret == 0 || ret != -EINVAL) {
1931 return ret;
1932 }
1933
1934
1935
1936
1937
1938
1939 }
1940#endif
1941
1942#ifdef CONFIG_FALLOCATE_PUNCH_HOLE
1943 if (s->has_discard && s->has_fallocate) {
1944 int ret = do_fallocate(s->fd,
1945 FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE,
1946 aiocb->aio_offset, aiocb->aio_nbytes);
1947 if (ret == 0) {
1948 ret = do_fallocate(s->fd, 0, aiocb->aio_offset, aiocb->aio_nbytes);
1949 if (ret == 0 || ret != -ENOTSUP) {
1950 return ret;
1951 }
1952 s->has_fallocate = false;
1953 } else if (ret == -EINVAL) {
1954
1955
1956
1957
1958
1959
1960 warn_report_once("Your file system is misbehaving: "
1961 "fallocate(FALLOC_FL_PUNCH_HOLE) returned EINVAL. "
1962 "Please report this bug to your file system "
1963 "vendor.");
1964 } else if (ret != -ENOTSUP) {
1965 return ret;
1966 } else {
1967 s->has_discard = false;
1968 }
1969 }
1970#endif
1971
1972#ifdef CONFIG_FALLOCATE
1973
1974
1975 len = raw_getlength(aiocb->bs);
1976 if (s->has_fallocate && len >= 0 && aiocb->aio_offset >= len) {
1977 int ret = do_fallocate(s->fd, 0, aiocb->aio_offset, aiocb->aio_nbytes);
1978 if (ret == 0 || ret != -ENOTSUP) {
1979 return ret;
1980 }
1981 s->has_fallocate = false;
1982 }
1983#endif
1984
1985 return -ENOTSUP;
1986}
1987
1988static int handle_aiocb_write_zeroes_unmap(void *opaque)
1989{
1990 RawPosixAIOData *aiocb = opaque;
1991 BDRVRawState *s G_GNUC_UNUSED = aiocb->bs->opaque;
1992
1993
1994
1995#ifdef CONFIG_FALLOCATE_PUNCH_HOLE
1996 int ret = do_fallocate(s->fd, FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE,
1997 aiocb->aio_offset, aiocb->aio_nbytes);
1998 switch (ret) {
1999 case -ENOTSUP:
2000 case -EINVAL:
2001 case -EBUSY:
2002 break;
2003 default:
2004 return ret;
2005 }
2006#endif
2007
2008
2009
2010 return handle_aiocb_write_zeroes(aiocb);
2011}
2012
2013#ifndef HAVE_COPY_FILE_RANGE
2014static off_t copy_file_range(int in_fd, off_t *in_off, int out_fd,
2015 off_t *out_off, size_t len, unsigned int flags)
2016{
2017#ifdef __NR_copy_file_range
2018 return syscall(__NR_copy_file_range, in_fd, in_off, out_fd,
2019 out_off, len, flags);
2020#else
2021 errno = ENOSYS;
2022 return -1;
2023#endif
2024}
2025#endif
2026
2027
2028
2029
2030#if defined(CONFIG_BLKZONED)
2031static inline int parse_zone(struct BlockZoneDescriptor *zone,
2032 const struct blk_zone *blkz) {
2033 zone->start = blkz->start << BDRV_SECTOR_BITS;
2034 zone->length = blkz->len << BDRV_SECTOR_BITS;
2035 zone->wp = blkz->wp << BDRV_SECTOR_BITS;
2036
2037#ifdef HAVE_BLK_ZONE_REP_CAPACITY
2038 zone->cap = blkz->capacity << BDRV_SECTOR_BITS;
2039#else
2040 zone->cap = blkz->len << BDRV_SECTOR_BITS;
2041#endif
2042
2043 switch (blkz->type) {
2044 case BLK_ZONE_TYPE_SEQWRITE_REQ:
2045 zone->type = BLK_ZT_SWR;
2046 break;
2047 case BLK_ZONE_TYPE_SEQWRITE_PREF:
2048 zone->type = BLK_ZT_SWP;
2049 break;
2050 case BLK_ZONE_TYPE_CONVENTIONAL:
2051 zone->type = BLK_ZT_CONV;
2052 break;
2053 default:
2054 error_report("Unsupported zone type: 0x%x", blkz->type);
2055 return -ENOTSUP;
2056 }
2057
2058 switch (blkz->cond) {
2059 case BLK_ZONE_COND_NOT_WP:
2060 zone->state = BLK_ZS_NOT_WP;
2061 break;
2062 case BLK_ZONE_COND_EMPTY:
2063 zone->state = BLK_ZS_EMPTY;
2064 break;
2065 case BLK_ZONE_COND_IMP_OPEN:
2066 zone->state = BLK_ZS_IOPEN;
2067 break;
2068 case BLK_ZONE_COND_EXP_OPEN:
2069 zone->state = BLK_ZS_EOPEN;
2070 break;
2071 case BLK_ZONE_COND_CLOSED:
2072 zone->state = BLK_ZS_CLOSED;
2073 break;
2074 case BLK_ZONE_COND_READONLY:
2075 zone->state = BLK_ZS_RDONLY;
2076 break;
2077 case BLK_ZONE_COND_FULL:
2078 zone->state = BLK_ZS_FULL;
2079 break;
2080 case BLK_ZONE_COND_OFFLINE:
2081 zone->state = BLK_ZS_OFFLINE;
2082 break;
2083 default:
2084 error_report("Unsupported zone state: 0x%x", blkz->cond);
2085 return -ENOTSUP;
2086 }
2087 return 0;
2088}
2089#endif
2090
2091#if defined(CONFIG_BLKZONED)
2092static int handle_aiocb_zone_report(void *opaque)
2093{
2094 RawPosixAIOData *aiocb = opaque;
2095 int fd = aiocb->aio_fildes;
2096 unsigned int *nr_zones = aiocb->zone_report.nr_zones;
2097 BlockZoneDescriptor *zones = aiocb->zone_report.zones;
2098
2099 uint64_t sector = aiocb->aio_offset / 512;
2100
2101 struct blk_zone *blkz;
2102 size_t rep_size;
2103 unsigned int nrz;
2104 int ret;
2105 unsigned int n = 0, i = 0;
2106
2107 nrz = *nr_zones;
2108 rep_size = sizeof(struct blk_zone_report) + nrz * sizeof(struct blk_zone);
2109 g_autofree struct blk_zone_report *rep = NULL;
2110 rep = g_malloc(rep_size);
2111
2112 blkz = (struct blk_zone *)(rep + 1);
2113 while (n < nrz) {
2114 memset(rep, 0, rep_size);
2115 rep->sector = sector;
2116 rep->nr_zones = nrz - n;
2117
2118 do {
2119 ret = ioctl(fd, BLKREPORTZONE, rep);
2120 } while (ret != 0 && errno == EINTR);
2121 if (ret != 0) {
2122 error_report("%d: ioctl BLKREPORTZONE at %" PRId64 " failed %d",
2123 fd, sector, errno);
2124 return -errno;
2125 }
2126
2127 if (!rep->nr_zones) {
2128 break;
2129 }
2130
2131 for (i = 0; i < rep->nr_zones; i++, n++) {
2132 ret = parse_zone(&zones[n], &blkz[i]);
2133 if (ret != 0) {
2134 return ret;
2135 }
2136
2137
2138 sector = blkz[i].start + blkz[i].len;
2139 }
2140 }
2141
2142 *nr_zones = n;
2143 return 0;
2144}
2145#endif
2146
2147#if defined(CONFIG_BLKZONED)
2148static int handle_aiocb_zone_mgmt(void *opaque)
2149{
2150 RawPosixAIOData *aiocb = opaque;
2151 int fd = aiocb->aio_fildes;
2152 uint64_t sector = aiocb->aio_offset / 512;
2153 int64_t nr_sectors = aiocb->aio_nbytes / 512;
2154 struct blk_zone_range range;
2155 int ret;
2156
2157
2158 range.sector = sector;
2159 range.nr_sectors = nr_sectors;
2160 do {
2161 ret = ioctl(fd, aiocb->zone_mgmt.op, &range);
2162 } while (ret != 0 && errno == EINTR);
2163
2164 return ret < 0 ? -errno : ret;
2165}
2166#endif
2167
2168static int handle_aiocb_copy_range(void *opaque)
2169{
2170 RawPosixAIOData *aiocb = opaque;
2171 uint64_t bytes = aiocb->aio_nbytes;
2172 off_t in_off = aiocb->aio_offset;
2173 off_t out_off = aiocb->copy_range.aio_offset2;
2174
2175 while (bytes) {
2176 ssize_t ret = copy_file_range(aiocb->aio_fildes, &in_off,
2177 aiocb->copy_range.aio_fd2, &out_off,
2178 bytes, 0);
2179 trace_file_copy_file_range(aiocb->bs, aiocb->aio_fildes, in_off,
2180 aiocb->copy_range.aio_fd2, out_off, bytes,
2181 0, ret);
2182 if (ret == 0) {
2183
2184
2185 return -ENOSPC;
2186 }
2187 if (ret < 0) {
2188 switch (errno) {
2189 case ENOSYS:
2190 return -ENOTSUP;
2191 case EINTR:
2192 continue;
2193 default:
2194 return -errno;
2195 }
2196 }
2197 bytes -= ret;
2198 }
2199 return 0;
2200}
2201
2202static int handle_aiocb_discard(void *opaque)
2203{
2204 RawPosixAIOData *aiocb = opaque;
2205 int ret = -ENOTSUP;
2206 BDRVRawState *s = aiocb->bs->opaque;
2207
2208 if (!s->has_discard) {
2209 return -ENOTSUP;
2210 }
2211
2212 if (aiocb->aio_type & QEMU_AIO_BLKDEV) {
2213#ifdef BLKDISCARD
2214 do {
2215 uint64_t range[2] = { aiocb->aio_offset, aiocb->aio_nbytes };
2216 if (ioctl(aiocb->aio_fildes, BLKDISCARD, range) == 0) {
2217 return 0;
2218 }
2219 } while (errno == EINTR);
2220
2221 ret = translate_err(-errno);
2222#endif
2223 } else {
2224#ifdef CONFIG_FALLOCATE_PUNCH_HOLE
2225 ret = do_fallocate(s->fd, FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE,
2226 aiocb->aio_offset, aiocb->aio_nbytes);
2227 ret = translate_err(ret);
2228#elif defined(__APPLE__) && (__MACH__)
2229 fpunchhole_t fpunchhole;
2230 fpunchhole.fp_flags = 0;
2231 fpunchhole.reserved = 0;
2232 fpunchhole.fp_offset = aiocb->aio_offset;
2233 fpunchhole.fp_length = aiocb->aio_nbytes;
2234 if (fcntl(s->fd, F_PUNCHHOLE, &fpunchhole) == -1) {
2235 ret = errno == ENODEV ? -ENOTSUP : -errno;
2236 } else {
2237 ret = 0;
2238 }
2239#endif
2240 }
2241
2242 if (ret == -ENOTSUP) {
2243 s->has_discard = false;
2244 }
2245 return ret;
2246}
2247
2248
2249
2250
2251
2252
2253
2254
2255
2256
2257
2258
2259
2260
2261
2262static int allocate_first_block(int fd, size_t max_size)
2263{
2264 size_t write_size = (max_size < MAX_BLOCKSIZE)
2265 ? BDRV_SECTOR_SIZE
2266 : MAX_BLOCKSIZE;
2267 size_t max_align = MAX(MAX_BLOCKSIZE, qemu_real_host_page_size());
2268 void *buf;
2269 ssize_t n;
2270 int ret;
2271
2272 buf = qemu_memalign(max_align, write_size);
2273 memset(buf, 0, write_size);
2274
2275 n = RETRY_ON_EINTR(pwrite(fd, buf, write_size, 0));
2276
2277 ret = (n == -1) ? -errno : 0;
2278
2279 qemu_vfree(buf);
2280 return ret;
2281}
2282
2283static int handle_aiocb_truncate(void *opaque)
2284{
2285 RawPosixAIOData *aiocb = opaque;
2286 int result = 0;
2287 int64_t current_length = 0;
2288 char *buf = NULL;
2289 struct stat st;
2290 int fd = aiocb->aio_fildes;
2291 int64_t offset = aiocb->aio_offset;
2292 PreallocMode prealloc = aiocb->truncate.prealloc;
2293 Error **errp = aiocb->truncate.errp;
2294
2295 if (fstat(fd, &st) < 0) {
2296 result = -errno;
2297 error_setg_errno(errp, -result, "Could not stat file");
2298 return result;
2299 }
2300
2301 current_length = st.st_size;
2302 if (current_length > offset && prealloc != PREALLOC_MODE_OFF) {
2303 error_setg(errp, "Cannot use preallocation for shrinking files");
2304 return -ENOTSUP;
2305 }
2306
2307 switch (prealloc) {
2308#ifdef CONFIG_POSIX_FALLOCATE
2309 case PREALLOC_MODE_FALLOC:
2310
2311
2312
2313
2314
2315 if (offset != current_length) {
2316 result = -posix_fallocate(fd, current_length,
2317 offset - current_length);
2318 if (result != 0) {
2319
2320 error_setg_errno(errp, -result,
2321 "Could not preallocate new data");
2322 } else if (current_length == 0) {
2323
2324
2325
2326
2327
2328
2329
2330
2331
2332 allocate_first_block(fd, offset);
2333 }
2334 } else {
2335 result = 0;
2336 }
2337 goto out;
2338#endif
2339 case PREALLOC_MODE_FULL:
2340 {
2341 int64_t num = 0, left = offset - current_length;
2342 off_t seek_result;
2343
2344
2345
2346
2347
2348
2349 if (ftruncate(fd, offset) != 0) {
2350 result = -errno;
2351 error_setg_errno(errp, -result, "Could not resize file");
2352 goto out;
2353 }
2354
2355 buf = g_malloc0(65536);
2356
2357 seek_result = lseek(fd, current_length, SEEK_SET);
2358 if (seek_result < 0) {
2359 result = -errno;
2360 error_setg_errno(errp, -result,
2361 "Failed to seek to the old end of file");
2362 goto out;
2363 }
2364
2365 while (left > 0) {
2366 num = MIN(left, 65536);
2367 result = write(fd, buf, num);
2368 if (result < 0) {
2369 if (errno == EINTR) {
2370 continue;
2371 }
2372 result = -errno;
2373 error_setg_errno(errp, -result,
2374 "Could not write zeros for preallocation");
2375 goto out;
2376 }
2377 left -= result;
2378 }
2379 if (result >= 0) {
2380 result = fsync(fd);
2381 if (result < 0) {
2382 result = -errno;
2383 error_setg_errno(errp, -result,
2384 "Could not flush file to disk");
2385 goto out;
2386 }
2387 }
2388 goto out;
2389 }
2390 case PREALLOC_MODE_OFF:
2391 if (ftruncate(fd, offset) != 0) {
2392 result = -errno;
2393 error_setg_errno(errp, -result, "Could not resize file");
2394 } else if (current_length == 0 && offset > current_length) {
2395
2396 allocate_first_block(fd, offset);
2397 }
2398 return result;
2399 default:
2400 result = -ENOTSUP;
2401 error_setg(errp, "Unsupported preallocation mode: %s",
2402 PreallocMode_str(prealloc));
2403 return result;
2404 }
2405
2406out:
2407 if (result < 0) {
2408 if (ftruncate(fd, current_length) < 0) {
2409 error_report("Failed to restore old file length: %s",
2410 strerror(errno));
2411 }
2412 }
2413
2414 g_free(buf);
2415 return result;
2416}
2417
2418static int coroutine_fn raw_thread_pool_submit(ThreadPoolFunc func, void *arg)
2419{
2420 return thread_pool_submit_co(func, arg);
2421}
2422
2423
2424
2425
2426static bool bdrv_qiov_is_aligned(BlockDriverState *bs, QEMUIOVector *qiov)
2427{
2428 int i;
2429 size_t alignment = bdrv_min_mem_align(bs);
2430 size_t len = bs->bl.request_alignment;
2431 IO_CODE();
2432
2433 for (i = 0; i < qiov->niov; i++) {
2434 if ((uintptr_t) qiov->iov[i].iov_base % alignment) {
2435 return false;
2436 }
2437 if (qiov->iov[i].iov_len % len) {
2438 return false;
2439 }
2440 }
2441
2442 return true;
2443}
2444
2445static int coroutine_fn raw_co_prw(BlockDriverState *bs, uint64_t offset,
2446 uint64_t bytes, QEMUIOVector *qiov, int type)
2447{
2448 BDRVRawState *s = bs->opaque;
2449 RawPosixAIOData acb;
2450 int ret;
2451
2452 if (fd_open(bs) < 0)
2453 return -EIO;
2454#if defined(CONFIG_BLKZONED)
2455 if ((type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND)) && bs->wps) {
2456 qemu_co_mutex_lock(&bs->wps->colock);
2457 if (type & QEMU_AIO_ZONE_APPEND && bs->bl.zone_size) {
2458 int index = offset / bs->bl.zone_size;
2459 offset = bs->wps->wp[index];
2460 }
2461 }
2462#endif
2463
2464
2465
2466
2467
2468
2469
2470 if (s->needs_alignment && !bdrv_qiov_is_aligned(bs, qiov)) {
2471 type |= QEMU_AIO_MISALIGNED;
2472#ifdef CONFIG_LINUX_IO_URING
2473 } else if (s->use_linux_io_uring) {
2474 assert(qiov->size == bytes);
2475 ret = luring_co_submit(bs, s->fd, offset, qiov, type);
2476 goto out;
2477#endif
2478#ifdef CONFIG_LINUX_AIO
2479 } else if (s->use_linux_aio) {
2480 assert(qiov->size == bytes);
2481 ret = laio_co_submit(s->fd, offset, qiov, type,
2482 s->aio_max_batch);
2483 goto out;
2484#endif
2485 }
2486
2487 acb = (RawPosixAIOData) {
2488 .bs = bs,
2489 .aio_fildes = s->fd,
2490 .aio_type = type,
2491 .aio_offset = offset,
2492 .aio_nbytes = bytes,
2493 .io = {
2494 .iov = qiov->iov,
2495 .niov = qiov->niov,
2496 },
2497 };
2498
2499 assert(qiov->size == bytes);
2500 ret = raw_thread_pool_submit(handle_aiocb_rw, &acb);
2501 goto out;
2502
2503out:
2504#if defined(CONFIG_BLKZONED)
2505{
2506 BlockZoneWps *wps = bs->wps;
2507 if (ret == 0) {
2508 if ((type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND))
2509 && wps && bs->bl.zone_size) {
2510 uint64_t *wp = &wps->wp[offset / bs->bl.zone_size];
2511 if (!BDRV_ZT_IS_CONV(*wp)) {
2512 if (type & QEMU_AIO_ZONE_APPEND) {
2513 *s->offset = *wp;
2514 trace_zbd_zone_append_complete(bs, *s->offset
2515 >> BDRV_SECTOR_BITS);
2516 }
2517
2518 if (offset + bytes > *wp) {
2519 *wp = offset + bytes;
2520 }
2521 }
2522 }
2523 } else {
2524 if (type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND)) {
2525 update_zones_wp(bs, s->fd, 0, 1);
2526 }
2527 }
2528
2529 if ((type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND)) && wps) {
2530 qemu_co_mutex_unlock(&wps->colock);
2531 }
2532}
2533#endif
2534 return ret;
2535}
2536
2537static int coroutine_fn raw_co_preadv(BlockDriverState *bs, int64_t offset,
2538 int64_t bytes, QEMUIOVector *qiov,
2539 BdrvRequestFlags flags)
2540{
2541 return raw_co_prw(bs, offset, bytes, qiov, QEMU_AIO_READ);
2542}
2543
2544static int coroutine_fn raw_co_pwritev(BlockDriverState *bs, int64_t offset,
2545 int64_t bytes, QEMUIOVector *qiov,
2546 BdrvRequestFlags flags)
2547{
2548 return raw_co_prw(bs, offset, bytes, qiov, QEMU_AIO_WRITE);
2549}
2550
2551static int coroutine_fn raw_co_flush_to_disk(BlockDriverState *bs)
2552{
2553 BDRVRawState *s = bs->opaque;
2554 RawPosixAIOData acb;
2555 int ret;
2556
2557 ret = fd_open(bs);
2558 if (ret < 0) {
2559 return ret;
2560 }
2561
2562 acb = (RawPosixAIOData) {
2563 .bs = bs,
2564 .aio_fildes = s->fd,
2565 .aio_type = QEMU_AIO_FLUSH,
2566 };
2567
2568#ifdef CONFIG_LINUX_IO_URING
2569 if (s->use_linux_io_uring) {
2570 return luring_co_submit(bs, s->fd, 0, NULL, QEMU_AIO_FLUSH);
2571 }
2572#endif
2573 return raw_thread_pool_submit(handle_aiocb_flush, &acb);
2574}
2575
2576static void raw_aio_attach_aio_context(BlockDriverState *bs,
2577 AioContext *new_context)
2578{
2579 BDRVRawState __attribute__((unused)) *s = bs->opaque;
2580#ifdef CONFIG_LINUX_AIO
2581 if (s->use_linux_aio) {
2582 Error *local_err = NULL;
2583 if (!aio_setup_linux_aio(new_context, &local_err)) {
2584 error_reportf_err(local_err, "Unable to use native AIO, "
2585 "falling back to thread pool: ");
2586 s->use_linux_aio = false;
2587 }
2588 }
2589#endif
2590#ifdef CONFIG_LINUX_IO_URING
2591 if (s->use_linux_io_uring) {
2592 Error *local_err = NULL;
2593 if (!aio_setup_linux_io_uring(new_context, &local_err)) {
2594 error_reportf_err(local_err, "Unable to use linux io_uring, "
2595 "falling back to thread pool: ");
2596 s->use_linux_io_uring = false;
2597 }
2598 }
2599#endif
2600}
2601
2602static void raw_close(BlockDriverState *bs)
2603{
2604 BDRVRawState *s = bs->opaque;
2605
2606 if (s->fd >= 0) {
2607#if defined(CONFIG_BLKZONED)
2608 g_free(bs->wps);
2609#endif
2610 qemu_close(s->fd);
2611 s->fd = -1;
2612 }
2613}
2614
2615
2616
2617
2618
2619
2620
2621static int coroutine_fn
2622raw_regular_truncate(BlockDriverState *bs, int fd, int64_t offset,
2623 PreallocMode prealloc, Error **errp)
2624{
2625 RawPosixAIOData acb;
2626
2627 acb = (RawPosixAIOData) {
2628 .bs = bs,
2629 .aio_fildes = fd,
2630 .aio_type = QEMU_AIO_TRUNCATE,
2631 .aio_offset = offset,
2632 .truncate = {
2633 .prealloc = prealloc,
2634 .errp = errp,
2635 },
2636 };
2637
2638 return raw_thread_pool_submit(handle_aiocb_truncate, &acb);
2639}
2640
2641static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,
2642 bool exact, PreallocMode prealloc,
2643 BdrvRequestFlags flags, Error **errp)
2644{
2645 BDRVRawState *s = bs->opaque;
2646 struct stat st;
2647 int ret;
2648
2649 if (fstat(s->fd, &st)) {
2650 ret = -errno;
2651 error_setg_errno(errp, -ret, "Failed to fstat() the file");
2652 return ret;
2653 }
2654
2655 if (S_ISREG(st.st_mode)) {
2656
2657 return raw_regular_truncate(bs, s->fd, offset, prealloc, errp);
2658 }
2659
2660 if (prealloc != PREALLOC_MODE_OFF) {
2661 error_setg(errp, "Preallocation mode '%s' unsupported for this "
2662 "non-regular file", PreallocMode_str(prealloc));
2663 return -ENOTSUP;
2664 }
2665
2666 if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) {
2667 int64_t cur_length = raw_getlength(bs);
2668
2669 if (offset != cur_length && exact) {
2670 error_setg(errp, "Cannot resize device files");
2671 return -ENOTSUP;
2672 } else if (offset > cur_length) {
2673 error_setg(errp, "Cannot grow device files");
2674 return -EINVAL;
2675 }
2676 } else {
2677 error_setg(errp, "Resizing this file is not supported");
2678 return -ENOTSUP;
2679 }
2680
2681 return 0;
2682}
2683
2684#ifdef __OpenBSD__
2685static int64_t raw_getlength(BlockDriverState *bs)
2686{
2687 BDRVRawState *s = bs->opaque;
2688 int fd = s->fd;
2689 struct stat st;
2690
2691 if (fstat(fd, &st))
2692 return -errno;
2693 if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) {
2694 struct disklabel dl;
2695
2696 if (ioctl(fd, DIOCGDINFO, &dl))
2697 return -errno;
2698 return (uint64_t)dl.d_secsize *
2699 dl.d_partitions[DISKPART(st.st_rdev)].p_size;
2700 } else
2701 return st.st_size;
2702}
2703#elif defined(__NetBSD__)
2704static int64_t raw_getlength(BlockDriverState *bs)
2705{
2706 BDRVRawState *s = bs->opaque;
2707 int fd = s->fd;
2708 struct stat st;
2709
2710 if (fstat(fd, &st))
2711 return -errno;
2712 if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) {
2713 struct dkwedge_info dkw;
2714
2715 if (ioctl(fd, DIOCGWEDGEINFO, &dkw) != -1) {
2716 return dkw.dkw_size * 512;
2717 } else {
2718 struct disklabel dl;
2719
2720 if (ioctl(fd, DIOCGDINFO, &dl))
2721 return -errno;
2722 return (uint64_t)dl.d_secsize *
2723 dl.d_partitions[DISKPART(st.st_rdev)].p_size;
2724 }
2725 } else
2726 return st.st_size;
2727}
2728#elif defined(__sun__)
2729static int64_t raw_getlength(BlockDriverState *bs)
2730{
2731 BDRVRawState *s = bs->opaque;
2732 struct dk_minfo minfo;
2733 int ret;
2734 int64_t size;
2735
2736 ret = fd_open(bs);
2737 if (ret < 0) {
2738 return ret;
2739 }
2740
2741
2742
2743
2744 ret = ioctl(s->fd, DKIOCGMEDIAINFO, &minfo);
2745 if (ret != -1) {
2746 return minfo.dki_lbsize * minfo.dki_capacity;
2747 }
2748
2749
2750
2751
2752
2753 size = lseek(s->fd, 0, SEEK_END);
2754 if (size < 0) {
2755 return -errno;
2756 }
2757 return size;
2758}
2759#elif defined(CONFIG_BSD)
2760static int64_t raw_getlength(BlockDriverState *bs)
2761{
2762 BDRVRawState *s = bs->opaque;
2763 int fd = s->fd;
2764 int64_t size;
2765 struct stat sb;
2766#if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
2767 int reopened = 0;
2768#endif
2769 int ret;
2770
2771 ret = fd_open(bs);
2772 if (ret < 0)
2773 return ret;
2774
2775#if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
2776again:
2777#endif
2778 if (!fstat(fd, &sb) && (S_IFCHR & sb.st_mode)) {
2779 size = 0;
2780#ifdef DIOCGMEDIASIZE
2781 if (ioctl(fd, DIOCGMEDIASIZE, (off_t *)&size)) {
2782 size = 0;
2783 }
2784#endif
2785#ifdef DIOCGPART
2786 if (size == 0) {
2787 struct partinfo pi;
2788 if (ioctl(fd, DIOCGPART, &pi) == 0) {
2789 size = pi.media_size;
2790 }
2791 }
2792#endif
2793#if defined(DKIOCGETBLOCKCOUNT) && defined(DKIOCGETBLOCKSIZE)
2794 if (size == 0) {
2795 uint64_t sectors = 0;
2796 uint32_t sector_size = 0;
2797
2798 if (ioctl(fd, DKIOCGETBLOCKCOUNT, §ors) == 0
2799 && ioctl(fd, DKIOCGETBLOCKSIZE, §or_size) == 0) {
2800 size = sectors * sector_size;
2801 }
2802 }
2803#endif
2804 if (size == 0) {
2805 size = lseek(fd, 0LL, SEEK_END);
2806 }
2807 if (size < 0) {
2808 return -errno;
2809 }
2810#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
2811 switch(s->type) {
2812 case FTYPE_CD:
2813
2814 if (size == 2048LL * (unsigned)-1)
2815 size = 0;
2816
2817 if (size <= 0 && !reopened && cdrom_reopen(bs) >= 0) {
2818 reopened = 1;
2819 goto again;
2820 }
2821 }
2822#endif
2823 } else {
2824 size = lseek(fd, 0, SEEK_END);
2825 if (size < 0) {
2826 return -errno;
2827 }
2828 }
2829 return size;
2830}
2831#else
2832static int64_t raw_getlength(BlockDriverState *bs)
2833{
2834 BDRVRawState *s = bs->opaque;
2835 int ret;
2836 int64_t size;
2837
2838 ret = fd_open(bs);
2839 if (ret < 0) {
2840 return ret;
2841 }
2842
2843 size = lseek(s->fd, 0, SEEK_END);
2844 if (size < 0) {
2845 return -errno;
2846 }
2847 return size;
2848}
2849#endif
2850
2851static int64_t coroutine_fn raw_co_getlength(BlockDriverState *bs)
2852{
2853 return raw_getlength(bs);
2854}
2855
2856static int64_t coroutine_fn raw_co_get_allocated_file_size(BlockDriverState *bs)
2857{
2858 struct stat st;
2859 BDRVRawState *s = bs->opaque;
2860
2861 if (fstat(s->fd, &st) < 0) {
2862 return -errno;
2863 }
2864 return (int64_t)st.st_blocks * 512;
2865}
2866
2867static int coroutine_fn
2868raw_co_create(BlockdevCreateOptions *options, Error **errp)
2869{
2870 BlockdevCreateOptionsFile *file_opts;
2871 Error *local_err = NULL;
2872 int fd;
2873 uint64_t perm, shared;
2874 int result = 0;
2875
2876
2877 assert(options->driver == BLOCKDEV_DRIVER_FILE);
2878 file_opts = &options->u.file;
2879
2880 if (!file_opts->has_nocow) {
2881 file_opts->nocow = false;
2882 }
2883 if (!file_opts->has_preallocation) {
2884 file_opts->preallocation = PREALLOC_MODE_OFF;
2885 }
2886 if (!file_opts->has_extent_size_hint) {
2887 file_opts->extent_size_hint = 1 * MiB;
2888 }
2889 if (file_opts->extent_size_hint > UINT32_MAX) {
2890 result = -EINVAL;
2891 error_setg(errp, "Extent size hint is too large");
2892 goto out;
2893 }
2894
2895
2896 fd = qemu_create(file_opts->filename, O_RDWR | O_BINARY, 0644, errp);
2897 if (fd < 0) {
2898 result = -errno;
2899 goto out;
2900 }
2901
2902
2903
2904
2905
2906
2907
2908
2909
2910
2911
2912 perm = BLK_PERM_WRITE | BLK_PERM_RESIZE;
2913 shared = BLK_PERM_ALL & ~BLK_PERM_RESIZE;
2914
2915
2916 result = raw_apply_lock_bytes(NULL, fd, perm, ~shared, false, errp);
2917 if (result < 0) {
2918 goto out_close;
2919 }
2920
2921
2922 result = raw_check_lock_bytes(fd, perm, shared, errp);
2923 if (result < 0) {
2924 error_append_hint(errp,
2925 "Is another process using the image [%s]?\n",
2926 file_opts->filename);
2927 goto out_unlock;
2928 }
2929
2930
2931 result = raw_regular_truncate(NULL, fd, 0, PREALLOC_MODE_OFF, errp);
2932 if (result < 0) {
2933 goto out_unlock;
2934 }
2935
2936 if (file_opts->nocow) {
2937#ifdef __linux__
2938
2939
2940
2941
2942
2943 int attr;
2944 if (ioctl(fd, FS_IOC_GETFLAGS, &attr) == 0) {
2945 attr |= FS_NOCOW_FL;
2946 ioctl(fd, FS_IOC_SETFLAGS, &attr);
2947 }
2948#endif
2949 }
2950#ifdef FS_IOC_FSSETXATTR
2951
2952
2953
2954
2955 {
2956 struct fsxattr attr;
2957 result = ioctl(fd, FS_IOC_FSGETXATTR, &attr);
2958 if (result == 0) {
2959 attr.fsx_xflags |= FS_XFLAG_EXTSIZE;
2960 attr.fsx_extsize = file_opts->extent_size_hint;
2961 result = ioctl(fd, FS_IOC_FSSETXATTR, &attr);
2962 }
2963 if (result < 0 && file_opts->has_extent_size_hint &&
2964 file_opts->extent_size_hint)
2965 {
2966 warn_report("Failed to set extent size hint: %s",
2967 strerror(errno));
2968 }
2969 }
2970#endif
2971
2972
2973
2974 result = raw_regular_truncate(NULL, fd, file_opts->size,
2975 file_opts->preallocation, errp);
2976 if (result < 0) {
2977 goto out_unlock;
2978 }
2979
2980out_unlock:
2981 raw_apply_lock_bytes(NULL, fd, 0, 0, true, &local_err);
2982 if (local_err) {
2983
2984
2985
2986
2987 warn_report_err(local_err);
2988 }
2989
2990out_close:
2991 if (qemu_close(fd) != 0 && result == 0) {
2992 result = -errno;
2993 error_setg_errno(errp, -result, "Could not close the new file");
2994 }
2995out:
2996 return result;
2997}
2998
2999static int coroutine_fn GRAPH_RDLOCK
3000raw_co_create_opts(BlockDriver *drv, const char *filename,
3001 QemuOpts *opts, Error **errp)
3002{
3003 BlockdevCreateOptions options;
3004 int64_t total_size = 0;
3005 int64_t extent_size_hint = 0;
3006 bool has_extent_size_hint = false;
3007 bool nocow = false;
3008 PreallocMode prealloc;
3009 char *buf = NULL;
3010 Error *local_err = NULL;
3011
3012
3013 strstart(filename, "file:", &filename);
3014
3015
3016 total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
3017 BDRV_SECTOR_SIZE);
3018 if (qemu_opt_get(opts, BLOCK_OPT_EXTENT_SIZE_HINT)) {
3019 has_extent_size_hint = true;
3020 extent_size_hint =
3021 qemu_opt_get_size_del(opts, BLOCK_OPT_EXTENT_SIZE_HINT, -1);
3022 }
3023 nocow = qemu_opt_get_bool(opts, BLOCK_OPT_NOCOW, false);
3024 buf = qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC);
3025 prealloc = qapi_enum_parse(&PreallocMode_lookup, buf,
3026 PREALLOC_MODE_OFF, &local_err);
3027 g_free(buf);
3028 if (local_err) {
3029 error_propagate(errp, local_err);
3030 return -EINVAL;
3031 }
3032
3033 options = (BlockdevCreateOptions) {
3034 .driver = BLOCKDEV_DRIVER_FILE,
3035 .u.file = {
3036 .filename = (char *) filename,
3037 .size = total_size,
3038 .has_preallocation = true,
3039 .preallocation = prealloc,
3040 .has_nocow = true,
3041 .nocow = nocow,
3042 .has_extent_size_hint = has_extent_size_hint,
3043 .extent_size_hint = extent_size_hint,
3044 },
3045 };
3046 return raw_co_create(&options, errp);
3047}
3048
3049static int coroutine_fn raw_co_delete_file(BlockDriverState *bs,
3050 Error **errp)
3051{
3052 struct stat st;
3053 int ret;
3054
3055 if (!(stat(bs->filename, &st) == 0) || !S_ISREG(st.st_mode)) {
3056 error_setg_errno(errp, ENOENT, "%s is not a regular file",
3057 bs->filename);
3058 return -ENOENT;
3059 }
3060
3061 ret = unlink(bs->filename);
3062 if (ret < 0) {
3063 ret = -errno;
3064 error_setg_errno(errp, -ret, "Error when deleting file %s",
3065 bs->filename);
3066 }
3067
3068 return ret;
3069}
3070
3071
3072
3073
3074
3075
3076
3077
3078
3079
3080
3081static int find_allocation(BlockDriverState *bs, off_t start,
3082 off_t *data, off_t *hole)
3083{
3084#if defined SEEK_HOLE && defined SEEK_DATA
3085 BDRVRawState *s = bs->opaque;
3086 off_t offs;
3087
3088
3089
3090
3091
3092
3093
3094
3095
3096
3097
3098
3099 offs = lseek(s->fd, start, SEEK_DATA);
3100 if (offs < 0) {
3101 return -errno;
3102 }
3103
3104 if (offs < start) {
3105
3106
3107 return -EIO;
3108 }
3109
3110 if (offs > start) {
3111
3112 *hole = start;
3113 *data = offs;
3114 return 0;
3115 }
3116
3117
3118
3119
3120
3121
3122
3123
3124
3125
3126
3127
3128
3129
3130
3131
3132
3133
3134
3135
3136 offs = lseek(s->fd, start, SEEK_HOLE);
3137 if (offs < 0) {
3138 return -errno;
3139 }
3140
3141 if (offs < start) {
3142
3143
3144 return -EIO;
3145 }
3146
3147 if (offs > start) {
3148
3149
3150
3151
3152
3153
3154 *data = start;
3155 *hole = offs;
3156 return 0;
3157 }
3158
3159
3160 return -EBUSY;
3161#else
3162 return -ENOTSUP;
3163#endif
3164}
3165
3166
3167
3168
3169
3170
3171
3172
3173
3174
3175
3176
3177
3178static int coroutine_fn raw_co_block_status(BlockDriverState *bs,
3179 bool want_zero,
3180 int64_t offset,
3181 int64_t bytes, int64_t *pnum,
3182 int64_t *map,
3183 BlockDriverState **file)
3184{
3185 off_t data = 0, hole = 0;
3186 int ret;
3187
3188 assert(QEMU_IS_ALIGNED(offset | bytes, bs->bl.request_alignment));
3189
3190 ret = fd_open(bs);
3191 if (ret < 0) {
3192 return ret;
3193 }
3194
3195 if (!want_zero) {
3196 *pnum = bytes;
3197 *map = offset;
3198 *file = bs;
3199 return BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID;
3200 }
3201
3202 ret = find_allocation(bs, offset, &data, &hole);
3203 if (ret == -ENXIO) {
3204
3205 *pnum = bytes;
3206 ret = BDRV_BLOCK_ZERO;
3207 } else if (ret < 0) {
3208
3209 *pnum = bytes;
3210 ret = BDRV_BLOCK_DATA;
3211 } else if (data == offset) {
3212
3213
3214 *pnum = hole - offset;
3215
3216
3217
3218
3219
3220 if (!QEMU_IS_ALIGNED(*pnum, bs->bl.request_alignment)) {
3221 int64_t file_length = raw_getlength(bs);
3222 if (file_length > 0) {
3223
3224 assert(hole == file_length);
3225 }
3226 *pnum = ROUND_UP(*pnum, bs->bl.request_alignment);
3227 }
3228
3229 ret = BDRV_BLOCK_DATA;
3230 } else {
3231
3232 assert(hole == offset);
3233 *pnum = data - offset;
3234 ret = BDRV_BLOCK_ZERO;
3235 }
3236 *map = offset;
3237 *file = bs;
3238 return ret | BDRV_BLOCK_OFFSET_VALID;
3239}
3240
3241#if defined(__linux__)
3242
3243static void check_cache_dropped(BlockDriverState *bs, Error **errp)
3244{
3245 const size_t window_size = 128 * 1024 * 1024;
3246 BDRVRawState *s = bs->opaque;
3247 void *window = NULL;
3248 size_t length = 0;
3249 unsigned char *vec;
3250 size_t page_size;
3251 off_t offset;
3252 off_t end;
3253
3254
3255 page_size = sysconf(_SC_PAGESIZE);
3256 vec = g_malloc(DIV_ROUND_UP(window_size, page_size));
3257
3258 end = raw_getlength(bs);
3259
3260 for (offset = 0; offset < end; offset += window_size) {
3261 void *new_window;
3262 size_t new_length;
3263 size_t vec_end;
3264 size_t i;
3265 int ret;
3266
3267
3268 new_length = MIN(end - offset, window_size);
3269 if (new_length != length) {
3270 munmap(window, length);
3271 window = NULL;
3272 length = 0;
3273 }
3274
3275 new_window = mmap(window, new_length, PROT_NONE, MAP_PRIVATE,
3276 s->fd, offset);
3277 if (new_window == MAP_FAILED) {
3278 error_setg_errno(errp, errno, "mmap failed");
3279 break;
3280 }
3281
3282 window = new_window;
3283 length = new_length;
3284
3285 ret = mincore(window, length, vec);
3286 if (ret < 0) {
3287 error_setg_errno(errp, errno, "mincore failed");
3288 break;
3289 }
3290
3291 vec_end = DIV_ROUND_UP(length, page_size);
3292 for (i = 0; i < vec_end; i++) {
3293 if (vec[i] & 0x1) {
3294 break;
3295 }
3296 }
3297 if (i < vec_end) {
3298 error_setg(errp, "page cache still in use!");
3299 break;
3300 }
3301 }
3302
3303 if (window) {
3304 munmap(window, length);
3305 }
3306
3307 g_free(vec);
3308}
3309#endif
3310
3311static void coroutine_fn GRAPH_RDLOCK
3312raw_co_invalidate_cache(BlockDriverState *bs, Error **errp)
3313{
3314 BDRVRawState *s = bs->opaque;
3315 int ret;
3316
3317 ret = fd_open(bs);
3318 if (ret < 0) {
3319 error_setg_errno(errp, -ret, "The file descriptor is not open");
3320 return;
3321 }
3322
3323 if (!s->drop_cache) {
3324 return;
3325 }
3326
3327 if (s->open_flags & O_DIRECT) {
3328 return;
3329 }
3330
3331#if defined(__linux__)
3332
3333 ret = bdrv_co_flush(bs);
3334 if (ret < 0) {
3335 error_setg_errno(errp, -ret, "flush failed");
3336 return;
3337 }
3338
3339
3340
3341
3342
3343 ret = posix_fadvise(s->fd, 0, 0, POSIX_FADV_DONTNEED);
3344 if (ret != 0) {
3345 error_setg_errno(errp, ret, "fadvise failed");
3346 return;
3347 }
3348
3349 if (s->check_cache_dropped) {
3350 check_cache_dropped(bs, errp);
3351 }
3352#else
3353
3354
3355
3356
3357
3358
3359#endif
3360}
3361
3362static void raw_account_discard(BDRVRawState *s, uint64_t nbytes, int ret)
3363{
3364 if (ret) {
3365 s->stats.discard_nb_failed++;
3366 } else {
3367 s->stats.discard_nb_ok++;
3368 s->stats.discard_bytes_ok += nbytes;
3369 }
3370}
3371
3372
3373
3374
3375
3376
3377
3378
3379#if defined(CONFIG_BLKZONED)
3380static int coroutine_fn raw_co_zone_report(BlockDriverState *bs, int64_t offset,
3381 unsigned int *nr_zones,
3382 BlockZoneDescriptor *zones) {
3383 BDRVRawState *s = bs->opaque;
3384 RawPosixAIOData acb = (RawPosixAIOData) {
3385 .bs = bs,
3386 .aio_fildes = s->fd,
3387 .aio_type = QEMU_AIO_ZONE_REPORT,
3388 .aio_offset = offset,
3389 .zone_report = {
3390 .nr_zones = nr_zones,
3391 .zones = zones,
3392 },
3393 };
3394
3395 trace_zbd_zone_report(bs, *nr_zones, offset >> BDRV_SECTOR_BITS);
3396 return raw_thread_pool_submit(handle_aiocb_zone_report, &acb);
3397}
3398#endif
3399
3400
3401
3402
3403#if defined(CONFIG_BLKZONED)
3404static int coroutine_fn raw_co_zone_mgmt(BlockDriverState *bs, BlockZoneOp op,
3405 int64_t offset, int64_t len) {
3406 BDRVRawState *s = bs->opaque;
3407 RawPosixAIOData acb;
3408 int64_t zone_size, zone_size_mask;
3409 const char *op_name;
3410 unsigned long zo;
3411 int ret;
3412 BlockZoneWps *wps = bs->wps;
3413 int64_t capacity = bs->total_sectors << BDRV_SECTOR_BITS;
3414
3415 zone_size = bs->bl.zone_size;
3416 zone_size_mask = zone_size - 1;
3417 if (offset & zone_size_mask) {
3418 error_report("sector offset %" PRId64 " is not aligned to zone size "
3419 "%" PRId64 "", offset / 512, zone_size / 512);
3420 return -EINVAL;
3421 }
3422
3423 if (((offset + len) < capacity && len & zone_size_mask) ||
3424 offset + len > capacity) {
3425 error_report("number of sectors %" PRId64 " is not aligned to zone size"
3426 " %" PRId64 "", len / 512, zone_size / 512);
3427 return -EINVAL;
3428 }
3429
3430 uint32_t i = offset / bs->bl.zone_size;
3431 uint32_t nrz = len / bs->bl.zone_size;
3432 uint64_t *wp = &wps->wp[i];
3433 if (BDRV_ZT_IS_CONV(*wp) && len != capacity) {
3434 error_report("zone mgmt operations are not allowed for conventional zones");
3435 return -EIO;
3436 }
3437
3438 switch (op) {
3439 case BLK_ZO_OPEN:
3440 op_name = "BLKOPENZONE";
3441 zo = BLKOPENZONE;
3442 break;
3443 case BLK_ZO_CLOSE:
3444 op_name = "BLKCLOSEZONE";
3445 zo = BLKCLOSEZONE;
3446 break;
3447 case BLK_ZO_FINISH:
3448 op_name = "BLKFINISHZONE";
3449 zo = BLKFINISHZONE;
3450 break;
3451 case BLK_ZO_RESET:
3452 op_name = "BLKRESETZONE";
3453 zo = BLKRESETZONE;
3454 break;
3455 default:
3456 error_report("Unsupported zone op: 0x%x", op);
3457 return -ENOTSUP;
3458 }
3459
3460 acb = (RawPosixAIOData) {
3461 .bs = bs,
3462 .aio_fildes = s->fd,
3463 .aio_type = QEMU_AIO_ZONE_MGMT,
3464 .aio_offset = offset,
3465 .aio_nbytes = len,
3466 .zone_mgmt = {
3467 .op = zo,
3468 },
3469 };
3470
3471 trace_zbd_zone_mgmt(bs, op_name, offset >> BDRV_SECTOR_BITS,
3472 len >> BDRV_SECTOR_BITS);
3473 ret = raw_thread_pool_submit(handle_aiocb_zone_mgmt, &acb);
3474 if (ret != 0) {
3475 update_zones_wp(bs, s->fd, offset, i);
3476 error_report("ioctl %s failed %d", op_name, ret);
3477 return ret;
3478 }
3479
3480 if (zo == BLKRESETZONE && len == capacity) {
3481 ret = get_zones_wp(bs, s->fd, 0, bs->bl.nr_zones, 1);
3482 if (ret < 0) {
3483 error_report("reporting single wp failed");
3484 return ret;
3485 }
3486 } else if (zo == BLKRESETZONE) {
3487 for (unsigned int j = 0; j < nrz; ++j) {
3488 wp[j] = offset + j * zone_size;
3489 }
3490 } else if (zo == BLKFINISHZONE) {
3491 for (unsigned int j = 0; j < nrz; ++j) {
3492
3493
3494 wp[j] = MIN(offset + (j + 1) * zone_size, offset + len);
3495 }
3496 }
3497
3498 return ret;
3499}
3500#endif
3501
3502#if defined(CONFIG_BLKZONED)
3503static int coroutine_fn raw_co_zone_append(BlockDriverState *bs,
3504 int64_t *offset,
3505 QEMUIOVector *qiov,
3506 BdrvRequestFlags flags) {
3507 assert(flags == 0);
3508 int64_t zone_size_mask = bs->bl.zone_size - 1;
3509 int64_t iov_len = 0;
3510 int64_t len = 0;
3511 BDRVRawState *s = bs->opaque;
3512 s->offset = offset;
3513
3514 if (*offset & zone_size_mask) {
3515 error_report("sector offset %" PRId64 " is not aligned to zone size "
3516 "%" PRId32 "", *offset / 512, bs->bl.zone_size / 512);
3517 return -EINVAL;
3518 }
3519
3520 int64_t wg = bs->bl.write_granularity;
3521 int64_t wg_mask = wg - 1;
3522 for (int i = 0; i < qiov->niov; i++) {
3523 iov_len = qiov->iov[i].iov_len;
3524 if (iov_len & wg_mask) {
3525 error_report("len of IOVector[%d] %" PRId64 " is not aligned to "
3526 "block size %" PRId64 "", i, iov_len, wg);
3527 return -EINVAL;
3528 }
3529 len += iov_len;
3530 }
3531
3532 trace_zbd_zone_append(bs, *offset >> BDRV_SECTOR_BITS);
3533 return raw_co_prw(bs, *offset, len, qiov, QEMU_AIO_ZONE_APPEND);
3534}
3535#endif
3536
3537static coroutine_fn int
3538raw_do_pdiscard(BlockDriverState *bs, int64_t offset, int64_t bytes,
3539 bool blkdev)
3540{
3541 BDRVRawState *s = bs->opaque;
3542 RawPosixAIOData acb;
3543 int ret;
3544
3545 acb = (RawPosixAIOData) {
3546 .bs = bs,
3547 .aio_fildes = s->fd,
3548 .aio_type = QEMU_AIO_DISCARD,
3549 .aio_offset = offset,
3550 .aio_nbytes = bytes,
3551 };
3552
3553 if (blkdev) {
3554 acb.aio_type |= QEMU_AIO_BLKDEV;
3555 }
3556
3557 ret = raw_thread_pool_submit(handle_aiocb_discard, &acb);
3558 raw_account_discard(s, bytes, ret);
3559 return ret;
3560}
3561
3562static coroutine_fn int
3563raw_co_pdiscard(BlockDriverState *bs, int64_t offset, int64_t bytes)
3564{
3565 return raw_do_pdiscard(bs, offset, bytes, false);
3566}
3567
3568static int coroutine_fn
3569raw_do_pwrite_zeroes(BlockDriverState *bs, int64_t offset, int64_t bytes,
3570 BdrvRequestFlags flags, bool blkdev)
3571{
3572 BDRVRawState *s = bs->opaque;
3573 RawPosixAIOData acb;
3574 ThreadPoolFunc *handler;
3575
3576#ifdef CONFIG_FALLOCATE
3577 if (offset + bytes > bs->total_sectors * BDRV_SECTOR_SIZE) {
3578 BdrvTrackedRequest *req;
3579
3580
3581
3582
3583
3584
3585
3586
3587
3588
3589
3590
3591
3592
3593
3594
3595
3596 req = bdrv_co_get_self_request(bs);
3597 assert(req);
3598 assert(req->type == BDRV_TRACKED_WRITE);
3599 assert(req->offset <= offset);
3600 assert(req->offset + req->bytes >= offset + bytes);
3601
3602 req->bytes = BDRV_MAX_LENGTH - req->offset;
3603
3604 bdrv_check_request(req->offset, req->bytes, &error_abort);
3605
3606 bdrv_make_request_serialising(req, bs->bl.request_alignment);
3607 }
3608#endif
3609
3610 acb = (RawPosixAIOData) {
3611 .bs = bs,
3612 .aio_fildes = s->fd,
3613 .aio_type = QEMU_AIO_WRITE_ZEROES,
3614 .aio_offset = offset,
3615 .aio_nbytes = bytes,
3616 };
3617
3618 if (blkdev) {
3619 acb.aio_type |= QEMU_AIO_BLKDEV;
3620 }
3621 if (flags & BDRV_REQ_NO_FALLBACK) {
3622 acb.aio_type |= QEMU_AIO_NO_FALLBACK;
3623 }
3624
3625 if (flags & BDRV_REQ_MAY_UNMAP) {
3626 acb.aio_type |= QEMU_AIO_DISCARD;
3627 handler = handle_aiocb_write_zeroes_unmap;
3628 } else {
3629 handler = handle_aiocb_write_zeroes;
3630 }
3631
3632 return raw_thread_pool_submit(handler, &acb);
3633}
3634
3635static int coroutine_fn raw_co_pwrite_zeroes(
3636 BlockDriverState *bs, int64_t offset,
3637 int64_t bytes, BdrvRequestFlags flags)
3638{
3639 return raw_do_pwrite_zeroes(bs, offset, bytes, flags, false);
3640}
3641
3642static int coroutine_fn
3643raw_co_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
3644{
3645 return 0;
3646}
3647
3648static ImageInfoSpecific *raw_get_specific_info(BlockDriverState *bs,
3649 Error **errp)
3650{
3651 ImageInfoSpecificFile *file_info = g_new0(ImageInfoSpecificFile, 1);
3652 ImageInfoSpecific *spec_info = g_new(ImageInfoSpecific, 1);
3653
3654 *spec_info = (ImageInfoSpecific){
3655 .type = IMAGE_INFO_SPECIFIC_KIND_FILE,
3656 .u.file.data = file_info,
3657 };
3658
3659#ifdef FS_IOC_FSGETXATTR
3660 {
3661 BDRVRawState *s = bs->opaque;
3662 struct fsxattr attr;
3663 int ret;
3664
3665 ret = ioctl(s->fd, FS_IOC_FSGETXATTR, &attr);
3666 if (!ret && attr.fsx_extsize != 0) {
3667 file_info->has_extent_size_hint = true;
3668 file_info->extent_size_hint = attr.fsx_extsize;
3669 }
3670 }
3671#endif
3672
3673 return spec_info;
3674}
3675
3676static BlockStatsSpecificFile get_blockstats_specific_file(BlockDriverState *bs)
3677{
3678 BDRVRawState *s = bs->opaque;
3679 return (BlockStatsSpecificFile) {
3680 .discard_nb_ok = s->stats.discard_nb_ok,
3681 .discard_nb_failed = s->stats.discard_nb_failed,
3682 .discard_bytes_ok = s->stats.discard_bytes_ok,
3683 };
3684}
3685
3686static BlockStatsSpecific *raw_get_specific_stats(BlockDriverState *bs)
3687{
3688 BlockStatsSpecific *stats = g_new(BlockStatsSpecific, 1);
3689
3690 stats->driver = BLOCKDEV_DRIVER_FILE;
3691 stats->u.file = get_blockstats_specific_file(bs);
3692
3693 return stats;
3694}
3695
3696#if defined(HAVE_HOST_BLOCK_DEVICE)
3697static BlockStatsSpecific *hdev_get_specific_stats(BlockDriverState *bs)
3698{
3699 BlockStatsSpecific *stats = g_new(BlockStatsSpecific, 1);
3700
3701 stats->driver = BLOCKDEV_DRIVER_HOST_DEVICE;
3702 stats->u.host_device = get_blockstats_specific_file(bs);
3703
3704 return stats;
3705}
3706#endif
3707
3708static QemuOptsList raw_create_opts = {
3709 .name = "raw-create-opts",
3710 .head = QTAILQ_HEAD_INITIALIZER(raw_create_opts.head),
3711 .desc = {
3712 {
3713 .name = BLOCK_OPT_SIZE,
3714 .type = QEMU_OPT_SIZE,
3715 .help = "Virtual disk size"
3716 },
3717 {
3718 .name = BLOCK_OPT_NOCOW,
3719 .type = QEMU_OPT_BOOL,
3720 .help = "Turn off copy-on-write (valid only on btrfs)"
3721 },
3722 {
3723 .name = BLOCK_OPT_PREALLOC,
3724 .type = QEMU_OPT_STRING,
3725 .help = "Preallocation mode (allowed values: off"
3726#ifdef CONFIG_POSIX_FALLOCATE
3727 ", falloc"
3728#endif
3729 ", full)"
3730 },
3731 {
3732 .name = BLOCK_OPT_EXTENT_SIZE_HINT,
3733 .type = QEMU_OPT_SIZE,
3734 .help = "Extent size hint for the image file, 0 to disable"
3735 },
3736 { }
3737 }
3738};
3739
3740static int raw_check_perm(BlockDriverState *bs, uint64_t perm, uint64_t shared,
3741 Error **errp)
3742{
3743 BDRVRawState *s = bs->opaque;
3744 int input_flags = s->reopen_state ? s->reopen_state->flags : bs->open_flags;
3745 int open_flags;
3746 int ret;
3747
3748
3749 ret = raw_reconfigure_getfd(bs, input_flags, &open_flags, perm,
3750 false, errp);
3751 if (ret < 0) {
3752 return ret;
3753 } else if (ret != s->fd) {
3754 Error *local_err = NULL;
3755
3756
3757
3758
3759
3760 raw_probe_alignment(bs, ret, &local_err);
3761 if (local_err) {
3762 error_propagate(errp, local_err);
3763 return -EINVAL;
3764 }
3765
3766 s->perm_change_fd = ret;
3767 s->perm_change_flags = open_flags;
3768 }
3769
3770
3771
3772 ret = raw_handle_perm_lock(bs, RAW_PL_PREPARE, perm, shared, errp);
3773 if (ret < 0) {
3774 goto fail;
3775 }
3776
3777
3778 if (s->perm_change_fd && s->use_lock) {
3779 ret = raw_apply_lock_bytes(NULL, s->perm_change_fd, perm, ~shared,
3780 false, errp);
3781 if (ret < 0) {
3782 raw_handle_perm_lock(bs, RAW_PL_ABORT, 0, 0, NULL);
3783 goto fail;
3784 }
3785 }
3786 return 0;
3787
3788fail:
3789 if (s->perm_change_fd) {
3790 qemu_close(s->perm_change_fd);
3791 }
3792 s->perm_change_fd = 0;
3793 return ret;
3794}
3795
3796static void raw_set_perm(BlockDriverState *bs, uint64_t perm, uint64_t shared)
3797{
3798 BDRVRawState *s = bs->opaque;
3799
3800
3801
3802 if (s->perm_change_fd && s->fd != s->perm_change_fd) {
3803 qemu_close(s->fd);
3804 s->fd = s->perm_change_fd;
3805 s->open_flags = s->perm_change_flags;
3806 }
3807 s->perm_change_fd = 0;
3808
3809 raw_handle_perm_lock(bs, RAW_PL_COMMIT, perm, shared, NULL);
3810 s->perm = perm;
3811 s->shared_perm = shared;
3812}
3813
3814static void raw_abort_perm_update(BlockDriverState *bs)
3815{
3816 BDRVRawState *s = bs->opaque;
3817
3818
3819
3820 if (s->perm_change_fd) {
3821 qemu_close(s->perm_change_fd);
3822 }
3823 s->perm_change_fd = 0;
3824
3825 raw_handle_perm_lock(bs, RAW_PL_ABORT, 0, 0, NULL);
3826}
3827
3828static int coroutine_fn GRAPH_RDLOCK raw_co_copy_range_from(
3829 BlockDriverState *bs, BdrvChild *src, int64_t src_offset,
3830 BdrvChild *dst, int64_t dst_offset, int64_t bytes,
3831 BdrvRequestFlags read_flags, BdrvRequestFlags write_flags)
3832{
3833 return bdrv_co_copy_range_to(src, src_offset, dst, dst_offset, bytes,
3834 read_flags, write_flags);
3835}
3836
3837static int coroutine_fn GRAPH_RDLOCK
3838raw_co_copy_range_to(BlockDriverState *bs,
3839 BdrvChild *src, int64_t src_offset,
3840 BdrvChild *dst, int64_t dst_offset,
3841 int64_t bytes, BdrvRequestFlags read_flags,
3842 BdrvRequestFlags write_flags)
3843{
3844 RawPosixAIOData acb;
3845 BDRVRawState *s = bs->opaque;
3846 BDRVRawState *src_s;
3847
3848 assert(dst->bs == bs);
3849 if (src->bs->drv->bdrv_co_copy_range_to != raw_co_copy_range_to) {
3850 return -ENOTSUP;
3851 }
3852
3853 src_s = src->bs->opaque;
3854 if (fd_open(src->bs) < 0 || fd_open(dst->bs) < 0) {
3855 return -EIO;
3856 }
3857
3858 acb = (RawPosixAIOData) {
3859 .bs = bs,
3860 .aio_type = QEMU_AIO_COPY_RANGE,
3861 .aio_fildes = src_s->fd,
3862 .aio_offset = src_offset,
3863 .aio_nbytes = bytes,
3864 .copy_range = {
3865 .aio_fd2 = s->fd,
3866 .aio_offset2 = dst_offset,
3867 },
3868 };
3869
3870 return raw_thread_pool_submit(handle_aiocb_copy_range, &acb);
3871}
3872
3873BlockDriver bdrv_file = {
3874 .format_name = "file",
3875 .protocol_name = "file",
3876 .instance_size = sizeof(BDRVRawState),
3877 .bdrv_needs_filename = true,
3878 .bdrv_probe = NULL,
3879 .bdrv_parse_filename = raw_parse_filename,
3880 .bdrv_file_open = raw_open,
3881 .bdrv_reopen_prepare = raw_reopen_prepare,
3882 .bdrv_reopen_commit = raw_reopen_commit,
3883 .bdrv_reopen_abort = raw_reopen_abort,
3884 .bdrv_close = raw_close,
3885 .bdrv_co_create = raw_co_create,
3886 .bdrv_co_create_opts = raw_co_create_opts,
3887 .bdrv_has_zero_init = bdrv_has_zero_init_1,
3888 .bdrv_co_block_status = raw_co_block_status,
3889 .bdrv_co_invalidate_cache = raw_co_invalidate_cache,
3890 .bdrv_co_pwrite_zeroes = raw_co_pwrite_zeroes,
3891 .bdrv_co_delete_file = raw_co_delete_file,
3892
3893 .bdrv_co_preadv = raw_co_preadv,
3894 .bdrv_co_pwritev = raw_co_pwritev,
3895 .bdrv_co_flush_to_disk = raw_co_flush_to_disk,
3896 .bdrv_co_pdiscard = raw_co_pdiscard,
3897 .bdrv_co_copy_range_from = raw_co_copy_range_from,
3898 .bdrv_co_copy_range_to = raw_co_copy_range_to,
3899 .bdrv_refresh_limits = raw_refresh_limits,
3900 .bdrv_attach_aio_context = raw_aio_attach_aio_context,
3901
3902 .bdrv_co_truncate = raw_co_truncate,
3903 .bdrv_co_getlength = raw_co_getlength,
3904 .bdrv_co_get_info = raw_co_get_info,
3905 .bdrv_get_specific_info = raw_get_specific_info,
3906 .bdrv_co_get_allocated_file_size = raw_co_get_allocated_file_size,
3907 .bdrv_get_specific_stats = raw_get_specific_stats,
3908 .bdrv_check_perm = raw_check_perm,
3909 .bdrv_set_perm = raw_set_perm,
3910 .bdrv_abort_perm_update = raw_abort_perm_update,
3911 .create_opts = &raw_create_opts,
3912 .mutable_opts = mutable_opts,
3913};
3914
3915
3916
3917
3918#if defined(HAVE_HOST_BLOCK_DEVICE)
3919
3920#if defined(__APPLE__) && defined(__MACH__)
3921static kern_return_t GetBSDPath(io_iterator_t mediaIterator, char *bsdPath,
3922 CFIndex maxPathSize, int flags);
3923
3924#if !defined(MAC_OS_VERSION_12_0) \
3925 || (MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_VERSION_12_0)
3926#define IOMainPort IOMasterPort
3927#endif
3928
3929static char *FindEjectableOpticalMedia(io_iterator_t *mediaIterator)
3930{
3931 kern_return_t kernResult = KERN_FAILURE;
3932 mach_port_t mainPort;
3933 CFMutableDictionaryRef classesToMatch;
3934 const char *matching_array[] = {kIODVDMediaClass, kIOCDMediaClass};
3935 char *mediaType = NULL;
3936
3937 kernResult = IOMainPort(MACH_PORT_NULL, &mainPort);
3938 if ( KERN_SUCCESS != kernResult ) {
3939 printf("IOMainPort returned %d\n", kernResult);
3940 }
3941
3942 int index;
3943 for (index = 0; index < ARRAY_SIZE(matching_array); index++) {
3944 classesToMatch = IOServiceMatching(matching_array[index]);
3945 if (classesToMatch == NULL) {
3946 error_report("IOServiceMatching returned NULL for %s",
3947 matching_array[index]);
3948 continue;
3949 }
3950 CFDictionarySetValue(classesToMatch, CFSTR(kIOMediaEjectableKey),
3951 kCFBooleanTrue);
3952 kernResult = IOServiceGetMatchingServices(mainPort, classesToMatch,
3953 mediaIterator);
3954 if (kernResult != KERN_SUCCESS) {
3955 error_report("Note: IOServiceGetMatchingServices returned %d",
3956 kernResult);
3957 continue;
3958 }
3959
3960
3961 if (*mediaIterator != 0) {
3962 trace_file_FindEjectableOpticalMedia(matching_array[index]);
3963 mediaType = g_strdup(matching_array[index]);
3964 break;
3965 }
3966 }
3967 return mediaType;
3968}
3969
3970kern_return_t GetBSDPath(io_iterator_t mediaIterator, char *bsdPath,
3971 CFIndex maxPathSize, int flags)
3972{
3973 io_object_t nextMedia;
3974 kern_return_t kernResult = KERN_FAILURE;
3975 *bsdPath = '\0';
3976 nextMedia = IOIteratorNext( mediaIterator );
3977 if ( nextMedia )
3978 {
3979 CFTypeRef bsdPathAsCFString;
3980 bsdPathAsCFString = IORegistryEntryCreateCFProperty( nextMedia, CFSTR( kIOBSDNameKey ), kCFAllocatorDefault, 0 );
3981 if ( bsdPathAsCFString ) {
3982 size_t devPathLength;
3983 strcpy( bsdPath, _PATH_DEV );
3984 if (flags & BDRV_O_NOCACHE) {
3985 strcat(bsdPath, "r");
3986 }
3987 devPathLength = strlen( bsdPath );
3988 if ( CFStringGetCString( bsdPathAsCFString, bsdPath + devPathLength, maxPathSize - devPathLength, kCFStringEncodingASCII ) ) {
3989 kernResult = KERN_SUCCESS;
3990 }
3991 CFRelease( bsdPathAsCFString );
3992 }
3993 IOObjectRelease( nextMedia );
3994 }
3995
3996 return kernResult;
3997}
3998
3999
4000static bool setup_cdrom(char *bsd_path, Error **errp)
4001{
4002 int index, num_of_test_partitions = 2, fd;
4003 char test_partition[MAXPATHLEN];
4004 bool partition_found = false;
4005
4006
4007 for (index = 0; index < num_of_test_partitions; index++) {
4008 snprintf(test_partition, sizeof(test_partition), "%ss%d", bsd_path,
4009 index);
4010 fd = qemu_open(test_partition, O_RDONLY | O_BINARY | O_LARGEFILE, NULL);
4011 if (fd >= 0) {
4012 partition_found = true;
4013 qemu_close(fd);
4014 break;
4015 }
4016 }
4017
4018
4019 if (partition_found == false) {
4020 error_setg(errp, "Failed to find a working partition on disc");
4021 } else {
4022 trace_file_setup_cdrom(test_partition);
4023 pstrcpy(bsd_path, MAXPATHLEN, test_partition);
4024 }
4025 return partition_found;
4026}
4027
4028
4029static void print_unmounting_directions(const char *file_name)
4030{
4031 error_report("If device %s is mounted on the desktop, unmount"
4032 " it first before using it in QEMU", file_name);
4033 error_report("Command to unmount device: diskutil unmountDisk %s",
4034 file_name);
4035 error_report("Command to mount device: diskutil mountDisk %s", file_name);
4036}
4037
4038#endif
4039
4040static int hdev_probe_device(const char *filename)
4041{
4042 struct stat st;
4043
4044
4045 if (strstart(filename, "/dev/cdrom", NULL))
4046 return 50;
4047
4048 if (stat(filename, &st) >= 0 &&
4049 (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode))) {
4050 return 100;
4051 }
4052
4053 return 0;
4054}
4055
4056static void hdev_parse_filename(const char *filename, QDict *options,
4057 Error **errp)
4058{
4059 bdrv_parse_filename_strip_prefix(filename, "host_device:", options);
4060}
4061
4062static bool hdev_is_sg(BlockDriverState *bs)
4063{
4064
4065#if defined(__linux__)
4066
4067 BDRVRawState *s = bs->opaque;
4068 struct stat st;
4069 struct sg_scsi_id scsiid;
4070 int sg_version;
4071 int ret;
4072
4073 if (stat(bs->filename, &st) < 0 || !S_ISCHR(st.st_mode)) {
4074 return false;
4075 }
4076
4077 ret = ioctl(s->fd, SG_GET_VERSION_NUM, &sg_version);
4078 if (ret < 0) {
4079 return false;
4080 }
4081
4082 ret = ioctl(s->fd, SG_GET_SCSI_ID, &scsiid);
4083 if (ret >= 0) {
4084 trace_file_hdev_is_sg(scsiid.scsi_type, sg_version);
4085 return true;
4086 }
4087
4088#endif
4089
4090 return false;
4091}
4092
4093static int hdev_open(BlockDriverState *bs, QDict *options, int flags,
4094 Error **errp)
4095{
4096 BDRVRawState *s = bs->opaque;
4097 int ret;
4098
4099#if defined(__APPLE__) && defined(__MACH__)
4100
4101
4102
4103
4104
4105
4106 const char *filename = qdict_get_str(options, "filename");
4107 char bsd_path[MAXPATHLEN] = "";
4108 bool error_occurred = false;
4109
4110
4111 if (strcmp(filename, "/dev/cdrom") == 0) {
4112 char *mediaType = NULL;
4113 kern_return_t ret_val;
4114 io_iterator_t mediaIterator = 0;
4115
4116 mediaType = FindEjectableOpticalMedia(&mediaIterator);
4117 if (mediaType == NULL) {
4118 error_setg(errp, "Please make sure your CD/DVD is in the optical"
4119 " drive");
4120 error_occurred = true;
4121 goto hdev_open_Mac_error;
4122 }
4123
4124 ret_val = GetBSDPath(mediaIterator, bsd_path, sizeof(bsd_path), flags);
4125 if (ret_val != KERN_SUCCESS) {
4126 error_setg(errp, "Could not get BSD path for optical drive");
4127 error_occurred = true;
4128 goto hdev_open_Mac_error;
4129 }
4130
4131
4132 if (bsd_path[0] == '\0') {
4133 error_setg(errp, "Failed to obtain bsd path for optical drive");
4134 error_occurred = true;
4135 goto hdev_open_Mac_error;
4136 }
4137
4138
4139 if (strncmp(mediaType, kIOCDMediaClass, 9) == 0 &&
4140 setup_cdrom(bsd_path, errp) == false) {
4141 print_unmounting_directions(bsd_path);
4142 error_occurred = true;
4143 goto hdev_open_Mac_error;
4144 }
4145
4146 qdict_put_str(options, "filename", bsd_path);
4147
4148hdev_open_Mac_error:
4149 g_free(mediaType);
4150 if (mediaIterator) {
4151 IOObjectRelease(mediaIterator);
4152 }
4153 if (error_occurred) {
4154 return -ENOENT;
4155 }
4156 }
4157#endif
4158
4159 s->type = FTYPE_FILE;
4160
4161 ret = raw_open_common(bs, options, flags, 0, true, errp);
4162 if (ret < 0) {
4163#if defined(__APPLE__) && defined(__MACH__)
4164 if (*bsd_path) {
4165 filename = bsd_path;
4166 }
4167
4168 if (strncmp(filename, "/dev/", 5) == 0) {
4169 print_unmounting_directions(filename);
4170 }
4171#endif
4172 return ret;
4173 }
4174
4175
4176 bs->sg = hdev_is_sg(bs);
4177
4178 return ret;
4179}
4180
4181#if defined(__linux__)
4182static int coroutine_fn
4183hdev_co_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
4184{
4185 BDRVRawState *s = bs->opaque;
4186 RawPosixAIOData acb;
4187 int ret;
4188
4189 ret = fd_open(bs);
4190 if (ret < 0) {
4191 return ret;
4192 }
4193
4194 if (req == SG_IO && s->pr_mgr) {
4195 struct sg_io_hdr *io_hdr = buf;
4196 if (io_hdr->cmdp[0] == PERSISTENT_RESERVE_OUT ||
4197 io_hdr->cmdp[0] == PERSISTENT_RESERVE_IN) {
4198 return pr_manager_execute(s->pr_mgr, qemu_get_current_aio_context(),
4199 s->fd, io_hdr);
4200 }
4201 }
4202
4203 acb = (RawPosixAIOData) {
4204 .bs = bs,
4205 .aio_type = QEMU_AIO_IOCTL,
4206 .aio_fildes = s->fd,
4207 .aio_offset = 0,
4208 .ioctl = {
4209 .buf = buf,
4210 .cmd = req,
4211 },
4212 };
4213
4214 return raw_thread_pool_submit(handle_aiocb_ioctl, &acb);
4215}
4216#endif
4217
4218static coroutine_fn int
4219hdev_co_pdiscard(BlockDriverState *bs, int64_t offset, int64_t bytes)
4220{
4221 BDRVRawState *s = bs->opaque;
4222 int ret;
4223
4224 ret = fd_open(bs);
4225 if (ret < 0) {
4226 raw_account_discard(s, bytes, ret);
4227 return ret;
4228 }
4229 return raw_do_pdiscard(bs, offset, bytes, true);
4230}
4231
4232static coroutine_fn int hdev_co_pwrite_zeroes(BlockDriverState *bs,
4233 int64_t offset, int64_t bytes, BdrvRequestFlags flags)
4234{
4235 int rc;
4236
4237 rc = fd_open(bs);
4238 if (rc < 0) {
4239 return rc;
4240 }
4241
4242 return raw_do_pwrite_zeroes(bs, offset, bytes, flags, true);
4243}
4244
4245static BlockDriver bdrv_host_device = {
4246 .format_name = "host_device",
4247 .protocol_name = "host_device",
4248 .instance_size = sizeof(BDRVRawState),
4249 .bdrv_needs_filename = true,
4250 .bdrv_probe_device = hdev_probe_device,
4251 .bdrv_parse_filename = hdev_parse_filename,
4252 .bdrv_file_open = hdev_open,
4253 .bdrv_close = raw_close,
4254 .bdrv_reopen_prepare = raw_reopen_prepare,
4255 .bdrv_reopen_commit = raw_reopen_commit,
4256 .bdrv_reopen_abort = raw_reopen_abort,
4257 .bdrv_co_create_opts = bdrv_co_create_opts_simple,
4258 .create_opts = &bdrv_create_opts_simple,
4259 .mutable_opts = mutable_opts,
4260 .bdrv_co_invalidate_cache = raw_co_invalidate_cache,
4261 .bdrv_co_pwrite_zeroes = hdev_co_pwrite_zeroes,
4262
4263 .bdrv_co_preadv = raw_co_preadv,
4264 .bdrv_co_pwritev = raw_co_pwritev,
4265 .bdrv_co_flush_to_disk = raw_co_flush_to_disk,
4266 .bdrv_co_pdiscard = hdev_co_pdiscard,
4267 .bdrv_co_copy_range_from = raw_co_copy_range_from,
4268 .bdrv_co_copy_range_to = raw_co_copy_range_to,
4269 .bdrv_refresh_limits = raw_refresh_limits,
4270 .bdrv_attach_aio_context = raw_aio_attach_aio_context,
4271
4272 .bdrv_co_truncate = raw_co_truncate,
4273 .bdrv_co_getlength = raw_co_getlength,
4274 .bdrv_co_get_info = raw_co_get_info,
4275 .bdrv_get_specific_info = raw_get_specific_info,
4276 .bdrv_co_get_allocated_file_size = raw_co_get_allocated_file_size,
4277 .bdrv_get_specific_stats = hdev_get_specific_stats,
4278 .bdrv_check_perm = raw_check_perm,
4279 .bdrv_set_perm = raw_set_perm,
4280 .bdrv_abort_perm_update = raw_abort_perm_update,
4281 .bdrv_probe_blocksizes = hdev_probe_blocksizes,
4282 .bdrv_probe_geometry = hdev_probe_geometry,
4283
4284
4285#ifdef __linux__
4286 .bdrv_co_ioctl = hdev_co_ioctl,
4287#endif
4288
4289
4290#if defined(CONFIG_BLKZONED)
4291
4292 .bdrv_co_zone_report = raw_co_zone_report,
4293 .bdrv_co_zone_mgmt = raw_co_zone_mgmt,
4294 .bdrv_co_zone_append = raw_co_zone_append,
4295#endif
4296};
4297
4298#if defined(__linux__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
4299static void cdrom_parse_filename(const char *filename, QDict *options,
4300 Error **errp)
4301{
4302 bdrv_parse_filename_strip_prefix(filename, "host_cdrom:", options);
4303}
4304
4305static void cdrom_refresh_limits(BlockDriverState *bs, Error **errp)
4306{
4307 bs->bl.has_variable_length = true;
4308 raw_refresh_limits(bs, errp);
4309}
4310#endif
4311
4312#ifdef __linux__
4313static int cdrom_open(BlockDriverState *bs, QDict *options, int flags,
4314 Error **errp)
4315{
4316 BDRVRawState *s = bs->opaque;
4317
4318 s->type = FTYPE_CD;
4319
4320
4321 return raw_open_common(bs, options, flags, O_NONBLOCK, true, errp);
4322}
4323
4324static int cdrom_probe_device(const char *filename)
4325{
4326 int fd, ret;
4327 int prio = 0;
4328 struct stat st;
4329
4330 fd = qemu_open(filename, O_RDONLY | O_NONBLOCK, NULL);
4331 if (fd < 0) {
4332 goto out;
4333 }
4334 ret = fstat(fd, &st);
4335 if (ret == -1 || !S_ISBLK(st.st_mode)) {
4336 goto outc;
4337 }
4338
4339
4340 ret = ioctl(fd, CDROM_DRIVE_STATUS, CDSL_CURRENT);
4341 if (ret >= 0)
4342 prio = 100;
4343
4344outc:
4345 qemu_close(fd);
4346out:
4347 return prio;
4348}
4349
4350static bool coroutine_fn cdrom_co_is_inserted(BlockDriverState *bs)
4351{
4352 BDRVRawState *s = bs->opaque;
4353 int ret;
4354
4355 ret = ioctl(s->fd, CDROM_DRIVE_STATUS, CDSL_CURRENT);
4356 return ret == CDS_DISC_OK;
4357}
4358
4359static void coroutine_fn cdrom_co_eject(BlockDriverState *bs, bool eject_flag)
4360{
4361 BDRVRawState *s = bs->opaque;
4362
4363 if (eject_flag) {
4364 if (ioctl(s->fd, CDROMEJECT, NULL) < 0)
4365 perror("CDROMEJECT");
4366 } else {
4367 if (ioctl(s->fd, CDROMCLOSETRAY, NULL) < 0)
4368 perror("CDROMEJECT");
4369 }
4370}
4371
4372static void coroutine_fn cdrom_co_lock_medium(BlockDriverState *bs, bool locked)
4373{
4374 BDRVRawState *s = bs->opaque;
4375
4376 if (ioctl(s->fd, CDROM_LOCKDOOR, locked) < 0) {
4377
4378
4379
4380
4381
4382 }
4383}
4384
4385static BlockDriver bdrv_host_cdrom = {
4386 .format_name = "host_cdrom",
4387 .protocol_name = "host_cdrom",
4388 .instance_size = sizeof(BDRVRawState),
4389 .bdrv_needs_filename = true,
4390 .bdrv_probe_device = cdrom_probe_device,
4391 .bdrv_parse_filename = cdrom_parse_filename,
4392 .bdrv_file_open = cdrom_open,
4393 .bdrv_close = raw_close,
4394 .bdrv_reopen_prepare = raw_reopen_prepare,
4395 .bdrv_reopen_commit = raw_reopen_commit,
4396 .bdrv_reopen_abort = raw_reopen_abort,
4397 .bdrv_co_create_opts = bdrv_co_create_opts_simple,
4398 .create_opts = &bdrv_create_opts_simple,
4399 .mutable_opts = mutable_opts,
4400 .bdrv_co_invalidate_cache = raw_co_invalidate_cache,
4401
4402 .bdrv_co_preadv = raw_co_preadv,
4403 .bdrv_co_pwritev = raw_co_pwritev,
4404 .bdrv_co_flush_to_disk = raw_co_flush_to_disk,
4405 .bdrv_refresh_limits = cdrom_refresh_limits,
4406 .bdrv_attach_aio_context = raw_aio_attach_aio_context,
4407
4408 .bdrv_co_truncate = raw_co_truncate,
4409 .bdrv_co_getlength = raw_co_getlength,
4410 .bdrv_co_get_allocated_file_size = raw_co_get_allocated_file_size,
4411
4412
4413 .bdrv_co_is_inserted = cdrom_co_is_inserted,
4414 .bdrv_co_eject = cdrom_co_eject,
4415 .bdrv_co_lock_medium = cdrom_co_lock_medium,
4416
4417
4418 .bdrv_co_ioctl = hdev_co_ioctl,
4419};
4420#endif
4421
4422#if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
4423static int cdrom_open(BlockDriverState *bs, QDict *options, int flags,
4424 Error **errp)
4425{
4426 BDRVRawState *s = bs->opaque;
4427 int ret;
4428
4429 s->type = FTYPE_CD;
4430
4431 ret = raw_open_common(bs, options, flags, 0, true, errp);
4432 if (ret) {
4433 return ret;
4434 }
4435
4436
4437 ioctl(s->fd, CDIOCALLOW);
4438 return 0;
4439}
4440
4441static int cdrom_probe_device(const char *filename)
4442{
4443 if (strstart(filename, "/dev/cd", NULL) ||
4444 strstart(filename, "/dev/acd", NULL))
4445 return 100;
4446 return 0;
4447}
4448
4449static int cdrom_reopen(BlockDriverState *bs)
4450{
4451 BDRVRawState *s = bs->opaque;
4452 int fd;
4453
4454
4455
4456
4457
4458 if (s->fd >= 0)
4459 qemu_close(s->fd);
4460 fd = qemu_open(bs->filename, s->open_flags, NULL);
4461 if (fd < 0) {
4462 s->fd = -1;
4463 return -EIO;
4464 }
4465 s->fd = fd;
4466
4467
4468 ioctl(s->fd, CDIOCALLOW);
4469 return 0;
4470}
4471
4472static bool coroutine_fn cdrom_co_is_inserted(BlockDriverState *bs)
4473{
4474 return raw_getlength(bs) > 0;
4475}
4476
4477static void coroutine_fn cdrom_co_eject(BlockDriverState *bs, bool eject_flag)
4478{
4479 BDRVRawState *s = bs->opaque;
4480
4481 if (s->fd < 0)
4482 return;
4483
4484 (void) ioctl(s->fd, CDIOCALLOW);
4485
4486 if (eject_flag) {
4487 if (ioctl(s->fd, CDIOCEJECT) < 0)
4488 perror("CDIOCEJECT");
4489 } else {
4490 if (ioctl(s->fd, CDIOCCLOSE) < 0)
4491 perror("CDIOCCLOSE");
4492 }
4493
4494 cdrom_reopen(bs);
4495}
4496
4497static void coroutine_fn cdrom_co_lock_medium(BlockDriverState *bs, bool locked)
4498{
4499 BDRVRawState *s = bs->opaque;
4500
4501 if (s->fd < 0)
4502 return;
4503 if (ioctl(s->fd, (locked ? CDIOCPREVENT : CDIOCALLOW)) < 0) {
4504
4505
4506
4507
4508
4509 }
4510}
4511
4512static BlockDriver bdrv_host_cdrom = {
4513 .format_name = "host_cdrom",
4514 .protocol_name = "host_cdrom",
4515 .instance_size = sizeof(BDRVRawState),
4516 .bdrv_needs_filename = true,
4517 .bdrv_probe_device = cdrom_probe_device,
4518 .bdrv_parse_filename = cdrom_parse_filename,
4519 .bdrv_file_open = cdrom_open,
4520 .bdrv_close = raw_close,
4521 .bdrv_reopen_prepare = raw_reopen_prepare,
4522 .bdrv_reopen_commit = raw_reopen_commit,
4523 .bdrv_reopen_abort = raw_reopen_abort,
4524 .bdrv_co_create_opts = bdrv_co_create_opts_simple,
4525 .create_opts = &bdrv_create_opts_simple,
4526 .mutable_opts = mutable_opts,
4527
4528 .bdrv_co_preadv = raw_co_preadv,
4529 .bdrv_co_pwritev = raw_co_pwritev,
4530 .bdrv_co_flush_to_disk = raw_co_flush_to_disk,
4531 .bdrv_refresh_limits = cdrom_refresh_limits,
4532 .bdrv_attach_aio_context = raw_aio_attach_aio_context,
4533
4534 .bdrv_co_truncate = raw_co_truncate,
4535 .bdrv_co_getlength = raw_co_getlength,
4536 .bdrv_co_get_allocated_file_size = raw_co_get_allocated_file_size,
4537
4538
4539 .bdrv_co_is_inserted = cdrom_co_is_inserted,
4540 .bdrv_co_eject = cdrom_co_eject,
4541 .bdrv_co_lock_medium = cdrom_co_lock_medium,
4542};
4543#endif
4544
4545#endif
4546
4547static void bdrv_file_init(void)
4548{
4549
4550
4551
4552
4553 bdrv_register(&bdrv_file);
4554#if defined(HAVE_HOST_BLOCK_DEVICE)
4555 bdrv_register(&bdrv_host_device);
4556#ifdef __linux__
4557 bdrv_register(&bdrv_host_cdrom);
4558#endif
4559#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
4560 bdrv_register(&bdrv_host_cdrom);
4561#endif
4562#endif
4563}
4564
4565block_init(bdrv_file_init);
4566