Add virtio-loopback-adapter

The virtio-loopback-adapter is part of the Virtio Loopback
architecture detailed in the following link:
  https://git.virtualopensystems.com/virtio-loopback/docs

The following vhost-user devices are supported:
- vhost-user-blk
- vhost-user-rng
- vhost-user-input
- vhost-user-gpio
- vhost-user-sound

Bug-AGL: SPEC-4834
Change-Id: I4edb28faf370992f5f45390f5c4240a0f5c3084c
Signed-off-by: Angelos Mouzakitis <a.mouzakitis@virtualopensystems.com>

1 files changed, 381 insertions, 0 deletions

diff --git a/vhost_user_gpio.c b/vhost_user_gpio.c
new file mode 100644
index 0000000..6049bd5
--- /dev/null
+++ b/vhost_user_gpio.c
@@ -0,0 +1,381 @@
+/*
+ * Based on vhost-user-gpio.c of QEMU project
+ *
+ * Copyright (c) 2022 Viresh Kumar <viresh.kumar@linaro.org>
+ *
+ * Copyright (c) 2023 Virtual Open Systems SAS.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+#include <stdbool.h>
+#include <sys/param.h>
+#include <errno.h>
+
+/* Project header files */
+#include "vhost_user_gpio.h"
+
+#ifdef DEBUG
+#define DBG(...) printf("vhost-user-gpio: " __VA_ARGS__)
+#else
+#define DBG(...)
+#endif /* DEBUG */
+
+#define REALIZE_CONNECTION_RETRIES 3
+#define VHOST_NVQS 2
+
+static const int feature_bits[] = {
+    VIRTIO_F_VERSION_1,
+    VIRTIO_F_NOTIFY_ON_EMPTY,
+    VIRTIO_RING_F_INDIRECT_DESC,
+    VIRTIO_RING_F_EVENT_IDX,
+    VIRTIO_GPIO_F_IRQ,
+    VIRTIO_F_RING_RESET,
+    VHOST_INVALID_FEATURE_BIT
+};
+
+static void vu_gpio_get_config(VirtIODevice *vdev, uint8_t *config)
+{
+    VHostUserGPIO *gpio = dev->vdev->vhugpio;
+
+    DBG("vu_gpio_get_config()\n");
+    memcpy(config, &gpio->config, sizeof(gpio->config));
+}
+
+static int vu_gpio_config_notifier(struct vhost_dev *dev)
+{
+    VHostUserGPIO *gpio = dev->vdev->vhugpio;
+
+    DBG("vu_gpio_config_notifier\n");
+
+    memcpy(dev->vdev->config, &gpio->config, sizeof(gpio->config));
+    virtio_notify_config(dev->vdev);
+
+    return 0;
+}
+
+const VhostDevConfigOps gpio_ops = {
+    .vhost_dev_config_notifier = vu_gpio_config_notifier,
+};
+
+static int vu_gpio_start(VirtIODevice *vdev)
+{
+    VirtioBus *k = vdev->vbus;
+    VHostUserGPIO *gpio = vdev->vhugpio;
+    int ret, i;
+
+    DBG("vu_gpio_start()\n");
+
+    if (!k->set_guest_notifiers) {
+        DBG("binding does not support guest notifiers");
+        return -ENOSYS;
+    }
+
+    ret = vhost_dev_enable_notifiers(gpio->vhost_dev, vdev);
+    if (ret < 0) {
+        DBG("Error enabling host notifiers: %d", ret);
+        return ret;
+    }
+
+    ret = k->set_guest_notifiers(k->vdev, gpio->vhost_dev->nvqs, true);
+    if (ret < 0) {
+        DBG("Error binding guest notifier: %d", ret);
+        goto out_with_err_host_notifiers;
+    }
+
+    vhost_ack_features(gpio->vhost_dev, feature_bits, vdev->guest_features);
+
+    ret = vhost_dev_start(gpio->vhost_dev, vdev, true);
+    if (ret < 0) {
+        DBG("Error starting vhost-user-gpio: %d", ret);
+        goto out_with_err_guest_notifiers;
+    }
+    gpio->started_vu = true;
+
+    for (i = 0; i < gpio->vhost_dev->nvqs; i++) {
+        vhost_virtqueue_mask(gpio->vhost_dev, vdev, i, false);
+    }
+
+    /*
+     * TODO: check if we need the following is needed
+     * ret = gpio->vhost_dev->vhost_ops->vhost_set_vring_enable(gpio->vhost_dev,
+     *                                                          true);
+     */
+
+    return 0;
+
+out_with_err_guest_notifiers:
+    k->set_guest_notifiers(k->vdev, gpio->vhost_dev->nvqs, false);
+out_with_err_host_notifiers:
+    /*
+     * TODO: implement the following functions:
+     * vhost_dev_disable_notifiers(&gpio->vhost_dev, vdev);
+     */
+
+    return ret;
+}
+
+static void vu_gpio_stop(VirtIODevice *vdev)
+{
+    DBG("vu_gpio_stop() not yet implemented\n");
+}
+
+static void vu_gpio_set_status(VirtIODevice *vdev, uint8_t status)
+{
+    VHostUserGPIO *gpio = vdev->vhugpio;
+    bool should_start = virtio_device_started(vdev, status);
+
+    DBG("vu_gpio_set_status()\n");
+
+    if (!gpio->connected) {
+        return;
+    }
+
+printf("should_start: %d\n", should_start);
+    if (gpio->vhost_dev->started) {
+        return;
+    }
+
+    if (should_start) {
+        if (vu_gpio_start(vdev)) {
+            DBG("vu_gpio_start() failed\n");
+        }
+    } else {
+        vu_gpio_stop(vdev);
+    }
+}
+
+static uint64_t vu_gpio_get_features(VirtIODevice *vdev, uint64_t features)
+{
+    VHostUserGPIO *gpio = vdev->vhugpio;
+
+    DBG("vu_gpio_get_features()\n");
+    return vhost_get_features(gpio->vhost_dev, feature_bits, features);
+}
+
+static void vu_gpio_handle_output(VirtIODevice *vdev, VirtQueue *vq)
+{
+    /*
+     * Not normally called; it's the daemon that handles the queue;
+     * however virtio's cleanup path can call this.
+     */
+    DBG("vu_gpio_handle_output not yet implemented\n");
+}
+
+static void vu_gpio_guest_notifier_mask(VirtIODevice *vdev, int idx, bool mask)
+{
+    VHostUserGPIO *gpio = vdev->vhugpio;
+
+    DBG("vu_gpio_guest_notifier_mask() not yet implemented\n");
+
+    vhost_virtqueue_mask(gpio->vhost_dev, vdev, idx, mask);
+}
+
+static void do_vhost_user_cleanup(VirtIODevice *vdev, VHostUserGPIO *gpio)
+{
+    DBG("do_vhost_user_cleanup() not yet implemented\n");
+}
+
+static int vu_gpio_connect(VirtIODevice *vdev)
+{
+    VHostUserGPIO *gpio = vdev->vhugpio;
+    int ret;
+
+    DBG("vu_gpio_connect()\n");
+
+    if (gpio->connected) {
+        return 0;
+    }
+    gpio->connected = true;
+
+    vhost_dev_set_config_notifier(gpio->vhost_dev, &gpio_ops);
+    /*
+     * TODO: Investigate if the following is needed
+     * gpio->vhost_user.supports_config = true;
+     */
+
+    gpio->vhost_dev->nvqs = VHOST_NVQS;
+    gpio->vhost_dev->vqs = gpio->vhost_vqs;
+
+    vhost_dev_init(gpio->vhost_dev);
+    /*
+     * TODO: Add error handling
+     * if (ret < 0) {
+     *     return ret;
+     * }
+     */
+
+    /* restore vhost state */
+    if (virtio_device_started(vdev, vdev->status)) {
+        vu_gpio_start(vdev);
+    }
+
+    return 0;
+}
+
+static int vu_gpio_realize_connect(VHostUserGPIO *gpio)
+{
+    int ret;
+
+    DBG("vu_gpio_realize_connect()\n");
+
+    ret = vu_gpio_connect(gpio->parent);
+    if (ret < 0) {
+        return ret;
+    }
+
+    ret = vhost_dev_get_config(gpio->vhost_dev, (uint8_t *)&gpio->config,
+                               sizeof(gpio->config));
+
+    if (ret < 0) {
+        DBG("vhost-user-gpio: get config failed\n");
+        /*
+         * TODO: Add cleanup function
+         * vhost_dev_cleanup(vhost_dev);
+         */
+        return ret;
+    }
+
+    return 0;
+}
+
+static void vu_gpio_device_unrealize(VirtIODevice *vdev)
+{
+    DBG("vu_gpio_device_unrealize() not yet implemented\n");
+}
+
+static void print_config_gpio(uint8_t *config_data)
+{
+    struct virtio_gpio_config *config =
+        (struct virtio_gpio_config *)config_data;
+
+    DBG("ngpio: %hu\n", config->ngpio);
+    DBG("gpio_names_size: %u\n", config->gpio_names_size);
+}
+
+static void vu_gpio_class_init(VirtIODevice *vdev)
+{
+    DBG("vu_gpio_class_init()\n");
+
+    vdev->vdev_class = (VirtioDeviceClass *)malloc(sizeof(VirtioDeviceClass));
+    if (!vdev->vdev_class) {
+        DBG("vdev_class memory allocation failed\n");
+        return;
+    }
+    vdev->vdev_class->realize = vu_gpio_device_realize;
+    vdev->vdev_class->unrealize = vu_gpio_device_unrealize;
+    vdev->vdev_class->get_features = vu_gpio_get_features;
+    vdev->vdev_class->get_config = vu_gpio_get_config;
+    vdev->vdev_class->set_status = vu_gpio_set_status;
+    vdev->vdev_class->guest_notifier_mask = vu_gpio_guest_notifier_mask;
+}
+
+void vu_gpio_init(VirtIODevice *vdev)
+{
+    DBG("vu_gpio_init()\n");
+
+    VHostUserGPIO *vhugpio = (VHostUserGPIO *)malloc(sizeof(VHostUserGPIO));
+    if (!proxy) {
+        DBG("proxy memory allocation failed\n");
+        goto out;
+    }
+
+    vdev->vhugpio = vhugpio;
+    vdev->nvqs = &dev->nvqs;
+    vhugpio->parent = vdev;
+    vhugpio->vhost_dev = dev;
+
+    vu_gpio_class_init(vdev);
+    virtio_loopback_bus_init(vdev->vbus);
+
+out:
+    return;
+}
+
+/* TODO: Add queue_num, queue_size as parameters */
+void vu_gpio_device_realize()
+{
+    int retries, ret;
+    int i;
+
+    DBG("vu_gpio_device_realize()\n");
+
+    /* This needs to be added */
+    proxy = (VirtIOMMIOProxy *)malloc(sizeof(VirtIOMMIOProxy));
+    if (!proxy) {
+        DBG("proxy memory allocation failed\n");
+        goto out_with_error;
+    }
+
+    *proxy = (VirtIOMMIOProxy) {
+        .legacy = 1,
+    };
+
+    /* VIRTIO_ID_GPIO is 41, check virtio_ids.h in linux */
+    virtio_dev_init(global_vdev, "virtio-gpio", 41,
+                sizeof(struct virtio_gpio_config));
+
+    vu_gpio_init(global_vdev);
+    if (!global_vdev->vhugpio) {
+        DBG("vhugpio memory allocation failed\n");
+        goto out_with_proxy;
+    }
+
+    global_vdev->vhugpio->command_vq = virtio_add_queue(global_vdev, 64,
+                                                        vu_gpio_handle_output);
+    global_vdev->vhugpio->interrupt_vq = virtio_add_queue(global_vdev, 64,
+                                                        vu_gpio_handle_output);
+
+    global_vdev->vhugpio->vhost_vqs = (struct vhost_virtqueue *)
+                                malloc(sizeof(struct vhost_virtqueue *));
+    if (!global_vdev->vhugpio->vhost_vqs) {
+        DBG("vhost_vqs memory allocation failed\n");
+        goto out_with_dev;
+    }
+
+    global_vdev->vhugpio->connected = false;
+
+    retries = REALIZE_CONNECTION_RETRIES;
+
+    do {
+        ret = vu_gpio_realize_connect(global_vdev->vhugpio);
+    } while (ret < 0 && retries--);
+
+    if (ret < 0) {
+        DBG("vu_gpio_realize_connect(): -EPROTO\n");
+        do_vhost_user_cleanup(global_vdev, global_vdev->vhugpio);
+    }
+
+    print_config_gpio((uint8_t *)(&global_vdev->vhugpio->config));
+    DBG("(realize completed)\n");
+
+    return;
+
+    /* TODO: Fix the following considering also do_vhost_user_cleanup() */
+out_with_cmd_vq:
+    /* free(global_vdev->vhugpio->command_vq); */
+out_with_dev:
+    free(global_vdev->vhugpio);
+out_with_proxy:
+    free(proxy);
+out_with_error:
+    DBG("Realize funciton return error\n");
+    return;
+}