2 * Communication channel between QEMU and remote device process
4 * Copyright © 2018, 2021 Oracle and/or its affiliates.
6 * This work is licensed under the terms of the GNU GPL, version 2 or later.
7 * See the COPYING file in the top-level directory.
11 #include "qemu/osdep.h"
12 #include "qemu-common.h"
14 #include "qemu/module.h"
15 #include "hw/remote/mpqemu-link.h"
16 #include "qapi/error.h"
18 #include "qemu/error-report.h"
19 #include "qemu/main-loop.h"
20 #include "io/channel.h"
21 #include "sysemu/iothread.h"
25 * Send message over the ioc QIOChannel.
26 * This function is safe to call from:
27 * - main loop in co-routine context. Will block the main loop if not in
29 * - vCPU thread with no co-routine context and if the channel is not part
30 * of the main loop handling;
31 * - IOThread within co-routine context, outside of co-routine context
32 * will block IOThread;
33 * Returns true if no errors were encountered, false otherwise.
35 bool mpqemu_msg_send(MPQemuMsg
*msg
, QIOChannel
*ioc
, Error
**errp
)
37 bool iolock
= qemu_mutex_iothread_locked();
38 bool iothread
= qemu_in_iothread();
39 struct iovec send
[2] = {};
44 send
[0].iov_base
= msg
;
45 send
[0].iov_len
= MPQEMU_MSG_HDR_SIZE
;
47 send
[1].iov_base
= (void *)&msg
->data
;
48 send
[1].iov_len
= msg
->size
;
56 * Dont use in IOThread out of co-routine context as
57 * it will block IOThread.
59 assert(qemu_in_coroutine() || !iothread
);
62 * Skip unlocking/locking iothread lock when the IOThread is running
63 * in co-routine context. Co-routine context is asserted above
65 * Also skip lock handling while in a co-routine in the main context.
67 if (iolock
&& !iothread
&& !qemu_in_coroutine()) {
68 qemu_mutex_unlock_iothread();
71 if (!qio_channel_writev_full_all(ioc
, send
, G_N_ELEMENTS(send
),
75 trace_mpqemu_send_io_error(msg
->cmd
, msg
->size
, nfds
);
78 if (iolock
&& !iothread
&& !qemu_in_coroutine()) {
79 /* See above comment why skip locking here. */
80 qemu_mutex_lock_iothread();
87 * Read message from the ioc QIOChannel.
88 * This function is safe to call from:
89 * - From main loop in co-routine context. Will block the main loop if not in
91 * - From vCPU thread with no co-routine context and if the channel is not part
92 * of the main loop handling;
93 * - From IOThread within co-routine context, outside of co-routine context
94 * will block IOThread;
96 static ssize_t
mpqemu_read(QIOChannel
*ioc
, void *buf
, size_t len
, int **fds
,
97 size_t *nfds
, Error
**errp
)
99 struct iovec iov
= { .iov_base
= buf
, .iov_len
= len
};
100 bool iolock
= qemu_mutex_iothread_locked();
101 bool iothread
= qemu_in_iothread();
105 * Dont use in IOThread out of co-routine context as
106 * it will block IOThread.
108 assert(qemu_in_coroutine() || !iothread
);
110 if (iolock
&& !iothread
&& !qemu_in_coroutine()) {
111 qemu_mutex_unlock_iothread();
114 ret
= qio_channel_readv_full_all_eof(ioc
, &iov
, 1, fds
, nfds
, errp
);
116 if (iolock
&& !iothread
&& !qemu_in_coroutine()) {
117 qemu_mutex_lock_iothread();
120 return (ret
<= 0) ? ret
: iov
.iov_len
;
123 bool mpqemu_msg_recv(MPQemuMsg
*msg
, QIOChannel
*ioc
, Error
**errp
)
126 g_autofree
int *fds
= NULL
;
131 len
= mpqemu_read(ioc
, msg
, MPQEMU_MSG_HDR_SIZE
, &fds
, &nfds
, errp
);
134 } else if (len
!= MPQEMU_MSG_HDR_SIZE
) {
135 error_setg(errp
, "Message header corrupted");
139 if (msg
->size
> sizeof(msg
->data
)) {
140 error_setg(errp
, "Invalid size for message");
148 len
= mpqemu_read(ioc
, &msg
->data
, msg
->size
, NULL
, NULL
, errp
);
152 if (len
!= msg
->size
) {
153 error_setg(errp
, "Unable to read full message");
159 if (nfds
> G_N_ELEMENTS(msg
->fds
)) {
161 "Overflow error: received %zu fds, more than max of %d fds",
162 nfds
, REMOTE_MAX_FDS
);
166 memcpy(msg
->fds
, fds
, nfds
* sizeof(int));
173 trace_mpqemu_recv_io_error(msg
->cmd
, msg
->size
, nfds
);
175 while (*errp
&& nfds
) {
176 close(fds
[nfds
- 1]);
184 * Send msg and wait for a reply with command code RET_MSG.
185 * Returns the message received of size u64 or UINT64_MAX
187 * Called from VCPU thread in non-coroutine context.
188 * Used by the Proxy object to communicate to remote processes.
190 uint64_t mpqemu_msg_send_and_await_reply(MPQemuMsg
*msg
, PCIProxyDev
*pdev
,
193 MPQemuMsg msg_reply
= {0};
194 uint64_t ret
= UINT64_MAX
;
196 assert(!qemu_in_coroutine());
198 QEMU_LOCK_GUARD(&pdev
->io_mutex
);
199 if (!mpqemu_msg_send(msg
, pdev
->ioc
, errp
)) {
203 if (!mpqemu_msg_recv(&msg_reply
, pdev
->ioc
, errp
)) {
207 if (!mpqemu_msg_valid(&msg_reply
) || msg_reply
.cmd
!= MPQEMU_CMD_RET
) {
208 error_setg(errp
, "ERROR: Invalid reply received for command %d",
213 return msg_reply
.data
.u64
;
216 bool mpqemu_msg_valid(MPQemuMsg
*msg
)
218 if (msg
->cmd
>= MPQEMU_CMD_MAX
|| msg
->cmd
< 0) {
223 if (msg
->num_fds
>= REMOTE_MAX_FDS
) {
227 if (msg
->num_fds
> 0) {
228 for (int i
= 0; i
< msg
->num_fds
; i
++) {
229 if (fcntl(msg
->fds
[i
], F_GETFL
) == -1) {
235 /* Verify message specific fields. */
237 case MPQEMU_CMD_SYNC_SYSMEM
:
238 if (msg
->num_fds
== 0 || msg
->size
!= sizeof(SyncSysmemMsg
)) {
242 case MPQEMU_CMD_PCI_CFGWRITE
:
243 case MPQEMU_CMD_PCI_CFGREAD
:
244 if (msg
->size
!= sizeof(PciConfDataMsg
)) {
248 case MPQEMU_CMD_BAR_WRITE
:
249 case MPQEMU_CMD_BAR_READ
:
250 if ((msg
->size
!= sizeof(BarAccessMsg
)) || (msg
->num_fds
!= 0)) {
254 case MPQEMU_CMD_SET_IRQFD
:
255 if (msg
->size
|| (msg
->num_fds
!= 2)) {