sem.c

#include "types.h"
#include "param.h"
#include "memlayout.h"
#include "riscv.h"
#include "spinlock.h"
#include "proc.h"
#include "defs.h"

// longitud del arreglo dentro del espacio de kernel
#define NSEM 65

// tope maximo del contador de semaforo
#define SEM_VALUE_MAX 1000000

struct sem {
    int used;                 // 1 = abierto, 0 = cerrado
    int value;                // contador
    struct spinlock lock;
};

// arreglo dentro del espacio de kernel, arreglo global
struct sem sems[NSEM];

// inicializamos el arreglo de semaforos
void
seminit(void)
{
    for(int i = 0; i < NSEM; i = i+1)
    {
        initlock(&sems[i].lock, "sem");
        sems[i].used = 0;
        sems[i].value = 0;
    }
}


/*  sem_up(sem): incrementa el contador y despierta a los que esperan.
 *  Exito: retorna sem > 0
 *  Error: retorna 0
 *
 */
int
sem_up(int sem)
{
    // variable de retorno
    int result = 0;

    // fuera de rango
    if(sem <= 0 || sem >= NSEM)
    {
        result = 0;
    }
    else
    {
        // apuntamos al semaforo en cuestion
        struct sem *s = &sems[sem];
        // bloqueamos el semaforo, exclusion mutua
        acquire(&s->lock);

        // no estaba abierto o el contador se paso
        if(!s->used || s->value >= SEM_VALUE_MAX)
        {
            // liberamos el lock
            release(&s->lock);
            result = 0;
        }
        else // luz verde
        {
            // incrementamos el contador
            s->value = s->value + 1;

            // lanza el proceso que hubiera llamado a sleep() antes
            wakeup(s);

            // liberamos el lock
            release(&s->lock);
            // exito: devolvemos el id del semaforo (sem > 0)
            result = sem;
        }
    }
    return result;
}

int
sem_open(int sem, int value)
{
  return 0;
}

int
sem_close(int sem)
{
  return 0;
}

int
sem_down(int sem)
{
  return 0;
}