Function pthread_create

src/threadwrappers.cpp:93–140

}

extern "C" int
pthread_create(pthread_t *pth,
               const pthread_attr_t *attr,
               void *(*start_routine)(void *),
               void *arg)
{
  WrapperLock wrapperLock;
  Thread *thread = dmtcp_get_current_thread();

  Thread *newThread = ThreadList::getNewThread(start_routine, arg);
  ThreadSync::wrapperExecutionLockLockForNewThread(newThread);
  JASSERT(newThread->wrapperLockCount != 0);

  JASSERT(Thread_UpdateState(thread, ST_THREAD_CREATE, ST_RUNNING));

  int retval = _real_pthread_create(pth, attr, thread_start, newThread);

  JASSERT(Thread_UpdateState(thread, ST_RUNNING, ST_THREAD_CREATE));

  if (retval == 0) {
    ProcessInfo::instance().clearPthreadJoinState(*pth);
    // Since glibc 2.42, pthread_create adds a lightweight guard page
    // at the beginning of the new thread's stack using madvise() and
    // MADV_GUARD_INSTALL. DMTCP may reads from this guard page and
    // cause a segfault. As a quick fix, we remove the guard page
    // immediately.
    //
    // FIXME: A better solution will be keep a record or added
    // lightweight guard page. Remove them at checkpoint time and
    // restore them at restart time.
#if __GLIBC__ == 2 && __GLIBC_MINOR__ >= 42
    pthread_attr_t new_attr;
    void *stack_addr;
    size_t stack_size, guard_size;
    pthread_getattr_np(*pth, &new_attr);
    pthread_attr_getstack(&new_attr, &stack_addr, &stack_size);
    pthread_attr_getguardsize(&new_attr, &guard_size);
    madvise((void*)((char*)stack_addr - guard_size), guard_size,
            MADV_GUARD_REMOVE);
    pthread_attr_destroy(&new_attr);
#endif
  } else { // if we failed to create new pthread
    ThreadSync::wrapperExecutionLockUnlockForNewThread(newThread);
    ThreadList::threadIsDead(newThread);
  }

  return retval;
}

// Make sure __clone is not called without pthread_create.
extern "C" int