pthread.c

Go to the documentation of this file.

 
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#include <unistd.h>
#include <errno.h>
#include <pthread.h>
 
#include <core/mutex.h>
 
#include <syscall.h>
#include <sys/syscall.h>
 
struct pthread_attr {
    uint64_t    _unused;
};
 
struct pthread {
    uint64_t    tid;
    int         error;                      // errno
    TAILQ_ENTRY(pthread)    threadTable;
 
    // Initialization
    void        *(*entry)(void *);
    void        *arg;
 
    // Termination
    void        *result;
 
    // Condition Variables
    TAILQ_ENTRY(pthread)    cvTable;
};
 
typedef TAILQ_HEAD(pthreadList, pthread) pthreadList;
 
#define THREAD_HASH_SLOTS       32
 
static CoreMutex __threadTableLock;
static pthreadList __threads[THREAD_HASH_SLOTS];
 
int *
__error(void)
{
    struct pthread *pth = pthread_self();
 
    return &(pth->error);
}
 
void
__pthread_init(void)
{
    int i;
    struct pthread *thr = (struct pthread *)malloc(sizeof(*thr));
 
    for (i = 0; i < THREAD_HASH_SLOTS; i++) {
        TAILQ_INIT(&__threads[i]);
    }
 
    if (thr == NULL) {
        abort();
    }
 
    thr->tid = OSGetTID();
    thr->error = 0;
    thr->entry = NULL;
    thr->arg = 0;
 
    CoreMutex_Init(&__threadTableLock);
 
    CoreMutex_Lock(&__threadTableLock);
    TAILQ_INSERT_HEAD(&__threads[thr->tid % THREAD_HASH_SLOTS], thr, threadTable);
    CoreMutex_Unlock(&__threadTableLock);
}
 
pthread_t
pthread_self(void)
{
    int tid = OSGetTID();
    struct pthread *thr;
 
    CoreMutex_Lock(&__threadTableLock);
    TAILQ_FOREACH(thr, &__threads[tid % THREAD_HASH_SLOTS], threadTable) {
        if (thr->tid == tid) {
            CoreMutex_Unlock(&__threadTableLock);
            return thr;
        }
    }
    CoreMutex_Unlock(&__threadTableLock);
 
    printf("pthread_self failed to find current thread!\n");
    abort();
}
 
void
pthreadCreateHelper(void *arg)
{
    struct pthread *thr = (struct pthread *)arg;
 
    thr->result = (thr->entry)(thr->arg);
 
    OSThreadExit(0);
}
 
int
pthread_create(pthread_t *thread, const pthread_attr_t *attr,
               void *(*start_routine)(void *), void *arg)
{
    uint64_t status;
    struct pthread *thr;
 
    thr = malloc(sizeof(*thr));
    if (!thr) {
        return EAGAIN;
    }
 
    memset(thr, 0, sizeof(*thr));
 
    thr->entry = start_routine;
    thr->arg = arg;
 
    status = OSThreadCreate((uintptr_t)&pthreadCreateHelper, (uint64_t)thr);
    if (SYSCALL_ERRCODE(status) != 0) {
        free(thr);
        return SYSCALL_ERRCODE(status);
    }
 
    thr->tid = SYSCALL_VALUE(status);
 
    CoreMutex_Lock(&__threadTableLock);
    TAILQ_INSERT_HEAD(&__threads[thr->tid % THREAD_HASH_SLOTS], thr, threadTable);
    CoreMutex_Unlock(&__threadTableLock);
 
    *thread = thr;
 
    return 0;
}
 
void
pthread_exit(void *value_ptr)
{
    struct pthread *thr = pthread_self();
 
    thr->result = value_ptr;
 
    OSThreadExit(0);
}
 
int
pthread_join(pthread_t thread, void **value_ptr)
{
    struct pthread *thr = thread;
    uint64_t status = OSThreadWait(0);//thr->tid);
    if (SYSCALL_ERRCODE(status) != 0) {
        return status;
    }
 
    *value_ptr = (void *)thr->result;
 
    CoreMutex_Lock(&__threadTableLock);
    TAILQ_REMOVE(&__threads[thr->tid % THREAD_HASH_SLOTS], thr, threadTable);
    CoreMutex_Unlock(&__threadTableLock);
 
    // Cleanup
    free(thr);
 
    return 0;
}
 
void
pthread_yield(void)
{
    OSThreadSleep(0);
}
 
/*
 * Barriers
 */
 
int
pthread_barrier_init(pthread_barrier_t *barrier,
                     const pthread_barrierattr_t *attr,
                     unsigned count)
{
    return EINVAL;
}
 
int
pthread_barrier_destroy(pthread_barrier_t *barrier)
{
    return EINVAL;
}
 
int
pthread_barrier_wait(pthread_barrier_t *barrier)
{
    return EINVAL;
}
 
/*
 * Mutex
 */
 
struct pthread_mutexattr {
    uint64_t    _unused;
};
 
struct pthread_mutex {
    uint64_t    lock;
};
 
int
pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr)
{
    struct pthread_mutex *mtx = (struct pthread_mutex *)malloc(sizeof(*mtx));
 
    if (mtx == NULL) {
        return ENOMEM;
    }
 
    mtx->lock = 0;
    *mutex = mtx;
 
    return 0;
}
 
int
pthread_mutex_destroy(pthread_mutex_t *mutex)
{
    struct pthread_mutex *mtx = *mutex;
 
    if (mtx == NULL) {
        return EINVAL;
    } else if (mtx->lock == 1) {
        return EBUSY;
    } else {
        *mutex = NULL;
        free(mtx);
        return 0;
    }
}
 
int
pthread_mutex_lock(pthread_mutex_t *mutex)
{
    struct pthread_mutex *mtx;
    
    if (*mutex == NULL) {
        int status = pthread_mutex_init(mutex, NULL);
        if (status != 0)
            return status;
    }
 
    mtx = *mutex;
 
    // XXX: Should have the kernel wait kernel instead of yielding
    while (__sync_lock_test_and_set(&mtx->lock, 1) == 1) {
        OSThreadSleep(0);
    }
 
    return 0;
}
 
int
pthread_mutex_trylock(pthread_mutex_t *mutex)
{
    struct pthread_mutex *mtx;
 
    if (*mutex == NULL) {
        int status = pthread_mutex_init(mutex, NULL);
        if (status != 0)
            return status;
    }
 
    mtx = *mutex;
 
    if (__sync_lock_test_and_set(&mtx->lock, 1) == 1) {
        return EBUSY;
    } else {
        // Lock acquired
        return 0;
    }
}
 
int
pthread_mutex_unlock(pthread_mutex_t *mutex)
{
    struct pthread_mutex *mtx;
 
    if (*mutex == NULL) {
        int status = pthread_mutex_init(mutex, NULL);
        if (status != 0)
            return status;
    }
 
    mtx = *mutex;
 
    __sync_lock_release(&mtx->lock);
    // XXX: Wakeup a sleeping thread
 
    return 0;
}
 
 
/*
 * Reader/Writer Lock
 */
 
/*
 * Condition Variables
 */
 
struct pthread_condattr {
    uint64_t    _unused;
};
 
struct pthread_cond {
    CoreMutex   mtx;
    uint64_t    enter;
    uint64_t    exit;
};
 
int
pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr)
{
    struct pthread_cond *cnd = (struct pthread_cond *)malloc(sizeof(*cnd));
 
    if (cnd == NULL) {
        return ENOMEM;
    }
 
    CoreMutex_Init(&cnd->mtx);
    cnd->enter = 0;
    cnd->exit = 0;
 
    *cond = cnd;
 
    return 0;
}
 
int
pthread_cond_destroy(pthread_cond_t *cond)
{
    struct pthread_cond *cnd = *cond;
 
    *cond = NULL;
    free(cnd);
 
    return 0;
}
 
int
pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
{
    int status;
    struct pthread_cond *cnd;
    uint64_t level;
 
    if (*cond == NULL) {
        status = pthread_cond_init(cond, NULL);
        if (status != 0)
            return status;
    }
    cnd = *cond;
 
    if (mutex) {
        status = pthread_mutex_unlock(mutex);
        if (status != 0)
            return status;
    }
 
    CoreMutex_Lock(&cnd->mtx);
    level = cnd->enter;
    cnd->enter++;
    CoreMutex_Unlock(&cnd->mtx);
 
    while (level >= cnd->exit) {
        OSThreadSleep(0);
    }
 
    if (mutex) {
        status = pthread_mutex_lock(mutex);
        if (status != 0)
            return status;
    }
 
    return 0;
}
 
int
pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex,
                       const struct timespec *abstime)
{
    int status = 0;
    int rstatus = 0;
    struct pthread_cond *cnd;
    uint64_t level;
    uint64_t endtime = abstime->tv_sec * 1000000000 + abstime->tv_nsec;
 
    if (*cond == NULL) {
        status = pthread_cond_init(cond, NULL);
        if (status != 0)
            return status;
    }
    cnd = *cond;
 
    if (mutex) {
        status = pthread_mutex_unlock(mutex);
        if (status != 0)
            return status;
    }
 
    CoreMutex_Lock(&cnd->mtx);
    level = cnd->enter;
    cnd->enter++;
    CoreMutex_Unlock(&cnd->mtx);
 
    while (level >= cnd->exit) {
        OSThreadSleep(0);
 
        if (endtime < OSTime()) {
            rstatus = ETIMEDOUT;
            break;
        }
    }
 
    if (mutex) {
        status = pthread_mutex_lock(mutex);
        if (status != 0)
            return status;
    }
 
    return rstatus;
}
 
 
int
pthread_cond_signal(pthread_cond_t *cond)
{
    struct pthread_cond *cnd;
 
    if (*cond == NULL) {
        int status = pthread_cond_init(cond, NULL);
        if (status != 0)
            return status;
    }
    cnd = *cond;
 
    CoreMutex_Lock(&cnd->mtx);
    cnd->exit++;
    CoreMutex_Unlock(&cnd->mtx);
 
    return 0;
}
 
int
pthread_cond_broadcast(pthread_cond_t *cond)
{
    struct pthread_cond *cnd;
 
    if (*cond == NULL) {
        int status = pthread_cond_init(cond, NULL);
        if (status != 0)
            return status;
    }
    cnd = *cond;
 
    CoreMutex_Lock(&cnd->mtx);
    cnd->exit = cnd->enter;
    CoreMutex_Unlock(&cnd->mtx);
 
    return 0;
}