xpcom/threads/nsThread.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "nsThread.h"
   8
   9 #include "base/message_loop.h"
  10
  11 // Chromium's logging can sometimes leak through...
  12 #ifdef LOG
  13 #undef LOG
  14 #endif
  15
  16 #include "mozilla/ReentrantMonitor.h"
  17 #include "nsMemoryPressure.h"
  18 #include "nsThreadManager.h"
  19 #include "nsIClassInfoImpl.h"
  20 #include "nsIProgrammingLanguage.h"
  21 #include "nsAutoPtr.h"
  22 #include "nsCOMPtr.h"
  23 #include "pratom.h"
  24 #include "prlog.h"
  25 #include "nsIObserverService.h"
  26 #include "mozilla/HangMonitor.h"
  27 #include "mozilla/IOInterposer.h"
  28 #include "mozilla/ipc/MessageChannel.h"
  29 #include "mozilla/Services.h"
  30 #include "nsXPCOMPrivate.h"
  31 #include "mozilla/ChaosMode.h"
  32
  33 #ifdef MOZ_CRASHREPORTER
  34 #include "nsServiceManagerUtils.h"
  35 #include "nsICrashReporter.h"
  36 #endif
  37
  38 #ifdef XP_LINUX
  39 #include <sys/time.h>
  40 #include <sys/resource.h>
  41 #include <sched.h>
  42 #endif
  43
  44 #define HAVE_UALARM _BSD_SOURCE || (_XOPEN_SOURCE >= 500 ||                 \
  45                       _XOPEN_SOURCE && _XOPEN_SOURCE_EXTENDED) &&           \
  46                       !(_POSIX_C_SOURCE >= 200809L || _XOPEN_SOURCE >= 700)
  47
  48 #if defined(XP_LINUX) && !defined(ANDROID) && defined(_GNU_SOURCE)
  49 #define HAVE_SCHED_SETAFFINITY
  50 #endif
  51
  52 #ifdef MOZ_CANARY
  53 # include <unistd.h>
  54 # include <execinfo.h>
  55 # include <signal.h>
  56 # include <fcntl.h>
  57 # include "nsXULAppAPI.h"
  58 #endif
  59
  60 #if defined(NS_FUNCTION_TIMER) && defined(_MSC_VER)
  61 #include "nsTimerImpl.h"
  62 #include "nsStackWalk.h"
  63 #endif
  64 #ifdef NS_FUNCTION_TIMER
  65 #include "nsCRT.h"
  66 #endif
  67
  68 #ifdef MOZ_TASK_TRACER
  69 #include "GeckoTaskTracer.h"
  70 using namespace mozilla::tasktracer;
  71 #endif
  72
  73 using namespace mozilla;
  74
  75 #ifdef PR_LOGGING
  76 static PRLogModuleInfo*
  77 GetThreadLog()
  78 {
  79   static PRLogModuleInfo* sLog;
  80   if (!sLog) {
  81     sLog = PR_NewLogModule("nsThread");
  82   }
  83   return sLog;
  84 }
  85 #endif
  86 #ifdef LOG
  87 #undef LOG
  88 #endif
  89 #define LOG(args) PR_LOG(GetThreadLog(), PR_LOG_DEBUG, args)
  90
  91 NS_DECL_CI_INTERFACE_GETTER(nsThread)
  92
  93 nsIThreadObserver* nsThread::sMainThreadObserver = nullptr;
  94
  95 //-----------------------------------------------------------------------------
  96 // Because we do not have our own nsIFactory, we have to implement nsIClassInfo
  97 // somewhat manually.
  98
  99 class nsThreadClassInfo : public nsIClassInfo
 100 {
 101 public:
 102   NS_DECL_ISUPPORTS_INHERITED  // no mRefCnt
 103   NS_DECL_NSICLASSINFO
 104
 105   nsThreadClassInfo()
 106   {
 107   }
 108 };
 109
 110 NS_IMETHODIMP_(MozExternalRefCountType)
 111 nsThreadClassInfo::AddRef()
 112 {
 113   return 2;
 114 }
 115 NS_IMETHODIMP_(MozExternalRefCountType)
 116 nsThreadClassInfo::Release()
 117 {
 118   return 1;
 119 }
 120 NS_IMPL_QUERY_INTERFACE(nsThreadClassInfo, nsIClassInfo)
 121
 122 NS_IMETHODIMP
 123 nsThreadClassInfo::GetInterfaces(uint32_t* aCount, nsIID*** aArray)
 124 {
 125   return NS_CI_INTERFACE_GETTER_NAME(nsThread)(aCount, aArray);
 126 }
 127
 128 NS_IMETHODIMP
 129 nsThreadClassInfo::GetHelperForLanguage(uint32_t aLang, nsISupports** aResult)
 130 {
 131   *aResult = nullptr;
 132   return NS_OK;
 133 }
 134
 135 NS_IMETHODIMP
 136 nsThreadClassInfo::GetContractID(char** aResult)
 137 {
 138   *aResult = nullptr;
 139   return NS_OK;
 140 }
 141
 142 NS_IMETHODIMP
 143 nsThreadClassInfo::GetClassDescription(char** aResult)
 144 {
 145   *aResult = nullptr;
 146   return NS_OK;
 147 }
 148
 149 NS_IMETHODIMP
 150 nsThreadClassInfo::GetClassID(nsCID** aResult)
 151 {
 152   *aResult = nullptr;
 153   return NS_OK;
 154 }
 155
 156 NS_IMETHODIMP
 157 nsThreadClassInfo::GetImplementationLanguage(uint32_t* aResult)
 158 {
 159   *aResult = nsIProgrammingLanguage::CPLUSPLUS;
 160   return NS_OK;
 161 }
 162
 163 NS_IMETHODIMP
 164 nsThreadClassInfo::GetFlags(uint32_t* aResult)
 165 {
 166   *aResult = THREADSAFE;
 167   return NS_OK;
 168 }
 169
 170 NS_IMETHODIMP
 171 nsThreadClassInfo::GetClassIDNoAlloc(nsCID* aResult)
 172 {
 173   return NS_ERROR_NOT_AVAILABLE;
 174 }
 175
 176 //-----------------------------------------------------------------------------
 177
 178 NS_IMPL_ADDREF(nsThread)
 179 NS_IMPL_RELEASE(nsThread)
 180 NS_INTERFACE_MAP_BEGIN(nsThread)
 181   NS_INTERFACE_MAP_ENTRY(nsIThread)
 182   NS_INTERFACE_MAP_ENTRY(nsIThreadInternal)
 183   NS_INTERFACE_MAP_ENTRY(nsIEventTarget)
 184   NS_INTERFACE_MAP_ENTRY(nsISupportsPriority)
 185   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIThread)
 186   if (aIID.Equals(NS_GET_IID(nsIClassInfo))) {
 187     static nsThreadClassInfo sThreadClassInfo;
 188     foundInterface = static_cast<nsIClassInfo*>(&sThreadClassInfo);
 189   } else
 190 NS_INTERFACE_MAP_END
 191 NS_IMPL_CI_INTERFACE_GETTER(nsThread, nsIThread, nsIThreadInternal,
 192                             nsIEventTarget, nsISupportsPriority)
 193
 194 //-----------------------------------------------------------------------------
 195
 196 class nsThreadStartupEvent : public nsRunnable
 197 {
 198 public:
 199   nsThreadStartupEvent()
 200     : mMon("nsThreadStartupEvent.mMon")
 201     , mInitialized(false)
 202   {
 203   }
 204
 205   // This method does not return until the thread startup object is in the
 206   // completion state.
 207   void Wait()
 208   {
 209     if (mInitialized) {
 210       // Maybe avoid locking...
 211       return;
 212     }
 213
 214     ReentrantMonitorAutoEnter mon(mMon);
 215     while (!mInitialized) {
 216       mon.Wait();
 217     }
 218   }
 219
 220   // This method needs to be public to support older compilers (xlC_r on AIX).
 221   // It should be called directly as this class type is reference counted.
 222   virtual ~nsThreadStartupEvent() {}
 223
 224 private:
 225   NS_IMETHOD Run()
 226   {
 227     ReentrantMonitorAutoEnter mon(mMon);
 228     mInitialized = true;
 229     mon.Notify();
 230     return NS_OK;
 231   }
 232
 233   ReentrantMonitor mMon;
 234   bool mInitialized;
 235 };
 236
 237 //-----------------------------------------------------------------------------
 238
 239 struct nsThreadShutdownContext
 240 {
 241   nsThread* joiningThread;
 242   bool      shutdownAck;
 243 };
 244
 245 // This event is responsible for notifying nsThread::Shutdown that it is time
 246 // to call PR_JoinThread.
 247 class nsThreadShutdownAckEvent : public nsRunnable
 248 {
 249 public:
 250   explicit nsThreadShutdownAckEvent(nsThreadShutdownContext* aCtx)
 251     : mShutdownContext(aCtx)
 252   {
 253   }
 254   NS_IMETHOD Run()
 255   {
 256     mShutdownContext->shutdownAck = true;
 257     return NS_OK;
 258   }
 259 private:
 260   nsThreadShutdownContext* mShutdownContext;
 261 };
 262
 263 // This event is responsible for setting mShutdownContext
 264 class nsThreadShutdownEvent : public nsRunnable
 265 {
 266 public:
 267   nsThreadShutdownEvent(nsThread* aThr, nsThreadShutdownContext* aCtx)
 268     : mThread(aThr)
 269     , mShutdownContext(aCtx)
 270   {
 271   }
 272   NS_IMETHOD Run()
 273   {
 274     mThread->mShutdownContext = mShutdownContext;
 275     MessageLoop::current()->Quit();
 276     return NS_OK;
 277   }
 278 private:
 279   nsRefPtr<nsThread>       mThread;
 280   nsThreadShutdownContext* mShutdownContext;
 281 };
 282
 283 //-----------------------------------------------------------------------------
 284
 285 static void
 286 SetupCurrentThreadForChaosMode()
 287 {
 288   if (!ChaosMode::isActive()) {
 289     return;
 290   }
 291
 292 #ifdef XP_LINUX
 293   // PR_SetThreadPriority doesn't really work since priorities >
 294   // PR_PRIORITY_NORMAL can't be set by non-root users. Instead we'll just use
 295   // setpriority(2) to set random 'nice values'. In regular Linux this is only
 296   // a dynamic adjustment so it still doesn't really do what we want, but tools
 297   // like 'rr' can be more aggressive about honoring these values.
 298   // Some of these calls may fail due to trying to lower the priority
 299   // (e.g. something may have already called setpriority() for this thread).
 300   // This makes it hard to have non-main threads with higher priority than the
 301   // main thread, but that's hard to fix. Tools like rr can choose to honor the
 302   // requested values anyway.
 303   // Use just 4 priorities so there's a reasonable chance of any two threads
 304   // having equal priority.
 305   setpriority(PRIO_PROCESS, 0, ChaosMode::randomUint32LessThan(4));
 306 #else
 307   // We should set the affinity here but NSPR doesn't provide a way to expose it.
 308   uint32_t priority = ChaosMode::randomUint32LessThan(PR_PRIORITY_LAST + 1);
 309   PR_SetThreadPriority(PR_GetCurrentThread(), PRThreadPriority(priority));
 310 #endif
 311
 312 #ifdef HAVE_SCHED_SETAFFINITY
 313   // Force half the threads to CPU 0 so they compete for CPU
 314   if (ChaosMode::randomUint32LessThan(2)) {
 315     cpu_set_t cpus;
 316     CPU_ZERO(&cpus);
 317     CPU_SET(0, &cpus);
 318     sched_setaffinity(0, sizeof(cpus), &cpus);
 319   }
 320 #endif
 321 }
 322
 323 /*static*/ void
 324 nsThread::ThreadFunc(void* aArg)
 325 {
 326   nsThread* self = static_cast<nsThread*>(aArg);  // strong reference
 327   self->mThread = PR_GetCurrentThread();
 328   SetupCurrentThreadForChaosMode();
 329
 330   // Inform the ThreadManager
 331   nsThreadManager::get()->RegisterCurrentThread(self);
 332
 333   mozilla::IOInterposer::RegisterCurrentThread();
 334
 335   // Wait for and process startup event
 336   nsCOMPtr<nsIRunnable> event;
 337   if (!self->GetEvent(true, getter_AddRefs(event))) {
 338     NS_WARNING("failed waiting for thread startup event");
 339     return;
 340   }
 341   event->Run();  // unblocks nsThread::Init
 342   event = nullptr;
 343
 344   {
 345     // Scope for MessageLoop.
 346     nsAutoPtr<MessageLoop> loop(
 347       new MessageLoop(MessageLoop::TYPE_MOZILLA_NONMAINTHREAD));
 348
 349     // Now, process incoming events...
 350     loop->Run();
 351
 352     // Do NS_ProcessPendingEvents but with special handling to set
 353     // mEventsAreDoomed atomically with the removal of the last event. The key
 354     // invariant here is that we will never permit PutEvent to succeed if the
 355     // event would be left in the queue after our final call to
 356     // NS_ProcessPendingEvents.
 357     while (true) {
 358       {
 359         MutexAutoLock lock(self->mLock);
 360         if (!self->mEvents->HasPendingEvent()) {
 361           // No events in the queue, so we will stop now. Don't let any more
 362           // events be added, since they won't be processed. It is critical
 363           // that no PutEvent can occur between testing that the event queue is
 364           // empty and setting mEventsAreDoomed!
 365           self->mEventsAreDoomed = true;
 366           break;
 367         }
 368       }
 369       NS_ProcessPendingEvents(self);
 370     }
 371   }
 372
 373   mozilla::IOInterposer::UnregisterCurrentThread();
 374
 375   // Inform the threadmanager that this thread is going away
 376   nsThreadManager::get()->UnregisterCurrentThread(self);
 377
 378   // Dispatch shutdown ACK
 379   event = new nsThreadShutdownAckEvent(self->mShutdownContext);
 380   self->mShutdownContext->joiningThread->Dispatch(event, NS_DISPATCH_NORMAL);
 381
 382   // Release any observer of the thread here.
 383   self->SetObserver(nullptr);
 384
 385 #ifdef MOZ_TASK_TRACER
 386   FreeTraceInfo();
 387 #endif
 388
 389   NS_RELEASE(self);
 390 }
 391
 392 //-----------------------------------------------------------------------------
 393
 394 #ifdef MOZ_CRASHREPORTER
 395 // Tell the crash reporter to save a memory report if our heuristics determine
 396 // that an OOM failure is likely to occur soon.
 397 static bool SaveMemoryReportNearOOM()
 398 {
 399   bool needMemoryReport = false;
 400
 401 #ifdef XP_WIN // XXX implement on other platforms as needed
 402   const size_t LOWMEM_THRESHOLD_VIRTUAL = 200 * 1024 * 1024;
 403   MEMORYSTATUSEX statex;
 404   statex.dwLength = sizeof(statex);
 405   if (GlobalMemoryStatusEx(&statex)) {
 406     if (statex.ullAvailVirtual < LOWMEM_THRESHOLD_VIRTUAL) {
 407       needMemoryReport = true;
 408     }
 409   }
 410 #endif
 411
 412   if (needMemoryReport) {
 413     nsCOMPtr<nsICrashReporter> cr =
 414       do_GetService("@mozilla.org/toolkit/crash-reporter;1");
 415     cr->SaveMemoryReport();
 416   }
 417
 418   return needMemoryReport;
 419 }
 420 #endif
 421
 422 #ifdef MOZ_CANARY
 423 int sCanaryOutputFD = -1;
 424 #endif
 425
 426 nsThread::nsThread(MainThreadFlag aMainThread, uint32_t aStackSize)
 427   : mLock("nsThread.mLock")
 428   , mEvents(&mEventsRoot)
 429   , mPriority(PRIORITY_NORMAL)
 430   , mThread(nullptr)
 431   , mRunningEvent(0)
 432   , mStackSize(aStackSize)
 433   , mShutdownContext(nullptr)
 434   , mShutdownRequired(false)
 435   , mEventsAreDoomed(false)
 436   , mIsMainThread(aMainThread)
 437 {
 438 }
 439
 440 nsThread::~nsThread()
 441 {
 442 }
 443
 444 nsresult
 445 nsThread::Init()
 446 {
 447   // spawn thread and wait until it is fully setup
 448   nsRefPtr<nsThreadStartupEvent> startup = new nsThreadStartupEvent();
 449
 450   NS_ADDREF_THIS();
 451
 452   mShutdownRequired = true;
 453
 454   // ThreadFunc is responsible for setting mThread
 455   PRThread* thr = PR_CreateThread(PR_USER_THREAD, ThreadFunc, this,
 456                                   PR_PRIORITY_NORMAL, PR_GLOBAL_THREAD,
 457                                   PR_JOINABLE_THREAD, mStackSize);
 458   if (!thr) {
 459     NS_RELEASE_THIS();
 460     return NS_ERROR_OUT_OF_MEMORY;
 461   }
 462
 463   // ThreadFunc will wait for this event to be run before it tries to access
 464   // mThread.  By delaying insertion of this event into the queue, we ensure
 465   // that mThread is set properly.
 466   {
 467     MutexAutoLock lock(mLock);
 468     mEventsRoot.PutEvent(startup);
 469   }
 470
 471   // Wait for thread to call ThreadManager::SetupCurrentThread, which completes
 472   // initialization of ThreadFunc.
 473   startup->Wait();
 474   return NS_OK;
 475 }
 476
 477 nsresult
 478 nsThread::InitCurrentThread()
 479 {
 480   mThread = PR_GetCurrentThread();
 481   SetupCurrentThreadForChaosMode();
 482
 483   nsThreadManager::get()->RegisterCurrentThread(this);
 484   return NS_OK;
 485 }
 486
 487 nsresult
 488 nsThread::PutEvent(nsIRunnable* aEvent, nsNestedEventTarget* aTarget)
 489 {
 490   {
 491     MutexAutoLock lock(mLock);
 492     nsChainedEventQueue* queue = aTarget ? aTarget->mQueue : &mEventsRoot;
 493     if (!queue || (queue == &mEventsRoot && mEventsAreDoomed)) {
 494       NS_WARNING("An event was posted to a thread that will never run it (rejected)");
 495       return NS_ERROR_UNEXPECTED;
 496     }
 497     queue->PutEvent(aEvent);
 498   }
 499
 500   nsCOMPtr<nsIThreadObserver> obs = GetObserver();
 501   if (obs) {
 502     obs->OnDispatchedEvent(this);
 503   }
 504
 505   return NS_OK;
 506 }
 507
 508 nsresult
 509 nsThread::DispatchInternal(nsIRunnable* aEvent, uint32_t aFlags,
 510                            nsNestedEventTarget* aTarget)
 511 {
 512   if (NS_WARN_IF(!aEvent)) {
 513     return NS_ERROR_INVALID_ARG;
 514   }
 515
 516   if (gXPCOMThreadsShutDown && MAIN_THREAD != mIsMainThread && !aTarget) {
 517     return NS_ERROR_ILLEGAL_DURING_SHUTDOWN;
 518   }
 519
 520 #ifdef MOZ_TASK_TRACER
 521   nsRefPtr<nsIRunnable> tracedRunnable = CreateTracedRunnable(aEvent);
 522   aEvent = tracedRunnable;
 523 #endif
 524
 525   if (aFlags & DISPATCH_SYNC) {
 526     nsThread* thread = nsThreadManager::get()->GetCurrentThread();
 527     if (NS_WARN_IF(!thread)) {
 528       return NS_ERROR_NOT_AVAILABLE;
 529     }
 530
 531     // XXX we should be able to do something better here... we should
 532     //     be able to monitor the slot occupied by this event and use
 533     //     that to tell us when the event has been processed.
 534
 535     nsRefPtr<nsThreadSyncDispatch> wrapper =
 536       new nsThreadSyncDispatch(thread, aEvent);
 537     if (!wrapper) {
 538       return NS_ERROR_OUT_OF_MEMORY;
 539     }
 540     nsresult rv = PutEvent(wrapper, aTarget);
 541     // Don't wait for the event to finish if we didn't dispatch it...
 542     if (NS_FAILED(rv)) {
 543       return rv;
 544     }
 545
 546     // Allows waiting; ensure no locks are held that would deadlock us!
 547     while (wrapper->IsPending()) {
 548       NS_ProcessNextEvent(thread, true);
 549     }
 550     return wrapper->Result();
 551   }
 552
 553   NS_ASSERTION(aFlags == NS_DISPATCH_NORMAL, "unexpected dispatch flags");
 554   return PutEvent(aEvent, aTarget);
 555 }
 556
 557 //-----------------------------------------------------------------------------
 558 // nsIEventTarget
 559
 560 NS_IMETHODIMP
 561 nsThread::Dispatch(nsIRunnable* aEvent, uint32_t aFlags)
 562 {
 563   LOG(("THRD(%p) Dispatch [%p %x]\n", this, aEvent, aFlags));
 564
 565   return DispatchInternal(aEvent, aFlags, nullptr);
 566 }
 567
 568 NS_IMETHODIMP
 569 nsThread::IsOnCurrentThread(bool* aResult)
 570 {
 571   *aResult = (PR_GetCurrentThread() == mThread);
 572   return NS_OK;
 573 }
 574
 575 //-----------------------------------------------------------------------------
 576 // nsIThread
 577
 578 NS_IMETHODIMP
 579 nsThread::GetPRThread(PRThread** aResult)
 580 {
 581   *aResult = mThread;
 582   return NS_OK;
 583 }
 584
 585 NS_IMETHODIMP
 586 nsThread::Shutdown()
 587 {
 588   LOG(("THRD(%p) shutdown\n", this));
 589
 590   // XXX If we make this warn, then we hit that warning at xpcom shutdown while
 591   //     shutting down a thread in a thread pool.  That happens b/c the thread
 592   //     in the thread pool is already shutdown by the thread manager.
 593   if (!mThread) {
 594     return NS_OK;
 595   }
 596
 597   if (NS_WARN_IF(mThread == PR_GetCurrentThread())) {
 598     return NS_ERROR_UNEXPECTED;
 599   }
 600
 601   // Prevent multiple calls to this method
 602   {
 603     MutexAutoLock lock(mLock);
 604     if (!mShutdownRequired) {
 605       return NS_ERROR_UNEXPECTED;
 606     }
 607     mShutdownRequired = false;
 608   }
 609
 610   nsThreadShutdownContext context;
 611   context.joiningThread = nsThreadManager::get()->GetCurrentThread();
 612   context.shutdownAck = false;
 613
 614   // Set mShutdownContext and wake up the thread in case it is waiting for
 615   // events to process.
 616   nsCOMPtr<nsIRunnable> event = new nsThreadShutdownEvent(this, &context);
 617   if (!event) {
 618     return NS_ERROR_OUT_OF_MEMORY;
 619   }
 620   // XXXroc What if posting the event fails due to OOM?
 621   PutEvent(event, nullptr);
 622
 623   // We could still end up with other events being added after the shutdown
 624   // task, but that's okay because we process pending events in ThreadFunc
 625   // after setting mShutdownContext just before exiting.
 626
 627   // Process events on the current thread until we receive a shutdown ACK.
 628   // Allows waiting; ensure no locks are held that would deadlock us!
 629   while (!context.shutdownAck) {
 630     NS_ProcessNextEvent(context.joiningThread, true);
 631   }
 632
 633   // Now, it should be safe to join without fear of dead-locking.
 634
 635   PR_JoinThread(mThread);
 636   mThread = nullptr;
 637
 638   // We hold strong references to our event observers, and once the thread is
 639   // shut down the observers can't easily unregister themselves. Do it here
 640   // to avoid leaking.
 641   ClearObservers();
 642
 643 #ifdef DEBUG
 644   {
 645     MutexAutoLock lock(mLock);
 646     MOZ_ASSERT(!mObserver, "Should have been cleared at shutdown!");
 647   }
 648 #endif
 649
 650   return NS_OK;
 651 }
 652
 653 NS_IMETHODIMP
 654 nsThread::HasPendingEvents(bool* aResult)
 655 {
 656   if (NS_WARN_IF(PR_GetCurrentThread() != mThread)) {
 657     return NS_ERROR_NOT_SAME_THREAD;
 658   }
 659
 660   *aResult = mEvents->GetEvent(false, nullptr);
 661   return NS_OK;
 662 }
 663
 664 #ifdef MOZ_CANARY
 665 void canary_alarm_handler(int signum);
 666
 667 class Canary
 668 {
 669   //XXX ToDo: support nested loops
 670 public:
 671   Canary()
 672   {
 673     if (sCanaryOutputFD > 0 && EventLatencyIsImportant()) {
 674       signal(SIGALRM, canary_alarm_handler);
 675       ualarm(15000, 0);
 676     }
 677   }
 678
 679   ~Canary()
 680   {
 681     if (sCanaryOutputFD != 0 && EventLatencyIsImportant()) {
 682       ualarm(0, 0);
 683     }
 684   }
 685
 686   static bool EventLatencyIsImportant()
 687   {
 688     return NS_IsMainThread() && XRE_GetProcessType() == GeckoProcessType_Default;
 689   }
 690 };
 691
 692 void canary_alarm_handler(int signum)
 693 {
 694   void* array[30];
 695   const char msg[29] = "event took too long to run:\n";
 696   // use write to be safe in the signal handler
 697   write(sCanaryOutputFD, msg, sizeof(msg));
 698   backtrace_symbols_fd(array, backtrace(array, 30), sCanaryOutputFD);
 699 }
 700
 701 #endif
 702
 703 #define NOTIFY_EVENT_OBSERVERS(func_, params_)                                 \
 704   PR_BEGIN_MACRO                                                               \
 705     if (!mEventObservers.IsEmpty()) {                                          \
 706       nsAutoTObserverArray<nsCOMPtr<nsIThreadObserver>, 2>::ForwardIterator    \
 707         iter_(mEventObservers);                                                \
 708       nsCOMPtr<nsIThreadObserver> obs_;                                        \
 709       while (iter_.HasMore()) {                                                \
 710         obs_ = iter_.GetNext();                                                \
 711         obs_ -> func_ params_ ;                                                \
 712       }                                                                        \
 713     }                                                                          \
 714   PR_END_MACRO
 715
 716 NS_IMETHODIMP
 717 nsThread::ProcessNextEvent(bool aMayWait, bool* aResult)
 718 {
 719   LOG(("THRD(%p) ProcessNextEvent [%u %u]\n", this, aMayWait, mRunningEvent));
 720
 721   // If we're on the main thread, we shouldn't be dispatching CPOWs.
 722   MOZ_RELEASE_ASSERT(mIsMainThread != MAIN_THREAD ||
 723                      !ipc::ProcessingUrgentMessages());
 724
 725   if (NS_WARN_IF(PR_GetCurrentThread() != mThread)) {
 726     return NS_ERROR_NOT_SAME_THREAD;
 727   }
 728
 729   // The toplevel event loop normally blocks waiting for the next event, but
 730   // if we're trying to shut this thread down, we must exit the event loop when
 731   // the event queue is empty.
 732   // This only applys to the toplevel event loop! Nested event loops (e.g.
 733   // during sync dispatch) are waiting for some state change and must be able
 734   // to block even if something has requested shutdown of the thread. Otherwise
 735   // we'll just busywait as we endlessly look for an event, fail to find one,
 736   // and repeat the nested event loop since its state change hasn't happened yet.
 737   bool reallyWait = aMayWait && (mRunningEvent > 0 || !ShuttingDown());
 738
 739   if (MAIN_THREAD == mIsMainThread && reallyWait) {
 740     HangMonitor::Suspend();
 741   }
 742
 743   // Fire a memory pressure notification, if we're the main thread and one is
 744   // pending.
 745   if (MAIN_THREAD == mIsMainThread && !ShuttingDown()) {
 746     MemoryPressureState mpPending = NS_GetPendingMemoryPressure();
 747     if (mpPending != MemPressure_None) {
 748       nsCOMPtr<nsIObserverService> os = services::GetObserverService();
 749
 750       // Use no-forward to prevent the notifications from being transferred to
 751       // the children of this process.
 752       NS_NAMED_LITERAL_STRING(lowMem, "low-memory-no-forward");
 753       NS_NAMED_LITERAL_STRING(lowMemOngoing, "low-memory-ongoing-no-forward");
 754
 755       if (os) {
 756         os->NotifyObservers(nullptr, "memory-pressure",
 757                             mpPending == MemPressure_New ? lowMem.get() :
 758                             lowMemOngoing.get());
 759       } else {
 760         NS_WARNING("Can't get observer service!");
 761       }
 762     }
 763   }
 764
 765 #ifdef MOZ_CRASHREPORTER
 766   if (MAIN_THREAD == mIsMainThread && !ShuttingDown()) {
 767     // Keep an eye on memory usage (cheap, ~7ms) somewhat frequently,
 768     // but save memory reports (expensive, ~75ms) less frequently.
 769     const size_t LOW_MEMORY_CHECK_SECONDS = 30;
 770     const size_t LOW_MEMORY_SAVE_SECONDS = 3 * 60;
 771
 772     static TimeStamp nextCheck = TimeStamp::NowLoRes()
 773       + TimeDuration::FromSeconds(LOW_MEMORY_CHECK_SECONDS);
 774
 775     TimeStamp now = TimeStamp::NowLoRes();
 776     if (now >= nextCheck) {
 777       if (SaveMemoryReportNearOOM()) {
 778         nextCheck = now + TimeDuration::FromSeconds(LOW_MEMORY_SAVE_SECONDS);
 779       } else {
 780         nextCheck = now + TimeDuration::FromSeconds(LOW_MEMORY_CHECK_SECONDS);
 781       }
 782     }
 783   }
 784 #endif
 785
 786   bool notifyMainThreadObserver =
 787     (MAIN_THREAD == mIsMainThread) && sMainThreadObserver;
 788   if (notifyMainThreadObserver) {
 789     sMainThreadObserver->OnProcessNextEvent(this, reallyWait, mRunningEvent);
 790   }
 791
 792   nsCOMPtr<nsIThreadObserver> obs = mObserver;
 793   if (obs) {
 794     obs->OnProcessNextEvent(this, reallyWait, mRunningEvent);
 795   }
 796
 797   NOTIFY_EVENT_OBSERVERS(OnProcessNextEvent,
 798                          (this, reallyWait, mRunningEvent));
 799
 800   ++mRunningEvent;
 801
 802 #ifdef MOZ_CANARY
 803   Canary canary;
 804 #endif
 805   nsresult rv = NS_OK;
 806
 807   {
 808     // Scope for |event| to make sure that its destructor fires while
 809     // mRunningEvent has been incremented, since that destructor can
 810     // also do work.
 811
 812     // If we are shutting down, then do not wait for new events.
 813     nsCOMPtr<nsIRunnable> event;
 814     mEvents->GetEvent(reallyWait, getter_AddRefs(event));
 815
 816     *aResult = (event.get() != nullptr);
 817
 818     if (event) {
 819       LOG(("THRD(%p) running [%p]\n", this, event.get()));
 820       if (MAIN_THREAD == mIsMainThread) {
 821         HangMonitor::NotifyActivity();
 822       }
 823       event->Run();
 824     } else if (aMayWait) {
 825       MOZ_ASSERT(ShuttingDown(),
 826                  "This should only happen when shutting down");
 827       rv = NS_ERROR_UNEXPECTED;
 828     }
 829   }
 830
 831   --mRunningEvent;
 832
 833   NOTIFY_EVENT_OBSERVERS(AfterProcessNextEvent,
 834                          (this, mRunningEvent, *aResult));
 835
 836   if (obs) {
 837     obs->AfterProcessNextEvent(this, mRunningEvent, *aResult);
 838   }
 839
 840   if (notifyMainThreadObserver && sMainThreadObserver) {
 841     sMainThreadObserver->AfterProcessNextEvent(this, mRunningEvent, *aResult);
 842   }
 843
 844   return rv;
 845 }
 846
 847 //-----------------------------------------------------------------------------
 848 // nsISupportsPriority
 849
 850 NS_IMETHODIMP
 851 nsThread::GetPriority(int32_t* aPriority)
 852 {
 853   *aPriority = mPriority;
 854   return NS_OK;
 855 }
 856
 857 NS_IMETHODIMP
 858 nsThread::SetPriority(int32_t aPriority)
 859 {
 860   if (NS_WARN_IF(!mThread)) {
 861     return NS_ERROR_NOT_INITIALIZED;
 862   }
 863
 864   // NSPR defines the following four thread priorities:
 865   //   PR_PRIORITY_LOW
 866   //   PR_PRIORITY_NORMAL
 867   //   PR_PRIORITY_HIGH
 868   //   PR_PRIORITY_URGENT
 869   // We map the priority values defined on nsISupportsPriority to these values.
 870
 871   mPriority = aPriority;
 872
 873   PRThreadPriority pri;
 874   if (mPriority <= PRIORITY_HIGHEST) {
 875     pri = PR_PRIORITY_URGENT;
 876   } else if (mPriority < PRIORITY_NORMAL) {
 877     pri = PR_PRIORITY_HIGH;
 878   } else if (mPriority > PRIORITY_NORMAL) {
 879     pri = PR_PRIORITY_LOW;
 880   } else {
 881     pri = PR_PRIORITY_NORMAL;
 882   }
 883   // If chaos mode is active, retain the randomly chosen priority
 884   if (!ChaosMode::isActive()) {
 885     PR_SetThreadPriority(mThread, pri);
 886   }
 887
 888   return NS_OK;
 889 }
 890
 891 NS_IMETHODIMP
 892 nsThread::AdjustPriority(int32_t aDelta)
 893 {
 894   return SetPriority(mPriority + aDelta);
 895 }
 896
 897 //-----------------------------------------------------------------------------
 898 // nsIThreadInternal
 899
 900 NS_IMETHODIMP
 901 nsThread::GetObserver(nsIThreadObserver** aObs)
 902 {
 903   MutexAutoLock lock(mLock);
 904   NS_IF_ADDREF(*aObs = mObserver);
 905   return NS_OK;
 906 }
 907
 908 NS_IMETHODIMP
 909 nsThread::SetObserver(nsIThreadObserver* aObs)
 910 {
 911   if (NS_WARN_IF(PR_GetCurrentThread() != mThread)) {
 912     return NS_ERROR_NOT_SAME_THREAD;
 913   }
 914
 915   MutexAutoLock lock(mLock);
 916   mObserver = aObs;
 917   return NS_OK;
 918 }
 919
 920 NS_IMETHODIMP
 921 nsThread::GetRecursionDepth(uint32_t* aDepth)
 922 {
 923   if (NS_WARN_IF(PR_GetCurrentThread() != mThread)) {
 924     return NS_ERROR_NOT_SAME_THREAD;
 925   }
 926
 927   *aDepth = mRunningEvent;
 928   return NS_OK;
 929 }
 930
 931 NS_IMETHODIMP
 932 nsThread::AddObserver(nsIThreadObserver* aObserver)
 933 {
 934   if (NS_WARN_IF(!aObserver)) {
 935     return NS_ERROR_INVALID_ARG;
 936   }
 937   if (NS_WARN_IF(PR_GetCurrentThread() != mThread)) {
 938     return NS_ERROR_NOT_SAME_THREAD;
 939   }
 940
 941   NS_WARN_IF_FALSE(!mEventObservers.Contains(aObserver),
 942                    "Adding an observer twice!");
 943
 944   if (!mEventObservers.AppendElement(aObserver)) {
 945     NS_WARNING("Out of memory!");
 946     return NS_ERROR_OUT_OF_MEMORY;
 947   }
 948
 949   return NS_OK;
 950 }
 951
 952 NS_IMETHODIMP
 953 nsThread::RemoveObserver(nsIThreadObserver* aObserver)
 954 {
 955   if (NS_WARN_IF(PR_GetCurrentThread() != mThread)) {
 956     return NS_ERROR_NOT_SAME_THREAD;
 957   }
 958
 959   if (aObserver && !mEventObservers.RemoveElement(aObserver)) {
 960     NS_WARNING("Removing an observer that was never added!");
 961   }
 962
 963   return NS_OK;
 964 }
 965
 966 NS_IMETHODIMP
 967 nsThread::PushEventQueue(nsIEventTarget** aResult)
 968 {
 969   if (NS_WARN_IF(PR_GetCurrentThread() != mThread)) {
 970     return NS_ERROR_NOT_SAME_THREAD;
 971   }
 972
 973   nsChainedEventQueue* queue = new nsChainedEventQueue();
 974   queue->mEventTarget = new nsNestedEventTarget(this, queue);
 975
 976   {
 977     MutexAutoLock lock(mLock);
 978     queue->mNext = mEvents;
 979     mEvents = queue;
 980   }
 981
 982   NS_ADDREF(*aResult = queue->mEventTarget);
 983   return NS_OK;
 984 }
 985
 986 NS_IMETHODIMP
 987 nsThread::PopEventQueue(nsIEventTarget* aInnermostTarget)
 988 {
 989   if (NS_WARN_IF(PR_GetCurrentThread() != mThread)) {
 990     return NS_ERROR_NOT_SAME_THREAD;
 991   }
 992
 993   if (NS_WARN_IF(!aInnermostTarget)) {
 994     return NS_ERROR_NULL_POINTER;
 995   }
 996
 997   // Don't delete or release anything while holding the lock.
 998   nsAutoPtr<nsChainedEventQueue> queue;
 999   nsRefPtr<nsNestedEventTarget> target;
1000
1001   {
1002     MutexAutoLock lock(mLock);
1003
1004     // Make sure we're popping the innermost event target.
1005     if (NS_WARN_IF(mEvents->mEventTarget != aInnermostTarget)) {
1006       return NS_ERROR_UNEXPECTED;
1007     }
1008
1009     MOZ_ASSERT(mEvents != &mEventsRoot);
1010
1011     queue = mEvents;
1012     mEvents = mEvents->mNext;
1013
1014     nsCOMPtr<nsIRunnable> event;
1015     while (queue->GetEvent(false, getter_AddRefs(event))) {
1016       mEvents->PutEvent(event);
1017     }
1018
1019     // Don't let the event target post any more events.
1020     queue->mEventTarget.swap(target);
1021     target->mQueue = nullptr;
1022   }
1023
1024   return NS_OK;
1025 }
1026
1027 nsresult
1028 nsThread::SetMainThreadObserver(nsIThreadObserver* aObserver)
1029 {
1030   if (aObserver && nsThread::sMainThreadObserver) {
1031     return NS_ERROR_NOT_AVAILABLE;
1032   }
1033
1034   if (!NS_IsMainThread()) {
1035     return NS_ERROR_UNEXPECTED;
1036   }
1037
1038   nsThread::sMainThreadObserver = aObserver;
1039   return NS_OK;
1040 }
1041
1042 //-----------------------------------------------------------------------------
1043
1044 NS_IMETHODIMP
1045 nsThreadSyncDispatch::Run()
1046 {
1047   if (mSyncTask) {
1048     mResult = mSyncTask->Run();
1049     mSyncTask = nullptr;
1050     // unblock the origin thread
1051     mOrigin->Dispatch(this, NS_DISPATCH_NORMAL);
1052   }
1053   return NS_OK;
1054 }
1055
1056 //-----------------------------------------------------------------------------
1057
1058 NS_IMPL_ISUPPORTS(nsThread::nsNestedEventTarget, nsIEventTarget)
1059
1060 NS_IMETHODIMP
1061 nsThread::nsNestedEventTarget::Dispatch(nsIRunnable* aEvent, uint32_t aFlags)
1062 {
1063   LOG(("THRD(%p) Dispatch [%p %x] to nested loop %p\n", mThread.get(), aEvent,
1064        aFlags, this));
1065
1066   return mThread->DispatchInternal(aEvent, aFlags, this);
1067 }
1068
1069 NS_IMETHODIMP
1070 nsThread::nsNestedEventTarget::IsOnCurrentThread(bool* aResult)
1071 {
1072   return mThread->IsOnCurrentThread(aResult);
1073 }