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