qemu

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
9
 * version 2.1 of the License, or (at your option) any later version.
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

21
#include "qemu/osdep.h"
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

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

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

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;
118
    QIOChannelSocketSource *ssource = (QIOChannelSocketSource *)source;
119
    fd_set rfds, wfds, xfds;
120

121
    if (!ssource->condition) {
122
        return 0;
123
    }
124

125
    FD_ZERO(&rfds);
126
    FD_ZERO(&wfds);
127
    FD_ZERO(&xfds);
128
    if (ssource->condition & G_IO_IN) {
129
        FD_SET(ssource->socket, &rfds);
130
    }
131
    if (ssource->condition & G_IO_OUT) {
132
        FD_SET(ssource->socket, &wfds);
133
    }
134
    if (ssource->condition & G_IO_PRI) {
135
        FD_SET(ssource->socket, &xfds);
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

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

264
#ifdef CONFIG_WIN32
265
    ssource->fd.fd = (gint64)_get_osfhandle(fd);
266
#else
267
    ssource->fd.fd = fd;
268
#endif
269
    ssource->fd.events = condition;
270

271
    g_source_add_poll(source, &ssource->fd);
272

273
    return source;
274
}
275

276
#ifdef CONFIG_WIN32
277
GSource *qio_channel_create_socket_watch(QIOChannel *ioc,
278
                                         int sockfd,
279
                                         GIOCondition condition)
280
{
281
    GSource *source;
282
    QIOChannelSocketSource *ssource;
283

284
    qemu_socket_select(sockfd, ioc->event,
285
                       FD_READ | FD_ACCEPT | FD_CLOSE |
286
                       FD_CONNECT | FD_WRITE | FD_OOB, NULL);
287

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;
296
    ssource->socket = _get_osfhandle(sockfd);
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;
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
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

332
#ifdef CONFIG_WIN32
333
    ssource->fdread.fd = (gint64)_get_osfhandle(fdread);
334
    ssource->fdwrite.fd = (gint64)_get_osfhandle(fdwrite);
335
#else
336
    ssource->fdread.fd = fdread;
337
    ssource->fdwrite.fd = fdwrite;
338
#endif
339

340
    ssource->fdread.events = condition & G_IO_IN;
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
}
348