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