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