source: trunk/sys/libpthread/pthread.c @ 218

/*
 * pthread.c - threads creation/synchronization related functions
 * 
 * Copyright (c) 2008,2009,2010,2011,2012 Ghassan Almaless
 * Copyright (c) 2011,2012 UPMC Sorbonne Universites
 *
 * This file is part of ALMOS.
 *
 * ALMOS is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by
 * the Free Software Foundation; version 2.0 of the License.
 *
 * ALMOS is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with ALMOS; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include <sys/types.h>
#include <errno.h>
#include <stdio.h>
#include <stdint.h>
#include <assert.h>
#include <stdlib.h>
#include <sys/syscall.h>
#include <cpu-syscall.h>
#include <stdlib.h>
#include <string.h>

#include <pthread.h>

pthread_mutex_t __printf_lock = PTHREAD_MUTEX_INITIALIZER;
uint_t ___dmsg_lock = 0;
uint_t ___dmsg_ok = 0;

void __pthread_init(void)
{
        __pthread_keys_init();
        __pthread_barrier_init();
}

void __pthread_tls_init(struct __pthread_tls_s *tls)
{
        memset(tls, 0, sizeof(*tls));
        tls->signature = __PTHREAD_OBJECT_CREATED;
        cpu_set_tls(tls);
        cpu_syscall(&tls->attr,NULL,NULL,NULL,SYS_GETATTR);
}

void pthread_exit (void *retval)
{
        cpu_syscall(retval,NULL,NULL,NULL,SYS_EXIT);
}

static void* __pthread_start(void* (*entry_func)(void*), void *arg)
{
        void *retval;
        __pthread_tls_t tls;
        pthread_t tid;
        struct __shared_s *shared;
  
        __pthread_tls_init(&tls);

        shared          = arg;
        shared->tid     = tls.attr.key;
        shared->mailbox = 0;

        __pthread_tls_set(&tls,__PT_TLS_SHARED, shared);

#if 0
        fprintf(stderr, "%s: tid %d, shared %x\n", 
                __FUNCTION__, 
                shared->tid, 
                (unsigned) shared);
#endif

        retval = entry_func(shared->arg);
  
        __pthread_keys_destroy();
        tid = pthread_self();

        if(tid != tls.attr.key)
        {
                fprintf(stderr,"tid %d, found %d\n", (uint32_t)tls.attr.key, (uint32_t)tid);
                while(1);
        }
 
        pthread_exit(retval);
        return retval;          /* fake return */
}

static void __pthread_sigreturn(void)
{
        cpu_syscall(NULL,NULL,NULL,NULL,SYS_SIGRETURN);
}


int pthread_create (pthread_t *thread, pthread_attr_t *attr, void *(*start_routine) (void *), void *arg)
{
        register int retval;
        pthread_attr_t _attr;
        struct __shared_s *shared;

        //___dmsg_ok = 1;

        if(attr == NULL)
        {
                pthread_attr_init(&_attr);
                attr = &_attr;
        }

        if(attr->stack_addr != NULL)
        {
                if((attr->sigstack_addr = valloc(1)) == NULL)
                        return ENOMEM;

                attr->sigstack_size = 2048;
                shared = (struct __shared_s*)(attr->sigstack_addr + attr->sigstack_size + 64);
        }
        else
        {
                shared = malloc(sizeof(*shared));

                if(shared == NULL)
                        return ENOMEM;

                //fprintf(stderr, "%s: shared @%x\n", __FUNCTION__, (unsigned) shared);
        }
  
        shared->arg          = arg;
        attr->entry_func     = (void*)__pthread_start;
        attr->exit_func      = (void*)pthread_exit;
        attr->sigreturn_func = (void*)__pthread_sigreturn;
        attr->arg1           = (void*)start_routine;
        attr->arg2           = shared;
        
        retval = (int)cpu_syscall((void*)thread,attr,NULL,NULL,SYS_CREATE);
        return retval;
}

int pthread_join (pthread_t th, void **thread_return)
{
        register int retval;
        retval = (int)cpu_syscall((void*)th,(void*)thread_return,NULL,NULL,SYS_JOIN);
        return retval;
}

int pthread_detach(pthread_t thread)
{
        register int retval; 
        retval = (int)cpu_syscall((void*)thread,NULL,NULL,NULL,SYS_DETACH);
        return retval;
}

int pthread_migrate_np(pthread_attr_t *attr)
{
        register __pthread_tls_t *tls;
        register int retval;
        pthread_attr_t _attr;

        if(attr == NULL)
        {
                pthread_attr_init(&_attr);
                attr = &_attr;
        }

        retval = (int)cpu_syscall((void*)attr,NULL,NULL,NULL,SYS_MIGRATE);

        if(retval == 0)
        {
                tls = cpu_get_tls();
                cpu_syscall(&tls->attr,NULL,NULL,NULL,SYS_GETATTR);
        }

        return retval;
}

void pthread_yield (void)
{
        cpu_syscall(NULL,NULL,NULL,NULL,SYS_YIELD);
}

int pthread_once(pthread_once_t *once_control, void (*init_routine) (void))
{
        if((once_control == NULL) || (init_routine == NULL))
                return EINVAL;

        if(cpu_spinlock_trylock(&once_control->lock))
                return 0;

        if(once_control->state != 0)
        {
                cpu_spinlock_unlock(&once_control->lock);
                return 0;
        }
    
        once_control->state = 1;
        cpu_spinlock_unlock(&once_control->lock);

        init_routine();

        return 0;
}

pthread_t pthread_self (void)
{
        __pthread_tls_t *tls;

        tls = cpu_get_tls();
        assert((tls != NULL) && (tls->signature == __PTHREAD_OBJECT_CREATED));
        return (pthread_t) tls->attr.key;
}

int pthread_equal (pthread_t thread1, pthread_t thread2)
{
        return thread1 == thread2;
}

int pthread_profiling_np(int cmd, pid_t pid, pthread_t tid)
{
        return (int)cpu_syscall((void*)cmd, (void*)pid, (void*)tid, NULL,SYS_PS);
}