Various RT doc fixes
[openssl.git] / doc / crypto / threads.pod
1 =pod
2
3 =head1 NAME
4
5 CRYPTO_THREADID_set_callback, CRYPTO_THREADID_get_callback,
6 CRYPTO_THREADID_current, CRYPTO_THREADID_cmp, CRYPTO_THREADID_cpy,
7 CRYPTO_THREADID_hash, CRYPTO_set_locking_callback, CRYPTO_num_locks,
8 CRYPTO_set_dynlock_create_callback, CRYPTO_set_dynlock_lock_callback,
9 CRYPTO_set_dynlock_destroy_callback, CRYPTO_get_new_dynlockid,
10 CRYPTO_destroy_dynlockid, CRYPTO_lock - OpenSSL thread support
11
12 =head1 SYNOPSIS
13
14  #include <openssl/crypto.h>
15
16  /* Don't use this structure directly. */
17  typedef struct crypto_threadid_st
18          {
19          void *ptr;
20          unsigned long val;
21          } CRYPTO_THREADID;
22  /* Only use CRYPTO_THREADID_set_[numeric|pointer]() within callbacks */
23  void CRYPTO_THREADID_set_numeric(CRYPTO_THREADID *id, unsigned long val);
24  void CRYPTO_THREADID_set_pointer(CRYPTO_THREADID *id, void *ptr);
25  int CRYPTO_THREADID_set_callback(void (*threadid_func)(CRYPTO_THREADID *));
26  void (*CRYPTO_THREADID_get_callback(void))(CRYPTO_THREADID *);
27  void CRYPTO_THREADID_current(CRYPTO_THREADID *id);
28  int CRYPTO_THREADID_cmp(const CRYPTO_THREADID *a,
29                          const CRYPTO_THREADID *b);
30  void CRYPTO_THREADID_cpy(CRYPTO_THREADID *dest,
31                           const CRYPTO_THREADID *src);
32  unsigned long CRYPTO_THREADID_hash(const CRYPTO_THREADID *id);
33
34  int CRYPTO_num_locks(void);
35
36  /* struct CRYPTO_dynlock_value needs to be defined by the user */
37  struct CRYPTO_dynlock_value;
38
39  void CRYPTO_set_dynlock_create_callback(struct CRYPTO_dynlock_value *
40         (*dyn_create_function)(const char *file, int line));
41  void CRYPTO_set_dynlock_lock_callback(void (*dyn_lock_function)
42         (int mode, struct CRYPTO_dynlock_value *l,
43         const char *file, int line));
44  void CRYPTO_set_dynlock_destroy_callback(void (*dyn_destroy_function)
45         (struct CRYPTO_dynlock_value *l, const char *file, int line));
46
47  int CRYPTO_get_new_dynlockid(void);
48
49  void CRYPTO_destroy_dynlockid(int i);
50
51  void CRYPTO_lock(int mode, int n, const char *file, int line);
52
53  #define CRYPTO_w_lock(type)    \
54         CRYPTO_lock(CRYPTO_LOCK|CRYPTO_WRITE,type,__FILE__,__LINE__)
55  #define CRYPTO_w_unlock(type)  \
56         CRYPTO_lock(CRYPTO_UNLOCK|CRYPTO_WRITE,type,__FILE__,__LINE__)
57  #define CRYPTO_r_lock(type)    \
58         CRYPTO_lock(CRYPTO_LOCK|CRYPTO_READ,type,__FILE__,__LINE__)
59  #define CRYPTO_r_unlock(type)  \
60         CRYPTO_lock(CRYPTO_UNLOCK|CRYPTO_READ,type,__FILE__,__LINE__)
61  #define CRYPTO_add(addr,amount,type)   \
62         CRYPTO_add_lock(addr,amount,type,__FILE__,__LINE__)
63
64 =head1 DESCRIPTION
65
66 OpenSSL can safely be used in multi-threaded applications provided
67 that at least two callback functions are set, locking_function and
68 threadid_func.
69
70 locking_function(int mode, int n, const char *file, int line) is
71 needed to perform locking on shared data structures. 
72 (Note that OpenSSL uses a number of global data structures that
73 will be implicitly shared whenever multiple threads use OpenSSL.)
74 Multi-threaded applications will crash at random if it is not set.
75
76 locking_function() must be able to handle up to CRYPTO_num_locks()
77 different mutex locks. It sets the B<n>-th lock if B<mode> &
78 B<CRYPTO_LOCK>, and releases it otherwise.
79
80 B<file> and B<line> are the file number of the function setting the
81 lock. They can be useful for debugging.
82
83 threadid_func(CRYPTO_THREADID *id) is needed to record the currently-executing
84 thread's identifier into B<id>. The implementation of this callback should not
85 fill in B<id> directly, but should use CRYPTO_THREADID_set_numeric() if thread
86 IDs are numeric, or CRYPTO_THREADID_set_pointer() if they are pointer-based.
87 The B<id> must be unique for the duration of the execution of the program.
88 If the application does not register such a callback using
89 CRYPTO_THREADID_set_callback(), then a default implementation is used - on
90 Windows this uses the system's default thread identifying APIs, and on
91 all other platforms it uses the address of B<errno>. The latter is satisfactory
92 for thread-safety if and only if the platform has a thread-local error number
93 facility.
94
95 Once threadid_func() is registered, or if the built-in default implementation is
96 to be used;
97
98 =over 4
99
100 =item *
101 CRYPTO_THREADID_current() records the currently-executing thread ID into the
102 given B<id> object.
103
104 =item *
105 CRYPTO_THREADID_cmp() compares two thread IDs (returning zero for equality, ie.
106 the same semantics as memcmp()).
107
108 =item *
109 CRYPTO_THREADID_cpy() duplicates a thread ID value,
110
111 =item *
112 CRYPTO_THREADID_hash() returns a numeric value usable as a hash-table key. This
113 is usually the exact numeric or pointer-based thread ID used internally, however
114 this also handles the unusual case where pointers are larger than 'long'
115 variables and the platform's thread IDs are pointer-based - in this case, mixing
116 is done to attempt to produce a unique numeric value even though it is not as
117 wide as the platform's true thread IDs.
118
119 =back
120
121 Additionally, OpenSSL supports dynamic locks, and sometimes, some parts
122 of OpenSSL need it for better performance.  To enable this, the following
123 is required:
124
125 =over 4
126
127 =item *
128 Three additional callback function, dyn_create_function, dyn_lock_function
129 and dyn_destroy_function.
130
131 =item *
132 A structure defined with the data that each lock needs to handle.
133
134 =back
135
136 struct CRYPTO_dynlock_value has to be defined to contain whatever structure
137 is needed to handle locks.
138
139 dyn_create_function(const char *file, int line) is needed to create a
140 lock.  Multi-threaded applications might crash at random if it is not set.
141
142 dyn_lock_function(int mode, CRYPTO_dynlock *l, const char *file, int line)
143 is needed to perform locking off dynamic lock numbered n. Multi-threaded
144 applications might crash at random if it is not set.
145
146 dyn_destroy_function(CRYPTO_dynlock *l, const char *file, int line) is
147 needed to destroy the lock l. Multi-threaded applications might crash at
148 random if it is not set.
149
150 CRYPTO_get_new_dynlockid() is used to create locks.  It will call
151 dyn_create_function for the actual creation.
152
153 CRYPTO_destroy_dynlockid() is used to destroy locks.  It will call
154 dyn_destroy_function for the actual destruction.
155
156 CRYPTO_lock() is used to lock and unlock the locks.  mode is a bitfield
157 describing what should be done with the lock.  n is the number of the
158 lock as returned from CRYPTO_get_new_dynlockid().  mode can be combined
159 from the following values.  These values are pairwise exclusive, with
160 undefined behaviour if misused (for example, CRYPTO_READ and CRYPTO_WRITE
161 should not be used together):
162
163         CRYPTO_LOCK     0x01
164         CRYPTO_UNLOCK   0x02
165         CRYPTO_READ     0x04
166         CRYPTO_WRITE    0x08
167
168 =head1 RETURN VALUES
169
170 CRYPTO_num_locks() returns the required number of locks.
171
172 CRYPTO_get_new_dynlockid() returns the index to the newly created lock.
173
174 The other functions return no values.
175
176 =head1 NOTES
177
178 You can find out if OpenSSL was configured with thread support:
179
180  #define OPENSSL_THREAD_DEFINES
181  #include <openssl/opensslconf.h>
182  #if defined(OPENSSL_THREADS)
183    // thread support enabled
184  #else
185    // no thread support
186  #endif
187
188 Also, dynamic locks are currently not used internally by OpenSSL, but
189 may do so in the future.
190
191 =head1 EXAMPLES
192
193 B<crypto/threads/mttest.c> shows examples of the callback functions on
194 Solaris, Irix and Win32.
195
196 =head1 HISTORY
197
198 B<CRYPTO_THREADID> and associated functions were introduced in OpenSSL 1.0.0
199 to replace (actually, deprecate) the previous CRYPTO_set_id_callback(),
200 CRYPTO_get_id_callback(), and CRYPTO_thread_id() functions which assumed
201 thread IDs to always be represented by 'unsigned long'.
202
203 =head1 SEE ALSO
204
205 L<crypto(3)>
206
207 =cut