musl/src/thread/pthread_setcancelstate.c

#include "pthread_impl.h"

int pthread_setcancelstate(int new, int *old)
{
	if (new > 1U) return EINVAL;
	if (libc.main_thread) {
		struct pthread *self = __pthread_self();
		if (old) *old = self->canceldisable;
		self->canceldisable = new;
	} else {
		if (old) *old = libc.canceldisable;
		libc.canceldisable = new;
	}
	return 0;
}
initial check-in, version 0.5.0 2011-02-12 00:22:29 -05:00			`#include "pthread_impl.h"`

			`int pthread_setcancelstate(int new, int *old)`
			`{`
simplify cancellation point handling we take advantage of the fact that unless self->cancelpt is 1, cancellation cannot happen. so just increment it by 2 to temporarily block cancellation. this drops pthread_create.o well under 1k. 2011-04-13 20:47:01 -04:00			`if (new > 1U) return EINVAL;`
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 (libc.main_thread) {`
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			`struct pthread *self = __pthread_self();`
			`if (old) *old = self->canceldisable;`
			`self->canceldisable = new;`
			`} else {`
			`if (old) *old = libc.canceldisable;`
			`libc.canceldisable = new;`
			`}`
initial check-in, version 0.5.0 2011-02-12 00:22:29 -05:00			`return 0;`
			`}`