/* 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_private.h" #include "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)->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)
.htaccess Tutorial
Find information you are looking for on the AskApache Home Page.