* This function adds buffers to the virtio devices RX virtqueue. Buffers can
* be received from the physical port or from another virtio device. A packet
* count is returned to indicate the number of packets that are succesfully
- * added to the RX queue. This function works when mergeable is disabled.
+ * added to the RX queue. This function works when the mbuf is scattered, but
+ * it doesn't support the mergeable feature.
*/
static inline uint32_t __attribute__((always_inline))
virtio_dev_rx(struct virtio_net *dev, uint16_t queue_id,
struct virtio_net_hdr_mrg_rxbuf virtio_hdr = {{0, 0, 0, 0, 0, 0}, 0};
uint64_t buff_addr = 0;
uint64_t buff_hdr_addr = 0;
- uint32_t head[MAX_PKT_BURST], packet_len = 0;
+ uint32_t head[MAX_PKT_BURST];
uint32_t head_idx, packet_success = 0;
uint16_t avail_idx, res_cur_idx;
uint16_t res_base_idx, res_end_idx;
rte_prefetch0(&vq->desc[head[packet_success]]);
while (res_cur_idx != res_end_idx) {
+ uint32_t offset = 0, vb_offset = 0;
+ uint32_t pkt_len, len_to_cpy, data_len, total_copied = 0;
+ uint8_t hdr = 0, uncompleted_pkt = 0;
+
/* Get descriptor from available ring */
desc = &vq->desc[head[packet_success]];
/* Copy virtio_hdr to packet and increment buffer address */
buff_hdr_addr = buff_addr;
- packet_len = rte_pktmbuf_data_len(buff) + vq->vhost_hlen;
/*
* If the descriptors are chained the header and data are
* placed in separate buffers.
*/
- if (desc->flags & VRING_DESC_F_NEXT) {
- desc->len = vq->vhost_hlen;
+ if ((desc->flags & VRING_DESC_F_NEXT) &&
+ (desc->len == vq->vhost_hlen)) {
desc = &vq->desc[desc->next];
/* Buffer address translation. */
buff_addr = gpa_to_vva(dev, desc->addr);
- desc->len = rte_pktmbuf_data_len(buff);
} else {
- buff_addr += vq->vhost_hlen;
- desc->len = packet_len;
+ vb_offset += vq->vhost_hlen;
+ hdr = 1;
}
+ pkt_len = rte_pktmbuf_pkt_len(buff);
+ data_len = rte_pktmbuf_data_len(buff);
+ len_to_cpy = RTE_MIN(data_len,
+ hdr ? desc->len - vq->vhost_hlen : desc->len);
+ while (total_copied < pkt_len) {
+ /* Copy mbuf data to buffer */
+ rte_memcpy((void *)(uintptr_t)(buff_addr + vb_offset),
+ (const void *)(rte_pktmbuf_mtod(buff, const char *) + offset),
+ len_to_cpy);
+ PRINT_PACKET(dev, (uintptr_t)(buff_addr + vb_offset),
+ len_to_cpy, 0);
+
+ offset += len_to_cpy;
+ vb_offset += len_to_cpy;
+ total_copied += len_to_cpy;
+
+ /* The whole packet completes */
+ if (total_copied == pkt_len)
+ break;
+
+ /* The current segment completes */
+ if (offset == data_len) {
+ buff = buff->next;
+ offset = 0;
+ data_len = rte_pktmbuf_data_len(buff);
+ }
+
+ /* The current vring descriptor done */
+ if (vb_offset == desc->len) {
+ if (desc->flags & VRING_DESC_F_NEXT) {
+ desc = &vq->desc[desc->next];
+ buff_addr = gpa_to_vva(dev, desc->addr);
+ vb_offset = 0;
+ } else {
+ /* Room in vring buffer is not enough */
+ uncompleted_pkt = 1;
+ break;
+ }
+ }
+ len_to_cpy = RTE_MIN(data_len - offset, desc->len - vb_offset);
+ };
+
/* Update used ring with desc information */
vq->used->ring[res_cur_idx & (vq->size - 1)].id =
head[packet_success];
- vq->used->ring[res_cur_idx & (vq->size - 1)].len = packet_len;
- /* Copy mbuf data to buffer */
- /* FIXME for sg mbuf and the case that desc couldn't hold the mbuf data */
- rte_memcpy((void *)(uintptr_t)buff_addr,
- rte_pktmbuf_mtod(buff, const void *),
- rte_pktmbuf_data_len(buff));
- PRINT_PACKET(dev, (uintptr_t)buff_addr,
- rte_pktmbuf_data_len(buff), 0);
+ /* Drop the packet if it is uncompleted */
+ if (unlikely(uncompleted_pkt == 1))
+ vq->used->ring[res_cur_idx & (vq->size - 1)].len =
+ vq->vhost_hlen;
+ else
+ vq->used->ring[res_cur_idx & (vq->size - 1)].len =
+ pkt_len + vq->vhost_hlen;
res_cur_idx++;
packet_success++;
+ if (unlikely(uncompleted_pkt == 1))
+ continue;
+
rte_memcpy((void *)(uintptr_t)buff_hdr_addr,
(const void *)&virtio_hdr, vq->vhost_hlen);
*(volatile uint16_t *)&vq->used->idx += count;
vq->last_used_idx = res_end_idx;
+ /* flush used->idx update before we read avail->flags. */
+ rte_mb();
+
/* Kick the guest if necessary. */
if (!(vq->avail->flags & VRING_AVAIL_F_NO_INTERRUPT))
eventfd_write((int)vq->callfd, 1);
* (guest physical addr -> vhost virtual addr)
*/
vq = dev->virtqueue[VIRTIO_RXQ];
- vb_addr =
- gpa_to_vva(dev, vq->buf_vec[vec_idx].buf_addr);
+ vb_addr = gpa_to_vva(dev, vq->buf_vec[vec_idx].buf_addr);
vb_hdr_addr = vb_addr;
/* Prefetch buffer address. */
seg_avail = rte_pktmbuf_data_len(pkt);
vb_offset = vq->vhost_hlen;
- vb_avail =
- vq->buf_vec[vec_idx].buf_len - vq->vhost_hlen;
+ vb_avail = vq->buf_vec[vec_idx].buf_len - vq->vhost_hlen;
entry_len = vq->vhost_hlen;
if (vb_avail == 0) {
uint32_t desc_idx =
vq->buf_vec[vec_idx].desc_idx;
- vq->desc[desc_idx].len = vq->vhost_hlen;
if ((vq->desc[desc_idx].flags
& VRING_DESC_F_NEXT) == 0) {
}
vec_idx++;
- vb_addr =
- gpa_to_vva(dev, vq->buf_vec[vec_idx].buf_addr);
+ vb_addr = gpa_to_vva(dev, vq->buf_vec[vec_idx].buf_addr);
/* Prefetch buffer address. */
rte_prefetch0((void *)(uintptr_t)vb_addr);
*/
uint32_t desc_idx =
vq->buf_vec[vec_idx].desc_idx;
- vq->desc[desc_idx].len = vb_offset;
if ((vq->desc[desc_idx].flags &
VRING_DESC_F_NEXT) == 0) {
/*
* This whole packet completes.
*/
- uint32_t desc_idx =
- vq->buf_vec[vec_idx].desc_idx;
- vq->desc[desc_idx].len = vb_offset;
-
- while (vq->desc[desc_idx].flags &
- VRING_DESC_F_NEXT) {
- desc_idx = vq->desc[desc_idx].next;
- vq->desc[desc_idx].len = 0;
- }
-
/* Update used ring with desc information */
vq->used->ring[cur_idx & (vq->size - 1)].id
= vq->buf_vec[vec_idx].desc_idx;
vq->used->ring[cur_idx & (vq->size - 1)].len
= entry_len;
- entry_len = 0;
- cur_idx++;
entry_success++;
- seg_avail = 0;
- cpy_len = RTE_MIN(vb_avail, seg_avail);
+ break;
}
}
}
return entry_success;
}
+static inline void __attribute__((always_inline))
+update_secure_len(struct vhost_virtqueue *vq, uint32_t id,
+ uint32_t *secure_len, uint32_t *vec_idx)
+{
+ uint16_t wrapped_idx = id & (vq->size - 1);
+ uint32_t idx = vq->avail->ring[wrapped_idx];
+ uint8_t next_desc;
+ uint32_t len = *secure_len;
+ uint32_t vec_id = *vec_idx;
+
+ do {
+ next_desc = 0;
+ len += vq->desc[idx].len;
+ vq->buf_vec[vec_id].buf_addr = vq->desc[idx].addr;
+ vq->buf_vec[vec_id].buf_len = vq->desc[idx].len;
+ vq->buf_vec[vec_id].desc_idx = idx;
+ vec_id++;
+
+ if (vq->desc[idx].flags & VRING_DESC_F_NEXT) {
+ idx = vq->desc[idx].next;
+ next_desc = 1;
+ }
+ } while (next_desc);
+
+ *secure_len = len;
+ *vec_idx = vec_id;
+}
+
/*
* This function works for mergeable RX.
*/
{
struct vhost_virtqueue *vq;
uint32_t pkt_idx = 0, entry_success = 0;
- uint16_t avail_idx, res_cur_idx;
- uint16_t res_base_idx, res_end_idx;
+ uint16_t avail_idx;
+ uint16_t res_base_idx, res_cur_idx;
uint8_t success = 0;
LOG_DEBUG(VHOST_DATA, "(%"PRIu64") virtio_dev_merge_rx()\n",
return 0;
for (pkt_idx = 0; pkt_idx < count; pkt_idx++) {
- uint32_t secure_len = 0;
- uint16_t need_cnt;
- uint32_t vec_idx = 0;
uint32_t pkt_len = pkts[pkt_idx]->pkt_len + vq->vhost_hlen;
- uint16_t i, id;
do {
/*
* As many data cores may want access to available
* buffers, they need to be reserved.
*/
+ uint32_t secure_len = 0;
+ uint32_t vec_idx = 0;
+
res_base_idx = vq->last_used_idx_res;
res_cur_idx = res_base_idx;
dev->device_fh);
return pkt_idx;
} else {
- uint16_t wrapped_idx =
- (res_cur_idx) & (vq->size - 1);
- uint32_t idx =
- vq->avail->ring[wrapped_idx];
- uint8_t next_desc;
-
- do {
- next_desc = 0;
- secure_len += vq->desc[idx].len;
- if (vq->desc[idx].flags &
- VRING_DESC_F_NEXT) {
- idx = vq->desc[idx].next;
- next_desc = 1;
- }
- } while (next_desc);
-
+ update_secure_len(vq, res_cur_idx, &secure_len, &vec_idx);
res_cur_idx++;
}
} while (pkt_len > secure_len);
res_cur_idx);
} while (success == 0);
- id = res_base_idx;
- need_cnt = res_cur_idx - res_base_idx;
-
- for (i = 0; i < need_cnt; i++, id++) {
- uint16_t wrapped_idx = id & (vq->size - 1);
- uint32_t idx = vq->avail->ring[wrapped_idx];
- uint8_t next_desc;
- do {
- next_desc = 0;
- vq->buf_vec[vec_idx].buf_addr =
- vq->desc[idx].addr;
- vq->buf_vec[vec_idx].buf_len =
- vq->desc[idx].len;
- vq->buf_vec[vec_idx].desc_idx = idx;
- vec_idx++;
-
- if (vq->desc[idx].flags & VRING_DESC_F_NEXT) {
- idx = vq->desc[idx].next;
- next_desc = 1;
- }
- } while (next_desc);
- }
-
- res_end_idx = res_cur_idx;
-
entry_success = copy_from_mbuf_to_vring(dev, res_base_idx,
- res_end_idx, pkts[pkt_idx]);
+ res_cur_idx, pkts[pkt_idx]);
rte_compiler_barrier();
rte_pause();
*(volatile uint16_t *)&vq->used->idx += entry_success;
- vq->last_used_idx = res_end_idx;
+ vq->last_used_idx = res_cur_idx;
+
+ /* flush used->idx update before we read avail->flags. */
+ rte_mb();
/* Kick the guest if necessary. */
if (!(vq->avail->flags & VRING_AVAIL_F_NO_INTERRUPT))
desc = &vq->desc[head[entry_success]];
/* Discard first buffer as it is the virtio header */
- desc = &vq->desc[desc->next];
+ if (desc->flags & VRING_DESC_F_NEXT) {
+ desc = &vq->desc[desc->next];
+ vb_offset = 0;
+ vb_avail = desc->len;
+ } else {
+ vb_offset = vq->vhost_hlen;
+ vb_avail = desc->len - vb_offset;
+ }
/* Buffer address translation. */
vb_addr = gpa_to_vva(dev, desc->addr);
vq->used->ring[used_idx].id = head[entry_success];
vq->used->ring[used_idx].len = 0;
- vb_offset = 0;
- vb_avail = desc->len;
/* Allocate an mbuf and populate the structure. */
m = rte_pktmbuf_alloc(mbuf_pool);
if (unlikely(m == NULL)) {
RTE_LOG(ERR, VHOST_DATA,
"Failed to allocate memory for mbuf.\n");
- break;
+ break;
}
seg_offset = 0;
seg_avail = m->buf_len - RTE_PKTMBUF_HEADROOM;
git.droids-corp.org / dpdk.git / blobdiff