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