source: trunk/sys/libpthread/pthread_condition.c @ 189

/*
 * pthread.c -  conditions variables 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 <semaphore.h>
#include <pthread.h>
#include <sys/syscall.h>
#include <cpu-syscall.h>

typedef enum
{
        CV_INIT,
        CV_WAIT,
        CV_SIGNAL,
        CV_BROADCAST,
        CV_DESTROY
} cv_operation_t;

static int __sys_cond_var(void *sysid, int operation, sem_t *sem)
{
        register int retval;
  
        retval = (int)cpu_syscall(sysid,(void*)operation,(void*)sem,NULL,SYS_COND_VAR);
        return retval;
}

int pthread_condattr_init(pthread_condattr_t *attr)
{
        if(attr == NULL)
                return EINVAL;

        attr->scope = PTHREAD_PROCESS_PRIVATE;
        return 0;
}

int pthread_condattr_destroy(pthread_condattr_t *attr)
{
        if(attr == NULL)
                return EINVAL;

        attr->scope = -1;
        return 0;
}

int pthread_condattr_getpshared(pthread_condattr_t *attr, int *scope)
{
        if((attr == NULL) || (attr->scope < 0) || (scope == NULL))
                return EINVAL;

        *scope = attr->scope;
        return 0;
}

int pthread_condattr_setpshared(pthread_condattr_t *attr, int scope)
{
        if((attr == NULL) || ((scope != PTHREAD_PROCESS_PRIVATE) && (scope != PTHREAD_PROCESS_SHARED)))
                return EINVAL;

        attr->scope = scope;
        return 0;
}

int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cond_attr)
{
        int err;

        if(cond == NULL) return EINVAL;

        if((cond_attr != NULL) && (cond_attr->scope == PTHREAD_PROCESS_SHARED))
        {
                cond->scope = PTHREAD_PROCESS_SHARED;
                return __sys_cond_var(&cond->sysid, CV_INIT, NULL);
        }

        cond->scope = PTHREAD_PROCESS_PRIVATE;

        err = pthread_spin_init(&cond->lock, 0);

        if(err) return err;

        cond->count = 0;
        return 0;
}

int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
{
        register __pthread_tls_t *tls;
        register struct __shared_s *shared;
        int err;

        if((cond == NULL) || (mutex == NULL) || (mutex->attr.scope != cond->scope))
                return EINVAL;

        if(cond->scope == PTHREAD_PROCESS_SHARED)
                return __sys_cond_var(&cond->sysid, CV_WAIT, &mutex->sem);

        if(cond->count == 0)
                list_root_init(&cond->queue);
  
        cond->count ++;

        tls = cpu_get_tls();
        shared = (struct __shared_s*)__pthread_tls_get(tls, __PT_TLS_SHARED);

        list_add_last(&cond->queue, &shared->list);

        (void)pthread_mutex_unlock(mutex);

        /* TODO: compute syscall return value (signals treatment) */
        (void)cpu_syscall(NULL, NULL, NULL, NULL, SYS_SLEEP);
  
        err = pthread_mutex_lock(mutex);
        return err;
}

int pthread_cond_signal(pthread_cond_t *cond)
{
        struct __shared_s *next;
        int err;

        if(cond == NULL) return EINVAL;

        if(cond->scope == PTHREAD_PROCESS_SHARED)
                return __sys_cond_var(&cond->sysid, CV_SIGNAL, NULL);

        if(cond->count == 0)
                return 0;

        next = list_first(&cond->queue, struct __shared_s, list);
        list_unlink(&next->list);
        cond->count --;

        (void)cpu_syscall((void*)next->tid, NULL, NULL, NULL, SYS_WAKEUP);
        return 0;
}

int pthread_cond_broadcast(pthread_cond_t *cond)
{
        struct list_entry root;
        struct list_entry *list;
        struct __shared_s *next;
        uint_t count;
        uint_t i;
        int err = 0;
  
        if(cond == NULL) return EINVAL;
  
        if(cond->scope == PTHREAD_PROCESS_SHARED)
                return __sys_cond_var(&cond->sysid, CV_BROADCAST, NULL);

        if(cond->count == 0)
        {
                return 0;
        }

        count       = cond->count;
        cond->count = 0;
        list_replace(&cond->queue, &root);

        uint_t tbl[100];

        i = 0;
  
        while(count)
        {
                list_foreach_forward(&root, list)
                {
                        next   = list_element(list, struct __shared_s, list);
                        list_unlink(&next->list);
                        tbl[i] = next->tid;
                        count --;
                        i++;

                        if(i == 100)
                        {
                                i = 0;
                                (void)cpu_syscall((void*)tbl[0], (void*)&tbl[0], (void*)100, NULL, SYS_WAKEUP);
                        }
                }
        }

        if(i != 0)
                (void)cpu_syscall((void*)tbl[0], (void*)&tbl[0], (void*)i, NULL, SYS_WAKEUP);
    
        return err;
}

int pthread_cond_destroy(pthread_cond_t *cond)
{
        int err = 0;
  
        if(cond == NULL)
                return EINVAL;

        if(cond->scope == PTHREAD_PROCESS_SHARED)
                return __sys_cond_var(&cond->sysid, CV_DESTROY, NULL);

        if(cond->count != 0)
                err = EBUSY;

        return err;
}