chardev/char-io.c

   1 /*
   2  * QEMU System Emulator
   3  *
   4  * Copyright (c) 2003-2008 Fabrice Bellard
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  */
  24 #include "qemu/osdep.h"
  25 #include "char-io.h"
  26
  27 typedef struct IOWatchPoll {
  28     GSource parent;
  29
  30     QIOChannel *ioc;
  31     GSource *src;
  32
  33     IOCanReadHandler *fd_can_read;
  34     GSourceFunc fd_read;
  35     void *opaque;
  36     GMainContext *context;
  37 } IOWatchPoll;
  38
  39 static IOWatchPoll *io_watch_poll_from_source(GSource *source)
  40 {
  41     return container_of(source, IOWatchPoll, parent);
  42 }
  43
  44 static gboolean io_watch_poll_prepare(GSource *source,
  45                                       gint *timeout)
  46 {
  47     IOWatchPoll *iwp = io_watch_poll_from_source(source);
  48     bool now_active = iwp->fd_can_read(iwp->opaque) > 0;
  49     bool was_active = iwp->src != NULL;
  50     if (was_active == now_active) {
  51         return FALSE;
  52     }
  53
  54     if (now_active) {
  55         iwp->src = qio_channel_create_watch(
  56             iwp->ioc, G_IO_IN | G_IO_ERR | G_IO_HUP | G_IO_NVAL);
  57         g_source_set_callback(iwp->src, iwp->fd_read, iwp->opaque, NULL);
  58         g_source_attach(iwp->src, iwp->context);
  59     } else {
  60         g_source_destroy(iwp->src);
  61         g_source_unref(iwp->src);
  62         iwp->src = NULL;
  63     }
  64     return FALSE;
  65 }
  66
  67 static gboolean io_watch_poll_check(GSource *source)
  68 {
  69     return FALSE;
  70 }
  71
  72 static gboolean io_watch_poll_dispatch(GSource *source, GSourceFunc callback,
  73                                        gpointer user_data)
  74 {
  75     abort();
  76 }
  77
  78 static void io_watch_poll_finalize(GSource *source)
  79 {
  80     /* Due to a glib bug, removing the last reference to a source
  81      * inside a finalize callback causes recursive locking (and a
  82      * deadlock).  This is not a problem inside other callbacks,
  83      * including dispatch callbacks, so we call io_remove_watch_poll
  84      * to remove this source.  At this point, iwp->src must
  85      * be NULL, or we would leak it.
  86      *
  87      * This would be solved much more elegantly by child sources,
  88      * but we support older glib versions that do not have them.
  89      */
  90     IOWatchPoll *iwp = io_watch_poll_from_source(source);
  91     assert(iwp->src == NULL);
  92 }
  93
  94 static GSourceFuncs io_watch_poll_funcs = {
  95     .prepare = io_watch_poll_prepare,
  96     .check = io_watch_poll_check,
  97     .dispatch = io_watch_poll_dispatch,
  98     .finalize = io_watch_poll_finalize,
  99 };
 100
 101 GSource *io_add_watch_poll(Chardev *chr,
 102                         QIOChannel *ioc,
 103                         IOCanReadHandler *fd_can_read,
 104                         QIOChannelFunc fd_read,
 105                         gpointer user_data,
 106                         GMainContext *context)
 107 {
 108     IOWatchPoll *iwp;
 109     char *name;
 110
 111     iwp = (IOWatchPoll *) g_source_new(&io_watch_poll_funcs,
 112                                        sizeof(IOWatchPoll));
 113     iwp->fd_can_read = fd_can_read;
 114     iwp->opaque = user_data;
 115     iwp->ioc = ioc;
 116     iwp->fd_read = (GSourceFunc) fd_read;
 117     iwp->src = NULL;
 118     iwp->context = context;
 119
 120     name = g_strdup_printf("chardev-iowatch-%s", chr->label);
 121     g_source_set_name((GSource *)iwp, name);
 122     g_free(name);
 123
 124     g_source_attach(&iwp->parent, context);
 125     g_source_unref(&iwp->parent);
 126     return (GSource *)iwp;
 127 }
 128
 129 static void io_remove_watch_poll(GSource *source)
 130 {
 131     IOWatchPoll *iwp;
 132
 133     iwp = io_watch_poll_from_source(source);
 134     if (iwp->src) {
 135         g_source_destroy(iwp->src);
 136         g_source_unref(iwp->src);
 137         iwp->src = NULL;
 138     }
 139     g_source_destroy(&iwp->parent);
 140 }
 141
 142 void remove_fd_in_watch(Chardev *chr)
 143 {
 144     if (chr->gsource) {
 145         io_remove_watch_poll(chr->gsource);
 146         chr->gsource = NULL;
 147     }
 148 }
 149
 150 int io_channel_send_full(QIOChannel *ioc,
 151                          const void *buf, size_t len,
 152                          int *fds, size_t nfds)
 153 {
 154     size_t offset = 0;
 155
 156     while (offset < len) {
 157         ssize_t ret = 0;
 158         struct iovec iov = { .iov_base = (char *)buf + offset,
 159                              .iov_len = len - offset };
 160
 161         ret = qio_channel_writev_full(
 162             ioc, &iov, 1,
 163             fds, nfds, NULL);
 164         if (ret == QIO_CHANNEL_ERR_BLOCK) {
 165             if (offset) {
 166                 return offset;
 167             }
 168
 169             errno = EAGAIN;
 170             return -1;
 171         } else if (ret < 0) {
 172             errno = EINVAL;
 173             return -1;
 174         }
 175
 176         offset += ret;
 177     }
 178
 179     return offset;
 180 }
 181
 182 int io_channel_send(QIOChannel *ioc, const void *buf, size_t len)
 183 {
 184     return io_channel_send_full(ioc, buf, len, NULL, 0);
 185 }