Kernel/syscalls.c

   1 /*
   2  * AcessOS Microkernel Version
   3  * syscalls.c
   4  */
   5 #define DEBUG   0
   6
   7 #include <acess.h>
   8 #include <syscalls.h>
   9 #include <proc.h>
  10 #include <errno.h>
  11
  12 #define CHECK_NUM_NULLOK(v,size)        \
  13         if((v)&&!Syscall_Valid((size),(Uint)(v))){ret=-1;err=-EINVAL;break;}
  14 #define CHECK_STR_NULLOK(v)     \
  15         if((v)&&!Syscall_ValidString((Uint)(v))){ret=-1;err=-EINVAL;break;}
  16 #define CHECK_NUM_NONULL(v,size)        \
  17         if(!(v)||!Syscall_Valid((size),(Uint)(v))){ret=-1;err=-EINVAL;break;}
  18 #define CHECK_STR_NONULL(v)     \
  19         if(!(v)||!Syscall_ValidString((Uint)(v))){ret=-1;err=-EINVAL;break;}
  20
  21 // === IMPORTS ===
  22 extern int      Proc_Clone(Uint *Err, Uint Flags);
  23 extern int      Threads_WaitTID(int TID, int *status);
  24 extern Uint     Proc_SendMessage(Uint *Err, Uint Dest, Uint Length, void *Data);
  25 extern int      Proc_GetMessage(Uint *Err, Uint *Source, void *Buffer);
  26 extern int      Proc_Execve(char *File, char **ArgV, char **EnvP);
  27 extern Uint     Binary_Load(char *file, Uint *entryPoint);
  28 extern int      Threads_SetName(char *NewName);
  29 extern int      Threads_GetPID();
  30 extern int      Threads_GetTID();
  31 extern tUID     Threads_GetUID();
  32 extern int      Threads_SetUID(Uint *errno, tUID ID);
  33 extern tGID     Threads_GetGID();
  34 extern int      Threads_SetGID(Uint *errno, tGID ID);
  35 extern int      Threads_SetFaultHandler(Uint Handler);
  36
  37 // === PROTOTYPES ===
  38  int    Syscall_ValidString(Uint Addr);
  39  int    Syscall_Valid(int Size, Uint Addr);
  40
  41 // === CODE ===
  42 // TODO: Do sanity checking on arguments, ATM the user can really fuck with the kernel
  43 void SyscallHandler(tSyscallRegs *Regs)
  44 {
  45         Uint64  ret = 0;
  46         Uint    err = -EOK;
  47
  48         ENTER("iThread iNum", Threads_GetTID(), Regs->Num);
  49         if(Regs->Num < NUM_SYSCALLS)
  50                 LOG("Syscall %s", cSYSCALL_NAMES[Regs->Num]);
  51         LOG("Arg1: 0x%x, Arg2: 0x%x, Arg3: 0x%x, Arg4: 0x%x", Regs->Arg1, Regs->Arg2, Regs->Arg3, Regs->Arg4);
  52
  53         switch(Regs->Num)
  54         {
  55         // -- Exit the current thread
  56         case SYS_EXIT:  Threads_Exit(0, Regs->Arg1);    break;
  57
  58         // -- Put the current thread to sleep
  59         case SYS_SLEEP: Threads_Sleep();        break;
  60
  61         // -- Yield current timeslice
  62         case SYS_YIELD: Threads_Yield();        break;
  63
  64         // -- Set Error Handler
  65         case SYS_SETFAULTHANDLER:
  66                 Threads_SetFaultHandler(Regs->Arg1);
  67                 break;
  68
  69         // -- Clone the current thread
  70         case SYS_CLONE:
  71                 // Call clone system call
  72                 ret = Proc_Clone(&err, Regs->Arg1);
  73                 // Change user stack if a new stack address is passed
  74                 if(ret == 0 && Regs->Arg2)
  75                         Regs->StackPointer = Regs->Arg2;
  76                 break;
  77
  78         // -- Send a signal
  79         case SYS_KILL:
  80                 err = -ENOSYS;
  81                 ret = -1;
  82                 break;
  83
  84         // -- Wait for a thread
  85         case SYS_WAITTID:
  86                 // Sanity Check (Status can be NULL)
  87                 CHECK_NUM_NULLOK( Regs->Arg2, sizeof(int) );
  88                 // TID, *Status
  89                 ret = Threads_WaitTID(Regs->Arg1, (void*)Regs->Arg2);
  90                 break;
  91
  92         // -- Get the physical address of a page
  93         case SYS_GETPHYS:
  94                 ret = MM_GetPhysAddr(Regs->Arg1);
  95                 break;
  96
  97         // -- Map an address
  98         case SYS_MAP:   MM_Map(Regs->Arg1, Regs->Arg2); break;
  99
 100         // -- Allocate an address
 101         case SYS_ALLOCATE:      ret = MM_Allocate(Regs->Arg1);  break;
 102
 103         // -- Unmap an address
 104         case SYS_UNMAP:         MM_Deallocate(Regs->Arg1);      break;
 105
 106         // -- Get Thread/Process IDs
 107         case SYS_GETTID:        ret = Threads_GetTID(); break;
 108         case SYS_GETPID:        ret = Threads_GetPID(); break;
 109
 110         // -- Get User/Group IDs
 111         case SYS_GETUID:        ret = Threads_GetUID(); break;
 112         case SYS_GETGID:        ret = Threads_GetGID(); break;
 113
 114         // -- Set User/Group IDs
 115         case SYS_SETUID:        ret = Threads_SetUID(&err, Regs->Arg1); break;
 116         case SYS_SETGID:        ret = Threads_SetGID(&err, Regs->Arg1); break;
 117
 118         // -- Send Message
 119         case SYS_SENDMSG:
 120                 CHECK_NUM_NONULL(Regs->Arg3, Regs->Arg2);
 121                 // Destination, Size, *Data
 122                 ret = Proc_SendMessage(&err, Regs->Arg1, Regs->Arg2, (void*)Regs->Arg3);
 123                 break;
 124         // -- Check for messages
 125         case SYS_GETMSG:
 126                 CHECK_NUM_NULLOK(Regs->Arg1, sizeof(Uint));
 127                 if( Regs->Arg2 && Regs->Arg2 != -1 && !MM_IsUser(Regs->Arg2) )
 128                 {
 129                         err = -EINVAL;  ret = -1;       break;
 130                 }
 131                 // *Source, *Data
 132                 ret = Proc_GetMessage(&err, (Uint*)Regs->Arg1, (void*)Regs->Arg2);
 133                 break;
 134
 135         // -- Set the thread's name
 136         case SYS_SETNAME:
 137                 CHECK_STR_NONULL(Regs->Arg1);
 138                 Threads_SetName( (char*)Regs->Arg1 );
 139                 break;
 140
 141         // ---
 142         // Binary Control
 143         // ---
 144         case SYS_EXECVE:
 145                 CHECK_STR_NONULL(Regs->Arg1);
 146                 //Log(" Regs = {Arg2: %x, Arg3: %x}", Regs->Arg2, Regs->Arg3);
 147                 {
 148                          int    i;
 149                         char    **tmp = (char**)Regs->Arg2;
 150                         // Check ArgV (traverse array checking all string pointers)
 151                         CHECK_NUM_NONULL( tmp, sizeof(char**) );
 152                         //Log("tmp = %p", tmp);
 153                         for(i=0;tmp[i];i++) {
 154                                 CHECK_NUM_NONULL( &tmp[i], sizeof(char*) );
 155                                 CHECK_STR_NONULL( tmp[i] );
 156                         }
 157                         // Check EnvP also
 158                         // - EnvP can be NULL
 159                         if( Regs->Arg3 )
 160                         {
 161                                 tmp = (char**)Regs->Arg3;
 162                                 //Log("tmp = %p", tmp);
 163                                 for(i=0;tmp[i];i++) {
 164                                         CHECK_NUM_NULLOK( &tmp[i], sizeof(char*) );
 165                                         CHECK_STR_NONULL( tmp[i] );
 166                                 }
 167                         }
 168                 }
 169                 LEAVE('s', "Assuming 0");
 170                 // Path, **Argv, **Envp
 171                 ret = Proc_Execve((char*)Regs->Arg1, (char**)Regs->Arg2, (char**)Regs->Arg3);
 172                 break;
 173         case SYS_LOADBIN:
 174                 if( !Syscall_ValidString(Regs->Arg1)
 175                 ||  !Syscall_Valid(sizeof(Uint), Regs->Arg2) ) {
 176                         err = -EINVAL;
 177                         ret = 0;
 178                         break;
 179                 }
 180                 // Path, *Entrypoint
 181                 ret = Binary_Load((char*)Regs->Arg1, (Uint*)Regs->Arg2);
 182                 break;
 183
 184         // ---
 185         // Virtual Filesystem
 186         // ---
 187         case SYS_OPEN:
 188                 if( !Syscall_ValidString(Regs->Arg1) ) {
 189                         err = -EINVAL;
 190                         ret = -1;
 191                         break;
 192                 }
 193                 ret = VFS_Open((char*)Regs->Arg1, Regs->Arg2 | VFS_OPENFLAG_USER);
 194                 break;
 195
 196         case SYS_CLOSE:
 197                 VFS_Close( Regs->Arg1 );
 198                 break;
 199
 200         case SYS_SEEK:
 201                 #if BITS == 64
 202                 ret = VFS_Seek( Regs->Arg1, Regs->Arg2, Regs->Arg3 );
 203                 #else
 204                 ret = VFS_Seek( Regs->Arg1, Regs->Arg2|(((Uint64)Regs->Arg3)<<32), Regs->Arg4 );
 205                 #endif
 206                 break;
 207
 208         case SYS_TELL:
 209                 ret = VFS_Tell( Regs->Arg1 );
 210                 break;
 211
 212         case SYS_WRITE:
 213                 CHECK_NUM_NONULL( Regs->Arg3, Regs->Arg2 );
 214                 ret = VFS_Write( Regs->Arg1, Regs->Arg2, (void*)Regs->Arg3 );
 215                 break;
 216
 217         case SYS_READ:
 218                 CHECK_NUM_NONULL( Regs->Arg3, Regs->Arg2 );
 219                 ret = VFS_Read( Regs->Arg1, Regs->Arg2, (void*)Regs->Arg3 );
 220                 break;
 221
 222         case SYS_FINFO:
 223                 CHECK_NUM_NONULL( Regs->Arg2, sizeof(tFInfo) + Regs->Arg3*sizeof(tVFS_ACL) );
 224                 // FP, Dest, MaxACLs
 225                 ret = VFS_FInfo( Regs->Arg1, (void*)Regs->Arg2, Regs->Arg3 );
 226                 break;
 227
 228         // Get ACL Value
 229         case SYS_GETACL:
 230                 if( !Syscall_Valid(sizeof(tVFS_ACL), Regs->Arg1) ) {
 231                         err = -EINVAL;
 232                         ret = -1;
 233                         break;
 234                 }
 235                 ret = VFS_GetACL( Regs->Arg1, (void*)Regs->Arg2 );
 236                 break;
 237
 238         // Read Directory
 239         case SYS_READDIR:
 240                 if( !Syscall_Valid(8, Regs->Arg2) ) {
 241                         err = -EINVAL;
 242                         ret = -1;
 243                         break;
 244                 }
 245                 ret = VFS_ReadDir( Regs->Arg1, (void*)Regs->Arg2 );
 246                 break;
 247
 248         // Open a file that is a entry in an open directory
 249         case SYS_OPENCHILD:
 250                 if( !Syscall_ValidString(Regs->Arg2) ) {
 251                         err = -EINVAL;
 252                         ret = -1;
 253                         break;
 254                 }
 255                 ret = VFS_OpenChild( &err, Regs->Arg1, (char*)Regs->Arg2, Regs->Arg3);
 256                 break;
 257
 258         // Change Directory
 259         case SYS_CHDIR:
 260                 if( !Syscall_ValidString(Regs->Arg1) ) {
 261                         err = -EINVAL;
 262                         ret = -1;
 263                         break;
 264                 }
 265                 ret = VFS_ChDir( (void*)Regs->Arg1 );
 266                 break;
 267
 268         // IO Control
 269         case SYS_IOCTL:
 270                 // All sanity checking should be done by the driver
 271                 ret = VFS_IOCtl( Regs->Arg1, Regs->Arg2, (void*)Regs->Arg3 );
 272                 break;
 273
 274         // Mount a filesystem
 275         case SYS_MOUNT:
 276                 // Only root can mount filesystems
 277                 if(Threads_GetUID() != 0) {
 278                         err = -EACCES;
 279                         ret = -1;
 280                         break;
 281                 }
 282                 // Sanity check the paths
 283                 if(!Syscall_ValidString(Regs->Arg1)
 284                 || !Syscall_ValidString(Regs->Arg2)
 285                 || !Syscall_ValidString(Regs->Arg3)
 286                 || !Syscall_ValidString(Regs->Arg4) ) {
 287                         err = -EINVAL;
 288                         ret = -1;
 289                         break;
 290                 }
 291                 ret = VFS_Mount(
 292                         (char*)Regs->Arg1,      // Device
 293                         (char*)Regs->Arg2,      // Mount point
 294                         (char*)Regs->Arg3,      // Filesystem
 295                         (char*)Regs->Arg4       // Options
 296                         );
 297                 break;
 298
 299         // -- Debug
 300         //#if DEBUG_BUILD
 301         case SYS_DEBUG:
 302                 Log((char*)Regs->Arg1,
 303                         Regs->Arg2, Regs->Arg3, Regs->Arg4, Regs->Arg5, Regs->Arg6);
 304                 break;
 305         //#endif
 306
 307         // -- Default (Return Error)
 308         default:
 309                 Warning("SyscallHandler: Unknown System Call %i", Regs->Num);
 310                 if(Regs->Num < NUM_SYSCALLS)
 311                         Warning(" Syscall '%s'", cSYSCALL_NAMES[Regs->Num]);
 312                 err = -ENOSYS;
 313                 ret = -1;
 314                 break;
 315         }
 316
 317         if(err != 0) {
 318                 LOG("ID: %i, Return errno = %i", Regs->Num, err);
 319         }
 320
 321         #if BITS < 64
 322         Regs->Return = ret&0xFFFFFFFF;
 323         Regs->RetHi = ret >> 32;
 324         #else
 325         Regs->Return = ret;
 326         #endif
 327         Regs->Error = err;
 328         #if DEBUG
 329         LOG("err = %i", err);
 330         if(Regs->Num != SYS_EXECVE)
 331                 LEAVE('x', ret);
 332         else
 333                 LOG("Actual %i", ret);
 334         #endif
 335 }
 336
 337 /**
 338  * \fn int Syscall_ValidString(Uint Addr)
 339  * \brief Checks if a memory address contains a valid string
 340  */
 341 int Syscall_ValidString(Uint Addr)
 342 {
 343         // Check if the memory is user memory
 344         if(!MM_IsUser(Addr))    return 0;
 345
 346         return CheckString( (char*)Addr );
 347 }
 348
 349 /**
 350  * \fn int Syscall_Valid(int Size, Uint Addr)
 351  * \brief Checks if a memory address is valid
 352  */
 353 int Syscall_Valid(int Size, Uint Addr)
 354 {
 355         if(!MM_IsUser(Addr))    return 0;
 356
 357         return CheckMem( (void*)Addr, Size );
 358 }