diff options
author | Matt Caswell <matt@openssl.org> | 2020-12-23 11:15:03 +0000 |
---|---|---|
committer | Dmitry Belyavskiy <beldmit@gmail.com> | 2020-12-31 13:14:38 +0100 |
commit | 49fff26d674adb65f3532eec4f0f37369b41a594 (patch) | |
tree | 5f7b01c1c930a1e285b77692fea9b0d12eadcd10 /doc/man3/CRYPTO_THREAD_run_once.pod | |
parent | db6bcc81ab86fca74730566f0b471a7c3757c95c (diff) |
Add documentation for CRYPTO_atomic_or and CRYPTO_atomic_load
Reviewed-by: Dmitry Belyavskiy <beldmit@gmail.com>
(Merged from https://github.com/openssl/openssl/pull/13733)
Diffstat (limited to 'doc/man3/CRYPTO_THREAD_run_once.pod')
-rw-r--r-- | doc/man3/CRYPTO_THREAD_run_once.pod | 43 |
1 files changed, 33 insertions, 10 deletions
diff --git a/doc/man3/CRYPTO_THREAD_run_once.pod b/doc/man3/CRYPTO_THREAD_run_once.pod index 5cffc42026..a182359f47 100644 --- a/doc/man3/CRYPTO_THREAD_run_once.pod +++ b/doc/man3/CRYPTO_THREAD_run_once.pod @@ -5,7 +5,7 @@ CRYPTO_THREAD_run_once, CRYPTO_THREAD_lock_new, CRYPTO_THREAD_read_lock, CRYPTO_THREAD_write_lock, CRYPTO_THREAD_unlock, CRYPTO_THREAD_lock_free, -CRYPTO_atomic_add - OpenSSL thread support +CRYPTO_atomic_add, CRYPTO_atomic_or, CRYPTO_atomic_load - OpenSSL thread support =head1 SYNOPSIS @@ -21,6 +21,9 @@ CRYPTO_atomic_add - OpenSSL thread support void CRYPTO_THREAD_lock_free(CRYPTO_RWLOCK *lock); int CRYPTO_atomic_add(int *val, int amount, int *ret, CRYPTO_RWLOCK *lock); + int CRYPTO_atomic_or(uint64_t *val, uint64_t op, uint64_t *ret, + CRYPTO_RWLOCK *lock); + int CRYPTO_atomic_load(uint64_t *val, uint64_t *ret, CRYPTO_RWLOCK *lock); =head1 DESCRIPTION @@ -38,10 +41,10 @@ The following multi-threading function are provided: =item * CRYPTO_THREAD_run_once() can be used to perform one-time initialization. -The B<once> argument must be a pointer to a static object of type +The I<once> argument must be a pointer to a static object of type B<CRYPTO_ONCE> that was statically initialized to the value B<CRYPTO_ONCE_STATIC_INIT>. -The B<init> argument is a pointer to a function that performs the desired +The I<init> argument is a pointer to a function that performs the desired exactly once initialization. In particular, this can be used to allocate locks in a thread-safe manner, which can then be used with the locking functions below. @@ -53,27 +56,47 @@ lock. =item * -CRYPTO_THREAD_read_lock() locks the provided B<lock> for reading. +CRYPTO_THREAD_read_lock() locks the provided I<lock> for reading. =item * -CRYPTO_THREAD_write_lock() locks the provided B<lock> for writing. +CRYPTO_THREAD_write_lock() locks the provided I<lock> for writing. =item * -CRYPTO_THREAD_unlock() unlocks the previously locked B<lock>. +CRYPTO_THREAD_unlock() unlocks the previously locked I<lock>. =item * -CRYPTO_THREAD_lock_free() frees the provided B<lock>. +CRYPTO_THREAD_lock_free() frees the provided I<lock>. =item * -CRYPTO_atomic_add() atomically adds B<amount> to B<val> and returns the -result of the operation in B<ret>. B<lock> will be locked, unless atomic +CRYPTO_atomic_add() atomically adds I<amount> to I<*val> and returns the +result of the operation in I<*ret>. I<lock> will be locked, unless atomic operations are supported on the specific platform. Because of this, if a variable is modified by CRYPTO_atomic_add() then CRYPTO_atomic_add() must -be the only way that the variable is modified. +be the only way that the variable is modified. If atomic operations are not +supported and I<lock> is NULL, then the function will fail. + +=item * + +CRYPTO_atomic_or() performs an atomic bitwise or of I<op> and I<*val> and stores +the result back in I<*val>. It also returns the result of the operation in +I<*ret>. I<lock> will be locked, unless atomic operations are supported on the +specific platform. Because of this, if a variable is modified by +CRYPTO_atomic_or() or read by CRYPTO_atomic_load() then CRYPTO_atomic_or() must +be the only way that the variable is modified. If atomic operations are not +supported and I<lock> is NULL, then the function will fail. + +=item * + +CRYPTO_atomic_load() atomically loads the contents of I<*val> into I<*ret>. +I<lock> will be locked, unless atomic operations are supported on the specific +platform. Because of this, if a variable is modified by CRYPTO_atomic_or() or +read by CRYPTO_atomic_load() then CRYPTO_atomic_load() must be the only way that +the variable is read. If atomic operations are not supported and I<lock> is +NULL, then the function will fail. =back |