isr.c

Go to the documentation of this file.

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

#include <object.h>
#include <list.h>
#include <thread.h>
#include <interrupt.h>
#include <isr.h>
#include <arch.h>
#include <x86_util.h>

#include <segment.h> /* for USER, KERNEL macro definitions */
#include <paging.h> /* for cr3 structure - x86.h references this */
#include <x86.h>

#include <debug.h>

struct irq_handler {
        struct list_head head;
        int (*handler)(int sub_irq, void *info, void *data);
        int priority;
        void *data;
};

struct list {
        struct list_head head;
        int idx;
        int cnt;
        int max_priority;
        struct list_head list;
};

static LIST_HEAD(s_list);

int register_irq(int idx, int priority, int (*handler)(int, void *, void *), void *data)
{
        struct list_head *pos;
        struct list *entry;
        struct irq_handler *item;
        struct irq_handler *tmp;
        unsigned long flags;

        irq_local_save(&flags);
        item = malloc(sizeof(*item));
        if (!item) {
                irq_local_restore(flags);
                return -ENOMEM;
        }   

        entry = NULL;
        list_for_each(pos, &s_list) {
                entry = list_entry(pos, struct list, head);
                if (entry->idx == idx) {
                        break;
                }
                entry = NULL;
        }

        if (!entry) {
                entry = malloc(sizeof(*entry));
                if (!entry) {
                        free(item);
                        irq_local_restore(flags);
                        return -ENOMEM;
                }

                entry->idx = idx;
                entry->cnt = 0;
                entry->max_priority = 0;
                INIT_LIST_HEAD(&entry->list);

                list_add_tail(&entry->head, &s_list);
        }

        entry->cnt++;
        if (priority > entry->max_priority) {
                entry->max_priority = priority;
        }

        list_for_each(pos, &entry->list) {
                tmp = list_entry(pos, struct irq_handler, head);

                if (tmp->priority >= priority) {
                        break;
                }
        }

        item->handler = handler;
        item->priority = priority;
        item->data = data;

        list_add_tail(&item->head, pos);
        irq_local_restore(flags);
        return 0;
}

int unregister_irq(int idx, int (*handler)(int, void *, void *), void *data)
{
        struct list_head *n;
        struct list_head *pos;
        struct list *entry;
        struct irq_handler *item;
        unsigned long flags;

        irq_local_save(&flags);
        entry = NULL;
        list_for_each_safe(pos, n, &s_list) {
                entry = list_entry(pos, struct list, head);
                if (entry->idx == idx) {
                        break;
                }
                entry = NULL;
        }

        if (!entry) {
                irq_local_restore(flags);
                return -ENOENT;
        }

        list_for_each_safe(pos, n, &entry->list) {
                item = list_entry(pos, struct irq_handler, head);
                if (item->handler == handler && item->data == data) {
                        entry->cnt--;

                        list_del(&item->head);
                        free(item);

                        if (!entry->cnt) {
                                list_del(&entry->head);
                                free(entry);
                        }
                        irq_local_restore(flags);
                        return 0;
                }
        }

        irq_local_restore(flags);
        return -ENOENT;
}

static inline struct thread *select_next_thread(struct thread *tcb)
{
        struct x86_arch_data *arch_data;
        struct list_head *n;
        struct thread *it;
        int status;

        it = tcb;
        n = LIST_NEXT(&it->link);
        while (1) {
                it = list_entry(n, struct thread, link);
                if (tcb == it) { /* 쓰레드가 하나 뿐 인 경우 */
                        break;
                }

                n = LIST_NEXT(n); /* 다음 쓰레드를 찾아 놓고 */

                if (it->sem) { /* 세마포어가 있는 쓰레드는 스킵! */
                        continue;
                }

                status = thread_get_status(it);
                if (status == RUNNING) { /* 실행 중인 쓰레드를 선택 */
                        break;
                }

                if (status == DELETED) {
                        pthread_cancel(it);
                } else if (status == CREATED) {
                } else if (status == READY) {
                        thread_set_status(it, RUNNING);
                }
        }

        arch_data = thread_get_arch_data(it);
        assert(arch_data && "Arch data is not valid");

        if (x86_util_get_ring(it) == USER) {
                unsigned long sp;
                struct x86_user_data *user_data;
                unsigned char *io_bitmap;

                sp = thread_get_stack_pointer(it);
                user_data = thread_get_user_data(it);
                assert(user_data && "User data is not valid");

                tss_update_kernel_stack(sp);
                io_bitmap = tss_io_bitmap_get();
                assert(io_bitmap && "I/O Bitmap is not valid");

                memcpy(io_bitmap, user_data->io_bitmap,
                                        sizeof(user_data->io_bitmap));
        }
        load_cr3(arch_data->pma_pgd);

        return it;
}

static inline void create_info(struct pt_regs *reg, struct intr_info *info)
{
        if (reg->irq != IRQ_NR_SW) {
                info->argc = 0;
                info->argv = NULL;
                info->irq = -1;
                info->ret = -ENOSYS;
                return;
        }

        info->irq = reg->pushad.eax;
        info->argc = reg->pushad.ecx;
        if (info->argc) {
                int size;

                size = sizeof(*info->argv) * info->argc;

                info->argv = malloc(size);
                assert(info->argv);

                memcpy(info->argv, (void *)reg->pushad.esp, size);
        } else {
                info->argv = NULL;
        }

        return;
}

static inline void destroy_info(struct pt_regs *reg, struct intr_info *info)
{
        if (reg->irq != IRQ_NR_SW) {
                return;
        }

        reg->pushad.eax = info->ret;

        if (info->argv) {
                free(info->argv);
        }
}

asmlinkage struct pt_regs *do_irq(struct pt_regs *reg)
{
        struct list_head *pos;
        struct list *entry;
        struct thread *tcb;

        tcb = (struct thread *)pthread_self();
        if (!tcb) {
                dbg_printf("[%s:%d]\n", __func__, __LINE__);
                halt();
        }

        tcb->esp = (uint32_t *)reg;

        list_for_each(pos, &s_list) {
                entry = list_entry(pos, struct list, head);
                if (entry->idx == reg->irq) {
                        break;
                }

                entry = NULL;
        }

        if (entry) {
                struct intr_info info;
                struct irq_handler *item;

                create_info(reg, &info);

                list_for_each(pos, &entry->list) {
                        item = list_entry(pos, struct irq_handler, head);
                        if (!item->handler) {
                                continue;
                        }

                        info.ret = item->handler(info.irq, &info, item->data);
                }

                destroy_info(reg, &info);
        } else {
                dbg_printf("[%s:%d] IRQ 0x%x has no handler\r",
                        __func__, __LINE__, reg->irq);
        }

        tcb = select_next_thread(tcb);
        if (!tcb) {
                dbg_printf("[%s:%d]\n", __func__, __LINE__);
                halt();
        }

        reg = (struct pt_regs *)tcb->esp;
        return reg;
}

/* End of a file */