Changeset 101955 in vbox

Timestamp:

Nov 8, 2023 10:23:22 AM (15 months ago)

Author:

vboxsync

Message:

libs/xpcom/python: Convert to IPRT and remove some dead code, bugref:10545

Location:

trunk/src/libs/xpcom18a4/python/src

Files:

• ErrorUtils.cpp (modified) (9 diffs)
• PyGBase.cpp (modified) (5 diffs)
• PyISupports.cpp (modified) (4 diffs)
• PyXPCOM.h (modified) (4 diffs)
• dllmain.cpp (modified) (8 diffs)
• module/_xpcom.cpp (modified) (1 diff)

trunk/src/libs/xpcom18a4/python/src/ErrorUtils.cpp

@@ -52 +52 @@
 # include <iprt/err.h>
 # include <iprt/string.h>
-#endif
-#include "nspr.h" // PR_fprintf
+# include <iprt/stream.h>
+#endif
 
 static char *PyTraceback_AsString(PyObject *exc_tb);
@@ -63 +63 @@
 static void _PanicErrorWrite(const char *msg)
 {
-        PR_fprintf(PR_STDERR,"%s\n", msg);
+    RTStrmPrintf(g_pStdErr,"%s\n", msg);
 }
 
@@ -152 +152 @@
 static void VLogF(const char *methodName, const char *fmt, va_list argptr)
 {
-        char buff[512];
-#ifdef VBOX /* Enable the use of VBox formatting types. */
-        RTStrPrintfV(buff, sizeof(buff), fmt, argptr);
-#else
-        // Use safer NS_ functions.
-        PR_vsnprintf(buff, sizeof(buff), fmt, argptr);
-#endif
-
-        LogMessage(methodName, buff);
-}
-
-PRBool PyXPCOM_FormatCurrentException(nsCString &streamout)
-{
-        PRBool ok = PR_FALSE;
+    char buff[512];
+    RTStrPrintfV(buff, sizeof(buff), fmt, argptr);
+
+    LogMessage(methodName, buff);
+}
+
+bool PyXPCOM_FormatCurrentException(nsCString &streamout)
+{
+        bool ok = false;
         PyObject *exc_typ = NULL, *exc_val = NULL, *exc_tb = NULL;
         PyErr_Fetch( &exc_typ, &exc_val, &exc_tb);
@@ -177 +172 @@
 }
 
-PRBool PyXPCOM_FormatGivenException(nsCString &streamout,
+bool PyXPCOM_FormatGivenException(nsCString &streamout,
                                     PyObject *exc_typ, PyObject *exc_val,
                                     PyObject *exc_tb)
 {
         if (!exc_typ)
-                return PR_FALSE;
+                return false;
         streamout += "\n";
 
@@ -218 +213 @@
                         streamout += "Can't convert exception value to a string!";
         }
-        return PR_TRUE;
+        return true;
 }
 
@@ -232 +227 @@
         // traceback to be in the same buffer.
         char buff[512];
-        PR_vsnprintf(buff, sizeof(buff), fmt, marker);
+        RTStrPrintf2V(buff, sizeof(buff), fmt, marker);
         // If we have a Python exception, also log that:
         nsCAutoString streamout(buff);
@@ -287 +282 @@
                     nsXPIDLCString emsg;
                     ex->GetMessage(getter_Copies(emsg));
-                    PR_snprintf(msg, sizeof(msg), "%s",
-                                emsg.get());
+                    RTStrPrintf2(msg, sizeof(msg), "%s",
+                                 emsg.get());
                     gotMsg = true;
                 }
@@ -300 +295 @@
         if (strncmp(pMsg->pszMsgFull, "Unknown", 7) != 0)
         {
-            PR_snprintf(msg, sizeof(msg), "%s (%s)",
-                        pMsg->pszMsgFull, pMsg->pszDefine);
+            RTStrPrintf2(msg, sizeof(msg), "%s (%s)",
+                         pMsg->pszMsgFull, pMsg->pszDefine);
             gotMsg = true;
         }
@@ -308 +303 @@
     if (!gotMsg)
     {
-        PR_snprintf(msg, sizeof(msg), "Error 0x%x in module 0x%x",
-                    NS_ERROR_GET_CODE(r), NS_ERROR_GET_MODULE(r));
+        RTStrPrintf2(msg, sizeof(msg), "Error 0x%x in module 0x%x",
+                     NS_ERROR_GET_CODE(r), NS_ERROR_GET_MODULE(r));
     }
     PyObject *evalue = Py_BuildValue("is", r, msg);

trunk/src/libs/xpcom18a4/python/src/PyGBase.cpp

@@ -52 +52 @@
 #include <nsIInputStream.h>
 
-static PRInt32 cGateways = 0;
-PRInt32 _PyXPCOM_GetGatewayCount(void)
+#include <iprt/asm.h>
+
+static uint32_t cGateways = 0;
+uint32_t _PyXPCOM_GetGatewayCount(void)
 {
         return cGateways;
@@ -95 +97 @@
 {
         // Note that "instance" is the _policy_ instance!!
-        PR_AtomicIncrement(&cGateways);
+        ASMAtomicIncU32(&cGateways);
         m_pBaseObject = GetDefaultGateway(instance);
         // m_pWeakRef is an nsCOMPtr and needs no init.
@@ -160 +162 @@
 PyG_Base::~PyG_Base()
 {
-        PR_AtomicDecrement(&cGateways);
+        ASMAtomicDecU32(&cGateways);
 #ifdef DEBUG_LIFETIMES
         PYXPCOM_LOG_DEBUG("PyG_Base: deleted %p", this);
@@ -422 +424 @@
 PyG_Base::AddRef(void)
 {
-        nsrefcnt cnt = (nsrefcnt) PR_AtomicIncrement((PRInt32*)&mRefCnt);
+        nsrefcnt cnt = (nsrefcnt) ASMAtomicIncS32((volatile int32_t*)&mRefCnt);
 #ifdef NS_BUILD_REFCNT_LOGGING
         // If we have no pBaseObject, then we need to ignore them
@@ -434 +436 @@
 PyG_Base::Release(void)
 {
-        nsrefcnt cnt = (nsrefcnt) PR_AtomicDecrement((PRInt32*)&mRefCnt);
+        nsrefcnt cnt = (nsrefcnt) ASMAtomicDecS32((volatile int32_t*)&mRefCnt);
 #ifdef NS_BUILD_REFCNT_LOGGING
         if (m_pBaseObject == NULL)

trunk/src/libs/xpcom18a4/python/src/PyISupports.cpp

@@ -49 +49 @@
 #include "nsISupportsPrimitives.h"
 
-static PRInt32 cInterfaces=0;
+#include <iprt/asm.h>
+
+static volatile uint32_t cInterfaces=0;
 static PyObject *g_obFuncMakeInterfaceCount = NULL; // XXX - never released!!!
 
@@ -123 +125 @@
 }
 
-PRInt32
+uint32_t
 _PyXPCOM_GetInterfaceCount(void)
 {
-        return cInterfaces;
+    return ASMAtomicReadU32(&cInterfaces);
 }
 
@@ -144 +146 @@
         m_iid = iid;
         // refcnt of object managed by caller.
-        PR_AtomicIncrement(&cInterfaces);
+        ASMAtomicIncU32(&cInterfaces);
         PyXPCOM_DLLAddRef();
 #if 1 /* VBox: Must use for 3.9+, includes _Py_NewReferences. Works for all older versions too. @bugref{10079} */
@@ -172 +174 @@
 
         SafeRelease(this);
-        PR_AtomicDecrement(&cInterfaces);
+        ASMAtomicDecU32(&cInterfaces);
         PyXPCOM_DLLRelease();
 }

trunk/src/libs/xpcom18a4/python/src/PyXPCOM.h

@@ -298 +298 @@
 
 // Write current exception and traceback to a string.
-PYXPCOM_EXPORT PRBool PyXPCOM_FormatCurrentException(nsCString &streamout);
+PYXPCOM_EXPORT bool PyXPCOM_FormatCurrentException(nsCString &streamout);
 // Write specified exception and traceback to a string.
-PYXPCOM_EXPORT PRBool PyXPCOM_FormatGivenException(nsCString &streamout,
+PYXPCOM_EXPORT bool PyXPCOM_FormatGivenException(nsCString &streamout,
                                 PyObject *exc_typ, PyObject *exc_val,
                                 PyObject *exc_tb);
@@ -749 +749 @@
 extern PYXPCOM_EXPORT void AddDefaultGateway(PyObject *instance, nsISupports *gateway);
 
-extern PYXPCOM_EXPORT PRInt32 _PyXPCOM_GetGatewayCount(void);
-extern PYXPCOM_EXPORT PRInt32 _PyXPCOM_GetInterfaceCount(void);
+extern PYXPCOM_EXPORT uint32_t _PyXPCOM_GetGatewayCount(void);
+extern PYXPCOM_EXPORT uint32_t _PyXPCOM_GetInterfaceCount(void);
 #ifdef VBOX_DEBUG_LIFETIMES
 extern PYXPCOM_EXPORT PRInt32 _PyXPCOM_DumpInterfaces(void);
@@ -877 +877 @@
 PYXPCOM_EXPORT PRBool PyXPCOM_Globals_Ensure();
 
-// For 2.3, use the PyGILState_ calls
-#if (PY_VERSION_HEX >= 0x02030000)
-#define PYXPCOM_USE_PYGILSTATE
-#endif
-
-#ifdef PYXPCOM_USE_PYGILSTATE
 class CEnterLeavePython {
 public:
@@ -902 +896 @@
         PyGILState_STATE state;
 };
-#else
-
-extern PYXPCOM_EXPORT PyInterpreterState *PyXPCOM_InterpreterState;
-PYXPCOM_EXPORT PRBool PyXPCOM_ThreadState_Ensure();
-PYXPCOM_EXPORT void PyXPCOM_ThreadState_Free();
-PYXPCOM_EXPORT void PyXPCOM_ThreadState_Clear();
-PYXPCOM_EXPORT void PyXPCOM_InterpreterLock_Acquire();
-PYXPCOM_EXPORT void PyXPCOM_InterpreterLock_Release();
-
-// Pre 2.3 thread-state dances.
-class CEnterLeavePython {
-public:
-        CEnterLeavePython() {
-                created = PyXPCOM_ThreadState_Ensure();
-                PyXPCOM_InterpreterLock_Acquire();
-                if (created) {
-                        // If pending python calls are waiting as we enter Python,
-                        // it will generally mean an asynch signal handler, etc.
-                        // We can either call it here, or wait for Python to call it
-                        // as part of its "even 'n' opcodes" check.  If we wait for
-                        // Python to check it and the pending call raises an exception,
-                        // then it is _our_ code that will fail - this is unfair,
-                        // as the signal was raised before we were entered - indeed,
-                        // we may be directly responding to the signal!
-                        // Thus, we flush all the pending calls here, and report any
-                        // exceptions via our normal exception reporting mechanism.
-                        // We can then execute our code in the knowledge that only
-                        // signals raised _while_ we are executing will cause exceptions.
-                        PyXPCOM_MakePendingCalls();
-                }
-        }
-        ~CEnterLeavePython() {
-        // The interpreter state must be cleared
-        // _before_ we release the lock, as some of
-        // the sys. attributes cleared (eg, the current exception)
-        // may need the lock to invoke their destructors -
-        // specifically, when exc_value is a class instance, and
-        // the exception holds the last reference!
-                if ( created )
-                        PyXPCOM_ThreadState_Clear();
-                PyXPCOM_InterpreterLock_Release();
-                if ( created )
-                        PyXPCOM_ThreadState_Free();
-        }
-private:
-        PRBool created;
-};
-#endif // PYXPCOM_USE_PYGILSTATE
 
 // Our classes.

trunk/src/libs/xpcom18a4/python/src/dllmain.cpp

@@ -49 +49 @@
 #include "nsILocalFile.h"
 
+#include <iprt/asm.h>
+#include <iprt/errcore.h>
+#include <iprt/semaphore.h>
+
 #ifdef XP_WIN
 #ifndef WIN32_LEAN_AND_MEAN
@@ -56 +60 @@
 #endif
 
-static PRInt32 g_cLockCount = 0;
-static PRLock *g_lockMain = nsnull;
+static volatile uint32_t g_cLockCount = 0;
+static RTSEMFASTMUTEX    g_lockMain = NULL;
 
 PYXPCOM_EXPORT PyObject *PyXPCOM_Error = NULL;
@@ -72 +76 @@
 PyXPCOM_INTERFACE_DEFINE(Py_nsIComponentManagerObsolete, nsIComponentManagerObsolete, PyMethods_IComponentManagerObsolete)
 
-#ifndef PYXPCOM_USE_PYGILSTATE
-
-////////////////////////////////////////////////////////////
-// Thread-state helpers/global functions.
-// Only used if there is no Python PyGILState_* API
-//
-static PyThreadState *ptsGlobal = nsnull;
-PyInterpreterState *PyXPCOM_InterpreterState = nsnull;
-PRUintn tlsIndex = 0;
-
-
-// This function must be called at some time when the interpreter lock and state is valid.
-// Called by init{module} functions and also COM factory entry point.
-void PyXPCOM_InterpreterState_Ensure()
-{
-        if (PyXPCOM_InterpreterState==NULL) {
-                PyThreadState *threadStateSave = PyThreadState_Swap(NULL);
-                if (threadStateSave==NULL)
-                        Py_FatalError("Can not setup interpreter state, as current state is invalid");
-
-                PyXPCOM_InterpreterState = threadStateSave->interp;
-                PyThreadState_Swap(threadStateSave);
-        }
-}
-
-void PyXPCOM_InterpreterState_Free()
-{
-        PyXPCOM_ThreadState_Free();
-        PyXPCOM_InterpreterState = NULL; // Eek - should I be freeing something?
-}
-
-// This structure is stored in the TLS slot.  At this stage only a Python thread state
-// is kept, but this may change in the future...
-struct ThreadData{
-        PyThreadState *ts;
-};
-
-// Ensure that we have a Python thread state available to use.
-// If this is called for the first time on a thread, it will allocate
-// the thread state.  This does NOT change the state of the Python lock.
-// Returns TRUE if a new thread state was created, or FALSE if a
-// thread state already existed.
-PRBool PyXPCOM_ThreadState_Ensure()
-{
-        ThreadData *pData = (ThreadData *)PR_GetThreadPrivate(tlsIndex);
-        if (pData==NULL) { /* First request on this thread */
-                /* Check we have an interpreter state */
-                if (PyXPCOM_InterpreterState==NULL) {
-                                Py_FatalError("Can not setup thread state, as have no interpreter state");
-                }
-                pData = (ThreadData *)nsMemory::Alloc(sizeof(ThreadData));
-                if (!pData)
-                        Py_FatalError("Out of memory allocating thread state.");
-                memset(pData, 0, sizeof(*pData));
-                if (NS_FAILED( PR_SetThreadPrivate( tlsIndex, pData ) ) ) {
-                        NS_ABORT_IF_FALSE(0, "Could not create thread data for this thread!");
-                        Py_FatalError("Could not thread private thread data!");
-                }
-                pData->ts = PyThreadState_New(PyXPCOM_InterpreterState);
-                return PR_TRUE; // Did create a thread state state
-        }
-        return PR_FALSE; // Thread state was previously created
-}
-
-// Asuming we have a valid thread state, acquire the Python lock.
-void PyXPCOM_InterpreterLock_Acquire()
-{
-        ThreadData *pData = (ThreadData *)PR_GetThreadPrivate(tlsIndex);
-        NS_ABORT_IF_FALSE(pData, "Have no thread data for this thread!");
-        PyThreadState *thisThreadState = pData->ts;
-        PyEval_AcquireThread(thisThreadState);
-}
-
-// Asuming we have a valid thread state, release the Python lock.
-void PyXPCOM_InterpreterLock_Release()
-{
-        ThreadData *pData = (ThreadData *)PR_GetThreadPrivate(tlsIndex);
-        NS_ABORT_IF_FALSE(pData, "Have no thread data for this thread!");
-        PyThreadState *thisThreadState = pData->ts;
-        PyEval_ReleaseThread(thisThreadState);
-}
-
-// Free the thread state for the current thread
-// (Presumably previously create with a call to
-// PyXPCOM_ThreadState_Ensure)
-void PyXPCOM_ThreadState_Free()
-{
-        ThreadData *pData = (ThreadData *)PR_GetThreadPrivate(tlsIndex);
-        if (!pData) return;
-        PyThreadState *thisThreadState = pData->ts;
-        PyThreadState_Delete(thisThreadState);
-        PR_SetThreadPrivate(tlsIndex, NULL);
-        nsMemory::Free(pData);
-}
-
-void PyXPCOM_ThreadState_Clear()
-{
-        ThreadData *pData = (ThreadData *)PR_GetThreadPrivate(tlsIndex);
-        PyThreadState *thisThreadState = pData->ts;
-        PyThreadState_Clear(thisThreadState);
-}
-#endif // PYXPCOM_USE_PYGILSTATE
-
 ////////////////////////////////////////////////////////////
 // Lock/exclusion global functions.
@@ -180 +81 @@
 void PyXPCOM_AcquireGlobalLock(void)
 {
-        NS_PRECONDITION(g_lockMain != nsnull, "Cant acquire a NULL lock!");
-        PR_Lock(g_lockMain);
+        NS_PRECONDITION(g_lockMain != NIL_RTSEMFASTMUTEX, "Cant acquire a NULL lock!");
+        RTSemFastMutexRequest(g_lockMain);
 }
 void PyXPCOM_ReleaseGlobalLock(void)
 {
-        NS_PRECONDITION(g_lockMain != nsnull, "Cant release a NULL lock!");
-        PR_Unlock(g_lockMain);
+        NS_PRECONDITION(g_lockMain != NIL_RTSEMFASTMUTEX, "Cant release a NULL lock!");
+        RTSemFastMutexRelease(g_lockMain);
 }
 
@@ -193 +94 @@
         // Must be thread-safe, although cant have the Python lock!
         CEnterLeaveXPCOMFramework _celf;
-        PRInt32 cnt = PR_AtomicIncrement(&g_cLockCount);
+        uint32_t cnt = ASMAtomicIncU32(&g_cLockCount);
         if (cnt==1) { // First call
                 if (!Py_IsInitialized()) {
@@ -219 +120 @@
                         PyEval_InitThreads();
 #endif
-#ifndef PYXPCOM_USE_PYGILSTATE
-                        // Release Python lock, as first thing we do is re-get it.
-                        ptsGlobal = PyEval_SaveThread();
-#endif
                         // NOTE: We never finalize Python!!
                 }
@@ -229 +126 @@
 void PyXPCOM_DLLRelease(void)
 {
-        PR_AtomicDecrement(&g_cLockCount);
+        ASMAtomicDecU32(&g_cLockCount);
 }
 
 void pyxpcom_construct(void)
 {
-        g_lockMain = PR_NewLock();
-#ifndef PYXPCOM_USE_PYGILSTATE
-        PRStatus status;
-        status = PR_NewThreadPrivateIndex( &tlsIndex, NULL );
-        NS_WARN_IF_FALSE(status==0, "Could not allocate TLS storage");
-        if (NS_FAILED(status)) {
-                PR_DestroyLock(g_lockMain);
-                return; // PR_FALSE;
-        }
-#endif // PYXPCOM_USE_PYGILSTATE
-        return; // PR_TRUE;
+    int vrc = RTSemFastMutexCreate(&g_lockMain);
+    if (RT_FAILURE(vrc))
+        return;
+
+    return; // PR_TRUE;
 }
 
 void pyxpcom_destruct(void)
 {
-        PR_DestroyLock(g_lockMain);
-#ifndef PYXPCOM_USE_PYGILSTATE
-        // I can't locate a way to kill this -
-        // should I pass a dtor to PR_NewThreadPrivateIndex??
-        // TlsFree(tlsIndex);
-#endif // PYXPCOM_USE_PYGILSTATE
+    RTSemFastMutexDestroy(g_lockMain);
 }
 
@@ -273 +159 @@
 {
         PRBool rc = PR_TRUE;
-
-#ifndef PYXPCOM_USE_PYGILSTATE
-        PyXPCOM_InterpreterState_Ensure();
-#endif
 
         // The exception object - we load it from .py code!

trunk/src/libs/xpcom18a4/python/src/module/_xpcom.cpp

@@ -69 +69 @@
 #define LOADER_LINKS_WITH_PYTHON
 
-#ifndef PYXPCOM_USE_PYGILSTATE
-extern PYXPCOM_EXPORT void PyXPCOM_InterpreterState_Ensure();
-#endif
-
 #ifdef VBOX_PYXPCOM
 # include <iprt/cdefs.h>