chardev: refactoring & many bugfixes related tcp_chr_wait_connected
v2 cover chardev: refactoring & many bugfixes related tcp_chr_wait_connected
This is a followup to
v1: https://lists.gnu.org/archive/html/qemu-devel/2019-01/msg03344.html
This series comes out of a discussion between myself & Yongji Xie in:
https://lists.gnu.org/archive/html/qemu-devel/2019-01/msg01881.html
I eventually understood that the problem faced was that tcp_chr_wait_connected was racing with the background connection attempt previously started, causing two connections to be established. This broke because some vhost user servers only allow a single connection.
After messing around with the code alot the final solution was in fact very easy. We simply have to delay the first background connection attempt until the main loop is running. It will then automatically turn into a no-op if tcp_chr_wait_connected has been run. This is dealt with in the last patch in this series
I believe this should solve the problem Yongji Xie faced, and thus not require us to add support for "nowait" option with client sockets at all. The reconnect=1 option effectively already implements nowait semantics, and now plays nicely with tcp_chr_wait_connected.
In investigating this I found various other bugs that needed fixing and identified some useful refactoring to simplify / clarify the code, hence this very long series.
This series passes make check-unit & check-qtest (for x86_64 target).
I did a test with tests/vhost-user-bridge too, which was in fact already broken for the same reason Yongji Xie found - it only accepts a single connection. This series fixes use of reconnect=1 with vhost-user-bridge.
Changed in v2:
- Rewrite the way we synchronize in tcp_chr_wait_connected again to cope with chardev+device hotplug scenario
- Add extensive unit test coverage
- Resolve conflicts with git master
Daniel P. Berrangé (16):
io: store reference to thread information in the QIOTask struct
io: add qio_task_wait_thread to join with a background thread
chardev: fix validation of options for QMP created chardevs
chardev: forbid 'reconnect' option with server sockets
chardev: forbid 'wait' option with client sockets
chardev: remove many local variables in qemu_chr_parse_socket
chardev: ensure qemu_chr_parse_compat reports missing driver error
chardev: remove unused 'sioc' variable & cleanup paths
chardev: split tcp_chr_wait_connected into two methods
chardev: split up qmp_chardev_open_socket connection code
chardev: use a state machine for socket connection state
chardev: honour the reconnect setting in tcp_chr_wait_connected
chardev: disallow TLS/telnet/websocket with tcp_chr_wait_connected
chardev: fix race with client connections in tcp_chr_wait_connected
tests: expand coverage of socket chardev test
chardev: ensure termios is fully initialized
chardev/char-serial.c | 2 +- chardev/char-socket.c | 487 ++++++++++++++++++------- chardev/char.c | 2 + include/io/task.h | 29 +- io/task.c | 88 +++-- io/trace-events | 2 + tests/ivshmem-test.c | 2 +- tests/libqtest.c | 4 +- tests/test-char.c | 643 ++++++++++++++++++++++++--------- tests/test-filter-redirector.c | 4 +- 10 files changed, 928 insertions(+), 335 deletions(-)
Signature · 1 line
2.20.1
PATCH v2 1/16 io: store reference to thread information in the QIOTask struct
Currently the struct QIOTaskThreadData is only needed by the worker thread, but a subsequent patch will need to access it from another context.
--- io/task.c | 53 ++++++++++++++++++++++++++++------------------------- 1 file changed, 28 insertions(+), 25 deletions(-)
io/task.c +28 -25
@@ -24,6 +24,14 @@#include "qemu/thread.h" #include "trace.h" +struct QIOTaskThreadData { +QIOTaskWorker worker; +gpointer opaque; +GDestroyNotify destroy; +GMainContext *context; +}; + +struct QIOTask {Object *source;QIOTaskFunc func;
@@ -32,6 +40,7 @@ struct QIOTask {Error *err;gpointer result;GDestroyNotify destroyResult; +struct QIOTaskThreadData *thread; };
@@ -72,31 +81,23 @@ static void qio_task_free(QIOTask *task) } -struct QIOTaskThreadData { -QIOTask *task; -QIOTaskWorker worker; -gpointer opaque; -GDestroyNotify destroy; -GMainContext *context; -}; - -static gboolean qio_task_thread_result (gpointer opaque) { -struct QIOTaskThreadData *data = opaque; +QIOTask *task = opaque; -trace_qio_task_thread_result (data->task); -qio_task_complete (data->task); +trace_qio_task_thread_result (task); +qio_task_complete (task); -if (data->destroy) { - data->destroy (data->opaque); +if (task->thread->destroy) { + task->thread->destroy (task->thread->opaque); } -if (data->context) { -g_main_context_unref (data->context); +if (task->thread->context) { +g_main_context_unref (task->thread->context); } -g_free (data); +g_free (task->thread); + task->thread =NULL ;return FALSE; }
@@ -104,22 +105,23 @@ static gboolean qio_task_thread_result(gpointer opaque)static gpointer qio_task_thread_worker (gpointer opaque) { -struct QIOTaskThreadData *data = opaque; +QIOTask *task = opaque;GSource *idle; -trace_qio_task_thread_run (data->task); - data->worker (data->task, data->opaque); +trace_qio_task_thread_run (task); + + task->thread->worker (task, task->thread->opaque);/* We're running in the background thread, and must only * ever report the task results in the main event loop * thread. So we schedule an idle callback to report * the worker results */ -trace_qio_task_thread_exit (data->task); +trace_qio_task_thread_exit (task); idle =g_idle_source_new (); -g_source_set_callback (idle, qio_task_thread_result, data,NULL ); -g_source_attach (idle, data->context); +g_source_set_callback (idle, qio_task_thread_result, task,NULL ); +g_source_attach (idle, task->thread->context);return NULL ; }
@@ -138,17 +140,18 @@ void qio_task_run_in_thread(QIOTask *task,g_main_context_ref (context); } - data->task = task; data->worker = worker; data->opaque = opaque; data->destroy = destroy; data->context = context; + task->thread = data; +trace_qio_task_thread_start (task, worker, opaque);qemu_thread_create (&thread,"io-task-worker" , qio_task_thread_worker, - data, + task,QEMU_THREAD_DETACHED ); }
Signature · 1 line
2.20.1
Re: [Qemu-devel] [PATCH v2 01/16] io: store reference to thread information in the QIOTask struct
Quoted 6 lines · Daniel P. Berrangé
Currently the struct QIOTaskThreadData is only needed by the worker thread, but a subsequent patch will need to access it from another context.
Signed-off-by Daniel P. Berrangé <[email protected]>
Quoted 126 lines
--- io/task.c | 53 ++++++++++++++++++++++++++++------------------------- 1 file changed, 28 insertions(+), 25 deletions(-)io/task.c +28
-26@@ -24,6 +24,14 @@#include "qemu/thread.h" #include "trace.h" +struct QIOTaskThreadData { +QIOTaskWorker worker; +gpointer opaque; +GDestroyNotify destroy; +GMainContext *context; +}; + +struct QIOTask {Object *source;QIOTaskFunc func;@@ -32,6 +40,7 @@ struct QIOTask {Error *err;gpointer result;GDestroyNotify destroyResult; +struct QIOTaskThreadData *thread; };@@ -72,31 +81,23 @@ static void qio_task_free(QIOTask *task) } -struct QIOTaskThreadData { -QIOTask *task; -QIOTaskWorker worker; -gpointer opaque; -GDestroyNotify destroy; -GMainContext *context; -}; - -static gboolean qio_task_thread_result (gpointer opaque) { -struct QIOTaskThreadData *data = opaque; +QIOTask *task = opaque; -trace_qio_task_thread_result (data->task); -qio_task_complete (data->task); +trace_qio_task_thread_result (task); +qio_task_complete (task); -if (data->destroy) { - data->destroy (data->opaque); +if (task->thread->destroy) { + task->thread->destroy (task->thread->opaque); } -if (data->context) { -g_main_context_unref (data->context); +if (task->thread->context) { +g_main_context_unref (task->thread->context); } -g_free (data); +g_free (task->thread); + task->thread =NULL ;return FALSE; }@@ -104,22 +105,23 @@ static gboolean qio_task_thread_result(gpointer opaque)static gpointer qio_task_thread_worker (gpointer opaque) { -struct QIOTaskThreadData *data = opaque; +QIOTask *task = opaque;GSource *idle; -trace_qio_task_thread_run (data->task); - data->worker (data->task, data->opaque); +trace_qio_task_thread_run (task); + + task->thread->worker (task, task->thread->opaque);/* We're running in the background thread, and must only * ever report the task results in the main event loop * thread. So we schedule an idle callback to report * the worker results */ -trace_qio_task_thread_exit (data->task); +trace_qio_task_thread_exit (task); idle =g_idle_source_new (); -g_source_set_callback (idle, qio_task_thread_result, data,NULL ); -g_source_attach (idle, data->context); +g_source_set_callback (idle, qio_task_thread_result, task,NULL ); +g_source_attach (idle, task->thread->context);return NULL ; }@@ -138,17 +140,18 @@ void qio_task_run_in_thread(QIOTask *task,g_main_context_ref (context); } - data->task = task; data->worker = worker; data->opaque = opaque; data->destroy = destroy; data->context = context; + task->thread = data; +trace_qio_task_thread_start (task, worker, opaque);qemu_thread_create (&thread,"io-task-worker" , qio_task_thread_worker, - data, + task,QEMU_THREAD_DETACHED ); } --2.20.1
Re: [Qemu-devel] [PATCH v2 01/16] io: store reference to thread information in the QIOTask struct
Hi
Quoted 10 lines · Marc-André Lureau
Quoted 6 lines · Daniel P. Berrangé
Currently the struct QIOTaskThreadData is only needed by the worker thread, but a subsequent patch will need to access it from another context.
Signed-off-by Daniel P. Berrangé <[email protected]>Reviewed-by Marc-André Lureau <[email protected]>
nack:
$ tests/test-char
/char/null: OK
/char/invalid: OK
/char/ringbuf: OK
/char/mux: OK
/char/stdio: OK
/char/pipe: OK
/char/file: OK
/char/file-fifo: OK
/char/udp: OK
/char/serial: OK
/char/hotswap: OK
/char/websocket: OK
/char/socket/basic: OK
/char/socket/reconnect:
=================================================================
==22150==ERROR: AddressSanitizer: heap-use-after-free on address
0x606000004198 at pc 0x5618a22be8d3 bp 0x7fffa43d8a80 sp
0x7fffa43d8a70
READ of size 8 at 0x606000004198 thread T0
#0 0x5618a22be8d2 in qio_task_thread_result
/home/elmarco/src/qemu/io/task.c:91
#1 0x7f111f08397a (/lib64/libglib-2.0.so.0+0x4b97a)
#2 0x7f111f08706c in g_main_context_dispatch
(/lib64/libglib-2.0.so.0+0x4f06c)
#3 0x5618a23969b7 in glib_pollfds_poll
/home/elmarco/src/qemu/util/main-loop.c:215
#4 0x5618a23969b7 in os_host_main_loop_wait
/home/elmarco/src/qemu/util/main-loop.c:238
#5 0x5618a23969b7 in main_loop_wait
/home/elmarco/src/qemu/util/main-loop.c:497
#6 0x5618a2299786 in main_loop /home/elmarco/src/qemu/tests/test-char.c:27
#7 0x5618a229b651 in char_socket_test_common
/home/elmarco/src/qemu/tests/test-char.c:355
#8 0x7f111f0aefc9 (/lib64/libglib-2.0.so.0+0x76fc9)
#9 0x7f111f0aee83 (/lib64/libglib-2.0.so.0+0x76e83)
#10 0x7f111f0aee83 (/lib64/libglib-2.0.so.0+0x76e83)
#11 0x7f111f0af281 in g_test_run_suite (/lib64/libglib-2.0.so.0+0x77281)
#12 0x7f111f0af2a4 in g_test_run (/lib64/libglib-2.0.so.0+0x772a4)
#13 0x5618a2293859 in main /home/elmarco/src/qemu/tests/test-char.c:971
#14 0x7f111de11412 in __libc_start_main (/lib64/libc.so.6+0x24412)
#15 0x5618a2295c1d in _start
(/home/elmarco/src/qemu/build/tests/test-char+0x23ac1d)0x606000004198 is located 56 bytes inside of 64-byte region [0x606000004160,0x6060000041a0)
freed by thread T0 here:
#0 0x7f111f2f0480 in free (/lib64/libasan.so.5+0xef480)
#1 0x7f111f08ced1 in g_free (/lib64/libglib-2.0.so.0+0x54ed1)
#2 0x5618a243759f (/home/elmarco/src/qemu/build/tests/test-char+0x3dc59f)previously allocated by thread T0 here:
#0 0x7f111f2f0a50 in __interceptor_calloc (/lib64/libasan.so.5+0xefa50)
#1 0x7f111f08ce1d in g_malloc0 (/lib64/libglib-2.0.so.0+0x54e1d)SUMMARY: AddressSanitizer: heap-use-after-free /home/elmarco/src/qemu/io/task.c:91 in qio_task_thread_result Shadow bytes around the buggy address:
Quoted 127 lines
Quoted 126 lines
--- io/task.c | 53 ++++++++++++++++++++++++++++------------------------- 1 file changed, 28 insertions(+), 25 deletions(-)io/task.c +28
-26@@ -24,6 +24,14 @@#include "qemu/thread.h" #include "trace.h" +struct QIOTaskThreadData { +QIOTaskWorker worker; +gpointer opaque; +GDestroyNotify destroy; +GMainContext *context; +}; + +struct QIOTask {Object *source;QIOTaskFunc func;@@ -32,6 +40,7 @@ struct QIOTask {Error *err;gpointer result;GDestroyNotify destroyResult; +struct QIOTaskThreadData *thread; };@@ -72,31 +81,23 @@ static void qio_task_free(QIOTask *task) } -struct QIOTaskThreadData { -QIOTask *task; -QIOTaskWorker worker; -gpointer opaque; -GDestroyNotify destroy; -GMainContext *context; -}; - -static gboolean qio_task_thread_result (gpointer opaque) { -struct QIOTaskThreadData *data = opaque; +QIOTask *task = opaque; -trace_qio_task_thread_result (data->task); -qio_task_complete (data->task); +trace_qio_task_thread_result (task); +qio_task_complete (task); -if (data->destroy) { - data->destroy (data->opaque); +if (task->thread->destroy) { + task->thread->destroy (task->thread->opaque); } -if (data->context) { -g_main_context_unref (data->context); +if (task->thread->context) { +g_main_context_unref (task->thread->context); } -g_free (data); +g_free (task->thread); + task->thread =NULL ;return FALSE; }@@ -104,22 +105,23 @@ static gboolean qio_task_thread_result(gpointer opaque)static gpointer qio_task_thread_worker (gpointer opaque) { -struct QIOTaskThreadData *data = opaque; +QIOTask *task = opaque;GSource *idle; -trace_qio_task_thread_run (data->task); - data->worker (data->task, data->opaque); +trace_qio_task_thread_run (task); + + task->thread->worker (task, task->thread->opaque);/* We're running in the background thread, and must only * ever report the task results in the main event loop * thread. So we schedule an idle callback to report * the worker results */ -trace_qio_task_thread_exit (data->task); +trace_qio_task_thread_exit (task); idle =g_idle_source_new (); -g_source_set_callback (idle, qio_task_thread_result, data,NULL ); -g_source_attach (idle, data->context); +g_source_set_callback (idle, qio_task_thread_result, task,NULL ); +g_source_attach (idle, task->thread->context);return NULL ; }@@ -138,17 +140,18 @@ void qio_task_run_in_thread(QIOTask *task,g_main_context_ref (context); } - data->task = task; data->worker = worker; data->opaque = opaque; data->destroy = destroy; data->context = context; + task->thread = data; +trace_qio_task_thread_start (task, worker, opaque);qemu_thread_create (&thread,"io-task-worker" , qio_task_thread_worker, - data, + task,QEMU_THREAD_DETACHED ); } --2.20.1
Signature · 1 line
Marc-André Lureau
Re: [Qemu-devel] [PATCH v2 01/16] io: store reference to thread information in the QIOTask struct
Quoted 68 lines · Marc-André Lureau
Hi
Quoted 10 lines · Marc-André Lureau
Quoted 6 lines · Daniel P. Berrangé
Currently the struct QIOTaskThreadData is only needed by the worker thread, but a subsequent patch will need to access it from another context.
Signed-off-by Daniel P. Berrangé <[email protected]>Reviewed-by Marc-André Lureau <[email protected]>nack:
$ tests/test-char /char/null: OK /char/invalid: OK /char/ringbuf: OK /char/mux: OK /char/stdio: OK /char/pipe: OK /char/file: OK /char/file-fifo: OK /char/udp: OK /char/serial: OK /char/hotswap: OK /char/websocket: OK /char/socket/basic: OK /char/socket/reconnect: ================================================================= ==22150==ERROR: AddressSanitizer: heap-use-after-free on address 0x606000004198 at pc 0x5618a22be8d3 bp 0x7fffa43d8a80 sp 0x7fffa43d8a70 READ of size 8 at 0x606000004198 thread T0 #0 0x5618a22be8d2 in qio_task_thread_result /home/elmarco/src/qemu/io/task.c:91 #1 0x7f111f08397a (/lib64/libglib-2.0.so.0+0x4b97a) #2 0x7f111f08706c in g_main_context_dispatch (/lib64/libglib-2.0.so.0+0x4f06c) #3 0x5618a23969b7 in glib_pollfds_poll /home/elmarco/src/qemu/util/main-loop.c:215 #4 0x5618a23969b7 in os_host_main_loop_wait /home/elmarco/src/qemu/util/main-loop.c:238 #5 0x5618a23969b7 in main_loop_wait /home/elmarco/src/qemu/util/main-loop.c:497 #6 0x5618a2299786 in main_loop /home/elmarco/src/qemu/tests/test-char.c:27 #7 0x5618a229b651 in char_socket_test_common /home/elmarco/src/qemu/tests/test-char.c:355 #8 0x7f111f0aefc9 (/lib64/libglib-2.0.so.0+0x76fc9) #9 0x7f111f0aee83 (/lib64/libglib-2.0.so.0+0x76e83) #10 0x7f111f0aee83 (/lib64/libglib-2.0.so.0+0x76e83) #11 0x7f111f0af281 in g_test_run_suite (/lib64/libglib-2.0.so.0+0x77281) #12 0x7f111f0af2a4 in g_test_run (/lib64/libglib-2.0.so.0+0x772a4) #13 0x5618a2293859 in main /home/elmarco/src/qemu/tests/test-char.c:971 #14 0x7f111de11412 in __libc_start_main (/lib64/libc.so.6+0x24412) #15 0x5618a2295c1d in _start (/home/elmarco/src/qemu/build/tests/test-char+0x23ac1d)
0x606000004198is located 56 bytes inside of 64-byte region [0x606000004160,0x6060000041a0)
freed by thread T0 here:#0 0x7f111f2f0480 in free (/lib64/libasan.so.5+0xef480) #1 0x7f111f08ced1 in g_free (/lib64/libglib-2.0.so.0+0x54ed1) #2 0x5618a243759f (/home/elmarco/src/qemu/build/tests/test-char+0x3dc59f)
Quoted 7 lines
previously allocated by thread T0 here:
#0 0x7f111f2f0a50 in __interceptor_calloc (/lib64/libasan.so.5+0xefa50) #1 0x7f111f08ce1d in g_malloc0 (/lib64/libglib-2.0.so.0+0x54e1d)SUMMARY: AddressSanitizer: heap-use-after-free
/home/elmarco/src/qemu/io/task.c:91inqio_task_thread_resultShadow bytes around the buggy address:
FWIW, valgrind reports the same problem
Needs this change squashed in to fix it
io/task.c +12 -11
@@ -66,6 +66,18 @@ QIOTask *qio_task_new(Object *source,static void qio_task_free (QIOTask *task) { +if (task->thread) { +if (task->thread->destroy) { + task->thread->destroy (task->thread->opaque); + } + +if (task->thread->context) { +g_main_context_unref (task->thread->context); + } + +g_free (task->thread); + } +if (task->destroy) { task->destroy (task->opaque); }
@@ -88,17 +100,6 @@ static gboolean qio_task_thread_result(gpointer opaque)trace_qio_task_thread_result (task);qio_task_complete (task); -if (task->thread->destroy) { - task->thread->destroy (task->thread->opaque); - } - -if (task->thread->context) { -g_main_context_unref (task->thread->context); - } - -g_free (task->thread); - task->thread =NULL ; -return FALSE; }
Regards,
Daniel
Signature · 3 lines
|: https://berrange.com -o- https://www.flickr.com/photos/dberrange :| |: https://libvirt.org -o- https://fstop138.berrange.com :| |: https://entangle-photo.org -o- https://www.instagram.com/dberrange :|
PATCH v2 2/16 io: add qio_task_wait_thread to join with a background thread
In reply to Daniel P. BerrangéAdd the ability for a caller to wait for completion of the background thread to synchronously dispatch its result, without needing to wait for the main loop to run the idle callback.
This method needs very careful usage to avoid a dangerous race condition with the free'ing of the task. The completion callback is normally invoked from an idle callback registered with the main loop context. The qio_task_wait_thread method must only be called if the completion callback has not yet run. The only safe way to achieve this is to run the qio_task_wait_thread method from the thread that executes the main loop.
It is generally a bad idea to use this method since it will block execution of the main loop, however, the design of the character devices and its usage from vhostuser already requires blocking execution.
--- include/io/task.h | 29 ++++++++++++++++++++++++++++- io/task.c | 41 ++++++++++++++++++++++++++++++++++++----- io/trace-events | 2 ++ 3 files changed, 66 insertions(+), 6 deletions(-)
include/io/task.h +28 -1
@@ -232,7 +232,8 @@ QIOTask *qio_task_new(Object *source,* * Run a task in a background thread. When @worker * returns it will call qio_task_complete() in -* the event thread context that provided. +* the thread that is running the main loop associated +* with @context. */ void qio_task_run_in_thread(QIOTask *task, QIOTaskWorker worker,
@@ -240,6 +241,32 @@ void qio_task_run_in_thread(QIOTask *task,GDestroyNotify destroy, GMainContext *context); + +/** +* qio_task_wait_thread: +* @task: the task struct +* +* Wait for completion of a task that was previously +* invoked using qio_task_run_in_thread. This MUST +* ONLY be invoked if the task has not already +* completed, since after the completion callback +* is invoked, @task will have been freed. +* +* To avoid racing with execution of the completion +* callback provided with qio_task_new, this method +* MUST ONLY be invoked from the thread that is +* running the main loop associated with @context +* parameter to qio_task_run_in_thread. +* +* When the thread has completed, the completion +* callback provided to qio_task_new will be invoked. +* When that callback returns @task will be freed, +* so @task must not be referenced after this +* method completes. +*/ +void qio_task_wait_thread (QIOTask *task); + +/** * qio_task_complete: * @task: the task struct
io/task.c +36 -5
95 lines not on this page · raw message
io/trace-events +2 -0
@@ -7,6 +7,8 @@ qio_task_thread_start(void *task, void *worker, void *opaque) "Task thread start qio_task_thread_run(void *task) "Task thread run task=%p" qio_task_thread_exit(void *task) "Task thread exit task=%p" qio_task_thread_result(void *task) "Task thread result task=%p" +qio_task_thread_source_attach(void *task, void *source) "Task thread source attach task=%p source=%p" +qio_task_thread_source_cancel(void *task, void *source) "Task thread source cancel task=%p source=%p" # io/channel-socket.c qio_channel_socket_new(void *ioc) "Socket new ioc=%p"
Signature · 1 line
2.20.1
PATCH v2 3/16 chardev: fix validation of options for QMP created chardevs
In reply to Daniel P. BerrangéThe TLS creds option is not valid with certain address types. The user config was only checked for errors when parsing legacy QemuOpts, thus the user could pass unsupported values via QMP.
Pull all code for validating options out into a new method qmp_chardev_validate_socket, that is called from the main qmp_chardev_open_socket method. This adds a missing check for rejecting TLS creds with the vsock address type.
--- chardev/char-socket.c | 92 +++++++++++++++++++++++++++++++------------ 1 file changed, 66 insertions(+), 26 deletions(-)
chardev/char-socket.c +66 -26
@@ -987,6 +987,65 @@ static gboolean socket_reconnect_timeout(gpointer opaque)return false; } + +static bool qmp_chardev_validate_socket (ChardevSocket *sock, +SocketAddress *addr, +Error **errp) +{ +/* Validate any options which have a dependency on address type */ +switch (addr->type) { +case SOCKET_ADDRESS_TYPE_FD : +if (sock->has_reconnect) { +error_setg (errp, +"'reconnect' option is incompatible with " +"'fd' address type" ); +return false; + } +if (sock->has_tls_creds && + !(sock->has_server && sock->server)) { +error_setg (errp, +"'tls_creds' option is incompatible with " +"'fd' address type as client" ); +return false; + } +break ; + +case SOCKET_ADDRESS_TYPE_UNIX : +if (sock->has_tls_creds) { +error_setg (errp, +"'tls_creds' option is incompatible with " +"'unix' address type" ); +return false; + } +break ; + +case SOCKET_ADDRESS_TYPE_INET : +break ; + +case SOCKET_ADDRESS_TYPE_VSOCK : +if (sock->has_tls_creds) { +error_setg (errp, +"'tls_creds' option is incompatible with " +"'vsock' address type" ); +return false; + } + +default : +break ; + } + +/* Validate any options which have a dependancy on client vs server */ +if (!(sock->has_server && sock->server)) { +if (sock->has_websocket && sock->websocket) { +error_setg (errp,"%s" ,"Websocket client is not implemented" ); +return false; + } + } + +return true; +} + + static void qmp_chardev_open_socket(Chardev *chr, ChardevBackend *backend, bool *be_opened,
@@ -1004,11 +1063,6 @@ static void qmp_chardev_open_socket(Chardev *chr,QIOChannelSocket *sioc =NULL ;SocketAddress *addr; -if (!is_listen && is_websock) { -error_setg (errp,"%s" ,"Websocket client is not implemented" ); - goto error; - } - s->is_listen = is_listen; s->is_telnet = is_telnet; s->is_tn3270 = is_tn3270;
@@ -1049,10 +1103,10 @@ static void qmp_chardev_open_socket(Chardev *chr, s->addr = addr =socket_address_flatten (sock->addr); -if (sock->has_reconnect && addr->type ==SOCKET_ADDRESS_TYPE_FD ) { -error_setg (errp,"'reconnect' option is incompatible with 'fd'" ); +if (!qmp_chardev_validate_socket (sock, addr, errp)) { goto error; } +qemu_chr_set_feature (chr,QEMU_CHAR_FEATURE_RECONNECTABLE );/* TODO SOCKET_ADDRESS_FD where fd has AF_UNIX */ if (addr->type ==SOCKET_ADDRESS_TYPE_UNIX ) {
@@ -1140,27 +1194,12 @@ static void qemu_chr_parse_socket(QemuOpts *opts, ChardevBackend *backend,return ; } - backend->type =CHARDEV_BACKEND_KIND_SOCKET ; -if (path) { -if (tls_creds) { -error_setg (errp,"TLS can only be used over TCP socket" ); -return ; - } - }else if (host) { -if (!port) { -error_setg (errp,"chardev: socket: no port given" ); -return ; - } - }else if (fd) { -/* We don't know what host to validate against when in client mode */ -if (tls_creds && !is_listen) { -error_setg (errp,"TLS can not be used with pre-opened client FD" ); -return ; - } - }else { -g_assert_not_reached (); +if (host && !port) { +error_setg (errp,"chardev: socket: no port given" ); +return ; } + backend->type =CHARDEV_BACKEND_KIND_SOCKET ; sock = backend->u.socket.data =g_new0 (ChardevSocket,1 );qemu_chr_parse_common (opts,qapi_ChardevSocket_base (sock));
@@ -1178,6 +1217,7 @@ static void qemu_chr_parse_socket(QemuOpts *opts, ChardevBackend *backend, sock->wait = is_waitconnect; sock->has_reconnect =qemu_opt_find (opts,"reconnect" ); sock->reconnect = reconnect; + sock->has_tls_creds = tls_creds; sock->tls_creds =g_strdup (tls_creds); addr =g_new0 (SocketAddressLegacy,1 );
Signature · 1 line
2.20.1
PATCH v2 4/16 chardev: forbid 'reconnect' option with server sockets
In reply to Daniel P. BerrangéThe 'reconnect' option is used to give the sleep time, in seconds, before a client socket attempts to re-establish a connection to the server. It does not make sense to set this for server sockets, as they will always accept a new client connection immediately after the previous one went away.
--- chardev/char-socket.c | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-)
chardev/char-socket.c +8 -1
@@ -1035,7 +1035,14 @@ static bool qmp_chardev_validate_socket(ChardevSocket *sock, }/* Validate any options which have a dependancy on client vs server */ -if (!(sock->has_server && sock->server)) { +if (!sock->has_server || sock->server) { +if (sock->has_reconnect) { +error_setg (errp, +"'reconnect' option is incompatible with " +"socket in server listen mode" ); +return false; + } + }else {if (sock->has_websocket && sock->websocket) {error_setg (errp,"%s" ,"Websocket client is not implemented" );return false;
Signature · 1 line
2.20.1
PATCH v2 5/16 chardev: forbid 'wait' option with client sockets
In reply to Daniel P. BerrangéThe 'wait'/'nowait' parameter is used to tell server sockets whether to block until a client is accepted during initialization. Client chardevs have always silently ignored this option. Various tests were mistakenly passing this option for their client chardevs.
--- chardev/char-socket.c | 12 +++++++++++- tests/ivshmem-test.c | 2 +- tests/libqtest.c | 4 ++-- tests/test-filter-redirector.c | 4 ++-- 4 files changed, 16 insertions(+), 6 deletions(-)
chardev/char-socket.c +11 -1
@@ -1047,6 +1047,12 @@ static bool qmp_chardev_validate_socket(ChardevSocket *sock,error_setg (errp,"%s" ,"Websocket client is not implemented" );return false; } +if (sock->has_wait) { +error_setg (errp,"%s" , +"'wait' option is incompatible with " +"socket in client connect mode" ); +return false; + } }return true;
@@ -1220,7 +1226,11 @@ static void qemu_chr_parse_socket(QemuOpts *opts, ChardevBackend *backend, sock->tn3270 = is_tn3270; sock->has_websocket = true; sock->websocket = is_websock; - sock->has_wait = true; +/* +* We have different default to QMP for 'wait' when 'server' +* is set, hence we can't just check for existence of 'wait' +*/ + sock->has_wait =qemu_opt_find (opts,"wait" ) || is_listen; sock->wait = is_waitconnect; sock->has_reconnect =qemu_opt_find (opts,"reconnect" ); sock->reconnect = reconnect;
tests/ivshmem-test.c +1 -1
@@ -295,7 +295,7 @@ static void setup_vm_with_server(IVState *s, int nvectors) {char *cmd; - cmd =g_strdup_printf ("-chardev socket,id=chr0,path=%s,nowait " + cmd =g_strdup_printf ("-chardev socket,id=chr0,path=%s " "-device ivshmem-doorbell,chardev=chr0,vectors=%d" , tmpserver, nvectors);
tests/libqtest.c +2 -2
@@ -232,9 +232,9 @@ QTestState *qtest_init_without_qmp_handshake(const char *extra_args)qtest_add_abrt_handler (kill_qemu_hook_func, s); command =g_strdup_printf ("exec %s " -"-qtest unix:%s,nowait " +"-qtest unix:%s " "-qtest-log %s " -"-chardev socket,path=%s,nowait,id=char0 " +"-chardev socket,path=%s,id=char0 " "-mon chardev=char0,mode=control " "-machine accel=qtest " "-display none "
tests/test-filter-redirector.c +2 -2
@@ -96,7 +96,7 @@ static void test_redirector_tx(void)"-device %s,netdev=qtest-bn0,id=qtest-e0 " "-chardev socket,id=redirector0,path=%s,server,nowait " "-chardev socket,id=redirector1,path=%s,server,nowait " -"-chardev socket,id=redirector2,path=%s,nowait " +"-chardev socket,id=redirector2,path=%s " "-object filter-redirector,id=qtest-f0,netdev=qtest-bn0," "queue=tx,outdev=redirector0 " "-object filter-redirector,id=qtest-f1,netdev=qtest-bn0,"
@@ -166,7 +166,7 @@ static void test_redirector_rx(void)"-device %s,netdev=qtest-bn0,id=qtest-e0 " "-chardev socket,id=redirector0,path=%s,server,nowait " "-chardev socket,id=redirector1,path=%s,server,nowait " -"-chardev socket,id=redirector2,path=%s,nowait " +"-chardev socket,id=redirector2,path=%s " "-object filter-redirector,id=qtest-f0,netdev=qtest-bn0," "queue=rx,indev=redirector0 " "-object filter-redirector,id=qtest-f1,netdev=qtest-bn0,"
Signature · 1 line
2.20.1
PATCH v2 6/16 chardev: remove many local variables in qemu_chr_parse_socket
In reply to Daniel P. BerrangéNow that all validation is separated off into a separate method, we can directly populate the ChardevSocket struct from the QemuOpts values, avoiding many local variables.
--- chardev/char-socket.c | 40 ++++++++++++++++++---------------------- 1 file changed, 18 insertions(+), 22 deletions(-)
chardev/char-socket.c +18 -22
@@ -1186,18 +1186,10 @@ error:static void qemu_chr_parse_socket (QemuOpts *opts,ChardevBackend *backend,Error **errp) { -bool is_listen =qemu_opt_get_bool (opts,"server" , false); -bool is_waitconnect = is_listen &&qemu_opt_get_bool (opts,"wait" , true); -bool is_telnet =qemu_opt_get_bool (opts,"telnet" , false); -bool is_tn3270 =qemu_opt_get_bool (opts,"tn3270" , false); -bool is_websock =qemu_opt_get_bool (opts,"websocket" , false); -bool do_nodelay = !qemu_opt_get_bool (opts,"delay" , true); -int64_t reconnect =qemu_opt_get_number (opts,"reconnect" ,0 );const char *path =qemu_opt_get (opts,"path" );const char *host =qemu_opt_get (opts,"host" );const char *port =qemu_opt_get (opts,"port" );const char *fd =qemu_opt_get (opts,"fd" ); -const char *tls_creds =qemu_opt_get (opts,"tls-creds" );SocketAddressLegacy *addr;ChardevSocket *sock;
@@ -1216,26 +1208,30 @@ static void qemu_chr_parse_socket(QemuOpts *opts, ChardevBackend *backend, sock = backend->u.socket.data =g_new0 (ChardevSocket,1 );qemu_chr_parse_common (opts,qapi_ChardevSocket_base (sock)); - sock->has_nodelay = true; - sock->nodelay = do_nodelay; + sock->has_nodelay =qemu_opt_get (opts,"delay" ); + sock->nodelay = !qemu_opt_get_bool (opts,"delay" , true); +/* +* We have different default to QMP for 'server', hence +* we can't just check for existence of 'server' +*/ sock->has_server = true; - sock->server = is_listen; - sock->has_telnet = true; - sock->telnet = is_telnet; - sock->has_tn3270 = true; - sock->tn3270 = is_tn3270; - sock->has_websocket = true; - sock->websocket = is_websock; + sock->server =qemu_opt_get_bool (opts,"server" , false); + sock->has_telnet =qemu_opt_get (opts,"telnet" ); + sock->telnet =qemu_opt_get_bool (opts,"telnet" , false); + sock->has_tn3270 =qemu_opt_get (opts,"tn3270" ); + sock->tn3270 =qemu_opt_get_bool (opts,"tn3270" , false); + sock->has_websocket =qemu_opt_get (opts,"websocket" ); + sock->websocket =qemu_opt_get_bool (opts,"websocket" , false);/* * We have different default to QMP for 'wait' when 'server' * is set, hence we can't just check for existence of 'wait' */ - sock->has_wait =qemu_opt_find (opts,"wait" ) || is_listen; - sock->wait = is_waitconnect; + sock->has_wait =qemu_opt_find (opts,"wait" ) || sock->server; + sock->wait =qemu_opt_get_bool (opts,"wait" , true); sock->has_reconnect =qemu_opt_find (opts,"reconnect" ); - sock->reconnect = reconnect; - sock->has_tls_creds = tls_creds; - sock->tls_creds =g_strdup (tls_creds); + sock->reconnect =qemu_opt_get_number (opts,"reconnect" ,0 ); + sock->has_tls_creds =qemu_opt_get (opts,"tls-creds" ); + sock->tls_creds =g_strdup (qemu_opt_get (opts,"tls-creds" )); addr =g_new0 (SocketAddressLegacy,1 );if (path) {
Signature · 1 line
2.20.1
PATCH v2 7/16 chardev: ensure qemu_chr_parse_compat reports missing driver error
In reply to Daniel P. BerrangéIf no valid char driver was identified the qemu_chr_parse_compat method was silent, leaving callers no clue what failed.
--- chardev/char.c | 2 ++ tests/test-char.c | 3 ++- 2 files changed, 4 insertions(+), 1 deletion(-)
chardev/char.c +2 -0
@@ -490,6 +490,8 @@ QemuOpts *qemu_chr_parse_compat(const char *label, const char *filename,return opts; } +error_report ("'%s' is not a valid char driver" , filename); + fail:qemu_opts_del (opts);return NULL ;
tests/test-char.c +2 -1
@@ -856,9 +856,10 @@ static void char_null_test(void)static void char_invalid_test (void ) {Chardev *chr; - +setenv ("QTEST_SILENT_ERRORS" ,"1" ,1 ); chr =qemu_chr_new ("label-invalid" ,"invalid" );g_assert_null (chr); +unsetenv ("QTEST_SILENT_ERRORS" ); }static int chardev_change (void *opaque)
Signature · 1 line
2.20.1
PATCH v2 8/16 chardev: remove unused 'sioc' variable & cleanup paths
In reply to Daniel P. BerrangéThe 'sioc' variable in qmp_chardev_open_socket was unused since
commit 3e7d4d20d3a528b1ed10b1dc3d83119bfb0c5f24
Author: Peter Xu <[email protected]>
Date: Tue Mar 6 13:33:17 2018 +0800
chardev: use chardev's gcontext for async connect
--- chardev/char-socket.c | 22 +++++++--------------- 1 file changed, 7 insertions(+), 15 deletions(-)
chardev/char-socket.c +7 -15
@@ -1073,7 +1073,6 @@ static void qmp_chardev_open_socket(Chardev *chr,bool is_waitconnect = sock->has_wait ? sock->wait : false;bool is_websock = sock->has_websocket ? sock->websocket : false;int64_t reconnect = sock->has_reconnect ? sock->reconnect :0 ; -QIOChannelSocket *sioc =NULL ;SocketAddress *addr; s->is_listen = is_listen;
@@ -1088,7 +1087,7 @@ static void qmp_chardev_open_socket(Chardev *chr,if (!creds) {error_setg (errp,"No TLS credentials with id '%s'" , sock->tls_creds); - goto error; +return ; } s->tls_creds = (QCryptoTLSCreds *) object_dynamic_cast(creds,
@@ -1096,20 +1095,20 @@ static void qmp_chardev_open_socket(Chardev *chr,if (!s->tls_creds) {error_setg (errp,"Object with id '%s' is not TLS credentials" , sock->tls_creds); - goto error; +return ; }object_ref (OBJECT (s->tls_creds));if (is_listen) {if (s->tls_creds->endpoint !=QCRYPTO_TLS_CREDS_ENDPOINT_SERVER ) {error_setg (errp,"%s" ,"Expected TLS credentials for server endpoint" ); - goto error; +return ; } }else {if (s->tls_creds->endpoint !=QCRYPTO_TLS_CREDS_ENDPOINT_CLIENT ) {error_setg (errp,"%s" ,"Expected TLS credentials for client endpoint" ); - goto error; +return ; } } }
@@ -1117,7 +1116,7 @@ static void qmp_chardev_open_socket(Chardev *chr, s->addr = addr =socket_address_flatten (sock->addr);if (!qmp_chardev_validate_socket (sock, addr, errp)) { - goto error; +return ; }qemu_chr_set_feature (chr,QEMU_CHAR_FEATURE_RECONNECTABLE );
@@ -1153,7 +1152,7 @@ static void qmp_chardev_open_socket(Chardev *chr,if (qio_net_listener_open_sync (s->listener, s->addr, errp) <0 ) {object_unref (OBJECT (s->listener)); s->listener =NULL ; - goto error; +return ; }qapi_free_SocketAddress (s->addr);
@@ -1171,16 +1170,9 @@ static void qmp_chardev_open_socket(Chardev *chr, chr->gcontext); } }else if (qemu_chr_wait_connected (chr, errp) <0 ) { - goto error; +return ; } } - -return ; - -error: -if (sioc) { -object_unref (OBJECT (sioc)); - } } static void qemu_chr_parse_socket(QemuOpts *opts, ChardevBackend *backend,
Signature · 1 line
2.20.1
PATCH v2 9/16 chardev: split tcp_chr_wait_connected into two methods
In reply to Daniel P. BerrangéThe tcp_chr_wait_connected method can deal with either server or client chardevs, but some callers only care about one of these possibilities. The tcp_chr_wait_connected method will also need some refactoring to reliably deal with its primary goal of allowing a device frontend to wait for an established connection, which will interfere with other callers.
Split it into two methods, one responsible for server initiated connections, the other responsible for client initiated connections. In doing this split the tcp_char_connect_async() method is renamed to become consistent with naming of the new methods.
--- chardev/char-socket.c | 59 +++++++++++++++++++++++++++---------------- 1 file changed, 37 insertions(+), 22 deletions(-)
chardev/char-socket.c +37 -22
@@ -886,30 +886,47 @@ static void tcp_chr_accept(QIONetListener *listener,tcp_chr_new_client (chr, cioc); } -static int tcp_chr_wait_connected (Chardev *chr,Error **errp) + +static int tcp_chr_connect_client_sync (Chardev *chr,Error **errp) +{ +SocketChardev *s =SOCKET_CHARDEV (chr); +QIOChannelSocket *sioc =qio_channel_socket_new (); +tcp_chr_set_client_ioc_name (chr, sioc); +if (qio_channel_socket_connect_sync (sioc, s->addr, errp) <0 ) { +object_unref (OBJECT (sioc)); +return -1 ; + } +tcp_chr_new_client (chr, sioc); +object_unref (OBJECT (sioc)); +return 0 ; +} + + +static void tcp_chr_accept_server_sync (Chardev *chr) {SocketChardev *s =SOCKET_CHARDEV (chr);QIOChannelSocket *sioc; +info_report ("QEMU waiting for connection on: %s" , + chr->filename); + sioc =qio_net_listener_wait_client (s->listener); +tcp_chr_set_client_ioc_name (chr, sioc); +tcp_chr_new_client (chr, sioc); +object_unref (OBJECT (sioc)); +} + +static int tcp_chr_wait_connected (Chardev *chr,Error **errp) +{ +SocketChardev *s =SOCKET_CHARDEV (chr);/* It can't wait on s->connected, since it is set asynchronously * in TLS and telnet cases, only wait for an accepted socket */ while (!s->ioc) {if (s->is_listen) { -info_report ("QEMU waiting for connection on: %s" , - chr->filename); - sioc =qio_net_listener_wait_client (s->listener); -tcp_chr_set_client_ioc_name (chr, sioc); -tcp_chr_new_client (chr, sioc); -object_unref (OBJECT (sioc)); +tcp_chr_accept_server_sync (chr); }else { - sioc =qio_channel_socket_new (); -tcp_chr_set_client_ioc_name (chr, sioc); -if (qio_channel_socket_connect_sync (sioc, s->addr, errp) <0 ) { -object_unref (OBJECT (sioc)); +if (tcp_chr_connect_client_sync (chr, errp) <0 ) {return -1 ; } -tcp_chr_new_client (chr, sioc); -object_unref (OBJECT (sioc)); } }
@@ -958,7 +975,7 @@ cleanup:object_unref (OBJECT (sioc)); } -static void tcp_chr_connect_async (Chardev *chr) +static void tcp_chr_connect_client_async (Chardev *chr) {SocketChardev *s =SOCKET_CHARDEV (chr);QIOChannelSocket *sioc;
@@ -982,7 +999,7 @@ static gboolean socket_reconnect_timeout(gpointer opaque)return false; } -tcp_chr_connect_async (chr); +tcp_chr_connect_client_async (chr);return false; }
@@ -1139,7 +1156,7 @@ static void qmp_chardev_open_socket(Chardev *chr, }if (s->reconnect_time) { -tcp_chr_connect_async (chr); +tcp_chr_connect_client_async (chr); }else {if (s->is_listen) {char *name;
@@ -1159,17 +1176,15 @@ static void qmp_chardev_open_socket(Chardev *chr, s->addr =socket_local_address (s->listener->sioc[0 ]->fd, errp);update_disconnected_filename (s); -if (is_waitconnect && -qemu_chr_wait_connected (chr, errp) <0 ) { -return ; - } -if (!s->ioc) { +if (is_waitconnect) { +tcp_chr_accept_server_sync (chr); + }else {qio_net_listener_set_client_func_full (s->listener, tcp_chr_accept, chr,NULL , chr->gcontext); } - }else if (qemu_chr_wait_connected (chr, errp) <0 ) { + }else if (tcp_chr_connect_client_sync (chr, errp) <0 ) {return ; } }
Signature · 1 line
2.20.1
PATCH v2 10/16 chardev: split up qmp_chardev_open_socket connection code
In reply to Daniel P. BerrangéIn qmp_chardev_open_socket the code for connecting client chardevs is split across two conditionals far apart with some server chardev code in the middle. Split up the method so that code for client connection setup is separate from code for server connection setup.
--- chardev/char-socket.c | 96 +++++++++++++++++++++++++++---------------- 1 file changed, 60 insertions(+), 36 deletions(-)
chardev/char-socket.c +60 -36
@@ -1005,6 +1005,61 @@ static gboolean socket_reconnect_timeout(gpointer opaque) } +static int qmp_chardev_open_socket_server (Chardev *chr, +bool is_telnet, +bool is_waitconnect, +Error **errp) +{ +SocketChardev *s =SOCKET_CHARDEV (chr); +char *name; +if (is_telnet) { + s->do_telnetopt =1 ; + } + s->listener =qio_net_listener_new (); + + name =g_strdup_printf ("chardev-tcp-listener-%s" , chr->label); +qio_net_listener_set_name (s->listener, name); +g_free (name); + +if (qio_net_listener_open_sync (s->listener, s->addr, errp) <0 ) { +object_unref (OBJECT (s->listener)); + s->listener =NULL ; +return -1 ; + } + +qapi_free_SocketAddress (s->addr); + s->addr =socket_local_address (s->listener->sioc[0 ]->fd, errp); +update_disconnected_filename (s); + +if (is_waitconnect) { +tcp_chr_accept_server_sync (chr); + }else { +qio_net_listener_set_client_func_full (s->listener, + tcp_chr_accept, + chr,NULL , + chr->gcontext); + } + +return 0 ; +} + + +static int qmp_chardev_open_socket_client (Chardev *chr, +int64_t reconnect, +Error **errp) +{ +SocketChardev *s =SOCKET_CHARDEV (chr); + +if (reconnect >0 ) { + s->reconnect_time = reconnect; +tcp_chr_connect_client_async (chr); +return 0 ; + }else { +return tcp_chr_connect_client_sync (chr, errp); + } +} + +static bool qmp_chardev_validate_socket (ChardevSocket *sock,SocketAddress *addr,Error **errp)
@@ -1147,44 +1202,13 @@ static void qmp_chardev_open_socket(Chardev *chr,update_disconnected_filename (s); -if (is_listen) { -if (is_telnet || is_tn3270) { - s->do_telnetopt =1 ; +if (s->is_listen) { +if (qmp_chardev_open_socket_server (chr, is_telnet || is_tn3270, + is_waitconnect, errp) <0 ) { +return ; } - }else if (reconnect >0 ) { - s->reconnect_time = reconnect; - } - -if (s->reconnect_time) { -tcp_chr_connect_client_async (chr); }else { -if (s->is_listen) { -char *name; - s->listener =qio_net_listener_new (); - - name =g_strdup_printf ("chardev-tcp-listener-%s" , chr->label); -qio_net_listener_set_name (s->listener, name); -g_free (name); - -if (qio_net_listener_open_sync (s->listener, s->addr, errp) <0 ) { -object_unref (OBJECT (s->listener)); - s->listener =NULL ; -return ; - } - -qapi_free_SocketAddress (s->addr); - s->addr =socket_local_address (s->listener->sioc[0 ]->fd, errp); -update_disconnected_filename (s); - -if (is_waitconnect) { -tcp_chr_accept_server_sync (chr); - }else { -qio_net_listener_set_client_func_full (s->listener, - tcp_chr_accept, - chr,NULL , - chr->gcontext); - } - }else if (tcp_chr_connect_client_sync (chr, errp) <0 ) { +if (qmp_chardev_open_socket_client (chr, reconnect, errp) <0 ) {return ; } }
Signature · 1 line
2.20.1
PATCH v2 11/16 chardev: use a state machine for socket connection state
In reply to Daniel P. BerrangéThe socket connection state is indicated via the 'bool connected' field in the SocketChardev struct. This variable is somewhat misleading though, as it is only set to true once the connection has completed all required handshakes (eg for TLS, telnet or websockets). IOW there is a period of time in which the socket is connected, but the "connected" flag is still false.
The socket chardev really has three states that it can be in, disconnected, connecting and connected and those should be tracked explicitly.
--- chardev/char-socket.c | 63 +++++++++++++++++++++++++++++++++---------- 1 file changed, 49 insertions(+), 14 deletions(-)
chardev/char-socket.c +49 -14
@@ -46,6 +46,12 @@ typedef struct {size_t buflen; } TCPChardevTelnetInit; +typedef enum { +TCP_CHARDEV_STATE_DISCONNECTED , +TCP_CHARDEV_STATE_CONNECTING , +TCP_CHARDEV_STATE_CONNECTED , +}TCPChardevState ; + typedef struct { Chardev parent; QIOChannel *ioc; /* Client I/O channel */
@@ -53,7 +59,7 @@ typedef struct {QIONetListener *listener;GSource *hup_source;QCryptoTLSCreds *tls_creds; -int connected; +TCPChardevState state;int max_size;int do_telnetopt;int do_nodelay;
@@ -82,6 +88,21 @@ typedef struct {static gboolean socket_reconnect_timeout (gpointer opaque);static void tcp_chr_telnet_init (Chardev *chr); +static void tcp_chr_change_state (SocketChardev *s,TCPChardevState state) +{ +switch (state) { +case TCP_CHARDEV_STATE_DISCONNECTED : +break ; +case TCP_CHARDEV_STATE_CONNECTING : +assert (s->state ==TCP_CHARDEV_STATE_DISCONNECTED ); +break ; +case TCP_CHARDEV_STATE_CONNECTED : +assert (s->state ==TCP_CHARDEV_STATE_CONNECTING ); +break ; + } + s->state = state; +} +static void tcp_chr_reconn_timer_cancel (SocketChardev *s) {if (s->reconnect_timer) {
@@ -96,7 +117,7 @@ static void qemu_chr_socket_restart_timer(Chardev *chr)SocketChardev *s =SOCKET_CHARDEV (chr);char *name; -assert (s->connected ==0 ); +assert (s->state ==TCP_CHARDEV_STATE_DISCONNECTED ); name =g_strdup_printf ("chardev-socket-reconnect-%s" , chr->label); s->reconnect_timer = qemu_chr_timeout_add_ms(chr, s->reconnect_time * 1000,
@@ -131,7 +152,7 @@ static int tcp_chr_write(Chardev *chr, const uint8_t *buf, int len) {SocketChardev *s =SOCKET_CHARDEV (chr); -if (s->connected) { +if (s->state ==TCP_CHARDEV_STATE_CONNECTED ) {int ret =io_channel_send_full (s->ioc, buf, len, s->write_msgfds, s->write_msgfds_num);
@@ -164,7 +185,7 @@ static int tcp_chr_read_poll(void *opaque) {Chardev *chr =CHARDEV (opaque);SocketChardev *s =SOCKET_CHARDEV (opaque); -if (!s->connected) { +if (s->state !=TCP_CHARDEV_STATE_CONNECTED ) {return 0 ; } s->max_size =qemu_chr_be_can_write (chr);
@@ -277,7 +298,7 @@ static int tcp_set_msgfds(Chardev *chr, int *fds, int num) s->write_msgfds =NULL ; s->write_msgfds_num =0 ; -if (!s->connected || +if ((s->state !=TCP_CHARDEV_STATE_CONNECTED ) || !qio_channel_has_feature (s->ioc,QIO_CHANNEL_FEATURE_FD_PASS )) {return -1 ;
@@ -389,7 +410,7 @@ static void tcp_chr_free_connection(Chardev *chr) s->ioc =NULL ;g_free (chr->filename); chr->filename =NULL ; - s->connected =0 ; +tcp_chr_change_state (s,TCP_CHARDEV_STATE_DISCONNECTED ); }static const char *qemu_chr_socket_protocol (SocketChardev *s)
@@ -442,12 +463,12 @@ static void update_disconnected_filename(SocketChardev *s)/* NB may be called even if tcp_chr_connect has not been * reached, due to TLS or telnet initialization failure, -* so can *not* assume s->connected == true +* so can *not* assume s->state == TCP_CHARDEV_STATE_CONNECTED */ static void tcp_chr_disconnect (Chardev *chr) {SocketChardev *s =SOCKET_CHARDEV (chr); -bool emit_close = s->connected; +bool emit_close = s->state ==TCP_CHARDEV_STATE_CONNECTED ;tcp_chr_free_connection (chr);
@@ -471,7 +492,8 @@ static gboolean tcp_chr_read(QIOChannel *chan, GIOCondition cond, void *opaque)uint8_t buf[CHR_READ_BUF_LEN ];int len, size; -if (!s->connected || s->max_size <=0 ) { +if ((s->state !=TCP_CHARDEV_STATE_CONNECTED ) || + s->max_size <=0 ) {return TRUE; } len =sizeof (buf);
@@ -508,7 +530,7 @@ static int tcp_chr_sync_read(Chardev *chr, const uint8_t *buf, int len)SocketChardev *s =SOCKET_CHARDEV (chr);int size; -if (!s->connected) { +if (s->state !=TCP_CHARDEV_STATE_CONNECTED ) {return 0 ; }
@@ -564,7 +586,7 @@ static void update_ioc_handlers(SocketChardev *s) {Chardev *chr =CHARDEV (s); -if (!s->connected) { +if (s->state !=TCP_CHARDEV_STATE_CONNECTED ) {return ; }
@@ -589,7 +611,7 @@ static void tcp_chr_connect(void *opaque)g_free (chr->filename); chr->filename =qemu_chr_compute_filename (s); - s->connected =1 ; +tcp_chr_change_state (s,TCP_CHARDEV_STATE_CONNECTED );update_ioc_handlers (s);qemu_chr_be_event (chr,CHR_EVENT_OPENED ); }
@@ -828,7 +850,7 @@ static int tcp_chr_new_client(Chardev *chr, QIOChannelSocket *sioc) {SocketChardev *s =SOCKET_CHARDEV (chr); -if (s->ioc !=NULL ) { +if (s->state !=TCP_CHARDEV_STATE_CONNECTING ) {return -1 ; }
@@ -865,11 +887,17 @@ static int tcp_chr_add_client(Chardev *chr, int fd) {int ret;QIOChannelSocket *sioc; +SocketChardev *s =SOCKET_CHARDEV (chr); + +if (s->state !=TCP_CHARDEV_STATE_DISCONNECTED ) { +return -1 ; + } sioc =qio_channel_socket_new_fd (fd,NULL );if (!sioc) {return -1 ; } +tcp_chr_change_state (s,TCP_CHARDEV_STATE_CONNECTING );tcp_chr_set_client_ioc_name (chr, sioc); ret =tcp_chr_new_client (chr, sioc);object_unref (OBJECT (sioc));
@@ -881,7 +909,9 @@ static void tcp_chr_accept(QIONetListener *listener, void *opaque) {Chardev *chr =CHARDEV (opaque); +SocketChardev *s =SOCKET_CHARDEV (chr); +tcp_chr_change_state (s,TCP_CHARDEV_STATE_CONNECTING );tcp_chr_set_client_ioc_name (chr, cioc);tcp_chr_new_client (chr, cioc); }
@@ -891,8 +921,10 @@ static int tcp_chr_connect_client_sync(Chardev *chr, Error **errp) {SocketChardev *s =SOCKET_CHARDEV (chr);QIOChannelSocket *sioc =qio_channel_socket_new (); +tcp_chr_change_state (s,TCP_CHARDEV_STATE_CONNECTING );tcp_chr_set_client_ioc_name (chr, sioc);if (qio_channel_socket_connect_sync (sioc, s->addr, errp) <0 ) { +tcp_chr_change_state (s,TCP_CHARDEV_STATE_DISCONNECTED );object_unref (OBJECT (sioc));return -1 ; }
@@ -908,6 +940,7 @@ static void tcp_chr_accept_server_sync(Chardev *chr)QIOChannelSocket *sioc;info_report ("QEMU waiting for connection on: %s" , chr->filename); +tcp_chr_change_state (s,TCP_CHARDEV_STATE_CONNECTING ); sioc =qio_net_listener_wait_client (s->listener);tcp_chr_set_client_ioc_name (chr, sioc);tcp_chr_new_client (chr, sioc);
@@ -963,6 +996,7 @@ static void qemu_chr_socket_connected(QIOTask *task, void *opaque)Error *err =NULL ;if (qio_task_propagate_error (task, &err)) { +tcp_chr_change_state (s,TCP_CHARDEV_STATE_DISCONNECTED );check_report_connect_error (chr, err);error_free (err); goto cleanup;
@@ -980,6 +1014,7 @@ static void tcp_chr_connect_client_async(Chardev *chr)SocketChardev *s =SOCKET_CHARDEV (chr);QIOChannelSocket *sioc; +tcp_chr_change_state (s,TCP_CHARDEV_STATE_CONNECTING ); sioc =qio_channel_socket_new ();tcp_chr_set_client_ioc_name (chr, sioc); qio_channel_socket_connect_async(sioc, s->addr,
@@ -1307,7 +1342,7 @@ char_socket_get_connected(Object *obj, Error **errp) {SocketChardev *s =SOCKET_CHARDEV (obj); -return s->connected; +return s->state ==TCP_CHARDEV_STATE_CONNECTED ; }static void char_socket_class_init (ObjectClass *oc,void *data)
Signature · 1 line
2.20.1
PATCH v2 12/16 chardev: honour the reconnect setting in tcp_chr_wait_connected
In reply to Daniel P. BerrangéIf establishing a client connection fails, the tcp_chr_wait_connected method should sleep for the reconnect timeout and then retry the attempt. This ensures the callers don't immediately abort with an error when the initial connection fails.
--- chardev/char-socket.c | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-)
chardev/char-socket.c +9 -2
@@ -957,8 +957,15 @@ static int tcp_chr_wait_connected(Chardev *chr, Error **errp)if (s->is_listen) {tcp_chr_accept_server_sync (chr); }else { -if (tcp_chr_connect_client_sync (chr, errp) <0 ) { -return -1 ; +Error *err =NULL ; +if (tcp_chr_connect_client_sync (chr, &err) <0 ) { +if (s->reconnect_time) { +error_free (err); +g_usleep (s->reconnect_time *1000ULL *1000ULL ); + }else { +error_propagate (errp, err); +return -1 ; + } } } }
Signature · 1 line
2.20.1
PATCH v2 13/16 chardev: disallow TLS/telnet/websocket with tcp_chr_wait_connected
In reply to Daniel P. BerrangéIn the previous commit
commit 1dc8a6695c731abb7461c637b2512c3670d82be4
Author: Marc-André Lureau <[email protected]>
Date: Tue Aug 16 12:33:32 2016 +0400
char: fix waiting for TLS and telnet connection
the tcp_chr_wait_connected() method was changed to check for a non-NULL 's->ioc' as a sign that there is already a connection present, as opposed to checking the "connected" flag to supposedly fix handling of TLS/telnet connections.
The original code would repeatedly call tcp_chr_wait_connected creating many connections as 'connected' would never become true. The changed code would still repeatedly call tcp_chr_wait_connected busy waiting because s->ioc is set but the chardev will never see CHR_EVENT_OPENED. IOW, the code is still broken with TLS/telnet, but in a different way.
Checking for a non-NULL 's->ioc' does not mean that a CHR_EVENT_OPENED will be ready for a TLS/telnet connection. These protocols (and the websocket protocol) all require the main loop to be running in order to complete the protocol handshake before emitting CHR_EVENT_OPENED. The tcp_chr_wait_connected() method is only used during early startup before a main loop is running, so TLS/telnet/websock connections can never complete initialization.
Making this work would require changing tcp_chr_wait_connected to run a main loop. This is quite complex since we must not allow GSource's that other parts of QEMU have registered to run yet. The current callers of tcp_chr_wait_connected do not require use of the TLS/telnet/websocket protocols, so the simplest option is to just forbid this combination completely for now.
--- chardev/char-socket.c | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-)
chardev/char-socket.c +14 -2
@@ -951,8 +951,20 @@ static void tcp_chr_accept_server_sync(Chardev *chr)static int tcp_chr_wait_connected (Chardev *chr,Error **errp) {SocketChardev *s =SOCKET_CHARDEV (chr); -/* It can't wait on s->connected, since it is set asynchronously -* in TLS and telnet cases, only wait for an accepted socket */ +const char *opts[] = {"telnet" ,"tn3270" ,"websock" ,"tls-creds" }; +bool optset[] = { s->is_telnet, s->is_tn3270, s->is_websock, s->tls_creds }; +size_t i; + +QEMU_BUILD_BUG_ON (G_N_ELEMENTS (opts) !=G_N_ELEMENTS (optset)); +for (i =0 ; i <G_N_ELEMENTS (opts); i++) { +if (optset[i]) { +error_setg (errp, +"'%s' option is incompatible with waiting for " +"connection completion" , opts[i]); +return -1 ; + } + } +while (!s->ioc) {if (s->is_listen) {tcp_chr_accept_server_sync (chr);
Signature · 1 line
2.20.1
PATCH v2 14/16 chardev: fix race with client connections in tcp_chr_wait_connected
In reply to Daniel P. BerrangéWhen the 'reconnect' option is given for a client connection, the qmp_chardev_open_socket_client method will run an asynchronous connection attempt. The QIOChannel socket executes this is a single use background thread, so the connection will succeed immediately (assuming the server is listening). The chardev, however, won't get the result from this background thread until the main loop starts running and processes idle callbacks.
Thus when tcp_chr_wait_connected is run s->ioc will be NULL, but the state will be TCP_CHARDEV_STATE_CONNECTING, and there may already be an established connection that will be associated with the chardev by the pending idle callback. tcp_chr_wait_connected doesn't check the state, only s->ioc, so attempts to establish another connection synchronously.
If the server allows multiple connections this is unhelpful but not a fatal problem as the duplicate connection will get ignored by the tcp_chr_new_client method when it sees the state is already connected.
If the server only supports a single connection, however, the tcp_chr_wait_connected method will hang forever because the server will not accept its synchronous connection attempt until the first connection is closed.
To deal with this tcp_chr_wait_connected needs to synchronize with the completion of the background connection task. To do this it needs to create the QIOTask directly and use the qio_task_wait_thread method. This will cancel the pending idle callback and directly dispatch the task completion callback, allowing the connection to be associated with the chardev. If the background connection failed, it can still attempt a new synchronous connection.
--- chardev/char-socket.c | 87 +++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 83 insertions(+), 4 deletions(-)
chardev/char-socket.c +83 -4
@@ -80,6 +80,8 @@ typedef struct {GSource *reconnect_timer;int64_t reconnect_time;bool connect_err_reported; + +QIOTask *connect_task; } SocketChardev;#define SOCKET_CHARDEV (obj) \
@@ -965,7 +967,54 @@ static int tcp_chr_wait_connected(Chardev *chr, Error **errp) } } -while (!s->ioc) { +/* +* We expect states to be as follows: +* +* - server +* - wait -> CONNECTED +* - nowait -> DISCONNECTED +* - client +* - reconnect == 0 -> CONNECTED +* - reconnect != 0 -> CONNECTING +* +*/ +if (s->state ==TCP_CHARDEV_STATE_CONNECTING ) { +if (!s->connect_task) { +error_setg (errp, +"Unexpected 'connecting' state without connect task " +"while waiting for connection completion" ); +return -1 ; + } +/* +* tcp_chr_wait_connected should only ever be run from the +* main loop thread associated with chr->gcontext, otherwise +* qio_task_wait_thread has a dangerous race condition with +* free'ing of the s->connect_task object. +* +* Acquiring the main context doesn't 100% prove we're in +* the main loop thread, but it does at least guarantee +* that the main loop won't be executed by another thread +* avoiding the race condition with the task idle callback. +*/ +g_main_context_acquire (chr->gcontext); +qio_task_wait_thread (s->connect_task); +g_main_context_release (chr->gcontext); + +/* +* The completion callback (qemu_chr_socket_connected) for +* s->connect_task should have set this to NULL by the time +* qio_task_wait_thread has returned. +*/ +assert (!s->connect_task); + +/* +* NB we are *not* guaranteed to have "s->state == ..CONNECTED" +* at this point as this first connect may be failed, so +* allow the next loop to run regardless. +*/ + } + +while (s->state !=TCP_CHARDEV_STATE_CONNECTED ) {if (s->is_listen) {tcp_chr_accept_server_sync (chr); }else {
@@ -1014,6 +1063,8 @@ static void qemu_chr_socket_connected(QIOTask *task, void *opaque)SocketChardev *s =SOCKET_CHARDEV (chr);Error *err =NULL ; + s->connect_task =NULL ; +if (qio_task_propagate_error (task, &err)) {tcp_chr_change_state (s,TCP_CHARDEV_STATE_DISCONNECTED );check_report_connect_error (chr, err);
@@ -1028,6 +1079,20 @@ cleanup:object_unref (OBJECT (sioc)); } + +static void tcp_chr_connect_client_task (QIOTask *task, +gpointer opaque) +{ +QIOChannelSocket *ioc =QIO_CHANNEL_SOCKET (qio_task_get_source (task)); +SocketAddress *addr = opaque; +Error *err =NULL ; + +qio_channel_socket_connect_sync (ioc, addr, &err); + +qio_task_set_error (task, err); +} + +static void tcp_chr_connect_client_async (Chardev *chr) {SocketChardev *s =SOCKET_CHARDEV (chr);
@@ -1036,9 +1101,23 @@ static void tcp_chr_connect_client_async(Chardev *chr)tcp_chr_change_state (s,TCP_CHARDEV_STATE_CONNECTING ); sioc =qio_channel_socket_new ();tcp_chr_set_client_ioc_name (chr, sioc); -qio_channel_socket_connect_async (sioc, s->addr, - qemu_chr_socket_connected, - chr,NULL , chr->gcontext); +/* +* Normally code would use the qio_channel_socket_connect_async +* method which uses a QIOTask + qio_task_set_error internally +* to avoid blocking. The tcp_chr_wait_connected method, however, +* needs a way to synchronize with completion of the background +* connect task which can't be done with the QIOChannelSocket +* async APIs. Thus we must use QIOTask directly to implement +* the non-blocking concept locally. +*/ + s->connect_task =qio_task_new (OBJECT (sioc), + qemu_chr_socket_connected, + chr,NULL ); +qio_task_run_in_thread (s->connect_task, + tcp_chr_connect_client_task, + s->addr, +NULL , + chr->gcontext); }static gboolean socket_reconnect_timeout (gpointer opaque)
Signature · 1 line
2.20.1
PATCH v2 15/16 tests: expand coverage of socket chardev test
In reply to Daniel P. BerrangéThe current socket chardev tests try to exercise the chardev socket driver in both server and client mode at the same time. The chardev API is not very well designed to handle both ends of the connection being in the same process so this approach makes the test case quite unpleasant to deal with.
This splits the tests into distinct cases, one to test server socket chardevs and one to test client socket chardevs. In each case the peer is run in a background thread using the simpler QIOChannelSocket APIs. The main test case code can now be written in a way that mirrors the typical usage from within QEMU.
In doing this recfactoring it is possible to greatly expand the test coverage for the socket chardevs to test all combinations except for a server operating in blocking wait mode.
--- tests/test-char.c | 640 ++++++++++++++++++++++++++++++++++------------ 1 file changed, 475 insertions(+), 165 deletions(-)
tests/test-char.c +475 -165
@@ -11,6 +11,9 @@#include "qapi/qapi-commands-char.h" #include "qapi/qmp/qdict.h" #include "qom/qom-qobject.h" +#include "io/channel-socket.h" +#include "qapi/qobject-input-visitor.h" +#include "qapi/qapi-visit-sockets.h" static bool quit;
@@ -257,168 +260,6 @@ static void char_mux_test(void)qemu_chr_fe_deinit (&chr_be2, true); } -typedef struct SocketIdleData { -GMainLoop *loop; -Chardev *chr; -bool conn_expected; -CharBackend *be; -CharBackend *client_be; -}SocketIdleData ; - -static gboolean char_socket_test_idle (gpointer user_data) -{ -SocketIdleData *data = user_data; - -if (object_property_get_bool (OBJECT (data->chr),"connected" ,NULL ) - == data->conn_expected) { - quit = true; -return FALSE; - } - -return TRUE; -} - -static void socket_read (void *opaque,const uint8_t *buf,int size) -{ -SocketIdleData *data = opaque; - - g_assert_cmpint(size, ==, 1); - g_assert_cmpint(*buf, ==, 'Z'); - - size =qemu_chr_fe_write (data->be, (const uint8_t *)"hello" ,5 ); - g_assert_cmpint(size, ==, 5); -} - -static int socket_can_read (void *opaque) -{ -return 10 ; -} - -static void socket_read_hello (void *opaque,const uint8_t *buf,int size) -{ - g_assert_cmpint(size, ==, 5); -g_assert (strncmp ((char *)buf,"hello" ,5 ) ==0 ); - - quit = true; -} - -static int socket_can_read_hello (void *opaque) -{ -return 10 ; -} - -static void char_socket_test_common (Chardev *chr,bool reconnect) -{ -Chardev *chr_client; -QObject *addr; -QDict *qdict; -const char *port; -SocketIdleData d = { .chr = chr }; -CharBackend be; -CharBackend client_be; -char *tmp; - - d.be = &be; - d.client_be = &be; - -g_assert_nonnull (chr); -g_assert (!object_property_get_bool (OBJECT (chr),"connected" , &error_abort)); - - addr =object_property_get_qobject (OBJECT (chr),"addr" , &error_abort); - qdict =qobject_to (QDict, addr); - port =qdict_get_str (qdict,"port" ); - tmp =g_strdup_printf ("tcp:127.0.0.1:%s%s" , port, - reconnect ?",reconnect=1" :"" ); -qobject_unref (qdict); - -qemu_chr_fe_init (&be, chr, &error_abort); -qemu_chr_fe_set_handlers (&be, socket_can_read, socket_read, -NULL ,NULL , &d,NULL , true); - - chr_client =qemu_chr_new ("client" , tmp); -qemu_chr_fe_init (&client_be, chr_client, &error_abort); -qemu_chr_fe_set_handlers (&client_be, socket_can_read_hello, - socket_read_hello, -NULL ,NULL , &d,NULL , true); -g_free (tmp); - - d.conn_expected = true; -guint id =g_idle_add (char_socket_test_idle, &d); -g_source_set_name_by_id (id,"test-idle" ); - g_assert_cmpint(id, >, 0); -main_loop (); - - d.chr = chr_client; - id =g_idle_add (char_socket_test_idle, &d); -g_source_set_name_by_id (id,"test-idle" ); - g_assert_cmpint(id, >, 0); -main_loop (); - -g_assert (object_property_get_bool (OBJECT (chr),"connected" , &error_abort)); -g_assert (object_property_get_bool (OBJECT (chr_client), -"connected" , &error_abort)); - -qemu_chr_write_all (chr_client, (const uint8_t *)"Z" ,1 ); -main_loop (); - -object_unparent (OBJECT (chr_client)); - - d.chr = chr; - d.conn_expected = false; -g_idle_add (char_socket_test_idle, &d); -main_loop (); - -object_unparent (OBJECT (chr)); -} - - -static void char_socket_basic_test (void ) -{ -Chardev *chr =qemu_chr_new ("server" ,"tcp:127.0.0.1:0,server,nowait" ); - -char_socket_test_common (chr, false); -} - - -static void char_socket_reconnect_test (void ) -{ -Chardev *chr =qemu_chr_new ("server" ,"tcp:127.0.0.1:0,server,nowait" ); - -char_socket_test_common (chr, true); -} - - -static void char_socket_fdpass_test (void ) -{ -Chardev *chr; -char *optstr; -QemuOpts *opts; -int fd; -SocketAddress *addr =g_new0 (SocketAddress,1 ); - - addr->type =SOCKET_ADDRESS_TYPE_INET ; - addr->u.inet.host =g_strdup ("127.0.0.1" ); - addr->u.inet.port =g_strdup ("0" ); - - fd =socket_listen (addr, &error_abort); -g_assert (fd >=0 ); - -qapi_free_SocketAddress (addr); - - optstr =g_strdup_printf ("socket,id=cdev,fd=%d,server,nowait" , fd); - - opts =qemu_opts_parse_noisily (qemu_find_opts ("chardev" ), - optstr, true); -g_free (optstr); -g_assert_nonnull (opts); - - chr =qemu_chr_new_from_opts (opts, &error_abort); - -qemu_opts_del (opts); - -char_socket_test_common (chr, false); -} -static void websock_server_read (void *opaque,const uint8_t *buf,int size) {
@@ -610,6 +451,28 @@ static void char_pipe_test(void) }#endif +typedef struct SocketIdleData { +GMainLoop *loop; +Chardev *chr; +bool conn_expected; +CharBackend *be; +CharBackend *client_be; +}SocketIdleData ; + + +static void socket_read_hello (void *opaque,const uint8_t *buf,int size) +{ + g_assert_cmpint(size, ==, 5); +g_assert (strncmp ((char *)buf,"hello" ,5 ) ==0 ); + + quit = true; +} + +static int socket_can_read_hello (void *opaque) +{ +return 10 ; +} +static int make_udp_socket (int *port) {struct sockaddr_in addr = {0 , };
@@ -680,6 +543,391 @@ static void char_udp_test(void)char_udp_test_internal (NULL ,0 ); } + +typedef struct { +int event; +bool got_pong; +}CharSocketTestData ; + + +#define SOCKET_PING "Hello" +#define SOCKET_PONG "World" + + +static void +char_socket_event (void *opaque,int event) +{ +CharSocketTestData *data = opaque; + data->event = event; +} + + +static void +char_socket_read (void *opaque,const uint8_t *buf,int size) +{ +CharSocketTestData *data = opaque; + g_assert_cmpint(size, ==, sizeof(SOCKET_PONG)); +g_assert (memcmp (buf,SOCKET_PONG , size) ==0 ); + data->got_pong = true; +} + + +static int +char_socket_can_read (void *opaque) +{ +return sizeof (SOCKET_PONG ); +} + + +static char * +char_socket_addr_to_opt_str (SocketAddress *addr,bool fd_pass, +const char *reconnect,bool is_listen) +{ +if (fd_pass) { +QIOChannelSocket *ioc =qio_channel_socket_new (); +int fd; +char *optstr; +g_assert (!reconnect); +if (is_listen) { +qio_channel_socket_listen_sync (ioc, addr, &error_abort); + }else { +qio_channel_socket_connect_sync (ioc, addr, &error_abort); + } + fd = ioc->fd; + ioc->fd =-1 ; + optstr =g_strdup_printf ("socket,id=cdev0,fd=%d%s" , + fd, is_listen ?",server,nowait" :"" ); +object_unref (OBJECT (ioc)); +return optstr; + }else { +switch (addr->type) { +case SOCKET_ADDRESS_TYPE_INET : +return g_strdup_printf ("socket,id=cdev0,host=%s,port=%s%s%s" , + addr->u.inet.host, + addr->u.inet.port, + reconnect ? reconnect :"" , + is_listen ?",server,nowait" :"" ); + +case SOCKET_ADDRESS_TYPE_UNIX : +return g_strdup_printf ("socket,id=cdev0,path=%s%s%s" , + addr->u.q_unix.path, + reconnect ? reconnect :"" , + is_listen ?",server,nowait" :"" ); + +default : +g_assert_not_reached (); + } + } +} + + +static void +char_socket_ping_pong (QIOChannel *ioc) +{ +char greeting[sizeof (SOCKET_PING )]; +const char *response =SOCKET_PONG ; + +qio_channel_read_all (ioc, greeting,sizeof (greeting), &error_abort); + +g_assert (memcmp (greeting,SOCKET_PING ,sizeof (greeting)) ==0 ); + +qio_channel_write_all (ioc, response,sizeof (SOCKET_PONG ), &error_abort); + +object_unref (OBJECT (ioc)); +} + + +static gpointer +char_socket_server_client_thread (gpointer data) +{ +SocketAddress *addr = data; +QIOChannelSocket *ioc =qio_channel_socket_new (); + +qio_channel_socket_connect_sync (ioc, addr, &error_abort); + +char_socket_ping_pong (QIO_CHANNEL (ioc)); + +return NULL ; +} + + +typedef struct { +SocketAddress *addr; +bool wait_connected; +bool fd_pass; +}CharSocketServerTestConfig ; + + +static void char_socket_server_test (gconstpointer opaque) +{ +const CharSocketServerTestConfig *config = opaque; +Chardev *chr; +CharBackend be = {0 }; +CharSocketTestData data = {0 }; +QObject *qaddr; +SocketAddress *addr; +Visitor *v; +QemuThread thread; +int ret; +bool reconnected; +char *optstr; +QemuOpts *opts; + +setenv ("QTEST_SILENT_ERRORS" ,"1" ,1 ); +/* +* We rely on config->addr containing "nowait", otherwise +* qemu_chr_new() will block until a client connects. We +* can't spawn our client thread though, because until +* qemu_chr_new() returns we don't know what TCP port was +* allocated by the OS +*/ + optstr =char_socket_addr_to_opt_str (config->addr, + config->fd_pass, +NULL , + true); + opts =qemu_opts_parse_noisily (qemu_find_opts ("chardev" ), + optstr, true); +g_assert_nonnull (opts); + chr =qemu_chr_new_from_opts (opts, &error_abort); +qemu_opts_del (opts); +g_assert_nonnull (chr); +g_assert (!object_property_get_bool (OBJECT (chr),"connected" , &error_abort)); + + qaddr =object_property_get_qobject (OBJECT (chr),"addr" , &error_abort); +g_assert_nonnull (qaddr); + + v =qobject_input_visitor_new (qaddr); +visit_type_SocketAddress (v,"addr" , &addr, &error_abort); +visit_free (v); +qobject_unref (qaddr); + +qemu_chr_fe_init (&be, chr, &error_abort); + + reconnect: + data.event =-1 ; +qemu_chr_fe_set_handlers (&be,NULL ,NULL , + char_socket_event,NULL , + &data,NULL , true); +g_assert (data.event ==-1 ); + +/* +* Kick off a thread to act as the "remote" client +* which just plays ping-pong with us +*/ +qemu_thread_create (&thread,"client" , + char_socket_server_client_thread, + addr,QEMU_THREAD_JOINABLE ); +g_assert (data.event ==-1 ); + +if (config->wait_connected) { +/* Synchronously accept a connection */ +qemu_chr_wait_connected (chr, &error_abort); + }else { +/* +* Asynchronously accept a connection when the evnt +* loop reports the listener socket as readable +*/ +while (data.event ==-1 ) { +main_loop_wait (false); + } + } +g_assert (object_property_get_bool (OBJECT (chr),"connected" , &error_abort)); +g_assert (data.event ==CHR_EVENT_OPENED ); + data.event =-1 ; + +/* Send a greeting to the client */ + ret =qemu_chr_fe_write_all (&be, (const uint8_t *)SOCKET_PING , +sizeof (SOCKET_PING )); + g_assert_cmpint(ret, ==, sizeof(SOCKET_PING)); +g_assert (data.event ==-1 ); + +/* Setup a callback to receive the reply to our greeting */ +qemu_chr_fe_set_handlers (&be, char_socket_can_read, + char_socket_read, + char_socket_event,NULL , + &data,NULL , true); +g_assert (data.event ==CHR_EVENT_OPENED ); + data.event =-1 ; + +/* Wait for the client to go away */ +while (data.event ==-1 ) { +main_loop_wait (false); + } +g_assert (!object_property_get_bool (OBJECT (chr),"connected" , &error_abort)); +g_assert (data.event ==CHR_EVENT_CLOSED ); +g_assert (data.got_pong); + +qemu_thread_join (&thread); + +if (!reconnected) { + reconnected = true; + goto reconnect; + } + +qapi_free_SocketAddress (addr); +object_unparent (OBJECT (chr)); +g_free (optstr); +unsetenv ("QTEST_SILENT_ERRORS" ); +} + + +static gpointer +char_socket_client_server_thread (gpointer data) +{ +QIOChannelSocket *ioc = data; +QIOChannelSocket *cioc; + + cioc =qio_channel_socket_accept (ioc, &error_abort); +g_assert_nonnull (cioc); + +char_socket_ping_pong (QIO_CHANNEL (cioc)); + +return NULL ; +} + + +typedef struct { +SocketAddress *addr; +const char *reconnect; +bool wait_connected; +bool fd_pass; +}CharSocketClientTestConfig ; + + +static void char_socket_client_test (gconstpointer opaque) +{ +const CharSocketClientTestConfig *config = opaque; +QIOChannelSocket *ioc; +char *optstr; +Chardev *chr; +CharBackend be = {0 }; +CharSocketTestData data = {0 }; +SocketAddress *addr; +QemuThread thread; +int ret; +bool reconnected = false; +QemuOpts *opts; + +/* +* Setup a listener socket and determine get its address +* so we know the TCP port for the client later +*/ + ioc =qio_channel_socket_new (); +g_assert_nonnull (ioc); +qio_channel_socket_listen_sync (ioc, config->addr, &error_abort); + addr =qio_channel_socket_get_local_address (ioc, &error_abort); +g_assert_nonnull (addr); + +/* +* Kick off a thread to act as the "remote" client +* which just plays ping-pong with us +*/ +qemu_thread_create (&thread,"client" , + char_socket_client_server_thread, + ioc,QEMU_THREAD_JOINABLE ); + +/* +* Populate the chardev address based on what the server +* is actually listening on +*/ + optstr =char_socket_addr_to_opt_str (addr, + config->fd_pass, + config->reconnect, + false); + + opts =qemu_opts_parse_noisily (qemu_find_opts ("chardev" ), + optstr, true); +g_assert_nonnull (opts); + chr =qemu_chr_new_from_opts (opts, &error_abort); +qemu_opts_del (opts); +g_assert_nonnull (chr); + +if (config->reconnect) { +/* +* If reconnect is set, the connection will be +* established in a background thread and we won't +* see the "connected" status updated until we +* run the main event loop, or call qemu_chr_wait_connected +*/ +g_assert (!object_property_get_bool (OBJECT (chr),"connected" , + &error_abort)); + }else { +g_assert (object_property_get_bool (OBJECT (chr),"connected" , + &error_abort)); + } + +qemu_chr_fe_init (&be, chr, &error_abort); + + reconnect: + data.event =-1 ; +qemu_chr_fe_set_handlers (&be,NULL ,NULL , + char_socket_event,NULL , + &data,NULL , true); +if (config->reconnect) { +g_assert (data.event ==-1 ); + }else { +g_assert (data.event ==CHR_EVENT_OPENED ); + } + +if (config->wait_connected) { +/* +* Synchronously wait for the connection to complete +* This should be a no-op if reconnect is not set. +*/ +qemu_chr_wait_connected (chr, &error_abort); + }else { +/* +* Asynchronously wait for the connection to be reported +* as complete when the background thread reports its +* status. +* The loop will short-circuit if reconnect was set +*/ +while (data.event ==-1 ) { +main_loop_wait (false); + } + } +g_assert (data.event ==CHR_EVENT_OPENED ); + data.event =-1 ; +g_assert (object_property_get_bool (OBJECT (chr),"connected" , &error_abort)); + +/* Send a greeting to the server */ + ret =qemu_chr_fe_write_all (&be, (const uint8_t *)SOCKET_PING , +sizeof (SOCKET_PING )); + g_assert_cmpint(ret, ==, sizeof(SOCKET_PING)); +g_assert (data.event ==-1 ); + +/* Setup a callback to receive the reply to our greeting */ +qemu_chr_fe_set_handlers (&be, char_socket_can_read, + char_socket_read, + char_socket_event,NULL , + &data,NULL , true); +g_assert (data.event ==CHR_EVENT_OPENED ); + data.event =-1 ; + +/* Wait for the server to go away */ +while (data.event ==-1 ) { +main_loop_wait (false); + } +g_assert (data.event ==CHR_EVENT_CLOSED ); +g_assert (!object_property_get_bool (OBJECT (chr),"connected" , &error_abort)); +g_assert (data.got_pong); +qemu_thread_join (&thread); + +if (config->reconnect && !reconnected) { + reconnected = true; +qemu_thread_create (&thread,"client" , + char_socket_client_server_thread, + ioc,QEMU_THREAD_JOINABLE ); + goto reconnect; + } + +object_unref (OBJECT (ioc)); +object_unparent (OBJECT (chr)); +qapi_free_SocketAddress (addr); +g_free (optstr); +} + +#ifdef HAVE_CHARDEV_SERIAL static void char_serial_test (void ) {
@@ -959,9 +1207,71 @@ int main(int argc, char **argv)#ifndef _WIN32g_test_add_func ("/char/file-fifo" , char_file_fifo_test);#endif -g_test_add_func ("/char/socket/basic" , char_socket_basic_test); -g_test_add_func ("/char/socket/reconnect" , char_socket_reconnect_test); -g_test_add_func ("/char/socket/fdpass" , char_socket_fdpass_test); + +SocketAddress tcpaddr = { + .type =SOCKET_ADDRESS_TYPE_INET , + .u.inet.host = (char *)"127.0.0.1" , + .u.inet.port = (char *)"0" , + }; +#ifndef WIN32 +SocketAddress unixaddr = { + .type =SOCKET_ADDRESS_TYPE_UNIX , + .u.q_unix.path = (char *)"test-char.sock" , + }; +#endif + +#define SOCKET_SERVER_TEST (name, addr) \ + CharSocketServerTestConfig server1 ## name = \ + { addr, false, false }; \ + CharSocketServerTestConfig server2 ## name = \ + { addr, true, false }; \ + CharSocketServerTestConfig server3 ## name = \ + { addr, false, true }; \ + CharSocketServerTestConfig server4 ## name = \ + { addr, true, true }; \ + g_test_add_data_func("/char/socket/server/mainloop/" # name, \ + &server1 ##name, char_socket_server_test); \ + g_test_add_data_func("/char/socket/server/wait-conn/" # name, \ + &server2 ##name, char_socket_server_test); \ + g_test_add_data_func("/char/socket/server/mainloop-fdpass/" # name, \ + &server3 ##name, char_socket_server_test); \ + g_test_add_data_func("/char/socket/server/wait-conn-fdpass/" # name, \ + &server4 ##name, char_socket_server_test) + +#define SOCKET_CLIENT_TEST (name, addr) \ + CharSocketClientTestConfig client1 ## name = \ + { addr, NULL, false, false }; \ + CharSocketClientTestConfig client2 ## name = \ + { addr, NULL, true, false }; \ + CharSocketClientTestConfig client3 ## name = \ + { addr, ",reconnect=1", false }; \ + CharSocketClientTestConfig client4 ## name = \ + { addr, ",reconnect=1", true }; \ + CharSocketClientTestConfig client5 ## name = \ + { addr, NULL, false, true }; \ + CharSocketClientTestConfig client6 ## name = \ + { addr, NULL, true, true }; \ + g_test_add_data_func("/char/socket/client/mainloop/" # name, \ + &client1 ##name, char_socket_client_test); \ + g_test_add_data_func("/char/socket/client/wait-conn/" # name, \ + &client2 ##name, char_socket_client_test); \ + g_test_add_data_func("/char/socket/client/mainloop-reconnect/" # name, \ + &client3 ##name, char_socket_client_test); \ + g_test_add_data_func("/char/socket/client/wait-conn-reconnect/" # name, \ + &client4 ##name, char_socket_client_test); \ + g_test_add_data_func("/char/socket/client/mainloop-fdpass/" # name, \ + &client5 ##name, char_socket_client_test); \ + g_test_add_data_func("/char/socket/client/wait-conn-fdpass/" # name, \ + &client6 ##name, char_socket_client_test) + +SOCKET_SERVER_TEST (tcp, &tcpaddr); +SOCKET_CLIENT_TEST (tcp, &tcpaddr); +#ifndef WIN32 +SOCKET_SERVER_TEST (unix, &unixaddr); +SOCKET_CLIENT_TEST (unix, &unixaddr); +#endif + +g_test_add_func ("/char/udp" , char_udp_test);#ifdef HAVE_CHARDEV_SERIAL g_test_add_func ("/char/serial" , char_serial_test);
Signature · 1 line
2.20.1
PATCH v2 16/16 chardev: ensure termios is fully initialized
In reply to Daniel P. Berrangévalgrind on the test-char.c code reports that 'struct termios' contains uninitialized memory.
--- chardev/char-serial.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
chardev/char-serial.c +1 -1
@@ -57,7 +57,7 @@ static void qmp_chardev_open_serial(Chardev *chr,static void tty_serial_init (int fd,int speed,int parity,int data_bits,int stop_bits) { -struct termios tty; +struct termios tty = {0 };speed_t spd;#if 0
Signature · 1 line
2.20.1
Re: [Qemu-devel] [PATCH v2 16/16] chardev: ensure termios is fully initialized
Quoted 5 lines · Daniel P. Berrangé
valgrind on the
test-char.ccode reports that 'struct termios' contains uninitialized memory.Signed-off-by Daniel P. Berrangé <[email protected]>
Quoted 20 lines
--- chardev/char-serial.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)chardev/char-serial.c +1
-2@@ -57,7 +57,7 @@ static void qmp_chardev_open_serial(Chardev *chr,static void tty_serial_init (int fd,int speed,int parity,int data_bits,int stop_bits) { -struct termios tty; +struct termios tty = {0 };speed_t spd;#if 0 --2.20.1
Hi
Quoted 60 lines · Daniel P. Berrangé
This is a followup to
v1: https://lists.gnu.org/archive/html/qemu-devel/2019-01/msg03344.html
This series comes out of a discussion between myself & Yongji Xie in:
https://lists.gnu.org/archive/html/qemu-devel/2019-01/msg01881.html
I eventually understood that the problem faced was that
tcp_chr_wait_connectedwas racing with the background connection attempt previously started, causing two connections to be established. This broke because some vhost user servers only allow a single connection.After messing around with the code alot the final solution was in fact very easy. We simply have to delay the first background connection attempt until the main loop is running. It will then automatically turn into a no-op if
tcp_chr_wait_connectedhas been run. This is dealt with in the last patch in this seriesI believe this should solve the problem Yongji Xie faced, and thus not require us to add support for "nowait" option with client sockets at all. The reconnect=1 option effectively already implements nowait semantics, and now plays nicely with
tcp_chr_wait_connected.In investigating this I found various other bugs that needed fixing and identified some useful refactoring to simplify / clarify the code, hence this very long series.
This series passes make check-unit & check-qtest (for
x86_64target).I did a test with tests/vhost-user-bridge too, which was in fact already broken for the same reason Yongji Xie found - it only accepts a single connection. This series fixes use of reconnect=1 with vhost-user-bridge.
Changed in v2:
- Rewrite the way we synchronize in
tcp_chr_wait_connectedagain to cope with chardev+device hotplug scenario
- Add extensive unit test coverage
- Resolve conflicts with git masterDaniel P. Berrangé (16):
io: store reference to thread information in the QIOTask struct
io: addqio_task_wait_threadto join with a background thread
chardev: fix validation of options for QMP created chardevs
chardev: forbid 'reconnect' option with server sockets
chardev: forbid 'wait' option with client sockets
chardev: remove many local variables inqemu_chr_parse_socket
chardev: ensureqemu_chr_parse_compatreports missing driver error
chardev: remove unused 'sioc' variable & cleanup paths
chardev: splittcp_chr_wait_connectedinto two methods
chardev: split upqmp_chardev_open_socketconnection code
chardev: use a state machine for socket connection state
chardev: honour the reconnect setting intcp_chr_wait_connected
chardev: disallow TLS/telnet/websocket withtcp_chr_wait_connected
chardev: fix race with client connections intcp_chr_wait_connected
tests: expand coverage of socket chardev test
chardev: ensure termios is fully initialized
Quoted 12 lines
chardev/char-serial.c | 2 +- chardev/char-socket.c | 487 ++++++++++++++++++------- chardev/char.c | 2 + include/io/task.h | 29 +- io/task.c | 88 +++-- io/trace-events | 2 + tests/ivshmem-test.c | 2 +- tests/libqtest.c | 4 +- tests/test-char.c | 643 ++++++++++++++++++++++++--------- tests/test-filter-redirector.c | 4 +- 10 files changed, 928 insertions(+), 335 deletions(-)
With the fix squashed, I am queuing this series.
Quoted 3 lines
--
2.20.1
Quoted 75 lines · Marc-André Lureau
Hi
Quoted 60 lines · Daniel P. Berrangé
This is a followup to
v1: https://lists.gnu.org/archive/html/qemu-devel/2019-01/msg03344.html
This series comes out of a discussion between myself & Yongji Xie in:
https://lists.gnu.org/archive/html/qemu-devel/2019-01/msg01881.html
I eventually understood that the problem faced was that
tcp_chr_wait_connectedwas racing with the background connection attempt previously started, causing two connections to be established. This broke because some vhost user servers only allow a single connection.After messing around with the code alot the final solution was in fact very easy. We simply have to delay the first background connection attempt until the main loop is running. It will then automatically turn into a no-op if
tcp_chr_wait_connectedhas been run. This is dealt with in the last patch in this seriesI believe this should solve the problem Yongji Xie faced, and thus not require us to add support for "nowait" option with client sockets at all. The reconnect=1 option effectively already implements nowait semantics, and now plays nicely with
tcp_chr_wait_connected.In investigating this I found various other bugs that needed fixing and identified some useful refactoring to simplify / clarify the code, hence this very long series.
This series passes make check-unit & check-qtest (for
x86_64target).I did a test with tests/vhost-user-bridge too, which was in fact already broken for the same reason Yongji Xie found - it only accepts a single connection. This series fixes use of reconnect=1 with vhost-user-bridge.
Changed in v2:
- Rewrite the way we synchronize in
tcp_chr_wait_connectedagain to cope with chardev+device hotplug scenario
- Add extensive unit test coverage
- Resolve conflicts with git masterDaniel P. Berrangé (16):
io: store reference to thread information in the QIOTask struct
io: addqio_task_wait_threadto join with a background thread
chardev: fix validation of options for QMP created chardevs
chardev: forbid 'reconnect' option with server sockets
chardev: forbid 'wait' option with client sockets
chardev: remove many local variables inqemu_chr_parse_socket
chardev: ensureqemu_chr_parse_compatreports missing driver error
chardev: remove unused 'sioc' variable & cleanup paths
chardev: splittcp_chr_wait_connectedinto two methods
chardev: split upqmp_chardev_open_socketconnection code
chardev: use a state machine for socket connection state
chardev: honour the reconnect setting intcp_chr_wait_connected
chardev: disallow TLS/telnet/websocket withtcp_chr_wait_connected
chardev: fix race with client connections intcp_chr_wait_connected
tests: expand coverage of socket chardev test
chardev: ensure termios is fully initializedQuoted 12 lines
chardev/char-serial.c | 2 +- chardev/char-socket.c | 487 ++++++++++++++++++------- chardev/char.c | 2 + include/io/task.h | 29 +- io/task.c | 88 +++-- io/trace-events | 2 + tests/ivshmem-test.c | 2 +- tests/libqtest.c | 4 +- tests/test-char.c | 643 ++++++++++++++++++++++++--------- tests/test-filter-redirector.c | 4 +- 10 files changed, 928 insertions(+), 335 deletions(-)
Quoted 2 lines
With the fix squashed, I am queuing this series.
Reviewed-by Marc-André Lureau <[email protected]>
FYI in case you didn't notice, the fix i posted for patch 1, will invalidate a small part of patch 2 where I had fixed the same problem without realizing/remembering
I pushed my updated branch to if you want to compare:
https://github.com/berrange/qemu/commits/chr-sock
Regards,
Daniel
Signature · 3 lines
|: https://berrange.com -o- https://www.flickr.com/photos/dberrange :| |: https://libvirt.org -o- https://fstop138.berrange.com :| |: https://entangle-photo.org -o- https://www.instagram.com/dberrange :|
Hi
Quoted 80 lines · Daniel P. Berrangé
Quoted 75 lines · Marc-André Lureau
Hi
Quoted 60 lines · Daniel P. Berrangé
This is a followup to
v1: https://lists.gnu.org/archive/html/qemu-devel/2019-01/msg03344.html
This series comes out of a discussion between myself & Yongji Xie in:
https://lists.gnu.org/archive/html/qemu-devel/2019-01/msg01881.html
I eventually understood that the problem faced was that
tcp_chr_wait_connectedwas racing with the background connection attempt previously started, causing two connections to be established. This broke because some vhost user servers only allow a single connection.After messing around with the code alot the final solution was in fact very easy. We simply have to delay the first background connection attempt until the main loop is running. It will then automatically turn into a no-op if
tcp_chr_wait_connectedhas been run. This is dealt with in the last patch in this seriesI believe this should solve the problem Yongji Xie faced, and thus not require us to add support for "nowait" option with client sockets at all. The reconnect=1 option effectively already implements nowait semantics, and now plays nicely with
tcp_chr_wait_connected.In investigating this I found various other bugs that needed fixing and identified some useful refactoring to simplify / clarify the code, hence this very long series.
This series passes make check-unit & check-qtest (for
x86_64target).I did a test with tests/vhost-user-bridge too, which was in fact already broken for the same reason Yongji Xie found - it only accepts a single connection. This series fixes use of reconnect=1 with vhost-user-bridge.
Changed in v2:
- Rewrite the way we synchronize in
tcp_chr_wait_connectedagain to cope with chardev+device hotplug scenario
- Add extensive unit test coverage
- Resolve conflicts with git masterDaniel P. Berrangé (16):
io: store reference to thread information in the QIOTask struct
io: addqio_task_wait_threadto join with a background thread
chardev: fix validation of options for QMP created chardevs
chardev: forbid 'reconnect' option with server sockets
chardev: forbid 'wait' option with client sockets
chardev: remove many local variables inqemu_chr_parse_socket
chardev: ensureqemu_chr_parse_compatreports missing driver error
chardev: remove unused 'sioc' variable & cleanup paths
chardev: splittcp_chr_wait_connectedinto two methods
chardev: split upqmp_chardev_open_socketconnection code
chardev: use a state machine for socket connection state
chardev: honour the reconnect setting intcp_chr_wait_connected
chardev: disallow TLS/telnet/websocket withtcp_chr_wait_connected
chardev: fix race with client connections intcp_chr_wait_connected
tests: expand coverage of socket chardev test
chardev: ensure termios is fully initializedQuoted 12 lines
chardev/char-serial.c | 2 +- chardev/char-socket.c | 487 ++++++++++++++++++------- chardev/char.c | 2 + include/io/task.h | 29 +- io/task.c | 88 +++-- io/trace-events | 2 + tests/ivshmem-test.c | 2 +- tests/libqtest.c | 4 +- tests/test-char.c | 643 ++++++++++++++++++++++++--------- tests/test-filter-redirector.c | 4 +- 10 files changed, 928 insertions(+), 335 deletions(-)Quoted 2 lines
With the fix squashed, I am queuing this series.
Reviewed-by Marc-André Lureau <[email protected]>
Quoted 7 lines
FYI in case you didn't notice, the fix i posted for patch 1, will invalidate a small part of patch 2 where I had fixed the same problem without realizing/remembering
I pushed my updated branch to if you want to compare:
Thanks, I fixed the trivial conflict on rebase.
I also replaced setenv/unsetenv with glib equivalent to fix mingw build.
Quoted 8 lines
Regards,
Daniel
--|: https://berrange.com -o- https://www.flickr.com/photos/dberrange :| |: https://libvirt.org -o- https://fstop138.berrange.com :| |: https://entangle-photo.org -o- https://www.instagram.com/dberrange :|
Signature · 1 line
Marc-André Lureau