}

 /* Declared in rts/IOInterface.h. Used only by the MIO threaded I/O manager on

  * Unix platforms.

  */

 #if defined(IOMGR_ENABLED_SELECT)

         case IO_MANAGER_SELECT:

         {

             tso->block_info.fd = fd;

             appendToIOBlockedQueue(cap, tso);

             return true;

         }

 #endif

 #if defined(IOMGR_ENABLED_POLL)

         case IO_MANAGER_POLL:

             return syncIOWaitReadyPoll(cap, tso, rw, fd);

 #endif

         default:

         {

             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

     switch (iomgr_type) {

 #if defined(IOMGR_ENABLED_SELECT)

         case IO_MANAGER_SELECT:

             removeThreadFromQueue(cap, &cap->iomgr->sleeping_queue, tso);

             break;

 #endif

 void markCapabilityIOManager(evac_fn evac, void *user, Capability *cap);

 /* Several code paths are almost identical between read and write paths. In

  * such cases we use a shared code path with an enum to say which we're doing.

  */

     StgTSO_block_info(CurrentTSO) = reqID;

     ASSERT(StgTSO_why_blocked(CurrentTSO) == NotBlocked::I32);

     ccall appendToIOBlockedQueue(MyCapability() "ptr", CurrentTSO "ptr");

     jump stg_block_async();

     StgTSO_block_info(CurrentTSO) = reqID;

     ASSERT(StgTSO_why_blocked(CurrentTSO) == NotBlocked::I32);

     ccall appendToIOBlockedQueue(MyCapability() "ptr", CurrentTSO "ptr");

     jump stg_block_async();

 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;

     //

     // 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);

 }

   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->blocked_exceptions, c, sep, child_data);

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

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

             traversePushClosure(ts, tso->block_info.closure, c, sep, child_data);

         }

         goto 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:

     thread_(&tso->_link);

     thread_(&tso->global_link);

         thread_(&tso->block_info.closure);

     }

     thread_(&tso->blocked_exceptions);

     thread_(&tso->bq);

     if (tso->label != NULL) {

         markQueuePushClosure_(queue, (StgClosure *) tso->label);

     }

         markQueuePushClosure_(queue, tso->block_info.closure);

     }

 }

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

                                          // lockTSO(), might not happen now

         ASSERT(LOOKS_LIKE_CLOSURE_PTR(tso->block_info.closure));

     }

     ASSERT(LOOKS_LIKE_CLOSURE_PTR(tso->bq));

         evacuate((StgClosure **)&tso->label);

     }

         evacuate(&tso->block_info.closure);

 #if defined(THREADED_RTS)

     // in the THREADED_RTS, block_info.closure must always point to a

     // valid closure, because we assume this in throwTo().  In the

     // BlockedOnRead/BlockedOnWrite) or a time value (BlockedOnDelay)

         ASSERT(tso->block_info.unused == END_TSO_QUEUE);

 #endif

     }

     tso->dirty = gct->failed_to_evac;

                         }

                         // 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;