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