--- a/epoc32/include/stdapis/pthread.h Tue Nov 24 13:55:44 2009 +0000
+++ b/epoc32/include/stdapis/pthread.h Tue Mar 16 16:12:26 2010 +0000
@@ -1,1 +1,471 @@
-pthread.h
+/*
+* ==============================================================================
+* Name : pthread.h
+* Part of : pthread
+* Interface : POSIX, pthread
+* Description : POSIX thread exported header file
+* Version :
+
+Copyright © 2005-2006 Nokia Corporation
+All rights reserved.
+* © Portions copyright (c) 2007 Symbian Software Ltd. All rights reserved.
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+ * Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ * Neither the name of the <ORGANIZATION> nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+* ==============================================================================
+*/
+#ifndef PTHREAD_H
+#define PTHREAD_H
+
+#include <pthreadtypes.h>
+#include <sched.h>
+#include <e32def.h>
+#include <stddef.h>
+#include <time.h>
+#include <limits.h>
+#include <pthreadalias.h>
+
+#define POSIX_THREAD_DESTRUCTOR_ITERATIONS 4
+#define POSIX_THREAD_KEYS_MAX 128
+#define PTHREAD_STACK_MIN 0x2000
+#define POSIX_THREAD_THREADS_MAX 64
+#define PTHREAD_THREADS_MAX 1024
+#define POSIX_SEM_NSEMS_MAX 256
+#define SEM_NSEMS_MAX 1024
+#define _POSIX_SEM_VALUE_MAX 32767
+#define SEM_VALUE_MAX INT_MAX
+
+/* internal use*/
+typedef enum
+{
+ _ENeedsNormalInit =-3,
+ _ENeedsRecursiveInit,
+ _ENeedsErrorCheckInit,
+ _EInitialized =1,
+ _EDestroyed,
+ _EInvalid,
+}_handle_state;
+
+enum _LockStatus
+{
+ _ELockNotCreated,
+ _ELockCreating,
+ _ELockCreated,
+};
+
+enum _OnceStatus
+{
+ _ENotDone,
+ _EDoing,
+ _EDone,
+};
+
+typedef int pthread_once_t;
+
+struct _pthread_mutex_t;
+typedef struct
+{
+ _handle_state iState;
+ struct _pthread_mutex_t* iPtr;
+ int iReentry;
+}pthread_mutex_t;
+
+typedef struct
+{
+ _handle_state iState;
+ int iSharedType;
+ int iMutexType;
+}pthread_mutexattr_t;
+
+
+struct _CondNode;
+struct _CondQueue
+{
+ struct _CondNode* iHead;
+ struct _CondNode* iTail;
+ pthread_mutex_t iMutex;
+};
+
+typedef struct
+{
+ _handle_state iState;
+ struct _CondQueue iQueue;
+}pthread_cond_t;
+
+typedef struct _pthread_condattr_t* pthread_condattr_t;
+
+#define PTHREAD_ONCE_INIT _ENotDone
+
+#define PTHREAD_MUTEX_INITIALIZER { _ENeedsNormalInit, NULL,0 }
+#define PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP { _ENeedsRecursiveInit, NULL, 0 }
+#define PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP { _ENeedsErrorCheckInit, NULL,0 }
+
+#define PTHREAD_COND_INITIALIZER { _ENeedsNormalInit, NULL,NULL }
+
+enum
+{
+ PTHREAD_CREATE_JOINABLE = 0, /* Default */
+ PTHREAD_CREATE_DETACHED = 1
+};
+
+enum
+{
+ PTHREAD_SCOPE_SYSTEM = 1 /* Default */
+};
+
+enum
+{
+ PTHREAD_CANCEL_ASYNCHRONOUS = 0,
+ PTHREAD_CANCEL_DEFERRED = 1 /* Default */
+};
+
+enum
+{
+ PTHREAD_PROCESS_PRIVATE = 0,
+};
+
+enum
+{
+ PTHREAD_MUTEX_NORMAL,
+ PTHREAD_MUTEX_RECURSIVE,
+ PTHREAD_MUTEX_ERRORCHECK,
+ PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL
+};
+
+
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+typedef void * (*thread_begin_routine)(void *);
+/*
+This function creates a thread, with attributes specified by attrib,
+within a process. If attrib is NULL, then default attributes will be used.
+On successful completion, pthread_create() will store the ID of the
+created thread in the location referenced by threadhdl.
+*/
+IMPORT_C extern int pthread_create(pthread_t *threadhdl, pthread_attr_t *attrib,
+ thread_begin_routine begin_routine , void * param);
+/*
+This function return the handle to current thread.
+*/
+IMPORT_C extern pthread_t pthread_self ();
+
+/*
+Compare two thread handles
+*/
+IMPORT_C extern int pthread_equal(pthread_t t1,pthread_t t2);
+/*
+Waiting for thread termination
+*/
+IMPORT_C extern int pthread_join(pthread_t thHandle, void **retValPtr);
+/*
+detach from thread
+*/
+IMPORT_C extern int pthread_detach(pthread_t thrHandle);
+/*
+exit current thread
+*/
+IMPORT_C extern void pthread_exit(void *retValPtr);
+/*
+Initialise the thread attributes
+*/
+IMPORT_C int pthread_attr_init(pthread_attr_t *attrib);
+/*
+Destroy the thread attributes
+*/
+IMPORT_C int pthread_attr_destroy(pthread_attr_t *attrib);
+/*
+Get the detach_state of the current thread
+*/
+IMPORT_C int pthread_attr_getdetachstate(const pthread_attr_t *attrib,
+ int *detState);
+/*
+Set the detach_state of the current thread
+*/
+IMPORT_C int pthread_attr_setdetachstate(pthread_attr_t *attrib,
+ int detState);
+/*
+Get the stack size of the current thread
+*/
+IMPORT_C int pthread_attr_getstacksize(const pthread_attr_t *attrib,
+ size_t *stkSize);
+/*
+Set the stack size of the current thread
+*/
+IMPORT_C int pthread_attr_setstacksize(pthread_attr_t *attrib,
+ size_t stkSize);
+
+/*
+This function ensures that a piece of initialization code is executed at most once.
+The once_control argument must point to a static variable statically initialized to PTHREAD_ONCE_INIT
+
+*/
+typedef void (*thread_init_routine) (void);
+IMPORT_C extern int pthread_once (pthread_once_t * once_control,
+ thread_init_routine init_routine);
+
+/*
+extern int pthread_key_create (pthread_key_t * key, void (*destructor) (void *));
+extern int pthread_key_delete (pthread_key_t key);
+extern int pthread_setspecific (pthread_key_t key, const void *value);
+extern void* pthread_getspecific (pthread_key_t key);
+*/
+
+/*
+This function initializes the mutex attribute object attr and fills it with default values for the attributes.
+*/
+IMPORT_C extern int pthread_mutexattr_init (pthread_mutexattr_t * attr);
+
+/*
+This function destroys the mutex attribute object attr and marks it as a destroyed object.
+*/
+IMPORT_C extern int pthread_mutexattr_destroy (pthread_mutexattr_t * attr);
+
+/*
+This function retrieves the current value of the process shared attribute in
+attr and stores it in the location pointed to by pshared.
+*/
+IMPORT_C extern int pthread_mutexattr_getpshared (const pthread_mutexattr_t* attr, int* pshared);
+
+/*
+This function sets the current value of the process shared attribute in attr to the value specifed in the
+pshared variable.
+*/
+IMPORT_C extern int pthread_mutexattr_setpshared (pthread_mutexattr_t * attr, int pshared);
+
+/*
+This function retrieves the current value of the mutex kind attribute in attr and
+stores it in the location pointed to by type.
+*/
+IMPORT_C extern int pthread_mutexattr_gettype (pthread_mutexattr_t * attr, int *type);
+
+
+/*
+This function sets the current value of the mutex kind attribute in attr to the value specifed in the type variable.
+*/
+IMPORT_C extern int pthread_mutexattr_settype (pthread_mutexattr_t * attr, int type);
+
+/*
+This function initializes the mutex object pointed to by mutex according to the mutex attributes specified in attr.
+If attr is NULL, default attributes are used instead.
+
+*/
+IMPORT_C extern int pthread_mutex_init (pthread_mutex_t * mutex, const pthread_mutexattr_t * attr);
+
+/*
+This function destroys the mutex object. The mutex must be unlocked on entrance.
+This implementation requires even statically initialized mutexes to be explicitly destroyed.
+*/
+IMPORT_C extern int pthread_mutex_destroy (pthread_mutex_t * mutex);
+
+/*
+This function locks the given mutex. If the mutex is currently
+unlocked, it becomes locked and owned by the calling thread, and
+this function returns immediately. If the mutex is already
+locked by another thread, this function suspends the calling
+thread until the mutex is unlocked.
+
+If the mutex is already locked by the calling thread, the behavior of
+this function depends on the kind of the mutex. If the mutex is
+of the PTHREAD_MUTEX_NORMAL or PTHREAD_MUTEX_DEFAULT kind, the calling thread is suspended until the mutex
+is unlocked, thus effectively causing the calling thread to
+deadlock. If the mutex is of the PTHREAD_MUTEX_ERRORCHECK kind,
+this function returns immediately with the error code EDEADLK.
+If the mutex is of the PTHREAD_MUTEX_RECURSIVE kind, this function
+succeeds and returns immediately, recording the number of times the
+calling thread has locked the mutex. An equal number of
+pthread_mutex_unlock operations must be performed before the mutex
+returns to the unlocked state.
+*/
+IMPORT_C extern int pthread_mutex_lock (pthread_mutex_t * mutex);
+
+
+/*
+This function behaves identically to pthread_mutex_lock, except that if it cannot acquire the lock before
+the abs_timeout time, the call returns with the error code ETIMEDOUT.
+*/
+IMPORT_C extern int pthread_mutex_timedlock(pthread_mutex_t *mutex, const struct timespec *abstime);
+
+/*
+This function behaves identically to pthread_mutex_lock, except that it does not
+block the calling thread if the mutex is already locked by another thread (or by
+the calling thread in the case of a PTHREAD_MUTEX_RECURSIVE mutex). Instead, pthread_mutex_trylock
+returns immediately with the error code EAGAIN.
+*/
+IMPORT_C extern int pthread_mutex_trylock (pthread_mutex_t * mutex);
+
+/*
+This function unlocks the given mutex. The mutex is assumed
+to be locked and owned by the calling thread on entrance to
+this function. If the mutex is of the PTHREAD_MUTEX_NORMAL or PTHREAD_MUTEX_DEFAULT kind,
+this function always returns it to the unlocked state. If it
+is of the PTHREAD_MUTEX_RECURSIVE kind, it decrements the locking count of the
+mutex (number of pthread_mutex_lock operations performed on it by
+the calling thread), and only when this count reaches zero is the
+mutex actually unlocked.
+
+On PTHREAD_MUTEX_ERRORCHECK mutexes, this function actually checks
+at run-time that the mutex is locked on entrance, and that it was
+locked by the same thread that is now calling pthread_mutex_unlock.
+If these conditions are not met, an error code is returned and the
+mutex remains unchanged.
+*/
+IMPORT_C extern int pthread_mutex_unlock (pthread_mutex_t * mutex);
+
+/*
+This function initializes the condition attribute object attr and
+sets it with default values for the attributes.
+*/
+IMPORT_C extern int pthread_condattr_init (pthread_condattr_t * /*attr*/);
+
+/*
+This function destroys the condtion variable attribute object.
+*/
+IMPORT_C extern int pthread_condattr_destroy (pthread_condattr_t * attr);
+/*
+extern int pthread_condattr_getpshared (const pthread_condattr_t * attr, int *pshared);
+extern int pthread_condattr_setpshared (pthread_condattr_t * attr, int pshared);
+*/
+
+/*
+This function initializes the condition variable object pointed to by cond
+using the attributes of the attr variable. If attr is NULL, default attributes
+are used instead.
+*/
+IMPORT_C extern int pthread_cond_init (pthread_cond_t * cond, const pthread_condattr_t * /*attr*/);
+
+/*
+This function destroys the condition variable object.
+*/
+IMPORT_C extern int pthread_cond_destroy (pthread_cond_t * cond);
+
+/*
+This function atomically unlocks mutex and waits on cond,
+as pthread_cond_wait does, but it also bounds the duration
+of the wait. If cond has not been signalled within the amount
+of time specified by abstime, the mutex mutex is re-acquired and
+pthread_cond_timedwait returns the error ETIMEDOUT. The abstime
+parameter specifies an absolute time, with the same origin as time(2) and gettimeofday(2).
+*/
+IMPORT_C extern int pthread_cond_timedwait (pthread_cond_t * cond,pthread_mutex_t * mutex,const struct timespec *abstime);
+
+/*
+This function atomically unlocks the mutex (as per pthread_unlock_mutex)
+and waits for the condition variable cond to be signalled. The thread
+execution is suspended and does not consume any CPU time until the condition
+variable is signalled. The mutex must be locked by the calling thread on entrance
+to pthread_cond_wait. Before returning to the calling thread, pthread_cond_wait
+re-acquires mutex (as per pthread_lock_mutex).
+*/
+IMPORT_C extern int pthread_cond_wait (pthread_cond_t * cond, pthread_mutex_t * mutex);
+
+/*
+This function restarts one of the threads that are waiting on the condition
+variable cond. If no threads are waiting on cond, nothing happens. If several
+threads are waiting on cond, exactly one is restarted.
+
+*/
+IMPORT_C extern int pthread_cond_signal (pthread_cond_t * cond);
+
+/*
+This function restarts all the threads that are waiting on the
+condition variable cond. Nothing happens if no threads are waiting on cond.
+*/
+IMPORT_C extern int pthread_cond_broadcast (pthread_cond_t * cond);
+
+
+typedef void (*destructor_routine)(void *);
+/*
+Thread-specific data key creation
+*/
+IMPORT_C int pthread_key_create(pthread_key_t *key, destructor_routine dest);
+
+/*
+Thread-specific data key deletion
+*/
+IMPORT_C int pthread_key_delete(pthread_key_t key);
+
+/*
+Setting Thread-specific data
+*/
+IMPORT_C int pthread_setspecific(pthread_key_t key, const void *val);
+
+/*
+Getting Thread-specific data
+*/
+IMPORT_C void* pthread_getspecific(pthread_key_t key);
+
+/*
+Getting contention scope
+*/
+IMPORT_C int pthread_attr_getscope(const pthread_attr_t *attrib,
+ int* scope);
+/*
+Setting contention scope
+*/
+IMPORT_C int pthread_attr_setscope(pthread_attr_t *attrib,int conscope);
+
+/*
+Setting scheduling policy
+*/
+IMPORT_C int pthread_attr_setschedpolicy(pthread_attr_t *attrib,
+ int policy);
+
+/*
+Getting scheduling policy of the thread
+*/
+IMPORT_C int pthread_attr_getschedpolicy(const pthread_attr_t *attrib,
+ int *policy);
+
+/*
+Getting scheduling param of the thread
+*/
+IMPORT_C int pthread_attr_getschedparam(const pthread_attr_t *attrib,
+ struct sched_param *param);
+
+/*
+Setting scheduling param
+*/
+IMPORT_C int pthread_attr_setschedparam(pthread_attr_t *attrib,
+ const struct sched_param *param);
+
+/*
+Getting dynamic scheduling param of the thread
+*/
+IMPORT_C int pthread_getschedparam(pthread_t thr, int *policy,
+ struct sched_param *param);
+
+/*
+Dynamically Setting scheduling params
+*/
+IMPORT_C int pthread_setschedparam(pthread_t th, int policy,
+ const struct sched_param *param);
+
+#ifdef __cplusplus
+} /* End of "C" */
+#endif /* __cplusplus */
+
+
+#endif /* PTHREAD_H */
+