Kernel/syscalls.c

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