musl/src/thread/pthread_self.c

#include "pthread_impl.h"

static struct pthread main_thread;

/* pthread_key_create.c overrides this */
static const void *dummy[1] = { 0 };
weak_alias(dummy, __pthread_tsd_main);

static int init_main_thread()
{
	__syscall(SYS_rt_sigprocmask, SIG_UNBLOCK,
		SIGPT_SET, 0, __SYSCALL_SSLEN);
	if (__set_thread_area(&main_thread) < 0) return -1;
	main_thread.canceldisable = libc.canceldisable;
	main_thread.tsd = (void **)__pthread_tsd_main;
	main_thread.errno_ptr = __errno_location();
	main_thread.self = &main_thread;
	main_thread.tid = main_thread.pid =
		__syscall(SYS_set_tid_address, &main_thread.tid);
	libc.main_thread = &main_thread;
	return 0;
}

pthread_t __pthread_self_def()
{
	static int init, failed;
	if (!init) {
		if (failed) return 0;
		if (init_main_thread() < 0) failed = 1;
		if (failed) return 0;
		init = 1;
	}
	return __pthread_self();
}

weak_alias(__pthread_self_def, pthread_self);
weak_alias(__pthread_self_def, __pthread_self_init);
initial check-in, version 0.5.0 2011-02-12 00:22:29 -05:00			`#include "pthread_impl.h"`

			`static struct pthread main_thread;`

optimize POSIX TSD for fast pthread_getspecific 2011-03-03 18:30:44 -05:00			`/* pthread_key_create.c overrides this */`
use bss instead of mmap for main thread's pthread thread-specific data this simplifies code and removes a failure case 2011-04-01 22:07:59 -04:00			`static const void *dummy[1] = { 0 };`
			`weak_alias(dummy, __pthread_tsd_main);`
optimize POSIX TSD for fast pthread_getspecific 2011-03-03 18:30:44 -05:00
initial check-in, version 0.5.0 2011-02-12 00:22:29 -05:00			`static int init_main_thread()`
			`{`
fix (hopefully) all hard-coded 8's for kernel sigset_t size some minor changes to how hard-coded sets for thread-related purposes are handled were also needed, since the old object sizes were not necessarily sufficient. things have gotten a bit ugly in this area, and i think a cleanup is in order at some point, but for now the goal is just to get the code working on all supported archs including mips, which was badly broken by linux rejecting syscalls with the wrong sigset_t size. 2012-08-09 22:52:13 -04:00			`__syscall(SYS_rt_sigprocmask, SIG_UNBLOCK,`
			`SIGPT_SET, 0, __SYSCALL_SSLEN);`
fix minor bugs due to incorrect threaded-predicate semantics some functions that should have been testing whether pthread_self() had been called and initialized the thread pointer were instead testing whether pthread_create() had been called and actually made the program "threaded". while it's unlikely any mismatch would occur in real-world problems, this could have introduced subtle bugs. now, we store the address of the main thread's thread descriptor in the libc structure and use its presence as a flag that the thread register is initialized. note that after fork, the calling thread (not necessarily the original main thread) is the new main thread. 2011-04-20 21:41:45 -04:00			`if (__set_thread_area(&main_thread) < 0) return -1;`
optimize cancellation enable/disable code the goal is to be able to use pthread_setcancelstate internally in the implementation, whenever a function might want to use functions which are cancellation points but avoid becoming a cancellation point itself. i could have just used a separate internal function for temporarily inhibiting cancellation, but the solution in this commit is better because (1) it's one less implementation-specific detail in functions that need to use it, and (2) application code can also get the same benefit. previously, pthread_setcancelstate dependend on pthread_self, which would pull in unwanted thread setup overhead for non-threaded programs. now, it temporarily stores the state in the global libc struct if threads have not been initialized, and later moves it if needed. this way we can instead use __pthread_self, which has no dependencies and assumes that the thread register is already valid. 2011-04-17 13:21:13 -04:00			`main_thread.canceldisable = libc.canceldisable;`
use bss instead of mmap for main thread's pthread thread-specific data this simplifies code and removes a failure case 2011-04-01 22:07:59 -04:00			`main_thread.tsd = (void **)__pthread_tsd_main;`
finish unifying thread register handling in preparation for porting 2011-02-15 03:56:52 -05:00			`main_thread.errno_ptr = __errno_location();`
simplify multi-threaded errno, eliminate useless function pointer 2011-08-06 20:20:23 -04:00			`main_thread.self = &main_thread;`
remove some stray trailing space characters 2011-09-13 09:53:41 -04:00			`main_thread.tid = main_thread.pid =`
debloat: use __syscall instead of syscall where possible don't waste time (and significant code size due to function call overhead!) setting errno when the result of a syscall does not matter or when it can't fail. 2011-04-17 16:32:15 -04:00			`__syscall(SYS_set_tid_address, &main_thread.tid);`
simplify multi-threaded errno, eliminate useless function pointer 2011-08-06 20:20:23 -04:00			`libc.main_thread = &main_thread;`
initial check-in, version 0.5.0 2011-02-12 00:22:29 -05:00			`return 0;`
			`}`

work around "signal loses thread pointer" issue with "approach 2" this was discussed on the mailing list and no consensus on the preferred solution was reached, so in anticipation of a release, i'm just committing a minimally-invasive solution that avoids the problem by ensuring that multi-threaded-capable programs will always have initialized the thread pointer before any signal handler can run. in the long term we may switch to initializing the thread pointer at program start time whenever the program has the potential to access any per-thread data. 2012-02-27 18:51:02 -05:00			`pthread_t __pthread_self_def()`
initial check-in, version 0.5.0 2011-02-12 00:22:29 -05:00			`{`
			`static int init, failed;`
			`if (!init) {`
			`if (failed) return 0;`
			`if (init_main_thread() < 0) failed = 1;`
			`if (failed) return 0;`
			`init = 1;`
			`}`
			`return __pthread_self();`
			`}`
add proper fuxed-based locking for stdio previously, stdio used spinlocks, which would be unacceptable if we ever add support for thread priorities, and which yielded pathologically bad performance if an application attempted to use flockfile on a key file as a major/primary locking mechanism. i had held off on making this change for fear that it would hurt performance in the non-threaded case, but actually support for recursive locking had already inflicted that cost. by having the internal locking functions store a flag indicating whether they need to perform unlocking, rather than using the actual recursive lock counter, i was able to combine the conditionals at unlock time, eliminating any additional cost, and also avoid a nasty corner case where a huge number of calls to ftrylockfile could cause deadlock later at the point of internal locking. this commit also fixes some issues with usage of pthread_self conflicting with __attribute__((const)) which resulted in crashes with some compiler versions/optimizations, mainly in flockfile prior to pthread_create. 2011-07-30 08:02:14 -04:00
work around "signal loses thread pointer" issue with "approach 2" this was discussed on the mailing list and no consensus on the preferred solution was reached, so in anticipation of a release, i'm just committing a minimally-invasive solution that avoids the problem by ensuring that multi-threaded-capable programs will always have initialized the thread pointer before any signal handler can run. in the long term we may switch to initializing the thread pointer at program start time whenever the program has the potential to access any per-thread data. 2012-02-27 18:51:02 -05:00			`weak_alias(__pthread_self_def, pthread_self);`
			`weak_alias(__pthread_self_def, __pthread_self_init);`