static inline void release_lock(int i)
{
if ( pthread_mutex_unlock(&__hlt_globals()->synced_fiber_pool_lock) != 0 )
fatal_error("cannot unlock mutex");
hlt_pthread_setcancelstate(i, NULL);
}
static inline void acqire_lock(int* i)
{
hlt_pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, i);
if ( pthread_mutex_lock(&__hlt_globals()->synced_fiber_pool_lock) != 0 )
fatal_error("cannot lock mutex");
}
inline static void _release_lock(hlt_thread_queue* queue, int i, int reader, int thread)
{
if ( PTHREAD_SPIN_UNLOCK(&queue->lock) != 0 )
_fatal_error("cannot release lock");
// fprintf(stderr, "released %p %d %d\n", queue, reader, thread);
hlt_pthread_setcancelstate(i, NULL);
}
// Note: When using _acquire/_release, it is important that there's no
// cancelation point between the two calls as otherwise a lock main remain
// acquired after a thread has already terminated.
inline static void _acquire_lock(hlt_thread_queue* queue, int* i, int reader, int thread)
{
hlt_pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, i);
// stderr, "trying acquired %p %d %d\n", queue, reader, thread);
if ( PTHREAD_SPIN_LOCK(&queue->lock) != 0 )
_fatal_error("cannot acquire lock");
// fprintf(stderr, "acquired %p %d %d\n", queue, reader, thread);
}
static void __exception_print(const char* prefix, hlt_exception* e, hlt_execution_context* ctx)
{
hlt_exception* excpt = 0;
// We must not terminate while in here.
int old_state;
hlt_pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &old_state);
flockfile(stderr);
hlt_string s = __exception_render(e, ctx);
char* c = hlt_string_to_native(s, &excpt, ctx);
fprintf(stderr, "%s%s\n", prefix, c);
hlt_free(c);
fflush(stderr);
funlockfile(stderr);
hlt_pthread_setcancelstate(old_state, NULL);
}
