syscall.h

Go to the documentation of this file.

/*
 * Copyright (c) 2014, Michael Müller
 * Copyright (c) 2014, Sebastian Lackner
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice, this
 *    list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */

#ifndef _H_SYSCALL_
#define _H_SYSCALL_

#include <stdint.h>
#include <stdbool.h>

enum
{

    SYSCALL_YIELD,

    SYSCALL_EXIT_PROCESS,

    SYSCALL_EXIT_THREAD,

    SYSCALL_GET_CURRENT_PROCESS,

    SYSCALL_GET_CURRENT_THREAD,

    SYSCALL_GET_MONOTONIC_CLOCK,

    SYSCALL_GET_PROCESS_INFO,

     SYSCALL_EXECUTE_PROGRAM,

    SYSCALL_GET_THREADLOCAL_STORAGE_BASE        = 0x100,

    SYSCALL_GET_THREADLOCAL_STORAGE_LENGTH,

    SYSCALL_GET_PROGRAM_ARGUMENTS_BASE,

    SYSCALL_GET_PROGRAM_ARGUMENTS_LENGTH,

    SYSCALL_GET_ENVIRONMENT_VARIABLES_BASE,

    SYSCALL_GET_ENVIRONMENT_VARIABLES_LENGTH,

    SYSCALL_ALLOCATE_MEMORY                     = 0x200,

    SYSCALL_RELEASE_MEMORY,

    SYSCALL_FORK                                = 0x300,

    SYSCALL_CREATE_THREAD,

    SYSCALL_CREATE_EVENT,

    SYSCALL_CREATE_SEMAPHORE,

    SYSCALL_CREATE_PIPE,

    SYSCALL_CREATE_TIMER,

     SYSCALL_OBJECT_DUP                         = 0x400,

    SYSCALL_OBJECT_DUP2,

    SYSCALL_OBJECT_EXISTS,

    SYSCALL_OBJECT_COMPARE,

    SYSCALL_OBJECT_CLOSE,

    SYSCALL_OBJECT_SHUTDOWN,

    SYSCALL_OBJECT_GET_STATUS,

    SYSCALL_OBJECT_WAIT,

    SYSCALL_OBJECT_SIGNAL,

    SYSCALL_OBJECT_WRITE,

    SYSCALL_OBJECT_READ,

    SYSCALL_OBJECT_ATTACH_OBJ,

    SYSCALL_OBJECT_DETACH_OBJ,

    SYSCALL_CONSOLE_WRITE                           = 0x500,

    SYSCALL_CONSOLE_WRITE_RAW,

    SYSCALL_CONSOLE_CLEAR,

    SYSCALL_CONSOLE_GET_SIZE,

    SYSCALL_CONSOLE_SET_COLOR,

    SYSCALL_CONSOLE_GET_COLOR,

    SYSCALL_CONSOLE_SET_CURSOR,

    SYSCALL_CONSOLE_GET_CURSOR,

    SYSCALL_CONSOLE_SET_HARDWARE_CURSOR,

    SYSCALL_CONSOLE_GET_HARDWARE_CURSOR,

    SYSCALL_CONSOLE_SET_FLAGS,

    SYSCALL_CONSOLE_GET_FLAGS,

    SYSCALL_FILESYSTEM_SEARCH_FILE                  = 0x600,

    SYSCALL_FILESYSTEM_SEARCH_DIRECTORY,

    SYSCALL_FILESYSTEM_OPEN,

};

#ifndef __KERNEL__

    #define IBNOS_SYSCALL_FN(syscall, n0, n1, n2, n3, n4, n5, n6, n7, n8, n, ...) ibnos_syscall##n
    #define ibnos_syscall(syscall, ...) IBNOS_SYSCALL_FN(syscall, ##__VA_ARGS__, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)(syscall, ##__VA_ARGS__)

    static inline int ibnos_syscall0(int syscall)
    {
        int ret;
        asm volatile ("int $0x80" :"=a"(ret) :"a"(syscall));
        return ret;
    }

    static inline int ibnos_syscall1(int syscall, uint32_t value1)
    {
        int ret;
        asm volatile ("int $0x80" :"=a"(ret) : "a"(syscall), "b"(value1));
        return ret;
    }

    static inline int ibnos_syscall2(int syscall, uint32_t value1, uint32_t value2)
    {
        int ret;
        asm volatile ("int $0x80" :"=a"(ret) : "a"(syscall), "b"(value1), "c" (value2));
        return ret;
    }

    static inline int ibnos_syscall3(int syscall, uint32_t value1, uint32_t value2, uint32_t value3)
    {
        int ret;
        asm volatile ("int $0x80" :"=a"(ret) : "a"(syscall), "b"(value1), "c" (value2), "d" (value3));
        return ret;
    }

    static inline int ibnos_syscall4(int syscall, uint32_t value1, uint32_t value2, uint32_t value3, uint32_t value4)
    {
        int ret;
        asm volatile ("int $0x80" :"=a"(ret) : "a"(syscall), "b"(value1), "c" (value2), "d" (value3), "S" (value4));
        return ret;
    }

    static inline int ibnos_syscall5(int syscall, uint32_t value1, uint32_t value2, uint32_t value3, uint32_t value4, uint32_t value5)
    {
        int ret;
        asm volatile ("int $0x80" :"=a"(ret) : "a"(syscall), "b"(value1), "c" (value2), "d" (value3), "S" (value4), "D" (value5));
        return ret;
    }

    static inline void yield()
    {
        ibnos_syscall(SYSCALL_YIELD);
    }
    /* exit is already provided by the libc */

    static inline void exitThread(int exitcode)
    {
        ibnos_syscall(SYSCALL_EXIT_THREAD, exitcode);
    }

    static inline int32_t getCurrentProcess()
    {
        return (int32_t)ibnos_syscall(SYSCALL_GET_CURRENT_PROCESS);
    }

    static inline int32_t getCurrentThread()
    {
        return (int32_t)ibnos_syscall(SYSCALL_GET_CURRENT_THREAD);
    }

    static inline uint32_t getMonotonicClock()
    {

        return ibnos_syscall(SYSCALL_GET_MONOTONIC_CLOCK);
    }

    static inline uint32_t getProcessInfo(void *info, uint32_t count)
    {
        return ibnos_syscall(SYSCALL_GET_PROCESS_INFO, (uint32_t)info, count);
    }

    static inline int32_t executeProgram(int32_t handle, void *arg, uint32_t arglen, void *env, uint32_t envlen)
    {
        return ibnos_syscall(SYSCALL_EXECUTE_PROGRAM, (uint32_t)handle, (uint32_t)arg, arglen, (uint32_t)env, envlen);
    }

    static inline void *getTLS()
    {
        return (void *)ibnos_syscall(SYSCALL_GET_THREADLOCAL_STORAGE_BASE);
    }

    static inline uint32_t getTLSLength()
    {
        return ibnos_syscall(SYSCALL_GET_THREADLOCAL_STORAGE_LENGTH);
    }

    static inline void *getProgramArguments()
    {
        return (void *)ibnos_syscall(SYSCALL_GET_PROGRAM_ARGUMENTS_BASE);
    }

    static inline uint32_t getProgramArgumentsLength()
    {
        return ibnos_syscall(SYSCALL_GET_PROGRAM_ARGUMENTS_LENGTH);
    }

    static inline void *getEnvironmentVariables()
    {
        return (void *)ibnos_syscall(SYSCALL_GET_ENVIRONMENT_VARIABLES_BASE);
    }

    static inline uint32_t getEnvironmentVariablesLength()
    {
        return ibnos_syscall(SYSCALL_GET_ENVIRONMENT_VARIABLES_LENGTH);
    }

    /* malloc, free and fork are also provided by the libc */

    extern void *_thread_start;
    static inline int32_t createThread(void *func, uint32_t arg0, uint32_t arg1, uint32_t arg2)
    {
        return (int32_t)ibnos_syscall(SYSCALL_CREATE_THREAD, (uint32_t)&_thread_start, (uint32_t)func, arg0, arg1, arg2);
    }

    static inline int32_t createEvent(bool wakeupAll)
    {
        return (int32_t)ibnos_syscall(SYSCALL_CREATE_EVENT, (uint32_t)wakeupAll);
    }

    static inline int32_t createSemaphore(uint32_t value)
    {
        return (int32_t)ibnos_syscall(SYSCALL_CREATE_SEMAPHORE, value);
    }

    static inline int32_t createPipe()
    {
        return (int32_t)ibnos_syscall(SYSCALL_CREATE_PIPE);
    }

    static inline int32_t createTimer(bool wakeupAll)
    {
        return (int32_t)ibnos_syscall(SYSCALL_CREATE_TIMER, (uint32_t)wakeupAll);
    }

    /* dup, dup2 are provided by libc */

    static inline bool objectExists(int32_t handle)
    {
        return ibnos_syscall(SYSCALL_OBJECT_EXISTS, (uint32_t)handle);
    }

    static inline int32_t objectCompare(int32_t handle1, int32_t handle2)
    {
        return (int32_t)ibnos_syscall(SYSCALL_OBJECT_EXISTS, (uint32_t)handle1, (uint32_t)handle2);
    }

    static inline bool objectClose(int32_t handle)
    {
        return ibnos_syscall(SYSCALL_OBJECT_CLOSE, (uint32_t)handle);
    }

    static inline bool objectShutdown(int32_t handle, uint32_t mode)
    {
        return ibnos_syscall(SYSCALL_OBJECT_SHUTDOWN, (uint32_t)handle, mode);
    }

    static inline uint32_t objectGetStatus(int32_t handle, uint32_t mode)
    {
        return ibnos_syscall(SYSCALL_OBJECT_GET_STATUS, (uint32_t)handle, mode);
    }

    static inline int32_t objectWait(int32_t handle, uint32_t mode)
    {
        return (int32_t)ibnos_syscall(SYSCALL_OBJECT_WAIT, (uint32_t)handle, mode);
    }

    static inline bool objectSignal(int32_t handle, uint32_t result)
    {
        return ibnos_syscall(SYSCALL_OBJECT_SIGNAL, (uint32_t)handle, result);
    }

    static inline int32_t objectWrite(int32_t handle, void *buffer, uint32_t length)
    {
        return (int32_t)ibnos_syscall(SYSCALL_OBJECT_WRITE, (uint32_t)handle, (uint32_t)buffer, length);
    }

    static inline int32_t objectRead(int32_t handle, void *buffer, uint32_t length)
    {
        return (int32_t)ibnos_syscall(SYSCALL_OBJECT_READ, (uint32_t)handle, (uint32_t)buffer, length);
    }

    static inline bool objectAttach(int32_t handle, int32_t childHandle, uint32_t mode, uint32_t ident)
    {
        return ibnos_syscall(SYSCALL_OBJECT_ATTACH_OBJ, (uint32_t)handle, (uint32_t)childHandle, mode, ident);
    }

    static inline bool objectDetach(int32_t handle, uint32_t ident)
    {
        return ibnos_syscall(SYSCALL_OBJECT_DETACH_OBJ, (uint32_t)handle, ident);
    }

    static inline int32_t consoleWrite(const char *buffer, uint32_t length)
    {
        return (int32_t)ibnos_syscall(SYSCALL_CONSOLE_WRITE, (uint32_t)buffer, length);
    }

    static inline int32_t consoleWriteRaw(const uint16_t *buffer, uint32_t characters)
    {
        return (int32_t)ibnos_syscall(SYSCALL_CONSOLE_WRITE_RAW, (uint32_t)buffer, characters);
    }

    static inline void consoleClear()
    {
        ibnos_syscall(SYSCALL_CONSOLE_CLEAR);
    }

    static inline uint32_t consoleGetSize()
    {
        return ibnos_syscall(SYSCALL_CONSOLE_GET_SIZE);
    }

    static inline void consoleSetColor(uint32_t value)
    {
        ibnos_syscall(SYSCALL_CONSOLE_SET_COLOR, value);
    }

    static inline uint32_t consoleGetColor()
    {
        return ibnos_syscall(SYSCALL_CONSOLE_GET_COLOR);
    }

    static inline void consoleSetCursor(uint32_t x, uint32_t y)
    {
        ibnos_syscall(SYSCALL_CONSOLE_SET_CURSOR, x, y);
    }

    static inline uint32_t consoleGetCursor()
    {
        return ibnos_syscall(SYSCALL_CONSOLE_GET_CURSOR);
    }

    static inline void consoleSetHardwareCursor(uint32_t x, uint32_t y)
    {
        ibnos_syscall(SYSCALL_CONSOLE_SET_HARDWARE_CURSOR, x, y);
    }

    static inline uint32_t consoleGetHardwareCursor()
    {
        return ibnos_syscall(SYSCALL_CONSOLE_GET_HARDWARE_CURSOR);
    }

    static inline void consoleSetFlags(uint32_t flags)
    {
        ibnos_syscall(SYSCALL_CONSOLE_SET_FLAGS, flags);
    }

    static inline uint32_t consoleGetFlags()
    {
        return ibnos_syscall(SYSCALL_CONSOLE_GET_FLAGS);
    }

    static inline int32_t filesystemSearchFile(int32_t handle, const char *path, uint32_t length, bool create)
    {
        return ibnos_syscall(SYSCALL_FILESYSTEM_SEARCH_FILE, (uint32_t)handle, (uint32_t)path, length, create);
    }

    static inline int32_t filesystemSearchDirectory(int32_t handle, const char *path, uint32_t length, bool create)
    {
        return ibnos_syscall(SYSCALL_FILESYSTEM_SEARCH_DIRECTORY, (uint32_t)handle, (uint32_t)path, length, create);
    }

    static inline int32_t filesystemOpen(int32_t handle)
    {
        return ibnos_syscall(SYSCALL_FILESYSTEM_OPEN, (uint32_t)handle);
    }

#endif

#endif /* _H_SYSCALL_ */