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 "chardev/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     /*
  55      * We do not register the QIOChannel watch as a child GSource.
  56      * The 'prepare' function on the parent GSource will be
  57      * skipped if a child GSource's 'prepare' function indicates
  58      * readiness. We need this prepare function be guaranteed
  59      * to run on *every* iteration of the main loop, because
  60      * it is critical to ensure we remove the QIOChannel watch
  61      * if 'fd_can_read' indicates the frontend cannot receive
  62      * more data.
  63      */
  64     if (now_active) {
  65         iwp->src = qio_channel_create_watch(
  66             iwp->ioc, G_IO_IN | G_IO_ERR | G_IO_HUP | G_IO_NVAL);
  67         g_source_set_callback(iwp->src, iwp->fd_read, iwp->opaque, NULL);
  68         g_source_attach(iwp->src, iwp->context);
  69     } else {
  70         g_source_destroy(iwp->src);
  71         g_source_unref(iwp->src);
  72         iwp->src = NULL;
  73     }
  74     return FALSE;
  75 }
  76
  77 static gboolean io_watch_poll_check(GSource *source)
  78 {
  79     return FALSE;
  80 }
  81
  82 static gboolean io_watch_poll_dispatch(GSource *source, GSourceFunc callback,
  83                                        gpointer user_data)
  84 {
  85     abort();
  86 }
  87
  88 static void io_watch_poll_finalize(GSource *source)
  89 {
  90     IOWatchPoll *iwp = io_watch_poll_from_source(source);
  91     if (iwp->src) {
  92         g_source_destroy(iwp->src);
  93         g_source_unref(iwp->src);
  94         iwp->src = NULL;
  95     }
  96 }
  97
  98 static GSourceFuncs io_watch_poll_funcs = {
  99     .prepare = io_watch_poll_prepare,
 100     .check = io_watch_poll_check,
 101     .dispatch = io_watch_poll_dispatch,
 102     .finalize = io_watch_poll_finalize,
 103 };
 104
 105 GSource *io_add_watch_poll(Chardev *chr,
 106                         QIOChannel *ioc,
 107                         IOCanReadHandler *fd_can_read,
 108                         QIOChannelFunc fd_read,
 109                         gpointer user_data,
 110                         GMainContext *context)
 111 {
 112     IOWatchPoll *iwp;
 113     char *name;
 114
 115     iwp = (IOWatchPoll *) g_source_new(&io_watch_poll_funcs,
 116                                        sizeof(IOWatchPoll));
 117     iwp->fd_can_read = fd_can_read;
 118     iwp->opaque = user_data;
 119     iwp->ioc = ioc;
 120     iwp->fd_read = (GSourceFunc) fd_read;
 121     iwp->src = NULL;
 122     iwp->context = context;
 123
 124     name = g_strdup_printf("chardev-iowatch-%s", chr->label);
 125     g_source_set_name((GSource *)iwp, name);
 126     g_free(name);
 127
 128     g_source_attach(&iwp->parent, context);
 129     g_source_unref(&iwp->parent);
 130     return (GSource *)iwp;
 131 }
 132
 133 static void io_remove_watch_poll(GSource *source)
 134 {
 135     IOWatchPoll *iwp;
 136
 137     iwp = io_watch_poll_from_source(source);
 138     g_source_destroy(&iwp->parent);
 139 }
 140
 141 void remove_fd_in_watch(Chardev *chr)
 142 {
 143     if (chr->gsource) {
 144         io_remove_watch_poll(chr->gsource);
 145         chr->gsource = NULL;
 146     }
 147 }
 148
 149 int io_channel_send_full(QIOChannel *ioc,
 150                          const void *buf, size_t len,
 151                          int *fds, size_t nfds)
 152 {
 153     size_t offset = 0;
 154
 155     while (offset < len) {
 156         ssize_t ret = 0;
 157         struct iovec iov = { .iov_base = (char *)buf + offset,
 158                              .iov_len = len - offset };
 159
 160         ret = qio_channel_writev_full(
 161             ioc, &iov, 1,
 162             fds, nfds, 0, NULL);
 163         if (ret == QIO_CHANNEL_ERR_BLOCK) {
 164             if (offset) {
 165                 return offset;
 166             }
 167
 168             errno = EAGAIN;
 169             return -1;
 170         } else if (ret < 0) {
 171             errno = EINVAL;
 172             return -1;
 173         }
 174
 175         offset += ret;
 176     }
 177
 178     return offset;
 179 }
 180
 181 int io_channel_send(QIOChannel *ioc, const void *buf, size_t len)
 182 {
 183     return io_channel_send_full(ioc, buf, len, NULL, 0);
 184 }