Adding qemu as a submodule of KVMFORNFV

This Patch includes the changes to add qemu as a submodule to
kvmfornfv repo and make use of the updated latest qemu for the
execution of all testcase
Change-Id: I1280af507a857675c7f81d30c95255635667bdd7
Signed-off-by:RajithaY<rajithax.yerrumsetty@intel.com>

10 files changed, 0 insertions, 1646 deletions

diff --git a/qemu/include/io/channel-buffer.h b/qemu/include/io/channel-buffer.h
deleted file mode 100644
index 65c498b2c..000000000
--- a/qemu/include/io/channel-buffer.h
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
- * QEMU I/O channels memory buffer driver
- *
- * Copyright (c) 2015 Red Hat, Inc.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#ifndef QIO_CHANNEL_BUFFER_H__
-#define QIO_CHANNEL_BUFFER_H__
-
-#include "io/channel.h"
-
-#define TYPE_QIO_CHANNEL_BUFFER "qio-channel-buffer"
-#define QIO_CHANNEL_BUFFER(obj)                                     \
-    OBJECT_CHECK(QIOChannelBuffer, (obj), TYPE_QIO_CHANNEL_BUFFER)
-
-typedef struct QIOChannelBuffer QIOChannelBuffer;
-
-/**
- * QIOChannelBuffer:
- *
- * The QIOChannelBuffer object provides a channel implementation
- * that is able to perform I/O to/from a memory buffer.
- *
- */
-
-struct QIOChannelBuffer {
-    QIOChannel parent;
-    size_t capacity; /* Total allocated memory */
-    size_t usage;    /* Current size of data */
-    size_t offset;   /* Offset for future I/O ops */
-    uint8_t *data;
-};
-
-
-/**
- * qio_channel_buffer_new:
- * @capacity: the initial buffer capacity to allocate
- *
- * Allocate a new buffer which is initially empty
- *
- * Returns: the new channel object
- */
-QIOChannelBuffer *
-qio_channel_buffer_new(size_t capacity);
-
-#endif /* QIO_CHANNEL_BUFFER_H__ */
diff --git a/qemu/include/io/channel-command.h b/qemu/include/io/channel-command.h
deleted file mode 100644
index cfc177e78..000000000
--- a/qemu/include/io/channel-command.h
+++ /dev/null
@@ -1,91 +0,0 @@
-/*
- * QEMU I/O channels external command driver
- *
- * Copyright (c) 2015 Red Hat, Inc.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#ifndef QIO_CHANNEL_COMMAND_H__
-#define QIO_CHANNEL_COMMAND_H__
-
-#include "io/channel.h"
-
-#define TYPE_QIO_CHANNEL_COMMAND "qio-channel-command"
-#define QIO_CHANNEL_COMMAND(obj)                                     \
-    OBJECT_CHECK(QIOChannelCommand, (obj), TYPE_QIO_CHANNEL_COMMAND)
-
-typedef struct QIOChannelCommand QIOChannelCommand;
-
-
-/**
- * QIOChannelCommand:
- *
- * The QIOChannelCommand class provides a channel implementation
- * that can transport data with an externally running command
- * via its stdio streams.
- */
-
-struct QIOChannelCommand {
-    QIOChannel parent;
-    int writefd;
-    int readfd;
-    pid_t pid;
-};
-
-
-/**
- * qio_channel_command_new_pid:
- * @writefd: the FD connected to the command's stdin
- * @readfd: the FD connected to the command's stdout
- * @pid: the PID of the running child command
- * @errp: pointer to a NULL-initialized error object
- *
- * Create a channel for performing I/O with the
- * previously spawned command identified by @pid.
- * The two file descriptors provide the connection
- * to command's stdio streams, either one or which
- * may be -1 to indicate that stream is not open.
- *
- * The channel will take ownership of the process
- * @pid and will kill it when closing the channel.
- * Similarly it will take responsibility for
- * closing the file descriptors @writefd and @readfd.
- *
- * Returns: the command channel object, or NULL on error
- */
-QIOChannelCommand *
-qio_channel_command_new_pid(int writefd,
-                            int readfd,
-                            pid_t pid);
-
-/**
- * qio_channel_command_new_spawn:
- * @argv: the NULL terminated list of command arguments
- * @flags: the I/O mode, one of O_RDONLY, O_WRONLY, O_RDWR
- * @errp: pointer to a NULL-initialized error object
- *
- * Create a channel for performing I/O with the
- * command to be spawned with arguments @argv.
- *
- * Returns: the command channel object, or NULL on error
- */
-QIOChannelCommand *
-qio_channel_command_new_spawn(const char *const argv[],
-                              int flags,
-                              Error **errp);
-
-
-#endif /* QIO_CHANNEL_COMMAND_H__ */
diff --git a/qemu/include/io/channel-file.h b/qemu/include/io/channel-file.h
deleted file mode 100644
index 308e6d44d..000000000
--- a/qemu/include/io/channel-file.h
+++ /dev/null
@@ -1,93 +0,0 @@
-/*
- * QEMU I/O channels files driver
- *
- * Copyright (c) 2015 Red Hat, Inc.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#ifndef QIO_CHANNEL_FILE_H__
-#define QIO_CHANNEL_FILE_H__
-
-#include "io/channel.h"
-
-#define TYPE_QIO_CHANNEL_FILE "qio-channel-file"
-#define QIO_CHANNEL_FILE(obj)                                     \
-    OBJECT_CHECK(QIOChannelFile, (obj), TYPE_QIO_CHANNEL_FILE)
-
-typedef struct QIOChannelFile QIOChannelFile;
-
-/**
- * QIOChannelFile:
- *
- * The QIOChannelFile object provides a channel implementation
- * that is able to perform I/O on block devices, character
- * devices, FIFOs, pipes and plain files. While it is technically
- * able to work on sockets too on the UNIX platform, this is not
- * portable to Windows and lacks some extra sockets specific
- * functionality. So the QIOChannelSocket object is recommended
- * for that use case.
- *
- */
-
-struct QIOChannelFile {
-    QIOChannel parent;
-    int fd;
-};
-
-
-/**
- * qio_channel_file_new_fd:
- * @fd: the file descriptor
- *
- * Create a new IO channel object for a file represented
- * by the @fd parameter. @fd can be associated with a
- * block device, character device, fifo, pipe, or a
- * regular file. For sockets, the QIOChannelSocket class
- * should be used instead, as this provides greater
- * functionality and cross platform portability.
- *
- * The channel will own the passed in file descriptor
- * and will take responsibility for closing it, so the
- * caller must not close it. If appropriate the caller
- * should dup() its FD before opening the channel.
- *
- * Returns: the new channel object
- */
-QIOChannelFile *
-qio_channel_file_new_fd(int fd);
-
-/**
- * qio_channel_file_new_path:
- * @fd: the file descriptor
- * @flags: the open flags (O_RDONLY|O_WRONLY|O_RDWR, etc)
- * @mode: the file creation mode if O_WRONLY is set in @flags
- * @errp: pointer to initialized error object
- *
- * Create a new IO channel object for a file represented
- * by the @path parameter. @path can point to any
- * type of file on which sequential I/O can be
- * performed, whether it be a plain file, character
- * device or block device.
- *
- * Returns: the new channel object
- */
-QIOChannelFile *
-qio_channel_file_new_path(const char *path,
-                          int flags,
-                          mode_t mode,
-                          Error **errp);
-
-#endif /* QIO_CHANNEL_FILE_H__ */
diff --git a/qemu/include/io/channel-socket.h b/qemu/include/io/channel-socket.h
deleted file mode 100644
index 70d06b40d..000000000
--- a/qemu/include/io/channel-socket.h
+++ /dev/null
@@ -1,251 +0,0 @@
-/*
- * QEMU I/O channels sockets driver
- *
- * Copyright (c) 2015 Red Hat, Inc.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#ifndef QIO_CHANNEL_SOCKET_H__
-#define QIO_CHANNEL_SOCKET_H__
-
-#include "io/channel.h"
-#include "io/task.h"
-#include "qemu/sockets.h"
-
-#define TYPE_QIO_CHANNEL_SOCKET "qio-channel-socket"
-#define QIO_CHANNEL_SOCKET(obj)                                     \
-    OBJECT_CHECK(QIOChannelSocket, (obj), TYPE_QIO_CHANNEL_SOCKET)
-
-typedef struct QIOChannelSocket QIOChannelSocket;
-
-/**
- * QIOChannelSocket:
- *
- * The QIOChannelSocket class provides a channel implementation
- * that can transport data over a UNIX socket or TCP socket.
- * Beyond the core channel API, it also provides functionality
- * for accepting client connections, tuning some socket
- * parameters and getting socket address strings.
- */
-
-struct QIOChannelSocket {
-    QIOChannel parent;
-    int fd;
-    struct sockaddr_storage localAddr;
-    socklen_t localAddrLen;
-    struct sockaddr_storage remoteAddr;
-    socklen_t remoteAddrLen;
-};
-
-
-/**
- * qio_channel_socket_new:
- *
- * Create a channel for performing I/O on a socket
- * connection, that is initially closed. After
- * creating the socket, it must be setup as a client
- * connection or server.
- *
- * Returns: the socket channel object
- */
-QIOChannelSocket *
-qio_channel_socket_new(void);
-
-/**
- * qio_channel_socket_new_fd:
- * @fd: the socket file descriptor
- * @errp: pointer to a NULL-initialized error object
- *
- * Create a channel for performing I/O on the socket
- * connection represented by the file descriptor @fd.
- *
- * Returns: the socket channel object, or NULL on error
- */
-QIOChannelSocket *
-qio_channel_socket_new_fd(int fd,
-                          Error **errp);
-
-
-/**
- * qio_channel_socket_connect_sync:
- * @ioc: the socket channel object
- * @addr: the address to connect to
- * @errp: pointer to a NULL-initialized error object
- *
- * Attempt to connect to the address @addr. This method
- * will run in the foreground so the caller will not regain
- * execution control until the connection is established or
- * an error occurs.
- */
-int qio_channel_socket_connect_sync(QIOChannelSocket *ioc,
-                                    SocketAddress *addr,
-                                    Error **errp);
-
-/**
- * qio_channel_socket_connect_async:
- * @ioc: the socket channel object
- * @addr: the address to connect to
- * @callback: the function to invoke on completion
- * @opaque: user data to pass to @callback
- * @destroy: the function to free @opaque
- *
- * Attempt to connect to the address @addr. This method
- * will run in the background so the caller will regain
- * execution control immediately. The function @callback
- * will be invoked on completion or failure. The @addr
- * parameter will be copied, so may be freed as soon
- * as this function returns without waiting for completion.
- */
-void qio_channel_socket_connect_async(QIOChannelSocket *ioc,
-                                      SocketAddress *addr,
-                                      QIOTaskFunc callback,
-                                      gpointer opaque,
-                                      GDestroyNotify destroy);
-
-
-/**
- * qio_channel_socket_listen_sync:
- * @ioc: the socket channel object
- * @addr: the address to listen to
- * @errp: pointer to a NULL-initialized error object
- *
- * Attempt to listen to the address @addr. This method
- * will run in the foreground so the caller will not regain
- * execution control until the connection is established or
- * an error occurs.
- */
-int qio_channel_socket_listen_sync(QIOChannelSocket *ioc,
-                                   SocketAddress *addr,
-                                   Error **errp);
-
-/**
- * qio_channel_socket_listen_async:
- * @ioc: the socket channel object
- * @addr: the address to listen to
- * @callback: the function to invoke on completion
- * @opaque: user data to pass to @callback
- * @destroy: the function to free @opaque
- *
- * Attempt to listen to the address @addr. This method
- * will run in the background so the caller will regain
- * execution control immediately. The function @callback
- * will be invoked on completion or failure. The @addr
- * parameter will be copied, so may be freed as soon
- * as this function returns without waiting for completion.
- */
-void qio_channel_socket_listen_async(QIOChannelSocket *ioc,
-                                     SocketAddress *addr,
-                                     QIOTaskFunc callback,
-                                     gpointer opaque,
-                                     GDestroyNotify destroy);
-
-
-/**
- * qio_channel_socket_dgram_sync:
- * @ioc: the socket channel object
- * @localAddr: the address to local bind address
- * @remoteAddr: the address to remote peer address
- * @errp: pointer to a NULL-initialized error object
- *
- * Attempt to initialize a datagram socket bound to
- * @localAddr and communicating with peer @remoteAddr.
- * This method will run in the foreground so the caller
- * will not regain execution control until the socket
- * is established or an error occurs.
- */
-int qio_channel_socket_dgram_sync(QIOChannelSocket *ioc,
-                                  SocketAddress *localAddr,
-                                  SocketAddress *remoteAddr,
-                                  Error **errp);
-
-/**
- * qio_channel_socket_dgram_async:
- * @ioc: the socket channel object
- * @localAddr: the address to local bind address
- * @remoteAddr: the address to remote peer address
- * @callback: the function to invoke on completion
- * @opaque: user data to pass to @callback
- * @destroy: the function to free @opaque
- *
- * Attempt to initialize a datagram socket bound to
- * @localAddr and communicating with peer @remoteAddr.
- * This method will run in the background so the caller
- * will regain execution control immediately. The function
- * @callback will be invoked on completion or failure.
- * The @localAddr and @remoteAddr parameters will be copied,
- * so may be freed as soon as this function returns without
- * waiting for completion.
- */
-void qio_channel_socket_dgram_async(QIOChannelSocket *ioc,
-                                    SocketAddress *localAddr,
-                                    SocketAddress *remoteAddr,
-                                    QIOTaskFunc callback,
-                                    gpointer opaque,
-                                    GDestroyNotify destroy);
-
-
-/**
- * qio_channel_socket_get_local_address:
- * @ioc: the socket channel object
- * @errp: pointer to a NULL-initialized error object
- *
- * Get the string representation of the local socket
- * address. A pointer to the allocated address information
- * struct will be returned, which the caller is required to
- * release with a call qapi_free_SocketAddress when no
- * longer required.
- *
- * Returns: 0 on success, -1 on error
- */
-SocketAddress *
-qio_channel_socket_get_local_address(QIOChannelSocket *ioc,
-                                     Error **errp);
-
-/**
- * qio_channel_socket_get_remote_address:
- * @ioc: the socket channel object
- * @errp: pointer to a NULL-initialized error object
- *
- * Get the string representation of the local socket
- * address. A pointer to the allocated address information
- * struct will be returned, which the caller is required to
- * release with a call qapi_free_SocketAddress when no
- * longer required.
- *
- * Returns: the socket address struct, or NULL on error
- */
-SocketAddress *
-qio_channel_socket_get_remote_address(QIOChannelSocket *ioc,
-                                      Error **errp);
-
-
-/**
- * qio_channel_socket_accept:
- * @ioc: the socket channel object
- * @errp: pointer to a NULL-initialized error object
- *
- * If the socket represents a server, then this accepts
- * a new client connection. The returned channel will
- * represent the connected client socket.
- *
- * Returns: the new client channel, or NULL on error
- */
-QIOChannelSocket *
-qio_channel_socket_accept(QIOChannelSocket *ioc,
-                          Error **errp);
-
-
-#endif /* QIO_CHANNEL_SOCKET_H__ */
diff --git a/qemu/include/io/channel-tls.h b/qemu/include/io/channel-tls.h
deleted file mode 100644
index 322eccbaa..000000000
--- a/qemu/include/io/channel-tls.h
+++ /dev/null
@@ -1,142 +0,0 @@
-/*
- * QEMU I/O channels TLS driver
- *
- * Copyright (c) 2015 Red Hat, Inc.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#ifndef QIO_CHANNEL_TLS_H__
-#define QIO_CHANNEL_TLS_H__
-
-#include "io/channel.h"
-#include "io/task.h"
-#include "crypto/tlssession.h"
-
-#define TYPE_QIO_CHANNEL_TLS "qio-channel-tls"
-#define QIO_CHANNEL_TLS(obj)                                     \
-    OBJECT_CHECK(QIOChannelTLS, (obj), TYPE_QIO_CHANNEL_TLS)
-
-typedef struct QIOChannelTLS QIOChannelTLS;
-
-/**
- * QIOChannelTLS
- *
- * The QIOChannelTLS class provides a channel wrapper which
- * can transparently run the TLS encryption protocol. It is
- * usually used over a TCP socket, but there is actually no
- * technical restriction on which type of master channel is
- * used as the transport.
- *
- * This channel object is capable of running as either a
- * TLS server or TLS client.
- */
-
-struct QIOChannelTLS {
-    QIOChannel parent;
-    QIOChannel *master;
-    QCryptoTLSSession *session;
-};
-
-/**
- * qio_channel_tls_new_server:
- * @master: the underlying channel object
- * @creds: the credentials to use for TLS handshake
- * @aclname: the access control list for validating clients
- * @errp: pointer to a NULL-initialized error object
- *
- * Create a new TLS channel that runs the server side of
- * a TLS session. The TLS session handshake will use the
- * credentials provided in @creds. If the @aclname parameter
- * is non-NULL, then the client will have to provide
- * credentials (ie a x509 client certificate) which will
- * then be validated against the ACL.
- *
- * After creating the channel, it is mandatory to call
- * the qio_channel_tls_handshake() method before attempting
- * todo any I/O on the channel.
- *
- * Once the handshake has completed, all I/O should be done
- * via the new TLS channel object and not the original
- * master channel
- *
- * Returns: the new TLS channel object, or NULL
- */
-QIOChannelTLS *
-qio_channel_tls_new_server(QIOChannel *master,
-                           QCryptoTLSCreds *creds,
-                           const char *aclname,
-                           Error **errp);
-
-/**
- * qio_channel_tls_new_client:
- * @master: the underlying channel object
- * @creds: the credentials to use for TLS handshake
- * @hostname: the user specified server hostname
- * @errp: pointer to a NULL-initialized error object
- *
- * Create a new TLS channel that runs the client side of
- * a TLS session. The TLS session handshake will use the
- * credentials provided in @creds. The @hostname parameter
- * should provide the user specified hostname of the server
- * and will be validated against the server's credentials
- * (ie CommonName of the x509 certificate)
- *
- * After creating the channel, it is mandatory to call
- * the qio_channel_tls_handshake() method before attempting
- * todo any I/O on the channel.
- *
- * Once the handshake has completed, all I/O should be done
- * via the new TLS channel object and not the original
- * master channel
- *
- * Returns: the new TLS channel object, or NULL
- */
-QIOChannelTLS *
-qio_channel_tls_new_client(QIOChannel *master,
-                           QCryptoTLSCreds *creds,
-                           const char *hostname,
-                           Error **errp);
-
-/**
- * qio_channel_tls_handshake:
- * @ioc: the TLS channel object
- * @func: the callback to invoke when completed
- * @opaque: opaque data to pass to @func
- * @destroy: optional callback to free @opaque
- *
- * Perform the TLS session handshake. This method
- * will return immediately and the handshake will
- * continue in the background, provided the main
- * loop is running. When the handshake is complete,
- * or fails, the @func callback will be invoked.
- */
-void qio_channel_tls_handshake(QIOChannelTLS *ioc,
-                               QIOTaskFunc func,
-                               gpointer opaque,
-                               GDestroyNotify destroy);
-
-/**
- * qio_channel_tls_get_session:
- * @ioc: the TLS channel object
- *
- * Get the TLS session used by the channel.
- *
- * Returns: the TLS session
- */
-QCryptoTLSSession *
-qio_channel_tls_get_session(QIOChannelTLS *ioc);
-
-#endif /* QIO_CHANNEL_TLS_H__ */
diff --git a/qemu/include/io/channel-util.h b/qemu/include/io/channel-util.h
deleted file mode 100644
index c93af8288..000000000
--- a/qemu/include/io/channel-util.h
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
- * QEMU I/O channels utility APIs
- *
- * Copyright (c) 2016 Red Hat, Inc.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#ifndef QIO_CHANNEL_UTIL_H__
-#define QIO_CHANNEL_UTIL_H__
-
-#include "io/channel.h"
-
-/*
- * This module provides helper functions that are useful when dealing
- * with QIOChannel objects
- */
-
-
-/**
- * qio_channel_new_fd:
- * @fd: the file descriptor
- * @errp: pointer to a NULL-initialized error object
- *
- * Create a channel for performing I/O on the file
- * descriptor @fd. The particular subclass of QIOChannel
- * that is returned will depend on what underlying object
- * the file descriptor is associated with. It may be either
- * a QIOChannelSocket or a QIOChannelFile instance. Upon
- * success, the returned QIOChannel instance will own
- * the @fd file descriptor, and take responsibility for
- * closing it when no longer required. On failure, the
- * caller is responsible for closing @fd.
- *
- * Returns: the channel object, or NULL on error
- */
-QIOChannel *qio_channel_new_fd(int fd,
-                               Error **errp);
-
-#endif /* QIO_CHANNEL_UTIL_H__ */
diff --git a/qemu/include/io/channel-watch.h b/qemu/include/io/channel-watch.h
deleted file mode 100644
index 76d764223..000000000
--- a/qemu/include/io/channel-watch.h
+++ /dev/null
@@ -1,90 +0,0 @@
-/*
- * QEMU I/O channels watch helper APIs
- *
- * Copyright (c) 2015 Red Hat, Inc.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#ifndef QIO_CHANNEL_WATCH_H__
-#define QIO_CHANNEL_WATCH_H__
-
-#include "io/channel.h"
-
-/*
- * This module provides helper functions that will be needed by
- * the various QIOChannel implementations, for creating watches
- * on file descriptors / sockets
- */
-
-/**
- * qio_channel_create_fd_watch:
- * @ioc: the channel object
- * @fd: the file descriptor
- * @condition: the I/O condition
- *
- * Create a new main loop source that is able to
- * monitor the file descriptor @fd for the
- * I/O conditions in @condition. This is able
- * monitor block devices, character devices,
- * pipes but not plain files or, on Win32, sockets.
- *
- * Returns: the new main loop source
- */
-GSource *qio_channel_create_fd_watch(QIOChannel *ioc,
-                                     int fd,
-                                     GIOCondition condition);
-
-/**
- * qio_channel_create_socket_watch:
- * @ioc: the channel object
- * @fd: the file descriptor
- * @condition: the I/O condition
- *
- * Create a new main loop source that is able to
- * monitor the file descriptor @fd for the
- * I/O conditions in @condition. This is equivalent
- * to qio_channel_create_fd_watch on POSIX systems
- * but not on Windows.
- *
- * Returns: the new main loop source
- */
-GSource *qio_channel_create_socket_watch(QIOChannel *ioc,
-                                         int fd,
-                                         GIOCondition condition);
-
-/**
- * qio_channel_create_fd_pair_watch:
- * @ioc: the channel object
- * @fdread: the file descriptor for reading
- * @fdwrite: the file descriptor for writing
- * @condition: the I/O condition
- *
- * Create a new main loop source that is able to
- * monitor the pair of file descriptors @fdread
- * and @fdwrite for the I/O conditions in @condition.
- * This is intended for monitoring unidirectional
- * file descriptors such as pipes, where a pair
- * of descriptors is required for bidirectional
- * I/O
- *
- * Returns: the new main loop source
- */
-GSource *qio_channel_create_fd_pair_watch(QIOChannel *ioc,
-                                          int fdread,
-                                          int fdwrite,
-                                          GIOCondition condition);
-
-#endif /* QIO_CHANNEL_WATCH_H__ */
diff --git a/qemu/include/io/channel-websock.h b/qemu/include/io/channel-websock.h
deleted file mode 100644
index 0dc21cc56..000000000
--- a/qemu/include/io/channel-websock.h
+++ /dev/null
@@ -1,108 +0,0 @@
-/*
- * QEMU I/O channels driver websockets
- *
- * Copyright (c) 2015 Red Hat, Inc.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#ifndef QIO_CHANNEL_WEBSOCK_H__
-#define QIO_CHANNEL_WEBSOCK_H__
-
-#include "io/channel.h"
-#include "qemu/buffer.h"
-#include "io/task.h"
-
-#define TYPE_QIO_CHANNEL_WEBSOCK "qio-channel-websock"
-#define QIO_CHANNEL_WEBSOCK(obj)                                     \
-    OBJECT_CHECK(QIOChannelWebsock, (obj), TYPE_QIO_CHANNEL_WEBSOCK)
-
-typedef struct QIOChannelWebsock QIOChannelWebsock;
-typedef union QIOChannelWebsockMask QIOChannelWebsockMask;
-
-union QIOChannelWebsockMask {
-    char c[4];
-    uint32_t u;
-};
-
-/**
- * QIOChannelWebsock
- *
- * The QIOChannelWebsock class provides a channel wrapper which
- * can transparently run the HTTP websockets protocol. This is
- * usually used over a TCP socket, but there is actually no
- * technical restriction on which type of master channel is
- * used as the transport.
- *
- * This channel object is currently only capable of running as
- * a websocket server and is a pretty crude implementation
- * of it, not supporting the full websockets protocol feature
- * set. It is sufficient to use with a simple websockets
- * client for encapsulating VNC for noVNC in-browser client.
- */
-
-struct QIOChannelWebsock {
-    QIOChannel parent;
-    QIOChannel *master;
-    Buffer encinput;
-    Buffer encoutput;
-    Buffer rawinput;
-    Buffer rawoutput;
-    size_t payload_remain;
-    QIOChannelWebsockMask mask;
-    guint io_tag;
-    Error *io_err;
-    gboolean io_eof;
-};
-
-/**
- * qio_channel_websock_new_server:
- * @master: the underlying channel object
- *
- * Create a new websockets channel that runs the server
- * side of the protocol.
- *
- * After creating the channel, it is mandatory to call
- * the qio_channel_websock_handshake() method before attempting
- * todo any I/O on the channel.
- *
- * Once the handshake has completed, all I/O should be done
- * via the new websocket channel object and not the original
- * master channel
- *
- * Returns: the new websockets channel object
- */
-QIOChannelWebsock *
-qio_channel_websock_new_server(QIOChannel *master);
-
-/**
- * qio_channel_websock_handshake:
- * @ioc: the websocket channel object
- * @func: the callback to invoke when completed
- * @opaque: opaque data to pass to @func
- * @destroy: optional callback to free @opaque
- *
- * Perform the websocket handshake. This method
- * will return immediately and the handshake will
- * continue in the background, provided the main
- * loop is running. When the handshake is complete,
- * or fails, the @func callback will be invoked.
- */
-void qio_channel_websock_handshake(QIOChannelWebsock *ioc,
-                                   QIOTaskFunc func,
-                                   gpointer opaque,
-                                   GDestroyNotify destroy);
-
-#endif /* QIO_CHANNEL_WEBSOCK_H__ */
diff --git a/qemu/include/io/channel.h b/qemu/include/io/channel.h
deleted file mode 100644
index d37acd29e..000000000
--- a/qemu/include/io/channel.h
+++ /dev/null
@@ -1,504 +0,0 @@
-/*
- * QEMU I/O channels
- *
- * Copyright (c) 2015 Red Hat, Inc.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#ifndef QIO_CHANNEL_H__
-#define QIO_CHANNEL_H__
-
-#include "qemu-common.h"
-#include "qom/object.h"
-
-#define TYPE_QIO_CHANNEL "qio-channel"
-#define QIO_CHANNEL(obj)                                    \
-    OBJECT_CHECK(QIOChannel, (obj), TYPE_QIO_CHANNEL)
-#define QIO_CHANNEL_CLASS(klass)                                    \
-    OBJECT_CLASS_CHECK(QIOChannelClass, klass, TYPE_QIO_CHANNEL)
-#define QIO_CHANNEL_GET_CLASS(obj)                                  \
-    OBJECT_GET_CLASS(QIOChannelClass, obj, TYPE_QIO_CHANNEL)
-
-typedef struct QIOChannel QIOChannel;
-typedef struct QIOChannelClass QIOChannelClass;
-
-#define QIO_CHANNEL_ERR_BLOCK -2
-
-typedef enum QIOChannelFeature QIOChannelFeature;
-
-enum QIOChannelFeature {
-    QIO_CHANNEL_FEATURE_FD_PASS  = (1 << 0),
-    QIO_CHANNEL_FEATURE_SHUTDOWN = (1 << 1),
-};
-
-
-typedef enum QIOChannelShutdown QIOChannelShutdown;
-
-enum QIOChannelShutdown {
-    QIO_CHANNEL_SHUTDOWN_BOTH,
-    QIO_CHANNEL_SHUTDOWN_READ,
-    QIO_CHANNEL_SHUTDOWN_WRITE,
-};
-
-typedef gboolean (*QIOChannelFunc)(QIOChannel *ioc,
-                                   GIOCondition condition,
-                                   gpointer data);
-
-/**
- * QIOChannel:
- *
- * The QIOChannel defines the core API for a generic I/O channel
- * class hierarchy. It is inspired by GIOChannel, but has the
- * following differences
- *
- *  - Use QOM to properly support arbitrary subclassing
- *  - Support use of iovecs for efficient I/O with multiple blocks
- *  - None of the character set translation, binary data exclusively
- *  - Direct support for QEMU Error object reporting
- *  - File descriptor passing
- *
- * This base class is abstract so cannot be instantiated. There
- * will be subclasses for dealing with sockets, files, and higher
- * level protocols such as TLS, WebSocket, etc.
- */
-
-struct QIOChannel {
-    Object parent;
-    unsigned int features; /* bitmask of QIOChannelFeatures */
-#ifdef _WIN32
-    HANDLE event; /* For use with GSource on Win32 */
-#endif
-};
-
-/**
- * QIOChannelClass:
- *
- * This class defines the contract that all subclasses
- * must follow to provide specific channel implementations.
- * The first five callbacks are mandatory to support, others
- * provide additional optional features.
- *
- * Consult the corresponding public API docs for a description
- * of the semantics of each callback
- */
-struct QIOChannelClass {
-    ObjectClass parent;
-
-    /* Mandatory callbacks */
-    ssize_t (*io_writev)(QIOChannel *ioc,
-                         const struct iovec *iov,
-                         size_t niov,
-                         int *fds,
-                         size_t nfds,
-                         Error **errp);
-    ssize_t (*io_readv)(QIOChannel *ioc,
-                        const struct iovec *iov,
-                        size_t niov,
-                        int **fds,
-                        size_t *nfds,
-                        Error **errp);
-    int (*io_close)(QIOChannel *ioc,
-                    Error **errp);
-    GSource * (*io_create_watch)(QIOChannel *ioc,
-                                 GIOCondition condition);
-    int (*io_set_blocking)(QIOChannel *ioc,
-                           bool enabled,
-                           Error **errp);
-
-    /* Optional callbacks */
-    int (*io_shutdown)(QIOChannel *ioc,
-                       QIOChannelShutdown how,
-                       Error **errp);
-    void (*io_set_cork)(QIOChannel *ioc,
-                        bool enabled);
-    void (*io_set_delay)(QIOChannel *ioc,
-                         bool enabled);
-    off_t (*io_seek)(QIOChannel *ioc,
-                     off_t offset,
-                     int whence,
-                     Error **errp);
-};
-
-/* General I/O handling functions */
-
-/**
- * qio_channel_has_feature:
- * @ioc: the channel object
- * @feature: the feature to check support of
- *
- * Determine whether the channel implementation supports
- * the optional feature named in @feature.
- *
- * Returns: true if supported, false otherwise.
- */
-bool qio_channel_has_feature(QIOChannel *ioc,
-                             QIOChannelFeature feature);
-
-/**
- * qio_channel_readv_full:
- * @ioc: the channel object
- * @iov: the array of memory regions to read data into
- * @niov: the length of the @iov array
- * @fds: pointer to an array that will received file handles
- * @nfds: pointer filled with number of elements in @fds on return
- * @errp: pointer to a NULL-initialized error object
- *
- * Read data from the IO channel, storing it in the
- * memory regions referenced by @iov. Each element
- * in the @iov will be fully populated with data
- * before the next one is used. The @niov parameter
- * specifies the total number of elements in @iov.
- *
- * It is not required for all @iov to be filled with
- * data. If the channel is in blocking mode, at least
- * one byte of data will be read, but no more is
- * guaranteed. If the channel is non-blocking and no
- * data is available, it will return QIO_CHANNEL_ERR_BLOCK
- *
- * If the channel has passed any file descriptors,
- * the @fds array pointer will be allocated and
- * the elements filled with the received file
- * descriptors. The @nfds pointer will be updated
- * to indicate the size of the @fds array that
- * was allocated. It is the callers responsibility
- * to call close() on each file descriptor and to
- * call g_free() on the array pointer in @fds.
- *
- * It is an error to pass a non-NULL @fds parameter
- * unless qio_channel_has_feature() returns a true
- * value for the QIO_CHANNEL_FEATURE_FD_PASS constant.
- *
- * Returns: the number of bytes read, or -1 on error,
- * or QIO_CHANNEL_ERR_BLOCK if no data is available
- * and the channel is non-blocking
- */
-ssize_t qio_channel_readv_full(QIOChannel *ioc,
-                               const struct iovec *iov,
-                               size_t niov,
-                               int **fds,
-                               size_t *nfds,
-                               Error **errp);
-
-
-/**
- * qio_channel_writev_full:
- * @ioc: the channel object
- * @iov: the array of memory regions to write data from
- * @niov: the length of the @iov array
- * @fds: an array of file handles to send
- * @nfds: number of file handles in @fds
- * @errp: pointer to a NULL-initialized error object
- *
- * Write data to the IO channel, reading it from the
- * memory regions referenced by @iov. Each element
- * in the @iov will be fully sent, before the next
- * one is used. The @niov parameter specifies the
- * total number of elements in @iov.
- *
- * It is not required for all @iov data to be fully
- * sent. If the channel is in blocking mode, at least
- * one byte of data will be sent, but no more is
- * guaranteed. If the channel is non-blocking and no
- * data can be sent, it will return QIO_CHANNEL_ERR_BLOCK
- *
- * If there are file descriptors to send, the @fds
- * array should be non-NULL and provide the handles.
- * All file descriptors will be sent if at least one
- * byte of data was sent.
- *
- * It is an error to pass a non-NULL @fds parameter
- * unless qio_channel_has_feature() returns a true
- * value for the QIO_CHANNEL_FEATURE_FD_PASS constant.
- *
- * Returns: the number of bytes sent, or -1 on error,
- * or QIO_CHANNEL_ERR_BLOCK if no data is can be sent
- * and the channel is non-blocking
- */
-ssize_t qio_channel_writev_full(QIOChannel *ioc,
-                                const struct iovec *iov,
-                                size_t niov,
-                                int *fds,
-                                size_t nfds,
-                                Error **errp);
-
-/**
- * qio_channel_readv:
- * @ioc: the channel object
- * @iov: the array of memory regions to read data into
- * @niov: the length of the @iov array
- * @errp: pointer to a NULL-initialized error object
- *
- * Behaves as qio_channel_readv_full() but does not support
- * receiving of file handles.
- */
-ssize_t qio_channel_readv(QIOChannel *ioc,
-                          const struct iovec *iov,
-                          size_t niov,
-                          Error **errp);
-
-/**
- * qio_channel_writev:
- * @ioc: the channel object
- * @iov: the array of memory regions to write data from
- * @niov: the length of the @iov array
- * @errp: pointer to a NULL-initialized error object
- *
- * Behaves as qio_channel_writev_full() but does not support
- * sending of file handles.
- */
-ssize_t qio_channel_writev(QIOChannel *ioc,
-                           const struct iovec *iov,
-                           size_t niov,
-                           Error **errp);
-
-/**
- * qio_channel_readv:
- * @ioc: the channel object
- * @buf: the memory region to read data into
- * @buflen: the length of @buf
- * @errp: pointer to a NULL-initialized error object
- *
- * Behaves as qio_channel_readv_full() but does not support
- * receiving of file handles, and only supports reading into
- * a single memory region.
- */
-ssize_t qio_channel_read(QIOChannel *ioc,
-                         char *buf,
-                         size_t buflen,
-                         Error **errp);
-
-/**
- * qio_channel_writev:
- * @ioc: the channel object
- * @buf: the memory regions to send data from
- * @buflen: the length of @buf
- * @errp: pointer to a NULL-initialized error object
- *
- * Behaves as qio_channel_writev_full() but does not support
- * sending of file handles, and only supports writing from a
- * single memory region.
- */
-ssize_t qio_channel_write(QIOChannel *ioc,
-                          const char *buf,
-                          size_t buflen,
-                          Error **errp);
-
-/**
- * qio_channel_set_blocking:
- * @ioc: the channel object
- * @enabled: the blocking flag state
- * @errp: pointer to a NULL-initialized error object
- *
- * If @enabled is true, then the channel is put into
- * blocking mode, otherwise it will be non-blocking.
- *
- * In non-blocking mode, read/write operations may
- * return QIO_CHANNEL_ERR_BLOCK if they would otherwise
- * block on I/O
- */
-int qio_channel_set_blocking(QIOChannel *ioc,
-                             bool enabled,
-                             Error **errp);
-
-/**
- * qio_channel_close:
- * @ioc: the channel object
- * @errp: pointer to a NULL-initialized error object
- *
- * Close the channel, flushing any pending I/O
- *
- * Returns: 0 on success, -1 on error
- */
-int qio_channel_close(QIOChannel *ioc,
-                      Error **errp);
-
-/**
- * qio_channel_shutdown:
- * @ioc: the channel object
- * @how: the direction to shutdown
- * @errp: pointer to a NULL-initialized error object
- *
- * Shutdowns transmission and/or receiving of data
- * without closing the underlying transport.
- *
- * Not all implementations will support this facility,
- * so may report an error. To avoid errors, the
- * caller may check for the feature flag
- * QIO_CHANNEL_FEATURE_SHUTDOWN prior to calling
- * this method.
- *
- * Returns: 0 on success, -1 on error
- */
-int qio_channel_shutdown(QIOChannel *ioc,
-                         QIOChannelShutdown how,
-                         Error **errp);
-
-/**
- * qio_channel_set_delay:
- * @ioc: the channel object
- * @enabled: the new flag state
- *
- * Controls whether the underlying transport is
- * permitted to delay writes in order to merge
- * small packets. If @enabled is true, then the
- * writes may be delayed in order to opportunistically
- * merge small packets into larger ones. If @enabled
- * is false, writes are dispatched immediately with
- * no delay.
- *
- * When @enabled is false, applications may wish to
- * use the qio_channel_set_cork() method to explicitly
- * control write merging.
- *
- * On channels which are backed by a socket, this
- * API corresponds to the inverse of TCP_NODELAY flag,
- * controlling whether the Nagle algorithm is active.
- *
- * This setting is merely a hint, so implementations are
- * free to ignore this without it being considered an
- * error.
- */
-void qio_channel_set_delay(QIOChannel *ioc,
-                           bool enabled);
-
-/**
- * qio_channel_set_cork:
- * @ioc: the channel object
- * @enabled: the new flag state
- *
- * Controls whether the underlying transport is
- * permitted to dispatch data that is written.
- * If @enabled is true, then any data written will
- * be queued in local buffers until @enabled is
- * set to false once again.
- *
- * This feature is typically used when the automatic
- * write coalescing facility is disabled via the
- * qio_channel_set_delay() method.
- *
- * On channels which are backed by a socket, this
- * API corresponds to the TCP_CORK flag.
- *
- * This setting is merely a hint, so implementations are
- * free to ignore this without it being considered an
- * error.
- */
-void qio_channel_set_cork(QIOChannel *ioc,
-                          bool enabled);
-
-
-/**
- * qio_channel_seek:
- * @ioc: the channel object
- * @offset: the position to seek to, relative to @whence
- * @whence: one of the (POSIX) SEEK_* constants listed below
- * @errp: pointer to a NULL-initialized error object
- *
- * Moves the current I/O position within the channel
- * @ioc, to be @offset. The value of @offset is
- * interpreted relative to @whence:
- *
- * SEEK_SET - the position is set to @offset bytes
- * SEEK_CUR - the position is moved by @offset bytes
- * SEEK_END - the position is set to end of the file plus @offset bytes
- *
- * Not all implementations will support this facility,
- * so may report an error.
- *
- * Returns: the new position on success, (off_t)-1 on failure
- */
-off_t qio_channel_io_seek(QIOChannel *ioc,
-                          off_t offset,
-                          int whence,
-                          Error **errp);
-
-
-/**
- * qio_channel_create_watch:
- * @ioc: the channel object
- * @condition: the I/O condition to monitor
- *
- * Create a new main loop source that is used to watch
- * for the I/O condition @condition. Typically the
- * qio_channel_add_watch() method would be used instead
- * of this, since it directly attaches a callback to
- * the source
- *
- * Returns: the new main loop source.
- */
-GSource *qio_channel_create_watch(QIOChannel *ioc,
-                                  GIOCondition condition);
-
-/**
- * qio_channel_add_watch:
- * @ioc: the channel object
- * @condition: the I/O condition to monitor
- * @func: callback to invoke when the source becomes ready
- * @user_data: opaque data to pass to @func
- * @notify: callback to free @user_data
- *
- * Create a new main loop source that is used to watch
- * for the I/O condition @condition. The callback @func
- * will be registered against the source, to be invoked
- * when the source becomes ready. The optional @user_data
- * will be passed to @func when it is invoked. The @notify
- * callback will be used to free @user_data when the
- * watch is deleted
- *
- * The returned source ID can be used with g_source_remove()
- * to remove and free the source when no longer required.
- * Alternatively the @func callback can return a FALSE
- * value.
- *
- * Returns: the source ID
- */
-guint qio_channel_add_watch(QIOChannel *ioc,
-                            GIOCondition condition,
-                            QIOChannelFunc func,
-                            gpointer user_data,
-                            GDestroyNotify notify);
-
-
-/**
- * qio_channel_yield:
- * @ioc: the channel object
- * @condition: the I/O condition to wait for
- *
- * Yields execution from the current coroutine until
- * the condition indicated by @condition becomes
- * available.
- *
- * This must only be called from coroutine context
- */
-void qio_channel_yield(QIOChannel *ioc,
-                       GIOCondition condition);
-
-/**
- * qio_channel_wait:
- * @ioc: the channel object
- * @condition: the I/O condition to wait for
- *
- * Block execution from the current thread until
- * the condition indicated by @condition becomes
- * available.
- *
- * This will enter a nested event loop to perform
- * the wait.
- */
-void qio_channel_wait(QIOChannel *ioc,
-                      GIOCondition condition);
-
-#endif /* QIO_CHANNEL_H__ */
diff --git a/qemu/include/io/task.h b/qemu/include/io/task.h
deleted file mode 100644
index 2e69d8a47..000000000
--- a/qemu/include/io/task.h
+++ /dev/null
@@ -1,255 +0,0 @@
-/*
- * QEMU I/O task
- *
- * Copyright (c) 2015 Red Hat, Inc.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#ifndef QIO_TASK_H__
-#define QIO_TASK_H__
-
-#include "qemu-common.h"
-#include "qom/object.h"
-
-typedef struct QIOTask QIOTask;
-
-typedef void (*QIOTaskFunc)(Object *source,
-                            Error *err,
-                            gpointer opaque);
-
-typedef int (*QIOTaskWorker)(QIOTask *task,
-                             Error **errp,
-                             gpointer opaque);
-
-/**
- * QIOTask:
- *
- * The QIOTask object provides a simple mechanism for reporting
- * success / failure of long running background operations.
- *
- * A object on which the operation is to be performed could have
- * a public API which accepts a task callback:
- *
- * <example>
- *   <title>Task callback function signature</title>
- *   <programlisting>
- *  void myobject_operation(QMyObject *obj,
- *                          QIOTaskFunc *func,
- *                          gpointer opaque,
- *                          GDestroyNotify *notify);
- *   </programlisting>
- * </example>
- *
- * The 'func' parameter is the callback to be invoked, and 'opaque'
- * is data to pass to it. The optional 'notify' function is used
- * to free 'opaque' when no longer needed.
- *
- * Now, lets say the implementation of this method wants to set
- * a timer to run once a second checking for completion of some
- * activity. It would do something like
- *
- * <example>
- *   <title>Task callback function implementation</title>
- *   <programlisting>
- *    void myobject_operation(QMyObject *obj,
- *                            QIOTaskFunc *func,
- *                            gpointer opaque,
- *                            GDestroyNotify *notify)
- *    {
- *      QIOTask *task;
- *
- *      task = qio_task_new(OBJECT(obj), func, opaque, notify);
- *
- *      g_timeout_add_full(G_PRIORITY_DEFAULT,
- *                         1000,
- *                         myobject_operation_timer,
- *                         task,
- *                         NULL);
- *    }
- *   </programlisting>
- * </example>
- *
- * It could equally have setup a watch on a file descriptor or
- * created a background thread, or something else entirely.
- * Notice that the source object is passed to the task, and
- * QIOTask will hold a reference on that. This ensure that
- * the QMyObject instance cannot be garbage collected while
- * the async task is still in progress.
- *
- * In this case, myobject_operation_timer will fire after
- * 3 secs and do
- *
- * <example>
- *   <title>Task timer function</title>
- *   <programlisting>
- *   gboolean myobject_operation_timer(gpointer opaque)
- *   {
- *      QIOTask *task = QIO_TASK(opaque);
- *      Error *err;*
- *
- *      ...check something important...
- *       if (err) {
- *           qio_task_abort(task, err);
- *           error_free(task);
- *           return FALSE;
- *       } else if (...work is completed ...) {
- *           qio_task_complete(task);
- *           return FALSE;
- *       }
- *       ...carry on polling ...
- *       return TRUE;
- *   }
- *   </programlisting>
- * </example>
- *
- * Once this function returns false, object_unref will be called
- * automatically on the task causing it to be released and the
- * ref on QMyObject dropped too.
- *
- * The QIOTask module can also be used to perform operations
- * in a background thread context, while still reporting the
- * results in the main event thread. This allows code which
- * cannot easily be rewritten to be asychronous (such as DNS
- * lookups) to be easily run non-blocking. Reporting the
- * results in the main thread context means that the caller
- * typically does not need to be concerned about thread
- * safety wrt the QEMU global mutex.
- *
- * For example, the socket_listen() method will block the caller
- * while DNS lookups take place if given a name, instead of IP
- * address. The C library often do not provide a practical async
- * DNS API, so the to get non-blocking DNS lookups in a portable
- * manner requires use of a thread. So achieve a non-blocking
- * socket listen using QIOTask would require:
- *
- * <example>
- *    static int myobject_listen_worker(QIOTask *task,
- *                                      Error **errp,
- *                                      gpointer opaque)
- *    {
- *       QMyObject obj = QMY_OBJECT(qio_task_get_source(task));
- *       SocketAddress *addr = opaque;
- *
- *       obj->fd = socket_listen(addr, errp);
- *       if (obj->fd < 0) {
- *          return -1;
- *       }
- *       return 0;
- *    }
- *
- *    void myobject_listen_async(QMyObject *obj,
- *                               SocketAddress *addr,
- *                               QIOTaskFunc *func,
- *                               gpointer opaque,
- *                               GDestroyNotify *notify)
- *    {
- *      QIOTask *task;
- *      SocketAddress *addrCopy;
- *
- *      qapi_copy_SocketAddress(&addrCopy, addr);
- *      task = qio_task_new(OBJECT(obj), func, opaque, notify);
- *
- *      qio_task_run_in_thread(task, myobject_listen_worker,
- *                             addrCopy,
- *                             qapi_free_SocketAddress);
- *    }
- * </example>
- *
- * NB, The 'func' callback passed into myobject_listen_async
- * will be invoked from the main event thread, despite the
- * actual operation being performed in a different thread.
- */
-
-/**
- * qio_task_new:
- * @source: the object on which the operation is invoked
- * @func: the callback to invoke when the task completes
- * @opaque: opaque data to pass to @func when invoked
- * @destroy: optional callback to free @opaque
- *
- * Creates a new task struct to track completion of a
- * background operation running on the object @source.
- * When the operation completes or fails, the callback
- * @func will be invoked. The callback can access the
- * 'err' attribute in the task object to determine if
- * the operation was successful or not.
- *
- * The returned task will be released when one of
- * qio_task_abort() or qio_task_complete() are invoked.
- *
- * Returns: the task struct
- */
-QIOTask *qio_task_new(Object *source,
-                      QIOTaskFunc func,
-                      gpointer opaque,
-                      GDestroyNotify destroy);
-
-/**
- * qio_task_run_in_thread:
- * @task: the task struct
- * @worker: the function to invoke in a thread
- * @opaque: opaque data to pass to @worker
- * @destroy: function to free @opaque
- *
- * Run a task in a background thread. If @worker
- * returns 0 it will call qio_task_complete() in
- * the main event thread context. If @worker
- * returns -1 it will call qio_task_abort() in
- * the main event thread context.
- */
-void qio_task_run_in_thread(QIOTask *task,
-                            QIOTaskWorker worker,
-                            gpointer opaque,
-                            GDestroyNotify destroy);
-
-/**
- * qio_task_complete:
- * @task: the task struct
- *
- * Mark the operation as succesfully completed
- * and free the memory for @task.
- */
-void qio_task_complete(QIOTask *task);
-
-/**
- * qio_task_abort:
- * @task: the task struct
- * @err: the error to record for the operation
- *
- * Mark the operation as failed, with @err providing
- * details about the failure. The @err may be freed
- * afer the function returns, as the notification
- * callback is invoked synchronously. The @task will
- * be freed when this call completes.
- */
-void qio_task_abort(QIOTask *task,
-                    Error *err);
-
-
-/**
- * qio_task_get_source:
- * @task: the task struct
- *
- * Get the source object associated with the background
- * task. This returns a new reference to the object,
- * which the caller must released with object_unref()
- * when no longer required.
- *
- * Returns: the source object
- */
-Object *qio_task_get_source(QIOTask *task);
-
-#endif /* QIO_TASK_H__ */