← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mysys/my_pthread.h

Merged Nathan from lp:~nlws/drizzle/fix-string-c-ptr-overrun

Show diffs side-by-side

added added

removed removed

Lines of Context:
mysys/my_pthread.h
19
19
#define _my_pthread_h
20
20
 
21
21
#include <stdint.h>
22
 
#include <stdbool.h>
23
22
#include <unistd.h>
 
23
#include <signal.h>
24
24
 
25
25
#ifndef ETIME
26
26
#define ETIME ETIMEDOUT                         /* For FreeBSD */
31
31
extern "C" {
32
32
#else
33
33
#define EXTERNC
34
 
#endif /* __cplusplus */ 
 
34
#endif /* __cplusplus */
35
35
 
36
36
#include <pthread.h>
37
37
#ifndef _REENTRANT
45
45
#endif
46
46
 
47
47
#define pthread_key(T,V) pthread_key_t V
48
 
#define pthread_detach_this_thread()
49
48
#define pthread_handler_t void *
50
49
typedef void *(* pthread_handler)(void *);
51
50
 
52
 
/* Test first for RTS or FSU threads */
53
 
 
54
 
#if defined(PTHREAD_SCOPE_GLOBAL) && !defined(PTHREAD_SCOPE_SYSTEM)
55
 
#define HAVE_rts_threads
56
 
extern int my_pthread_create_detached;
57
 
#define pthread_sigmask(A,B,C) sigprocmask((A),(B),(C))
58
 
#define PTHREAD_CREATE_DETACHED &my_pthread_create_detached
59
 
#define PTHREAD_SCOPE_SYSTEM  PTHREAD_SCOPE_GLOBAL
60
 
#define PTHREAD_SCOPE_PROCESS PTHREAD_SCOPE_LOCAL
61
 
#define USE_ALARM_THREAD
62
 
#endif /* defined(PTHREAD_SCOPE_GLOBAL) && !defined(PTHREAD_SCOPE_SYSTEM) */
63
 
 
64
 
#ifndef HAVE_NONPOSIX_SIGWAIT
65
 
#define my_sigwait(A,B) sigwait((A),(B))
66
 
#else
67
 
int my_sigwait(const sigset_t *set,int *sig);
68
 
#endif
69
 
 
70
 
#ifdef HAVE_NONPOSIX_PTHREAD_MUTEX_INIT
71
 
#define pthread_mutex_init(a,b) my_pthread_mutex_init((a),(b))
72
 
extern int my_pthread_mutex_init(pthread_mutex_t *mp,
73
 
                                 const pthread_mutexattr_t *attr);
74
 
#define pthread_cond_init(a,b) my_pthread_cond_init((a),(b))
75
 
extern int my_pthread_cond_init(pthread_cond_t *mp,
76
 
                                const pthread_condattr_t *attr);
77
 
#endif /* HAVE_NONPOSIX_PTHREAD_MUTEX_INIT */
78
 
 
79
51
#if defined(HAVE_SIGTHREADMASK) && !defined(HAVE_PTHREAD_SIGMASK)
80
52
#define pthread_sigmask(A,B,C) sigthreadmask((A),(B),(C))
81
53
#endif
82
54
 
83
 
#if !defined(HAVE_SIGWAIT) && !defined(HAVE_rts_threads) && !defined(sigwait) && !defined(alpha_linux_port) && !defined(HAVE_NONPOSIX_SIGWAIT)
84
 
int sigwait(sigset_t *setp, int *sigp);         /* Use our implemention */
85
 
#endif
86
 
 
87
55
 
88
56
/*
89
57
  We define my_sigset() and use that instead of the system sigset() so that
115
83
#endif
116
84
#endif
117
85
 
118
 
#if !defined(HAVE_PTHREAD_ATTR_SETSCOPE)
119
 
#define pthread_attr_setscope(A,B)
120
 
#endif
121
 
 
122
 
#if defined(HAVE_BROKEN_PTHREAD_COND_TIMEDWAIT)
123
 
extern int my_pthread_cond_timedwait(pthread_cond_t *cond,
124
 
                                     pthread_mutex_t *mutex,
125
 
                                     struct timespec *abstime);
126
 
#define pthread_cond_timedwait(A,B,C) my_pthread_cond_timedwait((A),(B),(C))
127
 
#endif
128
 
 
129
 
/* FSU THREADS */
130
 
#if !defined(HAVE_PTHREAD_KEY_DELETE) && !defined(pthread_key_delete)
131
 
#define pthread_key_delete(A) pthread_dummy(0)
132
 
#endif
133
 
 
134
 
#ifdef HAVE_CTHREADS_WRAPPER                    /* For MacOSX */
135
 
#define pthread_cond_destroy(A) pthread_dummy(0)
136
 
#define pthread_mutex_destroy(A) pthread_dummy(0)
137
 
#define pthread_attr_delete(A) pthread_dummy(0)
138
 
#define pthread_condattr_delete(A) pthread_dummy(0)
139
 
#define pthread_attr_setstacksize(A,B) pthread_dummy(0)
140
 
#define pthread_equal(A,B) ((A) == (B))
141
 
#define pthread_cond_timedwait(a,b,c) pthread_cond_wait((a),(b))
142
 
#define pthread_attr_init(A) pthread_attr_create(A)
143
 
#define pthread_attr_destroy(A) pthread_attr_delete(A)
144
 
#define pthread_attr_setdetachstate(A,B) pthread_dummy(0)
145
 
#define pthread_create(A,B,C,D) pthread_create((A),*(B),(C),(D))
146
 
#define pthread_sigmask(A,B,C) sigprocmask((A),(B),(C))
147
 
#define pthread_kill(A,B) pthread_dummy((A) ? 0 : ESRCH)
148
 
#undef  pthread_detach_this_thread
149
 
#define pthread_detach_this_thread() { pthread_t tmp=pthread_self() ; pthread_detach(&tmp); }
150
 
#endif
151
 
 
152
 
#ifdef HAVE_DARWIN5_THREADS
153
 
#define pthread_sigmask(A,B,C) sigprocmask((A),(B),(C))
154
 
#define pthread_kill(A,B) pthread_dummy((A) ? 0 : ESRCH)
155
 
#define pthread_condattr_init(A) pthread_dummy(0)
156
 
#define pthread_condattr_destroy(A) pthread_dummy(0)
157
 
#undef  pthread_detach_this_thread
158
 
#define pthread_detach_this_thread() { pthread_t tmp=pthread_self() ; pthread_detach(tmp); }
159
 
#endif
160
 
 
161
 
#if (defined(HAVE_PTHREAD_ATTR_CREATE) && !defined(HAVE_SIGWAIT))
162
 
/* This is set on AIX_3_2 and Siemens unix (and DEC OSF/1 3.2 too) */
163
 
#define pthread_key_create(A,B) \
164
 
                pthread_keycreate(A,(B) ?\
165
 
                                  (pthread_destructor_t) (B) :\
166
 
                                  (pthread_destructor_t) pthread_dummy)
167
 
#define pthread_attr_init(A) pthread_attr_create(A)
168
 
#define pthread_attr_destroy(A) pthread_attr_delete(A)
169
 
#define pthread_attr_setdetachstate(A,B) pthread_dummy(0)
170
 
#define pthread_create(A,B,C,D) pthread_create((A),*(B),(C),(D))
171
 
#ifndef pthread_sigmask
172
 
#define pthread_sigmask(A,B,C) sigprocmask((A),(B),(C))
173
 
#endif
174
 
#define pthread_kill(A,B) pthread_dummy((A) ? 0 : ESRCH)
175
 
#undef  pthread_detach_this_thread
176
 
#define pthread_detach_this_thread() { pthread_t tmp=pthread_self() ; pthread_detach(&tmp); }
177
 
#else
178
 
#define HAVE_PTHREAD_KILL
179
 
#endif
180
 
 
181
 
#if defined(HAVE_POSIX1003_4a_MUTEX) && !defined(DONT_REMAP_PTHREAD_FUNCTIONS)
182
 
#undef pthread_mutex_trylock
183
 
#define pthread_mutex_trylock(a) my_pthread_mutex_trylock((a))
184
 
int my_pthread_mutex_trylock(pthread_mutex_t *mutex);
185
 
#endif
186
 
 
187
86
#if !defined(HAVE_PTHREAD_YIELD_ONE_ARG) && !defined(HAVE_PTHREAD_YIELD_ZERO_ARG)
188
87
/* no pthread_yield() available */
189
88
#ifdef HAVE_SCHED_YIELD
198
97
  for calculating an absolute time at which
199
98
  pthread_cond_timedwait should timeout
200
99
*/
201
 
#ifdef HAVE_TIMESPEC_TS_SEC
202
 
#ifndef set_timespec
203
 
#define set_timespec(ABSTIME,SEC) \
204
 
{ \
205
 
  (ABSTIME).ts_sec=time(0) + (time_t) (SEC); \
206
 
  (ABSTIME).ts_nsec=0; \
207
 
}
208
 
#endif /* !set_timespec */
209
 
#ifndef set_timespec_nsec
210
 
#define set_timespec_nsec(ABSTIME,NSEC) \
211
 
{ \
212
 
  uint64_t now= my_getsystime() + (NSEC/100); \
213
 
  (ABSTIME).ts_sec=  (now / 10000000UL); \
214
 
  (ABSTIME).ts_nsec= (now % 10000000UL * 100 + ((NSEC) % 100)); \
215
 
}
216
 
#endif /* !set_timespec_nsec */
217
 
#else
218
100
#ifndef set_timespec
219
101
#define set_timespec(ABSTIME,SEC) \
220
102
{\
232
114
  (ABSTIME).tv_nsec= (long) (now % 10000000UL * 100 + ((NSEC) % 100)); \
233
115
}
234
116
#endif /* !set_timespec_nsec */
235
 
#endif /* HAVE_TIMESPEC_TS_SEC */
236
117
 
237
118
        /* safe_mutex adds checking to mutex for easier debugging */
238
119
 
260
141
#define safe_mutex_assert_owner(mp)
261
142
#define safe_mutex_assert_not_owner(mp)
262
143
 
263
 
#if defined(MY_PTHREAD_FASTMUTEX)
264
 
typedef struct st_my_pthread_fastmutex_t
265
 
{
266
 
  pthread_mutex_t mutex;
267
 
  uint32_t spins;
268
 
} my_pthread_fastmutex_t;
269
 
void fastmutex_global_init(void);
270
 
 
271
 
int my_pthread_fastmutex_init(my_pthread_fastmutex_t *mp, 
272
 
                              const pthread_mutexattr_t *attr);
273
 
int my_pthread_fastmutex_lock(my_pthread_fastmutex_t *mp);
274
 
 
275
 
#undef pthread_mutex_init
276
 
#undef pthread_mutex_lock
277
 
#undef pthread_mutex_unlock
278
 
#undef pthread_mutex_destroy
279
 
#undef pthread_mutex_wait
280
 
#undef pthread_mutex_timedwait
281
 
#undef pthread_mutex_t
282
 
#undef pthread_cond_wait
283
 
#undef pthread_cond_timedwait
284
 
#undef pthread_mutex_trylock
285
 
#define pthread_mutex_init(A,B) my_pthread_fastmutex_init((A),(B))
286
 
#define pthread_mutex_lock(A) my_pthread_fastmutex_lock(A)
287
 
#define pthread_mutex_unlock(A) pthread_mutex_unlock(&(A)->mutex)
288
 
#define pthread_mutex_destroy(A) pthread_mutex_destroy(&(A)->mutex)
289
 
#define pthread_cond_wait(A,B) pthread_cond_wait((A),&(B)->mutex)
290
 
#define pthread_cond_timedwait(A,B,C) pthread_cond_timedwait((A),&(B)->mutex,(C))
291
 
#define pthread_mutex_trylock(A) pthread_mutex_trylock(&(A)->mutex)
292
 
#define pthread_mutex_t my_pthread_fastmutex_t
293
 
#endif /* defined(MY_PTHREAD_FASTMUTEX) */
294
 
 
295
144
        /* READ-WRITE thread locking */
296
145
 
297
 
#ifdef HAVE_BROKEN_RWLOCK                       /* For OpenUnix */
298
 
#undef HAVE_PTHREAD_RWLOCK_RDLOCK
299
 
#undef HAVE_RWLOCK_INIT
300
 
#undef HAVE_RWLOCK_T
301
 
#endif
302
 
 
303
 
#if defined(USE_MUTEX_INSTEAD_OF_RW_LOCKS)
304
 
/* use these defs for simple mutex locking */
305
 
#define rw_lock_t pthread_mutex_t
306
 
#define my_rwlock_init(A,B) pthread_mutex_init((A),(B))
307
 
#define rw_rdlock(A) pthread_mutex_lock((A))
308
 
#define rw_wrlock(A) pthread_mutex_lock((A))
309
 
#define rw_tryrdlock(A) pthread_mutex_trylock((A))
310
 
#define rw_trywrlock(A) pthread_mutex_trylock((A))
311
 
#define rw_unlock(A) pthread_mutex_unlock((A))
312
 
#define rwlock_destroy(A) pthread_mutex_destroy((A))
313
 
#elif defined(HAVE_PTHREAD_RWLOCK_RDLOCK)
314
 
#define rw_lock_t pthread_rwlock_t
315
 
#define my_rwlock_init(A,B) pthread_rwlock_init((A),(B))
316
 
#define rw_rdlock(A) pthread_rwlock_rdlock(A)
317
 
#define rw_wrlock(A) pthread_rwlock_wrlock(A)
318
 
#define rw_tryrdlock(A) pthread_rwlock_tryrdlock((A))
319
 
#define rw_trywrlock(A) pthread_rwlock_trywrlock((A))
320
 
#define rw_unlock(A) pthread_rwlock_unlock(A)
321
 
#define rwlock_destroy(A) pthread_rwlock_destroy(A)
322
 
#elif defined(HAVE_RWLOCK_INIT)
323
 
#ifdef HAVE_RWLOCK_T                            /* For example Solaris 2.6-> */
324
 
#define rw_lock_t rwlock_t
325
 
#endif
326
 
#define my_rwlock_init(A,B) rwlock_init((A),USYNC_THREAD,0)
327
 
#else
328
 
/* Use our own version of read/write locks */
329
 
typedef struct _my_rw_lock_t {
330
 
        pthread_mutex_t lock;           /* lock for structure           */
331
 
        pthread_cond_t  readers;        /* waiting readers              */
332
 
        pthread_cond_t  writers;        /* waiting writers              */
333
 
        int             state;          /* -1:writer,0:free,>0:readers  */
334
 
        int             waiters;        /* number of waiting writers    */
335
 
} my_rw_lock_t;
336
 
 
337
 
#define rw_lock_t my_rw_lock_t
338
 
#define rw_rdlock(A) my_rw_rdlock((A))
339
 
#define rw_wrlock(A) my_rw_wrlock((A))
340
 
#define rw_tryrdlock(A) my_rw_tryrdlock((A))
341
 
#define rw_trywrlock(A) my_rw_trywrlock((A))
342
 
#define rw_unlock(A) my_rw_unlock((A))
343
 
#define rwlock_destroy(A) my_rwlock_destroy((A))
344
 
 
345
 
extern int my_rwlock_init(my_rw_lock_t *, void *);
346
 
extern int my_rwlock_destroy(my_rw_lock_t *);
347
 
extern int my_rw_rdlock(my_rw_lock_t *);
348
 
extern int my_rw_wrlock(my_rw_lock_t *);
349
 
extern int my_rw_unlock(my_rw_lock_t *);
350
 
extern int my_rw_tryrdlock(my_rw_lock_t *);
351
 
extern int my_rw_trywrlock(my_rw_lock_t *);
352
 
#endif /* USE_MUTEX_INSTEAD_OF_RW_LOCKS */
353
 
 
354
146
#ifndef HAVE_THR_SETCONCURRENCY
355
147
#define thr_setconcurrency(A) pthread_dummy(0)
356
148
#endif
359
151
#endif
360
152
 
361
153
/* Define mutex types, see my_thr_init.c */
362
 
#define MY_MUTEX_INIT_SLOW   NULL
363
 
#ifdef PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP
 
154
#ifdef THREAD_ADAPTIVE_MUTEX_INITIALIZER_NP
364
155
extern pthread_mutexattr_t my_fast_mutexattr;
365
156
#define MY_MUTEX_INIT_FAST &my_fast_mutexattr
366
157
#else