io: fix mem leak when using QIOTask in TLS and websock channels
PATCH 1/3 io: separate freeing of tasks from marking them as complete
In reply to Daniel P. BerrangéThe original design of QIOTask was intended to simplify lifecycle management by automatically freeing it when the task was marked as complete. This overlooked the fact that when a QIOTask is used in combination with a GSource, there may be times when the source callback is never invoked. This is typically when a GSource is released before any I/O event arrives. In such cases it is not desirable to mark a QIOTask as complete, but it still needs to be freed. To satisfy this, the task must be released manually.
--- include/io/task.h | 29 +++++++++++++++++++++-------- io/channel-tls.c | 4 ++++ io/channel-websock.c | 3 +++ io/task.c | 8 ++++++-- tests/unit/test-io-task.c | 26 ++++++++++++++++++++++++++ 5 files changed, 60 insertions(+), 10 deletions(-)
include/io/task.h +21 -8
@@ -96,7 +96,7 @@ typedef void (*QIOTaskWorker)(QIOTask *task,* 1000, * myobject_operation_timer, * task, -* NULL); +* qio_task_free); * } * </programlisting> * </example>
@@ -138,9 +138,8 @@ typedef void (*QIOTaskWorker)(QIOTask *task,* 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. +* Once this function returns FALSE, the task will be freed, +* causing it release the ref on QMyObject too. * * The QIOTask module can also be used to perform operations * in a background thread context, while still reporting the
@@ -208,8 +207,8 @@ typedef void (*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 qio_task_complete() -* is invoked. +* The returned task must be released by calling +* qio_task_free() when no longer required. * * Returns: the task struct */
@@ -218,6 +217,19 @@ QIOTask *qio_task_new(Object *source,gpointer opaque, GDestroyNotify destroy); +/** +* qio_task_free: +* task: the task object to free +* +* Free the resources associated with the task. Typically +* the qio_task_complete() method will be called immediately +* before this to trigger the task callback, however, it is +* permissible to free the task in the case of cancellation. +* The destroy callback will be used to release the opaque +* data provided to qio_task_new(). +*/ +void qio_task_free (QIOTask *task); +/** * qio_task_run_in_thread: * @task: the task struct
@@ -268,8 +280,9 @@ void qio_task_wait_thread(QIOTask *task);* qio_task_complete: * @task: the task struct * -* Invoke the completion callback for @task and -* then free its memory. +* Invoke the completion callback for @task. This should typically +* only be invoked once on a task, and then qio_task_free() used +* to free it. */ void qio_task_complete (QIOTask *task);
io/channel-tls.c +4 -0
@@ -170,6 +170,7 @@ static void qio_channel_tls_handshake_task(QIOChannelTLS *ioc,trace_qio_channel_tls_handshake_fail (ioc);qio_task_set_error (task, err);qio_task_complete (task); +qio_task_free (task);return ; }
@@ -183,6 +184,7 @@ static void qio_channel_tls_handshake_task(QIOChannelTLS *ioc,trace_qio_channel_tls_credentials_allow (ioc); }qio_task_complete (task); +qio_task_free (task); }else {GIOCondition condition;QIOChannelTLSData *data =g_new0 (typeof (*data),1 );
@@ -270,11 +272,13 @@ static void qio_channel_tls_bye_task(QIOChannelTLS *ioc, QIOTask *task,trace_qio_channel_tls_bye_fail (ioc);qio_task_set_error (task, err);qio_task_complete (task); +qio_task_free (task);return ; }if (status ==QCRYPTO_TLS_BYE_COMPLETE ) {qio_task_complete (task); +qio_task_free (task);return ; }
io/channel-websock.c +3 -0
@@ -545,6 +545,7 @@ static gboolean qio_channel_websock_handshake_send(QIOChannel *ioc,trace_qio_channel_websock_handshake_fail (ioc,error_get_pretty (err));qio_task_set_error (task, err);qio_task_complete (task); +qio_task_free (task); wioc->hs_io_tag =0 ;return FALSE; }
@@ -561,6 +562,7 @@ static gboolean qio_channel_websock_handshake_send(QIOChannel *ioc,trace_qio_channel_websock_handshake_complete (ioc);qio_task_complete (task); } +qio_task_free (task); wioc->hs_io_tag =0 ;return FALSE; }
@@ -588,6 +590,7 @@ static gboolean qio_channel_websock_handshake_io(QIOChannel *ioc,trace_qio_channel_websock_handshake_fail (ioc,error_get_pretty (err));qio_task_set_error (task, err);qio_task_complete (task); +qio_task_free (task); wioc->hs_io_tag =0 ;return FALSE; }
io/task.c +6 -2
@@ -70,8 +70,12 @@ QIOTask *qio_task_new(Object *source,return task; } -static void qio_task_free (QIOTask *task) +void qio_task_free (QIOTask *task) { +if (!task) { +return ; + } +qemu_mutex_lock (&task->thread_lock);if (task->thread) {if (task->thread->destroy) {
@@ -110,6 +114,7 @@ static gboolean qio_task_thread_result(gpointer opaque)trace_qio_task_thread_result (task);qio_task_complete (task); +qio_task_free (task);return FALSE; }
@@ -196,7 +201,6 @@ void qio_task_complete(QIOTask *task) { task->func (task, task->opaque);trace_qio_task_complete (task); -qio_task_free (task); }
tests/unit/test-io-task.c +26 -0
@@ -73,6 +73,7 @@ static void test_task_complete(void) src =qio_task_get_source (task);qio_task_complete (task); +qio_task_free (task);g_assert (obj == src);
@@ -84,6 +85,28 @@ static void test_task_complete(void) } +static void test_task_cancel (void ) +{ +QIOTask *task; +Object *obj =object_new (TYPE_DUMMY ); +Object *src; +struct TestTaskData data = {NULL ,NULL , false }; + + task =qio_task_new (obj, task_callback, &data,NULL ); + src =qio_task_get_source (task); + +qio_task_free (task); + +g_assert (obj == src); + +object_unref (obj); + +g_assert (data.source ==NULL ); +g_assert (data.err ==NULL ); +g_assert (data.freed == false); +} + +static void task_data_free (gpointer opaque) {struct TestTaskData *data = opaque;
@@ -101,6 +124,7 @@ static void test_task_data_free(void) task =qio_task_new (obj, task_callback, &data, task_data_free);qio_task_complete (task); +qio_task_free (task);object_unref (obj);
@@ -123,6 +147,7 @@ static void test_task_failure(void)qio_task_set_error (task, err);qio_task_complete (task); +qio_task_free (task);object_unref (obj);
@@ -260,6 +285,7 @@ int main(int argc, char **argv)module_call_init (MODULE_INIT_QOM );type_register_static (&dummy_info);g_test_add_func ("/crypto/task/complete" , test_task_complete); +g_test_add_func ("/crypto/task/cancel" , test_task_cancel);g_test_add_func ("/crypto/task/datafree" , test_task_data_free);g_test_add_func ("/crypto/task/failure" , test_task_failure);g_test_add_func ("/crypto/task/thread_complete" , test_task_thread_complete);
Signature · 1 line
2.52.0
PATCH 3/3 io: fix cleanup for websock I/O source data on cancellation
In reply to Daniel P. BerrangéThe websock code will create a GSource for tracking completion of the handshake process, passing a QIOTask which is freed by the callback when it completes, which means when a source is cancelled, nothing is free'ing the task.
Switch to provide a data free callback to the GSource, which ensures the QIOTask is always freed even when the main event callback never fires.
--- io/channel-websock.c | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-)
io/channel-websock.c +1 -4
@@ -545,7 +545,6 @@ static gboolean qio_channel_websock_handshake_send(QIOChannel *ioc,trace_qio_channel_websock_handshake_fail (ioc,error_get_pretty (err));qio_task_set_error (task, err);qio_task_complete (task); -qio_task_free (task); wioc->hs_io_tag =0 ;return FALSE; }
@@ -562,7 +561,6 @@ static gboolean qio_channel_websock_handshake_send(QIOChannel *ioc,trace_qio_channel_websock_handshake_complete (ioc);qio_task_complete (task); } -qio_task_free (task); wioc->hs_io_tag =0 ;return FALSE; }
@@ -590,7 +588,6 @@ static gboolean qio_channel_websock_handshake_io(QIOChannel *ioc,trace_qio_channel_websock_handshake_fail (ioc,error_get_pretty (err));qio_task_set_error (task, err);qio_task_complete (task); -qio_task_free (task); wioc->hs_io_tag =0 ;return FALSE; }
@@ -918,7 +915,7 @@ void qio_channel_websock_handshake(QIOChannelWebsock *ioc,G_IO_IN , qio_channel_websock_handshake_io, task, - NULL); + (GDestroyNotify)qio_task_free); }
Signature · 1 line
2.52.0
cover io: fix mem leak when using QIOTask in TLS and websock channels
The handshake functions in the TLS and websock channels could leak a QIOTask and some related data if the underlying channel was torn down before the handshake completed. This also applies to the async TLS "bye" tasks.
Fixing this required refactoring the QIOTask cleanup paradigm slightly.
This is a followup to a proposed fix at
https://lists.nongnu.org/archive/html/qemu-devel/2025-09/msg02984.html
and also reported at
https://gitlab.com/qemu-project/qemu/-/issues/3114
Daniel P. Berrangé (3):
io: separate freeing of tasks from marking them as complete
io: fix cleanup for TLS I/O source data on cancellation
io: fix cleanup for websock I/O source data on cancellation
include/io/task.h | 29 +++++++++++++------ io/channel-tls.c | 60 ++++++++++++++++++++++++++------------- io/channel-websock.c | 2 +- io/task.c | 8 ++++-- tests/unit/test-io-task.c | 26 +++++++++++++++++ 5 files changed, 94 insertions(+), 31 deletions(-)
Signature · 1 line
2.52.0
PATCH 2/3 io: fix cleanup for TLS I/O source data on cancellation
The TLS code will create a GSource for tracking completion of the handshake process, passing a QIOChannelTLSData struct that contains various data items. The data struct is freed by the callback when it completes, which means when a source is cancelled, nothing is free'ing the data struct or its contents.
Switch to provide a data free callback to the GSource, which ensures the QIOChannelTLSData struct is always freed even when the main event callback never fires.
--- io/channel-tls.c | 64 ++++++++++++++++++++++++++++++------------------ 1 file changed, 40 insertions(+), 24 deletions(-)
io/channel-tls.c +40 -24
@@ -153,13 +153,32 @@ struct QIOChannelTLSData { };typedef struct QIOChannelTLSData QIOChannelTLSData ; +static void qio_channel_tls_io_data_free (gpointer user_data) +{ +QIOChannelTLSData *data = user_data; +/* +* Usually 'task' will be NULL since the GSource +* callback will either complete the task or pass +* it on to a new GSource. We'll see a non-NULL +* task here only if the GSource was released before +* its callback triggers +*/ +if (data->task) { +qio_task_free (data->task); + } +if (data->context) { +g_main_context_unref (data->context); + } +g_free (data); +} +static gboolean qio_channel_tls_handshake_io (QIOChannel *ioc,GIOCondition condition,gpointer user_data); -static void qio_channel_tls_handshake_task (QIOChannelTLS *ioc, -QIOTask *task, -GMainContext *context) +static gboolean qio_channel_tls_handshake_task (QIOChannelTLS *ioc, +QIOTask *task, +GMainContext *context) {Error *err =NULL ;int status;
@@ -170,8 +189,7 @@ static void qio_channel_tls_handshake_task(QIOChannelTLS *ioc,trace_qio_channel_tls_handshake_fail (ioc);qio_task_set_error (task, err);qio_task_complete (task); -qio_task_free (task); -return ; +return TRUE; }if (status ==QCRYPTO_TLS_HANDSHAKE_COMPLETE ) {
@@ -184,7 +202,7 @@ static void qio_channel_tls_handshake_task(QIOChannelTLS *ioc,trace_qio_channel_tls_credentials_allow (ioc); }qio_task_complete (task); -qio_task_free (task); +return TRUE; }else {GIOCondition condition;QIOChannelTLSData *data =g_new0 (typeof (*data),1 );
@@ -208,8 +226,9 @@ static void qio_channel_tls_handshake_task(QIOChannelTLS *ioc, condition, qio_channel_tls_handshake_io, data, -NULL , + qio_channel_tls_io_data_free, context); +return FALSE; } }
@@ -225,11 +244,9 @@ static gboolean qio_channel_tls_handshake_io(QIOChannel *ioc, qio_task_get_source(task)); tioc->hs_ioc_tag =0 ; -g_free (data); -qio_channel_tls_handshake_task (tioc, task, context); - -if (context) { -g_main_context_unref (context); +if (!qio_channel_tls_handshake_task (tioc, task, context)) { +/* task is kept by new GSource so must not be released yet */ + data->task =NULL ; }return FALSE;
@@ -258,8 +275,8 @@ void qio_channel_tls_handshake(QIOChannelTLS *ioc,static gboolean qio_channel_tls_bye_io (QIOChannel *ioc,GIOCondition condition,gpointer user_data); -static void qio_channel_tls_bye_task (QIOChannelTLS *ioc,QIOTask *task, -GMainContext *context) +static gboolean qio_channel_tls_bye_task (QIOChannelTLS *ioc,QIOTask *task, +GMainContext *context) {GIOCondition condition;QIOChannelTLSData *data;
@@ -272,14 +289,12 @@ static void qio_channel_tls_bye_task(QIOChannelTLS *ioc, QIOTask *task,trace_qio_channel_tls_bye_fail (ioc);qio_task_set_error (task, err);qio_task_complete (task); -qio_task_free (task); -return ; +return TRUE; }if (status ==QCRYPTO_TLS_BYE_COMPLETE ) {qio_task_complete (task); -qio_task_free (task); -return ; +return TRUE; } data =g_new0 (typeof (*data),1 );
@@ -299,7 +314,10 @@ static void qio_channel_tls_bye_task(QIOChannelTLS *ioc, QIOTask *task,trace_qio_channel_tls_bye_pending (ioc, status); ioc->bye_ioc_tag =qio_channel_add_watch_full (ioc->master, condition, qio_channel_tls_bye_io, - data,NULL , context); + data, + qio_channel_tls_io_data_free, + context); +return FALSE; }
@@ -312,11 +330,9 @@ static gboolean qio_channel_tls_bye_io(QIOChannel *ioc, GIOCondition condition,QIOChannelTLS *tioc =QIO_CHANNEL_TLS (qio_task_get_source (task)); tioc->bye_ioc_tag =0 ; -g_free (data); -qio_channel_tls_bye_task (tioc, task, context); - -if (context) { -g_main_context_unref (context); +if (!qio_channel_tls_bye_task (tioc, task, context)) { +/* task is kept by new GSource so must not be released yet */ + data->task =NULL ; }return FALSE;
Signature · 1 line
2.52.0
Re: [PATCH 2/3] io: fix cleanup for TLS I/O source data on cancellation
Quoted 7 lines · Daniel P. Berrangé
The TLS code will create a GSource for tracking completion of the handshake process, passing a QIOChannelTLSData struct that contains various data items. The data struct is freed by the callback when it completes, which means when a source is cancelled, nothing is free'ing the data struct or its contents.
Quoted 6 lines
Switch to provide a data free callback to the GSource, which ensures the QIOChannelTLSData struct is always freed even when the main event callback never fires.
Quoted 148 lines
--- io/channel-tls.c | 64 ++++++++++++++++++++++++++++++------------------ 1 file changed, 40 insertions(+), 24 deletions(-)io/channel-tls.c +40
-25@@ -153,13 +153,32 @@ struct QIOChannelTLSData { };typedef struct QIOChannelTLSData QIOChannelTLSData ; +static void qio_channel_tls_io_data_free (gpointer user_data) +{ +QIOChannelTLSData *data = user_data; +/* +* Usually 'task' will be NULL since the GSource +* callback will either complete the task or pass +* it on to a new GSource. We'll see a non-NULL +* task here only if the GSource was released before +* its callback triggers +*/ +if (data->task) { +qio_task_free (data->task); + } +if (data->context) { +g_main_context_unref (data->context); + } +g_free (data); +} +static gboolean qio_channel_tls_handshake_io (QIOChannel *ioc,GIOCondition condition,gpointer user_data); -static void qio_channel_tls_handshake_task (QIOChannelTLS *ioc, -QIOTask *task, -GMainContext *context) +static gboolean qio_channel_tls_handshake_task (QIOChannelTLS *ioc, +QIOTask *task, +GMainContext *context) {Error *err =NULL ;int status;@@ -170,8 +189,7 @@ static void qio_channel_tls_handshake_task(QIOChannelTLS *ioc,trace_qio_channel_tls_handshake_fail (ioc);qio_task_set_error (task, err);qio_task_complete (task); -qio_task_free (task); -return ; +return TRUE; }if (status ==QCRYPTO_TLS_HANDSHAKE_COMPLETE ) {@@ -184,7 +202,7 @@ static void qio_channel_tls_handshake_task(QIOChannelTLS *ioc,trace_qio_channel_tls_credentials_allow (ioc); }qio_task_complete (task); -qio_task_free (task); +return TRUE; }else {GIOCondition condition;QIOChannelTLSData *data =g_new0 (typeof (*data),1 );@@ -208,8 +226,9 @@ static void qio_channel_tls_handshake_task(QIOChannelTLS *ioc, condition, qio_channel_tls_handshake_io, data, -NULL , + qio_channel_tls_io_data_free, context); +return FALSE; } }@@ -225,11 +244,9 @@ static gboolean qio_channel_tls_handshake_io(QIOChannel *ioc, qio_task_get_source(task)); tioc->hs_ioc_tag =0 ; -g_free (data); -qio_channel_tls_handshake_task (tioc, task, context); - -if (context) { -g_main_context_unref (context); +if (!qio_channel_tls_handshake_task (tioc, task, context)) { +/* task is kept by new GSource so must not be released yet */ + data->task =NULL ; }return FALSE;@@ -258,8 +275,8 @@ void qio_channel_tls_handshake(QIOChannelTLS *ioc,static gboolean qio_channel_tls_bye_io (QIOChannel *ioc,GIOCondition condition,gpointer user_data); -static void qio_channel_tls_bye_task (QIOChannelTLS *ioc,QIOTask *task, -GMainContext *context) +static gboolean qio_channel_tls_bye_task (QIOChannelTLS *ioc,QIOTask *task, +GMainContext *context) {GIOCondition condition;QIOChannelTLSData *data;@@ -272,14 +289,12 @@ static void qio_channel_tls_bye_task(QIOChannelTLS *ioc, QIOTask *task,trace_qio_channel_tls_bye_fail (ioc);qio_task_set_error (task, err);qio_task_complete (task); -qio_task_free (task); -return ; +return TRUE; }if (status ==QCRYPTO_TLS_BYE_COMPLETE ) {qio_task_complete (task); -qio_task_free (task); -return ; +return TRUE; } data =g_new0 (typeof (*data),1 );@@ -299,7 +314,10 @@ static void qio_channel_tls_bye_task(QIOChannelTLS *ioc, QIOTask *task,trace_qio_channel_tls_bye_pending (ioc, status); ioc->bye_ioc_tag =qio_channel_add_watch_full (ioc->master, condition, qio_channel_tls_bye_io, - data,NULL , context); + data, + qio_channel_tls_io_data_free, + context); +return FALSE; }@@ -312,11 +330,9 @@ static gboolean qio_channel_tls_bye_io(QIOChannel *ioc, GIOCondition condition,QIOChannelTLS *tioc =QIO_CHANNEL_TLS (qio_task_get_source (task)); tioc->bye_ioc_tag =0 ; -g_free (data); -qio_channel_tls_bye_task (tioc, task, context); - -if (context) { -g_main_context_unref (context); +if (!qio_channel_tls_bye_task (tioc, task, context)) { +/* task is kept by new GSource so must not be released yet */ + data->task =NULL ; }return FALSE; --2.52.0
Signature · 1 line
Marc-André Lureau
Re: [PATCH 3/3] io: fix cleanup for websock I/O source data on cancellation
In reply to Daniel P. BerrangéQuoted 6 lines · Daniel P. Berrangé
The websock code will create a GSource for tracking completion of the handshake process, passing a QIOTask which is freed by the callback when it completes, which means when a source is cancelled, nothing is free'ing the task.
Quoted 6 lines
Switch to provide a data free callback to the GSource, which ensures the QIOTask is always freed even when the main event callback never fires.
Quoted 45 lines
--- io/channel-websock.c | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-)io/channel-websock.c +1
-5@@ -545,7 +545,6 @@ static gboolean qio_channel_websock_handshake_send(QIOChannel *ioc,trace_qio_channel_websock_handshake_fail (ioc,error_get_pretty (err));qio_task_set_error (task, err);qio_task_complete (task); -qio_task_free (task); wioc->hs_io_tag =0 ;return FALSE; }@@ -562,7 +561,6 @@ static gboolean qio_channel_websock_handshake_send(QIOChannel *ioc,trace_qio_channel_websock_handshake_complete (ioc);qio_task_complete (task); } -qio_task_free (task); wioc->hs_io_tag =0 ;return FALSE; }@@ -590,7 +588,6 @@ static gboolean qio_channel_websock_handshake_io(QIOChannel *ioc,trace_qio_channel_websock_handshake_fail (ioc,error_get_pretty (err));qio_task_set_error (task, err);qio_task_complete (task); -qio_task_free (task); wioc->hs_io_tag =0 ;return FALSE; }@@ -918,7 +915,7 @@ void qio_channel_websock_handshake(QIOChannelWebsock *ioc,G_IO_IN , qio_channel_websock_handshake_io, task, - NULL); + (GDestroyNotify)qio_task_free); } --2.52.0
Signature · 1 line
Marc-André Lureau
Re: [PATCH 1/3] io: separate freeing of tasks from marking them as complete
In reply to Daniel P. BerrangéQuoted 11 lines · Daniel P. Berrangé
The original design of QIOTask was intended to simplify lifecycle management by automatically freeing it when the task was marked as complete. This overlooked the fact that when a QIOTask is used in combination with a GSource, there may be times when the source callback is never invoked. This is typically when a GSource is released before any I/O event arrives. In such cases it is not desirable to mark a QIOTask as complete, but it still needs to be freed. To satisfy this, the task must be released manually.
Signed-off-by Daniel P. Berrangé <[email protected]>
Quoted 241 lines
--- include/io/task.h | 29 +++++++++++++++++++++-------- io/channel-tls.c | 4 ++++ io/channel-websock.c | 3 +++ io/task.c | 8 ++++++-- tests/unit/test-io-task.c | 26 ++++++++++++++++++++++++++ 5 files changed, 60 insertions(+), 10 deletions(-)include/io/task.h +21
-8@@ -96,7 +96,7 @@ typedef void (*QIOTaskWorker)(QIOTask *task,* 1000, * myobject_operation_timer, * task, -* NULL); +* qio_task_free); * } * </programlisting> * </example> @@ -138,9 +138,8 @@ typedef void (*QIOTaskWorker)(QIOTask *task,* 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. +* Once this function returns FALSE, the task will be freed, +* causing it release the ref on QMyObject too. * * The QIOTask module can also be used to perform operations * in a background thread context, while still reporting the @@ -208,8 +207,8 @@ typedef void (*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 qio_task_complete() -* is invoked. +* The returned task must be released by calling +* qio_task_free() when no longer required. * * Returns: the task struct */ @@ -218,6 +217,19 @@ QIOTask *qio_task_new(Object *source,gpointer opaque, GDestroyNotify destroy); +/** +* qio_task_free: +* task: the task object to free +* +* Free the resources associated with the task. Typically +* the qio_task_complete() method will be called immediately +* before this to trigger the task callback, however, it is +* permissible to free the task in the case of cancellation. +* The destroy callback will be used to release the opaque +* data provided to qio_task_new(). +*/ +void qio_task_free (QIOTask *task); +/** * qio_task_run_in_thread: * @task: the task struct @@ -268,8 +280,9 @@ void qio_task_wait_thread(QIOTask *task);* qio_task_complete: * @task: the task struct * -* Invoke the completion callback for @task and -* then free its memory. +* Invoke the completion callback for @task. This should typically +* only be invoked once on a task, and then qio_task_free() used +* to free it. */ void qio_task_complete (QIOTask *task);io/channel-tls.c +4
-0@@ -170,6 +170,7 @@ static void qio_channel_tls_handshake_task(QIOChannelTLS *ioc,trace_qio_channel_tls_handshake_fail (ioc);qio_task_set_error (task, err);qio_task_complete (task); +qio_task_free (task);return ; }@@ -183,6 +184,7 @@ static void qio_channel_tls_handshake_task(QIOChannelTLS *ioc,trace_qio_channel_tls_credentials_allow (ioc); }qio_task_complete (task); +qio_task_free (task); }else {GIOCondition condition;QIOChannelTLSData *data =g_new0 (typeof (*data),1 );@@ -270,11 +272,13 @@ static void qio_channel_tls_bye_task(QIOChannelTLS *ioc, QIOTask *task,trace_qio_channel_tls_bye_fail (ioc);qio_task_set_error (task, err);qio_task_complete (task); +qio_task_free (task);return ; }if (status ==QCRYPTO_TLS_BYE_COMPLETE ) {qio_task_complete (task); +qio_task_free (task);return ; }io/channel-websock.c +3
-0@@ -545,6 +545,7 @@ static gboolean qio_channel_websock_handshake_send(QIOChannel *ioc,trace_qio_channel_websock_handshake_fail (ioc,error_get_pretty (err));qio_task_set_error (task, err);qio_task_complete (task); +qio_task_free (task); wioc->hs_io_tag =0 ;return FALSE; }@@ -561,6 +562,7 @@ static gboolean qio_channel_websock_handshake_send(QIOChannel *ioc,trace_qio_channel_websock_handshake_complete (ioc);qio_task_complete (task); } +qio_task_free (task); wioc->hs_io_tag =0 ;return FALSE; }@@ -588,6 +590,7 @@ static gboolean qio_channel_websock_handshake_io(QIOChannel *ioc,trace_qio_channel_websock_handshake_fail (ioc,error_get_pretty (err));qio_task_set_error (task, err);qio_task_complete (task); +qio_task_free (task); wioc->hs_io_tag =0 ;return FALSE; }io/task.c +6
-2@@ -70,8 +70,12 @@ QIOTask *qio_task_new(Object *source,return task; } -static void qio_task_free (QIOTask *task) +void qio_task_free (QIOTask *task) { +if (!task) { +return ; + } +qemu_mutex_lock (&task->thread_lock);if (task->thread) {if (task->thread->destroy) {@@ -110,6 +114,7 @@ static gboolean qio_task_thread_result(gpointer opaque)trace_qio_task_thread_result (task);qio_task_complete (task); +qio_task_free (task);return FALSE; }@@ -196,7 +201,6 @@ void qio_task_complete(QIOTask *task) { task->func (task, task->opaque);trace_qio_task_complete (task); -qio_task_free (task); }tests/unit/test-io-task.c +26
-1@@ -73,6 +73,7 @@ static void test_task_complete(void) src =qio_task_get_source (task);qio_task_complete (task); +qio_task_free (task);g_assert (obj == src);@@ -84,6 +85,28 @@ static void test_task_complete(void) } +static void test_task_cancel (void ) +{ +QIOTask *task; +Object *obj =object_new (TYPE_DUMMY ); +Object *src; +struct TestTaskData data = {NULL ,NULL , false }; + + task =qio_task_new (obj, task_callback, &data,NULL ); + src =qio_task_get_source (task); + +qio_task_free (task); + +g_assert (obj == src); + +object_unref (obj); + +g_assert (data.source ==NULL ); +g_assert (data.err ==NULL ); +g_assert (data.freed == false); +} + +static void task_data_free (gpointer opaque) {struct TestTaskData *data = opaque;@@ -101,6 +124,7 @@ static void test_task_data_free(void) task =qio_task_new (obj, task_callback, &data, task_data_free);qio_task_complete (task); +qio_task_free (task);object_unref (obj);@@ -123,6 +147,7 @@ static void test_task_failure(void)qio_task_set_error (task, err);qio_task_complete (task); +qio_task_free (task);object_unref (obj);@@ -260,6 +285,7 @@ int main(int argc, char **argv)module_call_init (MODULE_INIT_QOM );type_register_static (&dummy_info);g_test_add_func ("/crypto/task/complete" , test_task_complete); +g_test_add_func ("/crypto/task/cancel" , test_task_cancel);g_test_add_func ("/crypto/task/datafree" , test_task_data_free);g_test_add_func ("/crypto/task/failure" , test_task_failure);g_test_add_func ("/crypto/task/thread_complete" , test_task_thread_complete); --2.52.0
Signature · 1 line
Marc-André Lureau