fix handling of errors in wxConditionInternal::Wait() and WaitTimeout() (#10111)

[wxWidgets.git] / src / unix / threadpsx.cpp

diff --git a/src/unix/threadpsx.cpp b/src/unix/threadpsx.cpp
index 1104048d4e6d09383331449c3ff80d22b691b63b..692be7d169bc96e1179749c0fc86f7b9268fd0fe 100644 (file)
--- a/src/unix/threadpsx.cpp
+++ b/src/unix/threadpsx.cpp
@@ -27,18 +27,19 @@
 #if wxUSE_THREADS
 
 #include "wx/thread.h"
 #if wxUSE_THREADS
 
 #include "wx/thread.h"

+#include "wx/except.h"

 
 #ifndef WX_PRECOMP
 
 #ifndef WX_PRECOMP

+    #include "wx/app.h"

     #include "wx/dynarray.h"
     #include "wx/intl.h"
     #include "wx/log.h"
     #include "wx/utils.h"
     #include "wx/timer.h"
     #include "wx/stopwatch.h"
     #include "wx/dynarray.h"
     #include "wx/intl.h"
     #include "wx/log.h"
     #include "wx/utils.h"
     #include "wx/timer.h"
     #include "wx/stopwatch.h"

+    #include "wx/module.h"

 #endif
 
 #endif
 

-#include "wx/module.h"
-

 #include <stdio.h>
 #include <unistd.h>
 #include <pthread.h>
 #include <stdio.h>
 #include <unistd.h>
 #include <pthread.h>


@@ -164,14 +165,21 @@ public:
     ~wxMutexInternal();
 
     wxMutexError Lock();
     ~wxMutexInternal();
 
     wxMutexError Lock();

+    wxMutexError Lock(unsigned long ms);

     wxMutexError TryLock();
     wxMutexError Unlock();
 
     bool IsOk() const { return m_isOk; }
 
     wxMutexError TryLock();
     wxMutexError Unlock();
 
     bool IsOk() const { return m_isOk; }
 

+private:
+    // convert the result of pthread_mutex_[timed]lock() call to wx return code
+    wxMutexError HandleLockResult(int err);
+

 private:
     pthread_mutex_t m_mutex;
     bool m_isOk;
 private:
     pthread_mutex_t m_mutex;
     bool m_isOk;

+    wxMutexType m_type;
+    unsigned long m_owningThread;

 
     // wxConditionInternal uses our m_mutex
     friend class wxConditionInternal;
 
     // wxConditionInternal uses our m_mutex
     friend class wxConditionInternal;


@@ -186,6 +194,9 @@ extern "C" int pthread_mutexattr_settype(pthread_mutexattr_t *, int);
 
 wxMutexInternal::wxMutexInternal(wxMutexType mutexType)
 {
 
 wxMutexInternal::wxMutexInternal(wxMutexType mutexType)
 {

+    m_type = mutexType;
+    m_owningThread = 0;
+

     int err;
     switch ( mutexType )
     {
     int err;
     switch ( mutexType )
     {


@@ -246,7 +257,69 @@ wxMutexInternal::~wxMutexInternal()
 
 wxMutexError wxMutexInternal::Lock()
 {
 
 wxMutexError wxMutexInternal::Lock()
 {

-    int err = pthread_mutex_lock(&m_mutex);
+    if ((m_type == wxMUTEX_DEFAULT) && (m_owningThread != 0))
+    {
+        if (m_owningThread == wxThread::GetCurrentId())
+           return wxMUTEX_DEAD_LOCK;
+    }
+        
+    return HandleLockResult(pthread_mutex_lock(&m_mutex));
+}
+
+wxMutexError wxMutexInternal::Lock(unsigned long ms)
+{
+#ifdef HAVE_PTHREAD_MUTEX_TIMEDLOCK
+    static const long MSEC_IN_SEC   = 1000;
+    static const long NSEC_IN_MSEC  = 1000000;
+    static const long NSEC_IN_USEC  = 1000;
+    static const long NSEC_IN_SEC   = MSEC_IN_SEC * NSEC_IN_MSEC;
+
+    time_t seconds = ms/MSEC_IN_SEC;
+    long nanoseconds = (ms % MSEC_IN_SEC) * NSEC_IN_MSEC;
+    timespec ts = { 0, 0 };
+
+    // normally we should use clock_gettime(CLOCK_REALTIME) here but this
+    // function is in librt and we don't link with it currently, so use
+    // gettimeofday() instead -- if it turns out that this is really too
+    // imprecise, we should modify configure to check if clock_gettime() is
+    // available and whether it requires -lrt and use it instead
+#if 0
+    if ( clock_gettime(CLOCK_REALTIME, &ts) == 0 )
+    {
+    }
+#else
+    struct timeval tv;
+    if ( wxGetTimeOfDay(&tv) != -1 )
+    {
+        ts.tv_sec = tv.tv_sec;
+        ts.tv_nsec = tv.tv_usec*NSEC_IN_USEC;
+    }
+#endif
+    else // fall back on system timer
+    {
+        ts.tv_sec = time(NULL);
+    }
+
+    ts.tv_sec += seconds;
+    ts.tv_nsec += nanoseconds;
+    if ( ts.tv_nsec > NSEC_IN_SEC )
+    {
+        ts.tv_sec += 1;
+        ts.tv_nsec -= NSEC_IN_SEC;
+    }
+
+    return HandleLockResult(pthread_mutex_timedlock(&m_mutex, &ts));
+#else // !HAVE_PTHREAD_MUTEX_TIMEDLOCK
+    wxUnusedVar(ms);
+
+    return wxMUTEX_MISC_ERROR;
+#endif // HAVE_PTHREAD_MUTEX_TIMEDLOCK/!HAVE_PTHREAD_MUTEX_TIMEDLOCK
+}
+
+wxMutexError wxMutexInternal::HandleLockResult(int err)
+{
+    // wxPrintf( "err %d\n", err );
+

     switch ( err )
     {
         case EDEADLK:
     switch ( err )
     {
         case EDEADLK:


@@ -256,19 +329,25 @@ wxMutexError wxMutexInternal::Lock()
             return wxMUTEX_DEAD_LOCK;
 
         case EINVAL:
             return wxMUTEX_DEAD_LOCK;
 
         case EINVAL:

-            wxLogDebug(_T("pthread_mutex_lock(): mutex not initialized."));
+            wxLogDebug(_T("pthread_mutex_[timed]lock(): mutex not initialized"));

             break;
 
             break;
 

+        case ETIMEDOUT:
+            return wxMUTEX_TIMEOUT;
+

         case 0:
         case 0:

+            if (m_type == wxMUTEX_DEFAULT)
+                m_owningThread = wxThread::GetCurrentId();

             return wxMUTEX_NO_ERROR;
 
         default:
             return wxMUTEX_NO_ERROR;
 
         default:

-            wxLogApiError(_T("pthread_mutex_lock()"), err);
+            wxLogApiError(_T("pthread_mutex_[timed]lock()"), err);

     }
 
     return wxMUTEX_MISC_ERROR;
 }
 
     }
 
     return wxMUTEX_MISC_ERROR;
 }
 

+

 wxMutexError wxMutexInternal::TryLock()
 {
     int err = pthread_mutex_trylock(&m_mutex);
 wxMutexError wxMutexInternal::TryLock()
 {
     int err = pthread_mutex_trylock(&m_mutex);


@@ -284,6 +363,8 @@ wxMutexError wxMutexInternal::TryLock()
             break;
 
         case 0:
             break;
 
         case 0:

+            if (m_type == wxMUTEX_DEFAULT)
+                m_owningThread = wxThread::GetCurrentId();

             return wxMUTEX_NO_ERROR;
 
         default:
             return wxMUTEX_NO_ERROR;
 
         default:


@@ -295,6 +376,8 @@ wxMutexError wxMutexInternal::TryLock()
 
 wxMutexError wxMutexInternal::Unlock()
 {
 
 wxMutexError wxMutexInternal::Unlock()
 {

+    m_owningThread = 0;
+                

     int err = pthread_mutex_unlock(&m_mutex);
     switch ( err )
     {
     int err = pthread_mutex_unlock(&m_mutex);
     switch ( err )
     {


@@ -764,11 +847,15 @@ void *wxThreadInternal::PthreadStart(wxThread *thread)
                    _T("Thread %ld about to enter its Entry()."),
                    THR_ID(pthread));
 
                    _T("Thread %ld about to enter its Entry()."),
                    THR_ID(pthread));
 

-        pthread->m_exitcode = thread->Entry();
+        wxTRY
+        {
+            pthread->m_exitcode = thread->Entry();

 
 

-        wxLogTrace(TRACE_THREADS,
-                   _T("Thread %ld Entry() returned %lu."),
-                   THR_ID(pthread), wxPtrToUInt(pthread->m_exitcode));
+            wxLogTrace(TRACE_THREADS,
+                       _T("Thread %ld Entry() returned %lu."),
+                       THR_ID(pthread), wxPtrToUInt(pthread->m_exitcode));
+        }
+        wxCATCH_ALL( wxTheApp->OnUnhandledException(); )

 
         {
             wxCriticalSectionLocker lock(thread->m_critsect);
 
         {
             wxCriticalSectionLocker lock(thread->m_critsect);


@@ -982,14 +1069,16 @@ void wxThread::Yield()
 #endif
 }
 
 #endif
 }
 

-void wxThread::Sleep(unsigned long milliseconds)
-{
-    wxMilliSleep(milliseconds);
-}
-

 int wxThread::GetCPUCount()
 {
 int wxThread::GetCPUCount()
 {

-#if defined(__LINUX__) && wxUSE_FFILE
+#if defined(_SC_NPROCESSORS_ONLN)
+    // this works for Solaris and Linux 2.6
+    int rc = sysconf(_SC_NPROCESSORS_ONLN);
+    if ( rc != -1 )
+    {
+        return rc;
+    }
+#elif defined(__LINUX__) && wxUSE_FFILE

     // read from proc (can't use wxTextFile here because it's a special file:
     // it has 0 size but still can be read from)
     wxLogNull nolog;
     // read from proc (can't use wxTextFile here because it's a special file:
     // it has 0 size but still can be read from)
     wxLogNull nolog;


@@ -1015,13 +1104,6 @@ int wxThread::GetCPUCount()
             wxLogDebug(_T("failed to read /proc/cpuinfo"));
         }
     }
             wxLogDebug(_T("failed to read /proc/cpuinfo"));
         }
     }

-#elif defined(_SC_NPROCESSORS_ONLN)
-    // this works for Solaris
-    int rc = sysconf(_SC_NPROCESSORS_ONLN);
-    if ( rc != -1 )
-    {
-        return rc;
-    }

 #endif // different ways to get number of CPUs
 
     // unknown
 #endif // different ways to get number of CPUs
 
     // unknown


@@ -1249,7 +1331,7 @@ void wxThread::SetPriority(unsigned int prio)
 
             // map wx priorites WXTHREAD_MIN_PRIORITY..WXTHREAD_MAX_PRIORITY
             // to Unix priorities 20..-20
 
             // map wx priorites WXTHREAD_MIN_PRIORITY..WXTHREAD_MAX_PRIORITY
             // to Unix priorities 20..-20

-            if ( setpriority(PRIO_PROCESS, 0, -(2*prio)/5 + 20) == -1 )
+            if ( setpriority(PRIO_PROCESS, 0, -(2*(int)prio)/5 + 20) == -1 )

             {
                 wxLogError(_("Failed to set thread priority %d."), prio);
             }
             {
                 wxLogError(_("Failed to set thread priority %d."), prio);
             }


@@ -1480,7 +1562,11 @@ void wxThread::Exit(ExitCode status)
     // might deadlock if, for example, it signals a condition in OnExit() (a
     // common case) while the main thread calls any of functions entering
     // m_critsect on us (almost all of them do)
     // might deadlock if, for example, it signals a condition in OnExit() (a
     // common case) while the main thread calls any of functions entering
     // m_critsect on us (almost all of them do)

-    OnExit();
+    wxTRY
+    {
+        OnExit();
+    }
+    wxCATCH_ALL( wxTheApp->OnUnhandledException(); )

 
     // delete C++ thread object if this is a detached thread - user is
     // responsible for doing this for joinable ones
 
     // delete C++ thread object if this is a detached thread - user is
     // responsible for doing this for joinable ones


@@ -1702,7 +1788,7 @@ static void ScheduleThreadForDeletion()
 
     wxLogTrace(TRACE_THREADS, _T("%lu thread%s waiting to be deleted"),
                (unsigned long)gs_nThreadsBeingDeleted,
 
     wxLogTrace(TRACE_THREADS, _T("%lu thread%s waiting to be deleted"),
                (unsigned long)gs_nThreadsBeingDeleted,

-               gs_nThreadsBeingDeleted == 1 ? "" : "s");
+               gs_nThreadsBeingDeleted == 1 ? _T("") : _T("s"));

 }
 
 static void DeleteThread(wxThread *This)
 }
 
 static void DeleteThread(wxThread *This)


@@ -1728,12 +1814,12 @@ static void DeleteThread(wxThread *This)
     }
 }
 
     }
 }
 

-void wxMutexGuiEnter()
+void wxMutexGuiEnterImpl()

 {
     gs_mutexGui->Lock();
 }
 
 {
     gs_mutexGui->Lock();
 }
 

-void wxMutexGuiLeave()
+void wxMutexGuiLeaveImpl()

 {
     gs_mutexGui->Unlock();
 }
 {
     gs_mutexGui->Unlock();
 }