/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

/* vim: set ts=8 sts=2 et sw=2 tw=80: */

/* This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "nsThread.h"

#include "base/message_loop.h"

#include "base/platform_thread.h"

// Chromium's logging can sometimes leak through...

#ifdef LOG

#undef LOG

#endif

#include "mozilla/ReentrantMonitor.h"

#include "nsMemoryPressure.h"

#include "nsThreadManager.h"

#include "nsIClassInfoImpl.h"

#include "nsAutoPtr.h"

#include "nsCOMPtr.h"

#include "nsQueryObject.h"

#include "pratom.h"

#include "mozilla/BackgroundHangMonitor.h"

#include "mozilla/CycleCollectedJSContext.h"

#include "mozilla/Logging.h"

#include "nsIObserverService.h"

#include "mozilla/IOInterposer.h"

#include "mozilla/ipc/MessageChannel.h"

#include "mozilla/ipc/BackgroundChild.h"

#include "mozilla/Preferences.h"

#include "mozilla/Scheduler.h"

#include "mozilla/SchedulerGroup.h"

#include "mozilla/Services.h"

#include "mozilla/StaticPrefs.h"

#include "mozilla/SystemGroup.h"

#include "nsXPCOMPrivate.h"

#include "mozilla/ChaosMode.h"

#include "mozilla/Telemetry.h"

#include "mozilla/TimeStamp.h"

#include "mozilla/Unused.h"

#include "mozilla/dom/ScriptSettings.h"

#include "nsThreadSyncDispatch.h"

#include "nsServiceManagerUtils.h"

#include "GeckoProfiler.h"

#include "InputEventStatistics.h"

#include "ThreadEventTarget.h"

#include "ThreadDelay.h"

#ifdef XP_LINUX

#ifdef __GLIBC__

#include <gnu/libc-version.h>

#endif

#include <sys/mman.h>

#include <sys/time.h>

#include <sys/resource.h>

#include <sched.h>

#include <stdio.h>

#endif

#ifdef XP_WIN

#include "mozilla/DynamicallyLinkedFunctionPtr.h"

#include <winbase.h>

using GetCurrentThreadStackLimitsFn = void (WINAPI*)(

  PULONG_PTR LowLimit, PULONG_PTR HighLimit);

#endif

#define HAVE_UALARM _BSD_SOURCE || (_XOPEN_SOURCE >= 500 ||                 \

                      _XOPEN_SOURCE && _XOPEN_SOURCE_EXTENDED) &&           \

                      !(_POSIX_C_SOURCE >= 200809L || _XOPEN_SOURCE >= 700)

#if defined(XP_LINUX) && !defined(ANDROID) && defined(_GNU_SOURCE)

#define HAVE_SCHED_SETAFFINITY

#endif

#ifdef XP_MACOSX

#include <mach/mach.h>

#include <mach/thread_policy.h>

#endif

#ifdef MOZ_CANARY

# include <unistd.h>

# include <execinfo.h>

# include <signal.h>

# include <fcntl.h>

# include "nsXULAppAPI.h"

#endif

#if defined(NS_FUNCTION_TIMER) && defined(_MSC_VER)

#include "nsTimerImpl.h"

#include "mozilla/StackWalk.h"

#endif

#ifdef NS_FUNCTION_TIMER

#include "nsCRT.h"

#endif

#ifdef MOZ_TASK_TRACER

#include "GeckoTaskTracer.h"

#include "TracedTaskCommon.h"

using namespace mozilla::tasktracer;

#endif

using namespace mozilla;

static LazyLogModule sThreadLog("nsThread");

#ifdef LOG

#undef LOG

#endif

#define LOG(args) MOZ_LOG(sThreadLog, mozilla::LogLevel::Debug, args)

NS_DECL_CI_INTERFACE_GETTER(nsThread)

Array<char, nsThread::kRunnableNameBufSize> nsThread::sMainThreadRunnableName;

//-----------------------------------------------------------------------------

// Because we do not have our own nsIFactory, we have to implement nsIClassInfo

// somewhat manually.

class nsThreadClassInfo : public nsIClassInfo

{

public:

  NS_DECL_ISUPPORTS_INHERITED  // no mRefCnt

  NS_DECL_NSICLASSINFO

  nsThreadClassInfo()

  {

  }

};

NS_IMETHODIMP_(MozExternalRefCountType)

nsThreadClassInfo::AddRef()

{

  return 2;

}

NS_IMETHODIMP_(MozExternalRefCountType)

nsThreadClassInfo::Release()

{

  return 1;

}

NS_IMPL_QUERY_INTERFACE(nsThreadClassInfo, nsIClassInfo)

NS_IMETHODIMP

nsThreadClassInfo::GetInterfaces(uint32_t* aCount, nsIID*** aArray)

{

  return NS_CI_INTERFACE_GETTER_NAME(nsThread)(aCount, aArray);

}

NS_IMETHODIMP

nsThreadClassInfo::GetScriptableHelper(nsIXPCScriptable** aResult)

{

  *aResult = nullptr;

  return NS_OK;

}

NS_IMETHODIMP

nsThreadClassInfo::GetContractID(nsACString& aResult)

{

  aResult.SetIsVoid(true);

  return NS_OK;

}

NS_IMETHODIMP

nsThreadClassInfo::GetClassDescription(nsACString& aResult)

{

  aResult.SetIsVoid(true);

  return NS_OK;

}

NS_IMETHODIMP

nsThreadClassInfo::GetClassID(nsCID** aResult)

{

  *aResult = nullptr;

  return NS_OK;

}

NS_IMETHODIMP

nsThreadClassInfo::GetFlags(uint32_t* aResult)

{

  *aResult = THREADSAFE;

  return NS_OK;

}

NS_IMETHODIMP

nsThreadClassInfo::GetClassIDNoAlloc(nsCID* aResult)

{

  return NS_ERROR_NOT_AVAILABLE;

}

//-----------------------------------------------------------------------------

NS_IMPL_ADDREF(nsThread)

NS_IMPL_RELEASE(nsThread)

NS_INTERFACE_MAP_BEGIN(nsThread)

  NS_INTERFACE_MAP_ENTRY(nsIThread)

  NS_INTERFACE_MAP_ENTRY(nsIThreadInternal)

  NS_INTERFACE_MAP_ENTRY(nsIEventTarget)

  NS_INTERFACE_MAP_ENTRY(nsISerialEventTarget)

  NS_INTERFACE_MAP_ENTRY(nsISupportsPriority)

  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIThread)

  if (aIID.Equals(NS_GET_IID(nsIClassInfo))) {

    static nsThreadClassInfo sThreadClassInfo;

    foundInterface = static_cast<nsIClassInfo*>(&sThreadClassInfo);

  } else

NS_INTERFACE_MAP_END

NS_IMPL_CI_INTERFACE_GETTER(nsThread, nsIThread, nsIThreadInternal,

                            nsIEventTarget, nsISupportsPriority)

//-----------------------------------------------------------------------------

class nsThreadStartupEvent final : public Runnable

{

public:

  nsThreadStartupEvent()

    : Runnable("nsThreadStartupEvent")

    , mMon("nsThreadStartupEvent.mMon")

    , mInitialized(false)

  {

  }

  // This method does not return until the thread startup object is in the

  // completion state.

  void Wait()

  {

    ReentrantMonitorAutoEnter mon(mMon);

    while (!mInitialized) {

      mon.Wait();

    }

  }

private:

  ~nsThreadStartupEvent() = default;

  NS_IMETHOD Run() override

  {

    ReentrantMonitorAutoEnter mon(mMon);

    mInitialized = true;

    mon.Notify();

    return NS_OK;

  }

  ReentrantMonitor mMon;

  bool mInitialized;

};

//-----------------------------------------------------------------------------

struct nsThreadShutdownContext

{

  nsThreadShutdownContext(NotNull<nsThread*> aTerminatingThread,

                          NotNull<nsThread*> aJoiningThread,

                          bool      aAwaitingShutdownAck)

    : mTerminatingThread(aTerminatingThread)

    , mJoiningThread(aJoiningThread)

    , mAwaitingShutdownAck(aAwaitingShutdownAck)

    , mIsMainThreadJoining(NS_IsMainThread())

  {

    MOZ_COUNT_CTOR(nsThreadShutdownContext);

  }

  ~nsThreadShutdownContext()

  {

    MOZ_COUNT_DTOR(nsThreadShutdownContext);

  }

  // NB: This will be the last reference.

  NotNull<RefPtr<nsThread>> mTerminatingThread;

  NotNull<nsThread*> MOZ_UNSAFE_REF("Thread manager is holding reference to joining thread")

    mJoiningThread;

  bool mAwaitingShutdownAck;

  bool mIsMainThreadJoining;

};

// This event is responsible for notifying nsThread::Shutdown that it is time

// to call PR_JoinThread. It implements nsICancelableRunnable so that it can

// run on a DOM Worker thread (where all events must implement

// nsICancelableRunnable.)

class nsThreadShutdownAckEvent : public CancelableRunnable

{

public:

  explicit nsThreadShutdownAckEvent(NotNull<nsThreadShutdownContext*> aCtx)

    : CancelableRunnable("nsThreadShutdownAckEvent")

    , mShutdownContext(aCtx)

  {

  }

  NS_IMETHOD Run() override

  {

    mShutdownContext->mTerminatingThread->ShutdownComplete(mShutdownContext);

    return NS_OK;

  }

  nsresult Cancel() override

  {

    return Run();

  }

private:

  virtual ~nsThreadShutdownAckEvent() { }

  NotNull<nsThreadShutdownContext*> mShutdownContext;

};

// This event is responsible for setting mShutdownContext

class nsThreadShutdownEvent : public Runnable

{

public:

  nsThreadShutdownEvent(NotNull<nsThread*> aThr,

                        NotNull<nsThreadShutdownContext*> aCtx)

    : Runnable("nsThreadShutdownEvent")

    , mThread(aThr)

    , mShutdownContext(aCtx)

  {

  }

  NS_IMETHOD Run() override

  {

    mThread->mShutdownContext = mShutdownContext;

    MessageLoop::current()->Quit();

    return NS_OK;

  }

private:

  NotNull<RefPtr<nsThread>> mThread;

  NotNull<nsThreadShutdownContext*> mShutdownContext;

};

//-----------------------------------------------------------------------------

static void

SetThreadAffinity(unsigned int cpu)

{

#ifdef HAVE_SCHED_SETAFFINITY

  cpu_set_t cpus;

  CPU_ZERO(&cpus);

  CPU_SET(cpu, &cpus);

  sched_setaffinity(0, sizeof(cpus), &cpus);

  // Don't assert sched_setaffinity's return value because it intermittently (?)

  // fails with EINVAL on Linux x64 try runs.

#elif defined(XP_MACOSX)

  // OS X does not provide APIs to pin threads to specific processors, but you

  // can tag threads as belonging to the same "affinity set" and the OS will try

  // to run them on the same processor. To run threads on different processors,

  // tag them as belonging to different affinity sets. Tag 0, the default, means

  // "no affinity" so let's pretend each CPU has its own tag `cpu+1`.

  thread_affinity_policy_data_t policy;

  policy.affinity_tag = cpu + 1;

  MOZ_ALWAYS_TRUE(thread_policy_set(mach_thread_self(), THREAD_AFFINITY_POLICY,

                                    &policy.affinity_tag, 1) == KERN_SUCCESS);

#elif defined(XP_WIN)

  MOZ_ALWAYS_TRUE(SetThreadIdealProcessor(GetCurrentThread(), cpu) != (DWORD)-1);

#endif

}

static void

SetupCurrentThreadForChaosMode()

{

  if (!ChaosMode::isActive(ChaosFeature::ThreadScheduling)) {

    return;

  }

#ifdef XP_LINUX

  // PR_SetThreadPriority doesn't really work since priorities >

  // PR_PRIORITY_NORMAL can't be set by non-root users. Instead we'll just use

  // setpriority(2) to set random 'nice values'. In regular Linux this is only

  // a dynamic adjustment so it still doesn't really do what we want, but tools

  // like 'rr' can be more aggressive about honoring these values.

  // Some of these calls may fail due to trying to lower the priority

  // (e.g. something may have already called setpriority() for this thread).

  // This makes it hard to have non-main threads with higher priority than the

  // main thread, but that's hard to fix. Tools like rr can choose to honor the

  // requested values anyway.

  // Use just 4 priorities so there's a reasonable chance of any two threads

  // having equal priority.

  setpriority(PRIO_PROCESS, 0, ChaosMode::randomUint32LessThan(4));

#else

  // We should set the affinity here but NSPR doesn't provide a way to expose it.

  uint32_t priority = ChaosMode::randomUint32LessThan(PR_PRIORITY_LAST + 1);

  PR_SetThreadPriority(PR_GetCurrentThread(), PRThreadPriority(priority));

#endif

  // Force half the threads to CPU 0 so they compete for CPU

  if (ChaosMode::randomUint32LessThan(2)) {

    SetThreadAffinity(0);

  }

}

namespace {

struct ThreadInitData {

  nsThread* thread;

  const nsACString& name;

};

}

/* static */ mozilla::OffTheBooksMutex&

nsThread::ThreadListMutex()

{

  static OffTheBooksMutex sMutex("nsThread::ThreadListMutex");

  return sMutex;

}

/* static */ LinkedList<nsThread>&

nsThread::ThreadList()

{

  static LinkedList<nsThread> sList;

  return sList;

}

/* static */ void

nsThread::ClearThreadList()

{

  OffTheBooksMutexAutoLock mal(ThreadListMutex());

  while (ThreadList().popFirst()) {}

}

/* static */ nsThreadEnumerator

nsThread::Enumerate()

{

  return {};

}

/*static*/ void

nsThread::ThreadFunc(void* aArg)

{

  using mozilla::ipc::BackgroundChild;

  ThreadInitData* initData = static_cast<ThreadInitData*>(aArg);

  nsThread* self = initData->thread;  // strong reference

  self->mThread = PR_GetCurrentThread();

  self->mVirtualThread = GetCurrentVirtualThread();

  self->mEventTarget->SetCurrentThread();

  SetupCurrentThreadForChaosMode();

  if (!initData->name.IsEmpty()) {

    NS_SetCurrentThreadName(initData->name.BeginReading());

  }

  self->InitCommon();

  // Inform the ThreadManager

  nsThreadManager::get().RegisterCurrentThread(*self);

  mozilla::IOInterposer::RegisterCurrentThread();

  // This must come after the call to nsThreadManager::RegisterCurrentThread(),

  // because that call is needed to properly set up this thread as an nsThread,

  // which profiler_register_thread() requires. See bug 1347007.

  if (!initData->name.IsEmpty()) {

    PROFILER_REGISTER_THREAD(initData->name.BeginReading());

  }

  // Wait for and process startup event

  nsCOMPtr<nsIRunnable> event = self->mEvents->GetEvent(true, nullptr);

  MOZ_ASSERT(event);

  initData = nullptr; // clear before unblocking nsThread::Init

  event->Run();  // unblocks nsThread::Init

  event = nullptr;

  {

    // Scope for MessageLoop.

    nsAutoPtr<MessageLoop> loop(

      new MessageLoop(MessageLoop::TYPE_MOZILLA_NONMAINTHREAD, self));

    // Now, process incoming events...

    loop->Run();

    BackgroundChild::CloseForCurrentThread();

    // NB: The main thread does not shut down here!  It shuts down via

    // nsThreadManager::Shutdown.

    // Do NS_ProcessPendingEvents but with special handling to set

    // mEventsAreDoomed atomically with the removal of the last event. The key

    // invariant here is that we will never permit PutEvent to succeed if the

    // event would be left in the queue after our final call to

    // NS_ProcessPendingEvents. We also have to keep processing events as long

    // as we have outstanding mRequestedShutdownContexts.

    while (true) {

      // Check and see if we're waiting on any threads.

      self->WaitForAllAsynchronousShutdowns();

      if (self->mEvents->ShutdownIfNoPendingEvents()) {

        break;

      }

      NS_ProcessPendingEvents(self);

    }

  }

  mozilla::IOInterposer::UnregisterCurrentThread();

  // Inform the threadmanager that this thread is going away

  nsThreadManager::get().UnregisterCurrentThread(*self);

  PROFILER_UNREGISTER_THREAD();

  // Dispatch shutdown ACK

  NotNull<nsThreadShutdownContext*> context =

    WrapNotNull(self->mShutdownContext);

  MOZ_ASSERT(context->mTerminatingThread == self);

  event = do_QueryObject(new nsThreadShutdownAckEvent(context));

  if (context->mIsMainThreadJoining) {

    SystemGroup::Dispatch(TaskCategory::Other, event.forget());

  } else {

    context->mJoiningThread->Dispatch(event, NS_DISPATCH_NORMAL);

  }

  // Release any observer of the thread here.

  self->SetObserver(nullptr);

#ifdef MOZ_TASK_TRACER

  FreeTraceInfo();

#endif

  NS_RELEASE(self);

}

void

nsThread::InitCommon()

{

  mThreadId = uint32_t(PlatformThread::CurrentId());

  {

#if defined(XP_LINUX)

    pthread_attr_t attr;

    pthread_attr_init(&attr);

    pthread_getattr_np(pthread_self(), &attr);

    size_t stackSize;

    pthread_attr_getstack(&attr, &mStackBase, &stackSize);

    // Glibc prior to 2.27 reports the stack size and base including the guard

    // region, so we need to compensate for it to get accurate accounting.

    // Also, this behavior difference isn't guarded by a versioned symbol, so we

    // actually need to check the runtime glibc version, not the version we were

    // compiled against.

    static bool sAdjustForGuardSize = ({

#ifdef __GLIBC__

      unsigned major, minor;

      sscanf(gnu_get_libc_version(), "%u.%u", &major, &minor) < 2 ||

        major < 2 || (major == 2 && minor < 27);

#else

      false;

#endif

    });

    if (sAdjustForGuardSize) {

      size_t guardSize;

      pthread_attr_getguardsize(&attr, &guardSize);

      // Note: This assumes that the stack grows down, as is the case on all of

      // our tier 1 platforms. On platforms where the stack grows up, the

      // mStackBase adjustment is unnecessary, but doesn't cause any harm other

      // than under-counting stack memory usage by one page.

      mStackBase = reinterpret_cast<char*>(mStackBase) + guardSize;

      stackSize -= guardSize;

    }

    mStackSize = stackSize;

    // This is a bit of a hack.

    //

    // We really do want the NOHUGEPAGE flag on our thread stacks, since we

    // don't expect any of them to need anywhere near 2MB of space. But setting

    // it here is too late to have an effect, since the first stack page has

    // already been faulted in existence, and NSPR doesn't give us a way to set

    // it beforehand.

    //

    // What this does get us, however, is a different set of VM flags on our

    // thread stacks compared to normal heap memory. Which makes the Linux

    // kernel report them as separate regions, even when they are adjacent to

    // heap memory. This allows us to accurately track the actual memory

    // consumption of our allocated stacks.

    madvise(mStackBase, stackSize, MADV_NOHUGEPAGE);

    pthread_attr_destroy(&attr);

#elif defined(XP_WIN)

    static const DynamicallyLinkedFunctionPtr<GetCurrentThreadStackLimitsFn>

      sGetStackLimits(L"kernel32.dll", "GetCurrentThreadStackLimits");

    if (sGetStackLimits) {

      ULONG_PTR stackBottom, stackTop;

      sGetStackLimits(&stackBottom, &stackTop);

      mStackBase = reinterpret_cast<void*>(stackBottom);

      mStackSize = stackTop - stackBottom;

    }

#endif

  }

  OffTheBooksMutexAutoLock mal(ThreadListMutex());

  ThreadList().insertBack(this);

}

//-----------------------------------------------------------------------------

#ifdef MOZ_CANARY

int sCanaryOutputFD = -1;

#endif

nsThread::nsThread(NotNull<SynchronizedEventQueue*> aQueue,

                   MainThreadFlag aMainThread,

                   uint32_t aStackSize)

  : mEvents(aQueue.get())

  , mEventTarget(new ThreadEventTarget(mEvents.get(), aMainThread == MAIN_THREAD))

  , mShutdownContext(nullptr)

  , mScriptObserver(nullptr)

  , mThread(nullptr)

  , mStackSize(aStackSize)

  , mNestedEventLoopDepth(0)

  , mCurrentEventLoopDepth(-1)

  , mShutdownRequired(false)

  , mPriority(PRIORITY_NORMAL)

  , mIsMainThread(uint8_t(aMainThread))

  , mCanInvokeJS(false)

  , mCurrentEvent(nullptr)

  , mCurrentEventStart(TimeStamp::Now())

  , mCurrentPerformanceCounter(nullptr)

{

}

nsThread::~nsThread()

{

  NS_ASSERTION(mRequestedShutdownContexts.IsEmpty(),

               "shouldn't be waiting on other threads to shutdown");

  // We shouldn't need to lock before checking isInList at this point. We're

  // destroying the last reference to this object, so there's no way for anyone

  // else to remove it in the middle of our check. And the not-in-list state is

  // determined the element's next and previous members pointing to itself, so a

  // non-atomic update to an adjacent member won't affect the outcome either.

  if (isInList()) {

    OffTheBooksMutexAutoLock mal(ThreadListMutex());

    removeFrom(ThreadList());

  }

#ifdef DEBUG

  // We deliberately leak these so they can be tracked by the leak checker.

  // If you're having nsThreadShutdownContext leaks, you can set:

  //   XPCOM_MEM_LOG_CLASSES=nsThreadShutdownContext

  // during a test run and that will at least tell you what thread is

  // requesting shutdown on another, which can be helpful for diagnosing

  // the leak.

  for (size_t i = 0; i < mRequestedShutdownContexts.Length(); ++i) {

    Unused << mRequestedShutdownContexts[i].forget();

  }

#endif

}

nsresult

nsThread::Init(const nsACString& aName)

{

  // spawn thread and wait until it is fully setup

  RefPtr<nsThreadStartupEvent> startup = new nsThreadStartupEvent();

  NS_ADDREF_THIS();

  mShutdownRequired = true;

  ThreadInitData initData = { this, aName };

  // ThreadFunc is responsible for setting mThread

  if (!PR_CreateThread(PR_USER_THREAD, ThreadFunc, &initData,

                       PR_PRIORITY_NORMAL, PR_GLOBAL_THREAD,

                       PR_JOINABLE_THREAD, mStackSize)) {

    NS_RELEASE_THIS();

    return NS_ERROR_OUT_OF_MEMORY;

  }

  // ThreadFunc will wait for this event to be run before it tries to access

  // mThread.  By delaying insertion of this event into the queue, we ensure

  // that mThread is set properly.

  {

    mEvents->PutEvent(do_AddRef(startup), EventPriority::Normal); // retain a reference

  }

  // Wait for thread to call ThreadManager::SetupCurrentThread, which completes

  // initialization of ThreadFunc.

  startup->Wait();

  return NS_OK;

}

nsresult

nsThread::InitCurrentThread()

{

  mThread = PR_GetCurrentThread();

  mVirtualThread = GetCurrentVirtualThread();

  SetupCurrentThreadForChaosMode();

  InitCommon();

  nsThreadManager::get().RegisterCurrentThread(*this);

  return NS_OK;

}

//-----------------------------------------------------------------------------

// nsIEventTarget

NS_IMETHODIMP

nsThread::DispatchFromScript(nsIRunnable* aEvent, uint32_t aFlags)

{

  nsCOMPtr<nsIRunnable> event(aEvent);

  return mEventTarget->Dispatch(event.forget(), aFlags);

}

NS_IMETHODIMP

nsThread::Dispatch(already_AddRefed<nsIRunnable> aEvent, uint32_t aFlags)

{

  LOG(("THRD(%p) Dispatch [%p %x]\n", this, /* XXX aEvent */nullptr, aFlags));

  return mEventTarget->Dispatch(std::move(aEvent), aFlags);

}

NS_IMETHODIMP

nsThread::DelayedDispatch(already_AddRefed<nsIRunnable> aEvent, uint32_t aDelayMs)

{

  return mEventTarget->DelayedDispatch(std::move(aEvent), aDelayMs);

}

NS_IMETHODIMP

nsThread::IsOnCurrentThread(bool* aResult)

{

  return mEventTarget->IsOnCurrentThread(aResult);

}

NS_IMETHODIMP_(bool)

nsThread::IsOnCurrentThreadInfallible()

{

  // Rely on mVirtualThread being correct.

  MOZ_CRASH("IsOnCurrentThreadInfallible should never be called on nsIThread");

}

//-----------------------------------------------------------------------------

// nsIThread

NS_IMETHODIMP

nsThread::GetPRThread(PRThread** aResult)

{

  *aResult = mThread;

  return NS_OK;

}

NS_IMETHODIMP

nsThread::GetCanInvokeJS(bool* aResult)

{

  *aResult = mCanInvokeJS;

  return NS_OK;

}

NS_IMETHODIMP

nsThread::SetCanInvokeJS(bool aCanInvokeJS)

{

  mCanInvokeJS = aCanInvokeJS;

  return NS_OK;

}

NS_IMETHODIMP

nsThread::AsyncShutdown()

{

  LOG(("THRD(%p) async shutdown\n", this));

  // XXX If we make this warn, then we hit that warning at xpcom shutdown while

  //     shutting down a thread in a thread pool.  That happens b/c the thread

  //     in the thread pool is already shutdown by the thread manager.

  if (!mThread) {

    return NS_OK;

  }

  return !!ShutdownInternal(/* aSync = */ false) ? NS_OK : NS_ERROR_UNEXPECTED;

}

nsThreadShutdownContext*

nsThread::ShutdownInternal(bool aSync)

{

  MOZ_ASSERT(mThread);

  MOZ_ASSERT(mThread != PR_GetCurrentThread());

  if (NS_WARN_IF(mThread == PR_GetCurrentThread())) {

    return nullptr;

  }

  // Prevent multiple calls to this method

  if (!mShutdownRequired.compareExchange(true, false)) {

    return nullptr;

  }

  {

    OffTheBooksMutexAutoLock mal(ThreadListMutex());

    if (isInList()) {

      removeFrom(ThreadList());

    }

  }

  NotNull<nsThread*> currentThread =

    WrapNotNull(nsThreadManager::get().GetCurrentThread());

  nsAutoPtr<nsThreadShutdownContext>& context =

    *currentThread->mRequestedShutdownContexts.AppendElement();

  context = new nsThreadShutdownContext(WrapNotNull(this), currentThread, aSync);

  // Set mShutdownContext and wake up the thread in case it is waiting for

  // events to process.

  nsCOMPtr<nsIRunnable> event =

    new nsThreadShutdownEvent(WrapNotNull(this), WrapNotNull(context.get()));

  // XXXroc What if posting the event fails due to OOM?

  mEvents->PutEvent(event.forget(), EventPriority::Normal);

  // We could still end up with other events being added after the shutdown

  // task, but that's okay because we process pending events in ThreadFunc

  // after setting mShutdownContext just before exiting.

  return context;

}

void

nsThread::ShutdownComplete(NotNull<nsThreadShutdownContext*> aContext)

{

  MOZ_ASSERT(mThread);

  MOZ_ASSERT(aContext->mTerminatingThread == this);

  {

    OffTheBooksMutexAutoLock mal(ThreadListMutex());

    if (isInList()) {

      removeFrom(ThreadList());

    }

  }

  if (aContext->mAwaitingShutdownAck) {

    // We're in a synchronous shutdown, so tell whatever is up the stack that

    // we're done and unwind the stack so it can call us again.

    aContext->mAwaitingShutdownAck = false;

    return;

  }

  // Now, it should be safe to join without fear of dead-locking.

  PR_JoinThread(mThread);

  mThread = nullptr;

#ifdef DEBUG

  nsCOMPtr<nsIThreadObserver> obs = mEvents->GetObserver();

  MOZ_ASSERT(!obs, "Should have been cleared at shutdown!");

#endif

  // Delete aContext.

  MOZ_ALWAYS_TRUE(

    aContext->mJoiningThread->mRequestedShutdownContexts.RemoveElement(aContext));

}

void

nsThread::WaitForAllAsynchronousShutdowns()

{

  // This is the motivating example for why SpinEventLoop has the template

  // parameter we are providing here.

  SpinEventLoopUntil<ProcessFailureBehavior::IgnoreAndContinue>([&]() {

      return mRequestedShutdownContexts.IsEmpty();

    }, this);

}

NS_IMETHODIMP

nsThread::Shutdown()

{

  LOG(("THRD(%p) sync shutdown\n", this));

  // XXX If we make this warn, then we hit that warning at xpcom shutdown while

  //     shutting down a thread in a thread pool.  That happens b/c the thread

  //     in the thread pool is already shutdown by the thread manager.

  if (!mThread) {

    return NS_OK;

  }

  nsThreadShutdownContext* maybeContext = ShutdownInternal(/* aSync = */ true);

  NS_ENSURE_TRUE(maybeContext, NS_ERROR_UNEXPECTED);

  NotNull<nsThreadShutdownContext*> context = WrapNotNull(maybeContext);

  // Process events on the current thread until we receive a shutdown ACK.

  // Allows waiting; ensure no locks are held that would deadlock us!

  SpinEventLoopUntil([&, context]() {

      return !context->mAwaitingShutdownAck;

    }, context->mJoiningThread);

  ShutdownComplete(context);

  return NS_OK;

}

NS_IMETHODIMP

nsThread::HasPendingEvents(bool* aResult)

{

  if (NS_WARN_IF(PR_GetCurrentThread() != mThread)) {

    return NS_ERROR_NOT_SAME_THREAD;

  }

  *aResult = mEvents->HasPendingEvent();

  return NS_OK;

}

NS_IMETHODIMP

nsThread::IdleDispatch(already_AddRefed<nsIRunnable> aEvent)

{

  nsCOMPtr<nsIRunnable> event = aEvent;

  if (NS_WARN_IF(!event)) {

    return NS_ERROR_INVALID_ARG;

  }

  if (!mEvents->PutEvent(event.forget(), EventPriority::Idle)) {

    NS_WARNING("An idle event was posted to a thread that will never run it (rejected)");

    return NS_ERROR_UNEXPECTED;

  }

  return NS_OK;

}

#ifdef MOZ_CANARY

void canary_alarm_handler(int signum);

class Canary

{

  //XXX ToDo: support nested loops

public:

  Canary()

  {

    if (sCanaryOutputFD > 0 && EventLatencyIsImportant()) {

      signal(SIGALRM, canary_alarm_handler);

      ualarm(15000, 0);

    }

  }

  ~Canary()

  {

    if (sCanaryOutputFD != 0 && EventLatencyIsImportant()) {

      ualarm(0, 0);

    }

  }

  static bool EventLatencyIsImportant()

  {

    return NS_IsMainThread() && XRE_IsParentProcess();

  }

};

void canary_alarm_handler(int signum)

{

  void* array[30];

  const char msg[29] = "event took too long to run:\n";

  // use write to be safe in the signal handler

  write(sCanaryOutputFD, msg, sizeof(msg));

  backtrace_symbols_fd(array, backtrace(array, 30), sCanaryOutputFD);

}

#endif

#define NOTIFY_EVENT_OBSERVERS(observers_, func_, params_)                     \

  do {                                                                         \

    if (!observers_.IsEmpty()) {                                               \

      nsTObserverArray<nsCOMPtr<nsIThreadObserver>>::ForwardIterator           \

        iter_(observers_);                                                     \

      nsCOMPtr<nsIThreadObserver> obs_;                                        \

      while (iter_.HasMore()) {                                                \

        obs_ = iter_.GetNext();                                                \

        obs_ -> func_ params_ ;                                                \

      }                                                                        \

    }                                                                          \

  } while(0)

#ifdef MOZ_COLLECTING_RUNNABLE_TELEMETRY

static bool

GetLabeledRunnableName(nsIRunnable* aEvent,

                       nsACString& aName,

                       EventPriority aPriority)

{

  bool labeled = false;

  if (RefPtr<SchedulerGroup::Runnable> groupRunnable = do_QueryObject(aEvent)) {

    labeled = true;

    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(groupRunnable->GetName(aName)));

  } else if (nsCOMPtr<nsINamed> named = do_QueryInterface(aEvent)) {

    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(named->GetName(aName)));

  } else {

    aName.AssignLiteral("non-nsINamed runnable");

  }

  if (aName.IsEmpty()) {

    aName.AssignLiteral("anonymous runnable");

  }

  if (!labeled && aPriority > EventPriority::Input) {

    aName.AppendLiteral("(unlabeled)");

  }

  return labeled;

}

#endif

mozilla::PerformanceCounter*

nsThread::GetPerformanceCounter(nsIRunnable* aEvent)

{

  RefPtr<SchedulerGroup::Runnable> docRunnable = do_QueryObject(aEvent);

  if (docRunnable) {

    mozilla::dom::DocGroup* docGroup = docRunnable->DocGroup();

    if (docGroup) {

      return docGroup->GetPerformanceCounter();

    }

  }

  return nullptr;

}

size_t

nsThread::ShallowSizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const

{

  size_t n = 0;