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 } 193