pthread_fork.c

Go to the documentation of this file.

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

#include <object.h>
#include <crt0.h>
#include <isr.h>
#include <list.h>
#include <thread.h>
#include <vfs.h>
#include <interrupt.h>
#include <x86_util.h>
#include <semaphore0.h>

#include <zone.h>
#include <page_frame.h>
#include <onetime_map.h>

#include <elf.h>

#include <segment.h> /* DESC_KERNEL_DS, DESC_KERNEL_CS */
#include <arch.h>

#include <debug.h>
#include <common.h>

#include <paging.h> /* struct cr3, referenced by x86.h */
#include <x86.h> /* struct x86_arch_data */

/* A whole new world */

static int __attribute__((noreturn)) cleanup(struct thread *tcb, void *arg)
{
        if (!tcb) {
                panic("Failed to get TCB");
        }

        dbg_printf("\nTHREAD DESTROYING %p (arg: %p)\n", tcb, arg);
        thread_set_status(tcb, DELETED);
        while (1) {
        }
}

static inline void push_user_stackframe(struct thread *tcb)
{
        struct pt_regs *isr_frame;
        struct pt_regs_user *user_frame;

        user_frame = (struct pt_regs_user *)tcb->esp;
        user_frame--;

        user_frame->esp = atoi(getenv("kvma"));
        user_frame->ss = (DESC_USER_SS << 3) | TI(GDT) | USER;

        isr_frame = (struct pt_regs *)user_frame;
        isr_frame--;
        memset(&isr_frame->pushad, 0, sizeof(isr_frame->pushad));
        isr_frame->pushad.esp = 0;
        isr_frame->pushad.ebp = 0;
        isr_frame->reserved0 = 0;
        isr_frame->reserved1 = 0;
        isr_frame->reserved2 = 0;
        isr_frame->reserved3 = 0;
        isr_frame->ds = (DESC_USER_DS << 3) | TI(GDT) | USER;
        isr_frame->es = isr_frame->ds;
        isr_frame->fs = isr_frame->ds;
        isr_frame->gs = isr_frame->ds;
        isr_frame->irq = IRQ_NR_TIMER;
        isr_frame->cs = (DESC_USER_CS << 3) | TI(GDT) | USER;
        isr_frame->eflags = 0x0202;
        isr_frame->eip = 0;

        isr_frame->ebp = 0;

        tcb->esp = (uint32_t *)isr_frame;
        return;
}

static inline void push_kernel_stackframe(struct thread *tcb,
                unsigned long eip, unsigned long arg)
{
        struct pt_regs *isr_frame;
        struct pt_regs_kernel *thread_frame;
        unsigned long *exit_stack;

        exit_stack = (unsigned long *)tcb->esp;

        exit_stack--;
        *exit_stack = arg;

        exit_stack--;
        *exit_stack = (unsigned long)tcb;

        thread_frame = (struct pt_regs_kernel *)exit_stack;
        thread_frame--;
        thread_frame->ret_addr = (unsigned long)cleanup;
        thread_frame->arg = (unsigned long)arg;

        isr_frame = (struct pt_regs *)thread_frame;
        isr_frame--;
        memset(&isr_frame->pushad, 0, sizeof(isr_frame->pushad));
        isr_frame->pushad.esp = 0;
        isr_frame->pushad.ebp = 0;
        isr_frame->reserved0 = 0;
        isr_frame->reserved1 = 0;
        isr_frame->reserved2 = 0;
        isr_frame->reserved3 = 0;
        isr_frame->ds = (DESC_KERNEL_DS << 3) | TI(GDT) | KERNEL;
        isr_frame->es = isr_frame->ds;
        isr_frame->fs = isr_frame->ds;
        isr_frame->gs = isr_frame->ds;
        isr_frame->irq = IRQ_NR_TIMER;
        isr_frame->cs = (DESC_KERNEL_CS << 3) | TI(GDT) | KERNEL;
        isr_frame->eflags = 0x0202;
        isr_frame->eip = eip;
        isr_frame->ebp = (unsigned long)&thread_frame->arg;

        tcb->esp = (uint32_t *)isr_frame;

        return;
}

int pthread_init(const pthread_attr_t *_attr)
{
        struct thread *tcb;
        struct thread_attr *attr;
        struct x86_arch_data *arch_data;
        int ret;

        if (!_attr) {
                dbg_printf("Invalid argument\n");
                return -EINVAL;
        }

        arch_data = malloc(sizeof(*arch_data));
        if (!arch_data) {
                dbg_printf("Failed to allocate heap for arch_data\n");
                return -ENOMEM;
        }

        arch_data->pma_pgd = read_cr3();
        arch_data->rpgd = vm_rpgd();

        attr = (struct thread_attr *)*_attr;
        attr->is_first = 1;

        tcb = malloc(sizeof(*tcb));
        if (!tcb) {
                free(arch_data);
                return -ENOMEM;
        }

        ret = thread_create(tcb, attr);
        if (ret < 0) {
                dbg_printf("Failed to create a new thread\n");
                free(arch_data);
                free(tcb);
                return ret;
        }

        tcb->arch_data = arch_data;
        tcb->user_data = NULL;
        return 0;
}

pid_t fork(void)
{
        return -ENOSYS;
}

static inline int update_thread_user_data(struct thread *tcb)
{
        struct x86_user_data *new_user_data;

        new_user_data = calloc(1, sizeof(*new_user_data));
        if (!new_user_data) {
                return -ENOMEM;
        }

        tcb->user_data = new_user_data;
        return 0;
}

static inline int update_thread_for_user(struct thread *tcb)
{
        struct x86_arch_data *arch_data;
        struct pgde *pgd;
        struct pgde *src_pgd;
        void *rpgd;
        void *pma_pgd;
        unsigned long flags;
        int ret;

        assert(!tcb->user_data && "user data already initialized");
        assert(tcb->arch_data && "arch data is not valid");

        arch_data = tcb->arch_data;

        pma_pgd = page_frame_alloc(ZONE_NORMAL, 1);
        if (!pma_pgd) {
                return -ENOMEM;
        }

        pgd = onetime_map(pma_pgd);
        if (!pgd) {
                page_frame_free(pma_pgd);
                return -ENOMEM;
        }

        src_pgd = onetime_map(arch_data->pma_pgd);
        if (!src_pgd) {
                onetime_unmap(pgd);
                page_frame_free(pma_pgd);
                return -ENOMEM;
        }

        memcpy(pgd, src_pgd, sysconf(_SC_PAGESIZE));

        onetime_unmap(pgd);
        onetime_unmap(src_pgd);

        rpgd = malloc(sysconf(_SC_PAGESIZE));
        if (!rpgd) {
                page_frame_free(pma_pgd);
                return -ENOMEM;
        }

        memcpy(rpgd, arch_data->rpgd, sysconf(_SC_PAGESIZE));

        irq_local_save(&flags);
        ret = update_thread_user_data(tcb);
        if (ret < 0) {
                irq_local_restore(flags);
                free(rpgd);
                page_frame_free(pma_pgd);
                return ret;
        }

        arch_data->pma_pgd = pma_pgd;
        arch_data->rpgd = rpgd;
        irq_local_restore(flags);
        return 0;
}

int execl(const char *path, const char *arg, ...)
{
        va_list ap;
        struct thread *tcb;
        int ret;

        tcb = (struct thread *)pthread_self();
        /* \note 커널 쓰레드는 사용자 쓰레드로 변경 될 수 없다. */
        assert(!tcb->attr.is_first && "Main thread is not able to be user level thread");

        ret = update_thread_for_user(tcb);
        if (ret < 0) {
                return ret;
        }

        va_start(ap, arg);
        va_end(ap);

        return -ENOSYS;
}

int execle(const char *path, const char *arg, ...)
{
        va_list ap;
        struct thread *tcb;
        int ret;

        tcb = (struct thread *)pthread_self();
        /* \note 커널 쓰레드는 사용자 쓰레드로 변경 될 수 없다. */
        assert(!tcb->attr.is_first && "Main thread is not able to be user level thread");

        ret = update_thread_for_user(tcb);
        if (ret < 0) {
                return ret;
        }

        va_start(ap, arg);
        va_end(ap);

        return -ENOSYS;
}

int execlp(const char *file, const char *arg, ...)
{
        va_list ap;
        struct thread *tcb;
        int ret;

        tcb = (struct thread *)pthread_self();
        /* \note 커널 쓰레드는 사용자 쓰레드로 변경 될 수 없다. */
        assert(!tcb->attr.is_first && "Main thread is not able to be user level thread");

        ret = update_thread_for_user(tcb);
        if (ret < 0) {
                return ret;
        }

        va_start(ap, arg);
        va_end(ap);

        return -ENOSYS;
}

int execv(const char *path, char *const argv[])
{
        struct thread *tcb;
        int ret;

        tcb = (struct thread *)pthread_self();
        assert(!tcb->attr.is_first
                && "Main thread is not able to be a user level thread");

        ret = update_thread_for_user(tcb);
        if (ret < 0) {
                return ret;
        }

        load_elf(tcb, argv[0]);
        return -ENOSYS;
}

int execvpe(const char *file, const char *const argv[], char *const envp[])
{
        struct thread *tcb;
        int ret;

        tcb = (struct thread *)pthread_self();
        /* \note 커널 쓰레드는 사용자 쓰레드로 변경 될 수 없다. */
        assert(!tcb->attr.is_first && "Main thread is not able to be user level thread");

        ret = update_thread_for_user(tcb);
        if (ret < 0) {
                return ret;
        }

        return -ENOSYS;
}

int execvp(const char *file, char *const argv[])
{
        struct thread *tcb;
        int ret;

        tcb = (struct thread *)pthread_self();

        /* \note 커널 쓰레드는 사용자 쓰레드로 변경 될 수 없다. */
        assert(!tcb->attr.is_first && "Main thread is not able to be user level thread");

        ret = update_thread_for_user(tcb);
        if (ret < 0) {
                return ret;
        }

        return -ENOSYS;
}

int pthread_create(pthread_t *handle, const pthread_attr_t *_attr,
                                        void *(*func)(void *), void *arg)
{
        struct x86_arch_data *arch_data;
        struct thread_attr *attr;
        struct thread *tcb;
        int ret;

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

        attr = (struct thread_attr *)(_attr ? *_attr : NULL);

        tcb = malloc(sizeof(*tcb));
        if (!tcb) {
                free(arch_data);
                return -ENOMEM;
        }

        ret = thread_create(tcb, attr);
        if (ret < 0) {
                free(arch_data);
                free(tcb);
                return ret;
        }

        memcpy(arch_data, tcb->root->arch_data, sizeof(*arch_data));
        tcb->arch_data = arch_data;
        tcb->user_data = NULL;

        push_kernel_stackframe(tcb, (uint32_t)func, (uint32_t)arg);

        thread_set_status(tcb, READY);
        *handle = (pthread_t)tcb;
        return 0;
}

int pthread_attr_init(pthread_attr_t *_attr)
{
        struct thread_attr *attr;
        uint32_t tcb_sz;
        struct thread_attr init_attr = {
                .stack = {
                        .addr = NULL,
                        .size = PTHREAD_STACK_MIN,
                        .is_allocated = 0,
                },

                .is_first = 0,
        };

        tcb_sz = common_get_tcb_sz();
        if (!tcb_sz) {
                return -EFAULT;
        }

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

        memcpy(attr, &init_attr, sizeof(init_attr));

        /* Reserve more memory for Local TCB */
        attr->stack.size += tcb_sz;

        *_attr = (pthread_attr_t)attr;
        return 0;
}

int pthread_attr_destroy(pthread_attr_t *_attr)
{
        struct thread_attr *attr;

        attr = (struct thread_attr *)*_attr;
        free(attr);

        *_attr = (pthread_attr_t)NULL;
        return 0;
}

void __attribute__((noreturn)) pthread_exit(void *retval)
{
        thread_set_status(pthread_self(), DELETED);
        while (1) {
        }
}

int pthread_join(pthread_t handle, void **retval)
{
        struct thread *tcb;
        tcb = (struct thread *)handle;

        printf("Join: %p\n", tcb);

        return -1;
}

int pthread_detach(pthread_t handle)
{
        struct thread *tcb;
        tcb = (struct thread *)handle;

        printf("Detach: %p\n", tcb);

        return -1;
}

int pthread_equal(pthread_t t1, pthread_t t2)
{
        struct thread *th1;
        struct thread *th2;

        th1 = (struct thread *)t1;
        th2 = (struct thread *)t2;

        return th1 == th2;
}

int pthread_cancel(pthread_t thid)
{
        struct thread *tcb;
        struct x86_arch_data *arch_data;
        int ret;
        int ring;
        unsigned long flags;

        irq_local_save(&flags);

        if (pthread_equal(pthread_self(), thid)) {
                irq_local_restore(flags);
                return -EINVAL;
        }

        tcb = (struct thread *)thid;
        ring = x86_util_get_ring(tcb);

        dbg_printf("Let's canceling the thread %p (ring: %d)\n", tcb, ring);

        ret = object_destroy(&tcb->object);

        if (ret < 0) {
                irq_local_restore(flags);
                dbg_printf("Failed to destroy an object\n");
                return ret;
        }

        arch_data = tcb->arch_data;
        if (ring == USER) {
                if (tcb->user_data) {
                        /* Release this */
                }
        } else {
                arch_data->pma_pgd = NULL;
                arch_data->rpgd = NULL;
        }
        free(arch_data);
        sem_clear(tcb);
        free(tcb);

        irq_local_restore(flags);
        return 0;
}

int pthread_attr_setstack(pthread_attr_t *_attr, void *addr, size_t size)
{
        struct thread_attr *attr;
        uint32_t tcb_sz;

        tcb_sz = common_get_tcb_sz();
        if (!tcb_sz) {
                return -EFAULT;
        }

        attr = (struct thread_attr *)*_attr;
        attr->stack.addr = addr;
        attr->stack.size = size;

        return 0;
}

int pthread_attr_getstack(pthread_attr_t *_attr, void **addr, size_t *size)
{
        struct thread_attr *attr;

        attr = (struct thread_attr *)*_attr;
        *addr = (void *)attr->stack.addr;
        *size = attr->stack.size;
        return 0;
}

pthread_t pthread_self(void)
{
        register unsigned long esp asm("esp");
        struct local_tcb *local;
        struct thread *tcb;
        uint32_t unit;

        unit = sysconf(_SC_PAGESIZE);
        unit = esp & ~(unit - 1);
        local = (struct local_tcb *)unit;

        while (strncmp(local->tag, THREAD_TAG, sizeof(local->tag))) {
                local++;

                /* Couldn't find the correct instance */
                if ((unsigned long)local < unit) {
                        return NULL;
                }
        }

        tcb = local->tcb_ptr;
        return (pthread_t)tcb;
}

int pthread_attr_setstacksize(pthread_attr_t *_attr, size_t stacksize)
{
        struct thread_attr *attr;

        attr = (struct thread_attr *)*_attr;
        attr->stack.size = stacksize;
        return 0;
}

int pthread_attr_getstacksize(pthread_attr_t *_attr, size_t *stacksize)
{
        struct thread_attr *attr;

        attr = (struct thread_attr *)*_attr;
        *stacksize = attr->stack.size;
        return 0;
}

int pthread_attr_setstackaddr(pthread_attr_t *_attr, void *stackaddr)
{
        struct thread_attr *attr;

        attr = (struct thread_attr *)*_attr;
        attr->stack.addr = stackaddr;
        return 0;
}

int pthread_attr_getstackaddr(pthread_attr_t *_attr, void **stackaddr)
{
        struct thread_attr *attr;

        attr = (struct thread_attr *)*_attr;
        *stackaddr = attr->stack.addr;
        return 0;
}

int pthread_yield(void)
{
        return syscall(SYS_NR_YIELD);
}

/* End of a file */