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