tree 482d5438c0e3f9ca191ad8ce1b9f447c15ee72cf
parent 4f7f46d32c9875004fae1d57ae3c02cc2e6cd6a3
author Asias He <asias@redhat.com> 1364969858 +0800
committer Nicholas Bellinger <nab@linux-iscsi.org> 1365455394 -0700

tcm_vhost: Initialize vq->last_used_idx when set endpoint

This patch fixes guest hang when booting seabios and guest.

  [    0.576238] scsi0 : Virtio SCSI HBA
  [    0.616754] virtio_scsi virtio1: request:id 0 is not a head!

vq->last_used_idx is initialized only when /dev/vhost-scsi is
opened or closed.

   vhost_scsi_open -> vhost_dev_init() -> vhost_vq_reset()
   vhost_scsi_release() -> vhost_dev_cleanup -> vhost_vq_reset()

So, when guest talks to tcm_vhost after seabios does, vq->last_used_idx
still contains the old valule for seabios. This confuses guest.

Fix this by calling vhost_init_used() to init vq->last_used_idx when
we set endpoint.

Signed-off-by: Asias He <asias@redhat.com>
Acked-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Nicholas Bellinger <nab@linux-iscsi.org>
