/* 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.h"#include "apr_portable.h"#include "apr_strings.h"#include "apr_arch_threadproc.h"static int thread_count = 0;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)->stack_size = APR_DEFAULT_STACK_SIZE;    (*new)->detach = 0;    (*new)->thread_name = NULL;    return APR_SUCCESS;}apr_status_t apr_threadattr_detach_set(apr_threadattr_t *attr,apr_int32_t on){    attr->detach = on;	return APR_SUCCESS;   }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->stack_size = 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;    return thd->func(thd, thd->data);}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;    long flags = NX_THR_BIND_CONTEXT;  	char threadName[NX_MAX_OBJECT_NAME_LEN+1];    size_t stack_size = APR_DEFAULT_STACK_SIZE;    if (attr && attr->thread_name) {        strncpy (threadName, attr->thread_name, NX_MAX_OBJECT_NAME_LEN);    }    else {	    sprintf(threadName, "APR_thread %04ld", ++thread_count);    }    /* An original stack size of 0 will allow NXCreateThread() to    *   assign a default system stack size.  An original stack    *   size of less than 0 will assign the APR default stack size.    *   anything else will be taken as is.    */    if (attr && (attr->stack_size >= 0)) {        stack_size = attr->stack_size;    }        (*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)->thread_name = (char*)apr_pstrdup(pool, threadName);        stat = apr_pool_create(&(*new)->pool, pool);    if (stat != APR_SUCCESS) {        return stat;    }        if (attr && attr->detach) {        flags |= NX_THR_DETACHED;    }        (*new)->ctx = NXContextAlloc(    	/* void(*start_routine)(void *arg)*/(void (*)(void *)) dummy_worker,     	/* void *arg */										   (*new),     	/* int priority */ 									   NX_PRIO_MED,     	/* NXSize_t stackSize */							   stack_size,     	/* long flags */									   NX_CTX_NORMAL,     	/* int *error */									   &stat);		     	                                                                     	stat = NXContextSetName(		 	/* NXContext_t ctx */			(*new)->ctx,			/* const char *name */			threadName);  	stat = NXThreadCreate(        	/* NXContext_t context */		(*new)->ctx,        	/* long flags */				flags,        	/* NXThreadId_t *thread_id */	&(*new)->td);    if(stat==0)     	return APR_SUCCESS;        	return(stat);// if error    }apr_os_thread_t apr_os_thread_current(){    return NXThreadGetId();}int apr_os_thread_equal(apr_os_thread_t tid1, apr_os_thread_t tid2){    return (tid1 == tid2);}void apr_thread_yield(){    NXThreadYield();}apr_status_t apr_thread_exit(apr_thread_t *thd,                             apr_status_t retval){    thd->exitval = retval;    apr_pool_destroy(thd->pool);    NXThreadExit(NULL);    return APR_SUCCESS;}apr_status_t apr_thread_join(apr_status_t *retval,                                          apr_thread_t *thd){    apr_status_t  stat;        NXThreadId_t dthr;    if ((stat = NXThreadJoin(thd->td, &dthr, NULL)) == 0) {        *retval = thd->exitval;        return APR_SUCCESS;    }    else {        return stat;    }}apr_status_t apr_thread_detach(apr_thread_t *thd){    return APR_SUCCESS;}apr_status_t apr_thread_data_get(void **data, const char *key,                                             apr_thread_t *thread){    if (thread != NULL) {            return apr_pool_userdata_get(data, key, thread->pool);    }    else {        data = NULL;        return APR_ENOTHREAD;    }}apr_status_t apr_thread_data_set(void *data, const char *key,                              apr_status_t (*cleanup) (void *),                              apr_thread_t *thread){    if (thread != NULL) {       return apr_pool_userdata_set(data, key, cleanup, thread->pool);    }    else {        data = NULL;        return APR_ENOTHREAD;    }}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 (!atomic_xchg(&control->value, 1)) {        func();    }    return APR_SUCCESS;}APR_POOL_IMPLEMENT_ACCESSOR(thread)