4 * Copyright (c) 2015 Red Hat, Inc.
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 of the License, or (at your option) any later version.
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.
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/>.
21 #include "qemu/osdep.h"
22 #include "io/channel.h"
23 #include "qapi/error.h"
24 #include "qemu/main-loop.h"
27 bool qio_channel_has_feature(QIOChannel
*ioc
,
28 QIOChannelFeature feature
)
30 return ioc
->features
& (1 << feature
);
34 void qio_channel_set_feature(QIOChannel
*ioc
,
35 QIOChannelFeature feature
)
37 ioc
->features
|= (1 << feature
);
41 void qio_channel_set_name(QIOChannel
*ioc
,
45 ioc
->name
= g_strdup(name
);
49 ssize_t
qio_channel_readv_full(QIOChannel
*ioc
,
50 const struct iovec
*iov
,
56 QIOChannelClass
*klass
= QIO_CHANNEL_GET_CLASS(ioc
);
59 !qio_channel_has_feature(ioc
, QIO_CHANNEL_FEATURE_FD_PASS
)) {
60 error_setg_errno(errp
, EINVAL
,
61 "Channel does not support file descriptor passing");
65 return klass
->io_readv(ioc
, iov
, niov
, fds
, nfds
, errp
);
69 ssize_t
qio_channel_writev_full(QIOChannel
*ioc
,
70 const struct iovec
*iov
,
76 QIOChannelClass
*klass
= QIO_CHANNEL_GET_CLASS(ioc
);
79 !qio_channel_has_feature(ioc
, QIO_CHANNEL_FEATURE_FD_PASS
)) {
80 error_setg_errno(errp
, EINVAL
,
81 "Channel does not support file descriptor passing");
85 return klass
->io_writev(ioc
, iov
, niov
, fds
, nfds
, errp
);
90 int qio_channel_readv_all(QIOChannel
*ioc
,
91 const struct iovec
*iov
,
96 struct iovec
*local_iov
= g_new(struct iovec
, niov
);
97 struct iovec
*local_iov_head
= local_iov
;
98 unsigned int nlocal_iov
= niov
;
100 nlocal_iov
= iov_copy(local_iov
, nlocal_iov
,
102 0, iov_size(iov
, niov
));
104 while (nlocal_iov
> 0) {
106 len
= qio_channel_readv(ioc
, local_iov
, nlocal_iov
, errp
);
107 if (len
== QIO_CHANNEL_ERR_BLOCK
) {
108 qio_channel_wait(ioc
, G_IO_IN
);
110 } else if (len
< 0) {
112 } else if (len
== 0) {
114 "Unexpected end-of-file before all bytes were read");
118 iov_discard_front(&local_iov
, &nlocal_iov
, len
);
124 g_free(local_iov_head
);
128 int qio_channel_writev_all(QIOChannel
*ioc
,
129 const struct iovec
*iov
,
134 struct iovec
*local_iov
= g_new(struct iovec
, niov
);
135 struct iovec
*local_iov_head
= local_iov
;
136 unsigned int nlocal_iov
= niov
;
138 nlocal_iov
= iov_copy(local_iov
, nlocal_iov
,
140 0, iov_size(iov
, niov
));
142 while (nlocal_iov
> 0) {
144 len
= qio_channel_writev(ioc
, local_iov
, nlocal_iov
, errp
);
145 if (len
== QIO_CHANNEL_ERR_BLOCK
) {
146 qio_channel_wait(ioc
, G_IO_OUT
);
153 iov_discard_front(&local_iov
, &nlocal_iov
, len
);
158 g_free(local_iov_head
);
162 ssize_t
qio_channel_readv(QIOChannel
*ioc
,
163 const struct iovec
*iov
,
167 return qio_channel_readv_full(ioc
, iov
, niov
, NULL
, NULL
, errp
);
171 ssize_t
qio_channel_writev(QIOChannel
*ioc
,
172 const struct iovec
*iov
,
176 return qio_channel_writev_full(ioc
, iov
, niov
, NULL
, 0, errp
);
180 ssize_t
qio_channel_read(QIOChannel
*ioc
,
185 struct iovec iov
= { .iov_base
= buf
, .iov_len
= buflen
};
186 return qio_channel_readv_full(ioc
, &iov
, 1, NULL
, NULL
, errp
);
190 ssize_t
qio_channel_write(QIOChannel
*ioc
,
195 struct iovec iov
= { .iov_base
= (char *)buf
, .iov_len
= buflen
};
196 return qio_channel_writev_full(ioc
, &iov
, 1, NULL
, 0, errp
);
200 int qio_channel_read_all(QIOChannel
*ioc
,
205 struct iovec iov
= { .iov_base
= buf
, .iov_len
= buflen
};
206 return qio_channel_readv_all(ioc
, &iov
, 1, errp
);
210 int qio_channel_write_all(QIOChannel
*ioc
,
215 struct iovec iov
= { .iov_base
= (char *)buf
, .iov_len
= buflen
};
216 return qio_channel_writev_all(ioc
, &iov
, 1, errp
);
220 int qio_channel_set_blocking(QIOChannel
*ioc
,
224 QIOChannelClass
*klass
= QIO_CHANNEL_GET_CLASS(ioc
);
225 return klass
->io_set_blocking(ioc
, enabled
, errp
);
229 int qio_channel_close(QIOChannel
*ioc
,
232 QIOChannelClass
*klass
= QIO_CHANNEL_GET_CLASS(ioc
);
233 return klass
->io_close(ioc
, errp
);
237 GSource
*qio_channel_create_watch(QIOChannel
*ioc
,
238 GIOCondition condition
)
240 QIOChannelClass
*klass
= QIO_CHANNEL_GET_CLASS(ioc
);
241 GSource
*ret
= klass
->io_create_watch(ioc
, condition
);
244 g_source_set_name(ret
, ioc
->name
);
251 void qio_channel_set_aio_fd_handler(QIOChannel
*ioc
,
257 QIOChannelClass
*klass
= QIO_CHANNEL_GET_CLASS(ioc
);
259 klass
->io_set_aio_fd_handler(ioc
, ctx
, io_read
, io_write
, opaque
);
262 guint
qio_channel_add_watch(QIOChannel
*ioc
,
263 GIOCondition condition
,
266 GDestroyNotify notify
)
271 source
= qio_channel_create_watch(ioc
, condition
);
273 g_source_set_callback(source
, (GSourceFunc
)func
, user_data
, notify
);
275 id
= g_source_attach(source
, NULL
);
276 g_source_unref(source
);
282 int qio_channel_shutdown(QIOChannel
*ioc
,
283 QIOChannelShutdown how
,
286 QIOChannelClass
*klass
= QIO_CHANNEL_GET_CLASS(ioc
);
288 if (!klass
->io_shutdown
) {
289 error_setg(errp
, "Data path shutdown not supported");
293 return klass
->io_shutdown(ioc
, how
, errp
);
297 void qio_channel_set_delay(QIOChannel
*ioc
,
300 QIOChannelClass
*klass
= QIO_CHANNEL_GET_CLASS(ioc
);
302 if (klass
->io_set_delay
) {
303 klass
->io_set_delay(ioc
, enabled
);
308 void qio_channel_set_cork(QIOChannel
*ioc
,
311 QIOChannelClass
*klass
= QIO_CHANNEL_GET_CLASS(ioc
);
313 if (klass
->io_set_cork
) {
314 klass
->io_set_cork(ioc
, enabled
);
319 off_t
qio_channel_io_seek(QIOChannel
*ioc
,
324 QIOChannelClass
*klass
= QIO_CHANNEL_GET_CLASS(ioc
);
326 if (!klass
->io_seek
) {
327 error_setg(errp
, "Channel does not support random access");
331 return klass
->io_seek(ioc
, offset
, whence
, errp
);
335 static void qio_channel_set_aio_fd_handlers(QIOChannel
*ioc
);
337 static void qio_channel_restart_read(void *opaque
)
339 QIOChannel
*ioc
= opaque
;
340 Coroutine
*co
= ioc
->read_coroutine
;
342 ioc
->read_coroutine
= NULL
;
343 qio_channel_set_aio_fd_handlers(ioc
);
347 static void qio_channel_restart_write(void *opaque
)
349 QIOChannel
*ioc
= opaque
;
350 Coroutine
*co
= ioc
->write_coroutine
;
352 ioc
->write_coroutine
= NULL
;
353 qio_channel_set_aio_fd_handlers(ioc
);
357 static void qio_channel_set_aio_fd_handlers(QIOChannel
*ioc
)
359 IOHandler
*rd_handler
= NULL
, *wr_handler
= NULL
;
362 if (ioc
->read_coroutine
) {
363 rd_handler
= qio_channel_restart_read
;
365 if (ioc
->write_coroutine
) {
366 wr_handler
= qio_channel_restart_write
;
369 ctx
= ioc
->ctx
? ioc
->ctx
: iohandler_get_aio_context();
370 qio_channel_set_aio_fd_handler(ioc
, ctx
, rd_handler
, wr_handler
, ioc
);
373 void qio_channel_attach_aio_context(QIOChannel
*ioc
,
376 assert(!ioc
->read_coroutine
);
377 assert(!ioc
->write_coroutine
);
381 void qio_channel_detach_aio_context(QIOChannel
*ioc
)
383 ioc
->read_coroutine
= NULL
;
384 ioc
->write_coroutine
= NULL
;
385 qio_channel_set_aio_fd_handlers(ioc
);
389 void coroutine_fn
qio_channel_yield(QIOChannel
*ioc
,
390 GIOCondition condition
)
392 assert(qemu_in_coroutine());
393 if (condition
== G_IO_IN
) {
394 assert(!ioc
->read_coroutine
);
395 ioc
->read_coroutine
= qemu_coroutine_self();
396 } else if (condition
== G_IO_OUT
) {
397 assert(!ioc
->write_coroutine
);
398 ioc
->write_coroutine
= qemu_coroutine_self();
402 qio_channel_set_aio_fd_handlers(ioc
);
403 qemu_coroutine_yield();
407 static gboolean
qio_channel_wait_complete(QIOChannel
*ioc
,
408 GIOCondition condition
,
411 GMainLoop
*loop
= opaque
;
413 g_main_loop_quit(loop
);
418 void qio_channel_wait(QIOChannel
*ioc
,
419 GIOCondition condition
)
421 GMainContext
*ctxt
= g_main_context_new();
422 GMainLoop
*loop
= g_main_loop_new(ctxt
, TRUE
);
425 source
= qio_channel_create_watch(ioc
, condition
);
427 g_source_set_callback(source
,
428 (GSourceFunc
)qio_channel_wait_complete
,
432 g_source_attach(source
, ctxt
);
434 g_main_loop_run(loop
);
436 g_source_unref(source
);
437 g_main_loop_unref(loop
);
438 g_main_context_unref(ctxt
);
442 static void qio_channel_finalize(Object
*obj
)
444 QIOChannel
*ioc
= QIO_CHANNEL(obj
);
450 CloseHandle(ioc
->event
);
455 static const TypeInfo qio_channel_info
= {
456 .parent
= TYPE_OBJECT
,
457 .name
= TYPE_QIO_CHANNEL
,
458 .instance_size
= sizeof(QIOChannel
),
459 .instance_finalize
= qio_channel_finalize
,
461 .class_size
= sizeof(QIOChannelClass
),
465 static void qio_channel_register_types(void)
467 type_register_static(&qio_channel_info
);
471 type_init(qio_channel_register_types
);