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