{-# LANGUAGE Trustworthy #-}{-# LANGUAGE BangPatterns
 , CPP
 , ExistentialQuantification
 , NoImplicitPrelude
 , RecordWildCards
 , TypeSynonymInstances
 , FlexibleInstances
 #-}-- |-- The event manager supports event notification on fds. Each fd may-- have multiple callbacks registered, each listening for a different-- set of events. Registrations may be automatically deactivated after-- the occurrence of an event ("one-shot mode") or active until-- explicitly unregistered.---- If an fd has only one-shot registrations then we use one-shot-- polling if available. Otherwise we use multi-shot polling.moduleGHC.Event.Manager(-- * TypesEventManager -- * Creation,new ,newWith ,newDefaultBackend -- * Running,finished ,loop ,step ,shutdown ,release ,cleanup ,wakeManager -- * State,callbackTableVar ,emControl -- * Registering interest in I/O events,Lifetime (..),Event ,evtRead ,evtWrite ,IOCallback ,FdKey (keyFd),FdData ,registerFd ,unregisterFd_ ,unregisterFd ,closeFd ,closeFd_ )where#include "EventConfig.h"
-------------------------------------------------------------------------- ImportsimportControl.Concurrent.MVar (MVar ,newMVar ,putMVar ,tryPutMVar ,takeMVar ,withMVar )importControl.Exception (onException )importData.Bits ((.&. ))importData.Foldable (forM_ )importData.Functor (void )importData.IORef (IORef ,atomicModifyIORef' ,mkWeakIORef ,newIORef ,readIORef ,writeIORef )importData.Maybe (maybe )importData.OldList (partition )importGHC.Arr (Array ,(!),listArray )importGHC.Base importGHC.Conc.Sync (yield )importGHC.List (filter ,replicate )importGHC.Num (Num (..))importGHC.Real (fromIntegral )importGHC.Show (Show (..))importGHC.Event.Control importGHC.Event.IntTable (IntTable )importGHC.Event.Internal (Backend ,Event ,evtClose ,evtRead ,evtWrite ,Lifetime (..),EventLifetime ,Timeout (..))importGHC.Event.Unique (Unique ,UniqueSource ,newSource ,newUnique )importSystem.Posix.Types (Fd )importqualifiedGHC.Event.IntTable asITimportqualifiedGHC.Event.Internal asI#if defined(HAVE_KQUEUE)
importqualifiedGHC.Event.KQueueasKQueue#elif defined(HAVE_EPOLL)
importqualifiedGHC.Event.EPoll asEPoll#elif defined(HAVE_POLL)
importqualifiedGHC.Event.PollasPoll#else
# error not implemented for this operating system
#endif
-------------------------------------------------------------------------- TypesdataFdData =FdData {fdKey ::{-# UNPACK#-}!FdKey ,fdEvents ::{-# UNPACK#-}!EventLifetime ,_fdCallback ::!IOCallback }-- | A file descriptor registration cookie.dataFdKey =FdKey {keyFd ::{-# UNPACK#-}!Fd ,keyUnique ::{-# UNPACK#-}!Unique }deriving(Eq-- ^ @since 4.4.0.0,Show -- ^ @since 4.4.0.0)-- | Callback invoked on I/O events.typeIOCallback =FdKey ->Event ->IO()dataState =Created |Running |Dying |Releasing |Finished deriving(Eq-- ^ @since 4.4.0.0,Show -- ^ @since 4.4.0.0)-- | The event manager state.dataEventManager =EventManager {emBackend ::!Backend ,emFds ::{-# UNPACK#-}!(Array Int(MVar (IntTable [FdData ]))),emState ::{-# UNPACK#-}!(IORef State ),emUniqueSource ::{-# UNPACK#-}!UniqueSource ,emControl ::{-# UNPACK#-}!Control ,emLock ::{-# UNPACK#-}!(MVar ())}-- must be power of 2callbackArraySize::IntcallbackArraySize =32hashFd::Fd ->InthashFd fd =fromIntegral fd .&. (callbackArraySize -1){-# INLINEhashFd#-}callbackTableVar::EventManager ->Fd ->MVar (IntTable [FdData ])callbackTableVar mgr fd =emFdsmgr !hashFd fd {-# INLINEcallbackTableVar#-}haveOneShot::Bool{-# INLINEhaveOneShot#-}#if defined(darwin_HOST_OS) || defined(ios_HOST_OS)
haveOneShot=False#elif defined(HAVE_EPOLL) || defined(HAVE_KQUEUE)
haveOneShot =True#else
haveOneShot=False#endif
-------------------------------------------------------------------------- CreationhandleControlEvent::EventManager ->Fd ->Event ->IO()handleControlEvent mgr fd _evt =domsg <-readControlMessage (emControlmgr )fd casemsg ofCMsgWakeup ->return ()CMsgDie ->writeIORef (emStatemgr )Finished _->return ()newDefaultBackend::IOBackend #if defined(HAVE_KQUEUE)
newDefaultBackend=KQueue.new#elif defined(HAVE_EPOLL)
newDefaultBackend =EPoll.new #elif defined(HAVE_POLL)
newDefaultBackend=Poll.new#else
newDefaultBackend=errorWithoutStackTrace"no back end for this platform"#endif
-- | Create a new event manager.new::IOEventManager new =newWith =<< newDefaultBackend -- | Create a new 'EventManager' with the given polling backend.newWith::Backend ->IOEventManager newWith be =doiofds <-fmap (listArray (0,callbackArraySize -1))$ replicateM callbackArraySize (newMVar =<< IT.new 8)ctrl <-newControl Falsestate <-newIORef Created us <-newSource _<-mkWeakIORef state $ dost <-atomicModifyIORef' state $ \s ->(Finished ,s )when (st /=Finished )$ doI.delete be closeControl ctrl lockVar <-newMVar ()letmgr =EventManager {emBackend=be ,emFds=iofds ,emState=state ,emUniqueSource=us ,emControl=ctrl ,emLock=lockVar }registerControlFd mgr (controlReadFdctrl )evtRead registerControlFd mgr (wakeupReadFd ctrl )evtRead return mgr wherereplicateM n x =sequence (replicate n x )failOnInvalidFile::String ->Fd ->IOBool->IO()failOnInvalidFile loc fd m =dook <-m when (notok )$ letmsg ="Failed while attempting to modify registration of file "++ show fd ++ " at location "++ loc inerrorWithoutStackTrace msg registerControlFd::EventManager ->Fd ->Event ->IO()registerControlFd mgr fd evs =failOnInvalidFile "registerControlFd"fd $ I.modifyFd (emBackendmgr )fd mempty evs -- | Asynchronously shuts down the event manager, if running.shutdown::EventManager ->IO()shutdown mgr =dostate <-atomicModifyIORef' (emStatemgr )$ \s ->(Dying ,s )when (state ==Running )$ sendDie (emControlmgr )-- | Asynchronously tell the thread executing the event-- manager loop to exit.release::EventManager ->IO()release EventManager {..}=dostate <-atomicModifyIORef' emState $ \s ->(Releasing ,s )when (state ==Running )$ sendWakeup emControl finished::EventManager ->IOBoolfinished mgr =(==Finished )`liftM `readIORef (emStatemgr )cleanup::EventManager ->IO()cleanup EventManager {..}=dowriteIORef emState Finished void $ tryPutMVar emLock ()I.delete emBackend closeControl emControl -------------------------------------------------------------------------- Event loop-- | Start handling events. This function loops until told to stop,-- using 'shutdown'.---- /Note/: This loop can only be run once per 'EventManager', as it-- closes all of its control resources when it finishes.loop::EventManager ->IO()loop mgr @EventManager {..}=dovoid $ takeMVar emLock state <-atomicModifyIORef' emState $ \s ->cases ofCreated ->(Running ,s )Releasing ->(Running ,s )_->(s ,s )casestate ofCreated ->go `onException `cleanup mgr Releasing ->go `onException `cleanup mgr Dying ->cleanup mgr -- While a poll loop is never forked when the event manager is in the-- 'Finished' state, its state could read 'Finished' once the new thread-- actually runs. This is not an error, just an unfortunate race condition-- in Thread.restartPollLoop. See #8235Finished ->return ()_->docleanup mgr errorWithoutStackTrace $ "GHC.Event.Manager.loop: state is already "++ show state wherego =dostate <-step mgr casestate ofRunning ->yield >> go Releasing ->putMVar emLock ()_->cleanup mgr -- | To make a step, we first do a non-blocking poll, in case-- there are already events ready to handle. This improves performance-- because we can make an unsafe foreign C call, thereby avoiding-- forcing the current Task to release the Capability and forcing a context switch.-- If the poll fails to find events, we yield, putting the poll loop thread at-- end of the Haskell run queue. When it comes back around, we do one more-- non-blocking poll, in case we get lucky and have ready events.-- If that also returns no events, then we do a blocking poll.step::EventManager ->IOState step mgr @EventManager {..}=dowaitForIO state <-readIORef emState state `seq`return state wherewaitForIO =don1 <-I.poll emBackend Nothing (onFdEvent mgr )when (n1 <=0)$ doyield n2 <-I.poll emBackend Nothing (onFdEvent mgr )when (n2 <=0)$ do_<-I.poll emBackend (Just Forever )(onFdEvent mgr )return ()-------------------------------------------------------------------------- Registering interest in I/O events-- | Register interest in the given events, without waking the event-- manager thread. The 'Bool' return value indicates whether the-- event manager ought to be woken.---- Note that the event manager is generally implemented in terms of the-- platform's @select@ or @epoll@ system call, which tend to vary in-- what sort of fds are permitted. For instance, waiting on regular files-- is not allowed on many platforms.registerFd_::EventManager ->IOCallback ->Fd ->Event ->Lifetime ->IO(FdKey ,Bool)registerFd_ mgr @(EventManager {..})cb fd evs lt =dou <-newUnique emUniqueSource letfd' =fromIntegral fd reg =FdKey fd u el =I.eventLifetime evs lt !fdd =FdData reg el cb (modify ,ok )<-withMVar (callbackTableVar mgr fd )$ \tbl ->dooldFdd <-IT.insertWith (++ )fd' [fdd ]tbl letprevEvs::EventLifetime prevEvs =maybe mempty eventsOf oldFdd el'::EventLifetime el' =prevEvs `mappend `el caseI.elLifetime el' of-- All registrations want one-shot semantics and this is supportedOneShot |haveOneShot ->dook <-I.modifyFdOnce emBackend fd (I.elEvent el' )ifok thenreturn (False,True)elseIT.reset fd' oldFdd tbl >> return (False,False)-- We don't want or don't support one-shot semantics_->doletmodify =prevEvs /=el' ok <-ifmodify thenletnewEvs =I.elEvent el' oldEvs =I.elEvent prevEvs inI.modifyFd emBackend fd oldEvs newEvs elsereturn Trueifok thenreturn (modify ,True)elseIT.reset fd' oldFdd tbl >> return (False,False)-- this simulates behavior of old IO manager:-- i.e. just call the callback if the registration fails.when (notok )(cb reg evs )return (reg ,modify ){-# INLINEregisterFd_#-}-- | @registerFd mgr cb fd evs lt@ registers interest in the events @evs@-- on the file descriptor @fd@ for lifetime @lt@. @cb@ is called for-- each event that occurs. Returns a cookie that can be handed to-- 'unregisterFd'.registerFd::EventManager ->IOCallback ->Fd ->Event ->Lifetime ->IOFdKey registerFd mgr cb fd evs lt =do(r ,wake )<-registerFd_ mgr cb fd evs lt when wake $ wakeManager mgr return r {-# INLINEregisterFd#-}{-
 Building GHC with parallel IO manager on Mac freezes when
 compiling the dph libraries in the phase 2. As workaround, we
 don't use oneshot and we wake up an IO manager on Mac every time
 when we register an event.
 For more information, please read:
 http://ghc.haskell.org/trac/ghc/ticket/7651
-}-- | Wake up the event manager.wakeManager::EventManager ->IO()#if defined(darwin_HOST_OS) || defined(ios_HOST_OS)
wakeManagermgr=sendWakeup(emControlmgr)#elif defined(HAVE_EPOLL) || defined(HAVE_KQUEUE)
wakeManager _=return ()#else
wakeManagermgr=sendWakeup(emControlmgr)#endif
eventsOf::[FdData ]->EventLifetime eventsOf [fdd ]=fdEventsfdd eventsOffdds =mconcat $ map fdEventsfdds -- | Drop a previous file descriptor registration, without waking the-- event manager thread. The return value indicates whether the event-- manager ought to be woken.unregisterFd_::EventManager ->FdKey ->IOBoolunregisterFd_ mgr @(EventManager {..})(FdKey fd u )=withMVar (callbackTableVar mgr fd )$ \tbl ->doletdropReg =nullToNothing . filter ((/=u ). keyUnique. fdKey)fd' =fromIntegral fd pairEvents::[FdData ]->IO(EventLifetime ,EventLifetime )pairEvents prev =dor <-maybe mempty eventsOf `fmap `IT.lookup fd' tbl return (eventsOf prev ,r )(oldEls ,newEls )<-IT.updateWith dropReg fd' tbl >>= maybe (return (mempty ,mempty ))pairEvents letmodify =oldEls /=newEls when modify $ failOnInvalidFile "unregisterFd_"fd $ caseI.elLifetime newEls ofOneShot |I.elEvent newEls /=mempty ,haveOneShot ->I.modifyFdOnce emBackend fd (I.elEvent newEls )_->I.modifyFd emBackend fd (I.elEvent oldEls )(I.elEvent newEls )return modify -- | Drop a previous file descriptor registration.unregisterFd::EventManager ->FdKey ->IO()unregisterFd mgr reg =dowake <-unregisterFd_ mgr reg when wake $ wakeManager mgr -- | Close a file descriptor in a race-safe way.closeFd::EventManager ->(Fd ->IO())->Fd ->IO()closeFd mgr close fd =dofds <-withMVar (callbackTableVar mgr fd )$ \tbl ->doprev <-IT.delete (fromIntegral fd )tbl caseprev ofNothing ->close fd >> return []Just fds ->doletoldEls =eventsOf fds when (I.elEvent oldEls /=mempty )$ do_<-I.modifyFd (emBackendmgr )fd (I.elEvent oldEls )mempty wakeManager mgr close fd return fds forM_ fds $ \(FdData reg el cb )->cb reg (I.elEvent el `mappend `evtClose )-- | Close a file descriptor in a race-safe way.-- It assumes the caller will update the callback tables and that the caller-- holds the callback table lock for the fd. It must hold this lock because-- this command executes a backend command on the fd.closeFd_::EventManager ->IntTable [FdData ]->Fd ->IO(IO())closeFd_ mgr tbl fd =doprev <-IT.delete (fromIntegral fd )tbl caseprev ofNothing ->return (return ())Just fds ->doletoldEls =eventsOf fds when (oldEls /=mempty )$ do_<-I.modifyFd (emBackendmgr )fd (I.elEvent oldEls )mempty wakeManager mgr return $ forM_ fds $ \(FdData reg el cb )->cb reg (I.elEvent el `mappend `evtClose )-------------------------------------------------------------------------- Utilities-- | Call the callbacks corresponding to the given file descriptor.onFdEvent::EventManager ->Fd ->Event ->IO()onFdEvent mgr fd evs |fd ==controlReadFd(emControlmgr )||fd ==wakeupReadFd (emControlmgr )=handleControlEvent mgr fd evs |otherwise =dofdds <-withMVar (callbackTableVar mgr fd )$ \tbl ->IT.delete (fromIntegral fd )tbl >>= maybe (return [])(selectCallbacks tbl )forM_ fdds $ \(FdData reg _cb )->cb reg evs where-- | Here we look through the list of registrations for the fd of interest-- and sort out which match the events that were triggered. We,---- 1. re-arm the fd as appropriate-- 2. reinsert registrations that weren't triggered and multishot-- registrations-- 3. return a list containing the callbacks that should be invoked.selectCallbacks::IntTable [FdData ]->[FdData ]->IO[FdData ]selectCallbacks tbl fdds =dolet-- figure out which registrations have been triggeredmatches::FdData ->Boolmatches fd' =evs `I.eventIs `I.elEvent (fdEventsfd' )(triggered ,notTriggered )=partition matches fdds -- sort out which registrations we need to retainisMultishot::FdData ->BoolisMultishot fd' =I.elLifetime (fdEventsfd' )==MultiShot saved =notTriggered ++ filter isMultishot triggered savedEls =eventsOf saved allEls =eventsOf fdds -- Reinsert multishot registrations.-- We deleted the table entry for this fd above so we there isn't a preexisting entry_<-IT.insertWith (\__->saved )(fromIntegral fd )saved tbl caseI.elLifetime allEls of-- we previously armed the fd for multiple shots, no need to rearmMultiShot |allEls ==savedEls ->return ()-- either we previously registered for one shot or the-- events of interest have changed, we must re-arm_->caseI.elLifetime savedEls ofOneShot |haveOneShot ->-- if there are no saved events and we registered with one-shot-- semantics then there is no need to re-armunless (OneShot ==I.elLifetime allEls &&mempty ==I.elEvent savedEls )$ dovoid $ I.modifyFdOnce (emBackendmgr )fd (I.elEvent savedEls )_->-- we need to re-arm with multi-shot semanticsvoid $ I.modifyFd (emBackendmgr )fd (I.elEvent allEls )(I.elEvent savedEls )return triggered nullToNothing::[a ]->Maybe [a ]nullToNothing []=Nothing nullToNothingxs @(_:_)=Just xs unless::Monad m =>Bool->m ()->m ()unless p =when (notp )