| /* Copyright 2000-2005 The Apache Software Foundation or its licensors, as | |
| * applicable. | |
| * | |
| * Licensed 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_private.h" | |
| #include "win32/apr_arch_threadproc.h" | |
| #include "apr_thread_proc.h" | |
| #include "apr_general.h" | |
| #include "apr_lib.h" | |
| #include "apr_portable.h" | |
| #if APR_HAVE_PROCESS_H | |
| #include <process.h> | |
| #endif | |
| #include "apr_arch_misc.h" | |
| /* Chosen for us by apr_initialize */ | |
| DWORD tls_apr_thread = 0; | |
| APR_DECLARE(apr_status_t) apr_threadattr_create(apr_threadattr_t **new, | |
| apr_pool_t *pool) | |
| { | |
| (*new) = (apr_threadattr_t *)apr_palloc(pool, | |
| sizeof(apr_threadattr_t)); | |
| if ((*new) == NULL) { | |
| return APR_ENOMEM; | |
| } | |
| (*new)->pool = pool; | |
| (*new)->detach = 0; | |
| (*new)->stacksize = 0; | |
| return APR_SUCCESS; | |
| } | |
| APR_DECLARE(apr_status_t) apr_threadattr_detach_set(apr_threadattr_t *attr, | |
| apr_int32_t on) | |
| { | |
| attr->detach = on; | |
| return APR_SUCCESS; | |
| } | |
| APR_DECLARE(apr_status_t) apr_threadattr_detach_get(apr_threadattr_t *attr) | |
| { | |
| if (attr->detach == 1) | |
| return APR_DETACH; | |
| return APR_NOTDETACH; | |
| } | |
| APR_DECLARE(apr_status_t) apr_threadattr_stacksize_set(apr_threadattr_t *attr, | |
| apr_size_t stacksize) | |
| { | |
| attr->stacksize = stacksize; | |
| return APR_SUCCESS; | |
| } | |
| APR_DECLARE(apr_status_t) apr_threadattr_guardsize_set(apr_threadattr_t *attr, | |
| apr_size_t size) | |
| { | |
| return APR_ENOTIMPL; | |
| } | |
| static void *dummy_worker(void *opaque) | |
| { | |
| apr_thread_t *thd = (apr_thread_t *)opaque; | |
| TlsSetValue(tls_apr_thread, thd->td); | |
| return thd->func(thd, thd->data); | |
| } | |
| APR_DECLARE(apr_status_t) apr_thread_create(apr_thread_t **new, | |
| apr_threadattr_t *attr, | |
| apr_thread_start_t func, | |
| void *data, apr_pool_t *pool) | |
| { | |
| apr_status_t stat; | |
| unsigned temp; | |
| HANDLE handle; | |
| (*new) = (apr_thread_t *)apr_palloc(pool, sizeof(apr_thread_t)); | |
| if ((*new) == NULL) { | |
| return APR_ENOMEM; | |
| } | |
| (*new)->pool = pool; | |
| (*new)->data = data; | |
| (*new)->func = func; | |
| (*new)->td = NULL; | |
| stat = apr_pool_create(&(*new)->pool, pool); | |
| if (stat != APR_SUCCESS) { | |
| return stat; | |
| } | |
| /* Use 0 for Thread Stack Size, because that will default the stack to the | |
| * same size as the calling thread. | |
| */ | |
| #ifndef _WIN32_WCE | |
| if ((handle = (HANDLE)_beginthreadex(NULL, | |
| (DWORD) (attr ? attr->stacksize : 0), | |
| (unsigned int (APR_THREAD_FUNC *)(void *))dummy_worker, | |
| (*new), 0, &temp)) == 0) { | |
| return APR_FROM_OS_ERROR(_doserrno); | |
| } | |
| #else | |
| if ((handle = CreateThread(NULL, | |
| attr && attr->stacksize > 0 ? attr->stacksize : 0, | |
| (unsigned int (APR_THREAD_FUNC *)(void *))dummy_worker, | |
| (*new), 0, &temp)) == 0) { | |
| return apr_get_os_error(); | |
| } | |
| #endif | |
| if (attr && attr->detach) { | |
| CloseHandle(handle); | |
| } | |
| else | |
| (*new)->td = handle; | |
| return APR_SUCCESS; | |
| } | |
| APR_DECLARE(apr_status_t) apr_thread_exit(apr_thread_t *thd, | |
| apr_status_t retval) | |
| { | |
| thd->exitval = retval; | |
| apr_pool_destroy(thd->pool); | |
| thd->pool = NULL; | |
| #ifndef _WIN32_WCE | |
| _endthreadex(0); | |
| #else | |
| ExitThread(0); | |
| #endif | |
| return APR_SUCCESS; | |
| } | |
| APR_DECLARE(apr_status_t) apr_thread_join(apr_status_t *retval, | |
| apr_thread_t *thd) | |
| { | |
| apr_status_t rv = APR_SUCCESS; | |
| if (!thd->td) { | |
| /* Can not join on detached threads */ | |
| return APR_DETACH; | |
| } | |
| rv = WaitForSingleObject(thd->td, INFINITE); | |
| if ( rv == WAIT_OBJECT_0 || rv == WAIT_ABANDONED) { | |
| /* If the thread_exit has been called */ | |
| if (!thd->pool) | |
| *retval = thd->exitval; | |
| else | |
| rv = APR_INCOMPLETE; | |
| } | |
| else | |
| rv = apr_get_os_error(); | |
| CloseHandle(thd->td); | |
| thd->td = NULL; | |
| return rv; | |
| } | |
| APR_DECLARE(apr_status_t) apr_thread_detach(apr_thread_t *thd) | |
| { | |
| if (thd->td && CloseHandle(thd->td)) { | |
| thd->td = NULL; | |
| return APR_SUCCESS; | |
| } | |
| else { | |
| return apr_get_os_error(); | |
| } | |
| } | |
| APR_DECLARE(void) apr_thread_yield() | |
| { | |
| /* SwitchToThread is not supported on Win9x, but since it's | |
| * primarily a noop (entering time consuming code, therefore | |
| * providing more critical threads a bit larger timeslice) | |
| * we won't worry too much if it's not available. | |
| */ | |
| #ifndef _WIN32_WCE | |
| if (apr_os_level >= APR_WIN_NT) { | |
| SwitchToThread(); | |
| } | |
| #endif | |
| } | |
| APR_DECLARE(apr_status_t) apr_thread_data_get(void **data, const char *key, | |
| apr_thread_t *thread) | |
| { | |
| return apr_pool_userdata_get(data, key, thread->pool); | |
| } | |
| APR_DECLARE(apr_status_t) apr_thread_data_set(void *data, const char *key, | |
| apr_status_t (*cleanup) (void *), | |
| apr_thread_t *thread) | |
| { | |
| return apr_pool_userdata_set(data, key, cleanup, thread->pool); | |
| } | |
| APR_DECLARE(apr_os_thread_t) apr_os_thread_current(void) | |
| { | |
| HANDLE hthread = (HANDLE)TlsGetValue(tls_apr_thread); | |
| HANDLE hproc; | |
| if (hthread) { | |
| return hthread; | |
| } | |
| hproc = GetCurrentProcess(); | |
| hthread = GetCurrentThread(); | |
| if (!DuplicateHandle(hproc, hthread, | |
| hproc, &hthread, 0, FALSE, | |
| DUPLICATE_SAME_ACCESS)) { | |
| return NULL; | |
| } | |
| TlsSetValue(tls_apr_thread, hthread); | |
| return hthread; | |
| } | |
| APR_DECLARE(apr_status_t) apr_os_thread_get(apr_os_thread_t **thethd, | |
| apr_thread_t *thd) | |
| { | |
| if (thd == NULL) { | |
| return APR_ENOTHREAD; | |
| } | |
| *thethd = thd->td; | |
| return APR_SUCCESS; | |
| } | |
| APR_DECLARE(apr_status_t) apr_os_thread_put(apr_thread_t **thd, | |
| apr_os_thread_t *thethd, | |
| apr_pool_t *pool) | |
| { | |
| if (pool == NULL) { | |
| return APR_ENOPOOL; | |
| } | |
| if ((*thd) == NULL) { | |
| (*thd) = (apr_thread_t *)apr_palloc(pool, sizeof(apr_thread_t)); | |
| (*thd)->pool = pool; | |
| } | |
| (*thd)->td = thethd; | |
| return APR_SUCCESS; | |
| } | |
| APR_DECLARE(apr_status_t) apr_thread_once_init(apr_thread_once_t **control, | |
| apr_pool_t *p) | |
| { | |
| (*control) = apr_pcalloc(p, sizeof(**control)); | |
| return APR_SUCCESS; | |
| } | |
| APR_DECLARE(apr_status_t) apr_thread_once(apr_thread_once_t *control, | |
| void (*func)(void)) | |
| { | |
| if (!InterlockedExchange(&control->value, 1)) { | |
| func(); | |
| } | |
| return APR_SUCCESS; | |
| } | |
| APR_DECLARE(int) apr_os_thread_equal(apr_os_thread_t tid1, | |
| apr_os_thread_t tid2) | |
| { | |
| /* Since the only tid's we support our are own, and | |
| * apr_os_thread_current returns the identical handle | |
| * to the one we created initially, the test is simple. | |
| */ | |
| return (tid1 == tid2); | |
| } | |
| APR_POOL_IMPLEMENT_ACCESSOR(thread) |