semaphore.c

Go to the documentation of this file.

#include <sys/types.h>
#include <stdint.h>
#include <errno.h>
#include <stdio.h>
#include <stddef.h>
#include <time.h>
#include <semaphore.h>
#include <assert.h>
#include <stdlib.h>
#include <pthread.h>

#include <interrupt.h>

#include <list.h>
#include <object.h>
#include <thread.h>
#include <semaphore0.h>

struct sem {
        struct list_head list; /* 세마포어 락에 걸린 쓰레드들 목록 */
        int pshared; 
        volatile int value; 
};

struct sem_list_info {
        struct list_head head;
        struct thread *tcb;
};

int sem_init(sem_t *_sem, int pshared, unsigned int value)
{
        struct sem *sem;
        assert(_sem && "Invalid argument");

        sem = malloc(sizeof(*sem));
        if (!sem) {
                return -ENOMEM;
        }

        sem->pshared = pshared;
        sem->value = value;

        INIT_LIST_HEAD(&sem->list);

        *_sem = sem;
        return 0;
}

int sem_destroy(sem_t *_sem)
{
        struct sem *sem;
        struct list_head *pos;
        struct list_head *n;
        struct sem_list_info *info;
        assert(_sem && "Invalid argument");

        sem = *_sem;
        if (!sem) {
                return -EINVAL;
        }

        list_for_each_safe(pos, n, &sem->list) {
                list_del(pos);
                info = list_entry(pos, struct sem_list_info, head);

                assert(info->tcb && "TCB is not valid");
                assert(info->tcb->sem == sem && "Invalid semaphore");
                info->tcb->sem = NULL;
                free(info);
        }

        free(sem);
        *_sem = NULL;
        return 0;
}

int sem_post(sem_t *_sem)
{
        struct sem *sem;
        unsigned long flags;
        assert(_sem && "Invalid argument");

        sem = *_sem;
        if (!sem) {
                return -EINVAL;
        }

        irq_local_save(&flags);
        if (++sem->value >= 0) {
                struct list_head *pos;
                struct sem_list_info *info;

                pos = LIST_NEXT(&sem->list);
                if (pos == &sem->list) {
                        goto out;
                }

                list_del(pos);
                info = list_entry(pos, struct sem_list_info, head);
                assert(info->tcb && "TCB is not valid");
                assert((sem == info->tcb->sem) && "Sempahore is not matched");

                info->tcb->sem = NULL;
                free(info);
        }
out:
        irq_local_restore(flags);
        return 0;
}

int sem_wait(sem_t *_sem)
{
        struct sem *sem;
        unsigned long flags;
        assert(_sem && "Invalid argument");

        sem = *_sem;
        if (!sem) {
                return -EINVAL;
        }

        irq_local_save(&flags);
        if (--sem->value < 0) {
                struct sem_list_info *info;

                info = malloc(sizeof(*info));
                if (!info) {
                        sem->value++;
                        irq_local_restore(flags);
                        return -ENOMEM;
                }

                info->tcb = pthread_self();
                assert(info->tcb && "TCB is not valid");
                assert(!info->tcb->sem && "TCB's sem is not cleared");

                info->tcb->sem = sem;
                list_add_tail(&info->head, &sem->list);
                irq_local_restore(flags);
                while (sem->value < 0) {
                }
                irq_local_save(&flags);
        }

        irq_local_restore(flags);
        return 0;
}

int sem_trywait(sem_t *_sem)
{
        struct sem *sem;
        unsigned long flags;
        assert(_sem && "Invalid argument");

        sem = *_sem;
        if (!sem) {
                return -EINVAL;
        }

        irq_local_save(&flags);
        if ((sem->value - 1) < 0) {
                irq_local_restore(flags);
                return -EBUSY;
        }
        sem->value--;
        irq_local_restore(flags);
        return 0;
}

int sem_timedwait(sem_t *_sem, const struct timespec *abs_timeout)
{
        struct sem *sem;
        assert(_sem && "Invalid argument");

        sem = *_sem;
        if (!sem) {
                return -EINVAL;
        }

        return -ENOSYS;
}

int sem_getvalue(sem_t *_sem, int *val)
{
        struct sem *sem;
        assert(val && _sem && "Invalid argument");

        sem = *_sem;
        if (!sem) {
                return -EINVAL;
        }

        *val = sem->value;
        return 0;
}

void sem_clear(struct thread *tcb)
{
        struct sem *sem;
        struct sem_list_info *info;
        struct list_head *pos;
        struct list_head *n;

        if (!tcb->sem) {
                return;
        }

        sem = tcb->sem;
        list_for_each_safe(pos, n, &sem->list) {
                info = list_entry(pos, struct sem_list_info, head);
                if (info->tcb == tcb) {
                        list_del(pos);
                        free(info);
                        break;
                }
        }
        
        return;
}

/* End of a file */