motorhead/qemu
1
0
Fork 0
mirror of https://github.com/Motorhead1991/qemu.git synced 2025-08-04 00:03:54 -06:00
Code Issues Projects Releases Packages Wiki Activity Actions

hw/display: introduce virtio-dmabuf

Browse source 
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>
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Albert Esteve <aesteve@redhat.com>
Message-Id: <20231002065706.94707-3-aesteve@redhat.com>
Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
This commit is contained in:
Albert Esteve 2023-10-02 08:57:04 +02:00 • committed by Michael S. Tsirkin
parent a6ceee591a
commit faefdba847
6 changed files with 384 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

1
tests/unit/meson.build
View file

@ -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

137
tests/unit/test-virtio-dmabuf.c Normal file
View file

@ -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();
}