#if defined(IOMGR_ENABLED_SELECT)

         case IO_MANAGER_SELECT:

         {

             tso->block_info.fd = fd;

             appendToIOBlockedQueue(cap, tso);

             return true;

         }

 #endif

         {

             LowResTime target = getDelayTarget(us_delay);

             tso->block_info.target = target;

             insertIntoSleepingQueue(cap, tso, target);

             return true;

         }

 #endif

              * simplifies matters, so set the status to OnDoProc and put the

              * delayed thread on the blocked_queue.

              */

             appendToIOBlockedQueue(cap, tso);

             return true;

         }

 #endif

 uint32_t

 throwToMsg (Capability *cap, MessageThrowTo *msg)

 {

     StgTSO *target = ACQUIRE_LOAD(&msg->target);

     Capability *target_cap;

         return THROWTO_BLOCKED;

     }

     case NotBlocked:

     {

         if ((target->flags & TSO_BLOCKEX) == 0) {

         // we have the MVar, let's check whether the thread

         // is still blocked on the same MVar.

             || target->block_info.mvar != mvar) {

             unlockClosure((StgClosure *)mvar, info);

             goto retry;

         goto retry;

     default:

     }

     barf("throwTo");

 }

 static void

 removeFromQueues(Capability *cap, StgTSO *tso)

 {

   case NotBlocked:

   case ThreadMigrating:

   }

  done:

   appendToRunQueue(cap, tso);

 }

 /* -----------------------------------------------------------------------------

     IF_DEBUG(sanity, checkTSO(tso));

     // wake it up

         appendToRunQueue(cap,tso);

     }

     return tso;

 #endif

     if (ret == ThreadBlocked) {

         if (why_blocked == BlockedOnBlackHole) {

             StgTSO *owner = blackHoleOwner(t->block_info.bh->bh);

             traceEventStopThread(cap, t, eventlogStopStatus(why_blocked),

     //

     // and a is never equal to b given a consistent view of memory.

     //

         if (!stmValidateNestOfTransactions(cap, t -> trec, true)) {

             debugTrace(DEBUG_sched | DEBUG_stm,

                        "trec %p found wasting its time", t);

   tso->block_info.unused = END_TSO_QUEUE;

   if (interruptible) {

   } else {

   }

   // Hand back capability

     tso = incall->suspended_tso;

     incall->suspended_tso = NULL;

     incall->suspended_cap = NULL;

     // we will modify tso->_link

     IF_NONMOVING_WRITE_BARRIER_ENABLED {

         updateRemembSetPushClosure(cap, (StgClosure *)tso->_link);

     }

     tso->_link = END_TSO_QUEUE;

     traceEventRunThread(cap, tso);

     /* Reset blocking status */

     if ((tso->flags & TSO_BLOCKEX) == 0) {

         // avoid locking the TSO if we don't have to

     // The TSO must be on the run queue of the Capability we own, or

     // we must own all Capabilities.

         throwToSingleThreaded(tso->cap,tso,NULL);

     }

 }

 { // for forkProcess only:

   // like deleteThread(), but we delete threads in foreign calls, too.

         tso->what_next = ThreadKilled;

         appendToRunQueue(tso->cap, tso);

     } else {

         deleteThread(tso);

     }

         // Wake up the thread on the Capability it was last on

         cap = tso->cap;

         case BlockedOnMVar:

         case BlockedOnMVarRead:

             /* Called by GC - sched_mutex lock is currently held. */

 unblock:

     // just run the thread now, if the BH is not really available,

     // we'll block again.

     appendToRunQueue(cap,tso);

     // We used to set the context switch flag here, which would

     // trigger a context switch a short time in the future (at the end

     // ThreadMigrating tells the target cap that it needs to be added to

     // the run queue when it receives the MSG_TRY_WAKEUP.

     tso->block_info.unused = END_TSO_QUEUE;

     tso->cap = to;

     tryWakeupThread(from, tso);

 }

     // save why_blocked here, because waking up the thread destroys

     // this information

     ASSERT(why_blocked == BlockedOnMVarRead || why_blocked == BlockedOnMVar);

     ASSERT(tso->block_info.mvar == mvar);

   debugBelch("other threads:\n");

   for (g = 0; g < RtsFlags.GcFlags.generations; g++) {

     for (t = generations[g].threads; t != END_TSO_QUEUE; t = next) {

           printThreadStatus(t);

       }

       next = t->global_link;

         traversePushClosure(ts, (StgClosure *) tso->bq, c, sep, child_data);

         traversePushClosure(ts, (StgClosure *) tso->trec, c, sep, child_data);

         if (IsBlockInfoClosure(why_blocked) && why_blocked != NotBlocked) {

             // The NotBlocked case uses block_info.prev as a TSO back link.

             // Do not follow in that case or we'll get into a loop.

     aiop->notify.tso     = tso;

     aiop->notify_type    = NotifyTSO;

     aiop->live           = &stg_ASYNCIO_LIVE0_closure;

     tso->block_info.aiop = aiop;

     return asyncIOWaitReadyPoll(cap, aiop, rw, fd);

 }

                  * cap because the tso was not on the run queue of any cap and

                  * so is not subject to thread migration.

                  */

                 pushOnRunQueue(cap, tso);

             }

             break;

         }

             break;

         }

         iomgr->sleeping_queue = tso->_link;

         IF_DEBUG(scheduler, debugBelch("Waking up sleeping thread %"

                                        FMT_StgThreadID "\n", tso->id));

         pushOnRunQueue(cap,tso);

         flag = true;

     }

     return flag;

               int fd;

               enum FdState fd_state = RTS_FD_IS_BLOCKING;

               case BlockedOnRead:

                   fd = tso->block_info.fd;

                   IF_DEBUG(scheduler,

                       debugBelch("Waking up blocked thread %" FMT_StgThreadID "\n",

                                  tso->id));

                   pushOnRunQueue(cap,tso);

                   break;

               case RTS_FD_IS_BLOCKING:

                   if (prev == NULL)

     initElemTimeoutQueue(timeout, notify, NotifyTSO, cap->r.rCCCS);

     ASSERT(tso->why_blocked == NotBlocked);

     tso->block_info.timeout = timeout;

     insertTimeoutQueue(&cap->iomgr->timeout_queue, timeout, target);

     switch (timeout->notify_type) {

         case NotifyTSO:

         {

             pushOnRunQueue(cap, tso);

             break;

         }

         case NotifyMVar:

            info == &stg_WHITEHOLE_info); // used to happen due to STM doing

                                          // lockTSO(), might not happen now

     switch (why_blocked) {

     case NotBlocked:

     case BlockedOnMVar:

                         }

                         // Terminates the run queue + this inner for-loop.

                         // For stg_block_async frames (read/write/doProc),

                         // write len and errCode directly to the stack.

                         // For stg_block_noregs frames (delay), nothing

                             tso->stackobj->sp[2] = (W_)errCode;

                         }

                         pushOnRunQueue(&MainCapability, tso);

                         break;

                     }

                     break;

                     break;

                 }

                 prev = tso;