Coverage Report

Created: 2026-11-20 08:13

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/qemu/tests/qtest/libqos/virtio-scmi.c
Line
Count
Source
1
/*
2
 * virtio-scmi nodes for testing
3
 *
4
 * Copyright (c) Linaro Ltd.
5
 * SPDX-FileCopyrightText: Red Hat, Inc.
6
 * SPDX-License-Identifier: GPL-2.0-or-later
7
 *
8
 * Based on virtio-gpio.c, doing basically the same thing.
9
 */
10
11
#include "qemu/osdep.h"
12
#include "standard-headers/linux/virtio_config.h"
13
#include "../libqtest.h"
14
#include "qemu/module.h"
15
#include "qgraph.h"
16
#include "virtio-scmi.h"
17
18
static QGuestAllocator *alloc;
19
20
static void virtio_scmi_cleanup(QVhostUserSCMI *scmi)
21
0
{
22
0
    QVirtioDevice *vdev = scmi->vdev;
23
0
    int i;
24
25
0
    for (i = 0; i < 2; i++) {
26
0
        qvirtqueue_cleanup(vdev->bus, scmi->queues[i], alloc);
27
0
    }
28
0
    g_free(scmi->queues);
29
0
}
30
31
/*
32
 * This handles the VirtIO setup from the point of view of the driver
33
 * frontend and therefore doesn't present any vhost specific features
34
 * and in fact masks of the re-used bit.
35
 */
36
static void virtio_scmi_setup(QVhostUserSCMI *scmi)
37
0
{
38
0
    QVirtioDevice *vdev = scmi->vdev;
39
0
    uint64_t features;
40
0
    int i;
41
42
0
    features = qvirtio_get_features(vdev);
43
0
    features &= ~QVIRTIO_F_BAD_FEATURE;
44
0
    qvirtio_set_features(vdev, features);
45
46
0
    scmi->queues = g_new(QVirtQueue *, 2);
47
0
    for (i = 0; i < 2; i++) {
48
0
        scmi->queues[i] = qvirtqueue_setup(vdev, alloc, i);
49
0
    }
50
0
    qvirtio_set_driver_ok(vdev);
51
0
}
52
53
static void *qvirtio_scmi_get_driver(QVhostUserSCMI *v_scmi,
54
                                     const char *interface)
55
0
{
56
0
    if (!g_strcmp0(interface, "vhost-user-scmi")) {
57
0
        return v_scmi;
58
0
    }
59
0
    if (!g_strcmp0(interface, "virtio")) {
60
0
        return v_scmi->vdev;
61
0
    }
62
63
0
    g_assert_not_reached();
64
0
}
65
66
static void *qvirtio_scmi_device_get_driver(void *object,
67
                                            const char *interface)
68
0
{
69
0
    QVhostUserSCMIDevice *v_scmi = object;
70
0
    return qvirtio_scmi_get_driver(&v_scmi->scmi, interface);
71
0
}
72
73
/* virtio-scmi (mmio) */
74
static void qvirtio_scmi_device_destructor(QOSGraphObject *obj)
75
0
{
76
0
    QVhostUserSCMIDevice *scmi_dev = (QVhostUserSCMIDevice *) obj;
77
0
    virtio_scmi_cleanup(&scmi_dev->scmi);
78
0
}
79
80
static void qvirtio_scmi_device_start_hw(QOSGraphObject *obj)
81
0
{
82
0
    QVhostUserSCMIDevice *scmi_dev = (QVhostUserSCMIDevice *) obj;
83
0
    virtio_scmi_setup(&scmi_dev->scmi);
84
0
}
85
86
static void *virtio_scmi_device_create(void *virtio_dev,
87
                                       QGuestAllocator *t_alloc,
88
                                       void *addr)
89
0
{
90
0
    QVhostUserSCMIDevice *virtio_device = g_new0(QVhostUserSCMIDevice, 1);
91
0
    QVhostUserSCMI *interface = &virtio_device->scmi;
92
93
0
    interface->vdev = virtio_dev;
94
0
    alloc = t_alloc;
95
96
0
    virtio_device->obj.get_driver = qvirtio_scmi_device_get_driver;
97
0
    virtio_device->obj.start_hw = qvirtio_scmi_device_start_hw;
98
0
    virtio_device->obj.destructor = qvirtio_scmi_device_destructor;
99
100
0
    return &virtio_device->obj;
101
0
}
102
103
/* virtio-scmi-pci */
104
static void qvirtio_scmi_pci_destructor(QOSGraphObject *obj)
105
0
{
106
0
    QVhostUserSCMIPCI *scmi_pci = (QVhostUserSCMIPCI *) obj;
107
0
    QOSGraphObject *pci_vobj =  &scmi_pci->pci_vdev.obj;
108
109
0
    virtio_scmi_cleanup(&scmi_pci->scmi);
110
0
    qvirtio_pci_destructor(pci_vobj);
111
0
}
112
113
static void qvirtio_scmi_pci_start_hw(QOSGraphObject *obj)
114
0
{
115
0
    QVhostUserSCMIPCI *scmi_pci = (QVhostUserSCMIPCI *) obj;
116
0
    QOSGraphObject *pci_vobj =  &scmi_pci->pci_vdev.obj;
117
118
0
    qvirtio_pci_start_hw(pci_vobj);
119
0
    virtio_scmi_setup(&scmi_pci->scmi);
120
0
}
121
122
static void *qvirtio_scmi_pci_get_driver(void *object, const char *interface)
123
0
{
124
0
    QVhostUserSCMIPCI *v_scmi = object;
125
126
0
    if (!g_strcmp0(interface, "pci-device")) {
127
0
        return v_scmi->pci_vdev.pdev;
128
0
    }
129
0
    return qvirtio_scmi_get_driver(&v_scmi->scmi, interface);
130
0
}
131
132
static void *virtio_scmi_pci_create(void *pci_bus, QGuestAllocator *t_alloc,
133
                                    void *addr)
134
0
{
135
0
    QVhostUserSCMIPCI *virtio_spci = g_new0(QVhostUserSCMIPCI, 1);
136
0
    QVhostUserSCMI *interface = &virtio_spci->scmi;
137
0
    QOSGraphObject *obj = &virtio_spci->pci_vdev.obj;
138
139
0
    virtio_pci_init(&virtio_spci->pci_vdev, pci_bus, addr);
140
0
    interface->vdev = &virtio_spci->pci_vdev.vdev;
141
0
    alloc = t_alloc;
142
143
0
    obj->get_driver = qvirtio_scmi_pci_get_driver;
144
0
    obj->start_hw = qvirtio_scmi_pci_start_hw;
145
0
    obj->destructor = qvirtio_scmi_pci_destructor;
146
147
0
    return obj;
148
0
}
149
150
static void virtio_scmi_register_nodes(void)
151
63
{
152
63
    QPCIAddress addr = {
153
63
        .devfn = QPCI_DEVFN(4, 0),
154
63
    };
155
156
63
    QOSGraphEdgeOptions edge_opts = { };
157
158
    /* vhost-user-scmi-device */
159
63
    edge_opts.extra_device_opts = "id=scmi,chardev=chr-vhost-user-test "
160
63
        "-global virtio-mmio.force-legacy=false";
161
63
    qos_node_create_driver("vhost-user-scmi-device",
162
63
                            virtio_scmi_device_create);
163
63
    qos_node_consumes("vhost-user-scmi-device", "virtio-bus", &edge_opts);
164
63
    qos_node_produces("vhost-user-scmi-device", "vhost-user-scmi");
165
166
    /* virtio-scmi-pci */
167
63
    edge_opts.extra_device_opts = "id=scmi,addr=04.0,chardev=chr-vhost-user-test";
168
63
    add_qpci_address(&edge_opts, &addr);
169
63
    qos_node_create_driver("vhost-user-scmi-pci", virtio_scmi_pci_create);
170
63
    qos_node_consumes("vhost-user-scmi-pci", "pci-bus", &edge_opts);
171
63
    qos_node_produces("vhost-user-scmi-pci", "vhost-user-scmi");
172
63
}
173
174
libqos_init(virtio_scmi_register_nodes);