system-syscalls.h

/*
 * Copyright (c) 2008-2014, Pedigree Developers
 *
 * Please see the CONTRIB file in the root of the source tree for a full
 * list of contributors.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
#ifndef SYSTEM_SYSCALLS_H
#define SYSTEM_SYSCALLS_H
 
#include "pedigree/kernel/processor/Processor.h"
#include "pedigree/kernel/processor/VirtualAddressSpace.h"
#include "pedigree/kernel/processor/state.h"
 
#include "logging.h"
#include "wait-syscalls.h"
#include <sys/types.h>
 
// Forward-declare types.
class File;
bool posix_exec_file_readable(File* file);
long posix_setfsuid(uid_t uid);
long posix_setfsgid(gid_t gid);
struct group;
struct LinuxKernelTimespec;
struct LinuxRlimit64;
struct LinuxRusage64;
struct passwd;
struct timespec;
 
uintptr_t posix_brk(uintptr_t theBreak);
long posix_sbrk(int delta);
SyscallState posix_copy_clone_state(const SyscallState& state);
long posix_clone(SyscallState& state, unsigned long flags, void* child_stack, int* ptid, int* ctid,
                 unsigned long newtls, bool linuxAbi = false, bool clearSignalHandlers = false);
int posix_fork(SyscallState& state);
int posix_vfork(SyscallState& state);
int posix_execve(const char* name, const char** argv, const char** env, SyscallState& state);
int posix_getpid();
int posix_getppid();
 
int posix_gettimeofday(timeval* tv, struct timezone* tz);
int posix_settimeofday(const timeval* tv, const struct timezone* tz);
time_t posix_time(time_t* tval);
clock_t posix_times(struct tms* tm);
int posix_getrusage(int who, struct rusage* r);
int posix_linux_getrusage(int who, LinuxRusage64* r);
ssize_t posix_getrandom(void* buffer, size_t length, unsigned int flags);
 
int posix_getpwent(passwd* pw, int n, char* str);
int posix_getpwnam(passwd* pw, const char* name, char* str);
uid_t posix_getuid();
gid_t posix_getgid();
uid_t posix_geteuid();
gid_t posix_getegid();
int posix_setuid(uid_t uid);
int posix_setgid(gid_t gid);
int posix_seteuid(uid_t euid);
int posix_setegid(gid_t egid);
 
size_t posix_alarm(uint32_t seconds);
int posix_sleep(uint32_t seconds);
int posix_usleep(size_t useconds);
int posix_nanosleep(const struct timespec* rqtp, struct timespec* rmtp, bool time32 = false);
int posix_clock_gettime(clockid_t clock_id, struct timespec* tp);
int posix_clock_settime(clockid_t clock_id, const LinuxKernelTimespec* tp);
int posix_clock_getres_native(clockid_t clock_id, struct timespec* resolution);
int posix_clock_getres(clockid_t clock_id, LinuxKernelTimespec* resolution);
int posix_clock_nanosleep(clockid_t clock_id, int flags, const LinuxKernelTimespec* request,
                          LinuxKernelTimespec* remainder);
 
int pedigree_sigret();
 
int posix_setsid();
int posix_setpgid(int pid, int pgid);
int posix_getpgrp();
int posix_getpgid(int pid);
 
mode_t posix_umask(mode_t mask);
 
int posix_getgrnam(const char* name, struct group* out);
int posix_getgrgid(gid_t id, struct group* out);
 
int posix_linux_syslog(int type, char* buf, int len);
int posix_syslog(const char* msg, int prio);
 
int pedigree_login(int uid);
 
int pedigree_reboot();
int posix_reboot(uint32_t magic1, uint32_t magic2, uint32_t command);
 
int posix_uname(struct utsname* n);
 
int posix_prctl(int option, uint64_t arg2, uint64_t arg3, uint64_t arg4, uint64_t arg5);
int posix_arch_prctl(int code, unsigned long addr);
 
int posix_pause();
 
int posix_setgroups(size_t size, const gid_t* list);
int posix_getgroups(size_t size, gid_t* list);
 
int posix_getrlimit(int resource, struct rlimit* rlim);
int posix_setrlimit(int resource, const struct rlimit* rlim);
int posix_prlimit64(int pid, int resource, const LinuxRlimit64* newLimit, LinuxRlimit64* oldLimit);
int posix_membarrier(int command, unsigned int flags, int cpuId);
int posix_getpriority(int which, int who, bool linuxAbi = false);
int posix_setpriority(int which, int who, int prio);
 
int posix_setreuid(uid_t ruid, uid_t euid);
int posix_setregid(gid_t rgid, gid_t egid);
 
int posix_setresuid(uid_t ruid, uid_t euid, uid_t suid);
int posix_setresgid(gid_t rgid, gid_t egid, gid_t sgid);
int posix_getresuid(uid_t* ruid, uid_t* euid, uid_t* suid);
int posix_getresgid(gid_t* rgid, gid_t* egid, gid_t* sgid);
 
int posix_get_robust_list(int pid, struct robust_list_head** head_ptr, size_t* len_ptr,
                          bool linuxAbi = false);
int posix_set_robust_list(struct robust_list_head* head, size_t len, bool linuxAbi = false);
 
int posix_ioperm(unsigned long from, unsigned long num, int turn_on);
int posix_iopl(int level);
 
int posix_getitimer(int which, struct itimerval* curr_value);
int posix_setitimer(int which, const struct itimerval* new_value, struct itimerval* old_value);
 
int posix_capget(void* hdrp, void* datap);
int posix_capset(void* hdrp, const void* datap);
 
#endif