QuasarApp/openssl
4
0
Fork 0
mirror of https://github.com/QuasarApp/openssl.git synced 2025-04-29 19:24:37 +00:00
Code Issues Projects Releases Wiki Activity

Add documentation for CRYPTO_atomic_or and CRYPTO_atomic_load

Browse Source 
Reviewed-by: Dmitry Belyavskiy <beldmit@gmail.com>
(Merged from https://github.com/openssl/openssl/pull/13733)
This commit is contained in:
Matt Caswell 2020-12-23 11:15:03 +00:00 committed by Dmitry Belyavskiy
parent db6bcc81ab
commit 49fff26d67
1 changed files with 33 additions and 10 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

43
doc/man3/CRYPTO_THREAD_run_once.pod
View File

@ -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