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