s3: Use sys_read in fork_domain_child
[Samba.git] / lib / util / smb_threads.c
blob58ea2daa67563bc831dffd811ec23e75f1a18f0f
1 /*
2 Unix SMB/CIFS implementation.
3 SMB client library implementation (thread interface functions).
4 Copyright (C) Jeremy Allison, 2009.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>.
21 * This code is based in the ideas in openssl
22 * but somewhat simpler and expended to include
23 * thread local storage.
26 #include "includes.h"
27 #include "smb_threads.h"
29 /*********************************************************
30 Functions to vector the locking primitives used internally
31 by libsmbclient.
32 *********************************************************/
34 const struct smb_thread_functions *global_tfp;
36 /*********************************************************
37 Dynamic lock array.
38 *********************************************************/
40 void **global_lock_array;
42 /*********************************************************
43 Mutex used for our internal "once" function
44 *********************************************************/
46 static void *once_mutex = NULL;
49 /*********************************************************
50 Function to set the locking primitives used by libsmbclient.
51 *********************************************************/
53 int smb_thread_set_functions(const struct smb_thread_functions *tf)
55 int i;
57 global_tfp = tf;
59 #if defined(PARANOID_MALLOC_CHECKER)
60 #ifdef malloc
61 #undef malloc
62 #endif
63 #endif
65 /* Here we initialize any static locks we're using. */
66 global_lock_array = (void **)malloc(sizeof(void *) *NUM_GLOBAL_LOCKS);
68 #if defined(PARANOID_MALLOC_CHECKER)
69 #define malloc(s) __ERROR_DONT_USE_MALLOC_DIRECTLY
70 #endif
72 if (global_lock_array == NULL) {
73 return ENOMEM;
76 for (i = 0; i < NUM_GLOBAL_LOCKS; i++) {
77 char *name = NULL;
78 if (asprintf(&name, "global_lock_%d", i) == -1) {
79 SAFE_FREE(global_lock_array);
80 return ENOMEM;
82 if (global_tfp->create_mutex(name,
83 &global_lock_array[i],
84 __location__)) {
85 smb_panic("smb_thread_set_functions: create mutexes failed");
87 SAFE_FREE(name);
90 /* Create the mutex we'll use for our "once" function */
91 if (SMB_THREAD_CREATE_MUTEX("smb_once", once_mutex) != 0) {
92 smb_panic("smb_thread_set_functions: failed to create 'once' mutex");
95 return 0;
98 /*******************************************************************
99 Call a function only once. We implement this ourselves
100 using our own mutex rather than using the thread implementation's
101 *_once() function because each implementation has its own
102 type for the variable which keeps track of whether the function
103 has been called, and there's no easy way to allocate the correct
104 size variable in code internal to Samba without knowing the
105 implementation's "once" type.
106 ********************************************************************/
108 int smb_thread_once(smb_thread_once_t *ponce,
109 void (*init_fn)(void *pdata),
110 void *pdata)
112 int ret;
114 /* Lock our "once" mutex in order to test and initialize ponce */
115 if (SMB_THREAD_LOCK(once_mutex) != 0) {
116 smb_panic("error locking 'once'");
119 /* Keep track of whether we ran their init function */
120 ret = ! *ponce;
123 * See if another thread got here after we tested it initially but
124 * before we got our lock.
126 if (! *ponce) {
127 /* Nope, we need to run the initialization function */
128 (*init_fn)(pdata);
130 /* Now we can indicate that the function has been run */
131 *ponce = true;
134 /* Unlock the mutex */
135 if (SMB_THREAD_UNLOCK(once_mutex) != 0) {
136 smb_panic("error unlocking 'once'");
140 * Tell 'em whether we ran their init function. If they passed a data
141 * pointer to the init function and the init function could change
142 * something in the pointed-to data, this will tell them whether that
143 * data is valid or not.
145 return ret;
149 #if 0
150 /* Test. - pthread implementations. */
151 #include <pthread.h>
153 #ifdef malloc
154 #undef malloc
155 #endif
157 SMB_THREADS_DEF_PTHREAD_IMPLEMENTATION(tf);
159 static smb_thread_once_t ot = SMB_THREAD_ONCE_INIT;
160 void *pkey = NULL;
162 static void init_fn(void)
164 int ret;
166 if (!global_tfp) {
167 /* Non-thread safe init case. */
168 if (ot) {
169 return;
171 ot = true;
174 if ((ret = SMB_THREAD_CREATE_TLS("test_tls", pkey)) != 0) {
175 printf("Create tls once error: %d\n", ret);
179 /* Test function. */
180 int test_threads(void)
182 int ret;
183 void *plock = NULL;
184 smb_thread_set_functions(&tf);
186 SMB_THREAD_ONCE(&ot, init_fn);
188 if ((ret = SMB_THREAD_CREATE_MUTEX("test", plock)) != 0) {
189 printf("Create lock error: %d\n", ret);
191 if ((ret = SMB_THREAD_LOCK(plock, SMB_THREAD_LOCK)) != 0) {
192 printf("lock error: %d\n", ret);
194 if ((ret = SMB_THREAD_LOCK(plock, SMB_THREAD_UNLOCK)) != 0) {
195 printf("unlock error: %d\n", ret);
197 SMB_THREAD_DESTROY_MUTEX(plock);
198 SMB_THREAD_DESTROY_TLS(pkey);
200 return 0;
202 #endif