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 guint 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     int tag;
 110     char *name;
 111
 112     iwp = (IOWatchPoll *) g_source_new(&io_watch_poll_funcs,
 113                                        sizeof(IOWatchPoll));
 114     iwp->fd_can_read = fd_can_read;
 115     iwp->opaque = user_data;
 116     iwp->ioc = ioc;
 117     iwp->fd_read = (GSourceFunc) fd_read;
 118     iwp->src = NULL;
 119     iwp->context = context;
 120
 121     name = g_strdup_printf("chardev-iowatch-%s", chr->label);
 122     g_source_set_name((GSource *)iwp, name);
 123     g_free(name);
 124
 125     tag = g_source_attach(&iwp->parent, context);
 126     g_source_unref(&iwp->parent);
 127     return tag;
 128 }
 129
 130 static void io_remove_watch_poll(guint tag)
 131 {
 132     GSource *source;
 133     IOWatchPoll *iwp;
 134
 135     g_return_if_fail(tag > 0);
 136
 137     source = g_main_context_find_source_by_id(NULL, tag);
 138     g_return_if_fail(source != NULL);
 139
 140     iwp = io_watch_poll_from_source(source);
 141     if (iwp->src) {
 142         g_source_destroy(iwp->src);
 143         g_source_unref(iwp->src);
 144         iwp->src = NULL;
 145     }
 146     g_source_destroy(&iwp->parent);
 147 }
 148
 149 void remove_fd_in_watch(Chardev *chr)
 150 {
 151     if (chr->fd_in_tag) {
 152         io_remove_watch_poll(chr->fd_in_tag);
 153         chr->fd_in_tag = 0;
 154     }
 155 }
 156
 157 int io_channel_send_full(QIOChannel *ioc,
 158                          const void *buf, size_t len,
 159                          int *fds, size_t nfds)
 160 {
 161     size_t offset = 0;
 162
 163     while (offset < len) {
 164         ssize_t ret = 0;
 165         struct iovec iov = { .iov_base = (char *)buf + offset,
 166                              .iov_len = len - offset };
 167
 168         ret = qio_channel_writev_full(
 169             ioc, &iov, 1,
 170             fds, nfds, NULL);
 171         if (ret == QIO_CHANNEL_ERR_BLOCK) {
 172             if (offset) {
 173                 return offset;
 174             }
 175
 176             errno = EAGAIN;
 177             return -1;
 178         } else if (ret < 0) {
 179             errno = EINVAL;
 180             return -1;
 181         }
 182
 183         offset += ret;
 184     }
 185
 186     return offset;
 187 }
 188
 189 int io_channel_send(QIOChannel *ioc, const void *buf, size_t len)
 190 {
 191     return io_channel_send_full(ioc, buf, len, NULL, 0);
 192 }