source: trunk/kernel/kern/cond_var.c @ 8

/*
 * kern/cond_var.c - condition variables implementation
 * 
 * Copyright (c) 2008,2009,2010,2011,2012 Ghassan Almaless
 * Copyright (c) 2011,2012 UPMC Sorbonne Universites
 *
 * This file is part of ALMOS-kernel.
 *
 * ALMOS-kernel 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-kernel 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-kernel; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include <types.h>
#include <errno.h>
#include <thread.h>
#include <kmem.h>
#include <scheduler.h>
#include <spinlock.h>
#include <wait_queue.h>
#include <kmagics.h>
#include <semaphore.h>
#include <cond_var.h>

error_t cv_init(struct cv_s *cv)
{  
        spinlock_init(&cv->lock, "CondVar Sync");
        cv->signature = COND_VAR_ID;
        wait_queue_init(&cv->wait_queue, "Condition Variable Sync");
        return 0;
}

error_t cv_wait(struct cv_s *cv, struct semaphore_s *sem)
{  
        int value;
        register error_t err;
        register struct thread_s *this;

        this = current_thread;
        (void)sem_getvalue(sem, &value);

        if((sem->owner != this) || (value > 0))
        {
                if(sem->scope == SEM_SCOPE_SYS)
                {
                        printk(ERROR,"ERROR: cv_wait: TID %x, sem %x is not owned or not locked [ value %d ]\n",
                               this, 
                               sem, 
                               value);
                }
                return EINVAL;
        }

        spinlock_lock(&cv->lock);

        if((err=sem_post(sem)))
        {
                spinlock_unlock(&cv->lock);
                return err;
        }

        wait_on(&cv->wait_queue, WAIT_LAST);

        spinlock_unlock_nosched(&cv->lock);
        sched_sleep(current_thread);

        return sem_wait(sem);
}

error_t cv_signal(struct cv_s *cv)
{
        struct thread_s *thread;

        spinlock_lock(&cv->lock);
        thread = wakeup_one(&cv->wait_queue, WAIT_FIRST); 
        spinlock_unlock(&cv->lock);
        return 0;
}

error_t cv_broadcast(struct cv_s *cv)
{
        spinlock_lock(&cv->lock);
        wakeup_all(&cv->wait_queue); 
        spinlock_unlock(&cv->lock);
        return 0;
}

error_t cv_destroy(struct cv_s *cv)
{
        register error_t err = 0;

        spinlock_lock(&cv->lock);

        if(!(wait_queue_isEmpty(&cv->wait_queue)))
                err = EBUSY;
    
        spinlock_unlock(&cv->lock);
  
        return err;
}