home *** CD-ROM | disk | FTP | other *** search
/ Chip 2001 January / Chip_2001-01_cd1.bin / tema / mysql / mysql-3.23.28g-win-source.exe / include / my_pthread.h < prev    next >
C/C++ Source or Header  |  2000-11-14  |  21KB  |  560 lines
  1. /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
  2.    
  3.    This library is free software; you can redistribute it and/or
  4.    modify it under the terms of the GNU Library General Public
  5.    License as published by the Free Software Foundation; either
  6.    version 2 of the License, or (at your option) any later version.
  7.    
  8.    This library is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11.    Library General Public License for more details.
  12.    
  13.    You should have received a copy of the GNU Library General Public
  14.    License along with this library; if not, write to the Free
  15.    Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  16.    MA 02111-1307, USA */
  17.  
  18. /* Defines to make different thread packages compatible */
  19.  
  20. #ifndef _my_pthread_h
  21. #define _my_pthread_h
  22.  
  23. #include <errno.h>
  24. #ifndef ETIME
  25. #define ETIME ETIMEDOUT                // For FreeBSD
  26. #endif
  27.  
  28. #if defined(__WIN__)
  29.  
  30. typedef CRITICAL_SECTION pthread_mutex_t;
  31. typedef HANDLE         pthread_t;
  32. typedef struct thread_attr {
  33.     DWORD dwStackSize ;
  34.     DWORD dwCreatingFlag ;
  35.     int priority ;
  36. } pthread_attr_t ;
  37.  
  38. typedef struct { int dummy; } pthread_condattr_t;
  39.  
  40. /* Implementation of posix conditions */
  41.  
  42. typedef struct st_pthread_link {
  43.   DWORD thread_id;
  44.   struct st_pthread_link *next;
  45. } pthread_link;
  46.  
  47. typedef struct {
  48.   uint32 waiting;
  49.   HANDLE semaphore;
  50. } pthread_cond_t;
  51.  
  52.  
  53. struct timespec {        /* For pthread_cond_timedwait() */
  54.     time_t tv_sec;
  55.     long tv_nsec;
  56. };
  57.  
  58. typedef int pthread_mutexattr_t;
  59. #define win_pthread_self my_thread_var->pthread_self
  60. #define pthread_handler_decl(A,B) void * __cdecl A(void *B)
  61. typedef void * (__cdecl *pthread_handler)(void *);
  62.  
  63. void win_pthread_init(void);
  64. int win_pthread_setspecific(void *A,void *B,uint length);
  65. int pthread_create(pthread_t *,pthread_attr_t *,pthread_handler,void *);
  66. int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr);
  67. int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
  68. int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex,
  69.                struct timespec *abstime);
  70. int pthread_cond_signal(pthread_cond_t *cond);
  71. int pthread_cond_broadcast(pthread_cond_t *cond);
  72. int pthread_cond_destroy(pthread_cond_t *cond);
  73. int pthread_attr_init(pthread_attr_t *connect_att);
  74. int pthread_attr_setstacksize(pthread_attr_t *connect_att,DWORD stack);
  75. int pthread_attr_setprio(pthread_attr_t *connect_att,int priority);
  76. int pthread_attr_destroy(pthread_attr_t *connect_att);
  77. struct tm *localtime_r(const time_t *timep,struct tm *tmp);
  78.  
  79. void pthread_exit(void *a);     /* was #define pthread_exit(A) ExitThread(A)*/
  80.  
  81. #define ETIMEDOUT 145            /* Win32 doesn't have this */
  82. #define getpid() GetCurrentThreadId()
  83. #define pthread_self() win_pthread_self
  84. #define HAVE_LOCALTIME_R
  85. #define _REENTRANT
  86. #define HAVE_PTHREAD_ATTR_SETSTACKSIZE
  87.  
  88. #ifdef USE_TLS                    /* For LIBMYSQL.DLL */
  89. #undef SAFE_MUTEX                /* This will cause conflicts */
  90. #define pthread_key(T,V)  DWORD V
  91. #define pthread_key_create(A,B) ((*A=TlsAlloc())==0xFFFFFFFF)
  92. #define pthread_getspecific(A) (TlsGetValue(A))
  93. #define my_pthread_getspecific(T,A) ((T) TlsGetValue(A))
  94. #define my_pthread_getspecific_ptr(T,V) ((T) TlsGetValue(V))
  95. #define my_pthread_setspecific_ptr(T,V) (!TlsSetValue((T),(V)))
  96. #define pthread_setspecific(A,B) (!TlsSetValue((A),(B)))
  97. #else
  98. #define pthread_key(T,V) __declspec(thread) T V
  99. #define pthread_key_create(A,B) pthread_dummy(0)
  100. #define pthread_getspecific(A) (&(A))
  101. #define my_pthread_getspecific(T,A) (&(A))
  102. #define my_pthread_getspecific_ptr(T,V) (V)
  103. #define my_pthread_setspecific_ptr(T,V) ((T)=(V),0)
  104. #define pthread_setspecific(A,B) win_pthread_setspecific(&(A),(B),sizeof(A))
  105. #endif /* USE_TLS */
  106.  
  107. #define pthread_equal(A,B) ((A) == (B))
  108. #define pthread_mutex_init(A,B)  InitializeCriticalSection(A)
  109. #define pthread_mutex_lock(A)     (EnterCriticalSection(A),0)
  110. #define pthread_mutex_unlock(A)  LeaveCriticalSection(A)
  111. #define pthread_mutex_destroy(A) DeleteCriticalSection(A)
  112. #define my_pthread_setprio(A,B)  SetThreadPriority(GetCurrentThread(), (B))
  113. /* Dummy defines for easier code */
  114. #define pthread_kill(A,B) pthread_dummy(0)
  115. #define pthread_attr_setdetachstate(A,B) pthread_dummy(0)
  116. #define my_pthread_attr_setprio(A,B) pthread_attr_setprio(A,B)
  117. #define pthread_attr_setscope(A,B)
  118. #define pthread_detach_this_thread()
  119. #define pthread_condattr_init(A)
  120. #define pthread_condattr_destroy(A)
  121.  
  122. //Irena: compiler does not like this:
  123. //#define my_pthread_getprio(pthread_t thread_id) pthread_dummy(0)
  124. #define my_pthread_getprio(thread_id) pthread_dummy(0)
  125.  
  126. #elif defined(HAVE_UNIXWARE7_THREADS)
  127.  
  128. #include <thread.h>
  129. #include <synch.h>
  130.  
  131. #ifndef _REENTRANT
  132. #define _REENTRANT
  133. #endif
  134.  
  135. #define HAVE_NONPOSIX_SIGWAIT
  136. #define pthread_t thread_t
  137. #define pthread_cond_t cond_t
  138. #define pthread_mutex_t mutex_t
  139. #define pthread_key_t thread_key_t
  140. typedef int pthread_attr_t;            /* Needed by Unixware 7.0.0 */
  141.  
  142. #define pthread_key_create(A,B) thr_keycreate((A),(B))
  143.  
  144. #define pthread_handler_decl(A,B) void *A(void *B)
  145. #define pthread_key(T,V) pthread_key_t V
  146.  
  147. void *    my_pthread_getspecific_imp(pthread_key_t key);
  148. #define my_pthread_getspecific(A,B) ((A) my_pthread_getspecific_imp(B))
  149. #define my_pthread_getspecific_ptr(T,V) my_pthread_getspecific(T,V)
  150.  
  151. #define pthread_setspecific(A,B) thr_setspecific(A,B)
  152. #define my_pthread_setspecific_ptr(T,V) pthread_setspecific(T,V)
  153.  
  154. #define pthread_create(A,B,C,D) thr_create(NULL,65536L,(C),(D),THR_DETACHED,(A))
  155. #define pthread_cond_init(a,b) cond_init((a),USYNC_THREAD,NULL)
  156. #define pthread_cond_destroy(a) cond_destroy(a)
  157. #define pthread_cond_signal(a) cond_signal(a)
  158. #define pthread_cond_wait(a,b) cond_wait((a),(b))
  159. #define pthread_cond_timedwait(a,b,c) cond_timedwait((a),(b),(c))
  160. #define pthread_cond_broadcast(a) cond_broadcast(a)
  161.  
  162. #define pthread_mutex_init(a,b) mutex_init((a),USYNC_THREAD,NULL)
  163. #define pthread_mutex_lock(a) mutex_lock(a)
  164. #define pthread_mutex_unlock(a) mutex_unlock(a)
  165. #define pthread_mutex_destroy(a) mutex_destroy(a)
  166.  
  167. #define pthread_self() thr_self()
  168. #define pthread_exit(A) thr_exit(A)
  169. #define pthread_equal(A,B) (((A) == (B)) ? 1 : 0)
  170. #define pthread_kill(A,B) thr_kill((A),(B))
  171. #define HAVE_PTHREAD_KILL
  172.  
  173. #define pthread_sigmask(A,B,C) thr_sigsetmask((A),(B),(C))
  174.  
  175. extern int my_sigwait(const sigset_t *set,int *sig);
  176.  
  177. #define pthread_detach_this_thread() pthread_dummy(0)
  178.  
  179. #define pthread_attr_init(A) pthread_dummy(0)
  180. #define pthread_attr_destroy(A) pthread_dummy(0)
  181. #define pthread_attr_setscope(A,B) pthread_dummy(0)
  182. #define pthread_attr_setdetachstate(A,B) pthread_dummy(0)
  183. #define my_pthread_setprio(A,B) pthread_dummy (0)
  184. #define my_pthread_getprio(A) pthread_dummy (0)
  185. #define my_pthread_attr_setprio(A,B) pthread_dummy(0)
  186.  
  187. #else /* Normal threads */
  188.  
  189. #ifdef HAVE_rts_threads
  190. #define sigwait org_sigwait
  191. #include <signal.h>
  192. #undef sigwait
  193. #endif
  194. #undef _REENTRANT            /* Fix if _REENTRANT is in pthread.h */
  195. #include <pthread.h>
  196. #ifndef _REENTRANT
  197. #define _REENTRANT
  198. #endif
  199. #ifdef HAVE_THR_SETCONCURRENCY
  200. #include <thread.h>            /* Probably solaris */
  201. #endif
  202. #ifdef HAVE_SCHED_H
  203. #include <sched.h>
  204. #endif
  205. #ifdef HAVE_SYNCH_H
  206. #include <synch.h>
  207. #endif
  208. #if defined(__EMX__) && (!defined(EMX_PTHREAD_REV) || (EMX_PTHREAD_REV < 2))
  209. #error Requires at least rev 2 of EMX pthreads library.
  210. #endif
  211.  
  212. extern int my_pthread_getprio(pthread_t thread_id);
  213.  
  214. #define pthread_key(T,V) pthread_key_t V
  215. #define my_pthread_getspecific_ptr(T,V) my_pthread_getspecific(T,(V))
  216. #define my_pthread_setspecific_ptr(T,V) pthread_setspecific(T,(void*) (V))
  217. #define pthread_detach_this_thread()
  218. #define pthread_handler_decl(A,B) void *A(void *B)
  219. typedef void *(* pthread_handler)(void *);
  220.  
  221. /* Test first for RTS or FSU threads */
  222.  
  223. #if defined(PTHREAD_SCOPE_GLOBAL) && !defined(PTHREAD_SCOPE_SYSTEM)
  224. #define HAVE_rts_threads
  225. extern int my_pthread_create_detached;
  226. #define pthread_sigmask(A,B,C) sigprocmask((A),(B),(C))
  227. #define PTHREAD_CREATE_DETACHED &my_pthread_create_detached
  228. #define PTHREAD_SCOPE_SYSTEM  PTHREAD_SCOPE_GLOBAL
  229. #define PTHREAD_SCOPE_PROCESS PTHREAD_SCOPE_LOCAL
  230. #define USE_ALARM_THREAD
  231. #elif defined(HAVE_mit_thread)
  232. #define USE_ALARM_THREAD
  233. #undef    HAVE_LOCALTIME_R
  234. #define HAVE_LOCALTIME_R
  235. #undef    HAVE_PTHREAD_ATTR_SETSCOPE
  236. #define HAVE_PTHREAD_ATTR_SETSCOPE
  237. #undef HAVE_GLIBC2_STYLE_GETHOSTBYNAME_R    /* If we are running linux */
  238. #undef HAVE_RWLOCK_T
  239. #undef HAVE_RWLOCK_INIT
  240. #undef HAVE_PTHREAD_RWLOCK_RDLOCK
  241. #undef HAVE_SNPRINTF
  242.  
  243. #define sigset(A,B) pthread_signal((A),(void (*)(int)) (B))
  244. #define signal(A,B) pthread_signal((A),(void (*)(int)) (B))
  245. #define my_pthread_attr_setprio(A,B)
  246. #endif /* defined(PTHREAD_SCOPE_GLOBAL) && !defined(PTHREAD_SCOPE_SYSTEM) */
  247.  
  248. #if defined(_BSDI_VERSION) && _BSDI_VERSION < 199910
  249. int sigwait(sigset_t *set, int *sig);
  250. #endif
  251.  
  252. #if defined(HAVE_UNIXWARE7_POSIX)
  253. #undef HAVE_NONPOSIX_SIGWAIT
  254. #define HAVE_NONPOSIX_SIGWAIT    /* sigwait takes only 1 argument */
  255. #endif
  256.  
  257. #ifndef HAVE_NONPOSIX_SIGWAIT
  258. #define my_sigwait(A,B) sigwait((A),(B))
  259. #else
  260. int my_sigwait(const sigset_t *set,int *sig);
  261. #endif
  262.  
  263. #ifdef HAVE_NONPOSIX_PTHREAD_MUTEX_INIT
  264. #ifndef SAFE_MUTEX
  265. #define pthread_mutex_init(a,b) my_pthread_mutex_init((a),(b))
  266. extern int my_pthread_mutex_init(pthread_mutex_t *mp,
  267.                  const pthread_mutexattr_t *attr);
  268. #endif /* SAFE_MUTEX */
  269. #define pthread_cond_init(a,b) my_pthread_cond_init((a),(b))
  270. extern int my_pthread_cond_init(pthread_cond_t *mp,
  271.                 const pthread_condattr_t *attr);
  272. #endif /* HAVE_NONPOSIX_PTHREAD_MUTEX_INIT */
  273.  
  274. #if defined(HAVE_SIGTHREADMASK) && !defined(HAVE_PTHREAD_SIGMASK)
  275. #define pthread_sigmask(A,B,C) sigthreadmask((A),(B),(C))
  276. #endif
  277.  
  278. #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)
  279. int sigwait(sigset_t *setp, int *sigp);        /* Use our implemention */
  280. #endif
  281. #if !defined(HAVE_SIGSET) && !defined(HAVE_mit_thread) && !defined(sigset)
  282. #define sigset(A,B) do { struct sigaction s; sigset_t set;              \
  283.                          sigemptyset(&set);                             \
  284.                          s.sa_handler = (B);                            \
  285.                          s.sa_mask    = set;                            \
  286.                          s.sa_flags   = 0;                              \
  287.                          sigaction((A), &s, (struct sigaction *) NULL); \
  288.                        } while (0)
  289. #endif
  290.  
  291. #ifndef my_pthread_setprio
  292. #if defined(HAVE_PTHREAD_SETPRIO_NP)        /* FSU threads */
  293. #define my_pthread_setprio(A,B) pthread_setprio_np((A),(B))
  294. #elif defined(HAVE_PTHREAD_SETPRIO)
  295. #define my_pthread_setprio(A,B) pthread_setprio((A),(B))
  296. #else
  297. extern void my_pthread_setprio(pthread_t thread_id,int prior);
  298. #endif
  299. #endif
  300.  
  301. #ifndef my_pthread_attr_setprio
  302. #ifdef HAVE_PTHREAD_ATTR_SETPRIO
  303. #define my_pthread_attr_setprio(A,B) pthread_attr_setprio((A),(B))
  304. #else
  305. extern void my_pthread_attr_setprio(pthread_attr_t *attr, int priority);
  306. #endif
  307. #endif
  308.  
  309. #if !defined(HAVE_PTHREAD_ATTR_SETSCOPE) || defined(HAVE_DEC_3_2_THREADS)
  310. #define pthread_attr_setscope(A,B)
  311. #undef    HAVE_GETHOSTBYADDR_R            /* No definition */
  312. #endif
  313.  
  314. #ifndef HAVE_NONPOSIX_PTHREAD_GETSPECIFIC
  315. #define my_pthread_getspecific(A,B) ((A) pthread_getspecific(B))
  316. #else
  317. #define my_pthread_getspecific(A,B) ((A) my_pthread_getspecific_imp(B))
  318. void *my_pthread_getspecific_imp(pthread_key_t key);
  319. #endif
  320.  
  321. #ifndef HAVE_LOCALTIME_R
  322. struct tm *localtime_r(const time_t *clock, struct tm *res);
  323. #endif
  324.  
  325. #ifdef HAVE_PTHREAD_CONDATTR_CREATE
  326. /* DCE threads on HPUX 10.20 */
  327. #define pthread_condattr_init pthread_condattr_create
  328. #define pthread_condattr_destroy pthread_condattr_delete
  329. #endif
  330.  
  331. #ifdef HAVE_CTHREADS_WRAPPER            /* For MacOSX */
  332. #define pthread_cond_destroy(A) pthread_dummy(0)
  333. #define pthread_mutex_destroy(A) pthread_dummy(0)
  334. #define pthread_attr_delete(A) pthread_dummy(0)
  335. #define pthread_condattr_delete(A) pthread_dummy(0)
  336. #define pthread_attr_setstacksize(A,B) pthread_dummy(0)
  337. #define pthread_equal(A,B) ((A) == (B))
  338. #define pthread_cond_timedwait(a,b,c) pthread_cond_wait((a),(b))
  339. #define pthread_attr_init(A) pthread_attr_create(A)
  340. #define pthread_attr_destroy(A) pthread_attr_delete(A)
  341. #define pthread_attr_setdetachstate(A,B) pthread_dummy(0)
  342. #define pthread_create(A,B,C,D) pthread_create((A),*(B),(C),(D))
  343. #define pthread_sigmask(A,B,C) sigprocmask((A),(B),(C))
  344. #define pthread_kill(A,B) pthread_dummy(0)
  345. #undef    pthread_detach_this_thread
  346. #define pthread_detach_this_thread() { pthread_t tmp=pthread_self() ; pthread_detach(&tmp); }
  347. #endif
  348.  
  349. #ifdef HAVE_DARWIN_THREADS
  350. #define pthread_sigmask(A,B,C) sigprocmask((A),(B),(C))
  351. #define pthread_kill(A,B) pthread_dummy(0)
  352. #define pthread_condattr_init(A) pthread_dummy(0)
  353. #define pthread_condattr_destroy(A) pthread_dummy(0)
  354. #define pthread_signal(A,B) pthread_dummy(0)
  355. #undef    pthread_detach_this_thread
  356. #define pthread_detach_this_thread() { pthread_t tmp=pthread_self() ; pthread_detach(tmp); }
  357. #undef sigset
  358. #define sigset(A,B) pthread_signal((A),(void (*)(int)) (B))
  359. #endif
  360.  
  361. #if ((defined(HAVE_PTHREAD_ATTR_CREATE) && !defined(HAVE_SIGWAIT)) || defined(HAVE_DEC_3_2_THREADS)) && !defined(HAVE_CTHREADS_WRAPPER)
  362. /* This is set on AIX_3_2 and Siemens unix (and DEC OSF/1 3.2 too) */
  363. #define pthread_key_create(A,B) \
  364.         pthread_keycreate(A,(B) ?\
  365.                   (pthread_destructor_t) (B) :\
  366.                   (pthread_destructor_t) pthread_dummy)
  367. #define pthread_attr_init(A) pthread_attr_create(A)
  368. #define pthread_attr_destroy(A) pthread_attr_delete(A)
  369. #define pthread_attr_setdetachstate(A,B) pthread_dummy(0)
  370. #define pthread_create(A,B,C,D) pthread_create((A),*(B),(C),(D))
  371. #ifndef pthread_sigmask
  372. #define pthread_sigmask(A,B,C) sigprocmask((A),(B),(C))
  373. #endif
  374. #define pthread_kill(A,B) pthread_dummy(0)
  375. #undef    pthread_detach_this_thread
  376. #define pthread_detach_this_thread() { pthread_t tmp=pthread_self() ; pthread_detach(&tmp); }
  377. #else /* HAVE_PTHREAD_ATTR_CREATE && !HAVE_SIGWAIT */
  378. #define HAVE_PTHREAD_KILL
  379. #endif
  380.  
  381. #if defined(HAVE_PTHREAD_ATTR_CREATE) || defined(_AIX) || defined(HAVE_GLIBC2_STYLE_GETHOSTBYNAME_R)
  382. #if !defined(HPUX)
  383. struct hostent;
  384. #endif /* HPUX */
  385. struct hostent *my_gethostbyname_r(const char *name,
  386.                    struct hostent *result, char *buffer,
  387.                    int buflen, int *h_errnop);
  388. #if defined(HAVE_GLIBC2_STYLE_GETHOSTBYNAME_R)
  389. #define GETHOSTBYNAME_BUFF_SIZE 2048
  390. #else
  391. #define GETHOSTBYNAME_BUFF_SIZE sizeof(struct hostent_data)
  392. #endif /* defined(HAVE_GLIBC2_STYLE_GETHOSTBYNAME_R) */
  393.  
  394. #else
  395. #ifdef HAVE_GETHOSTBYNAME_R_WITH_HOSTENT_DATA
  396. #define GETHOSTBYNAME_BUFF_SIZE sizeof(hostent_data)
  397. #define my_gethostbyname_r(A,B,C,D,E) gethostbyname_r((A),(B),(hostent_data*) (C))
  398. #else
  399. #define GETHOSTBYNAME_BUFF_SIZE 2048
  400. #define my_gethostbyname_r(A,B,C,D,E) gethostbyname_r((A),(B),(C),(D),(E))
  401. #endif /* HAVE_GETHOSTBYNAME_R_WITH_HOSTENT_DATA */
  402. #endif /* defined(HAVE_PTHREAD_ATTR_CREATE) || defined(_AIX) || defined(HAVE_GLIBC2_STYLE_GETHOSTBYNAME_R) */
  403.  
  404. #endif /* defined(__WIN__) */
  405.  
  406.     /* safe_mutex adds checking to mutex for easier debugging */
  407.  
  408. typedef struct st_safe_mutex_t
  409. {
  410.   pthread_mutex_t global,mutex;
  411.   char *file;
  412.   uint line,count;
  413.   pthread_t thread;
  414. } safe_mutex_t;
  415.  
  416. int safe_mutex_init(safe_mutex_t *mp, const pthread_mutexattr_t *attr);
  417. int safe_mutex_lock(safe_mutex_t *mp,const char *file, uint line);
  418. int safe_mutex_unlock(safe_mutex_t *mp,const char *file, uint line);
  419. int safe_mutex_destroy(safe_mutex_t *mp,const char *file, uint line);
  420. int safe_cond_wait(pthread_cond_t *cond, safe_mutex_t *mp,const char *file,
  421.            uint line);
  422. int safe_cond_timedwait(pthread_cond_t *cond, safe_mutex_t *mp,
  423.             struct timespec *abstime, const char *file, uint line);
  424.  
  425.     /* Wrappers if safe mutex is actually used */
  426. #ifdef SAFE_MUTEX
  427. #undef pthread_mutex_init
  428. #undef pthread_mutex_lock
  429. #undef pthread_mutex_unlock
  430. #undef pthread_mutex_destroy
  431. #undef pthread_mutex_wait
  432. #undef pthread_mutex_timedwait
  433. #undef pthread_mutex_t
  434. #define pthread_mutex_init(A,B) safe_mutex_init((A),(B))
  435. #define pthread_mutex_lock(A) safe_mutex_lock((A),__FILE__,__LINE__)
  436. #define pthread_mutex_unlock(A) safe_mutex_unlock((A),__FILE__,__LINE__)
  437. #define pthread_mutex_destroy(A) safe_mutex_destroy((A),__FILE__,__LINE__)
  438. #define pthread_cond_wait(A,B) safe_cond_wait((A),(B),__FILE__,__LINE__)
  439. #define pthread_cond_timedwait(A,B,C) safe_cond_timedwait((A),(B),(C),__FILE__,__LINE__)
  440. #define pthread_mutex_t safe_mutex_t
  441. #endif /* SAFE_MUTEX */
  442.  
  443.     /* READ-WRITE thread locking */
  444.  
  445. #if defined(USE_MUTEX_INSTEAD_OF_RW_LOCKS)
  446. /* use these defs for simple mutex locking */
  447. #define rw_lock_t pthread_mutex_t
  448. #define my_rwlock_init(A,B) pthread_mutex_init((A),(B))
  449. #define rw_rdlock(A) pthread_mutex_lock((A))
  450. #define rw_wrlock(A) pthread_mutex_lock((A))
  451. #define rw_unlock(A) pthread_mutex_unlock((A))
  452. #define rwlock_destroy(A) pthread_mutex_destroy((A))
  453. #elif defined(HAVE_PTHREAD_RWLOCK_RDLOCK)
  454. #define rw_lock_t pthread_rwlock_t
  455. #define my_rwlock_init(A,B) pthread_rwlock_init((A),(B))
  456. #define rw_rdlock(A) pthread_rwlock_rdlock(A)
  457. #define rw_wrlock(A) pthread_rwlock_wrlock(A)
  458. #define rw_unlock(A) pthread_rwlock_unlock(A)
  459. #define rwlock_destroy(A) pthread_rwlock_destroy(A)
  460. #elif defined(HAVE_RWLOCK_INIT)
  461. #ifdef HAVE_RWLOCK_T                /* For example Solaris 2.6-> */
  462. #define rw_lock_t rwlock_t
  463. #endif
  464. #define my_rwlock_init(A,B) rwlock_init((A),USYNC_THREAD,0)
  465. #else
  466. /* Use our own version of read/write locks */
  467. typedef struct _my_rw_lock_t {
  468.     pthread_mutex_t lock;        /* lock for structure        */
  469.     pthread_cond_t    readers;    /* waiting readers        */
  470.     pthread_cond_t    writers;    /* waiting writers        */
  471.     int        state;        /* -1:writer,0:free,>0:readers    */
  472.     int        waiters;    /* number of waiting writers    */
  473. } my_rw_lock_t;
  474.  
  475. #define rw_lock_t my_rw_lock_t
  476. #define rw_rdlock(A) my_rw_rdlock((A))
  477. #define rw_wrlock(A) my_rw_wrlock((A))
  478. #define rw_unlock(A) my_rw_unlock((A))
  479. #define rwlock_destroy(A) my_rwlock_destroy((A))
  480.  
  481. extern    int    my_rwlock_init( my_rw_lock_t *, void * );
  482. extern    int    my_rwlock_destroy( my_rw_lock_t * );
  483. extern    int    my_rw_rdlock( my_rw_lock_t * );
  484. extern    int    my_rw_wrlock( my_rw_lock_t * );
  485. extern    int    my_rw_unlock( my_rw_lock_t * );
  486. #endif /* USE_MUTEX_INSTEAD_OF_RW_LOCKS */
  487.  
  488. #define GETHOSTBYADDR_BUFF_SIZE 2048
  489.  
  490. #ifndef HAVE_THR_SETCONCURRENCY
  491. #define thr_setconcurrency(A) pthread_dummy(0)
  492. #endif
  493. #if !defined(HAVE_PTHREAD_ATTR_SETSTACKSIZE) && ! defined(pthread_attr_setstacksize)
  494. #define pthread_attr_setstacksize(A,B) pthread_dummy(0)
  495. #endif
  496.  
  497. extern my_bool my_thread_global_init(void);
  498. extern void my_thread_global_end(void);
  499. extern my_bool my_thread_init(void);
  500. extern void my_thread_end(void);
  501. extern char *my_thread_name(void);
  502. extern long my_thread_id(void);
  503. extern int pthread_no_free(void *);
  504. extern int pthread_dummy(int);
  505.  
  506. /* All thread specific variables are in the following struct */
  507.  
  508. #define THREAD_NAME_SIZE 10
  509. #if defined(__ia64__)
  510. #define DEFAULT_THREAD_STACK    (128*1024)
  511. #else
  512. #define DEFAULT_THREAD_STACK    (64*1024)
  513. #endif
  514.  
  515. struct st_my_thread_var
  516. {
  517.   int thr_errno;
  518.   pthread_cond_t suspend, *current_cond;
  519.   pthread_mutex_t mutex,  *current_mutex;
  520.   pthread_t pthread_self;
  521.   long id;
  522.   int cmp_length;
  523.   volatile int abort;
  524. #ifndef DBUG_OFF
  525.   gptr dbug;
  526.   char name[THREAD_NAME_SIZE+1];
  527. #endif
  528. };
  529.  
  530. extern struct st_my_thread_var *_my_thread_var(void) __attribute__ ((const));
  531. #define my_thread_var (_my_thread_var())
  532. #define my_errno my_thread_var->thr_errno
  533.  
  534.     /* statistics_xxx functions are for not essential statistic */
  535.  
  536. #ifndef thread_safe_increment
  537. #ifdef HAVE_ATOMIC_ADD
  538. #define thread_safe_increment(V,L) atomic_add(1,(atomic_t*) &V);
  539. #define thread_safe_add(V,C,L)     atomic_add((C),(atomic_t*) &V);
  540. #define thread_safe_sub(V,C,L)     atomic_sub((C),(atomic_t*) &V);
  541. #define statistic_increment(V,L)   thread_safe_increment((V),(L))
  542. #define statistic_add(V,C,L)       thread_safe_add((V),(C),(L))
  543. #else
  544. #define thread_safe_increment(V,L) \
  545.     pthread_mutex_lock((L)); (V)++; pthread_mutex_unlock((L));
  546. #define thread_safe_add(V,C,L) \
  547.     pthread_mutex_lock((L)); (V)+=(C); pthread_mutex_unlock((L));
  548. #define thread_safe_sub(V,C,L) \
  549.     pthread_mutex_lock((L)); (V)-=(C); pthread_mutex_unlock((L));
  550. #ifdef SAFE_STATISTICS
  551. #define statistic_increment(V,L)   thread_safe_increment((V),(L))
  552. #define statistic_add(V,C,L)       thread_safe_add((V),(C),(L))
  553. #else
  554. #define statistic_increment(V,L) (V)++
  555. #define statistic_add(V,C,L)     (V)+=(C)
  556. #endif /* SAFE_STATISTICS */
  557. #endif /* HAVE_ATOMIC_ADD */
  558. #endif /* thread_safe_increment */
  559. #endif /* _my_ptread_h */
  560.