path: root/interface/syscalls.c

#include "syscalls.h"

#include <stdint.h>
#include <stdio.h>
#include <string.h>

#include <sys/time.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/termios.h>

#include <errno.h>

// BASICS //

// everybody is root
uid_t getuid(void)
{
    return 0;
}

// everybody is root
uid_t getgid(void)
{
    return 0;
}

// no sync needed for our ram-image so far (DMA?)
void sync(void)
{
}

// set working directory - we simply save this in PWD environment var
int chdir(const char *path)
{
        sprintf(buf,"PWD=%s",path);
        putenv(buf);
        return 0; // assume success
}

// get working dir (see chdir)
char* getwd(char *buf)
{
        return getenv("PWD");
}

// C NEWLIB // 

// first of all we have a few posix syscalls required by newlib 
// (we use version newlib-3.0.0.20180802)
// https://sourceware.org/newlib/libc.html#Syscalls
// just check liunx man-pages, how they SHOULD work.

// holds environment variables
extern char **environ;

// terminate caller
void _exit(int status)
{
    return syscall(SYSCALL_EXIT,status,0,0);
}

// close file
int _close(int file) 
{
    return syscall(SYSCALL_CLOSE,file,0,0);
}
int close(int file) 
{
    return syscall(SYSCALL_CLOSE,file,0,0);
}

// execute programm
int _execve(const char *filename, char *const argv[], char *const envp[]) 
{
    return syscall(SYSCALL_EXECVE,filename,argv,envp);
}
int execve(const char *filename, char *const argv[], char *const envp[]) 
{
    return syscall(SYSCALL_EXECVE,filename,argv,envp);
}

// create a child process
pid_t _fork(void)
{
    return syscall(SYSCALL_FORK,0,0,0);
}
pid_t fork(void)
{
    return syscall(SYSCALL_FORK,0,0,0);
}

int _fstat(int file, struct stat *st)
{
    return syscall(SYSCALL_FSTAT,file,st,0);
}
int fstat(int file, struct stat *st)
{
    return syscall(SYSCALL_FSTAT,file,st,0);
}

int _getpid(void)
{
    return syscall(SYSCALL_GETPID,0,0,0);
}
int getpid(void)
{
    return syscall(SYSCALL_GETPID,0,0,0);
}

int _isatty(int file) 
{
    return syscall(SYSCALL_ISATTY,file,0,0);
}
int isatty(int file) 
{
    return syscall(SYSCALL_ISATTY,file,0,0);
}

int _kill(int pid, int sig)
{
    return syscall(SYSCALL_KILL,pid,sig,0);
}
int kill(int pid, int sig)
{
    return syscall(SYSCALL_KILL,pid,sig,0);
}

int _link(char *old, char *ne)
{
    return syscall(SYSCALL_LINK,old,ne,0);
}
int link(char *old, char *ne)
{
    return syscall(SYSCALL_LINK,old,ne,0);
}

int _lseek(int file, int ptr, int dir) 
{
    return syscall(SYSCALL_LSEEK,file,ptr,dir);
}
int lseek(int file, int ptr, int dir) 
{
    return syscall(SYSCALL_LSEEK,file,ptr,dir);
}

int _open(const char *name, int flags, int mode)
{
    return syscall(SYSCALL_OPEN,name,flags,mode);
}
int open(const char *name, int flags, int mode)
{
    return syscall(SYSCALL_OPEN,name,flags,mode);
}

int _read(int file, char *ptr, int len)
{
    return syscall(SYSCALL_READ,file,ptr,len);
}
int read(int file, char *ptr, int len)
{
    return syscall(SYSCALL_READ,file,ptr,len);
}

uint32_t _sbrk(int incr) 
{
    return syscall(SYSCALL_SBRK,incr,0,0);
}
uint32_t sbrk(int incr) 
{
    return syscall(SYSCALL_SBRK,incr,0,0);
}

int _stat(const char *file, struct stat *st)
{
    return syscall(SYSCALL_STAT,file,st,0);
}
int stat(const char *file, struct stat *st)
{
    return syscall(SYSCALL_STAT,file,st,0);
}

int _times(struct tms *buf)
{
    return syscall(SYSCALL_TIMES,buf,0,0);
}
int times(struct tms *buf)
{
    return syscall(SYSCALL_TIMES,buf,0,0);
}

int _unlink(char *name)
{
    return syscall(SYSCALL_UNLINK,name,0,0);
}
int unlink(char *name)
{
    return syscall(SYSCALL_UNLINK,name,0,0);
}

int _wait(int *status)
{
    return syscall(SYSCALL_WAIT,status,0,0);
}
int wait(int *status)
{
    return syscall(SYSCALL_WAIT,status,0,0);
}

int _write(int file, char *ptr, int len) 
{
    return syscall(SYSCALL_WRITE,file,ptr,len);
}
int write(int file, char *ptr, int len) 
{
    return syscall(SYSCALL_WRITE,file,ptr,len);
}

//////////////////////////////////////////////////////////////////////


int _readdir(const char *name,void *dirs,int max)
{
    return syscall(SYSCALL_READDIR,name,dirs,max);
}

int _poll(int file)
{
    return syscall(SYSCALL_POLL,file,0,0);
}

int _gettimeofday(struct timeval *tv, void *tz)
{
    return syscall(SYSCALL_GETTIMEOFDAY,tv,tz,0);
}

int _lstat(const char *file, struct stat *st)
{
    return syscall(SYSCALL_LSTAT,file,st,0);
}

// termios

        int tcgetattr(int fd, struct termios *termios_p)
        {
           return syscall(SYSCALL_TCGETATTR,fd,termios_p,0);
        }

        int tcsetattr(int fd, int optional_actions, const struct termios *termios_p)
        {
           return syscall(SYSCALL_TCSETATTR,fd,termios_p,0);
        }

/*

       int tcsendbreak(int fd, int duration);

       int tcdrain(int fd);


       int tcflow(int fd, int action);
*/

//       void cfmakeraw(struct termios *termios_p);

       /*
       speed_t cfgetispeed(const struct termios *termios_p);

       */

       speed_t cfgetospeed(const struct termios *termios_p)
       {
            syscall(SYSCALL_UNIMPLEMENTED,"cfgetospeed",0,0);
            return B230400;
       }

       long fpathconf(int fd, int name)
        {
            return syscall(SYSCALL_UNIMPLEMENTED,"fpathconf",0,0);
        }

       int tcflush(int fd, int queue_selector)
       {
            return syscall(SYSCALL_UNIMPLEMENTED,"tcflush",0,0);
       }

       /*
       int cfsetispeed(struct termios *termios_p, speed_t speed);

       int cfsetospeed(struct termios *termios_p, speed_t speed);

       int cfsetspeed(struct termios *termios_p, speed_t speed);
       */

////////////////////////////////////////// move along ///

    int access(const char *pathname, int mode)
    {
            return syscall(SYSCALL_UNIMPLEMENTED,"access",0,0);
    }

    #include <sys/types.h>
    #include <sys/stat.h>

    mode_t umask(mode_t mask)
    {
            return syscall(SYSCALL_UNIMPLEMENTED,"umask",0,0);
    }

    int mkdir(const char *pathname, mode_t mode)
    {
            return syscall(SYSCALL_UNIMPLEMENTED,"mkdir",0,0);
    }


    char *ttyname(int fd)
    {
            return syscall(SYSCALL_UNIMPLEMENTED,"ttyname",0,0);
    }

//

    struct void *readdir(DIR *dirp) // returns dirent
    {
            return syscall(SYSCALL_UNIMPLEMENTED,"readdir",0,0);
    }

    DIR *opendir(const char *name)
    {
            errno=EACCES;
            return syscall(SYSCALL_UNIMPLEMENTED,"opendir",name,0);
    }

    int closedir(DIR *dirp)
    {   
            return syscall(SYSCALL_UNIMPLEMENTED,"closedir",0,0);
    }
    

    unsigned int sleep(unsigned int seconds)
    {
            return syscall(SYSCALL_UNIMPLEMENTED,"sleep",0,0);
    }

    char *getlogin(void)
    {
            return syscall(SYSCALL_UNIMPLEMENTED,"getlogin",0,0);
    }


    /** 
     * Monitor multiple descriptors
     * ============================
     *
     * nfds is the MAX file descriptor number +1.
     *
     * It is possible to provide 3 different sets of filedescriptors 
     * (they can be NULL as well)
     *
     * - readfds        - reading   
     * - writefds       - writing
     * - exceptfds      - exceptions (all cleared unless exception occurs)
     *
     * The call returns the total number of descriptors contained in all
     * sets after returning.
     *
     * This call will block until time (timeout) runs out 
     * OR a file descriptor becomes ready.
     */

    int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout)
    {
            // pack all our sets togehter
            fd_set *fd_sets[3];

            fd_sets[0]=readfds;
            fd_sets[1]=writefds;
            fd_sets[2]=exceptfds;

            return syscall(SYSCALL_SELECT,nfds,timeout,fd_sets);
    }

    int pclose(FILE *stream)
    {
            return syscall(SYSCALL_UNIMPLEMENTED,"pclose",0,0);
    }

    FILE *popen(const char *command, const char *type)
    {
            return syscall(SYSCALL_UNIMPLEMENTED,"popen",0,0);
    }

    // call dup2 in dup emulation mode
    int dup(int oldfd)
    {
        return _dup2(oldfd,0xffffffff); // dup emulation mode
    }


int _clone(void)
{
    return syscall(SYSCALL_CLONE,0,0,0);
}
int _pipe(uint32_t fds[2])
{
    return syscall(SYSCALL_PIPE,fds,0,0);
}
int pipe(uint32_t fds[2])
{
    return syscall(SYSCALL_PIPE,fds,0,0);
}
int _dup2(uint32_t oldfd,uint32_t newfd)
{
    return syscall(SYSCALL_DUP2,oldfd,newfd,0);
}
int dup2(uint32_t oldfd,uint32_t newfd)
{
    return syscall(SYSCALL_DUP2,oldfd,newfd,0);
}
int _gui_rect()
{
    return syscall(SYSCALL_GUI_RECT,0,0,0);
}
int _gui_win()
{
    return syscall(SYSCALL_GUI_WIN,0,0,0);
}

int gethostname(char *name, size_t len)
{
    strcpy(name,"foolcomp"); 
    return 0; //success
}

ssize_t readlink(const char *pathname, char *buf, size_t bufsiz)
{
    return syscall(SYSCALL_UNIMPLEMENTED,"readlink",pathname,0);
}

int rmdir(const char *pathname)
{
    syscall(SYSCALL_UNIMPLEMENTED,"rmdir",0,0);
    return 0;
}

int fcntl(int fd, int cmd, ... /* arg */ )
{
    syscall(SYSCALL_UNIMPLEMENTED,"fcntl",0,0);
    return 0;
}

pid_t waitpid(pid_t pid, int *wstatus, int options)
{
    syscall(SYSCALL_UNIMPLEMENTED,"waitpid",0,0);
    return 0;
}

int execl(const char *path, const char *arg, ...)
{
    syscall(SYSCALL_UNIMPLEMENTED,"execl",0,0);
    return 0;
}

int execvp(const char *file, char *const argv[])
{
    syscall(SYSCALL_UNIMPLEMENTED,"execvp",0,0);
    return 0;
}

long sysconf(int name)
{
    return syscall(SYSCALL_UNIMPLEMENTED,"sysconf",name,0);
    return 0;
}

int chmod(const char *pathname, mode_t mode)
{
    syscall(SYSCALL_UNIMPLEMENTED,"chmod",0,0);
    return 0;
}

void _flushing()
{
    fflush(stdout);
}