From 93433b639d07eed499612b32286122791b0d3639 Mon Sep 17 00:00:00 2001 From: Yuanhan Liu Date: Sat, 1 Apr 2017 15:22:42 +0800 Subject: [PATCH] vhost: make notify ops per vhost driver Assume there is an application both support vhost-user net and vhost-user scsi, the callback should be different. Making notify ops per vhost driver allow application define different set of callbacks for different driver. Signed-off-by: Yuanhan Liu Reviewed-by: Maxime Coquelin --- doc/guides/prog_guide/vhost_lib.rst | 2 +- doc/guides/rel_notes/release_17_05.rst | 4 ++++ drivers/net/vhost/rte_eth_vhost.c | 20 ++++++++-------- examples/tep_termination/main.c | 7 +++++- examples/vhost/main.c | 9 ++++++-- lib/librte_vhost/rte_virtio_net.h | 3 ++- lib/librte_vhost/socket.c | 32 ++++++++++++++++++++++++++ lib/librte_vhost/vhost.c | 16 +------------ lib/librte_vhost/vhost.h | 5 +++- lib/librte_vhost/vhost_user.c | 22 +++++++++++++----- 10 files changed, 84 insertions(+), 36 deletions(-) diff --git a/doc/guides/prog_guide/vhost_lib.rst b/doc/guides/prog_guide/vhost_lib.rst index 6a4d206f6e..40f3b3b4f5 100644 --- a/doc/guides/prog_guide/vhost_lib.rst +++ b/doc/guides/prog_guide/vhost_lib.rst @@ -122,7 +122,7 @@ The following is an overview of some key Vhost API functions: starts an infinite loop, therefore it should be called in a dedicated thread. -* ``rte_vhost_driver_callback_register(virtio_net_device_ops)`` +* ``rte_vhost_driver_callback_register(path, virtio_net_device_ops)`` This function registers a set of callbacks, to let DPDK applications take the appropriate action when some events happen. The following events are diff --git a/doc/guides/rel_notes/release_17_05.rst b/doc/guides/rel_notes/release_17_05.rst index da95637751..5cdbe36f08 100644 --- a/doc/guides/rel_notes/release_17_05.rst +++ b/doc/guides/rel_notes/release_17_05.rst @@ -292,6 +292,10 @@ API Changes * ``rte_eth_vhost_feature_enable`` * ``rte_eth_vhost_feature_get`` + * The vhost API ``rte_vhost_driver_callback_register(ops)`` is reworked to + be per vhost-user socket file. Thus, it takes one more argument: + ``rte_vhost_driver_callback_register(path, ops)``. + ABI Changes ----------- diff --git a/drivers/net/vhost/rte_eth_vhost.c b/drivers/net/vhost/rte_eth_vhost.c index fbdfecb7ce..33cfe5ffcc 100644 --- a/drivers/net/vhost/rte_eth_vhost.c +++ b/drivers/net/vhost/rte_eth_vhost.c @@ -695,6 +695,12 @@ vring_state_changed(int vid, uint16_t vring, int enable) return 0; } +static struct virtio_net_device_ops vhost_ops = { + .new_device = new_device, + .destroy_device = destroy_device, + .vring_state_changed = vring_state_changed, +}; + int rte_eth_vhost_get_queue_event(uint8_t port_id, struct rte_eth_vhost_queue_event *event) @@ -764,15 +770,6 @@ rte_eth_vhost_get_vid_from_port_id(uint8_t port_id) static void * vhost_driver_session(void *param __rte_unused) { - static struct virtio_net_device_ops vhost_ops; - - /* set vhost arguments */ - vhost_ops.new_device = new_device; - vhost_ops.destroy_device = destroy_device; - vhost_ops.vring_state_changed = vring_state_changed; - if (rte_vhost_driver_callback_register(&vhost_ops) < 0) - RTE_LOG(ERR, PMD, "Can't register callbacks\n"); - /* start event handling */ rte_vhost_driver_session_start(); @@ -1116,6 +1113,11 @@ eth_dev_vhost_create(const char *name, char *iface_name, int16_t queues, if (rte_vhost_driver_register(iface_name, flags)) goto error; + if (rte_vhost_driver_callback_register(iface_name, &vhost_ops) < 0) { + RTE_LOG(ERR, PMD, "Can't register callbacks\n"); + goto error; + } + /* We need only one message handling thread */ if (rte_atomic16_add_return(&nb_started_ports, 1) == 1) { if (vhost_driver_session_start()) diff --git a/examples/tep_termination/main.c b/examples/tep_termination/main.c index 8097dcdd44..18b977e64d 100644 --- a/examples/tep_termination/main.c +++ b/examples/tep_termination/main.c @@ -1256,7 +1256,12 @@ main(int argc, char *argv[]) rte_vhost_driver_disable_features(dev_basename, 1ULL << VIRTIO_NET_F_MRG_RXBUF); - rte_vhost_driver_callback_register(&virtio_net_device_ops); + ret = rte_vhost_driver_callback_register(dev_basename, + &virtio_net_device_ops); + if (ret != 0) { + rte_exit(EXIT_FAILURE, + "failed to register vhost driver callbacks.\n"); + } rte_vhost_driver_session_start(); diff --git a/examples/vhost/main.c b/examples/vhost/main.c index 972a6a8619..72a9d69cd2 100644 --- a/examples/vhost/main.c +++ b/examples/vhost/main.c @@ -1538,9 +1538,14 @@ main(int argc, char *argv[]) rte_vhost_driver_enable_features(file, 1ULL << VIRTIO_NET_F_CTRL_RX); } - } - rte_vhost_driver_callback_register(&virtio_net_device_ops); + ret = rte_vhost_driver_callback_register(file, + &virtio_net_device_ops); + if (ret != 0) { + rte_exit(EXIT_FAILURE, + "failed to register vhost driver callbacks.\n"); + } + } rte_vhost_driver_session_start(); return 0; diff --git a/lib/librte_vhost/rte_virtio_net.h b/lib/librte_vhost/rte_virtio_net.h index 08bf965aac..39e3611790 100644 --- a/lib/librte_vhost/rte_virtio_net.h +++ b/lib/librte_vhost/rte_virtio_net.h @@ -137,7 +137,8 @@ int rte_vhost_driver_disable_features(const char *path, uint64_t features); int rte_vhost_driver_get_features(const char *path, uint64_t *features); /* Register callbacks. */ -int rte_vhost_driver_callback_register(struct virtio_net_device_ops const * const); +int rte_vhost_driver_callback_register(const char *path, + struct virtio_net_device_ops const * const ops); /* Start vhost driver session blocking loop. */ int rte_vhost_driver_session_start(void); diff --git a/lib/librte_vhost/socket.c b/lib/librte_vhost/socket.c index 416b1fdc3e..aa948b9820 100644 --- a/lib/librte_vhost/socket.c +++ b/lib/librte_vhost/socket.c @@ -77,6 +77,8 @@ struct vhost_user_socket { */ uint64_t supported_features; uint64_t features; + + struct virtio_net_device_ops const *notify_ops; }; struct vhost_user_connection { @@ -743,6 +745,36 @@ rte_vhost_driver_unregister(const char *path) return -1; } +/* + * Register ops so that we can add/remove device to data core. + */ +int +rte_vhost_driver_callback_register(const char *path, + struct virtio_net_device_ops const * const ops) +{ + struct vhost_user_socket *vsocket; + + pthread_mutex_lock(&vhost_user.mutex); + vsocket = find_vhost_user_socket(path); + if (vsocket) + vsocket->notify_ops = ops; + pthread_mutex_unlock(&vhost_user.mutex); + + return vsocket ? 0 : -1; +} + +struct virtio_net_device_ops const * +vhost_driver_callback_get(const char *path) +{ + struct vhost_user_socket *vsocket; + + pthread_mutex_lock(&vhost_user.mutex); + vsocket = find_vhost_user_socket(path); + pthread_mutex_unlock(&vhost_user.mutex); + + return vsocket ? vsocket->notify_ops : NULL; +} + int rte_vhost_driver_session_start(void) { diff --git a/lib/librte_vhost/vhost.c b/lib/librte_vhost/vhost.c index 7b40a922a6..7d7bb3cb19 100644 --- a/lib/librte_vhost/vhost.c +++ b/lib/librte_vhost/vhost.c @@ -51,9 +51,6 @@ struct virtio_net *vhost_devices[MAX_VHOST_DEVICE]; -/* device ops to add/remove device to/from data core. */ -struct virtio_net_device_ops const *notify_ops; - struct virtio_net * get_device(int vid) { @@ -253,7 +250,7 @@ vhost_destroy_device(int vid) if (dev->flags & VIRTIO_DEV_RUNNING) { dev->flags &= ~VIRTIO_DEV_RUNNING; - notify_ops->destroy_device(vid); + dev->notify_ops->destroy_device(vid); } cleanup_device(dev, 1); @@ -396,14 +393,3 @@ rte_vhost_enable_guest_notification(int vid, uint16_t queue_id, int enable) dev->virtqueue[queue_id]->used->flags = VRING_USED_F_NO_NOTIFY; return 0; } - -/* - * Register ops so that we can add/remove device to data core. - */ -int -rte_vhost_driver_callback_register(struct virtio_net_device_ops const * const ops) -{ - notify_ops = ops; - - return 0; -} diff --git a/lib/librte_vhost/vhost.h b/lib/librte_vhost/vhost.h index 692691b897..6186216bf4 100644 --- a/lib/librte_vhost/vhost.h +++ b/lib/librte_vhost/vhost.h @@ -185,6 +185,8 @@ struct virtio_net { struct ether_addr mac; uint16_t mtu; + struct virtio_net_device_ops const *notify_ops; + uint32_t nr_guest_pages; uint32_t max_guest_pages; struct guest_page *guest_pages; @@ -288,7 +290,6 @@ gpa_to_hpa(struct virtio_net *dev, uint64_t gpa, uint64_t size) return 0; } -struct virtio_net_device_ops const *notify_ops; struct virtio_net *get_device(int vid); int vhost_new_device(void); @@ -301,6 +302,8 @@ int alloc_vring_queue_pair(struct virtio_net *dev, uint32_t qp_idx); void vhost_set_ifname(int, const char *if_name, unsigned int if_len); void vhost_enable_dequeue_zero_copy(int vid); +struct virtio_net_device_ops const *vhost_driver_callback_get(const char *path); + /* * Backend-specific cleanup. * diff --git a/lib/librte_vhost/vhost_user.c b/lib/librte_vhost/vhost_user.c index 65fd0fc3cc..2083640066 100644 --- a/lib/librte_vhost/vhost_user.c +++ b/lib/librte_vhost/vhost_user.c @@ -135,7 +135,7 @@ vhost_user_reset_owner(struct virtio_net *dev) { if (dev->flags & VIRTIO_DEV_RUNNING) { dev->flags &= ~VIRTIO_DEV_RUNNING; - notify_ops->destroy_device(dev->vid); + dev->notify_ops->destroy_device(dev->vid); } cleanup_device(dev, 0); @@ -509,7 +509,7 @@ vhost_user_set_mem_table(struct virtio_net *dev, struct VhostUserMsg *pmsg) /* Remove from the data plane. */ if (dev->flags & VIRTIO_DEV_RUNNING) { dev->flags &= ~VIRTIO_DEV_RUNNING; - notify_ops->destroy_device(dev->vid); + dev->notify_ops->destroy_device(dev->vid); } if (dev->mem) { @@ -693,7 +693,7 @@ vhost_user_set_vring_kick(struct virtio_net *dev, struct VhostUserMsg *pmsg) "dequeue zero copy is enabled\n"); } - if (notify_ops->new_device(dev->vid) == 0) + if (dev->notify_ops->new_device(dev->vid) == 0) dev->flags |= VIRTIO_DEV_RUNNING; } } @@ -727,7 +727,7 @@ vhost_user_get_vring_base(struct virtio_net *dev, /* We have to stop the queue (virtio) if it is running. */ if (dev->flags & VIRTIO_DEV_RUNNING) { dev->flags &= ~VIRTIO_DEV_RUNNING; - notify_ops->destroy_device(dev->vid); + dev->notify_ops->destroy_device(dev->vid); } dev->flags &= ~VIRTIO_DEV_READY; @@ -769,8 +769,8 @@ vhost_user_set_vring_enable(struct virtio_net *dev, "set queue enable: %d to qp idx: %d\n", enable, state->index); - if (notify_ops->vring_state_changed) - notify_ops->vring_state_changed(dev->vid, state->index, enable); + if (dev->notify_ops->vring_state_changed) + dev->notify_ops->vring_state_changed(dev->vid, state->index, enable); dev->virtqueue[state->index]->enabled = enable; @@ -984,6 +984,16 @@ vhost_user_msg_handler(int vid, int fd) if (dev == NULL) return -1; + if (!dev->notify_ops) { + dev->notify_ops = vhost_driver_callback_get(dev->ifname); + if (!dev->notify_ops) { + RTE_LOG(ERR, VHOST_CONFIG, + "failed to get callback ops for driver %s\n", + dev->ifname); + return -1; + } + } + ret = read_vhost_message(fd, &msg); if (ret <= 0 || msg.request >= VHOST_USER_MAX) { if (ret < 0) -- 2.20.1