2 * pthread emulation for re-entrant libcs
4 * We can't use pthreads directly, so why not let libcs
5 * that want pthreads use Wine's own threading instead...
7 * Copyright 1999 Ove Kåven
8 * Copyright 2003 Alexandre Julliard
10 * This library is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with this library; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
26 #include "wine/port.h"
30 struct _pthread_cleanup_buffer
;
41 #include <sys/types.h>
42 #ifdef HAVE_SYS_SOCKET_H
43 # include <sys/socket.h>
45 #ifdef HAVE_SYS_MMAN_H
48 #ifdef HAVE_NETINET_IN_H
49 # include <netinet/in.h>
54 #ifdef HAVE_VALGRIND_MEMCHECK_H
55 #include <valgrind/memcheck.h>
58 #include "wine/pthread.h"
60 #define P_OUTPUT(stuff) write(2,stuff,strlen(stuff))
62 #define PSTR(str) __ASM_NAME(#str)
64 static struct wine_pthread_functions funcs
;
66 /* thread descriptor */
69 #define MAX_KEYS 16 /* libc6 doesn't use that many, but... */
72 struct pthread_descr_struct
79 struct __res_state res_state
;
80 const void *key_data
[MAX_KEYS
]; /* for normal pthread keys */
81 const void *tsd_data
[MAX_TSD
]; /* for libc internal tsd variables */
84 typedef struct pthread_descr_struct
*pthread_descr
;
86 static struct pthread_descr_struct initial_descr
;
88 pthread_descr
__pthread_thread_self(void)
90 struct pthread_descr_struct
*descr
;
91 if (!funcs
.ptr_get_thread_data
) return &initial_descr
;
92 descr
= funcs
.ptr_get_thread_data();
93 if (!descr
) return &initial_descr
;
97 static int (*libc_uselocale
)(int set
);
98 static int *libc_multiple_threads
;
100 /***********************************************************************
101 * __errno_location/__error/__errno/___errno/__thr_errno
103 * Get the per-thread errno location.
105 int *__errno_location(void) /* Linux */
107 pthread_descr descr
= __pthread_thread_self();
108 return &descr
->thread_errno
;
110 int *__error(void) { return __errno_location(); } /* FreeBSD */
111 int *__errno(void) { return __errno_location(); } /* NetBSD */
112 int *___errno(void) { return __errno_location(); } /* Solaris */
113 int *__thr_errno(void) { return __errno_location(); } /* UnixWare */
115 /***********************************************************************
118 * Get the per-thread h_errno location.
120 int *__h_errno_location(void)
122 pthread_descr descr
= __pthread_thread_self();
123 return &descr
->thread_h_errno
;
126 struct __res_state
*__res_state(void)
128 pthread_descr descr
= __pthread_thread_self();
129 return &descr
->res_state
;
132 static inline void writejump( const char *symbol
, void *dest
)
134 #if defined(__GLIBC__) && defined(__i386__)
135 unsigned char *addr
= dlsym( RTLD_NEXT
, symbol
);
139 /* write a relative jump at the function address */
140 mprotect((void*)((unsigned int)addr
& ~(getpagesize()-1)), 5, PROT_READ
|PROT_EXEC
|PROT_WRITE
);
142 *(int *)(addr
+1) = (unsigned char *)dest
- (addr
+ 5);
143 mprotect((void*)((unsigned int)addr
& ~(getpagesize()-1)), 5, PROT_READ
|PROT_EXEC
);
145 # ifdef HAVE_VALGRIND_MEMCHECK_H
146 VALGRIND_DISCARD_TRANSLATIONS( addr
, 5 );
148 #endif /* __GLIBC__ && __i386__ */
151 /***********************************************************************
152 * wine_pthread_init_process
154 * Initialization for a newly created process.
156 void wine_pthread_init_process( const struct wine_pthread_functions
*functions
)
158 memcpy( &funcs
, functions
, sizeof(funcs
) );
159 funcs
.ptr_set_thread_data( &initial_descr
);
163 /***********************************************************************
164 * wine_pthread_init_thread
166 * Initialization for a newly created thread.
168 void wine_pthread_init_thread(void)
170 struct pthread_descr_struct
*descr
;
172 if (funcs
.ptr_set_thread_data
)
174 descr
= calloc( 1, sizeof(*descr
) );
175 funcs
.ptr_set_thread_data( descr
);
176 if (libc_multiple_threads
) *libc_multiple_threads
= 1;
178 else /* first thread */
180 descr
= &initial_descr
;
181 writejump( "__errno_location", __errno_location
);
182 writejump( "__h_errno_location", __h_errno_location
);
183 writejump( "__res_state", __res_state
);
185 descr
->cancel_state
= PTHREAD_CANCEL_ENABLE
;
186 descr
->cancel_type
= PTHREAD_CANCEL_ASYNCHRONOUS
;
187 if (libc_uselocale
) libc_uselocale( -1 /*LC_GLOBAL_LOCALE*/ );
191 /* Currently this probably works only for glibc2,
192 * which checks for the presence of double-underscore-prepended
193 * pthread primitives, and use them if available.
194 * If they are not available, the libc defaults to
195 * non-threadsafe operation (not good). */
197 #if defined(__GLIBC__) || defined(__FreeBSD__)
205 /* adapt as necessary (a construct like this is used in glibc sources) */
206 #define strong_alias(orig, alias) \
207 asm(".globl " PSTR(alias) "\n" \
208 "\t.set " PSTR(alias) "," PSTR(orig))
212 /* pthread functions redirection */
214 struct pthread_functions
216 pid_t (*ptr_pthread_fork
) (struct fork_block
*);
217 int (*ptr_pthread_attr_destroy
) (pthread_attr_t
*);
218 int (*ptr___pthread_attr_init_2_0
) (pthread_attr_t
*);
219 int (*ptr___pthread_attr_init_2_1
) (pthread_attr_t
*);
220 int (*ptr_pthread_attr_getdetachstate
) (const pthread_attr_t
*, int *);
221 int (*ptr_pthread_attr_setdetachstate
) (pthread_attr_t
*, int);
222 int (*ptr_pthread_attr_getinheritsched
) (const pthread_attr_t
*, int *);
223 int (*ptr_pthread_attr_setinheritsched
) (pthread_attr_t
*, int);
224 int (*ptr_pthread_attr_getschedparam
) (const pthread_attr_t
*, struct sched_param
*);
225 int (*ptr_pthread_attr_setschedparam
) (pthread_attr_t
*, const struct sched_param
*);
226 int (*ptr_pthread_attr_getschedpolicy
) (const pthread_attr_t
*, int *);
227 int (*ptr_pthread_attr_setschedpolicy
) (pthread_attr_t
*, int);
228 int (*ptr_pthread_attr_getscope
) (const pthread_attr_t
*, int *);
229 int (*ptr_pthread_attr_setscope
) (pthread_attr_t
*, int);
230 int (*ptr_pthread_condattr_destroy
) (pthread_condattr_t
*);
231 int (*ptr_pthread_condattr_init
) (pthread_condattr_t
*);
232 int (*ptr___pthread_cond_broadcast
) (pthread_cond_t
*);
233 int (*ptr___pthread_cond_destroy
) (pthread_cond_t
*);
234 int (*ptr___pthread_cond_init
) (pthread_cond_t
*, const pthread_condattr_t
*);
235 int (*ptr___pthread_cond_signal
) (pthread_cond_t
*);
236 int (*ptr___pthread_cond_wait
) (pthread_cond_t
*, pthread_mutex_t
*);
237 int (*ptr_pthread_equal
) (pthread_t
, pthread_t
);
238 void (*ptr___pthread_exit
) (void *);
239 int (*ptr_pthread_getschedparam
) (pthread_t
, int *, struct sched_param
*);
240 int (*ptr_pthread_setschedparam
) (pthread_t
, int, const struct sched_param
*);
241 int (*ptr_pthread_mutex_destroy
) (pthread_mutex_t
*);
242 int (*ptr_pthread_mutex_init
) (pthread_mutex_t
*, const pthread_mutexattr_t
*);
243 int (*ptr_pthread_mutex_lock
) (pthread_mutex_t
*);
244 int (*ptr_pthread_mutex_trylock
) (pthread_mutex_t
*);
245 int (*ptr_pthread_mutex_unlock
) (pthread_mutex_t
*);
246 pthread_t (*ptr_pthread_self
) (void);
247 int (*ptr_pthread_setcancelstate
) (int, int *);
248 int (*ptr_pthread_setcanceltype
) (int, int *);
249 void (*ptr_pthread_do_exit
) (void *retval
, char *currentframe
);
250 void (*ptr_pthread_cleanup_upto
) (jmp_buf target
, char *targetframe
);
251 pthread_descr (*ptr_pthread_thread_self
) (void);
252 int (*ptr_pthread_internal_tsd_set
) (int key
, const void *pointer
);
253 void * (*ptr_pthread_internal_tsd_get
) (int key
);
254 void ** __attribute__ ((__const__
)) (*ptr_pthread_internal_tsd_address
) (int key
);
255 int (*ptr_pthread_sigaction
) (int sig
, const struct sigaction
* act
, struct sigaction
*oact
);
256 int (*ptr_pthread_sigwait
) (const sigset_t
*set
, int *sig
);
257 int (*ptr_pthread_raise
) (int sig
);
258 int (*ptr___pthread_cond_timedwait
) (pthread_cond_t
*, pthread_mutex_t
*, const struct timespec
*);
259 void (*ptr__pthread_cleanup_push
) (struct _pthread_cleanup_buffer
* buffer
, void (*routine
)(void *), void * arg
);
260 void (*ptr__pthread_cleanup_pop
) (struct _pthread_cleanup_buffer
* buffer
, int execute
);
263 static pid_t (*libc_fork
)(void);
264 static int (*libc_sigaction
)(int signum
, const struct sigaction
*act
, struct sigaction
*oldact
);
265 static int *(*libc_pthread_init
)( const struct pthread_functions
*funcs
);
267 static struct pthread_functions libc_pthread_functions
;
269 strong_alias(__pthread_thread_self
, pthread_thread_self
);
271 /* redefine this to prevent libpthread from overriding our function pointers */
272 int *__libc_pthread_init( const struct pthread_functions
*funcs
)
274 return libc_multiple_threads
;
277 typedef struct _wine_cleanup
{
278 void (*routine
)(void *);
282 int pthread_create(pthread_t
* thread
, const pthread_attr_t
* attr
, void*
283 (*start_routine
)(void *), void* arg
)
285 assert( funcs
.ptr_pthread_create
);
286 return funcs
.ptr_pthread_create( thread
, attr
, start_routine
, arg
);
289 int pthread_cancel(pthread_t thread
)
291 assert( funcs
.ptr_pthread_cancel
);
292 return funcs
.ptr_pthread_cancel( thread
);
295 int pthread_join(pthread_t thread
, void **value_ptr
)
297 assert( funcs
.ptr_pthread_join
);
298 return funcs
.ptr_pthread_join( thread
, value_ptr
);
301 int pthread_detach(pthread_t thread
)
303 assert( funcs
.ptr_pthread_detach
);
304 return funcs
.ptr_pthread_detach( thread
);
307 /* FIXME: we have no equivalents in win32 for the policys */
308 /* so just keep this as a stub */
309 int pthread_attr_setschedpolicy(pthread_attr_t
*attr
, int policy
)
311 P_OUTPUT("FIXME:pthread_attr_setschedpolicy\n");
315 /* FIXME: no win32 equivalent for scope */
316 int pthread_attr_setscope(pthread_attr_t
*attr
, int scope
)
318 P_OUTPUT("FIXME:pthread_attr_setscope\n");
319 return 0; /* return success */
322 /* FIXME: no win32 equivalent for schedule param */
323 int pthread_attr_setschedparam(pthread_attr_t
*attr
,
324 const struct sched_param
*param
)
326 P_OUTPUT("FIXME:pthread_attr_setschedparam\n");
327 return 0; /* return success */
331 int pthread_attr_setstack(pthread_attr_t
*attr
, void *addr
, size_t size
)
333 return 0; /* return success */
336 int __pthread_once(pthread_once_t
*once_control
, void (*init_routine
)(void))
338 static pthread_once_t the_once
= PTHREAD_ONCE_INIT
;
341 memcpy(&once_now
,&the_once
,sizeof(once_now
));
342 if (interlocked_cmpxchg((long*)once_control
, once_now
+1, once_now
) == once_now
)
346 strong_alias(__pthread_once
, pthread_once
);
348 void __pthread_kill_other_threads_np(void)
350 /* we don't need to do anything here */
352 strong_alias(__pthread_kill_other_threads_np
, pthread_kill_other_threads_np
);
356 #define MAX_ATFORK 8 /* libc doesn't need that many anyway */
358 static pthread_mutex_t atfork_mutex
= PTHREAD_MUTEX_INITIALIZER
;
360 typedef void (*atfork_handler
)();
361 static atfork_handler atfork_prepare
[MAX_ATFORK
];
362 static atfork_handler atfork_parent
[MAX_ATFORK
];
363 static atfork_handler atfork_child
[MAX_ATFORK
];
364 static int atfork_count
;
366 int __pthread_atfork(void (*prepare
)(void), void (*parent
)(void), void (*child
)(void))
368 pthread_mutex_lock( &atfork_mutex
);
369 assert( atfork_count
< MAX_ATFORK
);
370 atfork_prepare
[atfork_count
] = prepare
;
371 atfork_parent
[atfork_count
] = parent
;
372 atfork_child
[atfork_count
] = child
;
374 pthread_mutex_unlock( &atfork_mutex
);
377 strong_alias(__pthread_atfork
, pthread_atfork
);
386 libc_fork
= dlsym( RTLD_NEXT
, "fork" );
389 pthread_mutex_lock( &atfork_mutex
);
390 /* prepare handlers are called in reverse insertion order */
391 for (i
= atfork_count
- 1; i
>= 0; i
--) if (atfork_prepare
[i
]) atfork_prepare
[i
]();
392 if (!(pid
= libc_fork()))
394 pthread_mutex_init( &atfork_mutex
, NULL
);
395 for (i
= 0; i
< atfork_count
; i
++) if (atfork_child
[i
]) atfork_child
[i
]();
399 for (i
= 0; i
< atfork_count
; i
++) if (atfork_parent
[i
]) atfork_parent
[i
]();
400 pthread_mutex_unlock( &atfork_mutex
);
404 strong_alias(__fork
, fork
);
406 /***** MUTEXES *****/
408 int __pthread_mutex_init(pthread_mutex_t
*mutex
, const pthread_mutexattr_t
*mutexattr
)
410 if (!funcs
.ptr_pthread_mutex_init
) return 0;
411 return funcs
.ptr_pthread_mutex_init( mutex
, mutexattr
);
413 strong_alias(__pthread_mutex_init
, pthread_mutex_init
);
415 int __pthread_mutex_lock(pthread_mutex_t
*mutex
)
417 if (!funcs
.ptr_pthread_mutex_lock
) return 0;
418 return funcs
.ptr_pthread_mutex_lock( mutex
);
420 strong_alias(__pthread_mutex_lock
, pthread_mutex_lock
);
422 int __pthread_mutex_trylock(pthread_mutex_t
*mutex
)
424 if (!funcs
.ptr_pthread_mutex_trylock
) return 0;
425 return funcs
.ptr_pthread_mutex_trylock( mutex
);
427 strong_alias(__pthread_mutex_trylock
, pthread_mutex_trylock
);
429 int __pthread_mutex_unlock(pthread_mutex_t
*mutex
)
431 if (!funcs
.ptr_pthread_mutex_unlock
) return 0;
432 return funcs
.ptr_pthread_mutex_unlock( mutex
);
434 strong_alias(__pthread_mutex_unlock
, pthread_mutex_unlock
);
436 int __pthread_mutex_destroy(pthread_mutex_t
*mutex
)
438 if (!funcs
.ptr_pthread_mutex_destroy
) return 0;
439 return funcs
.ptr_pthread_mutex_destroy( mutex
);
441 strong_alias(__pthread_mutex_destroy
, pthread_mutex_destroy
);
444 /***** MUTEX ATTRIBUTES *****/
445 /* just dummies, since critical sections are always recursive */
447 int __pthread_mutexattr_init(pthread_mutexattr_t
*attr
)
451 strong_alias(__pthread_mutexattr_init
, pthread_mutexattr_init
);
453 int __pthread_mutexattr_destroy(pthread_mutexattr_t
*attr
)
457 strong_alias(__pthread_mutexattr_destroy
, pthread_mutexattr_destroy
);
459 int __pthread_mutexattr_setkind_np(pthread_mutexattr_t
*attr
, int kind
)
463 strong_alias(__pthread_mutexattr_setkind_np
, pthread_mutexattr_setkind_np
);
465 int __pthread_mutexattr_getkind_np(pthread_mutexattr_t
*attr
, int *kind
)
467 *kind
= PTHREAD_MUTEX_RECURSIVE
;
470 strong_alias(__pthread_mutexattr_getkind_np
, pthread_mutexattr_getkind_np
);
472 int __pthread_mutexattr_settype(pthread_mutexattr_t
*attr
, int kind
)
476 strong_alias(__pthread_mutexattr_settype
, pthread_mutexattr_settype
);
478 int __pthread_mutexattr_gettype(pthread_mutexattr_t
*attr
, int *kind
)
480 *kind
= PTHREAD_MUTEX_RECURSIVE
;
483 strong_alias(__pthread_mutexattr_gettype
, pthread_mutexattr_gettype
);
486 /***** THREAD-SPECIFIC VARIABLES (KEYS) *****/
488 int __pthread_key_create(pthread_key_t
*key
, void (*destr_function
)(void *))
490 static long keycnt
= FIRST_KEY
;
491 *key
= interlocked_xchg_add(&keycnt
, 1);
494 strong_alias(__pthread_key_create
, pthread_key_create
);
496 int __pthread_key_delete(pthread_key_t key
)
500 strong_alias(__pthread_key_delete
, pthread_key_delete
);
502 int __pthread_setspecific(pthread_key_t key
, const void *pointer
)
504 pthread_descr descr
= __pthread_thread_self();
505 descr
->key_data
[key
] = pointer
;
508 strong_alias(__pthread_setspecific
, pthread_setspecific
);
510 void *__pthread_getspecific(pthread_key_t key
)
512 pthread_descr descr
= __pthread_thread_self();
513 return (void *)descr
->key_data
[key
];
515 strong_alias(__pthread_getspecific
, pthread_getspecific
);
517 static int pthread_internal_tsd_set( int key
, const void *pointer
)
519 pthread_descr descr
= __pthread_thread_self();
520 descr
->tsd_data
[key
] = pointer
;
523 int (*__libc_internal_tsd_set
)(int, const void *) = pthread_internal_tsd_set
;
525 static void *pthread_internal_tsd_get( int key
)
527 pthread_descr descr
= __pthread_thread_self();
528 return (void *)descr
->tsd_data
[key
];
530 void* (*__libc_internal_tsd_get
)(int) = pthread_internal_tsd_get
;
532 static void ** __attribute__((const)) pthread_internal_tsd_address( int key
)
534 pthread_descr descr
= __pthread_thread_self();
535 return (void **)&descr
->tsd_data
[key
];
537 void** (*__libc_internal_tsd_address
)(int) = pthread_internal_tsd_address
;
539 /***** "EXCEPTION" FRAMES *****/
540 /* not implemented right now */
542 void _pthread_cleanup_push(struct _pthread_cleanup_buffer
*buffer
, void (*routine
)(void *), void *arg
)
544 ((wine_cleanup
)buffer
)->routine
= routine
;
545 ((wine_cleanup
)buffer
)->arg
= arg
;
548 void _pthread_cleanup_pop(struct _pthread_cleanup_buffer
*buffer
, int execute
)
550 if (execute
) (*(((wine_cleanup
)buffer
)->routine
))(((wine_cleanup
)buffer
)->arg
);
553 void _pthread_cleanup_push_defer(struct _pthread_cleanup_buffer
*buffer
, void (*routine
)(void *), void *arg
)
555 _pthread_cleanup_push(buffer
, routine
, arg
);
558 void _pthread_cleanup_pop_restore(struct _pthread_cleanup_buffer
*buffer
, int execute
)
560 _pthread_cleanup_pop(buffer
, execute
);
563 void __pthread_cleanup_upto(jmp_buf target
, char *frame
)
568 /***** CONDITIONS *****/
570 int __pthread_cond_init(pthread_cond_t
*cond
, const pthread_condattr_t
*cond_attr
)
572 if (!funcs
.ptr_pthread_cond_init
) return 0;
573 return funcs
.ptr_pthread_cond_init(cond
, cond_attr
);
575 strong_alias(__pthread_cond_init
, pthread_cond_init
);
577 int __pthread_cond_destroy(pthread_cond_t
*cond
)
579 if (!funcs
.ptr_pthread_cond_destroy
) return 0;
580 return funcs
.ptr_pthread_cond_destroy(cond
);
582 strong_alias(__pthread_cond_destroy
, pthread_cond_destroy
);
584 int __pthread_cond_signal(pthread_cond_t
*cond
)
586 if (!funcs
.ptr_pthread_cond_signal
) return 0;
587 return funcs
.ptr_pthread_cond_signal(cond
);
589 strong_alias(__pthread_cond_signal
, pthread_cond_signal
);
591 int __pthread_cond_broadcast(pthread_cond_t
*cond
)
593 if (!funcs
.ptr_pthread_cond_broadcast
) return 0;
594 return funcs
.ptr_pthread_cond_broadcast(cond
);
596 strong_alias(__pthread_cond_broadcast
, pthread_cond_broadcast
);
598 int __pthread_cond_wait(pthread_cond_t
*cond
, pthread_mutex_t
*mutex
)
600 if (!funcs
.ptr_pthread_cond_wait
) return 0;
601 return funcs
.ptr_pthread_cond_wait(cond
, mutex
);
603 strong_alias(__pthread_cond_wait
, pthread_cond_wait
);
605 int __pthread_cond_timedwait(pthread_cond_t
*cond
, pthread_mutex_t
*mutex
, const struct timespec
*abstime
)
607 if (!funcs
.ptr_pthread_cond_timedwait
) return 0;
608 return funcs
.ptr_pthread_cond_timedwait(cond
, mutex
, abstime
);
610 strong_alias(__pthread_cond_timedwait
, pthread_cond_timedwait
);
612 /**** CONDITION ATTRIBUTES *****/
613 /* not implemented right now */
615 int pthread_condattr_init(pthread_condattr_t
*attr
)
620 int pthread_condattr_destroy(pthread_condattr_t
*attr
)
625 /***** READ-WRITE LOCKS *****/
627 int __pthread_rwlock_init(pthread_rwlock_t
*rwlock
, const pthread_rwlockattr_t
*rwlock_attr
)
629 assert( funcs
.ptr_pthread_rwlock_init
);
630 return funcs
.ptr_pthread_rwlock_init( rwlock
, rwlock_attr
);
632 strong_alias(__pthread_rwlock_init
, pthread_rwlock_init
);
634 int __pthread_rwlock_destroy(pthread_rwlock_t
*rwlock
)
636 assert( funcs
.ptr_pthread_rwlock_destroy
);
637 return funcs
.ptr_pthread_rwlock_destroy( rwlock
);
639 strong_alias(__pthread_rwlock_destroy
, pthread_rwlock_destroy
);
641 int __pthread_rwlock_rdlock(pthread_rwlock_t
*rwlock
)
643 if (!funcs
.ptr_pthread_rwlock_rdlock
) return 0;
644 return funcs
.ptr_pthread_rwlock_rdlock( rwlock
);
646 strong_alias(__pthread_rwlock_rdlock
, pthread_rwlock_rdlock
);
648 int __pthread_rwlock_tryrdlock(pthread_rwlock_t
*rwlock
)
650 assert( funcs
.ptr_pthread_rwlock_tryrdlock
);
651 return funcs
.ptr_pthread_rwlock_tryrdlock( rwlock
);
653 strong_alias(__pthread_rwlock_tryrdlock
, pthread_rwlock_tryrdlock
);
655 int __pthread_rwlock_wrlock(pthread_rwlock_t
*rwlock
)
657 assert( funcs
.ptr_pthread_rwlock_wrlock
);
658 return funcs
.ptr_pthread_rwlock_wrlock( rwlock
);
660 strong_alias(__pthread_rwlock_wrlock
, pthread_rwlock_wrlock
);
662 int __pthread_rwlock_trywrlock(pthread_rwlock_t
*rwlock
)
664 assert( funcs
.ptr_pthread_rwlock_trywrlock
);
665 return funcs
.ptr_pthread_rwlock_trywrlock( rwlock
);
667 strong_alias(__pthread_rwlock_trywrlock
, pthread_rwlock_trywrlock
);
669 int __pthread_rwlock_unlock(pthread_rwlock_t
*rwlock
)
671 if (!funcs
.ptr_pthread_rwlock_unlock
) return 0;
672 return funcs
.ptr_pthread_rwlock_unlock( rwlock
);
674 strong_alias(__pthread_rwlock_unlock
, pthread_rwlock_unlock
);
676 /**** READ-WRITE LOCK ATTRIBUTES *****/
677 /* not implemented right now */
679 int pthread_rwlockattr_init(pthread_rwlockattr_t
*attr
)
684 int __pthread_rwlockattr_destroy(pthread_rwlockattr_t
*attr
)
688 strong_alias(__pthread_rwlockattr_destroy
, pthread_rwlockattr_destroy
);
690 int pthread_rwlockattr_getkind_np(const pthread_rwlockattr_t
*attr
, int *pref
)
696 int pthread_rwlockattr_setkind_np(pthread_rwlockattr_t
*attr
, int pref
)
703 pthread_t
pthread_self(void)
705 assert( funcs
.ptr_pthread_self
);
706 return funcs
.ptr_pthread_self();
709 int pthread_equal(pthread_t thread1
, pthread_t thread2
)
711 assert( funcs
.ptr_pthread_equal
);
712 return funcs
.ptr_pthread_equal( thread1
, thread2
);
715 void __pthread_do_exit(void *retval
, char *currentframe
)
717 assert( funcs
.ptr_pthread_exit
);
718 return funcs
.ptr_pthread_exit( retval
, currentframe
);
721 void __pthread_exit(void *retval
)
723 __pthread_do_exit( retval
, NULL
);
725 strong_alias(__pthread_exit
, pthread_exit
);
727 int pthread_setcancelstate(int state
, int *oldstate
)
729 pthread_descr descr
= __pthread_thread_self();
730 if (oldstate
) *oldstate
= descr
->cancel_state
;
731 descr
->cancel_state
= state
;
735 int pthread_setcanceltype(int type
, int *oldtype
)
737 pthread_descr descr
= __pthread_thread_self();
738 if (oldtype
) *oldtype
= descr
->cancel_type
;
739 descr
->cancel_type
= type
;
743 /***** ANTI-OVERRIDES *****/
744 /* pthreads tries to override these, point them back to libc */
746 int sigaction(int signum
, const struct sigaction
*act
, struct sigaction
*oldact
)
750 libc_sigaction
= dlsym( RTLD_NEXT
, "sigaction" );
751 assert( libc_sigaction
);
753 return libc_sigaction(signum
, act
, oldact
);
756 void __pthread_initialize(void)
763 libc_fork
= dlsym( RTLD_NEXT
, "fork" );
764 libc_sigaction
= dlsym( RTLD_NEXT
, "sigaction" );
765 libc_uselocale
= dlsym( RTLD_NEXT
, "uselocale" );
766 libc_pthread_init
= dlsym( RTLD_NEXT
, "__libc_pthread_init" );
767 if (libc_pthread_init
) libc_multiple_threads
= libc_pthread_init( &libc_pthread_functions
);
770 DECL_GLOBAL_CONSTRUCTOR(init
) { __pthread_initialize(); }
772 static struct pthread_functions libc_pthread_functions
=
774 NULL
, /* ptr_pthread_fork */
775 NULL
, /* FIXME */ /* ptr_pthread_attr_destroy */
776 NULL
, /* FIXME */ /* ptr___pthread_attr_init_2_0 */
777 NULL
, /* FIXME */ /* ptr___pthread_attr_init_2_1 */
778 NULL
, /* FIXME */ /* ptr_pthread_attr_getdetachstate */
779 NULL
, /* FIXME */ /* ptr_pthread_attr_setdetachstate */
780 NULL
, /* FIXME */ /* ptr_pthread_attr_getinheritsched */
781 NULL
, /* FIXME */ /* ptr_pthread_attr_setinheritsched */
782 NULL
, /* FIXME */ /* ptr_pthread_attr_getschedparam */
783 pthread_attr_setschedparam
, /* ptr_pthread_attr_setschedparam */
784 NULL
, /* FIXME */ /* ptr_pthread_attr_getschedpolicy) (const pthread_attr_t *, int *); */
785 NULL
, /* FIXME */ /* ptr_pthread_attr_setschedpolicy) (pthread_attr_t *, int); */
786 NULL
, /* FIXME */ /* ptr_pthread_attr_getscope) (const pthread_attr_t *, int *); */
787 NULL
, /* FIXME */ /* ptr_pthread_attr_setscope) (pthread_attr_t *, int); */
788 pthread_condattr_destroy
, /* ptr_pthread_condattr_destroy */
789 pthread_condattr_init
, /* ptr_pthread_condattr_init */
790 __pthread_cond_broadcast
, /* ptr___pthread_cond_broadcast */
791 __pthread_cond_destroy
, /* ptr___pthread_cond_destroy */
792 __pthread_cond_init
, /* ptr___pthread_cond_init */
793 __pthread_cond_signal
, /* ptr___pthread_cond_signal */
794 __pthread_cond_wait
, /* ptr___pthread_cond_wait */
795 pthread_equal
, /* ptr_pthread_equal */
796 __pthread_exit
, /* ptr___pthread_exit */
797 NULL
, /* FIXME */ /* ptr_pthread_getschedparam */
798 NULL
, /* FIXME */ /* ptr_pthread_setschedparam */
799 __pthread_mutex_destroy
, /* ptr_pthread_mutex_destroy */
800 __pthread_mutex_init
, /* ptr_pthread_mutex_init */
801 __pthread_mutex_lock
, /* ptr_pthread_mutex_lock */
802 __pthread_mutex_trylock
, /* ptr_pthread_mutex_trylock */
803 __pthread_mutex_unlock
, /* ptr_pthread_mutex_unlock */
804 pthread_self
, /* ptr_pthread_self */
805 pthread_setcancelstate
, /* ptr_pthread_setcancelstate */
806 pthread_setcanceltype
, /* ptr_pthread_setcanceltype */
807 __pthread_do_exit
, /* ptr_pthread_do_exit */
808 __pthread_cleanup_upto
, /* ptr_pthread_cleanup_upto */
809 __pthread_thread_self
, /* ptr_pthread_thread_self */
810 pthread_internal_tsd_set
, /* ptr_pthread_internal_tsd_set */
811 pthread_internal_tsd_get
, /* ptr_pthread_internal_tsd_get */
812 pthread_internal_tsd_address
, /* ptr_pthread_internal_tsd_address */
813 NULL
, /* ptr_pthread_sigaction */
814 NULL
, /* ptr_pthread_sigwait */
815 NULL
, /* ptr_pthread_raise */
816 __pthread_cond_timedwait
, /* ptr___pthread_cond_timedwait */
817 _pthread_cleanup_push
, /* ptr__pthread_cleanup_push */
818 _pthread_cleanup_pop
/* ptr__pthread_cleanup_pop */
821 #endif /* __GLIBC__ || __FREEBSD__ */
823 #else /* HAVE_NPTL */
825 void wine_pthread_init_process( const struct wine_pthread_functions
*functions
)
829 void wine_pthread_init_thread(void)
833 #endif /* HAVE_NPTL */