← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mysys/my_thr_init.cc

  • Committer: Brian Aker
  • Date: 2009-04-27 14:36:40 UTC
  • Revision ID: brian@gaz-20090427143640-f6zjmtt9vm55qgm2
Patch on show processlist from  davi@apache.org

Show diffs side-by-side

added added

removed removed

Lines of Context:
mysys/my_thr_init.cc
18
18
  thread variables.
19
19
*/
20
20
 
21
 
#include "mysys_priv.h"
 
21
#include "mysys/mysys_priv.h"
 
22
#include <mysys/my_pthread.h>
22
23
#include <mystrings/m_string.h>
 
24
 
 
25
#include <stdio.h>
23
26
#include <signal.h>
24
27
 
 
28
#if TIME_WITH_SYS_TIME
 
29
# include <sys/time.h>
 
30
# include <time.h>
 
31
#else
 
32
# if HAVE_SYS_TIME_H
 
33
#  include <sys/time.h>
 
34
# else
 
35
#  include <time.h>
 
36
# endif
 
37
#endif
 
38
 
25
39
uint32_t thd_lib_detected= 0;
26
40
 
27
 
#ifdef USE_TLS
28
 
pthread_key(struct st_my_thread_var*, THR_KEY_mysys);
29
 
#else
30
 
pthread_key(struct st_my_thread_var, THR_KEY_mysys);
31
 
#endif /* USE_TLS */
32
 
pthread_mutex_t THR_LOCK_malloc,THR_LOCK_open,
33
 
                THR_LOCK_lock,THR_LOCK_isam,THR_LOCK_myisam,THR_LOCK_heap,
34
 
                THR_LOCK_net, THR_LOCK_charset, THR_LOCK_threads, THR_LOCK_time;
 
41
pthread_key_t THR_KEY_mysys;
 
42
pthread_mutex_t THR_LOCK_open;
 
43
pthread_mutex_t THR_LOCK_lock;
 
44
pthread_mutex_t THR_LOCK_threads;
35
45
pthread_cond_t  THR_COND_threads;
36
46
uint32_t            THR_thread_count= 0;
37
47
uint32_t                my_thread_end_wait_time= 5;
38
 
#if !defined(HAVE_LOCALTIME_R) || !defined(HAVE_GMTIME_R)
39
 
pthread_mutex_t LOCK_localtime_r;
40
 
#endif
41
 
#ifndef HAVE_GETHOSTBYNAME_R
42
 
pthread_mutex_t LOCK_gethostbyname_r;
43
 
#endif
44
48
#ifdef PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP
45
49
pthread_mutexattr_t my_fast_mutexattr;
46
50
#endif
55
59
  race conditions in NPTL pthread_exit code.
56
60
*/
57
61
 
58
 
static pthread_handler_t
 
62
extern "C"
 
63
void *
59
64
nptl_pthread_exit_hack_handler(void *arg __attribute((unused)))
60
65
{
61
66
  /* Do nothing! */
90
95
    return 1;
91
96
  }
92
97
 
93
 
#ifdef TARGET_OS_LINUX
94
 
  /*
95
 
    BUG#24507: Race conditions inside current NPTL pthread_exit()
96
 
    implementation.
97
 
 
98
 
    To avoid a possible segmentation fault during concurrent
99
 
    executions of pthread_exit(), a dummy thread is spawned which
100
 
    initializes internal variables of pthread lib. See bug description
101
 
    for a full explanation.
102
 
 
103
 
    TODO: Remove this code when fixed versions of glibc6 are in common
104
 
    use.
105
 
  */
106
 
  if (thd_lib_detected == THD_LIB_NPTL)
107
 
  {
108
 
    pthread_t       dummy_thread;
109
 
    pthread_attr_t  dummy_thread_attr;
110
 
 
111
 
    pthread_attr_init(&dummy_thread_attr);
112
 
    pthread_attr_setdetachstate(&dummy_thread_attr, PTHREAD_CREATE_DETACHED);
113
 
 
114
 
    pthread_create(&dummy_thread,&dummy_thread_attr,
115
 
                   nptl_pthread_exit_hack_handler, NULL);
116
 
  }
117
 
#endif /* TARGET_OS_LINUX */
118
 
 
119
98
#ifdef PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP
120
99
  /*
121
100
    Set mutex type to "fast" a.k.a "adaptive"
139
118
                            PTHREAD_MUTEX_ERRORCHECK);
140
119
#endif
141
120
 
142
 
  pthread_mutex_init(&THR_LOCK_malloc,MY_MUTEX_INIT_FAST);
143
121
  pthread_mutex_init(&THR_LOCK_open,MY_MUTEX_INIT_FAST);
144
122
  pthread_mutex_init(&THR_LOCK_lock,MY_MUTEX_INIT_FAST);
145
 
  pthread_mutex_init(&THR_LOCK_isam,MY_MUTEX_INIT_SLOW);
146
 
  pthread_mutex_init(&THR_LOCK_myisam,MY_MUTEX_INIT_SLOW);
147
 
  pthread_mutex_init(&THR_LOCK_heap,MY_MUTEX_INIT_FAST);
148
 
  pthread_mutex_init(&THR_LOCK_net,MY_MUTEX_INIT_FAST);
149
 
  pthread_mutex_init(&THR_LOCK_charset,MY_MUTEX_INIT_FAST);
150
123
  pthread_mutex_init(&THR_LOCK_threads,MY_MUTEX_INIT_FAST);
151
 
  pthread_mutex_init(&THR_LOCK_time,MY_MUTEX_INIT_FAST);
152
124
  pthread_cond_init(&THR_COND_threads, NULL);
153
 
#if !defined(HAVE_LOCALTIME_R) || !defined(HAVE_GMTIME_R)
154
 
  pthread_mutex_init(&LOCK_localtime_r,MY_MUTEX_INIT_SLOW);
155
 
#endif
156
 
#ifndef HAVE_GETHOSTBYNAME_R
157
 
  pthread_mutex_init(&LOCK_gethostbyname_r,MY_MUTEX_INIT_SLOW);
158
 
#endif
159
125
  if (my_thread_init())
160
126
  {
161
127
    my_thread_global_end();                     /* Clean up */
178
144
                                      &abstime);
179
145
    if (error == ETIMEDOUT || error == ETIME)
180
146
    {
181
 
#ifdef HAVE_PTHREAD_KILL
182
147
      /*
183
148
        We shouldn't give an error here, because if we don't have
184
149
        pthread_kill(), programs like mysqld can't ensure that all threads
188
153
        fprintf(stderr,
189
154
                "Error in my_thread_global_end(): %d threads didn't exit\n",
190
155
                THR_thread_count);
191
 
#endif
192
156
      all_threads_killed= 0;
193
157
      break;
194
158
    }
202
166
#ifdef PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP
203
167
  pthread_mutexattr_destroy(&my_errorcheck_mutexattr);
204
168
#endif
205
 
  pthread_mutex_destroy(&THR_LOCK_malloc);
206
169
  pthread_mutex_destroy(&THR_LOCK_open);
207
170
  pthread_mutex_destroy(&THR_LOCK_lock);
208
 
  pthread_mutex_destroy(&THR_LOCK_isam);
209
 
  pthread_mutex_destroy(&THR_LOCK_myisam);
210
 
  pthread_mutex_destroy(&THR_LOCK_heap);
211
 
  pthread_mutex_destroy(&THR_LOCK_net);
212
 
  pthread_mutex_destroy(&THR_LOCK_time);
213
 
  pthread_mutex_destroy(&THR_LOCK_charset);
214
171
  if (all_threads_killed)
215
172
  {
216
173
    pthread_mutex_destroy(&THR_LOCK_threads);
217
174
    pthread_cond_destroy(&THR_COND_threads);
218
175
  }
219
 
#if !defined(HAVE_LOCALTIME_R) || !defined(HAVE_GMTIME_R)
220
 
  pthread_mutex_destroy(&LOCK_localtime_r);
221
 
#endif
222
 
#ifndef HAVE_GETHOSTBYNAME_R
223
 
  pthread_mutex_destroy(&LOCK_gethostbyname_r);
224
 
#endif
225
176
}
226
177
 
227
178
static my_thread_id thread_id= 0;
232
183
  SYNOPSIS
233
184
    my_thread_init()
234
185
 
235
 
  NOTES
236
 
    We can't use mutex_locks here if we are using windows as
237
 
    we may have compiled the program with SAFE_MUTEX, in which
238
 
    case the checking of mutex_locks will not work until
239
 
    the pthread_self thread specific variable is initialized.
240
 
 
241
186
  RETURN
242
187
    0  ok
243
188
    1  Fatal error; mysys/dbug functions can't be used
251
196
#ifdef EXTRA_DEBUG_THREADS
252
197
  fprintf(stderr,"my_thread_init(): thread_id: 0x%lx\n",
253
198
          (uint32_t) pthread_self());
254
 
#endif  
 
199
#endif
255
200
 
256
201
  if (pthread_getspecific(THR_KEY_mysys))
257
202
  {
258
203
#ifdef EXTRA_DEBUG_THREADS
259
204
    fprintf(stderr,"my_thread_init() called more than once in thread 0x%lx\n",
260
205
            (long) pthread_self());
261
 
#endif    
 
206
#endif
262
207
    goto end;
263
208
  }
264
209
  if (!(tmp= (struct st_my_thread_var *) calloc(1, sizeof(*tmp))))
302
247
#ifdef EXTRA_DEBUG_THREADS
303
248
  fprintf(stderr,"my_thread_end(): tmp: 0x%lx  pthread_self: 0x%lx  thread_id: %ld\n",
304
249
          (long) tmp, (long) pthread_self(), tmp ? (long) tmp->id : 0L);
305
 
#endif  
 
250
#endif
306
251
  if (tmp && tmp->init)
307
252
  {
308
253
#if !defined(__bsdi__) && !defined(__OpenBSD__)
310
255
    pthread_cond_destroy(&tmp->suspend);
311
256
#endif
312
257
    pthread_mutex_destroy(&tmp->mutex);
313
 
#if defined(USE_TLS)
314
 
    free(tmp);
315
 
#else
316
258
    tmp->init= 0;
317
 
#endif
318
259
 
319
260
    /*
320
261
      Decrement counter for number of running threads. We are using this
321
262
      in my_thread_global_end() to wait until all threads have called
322
263
      my_thread_end and thus freed all memory they have allocated in
323
 
      my_thread_init() 
 
264
      my_thread_init()
324
265
    */
325
266
    pthread_mutex_lock(&THR_LOCK_threads);
326
267
    assert(THR_thread_count != 0);
328
269
      pthread_cond_signal(&THR_COND_threads);
329
270
   pthread_mutex_unlock(&THR_LOCK_threads);
330
271
  }
331
 
  /* The following free has to be done, even if my_thread_var() is 0 */
332
 
#if defined(USE_TLS)
333
 
  pthread_setspecific(THR_KEY_mysys,0);
334
 
#endif
335
272
}
336
273
 
337
274
struct st_my_thread_var *_my_thread_var(void)
338
275
{
339
276
  struct st_my_thread_var *tmp= (struct st_my_thread_var*)pthread_getspecific(THR_KEY_mysys);
340
 
#if defined(USE_TLS)
341
 
  /* This can only happen in a .DLL */
342
 
  if (!tmp)
343
 
  {
344
 
    my_thread_init();
345
 
    tmp=my_pthread_getspecific(struct st_my_thread_var*,THR_KEY_mysys);
346
 
  }
347
 
#endif
348
277
  return tmp;
349
278
}
350
279
 
362
291
{
363
292
#ifdef _CS_GNU_LIBPTHREAD_VERSION
364
293
  char buff[64];
365
 
    
 
294
 
366
295
  confstr(_CS_GNU_LIBPTHREAD_VERSION, buff, sizeof(buff));
367
296
 
368
297
  if (!strncasecmp(buff, "NPTL", 4))