Method stopThisThread

src/library/checkpoint/SaveStateManager.cpp:747–844

}

void SaveStateManager::stopThisThread(int signum)
{
    GlobalNative gn;

    ThreadInfo *current_thread = ThreadManager::getCurrentThread();

    if (current_thread->state == ThreadInfo::ST_TERMINATED) {
        pthread_exit(nullptr);
    }
    
    if (current_thread->state == ThreadInfo::ST_CKPNTHREAD) {
        return;
    }

    /* Make sure we don't get called twice for same thread */
    if (ThreadManager::updateState(current_thread, ThreadInfo::ST_SUSPINPROG, ThreadInfo::ST_SIGNALED)) {

        /* Set up our restart point, ie, we get jumped to here after a restore */

        ThreadLocalStorage::saveTLSState(&current_thread->tlsInfo); // save thread local storage
        MYASSERT(getcontext(&current_thread->savctx) == 0)
        
        /* We save the current stack pointer, so that we can use the remaining
         * space in the stack as a stack segment for the clone() call if the current
         * thread has to be created */
        save_sp(&current_thread->saved_sp);

        if (!restoreInProgress) {

            /* Both state saving and state loading operations go here first, to
             * suspend the thread. */

            /* Tell the checkpoint thread that we're all saved away */
            MYASSERT(ThreadManager::updateState(current_thread, ThreadInfo::ST_SUSPENDED, ThreadInfo::ST_SUSPINPROG))
            sem_post(&semNotifyCkptThread);

            /* Then wait for the ckpt thread to write the ckpt file then wake us up */
            LOG(LL_DEBUG, LCF_CHECKPOINT, "Thread suspended");

            /* Before suspending, we must position the stack pointer so that it
             * always takes the same value. Because the stack pointer may not be
             * the same between saving and loading the thread, and so returning
             * after the `pthread_mutex_lock()` will cause a crash.
             * To do that, we allocate on the stack a big array so that we reach
             * near the end of the stack. */
            ptrdiff_t free_space = reinterpret_cast<ptrdiff_t>(current_thread->saved_sp)
                                 - reinterpret_cast<ptrdiff_t>(current_thread->stack_addr);
            free_space -= 4096*4; // Arbitrary size left to run the remaining code

            LOG(LL_DEBUG, LCF_CHECKPOINT, "Current stack pointer %p and base stack %p size %zu, allocate %td bytes", current_thread->saved_sp, current_thread->stack_addr, current_thread->stack_size, free_space);
            if (free_space < 0) {
                LOG(LL_WARN, LCF_CHECKPOINT, "We don't have enough space left in the stack to pad");
            }
            else {
                uintptr_t *pad = static_cast<uintptr_t*>(alloca(free_space));
                pad[0] = reinterpret_cast<uintptr_t>(pad); // to hopefully prevent optimization
            }