Coverage Report

Created: 2026-11-20 08:13

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/qemu/hw/remote/message.c
Line
Count
Source
1
/*
2
 * Copyright © 2020, 2021 Oracle and/or its affiliates.
3
 *
4
 * This work is licensed under the terms of the GNU GPL-v2, version 2 or later.
5
 *
6
 * See the COPYING file in the top-level directory.
7
 *
8
 */
9
10
#include "qemu/osdep.h"
11
12
#include "hw/remote/machine.h"
13
#include "io/channel.h"
14
#include "hw/remote/mpqemu-link.h"
15
#include "qapi/error.h"
16
#include "system/runstate.h"
17
#include "hw/pci/pci.h"
18
#include "exec/memattrs.h"
19
#include "hw/remote/memory.h"
20
#include "hw/remote/iohub.h"
21
#include "system/reset.h"
22
23
static void process_config_write(QIOChannel *ioc, PCIDevice *dev,
24
                                 MPQemuMsg *msg, Error **errp);
25
static void process_config_read(QIOChannel *ioc, PCIDevice *dev,
26
                                MPQemuMsg *msg, Error **errp);
27
static void process_bar_write(QIOChannel *ioc, MPQemuMsg *msg, Error **errp);
28
static void process_bar_read(QIOChannel *ioc, MPQemuMsg *msg, Error **errp);
29
static void process_device_reset_msg(QIOChannel *ioc, PCIDevice *dev,
30
                                     Error **errp);
31
32
void coroutine_fn mpqemu_remote_msg_loop_co(void *data)
33
0
{
34
0
    g_autofree RemoteCommDev *com = (RemoteCommDev *)data;
35
0
    PCIDevice *pci_dev = NULL;
36
0
    Error *local_err = NULL;
37
38
0
    assert(com->ioc);
39
40
0
    pci_dev = com->dev;
41
0
    for (; !local_err;) {
42
0
        MPQemuMsg msg = {0};
43
44
0
        if (!mpqemu_msg_recv(&msg, com->ioc, &local_err)) {
45
0
            break;
46
0
        }
47
48
0
        if (!mpqemu_msg_valid(&msg)) {
49
0
            error_setg(&local_err, "Received invalid message from proxy"
50
0
                                   "in remote process pid="FMT_pid"",
51
0
                                   getpid());
52
0
            break;
53
0
        }
54
55
0
        switch (msg.cmd) {
56
0
        case MPQEMU_CMD_PCI_CFGWRITE:
57
0
            process_config_write(com->ioc, pci_dev, &msg, &local_err);
58
0
            break;
59
0
        case MPQEMU_CMD_PCI_CFGREAD:
60
0
            process_config_read(com->ioc, pci_dev, &msg, &local_err);
61
0
            break;
62
0
        case MPQEMU_CMD_BAR_WRITE:
63
0
            process_bar_write(com->ioc, &msg, &local_err);
64
0
            break;
65
0
        case MPQEMU_CMD_BAR_READ:
66
0
            process_bar_read(com->ioc, &msg, &local_err);
67
0
            break;
68
0
        case MPQEMU_CMD_SYNC_SYSMEM:
69
0
            remote_sysmem_reconfig(&msg, &local_err);
70
0
            break;
71
0
        case MPQEMU_CMD_SET_IRQFD:
72
0
            process_set_irqfd_msg(pci_dev, &msg);
73
0
            break;
74
0
        case MPQEMU_CMD_DEVICE_RESET:
75
0
            process_device_reset_msg(com->ioc, pci_dev, &local_err);
76
0
            break;
77
0
        default:
78
0
            error_setg(&local_err,
79
0
                       "Unknown command (%d) received for device %s"
80
0
                       " (pid="FMT_pid")",
81
0
                       msg.cmd, DEVICE(pci_dev)->id, getpid());
82
0
        }
83
0
    }
84
85
0
    if (local_err) {
86
0
        error_report_err(local_err);
87
0
        qemu_system_shutdown_request(SHUTDOWN_CAUSE_HOST_ERROR);
88
0
    } else {
89
0
        qemu_system_shutdown_request(SHUTDOWN_CAUSE_GUEST_SHUTDOWN);
90
0
    }
91
0
}
92
93
static void process_config_write(QIOChannel *ioc, PCIDevice *dev,
94
                                 MPQemuMsg *msg, Error **errp)
95
0
{
96
0
    ERRP_GUARD();
97
0
    PciConfDataMsg *conf = (PciConfDataMsg *)&msg->data.pci_conf_data;
98
0
    MPQemuMsg ret = { 0 };
99
100
0
    if ((conf->addr + sizeof(conf->val)) > pci_config_size(dev)) {
101
0
        error_setg(errp, "Bad address for PCI config write, pid "FMT_pid".",
102
0
                   getpid());
103
0
        ret.data.u64 = UINT64_MAX;
104
0
    } else {
105
0
        pci_default_write_config(dev, conf->addr, conf->val, conf->len);
106
0
    }
107
108
0
    ret.cmd = MPQEMU_CMD_RET;
109
0
    ret.size = sizeof(ret.data.u64);
110
111
0
    if (!mpqemu_msg_send(&ret, ioc, NULL)) {
112
0
        error_prepend(errp, "Error returning code to proxy, pid "FMT_pid": ",
113
0
                      getpid());
114
0
    }
115
0
}
116
117
static void process_config_read(QIOChannel *ioc, PCIDevice *dev,
118
                                MPQemuMsg *msg, Error **errp)
119
0
{
120
0
    ERRP_GUARD();
121
0
    PciConfDataMsg *conf = (PciConfDataMsg *)&msg->data.pci_conf_data;
122
0
    MPQemuMsg ret = { 0 };
123
124
0
    if ((conf->addr + sizeof(conf->val)) > pci_config_size(dev)) {
125
0
        error_setg(errp, "Bad address for PCI config read, pid "FMT_pid".",
126
0
                   getpid());
127
0
        ret.data.u64 = UINT64_MAX;
128
0
    } else {
129
0
        ret.data.u64 = pci_default_read_config(dev, conf->addr, conf->len);
130
0
    }
131
132
0
    ret.cmd = MPQEMU_CMD_RET;
133
0
    ret.size = sizeof(ret.data.u64);
134
135
0
    if (!mpqemu_msg_send(&ret, ioc, NULL)) {
136
0
        error_prepend(errp, "Error returning code to proxy, pid "FMT_pid": ",
137
0
                      getpid());
138
0
    }
139
0
}
140
141
static void process_bar_write(QIOChannel *ioc, MPQemuMsg *msg, Error **errp)
142
0
{
143
0
    ERRP_GUARD();
144
0
    BarAccessMsg *bar_access = &msg->data.bar_access;
145
0
    AddressSpace *as =
146
0
        bar_access->memory ? &address_space_memory : &address_space_io;
147
0
    MPQemuMsg ret = { 0 };
148
0
    MemTxResult res;
149
0
    uint64_t val;
150
151
0
    if (!is_power_of_2(bar_access->size) ||
152
0
       (bar_access->size > sizeof(uint64_t))) {
153
0
        ret.data.u64 = UINT64_MAX;
154
0
        goto fail;
155
0
    }
156
157
0
    val = cpu_to_le64(bar_access->val);
158
159
0
    res = address_space_rw(as, bar_access->addr, MEMTXATTRS_UNSPECIFIED,
160
0
                           (void *)&val, bar_access->size, true);
161
162
0
    if (res != MEMTX_OK) {
163
0
        error_setg(errp, "Bad address %"PRIx64" for mem write, pid "FMT_pid".",
164
0
                   bar_access->addr, getpid());
165
0
        ret.data.u64 = -1;
166
0
    }
167
168
0
fail:
169
0
    ret.cmd = MPQEMU_CMD_RET;
170
0
    ret.size = sizeof(ret.data.u64);
171
172
0
    if (!mpqemu_msg_send(&ret, ioc, NULL)) {
173
0
        error_prepend(errp, "Error returning code to proxy, pid "FMT_pid": ",
174
0
                      getpid());
175
0
    }
176
0
}
177
178
static void process_bar_read(QIOChannel *ioc, MPQemuMsg *msg, Error **errp)
179
0
{
180
0
    ERRP_GUARD();
181
0
    BarAccessMsg *bar_access = &msg->data.bar_access;
182
0
    MPQemuMsg ret = { 0 };
183
0
    AddressSpace *as;
184
0
    MemTxResult res;
185
0
    uint64_t val = 0;
186
187
0
    as = bar_access->memory ? &address_space_memory : &address_space_io;
188
189
0
    if (!is_power_of_2(bar_access->size) ||
190
0
       (bar_access->size > sizeof(uint64_t))) {
191
0
        val = UINT64_MAX;
192
0
        goto fail;
193
0
    }
194
195
0
    res = address_space_rw(as, bar_access->addr, MEMTXATTRS_UNSPECIFIED,
196
0
                           (void *)&val, bar_access->size, false);
197
198
0
    if (res != MEMTX_OK) {
199
0
        error_setg(errp, "Bad address %"PRIx64" for mem read, pid "FMT_pid".",
200
0
                   bar_access->addr, getpid());
201
0
        val = UINT64_MAX;
202
0
    }
203
204
0
fail:
205
0
    ret.cmd = MPQEMU_CMD_RET;
206
0
    ret.data.u64 = le64_to_cpu(val);
207
0
    ret.size = sizeof(ret.data.u64);
208
209
0
    if (!mpqemu_msg_send(&ret, ioc, NULL)) {
210
0
        error_prepend(errp, "Error returning code to proxy, pid "FMT_pid": ",
211
0
                      getpid());
212
0
    }
213
0
}
214
215
static void process_device_reset_msg(QIOChannel *ioc, PCIDevice *dev,
216
                                     Error **errp)
217
0
{
218
0
    DeviceState *s = DEVICE(dev);
219
0
    MPQemuMsg ret = { 0 };
220
221
0
    device_cold_reset(s);
222
223
0
    ret.cmd = MPQEMU_CMD_RET;
224
225
0
    mpqemu_msg_send(&ret, ioc, errp);
226
0
}