The Tor Browser / file revision

 /* 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 "CacheIOThread.h"

 #include "CacheFileIOManager.h"

 #include "nsIRunnable.h"

 #include "nsISupportsImpl.h"

 #include "nsPrintfCString.h"

 #include "nsThreadUtils.h"

 #include "mozilla/IOInterposer.h"

 #include "mozilla/VisualEventTracer.h"

 namespace mozilla {

 namespace net {

 CacheIOThread* CacheIOThread::sSelf = nullptr;

 NS_IMPL_ISUPPORTS(CacheIOThread, nsIThreadObserver)

 CacheIOThread::CacheIOThread()

 : mMonitor("CacheIOThread")

 , mThread(nullptr)

 , mLowestLevelWaiting(LAST_LEVEL)

 , mCurrentlyExecutingLevel(0)

 , mHasXPCOMEvents(false)

 , mRerunCurrentEvent(false)

 , mShutdown(false)

 {

   sSelf = this;

 }

 CacheIOThread::~CacheIOThread()

 {

   sSelf = nullptr;

 #ifdef DEBUG

   for (uint32_t level = 0; level < LAST_LEVEL; ++level) {

     MOZ_ASSERT(!mEventQueue[level].Length());

   }

 #endif

 }

 nsresult CacheIOThread::Init()

 {

   mThread = PR_CreateThread(PR_USER_THREAD, ThreadFunc, this,

                             PR_PRIORITY_NORMAL, PR_GLOBAL_THREAD,

                             PR_JOINABLE_THREAD, 128 * 1024);

   if (!mThread)

     return NS_ERROR_FAILURE;

   return NS_OK;

 }

 nsresult CacheIOThread::Dispatch(nsIRunnable* aRunnable, uint32_t aLevel)

 {

   NS_ENSURE_ARG(aLevel < LAST_LEVEL);

   MonitorAutoLock lock(mMonitor);

   if (mShutdown && (PR_GetCurrentThread() != mThread))

     return NS_ERROR_UNEXPECTED;

   return DispatchInternal(aRunnable, aLevel);

 }

 nsresult CacheIOThread::DispatchAfterPendingOpens(nsIRunnable* aRunnable)

 {

   MonitorAutoLock lock(mMonitor);

   if (mShutdown && (PR_GetCurrentThread() != mThread))

     return NS_ERROR_UNEXPECTED;

   // Move everything from later executed OPEN level to the OPEN_PRIORITY level

   // where we post the (eviction) runnable.

   mEventQueue[OPEN_PRIORITY].AppendElements(mEventQueue[OPEN]);

   mEventQueue[OPEN].Clear();

   return DispatchInternal(aRunnable, OPEN_PRIORITY);

 }

 nsresult CacheIOThread::DispatchInternal(nsIRunnable* aRunnable, uint32_t aLevel)

 {

   mMonitor.AssertCurrentThreadOwns();

   mEventQueue[aLevel].AppendElement(aRunnable);

   if (mLowestLevelWaiting > aLevel)

     mLowestLevelWaiting = aLevel;

   mMonitor.NotifyAll();

   return NS_OK;

 }

 bool CacheIOThread::IsCurrentThread()

 {

   return mThread == PR_GetCurrentThread();

 }

 bool CacheIOThread::YieldInternal()

 {

   if (!IsCurrentThread()) {

     NS_WARNING("Trying to yield to priority events on non-cache2 I/O thread? "

                "You probably do something wrong.");

     return false;

   }

   if (mCurrentlyExecutingLevel == XPCOM_LEVEL) {

     // Doesn't make any sense, since this handler is the one

     // that would be executed as the next one.

     return false;

   }

   if (!EventsPending(mCurrentlyExecutingLevel))

     return false;

   mRerunCurrentEvent = true;

   return true;

 }

 nsresult CacheIOThread::Shutdown()

 {

   {

     MonitorAutoLock lock(mMonitor);

     mShutdown = true;

     mMonitor.NotifyAll();

   }

   PR_JoinThread(mThread);

   mThread = nullptr;

   return NS_OK;

 }

 already_AddRefed<nsIEventTarget> CacheIOThread::Target()

 {

   nsCOMPtr<nsIEventTarget> target;

   target = mXPCOMThread;

   if (!target && mThread)

   {

     MonitorAutoLock lock(mMonitor);

     if (!mXPCOMThread)

       lock.Wait();

     target = mXPCOMThread;

   }

   return target.forget();

 }

 // static

 void CacheIOThread::ThreadFunc(void* aClosure)

 {

   PR_SetCurrentThreadName("Cache2 I/O");

   mozilla::IOInterposer::RegisterCurrentThread();

   CacheIOThread* thread = static_cast<CacheIOThread*>(aClosure);

   thread->ThreadFunc();

   mozilla::IOInterposer::UnregisterCurrentThread();

 }

 void CacheIOThread::ThreadFunc()

 {

   nsCOMPtr<nsIThreadInternal> threadInternal;

   {

     MonitorAutoLock lock(mMonitor);

     // This creates nsThread for this PRThread

     nsCOMPtr<nsIThread> xpcomThread = NS_GetCurrentThread();

     threadInternal = do_QueryInterface(xpcomThread);

     if (threadInternal)

       threadInternal->SetObserver(this);

     mXPCOMThread.swap(xpcomThread);

     lock.NotifyAll();

     do {

 loopStart:

       // Reset the lowest level now, so that we can detect a new event on

       // a lower level (i.e. higher priority) has been scheduled while

       // executing any previously scheduled event.

       mLowestLevelWaiting = LAST_LEVEL;

       // Process xpcom events first

       while (mHasXPCOMEvents) {

         eventtracer::AutoEventTracer tracer(this, eventtracer::eExec, eventtracer::eDone,

           "net::cache::io::level(xpcom)");

         mHasXPCOMEvents = false;

         mCurrentlyExecutingLevel = XPCOM_LEVEL;

         MonitorAutoUnlock unlock(mMonitor);

         bool processedEvent;

         nsresult rv;

         do {

           rv = mXPCOMThread->ProcessNextEvent(false, &processedEvent);

         } while (NS_SUCCEEDED(rv) && processedEvent);

       }

       uint32_t level;

       for (level = 0; level < LAST_LEVEL; ++level) {

         if (!mEventQueue[level].Length()) {

           // no events on this level, go to the next level

           continue;

         }

         LoopOneLevel(level);

         // Go to the first (lowest) level again

         goto loopStart;

       }

       if (EventsPending())

         continue;

       if (mShutdown)

         break;

       lock.Wait(PR_INTERVAL_NO_TIMEOUT);

       if (EventsPending())

         continue;

     } while (true);

     MOZ_ASSERT(!EventsPending());

   } // lock

   if (threadInternal)

     threadInternal->SetObserver(nullptr);

 }

 static const char* const sLevelTraceName[] = {

   "net::cache::io::level(0)",

   "net::cache::io::level(1)",

   "net::cache::io::level(2)",

   "net::cache::io::level(3)",

   "net::cache::io::level(4)",

   "net::cache::io::level(5)",

   "net::cache::io::level(6)",

   "net::cache::io::level(7)",

   "net::cache::io::level(8)",

   "net::cache::io::level(9)",

   "net::cache::io::level(10)",

   "net::cache::io::level(11)",

   "net::cache::io::level(12)"

 };

 void CacheIOThread::LoopOneLevel(uint32_t aLevel)

 {

   eventtracer::AutoEventTracer tracer(this, eventtracer::eExec, eventtracer::eDone,

     sLevelTraceName[aLevel]);

   nsTArray<nsRefPtr<nsIRunnable> > events;

   events.SwapElements(mEventQueue[aLevel]);

   uint32_t length = events.Length();

   mCurrentlyExecutingLevel = aLevel;

   bool returnEvents = false;

   uint32_t index;

   {

     MonitorAutoUnlock unlock(mMonitor);

     for (index = 0; index < length; ++index) {

       if (EventsPending(aLevel)) {

         // Somebody scheduled a new event on a lower level, break and harry

         // to execute it!  Don't forget to return what we haven't exec.

         returnEvents = true;

         break;

       }

       // Drop any previous flagging, only an event on the current level may set

       // this flag.

       mRerunCurrentEvent = false;

       events[index]->Run();

       if (mRerunCurrentEvent) {

         // The event handler yields to higher priority events and wants to rerun.

         returnEvents = true;

         break;

       }

       // Release outside the lock.

       events[index] = nullptr;

     }

   }

   if (returnEvents)

     mEventQueue[aLevel].InsertElementsAt(0, events.Elements() + index, length - index);

 }

 bool CacheIOThread::EventsPending(uint32_t aLastLevel)

 {

   return mLowestLevelWaiting < aLastLevel || mHasXPCOMEvents;

 }

 NS_IMETHODIMP CacheIOThread::OnDispatchedEvent(nsIThreadInternal *thread)

 {

   MonitorAutoLock lock(mMonitor);

   mHasXPCOMEvents = true;

   MOZ_ASSERT(!mShutdown || (PR_GetCurrentThread() == mThread));

   lock.Notify();

   return NS_OK;

 }

 NS_IMETHODIMP CacheIOThread::OnProcessNextEvent(nsIThreadInternal *thread, bool mayWait, uint32_t recursionDepth)

 {

   return NS_OK;

 }

 NS_IMETHODIMP CacheIOThread::AfterProcessNextEvent(nsIThreadInternal *thread, uint32_t recursionDepth,

                                                    bool eventWasProcessed)

 {

   return NS_OK;

 }

 // Memory reporting

 size_t CacheIOThread::SizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf) const

 {

   MonitorAutoLock lock(const_cast<CacheIOThread*>(this)->mMonitor);

   size_t n = 0;

   n += mallocSizeOf(mThread);

   for (uint32_t level = 0; level < LAST_LEVEL; ++level) {

     n += mEventQueue[level].SizeOfExcludingThis(mallocSizeOf);

     // Events referenced by the queues are arbitrary objects we cannot be sure

     // are reported elsewhere as well as probably not implementing nsISizeOf

     // interface.  Deliberatly omitting them from reporting here.

   }

   return n;

 }

 size_t CacheIOThread::SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const

 {

   return mallocSizeOf(this) + SizeOfExcludingThis(mallocSizeOf);

 }

 } // net

 } // mozilla