Kernel/syscalls.c

   1 /*
   2  * AcessOS Microkernel Version
   3  * syscalls.c
   4  */
   5 #define DEBUG   0
   6
   7 #include <common.h>
   8 #include <syscalls.h>
   9 #include <proc.h>
  10 #include <errno.h>
  11
  12 // === IMPORTS ===
  13 extern int      Proc_Clone(Uint *Err, Uint Flags);
  14 extern int      Threads_WaitTID(int TID, int *status);
  15 extern Uint     Proc_SendMessage(Uint *Err, Uint Dest, Uint Length, void *Data);
  16 extern int      Proc_GetMessage(Uint *Err, Uint *Source, void *Buffer);
  17 extern int      Proc_Execve(char *File, char **ArgV, char **EnvP);
  18 extern Uint     Binary_Load(char *file, Uint *entryPoint);
  19 extern int      VFS_FInfo(int FD, void *Dest, int MaxACLs);
  20 extern int      VFS_GetACL(int FD, void *Dest);
  21 extern int      VFS_ChDir(char *Dest);
  22 extern int      Threads_SetName(char *NewName);
  23 extern int      Threads_GetPID();
  24 extern int      Threads_GetTID();
  25 extern int      Threads_GetUID();
  26 extern int      Threads_GetGID();
  27
  28 // === PROTOTYPES ===
  29  int    Syscall_ValidString(Uint Addr);
  30  int    Syscall_Valid(int Size, Uint Addr);
  31
  32 // === CODE ===
  33 // TODO: Do sanity checking on arguments, ATM the user can really fuck with the kernel
  34 void SyscallHandler(tSyscallRegs *Regs)
  35 {
  36         Uint64  ret = 0;
  37         Uint    err = 0;
  38         #if DEBUG
  39         ENTER("iThread iNum", Threads_GetTID(), Regs->Num);
  40         if(Regs->Num < NUM_SYSCALLS)
  41                 LOG("Syscall %s", cSYSCALL_NAMES[Regs->Num]);
  42         LOG("Arg1: 0x%x, Arg2: 0x%x, Arg3: 0x%x", Regs->Arg1, Regs->Arg2, Regs->Arg3);
  43         #endif
  44
  45         switch(Regs->Num)
  46         {
  47         // -- Exit the current thread
  48         case SYS_EXIT:  Threads_Exit(); break;
  49
  50         // -- Put the current thread to sleep
  51         case SYS_SLEEP: Threads_Sleep();        break;
  52
  53         // -- Yield current timeslice
  54         case SYS_YIELD: Threads_Yield();        break;
  55
  56         // -- Clone the current thread
  57         case SYS_CLONE:
  58                 // Call clone system call
  59                 ret = Proc_Clone(&err, Regs->Arg1);
  60                 Log("ret = %i");
  61                 // Change user stack if requested
  62                 if(ret == 0 && !(Regs->Arg1 & CLONE_VM))
  63                         Regs->StackPointer = Regs->Arg2;
  64                 break;
  65
  66         // -- Send a signal
  67         case SYS_KILL:
  68                 err = -ENOSYS;
  69                 ret = -1;
  70                 break;
  71
  72         // -- Wait for a thread
  73         case SYS_WAITTID:
  74                 ret = Threads_WaitTID(Regs->Arg1, (void*)Regs->Arg2);
  75                 break;
  76
  77         // -- Get the physical address of a page
  78         case SYS_GETPHYS:
  79                 ret = MM_GetPhysAddr(Regs->Arg1);
  80                 break;
  81
  82         // -- Map an address
  83         case SYS_MAP:   MM_Map(Regs->Arg1, Regs->Arg2); break;
  84
  85         // -- Allocate an address
  86         case SYS_ALLOCATE:      ret = MM_Allocate(Regs->Arg1);  break;
  87
  88         // -- Unmap an address
  89         case SYS_UNMAP:         MM_Deallocate(Regs->Arg1);      break;
  90
  91         // -- Get Thread/Process IDs
  92         case SYS_GETTID:        ret = Threads_GetTID(); break;
  93         case SYS_GETPID:        ret = Threads_GetPID(); break;
  94
  95         // -- Get User/Group IDs
  96         case SYS_GETUID:        ret = Threads_GetUID(); break;
  97         case SYS_GETGID:        ret = Threads_GetGID(); break;
  98
  99         // -- Send Message
 100         case SYS_SENDMSG:
 101                 ret = Proc_SendMessage(&err, Regs->Arg1, Regs->Arg2, (void*)Regs->Arg3);
 102                 break;
 103         // -- Check for messages
 104         case SYS_GETMSG:
 105                 ret = Proc_GetMessage(&err, (Uint*)Regs->Arg1, (void*)Regs->Arg2);
 106                 break;
 107
 108         // -- Set the thread's name
 109         case SYS_SETNAME:
 110                 // Sanity Check
 111                 if(!Regs->Arg1) {       ret = -1;       err = -EINVAL;  break;  }
 112                 Threads_SetName( (void*)Regs->Arg1 );
 113                 break;
 114
 115         // ---
 116         // Binary Control
 117         // ---
 118         case SYS_EXECVE:
 119                 ret = Proc_Execve((char*)Regs->Arg1, (char**)Regs->Arg2, (char**)Regs->Arg3);
 120                 break;
 121         case SYS_LOADBIN:
 122                 ret = Binary_Load((char*)Regs->Arg1, (Uint*)Regs->Arg2);
 123                 break;
 124
 125         // ---
 126         // Virtual Filesystem
 127         // ---
 128         case SYS_OPEN:
 129                 ret = VFS_Open((char*)Regs->Arg1, Regs->Arg2 | VFS_OPENFLAG_USER);
 130                 break;
 131
 132         case SYS_CLOSE:
 133                 VFS_Close( Regs->Arg1 );
 134                 break;
 135
 136         case SYS_WRITE:
 137                 #if BITS < 64
 138                 VFS_Write( Regs->Arg1, Regs->Arg2|((Uint64)Regs->Arg3<<32), (void*)Regs->Arg4 );
 139                 #else
 140                 VFS_Write( Regs->Arg1, Regs->Arg2, (void*)Regs->Arg3 );
 141                 #endif
 142                 break;
 143
 144         case SYS_READ:
 145                 #if BITS < 64
 146                 VFS_Read( Regs->Arg1, Regs->Arg2|((Uint64)Regs->Arg3<<32), (void*)Regs->Arg4 );
 147                 #else
 148                 VFS_Read( Regs->Arg1, Regs->Arg2, (void*)Regs->Arg3 );
 149                 #endif
 150                 break;
 151
 152         case SYS_FINFO:
 153                 ret = VFS_FInfo( Regs->Arg1, (void*)Regs->Arg2, Regs->Arg3 );
 154                 break;
 155
 156         // Get ACL Value
 157         case SYS_GETACL:
 158                 if( !Syscall_Valid(8, Regs->Arg1) ) {
 159                         err = -EINVAL;
 160                         ret = -1;
 161                         break;
 162                 }
 163                 ret = VFS_GetACL( Regs->Arg1, (void*)Regs->Arg2 );
 164                 break;
 165
 166         // Read Directory
 167         case SYS_READDIR:
 168                 if( !Syscall_ValidString(Regs->Arg2) ) {
 169                         err = -EINVAL;
 170                         ret = -1;
 171                         break;
 172                 }
 173                 ret = VFS_ReadDir( Regs->Arg1, (void*)Regs->Arg2 );
 174                 break;
 175
 176         // Change Directory
 177         case SYS_CHDIR:
 178                 if( !Syscall_ValidString(Regs->Arg1) ) {
 179                         err = -EINVAL;
 180                         ret = -1;
 181                         break;
 182                 }
 183                 ret = VFS_ChDir( (void*)Regs->Arg1 );
 184                 break;
 185
 186         // -- Debug
 187         case SYS_DEBUG:
 188                 Log((char*)Regs->Arg1,
 189                         Regs->Arg2, Regs->Arg3, Regs->Arg4, Regs->Arg5, Regs->Arg6);
 190                 break;
 191
 192         // -- Default (Return Error)
 193         default:
 194                 Warning("SyscallHandler: Unknown System Call %i", Regs->Num);
 195                 if(Regs->Num < NUM_SYSCALLS)
 196                         Warning(" Syscall '%s'", cSYSCALL_NAMES[Regs->Num]);
 197                 err = -ENOSYS;
 198                 ret = -1;
 199                 break;
 200         }
 201         #if BITS < 64
 202         Regs->Return = ret&0xFFFFFFFF;
 203         Regs->RetHi = ret >> 32;
 204         #else
 205         Regs->Return = ret;
 206         #endif
 207         Regs->Error = err;
 208         #if DEBUG
 209         LOG("SyscallHandler: err = %i", err);
 210         LEAVE('x', ret);
 211         #endif
 212 }
 213
 214 /**
 215  * \fn int Syscall_ValidString(Uint Addr)
 216  * \brief Checks if a memory address contains a valid string
 217  */
 218 int Syscall_ValidString(Uint Addr)
 219 {
 220         // Check 1st page
 221         if(!MM_GetPhysAddr(Addr))       return 0;
 222
 223         // Traverse String
 224         while(*(char*)Addr)
 225         {
 226                 if(!MM_GetPhysAddr(Addr))       return 0;
 227                 // Increment string pointer
 228                 Addr ++;
 229         }
 230
 231         return 1;
 232 }
 233
 234 /**
 235  * \fn int Syscall_Valid(int Size, Uint Addr)
 236  * \brief Checks if a memory address is valid
 237  */
 238 int Syscall_Valid(int Size, Uint Addr)
 239 {
 240         while(Size--)
 241         {
 242                 if(!MM_GetPhysAddr(Addr))       return 0;
 243                 Addr ++;
 244         }
 245         return 1;
 246 }