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