diff options
Diffstat (limited to 'app-emulation/qemu/files')
5 files changed, 190 insertions, 81 deletions
diff --git a/app-emulation/qemu/files/qemu-5.2.0-cleaner-werror.patch b/app-emulation/qemu/files/qemu-5.2.0-cleaner-werror.patch deleted file mode 100644 index 33115f1df480..000000000000 --- a/app-emulation/qemu/files/qemu-5.2.0-cleaner-werror.patch +++ /dev/null @@ -1,40 +0,0 @@ --Wall -Wextra compains about unused arguments, -causes safe-stack to be mis-detected. ---- a/configure -+++ b/configure -@@ -2293,7 +2293,7 @@ fi - cat > $TMPC << EOF - #include <stdint.h> - #include <stdio.h> --int main(int argc, char *argv[]) { -+int main(void) { - return printf("%zu", SIZE_MAX); - } - EOF -@@ -4911,7 +4911,7 @@ fi - - if test "$safe_stack" = "yes"; then - cat > $TMPC << EOF --int main(int argc, char *argv[]) -+int main(void) - { - #if ! __has_feature(safe_stack) - #error SafeStack Disabled -@@ -4933,7 +4933,7 @@ EOF - fi - else - cat > $TMPC << EOF --int main(int argc, char *argv[]) -+int main(void) - { - #if defined(__has_feature) - #if __has_feature(safe_stack) -@@ -5283,7 +5283,7 @@ static const int Z = 1; - #define TAUT(X) ((X) == Z) - #define PAREN(X, Y) (X == Y) - #define ID(X) (X) --int main(int argc, char *argv[]) -+int main(void) - { - int x = 0, y = 0; - x = ID(x); diff --git a/app-emulation/qemu/files/qemu-5.2.0-dce-locks.patch b/app-emulation/qemu/files/qemu-5.2.0-dce-locks.patch deleted file mode 100644 index 679a9f391b0b..000000000000 --- a/app-emulation/qemu/files/qemu-5.2.0-dce-locks.patch +++ /dev/null @@ -1,18 +0,0 @@ -Fix CFLAGS=-Og build break. -Og fails because gcc does not enable dead -code elimination (but does set __OPTIMIZE__ define). - -The fix avoids DCE reliance downstream entirely. - -Reported-by: Luke-Jr -Bug: https://bugs.gentoo.org/782364 ---- a/include/qemu/lockable.h -+++ b/include/qemu/lockable.h -@@ -28,7 +28,7 @@ struct QemuLockable { - * to QEMU_MAKE_LOCKABLE. For optimized builds, we can rely on dead-code elimination - * from the compiler, and give the errors already at link time. - */ --#if defined(__OPTIMIZE__) && !defined(__SANITIZE_ADDRESS__) -+#if defined(__OPTIMIZE__) && !defined(__SANITIZE_ADDRESS__) && defined(VALIDATE_LOCKS_VIA_DCE) - void unknown_lock_type(void *); - #else - static inline void unknown_lock_type(void *unused) diff --git a/app-emulation/qemu/files/qemu-5.2.0-strings.patch b/app-emulation/qemu/files/qemu-5.2.0-strings.patch deleted file mode 100644 index 0b3dcdce78c9..000000000000 --- a/app-emulation/qemu/files/qemu-5.2.0-strings.patch +++ /dev/null @@ -1,23 +0,0 @@ -https://bugs.gentoo.org/759310 ---- a/configure -+++ b/configure -@@ -521,6 +521,7 @@ ld="${LD-${cross_prefix}ld}" - ranlib="${RANLIB-${cross_prefix}ranlib}" - nm="${NM-${cross_prefix}nm}" - strip="${STRIP-${cross_prefix}strip}" -+strings="${STRINGS-${cross_prefix}strings}" - windres="${WINDRES-${cross_prefix}windres}" - pkg_config_exe="${PKG_CONFIG-${cross_prefix}pkg-config}" - query_pkg_config() { -@@ -2265,9 +2266,9 @@ int main(int argc, char *argv[]) { - EOF - - if compile_object ; then -- if strings -a $TMPO | grep -q BiGeNdIaN ; then -+ if $strings -a $TMPO | grep -q BiGeNdIaN ; then - bigendian="yes" -- elif strings -a $TMPO | grep -q LiTtLeEnDiAn ; then -+ elif $strings -a $TMPO | grep -q LiTtLeEnDiAn ; then - bigendian="no" - else - echo big/little test failed diff --git a/app-emulation/qemu/files/qemu-6.1.0-data-corruption.patch b/app-emulation/qemu/files/qemu-6.1.0-data-corruption.patch new file mode 100644 index 000000000000..25c788426a9c --- /dev/null +++ b/app-emulation/qemu/files/qemu-6.1.0-data-corruption.patch @@ -0,0 +1,114 @@ +commit cc071629539dc1f303175a7e2d4ab854c0a8b20f +Author: Paolo Bonzini <pbonzini@redhat.com> +Date: Thu Sep 23 09:04:36 2021 -0400 + + block: introduce max_hw_iov for use in scsi-generic + + Linux limits the size of iovecs to 1024 (UIO_MAXIOV in the kernel + sources, IOV_MAX in POSIX). Because of this, on some host adapters + requests with many iovecs are rejected with -EINVAL by the + io_submit() or readv()/writev() system calls. + + In fact, the same limit applies to SG_IO as well. To fix both the + EINVAL and the possible performance issues from using fewer iovecs + than allowed by Linux (some HBAs have max_segments as low as 128), + introduce a separate entry in BlockLimits to hold the max_segments + value from sysfs. This new limit is used only for SG_IO and clamped + to bs->bl.max_iov anyway, just like max_hw_transfer is clamped to + bs->bl.max_transfer. + + Reported-by: Halil Pasic <pasic@linux.ibm.com> + Cc: Hanna Reitz <hreitz@redhat.com> + Cc: Kevin Wolf <kwolf@redhat.com> + Cc: qemu-block@nongnu.org + Cc: qemu-stable@nongnu.org + Fixes: 18473467d5 ("file-posix: try BLKSECTGET on block devices too, do not round to power of 2", 2021-06-25) + Signed-off-by: Paolo Bonzini <pbonzini@redhat.com> + Message-Id: <20210923130436.1187591-1-pbonzini@redhat.com> + Signed-off-by: Kevin Wolf <kwolf@redhat.com> + +diff --git a/block/block-backend.c b/block/block-backend.c +index 6140d133e2..ba2b5ebb10 100644 +--- a/block/block-backend.c ++++ b/block/block-backend.c +@@ -1986,6 +1986,12 @@ uint32_t blk_get_max_transfer(BlockBackend *blk) + return ROUND_DOWN(max, blk_get_request_alignment(blk)); + } + ++int blk_get_max_hw_iov(BlockBackend *blk) ++{ ++ return MIN_NON_ZERO(blk->root->bs->bl.max_hw_iov, ++ blk->root->bs->bl.max_iov); ++} ++ + int blk_get_max_iov(BlockBackend *blk) + { + return blk->root->bs->bl.max_iov; +diff --git a/block/file-posix.c b/block/file-posix.c +index c62e42743d..53be0bdc1b 100644 +--- a/block/file-posix.c ++++ b/block/file-posix.c +@@ -1273,7 +1273,7 @@ static void raw_refresh_limits(BlockDriverState *bs, Error **errp) + + ret = hdev_get_max_segments(s->fd, &st); + if (ret > 0) { +- bs->bl.max_iov = ret; ++ bs->bl.max_hw_iov = ret; + } + } + } +diff --git a/block/io.c b/block/io.c +index 18d345a87a..bb0a254def 100644 +--- a/block/io.c ++++ b/block/io.c +@@ -136,6 +136,7 @@ static void bdrv_merge_limits(BlockLimits *dst, const BlockLimits *src) + dst->min_mem_alignment = MAX(dst->min_mem_alignment, + src->min_mem_alignment); + dst->max_iov = MIN_NON_ZERO(dst->max_iov, src->max_iov); ++ dst->max_hw_iov = MIN_NON_ZERO(dst->max_hw_iov, src->max_hw_iov); + } + + typedef struct BdrvRefreshLimitsState { +diff --git a/hw/scsi/scsi-generic.c b/hw/scsi/scsi-generic.c +index 665baf900e..0306ccc7b1 100644 +--- a/hw/scsi/scsi-generic.c ++++ b/hw/scsi/scsi-generic.c +@@ -180,7 +180,7 @@ static int scsi_handle_inquiry_reply(SCSIGenericReq *r, SCSIDevice *s, int len) + page = r->req.cmd.buf[2]; + if (page == 0xb0) { + uint64_t max_transfer = blk_get_max_hw_transfer(s->conf.blk); +- uint32_t max_iov = blk_get_max_iov(s->conf.blk); ++ uint32_t max_iov = blk_get_max_hw_iov(s->conf.blk); + + assert(max_transfer); + max_transfer = MIN_NON_ZERO(max_transfer, max_iov * qemu_real_host_page_size) +diff --git a/include/block/block_int.h b/include/block/block_int.h +index ffe86068d4..f4c75e8ba9 100644 +--- a/include/block/block_int.h ++++ b/include/block/block_int.h +@@ -718,6 +718,13 @@ typedef struct BlockLimits { + */ + uint64_t max_hw_transfer; + ++ /* Maximal number of scatter/gather elements allowed by the hardware. ++ * Applies whenever transfers to the device bypass the kernel I/O ++ * scheduler, for example with SG_IO. If larger than max_iov ++ * or if zero, blk_get_max_hw_iov will fall back to max_iov. ++ */ ++ int max_hw_iov; ++ + /* memory alignment, in bytes so that no bounce buffer is needed */ + size_t min_mem_alignment; + +diff --git a/include/sysemu/block-backend.h b/include/sysemu/block-backend.h +index 29d4fdbf63..82bae55161 100644 +--- a/include/sysemu/block-backend.h ++++ b/include/sysemu/block-backend.h +@@ -211,6 +211,7 @@ uint32_t blk_get_request_alignment(BlockBackend *blk); + uint32_t blk_get_max_transfer(BlockBackend *blk); + uint64_t blk_get_max_hw_transfer(BlockBackend *blk); + int blk_get_max_iov(BlockBackend *blk); ++int blk_get_max_hw_iov(BlockBackend *blk); + void blk_set_guest_block_size(BlockBackend *blk, int align); + void *blk_try_blockalign(BlockBackend *blk, size_t size); + void *blk_blockalign(BlockBackend *blk, size_t size); diff --git a/app-emulation/qemu/files/qemu-6.1.0-fix-unix-socket-copy.patch b/app-emulation/qemu/files/qemu-6.1.0-fix-unix-socket-copy.patch new file mode 100644 index 000000000000..7701b26b4f9a --- /dev/null +++ b/app-emulation/qemu/files/qemu-6.1.0-fix-unix-socket-copy.patch @@ -0,0 +1,76 @@ +commit 118d527f2e4baec5fe8060b22a6212468b8e4d3f +Author: Michael Tokarev <mjt@tls.msk.ru> +Date: Wed Sep 1 16:16:24 2021 +0300 + + qemu-sockets: fix unix socket path copy (again) + + Commit 4cfd970ec188558daa6214f26203fe553fb1e01f added an + assert which ensures the path within an address of a unix + socket returned from the kernel is at least one byte and + does not exceed sun_path buffer. Both of this constraints + are wrong: + + A unix socket can be unnamed, in this case the path is + completely empty (not even \0) + + And some implementations (notable linux) can add extra + trailing byte (\0) _after_ the sun_path buffer if we + passed buffer larger than it (and we do). + + So remove the assertion (since it causes real-life breakage) + but at the same time fix the usage of sun_path. Namely, + we should not access sun_path[0] if kernel did not return + it at all (this is the case for unnamed sockets), + and use the returned salen when copyig actual path as an + upper constraint for the amount of bytes to copy - this + will ensure we wont exceed the information provided by + the kernel, regardless whenever there is a trailing \0 + or not. This also helps with unnamed sockets. + + Note the case of abstract socket, the sun_path is actually + a blob and can contain \0 characters, - it should not be + passed to g_strndup and the like, it should be accessed by + memcpy-like functions. + + Fixes: 4cfd970ec188558daa6214f26203fe553fb1e01f + Fixes: http://bugs.debian.org/993145 + Signed-off-by: Michael Tokarev <mjt@tls.msk.ru> + Reviewed-by: Daniel P. Berrangé <berrange@redhat.com> + Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com> + CC: qemu-stable@nongnu.org + +diff --git a/util/qemu-sockets.c b/util/qemu-sockets.c +index f2f3676d1f..c5043999e9 100644 +--- a/util/qemu-sockets.c ++++ b/util/qemu-sockets.c +@@ -1345,25 +1345,22 @@ socket_sockaddr_to_address_unix(struct sockaddr_storage *sa, + SocketAddress *addr; + struct sockaddr_un *su = (struct sockaddr_un *)sa; + +- assert(salen >= sizeof(su->sun_family) + 1 && +- salen <= sizeof(struct sockaddr_un)); +- + addr = g_new0(SocketAddress, 1); + addr->type = SOCKET_ADDRESS_TYPE_UNIX; ++ salen -= offsetof(struct sockaddr_un, sun_path); + #ifdef CONFIG_LINUX +- if (!su->sun_path[0]) { ++ if (salen > 0 && !su->sun_path[0]) { + /* Linux abstract socket */ +- addr->u.q_unix.path = g_strndup(su->sun_path + 1, +- salen - sizeof(su->sun_family) - 1); ++ addr->u.q_unix.path = g_strndup(su->sun_path + 1, salen - 1); + addr->u.q_unix.has_abstract = true; + addr->u.q_unix.abstract = true; + addr->u.q_unix.has_tight = true; +- addr->u.q_unix.tight = salen < sizeof(*su); ++ addr->u.q_unix.tight = salen < sizeof(su->sun_path); + return addr; + } + #endif + +- addr->u.q_unix.path = g_strndup(su->sun_path, sizeof(su->sun_path)); ++ addr->u.q_unix.path = g_strndup(su->sun_path, salen); + return addr; + } + #endif /* WIN32 */ |