apr_{thread,proc,global}_timedlock() with negative timeout is now equivalent

to apr_{thread,proc,global}_trylock(), i.e. immediate attempt to acquire the
lock (but returning APR_TIMEUP if busy).



git-svn-id: https://svn.apache.org/repos/asf/apr/apr/trunk@1790632 13f79535-47bb-0310-9956-ffa450edef68

2 files changed, 43 insertions, 65 deletions

diff --git a/locks/unix/proc_mutex.c b/locks/unix/proc_mutex.c
index d49bfe10c..8b576a890 100644
--- a/locks/unix/proc_mutex.c
+++ b/locks/unix/proc_mutex.c
@@ -62,32 +62,27 @@ static apr_status_t proc_mutex_no_perms_set(apr_proc_mutex_t *mutex,
 static apr_status_t proc_mutex_spinsleep_timedacquire(apr_proc_mutex_t *mutex,
                                                   apr_interval_time_t timeout)
 {
-    apr_status_t rv;
-    if (timeout < 0) {
-        rv = apr_proc_mutex_lock(mutex);
-    }
-    else {
 #define SLEEP_TIME apr_time_from_msec(10)
-        for (;;) {
-            rv = apr_proc_mutex_trylock(mutex);
-            if (!APR_STATUS_IS_EBUSY(rv)) {
-                if (rv == APR_SUCCESS) {
-                    mutex->curr_locked = 1;
-                }
-                break;
-            }
-            if (!timeout) {
-                rv = APR_TIMEUP;
-                break;
-            }
-            if (timeout > SLEEP_TIME) {
-                apr_sleep(SLEEP_TIME);
-                timeout -= SLEEP_TIME;
-            }
-            else {
-                apr_sleep(timeout);
-                timeout = 0;
+    apr_status_t rv;
+    for (;;) {
+        rv = apr_proc_mutex_trylock(mutex);
+        if (!APR_STATUS_IS_EBUSY(rv)) {
+            if (rv == APR_SUCCESS) {
+                mutex->curr_locked = 1;
             }
+            break;
+        }
+        if (timeout <= 0) {
+            rv = APR_TIMEUP;
+            break;
+        }
+        if (timeout > SLEEP_TIME) {
+            apr_sleep(SLEEP_TIME);
+            timeout -= SLEEP_TIME;
+        }
+        else {
+            apr_sleep(timeout);
+            timeout = 0;
         }
     }
     return rv;
@@ -224,10 +219,7 @@ static apr_status_t proc_mutex_posix_tryacquire(apr_proc_mutex_t *mutex)
 static apr_status_t proc_mutex_posix_timedacquire(apr_proc_mutex_t *mutex,
                                               apr_interval_time_t timeout)
 {
-    if (timeout < 0) {
-        return proc_mutex_posix_acquire(mutex);
-    }
-    else if (!timeout) {
+    if (timeout <= 0) {
         apr_status_t rv = proc_mutex_posix_tryacquire(mutex);
         return (rv == APR_EBUSY) ? APR_TIMEUP : rv;
     }
@@ -382,10 +374,7 @@ static apr_status_t proc_mutex_sysv_tryacquire(apr_proc_mutex_t *mutex)
 static apr_status_t proc_mutex_sysv_timedacquire(apr_proc_mutex_t *mutex,
                                              apr_interval_time_t timeout)
 {
-    if (timeout < 0) {
-        return proc_mutex_sysv_acquire(mutex);
-    }
-    else if (!timeout) {
+    if (timeout <= 0) {
         apr_status_t rv = proc_mutex_sysv_tryacquire(mutex);
         return (rv == APR_EBUSY) ? APR_TIMEUP : rv;
     }
@@ -509,9 +498,6 @@ typedef struct {
 } proc_pthread_mutex_t;
 
 
-static apr_status_t proc_mutex_pthread_timedacquire(apr_proc_mutex_t *mutex,
-                                                apr_interval_time_t timeout);
-
 static APR_INLINE int proc_pthread_mutex_inc(apr_proc_mutex_t *mutex)
 {
     if (mutex->pthread_refcounting) {
@@ -690,19 +676,8 @@ static apr_status_t proc_mutex_pthread_child_init(apr_proc_mutex_t **mutex,
     return APR_SUCCESS;
 }
 
-static apr_status_t proc_mutex_pthread_acquire(apr_proc_mutex_t *mutex)
-{
-    return proc_mutex_pthread_timedacquire(mutex, -1);
-}
-
-static apr_status_t proc_mutex_pthread_tryacquire(apr_proc_mutex_t *mutex)
-{
-    apr_status_t rv = proc_mutex_pthread_timedacquire(mutex, 0);
-    return (rv == APR_TIMEUP) ? APR_EBUSY : rv;
-}
-
-static apr_status_t proc_mutex_pthread_timedacquire(apr_proc_mutex_t *mutex,
-                                                apr_interval_time_t timeout)
+static apr_status_t proc_mutex_pthread_acquire_ex(apr_proc_mutex_t *mutex,
+                                                  apr_interval_time_t timeout)
 {
 #if !APR_USE_PROC_PTHREAD_MUTEX_COND && !defined(HAVE_PTHREAD_MUTEX_TIMEDLOCK)
     return proc_mutex_spinsleep_timedacquire(mutex, timeout);
@@ -834,6 +809,23 @@ static apr_status_t proc_mutex_pthread_timedacquire(apr_proc_mutex_t *mutex,
 #endif
 }
 
+static apr_status_t proc_mutex_pthread_acquire(apr_proc_mutex_t *mutex)
+{
+    return proc_mutex_pthread_acquire_ex(mutex, -1);
+}
+
+static apr_status_t proc_mutex_pthread_tryacquire(apr_proc_mutex_t *mutex)
+{
+    apr_status_t rv = proc_mutex_pthread_acquire_ex(mutex, 0);
+    return (rv == APR_TIMEUP) ? APR_EBUSY : rv;
+}
+
+static apr_status_t proc_mutex_pthread_timedacquire(apr_proc_mutex_t *mutex,
+                                                apr_interval_time_t timeout)
+{
+    return proc_mutex_pthread_acquire_ex(mutex, (timeout <= 0) ? 0 : timeout);
+}
+
 static apr_status_t proc_mutex_pthread_release(apr_proc_mutex_t *mutex)
 {
     apr_status_t rv;
diff --git a/locks/unix/thread_mutex.c b/locks/unix/thread_mutex.c
index 6a26ff239..cf859e6ad 100644
--- a/locks/unix/thread_mutex.c
+++ b/locks/unix/thread_mutex.c
@@ -195,15 +195,7 @@ APR_DECLARE(apr_status_t) apr_thread_mutex_timedlock(apr_thread_mutex_t *mutex,
     apr_status_t rv = APR_ENOTIMPL;
 
 #ifdef HAVE_PTHREAD_MUTEX_TIMEDLOCK
-    if (timeout < 0) {
-        rv = pthread_mutex_lock(&mutex->mutex);
-#ifdef HAVE_ZOS_PTHREADS
-        if (rv) {
-            rv = errno;
-        }
-#endif
-    }
-    else if (!timeout) {
+    if (timeout <= 0) {
         rv = pthread_mutex_trylock(&mutex->mutex);
         if (rv) {
 #ifdef HAVE_ZOS_PTHREADS
@@ -244,18 +236,12 @@ APR_DECLARE(apr_status_t) apr_thread_mutex_timedlock(apr_thread_mutex_t *mutex,
         }
 
         if (mutex->locked) {
-            if (!timeout) {
+            if (timeout <= 0) {
                 rv = APR_TIMEUP;
             }
             else {
                 mutex->num_waiters++;
-                if (timeout < 0) {
-                    rv = apr_thread_cond_wait(mutex->cond, mutex);
-                }
-                else {
-                    rv = apr_thread_cond_timedwait(mutex->cond, mutex,
-                                                   timeout);
-                }
+                rv = apr_thread_cond_timedwait(mutex->cond, mutex, timeout);
 #ifdef HAVE_ZOS_PTHREADS
                 if (rv) {
                     rv = errno;