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