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