KernelLand/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 <hal_proc.h>
  11 #include <errno.h>
  12 #include <threads.h>
  13 #include <events.h>
  14
  15 #define CHECK_NUM_NULLOK(v,size)        \
  16         if((v)&&!Syscall_Valid((size),(v))){LOG("CHECK_NUM_NULLOK: %p(%x) FAIL",v,size);ret=-1;err=-EINVAL;break;}
  17 #define CHECK_STR_NULLOK(v)     \
  18         if((v)&&!Syscall_ValidString((v))){LOG("CHECK_STR_NULLOK: %p FAIL",v);ret=-1;err=-EINVAL;break;}
  19 #define CHECK_NUM_NONULL(v,size)        \
  20         if(!(v)||!Syscall_Valid((size),(v))){LOG("CHECK_NUM_NONULL: %p(%x) FAIL",v,size);ret=-1;err=-EINVAL;break;}
  21 #define CHECK_STR_NONULL(v)     \
  22         if(!(v)||!Syscall_ValidString((v))){LOG("CHECK_STR_NONULL: %p FAIL",v);ret=-1;err=-EINVAL;break;}
  23 #define CHECK_STR_ARRAY(arr)    do {\
  24          int    i;\
  25         char    **tmp = (char**)arr; \
  26         CHECK_NUM_NONULL( tmp, sizeof(char**) ); \
  27         for(i=0;tmp[i];i++) { \
  28                 CHECK_STR_NONULL( tmp[i] ); \
  29                 CHECK_NUM_NONULL( &tmp[i+1], sizeof(char*) ); \
  30         }\
  31         if(tmp[i]) break;\
  32 } while(0)
  33
  34 // === IMPORTS ===
  35 extern Uint     Binary_Load(const char *file, Uint *entryPoint);
  36
  37 // === PROTOTYPES ===
  38 void    SyscallHandler(tSyscallRegs *Regs);
  39  int    Syscall_ValidString(const char *Addr);
  40  int    Syscall_Valid(int Size, const void *Addr);
  41  int    Syscall_MM_SetFlags(const void *Addr, Uint Flags, Uint Mask);
  42
  43 // === CODE ===
  44 // TODO: Do sanity checking on arguments, ATM the user can really fuck with the kernel
  45 void SyscallHandler(tSyscallRegs *Regs)
  46 {
  47         Uint64  ret = 0;
  48         Uint    err = -EOK;
  49          int    callNum = Regs->Num;
  50
  51         #if DEBUG < 2
  52         if(callNum != SYS_READ && callNum != SYS_WRITE) {
  53         #endif
  54         ENTER("iThread iNum", Threads_GetTID(), callNum);
  55         if(callNum < NUM_SYSCALLS)
  56                 LOG("Syscall %s", cSYSCALL_NAMES[callNum]);
  57         LOG("Arg1: 0x%x, Arg2: 0x%x, Arg3: 0x%x, Arg4: 0x%x", Regs->Arg1, Regs->Arg2, Regs->Arg3, Regs->Arg4);
  58         #if DEBUG < 2
  59         }
  60         #endif
  61
  62         switch(Regs->Num)
  63         {
  64         // -- Exit the current thread
  65         case SYS_EXIT:  Threads_Exit(0, Regs->Arg1);    break;
  66
  67         // -- Put the current thread to sleep
  68         case SYS_SLEEP: Threads_Sleep();        break;
  69
  70         // -- Yield current timeslice
  71         case SYS_YIELD: Threads_Yield();        break;
  72
  73         // -- Set Error Handler
  74         case SYS_SETFAULTHANDLER:
  75                 Threads_SetFaultHandler(Regs->Arg1);
  76                 break;
  77
  78         // -- Clone the current thread
  79         case SYS_CLONE:
  80                 // Call clone system call
  81                 ret = Proc_Clone(Regs->Arg1);
  82                 break;
  83
  84         // -- Send a signal
  85         case SYS_KILL:
  86                 err = -ENOSYS;
  87                 ret = -1;
  88                 break;
  89
  90         // -- Wait fr an event
  91         case SYS_WAITEVENT:
  92                 // Message mask
  93                 ret = Threads_WaitEvents(Regs->Arg1);
  94                 break;
  95
  96         // -- Wait for a thread
  97         case SYS_WAITTID:
  98                 // Sanity Check (Status can be NULL)
  99                 CHECK_NUM_NULLOK( (int*)Regs->Arg2, sizeof(int) );
 100                 // TID, *Status
 101                 ret = Threads_WaitTID(Regs->Arg1, (int*)Regs->Arg2);
 102                 break;
 103
 104         // -- Get the physical address of a page
 105         case SYS_GETPHYS:
 106                 ret = MM_GetPhysAddr( (void*)Regs->Arg1 );
 107                 break;
 108
 109         // -- Map an address
 110         case SYS_MAP:   MM_Map(Regs->Arg1, Regs->Arg2); break;
 111
 112         // -- Allocate an address
 113         case SYS_ALLOCATE:      ret = MM_Allocate(Regs->Arg1);  break;
 114
 115         // -- Unmap an address
 116         case SYS_UNMAP:         MM_Deallocate(Regs->Arg1);      break;
 117
 118         // -- Change the protection on an address
 119         case SYS_SETFLAGS:
 120                 ret = Syscall_MM_SetFlags((void*)Regs->Arg1, Regs->Arg2, Regs->Arg3);
 121                 break;
 122
 123         // -- Get Thread/Process IDs
 124         case SYS_GETTID:        ret = Threads_GetTID(); break;
 125         case SYS_GETPID:        ret = Threads_GetPID(); break;
 126
 127         // -- Get User/Group IDs
 128         case SYS_GETUID:        ret = Threads_GetUID(); break;
 129         case SYS_GETGID:        ret = Threads_GetGID(); break;
 130
 131         // -- Set User/Group IDs
 132         case SYS_SETUID:        ret = Threads_SetUID(Regs->Arg1);       break;
 133         case SYS_SETGID:        ret = Threads_SetGID(Regs->Arg1);       break;
 134
 135         // -- Send Message
 136         case SYS_SENDMSG:
 137                 CHECK_NUM_NONULL( (void*)Regs->Arg3, Regs->Arg2 );
 138                 // Destination, Size, *Data
 139                 ret = Proc_SendMessage(Regs->Arg1, Regs->Arg2, (void*)Regs->Arg3);
 140                 break;
 141         // -- Check for messages
 142         case SYS_GETMSG:
 143                 CHECK_NUM_NULLOK( (Uint*)Regs->Arg1, sizeof(Uint) );
 144                 if( Regs->Arg3 != -1 )
 145                         CHECK_NUM_NULLOK((void*)Regs->Arg3, Regs->Arg2);
 146                 // *Source, *Data
 147                 ret = Proc_GetMessage((Uint*)Regs->Arg1, Regs->Arg2, (void*)Regs->Arg3);
 148                 break;
 149
 150         // -- Get the current timestamp
 151         case SYS_GETTIME:
 152                 ret = now();
 153                 break;
 154
 155         // -- Set the thread's name
 156         case SYS_SETNAME:
 157                 CHECK_STR_NONULL( (char*) Regs->Arg1);
 158                 Threads_SetName( (char*)Regs->Arg1 );
 159                 break;
 160
 161         // ---
 162         // Binary Control
 163         // ---
 164         // -- Create a new process
 165         case SYS_SPAWN:
 166                 CHECK_STR_NONULL((const char*)Regs->Arg1);
 167                 CHECK_STR_ARRAY((const char**)Regs->Arg2);
 168                 CHECK_STR_ARRAY((const char**)Regs->Arg3);
 169                 CHECK_NUM_NULLOK((void*)Regs->Arg5, Regs->Arg4*sizeof(int));
 170                 ret = Proc_SysSpawn(
 171                         (const char*)Regs->Arg1, (const char**)Regs->Arg2, (const char**)Regs->Arg3,
 172                         Regs->Arg4, (int*)Regs->Arg5
 173                         );
 174                 break;
 175         // -- Replace the current process with another
 176         case SYS_EXECVE:
 177                 CHECK_STR_NONULL((char*)Regs->Arg1);
 178                 CHECK_STR_ARRAY( (char**)Regs->Arg2 );
 179                 if( Regs->Arg3 )
 180                         CHECK_STR_ARRAY( (char**)Regs->Arg3 );
 181                 LEAVE('s', "Assuming 0");
 182                 // Path, **Argv, **Envp, DataSize (=0 to tell it to create a copy)
 183                 ret = Proc_Execve(
 184                         (const char*)Regs->Arg1, (const char**)Regs->Arg2, (const char**)Regs->Arg3,
 185                         0
 186                         );
 187                 break;
 188         // -- Load a binary into the current process
 189         case SYS_LOADBIN:
 190                 CHECK_STR_NONULL( (char*)Regs->Arg1 );
 191                 CHECK_NUM_NONULL( (Uint*)Regs->Arg2, sizeof(Uint) );
 192                 // Path, *Entrypoint
 193                 ret = Binary_Load((char*)Regs->Arg1, (Uint*)Regs->Arg2);
 194                 break;
 195
 196         // ---
 197         // Virtual Filesystem
 198         // ---
 199         case SYS_OPEN:
 200                 CHECK_STR_NONULL( (char*)Regs->Arg1 );
 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( (void*)Regs->Arg2, Regs->Arg3 );
 224                 ret = VFS_Write( Regs->Arg1, Regs->Arg3, (void*)Regs->Arg2 );
 225                 break;
 226
 227         case SYS_READ:
 228                 CHECK_NUM_NONULL( (void*)Regs->Arg2, Regs->Arg3 );
 229                 ret = VFS_Read( Regs->Arg1, Regs->Arg3, (void*)Regs->Arg2 );
 230                 break;
 231
 232         case SYS_FINFO:
 233                 CHECK_NUM_NONULL( (void*)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                 CHECK_NUM_NONULL( (void*)Regs->Arg2, sizeof(tVFS_ACL) );
 241                 ret = VFS_GetACL( Regs->Arg1, (void*)Regs->Arg2 );
 242                 break;
 243
 244         // Read Directory
 245         case SYS_READDIR:
 246                 // TODO: What if the filename is longer?
 247                 // Maybe force it to be a 256 byte buffer
 248                 CHECK_NUM_NONULL( (void*)Regs->Arg2, 256 );
 249                 ret = VFS_ReadDir( Regs->Arg1, (void*)Regs->Arg2 );
 250                 break;
 251
 252         // Open a file that is a entry in an open directory
 253         case SYS_OPENCHILD:
 254                 CHECK_STR_NONULL( (char*)Regs->Arg2 );
 255                 ret = VFS_OpenChild( Regs->Arg1, (char*)Regs->Arg2, Regs->Arg3 | VFS_OPENFLAG_USER);
 256                 break;
 257
 258         // Change Directory
 259         case SYS_CHDIR:
 260                 CHECK_STR_NONULL( (const char*)Regs->Arg1 );
 261                 ret = VFS_ChDir( (const char*)Regs->Arg1 );
 262                 break;
 263
 264         // IO Control
 265         case SYS_IOCTL:
 266                 // All sanity checking should be done by the driver
 267                 if( Regs->Arg3 && !MM_IsUser(Regs->Arg3) ) {
 268                         err = -EINVAL;  ret = -1;       break;
 269                 }
 270                 ret = VFS_IOCtl( Regs->Arg1, Regs->Arg2, (void*)Regs->Arg3 );
 271                 break;
 272
 273         // Mount a filesystem
 274         case SYS_MOUNT:
 275                 // Only root can mount filesystems
 276                 if(Threads_GetUID() != 0) {
 277                         err = -EACCES;
 278                         ret = -1;
 279                         break;
 280                 }
 281
 282                 if( !Regs->Arg1 )
 283                 {
 284                         if( !Syscall_ValidString((char*)Regs->Arg2) ) {
 285                                 err = -EINVAL;
 286                                 ret = -1;
 287                                 break;
 288                         }
 289
 290                         ret = VFS_Unmount((char*)Regs->Arg2);
 291                 }
 292                 else
 293                 {
 294                         // Sanity check the paths
 295                         if(!Syscall_ValidString((char*)Regs->Arg1)
 296                         || !Syscall_ValidString((char*)Regs->Arg2)
 297                         || (Regs->Arg3 && !Syscall_ValidString((char*)Regs->Arg3))
 298                         || !Syscall_ValidString((char*)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                 }
 310                 break;
 311
 312         // Wait on a set of handles
 313         case SYS_SELECT:
 314                 // Sanity checks
 315                 if( (Regs->Arg2 && !Syscall_Valid(sizeof(fd_set), (void*)Regs->Arg2))
 316                  || (Regs->Arg3 && !Syscall_Valid(sizeof(fd_set), (void*)Regs->Arg3))
 317                  || (Regs->Arg4 && !Syscall_Valid(sizeof(fd_set), (void*)Regs->Arg4))
 318                  || (Regs->Arg5 && !Syscall_Valid(sizeof(tTime), (void*)Regs->Arg5)) )
 319                 {
 320                         err = -EINVAL;
 321                         ret = -1;
 322                         break;
 323                 }
 324                 // Perform the call
 325                 ret = VFS_Select(
 326                         Regs->Arg1,     // Max handle
 327                         (fd_set *)Regs->Arg2,   // Read
 328                         (fd_set *)Regs->Arg3,   // Write
 329                         (fd_set *)Regs->Arg4,   // Errors
 330                         (tTime *)Regs->Arg5,    // Timeout
 331                         (Uint32)Regs->Arg6,     // Extra wakeup events
 332                         0       // User handles
 333                         );
 334                 break;
 335
 336         // -- Debug
 337         //#if DEBUG_BUILD
 338         case SYS_DEBUG:
 339                 CHECK_STR_NONULL( (char*)Regs->Arg1 );
 340                 LogF("Log: %08lli [%i] ", now(), Threads_GetTID());
 341                 LogF((const char*)Regs->Arg1,
 342                         Regs->Arg2, Regs->Arg3, Regs->Arg4, Regs->Arg5, Regs->Arg6);
 343                 LogF("\r\n");
 344                 break;
 345         //#endif
 346
 347         // -- Default (Return Error)
 348         default:
 349                 Log_Warning("Syscalls", "Unknown System Call %i", Regs->Num);
 350                 if(Regs->Num < NUM_SYSCALLS)
 351                         Log_Warning("Syscall", " named '%s'", cSYSCALL_NAMES[Regs->Num]);
 352                 err = -ENOSYS;
 353                 ret = -1;
 354                 break;
 355         }
 356
 357         if(err == 0)    err = errno;
 358
 359         if(err != 0) {
 360                 LOG("ID: %i, Return errno = %i", Regs->Num, err);
 361         }
 362
 363         #if BITS < 64
 364         Regs->Return = ret&0xFFFFFFFF;
 365         Regs->RetHi = ret >> 32;
 366         #else
 367         Regs->Return = ret;
 368         #endif
 369         Regs->Error = err;
 370         #if DEBUG
 371         # if DEBUG < 2
 372         if( callNum != SYS_READ && callNum != SYS_WRITE ) {
 373         # endif
 374         LOG("err = %i", err);
 375         if( callNum == SYS_EXECVE )
 376                 LOG("Actual %i", ret);
 377         else
 378                 LEAVE('x', ret);
 379         # if DEBUG < 2
 380         }
 381         # endif
 382         #endif
 383 }
 384
 385 /**
 386  * \fn int Syscall_ValidString(const char *Addr)
 387  * \brief Checks if a memory address contains a valid string
 388  */
 389 int Syscall_ValidString(const char *Addr)
 390 {
 391         // Check if the memory is user memory
 392         if(!MM_IsUser( (tVAddr) Addr))  return 0;
 393
 394         return CheckString( Addr );
 395 }
 396
 397 /**
 398  * \fn int Syscall_Valid(int Size, const void *Addr)
 399  * \brief Checks if a memory address is valid
 400  */
 401 int Syscall_Valid(int Size, const void *Addr)
 402 {
 403         if(!MM_IsUser( (tVAddr)Addr )) {
 404                 Log_Debug("Syscalls", "Syscall_Valid - %p not user", Addr);
 405                 return 0;
 406         }
 407
 408         return CheckMem( Addr, Size );
 409 }
 410
 411 int Syscall_MM_SetFlags(const void *Addr, Uint Flags, Uint Mask)
 412 {
 413         tPAddr  paddr = MM_GetPhysAddr(Addr);
 414         Flags &= MM_PFLAG_RO|MM_PFLAG_EXEC;
 415         Mask &= MM_PFLAG_RO|MM_PFLAG_EXEC;
 416
 417         //Log_Debug("Syscalls", "SYS_SETFLAGS: %p %x %x", Addr, Flags, Mask);
 418
 419         // Enable write?
 420         if( (Mask & MM_PFLAG_RO) && !(Flags & MM_PFLAG_RO) ) {
 421                 void    *node;
 422                 // HACK - Assume that RO mmap'd files are immutable
 423                 if( MM_GetPageNode(paddr, &node) == 0 && node ) {
 424                         Flags |= MM_PFLAG_COW;
 425                         Mask |= MM_PFLAG_COW;
 426                 }
 427         }
 428         MM_SetFlags((tVAddr)Addr, Flags, Mask);
 429         return 0;
 430 }