tree e13e0fafe22ef7bcd48f9fdf2fbcc04b75ca9966
parent ed8b4afe5ff290ae119237e4fa2142e9f1832230
author Nikolay Nikolaev <n.nikolaev@virtualopensystems.com> 1401192322 +0300
committer Michael S. Tsirkin <mst@redhat.com> 1403185316 +0300

vhost_net_init will use VhostNetOptions to get all its arguments

vhost_dev_init will replace devfd and devpath with a single opaque argument.
This is initialised with a file descriptor. When TAP is used (through
vhost_net), open /dev/vhost-net and pass the fd as an opaque parameter in
VhostNetOptions. The same applies to vhost-scsi - open /dev/vhost-scsi and
pass the fd.

Signed-off-by: Antonios Motakis <a.motakis@virtualopensystems.com>
Signed-off-by: Nikolay Nikolaev <n.nikolaev@virtualopensystems.com>
Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
