tree ada60845139760d25723bb77ba0c105b023dbd04
parent 9cbaacf999b01b27dc3a22502705178057af66de
author Stefan Hajnoczi <stefanha@redhat.com> 1361356111 +0100
committer Anthony Liguori <aliguori@us.ibm.com> 1361485051 -0600

aio: extract aio_dispatch() from aio_poll()

We will need to loop over AioHandlers calling ->io_read()/->io_write()
when aio_poll() is converted from select(2) to g_poll(2).

Luckily the code for this already exists, extract it into the new
aio_dispatch() function.

Two small changes:

 * aio_poll() checks !node->deleted to avoid calling handlers that have
   been deleted.

 * Fix typo 'then' -> 'them' in aio_poll() comment.

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Laszlo Ersek <lersek@redhat.com>
Message-id: 1361356113-11049-9-git-send-email-stefanha@redhat.com
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
