crt0.c

Go to the documentation of this file.

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

#include <object.h>
#include <list.h>
#include <thread.h>
#include <crt0.h>
#include <malloc0.h>
#include <pthread0.h>

#include <arch.h>
#include <vfs.h>

#include <cpu_node.h>
#include <interrupt.h>
#include <zone.h>
#include <page_frame.h>
#include <paging.h>
#include <segment.h> /* for the definition of IO_BITMAP_SIZE */
#include <x86.h>

#include <debug.h>
#include <initm.h>

#include <onetime_map.h>
#include <fat.h>

typedef void (*exec_entry)(char *args, char *envs, unsigned long kpma);

struct arg_t {
        int argc;
        char *argv[MAX_IDX];
};

extern unsigned long end;


#if !defined(NDEBUG)
static inline void tree_vfs(void)
{
        struct stack *item;
        struct ninfo *ninfo;
        struct ninfo *tmp;
        int depth;
        register int i;
        LIST_HEAD(stack);
        struct stack {
                struct list_head head;
                struct ninfo *node;
                int depth;
        };

        depth = 0;
        ninfo = vfs_get_ninfo(NULL, NULL, "/");
        printf("Root ninfo: %p\n", ninfo);
        while (ninfo) {
                for (i = 0; i < depth; i ++) {
                        printf(" ");
                }
                printf(ninfo->type == NINFO_TYPE_FOLDER ?
                                "[%s]\n" : "%s\n",
                                ninfo->name ? ninfo->name : "(root)");

                tmp = vfs_get_ninfo_child(ninfo);
                if (tmp) {
                        item = malloc(sizeof(*item));
                        if (!item) {
                                return;
                        }

                        item->node = ninfo;
                        item->depth = depth;
                        list_add_tail(&item->head, &stack);

                        ninfo = tmp;
                        depth += 4;
                        continue;
                }

                ninfo = vfs_get_ninfo_next_sibling(ninfo);
                if (ninfo) {
                        continue;
                }

                while (!ninfo) {
                        if (stack.prev == &stack) {
                                ninfo = NULL; 
                                break;
                        }

                        item = list_entry(stack.prev, struct stack, head);
                        list_del(&item->head);
                        ninfo = item->node;
                        depth = item->depth;
                        free(item);

                        ninfo = vfs_get_ninfo_next_sibling(ninfo);
                }
        }
}
#else
#define tree_vfs()
#endif

static inline int vfs_build_dev(void)
{
        struct ninfo *root;
        struct ninfo *dev;

        root = vfs_get_ninfo(NULL, NULL, "/");
        if (!root) {
                return -EFAULT;
        }

        dev = vfs_new_ninfo(root->si, root, "dev", NULL);
        if (!dev) {
                return -EFAULT;
        }

        dev->type = NINFO_TYPE_FOLDER;

        return 0;
}

static inline
int fill_env(struct env_t *envt, int idx, char *env, int *aidx)
{
        switch (idx) {
        case STDIN_IDX:
                envt->dev_stdin = env;
                break;
        case STDOUT_IDX:
                envt->dev_stdout = env;
                break;
        case STDERR_IDX:
                envt->dev_stderr = env;
                break;
        case MEMBASE_IDX: /* membase */
                envt->membase[*aidx] = atoi(env);
                break;
        case MEMSIZE_IDX: /* memsize */
                envt->memsize[*aidx] = atoi(env);
                (*aidx)++;
                break;
        case KVMA_IDX:
                envt->kvma = atoi(env);
                break;
        case MEMCNT_IDX: /* memcnt */
                envt->memcnt = atoi(env);
                if (envt->memcnt > MAX_MRD) {
                        dbg_printf("Too many MRD found %d\n", envt->memcnt);
                        while (1) {
                        }
                }
                break;
        default:
                return -ENOENT;
        }

        return 0;
}

static inline int fill_map(struct memmap *map, int idx, char *env)
{

        switch (idx) {
        case HEAP_SZ_IDX: /* heap_sz */
                map->heap_size = atoi(env);
                break;
        case INITM_IDX: /* initm */
                map->initm = (char *)atoi(env);
                break;
        case KERNEL_SZ_IDX:
                map->kernel_size = atoi(env);
                break;
        case ENV_SZ_IDX:
                map->env_size = atoi(env);
                break;
        case TCB_SZ_IDX:
                map->tcb_size = atoi(env);
                break;
        case INITM_SZ_IDX:
                map->initm_size = atoi(env);
                break;
        case TCB_IDX:
                map->tcb = (char *)atoi(env);
                break;
        case STACK_SZ_IDX:
                map->stack_size = atoi(env);
                break;
        case KPMA_IDX:
                map->kernel = (char *)atoi(env);
                break;
        default:
                return -ENOENT;
        }

        return 0;
}

static inline
void parse_env(char *env, struct env_t *envt, struct memmap *map)
{
        int idx;
        int token_idx;
        int i; 
        int array_idx;
        char label[][10] = {
                { "stdin" },
                { "stdout" },
                { "stderr" }, 
                { "membase" },
                { "memsize" },
                { "memcnt" },

                { "kvma" }, 
                { "heap_sz" },
                { "initm" }, 
                { "kernel_sz" },
                { "env_sz" },
                { "tcb_sz" },
                { "initm_sz" },
                { "tcb" },
                { "stack_sz" },
                { "kpma" }, 
                { '\0', },
        };

        map->env = env;

        idx = 0;
        i = 0;
        token_idx = 0;
        array_idx = 0;
        while (*env && idx < MAX_IDX) {
                if (label[token_idx][0]) {
                        if (label[token_idx][i] != *env) {
                                /* Check the next label */
                                env -= i;
                                i = 0;
                                token_idx++;
                                continue;
                        }

                        i++;
                        env++;

                        if (label[token_idx][i] != '\0' || *env != '=') {
                                continue;
                        }

                        /* Skip '=' */
                        i++;
                        env++;

                        if (fill_env(envt, token_idx, env, &array_idx) == 0) {
                                continue;
                        }

                        if (fill_map(map, token_idx, env) == 0) {
                                continue;
                        }
                }

                envt->envp[idx++] = env - i;
                i = 0;
                token_idx = 0;

                while (*env++) {
                }
        }

        envt->envp[idx] = NULL;
        return;
}

static inline void parse_arg(char *arg, struct arg_t *argt)
{
        argt->argc = 0;
        argt->argv[argt->argc] = arg;
        while (*arg++) {
                if (*arg != '\0') {
                        continue;
                }

                argt->argc++;
                if (argt->argc == MAX_IDX) {
                        break;
                }

                arg++;
                argt->argv[argt->argc] = arg;
        }

        /* 개수를 의미한다 */
        argt->argc++;
}

static inline void setup_default_thread(struct memmap *map)
{
        pthread_attr_t thattr;
        int ret;

        ret = pthread_attr_init(&thattr);
        if (ret < 0) {
                dbg_printf("Failed to initialize the attribute\n");
                return;
        }

        ret = pthread_attr_setstack(&thattr,
                (void*)(0xFFFFFFFF - (map->tcb_size + map->stack_size) + 1 - (0x01 << 20)),
                map->stack_size + map->tcb_size); 
        if (ret < 0) {
                dbg_printf("Failed to set stack info\n");
                pthread_attr_destroy(&thattr);
                return;
        }

        ret = pthread_init(&thattr);
        if (ret < 0) {
                dbg_printf("Failed to initialize a thread\n");
                /* Keep going, to finish this */
        }

        ret = pthread_attr_destroy(&thattr);
        if (ret < 0) {
                dbg_printf("Failed to destroy the attribute\n");
        }
}

static inline void test_thread(void)
{
        pthread_t thid;

        thid = pthread_self();
        if (thid) {
                printf("THID: %p\n", thid);
        } else {
                printf("Failed to find a THID\n");
        }
        printf("test_thread\n");
}

static inline void dump_map(struct memmap *map)
{
        dbg_printf("Dump memmap begin\n");
        dbg_printf("TCB %p - %d\n", map->tcb, map->tcb_size);
        dbg_printf("ENV %p - %d\n", map->env, map->env_size);
        dbg_printf("Kernel %p - %d\n", map->kernel, map->kernel_size);
        dbg_printf("initm %p - %d\n", map->initm, map->initm_size);
        dbg_printf("Heap: %d\n", map->heap_size);
        dbg_printf("Stack: %d\n", map->stack_size);
        dbg_printf("Dump memmap end\n");
}

static inline void transfer_to_vma(struct memmap *map, void *vma_kernel)
{
        char *vma_initm;

        vma_initm = (char *)vma_kernel + map->env_size + map->kernel_size;

        initm_set_pma((void *)map->initm);
        initm_set_vma(vma_initm);
        map->initm = initm_vma();
        map->tcb = (char *)(0xFFFFFFFF - map->tcb_size - (0x01 << 20) + 1);

        initm_update_for_vma();
}

static inline void frame_init(void)
{
        struct thread *tcb;
        struct pgde *pgd;
        struct pgte *pgt;
        struct x86_arch_data *arch_data;
        register int pgt_idx;
        register int page_idx;
        void *page;
        const unsigned long pagesize = sysconf(_SC_PAGESIZE);

        tcb = pthread_self();
        assert(tcb && "thread is not valid");

        arch_data = tcb->arch_data;
        assert(arch_data && "arch_data is not valid");

        pgd = onetime_map(arch_data->pma_pgd);
        assert(pgd && "Failed to do onetime mapping");

        page_frame_manage(ZONE_SYSTEM, arch_data->pma_pgd, 1);

        for (pgt_idx = 0; pgt_idx < NR_TABLES; pgt_idx++) {
                if (!pgd[pgt_idx].p) {
                        continue;
                }

                pgt = (struct pgte *)(pgd[pgt_idx].pt_base * pagesize);
                assert(pgt && "page table is not valid");
                page_frame_manage(ZONE_SYSTEM, pgt, 1);

                pgt = onetime_map(pgt);
                assert(pgt && "onetime map failed");

                for (page_idx = 0; page_idx < NR_PAGES; page_idx++) {
                        if (!pgt[page_idx].p) {
                                continue;
                        }

                        page = (void *)(pgt[page_idx].page_base * pagesize);
                        page_frame_manage(ZONE_SYSTEM, page, 1);
                }

                pgt = onetime_unmap(pgt);
                assert(pgt && "onetime unmap");
        }
}

static inline void vfs_attach_root(void)
{
        struct ninfo *root;
        struct ninfo *fat_root;

        root = vfs_get_ninfo(NULL, NULL, "/");
        if (!root) {
                dbg_printf("Failed to get root node\n");
                return;
        }

        fat_root = fat_load(root, "/dev/fda");
        if (!fat_root) {
                dbg_printf("Failed to get FAT sinfo\n");
        }
}

static void _start_on_vma(char *args, char *envs, unsigned long kpma)
{
        struct env_t envt;
        struct arg_t argt;
        struct memmap map;
        int ret;

        if (!vm_is_enabled()) {
                panic("Paging is not enabled");
                return;
        }

        parse_arg(args, &argt);
        parse_env(envs, &envt, &map);

        environ = (char **)envt.envp;

        transfer_to_vma(&map, (void *)envs);
        vm_init_done(&map, kpma);

        malloc_init((uint32_t)map.env + map.env_size +
                        map.kernel_size + map.initm_size, map.heap_size);

        vm_frame_init(envt.memcnt, envt.membase, envt.memsize);
        arch_init();
        vfs_init();

        if (vfs_build_dev() < 0) {
                dbg_printf("Failed to build VFS DEV tree");
                while (1) {
                }
        }

        drivers_init();

        setup_default_thread(&map);

        onetime_map_init(
                (void *)(0xFFFFFFFF - (0x01 << 20) + 1),
                (void *)0xFFFFFFFF);

        frame_init();

        dbg_printf("INITM_FREE %d\n", initm_free_size((void *)map.initm));
        dbg_printf("argc: %d, argv: %p, envp: %p\n", argt.argc, argt.argv, envt.envp);

        enable_interrupt();

        vfs_attach_root();

        test_thread();
        tree_vfs();

        ret = main(argt.argc, argt.argv, envt.envp);
        panic("End of a function (ret:%d)", ret);
        return;
}

void _start(char *args, char *env)
{
        /* register volatile uint32_t *esp asm ("esp"); */
        uint32_t *esp;
        uint32_t vma_args;
        uint32_t vma_start;
        struct env_t envt;
        struct memmap map;

        if (vm_is_enabled()) {
                dbg_printf("Paging is already enabled\n");
                while(1);
        }

        parse_env(env, &envt, &map);

        vma_args = envt.kvma + ((uint32_t)args - (uint32_t)map.env);
        vma_start = envt.kvma + ((uint32_t)_start_on_vma - (uint32_t)map.env);

        if (initm_init(map.initm, map.initm_size) < 0) {
                dbg_printf("Failed to init initm");
                while (1) {
                }
        }

        if (vm_init(&map, envt.kvma) < 0) {
                dbg_printf("Failed to init vm");
                while (1) {
                }
        }

        esp = (uint32_t *)(0xFFFFFFFF - map.tcb_size + 1 - (0x01 << 20));
        esp -= 3;
        esp[0] = vma_args;
        esp[1] = envt.kvma; 
        esp[2] = (uint32_t)map.env; 
        asm volatile (
                "movl %0, %%esp;"
                "call *%1"
                :
                : "m"(esp), "m"(vma_start)
                : "esp"
        );

        /* Could not be reach to here */
        dbg_printf("Failed to transfer to VMA\n");
        while (1) {
        }
}

/* End of a file */