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