hw/remote/mpqemu-link.c

   1 /*
   2  * Communication channel between QEMU and remote device process
   3  *
   4  * Copyright © 2018, 2021 Oracle and/or its affiliates.
   5  *
   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.
   8  *
   9  */
  10
  11 #include "qemu/osdep.h"
  12 #include "qemu-common.h"
  13
  14 #include "qemu/module.h"
  15 #include "hw/remote/mpqemu-link.h"
  16 #include "qapi/error.h"
  17 #include "qemu/iov.h"
  18 #include "qemu/error-report.h"
  19 #include "qemu/main-loop.h"
  20 #include "io/channel.h"
  21 #include "sysemu/iothread.h"
  22 #include "trace.h"
  23
  24 /*
  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
  28  *   co-routine context;
  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.
  34  */
  35 bool mpqemu_msg_send(MPQemuMsg *msg, QIOChannel *ioc, Error **errp)
  36 {
  37     ERRP_GUARD();
  38     bool iolock = qemu_mutex_iothread_locked();
  39     bool iothread = qemu_in_iothread();
  40     struct iovec send[2] = {};
  41     int *fds = NULL;
  42     size_t nfds = 0;
  43     bool ret = false;
  44
  45     send[0].iov_base = msg;
  46     send[0].iov_len = MPQEMU_MSG_HDR_SIZE;
  47
  48     send[1].iov_base = (void *)&msg->data;
  49     send[1].iov_len = msg->size;
  50
  51     if (msg->num_fds) {
  52         nfds = msg->num_fds;
  53         fds = msg->fds;
  54     }
  55
  56     /*
  57      * Dont use in IOThread out of co-routine context as
  58      * it will block IOThread.
  59      */
  60     assert(qemu_in_coroutine() || !iothread);
  61
  62     /*
  63      * Skip unlocking/locking iothread lock when the IOThread is running
  64      * in co-routine context. Co-routine context is asserted above
  65      * for IOThread case.
  66      * Also skip lock handling while in a co-routine in the main context.
  67      */
  68     if (iolock && !iothread && !qemu_in_coroutine()) {
  69         qemu_mutex_unlock_iothread();
  70     }
  71
  72     if (!qio_channel_writev_full_all(ioc, send, G_N_ELEMENTS(send),
  73                                     fds, nfds, errp)) {
  74         ret = true;
  75     } else {
  76         trace_mpqemu_send_io_error(msg->cmd, msg->size, nfds);
  77     }
  78
  79     if (iolock && !iothread && !qemu_in_coroutine()) {
  80         /* See above comment why skip locking here. */
  81         qemu_mutex_lock_iothread();
  82     }
  83
  84     return ret;
  85 }
  86
  87 /*
  88  * Read message from the ioc QIOChannel.
  89  * This function is safe to call from:
  90  * - From main loop in co-routine context. Will block the main loop if not in
  91  *   co-routine context;
  92  * - From vCPU thread with no co-routine context and if the channel is not part
  93  *   of the main loop handling;
  94  * - From IOThread within co-routine context, outside of co-routine context
  95  *   will block IOThread;
  96  */
  97 static ssize_t mpqemu_read(QIOChannel *ioc, void *buf, size_t len, int **fds,
  98                            size_t *nfds, Error **errp)
  99 {
 100     ERRP_GUARD();
 101     struct iovec iov = { .iov_base = buf, .iov_len = len };
 102     bool iolock = qemu_mutex_iothread_locked();
 103     bool iothread = qemu_in_iothread();
 104     int ret = -1;
 105
 106     /*
 107      * Dont use in IOThread out of co-routine context as
 108      * it will block IOThread.
 109      */
 110     assert(qemu_in_coroutine() || !iothread);
 111
 112     if (iolock && !iothread && !qemu_in_coroutine()) {
 113         qemu_mutex_unlock_iothread();
 114     }
 115
 116     ret = qio_channel_readv_full_all_eof(ioc, &iov, 1, fds, nfds, errp);
 117
 118     if (iolock && !iothread && !qemu_in_coroutine()) {
 119         qemu_mutex_lock_iothread();
 120     }
 121
 122     return (ret <= 0) ? ret : iov.iov_len;
 123 }
 124
 125 bool mpqemu_msg_recv(MPQemuMsg *msg, QIOChannel *ioc, Error **errp)
 126 {
 127     ERRP_GUARD();
 128     g_autofree int *fds = NULL;
 129     size_t nfds = 0;
 130     ssize_t len;
 131     bool ret = false;
 132
 133     len = mpqemu_read(ioc, msg, MPQEMU_MSG_HDR_SIZE, &fds, &nfds, errp);
 134     if (len <= 0) {
 135         goto fail;
 136     } else if (len != MPQEMU_MSG_HDR_SIZE) {
 137         error_setg(errp, "Message header corrupted");
 138         goto fail;
 139     }
 140
 141     if (msg->size > sizeof(msg->data)) {
 142         error_setg(errp, "Invalid size for message");
 143         goto fail;
 144     }
 145
 146     if (!msg->size) {
 147         goto copy_fds;
 148     }
 149
 150     len = mpqemu_read(ioc, &msg->data, msg->size, NULL, NULL, errp);
 151     if (len <= 0) {
 152         goto fail;
 153     }
 154     if (len != msg->size) {
 155         error_setg(errp, "Unable to read full message");
 156         goto fail;
 157     }
 158
 159 copy_fds:
 160     msg->num_fds = nfds;
 161     if (nfds > G_N_ELEMENTS(msg->fds)) {
 162         error_setg(errp,
 163                    "Overflow error: received %zu fds, more than max of %d fds",
 164                    nfds, REMOTE_MAX_FDS);
 165         goto fail;
 166     }
 167     if (nfds) {
 168         memcpy(msg->fds, fds, nfds * sizeof(int));
 169     }
 170
 171     ret = true;
 172
 173 fail:
 174     if (*errp) {
 175         trace_mpqemu_recv_io_error(msg->cmd, msg->size, nfds);
 176     }
 177     while (*errp && nfds) {
 178         close(fds[nfds - 1]);
 179         nfds--;
 180     }
 181
 182     return ret;
 183 }
 184
 185 bool mpqemu_msg_valid(MPQemuMsg *msg)
 186 {
 187     if (msg->cmd >= MPQEMU_CMD_MAX && msg->cmd < 0) {
 188         return false;
 189     }
 190
 191     /* Verify FDs. */
 192     if (msg->num_fds >= REMOTE_MAX_FDS) {
 193         return false;
 194     }
 195
 196     if (msg->num_fds > 0) {
 197         for (int i = 0; i < msg->num_fds; i++) {
 198             if (fcntl(msg->fds[i], F_GETFL) == -1) {
 199                 return false;
 200             }
 201         }
 202     }
 203
 204     return true;
 205 }