[PATCH v5 0/4] Virtio shared dma-buf

[PATCH v5 0/4] Virtio shared dma-buf

[Albert Esteve]

v1 link -> https://lists.gnu.org/archive/html/qemu-devel/2023-05/msg00598.html
v2 link -> https://lists.gnu.org/archive/html/qemu-devel/2023-05/msg04530.html
v3 link -> https://lists.gnu.org/archive/html/qemu-devel/2023-05/msg06126.html
v4 link -> https://lists.gnu.org/archive/html/qemu-devel/2023-06/msg05174.html
v4 -> v5:
- Allow shared table to hold pointers for vhost devices, in a struct that defines the types that the table can store
- New message VHOST_USER_GET_SHARED_OBJECT to retrieve objects stored in vhost backends
- Minor additions to support the previous items (e.g. new test usecases).

This patch covers the required steps to add support for virtio cross-device resource sharing[1],
which support is already available in the kernel.

The main usecase will be sharing dma buffers from virtio-gpu devices (as the exporter
-see VIRTIO_GPU_CMD_RESOURCE_ASSIGN_UUID in [2]), to virtio-video (under discussion)
devices (as the buffer-user or importer). Therefore, even though virtio specs talk about
resources or objects[3], this patch adds the infrastructure with dma-bufs in mind.
Note that virtio specs let the devices themselves define what a vitio object is.

These are the main parts that are covered in the patch:

- Add hash function to uuid module
- Shared resources table, to hold all resources that can be shared in the host and their assigned UUID,
  or pointers to the backend holding the resource
- Internal shared table API for virtio devices to add, lookup and remove resources
- Unit test to verify the API
- New messages to the vhost-user protocol to allow backend to interact with the shared
  table API through the control socket
- New vhost-user feature bit to enable shared objects feature

Applies cleanly to 38a6de80b917b2a822cff0e38d83563ab401c890

[1] - https://lwn.net/Articles/828988/
[2] - https://docs.oasis-open.org/virtio/virtio/v1.2/csd01/virtio-v1.2-csd01.html#x1-3730006
[3] - https://docs.oasis-open.org/virtio/virtio/v1.2/csd01/virtio-v1.2-csd01.html#x1-10500011

Albert Esteve (4):
  uuid: add a hash function
  virtio-dmabuf: introduce virtio-dmabuf
  vhost-user: add shared_object msg
  vhost-user: refactor send_resp code

 MAINTAINERS                               |   7 +
 docs/interop/vhost-user.rst               |  57 +++++++
 hw/display/meson.build                    |   1 +
 hw/display/virtio-dmabuf.c                | 136 +++++++++++++++++
 hw/virtio/vhost-user.c                    | 174 ++++++++++++++++++++--
 include/hw/virtio/vhost-backend.h         |   3 +
 include/hw/virtio/virtio-dmabuf.h         | 103 +++++++++++++
 include/qemu/uuid.h                       |   2 +
 subprojects/libvhost-user/libvhost-user.c | 118 +++++++++++++++
 subprojects/libvhost-user/libvhost-user.h |  55 ++++++-
 tests/unit/meson.build                    |   1 +
 tests/unit/test-uuid.c                    |  27 ++++
 tests/unit/test-virtio-dmabuf.c           | 137 +++++++++++++++++
 util/uuid.c                               |  14 ++
 14 files changed, 821 insertions(+), 14 deletions(-)
 create mode 100644 hw/display/virtio-dmabuf.c
 create mode 100644 include/hw/virtio/virtio-dmabuf.h
 create mode 100644 tests/unit/test-virtio-dmabuf.c

-- 
2.40.0

[PATCH v5 1/4] uuid: add a hash function

[Albert Esteve]

Add hash function to uuid module using the
djb2 hash algorithm.

Add a couple simple unit tests for the hash
function, checking collisions for similar UUIDs.

Signed-off-by: Albert Esteve <aesteve@redhat.com>
---
 include/qemu/uuid.h    |  2 ++
 tests/unit/test-uuid.c | 27 +++++++++++++++++++++++++++
 util/uuid.c            | 14 ++++++++++++++
 3 files changed, 43 insertions(+)

diff --git a/include/qemu/uuid.h b/include/qemu/uuid.h
index dc40ee1fc9..e24a1099e4 100644
--- a/include/qemu/uuid.h
+++ b/include/qemu/uuid.h
@@ -96,4 +96,6 @@ int qemu_uuid_parse(const char *str, QemuUUID *uuid);
 
 QemuUUID qemu_uuid_bswap(QemuUUID uuid);
 
+uint32_t qemu_uuid_hash(const void *uuid);
+
 #endif
diff --git a/tests/unit/test-uuid.c b/tests/unit/test-uuid.c
index c111de5fc1..aedc125ae9 100644
--- a/tests/unit/test-uuid.c
+++ b/tests/unit/test-uuid.c
@@ -171,6 +171,32 @@ static void test_uuid_unparse_strdup(void)
     }
 }
 
+static void test_uuid_hash(void)
+{
+    QemuUUID uuid;
+    int i;
+
+    for (i = 0; i < 100; i++) {
+        qemu_uuid_generate(&uuid);
+        /* Obtain the UUID hash */
+        uint32_t hash_a = qemu_uuid_hash(&uuid);
+        int data_idx = g_random_int_range(0, 15);
+        /* Change a single random byte of the UUID */
+        if (uuid.data[data_idx] < 0xFF) {
+            uuid.data[data_idx]++;
+        } else {
+            uuid.data[data_idx]--;
+        }
+        /* Obtain the UUID hash again */
+        uint32_t hash_b = qemu_uuid_hash(&uuid);
+        /*
+         * Both hashes shall be different (avoid collision)
+         * for any change in the UUID fields
+         */
+        g_assert_cmpint(hash_a, !=, hash_b);
+    }
+}
+
 int main(int argc, char **argv)
 {
     g_test_init(&argc, &argv, NULL);
@@ -179,6 +205,7 @@ int main(int argc, char **argv)
     g_test_add_func("/uuid/parse", test_uuid_parse);
     g_test_add_func("/uuid/unparse", test_uuid_unparse);
     g_test_add_func("/uuid/unparse_strdup", test_uuid_unparse_strdup);
+    g_test_add_func("/uuid/hash", test_uuid_hash);
 
     return g_test_run();
 }
diff --git a/util/uuid.c b/util/uuid.c
index b1108dde78..64eaf2e208 100644
--- a/util/uuid.c
+++ b/util/uuid.c
@@ -116,3 +116,17 @@ QemuUUID qemu_uuid_bswap(QemuUUID uuid)
     bswap16s(&uuid.fields.time_high_and_version);
     return uuid;
 }
+
+uint32_t qemu_uuid_hash(const void *uuid)
+{
+    QemuUUID *qid = (QemuUUID *) uuid;
+    uint32_t h = 5381;
+    int i;
+
+    for (i = 0; i < ARRAY_SIZE(qid->data); i++) {
+        h = (h << 5) + h + qid->data[i];
+    }
+
+    return h;
+}
+
-- 
2.40.0

Re: [PATCH v5 1/4] uuid: add a hash function

[Philippe Mathieu-Daudé]

On 2/8/23 11:08, Albert Esteve wrote:
> Add hash function to uuid module using the
> djb2 hash algorithm.

^ This info ...

> Add a couple simple unit tests for the hash
> function, checking collisions for similar UUIDs.
> 
> Signed-off-by: Albert Esteve <aesteve@redhat.com>
> ---
>   include/qemu/uuid.h    |  2 ++
>   tests/unit/test-uuid.c | 27 +++++++++++++++++++++++++++
>   util/uuid.c            | 14 ++++++++++++++
>   3 files changed, 43 insertions(+)
> 
> diff --git a/include/qemu/uuid.h b/include/qemu/uuid.h
> index dc40ee1fc9..e24a1099e4 100644
> --- a/include/qemu/uuid.h
> +++ b/include/qemu/uuid.h
> @@ -96,4 +96,6 @@ int qemu_uuid_parse(const char *str, QemuUUID *uuid);
>   
>   QemuUUID qemu_uuid_bswap(QemuUUID uuid);
>   
> +uint32_t qemu_uuid_hash(const void *uuid);
> +
>   #endif
> diff --git a/tests/unit/test-uuid.c b/tests/unit/test-uuid.c
> index c111de5fc1..aedc125ae9 100644
> --- a/tests/unit/test-uuid.c
> +++ b/tests/unit/test-uuid.c
> @@ -171,6 +171,32 @@ static void test_uuid_unparse_strdup(void)
>       }
>   }
>   
> +static void test_uuid_hash(void)
> +{
> +    QemuUUID uuid;
> +    int i;
> +
> +    for (i = 0; i < 100; i++) {
> +        qemu_uuid_generate(&uuid);
> +        /* Obtain the UUID hash */
> +        uint32_t hash_a = qemu_uuid_hash(&uuid);
> +        int data_idx = g_random_int_range(0, 15);
> +        /* Change a single random byte of the UUID */
> +        if (uuid.data[data_idx] < 0xFF) {
> +            uuid.data[data_idx]++;
> +        } else {
> +            uuid.data[data_idx]--;
> +        }
> +        /* Obtain the UUID hash again */
> +        uint32_t hash_b = qemu_uuid_hash(&uuid);
> +        /*
> +         * Both hashes shall be different (avoid collision)
> +         * for any change in the UUID fields
> +         */
> +        g_assert_cmpint(hash_a, !=, hash_b);
> +    }
> +}
> +
>   int main(int argc, char **argv)
>   {
>       g_test_init(&argc, &argv, NULL);
> @@ -179,6 +205,7 @@ int main(int argc, char **argv)
>       g_test_add_func("/uuid/parse", test_uuid_parse);
>       g_test_add_func("/uuid/unparse", test_uuid_unparse);
>       g_test_add_func("/uuid/unparse_strdup", test_uuid_unparse_strdup);
> +    g_test_add_func("/uuid/hash", test_uuid_hash);
>   
>       return g_test_run();
>   }
> diff --git a/util/uuid.c b/util/uuid.c
> index b1108dde78..64eaf2e208 100644
> --- a/util/uuid.c
> +++ b/util/uuid.c
> @@ -116,3 +116,17 @@ QemuUUID qemu_uuid_bswap(QemuUUID uuid)
>       bswap16s(&uuid.fields.time_high_and_version);
>       return uuid;
>   }

... would be more useful as a comment here.

/* djb2 hash algorithm */

Anyhow,

Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>

> +uint32_t qemu_uuid_hash(const void *uuid)
> +{
> +    QemuUUID *qid = (QemuUUID *) uuid;
> +    uint32_t h = 5381;
> +    int i;
> +
> +    for (i = 0; i < ARRAY_SIZE(qid->data); i++) {
> +        h = (h << 5) + h + qid->data[i];
> +    }
> +
> +    return h;
> +}
> +

[PATCH v5 2/4] virtio-dmabuf: introduce virtio-dmabuf

[Albert Esteve]

This API manages objects (in this iteration,
dmabuf fds) that can be shared along different
virtio devices, associated to a UUID.

The API allows the different devices to add,
remove and/or retrieve the objects by simply
invoking the public functions that reside in the
virtio-dmabuf file.

For vhost backends, the API stores the pointer
to the backend holding the object.

Suggested-by: Gerd Hoffmann <kraxel@redhat.com>
Signed-off-by: Albert Esteve <aesteve@redhat.com>
---
 MAINTAINERS                       |   7 ++
 hw/display/meson.build            |   1 +
 hw/display/virtio-dmabuf.c        | 136 +++++++++++++++++++++++++++++
 include/hw/virtio/virtio-dmabuf.h | 103 ++++++++++++++++++++++
 tests/unit/meson.build            |   1 +
 tests/unit/test-virtio-dmabuf.c   | 137 ++++++++++++++++++++++++++++++
 6 files changed, 385 insertions(+)
 create mode 100644 hw/display/virtio-dmabuf.c
 create mode 100644 include/hw/virtio/virtio-dmabuf.h
 create mode 100644 tests/unit/test-virtio-dmabuf.c

diff --git a/MAINTAINERS b/MAINTAINERS
index 12e59b6b27..cd8487785a 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -2158,6 +2158,13 @@ T: git https://gitlab.com/cohuck/qemu.git s390-next
 T: git https://github.com/borntraeger/qemu.git s390-next
 L: qemu-s390x@nongnu.org
 
+virtio-dmabuf
+M: Albert Esteve <aesteve@redhat.com>
+S: Supported
+F: hw/display/virtio-dmabuf.c
+F: include/hw/virtio/virtio-dmabuf.h
+F: tests/unit/test-virtio-dmabuf.c
+
 virtiofs
 M: Stefan Hajnoczi <stefanha@redhat.com>
 S: Supported
diff --git a/hw/display/meson.build b/hw/display/meson.build
index 413ba4ab24..05619c6968 100644
--- a/hw/display/meson.build
+++ b/hw/display/meson.build
@@ -37,6 +37,7 @@ system_ss.add(when: 'CONFIG_MACFB', if_true: files('macfb.c'))
 system_ss.add(when: 'CONFIG_NEXTCUBE', if_true: files('next-fb.c'))
 
 system_ss.add(when: 'CONFIG_VGA', if_true: files('vga.c'))
+system_ss.add(when: 'CONFIG_VIRTIO', if_true: files('virtio-dmabuf.c'))
 
 if (config_all_devices.has_key('CONFIG_VGA_CIRRUS') or
     config_all_devices.has_key('CONFIG_VGA_PCI') or
diff --git a/hw/display/virtio-dmabuf.c b/hw/display/virtio-dmabuf.c
new file mode 100644
index 0000000000..e852c71ba9
--- /dev/null
+++ b/hw/display/virtio-dmabuf.c
@@ -0,0 +1,136 @@
+/*
+ * Virtio Shared dma-buf
+ *
+ * Copyright Red Hat, Inc. 2023
+ *
+ * Authors:
+ *     Albert Esteve <aesteve@redhat.com>
+ *
+ * This work is licensed under the terms of the GNU GPL, version 2 or later.
+ * See the COPYING file in the top-level directory.
+ */
+
+#include "hw/virtio/virtio-dmabuf.h"
+
+
+static GMutex lock;
+static GHashTable *resource_uuids;
+
+/*
+ * uuid_equal_func: wrapper for UUID is_equal function to
+ * satisfy g_hash_table_new expected parameters signatures.
+ */
+static int uuid_equal_func(const void *lhv, const void *rhv)
+{
+    return qemu_uuid_is_equal(lhv, rhv);
+}
+
+static bool virtio_add_resource(QemuUUID *uuid, struct VirtioSharedObject *value)
+{
+    if (resource_uuids == NULL) {
+        resource_uuids = g_hash_table_new_full(
+            qemu_uuid_hash, uuid_equal_func, NULL, g_free);
+    }
+    if (g_hash_table_lookup(resource_uuids, uuid) != NULL) {
+        return false;
+    }
+
+    return g_hash_table_insert(resource_uuids, uuid, value);
+}
+
+static gpointer virtio_lookup_resource(const QemuUUID *uuid)
+{
+    if (resource_uuids == NULL) {
+        return NULL;
+    }
+
+    return g_hash_table_lookup(resource_uuids, uuid);
+}
+
+bool virtio_add_dmabuf(QemuUUID *uuid, int udmabuf_fd)
+{
+    bool result;
+    struct VirtioSharedObject *vso;
+    if (udmabuf_fd < 0) {
+        return false;
+    }
+    vso = g_new0(struct VirtioSharedObject, 1);
+    g_mutex_lock(&lock);
+    vso->type = TYPE_DMABUF;
+    vso->value = GINT_TO_POINTER(udmabuf_fd);
+    result = virtio_add_resource(uuid, vso);
+    g_mutex_unlock(&lock);
+
+    return result;
+}
+
+bool virtio_add_vhost_device(QemuUUID *uuid, struct vhost_dev *dev)
+{
+    bool result;
+    struct VirtioSharedObject *vso;
+    if (dev == NULL) {
+        return false;
+    }
+    vso = g_new0(struct VirtioSharedObject, 1);
+    g_mutex_lock(&lock);
+    vso->type = TYPE_VHOST_DEV;
+    vso->value = dev;
+    result = virtio_add_resource(uuid, vso);
+    g_mutex_unlock(&lock);
+
+    return result;
+}
+
+bool virtio_remove_resource(const QemuUUID *uuid)
+{
+    bool result;
+    g_mutex_lock(&lock);
+    result = g_hash_table_remove(resource_uuids, uuid);
+    g_mutex_unlock(&lock);
+
+    return result;
+}
+
+static struct VirtioSharedObject *get_shared_object(const QemuUUID *uuid)
+{
+    g_mutex_lock(&lock);
+    gpointer lookup_res = virtio_lookup_resource(uuid);
+    g_mutex_unlock(&lock);
+    return (struct VirtioSharedObject*) lookup_res;
+}
+
+int virtio_lookup_dmabuf(const QemuUUID *uuid)
+{
+    struct VirtioSharedObject *vso = get_shared_object(uuid);
+    if (vso == NULL) {
+        return -1;
+    }
+    assert(vso->type == TYPE_DMABUF);
+    return GPOINTER_TO_INT(vso->value);
+}
+
+struct vhost_dev *virtio_lookup_vhost_device(const QemuUUID *uuid)
+{
+    struct VirtioSharedObject *vso = get_shared_object(uuid);
+    if (vso == NULL) {
+        return NULL;
+    }
+    assert(vso->type == TYPE_VHOST_DEV);
+    return (struct vhost_dev *) vso->value;
+}
+
+enum SharedObjectType virtio_object_type(const QemuUUID *uuid)
+{
+    struct VirtioSharedObject *vso = get_shared_object(uuid);
+    if (vso == NULL) {
+        return TYPE_INVALID;
+    }
+    return vso->type;
+}
+
+void virtio_free_resources(void)
+{
+    g_hash_table_destroy(resource_uuids);
+    /* Reference count shall be 0 after the implicit unref on destroy */
+    resource_uuids = NULL;
+}
diff --git a/include/hw/virtio/virtio-dmabuf.h b/include/hw/virtio/virtio-dmabuf.h
new file mode 100644
index 0000000000..536e622555
--- /dev/null
+++ b/include/hw/virtio/virtio-dmabuf.h
@@ -0,0 +1,103 @@
+/*
+ * Virtio Shared dma-buf
+ *
+ * Copyright Red Hat, Inc. 2023
+ *
+ * Authors:
+ *     Albert Esteve <aesteve@redhat.com>
+ *
+ * This work is licensed under the terms of the GNU GPL, version 2.
+ * See the COPYING file in the top-level directory.
+ */
+
+#ifndef VIRTIO_DMABUF_H
+#define VIRTIO_DMABUF_H
+
+#include "qemu/osdep.h"
+
+#include <glib.h>
+#include "qemu/uuid.h"
+#include "vhost.h"
+
+enum SharedObjectType {
+    TYPE_INVALID = 0,
+    TYPE_DMABUF,
+    TYPE_VHOST_DEV,
+};
+
+struct VirtioSharedObject {
+    enum SharedObjectType type;
+    gpointer value;
+};
+
+/**
+ * virtio_add_dmabuf() - Add a new dma-buf resource to the lookup table
+ * @uuid: new resource's UUID
+ * @dmabuf_fd: the dma-buf descriptor that will be stored and shared with
+ *             other virtio devices. The caller retains ownership over the
+ *             descriptor and its lifecycle.
+ *
+ * Note: @dmabuf_fd must be a valid (non-negative) file descriptor.
+ *
+ * Return: true if the UUID did not exist and the resource has been added,
+ * false if another resource with the same UUID already existed.
+ * Note that if it finds a repeated UUID, the resource is not inserted in
+ * the lookup table.
+ */
+bool virtio_add_dmabuf(QemuUUID *uuid, int dmabuf_fd);
+
+/**
+ * virtio_add_vhost_device() - Add a new exporter vhost device that holds the
+ * resource with the associated UUID
+ * @uuid: new resource's UUID
+ * @dev: the pointer to the vhost device that holds the resource. The caller
+ *       retains ownership over the device struct and its lifecycle.
+ *
+ * Return: true if the UUID did not exist and the device has been tracked,
+ * false if another resource with the same UUID already existed.
+ * Note that if it finds a repeated UUID, the resource is not inserted in
+ * the lookup table.
+ */
+bool virtio_add_vhost_device(QemuUUID *uuid, struct vhost_dev *dev);
+
+/**
+ * virtio_remove_resource() - Removes a resource from the lookup table
+ * @uuid: resource's UUID
+ *
+ * Return: true if the UUID has been found and removed from the lookup table.
+ */
+bool virtio_remove_resource(const QemuUUID *uuid);
+
+/**
+ * virtio_lookup_dmabuf() - Looks for a dma-buf resource in the lookup table
+ * @uuid: resource's UUID
+ *
+ * Return: the dma-buf file descriptor integer, or -1 if the key is not found.
+ */
+int virtio_lookup_dmabuf(const QemuUUID *uuid);
+
+/**
+ * virtio_lookup_vhost_device() - Looks for an exporter vhost device in the
+ * lookup table
+ * @uuid: resource's UUID
+ *
+ * Return: pointer to the vhost_dev struct, or NULL if the key is not found.
+ */
+struct vhost_dev *virtio_lookup_vhost_device(const QemuUUID *uuid);
+
+/**
+ * virtio_object_type() - Looks for the type of resource in the lookup table
+ * @uuid: resource's UUID
+ *
+ * Return: the type of resource associated with the UUID, or TYPE_INVALID if
+ * the key is not found.
+ */
+enum SharedObjectType virtio_object_type(const QemuUUID *uuid);
+
+/**
+ * virtio_free_resources() - Destroys all keys and values of the shared
+ * resources lookup table, and frees them
+ */
+void virtio_free_resources(void);
+
+#endif /* VIRTIO_DMABUF_H */
diff --git a/tests/unit/meson.build b/tests/unit/meson.build
index 93977cc32d..425ecc30fb 100644
--- a/tests/unit/meson.build
+++ b/tests/unit/meson.build
@@ -50,6 +50,7 @@ tests = {
   'test-qapi-util': [],
   'test-interval-tree': [],
   'test-xs-node': [qom],
+  'test-virtio-dmabuf': [meson.project_source_root() / 'hw/display/virtio-dmabuf.c'],
 }
 
 if have_system or have_tools
diff --git a/tests/unit/test-virtio-dmabuf.c b/tests/unit/test-virtio-dmabuf.c
new file mode 100644
index 0000000000..40fe262538
--- /dev/null
+++ b/tests/unit/test-virtio-dmabuf.c
@@ -0,0 +1,137 @@
+/*
+ * QEMU tests for shared dma-buf API
+ *
+ * Copyright (c) 2023 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "qemu/osdep.h"
+#include "hw/virtio/virtio-dmabuf.h"
+
+
+static void test_add_remove_resources(void)
+{
+    QemuUUID uuid;
+    int i, dmabuf_fd;
+
+    for (i = 0; i < 100; ++i) {
+        qemu_uuid_generate(&uuid);
+        dmabuf_fd = g_random_int_range(3, 500);
+        /* Add a new resource */
+        g_assert(virtio_add_dmabuf(&uuid, dmabuf_fd));
+        g_assert_cmpint(virtio_lookup_dmabuf(&uuid), ==, dmabuf_fd);
+        /* Remove the resource */
+        g_assert(virtio_remove_resource(&uuid));
+        /* Resource is not found anymore */
+        g_assert_cmpint(virtio_lookup_dmabuf(&uuid), ==, -1);
+    }
+}
+
+static void test_add_remove_dev(void)
+{
+    QemuUUID uuid;
+    struct vhost_dev *dev = g_new0(struct vhost_dev, 1);
+    int i;
+
+    for (i = 0; i < 100; ++i) {
+        qemu_uuid_generate(&uuid);
+        virtio_add_vhost_device(&uuid, dev);
+        /* vhost device is found */
+        g_assert(virtio_lookup_vhost_device(&uuid) != NULL);
+        /* Remove the vhost device */
+        g_assert(virtio_remove_resource(&uuid));
+        /* vhost device is not found anymore */
+        g_assert(virtio_lookup_vhost_device(&uuid) == NULL);
+    }
+    g_free(dev);
+}
+
+static void test_remove_invalid_resource(void)
+{
+    QemuUUID uuid;
+    int i;
+
+    for (i = 0; i < 20; ++i) {
+        qemu_uuid_generate(&uuid);
+        g_assert_cmpint(virtio_lookup_dmabuf(&uuid), ==, -1);
+        /* Removing a resource that does not exist returns false */
+        g_assert_false(virtio_remove_resource(&uuid));
+    }
+}
+
+static void test_add_invalid_resource(void)
+{
+    QemuUUID uuid;
+    struct vhost_dev *dev = NULL;
+    int i, dmabuf_fd = -2, alt_dmabuf = 2;
+
+    for (i = 0; i < 20; ++i) {
+        qemu_uuid_generate(&uuid);
+        /* Add a new resource with invalid (negative) resource fd */
+        g_assert_false(virtio_add_dmabuf(&uuid, dmabuf_fd));
+        /* Resource is not found */
+        g_assert_cmpint(virtio_lookup_dmabuf(&uuid), ==, -1);
+        /* Add a new vhost device with invalid (NULL) pointer */
+        g_assert_false(virtio_add_vhost_device(&uuid, dev));
+        /* vhost device is not found */
+        g_assert(virtio_lookup_vhost_device(&uuid) == NULL);
+    }
+
+    for (i = 0; i < 20; ++i) {
+        /* Add a valid resource */
+        qemu_uuid_generate(&uuid);
+        dmabuf_fd = g_random_int_range(3, 500);
+        g_assert(virtio_add_dmabuf(&uuid, dmabuf_fd));
+        g_assert_cmpint(virtio_lookup_dmabuf(&uuid), ==, dmabuf_fd);
+        /* Add a new resource with repeated uuid returns false */
+        g_assert_false(virtio_add_dmabuf(&uuid, alt_dmabuf));
+        /* The value for the uuid key is not replaced */
+        g_assert_cmpint(virtio_lookup_dmabuf(&uuid), ==, dmabuf_fd);
+    }
+}
+
+static void test_free_resources(void)
+{
+    QemuUUID uuids[20];
+    int i, dmabuf_fd;
+
+    for (i = 0; i < ARRAY_SIZE(uuids); ++i) {
+        qemu_uuid_generate(&uuids[i]);
+        dmabuf_fd = g_random_int_range(3, 500);
+        g_assert(virtio_add_dmabuf(&uuids[i], dmabuf_fd));
+        g_assert_cmpint(virtio_lookup_dmabuf(&uuids[i]), ==, dmabuf_fd);
+    }
+    virtio_free_resources();
+    for (i = 0; i < ARRAY_SIZE(uuids); ++i) {
+        /* None of the resources is found after free'd */
+        g_assert_cmpint(virtio_lookup_dmabuf(&uuids[i]), ==, -1);
+    }
+
+}
+
+int main(int argc, char **argv)
+{
+    g_test_init(&argc, &argv, NULL);
+    g_test_add_func("/virtio-dmabuf/add_rm_res", test_add_remove_resources);
+        g_test_add_func("/virtio-dmabuf/add_rm_dev", test_add_remove_dev);
+    g_test_add_func("/virtio-dmabuf/rm_invalid_res",
+                    test_remove_invalid_resource);
+    g_test_add_func("/virtio-dmabuf/add_invalid_res",
+                    test_add_invalid_resource);
+    g_test_add_func("/virtio-dmabuf/free_res", test_free_resources);
+
+    return g_test_run();
+}
-- 
2.40.0

Re: [PATCH v5 2/4] virtio-dmabuf: introduce virtio-dmabuf

[Philippe Mathieu-Daudé]

Hi Albert,

On 2/8/23 11:08, Albert Esteve wrote:
> This API manages objects (in this iteration,
> dmabuf fds) that can be shared along different
> virtio devices, associated to a UUID.
> 
> The API allows the different devices to add,
> remove and/or retrieve the objects by simply
> invoking the public functions that reside in the
> virtio-dmabuf file.
> 
> For vhost backends, the API stores the pointer
> to the backend holding the object.
> 
> Suggested-by: Gerd Hoffmann <kraxel@redhat.com>
> Signed-off-by: Albert Esteve <aesteve@redhat.com>
> ---
>   MAINTAINERS                       |   7 ++
>   hw/display/meson.build            |   1 +
>   hw/display/virtio-dmabuf.c        | 136 +++++++++++++++++++++++++++++
>   include/hw/virtio/virtio-dmabuf.h | 103 ++++++++++++++++++++++
>   tests/unit/meson.build            |   1 +
>   tests/unit/test-virtio-dmabuf.c   | 137 ++++++++++++++++++++++++++++++
>   6 files changed, 385 insertions(+)
>   create mode 100644 hw/display/virtio-dmabuf.c
>   create mode 100644 include/hw/virtio/virtio-dmabuf.h
>   create mode 100644 tests/unit/test-virtio-dmabuf.c
> 
> diff --git a/MAINTAINERS b/MAINTAINERS
> index 12e59b6b27..cd8487785a 100644
> --- a/MAINTAINERS
> +++ b/MAINTAINERS
> @@ -2158,6 +2158,13 @@ T: git https://gitlab.com/cohuck/qemu.git s390-next
>   T: git https://github.com/borntraeger/qemu.git s390-next
>   L: qemu-s390x@nongnu.org
>   
> +virtio-dmabuf
> +M: Albert Esteve <aesteve@redhat.com>
> +S: Supported
> +F: hw/display/virtio-dmabuf.c
> +F: include/hw/virtio/virtio-dmabuf.h
> +F: tests/unit/test-virtio-dmabuf.c
> +
>   virtiofs
>   M: Stefan Hajnoczi <stefanha@redhat.com>
>   S: Supported
> diff --git a/hw/display/meson.build b/hw/display/meson.build
> index 413ba4ab24..05619c6968 100644
> --- a/hw/display/meson.build
> +++ b/hw/display/meson.build
> @@ -37,6 +37,7 @@ system_ss.add(when: 'CONFIG_MACFB', if_true: files('macfb.c'))
>   system_ss.add(when: 'CONFIG_NEXTCUBE', if_true: files('next-fb.c'))
>   
>   system_ss.add(when: 'CONFIG_VGA', if_true: files('vga.c'))
> +system_ss.add(when: 'CONFIG_VIRTIO', if_true: files('virtio-dmabuf.c'))
>   
>   if (config_all_devices.has_key('CONFIG_VGA_CIRRUS') or
>       config_all_devices.has_key('CONFIG_VGA_PCI') or
> diff --git a/hw/display/virtio-dmabuf.c b/hw/display/virtio-dmabuf.c
> new file mode 100644
> index 0000000000..e852c71ba9
> --- /dev/null
> +++ b/hw/display/virtio-dmabuf.c
> @@ -0,0 +1,136 @@
> +/*
> + * Virtio Shared dma-buf
> + *
> + * Copyright Red Hat, Inc. 2023
> + *
> + * Authors:
> + *     Albert Esteve <aesteve@redhat.com>
> + *
> + * This work is licensed under the terms of the GNU GPL, version 2 or later.
> + * See the COPYING file in the top-level directory.
> + */
> +
> +#include "hw/virtio/virtio-dmabuf.h"
> +
> +
> +static GMutex lock;
> +static GHashTable *resource_uuids;
> +
> +/*
> + * uuid_equal_func: wrapper for UUID is_equal function to
> + * satisfy g_hash_table_new expected parameters signatures.
> + */
> +static int uuid_equal_func(const void *lhv, const void *rhv)
> +{
> +    return qemu_uuid_is_equal(lhv, rhv);
> +}
> +
> +static bool virtio_add_resource(QemuUUID *uuid, struct VirtioSharedObject *value)

Per QEMU coding style we use typedefs, so "VirtioSharedObject" here.

> +{
> +    if (resource_uuids == NULL) {
> +        resource_uuids = g_hash_table_new_full(
> +            qemu_uuid_hash, uuid_equal_func, NULL, g_free);
> +    }
> +    if (g_hash_table_lookup(resource_uuids, uuid) != NULL) {
> +        return false;
> +    }
> +
> +    return g_hash_table_insert(resource_uuids, uuid, value);

Hmm shouldn't this function take the lock to access resource_uuids?

> +}
> +
> +static gpointer virtio_lookup_resource(const QemuUUID *uuid)
> +{
> +    if (resource_uuids == NULL) {
> +        return NULL;
> +    }
> +
> +    return g_hash_table_lookup(resource_uuids, uuid);

Ditto.

Here you can directly return the casted type (VirtioSharedObject *),
since a plain gpointer isn't really used / useful.

> +}
> +
> +bool virtio_add_dmabuf(QemuUUID *uuid, int udmabuf_fd)
> +{
> +    bool result;
> +    struct VirtioSharedObject *vso;
> +    if (udmabuf_fd < 0) {
> +        return false;
> +    }
> +    vso = g_new0(struct VirtioSharedObject, 1);

s/g_new0/g_new/

> +    g_mutex_lock(&lock);
> +    vso->type = TYPE_DMABUF;
> +    vso->value = GINT_TO_POINTER(udmabuf_fd);
> +    result = virtio_add_resource(uuid, vso);
> +    g_mutex_unlock(&lock);
> +
> +    return result;
> +}
> +
> +bool virtio_add_vhost_device(QemuUUID *uuid, struct vhost_dev *dev)
> +{
> +    bool result;
> +    struct VirtioSharedObject *vso;
> +    if (dev == NULL) {
> +        return false;
> +    }
> +    vso = g_new0(struct VirtioSharedObject, 1);
> +    g_mutex_lock(&lock);
> +    vso->type = TYPE_VHOST_DEV;
> +    vso->value = dev;
> +    result = virtio_add_resource(uuid, vso);

Ah, you lock here... I'd rather do it in the callee.

> +    g_mutex_unlock(&lock);
> +
> +    return result;
> +}
> +
> +bool virtio_remove_resource(const QemuUUID *uuid)
> +{
> +    bool result;
> +    g_mutex_lock(&lock);
> +    result = g_hash_table_remove(resource_uuids, uuid);
> +    g_mutex_unlock(&lock);

virtio_remove_resource() correctly locks. For API parity,
virtio_add_resource() should too.

> +
> +    return result;
> +}
> +
> +static struct VirtioSharedObject *get_shared_object(const QemuUUID *uuid)
> +{
> +    g_mutex_lock(&lock);
> +    gpointer lookup_res = virtio_lookup_resource(uuid);
> +    g_mutex_unlock(&lock);
> +    return (struct VirtioSharedObject*) lookup_res;

See earlier, this function can be merged with virtio_lookup_resource().

> +}
> +
> +int virtio_lookup_dmabuf(const QemuUUID *uuid)
> +{
> +    struct VirtioSharedObject *vso = get_shared_object(uuid);
> +    if (vso == NULL) {
> +        return -1;
> +    }
> +    assert(vso->type == TYPE_DMABUF);
> +    return GPOINTER_TO_INT(vso->value);
> +}
> +
> +struct vhost_dev *virtio_lookup_vhost_device(const QemuUUID *uuid)
> +{
> +    struct VirtioSharedObject *vso = get_shared_object(uuid);
> +    if (vso == NULL) {
> +        return NULL;
> +    }
> +    assert(vso->type == TYPE_VHOST_DEV);
> +    return (struct vhost_dev *) vso->value;
> +}
> +
> +enum SharedObjectType virtio_object_type(const QemuUUID *uuid)
> +{
> +    struct VirtioSharedObject *vso = get_shared_object(uuid);
> +    if (vso == NULL) {
> +        return TYPE_INVALID;
> +    }
> +    return vso->type;
> +}
> +
> +void virtio_free_resources(void)
> +{
> +    g_hash_table_destroy(resource_uuids);

Lock?

> +    /* Reference count shall be 0 after the implicit unref on destroy */
> +    resource_uuids = NULL;
> +}
> diff --git a/include/hw/virtio/virtio-dmabuf.h b/include/hw/virtio/virtio-dmabuf.h
> new file mode 100644
> index 0000000000..536e622555
> --- /dev/null
> +++ b/include/hw/virtio/virtio-dmabuf.h
> @@ -0,0 +1,103 @@
> +/*
> + * Virtio Shared dma-buf
> + *
> + * Copyright Red Hat, Inc. 2023
> + *
> + * Authors:
> + *     Albert Esteve <aesteve@redhat.com>
> + *
> + * This work is licensed under the terms of the GNU GPL, version 2.
> + * See the COPYING file in the top-level directory.
> + */
> +
> +#ifndef VIRTIO_DMABUF_H
> +#define VIRTIO_DMABUF_H
> +
> +#include "qemu/osdep.h"
> +
> +#include <glib.h>
> +#include "qemu/uuid.h"
> +#include "vhost.h"
> +
> +enum SharedObjectType {
> +    TYPE_INVALID = 0,
> +    TYPE_DMABUF,
> +    TYPE_VHOST_DEV,
> +};
> +

Please declare a

typedef

> +struct VirtioSharedObject {
> +    enum SharedObjectType type;
> +    gpointer value;
> +};

VirtioSharedObject;

and use it instead of 'struct VirtioSharedObject'.

Regards,

Phil.

Re: [PATCH v5 2/4] virtio-dmabuf: introduce virtio-dmabuf

[Albert Esteve]

[-- Attachment #1: Type: text/plain, Size: 8797 bytes --]

On Wed, Sep 6, 2023 at 7:56 AM Philippe Mathieu-Daudé <philmd@linaro.org>
wrote:

> Hi Albert,
>
> On 2/8/23 11:08, Albert Esteve wrote:
> > This API manages objects (in this iteration,
> > dmabuf fds) that can be shared along different
> > virtio devices, associated to a UUID.
> >
> > The API allows the different devices to add,
> > remove and/or retrieve the objects by simply
> > invoking the public functions that reside in the
> > virtio-dmabuf file.
> >
> > For vhost backends, the API stores the pointer
> > to the backend holding the object.
> >
> > Suggested-by: Gerd Hoffmann <kraxel@redhat.com>
> > Signed-off-by: Albert Esteve <aesteve@redhat.com>
> > ---
> >   MAINTAINERS                       |   7 ++
> >   hw/display/meson.build            |   1 +
> >   hw/display/virtio-dmabuf.c        | 136 +++++++++++++++++++++++++++++
> >   include/hw/virtio/virtio-dmabuf.h | 103 ++++++++++++++++++++++
> >   tests/unit/meson.build            |   1 +
> >   tests/unit/test-virtio-dmabuf.c   | 137 ++++++++++++++++++++++++++++++
> >   6 files changed, 385 insertions(+)
> >   create mode 100644 hw/display/virtio-dmabuf.c
> >   create mode 100644 include/hw/virtio/virtio-dmabuf.h
> >   create mode 100644 tests/unit/test-virtio-dmabuf.c
> >
> > diff --git a/MAINTAINERS b/MAINTAINERS
> > index 12e59b6b27..cd8487785a 100644
> > --- a/MAINTAINERS
> > +++ b/MAINTAINERS
> > @@ -2158,6 +2158,13 @@ T: git https://gitlab.com/cohuck/qemu.git
> s390-next
> >   T: git https://github.com/borntraeger/qemu.git s390-next
> >   L: qemu-s390x@nongnu.org
> >
> > +virtio-dmabuf
> > +M: Albert Esteve <aesteve@redhat.com>
> > +S: Supported
> > +F: hw/display/virtio-dmabuf.c
> > +F: include/hw/virtio/virtio-dmabuf.h
> > +F: tests/unit/test-virtio-dmabuf.c
> > +
> >   virtiofs
> >   M: Stefan Hajnoczi <stefanha@redhat.com>
> >   S: Supported
> > diff --git a/hw/display/meson.build b/hw/display/meson.build
> > index 413ba4ab24..05619c6968 100644
> > --- a/hw/display/meson.build
> > +++ b/hw/display/meson.build
> > @@ -37,6 +37,7 @@ system_ss.add(when: 'CONFIG_MACFB', if_true:
> files('macfb.c'))
> >   system_ss.add(when: 'CONFIG_NEXTCUBE', if_true: files('next-fb.c'))
> >
> >   system_ss.add(when: 'CONFIG_VGA', if_true: files('vga.c'))
> > +system_ss.add(when: 'CONFIG_VIRTIO', if_true: files('virtio-dmabuf.c'))
> >
> >   if (config_all_devices.has_key('CONFIG_VGA_CIRRUS') or
> >       config_all_devices.has_key('CONFIG_VGA_PCI') or
> > diff --git a/hw/display/virtio-dmabuf.c b/hw/display/virtio-dmabuf.c
> > new file mode 100644
> > index 0000000000..e852c71ba9
> > --- /dev/null
> > +++ b/hw/display/virtio-dmabuf.c
> > @@ -0,0 +1,136 @@
> > +/*
> > + * Virtio Shared dma-buf
> > + *
> > + * Copyright Red Hat, Inc. 2023
> > + *
> > + * Authors:
> > + *     Albert Esteve <aesteve@redhat.com>
> > + *
> > + * This work is licensed under the terms of the GNU GPL, version 2 or
> later.
> > + * See the COPYING file in the top-level directory.
> > + */
> > +
> > +#include "hw/virtio/virtio-dmabuf.h"
> > +
> > +
> > +static GMutex lock;
> > +static GHashTable *resource_uuids;
> > +
> > +/*
> > + * uuid_equal_func: wrapper for UUID is_equal function to
> > + * satisfy g_hash_table_new expected parameters signatures.
> > + */
> > +static int uuid_equal_func(const void *lhv, const void *rhv)
> > +{
> > +    return qemu_uuid_is_equal(lhv, rhv);
> > +}
> > +
> > +static bool virtio_add_resource(QemuUUID *uuid, struct
> VirtioSharedObject *value)
>
> Per QEMU coding style we use typedefs, so "VirtioSharedObject" here.
>
> > +{
> > +    if (resource_uuids == NULL) {
> > +        resource_uuids = g_hash_table_new_full(
> > +            qemu_uuid_hash, uuid_equal_func, NULL, g_free);
> > +    }
> > +    if (g_hash_table_lookup(resource_uuids, uuid) != NULL) {
> > +        return false;
> > +    }
> > +
> > +    return g_hash_table_insert(resource_uuids, uuid, value);
>
> Hmm shouldn't this function take the lock to access resource_uuids?
>
> > +}
> > +
> > +static gpointer virtio_lookup_resource(const QemuUUID *uuid)
> > +{
> > +    if (resource_uuids == NULL) {
> > +        return NULL;
> > +    }
> > +
> > +    return g_hash_table_lookup(resource_uuids, uuid);
>
> Ditto.
>
> Here you can directly return the casted type (VirtioSharedObject *),
> since a plain gpointer isn't really used / useful.
>
> > +}
> > +
> > +bool virtio_add_dmabuf(QemuUUID *uuid, int udmabuf_fd)
> > +{
> > +    bool result;
> > +    struct VirtioSharedObject *vso;
> > +    if (udmabuf_fd < 0) {
> > +        return false;
> > +    }
> > +    vso = g_new0(struct VirtioSharedObject, 1);
>
> s/g_new0/g_new/
>
> > +    g_mutex_lock(&lock);
> > +    vso->type = TYPE_DMABUF;
> > +    vso->value = GINT_TO_POINTER(udmabuf_fd);
> > +    result = virtio_add_resource(uuid, vso);
> > +    g_mutex_unlock(&lock);
> > +
> > +    return result;
> > +}
> > +
> > +bool virtio_add_vhost_device(QemuUUID *uuid, struct vhost_dev *dev)
> > +{
> > +    bool result;
> > +    struct VirtioSharedObject *vso;
> > +    if (dev == NULL) {
> > +        return false;
> > +    }
> > +    vso = g_new0(struct VirtioSharedObject, 1);
> > +    g_mutex_lock(&lock);
> > +    vso->type = TYPE_VHOST_DEV;
> > +    vso->value = dev;
> > +    result = virtio_add_resource(uuid, vso);
>
> Ah, you lock here... I'd rather do it in the callee.
>
> > +    g_mutex_unlock(&lock);
> > +
> > +    return result;
> > +}
> > +
> > +bool virtio_remove_resource(const QemuUUID *uuid)
> > +{
> > +    bool result;
> > +    g_mutex_lock(&lock);
> > +    result = g_hash_table_remove(resource_uuids, uuid);
> > +    g_mutex_unlock(&lock);
>
> virtio_remove_resource() correctly locks. For API parity,
> virtio_add_resource() should too.
>
> > +
> > +    return result;
> > +}
> > +
> > +static struct VirtioSharedObject *get_shared_object(const QemuUUID
> *uuid)
> > +{
> > +    g_mutex_lock(&lock);
> > +    gpointer lookup_res = virtio_lookup_resource(uuid);
> > +    g_mutex_unlock(&lock);
> > +    return (struct VirtioSharedObject*) lookup_res;
>
> See earlier, this function can be merged with virtio_lookup_resource().
>
> > +}
> > +
> > +int virtio_lookup_dmabuf(const QemuUUID *uuid)
> > +{
> > +    struct VirtioSharedObject *vso = get_shared_object(uuid);
> > +    if (vso == NULL) {
> > +        return -1;
> > +    }
> > +    assert(vso->type == TYPE_DMABUF);
> > +    return GPOINTER_TO_INT(vso->value);
> > +}
> > +
> > +struct vhost_dev *virtio_lookup_vhost_device(const QemuUUID *uuid)
> > +{
> > +    struct VirtioSharedObject *vso = get_shared_object(uuid);
> > +    if (vso == NULL) {
> > +        return NULL;
> > +    }
> > +    assert(vso->type == TYPE_VHOST_DEV);
> > +    return (struct vhost_dev *) vso->value;
> > +}
> > +
> > +enum SharedObjectType virtio_object_type(const QemuUUID *uuid)
> > +{
> > +    struct VirtioSharedObject *vso = get_shared_object(uuid);
> > +    if (vso == NULL) {
> > +        return TYPE_INVALID;
> > +    }
> > +    return vso->type;
> > +}
> > +
> > +void virtio_free_resources(void)
> > +{
> > +    g_hash_table_destroy(resource_uuids);
>
> Lock?
>
> > +    /* Reference count shall be 0 after the implicit unref on destroy */
> > +    resource_uuids = NULL;
> > +}
> > diff --git a/include/hw/virtio/virtio-dmabuf.h
> b/include/hw/virtio/virtio-dmabuf.h
> > new file mode 100644
> > index 0000000000..536e622555
> > --- /dev/null
> > +++ b/include/hw/virtio/virtio-dmabuf.h
> > @@ -0,0 +1,103 @@
> > +/*
> > + * Virtio Shared dma-buf
> > + *
> > + * Copyright Red Hat, Inc. 2023
> > + *
> > + * Authors:
> > + *     Albert Esteve <aesteve@redhat.com>
> > + *
> > + * This work is licensed under the terms of the GNU GPL, version 2.
> > + * See the COPYING file in the top-level directory.
> > + */
> > +
> > +#ifndef VIRTIO_DMABUF_H
> > +#define VIRTIO_DMABUF_H
> > +
> > +#include "qemu/osdep.h"
> > +
> > +#include <glib.h>
> > +#include "qemu/uuid.h"
> > +#include "vhost.h"
> > +
> > +enum SharedObjectType {
> > +    TYPE_INVALID = 0,
> > +    TYPE_DMABUF,
> > +    TYPE_VHOST_DEV,
> > +};
> > +
>
> Please declare a
>
> typedef
>
> > +struct VirtioSharedObject {
> > +    enum SharedObjectType type;
> > +    gpointer value;
> > +};
>
> VirtioSharedObject;
>
> and use it instead of 'struct VirtioSharedObject'.
>
>
You mean making the struct anonymous and typedefing?
Should I do the same with the enum? In other files I see enums are typedef
too, but not anonymous (e.g., block/qcow2.h).
So I could do the same here.

For the rest... Ack!


> Regards,
>
> Phil.
>
>

[-- Attachment #2: Type: text/html, Size: 11652 bytes --]

Re: [PATCH v5 2/4] virtio-dmabuf: introduce virtio-dmabuf

[Albert Esteve]

[-- Attachment #1: Type: text/plain, Size: 9436 bytes --]

On Wed, Sep 6, 2023 at 9:42 AM Albert Esteve <aesteve@redhat.com> wrote:

>
>
> On Wed, Sep 6, 2023 at 7:56 AM Philippe Mathieu-Daudé <philmd@linaro.org>
> wrote:
>
>> Hi Albert,
>>
>> On 2/8/23 11:08, Albert Esteve wrote:
>> > This API manages objects (in this iteration,
>> > dmabuf fds) that can be shared along different
>> > virtio devices, associated to a UUID.
>> >
>> > The API allows the different devices to add,
>> > remove and/or retrieve the objects by simply
>> > invoking the public functions that reside in the
>> > virtio-dmabuf file.
>> >
>> > For vhost backends, the API stores the pointer
>> > to the backend holding the object.
>> >
>> > Suggested-by: Gerd Hoffmann <kraxel@redhat.com>
>> > Signed-off-by: Albert Esteve <aesteve@redhat.com>
>> > ---
>> >   MAINTAINERS                       |   7 ++
>> >   hw/display/meson.build            |   1 +
>> >   hw/display/virtio-dmabuf.c        | 136 +++++++++++++++++++++++++++++
>> >   include/hw/virtio/virtio-dmabuf.h | 103 ++++++++++++++++++++++
>> >   tests/unit/meson.build            |   1 +
>> >   tests/unit/test-virtio-dmabuf.c   | 137 ++++++++++++++++++++++++++++++
>> >   6 files changed, 385 insertions(+)
>> >   create mode 100644 hw/display/virtio-dmabuf.c
>> >   create mode 100644 include/hw/virtio/virtio-dmabuf.h
>> >   create mode 100644 tests/unit/test-virtio-dmabuf.c
>> >
>> > diff --git a/MAINTAINERS b/MAINTAINERS
>> > index 12e59b6b27..cd8487785a 100644
>> > --- a/MAINTAINERS
>> > +++ b/MAINTAINERS
>> > @@ -2158,6 +2158,13 @@ T: git https://gitlab.com/cohuck/qemu.git
>> s390-next
>> >   T: git https://github.com/borntraeger/qemu.git s390-next
>> >   L: qemu-s390x@nongnu.org
>> >
>> > +virtio-dmabuf
>> > +M: Albert Esteve <aesteve@redhat.com>
>> > +S: Supported
>> > +F: hw/display/virtio-dmabuf.c
>> > +F: include/hw/virtio/virtio-dmabuf.h
>> > +F: tests/unit/test-virtio-dmabuf.c
>> > +
>> >   virtiofs
>> >   M: Stefan Hajnoczi <stefanha@redhat.com>
>> >   S: Supported
>> > diff --git a/hw/display/meson.build b/hw/display/meson.build
>> > index 413ba4ab24..05619c6968 100644
>> > --- a/hw/display/meson.build
>> > +++ b/hw/display/meson.build
>> > @@ -37,6 +37,7 @@ system_ss.add(when: 'CONFIG_MACFB', if_true:
>> files('macfb.c'))
>> >   system_ss.add(when: 'CONFIG_NEXTCUBE', if_true: files('next-fb.c'))
>> >
>> >   system_ss.add(when: 'CONFIG_VGA', if_true: files('vga.c'))
>> > +system_ss.add(when: 'CONFIG_VIRTIO', if_true: files('virtio-dmabuf.c'))
>> >
>> >   if (config_all_devices.has_key('CONFIG_VGA_CIRRUS') or
>> >       config_all_devices.has_key('CONFIG_VGA_PCI') or
>> > diff --git a/hw/display/virtio-dmabuf.c b/hw/display/virtio-dmabuf.c
>> > new file mode 100644
>> > index 0000000000..e852c71ba9
>> > --- /dev/null
>> > +++ b/hw/display/virtio-dmabuf.c
>> > @@ -0,0 +1,136 @@
>> > +/*
>> > + * Virtio Shared dma-buf
>> > + *
>> > + * Copyright Red Hat, Inc. 2023
>> > + *
>> > + * Authors:
>> > + *     Albert Esteve <aesteve@redhat.com>
>> > + *
>> > + * This work is licensed under the terms of the GNU GPL, version 2 or
>> later.
>> > + * See the COPYING file in the top-level directory.
>> > + */
>> > +
>> > +#include "hw/virtio/virtio-dmabuf.h"
>> > +
>> > +
>> > +static GMutex lock;
>> > +static GHashTable *resource_uuids;
>> > +
>> > +/*
>> > + * uuid_equal_func: wrapper for UUID is_equal function to
>> > + * satisfy g_hash_table_new expected parameters signatures.
>> > + */
>> > +static int uuid_equal_func(const void *lhv, const void *rhv)
>> > +{
>> > +    return qemu_uuid_is_equal(lhv, rhv);
>> > +}
>> > +
>> > +static bool virtio_add_resource(QemuUUID *uuid, struct
>> VirtioSharedObject *value)
>>
>> Per QEMU coding style we use typedefs, so "VirtioSharedObject" here.
>>
>> > +{
>> > +    if (resource_uuids == NULL) {
>> > +        resource_uuids = g_hash_table_new_full(
>> > +            qemu_uuid_hash, uuid_equal_func, NULL, g_free);
>> > +    }
>> > +    if (g_hash_table_lookup(resource_uuids, uuid) != NULL) {
>> > +        return false;
>> > +    }
>> > +
>> > +    return g_hash_table_insert(resource_uuids, uuid, value);
>>
>> Hmm shouldn't this function take the lock to access resource_uuids?
>>
>> > +}
>> > +
>> > +static gpointer virtio_lookup_resource(const QemuUUID *uuid)
>> > +{
>> > +    if (resource_uuids == NULL) {
>> > +        return NULL;
>> > +    }
>> > +
>> > +    return g_hash_table_lookup(resource_uuids, uuid);
>>
>> Ditto.
>>
>> Here you can directly return the casted type (VirtioSharedObject *),
>> since a plain gpointer isn't really used / useful.
>>
>> > +}
>> > +
>> > +bool virtio_add_dmabuf(QemuUUID *uuid, int udmabuf_fd)
>> > +{
>> > +    bool result;
>> > +    struct VirtioSharedObject *vso;
>> > +    if (udmabuf_fd < 0) {
>> > +        return false;
>> > +    }
>> > +    vso = g_new0(struct VirtioSharedObject, 1);
>>
>> s/g_new0/g_new/
>>
>> > +    g_mutex_lock(&lock);
>> > +    vso->type = TYPE_DMABUF;
>> > +    vso->value = GINT_TO_POINTER(udmabuf_fd);
>> > +    result = virtio_add_resource(uuid, vso);
>> > +    g_mutex_unlock(&lock);
>> > +
>> > +    return result;
>> > +}
>> > +
>> > +bool virtio_add_vhost_device(QemuUUID *uuid, struct vhost_dev *dev)
>> > +{
>> > +    bool result;
>> > +    struct VirtioSharedObject *vso;
>> > +    if (dev == NULL) {
>> > +        return false;
>> > +    }
>> > +    vso = g_new0(struct VirtioSharedObject, 1);
>> > +    g_mutex_lock(&lock);
>> > +    vso->type = TYPE_VHOST_DEV;
>> > +    vso->value = dev;
>> > +    result = virtio_add_resource(uuid, vso);
>>
>> Ah, you lock here... I'd rather do it in the callee.
>>
>> > +    g_mutex_unlock(&lock);
>> > +
>> > +    return result;
>> > +}
>> > +
>> > +bool virtio_remove_resource(const QemuUUID *uuid)
>> > +{
>> > +    bool result;
>> > +    g_mutex_lock(&lock);
>> > +    result = g_hash_table_remove(resource_uuids, uuid);
>> > +    g_mutex_unlock(&lock);
>>
>> virtio_remove_resource() correctly locks. For API parity,
>> virtio_add_resource() should too.
>>
>> > +
>> > +    return result;
>> > +}
>> > +
>> > +static struct VirtioSharedObject *get_shared_object(const QemuUUID
>> *uuid)
>> > +{
>> > +    g_mutex_lock(&lock);
>> > +    gpointer lookup_res = virtio_lookup_resource(uuid);
>> > +    g_mutex_unlock(&lock);
>> > +    return (struct VirtioSharedObject*) lookup_res;
>>
>> See earlier, this function can be merged with virtio_lookup_resource().
>>
>> > +}
>> > +
>> > +int virtio_lookup_dmabuf(const QemuUUID *uuid)
>> > +{
>> > +    struct VirtioSharedObject *vso = get_shared_object(uuid);
>> > +    if (vso == NULL) {
>> > +        return -1;
>> > +    }
>> > +    assert(vso->type == TYPE_DMABUF);
>> > +    return GPOINTER_TO_INT(vso->value);
>> > +}
>> > +
>> > +struct vhost_dev *virtio_lookup_vhost_device(const QemuUUID *uuid)
>> > +{
>> > +    struct VirtioSharedObject *vso = get_shared_object(uuid);
>> > +    if (vso == NULL) {
>> > +        return NULL;
>> > +    }
>> > +    assert(vso->type == TYPE_VHOST_DEV);
>> > +    return (struct vhost_dev *) vso->value;
>> > +}
>> > +
>> > +enum SharedObjectType virtio_object_type(const QemuUUID *uuid)
>> > +{
>> > +    struct VirtioSharedObject *vso = get_shared_object(uuid);
>> > +    if (vso == NULL) {
>> > +        return TYPE_INVALID;
>> > +    }
>> > +    return vso->type;
>> > +}
>> > +
>> > +void virtio_free_resources(void)
>> > +{
>> > +    g_hash_table_destroy(resource_uuids);
>>
>> Lock?
>>
>> > +    /* Reference count shall be 0 after the implicit unref on destroy
>> */
>> > +    resource_uuids = NULL;
>> > +}
>> > diff --git a/include/hw/virtio/virtio-dmabuf.h
>> b/include/hw/virtio/virtio-dmabuf.h
>> > new file mode 100644
>> > index 0000000000..536e622555
>> > --- /dev/null
>> > +++ b/include/hw/virtio/virtio-dmabuf.h
>> > @@ -0,0 +1,103 @@
>> > +/*
>> > + * Virtio Shared dma-buf
>> > + *
>> > + * Copyright Red Hat, Inc. 2023
>> > + *
>> > + * Authors:
>> > + *     Albert Esteve <aesteve@redhat.com>
>> > + *
>> > + * This work is licensed under the terms of the GNU GPL, version 2.
>> > + * See the COPYING file in the top-level directory.
>> > + */
>> > +
>> > +#ifndef VIRTIO_DMABUF_H
>> > +#define VIRTIO_DMABUF_H
>> > +
>> > +#include "qemu/osdep.h"
>> > +
>> > +#include <glib.h>
>> > +#include "qemu/uuid.h"
>> > +#include "vhost.h"
>> > +
>> > +enum SharedObjectType {
>> > +    TYPE_INVALID = 0,
>> > +    TYPE_DMABUF,
>> > +    TYPE_VHOST_DEV,
>> > +};
>> > +
>>
>> Please declare a
>>
>> typedef
>>
>> > +struct VirtioSharedObject {
>> > +    enum SharedObjectType type;
>> > +    gpointer value;
>> > +};
>>
>> VirtioSharedObject;
>>
>> and use it instead of 'struct VirtioSharedObject'.
>>
>>
> You mean making the struct anonymous and typedefing?
>

So after re-reading your comment and looking for more examples in the
codebase, I see
it is not uncommon to have a named struct also typedef in the same
declaration.
So I will typedef, but not make it anonymous, same for the enum.


> Should I do the same with the enum? In other files I see enums are typedef
> too, but not anonymous (e.g., block/qcow2.h).
> So I could do the same here.
>
> For the rest... Ack!
>
>
>> Regards,
>>
>> Phil.
>>
>>

[-- Attachment #2: Type: text/html, Size: 12601 bytes --]

Re: [PATCH v5 2/4] virtio-dmabuf: introduce virtio-dmabuf

[Philippe Mathieu-Daudé]

On 6/9/23 10:45, Albert Esteve wrote:

>          > diff --git a/include/hw/virtio/virtio-dmabuf.h
>         b/include/hw/virtio/virtio-dmabuf.h
>          > new file mode 100644
>          > index 0000000000..536e622555
>          > --- /dev/null
>          > +++ b/include/hw/virtio/virtio-dmabuf.h
>          > @@ -0,0 +1,103 @@
>          > +/*
>          > + * Virtio Shared dma-buf
>          > + *
>          > + * Copyright Red Hat, Inc. 2023
>          > + *
>          > + * Authors:
>          > + *     Albert Esteve <aesteve@redhat.com
>         <mailto:aesteve@redhat.com>>
>          > + *
>          > + * This work is licensed under the terms of the GNU GPL,
>         version 2.
>          > + * See the COPYING file in the top-level directory.
>          > + */
>          > +
>          > +#ifndef VIRTIO_DMABUF_H
>          > +#define VIRTIO_DMABUF_H
>          > +
>          > +#include "qemu/osdep.h"
>          > +
>          > +#include <glib.h>
>          > +#include "qemu/uuid.h"
>          > +#include "vhost.h"
>          > +
>          > +enum SharedObjectType {
>          > +    TYPE_INVALID = 0,
>          > +    TYPE_DMABUF,
>          > +    TYPE_VHOST_DEV,
>          > +};
>          > +
> 
>         Please declare a
> 
>         typedef
> 
>          > +struct VirtioSharedObject {
>          > +    enum SharedObjectType type;
>          > +    gpointer value;
>          > +};
> 
>         VirtioSharedObject;
> 
>         and use it instead of 'struct VirtioSharedObject'.
> 
> 
>     You mean making the struct anonymous and typedefing?
> 
> 
> So after re-reading your comment and looking for more examples in the 
> codebase, I see
> it is not uncommon to have a named struct also typedef in the same 
> declaration.
> So I will typedef, but not make it anonymous, same for the enum.

Correct (see https://qemu-project.gitlab.io/qemu/devel/style.html#typedefs

>     Should I do the same with the enum? In other files I see enums are
>     typedef too, but not anonymous (e.g., block/qcow2.h).
>     So I could do the same here.
> 
>     For the rest... Ack!

Thanks!

Phil.

[PATCH v5 3/4] vhost-user: add shared_object msg

[Albert Esteve]

Add three new vhost-user protocol
`VHOST_USER_BACKEND_SHARED_OBJECT_* messages`.
These new messages are sent from vhost-user
back-ends to interact with the virtio-dmabuf
table in order to add or remove themselves as
virtio exporters, or lookup for virtio dma-buf
shared objects.

The action taken in the front-end depends
on the type stored in the virtio shared
object hash table.

When the table holds a pointer to a vhost
backend for a given UUID, the front-end sends
a VHOST_USER_GET_SHARED_OBJECT to the
backend holding the shared object.

In the libvhost-user library we need to add
helper functions to allow sending messages to
interact with the virtio shared objects
hash table.

The messages can only be sent after successfully
negotiating a new VHOST_USER_PROTOCOL_F_SHARED_OBJECT
vhost-user protocol feature bit.

Signed-off-by: Albert Esteve <aesteve@redhat.com>
---
 docs/interop/vhost-user.rst               |  57 ++++++++
 hw/virtio/vhost-user.c                    | 166 ++++++++++++++++++++++
 include/hw/virtio/vhost-backend.h         |   3 +
 subprojects/libvhost-user/libvhost-user.c | 118 +++++++++++++++
 subprojects/libvhost-user/libvhost-user.h |  55 ++++++-
 5 files changed, 398 insertions(+), 1 deletion(-)

diff --git a/docs/interop/vhost-user.rst b/docs/interop/vhost-user.rst
index 5a070adbc1..415bb47a19 100644
--- a/docs/interop/vhost-user.rst
+++ b/docs/interop/vhost-user.rst
@@ -1440,6 +1440,18 @@ Front-end message types
   query the back-end for its device status as defined in the Virtio
   specification.
 
+``VHOST_USER_GET_SHARED_OBJECT``
+  :id: 41
+  :equivalent ioctl: N/A
+  :request payload: ``struct VhostUserShared``
+  :reply payload: dmabuf fd
+
+  When the ``VHOST_USER_PROTOCOL_F_SHARED_OBJECT`` protocol
+  feature has been successfully negotiated, and the UUID is found
+  in the exporters cache, this message is submitted by the front-end
+  to retrieve a given dma-buf fd from a given back-end, determined by
+  the requested UUID. Back-end will reply passing the fd when the operation
+  is successful, or no fd otherwise.
 
 Back-end message types
 ----------------------
@@ -1528,6 +1540,51 @@ is sent by the front-end.
 
   The state.num field is currently reserved and must be set to 0.
 
+``VHOST_USER_BACKEND_SHARED_OBJECT_ADD``
+  :id: 6
+  :equivalent ioctl: N/A
+  :request payload: ``struct VhostUserShared``
+  :reply payload: N/A
+
+  When the ``VHOST_USER_PROTOCOL_F_SHARED_OBJECT`` protocol
+  feature has been successfully negotiated, this message can be submitted
+  by the backends to add themselves as exporters to the virtio shared lookup
+  table. The back-end device gets associated with a UUID in the shared table.
+  The back-end is responsible of keeping its own table with exported dma-buf fds.
+  When another back-end tries to import the resource associated with the UUID,
+  it will send a message to the front-end, which will act as a proxy to the
+  exporter back-end. If ``VHOST_USER_PROTOCOL_F_REPLY_ACK`` is negotiated, and
+  the back-end sets the ``VHOST_USER_NEED_REPLY`` flag, the front-end must
+  respond with zero when operation is successfully completed, or non-zero
+  otherwise.
+
+``VHOST_USER_BACKEND_SHARED_OBJECT_REMOVE``
+  :id: 7
+  :equivalent ioctl: N/A
+  :request payload: ``struct VhostUserShared``
+  :reply payload: N/A
+
+  When the ``VHOST_USER_PROTOCOL_F_SHARED_OBJECT`` protocol
+  feature has been successfully negotiated, this message can be submitted
+  by the backend to remove themselves from to the virtio-dmabuf shared
+  table API. The shared table will remove the back-end device associated with
+  the UUID. If ``VHOST_USER_PROTOCOL_F_REPLY_ACK`` is negotiated, and the
+  back-end sets the ``VHOST_USER_NEED_REPLY`` flag, the front-end must respond
+  with zero when operation is successfully completed, or non-zero otherwise.
+
+``VHOST_USER_BACKEND_SHARED_OBJECT_LOOKUP``
+  :id: 8
+  :equivalent ioctl: N/A
+  :request payload: ``struct VhostUserShared``
+  :reply payload: dmabuf fd and ``u64``
+
+  When the ``VHOST_USER_PROTOCOL_F_SHARED_OBJECT`` protocol
+  feature has been successfully negotiated, this message can be submitted
+  by the backends to retrieve a given dma-buf fd from the virtio-dmabuf
+  shared table given a UUID. Frontend will reply passing the fd and a zero
+  when the operation is successful, or non-zero otherwise. Note that if the
+  operation fails, no fd is sent to the backend.
+
 .. _reply_ack:
 
 VHOST_USER_PROTOCOL_F_REPLY_ACK
diff --git a/hw/virtio/vhost-user.c b/hw/virtio/vhost-user.c
index 8dcf049d42..104a56a48d 100644
--- a/hw/virtio/vhost-user.c
+++ b/hw/virtio/vhost-user.c
@@ -10,6 +10,7 @@
 
 #include "qemu/osdep.h"
 #include "qapi/error.h"
+#include "hw/virtio/virtio-dmabuf.h"
 #include "hw/virtio/vhost.h"
 #include "hw/virtio/virtio-crypto.h"
 #include "hw/virtio/vhost-user.h"
@@ -21,6 +22,7 @@
 #include "sysemu/kvm.h"
 #include "qemu/error-report.h"
 #include "qemu/main-loop.h"
+#include "qemu/uuid.h"
 #include "qemu/sockets.h"
 #include "sysemu/runstate.h"
 #include "sysemu/cryptodev.h"
@@ -74,6 +76,7 @@ enum VhostUserProtocolFeature {
     /* Feature 14 reserved for VHOST_USER_PROTOCOL_F_INBAND_NOTIFICATIONS. */
     VHOST_USER_PROTOCOL_F_CONFIGURE_MEM_SLOTS = 15,
     VHOST_USER_PROTOCOL_F_STATUS = 16,
+    VHOST_USER_PROTOCOL_F_SHARED_OBJECT = 17,
     VHOST_USER_PROTOCOL_F_MAX
 };
 
@@ -121,6 +124,7 @@ typedef enum VhostUserRequest {
     VHOST_USER_REM_MEM_REG = 38,
     VHOST_USER_SET_STATUS = 39,
     VHOST_USER_GET_STATUS = 40,
+    VHOST_USER_GET_SHARED_OBJECT = 41,
     VHOST_USER_MAX
 } VhostUserRequest;
 
@@ -129,6 +133,9 @@ typedef enum VhostUserBackendRequest {
     VHOST_USER_BACKEND_IOTLB_MSG = 1,
     VHOST_USER_BACKEND_CONFIG_CHANGE_MSG = 2,
     VHOST_USER_BACKEND_VRING_HOST_NOTIFIER_MSG = 3,
+    VHOST_USER_BACKEND_SHARED_OBJECT_ADD = 6,
+    VHOST_USER_BACKEND_SHARED_OBJECT_REMOVE = 7,
+    VHOST_USER_BACKEND_SHARED_OBJECT_LOOKUP = 8,
     VHOST_USER_BACKEND_MAX
 }  VhostUserBackendRequest;
 
@@ -202,6 +209,10 @@ typedef struct VhostUserInflight {
     uint16_t queue_size;
 } VhostUserInflight;
 
+typedef struct VhostUserShared {
+    unsigned char uuid[16];
+} VhostUserShared;
+
 typedef struct {
     VhostUserRequest request;
 
@@ -226,6 +237,7 @@ typedef union {
         VhostUserCryptoSession session;
         VhostUserVringArea area;
         VhostUserInflight inflight;
+        VhostUserShared object;
 } VhostUserPayload;
 
 typedef struct VhostUserMsg {
@@ -1601,6 +1613,150 @@ static int vhost_user_backend_handle_vring_host_notifier(struct vhost_dev *dev,
     return 0;
 }
 
+static int
+vhost_user_backend_handle_shared_object_add(struct vhost_dev *dev,
+                                            VhostUserShared *object)
+{
+    QemuUUID uuid;
+
+    memcpy(uuid.data, object->uuid, sizeof(object->uuid));
+    return virtio_add_vhost_device(&uuid, dev);
+}
+
+static int
+vhost_user_backend_handle_shared_object_remove(VhostUserShared *object)
+{
+    QemuUUID uuid;
+
+    memcpy(uuid.data, object->uuid, sizeof(object->uuid));
+    return virtio_remove_resource(&uuid);
+}
+
+static bool
+vhost_user_backend_send_dmabuf_fd(QIOChannel *ioc, VhostUserHeader *hdr,
+                                  VhostUserPayload *payload)
+{
+    Error *local_err = NULL;
+    struct iovec iov[2];
+
+    if (hdr->flags & VHOST_USER_NEED_REPLY_MASK) {
+        hdr->flags &= ~VHOST_USER_NEED_REPLY_MASK;
+    }
+    hdr->flags |= VHOST_USER_REPLY_MASK;
+
+    hdr->size = sizeof(payload->u64);
+
+    iov[0].iov_base = hdr;
+    iov[0].iov_len = VHOST_USER_HDR_SIZE;
+    iov[1].iov_base = payload;
+    iov[1].iov_len = hdr->size;
+
+    if (qio_channel_writev_all(ioc, iov, ARRAY_SIZE(iov), &local_err)) {
+        error_report_err(local_err);
+        return false;
+    }
+    return true;
+}
+
+static bool
+vhost_user_backend_send_dmabuf_fd(QIOChannel *ioc, VhostUserHeader *hdr,
+                                  VhostUserPayload *payload)
+{
+    hdr->size = sizeof(payload->u64);
+    return vhost_user_send_resp(ioc, hdr, payload);
+}
+
+int vhost_user_get_shared_object(struct vhost_dev *dev, unsigned char *uuid,
+                                 int *dmabuf_fd)
+{
+    struct vhost_user *u = dev->opaque;
+    CharBackend *chr = u->user->chr;
+    int ret;
+    VhostUserMsg msg = {
+        .hdr.request = VHOST_USER_GET_SHARED_OBJECT,
+        .hdr.flags = VHOST_USER_VERSION,
+    };
+    memcpy(msg.payload.object.uuid, uuid, sizeof(msg.payload.object.uuid));
+
+    ret = vhost_user_write(dev, &msg, NULL, 0);
+    if (ret < 0) {
+        return ret;
+    }
+
+    ret = vhost_user_read(dev, &msg);
+    if (ret < 0) {
+        return ret;
+    }
+
+    if (msg.hdr.request != VHOST_USER_GET_SHARED_OBJECT) {
+        error_report("Received unexpected msg type. "
+                     "Expected %d received %d",
+                     VHOST_USER_GET_SHARED_OBJECT, msg.hdr.request);
+        return -EPROTO;
+    }
+
+    *dmabuf_fd = qemu_chr_fe_get_msgfd(chr);
+    if (*dmabuf_fd < 0) {
+        error_report("Failed to get dmabuf fd");
+        return -EIO;
+    }
+
+    return 0;
+}
+
+static int
+vhost_user_backend_handle_shared_object_lookup(struct vhost_user *u,
+                                               QIOChannel *ioc,
+                                               VhostUserHeader *hdr,
+                                               VhostUserPayload *payload)
+{
+    QemuUUID uuid;
+    CharBackend *chr = u->user->chr;
+    int dmabuf_fd = -1;
+    int fd_num = 0;
+
+    memcpy(uuid.data, payload->object.uuid, sizeof(payload->object.uuid));
+
+    payload->u64 = 0;
+    switch (virtio_object_type(&uuid)) {
+        case TYPE_DMABUF:
+            dmabuf_fd = virtio_lookup_dmabuf(&uuid);
+            break;
+        case TYPE_VHOST_DEV:
+        {
+            struct vhost_dev *dev = virtio_lookup_vhost_device(&uuid);
+            if (dev == NULL) {
+                payload->u64 = -EINVAL;
+                break;
+            }
+            int ret = vhost_user_get_shared_object(dev, uuid.data, &dmabuf_fd);
+            if (ret < 0) {
+                payload->u64 = ret;
+            }
+            break;
+        }
+        case TYPE_INVALID:
+            payload->u64 = -EINVAL;
+            break;
+    }
+
+    if (dmabuf_fd != -1) {
+        fd_num++;
+    }
+
+    if (qemu_chr_fe_set_msgfds(chr, &dmabuf_fd, fd_num) < 0) {
+        error_report("Failed to set msg fds.");
+        payload->u64 = -EINVAL;
+    }
+
+    if (!vhost_user_backend_send_dmabuf_fd(ioc, hdr, payload)) {
+        error_report("Failed to write response msg.");
+        return -EINVAL;
+    }
+
+    return 0;
+}
+
 static void close_backend_channel(struct vhost_user *u)
 {
     g_source_destroy(u->backend_src);
@@ -1658,6 +1814,16 @@ static gboolean backend_read(QIOChannel *ioc, GIOCondition condition,
         ret = vhost_user_backend_handle_vring_host_notifier(dev, &payload.area,
                                                           fd ? fd[0] : -1);
         break;
+    case VHOST_USER_BACKEND_SHARED_OBJECT_ADD:
+        ret = vhost_user_backend_handle_shared_object_add(dev, &payload.object);
+        break;
+    case VHOST_USER_BACKEND_SHARED_OBJECT_REMOVE:
+        ret = vhost_user_backend_handle_shared_object_remove(&payload.object);
+        break;
+    case VHOST_USER_BACKEND_SHARED_OBJECT_LOOKUP:
+        ret = vhost_user_backend_handle_shared_object_lookup(dev->opaque, ioc,
+                                                             &hdr, &payload);
+        break;
     default:
         error_report("Received unexpected msg type: %d.", hdr.request);
         ret = -EINVAL;
diff --git a/include/hw/virtio/vhost-backend.h b/include/hw/virtio/vhost-backend.h
index 31a251a9f5..1860b541d8 100644
--- a/include/hw/virtio/vhost-backend.h
+++ b/include/hw/virtio/vhost-backend.h
@@ -196,4 +196,7 @@ int vhost_backend_handle_iotlb_msg(struct vhost_dev *dev,
 
 int vhost_user_gpu_set_socket(struct vhost_dev *dev, int fd);
 
+int vhost_user_get_shared_object(struct vhost_dev *dev, unsigned char *uuid,
+                                        int *dmabuf_fd);
+
 #endif /* VHOST_BACKEND_H */
diff --git a/subprojects/libvhost-user/libvhost-user.c b/subprojects/libvhost-user/libvhost-user.c
index 0469a50101..432bb9fc0b 100644
--- a/subprojects/libvhost-user/libvhost-user.c
+++ b/subprojects/libvhost-user/libvhost-user.c
@@ -161,6 +161,7 @@ vu_request_to_string(unsigned int req)
         REQ(VHOST_USER_GET_MAX_MEM_SLOTS),
         REQ(VHOST_USER_ADD_MEM_REG),
         REQ(VHOST_USER_REM_MEM_REG),
+        REQ(VHOST_USER_GET_SHARED_OBJECT),
         REQ(VHOST_USER_MAX),
     };
 #undef REQ
@@ -900,6 +901,23 @@ vu_rem_mem_reg(VuDev *dev, VhostUserMsg *vmsg) {
     return false;
 }
 
+static bool
+vu_get_shared_object(VuDev *dev, VhostUserMsg *vmsg)
+{
+    int fd_num = 0;
+    int dmabuf_fd = -1;
+    if (dev->iface->get_shared_object) {
+        dmabuf_fd = dev->iface->get_shared_object(dev, &vmsg->payload.object.uuid[0]);
+    }
+    if (dmabuf_fd != -1) {
+        DPRINT("dmabuf_fd found for requested UUID\n");
+        vmsg->fds[fd_num++] = dmabuf_fd;
+    }
+    vmsg->fd_num = fd_num;
+
+    return true;
+}
+
 static bool
 vu_set_mem_table_exec_postcopy(VuDev *dev, VhostUserMsg *vmsg)
 {
@@ -1403,6 +1421,104 @@ bool vu_set_queue_host_notifier(VuDev *dev, VuVirtq *vq, int fd,
     return vu_process_message_reply(dev, &vmsg);
 }
 
+bool
+vu_lookup_shared_object(VuDev *dev, unsigned char uuid[UUID_LEN], int *dmabuf_fd)
+{
+    bool result = false;
+    VhostUserMsg msg_reply;
+    VhostUserMsg msg = {
+        .request = VHOST_USER_BACKEND_SHARED_OBJECT_LOOKUP,
+        .size = sizeof(msg.payload.object),
+        .flags = VHOST_USER_VERSION | VHOST_USER_NEED_REPLY_MASK,
+    };
+
+    memcpy(msg.payload.object.uuid, uuid, sizeof(uuid[0]) * UUID_LEN);
+
+    if (!vu_has_protocol_feature(dev, VHOST_USER_PROTOCOL_F_SHARED_OBJECT)) {
+        return false;
+    }
+
+    pthread_mutex_lock(&dev->backend_mutex);
+    if (!vu_message_write(dev, dev->backend_fd, &msg)) {
+        goto out;
+    }
+
+    if (!vu_message_read_default(dev, dev->backend_fd, &msg_reply)) {
+        goto out;
+    }
+
+    if (msg_reply.request != msg.request) {
+        DPRINT("Received unexpected msg type. Expected %d, received %d",
+               msg.request, msg_reply.request);
+        goto out;
+    }
+
+    if (msg_reply.fd_num != 1) {
+        DPRINT("Received unexpected number of fds. Expected 1, received %d",
+               msg_reply.fd_num);
+        goto out;
+    }
+
+    *dmabuf_fd = msg_reply.fds[0];
+    result = *dmabuf_fd > 0 && msg_reply.payload.u64 == 0;
+out:
+    pthread_mutex_unlock(&dev->backend_mutex);
+
+    return result;
+}
+
+static bool
+vu_send_message(VuDev *dev, VhostUserMsg *vmsg)
+{
+    bool result = false;
+    pthread_mutex_lock(&dev->backend_mutex);
+    if (!vu_message_write(dev, dev->backend_fd, vmsg)) {
+        goto out;
+    }
+
+    result = true;
+out:
+    pthread_mutex_unlock(&dev->backend_mutex);
+
+    return result;
+}
+
+bool
+vu_add_shared_object(VuDev *dev, unsigned char uuid[UUID_LEN])
+{
+    VhostUserMsg msg = {
+        .request = VHOST_USER_BACKEND_SHARED_OBJECT_ADD,
+        .size = sizeof(msg.payload.object),
+        .flags = VHOST_USER_VERSION,
+    };
+
+    memcpy(msg.payload.object.uuid, uuid, sizeof(uuid[0]) * UUID_LEN);
+
+    if (!vu_has_protocol_feature(dev, VHOST_USER_PROTOCOL_F_SHARED_OBJECT)) {
+        return false;
+    }
+
+    return vu_send_message(dev, &msg);
+}
+
+bool
+vu_rm_shared_object(VuDev *dev, unsigned char uuid[UUID_LEN])
+{
+    VhostUserMsg msg = {
+        .request = VHOST_USER_BACKEND_SHARED_OBJECT_REMOVE,
+        .size = sizeof(msg.payload.object),
+        .flags = VHOST_USER_VERSION,
+    };
+
+    memcpy(msg.payload.object.uuid, uuid, sizeof(uuid[0]) * UUID_LEN);
+
+    if (!vu_has_protocol_feature(dev, VHOST_USER_PROTOCOL_F_SHARED_OBJECT)) {
+        return false;
+    }
+
+    return vu_send_message(dev, &msg);
+}
+
 static bool
 vu_set_vring_call_exec(VuDev *dev, VhostUserMsg *vmsg)
 {
@@ -1943,6 +2059,8 @@ vu_process_message(VuDev *dev, VhostUserMsg *vmsg)
         return vu_add_mem_reg(dev, vmsg);
     case VHOST_USER_REM_MEM_REG:
         return vu_rem_mem_reg(dev, vmsg);
+    case VHOST_USER_GET_SHARED_OBJECT:
+        return vu_get_shared_object(dev, vmsg);
     default:
         vmsg_close_fds(vmsg);
         vu_panic(dev, "Unhandled request: %d", vmsg->request);
diff --git a/subprojects/libvhost-user/libvhost-user.h b/subprojects/libvhost-user/libvhost-user.h
index 708370c5f5..b36a42a7ca 100644
--- a/subprojects/libvhost-user/libvhost-user.h
+++ b/subprojects/libvhost-user/libvhost-user.h
@@ -64,7 +64,8 @@ enum VhostUserProtocolFeature {
     VHOST_USER_PROTOCOL_F_INFLIGHT_SHMFD = 12,
     VHOST_USER_PROTOCOL_F_INBAND_NOTIFICATIONS = 14,
     VHOST_USER_PROTOCOL_F_CONFIGURE_MEM_SLOTS = 15,
-
+    /* Feature 16 is reserved for VHOST_USER_PROTOCOL_F_STATUS. */
+    VHOST_USER_PROTOCOL_F_SHARED_OBJECT = 17,
     VHOST_USER_PROTOCOL_F_MAX
 };
 
@@ -109,6 +110,7 @@ typedef enum VhostUserRequest {
     VHOST_USER_GET_MAX_MEM_SLOTS = 36,
     VHOST_USER_ADD_MEM_REG = 37,
     VHOST_USER_REM_MEM_REG = 38,
+    VHOST_USER_GET_SHARED_OBJECT = 41,
     VHOST_USER_MAX
 } VhostUserRequest;
 
@@ -119,6 +121,9 @@ typedef enum VhostUserBackendRequest {
     VHOST_USER_BACKEND_VRING_HOST_NOTIFIER_MSG = 3,
     VHOST_USER_BACKEND_VRING_CALL = 4,
     VHOST_USER_BACKEND_VRING_ERR = 5,
+    VHOST_USER_BACKEND_SHARED_OBJECT_ADD = 6,
+    VHOST_USER_BACKEND_SHARED_OBJECT_REMOVE = 7,
+    VHOST_USER_BACKEND_SHARED_OBJECT_LOOKUP = 8,
     VHOST_USER_BACKEND_MAX
 }  VhostUserBackendRequest;
 
@@ -172,6 +177,12 @@ typedef struct VhostUserInflight {
     uint16_t queue_size;
 } VhostUserInflight;
 
+#define UUID_LEN 16
+
+typedef struct VhostUserShared {
+    unsigned char uuid[UUID_LEN];
+} VhostUserShared;
+
 #if defined(_WIN32) && (defined(__x86_64__) || defined(__i386__))
 # define VU_PACKED __attribute__((gcc_struct, packed))
 #else
@@ -199,6 +210,7 @@ typedef struct VhostUserMsg {
         VhostUserConfig config;
         VhostUserVringArea area;
         VhostUserInflight inflight;
+        VhostUserShared object;
     } payload;
 
     int fds[VHOST_MEMORY_BASELINE_NREGIONS];
@@ -232,6 +244,7 @@ typedef int (*vu_get_config_cb) (VuDev *dev, uint8_t *config, uint32_t len);
 typedef int (*vu_set_config_cb) (VuDev *dev, const uint8_t *data,
                                  uint32_t offset, uint32_t size,
                                  uint32_t flags);
+typedef int (*vu_get_shared_object_cb) (VuDev *dev, const unsigned char *uuid);
 
 typedef struct VuDevIface {
     /* called by VHOST_USER_GET_FEATURES to get the features bitmask */
@@ -258,6 +271,8 @@ typedef struct VuDevIface {
     vu_get_config_cb get_config;
     /* set the config space of the device */
     vu_set_config_cb set_config;
+    /* get virtio shared object from the underlying vhost implementation. */
+    vu_get_shared_object_cb get_shared_object;
 } VuDevIface;
 
 typedef void (*vu_queue_handler_cb) (VuDev *dev, int qidx);
@@ -541,6 +556,44 @@ void vu_set_queue_handler(VuDev *dev, VuVirtq *vq,
 bool vu_set_queue_host_notifier(VuDev *dev, VuVirtq *vq, int fd,
                                 int size, int offset);
 
+/**
+ * vu_lookup_shared_object:
+ * @dev: a VuDev context
+ * @uuid: UUID of the shared object
+ * @dmabuf_fd: output dma-buf file descriptor
+ *
+ * Lookup for a virtio shared object (i.e., dma-buf fd) associated with the
+ * received UUID. Result, if found, is stored in the dmabuf_fd argument.
+ *
+ * Returns: whether the virtio object was found.
+ */
+bool vu_lookup_shared_object(VuDev *dev, unsigned char uuid[UUID_LEN],
+                             int *dmabuf_fd);
+
+/**
+ * vu_add_shared_object:
+ * @dev: a VuDev context
+ * @uuid: UUID of the shared object
+ *
+ * Registers this back-end as the exporter for the object associated with
+ * the received UUID.
+ *
+ * Returns: TRUE on success, FALSE on failure.
+ */
+bool vu_add_shared_object(VuDev *dev, unsigned char uuid[UUID_LEN]);
+
+/**
+ * vu_rm_shared_object:
+ * @dev: a VuDev context
+ * @uuid: UUID of the shared object
+ *
+ * Removes a shared object entry (i.e., back-end entry) associated with the
+ * received UUID key from the hash table.
+ *
+ * Returns: TRUE on success, FALSE on failure.
+ */
+bool vu_rm_shared_object(VuDev *dev, unsigned char uuid[UUID_LEN]);
+
 /**
  * vu_queue_set_notification:
  * @dev: a VuDev context
-- 
2.40.0

Re: [PATCH v5 3/4] vhost-user: add shared_object msg

[Philippe Mathieu-Daudé]

On 2/8/23 11:08, Albert Esteve wrote:
> Add three new vhost-user protocol
> `VHOST_USER_BACKEND_SHARED_OBJECT_* messages`.
> These new messages are sent from vhost-user
> back-ends to interact with the virtio-dmabuf
> table in order to add or remove themselves as
> virtio exporters, or lookup for virtio dma-buf
> shared objects.
> 
> The action taken in the front-end depends
> on the type stored in the virtio shared
> object hash table.
> 
> When the table holds a pointer to a vhost
> backend for a given UUID, the front-end sends
> a VHOST_USER_GET_SHARED_OBJECT to the
> backend holding the shared object.
> 
> In the libvhost-user library we need to add
> helper functions to allow sending messages to
> interact with the virtio shared objects
> hash table.
> 
> The messages can only be sent after successfully
> negotiating a new VHOST_USER_PROTOCOL_F_SHARED_OBJECT
> vhost-user protocol feature bit.
> 
> Signed-off-by: Albert Esteve <aesteve@redhat.com>
> ---
>   docs/interop/vhost-user.rst               |  57 ++++++++
>   hw/virtio/vhost-user.c                    | 166 ++++++++++++++++++++++
>   include/hw/virtio/vhost-backend.h         |   3 +
>   subprojects/libvhost-user/libvhost-user.c | 118 +++++++++++++++
>   subprojects/libvhost-user/libvhost-user.h |  55 ++++++-
>   5 files changed, 398 insertions(+), 1 deletion(-)


> +static bool
> +vhost_user_backend_send_dmabuf_fd(QIOChannel *ioc, VhostUserHeader *hdr,
> +                                  VhostUserPayload *payload)
> +{
> +    Error *local_err = NULL;
> +    struct iovec iov[2];
> +
> +    if (hdr->flags & VHOST_USER_NEED_REPLY_MASK) {
> +        hdr->flags &= ~VHOST_USER_NEED_REPLY_MASK;
> +    }
> +    hdr->flags |= VHOST_USER_REPLY_MASK;
> +
> +    hdr->size = sizeof(payload->u64);
> +
> +    iov[0].iov_base = hdr;
> +    iov[0].iov_len = VHOST_USER_HDR_SIZE;
> +    iov[1].iov_base = payload;
> +    iov[1].iov_len = hdr->size;
> +
> +    if (qio_channel_writev_all(ioc, iov, ARRAY_SIZE(iov), &local_err)) {
> +        error_report_err(local_err);

This function could have a 'Error **errp' parameter to propagate
the error to the caller.

> +        return false;
> +    }
> +    return true;
> +}
> +
> +static bool
> +vhost_user_backend_send_dmabuf_fd(QIOChannel *ioc, VhostUserHeader *hdr,
> +                                  VhostUserPayload *payload)
> +{
> +    hdr->size = sizeof(payload->u64);
> +    return vhost_user_send_resp(ioc, hdr, payload);
> +}

I'm confused by having two vhost_user_backend_send_dmabuf_fd() functions
with different body...

> +int vhost_user_get_shared_object(struct vhost_dev *dev, unsigned char *uuid,
> +                                 int *dmabuf_fd)
> +{
> +    struct vhost_user *u = dev->opaque;
> +    CharBackend *chr = u->user->chr;
> +    int ret;
> +    VhostUserMsg msg = {
> +        .hdr.request = VHOST_USER_GET_SHARED_OBJECT,
> +        .hdr.flags = VHOST_USER_VERSION,
> +    };
> +    memcpy(msg.payload.object.uuid, uuid, sizeof(msg.payload.object.uuid));
> +
> +    ret = vhost_user_write(dev, &msg, NULL, 0);
> +    if (ret < 0) {
> +        return ret;
> +    }
> +
> +    ret = vhost_user_read(dev, &msg);
> +    if (ret < 0) {
> +        return ret;
> +    }
> +
> +    if (msg.hdr.request != VHOST_USER_GET_SHARED_OBJECT) {
> +        error_report("Received unexpected msg type. "
> +                     "Expected %d received %d",
> +                     VHOST_USER_GET_SHARED_OBJECT, msg.hdr.request);
> +        return -EPROTO;
> +    }
> +
> +    *dmabuf_fd = qemu_chr_fe_get_msgfd(chr);
> +    if (*dmabuf_fd < 0) {
> +        error_report("Failed to get dmabuf fd");
> +        return -EIO;
> +    }
> +
> +    return 0;
> +}
> +
> +static int
> +vhost_user_backend_handle_shared_object_lookup(struct vhost_user *u,
> +                                               QIOChannel *ioc,
> +                                               VhostUserHeader *hdr,
> +                                               VhostUserPayload *payload)

Also propagate a 'Error **errp'.

> +{
> +    QemuUUID uuid;
> +    CharBackend *chr = u->user->chr;
> +    int dmabuf_fd = -1;
> +    int fd_num = 0;
> +
> +    memcpy(uuid.data, payload->object.uuid, sizeof(payload->object.uuid));
> +
> +    payload->u64 = 0;
> +    switch (virtio_object_type(&uuid)) {
> +        case TYPE_DMABUF:
> +            dmabuf_fd = virtio_lookup_dmabuf(&uuid);
> +            break;
> +        case TYPE_VHOST_DEV:
> +        {
> +            struct vhost_dev *dev = virtio_lookup_vhost_device(&uuid);
> +            if (dev == NULL) {
> +                payload->u64 = -EINVAL;
> +                break;
> +            }
> +            int ret = vhost_user_get_shared_object(dev, uuid.data, &dmabuf_fd);
> +            if (ret < 0) {
> +                payload->u64 = ret;
> +            }
> +            break;
> +        }
> +        case TYPE_INVALID:
> +            payload->u64 = -EINVAL;
> +            break;
> +    }
> +
> +    if (dmabuf_fd != -1) {
> +        fd_num++;
> +    }
> +
> +    if (qemu_chr_fe_set_msgfds(chr, &dmabuf_fd, fd_num) < 0) {
> +        error_report("Failed to set msg fds.");
> +        payload->u64 = -EINVAL;
> +    }
> +
> +    if (!vhost_user_backend_send_dmabuf_fd(ioc, hdr, payload)) {
> +        error_report("Failed to write response msg.");
> +        return -EINVAL;
> +    }
> +
> +    return 0;
> +}

Re: [PATCH v5 3/4] vhost-user: add shared_object msg

[Philippe Mathieu-Daudé]

On 6/9/23 08:04, Philippe Mathieu-Daudé wrote:
> On 2/8/23 11:08, Albert Esteve wrote:
>> Add three new vhost-user protocol
>> `VHOST_USER_BACKEND_SHARED_OBJECT_* messages`.
>> These new messages are sent from vhost-user
>> back-ends to interact with the virtio-dmabuf
>> table in order to add or remove themselves as
>> virtio exporters, or lookup for virtio dma-buf
>> shared objects.
>>
>> The action taken in the front-end depends
>> on the type stored in the virtio shared
>> object hash table.
>>
>> When the table holds a pointer to a vhost
>> backend for a given UUID, the front-end sends
>> a VHOST_USER_GET_SHARED_OBJECT to the
>> backend holding the shared object.
>>
>> In the libvhost-user library we need to add
>> helper functions to allow sending messages to
>> interact with the virtio shared objects
>> hash table.
>>
>> The messages can only be sent after successfully
>> negotiating a new VHOST_USER_PROTOCOL_F_SHARED_OBJECT
>> vhost-user protocol feature bit.
>>
>> Signed-off-by: Albert Esteve <aesteve@redhat.com>
>> ---
>>   docs/interop/vhost-user.rst               |  57 ++++++++
>>   hw/virtio/vhost-user.c                    | 166 ++++++++++++++++++++++
>>   include/hw/virtio/vhost-backend.h         |   3 +
>>   subprojects/libvhost-user/libvhost-user.c | 118 +++++++++++++++
>>   subprojects/libvhost-user/libvhost-user.h |  55 ++++++-
>>   5 files changed, 398 insertions(+), 1 deletion(-)
> 
> 
>> +static bool
>> +vhost_user_backend_send_dmabuf_fd(QIOChannel *ioc, VhostUserHeader *hdr,
>> +                                  VhostUserPayload *payload)
>> +{
>> +    Error *local_err = NULL;
>> +    struct iovec iov[2];
>> +
>> +    if (hdr->flags & VHOST_USER_NEED_REPLY_MASK) {
>> +        hdr->flags &= ~VHOST_USER_NEED_REPLY_MASK;
>> +    }
>> +    hdr->flags |= VHOST_USER_REPLY_MASK;
>> +
>> +    hdr->size = sizeof(payload->u64);
>> +
>> +    iov[0].iov_base = hdr;
>> +    iov[0].iov_len = VHOST_USER_HDR_SIZE;
>> +    iov[1].iov_base = payload;
>> +    iov[1].iov_len = hdr->size;
>> +
>> +    if (qio_channel_writev_all(ioc, iov, ARRAY_SIZE(iov), &local_err)) {
>> +        error_report_err(local_err);
> 
> This function could have a 'Error **errp' parameter to propagate
> the error to the caller.
> 
>> +        return false;
>> +    }
>> +    return true;
>> +}
>> +
>> +static bool
>> +vhost_user_backend_send_dmabuf_fd(QIOChannel *ioc, VhostUserHeader *hdr,
>> +                                  VhostUserPayload *payload)
>> +{
>> +    hdr->size = sizeof(payload->u64);
>> +    return vhost_user_send_resp(ioc, hdr, payload);
>> +}
> 
> I'm confused by having two vhost_user_backend_send_dmabuf_fd() functions
> with different body...

This patch doesn't compile:

../../hw/virtio/vhost-user.c:1662:1: error: redefinition of 
‘vhost_user_backend_send_dmabuf_fd’
  1662 | vhost_user_backend_send_dmabuf_fd(QIOChannel *ioc, 
VhostUserHeader *hdr,
       | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
../../hw/virtio/vhost-user.c:1636:1: note: previous definition of 
‘vhost_user_backend_send_dmabuf_fd’ with type ‘_Bool(QIOChannel *, 
VhostUserHeader *, VhostUserPayload *)’
  1636 | vhost_user_backend_send_dmabuf_fd(QIOChannel *ioc, 
VhostUserHeader *hdr,
       | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
../../hw/virtio/vhost-user.c: In function 
‘vhost_user_backend_send_dmabuf_fd’:
../../hw/virtio/vhost-user.c:1666:12: error: implicit declaration of 
function ‘vhost_user_send_resp’; did you mean ‘vhost_user_set_u64’? 
[-Werror=implicit-function-declaration]
  1666 |     return vhost_user_send_resp(ioc, hdr, payload);
       |            ^~~~~~~~~~~~~~~~~~~~
       |            vhost_user_set_u64
../../hw/virtio/vhost-user.c:1666:12: error: nested extern declaration 
of ‘vhost_user_send_resp’ [-Werror=nested-externs]
At top level:
../../hw/virtio/vhost-user.c:1636:1: error: 
‘vhost_user_backend_send_dmabuf_fd’ defined but not used 
[-Werror=unused-function]
  1636 | vhost_user_backend_send_dmabuf_fd(QIOChannel *ioc, 
VhostUserHeader *hdr,
       | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
cc1: all warnings being treated as errors

Re: [PATCH v5 3/4] vhost-user: add shared_object msg

[Albert Esteve]

[-- Attachment #1: Type: text/plain, Size: 4714 bytes --]

On Wed, Sep 6, 2023 at 8:10 AM Philippe Mathieu-Daudé <philmd@linaro.org>
wrote:

> On 6/9/23 08:04, Philippe Mathieu-Daudé wrote:
> > On 2/8/23 11:08, Albert Esteve wrote:
> >> Add three new vhost-user protocol
> >> `VHOST_USER_BACKEND_SHARED_OBJECT_* messages`.
> >> These new messages are sent from vhost-user
> >> back-ends to interact with the virtio-dmabuf
> >> table in order to add or remove themselves as
> >> virtio exporters, or lookup for virtio dma-buf
> >> shared objects.
> >>
> >> The action taken in the front-end depends
> >> on the type stored in the virtio shared
> >> object hash table.
> >>
> >> When the table holds a pointer to a vhost
> >> backend for a given UUID, the front-end sends
> >> a VHOST_USER_GET_SHARED_OBJECT to the
> >> backend holding the shared object.
> >>
> >> In the libvhost-user library we need to add
> >> helper functions to allow sending messages to
> >> interact with the virtio shared objects
> >> hash table.
> >>
> >> The messages can only be sent after successfully
> >> negotiating a new VHOST_USER_PROTOCOL_F_SHARED_OBJECT
> >> vhost-user protocol feature bit.
> >>
> >> Signed-off-by: Albert Esteve <aesteve@redhat.com>
> >> ---
> >>   docs/interop/vhost-user.rst               |  57 ++++++++
> >>   hw/virtio/vhost-user.c                    | 166 ++++++++++++++++++++++
> >>   include/hw/virtio/vhost-backend.h         |   3 +
> >>   subprojects/libvhost-user/libvhost-user.c | 118 +++++++++++++++
> >>   subprojects/libvhost-user/libvhost-user.h |  55 ++++++-
> >>   5 files changed, 398 insertions(+), 1 deletion(-)
> >
> >
> >> +static bool
> >> +vhost_user_backend_send_dmabuf_fd(QIOChannel *ioc, VhostUserHeader
> *hdr,
> >> +                                  VhostUserPayload *payload)
> >> +{
> >> +    Error *local_err = NULL;
> >> +    struct iovec iov[2];
> >> +
> >> +    if (hdr->flags & VHOST_USER_NEED_REPLY_MASK) {
> >> +        hdr->flags &= ~VHOST_USER_NEED_REPLY_MASK;
> >> +    }
> >> +    hdr->flags |= VHOST_USER_REPLY_MASK;
> >> +
> >> +    hdr->size = sizeof(payload->u64);
> >> +
> >> +    iov[0].iov_base = hdr;
> >> +    iov[0].iov_len = VHOST_USER_HDR_SIZE;
> >> +    iov[1].iov_base = payload;
> >> +    iov[1].iov_len = hdr->size;
> >> +
> >> +    if (qio_channel_writev_all(ioc, iov, ARRAY_SIZE(iov), &local_err))
> {
> >> +        error_report_err(local_err);
> >
> > This function could have a 'Error **errp' parameter to propagate
> > the error to the caller.
> >
> >> +        return false;
> >> +    }
> >> +    return true;
> >> +}
> >> +
> >> +static bool
> >> +vhost_user_backend_send_dmabuf_fd(QIOChannel *ioc, VhostUserHeader
> *hdr,
> >> +                                  VhostUserPayload *payload)
> >> +{
> >> +    hdr->size = sizeof(payload->u64);
> >> +    return vhost_user_send_resp(ioc, hdr, payload);
> >> +}
> >
> > I'm confused by having two vhost_user_backend_send_dmabuf_fd() functions
> > with different body...
>
> This patch doesn't compile:
>
> ../../hw/virtio/vhost-user.c:1662:1: error: redefinition of
> ‘vhost_user_backend_send_dmabuf_fd’
>   1662 | vhost_user_backend_send_dmabuf_fd(QIOChannel *ioc,
> VhostUserHeader *hdr,
>        | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
> ../../hw/virtio/vhost-user.c:1636:1: note: previous definition of
> ‘vhost_user_backend_send_dmabuf_fd’ with type ‘_Bool(QIOChannel *,
> VhostUserHeader *, VhostUserPayload *)’
>   1636 | vhost_user_backend_send_dmabuf_fd(QIOChannel *ioc,
> VhostUserHeader *hdr,
>        | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
> ../../hw/virtio/vhost-user.c: In function
> ‘vhost_user_backend_send_dmabuf_fd’:
> ../../hw/virtio/vhost-user.c:1666:12: error: implicit declaration of
> function ‘vhost_user_send_resp’; did you mean ‘vhost_user_set_u64’?
> [-Werror=implicit-function-declaration]
>   1666 |     return vhost_user_send_resp(ioc, hdr, payload);
>        |            ^~~~~~~~~~~~~~~~~~~~
>        |            vhost_user_set_u64
> ../../hw/virtio/vhost-user.c:1666:12: error: nested extern declaration
> of ‘vhost_user_send_resp’ [-Werror=nested-externs]
> At top level:
> ../../hw/virtio/vhost-user.c:1636:1: error:
> ‘vhost_user_backend_send_dmabuf_fd’ defined but not used
> [-Werror=unused-function]
>   1636 | vhost_user_backend_send_dmabuf_fd(QIOChannel *ioc,
> VhostUserHeader *hdr,
>        | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
> cc1: all warnings being treated as errors
>
>
Uh, nice catch.
This was not happening before, but I did not try the patches individually
for the few last reviews.
I will squash it as suggested with the next patch.
Thanks for checking!

[-- Attachment #2: Type: text/html, Size: 6277 bytes --]

[PATCH v5 4/4] vhost-user: refactor send_resp code

[Albert Esteve]

Refactor code to send response message so that
all common parts both for the common REPLY_ACK
case, and other data responses, can call it and
avoid code repetition.

Signed-off-by: Albert Esteve <aesteve@redhat.com>
---
 hw/virtio/vhost-user.c | 36 +++++++++---------------------------
 1 file changed, 9 insertions(+), 27 deletions(-)

diff --git a/hw/virtio/vhost-user.c b/hw/virtio/vhost-user.c
index 104a56a48d..28fa0ace42 100644
--- a/hw/virtio/vhost-user.c
+++ b/hw/virtio/vhost-user.c
@@ -1632,29 +1632,23 @@ vhost_user_backend_handle_shared_object_remove(VhostUserShared *object)
     return virtio_remove_resource(&uuid);
 }
 
-static bool
-vhost_user_backend_send_dmabuf_fd(QIOChannel *ioc, VhostUserHeader *hdr,
-                                  VhostUserPayload *payload)
+static bool vhost_user_send_resp(QIOChannel *ioc, VhostUserHeader *hdr,
+                                 VhostUserPayload *payload)
 {
     Error *local_err = NULL;
-    struct iovec iov[2];
+    struct iovec iov[] = {
+        { .iov_base = hdr,      .iov_len = VHOST_USER_HDR_SIZE },
+        { .iov_base = payload,  .iov_len = hdr->size },
+    };
 
-    if (hdr->flags & VHOST_USER_NEED_REPLY_MASK) {
-        hdr->flags &= ~VHOST_USER_NEED_REPLY_MASK;
-    }
+    hdr->flags &= ~VHOST_USER_NEED_REPLY_MASK;
     hdr->flags |= VHOST_USER_REPLY_MASK;
 
-    hdr->size = sizeof(payload->u64);
-
-    iov[0].iov_base = hdr;
-    iov[0].iov_len = VHOST_USER_HDR_SIZE;
-    iov[1].iov_base = payload;
-    iov[1].iov_len = hdr->size;
-
     if (qio_channel_writev_all(ioc, iov, ARRAY_SIZE(iov), &local_err)) {
         error_report_err(local_err);
         return false;
     }
+
     return true;
 }
 
@@ -1834,22 +1828,10 @@ static gboolean backend_read(QIOChannel *ioc, GIOCondition condition,
      * directly in their request handlers.
      */
     if (hdr.flags & VHOST_USER_NEED_REPLY_MASK) {
-        struct iovec iovec[2];
-
-
-        hdr.flags &= ~VHOST_USER_NEED_REPLY_MASK;
-        hdr.flags |= VHOST_USER_REPLY_MASK;
-
         payload.u64 = !!ret;
         hdr.size = sizeof(payload.u64);
 
-        iovec[0].iov_base = &hdr;
-        iovec[0].iov_len = VHOST_USER_HDR_SIZE;
-        iovec[1].iov_base = &payload;
-        iovec[1].iov_len = hdr.size;
-
-        if (qio_channel_writev_all(ioc, iovec, ARRAY_SIZE(iovec), &local_err)) {
-            error_report_err(local_err);
+        if (!vhost_user_send_resp(ioc, &hdr, &payload)) {
             goto err;
         }
     }
-- 
2.40.0

Re: [PATCH v5 4/4] vhost-user: refactor send_resp code

[Philippe Mathieu-Daudé]

On 2/8/23 11:08, Albert Esteve wrote:
> Refactor code to send response message so that
> all common parts both for the common REPLY_ACK
> case, and other data responses, can call it and
> avoid code repetition.
> 
> Signed-off-by: Albert Esteve <aesteve@redhat.com>
> ---
>   hw/virtio/vhost-user.c | 36 +++++++++---------------------------
>   1 file changed, 9 insertions(+), 27 deletions(-)
> 
> diff --git a/hw/virtio/vhost-user.c b/hw/virtio/vhost-user.c
> index 104a56a48d..28fa0ace42 100644
> --- a/hw/virtio/vhost-user.c
> +++ b/hw/virtio/vhost-user.c
> @@ -1632,29 +1632,23 @@ vhost_user_backend_handle_shared_object_remove(VhostUserShared *object)
>       return virtio_remove_resource(&uuid);
>   }
>   
> -static bool
> -vhost_user_backend_send_dmabuf_fd(QIOChannel *ioc, VhostUserHeader *hdr,
> -                                  VhostUserPayload *payload)
> +static bool vhost_user_send_resp(QIOChannel *ioc, VhostUserHeader *hdr,
> +                                 VhostUserPayload *payload)

Squash this patch with the previous one (in particular
because this fixes the build failure).

Re: [PATCH v5 0/4] Virtio shared dma-buf

[Albert Esteve]

[-- Attachment #1: Type: text/plain, Size: 3611 bytes --]

Hi all,

A little bump for this patch, sorry for the extra noise.

Regards,
Albert


On Wed, Aug 2, 2023 at 11:08 AM Albert Esteve <aesteve@redhat.com> wrote:

> v1 link ->
> https://lists.gnu.org/archive/html/qemu-devel/2023-05/msg00598.html
> v2 link ->
> https://lists.gnu.org/archive/html/qemu-devel/2023-05/msg04530.html
> v3 link ->
> https://lists.gnu.org/archive/html/qemu-devel/2023-05/msg06126.html
> v4 link ->
> https://lists.gnu.org/archive/html/qemu-devel/2023-06/msg05174.html
> v4 -> v5:
> - Allow shared table to hold pointers for vhost devices, in a struct that
> defines the types that the table can store
> - New message VHOST_USER_GET_SHARED_OBJECT to retrieve objects stored in
> vhost backends
> - Minor additions to support the previous items (e.g. new test usecases).
>
> This patch covers the required steps to add support for virtio
> cross-device resource sharing[1],
> which support is already available in the kernel.
>
> The main usecase will be sharing dma buffers from virtio-gpu devices (as
> the exporter
> -see VIRTIO_GPU_CMD_RESOURCE_ASSIGN_UUID in [2]), to virtio-video (under
> discussion)
> devices (as the buffer-user or importer). Therefore, even though virtio
> specs talk about
> resources or objects[3], this patch adds the infrastructure with dma-bufs
> in mind.
> Note that virtio specs let the devices themselves define what a vitio
> object is.
>
> These are the main parts that are covered in the patch:
>
> - Add hash function to uuid module
> - Shared resources table, to hold all resources that can be shared in the
> host and their assigned UUID,
>   or pointers to the backend holding the resource
> - Internal shared table API for virtio devices to add, lookup and remove
> resources
> - Unit test to verify the API
> - New messages to the vhost-user protocol to allow backend to interact
> with the shared
>   table API through the control socket
> - New vhost-user feature bit to enable shared objects feature
>
> Applies cleanly to 38a6de80b917b2a822cff0e38d83563ab401c890
>
> [1] - https://lwn.net/Articles/828988/
> [2] -
> https://docs.oasis-open.org/virtio/virtio/v1.2/csd01/virtio-v1.2-csd01.html#x1-3730006
> [3] -
> https://docs.oasis-open.org/virtio/virtio/v1.2/csd01/virtio-v1.2-csd01.html#x1-10500011
>
> Albert Esteve (4):
>   uuid: add a hash function
>   virtio-dmabuf: introduce virtio-dmabuf
>   vhost-user: add shared_object msg
>   vhost-user: refactor send_resp code
>
>  MAINTAINERS                               |   7 +
>  docs/interop/vhost-user.rst               |  57 +++++++
>  hw/display/meson.build                    |   1 +
>  hw/display/virtio-dmabuf.c                | 136 +++++++++++++++++
>  hw/virtio/vhost-user.c                    | 174 ++++++++++++++++++++--
>  include/hw/virtio/vhost-backend.h         |   3 +
>  include/hw/virtio/virtio-dmabuf.h         | 103 +++++++++++++
>  include/qemu/uuid.h                       |   2 +
>  subprojects/libvhost-user/libvhost-user.c | 118 +++++++++++++++
>  subprojects/libvhost-user/libvhost-user.h |  55 ++++++-
>  tests/unit/meson.build                    |   1 +
>  tests/unit/test-uuid.c                    |  27 ++++
>  tests/unit/test-virtio-dmabuf.c           | 137 +++++++++++++++++
>  util/uuid.c                               |  14 ++
>  14 files changed, 821 insertions(+), 14 deletions(-)
>  create mode 100644 hw/display/virtio-dmabuf.c
>  create mode 100644 include/hw/virtio/virtio-dmabuf.h
>  create mode 100644 tests/unit/test-virtio-dmabuf.c
>
> --
> 2.40.0
>
>

[-- Attachment #2: Type: text/html, Size: 5365 bytes --]

Re: [PATCH v5 0/4] Virtio shared dma-buf

[Michael S. Tsirkin]

I was hoping for some acks from Gerd or anyone else with a clue
about graphics, but as that doesn't seem to happen I'll merge.
Thanks!

On Mon, Aug 21, 2023 at 02:37:56PM +0200, Albert Esteve wrote:
> Hi all,
> 
> A little bump for this patch, sorry for the extra noise.
> 
> Regards,
> Albert
> 
> 
> On Wed, Aug 2, 2023 at 11:08 AM Albert Esteve <aesteve@redhat.com> wrote:
> 
>     v1 link -> https://lists.gnu.org/archive/html/qemu-devel/2023-05/
>     msg00598.html
>     v2 link -> https://lists.gnu.org/archive/html/qemu-devel/2023-05/
>     msg04530.html
>     v3 link -> https://lists.gnu.org/archive/html/qemu-devel/2023-05/
>     msg06126.html
>     v4 link -> https://lists.gnu.org/archive/html/qemu-devel/2023-06/
>     msg05174.html
>     v4 -> v5:
>     - Allow shared table to hold pointers for vhost devices, in a struct that
>     defines the types that the table can store
>     - New message VHOST_USER_GET_SHARED_OBJECT to retrieve objects stored in
>     vhost backends
>     - Minor additions to support the previous items (e.g. new test usecases).
> 
>     This patch covers the required steps to add support for virtio cross-device
>     resource sharing[1],
>     which support is already available in the kernel.
> 
>     The main usecase will be sharing dma buffers from virtio-gpu devices (as
>     the exporter
>     -see VIRTIO_GPU_CMD_RESOURCE_ASSIGN_UUID in [2]), to virtio-video (under
>     discussion)
>     devices (as the buffer-user or importer). Therefore, even though virtio
>     specs talk about
>     resources or objects[3], this patch adds the infrastructure with dma-bufs
>     in mind.
>     Note that virtio specs let the devices themselves define what a vitio
>     object is.
> 
>     These are the main parts that are covered in the patch:
> 
>     - Add hash function to uuid module
>     - Shared resources table, to hold all resources that can be shared in the
>     host and their assigned UUID,
>       or pointers to the backend holding the resource
>     - Internal shared table API for virtio devices to add, lookup and remove
>     resources
>     - Unit test to verify the API
>     - New messages to the vhost-user protocol to allow backend to interact with
>     the shared
>       table API through the control socket
>     - New vhost-user feature bit to enable shared objects feature
> 
>     Applies cleanly to 38a6de80b917b2a822cff0e38d83563ab401c890
> 
>     [1] - https://lwn.net/Articles/828988/
>     [2] - https://docs.oasis-open.org/virtio/virtio/v1.2/csd01/
>     virtio-v1.2-csd01.html#x1-3730006
>     [3] - https://docs.oasis-open.org/virtio/virtio/v1.2/csd01/
>     virtio-v1.2-csd01.html#x1-10500011
> 
>     Albert Esteve (4):
>       uuid: add a hash function
>       virtio-dmabuf: introduce virtio-dmabuf
>       vhost-user: add shared_object msg
>       vhost-user: refactor send_resp code
> 
>      MAINTAINERS                               |   7 +
>      docs/interop/vhost-user.rst               |  57 +++++++
>      hw/display/meson.build                    |   1 +
>      hw/display/virtio-dmabuf.c                | 136 +++++++++++++++++
>      hw/virtio/vhost-user.c                    | 174 ++++++++++++++++++++--
>      include/hw/virtio/vhost-backend.h         |   3 +
>      include/hw/virtio/virtio-dmabuf.h         | 103 +++++++++++++
>      include/qemu/uuid.h                       |   2 +
>      subprojects/libvhost-user/libvhost-user.c | 118 +++++++++++++++
>      subprojects/libvhost-user/libvhost-user.h |  55 ++++++-
>      tests/unit/meson.build                    |   1 +
>      tests/unit/test-uuid.c                    |  27 ++++
>      tests/unit/test-virtio-dmabuf.c           | 137 +++++++++++++++++
>      util/uuid.c                               |  14 ++
>      14 files changed, 821 insertions(+), 14 deletions(-)
>      create mode 100644 hw/display/virtio-dmabuf.c
>      create mode 100644 include/hw/virtio/virtio-dmabuf.h
>      create mode 100644 tests/unit/test-virtio-dmabuf.c
> 
>     --
>     2.40.0
> 
> 

Re: [PATCH v5 0/4] Virtio shared dma-buf

[Philippe Mathieu-Daudé]

Hi Michael,

On 5/9/23 22:45, Michael S. Tsirkin wrote:
> I was hoping for some acks from Gerd or anyone else with a clue
> about graphics, but as that doesn't seem to happen I'll merge.
> Thanks!

I made few late comments. Patch #3 doesn't build (thus
break git-bisections). I also have some concern about locking.
I'd rather see a v6, do you mind dropping v5 from your queue?

Thanks,

Phil.

> On Mon, Aug 21, 2023 at 02:37:56PM +0200, Albert Esteve wrote:
>> Hi all,
>>
>> A little bump for this patch, sorry for the extra noise.
>>
>> Regards,
>> Albert

Re: [PATCH v5 0/4] Virtio shared dma-buf

[Albert Esteve]

[-- Attachment #1: Type: text/plain, Size: 851 bytes --]

On Wed, Sep 6, 2023 at 8:13 AM Philippe Mathieu-Daudé <philmd@linaro.org>
wrote:

> Hi Michael,
>
> On 5/9/23 22:45, Michael S. Tsirkin wrote:
> > I was hoping for some acks from Gerd or anyone else with a clue
> > about graphics, but as that doesn't seem to happen I'll merge.
> > Thanks!
>
> I made few late comments. Patch #3 doesn't build (thus
> break git-bisections). I also have some concern about locking.
> I'd rather see a v6, do you mind dropping v5 from your queue?
>
> Thanks,
>
> Phil.
>

I have the v6 ready. I will wait for Michael response and post it,
to ensure that I do not step on his toes.
Thank you both!


>
> > On Mon, Aug 21, 2023 at 02:37:56PM +0200, Albert Esteve wrote:
> >> Hi all,
> >>
> >> A little bump for this patch, sorry for the extra noise.
> >>
> >> Regards,
> >> Albert
>
>

[-- Attachment #2: Type: text/html, Size: 1523 bytes --]

Re: [PATCH v5 0/4] Virtio shared dma-buf

[Philippe Mathieu-Daudé]

On 6/9/23 11:39, Albert Esteve wrote:
> 
> 
> On Wed, Sep 6, 2023 at 8:13 AM Philippe Mathieu-Daudé <philmd@linaro.org 
> <mailto:philmd@linaro.org>> wrote:
> 
>     Hi Michael,
> 
>     On 5/9/23 22:45, Michael S. Tsirkin wrote:
>      > I was hoping for some acks from Gerd or anyone else with a clue
>      > about graphics, but as that doesn't seem to happen I'll merge.
>      > Thanks!
> 
>     I made few late comments. Patch #3 doesn't build (thus
>     break git-bisections). I also have some concern about locking.
>     I'd rather see a v6, do you mind dropping v5 from your queue?
> 
>     Thanks,
> 
>     Phil.
> 
> 
> I have the v6 ready. I will wait for Michael response and post it,
> to ensure that I do not step on his toes.
> Thank you both!

If you have them ready, don't wait to post them, because:
- we can review them
- Michael can directly pick it instead of dropping the current
   one (you'd have to wait his next PR)