main.c

Go to the documentation of this file.

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

#include <interrupt.h>
#include <isr.h>

#include <debug.h>

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

extern unsigned long end;
extern unsigned long etext;
extern unsigned long edata;


#if defined(MUTEX_TEST)
static pthread_mutex_t lock;
#define LOCK_INIT() do { pthread_mutex_init(&lock, NULL); } while (0)
#define LOCK() do { pthread_mutex_lock(&lock); } while (0)
#define UNLOCK() do { pthread_mutex_unlock(&lock); } while (0)
#elif defined(SEM_TEST)
static sem_t lock;
#define LOCK_INIT() do { sem_init(&lock, 0, 0); } while (0)
#define LOCK() do { sem_wait(&lock); } while (0)
#define UNLOCK() do { sem_post(&lock); } while (0)
#else
#define LOCK_INIT()
#define LOCK()
#define UNLOCK()
#endif

static void *t_func2(void *data)
{
        int id;
        int ret = 0;

        LOCK();
        printf("Thread[%s]: %p, arg: %p\n", __func__, pthread_self(), data);
        UNLOCK();
        for (id = 0; ; id++) {
                LOCK();
                printf("  T[%d] - ret: [%d]\r", id, ret);
                UNLOCK();
                ret = pthread_yield();
        }

        return (void *)NULL;
}

static void *t_func1(void *data)
{
        int id;

        LOCK();
        printf("Thread[%s]: %p, arg: %p\n", __func__, pthread_self(), data);
        UNLOCK();
        for (id = 0; id < 100; id++) {
                LOCK();
                printf(" A [%d]\r", id);
                UNLOCK();
                pthread_yield();
        }

        return (void *)NULL;
}

static inline void pf_test(void)
{
        char *test;

        test = (char *)0xba481030;
        *test = 'a';

        printf(">>>>>>>>> %p [%c]\n", test, *test);
}

static inline int sys_open(const char *path, ...)
{
        return -ENOSYS;
}

static inline int sys_close(int fd)
{
        return -ENOSYS;
}

static inline int sys_read(int fd, char *buffer, int count)
{
        return -ENOSYS;
}

static inline int sys_write(int fd, const char *buffer, int count)
{
        return -ENOSYS;
}

static inline int sys_lseek(int fd, off_t offset, int whence)
{
        return -ENOSYS;
}

static inline int sys_opendir(const char *path)
{
        return -ENOSYS;
}

static inline int sys_closedir(int fd)
{
        return -ENOSYS;
}

static inline int sys_readdir(int fd, void *ret)
{
        return -ENOSYS;
}

static inline int sys_yield(void)
{
        return -ENOSYS;
}

static int sw_intr_cb(int sub_irq, void *_info, void *data)
{
        static int call_count = 0;
        struct intr_info *info = _info;
        int ret;

        call_count++;

        printf("sw_intr_cb [%d] argc: %d, argv: %p\r", call_count, info->argc, info->argv);

        ret = -EINVAL;
        switch (sub_irq) {
        case SYS_NR_OPEN:
                if (info->argc != 3) {
                        break;
                }
                ret = sys_open((const char *)info->argv[0], info->argv[1], info->argv[2]);
                break;
        case SYS_NR_CLOSE:
                if (info->argc != 1) {
                        break;
                }
                ret = sys_close((int)info->argv[0]);
                break;
        case SYS_NR_READ:
                if (info->argc != 3) {
                        break;
                }
                ret = sys_read((int)info->argv[0], (char *)info->argv[1], (int)info->argv[2]);
                break;
        case SYS_NR_WRITE:
                if (info->argc != 3) {
                        break;
                }
                ret = sys_write((int)info->argv[0], (const char *)info->argv[1], (int)info->argv[2]);
                break;
        case SYS_NR_SEEK:
                if (info->argc != 3) {
                        break;
                }
                ret = sys_lseek((int)info->argv[0], (off_t)info->argv[1], (int)info->argv[2]);
                break;
        case SYS_NR_OPENDIR:
                if (info->argc != 1) {
                        break;
                }
                ret = sys_opendir((const char *)info->argv[0]);
                break;
        case SYS_NR_CLOSEDIR:
                if (info->argc != 1) {
                        break;
                }
                ret = sys_closedir((int)info->argv[0]);
                break;
        case SYS_NR_READDIR:
                if (info->argc != 2) {
                        break;
                }
                ret = sys_readdir((int)info->argv[0], (void *)info->argv[1]);
                break;
        case SYS_NR_YIELD:
                if (info->argc) {
                        break;
                }
                ret = sys_yield();
                break;
        default:
                ret = -ENOSYS;
                break;
        }

        return ret;
}

static inline void buddy_test(void)
{
        unsigned long *page[5];
        register int i;

        printf("[%s:%d]\n", __func__, __LINE__);

        for (i = 0; i < (sizeof(page) / sizeof(*page)); i++) {
                page[i] = page_frame_alloc(ZONE_NORMAL, 1);
                printf("Page[%d] : %p\n", i, page[i]);
        }

        for (i = 0; i < (sizeof(page) / sizeof(*page)); i++) {
                page_frame_free(page[i]);
        }

        for (i = 0; i < (sizeof(page) / sizeof(*page)); i++) {
                page[i] = page_frame_alloc(ZONE_NORMAL, 1);
                printf("Page[%d] : %p\n", i, page[i]);
        }

        for (i = 0; i < (sizeof(page) / sizeof(*page)); i++) {
                page_frame_free(page[i]);
        }
}

static inline void thread_test(void)
{
        pthread_t thid;

        printf("[%s:%d]\n", __func__, __LINE__);

        LOCK_INIT();
        pthread_create(&thid, NULL, t_func1, (void *)1);
        pthread_create(&thid, NULL, t_func2, thid);
}

static void *elf_func(void *data)
{
        char *tmp;
        char *argv[] = {
                "/fat/hello-world",
                NULL,
        };

        tmp = page_frame_alloc(ZONE_NORMAL, 1);
        if (tmp) {
                tmp = onetime_map(tmp);
                memset(tmp, 0, sysconf(_SC_PAGESIZE));
                tmp = onetime_unmap(tmp);
                page_frame_free(tmp);
                printf("Onetime mapper testing is done\n");
        }

        //printf("Executing %s\n", argv[0]);
        execv(argv[0], argv);

        while (1) {
        }
        return NULL;
}

static inline void elf_test(void)
{
        pthread_t thid;
        printf("Create a new thread for loading a ELF\n");
        pthread_create(&thid, NULL, elf_func, NULL);
}

static inline void file_test(void)
{
        int fd;
        char ch[BUFSIZ];
        int ret;
        register int i;
        char check;
        int validate_idx;

        printf("Open a file hello-world.txt\n");
        fd = open("/fat/hello-world.txt", O_RDONLY);
        if (fd < 0) {
                printf("Failed to open a text pattern file\n");
                return;
        }

        check = '0';
        validate_idx = 0;
        while ((ret = read(fd, ch, sizeof(ch))) > 0) {
                for (i = 0; i < ret && ch[i] == (validate_idx + check); i++);
                if (i != ret) {
                        printf("Mismatched %c[%d] / %d/%d\n",
                                                ch[i], validate_idx, i, ret);
                        break;
                }
                printf("%d Matched %d pattern [%d]\n",
                                lseek(fd, 0L, SEEK_CUR), i, validate_idx);
                validate_idx++;
        }
        printf("End of verifying read:ret = %d [%d]\n", ret, validate_idx);

        close(fd);
}

int main(int argc, char *argv[], char *envp[])
{
        register int i;
        int ret;

        for (i = 0; envp[i]; i++) {
                printf(">> ENV[%d] %s\n", i, envp[i]);
        }

        printf("[%s:%d] =====>         \n", __func__, __LINE__);
        pf_test();
        printf("[%s:%d] =====>         \n", __func__, __LINE__);

        ret = register_irq(IRQ_NR_SW, NORMAL_PRIORITY, sw_intr_cb, NULL);
        if (ret < 0) {
                printf("Failed to register irq handler for 0x%x\n", IRQ_NR_SW);
        }

        file_test();
        elf_test();
        buddy_test();
        thread_test();

        for (i = 0; ; i++) {
                LOCK();
                printf("M  [%d]\r", i);
                UNLOCK();
                ret = pthread_yield();
        }
        return 0;
}

/* End of a file */