Changeset 102057 in vbox for trunk/src

Timestamp:

Nov 10, 2023 7:53:16 AM (18 months ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

160165

Message:

libs/xpcom: Convert nsEventQueueService to use a IPRT fast mutex instead of a PRMonitor, bugref:10545

Location:

trunk/src/libs/xpcom18a4/xpcom/threads

Files:

• nsEventQueueService.cpp (modified) (18 diffs)
• nsEventQueueService.h (modified) (2 diffs)

trunk/src/libs/xpcom18a4/xpcom/threads/nsEventQueueService.cpp

@@ -52 +52 @@
 
 #include "nsEventQueueService.h"
-#include "prmon.h"
 #include "nsIComponentManager.h"
 #include "nsPIEventQueueChain.h"
@@ -58 +57 @@
 #include "nsXPCOM.h"
 
+#include <iprt/assert.h>
 #include <VBox/log.h>
 
@@ -64 +64 @@
 nsEventQueueServiceImpl::nsEventQueueServiceImpl()
 {
-  mEventQMonitor = PR_NewMonitor();
+    mEventQMonitor = NIL_RTSEMFASTMUTEX;
+    int vrc = RTSemFastMutexCreate(&mEventQMonitor);
+    AssertRC(vrc); RT_NOREF(vrc);
 }
 
@@ -72 +74 @@
                         void* closure)
 {
-  // 'aQueue' should be the eldest queue.
-  nsCOMPtr<nsPIEventQueueChain> pie(do_QueryInterface(aEldestQueue));
-  nsCOMPtr<nsIEventQueue> q;
-
-  // stop accepting events for youngest to oldest
-  pie->GetYoungest(getter_AddRefs(q));
-  while (q) {
-    q->StopAcceptingEvents();
-
-    nsCOMPtr<nsPIEventQueueChain> pq(do_QueryInterface(q));
-    pq->GetElder(getter_AddRefs(q));
-  }
-
-  return PL_DHASH_REMOVE;
+    // 'aQueue' should be the eldest queue.
+    nsCOMPtr<nsPIEventQueueChain> pie(do_QueryInterface(aEldestQueue));
+    nsCOMPtr<nsIEventQueue> q;
+
+    // stop accepting events for youngest to oldest
+    pie->GetYoungest(getter_AddRefs(q));
+    while (q)
+    {
+        q->StopAcceptingEvents();
+
+        nsCOMPtr<nsPIEventQueueChain> pq(do_QueryInterface(q));
+        pq->GetElder(getter_AddRefs(q));
+    }
+
+    return PL_DHASH_REMOVE;
 }
 
 nsEventQueueServiceImpl::~nsEventQueueServiceImpl()
 {
-  // XXX make it so we only enum over this once
-  mEventQTable.Enumerate(hash_enum_remove_queues, nsnull); // call StopAcceptingEvents on everything and clear out the hashtable
-
-  PR_DestroyMonitor(mEventQMonitor);
+    // XXX make it so we only enum over this once
+    mEventQTable.Enumerate(hash_enum_remove_queues, nsnull); // call StopAcceptingEvents on everything and clear out the hashtable
+
+    int vrc = RTSemFastMutexDestroy(mEventQMonitor);
+    AssertRC(vrc); RT_NOREF(vrc);
+    mEventQMonitor = NIL_RTSEMFASTMUTEX;
 }
 
@@ -99 +104 @@
 nsEventQueueServiceImpl::Init()
 {
-  NS_ENSURE_TRUE(mEventQMonitor, NS_ERROR_OUT_OF_MEMORY);
-
-  // This will only be called once on the main thread, so it's safe to
-  // not enter the monitor here.
-  if (!mEventQTable.Init()) {
-    return NS_ERROR_OUT_OF_MEMORY;
-  }
-  
-  // ensure that a main thread event queue exists!
-  RTTHREAD hMainThread;
-  nsresult rv = NS_GetMainThread(&hMainThread);
-  if (NS_SUCCEEDED(rv))
-    rv = CreateEventQueue(hMainThread, PR_TRUE);
+    NS_ENSURE_TRUE(mEventQMonitor != NIL_RTSEMFASTMUTEX, NS_ERROR_OUT_OF_MEMORY);
+
+    // This will only be called once on the main thread, so it's safe to
+    // not enter the monitor here.
+    if (!mEventQTable.Init())
+        return NS_ERROR_OUT_OF_MEMORY;
+
+    // ensure that a main thread event queue exists!
+    RTTHREAD hMainThread;
+    nsresult rv = NS_GetMainThread(&hMainThread);
+    if (NS_SUCCEEDED(rv))
+      rv = CreateEventQueue(hMainThread, PR_TRUE);
 
   return rv;
@@ -124 +128 @@
 nsEventQueueServiceImpl::CreateThreadEventQueue()
 {
-  return CreateEventQueue(RTThreadSelf(), PR_TRUE);
+    return CreateEventQueue(RTThreadSelf(), PR_TRUE);
 }
 
@@ -130 +134 @@
 nsEventQueueServiceImpl::CreateMonitoredThreadEventQueue()
 {
-  return CreateEventQueue(RTThreadSelf(), PR_FALSE);
+    return CreateEventQueue(RTThreadSelf(), PR_FALSE);
 }
 
@@ -137 +141 @@
                                            nsIEventQueue **aResult)
 {
-  nsresult rv;
-
-  rv = CreateEventQueue(aThread, aNative); // addrefs
-  if (NS_SUCCEEDED(rv))
-    rv = GetThreadEventQueue(aThread, aResult); // addrefs
-
-  return rv;
+    nsresult rv;
+
+    rv = CreateEventQueue(aThread, aNative); // addrefs
+    if (NS_SUCCEEDED(rv))
+      rv = GetThreadEventQueue(aThread, aResult); // addrefs
+
+    return rv;
 }
 
@@ -152 +156 @@
                                       nsIEventQueue **aQueue)
 {
-  nsresult rv;
-  nsCOMPtr<nsIEventQueue> queue = do_CreateInstance(kEventQueueCID, &rv);
-
-  if (NS_SUCCEEDED(rv)) {
-    rv = queue->InitFromPRThread(hThread, aNative);
-  }
-  *aQueue = queue;
-  NS_IF_ADDREF(*aQueue);
-  return rv;
+    nsresult rv;
+    nsCOMPtr<nsIEventQueue> queue = do_CreateInstance(kEventQueueCID, &rv);
+
+    if (NS_SUCCEEDED(rv))
+        rv = queue->InitFromPRThread(hThread, aNative);
+
+    *aQueue = queue;
+    NS_IF_ADDREF(*aQueue);
+    return rv;
 }
 
@@ -167 +171 @@
 nsEventQueueServiceImpl::CreateEventQueue(RTTHREAD aThread, PRBool aNative)
 {
-  nsresult rv = NS_OK;
-  /* Enter the lock that protects the EventQ hashtable... */
-  PR_EnterMonitor(mEventQMonitor);
-
-  /* create only one event queue chain per thread... */
-  if (!mEventQTable.GetWeak(aThread)) {
-    nsCOMPtr<nsIEventQueue> queue;
-
-    // we don't have one in the table
-    rv = MakeNewQueue(aThread, aNative, getter_AddRefs(queue)); // create new queue
-    mEventQTable.Put(aThread, queue); // add to the table (initial addref)
-  }
-
-  // Release the EventQ lock...
-  PR_ExitMonitor(mEventQMonitor);
-  return rv;
+    nsresult rv = NS_OK;
+    /* Enter the lock that protects the EventQ hashtable... */
+    RTSemFastMutexRequest(mEventQMonitor);
+
+    /* create only one event queue chain per thread... */
+    if (!mEventQTable.GetWeak(aThread))
+    {
+        nsCOMPtr<nsIEventQueue> queue;
+
+        // we don't have one in the table
+        rv = MakeNewQueue(aThread, aNative, getter_AddRefs(queue)); // create new queue
+        mEventQTable.Put(aThread, queue); // add to the table (initial addref)
+    }
+
+    // Release the EventQ lock...
+    RTSemFastMutexRelease(mEventQMonitor);
+    return rv;
 }
 
@@ -189 +194 @@
 nsEventQueueServiceImpl::DestroyThreadEventQueue(void)
 {
-  nsresult rv = NS_OK;
-
-  /* Enter the lock that protects the EventQ hashtable... */
-  PR_EnterMonitor(mEventQMonitor);
-
-  RTTHREAD hThread = RTThreadSelf();
-  nsIEventQueue* queue = mEventQTable.GetWeak(hThread);
-  if (queue) {
-    queue->StopAcceptingEvents(); // tell the queue to stop accepting events
-    queue = nsnull; // Queue may die on the next line
-    mEventQTable.Remove(hThread); // remove nsIEventQueue from hash table (releases)
-  }
-
-  // Release the EventQ lock...
-  PR_ExitMonitor(mEventQMonitor);
-  return rv;
+    nsresult rv = NS_OK;
+
+    /* Enter the lock that protects the EventQ hashtable... */
+    RTSemFastMutexRequest(mEventQMonitor);
+
+    RTTHREAD hThread = RTThreadSelf();
+    nsIEventQueue* queue = mEventQTable.GetWeak(hThread);
+    if (queue)
+    {
+        queue->StopAcceptingEvents(); // tell the queue to stop accepting events
+        queue = nsnull; // Queue may die on the next line
+        mEventQTable.Remove(hThread); // remove nsIEventQueue from hash table (releases)
+    }
+
+    // Release the EventQ lock...
+    RTSemFastMutexRelease(mEventQMonitor);
+    return rv;
 }
 
@@ -210 +216 @@
 nsEventQueueServiceImpl::CreateFromPLEventQueue(PLEventQueue* aPLEventQueue, nsIEventQueue** aResult)
 {
-        // Create our thread queue using the component manager
-        nsresult rv;
-        nsCOMPtr<nsIEventQueue> queue = do_CreateInstance(kEventQueueCID, &rv);
-        if (NS_FAILED(rv)) return rv;
-
-  rv = queue->InitFromPLQueue(aPLEventQueue);
-        if (NS_FAILED(rv)) return rv;
-
-        *aResult = queue;
-  NS_IF_ADDREF(*aResult);
-        return NS_OK;
+    // Create our thread queue using the component manager
+    nsresult rv;
+    nsCOMPtr<nsIEventQueue> queue = do_CreateInstance(kEventQueueCID, &rv);
+    if (NS_FAILED(rv))
+        return rv;
+
+    rv = queue->InitFromPLQueue(aPLEventQueue);
+    if (NS_FAILED(rv))
+        return rv;
+
+    *aResult = queue;
+    NS_IF_ADDREF(*aResult);
+    return NS_OK;
 }
 
@@ -228 +236 @@
 nsresult nsEventQueueServiceImpl::GetYoungestEventQueue(nsIEventQueue *queue, nsIEventQueue **aResult)
 {
-  nsCOMPtr<nsIEventQueue> answer;
-
-  if (queue) {
-    nsCOMPtr<nsPIEventQueueChain> ourChain(do_QueryInterface(queue));
-    if (ourChain)
-      ourChain->GetYoungestActive(getter_AddRefs(answer));
-    else
-      answer = queue;
-  }
-
-  *aResult = answer;
-  NS_IF_ADDREF(*aResult);
-  return NS_OK;
+    nsCOMPtr<nsIEventQueue> answer;
+
+    if (queue)
+    {
+        nsCOMPtr<nsPIEventQueueChain> ourChain(do_QueryInterface(queue));
+        if (ourChain)
+            ourChain->GetYoungestActive(getter_AddRefs(answer));
+        else
+            answer = queue;
+    }
+
+    *aResult = answer;
+    NS_IF_ADDREF(*aResult);
+    return NS_OK;
 }
 
@@ -249 +258 @@
 nsEventQueueServiceImpl::PushThreadEventQueue(nsIEventQueue **aNewQueue)
 {
-  nsresult rv = NS_OK;
-  RTTHREAD hThread = RTThreadSelf();
-  PRBool native = PR_TRUE; // native by default as per old comment
-
-
-  NS_ASSERTION(aNewQueue, "PushThreadEventQueue called with null param");
-
-  /* Enter the lock that protects the EventQ hashtable... */
-  PR_EnterMonitor(mEventQMonitor);
-
-  nsIEventQueue* queue = mEventQTable.GetWeak(hThread);
-  
-  NS_ASSERTION(queue, "pushed event queue on top of nothing");
-
-  if (queue) { // find out what kind of queue our relatives are
-    nsCOMPtr<nsIEventQueue> youngQueue;
-    GetYoungestEventQueue(queue, getter_AddRefs(youngQueue));
-    if (youngQueue) {
-      youngQueue->IsQueueNative(&native);
-    }
-  }
-
-  nsIEventQueue* newQueue = nsnull;
-  MakeNewQueue(hThread, native, &newQueue); // create new queue; addrefs
-
-  if (!queue) {
-    // shouldn't happen. as a fallback, we guess you wanted a native queue
-    mEventQTable.Put(hThread, newQueue);
-  }
-
-  // append to the event queue chain
-  nsCOMPtr<nsPIEventQueueChain> ourChain(do_QueryInterface(queue)); // QI the queue in the hash table
-  if (ourChain)
-    ourChain->AppendQueue(newQueue); // append new queue to it
-
-  *aNewQueue = newQueue;
+    nsresult rv = NS_OK;
+    RTTHREAD hThread = RTThreadSelf();
+    PRBool native = PR_TRUE; // native by default as per old comment
+
+    NS_ASSERTION(aNewQueue, "PushThreadEventQueue called with null param");
+
+    /* Enter the lock that protects the EventQ hashtable... */
+    RTSemFastMutexRequest(mEventQMonitor);
+
+    nsIEventQueue* queue = mEventQTable.GetWeak(hThread);
+    
+    NS_ASSERTION(queue, "pushed event queue on top of nothing");
+
+    if (queue)
+    {
+        // find out what kind of queue our relatives are
+        nsCOMPtr<nsIEventQueue> youngQueue;
+        GetYoungestEventQueue(queue, getter_AddRefs(youngQueue));
+        if (youngQueue)
+          youngQueue->IsQueueNative(&native);
+    }
+
+    nsIEventQueue* newQueue = nsnull;
+    MakeNewQueue(hThread, native, &newQueue); // create new queue; addrefs
+
+    if (!queue)
+    {
+        // shouldn't happen. as a fallback, we guess you wanted a native queue
+        mEventQTable.Put(hThread, newQueue);
+    }
+
+    // append to the event queue chain
+    nsCOMPtr<nsPIEventQueueChain> ourChain(do_QueryInterface(queue)); // QI the queue in the hash table
+    if (ourChain)
+        ourChain->AppendQueue(newQueue); // append new queue to it
+
+    *aNewQueue = newQueue;
 
 #ifdef LOG_ENABLED
-  PLEventQueue *equeue;
-  (*aNewQueue)->GetPLEventQueue(&equeue);
-  Log(("EventQueue: Service push queue [queue=%lx]",(long)equeue));
+    PLEventQueue *equeue;
+    (*aNewQueue)->GetPLEventQueue(&equeue);
+    Log(("EventQueue: Service push queue [queue=%lx]",(long)equeue));
 #endif
 
-  // Release the EventQ lock...
-  PR_ExitMonitor(mEventQMonitor);
-  return rv;
+    // Release the EventQ lock...
+    RTSemFastMutexRelease(mEventQMonitor);
+    return rv;
 }
 
@@ -301 +311 @@
 nsEventQueueServiceImpl::PopThreadEventQueue(nsIEventQueue *aQueue)
 {
-  RTTHREAD hThread = RTThreadSelf();
-
-  /* Enter the lock that protects the EventQ hashtable... */
-  PR_EnterMonitor(mEventQMonitor);
-
-  nsCOMPtr<nsIEventQueue> eldestQueue;
-  mEventQTable.Get(hThread, getter_AddRefs(eldestQueue));
-
-  // If we are popping the eldest queue, remove its mEventQTable entry.
-  if (aQueue == eldestQueue)
-    mEventQTable.Remove(hThread);
-
-  // Exit the monitor before processing pending events to avoid deadlock.
-  // Our reference from the eldestQueue nsCOMPtr will keep that object alive.
-  // Since it is thread-private, no one else can race with us here.
-  PR_ExitMonitor(mEventQMonitor);
-  if (!eldestQueue)
-    return NS_ERROR_FAILURE;
+    RTTHREAD hThread = RTThreadSelf();
+
+    /* Enter the lock that protects the EventQ hashtable... */
+    RTSemFastMutexRequest(mEventQMonitor);
+
+    nsCOMPtr<nsIEventQueue> eldestQueue;
+    mEventQTable.Get(hThread, getter_AddRefs(eldestQueue));
+
+    // If we are popping the eldest queue, remove its mEventQTable entry.
+    if (aQueue == eldestQueue)
+        mEventQTable.Remove(hThread);
+
+    // Exit the monitor before processing pending events to avoid deadlock.
+    // Our reference from the eldestQueue nsCOMPtr will keep that object alive.
+    // Since it is thread-private, no one else can race with us here.
+    RTSemFastMutexRelease(mEventQMonitor);
+    if (!eldestQueue)
+        return NS_ERROR_FAILURE;
 
 #ifdef LOG_ENABLED
-  PLEventQueue *equeue;
-  aQueue->GetPLEventQueue(&equeue);
-  Log(("EventQueue: Service pop queue [queue=%lx]",(long)equeue));
+    PLEventQueue *equeue;
+    aQueue->GetPLEventQueue(&equeue);
+    Log(("EventQueue: Service pop queue [queue=%lx]",(long)equeue));
 #endif
-  aQueue->StopAcceptingEvents();
-  aQueue->ProcessPendingEvents(); // make sure we don't orphan any events
-
-  return NS_OK;
+    aQueue->StopAcceptingEvents();
+    aQueue->ProcessPendingEvents(); // make sure we don't orphan any events
+
+    return NS_OK;
 }
 
@@ -334 +344 @@
 nsEventQueueServiceImpl::GetThreadEventQueue(RTTHREAD aThread, nsIEventQueue** aResult)
 {
-  /* Parameter validation... */
-  if (NULL == aResult) return NS_ERROR_NULL_POINTER;
-
-  RTTHREAD keyThread = aThread;
-
-  if (keyThread == NS_CURRENT_THREAD)
-  {
-     keyThread = RTThreadSelf();
-  }
-  else if (keyThread == NS_UI_THREAD)
-  {
-    // Get the primordial thread
-    nsresult rv = NS_GetMainThread(&keyThread);
-    if (NS_FAILED(rv)) return rv;
-  }
-
-  /* Enter the lock that protects the EventQ hashtable... */
-  PR_EnterMonitor(mEventQMonitor);
-
-  nsCOMPtr<nsIEventQueue> queue;
-  mEventQTable.Get(keyThread, getter_AddRefs(queue));
-
-  PR_ExitMonitor(mEventQMonitor);
-
-  if (queue) {
-    GetYoungestEventQueue(queue, aResult); // get the youngest active queue
-  } else {
-    *aResult = nsnull;
-  }
-  // XXX: Need error code for requesting an event queue when none exists...
-  if (!*aResult) {
-    return NS_ERROR_NOT_AVAILABLE;
-  }
-  return NS_OK;
+    /* Parameter validation... */
+    AssertReturn(aResult != NULL, NS_ERROR_NULL_POINTER);
+
+    RTTHREAD keyThread = aThread;
+
+    if (keyThread == NS_CURRENT_THREAD)
+         keyThread = RTThreadSelf();
+    else if (keyThread == NS_UI_THREAD)
+    {
+        // Get the primordial thread
+        nsresult rv = NS_GetMainThread(&keyThread);
+        if (NS_FAILED(rv))
+            return rv;
+    }
+
+    /* Enter the lock that protects the EventQ hashtable... */
+    RTSemFastMutexRequest(mEventQMonitor);
+
+    nsCOMPtr<nsIEventQueue> queue;
+    mEventQTable.Get(keyThread, getter_AddRefs(queue));
+
+    RTSemFastMutexRelease(mEventQMonitor);
+
+    if (queue)
+      GetYoungestEventQueue(queue, aResult); // get the youngest active queue
+    else
+      *aResult = nsnull;
+
+    // XXX: Need error code for requesting an event queue when none exists...
+    if (!*aResult)
+      return NS_ERROR_NOT_AVAILABLE;
+
+    return NS_OK;
 }
 
@@ -374 +383 @@
 nsEventQueueServiceImpl::ResolveEventQueue(nsIEventQueue* queueOrConstant, nsIEventQueue* *resultQueue)
 {
-  if (queueOrConstant == NS_CURRENT_EVENTQ) {
-    return GetThreadEventQueue(NS_CURRENT_THREAD, resultQueue);
-  }
-  else if (queueOrConstant == NS_UI_THREAD_EVENTQ) {
-    return GetThreadEventQueue(NS_UI_THREAD, resultQueue);
-  }
-
-  *resultQueue = queueOrConstant;
-  NS_ADDREF(*resultQueue);
-  return NS_OK;
+    if (queueOrConstant == NS_CURRENT_EVENTQ)
+        return GetThreadEventQueue(NS_CURRENT_THREAD, resultQueue);
+    else if (queueOrConstant == NS_UI_THREAD_EVENTQ)
+        return GetThreadEventQueue(NS_UI_THREAD, resultQueue);
+
+    *resultQueue = queueOrConstant;
+    NS_ADDREF(*resultQueue);
+    return NS_OK;
 }
 
@@ -390 +397 @@
                                               nsIEventQueue* *_retval)
 {
-  nsresult rv;
-
-  // barf if someone gave us a zero pointer
-  //
-  if (!_retval) {
-    return NS_ERROR_NULL_POINTER;
-  }
-
-  // try and get the requested event queue, returning NS_ERROR_FAILURE if there
-  // is a problem.  GetThreadEventQueue() does the AddRef() for us.
-  //
-  switch (aQueue) {
-  case CURRENT_THREAD_EVENT_QUEUE:
-    rv = GetThreadEventQueue(NS_CURRENT_THREAD, _retval);
-    if (NS_FAILED(rv)) {
-      return NS_ERROR_FAILURE;
-    }
-    break;
-
-  case UI_THREAD_EVENT_QUEUE:
-    rv = GetThreadEventQueue(NS_UI_THREAD, _retval);
-    if (NS_FAILED(rv)) {
-      return NS_ERROR_FAILURE;
-    }
-    break;
-
-    // somebody handed us a bogus constant
-    //
-  default:
-    return NS_ERROR_ILLEGAL_VALUE;
-  }
-
-  return NS_OK;
-}
-
+    AssertReturn(_retval, NS_ERROR_NULL_POINTER);
+
+    // try and get the requested event queue, returning NS_ERROR_FAILURE if there
+    // is a problem.  GetThreadEventQueue() does the AddRef() for us.
+    switch (aQueue)
+    {
+        case CURRENT_THREAD_EVENT_QUEUE:
+        {
+            nsresult rv = GetThreadEventQueue(NS_CURRENT_THREAD, _retval);
+            if (NS_FAILED(rv))
+                return NS_ERROR_FAILURE;
+            break;
+        }
+        case UI_THREAD_EVENT_QUEUE:
+        {
+            nsresult rv = GetThreadEventQueue(NS_UI_THREAD, _retval);
+            if (NS_FAILED(rv))
+                return NS_ERROR_FAILURE;
+            break;
+        }
+        /* somebody handed us a bogus constant */
+        default:
+            return NS_ERROR_ILLEGAL_VALUE;
+    }
+
+    return NS_OK;
+}
+

trunk/src/libs/xpcom18a4/xpcom/threads/nsEventQueueService.h

@@ -44 +44 @@
 #include "nsIEventQueue.h"
 
+#include <iprt/semaphore.h>
+
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -70 +72 @@
 
   nsInterfaceHashtable<nsVoidPtrHashKey, nsIEventQueue> mEventQTable;
-  PRMonitor *mEventQMonitor;
+  RTSEMFASTMUTEX mEventQMonitor;
 };