summaryrefslogtreecommitdiffstats
path: root/locks/win32
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-17 06:23:09 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-17 06:23:09 +0000
commit30d479c28c831a0d4f1fdb54a9e346b0fc176be1 (patch)
treeaa35d7414ce9f1326abf6f723f6dfa5b0aa08b1d /locks/win32
parentInitial commit. (diff)
downloadapr-30d479c28c831a0d4f1fdb54a9e346b0fc176be1.tar.xz
apr-30d479c28c831a0d4f1fdb54a9e346b0fc176be1.zip
Adding upstream version 1.7.2.upstream/1.7.2
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'locks/win32')
-rw-r--r--locks/win32/proc_mutex.c301
-rw-r--r--locks/win32/thread_cond.c188
-rw-r--r--locks/win32/thread_mutex.c175
-rw-r--r--locks/win32/thread_rwlock.c165
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)