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