tests/qtest: bios-tables-test: Skip if missing configs

If we build with --without-default-devices, CONFIG_HPET and CONFIG_PARALLEL are set to N, which makes the respective devices go missing from acpi tables. Signed-off-by: Fabiano Rosas <farosas@suse.de> Reviewed-by: Thomas Huth <thuth@redhat.com>
tests/qemu-iotests: Require virtio-scsi-pci
2023-02-13 18:01:07 -03:00 · 2023-02-13 18:01:07 -03:00 · 2023-02-13 18:01:07 -03:00 · 2023-02-13 18:01:07 -03:00 · 2023-02-13 18:01:07 -03:00 · 2023-02-13 18:01:07 -03:00
941 changed files with 29978 additions and 27723 deletions
--- a/.cirrus.yml
+++ b/.cirrus.yml
@@ -100,11 +100,9 @@ windows_msys2_task:
      tar xf C:\tools\archive\msys64.tar
      Write-Output "Extract msys2 time taken: $((Get-Date).Subtract($start_time))"
  script:
-    - mkdir build
-    - cd build
-    - C:\tools\msys64\usr\bin\bash.exe -lc "../configure --python=python3
-        --target-list-exclude=i386-softmmu,ppc64-softmmu,aarch64-softmmu,mips64-softmmu,mipsel-softmmu,sh4-softmmu"
-    - C:\tools\msys64\usr\bin\bash.exe -lc "make -j8"
+    - C:\tools\msys64\usr\bin\bash.exe -lc "mkdir build"
+    - C:\tools\msys64\usr\bin\bash.exe -lc "cd build && ../configure --python=python3"
+    - C:\tools\msys64\usr\bin\bash.exe -lc "cd build && make -j8"
    - exit $LastExitCode
  test_script:
    - C:\tools\msys64\usr\bin\bash.exe -lc "cd build && make V=1 check"
--- a/.gitlab-ci.d/base.yml
+++ b/.gitlab-ci.d/base.yml
@@ -11,8 +11,6 @@
    # and show the duration of each line.
    FF_SCRIPT_SECTIONS: 1

-  interruptible: true
-
  rules:
    #############################################################
    # Stage 1: exclude scenarios where we definitely don't
--- a/.gitlab-ci.d/buildtest-template.yml
+++ b/.gitlab-ci.d/buildtest-template.yml
@@ -11,10 +11,12 @@
      fi
    - mkdir build
    - cd build
-    - ../configure --enable-werror --disable-docs --enable-fdt=system
-          ${LD_JOBS:+--meson=git} ${TARGETS:+--target-list="$TARGETS"}
-          $CONFIGURE_ARGS ||
-      { cat config.log meson-logs/meson-log.txt && exit 1; }
+    - if test -n "$TARGETS";
+      then
+        ../configure --enable-werror --disable-docs ${LD_JOBS:+--meson=git} $CONFIGURE_ARGS --target-list="$TARGETS" ;
+      else
+        ../configure --enable-werror --disable-docs ${LD_JOBS:+--meson=git} $CONFIGURE_ARGS ;
+      fi || { cat config.log meson-logs/meson-log.txt && exit 1; }
    - if test -n "$LD_JOBS";
      then
        ../meson/meson.py configure . -Dbackend_max_links="$LD_JOBS" ;
@@ -25,22 +27,6 @@
        make -j"$JOBS" $MAKE_CHECK_ARGS ;
      fi

-# We jump some hoops in common_test_job_template to avoid
-# rebuilding all the object files we skip in the artifacts
-.native_build_artifact_template:
-  artifacts:
-    expire_in: 2 days
-    paths:
-      - build
-      - .git-submodule-status
-    exclude:
-      - build/**/*.p
-      - build/**/*.a.p
-      - build/**/*.fa.p
-      - build/**/*.c.o
-      - build/**/*.c.o.d
-      - build/**/*.fa
-
 .common_test_job_template:
  extends: .base_job_template
  stage: test
--- a/.gitlab-ci.d/buildtest.yml
+++ b/.gitlab-ci.d/buildtest.yml
@@ -2,9 +2,7 @@ include:
  - local: '/.gitlab-ci.d/buildtest-template.yml'

 build-system-alpine:
-  extends:
-    - .native_build_job_template
-    - .native_build_artifact_template
+  extends: .native_build_job_template
  needs:
    - job: amd64-alpine-container
  variables:
@@ -13,6 +11,11 @@ build-system-alpine:
      microblazeel-softmmu mips64el-softmmu
    MAKE_CHECK_ARGS: check-build
    CONFIGURE_ARGS: --enable-docs --enable-trace-backends=log,simple,syslog
+  artifacts:
+    expire_in: 2 days
+    paths:
+      - .git-submodule-status
+      - build

 check-system-alpine:
  extends: .native_test_job_template
@@ -33,17 +36,19 @@ avocado-system-alpine:
    MAKE_CHECK_ARGS: check-avocado

 build-system-ubuntu:
-  extends:
-    - .native_build_job_template
-    - .native_build_artifact_template
+  extends: .native_build_job_template
  needs:
-    job: amd64-ubuntu2204-container
+    job: amd64-ubuntu2004-container
  variables:
-    IMAGE: ubuntu2204
-    CONFIGURE_ARGS: --enable-docs
-    TARGETS: alpha-softmmu cris-softmmu hppa-softmmu
+    IMAGE: ubuntu2004
+    CONFIGURE_ARGS: --enable-docs --enable-fdt=system --enable-capstone
+    TARGETS: aarch64-softmmu alpha-softmmu cris-softmmu hppa-softmmu
      microblazeel-softmmu mips64el-softmmu
    MAKE_CHECK_ARGS: check-build
+  artifacts:
+    expire_in: 2 days
+    paths:
+      - build

 check-system-ubuntu:
  extends: .native_test_job_template
@@ -51,7 +56,7 @@ check-system-ubuntu:
    - job: build-system-ubuntu
      artifacts: true
  variables:
-    IMAGE: ubuntu2204
+    IMAGE: ubuntu2004
    MAKE_CHECK_ARGS: check

 avocado-system-ubuntu:
@@ -60,21 +65,22 @@ avocado-system-ubuntu:
    - job: build-system-ubuntu
      artifacts: true
  variables:
-    IMAGE: ubuntu2204
+    IMAGE: ubuntu2004
    MAKE_CHECK_ARGS: check-avocado

 build-system-debian:
-  extends:
-    - .native_build_job_template
-    - .native_build_artifact_template
+  extends: .native_build_job_template
  needs:
    job: amd64-debian-container
  variables:
    IMAGE: debian-amd64
-    CONFIGURE_ARGS: --with-coroutine=sigaltstack
    TARGETS: arm-softmmu avr-softmmu i386-softmmu mipsel-softmmu
      riscv64-softmmu sh4eb-softmmu sparc-softmmu xtensaeb-softmmu
    MAKE_CHECK_ARGS: check-build
+  artifacts:
+    expire_in: 2 days
+    paths:
+      - build

 check-system-debian:
  extends: .native_test_job_template
@@ -107,17 +113,20 @@ crash-test-debian:
    - tests/venv/bin/python3 scripts/device-crash-test -q ./qemu-system-i386

 build-system-fedora:
-  extends:
-    - .native_build_job_template
-    - .native_build_artifact_template
+  extends: .native_build_job_template
  needs:
    job: amd64-fedora-container
  variables:
    IMAGE: fedora
    CONFIGURE_ARGS: --disable-gcrypt --enable-nettle --enable-docs
+             --enable-fdt=system --enable-slirp --enable-capstone
    TARGETS: tricore-softmmu microblaze-softmmu mips-softmmu
      xtensa-softmmu m68k-softmmu riscv32-softmmu ppc-softmmu sparc64-softmmu
    MAKE_CHECK_ARGS: check-build
+  artifacts:
+    expire_in: 2 days
+    paths:
+      - build

 check-system-fedora:
  extends: .native_test_job_template
@@ -151,18 +160,21 @@ crash-test-fedora:
    - tests/venv/bin/python3 scripts/device-crash-test -q ./qemu-system-riscv32

 build-system-centos:
-  extends:
-    - .native_build_job_template
-    - .native_build_artifact_template
+  extends: .native_build_job_template
  needs:
    job: amd64-centos8-container
  variables:
    IMAGE: centos8
-    CONFIGURE_ARGS: --disable-nettle --enable-gcrypt --enable-vfio-user-server
+    CONFIGURE_ARGS: --disable-nettle --enable-gcrypt --enable-fdt=system
      --enable-modules --enable-trace-backends=dtrace --enable-docs
+      --enable-vfio-user-server
    TARGETS: ppc64-softmmu or1k-softmmu s390x-softmmu
      x86_64-softmmu rx-softmmu sh4-softmmu nios2-softmmu
    MAKE_CHECK_ARGS: check-build
+  artifacts:
+    expire_in: 2 days
+    paths:
+      - build

 check-system-centos:
  extends: .native_test_job_template
@@ -183,15 +195,18 @@ avocado-system-centos:
    MAKE_CHECK_ARGS: check-avocado

 build-system-opensuse:
-  extends:
-    - .native_build_job_template
-    - .native_build_artifact_template
+  extends: .native_build_job_template
  needs:
    job: amd64-opensuse-leap-container
  variables:
    IMAGE: opensuse-leap
+    CONFIGURE_ARGS: --enable-fdt=system
    TARGETS: s390x-softmmu x86_64-softmmu aarch64-softmmu
    MAKE_CHECK_ARGS: check-build
+  artifacts:
+    expire_in: 2 days
+    paths:
+      - build

 check-system-opensuse:
  extends: .native_test_job_template
@@ -326,9 +341,7 @@ clang-user:
 # Split in three sets of build/check/avocado to limit the execution time of each
 # job
 build-cfi-aarch64:
-  extends:
-    - .native_build_job_template
-    - .native_build_artifact_template
+  extends: .native_build_job_template
  needs:
  - job: amd64-fedora-container
  variables:
@@ -344,6 +357,10 @@ build-cfi-aarch64:
    # skipped until the situation has been solved.
    QEMU_JOB_SKIPPED: 1
  timeout: 90m
+  artifacts:
+    expire_in: 2 days
+    paths:
+      - build

 check-cfi-aarch64:
  extends: .native_test_job_template
@@ -364,9 +381,7 @@ avocado-cfi-aarch64:
    MAKE_CHECK_ARGS: check-avocado

 build-cfi-ppc64-s390x:
-  extends:
-    - .native_build_job_template
-    - .native_build_artifact_template
+  extends: .native_build_job_template
  needs:
  - job: amd64-fedora-container
  variables:
@@ -382,6 +397,10 @@ build-cfi-ppc64-s390x:
    # skipped until the situation has been solved.
    QEMU_JOB_SKIPPED: 1
  timeout: 80m
+  artifacts:
+    expire_in: 2 days
+    paths:
+      - build

 check-cfi-ppc64-s390x:
  extends: .native_test_job_template
@@ -402,9 +421,7 @@ avocado-cfi-ppc64-s390x:
    MAKE_CHECK_ARGS: check-avocado

 build-cfi-x86_64:
-  extends:
-    - .native_build_job_template
-    - .native_build_artifact_template
+  extends: .native_build_job_template
  needs:
  - job: amd64-fedora-container
  variables:
@@ -416,6 +433,10 @@ build-cfi-x86_64:
    TARGETS: x86_64-softmmu
    MAKE_CHECK_ARGS: check-build
  timeout: 70m
+  artifacts:
+    expire_in: 2 days
+    paths:
+      - build

 check-cfi-x86_64:
  extends: .native_test_job_template
@@ -438,23 +459,35 @@ avocado-cfi-x86_64:
 tsan-build:
  extends: .native_build_job_template
  needs:
-    job: amd64-ubuntu2204-container
+    job: amd64-ubuntu2004-container
  variables:
-    IMAGE: ubuntu2204
-    CONFIGURE_ARGS: --enable-tsan --cc=clang --cxx=clang++
-          --enable-trace-backends=ust --disable-slirp
+    IMAGE: ubuntu2004
+    CONFIGURE_ARGS: --enable-tsan --cc=clang-10 --cxx=clang++-10
+          --enable-trace-backends=ust --enable-fdt=system --disable-slirp
    TARGETS: x86_64-softmmu ppc64-softmmu riscv64-softmmu x86_64-linux-user
+    MAKE_CHECK_ARGS: bench V=1

-# gcov is a GCC features
-gcov:
+# gprof/gcov are GCC features
+build-gprof-gcov:
  extends: .native_build_job_template
  needs:
-    job: amd64-ubuntu2204-container
-  timeout: 80m
+    job: amd64-ubuntu2004-container
  variables:
-    IMAGE: ubuntu2204
-    CONFIGURE_ARGS: --enable-gcov
+    IMAGE: ubuntu2004
+    CONFIGURE_ARGS: --enable-gprof --enable-gcov
    TARGETS: aarch64-softmmu ppc64-softmmu s390x-softmmu x86_64-softmmu
+  artifacts:
+    expire_in: 1 days
+    paths:
+      - build
+
+check-gprof-gcov:
+  extends: .native_test_job_template
+  needs:
+    - job: build-gprof-gcov
+      artifacts: true
+  variables:
+    IMAGE: ubuntu2004
    MAKE_CHECK_ARGS: check
  after_script:
    - cd build
@@ -512,6 +545,18 @@ build-tci:
    - QTEST_QEMU_BINARY="./qemu-system-s390x" ./tests/qtest/pxe-test -m slow
    - make check-tcg

+# Alternate coroutines implementations are only really of interest to KVM users
+# However we can't test against KVM on Gitlab-CI so we can only run unit tests
+build-coroutine-sigaltstack:
+  extends: .native_build_job_template
+  needs:
+    job: amd64-ubuntu2004-container
+  variables:
+    IMAGE: ubuntu2004
+    CONFIGURE_ARGS: --with-coroutine=sigaltstack --disable-tcg
+                    --enable-trace-backends=ftrace
+    MAKE_CHECK_ARGS: check-unit
+
 # Check our reduced build configurations
 build-without-defaults:
  extends: .native_build_job_template
@@ -545,9 +590,7 @@ build-libvhost-user:
 # No targets are built here, just tools, docs, and unit tests. This
 # also feeds into the eventual documentation deployment steps later
 build-tools-and-docs-debian:
-  extends:
-    - .native_build_job_template
-    - .native_build_artifact_template
+  extends: .native_build_job_template
  needs:
    job: amd64-debian-container
    # when running on 'master' we use pre-existing container
@@ -557,6 +600,10 @@ build-tools-and-docs-debian:
    MAKE_CHECK_ARGS: check-unit ctags TAGS cscope
    CONFIGURE_ARGS: --disable-system --disable-user --enable-docs --enable-tools
    QEMU_JOB_PUBLISH: 1
+  artifacts:
+    expire_in: 2 days
+    paths:
+      - build

 # Prepare for GitLab pages deployment. Anything copied into the
 # "public" directory will be deployed to $USER.gitlab.io/$PROJECT
--- a/.gitlab-ci.d/cirrus/build.yml
+++ b/.gitlab-ci.d/cirrus/build.yml
@@ -32,9 +32,6 @@ build_task:
    - $MAKE -j$(sysctl -n hw.ncpu)
    - for TARGET in $TEST_TARGETS ;
      do
-        $MAKE -j$(sysctl -n hw.ncpu) $TARGET V=1 ;
+        $MAKE -j$(sysctl -n hw.ncpu) $TARGET V=1
+        || { cat meson-logs/testlog.txt; exit 1; } ;
      done
-  always:
-    build_result_artifacts:
-      path: build/meson-logs/*log.txt
-      type: text/plain
--- a/.gitlab-ci.d/cirrus/freebsd-12.vars
+++ b/.gitlab-ci.d/cirrus/freebsd-12.vars
@@ -11,6 +11,6 @@ MAKE='/usr/local/bin/gmake'
 NINJA='/usr/local/bin/ninja'
 PACKAGING_COMMAND='pkg'
 PIP3='/usr/local/bin/pip-3.8'
-PKGS='alsa-lib bash bison bzip2 ca_root_nss capstone4 ccache cdrkit-genisoimage cmocka ctags curl cyrus-sasl dbus diffutils dtc flex fusefs-libs3 gettext git glib gmake gnutls gsed gtk3 json-c libepoxy libffi libgcrypt libjpeg-turbo libnfs libslirp libspice-server libssh libtasn1 llvm lzo2 meson ncurses nettle ninja opencv pixman pkgconf png py39-numpy py39-pillow py39-pip py39-sphinx py39-sphinx_rtd_theme py39-yaml python3 rpm2cpio sdl2 sdl2_image snappy sndio socat spice-protocol tesseract usbredir virglrenderer vte3 zstd'
+PKGS='alsa-lib bash bison bzip2 ca_root_nss capstone4 ccache cdrkit-genisoimage cmocka ctags curl cyrus-sasl dbus diffutils dtc flex fusefs-libs3 gettext git glib gmake gnutls gsed gtk3 json-c libepoxy libffi libgcrypt libjpeg-turbo libnfs libslirp libspice-server libssh libtasn1 llvm lzo2 meson ncurses nettle ninja opencv pixman pkgconf png py39-numpy py39-pillow py39-pip py39-sphinx py39-sphinx_rtd_theme py39-yaml python3 rpm2cpio sdl2 sdl2_image snappy sndio spice-protocol tesseract usbredir virglrenderer vte3 zstd'
 PYPI_PKGS=''
 PYTHON='/usr/local/bin/python3'
--- a/.gitlab-ci.d/cirrus/freebsd-13.vars
+++ b/.gitlab-ci.d/cirrus/freebsd-13.vars
@@ -11,6 +11,6 @@ MAKE='/usr/local/bin/gmake'
 NINJA='/usr/local/bin/ninja'
 PACKAGING_COMMAND='pkg'
 PIP3='/usr/local/bin/pip-3.8'
-PKGS='alsa-lib bash bison bzip2 ca_root_nss capstone4 ccache cdrkit-genisoimage cmocka ctags curl cyrus-sasl dbus diffutils dtc flex fusefs-libs3 gettext git glib gmake gnutls gsed gtk3 json-c libepoxy libffi libgcrypt libjpeg-turbo libnfs libslirp libspice-server libssh libtasn1 llvm lzo2 meson ncurses nettle ninja opencv pixman pkgconf png py39-numpy py39-pillow py39-pip py39-sphinx py39-sphinx_rtd_theme py39-yaml python3 rpm2cpio sdl2 sdl2_image snappy sndio socat spice-protocol tesseract usbredir virglrenderer vte3 zstd'
+PKGS='alsa-lib bash bison bzip2 ca_root_nss capstone4 ccache cdrkit-genisoimage cmocka ctags curl cyrus-sasl dbus diffutils dtc flex fusefs-libs3 gettext git glib gmake gnutls gsed gtk3 json-c libepoxy libffi libgcrypt libjpeg-turbo libnfs libslirp libspice-server libssh libtasn1 llvm lzo2 meson ncurses nettle ninja opencv pixman pkgconf png py39-numpy py39-pillow py39-pip py39-sphinx py39-sphinx_rtd_theme py39-yaml python3 rpm2cpio sdl2 sdl2_image snappy sndio spice-protocol tesseract usbredir virglrenderer vte3 zstd'
 PYPI_PKGS=''
 PYTHON='/usr/local/bin/python3'
--- a/.gitlab-ci.d/cirrus/macos-12.vars
+++ b/.gitlab-ci.d/cirrus/macos-12.vars
@@ -11,6 +11,6 @@ MAKE='/opt/homebrew/bin/gmake'
 NINJA='/opt/homebrew/bin/ninja'
 PACKAGING_COMMAND='brew'
 PIP3='/opt/homebrew/bin/pip3'
-PKGS='bash bc bison bzip2 capstone ccache cmocka ctags curl dbus diffutils dtc flex gcovr gettext git glib gnu-sed gnutls gtk+3 jemalloc jpeg-turbo json-c libepoxy libffi libgcrypt libiscsi libnfs libpng libslirp libssh libtasn1 libusb llvm lzo make meson ncurses nettle ninja pixman pkg-config python3 rpm2cpio sdl2 sdl2_image snappy socat sparse spice-protocol tesseract usbredir vde vte3 zlib zstd'
+PKGS='bash bc bison bzip2 capstone ccache cmocka ctags curl dbus diffutils dtc flex gcovr gettext git glib gnu-sed gnutls gtk+3 jemalloc jpeg-turbo json-c libepoxy libffi libgcrypt libiscsi libnfs libpng libslirp libssh libtasn1 libusb llvm lzo make meson ncurses nettle ninja pixman pkg-config python3 rpm2cpio sdl2 sdl2_image snappy sparse spice-protocol tesseract usbredir vde vte3 zlib zstd'
 PYPI_PKGS='PyYAML numpy pillow sphinx sphinx-rtd-theme'
 PYTHON='/opt/homebrew/bin/python3'
--- a/.gitlab-ci.d/container-template.yml
+++ b/.gitlab-ci.d/container-template.yml
@@ -6,16 +6,17 @@
    - docker:dind
  before_script:
    - export TAG="$CI_REGISTRY_IMAGE/qemu/$NAME:latest"
-    - export COMMON_TAG="$CI_REGISTRY/qemu-project/qemu/qemu/$NAME:latest"
+    - export COMMON_TAG="$CI_REGISTRY/qemu-project/qemu/$NAME:latest"
    - apk add python3
    - docker info
    - docker login $CI_REGISTRY -u "$CI_REGISTRY_USER" -p "$CI_REGISTRY_PASSWORD"
  script:
    - echo "TAG:$TAG"
    - echo "COMMON_TAG:$COMMON_TAG"
-    - docker build --tag "$TAG" --cache-from "$TAG" --cache-from "$COMMON_TAG"
-      --build-arg BUILDKIT_INLINE_CACHE=1
-      -f "tests/docker/dockerfiles/$NAME.docker" "."
+    - ./tests/docker/docker.py --engine docker build
+          -t "qemu/$NAME" -f "tests/docker/dockerfiles/$NAME.docker"
+          -r $CI_REGISTRY/qemu-project/qemu
+    - docker tag "qemu/$NAME" "$TAG"
    - docker push "$TAG"
  after_script:
    - docker logout
--- a/.gitlab-ci.d/containers.yml
+++ b/.gitlab-ci.d/containers.yml
@@ -13,10 +13,10 @@ amd64-debian-container:
  variables:
    NAME: debian-amd64

-amd64-ubuntu2204-container:
+amd64-ubuntu2004-container:
  extends: .container_job_template
  variables:
-    NAME: ubuntu2204
+    NAME: ubuntu2004

 amd64-opensuse-leap-container:
  extends: .container_job_template
--- a/.gitlab-ci.d/crossbuild-template.yml
+++ b/.gitlab-ci.d/crossbuild-template.yml
@@ -6,9 +6,8 @@
  script:
    - mkdir build
    - cd build
-    - ../configure --enable-werror --disable-docs --enable-fdt=system
-        --disable-user $QEMU_CONFIGURE_OPTS $EXTRA_CONFIGURE_OPTS
-        --target-list-exclude="arm-softmmu cris-softmmu
+    - ../configure --enable-werror --disable-docs $QEMU_CONFIGURE_OPTS
+        --disable-user --target-list-exclude="arm-softmmu cris-softmmu
          i386-softmmu microblaze-softmmu mips-softmmu mipsel-softmmu
          mips64-softmmu ppc-softmmu riscv32-softmmu sh4-softmmu
          sparc-softmmu xtensa-softmmu $CROSS_SKIP_TARGETS"
@@ -49,14 +48,3 @@
          nios2-linux-user or1k-linux-user ppc-linux-user sparc-linux-user
          xtensa-linux-user $CROSS_SKIP_TARGETS"
    - make -j$(expr $(nproc) + 1) all check-build $MAKE_CHECK_ARGS
-
-# We can still run some tests on some of our cross build jobs. They can add this
-# template to their extends to save the build logs and test results
-.cross_test_artifacts:
-  artifacts:
-    name: "$CI_JOB_NAME-$CI_COMMIT_REF_SLUG"
-    expire_in: 7 days
-    paths:
-      - build/meson-logs/testlog.txt
-    reports:
-      junit: build/meson-logs/testlog.junit.xml
--- a/.gitlab-ci.d/crossbuilds.yml
+++ b/.gitlab-ci.d/crossbuilds.yml
@@ -44,9 +44,7 @@ cross-arm64-user:
    IMAGE: debian-arm64-cross

 cross-i386-system:
-  extends:
-    - .cross_system_build_job
-    - .cross_test_artifacts
+  extends: .cross_system_build_job
  needs:
    job: i386-fedora-cross-container
  variables:
@@ -54,9 +52,7 @@ cross-i386-system:
    MAKE_CHECK_ARGS: check-qtest

 cross-i386-user:
-  extends:
-    - .cross_user_build_job
-    - .cross_test_artifacts
+  extends: .cross_user_build_job
  needs:
    job: i386-fedora-cross-container
  variables:
@@ -64,9 +60,7 @@ cross-i386-user:
    MAKE_CHECK_ARGS: check

 cross-i386-tci:
-  extends:
-    - .cross_accel_build_job
-    - .cross_test_artifacts
+  extends: .cross_accel_build_job
  timeout: 60m
  needs:
    job: i386-fedora-cross-container
@@ -165,7 +159,7 @@ cross-s390x-kvm-only:
    job: s390x-debian-cross-container
  variables:
    IMAGE: debian-s390x-cross
-    EXTRA_CONFIGURE_OPTS: --disable-tcg --enable-trace-backends=ftrace
+    EXTRA_CONFIGURE_OPTS: --disable-tcg

 cross-mips64el-kvm-only:
  extends: .cross_accel_build_job
@@ -181,7 +175,6 @@ cross-win32-system:
    job: win32-fedora-cross-container
  variables:
    IMAGE: fedora-win32-cross
-    EXTRA_CONFIGURE_OPTS: --enable-fdt=internal
    CROSS_SKIP_TARGETS: alpha-softmmu avr-softmmu hppa-softmmu m68k-softmmu
                        microblazeel-softmmu mips64el-softmmu nios2-softmmu
  artifacts:
@@ -194,7 +187,6 @@ cross-win64-system:
    job: win64-fedora-cross-container
  variables:
    IMAGE: fedora-win64-cross
-    EXTRA_CONFIGURE_OPTS: --enable-fdt=internal
    CROSS_SKIP_TARGETS: alpha-softmmu avr-softmmu hppa-softmmu
                        m68k-softmmu microblazeel-softmmu nios2-softmmu
                        or1k-softmmu rx-softmmu sh4eb-softmmu sparc64-softmmu
--- a/.gitlab-ci.d/custom-runners.yml
+++ b/.gitlab-ci.d/custom-runners.yml
@@ -15,8 +15,7 @@ variables:

 # All custom runners can extend this template to upload the testlog
 # data as an artifact and also feed the junit report
-.custom_runner_template:
-  extends: .base_job_template
+.custom_artifacts_template:
  artifacts:
    name: "$CI_JOB_NAME-$CI_COMMIT_REF_SLUG"
    expire_in: 7 days
--- a/.gitlab-ci.d/custom-runners/ubuntu-20.04-s390x.yml
+++ b/.gitlab-ci.d/custom-runners/ubuntu-20.04-s390x.yml
@@ -3,7 +3,7 @@
 # "Install basic packages to build QEMU on Ubuntu 20.04/20.04"

 ubuntu-20.04-s390x-all-linux-static:
- extends: .custom_runner_template
+ extends: .custom_artifacts_template
 needs: []
 stage: build
 tags:
@@ -24,7 +24,7 @@ ubuntu-20.04-s390x-all-linux-static:
 - make --output-sync -j`nproc` check

 ubuntu-20.04-s390x-all:
- extends: .custom_runner_template
+ extends: .custom_artifacts_template
 needs: []
 stage: build
 tags:
@@ -43,7 +43,7 @@ ubuntu-20.04-s390x-all:
 - make --output-sync -j`nproc` check

 ubuntu-20.04-s390x-alldbg:
- extends: .custom_runner_template
+ extends: .custom_artifacts_template
 needs: []
 stage: build
 tags:
@@ -66,7 +66,7 @@ ubuntu-20.04-s390x-alldbg:
 - make --output-sync -j`nproc` check

 ubuntu-20.04-s390x-clang:
- extends: .custom_runner_template
+ extends: .custom_artifacts_template
 needs: []
 stage: build
 tags:
@@ -108,7 +108,7 @@ ubuntu-20.04-s390x-tci:
 - make --output-sync -j`nproc`

 ubuntu-20.04-s390x-notcg:
- extends: .custom_runner_template
+ extends: .custom_artifacts_template
 needs: []
 stage: build
 tags:
--- a/.gitlab-ci.d/custom-runners/ubuntu-22.04-aarch32.yml
+++ b/.gitlab-ci.d/custom-runners/ubuntu-22.04-aarch32.yml
@@ -3,7 +3,7 @@
 # "Install basic packages to build QEMU on Ubuntu 20.04"

 ubuntu-22.04-aarch32-all:
- extends: .custom_runner_template
+ extends: .custom_artifacts_template
 needs: []
 stage: build
 tags:
--- a/.gitlab-ci.d/custom-runners/ubuntu-22.04-aarch64.yml
+++ b/.gitlab-ci.d/custom-runners/ubuntu-22.04-aarch64.yml
@@ -3,7 +3,7 @@
 # "Install basic packages to build QEMU on Ubuntu 20.04"

 ubuntu-22.04-aarch64-all-linux-static:
- extends: .custom_runner_template
+ extends: .custom_artifacts_template
 needs: []
 stage: build
 tags:
@@ -24,7 +24,7 @@ ubuntu-22.04-aarch64-all-linux-static:
 - make --output-sync -j`nproc --ignore=40` check

 ubuntu-22.04-aarch64-all:
- extends: .custom_runner_template
+ extends: .custom_artifacts_template
 needs: []
 stage: build
 tags:
@@ -46,7 +46,7 @@ ubuntu-22.04-aarch64-all:
 - make --output-sync -j`nproc --ignore=40` check

 ubuntu-22.04-aarch64-alldbg:
- extends: .custom_runner_template
+ extends: .custom_artifacts_template
 needs: []
 stage: build
 tags:
@@ -65,7 +65,7 @@ ubuntu-22.04-aarch64-alldbg:
 - make --output-sync -j`nproc --ignore=40` check

 ubuntu-22.04-aarch64-clang:
- extends: .custom_runner_template
+ extends: .custom_artifacts_template
 needs: []
 stage: build
 tags:
@@ -107,7 +107,7 @@ ubuntu-22.04-aarch64-tci:
 - make --output-sync -j`nproc --ignore=40`

 ubuntu-22.04-aarch64-notcg:
- extends: .custom_runner_template
+ extends: .custom_artifacts_template
 needs: []
 stage: build
 tags:
--- a/.gitlab-ci.d/static_checks.yml
+++ b/.gitlab-ci.d/static_checks.yml
@@ -23,12 +23,12 @@ check-dco:
  before_script:
    - apk -U add git

-check-python-minreqs:
+check-python-pipenv:
  extends: .base_job_template
  stage: test
  image: $CI_REGISTRY_IMAGE/qemu/python:latest
  script:
-    - make -C python check-minreqs
+    - make -C python check-pipenv
  variables:
    GIT_DEPTH: 1
  needs:
--- a/.gitlab-ci.d/windows.yml
+++ b/.gitlab-ci.d/windows.yml
@@ -38,7 +38,6 @@ msys2-64bit:
      mingw-w64-x86_64-capstone
      mingw-w64-x86_64-curl
      mingw-w64-x86_64-cyrus-sasl
-      mingw-w64-x86_64-dtc
      mingw-w64-x86_64-gcc
      mingw-w64-x86_64-glib2
      mingw-w64-x86_64-gnutls
@@ -72,7 +71,7 @@ msys2-64bit:
  # for the msys2 64-bit job, due to the build could not complete within
  # the project timeout.
  - ..\msys64\usr\bin\bash -lc '../configure --target-list=x86_64-softmmu
-      --without-default-devices --enable-fdt=system'
+      --without-default-devices'
  - ..\msys64\usr\bin\bash -lc 'make'
  # qTests don't run successfully with "--without-default-devices",
  # so let's exclude the qtests from CI for now.
@@ -87,7 +86,6 @@ msys2-32bit:
      mingw-w64-i686-capstone
      mingw-w64-i686-curl
      mingw-w64-i686-cyrus-sasl
-      mingw-w64-i686-dtc
      mingw-w64-i686-gcc
      mingw-w64-i686-glib2
      mingw-w64-i686-gnutls
@@ -115,8 +113,7 @@ msys2-32bit:
  - $env:MSYS = 'winsymlinks:native' # Enable native Windows symlink
  - mkdir output
  - cd output
-  - ..\msys64\usr\bin\bash -lc '../configure --target-list=ppc64-softmmu
-                                --enable-fdt=system'
+  - ..\msys64\usr\bin\bash -lc '../configure --target-list=ppc64-softmmu'
  - ..\msys64\usr\bin\bash -lc 'make'
  - ..\msys64\usr\bin\bash -lc 'make check MTESTARGS=\"--no-suite qtest\" ||
                                { cat meson-logs/testlog.txt; exit 1; }'
--- a/.gitmodules
+++ b/.gitmodules
@@ -13,6 +13,9 @@
 [submodule "roms/qemu-palcode"]
 	path = roms/qemu-palcode
 	url = https://gitlab.com/qemu-project/qemu-palcode.git
+[submodule "roms/sgabios"]
+	path = roms/sgabios
+	url = https://gitlab.com/qemu-project/sgabios.git
 [submodule "dtc"]
 	path = dtc
 	url = https://gitlab.com/qemu-project/dtc.git
--- a/31
+++ b/31
@@ -123,7 +123,6 @@ M: Richard Henderson <richard.henderson@linaro.org>
 R: Paolo Bonzini <pbonzini@redhat.com>
 S: Maintained
 F: softmmu/cpus.c
-F: softmmu/watchpoint.c
 F: cpus-common.c
 F: page-vary.c
 F: page-vary-common.c
@@ -162,7 +161,6 @@ M: Peter Maydell <peter.maydell@linaro.org>
 L: qemu-arm@nongnu.org
 S: Maintained
 F: target/arm/
-F: target/arm/tcg/
 F: tests/tcg/arm/
 F: tests/tcg/aarch64/
 F: tests/qtest/arm-cpu-features.c
@@ -289,9 +287,6 @@ RISC-V TCG CPUs
 M: Palmer Dabbelt <palmer@dabbelt.com>
 M: Alistair Francis <alistair.francis@wdc.com>
 M: Bin Meng <bin.meng@windriver.com>
-R: Weiwei Li <liweiwei@iscas.ac.cn>
-R: Daniel Henrique Barboza <dbarboza@ventanamicro.com>
-R: Liu Zhiwei <zhiwei_liu@linux.alibaba.com>
 L: qemu-riscv@nongnu.org
 S: Supported
 F: target/riscv/
@@ -812,13 +807,13 @@ F: include/hw/net/mv88w8618_eth.h
 F: docs/system/arm/musicpal.rst

 Nuvoton NPCM7xx
+M: Havard Skinnemoen <hskinnemoen@google.com>
 M: Tyrone Ting <kfting@nuvoton.com>
-M: Hao Wu <wuhaotsh@google.com>
 L: qemu-arm@nongnu.org
 S: Supported
-F: hw/*/npcm*
-F: include/hw/*/npcm*
-F: tests/qtest/npcm*
+F: hw/*/npcm7xx*
+F: include/hw/*/npcm7xx*
+F: tests/qtest/npcm7xx*
 F: pc-bios/npcm7xx_bootrom.bin
 F: roms/vbootrom
 F: docs/system/arm/nuvoton.rst
@@ -1680,8 +1675,8 @@ F: hw/i2c/smbus_ich9.c
 F: hw/acpi/piix4.c
 F: hw/acpi/ich9*.c
 F: include/hw/acpi/ich9*.h
-F: include/hw/southbridge/ich9.h
 F: include/hw/southbridge/piix.h
+F: hw/misc/sga.c
 F: hw/isa/apm.c
 F: include/hw/isa/apm.h
 F: tests/unit/test-x86-cpuid.c
@@ -1713,7 +1708,6 @@ F: include/hw/char/parallel.h
 F: include/hw/dma/i8257.h
 F: include/hw/i2c/pm_smbus.h
 F: include/hw/input/i8042.h
-F: include/hw/intc/ioapic*
 F: include/hw/isa/i8259_internal.h
 F: include/hw/isa/superio.h
 F: include/hw/timer/hpet.h
@@ -1798,7 +1792,7 @@ F: hw/misc/edu.c
 IDE
 M: John Snow <jsnow@redhat.com>
 L: qemu-block@nongnu.org
-S: Odd Fixes
+S: Supported
 F: include/hw/ide.h
 F: include/hw/ide/
 F: hw/ide/
@@ -1823,7 +1817,7 @@ T: git https://github.com/cminyard/qemu.git master-ipmi-rebase
 Floppy
 M: John Snow <jsnow@redhat.com>
 L: qemu-block@nongnu.org
-S: Odd Fixes
+S: Supported
 F: hw/block/fdc.c
 F: hw/block/fdc-internal.h
 F: hw/block/fdc-isa.c
@@ -2002,7 +1996,6 @@ F: hw/usb/dev-serial.c

 VFIO
 M: Alex Williamson <alex.williamson@redhat.com>
-R: Cédric Le Goater <clg@redhat.com>
 S: Supported
 F: hw/vfio/*
 F: include/hw/vfio/
@@ -2104,8 +2097,10 @@ virtiofs
 M: Dr. David Alan Gilbert <dgilbert@redhat.com>
 M: Stefan Hajnoczi <stefanha@redhat.com>
 S: Supported
+F: tools/virtiofsd/*
 F: hw/virtio/vhost-user-fs*
 F: include/hw/virtio/vhost-user-fs.h
+F: docs/tools/virtiofsd.rst
 L: virtio-fs@redhat.com

 virtio-input
@@ -2280,6 +2275,7 @@ F: hw/acpi/vmgenid.c
 F: include/hw/acpi/vmgenid.h
 F: docs/specs/vmgenid.txt
 F: tests/qtest/vmgenid-test.c
+F: stubs/vmgenid.c

 LED
 M: Philippe Mathieu-Daudé <philmd@linaro.org>
@@ -2637,7 +2633,6 @@ T: git https://gitlab.com/vsementsov/qemu.git block
 Compute Express Link
 M: Ben Widawsky <ben.widawsky@intel.com>
 M: Jonathan Cameron <jonathan.cameron@huawei.com>
-R: Fan Ni <fan.ni@samsung.com>
 S: Supported
 F: hw/cxl/
 F: hw/mem/cxl_type3.c
@@ -2820,8 +2815,6 @@ F: qapi/run-state.json
 Read, Copy, Update (RCU)
 M: Paolo Bonzini <pbonzini@redhat.com>
 S: Maintained
-F: docs/devel/lockcnt.txt
-F: docs/devel/rcu.txt
 F: include/qemu/rcu*.h
 F: tests/unit/rcutorture.c
 F: tests/unit/test-rcu-*.c
@@ -3243,7 +3236,6 @@ S: Supported
 F: replay/*
 F: block/blkreplay.c
 F: net/filter-replay.c
-F: include/exec/replay-core.h
 F: include/sysemu/replay.h
 F: docs/devel/replay.rst
 F: docs/system/replay.rst
@@ -3588,11 +3580,13 @@ F: block/dmg.c
 parallels
 M: Stefan Hajnoczi <stefanha@redhat.com>
 M: Denis V. Lunev <den@openvz.org>
+M: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>
 L: qemu-block@nongnu.org
 S: Supported
 F: block/parallels.c
 F: block/parallels-ext.c
 F: docs/interop/parallels.txt
+T: git https://gitlab.com/vsementsov/qemu.git block

 qed
 M: Stefan Hajnoczi <stefanha@redhat.com>
@@ -3767,7 +3761,6 @@ F: scripts/ci/
 F: tests/docker/
 F: tests/vm/
 F: tests/lcitool/
-F: tests/avocado/tuxrun_baselines.py
 F: scripts/archive-source.sh
 F: docs/devel/testing.rst
 W: https://gitlab.com/qemu-project/qemu/pipelines
--- a/4
+++ b/4
@@ -220,7 +220,7 @@ qemu-%.tar.bz2:

 distclean: clean recurse-distclean
 	-$(quiet-@)test -f build.ninja && $(NINJA) $(NINJAFLAGS) -t clean -g || :
-	rm -f config-host.mak Makefile.prereqs
+	rm -f config-host.mak Makefile.prereqs qemu-bundle
 	rm -f tests/tcg/*/config-target.mak tests/tcg/config-host.mak
 	rm -f config.status
 	rm -f roms/seabios/config.mak
@@ -230,7 +230,7 @@ distclean: clean recurse-distclean
 	rm -f Makefile.ninja Makefile.mtest build.ninja.stamp meson.stamp
 	rm -f config.log
 	rm -f linux-headers/asm
-	rm -Rf .sdk qemu-bundle
+	rm -Rf .sdk

 find-src-path = find "$(SRC_PATH)" -path "$(SRC_PATH)/meson" -prune -o \
 	-type l -prune -o \( -name "*.[chsS]" -o -name "*.[ch].inc" \)
--- a/accel/kvm/kvm-all.c
+++ b/accel/kvm/kvm-all.c
@@ -2361,13 +2361,13 @@ static int kvm_init(MachineState *ms)
    static const char upgrade_note[] =
        "Please upgrade to at least kernel 2.6.29 or recent kvm-kmod\n"
        "(see http://sourceforge.net/projects/kvm).\n";
-    const struct {
+    struct {
        const char *name;
        int num;
    } num_cpus[] = {
        { "SMP",          ms->smp.cpus },
        { "hotpluggable", ms->smp.max_cpus },
-        { /* end of list */ }
+        { NULL, }
    }, *nc = num_cpus;
    int soft_vcpus_limit, hard_vcpus_limit;
    KVMState *s;
@@ -3305,7 +3305,7 @@ bool kvm_supports_guest_debug(void)
    return kvm_has_guest_debug;
 }

-int kvm_insert_breakpoint(CPUState *cpu, int type, vaddr addr, vaddr len)
+int kvm_insert_breakpoint(CPUState *cpu, int type, hwaddr addr, hwaddr len)
 {
    struct kvm_sw_breakpoint *bp;
    int err;
@@ -3343,7 +3343,7 @@ int kvm_insert_breakpoint(CPUState *cpu, int type, vaddr addr, vaddr len)
    return 0;
 }

-int kvm_remove_breakpoint(CPUState *cpu, int type, vaddr addr, vaddr len)
+int kvm_remove_breakpoint(CPUState *cpu, int type, hwaddr addr, hwaddr len)
 {
    struct kvm_sw_breakpoint *bp;
    int err;
@@ -3703,9 +3703,6 @@ static void kvm_accel_instance_init(Object *obj)
    s->kvm_dirty_ring_size = 0;
    s->notify_vmexit = NOTIFY_VMEXIT_OPTION_RUN;
    s->notify_window = 0;
-    s->xen_version = 0;
-    s->xen_gnttab_max_frames = 64;
-    s->xen_evtchn_max_pirq = 256;
 }

 /**
--- a/accel/kvm/kvm-cpus.h
+++ b/accel/kvm/kvm-cpus.h
@@ -19,8 +19,8 @@ void kvm_cpu_synchronize_post_reset(CPUState *cpu);
 void kvm_cpu_synchronize_post_init(CPUState *cpu);
 void kvm_cpu_synchronize_pre_loadvm(CPUState *cpu);
 bool kvm_supports_guest_debug(void);
-int kvm_insert_breakpoint(CPUState *cpu, int type, vaddr addr, vaddr len);
-int kvm_remove_breakpoint(CPUState *cpu, int type, vaddr addr, vaddr len);
+int kvm_insert_breakpoint(CPUState *cpu, int type, hwaddr addr, hwaddr len);
+int kvm_remove_breakpoint(CPUState *cpu, int type, hwaddr addr, hwaddr len);
 void kvm_remove_all_breakpoints(CPUState *cpu);

 #endif /* KVM_CPUS_H */
--- a/accel/stubs/tcg-stub.c
+++ b/accel/stubs/tcg-stub.c
@@ -25,7 +25,7 @@ void tcg_flush_jmp_cache(CPUState *cpu)
 {
 }

-int probe_access_flags(CPUArchState *env, target_ulong addr, int size,
+int probe_access_flags(CPUArchState *env, target_ulong addr,
                       MMUAccessType access_type, int mmu_idx,
                       bool nonfault, void **phost, uintptr_t retaddr)
 {
--- a/accel/tcg/cpu-exec.c
+++ b/accel/tcg/cpu-exec.c
@@ -20,6 +20,7 @@
 #include "qemu/osdep.h"
 #include "qemu/qemu-print.h"
 #include "qapi/error.h"
+#include "qapi/qapi-commands-machine.h"
 #include "qapi/type-helpers.h"
 #include "hw/core/tcg-cpu-ops.h"
 #include "trace.h"
@@ -27,6 +28,7 @@
 #include "exec/exec-all.h"
 #include "tcg/tcg.h"
 #include "qemu/atomic.h"
+#include "qemu/timer.h"
 #include "qemu/rcu.h"
 #include "exec/log.h"
 #include "qemu/main-loop.h"
@@ -36,7 +38,7 @@
 #include "sysemu/cpus.h"
 #include "exec/cpu-all.h"
 #include "sysemu/cpu-timers.h"
-#include "exec/replay-core.h"
+#include "sysemu/replay.h"
 #include "sysemu/tcg.h"
 #include "exec/helper-proto.h"
 #include "tb-jmp-cache.h"
@@ -62,8 +64,8 @@ typedef struct SyncClocks {
 #define MAX_DELAY_PRINT_RATE 2000000000LL
 #define MAX_NB_PRINTS 100

-int64_t max_delay;
-int64_t max_advance;
+static int64_t max_delay;
+static int64_t max_advance;

 static void align_clocks(SyncClocks *sc, CPUState *cpu)
 {
@@ -183,7 +185,7 @@ static bool tb_lookup_cmp(const void *p, const void *d)
    const TranslationBlock *tb = p;
    const struct tb_desc *desc = d;

-    if ((tb_cflags(tb) & CF_PCREL || tb->pc == desc->pc) &&
+    if ((TARGET_TB_PCREL || tb_pc(tb) == desc->pc) &&
        tb_page_addr0(tb) == desc->page_addr0 &&
        tb->cs_base == desc->cs_base &&
        tb->flags == desc->flags &&
@@ -235,7 +237,7 @@ static TranslationBlock *tb_htable_lookup(CPUState *cpu, target_ulong pc,
        return NULL;
    }
    desc.page_addr0 = phys_pc;
-    h = tb_hash_func(phys_pc, (cflags & CF_PCREL ? 0 : pc),
+    h = tb_hash_func(phys_pc, (TARGET_TB_PCREL ? 0 : pc),
                     flags, cflags, *cpu->trace_dstate);
    return qht_lookup_custom(&tb_ctx.htable, &desc, h, tb_lookup_cmp);
 }
@@ -254,46 +256,21 @@ static inline TranslationBlock *tb_lookup(CPUState *cpu, target_ulong pc,

    hash = tb_jmp_cache_hash_func(pc);
    jc = cpu->tb_jmp_cache;
+    tb = tb_jmp_cache_get_tb(jc, hash);

-    if (cflags & CF_PCREL) {
-        /* Use acquire to ensure current load of pc from jc. */
-        tb =  qatomic_load_acquire(&jc->array[hash].tb);
-
-        if (likely(tb &&
-                   jc->array[hash].pc == pc &&
-                   tb->cs_base == cs_base &&
-                   tb->flags == flags &&
-                   tb->trace_vcpu_dstate == *cpu->trace_dstate &&
-                   tb_cflags(tb) == cflags)) {
-            return tb;
-        }
-        tb = tb_htable_lookup(cpu, pc, cs_base, flags, cflags);
-        if (tb == NULL) {
-            return NULL;
-        }
-        jc->array[hash].pc = pc;
-        /* Use store_release on tb to ensure pc is written first. */
-        qatomic_store_release(&jc->array[hash].tb, tb);
-    } else {
-        /* Use rcu_read to ensure current load of pc from *tb. */
-        tb = qatomic_rcu_read(&jc->array[hash].tb);
-
-        if (likely(tb &&
-                   tb->pc == pc &&
-                   tb->cs_base == cs_base &&
-                   tb->flags == flags &&
-                   tb->trace_vcpu_dstate == *cpu->trace_dstate &&
-                   tb_cflags(tb) == cflags)) {
-            return tb;
-        }
-        tb = tb_htable_lookup(cpu, pc, cs_base, flags, cflags);
-        if (tb == NULL) {
-            return NULL;
-        }
-        /* Use the pc value already stored in tb->pc. */
-        qatomic_set(&jc->array[hash].tb, tb);
+    if (likely(tb &&
+               tb_jmp_cache_get_pc(jc, hash, tb) == pc &&
+               tb->cs_base == cs_base &&
+               tb->flags == flags &&
+               tb->trace_vcpu_dstate == *cpu->trace_dstate &&
+               tb_cflags(tb) == cflags)) {
+        return tb;
    }
-
+    tb = tb_htable_lookup(cpu, pc, cs_base, flags, cflags);
+    if (tb == NULL) {
+        return NULL;
+    }
+    tb_jmp_cache_set(jc, hash, tb, pc);
    return tb;
 }

@@ -482,9 +459,9 @@ cpu_tb_exec(CPUState *cpu, TranslationBlock *itb, int *tb_exit)
        if (cc->tcg_ops->synchronize_from_tb) {
            cc->tcg_ops->synchronize_from_tb(cpu, last_tb);
        } else {
-            tcg_debug_assert(!(tb_cflags(last_tb) & CF_PCREL));
+            assert(!TARGET_TB_PCREL);
            assert(cc->set_pc);
-            cc->set_pc(cpu, last_tb->pc);
+            cc->set_pc(cpu, tb_pc(last_tb));
        }
        if (qemu_loglevel_mask(CPU_LOG_EXEC)) {
            target_ulong pc = log_pc(cpu, last_tb);
@@ -982,8 +959,7 @@ cpu_exec_loop(CPUState *cpu, SyncClocks *sc)
                 * for the fast lookup
                 */
                h = tb_jmp_cache_hash_func(pc);
-                /* Use the pc value already stored in tb->pc. */
-                qatomic_set(&cpu->tb_jmp_cache->array[h].tb, tb);
+                tb_jmp_cache_set(cpu->tb_jmp_cache, h, tb, pc);
            }

 #ifndef CONFIG_USER_ONLY
@@ -1096,3 +1072,86 @@ void tcg_exec_unrealizefn(CPUState *cpu)
    tlb_destroy(cpu);
    g_free_rcu(cpu->tb_jmp_cache, rcu);
 }
+
+#ifndef CONFIG_USER_ONLY
+
+static void dump_drift_info(GString *buf)
+{
+    if (!icount_enabled()) {
+        return;
+    }
+
+    g_string_append_printf(buf, "Host - Guest clock  %"PRIi64" ms\n",
+                           (cpu_get_clock() - icount_get()) / SCALE_MS);
+    if (icount_align_option) {
+        g_string_append_printf(buf, "Max guest delay     %"PRIi64" ms\n",
+                               -max_delay / SCALE_MS);
+        g_string_append_printf(buf, "Max guest advance   %"PRIi64" ms\n",
+                               max_advance / SCALE_MS);
+    } else {
+        g_string_append_printf(buf, "Max guest delay     NA\n");
+        g_string_append_printf(buf, "Max guest advance   NA\n");
+    }
+}
+
+HumanReadableText *qmp_x_query_jit(Error **errp)
+{
+    g_autoptr(GString) buf = g_string_new("");
+
+    if (!tcg_enabled()) {
+        error_setg(errp, "JIT information is only available with accel=tcg");
+        return NULL;
+    }
+
+    dump_exec_info(buf);
+    dump_drift_info(buf);
+
+    return human_readable_text_from_str(buf);
+}
+
+HumanReadableText *qmp_x_query_opcount(Error **errp)
+{
+    g_autoptr(GString) buf = g_string_new("");
+
+    if (!tcg_enabled()) {
+        error_setg(errp, "Opcode count information is only available with accel=tcg");
+        return NULL;
+    }
+
+    tcg_dump_op_count(buf);
+
+    return human_readable_text_from_str(buf);
+}
+
+#ifdef CONFIG_PROFILER
+
+int64_t dev_time;
+
+HumanReadableText *qmp_x_query_profile(Error **errp)
+{
+    g_autoptr(GString) buf = g_string_new("");
+    static int64_t last_cpu_exec_time;
+    int64_t cpu_exec_time;
+    int64_t delta;
+
+    cpu_exec_time = tcg_cpu_exec_time();
+    delta = cpu_exec_time - last_cpu_exec_time;
+
+    g_string_append_printf(buf, "async time  %" PRId64 " (%0.3f)\n",
+                           dev_time, dev_time / (double)NANOSECONDS_PER_SECOND);
+    g_string_append_printf(buf, "qemu time   %" PRId64 " (%0.3f)\n",
+                           delta, delta / (double)NANOSECONDS_PER_SECOND);
+    last_cpu_exec_time = cpu_exec_time;
+    dev_time = 0;
+
+    return human_readable_text_from_str(buf);
+}
+#else
+HumanReadableText *qmp_x_query_profile(Error **errp)
+{
+    error_setg(errp, "Internal profiler not compiled");
+    return NULL;
+}
+#endif
+
+#endif /* !CONFIG_USER_ONLY */
--- a/accel/tcg/cputlb.c
+++ b/accel/tcg/cputlb.c
@@ -1250,6 +1250,7 @@ void tlb_set_page_full(CPUState *cpu, int mmu_idx,
    desc->fulltlb[index] = *full;
    desc->fulltlb[index].xlat_section = iotlb - vaddr_page;
    desc->fulltlb[index].phys_addr = paddr_page;
+    desc->fulltlb[index].prot = prot;

    /* Now calculate the new entry */
    tn.addend = addend - vaddr_page;
@@ -1588,12 +1589,12 @@ static int probe_access_internal(CPUArchState *env, target_ulong addr,
    return flags;
 }

-int probe_access_full(CPUArchState *env, target_ulong addr, int size,
+int probe_access_full(CPUArchState *env, target_ulong addr,
                      MMUAccessType access_type, int mmu_idx,
                      bool nonfault, void **phost, CPUTLBEntryFull **pfull,
                      uintptr_t retaddr)
 {
-    int flags = probe_access_internal(env, addr, size, access_type, mmu_idx,
+    int flags = probe_access_internal(env, addr, 0, access_type, mmu_idx,
                                      nonfault, phost, pfull, retaddr);

    /* Handle clean RAM pages.  */
@@ -1605,25 +1606,14 @@ int probe_access_full(CPUArchState *env, target_ulong addr, int size,
    return flags;
 }

-int probe_access_flags(CPUArchState *env, target_ulong addr, int size,
+int probe_access_flags(CPUArchState *env, target_ulong addr,
                       MMUAccessType access_type, int mmu_idx,
                       bool nonfault, void **phost, uintptr_t retaddr)
 {
    CPUTLBEntryFull *full;
-    int flags;

-    g_assert(-(addr | TARGET_PAGE_MASK) >= size);
-
-    flags = probe_access_internal(env, addr, size, access_type, mmu_idx,
-                                  nonfault, phost, &full, retaddr);
-
-    /* Handle clean RAM pages. */
-    if (unlikely(flags & TLB_NOTDIRTY)) {
-        notdirty_write(env_cpu(env), addr, 1, full, retaddr);
-        flags &= ~TLB_NOTDIRTY;
-    }
-
-    return flags;
+    return probe_access_full(env, addr, access_type, mmu_idx,
+                             nonfault, phost, &full, retaddr);
 }

 void *probe_access(CPUArchState *env, target_ulong addr, int size,
@@ -1767,7 +1757,6 @@ static void *atomic_mmu_lookup(CPUArchState *env, target_ulong addr,
    CPUTLBEntry *tlbe;
    target_ulong tlb_addr;
    void *hostaddr;
-    CPUTLBEntryFull *full;

    tcg_debug_assert(mmu_idx < NB_MMU_MODES);

@@ -1806,26 +1795,17 @@ static void *atomic_mmu_lookup(CPUArchState *env, target_ulong addr,
            tlb_addr = tlb_addr_write(tlbe) & ~TLB_INVALID_MASK;
        }

-        if (prot & PAGE_READ) {
+        /* Let the guest notice RMW on a write-only page.  */
+        if ((prot & PAGE_READ) &&
+            unlikely(tlbe->addr_read != (tlb_addr & ~TLB_NOTDIRTY))) {
+            tlb_fill(env_cpu(env), addr, size,
+                     MMU_DATA_LOAD, mmu_idx, retaddr);
            /*
-             * Let the guest notice RMW on a write-only page.
-             * We have just verified that the page is writable.
-             * Subpage lookups may have left TLB_INVALID_MASK set,
-             * but addr_read will only be -1 if PAGE_READ was unset.
+             * Since we don't support reads and writes to different addresses,
+             * and we do have the proper page loaded for write, this shouldn't
+             * ever return.  But just in case, handle via stop-the-world.
             */
-            if (unlikely(tlbe->addr_read == -1)) {
-                tlb_fill(env_cpu(env), addr, size,
-                         MMU_DATA_LOAD, mmu_idx, retaddr);
-                /*
-                 * Since we don't support reads and writes to different
-                 * addresses, and we do have the proper page loaded for
-                 * write, this shouldn't ever return.  But just in case,
-                 * handle via stop-the-world.
-                 */
-                goto stop_the_world;
-            }
-            /* Collect TLB_WATCHPOINT for read. */
-            tlb_addr |= tlbe->addr_read;
+            goto stop_the_world;
        }
    } else /* if (prot & PAGE_READ) */ {
        tlb_addr = tlbe->addr_read;
@@ -1841,25 +1821,17 @@ static void *atomic_mmu_lookup(CPUArchState *env, target_ulong addr,
    }

    /* Notice an IO access or a needs-MMU-lookup access */
-    if (unlikely(tlb_addr & (TLB_MMIO | TLB_DISCARD_WRITE))) {
+    if (unlikely(tlb_addr & TLB_MMIO)) {
        /* There's really nothing that can be done to
           support this apart from stop-the-world.  */
        goto stop_the_world;
    }

    hostaddr = (void *)((uintptr_t)addr + tlbe->addend);
-    full = &env_tlb(env)->d[mmu_idx].fulltlb[index];

    if (unlikely(tlb_addr & TLB_NOTDIRTY)) {
-        notdirty_write(env_cpu(env), addr, size, full, retaddr);
-    }
-
-    if (unlikely(tlb_addr & TLB_WATCHPOINT)) {
-        QEMU_BUILD_BUG_ON(PAGE_READ != BP_MEM_READ);
-        QEMU_BUILD_BUG_ON(PAGE_WRITE != BP_MEM_WRITE);
-        /* therefore prot == watchpoint bits */
-        cpu_check_watchpoint(env_cpu(env), addr, size,
-                             full->attrs, prot, retaddr);
+        notdirty_write(env_cpu(env), addr, size,
+                       &env_tlb(env)->d[mmu_idx].fulltlb[index], retaddr);
    }

    return hostaddr;
--- a/accel/tcg/hmp.c
+++ b/accel/tcg/hmp.c
@@ -0,0 +1,14 @@
+#include "qemu/osdep.h"
+#include "qemu/error-report.h"
+#include "qapi/error.h"
+#include "qapi/qapi-commands-machine.h"
+#include "exec/exec-all.h"
+#include "monitor/monitor.h"
+
+static void hmp_tcg_register(void)
+{
+    monitor_register_hmp_info_hrt("jit", qmp_x_query_jit);
+    monitor_register_hmp_info_hrt("opcount", qmp_x_query_opcount);
+}
+
+type_init(hmp_tcg_register);
--- a/accel/tcg/internal.h
+++ b/accel/tcg/internal.h
@@ -57,14 +57,11 @@ void cpu_restore_state_from_tb(CPUState *cpu, TranslationBlock *tb,
 /* Return the current PC from CPU, which may be cached in TB. */
 static inline target_ulong log_pc(CPUState *cpu, const TranslationBlock *tb)
 {
-    if (tb_cflags(tb) & CF_PCREL) {
-        return cpu->cc->get_pc(cpu);
-    } else {
-        return tb->pc;
-    }
+#if TARGET_TB_PCREL
+    return cpu->cc->get_pc(cpu);
+#else
+    return tb_pc(tb);
+#endif
 }

-extern int64_t max_delay;
-extern int64_t max_advance;
-
 #endif /* ACCEL_TCG_INTERNAL_H */
--- a/accel/tcg/meson.build
+++ b/accel/tcg/meson.build
@@ -18,7 +18,7 @@ specific_ss.add_all(when: 'CONFIG_TCG', if_true: tcg_ss)

 specific_ss.add(when: ['CONFIG_SOFTMMU', 'CONFIG_TCG'], if_true: files(
  'cputlb.c',
-  'monitor.c',
+  'hmp.c',
 ))

 tcg_module_ss.add(when: ['CONFIG_SOFTMMU', 'CONFIG_TCG'], if_true: files(
--- a/accel/tcg/monitor.c
+++ b/accel/tcg/monitor.c
@@ -1,106 +0,0 @@
-/*
- * SPDX-License-Identifier: LGPL-2.1-or-later
- *
- *  QEMU TCG monitor
- *
- *  Copyright (c) 2003-2005 Fabrice Bellard
- */
-
-#include "qemu/osdep.h"
-#include "qapi/error.h"
-#include "qapi/type-helpers.h"
-#include "qapi/qapi-commands-machine.h"
-#include "monitor/monitor.h"
-#include "sysemu/cpus.h"
-#include "sysemu/cpu-timers.h"
-#include "sysemu/tcg.h"
-#include "internal.h"
-
-
-static void dump_drift_info(GString *buf)
-{
-    if (!icount_enabled()) {
-        return;
-    }
-
-    g_string_append_printf(buf, "Host - Guest clock  %"PRIi64" ms\n",
-                           (cpu_get_clock() - icount_get()) / SCALE_MS);
-    if (icount_align_option) {
-        g_string_append_printf(buf, "Max guest delay     %"PRIi64" ms\n",
-                               -max_delay / SCALE_MS);
-        g_string_append_printf(buf, "Max guest advance   %"PRIi64" ms\n",
-                               max_advance / SCALE_MS);
-    } else {
-        g_string_append_printf(buf, "Max guest delay     NA\n");
-        g_string_append_printf(buf, "Max guest advance   NA\n");
-    }
-}
-
-HumanReadableText *qmp_x_query_jit(Error **errp)
-{
-    g_autoptr(GString) buf = g_string_new("");
-
-    if (!tcg_enabled()) {
-        error_setg(errp, "JIT information is only available with accel=tcg");
-        return NULL;
-    }
-
-    dump_exec_info(buf);
-    dump_drift_info(buf);
-
-    return human_readable_text_from_str(buf);
-}
-
-HumanReadableText *qmp_x_query_opcount(Error **errp)
-{
-    g_autoptr(GString) buf = g_string_new("");
-
-    if (!tcg_enabled()) {
-        error_setg(errp,
-                   "Opcode count information is only available with accel=tcg");
-        return NULL;
-    }
-
-    tcg_dump_op_count(buf);
-
-    return human_readable_text_from_str(buf);
-}
-
-#ifdef CONFIG_PROFILER
-
-int64_t dev_time;
-
-HumanReadableText *qmp_x_query_profile(Error **errp)
-{
-    g_autoptr(GString) buf = g_string_new("");
-    static int64_t last_cpu_exec_time;
-    int64_t cpu_exec_time;
-    int64_t delta;
-
-    cpu_exec_time = tcg_cpu_exec_time();
-    delta = cpu_exec_time - last_cpu_exec_time;
-
-    g_string_append_printf(buf, "async time  %" PRId64 " (%0.3f)\n",
-                           dev_time, dev_time / (double)NANOSECONDS_PER_SECOND);
-    g_string_append_printf(buf, "qemu time   %" PRId64 " (%0.3f)\n",
-                           delta, delta / (double)NANOSECONDS_PER_SECOND);
-    last_cpu_exec_time = cpu_exec_time;
-    dev_time = 0;
-
-    return human_readable_text_from_str(buf);
-}
-#else
-HumanReadableText *qmp_x_query_profile(Error **errp)
-{
-    error_setg(errp, "Internal profiler not compiled");
-    return NULL;
-}
-#endif
-
-static void hmp_tcg_register(void)
-{
-    monitor_register_hmp_info_hrt("jit", qmp_x_query_jit);
-    monitor_register_hmp_info_hrt("opcount", qmp_x_query_opcount);
-}
-
-type_init(hmp_tcg_register);
--- a/accel/tcg/perf.c
+++ b/accel/tcg/perf.c
@@ -328,7 +328,7 @@ void perf_report_code(uint64_t guest_pc, TranslationBlock *tb,
    for (insn = 0; insn < tb->icount; insn++) {
        /* FIXME: This replicates the restore_state_to_opc() logic. */
        q[insn].address = tcg_ctx->gen_insn_data[insn][0];
-        if (tb_cflags(tb) & CF_PCREL) {
+        if (TARGET_TB_PCREL) {
            q[insn].address |= (guest_pc & TARGET_PAGE_MASK);
        } else {
 #if defined(TARGET_I386)
--- a/accel/tcg/plugin-gen.c
+++ b/accel/tcg/plugin-gen.c
@@ -93,13 +93,11 @@ void HELPER(plugin_vcpu_mem_cb)(unsigned int vcpu_index,

 static void do_gen_mem_cb(TCGv vaddr, uint32_t info)
 {
-    TCGv_i32 cpu_index = tcg_temp_ebb_new_i32();
-    TCGv_i32 meminfo = tcg_temp_ebb_new_i32();
-    TCGv_i64 vaddr64 = tcg_temp_ebb_new_i64();
-    TCGv_ptr udata = tcg_temp_ebb_new_ptr();
+    TCGv_i32 cpu_index = tcg_temp_new_i32();
+    TCGv_i32 meminfo = tcg_const_i32(info);
+    TCGv_i64 vaddr64 = tcg_temp_new_i64();
+    TCGv_ptr udata = tcg_const_ptr(NULL);

-    tcg_gen_movi_i32(meminfo, info);
-    tcg_gen_movi_ptr(udata, 0);
    tcg_gen_ld_i32(cpu_index, cpu_env,
                   -offsetof(ArchCPU, env) + offsetof(CPUState, cpu_index));
    tcg_gen_extu_tl_i64(vaddr64, vaddr);
@@ -114,10 +112,9 @@ static void do_gen_mem_cb(TCGv vaddr, uint32_t info)

 static void gen_empty_udata_cb(void)
 {
-    TCGv_i32 cpu_index = tcg_temp_ebb_new_i32();
-    TCGv_ptr udata = tcg_temp_ebb_new_ptr();
+    TCGv_i32 cpu_index = tcg_temp_new_i32();
+    TCGv_ptr udata = tcg_const_ptr(NULL); /* will be overwritten later */

-    tcg_gen_movi_ptr(udata, 0);
    tcg_gen_ld_i32(cpu_index, cpu_env,
                   -offsetof(ArchCPU, env) + offsetof(CPUState, cpu_index));
    gen_helper_plugin_vcpu_udata_cb(cpu_index, udata);
@@ -132,10 +129,9 @@ static void gen_empty_udata_cb(void)
 */
 static void gen_empty_inline_cb(void)
 {
-    TCGv_i64 val = tcg_temp_ebb_new_i64();
-    TCGv_ptr ptr = tcg_temp_ebb_new_ptr();
+    TCGv_i64 val = tcg_temp_new_i64();
+    TCGv_ptr ptr = tcg_const_ptr(NULL); /* overwritten later */

-    tcg_gen_movi_ptr(ptr, 0);
    tcg_gen_ld_i64(val, ptr, 0);
    /* pass an immediate != 0 so that it doesn't get optimized away */
    tcg_gen_addi_i64(val, val, 0xdeadface);
@@ -155,9 +151,9 @@ static void gen_empty_mem_cb(TCGv addr, uint32_t info)
 */
 static void gen_empty_mem_helper(void)
 {
-    TCGv_ptr ptr = tcg_temp_ebb_new_ptr();
+    TCGv_ptr ptr;

-    tcg_gen_movi_ptr(ptr, 0);
+    ptr = tcg_const_ptr(NULL);
    tcg_gen_st_ptr(ptr, cpu_env, offsetof(CPUState, plugin_mem_cbs) -
                                 offsetof(ArchCPU, env));
    tcg_temp_free_ptr(ptr);
@@ -630,6 +626,8 @@ static void inject_mem_disable_helper(struct qemu_plugin_insn *plugin_insn,
 /* called before finishing a TB with exit_tb, goto_tb or goto_ptr */
 void plugin_gen_disable_mem_helpers(void)
 {
+    TCGv_ptr ptr;
+
    /*
     * We could emit the clearing unconditionally and be done. However, this can
     * be wasteful if for instance plugins don't track memory accesses, or if
@@ -642,8 +640,10 @@ void plugin_gen_disable_mem_helpers(void)
    if (!tcg_ctx->plugin_tb->mem_helper) {
        return;
    }
-    tcg_gen_st_ptr(tcg_constant_ptr(NULL), cpu_env,
-                   offsetof(CPUState, plugin_mem_cbs) - offsetof(ArchCPU, env));
+    ptr = tcg_const_ptr(NULL);
+    tcg_gen_st_ptr(ptr, cpu_env, offsetof(CPUState, plugin_mem_cbs) -
+                                 offsetof(ArchCPU, env));
+    tcg_temp_free_ptr(ptr);
 }

 static void plugin_gen_tb_udata(const struct qemu_plugin_tb *ptb,
--- a/accel/tcg/tb-jmp-cache.h
+++ b/accel/tcg/tb-jmp-cache.h
@@ -14,15 +14,53 @@

 /*
 * Accessed in parallel; all accesses to 'tb' must be atomic.
- * For CF_PCREL, accesses to 'pc' must be protected by a
- * load_acquire/store_release to 'tb'.
+ * For TARGET_TB_PCREL, accesses to 'pc' must be protected by
+ * a load_acquire/store_release to 'tb'.
 */
 struct CPUJumpCache {
    struct rcu_head rcu;
    struct {
        TranslationBlock *tb;
+#if TARGET_TB_PCREL
        target_ulong pc;
+#endif
    } array[TB_JMP_CACHE_SIZE];
 };

+static inline TranslationBlock *
+tb_jmp_cache_get_tb(CPUJumpCache *jc, uint32_t hash)
+{
+#if TARGET_TB_PCREL
+    /* Use acquire to ensure current load of pc from jc. */
+    return qatomic_load_acquire(&jc->array[hash].tb);
+#else
+    /* Use rcu_read to ensure current load of pc from *tb. */
+    return qatomic_rcu_read(&jc->array[hash].tb);
+#endif
+}
+
+static inline target_ulong
+tb_jmp_cache_get_pc(CPUJumpCache *jc, uint32_t hash, TranslationBlock *tb)
+{
+#if TARGET_TB_PCREL
+    return jc->array[hash].pc;
+#else
+    return tb_pc(tb);
+#endif
+}
+
+static inline void
+tb_jmp_cache_set(CPUJumpCache *jc, uint32_t hash,
+                 TranslationBlock *tb, target_ulong pc)
+{
+#if TARGET_TB_PCREL
+    jc->array[hash].pc = pc;
+    /* Use store_release on tb to ensure pc is written first. */
+    qatomic_store_release(&jc->array[hash].tb, tb);
+#else
+    /* Use the pc value already stored in tb->pc. */
+    qatomic_set(&jc->array[hash].tb, tb);
+#endif
+}
+
 #endif /* ACCEL_TCG_TB_JMP_CACHE_H */
--- a/accel/tcg/tb-maint.c
+++ b/accel/tcg/tb-maint.c
@@ -44,7 +44,7 @@ static bool tb_cmp(const void *ap, const void *bp)
    const TranslationBlock *a = ap;
    const TranslationBlock *b = bp;

-    return ((tb_cflags(a) & CF_PCREL || a->pc == b->pc) &&
+    return ((TARGET_TB_PCREL || tb_pc(a) == tb_pc(b)) &&
            a->cs_base == b->cs_base &&
            a->flags == b->flags &&
            (tb_cflags(a) & ~CF_INVALID) == (tb_cflags(b) & ~CF_INVALID) &&
@@ -847,13 +847,13 @@ static void tb_jmp_cache_inval_tb(TranslationBlock *tb)
 {
    CPUState *cpu;

-    if (tb_cflags(tb) & CF_PCREL) {
+    if (TARGET_TB_PCREL) {
        /* A TB may be at any virtual address */
        CPU_FOREACH(cpu) {
            tcg_flush_jmp_cache(cpu);
        }
    } else {
-        uint32_t h = tb_jmp_cache_hash_func(tb->pc);
+        uint32_t h = tb_jmp_cache_hash_func(tb_pc(tb));

        CPU_FOREACH(cpu) {
            CPUJumpCache *jc = cpu->tb_jmp_cache;
@@ -885,7 +885,7 @@ static void do_tb_phys_invalidate(TranslationBlock *tb, bool rm_from_page_list)

    /* remove the TB from the hash list */
    phys_pc = tb_page_addr0(tb);
-    h = tb_hash_func(phys_pc, (orig_cflags & CF_PCREL ? 0 : tb->pc),
+    h = tb_hash_func(phys_pc, (TARGET_TB_PCREL ? 0 : tb_pc(tb)),
                     tb->flags, orig_cflags, tb->trace_vcpu_dstate);
    if (!qht_remove(&tb_ctx.htable, tb, h)) {
        return;
@@ -966,7 +966,7 @@ TranslationBlock *tb_link_page(TranslationBlock *tb, tb_page_addr_t phys_pc,
    tb_record(tb, p, p2);

    /* add in the hash table */
-    h = tb_hash_func(phys_pc, (tb->cflags & CF_PCREL ? 0 : tb->pc),
+    h = tb_hash_func(phys_pc, (TARGET_TB_PCREL ? 0 : tb_pc(tb)),
                     tb->flags, tb->cflags, tb->trace_vcpu_dstate);
    qht_insert(&tb_ctx.htable, tb, h, &existing_tb);

--- a/accel/tcg/tcg-accel-ops.c
+++ b/accel/tcg/tcg-accel-ops.c
@@ -31,7 +31,6 @@
 #include "sysemu/cpu-timers.h"
 #include "qemu/main-loop.h"
 #include "qemu/guest-random.h"
-#include "qemu/timer.h"
 #include "exec/exec-all.h"
 #include "exec/hwaddr.h"
 #include "exec/gdbstub.h"
@@ -45,18 +44,7 @@

 void tcg_cpu_init_cflags(CPUState *cpu, bool parallel)
 {
-    uint32_t cflags;
-
-    /*
-     * Include the cluster number in the hash we use to look up TBs.
-     * This is important because a TB that is valid for one cluster at
-     * a given physical address and set of CPU flags is not necessarily
-     * valid for another:
-     * the two clusters may have different views of physical memory, or
-     * may have different CPU features (eg FPU present or absent).
-     */
-    cflags = cpu->cluster_index << CF_CLUSTER_SHIFT;
-
+    uint32_t cflags = cpu->cluster_index << CF_CLUSTER_SHIFT;
    cflags |= parallel ? CF_PARALLEL : 0;
    cflags |= icount_enabled() ? CF_USE_ICOUNT : 0;
    cpu->tcg_cflags = cflags;
@@ -128,7 +116,7 @@ static inline int xlat_gdb_type(CPUState *cpu, int gdbtype)
    return cputype;
 }

-static int tcg_insert_breakpoint(CPUState *cs, int type, vaddr addr, vaddr len)
+static int tcg_insert_breakpoint(CPUState *cs, int type, hwaddr addr, hwaddr len)
 {
    CPUState *cpu;
    int err = 0;
@@ -159,7 +147,7 @@ static int tcg_insert_breakpoint(CPUState *cs, int type, vaddr addr, vaddr len)
    }
 }

-static int tcg_remove_breakpoint(CPUState *cs, int type, vaddr addr, vaddr len)
+static int tcg_remove_breakpoint(CPUState *cs, int type, hwaddr addr, hwaddr len)
 {
    CPUState *cpu;
    int err = 0;
--- a/accel/tcg/tcg-all.c
+++ b/accel/tcg/tcg-all.c
@@ -25,7 +25,7 @@

 #include "qemu/osdep.h"
 #include "sysemu/tcg.h"
-#include "exec/replay-core.h"
+#include "sysemu/replay.h"
 #include "sysemu/cpu-timers.h"
 #include "tcg/tcg.h"
 #include "qapi/error.h"
--- a/accel/tcg/translate-all.c
+++ b/accel/tcg/translate-all.c
@@ -49,9 +49,9 @@
 #include "exec/translator.h"
 #include "qemu/bitmap.h"
 #include "qemu/qemu-print.h"
+#include "qemu/timer.h"
 #include "qemu/main-loop.h"
 #include "qemu/cacheinfo.h"
-#include "qemu/timer.h"
 #include "exec/log.h"
 #include "sysemu/cpus.h"
 #include "sysemu/cpu-timers.h"
@@ -135,7 +135,7 @@ static int encode_search(TranslationBlock *tb, uint8_t *block)

        for (j = 0; j < TARGET_INSN_START_WORDS; ++j) {
            if (i == 0) {
-                prev = (!(tb_cflags(tb) & CF_PCREL) && j == 0 ? tb->pc : 0);
+                prev = (!TARGET_TB_PCREL && j == 0 ? tb_pc(tb) : 0);
            } else {
                prev = tcg_ctx->gen_insn_data[i - 1][j];
            }
@@ -170,8 +170,8 @@ static int cpu_unwind_data_from_tb(TranslationBlock *tb, uintptr_t host_pc,
    }

    memset(data, 0, sizeof(uint64_t) * TARGET_INSN_START_WORDS);
-    if (!(tb_cflags(tb) & CF_PCREL)) {
-        data[0] = tb->pc;
+    if (!TARGET_TB_PCREL) {
+        data[0] = tb_pc(tb);
    }

    /*
@@ -281,7 +281,7 @@ static int setjmp_gen_code(CPUArchState *env, TranslationBlock *tb,
    tcg_func_start(tcg_ctx);

    tcg_ctx->cpu = env_cpu(env);
-    gen_intermediate_code(env_cpu(env), tb, max_insns, pc, host_pc);
+    gen_intermediate_code(env_cpu(env), tb, *max_insns, pc, host_pc);
    assert(tb->size != 0);
    tcg_ctx->cpu = NULL;
    *max_insns = tb->icount;
@@ -341,9 +341,9 @@ TranslationBlock *tb_gen_code(CPUState *cpu,

    gen_code_buf = tcg_ctx->code_gen_ptr;
    tb->tc.ptr = tcg_splitwx_to_rx(gen_code_buf);
-    if (!(cflags & CF_PCREL)) {
-        tb->pc = pc;
-    }
+#if !TARGET_TB_PCREL
+    tb->pc = pc;
+#endif
    tb->cs_base = cs_base;
    tb->flags = flags;
    tb->cflags = cflags;
@@ -408,8 +408,8 @@ TranslationBlock *tb_gen_code(CPUState *cpu,
    tb->tc.size = gen_code_size;

    /*
-     * For CF_PCREL, attribute all executions of the generated code
-     * to its first mapping.
+     * For TARGET_TB_PCREL, attribute all executions of the generated
+     * code to its first mapping.
     */
    perf_report_code(pc, tb, tcg_splitwx_to_rx(gen_code_buf));

--- a/accel/tcg/translator.c
+++ b/accel/tcg/translator.c
@@ -16,7 +16,20 @@
 #include "exec/log.h"
 #include "exec/translator.h"
 #include "exec/plugin-gen.h"
-#include "exec/replay-core.h"
+#include "sysemu/replay.h"
+
+/* Pairs with tcg_clear_temp_count.
+   To be called by #TranslatorOps.{translate_insn,tb_stop} if
+   (1) the target is sufficiently clean to support reporting,
+   (2) as and when all temporaries are known to be consumed.
+   For most targets, (2) is at the end of translate_insn.  */
+void translator_loop_temp_check(DisasContextBase *db)
+{
+    if (tcg_check_temp_count()) {
+        qemu_log("warning: TCG temporary leaks before "
+                 TARGET_FMT_lx "\n", db->pc_next);
+    }
+}

 bool translator_use_goto_tb(DisasContextBase *db, target_ulong dest)
 {
@@ -29,7 +42,7 @@ bool translator_use_goto_tb(DisasContextBase *db, target_ulong dest)
    return ((db->pc_first ^ dest) & TARGET_PAGE_MASK) == 0;
 }

-void translator_loop(CPUState *cpu, TranslationBlock *tb, int *max_insns,
+void translator_loop(CPUState *cpu, TranslationBlock *tb, int max_insns,
                     target_ulong pc, void *host_pc,
                     const TranslatorOps *ops, DisasContextBase *db)
 {
@@ -42,7 +55,7 @@ void translator_loop(CPUState *cpu, TranslationBlock *tb, int *max_insns,
    db->pc_next = pc;
    db->is_jmp = DISAS_NEXT;
    db->num_insns = 0;
-    db->max_insns = *max_insns;
+    db->max_insns = max_insns;
    db->singlestep_enabled = cflags & CF_SINGLE_STEP;
    db->host_addr[0] = host_pc;
    db->host_addr[1] = NULL;
@@ -54,6 +67,9 @@ void translator_loop(CPUState *cpu, TranslationBlock *tb, int *max_insns,
    ops->init_disas_context(db, cpu);
    tcg_debug_assert(db->is_jmp == DISAS_NEXT);  /* no early exit */

+    /* Reset the temp count so that we can identify leaks */
+    tcg_clear_temp_count();
+
    /* Start translating.  */
    gen_tb_start(db->tb);
    ops->tb_start(db, cpu);
@@ -62,7 +78,7 @@ void translator_loop(CPUState *cpu, TranslationBlock *tb, int *max_insns,
    plugin_enabled = plugin_gen_tb_start(cpu, db, cflags & CF_MEMI_ONLY);

    while (true) {
-        *max_insns = ++db->num_insns;
+        db->num_insns++;
        ops->insn_start(db, cpu);
        tcg_debug_assert(db->is_jmp == DISAS_NEXT);  /* no early exit */

@@ -160,16 +176,8 @@ static void *translator_access(CPUArchState *env, DisasContextBase *db,
        if (host == NULL) {
            tb_page_addr_t phys_page =
                get_page_addr_code_hostp(env, base, &db->host_addr[1]);
-
-            /*
-             * If the second page is MMIO, treat as if the first page
-             * was MMIO as well, so that we do not cache the TB.
-             */
-            if (unlikely(phys_page == -1)) {
-                tb_set_page_addr0(tb, -1);
-                return NULL;
-            }
-
+            /* We cannot handle MMIO as second page. */
+            assert(phys_page != -1);
            tb_set_page_addr1(tb, phys_page);
 #ifdef CONFIG_USER_ONLY
            page_protect(end);
--- a/accel/tcg/user-exec-stub.c
+++ b/accel/tcg/user-exec-stub.c
@@ -1,6 +1,6 @@
 #include "qemu/osdep.h"
 #include "hw/core/cpu.h"
-#include "exec/replay-core.h"
+#include "sysemu/replay.h"

 bool enable_cpu_pm = false;

--- a/accel/tcg/user-exec.c
+++ b/accel/tcg/user-exec.c
@@ -761,14 +761,13 @@ static int probe_access_internal(CPUArchState *env, target_ulong addr,
    cpu_loop_exit_sigsegv(env_cpu(env), addr, access_type, maperr, ra);
 }

-int probe_access_flags(CPUArchState *env, target_ulong addr, int size,
+int probe_access_flags(CPUArchState *env, target_ulong addr,
                       MMUAccessType access_type, int mmu_idx,
                       bool nonfault, void **phost, uintptr_t ra)
 {
    int flags;

-    g_assert(-(addr | TARGET_PAGE_MASK) >= size);
-    flags = probe_access_internal(env, addr, size, access_type, nonfault, ra);
+    flags = probe_access_internal(env, addr, 0, access_type, nonfault, ra);
    *phost = flags ? NULL : g2h(env_cpu(env), addr);
    return flags;
 }
--- a/accel/xen/xen-all.c
+++ b/accel/xen/xen-all.c
@@ -23,6 +23,16 @@
 #include "migration/global_state.h"
 #include "hw/boards.h"

+//#define DEBUG_XEN
+
+#ifdef DEBUG_XEN
+#define DPRINTF(fmt, ...) \
+    do { fprintf(stderr, "xen: " fmt, ## __VA_ARGS__); } while (0)
+#else
+#define DPRINTF(fmt, ...) \
+    do { } while (0)
+#endif
+
 bool xen_allowed;

 xc_interface *xen_xc;
@@ -171,8 +181,6 @@ static int xen_init(MachineState *ms)
     * opt out of system RAM being allocated by generic code
     */
    mc->default_ram_id = NULL;
-
-    xen_mode = XEN_ATTACH;
    return 0;
 }

--- a/authz/listfile.c
+++ b/authz/listfile.c
@@ -30,6 +30,7 @@
 #include "qapi/qapi-visit-authz.h"
 #include "qapi/qmp/qjson.h"
 #include "qapi/qmp/qobject.h"
+#include "qapi/qmp/qerror.h"
 #include "qapi/qobject-input-visitor.h"


--- a/backends/cryptodev-vhost.c
+++ b/backends/cryptodev-vhost.c
@@ -28,6 +28,7 @@

 #ifdef CONFIG_VHOST_CRYPTO
 #include "qapi/error.h"
+#include "qapi/qmp/qerror.h"
 #include "qemu/error-report.h"
 #include "hw/virtio/virtio-crypto.h"
 #include "sysemu/cryptodev-vhost-user.h"
--- a/backends/rng.c
+++ b/backends/rng.c
@@ -13,6 +13,7 @@
 #include "qemu/osdep.h"
 #include "sysemu/rng.h"
 #include "qapi/error.h"
+#include "qapi/qmp/qerror.h"
 #include "qemu/module.h"
 #include "qom/object_interfaces.h"

--- a/backends/vhost-user.c
+++ b/backends/vhost-user.c
@@ -13,6 +13,7 @@

 #include "qemu/osdep.h"
 #include "qapi/error.h"
+#include "qapi/qmp/qerror.h"
 #include "qemu/error-report.h"
 #include "qom/object_interfaces.h"
 #include "sysemu/vhost-user-backend.h"
@@ -20,6 +21,12 @@
 #include "io/channel-command.h"
 #include "hw/virtio/virtio-bus.h"

+static bool
+ioeventfd_enabled(void)
+{
+    return kvm_enabled() && kvm_eventfds_enabled();
+}
+
 int
 vhost_user_backend_dev_init(VhostUserBackend *b, VirtIODevice *vdev,
                            unsigned nvqs, Error **errp)
@@ -28,6 +35,11 @@ vhost_user_backend_dev_init(VhostUserBackend *b, VirtIODevice *vdev,

    assert(!b->vdev && vdev);

+    if (!ioeventfd_enabled()) {
+        error_setg(errp, "vhost initialization failed: requires kvm");
+        return -1;
+    }
+
    if (!vhost_user_init(&b->vhost_user, &b->chr, errp)) {
        return -1;
    }
--- a/block.c
+++ b/block.c
@@ -277,8 +277,8 @@ bool bdrv_is_read_only(BlockDriverState *bs)
    return !(bs->open_flags & BDRV_O_RDWR);
 }

-static int bdrv_can_set_read_only(BlockDriverState *bs, bool read_only,
-                                  bool ignore_allow_rdw, Error **errp)
+int bdrv_can_set_read_only(BlockDriverState *bs, bool read_only,
+                           bool ignore_allow_rdw, Error **errp)
 {
    IO_CODE();

@@ -533,7 +533,6 @@ int coroutine_fn bdrv_co_create(BlockDriver *drv, const char *filename,
    int ret;
    GLOBAL_STATE_CODE();
    ERRP_GUARD();
-    assert_bdrv_graph_readable();

    if (!drv->bdrv_co_create_opts) {
        error_setg(errp, "Driver '%s' does not support image creation",
@@ -658,8 +657,8 @@ int coroutine_fn bdrv_co_create_opts_simple(BlockDriver *drv,
    options = qdict_new();
    qdict_put_str(options, "driver", drv->format_name);

-    blk = blk_co_new_open(filename, NULL, options,
-                          BDRV_O_RDWR | BDRV_O_RESIZE, errp);
+    blk = blk_new_open(filename, NULL, options,
+                       BDRV_O_RDWR | BDRV_O_RESIZE, errp);
    if (!blk) {
        error_prepend(errp, "Protocol driver '%s' does not support image "
                      "creation, and opening the image failed: ",
@@ -740,7 +739,6 @@ int coroutine_fn bdrv_co_delete_file(BlockDriverState *bs, Error **errp)

    IO_CODE();
    assert(bs != NULL);
-    assert_bdrv_graph_readable();

    if (!bs->drv) {
        error_setg(errp, "Block node '%s' is not opened", bs->filename);
@@ -1042,7 +1040,6 @@ int coroutine_fn bdrv_co_refresh_total_sectors(BlockDriverState *bs,
 {
    BlockDriver *drv = bs->drv;
    IO_CODE();
-    assert_bdrv_graph_readable();

    if (!drv) {
        return -ENOMEDIUM;
@@ -3810,11 +3807,13 @@ out:
 * function eventually calls bdrv_refresh_total_sectors() which polls
 * when called from non-coroutine context.
 */
-static BlockDriverState * no_coroutine_fn
-bdrv_open_inherit(const char *filename, const char *reference, QDict *options,
-                  int flags, BlockDriverState *parent,
-                  const BdrvChildClass *child_class, BdrvChildRole child_role,
-                  Error **errp)
+static BlockDriverState *bdrv_open_inherit(const char *filename,
+                                           const char *reference,
+                                           QDict *options, int flags,
+                                           BlockDriverState *parent,
+                                           const BdrvChildClass *child_class,
+                                           BdrvChildRole child_role,
+                                           Error **errp)
 {
    int ret;
    BlockBackend *file = NULL;
@@ -3830,7 +3829,6 @@ bdrv_open_inherit(const char *filename, const char *reference, QDict *options,
    assert(!child_class || !flags);
    assert(!child_class == !parent);
    GLOBAL_STATE_CODE();
-    assert(!qemu_in_coroutine());

    if (reference) {
        bool options_non_empty = options ? qdict_size(options) : false;
@@ -5268,8 +5266,6 @@ int bdrv_drop_filter(BlockDriverState *bs, Error **errp)
 * child.
 *
 * This function does not create any image files.
- *
- * The caller must hold the AioContext lock for @bs_top.
 */
 int bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top,
                Error **errp)
@@ -5277,14 +5273,11 @@ int bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top,
    int ret;
    BdrvChild *child;
    Transaction *tran = tran_new();
-    AioContext *old_context, *new_context = NULL;

    GLOBAL_STATE_CODE();

    assert(!bs_new->backing);

-    old_context = bdrv_get_aio_context(bs_top);
-
    child = bdrv_attach_child_noperm(bs_new, bs_top, "backing",
                                     &child_of_bds, bdrv_backing_role(bs_new),
                                     tran, errp);
@@ -5293,19 +5286,6 @@ int bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top,
        goto out;
    }

-    /*
-     * bdrv_attach_child_noperm could change the AioContext of bs_top.
-     * bdrv_replace_node_noperm calls bdrv_drained_begin, so let's temporarily
-     * hold the new AioContext, since bdrv_drained_begin calls BDRV_POLL_WHILE
-     * that assumes the new lock is taken.
-     */
-    new_context = bdrv_get_aio_context(bs_top);
-
-    if (old_context != new_context) {
-        aio_context_release(old_context);
-        aio_context_acquire(new_context);
-    }
-
    ret = bdrv_replace_node_noperm(bs_top, bs_new, true, tran, errp);
    if (ret < 0) {
        goto out;
@@ -5317,11 +5297,6 @@ out:

    bdrv_refresh_limits(bs_top, NULL, NULL);

-    if (new_context && old_context != new_context) {
-        aio_context_release(new_context);
-        aio_context_acquire(old_context);
-    }
-
    return ret;
 }

@@ -5844,7 +5819,6 @@ int64_t coroutine_fn bdrv_co_nb_sectors(BlockDriverState *bs)
 {
    BlockDriver *drv = bs->drv;
    IO_CODE();
-    assert_bdrv_graph_readable();

    if (!drv)
        return -ENOMEDIUM;
@@ -5866,7 +5840,6 @@ int64_t coroutine_fn bdrv_co_getlength(BlockDriverState *bs)
 {
    int64_t ret;
    IO_CODE();
-    assert_bdrv_graph_readable();

    ret = bdrv_co_nb_sectors(bs);
    if (ret < 0) {
@@ -6830,7 +6803,6 @@ bool coroutine_fn bdrv_co_is_inserted(BlockDriverState *bs)
    BlockDriver *drv = bs->drv;
    BdrvChild *child;
    IO_CODE();
-    assert_bdrv_graph_readable();

    if (!drv) {
        return false;
@@ -6853,7 +6825,6 @@ void coroutine_fn bdrv_co_eject(BlockDriverState *bs, bool eject_flag)
 {
    BlockDriver *drv = bs->drv;
    IO_CODE();
-    assert_bdrv_graph_readable();

    if (drv && drv->bdrv_co_eject) {
        drv->bdrv_co_eject(bs, eject_flag);
@@ -6868,7 +6839,6 @@ void coroutine_fn bdrv_co_lock_medium(BlockDriverState *bs, bool locked)
 {
    BlockDriver *drv = bs->drv;
    IO_CODE();
-    assert_bdrv_graph_readable();
    trace_bdrv_lock_medium(bs, locked);

    if (drv && drv->bdrv_co_lock_medium) {
--- a/block/backup.c
+++ b/block/backup.c
@@ -22,6 +22,7 @@
 #include "block/block-copy.h"
 #include "block/dirty-bitmap.h"
 #include "qapi/error.h"
+#include "qapi/qmp/qerror.h"
 #include "qemu/cutils.h"
 #include "sysemu/block-backend.h"
 #include "qemu/bitmap.h"
@@ -269,10 +270,7 @@ static int coroutine_fn backup_run(Job *job, Error **errp)
                return -ECANCELED;
            }

-            /* rdlock protects the subsequent call to bdrv_is_allocated() */
-            bdrv_graph_co_rdlock();
            ret = block_copy_reset_unallocated(s->bcs, offset, &count);
-            bdrv_graph_co_rdunlock();
            if (ret < 0) {
                return ret;
            }
--- a/block/blkdebug.c
+++ b/block/blkdebug.c
@@ -626,7 +626,7 @@ static int rule_check(BlockDriverState *bs, uint64_t offset, uint64_t bytes,
    return -error;
 }

-static int coroutine_fn GRAPH_RDLOCK
+static int coroutine_fn
 blkdebug_co_preadv(BlockDriverState *bs, int64_t offset, int64_t bytes,
                   QEMUIOVector *qiov, BdrvRequestFlags flags)
 {
@@ -647,7 +647,7 @@ blkdebug_co_preadv(BlockDriverState *bs, int64_t offset, int64_t bytes,
    return bdrv_co_preadv(bs->file, offset, bytes, qiov, flags);
 }

-static int coroutine_fn GRAPH_RDLOCK
+static int coroutine_fn
 blkdebug_co_pwritev(BlockDriverState *bs, int64_t offset, int64_t bytes,
                    QEMUIOVector *qiov, BdrvRequestFlags flags)
 {
@@ -668,7 +668,7 @@ blkdebug_co_pwritev(BlockDriverState *bs, int64_t offset, int64_t bytes,
    return bdrv_co_pwritev(bs->file, offset, bytes, qiov, flags);
 }

-static int GRAPH_RDLOCK coroutine_fn blkdebug_co_flush(BlockDriverState *bs)
+static int coroutine_fn blkdebug_co_flush(BlockDriverState *bs)
 {
    int err = rule_check(bs, 0, 0, BLKDEBUG_IO_TYPE_FLUSH);

@@ -679,9 +679,9 @@ static int GRAPH_RDLOCK coroutine_fn blkdebug_co_flush(BlockDriverState *bs)
    return bdrv_co_flush(bs->file->bs);
 }

-static int coroutine_fn GRAPH_RDLOCK
-blkdebug_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset, int64_t bytes,
-                          BdrvRequestFlags flags)
+static int coroutine_fn blkdebug_co_pwrite_zeroes(BlockDriverState *bs,
+                                                  int64_t offset, int64_t bytes,
+                                                  BdrvRequestFlags flags)
 {
    uint32_t align = MAX(bs->bl.request_alignment,
                         bs->bl.pwrite_zeroes_alignment);
@@ -712,8 +712,8 @@ blkdebug_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset, int64_t bytes,
    return bdrv_co_pwrite_zeroes(bs->file, offset, bytes, flags);
 }

-static int coroutine_fn GRAPH_RDLOCK
-blkdebug_co_pdiscard(BlockDriverState *bs, int64_t offset, int64_t bytes)
+static int coroutine_fn blkdebug_co_pdiscard(BlockDriverState *bs,
+                                             int64_t offset, int64_t bytes)
 {
    uint32_t align = bs->bl.pdiscard_alignment;
    int err;
@@ -967,8 +967,7 @@ static bool blkdebug_debug_is_suspended(BlockDriverState *bs, const char *tag)
    return false;
 }

-static int64_t coroutine_fn GRAPH_RDLOCK
-blkdebug_co_getlength(BlockDriverState *bs)
+static int64_t coroutine_fn blkdebug_co_getlength(BlockDriverState *bs)
 {
    return bdrv_co_getlength(bs->file->bs);
 }
--- a/block/blklogwrites.c
+++ b/block/blklogwrites.c
@@ -267,8 +267,7 @@ static void blk_log_writes_close(BlockDriverState *bs)
    s->log_file = NULL;
 }

-static int64_t coroutine_fn GRAPH_RDLOCK
-blk_log_writes_co_getlength(BlockDriverState *bs)
+static int64_t coroutine_fn blk_log_writes_co_getlength(BlockDriverState *bs)
 {
    return bdrv_co_getlength(bs->file->bs);
 }
@@ -295,7 +294,7 @@ static void blk_log_writes_refresh_limits(BlockDriverState *bs, Error **errp)
    bs->bl.request_alignment = s->sectorsize;
 }

-static int coroutine_fn GRAPH_RDLOCK
+static int coroutine_fn
 blk_log_writes_co_preadv(BlockDriverState *bs, int64_t offset, int64_t bytes,
                         QEMUIOVector *qiov, BdrvRequestFlags flags)
 {
@@ -308,7 +307,7 @@ typedef struct BlkLogWritesFileReq {
    uint64_t bytes;
    int file_flags;
    QEMUIOVector *qiov;
-    int GRAPH_RDLOCK_PTR (*func)(struct BlkLogWritesFileReq *r);
+    int (*func)(struct BlkLogWritesFileReq *r);
    int file_ret;
 } BlkLogWritesFileReq;

@@ -320,8 +319,7 @@ typedef struct {
    int log_ret;
 } BlkLogWritesLogReq;

-static void coroutine_fn GRAPH_RDLOCK
-blk_log_writes_co_do_log(BlkLogWritesLogReq *lr)
+static void coroutine_fn blk_log_writes_co_do_log(BlkLogWritesLogReq *lr)
 {
    BDRVBlkLogWritesState *s = lr->bs->opaque;
    uint64_t cur_log_offset = s->cur_log_sector << s->sectorbits;
@@ -370,16 +368,15 @@ blk_log_writes_co_do_log(BlkLogWritesLogReq *lr)
    }
 }

-static void coroutine_fn GRAPH_RDLOCK
-blk_log_writes_co_do_file(BlkLogWritesFileReq *fr)
+static void coroutine_fn blk_log_writes_co_do_file(BlkLogWritesFileReq *fr)
 {
    fr->file_ret = fr->func(fr);
 }

-static int coroutine_fn GRAPH_RDLOCK
+static int coroutine_fn
 blk_log_writes_co_log(BlockDriverState *bs, uint64_t offset, uint64_t bytes,
                      QEMUIOVector *qiov, int flags,
-                      int /*GRAPH_RDLOCK*/ (*file_func)(BlkLogWritesFileReq *r),
+                      int (*file_func)(BlkLogWritesFileReq *r),
                      uint64_t entry_flags, bool is_zero_write)
 {
    QEMUIOVector log_qiov;
@@ -431,33 +428,32 @@ blk_log_writes_co_log(BlockDriverState *bs, uint64_t offset, uint64_t bytes,
    return fr.file_ret;
 }

-static int coroutine_fn GRAPH_RDLOCK
+static int coroutine_fn
 blk_log_writes_co_do_file_pwritev(BlkLogWritesFileReq *fr)
 {
    return bdrv_co_pwritev(fr->bs->file, fr->offset, fr->bytes,
                           fr->qiov, fr->file_flags);
 }

-static int coroutine_fn GRAPH_RDLOCK
+static int coroutine_fn
 blk_log_writes_co_do_file_pwrite_zeroes(BlkLogWritesFileReq *fr)
 {
    return bdrv_co_pwrite_zeroes(fr->bs->file, fr->offset, fr->bytes,
                                 fr->file_flags);
 }

-static int coroutine_fn GRAPH_RDLOCK
-blk_log_writes_co_do_file_flush(BlkLogWritesFileReq *fr)
+static int coroutine_fn blk_log_writes_co_do_file_flush(BlkLogWritesFileReq *fr)
 {
    return bdrv_co_flush(fr->bs->file->bs);
 }

-static int coroutine_fn GRAPH_RDLOCK
+static int coroutine_fn
 blk_log_writes_co_do_file_pdiscard(BlkLogWritesFileReq *fr)
 {
    return bdrv_co_pdiscard(fr->bs->file, fr->offset, fr->bytes);
 }

-static int coroutine_fn GRAPH_RDLOCK
+static int coroutine_fn
 blk_log_writes_co_pwritev(BlockDriverState *bs, int64_t offset, int64_t bytes,
                          QEMUIOVector *qiov, BdrvRequestFlags flags)
 {
@@ -465,7 +461,7 @@ blk_log_writes_co_pwritev(BlockDriverState *bs, int64_t offset, int64_t bytes,
                                 blk_log_writes_co_do_file_pwritev, 0, false);
 }

-static int coroutine_fn GRAPH_RDLOCK
+static int coroutine_fn
 blk_log_writes_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset,
                                int64_t bytes, BdrvRequestFlags flags)
 {
@@ -474,15 +470,14 @@ blk_log_writes_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset,
                                 true);
 }

-static int coroutine_fn GRAPH_RDLOCK
-blk_log_writes_co_flush_to_disk(BlockDriverState *bs)
+static int coroutine_fn blk_log_writes_co_flush_to_disk(BlockDriverState *bs)
 {
    return blk_log_writes_co_log(bs, 0, 0, NULL, 0,
                                 blk_log_writes_co_do_file_flush,
                                 LOG_FLUSH_FLAG, false);
 }

-static int coroutine_fn GRAPH_RDLOCK
+static int coroutine_fn
 blk_log_writes_co_pdiscard(BlockDriverState *bs, int64_t offset, int64_t bytes)
 {
    return blk_log_writes_co_log(bs, offset, bytes, NULL, 0,
--- a/block/blkreplay.c
+++ b/block/blkreplay.c
@@ -40,8 +40,7 @@ fail:
    return ret;
 }

-static int64_t coroutine_fn GRAPH_RDLOCK
-blkreplay_co_getlength(BlockDriverState *bs)
+static int64_t coroutine_fn blkreplay_co_getlength(BlockDriverState *bs)
 {
    return bdrv_co_getlength(bs->file->bs);
 }
@@ -70,9 +69,8 @@ static void block_request_create(uint64_t reqid, BlockDriverState *bs,
    replay_block_event(req->bh, reqid);
 }

-static int coroutine_fn GRAPH_RDLOCK
-blkreplay_co_preadv(BlockDriverState *bs, int64_t offset, int64_t bytes,
-                    QEMUIOVector *qiov, BdrvRequestFlags flags)
+static int coroutine_fn blkreplay_co_preadv(BlockDriverState *bs,
+    int64_t offset, int64_t bytes, QEMUIOVector *qiov, BdrvRequestFlags flags)
 {
    uint64_t reqid = blkreplay_next_id();
    int ret = bdrv_co_preadv(bs->file, offset, bytes, qiov, flags);
@@ -82,9 +80,8 @@ blkreplay_co_preadv(BlockDriverState *bs, int64_t offset, int64_t bytes,
    return ret;
 }

-static int coroutine_fn GRAPH_RDLOCK
-blkreplay_co_pwritev(BlockDriverState *bs, int64_t offset, int64_t bytes,
-                     QEMUIOVector *qiov, BdrvRequestFlags flags)
+static int coroutine_fn blkreplay_co_pwritev(BlockDriverState *bs,
+    int64_t offset, int64_t bytes, QEMUIOVector *qiov, BdrvRequestFlags flags)
 {
    uint64_t reqid = blkreplay_next_id();
    int ret = bdrv_co_pwritev(bs->file, offset, bytes, qiov, flags);
@@ -94,9 +91,8 @@ blkreplay_co_pwritev(BlockDriverState *bs, int64_t offset, int64_t bytes,
    return ret;
 }

-static int coroutine_fn GRAPH_RDLOCK
-blkreplay_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset, int64_t bytes,
-                           BdrvRequestFlags flags)
+static int coroutine_fn blkreplay_co_pwrite_zeroes(BlockDriverState *bs,
+    int64_t offset, int64_t bytes, BdrvRequestFlags flags)
 {
    uint64_t reqid = blkreplay_next_id();
    int ret = bdrv_co_pwrite_zeroes(bs->file, offset, bytes, flags);
@@ -106,8 +102,8 @@ blkreplay_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset, int64_t bytes,
    return ret;
 }

-static int coroutine_fn GRAPH_RDLOCK
-blkreplay_co_pdiscard(BlockDriverState *bs, int64_t offset, int64_t bytes)
+static int coroutine_fn blkreplay_co_pdiscard(BlockDriverState *bs,
+                                              int64_t offset, int64_t bytes)
 {
    uint64_t reqid = blkreplay_next_id();
    int ret = bdrv_co_pdiscard(bs->file, offset, bytes);
@@ -117,7 +113,7 @@ blkreplay_co_pdiscard(BlockDriverState *bs, int64_t offset, int64_t bytes)
    return ret;
 }

-static int coroutine_fn GRAPH_RDLOCK blkreplay_co_flush(BlockDriverState *bs)
+static int coroutine_fn blkreplay_co_flush(BlockDriverState *bs)
 {
    uint64_t reqid = blkreplay_next_id();
    int ret = bdrv_co_flush(bs->file->bs);
--- a/block/blkverify.c
+++ b/block/blkverify.c
@@ -155,8 +155,7 @@ static void blkverify_close(BlockDriverState *bs)
    s->test_file = NULL;
 }

-static int64_t coroutine_fn GRAPH_RDLOCK
-blkverify_co_getlength(BlockDriverState *bs)
+static int64_t coroutine_fn blkverify_co_getlength(BlockDriverState *bs)
 {
    BDRVBlkverifyState *s = bs->opaque;

@@ -257,7 +256,7 @@ blkverify_co_pwritev(BlockDriverState *bs, int64_t offset, int64_t bytes,
    return blkverify_co_prwv(bs, &r, offset, bytes, qiov, qiov, flags, true);
 }

-static int coroutine_fn GRAPH_RDLOCK blkverify_co_flush(BlockDriverState *bs)
+static int coroutine_fn blkverify_co_flush(BlockDriverState *bs)
 {
    BDRVBlkverifyState *s = bs->opaque;

--- a/block/block-backend.c
+++ b/block/block-backend.c
@@ -1235,8 +1235,8 @@ void blk_set_disable_request_queuing(BlockBackend *blk, bool disable)
    blk->disable_request_queuing = disable;
 }

-static int coroutine_fn GRAPH_RDLOCK
-blk_check_byte_request(BlockBackend *blk, int64_t offset, int64_t bytes)
+static coroutine_fn int blk_check_byte_request(BlockBackend *blk,
+                                               int64_t offset, int64_t bytes)
 {
    int64_t len;

@@ -1244,7 +1244,7 @@ blk_check_byte_request(BlockBackend *blk, int64_t offset, int64_t bytes)
        return -EIO;
    }

-    if (!blk_co_is_available(blk)) {
+    if (!blk_is_available(blk)) {
        return -ENOMEDIUM;
    }

@@ -1289,7 +1289,6 @@ blk_co_do_preadv_part(BlockBackend *blk, int64_t offset, int64_t bytes,
    IO_CODE();

    blk_wait_while_drained(blk);
-    GRAPH_RDLOCK_GUARD();

    /* Call blk_bs() only after waiting, the graph may have changed */
    bs = blk_bs(blk);
@@ -1364,7 +1363,6 @@ blk_co_do_pwritev_part(BlockBackend *blk, int64_t offset, int64_t bytes,
    IO_CODE();

    blk_wait_while_drained(blk);
-    GRAPH_RDLOCK_GUARD();

    /* Call blk_bs() only after waiting, the graph may have changed */
    bs = blk_bs(blk);
@@ -1433,7 +1431,6 @@ int coroutine_fn blk_co_block_status_above(BlockBackend *blk,
                                           BlockDriverState **file)
 {
    IO_CODE();
-    GRAPH_RDLOCK_GUARD();
    return bdrv_co_block_status_above(blk_bs(blk), base, offset, bytes, pnum,
                                      map, file);
 }
@@ -1444,7 +1441,6 @@ int coroutine_fn blk_co_is_allocated_above(BlockBackend *blk,
                                           int64_t bytes, int64_t *pnum)
 {
    IO_CODE();
-    GRAPH_RDLOCK_GUARD();
    return bdrv_co_is_allocated_above(blk_bs(blk), base, include_base, offset,
                                      bytes, pnum);
 }
@@ -1606,9 +1602,8 @@ BlockAIOCB *blk_aio_pwrite_zeroes(BlockBackend *blk, int64_t offset,
 int64_t coroutine_fn blk_co_getlength(BlockBackend *blk)
 {
    IO_CODE();
-    GRAPH_RDLOCK_GUARD();

-    if (!blk_co_is_available(blk)) {
+    if (!blk_is_available(blk)) {
        return -ENOMEDIUM;
    }

@@ -1628,9 +1623,8 @@ void blk_get_geometry(BlockBackend *blk, uint64_t *nb_sectors_ptr)
 int64_t coroutine_fn blk_co_nb_sectors(BlockBackend *blk)
 {
    IO_CODE();
-    GRAPH_RDLOCK_GUARD();

-    if (!blk_co_is_available(blk)) {
+    if (!blk_is_available(blk)) {
        return -ENOMEDIUM;
    }

@@ -1676,9 +1670,8 @@ blk_co_do_ioctl(BlockBackend *blk, unsigned long int req, void *buf)
    IO_CODE();

    blk_wait_while_drained(blk);
-    GRAPH_RDLOCK_GUARD();

-    if (!blk_co_is_available(blk)) {
+    if (!blk_is_available(blk)) {
        return -ENOMEDIUM;
    }

@@ -1723,7 +1716,6 @@ blk_co_do_pdiscard(BlockBackend *blk, int64_t offset, int64_t bytes)
    IO_CODE();

    blk_wait_while_drained(blk);
-    GRAPH_RDLOCK_GUARD();

    ret = blk_check_byte_request(blk, offset, bytes);
    if (ret < 0) {
@@ -1767,11 +1759,10 @@ int coroutine_fn blk_co_pdiscard(BlockBackend *blk, int64_t offset,
 /* To be called between exactly one pair of blk_inc/dec_in_flight() */
 static int coroutine_fn blk_co_do_flush(BlockBackend *blk)
 {
-    IO_CODE();
    blk_wait_while_drained(blk);
-    GRAPH_RDLOCK_GUARD();
+    IO_CODE();

-    if (!blk_co_is_available(blk)) {
+    if (!blk_is_available(blk)) {
        return -ENOMEDIUM;
    }

@@ -1998,22 +1989,20 @@ bool coroutine_fn blk_co_is_inserted(BlockBackend *blk)
 {
    BlockDriverState *bs = blk_bs(blk);
    IO_CODE();
-    assert_bdrv_graph_readable();

    return bs && bdrv_co_is_inserted(bs);
 }

-bool coroutine_fn blk_co_is_available(BlockBackend *blk)
+bool blk_is_available(BlockBackend *blk)
 {
    IO_CODE();
-    return blk_co_is_inserted(blk) && !blk_dev_is_tray_open(blk);
+    return blk_is_inserted(blk) && !blk_dev_is_tray_open(blk);
 }

 void coroutine_fn blk_co_lock_medium(BlockBackend *blk, bool locked)
 {
    BlockDriverState *bs = blk_bs(blk);
    IO_CODE();
-    GRAPH_RDLOCK_GUARD();

    if (bs) {
        bdrv_co_lock_medium(bs, locked);
@@ -2025,7 +2014,6 @@ void coroutine_fn blk_co_eject(BlockBackend *blk, bool eject_flag)
    BlockDriverState *bs = blk_bs(blk);
    char *id;
    IO_CODE();
-    GRAPH_RDLOCK_GUARD();

    if (bs) {
        bdrv_co_eject(bs, eject_flag);
@@ -2333,7 +2321,6 @@ void coroutine_fn blk_co_io_plug(BlockBackend *blk)
 {
    BlockDriverState *bs = blk_bs(blk);
    IO_CODE();
-    GRAPH_RDLOCK_GUARD();

    if (bs) {
        bdrv_co_io_plug(bs);
@@ -2344,7 +2331,6 @@ void coroutine_fn blk_co_io_unplug(BlockBackend *blk)
 {
    BlockDriverState *bs = blk_bs(blk);
    IO_CODE();
-    GRAPH_RDLOCK_GUARD();

    if (bs) {
        bdrv_co_io_unplug(bs);
@@ -2386,8 +2372,7 @@ int coroutine_fn blk_co_truncate(BlockBackend *blk, int64_t offset, bool exact,
                                 Error **errp)
 {
    IO_OR_GS_CODE();
-    GRAPH_RDLOCK_GUARD();
-    if (!blk_co_is_available(blk)) {
+    if (!blk_is_available(blk)) {
        error_setg(errp, "No medium inserted");
        return -ENOMEDIUM;
    }
@@ -2642,7 +2627,6 @@ int coroutine_fn blk_co_copy_range(BlockBackend *blk_in, int64_t off_in,
 {
    int r;
    IO_CODE();
-    GRAPH_RDLOCK_GUARD();

    r = blk_check_byte_request(blk_in, off_in, bytes);
    if (r) {
@@ -2652,7 +2636,6 @@ int coroutine_fn blk_co_copy_range(BlockBackend *blk_in, int64_t off_in,
    if (r) {
        return r;
    }
-
    return bdrv_co_copy_range(blk_in->root, off_in,
                              blk_out->root, off_out,
                              bytes, read_flags, write_flags);
--- a/block/block-copy.c
+++ b/block/block-copy.c
@@ -469,9 +469,10 @@ static coroutine_fn int block_copy_task_run(AioTaskPool *pool,
 * value of @method should be used for subsequent tasks.
 * Returns 0 on success.
 */
-static int coroutine_fn GRAPH_RDLOCK
-block_copy_do_copy(BlockCopyState *s, int64_t offset, int64_t bytes,
-                   BlockCopyMethod *method, bool *error_is_read)
+static int coroutine_fn block_copy_do_copy(BlockCopyState *s,
+                                           int64_t offset, int64_t bytes,
+                                           BlockCopyMethod *method,
+                                           bool *error_is_read)
 {
    int ret;
    int64_t nbytes = MIN(offset + bytes, s->len) - offset;
@@ -557,10 +558,8 @@ static coroutine_fn int block_copy_task_entry(AioTask *task)
    BlockCopyMethod method = t->method;
    int ret;

-    WITH_GRAPH_RDLOCK_GUARD() {
-        ret = block_copy_do_copy(s, t->req.offset, t->req.bytes, &method,
-                                 &error_is_read);
-    }
+    ret = block_copy_do_copy(s, t->req.offset, t->req.bytes, &method,
+                             &error_is_read);

    WITH_QEMU_LOCK_GUARD(&s->lock) {
        if (s->method == t->method) {
@@ -582,9 +581,9 @@ static coroutine_fn int block_copy_task_entry(AioTask *task)
    return ret;
 }

-static coroutine_fn GRAPH_RDLOCK
-int block_copy_block_status(BlockCopyState *s, int64_t offset, int64_t bytes,
-                            int64_t *pnum)
+static coroutine_fn int block_copy_block_status(BlockCopyState *s,
+                                                int64_t offset,
+                                                int64_t bytes, int64_t *pnum)
 {
    int64_t num;
    BlockDriverState *base;
@@ -619,9 +618,9 @@ int block_copy_block_status(BlockCopyState *s, int64_t offset, int64_t bytes,
 * Check if the cluster starting at offset is allocated or not.
 * return via pnum the number of contiguous clusters sharing this allocation.
 */
-static int coroutine_fn GRAPH_RDLOCK
-block_copy_is_cluster_allocated(BlockCopyState *s, int64_t offset,
-                                int64_t *pnum)
+static int coroutine_fn block_copy_is_cluster_allocated(BlockCopyState *s,
+                                                        int64_t offset,
+                                                        int64_t *pnum)
 {
    BlockDriverState *bs = s->source->bs;
    int64_t count, total_count = 0;
@@ -631,7 +630,6 @@ block_copy_is_cluster_allocated(BlockCopyState *s, int64_t offset,
    assert(QEMU_IS_ALIGNED(offset, s->cluster_size));

    while (true) {
-        /* protected in backup_run() */
        ret = bdrv_co_is_allocated(bs, offset, bytes, &count);
        if (ret < 0) {
            return ret;
@@ -706,7 +704,7 @@ int64_t coroutine_fn block_copy_reset_unallocated(BlockCopyState *s,
 * Returns 1 if dirty clusters found and successfully copied, 0 if no dirty
 * clusters found and -errno on failure.
 */
-static int coroutine_fn GRAPH_RDLOCK
+static int coroutine_fn
 block_copy_dirty_clusters(BlockCopyCallState *call_state)
 {
    BlockCopyState *s = call_state->s;
@@ -829,8 +827,7 @@ void block_copy_kick(BlockCopyCallState *call_state)
 * it means that some I/O operation failed in context of _this_ block_copy call,
 * not some parallel operation.
 */
-static int coroutine_fn GRAPH_RDLOCK
-block_copy_common(BlockCopyCallState *call_state)
+static int coroutine_fn block_copy_common(BlockCopyCallState *call_state)
 {
    int ret;
    BlockCopyState *s = call_state->s;
@@ -895,7 +892,6 @@ block_copy_common(BlockCopyCallState *call_state)

 static void coroutine_fn block_copy_async_co_entry(void *opaque)
 {
-    GRAPH_RDLOCK_GUARD();
    block_copy_common(opaque);
 }

--- a/block/bochs.c
+++ b/block/bochs.c
@@ -237,7 +237,7 @@ static int64_t seek_to_sector(BlockDriverState *bs, int64_t sector_num)
    return bitmap_offset + (512 * (s->bitmap_blocks + extent_offset));
 }

-static int coroutine_fn GRAPH_RDLOCK
+static int coroutine_fn
 bochs_co_preadv(BlockDriverState *bs, int64_t offset, int64_t bytes,
                QEMUIOVector *qiov, BdrvRequestFlags flags)
 {
--- a/block/commit.c
+++ b/block/commit.c
@@ -18,6 +18,7 @@
 #include "block/block_int.h"
 #include "block/blockjob_int.h"
 #include "qapi/error.h"
+#include "qapi/qmp/qerror.h"
 #include "qemu/ratelimit.h"
 #include "qemu/memalign.h"
 #include "sysemu/block-backend.h"
@@ -206,9 +207,8 @@ static const BlockJobDriver commit_job_driver = {
    },
 };

-static int coroutine_fn GRAPH_RDLOCK
-bdrv_commit_top_preadv(BlockDriverState *bs, int64_t offset, int64_t bytes,
-                       QEMUIOVector *qiov, BdrvRequestFlags flags)
+static int coroutine_fn bdrv_commit_top_preadv(BlockDriverState *bs,
+    int64_t offset, int64_t bytes, QEMUIOVector *qiov, BdrvRequestFlags flags)
 {
    return bdrv_co_preadv(bs->backing, offset, bytes, qiov, flags);
 }
--- a/block/copy-before-write.c
+++ b/block/copy-before-write.c
@@ -78,9 +78,9 @@ typedef struct BDRVCopyBeforeWriteState {
    int snapshot_error;
 } BDRVCopyBeforeWriteState;

-static int coroutine_fn GRAPH_RDLOCK
-cbw_co_preadv(BlockDriverState *bs, int64_t offset, int64_t bytes,
-              QEMUIOVector *qiov, BdrvRequestFlags flags)
+static coroutine_fn int cbw_co_preadv(
+        BlockDriverState *bs, int64_t offset, int64_t bytes,
+        QEMUIOVector *qiov, BdrvRequestFlags flags)
 {
    return bdrv_co_preadv(bs->file, offset, bytes, qiov, flags);
 }
@@ -149,8 +149,8 @@ static coroutine_fn int cbw_do_copy_before_write(BlockDriverState *bs,
    return 0;
 }

-static int coroutine_fn GRAPH_RDLOCK
-cbw_co_pdiscard(BlockDriverState *bs, int64_t offset, int64_t bytes)
+static int coroutine_fn cbw_co_pdiscard(BlockDriverState *bs,
+                                        int64_t offset, int64_t bytes)
 {
    int ret = cbw_do_copy_before_write(bs, offset, bytes, 0);
    if (ret < 0) {
@@ -160,9 +160,8 @@ cbw_co_pdiscard(BlockDriverState *bs, int64_t offset, int64_t bytes)
    return bdrv_co_pdiscard(bs->file, offset, bytes);
 }

-static int coroutine_fn GRAPH_RDLOCK
-cbw_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset, int64_t bytes,
-                     BdrvRequestFlags flags)
+static int coroutine_fn cbw_co_pwrite_zeroes(BlockDriverState *bs,
+        int64_t offset, int64_t bytes, BdrvRequestFlags flags)
 {
    int ret = cbw_do_copy_before_write(bs, offset, bytes, flags);
    if (ret < 0) {
@@ -172,9 +171,11 @@ cbw_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset, int64_t bytes,
    return bdrv_co_pwrite_zeroes(bs->file, offset, bytes, flags);
 }

-static coroutine_fn GRAPH_RDLOCK
-int cbw_co_pwritev(BlockDriverState *bs, int64_t offset, int64_t bytes,
-                   QEMUIOVector *qiov, BdrvRequestFlags flags)
+static coroutine_fn int cbw_co_pwritev(BlockDriverState *bs,
+                                       int64_t offset,
+                                       int64_t bytes,
+                                       QEMUIOVector *qiov,
+                                       BdrvRequestFlags flags)
 {
    int ret = cbw_do_copy_before_write(bs, offset, bytes, flags);
    if (ret < 0) {
@@ -184,7 +185,7 @@ int cbw_co_pwritev(BlockDriverState *bs, int64_t offset, int64_t bytes,
    return bdrv_co_pwritev(bs->file, offset, bytes, qiov, flags);
 }

-static int coroutine_fn GRAPH_RDLOCK cbw_co_flush(BlockDriverState *bs)
+static int coroutine_fn cbw_co_flush(BlockDriverState *bs)
 {
    if (!bs->file) {
        return 0;
@@ -256,7 +257,7 @@ cbw_snapshot_read_unlock(BlockDriverState *bs, BlockReq *req)
    g_free(req);
 }

-static int coroutine_fn GRAPH_RDLOCK
+static coroutine_fn int
 cbw_co_preadv_snapshot(BlockDriverState *bs, int64_t offset, int64_t bytes,
                       QEMUIOVector *qiov, size_t qiov_offset)
 {
@@ -288,7 +289,7 @@ cbw_co_preadv_snapshot(BlockDriverState *bs, int64_t offset, int64_t bytes,
    return 0;
 }

-static int coroutine_fn GRAPH_RDLOCK
+static int coroutine_fn
 cbw_co_snapshot_block_status(BlockDriverState *bs,
                             bool want_zero, int64_t offset, int64_t bytes,
                             int64_t *pnum, int64_t *map,
@@ -321,8 +322,8 @@ cbw_co_snapshot_block_status(BlockDriverState *bs,
    return ret;
 }

-static int coroutine_fn GRAPH_RDLOCK
-cbw_co_pdiscard_snapshot(BlockDriverState *bs, int64_t offset, int64_t bytes)
+static int coroutine_fn cbw_co_pdiscard_snapshot(BlockDriverState *bs,
+                                                 int64_t offset, int64_t bytes)
 {
    BDRVCopyBeforeWriteState *s = bs->opaque;

--- a/block/copy-on-read.c
+++ b/block/copy-on-read.c
@@ -121,16 +121,17 @@ static void cor_child_perm(BlockDriverState *bs, BdrvChild *c,
 }


-static int64_t coroutine_fn GRAPH_RDLOCK cor_co_getlength(BlockDriverState *bs)
+static int64_t coroutine_fn cor_co_getlength(BlockDriverState *bs)
 {
    return bdrv_co_getlength(bs->file->bs);
 }


-static int coroutine_fn GRAPH_RDLOCK
-cor_co_preadv_part(BlockDriverState *bs, int64_t offset, int64_t bytes,
-                   QEMUIOVector *qiov, size_t qiov_offset,
-                   BdrvRequestFlags flags)
+static int coroutine_fn cor_co_preadv_part(BlockDriverState *bs,
+                                           int64_t offset, int64_t bytes,
+                                           QEMUIOVector *qiov,
+                                           size_t qiov_offset,
+                                           BdrvRequestFlags flags)
 {
    int64_t n;
    int local_flags;
@@ -179,49 +180,50 @@ cor_co_preadv_part(BlockDriverState *bs, int64_t offset, int64_t bytes,
 }


-static int coroutine_fn GRAPH_RDLOCK
-cor_co_pwritev_part(BlockDriverState *bs, int64_t offset, int64_t bytes,
-                    QEMUIOVector *qiov, size_t qiov_offset,
-                    BdrvRequestFlags flags)
+static int coroutine_fn cor_co_pwritev_part(BlockDriverState *bs,
+                                            int64_t offset,
+                                            int64_t bytes,
+                                            QEMUIOVector *qiov,
+                                            size_t qiov_offset,
+                                            BdrvRequestFlags flags)
 {
    return bdrv_co_pwritev_part(bs->file, offset, bytes, qiov, qiov_offset,
                                flags);
 }


-static int coroutine_fn GRAPH_RDLOCK
-cor_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset, int64_t bytes,
-                     BdrvRequestFlags flags)
+static int coroutine_fn cor_co_pwrite_zeroes(BlockDriverState *bs,
+                                             int64_t offset, int64_t bytes,
+                                             BdrvRequestFlags flags)
 {
    return bdrv_co_pwrite_zeroes(bs->file, offset, bytes, flags);
 }


-static int coroutine_fn GRAPH_RDLOCK
-cor_co_pdiscard(BlockDriverState *bs, int64_t offset, int64_t bytes)
+static int coroutine_fn cor_co_pdiscard(BlockDriverState *bs,
+                                        int64_t offset, int64_t bytes)
 {
    return bdrv_co_pdiscard(bs->file, offset, bytes);
 }


-static int coroutine_fn GRAPH_RDLOCK
-cor_co_pwritev_compressed(BlockDriverState *bs, int64_t offset, int64_t bytes,
-                          QEMUIOVector *qiov)
+static int coroutine_fn cor_co_pwritev_compressed(BlockDriverState *bs,
+                                                  int64_t offset,
+                                                  int64_t bytes,
+                                                  QEMUIOVector *qiov)
 {
    return bdrv_co_pwritev(bs->file, offset, bytes, qiov,
                           BDRV_REQ_WRITE_COMPRESSED);
 }


-static void coroutine_fn GRAPH_RDLOCK
-cor_co_eject(BlockDriverState *bs, bool eject_flag)
+static void coroutine_fn cor_co_eject(BlockDriverState *bs, bool eject_flag)
 {
    bdrv_co_eject(bs->file->bs, eject_flag);
 }


-static void coroutine_fn GRAPH_RDLOCK
-cor_co_lock_medium(BlockDriverState *bs, bool locked)
+static void coroutine_fn cor_co_lock_medium(BlockDriverState *bs, bool locked)
 {
    bdrv_co_lock_medium(bs->file->bs, locked);
 }
--- a/block/coroutines.h
+++ b/block/coroutines.h
@@ -43,7 +43,7 @@ bdrv_co_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix);
 int coroutine_fn GRAPH_RDLOCK
 bdrv_co_invalidate_cache(BlockDriverState *bs, Error **errp);

-int coroutine_fn GRAPH_RDLOCK
+int coroutine_fn
 bdrv_co_common_block_status_above(BlockDriverState *bs,
                                  BlockDriverState *base,
                                  bool include_base,
--- a/block/create.c
+++ b/block/create.c
@@ -43,7 +43,6 @@ static int coroutine_fn blockdev_create_run(Job *job, Error **errp)
    int ret;

    GLOBAL_STATE_CODE();
-    GRAPH_RDLOCK_GUARD();

    job_progress_set_remaining(&s->common, 1);
    ret = s->drv->bdrv_co_create(s->opts, errp);
@@ -60,12 +59,6 @@ static const JobDriver blockdev_create_job_driver = {
    .run           = blockdev_create_run,
 };

-/* Checking whether the function is present doesn't require the graph lock */
-static inline bool TSA_NO_TSA has_bdrv_co_create(BlockDriver *drv)
-{
-    return drv->bdrv_co_create;
-}
-
 void qmp_blockdev_create(const char *job_id, BlockdevCreateOptions *options,
                         Error **errp)
 {
@@ -86,7 +79,7 @@ void qmp_blockdev_create(const char *job_id, BlockdevCreateOptions *options,
    }

    /* Error out if the driver doesn't support .bdrv_co_create */
-    if (!has_bdrv_co_create(drv)) {
+    if (!drv->bdrv_co_create) {
        error_setg(errp, "Driver does not support blockdev-create");
        return;
    }
--- a/block/crypto.c
+++ b/block/crypto.c
@@ -314,18 +314,19 @@ static int block_crypto_open_generic(QCryptoBlockFormat format,
 }


-static int coroutine_fn
-block_crypto_co_create_generic(BlockDriverState *bs, int64_t size,
-                               QCryptoBlockCreateOptions *opts,
-                               PreallocMode prealloc, Error **errp)
+static int block_crypto_co_create_generic(BlockDriverState *bs,
+                                          int64_t size,
+                                          QCryptoBlockCreateOptions *opts,
+                                          PreallocMode prealloc,
+                                          Error **errp)
 {
    int ret;
    BlockBackend *blk;
    QCryptoBlock *crypto = NULL;
    struct BlockCryptoCreateData data;

-    blk = blk_co_new_with_bs(bs, BLK_PERM_WRITE | BLK_PERM_RESIZE, BLK_PERM_ALL,
-                             errp);
+    blk = blk_new_with_bs(bs, BLK_PERM_WRITE | BLK_PERM_RESIZE, BLK_PERM_ALL,
+                          errp);
    if (!blk) {
        ret = -EPERM;
        goto cleanup;
@@ -359,7 +360,7 @@ block_crypto_co_create_generic(BlockDriverState *bs, int64_t size,
    return ret;
 }

-static int coroutine_fn GRAPH_RDLOCK
+static int coroutine_fn
 block_crypto_co_truncate(BlockDriverState *bs, int64_t offset, bool exact,
                         PreallocMode prealloc, BdrvRequestFlags flags,
                         Error **errp)
@@ -397,7 +398,7 @@ static int block_crypto_reopen_prepare(BDRVReopenState *state,
 */
 #define BLOCK_CRYPTO_MAX_IO_SIZE (1024 * 1024)

-static int coroutine_fn GRAPH_RDLOCK
+static coroutine_fn int
 block_crypto_co_preadv(BlockDriverState *bs, int64_t offset, int64_t bytes,
                       QEMUIOVector *qiov, BdrvRequestFlags flags)
 {
@@ -459,7 +460,7 @@ block_crypto_co_preadv(BlockDriverState *bs, int64_t offset, int64_t bytes,
 }


-static int coroutine_fn GRAPH_RDLOCK
+static coroutine_fn int
 block_crypto_co_pwritev(BlockDriverState *bs, int64_t offset, int64_t bytes,
                        QEMUIOVector *qiov, BdrvRequestFlags flags)
 {
@@ -530,8 +531,7 @@ static void block_crypto_refresh_limits(BlockDriverState *bs, Error **errp)
 }


-static int64_t coroutine_fn GRAPH_RDLOCK
-block_crypto_co_getlength(BlockDriverState *bs)
+static int64_t coroutine_fn block_crypto_co_getlength(BlockDriverState *bs)
 {
    BlockCrypto *crypto = bs->opaque;
    int64_t len = bdrv_co_getlength(bs->file->bs);
@@ -639,7 +639,7 @@ block_crypto_co_create_luks(BlockdevCreateOptions *create_options, Error **errp)
    assert(create_options->driver == BLOCKDEV_DRIVER_LUKS);
    luks_opts = &create_options->u.luks;

-    bs = bdrv_co_open_blockdev_ref(luks_opts->file, errp);
+    bs = bdrv_open_blockdev_ref(luks_opts->file, errp);
    if (bs == NULL) {
        return -EIO;
    }
@@ -665,9 +665,10 @@ fail:
    return ret;
 }

-static int coroutine_fn GRAPH_RDLOCK
-block_crypto_co_create_opts_luks(BlockDriver *drv, const char *filename,
-                                 QemuOpts *opts, Error **errp)
+static int coroutine_fn block_crypto_co_create_opts_luks(BlockDriver *drv,
+                                                         const char *filename,
+                                                         QemuOpts *opts,
+                                                         Error **errp)
 {
    QCryptoBlockCreateOptions *create_opts = NULL;
    BlockDriverState *bs = NULL;
@@ -707,8 +708,8 @@ block_crypto_co_create_opts_luks(BlockDriver *drv, const char *filename,
        goto fail;
    }

-    bs = bdrv_co_open(filename, NULL, NULL,
-                      BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL, errp);
+    bs = bdrv_open(filename, NULL, NULL,
+                   BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL, errp);
    if (!bs) {
        ret = -EINVAL;
        goto fail;
--- a/block/curl.c
+++ b/block/curl.c
@@ -38,15 +38,8 @@

 // #define DEBUG_VERBOSE

-/* CURL 7.85.0 switches to a string based API for specifying
- * the desired protocols.
- */
-#if LIBCURL_VERSION_NUM >= 0x075500
-#define PROTOCOLS "HTTP,HTTPS,FTP,FTPS"
-#else
 #define PROTOCOLS (CURLPROTO_HTTP | CURLPROTO_HTTPS | \
                   CURLPROTO_FTP | CURLPROTO_FTPS)
-#endif

 #define CURL_NUM_STATES 8
 #define CURL_NUM_ACB    8
@@ -517,18 +510,9 @@ static int curl_init_state(BDRVCURLState *s, CURLState *state)
         * obscure protocols.  For example, do not allow POP3/SMTP/IMAP see
         * CVE-2013-0249.
         *
-         * Restricting protocols is only supported from 7.19.4 upwards. Note:
-         * version 7.85.0 deprecates CURLOPT_*PROTOCOLS in favour of a string
-         * based CURLOPT_*PROTOCOLS_STR API.
+         * Restricting protocols is only supported from 7.19.4 upwards.
         */
-#if LIBCURL_VERSION_NUM >= 0x075500
-        if (curl_easy_setopt(state->curl,
-                             CURLOPT_PROTOCOLS_STR, PROTOCOLS) ||
-            curl_easy_setopt(state->curl,
-                             CURLOPT_REDIR_PROTOCOLS_STR, PROTOCOLS)) {
-            goto err;
-        }
-#elif LIBCURL_VERSION_NUM >= 0x071304
+#if LIBCURL_VERSION_NUM >= 0x071304
        if (curl_easy_setopt(state->curl, CURLOPT_PROTOCOLS, PROTOCOLS) ||
            curl_easy_setopt(state->curl, CURLOPT_REDIR_PROTOCOLS, PROTOCOLS)) {
            goto err;
@@ -686,12 +670,7 @@ static int curl_open(BlockDriverState *bs, QDict *options, int flags,
    const char *file;
    const char *cookie;
    const char *cookie_secret;
-    /* CURL >= 7.55.0 uses curl_off_t for content length instead of a double */
-#if LIBCURL_VERSION_NUM >= 0x073700
-    curl_off_t cl;
-#else
-    double cl;
-#endif
+    double d;
    const char *secretid;
    const char *protocol_delimiter;
    int ret;
@@ -818,36 +797,27 @@ static int curl_open(BlockDriverState *bs, QDict *options, int flags,
    }
    if (curl_easy_perform(state->curl))
        goto out;
-    /* CURL 7.55.0 deprecates CURLINFO_CONTENT_LENGTH_DOWNLOAD in favour of
-     * the *_T version which returns a more sensible type for content length.
-     */
-#if LIBCURL_VERSION_NUM >= 0x073700
-    if (curl_easy_getinfo(state->curl, CURLINFO_CONTENT_LENGTH_DOWNLOAD_T, &cl)) {
+    if (curl_easy_getinfo(state->curl, CURLINFO_CONTENT_LENGTH_DOWNLOAD, &d)) {
        goto out;
    }
-#else
-    if (curl_easy_getinfo(state->curl, CURLINFO_CONTENT_LENGTH_DOWNLOAD, &cl)) {
-        goto out;
-    }
-#endif
    /* Prior CURL 7.19.4 return value of 0 could mean that the file size is not
     * know or the size is zero. From 7.19.4 CURL returns -1 if size is not
     * known and zero if it is really zero-length file. */
 #if LIBCURL_VERSION_NUM >= 0x071304
-    if (cl < 0) {
+    if (d < 0) {
        pstrcpy(state->errmsg, CURL_ERROR_SIZE,
                "Server didn't report file size.");
        goto out;
    }
 #else
-    if (cl <= 0) {
+    if (d <= 0) {
        pstrcpy(state->errmsg, CURL_ERROR_SIZE,
                "Unknown file size or zero-length file.");
        goto out;
    }
 #endif

-    s->len = cl;
+    s->len = d;

    if ((!strncasecmp(s->url, "http://", strlen("http://"))
        || !strncasecmp(s->url, "https://", strlen("https://")))
@@ -880,10 +850,8 @@ out_noclean:
    g_free(s->username);
    g_free(s->proxyusername);
    g_free(s->proxypassword);
-    if (s->sockets) {
-        curl_drop_all_sockets(s->sockets);
-        g_hash_table_destroy(s->sockets);
-    }
+    curl_drop_all_sockets(s->sockets);
+    g_hash_table_destroy(s->sockets);
    qemu_opts_del(opts);
    return -EINVAL;
 }
--- a/block/dirty-bitmap.c
+++ b/block/dirty-bitmap.c
@@ -394,7 +394,6 @@ int coroutine_fn
 bdrv_co_remove_persistent_dirty_bitmap(BlockDriverState *bs, const char *name,
                                       Error **errp)
 {
-    assert_bdrv_graph_readable();
    if (bs->drv && bs->drv->bdrv_co_remove_persistent_dirty_bitmap) {
        return bs->drv->bdrv_co_remove_persistent_dirty_bitmap(bs, name, errp);
    }
@@ -416,7 +415,6 @@ bdrv_co_can_store_new_dirty_bitmap(BlockDriverState *bs, const char *name,
                                   uint32_t granularity, Error **errp)
 {
    BlockDriver *drv = bs->drv;
-    assert_bdrv_graph_readable();

    if (!drv) {
        error_setg_errno(errp, ENOMEDIUM,
--- a/block/file-posix.c
+++ b/block/file-posix.c
@@ -1738,7 +1738,7 @@ static int handle_aiocb_write_zeroes(void *opaque)
 #ifdef CONFIG_FALLOCATE
    /* Last resort: we are trying to extend the file with zeroed data. This
     * can be done via fallocate(fd, 0) */
-    len = raw_co_getlength(aiocb->bs);
+    len = bdrv_getlength(aiocb->bs);
    if (s->has_fallocate && len >= 0 && aiocb->aio_offset >= len) {
        int ret = do_fallocate(s->fd, 0, aiocb->aio_offset, aiocb->aio_nbytes);
        if (ret == 0 || ret != -ENOTSUP) {
@@ -2607,9 +2607,10 @@ out:
    return result;
 }

-static int coroutine_fn GRAPH_RDLOCK
-raw_co_create_opts(BlockDriver *drv, const char *filename,
-                   QemuOpts *opts, Error **errp)
+static int coroutine_fn raw_co_create_opts(BlockDriver *drv,
+                                           const char *filename,
+                                           QemuOpts *opts,
+                                           Error **errp)
 {
    BlockdevCreateOptions options;
    int64_t total_size = 0;
@@ -2919,8 +2920,8 @@ static void coroutine_fn check_cache_dropped(BlockDriverState *bs, Error **errp)
 }
 #endif /* __linux__ */

-static void coroutine_fn GRAPH_RDLOCK
-raw_co_invalidate_cache(BlockDriverState *bs, Error **errp)
+static void coroutine_fn raw_co_invalidate_cache(BlockDriverState *bs,
+                                                 Error **errp)
 {
    BDRVRawState *s = bs->opaque;
    int ret;
@@ -3271,7 +3272,7 @@ static void raw_abort_perm_update(BlockDriverState *bs)
    raw_handle_perm_lock(bs, RAW_PL_ABORT, 0, 0, NULL);
 }

-static int coroutine_fn GRAPH_RDLOCK raw_co_copy_range_from(
+static int coroutine_fn raw_co_copy_range_from(
        BlockDriverState *bs, BdrvChild *src, int64_t src_offset,
        BdrvChild *dst, int64_t dst_offset, int64_t bytes,
        BdrvRequestFlags read_flags, BdrvRequestFlags write_flags)
@@ -3280,12 +3281,14 @@ static int coroutine_fn GRAPH_RDLOCK raw_co_copy_range_from(
                                 read_flags, write_flags);
 }

-static int coroutine_fn GRAPH_RDLOCK
-raw_co_copy_range_to(BlockDriverState *bs,
-                     BdrvChild *src, int64_t src_offset,
-                     BdrvChild *dst, int64_t dst_offset,
-                     int64_t bytes, BdrvRequestFlags read_flags,
-                     BdrvRequestFlags write_flags)
+static int coroutine_fn raw_co_copy_range_to(BlockDriverState *bs,
+                                             BdrvChild *src,
+                                             int64_t src_offset,
+                                             BdrvChild *dst,
+                                             int64_t dst_offset,
+                                             int64_t bytes,
+                                             BdrvRequestFlags read_flags,
+                                             BdrvRequestFlags write_flags)
 {
    RawPosixAIOData acb;
    BDRVRawState *s = bs->opaque;
--- a/block/file-win32.c
+++ b/block/file-win32.c
@@ -613,9 +613,10 @@ static int raw_co_create(BlockdevCreateOptions *options, Error **errp)
    return 0;
 }

-static int coroutine_fn GRAPH_RDLOCK
-raw_co_create_opts(BlockDriver *drv, const char *filename,
-                   QemuOpts *opts, Error **errp)
+static int coroutine_fn raw_co_create_opts(BlockDriver *drv,
+                                           const char *filename,
+                                           QemuOpts *opts,
+                                           Error **errp)
 {
    BlockdevCreateOptions options;
    int64_t total_size = 0;
--- a/block/filter-compress.c
+++ b/block/filter-compress.c
@@ -55,43 +55,45 @@ static int compress_open(BlockDriverState *bs, QDict *options, int flags,
 }


-static int64_t coroutine_fn GRAPH_RDLOCK
-compress_co_getlength(BlockDriverState *bs)
+static int64_t coroutine_fn compress_co_getlength(BlockDriverState *bs)
 {
    return bdrv_co_getlength(bs->file->bs);
 }


-static int coroutine_fn GRAPH_RDLOCK
-compress_co_preadv_part(BlockDriverState *bs, int64_t offset, int64_t bytes,
-                        QEMUIOVector *qiov, size_t qiov_offset,
-                        BdrvRequestFlags flags)
+static int coroutine_fn compress_co_preadv_part(BlockDriverState *bs,
+                                                int64_t offset, int64_t bytes,
+                                                QEMUIOVector *qiov,
+                                                size_t qiov_offset,
+                                                BdrvRequestFlags flags)
 {
    return bdrv_co_preadv_part(bs->file, offset, bytes, qiov, qiov_offset,
                               flags);
 }


-static int coroutine_fn GRAPH_RDLOCK
-compress_co_pwritev_part(BlockDriverState *bs, int64_t offset, int64_t bytes,
-                         QEMUIOVector *qiov, size_t qiov_offset,
-                         BdrvRequestFlags flags)
+static int coroutine_fn compress_co_pwritev_part(BlockDriverState *bs,
+                                                 int64_t offset,
+                                                 int64_t bytes,
+                                                 QEMUIOVector *qiov,
+                                                 size_t qiov_offset,
+                                                 BdrvRequestFlags flags)
 {
    return bdrv_co_pwritev_part(bs->file, offset, bytes, qiov, qiov_offset,
                                flags | BDRV_REQ_WRITE_COMPRESSED);
 }


-static int coroutine_fn GRAPH_RDLOCK
-compress_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset, int64_t bytes,
-                          BdrvRequestFlags flags)
+static int coroutine_fn compress_co_pwrite_zeroes(BlockDriverState *bs,
+                                                  int64_t offset, int64_t bytes,
+                                                  BdrvRequestFlags flags)
 {
    return bdrv_co_pwrite_zeroes(bs->file, offset, bytes, flags);
 }


-static int coroutine_fn GRAPH_RDLOCK
-compress_co_pdiscard(BlockDriverState *bs, int64_t offset, int64_t bytes)
+static int coroutine_fn compress_co_pdiscard(BlockDriverState *bs,
+                                             int64_t offset, int64_t bytes)
 {
    return bdrv_co_pdiscard(bs->file, offset, bytes);
 }
@@ -115,14 +117,14 @@ static void compress_refresh_limits(BlockDriverState *bs, Error **errp)
 }


-static void coroutine_fn GRAPH_RDLOCK
+static void coroutine_fn
 compress_co_eject(BlockDriverState *bs, bool eject_flag)
 {
    bdrv_co_eject(bs->file->bs, eject_flag);
 }


-static void coroutine_fn GRAPH_RDLOCK
+static void coroutine_fn
 compress_co_lock_medium(BlockDriverState *bs, bool locked)
 {
    bdrv_co_lock_medium(bs->file->bs, locked);
--- a/block/io.c
+++ b/block/io.c
@@ -160,7 +160,6 @@ void bdrv_refresh_limits(BlockDriverState *bs, Transaction *tran, Error **errp)
    bool have_limits;

    GLOBAL_STATE_CODE();
-    assume_graph_lock(); /* FIXME */

    if (tran) {
        BdrvRefreshLimitsState *s = g_new(BdrvRefreshLimitsState, 1);
@@ -933,7 +932,6 @@ int coroutine_fn bdrv_co_pwrite_sync(BdrvChild *child, int64_t offset,
 {
    int ret;
    IO_CODE();
-    assert_bdrv_graph_readable();

    ret = bdrv_co_pwrite(child, offset, bytes, buf, flags);
    if (ret < 0) {
@@ -961,16 +959,16 @@ static void bdrv_co_io_em_complete(void *opaque, int ret)
    aio_co_wake(co->coroutine);
 }

-static int coroutine_fn GRAPH_RDLOCK
-bdrv_driver_preadv(BlockDriverState *bs, int64_t offset, int64_t bytes,
-                   QEMUIOVector *qiov, size_t qiov_offset, int flags)
+static int coroutine_fn bdrv_driver_preadv(BlockDriverState *bs,
+                                           int64_t offset, int64_t bytes,
+                                           QEMUIOVector *qiov,
+                                           size_t qiov_offset, int flags)
 {
    BlockDriver *drv = bs->drv;
    int64_t sector_num;
    unsigned int nb_sectors;
    QEMUIOVector local_qiov;
    int ret;
-    assert_bdrv_graph_readable();

    bdrv_check_qiov_request(offset, bytes, qiov, qiov_offset, &error_abort);
    assert(!(flags & ~bs->supported_read_flags));
@@ -1030,10 +1028,11 @@ out:
    return ret;
 }

-static int coroutine_fn GRAPH_RDLOCK
-bdrv_driver_pwritev(BlockDriverState *bs, int64_t offset, int64_t bytes,
-                    QEMUIOVector *qiov, size_t qiov_offset,
-                    BdrvRequestFlags flags)
+static int coroutine_fn bdrv_driver_pwritev(BlockDriverState *bs,
+                                            int64_t offset, int64_t bytes,
+                                            QEMUIOVector *qiov,
+                                            size_t qiov_offset,
+                                            BdrvRequestFlags flags)
 {
    BlockDriver *drv = bs->drv;
    bool emulate_fua = false;
@@ -1041,7 +1040,6 @@ bdrv_driver_pwritev(BlockDriverState *bs, int64_t offset, int64_t bytes,
    unsigned int nb_sectors;
    QEMUIOVector local_qiov;
    int ret;
-    assert_bdrv_graph_readable();

    bdrv_check_qiov_request(offset, bytes, qiov, qiov_offset, &error_abort);

@@ -1112,7 +1110,7 @@ emulate_flags:
    return ret;
 }

-static int coroutine_fn GRAPH_RDLOCK
+static int coroutine_fn
 bdrv_driver_pwritev_compressed(BlockDriverState *bs, int64_t offset,
                               int64_t bytes, QEMUIOVector *qiov,
                               size_t qiov_offset)
@@ -1120,7 +1118,6 @@ bdrv_driver_pwritev_compressed(BlockDriverState *bs, int64_t offset,
    BlockDriver *drv = bs->drv;
    QEMUIOVector local_qiov;
    int ret;
-    assert_bdrv_graph_readable();

    bdrv_check_qiov_request(offset, bytes, qiov, qiov_offset, &error_abort);

@@ -1148,9 +1145,9 @@ bdrv_driver_pwritev_compressed(BlockDriverState *bs, int64_t offset,
    return ret;
 }

-static int coroutine_fn GRAPH_RDLOCK
-bdrv_co_do_copy_on_readv(BdrvChild *child, int64_t offset, int64_t bytes,
-                         QEMUIOVector *qiov, size_t qiov_offset, int flags)
+static int coroutine_fn bdrv_co_do_copy_on_readv(BdrvChild *child,
+        int64_t offset, int64_t bytes, QEMUIOVector *qiov,
+        size_t qiov_offset, int flags)
 {
    BlockDriverState *bs = child->bs;

@@ -1312,10 +1309,9 @@ err:
 * handles copy on read, zeroing after EOF, and fragmentation of large
 * reads; any other features must be implemented by the caller.
 */
-static int coroutine_fn GRAPH_RDLOCK
-bdrv_aligned_preadv(BdrvChild *child, BdrvTrackedRequest *req,
-                    int64_t offset, int64_t bytes, int64_t align,
-                    QEMUIOVector *qiov, size_t qiov_offset, int flags)
+static int coroutine_fn bdrv_aligned_preadv(BdrvChild *child,
+    BdrvTrackedRequest *req, int64_t offset, int64_t bytes,
+    int64_t align, QEMUIOVector *qiov, size_t qiov_offset, int flags)
 {
    BlockDriverState *bs = child->bs;
    int64_t total_bytes, max_bytes;
@@ -1482,9 +1478,10 @@ static bool bdrv_init_padding(BlockDriverState *bs,
    return true;
 }

-static int coroutine_fn GRAPH_RDLOCK
-bdrv_padding_rmw_read(BdrvChild *child, BdrvTrackedRequest *req,
-                      BdrvRequestPadding *pad, bool zero_middle)
+static coroutine_fn int bdrv_padding_rmw_read(BdrvChild *child,
+                                              BdrvTrackedRequest *req,
+                                              BdrvRequestPadding *pad,
+                                              bool zero_middle)
 {
    QEMUIOVector local_qiov;
    BlockDriverState *bs = child->bs;
@@ -1672,9 +1669,8 @@ fail:
    return ret;
 }

-static int coroutine_fn GRAPH_RDLOCK
-bdrv_co_do_pwrite_zeroes(BlockDriverState *bs, int64_t offset, int64_t bytes,
-                         BdrvRequestFlags flags)
+static int coroutine_fn bdrv_co_do_pwrite_zeroes(BlockDriverState *bs,
+    int64_t offset, int64_t bytes, BdrvRequestFlags flags)
 {
    BlockDriver *drv = bs->drv;
    QEMUIOVector qiov;
@@ -1690,7 +1686,6 @@ bdrv_co_do_pwrite_zeroes(BlockDriverState *bs, int64_t offset, int64_t bytes,
                        bs->bl.request_alignment);
    int max_transfer = MIN_NON_ZERO(bs->bl.max_transfer, MAX_BOUNCE_BUFFER);

-    assert_bdrv_graph_readable();
    bdrv_check_request(offset, bytes, &error_abort);

    if (!drv) {
@@ -1894,11 +1889,10 @@ bdrv_co_write_req_finish(BdrvChild *child, int64_t offset, int64_t bytes,
 * Forwards an already correctly aligned write request to the BlockDriver,
 * after possibly fragmenting it.
 */
-static int coroutine_fn GRAPH_RDLOCK
-bdrv_aligned_pwritev(BdrvChild *child, BdrvTrackedRequest *req,
-                     int64_t offset, int64_t bytes, int64_t align,
-                     QEMUIOVector *qiov, size_t qiov_offset,
-                     BdrvRequestFlags flags)
+static int coroutine_fn bdrv_aligned_pwritev(BdrvChild *child,
+    BdrvTrackedRequest *req, int64_t offset, int64_t bytes,
+    int64_t align, QEMUIOVector *qiov, size_t qiov_offset,
+    BdrvRequestFlags flags)
 {
    BlockDriverState *bs = child->bs;
    BlockDriver *drv = bs->drv;
@@ -1982,9 +1976,11 @@ bdrv_aligned_pwritev(BdrvChild *child, BdrvTrackedRequest *req,
    return ret;
 }

-static int coroutine_fn GRAPH_RDLOCK
-bdrv_co_do_zero_pwritev(BdrvChild *child, int64_t offset, int64_t bytes,
-                        BdrvRequestFlags flags, BdrvTrackedRequest *req)
+static int coroutine_fn bdrv_co_do_zero_pwritev(BdrvChild *child,
+                                                int64_t offset,
+                                                int64_t bytes,
+                                                BdrvRequestFlags flags,
+                                                BdrvTrackedRequest *req)
 {
    BlockDriverState *bs = child->bs;
    QEMUIOVector local_qiov;
@@ -2157,7 +2153,6 @@ int coroutine_fn bdrv_co_pwrite_zeroes(BdrvChild *child, int64_t offset,
 {
    IO_CODE();
    trace_bdrv_co_pwrite_zeroes(child->bs, offset, bytes, flags);
-    assert_bdrv_graph_readable();

    if (!(child->bs->open_flags & BDRV_O_UNMAP)) {
        flags &= ~BDRV_REQ_MAY_UNMAP;
@@ -2229,10 +2224,11 @@ int bdrv_flush_all(void)
 * BDRV_BLOCK_OFFSET_VALID bit is set, 'map' and 'file' (if non-NULL) are
 * set to the host mapping and BDS corresponding to the guest offset.
 */
-static int coroutine_fn GRAPH_RDLOCK
-bdrv_co_block_status(BlockDriverState *bs, bool want_zero,
-                     int64_t offset, int64_t bytes,
-                     int64_t *pnum, int64_t *map, BlockDriverState **file)
+static int coroutine_fn bdrv_co_block_status(BlockDriverState *bs,
+                                             bool want_zero,
+                                             int64_t offset, int64_t bytes,
+                                             int64_t *pnum, int64_t *map,
+                                             BlockDriverState **file)
 {
    int64_t total_size;
    int64_t n; /* bytes */
@@ -2244,7 +2240,6 @@ bdrv_co_block_status(BlockDriverState *bs, bool want_zero,
    bool has_filtered_child;

    assert(pnum);
-    assert_bdrv_graph_readable();
    *pnum = 0;
    total_size = bdrv_getlength(bs);
    if (total_size < 0) {
@@ -2475,7 +2470,6 @@ bdrv_co_common_block_status_above(BlockDriverState *bs,
    IO_CODE();

    assert(!include_base || base); /* Can't include NULL base */
-    assert_bdrv_graph_readable();

    if (!depth) {
        depth = &dummy;
@@ -2842,7 +2836,6 @@ int coroutine_fn bdrv_co_flush(BlockDriverState *bs)
    int ret = 0;
    IO_CODE();

-    assert_bdrv_graph_readable();
    bdrv_inc_in_flight(bs);

    if (!bdrv_co_is_inserted(bs) || bdrv_is_read_only(bs) ||
@@ -2968,7 +2961,6 @@ int coroutine_fn bdrv_co_pdiscard(BdrvChild *child, int64_t offset,
    int head, tail, align;
    BlockDriverState *bs = child->bs;
    IO_CODE();
-    assert_bdrv_graph_readable();

    if (!bs || !bs->drv || !bdrv_co_is_inserted(bs)) {
        return -ENOMEDIUM;
@@ -3088,7 +3080,6 @@ int coroutine_fn bdrv_co_ioctl(BlockDriverState *bs, int req, void *buf)
    };
    BlockAIOCB *acb;
    IO_CODE();
-    assert_bdrv_graph_readable();

    bdrv_inc_in_flight(bs);
    if (!drv || (!drv->bdrv_aio_ioctl && !drv->bdrv_co_ioctl)) {
@@ -3153,7 +3144,6 @@ void coroutine_fn bdrv_co_io_plug(BlockDriverState *bs)
 {
    BdrvChild *child;
    IO_CODE();
-    assert_bdrv_graph_readable();

    QLIST_FOREACH(child, &bs->children, next) {
        bdrv_co_io_plug(child->bs);
@@ -3171,7 +3161,6 @@ void coroutine_fn bdrv_co_io_unplug(BlockDriverState *bs)
 {
    BdrvChild *child;
    IO_CODE();
-    assert_bdrv_graph_readable();

    assert(bs->io_plugged);
    if (qatomic_fetch_dec(&bs->io_plugged) == 1) {
@@ -3187,15 +3176,13 @@ void coroutine_fn bdrv_co_io_unplug(BlockDriverState *bs)
 }

 /* Helper that undoes bdrv_register_buf() when it fails partway through */
-static void GRAPH_RDLOCK
-bdrv_register_buf_rollback(BlockDriverState *bs, void *host, size_t size,
-                           BdrvChild *final_child)
+static void bdrv_register_buf_rollback(BlockDriverState *bs,
+                                       void *host,
+                                       size_t size,
+                                       BdrvChild *final_child)
 {
    BdrvChild *child;

-    GLOBAL_STATE_CODE();
-    assert_bdrv_graph_readable();
-
    QLIST_FOREACH(child, &bs->children, next) {
        if (child == final_child) {
            break;
@@ -3215,8 +3202,6 @@ bool bdrv_register_buf(BlockDriverState *bs, void *host, size_t size,
    BdrvChild *child;

    GLOBAL_STATE_CODE();
-    GRAPH_RDLOCK_GUARD_MAINLOOP();
-
    if (bs->drv && bs->drv->bdrv_register_buf) {
        if (!bs->drv->bdrv_register_buf(bs, host, size, errp)) {
            return false;
@@ -3236,8 +3221,6 @@ void bdrv_unregister_buf(BlockDriverState *bs, void *host, size_t size)
    BdrvChild *child;

    GLOBAL_STATE_CODE();
-    GRAPH_RDLOCK_GUARD_MAINLOOP();
-
    if (bs->drv && bs->drv->bdrv_unregister_buf) {
        bs->drv->bdrv_unregister_buf(bs, host, size);
    }
@@ -3246,7 +3229,7 @@ void bdrv_unregister_buf(BlockDriverState *bs, void *host, size_t size)
    }
 }

-static int coroutine_fn GRAPH_RDLOCK bdrv_co_copy_range_internal(
+static int coroutine_fn bdrv_co_copy_range_internal(
        BdrvChild *src, int64_t src_offset, BdrvChild *dst,
        int64_t dst_offset, int64_t bytes,
        BdrvRequestFlags read_flags, BdrvRequestFlags write_flags,
@@ -3254,7 +3237,6 @@ static int coroutine_fn GRAPH_RDLOCK bdrv_co_copy_range_internal(
 {
    BdrvTrackedRequest req;
    int ret;
-    assert_bdrv_graph_readable();

    /* TODO We can support BDRV_REQ_NO_FALLBACK here */
    assert(!(read_flags & BDRV_REQ_NO_FALLBACK));
@@ -3336,7 +3318,6 @@ int coroutine_fn bdrv_co_copy_range_from(BdrvChild *src, int64_t src_offset,
                                         BdrvRequestFlags write_flags)
 {
    IO_CODE();
-    assert_bdrv_graph_readable();
    trace_bdrv_co_copy_range_from(src, src_offset, dst, dst_offset, bytes,
                                  read_flags, write_flags);
    return bdrv_co_copy_range_internal(src, src_offset, dst, dst_offset,
@@ -3354,7 +3335,6 @@ int coroutine_fn bdrv_co_copy_range_to(BdrvChild *src, int64_t src_offset,
                                       BdrvRequestFlags write_flags)
 {
    IO_CODE();
-    assert_bdrv_graph_readable();
    trace_bdrv_co_copy_range_to(src, src_offset, dst, dst_offset, bytes,
                                read_flags, write_flags);
    return bdrv_co_copy_range_internal(src, src_offset, dst, dst_offset,
@@ -3367,8 +3347,6 @@ int coroutine_fn bdrv_co_copy_range(BdrvChild *src, int64_t src_offset,
                                    BdrvRequestFlags write_flags)
 {
    IO_CODE();
-    assert_bdrv_graph_readable();
-
    return bdrv_co_copy_range_from(src, src_offset,
                                   dst, dst_offset,
                                   bytes, read_flags, write_flags);
@@ -3402,7 +3380,6 @@ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact,
    int64_t old_size, new_bytes;
    int ret;
    IO_CODE();
-    assert_bdrv_graph_readable();

    /* if bs->drv == NULL, bs is closed, so there's nothing to do here */
    if (!drv) {
@@ -3540,7 +3517,6 @@ bdrv_co_preadv_snapshot(BdrvChild *child, int64_t offset, int64_t bytes,
    BlockDriver *drv = bs->drv;
    int ret;
    IO_CODE();
-    assert_bdrv_graph_readable();

    if (!drv) {
        return -ENOMEDIUM;
@@ -3566,7 +3542,6 @@ bdrv_co_snapshot_block_status(BlockDriverState *bs,
    BlockDriver *drv = bs->drv;
    int ret;
    IO_CODE();
-    assert_bdrv_graph_readable();

    if (!drv) {
        return -ENOMEDIUM;
@@ -3590,7 +3565,6 @@ bdrv_co_pdiscard_snapshot(BlockDriverState *bs, int64_t offset, int64_t bytes)
    BlockDriver *drv = bs->drv;
    int ret;
    IO_CODE();
-    assert_bdrv_graph_readable();

    if (!drv) {
        return -ENOMEDIUM;
--- a/block/iscsi.c
+++ b/block/iscsi.c
@@ -269,7 +269,6 @@ iscsi_co_generic_cb(struct iscsi_context *iscsi, int status,
                timer_mod(&iTask->retry_timer,
                          qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + retry_time);
                iTask->do_retry = 1;
-                return;
            } else if (status == SCSI_STATUS_CHECK_CONDITION) {
                int error = iscsi_translate_sense(&task->sense);
                if (error == EAGAIN) {
@@ -1354,9 +1353,6 @@ static void apply_chap(struct iscsi_context *iscsi, QemuOpts *opts,
    } else if (!password) {
        error_setg(errp, "CHAP username specified but no password was given");
        return;
-    } else {
-        warn_report("iSCSI block driver 'password' option is deprecated, "
-                    "use 'password-secret' instead");
    }

    if (iscsi_set_initiator_username_pwd(iscsi, user, password)) {
@@ -2190,12 +2186,14 @@ static void coroutine_fn iscsi_co_invalidate_cache(BlockDriverState *bs,
    iscsi_allocmap_invalidate(iscsilun);
 }

-static int coroutine_fn GRAPH_RDLOCK
-iscsi_co_copy_range_from(BlockDriverState *bs,
-                         BdrvChild *src, int64_t src_offset,
-                         BdrvChild *dst, int64_t dst_offset,
-                         int64_t bytes, BdrvRequestFlags read_flags,
-                         BdrvRequestFlags write_flags)
+static int coroutine_fn iscsi_co_copy_range_from(BlockDriverState *bs,
+                                                 BdrvChild *src,
+                                                 int64_t src_offset,
+                                                 BdrvChild *dst,
+                                                 int64_t dst_offset,
+                                                 int64_t bytes,
+                                                 BdrvRequestFlags read_flags,
+                                                 BdrvRequestFlags write_flags)
 {
    return bdrv_co_copy_range_to(src, src_offset, dst, dst_offset, bytes,
                                 read_flags, write_flags);
@@ -2329,12 +2327,14 @@ static void iscsi_xcopy_data(struct iscsi_data *data,
                              src_lba, dst_lba);
 }

-static int coroutine_fn GRAPH_RDLOCK
-iscsi_co_copy_range_to(BlockDriverState *bs,
-                       BdrvChild *src, int64_t src_offset,
-                       BdrvChild *dst, int64_t dst_offset,
-                       int64_t bytes, BdrvRequestFlags read_flags,
-                       BdrvRequestFlags write_flags)
+static int coroutine_fn iscsi_co_copy_range_to(BlockDriverState *bs,
+                                               BdrvChild *src,
+                                               int64_t src_offset,
+                                               BdrvChild *dst,
+                                               int64_t dst_offset,
+                                               int64_t bytes,
+                                               BdrvRequestFlags read_flags,
+                                               BdrvRequestFlags write_flags)
 {
    IscsiLun *dst_lun = dst->bs->opaque;
    IscsiLun *src_lun;
--- a/block/meson.build
+++ b/block/meson.build
@@ -141,7 +141,6 @@ block_gen_c = custom_target('block-gen.c',
                                      '../include/block/dirty-bitmap.h',
                                      '../include/block/block_int-io.h',
                                      '../include/block/block-global-state.h',
-                                      '../include/sysemu/block-backend-global-state.h',
                                      '../include/sysemu/block-backend-io.h',
                                      'coroutines.h'
                                      ),
--- a/block/mirror.c
+++ b/block/mirror.c
@@ -21,6 +21,7 @@
 #include "block/dirty-bitmap.h"
 #include "sysemu/block-backend.h"
 #include "qapi/error.h"
+#include "qapi/qmp/qerror.h"
 #include "qemu/ratelimit.h"
 #include "qemu/bitmap.h"
 #include "qemu/memalign.h"
@@ -389,10 +390,8 @@ static void coroutine_fn mirror_co_read(void *opaque)
    op->is_in_flight = true;
    trace_mirror_one_iteration(s, op->offset, op->bytes);

-    WITH_GRAPH_RDLOCK_GUARD() {
-        ret = bdrv_co_preadv(s->mirror_top_bs->backing, op->offset, op->bytes,
-                             &op->qiov, 0);
-    }
+    ret = bdrv_co_preadv(s->mirror_top_bs->backing, op->offset, op->bytes,
+                         &op->qiov, 0);
    mirror_read_complete(op, ret);
 }

@@ -559,11 +558,9 @@ static uint64_t coroutine_fn mirror_iteration(MirrorBlockJob *s)
        MirrorMethod mirror_method = MIRROR_METHOD_COPY;

        assert(!(offset % s->granularity));
-        WITH_GRAPH_RDLOCK_GUARD() {
-            ret = bdrv_block_status_above(source, NULL, offset,
-                                        nb_chunks * s->granularity,
-                                        &io_bytes, NULL, NULL);
-        }
+        ret = bdrv_block_status_above(source, NULL, offset,
+                                      nb_chunks * s->granularity,
+                                      &io_bytes, NULL, NULL);
        if (ret < 0) {
            io_bytes = MIN(nb_chunks * s->granularity, max_io_bytes);
        } else if (ret & BDRV_BLOCK_DATA) {
@@ -866,10 +863,8 @@ static int coroutine_fn mirror_dirty_init(MirrorBlockJob *s)
            return 0;
        }

-        WITH_GRAPH_RDLOCK_GUARD() {
-            ret = bdrv_is_allocated_above(bs, s->base_overlay, true, offset,
-                                          bytes, &count);
-        }
+        ret = bdrv_is_allocated_above(bs, s->base_overlay, true, offset, bytes,
+                                      &count);
        if (ret < 0) {
            return ret;
        }
@@ -901,7 +896,6 @@ static int coroutine_fn mirror_run(Job *job, Error **errp)
 {
    MirrorBlockJob *s = container_of(job, MirrorBlockJob, common.job);
    BlockDriverState *bs = s->mirror_top_bs->backing->bs;
-    MirrorBDSOpaque *mirror_top_opaque = s->mirror_top_bs->opaque;
    BlockDriverState *target_bs = blk_bs(s->target);
    bool need_drain = true;
    BlockDeviceIoStatus iostatus;
@@ -916,10 +910,7 @@ static int coroutine_fn mirror_run(Job *job, Error **errp)
        goto immediate_exit;
    }

-    bdrv_graph_co_rdlock();
    s->bdev_length = bdrv_co_getlength(bs);
-    bdrv_graph_co_rdunlock();
-
    if (s->bdev_length < 0) {
        ret = s->bdev_length;
        goto immediate_exit;
@@ -994,12 +985,6 @@ static int coroutine_fn mirror_run(Job *job, Error **errp)
        }
    }

-    /*
-     * Only now the job is fully initialised and mirror_top_bs should start
-     * accessing it.
-     */
-    mirror_top_opaque->job = s;
-
    assert(!s->dbi);
    s->dbi = bdrv_dirty_iter_new(s->dirty_bitmap);
    for (;;) {
@@ -1441,17 +1426,15 @@ static void coroutine_fn active_write_settle(MirrorOp *op)
    g_free(op);
 }

-static int coroutine_fn GRAPH_RDLOCK
-bdrv_mirror_top_preadv(BlockDriverState *bs, int64_t offset, int64_t bytes,
-                       QEMUIOVector *qiov, BdrvRequestFlags flags)
+static int coroutine_fn bdrv_mirror_top_preadv(BlockDriverState *bs,
+    int64_t offset, int64_t bytes, QEMUIOVector *qiov, BdrvRequestFlags flags)
 {
    return bdrv_co_preadv(bs->backing, offset, bytes, qiov, flags);
 }

-static int coroutine_fn GRAPH_RDLOCK
-bdrv_mirror_top_do_write(BlockDriverState *bs, MirrorMethod method,
-                         uint64_t offset, uint64_t bytes, QEMUIOVector *qiov,
-                         int flags)
+static int coroutine_fn bdrv_mirror_top_do_write(BlockDriverState *bs,
+    MirrorMethod method, uint64_t offset, uint64_t bytes, QEMUIOVector *qiov,
+    int flags)
 {
    MirrorOp *op = NULL;
    MirrorBDSOpaque *s = bs->opaque;
@@ -1500,9 +1483,8 @@ out:
    return ret;
 }

-static int coroutine_fn GRAPH_RDLOCK
-bdrv_mirror_top_pwritev(BlockDriverState *bs, int64_t offset, int64_t bytes,
-                        QEMUIOVector *qiov, BdrvRequestFlags flags)
+static int coroutine_fn bdrv_mirror_top_pwritev(BlockDriverState *bs,
+    int64_t offset, int64_t bytes, QEMUIOVector *qiov, BdrvRequestFlags flags)
 {
    MirrorBDSOpaque *s = bs->opaque;
    QEMUIOVector bounce_qiov;
@@ -1542,7 +1524,7 @@ bdrv_mirror_top_pwritev(BlockDriverState *bs, int64_t offset, int64_t bytes,
    return ret;
 }

-static int coroutine_fn GRAPH_RDLOCK bdrv_mirror_top_flush(BlockDriverState *bs)
+static int coroutine_fn bdrv_mirror_top_flush(BlockDriverState *bs)
 {
    if (bs->backing == NULL) {
        /* we can be here after failed bdrv_append in mirror_start_job */
@@ -1551,16 +1533,15 @@ static int coroutine_fn GRAPH_RDLOCK bdrv_mirror_top_flush(BlockDriverState *bs)
    return bdrv_co_flush(bs->backing->bs);
 }

-static int coroutine_fn GRAPH_RDLOCK
-bdrv_mirror_top_pwrite_zeroes(BlockDriverState *bs, int64_t offset,
-                              int64_t bytes, BdrvRequestFlags flags)
+static int coroutine_fn bdrv_mirror_top_pwrite_zeroes(BlockDriverState *bs,
+    int64_t offset, int64_t bytes, BdrvRequestFlags flags)
 {
    return bdrv_mirror_top_do_write(bs, MIRROR_METHOD_ZERO, offset, bytes, NULL,
                                    flags);
 }

-static int coroutine_fn GRAPH_RDLOCK
-bdrv_mirror_top_pdiscard(BlockDriverState *bs, int64_t offset, int64_t bytes)
+static int coroutine_fn bdrv_mirror_top_pdiscard(BlockDriverState *bs,
+    int64_t offset, int64_t bytes)
 {
    return bdrv_mirror_top_do_write(bs, MIRROR_METHOD_DISCARD, offset, bytes,
                                    NULL, 0);
@@ -1723,6 +1704,7 @@ static BlockJob *mirror_start_job(
    if (!s) {
        goto fail;
    }
+    bs_opaque->job = s;

    /* The block job now has a reference to this node */
    bdrv_unref(mirror_top_bs);
--- a/block/parallels.c
+++ b/block/parallels.c
@@ -165,9 +165,9 @@ static int64_t block_status(BDRVParallelsState *s, int64_t sector_num,
    return start_off;
 }

-static int64_t coroutine_fn GRAPH_RDLOCK
-allocate_clusters(BlockDriverState *bs, int64_t sector_num,
-                  int nb_sectors, int *pnum)
+static coroutine_fn int64_t allocate_clusters(BlockDriverState *bs,
+                                              int64_t sector_num,
+                                              int nb_sectors, int *pnum)
 {
    int ret = 0;
    BDRVParallelsState *s = bs->opaque;
@@ -261,8 +261,7 @@ allocate_clusters(BlockDriverState *bs, int64_t sector_num,
 }


-static int coroutine_fn GRAPH_RDLOCK
-parallels_co_flush_to_os(BlockDriverState *bs)
+static coroutine_fn int parallels_co_flush_to_os(BlockDriverState *bs)
 {
    BDRVParallelsState *s = bs->opaque;
    unsigned long size = DIV_ROUND_UP(s->header_size, s->bat_dirty_block);
@@ -321,9 +320,9 @@ static int coroutine_fn parallels_co_block_status(BlockDriverState *bs,
    return BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID;
 }

-static int coroutine_fn GRAPH_RDLOCK
-parallels_co_writev(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
-                    QEMUIOVector *qiov, int flags)
+static coroutine_fn int parallels_co_writev(BlockDriverState *bs,
+                                            int64_t sector_num, int nb_sectors,
+                                            QEMUIOVector *qiov, int flags)
 {
    BDRVParallelsState *s = bs->opaque;
    uint64_t bytes_done = 0;
@@ -364,9 +363,8 @@ parallels_co_writev(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
    return ret;
 }

-static int coroutine_fn GRAPH_RDLOCK
-parallels_co_readv(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
-                   QEMUIOVector *qiov)
+static coroutine_fn int parallels_co_readv(BlockDriverState *bs,
+        int64_t sector_num, int nb_sectors, QEMUIOVector *qiov)
 {
    BDRVParallelsState *s = bs->opaque;
    uint64_t bytes_done = 0;
@@ -416,9 +414,9 @@ parallels_co_readv(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
 }


-static int coroutine_fn GRAPH_RDLOCK
-parallels_co_check(BlockDriverState *bs, BdrvCheckResult *res,
-                   BdrvCheckMode fix)
+static int coroutine_fn parallels_co_check(BlockDriverState *bs,
+                                           BdrvCheckResult *res,
+                                           BdrvCheckMode fix)
 {
    BDRVParallelsState *s = bs->opaque;
    int64_t size, prev_off, high_off;
@@ -567,13 +565,13 @@ static int coroutine_fn parallels_co_create(BlockdevCreateOptions* opts,
    }

    /* Create BlockBackend to write to the image */
-    bs = bdrv_co_open_blockdev_ref(parallels_opts->file, errp);
+    bs = bdrv_open_blockdev_ref(parallels_opts->file, errp);
    if (bs == NULL) {
        return -EIO;
    }

-    blk = blk_co_new_with_bs(bs, BLK_PERM_WRITE | BLK_PERM_RESIZE, BLK_PERM_ALL,
-                             errp);
+    blk = blk_new_with_bs(bs, BLK_PERM_WRITE | BLK_PERM_RESIZE, BLK_PERM_ALL,
+                          errp);
    if (!blk) {
        ret = -EPERM;
        goto out;
@@ -622,9 +620,10 @@ exit:
    goto out;
 }

-static int coroutine_fn GRAPH_RDLOCK
-parallels_co_create_opts(BlockDriver *drv, const char *filename,
-                         QemuOpts *opts, Error **errp)
+static int coroutine_fn parallels_co_create_opts(BlockDriver *drv,
+                                                 const char *filename,
+                                                 QemuOpts *opts,
+                                                 Error **errp)
 {
    BlockdevCreateOptions *create_options = NULL;
    BlockDriverState *bs = NULL;
@@ -652,8 +651,8 @@ parallels_co_create_opts(BlockDriver *drv, const char *filename,
        goto done;
    }

-    bs = bdrv_co_open(filename, NULL, NULL,
-                      BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL, errp);
+    bs = bdrv_open(filename, NULL, NULL,
+                   BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL, errp);
    if (bs == NULL) {
        ret = -EIO;
        goto done;
--- a/block/preallocate.c
+++ b/block/preallocate.c
@@ -226,17 +226,16 @@ static void preallocate_reopen_abort(BDRVReopenState *state)
    state->opaque = NULL;
 }

-static int coroutine_fn GRAPH_RDLOCK
-preallocate_co_preadv_part(BlockDriverState *bs, int64_t offset, int64_t bytes,
-                           QEMUIOVector *qiov, size_t qiov_offset,
-                           BdrvRequestFlags flags)
+static coroutine_fn int preallocate_co_preadv_part(
+        BlockDriverState *bs, int64_t offset, int64_t bytes,
+        QEMUIOVector *qiov, size_t qiov_offset, BdrvRequestFlags flags)
 {
    return bdrv_co_preadv_part(bs->file, offset, bytes, qiov, qiov_offset,
                               flags);
 }

-static int coroutine_fn GRAPH_RDLOCK
-preallocate_co_pdiscard(BlockDriverState *bs, int64_t offset, int64_t bytes)
+static int coroutine_fn preallocate_co_pdiscard(BlockDriverState *bs,
+                                               int64_t offset, int64_t bytes)
 {
    return bdrv_co_pdiscard(bs->file, offset, bytes);
 }
@@ -270,9 +269,8 @@ static bool has_prealloc_perms(BlockDriverState *bs)
 * want_merge_zero is used to merge write-zero request with preallocation in
 * one bdrv_co_pwrite_zeroes() call.
 */
-static bool coroutine_fn GRAPH_RDLOCK
-handle_write(BlockDriverState *bs, int64_t offset, int64_t bytes,
-             bool want_merge_zero)
+static bool coroutine_fn handle_write(BlockDriverState *bs, int64_t offset,
+                                      int64_t bytes, bool want_merge_zero)
 {
    BDRVPreallocateState *s = bs->opaque;
    int64_t end = offset + bytes;
@@ -347,9 +345,8 @@ handle_write(BlockDriverState *bs, int64_t offset, int64_t bytes,
    return want_merge_zero;
 }

-static int coroutine_fn GRAPH_RDLOCK
-preallocate_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset,
-                             int64_t bytes, BdrvRequestFlags flags)
+static int coroutine_fn preallocate_co_pwrite_zeroes(BlockDriverState *bs,
+        int64_t offset, int64_t bytes, BdrvRequestFlags flags)
 {
    bool want_merge_zero =
        !(flags & ~(BDRV_REQ_ZERO_WRITE | BDRV_REQ_NO_FALLBACK));
@@ -360,10 +357,12 @@ preallocate_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset,
    return bdrv_co_pwrite_zeroes(bs->file, offset, bytes, flags);
 }

-static int coroutine_fn GRAPH_RDLOCK
-preallocate_co_pwritev_part(BlockDriverState *bs, int64_t offset, int64_t bytes,
-                            QEMUIOVector *qiov, size_t qiov_offset,
-                            BdrvRequestFlags flags)
+static coroutine_fn int preallocate_co_pwritev_part(BlockDriverState *bs,
+                                                    int64_t offset,
+                                                    int64_t bytes,
+                                                    QEMUIOVector *qiov,
+                                                    size_t qiov_offset,
+                                                    BdrvRequestFlags flags)
 {
    handle_write(bs, offset, bytes, false);

@@ -371,7 +370,7 @@ preallocate_co_pwritev_part(BlockDriverState *bs, int64_t offset, int64_t bytes,
                                flags);
 }

-static int coroutine_fn GRAPH_RDLOCK
+static int coroutine_fn
 preallocate_co_truncate(BlockDriverState *bs, int64_t offset,
                        bool exact, PreallocMode prealloc,
                        BdrvRequestFlags flags, Error **errp)
@@ -438,13 +437,12 @@ preallocate_co_truncate(BlockDriverState *bs, int64_t offset,
    return 0;
 }

-static int coroutine_fn GRAPH_RDLOCK preallocate_co_flush(BlockDriverState *bs)
+static int coroutine_fn preallocate_co_flush(BlockDriverState *bs)
 {
    return bdrv_co_flush(bs->file->bs);
 }

-static int64_t coroutine_fn GRAPH_RDLOCK
-preallocate_co_getlength(BlockDriverState *bs)
+static int64_t coroutine_fn preallocate_co_getlength(BlockDriverState *bs)
 {
    int64_t ret;
    BDRVPreallocateState *s = bs->opaque;
--- a/block/qcow.c
+++ b/block/qcow.c
@@ -92,8 +92,8 @@ typedef struct BDRVQcowState {

 static QemuOptsList qcow_create_opts;

-static int coroutine_fn GRAPH_RDLOCK
-decompress_cluster(BlockDriverState *bs, uint64_t cluster_offset);
+static int coroutine_fn decompress_cluster(BlockDriverState *bs,
+                                           uint64_t cluster_offset);

 static int qcow_probe(const uint8_t *buf, int buf_size, const char *filename)
 {
@@ -350,10 +350,11 @@ static int qcow_reopen_prepare(BDRVReopenState *state,
 * return 0 if not allocated, 1 if *result is assigned, and negative
 * errno on failure.
 */
-static int coroutine_fn GRAPH_RDLOCK
-get_cluster_offset(BlockDriverState *bs, uint64_t offset, int allocate,
-                   int compressed_size, int n_start, int n_end,
-                   uint64_t *result)
+static int coroutine_fn get_cluster_offset(BlockDriverState *bs,
+                                           uint64_t offset, int allocate,
+                                           int compressed_size,
+                                           int n_start, int n_end,
+                                           uint64_t *result)
 {
    BDRVQcowState *s = bs->opaque;
    int min_index, i, j, l1_index, l2_index, ret;
@@ -524,10 +525,11 @@ get_cluster_offset(BlockDriverState *bs, uint64_t offset, int allocate,
    return 1;
 }

-static int coroutine_fn GRAPH_RDLOCK
-qcow_co_block_status(BlockDriverState *bs, bool want_zero,
-                     int64_t offset, int64_t bytes, int64_t *pnum,
-                     int64_t *map, BlockDriverState **file)
+static int coroutine_fn qcow_co_block_status(BlockDriverState *bs,
+                                             bool want_zero,
+                                             int64_t offset, int64_t bytes,
+                                             int64_t *pnum, int64_t *map,
+                                             BlockDriverState **file)
 {
    BDRVQcowState *s = bs->opaque;
    int index_in_cluster, ret;
@@ -584,8 +586,8 @@ static int decompress_buffer(uint8_t *out_buf, int out_buf_size,
    return 0;
 }

-static int coroutine_fn GRAPH_RDLOCK
-decompress_cluster(BlockDriverState *bs, uint64_t cluster_offset)
+static int coroutine_fn decompress_cluster(BlockDriverState *bs,
+                                           uint64_t cluster_offset)
 {
    BDRVQcowState *s = bs->opaque;
    int ret, csize;
@@ -617,9 +619,9 @@ static void qcow_refresh_limits(BlockDriverState *bs, Error **errp)
    bs->bl.request_alignment = BDRV_SECTOR_SIZE;
 }

-static int coroutine_fn GRAPH_RDLOCK
-qcow_co_preadv(BlockDriverState *bs, int64_t offset, int64_t bytes,
-               QEMUIOVector *qiov, BdrvRequestFlags flags)
+static coroutine_fn int qcow_co_preadv(BlockDriverState *bs, int64_t offset,
+                                       int64_t bytes, QEMUIOVector *qiov,
+                                       BdrvRequestFlags flags)
 {
    BDRVQcowState *s = bs->opaque;
    int offset_in_cluster;
@@ -713,9 +715,9 @@ qcow_co_preadv(BlockDriverState *bs, int64_t offset, int64_t bytes,
    return ret;
 }

-static int coroutine_fn GRAPH_RDLOCK
-qcow_co_pwritev(BlockDriverState *bs, int64_t offset, int64_t bytes,
-                QEMUIOVector *qiov, BdrvRequestFlags flags)
+static coroutine_fn int qcow_co_pwritev(BlockDriverState *bs, int64_t offset,
+                                        int64_t bytes, QEMUIOVector *qiov,
+                                        BdrvRequestFlags flags)
 {
    BDRVQcowState *s = bs->opaque;
    int offset_in_cluster;
@@ -831,13 +833,13 @@ static int coroutine_fn qcow_co_create(BlockdevCreateOptions *opts,
    }

    /* Create BlockBackend to write to the image */
-    bs = bdrv_co_open_blockdev_ref(qcow_opts->file, errp);
+    bs = bdrv_open_blockdev_ref(qcow_opts->file, errp);
    if (bs == NULL) {
        return -EIO;
    }

-    qcow_blk = blk_co_new_with_bs(bs, BLK_PERM_WRITE | BLK_PERM_RESIZE,
-                                  BLK_PERM_ALL, errp);
+    qcow_blk = blk_new_with_bs(bs, BLK_PERM_WRITE | BLK_PERM_RESIZE,
+                               BLK_PERM_ALL, errp);
    if (!qcow_blk) {
        ret = -EPERM;
        goto exit;
@@ -921,9 +923,9 @@ exit:
    return ret;
 }

-static int coroutine_fn GRAPH_RDLOCK
-qcow_co_create_opts(BlockDriver *drv, const char *filename,
-                    QemuOpts *opts, Error **errp)
+static int coroutine_fn qcow_co_create_opts(BlockDriver *drv,
+                                            const char *filename,
+                                            QemuOpts *opts, Error **errp)
 {
    BlockdevCreateOptions *create_options = NULL;
    BlockDriverState *bs = NULL;
@@ -976,8 +978,8 @@ qcow_co_create_opts(BlockDriver *drv, const char *filename,
        goto fail;
    }

-    bs = bdrv_co_open(filename, NULL, NULL,
-                      BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL, errp);
+    bs = bdrv_open(filename, NULL, NULL,
+                   BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL, errp);
    if (bs == NULL) {
        ret = -EIO;
        goto fail;
@@ -1044,7 +1046,7 @@ static int qcow_make_empty(BlockDriverState *bs)

 /* XXX: put compressed sectors first, then all the cluster aligned
   tables to avoid losing bytes in alignment */
-static int coroutine_fn GRAPH_RDLOCK
+static coroutine_fn int
 qcow_co_pwritev_compressed(BlockDriverState *bs, int64_t offset, int64_t bytes,
                           QEMUIOVector *qiov)
 {
--- a/block/qcow2-cluster.c
+++ b/block/qcow2-cluster.c
@@ -491,9 +491,10 @@ static int count_contiguous_subclusters(BlockDriverState *bs, int nb_clusters,
    return count;
 }

-static int coroutine_fn GRAPH_RDLOCK
-do_perform_cow_read(BlockDriverState *bs, uint64_t src_cluster_offset,
-                    unsigned offset_in_cluster, QEMUIOVector *qiov)
+static int coroutine_fn do_perform_cow_read(BlockDriverState *bs,
+                                            uint64_t src_cluster_offset,
+                                            unsigned offset_in_cluster,
+                                            QEMUIOVector *qiov)
 {
    int ret;

@@ -534,9 +535,10 @@ do_perform_cow_read(BlockDriverState *bs, uint64_t src_cluster_offset,
    return 0;
 }

-static int coroutine_fn GRAPH_RDLOCK
-do_perform_cow_write(BlockDriverState *bs, uint64_t cluster_offset,
-                     unsigned offset_in_cluster, QEMUIOVector *qiov)
+static int coroutine_fn do_perform_cow_write(BlockDriverState *bs,
+                                             uint64_t cluster_offset,
+                                             unsigned offset_in_cluster,
+                                             QEMUIOVector *qiov)
 {
    BDRVQcow2State *s = bs->opaque;
    int ret;
@@ -884,8 +886,7 @@ int coroutine_fn qcow2_alloc_compressed_cluster_offset(BlockDriverState *bs,
    return 0;
 }

-static int coroutine_fn GRAPH_RDLOCK
-perform_cow(BlockDriverState *bs, QCowL2Meta *m)
+static int coroutine_fn perform_cow(BlockDriverState *bs, QCowL2Meta *m)
 {
    BDRVQcow2State *s = bs->opaque;
    Qcow2COWRegion *start = &m->cow_start;
--- a/block/qcow2.c
+++ b/block/qcow2.c
@@ -601,9 +601,9 @@ static void qcow2_add_check_result(BdrvCheckResult *out,
    }
 }

-static int coroutine_fn GRAPH_RDLOCK
-qcow2_co_check_locked(BlockDriverState *bs, BdrvCheckResult *result,
-                      BdrvCheckMode fix)
+static int coroutine_fn qcow2_co_check_locked(BlockDriverState *bs,
+                                              BdrvCheckResult *result,
+                                              BdrvCheckMode fix)
 {
    BdrvCheckResult snapshot_res = {};
    BdrvCheckResult refcount_res = {};
@@ -640,9 +640,9 @@ qcow2_co_check_locked(BlockDriverState *bs, BdrvCheckResult *result,
    return ret;
 }

-static int coroutine_fn GRAPH_RDLOCK
-qcow2_co_check(BlockDriverState *bs, BdrvCheckResult *result,
-               BdrvCheckMode fix)
+static int coroutine_fn qcow2_co_check(BlockDriverState *bs,
+                                       BdrvCheckResult *result,
+                                       BdrvCheckMode fix)
 {
    BDRVQcow2State *s = bs->opaque;
    int ret;
@@ -1294,9 +1294,9 @@ static int validate_compression_type(BDRVQcow2State *s, Error **errp)
 }

 /* Called with s->lock held.  */
-static int coroutine_fn GRAPH_RDLOCK
-qcow2_do_open(BlockDriverState *bs, QDict *options, int flags,
-              bool open_data_file, Error **errp)
+static int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options,
+                                      int flags, bool open_data_file,
+                                      Error **errp)
 {
    ERRP_GUARD();
    BDRVQcow2State *s = bs->opaque;
@@ -1617,9 +1617,9 @@ qcow2_do_open(BlockDriverState *bs, QDict *options, int flags,

    if (open_data_file) {
        /* Open external data file */
-        s->data_file = bdrv_co_open_child(NULL, options, "data-file", bs,
-                                          &child_of_bds, BDRV_CHILD_DATA,
-                                          true, errp);
+        s->data_file = bdrv_open_child(NULL, options, "data-file", bs,
+                                       &child_of_bds, BDRV_CHILD_DATA,
+                                       true, errp);
        if (*errp) {
            ret = -EINVAL;
            goto fail;
@@ -1627,10 +1627,9 @@ qcow2_do_open(BlockDriverState *bs, QDict *options, int flags,

        if (s->incompatible_features & QCOW2_INCOMPAT_DATA_FILE) {
            if (!s->data_file && s->image_data_file) {
-                s->data_file = bdrv_co_open_child(s->image_data_file, options,
-                                                  "data-file", bs,
-                                                  &child_of_bds,
-                                                  BDRV_CHILD_DATA, false, errp);
+                s->data_file = bdrv_open_child(s->image_data_file, options,
+                                               "data-file", bs, &child_of_bds,
+                                               BDRV_CHILD_DATA, false, errp);
                if (!s->data_file) {
                    ret = -EINVAL;
                    goto fail;
@@ -1890,8 +1889,6 @@ static void coroutine_fn qcow2_open_entry(void *opaque)
    QCow2OpenCo *qoc = opaque;
    BDRVQcow2State *s = qoc->bs->opaque;

-    assume_graph_lock(); /* FIXME */
-
    qemu_co_mutex_lock(&s->lock);
    qoc->ret = qcow2_do_open(qoc->bs, qoc->options, qoc->flags, true,
                             qoc->errp);
@@ -2139,8 +2136,9 @@ static int coroutine_fn qcow2_co_block_status(BlockDriverState *bs,
    return status;
 }

-static int coroutine_fn GRAPH_RDLOCK
-qcow2_handle_l2meta(BlockDriverState *bs, QCowL2Meta **pl2meta, bool link_l2)
+static coroutine_fn int qcow2_handle_l2meta(BlockDriverState *bs,
+                                            QCowL2Meta **pl2meta,
+                                            bool link_l2)
 {
    int ret = 0;
    QCowL2Meta *l2meta = *pl2meta;
@@ -2171,7 +2169,7 @@ out:
    return ret;
 }

-static int coroutine_fn GRAPH_RDLOCK
+static coroutine_fn int
 qcow2_co_preadv_encrypted(BlockDriverState *bs,
                           uint64_t host_offset,
                           uint64_t offset,
@@ -2272,10 +2270,12 @@ static coroutine_fn int qcow2_add_task(BlockDriverState *bs,
    return 0;
 }

-static int coroutine_fn GRAPH_RDLOCK
-qcow2_co_preadv_task(BlockDriverState *bs, QCow2SubclusterType subc_type,
-                     uint64_t host_offset, uint64_t offset, uint64_t bytes,
-                     QEMUIOVector *qiov, size_t qiov_offset)
+static coroutine_fn int qcow2_co_preadv_task(BlockDriverState *bs,
+                                             QCow2SubclusterType subc_type,
+                                             uint64_t host_offset,
+                                             uint64_t offset, uint64_t bytes,
+                                             QEMUIOVector *qiov,
+                                             size_t qiov_offset)
 {
    BDRVQcow2State *s = bs->opaque;

@@ -2314,11 +2314,7 @@ qcow2_co_preadv_task(BlockDriverState *bs, QCow2SubclusterType subc_type,
    g_assert_not_reached();
 }

-/*
- * This function can count as GRAPH_RDLOCK because qcow2_co_preadv_part() holds
- * the graph lock and keeps it until this coroutine has terminated.
- */
-static int coroutine_fn GRAPH_RDLOCK qcow2_co_preadv_task_entry(AioTask *task)
+static coroutine_fn int qcow2_co_preadv_task_entry(AioTask *task)
 {
    Qcow2AioTask *t = container_of(task, Qcow2AioTask, task);

@@ -2329,10 +2325,11 @@ static int coroutine_fn GRAPH_RDLOCK qcow2_co_preadv_task_entry(AioTask *task)
                                t->qiov, t->qiov_offset);
 }

-static int coroutine_fn GRAPH_RDLOCK
-qcow2_co_preadv_part(BlockDriverState *bs, int64_t offset, int64_t bytes,
-                     QEMUIOVector *qiov, size_t qiov_offset,
-                     BdrvRequestFlags flags)
+static coroutine_fn int qcow2_co_preadv_part(BlockDriverState *bs,
+                                             int64_t offset, int64_t bytes,
+                                             QEMUIOVector *qiov,
+                                             size_t qiov_offset,
+                                             BdrvRequestFlags flags)
 {
    BDRVQcow2State *s = bs->opaque;
    int ret = 0;
@@ -2452,8 +2449,7 @@ static bool merge_cow(uint64_t offset, unsigned bytes,
 * Return 1 if the COW regions read as zeroes, 0 if not, < 0 on error.
 * Note that returning 0 does not guarantee non-zero data.
 */
-static int coroutine_fn GRAPH_RDLOCK
-is_zero_cow(BlockDriverState *bs, QCowL2Meta *m)
+static int coroutine_fn is_zero_cow(BlockDriverState *bs, QCowL2Meta *m)
 {
    /*
     * This check is designed for optimization shortcut so it must be
@@ -2471,8 +2467,8 @@ is_zero_cow(BlockDriverState *bs, QCowL2Meta *m)
                                m->cow_end.nb_bytes);
 }

-static int coroutine_fn GRAPH_RDLOCK
-handle_alloc_space(BlockDriverState *bs, QCowL2Meta *l2meta)
+static int coroutine_fn handle_alloc_space(BlockDriverState *bs,
+                                           QCowL2Meta *l2meta)
 {
    BDRVQcow2State *s = bs->opaque;
    QCowL2Meta *m;
@@ -2535,10 +2531,12 @@ handle_alloc_space(BlockDriverState *bs, QCowL2Meta *l2meta)
 * l2meta  - if not NULL, qcow2_co_pwritev_task() will consume it. Caller must
 *           not use it somehow after qcow2_co_pwritev_task() call
 */
-static coroutine_fn GRAPH_RDLOCK
-int qcow2_co_pwritev_task(BlockDriverState *bs, uint64_t host_offset,
-                          uint64_t offset, uint64_t bytes, QEMUIOVector *qiov,
-                          uint64_t qiov_offset, QCowL2Meta *l2meta)
+static coroutine_fn int qcow2_co_pwritev_task(BlockDriverState *bs,
+                                              uint64_t host_offset,
+                                              uint64_t offset, uint64_t bytes,
+                                              QEMUIOVector *qiov,
+                                              uint64_t qiov_offset,
+                                              QCowL2Meta *l2meta)
 {
    int ret;
    BDRVQcow2State *s = bs->opaque;
@@ -2604,11 +2602,7 @@ out_locked:
    return ret;
 }

-/*
- * This function can count as GRAPH_RDLOCK because qcow2_co_pwritev_part() holds
- * the graph lock and keeps it until this coroutine has terminated.
- */
-static coroutine_fn GRAPH_RDLOCK int qcow2_co_pwritev_task_entry(AioTask *task)
+static coroutine_fn int qcow2_co_pwritev_task_entry(AioTask *task)
 {
    Qcow2AioTask *t = container_of(task, Qcow2AioTask, task);

@@ -2619,10 +2613,9 @@ static coroutine_fn GRAPH_RDLOCK int qcow2_co_pwritev_task_entry(AioTask *task)
                                 t->l2meta);
 }

-static int coroutine_fn GRAPH_RDLOCK
-qcow2_co_pwritev_part(BlockDriverState *bs, int64_t offset, int64_t bytes,
-                      QEMUIOVector *qiov, size_t qiov_offset,
-                      BdrvRequestFlags flags)
+static coroutine_fn int qcow2_co_pwritev_part(
+        BlockDriverState *bs, int64_t offset, int64_t bytes,
+        QEMUIOVector *qiov, size_t qiov_offset, BdrvRequestFlags flags)
 {
    BDRVQcow2State *s = bs->opaque;
    int offset_in_cluster;
@@ -2777,8 +2770,8 @@ static void qcow2_close(BlockDriverState *bs)
    qcow2_do_close(bs, true);
 }

-static void coroutine_fn GRAPH_RDLOCK
-qcow2_co_invalidate_cache(BlockDriverState *bs, Error **errp)
+static void coroutine_fn qcow2_co_invalidate_cache(BlockDriverState *bs,
+                                                   Error **errp)
 {
    ERRP_GUARD();
    BDRVQcow2State *s = bs->opaque;
@@ -3189,9 +3182,9 @@ static int qcow2_set_up_encryption(BlockDriverState *bs,
 *
 * Returns: 0 on success, -errno on failure.
 */
-static int coroutine_fn GRAPH_RDLOCK
-preallocate_co(BlockDriverState *bs, uint64_t offset, uint64_t new_length,
-               PreallocMode mode, Error **errp)
+static int coroutine_fn preallocate_co(BlockDriverState *bs, uint64_t offset,
+                                       uint64_t new_length, PreallocMode mode,
+                                       Error **errp)
 {
    BDRVQcow2State *s = bs->opaque;
    uint64_t bytes;
@@ -3461,7 +3454,7 @@ qcow2_co_create(BlockdevCreateOptions *create_options, Error **errp)
    assert(create_options->driver == BLOCKDEV_DRIVER_QCOW2);
    qcow2_opts = &create_options->u.qcow2;

-    bs = bdrv_co_open_blockdev_ref(qcow2_opts->file, errp);
+    bs = bdrv_open_blockdev_ref(qcow2_opts->file, errp);
    if (bs == NULL) {
        return -EIO;
    }
@@ -3603,7 +3596,7 @@ qcow2_co_create(BlockdevCreateOptions *create_options, Error **errp)
            ret = -EINVAL;
            goto out;
        }
-        data_bs = bdrv_co_open_blockdev_ref(qcow2_opts->data_file, errp);
+        data_bs = bdrv_open_blockdev_ref(qcow2_opts->data_file, errp);
        if (data_bs == NULL) {
            ret = -EIO;
            goto out;
@@ -3636,8 +3629,8 @@ qcow2_co_create(BlockdevCreateOptions *create_options, Error **errp)
    }

    /* Create BlockBackend to write to the image */
-    blk = blk_co_new_with_bs(bs, BLK_PERM_WRITE | BLK_PERM_RESIZE, BLK_PERM_ALL,
-                             errp);
+    blk = blk_new_with_bs(bs, BLK_PERM_WRITE | BLK_PERM_RESIZE, BLK_PERM_ALL,
+                          errp);
    if (!blk) {
        ret = -EPERM;
        goto out;
@@ -3719,9 +3712,9 @@ qcow2_co_create(BlockdevCreateOptions *create_options, Error **errp)
    if (data_bs) {
        qdict_put_str(options, "data-file", data_bs->node_name);
    }
-    blk = blk_co_new_open(NULL, NULL, options,
-                          BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_NO_FLUSH,
-                          errp);
+    blk = blk_new_open(NULL, NULL, options,
+                       BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_NO_FLUSH,
+                       errp);
    if (blk == NULL) {
        ret = -EIO;
        goto out;
@@ -3800,9 +3793,9 @@ qcow2_co_create(BlockdevCreateOptions *create_options, Error **errp)
    if (data_bs) {
        qdict_put_str(options, "data-file", data_bs->node_name);
    }
-    blk = blk_co_new_open(NULL, NULL, options,
-                          BDRV_O_RDWR | BDRV_O_NO_BACKING | BDRV_O_NO_IO,
-                          errp);
+    blk = blk_new_open(NULL, NULL, options,
+                       BDRV_O_RDWR | BDRV_O_NO_BACKING | BDRV_O_NO_IO,
+                       errp);
    if (blk == NULL) {
        ret = -EIO;
        goto out;
@@ -3816,9 +3809,10 @@ out:
    return ret;
 }

-static int coroutine_fn GRAPH_RDLOCK
-qcow2_co_create_opts(BlockDriver *drv, const char *filename, QemuOpts *opts,
-                     Error **errp)
+static int coroutine_fn qcow2_co_create_opts(BlockDriver *drv,
+                                             const char *filename,
+                                             QemuOpts *opts,
+                                             Error **errp)
 {
    BlockdevCreateOptions *create_options = NULL;
    QDict *qdict;
@@ -3883,8 +3877,8 @@ qcow2_co_create_opts(BlockDriver *drv, const char *filename, QemuOpts *opts,
        goto finish;
    }

-    bs = bdrv_co_open(filename, NULL, NULL,
-                      BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL, errp);
+    bs = bdrv_open(filename, NULL, NULL,
+                   BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL, errp);
    if (bs == NULL) {
        ret = -EIO;
        goto finish;
@@ -3898,9 +3892,9 @@ qcow2_co_create_opts(BlockDriver *drv, const char *filename, QemuOpts *opts,
            goto finish;
        }

-        data_bs = bdrv_co_open(val, NULL, NULL,
-                               BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL,
-                               errp);
+        data_bs = bdrv_open(val, NULL, NULL,
+                            BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL,
+                            errp);
        if (data_bs == NULL) {
            ret = -EIO;
            goto finish;
@@ -3979,9 +3973,8 @@ static bool is_zero(BlockDriverState *bs, int64_t offset, int64_t bytes)
    return res >= 0 && (res & BDRV_BLOCK_ZERO) && bytes == 0;
 }

-static int coroutine_fn GRAPH_RDLOCK
-qcow2_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset, int64_t bytes,
-                       BdrvRequestFlags flags)
+static coroutine_fn int qcow2_co_pwrite_zeroes(BlockDriverState *bs,
+    int64_t offset, int64_t bytes, BdrvRequestFlags flags)
 {
    int ret;
    BDRVQcow2State *s = bs->opaque;
@@ -4064,7 +4057,7 @@ static coroutine_fn int qcow2_co_pdiscard(BlockDriverState *bs,
    return ret;
 }

-static int coroutine_fn GRAPH_RDLOCK
+static int coroutine_fn
 qcow2_co_copy_range_from(BlockDriverState *bs,
                         BdrvChild *src, int64_t src_offset,
                         BdrvChild *dst, int64_t dst_offset,
@@ -4147,7 +4140,7 @@ out:
    return ret;
 }

-static int coroutine_fn GRAPH_RDLOCK
+static int coroutine_fn
 qcow2_co_copy_range_to(BlockDriverState *bs,
                       BdrvChild *src, int64_t src_offset,
                       BdrvChild *dst, int64_t dst_offset,
@@ -4215,9 +4208,9 @@ fail:
    return ret;
 }

-static int coroutine_fn GRAPH_RDLOCK
-qcow2_co_truncate(BlockDriverState *bs, int64_t offset, bool exact,
-                  PreallocMode prealloc, BdrvRequestFlags flags, Error **errp)
+static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
+                                          bool exact, PreallocMode prealloc,
+                                          BdrvRequestFlags flags, Error **errp)
 {
    BDRVQcow2State *s = bs->opaque;
    uint64_t old_length;
@@ -4591,7 +4584,7 @@ fail:
    return ret;
 }

-static int coroutine_fn GRAPH_RDLOCK
+static coroutine_fn int
 qcow2_co_pwritev_compressed_task(BlockDriverState *bs,
                                 uint64_t offset, uint64_t bytes,
                                 QEMUIOVector *qiov, size_t qiov_offset)
@@ -4655,13 +4648,7 @@ fail:
    return ret;
 }

-/*
- * This function can count as GRAPH_RDLOCK because
- * qcow2_co_pwritev_compressed_part() holds the graph lock and keeps it until
- * this coroutine has terminated.
- */
-static int coroutine_fn GRAPH_RDLOCK
-qcow2_co_pwritev_compressed_task_entry(AioTask *task)
+static coroutine_fn int qcow2_co_pwritev_compressed_task_entry(AioTask *task)
 {
    Qcow2AioTask *t = container_of(task, Qcow2AioTask, task);

@@ -4675,7 +4662,7 @@ qcow2_co_pwritev_compressed_task_entry(AioTask *task)
 * XXX: put compressed sectors first, then all the cluster aligned
 * tables to avoid losing bytes in alignment
 */
-static int coroutine_fn GRAPH_RDLOCK
+static coroutine_fn int
 qcow2_co_pwritev_compressed_part(BlockDriverState *bs,
                                 int64_t offset, int64_t bytes,
                                 QEMUIOVector *qiov, size_t qiov_offset)
@@ -4738,7 +4725,7 @@ qcow2_co_pwritev_compressed_part(BlockDriverState *bs,
    return ret;
 }

-static int coroutine_fn GRAPH_RDLOCK
+static int coroutine_fn
 qcow2_co_preadv_compressed(BlockDriverState *bs,
                           uint64_t l2_entry,
                           uint64_t offset,
@@ -5300,8 +5287,8 @@ static int64_t qcow2_check_vmstate_request(BlockDriverState *bs,
    return pos;
 }

-static int coroutine_fn GRAPH_RDLOCK
-qcow2_co_save_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos)
+static coroutine_fn int qcow2_co_save_vmstate(BlockDriverState *bs,
+                                              QEMUIOVector *qiov, int64_t pos)
 {
    int64_t offset = qcow2_check_vmstate_request(bs, qiov, pos);
    if (offset < 0) {
@@ -5312,8 +5299,8 @@ qcow2_co_save_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos)
    return bs->drv->bdrv_co_pwritev_part(bs, offset, qiov->size, qiov, 0, 0);
 }

-static int coroutine_fn GRAPH_RDLOCK
-qcow2_co_load_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos)
+static coroutine_fn int qcow2_co_load_vmstate(BlockDriverState *bs,
+                                              QEMUIOVector *qiov, int64_t pos)
 {
    int64_t offset = qcow2_check_vmstate_request(bs, qiov, pos);
    if (offset < 0) {
--- a/block/qcow2.h
+++ b/block/qcow2.h
@@ -846,7 +846,7 @@ int qcow2_validate_table(BlockDriverState *bs, uint64_t offset,
                         Error **errp);

 /* qcow2-refcount.c functions */
-int coroutine_fn GRAPH_RDLOCK qcow2_refcount_init(BlockDriverState *bs);
+int coroutine_fn qcow2_refcount_init(BlockDriverState *bs);
 void qcow2_refcount_close(BlockDriverState *bs);

 int qcow2_get_refcount(BlockDriverState *bs, int64_t cluster_index,
@@ -893,17 +893,14 @@ int qcow2_inc_refcounts_imrt(BlockDriverState *bs, BdrvCheckResult *res,
 int qcow2_change_refcount_order(BlockDriverState *bs, int refcount_order,
                                BlockDriverAmendStatusCB *status_cb,
                                void *cb_opaque, Error **errp);
-int coroutine_fn GRAPH_RDLOCK qcow2_shrink_reftable(BlockDriverState *bs);
+int coroutine_fn qcow2_shrink_reftable(BlockDriverState *bs);
 int64_t qcow2_get_last_cluster(BlockDriverState *bs, int64_t size);
 int coroutine_fn qcow2_detect_metadata_preallocation(BlockDriverState *bs);

 /* qcow2-cluster.c functions */
 int qcow2_grow_l1_table(BlockDriverState *bs, uint64_t min_size,
                        bool exact_size);
-
-int coroutine_fn GRAPH_RDLOCK
-qcow2_shrink_l1_table(BlockDriverState *bs, uint64_t max_size);
-
+int coroutine_fn qcow2_shrink_l1_table(BlockDriverState *bs, uint64_t max_size);
 int qcow2_write_l1_entry(BlockDriverState *bs, int l1_index);
 int qcow2_encrypt_sectors(BDRVQcow2State *s, int64_t sector_num,
                          uint8_t *buf, int nb_sectors, bool enc, Error **errp);
@@ -921,17 +918,14 @@ int coroutine_fn qcow2_alloc_compressed_cluster_offset(BlockDriverState *bs,
 void qcow2_parse_compressed_l2_entry(BlockDriverState *bs, uint64_t l2_entry,
                                     uint64_t *coffset, int *csize);

-int coroutine_fn GRAPH_RDLOCK
-qcow2_alloc_cluster_link_l2(BlockDriverState *bs, QCowL2Meta *m);
-
+int coroutine_fn qcow2_alloc_cluster_link_l2(BlockDriverState *bs,
+                                             QCowL2Meta *m);
 void qcow2_alloc_cluster_abort(BlockDriverState *bs, QCowL2Meta *m);
 int qcow2_cluster_discard(BlockDriverState *bs, uint64_t offset,
                          uint64_t bytes, enum qcow2_discard_type type,
                          bool full_discard);
-
-int coroutine_fn GRAPH_RDLOCK
-qcow2_subcluster_zeroize(BlockDriverState *bs, uint64_t offset, uint64_t bytes,
-                         int flags);
+int coroutine_fn qcow2_subcluster_zeroize(BlockDriverState *bs, uint64_t offset,
+                                          uint64_t bytes, int flags);

 int qcow2_expand_zero_clusters(BlockDriverState *bs,
                               BlockDriverAmendStatusCB *status_cb,
@@ -954,10 +948,9 @@ void qcow2_free_snapshots(BlockDriverState *bs);
 int qcow2_read_snapshots(BlockDriverState *bs, Error **errp);
 int qcow2_write_snapshots(BlockDriverState *bs);

-int coroutine_fn GRAPH_RDLOCK
-qcow2_check_read_snapshot_table(BlockDriverState *bs, BdrvCheckResult *result,
-                                BdrvCheckMode fix);
-
+int coroutine_fn qcow2_check_read_snapshot_table(BlockDriverState *bs,
+                                                 BdrvCheckResult *result,
+                                                 BdrvCheckMode fix);
 int coroutine_fn qcow2_check_fix_snapshot_table(BlockDriverState *bs,
                                                BdrvCheckResult *result,
                                                BdrvCheckMode fix);
--- a/block/qed-check.c
+++ b/block/qed-check.c
@@ -107,8 +107,7 @@ static unsigned int qed_check_l2_table(QEDCheck *check, QEDTable *table)
 /**
 * Descend tables and check each cluster is referenced once only
 */
-static int coroutine_fn GRAPH_RDLOCK
-qed_check_l1_table(QEDCheck *check, QEDTable *table)
+static int coroutine_fn qed_check_l1_table(QEDCheck *check, QEDTable *table)
 {
    BDRVQEDState *s = check->s;
    unsigned int i, num_invalid_l1 = 0;
--- a/block/qed-table.c
+++ b/block/qed-table.c
@@ -21,8 +21,8 @@
 #include "qemu/memalign.h"

 /* Called with table_lock held.  */
-static int coroutine_fn GRAPH_RDLOCK
-qed_read_table(BDRVQEDState *s, uint64_t offset, QEDTable *table)
+static int coroutine_fn qed_read_table(BDRVQEDState *s, uint64_t offset,
+                                       QEDTable *table)
 {
    unsigned int bytes = s->header.cluster_size * s->header.table_size;

@@ -63,9 +63,9 @@ out:
 *
 * Called with table_lock held.
 */
-static int coroutine_fn GRAPH_RDLOCK
-qed_write_table(BDRVQEDState *s, uint64_t offset, QEDTable *table,
-                unsigned int index, unsigned int n, bool flush)
+static int coroutine_fn qed_write_table(BDRVQEDState *s, uint64_t offset,
+                                        QEDTable *table, unsigned int index,
+                                        unsigned int n, bool flush)
 {
    unsigned int sector_mask = BDRV_SECTOR_SIZE / sizeof(uint64_t) - 1;
    unsigned int start, end, i;
--- a/block/qed.c
+++ b/block/qed.c
@@ -100,7 +100,7 @@ int qed_write_header_sync(BDRVQEDState *s)
 *
 * No new allocating reqs can start while this function runs.
 */
-static int coroutine_fn GRAPH_RDLOCK qed_write_header(BDRVQEDState *s)
+static int coroutine_fn qed_write_header(BDRVQEDState *s)
 {
    /* We must write full sectors for O_DIRECT but cannot necessarily generate
     * the data following the header if an unrecognized compat feature is
@@ -282,12 +282,11 @@ static void coroutine_fn qed_unplug_allocating_write_reqs(BDRVQEDState *s)
    qemu_co_mutex_unlock(&s->table_lock);
 }

-static void coroutine_fn GRAPH_RDLOCK qed_need_check_timer(BDRVQEDState *s)
+static void coroutine_fn qed_need_check_timer(BDRVQEDState *s)
 {
    int ret;

    trace_qed_need_check_timer_cb(s);
-    assert_bdrv_graph_readable();

    if (!qed_plug_allocating_write_reqs(s)) {
        return;
@@ -313,7 +312,6 @@ static void coroutine_fn GRAPH_RDLOCK qed_need_check_timer(BDRVQEDState *s)
 static void coroutine_fn qed_need_check_timer_entry(void *opaque)
 {
    BDRVQEDState *s = opaque;
-    GRAPH_RDLOCK_GUARD();

    qed_need_check_timer(opaque);
    bdrv_dec_in_flight(s->bs);
@@ -395,8 +393,8 @@ static void bdrv_qed_init_state(BlockDriverState *bs)
 }

 /* Called with table_lock held.  */
-static int coroutine_fn GRAPH_RDLOCK
-bdrv_qed_do_open(BlockDriverState *bs, QDict *options, int flags, Error **errp)
+static int coroutine_fn bdrv_qed_do_open(BlockDriverState *bs, QDict *options,
+                                         int flags, Error **errp)
 {
    BDRVQEDState *s = bs->opaque;
    QEDHeader le_header;
@@ -557,7 +555,7 @@ typedef struct QEDOpenCo {
    int ret;
 } QEDOpenCo;

-static void coroutine_fn GRAPH_RDLOCK bdrv_qed_open_entry(void *opaque)
+static void coroutine_fn bdrv_qed_open_entry(void *opaque)
 {
    QEDOpenCo *qoc = opaque;
    BDRVQEDState *s = qoc->bs->opaque;
@@ -579,8 +577,6 @@ static int bdrv_qed_open(BlockDriverState *bs, QDict *options, int flags,
    };
    int ret;

-    assume_graph_lock(); /* FIXME */
-
    ret = bdrv_open_file_child(NULL, options, "file", bs, errp);
    if (ret < 0) {
        return ret;
@@ -680,13 +676,13 @@ static int coroutine_fn bdrv_qed_co_create(BlockdevCreateOptions *opts,
    }

    /* Create BlockBackend to write to the image */
-    bs = bdrv_co_open_blockdev_ref(qed_opts->file, errp);
+    bs = bdrv_open_blockdev_ref(qed_opts->file, errp);
    if (bs == NULL) {
        return -EIO;
    }

-    blk = blk_co_new_with_bs(bs, BLK_PERM_WRITE | BLK_PERM_RESIZE, BLK_PERM_ALL,
-                             errp);
+    blk = blk_new_with_bs(bs, BLK_PERM_WRITE | BLK_PERM_RESIZE, BLK_PERM_ALL,
+                          errp);
    if (!blk) {
        ret = -EPERM;
        goto out;
@@ -754,9 +750,10 @@ out:
    return ret;
 }

-static int coroutine_fn GRAPH_RDLOCK
-bdrv_qed_co_create_opts(BlockDriver *drv, const char *filename,
-                        QemuOpts *opts, Error **errp)
+static int coroutine_fn bdrv_qed_co_create_opts(BlockDriver *drv,
+                                                const char *filename,
+                                                QemuOpts *opts,
+                                                Error **errp)
 {
    BlockdevCreateOptions *create_options = NULL;
    QDict *qdict;
@@ -786,8 +783,8 @@ bdrv_qed_co_create_opts(BlockDriver *drv, const char *filename,
        goto fail;
    }

-    bs = bdrv_co_open(filename, NULL, NULL,
-                      BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL, errp);
+    bs = bdrv_open(filename, NULL, NULL,
+                   BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL, errp);
    if (bs == NULL) {
        ret = -EIO;
        goto fail;
@@ -825,10 +822,11 @@ fail:
    return ret;
 }

-static int coroutine_fn GRAPH_RDLOCK
-bdrv_qed_co_block_status(BlockDriverState *bs, bool want_zero, int64_t pos,
-                         int64_t bytes, int64_t *pnum, int64_t *map,
-                         BlockDriverState **file)
+static int coroutine_fn bdrv_qed_co_block_status(BlockDriverState *bs,
+                                                 bool want_zero,
+                                                 int64_t pos, int64_t bytes,
+                                                 int64_t *pnum, int64_t *map,
+                                                 BlockDriverState **file)
 {
    BDRVQEDState *s = bs->opaque;
    size_t len = MIN(bytes, SIZE_MAX);
@@ -881,8 +879,8 @@ static BDRVQEDState *acb_to_s(QEDAIOCB *acb)
 * This function reads qiov->size bytes starting at pos from the backing file.
 * If there is no backing file then zeroes are read.
 */
-static int coroutine_fn GRAPH_RDLOCK
-qed_read_backing_file(BDRVQEDState *s, uint64_t pos, QEMUIOVector *qiov)
+static int coroutine_fn qed_read_backing_file(BDRVQEDState *s, uint64_t pos,
+                                              QEMUIOVector *qiov)
 {
    if (s->bs->backing) {
        BLKDBG_EVENT(s->bs->file, BLKDBG_READ_BACKING_AIO);
@@ -900,9 +898,9 @@ qed_read_backing_file(BDRVQEDState *s, uint64_t pos, QEMUIOVector *qiov)
 * @len:        Number of bytes
 * @offset:     Byte offset in image file
 */
-static int coroutine_fn GRAPH_RDLOCK
-qed_copy_from_backing_file(BDRVQEDState *s, uint64_t pos, uint64_t len,
-                           uint64_t offset)
+static int coroutine_fn qed_copy_from_backing_file(BDRVQEDState *s,
+                                                   uint64_t pos, uint64_t len,
+                                                   uint64_t offset)
 {
    QEMUIOVector qiov;
    int ret;
@@ -995,7 +993,7 @@ static void coroutine_fn qed_aio_complete(QEDAIOCB *acb)
 *
 * Called with table_lock held.
 */
-static int coroutine_fn GRAPH_RDLOCK qed_aio_write_l1_update(QEDAIOCB *acb)
+static int coroutine_fn qed_aio_write_l1_update(QEDAIOCB *acb)
 {
    BDRVQEDState *s = acb_to_s(acb);
    CachedL2Table *l2_table = acb->request.l2_table;
@@ -1025,8 +1023,7 @@ static int coroutine_fn GRAPH_RDLOCK qed_aio_write_l1_update(QEDAIOCB *acb)
 *
 * Called with table_lock held.
 */
-static int coroutine_fn GRAPH_RDLOCK
-qed_aio_write_l2_update(QEDAIOCB *acb, uint64_t offset)
+static int coroutine_fn qed_aio_write_l2_update(QEDAIOCB *acb, uint64_t offset)
 {
    BDRVQEDState *s = acb_to_s(acb);
    bool need_alloc = acb->find_cluster_ret == QED_CLUSTER_L1;
@@ -1064,7 +1061,7 @@ qed_aio_write_l2_update(QEDAIOCB *acb, uint64_t offset)
 *
 * Called with table_lock *not* held.
 */
-static int coroutine_fn GRAPH_RDLOCK qed_aio_write_main(QEDAIOCB *acb)
+static int coroutine_fn qed_aio_write_main(QEDAIOCB *acb)
 {
    BDRVQEDState *s = acb_to_s(acb);
    uint64_t offset = acb->cur_cluster +
@@ -1082,7 +1079,7 @@ static int coroutine_fn GRAPH_RDLOCK qed_aio_write_main(QEDAIOCB *acb)
 *
 * Called with table_lock held.
 */
-static int coroutine_fn GRAPH_RDLOCK qed_aio_write_cow(QEDAIOCB *acb)
+static int coroutine_fn qed_aio_write_cow(QEDAIOCB *acb)
 {
    BDRVQEDState *s = acb_to_s(acb);
    uint64_t start, len, offset;
@@ -1160,8 +1157,7 @@ static bool qed_should_set_need_check(BDRVQEDState *s)
 *
 * Called with table_lock held.
 */
-static int coroutine_fn GRAPH_RDLOCK
-qed_aio_write_alloc(QEDAIOCB *acb, size_t len)
+static int coroutine_fn qed_aio_write_alloc(QEDAIOCB *acb, size_t len)
 {
    BDRVQEDState *s = acb_to_s(acb);
    int ret;
@@ -1224,8 +1220,8 @@ qed_aio_write_alloc(QEDAIOCB *acb, size_t len)
 *
 * Called with table_lock held.
 */
-static int coroutine_fn GRAPH_RDLOCK
-qed_aio_write_inplace(QEDAIOCB *acb, uint64_t offset, size_t len)
+static int coroutine_fn qed_aio_write_inplace(QEDAIOCB *acb, uint64_t offset,
+                                              size_t len)
 {
    BDRVQEDState *s = acb_to_s(acb);
    int r;
@@ -1267,8 +1263,8 @@ out:
 *
 * Called with table_lock held.
 */
-static int coroutine_fn GRAPH_RDLOCK
-qed_aio_write_data(void *opaque, int ret, uint64_t offset, size_t len)
+static int coroutine_fn qed_aio_write_data(void *opaque, int ret,
+                                           uint64_t offset, size_t len)
 {
    QEDAIOCB *acb = opaque;

@@ -1300,8 +1296,8 @@ qed_aio_write_data(void *opaque, int ret, uint64_t offset, size_t len)
 *
 * Called with table_lock held.
 */
-static int coroutine_fn GRAPH_RDLOCK
-qed_aio_read_data(void *opaque, int ret, uint64_t offset, size_t len)
+static int coroutine_fn qed_aio_read_data(void *opaque, int ret,
+                                          uint64_t offset, size_t len)
 {
    QEDAIOCB *acb = opaque;
    BDRVQEDState *s = acb_to_s(acb);
@@ -1338,7 +1334,7 @@ qed_aio_read_data(void *opaque, int ret, uint64_t offset, size_t len)
 /**
 * Begin next I/O or complete the request
 */
-static int coroutine_fn GRAPH_RDLOCK qed_aio_next_io(QEDAIOCB *acb)
+static int coroutine_fn qed_aio_next_io(QEDAIOCB *acb)
 {
    BDRVQEDState *s = acb_to_s(acb);
    uint64_t offset;
@@ -1383,9 +1379,9 @@ static int coroutine_fn GRAPH_RDLOCK qed_aio_next_io(QEDAIOCB *acb)
    return ret;
 }

-static int coroutine_fn GRAPH_RDLOCK
-qed_co_request(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov,
-               int nb_sectors, int flags)
+static int coroutine_fn qed_co_request(BlockDriverState *bs, int64_t sector_num,
+                                       QEMUIOVector *qiov, int nb_sectors,
+                                       int flags)
 {
    QEDAIOCB acb = {
        .bs         = bs,
@@ -1402,23 +1398,24 @@ qed_co_request(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov,
    return qed_aio_next_io(&acb);
 }

-static int coroutine_fn GRAPH_RDLOCK
-bdrv_qed_co_readv(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
-                  QEMUIOVector *qiov)
+static int coroutine_fn bdrv_qed_co_readv(BlockDriverState *bs,
+                                          int64_t sector_num, int nb_sectors,
+                                          QEMUIOVector *qiov)
 {
    return qed_co_request(bs, sector_num, qiov, nb_sectors, 0);
 }

-static int coroutine_fn GRAPH_RDLOCK
-bdrv_qed_co_writev(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
-                   QEMUIOVector *qiov, int flags)
+static int coroutine_fn bdrv_qed_co_writev(BlockDriverState *bs,
+                                           int64_t sector_num, int nb_sectors,
+                                           QEMUIOVector *qiov, int flags)
 {
    return qed_co_request(bs, sector_num, qiov, nb_sectors, QED_AIOCB_WRITE);
 }

-static int coroutine_fn GRAPH_RDLOCK
-bdrv_qed_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset, int64_t bytes,
-                          BdrvRequestFlags flags)
+static int coroutine_fn bdrv_qed_co_pwrite_zeroes(BlockDriverState *bs,
+                                                  int64_t offset,
+                                                  int64_t bytes,
+                                                  BdrvRequestFlags flags)
 {
    BDRVQEDState *s = bs->opaque;

@@ -1572,8 +1569,8 @@ static int bdrv_qed_change_backing_file(BlockDriverState *bs,
    return ret;
 }

-static void coroutine_fn GRAPH_RDLOCK
-bdrv_qed_co_invalidate_cache(BlockDriverState *bs, Error **errp)
+static void coroutine_fn bdrv_qed_co_invalidate_cache(BlockDriverState *bs,
+                                                      Error **errp)
 {
    BDRVQEDState *s = bs->opaque;
    int ret;
@@ -1589,9 +1586,9 @@ bdrv_qed_co_invalidate_cache(BlockDriverState *bs, Error **errp)
    }
 }

-static int coroutine_fn GRAPH_RDLOCK
-bdrv_qed_co_check(BlockDriverState *bs, BdrvCheckResult *result,
-                  BdrvCheckMode fix)
+static int coroutine_fn bdrv_qed_co_check(BlockDriverState *bs,
+                                          BdrvCheckResult *result,
+                                          BdrvCheckMode fix)
 {
    BDRVQEDState *s = bs->opaque;
    int ret;
--- a/block/qed.h
+++ b/block/qed.h
@@ -200,40 +200,33 @@ void qed_commit_l2_cache_entry(L2TableCache *l2_cache, CachedL2Table *l2_table);
 /**
 * Table I/O functions
 */
-int coroutine_fn GRAPH_RDLOCK qed_read_l1_table_sync(BDRVQEDState *s);
-
-int coroutine_fn GRAPH_RDLOCK
-qed_write_l1_table(BDRVQEDState *s, unsigned int index, unsigned int n);
-
-int coroutine_fn GRAPH_RDLOCK
-qed_write_l1_table_sync(BDRVQEDState *s, unsigned int index, unsigned int n);
-
-int coroutine_fn GRAPH_RDLOCK
-qed_read_l2_table_sync(BDRVQEDState *s, QEDRequest *request, uint64_t offset);
-
-int coroutine_fn GRAPH_RDLOCK
-qed_read_l2_table(BDRVQEDState *s, QEDRequest *request, uint64_t offset);
-
-int coroutine_fn GRAPH_RDLOCK
-qed_write_l2_table(BDRVQEDState *s, QEDRequest *request, unsigned int index,
-                   unsigned int n, bool flush);
-
-int coroutine_fn GRAPH_RDLOCK
-qed_write_l2_table_sync(BDRVQEDState *s, QEDRequest *request,
-                        unsigned int index, unsigned int n, bool flush);
+int coroutine_fn qed_read_l1_table_sync(BDRVQEDState *s);
+int coroutine_fn qed_write_l1_table(BDRVQEDState *s, unsigned int index,
+                                    unsigned int n);
+int coroutine_fn qed_write_l1_table_sync(BDRVQEDState *s, unsigned int index,
+                                         unsigned int n);
+int coroutine_fn qed_read_l2_table_sync(BDRVQEDState *s, QEDRequest *request,
+                                        uint64_t offset);
+int coroutine_fn qed_read_l2_table(BDRVQEDState *s, QEDRequest *request,
+                                   uint64_t offset);
+int coroutine_fn qed_write_l2_table(BDRVQEDState *s, QEDRequest *request,
+                                    unsigned int index, unsigned int n,
+                                    bool flush);
+int coroutine_fn qed_write_l2_table_sync(BDRVQEDState *s, QEDRequest *request,
+                                         unsigned int index, unsigned int n,
+                                         bool flush);

 /**
 * Cluster functions
 */
-int coroutine_fn GRAPH_RDLOCK
-qed_find_cluster(BDRVQEDState *s, QEDRequest *request, uint64_t pos,
-                 size_t *len, uint64_t *img_offset);
+int coroutine_fn qed_find_cluster(BDRVQEDState *s, QEDRequest *request,
+                                  uint64_t pos, size_t *len,
+                                  uint64_t *img_offset);

 /**
 * Consistency check
 */
-int coroutine_fn GRAPH_RDLOCK
-qed_check(BDRVQEDState *s, BdrvCheckResult *result, bool fix);
+int coroutine_fn qed_check(BDRVQEDState *s, BdrvCheckResult *result, bool fix);

 QEDTable *qed_alloc_table(BDRVQEDState *s);

--- a/block/quorum.c
+++ b/block/quorum.c
@@ -270,11 +270,7 @@ static void quorum_report_bad_versions(BDRVQuorumState *s,
    }
 }

-/*
- * This function can count as GRAPH_RDLOCK because read_quorum_children() holds
- * the graph lock and keeps it until this coroutine has terminated.
- */
-static void coroutine_fn GRAPH_RDLOCK quorum_rewrite_entry(void *opaque)
+static void coroutine_fn quorum_rewrite_entry(void *opaque)
 {
    QuorumCo *co = opaque;
    QuorumAIOCB *acb = co->acb;
@@ -294,8 +290,8 @@ static void coroutine_fn GRAPH_RDLOCK quorum_rewrite_entry(void *opaque)
    }
 }

-static bool coroutine_fn GRAPH_RDLOCK
-quorum_rewrite_bad_versions(QuorumAIOCB *acb, QuorumVoteValue *value)
+static bool quorum_rewrite_bad_versions(QuorumAIOCB *acb,
+                                        QuorumVoteValue *value)
 {
    QuorumVoteVersion *version;
    QuorumVoteItem *item;
@@ -495,7 +491,7 @@ static int quorum_vote_error(QuorumAIOCB *acb)
    return ret;
 }

-static void coroutine_fn GRAPH_RDLOCK quorum_vote(QuorumAIOCB *acb)
+static void quorum_vote(QuorumAIOCB *acb)
 {
    bool quorum = true;
    int i, j, ret;
@@ -575,11 +571,7 @@ free_exit:
    quorum_free_vote_list(&acb->votes);
 }

-/*
- * This function can count as GRAPH_RDLOCK because read_quorum_children() holds
- * the graph lock and keeps it until this coroutine has terminated.
- */
-static void coroutine_fn GRAPH_RDLOCK read_quorum_children_entry(void *opaque)
+static void coroutine_fn read_quorum_children_entry(void *opaque)
 {
    QuorumCo *co = opaque;
    QuorumAIOCB *acb = co->acb;
@@ -607,7 +599,7 @@ static void coroutine_fn GRAPH_RDLOCK read_quorum_children_entry(void *opaque)
    }
 }

-static int coroutine_fn GRAPH_RDLOCK read_quorum_children(QuorumAIOCB *acb)
+static int coroutine_fn read_quorum_children(QuorumAIOCB *acb)
 {
    BDRVQuorumState *s = acb->bs->opaque;
    int i;
@@ -648,7 +640,7 @@ static int coroutine_fn GRAPH_RDLOCK read_quorum_children(QuorumAIOCB *acb)
    return acb->vote_ret;
 }

-static int coroutine_fn GRAPH_RDLOCK read_fifo_child(QuorumAIOCB *acb)
+static int coroutine_fn read_fifo_child(QuorumAIOCB *acb)
 {
    BDRVQuorumState *s = acb->bs->opaque;
    int n, ret;
@@ -669,9 +661,10 @@ static int coroutine_fn GRAPH_RDLOCK read_fifo_child(QuorumAIOCB *acb)
    return ret;
 }

-static int coroutine_fn GRAPH_RDLOCK
-quorum_co_preadv(BlockDriverState *bs, int64_t offset, int64_t bytes,
-                 QEMUIOVector *qiov, BdrvRequestFlags flags)
+static int coroutine_fn quorum_co_preadv(BlockDriverState *bs,
+                                         int64_t offset, int64_t bytes,
+                                         QEMUIOVector *qiov,
+                                         BdrvRequestFlags flags)
 {
    BDRVQuorumState *s = bs->opaque;
    QuorumAIOCB *acb = quorum_aio_get(bs, qiov, offset, bytes, flags);
@@ -690,11 +683,7 @@ quorum_co_preadv(BlockDriverState *bs, int64_t offset, int64_t bytes,
    return ret;
 }

-/*
- * This function can count as GRAPH_RDLOCK because quorum_co_pwritev() holds the
- * graph lock and keeps it until this coroutine has terminated.
- */
-static void coroutine_fn GRAPH_RDLOCK write_quorum_entry(void *opaque)
+static void coroutine_fn write_quorum_entry(void *opaque)
 {
    QuorumCo *co = opaque;
    QuorumAIOCB *acb = co->acb;
@@ -725,9 +714,9 @@ static void coroutine_fn GRAPH_RDLOCK write_quorum_entry(void *opaque)
    }
 }

-static int coroutine_fn GRAPH_RDLOCK
-quorum_co_pwritev(BlockDriverState *bs, int64_t offset, int64_t bytes,
-                  QEMUIOVector *qiov, BdrvRequestFlags flags)
+static int coroutine_fn quorum_co_pwritev(BlockDriverState *bs, int64_t offset,
+                                          int64_t bytes, QEMUIOVector *qiov,
+                                          BdrvRequestFlags flags)
 {
    BDRVQuorumState *s = bs->opaque;
    QuorumAIOCB *acb = quorum_aio_get(bs, qiov, offset, bytes, flags);
@@ -756,16 +745,16 @@ quorum_co_pwritev(BlockDriverState *bs, int64_t offset, int64_t bytes,
    return ret;
 }

-static int coroutine_fn GRAPH_RDLOCK
-quorum_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset, int64_t bytes,
-                        BdrvRequestFlags flags)
+static int coroutine_fn quorum_co_pwrite_zeroes(BlockDriverState *bs,
+                                                int64_t offset, int64_t bytes,
+                                                BdrvRequestFlags flags)
+
 {
    return quorum_co_pwritev(bs, offset, bytes, NULL,
                             flags | BDRV_REQ_ZERO_WRITE);
 }

-static int64_t coroutine_fn GRAPH_RDLOCK
-quorum_co_getlength(BlockDriverState *bs)
+static int64_t coroutine_fn quorum_co_getlength(BlockDriverState *bs)
 {
    BDRVQuorumState *s = bs->opaque;
    int64_t result;
@@ -789,7 +778,7 @@ quorum_co_getlength(BlockDriverState *bs)
    return result;
 }

-static coroutine_fn GRAPH_RDLOCK int quorum_co_flush(BlockDriverState *bs)
+static coroutine_fn int quorum_co_flush(BlockDriverState *bs)
 {
    BDRVQuorumState *s = bs->opaque;
    QuorumVoteVersion *winner = NULL;
@@ -1228,10 +1217,11 @@ static void quorum_child_perm(BlockDriverState *bs, BdrvChild *c,
 * return BDRV_BLOCK_ZERO if *all* children agree that a certain
 * region contains zeroes, and BDRV_BLOCK_DATA otherwise.
 */
-static int coroutine_fn GRAPH_RDLOCK
-quorum_co_block_status(BlockDriverState *bs, bool want_zero,
-                       int64_t offset, int64_t count,
-                       int64_t *pnum, int64_t *map, BlockDriverState **file)
+static int coroutine_fn quorum_co_block_status(BlockDriverState *bs,
+                                               bool want_zero,
+                                               int64_t offset, int64_t count,
+                                               int64_t *pnum, int64_t *map,
+                                               BlockDriverState **file)
 {
    BDRVQuorumState *s = bs->opaque;
    int i, ret;
--- a/block/raw-format.c
+++ b/block/raw-format.c
@@ -203,9 +203,9 @@ static inline int raw_adjust_offset(BlockDriverState *bs, int64_t *offset,
    return 0;
 }

-static int coroutine_fn GRAPH_RDLOCK
-raw_co_preadv(BlockDriverState *bs, int64_t offset, int64_t bytes,
-              QEMUIOVector *qiov, BdrvRequestFlags flags)
+static int coroutine_fn raw_co_preadv(BlockDriverState *bs, int64_t offset,
+                                      int64_t bytes, QEMUIOVector *qiov,
+                                      BdrvRequestFlags flags)
 {
    int ret;

@@ -218,9 +218,9 @@ raw_co_preadv(BlockDriverState *bs, int64_t offset, int64_t bytes,
    return bdrv_co_preadv(bs->file, offset, bytes, qiov, flags);
 }

-static int coroutine_fn GRAPH_RDLOCK
-raw_co_pwritev(BlockDriverState *bs, int64_t offset, int64_t bytes,
-               QEMUIOVector *qiov, BdrvRequestFlags flags)
+static int coroutine_fn raw_co_pwritev(BlockDriverState *bs, int64_t offset,
+                                       int64_t bytes, QEMUIOVector *qiov,
+                                       BdrvRequestFlags flags)
 {
    void *buf = NULL;
    BlockDriver *drv;
@@ -292,9 +292,9 @@ static int coroutine_fn raw_co_block_status(BlockDriverState *bs,
    return BDRV_BLOCK_RAW | BDRV_BLOCK_OFFSET_VALID;
 }

-static int coroutine_fn GRAPH_RDLOCK
-raw_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset, int64_t bytes,
-                     BdrvRequestFlags flags)
+static int coroutine_fn raw_co_pwrite_zeroes(BlockDriverState *bs,
+                                             int64_t offset, int64_t bytes,
+                                             BdrvRequestFlags flags)
 {
    int ret;

@@ -305,8 +305,8 @@ raw_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset, int64_t bytes,
    return bdrv_co_pwrite_zeroes(bs->file, offset, bytes, flags);
 }

-static int coroutine_fn GRAPH_RDLOCK
-raw_co_pdiscard(BlockDriverState *bs, int64_t offset, int64_t bytes)
+static int coroutine_fn raw_co_pdiscard(BlockDriverState *bs,
+                                        int64_t offset, int64_t bytes)
 {
    int ret;

@@ -317,8 +317,7 @@ raw_co_pdiscard(BlockDriverState *bs, int64_t offset, int64_t bytes)
    return bdrv_co_pdiscard(bs->file, offset, bytes);
 }

-static int64_t coroutine_fn GRAPH_RDLOCK
-raw_co_getlength(BlockDriverState *bs)
+static int64_t coroutine_fn raw_co_getlength(BlockDriverState *bs)
 {
    int64_t len;
    BDRVRawState *s = bs->opaque;
@@ -385,9 +384,9 @@ static void raw_refresh_limits(BlockDriverState *bs, Error **errp)
    }
 }

-static int coroutine_fn GRAPH_RDLOCK
-raw_co_truncate(BlockDriverState *bs, int64_t offset, bool exact,
-                PreallocMode prealloc, BdrvRequestFlags flags, Error **errp)
+static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,
+                                        bool exact, PreallocMode prealloc,
+                                        BdrvRequestFlags flags, Error **errp)
 {
    BDRVRawState *s = bs->opaque;

@@ -406,20 +405,18 @@ raw_co_truncate(BlockDriverState *bs, int64_t offset, bool exact,
    return bdrv_co_truncate(bs->file, offset, exact, prealloc, flags, errp);
 }

-static void coroutine_fn GRAPH_RDLOCK
-raw_co_eject(BlockDriverState *bs, bool eject_flag)
+static void coroutine_fn raw_co_eject(BlockDriverState *bs, bool eject_flag)
 {
    bdrv_co_eject(bs->file->bs, eject_flag);
 }

-static void coroutine_fn GRAPH_RDLOCK
-raw_co_lock_medium(BlockDriverState *bs, bool locked)
+static void coroutine_fn raw_co_lock_medium(BlockDriverState *bs, bool locked)
 {
    bdrv_co_lock_medium(bs->file->bs, locked);
 }

-static int coroutine_fn GRAPH_RDLOCK
-raw_co_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
+static int coroutine_fn raw_co_ioctl(BlockDriverState *bs,
+                                     unsigned long int req, void *buf)
 {
    BDRVRawState *s = bs->opaque;
    if (s->offset || s->has_size) {
@@ -433,9 +430,10 @@ static int raw_has_zero_init(BlockDriverState *bs)
    return bdrv_has_zero_init(bs->file->bs);
 }

-static int coroutine_fn GRAPH_RDLOCK
-raw_co_create_opts(BlockDriver *drv, const char *filename,
-                   QemuOpts *opts, Error **errp)
+static int coroutine_fn raw_co_create_opts(BlockDriver *drv,
+                                           const char *filename,
+                                           QemuOpts *opts,
+                                           Error **errp)
 {
    return bdrv_co_create_file(filename, opts, errp);
 }
@@ -538,12 +536,14 @@ static int raw_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
    return bdrv_probe_geometry(bs->file->bs, geo);
 }

-static int coroutine_fn GRAPH_RDLOCK
-raw_co_copy_range_from(BlockDriverState *bs,
-                       BdrvChild *src, int64_t src_offset,
-                       BdrvChild *dst, int64_t dst_offset,
-                       int64_t bytes, BdrvRequestFlags read_flags,
-                       BdrvRequestFlags write_flags)
+static int coroutine_fn raw_co_copy_range_from(BlockDriverState *bs,
+                                               BdrvChild *src,
+                                               int64_t src_offset,
+                                               BdrvChild *dst,
+                                               int64_t dst_offset,
+                                               int64_t bytes,
+                                               BdrvRequestFlags read_flags,
+                                               BdrvRequestFlags write_flags)
 {
    int ret;

@@ -555,12 +555,14 @@ raw_co_copy_range_from(BlockDriverState *bs,
                                   bytes, read_flags, write_flags);
 }

-static int coroutine_fn GRAPH_RDLOCK
-raw_co_copy_range_to(BlockDriverState *bs,
-                     BdrvChild *src, int64_t src_offset,
-                     BdrvChild *dst, int64_t dst_offset,
-                     int64_t bytes, BdrvRequestFlags read_flags,
-                     BdrvRequestFlags write_flags)
+static int coroutine_fn raw_co_copy_range_to(BlockDriverState *bs,
+                                             BdrvChild *src,
+                                             int64_t src_offset,
+                                             BdrvChild *dst,
+                                             int64_t dst_offset,
+                                             int64_t bytes,
+                                             BdrvRequestFlags read_flags,
+                                             BdrvRequestFlags write_flags)
 {
    int ret;

--- a/block/rbd.c
+++ b/block/rbd.c
@@ -72,16 +72,6 @@ static const char rbd_luks2_header_verification[
    'L', 'U', 'K', 'S', 0xBA, 0xBE, 0, 2
 };

-static const char rbd_layered_luks_header_verification[
-        RBD_ENCRYPTION_LUKS_HEADER_VERIFICATION_LEN] = {
-    'R', 'B', 'D', 'L', 0xBA, 0xBE, 0, 1
-};
-
-static const char rbd_layered_luks2_header_verification[
-        RBD_ENCRYPTION_LUKS_HEADER_VERIFICATION_LEN] = {
-    'R', 'B', 'D', 'L', 0xBA, 0xBE, 0, 2
-};
-
 typedef enum {
    RBD_AIO_READ,
    RBD_AIO_WRITE,
@@ -396,6 +386,7 @@ static int qemu_rbd_encryption_format(rbd_image_t image,
 {
    int r = 0;
    g_autofree char *passphrase = NULL;
+    size_t passphrase_len;
    rbd_encryption_format_t format;
    rbd_encryption_options_t opts;
    rbd_encryption_luks1_format_options_t luks_opts;
@@ -417,12 +408,12 @@ static int qemu_rbd_encryption_format(rbd_image_t image,
            opts_size = sizeof(luks_opts);
            r = qemu_rbd_convert_luks_create_options(
                    qapi_RbdEncryptionCreateOptionsLUKS_base(&encrypt->u.luks),
-                    &luks_opts.alg, &passphrase, &luks_opts.passphrase_size,
-                    errp);
+                    &luks_opts.alg, &passphrase, &passphrase_len, errp);
            if (r < 0) {
                return r;
            }
            luks_opts.passphrase = passphrase;
+            luks_opts.passphrase_size = passphrase_len;
            break;
        }
        case RBD_IMAGE_ENCRYPTION_FORMAT_LUKS2: {
@@ -433,12 +424,12 @@ static int qemu_rbd_encryption_format(rbd_image_t image,
            r = qemu_rbd_convert_luks_create_options(
                    qapi_RbdEncryptionCreateOptionsLUKS2_base(
                            &encrypt->u.luks2),
-                    &luks2_opts.alg, &passphrase, &luks2_opts.passphrase_size,
-                    errp);
+                    &luks2_opts.alg, &passphrase, &passphrase_len, errp);
            if (r < 0) {
                return r;
            }
            luks2_opts.passphrase = passphrase;
+            luks2_opts.passphrase_size = passphrase_len;
            break;
        }
        default: {
@@ -477,11 +468,9 @@ static int qemu_rbd_encryption_load(rbd_image_t image,
 {
    int r = 0;
    g_autofree char *passphrase = NULL;
+    size_t passphrase_len;
    rbd_encryption_luks1_format_options_t luks_opts;
    rbd_encryption_luks2_format_options_t luks2_opts;
-#ifdef LIBRBD_SUPPORTS_ENCRYPTION_LOAD2
-    rbd_encryption_luks_format_options_t luks_any_opts;
-#endif
    rbd_encryption_format_t format;
    rbd_encryption_options_t opts;
    size_t opts_size;
@@ -494,11 +483,12 @@ static int qemu_rbd_encryption_load(rbd_image_t image,
            opts_size = sizeof(luks_opts);
            r = qemu_rbd_convert_luks_options(
                    qapi_RbdEncryptionOptionsLUKS_base(&encrypt->u.luks),
-                    &passphrase, &luks_opts.passphrase_size, errp);
+                    &passphrase, &passphrase_len, errp);
            if (r < 0) {
                return r;
            }
            luks_opts.passphrase = passphrase;
+            luks_opts.passphrase_size = passphrase_len;
            break;
        }
        case RBD_IMAGE_ENCRYPTION_FORMAT_LUKS2: {
@@ -508,29 +498,14 @@ static int qemu_rbd_encryption_load(rbd_image_t image,
            opts_size = sizeof(luks2_opts);
            r = qemu_rbd_convert_luks_options(
                    qapi_RbdEncryptionOptionsLUKS2_base(&encrypt->u.luks2),
-                    &passphrase, &luks2_opts.passphrase_size, errp);
+                    &passphrase, &passphrase_len, errp);
            if (r < 0) {
                return r;
            }
            luks2_opts.passphrase = passphrase;
+            luks2_opts.passphrase_size = passphrase_len;
            break;
        }
-#ifdef LIBRBD_SUPPORTS_ENCRYPTION_LOAD2
-        case RBD_IMAGE_ENCRYPTION_FORMAT_LUKS_ANY: {
-            memset(&luks_any_opts, 0, sizeof(luks_any_opts));
-            format = RBD_ENCRYPTION_FORMAT_LUKS;
-            opts = &luks_any_opts;
-            opts_size = sizeof(luks_any_opts);
-            r = qemu_rbd_convert_luks_options(
-                    qapi_RbdEncryptionOptionsLUKSAny_base(&encrypt->u.luks_any),
-                    &passphrase, &luks_any_opts.passphrase_size, errp);
-            if (r < 0) {
-                return r;
-            }
-            luks_any_opts.passphrase = passphrase;
-            break;
-        }
-#endif
        default: {
            r = -ENOTSUP;
            error_setg_errno(
@@ -548,128 +523,6 @@ static int qemu_rbd_encryption_load(rbd_image_t image,

    return 0;
 }
-
-#ifdef LIBRBD_SUPPORTS_ENCRYPTION_LOAD2
-static int qemu_rbd_encryption_load2(rbd_image_t image,
-                                     RbdEncryptionOptions *encrypt,
-                                     Error **errp)
-{
-    int r = 0;
-    int encrypt_count = 1;
-    int i;
-    RbdEncryptionOptions *curr_encrypt;
-    rbd_encryption_spec_t *specs;
-    rbd_encryption_luks1_format_options_t *luks_opts;
-    rbd_encryption_luks2_format_options_t *luks2_opts;
-    rbd_encryption_luks_format_options_t *luks_any_opts;
-
-    /* count encryption options */
-    for (curr_encrypt = encrypt->parent; curr_encrypt;
-         curr_encrypt = curr_encrypt->parent) {
-        ++encrypt_count;
-    }
-
-    specs = g_new0(rbd_encryption_spec_t, encrypt_count);
-
-    curr_encrypt = encrypt;
-    for (i = 0; i < encrypt_count; ++i) {
-        switch (curr_encrypt->format) {
-            case RBD_IMAGE_ENCRYPTION_FORMAT_LUKS: {
-                specs[i].format = RBD_ENCRYPTION_FORMAT_LUKS1;
-
-                luks_opts = g_new0(rbd_encryption_luks1_format_options_t, 1);
-                specs[i].opts = luks_opts;
-                specs[i].opts_size = sizeof(*luks_opts);
-
-                r = qemu_rbd_convert_luks_options(
-                        qapi_RbdEncryptionOptionsLUKS_base(
-                                &curr_encrypt->u.luks),
-                        (char **)&luks_opts->passphrase,
-                        &luks_opts->passphrase_size,
-                        errp);
-                break;
-            }
-            case RBD_IMAGE_ENCRYPTION_FORMAT_LUKS2: {
-                specs[i].format = RBD_ENCRYPTION_FORMAT_LUKS2;
-
-                luks2_opts = g_new0(rbd_encryption_luks2_format_options_t, 1);
-                specs[i].opts = luks2_opts;
-                specs[i].opts_size = sizeof(*luks2_opts);
-
-                r = qemu_rbd_convert_luks_options(
-                        qapi_RbdEncryptionOptionsLUKS2_base(
-                                &curr_encrypt->u.luks2),
-                        (char **)&luks2_opts->passphrase,
-                        &luks2_opts->passphrase_size,
-                        errp);
-                break;
-            }
-            case RBD_IMAGE_ENCRYPTION_FORMAT_LUKS_ANY: {
-                specs[i].format = RBD_ENCRYPTION_FORMAT_LUKS;
-
-                luks_any_opts = g_new0(rbd_encryption_luks_format_options_t, 1);
-                specs[i].opts = luks_any_opts;
-                specs[i].opts_size = sizeof(*luks_any_opts);
-
-                r = qemu_rbd_convert_luks_options(
-                        qapi_RbdEncryptionOptionsLUKSAny_base(
-                                &curr_encrypt->u.luks_any),
-                        (char **)&luks_any_opts->passphrase,
-                        &luks_any_opts->passphrase_size,
-                        errp);
-                break;
-            }
-            default: {
-                r = -ENOTSUP;
-                error_setg_errno(
-                        errp, -r, "unknown image encryption format: %u",
-                        curr_encrypt->format);
-            }
-        }
-
-        if (r < 0) {
-            goto exit;
-        }
-
-        curr_encrypt = curr_encrypt->parent;
-    }
-
-    r = rbd_encryption_load2(image, specs, encrypt_count);
-    if (r < 0) {
-        error_setg_errno(errp, -r, "layered encryption load fail");
-        goto exit;
-    }
-
-exit:
-    for (i = 0; i < encrypt_count; ++i) {
-        if (!specs[i].opts) {
-            break;
-        }
-
-        switch (specs[i].format) {
-            case RBD_ENCRYPTION_FORMAT_LUKS1: {
-                luks_opts = specs[i].opts;
-                g_free((void *)luks_opts->passphrase);
-                break;
-            }
-            case RBD_ENCRYPTION_FORMAT_LUKS2: {
-                luks2_opts = specs[i].opts;
-                g_free((void *)luks2_opts->passphrase);
-                break;
-            }
-            case RBD_ENCRYPTION_FORMAT_LUKS: {
-                luks_any_opts = specs[i].opts;
-                g_free((void *)luks_any_opts->passphrase);
-                break;
-            }
-        }
-
-        g_free(specs[i].opts);
-    }
-    g_free(specs);
-    return r;
-}
-#endif
 #endif

 /* FIXME Deprecate and remove keypairs or make it available in QMP. */
@@ -1136,16 +989,7 @@ static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags,

    if (opts->encrypt) {
 #ifdef LIBRBD_SUPPORTS_ENCRYPTION
-        if (opts->encrypt->parent) {
-#ifdef LIBRBD_SUPPORTS_ENCRYPTION_LOAD2
-            r = qemu_rbd_encryption_load2(s->image, opts->encrypt, errp);
-#else
-            r = -ENOTSUP;
-            error_setg(errp, "RBD library does not support layered encryption");
-#endif
-        } else {
-            r = qemu_rbd_encryption_load(s->image, opts->encrypt, errp);
-        }
+        r = qemu_rbd_encryption_load(s->image, opts->encrypt, errp);
        if (r < 0) {
            goto failed_post_open;
        }
@@ -1437,16 +1281,6 @@ static ImageInfoSpecific *qemu_rbd_get_specific_info(BlockDriverState *bs,
        spec_info->u.rbd.data->encryption_format =
                RBD_IMAGE_ENCRYPTION_FORMAT_LUKS2;
        spec_info->u.rbd.data->has_encryption_format = true;
-    } else if (memcmp(buf, rbd_layered_luks_header_verification,
-               RBD_ENCRYPTION_LUKS_HEADER_VERIFICATION_LEN) == 0) {
-        spec_info->u.rbd.data->encryption_format =
-                RBD_IMAGE_ENCRYPTION_FORMAT_LUKS;
-        spec_info->u.rbd.data->has_encryption_format = true;
-    } else if (memcmp(buf, rbd_layered_luks2_header_verification,
-               RBD_ENCRYPTION_LUKS_HEADER_VERIFICATION_LEN) == 0) {
-        spec_info->u.rbd.data->encryption_format =
-                RBD_IMAGE_ENCRYPTION_FORMAT_LUKS2;
-        spec_info->u.rbd.data->has_encryption_format = true;
    } else {
        spec_info->u.rbd.data->has_encryption_format = false;
    }
--- a/block/replication.c
+++ b/block/replication.c
@@ -179,8 +179,7 @@ static void replication_child_perm(BlockDriverState *bs, BdrvChild *c,
    return;
 }

-static int64_t coroutine_fn GRAPH_RDLOCK
-replication_co_getlength(BlockDriverState *bs)
+static int64_t coroutine_fn replication_co_getlength(BlockDriverState *bs)
 {
    return bdrv_co_getlength(bs->file->bs);
 }
@@ -221,9 +220,10 @@ static int replication_return_value(BDRVReplicationState *s, int ret)
    return ret;
 }

-static int coroutine_fn GRAPH_RDLOCK
-replication_co_readv(BlockDriverState *bs, int64_t sector_num,
-                     int remaining_sectors, QEMUIOVector *qiov)
+static coroutine_fn int replication_co_readv(BlockDriverState *bs,
+                                             int64_t sector_num,
+                                             int remaining_sectors,
+                                             QEMUIOVector *qiov)
 {
    BDRVReplicationState *s = bs->opaque;
    int ret;
@@ -244,9 +244,11 @@ replication_co_readv(BlockDriverState *bs, int64_t sector_num,
    return replication_return_value(s, ret);
 }

-static int coroutine_fn GRAPH_RDLOCK
-replication_co_writev(BlockDriverState *bs, int64_t sector_num,
-                      int remaining_sectors, QEMUIOVector *qiov, int flags)
+static coroutine_fn int replication_co_writev(BlockDriverState *bs,
+                                              int64_t sector_num,
+                                              int remaining_sectors,
+                                              QEMUIOVector *qiov,
+                                              int flags)
 {
    BDRVReplicationState *s = bs->opaque;
    QEMUIOVector hd_qiov;
--- a/block/snapshot-access.c
+++ b/block/snapshot-access.c
@@ -26,7 +26,7 @@
 #include "qemu/cutils.h"
 #include "block/block_int.h"

-static int coroutine_fn GRAPH_RDLOCK
+static coroutine_fn int
 snapshot_access_co_preadv_part(BlockDriverState *bs,
                               int64_t offset, int64_t bytes,
                               QEMUIOVector *qiov, size_t qiov_offset,
@@ -39,7 +39,7 @@ snapshot_access_co_preadv_part(BlockDriverState *bs,
    return bdrv_co_preadv_snapshot(bs->file, offset, bytes, qiov, qiov_offset);
 }

-static int coroutine_fn GRAPH_RDLOCK
+static int coroutine_fn
 snapshot_access_co_block_status(BlockDriverState *bs,
                                bool want_zero, int64_t offset,
                                int64_t bytes, int64_t *pnum,
@@ -49,8 +49,8 @@ snapshot_access_co_block_status(BlockDriverState *bs,
                                         bytes, pnum, map, file);
 }

-static int coroutine_fn GRAPH_RDLOCK
-snapshot_access_co_pdiscard(BlockDriverState *bs, int64_t offset, int64_t bytes)
+static int coroutine_fn snapshot_access_co_pdiscard(BlockDriverState *bs,
+                                             int64_t offset, int64_t bytes)
 {
    return bdrv_co_pdiscard_snapshot(bs->file->bs, offset, bytes);
 }
--- a/block/stream.c
+++ b/block/stream.c
@@ -16,6 +16,7 @@
 #include "block/block_int.h"
 #include "block/blockjob_int.h"
 #include "qapi/error.h"
+#include "qapi/qmp/qerror.h"
 #include "qapi/qmp/qdict.h"
 #include "qemu/ratelimit.h"
 #include "sysemu/block-backend.h"
@@ -140,11 +141,9 @@ static int coroutine_fn stream_run(Job *job, Error **errp)
        return 0;
    }

-    WITH_GRAPH_RDLOCK_GUARD() {
-        len = bdrv_co_getlength(s->target_bs);
-        if (len < 0) {
-            return len;
-        }
+    len = bdrv_getlength(s->target_bs);
+    if (len < 0) {
+        return len;
    }
    job_progress_set_remaining(&s->common.job, len);

@@ -162,25 +161,21 @@ static int coroutine_fn stream_run(Job *job, Error **errp)

        copy = false;

-        WITH_GRAPH_RDLOCK_GUARD() {
-            ret = bdrv_is_allocated(unfiltered_bs, offset, STREAM_CHUNK, &n);
-            if (ret == 1) {
-                /* Allocated in the top, no need to copy.  */
-            } else if (ret >= 0) {
-                /*
-                 * Copy if allocated in the intermediate images.  Limit to the
-                 * known-unallocated area [offset, offset+n*BDRV_SECTOR_SIZE).
-                 */
-                ret = bdrv_is_allocated_above(bdrv_cow_bs(unfiltered_bs),
-                                            s->base_overlay, true,
-                                            offset, n, &n);
-                /* Finish early if end of backing file has been reached */
-                if (ret == 0 && n == 0) {
-                    n = len - offset;
-                }
-
-                copy = (ret > 0);
+        ret = bdrv_is_allocated(unfiltered_bs, offset, STREAM_CHUNK, &n);
+        if (ret == 1) {
+            /* Allocated in the top, no need to copy.  */
+        } else if (ret >= 0) {
+            /* Copy if allocated in the intermediate images.  Limit to the
+             * known-unallocated area [offset, offset+n*BDRV_SECTOR_SIZE).  */
+            ret = bdrv_is_allocated_above(bdrv_cow_bs(unfiltered_bs),
+                                          s->base_overlay, true,
+                                          offset, n, &n);
+            /* Finish early if end of backing file has been reached */
+            if (ret == 0 && n == 0) {
+                n = len - offset;
            }
+
+            copy = (ret > 0);
        }
        trace_stream_one_iteration(s, offset, n, ret);
        if (copy) {
--- a/block/throttle.c
+++ b/block/throttle.c
@@ -106,15 +106,15 @@ static void throttle_close(BlockDriverState *bs)
 }


-static int64_t coroutine_fn GRAPH_RDLOCK
-throttle_co_getlength(BlockDriverState *bs)
+static int64_t coroutine_fn throttle_co_getlength(BlockDriverState *bs)
 {
    return bdrv_co_getlength(bs->file->bs);
 }

-static int coroutine_fn GRAPH_RDLOCK
-throttle_co_preadv(BlockDriverState *bs, int64_t offset, int64_t bytes,
-                   QEMUIOVector *qiov, BdrvRequestFlags flags)
+static int coroutine_fn throttle_co_preadv(BlockDriverState *bs,
+                                           int64_t offset, int64_t bytes,
+                                           QEMUIOVector *qiov,
+                                           BdrvRequestFlags flags)
 {

    ThrottleGroupMember *tgm = bs->opaque;
@@ -123,9 +123,10 @@ throttle_co_preadv(BlockDriverState *bs, int64_t offset, int64_t bytes,
    return bdrv_co_preadv(bs->file, offset, bytes, qiov, flags);
 }

-static int coroutine_fn GRAPH_RDLOCK
-throttle_co_pwritev(BlockDriverState *bs, int64_t offset, int64_t bytes,
-                    QEMUIOVector *qiov, BdrvRequestFlags flags)
+static int coroutine_fn throttle_co_pwritev(BlockDriverState *bs,
+                                            int64_t offset, int64_t bytes,
+                                            QEMUIOVector *qiov,
+                                            BdrvRequestFlags flags)
 {
    ThrottleGroupMember *tgm = bs->opaque;
    throttle_group_co_io_limits_intercept(tgm, bytes, true);
@@ -133,9 +134,9 @@ throttle_co_pwritev(BlockDriverState *bs, int64_t offset, int64_t bytes,
    return bdrv_co_pwritev(bs->file, offset, bytes, qiov, flags);
 }

-static int coroutine_fn GRAPH_RDLOCK
-throttle_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset, int64_t bytes,
-                          BdrvRequestFlags flags)
+static int coroutine_fn throttle_co_pwrite_zeroes(BlockDriverState *bs,
+                                                  int64_t offset, int64_t bytes,
+                                                  BdrvRequestFlags flags)
 {
    ThrottleGroupMember *tgm = bs->opaque;
    throttle_group_co_io_limits_intercept(tgm, bytes, true);
@@ -143,8 +144,8 @@ throttle_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset, int64_t bytes,
    return bdrv_co_pwrite_zeroes(bs->file, offset, bytes, flags);
 }

-static int coroutine_fn GRAPH_RDLOCK
-throttle_co_pdiscard(BlockDriverState *bs, int64_t offset, int64_t bytes)
+static int coroutine_fn throttle_co_pdiscard(BlockDriverState *bs,
+                                             int64_t offset, int64_t bytes)
 {
    ThrottleGroupMember *tgm = bs->opaque;
    throttle_group_co_io_limits_intercept(tgm, bytes, true);
@@ -152,15 +153,16 @@ throttle_co_pdiscard(BlockDriverState *bs, int64_t offset, int64_t bytes)
    return bdrv_co_pdiscard(bs->file, offset, bytes);
 }

-static int coroutine_fn GRAPH_RDLOCK
-throttle_co_pwritev_compressed(BlockDriverState *bs, int64_t offset,
-                               int64_t bytes, QEMUIOVector *qiov)
+static int coroutine_fn throttle_co_pwritev_compressed(BlockDriverState *bs,
+                                                       int64_t offset,
+                                                       int64_t bytes,
+                                                       QEMUIOVector *qiov)
 {
    return throttle_co_pwritev(bs, offset, bytes, qiov,
                               BDRV_REQ_WRITE_COMPRESSED);
 }

-static int coroutine_fn GRAPH_RDLOCK throttle_co_flush(BlockDriverState *bs)
+static int coroutine_fn throttle_co_flush(BlockDriverState *bs)
 {
    return bdrv_co_flush(bs->file->bs);
 }
--- a/block/vdi.c
+++ b/block/vdi.c
@@ -544,7 +544,7 @@ static int coroutine_fn vdi_co_block_status(BlockDriverState *bs,
        (s->header.image_type == VDI_TYPE_STATIC ? BDRV_BLOCK_RECURSE : 0);
 }

-static int coroutine_fn GRAPH_RDLOCK
+static int coroutine_fn
 vdi_co_preadv(BlockDriverState *bs, int64_t offset, int64_t bytes,
              QEMUIOVector *qiov, BdrvRequestFlags flags)
 {
@@ -600,7 +600,7 @@ vdi_co_preadv(BlockDriverState *bs, int64_t offset, int64_t bytes,
    return ret;
 }

-static int coroutine_fn GRAPH_RDLOCK
+static int coroutine_fn
 vdi_co_pwritev(BlockDriverState *bs, int64_t offset, int64_t bytes,
               QEMUIOVector *qiov, BdrvRequestFlags flags)
 {
@@ -800,14 +800,14 @@ static int coroutine_fn vdi_co_do_create(BlockdevCreateOptions *create_options,
    }

    /* Create BlockBackend to write to the image */
-    bs_file = bdrv_co_open_blockdev_ref(vdi_opts->file, errp);
+    bs_file = bdrv_open_blockdev_ref(vdi_opts->file, errp);
    if (!bs_file) {
        ret = -EIO;
        goto exit;
    }

-    blk = blk_co_new_with_bs(bs_file, BLK_PERM_WRITE | BLK_PERM_RESIZE,
-                             BLK_PERM_ALL, errp);
+    blk = blk_new_with_bs(bs_file, BLK_PERM_WRITE | BLK_PERM_RESIZE,
+                          BLK_PERM_ALL, errp);
    if (!blk) {
        ret = -EPERM;
        goto exit;
@@ -898,9 +898,10 @@ static int coroutine_fn vdi_co_create(BlockdevCreateOptions *create_options,
    return vdi_co_do_create(create_options, DEFAULT_CLUSTER_SIZE, errp);
 }

-static int coroutine_fn GRAPH_RDLOCK
-vdi_co_create_opts(BlockDriver *drv, const char *filename,
-                   QemuOpts *opts, Error **errp)
+static int coroutine_fn vdi_co_create_opts(BlockDriver *drv,
+                                           const char *filename,
+                                           QemuOpts *opts,
+                                           Error **errp)
 {
    QDict *qdict = NULL;
    BlockdevCreateOptions *create_options = NULL;
@@ -939,8 +940,8 @@ vdi_co_create_opts(BlockDriver *drv, const char *filename,
        goto done;
    }

-    bs_file = bdrv_co_open(filename, NULL, NULL,
-                           BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL, errp);
+    bs_file = bdrv_open(filename, NULL, NULL,
+                        BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL, errp);
    if (!bs_file) {
        ret = -EIO;
        goto done;
--- a/block/vhdx.c
+++ b/block/vhdx.c
@@ -1172,9 +1172,8 @@ vhdx_co_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
 }


-static int coroutine_fn GRAPH_RDLOCK
-vhdx_co_readv(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
-              QEMUIOVector *qiov)
+static coroutine_fn int vhdx_co_readv(BlockDriverState *bs, int64_t sector_num,
+                                      int nb_sectors, QEMUIOVector *qiov)
 {
    BDRVVHDXState *s = bs->opaque;
    int ret = 0;
@@ -1325,9 +1324,9 @@ int vhdx_user_visible_write(BlockDriverState *bs, BDRVVHDXState *s)
    return ret;
 }

-static int coroutine_fn GRAPH_RDLOCK
-vhdx_co_writev(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
-               QEMUIOVector *qiov, int flags)
+static coroutine_fn int vhdx_co_writev(BlockDriverState *bs, int64_t sector_num,
+                                       int nb_sectors, QEMUIOVector *qiov,
+                                       int flags)
 {
    int ret = -ENOTSUP;
    BDRVVHDXState *s = bs->opaque;
@@ -1992,13 +1991,13 @@ static int coroutine_fn vhdx_co_create(BlockdevCreateOptions *opts,
    }

    /* Create BlockBackend to write to the image */
-    bs = bdrv_co_open_blockdev_ref(vhdx_opts->file, errp);
+    bs = bdrv_open_blockdev_ref(vhdx_opts->file, errp);
    if (bs == NULL) {
        return -EIO;
    }

-    blk = blk_co_new_with_bs(bs, BLK_PERM_WRITE | BLK_PERM_RESIZE, BLK_PERM_ALL,
-                             errp);
+    blk = blk_new_with_bs(bs, BLK_PERM_WRITE | BLK_PERM_RESIZE, BLK_PERM_ALL,
+                          errp);
    if (!blk) {
        ret = -EPERM;
        goto delete_and_exit;
@@ -2059,9 +2058,10 @@ delete_and_exit:
    return ret;
 }

-static int coroutine_fn GRAPH_RDLOCK
-vhdx_co_create_opts(BlockDriver *drv, const char *filename,
-                    QemuOpts *opts, Error **errp)
+static int coroutine_fn vhdx_co_create_opts(BlockDriver *drv,
+                                            const char *filename,
+                                            QemuOpts *opts,
+                                            Error **errp)
 {
    BlockdevCreateOptions *create_options = NULL;
    QDict *qdict;
@@ -2090,8 +2090,8 @@ vhdx_co_create_opts(BlockDriver *drv, const char *filename,
        goto fail;
    }

-    bs = bdrv_co_open(filename, NULL, NULL,
-                      BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL, errp);
+    bs = bdrv_open(filename, NULL, NULL,
+                   BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL, errp);
    if (bs == NULL) {
        ret = -EIO;
        goto fail;
--- a/block/vmdk.c
+++ b/block/vmdk.c
@@ -1403,11 +1403,13 @@ static void vmdk_refresh_limits(BlockDriverState *bs, Error **errp)
 * [@skip_start_sector, @skip_end_sector) is not copied or written, and leave
 * it for call to write user data in the request.
 */
-static int coroutine_fn GRAPH_RDLOCK
-get_whole_cluster(BlockDriverState *bs, VmdkExtent *extent,
-                  uint64_t cluster_offset, uint64_t offset,
-                  uint64_t skip_start_bytes, uint64_t skip_end_bytes,
-                  bool zeroed)
+static int coroutine_fn get_whole_cluster(BlockDriverState *bs,
+                                          VmdkExtent *extent,
+                                          uint64_t cluster_offset,
+                                          uint64_t offset,
+                                          uint64_t skip_start_bytes,
+                                          uint64_t skip_end_bytes,
+                                          bool zeroed)
 {
    int ret = VMDK_OK;
    int64_t cluster_bytes;
@@ -1482,8 +1484,8 @@ exit:
    return ret;
 }

-static int coroutine_fn GRAPH_RDLOCK
-vmdk_L2update(VmdkExtent *extent, VmdkMetaData *m_data, uint32_t offset)
+static int coroutine_fn vmdk_L2update(VmdkExtent *extent, VmdkMetaData *m_data,
+                                      uint32_t offset)
 {
    offset = cpu_to_le32(offset);
    /* update L2 table */
@@ -1534,11 +1536,14 @@ vmdk_L2update(VmdkExtent *extent, VmdkMetaData *m_data, uint32_t offset)
 *          VMDK_UNALLOC if cluster is not mapped and @allocate is false.
 *          VMDK_ERROR if failed.
 */
-static int coroutine_fn GRAPH_RDLOCK
-get_cluster_offset(BlockDriverState *bs, VmdkExtent *extent,
-                   VmdkMetaData *m_data, uint64_t offset, bool allocate,
-                   uint64_t *cluster_offset, uint64_t skip_start_bytes,
-                   uint64_t skip_end_bytes)
+static int coroutine_fn get_cluster_offset(BlockDriverState *bs,
+                                           VmdkExtent *extent,
+                                           VmdkMetaData *m_data,
+                                           uint64_t offset,
+                                           bool allocate,
+                                           uint64_t *cluster_offset,
+                                           uint64_t skip_start_bytes,
+                                           uint64_t skip_end_bytes)
 {
    unsigned int l1_index, l2_offset, l2_index;
    int min_index, i, j;
@@ -1731,10 +1736,11 @@ static inline uint64_t vmdk_find_offset_in_cluster(VmdkExtent *extent,
    return extent_relative_offset % cluster_size;
 }

-static int coroutine_fn GRAPH_RDLOCK
-vmdk_co_block_status(BlockDriverState *bs, bool want_zero,
-                     int64_t offset, int64_t bytes, int64_t *pnum,
-                     int64_t *map, BlockDriverState **file)
+static int coroutine_fn vmdk_co_block_status(BlockDriverState *bs,
+                                             bool want_zero,
+                                             int64_t offset, int64_t bytes,
+                                             int64_t *pnum, int64_t *map,
+                                             BlockDriverState **file)
 {
    BDRVVmdkState *s = bs->opaque;
    int64_t index_in_cluster, n, ret;
@@ -1779,7 +1785,7 @@ vmdk_co_block_status(BlockDriverState *bs, bool want_zero,
    return ret;
 }

-static int coroutine_fn GRAPH_RDLOCK
+static int coroutine_fn
 vmdk_write_extent(VmdkExtent *extent, int64_t cluster_offset,
                  int64_t offset_in_cluster, QEMUIOVector *qiov,
                  uint64_t qiov_offset, uint64_t n_bytes,
@@ -1861,9 +1867,10 @@ vmdk_write_extent(VmdkExtent *extent, int64_t cluster_offset,
    return ret;
 }

-static int coroutine_fn GRAPH_RDLOCK
+static int coroutine_fn
 vmdk_read_extent(VmdkExtent *extent, int64_t cluster_offset,
-                 int64_t offset_in_cluster, QEMUIOVector *qiov, int bytes)
+                 int64_t offset_in_cluster, QEMUIOVector *qiov,
+                 int bytes)
 {
    int ret;
    int cluster_bytes, buf_bytes;
@@ -1927,7 +1934,7 @@ vmdk_read_extent(VmdkExtent *extent, int64_t cluster_offset,
    return ret;
 }

-static int coroutine_fn GRAPH_RDLOCK
+static int coroutine_fn
 vmdk_co_preadv(BlockDriverState *bs, int64_t offset, int64_t bytes,
               QEMUIOVector *qiov, BdrvRequestFlags flags)
 {
@@ -2009,9 +2016,9 @@ fail:
 *
 * Returns: error code with 0 for success.
 */
-static int coroutine_fn GRAPH_RDLOCK
-vmdk_pwritev(BlockDriverState *bs, uint64_t offset, uint64_t bytes,
-             QEMUIOVector *qiov, bool zeroed, bool zero_dry_run)
+static int coroutine_fn vmdk_pwritev(BlockDriverState *bs, uint64_t offset,
+                                     uint64_t bytes, QEMUIOVector *qiov,
+                                     bool zeroed, bool zero_dry_run)
 {
    BDRVVmdkState *s = bs->opaque;
    VmdkExtent *extent = NULL;
@@ -2107,7 +2114,7 @@ vmdk_pwritev(BlockDriverState *bs, uint64_t offset, uint64_t bytes,
    return 0;
 }

-static int coroutine_fn GRAPH_RDLOCK
+static int coroutine_fn
 vmdk_co_pwritev(BlockDriverState *bs, int64_t offset, int64_t bytes,
                QEMUIOVector *qiov, BdrvRequestFlags flags)
 {
@@ -2119,7 +2126,7 @@ vmdk_co_pwritev(BlockDriverState *bs, int64_t offset, int64_t bytes,
    return ret;
 }

-static int coroutine_fn GRAPH_RDLOCK
+static int coroutine_fn
 vmdk_co_pwritev_compressed(BlockDriverState *bs, int64_t offset, int64_t bytes,
                           QEMUIOVector *qiov)
 {
@@ -2147,9 +2154,10 @@ vmdk_co_pwritev_compressed(BlockDriverState *bs, int64_t offset, int64_t bytes,
    return vmdk_co_pwritev(bs, offset, bytes, qiov, 0);
 }

-static int coroutine_fn GRAPH_RDLOCK
-vmdk_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset, int64_t bytes,
-                      BdrvRequestFlags flags)
+static int coroutine_fn vmdk_co_pwrite_zeroes(BlockDriverState *bs,
+                                              int64_t offset,
+                                              int64_t bytes,
+                                              BdrvRequestFlags flags)
 {
    int ret;
    BDRVVmdkState *s = bs->opaque;
@@ -2277,10 +2285,11 @@ exit:
    return ret;
 }

-static int coroutine_fn GRAPH_RDLOCK
-vmdk_create_extent(const char *filename, int64_t filesize, bool flat,
-                   bool compress, bool zeroed_grain, BlockBackend **pbb,
-                   QemuOpts *opts, Error **errp)
+static int coroutine_fn vmdk_create_extent(const char *filename,
+                                           int64_t filesize, bool flat,
+                                           bool compress, bool zeroed_grain,
+                                           BlockBackend **pbb,
+                                           QemuOpts *opts, Error **errp)
 {
    int ret;
    BlockBackend *blk = NULL;
@@ -2290,9 +2299,9 @@ vmdk_create_extent(const char *filename, int64_t filesize, bool flat,
        goto exit;
    }

-    blk = blk_co_new_open(filename, NULL, NULL,
-                          BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL,
-                          errp);
+    blk = blk_new_open(filename, NULL, NULL,
+                       BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL,
+                       errp);
    if (blk == NULL) {
        ret = -EIO;
        goto exit;
@@ -2358,10 +2367,14 @@ static int filename_decompose(const char *filename, char *path, char *prefix,
 *           non-split format.
 * idx >= 1: get the n-th extent if in a split subformat
 */
-typedef BlockBackend * coroutine_fn /* GRAPH_RDLOCK */
-    (*vmdk_create_extent_fn)(int64_t size, int idx, bool flat, bool split,
-                             bool compress, bool zeroed_grain, void *opaque,
-                             Error **errp);
+typedef BlockBackend * coroutine_fn (*vmdk_create_extent_fn)(int64_t size,
+                                                             int idx,
+                                                             bool flat,
+                                                             bool split,
+                                                             bool compress,
+                                                             bool zeroed_grain,
+                                                             void *opaque,
+                                                             Error **errp);

 static void vmdk_desc_add_extent(GString *desc,
                                 const char *extent_line_fmt,
@@ -2374,18 +2387,17 @@ static void vmdk_desc_add_extent(GString *desc,
    g_free(basename);
 }

-static int coroutine_fn GRAPH_RDLOCK
-vmdk_co_do_create(int64_t size,
-                  BlockdevVmdkSubformat subformat,
-                  BlockdevVmdkAdapterType adapter_type,
-                  const char *backing_file,
-                  const char *hw_version,
-                  const char *toolsversion,
-                  bool compat6,
-                  bool zeroed_grain,
-                  vmdk_create_extent_fn extent_fn,
-                  void *opaque,
-                  Error **errp)
+static int coroutine_fn vmdk_co_do_create(int64_t size,
+                                          BlockdevVmdkSubformat subformat,
+                                          BlockdevVmdkAdapterType adapter_type,
+                                          const char *backing_file,
+                                          const char *hw_version,
+                                          const char *toolsversion,
+                                          bool compat6,
+                                          bool zeroed_grain,
+                                          vmdk_create_extent_fn extent_fn,
+                                          void *opaque,
+                                          Error **errp)
 {
    int extent_idx;
    BlockBackend *blk = NULL;
@@ -2506,8 +2518,8 @@ vmdk_co_do_create(int64_t size,
        }
        assert(full_backing);

-        backing = blk_co_new_open(full_backing, NULL, NULL,
-                                  BDRV_O_NO_BACKING, errp);
+        backing = blk_new_open(full_backing, NULL, NULL,
+                               BDRV_O_NO_BACKING, errp);
        g_free(full_backing);
        if (backing == NULL) {
            ret = -EIO;
@@ -2605,10 +2617,10 @@ typedef struct {
    QemuOpts *opts;
 } VMDKCreateOptsData;

-static BlockBackend * coroutine_fn GRAPH_RDLOCK
-vmdk_co_create_opts_cb(int64_t size, int idx, bool flat, bool split,
-                       bool compress, bool zeroed_grain, void *opaque,
-                       Error **errp)
+static BlockBackend * coroutine_fn vmdk_co_create_opts_cb(int64_t size, int idx,
+                                            bool flat, bool split, bool compress,
+                                            bool zeroed_grain, void *opaque,
+                                            Error **errp)
 {
    BlockBackend *blk = NULL;
    BlockDriverState *bs = NULL;
@@ -2647,9 +2659,10 @@ exit:
    return blk;
 }

-static int coroutine_fn GRAPH_RDLOCK
-vmdk_co_create_opts(BlockDriver *drv, const char *filename,
-                    QemuOpts *opts, Error **errp)
+static int coroutine_fn vmdk_co_create_opts(BlockDriver *drv,
+                                            const char *filename,
+                                            QemuOpts *opts,
+                                            Error **errp)
 {
    Error *local_err = NULL;
    char *desc = NULL;
@@ -2768,7 +2781,7 @@ static BlockBackend * coroutine_fn vmdk_co_create_cb(int64_t size, int idx,
    BlockdevCreateOptionsVmdk *opts = opaque;

    if (idx == 0) {
-        bs = bdrv_co_open_blockdev_ref(opts->file, errp);
+        bs = bdrv_open_blockdev_ref(opts->file, errp);
    } else {
        int i;
        BlockdevRefList *list = opts->extents;
@@ -2783,16 +2796,14 @@ static BlockBackend * coroutine_fn vmdk_co_create_cb(int64_t size, int idx,
            error_setg(errp, "Extent [%d] not specified", idx - 1);
            return NULL;
        }
-        bs = bdrv_co_open_blockdev_ref(list->value, errp);
+        bs = bdrv_open_blockdev_ref(list->value, errp);
    }
    if (!bs) {
        return NULL;
    }
-    blk = blk_co_new_with_bs(bs,
-                             BLK_PERM_CONSISTENT_READ | BLK_PERM_WRITE |
-                                BLK_PERM_RESIZE,
-                             BLK_PERM_ALL,
-                             errp);
+    blk = blk_new_with_bs(bs,
+                          BLK_PERM_CONSISTENT_READ | BLK_PERM_WRITE | BLK_PERM_RESIZE,
+                          BLK_PERM_ALL, errp);
    if (!blk) {
        return NULL;
    }
@@ -2809,8 +2820,8 @@ static BlockBackend * coroutine_fn vmdk_co_create_cb(int64_t size, int idx,
    return blk;
 }

-static int coroutine_fn GRAPH_RDLOCK
-vmdk_co_create(BlockdevCreateOptions *create_options, Error **errp)
+static int coroutine_fn vmdk_co_create(BlockdevCreateOptions *create_options,
+                                       Error **errp)
 {
    BlockdevCreateOptionsVmdk *opts;

@@ -2905,8 +2916,9 @@ static VmdkExtentInfo *vmdk_get_extent_info(VmdkExtent *extent)
    return info;
 }

-static int coroutine_fn GRAPH_RDLOCK
-vmdk_co_check(BlockDriverState *bs, BdrvCheckResult *result, BdrvCheckMode fix)
+static int coroutine_fn vmdk_co_check(BlockDriverState *bs,
+                                      BdrvCheckResult *result,
+                                      BdrvCheckMode fix)
 {
    BDRVVmdkState *s = bs->opaque;
    VmdkExtent *extent = NULL;
--- a/block/vpc.c
+++ b/block/vpc.c
@@ -610,7 +610,7 @@ vpc_co_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
    return 0;
 }

-static int coroutine_fn GRAPH_RDLOCK
+static int coroutine_fn
 vpc_co_preadv(BlockDriverState *bs, int64_t offset, int64_t bytes,
              QEMUIOVector *qiov, BdrvRequestFlags flags)
 {
@@ -660,7 +660,7 @@ fail:
    return ret;
 }

-static int coroutine_fn GRAPH_RDLOCK
+static int coroutine_fn
 vpc_co_pwritev(BlockDriverState *bs, int64_t offset, int64_t bytes,
               QEMUIOVector *qiov, BdrvRequestFlags flags)
 {
@@ -1005,13 +1005,13 @@ static int coroutine_fn vpc_co_create(BlockdevCreateOptions *opts,
    }

    /* Create BlockBackend to write to the image */
-    bs = bdrv_co_open_blockdev_ref(vpc_opts->file, errp);
+    bs = bdrv_open_blockdev_ref(vpc_opts->file, errp);
    if (bs == NULL) {
        return -EIO;
    }

-    blk = blk_co_new_with_bs(bs, BLK_PERM_WRITE | BLK_PERM_RESIZE, BLK_PERM_ALL,
-                             errp);
+    blk = blk_new_with_bs(bs, BLK_PERM_WRITE | BLK_PERM_RESIZE, BLK_PERM_ALL,
+                          errp);
    if (!blk) {
        ret = -EPERM;
        goto out;
@@ -1087,9 +1087,10 @@ out:
    return ret;
 }

-static int coroutine_fn GRAPH_RDLOCK
-vpc_co_create_opts(BlockDriver *drv, const char *filename,
-                   QemuOpts *opts, Error **errp)
+static int coroutine_fn vpc_co_create_opts(BlockDriver *drv,
+                                           const char *filename,
+                                           QemuOpts *opts,
+                                           Error **errp)
 {
    BlockdevCreateOptions *create_options = NULL;
    QDict *qdict;
@@ -1116,8 +1117,8 @@ vpc_co_create_opts(BlockDriver *drv, const char *filename,
        goto fail;
    }

-    bs = bdrv_co_open(filename, NULL, NULL,
-                      BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL, errp);
+    bs = bdrv_open(filename, NULL, NULL,
+                   BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL, errp);
    if (bs == NULL) {
        ret = -EIO;
        goto fail;
--- a/block/vvfat.c
+++ b/block/vvfat.c
@@ -2784,10 +2784,13 @@ static int handle_commits(BDRVVVFATState* s)
            fail = -2;
            break;
        case ACTION_WRITEOUT: {
+#ifndef NDEBUG
+            /* these variables are only used by assert() below */
            direntry_t* entry = array_get(&(s->directory),
                    commit->param.writeout.dir_index);
            uint32_t begin = begin_of_direntry(entry);
            mapping_t* mapping = find_mapping_for_cluster(s, begin);
+#endif

            assert(mapping);
            assert(mapping->begin == begin);
--- a/bsd-user/freebsd/os-sys.c
+++ b/bsd-user/freebsd/os-sys.c
@@ -21,577 +21,6 @@
 #include "qemu.h"
 #include "target_arch_sysarch.h"

-#include <sys/sysctl.h>
-
-/*
- * Length for the fixed length types.
- * 0 means variable length for strings and structures
- * Compare with sys/kern_sysctl.c ctl_size
- * Note: Not all types appear to be used in-tree.
- */
-static const int guest_ctl_size[CTLTYPE + 1] = {
-        [CTLTYPE_INT] = sizeof(abi_int),
-        [CTLTYPE_UINT] = sizeof(abi_uint),
-        [CTLTYPE_LONG] = sizeof(abi_long),
-        [CTLTYPE_ULONG] = sizeof(abi_ulong),
-        [CTLTYPE_S8] = sizeof(int8_t),
-        [CTLTYPE_S16] = sizeof(int16_t),
-        [CTLTYPE_S32] = sizeof(int32_t),
-        [CTLTYPE_S64] = sizeof(int64_t),
-        [CTLTYPE_U8] = sizeof(uint8_t),
-        [CTLTYPE_U16] = sizeof(uint16_t),
-        [CTLTYPE_U32] = sizeof(uint32_t),
-        [CTLTYPE_U64] = sizeof(uint64_t),
-};
-
-static const int host_ctl_size[CTLTYPE + 1] = {
-        [CTLTYPE_INT] = sizeof(int),
-        [CTLTYPE_UINT] = sizeof(u_int),
-        [CTLTYPE_LONG] = sizeof(long),
-        [CTLTYPE_ULONG] = sizeof(u_long),
-        [CTLTYPE_S8] = sizeof(int8_t),
-        [CTLTYPE_S16] = sizeof(int16_t),
-        [CTLTYPE_S32] = sizeof(int32_t),
-        [CTLTYPE_S64] = sizeof(int64_t),
-        [CTLTYPE_U8] = sizeof(uint8_t),
-        [CTLTYPE_U16] = sizeof(uint16_t),
-        [CTLTYPE_U32] = sizeof(uint32_t),
-        [CTLTYPE_U64] = sizeof(uint64_t),
-};
-
-#ifdef TARGET_ABI32
-/*
- * Limit the amount of available memory to be most of the 32-bit address
- * space. 0x100c000 was arrived at through trial and error as a good
- * definition of 'most'.
- */
-static const abi_ulong guest_max_mem = UINT32_MAX - 0x100c000 + 1;
-
-static abi_ulong cap_memory(uint64_t mem)
-{
-    return MIN(guest_max_mem, mem);
-}
-#endif
-
-static abi_ulong scale_to_guest_pages(uint64_t pages)
-{
-    /* Scale pages from host to guest */
-    pages = muldiv64(pages, qemu_real_host_page_size(), TARGET_PAGE_SIZE);
-#ifdef TARGET_ABI32
-    /* cap pages if need be */
-    pages = MIN(pages, guest_max_mem / (abi_ulong)TARGET_PAGE_SIZE);
-#endif
-    return pages;
-}
-
-#ifdef TARGET_ABI32
-/* Used only for TARGET_ABI32 */
-static abi_long h2g_long_sat(long l)
-{
-    if (l > INT32_MAX) {
-        l = INT32_MAX;
-    } else if (l < INT32_MIN) {
-        l = INT32_MIN;
-    }
-    return l;
-}
-
-static abi_ulong h2g_ulong_sat(u_long ul)
-{
-    return MIN(ul, UINT32_MAX);
-}
-#endif
-
-/*
- * placeholder until bsd-user downstream upstreams this with its thread support
- */
-#define bsd_get_ncpu() 1
-
-/*
- * This uses the undocumented oidfmt interface to find the kind of a requested
- * sysctl, see /sys/kern/kern_sysctl.c:sysctl_sysctl_oidfmt() (compare to
- * src/sbin/sysctl/sysctl.c)
- */
-static int oidfmt(int *oid, int len, char *fmt, uint32_t *kind)
-{
-    int qoid[CTL_MAXNAME + 2];
-    uint8_t buf[BUFSIZ];
-    int i;
-    size_t j;
-
-    qoid[0] = CTL_SYSCTL;
-    qoid[1] = CTL_SYSCTL_OIDFMT;
-    memcpy(qoid + 2, oid, len * sizeof(int));
-
-    j = sizeof(buf);
-    i = sysctl(qoid, len + 2, buf, &j, 0, 0);
-    if (i) {
-        return i;
-    }
-
-    if (kind) {
-        *kind = *(uint32_t *)buf;
-    }
-
-    if (fmt) {
-        strcpy(fmt, (char *)(buf + sizeof(uint32_t)));
-    }
-    return 0;
-}
-
-/*
- * Convert the old value from host to guest.
- *
- * For LONG and ULONG on ABI32, we need to 'down convert' the 8 byte quantities
- * to 4 bytes. The caller setup a buffer in host memory to get this data from
- * the kernel and pass it to us. We do the down conversion and adjust the length
- * so the caller knows what to write as the returned length into the target when
- * it copies the down converted values into the target.
- *
- * For normal integral types, we just need to byte swap. No size changes.
- *
- * For strings and node data, there's no conversion needed.
- *
- * For opaque data, per sysctl OID converts take care of it.
- */
-static void h2g_old_sysctl(void *holdp, size_t *holdlen, uint32_t kind)
-{
-    size_t len;
-    int hlen, glen;
-    uint8_t *hp, *gp;
-
-    /*
-     * Although rare, we can have arrays of sysctl. Both sysctl_old_ddb in
-     * kern_sysctl.c and show_var in sbin/sysctl/sysctl.c have code that loops
-     * this way.  *holdlen has been set by the kernel to the host's length.
-     * Only LONG and ULONG on ABI32 have different sizes: see below.
-     */
-    gp = hp = (uint8_t *)holdp;
-    len = 0;
-    hlen = host_ctl_size[kind & CTLTYPE];
-    glen = guest_ctl_size[kind & CTLTYPE];
-
-    /*
-     * hlen == 0 for CTLTYPE_STRING and CTLTYPE_NODE, which need no conversion
-     * as well as CTLTYPE_OPAQUE, which needs special converters.
-     */
-    if (hlen == 0) {
-        return;
-    }
-
-    while (len < *holdlen) {
-        if (hlen == glen) {
-            switch (hlen) {
-            case 1:
-                /* Nothing needed: no byteswapping and assigning in place */
-                break;
-            case 2:
-                *(uint16_t *)gp = tswap16(*(uint16_t *)hp);
-                break;
-            case 4:
-                *(uint32_t *)gp = tswap32(*(uint32_t *)hp);
-                break;
-            case 8:
-                *(uint64_t *)gp = tswap64(*(uint64_t *)hp);
-                break;
-            default:
-                g_assert_not_reached();
-            }
-        } else {
-#ifdef TARGET_ABI32
-            /*
-             * Saturating assignment for the only two types that differ between
-             * 32-bit and 64-bit machines. All other integral types have the
-             * same, fixed size and will be converted w/o loss of precision
-             * in the above switch.
-             */
-            switch (kind & CTLTYPE) {
-            case CTLTYPE_LONG:
-                *(abi_long *)gp = tswap32(h2g_long_sat(*(long *)hp));
-                break;
-            case CTLTYPE_ULONG:
-                *(abi_ulong *)gp = tswap32(h2g_ulong_sat(*(u_long *)hp));
-                break;
-            default:
-                g_assert_not_reached();
-            }
-#else
-            g_assert_not_reached();
-#endif
-        }
-        gp += glen;
-        hp += hlen;
-        len += hlen;
-    }
-#ifdef TARGET_ABI32
-    if (hlen != glen) {
-        *holdlen = (*holdlen / hlen) * glen;
-    }
-#endif
-}
-
-/*
- * Convert the undocmented name2oid sysctl data for the target.
- */
-static inline void sysctl_name2oid(uint32_t *holdp, size_t holdlen)
-{
-    size_t i, num = holdlen / sizeof(uint32_t);
-
-    for (i = 0; i < num; i++) {
-        holdp[i] = tswap32(holdp[i]);
-    }
-}
-
-static inline void sysctl_oidfmt(uint32_t *holdp)
-{
-    /* byte swap the kind */
-    holdp[0] = tswap32(holdp[0]);
-}
-
-static abi_long do_freebsd_sysctl_oid(CPUArchState *env, int32_t *snamep,
-        int32_t namelen, void *holdp, size_t *holdlenp, void *hnewp,
-        size_t newlen)
-{
-    uint32_t kind = 0;
-    abi_long ret;
-    size_t holdlen, oldlen;
-#ifdef TARGET_ABI32
-    void *old_holdp;
-#endif
-
-    holdlen = oldlen = *holdlenp;
-    oidfmt(snamep, namelen, NULL, &kind);
-
-    /* Handle some arch/emulator dependent sysctl()'s here. */
-    switch (snamep[0]) {
-    case CTL_KERN:
-        switch (snamep[1]) {
-        case KERN_USRSTACK:
-            if (oldlen) {
-                (*(abi_ulong *)holdp) = tswapal(TARGET_USRSTACK);
-            }
-            holdlen = sizeof(abi_ulong);
-            ret = 0;
-            goto out;
-
-        case KERN_PS_STRINGS:
-            if (oldlen) {
-                (*(abi_ulong *)holdp) = tswapal(TARGET_PS_STRINGS);
-            }
-            holdlen = sizeof(abi_ulong);
-            ret = 0;
-            goto out;
-
-        default:
-            break;
-        }
-        break;
-
-    case CTL_HW:
-        switch (snamep[1]) {
-        case HW_MACHINE:
-            holdlen = sizeof(TARGET_HW_MACHINE);
-            if (holdp) {
-                strlcpy(holdp, TARGET_HW_MACHINE, oldlen);
-            }
-            ret = 0;
-            goto out;
-
-        case HW_MACHINE_ARCH:
-        {
-            holdlen = sizeof(TARGET_HW_MACHINE_ARCH);
-            if (holdp) {
-                strlcpy(holdp, TARGET_HW_MACHINE_ARCH, oldlen);
-            }
-            ret = 0;
-            goto out;
-        }
-        case HW_NCPU:
-            if (oldlen) {
-                (*(abi_int *)holdp) = tswap32(bsd_get_ncpu());
-            }
-            holdlen = sizeof(int32_t);
-            ret = 0;
-            goto out;
-#if defined(TARGET_ARM)
-        case HW_FLOATINGPT:
-            if (oldlen) {
-                ARMCPU *cpu = env_archcpu(env);
-                *(abi_int *)holdp = cpu_isar_feature(aa32_vfp, cpu);
-            }
-            holdlen = sizeof(abi_int);
-            ret = 0;
-            goto out;
-#endif
-
-
-#ifdef TARGET_ABI32
-        case HW_PHYSMEM:
-        case HW_USERMEM:
-        case HW_REALMEM:
-            holdlen = sizeof(abi_ulong);
-            ret = 0;
-
-            if (oldlen) {
-                int mib[2] = {snamep[0], snamep[1]};
-                unsigned long lvalue;
-                size_t len = sizeof(lvalue);
-
-                if (sysctl(mib, 2, &lvalue, &len, NULL, 0) == -1) {
-                    ret = -1;
-                } else {
-                    lvalue = cap_memory(lvalue);
-                    (*(abi_ulong *)holdp) = tswapal((abi_ulong)lvalue);
-                }
-            }
-            goto out;
-#endif
-
-        default:
-        {
-            static int oid_hw_availpages;
-            static int oid_hw_pagesizes;
-
-            if (!oid_hw_availpages) {
-                int real_oid[CTL_MAXNAME + 2];
-                size_t len = sizeof(real_oid) / sizeof(int);
-
-                if (sysctlnametomib("hw.availpages", real_oid, &len) >= 0) {
-                    oid_hw_availpages = real_oid[1];
-                }
-            }
-            if (!oid_hw_pagesizes) {
-                int real_oid[CTL_MAXNAME + 2];
-                size_t len = sizeof(real_oid) / sizeof(int);
-
-                if (sysctlnametomib("hw.pagesizes", real_oid, &len) >= 0) {
-                    oid_hw_pagesizes = real_oid[1];
-                }
-            }
-
-            if (oid_hw_availpages && snamep[1] == oid_hw_availpages) {
-                long lvalue;
-                size_t len = sizeof(lvalue);
-
-                if (sysctlbyname("hw.availpages", &lvalue, &len, NULL, 0) == -1) {
-                    ret = -1;
-                } else {
-                    if (oldlen) {
-                        lvalue = scale_to_guest_pages(lvalue);
-                        (*(abi_ulong *)holdp) = tswapal((abi_ulong)lvalue);
-                    }
-                    holdlen = sizeof(abi_ulong);
-                    ret = 0;
-                }
-                goto out;
-            }
-
-            if (oid_hw_pagesizes && snamep[1] == oid_hw_pagesizes) {
-                if (oldlen) {
-                    (*(abi_ulong *)holdp) = tswapal((abi_ulong)TARGET_PAGE_SIZE);
-                    ((abi_ulong *)holdp)[1] = 0;
-                }
-                holdlen = sizeof(abi_ulong) * 2;
-                ret = 0;
-                goto out;
-            }
-            break;
-        }
-        }
-        break;
-
-    default:
-        break;
-    }
-
-#ifdef TARGET_ABI32
-    /*
-     * For long and ulong with a 64-bit host and a 32-bit target we have to do
-     * special things. holdlen here is the length provided by the target to the
-     * system call. So we allocate a buffer twice as large because longs are
-     * twice as big on the host which will be writing them. In h2g_old_sysctl
-     * we'll adjust them and adjust the length.
-     */
-    if (kind == CTLTYPE_LONG || kind == CTLTYPE_ULONG) {
-        old_holdp = holdp;
-        holdlen = holdlen * 2;
-        holdp = g_malloc(holdlen);
-    }
-#endif
-
-    ret = get_errno(sysctl(snamep, namelen, holdp, &holdlen, hnewp, newlen));
-    if (!ret && (holdp != 0)) {
-
-        if (snamep[0] == CTL_SYSCTL) {
-            switch (snamep[1]) {
-            case CTL_SYSCTL_NEXT:
-            case CTL_SYSCTL_NAME2OID:
-            case CTL_SYSCTL_NEXTNOSKIP:
-                /*
-                 * All of these return an OID array, so we need to convert to
-                 * target.
-                 */
-                sysctl_name2oid(holdp, holdlen);
-                break;
-
-            case CTL_SYSCTL_OIDFMT:
-                /* Handle oidfmt */
-                sysctl_oidfmt(holdp);
-                break;
-            case CTL_SYSCTL_OIDDESCR:
-            case CTL_SYSCTL_OIDLABEL:
-            default:
-                /* Handle it based on the type */
-                h2g_old_sysctl(holdp, &holdlen, kind);
-                /* NB: None of these are LONG or ULONG */
-                break;
-            }
-        } else {
-            /*
-             * Need to convert from host to target. All the weird special cases
-             * are handled above.
-             */
-            h2g_old_sysctl(holdp, &holdlen, kind);
-#ifdef TARGET_ABI32
-            /*
-             * For the 32-bit on 64-bit case, for longs we need to copy the
-             * now-converted buffer to the target and free the buffer.
-             */
-            if (kind == CTLTYPE_LONG || kind == CTLTYPE_ULONG) {
-                memcpy(old_holdp, holdp, holdlen);
-                g_free(holdp);
-                holdp = old_holdp;
-            }
-#endif
-        }
-    }
-
-out:
-    *holdlenp = holdlen;
-    return ret;
-}
-
-/*
- * This syscall was created to make sysctlbyname(3) more efficient, but we can't
- * really provide it in bsd-user.  Notably, we must always translate the names
- * independently since some sysctl values have to be faked for the target
- * environment, so it still has to break down to two syscalls for the underlying
- * implementation.
- */
-abi_long do_freebsd_sysctlbyname(CPUArchState *env, abi_ulong namep,
-        int32_t namelen, abi_ulong oldp, abi_ulong oldlenp, abi_ulong newp,
-        abi_ulong newlen)
-{
-    abi_long ret = -TARGET_EFAULT;
-    void *holdp = NULL, *hnewp = NULL;
-    char *snamep = NULL;
-    int oid[CTL_MAXNAME + 2];
-    size_t holdlen, oidplen;
-    abi_ulong oldlen = 0;
-
-    /* oldlenp is read/write, pre-check here for write */
-    if (oldlenp) {
-        if (!access_ok(VERIFY_WRITE, oldlenp, sizeof(abi_ulong)) ||
-            get_user_ual(oldlen, oldlenp)) {
-            goto out;
-        }
-    }
-    snamep = lock_user_string(namep);
-    if (snamep == NULL) {
-        goto out;
-    }
-    if (newp) {
-        hnewp = lock_user(VERIFY_READ, newp, newlen, 1);
-        if (hnewp == NULL) {
-            goto out;
-        }
-    }
-    if (oldp) {
-        holdp = lock_user(VERIFY_WRITE, oldp, oldlen, 0);
-        if (holdp == NULL) {
-            goto out;
-        }
-    }
-    holdlen = oldlen;
-
-    oidplen = ARRAY_SIZE(oid);
-    if (sysctlnametomib(snamep, oid, &oidplen) != 0) {
-        ret = -TARGET_EINVAL;
-        goto out;
-    }
-
-    ret = do_freebsd_sysctl_oid(env, oid, oidplen, holdp, &holdlen, hnewp,
-        newlen);
-
-    /*
-     * writeability pre-checked above. __sysctl(2) returns ENOMEM and updates
-     * oldlenp for the proper size to use.
-     */
-    if (oldlenp && (ret == 0 || ret == -TARGET_ENOMEM)) {
-        put_user_ual(holdlen, oldlenp);
-    }
-out:
-    unlock_user(snamep, namep, 0);
-    unlock_user(holdp, oldp, ret == 0 ? holdlen : 0);
-    unlock_user(hnewp, newp, 0);
-
-    return ret;
-}
-
-abi_long do_freebsd_sysctl(CPUArchState *env, abi_ulong namep, int32_t namelen,
-        abi_ulong oldp, abi_ulong oldlenp, abi_ulong newp, abi_ulong newlen)
-{
-    abi_long ret = -TARGET_EFAULT;
-    void *hnamep, *holdp = NULL, *hnewp = NULL;
-    size_t holdlen;
-    abi_ulong oldlen = 0;
-    int32_t *snamep = g_malloc(sizeof(int32_t) * namelen), *p, *q, i;
-
-    /* oldlenp is read/write, pre-check here for write */
-    if (oldlenp) {
-        if (!access_ok(VERIFY_WRITE, oldlenp, sizeof(abi_ulong)) ||
-            get_user_ual(oldlen, oldlenp)) {
-            goto out;
-        }
-    }
-    hnamep = lock_user(VERIFY_READ, namep, namelen, 1);
-    if (hnamep == NULL) {
-        goto out;
-    }
-    if (newp) {
-        hnewp = lock_user(VERIFY_READ, newp, newlen, 1);
-        if (hnewp == NULL) {
-            goto out;
-        }
-    }
-    if (oldp) {
-        holdp = lock_user(VERIFY_WRITE, oldp, oldlen, 0);
-        if (holdp == NULL) {
-            goto out;
-        }
-    }
-    holdlen = oldlen;
-    for (p = hnamep, q = snamep, i = 0; i < namelen; p++, i++, q++) {
-        *q = tswap32(*p);
-    }
-
-    ret = do_freebsd_sysctl_oid(env, snamep, namelen, holdp, &holdlen, hnewp,
-        newlen);
-
-    /*
-     * writeability pre-checked above. __sysctl(2) returns ENOMEM and updates
-     * oldlenp for the proper size to use.
-     */
-    if (oldlenp && (ret == 0 || ret == -TARGET_ENOMEM)) {
-        put_user_ual(holdlen, oldlenp);
-    }
-    unlock_user(hnamep, namep, 0);
-    unlock_user(holdp, oldp, ret == 0 ? holdlen : 0);
-out:
-    g_free(snamep);
-    return ret;
-}
-
 /* sysarch() is architecture dependent. */
 abi_long do_freebsd_sysarch(void *cpu_env, abi_long arg1, abi_long arg2)
 {
--- a/bsd-user/freebsd/os-syscall.c
+++ b/bsd-user/freebsd/os-syscall.c
@@ -491,21 +491,6 @@ static abi_long freebsd_syscall(void *cpu_env, int num, abi_long arg1,
        ret = do_bsd_undelete(arg1);
        break;

-        /*
-         * sys{ctl, arch, call}
-         */
-    case TARGET_FREEBSD_NR___sysctl: /* sysctl(3) */
-        ret = do_freebsd_sysctl(cpu_env, arg1, arg2, arg3, arg4, arg5, arg6);
-        break;
-
-    case TARGET_FREEBSD_NR___sysctlbyname: /* sysctlbyname(2) */
-        ret = do_freebsd_sysctlbyname(cpu_env, arg1, arg2, arg3, arg4, arg5, arg6);
-        break;
-
-    case TARGET_FREEBSD_NR_sysarch: /* sysarch(2) */
-        ret = do_freebsd_sysarch(cpu_env, arg1, arg2);
-        break;
-
    default:
        qemu_log_mask(LOG_UNIMP, "Unsupported syscall: %d\n", num);
        ret = -TARGET_ENOSYS;
@@ -527,7 +512,7 @@ abi_long do_freebsd_syscall(void *cpu_env, int num, abi_long arg1,
                            abi_long arg8)
 {
    CPUState *cpu = env_cpu(cpu_env);
-    abi_long ret;
+    int ret;

    trace_guest_user_syscall(cpu, num, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
    if (do_strace) {
--- a/bsd-user/qemu.h
+++ b/bsd-user/qemu.h
@@ -36,7 +36,6 @@ extern char **environ;
 #include "target_os_signal.h"
 #include "target.h"
 #include "exec/gdbstub.h"
-#include "qemu/clang-tsa.h"

 /*
 * This struct is used to hold certain information about the image.  Basically,
@@ -235,8 +234,8 @@ int target_msync(abi_ulong start, abi_ulong len, int flags);
 extern unsigned long last_brk;
 extern abi_ulong mmap_next_start;
 abi_ulong mmap_find_vma(abi_ulong start, abi_ulong size);
-void TSA_NO_TSA mmap_fork_start(void);
-void TSA_NO_TSA mmap_fork_end(int child);
+void mmap_fork_start(void);
+void mmap_fork_end(int child);

 /* main.c */
 extern char qemu_proc_pathname[];
@@ -253,11 +252,6 @@ bool is_error(abi_long ret);
 int host_to_target_errno(int err);

 /* os-sys.c */
-abi_long do_freebsd_sysctl(CPUArchState *env, abi_ulong namep, int32_t namelen,
-        abi_ulong oldp, abi_ulong oldlenp, abi_ulong newp, abi_ulong newlen);
-abi_long do_freebsd_sysctlbyname(CPUArchState *env, abi_ulong namep,
-        int32_t namelen, abi_ulong oldp, abi_ulong oldlenp, abi_ulong newp,
-        abi_ulong newlen);
 abi_long do_freebsd_sysarch(void *cpu_env, abi_long arg1, abi_long arg2);

 /* user access */
--- a/chardev/char-socket.c
+++ b/chardev/char-socket.c
@@ -1065,7 +1065,6 @@ static void char_socket_finalize(Object *obj)
        qio_net_listener_set_client_func_full(s->listener, NULL, NULL,
                                              NULL, chr->gcontext);
        object_unref(OBJECT(s->listener));
-        s->listener = NULL;
    }
    if (s->tls_creds) {
        object_unref(OBJECT(s->tls_creds));
--- a/configs/targets/microblaze-linux-user.mak
+++ b/configs/targets/microblaze-linux-user.mak
@@ -3,4 +3,3 @@ TARGET_SYSTBL_ABI=common
 TARGET_SYSTBL=syscall.tbl
 TARGET_BIG_ENDIAN=y
 TARGET_HAS_BFLT=y
-TARGET_XML_FILES=gdb-xml/microblaze-core.xml gdb-xml/microblaze-stack-protect.xml
--- a/configs/targets/microblaze-softmmu.mak
+++ b/configs/targets/microblaze-softmmu.mak
@@ -2,4 +2,3 @@ TARGET_ARCH=microblaze
 TARGET_BIG_ENDIAN=y
 TARGET_SUPPORTS_MTTCG=y
 TARGET_NEED_FDT=y
-TARGET_XML_FILES=gdb-xml/microblaze-core.xml gdb-xml/microblaze-stack-protect.xml
--- a/configs/targets/microblazeel-linux-user.mak
+++ b/configs/targets/microblazeel-linux-user.mak
@@ -2,4 +2,3 @@ TARGET_ARCH=microblaze
 TARGET_SYSTBL_ABI=common
 TARGET_SYSTBL=syscall.tbl
 TARGET_HAS_BFLT=y
-TARGET_XML_FILES=gdb-xml/microblaze-core.xml gdb-xml/microblaze-stack-protect.xml
--- a/configs/targets/microblazeel-softmmu.mak
+++ b/configs/targets/microblazeel-softmmu.mak
@@ -1,4 +1,3 @@
 TARGET_ARCH=microblaze
 TARGET_SUPPORTS_MTTCG=y
 TARGET_NEED_FDT=y
-TARGET_XML_FILES=gdb-xml/microblaze-core.xml gdb-xml/microblaze-stack-protect.xml
--- a/122
+++ b/122
@@ -31,12 +31,8 @@ then
        fi
    fi

-    if ! mkdir build || ! touch $MARKER
-    then
-        echo "ERROR: Could not create ./build directory. Check the permissions on"
-        echo "your source directory, or try doing an out-of-tree build."
-        exit 1
-    fi
+    mkdir build
+    touch $MARKER

    cat > GNUmakefile <<'EOF'
 # This file is auto-generated by configure to support in-source tree
@@ -596,43 +592,20 @@ esac

 : ${make=${MAKE-make}}

-
-check_py_version() {
-    # We require python >= 3.6.
-    # NB: a True python conditional creates a non-zero return code (Failure)
-    "$1" -c 'import sys; sys.exit(sys.version_info < (3,6))'
-}
-
+# We prefer python 3.x. A bare 'python' is traditionally
+# python 2.x, but some distros have it as python 3.x, so
+# we check that too
 python=
-first_python=
-if test -z "${PYTHON}"; then
-    explicit_python=no
-    # A bare 'python' is traditionally python 2.x, but some distros
-    # have it as python 3.x, so check in both places.
-    for binary in python3 python python3.11 python3.10 python3.9 python3.8 python3.7 python3.6; do
-        if has "$binary"; then
-            python=$(command -v "$binary")
-            if check_py_version "$python"; then
-                # This one is good.
-                first_python=
-                break
-            else
-                first_python=$python
-            fi
-        fi
-    done
-else
-    # Same as above, but only check the environment variable.
-    has "${PYTHON}" || error_exit "The PYTHON environment variable does not point to an executable"
-    python=$(command -v "$PYTHON")
-    explicit_python=yes
-    if check_py_version "$python"; then
-        # This one is good.
-        first_python=
-    else
-        first_python=$first_python
+explicit_python=no
+for binary in "${PYTHON-python3}" python
+do
+    if has "$binary"
+    then
+        python=$(command -v "$binary")
+        break
    fi
-fi
+done
+

 # Check for ancillary tools used in testing
 genisoimage=
@@ -1045,7 +1018,7 @@ cat << EOF
  debug-tcg       TCG debugging (default is disabled)
  debug-info      debugging information
  safe-stack      SafeStack Stack Smash Protection. Depends on
-                  clang/llvm and requires coroutine backend ucontext.
+                  clang/llvm >= 3.7 and requires coroutine backend ucontext.

 NOTE: The object files are built at the place where configure is launched
 EOF
@@ -1057,44 +1030,25 @@ rm -f ./*/config-devices.mak.d

 if test -z "$python"
 then
-    # If first_python is set, there was a binary somewhere even though
-    # it was not suitable.  Use it for the error message.
-    if test -n "$first_python"; then
-        error_exit "Cannot use '$first_python', Python >= 3.6 is required." \
-            "Use --python=/path/to/python to specify a supported Python."
-    else
-        error_exit "Python not found. Use --python=/path/to/python"
-    fi
+    error_exit "Python not found. Use --python=/path/to/python"
 fi
-
 if ! has "$make"
 then
    error_exit "GNU make ($make) not found"
 fi

-if ! check_py_version "$python"; then
+# Note that if the Python conditional here evaluates True we will exit
+# with status 1 which is a shell 'false' value.
+if ! $python -c 'import sys; sys.exit(sys.version_info < (3,6))'; then
  error_exit "Cannot use '$python', Python >= 3.6 is required." \
      "Use --python=/path/to/python to specify a supported Python."
 fi

-# Resolve PATH + suppress writing compiled files
-python="$(command -v "$python") -B"
-
-has_meson() {
-  local python_dir=$(dirname "$python")
-  # PEP405: pyvenv.cfg is either adjacent to the Python executable
-  # or one directory above
-  if test -f $python_dir/pyvenv.cfg || test -f $python_dir/../pyvenv.cfg; then
-    # Ensure that Meson and Python come from the same virtual environment
-    test -x "$python_dir/meson" &&
-      test "$(command -v meson)" -ef "$python_dir/meson"
-  else
-    has meson
-  fi
-}
+# Suppress writing compiled files
+python="$python -B"

 if test -z "$meson"; then
-    if test "$explicit_python" = no && has_meson && version_ge "$(meson --version)" 0.61.5; then
+    if test "$explicit_python" = no && has meson && version_ge "$(meson --version)" 0.61.5; then
        meson=meson
    elif test "$git_submodules_action" != 'ignore' ; then
        meson=git
@@ -1184,12 +1138,12 @@ fi
 cat > $TMPC << EOF
 #if defined(__clang_major__) && defined(__clang_minor__)
 # ifdef __apple_build_version__
-#  if __clang_major__ < 12 || (__clang_major__ == 12 && __clang_minor__ < 0)
-#   error You need at least XCode Clang v12.0 to compile QEMU
+#  if __clang_major__ < 10 || (__clang_major__ == 10 && __clang_minor__ < 0)
+#   error You need at least XCode Clang v10.0 to compile QEMU
 #  endif
 # else
-#  if __clang_major__ < 10 || (__clang_major__ == 10 && __clang_minor__ < 0)
-#   error You need at least Clang v10.0 to compile QEMU
+#  if __clang_major__ < 6 || (__clang_major__ == 6 && __clang_minor__ < 0)
+#   error You need at least Clang v6.0 to compile QEMU
 #  endif
 # endif
 #elif defined(__GNUC__) && defined(__GNUC_MINOR__)
@@ -1202,7 +1156,7 @@ cat > $TMPC << EOF
 int main (void) { return 0; }
 EOF
 if ! compile_prog "" "" ; then
-    error_exit "You need at least GCC v7.4 or Clang v10.0 (or XCode Clang v12.0)"
+    error_exit "You need at least GCC v7.4 or Clang v6.0 (or XCode Clang v10.0)"
 fi

 # Accumulate -Wfoo and -Wno-bar separately.
@@ -1231,10 +1185,6 @@ add_to warn_flags -Wexpansion-to-defined
 add_to warn_flags -Wimplicit-fallthrough=2
 add_to warn_flags -Wmissing-format-attribute

-if test "$targetos" != "darwin"; then
-    add_to warn_flags -Wthread-safety
-fi
-
 nowarn_flags=
 add_to nowarn_flags -Wno-initializer-overrides
 add_to nowarn_flags -Wno-missing-include-dirs
@@ -1311,6 +1261,19 @@ EOF
  fi
 fi

+# Disable -Wmissing-braces on older compilers that warn even for
+# the "universal" C zero initializer {0}.
+cat > $TMPC << EOF
+struct {
+  int a[2];
+} x = {0};
+EOF
+if compile_object "-Werror" "" ; then
+  :
+else
+  QEMU_CFLAGS="$QEMU_CFLAGS -Wno-missing-braces"
+fi
+
 # Our module code doesn't support Windows
 if test "$modules" = "yes" && test "$mingw32" = "yes" ; then
  error_exit "Modules are not available for Windows"
@@ -1350,7 +1313,7 @@ if test "$static" = "yes"; then
    error_exit "-static-pie not available due to missing toolchain support"
  else
    pie="no"
-    QEMU_CFLAGS="-fno-pie $QEMU_CFLAGS"
+    QEMU_CFLAGS="-fno-pie -no-pie $QEMU_CFLAGS"
  fi
 elif test "$pie" = "no"; then
  if compile_prog "-Werror -fno-pie" "-no-pie"; then
@@ -1793,7 +1756,6 @@ fi
 # functions to probe cross compilers

 container="no"
-runc=""
 if test $use_containers = "yes" && (has "docker" || has "podman"); then
    case $($python "$source_path"/tests/docker/docker.py probe) in
        *docker) container=docker ;;
@@ -1802,7 +1764,6 @@ if test $use_containers = "yes" && (has "docker" || has "podman"); then
    esac
    if test "$container" != "no"; then
        docker_py="$python $source_path/tests/docker/docker.py --engine $container"
-        runc=$($python "$source_path"/tests/docker/docker.py probe)
    fi
 fi

@@ -2402,7 +2363,6 @@ fi

 if test "$container" != no; then
    echo "ENGINE=$container" >> $config_host_mak
-    echo "RUNC=$runc" >> $config_host_mak
 fi
 echo "ROMS=$roms" >> $config_host_mak
 echo "MAKE=$make" >> $config_host_mak
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Fabiano Rosas	eab13108cd	tests/qtest: bios-tables-test: Skip if missing configs If we build with --without-default-devices, CONFIG_HPET and CONFIG_PARALLEL are set to N, which makes the respective devices go missing from acpi tables. Signed-off-by: Fabiano Rosas <farosas@suse.de> Reviewed-by: Thomas Huth <thuth@redhat.com>	2023-02-13 18:01:07 -03:00
Fabiano Rosas	750400c56f	tests/qemu-iotests: Require virtio-scsi-pci Check that virtio-scsi-pci is present in the QEMU build before running the tests. Signed-off-by: Fabiano Rosas <farosas@suse.de> Reviewed-by: Thomas Huth <thuth@redhat.com>	2023-02-13 18:01:07 -03:00
Fabiano Rosas	f5ef199312	tests/qtest: Do not include hexloader-test if loader device is not present Signed-off-by: Fabiano Rosas <farosas@suse.de> Reviewed-by: Thomas Huth <thuth@redhat.com>	2023-02-13 18:01:07 -03:00
Fabiano Rosas	c789207417	tests/qtest: Check for devices in bios-tables-test Do not include tests that require devices that are not available in the QEMU build. Signed-off-by: Fabiano Rosas <farosas@suse.de> Acked-by: Michael S. Tsirkin <mst@redhat.com>	2023-02-13 18:01:07 -03:00
Fabiano Rosas	3bf0b7dd7b	tests/qtest: drive_del-test: Skip tests that require missing devices Signed-off-by: Fabiano Rosas <farosas@suse.de> Reviewed-by: Thomas Huth <thuth@redhat.com>	2023-02-13 18:01:07 -03:00
Fabiano Rosas	3864d5e5c6	tests/qtest: Skip unplug tests that use missing devices Signed-off-by: Fabiano Rosas <farosas@suse.de> Reviewed-by: Thomas Huth <thuth@redhat.com>	2023-02-13 18:01:07 -03:00
Fabiano Rosas	8a840ab4c2	tests/qtest: Fix coding style in device-plug-test.c We should not mix declarations and statements in QEMU code. Signed-off-by: Fabiano Rosas <farosas@suse.de> Reviewed-by: Thomas Huth <thuth@redhat.com>	2023-02-13 18:01:07 -03:00
Fabiano Rosas	d32f29f651	tests/qtest: hd-geo-test: Check for missing devices Don't include tests that require devices not available in the QEMU binary. Signed-off-by: Fabiano Rosas <farosas@suse.de> Reviewed-by: Thomas Huth <thuth@redhat.com>	2023-02-13 18:01:07 -03:00
Fabiano Rosas	696cf0c1cd	tests/qtest: Don't build virtio-serial-test.c if device not present The virtconsole device might not be present in the QEMU build that is being tested. Signed-off-by: Fabiano Rosas <farosas@suse.de>	2023-02-13 18:01:07 -03:00
Fabiano Rosas	ef92be0914	tests/qtest: Add dependence on PCIE_PORT for virtio-net-failover.c This test depends on the presence of the pcie-root-port device. Add a build time dependency. Signed-off-by: Fabiano Rosas <farosas@suse.de> Reviewed-by: Thomas Huth <thuth@redhat.com>	2023-02-13 18:01:07 -03:00
Fabiano Rosas	f85bfa0bcb	tests/qtest: Do not run lsi53c895a test if device is not present The tests are built once for all the targets, so as long as one QEMU binary is built with CONFIG_LSI_SCSI_PCI=y, this test will run. However some binaries might not include the device. So check this again in runtime. Signed-off-by: Fabiano Rosas <farosas@suse.de> Reviewed-by: Thomas Huth <thuth@redhat.com>	2023-02-13 18:01:07 -03:00
Fabiano Rosas	ecbd3f095e	tests/qtest: Skip PXE tests for missing devices Check if the devices we're trying to add are present in the QEMU binary. They could have been removed from the build via Kconfig or the --without-default-devices option. Signed-off-by: Fabiano Rosas <farosas@suse.de> Reviewed-by: Thomas Huth <thuth@redhat.com>	2023-02-13 18:01:07 -03:00