--- /dev/null
+/*
+ * Copyright 2023 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License"). You may not use
+ * this file except in compliance with the License. You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OSSL_QUIC_THREAD_ASSIST_H
+# define OSSL_QUIC_THREAD_ASSIST_H
+
+# include <openssl/ssl.h>
+# include "internal/thread.h"
+
+# if defined(OPENSSL_NO_QUIC) || defined(OPENSSL_NO_THREAD_POOL)
+# define OPENSSL_NO_QUIC_THREAD_ASSIST
+# endif
+
+# ifndef OPENSSL_NO_QUIC_THREAD_ASSIST
+
+/*
+ * QUIC Thread Assisted Functionality
+ * ==================================
+ *
+ * Where OS threading support is available, QUIC can optionally support a thread
+ * assisted mode of operation. The purpose of this mode of operation is to
+ * ensure that assorted timeout events which QUIC expects to be handled in a
+ * timely manner can be handled without the application needing to ensure that
+ * SSL_tick() is called on time. This is not needed if the application always
+ * has a call blocking to SSL_read() or SSL_write() (or another I/O function) on
+ * a QUIC SSL object, but if the application goes for long periods of time
+ * without makingany such call to a QUIC SSL object, libssl cannot ordinarily
+ * guarantee that QUIC timeout events will be serviced in a timely fashion.
+ * Thread assisted mode is therefore of use to applications which do not always
+ * have an ongoing call to an I/O function on a QUIC SSL object but also do not
+ * want to have to arrange periodic ticking.
+ *
+ * A consequence of this is that the intrusiveness of thread assisted mode upon
+ * the general architecture of our QUIC engine is actually fairly limited and
+ * amounts to an automatic ticking of the QUIC engine when timeouts expire,
+ * synchronised correctly with an application's own threads using locking.
+ */
+typedef struct quic_thread_assist_st {
+ QUIC_CHANNEL *ch;
+ CRYPTO_CONDVAR *cv;
+ CRYPTO_THREAD *t;
+ int teardown, joined;
+} QUIC_THREAD_ASSIST;
+
+/*
+ * Initialise the thread assist object. The channel must have a valid mutex
+ * configured on it which will be retrieved automatically. It is assumed that
+ * the mutex is currently held when this function is called. This function does
+ * not affect the state of the mutex.
+ */
+int ossl_quic_thread_assist_init_start(QUIC_THREAD_ASSIST *qta,
+ QUIC_CHANNEL *ch);
+
+/*
+ * Request the thread assist helper to begin stopping the assist thread. This
+ * returns before the teardown is complete. Idempotent; multiple calls to this
+ * function are inconsequential.
+ *
+ * Precondition: channel mutex must be held (unchecked)
+ */
+int ossl_quic_thread_assist_stop_async(QUIC_THREAD_ASSIST *qta);
+
+/*
+ * Wait until the thread assist helper is torn down. This automatically implies
+ * the effects of ossl_quic_thread_assist_stop_async(). Returns immediately
+ * if the teardown has already completed.
+ *
+ * Precondition: channel mutex must be held (unchecked)
+ */
+int ossl_quic_thread_assist_wait_stopped(QUIC_THREAD_ASSIST *qta);
+
+/*
+ * Deallocates state associated with the thread assist helper.
+ * ossl_quic_thread_assist_wait_stopped() must have returned successfully before
+ * calling this. It does not matter whether the channel mutex is held or not.
+ *
+ * Precondition: ossl_quic_thread_assist_wait_stopped() has returned 1
+ * (asserted)
+ */
+int ossl_quic_thread_assist_cleanup(QUIC_THREAD_ASSIST *qta);
+
+/*
+ * Must be called to notify the assist thread if the channel deadline changes.
+ *
+ * Precondition: channel mutex must be held (unchecked)
+ */
+int ossl_quic_thread_assist_notify_deadline_changed(QUIC_THREAD_ASSIST *qta);
+
+# endif
+
+#endif
IF[{- !$disabled{quic} -}]
SOURCE[../libssl]=priority_queue.c event_queue.c
+
+ IF[{- !$disabled{'thread-pool'} -}]
+ SHARED_SOURCE[../libssl]=\
+ ../crypto/thread/arch/thread_posix.c \
+ ../crypto/thread/arch/thread_win.c \
+ ../crypto/thread/arch/thread_none.c \
+ ../crypto/thread/arch.c
+ ENDIF
+
ENDIF
SOURCE[$LIBSSL]=quic_channel.c
SOURCE[$LIBSSL]=quic_tserver.c
SOURCE[$LIBSSL]=quic_tls.c
+SOURCE[$LIBSSL]=quic_thread_assist.c
--- /dev/null
+/*
+ * Copyright 2023 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License"). You may not use
+ * this file except in compliance with the License. You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#include <openssl/macros.h>
+#include "quic_local.h"
+#include "internal/time.h"
+#include "internal/thread.h"
+#include "internal/thread_arch.h"
+#include "internal/quic_thread_assist.h"
+
+#if !defined(OPENSSL_NO_QUIC) && !defined(OPENSSL_NO_THREAD_POOL)
+
+/* Main loop for the QUIC assist thread. */
+static unsigned int assist_thread_main(void *arg)
+{
+ QUIC_THREAD_ASSIST *qta = arg;
+ CRYPTO_MUTEX *m = ossl_quic_channel_get_mutex(qta->ch);
+ QUIC_REACTOR *rtor;
+
+ if (!CRYPTO_THREAD_write_lock(m))
+ return 0;
+
+ rtor = ossl_quic_channel_get_reactor(qta->ch);
+
+ for (;;) {
+ if (qta->teardown)
+ break;
+
+ ossl_crypto_condvar_wait_timeout(qta->cv, m,
+ ossl_quic_reactor_get_tick_deadline(rtor));
+
+ /*
+ * We have now been woken up. This can be for one of the following
+ * reasons:
+ *
+ * - We have been asked to teardown (qta->teardown is set);
+ * - The tick deadline has passed.
+ * - The tick deadline has changed.
+ *
+ * For robustness, this loop also handles spurious wakeups correctly
+ * (which does not require any extra code).
+ */
+ if (qta->teardown)
+ break;
+
+ ossl_quic_reactor_tick(rtor);
+ }
+
+ CRYPTO_THREAD_unlock(m);
+ return 1;
+}
+
+int ossl_quic_thread_assist_init_start(QUIC_THREAD_ASSIST *qta,
+ QUIC_CHANNEL *ch)
+{
+ CRYPTO_MUTEX *mutex = ossl_quic_channel_get_mutex(ch);
+
+ if (mutex == NULL)
+ return 0;
+
+ qta->ch = ch;
+ qta->teardown = 0;
+ qta->joined = 0;
+
+ qta->cv = ossl_crypto_condvar_new();
+ if (qta->cv == NULL)
+ return 0;
+
+ qta->t = ossl_crypto_thread_native_start(assist_thread_main,
+ qta, /*joinable=*/1);
+ if (qta->t == NULL) {
+ ossl_crypto_condvar_free(qta->cv);
+ return 0;
+ }
+
+ return 1;
+}
+
+int ossl_quic_thread_assist_stop_async(QUIC_THREAD_ASSIST *qta)
+{
+ if (!qta->teardown) {
+ qta->teardown = 1;
+ ossl_crypto_condvar_broadcast(qta->cv);
+ }
+
+ return 1;
+}
+
+static void ignore_res(int x) {}
+
+int ossl_quic_thread_assist_wait_stopped(QUIC_THREAD_ASSIST *qta)
+{
+ CRYPTO_THREAD_RETVAL rv;
+ CRYPTO_RWLOCK *m = ossl_quic_channel_get_mutex(qta->ch);
+
+ if (qta->joined)
+ return 1;
+
+ if (!ossl_quic_thread_assist_stop_async(qta))
+ return 0;
+
+ CRYPTO_THREAD_unlock(m);
+
+ if (!ossl_crypto_thread_native_join(qta->t, &rv)) {
+ ignore_res(CRYPTO_THREAD_write_lock(m)); /* best effort */
+ return 0;
+ }
+
+ qta->joined = 1;
+
+ if (!CRYPTO_THREAD_write_lock(m))
+ return 0;
+
+ return 1;
+}
+
+int ossl_quic_thread_assist_cleanup(QUIC_THREAD_ASSIST *qta)
+{
+ if (!ossl_assert(qta->joined))
+ return 0;
+
+ ossl_crypto_condvar_free(qta->cv);
+ ossl_crypto_thread_native_clean(qta->t);
+
+ qta->ch = NULL;
+ qta->cv = NULL;
+ qta->t = NULL;
+ return 1;
+}
+
+int ossl_quic_thread_assist_notify_deadline_changed(QUIC_THREAD_ASSIST *qta)
+{
+ if (qta->teardown)
+ return 0;
+
+ /*
+ * Wake-one would be better here but as there is only one listening thread
+ * this does not actually matter.
+ */
+ ossl_crypto_condvar_broadcast(qta->cv);
+ return 1;
+}
+
+#endif
projects / thirdparty / openssl.git / commitdiff
