my_pthread.h

/*
 * Copyright (c) 2000, 2024, Oracle and/or its affiliates.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License, version 2.0, as
 * published by the Free Software Foundation.
 *
 * This program is designed to work with certain software (including
 * but not limited to OpenSSL) that is licensed under separate terms, as
 * designated in a particular file or component or in included license
 * documentation. The authors of MySQL hereby grant you an additional
 * permission to link the program and your derivative works with the
 * separately licensed software that they have either included with
 * the program or referenced in the documentation.
 *
 * Without limiting anything contained in the foregoing, this file,
 * which is part of Connector/C++, is also subject to the
 * Universal FOSS Exception, version 1.0, a copy of which can be found at
 * https://oss.oracle.com/licenses/universal-foss-exception.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License, version 2.0, for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 */



/* Defines to make different thread packages compatible */

#ifndef_my_pthread_h
#define_my_pthread_h

#ifndefETIME
#defineETIME ETIMEDOUT /* For FreeBSD */
#endif

#ifdef__cplusplus
#defineEXTERNC extern "C"
extern"C" {
#else
#defineEXTERNC
#endif/* __cplusplus */

#if defined(_WIN32) || defined(_WIN64)
typedefCRITICAL_SECTIONpthread_mutex_t;
typedefDWORDpthread_t;
typedefstructthread_attr {
DWORDdwStackSize ;
DWORDdwCreatingFlag ;
} pthread_attr_t ;

typedefstruct { intdummy; } pthread_condattr_t;

/* Implementation of posix conditions */

typedefstructst_pthread_link {
DWORDthread_id;
structst_pthread_link*next;
} pthread_link;

typedefstruct {
uint32waiting;
CRITICAL_SECTIONlock_waiting;

enum {
SIGNAL=0,
BROADCAST=1,
MAX_EVENTS=2
 } EVENTS;

HANDLEevents[MAX_EVENTS];
HANDLEbroadcast_block_event;

} pthread_cond_t;


typedefintpthread_mutexattr_t;
#definepthread_self() GetCurrentThreadId()
#definepthread_handler_t EXTERNC void * __cdecl
typedefvoid* (__cdecl *pthread_handler)(void*);

/*
 Struct and macros to be used in combination with the
 windows implementation of pthread_cond_timedwait
*/

/*
 Declare a union to make sure FILETIME is properly aligned
 so it can be used directly as a 64 bit value. The value
 stored is in 100ns units.
 */
unionft64 {
FILETIMEft;
__int64i64;
};

structtimespec {
unionft64tv;
/* The max timeout value in millisecond for pthread_cond_timedwait */
longmax_timeout_msec;
};

#defineset_timespec_time_nsec(ABSTIME,TIME,NSEC) do { \
 (ABSTIME).tv.i64= (TIME)+(__int64)(NSEC)/100; \
 (ABSTIME).max_timeout_msec= (long)((NSEC)/1000000); \
} while(0)

#defineset_timespec_nsec(ABSTIME,NSEC) do { \
 union ft64 tv; \
 GetSystemTimeAsFileTime(&tv.ft); \
 set_timespec_time_nsec((ABSTIME), tv.i64, (NSEC)); \
} while(0)

intwin_pthread_mutex_trylock(pthread_mutex_t*mutex);
intpthread_create(pthread_t*,pthread_attr_t*,pthread_handler,void*);
intpthread_cond_init(pthread_cond_t*cond, constpthread_condattr_t*attr);
intpthread_cond_wait(pthread_cond_t*cond, pthread_mutex_t*mutex);
intpthread_cond_timedwait(pthread_cond_t*cond, pthread_mutex_t*mutex,
structtimespec*abstime);
intpthread_cond_signal(pthread_cond_t*cond);
intpthread_cond_broadcast(pthread_cond_t*cond);
intpthread_cond_destroy(pthread_cond_t*cond);
intpthread_attr_init(pthread_attr_t*connect_att);
intpthread_attr_setstacksize(pthread_attr_t*connect_att,DWORDstack);
intpthread_attr_destroy(pthread_attr_t*connect_att);
structtm*localtime_r(consttime_t*timep,structtm*tmp);
structtm*gmtime_r(consttime_t*timep,structtm*tmp);

voidpthread_exit(void*a);
intpthread_join(pthread_tthread, void**value_ptr);


#defineETIMEDOUT 145 /* Win32 doesn't have this */
#defineHAVE_LOCALTIME_R 1
#define_REENTRANT 1
#defineHAVE_PTHREAD_ATTR_SETSTACKSIZE 1


#undef SAFE_MUTEX /* This will cause conflicts */
#definepthread_key(T,V) DWORD V
#definepthread_key_create(A,B) ((*A=TlsAlloc())==0xFFFFFFFF)
#definepthread_key_delete(A) TlsFree(A)
#definemy_pthread_setspecific_ptr(T,V) (!TlsSetValue((T),(V)))
#definepthread_setspecific(A,B) (!TlsSetValue((A),(B)))
#definepthread_getspecific(A) (TlsGetValue(A))
#definemy_pthread_getspecific(T,A) ((T) TlsGetValue(A))
#definemy_pthread_getspecific_ptr(T,V) ((T) TlsGetValue(V))

#definepthread_equal(A,B) ((A) == (B))
#definepthread_mutex_init(A,B) (InitializeCriticalSection(A),0)
#definepthread_mutex_lock(A) (EnterCriticalSection(A),0)
#definepthread_mutex_trylock(A) win_pthread_mutex_trylock((A))
#definepthread_mutex_unlock(A) (LeaveCriticalSection(A),0)
#definepthread_mutex_destroy(A) DeleteCriticalSection(A)
#definepthread_kill(A,B) pthread_dummy((A) ? 0 : ESRCH)


/* Dummy defines for easier code */
#definepthread_attr_setdetachstate(A,B) pthread_dummy(0)
#definepthread_attr_setscope(A,B)
#definepthread_detach_this_thread()
#definepthread_condattr_init(A)
#definepthread_condattr_destroy(A)
#definepthread_yield() SwitchToThread()


#else/* Normal threads */

#ifdefHAVE_rts_threads
#definesigwait org_sigwait
#include<signal.h>
#undef sigwait
#endif
#include<pthread.h>
#ifndef_REENTRANT
#define_REENTRANT
#endif
#ifdefHAVE_THR_SETCONCURRENCY
#include<thread.h>/* Probably solaris */
#endif
#ifdefHAVE_SCHED_H
#include<sched.h>
#endif
#ifdefHAVE_SYNCH_H
#include<synch.h>
#endif

#ifdef__NETWARE__
voidmy_pthread_exit(void*status);
#definepthread_exit(A) my_pthread_exit(A)
#endif

#definepthread_key(T,V) pthread_key_t V
#definemy_pthread_getspecific_ptr(T,V) my_pthread_getspecific(T,(V))
#definemy_pthread_setspecific_ptr(T,V) pthread_setspecific(T,(void*) (V))
#definepthread_detach_this_thread()
#definepthread_handler_t EXTERNC void *
typedefvoid*(*pthread_handler)(void*);

/* Test first for RTS or FSU threads */

#if defined(PTHREAD_SCOPE_GLOBAL) && !defined(PTHREAD_SCOPE_SYSTEM)
#defineHAVE_rts_threads
externintmy_pthread_create_detached;
#definepthread_sigmask(A,B,C) sigprocmask((A),(B),(C))
#definePTHREAD_CREATE_DETACHED &my_pthread_create_detached
#definePTHREAD_SCOPE_SYSTEM PTHREAD_SCOPE_GLOBAL
#definePTHREAD_SCOPE_PROCESS PTHREAD_SCOPE_LOCAL
#defineUSE_ALARM_THREAD
#endif/* defined(PTHREAD_SCOPE_GLOBAL) && !defined(PTHREAD_SCOPE_SYSTEM) */

#if defined(_BSDI_VERSION) &&_BSDI_VERSION<199910
intsigwait(sigset_t*set, int*sig);
#endif

#ifndefHAVE_NONPOSIX_SIGWAIT
#definemy_sigwait(A,B) sigwait((A),(B))
#else
intmy_sigwait(constsigset_t*set,int*sig);
#endif

#ifdefHAVE_NONPOSIX_PTHREAD_MUTEX_INIT
#ifndefSAFE_MUTEX
#definepthread_mutex_init(a,b) my_pthread_mutex_noposix_init((a),(b))
externintmy_pthread_mutex_noposix_init(pthread_mutex_t*mp,
constpthread_mutexattr_t*attr);
#endif/* SAFE_MUTEX */
#definepthread_cond_init(a,b) my_pthread_cond_noposix_init((a),(b))
externintmy_pthread_cond_noposix_init(pthread_cond_t*mp,
constpthread_condattr_t*attr);
#endif/* HAVE_NONPOSIX_PTHREAD_MUTEX_INIT */

#if defined(HAVE_SIGTHREADMASK) && !defined(HAVE_PTHREAD_SIGMASK)
#definepthread_sigmask(A,B,C) sigthreadmask((A),(B),(C))
#endif

#if !defined(HAVE_SIGWAIT) && !defined(HAVE_rts_threads) && !defined(sigwait) && !defined(alpha_linux_port) && !defined(HAVE_NONPOSIX_SIGWAIT) && !defined(HAVE_DEC_3_2_THREADS) && !defined(_AIX)
intsigwait(sigset_t*setp, int*sigp); /* Use our implemention */
#endif


/*
 We define my_sigset() and use that instead of the system sigset() so that
 we can favor an implementation based on sigaction(). On some systems, such
 as Mac OS X, sigset() results in flags such as SA_RESTART being set, and
 we want to make sure that no such flags are set.
*/
#if defined(HAVE_SIGACTION) && !defined(my_sigset)
#definemy_sigset(A,B) do { struct sigaction l_s; sigset_t l_set; int l_rc; \
 DBUG_ASSERT((A) != 0); \
 sigemptyset(&l_set); \
 l_s.sa_handler = (B); \
 l_s.sa_mask = l_set; \
 l_s.sa_flags = 0; \
 l_rc= sigaction((A), &l_s, (struct sigaction *) NULL);\
 DBUG_ASSERT(l_rc == 0); \
 } while (0)
#elif defined(HAVE_SIGSET) && !defined(my_sigset)
#definemy_sigset(A,B) sigset((A),(B))
#elif !defined(my_sigset)
#definemy_sigset(A,B) signal((A),(B))
#endif

#if !defined(HAVE_PTHREAD_ATTR_SETSCOPE) || defined(HAVE_DEC_3_2_THREADS)
#definepthread_attr_setscope(A,B)
#undef HAVE_GETHOSTBYADDR_R /* No definition */
#endif

#if defined(HAVE_BROKEN_PTHREAD_COND_TIMEDWAIT) && !defined(SAFE_MUTEX)
externintmy_pthread_cond_timedwait(pthread_cond_t*cond, pthread_mutex_t*mutex, structtimespec*abstime);
#definepthread_cond_timedwait(A,B,C) my_pthread_cond_timedwait((A),(B),(C))
#endif

#if !defined( HAVE_NONPOSIX_PTHREAD_GETSPECIFIC)
#definemy_pthread_getspecific(A,B) ((A) pthread_getspecific(B))
#else
#definemy_pthread_getspecific(A,B) ((A) my_pthread_getspecific_imp(B))
void*my_pthread_getspecific_imp(pthread_key_tkey);
#endif

#ifndefHAVE_LOCALTIME_R
structtm*localtime_r(consttime_t*clock, structtm*res);
#endif

#ifndefHAVE_GMTIME_R
structtm*gmtime_r(consttime_t*clock, structtm*res);
#endif

#ifdefHAVE_PTHREAD_CONDATTR_CREATE
/* DCE threads on HPUX 10.20 */
#definepthread_condattr_init pthread_condattr_create
#definepthread_condattr_destroy pthread_condattr_delete
#endif

/* FSU THREADS */
#if !defined(HAVE_PTHREAD_KEY_DELETE) && !defined(pthread_key_delete)
#definepthread_key_delete(A) pthread_dummy(0)
#endif

#ifdefHAVE_CTHREADS_WRAPPER/* For MacOSX */
#definepthread_cond_destroy(A) pthread_dummy(0)
#definepthread_mutex_destroy(A) pthread_dummy(0)
#definepthread_attr_delete(A) pthread_dummy(0)
#definepthread_condattr_delete(A) pthread_dummy(0)
#definepthread_attr_setstacksize(A,B) pthread_dummy(0)
#definepthread_equal(A,B) ((A) == (B))
#definepthread_cond_timedwait(a,b,c) pthread_cond_wait((a),(b))
#definepthread_attr_init(A) pthread_attr_create(A)
#definepthread_attr_destroy(A) pthread_attr_delete(A)
#definepthread_attr_setdetachstate(A,B) pthread_dummy(0)
#definepthread_create(A,B,C,D) pthread_create((A),*(B),(C),(D))
#definepthread_sigmask(A,B,C) sigprocmask((A),(B),(C))
#definepthread_kill(A,B) pthread_dummy((A) ? 0 : ESRCH)
#undef pthread_detach_this_thread
#definepthread_detach_this_thread() { pthread_t tmp=pthread_self() ; pthread_detach(&tmp); }
#endif

#ifdefHAVE_DARWIN5_THREADS
#definepthread_sigmask(A,B,C) sigprocmask((A),(B),(C))
#definepthread_kill(A,B) pthread_dummy((A) ? 0 : ESRCH)
#definepthread_condattr_init(A) pthread_dummy(0)
#definepthread_condattr_destroy(A) pthread_dummy(0)
#undef pthread_detach_this_thread
#definepthread_detach_this_thread() { pthread_t tmp=pthread_self() ; pthread_detach(tmp); }
#endif

#if ((defined(HAVE_PTHREAD_ATTR_CREATE) && !defined(HAVE_SIGWAIT)) || defined(HAVE_DEC_3_2_THREADS)) && !defined(HAVE_CTHREADS_WRAPPER)
/* This is set on AIX_3_2 and Siemens unix (and DEC OSF/1 3.2 too) */
#definepthread_key_create(A,B) \
 pthread_keycreate(A,(B) ?\
 (pthread_destructor_t) (B) :\
 (pthread_destructor_t) pthread_dummy)
#definepthread_attr_init(A) pthread_attr_create(A)
#definepthread_attr_destroy(A) pthread_attr_delete(A)
#definepthread_attr_setdetachstate(A,B) pthread_dummy(0)
#definepthread_create(A,B,C,D) pthread_create((A),*(B),(C),(D))
#ifndefpthread_sigmask
#definepthread_sigmask(A,B,C) sigprocmask((A),(B),(C))
#endif
#definepthread_kill(A,B) pthread_dummy((A) ? 0 : ESRCH)
#undef pthread_detach_this_thread
#definepthread_detach_this_thread() { pthread_t tmp=pthread_self() ; pthread_detach(&tmp); }
#elif !defined(__NETWARE__) /* HAVE_PTHREAD_ATTR_CREATE && !HAVE_SIGWAIT */
#defineHAVE_PTHREAD_KILL
#endif

#endif/* defined(__WIN__) */

#if defined(HPUX10) && !defined(DONT_REMAP_PTHREAD_FUNCTIONS)
#undef pthread_cond_timedwait
#definepthread_cond_timedwait(a,b,c) my_pthread_cond_timedwait((a),(b),(c))
intmy_pthread_cond_timedwait(pthread_cond_t*cond, pthread_mutex_t*mutex,
structtimespec*abstime);
#endif

#if defined(HPUX10)
#definepthread_attr_getstacksize(A,B) my_pthread_attr_getstacksize(A,B)
voidmy_pthread_attr_getstacksize(pthread_attr_t*attrib, size_t*size);
#endif

#if defined(HAVE_POSIX1003_4a_MUTEX) && !defined(DONT_REMAP_PTHREAD_FUNCTIONS)
#undef pthread_mutex_trylock
#definepthread_mutex_trylock(a) my_pthread_mutex_trylock((a))
intmy_pthread_mutex_trylock(pthread_mutex_t*mutex);
#endif

#if !defined(HAVE_PTHREAD_YIELD_ONE_ARG) && !defined(HAVE_PTHREAD_YIELD_ZERO_ARG)
/* no pthread_yield() available */
#ifdefHAVE_SCHED_YIELD
#definepthread_yield() sched_yield()
#elif defined(HAVE_PTHREAD_YIELD_NP) /* can be Mac OS X */
#definepthread_yield() pthread_yield_np()
#elif defined(HAVE_THR_YIELD)
#definepthread_yield() thr_yield()
#endif
#endif

/*
 The defines set_timespec and set_timespec_nsec should be used
 for calculating an absolute time at which
 pthread_cond_timedwait should timeout
*/

#defineset_timespec(ABSTIME,SEC) set_timespec_nsec((ABSTIME),(SEC)*1000000000ULL)

#ifndefset_timespec_nsec
#defineset_timespec_nsec(ABSTIME,NSEC) \
 set_timespec_time_nsec((ABSTIME),my_getsystime(),(NSEC))
#endif/* !set_timespec_nsec */

/* adapt for two different flavors of struct timespec */
#ifdefHAVE_TIMESPEC_TS_SEC
#defineMY_tv_sec ts_sec
#defineMY_tv_nsec ts_nsec
#else
#defineMY_tv_sec tv_sec
#defineMY_tv_nsec tv_nsec
#endif/* HAVE_TIMESPEC_TS_SEC */

#ifndefset_timespec_time_nsec
#defineset_timespec_time_nsec(ABSTIME,TIME,NSEC) do { \
 ulonglong nsec= (NSEC); \
 ulonglong now= (TIME) + (nsec/100); \
 (ABSTIME).MY_tv_sec= (now / ULL(10000000)); \
 (ABSTIME).MY_tv_nsec= (now % ULL(10000000) * 100 + (nsec % 100)); \
} while(0)
#endif/* !set_timespec_time_nsec */

/* safe_mutex adds checking to mutex for easier debugging */

#if defined(__NETWARE__) && !defined(SAFE_MUTEX_DETECT_DESTROY)
#defineSAFE_MUTEX_DETECT_DESTROY
#endif
structst_hash;

typedefstructst_safe_mutex_t
{
pthread_mutex_tglobal,mutex;
constchar*file, *name;
uintline,count;
myfcreate_flags, active_flags;
ulongid;
pthread_tthread;
structst_hash*locked_mutex, *used_mutex;
structst_safe_mutex_t*prev, *next;
#ifdefSAFE_MUTEX_DETECT_DESTROY
structst_safe_mutex_info_t*info; /* to track destroying of mutexes */
#endif
} safe_mutex_t;

typedefstructst_safe_mutex_deadlock_t
{
constchar*file, *name;
safe_mutex_t*mutex;
uintline;
ulongcount;
ulongid;
my_boolwarning_only;
} safe_mutex_deadlock_t;

#ifdefSAFE_MUTEX_DETECT_DESTROY
/*
 Used to track the destroying of mutexes. This needs to be a seperate
 structure because the safe_mutex_t structure could be freed before
 the mutexes are destroyed.
*/

typedefstructst_safe_mutex_info_t
{
structst_safe_mutex_info_t*next;
structst_safe_mutex_info_t*prev;
constchar*init_file;
uint32init_line;
} safe_mutex_info_t;
#endif/* SAFE_MUTEX_DETECT_DESTROY */

intsafe_mutex_init(safe_mutex_t*mp, constpthread_mutexattr_t*attr,
constchar*name, myfmy_flags,
constchar*file, uintline);
intsafe_mutex_lock(safe_mutex_t*mp, myfmy_flags, constchar*file,
uintline);
intsafe_mutex_unlock(safe_mutex_t*mp,constchar*file, uintline);
intsafe_mutex_destroy(safe_mutex_t*mp,constchar*file, uintline);
intsafe_cond_wait(pthread_cond_t*cond, safe_mutex_t*mp,constchar*file,
uintline);
intsafe_cond_timedwait(pthread_cond_t*cond, safe_mutex_t*mp,
structtimespec*abstime, constchar*file, uintline);
voidsafe_mutex_global_init(void);
voidsafe_mutex_end(FILE*file);
voidsafe_mutex_free_deadlock_data(safe_mutex_t*mp);

/* Wrappers if safe mutex is actually used */
#defineMYF_TRY_LOCK 1
#defineMYF_NO_DEADLOCK_DETECTION 2

#ifdefSAFE_MUTEX
#undef pthread_mutex_init
#undef pthread_mutex_lock
#undef pthread_mutex_unlock
#undef pthread_mutex_destroy
#undef pthread_mutex_wait
#undef pthread_mutex_timedwait
#undef pthread_mutex_t
#undef pthread_cond_wait
#undef pthread_cond_timedwait
#undef pthread_mutex_trylock
#definemy_pthread_mutex_init(A,B,C,D) safe_mutex_init((A),(B),(C),(D),__FILE__,__LINE__)
#definepthread_mutex_init(A,B) safe_mutex_init((A),(B),#A,0,__FILE__,__LINE__)
#definepthread_mutex_lock(A) safe_mutex_lock((A), 0, __FILE__, __LINE__)
#definemy_pthread_mutex_lock(A,B) safe_mutex_lock((A), (B), __FILE__, __LINE__)
#definepthread_mutex_unlock(A) safe_mutex_unlock((A),__FILE__,__LINE__)
#definepthread_mutex_destroy(A) safe_mutex_destroy((A),__FILE__,__LINE__)
#definepthread_cond_wait(A,B) safe_cond_wait((A),(B),__FILE__,__LINE__)
#definepthread_cond_timedwait(A,B,C) safe_cond_timedwait((A),(B),(C),__FILE__,__LINE__)
#definepthread_mutex_trylock(A) safe_mutex_lock((A), MYF_TRY_LOCK, __FILE__, __LINE__)
#definepthread_mutex_t safe_mutex_t
#definesafe_mutex_assert_owner(mp) \
 DBUG_ASSERT((mp)->count > 0 && \
 pthread_equal(pthread_self(), (mp)->thread))
#definesafe_mutex_assert_not_owner(mp) \
 DBUG_ASSERT(! (mp)->count || \
 ! pthread_equal(pthread_self(), (mp)->thread))
#else
#definemy_pthread_mutex_init(A,B,C,D) pthread_mutex_init((A),(B))
#definemy_pthread_mutex_lock(A,B) pthread_mutex_lock(A)
#definesafe_mutex_assert_owner(mp)
#definesafe_mutex_assert_not_owner(mp)
#definesafe_mutex_free_deadlock_data(mp)
#endif/* SAFE_MUTEX */

#if defined(MY_PTHREAD_FASTMUTEX) && !defined(SAFE_MUTEX)
typedefstructst_my_pthread_fastmutex_t
{
pthread_mutex_tmutex;
uintspins;
uintrng_state;
} my_pthread_fastmutex_t;
voidfastmutex_global_init(void);

intmy_pthread_fastmutex_init(my_pthread_fastmutex_t*mp,
constpthread_mutexattr_t*attr);
intmy_pthread_fastmutex_lock(my_pthread_fastmutex_t*mp);

#undef pthread_mutex_init
#undef pthread_mutex_lock
#undef pthread_mutex_unlock
#undef pthread_mutex_destroy
#undef pthread_mutex_wait
#undef pthread_mutex_timedwait
#undef pthread_mutex_t
#undef pthread_cond_wait
#undef pthread_cond_timedwait
#undef pthread_mutex_trylock
#definepthread_mutex_init(A,B) my_pthread_fastmutex_init((A),(B))
#definepthread_mutex_lock(A) my_pthread_fastmutex_lock(A)
#definepthread_mutex_unlock(A) pthread_mutex_unlock(&(A)->mutex)
#definepthread_mutex_destroy(A) pthread_mutex_destroy(&(A)->mutex)
#definepthread_cond_wait(A,B) pthread_cond_wait((A),&(B)->mutex)
#definepthread_cond_timedwait(A,B,C) pthread_cond_timedwait((A),&(B)->mutex,(C))
#definepthread_mutex_trylock(A) pthread_mutex_trylock(&(A)->mutex)
#definepthread_mutex_t my_pthread_fastmutex_t
#endif/* defined(MY_PTHREAD_FASTMUTEX) && !defined(SAFE_MUTEX) */


#defineGETHOSTBYADDR_BUFF_SIZE 2048

#ifndefHAVE_THR_SETCONCURRENCY
#definethr_setconcurrency(A) pthread_dummy(0)
#endif
#if !defined(HAVE_PTHREAD_ATTR_SETSTACKSIZE) && ! defined(pthread_attr_setstacksize)
#definepthread_attr_setstacksize(A,B) pthread_dummy(0)
#endif

/* Define mutex types, see my_thr_init.c */
#defineMY_MUTEX_INIT_SLOW NULL
#ifdefPTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP
externpthread_mutexattr_tmy_fast_mutexattr;
#defineMY_MUTEX_INIT_FAST &my_fast_mutexattr
#else
#defineMY_MUTEX_INIT_FAST NULL
#endif
#ifdefPTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP
externpthread_mutexattr_tmy_errorcheck_mutexattr;
#defineMY_MUTEX_INIT_ERRCHK &my_errorcheck_mutexattr
#else
#defineMY_MUTEX_INIT_ERRCHK NULL
#endif

#ifndefESRCH
/* Define it to something */
#defineESRCH 1
#endif

typedefulongmy_thread_id;

externvoidmy_threadattr_global_init(void);
externmy_boolmy_thread_global_init(void);
externvoidmy_thread_global_end(void);
externmy_boolmy_thread_init(void);
externvoidmy_thread_end(void);
externconstchar*my_thread_name(void);
externmy_thread_idmy_thread_dbug_id(void);
externintpthread_no_free(void*);
externintpthread_dummy(int);

/* All thread specific variables are in the following struct */

#defineTHREAD_NAME_SIZE 10
#ifndefDEFAULT_THREAD_STACK
#ifSIZEOF_CHARP>4
/*
 MySQL can survive with 32K, but some glibc libraries require > 128K stack
 To resolve hostnames. Also recursive stored procedures needs stack.
*/
#defineDEFAULT_THREAD_STACK (256*1024L)
#else
#defineDEFAULT_THREAD_STACK (195*1024)
#endif
#endif

#defineMY_PTHREAD_LOCK_READ 0
#defineMY_PTHREAD_LOCK_WRITE 1

structst_my_thread_var
{
intthr_errno;
pthread_cond_tsuspend;
pthread_mutex_tmutex;
pthread_mutex_t*volatilecurrent_mutex;
pthread_cond_t*volatilecurrent_cond;
pthread_tpthread_self;
my_thread_idid;
intcmp_length;
intvolatileabort;
my_boolinit;
structst_my_thread_var*next,**prev;
void*opt_info;
uintlock_type; /* used by conditional release the queue */
void*stack_ends_here;
safe_mutex_t*mutex_in_use;
#ifndefDBUG_OFF
void*dbug;
charname[THREAD_NAME_SIZE+1];
#endif
};

externstructst_my_thread_var*_my_thread_var(void) __attribute__ ((const));
externvoid**my_thread_var_dbug();
externsafe_mutex_t**my_thread_var_mutex_in_use();
externuintmy_thread_end_wait_time;
externmy_boolsafe_mutex_deadlock_detector;
#definemy_thread_var (_my_thread_var())
#definemy_errno my_thread_var->thr_errno
/*
 Keep track of shutdown,signal, and main threads so that my_end() will not
 report errors with them
*/

/* Which kind of thread library is in use */

#defineTHD_LIB_OTHER 1
#defineTHD_LIB_NPTL 2
#defineTHD_LIB_LT 4

externuintthd_lib_detected;


#ifdef__cplusplus
}
#endif
#endif/* _my_ptread_h */