vhost: support inflight share memory protocol feature
PATCH 1/1 vhost: support inflight share memory protocol feature
This patch introduces two new messages VHOST_USER_GET_INFLIGHT_FD and VHOST_USER_SET_INFLIGHT_FD to support transferring a shared buffer between qemu and backend.
Firstly, qemu uses VHOST_USER_GET_INFLIGHT_FD to get the shared buffer from backend. Then qemu should send it back through VHOST_USER_SET_INFLIGHT_FD each time we start vhost-user.
This shared buffer is used to process inflight I/O when backend reconnect.
--- lib/librte_vhost/rte_vhost.h | 96 ++++++++++ lib/librte_vhost/rte_vhost_version.map | 4 + lib/librte_vhost/vhost.c | 72 ++++++++ lib/librte_vhost/vhost.h | 11 ++ lib/librte_vhost/vhost_user.c | 237 +++++++++++++++++++++++++ lib/librte_vhost/vhost_user.h | 17 +- 6 files changed, 434 insertions(+), 3 deletions(-)
lib/librte_vhost/rte_vhost.h +96 -0
@@ -71,6 +71,10 @@ extern "C" {#define VHOST_USER_PROTOCOL_F_HOST_NOTIFIER 11#endif +#ifndef VHOST_USER_PROTOCOL_F_INFLIGHT_SHMFD +#define VHOST_USER_PROTOCOL_F_INFLIGHT_SHMFD 12 +#endif +/** Indicate whether protocol features negotiation is supported. */ #ifndef VHOST_USER_F_PROTOCOL_FEATURES #define VHOST_USER_F_PROTOCOL_FEATURES 30
@@ -98,12 +102,53 @@ struct rte_vhost_memory {struct rte_vhost_mem_region regions[]; }; +typedef struct VhostUserInflightEntry { +/* Indicate whether this descriptor is inflight or not. +* Only available for head-descriptor. */ +uint8_t inflight; + +uint8_t padding[5 ]; + +/* Maintain a list for the last batch of used descriptors. +* Only available when batching is used for submitting */ +uint16_t next; + +/* Used to preserve the order of fetching available descriptors. +* Only available for head-descriptor. */ +uint64_t counter; +}VhostUserInflightEntry ; + +typedef struct VhostInflightInfo { +/* The feature flags of this region. Now it's initialized to 0. */ +uint64_t feature; + +/* The version of this region. It's 1 currently. +* Zero value indicates an uninitialized buffer */ +uint16_t version; + +/* The size of DescStateSplit array. It's equal to the virtqueue +* size. Slave could get it from queue size field of VhostUserInflight. */ +uint16_t desc_num; + +/* The head of list that track the last batch of used descriptors. */ +uint16_t last_batch_head; + +/* Store the idx value of used ring */ +uint16_t used_idx; + +/* Used to track the state of each descriptor in descriptor table */ +VhostUserInflightEntry desc[0 ]; +}VhostInflightInfo ; +struct rte_vhost_vring {struct vring_desc *desc;struct vring_avail *avail;struct vring_used *used;uint64_t log_guest_addr; +VhostInflightInfo *inflight; +int inflight_flag; +/** Deprecated, use rte_vhost_vring_call() instead. */ int callfd;
@@ -603,6 +648,22 @@ uint16_t rte_vhost_dequeue_burst(int vid, uint16_t queue_id,*/ int rte_vhost_get_mem_table (int vid,struct rte_vhost_memory **mem); +/** +* Get guest vring info including the vring address, vring size, inflight, etc. +* +* @param vid +* vhost device ID +* @param vring_idx +* vring index +* @param vring +* the structure to hold the requested vring info +* @return +* 0 on success, -1 on failure +*/ +int __rte_experimental +rte_vhost_get_vhost_vring_with_inflight (int vid,uint16_t vring_idx, +struct rte_vhost_vring *vring); +/** * Get guest vring info, including the vring address, vring size, etc. *
@@ -631,6 +692,41 @@ int rte_vhost_get_vhost_vring(int vid, uint16_t vring_idx,*/ int rte_vhost_vring_call (int vid,uint16_t vring_idx); +/** +* set inflight flag for a entry. +* +* @param vring +* the structure to hold the requested vring info +* @param idx +* inflight entry index +*/ +void __rte_experimental rte_vhost_set_inflight(struct rte_vhost_vring *vring, +uint16_t idx); + +/** +* clear inflight flag for a entry. +* +* @param vring +* the structure to hold the requested vring info +* @param last_used_idx +* next free used_idx +* @param idx +* inflight entry index +*/ +void __rte_experimental rte_vhost_clr_inflight(struct rte_vhost_vring *vring, +uint16_t last_used_idx,uint16_t idx); + +/** +* set last inflight io index. +* +* @param vring +* the structure to hold the requested vring info +* @param idx +* inflight entry index +*/ +void __rte_experimental rte_vhost_set_last_inflight_io(struct rte_vhost_vring *vring, +uint16_t idx); +/** * Get vhost RX queue avail count. *
lib/librte_vhost/rte_vhost_version.map +4 -0
@@ -87,4 +87,8 @@ EXPERIMENTAL { rte_vdpa_relay_vring_used; rte_vhost_extern_callback_register; rte_vhost_driver_set_protocol_features; + rte_vhost_set_inflight; + rte_vhost_clr_inflight; + rte_vhost_set_last_inflight_io; + rte_vhost_get_vhost_with_inflight; };
lib/librte_vhost/vhost.c +72 -0
90 lines not on this page · raw message
lib/librte_vhost/vhost.h +11 -0
@@ -128,6 +128,10 @@ struct vhost_virtqueue {/* Physical address of used ring, for logging */ uint64_t log_guest_addr; +/* Inflight share memory info */ +VhostInflightInfo *inflight; +bool inflight_flag; +uint16_t nr_zmbuf;uint16_t zmbuf_size;uint16_t last_zmbuf_idx;
@@ -286,6 +290,12 @@ struct guest_page {uint64_t size; }; +typedef struct VuDevInflightInfo { +int fd; +void *addr; +uint64_t size; +}VuDevInflightInfo ; +/** * Device structure contains all configuration information relating * to the device.
@@ -303,6 +313,7 @@ struct virtio_net {uint32_t nr_vring;int dequeue_zero_copy;struct vhost_virtqueue *virtqueue[VHOST_MAX_QUEUE_PAIRS *2 ]; +VuDevInflightInfo inflight_info;#define IF_NAME_SZ (PATH_MAX > IFNAMSIZ ? PATH_MAX : IFNAMSIZ)char ifname[IF_NAME_SZ ];uint64_t log_size;
lib/librte_vhost/vhost_user.c +237 -0
285 lines not on this page · raw message
lib/librte_vhost/vhost_user.h +14 -3
@@ -22,8 +22,8 @@ (1ULL << VHOST_USER_PROTOCOL_F_SLAVE_REQ) | \ (1ULL << VHOST_USER_PROTOCOL_F_CRYPTO_SESSION) | \ (1ULL << VHOST_USER_PROTOCOL_F_SLAVE_SEND_FD) | \ - (1ULL << VHOST_USER_PROTOCOL_F_HOST_NOTIFIER) | \ - (1ULL << VHOST_USER_PROTOCOL_F_PAGEFAULT)) + (1ULL << VHOST_USER_PROTOCOL_F_HOST_NOTIFIER)) + typedef enum VhostUserRequest { VHOST_USER_NONE = 0,
@@ -54,7 +54,9 @@ typedef enum VhostUserRequest {VHOST_USER_POSTCOPY_ADVISE =28 ,VHOST_USER_POSTCOPY_LISTEN =29 ,VHOST_USER_POSTCOPY_END =30 , - VHOST_USER_MAX = 31 +VHOST_USER_GET_INFLIGHT_FD =31 , +VHOST_USER_SET_INFLIGHT_FD =32 , + VHOST_USER_MAX = 33 } VhostUserRequest; typedef enum VhostUserSlaveRequest {
@@ -112,6 +114,13 @@ typedef struct VhostUserVringArea {uint64_t offset; } VhostUserVringArea; +typedef struct VhostUserInflight { +uint64_t mmap_size; +uint64_t mmap_offset; +uint16_t num_queues; +uint16_t queue_size; +}VhostUserInflight ; + typedef struct VhostUserMsg { union { uint32_t master; /* a VhostUserRequest value */
@@ -131,6 +140,7 @@ typedef struct VhostUserMsg {struct vhost_vring_addr addr;VhostUserMemory memory;VhostUserLog log; +VhostUserInflight inflight;struct vhost_iotlb_msg iotlb;VhostUserCryptoSessionParam crypto_session;VhostUserVringArea area;
@@ -148,6 +158,7 @@ typedef struct VhostUserMsg {/* vhost_user.c */ int vhost_user_msg_handler (int vid,int fd);int vhost_user_iotlb_miss (struct virtio_net *dev,uint64_t iova,uint8_t perm); +void *inflight_mem_alloc (const char *name,size_t size,int *fd);/* socket.c */ int read_fd_message(int sockfd, char *buf, int buflen, int *fds, int max_fds,
Signature · 1 line
2.17.2
You need to specify the revision number when using git format-patch. You can see the 'contributing' section in the documentation for more information.
Quoted 8 lines · JinYu
This patch introduces two new messages
VHOST_USER_GET_INFLIGHT_FDandVHOST_USER_SET_INFLIGHT_FDto support transferring a shared buffer between qemu and backend.Firstly, qemu uses
VHOST_USER_GET_INFLIGHT_FDto get the shared buffer from backend. Then qemu should send it back throughVHOST_USER_SET_INFLIGHT_FDeach time we start vhost-user.
Quoted 7 lines
This shared buffer is used to process inflight I/O when backend reconnect.
Signed-off-by lilin <[email protected]>Signed-off-by Ni Xun <[email protected]>Signed-off-by Zhang Yu <[email protected]>Signed-off-by JinYu <[email protected]>
The correct format for names is Firstname Lastname.
Quoted 105 lines
--- lib/librte_vhost/rte_vhost.h | 96 ++++++++++ lib/librte_vhost/rte_vhost_version.map | 4 + lib/librte_vhost/vhost.c | 72 ++++++++ lib/librte_vhost/vhost.h | 11 ++ lib/librte_vhost/vhost_user.c | 237 +++++++++++++++++++++++++ lib/librte_vhost/vhost_user.h | 17 +- 6 files changed, 434 insertions(+), 3 deletions(-)lib/librte_vhost/rte_vhost.h +61
-0@@ -71,6 +71,10 @@ extern "C" {#define VHOST_USER_PROTOCOL_F_HOST_NOTIFIER 11#endif +#ifndef VHOST_USER_PROTOCOL_F_INFLIGHT_SHMFD +#define VHOST_USER_PROTOCOL_F_INFLIGHT_SHMFD 12 +#endif +/** Indicate whether protocol features negotiation is supported. */ #ifndef VHOST_USER_F_PROTOCOL_FEATURES #define VHOST_USER_F_PROTOCOL_FEATURES 30@@ -98,12 +102,53 @@ struct rte_vhost_memory {struct rte_vhost_mem_region regions[]; }; +typedef struct VhostUserInflightEntry { +/* Indicate whether this descriptor is inflight or not. +* Only available for head-descriptor. */ +uint8_t inflight; + +uint8_t padding[5 ]; + +/* Maintain a list for the last batch of used descriptors. +* Only available when batching is used for submitting */ +uint16_t next; + +/* Used to preserve the order of fetching available descriptors. +* Only available for head-descriptor. */ +uint64_t counter; +}VhostUserInflightEntry ; + +typedef struct VhostInflightInfo { +/* The feature flags of this region. Now it's initialized to 0. */ +uint64_t feature; + +/* The version of this region. It's 1 currently. +* Zero value indicates an uninitialized buffer */ +uint16_t version; + +/* The size of DescStateSplit array. It's equal to the virtqueue +* size. Slave could get it from queue size field of VhostUserInflight. */ +uint16_t desc_num; + +/* The head of list that track the last batch of used descriptors. */ +uint16_t last_batch_head; + +/* Store the idx value of used ring */ +uint16_t used_idx; + +/* Used to track the state of each descriptor in descriptor table */ +VhostUserInflightEntry desc[0 ]; +}VhostInflightInfo ; +struct rte_vhost_vring {struct vring_desc *desc;struct vring_avail *avail;struct vring_used *used;uint64_t log_guest_addr; +VhostInflightInfo *inflight; +int inflight_flag; +/** Deprecated, use rte_vhost_vring_call() instead. */ int callfd;@@ -603,6 +648,22 @@ uint16_t rte_vhost_dequeue_burst(int vid, uint16_t queue_id,*/ int rte_vhost_get_mem_table (int vid,struct rte_vhost_memory **mem); +/** +* Get guest vring info including the vring address, vring size, inflight, etc. +* +* @param vid +* vhost device ID +* @param vring_idx +* vring index +* @param vring +* the structure to hold the requested vring info +* @return +* 0 on success, -1 on failure +*/ +int __rte_experimental +rte_vhost_get_vhost_vring_with_inflight (int vid,uint16_t vring_idx, +struct rte_vhost_vring *vring); +/** * Get guest vring info, including the vring address, vring size, etc. * @@ -631,6 +692,41 @@ int rte_vhost_get_vhost_vring(int vid, uint16_t vring_idx,*/ int rte_vhost_vring_call (int vid,uint16_t vring_idx);
lib/librte_vhost/rte_vhost.h int rte_vhost_get_vhost_vring(int vid, uint16_t vring_idx, · line 704
Quoted 10 lines
lib/librte_vhost/rte_vhost.h +10
-0+/** +* set inflight flag for a entry. +* +* @param vring +* the structure to hold the requested vring info +* @param idx +* inflight entry index +*/ +void __rte_experimental rte_vhost_set_inflight(struct rte_vhost_vring *vring, +uint16_t idx);
You didn't took comments made on previous revision into account.
Quoted 420 lines
lib/librte_vhost/rte_vhost.h +25
-0+ +/** +* clear inflight flag for a entry. +* +* @param vring +* the structure to hold the requested vring info +* @param last_used_idx +* next free used_idx +* @param idx +* inflight entry index +*/ +void __rte_experimental rte_vhost_clr_inflight(struct rte_vhost_vring *vring, +uint16_t last_used_idx,uint16_t idx); + +/** +* set last inflight io index. +* +* @param vring +* the structure to hold the requested vring info +* @param idx +* inflight entry index +*/ +void __rte_experimental rte_vhost_set_last_inflight_io(struct rte_vhost_vring *vring, +uint16_t idx); +/** * Get vhost RX queue avail count. * lib/librte_vhost/rte_vhost_version.map +4
-0@@ -87,4 +87,8 @@ EXPERIMENTAL { rte_vdpa_relay_vring_used; rte_vhost_extern_callback_register; rte_vhost_driver_set_protocol_features; + rte_vhost_set_inflight; + rte_vhost_clr_inflight; + rte_vhost_set_last_inflight_io; + rte_vhost_get_vhost_with_inflight; };lib/librte_vhost/vhost.c +72
-0@@ -240,6 +240,8 @@ cleanup_vq(struct vhost_virtqueue *vq, int destroy)close (vq->callfd);if (vq->kickfd >=0 )close (vq->kickfd); +if (vq->inflight) + vq->inflight =NULL ; }/* @@ -726,6 +728,41 @@ rte_vhost_get_mem_table(int vid, struct rte_vhost_memory **mem)return 0 ; } +int __rte_experimental +rte_vhost_get_vhost_vring_with_inflight (int vid,uint16_t vring_idx, +struct rte_vhost_vring *vring) +{ +struct virtio_net *dev; +struct vhost_virtqueue *vq; + + dev =get_device (vid); +if (dev ==NULL || vring ==NULL ) +return -1 ; + +if (vring_idx >=VHOST_MAX_VRING ) +return -1 ; + + vq = dev->virtqueue[vring_idx]; +if (!vq) +return -1 ; + + vring->desc = vq->desc; + vring->avail = vq->avail; + vring->used = vq->used; + vring->log_guest_addr = vq->log_guest_addr; + + vring->callfd = vq->callfd; + vring->kickfd = vq->kickfd; + vring->size = vq->size; + + vring->inflight = vq->inflight; + + vring->inflight_flag = vq->inflight_flag; + vq->inflight_flag =0 ; + +return 0 ; +} +int rte_vhost_get_vhost_vring (int vid,uint16_t vring_idx,struct rte_vhost_vring *vring)@@ -781,6 +818,41 @@ rte_vhost_vring_call(int vid, uint16_t vring_idx)return 0 ; } +void __rte_experimental +rte_vhost_set_inflight (struct rte_vhost_vring *vring,uint16_t idx) +{ +VhostInflightInfo *inflight = vring->inflight; +if (unlikely (!inflight)) +return ; + inflight->desc[idx].inflight =1 ; +} + +void __rte_experimental +rte_vhost_clr_inflight (struct rte_vhost_vring *vring, +uint16_t last_used_idx,uint16_t idx) +{ +VhostInflightInfo *inflight = vring->inflight; + +if (unlikely (!inflight)) +return ; + +rte_compiler_barrier (); + inflight->desc[idx].inflight =0 ; +rte_compiler_barrier (); + inflight->used_idx = last_used_idx; +} + +void __rte_experimental +rte_vhost_set_last_inflight_io (struct rte_vhost_vring *vring,uint16_t idx) +{ +VhostInflightInfo *inflight = vring->inflight; + +if (unlikely (!inflight)) +return ; + + inflight->last_batch_head = idx; +} +uint16_t rte_vhost_avail_entries (int vid,uint16_t queue_id) {lib/librte_vhost/vhost.h +11
-0@@ -128,6 +128,10 @@ struct vhost_virtqueue {/* Physical address of used ring, for logging */ uint64_t log_guest_addr; +/* Inflight share memory info */ +VhostInflightInfo *inflight; +bool inflight_flag; +uint16_t nr_zmbuf;uint16_t zmbuf_size;uint16_t last_zmbuf_idx;@@ -286,6 +290,12 @@ struct guest_page {uint64_t size; }; +typedef struct VuDevInflightInfo { +int fd; +void *addr; +uint64_t size; +}VuDevInflightInfo ; +/** * Device structure contains all configuration information relating * to the device. @@ -303,6 +313,7 @@ struct virtio_net {uint32_t nr_vring;int dequeue_zero_copy;struct vhost_virtqueue *virtqueue[VHOST_MAX_QUEUE_PAIRS *2 ]; +VuDevInflightInfo inflight_info;#define IF_NAME_SZ (PATH_MAX > IFNAMSIZ ? PATH_MAX : IFNAMSIZ)char ifname[IF_NAME_SZ ];uint64_t log_size;lib/librte_vhost/vhost_user.c +203
-0@@ -31,6 +31,8 @@#include <sys/stat.h> #include <sys/syscall.h> #include <assert.h> +#include <sys/syscall.h> +#include <asm/unistd.h> #ifdef RTE_LIBRTE_VHOST_NUMA #include <numaif.h> #endif @@ -49,6 +51,14 @@#define VIRTIO_MIN_MTU 68#define VIRTIO_MAX_MTU 65535 +#define INFLIGHT_ALIGNMENT 64 +#define INFLIGHT_VERSION 0xabcd + +#define CLOEXEC 0x0001U + +#define ALIGN_DOWN (n, m) ((n) / (m) * (m)) +#define ALIGN_UP (n, m) ALIGN_DOWN((n) + (m) - 1, (m)) +static const char *vhost_message_str[VHOST_USER_MAX ] = { [VHOST_USER_NONE ] ="VHOST_USER_NONE" , [VHOST_USER_GET_FEATURES ] ="VHOST_USER_GET_FEATURES" ,@@ -78,6 +88,8 @@ static const char *vhost_message_str[VHOST_USER_MAX] = { [VHOST_USER_POSTCOPY_ADVISE] = "VHOST_USER_POSTCOPY_ADVISE", [VHOST_USER_POSTCOPY_LISTEN] = "VHOST_USER_POSTCOPY_LISTEN", [VHOST_USER_POSTCOPY_END] = "VHOST_USER_POSTCOPY_END", + [VHOST_USER_GET_INFLIGHT_FD] = "VHOST_USER_GET_INFLIGHT_FD", + [VHOST_USER_SET_INFLIGHT_FD] = "VHOST_USER_SET_INFLIGHT_FD", };static int send_vhost_reply (int sockfd,struct VhostUserMsg *msg);@@ -160,6 +172,16 @@ vhost_backend_cleanup(struct virtio_net *dev) dev->log_addr =0 ; } +if (dev->inflight_info.addr) { +munmap (dev->inflight_info.addr, dev->inflight_info.size); + dev->inflight_info.addr =NULL ; + } + +if (dev->inflight_info.fd >0 ) { +close (dev->inflight_info.fd); + dev->inflight_info.fd =-1 ; + } +if (dev->slave_req_fd >=0 ) {close (dev->slave_req_fd); dev->slave_req_fd =-1 ;@@ -1165,6 +1187,184 @@ virtio_is_ready(struct virtio_net *dev)return 1 ; } +static int mem_create (const char *name,unsigned int flags) +{ +#ifdef __NR_memfd_create +return syscall (__NR_memfd_create, name, flags); +#else +return -1 ; +#endif +} + +void *inflight_mem_alloc (const char *name,size_t size,int *fd) +{ +void *ptr; +int mfd =-1 ; +char fname[20 ] ="/tmp/memfd-XXXXXX" ; + + *fd =-1 ; + mfd =mem_create (name,CLOEXEC ); +if (mfd !=-1 ) { +if (ftruncate (mfd, size) ==-1 ) { +RTE_LOG (ERR ,VHOST_CONFIG , +"ftruncate fail for alloc inflight buffer\n" ); +close (mfd); +return NULL ; + } + }else { + mfd =mkstemp (fname); +unlink (fname); + +if (mfd ==-1 ) { +RTE_LOG (ERR ,VHOST_CONFIG , +"mkstemp fail for alloc inflight buffer\n" ); +return NULL ; + } + +if (ftruncate (mfd, size) ==-1 ) { +RTE_LOG (ERR ,VHOST_CONFIG , +"ftruncate fail for alloc inflight buffer\n" ); +close (mfd); +return NULL ; + } + } + + ptr =mmap (0 , size,PROT_READ |PROT_WRITE ,MAP_SHARED , mfd,0 ); +if (ptr ==MAP_FAILED ) { +RTE_LOG (ERR ,VHOST_CONFIG , +"mmap fail for alloc inflight buffer\n" ); +close (mfd); +return NULL ; + } + + *fd = mfd; +return ptr; +} + +static uint32_t get_pervq_shm_size (uint16_t queue_size) +{ +return ALIGN_UP (sizeof (VhostUserInflightEntry) * queue_size + +sizeof (uint16_t ) *4 +sizeof (uint64_t ),INFLIGHT_ALIGNMENT ); +} + +static int +vhost_user_get_inflight_fd (struct virtio_net **pdev,VhostUserMsg *msg, + int main_fd __rte_unused) +{ +int fd; +uint64_t mmap_size; +void *addr; +uint16_t num_queues, queue_size; +struct virtio_net *dev = *pdev; + +if (msg->size !=sizeof (msg->payload.inflight)) { +RTE_LOG (ERR ,VHOST_CONFIG , +"Invalid get_inflight_fd message size is %d" , + msg->size); + msg->payload.inflight.mmap_size =0 ; +return RTE_VHOST_MSG_RESULT_OK ; + } + + num_queues = msg->payload.inflight.num_queues; + queue_size = msg->payload.inflight.queue_size; + +RTE_LOG (INFO ,VHOST_CONFIG ,"get_inflight_fd num_queues: %u\n" , + msg->payload.inflight.num_queues); +RTE_LOG (INFO ,VHOST_CONFIG ,"get_inflight_fd queue_size: %u\n" , + msg->payload.inflight.queue_size); + mmap_size = num_queues *get_pervq_shm_size (queue_size); + + addr =inflight_mem_alloc ("vhost-inflight" , mmap_size, &fd); +if (!addr) { +RTE_LOG (ERR ,VHOST_CONFIG ,"Failed to alloc vhost inflight area" ); + msg->payload.inflight.mmap_size =0 ; +return RTE_VHOST_MSG_RESULT_OK ; + } +memset (addr,0 , mmap_size); + + dev->inflight_info.addr = addr; + dev->inflight_info.size = msg->payload.inflight.mmap_size = mmap_size; + dev->inflight_info.fd = msg->fds[0 ] = fd; + msg->payload.inflight.mmap_offset =0 ; + msg->fd_num =1 ; + +RTE_LOG (INFO ,VHOST_CONFIG , +"send inflight mmap_size: %lu\n" , + msg->payload.inflight.mmap_size); +RTE_LOG (INFO ,VHOST_CONFIG , +"send inflight mmap_offset: %lu\n" , + msg->payload.inflight.mmap_offset); +RTE_LOG (INFO ,VHOST_CONFIG , +"send inflight fd: %d\n" , msg->fds[0 ]); + +return RTE_VHOST_MSG_RESULT_REPLY ; +} + +static int +vhost_user_set_inflight_fd (struct virtio_net **pdev,VhostUserMsg *msg, + int main_fd __rte_unused) +{ +int fd, i; +uint64_t mmap_size, mmap_offset; +uint16_t num_queues, queue_size; +uint32_t pervq_inflight_size; +void *addr; +struct vhost_virtqueue *vq; +struct virtio_net *dev = *pdev; + + fd = msg->fds[0 ]; +if (msg->size !=sizeof (msg->payload.inflight) || fd <0 ) { +RTE_LOG (ERR ,VHOST_CONFIG ,"Invalid set_inflight_fd message size is %d,fd is %d\n" , + msg->size, fd); +return RTE_VHOST_MSG_RESULT_ERR ; + } + + mmap_size = msg->payload.inflight.mmap_size; + mmap_offset = msg->payload.inflight.mmap_offset; + num_queues = msg->payload.inflight.num_queues; + queue_size = msg->payload.inflight.queue_size; + pervq_inflight_size =get_pervq_shm_size (queue_size); + +RTE_LOG (INFO ,VHOST_CONFIG , +"set_inflight_fd mmap_size: %lu\n" , mmap_size); +RTE_LOG (INFO ,VHOST_CONFIG , +"set_inflight_fd mmap_offset: %lu\n" , mmap_offset); +RTE_LOG (INFO ,VHOST_CONFIG , +"set_inflight_fd num_queues: %u\n" , num_queues); +RTE_LOG (INFO ,VHOST_CONFIG , +"set_inflight_fd queue_size: %u\n" , queue_size); +RTE_LOG (INFO ,VHOST_CONFIG , +"set_inflight_fd fd: %d\n" , fd); +RTE_LOG (INFO ,VHOST_CONFIG , +"set_inflight_fd pervq_inflight_size: %d\n" , + pervq_inflight_size); + +if (dev->inflight_info.addr) +munmap (dev->inflight_info.addr, dev->inflight_info.size); + + addr =mmap (0 , mmap_size,PROT_READ |PROT_WRITE ,MAP_SHARED , + fd, mmap_offset); +if (addr ==MAP_FAILED ) { +RTE_LOG (ERR ,VHOST_CONFIG ,"failed to mmap share memory.\n" ); +return RTE_VHOST_MSG_RESULT_ERR ; + } + +if (dev->inflight_info.fd) +close (dev->inflight_info.fd); + + dev->inflight_info.fd = fd; + dev->inflight_info.addr = addr; + dev->inflight_info.size = mmap_size; + +for (i =0 ; i < num_queues; i++) { + vq = dev->virtqueue[i]; + vq->inflight = (VhostInflightInfo *)addr; + addr = (void *)((char *)addr + pervq_inflight_size); + } + +return RTE_VHOST_MSG_RESULT_OK ; +} +static int vhost_user_set_vring_call (struct virtio_net **pdev,struct VhostUserMsg *msg, int main_fd __rte_unused)@@ -1201,6 +1401,35 @@ static int vhost_user_set_vring_err(struct virtio_net **pdev __rte_unused,return RTE_VHOST_MSG_RESULT_OK ; } +static int +vhost_check_queue_inflights (struct virtio_net *dev,struct vhost_virtqueue *vq) +{
lib/librte_vhost/vhost_user.c static int vhost_user_set_vring_err(struct virtio_net **pdev __rte_unused, · line 1416
Quoted 10 lines
lib/librte_vhost/vhost_user.c +10
-0+uint16_t i =0 ; + +if (!(dev->protocol_features &VHOST_USER_PROTOCOL_F_INFLIGHT_SHMFD )) +return RTE_VHOST_MSG_RESULT_OK ; + +if ((!vq->inflight)) +return RTE_VHOST_MSG_RESULT_ERR ; + +/* TODO */ +/* should check whether the feature is negotiated first. */
Why not just do the feature check now?
Quoted 98 lines
lib/librte_vhost/vhost_user.c +24
-0+ +if (!vq->inflight->version) { + vq->inflight->version =INFLIGHT_VERSION ; +return RTE_VHOST_MSG_RESULT_OK ; + } + +for (i =0 ; i < vq->size; i++) { +if (vq->inflight->desc[i].inflight ==1 ) { + vq->inflight_flag =1 ; +break ; + } + } + +return RTE_VHOST_MSG_RESULT_OK ; +} +static int vhost_user_set_vring_kick (struct virtio_net **pdev,struct VhostUserMsg *msg, int main_fd __rte_unused)@@ -1242,6 +1471,12 @@ vhost_user_set_vring_kick(struct virtio_net **pdev, struct VhostUserMsg *msg,close (vq->kickfd); vq->kickfd = file.fd; +if (vhost_check_queue_inflights (dev, vq)) { +RTE_LOG (ERR ,VHOST_CONFIG , +"Failed to inflights for vq: %d\n" , file.index); +return RTE_VHOST_MSG_RESULT_ERR ; + } +return RTE_VHOST_MSG_RESULT_OK ; }@@ -1762,6 +1997,8 @@ static vhost_message_handler_t vhost_message_handlers[VHOST_USER_MAX] = { [VHOST_USER_POSTCOPY_ADVISE] = vhost_user_set_postcopy_advise, [VHOST_USER_POSTCOPY_LISTEN] = vhost_user_set_postcopy_listen, [VHOST_USER_POSTCOPY_END] = vhost_user_postcopy_end, + [VHOST_USER_GET_INFLIGHT_FD] = vhost_user_get_inflight_fd, + [VHOST_USER_SET_INFLIGHT_FD] = vhost_user_set_inflight_fd, };lib/librte_vhost/vhost_user.h +14
-3@@ -22,8 +22,8 @@ (1ULL << VHOST_USER_PROTOCOL_F_SLAVE_REQ) | \ (1ULL << VHOST_USER_PROTOCOL_F_CRYPTO_SESSION) | \ (1ULL << VHOST_USER_PROTOCOL_F_SLAVE_SEND_FD) | \ - (1ULL << VHOST_USER_PROTOCOL_F_HOST_NOTIFIER) | \ - (1ULL << VHOST_USER_PROTOCOL_F_PAGEFAULT)) + (1ULL << VHOST_USER_PROTOCOL_F_HOST_NOTIFIER)) + typedef enum VhostUserRequest { VHOST_USER_NONE = 0,@@ -54,7 +54,9 @@ typedef enum VhostUserRequest {VHOST_USER_POSTCOPY_ADVISE =28 ,VHOST_USER_POSTCOPY_LISTEN =29 ,VHOST_USER_POSTCOPY_END =30 , - VHOST_USER_MAX = 31 +VHOST_USER_GET_INFLIGHT_FD =31 , +VHOST_USER_SET_INFLIGHT_FD =32 , + VHOST_USER_MAX = 33 } VhostUserRequest; typedef enum VhostUserSlaveRequest {@@ -112,6 +114,13 @@ typedef struct VhostUserVringArea {uint64_t offset; } VhostUserVringArea; +typedef struct VhostUserInflight { +uint64_t mmap_size; +uint64_t mmap_offset; +uint16_t num_queues; +uint16_t queue_size; +}VhostUserInflight ; + typedef struct VhostUserMsg { union { uint32_t master; /* a VhostUserRequest value */@@ -131,6 +140,7 @@ typedef struct VhostUserMsg {struct vhost_vring_addr addr;VhostUserMemory memory;VhostUserLog log; +VhostUserInflight inflight;struct vhost_iotlb_msg iotlb;VhostUserCryptoSessionParam crypto_session;VhostUserVringArea area;@@ -148,6 +158,7 @@ typedef struct VhostUserMsg {/* vhost_user.c */ int vhost_user_msg_handler (int vid,int fd);int vhost_user_iotlb_miss (struct virtio_net *dev,uint64_t iova,uint8_t perm); +void *inflight_mem_alloc (const char *name,size_t size,int *fd);/* socket.c */ int read_fd_message(int sockfd, char *buf, int buflen, int *fds, int max_fds,