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