thread.c

Go to the documentation of this file.

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

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

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

#define THREAD_LIST_LINK(tcb) \
do { \
        unsigned long flag; \
        struct thread *first_child; \
 \
        irq_local_save(&flag); \
        INIT_LIST_HEAD(&(tcb)->child); \
        INIT_LIST_HEAD(&(tcb)->sibling); \
 \
        first_child = list_entry(tcb->parent->child.next, struct thread, child); \
        if (first_child) { \
                list_add_tail(&tcb->sibling, &first_child->sibling); \
        } else { \
                list_add_tail(&tcb->child, &tcb->parent->child); \
        } \
 \
        list_add_tail(&(tcb)->link, &(tcb)->root->link); \
        irq_local_restore(flag); \
} while (0)

#define THREAD_IS_ROOT(tcb) ((tcb)->parent == NULL && (tcb)->root == (tcb))

#define THREAD_LIST_INIT(tcb) \
do { \
        INIT_LIST_HEAD(&(tcb)->sibling); \
        INIT_LIST_HEAD(&(tcb)->child); \
        INIT_LIST_HEAD(&(tcb)->link); \
} while (0)

FILE *thread_get_stdin(void)
{
        struct thread *thread;

        thread = pthread_self();
        if (!thread) {
                return NULL;
        }

        if (!thread->file_ctx) {
                return NULL;
        }

        return thread->file_ctx->table + STDIN_FILENO;
}

FILE *thread_get_stderr(void)
{
        struct thread *thread;

        thread = pthread_self();
        if (!thread) {
                return NULL;
        }

        if (!thread->file_ctx) {
                return NULL;
        }

        return thread->file_ctx->table + STDERR_FILENO;
}

FILE *thread_get_stdout(void)
{
        struct thread *thread;

        thread = pthread_self();
        if (!thread) {
                return NULL;
        }

        if (!thread->file_ctx) {
                return NULL;
        }

        return thread->file_ctx->table + STDOUT_FILENO;
}

static int file_entry_create(struct object *object, void *data)
{
        struct entry *ctx;
        int ret = 0;
        struct ninfo *ninfo;
        struct file_object_info *info;

        info = data;
        ninfo = vfs_get_ninfo(NULL, NULL, info->path);
        if (!ninfo) {
                dbg_printf("Failed to find ninfo for %s\n", info->path);
                return -ENOENT;
        }

        ctx = object_get(object, struct entry, object);

        ctx->ninfo = ninfo;
        ctx->mode = info->mode;

        if (ninfo->nops.open) {
                ret = ninfo->nops.open(ninfo, &ctx->nctx);
                if (ret < 0) {
                        dbg_printf("Failed to do DEVICE open (%s)\n", info->path);
                }
        }

        return ret;
}

static int file_entry_destroy(struct object *object)
{
        struct ninfo *ninfo;
        struct entry *ctx;
        int ret;

        ctx = object_get(object, struct entry, object);

        ninfo = ctx->ninfo;
        if (ninfo && ninfo->nops.close) {
                ret = ninfo->nops.close(ninfo, &ctx->nctx);
        } else {
                ret = 0;
        }

        return ret;
}

static int file_entry_copy(struct object *_dest, struct object *_src)
{
        struct entry *dest;
        struct entry *src;

        src = object_get(_src, struct entry, object);
        dest = object_get(_dest, struct entry, object);

        dest->mode = src->mode;
        dest->ninfo = src->ninfo;

        memcpy(&dest->nctx, &src->nctx, sizeof(src->nctx));

        return 0;
}

static int file_object_create(struct object *object, void *data)
{
        struct file *file;
        struct file_object_info *info = data;
        struct object_ops entry_ops = {
                .create = file_entry_create,
                .destroy = file_entry_destroy,
                .link = NULL,
                .copy = file_entry_copy,
        };
        int ret;

        file = object_get(object, struct file, object);

        file->size = info->size;
        file->offset = 0;
        if (file->size) {
                file->buffer = malloc(file->size);
                if (!file->buffer) {
                        return -ENOMEM;
                }
        } else {
                file->buffer = NULL;
        }

        file->ctx = malloc(sizeof(*file->ctx));
        if (!file->ctx) {
                if (file->buffer) {
                        free(file->buffer);
                }
                return -ENOMEM;
        }

        ret = object_init(&file->ctx->object, &entry_ops);
        if (ret < 0) {
                dbg_printf("Failed to initialize entry object\n");
                if (file->buffer) {
                        free(file->buffer);
                }
                free(file->ctx);
                return ret;
        }

        ret = object_create(&file->ctx->object, info);
        if (ret < 0) {
                dbg_printf("Failed to create entry context (%s)\n", info->path);
                if (file->buffer) {
                        free(file->buffer);
                }
                free(file->ctx);
                return ret;
        }

        return 0;
}

static int file_object_destroy(struct object *object)
{
        struct file *file;
        int ret;

        file = object_get(object, struct file, object);

        if (file->ctx) {
                ret = object_destroy(&file->ctx->object);
                if (ret < 0) {
                        return ret;
                }

                free(file->ctx);
                file->ctx = NULL;
        }

        if (file->buffer) {
                free(file->buffer);
        }

        file->buffer = NULL;
        file->size = 0;
        file->offset = 0;

        return 0;
}

static int file_object_copy(struct object *dest, struct object *src)
{
        struct file *dest_file;
        struct file *src_file;

        dest_file = object_get(dest, struct file, object);
        src_file = object_get(src, struct file, object);

        dest_file->size = src_file->size;
        if (src_file->size) {
                dest_file->buffer = malloc(src_file->size);
                if (!dest_file->buffer) {
                        return -ENOMEM;
                }

                memcpy(dest_file->buffer, src_file->buffer, src_file->size);
        }
        dest_file->offset = src_file->offset;

        if (src_file->ctx) {
                int ret;
                dest_file->ctx = malloc(sizeof(*dest_file->ctx));
                if (!dest_file->ctx) {
                        free(dest_file->buffer);
                        return -ENOMEM;
                }

                ret = object_copy(&dest_file->ctx->object,
                                        &src_file->ctx->object);
                if (ret < 0) {
                        free(dest_file->ctx);
                        free(dest_file->buffer);
                        return ret;
                }
        } else {
                dest_file->ctx = NULL;
        }

        return 0;
}

static int file_ctx_create(struct object *object, void *data)
{
        struct thread_file_ctx *ctx;
        register int fd;
        struct object_ops ops = {
                .create = file_object_create,
                .destroy = file_object_destroy,
                .copy = file_object_copy,
                .link = NULL,
        };

        ctx = object_get(object, struct thread_file_ctx, object);

        for (fd = 0; fd < MAX_ENTRY; fd++) {
                object_init(&ctx->table[fd].object, &ops);
        }

        return 0;
}

static inline int thread_fini_file_table(struct thread *tcb)
{
        struct thread_file_ctx *fctx;
        register int i;

        fctx = tcb->file_ctx;
        if (!fctx) {
                return -EINVAL;
        }

        for (i = 0; i < MAX_ENTRY; i++) {
                (void)object_destroy(&fctx->table[i].object);
        }

        object_destroy(&fctx->object);
        free(fctx);
        tcb->file_ctx = NULL;
        return 0;
}

static int file_ctx_destroy(struct object *object)
{
        struct thread_file_ctx *ctx;
        register int fd;

        ctx = object_get(object, struct thread_file_ctx, object);
        for (fd = 0; fd < MAX_ENTRY; fd++) {
                (void)object_destroy(&ctx->table[fd].object);
        }

        return 0;
}

static int file_ctx_copy(struct object *_dest, struct object *_src)
{
        struct thread_file_ctx *src;
        struct thread_file_ctx *dest;
        register int fd;
        int ret;

        src = object_get(_src, struct thread_file_ctx, object);
        dest = object_get(_dest, struct thread_file_ctx, object);

        for (fd = 0; fd < MAX_ENTRY; fd++) {
                ret = object_copy(&dest->table[fd].object,
                                                &src->table[fd].object);
                if (ret < 0) {
                        goto errout;
                }
        }

        return 0;

errout:
        while (--fd >= 0) {
                object_destroy(&dest->table[fd].object);
        }

        return ret;
}

static inline int thread_init_file_table(struct thread *tcb)
{
        const char *dev_node;
        int ret;
        struct thread_file_ctx *fctx;
        struct file_object_info info;
        struct object_ops ops = {
                .create = file_ctx_create,
                .destroy = file_ctx_destroy,
                .copy = file_ctx_copy,
                .link = NULL,
        };

        tcb->file_ctx = malloc(sizeof(*tcb->file_ctx));
        if (!tcb->file_ctx) {
                return -ENOMEM;
        }

        ret = object_init(&tcb->file_ctx->object, &ops);
        if (ret < 0) {
                free(tcb->file_ctx);
                tcb->file_ctx = NULL;
                return ret;
        }

        ret = object_create(&tcb->file_ctx->object, NULL);
        if (ret < 0) {
                dbg_printf("Failed to create a file context\n");
                free(tcb->file_ctx);
                tcb->file_ctx = NULL;
                return ret;
        }

        fctx = tcb->file_ctx;

        dev_node = getenv("stdin");
        if (dev_node) {
                info.size = BUFSIZ;
                info.path = dev_node;
                info.mode = O_RDONLY;

                ret = object_create(&fctx->table[STDIN_FILENO].object, &info);
                if (ret < 0) {
                        dbg_printf("Failed to initiate the STDIN\n");
                }
        }

        dev_node = getenv("stdout");
        if (dev_node) {
                info.size = BUFSIZ;
                info.path = dev_node;
                info.mode = O_WRONLY;

                ret = object_create(&fctx->table[STDOUT_FILENO].object, &info);
                if (ret < 0) {
                        dbg_printf("Failed to initiate the STDOUT\n");
                }
        }

        dev_node = getenv("stderr");
        if (dev_node) {
                info.size = 0;
                info.path = dev_node;
                info.mode = O_WRONLY;

                ret = object_create(&fctx->table[STDERR_FILENO].object, &info);
                if (ret < 0) {
                        dbg_printf("Failed to initiate the STDERR\n");
                }
        }

        return 0;
}

static inline int destroy_stack(struct thread *tcb)
{
        if (tcb->attr.stack.is_allocated) {
                free(tcb->attr.stack.addr);
        }

        tcb->attr.stack.addr = NULL;
        tcb->attr.stack.size = 0;
        return 0;
}

static inline int allocate_stack(struct thread *tcb)
{
        int ret;
        char *tmp;

        ret = posix_memalign((void **)&tmp,
                        sysconf(_SC_PAGESIZE), tcb->attr.stack.size);
        if (ret < 0) {
                return ret;
        }

        tcb->attr.stack.addr = tmp;
        tcb->attr.stack.is_allocated = 1;
        return 0;
}

static inline int create_stack(struct thread *tcb, struct thread_attr *attr)
{
        unsigned int tcb_sz;
        struct local_tcb *local_tcb;
        char *tmp;

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

        if (attr) {
                memcpy(&tcb->attr, attr, sizeof(*attr));
        } else {
                tcb->attr.stack.size = PTHREAD_STACK_MIN + tcb_sz;
                tcb->attr.stack.addr = NULL;
        }

        if (!tcb->attr.stack.addr) {
                int ret;
                ret = allocate_stack(tcb);
                if (ret < 0) {
                        dbg_printf("Heap is not allocated: %d\n", ret);
                }
        }

        tmp = (char *)tcb->attr.stack.addr;
        tmp += (tcb->attr.stack.size - tcb_sz);
        local_tcb = (struct local_tcb *)tmp;
        tcb->esp = (uint32_t *)tmp;

        local_tcb->tcb_ptr = tcb;

        strncpy(local_tcb->tag, THREAD_TAG, sizeof(local_tcb->tag));
        return 0;
}

static int thread_object_create(struct object *object, void *_attr)
{
        struct thread *tcb;
        struct thread_attr *attr;
        int ret;

        attr = _attr;
        tcb = object_get(object, struct thread, object);

        ret = create_stack(tcb, attr);
        if (ret < 0) {
                return ret;
        }

        ret = thread_init_file_table(tcb);
        if (ret < 0) {
                goto error_out;
        }

        tcb->sem = NULL;

        if (!attr || !attr->is_first) {
                tcb->parent = pthread_self();
                if (!tcb->parent) {
                        ret = -EFAULT;
                        thread_fini_file_table(tcb);
                        goto error_out;
                }

                tcb->root = tcb->parent->root;

                thread_set_status(tcb, CREATED);
                THREAD_LIST_LINK(tcb);
                return 0;
        }

        tcb->parent = NULL;
        tcb->root = tcb;

        thread_set_status(tcb, RUNNING);
        THREAD_LIST_INIT(tcb);
        return 0;

error_out:
        destroy_stack(tcb);
        return ret;
}

static int thread_object_destroy(struct object *object)
{
        struct thread *tcb;
        struct list_head *end_of_sibling;
        struct thread *tmp;
        unsigned long flag;

        tcb = object_get(object, struct thread, object);

        irq_local_save(&flag);
        list_del(&tcb->link);

        tmp = list_entry(tcb->child.next, struct thread, child);
        if (tmp) {
                struct list_head *pos;
                struct thread *i;

                tmp->parent = tcb->parent;
                list_for_each(pos, &tmp->sibling) {
                        i = list_entry(pos, struct thread, sibling);
                        i->parent = tcb->parent;
                }
        }

        tmp = list_entry(tcb->parent->child.next, struct thread, child);
        if (tmp == tcb) { 
                struct thread *i;
                tmp = list_entry(tcb->child.next, struct thread, child);
                end_of_sibling = tcb->sibling.prev;
                list_link(&tmp->sibling, end_of_sibling);

                tmp = tcb->root;
                i = list_entry(tcb->sibling.next, struct thread, sibling);
                tmp->child.prev = &i->child;
                i->child.next = &tmp->child;

                tcb->parent->child.next = &i->child;
                i->child.prev = &tcb->parent->child;
        } else { 
                end_of_sibling = tmp->sibling.prev;
                tmp = list_entry(tcb->child.next, struct thread, child);
                list_link(&tmp->sibling, end_of_sibling);

                list_del(&tcb->sibling);
        }

        thread_fini_file_table(tcb);
        destroy_stack(tcb);
        irq_local_restore(flag);

        return 0;
}

static int thread_object_copy(struct object *_dest, struct object *_src)
{
        struct thread *src;

        src = object_get(_src, struct thread, object);
        if (!src->user_data) {
                return -EINVAL;
        }

        return -ENOSYS;
}

static struct object *thread_object_link(struct object *object)
{
        struct thread *tcb;

        tcb = object_get(object, struct thread, object);
        if (!tcb->user_data) {
                return NULL;
        }

        return object;
}

int thread_create(struct thread *tcb, struct thread_attr *attr)
{
        int ret;
        struct object_ops ops = {
                .create = thread_object_create,
                .destroy = thread_object_destroy,
                .copy = thread_object_copy,
                .link = thread_object_link,
        };

        ret = object_init(&tcb->object, &ops);
        if (ret < 0) {
                return ret;
        }

        ret = object_create(&tcb->object, attr);
        if (ret < 0) {
                return ret;
        }

        return 0;
}

void thread_set_status(struct thread *tcb, int status)
{
        assert(tcb && "Invalid argument");
        tcb->status = status;
}

int thread_get_status(struct thread *tcb)
{
        assert(tcb && "Invalid argument");
        return tcb->status;
}

unsigned long thread_get_stack_pointer(struct thread *tcb)
{
        unsigned long stack_pointer;

        assert(tcb && "Invalid argument");

        stack_pointer = (unsigned long)tcb->attr.stack.addr;
        stack_pointer += tcb->attr.stack.size;

        return stack_pointer;
}

void *thread_get_arch_data(struct thread *tcb)
{
        assert(tcb && "Invalid argument");
        return tcb->arch_data;
}

void *thread_get_user_data(struct thread *tcb)
{
        assert(tcb && "Invalid argument");
        return tcb->user_data;
}

/* End of a file */