Lines Matching +full:- +full:- +full:disable +full:- +full:attr
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()
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()
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()
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()
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()
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()
876 locked_perm = s->locked_perm; in raw_apply_lock_bytes()
877 locked_shared_perm = s->locked_shared_perm; 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()
971 raw_lock_error_setg_errno(errp, -ret, 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()
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()
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()
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()
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()
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()
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()
1617 return -1; in check_for_dasd()
1628 BDRVRawState *s = bs->opaque; in hdev_probe_blocksizes()
1632 if (check_for_dasd(s->fd) < 0) { in hdev_probe_blocksizes()
1634 if (bs->bl.zoned == BLK_Z_NONE) { in hdev_probe_blocksizes()
1635 return -ENOTSUP; in hdev_probe_blocksizes()
1638 ret = probe_logical_blocksize(s->fd, &bsz->log); in hdev_probe_blocksizes()
1642 return probe_physical_blocksize(s->fd, &bsz->phys); in hdev_probe_blocksizes()
1648 * On failure return -errno.
1654 BDRVRawState *s = bs->opaque; in hdev_probe_geometry()
1658 if (check_for_dasd(s->fd) < 0) { in hdev_probe_geometry()
1659 return -ENOTSUP; in hdev_probe_geometry()
1661 if (ioctl(s->fd, HDIO_GETGEO, &ioctl_geo) < 0) { in hdev_probe_geometry()
1662 return -errno; in hdev_probe_geometry()
1667 return -ENOTSUP; in hdev_probe_geometry()
1671 return -ENOTSUP; in hdev_probe_geometry()
1673 geo->heads = ioctl_geo.heads; in hdev_probe_geometry()
1674 geo->sectors = ioctl_geo.sectors; in hdev_probe_geometry()
1675 geo->cylinders = ioctl_geo.cylinders; in hdev_probe_geometry()
1682 return -ENOTSUP; in hdev_probe_geometry()
1693 ioctl(aiocb->aio_fildes, aiocb->ioctl.cmd, aiocb->ioctl.buf) in handle_aiocb_ioctl()
1695 if (ret == -1) { in handle_aiocb_ioctl()
1696 return -errno; in handle_aiocb_ioctl()
1706 BDRVRawState *s = aiocb->bs->opaque; in handle_aiocb_flush()
1709 if (s->page_cache_inconsistent) { in handle_aiocb_flush()
1710 return -s->page_cache_inconsistent; in handle_aiocb_flush()
1713 ret = qemu_fdatasync(aiocb->aio_fildes); in handle_aiocb_flush()
1714 if (ret == -1) { in handle_aiocb_flush()
1721 * on-disk contents. The next fdatasync() call would succeed, but no in handle_aiocb_flush()
1730 if ((s->open_flags & O_DIRECT) == 0) { in handle_aiocb_flush()
1731 s->page_cache_inconsistent = errno; in handle_aiocb_flush()
1733 return -errno; in handle_aiocb_flush()
1761 return -ENOSYS; in qemu_preadv()
1767 return -ENOSYS; in qemu_pwritev()
1777 (aiocb->aio_type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND)) ? in handle_aiocb_rw_vector()
1778 qemu_pwritev(aiocb->aio_fildes, in handle_aiocb_rw_vector()
1779 aiocb->io.iov, in handle_aiocb_rw_vector()
1780 aiocb->io.niov, in handle_aiocb_rw_vector()
1781 aiocb->aio_offset) : in handle_aiocb_rw_vector()
1782 qemu_preadv(aiocb->aio_fildes, in handle_aiocb_rw_vector()
1783 aiocb->io.iov, in handle_aiocb_rw_vector()
1784 aiocb->io.niov, in handle_aiocb_rw_vector()
1785 aiocb->aio_offset) in handle_aiocb_rw_vector()
1788 if (len == -1) { in handle_aiocb_rw_vector()
1789 return -errno; in handle_aiocb_rw_vector()
1797 * Returns the number of bytes handles or -errno in case of an error. Short
1805 while (offset < aiocb->aio_nbytes) { in handle_aiocb_rw_linear()
1806 if (aiocb->aio_type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND)) { in handle_aiocb_rw_linear()
1807 len = pwrite(aiocb->aio_fildes, in handle_aiocb_rw_linear()
1809 aiocb->aio_nbytes - offset, in handle_aiocb_rw_linear()
1810 aiocb->aio_offset + offset); in handle_aiocb_rw_linear()
1812 len = pread(aiocb->aio_fildes, in handle_aiocb_rw_linear()
1814 aiocb->aio_nbytes - offset, in handle_aiocb_rw_linear()
1815 aiocb->aio_offset + offset); in handle_aiocb_rw_linear()
1817 if (len == -1 && errno == EINTR) { in handle_aiocb_rw_linear()
1819 } else if (len == -1 && errno == EINVAL && in handle_aiocb_rw_linear()
1820 (aiocb->bs->open_flags & BDRV_O_NOCACHE) && in handle_aiocb_rw_linear()
1821 !(aiocb->aio_type & QEMU_AIO_WRITE) && in handle_aiocb_rw_linear()
1828 } else if (len == -1) { in handle_aiocb_rw_linear()
1829 offset = -errno; in handle_aiocb_rw_linear()
1846 if (!(aiocb->aio_type & QEMU_AIO_MISALIGNED)) { in handle_aiocb_rw()
1851 if (aiocb->io.niov == 1) { in handle_aiocb_rw()
1852 nbytes = handle_aiocb_rw_linear(aiocb, aiocb->io.iov->iov_base); in handle_aiocb_rw()
1863 if (nbytes == aiocb->aio_nbytes || in handle_aiocb_rw()
1864 (nbytes < 0 && nbytes != -ENOSYS)) { in handle_aiocb_rw()
1881 buf = qemu_try_blockalign(aiocb->bs, aiocb->aio_nbytes); in handle_aiocb_rw()
1883 nbytes = -ENOMEM; in handle_aiocb_rw()
1887 if (aiocb->aio_type & QEMU_AIO_WRITE) { in handle_aiocb_rw()
1891 for (i = 0; i < aiocb->io.niov; ++i) { in handle_aiocb_rw()
1892 memcpy(p, aiocb->io.iov[i].iov_base, aiocb->io.iov[i].iov_len); in handle_aiocb_rw()
1893 p += aiocb->io.iov[i].iov_len; in handle_aiocb_rw()
1895 assert(p - buf == aiocb->aio_nbytes); in handle_aiocb_rw()
1899 if (!(aiocb->aio_type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND))) { in handle_aiocb_rw()
1901 size_t count = aiocb->aio_nbytes, copy; in handle_aiocb_rw()
1904 for (i = 0; i < aiocb->io.niov && count; ++i) { in handle_aiocb_rw()
1906 if (copy > aiocb->io.iov[i].iov_len) { in handle_aiocb_rw()
1907 copy = aiocb->io.iov[i].iov_len; in handle_aiocb_rw()
1909 memcpy(aiocb->io.iov[i].iov_base, p, copy); in handle_aiocb_rw()
1912 count -= copy; in handle_aiocb_rw()
1919 if (nbytes == aiocb->aio_nbytes) { in handle_aiocb_rw()
1921 } else if (nbytes >= 0 && nbytes < aiocb->aio_nbytes) { in handle_aiocb_rw()
1922 if (aiocb->aio_type & QEMU_AIO_WRITE) { in handle_aiocb_rw()
1923 return -EINVAL; in handle_aiocb_rw()
1925 iov_memset(aiocb->io.iov, aiocb->io.niov, nbytes, in handle_aiocb_rw()
1926 0, aiocb->aio_nbytes - nbytes); in handle_aiocb_rw()
1938 if (err == -ENODEV || err == -ENOSYS || err == -EOPNOTSUPP || in translate_err()
1939 err == -ENOTTY) { in translate_err()
1940 err = -ENOTSUP; in translate_err()
1954 return translate_err(-errno); in do_fallocate()
1960 int ret = -ENOTSUP; in handle_aiocb_write_zeroes_block()
1961 BDRVRawState *s = aiocb->bs->opaque; in handle_aiocb_write_zeroes_block()
1963 if (!s->has_write_zeroes) { in handle_aiocb_write_zeroes_block()
1964 return -ENOTSUP; in handle_aiocb_write_zeroes_block()
1971 if (!(aiocb->aio_type & QEMU_AIO_NO_FALLBACK)) { in handle_aiocb_write_zeroes_block()
1973 uint64_t range[2] = { aiocb->aio_offset, aiocb->aio_nbytes }; in handle_aiocb_write_zeroes_block()
1974 if (ioctl(aiocb->aio_fildes, BLKZEROOUT, range) == 0) { in handle_aiocb_write_zeroes_block()
1979 ret = translate_err(-errno); in handle_aiocb_write_zeroes_block()
1980 if (ret == -ENOTSUP) { in handle_aiocb_write_zeroes_block()
1981 s->has_write_zeroes = false; in handle_aiocb_write_zeroes_block()
1993 BDRVRawState *s = aiocb->bs->opaque; in handle_aiocb_write_zeroes()
1997 if (aiocb->aio_type & QEMU_AIO_BLKDEV) { in handle_aiocb_write_zeroes()
2002 if (s->has_write_zeroes) { in handle_aiocb_write_zeroes()
2003 int ret = do_fallocate(s->fd, FALLOC_FL_ZERO_RANGE, in handle_aiocb_write_zeroes()
2004 aiocb->aio_offset, aiocb->aio_nbytes); in handle_aiocb_write_zeroes()
2005 if (ret == -ENOTSUP) { in handle_aiocb_write_zeroes()
2006 s->has_write_zeroes = false; in handle_aiocb_write_zeroes()
2007 } else if (ret == 0 || ret != -EINVAL) { in handle_aiocb_write_zeroes()
2013 * to the man-page of fallocate(). Thus we simply ignore this return in handle_aiocb_write_zeroes()
2020 if (s->has_discard && s->has_fallocate) { in handle_aiocb_write_zeroes()
2021 int ret = do_fallocate(s->fd, in handle_aiocb_write_zeroes()
2023 aiocb->aio_offset, aiocb->aio_nbytes); in handle_aiocb_write_zeroes()
2025 ret = do_fallocate(s->fd, 0, aiocb->aio_offset, aiocb->aio_nbytes); in handle_aiocb_write_zeroes()
2026 if (ret == 0 || ret != -ENOTSUP) { in handle_aiocb_write_zeroes()
2029 s->has_fallocate = false; in handle_aiocb_write_zeroes()
2030 } else if (ret == -EINVAL) { in handle_aiocb_write_zeroes()
2032 * Some file systems like older versions of GPFS do not like un- in handle_aiocb_write_zeroes()
2034 * they should not do it according to the man-page of fallocate(). in handle_aiocb_write_zeroes()
2041 } else if (ret != -ENOTSUP) { in handle_aiocb_write_zeroes()
2044 s->has_discard = false; in handle_aiocb_write_zeroes()
2052 len = raw_getlength(aiocb->bs); in handle_aiocb_write_zeroes()
2053 if (s->has_fallocate && len >= 0 && aiocb->aio_offset >= len) { in handle_aiocb_write_zeroes()
2054 int ret = do_fallocate(s->fd, 0, aiocb->aio_offset, aiocb->aio_nbytes); in handle_aiocb_write_zeroes()
2055 if (ret == 0 || ret != -ENOTSUP) { in handle_aiocb_write_zeroes()
2058 s->has_fallocate = false; in handle_aiocb_write_zeroes()
2062 return -ENOTSUP; in handle_aiocb_write_zeroes()
2068 BDRVRawState *s G_GNUC_UNUSED = aiocb->bs->opaque; in handle_aiocb_write_zeroes_unmap()
2073 int ret = do_fallocate(s->fd, FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE, in handle_aiocb_write_zeroes_unmap()
2074 aiocb->aio_offset, aiocb->aio_nbytes); in handle_aiocb_write_zeroes_unmap()
2076 case -ENOTSUP: in handle_aiocb_write_zeroes_unmap()
2077 case -EINVAL: in handle_aiocb_write_zeroes_unmap()
2078 case -EBUSY: in handle_aiocb_write_zeroes_unmap()
2086 * all-zero afterwards, just write zeroes without unmapping */ in handle_aiocb_write_zeroes_unmap()
2102 return -1; in copy_file_range()
2108 * parse_zone - Fill a zone descriptor
2113 zone->start = blkz->start << BDRV_SECTOR_BITS; in parse_zone()
2114 zone->length = blkz->len << BDRV_SECTOR_BITS; in parse_zone()
2115 zone->wp = blkz->wp << BDRV_SECTOR_BITS; in parse_zone()
2118 zone->cap = blkz->capacity << BDRV_SECTOR_BITS; in parse_zone()
2120 zone->cap = blkz->len << BDRV_SECTOR_BITS; in parse_zone()
2123 switch (blkz->type) { in parse_zone()
2125 zone->type = BLK_ZT_SWR; in parse_zone()
2128 zone->type = BLK_ZT_SWP; in parse_zone()
2131 zone->type = BLK_ZT_CONV; in parse_zone()
2134 error_report("Unsupported zone type: 0x%x", blkz->type); in parse_zone()
2135 return -ENOTSUP; in parse_zone()
2138 switch (blkz->cond) { in parse_zone()
2140 zone->state = BLK_ZS_NOT_WP; in parse_zone()
2143 zone->state = BLK_ZS_EMPTY; in parse_zone()
2146 zone->state = BLK_ZS_IOPEN; in parse_zone()
2149 zone->state = BLK_ZS_EOPEN; in parse_zone()
2152 zone->state = BLK_ZS_CLOSED; in parse_zone()
2155 zone->state = BLK_ZS_RDONLY; in parse_zone()
2158 zone->state = BLK_ZS_FULL; in parse_zone()
2161 zone->state = BLK_ZS_OFFLINE; in parse_zone()
2164 error_report("Unsupported zone state: 0x%x", blkz->cond); in parse_zone()
2165 return -ENOTSUP; in parse_zone()
2175 int fd = aiocb->aio_fildes; in handle_aiocb_zone_report()
2176 unsigned int *nr_zones = aiocb->zone_report.nr_zones; in handle_aiocb_zone_report()
2177 BlockZoneDescriptor *zones = aiocb->zone_report.zones; in handle_aiocb_zone_report()
2178 /* zoned block devices use 512-byte sectors */ in handle_aiocb_zone_report()
2179 uint64_t sector = aiocb->aio_offset / 512; in handle_aiocb_zone_report()
2195 rep->sector = sector; in handle_aiocb_zone_report()
2196 rep->nr_zones = nrz - n; in handle_aiocb_zone_report()
2204 return -errno; in handle_aiocb_zone_report()
2207 if (!rep->nr_zones) { in handle_aiocb_zone_report()
2211 for (i = 0; i < rep->nr_zones; i++, n++) { in handle_aiocb_zone_report()
2231 int fd = aiocb->aio_fildes; in handle_aiocb_zone_mgmt()
2232 uint64_t sector = aiocb->aio_offset / 512; in handle_aiocb_zone_mgmt()
2233 int64_t nr_sectors = aiocb->aio_nbytes / 512; in handle_aiocb_zone_mgmt()
2241 ret = ioctl(fd, aiocb->zone_mgmt.op, &range); in handle_aiocb_zone_mgmt()
2244 return ret < 0 ? -errno : ret; in handle_aiocb_zone_mgmt()
2251 uint64_t bytes = aiocb->aio_nbytes; in handle_aiocb_copy_range()
2252 off_t in_off = aiocb->aio_offset; in handle_aiocb_copy_range()
2253 off_t out_off = aiocb->copy_range.aio_offset2; in handle_aiocb_copy_range()
2256 ssize_t ret = copy_file_range(aiocb->aio_fildes, &in_off, in handle_aiocb_copy_range()
2257 aiocb->copy_range.aio_fd2, &out_off, in handle_aiocb_copy_range()
2259 trace_file_copy_file_range(aiocb->bs, aiocb->aio_fildes, in_off, in handle_aiocb_copy_range()
2260 aiocb->copy_range.aio_fd2, out_off, bytes, in handle_aiocb_copy_range()
2265 return -ENOSPC; in handle_aiocb_copy_range()
2270 return -ENOTSUP; in handle_aiocb_copy_range()
2274 return -errno; in handle_aiocb_copy_range()
2277 bytes -= ret; in handle_aiocb_copy_range()
2285 int ret = -ENOTSUP; in handle_aiocb_discard()
2286 BDRVRawState *s = aiocb->bs->opaque; in handle_aiocb_discard()
2288 if (!s->has_discard) { in handle_aiocb_discard()
2289 return -ENOTSUP; in handle_aiocb_discard()
2292 if (aiocb->aio_type & QEMU_AIO_BLKDEV) { in handle_aiocb_discard()
2295 uint64_t range[2] = { aiocb->aio_offset, aiocb->aio_nbytes }; in handle_aiocb_discard()
2296 if (ioctl(aiocb->aio_fildes, BLKDISCARD, range) == 0) { in handle_aiocb_discard()
2301 ret = translate_err(-errno); in handle_aiocb_discard()
2305 ret = do_fallocate(s->fd, FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE, in handle_aiocb_discard()
2306 aiocb->aio_offset, aiocb->aio_nbytes); in handle_aiocb_discard()
2312 fpunchhole.fp_offset = aiocb->aio_offset; in handle_aiocb_discard()
2313 fpunchhole.fp_length = aiocb->aio_nbytes; in handle_aiocb_discard()
2314 if (fcntl(s->fd, F_PUNCHHOLE, &fpunchhole) == -1) { in handle_aiocb_discard()
2315 ret = errno == ENODEV ? -ENOTSUP : -errno; in handle_aiocb_discard()
2322 if (ret == -ENOTSUP) { in handle_aiocb_discard()
2323 s->has_discard = false; in handle_aiocb_discard()
2339 * Returns: 0 on success, -errno on failure. Since this is an optimization,
2357 ret = (n == -1) ? -errno : 0; in allocate_first_block()
2370 int fd = aiocb->aio_fildes; in handle_aiocb_truncate()
2371 int64_t offset = aiocb->aio_offset; in handle_aiocb_truncate()
2372 PreallocMode prealloc = aiocb->truncate.prealloc; in handle_aiocb_truncate()
2373 Error **errp = aiocb->truncate.errp; in handle_aiocb_truncate()
2376 result = -errno; in handle_aiocb_truncate()
2377 error_setg_errno(errp, -result, "Could not stat file"); in handle_aiocb_truncate()
2384 return -ENOTSUP; in handle_aiocb_truncate()
2396 result = -posix_fallocate(fd, current_length, in handle_aiocb_truncate()
2397 offset - current_length); in handle_aiocb_truncate()
2400 error_setg_errno(errp, -result, in handle_aiocb_truncate()
2421 int64_t num = 0, left = offset - current_length; in handle_aiocb_truncate()
2430 result = -errno; in handle_aiocb_truncate()
2431 error_setg_errno(errp, -result, "Could not resize file"); in handle_aiocb_truncate()
2439 result = -errno; in handle_aiocb_truncate()
2440 error_setg_errno(errp, -result, in handle_aiocb_truncate()
2452 result = -errno; in handle_aiocb_truncate()
2453 error_setg_errno(errp, -result, in handle_aiocb_truncate()
2457 left -= result; in handle_aiocb_truncate()
2462 result = -errno; in handle_aiocb_truncate()
2463 error_setg_errno(errp, -result, in handle_aiocb_truncate()
2472 result = -errno; in handle_aiocb_truncate()
2473 error_setg_errno(errp, -result, "Could not resize file"); in handle_aiocb_truncate()
2480 result = -ENOTSUP; in handle_aiocb_truncate()
2510 size_t len = bs->bl.request_alignment; in bdrv_qiov_is_aligned()
2513 for (i = 0; i < qiov->niov; i++) { in bdrv_qiov_is_aligned()
2514 if ((uintptr_t) qiov->iov[i].iov_base % alignment) { in bdrv_qiov_is_aligned()
2517 if (qiov->iov[i].iov_len % len) { in bdrv_qiov_is_aligned()
2531 if (!s->use_linux_io_uring) { in raw_check_linux_io_uring()
2539 s->use_linux_io_uring = false; in raw_check_linux_io_uring()
2552 if (!s->use_linux_aio) { in raw_check_linux_aio()
2560 s->use_linux_aio = false; in raw_check_linux_aio()
2571 BDRVRawState *s = bs->opaque; in raw_co_prw()
2577 return -EIO; in raw_co_prw()
2580 bs->bl.zoned != BLK_Z_NONE) { in raw_co_prw()
2581 qemu_co_mutex_lock(&bs->wps->colock); in raw_co_prw()
2583 int index = offset / bs->bl.zone_size; in raw_co_prw()
2584 offset = bs->wps->wp[index]; in raw_co_prw()
2595 if (s->needs_alignment && !bdrv_qiov_is_aligned(bs, qiov)) { in raw_co_prw()
2599 assert(qiov->size == bytes); in raw_co_prw()
2600 ret = luring_co_submit(bs, s->fd, offset, qiov, type, flags); in raw_co_prw()
2605 assert(qiov->size == bytes); in raw_co_prw()
2606 ret = laio_co_submit(s->fd, offset, qiov, type, flags, in raw_co_prw()
2607 s->aio_max_batch); in raw_co_prw()
2614 .aio_fildes = s->fd, in raw_co_prw()
2619 .iov = qiov->iov, in raw_co_prw()
2620 .niov = qiov->niov, in raw_co_prw()
2624 assert(qiov->size == bytes); in raw_co_prw()
2635 bs->bl.zoned != BLK_Z_NONE) { in raw_co_prw()
2636 BlockZoneWps *wps = bs->wps; in raw_co_prw()
2638 uint64_t *wp = &wps->wp[offset / bs->bl.zone_size]; in raw_co_prw()
2654 update_zones_wp(bs, s->fd, offset, 1); in raw_co_prw()
2657 qemu_co_mutex_unlock(&wps->colock); in raw_co_prw()
2679 BDRVRawState *s = bs->opaque; in raw_co_flush_to_disk()
2690 .aio_fildes = s->fd, in raw_co_flush_to_disk()
2696 return luring_co_submit(bs, s->fd, 0, NULL, QEMU_AIO_FLUSH, 0); in raw_co_flush_to_disk()
2700 if (s->has_laio_fdsync && raw_check_linux_aio(s)) { in raw_co_flush_to_disk()
2701 return laio_co_submit(s->fd, 0, NULL, QEMU_AIO_FLUSH, 0, 0); in raw_co_flush_to_disk()
2709 BDRVRawState *s = bs->opaque; in raw_close()
2711 if (s->fd >= 0) { in raw_close()
2713 g_free(bs->wps); in raw_close()
2715 qemu_close(s->fd); in raw_close()
2716 s->fd = -1; in raw_close()
2724 * Returns: 0 on success, -errno on failure.
2750 BDRVRawState *s = bs->opaque; in raw_co_truncate()
2754 if (fstat(s->fd, &st)) { in raw_co_truncate()
2755 ret = -errno; in raw_co_truncate()
2756 error_setg_errno(errp, -ret, "Failed to fstat() the file"); in raw_co_truncate()
2762 return raw_regular_truncate(bs, s->fd, offset, prealloc, errp); in raw_co_truncate()
2767 "non-regular file", PreallocMode_str(prealloc)); in raw_co_truncate()
2768 return -ENOTSUP; in raw_co_truncate()
2776 return -ENOTSUP; in raw_co_truncate()
2779 return -EINVAL; in raw_co_truncate()
2783 return -ENOTSUP; in raw_co_truncate()
2792 BDRVRawState *s = bs->opaque; in raw_getlength()
2793 int fd = s->fd; in raw_getlength()
2797 return -errno; in raw_getlength()
2802 return -errno; in raw_getlength()
2811 BDRVRawState *s = bs->opaque; in raw_getlength()
2812 int fd = s->fd; in raw_getlength()
2816 return -errno; in raw_getlength()
2820 if (ioctl(fd, DIOCGWEDGEINFO, &dkw) != -1) { in raw_getlength()
2826 return -errno; in raw_getlength()
2836 BDRVRawState *s = bs->opaque; in raw_getlength()
2849 ret = ioctl(s->fd, DKIOCGMEDIAINFO, &minfo); in raw_getlength()
2850 if (ret != -1) { in raw_getlength()
2858 size = lseek(s->fd, 0, SEEK_END); in raw_getlength()
2860 return -errno; in raw_getlength()
2867 BDRVRawState *s = bs->opaque; in raw_getlength()
2868 int fd = s->fd; in raw_getlength()
2913 return -errno; in raw_getlength()
2916 switch(s->type) { in raw_getlength()
2919 if (size == 2048LL * (unsigned)-1) in raw_getlength()
2931 return -errno; in raw_getlength()
2939 BDRVRawState *s = bs->opaque; in raw_getlength()
2948 size = lseek(s->fd, 0, SEEK_END); in raw_getlength()
2950 return -errno; in raw_getlength()
2964 BDRVRawState *s = bs->opaque; in raw_co_get_allocated_file_size()
2966 if (fstat(s->fd, &st) < 0) { in raw_co_get_allocated_file_size()
2967 return -errno; in raw_co_get_allocated_file_size()
2982 assert(options->driver == BLOCKDEV_DRIVER_FILE); in raw_co_create()
2983 file_opts = &options->u.file; in raw_co_create()
2985 if (!file_opts->has_nocow) { in raw_co_create()
2986 file_opts->nocow = false; in raw_co_create()
2988 if (!file_opts->has_preallocation) { in raw_co_create()
2989 file_opts->preallocation = PREALLOC_MODE_OFF; in raw_co_create()
2991 if (!file_opts->has_extent_size_hint) { in raw_co_create()
2992 file_opts->extent_size_hint = 1 * MiB; in raw_co_create()
2994 if (file_opts->extent_size_hint > UINT32_MAX) { in raw_co_create()
2995 result = -EINVAL; in raw_co_create()
3001 fd = qemu_create(file_opts->filename, O_RDWR | O_BINARY, 0644, errp); in raw_co_create()
3003 result = -errno; in raw_co_create()
3031 file_opts->filename); in raw_co_create()
3041 if (file_opts->nocow) { in raw_co_create()
3048 int attr; in raw_co_create() local
3049 if (ioctl(fd, FS_IOC_GETFLAGS, &attr) == 0) { in raw_co_create()
3050 attr |= FS_NOCOW_FL; in raw_co_create()
3051 ioctl(fd, FS_IOC_SETFLAGS, &attr); in raw_co_create()
3061 struct fsxattr attr; in raw_co_create() local
3062 result = ioctl(fd, FS_IOC_FSGETXATTR, &attr); in raw_co_create()
3064 attr.fsx_xflags |= FS_XFLAG_EXTSIZE; in raw_co_create()
3065 attr.fsx_extsize = file_opts->extent_size_hint; in raw_co_create()
3066 result = ioctl(fd, FS_IOC_FSSETXATTR, &attr); in raw_co_create()
3068 if (result < 0 && file_opts->has_extent_size_hint && in raw_co_create()
3069 file_opts->extent_size_hint) in raw_co_create()
3079 result = raw_regular_truncate(NULL, fd, file_opts->size, in raw_co_create()
3080 file_opts->preallocation, errp); in raw_co_create()
3097 result = -errno; in raw_co_create()
3098 error_setg_errno(errp, -result, "Could not close the new file"); in raw_co_create()
3126 qemu_opt_get_size_del(opts, BLOCK_OPT_EXTENT_SIZE_HINT, -1); in raw_co_create_opts()
3135 return -EINVAL; in raw_co_create_opts()
3160 if (!(stat(bs->filename, &st) == 0) || !S_ISREG(st.st_mode)) { in raw_co_delete_file()
3162 bs->filename); in raw_co_delete_file()
3163 return -ENOENT; in raw_co_delete_file()
3166 ret = unlink(bs->filename); in raw_co_delete_file()
3168 ret = -errno; in raw_co_delete_file()
3169 error_setg_errno(errp, -ret, "Error when deleting file %s", in raw_co_delete_file()
3170 bs->filename); in raw_co_delete_file()
3181 * If @start is in a non-trailing hole, store @start in @hole and the
3182 * beginning of the next non-hole in @data, and return 0.
3183 * If @start is in a trailing hole or beyond EOF, return -ENXIO.
3184 * If we can't find out, return a negative errno other than -ENXIO.
3190 BDRVRawState *s = bs->opaque; in find_allocation()
3204 offs = lseek(s->fd, start, SEEK_DATA); in find_allocation()
3206 return -errno; /* D3 or D4 */ in find_allocation()
3211 * -EIO in this case, and we'll treat it like D4. */ in find_allocation()
3212 return -EIO; in find_allocation()
3241 offs = lseek(s->fd, start, SEEK_HOLE); in find_allocation()
3243 return -errno; /* D1 and (H3 or H4) */ in find_allocation()
3248 * -EIO in this case, and we'll treat it like H4. */ in find_allocation()
3249 return -EIO; in find_allocation()
3265 return -EBUSY; in find_allocation()
3267 return -ENOTSUP; in find_allocation()
3293 assert(QEMU_IS_ALIGNED(offset | bytes, bs->bl.request_alignment)); in raw_co_block_status()
3301 /* There is no backing file - all bytes are allocated in this file. */ in raw_co_block_status()
3309 if (ret == -ENXIO) { in raw_co_block_status()
3320 *pnum = hole - offset; in raw_co_block_status()
3326 if (!QEMU_IS_ALIGNED(*pnum, bs->bl.request_alignment)) { in raw_co_block_status()
3332 *pnum = ROUND_UP(*pnum, bs->bl.request_alignment); in raw_co_block_status()
3339 *pnum = data - offset; in raw_co_block_status()
3352 BDRVRawState *s = bs->opaque; in check_cache_dropped()
3374 new_length = MIN(end - offset, window_size); in check_cache_dropped()
3382 s->fd, offset); in check_cache_dropped()
3420 BDRVRawState *s = bs->opaque; in raw_co_invalidate_cache()
3425 error_setg_errno(errp, -ret, "The file descriptor is not open"); in raw_co_invalidate_cache()
3429 if (!s->drop_cache) { in raw_co_invalidate_cache()
3433 if (s->open_flags & O_DIRECT) { in raw_co_invalidate_cache()
3441 error_setg_errno(errp, -ret, "flush failed"); in raw_co_invalidate_cache()
3449 ret = posix_fadvise(s->fd, 0, 0, POSIX_FADV_DONTNEED); in raw_co_invalidate_cache()
3455 if (s->check_cache_dropped) { in raw_co_invalidate_cache()
3471 s->stats.discard_nb_failed++; in raw_account_discard()
3473 s->stats.discard_nb_ok++; in raw_account_discard()
3474 s->stats.discard_bytes_ok += nbytes; in raw_account_discard()
3479 * zone report - Get a zone block device's information in the form
3489 BDRVRawState *s = bs->opaque; in raw_co_zone_report()
3492 .aio_fildes = s->fd, in raw_co_zone_report()
3507 * zone management operations - Execute an operation on a zone
3512 BDRVRawState *s = bs->opaque; in raw_co_zone_mgmt()
3518 BlockZoneWps *wps = bs->wps; in raw_co_zone_mgmt()
3519 int64_t capacity = bs->total_sectors << BDRV_SECTOR_BITS; in raw_co_zone_mgmt()
3521 zone_size = bs->bl.zone_size; in raw_co_zone_mgmt()
3522 zone_size_mask = zone_size - 1; in raw_co_zone_mgmt()
3526 return -EINVAL; in raw_co_zone_mgmt()
3533 return -EINVAL; in raw_co_zone_mgmt()
3536 uint32_t i = offset / bs->bl.zone_size; in raw_co_zone_mgmt()
3537 uint32_t nrz = len / bs->bl.zone_size; in raw_co_zone_mgmt()
3538 uint64_t *wp = &wps->wp[i]; in raw_co_zone_mgmt()
3541 return -EIO; in raw_co_zone_mgmt()
3563 return -ENOTSUP; in raw_co_zone_mgmt()
3568 .aio_fildes = s->fd, in raw_co_zone_mgmt()
3581 update_zones_wp(bs, s->fd, offset, nrz); in raw_co_zone_mgmt()
3587 ret = get_zones_wp(bs, s->fd, 0, bs->bl.nr_zones, 1); in raw_co_zone_mgmt()
3614 int64_t zone_size_mask = bs->bl.zone_size - 1; in raw_co_zone_append()
3620 "%" PRId32 "", *offset / 512, bs->bl.zone_size / 512); in raw_co_zone_append()
3621 return -EINVAL; in raw_co_zone_append()
3624 int64_t wg = bs->bl.write_granularity; in raw_co_zone_append()
3625 int64_t wg_mask = wg - 1; in raw_co_zone_append()
3626 for (int i = 0; i < qiov->niov; i++) { in raw_co_zone_append()
3627 iov_len = qiov->iov[i].iov_len; in raw_co_zone_append()
3631 return -EINVAL; in raw_co_zone_append()
3645 BDRVRawState *s = bs->opaque; in raw_do_pdiscard()
3651 .aio_fildes = s->fd, in raw_do_pdiscard()
3676 BDRVRawState *s = bs->opaque; in raw_do_pwrite_zeroes()
3681 if (offset + bytes > bs->total_sectors * BDRV_SECTOR_SIZE) { in raw_do_pwrite_zeroes()
3702 assert(req->type == BDRV_TRACKED_WRITE); in raw_do_pwrite_zeroes()
3703 assert(req->offset <= offset); in raw_do_pwrite_zeroes()
3704 assert(req->offset + req->bytes >= offset + bytes); in raw_do_pwrite_zeroes()
3706 req->bytes = BDRV_MAX_LENGTH - req->offset; in raw_do_pwrite_zeroes()
3708 bdrv_check_request(req->offset, req->bytes, &error_abort); in raw_do_pwrite_zeroes()
3710 bdrv_make_request_serialising(req, bs->bl.request_alignment); in raw_do_pwrite_zeroes()
3716 .aio_fildes = s->fd, in raw_do_pwrite_zeroes()
3765 BDRVRawState *s = bs->opaque; in raw_get_specific_info()
3766 struct fsxattr attr; in raw_get_specific_info() local
3769 ret = ioctl(s->fd, FS_IOC_FSGETXATTR, &attr); in raw_get_specific_info()
3770 if (!ret && attr.fsx_extsize != 0) { in raw_get_specific_info()
3771 file_info->has_extent_size_hint = true; in raw_get_specific_info()
3772 file_info->extent_size_hint = attr.fsx_extsize; in raw_get_specific_info()
3782 BDRVRawState *s = bs->opaque; in get_blockstats_specific_file()
3784 .discard_nb_ok = s->stats.discard_nb_ok, in get_blockstats_specific_file()
3785 .discard_nb_failed = s->stats.discard_nb_failed, in get_blockstats_specific_file()
3786 .discard_bytes_ok = s->stats.discard_bytes_ok, in get_blockstats_specific_file()
3794 stats->driver = BLOCKDEV_DRIVER_FILE; in raw_get_specific_stats()
3795 stats->u.file = get_blockstats_specific_file(bs); in raw_get_specific_stats()
3805 stats->driver = BLOCKDEV_DRIVER_HOST_DEVICE; in hdev_get_specific_stats()
3806 stats->u.host_device = get_blockstats_specific_file(bs); in hdev_get_specific_stats()
3813 .name = "raw-create-opts",
3824 .help = "Turn off copy-on-write (valid only on btrfs)"
3838 .help = "Extent size hint for the image file, 0 to disable"
3847 BDRVRawState *s = bs->opaque; in raw_check_perm()
3848 int input_flags = s->reopen_state ? s->reopen_state->flags : bs->open_flags; in raw_check_perm()
3852 /* We may need a new fd if auto-read-only switches the mode */ in raw_check_perm()
3856 } else if (ret != s->fd) { in raw_check_perm()
3866 return -EINVAL; in raw_check_perm()
3869 s->perm_change_fd = ret; in raw_check_perm()
3870 s->perm_change_flags = open_flags; in raw_check_perm()
3881 if (s->perm_change_fd && s->use_lock) { in raw_check_perm()
3882 ret = raw_apply_lock_bytes(NULL, s->perm_change_fd, perm, ~shared, in raw_check_perm()
3892 if (s->perm_change_fd) { in raw_check_perm()
3893 qemu_close(s->perm_change_fd); in raw_check_perm()
3895 s->perm_change_fd = 0; in raw_check_perm()
3901 BDRVRawState *s = bs->opaque; in raw_set_perm()
3905 if (s->perm_change_fd && s->fd != s->perm_change_fd) { in raw_set_perm()
3906 qemu_close(s->fd); in raw_set_perm()
3907 s->fd = s->perm_change_fd; in raw_set_perm()
3908 s->open_flags = s->perm_change_flags; in raw_set_perm()
3910 s->perm_change_fd = 0; in raw_set_perm()
3913 s->perm = perm; in raw_set_perm()
3914 s->shared_perm = shared; in raw_set_perm()
3919 BDRVRawState *s = bs->opaque; in raw_abort_perm_update()
3923 if (s->perm_change_fd) { in raw_abort_perm_update()
3924 qemu_close(s->perm_change_fd); in raw_abort_perm_update()
3926 s->perm_change_fd = 0; in raw_abort_perm_update()
3948 BDRVRawState *s = bs->opaque; in raw_co_copy_range_to()
3951 assert(dst->bs == bs); in raw_co_copy_range_to()
3952 if (src->bs->drv->bdrv_co_copy_range_to != raw_co_copy_range_to) { in raw_co_copy_range_to()
3953 return -ENOTSUP; in raw_co_copy_range_to()
3956 src_s = src->bs->opaque; in raw_co_copy_range_to()
3957 if (fd_open(src->bs) < 0 || fd_open(dst->bs) < 0) { in raw_co_copy_range_to()
3958 return -EIO; in raw_co_copy_range_to()
3964 .aio_fildes = src_s->fd, in raw_co_copy_range_to()
3968 .aio_fd2 = s->fd, in raw_co_copy_range_to()
4085 …if ( CFStringGetCString( bsdPathAsCFString, bsdPath + devPathLength, maxPathSize - devPathLength, … in GetBSDPath()
4141 /* allow a dedicated CD-ROM driver to match with a higher priority */ in hdev_probe_device()
4164 BDRVRawState *s = bs->opaque; in hdev_is_sg()
4170 if (stat(bs->filename, &st) < 0 || !S_ISCHR(st.st_mode)) { in hdev_is_sg()
4174 ret = ioctl(s->fd, SG_GET_VERSION_NUM, &sg_version); in hdev_is_sg()
4179 ret = ioctl(s->fd, SG_GET_SCSI_ID, &scsiid); in hdev_is_sg()
4193 BDRVRawState *s = bs->opaque; in hdev_open()
4198 * Caution: while qdict_get_str() is fine, getting non-string types in hdev_open()
4199 * would require more care. When @options come from -blockdev or in hdev_open()
4201 * schema, but when they come from -drive, they're all QString. in hdev_open()
4251 return -ENOENT; in hdev_open()
4256 s->type = FTYPE_FILE; in hdev_open()
4273 bs->sg = hdev_is_sg(bs); in hdev_open()
4275 /* sg devices aren't even block devices and can't use dm-mpath */ in hdev_open()
4276 s->use_mpath = !bs->sg; in hdev_open()
4287 case -ENODEV: in sgio_path_error()
4289 case -EAGAIN: in sgio_path_error()
4307 if (io_hdr->host_status != SCSI_HOST_OK) { in sgio_path_error()
4311 switch (io_hdr->status) { in sgio_path_error()
4320 return !scsi_sense_buf_is_guest_recoverable(io_hdr->sbp, in sgio_path_error()
4321 io_hdr->mx_sb_len); in sgio_path_error()
4329 BDRVRawState *s = acb->bs->opaque; in hdev_co_ioctl_sgio_retry()
4332 if (!s->use_mpath) { in hdev_co_ioctl_sgio_retry()
4336 if (!sgio_path_error(ret, acb->ioctl.buf)) { in hdev_co_ioctl_sgio_retry()
4341 .bs = acb->bs, in hdev_co_ioctl_sgio_retry()
4343 .aio_fildes = s->fd, in hdev_co_ioctl_sgio_retry()
4352 if (ret == -ENOTTY) { in hdev_co_ioctl_sgio_retry()
4353 s->use_mpath = false; in hdev_co_ioctl_sgio_retry()
4354 } else if (ret == -EAGAIN) { in hdev_co_ioctl_sgio_retry()
4371 BDRVRawState *s = bs->opaque; in hdev_co_ioctl()
4381 if (req == SG_IO && s->pr_mgr) { in hdev_co_ioctl()
4383 if (io_hdr->cmdp[0] == PERSISTENT_RESERVE_OUT || in hdev_co_ioctl()
4384 io_hdr->cmdp[0] == PERSISTENT_RESERVE_IN) { in hdev_co_ioctl()
4385 return pr_manager_execute(s->pr_mgr, qemu_get_current_aio_context(), in hdev_co_ioctl()
4386 s->fd, io_hdr); in hdev_co_ioctl()
4393 .aio_fildes = s->fd, in hdev_co_ioctl()
4403 } while (req == SG_IO && retries-- && hdev_co_ioctl_sgio_retry(&acb, ret)); in hdev_co_ioctl()
4412 BDRVRawState *s = bs->opaque; in hdev_co_pdiscard()
4497 bs->bl.has_variable_length = true; in cdrom_refresh_limits()
4506 BDRVRawState *s = bs->opaque; in cdrom_open()
4508 s->type = FTYPE_CD; in cdrom_open()
4525 if (ret == -1 || !S_ISBLK(st.st_mode)) { in cdrom_probe_device()
4542 BDRVRawState *s = bs->opaque; in cdrom_co_is_inserted()
4545 ret = ioctl(s->fd, CDROM_DRIVE_STATUS, CDSL_CURRENT); in cdrom_co_is_inserted()
4551 BDRVRawState *s = bs->opaque; in cdrom_co_eject()
4554 if (ioctl(s->fd, CDROMEJECT, NULL) < 0) in cdrom_co_eject()
4557 if (ioctl(s->fd, CDROMCLOSETRAY, NULL) < 0) in cdrom_co_eject()
4564 BDRVRawState *s = bs->opaque; in cdrom_co_lock_medium()
4566 if (ioctl(s->fd, CDROM_LOCKDOOR, locked) < 0) { in cdrom_co_lock_medium()
4569 * mounts the CD-ROM in cdrom_co_lock_medium()
4615 BDRVRawState *s = bs->opaque; in cdrom_open()
4618 s->type = FTYPE_CD; in cdrom_open()
4626 ioctl(s->fd, CDIOCALLOW); in cdrom_open()
4640 BDRVRawState *s = bs->opaque; in cdrom_reopen()
4647 if (s->fd >= 0) in cdrom_reopen()
4648 qemu_close(s->fd); in cdrom_reopen()
4649 fd = qemu_open(bs->filename, s->open_flags, NULL); in cdrom_reopen()
4651 s->fd = -1; in cdrom_reopen()
4652 return -EIO; in cdrom_reopen()
4654 s->fd = fd; in cdrom_reopen()
4657 ioctl(s->fd, CDIOCALLOW); in cdrom_reopen()
4668 BDRVRawState *s = bs->opaque; in cdrom_co_eject()
4670 if (s->fd < 0) in cdrom_co_eject()
4673 (void) ioctl(s->fd, CDIOCALLOW); in cdrom_co_eject()
4676 if (ioctl(s->fd, CDIOCEJECT) < 0) in cdrom_co_eject()
4679 if (ioctl(s->fd, CDIOCCLOSE) < 0) in cdrom_co_eject()
4688 BDRVRawState *s = bs->opaque; in cdrom_co_lock_medium()
4690 if (s->fd < 0) in cdrom_co_lock_medium()
4692 if (ioctl(s->fd, (locked ? CDIOCPREVENT : CDIOCALLOW)) < 0) { in cdrom_co_lock_medium()
4695 * mounts the CD-ROM in cdrom_co_lock_medium()