tree a6a63bb73444688e7994a4a40eef3a38607f9251
parent 49110174f8835ec3d5ca7fc076ee1f51c18564fe
author Paolo Bonzini <pbonzini@redhat.com> 1424449612 +0100
committer Kevin Wolf <kwolf@redhat.com> 1430228168 +0200

iothread: release iothread around aio_poll

This is the first step towards having fine-grained critical sections in
dataplane threads, which resolves lock ordering problems between
address_space_* functions (which need the BQL when doing MMIO, even
after we complete RCU-based dispatch) and the AioContext.

Because AioContext does not use contention callbacks anymore, the
unit test has to be changed.

Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 1424449612-18215-4-git-send-email-pbonzini@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
