Ticket #6200: thread_eintr.patch

boost/thread/pthread/condition_variable.hpp

@@ -52 +52 @@
             thread_cv_detail::lock_on_exit<unique_lock<mutex> > guard;
             detail::interruption_checker check_for_interruption(&internal_mutex,&cond);
             guard.activate(m);
-            res=pthread_cond_wait(&cond,&internal_mutex);
+            int ret;
+            do {
+                ret = pthread_cond_wait(&cond,m.mutex()->native_handle());
+            } while (ret == EINTR);
         }
         this_thread::interruption_point();
         if(res)

boost/thread/pthread/condition_variable_fwd.hpp

@@ -44 +44 @@
         ~condition_variable()
         {
             BOOST_VERIFY(!pthread_mutex_destroy(&internal_mutex));
-            BOOST_VERIFY(!pthread_cond_destroy(&cond));
+            int ret;
+            do {
+                ret = pthread_cond_destroy(&cond);
+            } while (ret == EINTR);
         }
 
         void wait(unique_lock<mutex>& m);

boost/thread/pthread/mutex.hpp

@@ -44 +44 @@
         }
         ~mutex()
         {
-            BOOST_VERIFY(!pthread_mutex_destroy(&m));
+            int ret;
+            do {
+                ret = pthread_mutex_destroy(&m);
+            } while (ret == EINTR);
         }
         
         void lock()
         {
-            int const res=pthread_mutex_lock(&m);
-            if(res)
-            {
+            int res;
+            do {
+                res = pthread_mutex_lock(&m);
+            } while (res == EINTR);
+
+            if (res) {
                 boost::throw_exception(lock_error(res));
             }
         }
 
         void unlock()
         {
-            BOOST_VERIFY(!pthread_mutex_unlock(&m));
+            int ret;
+            do {
+                ret = pthread_mutex_unlock(&m);
+            } while (ret == EINTR);
+            BOOST_VERIFY(!ret);
         }
         
         bool try_lock()
         {
-            int const res=pthread_mutex_trylock(&m);
+            int res;
+            do {
+                res = pthread_mutex_trylock(&m);
+            } while (res == EINTR);
             if(res && (res!=EBUSY))
             {
                 boost::throw_exception(lock_error(res));