/*
 * Implementação de mutex locks e variáveis de condição
 * utilizando semáforos.
 */

#include <stdlib.h>
#include "mutex_lista.h"

int mutex_init(mutex_t *lock, mutexattr_t* attr) {
  return sem_init(&lock->sem, 0, 1);
}

int mutex_destroy(mutex_t *lock) {
  return sem_destroy(&lock->sem);
}

int mutex_lock(mutex_t *lock) {
  return sem_wait(&lock->sem);
}

int mutex_unlock(mutex_t *lock) {
  return sem_post(&lock->sem);
}


/*------------------------------------------------------*/

int cond_init(cond_t *cond, condattr_t* attr) {
  mutex_init(&cond->lock, NULL);
  cond->first = NULL;
  return 0;
}

int cond_destroy(cond_t *cond) {
  node_t *r;
  mutex_destroy(&cond->lock);
  while (cond->first) {
    r = cond->first;
    sem_destroy(&r->sem);
    cond->first = r->next;
    free(r);
  } 
  return 0;
}

int cond_wait(cond_t *cond, 
              mutex_t *mutex_externo) {
  node_t *n = malloc(sizeof(node_t));
  sem_init(&n->sem, 0, 0);
  n->next = NULL;
  mutex_lock(&cond->lock);
  if (cond->first) {
    cond->last->next = n;
    cond->last = n;
  }
  else
    cond->first = cond->last = n;
  mutex_unlock(&cond->lock);                  
  mutex_unlock(mutex_externo);
  sem_wait(&n->sem);
  sem_destroy(&n->sem);
  free(n);
  mutex_lock(mutex_externo);  
  return 0;
}

int cond_signal(cond_t *cond){
  node_t *aux;
  mutex_lock(&cond->lock);
  if (cond->first) {
    aux = cond->first->next;
    sem_post(&cond->first->sem);
    cond->first = aux;
  }
  mutex_unlock(&cond->lock);
  return 0;  
}

int cond_broadcast(cond_t *cond){
  node_t* aux;
  mutex_lock(&cond->lock);
  while (cond->first) {
    aux = cond->first->next;
    sem_post(&cond->first->sem);
    cond->first = aux;
  }
  mutex_unlock(&cond->lock);  
  return 0;  
}