/* 

 * tclUnixThrd.c --

 *

 *	This file implements the UNIX-specific thread support.

 *

 * Copyright (c) 1991-1994 The Regents of the University of California.

 * Copyright (c) 1994-1997 Sun Microsystems, Inc.

 * Portions Copyright (c) 2007-2008 Nokia Corporation and/or its subsidiaries. All rights reserved.  

 *

 * See the file "license.terms" for information on usage and redistribution

 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.

 *

 * SCCS:  @(#) tclUnixThrd.c 1.18 98/02/19 14:24:12

 */

#include "tclInt.h"

#include "tclPort.h"

#ifdef TCL_THREADS

#include "pthread.h"

typedef struct ThreadSpecificData {

    char nabuf[16];

} ThreadSpecificData;

static Tcl_ThreadDataKey dataKey;

/*

 * masterLock is used to serialize creation of mutexes, condition

 * variables, and thread local storage.

 * This is the only place that can count on the ability to statically

 * initialize the mutex.

 */

static pthread_mutex_t masterLock = PTHREAD_MUTEX_INITIALIZER;

/*

 * initLock is used to serialize initialization and finalization

 * of Tcl.  It cannot use any dyamically allocated storage.

 */

static pthread_mutex_t initLock = PTHREAD_MUTEX_INITIALIZER;

/*

 * allocLock is used by Tcl's version of malloc for synchronization.

 * For obvious reasons, cannot use any dyamically allocated storage.

 */

static pthread_mutex_t allocLock = PTHREAD_MUTEX_INITIALIZER;

static pthread_mutex_t *allocLockPtr = &allocLock;

/*

 * These are for the critical sections inside this file.

 */

#define MASTER_LOCK	pthread_mutex_lock(&masterLock)

#define MASTER_UNLOCK	pthread_mutex_unlock(&masterLock)

#endif /* TCL_THREADS */

/*

 *----------------------------------------------------------------------

 *

 * TclpThreadCreate --

 *

 *	This procedure creates a new thread.

 *

 * Results:

 *	TCL_OK if the thread could be created.  The thread ID is

 *	returned in a parameter.

 *

 * Side effects:

 *	A new thread is created.

 *

 *----------------------------------------------------------------------

 */

int

TclpThreadCreate(idPtr, proc, clientData, stackSize, flags)

    Tcl_ThreadId *idPtr;		/* Return, the ID of the thread */

    Tcl_ThreadCreateProc proc;		/* Main() function of the thread */

    ClientData clientData;		/* The one argument to Main() */

    int stackSize;			/* Size of stack for the new thread */

    int flags;				/* Flags controlling behaviour of

					 * the new thread */

{

#ifdef TCL_THREADS

    pthread_attr_t attr;

    pthread_t theThread;

    int result;

    pthread_attr_init(&attr);

    pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM);

#ifdef HAVE_PTHREAD_ATTR_SETSTACKSIZE

    if (stackSize != TCL_THREAD_STACK_DEFAULT) {

        pthread_attr_setstacksize(&attr, (size_t) stackSize);

#ifdef TCL_THREAD_STACK_MIN

    } else {

        /*

	 * Certain systems define a thread stack size that by default is

	 * too small for many operations.  The user has the option of

	 * defining TCL_THREAD_STACK_MIN to a value large enough to work

	 * for their needs.  This would look like (for 128K min stack):

	 *    make MEM_DEBUG_FLAGS=-DTCL_THREAD_STACK_MIN=131072L

	 *

	 * This solution is not optimal, as we should allow the user to

	 * specify a size at runtime, but we don't want to slow this function

	 * down, and that would still leave the main thread at the default.

	 */

        size_t size;

	result = pthread_attr_getstacksize(&attr, &size);

	if (!result && (size < TCL_THREAD_STACK_MIN)) {

	    pthread_attr_setstacksize(&attr, (size_t) TCL_THREAD_STACK_MIN);

	}

#endif

    }

#endif

    if (! (flags & TCL_THREAD_JOINABLE)) {

        pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);

    }

    if (pthread_create(&theThread, &attr,

	    (void * (*)())proc, (void *)clientData) &&

	    pthread_create(&theThread, NULL,

		    (void * (*)())proc, (void *)clientData)) {

	result = TCL_ERROR;

    } else {

	*idPtr = (Tcl_ThreadId)theThread;

	result = TCL_OK;

    }

    pthread_attr_destroy(&attr);

    return result;

#else

    return TCL_ERROR;

#endif /* TCL_THREADS */

}

/*

 *----------------------------------------------------------------------

 *

 * Tcl_JoinThread --

 *

 *	This procedure waits upon the exit of the specified thread.

 *

 * Results:

 *	TCL_OK if the wait was successful, TCL_ERROR else.

 *

 * Side effects:

 *	The result area is set to the exit code of the thread we

 *	waited upon.

 *

 *----------------------------------------------------------------------

 */

EXPORT_C int

Tcl_JoinThread(threadId, state)

    Tcl_ThreadId threadId; /* Id of the thread to wait upon */

    int*     state;	   /* Reference to the storage the result

			    * of the thread we wait upon will be

			    * written into. */

{

#ifdef TCL_THREADS

    int result;

    result = pthread_join ((pthread_t) threadId, (VOID**) state);

    return (result == 0) ? TCL_OK : TCL_ERROR;

#else

    return TCL_ERROR;

#endif

}

#ifdef TCL_THREADS

/*

 *----------------------------------------------------------------------

 *

 * TclpThreadExit --

 *

 *	This procedure terminates the current thread.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	This procedure terminates the current thread.

 *

 *----------------------------------------------------------------------

 */

void

TclpThreadExit(status)

    int status;

{

    pthread_exit((VOID *)status);

}

#endif /* TCL_THREADS */

/*

 *----------------------------------------------------------------------

 *

 * Tcl_GetCurrentThread --

 *

 *	This procedure returns the ID of the currently running thread.

 *

 * Results:

 *	A thread ID.

 *

 * Side effects:

 *	None.

 *

 *----------------------------------------------------------------------

 */

EXPORT_C Tcl_ThreadId

Tcl_GetCurrentThread()

{

#ifdef TCL_THREADS

    return (Tcl_ThreadId) pthread_self();

#else

    return (Tcl_ThreadId) 0;

#endif

}

/*

 *----------------------------------------------------------------------

 *

 * TclpInitLock

 *

 *	This procedure is used to grab a lock that serializes initialization

 *	and finalization of Tcl.  On some platforms this may also initialize

 *	the mutex used to serialize creation of more mutexes and thread

 *	local storage keys.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	Acquire the initialization mutex.

 *

 *----------------------------------------------------------------------

 */

void

TclpInitLock()

{

#ifdef TCL_THREADS

    pthread_mutex_lock(&initLock);

#endif

}

/*

 *----------------------------------------------------------------------

 *

 * TclpFinalizeLock

 *

 *	This procedure is used to destroy all private resources used in

 *	this file.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	Destroys everything private.  TclpInitLock must be held

 *	entering this function.

 *

 *----------------------------------------------------------------------

 */

void

TclFinalizeLock ()

{

#ifdef TCL_THREADS

    /*

     * You do not need to destroy mutexes that were created with the

     * PTHREAD_MUTEX_INITIALIZER macro.  These mutexes do not need

     * any destruction: masterLock, allocLock, and initLock.

     */

    pthread_mutex_unlock(&initLock);

#endif

}

/*

 *----------------------------------------------------------------------

 *

 * TclpInitUnlock

 *

 *	This procedure is used to release a lock that serializes initialization

 *	and finalization of Tcl.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	Release the initialization mutex.

 *

 *----------------------------------------------------------------------

 */

void

TclpInitUnlock()

{

#ifdef TCL_THREADS

    pthread_mutex_unlock(&initLock);

#endif

}

/*

 *----------------------------------------------------------------------

 *

 * TclpMasterLock

 *

 *	This procedure is used to grab a lock that serializes creation

 *	and finalization of serialization objects.  This interface is

 *	only needed in finalization; it is hidden during

 *	creation of the objects.

 *

 *	This lock must be different than the initLock because the

 *	initLock is held during creation of syncronization objects.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	Acquire the master mutex.

 *

 *----------------------------------------------------------------------

 */

void

TclpMasterLock()

{

#ifdef TCL_THREADS

    pthread_mutex_lock(&masterLock);

#endif

}

/*

 *----------------------------------------------------------------------

 *

 * TclpMasterUnlock

 *

 *	This procedure is used to release a lock that serializes creation

 *	and finalization of synchronization objects.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	Release the master mutex.

 *

 *----------------------------------------------------------------------

 */

void

TclpMasterUnlock()

{

#ifdef TCL_THREADS

    pthread_mutex_unlock(&masterLock);

#endif

}

/*

 *----------------------------------------------------------------------

 *

 * Tcl_GetAllocMutex

 *

 *	This procedure returns a pointer to a statically initialized

 *	mutex for use by the memory allocator.  The alloctor must

 *	use this lock, because all other locks are allocated...

 *

 * Results:

 *	A pointer to a mutex that is suitable for passing to

 *	Tcl_MutexLock and Tcl_MutexUnlock.

 *

 * Side effects:

 *	None.

 *

 *----------------------------------------------------------------------

 */

EXPORT_C Tcl_Mutex *

Tcl_GetAllocMutex()

{

#ifdef TCL_THREADS

    return (Tcl_Mutex *)&allocLockPtr;

#else

    return NULL;

#endif

}

#ifdef TCL_THREADS

/*

 *----------------------------------------------------------------------

 *

 * Tcl_MutexLock --

 *

 *	This procedure is invoked to lock a mutex.  This procedure

 *	handles initializing the mutex, if necessary.  The caller

 *	can rely on the fact that Tcl_Mutex is an opaque pointer.

 *	This routine will change that pointer from NULL after first use.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	May block the current thread.  The mutex is aquired when

 *	this returns.  Will allocate memory for a pthread_mutex_t

 *	and initialize this the first time this Tcl_Mutex is used.

 *

 *----------------------------------------------------------------------

 */

EXPORT_C void

Tcl_MutexLock(mutexPtr)

    Tcl_Mutex *mutexPtr;	/* Really (pthread_mutex_t **) */

{

    pthread_mutex_t *pmutexPtr;

    if (*mutexPtr == NULL) {

	MASTER_LOCK;

	if (*mutexPtr == NULL) {

	    /* 

	     * Double inside master lock check to avoid a race condition.

	     */

	    pmutexPtr = (pthread_mutex_t *)ckalloc(sizeof(pthread_mutex_t));

	    pthread_mutex_init(pmutexPtr, NULL);

	    *mutexPtr = (Tcl_Mutex)pmutexPtr;

	    TclRememberMutex(mutexPtr);

	}

	MASTER_UNLOCK;

    }

    pmutexPtr = *((pthread_mutex_t **)mutexPtr);

    pthread_mutex_lock(pmutexPtr);

}

/*

 *----------------------------------------------------------------------

 *

 * Tcl_MutexUnlock --

 *

 *	This procedure is invoked to unlock a mutex.  The mutex must

 *	have been locked by Tcl_MutexLock.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	The mutex is released when this returns.

 *

 *----------------------------------------------------------------------

 */

EXPORT_C void

Tcl_MutexUnlock(mutexPtr)

    Tcl_Mutex *mutexPtr;	/* Really (pthread_mutex_t **) */

{

    pthread_mutex_t *pmutexPtr = *(pthread_mutex_t **)mutexPtr;

    pthread_mutex_unlock(pmutexPtr);

}

/*

 *----------------------------------------------------------------------

 *

 * TclpFinalizeMutex --

 *

 *	This procedure is invoked to clean up one mutex.  This is only

 *	safe to call at the end of time.

 *

 *	This assumes the Master Lock is held.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	The mutex list is deallocated.

 *

 *----------------------------------------------------------------------

 */

void

TclpFinalizeMutex(mutexPtr)

    Tcl_Mutex *mutexPtr;

{

    pthread_mutex_t *pmutexPtr = *(pthread_mutex_t **)mutexPtr;

    if (pmutexPtr != NULL) {

        pthread_mutex_destroy(pmutexPtr);

	ckfree((char *)pmutexPtr);

	*mutexPtr = NULL;

    }

}

/*

 *----------------------------------------------------------------------

 *

 * TclpThreadDataKeyInit --

 *

 *	This procedure initializes a thread specific data block key.

 *	Each thread has table of pointers to thread specific data.

 *	all threads agree on which table entry is used by each module.

 *	this is remembered in a "data key", that is just an index into

 *	this table.  To allow self initialization, the interface

 *	passes a pointer to this key and the first thread to use

 *	the key fills in the pointer to the key.  The key should be

 *	a process-wide static.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	Will allocate memory the first time this process calls for

 *	this key.  In this case it modifies its argument

 *	to hold the pointer to information about the key.

 *

 *----------------------------------------------------------------------

 */

void

TclpThreadDataKeyInit(keyPtr)

    Tcl_ThreadDataKey *keyPtr;	/* Identifier for the data chunk,

				 * really (pthread_key_t **) */

{

    pthread_key_t *pkeyPtr;

    MASTER_LOCK;

    if (*keyPtr == NULL) {

	pkeyPtr = (pthread_key_t *)ckalloc(sizeof(pthread_key_t));

	pthread_key_create(pkeyPtr, NULL);

	*keyPtr = (Tcl_ThreadDataKey)pkeyPtr;

	TclRememberDataKey(keyPtr);

    }

    MASTER_UNLOCK;

}

/*

 *----------------------------------------------------------------------

 *

 * TclpThreadDataKeyGet --

 *

 *	This procedure returns a pointer to a block of thread local storage.

 *

 * Results:

 *	A thread-specific pointer to the data structure, or NULL

 *	if the memory has not been assigned to this key for this thread.

 *

 * Side effects:

 *	None.

 *

 *----------------------------------------------------------------------

 */

VOID *

TclpThreadDataKeyGet(keyPtr)

    Tcl_ThreadDataKey *keyPtr;	/* Identifier for the data chunk,

				 * really (pthread_key_t **) */

{

    pthread_key_t *pkeyPtr = *(pthread_key_t **)keyPtr;

    if (pkeyPtr == NULL) {

	return NULL;

    } else {

	return (VOID *)pthread_getspecific(*pkeyPtr);

    }

}

/*

 *----------------------------------------------------------------------

 *

 * TclpThreadDataKeySet --

 *

 *	This procedure sets the pointer to a block of thread local storage.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	Sets up the thread so future calls to TclpThreadDataKeyGet with

 *	this key will return the data pointer.

 *

 *----------------------------------------------------------------------

 */

void

TclpThreadDataKeySet(keyPtr, data)

    Tcl_ThreadDataKey *keyPtr;	/* Identifier for the data chunk,

				 * really (pthread_key_t **) */

    VOID *data;			/* Thread local storage */

{

    pthread_key_t *pkeyPtr = *(pthread_key_t **)keyPtr;

    pthread_setspecific(*pkeyPtr, data);

}

/*

 *----------------------------------------------------------------------

 *

 * TclpFinalizeThreadData --

 *

 *	This procedure cleans up the thread-local storage.  This is

 *	called once for each thread.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	Frees up all thread local storage.

 *

 *----------------------------------------------------------------------

 */

void

TclpFinalizeThreadData(keyPtr)

    Tcl_ThreadDataKey *keyPtr;

{

    VOID *result;

    pthread_key_t *pkeyPtr;

    if (*keyPtr != NULL) {

	pkeyPtr = *(pthread_key_t **)keyPtr;

	result = (VOID *)pthread_getspecific(*pkeyPtr);

	if (result != NULL) {

	    ckfree((char *)result);

	    pthread_setspecific(*pkeyPtr, (void *)NULL);

	}

    }

}

/*

 *----------------------------------------------------------------------

 *

 * TclpFinalizeThreadDataKey --

 *

 *	This procedure is invoked to clean up one key.  This is a

 *	process-wide storage identifier.  The thread finalization code

 *	cleans up the thread local storage itself.

 *

 *	This assumes the master lock is held.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	The key is deallocated.

 *

 *----------------------------------------------------------------------

 */

void

TclpFinalizeThreadDataKey(keyPtr)

    Tcl_ThreadDataKey *keyPtr;

{

    pthread_key_t *pkeyPtr;

    if (*keyPtr != NULL) {

	pkeyPtr = *(pthread_key_t **)keyPtr;

	pthread_key_delete(*pkeyPtr);

	ckfree((char *)pkeyPtr);

	*keyPtr = NULL;

    }

}

/*

 *----------------------------------------------------------------------

 *

 * Tcl_ConditionWait --

 *

 *	This procedure is invoked to wait on a condition variable.

 *	The mutex is automically released as part of the wait, and

 *	automatically grabbed when the condition is signaled.

 *

 *	The mutex must be held when this procedure is called.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	May block the current thread.  The mutex is aquired when

 *	this returns.  Will allocate memory for a pthread_mutex_t

 *	and initialize this the first time this Tcl_Mutex is used.

 *

 *----------------------------------------------------------------------

 */

EXPORT_C void

Tcl_ConditionWait(condPtr, mutexPtr, timePtr)

    Tcl_Condition *condPtr;	/* Really (pthread_cond_t **) */

    Tcl_Mutex *mutexPtr;	/* Really (pthread_mutex_t **) */

    Tcl_Time *timePtr;		/* Timeout on waiting period */

{

    pthread_cond_t *pcondPtr;

    pthread_mutex_t *pmutexPtr;

    struct timespec ptime;

    if (*condPtr == NULL) {

	MASTER_LOCK;

	/* 

	 * Double check inside mutex to avoid race,

	 * then initialize condition variable if necessary.

	 */

	if (*condPtr == NULL) {

	    pcondPtr = (pthread_cond_t *)ckalloc(sizeof(pthread_cond_t));

	    pthread_cond_init(pcondPtr, NULL);

	    *condPtr = (Tcl_Condition)pcondPtr;

	    TclRememberCondition(condPtr);

	}

	MASTER_UNLOCK;

    }

    pmutexPtr = *((pthread_mutex_t **)mutexPtr);

    pcondPtr = *((pthread_cond_t **)condPtr);

    if (timePtr == NULL) {

	pthread_cond_wait(pcondPtr, pmutexPtr);

    } else {

	Tcl_Time now;

	/*

	 * Make sure to take into account the microsecond component of the

	 * current time, including possible overflow situations. [Bug #411603]

	 */

	Tcl_GetTime(&now);

	ptime.tv_sec = timePtr->sec + now.sec +

	    (timePtr->usec + now.usec) / 1000000;

	ptime.tv_nsec = 1000 * ((timePtr->usec + now.usec) % 1000000);

	pthread_cond_timedwait(pcondPtr, pmutexPtr, &ptime);

    }

}

/*

 *----------------------------------------------------------------------

 *

 * Tcl_ConditionNotify --

 *

 *	This procedure is invoked to signal a condition variable.

 *

 *	The mutex must be held during this call to avoid races,

 *	but this interface does not enforce that.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	May unblock another thread.

 *

 *----------------------------------------------------------------------

 */

EXPORT_C void

Tcl_ConditionNotify(condPtr)

    Tcl_Condition *condPtr;

{

    pthread_cond_t *pcondPtr = *((pthread_cond_t **)condPtr);

    if (pcondPtr != NULL) {

	pthread_cond_broadcast(pcondPtr);

    } else {

	/*

	 * Noone has used the condition variable, so there are no waiters.

	 */

    }

}

/*

 *----------------------------------------------------------------------

 *

 * TclpFinalizeCondition --

 *

 *	This procedure is invoked to clean up a condition variable.

 *	This is only safe to call at the end of time.

 *

 *	This assumes the Master Lock is held.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	The condition variable is deallocated.

 *

 *----------------------------------------------------------------------

 */

void

TclpFinalizeCondition(condPtr)

    Tcl_Condition *condPtr;

{

    pthread_cond_t *pcondPtr = *(pthread_cond_t **)condPtr;

    if (pcondPtr != NULL) {

	pthread_cond_destroy(pcondPtr);

	ckfree((char *)pcondPtr);

	*condPtr = NULL;

    }

}

#endif /* TCL_THREADS */

/*

 *----------------------------------------------------------------------

 *

 * TclpReaddir, TclpLocaltime, TclpGmtime, TclpInetNtoa --

 *

 *	These procedures replace core C versions to be used in a

 *	threaded environment.

 *

 * Results:

 *	See documentation of C functions.

 *

 * Side effects:

 *	See documentation of C functions.

 *

 * Notes:

 * 	TclpReaddir is no longer used by the core (see 1095909),

 * 	but it appears in the internal stubs table (see #589526).

 *----------------------------------------------------------------------

 */

Tcl_DirEntry *

TclpReaddir(DIR * dir)

{

    return TclOSreaddir(dir);

}

char *

TclpInetNtoa(struct in_addr addr)

{

#ifdef TCL_THREADS

    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);

    unsigned char *b = (unsigned char*) &addr.s_addr;

    sprintf(tsdPtr->nabuf, "%u.%u.%u.%u", b[0], b[1], b[2], b[3]);

    return tsdPtr->nabuf;

#else

    return inet_ntoa(addr);

#endif

}

#if defined(TCL_THREADS) && defined(USE_THREAD_ALLOC) && !defined(TCL_MEM_DEBUG)

/*

 * Additions by AOL for specialized thread memory allocator.

 */

#ifdef USE_THREAD_ALLOC

static volatile int initialized = 0;

static pthread_key_t	key;

typedef struct allocMutex {

    Tcl_Mutex       tlock;

    pthread_mutex_t plock;

} allocMutex;

Tcl_Mutex *

TclpNewAllocMutex(void)

{

    struct allocMutex *lockPtr;

    lockPtr = malloc(sizeof(struct allocMutex));

    if (lockPtr == NULL) {

	panic("could not allocate lock");

    }

    lockPtr->tlock = (Tcl_Mutex) &lockPtr->plock;

    pthread_mutex_init(&lockPtr->plock, NULL);

    return &lockPtr->tlock;

}

void

TclpFreeAllocMutex(mutex)

    Tcl_Mutex *mutex; /* The alloc mutex to free. */

{

    allocMutex* lockPtr = (allocMutex*) mutex;

    if (!lockPtr) return;

    pthread_mutex_destroy(&lockPtr->plock);

    free(lockPtr);

}

void TclpFreeAllocCache(ptr)

    void *ptr;

{

    if (ptr != NULL) {

        /*

         * Called by the pthread lib when a thread exits

         */

        TclFreeAllocCache(ptr);

    } else if (initialized) {

        /*

         * Called by us in TclFinalizeThreadAlloc() during

         * the library finalization initiated from Tcl_Finalize()

         */

        pthread_key_delete(key);

        initialized = 0;

    }

}

void *

TclpGetAllocCache(void)

{

    if (!initialized) {

	pthread_mutex_lock(allocLockPtr);

	if (!initialized) {

	    pthread_key_create(&key, TclpFreeAllocCache);

	    initialized = 1;

	}

	pthread_mutex_unlock(allocLockPtr);

    }

    return pthread_getspecific(key);

}

void

TclpSetAllocCache(void *arg)

{

    pthread_setspecific(key, arg);

}

#endif /* USE_THREAD_ALLOC */

#endif /* TCL_THREADS */