dep/include/mysql/my_pthread.h

   1 /* Copyright (C) 2000 MySQL AB
   2
   3    This program is free software; you can redistribute it and/or modify
   4    it under the terms of the GNU General Public License as published by
   5    the Free Software Foundation; version 2 of the License.
   6
   7    This program is distributed in the hope that it will be useful,
   8    but WITHOUT ANY WARRANTY; without even the implied warranty of
   9    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10    GNU General Public License for more details.
  11
  12    You should have received a copy of the GNU General Public License
  13    along with this program; if not, write to the Free Software
  14    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  15
  16 /* Defines to make different thread packages compatible */
  17
  18 #ifndef _my_pthread_h
  19 #define _my_pthread_h
  20
  21 #include <errno.h>
  22 #ifndef ETIME
  23 #define ETIME ETIMEDOUT                         /* For FreeBSD */
  24 #endif
  25
  26 #ifdef  __cplusplus
  27 #define EXTERNC extern "C"
  28 extern "C" {
  29 #else
  30 #define EXTERNC
  31 #endif /* __cplusplus */
  32
  33 #if defined(__WIN__) || defined(OS2)
  34
  35 #ifdef OS2
  36 typedef ULONG     HANDLE;
  37 typedef ULONG     DWORD;
  38 typedef int sigset_t;
  39 #endif
  40
  41 #ifdef OS2
  42 typedef HMTX             pthread_mutex_t;
  43 #else
  44 typedef CRITICAL_SECTION pthread_mutex_t;
  45 #endif
  46 typedef HANDLE           pthread_t;
  47 typedef struct thread_attr {
  48     DWORD dwStackSize ;
  49     DWORD dwCreatingFlag ;
  50     int priority ;
  51 } pthread_attr_t ;
  52
  53 typedef struct { int dummy; } pthread_condattr_t;
  54
  55 /* Implementation of posix conditions */
  56
  57 typedef struct st_pthread_link {
  58   DWORD thread_id;
  59   struct st_pthread_link *next;
  60 } pthread_link;
  61
  62 typedef struct {
  63   uint32 waiting;
  64   CRITICAL_SECTION lock_waiting;
  65
  66   enum {
  67     SIGNAL= 0,
  68     BROADCAST= 1,
  69     MAX_EVENTS= 2
  70   } EVENTS;
  71
  72   HANDLE events[MAX_EVENTS];
  73   HANDLE broadcast_block_event;
  74
  75 } pthread_cond_t;
  76
  77 typedef int pthread_mutexattr_t;
  78 #define win_pthread_self my_thread_var->pthread_self
  79 #ifdef OS2
  80 #define pthread_handler_t EXTERNC void * _Optlink
  81 typedef void * (_Optlink *pthread_handler)(void *);
  82 #else
  83 #define pthread_handler_t EXTERNC void * __cdecl
  84 typedef void * (__cdecl *pthread_handler)(void *);
  85 #endif
  86
  87 /*
  88   Struct and macros to be used in combination with the
  89   windows implementation of pthread_cond_timedwait
  90 */
  91
  92 /*
  93    Declare a union to make sure FILETIME is properly aligned
  94    so it can be used directly as a 64 bit value. The value
  95    stored is in 100ns units.
  96  */
  97  union ft64 {
  98   FILETIME ft;
  99   __int64 i64;
 100  };
 101 struct timespec {
 102   union ft64 tv;
 103   /* The max timeout value in millisecond for pthread_cond_timedwait */
 104   long max_timeout_msec;
 105 };
 106 #define set_timespec(ABSTIME,SEC) { \
 107   GetSystemTimeAsFileTime(&((ABSTIME).tv.ft)); \
 108   (ABSTIME).tv.i64+= (__int64)(SEC)*10000000; \
 109   (ABSTIME).max_timeout_msec= (long)((SEC)*1000); \
 110 }
 111 #define set_timespec_nsec(ABSTIME,NSEC) { \
 112   GetSystemTimeAsFileTime(&((ABSTIME).tv.ft)); \
 113   (ABSTIME).tv.i64+= (__int64)(NSEC)/100; \
 114   (ABSTIME).max_timeout_msec= (long)((NSEC)/1000000); \
 115 }
 116
 117 void win_pthread_init(void);
 118 int win_pthread_setspecific(void *A,void *B,uint length);
 119 int win_pthread_mutex_trylock(pthread_mutex_t *mutex);
 120 int pthread_create(pthread_t *,pthread_attr_t *,pthread_handler,void *);
 121 int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr);
 122 int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
 123 int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex,
 124                            struct timespec *abstime);
 125 int pthread_cond_signal(pthread_cond_t *cond);
 126 int pthread_cond_broadcast(pthread_cond_t *cond);
 127 int pthread_cond_destroy(pthread_cond_t *cond);
 128 int pthread_attr_init(pthread_attr_t *connect_att);
 129 int pthread_attr_setstacksize(pthread_attr_t *connect_att,DWORD stack);
 130 int pthread_attr_setprio(pthread_attr_t *connect_att,int priority);
 131 int pthread_attr_destroy(pthread_attr_t *connect_att);
 132 struct tm *localtime_r(const time_t *timep,struct tm *tmp);
 133 struct tm *gmtime_r(const time_t *timep,struct tm *tmp);
 134
 135
 136 void pthread_exit(void *a);      /* was #define pthread_exit(A) ExitThread(A)*/
 137
 138 #ifndef OS2
 139 #define ETIMEDOUT 145               /* Win32 doesn't have this */
 140 #define getpid() GetCurrentThreadId()
 141 #endif
 142 #define pthread_self() win_pthread_self
 143 #define HAVE_LOCALTIME_R                1
 144 #define _REENTRANT                      1
 145 #define HAVE_PTHREAD_ATTR_SETSTACKSIZE  1
 146
 147 #ifdef USE_TLS                                  /* For LIBMYSQL.DLL */
 148 #undef SAFE_MUTEX                               /* This will cause conflicts */
 149 #define pthread_key(T,V)  DWORD V
 150 #define pthread_key_create(A,B) ((*A=TlsAlloc())==0xFFFFFFFF)
 151 #define pthread_key_delete(A) TlsFree(A)
 152 #define pthread_getspecific(A) (TlsGetValue(A))
 153 #define my_pthread_getspecific(T,A) ((T) TlsGetValue(A))
 154 #define my_pthread_getspecific_ptr(T,V) ((T) TlsGetValue(V))
 155 #define my_pthread_setspecific_ptr(T,V) (!TlsSetValue((T),(V)))
 156 #define pthread_setspecific(A,B) (!TlsSetValue((A),(B)))
 157 #else
 158 #define pthread_key(T,V) __declspec(thread) T V
 159 #define pthread_key_create(A,B) pthread_dummy(0)
 160 #define pthread_key_delete(A) pthread_dummy(0)
 161 #define pthread_getspecific(A) (&(A))
 162 #define my_pthread_getspecific(T,A) (&(A))
 163 #define my_pthread_getspecific_ptr(T,V) (V)
 164 #define my_pthread_setspecific_ptr(T,V) ((T)=(V),0)
 165 #define pthread_setspecific(A,B) win_pthread_setspecific(&(A),(B),sizeof(A))
 166 #endif /* USE_TLS */
 167
 168 #define pthread_equal(A,B) ((A) == (B))
 169 #ifdef OS2
 170 extern int pthread_mutex_init (pthread_mutex_t *, const pthread_mutexattr_t *);
 171 extern int pthread_mutex_lock (pthread_mutex_t *);
 172 extern int pthread_mutex_unlock (pthread_mutex_t *);
 173 extern int pthread_mutex_destroy (pthread_mutex_t *);
 174 #define my_pthread_setprio(A,B)  DosSetPriority(PRTYS_THREAD,PRTYC_NOCHANGE, B, A)
 175 #define pthread_kill(A,B) raise(B)
 176 #define pthread_exit(A) pthread_dummy()
 177 #else
 178 #define pthread_mutex_init(A,B)  (InitializeCriticalSection(A),0)
 179 #define pthread_mutex_lock(A)    (EnterCriticalSection(A),0)
 180 #define pthread_mutex_trylock(A) win_pthread_mutex_trylock((A))
 181 #define pthread_mutex_unlock(A)  LeaveCriticalSection(A)
 182 #define pthread_mutex_destroy(A) DeleteCriticalSection(A)
 183 #define my_pthread_setprio(A,B)  SetThreadPriority(GetCurrentThread(), (B))
 184 #define pthread_kill(A,B) pthread_dummy(ESRCH)
 185 #endif /* OS2 */
 186
 187 /* Dummy defines for easier code */
 188 #define pthread_attr_setdetachstate(A,B) pthread_dummy(0)
 189 #define my_pthread_attr_setprio(A,B) pthread_attr_setprio(A,B)
 190 #define pthread_attr_setscope(A,B)
 191 #define pthread_detach_this_thread()
 192 #define pthread_condattr_init(A)
 193 #define pthread_condattr_destroy(A)
 194
 195 #define my_pthread_getprio(thread_id) pthread_dummy(0)
 196
 197 #elif defined(HAVE_UNIXWARE7_THREADS)
 198
 199 #include <thread.h>
 200 #include <synch.h>
 201
 202 #ifndef _REENTRANT
 203 #define _REENTRANT
 204 #endif
 205
 206 #define HAVE_NONPOSIX_SIGWAIT
 207 #define pthread_t thread_t
 208 #define pthread_cond_t cond_t
 209 #define pthread_mutex_t mutex_t
 210 #define pthread_key_t thread_key_t
 211 typedef int pthread_attr_t;                     /* Needed by Unixware 7.0.0 */
 212
 213 #define pthread_key_create(A,B) thr_keycreate((A),(B))
 214 #define pthread_key_delete(A) thr_keydelete(A)
 215
 216 #define pthread_handler_t EXTERNC void *
 217 #define pthread_key(T,V) pthread_key_t V
 218
 219 void *  my_pthread_getspecific_imp(pthread_key_t key);
 220 #define my_pthread_getspecific(A,B) ((A) my_pthread_getspecific_imp(B))
 221 #define my_pthread_getspecific_ptr(T,V) my_pthread_getspecific(T,V)
 222
 223 #define pthread_setspecific(A,B) thr_setspecific(A,B)
 224 #define my_pthread_setspecific_ptr(T,V) pthread_setspecific(T,V)
 225
 226 #define pthread_create(A,B,C,D) thr_create(NULL,65536L,(C),(D),THR_DETACHED,(A))
 227 #define pthread_cond_init(a,b) cond_init((a),USYNC_THREAD,NULL)
 228 #define pthread_cond_destroy(a) cond_destroy(a)
 229 #define pthread_cond_signal(a) cond_signal(a)
 230 #define pthread_cond_wait(a,b) cond_wait((a),(b))
 231 #define pthread_cond_timedwait(a,b,c) cond_timedwait((a),(b),(c))
 232 #define pthread_cond_broadcast(a) cond_broadcast(a)
 233
 234 #define pthread_mutex_init(a,b) mutex_init((a),USYNC_THREAD,NULL)
 235 #define pthread_mutex_lock(a) mutex_lock(a)
 236 #define pthread_mutex_unlock(a) mutex_unlock(a)
 237 #define pthread_mutex_destroy(a) mutex_destroy(a)
 238
 239 #define pthread_self() thr_self()
 240 #define pthread_exit(A) thr_exit(A)
 241 #define pthread_equal(A,B) (((A) == (B)) ? 1 : 0)
 242 #define pthread_kill(A,B) thr_kill((A),(B))
 243 #define HAVE_PTHREAD_KILL
 244
 245 #define pthread_sigmask(A,B,C) thr_sigsetmask((A),(B),(C))
 246
 247 extern int my_sigwait(const sigset_t *set,int *sig);
 248
 249 #define pthread_detach_this_thread() pthread_dummy(0)
 250
 251 #define pthread_attr_init(A) pthread_dummy(0)
 252 #define pthread_attr_destroy(A) pthread_dummy(0)
 253 #define pthread_attr_setscope(A,B) pthread_dummy(0)
 254 #define pthread_attr_setdetachstate(A,B) pthread_dummy(0)
 255 #define my_pthread_setprio(A,B) pthread_dummy (0)
 256 #define my_pthread_getprio(A) pthread_dummy (0)
 257 #define my_pthread_attr_setprio(A,B) pthread_dummy(0)
 258
 259 #else /* Normal threads */
 260
 261 #ifdef HAVE_rts_threads
 262 #define sigwait org_sigwait
 263 #include <signal.h>
 264 #undef sigwait
 265 #endif
 266 #include <pthread.h>
 267 #ifndef _REENTRANT
 268 #define _REENTRANT
 269 #endif
 270 #ifdef HAVE_THR_SETCONCURRENCY
 271 #include <thread.h>                     /* Probably solaris */
 272 #endif
 273 #ifdef HAVE_SCHED_H
 274 #include <sched.h>
 275 #endif
 276 #ifdef HAVE_SYNCH_H
 277 #include <synch.h>
 278 #endif
 279 #if defined(__EMX__) && (!defined(EMX_PTHREAD_REV) || (EMX_PTHREAD_REV < 2))
 280 #error Requires at least rev 2 of EMX pthreads library.
 281 #endif
 282
 283 #ifdef __NETWARE__
 284 void my_pthread_exit(void *status);
 285 #define pthread_exit(A) my_pthread_exit(A)
 286 #endif
 287
 288 extern int my_pthread_getprio(pthread_t thread_id);
 289
 290 #define pthread_key(T,V) pthread_key_t V
 291 #define my_pthread_getspecific_ptr(T,V) my_pthread_getspecific(T,(V))
 292 #define my_pthread_setspecific_ptr(T,V) pthread_setspecific(T,(void*) (V))
 293 #define pthread_detach_this_thread()
 294 #define pthread_handler_t EXTERNC void *
 295 typedef void *(* pthread_handler)(void *);
 296
 297 /* Test first for RTS or FSU threads */
 298
 299 #if defined(PTHREAD_SCOPE_GLOBAL) && !defined(PTHREAD_SCOPE_SYSTEM)
 300 #define HAVE_rts_threads
 301 extern int my_pthread_create_detached;
 302 #define pthread_sigmask(A,B,C) sigprocmask((A),(B),(C))
 303 #define PTHREAD_CREATE_DETACHED &my_pthread_create_detached
 304 #define PTHREAD_SCOPE_SYSTEM  PTHREAD_SCOPE_GLOBAL
 305 #define PTHREAD_SCOPE_PROCESS PTHREAD_SCOPE_LOCAL
 306 #define USE_ALARM_THREAD
 307 #elif defined(HAVE_mit_thread)
 308 #define USE_ALARM_THREAD
 309 #undef  HAVE_LOCALTIME_R
 310 #define HAVE_LOCALTIME_R
 311 #undef  HAVE_GMTIME_R
 312 #define HAVE_GMTIME_R
 313 #undef  HAVE_PTHREAD_ATTR_SETSCOPE
 314 #define HAVE_PTHREAD_ATTR_SETSCOPE
 315 #undef HAVE_GETHOSTBYNAME_R_GLIBC2_STYLE        /* If we are running linux */
 316 #undef HAVE_RWLOCK_T
 317 #undef HAVE_RWLOCK_INIT
 318 #undef HAVE_PTHREAD_RWLOCK_RDLOCK
 319 #undef HAVE_SNPRINTF
 320
 321 #define my_pthread_attr_setprio(A,B)
 322 #endif /* defined(PTHREAD_SCOPE_GLOBAL) && !defined(PTHREAD_SCOPE_SYSTEM) */
 323
 324 #if defined(_BSDI_VERSION) && _BSDI_VERSION < 199910
 325 int sigwait(sigset_t *set, int *sig);
 326 #endif
 327
 328 #ifndef HAVE_NONPOSIX_SIGWAIT
 329 #define my_sigwait(A,B) sigwait((A),(B))
 330 #else
 331 int my_sigwait(const sigset_t *set,int *sig);
 332 #endif
 333
 334 #ifdef HAVE_NONPOSIX_PTHREAD_MUTEX_INIT
 335 #ifndef SAFE_MUTEX
 336 #define pthread_mutex_init(a,b) my_pthread_mutex_init((a),(b))
 337 extern int my_pthread_mutex_init(pthread_mutex_t *mp,
 338                                  const pthread_mutexattr_t *attr);
 339 #endif /* SAFE_MUTEX */
 340 #define pthread_cond_init(a,b) my_pthread_cond_init((a),(b))
 341 extern int my_pthread_cond_init(pthread_cond_t *mp,
 342                                 const pthread_condattr_t *attr);
 343 #endif /* HAVE_NONPOSIX_PTHREAD_MUTEX_INIT */
 344
 345 #if defined(HAVE_SIGTHREADMASK) && !defined(HAVE_PTHREAD_SIGMASK)
 346 #define pthread_sigmask(A,B,C) sigthreadmask((A),(B),(C))
 347 #endif
 348
 349 #if !defined(HAVE_SIGWAIT) && !defined(HAVE_mit_thread) && !defined(HAVE_rts_threads) && !defined(sigwait) && !defined(alpha_linux_port) && !defined(HAVE_NONPOSIX_SIGWAIT) && !defined(HAVE_DEC_3_2_THREADS) && !defined(_AIX)
 350 int sigwait(sigset_t *setp, int *sigp);         /* Use our implemention */
 351 #endif
 352
 353
 354 /*
 355   We define my_sigset() and use that instead of the system sigset() so that
 356   we can favor an implementation based on sigaction(). On some systems, such
 357   as Mac OS X, sigset() results in flags such as SA_RESTART being set, and
 358   we want to make sure that no such flags are set.
 359 */
 360 #if defined(HAVE_SIGACTION) && !defined(my_sigset)
 361 #define my_sigset(A,B) do { struct sigaction l_s; sigset_t l_set; int l_rc; \
 362                             DBUG_ASSERT((A) != 0);                          \
 363                             sigemptyset(&l_set);                            \
 364                             l_s.sa_handler = (B);                           \
 365                             l_s.sa_mask   = l_set;                          \
 366                             l_s.sa_flags   = 0;                             \
 367                             l_rc= sigaction((A), &l_s, (struct sigaction *) NULL);\
 368                             DBUG_ASSERT(l_rc == 0);                         \
 369                           } while (0)
 370 #elif defined(HAVE_SIGSET) && !defined(my_sigset)
 371 #define my_sigset(A,B) sigset((A),(B))
 372 #elif !defined(my_sigset)
 373 #define my_sigset(A,B) signal((A),(B))
 374 #endif
 375
 376 #ifndef my_pthread_setprio
 377 #if defined(HAVE_PTHREAD_SETPRIO_NP)            /* FSU threads */
 378 #define my_pthread_setprio(A,B) pthread_setprio_np((A),(B))
 379 #elif defined(HAVE_PTHREAD_SETPRIO)
 380 #define my_pthread_setprio(A,B) pthread_setprio((A),(B))
 381 #else
 382 extern void my_pthread_setprio(pthread_t thread_id,int prior);
 383 #endif
 384 #endif
 385
 386 #ifndef my_pthread_attr_setprio
 387 #ifdef HAVE_PTHREAD_ATTR_SETPRIO
 388 #define my_pthread_attr_setprio(A,B) pthread_attr_setprio((A),(B))
 389 #else
 390 extern void my_pthread_attr_setprio(pthread_attr_t *attr, int priority);
 391 #endif
 392 #endif
 393
 394 #if !defined(HAVE_PTHREAD_ATTR_SETSCOPE) || defined(HAVE_DEC_3_2_THREADS)
 395 #define pthread_attr_setscope(A,B)
 396 #undef  HAVE_GETHOSTBYADDR_R                    /* No definition */
 397 #endif
 398
 399 #if defined(HAVE_BROKEN_PTHREAD_COND_TIMEDWAIT) && !defined(SAFE_MUTEX)
 400 extern int my_pthread_cond_timedwait(pthread_cond_t *cond,
 401                                      pthread_mutex_t *mutex,
 402                                      struct timespec *abstime);
 403 #define pthread_cond_timedwait(A,B,C) my_pthread_cond_timedwait((A),(B),(C))
 404 #endif
 405
 406 #if defined(OS2)
 407 #define my_pthread_getspecific(T,A) ((T) &(A))
 408 #define pthread_setspecific(A,B) win_pthread_setspecific(&(A),(B),sizeof(A))
 409 #elif !defined( HAVE_NONPOSIX_PTHREAD_GETSPECIFIC)
 410 #define my_pthread_getspecific(A,B) ((A) pthread_getspecific(B))
 411 #else
 412 #define my_pthread_getspecific(A,B) ((A) my_pthread_getspecific_imp(B))
 413 void *my_pthread_getspecific_imp(pthread_key_t key);
 414 #endif /* OS2 */
 415
 416 #ifndef HAVE_LOCALTIME_R
 417 struct tm *localtime_r(const time_t *clock, struct tm *res);
 418 #endif
 419
 420 #ifndef HAVE_GMTIME_R
 421 struct tm *gmtime_r(const time_t *clock, struct tm *res);
 422 #endif
 423
 424 #ifdef HAVE_PTHREAD_CONDATTR_CREATE
 425 /* DCE threads on HPUX 10.20 */
 426 #define pthread_condattr_init pthread_condattr_create
 427 #define pthread_condattr_destroy pthread_condattr_delete
 428 #endif
 429
 430 /* FSU THREADS */
 431 #if !defined(HAVE_PTHREAD_KEY_DELETE) && !defined(pthread_key_delete)
 432 #define pthread_key_delete(A) pthread_dummy(0)
 433 #endif
 434
 435 #ifdef HAVE_CTHREADS_WRAPPER                    /* For MacOSX */
 436 #define pthread_cond_destroy(A) pthread_dummy(0)
 437 #define pthread_mutex_destroy(A) pthread_dummy(0)
 438 #define pthread_attr_delete(A) pthread_dummy(0)
 439 #define pthread_condattr_delete(A) pthread_dummy(0)
 440 #define pthread_attr_setstacksize(A,B) pthread_dummy(0)
 441 #define pthread_equal(A,B) ((A) == (B))
 442 #define pthread_cond_timedwait(a,b,c) pthread_cond_wait((a),(b))
 443 #define pthread_attr_init(A) pthread_attr_create(A)
 444 #define pthread_attr_destroy(A) pthread_attr_delete(A)
 445 #define pthread_attr_setdetachstate(A,B) pthread_dummy(0)
 446 #define pthread_create(A,B,C,D) pthread_create((A),*(B),(C),(D))
 447 #define pthread_sigmask(A,B,C) sigprocmask((A),(B),(C))
 448 #define pthread_kill(A,B) pthread_dummy(ESRCH)
 449 #undef  pthread_detach_this_thread
 450 #define pthread_detach_this_thread() { pthread_t tmp=pthread_self() ; pthread_detach(&tmp); }
 451 #endif
 452
 453 #ifdef HAVE_DARWIN5_THREADS
 454 #define pthread_sigmask(A,B,C) sigprocmask((A),(B),(C))
 455 #define pthread_kill(A,B) pthread_dummy(ESRCH)
 456 #define pthread_condattr_init(A) pthread_dummy(0)
 457 #define pthread_condattr_destroy(A) pthread_dummy(0)
 458 #undef  pthread_detach_this_thread
 459 #define pthread_detach_this_thread() { pthread_t tmp=pthread_self() ; pthread_detach(tmp); }
 460 #endif
 461
 462 #if ((defined(HAVE_PTHREAD_ATTR_CREATE) && !defined(HAVE_SIGWAIT)) || defined(HAVE_DEC_3_2_THREADS)) && !defined(HAVE_CTHREADS_WRAPPER)
 463 /* This is set on AIX_3_2 and Siemens unix (and DEC OSF/1 3.2 too) */
 464 #define pthread_key_create(A,B) \
 465                 pthread_keycreate(A,(B) ?\
 466                                   (pthread_destructor_t) (B) :\
 467                                   (pthread_destructor_t) pthread_dummy)
 468 #define pthread_attr_init(A) pthread_attr_create(A)
 469 #define pthread_attr_destroy(A) pthread_attr_delete(A)
 470 #define pthread_attr_setdetachstate(A,B) pthread_dummy(0)
 471 #define pthread_create(A,B,C,D) pthread_create((A),*(B),(C),(D))
 472 #ifndef pthread_sigmask
 473 #define pthread_sigmask(A,B,C) sigprocmask((A),(B),(C))
 474 #endif
 475 #define pthread_kill(A,B) pthread_dummy(ESRCH)
 476 #undef  pthread_detach_this_thread
 477 #define pthread_detach_this_thread() { pthread_t tmp=pthread_self() ; pthread_detach(&tmp); }
 478 #elif !defined(__NETWARE__) /* HAVE_PTHREAD_ATTR_CREATE && !HAVE_SIGWAIT */
 479 #define HAVE_PTHREAD_KILL
 480 #endif
 481
 482 #endif /* defined(__WIN__) */
 483
 484 #if defined(HPUX10) && !defined(DONT_REMAP_PTHREAD_FUNCTIONS)
 485 #undef pthread_cond_timedwait
 486 #define pthread_cond_timedwait(a,b,c) my_pthread_cond_timedwait((a),(b),(c))
 487 int my_pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex,
 488                               struct timespec *abstime);
 489 #endif
 490
 491 #if defined(HPUX10)
 492 #define pthread_attr_getstacksize(A,B) my_pthread_attr_getstacksize(A,B)
 493 void my_pthread_attr_getstacksize(pthread_attr_t *attrib, size_t *size);
 494 #endif
 495
 496 #if defined(HAVE_POSIX1003_4a_MUTEX) && !defined(DONT_REMAP_PTHREAD_FUNCTIONS)
 497 #undef pthread_mutex_trylock
 498 #define pthread_mutex_trylock(a) my_pthread_mutex_trylock((a))
 499 int my_pthread_mutex_trylock(pthread_mutex_t *mutex);
 500 #endif
 501
 502 /*
 503   The defines set_timespec and set_timespec_nsec should be used
 504   for calculating an absolute time at which
 505   pthread_cond_timedwait should timeout
 506 */
 507 #ifdef HAVE_TIMESPEC_TS_SEC
 508 #ifndef set_timespec
 509 #define set_timespec(ABSTIME,SEC) \
 510 { \
 511   (ABSTIME).ts_sec=time(0) + (time_t) (SEC); \
 512   (ABSTIME).ts_nsec=0; \
 513 }
 514 #endif /* !set_timespec */
 515 #ifndef set_timespec_nsec
 516 #define set_timespec_nsec(ABSTIME,NSEC) \
 517 { \
 518   ulonglong now= my_getsystime() + (NSEC/100); \
 519   (ABSTIME).ts_sec=  (now / ULL(10000000)); \
 520   (ABSTIME).ts_nsec= (now % ULL(10000000) * 100 + ((NSEC) % 100)); \
 521 }
 522 #endif /* !set_timespec_nsec */
 523 #else
 524 #ifndef set_timespec
 525 #define set_timespec(ABSTIME,SEC) \
 526 {\
 527   struct timeval tv;\
 528   gettimeofday(&tv,0);\
 529   (ABSTIME).tv_sec=tv.tv_sec+(time_t) (SEC);\
 530   (ABSTIME).tv_nsec=tv.tv_usec*1000;\
 531 }
 532 #endif /* !set_timespec */
 533 #ifndef set_timespec_nsec
 534 #define set_timespec_nsec(ABSTIME,NSEC) \
 535 {\
 536   ulonglong now= my_getsystime() + (NSEC/100); \
 537   (ABSTIME).tv_sec=  (time_t) (now / ULL(10000000));                  \
 538   (ABSTIME).tv_nsec= (long) (now % ULL(10000000) * 100 + ((NSEC) % 100)); \
 539 }
 540 #endif /* !set_timespec_nsec */
 541 #endif /* HAVE_TIMESPEC_TS_SEC */
 542
 543         /* safe_mutex adds checking to mutex for easier debugging */
 544
 545 #if defined(__NETWARE__) && !defined(SAFE_MUTEX_DETECT_DESTROY)
 546 #define SAFE_MUTEX_DETECT_DESTROY
 547 #endif
 548
 549 typedef struct st_safe_mutex_t
 550 {
 551   pthread_mutex_t global,mutex;
 552   const char *file;
 553   uint line,count;
 554   pthread_t thread;
 555 #ifdef SAFE_MUTEX_DETECT_DESTROY
 556   struct st_safe_mutex_info_t *info;    /* to track destroying of mutexes */
 557 #endif
 558 } safe_mutex_t;
 559
 560 #ifdef SAFE_MUTEX_DETECT_DESTROY
 561 /*
 562   Used to track the destroying of mutexes. This needs to be a seperate
 563   structure because the safe_mutex_t structure could be freed before
 564   the mutexes are destroyed.
 565 */
 566
 567 typedef struct st_safe_mutex_info_t
 568 {
 569   struct st_safe_mutex_info_t *next;
 570   struct st_safe_mutex_info_t *prev;
 571   const char *init_file;
 572   uint32 init_line;
 573 } safe_mutex_info_t;
 574 #endif /* SAFE_MUTEX_DETECT_DESTROY */
 575
 576 int safe_mutex_init(safe_mutex_t *mp, const pthread_mutexattr_t *attr,
 577                     const char *file, uint line);
 578 int safe_mutex_lock(safe_mutex_t *mp, my_bool try_lock, const char *file, uint line);
 579 int safe_mutex_unlock(safe_mutex_t *mp,const char *file, uint line);
 580 int safe_mutex_destroy(safe_mutex_t *mp,const char *file, uint line);
 581 int safe_cond_wait(pthread_cond_t *cond, safe_mutex_t *mp,const char *file,
 582                    uint line);
 583 int safe_cond_timedwait(pthread_cond_t *cond, safe_mutex_t *mp,
 584                         struct timespec *abstime, const char *file, uint line);
 585 void safe_mutex_global_init(void);
 586 void safe_mutex_end(FILE *file);
 587
 588         /* Wrappers if safe mutex is actually used */
 589 #ifdef SAFE_MUTEX
 590 #undef pthread_mutex_init
 591 #undef pthread_mutex_lock
 592 #undef pthread_mutex_unlock
 593 #undef pthread_mutex_destroy
 594 #undef pthread_mutex_wait
 595 #undef pthread_mutex_timedwait
 596 #undef pthread_mutex_t
 597 #undef pthread_cond_wait
 598 #undef pthread_cond_timedwait
 599 #undef pthread_mutex_trylock
 600 #define pthread_mutex_init(A,B) safe_mutex_init((A),(B),__FILE__,__LINE__)
 601 #define pthread_mutex_lock(A) safe_mutex_lock((A), FALSE, __FILE__, __LINE__)
 602 #define pthread_mutex_unlock(A) safe_mutex_unlock((A),__FILE__,__LINE__)
 603 #define pthread_mutex_destroy(A) safe_mutex_destroy((A),__FILE__,__LINE__)
 604 #define pthread_cond_wait(A,B) safe_cond_wait((A),(B),__FILE__,__LINE__)
 605 #define pthread_cond_timedwait(A,B,C) safe_cond_timedwait((A),(B),(C),__FILE__,__LINE__)
 606 #define pthread_mutex_trylock(A) safe_mutex_lock((A), TRUE, __FILE__, __LINE__)
 607 #define pthread_mutex_t safe_mutex_t
 608 #define safe_mutex_assert_owner(mp) \
 609           DBUG_ASSERT((mp)->count > 0 && \
 610                       pthread_equal(pthread_self(), (mp)->thread))
 611 #define safe_mutex_assert_not_owner(mp) \
 612           DBUG_ASSERT(! (mp)->count || \
 613                       ! pthread_equal(pthread_self(), (mp)->thread))
 614 #else
 615 #define safe_mutex_assert_owner(mp)
 616 #define safe_mutex_assert_not_owner(mp)
 617 #endif /* SAFE_MUTEX */
 618
 619         /* READ-WRITE thread locking */
 620
 621 #ifdef HAVE_BROKEN_RWLOCK                       /* For OpenUnix */
 622 #undef HAVE_PTHREAD_RWLOCK_RDLOCK
 623 #undef HAVE_RWLOCK_INIT
 624 #undef HAVE_RWLOCK_T
 625 #endif
 626
 627 #if defined(USE_MUTEX_INSTEAD_OF_RW_LOCKS)
 628 /* use these defs for simple mutex locking */
 629 #define rw_lock_t pthread_mutex_t
 630 #define my_rwlock_init(A,B) pthread_mutex_init((A),(B))
 631 #define rw_rdlock(A) pthread_mutex_lock((A))
 632 #define rw_wrlock(A) pthread_mutex_lock((A))
 633 #define rw_tryrdlock(A) pthread_mutex_trylock((A))
 634 #define rw_trywrlock(A) pthread_mutex_trylock((A))
 635 #define rw_unlock(A) pthread_mutex_unlock((A))
 636 #define rwlock_destroy(A) pthread_mutex_destroy((A))
 637 #elif defined(HAVE_PTHREAD_RWLOCK_RDLOCK)
 638 #define rw_lock_t pthread_rwlock_t
 639 #define my_rwlock_init(A,B) pthread_rwlock_init((A),(B))
 640 #define rw_rdlock(A) pthread_rwlock_rdlock(A)
 641 #define rw_wrlock(A) pthread_rwlock_wrlock(A)
 642 #define rw_tryrdlock(A) pthread_rwlock_tryrdlock((A))
 643 #define rw_trywrlock(A) pthread_rwlock_trywrlock((A))
 644 #define rw_unlock(A) pthread_rwlock_unlock(A)
 645 #define rwlock_destroy(A) pthread_rwlock_destroy(A)
 646 #elif defined(HAVE_RWLOCK_INIT)
 647 #ifdef HAVE_RWLOCK_T                            /* For example Solaris 2.6-> */
 648 #define rw_lock_t rwlock_t
 649 #endif
 650 #define my_rwlock_init(A,B) rwlock_init((A),USYNC_THREAD,0)
 651 #else
 652 /* Use our own version of read/write locks */
 653 typedef struct _my_rw_lock_t {
 654         pthread_mutex_t lock;           /* lock for structure           */
 655         pthread_cond_t  readers;        /* waiting readers              */
 656         pthread_cond_t  writers;        /* waiting writers              */
 657         int             state;          /* -1:writer,0:free,>0:readers  */
 658         int             waiters;        /* number of waiting writers    */
 659 } my_rw_lock_t;
 660
 661 #define rw_lock_t my_rw_lock_t
 662 #define rw_rdlock(A) my_rw_rdlock((A))
 663 #define rw_wrlock(A) my_rw_wrlock((A))
 664 #define rw_tryrdlock(A) my_rw_tryrdlock((A))
 665 #define rw_trywrlock(A) my_rw_trywrlock((A))
 666 #define rw_unlock(A) my_rw_unlock((A))
 667 #define rwlock_destroy(A) my_rwlock_destroy((A))
 668
 669 extern int my_rwlock_init(my_rw_lock_t *, void *);
 670 extern int my_rwlock_destroy(my_rw_lock_t *);
 671 extern int my_rw_rdlock(my_rw_lock_t *);
 672 extern int my_rw_wrlock(my_rw_lock_t *);
 673 extern int my_rw_unlock(my_rw_lock_t *);
 674 extern int my_rw_tryrdlock(my_rw_lock_t *);
 675 extern int my_rw_trywrlock(my_rw_lock_t *);
 676 #endif /* USE_MUTEX_INSTEAD_OF_RW_LOCKS */
 677
 678 #define GETHOSTBYADDR_BUFF_SIZE 2048
 679
 680 #ifndef HAVE_THR_SETCONCURRENCY
 681 #define thr_setconcurrency(A) pthread_dummy(0)
 682 #endif
 683 #if !defined(HAVE_PTHREAD_ATTR_SETSTACKSIZE) && ! defined(pthread_attr_setstacksize)
 684 #define pthread_attr_setstacksize(A,B) pthread_dummy(0)
 685 #endif
 686
 687 /* Define mutex types, see my_thr_init.c */
 688 #define MY_MUTEX_INIT_SLOW   NULL
 689 #ifdef PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP
 690 extern pthread_mutexattr_t my_fast_mutexattr;
 691 #define MY_MUTEX_INIT_FAST &my_fast_mutexattr
 692 #else
 693 #define MY_MUTEX_INIT_FAST   NULL
 694 #endif
 695 #ifdef PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP
 696 extern pthread_mutexattr_t my_errorcheck_mutexattr;
 697 #define MY_MUTEX_INIT_ERRCHK &my_errorcheck_mutexattr
 698 #else
 699 #define MY_MUTEX_INIT_ERRCHK   NULL
 700 #endif
 701
 702 #ifndef ESRCH
 703 /* Define it to something */
 704 #define ESRCH 1
 705 #endif
 706
 707 extern my_bool my_thread_global_init(void);
 708 extern void my_thread_global_end(void);
 709 extern my_bool my_thread_init(void);
 710 extern void my_thread_end(void);
 711 extern const char *my_thread_name(void);
 712 extern long my_thread_id(void);
 713 extern int pthread_no_free(void *);
 714 extern int pthread_dummy(int);
 715
 716 /* All thread specific variables are in the following struct */
 717
 718 #define THREAD_NAME_SIZE 10
 719 #ifndef DEFAULT_THREAD_STACK
 720 #if SIZEOF_CHARP > 4
 721 /*
 722   MySQL can survive with 32K, but some glibc libraries require > 128K stack
 723   To resolve hostnames. Also recursive stored procedures needs stack.
 724 */
 725 #define DEFAULT_THREAD_STACK    (256*1024L)
 726 #else
 727 #define DEFAULT_THREAD_STACK    (192*1024)
 728 #endif
 729 #endif
 730
 731 struct st_my_thread_var
 732 {
 733   int thr_errno;
 734   pthread_cond_t suspend;
 735   pthread_mutex_t mutex;
 736   pthread_mutex_t * volatile current_mutex;
 737   pthread_cond_t * volatile current_cond;
 738   pthread_t pthread_self;
 739   long id;
 740   int cmp_length;
 741   int volatile abort;
 742   my_bool init;
 743   struct st_my_thread_var *next,**prev;
 744   void *opt_info;
 745 #ifndef DBUG_OFF
 746   gptr dbug;
 747   char name[THREAD_NAME_SIZE+1];
 748 #endif
 749 };
 750
 751 extern struct st_my_thread_var *_my_thread_var(void) __attribute__ ((const));
 752 extern uint my_thread_end_wait_time;
 753 #define my_thread_var (_my_thread_var())
 754 #define my_errno my_thread_var->thr_errno
 755 /*
 756   Keep track of shutdown,signal, and main threads so that my_end() will not
 757   report errors with them
 758 */
 759
 760 /* Which kind of thread library is in use */
 761
 762 #define THD_LIB_OTHER 1
 763 #define THD_LIB_NPTL  2
 764 #define THD_LIB_LT    4
 765
 766 extern uint thd_lib_detected;
 767
 768         /* statistics_xxx functions are for not essential statistic */
 769
 770 #ifndef thread_safe_increment
 771 #ifdef HAVE_ATOMIC_ADD
 772 #define thread_safe_increment(V,L) atomic_inc((atomic_t*) &V)
 773 #define thread_safe_decrement(V,L) atomic_dec((atomic_t*) &V)
 774 #define thread_safe_add(V,C,L)     atomic_add((C),(atomic_t*) &V)
 775 #define thread_safe_sub(V,C,L)     atomic_sub((C),(atomic_t*) &V)
 776 #else
 777 #define thread_safe_increment(V,L) \
 778         (pthread_mutex_lock((L)), (V)++, pthread_mutex_unlock((L)))
 779 #define thread_safe_decrement(V,L) \
 780         (pthread_mutex_lock((L)), (V)--, pthread_mutex_unlock((L)))
 781 #define thread_safe_add(V,C,L) (pthread_mutex_lock((L)), (V)+=(C), pthread_mutex_unlock((L)))
 782 #define thread_safe_sub(V,C,L) \
 783         (pthread_mutex_lock((L)), (V)-=(C), pthread_mutex_unlock((L)))
 784 #endif /* HAVE_ATOMIC_ADD */
 785 #ifdef SAFE_STATISTICS
 786 #define statistic_increment(V,L)   thread_safe_increment((V),(L))
 787 #define statistic_decrement(V,L)   thread_safe_decrement((V),(L))
 788 #define statistic_add(V,C,L)       thread_safe_add((V),(C),(L))
 789 #else
 790 #define statistic_decrement(V,L) (V)--
 791 #define statistic_increment(V,L) (V)++
 792 #define statistic_add(V,C,L)     (V)+=(C)
 793 #endif /* SAFE_STATISTICS */
 794 #endif /* thread_safe_increment */
 795
 796 #ifdef  __cplusplus
 797 }
 798 #endif
 799 #endif /* _my_ptread_h */