+static int
+m_ifcvf_start(struct ifcvf_internal *internal)
+{
+ struct ifcvf_hw *hw = &internal->hw;
+ uint32_t i, nr_vring;
+ int vid, ret;
+ struct rte_vhost_vring vq;
+ void *vring_buf;
+ uint64_t m_vring_iova = IFCVF_MEDIATED_VRING;
+ uint64_t size;
+ uint64_t gpa;
+
+ vid = internal->vid;
+ nr_vring = rte_vhost_get_vring_num(vid);
+ rte_vhost_get_negotiated_features(vid, &hw->req_features);
+
+ for (i = 0; i < nr_vring; i++) {
+ rte_vhost_get_vhost_vring(vid, i, &vq);
+
+ size = RTE_ALIGN_CEIL(vring_size(vq.size, PAGE_SIZE),
+ PAGE_SIZE);
+ vring_buf = rte_zmalloc("ifcvf", size, PAGE_SIZE);
+ vring_init(&internal->m_vring[i], vq.size, vring_buf,
+ PAGE_SIZE);
+
+ ret = rte_vfio_container_dma_map(internal->vfio_container_fd,
+ (uint64_t)(uintptr_t)vring_buf, m_vring_iova, size);
+ if (ret < 0) {
+ DRV_LOG(ERR, "mediated vring DMA map failed.");
+ goto error;
+ }
+
+ gpa = hva_to_gpa(vid, (uint64_t)(uintptr_t)vq.desc);
+ if (gpa == 0) {
+ DRV_LOG(ERR, "Fail to get GPA for descriptor ring.");
+ return -1;
+ }
+ hw->vring[i].desc = gpa;
+
+ gpa = hva_to_gpa(vid, (uint64_t)(uintptr_t)vq.avail);
+ if (gpa == 0) {
+ DRV_LOG(ERR, "Fail to get GPA for available ring.");
+ return -1;
+ }
+ hw->vring[i].avail = gpa;
+
+ /* Direct I/O for Tx queue, relay for Rx queue */
+ if (i & 1) {
+ gpa = hva_to_gpa(vid, (uint64_t)(uintptr_t)vq.used);
+ if (gpa == 0) {
+ DRV_LOG(ERR, "Fail to get GPA for used ring.");
+ return -1;
+ }
+ hw->vring[i].used = gpa;
+ } else {
+ hw->vring[i].used = m_vring_iova +
+ (char *)internal->m_vring[i].used -
+ (char *)internal->m_vring[i].desc;
+ }
+
+ hw->vring[i].size = vq.size;
+
+ rte_vhost_get_vring_base(vid, i,
+ &internal->m_vring[i].avail->idx,
+ &internal->m_vring[i].used->idx);
+
+ rte_vhost_get_vring_base(vid, i, &hw->vring[i].last_avail_idx,
+ &hw->vring[i].last_used_idx);
+
+ m_vring_iova += size;
+ }
+ hw->nr_vring = nr_vring;
+
+ return ifcvf_start_hw(&internal->hw);
+
+error:
+ for (i = 0; i < nr_vring; i++)
+ if (internal->m_vring[i].desc)
+ rte_free(internal->m_vring[i].desc);
+
+ return -1;
+}
+
+static int
+m_ifcvf_stop(struct ifcvf_internal *internal)
+{
+ int vid;
+ uint32_t i;
+ struct rte_vhost_vring vq;
+ struct ifcvf_hw *hw = &internal->hw;
+ uint64_t m_vring_iova = IFCVF_MEDIATED_VRING;
+ uint64_t size, len;
+
+ vid = internal->vid;
+ ifcvf_stop_hw(hw);
+
+ for (i = 0; i < hw->nr_vring; i++) {
+ /* synchronize remaining new used entries if any */
+ if ((i & 1) == 0)
+ update_used_ring(internal, i);
+
+ rte_vhost_get_vhost_vring(vid, i, &vq);
+ len = IFCVF_USED_RING_LEN(vq.size);
+ rte_vhost_log_used_vring(vid, i, 0, len);
+
+ size = RTE_ALIGN_CEIL(vring_size(vq.size, PAGE_SIZE),
+ PAGE_SIZE);
+ rte_vfio_container_dma_unmap(internal->vfio_container_fd,
+ (uint64_t)(uintptr_t)internal->m_vring[i].desc,
+ m_vring_iova, size);
+
+ rte_vhost_set_vring_base(vid, i, hw->vring[i].last_avail_idx,
+ hw->vring[i].last_used_idx);
+ rte_free(internal->m_vring[i].desc);
+ m_vring_iova += size;
+ }
+
+ return 0;
+}
+
+static void
+update_used_ring(struct ifcvf_internal *internal, uint16_t qid)
+{
+ rte_vdpa_relay_vring_used(internal->vid, qid, &internal->m_vring[qid]);
+ rte_vhost_vring_call(internal->vid, qid);
+}
+
+static void *
+vring_relay(void *arg)
+{
+ int i, vid, epfd, fd, nfds;
+ struct ifcvf_internal *internal = (struct ifcvf_internal *)arg;
+ struct rte_vhost_vring vring;
+ uint16_t qid, q_num;
+ struct epoll_event events[IFCVF_MAX_QUEUES * 4];
+ struct epoll_event ev;
+ int nbytes;
+ uint64_t buf;
+
+ vid = internal->vid;
+ q_num = rte_vhost_get_vring_num(vid);
+
+ /* add notify fd and interrupt fd to epoll */
+ epfd = epoll_create(IFCVF_MAX_QUEUES * 2);
+ if (epfd < 0) {
+ DRV_LOG(ERR, "failed to create epoll instance.");
+ return NULL;
+ }
+ internal->epfd = epfd;
+
+ for (qid = 0; qid < q_num; qid++) {
+ ev.events = EPOLLIN | EPOLLPRI;
+ rte_vhost_get_vhost_vring(vid, qid, &vring);
+ ev.data.u64 = qid << 1 | (uint64_t)vring.kickfd << 32;
+ if (epoll_ctl(epfd, EPOLL_CTL_ADD, vring.kickfd, &ev) < 0) {
+ DRV_LOG(ERR, "epoll add error: %s", strerror(errno));
+ return NULL;
+ }
+ }
+
+ for (qid = 0; qid < q_num; qid += 2) {
+ ev.events = EPOLLIN | EPOLLPRI;
+ /* leave a flag to mark it's for interrupt */
+ ev.data.u64 = 1 | qid << 1 |
+ (uint64_t)internal->intr_fd[qid] << 32;
+ if (epoll_ctl(epfd, EPOLL_CTL_ADD, internal->intr_fd[qid], &ev)
+ < 0) {
+ DRV_LOG(ERR, "epoll add error: %s", strerror(errno));
+ return NULL;
+ }
+ update_used_ring(internal, qid);
+ }
+
+ /* start relay with a first kick */
+ for (qid = 0; qid < q_num; qid++)
+ ifcvf_notify_queue(&internal->hw, qid);
+
+ /* listen to the events and react accordingly */
+ for (;;) {
+ nfds = epoll_wait(epfd, events, q_num * 2, -1);
+ if (nfds < 0) {
+ if (errno == EINTR)
+ continue;
+ DRV_LOG(ERR, "epoll_wait return fail\n");
+ return NULL;
+ }
+
+ for (i = 0; i < nfds; i++) {
+ fd = (uint32_t)(events[i].data.u64 >> 32);
+ do {
+ nbytes = read(fd, &buf, 8);
+ if (nbytes < 0) {
+ if (errno == EINTR ||
+ errno == EWOULDBLOCK ||
+ errno == EAGAIN)
+ continue;
+ DRV_LOG(INFO, "Error reading "
+ "kickfd: %s",
+ strerror(errno));
+ }
+ break;
+ } while (1);
+
+ qid = events[i].data.u32 >> 1;
+
+ if (events[i].data.u32 & 1)
+ update_used_ring(internal, qid);
+ else
+ ifcvf_notify_queue(&internal->hw, qid);
+ }
+ }
+
+ return NULL;
+}
+
+static int
+setup_vring_relay(struct ifcvf_internal *internal)
+{
+ int ret;
+
+ ret = pthread_create(&internal->tid, NULL, vring_relay,
+ (void *)internal);
+ if (ret) {
+ DRV_LOG(ERR, "failed to create ring relay pthread.");
+ return -1;
+ }
+ return 0;
+}
+
+static int
+unset_vring_relay(struct ifcvf_internal *internal)
+{
+ void *status;
+
+ if (internal->tid) {
+ pthread_cancel(internal->tid);
+ pthread_join(internal->tid, &status);
+ }
+ internal->tid = 0;
+
+ if (internal->epfd >= 0)
+ close(internal->epfd);
+ internal->epfd = -1;
+
+ return 0;
+}
+
+static int
+ifcvf_sw_fallback_switchover(struct ifcvf_internal *internal)
+{
+ int ret;
+ int vid = internal->vid;
+
+ /* stop the direct IO data path */
+ unset_notify_relay(internal);
+ vdpa_ifcvf_stop(internal);
+ vdpa_disable_vfio_intr(internal);
+
+ ret = rte_vhost_host_notifier_ctrl(vid, false);
+ if (ret && ret != -ENOTSUP)
+ goto error;
+
+ /* set up interrupt for interrupt relay */
+ ret = vdpa_enable_vfio_intr(internal, 1);
+ if (ret)
+ goto unmap;
+
+ /* config the VF */
+ ret = m_ifcvf_start(internal);
+ if (ret)
+ goto unset_intr;
+
+ /* set up vring relay thread */
+ ret = setup_vring_relay(internal);
+ if (ret)
+ goto stop_vf;
+
+ rte_vhost_host_notifier_ctrl(vid, true);
+
+ internal->sw_fallback_running = true;
+
+ return 0;
+
+stop_vf:
+ m_ifcvf_stop(internal);
+unset_intr:
+ vdpa_disable_vfio_intr(internal);
+unmap:
+ ifcvf_dma_map(internal, 0);
+error:
+ return -1;
+}
+