1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24#include "qemu-common.h"
25#include "qemu/error-report.h"
26#include "qemu/timer.h"
27#include "qemu/log.h"
28#include "block/block_int.h"
29#include "qemu/module.h"
30#include "trace.h"
31#include "block/thread-pool.h"
32#include "qemu/iov.h"
33#include "raw-aio.h"
34#include "qapi/util.h"
35#include "qapi/qmp/qstring.h"
36
37#if defined(__APPLE__) && (__MACH__)
38#include <paths.h>
39#include <sys/param.h>
40#include <IOKit/IOKitLib.h>
41#include <IOKit/IOBSD.h>
42#include <IOKit/storage/IOMediaBSDClient.h>
43#include <IOKit/storage/IOMedia.h>
44#include <IOKit/storage/IOCDMedia.h>
45
46#include <CoreFoundation/CoreFoundation.h>
47#endif
48
49#ifdef __sun__
50#define _POSIX_PTHREAD_SEMANTICS 1
51#include <sys/dkio.h>
52#endif
53#ifdef __linux__
54#include <sys/types.h>
55#include <sys/stat.h>
56#include <sys/ioctl.h>
57#include <sys/param.h>
58#include <linux/cdrom.h>
59#include <linux/fd.h>
60#include <linux/fs.h>
61#include <linux/hdreg.h>
62#include <scsi/sg.h>
63#ifdef __s390__
64#include <asm/dasd.h>
65#endif
66#ifndef FS_NOCOW_FL
67#define FS_NOCOW_FL 0x00800000
68#endif
69#endif
70#if defined(CONFIG_FALLOCATE_PUNCH_HOLE) || defined(CONFIG_FALLOCATE_ZERO_RANGE)
71#include <linux/falloc.h>
72#endif
73#if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
74#include <sys/disk.h>
75#include <sys/cdio.h>
76#endif
77
78#ifdef __OpenBSD__
79#include <sys/ioctl.h>
80#include <sys/disklabel.h>
81#include <sys/dkio.h>
82#endif
83
84#ifdef __NetBSD__
85#include <sys/ioctl.h>
86#include <sys/disklabel.h>
87#include <sys/dkio.h>
88#include <sys/disk.h>
89#endif
90
91#ifdef __DragonFly__
92#include <sys/ioctl.h>
93#include <sys/diskslice.h>
94#endif
95
96#ifdef CONFIG_XFS
97#include <xfs/xfs.h>
98#endif
99
100
101
102#ifdef DEBUG_BLOCK
103# define DEBUG_BLOCK_PRINT 1
104#else
105# define DEBUG_BLOCK_PRINT 0
106#endif
107#define DPRINTF(fmt, ...) \
108do { \
109 if (DEBUG_BLOCK_PRINT) { \
110 printf(fmt, ## __VA_ARGS__); \
111 } \
112} while (0)
113
114
115#ifndef O_DSYNC
116#ifdef O_SYNC
117#define O_DSYNC O_SYNC
118#elif defined(O_FSYNC)
119#define O_DSYNC O_FSYNC
120#endif
121#endif
122
123
124#ifndef O_DIRECT
125#define O_DIRECT O_DSYNC
126#endif
127
128#define FTYPE_FILE 0
129#define FTYPE_CD 1
130
131#define MAX_BLOCKSIZE 4096
132
133typedef struct BDRVRawState {
134 int fd;
135 int type;
136 int open_flags;
137 size_t buf_align;
138
139#ifdef CONFIG_LINUX_AIO
140 int use_aio;
141 void *aio_ctx;
142#endif
143#ifdef CONFIG_XFS
144 bool is_xfs:1;
145#endif
146 bool has_discard:1;
147 bool has_write_zeroes:1;
148 bool discard_zeroes:1;
149 bool has_fallocate;
150 bool needs_alignment;
151} BDRVRawState;
152
153typedef struct BDRVRawReopenState {
154 int fd;
155 int open_flags;
156#ifdef CONFIG_LINUX_AIO
157 int use_aio;
158#endif
159} BDRVRawReopenState;
160
161static int fd_open(BlockDriverState *bs);
162static int64_t raw_getlength(BlockDriverState *bs);
163
164typedef struct RawPosixAIOData {
165 BlockDriverState *bs;
166 int aio_fildes;
167 union {
168 struct iovec *aio_iov;
169 void *aio_ioctl_buf;
170 };
171 int aio_niov;
172 uint64_t aio_nbytes;
173#define aio_ioctl_cmd aio_nbytes
174 off_t aio_offset;
175 int aio_type;
176} RawPosixAIOData;
177
178#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
179static int cdrom_reopen(BlockDriverState *bs);
180#endif
181
182#if defined(__NetBSD__)
183static int raw_normalize_devicepath(const char **filename)
184{
185 static char namebuf[PATH_MAX];
186 const char *dp, *fname;
187 struct stat sb;
188
189 fname = *filename;
190 dp = strrchr(fname, '/');
191 if (lstat(fname, &sb) < 0) {
192 fprintf(stderr, "%s: stat failed: %s\n",
193 fname, strerror(errno));
194 return -errno;
195 }
196
197 if (!S_ISBLK(sb.st_mode)) {
198 return 0;
199 }
200
201 if (dp == NULL) {
202 snprintf(namebuf, PATH_MAX, "r%s", fname);
203 } else {
204 snprintf(namebuf, PATH_MAX, "%.*s/r%s",
205 (int)(dp - fname), fname, dp + 1);
206 }
207 fprintf(stderr, "%s is a block device", fname);
208 *filename = namebuf;
209 fprintf(stderr, ", using %s\n", *filename);
210
211 return 0;
212}
213#else
214static int raw_normalize_devicepath(const char **filename)
215{
216 return 0;
217}
218#endif
219
220
221
222
223static int probe_logical_blocksize(int fd, unsigned int *sector_size_p)
224{
225 unsigned int sector_size;
226 bool success = false;
227
228 errno = ENOTSUP;
229
230
231#ifdef BLKSSZGET
232 if (ioctl(fd, BLKSSZGET, §or_size) >= 0) {
233 *sector_size_p = sector_size;
234 success = true;
235 }
236#endif
237#ifdef DKIOCGETBLOCKSIZE
238 if (ioctl(fd, DKIOCGETBLOCKSIZE, §or_size) >= 0) {
239 *sector_size_p = sector_size;
240 success = true;
241 }
242#endif
243#ifdef DIOCGSECTORSIZE
244 if (ioctl(fd, DIOCGSECTORSIZE, §or_size) >= 0) {
245 *sector_size_p = sector_size;
246 success = true;
247 }
248#endif
249
250 return success ? 0 : -errno;
251}
252
253
254
255
256
257
258static int probe_physical_blocksize(int fd, unsigned int *blk_size)
259{
260#ifdef BLKPBSZGET
261 if (ioctl(fd, BLKPBSZGET, blk_size) < 0) {
262 return -errno;
263 }
264 return 0;
265#else
266 return -ENOTSUP;
267#endif
268}
269
270
271
272
273
274static bool raw_is_io_aligned(int fd, void *buf, size_t len)
275{
276 ssize_t ret = pread(fd, buf, len, 0);
277
278 if (ret >= 0) {
279 return true;
280 }
281
282#ifdef __linux__
283
284
285
286
287 if (errno != EINVAL) {
288 return true;
289 }
290#endif
291
292 return false;
293}
294
295static void raw_probe_alignment(BlockDriverState *bs, int fd, Error **errp)
296{
297 BDRVRawState *s = bs->opaque;
298 char *buf;
299 size_t max_align = MAX(MAX_BLOCKSIZE, getpagesize());
300
301
302
303 if (bdrv_is_sg(bs) || !s->needs_alignment) {
304 bs->request_alignment = 1;
305 s->buf_align = 1;
306 return;
307 }
308
309 bs->request_alignment = 0;
310 s->buf_align = 0;
311
312 if (probe_logical_blocksize(fd, &bs->request_alignment) < 0) {
313 bs->request_alignment = 0;
314 }
315#ifdef CONFIG_XFS
316 if (s->is_xfs) {
317 struct dioattr da;
318 if (xfsctl(NULL, fd, XFS_IOC_DIOINFO, &da) >= 0) {
319 bs->request_alignment = da.d_miniosz;
320
321
322 }
323 }
324#endif
325
326
327 if (!s->buf_align) {
328 size_t align;
329 buf = qemu_memalign(max_align, 2 * max_align);
330 for (align = 512; align <= max_align; align <<= 1) {
331 if (raw_is_io_aligned(fd, buf + align, max_align)) {
332 s->buf_align = align;
333 break;
334 }
335 }
336 qemu_vfree(buf);
337 }
338
339 if (!bs->request_alignment) {
340 size_t align;
341 buf = qemu_memalign(s->buf_align, max_align);
342 for (align = 512; align <= max_align; align <<= 1) {
343 if (raw_is_io_aligned(fd, buf, align)) {
344 bs->request_alignment = align;
345 break;
346 }
347 }
348 qemu_vfree(buf);
349 }
350
351 if (!s->buf_align || !bs->request_alignment) {
352 error_setg(errp, "Could not find working O_DIRECT alignment. "
353 "Try cache.direct=off.");
354 }
355}
356
357static void raw_parse_flags(int bdrv_flags, int *open_flags)
358{
359 assert(open_flags != NULL);
360
361 *open_flags |= O_BINARY;
362 *open_flags &= ~O_ACCMODE;
363 if (bdrv_flags & BDRV_O_RDWR) {
364 *open_flags |= O_RDWR;
365 } else {
366 *open_flags |= O_RDONLY;
367 }
368
369
370
371 if ((bdrv_flags & BDRV_O_NOCACHE)) {
372 *open_flags |= O_DIRECT;
373 }
374}
375
376static void raw_detach_aio_context(BlockDriverState *bs)
377{
378#ifdef CONFIG_LINUX_AIO
379 BDRVRawState *s = bs->opaque;
380
381 if (s->use_aio) {
382 laio_detach_aio_context(s->aio_ctx, bdrv_get_aio_context(bs));
383 }
384#endif
385}
386
387static void raw_attach_aio_context(BlockDriverState *bs,
388 AioContext *new_context)
389{
390#ifdef CONFIG_LINUX_AIO
391 BDRVRawState *s = bs->opaque;
392
393 if (s->use_aio) {
394 laio_attach_aio_context(s->aio_ctx, new_context);
395 }
396#endif
397}
398
399#ifdef CONFIG_LINUX_AIO
400static int raw_set_aio(void **aio_ctx, int *use_aio, int bdrv_flags)
401{
402 int ret = -1;
403 assert(aio_ctx != NULL);
404 assert(use_aio != NULL);
405
406
407
408
409 if ((bdrv_flags & (BDRV_O_NOCACHE|BDRV_O_NATIVE_AIO)) ==
410 (BDRV_O_NOCACHE|BDRV_O_NATIVE_AIO)) {
411
412
413 if (*aio_ctx == NULL) {
414 *aio_ctx = laio_init();
415 if (!*aio_ctx) {
416 goto error;
417 }
418 }
419 *use_aio = 1;
420 } else {
421 *use_aio = 0;
422 }
423
424 ret = 0;
425
426error:
427 return ret;
428}
429#endif
430
431static void raw_parse_filename(const char *filename, QDict *options,
432 Error **errp)
433{
434
435
436
437 strstart(filename, "file:", &filename);
438
439 qdict_put_obj(options, "filename", QOBJECT(qstring_from_str(filename)));
440}
441
442static QemuOptsList raw_runtime_opts = {
443 .name = "raw",
444 .head = QTAILQ_HEAD_INITIALIZER(raw_runtime_opts.head),
445 .desc = {
446 {
447 .name = "filename",
448 .type = QEMU_OPT_STRING,
449 .help = "File name of the image",
450 },
451 { }
452 },
453};
454
455static int raw_open_common(BlockDriverState *bs, QDict *options,
456 int bdrv_flags, int open_flags, Error **errp)
457{
458 BDRVRawState *s = bs->opaque;
459 QemuOpts *opts;
460 Error *local_err = NULL;
461 const char *filename = NULL;
462 int fd, ret;
463 struct stat st;
464
465 opts = qemu_opts_create(&raw_runtime_opts, NULL, 0, &error_abort);
466 qemu_opts_absorb_qdict(opts, options, &local_err);
467 if (local_err) {
468 error_propagate(errp, local_err);
469 ret = -EINVAL;
470 goto fail;
471 }
472
473 filename = qemu_opt_get(opts, "filename");
474
475 ret = raw_normalize_devicepath(&filename);
476 if (ret != 0) {
477 error_setg_errno(errp, -ret, "Could not normalize device path");
478 goto fail;
479 }
480
481 s->open_flags = open_flags;
482 raw_parse_flags(bdrv_flags, &s->open_flags);
483
484 s->fd = -1;
485 fd = qemu_open(filename, s->open_flags, 0644);
486 if (fd < 0) {
487 ret = -errno;
488 if (ret == -EROFS) {
489 ret = -EACCES;
490 }
491 goto fail;
492 }
493 s->fd = fd;
494
495#ifdef CONFIG_LINUX_AIO
496 if (raw_set_aio(&s->aio_ctx, &s->use_aio, bdrv_flags)) {
497 qemu_close(fd);
498 ret = -errno;
499 error_setg_errno(errp, -ret, "Could not set AIO state");
500 goto fail;
501 }
502 if (!s->use_aio && (bdrv_flags & BDRV_O_NATIVE_AIO)) {
503 error_printf("WARNING: aio=native was specified for '%s', but "
504 "it requires cache.direct=on, which was not "
505 "specified. Falling back to aio=threads.\n"
506 " This will become an error condition in "
507 "future QEMU versions.\n",
508 bs->filename);
509 }
510#else
511 if (bdrv_flags & BDRV_O_NATIVE_AIO) {
512 error_printf("WARNING: aio=native was specified for '%s', but "
513 "is not supported in this build. Falling back to "
514 "aio=threads.\n"
515 " This will become an error condition in "
516 "future QEMU versions.\n",
517 bs->filename);
518 }
519#endif
520
521 s->has_discard = true;
522 s->has_write_zeroes = true;
523 if ((bs->open_flags & BDRV_O_NOCACHE) != 0) {
524 s->needs_alignment = true;
525 }
526
527 if (fstat(s->fd, &st) < 0) {
528 ret = -errno;
529 error_setg_errno(errp, errno, "Could not stat file");
530 goto fail;
531 }
532 if (S_ISREG(st.st_mode)) {
533 s->discard_zeroes = true;
534 s->has_fallocate = true;
535 }
536 if (S_ISBLK(st.st_mode)) {
537#ifdef BLKDISCARDZEROES
538 unsigned int arg;
539 if (ioctl(s->fd, BLKDISCARDZEROES, &arg) == 0 && arg) {
540 s->discard_zeroes = true;
541 }
542#endif
543#ifdef __linux__
544
545
546
547
548 if (!(bs->open_flags & BDRV_O_NOCACHE)) {
549 s->discard_zeroes = false;
550 s->has_write_zeroes = false;
551 }
552#endif
553 }
554#ifdef __FreeBSD__
555 if (S_ISCHR(st.st_mode)) {
556
557
558
559
560
561
562 s->needs_alignment = true;
563 }
564#endif
565
566#ifdef CONFIG_XFS
567 if (platform_test_xfs_fd(s->fd)) {
568 s->is_xfs = true;
569 }
570#endif
571
572 raw_attach_aio_context(bs, bdrv_get_aio_context(bs));
573
574 ret = 0;
575fail:
576 if (filename && (bdrv_flags & BDRV_O_TEMPORARY)) {
577 unlink(filename);
578 }
579 qemu_opts_del(opts);
580 return ret;
581}
582
583static int raw_open(BlockDriverState *bs, QDict *options, int flags,
584 Error **errp)
585{
586 BDRVRawState *s = bs->opaque;
587 Error *local_err = NULL;
588 int ret;
589
590 s->type = FTYPE_FILE;
591 ret = raw_open_common(bs, options, flags, 0, &local_err);
592 if (local_err) {
593 error_propagate(errp, local_err);
594 }
595 return ret;
596}
597
598static int raw_reopen_prepare(BDRVReopenState *state,
599 BlockReopenQueue *queue, Error **errp)
600{
601 BDRVRawState *s;
602 BDRVRawReopenState *raw_s;
603 int ret = 0;
604 Error *local_err = NULL;
605
606 assert(state != NULL);
607 assert(state->bs != NULL);
608
609 s = state->bs->opaque;
610
611 state->opaque = g_new0(BDRVRawReopenState, 1);
612 raw_s = state->opaque;
613
614#ifdef CONFIG_LINUX_AIO
615 raw_s->use_aio = s->use_aio;
616
617
618
619
620 if (raw_set_aio(&s->aio_ctx, &raw_s->use_aio, state->flags)) {
621 error_setg(errp, "Could not set AIO state");
622 return -1;
623 }
624#endif
625
626 if (s->type == FTYPE_CD) {
627 raw_s->open_flags |= O_NONBLOCK;
628 }
629
630 raw_parse_flags(state->flags, &raw_s->open_flags);
631
632 raw_s->fd = -1;
633
634 int fcntl_flags = O_APPEND | O_NONBLOCK;
635#ifdef O_NOATIME
636 fcntl_flags |= O_NOATIME;
637#endif
638
639#ifdef O_ASYNC
640
641
642
643
644
645 assert((s->open_flags & O_ASYNC) == 0);
646#endif
647
648 if ((raw_s->open_flags & ~fcntl_flags) == (s->open_flags & ~fcntl_flags)) {
649
650
651#ifdef F_DUPFD_CLOEXEC
652 raw_s->fd = fcntl(s->fd, F_DUPFD_CLOEXEC, 0);
653#else
654 raw_s->fd = dup(s->fd);
655 if (raw_s->fd != -1) {
656 qemu_set_cloexec(raw_s->fd);
657 }
658#endif
659 if (raw_s->fd >= 0) {
660 ret = fcntl_setfl(raw_s->fd, raw_s->open_flags);
661 if (ret) {
662 qemu_close(raw_s->fd);
663 raw_s->fd = -1;
664 }
665 }
666 }
667
668
669 if (raw_s->fd == -1) {
670 const char *normalized_filename = state->bs->filename;
671 ret = raw_normalize_devicepath(&normalized_filename);
672 if (ret < 0) {
673 error_setg_errno(errp, -ret, "Could not normalize device path");
674 } else {
675 assert(!(raw_s->open_flags & O_CREAT));
676 raw_s->fd = qemu_open(normalized_filename, raw_s->open_flags);
677 if (raw_s->fd == -1) {
678 error_setg_errno(errp, errno, "Could not reopen file");
679 ret = -1;
680 }
681 }
682 }
683
684
685
686 if (raw_s->fd != -1) {
687 raw_probe_alignment(state->bs, raw_s->fd, &local_err);
688 if (local_err) {
689 qemu_close(raw_s->fd);
690 raw_s->fd = -1;
691 error_propagate(errp, local_err);
692 ret = -EINVAL;
693 }
694 }
695
696 return ret;
697}
698
699static void raw_reopen_commit(BDRVReopenState *state)
700{
701 BDRVRawReopenState *raw_s = state->opaque;
702 BDRVRawState *s = state->bs->opaque;
703
704 s->open_flags = raw_s->open_flags;
705
706 qemu_close(s->fd);
707 s->fd = raw_s->fd;
708#ifdef CONFIG_LINUX_AIO
709 s->use_aio = raw_s->use_aio;
710#endif
711
712 g_free(state->opaque);
713 state->opaque = NULL;
714}
715
716
717static void raw_reopen_abort(BDRVReopenState *state)
718{
719 BDRVRawReopenState *raw_s = state->opaque;
720
721
722 if (raw_s == NULL) {
723 return;
724 }
725
726 if (raw_s->fd >= 0) {
727 qemu_close(raw_s->fd);
728 raw_s->fd = -1;
729 }
730 g_free(state->opaque);
731 state->opaque = NULL;
732}
733
734static void raw_refresh_limits(BlockDriverState *bs, Error **errp)
735{
736 BDRVRawState *s = bs->opaque;
737
738 raw_probe_alignment(bs, s->fd, errp);
739 bs->bl.min_mem_alignment = s->buf_align;
740 bs->bl.opt_mem_alignment = MAX(s->buf_align, getpagesize());
741}
742
743static int check_for_dasd(int fd)
744{
745#ifdef BIODASDINFO2
746 struct dasd_information2_t info = {0};
747
748 return ioctl(fd, BIODASDINFO2, &info);
749#else
750 return -1;
751#endif
752}
753
754
755
756
757
758
759static int hdev_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz)
760{
761 BDRVRawState *s = bs->opaque;
762 int ret;
763
764
765 if (check_for_dasd(s->fd) < 0) {
766 return -ENOTSUP;
767 }
768 ret = probe_logical_blocksize(s->fd, &bsz->log);
769 if (ret < 0) {
770 return ret;
771 }
772 return probe_physical_blocksize(s->fd, &bsz->phys);
773}
774
775
776
777
778
779
780
781#ifdef __linux__
782static int hdev_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
783{
784 BDRVRawState *s = bs->opaque;
785 struct hd_geometry ioctl_geo = {0};
786 uint32_t blksize;
787
788
789 if (check_for_dasd(s->fd) < 0) {
790 return -ENOTSUP;
791 }
792 if (ioctl(s->fd, HDIO_GETGEO, &ioctl_geo) < 0) {
793 return -errno;
794 }
795
796
797 if (!ioctl_geo.heads || !ioctl_geo.sectors || !ioctl_geo.cylinders) {
798 return -ENOTSUP;
799 }
800
801 if (ioctl_geo.start != 0) {
802 return -ENOTSUP;
803 }
804 geo->heads = ioctl_geo.heads;
805 geo->sectors = ioctl_geo.sectors;
806 if (!probe_physical_blocksize(s->fd, &blksize)) {
807
808 geo->cylinders = bdrv_nb_sectors(bs) / (blksize / BDRV_SECTOR_SIZE)
809 / (geo->heads * geo->sectors);
810 return 0;
811 }
812 geo->cylinders = ioctl_geo.cylinders;
813
814 return 0;
815}
816#else
817static int hdev_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
818{
819 return -ENOTSUP;
820}
821#endif
822
823static ssize_t handle_aiocb_ioctl(RawPosixAIOData *aiocb)
824{
825 int ret;
826
827 ret = ioctl(aiocb->aio_fildes, aiocb->aio_ioctl_cmd, aiocb->aio_ioctl_buf);
828 if (ret == -1) {
829 return -errno;
830 }
831
832 return 0;
833}
834
835static ssize_t handle_aiocb_flush(RawPosixAIOData *aiocb)
836{
837 int ret;
838
839 ret = qemu_fdatasync(aiocb->aio_fildes);
840 if (ret == -1) {
841 return -errno;
842 }
843 return 0;
844}
845
846#ifdef CONFIG_PREADV
847
848static bool preadv_present = true;
849
850static ssize_t
851qemu_preadv(int fd, const struct iovec *iov, int nr_iov, off_t offset)
852{
853 return preadv(fd, iov, nr_iov, offset);
854}
855
856static ssize_t
857qemu_pwritev(int fd, const struct iovec *iov, int nr_iov, off_t offset)
858{
859 return pwritev(fd, iov, nr_iov, offset);
860}
861
862#else
863
864static bool preadv_present = false;
865
866static ssize_t
867qemu_preadv(int fd, const struct iovec *iov, int nr_iov, off_t offset)
868{
869 return -ENOSYS;
870}
871
872static ssize_t
873qemu_pwritev(int fd, const struct iovec *iov, int nr_iov, off_t offset)
874{
875 return -ENOSYS;
876}
877
878#endif
879
880static ssize_t handle_aiocb_rw_vector(RawPosixAIOData *aiocb)
881{
882 ssize_t len;
883
884 do {
885 if (aiocb->aio_type & QEMU_AIO_WRITE)
886 len = qemu_pwritev(aiocb->aio_fildes,
887 aiocb->aio_iov,
888 aiocb->aio_niov,
889 aiocb->aio_offset);
890 else
891 len = qemu_preadv(aiocb->aio_fildes,
892 aiocb->aio_iov,
893 aiocb->aio_niov,
894 aiocb->aio_offset);
895 } while (len == -1 && errno == EINTR);
896
897 if (len == -1) {
898 return -errno;
899 }
900 return len;
901}
902
903
904
905
906
907
908
909static ssize_t handle_aiocb_rw_linear(RawPosixAIOData *aiocb, char *buf)
910{
911 ssize_t offset = 0;
912 ssize_t len;
913
914 while (offset < aiocb->aio_nbytes) {
915 if (aiocb->aio_type & QEMU_AIO_WRITE) {
916 len = pwrite(aiocb->aio_fildes,
917 (const char *)buf + offset,
918 aiocb->aio_nbytes - offset,
919 aiocb->aio_offset + offset);
920 } else {
921 len = pread(aiocb->aio_fildes,
922 buf + offset,
923 aiocb->aio_nbytes - offset,
924 aiocb->aio_offset + offset);
925 }
926 if (len == -1 && errno == EINTR) {
927 continue;
928 } else if (len == -1 && errno == EINVAL &&
929 (aiocb->bs->open_flags & BDRV_O_NOCACHE) &&
930 !(aiocb->aio_type & QEMU_AIO_WRITE) &&
931 offset > 0) {
932
933
934
935
936 break;
937 } else if (len == -1) {
938 offset = -errno;
939 break;
940 } else if (len == 0) {
941 break;
942 }
943 offset += len;
944 }
945
946 return offset;
947}
948
949static ssize_t handle_aiocb_rw(RawPosixAIOData *aiocb)
950{
951 ssize_t nbytes;
952 char *buf;
953
954 if (!(aiocb->aio_type & QEMU_AIO_MISALIGNED)) {
955
956
957
958
959 if (aiocb->aio_niov == 1) {
960 return handle_aiocb_rw_linear(aiocb, aiocb->aio_iov->iov_base);
961 }
962
963
964
965
966
967
968 if (preadv_present) {
969 nbytes = handle_aiocb_rw_vector(aiocb);
970 if (nbytes == aiocb->aio_nbytes ||
971 (nbytes < 0 && nbytes != -ENOSYS)) {
972 return nbytes;
973 }
974 preadv_present = false;
975 }
976
977
978
979
980
981
982 }
983
984
985
986
987
988 buf = qemu_try_blockalign(aiocb->bs, aiocb->aio_nbytes);
989 if (buf == NULL) {
990 return -ENOMEM;
991 }
992
993 if (aiocb->aio_type & QEMU_AIO_WRITE) {
994 char *p = buf;
995 int i;
996
997 for (i = 0; i < aiocb->aio_niov; ++i) {
998 memcpy(p, aiocb->aio_iov[i].iov_base, aiocb->aio_iov[i].iov_len);
999 p += aiocb->aio_iov[i].iov_len;
1000 }
1001 assert(p - buf == aiocb->aio_nbytes);
1002 }
1003
1004 nbytes = handle_aiocb_rw_linear(aiocb, buf);
1005 if (!(aiocb->aio_type & QEMU_AIO_WRITE)) {
1006 char *p = buf;
1007 size_t count = aiocb->aio_nbytes, copy;
1008 int i;
1009
1010 for (i = 0; i < aiocb->aio_niov && count; ++i) {
1011 copy = count;
1012 if (copy > aiocb->aio_iov[i].iov_len) {
1013 copy = aiocb->aio_iov[i].iov_len;
1014 }
1015 memcpy(aiocb->aio_iov[i].iov_base, p, copy);
1016 assert(count >= copy);
1017 p += copy;
1018 count -= copy;
1019 }
1020 assert(count == 0);
1021 }
1022 qemu_vfree(buf);
1023
1024 return nbytes;
1025}
1026
1027#ifdef CONFIG_XFS
1028static int xfs_write_zeroes(BDRVRawState *s, int64_t offset, uint64_t bytes)
1029{
1030 struct xfs_flock64 fl;
1031 int err;
1032
1033 memset(&fl, 0, sizeof(fl));
1034 fl.l_whence = SEEK_SET;
1035 fl.l_start = offset;
1036 fl.l_len = bytes;
1037
1038 if (xfsctl(NULL, s->fd, XFS_IOC_ZERO_RANGE, &fl) < 0) {
1039 err = errno;
1040 DPRINTF("cannot write zero range (%s)\n", strerror(errno));
1041 return -err;
1042 }
1043
1044 return 0;
1045}
1046
1047static int xfs_discard(BDRVRawState *s, int64_t offset, uint64_t bytes)
1048{
1049 struct xfs_flock64 fl;
1050 int err;
1051
1052 memset(&fl, 0, sizeof(fl));
1053 fl.l_whence = SEEK_SET;
1054 fl.l_start = offset;
1055 fl.l_len = bytes;
1056
1057 if (xfsctl(NULL, s->fd, XFS_IOC_UNRESVSP64, &fl) < 0) {
1058 err = errno;
1059 DPRINTF("cannot punch hole (%s)\n", strerror(errno));
1060 return -err;
1061 }
1062
1063 return 0;
1064}
1065#endif
1066
1067static int translate_err(int err)
1068{
1069 if (err == -ENODEV || err == -ENOSYS || err == -EOPNOTSUPP ||
1070 err == -ENOTTY) {
1071 err = -ENOTSUP;
1072 }
1073 return err;
1074}
1075
1076#ifdef CONFIG_FALLOCATE
1077static int do_fallocate(int fd, int mode, off_t offset, off_t len)
1078{
1079 do {
1080 if (fallocate(fd, mode, offset, len) == 0) {
1081 return 0;
1082 }
1083 } while (errno == EINTR);
1084 return translate_err(-errno);
1085}
1086#endif
1087
1088static ssize_t handle_aiocb_write_zeroes_block(RawPosixAIOData *aiocb)
1089{
1090 int ret = -ENOTSUP;
1091 BDRVRawState *s = aiocb->bs->opaque;
1092
1093 if (!s->has_write_zeroes) {
1094 return -ENOTSUP;
1095 }
1096
1097#ifdef BLKZEROOUT
1098 do {
1099 uint64_t range[2] = { aiocb->aio_offset, aiocb->aio_nbytes };
1100 if (ioctl(aiocb->aio_fildes, BLKZEROOUT, range) == 0) {
1101 return 0;
1102 }
1103 } while (errno == EINTR);
1104
1105 ret = translate_err(-errno);
1106#endif
1107
1108 if (ret == -ENOTSUP) {
1109 s->has_write_zeroes = false;
1110 }
1111 return ret;
1112}
1113
1114static ssize_t handle_aiocb_write_zeroes(RawPosixAIOData *aiocb)
1115{
1116#if defined(CONFIG_FALLOCATE) || defined(CONFIG_XFS)
1117 BDRVRawState *s = aiocb->bs->opaque;
1118#endif
1119
1120 if (aiocb->aio_type & QEMU_AIO_BLKDEV) {
1121 return handle_aiocb_write_zeroes_block(aiocb);
1122 }
1123
1124#ifdef CONFIG_XFS
1125 if (s->is_xfs) {
1126 return xfs_write_zeroes(s, aiocb->aio_offset, aiocb->aio_nbytes);
1127 }
1128#endif
1129
1130#ifdef CONFIG_FALLOCATE_ZERO_RANGE
1131 if (s->has_write_zeroes) {
1132 int ret = do_fallocate(s->fd, FALLOC_FL_ZERO_RANGE,
1133 aiocb->aio_offset, aiocb->aio_nbytes);
1134 if (ret == 0 || ret != -ENOTSUP) {
1135 return ret;
1136 }
1137 s->has_write_zeroes = false;
1138 }
1139#endif
1140
1141#ifdef CONFIG_FALLOCATE_PUNCH_HOLE
1142 if (s->has_discard && s->has_fallocate) {
1143 int ret = do_fallocate(s->fd,
1144 FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE,
1145 aiocb->aio_offset, aiocb->aio_nbytes);
1146 if (ret == 0) {
1147 ret = do_fallocate(s->fd, 0, aiocb->aio_offset, aiocb->aio_nbytes);
1148 if (ret == 0 || ret != -ENOTSUP) {
1149 return ret;
1150 }
1151 s->has_fallocate = false;
1152 } else if (ret != -ENOTSUP) {
1153 return ret;
1154 } else {
1155 s->has_discard = false;
1156 }
1157 }
1158#endif
1159
1160#ifdef CONFIG_FALLOCATE
1161 if (s->has_fallocate && aiocb->aio_offset >= bdrv_getlength(aiocb->bs)) {
1162 int ret = do_fallocate(s->fd, 0, aiocb->aio_offset, aiocb->aio_nbytes);
1163 if (ret == 0 || ret != -ENOTSUP) {
1164 return ret;
1165 }
1166 s->has_fallocate = false;
1167 }
1168#endif
1169
1170 return -ENOTSUP;
1171}
1172
1173static ssize_t handle_aiocb_discard(RawPosixAIOData *aiocb)
1174{
1175 int ret = -EOPNOTSUPP;
1176 BDRVRawState *s = aiocb->bs->opaque;
1177
1178 if (!s->has_discard) {
1179 return -ENOTSUP;
1180 }
1181
1182 if (aiocb->aio_type & QEMU_AIO_BLKDEV) {
1183#ifdef BLKDISCARD
1184 do {
1185 uint64_t range[2] = { aiocb->aio_offset, aiocb->aio_nbytes };
1186 if (ioctl(aiocb->aio_fildes, BLKDISCARD, range) == 0) {
1187 return 0;
1188 }
1189 } while (errno == EINTR);
1190
1191 ret = -errno;
1192#endif
1193 } else {
1194#ifdef CONFIG_XFS
1195 if (s->is_xfs) {
1196 return xfs_discard(s, aiocb->aio_offset, aiocb->aio_nbytes);
1197 }
1198#endif
1199
1200#ifdef CONFIG_FALLOCATE_PUNCH_HOLE
1201 ret = do_fallocate(s->fd, FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE,
1202 aiocb->aio_offset, aiocb->aio_nbytes);
1203#endif
1204 }
1205
1206 ret = translate_err(ret);
1207 if (ret == -ENOTSUP) {
1208 s->has_discard = false;
1209 }
1210 return ret;
1211}
1212
1213static int aio_worker(void *arg)
1214{
1215 RawPosixAIOData *aiocb = arg;
1216 ssize_t ret = 0;
1217
1218 switch (aiocb->aio_type & QEMU_AIO_TYPE_MASK) {
1219 case QEMU_AIO_READ:
1220 ret = handle_aiocb_rw(aiocb);
1221 if (ret >= 0 && ret < aiocb->aio_nbytes) {
1222 iov_memset(aiocb->aio_iov, aiocb->aio_niov, ret,
1223 0, aiocb->aio_nbytes - ret);
1224
1225 ret = aiocb->aio_nbytes;
1226 }
1227 if (ret == aiocb->aio_nbytes) {
1228 ret = 0;
1229 } else if (ret >= 0 && ret < aiocb->aio_nbytes) {
1230 ret = -EINVAL;
1231 }
1232 break;
1233 case QEMU_AIO_WRITE:
1234 ret = handle_aiocb_rw(aiocb);
1235 if (ret == aiocb->aio_nbytes) {
1236 ret = 0;
1237 } else if (ret >= 0 && ret < aiocb->aio_nbytes) {
1238 ret = -EINVAL;
1239 }
1240 break;
1241 case QEMU_AIO_FLUSH:
1242 ret = handle_aiocb_flush(aiocb);
1243 break;
1244 case QEMU_AIO_IOCTL:
1245 ret = handle_aiocb_ioctl(aiocb);
1246 break;
1247 case QEMU_AIO_DISCARD:
1248 ret = handle_aiocb_discard(aiocb);
1249 break;
1250 case QEMU_AIO_WRITE_ZEROES:
1251 ret = handle_aiocb_write_zeroes(aiocb);
1252 break;
1253 default:
1254 fprintf(stderr, "invalid aio request (0x%x)\n", aiocb->aio_type);
1255 ret = -EINVAL;
1256 break;
1257 }
1258
1259 g_free(aiocb);
1260 return ret;
1261}
1262
1263static int paio_submit_co(BlockDriverState *bs, int fd,
1264 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
1265 int type)
1266{
1267 RawPosixAIOData *acb = g_new(RawPosixAIOData, 1);
1268 ThreadPool *pool;
1269
1270 acb->bs = bs;
1271 acb->aio_type = type;
1272 acb->aio_fildes = fd;
1273
1274 acb->aio_nbytes = nb_sectors * BDRV_SECTOR_SIZE;
1275 acb->aio_offset = sector_num * BDRV_SECTOR_SIZE;
1276
1277 if (qiov) {
1278 acb->aio_iov = qiov->iov;
1279 acb->aio_niov = qiov->niov;
1280 assert(qiov->size == acb->aio_nbytes);
1281 }
1282
1283 trace_paio_submit_co(sector_num, nb_sectors, type);
1284 pool = aio_get_thread_pool(bdrv_get_aio_context(bs));
1285 return thread_pool_submit_co(pool, aio_worker, acb);
1286}
1287
1288static BlockAIOCB *paio_submit(BlockDriverState *bs, int fd,
1289 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
1290 BlockCompletionFunc *cb, void *opaque, int type)
1291{
1292 RawPosixAIOData *acb = g_new(RawPosixAIOData, 1);
1293 ThreadPool *pool;
1294
1295 acb->bs = bs;
1296 acb->aio_type = type;
1297 acb->aio_fildes = fd;
1298
1299 acb->aio_nbytes = nb_sectors * BDRV_SECTOR_SIZE;
1300 acb->aio_offset = sector_num * BDRV_SECTOR_SIZE;
1301
1302 if (qiov) {
1303 acb->aio_iov = qiov->iov;
1304 acb->aio_niov = qiov->niov;
1305 assert(qiov->size == acb->aio_nbytes);
1306 }
1307
1308 trace_paio_submit(acb, opaque, sector_num, nb_sectors, type);
1309 pool = aio_get_thread_pool(bdrv_get_aio_context(bs));
1310 return thread_pool_submit_aio(pool, aio_worker, acb, cb, opaque);
1311}
1312
1313static BlockAIOCB *raw_aio_submit(BlockDriverState *bs,
1314 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
1315 BlockCompletionFunc *cb, void *opaque, int type)
1316{
1317 BDRVRawState *s = bs->opaque;
1318
1319 if (fd_open(bs) < 0)
1320 return NULL;
1321
1322
1323
1324
1325
1326
1327
1328 if (s->needs_alignment) {
1329 if (!bdrv_qiov_is_aligned(bs, qiov)) {
1330 type |= QEMU_AIO_MISALIGNED;
1331#ifdef CONFIG_LINUX_AIO
1332 } else if (s->use_aio) {
1333 return laio_submit(bs, s->aio_ctx, s->fd, sector_num, qiov,
1334 nb_sectors, cb, opaque, type);
1335#endif
1336 }
1337 }
1338
1339 return paio_submit(bs, s->fd, sector_num, qiov, nb_sectors,
1340 cb, opaque, type);
1341}
1342
1343static void raw_aio_plug(BlockDriverState *bs)
1344{
1345#ifdef CONFIG_LINUX_AIO
1346 BDRVRawState *s = bs->opaque;
1347 if (s->use_aio) {
1348 laio_io_plug(bs, s->aio_ctx);
1349 }
1350#endif
1351}
1352
1353static void raw_aio_unplug(BlockDriverState *bs)
1354{
1355#ifdef CONFIG_LINUX_AIO
1356 BDRVRawState *s = bs->opaque;
1357 if (s->use_aio) {
1358 laio_io_unplug(bs, s->aio_ctx, true);
1359 }
1360#endif
1361}
1362
1363static void raw_aio_flush_io_queue(BlockDriverState *bs)
1364{
1365#ifdef CONFIG_LINUX_AIO
1366 BDRVRawState *s = bs->opaque;
1367 if (s->use_aio) {
1368 laio_io_unplug(bs, s->aio_ctx, false);
1369 }
1370#endif
1371}
1372
1373static BlockAIOCB *raw_aio_readv(BlockDriverState *bs,
1374 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
1375 BlockCompletionFunc *cb, void *opaque)
1376{
1377 return raw_aio_submit(bs, sector_num, qiov, nb_sectors,
1378 cb, opaque, QEMU_AIO_READ);
1379}
1380
1381static BlockAIOCB *raw_aio_writev(BlockDriverState *bs,
1382 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
1383 BlockCompletionFunc *cb, void *opaque)
1384{
1385 return raw_aio_submit(bs, sector_num, qiov, nb_sectors,
1386 cb, opaque, QEMU_AIO_WRITE);
1387}
1388
1389static BlockAIOCB *raw_aio_flush(BlockDriverState *bs,
1390 BlockCompletionFunc *cb, void *opaque)
1391{
1392 BDRVRawState *s = bs->opaque;
1393
1394 if (fd_open(bs) < 0)
1395 return NULL;
1396
1397 return paio_submit(bs, s->fd, 0, NULL, 0, cb, opaque, QEMU_AIO_FLUSH);
1398}
1399
1400static void raw_close(BlockDriverState *bs)
1401{
1402 BDRVRawState *s = bs->opaque;
1403
1404 raw_detach_aio_context(bs);
1405
1406#ifdef CONFIG_LINUX_AIO
1407 if (s->use_aio) {
1408 laio_cleanup(s->aio_ctx);
1409 }
1410#endif
1411 if (s->fd >= 0) {
1412 qemu_close(s->fd);
1413 s->fd = -1;
1414 }
1415}
1416
1417static int raw_truncate(BlockDriverState *bs, int64_t offset)
1418{
1419 BDRVRawState *s = bs->opaque;
1420 struct stat st;
1421
1422 if (fstat(s->fd, &st)) {
1423 return -errno;
1424 }
1425
1426 if (S_ISREG(st.st_mode)) {
1427 if (ftruncate(s->fd, offset) < 0) {
1428 return -errno;
1429 }
1430 } else if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) {
1431 if (offset > raw_getlength(bs)) {
1432 return -EINVAL;
1433 }
1434 } else {
1435 return -ENOTSUP;
1436 }
1437
1438 return 0;
1439}
1440
1441#ifdef __OpenBSD__
1442static int64_t raw_getlength(BlockDriverState *bs)
1443{
1444 BDRVRawState *s = bs->opaque;
1445 int fd = s->fd;
1446 struct stat st;
1447
1448 if (fstat(fd, &st))
1449 return -errno;
1450 if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) {
1451 struct disklabel dl;
1452
1453 if (ioctl(fd, DIOCGDINFO, &dl))
1454 return -errno;
1455 return (uint64_t)dl.d_secsize *
1456 dl.d_partitions[DISKPART(st.st_rdev)].p_size;
1457 } else
1458 return st.st_size;
1459}
1460#elif defined(__NetBSD__)
1461static int64_t raw_getlength(BlockDriverState *bs)
1462{
1463 BDRVRawState *s = bs->opaque;
1464 int fd = s->fd;
1465 struct stat st;
1466
1467 if (fstat(fd, &st))
1468 return -errno;
1469 if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) {
1470 struct dkwedge_info dkw;
1471
1472 if (ioctl(fd, DIOCGWEDGEINFO, &dkw) != -1) {
1473 return dkw.dkw_size * 512;
1474 } else {
1475 struct disklabel dl;
1476
1477 if (ioctl(fd, DIOCGDINFO, &dl))
1478 return -errno;
1479 return (uint64_t)dl.d_secsize *
1480 dl.d_partitions[DISKPART(st.st_rdev)].p_size;
1481 }
1482 } else
1483 return st.st_size;
1484}
1485#elif defined(__sun__)
1486static int64_t raw_getlength(BlockDriverState *bs)
1487{
1488 BDRVRawState *s = bs->opaque;
1489 struct dk_minfo minfo;
1490 int ret;
1491 int64_t size;
1492
1493 ret = fd_open(bs);
1494 if (ret < 0) {
1495 return ret;
1496 }
1497
1498
1499
1500
1501 ret = ioctl(s->fd, DKIOCGMEDIAINFO, &minfo);
1502 if (ret != -1) {
1503 return minfo.dki_lbsize * minfo.dki_capacity;
1504 }
1505
1506
1507
1508
1509
1510 size = lseek(s->fd, 0, SEEK_END);
1511 if (size < 0) {
1512 return -errno;
1513 }
1514 return size;
1515}
1516#elif defined(CONFIG_BSD)
1517static int64_t raw_getlength(BlockDriverState *bs)
1518{
1519 BDRVRawState *s = bs->opaque;
1520 int fd = s->fd;
1521 int64_t size;
1522 struct stat sb;
1523#if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
1524 int reopened = 0;
1525#endif
1526 int ret;
1527
1528 ret = fd_open(bs);
1529 if (ret < 0)
1530 return ret;
1531
1532#if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
1533again:
1534#endif
1535 if (!fstat(fd, &sb) && (S_IFCHR & sb.st_mode)) {
1536#ifdef DIOCGMEDIASIZE
1537 if (ioctl(fd, DIOCGMEDIASIZE, (off_t *)&size))
1538#elif defined(DIOCGPART)
1539 {
1540 struct partinfo pi;
1541 if (ioctl(fd, DIOCGPART, &pi) == 0)
1542 size = pi.media_size;
1543 else
1544 size = 0;
1545 }
1546 if (size == 0)
1547#endif
1548#if defined(__APPLE__) && defined(__MACH__)
1549 {
1550 uint64_t sectors = 0;
1551 uint32_t sector_size = 0;
1552
1553 if (ioctl(fd, DKIOCGETBLOCKCOUNT, §ors) == 0
1554 && ioctl(fd, DKIOCGETBLOCKSIZE, §or_size) == 0) {
1555 size = sectors * sector_size;
1556 } else {
1557 size = lseek(fd, 0LL, SEEK_END);
1558 if (size < 0) {
1559 return -errno;
1560 }
1561 }
1562 }
1563#else
1564 size = lseek(fd, 0LL, SEEK_END);
1565 if (size < 0) {
1566 return -errno;
1567 }
1568#endif
1569#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1570 switch(s->type) {
1571 case FTYPE_CD:
1572
1573 if (size == 2048LL * (unsigned)-1)
1574 size = 0;
1575
1576 if (size <= 0 && !reopened && cdrom_reopen(bs) >= 0) {
1577 reopened = 1;
1578 goto again;
1579 }
1580 }
1581#endif
1582 } else {
1583 size = lseek(fd, 0, SEEK_END);
1584 if (size < 0) {
1585 return -errno;
1586 }
1587 }
1588 return size;
1589}
1590#else
1591static int64_t raw_getlength(BlockDriverState *bs)
1592{
1593 BDRVRawState *s = bs->opaque;
1594 int ret;
1595 int64_t size;
1596
1597 ret = fd_open(bs);
1598 if (ret < 0) {
1599 return ret;
1600 }
1601
1602 size = lseek(s->fd, 0, SEEK_END);
1603 if (size < 0) {
1604 return -errno;
1605 }
1606 return size;
1607}
1608#endif
1609
1610static int64_t raw_get_allocated_file_size(BlockDriverState *bs)
1611{
1612 struct stat st;
1613 BDRVRawState *s = bs->opaque;
1614
1615 if (fstat(s->fd, &st) < 0) {
1616 return -errno;
1617 }
1618 return (int64_t)st.st_blocks * 512;
1619}
1620
1621static int raw_create(const char *filename, QemuOpts *opts, Error **errp)
1622{
1623 int fd;
1624 int result = 0;
1625 int64_t total_size = 0;
1626 bool nocow = false;
1627 PreallocMode prealloc;
1628 char *buf = NULL;
1629 Error *local_err = NULL;
1630
1631 strstart(filename, "file:", &filename);
1632
1633
1634 total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
1635 BDRV_SECTOR_SIZE);
1636 nocow = qemu_opt_get_bool(opts, BLOCK_OPT_NOCOW, false);
1637 buf = qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC);
1638 prealloc = qapi_enum_parse(PreallocMode_lookup, buf,
1639 PREALLOC_MODE_MAX, PREALLOC_MODE_OFF,
1640 &local_err);
1641 g_free(buf);
1642 if (local_err) {
1643 error_propagate(errp, local_err);
1644 result = -EINVAL;
1645 goto out;
1646 }
1647
1648 fd = qemu_open(filename, O_RDWR | O_CREAT | O_TRUNC | O_BINARY,
1649 0644);
1650 if (fd < 0) {
1651 result = -errno;
1652 error_setg_errno(errp, -result, "Could not create file");
1653 goto out;
1654 }
1655
1656 if (nocow) {
1657#ifdef __linux__
1658
1659
1660
1661
1662
1663 int attr;
1664 if (ioctl(fd, FS_IOC_GETFLAGS, &attr) == 0) {
1665 attr |= FS_NOCOW_FL;
1666 ioctl(fd, FS_IOC_SETFLAGS, &attr);
1667 }
1668#endif
1669 }
1670
1671 if (ftruncate(fd, total_size) != 0) {
1672 result = -errno;
1673 error_setg_errno(errp, -result, "Could not resize file");
1674 goto out_close;
1675 }
1676
1677 switch (prealloc) {
1678#ifdef CONFIG_POSIX_FALLOCATE
1679 case PREALLOC_MODE_FALLOC:
1680
1681 result = -posix_fallocate(fd, 0, total_size);
1682 if (result != 0) {
1683 error_setg_errno(errp, -result,
1684 "Could not preallocate data for the new file");
1685 }
1686 break;
1687#endif
1688 case PREALLOC_MODE_FULL:
1689 {
1690 int64_t num = 0, left = total_size;
1691 buf = g_malloc0(65536);
1692
1693 while (left > 0) {
1694 num = MIN(left, 65536);
1695 result = write(fd, buf, num);
1696 if (result < 0) {
1697 result = -errno;
1698 error_setg_errno(errp, -result,
1699 "Could not write to the new file");
1700 break;
1701 }
1702 left -= result;
1703 }
1704 if (result >= 0) {
1705 result = fsync(fd);
1706 if (result < 0) {
1707 result = -errno;
1708 error_setg_errno(errp, -result,
1709 "Could not flush new file to disk");
1710 }
1711 }
1712 g_free(buf);
1713 break;
1714 }
1715 case PREALLOC_MODE_OFF:
1716 break;
1717 default:
1718 result = -EINVAL;
1719 error_setg(errp, "Unsupported preallocation mode: %s",
1720 PreallocMode_lookup[prealloc]);
1721 break;
1722 }
1723
1724out_close:
1725 if (qemu_close(fd) != 0 && result == 0) {
1726 result = -errno;
1727 error_setg_errno(errp, -result, "Could not close the new file");
1728 }
1729out:
1730 return result;
1731}
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743static int find_allocation(BlockDriverState *bs, off_t start,
1744 off_t *data, off_t *hole)
1745{
1746#if defined SEEK_HOLE && defined SEEK_DATA
1747 BDRVRawState *s = bs->opaque;
1748 off_t offs;
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761 offs = lseek(s->fd, start, SEEK_DATA);
1762 if (offs < 0) {
1763 return -errno;
1764 }
1765 assert(offs >= start);
1766
1767 if (offs > start) {
1768
1769 *hole = start;
1770 *data = offs;
1771 return 0;
1772 }
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793 offs = lseek(s->fd, start, SEEK_HOLE);
1794 if (offs < 0) {
1795 return -errno;
1796 }
1797 assert(offs >= start);
1798
1799 if (offs > start) {
1800
1801
1802
1803
1804
1805
1806 *data = start;
1807 *hole = offs;
1808 return 0;
1809 }
1810
1811
1812 return -EBUSY;
1813#else
1814 return -ENOTSUP;
1815#endif
1816}
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831static int64_t coroutine_fn raw_co_get_block_status(BlockDriverState *bs,
1832 int64_t sector_num,
1833 int nb_sectors, int *pnum)
1834{
1835 off_t start, data = 0, hole = 0;
1836 int64_t total_size;
1837 int ret;
1838
1839 ret = fd_open(bs);
1840 if (ret < 0) {
1841 return ret;
1842 }
1843
1844 start = sector_num * BDRV_SECTOR_SIZE;
1845 total_size = bdrv_getlength(bs);
1846 if (total_size < 0) {
1847 return total_size;
1848 } else if (start >= total_size) {
1849 *pnum = 0;
1850 return 0;
1851 } else if (start + nb_sectors * BDRV_SECTOR_SIZE > total_size) {
1852 nb_sectors = DIV_ROUND_UP(total_size - start, BDRV_SECTOR_SIZE);
1853 }
1854
1855 ret = find_allocation(bs, start, &data, &hole);
1856 if (ret == -ENXIO) {
1857
1858 *pnum = nb_sectors;
1859 ret = BDRV_BLOCK_ZERO;
1860 } else if (ret < 0) {
1861
1862 *pnum = nb_sectors;
1863 ret = BDRV_BLOCK_DATA;
1864 } else if (data == start) {
1865
1866
1867 *pnum = MIN(nb_sectors, DIV_ROUND_UP(hole - start, BDRV_SECTOR_SIZE));
1868 ret = BDRV_BLOCK_DATA;
1869 } else {
1870
1871 assert(hole == start);
1872 *pnum = MIN(nb_sectors, (data - start) / BDRV_SECTOR_SIZE);
1873 ret = BDRV_BLOCK_ZERO;
1874 }
1875 return ret | BDRV_BLOCK_OFFSET_VALID | start;
1876}
1877
1878static coroutine_fn BlockAIOCB *raw_aio_discard(BlockDriverState *bs,
1879 int64_t sector_num, int nb_sectors,
1880 BlockCompletionFunc *cb, void *opaque)
1881{
1882 BDRVRawState *s = bs->opaque;
1883
1884 return paio_submit(bs, s->fd, sector_num, NULL, nb_sectors,
1885 cb, opaque, QEMU_AIO_DISCARD);
1886}
1887
1888static int coroutine_fn raw_co_write_zeroes(
1889 BlockDriverState *bs, int64_t sector_num,
1890 int nb_sectors, BdrvRequestFlags flags)
1891{
1892 BDRVRawState *s = bs->opaque;
1893
1894 if (!(flags & BDRV_REQ_MAY_UNMAP)) {
1895 return paio_submit_co(bs, s->fd, sector_num, NULL, nb_sectors,
1896 QEMU_AIO_WRITE_ZEROES);
1897 } else if (s->discard_zeroes) {
1898 return paio_submit_co(bs, s->fd, sector_num, NULL, nb_sectors,
1899 QEMU_AIO_DISCARD);
1900 }
1901 return -ENOTSUP;
1902}
1903
1904static int raw_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
1905{
1906 BDRVRawState *s = bs->opaque;
1907
1908 bdi->unallocated_blocks_are_zero = s->discard_zeroes;
1909 bdi->can_write_zeroes_with_unmap = s->discard_zeroes;
1910 return 0;
1911}
1912
1913static QemuOptsList raw_create_opts = {
1914 .name = "raw-create-opts",
1915 .head = QTAILQ_HEAD_INITIALIZER(raw_create_opts.head),
1916 .desc = {
1917 {
1918 .name = BLOCK_OPT_SIZE,
1919 .type = QEMU_OPT_SIZE,
1920 .help = "Virtual disk size"
1921 },
1922 {
1923 .name = BLOCK_OPT_NOCOW,
1924 .type = QEMU_OPT_BOOL,
1925 .help = "Turn off copy-on-write (valid only on btrfs)"
1926 },
1927 {
1928 .name = BLOCK_OPT_PREALLOC,
1929 .type = QEMU_OPT_STRING,
1930 .help = "Preallocation mode (allowed values: off, falloc, full)"
1931 },
1932 { }
1933 }
1934};
1935
1936BlockDriver bdrv_file = {
1937 .format_name = "file",
1938 .protocol_name = "file",
1939 .instance_size = sizeof(BDRVRawState),
1940 .bdrv_needs_filename = true,
1941 .bdrv_probe = NULL,
1942 .bdrv_parse_filename = raw_parse_filename,
1943 .bdrv_file_open = raw_open,
1944 .bdrv_reopen_prepare = raw_reopen_prepare,
1945 .bdrv_reopen_commit = raw_reopen_commit,
1946 .bdrv_reopen_abort = raw_reopen_abort,
1947 .bdrv_close = raw_close,
1948 .bdrv_create = raw_create,
1949 .bdrv_has_zero_init = bdrv_has_zero_init_1,
1950 .bdrv_co_get_block_status = raw_co_get_block_status,
1951 .bdrv_co_write_zeroes = raw_co_write_zeroes,
1952
1953 .bdrv_aio_readv = raw_aio_readv,
1954 .bdrv_aio_writev = raw_aio_writev,
1955 .bdrv_aio_flush = raw_aio_flush,
1956 .bdrv_aio_discard = raw_aio_discard,
1957 .bdrv_refresh_limits = raw_refresh_limits,
1958 .bdrv_io_plug = raw_aio_plug,
1959 .bdrv_io_unplug = raw_aio_unplug,
1960 .bdrv_flush_io_queue = raw_aio_flush_io_queue,
1961
1962 .bdrv_truncate = raw_truncate,
1963 .bdrv_getlength = raw_getlength,
1964 .bdrv_get_info = raw_get_info,
1965 .bdrv_get_allocated_file_size
1966 = raw_get_allocated_file_size,
1967
1968 .bdrv_detach_aio_context = raw_detach_aio_context,
1969 .bdrv_attach_aio_context = raw_attach_aio_context,
1970
1971 .create_opts = &raw_create_opts,
1972};
1973
1974
1975
1976
1977#if defined(__APPLE__) && defined(__MACH__)
1978static kern_return_t FindEjectableCDMedia( io_iterator_t *mediaIterator );
1979static kern_return_t GetBSDPath(io_iterator_t mediaIterator, char *bsdPath,
1980 CFIndex maxPathSize, int flags);
1981kern_return_t FindEjectableCDMedia( io_iterator_t *mediaIterator )
1982{
1983 kern_return_t kernResult;
1984 mach_port_t masterPort;
1985 CFMutableDictionaryRef classesToMatch;
1986
1987 kernResult = IOMasterPort( MACH_PORT_NULL, &masterPort );
1988 if ( KERN_SUCCESS != kernResult ) {
1989 printf( "IOMasterPort returned %d\n", kernResult );
1990 }
1991
1992 classesToMatch = IOServiceMatching( kIOCDMediaClass );
1993 if ( classesToMatch == NULL ) {
1994 printf( "IOServiceMatching returned a NULL dictionary.\n" );
1995 } else {
1996 CFDictionarySetValue( classesToMatch, CFSTR( kIOMediaEjectableKey ), kCFBooleanTrue );
1997 }
1998 kernResult = IOServiceGetMatchingServices( masterPort, classesToMatch, mediaIterator );
1999 if ( KERN_SUCCESS != kernResult )
2000 {
2001 printf( "IOServiceGetMatchingServices returned %d\n", kernResult );
2002 }
2003
2004 return kernResult;
2005}
2006
2007kern_return_t GetBSDPath(io_iterator_t mediaIterator, char *bsdPath,
2008 CFIndex maxPathSize, int flags)
2009{
2010 io_object_t nextMedia;
2011 kern_return_t kernResult = KERN_FAILURE;
2012 *bsdPath = '\0';
2013 nextMedia = IOIteratorNext( mediaIterator );
2014 if ( nextMedia )
2015 {
2016 CFTypeRef bsdPathAsCFString;
2017 bsdPathAsCFString = IORegistryEntryCreateCFProperty( nextMedia, CFSTR( kIOBSDNameKey ), kCFAllocatorDefault, 0 );
2018 if ( bsdPathAsCFString ) {
2019 size_t devPathLength;
2020 strcpy( bsdPath, _PATH_DEV );
2021 if (flags & BDRV_O_NOCACHE) {
2022 strcat(bsdPath, "r");
2023 }
2024 devPathLength = strlen( bsdPath );
2025 if ( CFStringGetCString( bsdPathAsCFString, bsdPath + devPathLength, maxPathSize - devPathLength, kCFStringEncodingASCII ) ) {
2026 kernResult = KERN_SUCCESS;
2027 }
2028 CFRelease( bsdPathAsCFString );
2029 }
2030 IOObjectRelease( nextMedia );
2031 }
2032
2033 return kernResult;
2034}
2035
2036#endif
2037
2038static int hdev_probe_device(const char *filename)
2039{
2040 struct stat st;
2041
2042
2043 if (strstart(filename, "/dev/cdrom", NULL))
2044 return 50;
2045
2046 if (stat(filename, &st) >= 0 &&
2047 (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode))) {
2048 return 100;
2049 }
2050
2051 return 0;
2052}
2053
2054static int check_hdev_writable(BDRVRawState *s)
2055{
2056#if defined(BLKROGET)
2057
2058
2059
2060
2061
2062
2063
2064
2065 struct stat st;
2066 int readonly = 0;
2067
2068 if (fstat(s->fd, &st)) {
2069 return -errno;
2070 }
2071
2072 if (!S_ISBLK(st.st_mode)) {
2073 return 0;
2074 }
2075
2076 if (ioctl(s->fd, BLKROGET, &readonly) < 0) {
2077 return -errno;
2078 }
2079
2080 if (readonly) {
2081 return -EACCES;
2082 }
2083#endif
2084 return 0;
2085}
2086
2087static void hdev_parse_filename(const char *filename, QDict *options,
2088 Error **errp)
2089{
2090
2091 strstart(filename, "host_device:", &filename);
2092
2093 qdict_put_obj(options, "filename", QOBJECT(qstring_from_str(filename)));
2094}
2095
2096static bool hdev_is_sg(BlockDriverState *bs)
2097{
2098
2099#if defined(__linux__)
2100
2101 struct stat st;
2102 struct sg_scsi_id scsiid;
2103 int sg_version;
2104
2105 if (stat(bs->filename, &st) >= 0 && S_ISCHR(st.st_mode) &&
2106 !bdrv_ioctl(bs, SG_GET_VERSION_NUM, &sg_version) &&
2107 !bdrv_ioctl(bs, SG_GET_SCSI_ID, &scsiid)) {
2108 DPRINTF("SG device found: type=%d, version=%d\n",
2109 scsiid.scsi_type, sg_version);
2110 return true;
2111 }
2112
2113#endif
2114
2115 return false;
2116}
2117
2118static int hdev_open(BlockDriverState *bs, QDict *options, int flags,
2119 Error **errp)
2120{
2121 BDRVRawState *s = bs->opaque;
2122 Error *local_err = NULL;
2123 int ret;
2124
2125#if defined(__APPLE__) && defined(__MACH__)
2126 const char *filename = qdict_get_str(options, "filename");
2127
2128 if (strstart(filename, "/dev/cdrom", NULL)) {
2129 kern_return_t kernResult;
2130 io_iterator_t mediaIterator;
2131 char bsdPath[ MAXPATHLEN ];
2132 int fd;
2133
2134 kernResult = FindEjectableCDMedia( &mediaIterator );
2135 kernResult = GetBSDPath(mediaIterator, bsdPath, sizeof(bsdPath),
2136 flags);
2137 if ( bsdPath[ 0 ] != '\0' ) {
2138 strcat(bsdPath,"s0");
2139
2140 fd = qemu_open(bsdPath, O_RDONLY | O_BINARY | O_LARGEFILE);
2141 if (fd < 0) {
2142 bsdPath[strlen(bsdPath)-1] = '1';
2143 } else {
2144 qemu_close(fd);
2145 }
2146 filename = bsdPath;
2147 qdict_put(options, "filename", qstring_from_str(filename));
2148 }
2149
2150 if ( mediaIterator )
2151 IOObjectRelease( mediaIterator );
2152 }
2153#endif
2154
2155 s->type = FTYPE_FILE;
2156
2157 ret = raw_open_common(bs, options, flags, 0, &local_err);
2158 if (ret < 0) {
2159 if (local_err) {
2160 error_propagate(errp, local_err);
2161 }
2162 return ret;
2163 }
2164
2165
2166 bs->sg = hdev_is_sg(bs);
2167
2168 if (flags & BDRV_O_RDWR) {
2169 ret = check_hdev_writable(s);
2170 if (ret < 0) {
2171 raw_close(bs);
2172 error_setg_errno(errp, -ret, "The device is not writable");
2173 return ret;
2174 }
2175 }
2176
2177 return ret;
2178}
2179
2180#if defined(__linux__)
2181
2182static BlockAIOCB *hdev_aio_ioctl(BlockDriverState *bs,
2183 unsigned long int req, void *buf,
2184 BlockCompletionFunc *cb, void *opaque)
2185{
2186 BDRVRawState *s = bs->opaque;
2187 RawPosixAIOData *acb;
2188 ThreadPool *pool;
2189
2190 if (fd_open(bs) < 0)
2191 return NULL;
2192
2193 acb = g_new(RawPosixAIOData, 1);
2194 acb->bs = bs;
2195 acb->aio_type = QEMU_AIO_IOCTL;
2196 acb->aio_fildes = s->fd;
2197 acb->aio_offset = 0;
2198 acb->aio_ioctl_buf = buf;
2199 acb->aio_ioctl_cmd = req;
2200 pool = aio_get_thread_pool(bdrv_get_aio_context(bs));
2201 return thread_pool_submit_aio(pool, aio_worker, acb, cb, opaque);
2202}
2203#endif
2204
2205static int fd_open(BlockDriverState *bs)
2206{
2207 BDRVRawState *s = bs->opaque;
2208
2209
2210 if (s->fd >= 0)
2211 return 0;
2212 return -EIO;
2213}
2214
2215static coroutine_fn BlockAIOCB *hdev_aio_discard(BlockDriverState *bs,
2216 int64_t sector_num, int nb_sectors,
2217 BlockCompletionFunc *cb, void *opaque)
2218{
2219 BDRVRawState *s = bs->opaque;
2220
2221 if (fd_open(bs) < 0) {
2222 return NULL;
2223 }
2224 return paio_submit(bs, s->fd, sector_num, NULL, nb_sectors,
2225 cb, opaque, QEMU_AIO_DISCARD|QEMU_AIO_BLKDEV);
2226}
2227
2228static coroutine_fn int hdev_co_write_zeroes(BlockDriverState *bs,
2229 int64_t sector_num, int nb_sectors, BdrvRequestFlags flags)
2230{
2231 BDRVRawState *s = bs->opaque;
2232 int rc;
2233
2234 rc = fd_open(bs);
2235 if (rc < 0) {
2236 return rc;
2237 }
2238 if (!(flags & BDRV_REQ_MAY_UNMAP)) {
2239 return paio_submit_co(bs, s->fd, sector_num, NULL, nb_sectors,
2240 QEMU_AIO_WRITE_ZEROES|QEMU_AIO_BLKDEV);
2241 } else if (s->discard_zeroes) {
2242 return paio_submit_co(bs, s->fd, sector_num, NULL, nb_sectors,
2243 QEMU_AIO_DISCARD|QEMU_AIO_BLKDEV);
2244 }
2245 return -ENOTSUP;
2246}
2247
2248static int hdev_create(const char *filename, QemuOpts *opts,
2249 Error **errp)
2250{
2251 int fd;
2252 int ret = 0;
2253 struct stat stat_buf;
2254 int64_t total_size = 0;
2255 bool has_prefix;
2256
2257
2258
2259
2260
2261 has_prefix =
2262 strstart(filename, "host_device:", &filename) ||
2263 strstart(filename, "host_cdrom:" , &filename);
2264
2265 (void)has_prefix;
2266
2267 ret = raw_normalize_devicepath(&filename);
2268 if (ret < 0) {
2269 error_setg_errno(errp, -ret, "Could not normalize device path");
2270 return ret;
2271 }
2272
2273
2274 total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
2275 BDRV_SECTOR_SIZE);
2276
2277 fd = qemu_open(filename, O_WRONLY | O_BINARY);
2278 if (fd < 0) {
2279 ret = -errno;
2280 error_setg_errno(errp, -ret, "Could not open device");
2281 return ret;
2282 }
2283
2284 if (fstat(fd, &stat_buf) < 0) {
2285 ret = -errno;
2286 error_setg_errno(errp, -ret, "Could not stat device");
2287 } else if (!S_ISBLK(stat_buf.st_mode) && !S_ISCHR(stat_buf.st_mode)) {
2288 error_setg(errp,
2289 "The given file is neither a block nor a character device");
2290 ret = -ENODEV;
2291 } else if (lseek(fd, 0, SEEK_END) < total_size) {
2292 error_setg(errp, "Device is too small");
2293 ret = -ENOSPC;
2294 }
2295
2296 qemu_close(fd);
2297 return ret;
2298}
2299
2300static BlockDriver bdrv_host_device = {
2301 .format_name = "host_device",
2302 .protocol_name = "host_device",
2303 .instance_size = sizeof(BDRVRawState),
2304 .bdrv_needs_filename = true,
2305 .bdrv_probe_device = hdev_probe_device,
2306 .bdrv_parse_filename = hdev_parse_filename,
2307 .bdrv_file_open = hdev_open,
2308 .bdrv_close = raw_close,
2309 .bdrv_reopen_prepare = raw_reopen_prepare,
2310 .bdrv_reopen_commit = raw_reopen_commit,
2311 .bdrv_reopen_abort = raw_reopen_abort,
2312 .bdrv_create = hdev_create,
2313 .create_opts = &raw_create_opts,
2314 .bdrv_co_write_zeroes = hdev_co_write_zeroes,
2315
2316 .bdrv_aio_readv = raw_aio_readv,
2317 .bdrv_aio_writev = raw_aio_writev,
2318 .bdrv_aio_flush = raw_aio_flush,
2319 .bdrv_aio_discard = hdev_aio_discard,
2320 .bdrv_refresh_limits = raw_refresh_limits,
2321 .bdrv_io_plug = raw_aio_plug,
2322 .bdrv_io_unplug = raw_aio_unplug,
2323 .bdrv_flush_io_queue = raw_aio_flush_io_queue,
2324
2325 .bdrv_truncate = raw_truncate,
2326 .bdrv_getlength = raw_getlength,
2327 .bdrv_get_info = raw_get_info,
2328 .bdrv_get_allocated_file_size
2329 = raw_get_allocated_file_size,
2330 .bdrv_probe_blocksizes = hdev_probe_blocksizes,
2331 .bdrv_probe_geometry = hdev_probe_geometry,
2332
2333 .bdrv_detach_aio_context = raw_detach_aio_context,
2334 .bdrv_attach_aio_context = raw_attach_aio_context,
2335
2336
2337#ifdef __linux__
2338 .bdrv_aio_ioctl = hdev_aio_ioctl,
2339#endif
2340};
2341
2342#if defined(__linux__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
2343static void cdrom_parse_filename(const char *filename, QDict *options,
2344 Error **errp)
2345{
2346
2347 strstart(filename, "host_cdrom:", &filename);
2348
2349 qdict_put_obj(options, "filename", QOBJECT(qstring_from_str(filename)));
2350}
2351#endif
2352
2353#ifdef __linux__
2354static int cdrom_open(BlockDriverState *bs, QDict *options, int flags,
2355 Error **errp)
2356{
2357 BDRVRawState *s = bs->opaque;
2358 Error *local_err = NULL;
2359 int ret;
2360
2361 s->type = FTYPE_CD;
2362
2363
2364 ret = raw_open_common(bs, options, flags, O_NONBLOCK, &local_err);
2365 if (local_err) {
2366 error_propagate(errp, local_err);
2367 }
2368 return ret;
2369}
2370
2371static int cdrom_probe_device(const char *filename)
2372{
2373 int fd, ret;
2374 int prio = 0;
2375 struct stat st;
2376
2377 fd = qemu_open(filename, O_RDONLY | O_NONBLOCK);
2378 if (fd < 0) {
2379 goto out;
2380 }
2381 ret = fstat(fd, &st);
2382 if (ret == -1 || !S_ISBLK(st.st_mode)) {
2383 goto outc;
2384 }
2385
2386
2387 ret = ioctl(fd, CDROM_DRIVE_STATUS, CDSL_CURRENT);
2388 if (ret >= 0)
2389 prio = 100;
2390
2391outc:
2392 qemu_close(fd);
2393out:
2394 return prio;
2395}
2396
2397static bool cdrom_is_inserted(BlockDriverState *bs)
2398{
2399 BDRVRawState *s = bs->opaque;
2400 int ret;
2401
2402 ret = ioctl(s->fd, CDROM_DRIVE_STATUS, CDSL_CURRENT);
2403 return ret == CDS_DISC_OK;
2404}
2405
2406static void cdrom_eject(BlockDriverState *bs, bool eject_flag)
2407{
2408 BDRVRawState *s = bs->opaque;
2409
2410 if (eject_flag) {
2411 if (ioctl(s->fd, CDROMEJECT, NULL) < 0)
2412 perror("CDROMEJECT");
2413 } else {
2414 if (ioctl(s->fd, CDROMCLOSETRAY, NULL) < 0)
2415 perror("CDROMEJECT");
2416 }
2417}
2418
2419static void cdrom_lock_medium(BlockDriverState *bs, bool locked)
2420{
2421 BDRVRawState *s = bs->opaque;
2422
2423 if (ioctl(s->fd, CDROM_LOCKDOOR, locked) < 0) {
2424
2425
2426
2427
2428
2429 }
2430}
2431
2432static BlockDriver bdrv_host_cdrom = {
2433 .format_name = "host_cdrom",
2434 .protocol_name = "host_cdrom",
2435 .instance_size = sizeof(BDRVRawState),
2436 .bdrv_needs_filename = true,
2437 .bdrv_probe_device = cdrom_probe_device,
2438 .bdrv_parse_filename = cdrom_parse_filename,
2439 .bdrv_file_open = cdrom_open,
2440 .bdrv_close = raw_close,
2441 .bdrv_reopen_prepare = raw_reopen_prepare,
2442 .bdrv_reopen_commit = raw_reopen_commit,
2443 .bdrv_reopen_abort = raw_reopen_abort,
2444 .bdrv_create = hdev_create,
2445 .create_opts = &raw_create_opts,
2446
2447 .bdrv_aio_readv = raw_aio_readv,
2448 .bdrv_aio_writev = raw_aio_writev,
2449 .bdrv_aio_flush = raw_aio_flush,
2450 .bdrv_refresh_limits = raw_refresh_limits,
2451 .bdrv_io_plug = raw_aio_plug,
2452 .bdrv_io_unplug = raw_aio_unplug,
2453 .bdrv_flush_io_queue = raw_aio_flush_io_queue,
2454
2455 .bdrv_truncate = raw_truncate,
2456 .bdrv_getlength = raw_getlength,
2457 .has_variable_length = true,
2458 .bdrv_get_allocated_file_size
2459 = raw_get_allocated_file_size,
2460
2461 .bdrv_detach_aio_context = raw_detach_aio_context,
2462 .bdrv_attach_aio_context = raw_attach_aio_context,
2463
2464
2465 .bdrv_is_inserted = cdrom_is_inserted,
2466 .bdrv_eject = cdrom_eject,
2467 .bdrv_lock_medium = cdrom_lock_medium,
2468
2469
2470 .bdrv_aio_ioctl = hdev_aio_ioctl,
2471};
2472#endif
2473
2474#if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
2475static int cdrom_open(BlockDriverState *bs, QDict *options, int flags,
2476 Error **errp)
2477{
2478 BDRVRawState *s = bs->opaque;
2479 Error *local_err = NULL;
2480 int ret;
2481
2482 s->type = FTYPE_CD;
2483
2484 ret = raw_open_common(bs, options, flags, 0, &local_err);
2485 if (ret) {
2486 if (local_err) {
2487 error_propagate(errp, local_err);
2488 }
2489 return ret;
2490 }
2491
2492
2493 ioctl(s->fd, CDIOCALLOW);
2494 return 0;
2495}
2496
2497static int cdrom_probe_device(const char *filename)
2498{
2499 if (strstart(filename, "/dev/cd", NULL) ||
2500 strstart(filename, "/dev/acd", NULL))
2501 return 100;
2502 return 0;
2503}
2504
2505static int cdrom_reopen(BlockDriverState *bs)
2506{
2507 BDRVRawState *s = bs->opaque;
2508 int fd;
2509
2510
2511
2512
2513
2514 if (s->fd >= 0)
2515 qemu_close(s->fd);
2516 fd = qemu_open(bs->filename, s->open_flags, 0644);
2517 if (fd < 0) {
2518 s->fd = -1;
2519 return -EIO;
2520 }
2521 s->fd = fd;
2522
2523
2524 ioctl(s->fd, CDIOCALLOW);
2525 return 0;
2526}
2527
2528static bool cdrom_is_inserted(BlockDriverState *bs)
2529{
2530 return raw_getlength(bs) > 0;
2531}
2532
2533static void cdrom_eject(BlockDriverState *bs, bool eject_flag)
2534{
2535 BDRVRawState *s = bs->opaque;
2536
2537 if (s->fd < 0)
2538 return;
2539
2540 (void) ioctl(s->fd, CDIOCALLOW);
2541
2542 if (eject_flag) {
2543 if (ioctl(s->fd, CDIOCEJECT) < 0)
2544 perror("CDIOCEJECT");
2545 } else {
2546 if (ioctl(s->fd, CDIOCCLOSE) < 0)
2547 perror("CDIOCCLOSE");
2548 }
2549
2550 cdrom_reopen(bs);
2551}
2552
2553static void cdrom_lock_medium(BlockDriverState *bs, bool locked)
2554{
2555 BDRVRawState *s = bs->opaque;
2556
2557 if (s->fd < 0)
2558 return;
2559 if (ioctl(s->fd, (locked ? CDIOCPREVENT : CDIOCALLOW)) < 0) {
2560
2561
2562
2563
2564
2565 }
2566}
2567
2568static BlockDriver bdrv_host_cdrom = {
2569 .format_name = "host_cdrom",
2570 .protocol_name = "host_cdrom",
2571 .instance_size = sizeof(BDRVRawState),
2572 .bdrv_needs_filename = true,
2573 .bdrv_probe_device = cdrom_probe_device,
2574 .bdrv_parse_filename = cdrom_parse_filename,
2575 .bdrv_file_open = cdrom_open,
2576 .bdrv_close = raw_close,
2577 .bdrv_reopen_prepare = raw_reopen_prepare,
2578 .bdrv_reopen_commit = raw_reopen_commit,
2579 .bdrv_reopen_abort = raw_reopen_abort,
2580 .bdrv_create = hdev_create,
2581 .create_opts = &raw_create_opts,
2582
2583 .bdrv_aio_readv = raw_aio_readv,
2584 .bdrv_aio_writev = raw_aio_writev,
2585 .bdrv_aio_flush = raw_aio_flush,
2586 .bdrv_refresh_limits = raw_refresh_limits,
2587 .bdrv_io_plug = raw_aio_plug,
2588 .bdrv_io_unplug = raw_aio_unplug,
2589 .bdrv_flush_io_queue = raw_aio_flush_io_queue,
2590
2591 .bdrv_truncate = raw_truncate,
2592 .bdrv_getlength = raw_getlength,
2593 .has_variable_length = true,
2594 .bdrv_get_allocated_file_size
2595 = raw_get_allocated_file_size,
2596
2597 .bdrv_detach_aio_context = raw_detach_aio_context,
2598 .bdrv_attach_aio_context = raw_attach_aio_context,
2599
2600
2601 .bdrv_is_inserted = cdrom_is_inserted,
2602 .bdrv_eject = cdrom_eject,
2603 .bdrv_lock_medium = cdrom_lock_medium,
2604};
2605#endif
2606
2607static void bdrv_file_init(void)
2608{
2609
2610
2611
2612
2613 bdrv_register(&bdrv_file);
2614 bdrv_register(&bdrv_host_device);
2615#ifdef __linux__
2616 bdrv_register(&bdrv_host_cdrom);
2617#endif
2618#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
2619 bdrv_register(&bdrv_host_cdrom);
2620#endif
2621}
2622
2623block_init(bdrv_file_init);
2624