Lines Matching +full:lock +full:- +full:detect +full:- +full:function +full:- +full:integer +full:- +full:n +full:- +full:enable
28 #include "qemu/error-report.h"
29 #include "block/block-io.h"
36 #include "block/thread-pool.h"
38 #include "block/raw-aio.h"
42 #include "scsi/pr-manager.h"
76 #include <linux/dm-ioctl.h>
146 * - DM_MPATH_PROBE_PATHS returns success, but before SG_IO completes, another
149 * - DM_MPATH_PROBE_PATHS failed all paths in the current path group, so we have
154 * failover), it's rare to have more than eight path groups - and even then
171 * s->fd. */
210 BDRVRawState *s = bs->opaque; in fd_open()
212 /* this is just to ensure s->fd is sane (its called by io ops) */ in fd_open()
213 if (s->fd >= 0) { in fd_open()
216 return -EIO; in fd_open()
262 * Elide EAGAIN and EACCES details when failing to lock, as this
286 return -errno; in raw_normalize_devicepath()
297 (int)(dp - fname), fname, dp + 1); in raw_normalize_devicepath()
341 return success ? 0 : -errno; in probe_logical_blocksize()
347 * On failure, return -errno.
353 return -errno; in probe_physical_blocksize()
357 return -ENOTSUP; in probe_physical_blocksize()
385 BDRVRawState *s = bs->opaque; in raw_needs_alignment()
387 if ((bs->open_flags & BDRV_O_NOCACHE) != 0 && !dio_byte_aligned(s->fd)) { in raw_needs_alignment()
391 return s->force_alignment; in raw_needs_alignment()
396 * This function is used to check O_DIRECT memory buffer and request alignment.
421 BDRVRawState *s = bs->opaque; in raw_probe_alignment()
428 if (bdrv_is_sg(bs) || !s->needs_alignment) { in raw_probe_alignment()
429 bs->bl.request_alignment = 1; in raw_probe_alignment()
430 s->buf_align = 1; in raw_probe_alignment()
434 bs->bl.request_alignment = 0; in raw_probe_alignment()
435 s->buf_align = 0; in raw_probe_alignment()
437 if (probe_logical_blocksize(fd, &bs->bl.request_alignment) < 0) { in raw_probe_alignment()
438 bs->bl.request_alignment = 0; in raw_probe_alignment()
453 bs->bl.request_alignment = da.d_miniosz; in raw_probe_alignment()
455 /* s->buf_align = da.d_mem; */ in raw_probe_alignment()
461 * to detect request alignment, since it is more likely to succeed. Then in raw_probe_alignment()
462 * try to detect buf_align, which cannot be detected in some cases (e.g. in raw_probe_alignment()
467 if (!bs->bl.request_alignment) { in raw_probe_alignment()
475 bs->bl.request_alignment = (align != 1) ? align : max_align; in raw_probe_alignment()
482 if (!s->buf_align) { in raw_probe_alignment()
490 s->buf_align = (align != 1) ? align : bs->bl.request_alignment; in raw_probe_alignment()
497 if (!s->buf_align || !bs->bl.request_alignment) { in raw_probe_alignment()
499 error_append_hint(errp, "Try cache.direct=off\n"); in raw_probe_alignment()
506 /* Linux block devices can be configured "read-only" using blockdev(8). in check_hdev_writable()
510 * bdrv_open() is supposed to fail if the disk is read-only. Explicitly in check_hdev_writable()
511 * check for read-only block devices so that Linux block devices behave in check_hdev_writable()
518 return -errno; in check_hdev_writable()
526 return -errno; in check_hdev_writable()
530 return -EACCES; in check_hdev_writable()
556 /* Use O_DSYNC for write-through caching, no flags for write-back caching, in raw_parse_flags()
584 .name = "aio-max-batch",
594 .name = "pr-manager",
600 .name = "drop-cache",
606 .name = "x-check-cache-dropped",
614 static const char *const mutable_opts[] = { "x-check-cache-dropped", NULL };
620 BDRVRawState *s = bs->opaque; in raw_open_common()
632 ret = -EINVAL; in raw_open_common()
658 ret = -EINVAL; in raw_open_common()
662 s->use_linux_aio = (aio == BLOCKDEV_AIO_OPTIONS_NATIVE); in raw_open_common()
664 s->use_linux_io_uring = (aio == BLOCKDEV_AIO_OPTIONS_IO_URING); in raw_open_common()
667 s->aio_max_batch = qemu_opt_get_number(opts, "aio-max-batch", 0); in raw_open_common()
674 ret = -EINVAL; in raw_open_common()
679 s->use_lock = true; in raw_open_common()
681 warn_report("File lock requested but OFD locking syscall is " in raw_open_common()
684 "unexpectedly.\n"); in raw_open_common()
688 s->use_lock = false; in raw_open_common()
691 s->use_lock = qemu_has_ofd_lock(); in raw_open_common()
697 str = qemu_opt_get(opts, "pr-manager"); in raw_open_common()
699 s->pr_mgr = pr_manager_lookup(str, &local_err); in raw_open_common()
702 ret = -EINVAL; in raw_open_common()
707 s->drop_cache = qemu_opt_get_bool(opts, "drop-cache", true); in raw_open_common()
708 s->check_cache_dropped = qemu_opt_get_bool(opts, "x-check-cache-dropped", in raw_open_common()
711 s->open_flags = open_flags; in raw_open_common()
712 raw_parse_flags(bdrv_flags, &s->open_flags, false); in raw_open_common()
714 s->fd = -1; in raw_open_common()
715 fd = qemu_open(filename, s->open_flags, errp); in raw_open_common()
716 ret = fd < 0 ? -errno : 0; in raw_open_common()
719 if (ret == -EROFS) { in raw_open_common()
720 ret = -EACCES; in raw_open_common()
724 s->fd = fd; in raw_open_common()
726 /* Check s->open_flags rather than bdrv_flags due to auto-read-only */ in raw_open_common()
727 if (s->open_flags & O_RDWR) { in raw_open_common()
728 ret = check_hdev_writable(s->fd); in raw_open_common()
730 error_setg_errno(errp, -ret, "The device is not writable"); in raw_open_common()
735 s->perm = 0; in raw_open_common()
736 s->shared_perm = BLK_PERM_ALL; in raw_open_common()
740 if (s->use_linux_aio && !(s->open_flags & O_DIRECT)) { in raw_open_common()
743 ret = -EINVAL; in raw_open_common()
746 if (s->use_linux_aio) { in raw_open_common()
747 s->has_laio_fdsync = laio_has_fdsync(s->fd); in raw_open_common()
750 if (s->use_linux_aio) { in raw_open_common()
753 ret = -EINVAL; in raw_open_common()
759 if (s->use_linux_io_uring) { in raw_open_common()
762 ret = -EINVAL; in raw_open_common()
767 s->has_discard = true; in raw_open_common()
768 s->has_write_zeroes = true; in raw_open_common()
770 if (fstat(s->fd, &st) < 0) { in raw_open_common()
771 ret = -errno; in raw_open_common()
779 bs->drv->format_name, bs->filename); in raw_open_common()
780 ret = -EINVAL; in raw_open_common()
783 s->has_fallocate = true; in raw_open_common()
789 bs->drv->format_name, bs->filename); in raw_open_common()
790 ret = -EINVAL; in raw_open_common()
799 if ((bs->bl.zoned != BLK_Z_NONE) && in raw_open_common()
800 (!(s->open_flags & O_DIRECT))) { in raw_open_common()
803 return -EINVAL; /* No host kernel page cache */ in raw_open_common()
815 s->force_alignment = true; in raw_open_common()
818 s->needs_alignment = raw_needs_alignment(bs); in raw_open_common()
820 bs->supported_write_flags = BDRV_REQ_FUA; in raw_open_common()
821 if (s->use_linux_aio && !laio_has_fua()) { in raw_open_common()
822 bs->supported_write_flags &= ~BDRV_REQ_FUA; in raw_open_common()
823 } else if (s->use_linux_io_uring && !luring_has_fua()) { in raw_open_common()
824 bs->supported_write_flags &= ~BDRV_REQ_FUA; in raw_open_common()
827 bs->supported_zero_flags = BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK; in raw_open_common()
830 bs->supported_truncate_flags = BDRV_REQ_ZERO_WRITE; in raw_open_common()
834 if (ret < 0 && s->fd != -1) { in raw_open_common()
835 qemu_close(s->fd); in raw_open_common()
847 BDRVRawState *s = bs->opaque; in raw_open()
849 s->type = FTYPE_FILE; in raw_open()
862 /* Lock bytes indicated by @perm_lock_bits and @shared_perm_lock_bits in the
876 locked_perm = s->locked_perm; in raw_apply_lock_bytes()
877 locked_shared_perm = s->locked_shared_perm; in raw_apply_lock_bytes()
880 * We don't have the previous bits, just lock/unlock for each of the in raw_apply_lock_bytes()
898 raw_lock_error_setg_errno(errp, -ret, "Failed to lock byte %d", in raw_apply_lock_bytes()
902 s->locked_perm |= bit; in raw_apply_lock_bytes()
907 error_setg_errno(errp, -ret, "Failed to unlock byte %d", off); in raw_apply_lock_bytes()
910 s->locked_perm &= ~bit; in raw_apply_lock_bytes()
920 raw_lock_error_setg_errno(errp, -ret, "Failed to lock byte %d", in raw_apply_lock_bytes()
924 s->locked_shared_perm |= bit; in raw_apply_lock_bytes()
930 error_setg_errno(errp, -ret, "Failed to unlock byte %d", off); in raw_apply_lock_bytes()
933 s->locked_shared_perm &= ~bit; in raw_apply_lock_bytes()
955 raw_lock_error_setg_errno(errp, -ret, in raw_check_lock_bytes()
956 "Failed to get \"%s\" lock", in raw_check_lock_bytes()
971 raw_lock_error_setg_errno(errp, -ret, in raw_check_lock_bytes()
972 "Failed to get shared \"%s\" lock", in raw_check_lock_bytes()
987 BDRVRawState *s = bs->opaque; in raw_handle_perm_lock()
991 if (!s->use_lock) { in raw_handle_perm_lock()
1001 if ((s->perm | new_perm) == s->perm && in raw_handle_perm_lock()
1002 (s->shared_perm & new_shared) == s->shared_perm) in raw_handle_perm_lock()
1006 * to some fs-dependent permission-unrelated reasons (which occurs in raw_handle_perm_lock()
1013 ret = raw_apply_lock_bytes(s, s->fd, s->perm | new_perm, in raw_handle_perm_lock()
1014 ~s->shared_perm | ~new_shared, in raw_handle_perm_lock()
1017 ret = raw_check_lock_bytes(s->fd, new_perm, new_shared, errp); in raw_handle_perm_lock()
1022 "Is another process using the image [%s]?\n", in raw_handle_perm_lock()
1023 bs->filename); in raw_handle_perm_lock()
1027 raw_apply_lock_bytes(s, s->fd, s->perm, ~s->shared_perm, in raw_handle_perm_lock()
1037 raw_apply_lock_bytes(s, s->fd, new_perm, ~new_shared, in raw_handle_perm_lock()
1056 if (flags == -1) { in fcntl_setfl()
1057 return -errno; in fcntl_setfl()
1059 if (fcntl(fd, F_SETFL, flags | flag) == -1) { in fcntl_setfl()
1060 return -errno; in fcntl_setfl()
1068 BDRVRawState *s = bs->opaque; in raw_reconfigure_getfd()
1069 int fd = -1; in raw_reconfigure_getfd()
1079 if (s->type == FTYPE_CD) { in raw_reconfigure_getfd()
1087 * will not let us track the state into rs->open_flags (typically in raw_reconfigure_getfd()
1091 assert((s->open_flags & O_ASYNC) == 0); in raw_reconfigure_getfd()
1094 if (*open_flags == s->open_flags) { in raw_reconfigure_getfd()
1096 return s->fd; in raw_reconfigure_getfd()
1099 if ((*open_flags & ~fcntl_flags) == (s->open_flags & ~fcntl_flags)) { in raw_reconfigure_getfd()
1101 fd = qemu_dup(s->fd); in raw_reconfigure_getfd()
1106 fd = -1; in raw_reconfigure_getfd()
1112 if (fd == -1) { in raw_reconfigure_getfd()
1113 const char *normalized_filename = bs->filename; in raw_reconfigure_getfd()
1117 if (fd == -1) { in raw_reconfigure_getfd()
1118 return -1; in raw_reconfigure_getfd()
1123 if (fd != -1 && (*open_flags & O_RDWR)) { in raw_reconfigure_getfd()
1127 error_setg_errno(errp, -ret, "The device is not writable"); in raw_reconfigure_getfd()
1128 return -1; in raw_reconfigure_getfd()
1144 assert(state->bs != NULL); in raw_reopen_prepare()
1146 s = state->bs->opaque; in raw_reopen_prepare()
1148 state->opaque = g_new0(BDRVRawReopenState, 1); in raw_reopen_prepare()
1149 rs = state->opaque; in raw_reopen_prepare()
1153 if (!qemu_opts_absorb_qdict(opts, state->options, errp)) { in raw_reopen_prepare()
1154 ret = -EINVAL; in raw_reopen_prepare()
1158 rs->drop_cache = qemu_opt_get_bool_del(opts, "drop-cache", true); in raw_reopen_prepare()
1159 rs->check_cache_dropped = in raw_reopen_prepare()
1160 qemu_opt_get_bool_del(opts, "x-check-cache-dropped", false); in raw_reopen_prepare()
1162 /* This driver's reopen function doesn't currently allow changing in raw_reopen_prepare()
1164 * bdrv_reopen_prepare() will detect changes and complain. */ in raw_reopen_prepare()
1165 qemu_opts_to_qdict(opts, state->options); in raw_reopen_prepare()
1176 s->reopen_state = state; in raw_reopen_prepare()
1186 BDRVRawReopenState *rs = state->opaque; in raw_reopen_commit()
1187 BDRVRawState *s = state->bs->opaque; in raw_reopen_commit()
1189 s->drop_cache = rs->drop_cache; in raw_reopen_commit()
1190 s->check_cache_dropped = rs->check_cache_dropped; in raw_reopen_commit()
1191 s->open_flags = rs->open_flags; in raw_reopen_commit()
1192 g_free(state->opaque); in raw_reopen_commit()
1193 state->opaque = NULL; in raw_reopen_commit()
1195 assert(s->reopen_state == state); in raw_reopen_commit()
1196 s->reopen_state = NULL; in raw_reopen_commit()
1202 BDRVRawReopenState *rs = state->opaque; in raw_reopen_abort()
1203 BDRVRawState *s = state->bs->opaque; in raw_reopen_abort()
1210 g_free(state->opaque); in raw_reopen_abort()
1211 state->opaque = NULL; in raw_reopen_abort()
1213 assert(s->reopen_state == state); in raw_reopen_abort()
1214 s->reopen_state = NULL; in raw_reopen_abort()
1220 if (S_ISBLK(st->st_mode)) { in hdev_get_max_hw_transfer()
1231 return -errno; in hdev_get_max_hw_transfer()
1233 return -ENOSYS; in hdev_get_max_hw_transfer()
1246 if (!S_ISBLK(st->st_mode)) { in get_sysfs_str_val()
1247 return -ENOTSUP; in get_sysfs_str_val()
1251 major(st->st_rdev), minor(st->st_rdev), in get_sysfs_str_val()
1254 return -ENOENT; in get_sysfs_str_val()
1257 /* The file is ended with '\n' */ in get_sysfs_str_val()
1260 if (*(p + len - 1) == '\n') { in get_sysfs_str_val()
1261 *(p + len - 1) = '\0'; in get_sysfs_str_val()
1278 if (strcmp(val, "host-managed") == 0) { in get_sysfs_zoned_model()
1280 } else if (strcmp(val, "host-aware") == 0) { in get_sysfs_zoned_model()
1285 return -ENOTSUP; in get_sysfs_zoned_model()
1293 * Get a sysfs attribute value as a long integer.
1307 /* The file is ended with '\n', pass 'end' to accept that. */ in get_sysfs_long_val()
1331 /* The file is ended with '\n', pass 'end' to accept that. */ in get_sysfs_u32_val()
1345 if (S_ISCHR(st->st_mode)) { in hdev_get_max_segments()
1349 return -ENOTSUP; in hdev_get_max_segments()
1353 return -ENOTSUP; in hdev_get_max_segments()
1359 * -errno otherwise.
1370 return -ENOTSUP; in hdev_get_pdiscard_alignment()
1386 BlockZoneWps *wps = bs->wps; in get_zones_wp()
1387 unsigned int j = offset / bs->bl.zone_size; in get_zones_wp()
1388 unsigned int n = 0, i = 0; in get_zones_wp() local
1395 while (n < nrz) { in get_zones_wp()
1397 rep->sector = sector; in get_zones_wp()
1398 rep->nr_zones = nrz - n; in get_zones_wp()
1406 return -errno; in get_zones_wp()
1409 if (!rep->nr_zones) { in get_zones_wp()
1413 for (i = 0; i < rep->nr_zones; ++i, ++n, ++j) { in get_zones_wp()
1422 wps->wp[j] |= 1ULL << 63; in get_zones_wp()
1428 wps->wp[j] = (blkz[i].start + blkz[i].len) << BDRV_SECTOR_BITS; in get_zones_wp()
1432 wps->wp[j] = (blkz[i].start) << BDRV_SECTOR_BITS; in get_zones_wp()
1436 wps->wp[j] = blkz[i].start << BDRV_SECTOR_BITS; in get_zones_wp()
1438 wps->wp[j] = blkz[i].wp << BDRV_SECTOR_BITS; in get_zones_wp()
1444 sector = blkz[i - 1].start + blkz[i - 1].len; in get_zones_wp()
1461 BDRVRawState *s = bs->opaque; in raw_refresh_zoned_limits()
1469 bs->bl.zoned = zoned; in raw_refresh_zoned_limits()
1473 bs->bl.max_open_zones = ret; in raw_refresh_zoned_limits()
1478 bs->bl.max_active_zones = ret; in raw_refresh_zoned_limits()
1486 error_setg_errno(errp, -ret, "Unable to read chunk_sectors " in raw_refresh_zoned_limits()
1493 bs->bl.zone_size = ret << BDRV_SECTOR_BITS; in raw_refresh_zoned_limits()
1497 error_setg_errno(errp, -ret, "Unable to read nr_zones " in raw_refresh_zoned_limits()
1504 bs->bl.nr_zones = ret; in raw_refresh_zoned_limits()
1508 bs->bl.max_append_sectors = ret >> BDRV_SECTOR_BITS; in raw_refresh_zoned_limits()
1513 bs->bl.write_granularity = ret; in raw_refresh_zoned_limits()
1516 /* The refresh_limits() function can be called multiple times. */ in raw_refresh_zoned_limits()
1517 g_free(bs->wps); in raw_refresh_zoned_limits()
1518 bs->wps = g_malloc(sizeof(BlockZoneWps) + in raw_refresh_zoned_limits()
1519 sizeof(int64_t) * bs->bl.nr_zones); in raw_refresh_zoned_limits()
1520 ret = get_zones_wp(bs, s->fd, 0, bs->bl.nr_zones, 0); in raw_refresh_zoned_limits()
1522 error_setg_errno(errp, -ret, "report wps failed"); in raw_refresh_zoned_limits()
1525 qemu_co_mutex_init(&bs->wps->colock); in raw_refresh_zoned_limits()
1529 bs->bl.zoned = BLK_Z_NONE; in raw_refresh_zoned_limits()
1530 g_free(bs->wps); in raw_refresh_zoned_limits()
1531 bs->wps = NULL; in raw_refresh_zoned_limits()
1537 bs->bl.zoned = BLK_Z_NONE; in raw_refresh_zoned_limits()
1543 BDRVRawState *s = bs->opaque; in raw_refresh_limits()
1546 s->needs_alignment = raw_needs_alignment(bs); in raw_refresh_limits()
1547 raw_probe_alignment(bs, s->fd, errp); in raw_refresh_limits()
1549 bs->bl.min_mem_alignment = s->buf_align; in raw_refresh_limits()
1550 bs->bl.opt_mem_alignment = MAX(s->buf_align, qemu_real_host_page_size()); in raw_refresh_limits()
1557 if (fstat(s->fd, &st)) { in raw_refresh_limits()
1564 if (!fstatfs(s->fd, &buf)) { in raw_refresh_limits()
1565 bs->bl.opt_transfer = buf.f_iosize; in raw_refresh_limits()
1566 bs->bl.pdiscard_alignment = buf.f_bsize; in raw_refresh_limits()
1571 int ret = hdev_get_max_hw_transfer(s->fd, &st); in raw_refresh_limits()
1574 bs->bl.max_hw_transfer = ret; in raw_refresh_limits()
1577 ret = hdev_get_max_segments(s->fd, &st); in raw_refresh_limits()
1579 bs->bl.max_hw_iov = ret; in raw_refresh_limits()
1589 uint32_t ralign = bs->bl.request_alignment; in raw_refresh_limits()
1603 bs->bl.pdiscard_alignment = dalign; in raw_refresh_limits()
1611 if (!s->needs_alignment) { in raw_refresh_limits()
1612 ret = probe_logical_blocksize(s->fd, in raw_refresh_limits()
1613 &bs->bl.pwrite_zeroes_alignment); in raw_refresh_limits()
1615 error_setg_errno(errp, -ret, in raw_refresh_limits()
1633 return -1; in check_for_dasd()
1644 BDRVRawState *s = bs->opaque; in hdev_probe_blocksizes()
1648 if (check_for_dasd(s->fd) < 0) { in hdev_probe_blocksizes()
1650 if (bs->bl.zoned == BLK_Z_NONE) { in hdev_probe_blocksizes()
1651 return -ENOTSUP; in hdev_probe_blocksizes()
1654 ret = probe_logical_blocksize(s->fd, &bsz->log); in hdev_probe_blocksizes()
1658 return probe_physical_blocksize(s->fd, &bsz->phys); in hdev_probe_blocksizes()
1664 * On failure return -errno.
1670 BDRVRawState *s = bs->opaque; in hdev_probe_geometry()
1674 if (check_for_dasd(s->fd) < 0) { in hdev_probe_geometry()
1675 return -ENOTSUP; in hdev_probe_geometry()
1677 if (ioctl(s->fd, HDIO_GETGEO, &ioctl_geo) < 0) { in hdev_probe_geometry()
1678 return -errno; in hdev_probe_geometry()
1683 return -ENOTSUP; in hdev_probe_geometry()
1687 return -ENOTSUP; in hdev_probe_geometry()
1689 geo->heads = ioctl_geo.heads; in hdev_probe_geometry()
1690 geo->sectors = ioctl_geo.sectors; in hdev_probe_geometry()
1691 geo->cylinders = ioctl_geo.cylinders; in hdev_probe_geometry()
1698 return -ENOTSUP; in hdev_probe_geometry()
1709 ioctl(aiocb->aio_fildes, aiocb->ioctl.cmd, aiocb->ioctl.buf) in handle_aiocb_ioctl()
1711 if (ret == -1) { in handle_aiocb_ioctl()
1712 return -errno; in handle_aiocb_ioctl()
1722 BDRVRawState *s = aiocb->bs->opaque; in handle_aiocb_flush()
1725 if (s->page_cache_inconsistent) { in handle_aiocb_flush()
1726 return -s->page_cache_inconsistent; in handle_aiocb_flush()
1729 ret = qemu_fdatasync(aiocb->aio_fildes); in handle_aiocb_flush()
1730 if (ret == -1) { in handle_aiocb_flush()
1737 * on-disk contents. The next fdatasync() call would succeed, but no in handle_aiocb_flush()
1746 if ((s->open_flags & O_DIRECT) == 0) { in handle_aiocb_flush()
1747 s->page_cache_inconsistent = errno; in handle_aiocb_flush()
1749 return -errno; in handle_aiocb_flush()
1777 return -ENOSYS; in qemu_preadv()
1783 return -ENOSYS; in qemu_pwritev()
1793 (aiocb->aio_type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND)) ? in handle_aiocb_rw_vector()
1794 qemu_pwritev(aiocb->aio_fildes, in handle_aiocb_rw_vector()
1795 aiocb->io.iov, in handle_aiocb_rw_vector()
1796 aiocb->io.niov, in handle_aiocb_rw_vector()
1797 aiocb->aio_offset) : in handle_aiocb_rw_vector()
1798 qemu_preadv(aiocb->aio_fildes, in handle_aiocb_rw_vector()
1799 aiocb->io.iov, in handle_aiocb_rw_vector()
1800 aiocb->io.niov, in handle_aiocb_rw_vector()
1801 aiocb->aio_offset) in handle_aiocb_rw_vector()
1804 if (len == -1) { in handle_aiocb_rw_vector()
1805 return -errno; in handle_aiocb_rw_vector()
1813 * Returns the number of bytes handles or -errno in case of an error. Short
1821 while (offset < aiocb->aio_nbytes) { in handle_aiocb_rw_linear()
1822 if (aiocb->aio_type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND)) { in handle_aiocb_rw_linear()
1823 len = pwrite(aiocb->aio_fildes, in handle_aiocb_rw_linear()
1825 aiocb->aio_nbytes - offset, in handle_aiocb_rw_linear()
1826 aiocb->aio_offset + offset); in handle_aiocb_rw_linear()
1828 len = pread(aiocb->aio_fildes, in handle_aiocb_rw_linear()
1830 aiocb->aio_nbytes - offset, in handle_aiocb_rw_linear()
1831 aiocb->aio_offset + offset); in handle_aiocb_rw_linear()
1833 if (len == -1 && errno == EINTR) { in handle_aiocb_rw_linear()
1835 } else if (len == -1 && errno == EINVAL && in handle_aiocb_rw_linear()
1836 (aiocb->bs->open_flags & BDRV_O_NOCACHE) && in handle_aiocb_rw_linear()
1837 !(aiocb->aio_type & QEMU_AIO_WRITE) && in handle_aiocb_rw_linear()
1844 } else if (len == -1) { in handle_aiocb_rw_linear()
1845 offset = -errno; in handle_aiocb_rw_linear()
1862 if (!(aiocb->aio_type & QEMU_AIO_MISALIGNED)) { in handle_aiocb_rw()
1867 if (aiocb->io.niov == 1) { in handle_aiocb_rw()
1868 nbytes = handle_aiocb_rw_linear(aiocb, aiocb->io.iov->iov_base); in handle_aiocb_rw()
1879 if (nbytes == aiocb->aio_nbytes || in handle_aiocb_rw()
1880 (nbytes < 0 && nbytes != -ENOSYS)) { in handle_aiocb_rw()
1897 buf = qemu_try_blockalign(aiocb->bs, aiocb->aio_nbytes); in handle_aiocb_rw()
1899 nbytes = -ENOMEM; in handle_aiocb_rw()
1903 if (aiocb->aio_type & QEMU_AIO_WRITE) { in handle_aiocb_rw()
1907 for (i = 0; i < aiocb->io.niov; ++i) { in handle_aiocb_rw()
1908 memcpy(p, aiocb->io.iov[i].iov_base, aiocb->io.iov[i].iov_len); in handle_aiocb_rw()
1909 p += aiocb->io.iov[i].iov_len; in handle_aiocb_rw()
1911 assert(p - buf == aiocb->aio_nbytes); in handle_aiocb_rw()
1915 if (!(aiocb->aio_type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND))) { in handle_aiocb_rw()
1917 size_t count = aiocb->aio_nbytes, copy; in handle_aiocb_rw()
1920 for (i = 0; i < aiocb->io.niov && count; ++i) { in handle_aiocb_rw()
1922 if (copy > aiocb->io.iov[i].iov_len) { in handle_aiocb_rw()
1923 copy = aiocb->io.iov[i].iov_len; in handle_aiocb_rw()
1925 memcpy(aiocb->io.iov[i].iov_base, p, copy); in handle_aiocb_rw()
1928 count -= copy; in handle_aiocb_rw()
1935 if (nbytes == aiocb->aio_nbytes) { in handle_aiocb_rw()
1937 } else if (nbytes >= 0 && nbytes < aiocb->aio_nbytes) { in handle_aiocb_rw()
1938 if (aiocb->aio_type & QEMU_AIO_WRITE) { in handle_aiocb_rw()
1939 return -EINVAL; in handle_aiocb_rw()
1941 iov_memset(aiocb->io.iov, aiocb->io.niov, nbytes, in handle_aiocb_rw()
1942 0, aiocb->aio_nbytes - nbytes); in handle_aiocb_rw()
1954 if (err == -ENODEV || err == -ENOSYS || err == -EOPNOTSUPP || in translate_err()
1955 err == -ENOTTY) { in translate_err()
1956 err = -ENOTSUP; in translate_err()
1970 return translate_err(-errno); in do_fallocate()
1976 int ret = -ENOTSUP; in handle_aiocb_write_zeroes_block()
1977 BDRVRawState *s = aiocb->bs->opaque; in handle_aiocb_write_zeroes_block()
1979 if (!s->has_write_zeroes) { in handle_aiocb_write_zeroes_block()
1980 return -ENOTSUP; in handle_aiocb_write_zeroes_block()
1987 if (!(aiocb->aio_type & QEMU_AIO_NO_FALLBACK)) { in handle_aiocb_write_zeroes_block()
1989 uint64_t range[2] = { aiocb->aio_offset, aiocb->aio_nbytes }; in handle_aiocb_write_zeroes_block()
1990 if (ioctl(aiocb->aio_fildes, BLKZEROOUT, range) == 0) { in handle_aiocb_write_zeroes_block()
1995 ret = translate_err(-errno); in handle_aiocb_write_zeroes_block()
1996 if (ret == -ENOTSUP) { in handle_aiocb_write_zeroes_block()
1997 s->has_write_zeroes = false; in handle_aiocb_write_zeroes_block()
2009 BDRVRawState *s = aiocb->bs->opaque; in handle_aiocb_write_zeroes()
2013 if (aiocb->aio_type & QEMU_AIO_BLKDEV) { in handle_aiocb_write_zeroes()
2018 if (s->has_write_zeroes) { in handle_aiocb_write_zeroes()
2019 int ret = do_fallocate(s->fd, FALLOC_FL_ZERO_RANGE, in handle_aiocb_write_zeroes()
2020 aiocb->aio_offset, aiocb->aio_nbytes); in handle_aiocb_write_zeroes()
2021 if (ret == -ENOTSUP) { in handle_aiocb_write_zeroes()
2022 s->has_write_zeroes = false; in handle_aiocb_write_zeroes()
2023 } else if (ret == 0 || ret != -EINVAL) { in handle_aiocb_write_zeroes()
2029 * to the man-page of fallocate(). Thus we simply ignore this return in handle_aiocb_write_zeroes()
2036 if (s->has_discard && s->has_fallocate) { in handle_aiocb_write_zeroes()
2037 int ret = do_fallocate(s->fd, in handle_aiocb_write_zeroes()
2039 aiocb->aio_offset, aiocb->aio_nbytes); in handle_aiocb_write_zeroes()
2041 ret = do_fallocate(s->fd, 0, aiocb->aio_offset, aiocb->aio_nbytes); in handle_aiocb_write_zeroes()
2042 if (ret == 0 || ret != -ENOTSUP) { in handle_aiocb_write_zeroes()
2045 s->has_fallocate = false; in handle_aiocb_write_zeroes()
2046 } else if (ret == -EINVAL) { in handle_aiocb_write_zeroes()
2048 * Some file systems like older versions of GPFS do not like un- in handle_aiocb_write_zeroes()
2050 * they should not do it according to the man-page of fallocate(). in handle_aiocb_write_zeroes()
2057 } else if (ret != -ENOTSUP) { in handle_aiocb_write_zeroes()
2060 s->has_discard = false; in handle_aiocb_write_zeroes()
2068 len = raw_getlength(aiocb->bs); in handle_aiocb_write_zeroes()
2069 if (s->has_fallocate && len >= 0 && aiocb->aio_offset >= len) { in handle_aiocb_write_zeroes()
2070 int ret = do_fallocate(s->fd, 0, aiocb->aio_offset, aiocb->aio_nbytes); in handle_aiocb_write_zeroes()
2071 if (ret == 0 || ret != -ENOTSUP) { in handle_aiocb_write_zeroes()
2074 s->has_fallocate = false; in handle_aiocb_write_zeroes()
2078 return -ENOTSUP; in handle_aiocb_write_zeroes()
2084 BDRVRawState *s G_GNUC_UNUSED = aiocb->bs->opaque; in handle_aiocb_write_zeroes_unmap()
2089 int ret = do_fallocate(s->fd, FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE, in handle_aiocb_write_zeroes_unmap()
2090 aiocb->aio_offset, aiocb->aio_nbytes); in handle_aiocb_write_zeroes_unmap()
2092 case -ENOTSUP: in handle_aiocb_write_zeroes_unmap()
2093 case -EINVAL: in handle_aiocb_write_zeroes_unmap()
2094 case -EBUSY: in handle_aiocb_write_zeroes_unmap()
2102 * all-zero afterwards, just write zeroes without unmapping */ in handle_aiocb_write_zeroes_unmap()
2118 return -1; in copy_file_range()
2124 * parse_zone - Fill a zone descriptor
2129 zone->start = blkz->start << BDRV_SECTOR_BITS; in parse_zone()
2130 zone->length = blkz->len << BDRV_SECTOR_BITS; in parse_zone()
2131 zone->wp = blkz->wp << BDRV_SECTOR_BITS; in parse_zone()
2134 zone->cap = blkz->capacity << BDRV_SECTOR_BITS; in parse_zone()
2136 zone->cap = blkz->len << BDRV_SECTOR_BITS; in parse_zone()
2139 switch (blkz->type) { in parse_zone()
2141 zone->type = BLK_ZT_SWR; in parse_zone()
2144 zone->type = BLK_ZT_SWP; in parse_zone()
2147 zone->type = BLK_ZT_CONV; in parse_zone()
2150 error_report("Unsupported zone type: 0x%x", blkz->type); in parse_zone()
2151 return -ENOTSUP; in parse_zone()
2154 switch (blkz->cond) { in parse_zone()
2156 zone->state = BLK_ZS_NOT_WP; in parse_zone()
2159 zone->state = BLK_ZS_EMPTY; in parse_zone()
2162 zone->state = BLK_ZS_IOPEN; in parse_zone()
2165 zone->state = BLK_ZS_EOPEN; in parse_zone()
2168 zone->state = BLK_ZS_CLOSED; in parse_zone()
2171 zone->state = BLK_ZS_RDONLY; in parse_zone()
2174 zone->state = BLK_ZS_FULL; in parse_zone()
2177 zone->state = BLK_ZS_OFFLINE; in parse_zone()
2180 error_report("Unsupported zone state: 0x%x", blkz->cond); in parse_zone()
2181 return -ENOTSUP; in parse_zone()
2191 int fd = aiocb->aio_fildes; in handle_aiocb_zone_report()
2192 unsigned int *nr_zones = aiocb->zone_report.nr_zones; in handle_aiocb_zone_report()
2193 BlockZoneDescriptor *zones = aiocb->zone_report.zones; in handle_aiocb_zone_report()
2194 /* zoned block devices use 512-byte sectors */ in handle_aiocb_zone_report()
2195 uint64_t sector = aiocb->aio_offset / 512; in handle_aiocb_zone_report()
2201 unsigned int n = 0, i = 0; in handle_aiocb_zone_report() local
2209 while (n < nrz) { in handle_aiocb_zone_report()
2211 rep->sector = sector; in handle_aiocb_zone_report()
2212 rep->nr_zones = nrz - n; in handle_aiocb_zone_report()
2220 return -errno; in handle_aiocb_zone_report()
2223 if (!rep->nr_zones) { in handle_aiocb_zone_report()
2227 for (i = 0; i < rep->nr_zones; i++, n++) { in handle_aiocb_zone_report()
2228 ret = parse_zone(&zones[n], &blkz[i]); in handle_aiocb_zone_report()
2238 *nr_zones = n; in handle_aiocb_zone_report()
2247 int fd = aiocb->aio_fildes; in handle_aiocb_zone_mgmt()
2248 uint64_t sector = aiocb->aio_offset / 512; in handle_aiocb_zone_mgmt()
2249 int64_t nr_sectors = aiocb->aio_nbytes / 512; in handle_aiocb_zone_mgmt()
2257 ret = ioctl(fd, aiocb->zone_mgmt.op, &range); in handle_aiocb_zone_mgmt()
2260 return ret < 0 ? -errno : ret; in handle_aiocb_zone_mgmt()
2267 uint64_t bytes = aiocb->aio_nbytes; in handle_aiocb_copy_range()
2268 off_t in_off = aiocb->aio_offset; in handle_aiocb_copy_range()
2269 off_t out_off = aiocb->copy_range.aio_offset2; in handle_aiocb_copy_range()
2272 ssize_t ret = copy_file_range(aiocb->aio_fildes, &in_off, in handle_aiocb_copy_range()
2273 aiocb->copy_range.aio_fd2, &out_off, in handle_aiocb_copy_range()
2275 trace_file_copy_file_range(aiocb->bs, aiocb->aio_fildes, in_off, in handle_aiocb_copy_range()
2276 aiocb->copy_range.aio_fd2, out_off, bytes, in handle_aiocb_copy_range()
2281 return -ENOSPC; in handle_aiocb_copy_range()
2286 return -ENOTSUP; in handle_aiocb_copy_range()
2290 return -errno; in handle_aiocb_copy_range()
2293 bytes -= ret; in handle_aiocb_copy_range()
2301 int ret = -ENOTSUP; in handle_aiocb_discard()
2302 BDRVRawState *s = aiocb->bs->opaque; in handle_aiocb_discard()
2304 if (!s->has_discard) { in handle_aiocb_discard()
2305 return -ENOTSUP; in handle_aiocb_discard()
2308 if (aiocb->aio_type & QEMU_AIO_BLKDEV) { in handle_aiocb_discard()
2311 uint64_t range[2] = { aiocb->aio_offset, aiocb->aio_nbytes }; in handle_aiocb_discard()
2312 if (ioctl(aiocb->aio_fildes, BLKDISCARD, range) == 0) { in handle_aiocb_discard()
2317 ret = translate_err(-errno); in handle_aiocb_discard()
2321 ret = do_fallocate(s->fd, FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE, in handle_aiocb_discard()
2322 aiocb->aio_offset, aiocb->aio_nbytes); in handle_aiocb_discard()
2328 fpunchhole.fp_offset = aiocb->aio_offset; in handle_aiocb_discard()
2329 fpunchhole.fp_length = aiocb->aio_nbytes; in handle_aiocb_discard()
2330 if (fcntl(s->fd, F_PUNCHHOLE, &fpunchhole) == -1) { in handle_aiocb_discard()
2331 ret = errno == ENODEV ? -ENOTSUP : -errno; in handle_aiocb_discard()
2338 if (ret == -ENOTSUP) { in handle_aiocb_discard()
2339 s->has_discard = false; in handle_aiocb_discard()
2355 * Returns: 0 on success, -errno on failure. Since this is an optimization,
2365 ssize_t n; in allocate_first_block() local
2371 n = RETRY_ON_EINTR(pwrite(fd, buf, write_size, 0)); in allocate_first_block()
2373 ret = (n == -1) ? -errno : 0; in allocate_first_block()
2386 int fd = aiocb->aio_fildes; in handle_aiocb_truncate()
2387 int64_t offset = aiocb->aio_offset; in handle_aiocb_truncate()
2388 PreallocMode prealloc = aiocb->truncate.prealloc; in handle_aiocb_truncate()
2389 Error **errp = aiocb->truncate.errp; in handle_aiocb_truncate()
2392 result = -errno; in handle_aiocb_truncate()
2393 error_setg_errno(errp, -result, "Could not stat file"); in handle_aiocb_truncate()
2400 return -ENOTSUP; in handle_aiocb_truncate()
2412 result = -posix_fallocate(fd, current_length, in handle_aiocb_truncate()
2413 offset - current_length); in handle_aiocb_truncate()
2416 error_setg_errno(errp, -result, in handle_aiocb_truncate()
2437 int64_t num = 0, left = offset - current_length; in handle_aiocb_truncate()
2446 result = -errno; in handle_aiocb_truncate()
2447 error_setg_errno(errp, -result, "Could not resize file"); in handle_aiocb_truncate()
2455 result = -errno; in handle_aiocb_truncate()
2456 error_setg_errno(errp, -result, in handle_aiocb_truncate()
2468 result = -errno; in handle_aiocb_truncate()
2469 error_setg_errno(errp, -result, in handle_aiocb_truncate()
2473 left -= result; in handle_aiocb_truncate()
2478 result = -errno; in handle_aiocb_truncate()
2479 error_setg_errno(errp, -result, in handle_aiocb_truncate()
2488 result = -errno; in handle_aiocb_truncate()
2489 error_setg_errno(errp, -result, "Could not resize file"); in handle_aiocb_truncate()
2496 result = -ENOTSUP; in handle_aiocb_truncate()
2526 size_t len = bs->bl.request_alignment; in bdrv_qiov_is_aligned()
2529 for (i = 0; i < qiov->niov; i++) { in bdrv_qiov_is_aligned()
2530 if ((uintptr_t) qiov->iov[i].iov_base % alignment) { in bdrv_qiov_is_aligned()
2533 if (qiov->iov[i].iov_len % len) { in bdrv_qiov_is_aligned()
2547 if (!s->use_linux_io_uring) { in raw_check_linux_io_uring()
2555 s->use_linux_io_uring = false; in raw_check_linux_io_uring()
2568 if (!s->use_linux_aio) { in raw_check_linux_aio()
2576 s->use_linux_aio = false; in raw_check_linux_aio()
2587 BDRVRawState *s = bs->opaque; in raw_co_prw()
2593 return -EIO; in raw_co_prw()
2596 bs->bl.zoned != BLK_Z_NONE) { in raw_co_prw()
2597 qemu_co_mutex_lock(&bs->wps->colock); in raw_co_prw()
2599 int index = offset / bs->bl.zone_size; in raw_co_prw()
2600 offset = bs->wps->wp[index]; in raw_co_prw()
2611 if (s->needs_alignment && !bdrv_qiov_is_aligned(bs, qiov)) { in raw_co_prw()
2615 assert(qiov->size == bytes); in raw_co_prw()
2616 ret = luring_co_submit(bs, s->fd, offset, qiov, type, flags); in raw_co_prw()
2621 assert(qiov->size == bytes); in raw_co_prw()
2622 ret = laio_co_submit(s->fd, offset, qiov, type, flags, in raw_co_prw()
2623 s->aio_max_batch); in raw_co_prw()
2630 .aio_fildes = s->fd, in raw_co_prw()
2635 .iov = qiov->iov, in raw_co_prw()
2636 .niov = qiov->niov, in raw_co_prw()
2640 assert(qiov->size == bytes); in raw_co_prw()
2651 bs->bl.zoned != BLK_Z_NONE) { in raw_co_prw()
2652 BlockZoneWps *wps = bs->wps; in raw_co_prw()
2654 uint64_t *wp = &wps->wp[offset / bs->bl.zone_size]; in raw_co_prw()
2670 update_zones_wp(bs, s->fd, offset, 1); in raw_co_prw()
2673 qemu_co_mutex_unlock(&wps->colock); in raw_co_prw()
2695 BDRVRawState *s = bs->opaque; in raw_co_flush_to_disk()
2706 .aio_fildes = s->fd, in raw_co_flush_to_disk()
2712 return luring_co_submit(bs, s->fd, 0, NULL, QEMU_AIO_FLUSH, 0); in raw_co_flush_to_disk()
2716 if (s->has_laio_fdsync && raw_check_linux_aio(s)) { in raw_co_flush_to_disk()
2717 return laio_co_submit(s->fd, 0, NULL, QEMU_AIO_FLUSH, 0, 0); in raw_co_flush_to_disk()
2725 BDRVRawState *s = bs->opaque; in raw_close()
2727 if (s->fd >= 0) { in raw_close()
2729 g_free(bs->wps); in raw_close()
2731 qemu_close(s->fd); in raw_close()
2732 s->fd = -1; in raw_close()
2740 * Returns: 0 on success, -errno on failure.
2766 BDRVRawState *s = bs->opaque; in raw_co_truncate()
2770 if (fstat(s->fd, &st)) { in raw_co_truncate()
2771 ret = -errno; in raw_co_truncate()
2772 error_setg_errno(errp, -ret, "Failed to fstat() the file"); in raw_co_truncate()
2778 return raw_regular_truncate(bs, s->fd, offset, prealloc, errp); in raw_co_truncate()
2783 "non-regular file", PreallocMode_str(prealloc)); in raw_co_truncate()
2784 return -ENOTSUP; in raw_co_truncate()
2792 return -ENOTSUP; in raw_co_truncate()
2795 return -EINVAL; in raw_co_truncate()
2799 return -ENOTSUP; in raw_co_truncate()
2808 BDRVRawState *s = bs->opaque; in raw_getlength()
2809 int fd = s->fd; in raw_getlength()
2813 return -errno; in raw_getlength()
2818 return -errno; in raw_getlength()
2827 BDRVRawState *s = bs->opaque; in raw_getlength()
2828 int fd = s->fd; in raw_getlength()
2832 return -errno; in raw_getlength()
2836 if (ioctl(fd, DIOCGWEDGEINFO, &dkw) != -1) { in raw_getlength()
2842 return -errno; in raw_getlength()
2852 BDRVRawState *s = bs->opaque; in raw_getlength()
2865 ret = ioctl(s->fd, DKIOCGMEDIAINFO, &minfo); in raw_getlength()
2866 if (ret != -1) { in raw_getlength()
2874 size = lseek(s->fd, 0, SEEK_END); in raw_getlength()
2876 return -errno; in raw_getlength()
2883 BDRVRawState *s = bs->opaque; in raw_getlength()
2884 int fd = s->fd; in raw_getlength()
2929 return -errno; in raw_getlength()
2932 switch(s->type) { in raw_getlength()
2935 if (size == 2048LL * (unsigned)-1) in raw_getlength()
2947 return -errno; in raw_getlength()
2955 BDRVRawState *s = bs->opaque; in raw_getlength()
2964 size = lseek(s->fd, 0, SEEK_END); in raw_getlength()
2966 return -errno; in raw_getlength()
2980 BDRVRawState *s = bs->opaque; in raw_co_get_allocated_file_size()
2982 if (fstat(s->fd, &st) < 0) { in raw_co_get_allocated_file_size()
2983 return -errno; in raw_co_get_allocated_file_size()
2998 assert(options->driver == BLOCKDEV_DRIVER_FILE); in raw_co_create()
2999 file_opts = &options->u.file; in raw_co_create()
3001 if (!file_opts->has_nocow) { in raw_co_create()
3002 file_opts->nocow = false; in raw_co_create()
3004 if (!file_opts->has_preallocation) { in raw_co_create()
3005 file_opts->preallocation = PREALLOC_MODE_OFF; in raw_co_create()
3007 if (!file_opts->has_extent_size_hint) { in raw_co_create()
3008 file_opts->extent_size_hint = 1 * MiB; in raw_co_create()
3010 if (file_opts->extent_size_hint > UINT32_MAX) { in raw_co_create()
3011 result = -EINVAL; in raw_co_create()
3017 fd = qemu_create(file_opts->filename, O_RDWR | O_BINARY, 0644, errp); in raw_co_create()
3019 result = -errno; in raw_co_create()
3027 * because we promise that after this function, the file has the in raw_co_create()
3030 * Note that after this function, we can no longer guarantee that in raw_co_create()
3046 "Is another process using the image [%s]?\n", in raw_co_create()
3047 file_opts->filename); in raw_co_create()
3057 if (file_opts->nocow) { in raw_co_create()
3081 attr.fsx_extsize = file_opts->extent_size_hint; in raw_co_create()
3084 if (result < 0 && file_opts->has_extent_size_hint && in raw_co_create()
3085 file_opts->extent_size_hint) in raw_co_create()
3095 result = raw_regular_truncate(NULL, fd, file_opts->size, in raw_co_create()
3096 file_opts->preallocation, errp); in raw_co_create()
3113 result = -errno; in raw_co_create()
3114 error_setg_errno(errp, -result, "Could not close the new file"); in raw_co_create()
3142 qemu_opt_get_size_del(opts, BLOCK_OPT_EXTENT_SIZE_HINT, -1); in raw_co_create_opts()
3151 return -EINVAL; in raw_co_create_opts()
3176 if (!(stat(bs->filename, &st) == 0) || !S_ISREG(st.st_mode)) { in raw_co_delete_file()
3178 bs->filename); in raw_co_delete_file()
3179 return -ENOENT; in raw_co_delete_file()
3182 ret = unlink(bs->filename); in raw_co_delete_file()
3184 ret = -errno; in raw_co_delete_file()
3185 error_setg_errno(errp, -ret, "Error when deleting file %s", in raw_co_delete_file()
3186 bs->filename); in raw_co_delete_file()
3197 * If @start is in a non-trailing hole, store @start in @hole and the
3198 * beginning of the next non-hole in @data, and return 0.
3199 * If @start is in a trailing hole or beyond EOF, return -ENXIO.
3200 * If we can't find out, return a negative errno other than -ENXIO.
3206 BDRVRawState *s = bs->opaque; in find_allocation()
3220 offs = lseek(s->fd, start, SEEK_DATA); in find_allocation()
3222 return -errno; /* D3 or D4 */ in find_allocation()
3227 * -EIO in this case, and we'll treat it like D4. */ in find_allocation()
3228 return -EIO; in find_allocation()
3257 offs = lseek(s->fd, start, SEEK_HOLE); in find_allocation()
3259 return -errno; /* D1 and (H3 or H4) */ in find_allocation()
3264 * -EIO in this case, and we'll treat it like H4. */ in find_allocation()
3265 return -EIO; in find_allocation()
3281 return -EBUSY; in find_allocation()
3283 return -ENOTSUP; in find_allocation()
3309 assert(QEMU_IS_ALIGNED(offset | bytes, bs->bl.request_alignment)); in raw_co_block_status()
3317 /* There is no backing file - all bytes are allocated in this file. */ in raw_co_block_status()
3325 if (ret == -ENXIO) { in raw_co_block_status()
3336 *pnum = hole - offset; in raw_co_block_status()
3342 if (!QEMU_IS_ALIGNED(*pnum, bs->bl.request_alignment)) { in raw_co_block_status()
3348 *pnum = ROUND_UP(*pnum, bs->bl.request_alignment); in raw_co_block_status()
3355 *pnum = data - offset; in raw_co_block_status()
3368 BDRVRawState *s = bs->opaque; in check_cache_dropped()
3390 new_length = MIN(end - offset, window_size); in check_cache_dropped()
3398 s->fd, offset); in check_cache_dropped()
3436 BDRVRawState *s = bs->opaque; in raw_co_invalidate_cache()
3441 error_setg_errno(errp, -ret, "The file descriptor is not open"); in raw_co_invalidate_cache()
3445 if (!s->drop_cache) { in raw_co_invalidate_cache()
3449 if (s->open_flags & O_DIRECT) { in raw_co_invalidate_cache()
3457 error_setg_errno(errp, -ret, "flush failed"); in raw_co_invalidate_cache()
3465 ret = posix_fadvise(s->fd, 0, 0, POSIX_FADV_DONTNEED); in raw_co_invalidate_cache()
3471 if (s->check_cache_dropped) { in raw_co_invalidate_cache()
3487 s->stats.discard_nb_failed++; in raw_account_discard()
3489 s->stats.discard_nb_ok++; in raw_account_discard()
3490 s->stats.discard_bytes_ok += nbytes; in raw_account_discard()
3495 * zone report - Get a zone block device's information in the form
3505 BDRVRawState *s = bs->opaque; in raw_co_zone_report()
3508 .aio_fildes = s->fd, in raw_co_zone_report()
3523 * zone management operations - Execute an operation on a zone
3528 BDRVRawState *s = bs->opaque; in raw_co_zone_mgmt()
3534 BlockZoneWps *wps = bs->wps; in raw_co_zone_mgmt()
3535 int64_t capacity = bs->total_sectors << BDRV_SECTOR_BITS; in raw_co_zone_mgmt()
3537 zone_size = bs->bl.zone_size; in raw_co_zone_mgmt()
3538 zone_size_mask = zone_size - 1; in raw_co_zone_mgmt()
3542 return -EINVAL; in raw_co_zone_mgmt()
3549 return -EINVAL; in raw_co_zone_mgmt()
3552 uint32_t i = offset / bs->bl.zone_size; in raw_co_zone_mgmt()
3553 uint32_t nrz = len / bs->bl.zone_size; in raw_co_zone_mgmt()
3554 uint64_t *wp = &wps->wp[i]; in raw_co_zone_mgmt()
3557 return -EIO; in raw_co_zone_mgmt()
3579 return -ENOTSUP; in raw_co_zone_mgmt()
3584 .aio_fildes = s->fd, in raw_co_zone_mgmt()
3597 update_zones_wp(bs, s->fd, offset, nrz); in raw_co_zone_mgmt()
3603 ret = get_zones_wp(bs, s->fd, 0, bs->bl.nr_zones, 1); in raw_co_zone_mgmt()
3631 int64_t zone_size_mask = bs->bl.zone_size - 1; in raw_co_zone_append()
3637 "%" PRId32 "", *offset / 512, bs->bl.zone_size / 512); in raw_co_zone_append()
3638 return -EINVAL; in raw_co_zone_append()
3641 int64_t wg = bs->bl.write_granularity; in raw_co_zone_append()
3642 int64_t wg_mask = wg - 1; in raw_co_zone_append()
3643 for (int i = 0; i < qiov->niov; i++) { in raw_co_zone_append()
3644 iov_len = qiov->iov[i].iov_len; in raw_co_zone_append()
3648 return -EINVAL; in raw_co_zone_append()
3662 BDRVRawState *s = bs->opaque; in raw_do_pdiscard()
3668 .aio_fildes = s->fd, in raw_do_pdiscard()
3693 BDRVRawState *s = bs->opaque; in raw_do_pwrite_zeroes()
3698 if (offset + bytes > bs->total_sectors * BDRV_SECTOR_SIZE) { in raw_do_pwrite_zeroes()
3712 * We have to enable this workaround for all filesystems and in raw_do_pwrite_zeroes()
3719 assert(req->type == BDRV_TRACKED_WRITE); in raw_do_pwrite_zeroes()
3720 assert(req->offset <= offset); in raw_do_pwrite_zeroes()
3721 assert(req->offset + req->bytes >= offset + bytes); in raw_do_pwrite_zeroes()
3723 req->bytes = BDRV_MAX_LENGTH - req->offset; in raw_do_pwrite_zeroes()
3725 bdrv_check_request(req->offset, req->bytes, &error_abort); in raw_do_pwrite_zeroes()
3727 bdrv_make_request_serialising(req, bs->bl.request_alignment); in raw_do_pwrite_zeroes()
3733 .aio_fildes = s->fd, in raw_do_pwrite_zeroes()
3782 BDRVRawState *s = bs->opaque; in raw_get_specific_info()
3786 ret = ioctl(s->fd, FS_IOC_FSGETXATTR, &attr); in raw_get_specific_info()
3788 file_info->has_extent_size_hint = true; in raw_get_specific_info()
3789 file_info->extent_size_hint = attr.fsx_extsize; in raw_get_specific_info()
3799 BDRVRawState *s = bs->opaque; in get_blockstats_specific_file()
3801 .discard_nb_ok = s->stats.discard_nb_ok, in get_blockstats_specific_file()
3802 .discard_nb_failed = s->stats.discard_nb_failed, in get_blockstats_specific_file()
3803 .discard_bytes_ok = s->stats.discard_bytes_ok, in get_blockstats_specific_file()
3811 stats->driver = BLOCKDEV_DRIVER_FILE; in raw_get_specific_stats()
3812 stats->u.file = get_blockstats_specific_file(bs); in raw_get_specific_stats()
3822 stats->driver = BLOCKDEV_DRIVER_HOST_DEVICE; in hdev_get_specific_stats()
3823 stats->u.host_device = get_blockstats_specific_file(bs); in hdev_get_specific_stats()
3830 .name = "raw-create-opts",
3841 .help = "Turn off copy-on-write (valid only on btrfs)"
3864 BDRVRawState *s = bs->opaque; in raw_check_perm()
3865 int input_flags = s->reopen_state ? s->reopen_state->flags : bs->open_flags; in raw_check_perm()
3869 /* We may need a new fd if auto-read-only switches the mode */ in raw_check_perm()
3873 } else if (ret != s->fd) { in raw_check_perm()
3883 return -EINVAL; in raw_check_perm()
3886 s->perm_change_fd = ret; in raw_check_perm()
3887 s->perm_change_flags = open_flags; in raw_check_perm()
3898 if (s->perm_change_fd && s->use_lock) { in raw_check_perm()
3899 ret = raw_apply_lock_bytes(NULL, s->perm_change_fd, perm, ~shared, in raw_check_perm()
3909 if (s->perm_change_fd) { in raw_check_perm()
3910 qemu_close(s->perm_change_fd); in raw_check_perm()
3912 s->perm_change_fd = 0; in raw_check_perm()
3918 BDRVRawState *s = bs->opaque; in raw_set_perm()
3922 if (s->perm_change_fd && s->fd != s->perm_change_fd) { in raw_set_perm()
3923 qemu_close(s->fd); in raw_set_perm()
3924 s->fd = s->perm_change_fd; in raw_set_perm()
3925 s->open_flags = s->perm_change_flags; in raw_set_perm()
3927 s->perm_change_fd = 0; in raw_set_perm()
3930 s->perm = perm; in raw_set_perm()
3931 s->shared_perm = shared; in raw_set_perm()
3936 BDRVRawState *s = bs->opaque; in raw_abort_perm_update()
3940 if (s->perm_change_fd) { in raw_abort_perm_update()
3941 qemu_close(s->perm_change_fd); in raw_abort_perm_update()
3943 s->perm_change_fd = 0; in raw_abort_perm_update()
3965 BDRVRawState *s = bs->opaque; in raw_co_copy_range_to()
3968 assert(dst->bs == bs); in raw_co_copy_range_to()
3969 if (src->bs->drv->bdrv_co_copy_range_to != raw_co_copy_range_to) { in raw_co_copy_range_to()
3970 return -ENOTSUP; in raw_co_copy_range_to()
3973 src_s = src->bs->opaque; in raw_co_copy_range_to()
3974 if (fd_open(src->bs) < 0 || fd_open(dst->bs) < 0) { in raw_co_copy_range_to()
3975 return -EIO; in raw_co_copy_range_to()
3981 .aio_fildes = src_s->fd, in raw_co_copy_range_to()
3985 .aio_fd2 = s->fd, in raw_co_copy_range_to()
4053 printf("IOMainPort returned %d\n", kernResult); in FindEjectableOpticalMedia()
4102 …if ( CFStringGetCString( bsdPathAsCFString, bsdPath + devPathLength, maxPathSize - devPathLength, … in GetBSDPath()
4158 /* allow a dedicated CD-ROM driver to match with a higher priority */ in hdev_probe_device()
4181 BDRVRawState *s = bs->opaque; in hdev_is_sg()
4187 if (stat(bs->filename, &st) < 0 || !S_ISCHR(st.st_mode)) { in hdev_is_sg()
4191 ret = ioctl(s->fd, SG_GET_VERSION_NUM, &sg_version); in hdev_is_sg()
4196 ret = ioctl(s->fd, SG_GET_SCSI_ID, &scsiid); in hdev_is_sg()
4210 BDRVRawState *s = bs->opaque; in hdev_open()
4215 * Caution: while qdict_get_str() is fine, getting non-string types in hdev_open()
4216 * would require more care. When @options come from -blockdev or in hdev_open()
4218 * schema, but when they come from -drive, they're all QString. in hdev_open()
4268 return -ENOENT; in hdev_open()
4273 s->type = FTYPE_FILE; in hdev_open()
4290 bs->sg = hdev_is_sg(bs); in hdev_open()
4292 /* sg devices aren't even block devices and can't use dm-mpath */ in hdev_open()
4293 s->use_mpath = !bs->sg; in hdev_open()
4304 case -ENODEV: in sgio_path_error()
4306 case -EAGAIN: in sgio_path_error()
4324 if (io_hdr->host_status != SCSI_HOST_OK) { in sgio_path_error()
4328 switch (io_hdr->status) { in sgio_path_error()
4337 return !scsi_sense_buf_is_guest_recoverable(io_hdr->sbp, in sgio_path_error()
4338 io_hdr->mx_sb_len); in sgio_path_error()
4346 BDRVRawState *s = acb->bs->opaque; in hdev_co_ioctl_sgio_retry()
4349 if (!s->use_mpath) { in hdev_co_ioctl_sgio_retry()
4353 if (!sgio_path_error(ret, acb->ioctl.buf)) { in hdev_co_ioctl_sgio_retry()
4358 .bs = acb->bs, in hdev_co_ioctl_sgio_retry()
4360 .aio_fildes = s->fd, in hdev_co_ioctl_sgio_retry()
4369 if (ret == -ENOTTY) { in hdev_co_ioctl_sgio_retry()
4370 s->use_mpath = false; in hdev_co_ioctl_sgio_retry()
4371 } else if (ret == -EAGAIN) { in hdev_co_ioctl_sgio_retry()
4388 BDRVRawState *s = bs->opaque; in hdev_co_ioctl()
4398 if (req == SG_IO && s->pr_mgr) { in hdev_co_ioctl()
4400 if (io_hdr->cmdp[0] == PERSISTENT_RESERVE_OUT || in hdev_co_ioctl()
4401 io_hdr->cmdp[0] == PERSISTENT_RESERVE_IN) { in hdev_co_ioctl()
4402 return pr_manager_execute(s->pr_mgr, qemu_get_current_aio_context(), in hdev_co_ioctl()
4403 s->fd, io_hdr); in hdev_co_ioctl()
4410 .aio_fildes = s->fd, in hdev_co_ioctl()
4420 } while (req == SG_IO && retries-- && hdev_co_ioctl_sgio_retry(&acb, ret)); in hdev_co_ioctl()
4429 BDRVRawState *s = bs->opaque; in hdev_co_pdiscard()
4514 bs->bl.has_variable_length = true; in cdrom_refresh_limits()
4523 BDRVRawState *s = bs->opaque; in cdrom_open()
4525 s->type = FTYPE_CD; in cdrom_open()
4542 if (ret == -1 || !S_ISBLK(st.st_mode)) { in cdrom_probe_device()
4546 /* Attempt to detect via a CDROM specific ioctl */ in cdrom_probe_device()
4559 BDRVRawState *s = bs->opaque; in cdrom_co_is_inserted()
4562 ret = ioctl(s->fd, CDROM_DRIVE_STATUS, CDSL_CURRENT); in cdrom_co_is_inserted()
4568 BDRVRawState *s = bs->opaque; in cdrom_co_eject()
4571 if (ioctl(s->fd, CDROMEJECT, NULL) < 0) in cdrom_co_eject()
4574 if (ioctl(s->fd, CDROMCLOSETRAY, NULL) < 0) in cdrom_co_eject()
4581 BDRVRawState *s = bs->opaque; in cdrom_co_lock_medium()
4583 if (ioctl(s->fd, CDROM_LOCKDOOR, locked) < 0) { in cdrom_co_lock_medium()
4586 * mounts the CD-ROM in cdrom_co_lock_medium()
4632 BDRVRawState *s = bs->opaque; in cdrom_open()
4635 s->type = FTYPE_CD; in cdrom_open()
4643 ioctl(s->fd, CDIOCALLOW); in cdrom_open()
4657 BDRVRawState *s = bs->opaque; in cdrom_reopen()
4664 if (s->fd >= 0) in cdrom_reopen()
4665 qemu_close(s->fd); in cdrom_reopen()
4666 fd = qemu_open(bs->filename, s->open_flags, NULL); in cdrom_reopen()
4668 s->fd = -1; in cdrom_reopen()
4669 return -EIO; in cdrom_reopen()
4671 s->fd = fd; in cdrom_reopen()
4674 ioctl(s->fd, CDIOCALLOW); in cdrom_reopen()
4685 BDRVRawState *s = bs->opaque; in cdrom_co_eject()
4687 if (s->fd < 0) in cdrom_co_eject()
4690 (void) ioctl(s->fd, CDIOCALLOW); in cdrom_co_eject()
4693 if (ioctl(s->fd, CDIOCEJECT) < 0) in cdrom_co_eject()
4696 if (ioctl(s->fd, CDIOCCLOSE) < 0) in cdrom_co_eject()
4705 BDRVRawState *s = bs->opaque; in cdrom_co_lock_medium()
4707 if (s->fd < 0) in cdrom_co_lock_medium()
4709 if (ioctl(s->fd, (locked ? CDIOCPREVENT : CDIOCALLOW)) < 0) { in cdrom_co_lock_medium()
4712 * mounts the CD-ROM in cdrom_co_lock_medium()