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
25#include "qemu/osdep.h"
26#include "qemu-common.h"
27#include "qapi/error.h"
28#include "qemu/cutils.h"
29#include "qemu/error-report.h"
30#include "block/block_int.h"
31#include "qemu/module.h"
32#include "qemu/option.h"
33#include "trace.h"
34#include "block/thread-pool.h"
35#include "qemu/iov.h"
36#include "block/raw-aio.h"
37#include "qapi/qmp/qdict.h"
38#include "qapi/qmp/qstring.h"
39
40#include "scsi/pr-manager.h"
41#include "scsi/constants.h"
42
43#if defined(__APPLE__) && (__MACH__)
44#include <paths.h>
45#include <sys/param.h>
46#include <IOKit/IOKitLib.h>
47#include <IOKit/IOBSD.h>
48#include <IOKit/storage/IOMediaBSDClient.h>
49#include <IOKit/storage/IOMedia.h>
50#include <IOKit/storage/IOCDMedia.h>
51//#include <IOKit/storage/IOCDTypes.h>
52#include <IOKit/storage/IODVDMedia.h>
53#include <CoreFoundation/CoreFoundation.h>
54#endif
55
56#ifdef __sun__
57#define _POSIX_PTHREAD_SEMANTICS 1
58#include <sys/dkio.h>
59#endif
60#ifdef __linux__
61#include <sys/ioctl.h>
62#include <sys/param.h>
63#include <sys/syscall.h>
64#include <linux/cdrom.h>
65#include <linux/fd.h>
66#include <linux/fs.h>
67#include <linux/hdreg.h>
68#include <scsi/sg.h>
69#ifdef __s390__
70#include <asm/dasd.h>
71#endif
72#ifndef FS_NOCOW_FL
73#define FS_NOCOW_FL 0x00800000 /* Do not cow file */
74#endif
75#endif
76#if defined(CONFIG_FALLOCATE_PUNCH_HOLE) || defined(CONFIG_FALLOCATE_ZERO_RANGE)
77#include <linux/falloc.h>
78#endif
79#if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
80#include <sys/disk.h>
81#include <sys/cdio.h>
82#endif
83
84#ifdef __OpenBSD__
85#include <sys/ioctl.h>
86#include <sys/disklabel.h>
87#include <sys/dkio.h>
88#endif
89
90#ifdef __NetBSD__
91#include <sys/ioctl.h>
92#include <sys/disklabel.h>
93#include <sys/dkio.h>
94#include <sys/disk.h>
95#endif
96
97#ifdef __DragonFly__
98#include <sys/ioctl.h>
99#include <sys/diskslice.h>
100#endif
101
102#ifdef CONFIG_XFS
103#include <xfs/xfs.h>
104#endif
105
106#include "trace.h"
107
108/* OS X does not have O_DSYNC */
109#ifndef O_DSYNC
110#ifdef O_SYNC
111#define O_DSYNC O_SYNC
112#elif defined(O_FSYNC)
113#define O_DSYNC O_FSYNC
114#endif
115#endif
116
117/* Approximate O_DIRECT with O_DSYNC if O_DIRECT isn't available */
118#ifndef O_DIRECT
119#define O_DIRECT O_DSYNC
120#endif
121
122#define FTYPE_FILE 0
123#define FTYPE_CD 1
124
125#define MAX_BLOCKSIZE 4096
126
127/* Posix file locking bytes. Libvirt takes byte 0, we start from higher bytes,
128 * leaving a few more bytes for its future use. */
129#define RAW_LOCK_PERM_BASE 100
130#define RAW_LOCK_SHARED_BASE 200
131
132typedef struct BDRVRawState {
133 int fd;
134 bool use_lock;
135 int type;
136 int open_flags;
137 size_t buf_align;
138
139 /* The current permissions. */
140 uint64_t perm;
141 uint64_t shared_perm;
142
143 /* The perms bits whose corresponding bytes are already locked in
144 * s->fd. */
145 uint64_t locked_perm;
146 uint64_t locked_shared_perm;
147
148 int perm_change_fd;
149 int perm_change_flags;
150 BDRVReopenState *reopen_state;
151
152#ifdef CONFIG_XFS
153 bool is_xfs:1;
154#endif
155 bool has_discard:1;
156 bool has_write_zeroes:1;
157 bool discard_zeroes:1;
158 bool use_linux_aio:1;
159 bool page_cache_inconsistent:1;
160 bool has_fallocate;
161 bool needs_alignment;
162 bool drop_cache;
163 bool check_cache_dropped;
164
165 PRManager *pr_mgr;
166} BDRVRawState;
167
168typedef struct BDRVRawReopenState {
169 int fd;
170 int open_flags;
171 bool drop_cache;
172 bool check_cache_dropped;
173} BDRVRawReopenState;
174
175static int fd_open(BlockDriverState *bs);
176static int64_t raw_getlength(BlockDriverState *bs);
177
178typedef struct RawPosixAIOData {
179 BlockDriverState *bs;
180 int aio_type;
181 int aio_fildes;
182
183 off_t aio_offset;
184 uint64_t aio_nbytes;
185
186 union {
187 struct {
188 struct iovec *iov;
189 int niov;
190 } io;
191 struct {
192 uint64_t cmd;
193 void *buf;
194 } ioctl;
195 struct {
196 int aio_fd2;
197 off_t aio_offset2;
198 } copy_range;
199 struct {
200 PreallocMode prealloc;
201 Error **errp;
202 } truncate;
203 };
204} RawPosixAIOData;
205
206#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
207static int cdrom_reopen(BlockDriverState *bs);
208#endif
209
210#if defined(__NetBSD__)
211static int raw_normalize_devicepath(const char **filename, Error **errp)
212{
213 static char namebuf[PATH_MAX];
214 const char *dp, *fname;
215 struct stat sb;
216
217 fname = *filename;
218 dp = strrchr(fname, '/');
219 if (lstat(fname, &sb) < 0) {
220 error_setg_file_open(errp, errno, fname);
221 return -errno;
222 }
223
224 if (!S_ISBLK(sb.st_mode)) {
225 return 0;
226 }
227
228 if (dp == NULL) {
229 snprintf(namebuf, PATH_MAX, "r%s", fname);
230 } else {
231 snprintf(namebuf, PATH_MAX, "%.*s/r%s",
232 (int)(dp - fname), fname, dp + 1);
233 }
234 *filename = namebuf;
235 warn_report("%s is a block device, using %s", fname, *filename);
236
237 return 0;
238}
239#else
240static int raw_normalize_devicepath(const char **filename, Error **errp)
241{
242 return 0;
243}
244#endif
245
246/*
247 * Get logical block size via ioctl. On success store it in @sector_size_p.
248 */
249static int probe_logical_blocksize(int fd, unsigned int *sector_size_p)
250{
251 unsigned int sector_size;
252 bool success = false;
253 int i;
254
255 errno = ENOTSUP;
256 static const unsigned long ioctl_list[] = {
257#ifdef BLKSSZGET
258 BLKSSZGET,
259#endif
260#ifdef DKIOCGETBLOCKSIZE
261 DKIOCGETBLOCKSIZE,
262#endif
263#ifdef DIOCGSECTORSIZE
264 DIOCGSECTORSIZE,
265#endif
266 };
267
268 /* Try a few ioctls to get the right size */
269 for (i = 0; i < (int)ARRAY_SIZE(ioctl_list); i++) {
270 if (ioctl(fd, ioctl_list[i], &sector_size) >= 0) {
271 *sector_size_p = sector_size;
272 success = true;
273 }
274 }
275
276 return success ? 0 : -errno;
277}
278
279/**
280 * Get physical block size of @fd.
281 * On success, store it in @blk_size and return 0.
282 * On failure, return -errno.
283 */
284static int probe_physical_blocksize(int fd, unsigned int *blk_size)
285{
286#ifdef BLKPBSZGET
287 if (ioctl(fd, BLKPBSZGET, blk_size) < 0) {
288 return -errno;
289 }
290 return 0;
291#else
292 return -ENOTSUP;
293#endif
294}
295
296/* Check if read is allowed with given memory buffer and length.
297 *
298 * This function is used to check O_DIRECT memory buffer and request alignment.
299 */
300static bool raw_is_io_aligned(int fd, void *buf, size_t len)
301{
302 ssize_t ret = pread(fd, buf, len, 0);
303
304 if (ret >= 0) {
305 return true;
306 }
307
308#ifdef __linux__
309 /* The Linux kernel returns EINVAL for misaligned O_DIRECT reads. Ignore
310 * other errors (e.g. real I/O error), which could happen on a failed
311 * drive, since we only care about probing alignment.
312 */
313 if (errno != EINVAL) {
314 return true;
315 }
316#endif
317
318 return false;
319}
320
321static void raw_probe_alignment(BlockDriverState *bs, int fd, Error **errp)
322{
323 BDRVRawState *s = bs->opaque;
324 char *buf;
325 size_t max_align = MAX(MAX_BLOCKSIZE, getpagesize());
326 size_t alignments[] = {1, 512, 1024, 2048, 4096};
327
328 /* For SCSI generic devices the alignment is not really used.
329 With buffered I/O, we don't have any restrictions. */
330 if (bdrv_is_sg(bs) || !s->needs_alignment) {
331 bs->bl.request_alignment = 1;
332 s->buf_align = 1;
333 return;
334 }
335
336 bs->bl.request_alignment = 0;
337 s->buf_align = 0;
338 /* Let's try to use the logical blocksize for the alignment. */
339 if (probe_logical_blocksize(fd, &bs->bl.request_alignment) < 0) {
340 bs->bl.request_alignment = 0;
341 }
342#ifdef CONFIG_XFS
343 if (s->is_xfs) {
344 struct dioattr da;
345 if (xfsctl(NULL, fd, XFS_IOC_DIOINFO, &da) >= 0) {
346 bs->bl.request_alignment = da.d_miniosz;
347 /* The kernel returns wrong information for d_mem */
348 /* s->buf_align = da.d_mem; */
349 }
350 }
351#endif
352
353 /*
354 * If we could not get the sizes so far, we can only guess them. First try
355 * to detect request alignment, since it is more likely to succeed. Then
356 * try to detect buf_align, which cannot be detected in some cases (e.g.
357 * Gluster). If buf_align cannot be detected, we fallback to the value of
358 * request_alignment.
359 */
360
361 if (!bs->bl.request_alignment) {
362 int i;
363 size_t align;
364 buf = qemu_memalign(max_align, max_align);
365 for (i = 0; i < ARRAY_SIZE(alignments); i++) {
366 align = alignments[i];
367 if (raw_is_io_aligned(fd, buf, align)) {
368 /* Fallback to safe value. */
369 bs->bl.request_alignment = (align != 1) ? align : max_align;
370 break;
371 }
372 }
373 qemu_vfree(buf);
374 }
375
376 if (!s->buf_align) {
377 int i;
378 size_t align;
379 buf = qemu_memalign(max_align, 2 * max_align);
380 for (i = 0; i < ARRAY_SIZE(alignments); i++) {
381 align = alignments[i];
382 if (raw_is_io_aligned(fd, buf + align, max_align)) {
383 /* Fallback to request_alignment. */
384 s->buf_align = (align != 1) ? align : bs->bl.request_alignment;
385 break;
386 }
387 }
388 qemu_vfree(buf);
389 }
390
391 if (!s->buf_align || !bs->bl.request_alignment) {
392 error_setg(errp, "Could not find working O_DIRECT alignment");
393 error_append_hint(errp, "Try cache.direct=off\n");
394 }
395}
396
397static void raw_parse_flags(int bdrv_flags, int *open_flags, bool has_writers)
398{
399 bool read_write = false;
400 assert(open_flags != NULL);
401
402 *open_flags |= O_BINARY;
403 *open_flags &= ~O_ACCMODE;
404
405 if (bdrv_flags & BDRV_O_AUTO_RDONLY) {
406 read_write = has_writers;
407 } else if (bdrv_flags & BDRV_O_RDWR) {
408 read_write = true;
409 }
410
411 if (read_write) {
412 *open_flags |= O_RDWR;
413 } else {
414 *open_flags |= O_RDONLY;
415 }
416
417 /* Use O_DSYNC for write-through caching, no flags for write-back caching,
418 * and O_DIRECT for no caching. */
419 if ((bdrv_flags & BDRV_O_NOCACHE)) {
420 *open_flags |= O_DIRECT;
421 }
422}
423
424static void raw_parse_filename(const char *filename, QDict *options,
425 Error **errp)
426{
427 bdrv_parse_filename_strip_prefix(filename, "file:", options);
428}
429
430static QemuOptsList raw_runtime_opts = {
431 .name = "raw",
432 .head = QTAILQ_HEAD_INITIALIZER(raw_runtime_opts.head),
433 .desc = {
434 {
435 .name = "filename",
436 .type = QEMU_OPT_STRING,
437 .help = "File name of the image",
438 },
439 {
440 .name = "aio",
441 .type = QEMU_OPT_STRING,
442 .help = "host AIO implementation (threads, native)",
443 },
444 {
445 .name = "locking",
446 .type = QEMU_OPT_STRING,
447 .help = "file locking mode (on/off/auto, default: auto)",
448 },
449 {
450 .name = "pr-manager",
451 .type = QEMU_OPT_STRING,
452 .help = "id of persistent reservation manager object (default: none)",
453 },
454#if defined(__linux__)
455 {
456 .name = "drop-cache",
457 .type = QEMU_OPT_BOOL,
458 .help = "invalidate page cache during live migration (default: on)",
459 },
460#endif
461 {
462 .name = "x-check-cache-dropped",
463 .type = QEMU_OPT_BOOL,
464 .help = "check that page cache was dropped on live migration (default: off)"
465 },
466 { /* end of list */ }
467 },
468};
469
470static const char *const mutable_opts[] = { "x-check-cache-dropped", NULL };
471
472static int raw_open_common(BlockDriverState *bs, QDict *options,
473 int bdrv_flags, int open_flags,
474 bool device, Error **errp)
475{
476 BDRVRawState *s = bs->opaque;
477 QemuOpts *opts;
478 Error *local_err = NULL;
479 const char *filename = NULL;
480 const char *str;
481 BlockdevAioOptions aio, aio_default;
482 int fd, ret;
483 struct stat st;
484 OnOffAuto locking;
485
486 opts = qemu_opts_create(&raw_runtime_opts, NULL, 0, &error_abort);
487 qemu_opts_absorb_qdict(opts, options, &local_err);
488 if (local_err) {
489 error_propagate(errp, local_err);
490 ret = -EINVAL;
491 goto fail;
492 }
493
494 filename = qemu_opt_get(opts, "filename");
495
496 ret = raw_normalize_devicepath(&filename, errp);
497 if (ret != 0) {
498 goto fail;
499 }
500
501 aio_default = (bdrv_flags & BDRV_O_NATIVE_AIO)
502 ? BLOCKDEV_AIO_OPTIONS_NATIVE
503 : BLOCKDEV_AIO_OPTIONS_THREADS;
504 aio = qapi_enum_parse(&BlockdevAioOptions_lookup,
505 qemu_opt_get(opts, "aio"),
506 aio_default, &local_err);
507 if (local_err) {
508 error_propagate(errp, local_err);
509 ret = -EINVAL;
510 goto fail;
511 }
512 s->use_linux_aio = (aio == BLOCKDEV_AIO_OPTIONS_NATIVE);
513
514 locking = qapi_enum_parse(&OnOffAuto_lookup,
515 qemu_opt_get(opts, "locking"),
516 ON_OFF_AUTO_AUTO, &local_err);
517 if (local_err) {
518 error_propagate(errp, local_err);
519 ret = -EINVAL;
520 goto fail;
521 }
522 switch (locking) {
523 case ON_OFF_AUTO_ON:
524 s->use_lock = true;
525 if (!qemu_has_ofd_lock()) {
526 warn_report("File lock requested but OFD locking syscall is "
527 "unavailable, falling back to POSIX file locks");
528 error_printf("Due to the implementation, locks can be lost "
529 "unexpectedly.\n");
530 }
531 break;
532 case ON_OFF_AUTO_OFF:
533 s->use_lock = false;
534 break;
535 case ON_OFF_AUTO_AUTO:
536 s->use_lock = qemu_has_ofd_lock();
537 break;
538 default:
539 abort();
540 }
541
542 str = qemu_opt_get(opts, "pr-manager");
543 if (str) {
544 s->pr_mgr = pr_manager_lookup(str, &local_err);
545 if (local_err) {
546 error_propagate(errp, local_err);
547 ret = -EINVAL;
548 goto fail;
549 }
550 }
551
552 s->drop_cache = qemu_opt_get_bool(opts, "drop-cache", true);
553 s->check_cache_dropped = qemu_opt_get_bool(opts, "x-check-cache-dropped",
554 false);
555
556 s->open_flags = open_flags;
557 raw_parse_flags(bdrv_flags, &s->open_flags, false);
558
559 s->fd = -1;
560 fd = qemu_open(filename, s->open_flags, 0644);
561 ret = fd < 0 ? -errno : 0;
562
563 if (ret < 0) {
564 error_setg_file_open(errp, -ret, filename);
565 if (ret == -EROFS) {
566 ret = -EACCES;
567 }
568 goto fail;
569 }
570 s->fd = fd;
571
572 s->perm = 0;
573 s->shared_perm = BLK_PERM_ALL;
574
575#ifdef CONFIG_LINUX_AIO
576 /* Currently Linux does AIO only for files opened with O_DIRECT */
577 if (s->use_linux_aio) {
578 if (!(s->open_flags & O_DIRECT)) {
579 error_setg(errp, "aio=native was specified, but it requires "
580 "cache.direct=on, which was not specified.");
581 ret = -EINVAL;
582 goto fail;
583 }
584 if (!aio_setup_linux_aio(bdrv_get_aio_context(bs), errp)) {
585 error_prepend(errp, "Unable to use native AIO: ");
586 goto fail;
587 }
588 }
589#else
590 if (s->use_linux_aio) {
591 error_setg(errp, "aio=native was specified, but is not supported "
592 "in this build.");
593 ret = -EINVAL;
594 goto fail;
595 }
596#endif /* !defined(CONFIG_LINUX_AIO) */
597
598 s->has_discard = true;
599 s->has_write_zeroes = true;
600 if ((bs->open_flags & BDRV_O_NOCACHE) != 0) {
601 s->needs_alignment = true;
602 }
603
604 if (fstat(s->fd, &st) < 0) {
605 ret = -errno;
606 error_setg_errno(errp, errno, "Could not stat file");
607 goto fail;
608 }
609
610 if (!device) {
611 if (S_ISBLK(st.st_mode)) {
612 warn_report("Opening a block device as a file using the '%s' "
613 "driver is deprecated", bs->drv->format_name);
614 } else if (S_ISCHR(st.st_mode)) {
615 warn_report("Opening a character device as a file using the '%s' "
616 "driver is deprecated", bs->drv->format_name);
617 } else if (!S_ISREG(st.st_mode)) {
618 error_setg(errp, "A regular file was expected by the '%s' driver, "
619 "but something else was given", bs->drv->format_name);
620 ret = -EINVAL;
621 goto fail;
622 } else {
623 s->discard_zeroes = true;
624 s->has_fallocate = true;
625 }
626 } else {
627 if (!(S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode))) {
628 error_setg(errp, "'%s' driver expects either "
629 "a character or block device", bs->drv->format_name);
630 ret = -EINVAL;
631 goto fail;
632 }
633 }
634
635 if (S_ISBLK(st.st_mode)) {
636#ifdef BLKDISCARDZEROES
637 unsigned int arg;
638 if (ioctl(s->fd, BLKDISCARDZEROES, &arg) == 0 && arg) {
639 s->discard_zeroes = true;
640 }
641#endif
642#ifdef __linux__
643 /* On Linux 3.10, BLKDISCARD leaves stale data in the page cache. Do
644 * not rely on the contents of discarded blocks unless using O_DIRECT.
645 * Same for BLKZEROOUT.
646 */
647 if (!(bs->open_flags & BDRV_O_NOCACHE)) {
648 s->discard_zeroes = false;
649 s->has_write_zeroes = false;
650 }
651#endif
652 }
653#ifdef __FreeBSD__
654 if (S_ISCHR(st.st_mode)) {
655 /*
656 * The file is a char device (disk), which on FreeBSD isn't behind
657 * a pager, so force all requests to be aligned. This is needed
658 * so QEMU makes sure all IO operations on the device are aligned
659 * to sector size, or else FreeBSD will reject them with EINVAL.
660 */
661 s->needs_alignment = true;
662 }
663#endif
664
665#ifdef CONFIG_XFS
666 if (platform_test_xfs_fd(s->fd)) {
667 s->is_xfs = true;
668 }
669#endif
670
671 bs->supported_zero_flags = BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK;
672 ret = 0;
673fail:
674 if (filename && (bdrv_flags & BDRV_O_TEMPORARY)) {
675 unlink(filename);
676 }
677 qemu_opts_del(opts);
678 return ret;
679}
680
681static int raw_open(BlockDriverState *bs, QDict *options, int flags,
682 Error **errp)
683{
684 BDRVRawState *s = bs->opaque;
685
686 s->type = FTYPE_FILE;
687 return raw_open_common(bs, options, flags, 0, false, errp);
688}
689
690typedef enum {
691 RAW_PL_PREPARE,
692 RAW_PL_COMMIT,
693 RAW_PL_ABORT,
694} RawPermLockOp;
695
696#define PERM_FOREACH(i) \
697 for ((i) = 0; (1ULL << (i)) <= BLK_PERM_ALL; i++)
698
699/* Lock bytes indicated by @perm_lock_bits and @shared_perm_lock_bits in the
700 * file; if @unlock == true, also unlock the unneeded bytes.
701 * @shared_perm_lock_bits is the mask of all permissions that are NOT shared.
702 */
703static int raw_apply_lock_bytes(BDRVRawState *s, int fd,
704 uint64_t perm_lock_bits,
705 uint64_t shared_perm_lock_bits,
706 bool unlock, Error **errp)
707{
708 int ret;
709 int i;
710 uint64_t locked_perm, locked_shared_perm;
711
712 if (s) {
713 locked_perm = s->locked_perm;
714 locked_shared_perm = s->locked_shared_perm;
715 } else {
716 /*
717 * We don't have the previous bits, just lock/unlock for each of the
718 * requested bits.
719 */
720 if (unlock) {
721 locked_perm = BLK_PERM_ALL;
722 locked_shared_perm = BLK_PERM_ALL;
723 } else {
724 locked_perm = 0;
725 locked_shared_perm = 0;
726 }
727 }
728
729 PERM_FOREACH(i) {
730 int off = RAW_LOCK_PERM_BASE + i;
731 uint64_t bit = (1ULL << i);
732 if ((perm_lock_bits & bit) && !(locked_perm & bit)) {
733 ret = qemu_lock_fd(fd, off, 1, false);
734 if (ret) {
735 error_setg(errp, "Failed to lock byte %d", off);
736 return ret;
737 } else if (s) {
738 s->locked_perm |= bit;
739 }
740 } else if (unlock && (locked_perm & bit) && !(perm_lock_bits & bit)) {
741 ret = qemu_unlock_fd(fd, off, 1);
742 if (ret) {
743 error_setg(errp, "Failed to unlock byte %d", off);
744 return ret;
745 } else if (s) {
746 s->locked_perm &= ~bit;
747 }
748 }
749 }
750 PERM_FOREACH(i) {
751 int off = RAW_LOCK_SHARED_BASE + i;
752 uint64_t bit = (1ULL << i);
753 if ((shared_perm_lock_bits & bit) && !(locked_shared_perm & bit)) {
754 ret = qemu_lock_fd(fd, off, 1, false);
755 if (ret) {
756 error_setg(errp, "Failed to lock byte %d", off);
757 return ret;
758 } else if (s) {
759 s->locked_shared_perm |= bit;
760 }
761 } else if (unlock && (locked_shared_perm & bit) &&
762 !(shared_perm_lock_bits & bit)) {
763 ret = qemu_unlock_fd(fd, off, 1);
764 if (ret) {
765 error_setg(errp, "Failed to unlock byte %d", off);
766 return ret;
767 } else if (s) {
768 s->locked_shared_perm &= ~bit;
769 }
770 }
771 }
772 return 0;
773}
774
775/* Check "unshared" bytes implied by @perm and ~@shared_perm in the file. */
776static int raw_check_lock_bytes(int fd, uint64_t perm, uint64_t shared_perm,
777 Error **errp)
778{
779 int ret;
780 int i;
781
782 PERM_FOREACH(i) {
783 int off = RAW_LOCK_SHARED_BASE + i;
784 uint64_t p = 1ULL << i;
785 if (perm & p) {
786 ret = qemu_lock_fd_test(fd, off, 1, true);
787 if (ret) {
788 char *perm_name = bdrv_perm_names(p);
789 error_setg(errp,
790 "Failed to get \"%s\" lock",
791 perm_name);
792 g_free(perm_name);
793 return ret;
794 }
795 }
796 }
797 PERM_FOREACH(i) {
798 int off = RAW_LOCK_PERM_BASE + i;
799 uint64_t p = 1ULL << i;
800 if (!(shared_perm & p)) {
801 ret = qemu_lock_fd_test(fd, off, 1, true);
802 if (ret) {
803 char *perm_name = bdrv_perm_names(p);
804 error_setg(errp,
805 "Failed to get shared \"%s\" lock",
806 perm_name);
807 g_free(perm_name);
808 return ret;
809 }
810 }
811 }
812 return 0;
813}
814
815static int raw_handle_perm_lock(BlockDriverState *bs,
816 RawPermLockOp op,
817 uint64_t new_perm, uint64_t new_shared,
818 Error **errp)
819{
820 BDRVRawState *s = bs->opaque;
821 int ret = 0;
822 Error *local_err = NULL;
823
824 if (!s->use_lock) {
825 return 0;
826 }
827
828 if (bdrv_get_flags(bs) & BDRV_O_INACTIVE) {
829 return 0;
830 }
831
832 switch (op) {
833 case RAW_PL_PREPARE:
834 if ((s->perm | new_perm) == s->perm &&
835 (s->shared_perm & new_shared) == s->shared_perm)
836 {
837 /*
838 * We are going to unlock bytes, it should not fail. If it fail due
839 * to some fs-dependent permission-unrelated reasons (which occurs
840 * sometimes on NFS and leads to abort in bdrv_replace_child) we
841 * can't prevent such errors by any check here. And we ignore them
842 * anyway in ABORT and COMMIT.
843 */
844 return 0;
845 }
846 ret = raw_apply_lock_bytes(s, s->fd, s->perm | new_perm,
847 ~s->shared_perm | ~new_shared,
848 false, errp);
849 if (!ret) {
850 ret = raw_check_lock_bytes(s->fd, new_perm, new_shared, errp);
851 if (!ret) {
852 return 0;
853 }
854 error_append_hint(errp,
855 "Is another process using the image [%s]?\n",
856 bs->filename);
857 }
858 op = RAW_PL_ABORT;
859 /* fall through to unlock bytes. */
860 case RAW_PL_ABORT:
861 raw_apply_lock_bytes(s, s->fd, s->perm, ~s->shared_perm,
862 true, &local_err);
863 if (local_err) {
864 /* Theoretically the above call only unlocks bytes and it cannot
865 * fail. Something weird happened, report it.
866 */
867 warn_report_err(local_err);
868 }
869 break;
870 case RAW_PL_COMMIT:
871 raw_apply_lock_bytes(s, s->fd, new_perm, ~new_shared,
872 true, &local_err);
873 if (local_err) {
874 /* Theoretically the above call only unlocks bytes and it cannot
875 * fail. Something weird happened, report it.
876 */
877 warn_report_err(local_err);
878 }
879 break;
880 }
881 return ret;
882}
883
884static int raw_reconfigure_getfd(BlockDriverState *bs, int flags,
885 int *open_flags, uint64_t perm, bool force_dup,
886 Error **errp)
887{
888 BDRVRawState *s = bs->opaque;
889 int fd = -1;
890 int ret;
891 bool has_writers = perm &
892 (BLK_PERM_WRITE | BLK_PERM_WRITE_UNCHANGED | BLK_PERM_RESIZE);
893 int fcntl_flags = O_APPEND | O_NONBLOCK;
894#ifdef O_NOATIME
895 fcntl_flags |= O_NOATIME;
896#endif
897
898 *open_flags = 0;
899 if (s->type == FTYPE_CD) {
900 *open_flags |= O_NONBLOCK;
901 }
902
903 raw_parse_flags(flags, open_flags, has_writers);
904
905#ifdef O_ASYNC
906 /* Not all operating systems have O_ASYNC, and those that don't
907 * will not let us track the state into rs->open_flags (typically
908 * you achieve the same effect with an ioctl, for example I_SETSIG
909 * on Solaris). But we do not use O_ASYNC, so that's fine.
910 */
911 assert((s->open_flags & O_ASYNC) == 0);
912#endif
913
914 if (!force_dup && *open_flags == s->open_flags) {
915 /* We're lucky, the existing fd is fine */
916 return s->fd;
917 }
918
919 if ((*open_flags & ~fcntl_flags) == (s->open_flags & ~fcntl_flags)) {
920 /* dup the original fd */
921 fd = qemu_dup(s->fd);
922 if (fd >= 0) {
923 ret = fcntl_setfl(fd, *open_flags);
924 if (ret) {
925 qemu_close(fd);
926 fd = -1;
927 }
928 }
929 }
930
931 /* If we cannot use fcntl, or fcntl failed, fall back to qemu_open() */
932 if (fd == -1) {
933 const char *normalized_filename = bs->filename;
934 ret = raw_normalize_devicepath(&normalized_filename, errp);
935 if (ret >= 0) {
936 assert(!(*open_flags & O_CREAT));
937 fd = qemu_open(normalized_filename, *open_flags);
938 if (fd == -1) {
939 error_setg_errno(errp, errno, "Could not reopen file");
940 return -1;
941 }
942 }
943 }
944
945 return fd;
946}
947
948static int raw_reopen_prepare(BDRVReopenState *state,
949 BlockReopenQueue *queue, Error **errp)
950{
951 BDRVRawState *s;
952 BDRVRawReopenState *rs;
953 QemuOpts *opts;
954 int ret;
955 Error *local_err = NULL;
956
957 assert(state != NULL);
958 assert(state->bs != NULL);
959
960 s = state->bs->opaque;
961
962 state->opaque = g_new0(BDRVRawReopenState, 1);
963 rs = state->opaque;
964
965 /* Handle options changes */
966 opts = qemu_opts_create(&raw_runtime_opts, NULL, 0, &error_abort);
967 qemu_opts_absorb_qdict(opts, state->options, &local_err);
968 if (local_err) {
969 error_propagate(errp, local_err);
970 ret = -EINVAL;
971 goto out;
972 }
973
974 rs->drop_cache = qemu_opt_get_bool_del(opts, "drop-cache", true);
975 rs->check_cache_dropped =
976 qemu_opt_get_bool_del(opts, "x-check-cache-dropped", false);
977
978 /* This driver's reopen function doesn't currently allow changing
979 * other options, so let's put them back in the original QDict and
980 * bdrv_reopen_prepare() will detect changes and complain. */
981 qemu_opts_to_qdict(opts, state->options);
982
983 rs->fd = raw_reconfigure_getfd(state->bs, state->flags, &rs->open_flags,
984 state->perm, true, &local_err);
985 if (local_err) {
986 error_propagate(errp, local_err);
987 ret = -1;
988 goto out;
989 }
990
991 /* Fail already reopen_prepare() if we can't get a working O_DIRECT
992 * alignment with the new fd. */
993 if (rs->fd != -1) {
994 raw_probe_alignment(state->bs, rs->fd, &local_err);
995 if (local_err) {
996 error_propagate(errp, local_err);
997 ret = -EINVAL;
998 goto out_fd;
999 }
1000 }
1001
1002 s->reopen_state = state;
1003 ret = 0;
1004out_fd:
1005 if (ret < 0) {
1006 qemu_close(rs->fd);
1007 rs->fd = -1;
1008 }
1009out:
1010 qemu_opts_del(opts);
1011 return ret;
1012}
1013
1014static void raw_reopen_commit(BDRVReopenState *state)
1015{
1016 BDRVRawReopenState *rs = state->opaque;
1017 BDRVRawState *s = state->bs->opaque;
1018
1019 s->drop_cache = rs->drop_cache;
1020 s->check_cache_dropped = rs->check_cache_dropped;
1021 s->open_flags = rs->open_flags;
1022
1023 qemu_close(s->fd);
1024 s->fd = rs->fd;
1025
1026 g_free(state->opaque);
1027 state->opaque = NULL;
1028
1029 assert(s->reopen_state == state);
1030 s->reopen_state = NULL;
1031}
1032
1033
1034static void raw_reopen_abort(BDRVReopenState *state)
1035{
1036 BDRVRawReopenState *rs = state->opaque;
1037 BDRVRawState *s = state->bs->opaque;
1038
1039 /* nothing to do if NULL, we didn't get far enough */
1040 if (rs == NULL) {
1041 return;
1042 }
1043
1044 if (rs->fd >= 0) {
1045 qemu_close(rs->fd);
1046 rs->fd = -1;
1047 }
1048 g_free(state->opaque);
1049 state->opaque = NULL;
1050
1051 assert(s->reopen_state == state);
1052 s->reopen_state = NULL;
1053}
1054
1055static int sg_get_max_transfer_length(int fd)
1056{
1057#ifdef BLKSECTGET
1058 int max_bytes = 0;
1059
1060 if (ioctl(fd, BLKSECTGET, &max_bytes) == 0) {
1061 return max_bytes;
1062 } else {
1063 return -errno;
1064 }
1065#else
1066 return -ENOSYS;
1067#endif
1068}
1069
1070static int sg_get_max_segments(int fd)
1071{
1072#ifdef CONFIG_LINUX
1073 char buf[32];
1074 const char *end;
1075 char *sysfspath = NULL;
1076 int ret;
1077 int sysfd = -1;
1078 long max_segments;
1079 struct stat st;
1080
1081 if (fstat(fd, &st)) {
1082 ret = -errno;
1083 goto out;
1084 }
1085
1086 sysfspath = g_strdup_printf("/sys/dev/block/%u:%u/queue/max_segments",
1087 major(st.st_rdev), minor(st.st_rdev));
1088 sysfd = open(sysfspath, O_RDONLY);
1089 if (sysfd == -1) {
1090 ret = -errno;
1091 goto out;
1092 }
1093 do {
1094 ret = read(sysfd, buf, sizeof(buf) - 1);
1095 } while (ret == -1 && errno == EINTR);
1096 if (ret < 0) {
1097 ret = -errno;
1098 goto out;
1099 } else if (ret == 0) {
1100 ret = -EIO;
1101 goto out;
1102 }
1103 buf[ret] = 0;
1104 /* The file is ended with '\n', pass 'end' to accept that. */
1105 ret = qemu_strtol(buf, &end, 10, &max_segments);
1106 if (ret == 0 && end && *end == '\n') {
1107 ret = max_segments;
1108 }
1109
1110out:
1111 if (sysfd != -1) {
1112 close(sysfd);
1113 }
1114 g_free(sysfspath);
1115 return ret;
1116#else
1117 return -ENOTSUP;
1118#endif
1119}
1120
1121static void raw_refresh_limits(BlockDriverState *bs, Error **errp)
1122{
1123 BDRVRawState *s = bs->opaque;
1124
1125 if (bs->sg) {
1126 int ret = sg_get_max_transfer_length(s->fd);
1127
1128 if (ret > 0 && ret <= BDRV_REQUEST_MAX_BYTES) {
1129 bs->bl.max_transfer = pow2floor(ret);
1130 }
1131
1132 ret = sg_get_max_segments(s->fd);
1133 if (ret > 0) {
1134 bs->bl.max_transfer = MIN(bs->bl.max_transfer, ret * getpagesize());
1135 }
1136 }
1137
1138 raw_probe_alignment(bs, s->fd, errp);
1139 bs->bl.min_mem_alignment = s->buf_align;
1140 bs->bl.opt_mem_alignment = MAX(s->buf_align, getpagesize());
1141}
1142
1143static int check_for_dasd(int fd)
1144{
1145#ifdef BIODASDINFO2
1146 struct dasd_information2_t info = {0};
1147
1148 return ioctl(fd, BIODASDINFO2, &info);
1149#else
1150 return -1;
1151#endif
1152}
1153
1154/**
1155 * Try to get @bs's logical and physical block size.
1156 * On success, store them in @bsz and return zero.
1157 * On failure, return negative errno.
1158 */
1159static int hdev_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz)
1160{
1161 BDRVRawState *s = bs->opaque;
1162 int ret;
1163
1164 /* If DASD, get blocksizes */
1165 if (check_for_dasd(s->fd) < 0) {
1166 return -ENOTSUP;
1167 }
1168 ret = probe_logical_blocksize(s->fd, &bsz->log);
1169 if (ret < 0) {
1170 return ret;
1171 }
1172 return probe_physical_blocksize(s->fd, &bsz->phys);
1173}
1174
1175/**
1176 * Try to get @bs's geometry: cyls, heads, sectors.
1177 * On success, store them in @geo and return 0.
1178 * On failure return -errno.
1179 * (Allows block driver to assign default geometry values that guest sees)
1180 */
1181#ifdef __linux__
1182static int hdev_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
1183{
1184 BDRVRawState *s = bs->opaque;
1185 struct hd_geometry ioctl_geo = {0};
1186
1187 /* If DASD, get its geometry */
1188 if (check_for_dasd(s->fd) < 0) {
1189 return -ENOTSUP;
1190 }
1191 if (ioctl(s->fd, HDIO_GETGEO, &ioctl_geo) < 0) {
1192 return -errno;
1193 }
1194 /* HDIO_GETGEO may return success even though geo contains zeros
1195 (e.g. certain multipath setups) */
1196 if (!ioctl_geo.heads || !ioctl_geo.sectors || !ioctl_geo.cylinders) {
1197 return -ENOTSUP;
1198 }
1199 /* Do not return a geometry for partition */
1200 if (ioctl_geo.start != 0) {
1201 return -ENOTSUP;
1202 }
1203 geo->heads = ioctl_geo.heads;
1204 geo->sectors = ioctl_geo.sectors;
1205 geo->cylinders = ioctl_geo.cylinders;
1206
1207 return 0;
1208}
1209#else /* __linux__ */
1210static int hdev_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
1211{
1212 return -ENOTSUP;
1213}
1214#endif
1215
1216#if defined(__linux__)
1217static int handle_aiocb_ioctl(void *opaque)
1218{
1219 RawPosixAIOData *aiocb = opaque;
1220 int ret;
1221
1222 ret = ioctl(aiocb->aio_fildes, aiocb->ioctl.cmd, aiocb->ioctl.buf);
1223 if (ret == -1) {
1224 return -errno;
1225 }
1226
1227 return 0;
1228}
1229#endif /* linux */
1230
1231static int handle_aiocb_flush(void *opaque)
1232{
1233 RawPosixAIOData *aiocb = opaque;
1234 BDRVRawState *s = aiocb->bs->opaque;
1235 int ret;
1236
1237 if (s->page_cache_inconsistent) {
1238 return -EIO;
1239 }
1240
1241 ret = qemu_fdatasync(aiocb->aio_fildes);
1242 if (ret == -1) {
1243 /* There is no clear definition of the semantics of a failing fsync(),
1244 * so we may have to assume the worst. The sad truth is that this
1245 * assumption is correct for Linux. Some pages are now probably marked
1246 * clean in the page cache even though they are inconsistent with the
1247 * on-disk contents. The next fdatasync() call would succeed, but no
1248 * further writeback attempt will be made. We can't get back to a state
1249 * in which we know what is on disk (we would have to rewrite
1250 * everything that was touched since the last fdatasync() at least), so
1251 * make bdrv_flush() fail permanently. Given that the behaviour isn't
1252 * really defined, I have little hope that other OSes are doing better.
1253 *
1254 * Obviously, this doesn't affect O_DIRECT, which bypasses the page
1255 * cache. */
1256 if ((s->open_flags & O_DIRECT) == 0) {
1257 s->page_cache_inconsistent = true;
1258 }
1259 return -errno;
1260 }
1261 return 0;
1262}
1263
1264#ifdef CONFIG_PREADV
1265
1266static bool preadv_present = true;
1267
1268static ssize_t
1269qemu_preadv(int fd, const struct iovec *iov, int nr_iov, off_t offset)
1270{
1271 return preadv(fd, iov, nr_iov, offset);
1272}
1273
1274static ssize_t
1275qemu_pwritev(int fd, const struct iovec *iov, int nr_iov, off_t offset)
1276{
1277 return pwritev(fd, iov, nr_iov, offset);
1278}
1279
1280#else
1281
1282static bool preadv_present = false;
1283
1284static ssize_t
1285qemu_preadv(int fd, const struct iovec *iov, int nr_iov, off_t offset)
1286{
1287 return -ENOSYS;
1288}
1289
1290static ssize_t
1291qemu_pwritev(int fd, const struct iovec *iov, int nr_iov, off_t offset)
1292{
1293 return -ENOSYS;
1294}
1295
1296#endif
1297
1298static ssize_t handle_aiocb_rw_vector(RawPosixAIOData *aiocb)
1299{
1300 ssize_t len;
1301
1302 do {
1303 if (aiocb->aio_type & QEMU_AIO_WRITE)
1304 len = qemu_pwritev(aiocb->aio_fildes,
1305 aiocb->io.iov,
1306 aiocb->io.niov,
1307 aiocb->aio_offset);
1308 else
1309 len = qemu_preadv(aiocb->aio_fildes,
1310 aiocb->io.iov,
1311 aiocb->io.niov,
1312 aiocb->aio_offset);
1313 } while (len == -1 && errno == EINTR);
1314
1315 if (len == -1) {
1316 return -errno;
1317 }
1318 return len;
1319}
1320
1321/*
1322 * Read/writes the data to/from a given linear buffer.
1323 *
1324 * Returns the number of bytes handles or -errno in case of an error. Short
1325 * reads are only returned if the end of the file is reached.
1326 */
1327static ssize_t handle_aiocb_rw_linear(RawPosixAIOData *aiocb, char *buf)
1328{
1329 ssize_t offset = 0;
1330 ssize_t len;
1331
1332 while (offset < aiocb->aio_nbytes) {
1333 if (aiocb->aio_type & QEMU_AIO_WRITE) {
1334 len = pwrite(aiocb->aio_fildes,
1335 (const char *)buf + offset,
1336 aiocb->aio_nbytes - offset,
1337 aiocb->aio_offset + offset);
1338 } else {
1339 len = pread(aiocb->aio_fildes,
1340 buf + offset,
1341 aiocb->aio_nbytes - offset,
1342 aiocb->aio_offset + offset);
1343 }
1344 if (len == -1 && errno == EINTR) {
1345 continue;
1346 } else if (len == -1 && errno == EINVAL &&
1347 (aiocb->bs->open_flags & BDRV_O_NOCACHE) &&
1348 !(aiocb->aio_type & QEMU_AIO_WRITE) &&
1349 offset > 0) {
1350 /* O_DIRECT pread() may fail with EINVAL when offset is unaligned
1351 * after a short read. Assume that O_DIRECT short reads only occur
1352 * at EOF. Therefore this is a short read, not an I/O error.
1353 */
1354 break;
1355 } else if (len == -1) {
1356 offset = -errno;
1357 break;
1358 } else if (len == 0) {
1359 break;
1360 }
1361 offset += len;
1362 }
1363
1364 return offset;
1365}
1366
1367static int handle_aiocb_rw(void *opaque)
1368{
1369 RawPosixAIOData *aiocb = opaque;
1370 ssize_t nbytes;
1371 char *buf;
1372
1373 if (!(aiocb->aio_type & QEMU_AIO_MISALIGNED)) {
1374 /*
1375 * If there is just a single buffer, and it is properly aligned
1376 * we can just use plain pread/pwrite without any problems.
1377 */
1378 if (aiocb->io.niov == 1) {
1379 nbytes = handle_aiocb_rw_linear(aiocb, aiocb->io.iov->iov_base);
1380 goto out;
1381 }
1382 /*
1383 * We have more than one iovec, and all are properly aligned.
1384 *
1385 * Try preadv/pwritev first and fall back to linearizing the
1386 * buffer if it's not supported.
1387 */
1388 if (preadv_present) {
1389 nbytes = handle_aiocb_rw_vector(aiocb);
1390 if (nbytes == aiocb->aio_nbytes ||
1391 (nbytes < 0 && nbytes != -ENOSYS)) {
1392 goto out;
1393 }
1394 preadv_present = false;
1395 }
1396
1397 /*
1398 * XXX(hch): short read/write. no easy way to handle the reminder
1399 * using these interfaces. For now retry using plain
1400 * pread/pwrite?
1401 */
1402 }
1403
1404 /*
1405 * Ok, we have to do it the hard way, copy all segments into
1406 * a single aligned buffer.
1407 */
1408 buf = qemu_try_blockalign(aiocb->bs, aiocb->aio_nbytes);
1409 if (buf == NULL) {
1410 nbytes = -ENOMEM;
1411 goto out;
1412 }
1413
1414 if (aiocb->aio_type & QEMU_AIO_WRITE) {
1415 char *p = buf;
1416 int i;
1417
1418 for (i = 0; i < aiocb->io.niov; ++i) {
1419 memcpy(p, aiocb->io.iov[i].iov_base, aiocb->io.iov[i].iov_len);
1420 p += aiocb->io.iov[i].iov_len;
1421 }
1422 assert(p - buf == aiocb->aio_nbytes);
1423 }
1424
1425 nbytes = handle_aiocb_rw_linear(aiocb, buf);
1426 if (!(aiocb->aio_type & QEMU_AIO_WRITE)) {
1427 char *p = buf;
1428 size_t count = aiocb->aio_nbytes, copy;
1429 int i;
1430
1431 for (i = 0; i < aiocb->io.niov && count; ++i) {
1432 copy = count;
1433 if (copy > aiocb->io.iov[i].iov_len) {
1434 copy = aiocb->io.iov[i].iov_len;
1435 }
1436 memcpy(aiocb->io.iov[i].iov_base, p, copy);
1437 assert(count >= copy);
1438 p += copy;
1439 count -= copy;
1440 }
1441 assert(count == 0);
1442 }
1443 qemu_vfree(buf);
1444
1445out:
1446 if (nbytes == aiocb->aio_nbytes) {
1447 return 0;
1448 } else if (nbytes >= 0 && nbytes < aiocb->aio_nbytes) {
1449 if (aiocb->aio_type & QEMU_AIO_WRITE) {
1450 return -EINVAL;
1451 } else {
1452 iov_memset(aiocb->io.iov, aiocb->io.niov, nbytes,
1453 0, aiocb->aio_nbytes - nbytes);
1454 return 0;
1455 }
1456 } else {
1457 assert(nbytes < 0);
1458 return nbytes;
1459 }
1460}
1461
1462#ifdef CONFIG_XFS
1463static int xfs_write_zeroes(BDRVRawState *s, int64_t offset, uint64_t bytes)
1464{
1465 int64_t len;
1466 struct xfs_flock64 fl;
1467 int err;
1468
1469 len = lseek(s->fd, 0, SEEK_END);
1470 if (len < 0) {
1471 return -errno;
1472 }
1473
1474 if (offset + bytes > len) {
1475 /* XFS_IOC_ZERO_RANGE does not increase the file length */
1476 if (ftruncate(s->fd, offset + bytes) < 0) {
1477 return -errno;
1478 }
1479 }
1480
1481 memset(&fl, 0, sizeof(fl));
1482 fl.l_whence = SEEK_SET;
1483 fl.l_start = offset;
1484 fl.l_len = bytes;
1485
1486 if (xfsctl(NULL, s->fd, XFS_IOC_ZERO_RANGE, &fl) < 0) {
1487 err = errno;
1488 trace_file_xfs_write_zeroes(strerror(errno));
1489 return -err;
1490 }
1491
1492 return 0;
1493}
1494
1495static int xfs_discard(BDRVRawState *s, int64_t offset, uint64_t bytes)
1496{
1497 struct xfs_flock64 fl;
1498 int err;
1499
1500 memset(&fl, 0, sizeof(fl));
1501 fl.l_whence = SEEK_SET;
1502 fl.l_start = offset;
1503 fl.l_len = bytes;
1504
1505 if (xfsctl(NULL, s->fd, XFS_IOC_UNRESVSP64, &fl) < 0) {
1506 err = errno;
1507 trace_file_xfs_discard(strerror(errno));
1508 return -err;
1509 }
1510
1511 return 0;
1512}
1513#endif
1514
1515static int translate_err(int err)
1516{
1517 if (err == -ENODEV || err == -ENOSYS || err == -EOPNOTSUPP ||
1518 err == -ENOTTY) {
1519 err = -ENOTSUP;
1520 }
1521 return err;
1522}
1523
1524#ifdef CONFIG_FALLOCATE
1525static int do_fallocate(int fd, int mode, off_t offset, off_t len)
1526{
1527 do {
1528 if (fallocate(fd, mode, offset, len) == 0) {
1529 return 0;
1530 }
1531 } while (errno == EINTR);
1532 return translate_err(-errno);
1533}
1534#endif
1535
1536static ssize_t handle_aiocb_write_zeroes_block(RawPosixAIOData *aiocb)
1537{
1538 int ret = -ENOTSUP;
1539 BDRVRawState *s = aiocb->bs->opaque;
1540
1541 if (!s->has_write_zeroes) {
1542 return -ENOTSUP;
1543 }
1544
1545#ifdef BLKZEROOUT
1546 /* The BLKZEROOUT implementation in the kernel doesn't set
1547 * BLKDEV_ZERO_NOFALLBACK, so we can't call this if we have to avoid slow
1548 * fallbacks. */
1549 if (!(aiocb->aio_type & QEMU_AIO_NO_FALLBACK)) {
1550 do {
1551 uint64_t range[2] = { aiocb->aio_offset, aiocb->aio_nbytes };
1552 if (ioctl(aiocb->aio_fildes, BLKZEROOUT, range) == 0) {
1553 return 0;
1554 }
1555 } while (errno == EINTR);
1556
1557 ret = translate_err(-errno);
1558 }
1559#endif
1560
1561 if (ret == -ENOTSUP) {
1562 s->has_write_zeroes = false;
1563 }
1564 return ret;
1565}
1566
1567static int handle_aiocb_write_zeroes(void *opaque)
1568{
1569 RawPosixAIOData *aiocb = opaque;
1570#if defined(CONFIG_FALLOCATE) || defined(CONFIG_XFS)
1571 BDRVRawState *s = aiocb->bs->opaque;
1572#endif
1573#ifdef CONFIG_FALLOCATE
1574 int64_t len;
1575#endif
1576
1577 if (aiocb->aio_type & QEMU_AIO_BLKDEV) {
1578 return handle_aiocb_write_zeroes_block(aiocb);
1579 }
1580
1581#ifdef CONFIG_XFS
1582 if (s->is_xfs) {
1583 return xfs_write_zeroes(s, aiocb->aio_offset, aiocb->aio_nbytes);
1584 }
1585#endif
1586
1587#ifdef CONFIG_FALLOCATE_ZERO_RANGE
1588 if (s->has_write_zeroes) {
1589 int ret = do_fallocate(s->fd, FALLOC_FL_ZERO_RANGE,
1590 aiocb->aio_offset, aiocb->aio_nbytes);
1591 if (ret == 0 || ret != -ENOTSUP) {
1592 return ret;
1593 }
1594 s->has_write_zeroes = false;
1595 }
1596#endif
1597
1598#ifdef CONFIG_FALLOCATE_PUNCH_HOLE
1599 if (s->has_discard && s->has_fallocate) {
1600 int ret = do_fallocate(s->fd,
1601 FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE,
1602 aiocb->aio_offset, aiocb->aio_nbytes);
1603 if (ret == 0) {
1604 ret = do_fallocate(s->fd, 0, aiocb->aio_offset, aiocb->aio_nbytes);
1605 if (ret == 0 || ret != -ENOTSUP) {
1606 return ret;
1607 }
1608 s->has_fallocate = false;
1609 } else if (ret != -ENOTSUP) {
1610 return ret;
1611 } else {
1612 s->has_discard = false;
1613 }
1614 }
1615#endif
1616
1617#ifdef CONFIG_FALLOCATE
1618 /* Last resort: we are trying to extend the file with zeroed data. This
1619 * can be done via fallocate(fd, 0) */
1620 len = bdrv_getlength(aiocb->bs);
1621 if (s->has_fallocate && len >= 0 && aiocb->aio_offset >= len) {
1622 int ret = do_fallocate(s->fd, 0, aiocb->aio_offset, aiocb->aio_nbytes);
1623 if (ret == 0 || ret != -ENOTSUP) {
1624 return ret;
1625 }
1626 s->has_fallocate = false;
1627 }
1628#endif
1629
1630 return -ENOTSUP;
1631}
1632
1633static int handle_aiocb_write_zeroes_unmap(void *opaque)
1634{
1635 RawPosixAIOData *aiocb = opaque;
1636 BDRVRawState *s G_GNUC_UNUSED = aiocb->bs->opaque;
1637 int ret;
1638
1639 /* First try to write zeros and unmap at the same time */
1640
1641#ifdef CONFIG_FALLOCATE_PUNCH_HOLE
1642 ret = do_fallocate(s->fd, FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE,
1643 aiocb->aio_offset, aiocb->aio_nbytes);
1644 if (ret != -ENOTSUP) {
1645 return ret;
1646 }
1647#endif
1648
1649#ifdef CONFIG_XFS
1650 if (s->is_xfs) {
1651 /* xfs_discard() guarantees that the discarded area reads as all-zero
1652 * afterwards, so we can use it here. */
1653 return xfs_discard(s, aiocb->aio_offset, aiocb->aio_nbytes);
1654 }
1655#endif
1656
1657 /* If we couldn't manage to unmap while guaranteed that the area reads as
1658 * all-zero afterwards, just write zeroes without unmapping */
1659 ret = handle_aiocb_write_zeroes(aiocb);
1660 return ret;
1661}
1662
1663#ifndef HAVE_COPY_FILE_RANGE
1664static off_t copy_file_range(int in_fd, off_t *in_off, int out_fd,
1665 off_t *out_off, size_t len, unsigned int flags)
1666{
1667#ifdef __NR_copy_file_range
1668 return syscall(__NR_copy_file_range, in_fd, in_off, out_fd,
1669 out_off, len, flags);
1670#else
1671 errno = ENOSYS;
1672 return -1;
1673#endif
1674}
1675#endif
1676
1677static int handle_aiocb_copy_range(void *opaque)
1678{
1679 RawPosixAIOData *aiocb = opaque;
1680 uint64_t bytes = aiocb->aio_nbytes;
1681 off_t in_off = aiocb->aio_offset;
1682 off_t out_off = aiocb->copy_range.aio_offset2;
1683
1684 while (bytes) {
1685 ssize_t ret = copy_file_range(aiocb->aio_fildes, &in_off,
1686 aiocb->copy_range.aio_fd2, &out_off,
1687 bytes, 0);
1688 trace_file_copy_file_range(aiocb->bs, aiocb->aio_fildes, in_off,
1689 aiocb->copy_range.aio_fd2, out_off, bytes,
1690 0, ret);
1691 if (ret == 0) {
1692 /* No progress (e.g. when beyond EOF), let the caller fall back to
1693 * buffer I/O. */
1694 return -ENOSPC;
1695 }
1696 if (ret < 0) {
1697 switch (errno) {
1698 case ENOSYS:
1699 return -ENOTSUP;
1700 case EINTR:
1701 continue;
1702 default:
1703 return -errno;
1704 }
1705 }
1706 bytes -= ret;
1707 }
1708 return 0;
1709}
1710
1711static int handle_aiocb_discard(void *opaque)
1712{
1713 RawPosixAIOData *aiocb = opaque;
1714 int ret = -EOPNOTSUPP;
1715 BDRVRawState *s = aiocb->bs->opaque;
1716
1717 if (!s->has_discard) {
1718 return -ENOTSUP;
1719 }
1720
1721 if (aiocb->aio_type & QEMU_AIO_BLKDEV) {
1722#ifdef BLKDISCARD
1723 do {
1724 uint64_t range[2] = { aiocb->aio_offset, aiocb->aio_nbytes };
1725 if (ioctl(aiocb->aio_fildes, BLKDISCARD, range) == 0) {
1726 return 0;
1727 }
1728 } while (errno == EINTR);
1729
1730 ret = -errno;
1731#endif
1732 } else {
1733#ifdef CONFIG_XFS
1734 if (s->is_xfs) {
1735 return xfs_discard(s, aiocb->aio_offset, aiocb->aio_nbytes);
1736 }
1737#endif
1738
1739#ifdef CONFIG_FALLOCATE_PUNCH_HOLE
1740 ret = do_fallocate(s->fd, FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE,
1741 aiocb->aio_offset, aiocb->aio_nbytes);
1742#endif
1743 }
1744
1745 ret = translate_err(ret);
1746 if (ret == -ENOTSUP) {
1747 s->has_discard = false;
1748 }
1749 return ret;
1750}
1751
1752/*
1753 * Help alignment probing by allocating the first block.
1754 *
1755 * When reading with direct I/O from unallocated area on Gluster backed by XFS,
1756 * reading succeeds regardless of request length. In this case we fallback to
1757 * safe alignment which is not optimal. Allocating the first block avoids this
1758 * fallback.
1759 *
1760 * fd may be opened with O_DIRECT, but we don't know the buffer alignment or
1761 * request alignment, so we use safe values.
1762 *
1763 * Returns: 0 on success, -errno on failure. Since this is an optimization,
1764 * caller may ignore failures.
1765 */
1766static int allocate_first_block(int fd, size_t max_size)
1767{
1768 size_t write_size = (max_size < MAX_BLOCKSIZE)
1769 ? BDRV_SECTOR_SIZE
1770 : MAX_BLOCKSIZE;
1771 size_t max_align = MAX(MAX_BLOCKSIZE, getpagesize());
1772 void *buf;
1773 ssize_t n;
1774 int ret;
1775
1776 buf = qemu_memalign(max_align, write_size);
1777 memset(buf, 0, write_size);
1778
1779 do {
1780 n = pwrite(fd, buf, write_size, 0);
1781 } while (n == -1 && errno == EINTR);
1782
1783 ret = (n == -1) ? -errno : 0;
1784
1785 qemu_vfree(buf);
1786 return ret;
1787}
1788
1789static int handle_aiocb_truncate(void *opaque)
1790{
1791 RawPosixAIOData *aiocb = opaque;
1792 int result = 0;
1793 int64_t current_length = 0;
1794 char *buf = NULL;
1795 struct stat st;
1796 int fd = aiocb->aio_fildes;
1797 int64_t offset = aiocb->aio_offset;
1798 PreallocMode prealloc = aiocb->truncate.prealloc;
1799 Error **errp = aiocb->truncate.errp;
1800
1801 if (fstat(fd, &st) < 0) {
1802 result = -errno;
1803 error_setg_errno(errp, -result, "Could not stat file");
1804 return result;
1805 }
1806
1807 current_length = st.st_size;
1808 if (current_length > offset && prealloc != PREALLOC_MODE_OFF) {
1809 error_setg(errp, "Cannot use preallocation for shrinking files");
1810 return -ENOTSUP;
1811 }
1812
1813 switch (prealloc) {
1814#ifdef CONFIG_POSIX_FALLOCATE
1815 case PREALLOC_MODE_FALLOC:
1816 /*
1817 * Truncating before posix_fallocate() makes it about twice slower on
1818 * file systems that do not support fallocate(), trying to check if a
1819 * block is allocated before allocating it, so don't do that here.
1820 */
1821 if (offset != current_length) {
1822 result = -posix_fallocate(fd, current_length,
1823 offset - current_length);
1824 if (result != 0) {
1825 /* posix_fallocate() doesn't set errno. */
1826 error_setg_errno(errp, -result,
1827 "Could not preallocate new data");
1828 } else if (current_length == 0) {
1829 /*
1830 * posix_fallocate() uses fallocate() if the filesystem
1831 * supports it, or fallback to manually writing zeroes. If
1832 * fallocate() was used, unaligned reads from the fallocated
1833 * area in raw_probe_alignment() will succeed, hence we need to
1834 * allocate the first block.
1835 *
1836 * Optimize future alignment probing; ignore failures.
1837 */
1838 allocate_first_block(fd, offset);
1839 }
1840 } else {
1841 result = 0;
1842 }
1843 goto out;
1844#endif
1845 case PREALLOC_MODE_FULL:
1846 {
1847 int64_t num = 0, left = offset - current_length;
1848 off_t seek_result;
1849
1850 /*
1851 * Knowing the final size from the beginning could allow the file
1852 * system driver to do less allocations and possibly avoid
1853 * fragmentation of the file.
1854 */
1855 if (ftruncate(fd, offset) != 0) {
1856 result = -errno;
1857 error_setg_errno(errp, -result, "Could not resize file");
1858 goto out;
1859 }
1860
1861 buf = g_malloc0(65536);
1862
1863 seek_result = lseek(fd, current_length, SEEK_SET);
1864 if (seek_result < 0) {
1865 result = -errno;
1866 error_setg_errno(errp, -result,
1867 "Failed to seek to the old end of file");
1868 goto out;
1869 }
1870
1871 while (left > 0) {
1872 num = MIN(left, 65536);
1873 result = write(fd, buf, num);
1874 if (result < 0) {
1875 if (errno == EINTR) {
1876 continue;
1877 }
1878 result = -errno;
1879 error_setg_errno(errp, -result,
1880 "Could not write zeros for preallocation");
1881 goto out;
1882 }
1883 left -= result;
1884 }
1885 if (result >= 0) {
1886 result = fsync(fd);
1887 if (result < 0) {
1888 result = -errno;
1889 error_setg_errno(errp, -result,
1890 "Could not flush file to disk");
1891 goto out;
1892 }
1893 }
1894 goto out;
1895 }
1896 case PREALLOC_MODE_OFF:
1897 if (ftruncate(fd, offset) != 0) {
1898 result = -errno;
1899 error_setg_errno(errp, -result, "Could not resize file");
1900 } else if (current_length == 0 && offset > current_length) {
1901 /* Optimize future alignment probing; ignore failures. */
1902 allocate_first_block(fd, offset);
1903 }
1904 return result;
1905 default:
1906 result = -ENOTSUP;
1907 error_setg(errp, "Unsupported preallocation mode: %s",
1908 PreallocMode_str(prealloc));
1909 return result;
1910 }
1911
1912out:
1913 if (result < 0) {
1914 if (ftruncate(fd, current_length) < 0) {
1915 error_report("Failed to restore old file length: %s",
1916 strerror(errno));
1917 }
1918 }
1919
1920 g_free(buf);
1921 return result;
1922}
1923
1924static int coroutine_fn raw_thread_pool_submit(BlockDriverState *bs,
1925 ThreadPoolFunc func, void *arg)
1926{
1927 /* @bs can be NULL, bdrv_get_aio_context() returns the main context then */
1928 ThreadPool *pool = aio_get_thread_pool(bdrv_get_aio_context(bs));
1929 return thread_pool_submit_co(pool, func, arg);
1930}
1931
1932static int coroutine_fn raw_co_prw(BlockDriverState *bs, uint64_t offset,
1933 uint64_t bytes, QEMUIOVector *qiov, int type)
1934{
1935 BDRVRawState *s = bs->opaque;
1936 RawPosixAIOData acb;
1937
1938 if (fd_open(bs) < 0)
1939 return -EIO;
1940
1941 /*
1942 * Check if the underlying device requires requests to be aligned,
1943 * and if the request we are trying to submit is aligned or not.
1944 * If this is the case tell the low-level driver that it needs
1945 * to copy the buffer.
1946 */
1947 if (s->needs_alignment) {
1948 if (!bdrv_qiov_is_aligned(bs, qiov)) {
1949 type |= QEMU_AIO_MISALIGNED;
1950#ifdef CONFIG_LINUX_AIO
1951 } else if (s->use_linux_aio) {
1952 LinuxAioState *aio = aio_get_linux_aio(bdrv_get_aio_context(bs));
1953 assert(qiov->size == bytes);
1954 return laio_co_submit(bs, aio, s->fd, offset, qiov, type);
1955#endif
1956 }
1957 }
1958
1959 acb = (RawPosixAIOData) {
1960 .bs = bs,
1961 .aio_fildes = s->fd,
1962 .aio_type = type,
1963 .aio_offset = offset,
1964 .aio_nbytes = bytes,
1965 .io = {
1966 .iov = qiov->iov,
1967 .niov = qiov->niov,
1968 },
1969 };
1970
1971 assert(qiov->size == bytes);
1972 return raw_thread_pool_submit(bs, handle_aiocb_rw, &acb);
1973}
1974
1975static int coroutine_fn raw_co_preadv(BlockDriverState *bs, uint64_t offset,
1976 uint64_t bytes, QEMUIOVector *qiov,
1977 int flags)
1978{
1979 return raw_co_prw(bs, offset, bytes, qiov, QEMU_AIO_READ);
1980}
1981
1982static int coroutine_fn raw_co_pwritev(BlockDriverState *bs, uint64_t offset,
1983 uint64_t bytes, QEMUIOVector *qiov,
1984 int flags)
1985{
1986 assert(flags == 0);
1987 return raw_co_prw(bs, offset, bytes, qiov, QEMU_AIO_WRITE);
1988}
1989
1990static void raw_aio_plug(BlockDriverState *bs)
1991{
1992#ifdef CONFIG_LINUX_AIO
1993 BDRVRawState *s = bs->opaque;
1994 if (s->use_linux_aio) {
1995 LinuxAioState *aio = aio_get_linux_aio(bdrv_get_aio_context(bs));
1996 laio_io_plug(bs, aio);
1997 }
1998#endif
1999}
2000
2001static void raw_aio_unplug(BlockDriverState *bs)
2002{
2003#ifdef CONFIG_LINUX_AIO
2004 BDRVRawState *s = bs->opaque;
2005 if (s->use_linux_aio) {
2006 LinuxAioState *aio = aio_get_linux_aio(bdrv_get_aio_context(bs));
2007 laio_io_unplug(bs, aio);
2008 }
2009#endif
2010}
2011
2012static int raw_co_flush_to_disk(BlockDriverState *bs)
2013{
2014 BDRVRawState *s = bs->opaque;
2015 RawPosixAIOData acb;
2016 int ret;
2017
2018 ret = fd_open(bs);
2019 if (ret < 0) {
2020 return ret;
2021 }
2022
2023 acb = (RawPosixAIOData) {
2024 .bs = bs,
2025 .aio_fildes = s->fd,
2026 .aio_type = QEMU_AIO_FLUSH,
2027 };
2028
2029 return raw_thread_pool_submit(bs, handle_aiocb_flush, &acb);
2030}
2031
2032static void raw_aio_attach_aio_context(BlockDriverState *bs,
2033 AioContext *new_context)
2034{
2035#ifdef CONFIG_LINUX_AIO
2036 BDRVRawState *s = bs->opaque;
2037 if (s->use_linux_aio) {
2038 Error *local_err;
2039 if (!aio_setup_linux_aio(new_context, &local_err)) {
2040 error_reportf_err(local_err, "Unable to use native AIO, "
2041 "falling back to thread pool: ");
2042 s->use_linux_aio = false;
2043 }
2044 }
2045#endif
2046}
2047
2048static void raw_close(BlockDriverState *bs)
2049{
2050 BDRVRawState *s = bs->opaque;
2051
2052 if (s->fd >= 0) {
2053 qemu_close(s->fd);
2054 s->fd = -1;
2055 }
2056}
2057
2058/**
2059 * Truncates the given regular file @fd to @offset and, when growing, fills the
2060 * new space according to @prealloc.
2061 *
2062 * Returns: 0 on success, -errno on failure.
2063 */
2064static int coroutine_fn
2065raw_regular_truncate(BlockDriverState *bs, int fd, int64_t offset,
2066 PreallocMode prealloc, Error **errp)
2067{
2068 RawPosixAIOData acb;
2069
2070 acb = (RawPosixAIOData) {
2071 .bs = bs,
2072 .aio_fildes = fd,
2073 .aio_type = QEMU_AIO_TRUNCATE,
2074 .aio_offset = offset,
2075 .truncate = {
2076 .prealloc = prealloc,
2077 .errp = errp,
2078 },
2079 };
2080
2081 return raw_thread_pool_submit(bs, handle_aiocb_truncate, &acb);
2082}
2083
2084static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,
2085 PreallocMode prealloc, Error **errp)
2086{
2087 BDRVRawState *s = bs->opaque;
2088 struct stat st;
2089 int ret;
2090
2091 if (fstat(s->fd, &st)) {
2092 ret = -errno;
2093 error_setg_errno(errp, -ret, "Failed to fstat() the file");
2094 return ret;
2095 }
2096
2097 if (S_ISREG(st.st_mode)) {
2098 return raw_regular_truncate(bs, s->fd, offset, prealloc, errp);
2099 }
2100
2101 if (prealloc != PREALLOC_MODE_OFF) {
2102 error_setg(errp, "Preallocation mode '%s' unsupported for this "
2103 "non-regular file", PreallocMode_str(prealloc));
2104 return -ENOTSUP;
2105 }
2106
2107 if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) {
2108 if (offset > raw_getlength(bs)) {
2109 error_setg(errp, "Cannot grow device files");
2110 return -EINVAL;
2111 }
2112 } else {
2113 error_setg(errp, "Resizing this file is not supported");
2114 return -ENOTSUP;
2115 }
2116
2117 return 0;
2118}
2119
2120#ifdef __OpenBSD__
2121static int64_t raw_getlength(BlockDriverState *bs)
2122{
2123 BDRVRawState *s = bs->opaque;
2124 int fd = s->fd;
2125 struct stat st;
2126
2127 if (fstat(fd, &st))
2128 return -errno;
2129 if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) {
2130 struct disklabel dl;
2131
2132 if (ioctl(fd, DIOCGDINFO, &dl))
2133 return -errno;
2134 return (uint64_t)dl.d_secsize *
2135 dl.d_partitions[DISKPART(st.st_rdev)].p_size;
2136 } else
2137 return st.st_size;
2138}
2139#elif defined(__NetBSD__)
2140static int64_t raw_getlength(BlockDriverState *bs)
2141{
2142 BDRVRawState *s = bs->opaque;
2143 int fd = s->fd;
2144 struct stat st;
2145
2146 if (fstat(fd, &st))
2147 return -errno;
2148 if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) {
2149 struct dkwedge_info dkw;
2150
2151 if (ioctl(fd, DIOCGWEDGEINFO, &dkw) != -1) {
2152 return dkw.dkw_size * 512;
2153 } else {
2154 struct disklabel dl;
2155
2156 if (ioctl(fd, DIOCGDINFO, &dl))
2157 return -errno;
2158 return (uint64_t)dl.d_secsize *
2159 dl.d_partitions[DISKPART(st.st_rdev)].p_size;
2160 }
2161 } else
2162 return st.st_size;
2163}
2164#elif defined(__sun__)
2165static int64_t raw_getlength(BlockDriverState *bs)
2166{
2167 BDRVRawState *s = bs->opaque;
2168 struct dk_minfo minfo;
2169 int ret;
2170 int64_t size;
2171
2172 ret = fd_open(bs);
2173 if (ret < 0) {
2174 return ret;
2175 }
2176
2177 /*
2178 * Use the DKIOCGMEDIAINFO ioctl to read the size.
2179 */
2180 ret = ioctl(s->fd, DKIOCGMEDIAINFO, &minfo);
2181 if (ret != -1) {
2182 return minfo.dki_lbsize * minfo.dki_capacity;
2183 }
2184
2185 /*
2186 * There are reports that lseek on some devices fails, but
2187 * irc discussion said that contingency on contingency was overkill.
2188 */
2189 size = lseek(s->fd, 0, SEEK_END);
2190 if (size < 0) {
2191 return -errno;
2192 }
2193 return size;
2194}
2195#elif defined(CONFIG_BSD)
2196static int64_t raw_getlength(BlockDriverState *bs)
2197{
2198 BDRVRawState *s = bs->opaque;
2199 int fd = s->fd;
2200 int64_t size;
2201 struct stat sb;
2202#if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
2203 int reopened = 0;
2204#endif
2205 int ret;
2206
2207 ret = fd_open(bs);
2208 if (ret < 0)
2209 return ret;
2210
2211#if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
2212again:
2213#endif
2214 if (!fstat(fd, &sb) && (S_IFCHR & sb.st_mode)) {
2215#ifdef DIOCGMEDIASIZE
2216 if (ioctl(fd, DIOCGMEDIASIZE, (off_t *)&size))
2217#elif defined(DIOCGPART)
2218 {
2219 struct partinfo pi;
2220 if (ioctl(fd, DIOCGPART, &pi) == 0)
2221 size = pi.media_size;
2222 else
2223 size = 0;
2224 }
2225 if (size == 0)
2226#endif
2227#if defined(__APPLE__) && defined(__MACH__)
2228 {
2229 uint64_t sectors = 0;
2230 uint32_t sector_size = 0;
2231
2232 if (ioctl(fd, DKIOCGETBLOCKCOUNT, &sectors) == 0
2233 && ioctl(fd, DKIOCGETBLOCKSIZE, &sector_size) == 0) {
2234 size = sectors * sector_size;
2235 } else {
2236 size = lseek(fd, 0LL, SEEK_END);
2237 if (size < 0) {
2238 return -errno;
2239 }
2240 }
2241 }
2242#else
2243 size = lseek(fd, 0LL, SEEK_END);
2244 if (size < 0) {
2245 return -errno;
2246 }
2247#endif
2248#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
2249 switch(s->type) {
2250 case FTYPE_CD:
2251 /* XXX FreeBSD acd returns UINT_MAX sectors for an empty drive */
2252 if (size == 2048LL * (unsigned)-1)
2253 size = 0;
2254 /* XXX no disc? maybe we need to reopen... */
2255 if (size <= 0 && !reopened && cdrom_reopen(bs) >= 0) {
2256 reopened = 1;
2257 goto again;
2258 }
2259 }
2260#endif
2261 } else {
2262 size = lseek(fd, 0, SEEK_END);
2263 if (size < 0) {
2264 return -errno;
2265 }
2266 }
2267 return size;
2268}
2269#else
2270static int64_t raw_getlength(BlockDriverState *bs)
2271{
2272 BDRVRawState *s = bs->opaque;
2273 int ret;
2274 int64_t size;
2275
2276 ret = fd_open(bs);
2277 if (ret < 0) {
2278 return ret;
2279 }
2280
2281 size = lseek(s->fd, 0, SEEK_END);
2282 if (size < 0) {
2283 return -errno;
2284 }
2285 return size;
2286}
2287#endif
2288
2289static int64_t raw_get_allocated_file_size(BlockDriverState *bs)
2290{
2291 struct stat st;
2292 BDRVRawState *s = bs->opaque;
2293
2294 if (fstat(s->fd, &st) < 0) {
2295 return -errno;
2296 }
2297 return (int64_t)st.st_blocks * 512;
2298}
2299
2300static int coroutine_fn
2301raw_co_create(BlockdevCreateOptions *options, Error **errp)
2302{
2303 BlockdevCreateOptionsFile *file_opts;
2304 Error *local_err = NULL;
2305 int fd;
2306 uint64_t perm, shared;
2307 int result = 0;
2308
2309 /* Validate options and set default values */
2310 assert(options->driver == BLOCKDEV_DRIVER_FILE);
2311 file_opts = &options->u.file;
2312
2313 if (!file_opts->has_nocow) {
2314 file_opts->nocow = false;
2315 }
2316 if (!file_opts->has_preallocation) {
2317 file_opts->preallocation = PREALLOC_MODE_OFF;
2318 }
2319
2320 /* Create file */
2321 fd = qemu_open(file_opts->filename, O_RDWR | O_CREAT | O_BINARY, 0644);
2322 if (fd < 0) {
2323 result = -errno;
2324 error_setg_errno(errp, -result, "Could not create file");
2325 goto out;
2326 }
2327
2328 /* Take permissions: We want to discard everything, so we need
2329 * BLK_PERM_WRITE; and truncation to the desired size requires
2330 * BLK_PERM_RESIZE.
2331 * On the other hand, we cannot share the RESIZE permission
2332 * because we promise that after this function, the file has the
2333 * size given in the options. If someone else were to resize it
2334 * concurrently, we could not guarantee that.
2335 * Note that after this function, we can no longer guarantee that
2336 * the file is not touched by a third party, so it may be resized
2337 * then. */
2338 perm = BLK_PERM_WRITE | BLK_PERM_RESIZE;
2339 shared = BLK_PERM_ALL & ~BLK_PERM_RESIZE;
2340
2341 /* Step one: Take locks */
2342 result = raw_apply_lock_bytes(NULL, fd, perm, ~shared, false, errp);
2343 if (result < 0) {
2344 goto out_close;
2345 }
2346
2347 /* Step two: Check that nobody else has taken conflicting locks */
2348 result = raw_check_lock_bytes(fd, perm, shared, errp);
2349 if (result < 0) {
2350 error_append_hint(errp,
2351 "Is another process using the image [%s]?\n",
2352 file_opts->filename);
2353 goto out_unlock;
2354 }
2355
2356 /* Clear the file by truncating it to 0 */
2357 result = raw_regular_truncate(NULL, fd, 0, PREALLOC_MODE_OFF, errp);
2358 if (result < 0) {
2359 goto out_unlock;
2360 }
2361
2362 if (file_opts->nocow) {
2363#ifdef __linux__
2364 /* Set NOCOW flag to solve performance issue on fs like btrfs.
2365 * This is an optimisation. The FS_IOC_SETFLAGS ioctl return value
2366 * will be ignored since any failure of this operation should not
2367 * block the left work.
2368 */
2369 int attr;
2370 if (ioctl(fd, FS_IOC_GETFLAGS, &attr) == 0) {
2371 attr |= FS_NOCOW_FL;
2372 ioctl(fd, FS_IOC_SETFLAGS, &attr);
2373 }
2374#endif
2375 }
2376
2377 /* Resize and potentially preallocate the file to the desired
2378 * final size */
2379 result = raw_regular_truncate(NULL, fd, file_opts->size,
2380 file_opts->preallocation, errp);
2381 if (result < 0) {
2382 goto out_unlock;
2383 }
2384
2385out_unlock:
2386 raw_apply_lock_bytes(NULL, fd, 0, 0, true, &local_err);
2387 if (local_err) {
2388 /* The above call should not fail, and if it does, that does
2389 * not mean the whole creation operation has failed. So
2390 * report it the user for their convenience, but do not report
2391 * it to the caller. */
2392 warn_report_err(local_err);
2393 }
2394
2395out_close:
2396 if (qemu_close(fd) != 0 && result == 0) {
2397 result = -errno;
2398 error_setg_errno(errp, -result, "Could not close the new file");
2399 }
2400out:
2401 return result;
2402}
2403
2404static int coroutine_fn raw_co_create_opts(const char *filename, QemuOpts *opts,
2405 Error **errp)
2406{
2407 BlockdevCreateOptions options;
2408 int64_t total_size = 0;
2409 bool nocow = false;
2410 PreallocMode prealloc;
2411 char *buf = NULL;
2412 Error *local_err = NULL;
2413
2414 /* Skip file: protocol prefix */
2415 strstart(filename, "file:", &filename);
2416
2417 /* Read out options */
2418 total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
2419 BDRV_SECTOR_SIZE);
2420 nocow = qemu_opt_get_bool(opts, BLOCK_OPT_NOCOW, false);
2421 buf = qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC);
2422 prealloc = qapi_enum_parse(&PreallocMode_lookup, buf,
2423 PREALLOC_MODE_OFF, &local_err);
2424 g_free(buf);
2425 if (local_err) {
2426 error_propagate(errp, local_err);
2427 return -EINVAL;
2428 }
2429
2430 options = (BlockdevCreateOptions) {
2431 .driver = BLOCKDEV_DRIVER_FILE,
2432 .u.file = {
2433 .filename = (char *) filename,
2434 .size = total_size,
2435 .has_preallocation = true,
2436 .preallocation = prealloc,
2437 .has_nocow = true,
2438 .nocow = nocow,
2439 },
2440 };
2441 return raw_co_create(&options, errp);
2442}
2443
2444/*
2445 * Find allocation range in @bs around offset @start.
2446 * May change underlying file descriptor's file offset.
2447 * If @start is not in a hole, store @start in @data, and the
2448 * beginning of the next hole in @hole, and return 0.
2449 * If @start is in a non-trailing hole, store @start in @hole and the
2450 * beginning of the next non-hole in @data, and return 0.
2451 * If @start is in a trailing hole or beyond EOF, return -ENXIO.
2452 * If we can't find out, return a negative errno other than -ENXIO.
2453 */
2454static int find_allocation(BlockDriverState *bs, off_t start,
2455 off_t *data, off_t *hole)
2456{
2457#if defined SEEK_HOLE && defined SEEK_DATA
2458 BDRVRawState *s = bs->opaque;
2459 off_t offs;
2460
2461 /*
2462 * SEEK_DATA cases:
2463 * D1. offs == start: start is in data
2464 * D2. offs > start: start is in a hole, next data at offs
2465 * D3. offs < 0, errno = ENXIO: either start is in a trailing hole
2466 * or start is beyond EOF
2467 * If the latter happens, the file has been truncated behind
2468 * our back since we opened it. All bets are off then.
2469 * Treating like a trailing hole is simplest.
2470 * D4. offs < 0, errno != ENXIO: we learned nothing
2471 */
2472 offs = lseek(s->fd, start, SEEK_DATA);
2473 if (offs < 0) {
2474 return -errno; /* D3 or D4 */
2475 }
2476
2477 if (offs < start) {
2478 /* This is not a valid return by lseek(). We are safe to just return
2479 * -EIO in this case, and we'll treat it like D4. */
2480 return -EIO;
2481 }
2482
2483 if (offs > start) {
2484 /* D2: in hole, next data at offs */
2485 *hole = start;
2486 *data = offs;
2487 return 0;
2488 }
2489
2490 /* D1: in data, end not yet known */
2491
2492 /*
2493 * SEEK_HOLE cases:
2494 * H1. offs == start: start is in a hole
2495 * If this happens here, a hole has been dug behind our back
2496 * since the previous lseek().
2497 * H2. offs > start: either start is in data, next hole at offs,
2498 * or start is in trailing hole, EOF at offs
2499 * Linux treats trailing holes like any other hole: offs ==
2500 * start. Solaris seeks to EOF instead: offs > start (blech).
2501 * If that happens here, a hole has been dug behind our back
2502 * since the previous lseek().
2503 * H3. offs < 0, errno = ENXIO: start is beyond EOF
2504 * If this happens, the file has been truncated behind our
2505 * back since we opened it. Treat it like a trailing hole.
2506 * H4. offs < 0, errno != ENXIO: we learned nothing
2507 * Pretend we know nothing at all, i.e. "forget" about D1.
2508 */
2509 offs = lseek(s->fd, start, SEEK_HOLE);
2510 if (offs < 0) {
2511 return -errno; /* D1 and (H3 or H4) */
2512 }
2513
2514 if (offs < start) {
2515 /* This is not a valid return by lseek(). We are safe to just return
2516 * -EIO in this case, and we'll treat it like H4. */
2517 return -EIO;
2518 }
2519
2520 if (offs > start) {
2521 /*
2522 * D1 and H2: either in data, next hole at offs, or it was in
2523 * data but is now in a trailing hole. In the latter case,
2524 * all bets are off. Treating it as if it there was data all
2525 * the way to EOF is safe, so simply do that.
2526 */
2527 *data = start;
2528 *hole = offs;
2529 return 0;
2530 }
2531
2532 /* D1 and H1 */
2533 return -EBUSY;
2534#else
2535 return -ENOTSUP;
2536#endif
2537}
2538
2539/*
2540 * Returns the allocation status of the specified offset.
2541 *
2542 * The block layer guarantees 'offset' and 'bytes' are within bounds.
2543 *
2544 * 'pnum' is set to the number of bytes (including and immediately following
2545 * the specified offset) that are known to be in the same
2546 * allocated/unallocated state.
2547 *
2548 * 'bytes' is the max value 'pnum' should be set to.
2549 */
2550static int coroutine_fn raw_co_block_status(BlockDriverState *bs,
2551 bool want_zero,
2552 int64_t offset,
2553 int64_t bytes, int64_t *pnum,
2554 int64_t *map,
2555 BlockDriverState **file)
2556{
2557 off_t data = 0, hole = 0;
2558 int ret;
2559
2560 assert(QEMU_IS_ALIGNED(offset | bytes, bs->bl.request_alignment));
2561
2562 ret = fd_open(bs);
2563 if (ret < 0) {
2564 return ret;
2565 }
2566
2567 if (!want_zero) {
2568 *pnum = bytes;
2569 *map = offset;
2570 *file = bs;
2571 return BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID;
2572 }
2573
2574 ret = find_allocation(bs, offset, &data, &hole);
2575 if (ret == -ENXIO) {
2576 /* Trailing hole */
2577 *pnum = bytes;
2578 ret = BDRV_BLOCK_ZERO;
2579 } else if (ret < 0) {
2580 /* No info available, so pretend there are no holes */
2581 *pnum = bytes;
2582 ret = BDRV_BLOCK_DATA;
2583 } else if (data == offset) {
2584 /* On a data extent, compute bytes to the end of the extent,
2585 * possibly including a partial sector at EOF. */
2586 *pnum = MIN(bytes, hole - offset);
2587
2588 /*
2589 * We are not allowed to return partial sectors, though, so
2590 * round up if necessary.
2591 */
2592 if (!QEMU_IS_ALIGNED(*pnum, bs->bl.request_alignment)) {
2593 int64_t file_length = raw_getlength(bs);
2594 if (file_length > 0) {
2595 /* Ignore errors, this is just a safeguard */
2596 assert(hole == file_length);
2597 }
2598 *pnum = ROUND_UP(*pnum, bs->bl.request_alignment);
2599 }
2600
2601 ret = BDRV_BLOCK_DATA;
2602 } else {
2603 /* On a hole, compute bytes to the beginning of the next extent. */
2604 assert(hole == offset);
2605 *pnum = MIN(bytes, data - offset);
2606 ret = BDRV_BLOCK_ZERO;
2607 }
2608 *map = offset;
2609 *file = bs;
2610 return ret | BDRV_BLOCK_OFFSET_VALID;
2611}
2612
2613#if defined(__linux__)
2614/* Verify that the file is not in the page cache */
2615static void check_cache_dropped(BlockDriverState *bs, Error **errp)
2616{
2617 const size_t window_size = 128 * 1024 * 1024;
2618 BDRVRawState *s = bs->opaque;
2619 void *window = NULL;
2620 size_t length = 0;
2621 unsigned char *vec;
2622 size_t page_size;
2623 off_t offset;
2624 off_t end;
2625
2626 /* mincore(2) page status information requires 1 byte per page */
2627 page_size = sysconf(_SC_PAGESIZE);
2628 vec = g_malloc(DIV_ROUND_UP(window_size, page_size));
2629
2630 end = raw_getlength(bs);
2631
2632 for (offset = 0; offset < end; offset += window_size) {
2633 void *new_window;
2634 size_t new_length;
2635 size_t vec_end;
2636 size_t i;
2637 int ret;
2638
2639 /* Unmap previous window if size has changed */
2640 new_length = MIN(end - offset, window_size);
2641 if (new_length != length) {
2642 munmap(window, length);
2643 window = NULL;
2644 length = 0;
2645 }
2646
2647 new_window = mmap(window, new_length, PROT_NONE, MAP_PRIVATE,
2648 s->fd, offset);
2649 if (new_window == MAP_FAILED) {
2650 error_setg_errno(errp, errno, "mmap failed");
2651 break;
2652 }
2653
2654 window = new_window;
2655 length = new_length;
2656
2657 ret = mincore(window, length, vec);
2658 if (ret < 0) {
2659 error_setg_errno(errp, errno, "mincore failed");
2660 break;
2661 }
2662
2663 vec_end = DIV_ROUND_UP(length, page_size);
2664 for (i = 0; i < vec_end; i++) {
2665 if (vec[i] & 0x1) {
2666 error_setg(errp, "page cache still in use!");
2667 break;
2668 }
2669 }
2670 }
2671
2672 if (window) {
2673 munmap(window, length);
2674 }
2675
2676 g_free(vec);
2677}
2678#endif /* __linux__ */
2679
2680static void coroutine_fn raw_co_invalidate_cache(BlockDriverState *bs,
2681 Error **errp)
2682{
2683 BDRVRawState *s = bs->opaque;
2684 int ret;
2685
2686 ret = fd_open(bs);
2687 if (ret < 0) {
2688 error_setg_errno(errp, -ret, "The file descriptor is not open");
2689 return;
2690 }
2691
2692 if (!s->drop_cache) {
2693 return;
2694 }
2695
2696 if (s->open_flags & O_DIRECT) {
2697 return; /* No host kernel page cache */
2698 }
2699
2700#if defined(__linux__)
2701 /* This sets the scene for the next syscall... */
2702 ret = bdrv_co_flush(bs);
2703 if (ret < 0) {
2704 error_setg_errno(errp, -ret, "flush failed");
2705 return;
2706 }
2707
2708 /* Linux does not invalidate pages that are dirty, locked, or mmapped by a
2709 * process. These limitations are okay because we just fsynced the file,
2710 * we don't use mmap, and the file should not be in use by other processes.
2711 */
2712 ret = posix_fadvise(s->fd, 0, 0, POSIX_FADV_DONTNEED);
2713 if (ret != 0) { /* the return value is a positive errno */
2714 error_setg_errno(errp, ret, "fadvise failed");
2715 return;
2716 }
2717
2718 if (s->check_cache_dropped) {
2719 check_cache_dropped(bs, errp);
2720 }
2721#else /* __linux__ */
2722 /* Do nothing. Live migration to a remote host with cache.direct=off is
2723 * unsupported on other host operating systems. Cache consistency issues
2724 * may occur but no error is reported here, partly because that's the
2725 * historical behavior and partly because it's hard to differentiate valid
2726 * configurations that should not cause errors.
2727 */
2728#endif /* !__linux__ */
2729}
2730
2731static coroutine_fn int
2732raw_do_pdiscard(BlockDriverState *bs, int64_t offset, int bytes, bool blkdev)
2733{
2734 BDRVRawState *s = bs->opaque;
2735 RawPosixAIOData acb;
2736
2737 acb = (RawPosixAIOData) {
2738 .bs = bs,
2739 .aio_fildes = s->fd,
2740 .aio_type = QEMU_AIO_DISCARD,
2741 .aio_offset = offset,
2742 .aio_nbytes = bytes,
2743 };
2744
2745 if (blkdev) {
2746 acb.aio_type |= QEMU_AIO_BLKDEV;
2747 }
2748
2749 return raw_thread_pool_submit(bs, handle_aiocb_discard, &acb);
2750}
2751
2752static coroutine_fn int
2753raw_co_pdiscard(BlockDriverState *bs, int64_t offset, int bytes)
2754{
2755 return raw_do_pdiscard(bs, offset, bytes, false);
2756}
2757
2758static int coroutine_fn
2759raw_do_pwrite_zeroes(BlockDriverState *bs, int64_t offset, int bytes,
2760 BdrvRequestFlags flags, bool blkdev)
2761{
2762 BDRVRawState *s = bs->opaque;
2763 RawPosixAIOData acb;
2764 ThreadPoolFunc *handler;
2765
2766 acb = (RawPosixAIOData) {
2767 .bs = bs,
2768 .aio_fildes = s->fd,
2769 .aio_type = QEMU_AIO_WRITE_ZEROES,
2770 .aio_offset = offset,
2771 .aio_nbytes = bytes,
2772 };
2773
2774 if (blkdev) {
2775 acb.aio_type |= QEMU_AIO_BLKDEV;
2776 }
2777 if (flags & BDRV_REQ_NO_FALLBACK) {
2778 acb.aio_type |= QEMU_AIO_NO_FALLBACK;
2779 }
2780
2781 if (flags & BDRV_REQ_MAY_UNMAP) {
2782 acb.aio_type |= QEMU_AIO_DISCARD;
2783 handler = handle_aiocb_write_zeroes_unmap;
2784 } else {
2785 handler = handle_aiocb_write_zeroes;
2786 }
2787
2788 return raw_thread_pool_submit(bs, handler, &acb);
2789}
2790
2791static int coroutine_fn raw_co_pwrite_zeroes(
2792 BlockDriverState *bs, int64_t offset,
2793 int bytes, BdrvRequestFlags flags)
2794{
2795 return raw_do_pwrite_zeroes(bs, offset, bytes, flags, false);
2796}
2797
2798static int raw_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
2799{
2800 BDRVRawState *s = bs->opaque;
2801
2802 bdi->unallocated_blocks_are_zero = s->discard_zeroes;
2803 return 0;
2804}
2805
2806static QemuOptsList raw_create_opts = {
2807 .name = "raw-create-opts",
2808 .head = QTAILQ_HEAD_INITIALIZER(raw_create_opts.head),
2809 .desc = {
2810 {
2811 .name = BLOCK_OPT_SIZE,
2812 .type = QEMU_OPT_SIZE,
2813 .help = "Virtual disk size"
2814 },
2815 {
2816 .name = BLOCK_OPT_NOCOW,
2817 .type = QEMU_OPT_BOOL,
2818 .help = "Turn off copy-on-write (valid only on btrfs)"
2819 },
2820 {
2821 .name = BLOCK_OPT_PREALLOC,
2822 .type = QEMU_OPT_STRING,
2823 .help = "Preallocation mode (allowed values: off"
2824#ifdef CONFIG_POSIX_FALLOCATE
2825 ", falloc"
2826#endif
2827 ", full)"
2828 },
2829 { /* end of list */ }
2830 }
2831};
2832
2833static int raw_check_perm(BlockDriverState *bs, uint64_t perm, uint64_t shared,
2834 Error **errp)
2835{
2836 BDRVRawState *s = bs->opaque;
2837 BDRVRawReopenState *rs = NULL;
2838 int open_flags;
2839 int ret;
2840
2841 if (s->perm_change_fd) {
2842 /*
2843 * In the context of reopen, this function may be called several times
2844 * (directly and recursively while change permissions of the parent).
2845 * This is even true for children that don't inherit from the original
2846 * reopen node, so s->reopen_state is not set.
2847 *
2848 * Ignore all but the first call.
2849 */
2850 return 0;
2851 }
2852
2853 if (s->reopen_state) {
2854 /* We already have a new file descriptor to set permissions for */
2855 assert(s->reopen_state->perm == perm);
2856 assert(s->reopen_state->shared_perm == shared);
2857 rs = s->reopen_state->opaque;
2858 s->perm_change_fd = rs->fd;
2859 s->perm_change_flags = rs->open_flags;
2860 } else {
2861 /* We may need a new fd if auto-read-only switches the mode */
2862 ret = raw_reconfigure_getfd(bs, bs->open_flags, &open_flags, perm,
2863 false, errp);
2864 if (ret < 0) {
2865 return ret;
2866 } else if (ret != s->fd) {
2867 s->perm_change_fd = ret;
2868 s->perm_change_flags = open_flags;
2869 }
2870 }
2871
2872 /* Prepare permissions on old fd to avoid conflicts between old and new,
2873 * but keep everything locked that new will need. */
2874 ret = raw_handle_perm_lock(bs, RAW_PL_PREPARE, perm, shared, errp);
2875 if (ret < 0) {
2876 goto fail;
2877 }
2878
2879 /* Copy locks to the new fd */
2880 if (s->perm_change_fd) {
2881 ret = raw_apply_lock_bytes(NULL, s->perm_change_fd, perm, ~shared,
2882 false, errp);
2883 if (ret < 0) {
2884 raw_handle_perm_lock(bs, RAW_PL_ABORT, 0, 0, NULL);
2885 goto fail;
2886 }
2887 }
2888 return 0;
2889
2890fail:
2891 if (s->perm_change_fd && !s->reopen_state) {
2892 qemu_close(s->perm_change_fd);
2893 }
2894 s->perm_change_fd = 0;
2895 return ret;
2896}
2897
2898static void raw_set_perm(BlockDriverState *bs, uint64_t perm, uint64_t shared)
2899{
2900 BDRVRawState *s = bs->opaque;
2901
2902 /* For reopen, we have already switched to the new fd (.bdrv_set_perm is
2903 * called after .bdrv_reopen_commit) */
2904 if (s->perm_change_fd && s->fd != s->perm_change_fd) {
2905 qemu_close(s->fd);
2906 s->fd = s->perm_change_fd;
2907 s->open_flags = s->perm_change_flags;
2908 }
2909 s->perm_change_fd = 0;
2910
2911 raw_handle_perm_lock(bs, RAW_PL_COMMIT, perm, shared, NULL);
2912 s->perm = perm;
2913 s->shared_perm = shared;
2914}
2915
2916static void raw_abort_perm_update(BlockDriverState *bs)
2917{
2918 BDRVRawState *s = bs->opaque;
2919
2920 /* For reopen, .bdrv_reopen_abort is called afterwards and will close
2921 * the file descriptor. */
2922 if (s->perm_change_fd && !s->reopen_state) {
2923 qemu_close(s->perm_change_fd);
2924 }
2925 s->perm_change_fd = 0;
2926
2927 raw_handle_perm_lock(bs, RAW_PL_ABORT, 0, 0, NULL);
2928}
2929
2930static int coroutine_fn raw_co_copy_range_from(
2931 BlockDriverState *bs, BdrvChild *src, uint64_t src_offset,
2932 BdrvChild *dst, uint64_t dst_offset, uint64_t bytes,
2933 BdrvRequestFlags read_flags, BdrvRequestFlags write_flags)
2934{
2935 return bdrv_co_copy_range_to(src, src_offset, dst, dst_offset, bytes,
2936 read_flags, write_flags);
2937}
2938
2939static int coroutine_fn raw_co_copy_range_to(BlockDriverState *bs,
2940 BdrvChild *src,
2941 uint64_t src_offset,
2942 BdrvChild *dst,
2943 uint64_t dst_offset,
2944 uint64_t bytes,
2945 BdrvRequestFlags read_flags,
2946 BdrvRequestFlags write_flags)
2947{
2948 RawPosixAIOData acb;
2949 BDRVRawState *s = bs->opaque;
2950 BDRVRawState *src_s;
2951
2952 assert(dst->bs == bs);
2953 if (src->bs->drv->bdrv_co_copy_range_to != raw_co_copy_range_to) {
2954 return -ENOTSUP;
2955 }
2956
2957 src_s = src->bs->opaque;
2958 if (fd_open(src->bs) < 0 || fd_open(dst->bs) < 0) {
2959 return -EIO;
2960 }
2961
2962 acb = (RawPosixAIOData) {
2963 .bs = bs,
2964 .aio_type = QEMU_AIO_COPY_RANGE,
2965 .aio_fildes = src_s->fd,
2966 .aio_offset = src_offset,
2967 .aio_nbytes = bytes,
2968 .copy_range = {
2969 .aio_fd2 = s->fd,
2970 .aio_offset2 = dst_offset,
2971 },
2972 };
2973
2974 return raw_thread_pool_submit(bs, handle_aiocb_copy_range, &acb);
2975}
2976
2977BlockDriver bdrv_file = {
2978 .format_name = "file",
2979 .protocol_name = "file",
2980 .instance_size = sizeof(BDRVRawState),
2981 .bdrv_needs_filename = true,
2982 .bdrv_probe = NULL, /* no probe for protocols */
2983 .bdrv_parse_filename = raw_parse_filename,
2984 .bdrv_file_open = raw_open,
2985 .bdrv_reopen_prepare = raw_reopen_prepare,
2986 .bdrv_reopen_commit = raw_reopen_commit,
2987 .bdrv_reopen_abort = raw_reopen_abort,
2988 .bdrv_close = raw_close,
2989 .bdrv_co_create = raw_co_create,
2990 .bdrv_co_create_opts = raw_co_create_opts,
2991 .bdrv_has_zero_init = bdrv_has_zero_init_1,
2992 .bdrv_has_zero_init_truncate = bdrv_has_zero_init_1,
2993 .bdrv_co_block_status = raw_co_block_status,
2994 .bdrv_co_invalidate_cache = raw_co_invalidate_cache,
2995 .bdrv_co_pwrite_zeroes = raw_co_pwrite_zeroes,
2996
2997 .bdrv_co_preadv = raw_co_preadv,
2998 .bdrv_co_pwritev = raw_co_pwritev,
2999 .bdrv_co_flush_to_disk = raw_co_flush_to_disk,
3000 .bdrv_co_pdiscard = raw_co_pdiscard,
3001 .bdrv_co_copy_range_from = raw_co_copy_range_from,
3002 .bdrv_co_copy_range_to = raw_co_copy_range_to,
3003 .bdrv_refresh_limits = raw_refresh_limits,
3004 .bdrv_io_plug = raw_aio_plug,
3005 .bdrv_io_unplug = raw_aio_unplug,
3006 .bdrv_attach_aio_context = raw_aio_attach_aio_context,
3007
3008 .bdrv_co_truncate = raw_co_truncate,
3009 .bdrv_getlength = raw_getlength,
3010 .bdrv_get_info = raw_get_info,
3011 .bdrv_get_allocated_file_size
3012 = raw_get_allocated_file_size,
3013 .bdrv_check_perm = raw_check_perm,
3014 .bdrv_set_perm = raw_set_perm,
3015 .bdrv_abort_perm_update = raw_abort_perm_update,
3016 .create_opts = &raw_create_opts,
3017 .mutable_opts = mutable_opts,
3018};
3019
3020/***********************************************/
3021/* host device */
3022
3023#if defined(__APPLE__) && defined(__MACH__)
3024static kern_return_t GetBSDPath(io_iterator_t mediaIterator, char *bsdPath,
3025 CFIndex maxPathSize, int flags);
3026static char *FindEjectableOpticalMedia(io_iterator_t *mediaIterator)
3027{
3028 kern_return_t kernResult = KERN_FAILURE;
3029 mach_port_t masterPort;
3030 CFMutableDictionaryRef classesToMatch;
3031 const char *matching_array[] = {kIODVDMediaClass, kIOCDMediaClass};
3032 char *mediaType = NULL;
3033
3034 kernResult = IOMasterPort( MACH_PORT_NULL, &masterPort );
3035 if ( KERN_SUCCESS != kernResult ) {
3036 printf( "IOMasterPort returned %d\n", kernResult );
3037 }
3038
3039 int index;
3040 for (index = 0; index < ARRAY_SIZE(matching_array); index++) {
3041 classesToMatch = IOServiceMatching(matching_array[index]);
3042 if (classesToMatch == NULL) {
3043 error_report("IOServiceMatching returned NULL for %s",
3044 matching_array[index]);
3045 continue;
3046 }
3047 CFDictionarySetValue(classesToMatch, CFSTR(kIOMediaEjectableKey),
3048 kCFBooleanTrue);
3049 kernResult = IOServiceGetMatchingServices(masterPort, classesToMatch,
3050 mediaIterator);
3051 if (kernResult != KERN_SUCCESS) {
3052 error_report("Note: IOServiceGetMatchingServices returned %d",
3053 kernResult);
3054 continue;
3055 }
3056
3057 /* If a match was found, leave the loop */
3058 if (*mediaIterator != 0) {
3059 trace_file_FindEjectableOpticalMedia(matching_array[index]);
3060 mediaType = g_strdup(matching_array[index]);
3061 break;
3062 }
3063 }
3064 return mediaType;
3065}
3066
3067kern_return_t GetBSDPath(io_iterator_t mediaIterator, char *bsdPath,
3068 CFIndex maxPathSize, int flags)
3069{
3070 io_object_t nextMedia;
3071 kern_return_t kernResult = KERN_FAILURE;
3072 *bsdPath = '\0';
3073 nextMedia = IOIteratorNext( mediaIterator );
3074 if ( nextMedia )
3075 {
3076 CFTypeRef bsdPathAsCFString;
3077 bsdPathAsCFString = IORegistryEntryCreateCFProperty( nextMedia, CFSTR( kIOBSDNameKey ), kCFAllocatorDefault, 0 );
3078 if ( bsdPathAsCFString ) {
3079 size_t devPathLength;
3080 strcpy( bsdPath, _PATH_DEV );
3081 if (flags & BDRV_O_NOCACHE) {
3082 strcat(bsdPath, "r");
3083 }
3084 devPathLength = strlen( bsdPath );
3085 if ( CFStringGetCString( bsdPathAsCFString, bsdPath + devPathLength, maxPathSize - devPathLength, kCFStringEncodingASCII ) ) {
3086 kernResult = KERN_SUCCESS;
3087 }
3088 CFRelease( bsdPathAsCFString );
3089 }
3090 IOObjectRelease( nextMedia );
3091 }
3092
3093 return kernResult;
3094}
3095
3096/* Sets up a real cdrom for use in QEMU */
3097static bool setup_cdrom(char *bsd_path, Error **errp)
3098{
3099 int index, num_of_test_partitions = 2, fd;
3100 char test_partition[MAXPATHLEN];
3101 bool partition_found = false;
3102
3103 /* look for a working partition */
3104 for (index = 0; index < num_of_test_partitions; index++) {
3105 snprintf(test_partition, sizeof(test_partition), "%ss%d", bsd_path,
3106 index);
3107 fd = qemu_open(test_partition, O_RDONLY | O_BINARY | O_LARGEFILE);
3108 if (fd >= 0) {
3109 partition_found = true;
3110 qemu_close(fd);
3111 break;
3112 }
3113 }
3114
3115 /* if a working partition on the device was not found */
3116 if (partition_found == false) {
3117 error_setg(errp, "Failed to find a working partition on disc");
3118 } else {
3119 trace_file_setup_cdrom(test_partition);
3120 pstrcpy(bsd_path, MAXPATHLEN, test_partition);
3121 }
3122 return partition_found;
3123}
3124
3125/* Prints directions on mounting and unmounting a device */
3126static void print_unmounting_directions(const char *file_name)
3127{
3128 error_report("If device %s is mounted on the desktop, unmount"
3129 " it first before using it in QEMU", file_name);
3130 error_report("Command to unmount device: diskutil unmountDisk %s",
3131 file_name);
3132 error_report("Command to mount device: diskutil mountDisk %s", file_name);
3133}
3134
3135#endif /* defined(__APPLE__) && defined(__MACH__) */
3136
3137static int hdev_probe_device(const char *filename)
3138{
3139 struct stat st;
3140
3141 /* allow a dedicated CD-ROM driver to match with a higher priority */
3142 if (strstart(filename, "/dev/cdrom", NULL))
3143 return 50;
3144
3145 if (stat(filename, &st) >= 0 &&
3146 (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode))) {
3147 return 100;
3148 }
3149
3150 return 0;
3151}
3152
3153static int check_hdev_writable(BDRVRawState *s)
3154{
3155#if defined(BLKROGET)
3156 /* Linux block devices can be configured "read-only" using blockdev(8).
3157 * This is independent of device node permissions and therefore open(2)
3158 * with O_RDWR succeeds. Actual writes fail with EPERM.
3159 *
3160 * bdrv_open() is supposed to fail if the disk is read-only. Explicitly
3161 * check for read-only block devices so that Linux block devices behave
3162 * properly.
3163 */
3164 struct stat st;
3165 int readonly = 0;
3166
3167 if (fstat(s->fd, &st)) {
3168 return -errno;
3169 }
3170
3171 if (!S_ISBLK(st.st_mode)) {
3172 return 0;
3173 }
3174
3175 if (ioctl(s->fd, BLKROGET, &readonly) < 0) {
3176 return -errno;
3177 }
3178
3179 if (readonly) {
3180 return -EACCES;
3181 }
3182#endif /* defined(BLKROGET) */
3183 return 0;
3184}
3185
3186static void hdev_parse_filename(const char *filename, QDict *options,
3187 Error **errp)
3188{
3189 bdrv_parse_filename_strip_prefix(filename, "host_device:", options);
3190}
3191
3192static bool hdev_is_sg(BlockDriverState *bs)
3193{
3194
3195#if defined(__linux__)
3196
3197 BDRVRawState *s = bs->opaque;
3198 struct stat st;
3199 struct sg_scsi_id scsiid;
3200 int sg_version;
3201 int ret;
3202
3203 if (stat(bs->filename, &st) < 0 || !S_ISCHR(st.st_mode)) {
3204 return false;
3205 }
3206
3207 ret = ioctl(s->fd, SG_GET_VERSION_NUM, &sg_version);
3208 if (ret < 0) {
3209 return false;
3210 }
3211
3212 ret = ioctl(s->fd, SG_GET_SCSI_ID, &scsiid);
3213 if (ret >= 0) {
3214 trace_file_hdev_is_sg(scsiid.scsi_type, sg_version);
3215 return true;
3216 }
3217
3218#endif
3219
3220 return false;
3221}
3222
3223static int hdev_open(BlockDriverState *bs, QDict *options, int flags,
3224 Error **errp)
3225{
3226 BDRVRawState *s = bs->opaque;
3227 Error *local_err = NULL;
3228 int ret;
3229
3230#if defined(__APPLE__) && defined(__MACH__)
3231 /*
3232 * Caution: while qdict_get_str() is fine, getting non-string types
3233 * would require more care. When @options come from -blockdev or
3234 * blockdev_add, its members are typed according to the QAPI
3235 * schema, but when they come from -drive, they're all QString.
3236 */
3237 const char *filename = qdict_get_str(options, "filename");
3238 char bsd_path[MAXPATHLEN] = "";
3239 bool error_occurred = false;
3240
3241 /* If using a real cdrom */
3242 if (strcmp(filename, "/dev/cdrom") == 0) {
3243 char *mediaType = NULL;
3244 kern_return_t ret_val;
3245 io_iterator_t mediaIterator = 0;
3246
3247 mediaType = FindEjectableOpticalMedia(&mediaIterator);
3248 if (mediaType == NULL) {
3249 error_setg(errp, "Please make sure your CD/DVD is in the optical"
3250 " drive");
3251 error_occurred = true;
3252 goto hdev_open_Mac_error;
3253 }
3254
3255 ret_val = GetBSDPath(mediaIterator, bsd_path, sizeof(bsd_path), flags);
3256 if (ret_val != KERN_SUCCESS) {
3257 error_setg(errp, "Could not get BSD path for optical drive");
3258 error_occurred = true;
3259 goto hdev_open_Mac_error;
3260 }
3261
3262 /* If a real optical drive was not found */
3263 if (bsd_path[0] == '\0') {
3264 error_setg(errp, "Failed to obtain bsd path for optical drive");
3265 error_occurred = true;
3266 goto hdev_open_Mac_error;
3267 }
3268
3269 /* If using a cdrom disc and finding a partition on the disc failed */
3270 if (strncmp(mediaType, kIOCDMediaClass, 9) == 0 &&
3271 setup_cdrom(bsd_path, errp) == false) {
3272 print_unmounting_directions(bsd_path);
3273 error_occurred = true;
3274 goto hdev_open_Mac_error;
3275 }
3276
3277 qdict_put_str(options, "filename", bsd_path);
3278
3279hdev_open_Mac_error:
3280 g_free(mediaType);
3281 if (mediaIterator) {
3282 IOObjectRelease(mediaIterator);
3283 }
3284 if (error_occurred) {
3285 return -ENOENT;
3286 }
3287 }
3288#endif /* defined(__APPLE__) && defined(__MACH__) */
3289
3290 s->type = FTYPE_FILE;
3291
3292 ret = raw_open_common(bs, options, flags, 0, true, &local_err);
3293 if (ret < 0) {
3294 error_propagate(errp, local_err);
3295#if defined(__APPLE__) && defined(__MACH__)
3296 if (*bsd_path) {
3297 filename = bsd_path;
3298 }
3299 /* if a physical device experienced an error while being opened */
3300 if (strncmp(filename, "/dev/", 5) == 0) {
3301 print_unmounting_directions(filename);
3302 }
3303#endif /* defined(__APPLE__) && defined(__MACH__) */
3304 return ret;
3305 }
3306
3307 /* Since this does ioctl the device must be already opened */
3308 bs->sg = hdev_is_sg(bs);
3309
3310 if (flags & BDRV_O_RDWR) {
3311 ret = check_hdev_writable(s);
3312 if (ret < 0) {
3313 raw_close(bs);
3314 error_setg_errno(errp, -ret, "The device is not writable");
3315 return ret;
3316 }
3317 }
3318
3319 return ret;
3320}
3321
3322#if defined(__linux__)
3323static int coroutine_fn
3324hdev_co_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
3325{
3326 BDRVRawState *s = bs->opaque;
3327 RawPosixAIOData acb;
3328 int ret;
3329
3330 ret = fd_open(bs);
3331 if (ret < 0) {
3332 return ret;
3333 }
3334
3335 if (req == SG_IO && s->pr_mgr) {
3336 struct sg_io_hdr *io_hdr = buf;
3337 if (io_hdr->cmdp[0] == PERSISTENT_RESERVE_OUT ||
3338 io_hdr->cmdp[0] == PERSISTENT_RESERVE_IN) {
3339 return pr_manager_execute(s->pr_mgr, bdrv_get_aio_context(bs),
3340 s->fd, io_hdr);
3341 }
3342 }
3343
3344 acb = (RawPosixAIOData) {
3345 .bs = bs,
3346 .aio_type = QEMU_AIO_IOCTL,
3347 .aio_fildes = s->fd,
3348 .aio_offset = 0,
3349 .ioctl = {
3350 .buf = buf,
3351 .cmd = req,
3352 },
3353 };
3354
3355 return raw_thread_pool_submit(bs, handle_aiocb_ioctl, &acb);
3356}
3357#endif /* linux */
3358
3359static int fd_open(BlockDriverState *bs)
3360{
3361 BDRVRawState *s = bs->opaque;
3362
3363 /* this is just to ensure s->fd is sane (its called by io ops) */
3364 if (s->fd >= 0)
3365 return 0;
3366 return -EIO;
3367}
3368
3369static coroutine_fn int
3370hdev_co_pdiscard(BlockDriverState *bs, int64_t offset, int bytes)
3371{
3372 int ret;
3373
3374 ret = fd_open(bs);
3375 if (ret < 0) {
3376 return ret;
3377 }
3378 return raw_do_pdiscard(bs, offset, bytes, true);
3379}
3380
3381static coroutine_fn int hdev_co_pwrite_zeroes(BlockDriverState *bs,
3382 int64_t offset, int bytes, BdrvRequestFlags flags)
3383{
3384 int rc;
3385
3386 rc = fd_open(bs);
3387 if (rc < 0) {
3388 return rc;
3389 }
3390
3391 return raw_do_pwrite_zeroes(bs, offset, bytes, flags, true);
3392}
3393
3394static int coroutine_fn hdev_co_create_opts(const char *filename, QemuOpts *opts,
3395 Error **errp)
3396{
3397 int fd;
3398 int ret = 0;
3399 struct stat stat_buf;
3400 int64_t total_size = 0;
3401 bool has_prefix;
3402
3403 /* This function is used by both protocol block drivers and therefore either
3404 * of these prefixes may be given.
3405 * The return value has to be stored somewhere, otherwise this is an error
3406 * due to -Werror=unused-value. */
3407 has_prefix =
3408 strstart(filename, "host_device:", &filename) ||
3409 strstart(filename, "host_cdrom:" , &filename);
3410
3411 (void)has_prefix;
3412
3413 ret = raw_normalize_devicepath(&filename, errp);
3414 if (ret < 0) {
3415 return ret;
3416 }
3417
3418 /* Read out options */
3419 total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
3420 BDRV_SECTOR_SIZE);
3421
3422 fd = qemu_open(filename, O_WRONLY | O_BINARY);
3423 if (fd < 0) {
3424 ret = -errno;
3425 error_setg_errno(errp, -ret, "Could not open device");
3426 return ret;
3427 }
3428
3429 if (fstat(fd, &stat_buf) < 0) {
3430 ret = -errno;
3431 error_setg_errno(errp, -ret, "Could not stat device");
3432 } else if (!S_ISBLK(stat_buf.st_mode) && !S_ISCHR(stat_buf.st_mode)) {
3433 error_setg(errp,
3434 "The given file is neither a block nor a character device");
3435 ret = -ENODEV;
3436 } else if (lseek(fd, 0, SEEK_END) < total_size) {
3437 error_setg(errp, "Device is too small");
3438 ret = -ENOSPC;
3439 }
3440
3441 if (!ret && total_size) {
3442 uint8_t buf[BDRV_SECTOR_SIZE] = { 0 };
3443 int64_t zero_size = MIN(BDRV_SECTOR_SIZE, total_size);
3444 if (lseek(fd, 0, SEEK_SET) == -1) {
3445 ret = -errno;
3446 } else {
3447 ret = qemu_write_full(fd, buf, zero_size);
3448 ret = ret == zero_size ? 0 : -errno;
3449 }
3450 }
3451 qemu_close(fd);
3452 return ret;
3453}
3454
3455static BlockDriver bdrv_host_device = {
3456 .format_name = "host_device",
3457 .protocol_name = "host_device",
3458 .instance_size = sizeof(BDRVRawState),
3459 .bdrv_needs_filename = true,
3460 .bdrv_probe_device = hdev_probe_device,
3461 .bdrv_parse_filename = hdev_parse_filename,
3462 .bdrv_file_open = hdev_open,
3463 .bdrv_close = raw_close,
3464 .bdrv_reopen_prepare = raw_reopen_prepare,
3465 .bdrv_reopen_commit = raw_reopen_commit,
3466 .bdrv_reopen_abort = raw_reopen_abort,
3467 .bdrv_co_create_opts = hdev_co_create_opts,
3468 .create_opts = &raw_create_opts,
3469 .mutable_opts = mutable_opts,
3470 .bdrv_co_invalidate_cache = raw_co_invalidate_cache,
3471 .bdrv_co_pwrite_zeroes = hdev_co_pwrite_zeroes,
3472
3473 .bdrv_co_preadv = raw_co_preadv,
3474 .bdrv_co_pwritev = raw_co_pwritev,
3475 .bdrv_co_flush_to_disk = raw_co_flush_to_disk,
3476 .bdrv_co_pdiscard = hdev_co_pdiscard,
3477 .bdrv_co_copy_range_from = raw_co_copy_range_from,
3478 .bdrv_co_copy_range_to = raw_co_copy_range_to,
3479 .bdrv_refresh_limits = raw_refresh_limits,
3480 .bdrv_io_plug = raw_aio_plug,
3481 .bdrv_io_unplug = raw_aio_unplug,
3482 .bdrv_attach_aio_context = raw_aio_attach_aio_context,
3483
3484 .bdrv_co_truncate = raw_co_truncate,
3485 .bdrv_getlength = raw_getlength,
3486 .bdrv_get_info = raw_get_info,
3487 .bdrv_get_allocated_file_size
3488 = raw_get_allocated_file_size,
3489 .bdrv_check_perm = raw_check_perm,
3490 .bdrv_set_perm = raw_set_perm,
3491 .bdrv_abort_perm_update = raw_abort_perm_update,
3492 .bdrv_probe_blocksizes = hdev_probe_blocksizes,
3493 .bdrv_probe_geometry = hdev_probe_geometry,
3494
3495 /* generic scsi device */
3496#ifdef __linux__
3497 .bdrv_co_ioctl = hdev_co_ioctl,
3498#endif
3499};
3500
3501#if defined(__linux__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
3502static void cdrom_parse_filename(const char *filename, QDict *options,
3503 Error **errp)
3504{
3505 bdrv_parse_filename_strip_prefix(filename, "host_cdrom:", options);
3506}
3507#endif
3508
3509#ifdef __linux__
3510static int cdrom_open(BlockDriverState *bs, QDict *options, int flags,
3511 Error **errp)
3512{
3513 BDRVRawState *s = bs->opaque;
3514
3515 s->type = FTYPE_CD;
3516
3517 /* open will not fail even if no CD is inserted, so add O_NONBLOCK */
3518 return raw_open_common(bs, options, flags, O_NONBLOCK, true, errp);
3519}
3520
3521static int cdrom_probe_device(const char *filename)
3522{
3523 int fd, ret;
3524 int prio = 0;
3525 struct stat st;
3526
3527 fd = qemu_open(filename, O_RDONLY | O_NONBLOCK);
3528 if (fd < 0) {
3529 goto out;
3530 }
3531 ret = fstat(fd, &st);
3532 if (ret == -1 || !S_ISBLK(st.st_mode)) {
3533 goto outc;
3534 }
3535
3536 /* Attempt to detect via a CDROM specific ioctl */
3537 ret = ioctl(fd, CDROM_DRIVE_STATUS, CDSL_CURRENT);
3538 if (ret >= 0)
3539 prio = 100;
3540
3541outc:
3542 qemu_close(fd);
3543out:
3544 return prio;
3545}
3546
3547static bool cdrom_is_inserted(BlockDriverState *bs)
3548{
3549 BDRVRawState *s = bs->opaque;
3550 int ret;
3551
3552 ret = ioctl(s->fd, CDROM_DRIVE_STATUS, CDSL_CURRENT);
3553 return ret == CDS_DISC_OK;
3554}
3555
3556static void cdrom_eject(BlockDriverState *bs, bool eject_flag)
3557{
3558 BDRVRawState *s = bs->opaque;
3559
3560 if (eject_flag) {
3561 if (ioctl(s->fd, CDROMEJECT, NULL) < 0)
3562 perror("CDROMEJECT");
3563 } else {
3564 if (ioctl(s->fd, CDROMCLOSETRAY, NULL) < 0)
3565 perror("CDROMEJECT");
3566 }
3567}
3568
3569static void cdrom_lock_medium(BlockDriverState *bs, bool locked)
3570{
3571 BDRVRawState *s = bs->opaque;
3572
3573 if (ioctl(s->fd, CDROM_LOCKDOOR, locked) < 0) {
3574 /*
3575 * Note: an error can happen if the distribution automatically
3576 * mounts the CD-ROM
3577 */
3578 /* perror("CDROM_LOCKDOOR"); */
3579 }
3580}
3581
3582static BlockDriver bdrv_host_cdrom = {
3583 .format_name = "host_cdrom",
3584 .protocol_name = "host_cdrom",
3585 .instance_size = sizeof(BDRVRawState),
3586 .bdrv_needs_filename = true,
3587 .bdrv_probe_device = cdrom_probe_device,
3588 .bdrv_parse_filename = cdrom_parse_filename,
3589 .bdrv_file_open = cdrom_open,
3590 .bdrv_close = raw_close,
3591 .bdrv_reopen_prepare = raw_reopen_prepare,
3592 .bdrv_reopen_commit = raw_reopen_commit,
3593 .bdrv_reopen_abort = raw_reopen_abort,
3594 .bdrv_co_create_opts = hdev_co_create_opts,
3595 .create_opts = &raw_create_opts,
3596 .mutable_opts = mutable_opts,
3597 .bdrv_co_invalidate_cache = raw_co_invalidate_cache,
3598
3599
3600 .bdrv_co_preadv = raw_co_preadv,
3601 .bdrv_co_pwritev = raw_co_pwritev,
3602 .bdrv_co_flush_to_disk = raw_co_flush_to_disk,
3603 .bdrv_refresh_limits = raw_refresh_limits,
3604 .bdrv_io_plug = raw_aio_plug,
3605 .bdrv_io_unplug = raw_aio_unplug,
3606 .bdrv_attach_aio_context = raw_aio_attach_aio_context,
3607
3608 .bdrv_co_truncate = raw_co_truncate,
3609 .bdrv_getlength = raw_getlength,
3610 .has_variable_length = true,
3611 .bdrv_get_allocated_file_size
3612 = raw_get_allocated_file_size,
3613
3614 /* removable device support */
3615 .bdrv_is_inserted = cdrom_is_inserted,
3616 .bdrv_eject = cdrom_eject,
3617 .bdrv_lock_medium = cdrom_lock_medium,
3618
3619 /* generic scsi device */
3620 .bdrv_co_ioctl = hdev_co_ioctl,
3621};
3622#endif /* __linux__ */
3623
3624#if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
3625static int cdrom_open(BlockDriverState *bs, QDict *options, int flags,
3626 Error **errp)
3627{
3628 BDRVRawState *s = bs->opaque;
3629 Error *local_err = NULL;
3630 int ret;
3631
3632 s->type = FTYPE_CD;
3633
3634 ret = raw_open_common(bs, options, flags, 0, true, &local_err);
3635 if (ret) {
3636 error_propagate(errp, local_err);
3637 return ret;
3638 }
3639
3640 /* make sure the door isn't locked at this time */
3641 ioctl(s->fd, CDIOCALLOW);
3642 return 0;
3643}
3644
3645static int cdrom_probe_device(const char *filename)
3646{
3647 if (strstart(filename, "/dev/cd", NULL) ||
3648 strstart(filename, "/dev/acd", NULL))
3649 return 100;
3650 return 0;
3651}
3652
3653static int cdrom_reopen(BlockDriverState *bs)
3654{
3655 BDRVRawState *s = bs->opaque;
3656 int fd;
3657
3658 /*
3659 * Force reread of possibly changed/newly loaded disc,
3660 * FreeBSD seems to not notice sometimes...
3661 */
3662 if (s->fd >= 0)
3663 qemu_close(s->fd);
3664 fd = qemu_open(bs->filename, s->open_flags, 0644);
3665 if (fd < 0) {
3666 s->fd = -1;
3667 return -EIO;
3668 }
3669 s->fd = fd;
3670
3671 /* make sure the door isn't locked at this time */
3672 ioctl(s->fd, CDIOCALLOW);
3673 return 0;
3674}
3675
3676static bool cdrom_is_inserted(BlockDriverState *bs)
3677{
3678 return raw_getlength(bs) > 0;
3679}
3680
3681static void cdrom_eject(BlockDriverState *bs, bool eject_flag)
3682{
3683 BDRVRawState *s = bs->opaque;
3684
3685 if (s->fd < 0)
3686 return;
3687
3688 (void) ioctl(s->fd, CDIOCALLOW);
3689
3690 if (eject_flag) {
3691 if (ioctl(s->fd, CDIOCEJECT) < 0)
3692 perror("CDIOCEJECT");
3693 } else {
3694 if (ioctl(s->fd, CDIOCCLOSE) < 0)
3695 perror("CDIOCCLOSE");
3696 }
3697
3698 cdrom_reopen(bs);
3699}
3700
3701static void cdrom_lock_medium(BlockDriverState *bs, bool locked)
3702{
3703 BDRVRawState *s = bs->opaque;
3704
3705 if (s->fd < 0)
3706 return;
3707 if (ioctl(s->fd, (locked ? CDIOCPREVENT : CDIOCALLOW)) < 0) {
3708 /*
3709 * Note: an error can happen if the distribution automatically
3710 * mounts the CD-ROM
3711 */
3712 /* perror("CDROM_LOCKDOOR"); */
3713 }
3714}
3715
3716static BlockDriver bdrv_host_cdrom = {
3717 .format_name = "host_cdrom",
3718 .protocol_name = "host_cdrom",
3719 .instance_size = sizeof(BDRVRawState),
3720 .bdrv_needs_filename = true,
3721 .bdrv_probe_device = cdrom_probe_device,
3722 .bdrv_parse_filename = cdrom_parse_filename,
3723 .bdrv_file_open = cdrom_open,
3724 .bdrv_close = raw_close,
3725 .bdrv_reopen_prepare = raw_reopen_prepare,
3726 .bdrv_reopen_commit = raw_reopen_commit,
3727 .bdrv_reopen_abort = raw_reopen_abort,
3728 .bdrv_co_create_opts = hdev_co_create_opts,
3729 .create_opts = &raw_create_opts,
3730 .mutable_opts = mutable_opts,
3731
3732 .bdrv_co_preadv = raw_co_preadv,
3733 .bdrv_co_pwritev = raw_co_pwritev,
3734 .bdrv_co_flush_to_disk = raw_co_flush_to_disk,
3735 .bdrv_refresh_limits = raw_refresh_limits,
3736 .bdrv_io_plug = raw_aio_plug,
3737 .bdrv_io_unplug = raw_aio_unplug,
3738 .bdrv_attach_aio_context = raw_aio_attach_aio_context,
3739
3740 .bdrv_co_truncate = raw_co_truncate,
3741 .bdrv_getlength = raw_getlength,
3742 .has_variable_length = true,
3743 .bdrv_get_allocated_file_size
3744 = raw_get_allocated_file_size,
3745
3746 /* removable device support */
3747 .bdrv_is_inserted = cdrom_is_inserted,
3748 .bdrv_eject = cdrom_eject,
3749 .bdrv_lock_medium = cdrom_lock_medium,
3750};
3751#endif /* __FreeBSD__ */
3752
3753static void bdrv_file_init(void)
3754{
3755 /*
3756 * Register all the drivers. Note that order is important, the driver
3757 * registered last will get probed first.
3758 */
3759 bdrv_register(&bdrv_file);
3760 bdrv_register(&bdrv_host_device);
3761#ifdef __linux__
3762 bdrv_register(&bdrv_host_cdrom);
3763#endif
3764#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
3765 bdrv_register(&bdrv_host_cdrom);
3766#endif
3767}
3768
3769block_init(bdrv_file_init);
3770