?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ui/vnc: optimize clearing in find_and_clear_dirty_height()
[qemu/cris-port.git] / block / raw-posix.c
blobe6b4c1fe02534130eab899b3b6b231aba3c24041
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 int hdev_open(BlockDriverState *bs, QDict *options, int flags,
1565 Error **errp)
1566 {
1567 BDRVRawState *s = bs->opaque;
1568 Error *local_err = NULL;
1569 int ret;
1570 const char *filename = qdict_get_str(options, "filename");
1571
1572 #if defined(__APPLE__) && defined(__MACH__)
1573 if (strstart(filename, "/dev/cdrom", NULL)) {
1574 kern_return_t kernResult;
1575 io_iterator_t mediaIterator;
1576 char bsdPath[ MAXPATHLEN ];
1577 int fd;
1578
1579 kernResult = FindEjectableCDMedia( &mediaIterator );
1580 kernResult = GetBSDPath( mediaIterator, bsdPath, sizeof( bsdPath ) );
1581
1582 if ( bsdPath[ 0 ] != '\0' ) {
1583 strcat(bsdPath,"s0");
1584 /* some CDs don't have a partition 0 */
1585 fd = qemu_open(bsdPath, O_RDONLY | O_BINARY | O_LARGEFILE);
1586 if (fd < 0) {
1587 bsdPath[strlen(bsdPath)-1] = '1';
1588 } else {
1589 qemu_close(fd);
1590 }
1591 filename = bsdPath;
1592 qdict_put(options, "filename", qstring_from_str(filename));
1593 }
1594
1595 if ( mediaIterator )
1596 IOObjectRelease( mediaIterator );
1597 }
1598 #endif
1599
1600 s->type = FTYPE_FILE;
1601 #if defined(__linux__)
1602 {
1603 char resolved_path[ MAXPATHLEN ], *temp;
1604
1605 temp = realpath(filename, resolved_path);
1606 if (temp && strstart(temp, "/dev/sg", NULL)) {
1607 bs->sg = 1;
1608 }
1609 }
1610 #endif
1611
1612 ret = raw_open_common(bs, options, flags, 0, &local_err);
1613 if (ret < 0) {
1614 if (local_err) {
1615 error_propagate(errp, local_err);
1616 }
1617 return ret;
1618 }
1619
1620 if (flags & BDRV_O_RDWR) {
1621 ret = check_hdev_writable(s);
1622 if (ret < 0) {
1623 raw_close(bs);
1624 error_setg_errno(errp, -ret, "The device is not writable");
1625 return ret;
1626 }
1627 }
1628
1629 return ret;
1630 }
1631
1632 #if defined(__linux__)
1633 /* Note: we do not have a reliable method to detect if the floppy is
1634 present. The current method is to try to open the floppy at every
1635 I/O and to keep it opened during a few hundreds of ms. */
1636 static int fd_open(BlockDriverState *bs)
1637 {
1638 BDRVRawState *s = bs->opaque;
1639 int last_media_present;
1640
1641 if (s->type != FTYPE_FD)
1642 return 0;
1643 last_media_present = (s->fd >= 0);
1644 if (s->fd >= 0 &&
1645 (get_clock() - s->fd_open_time) >= FD_OPEN_TIMEOUT) {
1646 qemu_close(s->fd);
1647 s->fd = -1;
1648 #ifdef DEBUG_FLOPPY
1649 printf("Floppy closed\n");
1650 #endif
1651 }
1652 if (s->fd < 0) {
1653 if (s->fd_got_error &&
1654 (get_clock() - s->fd_error_time) < FD_OPEN_TIMEOUT) {
1655 #ifdef DEBUG_FLOPPY
1656 printf("No floppy (open delayed)\n");
1657 #endif
1658 return -EIO;
1659 }
1660 s->fd = qemu_open(bs->filename, s->open_flags & ~O_NONBLOCK);
1661 if (s->fd < 0) {
1662 s->fd_error_time = get_clock();
1663 s->fd_got_error = 1;
1664 if (last_media_present)
1665 s->fd_media_changed = 1;
1666 #ifdef DEBUG_FLOPPY
1667 printf("No floppy\n");
1668 #endif
1669 return -EIO;
1670 }
1671 #ifdef DEBUG_FLOPPY
1672 printf("Floppy opened\n");
1673 #endif
1674 }
1675 if (!last_media_present)
1676 s->fd_media_changed = 1;
1677 s->fd_open_time = get_clock();
1678 s->fd_got_error = 0;
1679 return 0;
1680 }
1681
1682 static int hdev_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
1683 {
1684 BDRVRawState *s = bs->opaque;
1685
1686 return ioctl(s->fd, req, buf);
1687 }
1688
1689 static BlockDriverAIOCB *hdev_aio_ioctl(BlockDriverState *bs,
1690 unsigned long int req, void *buf,
1691 BlockDriverCompletionFunc *cb, void *opaque)
1692 {
1693 BDRVRawState *s = bs->opaque;
1694 RawPosixAIOData *acb;
1695 ThreadPool *pool;
1696
1697 if (fd_open(bs) < 0)
1698 return NULL;
1699
1700 acb = g_slice_new(RawPosixAIOData);
1701 acb->bs = bs;
1702 acb->aio_type = QEMU_AIO_IOCTL;
1703 acb->aio_fildes = s->fd;
1704 acb->aio_offset = 0;
1705 acb->aio_ioctl_buf = buf;
1706 acb->aio_ioctl_cmd = req;
1707 pool = aio_get_thread_pool(bdrv_get_aio_context(bs));
1708 return thread_pool_submit_aio(pool, aio_worker, acb, cb, opaque);
1709 }
1710
1711 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1712 static int fd_open(BlockDriverState *bs)
1713 {
1714 BDRVRawState *s = bs->opaque;
1715
1716 /* this is just to ensure s->fd is sane (its called by io ops) */
1717 if (s->fd >= 0)
1718 return 0;
1719 return -EIO;
1720 }
1721 #else /* !linux && !FreeBSD */
1722
1723 static int fd_open(BlockDriverState *bs)
1724 {
1725 return 0;
1726 }
1727
1728 #endif /* !linux && !FreeBSD */
1729
1730 static coroutine_fn BlockDriverAIOCB *hdev_aio_discard(BlockDriverState *bs,
1731 int64_t sector_num, int nb_sectors,
1732 BlockDriverCompletionFunc *cb, void *opaque)
1733 {
1734 BDRVRawState *s = bs->opaque;
1735
1736 if (fd_open(bs) < 0) {
1737 return NULL;
1738 }
1739 return paio_submit(bs, s->fd, sector_num, NULL, nb_sectors,
1740 cb, opaque, QEMU_AIO_DISCARD|QEMU_AIO_BLKDEV);
1741 }
1742
1743 static coroutine_fn int hdev_co_write_zeroes(BlockDriverState *bs,
1744 int64_t sector_num, int nb_sectors, BdrvRequestFlags flags)
1745 {
1746 BDRVRawState *s = bs->opaque;
1747 int rc;
1748
1749 rc = fd_open(bs);
1750 if (rc < 0) {
1751 return rc;
1752 }
1753 if (!(flags & BDRV_REQ_MAY_UNMAP)) {
1754 return paio_submit_co(bs, s->fd, sector_num, NULL, nb_sectors,
1755 QEMU_AIO_WRITE_ZEROES|QEMU_AIO_BLKDEV);
1756 } else if (s->discard_zeroes) {
1757 return paio_submit_co(bs, s->fd, sector_num, NULL, nb_sectors,
1758 QEMU_AIO_DISCARD|QEMU_AIO_BLKDEV);
1759 }
1760 return -ENOTSUP;
1761 }
1762
1763 static int hdev_create(const char *filename, QEMUOptionParameter *options,
1764 Error **errp)
1765 {
1766 int fd;
1767 int ret = 0;
1768 struct stat stat_buf;
1769 int64_t total_size = 0;
1770
1771 /* Read out options */
1772 while (options && options->name) {
1773 if (!strcmp(options->name, "size")) {
1774 total_size = options->value.n / BDRV_SECTOR_SIZE;
1775 }
1776 options++;
1777 }
1778
1779 fd = qemu_open(filename, O_WRONLY | O_BINARY);
1780 if (fd < 0) {
1781 ret = -errno;
1782 error_setg_errno(errp, -ret, "Could not open device");
1783 return ret;
1784 }
1785
1786 if (fstat(fd, &stat_buf) < 0) {
1787 ret = -errno;
1788 error_setg_errno(errp, -ret, "Could not stat device");
1789 } else if (!S_ISBLK(stat_buf.st_mode) && !S_ISCHR(stat_buf.st_mode)) {
1790 error_setg(errp,
1791 "The given file is neither a block nor a character device");
1792 ret = -ENODEV;
1793 } else if (lseek(fd, 0, SEEK_END) < total_size * BDRV_SECTOR_SIZE) {
1794 error_setg(errp, "Device is too small");
1795 ret = -ENOSPC;
1796 }
1797
1798 qemu_close(fd);
1799 return ret;
1800 }
1801
1802 static BlockDriver bdrv_host_device = {
1803 .format_name = "host_device",
1804 .protocol_name = "host_device",
1805 .instance_size = sizeof(BDRVRawState),
1806 .bdrv_needs_filename = true,
1807 .bdrv_probe_device = hdev_probe_device,
1808 .bdrv_file_open = hdev_open,
1809 .bdrv_close = raw_close,
1810 .bdrv_reopen_prepare = raw_reopen_prepare,
1811 .bdrv_reopen_commit = raw_reopen_commit,
1812 .bdrv_reopen_abort = raw_reopen_abort,
1813 .bdrv_create = hdev_create,
1814 .create_options = raw_create_options,
1815 .bdrv_co_write_zeroes = hdev_co_write_zeroes,
1816
1817 .bdrv_aio_readv = raw_aio_readv,
1818 .bdrv_aio_writev = raw_aio_writev,
1819 .bdrv_aio_flush = raw_aio_flush,
1820 .bdrv_aio_discard = hdev_aio_discard,
1821 .bdrv_refresh_limits = raw_refresh_limits,
1822
1823 .bdrv_truncate = raw_truncate,
1824 .bdrv_getlength = raw_getlength,
1825 .bdrv_get_info = raw_get_info,
1826 .bdrv_get_allocated_file_size
1827 = raw_get_allocated_file_size,
1828
1829 /* generic scsi device */
1830 #ifdef __linux__
1831 .bdrv_ioctl = hdev_ioctl,
1832 .bdrv_aio_ioctl = hdev_aio_ioctl,
1833 #endif
1834 };
1835
1836 #ifdef __linux__
1837 static int floppy_open(BlockDriverState *bs, QDict *options, int flags,
1838 Error **errp)
1839 {
1840 BDRVRawState *s = bs->opaque;
1841 Error *local_err = NULL;
1842 int ret;
1843
1844 s->type = FTYPE_FD;
1845
1846 /* open will not fail even if no floppy is inserted, so add O_NONBLOCK */
1847 ret = raw_open_common(bs, options, flags, O_NONBLOCK, &local_err);
1848 if (ret) {
1849 if (local_err) {
1850 error_propagate(errp, local_err);
1851 }
1852 return ret;
1853 }
1854
1855 /* close fd so that we can reopen it as needed */
1856 qemu_close(s->fd);
1857 s->fd = -1;
1858 s->fd_media_changed = 1;
1859
1860 return 0;
1861 }
1862
1863 static int floppy_probe_device(const char *filename)
1864 {
1865 int fd, ret;
1866 int prio = 0;
1867 struct floppy_struct fdparam;
1868 struct stat st;
1869
1870 if (strstart(filename, "/dev/fd", NULL) &&
1871 !strstart(filename, "/dev/fdset/", NULL)) {
1872 prio = 50;
1873 }
1874
1875 fd = qemu_open(filename, O_RDONLY | O_NONBLOCK);
1876 if (fd < 0) {
1877 goto out;
1878 }
1879 ret = fstat(fd, &st);
1880 if (ret == -1 || !S_ISBLK(st.st_mode)) {
1881 goto outc;
1882 }
1883
1884 /* Attempt to detect via a floppy specific ioctl */
1885 ret = ioctl(fd, FDGETPRM, &fdparam);
1886 if (ret >= 0)
1887 prio = 100;
1888
1889 outc:
1890 qemu_close(fd);
1891 out:
1892 return prio;
1893 }
1894
1895
1896 static int floppy_is_inserted(BlockDriverState *bs)
1897 {
1898 return fd_open(bs) >= 0;
1899 }
1900
1901 static int floppy_media_changed(BlockDriverState *bs)
1902 {
1903 BDRVRawState *s = bs->opaque;
1904 int ret;
1905
1906 /*
1907 * XXX: we do not have a true media changed indication.
1908 * It does not work if the floppy is changed without trying to read it.
1909 */
1910 fd_open(bs);
1911 ret = s->fd_media_changed;
1912 s->fd_media_changed = 0;
1913 #ifdef DEBUG_FLOPPY
1914 printf("Floppy changed=%d\n", ret);
1915 #endif
1916 return ret;
1917 }
1918
1919 static void floppy_eject(BlockDriverState *bs, bool eject_flag)
1920 {
1921 BDRVRawState *s = bs->opaque;
1922 int fd;
1923
1924 if (s->fd >= 0) {
1925 qemu_close(s->fd);
1926 s->fd = -1;
1927 }
1928 fd = qemu_open(bs->filename, s->open_flags | O_NONBLOCK);
1929 if (fd >= 0) {
1930 if (ioctl(fd, FDEJECT, 0) < 0)
1931 perror("FDEJECT");
1932 qemu_close(fd);
1933 }
1934 }
1935
1936 static BlockDriver bdrv_host_floppy = {
1937 .format_name = "host_floppy",
1938 .protocol_name = "host_floppy",
1939 .instance_size = sizeof(BDRVRawState),
1940 .bdrv_needs_filename = true,
1941 .bdrv_probe_device = floppy_probe_device,
1942 .bdrv_file_open = floppy_open,
1943 .bdrv_close = raw_close,
1944 .bdrv_reopen_prepare = raw_reopen_prepare,
1945 .bdrv_reopen_commit = raw_reopen_commit,
1946 .bdrv_reopen_abort = raw_reopen_abort,
1947 .bdrv_create = hdev_create,
1948 .create_options = raw_create_options,
1949
1950 .bdrv_aio_readv = raw_aio_readv,
1951 .bdrv_aio_writev = raw_aio_writev,
1952 .bdrv_aio_flush = raw_aio_flush,
1953 .bdrv_refresh_limits = raw_refresh_limits,
1954
1955 .bdrv_truncate = raw_truncate,
1956 .bdrv_getlength = raw_getlength,
1957 .has_variable_length = true,
1958 .bdrv_get_allocated_file_size
1959 = raw_get_allocated_file_size,
1960
1961 /* removable device support */
1962 .bdrv_is_inserted = floppy_is_inserted,
1963 .bdrv_media_changed = floppy_media_changed,
1964 .bdrv_eject = floppy_eject,
1965 };
1966
1967 static int cdrom_open(BlockDriverState *bs, QDict *options, int flags,
1968 Error **errp)
1969 {
1970 BDRVRawState *s = bs->opaque;
1971 Error *local_err = NULL;
1972 int ret;
1973
1974 s->type = FTYPE_CD;
1975
1976 /* open will not fail even if no CD is inserted, so add O_NONBLOCK */
1977 ret = raw_open_common(bs, options, flags, O_NONBLOCK, &local_err);
1978 if (local_err) {
1979 error_propagate(errp, local_err);
1980 }
1981 return ret;
1982 }
1983
1984 static int cdrom_probe_device(const char *filename)
1985 {
1986 int fd, ret;
1987 int prio = 0;
1988 struct stat st;
1989
1990 fd = qemu_open(filename, O_RDONLY | O_NONBLOCK);
1991 if (fd < 0) {
1992 goto out;
1993 }
1994 ret = fstat(fd, &st);
1995 if (ret == -1 || !S_ISBLK(st.st_mode)) {
1996 goto outc;
1997 }
1998
1999 /* Attempt to detect via a CDROM specific ioctl */
2000 ret = ioctl(fd, CDROM_DRIVE_STATUS, CDSL_CURRENT);
2001 if (ret >= 0)
2002 prio = 100;
2003
2004 outc:
2005 qemu_close(fd);
2006 out:
2007 return prio;
2008 }
2009
2010 static int cdrom_is_inserted(BlockDriverState *bs)
2011 {
2012 BDRVRawState *s = bs->opaque;
2013 int ret;
2014
2015 ret = ioctl(s->fd, CDROM_DRIVE_STATUS, CDSL_CURRENT);
2016 if (ret == CDS_DISC_OK)
2017 return 1;
2018 return 0;
2019 }
2020
2021 static void cdrom_eject(BlockDriverState *bs, bool eject_flag)
2022 {
2023 BDRVRawState *s = bs->opaque;
2024
2025 if (eject_flag) {
2026 if (ioctl(s->fd, CDROMEJECT, NULL) < 0)
2027 perror("CDROMEJECT");
2028 } else {
2029 if (ioctl(s->fd, CDROMCLOSETRAY, NULL) < 0)
2030 perror("CDROMEJECT");
2031 }
2032 }
2033
2034 static void cdrom_lock_medium(BlockDriverState *bs, bool locked)
2035 {
2036 BDRVRawState *s = bs->opaque;
2037
2038 if (ioctl(s->fd, CDROM_LOCKDOOR, locked) < 0) {
2039 /*
2040 * Note: an error can happen if the distribution automatically
2041 * mounts the CD-ROM
2042 */
2043 /* perror("CDROM_LOCKDOOR"); */
2044 }
2045 }
2046
2047 static BlockDriver bdrv_host_cdrom = {
2048 .format_name = "host_cdrom",
2049 .protocol_name = "host_cdrom",
2050 .instance_size = sizeof(BDRVRawState),
2051 .bdrv_needs_filename = true,
2052 .bdrv_probe_device = cdrom_probe_device,
2053 .bdrv_file_open = cdrom_open,
2054 .bdrv_close = raw_close,
2055 .bdrv_reopen_prepare = raw_reopen_prepare,
2056 .bdrv_reopen_commit = raw_reopen_commit,
2057 .bdrv_reopen_abort = raw_reopen_abort,
2058 .bdrv_create = hdev_create,
2059 .create_options = raw_create_options,
2060
2061 .bdrv_aio_readv = raw_aio_readv,
2062 .bdrv_aio_writev = raw_aio_writev,
2063 .bdrv_aio_flush = raw_aio_flush,
2064 .bdrv_refresh_limits = raw_refresh_limits,
2065
2066 .bdrv_truncate = raw_truncate,
2067 .bdrv_getlength = raw_getlength,
2068 .has_variable_length = true,
2069 .bdrv_get_allocated_file_size
2070 = raw_get_allocated_file_size,
2071
2072 /* removable device support */
2073 .bdrv_is_inserted = cdrom_is_inserted,
2074 .bdrv_eject = cdrom_eject,
2075 .bdrv_lock_medium = cdrom_lock_medium,
2076
2077 /* generic scsi device */
2078 .bdrv_ioctl = hdev_ioctl,
2079 .bdrv_aio_ioctl = hdev_aio_ioctl,
2080 };
2081 #endif /* __linux__ */
2082
2083 #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
2084 static int cdrom_open(BlockDriverState *bs, QDict *options, int flags,
2085 Error **errp)
2086 {
2087 BDRVRawState *s = bs->opaque;
2088 Error *local_err = NULL;
2089 int ret;
2090
2091 s->type = FTYPE_CD;
2092
2093 ret = raw_open_common(bs, options, flags, 0, &local_err);
2094 if (ret) {
2095 if (local_err) {
2096 error_propagate(errp, local_err);
2097 }
2098 return ret;
2099 }
2100
2101 /* make sure the door isn't locked at this time */
2102 ioctl(s->fd, CDIOCALLOW);
2103 return 0;
2104 }
2105
2106 static int cdrom_probe_device(const char *filename)
2107 {
2108 if (strstart(filename, "/dev/cd", NULL) ||
2109 strstart(filename, "/dev/acd", NULL))
2110 return 100;
2111 return 0;
2112 }
2113
2114 static int cdrom_reopen(BlockDriverState *bs)
2115 {
2116 BDRVRawState *s = bs->opaque;
2117 int fd;
2118
2119 /*
2120 * Force reread of possibly changed/newly loaded disc,
2121 * FreeBSD seems to not notice sometimes...
2122 */
2123 if (s->fd >= 0)
2124 qemu_close(s->fd);
2125 fd = qemu_open(bs->filename, s->open_flags, 0644);
2126 if (fd < 0) {
2127 s->fd = -1;
2128 return -EIO;
2129 }
2130 s->fd = fd;
2131
2132 /* make sure the door isn't locked at this time */
2133 ioctl(s->fd, CDIOCALLOW);
2134 return 0;
2135 }
2136
2137 static int cdrom_is_inserted(BlockDriverState *bs)
2138 {
2139 return raw_getlength(bs) > 0;
2140 }
2141
2142 static void cdrom_eject(BlockDriverState *bs, bool eject_flag)
2143 {
2144 BDRVRawState *s = bs->opaque;
2145
2146 if (s->fd < 0)
2147 return;
2148
2149 (void) ioctl(s->fd, CDIOCALLOW);
2150
2151 if (eject_flag) {
2152 if (ioctl(s->fd, CDIOCEJECT) < 0)
2153 perror("CDIOCEJECT");
2154 } else {
2155 if (ioctl(s->fd, CDIOCCLOSE) < 0)
2156 perror("CDIOCCLOSE");
2157 }
2158
2159 cdrom_reopen(bs);
2160 }
2161
2162 static void cdrom_lock_medium(BlockDriverState *bs, bool locked)
2163 {
2164 BDRVRawState *s = bs->opaque;
2165
2166 if (s->fd < 0)
2167 return;
2168 if (ioctl(s->fd, (locked ? CDIOCPREVENT : CDIOCALLOW)) < 0) {
2169 /*
2170 * Note: an error can happen if the distribution automatically
2171 * mounts the CD-ROM
2172 */
2173 /* perror("CDROM_LOCKDOOR"); */
2174 }
2175 }
2176
2177 static BlockDriver bdrv_host_cdrom = {
2178 .format_name = "host_cdrom",
2179 .protocol_name = "host_cdrom",
2180 .instance_size = sizeof(BDRVRawState),
2181 .bdrv_needs_filename = true,
2182 .bdrv_probe_device = cdrom_probe_device,
2183 .bdrv_file_open = cdrom_open,
2184 .bdrv_close = raw_close,
2185 .bdrv_reopen_prepare = raw_reopen_prepare,
2186 .bdrv_reopen_commit = raw_reopen_commit,
2187 .bdrv_reopen_abort = raw_reopen_abort,
2188 .bdrv_create = hdev_create,
2189 .create_options = raw_create_options,
2190
2191 .bdrv_aio_readv = raw_aio_readv,
2192 .bdrv_aio_writev = raw_aio_writev,
2193 .bdrv_aio_flush = raw_aio_flush,
2194 .bdrv_refresh_limits = raw_refresh_limits,
2195
2196 .bdrv_truncate = raw_truncate,
2197 .bdrv_getlength = raw_getlength,
2198 .has_variable_length = true,
2199 .bdrv_get_allocated_file_size
2200 = raw_get_allocated_file_size,
2201
2202 /* removable device support */
2203 .bdrv_is_inserted = cdrom_is_inserted,
2204 .bdrv_eject = cdrom_eject,
2205 .bdrv_lock_medium = cdrom_lock_medium,
2206 };
2207 #endif /* __FreeBSD__ */
2208
2209 #ifdef CONFIG_LINUX_AIO
2210 /**
2211 * Return the file descriptor for Linux AIO
2212 *
2213 * This function is a layering violation and should be removed when it becomes
2214 * possible to call the block layer outside the global mutex. It allows the
2215 * caller to hijack the file descriptor so I/O can be performed outside the
2216 * block layer.
2217 */
2218 int raw_get_aio_fd(BlockDriverState *bs)
2219 {
2220 BDRVRawState *s;
2221
2222 if (!bs->drv) {
2223 return -ENOMEDIUM;
2224 }
2225
2226 if (bs->drv == bdrv_find_format("raw")) {
2227 bs = bs->file;
2228 }
2229
2230 /* raw-posix has several protocols so just check for raw_aio_readv */
2231 if (bs->drv->bdrv_aio_readv != raw_aio_readv) {
2232 return -ENOTSUP;
2233 }
2234
2235 s = bs->opaque;
2236 if (!s->use_aio) {
2237 return -ENOTSUP;
2238 }
2239 return s->fd;
2240 }
2241 #endif /* CONFIG_LINUX_AIO */
2242
2243 static void bdrv_file_init(void)
2244 {
2245 /*
2246 * Register all the drivers. Note that order is important, the driver
2247 * registered last will get probed first.
2248 */
2249 bdrv_register(&bdrv_file);
2250 bdrv_register(&bdrv_host_device);
2251 #ifdef __linux__
2252 bdrv_register(&bdrv_host_floppy);
2253 bdrv_register(&bdrv_host_cdrom);
2254 #endif
2255 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
2256 bdrv_register(&bdrv_host_cdrom);
2257 #endif
2258 }
2259
2260 block_init(bdrv_file_init);
CRIS target port of Qemu