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