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