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