1 files changed, 148 insertions, 0 deletions
diff --git a/ssl/quic/quic_thread_assist.c b/ssl/quic/quic_thread_assist.c
new file mode 100644
index 000000000000..5315bf1662c6
--- /dev/null
+++ b/ssl/quic/quic_thread_assist.c
@@ -0,0 +1,148 @@
+/*
+ * Copyright 2023-2025 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_THREAD_ASSIST)
+
+/* 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;
+    QUIC_ENGINE *eng = ossl_quic_channel_get0_engine(qta->ch);
+
+    ossl_crypto_mutex_lock(m);
+
+    rtor = ossl_quic_channel_get_reactor(qta->ch);
+
+    for (;;) {
+        OSSL_TIME deadline;
+
+        if (qta->teardown)
+            break;
+
+        deadline = ossl_quic_reactor_get_tick_deadline(rtor);
+        /*
+         * ossl_crypto_condvar_wait_timeout needs to use real time for the
+         * deadline
+         */
+        deadline = ossl_quic_engine_make_real_time(eng, deadline);
+        ossl_crypto_condvar_wait_timeout(qta->cv, m, deadline);
+
+        /*
+         * 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, QUIC_REACTOR_TICK_FLAG_CHANNEL_ONLY);
+    }
+
+    ossl_crypto_mutex_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_signal(qta->cv);
+    }
+
+    return 1;
+}
+
+int ossl_quic_thread_assist_wait_stopped(QUIC_THREAD_ASSIST *qta)
+{
+    CRYPTO_THREAD_RETVAL rv;
+    CRYPTO_MUTEX *m = ossl_quic_channel_get_mutex(qta->ch);
+
+    if (qta->joined)
+        return 1;
+
+    if (!ossl_quic_thread_assist_stop_async(qta))
+        return 0;
+
+    ossl_crypto_mutex_unlock(m);
+
+    if (!ossl_crypto_thread_native_join(qta->t, &rv)) {
+        ossl_crypto_mutex_lock(m);
+        return 0;
+    }
+
+    qta->joined = 1;
+
+    ossl_crypto_mutex_lock(m);
+    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->t      = NULL;
+    return 1;
+}
+
+int ossl_quic_thread_assist_notify_deadline_changed(QUIC_THREAD_ASSIST *qta)
+{
+    if (qta->teardown)
+        return 0;
+
+    ossl_crypto_condvar_signal(qta->cv);
+    return 1;
+}
+
+#endif