syscalls.h

Go to the documentation of this file.

/*
    This file is part of Fennix Kernel.
 
    Fennix Kernel is free software: you can redistribute it and/or
    modify it under the terms of the GNU General Public License as
    published by the Free Software Foundation, either version 3 of
    the License, or (at your option) any later version.
 
    Fennix Kernel is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with Fennix Kernel. If not, see <https://www.gnu.org/licenses/>.
*/
 
#ifndef __FENNIX_API_SYSTEM_CALLS_LIST_H__
#define __FENNIX_API_SYSTEM_CALLS_LIST_H__
 
#if __has_include(<interface/fcntl.h>)
#include <interface/fcntl.h>
#else
#include <fcntl.h>
#endif
 
#ifndef __fennix__
#error "__fennix__ not defined"
#endif
 
#pragma region Syscall Wrappers
 
#define scarg __UINTPTR_TYPE__
 
#ifdef __arm__
#ifdef __thumb__
#define __thumb_r7
#define __arm_call(...)
#warning "arm thumb code not implemented"
#else /* __thumb__ */
#define __thumb_r7 __asm__("r7")
#define __arm_call(...)                \
    __asm__ __volatile__("svc 0"       \
                         : "=r"(r0)    \
                         : __VA_ARGS__ \
                         : "memory")
#endif /* __thumb__ */
 
#ifdef __thumb2__
#define __r7_operand "rI"(r7)
#else /* __thumb2__ */
#define __r7_operand "r"(r7)
#endif /* __thumb2__ */
#endif /* __arm__ */
 
static inline scarg syscall0(scarg syscall)
{
    scarg ret;
#if defined(__amd64__)
    __asm__ __volatile__("syscall"
                         : "=a"(ret)
                         : "a"(syscall)
                         : "rcx", "r11", "memory");
#elif defined(__i386__)
    __asm__ __volatile__("int $0x30"
                         : "=a"(ret)
                         : "a"(syscall)
                         : "memory");
#elif defined(__arm__)
    register scarg r7 __thumb_r7 = syscall;
    register scarg r0 __asm__("r0");
    __arm_call(__r7_operand);
#elif defined(__aarch64__)
    register scarg x8 __asm__("x8") = syscall;
    register scarg x0 __asm__("x0");
    __asm__ __volatile__("svc 0"
                         : "=r"(x0)
                         : "r"(x8)
                         : "memory", "cc");
#else
#error "Unsupported architecture"
#endif
    return ret;
}
 
static inline scarg syscall1(scarg syscall, scarg arg1)
{
    scarg ret;
#if defined(__amd64__)
    __asm__ __volatile__("syscall"
                         : "=a"(ret)
                         : "a"(syscall), "D"(arg1)
                         : "rcx", "r11", "memory");
#elif defined(__i386__)
    __asm__ __volatile__("int $0x30"
                         : "=a"(ret)
                         : "a"(syscall), "b"(arg1)
                         : "memory");
#elif defined(__arm__)
    register scarg r7 __thumb_r7 = syscall;
    register scarg r0 __asm__("r0") = arg1;
    __arm_call(__r7_operand, "0"(r0));
#elif defined(__aarch64__)
    register scarg x8 __asm__("x8") = syscall;
    register scarg x0 __asm__("x0") = arg1;
    __asm__ __volatile__("svc 0"
                         : "=r"(ret)
                         : "r"(x8), "0"(x0)
                         : "memory", "cc");
#else
#error "Unsupported architecture"
#endif
    return ret;
}
 
static inline scarg syscall2(scarg syscall, scarg arg1, scarg arg2)
{
    scarg ret;
#if defined(__amd64__)
    __asm__ __volatile__("syscall"
                         : "=a"(ret)
                         : "a"(syscall), "D"(arg1), "S"(arg2)
                         : "rcx", "r11", "memory");
#elif defined(__i386__)
    __asm__ __volatile__("int $0x30"
                         : "=a"(ret)
                         : "a"(syscall), "b"(arg1), "c"(arg2)
                         : "memory");
#elif defined(__arm__)
    register scarg r7 __thumb_r7 = syscall;
    register scarg r0 __asm__("r0") = arg1;
    register scarg r1 __asm__("r1") = arg2;
    __arm_call(__r7_operand, "0"(r0), "r"(r1));
#elif defined(__aarch64__)
    register scarg x8 __asm__("x8") = syscall;
    register scarg x0 __asm__("x0") = arg1;
    register scarg x1 __asm__("x1") = arg2;
    __asm__ __volatile__("svc 0"
                         : "=r"(ret)
                         : "r"(x8), "0"(x0), "r"(x1)
                         : "memory", "cc");
#else
#error "Unsupported architecture"
#endif
    return ret;
}
 
static inline scarg syscall3(scarg syscall, scarg arg1, scarg arg2, scarg arg3)
{
    scarg ret;
#if defined(__amd64__)
    __asm__ __volatile__("syscall"
                         : "=a"(ret)
                         : "a"(syscall), "D"(arg1), "S"(arg2), "d"(arg3)
                         : "rcx", "r11", "memory");
#elif defined(__i386__)
    __asm__ __volatile__("int $0x30"
                         : "=a"(ret)
                         : "a"(syscall), "b"(arg1), "c"(arg2), "d"(arg3)
                         : "memory");
#elif defined(__arm__)
    register scarg r7 __thumb_r7 = syscall;
    register scarg r0 __asm__("r0") = arg1;
    register scarg r1 __asm__("r1") = arg2;
    register scarg r2 __asm__("r2") = arg3;
    __arm_call(__r7_operand, "0"(r0), "r"(r1), "r"(r2));
#elif defined(__aarch64__)
    register scarg x8 __asm__("x8") = syscall;
    register scarg x0 __asm__("x0") = arg1;
    register scarg x1 __asm__("x1") = arg2;
    register scarg x2 __asm__("x2") = arg3;
    __asm__ __volatile__("svc 0"
                         : "=r"(ret)
                         : "r"(x8), "0"(x0), "r"(x1), "r"(x2)
                         : "memory", "cc");
#else
#error "Unsupported architecture"
#endif
    return ret;
}
 
static inline scarg syscall4(scarg syscall, scarg arg1, scarg arg2, scarg arg3, scarg arg4)
{
    scarg ret;
#if defined(__amd64__)
    register scarg r10 __asm__("r10") = arg4;
    __asm__ __volatile__("syscall"
                         : "=a"(ret)
                         : "a"(syscall), "D"(arg1), "S"(arg2), "d"(arg3), "r"(r10)
                         : "rcx", "r11", "memory");
#elif defined(__i386__)
    __asm__ __volatile__("int $0x30"
                         : "=a"(ret)
                         : "a"(syscall), "b"(arg1), "c"(arg2), "d"(arg3), "S"(arg4)
                         : "memory");
#elif defined(__arm__)
    register scarg r7 __thumb_r7 = syscall;
    register scarg r0 __asm__("r0") = arg1;
    register scarg r1 __asm__("r1") = arg2;
    register scarg r2 __asm__("r2") = arg3;
    register scarg r3 __asm__("r3") = arg4;
    __arm_call(__r7_operand, "0"(r0), "r"(r1), "r"(r2), "r"(r3));
#elif defined(__aarch64__)
    register scarg x8 __asm__("x8") = syscall;
    register scarg x0 __asm__("x0") = arg1;
    register scarg x1 __asm__("x1") = arg2;
    register scarg x2 __asm__("x2") = arg3;
    register scarg x3 __asm__("x3") = arg4;
    __asm__ __volatile__("svc 0"
                         : "=r"(ret)
                         : "r"(x8), "0"(x0), "r"(x1), "r"(x2), "r"(x3)
                         : "memory", "cc");
#else
#error "Unsupported architecture"
#endif
    return ret;
}
 
static inline scarg syscall5(scarg syscall, scarg arg1, scarg arg2, scarg arg3, scarg arg4, scarg arg5)
{
    scarg ret;
#if defined(__amd64__)
    register scarg r10 __asm__("r10") = arg4;
    register scarg r8 __asm__("r8") = arg5;
    __asm__ __volatile__("syscall"
                         : "=a"(ret)
                         : "a"(syscall), "D"(arg1), "S"(arg2), "d"(arg3), "r"(r10), "r"(r8)
                         : "rcx", "r11", "memory");
#elif defined(__i386__)
    __asm__ __volatile__("int $0x30"
                         : "=a"(ret)
                         : "a"(syscall), "b"(arg1), "c"(arg2), "d"(arg3), "S"(arg4), "D"(arg5)
                         : "memory");
#elif defined(__arm__)
    register scarg r7 __thumb_r7 = syscall;
    register scarg r0 __asm__("r0") = arg1;
    register scarg r1 __asm__("r1") = arg2;
    register scarg r2 __asm__("r2") = arg3;
    register scarg r3 __asm__("r3") = arg4;
    register scarg r4 __asm__("r4") = arg5;
    __arm_call(__r7_operand, "0"(r0), "r"(r1), "r"(r2), "r"(r3), "r"(r4));
#elif defined(__aarch64__)
    register scarg x8 __asm__("x8") = syscall;
    register scarg x0 __asm__("x0") = arg1;
    register scarg x1 __asm__("x1") = arg2;
    register scarg x2 __asm__("x2") = arg3;
    register scarg x3 __asm__("x3") = arg4;
    register scarg x4 __asm__("x4") = arg5;
    __asm__ __volatile__("svc 0"
                         : "=r"(ret)
                         : "r"(x8), "0"(x0), "r"(x1), "r"(x2), "r"(x3), "r"(x4)
                         : "memory", "cc");
#else
#error "Unsupported architecture"
#endif
    return ret;
}
 
static inline scarg syscall6(scarg syscall, scarg arg1, scarg arg2, scarg arg3, scarg arg4, scarg arg5, scarg arg6)
{
    scarg ret;
#if defined(__amd64__)
    register scarg r10 __asm__("r10") = arg4;
    register scarg r8 __asm__("r8") = arg5;
    register scarg r9 __asm__("r9") = arg6;
    __asm__ __volatile__("syscall"
                         : "=a"(ret)
                         : "a"(syscall), "D"(arg1), "S"(arg2), "d"(arg3), "r"(r10), "r"(r8), "r"(r9)
                         : "rcx", "r11", "memory");
#elif defined(__i386__)
    __asm__ __volatile__("int $0x30"
                         : "=a"(ret)
                         : "a"(syscall), "b"(arg1), "c"(arg2), "d"(arg3), "S"(arg4), "D"(arg5), "g"(arg6)
                         : "memory");
#elif defined(__arm__)
    register scarg r7 __thumb_r7 = syscall;
    register scarg r0 __asm__("r0") = arg1;
    register scarg r1 __asm__("r1") = arg2;
    register scarg r2 __asm__("r2") = arg3;
    register scarg r3 __asm__("r3") = arg4;
    register scarg r4 __asm__("r4") = arg5;
    register scarg r5 __asm__("r5") = arg6;
    __arm_call(__r7_operand, "0"(r0), "r"(r1), "r"(r2), "r"(r3), "r"(r4), "r"(r5));
#elif defined(__aarch64__)
    register scarg x8 __asm__("x8") = syscall;
    register scarg x0 __asm__("x0") = arg1;
    register scarg x1 __asm__("x1") = arg2;
    register scarg x2 __asm__("x2") = arg3;
    register scarg x3 __asm__("x3") = arg4;
    register scarg x4 __asm__("x4") = arg5;
    register scarg x5 __asm__("x5") = arg6;
    __asm__ __volatile__("svc 0"
                         : "=r"(ret)
                         : "r"(x8), "0"(x0), "r"(x1), "r"(x2), "r"(x3), "r"(x4), "r"(x5)
                         : "memory", "cc");
#else
#error "Unsupported architecture"
#endif
    return ret;
}
 
#pragma endregion Syscall Wrappers
 
#define __SYS_NULL ((void *)0)
 
typedef enum
{
    __SYS_PROT_READ = 0x1,
    __SYS_PROT_WRITE = 0x2,
    __SYS_PROT_EXEC = 0x4,
    __SYS_PROT_NONE = 0x0,
 
    __SYS_MAP_SHARED = 0x1,
    __SYS_MAP_PRIVATE = 0x2,
    __SYS_MAP_FIXED = 0x4,
    __SYS_MAP_ANONYMOUS = 0x8,
    __SYS_MAP_ANON = __SYS_MAP_ANONYMOUS
} syscall_mmap_flags_t;
 
typedef enum
{
    __SYS_O_RDONLY = O_RDONLY,
    __SYS_O_WRONLY = O_WRONLY,
    __SYS_O_RDWR = O_RDWR,
    __SYS_O_APPEND = O_APPEND,
    __SYS_O_CREAT = O_CREAT,
    __SYS_O_DSYNC = O_DSYNC,
    __SYS_O_EXCL = O_EXCL,
    __SYS_O_NOCTTY = O_NOCTTY,
    __SYS_O_NONBLOCK = O_NONBLOCK,
    __SYS_O_RSYNC = O_RSYNC,
    __SYS_O_SYNC = O_SYNC,
    __SYS_O_TRUNC = O_TRUNC
} syscall_open_flags_t;
 
typedef enum
{
    __SYS_F_OK = 0,
    __SYS_R_OK = 1,
    __SYS_W_OK = 2,
    __SYS_X_OK = 3
} syscall_access_flags_t;
 
typedef enum
{
    __SYS_GET_GS = 0,
    __SYS_SET_GS = 1,
    __SYS_GET_FS = 2,
    __SYS_SET_FS = 3,
} syscall_prctl_options_t;
#ifdef __kernel__
typedef syscall_prctl_options_t prctl_options_t;
#endif
 
typedef enum
{
    __SYS_SEEK_SET = 0,
    __SYS_SEEK_CUR = 1,
    __SYS_SEEK_END = 2
} syscall_seek_whence_t;
 
typedef enum
{
    __SYS_SIGNULL = 0,
    /* Process abort signal. */
    __SYS_SIGABRT = 1,
    /* Alarm clock. */
    __SYS_SIGALRM = 2,
    /* Access to an undefined portion of a memory object. */
    __SYS_SIGBUS = 3,
    /* Child process terminated, stopped, or continued. */
    __SYS_SIGCHLD = 4,
    /* Continue executing, if stopped. */
    __SYS_SIGCONT = 5,
    /* Erroneous arithmetic operation. */
    __SYS_SIGFPE = 6,
    /* Hangup. */
    __SYS_SIGHUP = 7,
    /* Illegal instruction. */
    __SYS_SIGILL = 8,
    /* Terminal interrupt signal. */
    __SYS_SIGINT = 9,
    /* Kill (cannot be caught or ignored). */
    __SYS_SIGKILL = 10,
    /* Write on a pipe with no one to read it. */
    __SYS_SIGPIPE = 11,
    /* Terminal quit signal. */
    __SYS_SIGQUIT = 12,
    /* Invalid memory reference. */
    __SYS_SIGSEGV = 13,
    /* Stop executing (cannot be caught or ignored). */
    __SYS_SIGSTOP = 14,
    /* Termination signal. */
    __SYS_SIGTERM = 15,
    /* Terminal stop signal. */
    __SYS_SIGTSTP = 16,
    /* Background process attempting read. */
    __SYS_SIGTTIN = 17,
    /* Background process attempting write. */
    __SYS_SIGTTOU = 18,
    /* User-defined signal 1. */
    __SYS_SIGUSR1 = 19,
    /* User-defined signal 2. */
    __SYS_SIGUSR2 = 20,
    /* Pollable event. */
    __SYS_SIGPOLL = 21,
    /* Profiling timer expired. */
    __SYS_SIGPROF = 22,
    /* Bad system call. */
    __SYS_SIGSYS = 23,
    /* Trace/breakpoint trap. */
    __SYS_SIGTRAP = 24,
    /* High bandwidth data is available at a socket. */
    __SYS_SIGURG = 25,
    /* Virtual timer expired. */
    __SYS_SIGVTALRM = 26,
    /* CPU time limit exceeded. */
    __SYS_SIGXCPU = 27,
    /* File size limit exceeded. */
    __SYS_SIGXFSZ = 28,
 
    __SYS_SIGCOMP1 = 29,
    __SYS_SIGCOMP2 = 30,
    __SYS_SIGCOMP3 = 31,
 
    /* Real-time signals. */
    __SYS_SIGRTMIN = 32,
    __SYS_SIGRT_1 = 33,
    __SYS_SIGRT_2 = 34,
    __SYS_SIGRT_3 = 35,
    __SYS_SIGRT_4 = 36,
    __SYS_SIGRT_5 = 37,
    __SYS_SIGRT_6 = 38,
    __SYS_SIGRT_7 = 39,
    __SYS_SIGRT_8 = 40,
    __SYS_SIGRT_9 = 41,
    __SYS_SIGRT_10 = 42,
    __SYS_SIGRT_11 = 43,
    __SYS_SIGRT_12 = 44,
    __SYS_SIGRT_13 = 45,
    __SYS_SIGRT_14 = 46,
    __SYS_SIGRT_15 = 47,
    __SYS_SIGRT_16 = 48,
    __SYS_SIGRT_17 = 49,
    __SYS_SIGRT_18 = 50,
    __SYS_SIGRT_19 = 51,
    __SYS_SIGRT_20 = 52,
    __SYS_SIGRT_21 = 53,
    __SYS_SIGRT_22 = 54,
    __SYS_SIGRT_23 = 55,
    __SYS_SIGRT_24 = 56,
    __SYS_SIGRT_25 = 57,
    __SYS_SIGRT_26 = 58,
    __SYS_SIGRT_27 = 59,
    __SYS_SIGRT_28 = 60,
    __SYS_SIGRT_29 = 61,
    __SYS_SIGRT_30 = 62,
    __SYS_SIGRT_31 = 63,
    __SYS_SIGRTMAX = 64,
 
    /* Maximum signal number. */
    __SYS_SIGNAL_MAX = __SYS_SIGRTMAX
} syscall_signal_t;
#ifdef __kernel__
typedef syscall_signal_t signal_t;
#endif
 
typedef enum
{
    __SYS_SIG_TERM = 0,
    __SYS_SIG_IGN = 1,
    __SYS_SIG_CONT = 2,
    __SYS_SIG_STOP = 3,
    __SYS_SIG_CORE = 4
} syscall_signal_disposition_t;
#ifdef __kernel__
typedef syscall_signal_disposition_t signal_disposition_t;
#endif
 
typedef enum
{
    __SYS_SIG_BLOCK = 0,
    __SYS_SIG_UNBLOCK = 1,
    __SYS_SIG_SETMASK = 2
} syscall_signal_actions_t;
 
typedef enum
{
    __SYS_SA_NOCLDSTOP = 1,
    __SYS_SA_ONSTACK = 0x08000000,
    __SYS_SA_RESETHAND = 0x80000000,
    __SYS_SA_RESTART = 0x10000000,
    __SYS_SA_SIGINFO = 4,
    __SYS_SA_NOCLDWAIT = 2,
    __SYS_SA_NODEFER = 0x40000000,
} syscall_signal_action_flags_t;
 
typedef enum
{
    __SYS_SIG_ERR = -1,
    __SYS_SIG_DFL = 0,
    ___SYS_SIG_IGN = 1
} syscall_signal_action_disposition_t;
 
typedef enum
{
    __SYS_CLOCK_MONOTONIC = 1,
    __SYS_CLOCK_PROCESS_CPUTIME_ID = 2,
    __SYS_CLOCK_REALTIME = 3,
    __SYS_CLOCK_THREAD_CPUTIME_ID = 4,
} syscall_clockid_t;
 
#ifndef __cplusplus
_Static_assert((int)__SYS_SIG_IGN == (int)___SYS_SIG_IGN, "SIG_IGN values do not match");
#else
static_assert((int)__SYS_SIG_IGN == (int)___SYS_SIG_IGN, "SIG_IGN values do not match");
#endif
 
typedef int __SYS_clockid_t;
typedef unsigned int __SYS_socklen_t;
 
typedef struct FramebufferScreenInfo
{
    __UINT32_TYPE__ Width;
    __UINT32_TYPE__ Height;
    __UINT32_TYPE__ Pitch;
    __UINT32_TYPE__ Bpp;
    __UINT32_TYPE__ Size;
} FramebufferScreenInfo;
 
#define FBIOGET_SCREEN_INFO 0xf0
 
struct kutsname
{
    char sysname[65];
    char release[65];
    char version[65];
    char machine[65];
};
 
typedef enum
{
    /* Initialization */
 
    SYS_API_VERSION = 0,
 
    SYS_DEBUG_REPORT = 1,
 
    /* I/O */
 
    SYS_READ = 100,
    SYS_PREAD,
    SYS_WRITE,
    SYS_PWRITE,
    SYS_OPEN,
    SYS_CLOSE,
    SYS_IOCTL,
    SYS_FCNTL,
 
    /* File Status */
 
    SYS_STAT = 200,
    SYS_FSTAT,
    SYS_LSTAT,
    SYS_ACCESS,
    SYS_TRUNCATE,
    SYS_FTRUNCATE,
    SYS_TELL,
    SYS_SEEK,
 
    /* Process Control */
 
    SYS_EXIT = 300,
    SYS_FORK,
    SYS_EXECVE,
    SYS_GETPID,
    SYS_GETPPID,
    SYS_WAITPID,
    SYS_KILL,
    SYS_PRCTL,
 
    /* Memory */
 
    SYS_BRK = 400,
    SYS_MMAP,
    SYS_MUNMAP,
    SYS_MPROTECT,
    SYS_MADVISE,
 
    /* Communication */
 
    SYS_PIPE = 500,
    SYS_DUP,
    SYS_DUP2,
    SYS_SOCKET,
    SYS_BIND,
    SYS_CONNECT,
    SYS_LISTEN,
    SYS_ACCEPT,
    SYS_SEND,
    SYS_RECV,
    SYS_SHUTDOWN,
 
    /* Time */
 
    SYS_TIME = 600,
    SYS_CLOCK_GETTIME,
    SYS_CLOCK_SETTIME,
    SYS_NANOSLEEP,
 
    /* Miscellaneous */
 
    SYS_GETCWD = 700,
    SYS_CHDIR,
    SYS_MKDIR,
    SYS_RMDIR,
    SYS_UNLINK,
    SYS_RENAME,
    SYS_UNAME,
 
    SYS_MAX
} syscalls_t;
 
/* Initialization */
 
#define call_api_version(version) syscall1(SYS_API_VERSION, (scarg)version)
 
/* I/O */
 
#define call_read(fd, buf, count) syscall3(SYS_READ, (scarg)fd, (scarg)buf, (scarg)count)
 
#define call_pread(fd, buf, count, offset) syscall4(SYS_PREAD, (scarg)fd, (scarg)buf, (scarg)count, (scarg)offset)
 
#define call_write(fd, buf, count) syscall3(SYS_WRITE, (scarg)fd, (scarg)buf, (scarg)count)
 
#define call_pwrite(fd, buf, count, offset) syscall4(SYS_PWRITE, (scarg)fd, (scarg)buf, (scarg)count, (scarg)offset)
 
#define call_open(pathname, flags, mode) syscall3(SYS_OPEN, (scarg)pathname, (scarg)flags, (scarg)mode)
 
#define call_close(fd) syscall1(SYS_CLOSE, fd)
 
#define call_ioctl(fd, request, argp) syscall3(SYS_IOCTL, (scarg)fd, (scarg)request, (scarg)argp)
 
#define call_fcntl(fd, cmd, arg) syscall3(SYS_FCNTL, (scarg)fd, (scarg)cmd, (scarg)arg)
 
/* File Status */
 
#define call_stat(pathname, statbuf) syscall2(SYS_STAT, (scarg)pathname, (scarg)statbuf)
 
#define call_fstat(fd, statbuf) syscall2(SYS_FSTAT, (scarg)fd, (scarg)statbuf)
 
#define call_lstat(pathname, statbuf) syscall2(SYS_LSTAT, (scarg)pathname, (scarg)statbuf)
 
#define call_access(pathname, mode) syscall2(SYS_ACCESS, (scarg)pathname, (scarg)mode)
 
#define call_truncate(pathname, length) syscall2(SYS_TRUNCATE, (scarg)pathname, (scarg)length)
 
#define call_ftruncate(fd, length) syscall2(SYS_FTRUNCATE, (scarg)fd, (scarg)length)
 
#define call_tell(fd) syscall1(SYS_TELL, (scarg)fd)
 
#define call_seek(fd, offset, whence) syscall3(SYS_SEEK, (scarg)fd, (scarg)offset, (scarg)whence)
 
/* Process Control */
 
#define call_exit(status) syscall1(SYS_EXIT, (scarg)status)
 
#define call_fork() syscall0(SYS_FORK)
 
#define call_execve(pathname, argv, envp) syscall3(SYS_EXECVE, (scarg)pathname, (scarg)argv, (scarg)envp)
 
#define call_getpid() syscall0(SYS_GETPID)
 
#define call_getppid() syscall0(SYS_GETPPID)
 
#define call_waitpid(pid, wstatus, options) syscall3(SYS_WAITPID, (scarg)pid, (scarg)wstatus, (scarg)options)
 
#define call_kill(pid, sig) syscall2(SYS_KILL, (scarg)pid, (scarg)sig)
 
#define call_prctl(option, arg1, arg2, arg3, arg4) syscall5(SYS_PRCTL, (scarg)option, (scarg)arg1, (scarg)arg2, (scarg)arg3, (scarg)arg4)
 
/* Memory */
 
#define call_brk(end_data) syscall1(SYS_BRK, (scarg)end_data)
 
#define call_mmap(addr, length, prot, flags, fd, offset) syscall6(SYS_MMAP, (scarg)addr, (scarg)length, (scarg)prot, (scarg)flags, (scarg)fd, (scarg)offset)
 
#define call_munmap(addr, length) syscall2(SYS_MUNMAP, (scarg)addr, (scarg)length)
 
#define call_mprotect(addr, length, prot) syscall3(SYS_MPROTECT, (scarg)addr, (scarg)length, (scarg)prot)
 
#define call_madvise(addr, length, advice) syscall3(SYS_MADVISE, (scarg)addr, (scarg)length, (scarg)advice)
 
/* Communication */
 
#define call_pipe(pipefd) syscall1(SYS_PIPE, (scarg)pipefd)
 
#define call_dup(oldfd) syscall1(SYS_DUP, (scarg)oldfd)
 
#define call_dup2(oldfd, newfd) syscall2(SYS_DUP2, (scarg)oldfd, (scarg)newfd)
 
#define call_socket(domain, type, protocol) syscall3(SYS_SOCKET, (scarg)domain, (scarg)type, (scarg)protocol)
 
#define call_bind(sockfd, addr, addrlen) syscall3(SYS_BIND, (scarg)sockfd, (scarg)addr, (scarg)addrlen)
 
#define call_connect(sockfd, addr, addrlen) syscall3(SYS_CONNECT, (scarg)sockfd, (scarg)addr, (scarg)addrlen)
 
#define call_listen(sockfd, backlog) syscall2(SYS_LISTEN, (scarg)sockfd, (scarg)backlog)
 
#define call_accept(sockfd, addr, addrlen) syscall3(SYS_ACCEPT, (scarg)sockfd, (scarg)addr, (scarg)addrlen)
 
#define call_send(sockfd, buf, len, flags) syscall4(SYS_SEND, (scarg)sockfd, (scarg)buf, (scarg)len, (scarg)flags)
 
#define call_recv(sockfd, buf, len, flags) syscall4(SYS_RECV, (scarg)sockfd, (scarg)buf, (scarg)len, (scarg)flags)
 
#define call_shutdown(sockfd, how) syscall2(SYS_SHUTDOWN, (scarg)sockfd, (scarg)how)
 
/* Time */
 
#define call_time(t) syscall1(SYS_TIME, (scarg)t)
 
#define call_clock_gettime(clockid, tp) syscall2(SYS_CLOCK_GETTIME, (scarg)clockid, (scarg)tp)
 
#define call_clock_settime(clockid, tp) syscall2(SYS_CLOCK_SETTIME, (scarg)clockid, (scarg)tp)
 
#define call_nanosleep(req, rem) syscall2(SYS_NANOSLEEP, (scarg)req, (scarg)rem)
 
/* Miscellaneous */
 
#define call_getcwd(buf, size) syscall2(SYS_GETCWD, (scarg)buf, (scarg)size)
 
#define call_chdir(path) syscall1(SYS_CHDIR, (scarg)path)
 
#define call_mkdir(path, mode) syscall2(SYS_MKDIR, (scarg)path, (scarg)mode)
 
#define call_rmdir(path) syscall1(SYS_RMDIR, (scarg)path)
 
#define call_unlink(pathname) syscall1(SYS_UNLINK, (scarg)pathname)
 
#define call_rename(oldpath, newpath) syscall2(SYS_RENAME, (scarg)oldpath, (scarg)newpath)
 
#define call_uname(buf) syscall1(SYS_UNAME, (scarg)buf)
 
#endif // !__FENNIX_API_SYSTEM_CALLS_LIST_H__