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