virtio: rewrite with new virtio API

Change-Id: I935332a83e44f49ddb3fc5717b3da7a68b953e88
Signed-off-by: Sooyoung Ha <yoosah.ha@samsung.com>

diff --git a/hw/9pfs/9p-local-maru.c b/hw/9pfs/9p-local-maru.c
index 701cc12..c794b90 100644 (file)
--- a/hw/9pfs/9p-local-maru.c
+++ b/hw/9pfs/9p-local-maru.c
@@ -1420,6 +1420,7 @@ static int local_statfs(FsContext *s, V9fsPath *fs_path, struct statfs *stbuf)
     char *path = fs_path->data;
 
     buffer = rpath(s, path);
+    LOG_TRACE("[%d][%s] statfs(%s)\n", __LINE__, __func__, buffer);
 #ifndef CONFIG_WIN32
     int ret;
     ret = statfs(buffer, stbuf);

diff --git a/tizen/src/hw/virtio/maru_virtio_evdi.c b/tizen/src/hw/virtio/maru_virtio_evdi.c
index 7b62c95..9711a1e 100644 (file)
--- a/tizen/src/hw/virtio/maru_virtio_evdi.c
+++ b/tizen/src/hw/virtio/maru_virtio_evdi.c
@@ -119,19 +119,18 @@ bool send_to_evdi(const uint32_t route, char *data, const uint32_t len)
 
 static void flush_evdi_recv_queue(void)
 {
+    size_t len;
     if (unlikely(!virtio_queue_ready(vio_evdi->rvq))) {
-        INFO("virtio queue is not ready\n");
+        LOG_INFO("virtio queue is not ready\n");
         return;
     }
 
     if (unlikely(virtio_queue_empty(vio_evdi->rvq))) {
-        TRACE("virtqueue is empty\n");
+        LOG_TRACE("virtqueue is empty\n");
         return;
     }
 
-
     qemu_mutex_lock(&recv_buf_mutex);
-
     while (!QTAILQ_EMPTY(&evdi_recv_msg_queue)) {
         MsgInfo *msginfo = QTAILQ_FIRST(&evdi_recv_msg_queue);
         if (!msginfo) {
@@ -141,22 +140,28 @@ static void flush_evdi_recv_queue(void)
         VirtQueueElement *elem;
         elem = virtqueue_pop(vio_evdi->rvq, sizeof(VirtQueueElement));
         if (!elem) {
-            /* ERR("unexpected empty queue"); */
+            LOG_SEVERE("unexpected empty queue\n");
             break;
         }
 
         memset(elem->in_sg[0].iov_base, 0, elem->in_sg[0].iov_len);
-        memcpy(elem->in_sg[0].iov_base, &msginfo->info, sizeof(struct msg_info));
 
-        virtqueue_push(vio_evdi->rvq, elem, sizeof(msg_info));
+        len = iov_from_buf(elem->in_sg, elem->in_num, 0,
+                           &msginfo->info, sizeof(struct msg_info));
+        if (len != sizeof(struct msg_info)) {
+            LOG_WARNING("len != sizeof(msg_info). len: %zu, sizeof(msg_info): %zu\n",
+                            len, sizeof(struct msg_info));
+            len = sizeof(struct msg_info);
+        }
+        virtqueue_push(vio_evdi->rvq, elem, len);
         virtio_notify(&vio_evdi->vdev, vio_evdi->rvq);
+        g_free(elem);
 
         QTAILQ_REMOVE(&evdi_recv_msg_queue, msginfo, next);
         if (msginfo) {
             free(msginfo);
         }
     }
-
     qemu_mutex_unlock(&recv_buf_mutex);
 
 }
@@ -170,10 +175,12 @@ static void virtio_evdi_send(VirtIODevice *vdev, VirtQueue *vq)
 {
     VirtIOEVDI *vevdi = (VirtIOEVDI *)vdev;
     struct msg_info _msg;
-    int len = 0;
+    struct iovec *iov, *iov2;
+    unsigned int iov_cnt;
+    size_t len;
 
     if (virtio_queue_empty(vevdi->svq)) {
-        INFO("<< virtqueue is empty.\n");
+        LOG_INFO("<< virtqueue is empty.\n");
         return;
     }
 
@@ -181,23 +188,30 @@ static void virtio_evdi_send(VirtIODevice *vdev, VirtQueue *vq)
 
     while ((elem = virtqueue_pop(vq, sizeof(VirtQueueElement)))) {
         memset(&_msg, 0x00, sizeof(_msg));
-        memcpy(&_msg, elem->out_sg[0].iov_base, elem->out_sg[0].iov_len);
 
-        len = iov_from_buf(elem->in_sg, elem->in_num,
-                0, vevdi, sizeof(VirtIOEVDI));
-
-        virtqueue_push(vq, elem, len);
+        iov_cnt = elem->out_num;
+        iov2 = iov = g_memdup(elem->out_sg, sizeof(struct iovec) * iov_cnt);
+        len = iov_to_buf(iov, iov_cnt, 0, &_msg, sizeof(_msg));
+        if (len != sizeof(_msg)) {
+            LOG_WARNING("len != sizeof(_msg). len: %zu, sizeof(_msg): %zu\n"
+                            , len, sizeof(_msg));
+        }
 
         send_injector_ntf(_msg.buf, _msg.use);
+
+        virtqueue_push(vq, elem, 0);
+        virtio_notify(&vio_evdi->vdev, vq);
+
+        g_free(iov2);
+        g_free(elem);
     }
 
-    virtio_notify(&vio_evdi->vdev, vq);
 }
 
 static uint64_t virtio_evdi_get_features(VirtIODevice *vdev,
         uint64_t request_feature, Error **errp)
 {
-    TRACE("virtio_evdi_get_features.\n");
+    LOG_TRACE("virtio_evdi_get_features.\n");
     return 0;
 }
 

diff --git a/tizen/src/hw/virtio/maru_virtio_nfc.c b/tizen/src/hw/virtio/maru_virtio_nfc.c
index 435b3de..240c446 100644 (file)
--- a/tizen/src/hw/virtio/maru_virtio_nfc.c
+++ b/tizen/src/hw/virtio/maru_virtio_nfc.c
@@ -29,6 +29,7 @@
 #include <pthread.h>
 
 #include "qemu/osdep.h"
+#include "qemu/iov.h"
 #include "hw/maru_device_ids.h"
 #include "maru_virtio_nfc.h"
 #include "ecs/ecs.h"
@@ -145,13 +146,14 @@ bool send_to_nfc(unsigned char id, unsigned char type, const char *data,
 
 static void flush_nfc_recv_queue(void)
 {
+    size_t len;
     if (unlikely(!virtio_queue_ready(vio_nfc->rvq))) {
-        INFO("virtio queue is not ready\n");
+        LOG_INFO("virtio queue is not ready\n");
         return;
     }
 
     if (unlikely(virtio_queue_empty(vio_nfc->rvq))) {
-        TRACE("virtqueue is empty\n");
+        LOG_TRACE("virtqueue is empty\n");
         return;
     }
 
@@ -167,21 +169,29 @@ static void flush_nfc_recv_queue(void)
         VirtQueueElement *elem;
         elem = virtqueue_pop(vio_nfc->rvq, sizeof(VirtQueueElement));
         if (!elem) {
-            /* ERR("unexpected empty queue"); */
+            LOG_SEVERE("unexpected empty queue\n");
             break;
         }
 
-        INFO(">> virtqueue_pop. out_num : %d, in_num : %d\n",
+        LOG_TRACE(">> virtqueue_pop. out_num : %d, in_num : %d\n",
                 elem->out_num, elem->in_num);
 
-        memcpy(elem->in_sg[0].iov_base, &msginfo->info,
-               sizeof(struct nfc_msg_info));
+        memset(elem->in_sg[0].iov_base, 0, elem->in_sg[0].iov_len);
+        len = iov_from_buf(elem->in_sg, elem->in_num, 0,
+                           &msginfo->info, sizeof(struct nfc_msg_info));
+        if (len != sizeof(struct nfc_msg_info)) {
+            LOG_WARNING("len != sizeof(nfc_msg_info).\n");
+            LOG_WARNING("len: %zu, sizeof(nfc_msg_info): %zu\n",
+                            len, sizeof(struct nfc_msg_info));
+            len = sizeof(struct nfc_msg_info);
+        }
 
-        INFO(">> send to guest use = %d, msg = %s, iov_len = %d\n",
+        LOG_TRACE(">> send to guest use = %d, msg = %s, iov_len = %d\n",
                 msginfo->info.use, msginfo->info.buf, elem->in_sg[0].iov_len);
 
-        virtqueue_push(vio_nfc->rvq, elem, sizeof(nfc_msg_info));
+        virtqueue_push(vio_nfc->rvq, elem, len);
         virtio_notify(&vio_nfc->vdev, vio_nfc->rvq);
+        g_free(elem);
 
         QTAILQ_REMOVE(&nfc_recv_msg_queue, msginfo, next);
         if (msginfo) {
@@ -203,9 +213,12 @@ static void virtio_nfc_send(VirtIODevice *vdev, VirtQueue *vq)
 {
     VirtIONFC *vnfc = (VirtIONFC *)vdev;
     struct nfc_msg_info _msg;
+    struct iovec *iov, *iov2;
+    unsigned int iov_cnt;
+    size_t len;
 
     if (virtio_queue_empty(vnfc->svq)) {
-        INFO("<< virtqueue is empty.\n");
+        LOG_INFO("<< virtqueue is empty.\n");
         return;
     }
 
@@ -213,15 +226,23 @@ static void virtio_nfc_send(VirtIODevice *vdev, VirtQueue *vq)
 
     while ((elem = virtqueue_pop(vq, sizeof(VirtQueueElement)))) {
         memset(&_msg, 0x00, sizeof(_msg));
-        memcpy(&_msg, elem->out_sg[0].iov_base, elem->out_sg[0].iov_len);
 
-        INFO("<< recv from guest len = %d, msg = %s\n", _msg.use, _msg.buf);
+        iov_cnt = elem->out_num;
+        iov2 = iov = g_memdup(elem->out_sg, sizeof(struct iovec) * iov_cnt);
+        len = iov_to_buf(iov, iov_cnt, 0, &_msg, sizeof(_msg));
+        if (len != sizeof(_msg)) {
+            LOG_WARNING("len != sizeof(_msg). len: %zu, sizeof(_msg): %zu\n"
+                            , len, sizeof(_msg));
+        }
+
+        LOG_TRACE("<< recv from guest len = %d, msg = %s\n", _msg.use, _msg.buf);
         send_nfc_ntf(&_msg);
 
+        virtqueue_push(vq, elem, 0);
+        virtio_notify(&vio_nfc->vdev, vq);
+        g_free(iov2);
+        g_free(elem);
     }
-
-    virtqueue_push(vq, elem, sizeof(VirtIONFC));
-    virtio_notify(&vio_nfc->vdev, vq);
 }
 
 static uint64_t virtio_nfc_get_features(VirtIODevice *vdev,

diff --git a/tizen/src/hw/virtio/maru_virtio_tablet.c b/tizen/src/hw/virtio/maru_virtio_tablet.c
index ef29607..9a564ba 100644 (file)
--- a/tizen/src/hw/virtio/maru_virtio_tablet.c
+++ b/tizen/src/hw/virtio/maru_virtio_tablet.c
@@ -29,6 +29,7 @@
  */
 
 #include "qemu/osdep.h"
+#include "qemu/iov.h"
 #include "emul_state.h"
 #include "maru_virtio_tablet.h"
 #include "hw/maru_device_ids.h"
@@ -131,7 +132,7 @@ static void maru_tablet_bh(void *opaque)
     VirtIOTablet *vt = (VirtIOTablet *)opaque;
     TabletEventEntry *event_entry = NULL;
     VirtQueueElement *elem;
-    uint32_t push_len = 0;
+    size_t push_len = 0, len;
 
     if (unlikely(!virtio_queue_ready(vt->vq))) {
         ERR("virtio queue is not ready\n");
@@ -157,9 +158,13 @@ static void maru_tablet_bh(void *opaque)
         event_entry = QTAILQ_FIRST(&events_queue);
 
         /* copy event into virtio buffer */
-        memcpy(elem->in_sg[0].iov_base + push_len,
-               &(event_entry->tablet),
-               sizeof(EmulTabletEvent));
+        len = iov_from_buf(elem->in_sg, elem->in_num, push_len,
+                           &(event_entry->tablet), sizeof(EmulTabletEvent));
+        if(len != sizeof(EmulTabletEvent)) {
+            LOG_WARNING("len != sizeof(EmulTabletEvent).\n");
+            LOG_WARNING("len: %zu, sizeof(EmulTabletEvent): %zu\n",
+                            len, sizeof(EmulTabletEvent));
+        }
         push_len += sizeof(EmulTabletEvent);
 
         /* remove host event */
@@ -171,8 +176,9 @@ static void maru_tablet_bh(void *opaque)
     vt->avail = false;
     qemu_mutex_unlock(&vt->mutex);
 
-    TRACE("maru_virtio_tablet_bh: push_len(%u), push events(%zu)\n",
+    LOG_TRACE("maru_virtio_tablet_bh: push_len(%zu), push events(%zu)\n",
           push_len, push_len / sizeof(EmulTabletEvent));
+    g_free(elem);
 }
 
 static uint64_t virtio_tablet_get_features(

diff --git a/tizen/src/hw/virtio/maru_virtio_vmodem.c b/tizen/src/hw/virtio/maru_virtio_vmodem.c
index 14799c7..fb25d37 100644 (file)
--- a/tizen/src/hw/virtio/maru_virtio_vmodem.c
+++ b/tizen/src/hw/virtio/maru_virtio_vmodem.c
@@ -29,6 +29,7 @@
  */
 
 #include "qemu/osdep.h"
+#include "qemu/iov.h"
 #include "hw/maru_device_ids.h"
 #include "maru_virtio_vmodem.h"
 #include "maru_virtio_evdi.h"
@@ -98,35 +99,44 @@ bool send_to_vmodem(const uint32_t route, char *data, const uint32_t len)
 
 static void flush_vmodem_recv_queue(void)
 {
+    size_t len;
     if (unlikely(!virtio_queue_ready(vio_vmodem->rvq))) {
-        LOG_SEVERE("recv virtio queue is not ready\n");
+        LOG_TRACE("recv virtio queue is not ready\n");
         return;
     }
 
     if (unlikely(virtio_queue_empty(vio_vmodem->rvq))) {
-        LOG_SEVERE("recv virtqueue is empty\n");
+        LOG_TRACE("recv virtqueue is empty\n");
         return;
     }
 
     qemu_mutex_lock(&vio_vmodem->mutex);
-
     while (!QTAILQ_EMPTY(&vmodem_recv_msg_queue)) {
         MsgInfo *msginfo = QTAILQ_FIRST(&vmodem_recv_msg_queue);
         if (!msginfo) {
+            LOG_SEVERE("unexpected empty message queue\n");
             break;
         }
 
         VirtQueueElement *elem;
         elem = virtqueue_pop(vio_vmodem->rvq, sizeof(VirtQueueElement));
         if (!elem) {
+            LOG_SEVERE("unexpected empty virtqueue\n");
             break;
         }
 
         memset(elem->in_sg[0].iov_base, 0, elem->in_sg[0].iov_len);
-        memcpy(elem->in_sg[0].iov_base, &msginfo->info, sizeof(struct msg_info));
 
-        virtqueue_push(vio_vmodem->rvq, elem, sizeof(msg_info));
+        len = iov_from_buf(elem->in_sg, elem->in_num, 0,
+                           &msginfo->info, sizeof(struct msg_info));
+        if (len != sizeof(struct msg_info)) {
+            LOG_WARNING("len != sizeof(msg_info). len: %zu, sizeof(msg_info): %zu\n",
+                            len, sizeof(struct msg_info));
+            len = sizeof(struct msg_info);
+        }
+        virtqueue_push(vio_vmodem->rvq, elem, len);
         virtio_notify(&vio_vmodem->vdev, vio_vmodem->rvq);
+        g_free(elem);
 
         QTAILQ_REMOVE(&vmodem_recv_msg_queue, msginfo, next);
         if (msginfo) {
@@ -146,6 +156,9 @@ static void virtio_vmodem_send(VirtIODevice *vdev, VirtQueue *vq)
 {
     VirtIOVModem *vvmodem = (VirtIOVModem *)vdev;
     struct msg_info _msg;
+    struct iovec *iov, *iov2;
+    unsigned int iov_cnt;
+    size_t len;
 
     if (virtio_queue_empty(vvmodem->svq)) {
         LOG_SEVERE("send virtqueue is empty.\n");
@@ -156,12 +169,21 @@ static void virtio_vmodem_send(VirtIODevice *vdev, VirtQueue *vq)
 
     while ((elem = virtqueue_pop(vq, sizeof(VirtQueueElement)))) {
         memset(&_msg, 0x00, sizeof(_msg));
-        memcpy(&_msg, elem->out_sg[0].iov_base, elem->out_sg[0].iov_len);
+
+        iov_cnt = elem->out_num;
+        iov2 = iov = g_memdup(elem->out_sg, sizeof(struct iovec) * iov_cnt);
+        len = iov_to_buf(iov, iov_cnt, 0, &_msg, sizeof(_msg));
+        if (len != sizeof(_msg)) {
+            LOG_WARNING("len != sizeof(_msg). len: %zu, sizeof(_msg): %zu\n"
+                            , len, sizeof(_msg));
+        }
 
         LOG_TRACE("vmodem send to ecp.\n");
         send_injector_ntf(_msg.buf, _msg.use);
         virtqueue_push(vq, elem, 0);
         virtio_notify(&vio_vmodem->vdev, vq);
+        g_free(iov2);
+        g_free(elem);
     }
 
 }