io: enable DNS resolving separately of socket create
v2 cover io: enable DNS resolving separately of socket create
This is a followup of:
v1: https://lists.gnu.org/archive/html/qemu-devel/2017-01/msg00574.html
Currently DNS resolution of SocketAddress structs is done as part of the socket connect/listen process. This is very inflexible as it assumes that a single SocketAddress struct will only ever require a single socket to be opened. While true for connect(), it is not the case for listen() in two scenarios
- A name may resolve to both an IPv4 and IPv6 address. Currently we workaround that by clearing the IPV6_V6ONLY flag.
- A name may resolve to multiple IP addresses of the same protocol. eg "myhostname" may return "192.168.122.1" and "10.0.0.2" when the host has multiple NICs, or multiple addresses per NIC.
The only way to deal with the latter problem is to open multiple sockets and that requires the ability to separate DNS resolution from socket creation.
This series thus enhances the I/O framework in QEMU to introduce the "QIODNSResolver" concept. This (singleton) object allows the caller to feed in a single SocketAddress struct, perform DNS resolution, and get back out one or more new SocketAddress structs for the results. The API allows both synchronous and asynchrounous DNS lookups, the latter done by spawning a thread to do the getaddrinfo call via the QIOTask framework.
In this series the InetSocketAddress struct gains a new field to let the caller indicate that the address is providing a numeric host value, thus skipping DNS altogether.
The QIOTask object had some refactoring to allow results to be associated with it explicitly, so that the asynchronous DNS results can be passed around. This triggered the code churn across other files in QEMU using QIOTask.
This series will be utilized by a second series that will be sent that updates the VNC server code to use this new feature.
Changed in v2:
- Fix qapi schema version annotation (Eric)
- Fix qapi schema optional status for "numeric" (Eric)
- Use bool instead of gboolean (Eric)
- Document that qio_task_set_error() accepts NULL (Eric)
- Make qio_task_set_error() calls unconditional (Eric)
- Fix leak of SocketAddress results (Eric)
- Other misc typos (Eric)
Daniel P. Berrange (8):
sockets: add ability to disable DNS resolution for InetSocketAddress
io: stop incrementing reference in qio_task_get_source
io: fix typo in docs for QIOTask
io: add ability to associate an opaque "result" with with a task
io: add ability to associate an error with a task
io: change the QIOTask callback signature
io: remove Error parameter from QIOTask thread worker
io: introduce a DNS resolver API
include/io/dns-resolver.h | 228 +++++++++++++++++++++++++++++++++++ include/io/task.h | 154 +++++++++++++++++------- include/qemu/sockets.h | 2 + io/Makefile.objs | 1 + io/channel-socket.c | 44 +++---- io/channel-tls.c | 16 +-- io/channel-websock.c | 8 +- io/dns-resolver.c | 267 +++++++++++++++++++++++++++++++++++++++++ io/task.c | 62 +++++++--- io/trace-events | 1 - migration/socket.c | 11 +- migration/tls.c | 19 +-- nbd/common.c | 8 +- nbd/nbd-internal.h | 3 +- qapi-schema.json | 5 + qemu-char.c | 18 +-- tests/test-io-channel-socket.c | 5 +- tests/test-io-channel-tls.c | 5 +- tests/test-io-task.c | 31 ++--- ui/vnc-auth-vencrypt.c | 7 +- ui/vnc-ws.c | 14 ++- util/qemu-sockets.c | 7 +- 22 files changed, 747 insertions(+), 169 deletions(-) create mode 100644 include/io/dns-resolver.h create mode 100644 io/dns-resolver.c
Signature · 1 line
2.9.3
PATCH v2 1/8 sockets: add ability to disable DNS resolution for InetSocketAddress
Add a 'numeric' flag to the InetSocketAddress struct to allow the caller to indicate that DNS should be skipped for the host/port fields. This is useful if the caller knows the address is already numeric and wants to guarantee no (potentially blocking) DNS lookups are attempted.
--- qapi-schema.json | 5 +++++ util/qemu-sockets.c | 3 +++ 2 files changed, 8 insertions(+)
qapi-schema.json +5 -0
@@ -3070,6 +3070,10 @@ # # @port: port part of the address, or lowest port if @to is present # +# @numeric: #optional true if the host/port are guaranteed to be numeric, +# false if name resolution should be attempted. Defaults to false. +# (Since 2.9) +# # @to: highest port to try # # @ipv4: whether to accept IPv4 addresses, default try both IPv4 and IPv6
@@ -3084,6 +3088,7 @@ 'data': { 'host': 'str', 'port': 'str', + '*numeric': 'bool', '*to': 'uint16', '*ipv4': 'bool', '*ipv6': 'bool' } }
util/qemu-sockets.c +3 -0
@@ -141,6 +141,9 @@ static int inet_listen_saddr(InetSocketAddress *saddr,memset (&ai,0 ,sizeof (ai)); ai.ai_flags =AI_PASSIVE ; +if (saddr->has_numeric && saddr->numeric) { + ai.ai_flags |=AI_NUMERICHOST |AI_NUMERICSERV ; + } ai.ai_family =inet_ai_family_from_address (saddr, &err); ai.ai_socktype =SOCK_STREAM ;
Signature · 1 line
2.9.3
PATCH v2 2/8 io: stop incrementing reference in qio_task_get_source
In reply to Daniel P. BerrangeIncrementing the reference in qio_task_get_source is not necessary, since we're not running concurrently with any other code touching the QIOTask. This minimizes chances of further memory leaks.
--- include/io/task.h | 7 ++++--- io/channel-socket.c | 3 --- io/channel-tls.c | 2 -- io/task.c | 1 - tests/test-io-task.c | 1 - 5 files changed, 4 insertions(+), 10 deletions(-)
include/io/task.h +4 -3
@@ -244,9 +244,10 @@ void qio_task_abort(QIOTask *task,* @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. +* task. The caller does not own a reference on the +* returned Object, and so should call object_ref() +* if it wants to keep the object pointer outside the +* lifetime of the QIOTask object. * * Returns: the source object */
io/channel-socket.c +0 -3
@@ -168,7 +168,6 @@ static int qio_channel_socket_connect_worker(QIOTask *task, addr, errp); -object_unref (OBJECT (ioc));return ret; }
@@ -231,7 +230,6 @@ static int qio_channel_socket_listen_worker(QIOTask *task, addr, errp); -object_unref (OBJECT (ioc));return ret; }
@@ -309,7 +307,6 @@ static int qio_channel_socket_dgram_worker(QIOTask *task, data->remoteAddr, errp); -object_unref (OBJECT (ioc));return ret; }
io/channel-tls.c +0 -2
@@ -200,8 +200,6 @@ static gboolean qio_channel_tls_handshake_io(QIOChannel *ioc,qio_channel_tls_handshake_task ( tioc, task); -object_unref (OBJECT (tioc)); -return FALSE; }
io/task.c +0 -1
@@ -156,6 +156,5 @@ void qio_task_abort(QIOTask *task,Object *qio_task_get_source (QIOTask *task) { -object_ref (task->source);return task->source; }
tests/test-io-task.c +0 -1
@@ -76,7 +76,6 @@ static void test_task_complete(void)g_assert (obj == src);object_unref (obj); -object_unref (src);g_assert (data.source == obj);g_assert (data.err ==NULL );
Signature · 1 line
2.9.3
PATCH v2 3/8 io: fix typo in docs for QIOTask
In reply to Daniel P. BerrangeThe GDestroyNotify parameter is already a pointer, so does not need a '*' suffix on the type.
--- include/io/task.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
include/io/task.h +3 -3
@@ -49,7 +49,7 @@ typedef int (*QIOTaskWorker)(QIOTask *task,* void myobject_operation(QMyObject *obj, * QIOTaskFunc *func, * gpointer opaque, -* GDestroyNotify *notify); +* GDestroyNotify notify); * </programlisting> * </example> *
@@ -67,7 +67,7 @@ typedef int (*QIOTaskWorker)(QIOTask *task,* void myobject_operation(QMyObject *obj, * QIOTaskFunc *func, * gpointer opaque, -* GDestroyNotify *notify) +* GDestroyNotify notify) * { * QIOTask *task; *
@@ -154,7 +154,7 @@ typedef int (*QIOTaskWorker)(QIOTask *task,* SocketAddress *addr, * QIOTaskFunc *func, * gpointer opaque, -* GDestroyNotify *notify) +* GDestroyNotify notify) * { * QIOTask *task; * SocketAddress *addrCopy;
Signature · 1 line
2.9.3
PATCH v2 4/8 io: add ability to associate an opaque "result" with with a task
In reply to Daniel P. BerrangeCurrently there is no data associated with a successful task completion. This adds an opaque pointer to the task to store an arbitrary result.
--- include/io/task.h | 27 +++++++++++++++++++++++++++ io/task.c | 20 ++++++++++++++++++++ 2 files changed, 47 insertions(+)
include/io/task.h +27 -0
@@ -240,6 +240,33 @@ void qio_task_abort(QIOTask *task,/** +* qio_task_set_result_pointer: +* @task: the task struct +* @result: pointer to the result data +* +* Associate an opaque result with the task, +* which can later be retrieved with the +* qio_task_get_result_pointer() method +* +*/ +void qio_task_set_result_pointer (QIOTask *task, +gpointer result, +GDestroyNotify notify); + + +/** +* qio_task_get_result_pointer: +* @task: the task struct +* +* Retrieve the opaque result data associated +* with the task, if any. +* +* Returns: the task result, or NULL +*/ +gpointer qio_task_get_result_pointer (QIOTask *task); + + +/** * qio_task_get_source: * @task: the task struct *
io/task.c +20 -0
@@ -29,6 +29,8 @@ struct QIOTask {QIOTaskFunc func;gpointer opaque;GDestroyNotify destroy; +gpointer result; +GDestroyNotify destroyResult; };
@@ -57,6 +59,9 @@ static void qio_task_free(QIOTask *task)if (task->destroy) { task->destroy (task->opaque); } +if (task->destroyResult) { + task->destroyResult (task->result); + }object_unref (task->source);g_free (task);
@@ -154,6 +159,21 @@ void qio_task_abort(QIOTask *task, } +void qio_task_set_result_pointer (QIOTask *task, +gpointer result, +GDestroyNotify destroy) +{ + task->result = result; + task->destroyResult = destroy; +} + + +gpointer qio_task_get_result_pointer (QIOTask *task) +{ +return task->result; +} + +Object *qio_task_get_source (QIOTask *task) {return task->source;
Signature · 1 line
2.9.3
PATCH v2 5/8 io: add ability to associate an error with a task
In reply to Daniel P. BerrangeCurrently when a task fails, the error is never explicitly associated with the task object, it is just passed along through the completion callback. This adds the ability to explicitly associate an error with the task.
--- include/io/task.h | 32 ++++++++++++++++++++++++++++++++ io/task.c | 23 +++++++++++++++++++++++ 2 files changed, 55 insertions(+)
include/io/task.h +32 -0
@@ -240,6 +240,38 @@ void qio_task_abort(QIOTask *task,/** +* qio_task_set_error: +* @task: the task struct +* @err: pointer to the error, or NULL +* +* Associate an error with the task, which can later +* be retrieved with the qio_task_propagate_error() +* method. This method takes ownership of @err, so +* it is not valid to access it after this call +* completes. If @err is NULL this is a no-op. If +* this is call multiple times, only the first +* provided @err will be recorded, later ones will +* be discarded and freed. +*/ +void qio_task_set_error (QIOTask *task, +Error *err); + + +/** +* qio_task_propagate_error: +* @task: the task struct +* @errp: pointer to a NULL-initialized error object +* +* Propagate the error associated with @task +* into @errp. +* +* Returns: true if an error was propagated, false otherwise +*/ +bool qio_task_propagate_error (QIOTask *task, +Error **errp); + + +/** * qio_task_set_result_pointer: * @task: the task struct * @result: pointer to the result data
io/task.c +23 -0
@@ -29,6 +29,7 @@ struct QIOTask {QIOTaskFunc func;gpointer opaque;GDestroyNotify destroy; +Error *err;gpointer result;GDestroyNotify destroyResult; };
@@ -62,6 +63,9 @@ static void qio_task_free(QIOTask *task)if (task->destroyResult) { task->destroyResult (task->result); } +if (task->err) { +error_free (task->err); + }object_unref (task->source);g_free (task);
@@ -159,6 +163,25 @@ void qio_task_abort(QIOTask *task, } +void qio_task_set_error (QIOTask *task, +Error *err) +{ +error_propagate (&task->err, err); +} + + +bool qio_task_propagate_error (QIOTask *task, +Error **errp) +{ +if (task->err) { +error_propagate (errp, task->err); +return true; + } + +return false; +} + +void qio_task_set_result_pointer (QIOTask *task,gpointer result,GDestroyNotify destroy)
Signature · 1 line
2.9.3
PATCH v2 7/8 io: remove Error parameter from QIOTask thread worker
In reply to Daniel P. BerrangeNow that task objects have a directly associated error, there's no need for an an Error **errp parameter to the QIOTask thread worker function. It already has a QIOTask object, so can directly set the error on it.
--- include/io/task.h | 19 ++++++++----------- io/channel-socket.c | 41 ++++++++++++++++------------------------- io/task.c | 10 +--------- tests/test-io-task.c | 12 +++++------- 4 files changed, 30 insertions(+), 52 deletions(-)
include/io/task.h +8 -11
@@ -29,9 +29,8 @@ typedef struct QIOTask QIOTask;typedef void (*QIOTaskFunc )(QIOTask *task,gpointer opaque); -typedef int (*QIOTaskWorker )(QIOTask *task, -Error **errp, -gpointer opaque); +typedef void (*QIOTaskWorker )(QIOTask *task, +gpointer opaque);/** * QIOTask:
@@ -163,18 +162,16 @@ typedef int (*QIOTaskWorker)(QIOTask *task,* socket listen using QIOTask would require: * * <example> -* static int myobject_listen_worker(QIOTask *task, -* Error **errp, -* gpointer opaque) +* static void myobject_listen_worker(QIOTask *task, +* gpointer opaque) * { * QMyObject obj = QMY_OBJECT(qio_task_get_source(task)); * SocketAddress *addr = opaque; +* Error *err = NULL; * -* obj->fd = socket_listen(addr, errp); -* if (obj->fd < 0) { -* return -1; -* } -* return 0; +* obj->fd = socket_listen(addr, &err); +* +qio_task_set_error(task, err); * } * * void myobject_listen_async(QMyObject *obj,
io/channel-socket.c +16 -25
75 lines not on this page · raw message
io/task.c +1 -9
@@ -77,8 +77,6 @@ struct QIOTaskThreadData {QIOTaskWorker worker;gpointer opaque;GDestroyNotify destroy; -Error *err; -int ret; };
@@ -87,9 +85,6 @@ static gboolean gio_task_thread_result(gpointer opaque)struct QIOTaskThreadData *data = opaque;trace_qio_task_thread_result (data->task); -if (data->err) { -qio_task_set_error (data->task, data->err); - }qio_task_complete (data->task);if (data->destroy) {
@@ -107,10 +102,7 @@ static gpointer qio_task_thread_worker(gpointer opaque)struct QIOTaskThreadData *data = opaque;trace_qio_task_thread_run (data->task); - data->ret = data->worker (data->task, &data->err, data->opaque); -if (data->ret <0 && data->err ==NULL ) { -error_setg (&data->err,"Task worker failed but did not set an error" ); - } + data->worker (data->task, data->opaque);/* We're running in the background thread, and must only * ever report the task results in the main event loop
tests/test-io-task.c +5 -7
@@ -140,20 +140,18 @@ struct TestThreadWorkerData {GMainLoop *loop; }; -static int test_task_thread_worker (QIOTask *task, -Error **errp, -gpointer opaque) +static void test_task_thread_worker (QIOTask *task, +gpointer opaque) {struct TestThreadWorkerData *data = opaque; data->worker =g_thread_self ();if (data->fail) { -error_setg (errp,"Testing fail" ); -return -1 ; +Error *err =NULL ; +error_setg (&err,"Testing fail" ); +qio_task_set_error (task, err); } - -return 0 ; }
Signature · 1 line
2.9.3
PATCH v2 6/8 io: change the QIOTask callback signature
In reply to Daniel P. BerrangeCurrently the QIOTaskFunc signature takes an Object * for the source, and an Error * for any error. We also need to be able to provide a result pointer. Rather than continue to add parameters to QIOTaskFunc, remove the existing ones and simply pass the QIOTask object instead. This has methods to access all the other data items required in the callback impl.
--- include/io/task.h | 73 ++++++++++++++++++++++++------------------ io/channel-tls.c | 14 ++++---- io/channel-websock.c | 8 ++--- io/task.c | 18 +++-------- io/trace-events | 1 - migration/socket.c | 11 ++++--- migration/tls.c | 19 +++++------ nbd/common.c | 8 ++--- nbd/nbd-internal.h | 3 +- qemu-char.c | 18 ++++++----- tests/test-io-channel-socket.c | 5 ++- tests/test-io-channel-tls.c | 5 ++- tests/test-io-task.c | 18 +++++------ ui/vnc-auth-vencrypt.c | 7 ++-- ui/vnc-ws.c | 14 ++++---- 15 files changed, 110 insertions(+), 112 deletions(-)
include/io/task.h +42 -31
@@ -26,8 +26,7 @@typedef struct QIOTask QIOTask ; -typedef void (*QIOTaskFunc )(Object *source, -Error *err, +typedef void (*QIOTaskFunc )(QIOTask *task,gpointer opaque); typedef int (*QIOTaskWorker)(QIOTask *task,
@@ -44,7 +43,7 @@ typedef int (*QIOTaskWorker)(QIOTask *task,* a public API which accepts a task callback: * * <example> -* <title>Task callback function signature</title> +* <title>Task function signature</title> * <programlisting> * void myobject_operation(QMyObject *obj, * QIOTaskFunc *func,
@@ -57,12 +56,36 @@ typedef int (*QIOTaskWorker)(QIOTask *task,* 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 +* When the operation completes, the 'func' callback will be +* invoked, allowing the calling code to determine the result +* of the operation. An example QIOTaskFunc implementation may +* look like * * <example> -* <title>Task callback function implementation</title> +* <title>Task callback implementation</title> +* <programlisting> +* static void myobject_operation_notify(QIOTask *task, +* gpointer opaque) +* { +* Error *err = NULL; +* if (qio_task_propagate_error(task, &err)) { +* ...deal with the failure... +* error_free(err); +* } else { +* QMyObject *src = QMY_OBJECT(qio_task_get_source(task)); +* ...deal with the completion... +* } +* } +* </programlisting> +* </example> +* +* Now, lets say the implementation of the method using the +* task wants to set a timer to run once a second checking +* for completion of some activity. It would do something +* like +* +* <example> +* <title>Task function implementation</title> * <programlisting> * void myobject_operation(QMyObject *obj, * QIOTaskFunc *func,
@@ -102,8 +125,8 @@ typedef int (*QIOTaskWorker)(QIOTask *task,* * ...check something important... * if (err) { -* qio_task_abort(task, err); -* error_free(task); +* qio_task_set_error(task, err); +* qio_task_complete(task); * return FALSE; * } else if (...work is completed ...) { * qio_task_complete(task);
@@ -115,6 +138,10 @@ typedef int (*QIOTaskWorker)(QIOTask *task,* </programlisting> * </example> * +* The 'qio_task_complete' call in this method will trigger +* the callback func 'myobject_operation_notify' shown +* earlier to deal with the results. +* * 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.
@@ -187,8 +214,8 @@ typedef int (*QIOTaskWorker)(QIOTask *task,* '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. +* The returned task will be released when qio_task_complete() +* is invoked. * * Returns: the task struct */
@@ -204,10 +231,8 @@ QIOTask *qio_task_new(Object *source,* @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 +* Run a task in a background thread. When @worker +* returns it will call qio_task_complete() in * the main event thread context. */ void qio_task_run_in_thread(QIOTask *task,
@@ -219,25 +244,11 @@ void qio_task_run_in_thread(QIOTask *task,* qio_task_complete: * @task: the task struct * -* Mark the operation as successfully completed -* and free the memory for @task. +* Invoke the completion callback for @task and +* then free its memory. */ 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_set_error:
io/channel-tls.c +6 -8
@@ -153,8 +153,9 @@ static void qio_channel_tls_handshake_task(QIOChannelTLS *ioc,if (qcrypto_tls_session_handshake (ioc->session, &err) <0 ) {trace_qio_channel_tls_handshake_fail (ioc); -qio_task_abort (task, err); - goto cleanup; +qio_task_set_error (task, err); +qio_task_complete (task); +return ; } status =qcrypto_tls_session_get_handshake_status (ioc->session);
@@ -163,10 +164,10 @@ static void qio_channel_tls_handshake_task(QIOChannelTLS *ioc,if (qcrypto_tls_session_check_credentials (ioc->session, &err) <0 ) {trace_qio_channel_tls_credentials_deny (ioc); -qio_task_abort (task, err); - goto cleanup; +qio_task_set_error (task, err); + }else { +trace_qio_channel_tls_credentials_allow (ioc); } -trace_qio_channel_tls_credentials_allow (ioc);qio_task_complete (task); }else {GIOCondition condition;
@@ -183,9 +184,6 @@ static void qio_channel_tls_handshake_task(QIOChannelTLS *ioc, task, NULL); } - - cleanup: -error_free (err); }
io/channel-websock.c +4 -4
@@ -279,8 +279,8 @@ static gboolean qio_channel_websock_handshake_send(QIOChannel *ioc,if (ret <0 ) {trace_qio_channel_websock_handshake_fail (ioc); -qio_task_abort (task, err); -error_free (err); +qio_task_set_error (task, err); +qio_task_complete (task);return FALSE; }
@@ -307,8 +307,8 @@ static gboolean qio_channel_websock_handshake_io(QIOChannel *ioc, ret =qio_channel_websock_handshake_read (wioc, &err);if (ret <0 ) {trace_qio_channel_websock_handshake_fail (ioc); -qio_task_abort (task, err); -error_free (err); +qio_task_set_error (task, err); +qio_task_complete (task);return FALSE; }if (ret ==0 ) {
io/task.c +4 -14
@@ -87,13 +87,11 @@ static gboolean gio_task_thread_result(gpointer opaque)struct QIOTaskThreadData *data = opaque;trace_qio_task_thread_result (data->task); -if (data->ret ==0 ) { -qio_task_complete (data->task); - }else { -qio_task_abort (data->task, data->err); +if (data->err) { +qio_task_set_error (data->task, data->err); } +qio_task_complete (data->task); -error_free (data->err);if (data->destroy) { data->destroy (data->opaque); }
@@ -149,19 +147,11 @@ void qio_task_run_in_thread(QIOTask *task,void qio_task_complete (QIOTask *task) { - task->func (task->source,NULL , task->opaque); + task->func (task, task->opaque);trace_qio_task_complete (task);qio_task_free (task); } -void qio_task_abort (QIOTask *task, -Error *err) -{ - task->func (task->source, err, task->opaque); -trace_qio_task_abort (task); -qio_task_free (task); -} -void qio_task_set_error (QIOTask *task,Error *err)
io/trace-events +0 -1
@@ -3,7 +3,6 @@ # io/task.c qio_task_new(void *task, void *source, void *func, void *opaque) "Task new task=%p source=%p func=%p opaque=%p" qio_task_complete(void *task) "Task complete task=%p" -qio_task_abort(void *task) "Task abort task=%p" qio_task_thread_start(void *task, void *worker, void *opaque) "Task thread start task=%p worker=%p opaque=%p" qio_task_thread_run(void *task) "Task thread run task=%p" qio_task_thread_exit(void *task) "Task thread exit task=%p"
migration/socket.c +6 -5
@@ -70,22 +70,23 @@ static void socket_connect_data_free(void *opaque)g_free (data); } -static void socket_outgoing_migration (Object *src, -Error *err, +static void socket_outgoing_migration (QIOTask *task,gpointer opaque) {struct SocketConnectData *data = opaque; -QIOChannel *sioc =QIO_CHANNEL (src); +QIOChannel *sioc =QIO_CHANNEL (qio_task_get_source (task)); +Error *err =NULL ; -if (err) { +if (qio_task_propagate_error (task, &err)) {trace_migration_socket_outgoing_error (error_get_pretty (err)); data->s->to_dst_file =NULL ;migrate_fd_error (data->s, err); +error_free (err); }else {trace_migration_socket_outgoing_connected (data->hostname);migration_channel_connect (data->s, sioc, data->hostname); } -object_unref (src); +object_unref (OBJECT (sioc)); } static void socket_start_outgoing_migration(MigrationState *s,
migration/tls.c +10 -9
@@ -61,15 +61,15 @@ migration_tls_get_creds(MigrationState *s, } -static void migration_tls_incoming_handshake (Object *src, -Error *err, +static void migration_tls_incoming_handshake (QIOTask *task,gpointer opaque) { -QIOChannel *ioc =QIO_CHANNEL (src); +QIOChannel *ioc =QIO_CHANNEL (qio_task_get_source (task)); +Error *err =NULL ; -if (err) { +if (qio_task_propagate_error (task, &err)) {trace_migration_tls_incoming_handshake_error (error_get_pretty (err)); -error_report ("%s" ,error_get_pretty (err)); +error_report_err (err); }else {trace_migration_tls_incoming_handshake_complete ();migration_channel_process_incoming (migrate_get_current (), ioc);
@@ -107,17 +107,18 @@ void migration_tls_channel_process_incoming(MigrationState *s, } -static void migration_tls_outgoing_handshake (Object *src, -Error *err, +static void migration_tls_outgoing_handshake (QIOTask *task,gpointer opaque) {MigrationState *s = opaque; -QIOChannel *ioc =QIO_CHANNEL (src); +QIOChannel *ioc =QIO_CHANNEL (qio_task_get_source (task)); +Error *err =NULL ; -if (err) { +if (qio_task_propagate_error (task, &err)) {trace_migration_tls_outgoing_handshake_error (error_get_pretty (err)); s->to_dst_file =NULL ;migrate_fd_error (s, err); +error_free (err); }else {trace_migration_tls_outgoing_handshake_complete ();migration_channel_connect (s, ioc,NULL );
nbd/common.c +3 -5
@@ -78,15 +78,13 @@ ssize_t nbd_wr_syncv(QIOChannel *ioc, } -void nbd_tls_handshake (Object *src, -Error *err, +void nbd_tls_handshake (QIOTask *task,void *opaque) {struct NBDTLSHandshakeData *data = opaque; -if (err) { -TRACE ("TLS failed %s" ,error_get_pretty (err)); - data->error =error_copy (err); +if (qio_task_propagate_error (task, &data->error)) { +TRACE ("TLS failed %s" ,error_get_pretty (data->error)); } data->complete = true;g_main_loop_quit (data->loop);
nbd/nbd-internal.h +1 -2
@@ -120,8 +120,7 @@ struct NBDTLSHandshakeData { }; -void nbd_tls_handshake (Object *src, -Error *err, +void nbd_tls_handshake (QIOTask *task,void *opaque);#endif
qemu-char.c +10 -8
@@ -3272,14 +3272,13 @@ static void tcp_chr_telnet_init(CharDriverState *chr) } -static void tcp_chr_tls_handshake (Object *source, -Error *err, +static void tcp_chr_tls_handshake (QIOTask *task,gpointer user_data) {CharDriverState *chr = user_data;TCPCharDriver *s = chr->opaque; -if (err) { +if (qio_task_propagate_error (task,NULL )) {tcp_chr_disconnect (chr); }else {if (s->do_telnetopt) {
@@ -3487,20 +3486,23 @@ static void tcp_chr_free(CharDriverState *chr) } -static void qemu_chr_socket_connected (Object *src,Error *err,void *opaque) +static void qemu_chr_socket_connected (QIOTask *task,void *opaque) { -QIOChannelSocket *sioc =QIO_CHANNEL_SOCKET (src); +QIOChannelSocket *sioc =QIO_CHANNEL_SOCKET (qio_task_get_source (task));CharDriverState *chr = opaque;TCPCharDriver *s = chr->opaque; +Error *err =NULL ; -if (err) { +if (qio_task_propagate_error (task, &err)) {check_report_connect_error (chr, err); -object_unref (src); -return ; +error_free (err); + goto cleanup; } s->connect_err_reported = false;tcp_chr_new_client (chr, sioc); + + cleanup:object_unref (OBJECT (sioc)); }
tests/test-io-channel-socket.c +2 -3
@@ -156,12 +156,11 @@ struct TestIOChannelData { }; -static void test_io_channel_complete (Object *src, -Error *err, +static void test_io_channel_complete (QIOTask *task,gpointer opaque) {struct TestIOChannelData *data = opaque; - data->err = err !=NULL ; + data->err =qio_task_propagate_error (task,NULL );g_main_loop_quit (data->loop); }
tests/test-io-channel-tls.c +2 -3
@@ -53,14 +53,13 @@ struct QIOChannelTLSHandshakeData {bool failed; }; -static void test_tls_handshake_done (Object *source, -Error *err, +static void test_tls_handshake_done (QIOTask *task,gpointer opaque) {struct QIOChannelTLSHandshakeData *data = opaque; data->finished = true; - data->failed = err !=NULL ; + data->failed =qio_task_propagate_error (task,NULL ); }
tests/test-io-task.c +8 -10
@@ -50,14 +50,13 @@ struct TestTaskData { }; -static void task_callback (Object *source, -Error *err, +static void task_callback (QIOTask *task,gpointer opaque) {struct TestTaskData *data = opaque; - data->source = source; - data->err = err; + data->source =qio_task_get_source (task); +qio_task_propagate_error (task, &data->err); }
@@ -120,9 +119,9 @@ static void test_task_failure(void)error_setg (&err,"Some error" ); -qio_task_abort (task, err); +qio_task_set_error (task, err); +qio_task_complete (task); -error_free (err);object_unref (obj);g_assert (data.source == obj);
@@ -158,14 +157,13 @@ static int test_task_thread_worker(QIOTask *task, } -static void test_task_thread_callback (Object *source, -Error *err, +static void test_task_thread_callback (QIOTask *task,gpointer opaque) {struct TestThreadWorkerData *data = opaque; - data->source = source; - data->err = err; + data->source =qio_task_get_source (task); +qio_task_propagate_error (task, &data->err); data->complete =g_thread_self ();
ui/vnc-auth-vencrypt.c +4 -3
@@ -65,16 +65,17 @@ static void start_auth_vencrypt_subauth(VncState *vs) } } -static void vnc_tls_handshake_done (Object *source, -Error *err, +static void vnc_tls_handshake_done (QIOTask *task,gpointer user_data) {VncState *vs = user_data; +Error *err =NULL ; -if (err) { +if (qio_task_propagate_error (task, &err)) {VNC_DEBUG ("Handshake failed %s\n" ,error_get_pretty (err));vnc_client_error (vs); +error_free (err); }else { vs->ioc_tag =qio_channel_add_watch ( vs->ioc,G_IO_IN |G_IO_OUT , vnc_client_io, vs,NULL );
ui/vnc-ws.c +8 -6
@@ -24,15 +24,16 @@#include "io/channel-websock.h" #include "qemu/bswap.h" -static void vncws_tls_handshake_done (Object *source, -Error *err, +static void vncws_tls_handshake_done (QIOTask *task,gpointer user_data) {VncState *vs = user_data; +Error *err =NULL ; -if (err) { +if (qio_task_propagate_error (task, &err)) {VNC_DEBUG ("Handshake failed %s\n" ,error_get_pretty (err));vnc_client_error (vs); +error_free (err); }else {VNC_DEBUG ("TLS handshake complete, starting websocket handshake\n" ); vs->ioc_tag = qio_channel_add_watch(
@@ -83,15 +84,16 @@ gboolean vncws_tls_handshake_io(QIOChannel *ioc G_GNUC_UNUSED, } -static void vncws_handshake_done (Object *source, -Error *err, +static void vncws_handshake_done (QIOTask *task,gpointer user_data) {VncState *vs = user_data; +Error *err =NULL ; -if (err) { +if (qio_task_propagate_error (task, &err)) {VNC_DEBUG ("Websock handshake failed %s\n" ,error_get_pretty (err));vnc_client_error (vs); +error_free (err); }else {VNC_DEBUG ("Websock handshake complete, starting VNC protocol\n" );vnc_start_protocol (vs);
Signature · 1 line
2.9.3
PATCH v2 8/8 io: introduce a DNS resolver API
In reply to Daniel P. BerrangeCurrently DNS resolution is done automatically as part of the creation of a QIOChannelSocket object instance. This works ok for network clients where you just end up a single network socket, but for servers, the results of DNS resolution may require creation of multiple sockets.
Introducing a DNS resolver API allows DNS resolution to be separated from the socket object creation. This will make it practical to create multiple QIOChannelSocket instances for servers.
--- include/io/dns-resolver.h | 228 +++++++++++++++++++++++++++++++++++++++ include/qemu/sockets.h | 2 + io/Makefile.objs | 1 + io/dns-resolver.c | 267 ++++++++++++++++++++++++++++++++++++++++++++++ util/qemu-sockets.c | 4 +- 5 files changed, 500 insertions(+), 2 deletions(-) create mode 100644 include/io/dns-resolver.h create mode 100644 io/dns-resolver.c
include/io/dns-resolver.h new file +228 -0
@@ -0,0 +1,228 @@ +/* +* QEMU DNS resolver +* +* Copyright (c) 2016-2017 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_DNS_RESOLVER_H +#define QIO_DNS_RESOLVER_H + +#include "qemu-common.h" +#include "qom/object.h" +#include "io/task.h" + +#define TYPE_QIO_DNS_RESOLVER "qio-dns-resolver" +#define QIO_DNS_RESOLVER (obj) \ + OBJECT_CHECK(QIODNSResolver, (obj), TYPE_QIO_DNS_RESOLVER) +#define QIO_DNS_RESOLVER_CLASS (klass) \ + OBJECT_CLASS_CHECK(QIODNSResolverClass, klass, TYPE_QIO_DNS_RESOLVER) +#define QIO_DNS_RESOLVER_GET_CLASS (obj) \ + OBJECT_GET_CLASS(QIODNSResolverClass, obj, TYPE_QIO_DNS_RESOLVER) + +typedef struct QIODNSResolver QIODNSResolver ; +typedef struct QIODNSResolverClass QIODNSResolverClass ; + +/** +* QIODNSResolver: +* +* The QIODNSResolver class provides a framework for doing +* DNS resolution on SocketAddress objects, independently +* of socket creation. +* +* <example> +* <title>Resolving addresses synchronously</title> +* <programlisting> +* int mylisten(SocketAddress *addr, Error **errp) { +* QIODNSResolver *resolver = qio_dns_resolver_get_instance(); +* SocketAddress **rawaddrs = NULL; +* size_t nrawaddrs = 0; +* Error *err = NULL; +* QIOChannel **socks = NULL; +* size_t nsocks = 0; +* +* if (qio_dns_resolver_lookup_sync(dns, addr, &nrawaddrs, +* &rawaddrs, errp) < 0) { +* return -1; +* } +* +* for (i = 0; i < nrawaddrs; i++) { +* QIOChannel *sock = qio_channel_new(); +* Error *local_err = NULL; +* qio_channel_listen_sync(sock, rawaddrs[i], &local_err); +* if (local_err) { +* error_propagate(&err, local_err); +* } else { +* socks = g_renew(QIOChannelSocket *, socks, nsocks + 1); +* socks[nsocks++] = sock; +* } +* qapi_free_SocketAddress(rawaddrs[i]); +* } +* g_free(rawaddrs); +* +* if (nsocks == 0) { +* error_propagate(errp, err); +* } else { +* error_free(err); +* } +* } +* </programlisting> +* </example> +* +* <example> +* <title>Resolving addresses asynchronously</title> +* <programlisting> +* typedef struct MyListenData { +* Error *err; +* QIOChannelSocket **socks; +* size_t nsocks; +* } MyListenData; +* +* void mylistenresult(QIOTask *task, void *opaque) { +* MyListenData *data = opaque; +* QIODNSResolver *resolver = +* QIO_DNS_RESOLVER(qio_task_get_source(task); +* SocketAddress **rawaddrs = NULL; +* size_t nrawaddrs = 0; +* Error *err = NULL; +* +* if (qio_task_propagate_error(task, &data->err)) { +* return; +* } +* +* qio_dns_resolver_lookup_result(resolver, task, +* &nrawaddrs, &rawaddrs); +* +* for (i = 0; i < nrawaddrs; i++) { +* QIOChannel *sock = qio_channel_new(); +* Error *local_err = NULL; +* qio_channel_listen_sync(sock, rawaddrs[i], &local_err); +* if (local_err) { +* error_propagate(&err, local_err); +* } else { +* socks = g_renew(QIOChannelSocket *, socks, nsocks + 1); +* socks[nsocks++] = sock; +* } +* qapi_free_SocketAddress(rawaddrs[i]); +* } +* g_free(rawaddrs); +* +* if (nsocks == 0) { +* error_propagate(&data->err, err); +* } else { +* error_free(err); +* } +* } +* +* void mylisten(SocketAddress *addr, MyListenData *data) { +* QIODNSResolver *resolver = qio_dns_resolver_get_instance(); +* qio_dns_resolver_lookup_async(dns, addr, +* mylistenresult, data, NULL); +* } +* </programlisting> +* </example> +*/ +struct QIODNSResolver { +Object parent; +}; + +struct QIODNSResolverClass { +ObjectClass parent; +}; + + +/** +* qio_dns_resolver_get_instance: +* +* Get the singleton dns resolver instance. The caller +* does not own a reference on the returned object. +* +* Returns: the single dns resolver instance +*/ +QIODNSResolver *qio_dns_resolver_get_instance (void ); + +/** +* qio_dns_resolver_lookup_sync: +* @resolver: the DNS resolver instance +* @addr: the address to resolve +* @naddr: pointer to hold number of resolved addresses +* @addrs: pointer to hold resolved addresses +* @errp: pointer to NULL initialized error object +* +* This will attempt to resolve the address provided +* in @addr. If resolution succeeds, @addrs will be filled +* with all the resolved addresses. @naddrs will specify +* the number of entries allocated in @addrs. The caller +* is responsible for freeing each entry in @addrs, as +* well as @addrs itself. @naddrs is guaranteed to be +* greater than zero on success. +* +* DNS resolution will be done synchronously so execution +* of the caller may be blocked for an arbitrary length +* of time. +* +* Returns: 0 if resolution was successful, -1 on error +*/ +int qio_dns_resolver_lookup_sync (QIODNSResolver *resolver, +SocketAddress *addr, +size_t *naddrs, +SocketAddress ***addrs, +Error **errp); + +/** +* qio_dns_resolver_lookup_async: +* @resolver: the DNS resolver instance +* @addr: the address to resolve +* @func: the callback to invoke on lookup completion +* @opaque: data blob to pass to @func +* @notify: the callback to free @opaque, or NULL +* +* This will attempt to resolve the address provided +* in @addr. The callback @func will be invoked when +* resolution has either completed or failed. On +* success, the @func should call the method +* qio_dns_resolver_lookup_result() to obtain the +* results. +* +* DNS resolution will be done asynchronously so execution +* of the caller will not be blocked. +*/ +void qio_dns_resolver_lookup_async (QIODNSResolver *resolver, +SocketAddress *addr, +QIOTaskFunc func, +gpointer opaque, +GDestroyNotify notify); + +/** +* qio_dns_resolver_lookup_result: +* @resolver: the DNS resolver instance +* @task: the task object to get results for +* @naddr: pointer to hold number of resolved addresses +* @addrs: pointer to hold resolved addresses +* +* This method should be called from the callback passed +* to qio_dns_resolver_lookup_async() in order to obtain +* results. @addrs will be filled with all the resolved +* addresses. @naddrs will specify the number of entries +* allocated in @addrs. The caller is responsible for +* freeing each entry in @addrs, as well as @addrs itself. +*/ +void qio_dns_resolver_lookup_result (QIODNSResolver *resolver, +QIOTask *task, +size_t *naddrs, +SocketAddress ***addrs); + +#endif /* QIO_DNS_RESOLVER_H */
include/qemu/sockets.h +2 -0
@@ -32,6 +32,8 @@ int socket_set_fast_reuse(int fd);*/ typedef void NonBlockingConnectHandler (int fd,Error *err,void *opaque); +int inet_ai_family_from_address (InetSocketAddress *addr, +Error **errp);InetSocketAddress *inet_parse (const char *str,Error **errp);int inet_connect (const char *str,Error **errp); int inet_connect_saddr(InetSocketAddress *saddr, Error **errp,
io/Makefile.objs +1 -0
@@ -7,4 +7,5 @@ io-obj-y += channel-tls.o io-obj-y += channel-watch.o io-obj-y += channel-websock.o io-obj-y += channel-util.o +io-obj-y += dns-resolver.o io-obj-y += task.o
io/dns-resolver.c new file +267 -0
267 lines not on this page · raw message
util/qemu-sockets.c +2 -2
@@ -110,8 +110,8 @@ NetworkAddressFamily inet_netfamily(int family)* outside scope of this method and not currently handled by * callers at all. */ -static int inet_ai_family_from_address (InetSocketAddress *addr, -Error **errp) +int inet_ai_family_from_address (InetSocketAddress *addr, +Error **errp) {if (addr->has_ipv6 && addr->has_ipv4 && !addr->ipv6 && !addr->ipv4) {
Signature · 1 line
2.9.3
Re: [Qemu-devel] [PATCH v2 1/8] sockets: add ability to disable DNS resolution for InetSocketAddress
In reply to Daniel P. BerrangeQuoted 6 lines · Daniel P. Berrange
Add a 'numeric' flag to the InetSocketAddress struct to allow the caller to indicate that DNS should be skipped for the host/port fields. This is useful if the caller knows the address is already numeric and wants to guarantee no (potentially blocking) DNS lookups are attempted.
Quoted 6 lines
Signed-off-by Daniel P. Berrange <[email protected]>--- qapi-schema.json | 5 +++++ util/qemu-sockets.c | 3 +++ 2 files changed, 8 insertions(+)
Signature · 2 lines
Eric Blake eblake redhat com +1-919-301-3266 Libvirt virtualization library http://libvirt.org
Re: [Qemu-devel] [PATCH v2 5/8] io: add ability to associate an error with a task
In reply to Daniel P. BerrangeQuoted 12 lines · Daniel P. Berrange
Currently when a task fails, the error is never explicitly associated with the task object, it is just passed along through the completion callback. This adds the ability to explicitly associate an error with the task.
Signed-off-by Daniel P. Berrange <[email protected]>--- include/io/task.h | 32 ++++++++++++++++++++++++++++++++ io/task.c | 23 +++++++++++++++++++++++ 2 files changed, 55 insertions(+)
Quoted 11 lines
/**
+ *qio_task_set_error:
+ * @task: the task struct
+ * @err: pointer to the error, or NULL
+ *
+ * Associate an error with the task, which can later
+ * be retrieved with theqio_task_propagate_error()
+ * method. This method takes ownership of @err, so
+ * it is not valid to access it after this call
+ * completes. If @err is NULL this is a no-op. If
+ * this is call multiple times, only the first
s/call/called/
Quoted 3 lines
+ * provided @err will be recorded, later ones will
+ * be discarded and freed.
+ */
With the typo fix,
Signature · 2 lines
Eric Blake eblake redhat com +1-919-301-3266 Libvirt virtualization library http://libvirt.org
Re: [Qemu-devel] [PATCH v2 8/8] io: introduce a DNS resolver API
In reply to Daniel P. BerrangeQuoted 26 lines · Daniel P. Berrange
Currently DNS resolution is done automatically as part of the creation of a QIOChannelSocket object instance. This works ok for network clients where you just end up a single network socket, but for servers, the results of DNS resolution may require creation of multiple sockets.
Introducing a DNS resolver API allows DNS resolution to be separated from the socket object creation. This will make it practical to create multiple QIOChannelSocket instances for servers.
Signed-off-by Daniel P. Berrange <[email protected]>--- include/io/dns-resolver.h | 228 +++++++++++++++++++++++++++++++++++++++ include/qemu/sockets.h | 2 + io/Makefile.objs | 1 + io/dns-resolver.c | 267 ++++++++++++++++++++++++++++++++++++++++++++++ util/qemu-sockets.c | 4 +- 5 files changed, 500 insertions(+), 2 deletions(-) create mode 100644 include/io/dns-resolver.h create mode 100644 io/dns-resolver.c+++
b/io/dns-resolver.c
io/dns-resolver.c line 4
Quoted 4 lines
io/dns-resolver.c new file +4
-0@@ -0,0 +1,267 @@ +/* +* QEMU DNS resolver +* +* Copyright (c) 2016 Red Hat, Inc.
If you want to add 2017, go for it.
Looks like you addressed everything I spotted in v1.
Signature · 2 lines
Eric Blake eblake redhat com +1-919-301-3266 Libvirt virtualization library http://libvirt.org