KernelLand/Kernel/threads.c

   1 /*
   2  * Acess2 Kernel
   3  * - By John Hodge (thePowersGang)
   4  * threads.c
   5  * - Common Thread Control
   6  */
   7 #include <acess.h>
   8 #include <threads.h>
   9 #include <threads_int.h>
  10 #include <errno.h>
  11 #include <hal_proc.h>
  12 #include <semaphore.h>
  13 #include <vfs_threads.h>        // VFS Handle maintainence
  14 #include <events.h>
  15
  16 // Configuration
  17 #define DEBUG_TRACE_TICKETS     0       // Trace ticket counts
  18 #define DEBUG_TRACE_STATE       0       // Trace state changes (sleep/wake)
  19
  20 // --- Schedulers ---
  21 #define SCHED_UNDEF     0
  22 #define SCHED_LOTTERY   1       // Lottery scheduler
  23 #define SCHED_RR_SIM    2       // Single Queue Round Robin
  24 #define SCHED_RR_PRI    3       // Multi Queue Round Robin
  25 // Set scheduler type
  26 #define SCHEDULER_TYPE  SCHED_RR_PRI
  27
  28 // === CONSTANTS ===
  29 #define DEFAULT_QUANTUM 5
  30 #define DEFAULT_PRIORITY        5
  31 #define MIN_PRIORITY            10
  32
  33 // === IMPORTS ===
  34
  35 // === TYPE ===
  36 typedef struct
  37 {
  38         tThread *Head;
  39         tThread *Tail;
  40 } tThreadList;
  41
  42 // === PROTOTYPES ===
  43 void    Threads_Init(void);
  44 #if 0
  45 void    Threads_Delete(tThread *Thread);
  46  int    Threads_SetName(const char *NewName);
  47 #endif
  48 char    *Threads_GetName(tTID ID);
  49 #if 0
  50 void    Threads_SetPriority(tThread *Thread, int Pri);
  51 tThread *Threads_CloneTCB(Uint *Err, Uint Flags);
  52  int    Threads_WaitTID(int TID, int *status);
  53 tThread *Threads_GetThread(Uint TID);
  54 #endif
  55 tThread *Threads_int_DelFromQueue(tThreadList *List, tThread *Thread);
  56 void    Threads_int_AddToList(tThreadList *List, tThread *Thread);
  57 #if 0
  58 void    Threads_Exit(int TID, int Status);
  59 void    Threads_Kill(tThread *Thread, int Status);
  60 void    Threads_Yield(void);
  61 void    Threads_Sleep(void);
  62  int    Threads_Wake(tThread *Thread);
  63 void    Threads_AddActive(tThread *Thread);
  64 tThread *Threads_RemActive(void);
  65 #endif
  66 void    Threads_ToggleTrace(int TID);
  67 void    Threads_Fault(int Num);
  68 void    Threads_SegFault(tVAddr Addr);
  69 #if 0
  70  int    Threads_GetPID(void);
  71  int    Threads_GetTID(void);
  72 tUID    Threads_GetUID(void);
  73 tGID    Threads_GetGID(void);
  74  int    Threads_SetUID(Uint *Errno, tUID ID);
  75  int    Threads_SetGID(Uint *Errno, tUID ID);
  76 #endif
  77 void    Threads_int_DumpThread(tThread *thread);
  78 void    Threads_Dump(void);
  79 void    Threads_DumpActive(void);
  80
  81 // === GLOBALS ===
  82 // -- Core Thread --
  83 struct sProcess gProcessZero = {
  84         };
  85 // Only used for the core kernel
  86 tThread gThreadZero = {
  87         .Status         = THREAD_STAT_ACTIVE,   // Status
  88         .ThreadName     = (char*)"ThreadZero",  // Name
  89         .Quantum        = DEFAULT_QUANTUM,      // Default Quantum
  90         .Remaining      = DEFAULT_QUANTUM,      // Current Quantum
  91         .Priority       = DEFAULT_PRIORITY      // Number of tickets
  92         };
  93 // -- Processes --
  94 // --- Locks ---
  95 tShortSpinlock  glThreadListLock;       ///\note NEVER use a heap function while locked
  96 // --- Current State ---
  97 volatile int    giNumActiveThreads = 0; // Number of threads on the active queue
  98 volatile Uint   giNextTID = 1;  // Next TID to allocate
  99 // --- Thread Lists ---
 100 tThread *gAllThreads = NULL;            // All allocated threads
 101 tThreadList     gSleepingThreads;       // Sleeping Threads
 102  int    giNumCPUs = 1;  // Number of CPUs
 103 BOOL     gaThreads_NoTaskSwitch[MAX_CPUS];      // Disables task switches for each core (Pseudo-IF)
 104 // --- Scheduler Types ---
 105 #if SCHEDULER_TYPE == SCHED_LOTTERY
 106 const int       caiTICKET_COUNTS[MIN_PRIORITY+1] = {100,81,64,49,36,25,16,9,4,1,0};
 107 volatile int    giFreeTickets = 0;      // Number of tickets held by non-scheduled threads
 108 tThreadList     gActiveThreads;         // Currently Running Threads
 109 #elif SCHEDULER_TYPE == SCHED_RR_SIM
 110 tThreadList     gActiveThreads;         // Currently Running Threads
 111 #elif SCHEDULER_TYPE == SCHED_RR_PRI
 112 tThreadList     gaActiveThreads[MIN_PRIORITY+1];        // Active threads for each priority level
 113 #else
 114 # error "Unkown scheduler type"
 115 #endif
 116
 117 // === CODE ===
 118 /**
 119  * \fn void Threads_Init(void)
 120  * \brief Initialse the thread list
 121  */
 122 void Threads_Init(void)
 123 {
 124         ArchThreads_Init();
 125
 126         Log_Debug("Threads", "Offsets of tThread");
 127         Log_Debug("Threads", ".Priority = %i", offsetof(tThread, Priority));
 128         Log_Debug("Threads", ".KernelStack = %i", offsetof(tThread, KernelStack));
 129
 130         // Create Initial Task
 131         gAllThreads = &gThreadZero;
 132         giNumActiveThreads = 1;
 133         gThreadZero.Process = &gProcessZero;
 134
 135         Proc_Start();
 136 }
 137
 138 void Threads_Delete(tThread *Thread)
 139 {
 140         // Set to dead
 141         Thread->Status = THREAD_STAT_BURIED;
 142
 143         // Clear out process state
 144         Proc_ClearThread(Thread);
 145
 146         Thread->Process->nThreads --;
 147
 148         if( Thread->Process->FirstThread == Thread )
 149         {
 150                 Thread->Process->FirstThread = Thread->ProcessNext;
 151         }
 152         else
 153         {
 154                 tThread *prev = Thread->Process->FirstThread;
 155                 while(prev && prev->ProcessNext != Thread)
 156                         prev = prev->ProcessNext;
 157                 if( !prev )
 158                         Log_Error("Threads", "Thread %p(%i %s) is not on the process's list",
 159                                 Thread, Thread->TID, Thread->ThreadName
 160                                 );
 161                 else
 162                         prev->ProcessNext = Thread->ProcessNext;
 163         }
 164
 165         // If the final thread is being terminated, clean up the process
 166         if( Thread->Process->nThreads == 0 )
 167         {
 168                 tProcess        *proc = Thread->Process;
 169                 // VFS Cleanup
 170                 VFS_CloseAllUserHandles();
 171                 // Architecture cleanup
 172                 Proc_ClearProcess( proc );
 173                 // VFS Configuration strings
 174                 if( proc->CurrentWorkingDir)
 175                         free( proc->CurrentWorkingDir );
 176                 if( proc->RootDir )
 177                         free( proc->RootDir );
 178                 // Process descriptor
 179                 free( proc );
 180         }
 181
 182         // Free name
 183         if( IsHeap(Thread->ThreadName) )
 184                 free(Thread->ThreadName);
 185
 186         // Remove from global list
 187         // TODO: Lock this too
 188         if( Thread == gAllThreads )
 189                 gAllThreads = Thread->GlobalNext;
 190         else
 191                 Thread->GlobalPrev->GlobalNext = Thread->GlobalNext;
 192
 193         free(Thread);
 194 }
 195
 196 /**
 197  * \fn void Threads_SetName(const char *NewName)
 198  * \brief Sets the current thread's name
 199  * \param NewName       New name for the thread
 200  * \return Boolean Failure
 201  */
 202 int Threads_SetName(const char *NewName)
 203 {
 204         tThread *cur = Proc_GetCurThread();
 205         char    *oldname = cur->ThreadName;
 206
 207         // NOTE: There is a possibility of non-thread safety here
 208         // A thread could read the current name pointer before it is zeroed
 209
 210         cur->ThreadName = NULL;
 211
 212         if( IsHeap(oldname) )   free( oldname );
 213         cur->ThreadName = strdup(NewName);
 214
 215 //      Log_Debug("Threads", "Thread renamed to '%s'", NewName);
 216
 217         return 0;
 218 }
 219
 220 /**
 221  * \fn char *Threads_GetName(int ID)
 222  * \brief Gets a thread's name
 223  * \param ID    Thread ID (-1 indicates current thread)
 224  * \return Pointer to name
 225  * \retval NULL Failure
 226  */
 227 char *Threads_GetName(tTID ID)
 228 {
 229         if(ID == -1) {
 230                 return Proc_GetCurThread()->ThreadName;
 231         }
 232         return Threads_GetThread(ID)->ThreadName;
 233 }
 234
 235 /**
 236  * \fn void Threads_SetPriority(tThread *Thread, int Pri)
 237  * \brief Sets the priority of a task
 238  * \param Thread        Thread to update ticket count (NULL means current thread)
 239  * \param Pri   New priority
 240  */
 241 void Threads_SetPriority(tThread *Thread, int Pri)
 242 {
 243         // Get current thread
 244         if(Thread == NULL)      Thread = Proc_GetCurThread();
 245         // Bounds checking
 246         // - If < 0, set to lowest priority
 247         // - Minumum priority is actualy a high number, 0 is highest
 248         if(Pri < 0)     Pri = MIN_PRIORITY;
 249         if(Pri > MIN_PRIORITY)  Pri = MIN_PRIORITY;
 250
 251         // Do we actually have to do anything?
 252         if( Pri == Thread->Priority )   return;
 253
 254         #if SCHEDULER_TYPE == SCHED_RR_PRI
 255         if( Thread != Proc_GetCurThread() )
 256         {
 257                 SHORTLOCK( &glThreadListLock );
 258                 // Remove from old priority
 259                 Threads_int_DelFromQueue( &gaActiveThreads[Thread->Priority], Thread );
 260                 // And add to new
 261                 Threads_int_AddToList( &gaActiveThreads[Pri], Thread );
 262                 Thread->Priority = Pri;
 263                 SHORTREL( &glThreadListLock );
 264         }
 265         else
 266                 Thread->Priority = Pri;
 267         #else
 268         // If this isn't the current thread, we need to lock
 269         if( Thread != Proc_GetCurThread() )
 270         {
 271                 SHORTLOCK( &glThreadListLock );
 272
 273                 #if SCHEDULER_TYPE == SCHED_LOTTERY
 274                 giFreeTickets -= caiTICKET_COUNTS[Thread->Priority] - caiTICKET_COUNTS[Pri];
 275                 # if DEBUG_TRACE_TICKETS
 276                 Log("Threads_SetTickets: new giFreeTickets = %i [-%i+%i]",
 277                         giFreeTickets,
 278                         caiTICKET_COUNTS[Thread->Priority], caiTICKET_COUNTS[Pri]);
 279                 # endif
 280                 #endif
 281                 Thread->Priority = Pri;
 282                 SHORTREL( &glThreadListLock );
 283         }
 284         else
 285                 Thread->Priority = Pri;
 286         #endif
 287
 288         #if DEBUG_TRACE_STATE
 289         Log("Threads_SetPriority: %p(%i %s) pri set %i",
 290                 Thread, Thread->TID, Thread->ThreadName,
 291                 Pri);
 292         #endif
 293 }
 294
 295 /**
 296  * \brief Clone the TCB of the current thread
 297  * \param Flags Flags for something... (What is this for?)
 298  */
 299 tThread *Threads_CloneTCB(Uint Flags)
 300 {
 301         tThread *cur, *new;
 302         cur = Proc_GetCurThread();
 303
 304         // Allocate and duplicate
 305         new = malloc(sizeof(tThread));
 306         if(new == NULL) { errno = -ENOMEM; return NULL; }
 307         memcpy(new, cur, sizeof(tThread));
 308
 309         new->CurCPU = -1;
 310         new->Next = NULL;
 311         memset( &new->IsLocked, 0, sizeof(new->IsLocked));
 312         new->Status = THREAD_STAT_PREINIT;
 313         new->RetStatus = 0;
 314
 315         // Get Thread ID
 316         new->TID = giNextTID++;
 317         new->Parent = cur;
 318         new->bInstrTrace = 0;
 319
 320         // Clone Name
 321         new->ThreadName = strdup(cur->ThreadName);
 322
 323         // Set Thread Group ID (PID)
 324         if(Flags & CLONE_VM) {
 325                 tProcess        *newproc, *oldproc;
 326                 oldproc = cur->Process;
 327                 new->Process = malloc( sizeof(struct sProcess) );
 328                 newproc = new->Process;
 329                 newproc->PID = new->TID;
 330                 if( Flags & CLONE_PGID )
 331                         newproc->PGID = oldproc->PGID;
 332                 else
 333                         newproc->PGID = newproc->PID;
 334                 newproc->UID = oldproc->UID;
 335                 newproc->GID = oldproc->GID;
 336                 newproc->MaxFD = oldproc->MaxFD;
 337                 if( oldproc->CurrentWorkingDir )
 338                         newproc->CurrentWorkingDir = strdup( oldproc->CurrentWorkingDir );
 339                 else
 340                         newproc->CurrentWorkingDir = NULL;
 341                 if( oldproc->RootDir )
 342                         newproc->RootDir = strdup( oldproc->RootDir );
 343                 else
 344                         newproc->RootDir = NULL;
 345                 newproc->nThreads = 1;
 346                 // Reference all handles in the VFS
 347                 VFS_ReferenceUserHandles();
 348
 349                 newproc->FirstThread = new;
 350                 new->ProcessNext = NULL;
 351         }
 352         else {
 353                 new->Process->nThreads ++;
 354                 new->Process = cur->Process;
 355                 // TODO: Locking
 356                 new->ProcessNext = new->Process->FirstThread;
 357                 new->Process->FirstThread = new;
 358         }
 359
 360         // Messages are not inherited
 361         new->Messages = NULL;
 362         new->LastMessage = NULL;
 363
 364         // Set State
 365         new->Remaining = new->Quantum = cur->Quantum;
 366         new->Priority = cur->Priority;
 367         new->_errno = 0;
 368
 369         // Set Signal Handlers
 370         new->CurFaultNum = 0;
 371         new->FaultHandler = cur->FaultHandler;
 372
 373         // Maintain a global list of threads
 374         SHORTLOCK( &glThreadListLock );
 375         new->GlobalPrev = NULL; // Protect against bugs
 376         new->GlobalNext = gAllThreads;
 377         gAllThreads->GlobalPrev = new;
 378         gAllThreads = new;
 379         SHORTREL( &glThreadListLock );
 380
 381         return new;
 382 }
 383
 384 /**
 385  * \brief Clone the TCB of the kernel thread
 386  */
 387 tThread *Threads_CloneThreadZero(void)
 388 {
 389         tThread *new;
 390
 391         // Allocate and duplicate
 392         new = malloc(sizeof(tThread));
 393         if(new == NULL) {
 394                 return NULL;
 395         }
 396         memcpy(new, &gThreadZero, sizeof(tThread));
 397
 398         new->Process->nThreads ++;
 399
 400         new->CurCPU = -1;
 401         new->Next = NULL;
 402         memset( &new->IsLocked, 0, sizeof(new->IsLocked));
 403         new->Status = THREAD_STAT_PREINIT;
 404         new->RetStatus = 0;
 405
 406         // Get Thread ID
 407         new->TID = giNextTID++;
 408         new->Parent = 0;
 409
 410         // Clone Name
 411         new->ThreadName = NULL;
 412
 413         // Messages are not inherited
 414         new->Messages = NULL;
 415         new->LastMessage = NULL;
 416
 417         // Set State
 418         new->Remaining = new->Quantum = DEFAULT_QUANTUM;
 419         new->Priority = DEFAULT_PRIORITY;
 420         new->bInstrTrace = 0;
 421
 422         // Set Signal Handlers
 423         new->CurFaultNum = 0;
 424         new->FaultHandler = 0;
 425
 426         // Maintain a global list of threads
 427         SHORTLOCK( &glThreadListLock );
 428         new->GlobalPrev = NULL; // Protect against bugs
 429         new->GlobalNext = gAllThreads;
 430         gAllThreads->GlobalPrev = new;
 431         gAllThreads = new;
 432         SHORTREL( &glThreadListLock );
 433
 434         return new;
 435 }
 436
 437 /**
 438  * \brief Wait for a task to change state
 439  * \param TID   Thread ID to wait on (-1: Any child thread, 0: Any Child/Sibling, <-1: -PID)
 440  * \param Status        Thread return status
 441  * \return TID of child that changed state
 442  */
 443 tTID Threads_WaitTID(int TID, int *Status)
 444 {
 445         // Any Child
 446         if(TID == -1)
 447         {
 448                 Uint32 ev = Threads_WaitEvents(THREAD_EVENT_DEADCHILD);
 449                 tTID    ret = -1;
 450                 if( ev & THREAD_EVENT_DEADCHILD )
 451                 {
 452                         // A child died, get the TID
 453                         tThread *us = Proc_GetCurThread();
 454                         ASSERT(us->LastDeadChild);
 455                         ret = us->LastDeadChild->TID;
 456                         // - Mark as dead (as opposed to undead)
 457                         ASSERT(us->LastDeadChild->Status == THREAD_STAT_ZOMBIE);
 458                         us->LastDeadChild->Status = THREAD_STAT_DEAD;
 459                         // - Set return status
 460                         if(Status)
 461                                 *Status = us->LastDeadChild->RetStatus;
 462                         us->LastDeadChild = NULL;
 463                         Mutex_Release(&us->DeadChildLock);
 464                 }
 465                 else
 466                 {
 467                         Log_Error("Threads", "TODO: Threads_WaitTID(TID=-1) - Any Child");
 468                 }
 469                 return ret;
 470         }
 471
 472         // Any peer/child thread
 473         if(TID == 0) {
 474                 Log_Error("Threads", "TODO: Threads_WaitTID(TID=0) - Any Child/Sibling");
 475                 return -1;
 476         }
 477
 478         // TGID = abs(TID)
 479         if(TID < -1) {
 480                 Log_Error("Threads", "TODO: Threads_WaitTID(TID<0) - TGID");
 481                 return -1;
 482         }
 483
 484         // Specific Thread
 485         if(TID > 0)
 486         {
 487                 tTID    ret;
 488                 while( (ret = Threads_WaitTID(-1, Status)) != TID )
 489                 {
 490                         if( ret == -1 )
 491                                 break;
 492                 }
 493                 return ret;
 494         }
 495
 496         return -1;
 497 }
 498
 499 /**
 500  * \brief Gets a thread given its TID
 501  * \param TID   Thread ID
 502  * \return Thread pointer
 503  */
 504 tThread *Threads_GetThread(Uint TID)
 505 {
 506         tThread *thread;
 507
 508         // Search global list
 509         for( thread = gAllThreads; thread; thread = thread->GlobalNext )
 510         {
 511                 if(thread->TID == TID)
 512                         return thread;
 513         }
 514
 515         Log_Notice("Threads", "Unable to find TID %i on main list\n", TID);
 516
 517         return NULL;
 518 }
 519
 520 /**
 521  * \brief Deletes an entry from a list
 522  * \param List  Pointer to the list head
 523  * \param Thread        Thread to find
 524  * \return \a Thread
 525  */
 526 tThread *Threads_int_DelFromQueue(tThreadList *List, tThread *Thread)
 527 {
 528         tThread *ret, *prev = NULL;
 529
 530         for(ret = List->Head;
 531                 ret && ret != Thread;
 532                 prev = ret, ret = ret->Next
 533                 );
 534
 535         // Is the thread on the list
 536         if(!ret) {
 537                 //LogF("%p(%s) is not on list %p\n", Thread, Thread->ThreadName, List);
 538                 return NULL;
 539         }
 540
 541         if( !prev ) {
 542                 List->Head = Thread->Next;
 543                 //LogF("%p(%s) removed from head of %p\n", Thread, Thread->ThreadName, List);
 544         }
 545         else {
 546                 prev->Next = Thread->Next;
 547                 //LogF("%p(%s) removed from %p (prev=%p)\n", Thread, Thread->ThreadName, List, prev);
 548         }
 549         if( Thread->Next == NULL )
 550                 List->Tail = prev;
 551
 552         return Thread;
 553 }
 554
 555 void Threads_int_AddToList(tThreadList *List, tThread *Thread)
 556 {
 557         if( List->Head )
 558                 List->Tail->Next = Thread;
 559         else
 560                 List->Head = Thread;
 561         List->Tail = Thread;
 562         Thread->Next = NULL;
 563 }
 564
 565 /**
 566  * \brief Exit the current process (or another?)
 567  * \param TID   Thread ID to kill
 568  * \param Status        Exit status
 569  */
 570 void Threads_Exit(int TID, int Status)
 571 {
 572         if( TID == 0 )
 573                 Threads_Kill( Proc_GetCurThread(), (Uint)Status & 0xFF );
 574         else
 575                 Threads_Kill( Threads_GetThread(TID), (Uint)Status & 0xFF );
 576
 577         // Halt forever, just in case
 578         for(;;) HALT();
 579 }
 580
 581 /**
 582  * \fn void Threads_Kill(tThread *Thread, int Status)
 583  * \brief Kill a thread
 584  * \param Thread        Thread to kill
 585  * \param Status        Status code to return to the parent
 586  */
 587 void Threads_Kill(tThread *Thread, int Status)
 588 {
 589         tMsg    *msg;
 590          int    isCurThread = Thread == Proc_GetCurThread();
 591
 592         // TODO: Disown all children?
 593         #if 1
 594         {
 595                 tThread *child;
 596                 // TODO: I should keep a .Children list
 597                 for(child = gAllThreads;
 598                         child;
 599                         child = child->GlobalNext)
 600                 {
 601                         if(child->Parent == Thread)
 602                                 child->Parent = &gThreadZero;
 603                 }
 604         }
 605         #endif
 606
 607         ///\note Double lock is needed due to overlap of lock areas
 608
 609         // Lock thread (stop us recieving messages)
 610         SHORTLOCK( &Thread->IsLocked );
 611
 612         // Clear Message Queue
 613         while( Thread->Messages )
 614         {
 615                 msg = Thread->Messages->Next;
 616                 free( Thread->Messages );
 617                 Thread->Messages = msg;
 618         }
 619
 620         // Lock thread list
 621         SHORTLOCK( &glThreadListLock );
 622
 623         switch(Thread->Status)
 624         {
 625         case THREAD_STAT_PREINIT:       // Only on main list
 626                 break;
 627
 628         // Currently active thread
 629         case THREAD_STAT_ACTIVE:
 630                 if( Thread != Proc_GetCurThread() )
 631                 {
 632                         #if SCHEDULER_TYPE == SCHED_RR_PRI
 633                         tThreadList     *list = &gaActiveThreads[Thread->Priority];
 634                         #else
 635                         tThreadList     *list = &gActiveThreads;
 636                         #endif
 637                         if( Threads_int_DelFromQueue( list, Thread ) )
 638                         {
 639                         }
 640                         else
 641                         {
 642                                 Log_Warning("Threads",
 643                                         "Threads_Kill - Thread %p(%i,%s) marked as active, but not on list",
 644                                         Thread, Thread->TID, Thread->ThreadName
 645                                         );
 646                         }
 647                         #if SCHEDULER_TYPE == SCHED_LOTTERY
 648                         giFreeTickets -= caiTICKET_COUNTS[ Thread->Priority ];
 649                         #endif
 650                 }
 651                 // Ensure that we are not rescheduled
 652                 Thread->Remaining = 0;  // Clear Remaining Quantum
 653                 Thread->Quantum = 0;    // Clear Quantum to indicate dead thread
 654
 655                 // Update bookkeeping
 656                 giNumActiveThreads --;
 657                 break;
 658         // Kill it while it sleeps!
 659         case THREAD_STAT_SLEEPING:
 660                 if( !Threads_int_DelFromQueue( &gSleepingThreads, Thread ) )
 661                 {
 662                         Log_Warning("Threads",
 663                                 "Threads_Kill - Thread %p(%i,%s) marked as sleeping, but not on list",
 664                                 Thread, Thread->TID, Thread->ThreadName
 665                                 );
 666                 }
 667                 break;
 668
 669         // Brains!... You cannot kill something that is already dead
 670         case THREAD_STAT_ZOMBIE:
 671                 Log_Warning("Threads", "Threads_Kill - Thread %p(%i,%s) is undead, you cannot kill it",
 672                         Thread, Thread->TID, Thread->ThreadName);
 673                 SHORTREL( &glThreadListLock );
 674                 SHORTREL( &Thread->IsLocked );
 675                 return ;
 676
 677         default:
 678                 Log_Warning("Threads", "Threads_Kill - BUG Un-checked status (%i)",
 679                         Thread->Status);
 680                 break;
 681         }
 682
 683         // Save exit status
 684         Thread->RetStatus = Status;
 685
 686         SHORTREL( &Thread->IsLocked );
 687
 688         Thread->Status = THREAD_STAT_ZOMBIE;
 689         SHORTREL( &glThreadListLock );
 690         // TODO: It's possible that we could be timer-preempted here, should disable that... somehow
 691         Mutex_Acquire( &Thread->Parent->DeadChildLock );        // released by parent
 692         Thread->Parent->LastDeadChild = Thread;
 693         Threads_PostEvent( Thread->Parent, THREAD_EVENT_DEADCHILD );
 694
 695         Log("Thread %i went *hurk* (%i)", Thread->TID, Status);
 696
 697         // And, reschedule
 698         if(isCurThread)
 699         {
 700                 for( ;; )
 701                         Proc_Reschedule();
 702         }
 703 }
 704
 705 /**
 706  * \brief Yield remainder of the current thread's timeslice
 707  */
 708 void Threads_Yield(void)
 709 {
 710 //      Log("Threads_Yield: by %p", __builtin_return_address(0));
 711         Proc_Reschedule();
 712 }
 713
 714 /**
 715  * \fn void Threads_Sleep(void)
 716  * \brief Take the current process off the run queue
 717  */
 718 void Threads_Sleep(void)
 719 {
 720         tThread *cur = Proc_GetCurThread();
 721
 722         // Acquire Spinlock
 723         SHORTLOCK( &glThreadListLock );
 724
 725         // Don't sleep if there is a message waiting
 726         if( cur->Messages ) {
 727                 SHORTREL( &glThreadListLock );
 728                 return;
 729         }
 730
 731         // Remove us from running queue
 732         Threads_RemActive();
 733         // Mark thread as sleeping
 734         cur->Status = THREAD_STAT_SLEEPING;
 735
 736         // Add to Sleeping List (at the top)
 737         Threads_int_AddToList( &gSleepingThreads, cur );
 738
 739         #if DEBUG_TRACE_STATE
 740         Log("Threads_Sleep: %p (%i %s) sleeping", cur, cur->TID, cur->ThreadName);
 741         #endif
 742
 743         // Release Spinlock
 744         SHORTREL( &glThreadListLock );
 745
 746         while(cur->Status != THREAD_STAT_ACTIVE) {
 747                 Proc_Reschedule();
 748                 if( cur->Status != THREAD_STAT_ACTIVE )
 749                         Log("%i - Huh? why am I up? zzzz...", cur->TID);
 750         }
 751 }
 752
 753
 754 /**
 755  * \brief Wakes a sleeping/waiting thread up
 756  * \param Thread        Thread to wake
 757  * \return Boolean Failure (Returns ERRNO)
 758  * \warning This should ONLY be called with task switches disabled
 759  */
 760 int Threads_Wake(tThread *Thread)
 761 {
 762         if(!Thread)
 763                 return -EINVAL;
 764
 765         switch(Thread->Status)
 766         {
 767         case THREAD_STAT_ACTIVE:
 768                 Log("Threads_Wake - Waking awake thread (%i)", Thread->TID);
 769                 return -EALREADY;
 770
 771         case THREAD_STAT_SLEEPING:
 772                 // Remove from sleeping queue
 773                 SHORTLOCK( &glThreadListLock );
 774                 Threads_int_DelFromQueue(&gSleepingThreads, Thread);
 775                 SHORTREL( &glThreadListLock );
 776
 777                 Threads_AddActive( Thread );
 778
 779                 #if DEBUG_TRACE_STATE
 780                 Log("Threads_Sleep: %p (%i %s) woken", Thread, Thread->TID, Thread->ThreadName);
 781                 #endif
 782                 return -EOK;
 783
 784         case THREAD_STAT_SEMAPHORESLEEP: {
 785                 tSemaphore      *sem;
 786                 tThread *th, *prev=NULL;
 787
 788                 sem = Thread->WaitPointer;
 789
 790                 SHORTLOCK( &sem->Protector );
 791
 792                 // Remove from sleeping queue
 793                 for( th = sem->Waiting; th; prev = th, th = th->Next )
 794                         if( th == Thread )      break;
 795                 if( th )
 796                 {
 797                         if(prev)
 798                                 prev->Next = Thread->Next;
 799                         else
 800                                 sem->Waiting = Thread->Next;
 801                         if(sem->LastWaiting == Thread)
 802                                 sem->LastWaiting = prev;
 803                 }
 804                 else
 805                 {
 806                         prev = NULL;
 807                         for( th = sem->Signaling; th; prev = th, th = th->Next )
 808                                 if( th == Thread )      break;
 809                         if( !th ) {
 810                                 Log_Warning("Threads", "Thread %p(%i %s) is not on semaphore %p(%s:%s)",
 811                                         Thread, Thread->TID, Thread->ThreadName,
 812                                         sem, sem->ModName, sem->Name);
 813                                 return -EINTERNAL;
 814                         }
 815
 816                         if(prev)
 817                                 prev->Next = Thread->Next;
 818                         else
 819                                 sem->Signaling = Thread->Next;
 820                         if(sem->LastSignaling == Thread)
 821                                 sem->LastSignaling = prev;
 822                 }
 823
 824                 Thread->RetStatus = 0;  // It didn't get anything
 825                 Threads_AddActive( Thread );
 826
 827                 #if DEBUG_TRACE_STATE
 828                 Log("Threads_Sleep: %p(%i %s) woken from semaphore", Thread, Thread->TID, Thread->ThreadName);
 829                 #endif
 830                 SHORTREL( &sem->Protector );
 831                 } return -EOK;
 832
 833         case THREAD_STAT_WAITING:
 834                 Warning("Threads_Wake - Waiting threads are not currently supported");
 835                 return -ENOTIMPL;
 836
 837         case THREAD_STAT_DEAD:
 838                 Warning("Threads_Wake - Attempt to wake dead thread (%i)", Thread->TID);
 839                 return -ENOTIMPL;
 840
 841         default:
 842                 Log_Warning("Threads", "Threads_Wake - Unknown process status (%i)", Thread->Status);
 843                 return -EINTERNAL;
 844         }
 845 }
 846
 847 /**
 848  * \brief Wake a thread given the TID
 849  * \param TID   Thread ID to wake
 850  * \return Boolean Faulure (errno)
 851  */
 852 int Threads_WakeTID(tTID TID)
 853 {
 854         tThread *thread = Threads_GetThread(TID);
 855          int    ret;
 856         if(!thread)
 857                 return -ENOENT;
 858         ret = Threads_Wake( thread );
 859         //Log_Debug("Threads", "TID %i woke %i (%p)", Threads_GetTID(), TID, thread);
 860         return ret;
 861 }
 862
 863 void Threads_ToggleTrace(int TID)
 864 {
 865         tThread *thread = Threads_GetThread(TID);
 866         if(!thread)     return ;
 867         thread->bInstrTrace = !thread->bInstrTrace;
 868 }
 869
 870 /**
 871  * \brief Adds a thread to the active queue
 872  */
 873 void Threads_AddActive(tThread *Thread)
 874 {
 875         SHORTLOCK( &glThreadListLock );
 876
 877         if( Thread->Status == THREAD_STAT_ACTIVE ) {
 878                 tThread *cur = Proc_GetCurThread();
 879                 Log_Warning("Threads", "WTF, %p CPU%i %p (%i %s) is adding %p (%i %s) when it is active",
 880                         __builtin_return_address(0),
 881                         GetCPUNum(), cur, cur->TID, cur->ThreadName, Thread, Thread->TID, Thread->ThreadName);
 882                 SHORTREL( &glThreadListLock );
 883                 return ;
 884         }
 885
 886         // Set state
 887         Thread->Status = THREAD_STAT_ACTIVE;
 888 //      Thread->CurCPU = -1;
 889         // Add to active list
 890         {
 891                 #if SCHEDULER_TYPE == SCHED_RR_PRI
 892                 tThreadList     *list = &gaActiveThreads[Thread->Priority];
 893                 #else
 894                 tThreadList     *list = &gActiveThreads;
 895                 #endif
 896                 Threads_int_AddToList( list, Thread );
 897         }
 898
 899         // Update bookkeeping
 900         giNumActiveThreads ++;
 901
 902         #if SCHEDULER_TYPE == SCHED_LOTTERY
 903         {
 904                  int    delta;
 905                 // Only change the ticket count if the thread is un-scheduled
 906                 if(Thread->CurCPU != -1)
 907                         delta = 0;
 908                 else
 909                         delta = caiTICKET_COUNTS[ Thread->Priority ];
 910
 911                 giFreeTickets += delta;
 912                 # if DEBUG_TRACE_TICKETS
 913                 Log("CPU%i %p (%i %s) added, new giFreeTickets = %i [+%i]",
 914                         GetCPUNum(), Thread, Thread->TID, Thread->ThreadName,
 915                         giFreeTickets, delta
 916                         );
 917                 # endif
 918         }
 919         #endif
 920
 921         SHORTREL( &glThreadListLock );
 922 }
 923
 924 /**
 925  * \brief Removes the current thread from the active queue
 926  * \warning This should ONLY be called with the lock held
 927  * \return Current thread pointer
 928  */
 929 tThread *Threads_RemActive(void)
 930 {
 931         giNumActiveThreads --;
 932         return Proc_GetCurThread();
 933 }
 934
 935 /**
 936  * \fn void Threads_SetFaultHandler(Uint Handler)
 937  * \brief Sets the signal handler for a signal
 938  */
 939 void Threads_SetFaultHandler(Uint Handler)
 940 {
 941         //Log_Debug("Threads", "Threads_SetFaultHandler: Handler = %p", Handler);
 942         Proc_GetCurThread()->FaultHandler = Handler;
 943 }
 944
 945 /**
 946  * \fn void Threads_Fault(int Num)
 947  * \brief Calls a fault handler
 948  */
 949 void Threads_Fault(int Num)
 950 {
 951         tThread *thread = Proc_GetCurThread();
 952
 953         if(!thread)     return ;
 954
 955         Log_Log("Threads", "Threads_Fault: thread->FaultHandler = %p", thread->FaultHandler);
 956
 957         switch(thread->FaultHandler)
 958         {
 959         case 0: // Panic?
 960                 Threads_Kill(thread, -1);
 961                 HALT();
 962                 return ;
 963         case 1: // Dump Core?
 964                 Threads_Kill(thread, -1);
 965                 HALT();
 966                 return ;
 967         }
 968
 969         // Double Fault? Oh, F**k
 970         if(thread->CurFaultNum != 0) {
 971                 Log_Warning("Threads", "Threads_Fault: Double fault on %i", thread->TID);
 972                 Threads_Kill(thread, -1);       // For now, just kill
 973                 HALT();
 974         }
 975
 976         thread->CurFaultNum = Num;
 977
 978         Proc_CallFaultHandler(thread);
 979 }
 980
 981 /**
 982  * \fn void Threads_SegFault(tVAddr Addr)
 983  * \brief Called when a Segment Fault occurs
 984  */
 985 void Threads_SegFault(tVAddr Addr)
 986 {
 987         tThread *cur = Proc_GetCurThread();
 988         cur->bInstrTrace = 0;
 989         Log_Warning("Threads", "Thread #%i committed a segfault at address %p", cur->TID, Addr);
 990         MM_DumpTables(0, USER_MAX);
 991         Threads_Fault( 1 );
 992         //Threads_Exit( 0, -1 );
 993 }
 994
 995 // --- Process Structure Access Functions ---
 996 tPGID Threads_GetPGID(void)
 997 {
 998         return Proc_GetCurThread()->Process->PGID;
 999 }
1000 tPID Threads_GetPID(void)
1001 {
1002         return Proc_GetCurThread()->Process->PID;
1003 }
1004 tTID Threads_GetTID(void)
1005 {
1006         return Proc_GetCurThread()->TID;
1007 }
1008 tUID Threads_GetUID(void)
1009 {
1010         return Proc_GetCurThread()->Process->UID;
1011 }
1012 tGID Threads_GetGID(void)
1013 {
1014         return Proc_GetCurThread()->Process->GID;
1015 }
1016
1017 int Threads_SetUID(tUID ID)
1018 {
1019         tThread *t = Proc_GetCurThread();
1020         if( t->Process->UID != 0 ) {
1021                 errno = -EACCES;
1022                 return -1;
1023         }
1024         Log_Debug("Threads", "PID %i's UID set to %i", t->Process->PID, ID);
1025         t->Process->UID = ID;
1026         return 0;
1027 }
1028
1029 int Threads_SetGID(tGID ID)
1030 {
1031         tThread *t = Proc_GetCurThread();
1032         if( t->Process->UID != 0 ) {
1033                 errno = -EACCES;
1034                 return -1;
1035         }
1036         Log_Debug("Threads", "PID %i's GID set to %i", t->Process->PID, ID);
1037         t->Process->GID = ID;
1038         return 0;
1039 }
1040
1041 // --- Per-thread storage ---
1042 int *Threads_GetErrno(void)
1043 {
1044         return &Proc_GetCurThread()->_errno;
1045 }
1046
1047 // --- Configuration ---
1048 int *Threads_GetMaxFD(void)
1049 {
1050         return &Proc_GetCurThread()->Process->MaxFD;
1051 }
1052 char **Threads_GetChroot(void)
1053 {
1054         return &Proc_GetCurThread()->Process->RootDir;
1055 }
1056 char **Threads_GetCWD(void)
1057 {
1058         return &Proc_GetCurThread()->Process->CurrentWorkingDir;
1059 }
1060 // ---
1061
1062 void Threads_int_DumpThread(tThread *thread)
1063 {
1064         Log(" %p %i (%i) - %s (CPU %i) - %i (%s)",
1065                 thread, thread->TID, thread->Process->PID, thread->ThreadName, thread->CurCPU,
1066                 thread->Status, casTHREAD_STAT[thread->Status]
1067                 );
1068         switch(thread->Status)
1069         {
1070         case THREAD_STAT_MUTEXSLEEP:
1071                 Log("  Mutex Pointer: %p", thread->WaitPointer);
1072                 break;
1073         case THREAD_STAT_SEMAPHORESLEEP:
1074                 Log("  Semaphore Pointer: %p", thread->WaitPointer);
1075                 Log("  Semaphore Name: %s:%s",
1076                         ((tSemaphore*)thread->WaitPointer)->ModName,
1077                         ((tSemaphore*)thread->WaitPointer)->Name
1078                         );
1079                 break;
1080         case THREAD_STAT_ZOMBIE:
1081                 Log("  Return Status: %i", thread->RetStatus);
1082                 break;
1083         default:        break;
1084         }
1085         Log("  Priority %i, Quantum %i", thread->Priority, thread->Quantum);
1086         Log("  KStack %p", thread->KernelStack);
1087         if( thread->bInstrTrace )
1088                 Log("  Tracing Enabled");
1089         Proc_DumpThreadCPUState(thread);
1090 }
1091
1092 /**
1093  * \fn void Threads_Dump(void)
1094  */
1095 void Threads_DumpActive(void)
1096 {
1097         tThread *thread;
1098         tThreadList     *list;
1099         #if SCHEDULER_TYPE == SCHED_RR_PRI
1100          int    i;
1101         #endif
1102
1103         Log("Active Threads: (%i reported)", giNumActiveThreads);
1104
1105         #if SCHEDULER_TYPE == SCHED_RR_PRI
1106         for( i = 0; i < MIN_PRIORITY+1; i++ )
1107         {
1108                 list = &gaActiveThreads[i];
1109         #else
1110                 list = &gActiveThreads;
1111         #endif
1112                 for(thread=list->Head;thread;thread=thread->Next)
1113                 {
1114                         Threads_int_DumpThread(thread);
1115                         if(thread->Status != THREAD_STAT_ACTIVE)
1116                                 Log("  ERROR State (%i) != THREAD_STAT_ACTIVE (%i)",
1117                                         thread->Status, THREAD_STAT_ACTIVE);
1118                 }
1119
1120         #if SCHEDULER_TYPE == SCHED_RR_PRI
1121         }
1122         #endif
1123 }
1124
1125 /**
1126  * \fn void Threads_Dump(void)
1127  * \brief Dumps a list of currently running threads
1128  */
1129 void Threads_Dump(void)
1130 {
1131         tThread *thread;
1132
1133         Log("--- Thread Dump ---");
1134         Threads_DumpActive();
1135
1136         Log("All Threads:");
1137         for(thread=gAllThreads;thread;thread=thread->GlobalNext)
1138         {
1139                 Threads_int_DumpThread(thread);
1140         }
1141 }
1142
1143 /**
1144  * \brief Gets the next thread to run
1145  * \param CPU   Current CPU
1146  * \param Last  The thread the CPU was running
1147  */
1148 tThread *Threads_GetNextToRun(int CPU, tThread *Last)
1149 {
1150         tThread *thread;
1151
1152         // If this CPU has the lock, we must let it complete
1153         if( CPU_HAS_LOCK( &glThreadListLock ) )
1154                 return Last;
1155
1156         // Don't change threads if the current CPU has switches disabled
1157         if( gaThreads_NoTaskSwitch[CPU] )
1158                 return Last;
1159
1160         // Lock thread list
1161         SHORTLOCK( &glThreadListLock );
1162
1163         // Make sure the current (well, old) thread is marked as de-scheduled
1164         if(Last)        Last->CurCPU = -1;
1165
1166         // No active threads, just take a nap
1167         if(giNumActiveThreads == 0) {
1168                 SHORTREL( &glThreadListLock );
1169                 #if DEBUG_TRACE_TICKETS
1170                 Log("No active threads");
1171                 #endif
1172                 return NULL;
1173         }
1174
1175         #if 0
1176         #if SCHEDULER_TYPE != SCHED_RR_PRI
1177         // Special case: 1 thread
1178         if(giNumActiveThreads == 1) {
1179                 if( gActiveThreads.Head->CurCPU == -1 )
1180                         gActiveThreads.Head->CurCPU = CPU;
1181
1182                 SHORTREL( &glThreadListLock );
1183
1184                 if( gActiveThreads.Head->CurCPU == CPU )
1185                         return gActiveThreads.Head;
1186
1187                 return NULL;    // CPU has nothing to do
1188         }
1189         #endif
1190         #endif
1191
1192         // Allow the old thread to be scheduled again
1193         if( Last ) {
1194                 if( Last->Status == THREAD_STAT_ACTIVE ) {
1195                         tThreadList     *list;
1196                         #if SCHEDULER_TYPE == SCHED_LOTTERY
1197                         giFreeTickets += caiTICKET_COUNTS[ Last->Priority ];
1198                         # if DEBUG_TRACE_TICKETS
1199                         LogF("Log: CPU%i released %p (%i %s) into the pool (%i [+%i] tickets in pool)\n",
1200                                 CPU, Last, Last->TID, Last->ThreadName, giFreeTickets,
1201                                 caiTICKET_COUNTS[ Last->Priority ]);
1202                         # endif
1203                         #endif
1204
1205                         #if SCHEDULER_TYPE == SCHED_RR_PRI
1206                         list = &gaActiveThreads[ Last->Priority ];
1207                         #else
1208                         list = &gActiveThreads;
1209                         #endif
1210                         // Add to end of list
1211                         Threads_int_AddToList( list, Last );
1212                 }
1213                 #if SCHEDULER_TYPE == SCHED_LOTTERY && DEBUG_TRACE_TICKETS
1214                 else
1215                         LogF("Log: CPU%i released %p (%i %s)->Status = %i (Released,not in pool)\n",
1216                                 CPU, Last, Last->TID, Last->ThreadName, Last->Status);
1217                 #endif
1218                 Last->CurCPU = -1;
1219         }
1220
1221         // ---
1222         // Lottery Scheduler
1223         // ---
1224         #if SCHEDULER_TYPE == SCHED_LOTTERY
1225         {
1226                  int    ticket, number;
1227                 # if 1
1228                 number = 0;
1229                 for(thread = gActiveThreads.Head; thread; thread = thread->Next)
1230                 {
1231                         if(thread->Status != THREAD_STAT_ACTIVE)
1232                                 Panic("Bookkeeping fail - %p %i(%s) is on the active queue with a status of %i",
1233                                         thread, thread->TID, thread->ThreadName, thread->Status);
1234                         if(thread->Next == thread) {
1235                                 Panic("Bookkeeping fail - %p %i(%s) loops back on itself",
1236                                         thread, thread->TID, thread->ThreadName, thread->Status);
1237                         }
1238                         number += caiTICKET_COUNTS[ thread->Priority ];
1239                 }
1240                 if(number != giFreeTickets) {
1241                         Panic("Bookkeeping fail (giFreeTickets(%i) != number(%i)) - CPU%i",
1242                                 giFreeTickets, number, CPU);
1243                 }
1244                 # endif
1245
1246                 // No free tickets (all tasks delegated to cores)
1247                 if( giFreeTickets == 0 ) {
1248                         SHORTREL(&glThreadListLock);
1249                         return NULL;
1250                 }
1251
1252                 // Get the ticket number
1253                 ticket = number = rand() % giFreeTickets;
1254
1255                 // Find the next thread
1256                 for(thread = gActiveThreads.Head; thread; prev = thread, thread = thread->Next )
1257                 {
1258                         if( caiTICKET_COUNTS[ thread->Priority ] > number)      break;
1259                         number -= caiTICKET_COUNTS[ thread->Priority ];
1260                 }
1261
1262                 // If we didn't find a thread, something went wrong
1263                 if(thread == NULL)
1264                 {
1265                         number = 0;
1266                         for(thread=gActiveThreads;thread;thread=thread->Next) {
1267                                 if(thread->CurCPU >= 0) continue;
1268                                 number += caiTICKET_COUNTS[ thread->Priority ];
1269                         }
1270                         Panic("Bookeeping Failed - giFreeTickets(%i) > true count (%i)",
1271                                 giFreeTickets, number);
1272                 }
1273
1274                 // Remove
1275                 if(prev)
1276                         prev->Next = thread->Next;
1277                 else
1278                         gActiveThreads.Head = thread->Next;
1279                 if(!thread->Next)
1280                         gActiveThreads.Tail = prev;
1281
1282                 giFreeTickets -= caiTICKET_COUNTS[ thread->Priority ];
1283                 # if DEBUG_TRACE_TICKETS
1284                 LogF("Log: CPU%i allocated %p (%i %s), (%i [-%i] tickets in pool), \n",
1285                         CPU, thread, thread->TID, thread->ThreadName,
1286                         giFreeTickets, caiTICKET_COUNTS[ thread->Priority ]);
1287                 # endif
1288         }
1289
1290         // ---
1291         // Priority based round robin scheduler
1292         // ---
1293         #elif SCHEDULER_TYPE == SCHED_RR_PRI
1294         {
1295                  int    i;
1296                 thread = NULL;
1297                 for( i = 0; i < MIN_PRIORITY + 1; i ++ )
1298                 {
1299                         if( !gaActiveThreads[i].Head )
1300                                 continue ;
1301
1302                         thread = gaActiveThreads[i].Head;
1303
1304                         // Remove from head
1305                         gaActiveThreads[i].Head = thread->Next;
1306                         if(!thread->Next)
1307                                 gaActiveThreads[i].Tail = NULL;
1308                         thread->Next = NULL;
1309                         break;
1310                 }
1311
1312                 // Anything to do?
1313                 if( !thread ) {
1314                         SHORTREL(&glThreadListLock);
1315                         return NULL;
1316                 }
1317                 if( thread->Status != THREAD_STAT_ACTIVE ) {
1318                         LogF("Oops, Thread %i (%s) is not active\n", thread->TID, thread->ThreadName);
1319                 }
1320         }
1321         #elif SCHEDULER_TYPE == SCHED_RR_SIM
1322         {
1323                 // Get the next thread off the list
1324                 thread = gActiveThreads.Head;
1325                 gActiveThreads.Head = thread->Next;
1326                 if(!thread->Next)
1327                         gaActiveThreads.Tail = NULL;
1328                 thread->Next = NULL;
1329
1330                 // Anything to do?
1331                 if( !thread ) {
1332                         SHORTREL(&glThreadListLock);
1333                         return NULL;
1334                 }
1335         }
1336         #else
1337         # error "Unimplemented scheduling algorithm"
1338         #endif
1339
1340         // Make the new thread non-schedulable
1341         thread->CurCPU = CPU;
1342         thread->Remaining = thread->Quantum;
1343
1344         SHORTREL( &glThreadListLock );
1345
1346         return thread;
1347 }
1348
1349 // === EXPORTS ===
1350 EXPORT(Threads_GetUID);
1351 EXPORT(Threads_GetGID);