usermode.h

Go to the documentation of this file.

// SPDX-License-Identifier: GPL-3.0-or-later
// Usermode syscall wrappers
// This file was generated by scripts/gen_syscall.py
 
#pragma once
 
#include <mos/filesystem/fs_types.h>
#include <mos/io/io_types.h>
#include <mos/mos_global.h>
#include <mos/tasks/signal_types.h>
#include <mos/types.h>
#include <sys/poll.h>
#include <sys/select.h>
#include <sys/uio.h>
 
// platform syscall header
#include <mos/platform_syscall.h>
#include <mos/syscall/number.h>
 
#ifdef __MOS_KERNEL__
#error "This file should not be included in the kernel!"
#endif
 
should_inline fd_t syscall_vfs_openat(fd_t dirfd, const char *file_path, open_flags flags)
{
    return (fd_t) platform_syscall3(SYSCALL_vfs_openat, (reg_t) dirfd, (reg_t) file_path, (reg_t) flags);
}
 
should_inline long syscall_vfs_fstatat(fd_t dirfd, const char *file_path, file_stat_t *stat_buf, fstatat_flags flags)
{
    return (long) platform_syscall4(SYSCALL_vfs_fstatat, (reg_t) dirfd, (reg_t) file_path, (reg_t) stat_buf, (reg_t) flags);
}
 
should_inline size_t syscall_io_read(fd_t fd, void *buffer, size_t size)
{
    return (size_t) platform_syscall3(SYSCALL_io_read, (reg_t) fd, (reg_t) buffer, (reg_t) size);
}
 
should_inline size_t syscall_io_write(fd_t fd, const void *buffer, size_t size)
{
    return (size_t) platform_syscall3(SYSCALL_io_write, (reg_t) fd, (reg_t) buffer, (reg_t) size);
}
 
should_inline bool syscall_io_close(fd_t fd)
{
    return (bool) platform_syscall1(SYSCALL_io_close, (reg_t) fd);
}
 
should_inline __attribute__((__noreturn__)) void syscall_exit(u32 exit_code)
{
    platform_syscall1(SYSCALL_exit, (reg_t) exit_code);
    __builtin_unreachable();
}
 
should_inline void syscall_yield_cpu(void)
{
    platform_syscall0(SYSCALL_yield_cpu);
}
 
should_inline pid_t syscall_fork(void)
{
    return (pid_t) platform_syscall0(SYSCALL_fork);
}
 
should_inline pid_t syscall_get_pid(void)
{
    return (pid_t) platform_syscall0(SYSCALL_get_pid);
}
 
should_inline pid_t syscall_get_parent_pid(void)
{
    return (pid_t) platform_syscall0(SYSCALL_get_parent_pid);
}
 
should_inline pid_t syscall_spawn(const char *file_path, const char *const *argv, const char *const *envp)
{
    return (pid_t) platform_syscall3(SYSCALL_spawn, (reg_t) file_path, (reg_t) argv, (reg_t) envp);
}
 
should_inline tid_t syscall_create_thread(const char *name, thread_entry_t entry, void *arg, size_t stack_size, void *stack)
{
    return (tid_t) platform_syscall5(SYSCALL_create_thread, (reg_t) name, (reg_t) entry, (reg_t) arg, (reg_t) stack_size, (reg_t) stack);
}
 
should_inline tid_t syscall_get_tid(void)
{
    return (tid_t) platform_syscall0(SYSCALL_get_tid);
}
 
should_inline __attribute__((__noreturn__)) void syscall_thread_exit(void)
{
    platform_syscall0(SYSCALL_thread_exit);
    __builtin_unreachable();
}
 
should_inline bool syscall_wait_for_thread(tid_t tid)
{
    return (bool) platform_syscall1(SYSCALL_wait_for_thread, (reg_t) tid);
}
 
should_inline bool syscall_futex_wait(futex_word_t *futex, u32 val)
{
    return (bool) platform_syscall2(SYSCALL_futex_wait, (reg_t) futex, (reg_t) val);
}
 
should_inline bool syscall_futex_wake(futex_word_t *futex, size_t count)
{
    return (bool) platform_syscall2(SYSCALL_futex_wake, (reg_t) futex, (reg_t) count);
}
 
should_inline fd_t syscall_ipc_create(const char *name, size_t max_pending_connections)
{
    return (fd_t) platform_syscall2(SYSCALL_ipc_create, (reg_t) name, (reg_t) max_pending_connections);
}
 
should_inline fd_t syscall_ipc_accept(fd_t fd)
{
    return (fd_t) platform_syscall1(SYSCALL_ipc_accept, (reg_t) fd);
}
 
should_inline fd_t syscall_ipc_connect(const char *name, size_t buffer_size)
{
    return (fd_t) platform_syscall2(SYSCALL_ipc_connect, (reg_t) name, (reg_t) buffer_size);
}
 
should_inline u64 syscall_arch_syscall(u64 nr, u64 arg1, u64 arg2, u64 arg3, u64 arg4)
{
    return (u64) platform_syscall5(SYSCALL_arch_syscall, (reg_t) nr, (reg_t) arg1, (reg_t) arg2, (reg_t) arg3, (reg_t) arg4);
}
 
should_inline long syscall_vfs_mount(const char *device, const char *mount_point, const char *fs_type, const char *options)
{
    return (long) platform_syscall4(SYSCALL_vfs_mount, (reg_t) device, (reg_t) mount_point, (reg_t) fs_type, (reg_t) options);
}
 
should_inline ssize_t syscall_vfs_readlinkat(fd_t dirfd, const char *path, char *buf, size_t buf_size)
{
    return (ssize_t) platform_syscall4(SYSCALL_vfs_readlinkat, (reg_t) dirfd, (reg_t) path, (reg_t) buf, (reg_t) buf_size);
}
 
should_inline long syscall_vfs_unlinkat(fd_t dirfd, const char *path)
{
    return (long) platform_syscall2(SYSCALL_vfs_unlinkat, (reg_t) dirfd, (reg_t) path);
}
 
should_inline long syscall_vfs_symlink(const char *link_path, const char *target)
{
    return (long) platform_syscall2(SYSCALL_vfs_symlink, (reg_t) link_path, (reg_t) target);
}
 
should_inline long syscall_vfs_mkdir(const char *path)
{
    return (long) platform_syscall1(SYSCALL_vfs_mkdir, (reg_t) path);
}
 
should_inline size_t syscall_vfs_list_dir(fd_t fd, char *buffer, size_t buffer_size)
{
    return (size_t) platform_syscall3(SYSCALL_vfs_list_dir, (reg_t) fd, (reg_t) buffer, (reg_t) buffer_size);
}
 
should_inline long syscall_fd_manipulate(fd_t fd, u64 cmd, void *arg)
{
    return (long) platform_syscall3(SYSCALL_fd_manipulate, (reg_t) fd, (reg_t) cmd, (reg_t) arg);
}
 
should_inline void *syscall_mmap_anonymous(ptr_t hint_addr, size_t size, mem_perm_t perm, mmap_flags_t flags)
{
    return (void *) platform_syscall4(SYSCALL_mmap_anonymous, (reg_t) hint_addr, (reg_t) size, (reg_t) perm, (reg_t) flags);
}
 
should_inline void *syscall_mmap_file(ptr_t hint_addr, size_t size, mem_perm_t perm, mmap_flags_t flags, fd_t fd, off_t offset)
{
    return (void *) platform_syscall6(SYSCALL_mmap_file, (reg_t) hint_addr, (reg_t) size, (reg_t) perm, (reg_t) flags, (reg_t) fd, (reg_t) offset);
}
 
should_inline pid_t syscall_wait_for_process(pid_t pid, u32 *exit_code, u32 flags)
{
    return (pid_t) platform_syscall3(SYSCALL_wait_for_process, (reg_t) pid, (reg_t) exit_code, (reg_t) flags);
}
 
should_inline bool syscall_munmap(void *addr, size_t size)
{
    return (bool) platform_syscall2(SYSCALL_munmap, (reg_t) addr, (reg_t) size);
}
 
should_inline long syscall_vfs_chdirat(fd_t dirfd, const char *path)
{
    return (long) platform_syscall2(SYSCALL_vfs_chdirat, (reg_t) dirfd, (reg_t) path);
}
 
should_inline ssize_t syscall_vfs_getcwd(char *buf, size_t buf_size)
{
    return (ssize_t) platform_syscall2(SYSCALL_vfs_getcwd, (reg_t) buf, (reg_t) buf_size);
}
 
should_inline off_t syscall_io_seek(fd_t fd, off_t offset, io_seek_whence_t whence)
{
    return (off_t) platform_syscall3(SYSCALL_io_seek, (reg_t) fd, (reg_t) offset, (reg_t) whence);
}
 
should_inline off_t syscall_io_tell(fd_t fd)
{
    return (off_t) platform_syscall1(SYSCALL_io_tell, (reg_t) fd);
}
 
should_inline bool syscall_signal_register(signal_t signum, const sigaction_t *action)
{
    return (bool) platform_syscall2(SYSCALL_signal_register, (reg_t) signum, (reg_t) action);
}
 
should_inline long syscall_signal_process(pid_t pid, signal_t signum)
{
    return (long) platform_syscall2(SYSCALL_signal_process, (reg_t) pid, (reg_t) signum);
}
 
should_inline long syscall_signal_thread(tid_t tid, signal_t signum)
{
    return (long) platform_syscall2(SYSCALL_signal_thread, (reg_t) tid, (reg_t) signum);
}
 
should_inline void syscall_poweroff(bool reboot, u32 magic)
{
    platform_syscall2(SYSCALL_poweroff, (reg_t) reboot, (reg_t) magic);
}
 
should_inline __attribute__((__noreturn__)) void syscall_signal_return(void *sp)
{
    platform_syscall1(SYSCALL_signal_return, (reg_t) sp);
    __builtin_unreachable();
}
 
should_inline bool syscall_vm_protect(void *addr, size_t size, mem_perm_t perm)
{
    return (bool) platform_syscall3(SYSCALL_vm_protect, (reg_t) addr, (reg_t) size, (reg_t) perm);
}
 
should_inline int syscall_io_poll(struct pollfd *fds, nfds_t nfds, int timeout)
{
    return (int) platform_syscall3(SYSCALL_io_poll, (reg_t) fds, (reg_t) nfds, (reg_t) timeout);
}
 
should_inline int syscall_io_pselect(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, const struct timespec *timeout, const sigset_t *sigmask)
{
    return (int) platform_syscall6(SYSCALL_io_pselect, (reg_t) nfds, (reg_t) readfds, (reg_t) writefds, (reg_t) exceptfds, (reg_t) timeout, (reg_t) sigmask);
}
 
should_inline long syscall_execveat(fd_t dirfd, const char *file_path, const char *const *argv, const char *const *envp, u32 flags)
{
    return (long) platform_syscall5(SYSCALL_execveat, (reg_t) dirfd, (reg_t) file_path, (reg_t) argv, (reg_t) envp, (reg_t) flags);
}
 
should_inline long syscall_clock_msleep(u64 ms)
{
    return (long) platform_syscall1(SYSCALL_clock_msleep, (reg_t) ms);
}
 
should_inline fd_t syscall_io_dup(fd_t fd)
{
    return (fd_t) platform_syscall1(SYSCALL_io_dup, (reg_t) fd);
}
 
should_inline fd_t syscall_io_dup2(fd_t old_fd, fd_t new_fd)
{
    return (fd_t) platform_syscall2(SYSCALL_io_dup2, (reg_t) old_fd, (reg_t) new_fd);
}
 
should_inline bool syscall_dmabuf_alloc(size_t n_pages, ptr_t *out_paddr, ptr_t *out_vaddr)
{
    return (bool) platform_syscall3(SYSCALL_dmabuf_alloc, (reg_t) n_pages, (reg_t) out_paddr, (reg_t) out_vaddr);
}
 
should_inline bool syscall_dmabuf_free(ptr_t vaddr, ptr_t paddr)
{
    return (bool) platform_syscall2(SYSCALL_dmabuf_free, (reg_t) vaddr, (reg_t) paddr);
}
 
should_inline bool syscall_dmabuf_share(void *buf, size_t bufsize, ptr_t *out_paddr)
{
    return (bool) platform_syscall3(SYSCALL_dmabuf_share, (reg_t) buf, (reg_t) bufsize, (reg_t) out_paddr);
}
 
should_inline bool syscall_dmabuf_unshare(ptr_t paddr, size_t size, void *vaddr)
{
    return (bool) platform_syscall3(SYSCALL_dmabuf_unshare, (reg_t) paddr, (reg_t) size, (reg_t) vaddr);
}
 
should_inline long syscall_pipe(fd_t *out_read_fd, fd_t *out_write_fd, fd_flags_t flags)
{
    return (long) platform_syscall3(SYSCALL_pipe, (reg_t) out_read_fd, (reg_t) out_write_fd, (reg_t) flags);
}
 
should_inline ssize_t syscall_io_readv(fd_t fd, const struct iovec *iov, int iov_count)
{
    return (ssize_t) platform_syscall3(SYSCALL_io_readv, (reg_t) fd, (reg_t) iov, (reg_t) iov_count);
}
 
should_inline long syscall_vfs_unmount(const char *mount_point)
{
    return (long) platform_syscall1(SYSCALL_vfs_unmount, (reg_t) mount_point);
}
 
should_inline long syscall_clock_gettimeofday(struct timespec *tv)
{
    return (long) platform_syscall1(SYSCALL_clock_gettimeofday, (reg_t) tv);
}
 
should_inline long syscall_thread_setname(tid_t tid, const char *name)
{
    return (long) platform_syscall2(SYSCALL_thread_setname, (reg_t) tid, (reg_t) name);
}
 
should_inline ssize_t syscall_thread_getname(tid_t tid, char *buf, size_t buf_size)
{
    return (ssize_t) platform_syscall3(SYSCALL_thread_getname, (reg_t) tid, (reg_t) buf, (reg_t) buf_size);
}
 
should_inline long syscall_vfs_fchmodat(fd_t dirfd, const char *path, int mode, int flags)
{
    return (long) platform_syscall4(SYSCALL_vfs_fchmodat, (reg_t) dirfd, (reg_t) path, (reg_t) mode, (reg_t) flags);
}
 
should_inline long syscall_io_pread(fd_t fd, void *buf, size_t count, off_t offset)
{
    return (long) platform_syscall4(SYSCALL_io_pread, (reg_t) fd, (reg_t) buf, (reg_t) count, (reg_t) offset);
}
 
should_inline fd_t syscall_memfd_create(const char *name, u32 flags)
{
    return (fd_t) platform_syscall2(SYSCALL_memfd_create, (reg_t) name, (reg_t) flags);
}
 
should_inline long syscall_signal_mask_op(int how, const sigset_t *set, sigset_t *oldset)
{
    return (long) platform_syscall3(SYSCALL_signal_mask_op, (reg_t) how, (reg_t) set, (reg_t) oldset);
}
 
should_inline long syscall_vfs_fsync(fd_t fd, bool data_only)
{
    return (long) platform_syscall2(SYSCALL_vfs_fsync, (reg_t) fd, (reg_t) data_only);
}