Daniel P. Berrange | 1c809fa | 2015-03-03 12:59:16 +0000 | [diff] [blame] | 1 | /* |
| 2 | * QEMU I/O channels watch helper APIs |
| 3 | * |
| 4 | * Copyright (c) 2015 Red Hat, Inc. |
| 5 | * |
| 6 | * This library is free software; you can redistribute it and/or |
| 7 | * modify it under the terms of the GNU Lesser General Public |
| 8 | * License as published by the Free Software Foundation; either |
Chetan Pant | c8198bd | 2020-10-14 13:40:33 +0000 | [diff] [blame] | 9 | * version 2.1 of the License, or (at your option) any later version. |
Daniel P. Berrange | 1c809fa | 2015-03-03 12:59:16 +0000 | [diff] [blame] | 10 | * |
| 11 | * This library is distributed in the hope that it will be useful, |
| 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| 14 | * Lesser General Public License for more details. |
| 15 | * |
| 16 | * You should have received a copy of the GNU Lesser General Public |
| 17 | * License along with this library; if not, see <http://www.gnu.org/licenses/>. |
| 18 | * |
| 19 | */ |
| 20 | |
Peter Maydell | cae9fc5 | 2016-01-29 17:50:03 +0000 | [diff] [blame] | 21 | #include "qemu/osdep.h" |
Daniel P. Berrange | 1c809fa | 2015-03-03 12:59:16 +0000 | [diff] [blame] | 22 | #include "io/channel-watch.h" |
| 23 | |
| 24 | typedef struct QIOChannelFDSource QIOChannelFDSource; |
| 25 | struct QIOChannelFDSource { |
| 26 | GSource parent; |
| 27 | GPollFD fd; |
| 28 | QIOChannel *ioc; |
| 29 | GIOCondition condition; |
| 30 | }; |
| 31 | |
| 32 | |
Paolo Bonzini | a589720 | 2016-03-07 12:12:36 +0100 | [diff] [blame] | 33 | #ifdef CONFIG_WIN32 |
| 34 | typedef struct QIOChannelSocketSource QIOChannelSocketSource; |
| 35 | struct QIOChannelSocketSource { |
| 36 | GSource parent; |
| 37 | GPollFD fd; |
| 38 | QIOChannel *ioc; |
| 39 | SOCKET socket; |
| 40 | int revents; |
| 41 | GIOCondition condition; |
| 42 | }; |
| 43 | |
| 44 | #endif |
| 45 | |
| 46 | |
Daniel P. Berrange | 1c809fa | 2015-03-03 12:59:16 +0000 | [diff] [blame] | 47 | typedef struct QIOChannelFDPairSource QIOChannelFDPairSource; |
| 48 | struct QIOChannelFDPairSource { |
| 49 | GSource parent; |
| 50 | GPollFD fdread; |
| 51 | GPollFD fdwrite; |
| 52 | QIOChannel *ioc; |
| 53 | GIOCondition condition; |
| 54 | }; |
| 55 | |
| 56 | |
| 57 | static gboolean |
| 58 | qio_channel_fd_source_prepare(GSource *source G_GNUC_UNUSED, |
| 59 | gint *timeout) |
| 60 | { |
| 61 | *timeout = -1; |
| 62 | |
| 63 | return FALSE; |
| 64 | } |
| 65 | |
| 66 | |
| 67 | static gboolean |
| 68 | qio_channel_fd_source_check(GSource *source) |
| 69 | { |
| 70 | QIOChannelFDSource *ssource = (QIOChannelFDSource *)source; |
| 71 | |
| 72 | return ssource->fd.revents & ssource->condition; |
| 73 | } |
| 74 | |
| 75 | |
| 76 | static gboolean |
| 77 | qio_channel_fd_source_dispatch(GSource *source, |
| 78 | GSourceFunc callback, |
| 79 | gpointer user_data) |
| 80 | { |
| 81 | QIOChannelFunc func = (QIOChannelFunc)callback; |
| 82 | QIOChannelFDSource *ssource = (QIOChannelFDSource *)source; |
| 83 | |
| 84 | return (*func)(ssource->ioc, |
| 85 | ssource->fd.revents & ssource->condition, |
| 86 | user_data); |
| 87 | } |
| 88 | |
| 89 | |
| 90 | static void |
| 91 | qio_channel_fd_source_finalize(GSource *source) |
| 92 | { |
| 93 | QIOChannelFDSource *ssource = (QIOChannelFDSource *)source; |
| 94 | |
| 95 | object_unref(OBJECT(ssource->ioc)); |
| 96 | } |
| 97 | |
| 98 | |
Paolo Bonzini | a589720 | 2016-03-07 12:12:36 +0100 | [diff] [blame] | 99 | #ifdef CONFIG_WIN32 |
| 100 | static gboolean |
| 101 | qio_channel_socket_source_prepare(GSource *source G_GNUC_UNUSED, |
| 102 | gint *timeout) |
| 103 | { |
| 104 | *timeout = -1; |
| 105 | |
| 106 | return FALSE; |
| 107 | } |
| 108 | |
| 109 | |
| 110 | /* |
| 111 | * NB, this impl only works when the socket is in non-blocking |
| 112 | * mode on Win32 |
| 113 | */ |
| 114 | static gboolean |
| 115 | qio_channel_socket_source_check(GSource *source) |
| 116 | { |
| 117 | static struct timeval tv0; |
Paolo Bonzini | a589720 | 2016-03-07 12:12:36 +0100 | [diff] [blame] | 118 | QIOChannelSocketSource *ssource = (QIOChannelSocketSource *)source; |
Paolo Bonzini | a589720 | 2016-03-07 12:12:36 +0100 | [diff] [blame] | 119 | fd_set rfds, wfds, xfds; |
| 120 | |
| 121 | if (!ssource->condition) { |
| 122 | return 0; |
| 123 | } |
| 124 | |
Paolo Bonzini | a589720 | 2016-03-07 12:12:36 +0100 | [diff] [blame] | 125 | FD_ZERO(&rfds); |
| 126 | FD_ZERO(&wfds); |
| 127 | FD_ZERO(&xfds); |
| 128 | if (ssource->condition & G_IO_IN) { |
Bin Meng | 6c822a0 | 2022-10-06 23:19:24 +0800 | [diff] [blame] | 129 | FD_SET(ssource->socket, &rfds); |
Paolo Bonzini | a589720 | 2016-03-07 12:12:36 +0100 | [diff] [blame] | 130 | } |
| 131 | if (ssource->condition & G_IO_OUT) { |
Bin Meng | 6c822a0 | 2022-10-06 23:19:24 +0800 | [diff] [blame] | 132 | FD_SET(ssource->socket, &wfds); |
Paolo Bonzini | a589720 | 2016-03-07 12:12:36 +0100 | [diff] [blame] | 133 | } |
| 134 | if (ssource->condition & G_IO_PRI) { |
Bin Meng | 6c822a0 | 2022-10-06 23:19:24 +0800 | [diff] [blame] | 135 | FD_SET(ssource->socket, &xfds); |
Paolo Bonzini | a589720 | 2016-03-07 12:12:36 +0100 | [diff] [blame] | 136 | } |
| 137 | ssource->revents = 0; |
| 138 | if (select(0, &rfds, &wfds, &xfds, &tv0) == 0) { |
| 139 | return 0; |
| 140 | } |
| 141 | |
| 142 | if (FD_ISSET(ssource->socket, &rfds)) { |
| 143 | ssource->revents |= G_IO_IN; |
| 144 | } |
| 145 | if (FD_ISSET(ssource->socket, &wfds)) { |
| 146 | ssource->revents |= G_IO_OUT; |
| 147 | } |
| 148 | if (FD_ISSET(ssource->socket, &xfds)) { |
| 149 | ssource->revents |= G_IO_PRI; |
| 150 | } |
| 151 | |
| 152 | return ssource->revents; |
| 153 | } |
| 154 | |
| 155 | |
| 156 | static gboolean |
| 157 | qio_channel_socket_source_dispatch(GSource *source, |
| 158 | GSourceFunc callback, |
| 159 | gpointer user_data) |
| 160 | { |
| 161 | QIOChannelFunc func = (QIOChannelFunc)callback; |
| 162 | QIOChannelSocketSource *ssource = (QIOChannelSocketSource *)source; |
| 163 | |
| 164 | return (*func)(ssource->ioc, ssource->revents, user_data); |
| 165 | } |
| 166 | |
| 167 | |
| 168 | static void |
| 169 | qio_channel_socket_source_finalize(GSource *source) |
| 170 | { |
| 171 | QIOChannelSocketSource *ssource = (QIOChannelSocketSource *)source; |
| 172 | |
| 173 | object_unref(OBJECT(ssource->ioc)); |
| 174 | } |
| 175 | |
| 176 | |
| 177 | GSourceFuncs qio_channel_socket_source_funcs = { |
| 178 | qio_channel_socket_source_prepare, |
| 179 | qio_channel_socket_source_check, |
| 180 | qio_channel_socket_source_dispatch, |
| 181 | qio_channel_socket_source_finalize |
| 182 | }; |
| 183 | #endif |
| 184 | |
| 185 | |
Daniel P. Berrange | 1c809fa | 2015-03-03 12:59:16 +0000 | [diff] [blame] | 186 | static gboolean |
| 187 | qio_channel_fd_pair_source_prepare(GSource *source G_GNUC_UNUSED, |
| 188 | gint *timeout) |
| 189 | { |
| 190 | *timeout = -1; |
| 191 | |
| 192 | return FALSE; |
| 193 | } |
| 194 | |
| 195 | |
| 196 | static gboolean |
| 197 | qio_channel_fd_pair_source_check(GSource *source) |
| 198 | { |
| 199 | QIOChannelFDPairSource *ssource = (QIOChannelFDPairSource *)source; |
| 200 | GIOCondition poll_condition = ssource->fdread.revents | |
| 201 | ssource->fdwrite.revents; |
| 202 | |
| 203 | return poll_condition & ssource->condition; |
| 204 | } |
| 205 | |
| 206 | |
| 207 | static gboolean |
| 208 | qio_channel_fd_pair_source_dispatch(GSource *source, |
| 209 | GSourceFunc callback, |
| 210 | gpointer user_data) |
| 211 | { |
| 212 | QIOChannelFunc func = (QIOChannelFunc)callback; |
| 213 | QIOChannelFDPairSource *ssource = (QIOChannelFDPairSource *)source; |
| 214 | GIOCondition poll_condition = ssource->fdread.revents | |
| 215 | ssource->fdwrite.revents; |
| 216 | |
| 217 | return (*func)(ssource->ioc, |
| 218 | poll_condition & ssource->condition, |
| 219 | user_data); |
| 220 | } |
| 221 | |
| 222 | |
| 223 | static void |
| 224 | qio_channel_fd_pair_source_finalize(GSource *source) |
| 225 | { |
| 226 | QIOChannelFDPairSource *ssource = (QIOChannelFDPairSource *)source; |
| 227 | |
| 228 | object_unref(OBJECT(ssource->ioc)); |
| 229 | } |
| 230 | |
| 231 | |
| 232 | GSourceFuncs qio_channel_fd_source_funcs = { |
| 233 | qio_channel_fd_source_prepare, |
| 234 | qio_channel_fd_source_check, |
| 235 | qio_channel_fd_source_dispatch, |
| 236 | qio_channel_fd_source_finalize |
| 237 | }; |
| 238 | |
| 239 | |
| 240 | GSourceFuncs qio_channel_fd_pair_source_funcs = { |
| 241 | qio_channel_fd_pair_source_prepare, |
| 242 | qio_channel_fd_pair_source_check, |
| 243 | qio_channel_fd_pair_source_dispatch, |
| 244 | qio_channel_fd_pair_source_finalize |
| 245 | }; |
| 246 | |
| 247 | |
| 248 | GSource *qio_channel_create_fd_watch(QIOChannel *ioc, |
| 249 | int fd, |
| 250 | GIOCondition condition) |
| 251 | { |
| 252 | GSource *source; |
| 253 | QIOChannelFDSource *ssource; |
| 254 | |
| 255 | source = g_source_new(&qio_channel_fd_source_funcs, |
| 256 | sizeof(QIOChannelFDSource)); |
| 257 | ssource = (QIOChannelFDSource *)source; |
| 258 | |
| 259 | ssource->ioc = ioc; |
| 260 | object_ref(OBJECT(ioc)); |
| 261 | |
| 262 | ssource->condition = condition; |
| 263 | |
Paolo Bonzini | e560d14 | 2016-03-07 11:13:06 +0100 | [diff] [blame] | 264 | #ifdef CONFIG_WIN32 |
| 265 | ssource->fd.fd = (gint64)_get_osfhandle(fd); |
| 266 | #else |
Daniel P. Berrange | 1c809fa | 2015-03-03 12:59:16 +0000 | [diff] [blame] | 267 | ssource->fd.fd = fd; |
Paolo Bonzini | e560d14 | 2016-03-07 11:13:06 +0100 | [diff] [blame] | 268 | #endif |
Daniel P. Berrange | 1c809fa | 2015-03-03 12:59:16 +0000 | [diff] [blame] | 269 | ssource->fd.events = condition; |
| 270 | |
| 271 | g_source_add_poll(source, &ssource->fd); |
| 272 | |
| 273 | return source; |
| 274 | } |
| 275 | |
Paolo Bonzini | b83b68a | 2016-03-07 11:16:39 +0100 | [diff] [blame] | 276 | #ifdef CONFIG_WIN32 |
| 277 | GSource *qio_channel_create_socket_watch(QIOChannel *ioc, |
Marc-André Lureau | abe3428 | 2023-02-21 16:47:59 +0400 | [diff] [blame] | 278 | int sockfd, |
Paolo Bonzini | b83b68a | 2016-03-07 11:16:39 +0100 | [diff] [blame] | 279 | GIOCondition condition) |
| 280 | { |
Paolo Bonzini | a589720 | 2016-03-07 12:12:36 +0100 | [diff] [blame] | 281 | GSource *source; |
| 282 | QIOChannelSocketSource *ssource; |
| 283 | |
Marc-André Lureau | abe3428 | 2023-02-21 16:47:59 +0400 | [diff] [blame] | 284 | qemu_socket_select(sockfd, ioc->event, |
Marc-André Lureau | f5fd677 | 2023-02-21 16:47:51 +0400 | [diff] [blame] | 285 | FD_READ | FD_ACCEPT | FD_CLOSE | |
| 286 | FD_CONNECT | FD_WRITE | FD_OOB, NULL); |
Paolo Bonzini | bf88c12 | 2017-02-13 14:52:22 +0100 | [diff] [blame] | 287 | |
Paolo Bonzini | a589720 | 2016-03-07 12:12:36 +0100 | [diff] [blame] | 288 | source = g_source_new(&qio_channel_socket_source_funcs, |
| 289 | sizeof(QIOChannelSocketSource)); |
| 290 | ssource = (QIOChannelSocketSource *)source; |
| 291 | |
| 292 | ssource->ioc = ioc; |
| 293 | object_ref(OBJECT(ioc)); |
| 294 | |
| 295 | ssource->condition = condition; |
Marc-André Lureau | abe3428 | 2023-02-21 16:47:59 +0400 | [diff] [blame] | 296 | ssource->socket = _get_osfhandle(sockfd); |
Paolo Bonzini | a589720 | 2016-03-07 12:12:36 +0100 | [diff] [blame] | 297 | ssource->revents = 0; |
| 298 | |
| 299 | ssource->fd.fd = (gintptr)ioc->event; |
| 300 | ssource->fd.events = G_IO_IN; |
| 301 | |
| 302 | g_source_add_poll(source, &ssource->fd); |
| 303 | |
| 304 | return source; |
Paolo Bonzini | b83b68a | 2016-03-07 11:16:39 +0100 | [diff] [blame] | 305 | } |
| 306 | #else |
| 307 | GSource *qio_channel_create_socket_watch(QIOChannel *ioc, |
| 308 | int socket, |
| 309 | GIOCondition condition) |
| 310 | { |
| 311 | return qio_channel_create_fd_watch(ioc, socket, condition); |
| 312 | } |
| 313 | #endif |
Daniel P. Berrange | 1c809fa | 2015-03-03 12:59:16 +0000 | [diff] [blame] | 314 | |
| 315 | GSource *qio_channel_create_fd_pair_watch(QIOChannel *ioc, |
| 316 | int fdread, |
| 317 | int fdwrite, |
| 318 | GIOCondition condition) |
| 319 | { |
| 320 | GSource *source; |
| 321 | QIOChannelFDPairSource *ssource; |
| 322 | |
| 323 | source = g_source_new(&qio_channel_fd_pair_source_funcs, |
| 324 | sizeof(QIOChannelFDPairSource)); |
| 325 | ssource = (QIOChannelFDPairSource *)source; |
| 326 | |
| 327 | ssource->ioc = ioc; |
| 328 | object_ref(OBJECT(ioc)); |
| 329 | |
| 330 | ssource->condition = condition; |
| 331 | |
Paolo Bonzini | e560d14 | 2016-03-07 11:13:06 +0100 | [diff] [blame] | 332 | #ifdef CONFIG_WIN32 |
| 333 | ssource->fdread.fd = (gint64)_get_osfhandle(fdread); |
| 334 | ssource->fdwrite.fd = (gint64)_get_osfhandle(fdwrite); |
| 335 | #else |
Daniel P. Berrange | 1c809fa | 2015-03-03 12:59:16 +0000 | [diff] [blame] | 336 | ssource->fdread.fd = fdread; |
Daniel P. Berrange | 1c809fa | 2015-03-03 12:59:16 +0000 | [diff] [blame] | 337 | ssource->fdwrite.fd = fdwrite; |
Paolo Bonzini | e560d14 | 2016-03-07 11:13:06 +0100 | [diff] [blame] | 338 | #endif |
| 339 | |
| 340 | ssource->fdread.events = condition & G_IO_IN; |
Daniel P. Berrange | 1c809fa | 2015-03-03 12:59:16 +0000 | [diff] [blame] | 341 | ssource->fdwrite.events = condition & G_IO_OUT; |
| 342 | |
| 343 | g_source_add_poll(source, &ssource->fdread); |
| 344 | g_source_add_poll(source, &ssource->fdwrite); |
| 345 | |
| 346 | return source; |
| 347 | } |