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