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                 // NOTE: Race condition - Other child dies, desired child dies, first death is 'lost'
 489                 while( (ret = Threads_WaitTID(-1, Status)) != TID )
 490                 {
 491                         if( ret == -1 )
 492                                 break;
 493                 }
 494                 return ret;
 495         }
 496
 497         return -1;
 498 }
 499
 500 /**
 501  * \brief Gets a thread given its TID
 502  * \param TID   Thread ID
 503  * \return Thread pointer
 504  */
 505 tThread *Threads_GetThread(Uint TID)
 506 {
 507         tThread *thread;
 508
 509         // Search global list
 510         for( thread = gAllThreads; thread; thread = thread->GlobalNext )
 511         {
 512                 if(thread->TID == TID)
 513                         return thread;
 514         }
 515
 516         Log_Notice("Threads", "Unable to find TID %i on main list\n", TID);
 517
 518         return NULL;
 519 }
 520
 521 /**
 522  * \brief Deletes an entry from a list
 523  * \param List  Pointer to the list head
 524  * \param Thread        Thread to find
 525  * \return \a Thread
 526  */
 527 tThread *Threads_int_DelFromQueue(tThreadList *List, tThread *Thread)
 528 {
 529         tThread *ret, *prev = NULL;
 530
 531         for(ret = List->Head;
 532                 ret && ret != Thread;
 533                 prev = ret, ret = ret->Next
 534                 );
 535
 536         // Is the thread on the list
 537         if(!ret) {
 538                 //LogF("%p(%s) is not on list %p\n", Thread, Thread->ThreadName, List);
 539                 return NULL;
 540         }
 541
 542         if( !prev ) {
 543                 List->Head = Thread->Next;
 544                 //LogF("%p(%s) removed from head of %p\n", Thread, Thread->ThreadName, List);
 545         }
 546         else {
 547                 prev->Next = Thread->Next;
 548                 //LogF("%p(%s) removed from %p (prev=%p)\n", Thread, Thread->ThreadName, List, prev);
 549         }
 550         if( Thread->Next == NULL )
 551                 List->Tail = prev;
 552
 553         return Thread;
 554 }
 555
 556 void Threads_int_AddToList(tThreadList *List, tThread *Thread)
 557 {
 558         if( List->Head )
 559                 List->Tail->Next = Thread;
 560         else
 561                 List->Head = Thread;
 562         List->Tail = Thread;
 563         Thread->Next = NULL;
 564 }
 565
 566 /**
 567  * \brief Exit the current process (or another?)
 568  * \param TID   Thread ID to kill
 569  * \param Status        Exit status
 570  */
 571 void Threads_Exit(int TID, int Status)
 572 {
 573         if( TID == 0 )
 574                 Threads_Kill( Proc_GetCurThread(), (Uint)Status & 0xFF );
 575         else
 576                 Threads_Kill( Threads_GetThread(TID), (Uint)Status & 0xFF );
 577
 578         // Halt forever, just in case
 579         for(;;) HALT();
 580 }
 581
 582 /**
 583  * \fn void Threads_Kill(tThread *Thread, int Status)
 584  * \brief Kill a thread
 585  * \param Thread        Thread to kill
 586  * \param Status        Status code to return to the parent
 587  */
 588 void Threads_Kill(tThread *Thread, int Status)
 589 {
 590         tMsg    *msg;
 591          int    isCurThread = Thread == Proc_GetCurThread();
 592
 593         // TODO: Disown all children?
 594         #if 1
 595         {
 596                 tThread *child;
 597                 // TODO: I should keep a .Children list
 598                 for(child = gAllThreads;
 599                         child;
 600                         child = child->GlobalNext)
 601                 {
 602                         if(child->Parent == Thread)
 603                                 child->Parent = &gThreadZero;
 604                 }
 605         }
 606         #endif
 607
 608         ///\note Double lock is needed due to overlap of lock areas
 609
 610         // Lock thread (stop us recieving messages)
 611         SHORTLOCK( &Thread->IsLocked );
 612
 613         // Clear Message Queue
 614         while( Thread->Messages )
 615         {
 616                 msg = Thread->Messages->Next;
 617                 free( Thread->Messages );
 618                 Thread->Messages = msg;
 619         }
 620
 621         // Lock thread list
 622         SHORTLOCK( &glThreadListLock );
 623
 624         switch(Thread->Status)
 625         {
 626         case THREAD_STAT_PREINIT:       // Only on main list
 627                 break;
 628
 629         // Currently active thread
 630         case THREAD_STAT_ACTIVE:
 631                 if( Thread != Proc_GetCurThread() )
 632                 {
 633                         #if SCHEDULER_TYPE == SCHED_RR_PRI
 634                         tThreadList     *list = &gaActiveThreads[Thread->Priority];
 635                         #else
 636                         tThreadList     *list = &gActiveThreads;
 637                         #endif
 638                         if( Threads_int_DelFromQueue( list, Thread ) )
 639                         {
 640                         }
 641                         else
 642                         {
 643                                 Log_Warning("Threads",
 644                                         "Threads_Kill - Thread %p(%i,%s) marked as active, but not on list",
 645                                         Thread, Thread->TID, Thread->ThreadName
 646                                         );
 647                         }
 648                         #if SCHEDULER_TYPE == SCHED_LOTTERY
 649                         giFreeTickets -= caiTICKET_COUNTS[ Thread->Priority ];
 650                         #endif
 651                 }
 652                 // Ensure that we are not rescheduled
 653                 Thread->Remaining = 0;  // Clear Remaining Quantum
 654                 Thread->Quantum = 0;    // Clear Quantum to indicate dead thread
 655
 656                 // Update bookkeeping
 657                 giNumActiveThreads --;
 658                 break;
 659         // Kill it while it sleeps!
 660         case THREAD_STAT_SLEEPING:
 661                 if( !Threads_int_DelFromQueue( &gSleepingThreads, Thread ) )
 662                 {
 663                         Log_Warning("Threads",
 664                                 "Threads_Kill - Thread %p(%i,%s) marked as sleeping, but not on list",
 665                                 Thread, Thread->TID, Thread->ThreadName
 666                                 );
 667                 }
 668                 break;
 669
 670         // Brains!... You cannot kill something that is already dead
 671         case THREAD_STAT_ZOMBIE:
 672                 Log_Warning("Threads", "Threads_Kill - Thread %p(%i,%s) is undead, you cannot kill it",
 673                         Thread, Thread->TID, Thread->ThreadName);
 674                 SHORTREL( &glThreadListLock );
 675                 SHORTREL( &Thread->IsLocked );
 676                 return ;
 677
 678         default:
 679                 Log_Warning("Threads", "Threads_Kill - BUG Un-checked status (%i)",
 680                         Thread->Status);
 681                 break;
 682         }
 683
 684         // Save exit status
 685         Thread->RetStatus = Status;
 686
 687         SHORTREL( &Thread->IsLocked );
 688
 689         Thread->Status = THREAD_STAT_ZOMBIE;
 690         SHORTREL( &glThreadListLock );
 691         // TODO: It's possible that we could be timer-preempted here, should disable that... somehow
 692         Mutex_Acquire( &Thread->Parent->DeadChildLock );        // released by parent
 693         Thread->Parent->LastDeadChild = Thread;
 694         Threads_PostEvent( Thread->Parent, THREAD_EVENT_DEADCHILD );
 695
 696         Log("Thread %i went *hurk* (%i)", Thread->TID, Status);
 697
 698         // And, reschedule
 699         if(isCurThread)
 700         {
 701                 for( ;; )
 702                         Proc_Reschedule();
 703         }
 704 }
 705
 706 /**
 707  * \brief Yield remainder of the current thread's timeslice
 708  */
 709 void Threads_Yield(void)
 710 {
 711 //      Log("Threads_Yield: by %p", __builtin_return_address(0));
 712         Proc_Reschedule();
 713 }
 714
 715 /**
 716  * \breif Wait for the thread status to not be a specified value
 717  */
 718 void Threads_int_WaitForStatusEnd(enum eThreadStatus Status)
 719 {
 720         tThread *us = Proc_GetCurThread();
 721         ASSERT(Status != THREAD_STAT_ACTIVE);
 722         ASSERT(Status != THREAD_STAT_DEAD);
 723         while( us->Status == Status )
 724         {
 725                 Proc_Reschedule();
 726                 if( us->Status == Status )
 727                         Debug("Thread %p(%i %s) rescheduled while in %s state", casTHREAD_STAT[Status]);
 728         }
 729 }
 730
 731 /**
 732  * \fn void Threads_Sleep(void)
 733  * \brief Take the current process off the run queue
 734  */
 735 void Threads_Sleep(void)
 736 {
 737         tThread *cur = Proc_GetCurThread();
 738
 739         // Acquire Spinlock
 740         SHORTLOCK( &glThreadListLock );
 741
 742         // Don't sleep if there is a message waiting
 743         if( cur->Messages ) {
 744                 SHORTREL( &glThreadListLock );
 745                 return;
 746         }
 747
 748         // Remove us from running queue
 749         Threads_RemActive();
 750         // Mark thread as sleeping
 751         cur->Status = THREAD_STAT_SLEEPING;
 752
 753         // Add to Sleeping List (at the top)
 754         Threads_int_AddToList( &gSleepingThreads, cur );
 755
 756         #if DEBUG_TRACE_STATE
 757         Log("Threads_Sleep: %p (%i %s) sleeping", cur, cur->TID, cur->ThreadName);
 758         #endif
 759
 760         // Release Spinlock
 761         SHORTREL( &glThreadListLock );
 762         Threads_int_WaitForStatusEnd(THREAD_STAT_SLEEPING);
 763 }
 764
 765
 766 /**
 767  * \brief Wakes a sleeping/waiting thread up
 768  * \param Thread        Thread to wake
 769  * \return Boolean Failure (Returns ERRNO)
 770  * \warning This should ONLY be called with task switches disabled
 771  */
 772 int Threads_Wake(tThread *Thread)
 773 {
 774         if(!Thread)
 775                 return -EINVAL;
 776
 777         switch(Thread->Status)
 778         {
 779         case THREAD_STAT_ACTIVE:
 780                 Log("Threads_Wake - Waking awake thread (%i)", Thread->TID);
 781                 return -EALREADY;
 782
 783         case THREAD_STAT_SLEEPING:
 784                 // Remove from sleeping queue
 785                 SHORTLOCK( &glThreadListLock );
 786                 Threads_int_DelFromQueue(&gSleepingThreads, Thread);
 787                 SHORTREL( &glThreadListLock );
 788
 789                 Threads_AddActive( Thread );
 790
 791                 #if DEBUG_TRACE_STATE
 792                 Log("Threads_Sleep: %p (%i %s) woken", Thread, Thread->TID, Thread->ThreadName);
 793                 #endif
 794                 return -EOK;
 795
 796         case THREAD_STAT_SEMAPHORESLEEP: {
 797                 tSemaphore      *sem;
 798                 tThread *th, *prev=NULL;
 799
 800                 sem = Thread->WaitPointer;
 801
 802                 SHORTLOCK( &sem->Protector );
 803
 804                 // Remove from sleeping queue
 805                 for( th = sem->Waiting; th; prev = th, th = th->Next )
 806                         if( th == Thread )      break;
 807                 if( th )
 808                 {
 809                         if(prev)
 810                                 prev->Next = Thread->Next;
 811                         else
 812                                 sem->Waiting = Thread->Next;
 813                         if(sem->LastWaiting == Thread)
 814                                 sem->LastWaiting = prev;
 815                 }
 816                 else
 817                 {
 818                         prev = NULL;
 819                         for( th = sem->Signaling; th; prev = th, th = th->Next )
 820                                 if( th == Thread )      break;
 821                         if( !th ) {
 822                                 Log_Warning("Threads", "Thread %p(%i %s) is not on semaphore %p(%s:%s)",
 823                                         Thread, Thread->TID, Thread->ThreadName,
 824                                         sem, sem->ModName, sem->Name);
 825                                 return -EINTERNAL;
 826                         }
 827
 828                         if(prev)
 829                                 prev->Next = Thread->Next;
 830                         else
 831                                 sem->Signaling = Thread->Next;
 832                         if(sem->LastSignaling == Thread)
 833                                 sem->LastSignaling = prev;
 834                 }
 835
 836                 Thread->RetStatus = 0;  // It didn't get anything
 837                 Threads_AddActive( Thread );
 838
 839                 #if DEBUG_TRACE_STATE
 840                 Log("Threads_Sleep: %p(%i %s) woken from semaphore", Thread, Thread->TID, Thread->ThreadName);
 841                 #endif
 842                 SHORTREL( &sem->Protector );
 843                 } return -EOK;
 844
 845         case THREAD_STAT_WAITING:
 846                 Warning("Threads_Wake - Waiting threads are not currently supported");
 847                 return -ENOTIMPL;
 848
 849         case THREAD_STAT_DEAD:
 850                 Warning("Threads_Wake - Attempt to wake dead thread (%i)", Thread->TID);
 851                 return -ENOTIMPL;
 852
 853         default:
 854                 Log_Warning("Threads", "Threads_Wake - Unknown process status (%i)", Thread->Status);
 855                 return -EINTERNAL;
 856         }
 857 }
 858
 859 /**
 860  * \brief Wake a thread given the TID
 861  * \param TID   Thread ID to wake
 862  * \return Boolean Faulure (errno)
 863  */
 864 int Threads_WakeTID(tTID TID)
 865 {
 866         tThread *thread = Threads_GetThread(TID);
 867          int    ret;
 868         if(!thread)
 869                 return -ENOENT;
 870         ret = Threads_Wake( thread );
 871         //Log_Debug("Threads", "TID %i woke %i (%p)", Threads_GetTID(), TID, thread);
 872         return ret;
 873 }
 874
 875 void Threads_ToggleTrace(int TID)
 876 {
 877         tThread *thread = Threads_GetThread(TID);
 878         if(!thread)     return ;
 879         thread->bInstrTrace = !thread->bInstrTrace;
 880 }
 881
 882 /**
 883  * \brief Adds a thread to the active queue
 884  */
 885 void Threads_AddActive(tThread *Thread)
 886 {
 887         SHORTLOCK( &glThreadListLock );
 888
 889         if( Thread->Status == THREAD_STAT_ACTIVE ) {
 890                 tThread *cur = Proc_GetCurThread();
 891                 Log_Warning("Threads", "WTF, %p CPU%i %p (%i %s) is adding %p (%i %s) when it is active",
 892                         __builtin_return_address(0),
 893                         GetCPUNum(), cur, cur->TID, cur->ThreadName, Thread, Thread->TID, Thread->ThreadName);
 894                 SHORTREL( &glThreadListLock );
 895                 return ;
 896         }
 897
 898         // Set state
 899         Thread->Status = THREAD_STAT_ACTIVE;
 900 //      Thread->CurCPU = -1;
 901         // Add to active list
 902         {
 903                 #if SCHEDULER_TYPE == SCHED_RR_PRI
 904                 tThreadList     *list = &gaActiveThreads[Thread->Priority];
 905                 #else
 906                 tThreadList     *list = &gActiveThreads;
 907                 #endif
 908                 Threads_int_AddToList( list, Thread );
 909         }
 910
 911         // Update bookkeeping
 912         giNumActiveThreads ++;
 913
 914         #if SCHEDULER_TYPE == SCHED_LOTTERY
 915         {
 916                  int    delta;
 917                 // Only change the ticket count if the thread is un-scheduled
 918                 if(Thread->CurCPU != -1)
 919                         delta = 0;
 920                 else
 921                         delta = caiTICKET_COUNTS[ Thread->Priority ];
 922
 923                 giFreeTickets += delta;
 924                 # if DEBUG_TRACE_TICKETS
 925                 Log("CPU%i %p (%i %s) added, new giFreeTickets = %i [+%i]",
 926                         GetCPUNum(), Thread, Thread->TID, Thread->ThreadName,
 927                         giFreeTickets, delta
 928                         );
 929                 # endif
 930         }
 931         #endif
 932
 933         SHORTREL( &glThreadListLock );
 934 }
 935
 936 /**
 937  * \brief Removes the current thread from the active queue
 938  * \warning This should ONLY be called with the lock held
 939  * \return Current thread pointer
 940  */
 941 tThread *Threads_RemActive(void)
 942 {
 943         giNumActiveThreads --;
 944         return Proc_GetCurThread();
 945 }
 946
 947 /**
 948  * \fn void Threads_SetFaultHandler(Uint Handler)
 949  * \brief Sets the signal handler for a signal
 950  */
 951 void Threads_SetFaultHandler(Uint Handler)
 952 {
 953         //Log_Debug("Threads", "Threads_SetFaultHandler: Handler = %p", Handler);
 954         Proc_GetCurThread()->FaultHandler = Handler;
 955 }
 956
 957 /**
 958  * \fn void Threads_Fault(int Num)
 959  * \brief Calls a fault handler
 960  */
 961 void Threads_Fault(int Num)
 962 {
 963         tThread *thread = Proc_GetCurThread();
 964
 965         if(!thread)     return ;
 966
 967         Log_Log("Threads", "Threads_Fault: thread->FaultHandler = %p", thread->FaultHandler);
 968
 969         switch(thread->FaultHandler)
 970         {
 971         case 0: // Panic?
 972                 Threads_Kill(thread, -1);
 973                 HALT();
 974                 return ;
 975         case 1: // Dump Core?
 976                 Threads_Kill(thread, -1);
 977                 HALT();
 978                 return ;
 979         }
 980
 981         // Double Fault? Oh, F**k
 982         if(thread->CurFaultNum != 0) {
 983                 Log_Warning("Threads", "Threads_Fault: Double fault on %i", thread->TID);
 984                 Threads_Kill(thread, -1);       // For now, just kill
 985                 HALT();
 986         }
 987
 988         thread->CurFaultNum = Num;
 989
 990         Proc_CallFaultHandler(thread);
 991 }
 992
 993 /**
 994  * \fn void Threads_SegFault(tVAddr Addr)
 995  * \brief Called when a Segment Fault occurs
 996  */
 997 void Threads_SegFault(tVAddr Addr)
 998 {
 999         tThread *cur = Proc_GetCurThread();
1000         cur->bInstrTrace = 0;
1001         Log_Warning("Threads", "Thread #%i committed a segfault at address %p", cur->TID, Addr);
1002         MM_DumpTables(0, USER_MAX);
1003         Threads_Fault( 1 );
1004         //Threads_Exit( 0, -1 );
1005 }
1006
1007 // --- Process Structure Access Functions ---
1008 tPGID Threads_GetPGID(void)
1009 {
1010         return Proc_GetCurThread()->Process->PGID;
1011 }
1012 tPID Threads_GetPID(void)
1013 {
1014         return Proc_GetCurThread()->Process->PID;
1015 }
1016 tTID Threads_GetTID(void)
1017 {
1018         return Proc_GetCurThread()->TID;
1019 }
1020 tUID Threads_GetUID(void)
1021 {
1022         return Proc_GetCurThread()->Process->UID;
1023 }
1024 tGID Threads_GetGID(void)
1025 {
1026         return Proc_GetCurThread()->Process->GID;
1027 }
1028
1029 int Threads_SetUID(tUID 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 UID set to %i", t->Process->PID, ID);
1037         t->Process->UID = ID;
1038         return 0;
1039 }
1040
1041 int Threads_SetGID(tGID ID)
1042 {
1043         tThread *t = Proc_GetCurThread();
1044         if( t->Process->UID != 0 ) {
1045                 errno = -EACCES;
1046                 return -1;
1047         }
1048         Log_Debug("Threads", "PID %i's GID set to %i", t->Process->PID, ID);
1049         t->Process->GID = ID;
1050         return 0;
1051 }
1052
1053 // --- Per-thread storage ---
1054 int *Threads_GetErrno(void)
1055 {
1056         return &Proc_GetCurThread()->_errno;
1057 }
1058
1059 // --- Configuration ---
1060 int *Threads_GetMaxFD(void)
1061 {
1062         return &Proc_GetCurThread()->Process->MaxFD;
1063 }
1064 char **Threads_GetChroot(void)
1065 {
1066         return &Proc_GetCurThread()->Process->RootDir;
1067 }
1068 char **Threads_GetCWD(void)
1069 {
1070         return &Proc_GetCurThread()->Process->CurrentWorkingDir;
1071 }
1072 // ---
1073
1074 void Threads_int_DumpThread(tThread *thread)
1075 {
1076         Log(" %p %i (%i) - %s (CPU %i) - %i (%s)",
1077                 thread, thread->TID, thread->Process->PID, thread->ThreadName, thread->CurCPU,
1078                 thread->Status, casTHREAD_STAT[thread->Status]
1079                 );
1080         switch(thread->Status)
1081         {
1082         case THREAD_STAT_MUTEXSLEEP:
1083                 Log("  Mutex Pointer: %p", thread->WaitPointer);
1084                 break;
1085         case THREAD_STAT_SEMAPHORESLEEP:
1086                 Log("  Semaphore Pointer: %p", thread->WaitPointer);
1087                 Log("  Semaphore Name: %s:%s",
1088                         ((tSemaphore*)thread->WaitPointer)->ModName,
1089                         ((tSemaphore*)thread->WaitPointer)->Name
1090                         );
1091                 break;
1092         case THREAD_STAT_ZOMBIE:
1093                 Log("  Return Status: %i", thread->RetStatus);
1094                 break;
1095         default:        break;
1096         }
1097         Log("  Priority %i, Quantum %i", thread->Priority, thread->Quantum);
1098         Log("  KStack %p", thread->KernelStack);
1099         if( thread->bInstrTrace )
1100                 Log("  Tracing Enabled");
1101         Proc_DumpThreadCPUState(thread);
1102 }
1103
1104 /**
1105  * \fn void Threads_Dump(void)
1106  */
1107 void Threads_DumpActive(void)
1108 {
1109         tThread *thread;
1110         tThreadList     *list;
1111         #if SCHEDULER_TYPE == SCHED_RR_PRI
1112          int    i;
1113         #endif
1114
1115         Log("Active Threads: (%i reported)", giNumActiveThreads);
1116
1117         #if SCHEDULER_TYPE == SCHED_RR_PRI
1118         for( i = 0; i < MIN_PRIORITY+1; i++ )
1119         {
1120                 list = &gaActiveThreads[i];
1121         #else
1122                 list = &gActiveThreads;
1123         #endif
1124                 for(thread=list->Head;thread;thread=thread->Next)
1125                 {
1126                         Threads_int_DumpThread(thread);
1127                         if(thread->Status != THREAD_STAT_ACTIVE)
1128                                 Log("  ERROR State (%i) != THREAD_STAT_ACTIVE (%i)",
1129                                         thread->Status, THREAD_STAT_ACTIVE);
1130                 }
1131
1132         #if SCHEDULER_TYPE == SCHED_RR_PRI
1133         }
1134         #endif
1135 }
1136
1137 /**
1138  * \fn void Threads_Dump(void)
1139  * \brief Dumps a list of currently running threads
1140  */
1141 void Threads_Dump(void)
1142 {
1143         tThread *thread;
1144
1145         Log("--- Thread Dump ---");
1146         Threads_DumpActive();
1147
1148         Log("All Threads:");
1149         for(thread=gAllThreads;thread;thread=thread->GlobalNext)
1150         {
1151                 Threads_int_DumpThread(thread);
1152         }
1153 }
1154
1155 /**
1156  * \brief Gets the next thread to run
1157  * \param CPU   Current CPU
1158  * \param Last  The thread the CPU was running
1159  */
1160 tThread *Threads_GetNextToRun(int CPU, tThread *Last)
1161 {
1162         tThread *thread;
1163
1164         // If this CPU has the lock, we must let it complete
1165         if( CPU_HAS_LOCK( &glThreadListLock ) )
1166                 return Last;
1167
1168         // Don't change threads if the current CPU has switches disabled
1169         if( gaThreads_NoTaskSwitch[CPU] )
1170                 return Last;
1171
1172         // Lock thread list
1173         SHORTLOCK( &glThreadListLock );
1174
1175         // Make sure the current (well, old) thread is marked as de-scheduled
1176         if(Last)        Last->CurCPU = -1;
1177
1178         // No active threads, just take a nap
1179         if(giNumActiveThreads == 0) {
1180                 SHORTREL( &glThreadListLock );
1181                 #if DEBUG_TRACE_TICKETS
1182                 Log("No active threads");
1183                 #endif
1184                 return NULL;
1185         }
1186
1187         #if 0
1188         #if SCHEDULER_TYPE != SCHED_RR_PRI
1189         // Special case: 1 thread
1190         if(giNumActiveThreads == 1) {
1191                 if( gActiveThreads.Head->CurCPU == -1 )
1192                         gActiveThreads.Head->CurCPU = CPU;
1193
1194                 SHORTREL( &glThreadListLock );
1195
1196                 if( gActiveThreads.Head->CurCPU == CPU )
1197                         return gActiveThreads.Head;
1198
1199                 return NULL;    // CPU has nothing to do
1200         }
1201         #endif
1202         #endif
1203
1204         // Allow the old thread to be scheduled again
1205         if( Last ) {
1206                 if( Last->Status == THREAD_STAT_ACTIVE ) {
1207                         tThreadList     *list;
1208                         #if SCHEDULER_TYPE == SCHED_LOTTERY
1209                         giFreeTickets += caiTICKET_COUNTS[ Last->Priority ];
1210                         # if DEBUG_TRACE_TICKETS
1211                         LogF("Log: CPU%i released %p (%i %s) into the pool (%i [+%i] tickets in pool)\n",
1212                                 CPU, Last, Last->TID, Last->ThreadName, giFreeTickets,
1213                                 caiTICKET_COUNTS[ Last->Priority ]);
1214                         # endif
1215                         #endif
1216
1217                         #if SCHEDULER_TYPE == SCHED_RR_PRI
1218                         list = &gaActiveThreads[ Last->Priority ];
1219                         #else
1220                         list = &gActiveThreads;
1221                         #endif
1222                         // Add to end of list
1223                         Threads_int_AddToList( list, Last );
1224                 }
1225                 #if SCHEDULER_TYPE == SCHED_LOTTERY && DEBUG_TRACE_TICKETS
1226                 else
1227                         LogF("Log: CPU%i released %p (%i %s)->Status = %i (Released,not in pool)\n",
1228                                 CPU, Last, Last->TID, Last->ThreadName, Last->Status);
1229                 #endif
1230                 Last->CurCPU = -1;
1231         }
1232
1233         // ---
1234         // Lottery Scheduler
1235         // ---
1236         #if SCHEDULER_TYPE == SCHED_LOTTERY
1237         {
1238                  int    ticket, number;
1239                 # if 1
1240                 number = 0;
1241                 for(thread = gActiveThreads.Head; thread; thread = thread->Next)
1242                 {
1243                         if(thread->Status != THREAD_STAT_ACTIVE)
1244                                 Panic("Bookkeeping fail - %p %i(%s) is on the active queue with a status of %i",
1245                                         thread, thread->TID, thread->ThreadName, thread->Status);
1246                         if(thread->Next == thread) {
1247                                 Panic("Bookkeeping fail - %p %i(%s) loops back on itself",
1248                                         thread, thread->TID, thread->ThreadName, thread->Status);
1249                         }
1250                         number += caiTICKET_COUNTS[ thread->Priority ];
1251                 }
1252                 if(number != giFreeTickets) {
1253                         Panic("Bookkeeping fail (giFreeTickets(%i) != number(%i)) - CPU%i",
1254                                 giFreeTickets, number, CPU);
1255                 }
1256                 # endif
1257
1258                 // No free tickets (all tasks delegated to cores)
1259                 if( giFreeTickets == 0 ) {
1260                         SHORTREL(&glThreadListLock);
1261                         return NULL;
1262                 }
1263
1264                 // Get the ticket number
1265                 ticket = number = rand() % giFreeTickets;
1266
1267                 // Find the next thread
1268                 for(thread = gActiveThreads.Head; thread; prev = thread, thread = thread->Next )
1269                 {
1270                         if( caiTICKET_COUNTS[ thread->Priority ] > number)      break;
1271                         number -= caiTICKET_COUNTS[ thread->Priority ];
1272                 }
1273
1274                 // If we didn't find a thread, something went wrong
1275                 if(thread == NULL)
1276                 {
1277                         number = 0;
1278                         for(thread=gActiveThreads;thread;thread=thread->Next) {
1279                                 if(thread->CurCPU >= 0) continue;
1280                                 number += caiTICKET_COUNTS[ thread->Priority ];
1281                         }
1282                         Panic("Bookeeping Failed - giFreeTickets(%i) > true count (%i)",
1283                                 giFreeTickets, number);
1284                 }
1285
1286                 // Remove
1287                 if(prev)
1288                         prev->Next = thread->Next;
1289                 else
1290                         gActiveThreads.Head = thread->Next;
1291                 if(!thread->Next)
1292                         gActiveThreads.Tail = prev;
1293
1294                 giFreeTickets -= caiTICKET_COUNTS[ thread->Priority ];
1295                 # if DEBUG_TRACE_TICKETS
1296                 LogF("Log: CPU%i allocated %p (%i %s), (%i [-%i] tickets in pool), \n",
1297                         CPU, thread, thread->TID, thread->ThreadName,
1298                         giFreeTickets, caiTICKET_COUNTS[ thread->Priority ]);
1299                 # endif
1300         }
1301
1302         // ---
1303         // Priority based round robin scheduler
1304         // ---
1305         #elif SCHEDULER_TYPE == SCHED_RR_PRI
1306         {
1307                  int    i;
1308                 thread = NULL;
1309                 for( i = 0; i < MIN_PRIORITY + 1; i ++ )
1310                 {
1311                         if( !gaActiveThreads[i].Head )
1312                                 continue ;
1313
1314                         thread = gaActiveThreads[i].Head;
1315
1316                         // Remove from head
1317                         gaActiveThreads[i].Head = thread->Next;
1318                         if(!thread->Next)
1319                                 gaActiveThreads[i].Tail = NULL;
1320                         thread->Next = NULL;
1321                         break;
1322                 }
1323
1324                 // Anything to do?
1325                 if( !thread ) {
1326                         SHORTREL(&glThreadListLock);
1327                         return NULL;
1328                 }
1329                 if( thread->Status != THREAD_STAT_ACTIVE ) {
1330                         LogF("Oops, Thread %i (%s) is not active\n", thread->TID, thread->ThreadName);
1331                 }
1332         }
1333         #elif SCHEDULER_TYPE == SCHED_RR_SIM
1334         {
1335                 // Get the next thread off the list
1336                 thread = gActiveThreads.Head;
1337                 gActiveThreads.Head = thread->Next;
1338                 if(!thread->Next)
1339                         gaActiveThreads.Tail = NULL;
1340                 thread->Next = NULL;
1341
1342                 // Anything to do?
1343                 if( !thread ) {
1344                         SHORTREL(&glThreadListLock);
1345                         return NULL;
1346                 }
1347         }
1348         #else
1349         # error "Unimplemented scheduling algorithm"
1350         #endif
1351
1352         // Make the new thread non-schedulable
1353         thread->CurCPU = CPU;
1354         thread->Remaining = thread->Quantum;
1355
1356         SHORTREL( &glThreadListLock );
1357
1358         return thread;
1359 }
1360
1361 // === EXPORTS ===
1362 EXPORT(Threads_GetUID);
1363 EXPORT(Threads_GetGID);