Adding upstream version 1.7.2.upstream/1.7.2

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

4 files changed, 829 insertions, 0 deletions

diff --git a/locks/win32/proc_mutex.c b/locks/win32/proc_mutex.c
new file mode 100644
index 0000000..e132e20
--- /dev/null
+++ b/locks/win32/proc_mutex.c
@@ -0,0 +1,301 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "apr.h"
+#include "apr_private.h"
+#include "apr_general.h"
+#include "apr_strings.h"
+#include "apr_portable.h"
+#include "apr_arch_file_io.h"
+#include "apr_arch_proc_mutex.h"
+#include "apr_arch_misc.h"
+
+static apr_status_t proc_mutex_cleanup(void *mutex_)
+{
+    apr_proc_mutex_t *mutex = mutex_;
+
+    if (mutex->handle) {
+        if (CloseHandle(mutex->handle) == 0) {
+            return apr_get_os_error();
+        }
+    }
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_proc_mutex_create(apr_proc_mutex_t **mutex,
+                                                const char *fname,
+                                                apr_lockmech_e mech,
+                                                apr_pool_t *pool)
+{
+    HANDLE hMutex;
+    void *mutexkey;
+
+    if (mech != APR_LOCK_DEFAULT && mech != APR_LOCK_DEFAULT_TIMED) {
+        return APR_ENOTIMPL;
+    }
+
+    /* res_name_from_filename turns fname into a pseduo-name
+     * without slashes or backslashes, and prepends the \global
+     * prefix on Win2K and later
+     */
+    if (fname) {
+        mutexkey = res_name_from_filename(fname, 1, pool);
+    }
+    else {
+        mutexkey = NULL;
+    }
+
+#if APR_HAS_UNICODE_FS
+    IF_WIN_OS_IS_UNICODE
+    {
+        hMutex = CreateMutexW(NULL, FALSE, mutexkey);
+    }
+#endif
+#if APR_HAS_ANSI_FS
+    ELSE_WIN_OS_IS_ANSI
+    {
+        hMutex = CreateMutexA(NULL, FALSE, mutexkey);
+    }
+#endif
+
+    if (!hMutex) {
+        return apr_get_os_error();
+    }
+
+    *mutex = (apr_proc_mutex_t *)apr_palloc(pool, sizeof(apr_proc_mutex_t));
+    (*mutex)->pool = pool;
+    (*mutex)->handle = hMutex;
+    (*mutex)->fname = fname;
+    apr_pool_cleanup_register((*mutex)->pool, *mutex, 
+                              proc_mutex_cleanup, apr_pool_cleanup_null);
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_proc_mutex_child_init(apr_proc_mutex_t **mutex,
+                                                    const char *fname,
+                                                    apr_pool_t *pool)
+{
+    HANDLE hMutex;
+    void *mutexkey;
+
+    if (!fname) {
+        /* Reinitializing unnamed mutexes is a noop in the Unix code. */
+        return APR_SUCCESS;
+    }
+
+    /* res_name_from_filename turns file into a pseudo-name
+     * without slashes or backslashes, and prepends the \global
+     * prefix on Win2K and later
+     */
+    mutexkey = res_name_from_filename(fname, 1, pool);
+
+#if defined(_WIN32_WCE)
+    hMutex = CreateMutex(NULL, FALSE, mutexkey);
+    if (hMutex && ERROR_ALREADY_EXISTS != GetLastError()) {
+        CloseHandle(hMutex);
+        hMutex = NULL;
+        SetLastError(ERROR_FILE_NOT_FOUND);
+    }
+#else
+#if APR_HAS_UNICODE_FS
+    IF_WIN_OS_IS_UNICODE
+    {
+        hMutex = OpenMutexW(MUTEX_ALL_ACCESS, FALSE, mutexkey);
+    }
+#endif
+#if APR_HAS_ANSI_FS
+    ELSE_WIN_OS_IS_ANSI
+    {
+        hMutex = OpenMutexA(MUTEX_ALL_ACCESS, FALSE, mutexkey);
+    }
+#endif
+#endif
+
+    if (!hMutex) {
+        return apr_get_os_error();
+    }
+
+    *mutex = (apr_proc_mutex_t *)apr_palloc(pool, sizeof(apr_proc_mutex_t));
+    (*mutex)->pool = pool;
+    (*mutex)->handle = hMutex;
+    (*mutex)->fname = fname;
+    apr_pool_cleanup_register((*mutex)->pool, *mutex, 
+                              proc_mutex_cleanup, apr_pool_cleanup_null);
+    return APR_SUCCESS;
+}
+    
+APR_DECLARE(apr_status_t) apr_proc_mutex_lock(apr_proc_mutex_t *mutex)
+{
+    DWORD rv;
+
+    rv = WaitForSingleObject(mutex->handle, INFINITE);
+
+    if (rv == WAIT_OBJECT_0 || rv == WAIT_ABANDONED) {
+        return APR_SUCCESS;
+    }
+    return apr_get_os_error();
+}
+
+APR_DECLARE(apr_status_t) apr_proc_mutex_trylock(apr_proc_mutex_t *mutex)
+{
+    DWORD rv;
+
+    rv = WaitForSingleObject(mutex->handle, 0);
+
+    if (rv == WAIT_OBJECT_0 || rv == WAIT_ABANDONED) {
+        return APR_SUCCESS;
+    } 
+    else if (rv == WAIT_TIMEOUT) {
+        return APR_EBUSY;
+    }
+    return apr_get_os_error();
+}
+
+APR_DECLARE(apr_status_t) apr_proc_mutex_timedlock(apr_proc_mutex_t *mutex,
+                                               apr_interval_time_t timeout)
+{
+    DWORD rv, timeout_ms = 0;
+    apr_interval_time_t t = timeout;
+
+    do {
+        if (t > 0) {
+            /* Given timeout is 64bit usecs whereas Windows timeouts are
+             * 32bit msecs and below INFINITE (2^32 - 1), so we may need
+             * multiple timed out waits...
+             */
+            if (t > apr_time_from_msec(INFINITE - 1)) {
+                timeout_ms = INFINITE - 1;
+                t -= apr_time_from_msec(INFINITE - 1);
+            }
+            else {
+                timeout_ms = (DWORD)apr_time_as_msec(t);
+                t = 0;
+            }
+        }
+        rv = WaitForSingleObject(mutex->handle, timeout_ms);
+    } while (rv == WAIT_TIMEOUT && t > 0);
+
+    if (rv == WAIT_TIMEOUT) {
+        return APR_TIMEUP;
+    }
+    if (rv == WAIT_OBJECT_0 || rv == WAIT_ABANDONED) {
+        return APR_SUCCESS;
+    } 
+    return apr_get_os_error();
+}
+
+APR_DECLARE(apr_status_t) apr_proc_mutex_unlock(apr_proc_mutex_t *mutex)
+{
+    if (ReleaseMutex(mutex->handle) == 0) {
+        return apr_get_os_error();
+    }
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_proc_mutex_destroy(apr_proc_mutex_t *mutex)
+{
+    apr_status_t stat;
+
+    stat = proc_mutex_cleanup(mutex);
+    if (stat == APR_SUCCESS) {
+        apr_pool_cleanup_kill(mutex->pool, mutex, proc_mutex_cleanup);
+    }
+    return stat;
+}
+
+APR_DECLARE(apr_status_t) apr_proc_mutex_cleanup(void *mutex)
+{
+    return apr_proc_mutex_destroy((apr_proc_mutex_t *)mutex);
+}
+
+APR_DECLARE(const char *) apr_proc_mutex_lockfile(apr_proc_mutex_t *mutex)
+{
+    return mutex->fname;
+}
+
+APR_DECLARE(apr_lockmech_e) apr_proc_mutex_mech(apr_proc_mutex_t *mutex)
+{
+    return APR_LOCK_DEFAULT;
+}
+
+APR_DECLARE(const char *) apr_proc_mutex_name(apr_proc_mutex_t *mutex)
+{
+    return apr_proc_mutex_defname();
+}
+
+APR_DECLARE(const char *) apr_proc_mutex_defname(void)
+{
+    return "win32mutex";
+}
+
+APR_PERMS_SET_ENOTIMPL(proc_mutex)
+
+APR_POOL_IMPLEMENT_ACCESSOR(proc_mutex)
+
+/* Implement OS-specific accessors defined in apr_portable.h */
+
+APR_DECLARE(apr_status_t) apr_os_proc_mutex_get_ex(apr_os_proc_mutex_t *ospmutex, 
+                                                   apr_proc_mutex_t *pmutex,
+                                                   apr_lockmech_e *mech)
+{
+    *ospmutex = pmutex->handle;
+    if (mech) {
+        *mech = APR_LOCK_DEFAULT;
+    }
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_os_proc_mutex_get(apr_os_proc_mutex_t *ospmutex,
+                                                apr_proc_mutex_t *pmutex)
+{
+    return apr_os_proc_mutex_get_ex(ospmutex, pmutex, NULL);
+}
+
+APR_DECLARE(apr_status_t) apr_os_proc_mutex_put_ex(apr_proc_mutex_t **pmutex,
+                                                apr_os_proc_mutex_t *ospmutex,
+                                                apr_lockmech_e mech,
+                                                int register_cleanup,
+                                                apr_pool_t *pool)
+{
+    if (pool == NULL) {
+        return APR_ENOPOOL;
+    }
+    if (mech != APR_LOCK_DEFAULT && mech != APR_LOCK_DEFAULT_TIMED) {
+        return APR_ENOTIMPL;
+    }
+
+    if ((*pmutex) == NULL) {
+        (*pmutex) = (apr_proc_mutex_t *)apr_palloc(pool,
+                                                   sizeof(apr_proc_mutex_t));
+        (*pmutex)->pool = pool;
+    }
+    (*pmutex)->handle = *ospmutex;
+
+    if (register_cleanup) {
+        apr_pool_cleanup_register(pool, *pmutex, proc_mutex_cleanup,
+                                  apr_pool_cleanup_null);
+    }
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_os_proc_mutex_put(apr_proc_mutex_t **pmutex,
+                                                apr_os_proc_mutex_t *ospmutex,
+                                                apr_pool_t *pool)
+{
+    return apr_os_proc_mutex_put_ex(pmutex, ospmutex, APR_LOCK_DEFAULT,
+                                    0, pool);
+}
+
diff --git a/locks/win32/thread_cond.c b/locks/win32/thread_cond.c
new file mode 100644
index 0000000..f571f9e
--- /dev/null
+++ b/locks/win32/thread_cond.c
@@ -0,0 +1,188 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "apr.h"
+#include "apr_private.h"
+#include "apr_general.h"
+#include "apr_strings.h"
+#include "apr_arch_thread_mutex.h"
+#include "apr_arch_thread_cond.h"
+#include "apr_portable.h"
+
+#include <limits.h>
+
+static apr_status_t thread_cond_cleanup(void *data)
+{
+    apr_thread_cond_t *cond = data;
+    CloseHandle(cond->semaphore);
+    DeleteCriticalSection(&cond->csection);
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_cond_create(apr_thread_cond_t **cond,
+                                                 apr_pool_t *pool)
+{
+    apr_thread_cond_t *cv;
+
+    cv = apr_pcalloc(pool, sizeof(**cond));
+    if (cv == NULL) {
+        return APR_ENOMEM;
+    }
+
+    cv->semaphore = CreateSemaphore(NULL, 0, LONG_MAX, NULL);
+    if (cv->semaphore == NULL) {
+        return apr_get_os_error();
+    }
+
+    *cond = cv;
+    cv->pool = pool;
+    InitializeCriticalSection(&cv->csection);
+    apr_pool_cleanup_register(cv->pool, cv, thread_cond_cleanup,
+                              apr_pool_cleanup_null);
+
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_cond_destroy(apr_thread_cond_t *cond)
+{
+    return apr_pool_cleanup_run(cond->pool, cond, thread_cond_cleanup);
+}
+
+static APR_INLINE apr_status_t thread_cond_timedwait(apr_thread_cond_t *cond,
+                                                     apr_thread_mutex_t *mutex,
+                                                     apr_interval_time_t timeout)
+{
+    DWORD res;
+    apr_status_t rv;
+    unsigned int wake = 0;
+    unsigned long generation;
+    DWORD timeout_ms = 0;
+
+    EnterCriticalSection(&cond->csection);
+    cond->num_waiting++;
+    generation = cond->generation;
+    LeaveCriticalSection(&cond->csection);
+
+    apr_thread_mutex_unlock(mutex);
+
+    do {
+        apr_interval_time_t t = timeout;
+
+        do {
+            if (t < 0) {
+                timeout_ms = INFINITE;
+            }
+            else if (t > 0) {
+                /* Given timeout is 64bit usecs whereas Windows timeouts are
+                 * 32bit msecs and below INFINITE (2^32 - 1), so we may need
+                 * multiple timed out waits...
+                 */
+                if (t > apr_time_from_msec(INFINITE - 1)) {
+                    timeout_ms = INFINITE - 1;
+                    t -= apr_time_from_msec(INFINITE - 1);
+                }
+                else {
+                    timeout_ms = (DWORD)apr_time_as_msec(t);
+                    t = 0;
+                }
+            }
+            res = WaitForSingleObject(cond->semaphore, timeout_ms);
+        } while (res == WAIT_TIMEOUT && t > 0);
+
+        EnterCriticalSection(&cond->csection);
+
+        if (cond->num_wake) {
+            if (cond->generation != generation) {
+                cond->num_wake--;
+                cond->num_waiting--;
+                rv = APR_SUCCESS;
+                break;
+            } else {
+                wake = 1;
+            }
+        }
+        else if (res != WAIT_OBJECT_0) {
+            cond->num_waiting--;
+            rv = APR_TIMEUP;
+            break;
+        }
+
+        LeaveCriticalSection(&cond->csection);
+
+        if (wake) {
+            wake = 0;
+            ReleaseSemaphore(cond->semaphore, 1, NULL);
+        }
+    } while (1);
+
+    LeaveCriticalSection(&cond->csection);
+    apr_thread_mutex_lock(mutex);
+
+    return rv;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_cond_wait(apr_thread_cond_t *cond,
+                                               apr_thread_mutex_t *mutex)
+{
+    return thread_cond_timedwait(cond, mutex, (apr_interval_time_t)-1);
+}
+
+APR_DECLARE(apr_status_t) apr_thread_cond_timedwait(apr_thread_cond_t *cond,
+                                                    apr_thread_mutex_t *mutex,
+                                                    apr_interval_time_t timeout)
+{
+    return thread_cond_timedwait(cond, mutex, timeout);
+}
+
+APR_DECLARE(apr_status_t) apr_thread_cond_signal(apr_thread_cond_t *cond)
+{
+    unsigned int wake = 0;
+
+    EnterCriticalSection(&cond->csection);
+    if (cond->num_waiting > cond->num_wake) {
+        wake = 1;
+        cond->num_wake++;
+        cond->generation++;
+    }
+    LeaveCriticalSection(&cond->csection);
+
+    if (wake) {
+        ReleaseSemaphore(cond->semaphore, 1, NULL);
+    }
+
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_cond_broadcast(apr_thread_cond_t *cond)
+{
+    unsigned long num_wake = 0;
+
+    EnterCriticalSection(&cond->csection);
+    if (cond->num_waiting > cond->num_wake) {
+        num_wake = cond->num_waiting - cond->num_wake;
+        cond->num_wake = cond->num_waiting;
+        cond->generation++;
+    }
+    LeaveCriticalSection(&cond->csection);
+
+    if (num_wake) {
+        ReleaseSemaphore(cond->semaphore, num_wake, NULL);
+    }
+
+    return APR_SUCCESS;
+}
+
+APR_POOL_IMPLEMENT_ACCESSOR(thread_cond)
diff --git a/locks/win32/thread_mutex.c b/locks/win32/thread_mutex.c
new file mode 100644
index 0000000..f191524
--- /dev/null
+++ b/locks/win32/thread_mutex.c
@@ -0,0 +1,175 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "apr.h"
+#include "apr_private.h"
+#include "apr_general.h"
+#include "apr_strings.h"
+#include "apr_arch_thread_mutex.h"
+#include "apr_thread_mutex.h"
+#include "apr_portable.h"
+#include "apr_arch_misc.h"
+
+static apr_status_t thread_mutex_cleanup(void *data)
+{
+    apr_thread_mutex_t *lock = data;
+
+    if (lock->type == thread_mutex_critical_section) {
+        lock->type = -1;
+        DeleteCriticalSection(&lock->section);
+    }
+    else {
+        if (!CloseHandle(lock->handle)) {
+            return apr_get_os_error();
+        }
+    }
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_mutex_create(apr_thread_mutex_t **mutex,
+                                                  unsigned int flags,
+                                                  apr_pool_t *pool)
+{
+    (*mutex) = (apr_thread_mutex_t *)apr_palloc(pool, sizeof(**mutex));
+
+    (*mutex)->pool = pool;
+
+    if (flags & APR_THREAD_MUTEX_UNNESTED) {
+        /* Use an auto-reset signaled event, ready to accept one
+         * waiting thread.
+         */
+        (*mutex)->type = thread_mutex_unnested_event;
+        (*mutex)->handle = CreateEvent(NULL, FALSE, TRUE, NULL);
+    }
+    else if (flags & APR_THREAD_MUTEX_TIMED) {
+        (*mutex)->type = thread_mutex_nested_mutex;
+        (*mutex)->handle = CreateMutex(NULL, FALSE, NULL);
+    }
+    else {
+#if APR_HAS_UNICODE_FS
+        /* Critical Sections are terrific, performance-wise, on NT.
+         * On Win9x, we cannot 'try' on a critical section, so we 
+         * use a [slower] mutex object, instead.
+         */
+        IF_WIN_OS_IS_UNICODE {
+            InitializeCriticalSection(&(*mutex)->section);
+            (*mutex)->type = thread_mutex_critical_section;
+            (*mutex)->handle = NULL;
+        }
+#endif
+#if APR_HAS_ANSI_FS
+        ELSE_WIN_OS_IS_ANSI {
+            (*mutex)->type = thread_mutex_nested_mutex;
+            (*mutex)->handle = CreateMutex(NULL, FALSE, NULL);
+
+        }
+#endif
+    }
+
+    apr_pool_cleanup_register((*mutex)->pool, (*mutex), thread_mutex_cleanup,
+                              apr_pool_cleanup_null);
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_mutex_lock(apr_thread_mutex_t *mutex)
+{
+    if (mutex->type == thread_mutex_critical_section) {
+        EnterCriticalSection(&mutex->section);
+    }
+    else {
+        DWORD rv = WaitForSingleObject(mutex->handle, INFINITE);
+        if ((rv != WAIT_OBJECT_0) && (rv != WAIT_ABANDONED)) {
+            return (rv == WAIT_TIMEOUT) ? APR_EBUSY : apr_get_os_error();
+        }
+    }        
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_mutex_trylock(apr_thread_mutex_t *mutex)
+{
+    if (mutex->type == thread_mutex_critical_section) {
+        if (!TryEnterCriticalSection(&mutex->section)) {
+            return APR_EBUSY;
+        }
+    }
+    else {
+        DWORD rv = WaitForSingleObject(mutex->handle, 0);
+        if ((rv != WAIT_OBJECT_0) && (rv != WAIT_ABANDONED)) {
+            return (rv == WAIT_TIMEOUT) ? APR_EBUSY : apr_get_os_error();
+        }
+    }        
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_mutex_timedlock(apr_thread_mutex_t *mutex,
+                                                 apr_interval_time_t timeout)
+{
+    if (mutex->type != thread_mutex_critical_section) {
+        DWORD rv, timeout_ms = 0;
+        apr_interval_time_t t = timeout;
+
+        do {
+            if (t > 0) {
+                /* Given timeout is 64bit usecs whereas Windows timeouts are
+                 * 32bit msecs and below INFINITE (2^32 - 1), so we may need
+                 * multiple timed out waits...
+                 */
+                if (t > apr_time_from_msec(INFINITE - 1)) {
+                    timeout_ms = INFINITE - 1;
+                    t -= apr_time_from_msec(INFINITE - 1);
+                }
+                else {
+                    timeout_ms = (DWORD)apr_time_as_msec(t);
+                    t = 0;
+                }
+            }
+            rv = WaitForSingleObject(mutex->handle, timeout_ms);
+        } while (rv == WAIT_TIMEOUT && t > 0);
+
+        if ((rv != WAIT_OBJECT_0) && (rv != WAIT_ABANDONED)) {
+            return (rv == WAIT_TIMEOUT) ? APR_TIMEUP : apr_get_os_error();
+        }
+        return APR_SUCCESS;
+    }        
+
+    return APR_ENOTIMPL;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_mutex_unlock(apr_thread_mutex_t *mutex)
+{
+    if (mutex->type == thread_mutex_critical_section) {
+        LeaveCriticalSection(&mutex->section);
+    }
+    else if (mutex->type == thread_mutex_unnested_event) {
+        if (!SetEvent(mutex->handle)) {
+            return apr_get_os_error();
+        }
+    }
+    else if (mutex->type == thread_mutex_nested_mutex) {
+        if (!ReleaseMutex(mutex->handle)) {
+            return apr_get_os_error();
+        }
+    }
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_mutex_destroy(apr_thread_mutex_t *mutex)
+{
+    return apr_pool_cleanup_run(mutex->pool, mutex, thread_mutex_cleanup);
+}
+
+APR_POOL_IMPLEMENT_ACCESSOR(thread_mutex)
+
diff --git a/locks/win32/thread_rwlock.c b/locks/win32/thread_rwlock.c
new file mode 100644
index 0000000..fd9d579
--- /dev/null
+++ b/locks/win32/thread_rwlock.c
@@ -0,0 +1,165 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "apr.h"
+#include "apr_private.h"
+#include "apr_general.h"
+#include "apr_strings.h"
+#include "apr_arch_thread_rwlock.h"
+#include "apr_portable.h"
+
+static apr_status_t thread_rwlock_cleanup(void *data)
+{
+    apr_thread_rwlock_t *rwlock = data;
+    
+    if (! CloseHandle(rwlock->read_event))
+        return apr_get_os_error();
+
+    if (! CloseHandle(rwlock->write_mutex))
+        return apr_get_os_error();
+    
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t)apr_thread_rwlock_create(apr_thread_rwlock_t **rwlock,
+                                                  apr_pool_t *pool)
+{
+    *rwlock = apr_palloc(pool, sizeof(**rwlock));
+
+    (*rwlock)->pool        = pool;
+    (*rwlock)->readers     = 0;
+
+    if (! ((*rwlock)->read_event = CreateEvent(NULL, TRUE, FALSE, NULL))) {
+        *rwlock = NULL;
+        return apr_get_os_error();
+    }
+
+    if (! ((*rwlock)->write_mutex = CreateMutex(NULL, FALSE, NULL))) {
+        CloseHandle((*rwlock)->read_event);
+        *rwlock = NULL;
+        return apr_get_os_error();
+    }
+
+    apr_pool_cleanup_register(pool, *rwlock, thread_rwlock_cleanup,
+                              apr_pool_cleanup_null);
+
+    return APR_SUCCESS;
+}
+
+static apr_status_t apr_thread_rwlock_rdlock_core(apr_thread_rwlock_t *rwlock,
+                                                  DWORD  milliseconds)
+{
+    DWORD   code = WaitForSingleObject(rwlock->write_mutex, milliseconds);
+
+    if (code == WAIT_FAILED || code == WAIT_TIMEOUT)
+        return APR_FROM_OS_ERROR(code);
+
+    /* We've successfully acquired the writer mutex, we can't be locked
+     * for write, so it's OK to add the reader lock.  The writer mutex
+     * doubles as race condition protection for the readers counter.   
+     */
+    InterlockedIncrement(&rwlock->readers);
+    
+    if (! ResetEvent(rwlock->read_event))
+        return apr_get_os_error();
+    
+    if (! ReleaseMutex(rwlock->write_mutex))
+        return apr_get_os_error();
+    
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_rwlock_rdlock(apr_thread_rwlock_t *rwlock)
+{
+    return apr_thread_rwlock_rdlock_core(rwlock, INFINITE);
+}
+
+APR_DECLARE(apr_status_t) 
+apr_thread_rwlock_tryrdlock(apr_thread_rwlock_t *rwlock)
+{
+    return apr_thread_rwlock_rdlock_core(rwlock, 0);
+}
+
+static apr_status_t 
+apr_thread_rwlock_wrlock_core(apr_thread_rwlock_t *rwlock, DWORD milliseconds)
+{
+    DWORD   code = WaitForSingleObject(rwlock->write_mutex, milliseconds);
+
+    if (code == WAIT_FAILED || code == WAIT_TIMEOUT)
+        return APR_FROM_OS_ERROR(code);
+
+    /* We've got the writer lock but we have to wait for all readers to
+     * unlock before it's ok to use it.
+     */
+    if (rwlock->readers) {
+        /* Must wait for readers to finish before returning, unless this
+         * is an trywrlock (milliseconds == 0):
+         */
+        code = milliseconds
+          ? WaitForSingleObject(rwlock->read_event, milliseconds)
+          : WAIT_TIMEOUT;
+        
+        if (code == WAIT_FAILED || code == WAIT_TIMEOUT) {
+            /* Unable to wait for readers to finish, release write lock: */
+            if (! ReleaseMutex(rwlock->write_mutex))
+                return apr_get_os_error();
+            
+            return APR_FROM_OS_ERROR(code);
+        }
+    }
+
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_rwlock_wrlock(apr_thread_rwlock_t *rwlock)
+{
+    return apr_thread_rwlock_wrlock_core(rwlock, INFINITE);
+}
+
+APR_DECLARE(apr_status_t)apr_thread_rwlock_trywrlock(apr_thread_rwlock_t *rwlock)
+{
+    return apr_thread_rwlock_wrlock_core(rwlock, 0);
+}
+
+APR_DECLARE(apr_status_t) apr_thread_rwlock_unlock(apr_thread_rwlock_t *rwlock)
+{
+    apr_status_t rv = 0;
+
+    /* First, guess that we're unlocking a writer */
+    if (! ReleaseMutex(rwlock->write_mutex))
+        rv = apr_get_os_error();
+    
+    if (rv == APR_FROM_OS_ERROR(ERROR_NOT_OWNER)) {
+        /* Nope, we must have a read lock */
+        if (rwlock->readers &&
+            ! InterlockedDecrement(&rwlock->readers) &&
+            ! SetEvent(rwlock->read_event)) {
+            rv = apr_get_os_error();
+        }
+        else {
+            rv = 0;
+        }
+    }
+
+    return rv;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_rwlock_destroy(apr_thread_rwlock_t *rwlock)
+{
+    return apr_pool_cleanup_run(rwlock->pool, rwlock, thread_rwlock_cleanup);
+}
+
+APR_POOL_IMPLEMENT_ACCESSOR(thread_rwlock)