forkIO,
#ifdef __GLASGOW_HASKELL__
+ forkIOUnmasked,
killThread,
throwTo,
#endif
#ifdef __GLASGOW_HASKELL__
import GHC.Exception
import GHC.Conc ( ThreadId(..), myThreadId, killThread, yield,
- threadDelay, forkIO, childHandler )
+ threadDelay, forkIO, forkIOUnmasked, childHandler )
import qualified GHC.Conc
-import GHC.IOBase ( IO(..) )
-import GHC.IOBase ( unsafeInterleaveIO )
-import GHC.IOBase ( newIORef, readIORef, writeIORef )
+import GHC.IO ( IO(..), unsafeInterleaveIO, unsafeUnmask )
+import GHC.IORef ( newIORef, readIORef, writeIORef )
import GHC.Base
import System.Posix.Types ( Fd )
#ifdef mingw32_HOST_OS
import Foreign.C
import System.IO
-import GHC.Handle
#endif
#endif
forkOS action0
| rtsSupportsBoundThreads = do
mv <- newEmptyMVar
- b <- Exception.blocked
+ b <- Exception.getMaskingState
let
- -- async exceptions are blocked in the child if they are blocked
+ -- async exceptions are masked in the child if they are masked
-- in the parent, as for forkIO (see #1048). forkOS_createThread
- -- creates a thread with exceptions blocked by default.
- action1 | b = action0
- | otherwise = unblock action0
+ -- creates a thread with exceptions masked by default.
+ action1 = case b of
+ Unmasked -> unsafeUnmask action0
+ MaskedInterruptible -> action0
+ MaskedUninterruptible -> uninterruptibleMask_ action0
action_plus = Exception.catch action1 childHandler
if bound
then do
mv <- newEmptyMVar
- forkIO (Exception.try action >>= putMVar mv)
+ b <- blocked
+ _ <- mask $ \restore -> forkIO $
+ Exception.try (if b then action else restore action) >>=
+ putMVar mv
takeMVar mv >>= \ei -> case ei of
Left exception -> Exception.throw (exception :: SomeException)
Right result -> return result
-- and this only works with -threaded.
| threaded = withThread (waitFd fd 0)
| otherwise = case fd of
- 0 -> do hWaitForInput stdin (-1); return ()
+ 0 -> do _ <- hWaitForInput stdin (-1)
+ return ()
-- hWaitForInput does work properly, but we can only
-- do this for stdin since we know its FD.
_ -> error "threadWaitRead requires -threaded on Windows, or use System.IO.hWaitForInput"
withThread :: IO a -> IO a
withThread io = do
m <- newEmptyMVar
- forkIO $ try io >>= putMVar m
+ _ <- mask_ $ forkIO $ try io >>= putMVar m
x <- takeMVar m
case x of
Right a -> return a
waitFd :: Fd -> CInt -> IO ()
waitFd fd write = do
- throwErrnoIfMinus1 "fdReady" $
+ throwErrnoIfMinus1_ "fdReady" $
fdReady (fromIntegral fd) write (fromIntegral iNFINITE) 0
- return ()
iNFINITE :: CInt
iNFINITE = 0xFFFFFFFF -- urgh