diff options
author | Hugo Landau <hlandau@openssl.org> | 2023-02-21 10:18:59 +0000 |
---|---|---|
committer | Hugo Landau <hlandau@openssl.org> | 2023-03-30 11:14:08 +0100 |
commit | 9f7acf071c363ed8cb5012e122e1e60447b45c78 (patch) | |
tree | 1b5c2a20cd4263b6b23bb8bec5c3ff0790e27192 /include | |
parent | 4a530180e5b9921bc3d1b5228d9be96f2a0b4b07 (diff) |
QUIC Thread Assist Core
Reviewed-by: Tomas Mraz <tomas@openssl.org>
Reviewed-by: Matt Caswell <matt@openssl.org>
(Merged from https://github.com/openssl/openssl/pull/20348)
Diffstat (limited to 'include')
-rw-r--r-- | include/internal/quic_thread_assist.h | 97 |
1 files changed, 97 insertions, 0 deletions
diff --git a/include/internal/quic_thread_assist.h b/include/internal/quic_thread_assist.h new file mode 100644 index 0000000000..94fcaec004 --- /dev/null +++ b/include/internal/quic_thread_assist.h @@ -0,0 +1,97 @@ +/* + * 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 |