lock

VALUE
rb_mutex_lock(VALUE self)
{

    if (rb_mutex_trylock(self) == Qfalse) {
        rb_mutex_t *mutex;
        rb_thread_t *th = GET_THREAD();
        GetMutexPtr(self, mutex);

        if (mutex->th == GET_THREAD()) {
            rb_raise(rb_eThreadError, "deadlock; recursive locking");
        }

        while (mutex->th != th) {
            int interrupted;
            enum rb_thread_status prev_status = th->status;
            int timeout_ms = 0;
            struct rb_unblock_callback oldubf;

            set_unblock_function(th, lock_interrupt, mutex, &oldubf);
            th->status = THREAD_STOPPED_FOREVER;
            th->locking_mutex = self;

            native_mutex_lock(&mutex->lock);
            th->vm->sleeper++;
            /*
             * Carefully! while some contended threads are in lock_func(),
             * vm->sleepr is unstable value. we have to avoid both deadlock
             * and busy loop.
             */
            if (vm_living_thread_num(th->vm) == th->vm->sleeper) {
                timeout_ms = 100;
            }
            GVL_UNLOCK_BEGIN();
            interrupted = lock_func(th, mutex, timeout_ms);
            native_mutex_unlock(&mutex->lock);
            GVL_UNLOCK_END();

            reset_unblock_function(th, &oldubf);

            th->locking_mutex = Qfalse;
            if (mutex->th && interrupted == 2) {
                rb_check_deadlock(th->vm);
            }
            if (th->status == THREAD_STOPPED_FOREVER) {
                th->status = prev_status;
            }
            th->vm->sleeper--;

            if (mutex->th == th) mutex_locked(th, self);

            if (interrupted) {
                RUBY_VM_CHECK_INTS();
            }
        }
    }
    return self;
}