2 * pthread emulation based on kernel threads
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"
28 struct _pthread_cleanup_buffer
;
39 #include <sys/types.h>
40 #ifdef HAVE_SYS_SOCKET_H
41 # include <sys/socket.h>
43 #ifdef HAVE_SYS_MMAN_H
46 #ifdef HAVE_NETINET_IN_H
47 # include <netinet/in.h>
49 #ifdef HAVE_ARPA_NAMESER_H
50 # include <arpa/nameser.h>
55 #ifdef HAVE_VALGRIND_MEMCHECK_H
56 #include <valgrind/memcheck.h>
58 #ifdef HAVE_SYS_SYSCALL_H
59 # include <sys/syscall.h>
64 #ifdef HAVE_UCONTEXT_H
65 # include <ucontext.h>
71 #include "wine/library.h"
72 #include "wine/pthread.h"
74 #define P_OUTPUT(stuff) write(2,stuff,strlen(stuff))
76 #define PSTR(str) __ASM_NAME(#str)
78 static struct wine_pthread_callbacks funcs
;
80 /* thread descriptor */
83 #define MAX_KEYS 16 /* libc6 doesn't use that many, but... */
86 struct pthread_descr_struct
93 struct __res_state res_state
;
94 const void *key_data
[MAX_KEYS
]; /* for normal pthread keys */
95 const void *tsd_data
[MAX_TSD
]; /* for libc internal tsd variables */
98 typedef struct pthread_descr_struct
*pthread_descr
;
100 static struct pthread_descr_struct initial_descr
;
102 pthread_descr
__pthread_thread_self(void)
104 struct pthread_descr_struct
*descr
;
105 if (!funcs
.ptr_get_thread_data
) return &initial_descr
;
106 descr
= funcs
.ptr_get_thread_data();
107 if (!descr
) return &initial_descr
;
111 static int (*libc_uselocale
)(int set
);
112 static int *libc_multiple_threads
;
114 /***********************************************************************
115 * __errno_location/__error/__errno/___errno/__thr_errno
117 * Get the per-thread errno location.
119 int *__errno_location(void) /* Linux */
121 pthread_descr descr
= __pthread_thread_self();
122 return &descr
->thread_errno
;
124 int *__error(void) { return __errno_location(); } /* FreeBSD */
125 int *__errno(void) { return __errno_location(); } /* NetBSD */
126 int *___errno(void) { return __errno_location(); } /* Solaris */
127 int *__thr_errno(void) { return __errno_location(); } /* UnixWare */
129 /***********************************************************************
132 * Get the per-thread h_errno location.
134 int *__h_errno_location(void)
136 pthread_descr descr
= __pthread_thread_self();
137 return &descr
->thread_h_errno
;
140 struct __res_state
*__res_state(void)
142 pthread_descr descr
= __pthread_thread_self();
143 return &descr
->res_state
;
146 static inline void writejump( const char *symbol
, void *dest
)
148 #if defined(__GLIBC__) && defined(__i386__)
149 unsigned char *addr
= wine_dlsym( RTLD_NEXT
, symbol
, NULL
, 0 );
153 /* write a relative jump at the function address */
154 mprotect((void*)((unsigned int)addr
& ~(getpagesize()-1)), 5, PROT_READ
|PROT_EXEC
|PROT_WRITE
);
156 *(int *)(addr
+1) = (unsigned char *)dest
- (addr
+ 5);
157 mprotect((void*)((unsigned int)addr
& ~(getpagesize()-1)), 5, PROT_READ
|PROT_EXEC
);
159 # ifdef HAVE_VALGRIND_MEMCHECK_H
160 VALGRIND_DISCARD_TRANSLATIONS( addr
, 5 );
162 #endif /* __GLIBC__ && __i386__ */
165 /* temporary stacks used on thread exit */
166 #define TEMP_STACK_SIZE 1024
167 #define NB_TEMP_STACKS 8
168 static char temp_stacks
[NB_TEMP_STACKS
][TEMP_STACK_SIZE
];
169 static int next_temp_stack
; /* next temp stack to use */
171 /***********************************************************************
174 * Get a temporary stack address to run the thread exit code on.
176 inline static char *get_temp_stack(void)
178 unsigned int next
= interlocked_xchg_add( &next_temp_stack
, 1 );
179 return temp_stacks
[next
% NB_TEMP_STACKS
] + TEMP_STACK_SIZE
;
183 /***********************************************************************
186 * Cleanup the remains of a thread. Runs on a temporary stack.
188 static void cleanup_thread( void *ptr
)
190 /* copy the info structure since it is on the stack we will free */
191 struct wine_pthread_thread_info info
= *(struct wine_pthread_thread_info
*)ptr
;
192 wine_ldt_free_fs( info
.teb_sel
);
193 munmap( info
.stack_base
, info
.stack_size
);
194 munmap( info
.teb_base
, info
.teb_size
);
195 #ifdef HAVE__LWP_CREATE
198 _exit( info
.exit_status
);
202 /***********************************************************************
205 * Initialization for a newly created process.
207 static void init_process( const struct wine_pthread_callbacks
*callbacks
, size_t size
)
209 memcpy( &funcs
, callbacks
, min( size
, sizeof(funcs
) ));
210 funcs
.ptr_set_thread_data( &initial_descr
);
214 /***********************************************************************
217 * Initialization for a newly created thread.
219 static void init_thread( struct wine_pthread_thread_info
*info
)
221 struct pthread_descr_struct
*descr
;
223 if (funcs
.ptr_set_thread_data
)
225 descr
= calloc( 1, sizeof(*descr
) );
226 funcs
.ptr_set_thread_data( descr
);
227 if (libc_multiple_threads
) *libc_multiple_threads
= 1;
229 else /* first thread */
231 descr
= &initial_descr
;
232 writejump( "__errno_location", __errno_location
);
233 writejump( "__h_errno_location", __h_errno_location
);
234 writejump( "__res_state", __res_state
);
236 descr
->cancel_state
= PTHREAD_CANCEL_ENABLE
;
237 descr
->cancel_type
= PTHREAD_CANCEL_ASYNCHRONOUS
;
238 if (libc_uselocale
) libc_uselocale( -1 /*LC_GLOBAL_LOCALE*/ );
242 /***********************************************************************
245 static int create_thread( struct wine_pthread_thread_info
*info
)
247 if (!info
->stack_base
)
249 info
->stack_base
= wine_anon_mmap( NULL
, info
->stack_size
,
250 PROT_READ
| PROT_WRITE
| PROT_EXEC
, 0 );
251 if (info
->stack_base
== (void *)-1) return -1;
254 if (clone( (int (*)(void *))info
->entry
, (char *)info
->stack_base
+ info
->stack_size
,
255 CLONE_VM
| CLONE_FS
| CLONE_FILES
| SIGCHLD
, info
) < 0)
258 #elif defined(HAVE_RFORK)
260 void **sp
= (void **)((char *)info
->stack_base
+ info
->stack_size
);
264 __asm__
__volatile__(
265 "pushl %2;\n\t" /* flags */
266 "pushl $0;\n\t" /* 0 ? */
267 "movl %1,%%eax;\n\t" /* SYS_rfork */
268 ".byte 0x9a; .long 0; .word 7;\n\t" /* lcall 7:0... FreeBSD syscall */
269 "cmpl $0, %%edx;\n\t"
271 "movl %0,%%esp;\n\t" /* child -> new thread */
273 "1:\n\t" /* parent -> caller thread */
275 : "r" (sp
), "r" (SYS_rfork
), "r" (RFPROC
| RFMEM
| RFTHREAD
)
279 #elif defined(HAVE__LWP_CREATE)
282 _lwp_makecontext( &context
, (void(*)(void *))info
->entry
, info
,
283 NULL
, info
->stack_base
, info
->stack_size
);
284 if ( _lwp_create( &context
, 0, NULL
) )
293 /***********************************************************************
296 * Set the current TEB for a new thread.
298 static void init_current_teb( struct wine_pthread_thread_info
*info
)
301 /* On the i386, the current thread is in the %fs register */
304 wine_ldt_set_base( &fs_entry
, info
->teb_base
);
305 wine_ldt_set_limit( &fs_entry
, info
->teb_size
- 1 );
306 wine_ldt_set_flags( &fs_entry
, WINE_LDT_FLAGS_DATA
|WINE_LDT_FLAGS_32BIT
);
307 wine_ldt_init_fs( info
->teb_sel
, &fs_entry
);
308 #elif defined(HAVE__LWP_CREATE)
309 /* On non-i386 Solaris, we use the LWP private pointer */
310 _lwp_setprivate( info
->teb_base
);
311 #elif defined(__powerpc__)
312 /* On PowerPC, the current TEB is in the gpr13 register */
314 __asm__
__volatile__("mr r13, %0" : : "r" (info
->teb_base
));
316 __asm__
__volatile__("mr 2, %0" : : "r" (info
->teb_base
));
318 #elif defined(__ALPHA__)
319 /* FIXME: On Alpha, the current TEB is not accessible to user-space */
320 /* __asm__ __volatile__();*/
322 # error You must implement init_current_teb for your platform
325 /* set pid and tid */
326 info
->pid
= getpid();
327 #ifdef HAVE__LWP_SELF
328 info
->tid
= _lwp_self();
335 /***********************************************************************
338 static void *get_current_teb(void)
343 __asm__( ".byte 0x64\n\tmovl 0x18,%0" : "=r" (ret
) );
344 #elif defined(HAVE__LWP_CREATE)
345 ret
= _lwp_getprivate();
346 #elif defined(__powerpc__)
348 __asm__( "mr %0,r13" : "=r" (ret
) );
350 __asm__( "mr %0,2" : "=r" (ret
) );
352 #elif defined(__ALPHA__)
353 /* 0x00ab is the PAL opcode for rdteb */
354 __asm__( "lda $30,8($30)\n\t"
356 "call_pal 0x00ab\n\t"
359 "lda $30,-8($30)" : "=r" (ret
) );
361 # error get_current_teb not defined for this architecture
362 #endif /* __i386__ */
368 /***********************************************************************
371 static void DECLSPEC_NORETURN
exit_thread( struct wine_pthread_thread_info
*info
)
373 wine_switch_to_stack( cleanup_thread
, info
, get_temp_stack() );
377 /***********************************************************************
380 static void DECLSPEC_NORETURN
abort_thread( long status
)
382 #ifdef HAVE__LWP_CREATE
389 /***********************************************************************
392 const struct wine_pthread_functions pthread_functions
=
404 /* Currently this probably works only for glibc2,
405 * which checks for the presence of double-underscore-prepended
406 * pthread primitives, and use them if available.
407 * If they are not available, the libc defaults to
408 * non-threadsafe operation (not good). */
410 #if defined(HAVE_PTHREAD_H) && (defined(__GLIBC__) || defined(__FreeBSD__))
412 /* adapt as necessary (a construct like this is used in glibc sources) */
413 #define strong_alias(orig, alias) \
414 asm(".globl " PSTR(alias) "\n" \
415 "\t.set " PSTR(alias) "," PSTR(orig))
419 /* pthread functions redirection */
421 struct pthread_functions
423 pid_t (*ptr_pthread_fork
) (struct fork_block
*);
424 int (*ptr_pthread_attr_destroy
) (pthread_attr_t
*);
425 int (*ptr___pthread_attr_init_2_0
) (pthread_attr_t
*);
426 int (*ptr___pthread_attr_init_2_1
) (pthread_attr_t
*);
427 int (*ptr_pthread_attr_getdetachstate
) (const pthread_attr_t
*, int *);
428 int (*ptr_pthread_attr_setdetachstate
) (pthread_attr_t
*, int);
429 int (*ptr_pthread_attr_getinheritsched
) (const pthread_attr_t
*, int *);
430 int (*ptr_pthread_attr_setinheritsched
) (pthread_attr_t
*, int);
431 int (*ptr_pthread_attr_getschedparam
) (const pthread_attr_t
*, struct sched_param
*);
432 int (*ptr_pthread_attr_setschedparam
) (pthread_attr_t
*, const struct sched_param
*);
433 int (*ptr_pthread_attr_getschedpolicy
) (const pthread_attr_t
*, int *);
434 int (*ptr_pthread_attr_setschedpolicy
) (pthread_attr_t
*, int);
435 int (*ptr_pthread_attr_getscope
) (const pthread_attr_t
*, int *);
436 int (*ptr_pthread_attr_setscope
) (pthread_attr_t
*, int);
437 int (*ptr_pthread_condattr_destroy
) (pthread_condattr_t
*);
438 int (*ptr_pthread_condattr_init
) (pthread_condattr_t
*);
439 int (*ptr___pthread_cond_broadcast
) (pthread_cond_t
*);
440 int (*ptr___pthread_cond_destroy
) (pthread_cond_t
*);
441 int (*ptr___pthread_cond_init
) (pthread_cond_t
*, const pthread_condattr_t
*);
442 int (*ptr___pthread_cond_signal
) (pthread_cond_t
*);
443 int (*ptr___pthread_cond_wait
) (pthread_cond_t
*, pthread_mutex_t
*);
444 int (*ptr_pthread_equal
) (pthread_t
, pthread_t
);
445 void (*ptr___pthread_exit
) (void *);
446 int (*ptr_pthread_getschedparam
) (pthread_t
, int *, struct sched_param
*);
447 int (*ptr_pthread_setschedparam
) (pthread_t
, int, const struct sched_param
*);
448 int (*ptr_pthread_mutex_destroy
) (pthread_mutex_t
*);
449 int (*ptr_pthread_mutex_init
) (pthread_mutex_t
*, const pthread_mutexattr_t
*);
450 int (*ptr_pthread_mutex_lock
) (pthread_mutex_t
*);
451 int (*ptr_pthread_mutex_trylock
) (pthread_mutex_t
*);
452 int (*ptr_pthread_mutex_unlock
) (pthread_mutex_t
*);
453 pthread_t (*ptr_pthread_self
) (void);
454 int (*ptr_pthread_setcancelstate
) (int, int *);
455 int (*ptr_pthread_setcanceltype
) (int, int *);
456 void (*ptr_pthread_do_exit
) (void *retval
, char *currentframe
);
457 void (*ptr_pthread_cleanup_upto
) (jmp_buf target
, char *targetframe
);
458 pthread_descr (*ptr_pthread_thread_self
) (void);
459 int (*ptr_pthread_internal_tsd_set
) (int key
, const void *pointer
);
460 void * (*ptr_pthread_internal_tsd_get
) (int key
);
461 void ** __attribute__ ((__const__
)) (*ptr_pthread_internal_tsd_address
) (int key
);
462 int (*ptr_pthread_sigaction
) (int sig
, const struct sigaction
* act
, struct sigaction
*oact
);
463 int (*ptr_pthread_sigwait
) (const sigset_t
*set
, int *sig
);
464 int (*ptr_pthread_raise
) (int sig
);
465 int (*ptr___pthread_cond_timedwait
) (pthread_cond_t
*, pthread_mutex_t
*, const struct timespec
*);
466 void (*ptr__pthread_cleanup_push
) (struct _pthread_cleanup_buffer
* buffer
, void (*routine
)(void *), void * arg
);
467 void (*ptr__pthread_cleanup_pop
) (struct _pthread_cleanup_buffer
* buffer
, int execute
);
470 static pid_t (*libc_fork
)(void);
471 static int (*libc_sigaction
)(int signum
, const struct sigaction
*act
, struct sigaction
*oldact
);
472 static int *(*libc_pthread_init
)( const struct pthread_functions
*funcs
);
474 static struct pthread_functions libc_pthread_functions
;
476 strong_alias(__pthread_thread_self
, pthread_thread_self
);
478 /* redefine this to prevent libpthread from overriding our function pointers */
479 int *__libc_pthread_init( const struct pthread_functions
*funcs
)
481 return libc_multiple_threads
;
484 typedef struct _wine_cleanup
{
485 void (*routine
)(void *);
489 int pthread_create(pthread_t
* thread
, const pthread_attr_t
* attr
, void*
490 (*start_routine
)(void *), void* arg
)
492 assert( funcs
.ptr_pthread_create
);
493 return funcs
.ptr_pthread_create( thread
, attr
, start_routine
, arg
);
496 int pthread_cancel(pthread_t thread
)
498 assert( funcs
.ptr_pthread_cancel
);
499 return funcs
.ptr_pthread_cancel( thread
);
502 int pthread_join(pthread_t thread
, void **value_ptr
)
504 assert( funcs
.ptr_pthread_join
);
505 return funcs
.ptr_pthread_join( thread
, value_ptr
);
508 int pthread_detach(pthread_t thread
)
510 assert( funcs
.ptr_pthread_detach
);
511 return funcs
.ptr_pthread_detach( thread
);
514 /* FIXME: we have no equivalents in win32 for the policys */
515 /* so just keep this as a stub */
516 int pthread_attr_setschedpolicy(pthread_attr_t
*attr
, int policy
)
518 P_OUTPUT("FIXME:pthread_attr_setschedpolicy\n");
522 /* FIXME: no win32 equivalent for scope */
523 int pthread_attr_setscope(pthread_attr_t
*attr
, int scope
)
525 P_OUTPUT("FIXME:pthread_attr_setscope\n");
526 return 0; /* return success */
529 /* FIXME: no win32 equivalent for schedule param */
530 int pthread_attr_setschedparam(pthread_attr_t
*attr
,
531 const struct sched_param
*param
)
533 P_OUTPUT("FIXME:pthread_attr_setschedparam\n");
534 return 0; /* return success */
538 int pthread_attr_setstack(pthread_attr_t
*attr
, void *addr
, size_t size
)
540 return 0; /* return success */
543 int __pthread_once(pthread_once_t
*once_control
, void (*init_routine
)(void))
545 static pthread_once_t the_once
= PTHREAD_ONCE_INIT
;
548 memcpy(&once_now
,&the_once
,sizeof(once_now
));
549 if (interlocked_cmpxchg((int*)once_control
, once_now
+1, once_now
) == once_now
)
553 strong_alias(__pthread_once
, pthread_once
);
555 void __pthread_kill_other_threads_np(void)
557 /* we don't need to do anything here */
559 strong_alias(__pthread_kill_other_threads_np
, pthread_kill_other_threads_np
);
563 #define MAX_ATFORK 8 /* libc doesn't need that many anyway */
565 static pthread_mutex_t atfork_mutex
= PTHREAD_MUTEX_INITIALIZER
;
567 typedef void (*atfork_handler
)();
568 static atfork_handler atfork_prepare
[MAX_ATFORK
];
569 static atfork_handler atfork_parent
[MAX_ATFORK
];
570 static atfork_handler atfork_child
[MAX_ATFORK
];
571 static int atfork_count
;
573 int __pthread_atfork(void (*prepare
)(void), void (*parent
)(void), void (*child
)(void))
575 pthread_mutex_lock( &atfork_mutex
);
576 assert( atfork_count
< MAX_ATFORK
);
577 atfork_prepare
[atfork_count
] = prepare
;
578 atfork_parent
[atfork_count
] = parent
;
579 atfork_child
[atfork_count
] = child
;
581 pthread_mutex_unlock( &atfork_mutex
);
584 strong_alias(__pthread_atfork
, pthread_atfork
);
593 libc_fork
= wine_dlsym( RTLD_NEXT
, "fork", NULL
, 0 );
596 pthread_mutex_lock( &atfork_mutex
);
597 /* prepare handlers are called in reverse insertion order */
598 for (i
= atfork_count
- 1; i
>= 0; i
--) if (atfork_prepare
[i
]) atfork_prepare
[i
]();
599 if (!(pid
= libc_fork()))
601 pthread_mutex_init( &atfork_mutex
, NULL
);
602 for (i
= 0; i
< atfork_count
; i
++) if (atfork_child
[i
]) atfork_child
[i
]();
606 for (i
= 0; i
< atfork_count
; i
++) if (atfork_parent
[i
]) atfork_parent
[i
]();
607 pthread_mutex_unlock( &atfork_mutex
);
611 strong_alias(__fork
, fork
);
613 /***** MUTEXES *****/
615 int __pthread_mutex_init(pthread_mutex_t
*mutex
, const pthread_mutexattr_t
*mutexattr
)
617 if (!funcs
.ptr_pthread_mutex_init
) return 0;
618 return funcs
.ptr_pthread_mutex_init( mutex
, mutexattr
);
620 strong_alias(__pthread_mutex_init
, pthread_mutex_init
);
622 int __pthread_mutex_lock(pthread_mutex_t
*mutex
)
624 if (!funcs
.ptr_pthread_mutex_lock
) return 0;
625 return funcs
.ptr_pthread_mutex_lock( mutex
);
627 strong_alias(__pthread_mutex_lock
, pthread_mutex_lock
);
629 int __pthread_mutex_trylock(pthread_mutex_t
*mutex
)
631 if (!funcs
.ptr_pthread_mutex_trylock
) return 0;
632 return funcs
.ptr_pthread_mutex_trylock( mutex
);
634 strong_alias(__pthread_mutex_trylock
, pthread_mutex_trylock
);
636 int __pthread_mutex_unlock(pthread_mutex_t
*mutex
)
638 if (!funcs
.ptr_pthread_mutex_unlock
) return 0;
639 return funcs
.ptr_pthread_mutex_unlock( mutex
);
641 strong_alias(__pthread_mutex_unlock
, pthread_mutex_unlock
);
643 int __pthread_mutex_destroy(pthread_mutex_t
*mutex
)
645 if (!funcs
.ptr_pthread_mutex_destroy
) return 0;
646 return funcs
.ptr_pthread_mutex_destroy( mutex
);
648 strong_alias(__pthread_mutex_destroy
, pthread_mutex_destroy
);
651 /***** MUTEX ATTRIBUTES *****/
652 /* just dummies, since critical sections are always recursive */
654 int __pthread_mutexattr_init(pthread_mutexattr_t
*attr
)
658 strong_alias(__pthread_mutexattr_init
, pthread_mutexattr_init
);
660 int __pthread_mutexattr_destroy(pthread_mutexattr_t
*attr
)
664 strong_alias(__pthread_mutexattr_destroy
, pthread_mutexattr_destroy
);
666 int __pthread_mutexattr_setkind_np(pthread_mutexattr_t
*attr
, int kind
)
670 strong_alias(__pthread_mutexattr_setkind_np
, pthread_mutexattr_setkind_np
);
672 int __pthread_mutexattr_getkind_np(pthread_mutexattr_t
*attr
, int *kind
)
674 *kind
= PTHREAD_MUTEX_RECURSIVE
;
677 strong_alias(__pthread_mutexattr_getkind_np
, pthread_mutexattr_getkind_np
);
679 int __pthread_mutexattr_settype(pthread_mutexattr_t
*attr
, int kind
)
683 strong_alias(__pthread_mutexattr_settype
, pthread_mutexattr_settype
);
685 int __pthread_mutexattr_gettype(const pthread_mutexattr_t
*attr
, int *kind
)
687 *kind
= PTHREAD_MUTEX_RECURSIVE
;
690 strong_alias(__pthread_mutexattr_gettype
, pthread_mutexattr_gettype
);
693 /***** THREAD-SPECIFIC VARIABLES (KEYS) *****/
695 int __pthread_key_create(pthread_key_t
*key
, void (*destr_function
)(void *))
697 static int keycnt
= FIRST_KEY
;
698 *key
= interlocked_xchg_add(&keycnt
, 1);
701 strong_alias(__pthread_key_create
, pthread_key_create
);
703 int __pthread_key_delete(pthread_key_t key
)
707 strong_alias(__pthread_key_delete
, pthread_key_delete
);
709 int __pthread_setspecific(pthread_key_t key
, const void *pointer
)
711 pthread_descr descr
= __pthread_thread_self();
712 descr
->key_data
[key
] = pointer
;
715 strong_alias(__pthread_setspecific
, pthread_setspecific
);
717 void *__pthread_getspecific(pthread_key_t key
)
719 pthread_descr descr
= __pthread_thread_self();
720 return (void *)descr
->key_data
[key
];
722 strong_alias(__pthread_getspecific
, pthread_getspecific
);
724 static int pthread_internal_tsd_set( int key
, const void *pointer
)
726 pthread_descr descr
= __pthread_thread_self();
727 descr
->tsd_data
[key
] = pointer
;
730 int (*__libc_internal_tsd_set
)(int, const void *) = pthread_internal_tsd_set
;
732 static void *pthread_internal_tsd_get( int key
)
734 pthread_descr descr
= __pthread_thread_self();
735 return (void *)descr
->tsd_data
[key
];
737 void* (*__libc_internal_tsd_get
)(int) = pthread_internal_tsd_get
;
739 static void ** __attribute__((const)) pthread_internal_tsd_address( int key
)
741 pthread_descr descr
= __pthread_thread_self();
742 return (void **)&descr
->tsd_data
[key
];
744 void** (*__libc_internal_tsd_address
)(int) = pthread_internal_tsd_address
;
746 /***** "EXCEPTION" FRAMES *****/
747 /* not implemented right now */
749 void _pthread_cleanup_push(struct _pthread_cleanup_buffer
*buffer
, void (*routine
)(void *), void *arg
)
751 ((wine_cleanup
)buffer
)->routine
= routine
;
752 ((wine_cleanup
)buffer
)->arg
= arg
;
755 void _pthread_cleanup_pop(struct _pthread_cleanup_buffer
*buffer
, int execute
)
757 if (execute
) (*(((wine_cleanup
)buffer
)->routine
))(((wine_cleanup
)buffer
)->arg
);
760 void _pthread_cleanup_push_defer(struct _pthread_cleanup_buffer
*buffer
, void (*routine
)(void *), void *arg
)
762 _pthread_cleanup_push(buffer
, routine
, arg
);
765 void _pthread_cleanup_pop_restore(struct _pthread_cleanup_buffer
*buffer
, int execute
)
767 _pthread_cleanup_pop(buffer
, execute
);
770 void __pthread_cleanup_upto(jmp_buf target
, char *frame
)
775 /***** CONDITIONS *****/
777 int __pthread_cond_init(pthread_cond_t
*cond
, const pthread_condattr_t
*cond_attr
)
779 if (!funcs
.ptr_pthread_cond_init
) return 0;
780 return funcs
.ptr_pthread_cond_init(cond
, cond_attr
);
782 strong_alias(__pthread_cond_init
, pthread_cond_init
);
784 int __pthread_cond_destroy(pthread_cond_t
*cond
)
786 if (!funcs
.ptr_pthread_cond_destroy
) return 0;
787 return funcs
.ptr_pthread_cond_destroy(cond
);
789 strong_alias(__pthread_cond_destroy
, pthread_cond_destroy
);
791 int __pthread_cond_signal(pthread_cond_t
*cond
)
793 if (!funcs
.ptr_pthread_cond_signal
) return 0;
794 return funcs
.ptr_pthread_cond_signal(cond
);
796 strong_alias(__pthread_cond_signal
, pthread_cond_signal
);
798 int __pthread_cond_broadcast(pthread_cond_t
*cond
)
800 if (!funcs
.ptr_pthread_cond_broadcast
) return 0;
801 return funcs
.ptr_pthread_cond_broadcast(cond
);
803 strong_alias(__pthread_cond_broadcast
, pthread_cond_broadcast
);
805 int __pthread_cond_wait(pthread_cond_t
*cond
, pthread_mutex_t
*mutex
)
807 if (!funcs
.ptr_pthread_cond_wait
) return 0;
808 return funcs
.ptr_pthread_cond_wait(cond
, mutex
);
810 strong_alias(__pthread_cond_wait
, pthread_cond_wait
);
812 int __pthread_cond_timedwait(pthread_cond_t
*cond
, pthread_mutex_t
*mutex
, const struct timespec
*abstime
)
814 if (!funcs
.ptr_pthread_cond_timedwait
) return 0;
815 return funcs
.ptr_pthread_cond_timedwait(cond
, mutex
, abstime
);
817 strong_alias(__pthread_cond_timedwait
, pthread_cond_timedwait
);
819 /**** CONDITION ATTRIBUTES *****/
820 /* not implemented right now */
822 int pthread_condattr_init(pthread_condattr_t
*attr
)
827 int pthread_condattr_destroy(pthread_condattr_t
*attr
)
832 /***** READ-WRITE LOCKS *****/
834 int __pthread_rwlock_init(pthread_rwlock_t
*rwlock
, const pthread_rwlockattr_t
*rwlock_attr
)
836 assert( funcs
.ptr_pthread_rwlock_init
);
837 return funcs
.ptr_pthread_rwlock_init( rwlock
, rwlock_attr
);
839 strong_alias(__pthread_rwlock_init
, pthread_rwlock_init
);
841 int __pthread_rwlock_destroy(pthread_rwlock_t
*rwlock
)
843 assert( funcs
.ptr_pthread_rwlock_destroy
);
844 return funcs
.ptr_pthread_rwlock_destroy( rwlock
);
846 strong_alias(__pthread_rwlock_destroy
, pthread_rwlock_destroy
);
848 int __pthread_rwlock_rdlock(pthread_rwlock_t
*rwlock
)
850 if (!funcs
.ptr_pthread_rwlock_rdlock
) return 0;
851 return funcs
.ptr_pthread_rwlock_rdlock( rwlock
);
853 strong_alias(__pthread_rwlock_rdlock
, pthread_rwlock_rdlock
);
855 int __pthread_rwlock_tryrdlock(pthread_rwlock_t
*rwlock
)
857 assert( funcs
.ptr_pthread_rwlock_tryrdlock
);
858 return funcs
.ptr_pthread_rwlock_tryrdlock( rwlock
);
860 strong_alias(__pthread_rwlock_tryrdlock
, pthread_rwlock_tryrdlock
);
862 int __pthread_rwlock_wrlock(pthread_rwlock_t
*rwlock
)
864 assert( funcs
.ptr_pthread_rwlock_wrlock
);
865 return funcs
.ptr_pthread_rwlock_wrlock( rwlock
);
867 strong_alias(__pthread_rwlock_wrlock
, pthread_rwlock_wrlock
);
869 int __pthread_rwlock_trywrlock(pthread_rwlock_t
*rwlock
)
871 assert( funcs
.ptr_pthread_rwlock_trywrlock
);
872 return funcs
.ptr_pthread_rwlock_trywrlock( rwlock
);
874 strong_alias(__pthread_rwlock_trywrlock
, pthread_rwlock_trywrlock
);
876 int __pthread_rwlock_unlock(pthread_rwlock_t
*rwlock
)
878 if (!funcs
.ptr_pthread_rwlock_unlock
) return 0;
879 return funcs
.ptr_pthread_rwlock_unlock( rwlock
);
881 strong_alias(__pthread_rwlock_unlock
, pthread_rwlock_unlock
);
883 /**** READ-WRITE LOCK ATTRIBUTES *****/
884 /* not implemented right now */
886 int pthread_rwlockattr_init(pthread_rwlockattr_t
*attr
)
891 int __pthread_rwlockattr_destroy(pthread_rwlockattr_t
*attr
)
895 strong_alias(__pthread_rwlockattr_destroy
, pthread_rwlockattr_destroy
);
897 int pthread_rwlockattr_getkind_np(const pthread_rwlockattr_t
*attr
, int *pref
)
903 int pthread_rwlockattr_setkind_np(pthread_rwlockattr_t
*attr
, int pref
)
910 pthread_t
pthread_self(void)
912 assert( funcs
.ptr_pthread_self
);
913 return funcs
.ptr_pthread_self();
916 int pthread_equal(pthread_t thread1
, pthread_t thread2
)
918 assert( funcs
.ptr_pthread_equal
);
919 return funcs
.ptr_pthread_equal( thread1
, thread2
);
922 void __pthread_do_exit(void *retval
, char *currentframe
)
924 assert( funcs
.ptr_pthread_exit
);
925 return funcs
.ptr_pthread_exit( retval
, currentframe
);
928 void __pthread_exit(void *retval
)
930 __pthread_do_exit( retval
, NULL
);
932 strong_alias(__pthread_exit
, pthread_exit
);
934 int pthread_setcancelstate(int state
, int *oldstate
)
936 pthread_descr descr
= __pthread_thread_self();
937 if (oldstate
) *oldstate
= descr
->cancel_state
;
938 descr
->cancel_state
= state
;
942 int pthread_setcanceltype(int type
, int *oldtype
)
944 pthread_descr descr
= __pthread_thread_self();
945 if (oldtype
) *oldtype
= descr
->cancel_type
;
946 descr
->cancel_type
= type
;
950 /***** ANTI-OVERRIDES *****/
951 /* pthreads tries to override these, point them back to libc */
953 int sigaction(int signum
, const struct sigaction
*act
, struct sigaction
*oldact
)
957 libc_sigaction
= wine_dlsym( RTLD_NEXT
, "sigaction", NULL
, 0 );
958 assert( libc_sigaction
);
960 return libc_sigaction(signum
, act
, oldact
);
963 void __pthread_initialize(void)
970 libc_fork
= wine_dlsym( RTLD_NEXT
, "fork", NULL
, 0 );
971 libc_sigaction
= wine_dlsym( RTLD_NEXT
, "sigaction", NULL
, 0 );
972 libc_uselocale
= wine_dlsym( RTLD_DEFAULT
, "uselocale", NULL
, 0 );
973 libc_pthread_init
= wine_dlsym( RTLD_NEXT
, "__libc_pthread_init", NULL
, 0 );
974 if (libc_pthread_init
) libc_multiple_threads
= libc_pthread_init( &libc_pthread_functions
);
979 static void init(void) __attribute__((constructor
));
980 static void init(void)
982 __pthread_initialize();
986 static struct pthread_functions libc_pthread_functions
=
988 NULL
, /* ptr_pthread_fork */
989 NULL
, /* FIXME */ /* ptr_pthread_attr_destroy */
990 NULL
, /* FIXME */ /* ptr___pthread_attr_init_2_0 */
991 NULL
, /* FIXME */ /* ptr___pthread_attr_init_2_1 */
992 NULL
, /* FIXME */ /* ptr_pthread_attr_getdetachstate */
993 NULL
, /* FIXME */ /* ptr_pthread_attr_setdetachstate */
994 NULL
, /* FIXME */ /* ptr_pthread_attr_getinheritsched */
995 NULL
, /* FIXME */ /* ptr_pthread_attr_setinheritsched */
996 NULL
, /* FIXME */ /* ptr_pthread_attr_getschedparam */
997 pthread_attr_setschedparam
, /* ptr_pthread_attr_setschedparam */
998 NULL
, /* FIXME */ /* ptr_pthread_attr_getschedpolicy */
999 NULL
, /* FIXME */ /* ptr_pthread_attr_setschedpolicy */
1000 NULL
, /* FIXME */ /* ptr_pthread_attr_getscope */
1001 NULL
, /* FIXME */ /* ptr_pthread_attr_setscope */
1002 pthread_condattr_destroy
, /* ptr_pthread_condattr_destroy */
1003 pthread_condattr_init
, /* ptr_pthread_condattr_init */
1004 __pthread_cond_broadcast
, /* ptr___pthread_cond_broadcast */
1005 __pthread_cond_destroy
, /* ptr___pthread_cond_destroy */
1006 __pthread_cond_init
, /* ptr___pthread_cond_init */
1007 __pthread_cond_signal
, /* ptr___pthread_cond_signal */
1008 __pthread_cond_wait
, /* ptr___pthread_cond_wait */
1009 pthread_equal
, /* ptr_pthread_equal */
1010 __pthread_exit
, /* ptr___pthread_exit */
1011 NULL
, /* FIXME */ /* ptr_pthread_getschedparam */
1012 NULL
, /* FIXME */ /* ptr_pthread_setschedparam */
1013 __pthread_mutex_destroy
, /* ptr_pthread_mutex_destroy */
1014 __pthread_mutex_init
, /* ptr_pthread_mutex_init */
1015 __pthread_mutex_lock
, /* ptr_pthread_mutex_lock */
1016 __pthread_mutex_trylock
, /* ptr_pthread_mutex_trylock */
1017 __pthread_mutex_unlock
, /* ptr_pthread_mutex_unlock */
1018 pthread_self
, /* ptr_pthread_self */
1019 pthread_setcancelstate
, /* ptr_pthread_setcancelstate */
1020 pthread_setcanceltype
, /* ptr_pthread_setcanceltype */
1021 __pthread_do_exit
, /* ptr_pthread_do_exit */
1022 __pthread_cleanup_upto
, /* ptr_pthread_cleanup_upto */
1023 __pthread_thread_self
, /* ptr_pthread_thread_self */
1024 pthread_internal_tsd_set
, /* ptr_pthread_internal_tsd_set */
1025 pthread_internal_tsd_get
, /* ptr_pthread_internal_tsd_get */
1026 pthread_internal_tsd_address
, /* ptr_pthread_internal_tsd_address */
1027 NULL
, /* ptr_pthread_sigaction */
1028 NULL
, /* ptr_pthread_sigwait */
1029 NULL
, /* ptr_pthread_raise */
1030 __pthread_cond_timedwait
, /* ptr___pthread_cond_timedwait */
1031 _pthread_cleanup_push
, /* ptr__pthread_cleanup_push */
1032 _pthread_cleanup_pop
/* ptr__pthread_cleanup_pop */
1035 #endif /* HAVE_PTHREAD_H && (__GLIBC__ || __FREEBSD__) */