*
* threads_int.c
* - Internal threading functions
+ *
+ * POSIX Mutex/Semaphore management
+ * Wait state
*/
#include <stddef.h>
#include <stdlib.h>
#include <stdint.h>
+#include <stdio.h> // printf debugging
#include <acess_logging.h>
#include <threads_int.h>
#include <pthread_weak.h>
+#include <shortlock.h>
// === TYPES ===
-typedef struct sThread tThread;
struct sThreadIntMutex { int lock; };
struct sThreadIntSem { int val; };
// === CODE ===
int Threads_int_ThreadingEnabled(void)
{
- Log_Debug("Threads", "pthread_create = %p", pthread_create);
return !!pthread_create;
}
tThreadIntMutex *Threads_int_MutexCreate(void)
{
- if( pthread_mutex_init )
+ if( Threads_int_ThreadingEnabled() )
{
tThreadIntMutex *ret = malloc(sizeof(pthread_mutex_t));
pthread_mutex_init( (void*)ret, NULL );
if( !Mutex ) {
return ;
}
- if( pthread_mutex_lock )
+ if( Threads_int_ThreadingEnabled() )
{
pthread_mutex_lock( (void*)Mutex );
}
return ;
}
- if( pthread_mutex_unlock )
+ if( Threads_int_ThreadingEnabled() )
{
pthread_mutex_unlock( (void*)Mutex );
}
tThreadIntSem *Threads_int_SemCreate(void)
{
- if( sem_init )
+ if( Threads_int_ThreadingEnabled() )
{
tThreadIntSem *ret = malloc(sizeof(sem_t));
sem_init( (void*)ret, 0, 0 );
void Threads_int_SemSignal(tThreadIntSem *Sem)
{
- if( sem_wait )
+ if( Threads_int_ThreadingEnabled() )
{
- sem_wait( (void*)Sem );
+ sem_post( (void*)Sem );
}
else
{
void Threads_int_SemWaitAll(tThreadIntSem *Sem)
{
- if( sem_post )
+ if( Threads_int_ThreadingEnabled() )
{
- sem_post( (void*)Sem );
+ // TODO: Handle multiples
+ sem_wait( (void*)Sem );
+ while( sem_trywait((void*)Sem) )
+ ;
}
else
{
int Threads_int_CreateThread(tThread *Thread)
{
- if( pthread_create )
+ if( Threads_int_ThreadingEnabled() )
{
pthread_t *pthread = malloc(sizeof(pthread_t));
Thread->ThreadHandle = pthread;
}
}
+void SHORTLOCK(tShortSpinlock *Lock)
+{
+ if( Threads_int_ThreadingEnabled() )
+ {
+ if( !*Lock ) {
+ *Lock = malloc(sizeof(pthread_mutex_t));
+ pthread_mutex_init(*Lock, NULL);
+ }
+// printf("%p: SHORTLOCK wait\n", lpThreads_This);
+ pthread_mutex_lock(*Lock);
+// printf("%p: SHORTLOCK held %p\n", lpThreads_This, __builtin_return_address(0));
+ }
+ else
+ {
+ if(*Lock) Log_KernelPanic("---", "Double short lock");
+ *Lock = (void*)1;
+ }
+}
+
+void SHORTREL(tShortSpinlock *Lock)
+{
+ if( Threads_int_ThreadingEnabled() )
+ {
+ pthread_mutex_unlock(*Lock);
+// printf("%p: SHORTLOCK rel\n", lpThreads_This);
+ }
+ else
+ {
+ if(!*Lock) Log_Notice("---", "Short release when not held");
+ *Lock = NULL;
+ }
+}
+
+int CPU_HAS_LOCK(tShortSpinlock *Lock)
+{
+ if( Threads_int_ThreadingEnabled() )
+ {
+ Log_KernelPanic("---", "TODO: CPU_HAS_LOCK with threading enabled");
+ return 0;
+ }
+ else
+ {
+ return 0;
+ }
+}