castForeignPtr,
newConcForeignPtr,
addForeignPtrConcFinalizer,
+ finalizeForeignPtr
) where
import Control.Monad ( sequence_ )
return fObj
mallocForeignPtr :: Storable a => IO (ForeignPtr a)
--- ^ allocates some memory and returns a ForeignPtr to it. The memory
--- will be released automatically when the ForeignPtr is discarded.
+-- ^ Allocate some memory and return a 'ForeignPtr' to it. The memory
+-- will be released automatically when the 'ForeignPtr' is discarded.
--
--- @mallocForeignPtr@ is equivalent to
+-- 'mallocForeignPtr' is equivalent to
--
--- > do { p <- malloc; newForeignPtr p free }
+-- > do { p <- malloc; newForeignPtr finalizerFree p }
--
--- although it may be implemented differently internally. You may not
+-- although it may be implemented differently internally: you may not
-- assume that the memory returned by 'mallocForeignPtr' has been
--- allocated with C's @malloc()@.
+-- allocated with 'Foreign.Marshal.Alloc.malloc'.
mallocForeignPtr = doMalloc undefined
where doMalloc :: Storable a => a -> IO (ForeignPtr a)
doMalloc a = do
}
where (I# size) = sizeOf a
--- | similar to 'mallocForeignPtr', except that the size of the memory required
--- is given explicitly as a number of bytes.
+-- | This function is similar to 'mallocForeignPtr', except that the
+-- size of the memory required is given explicitly as a number of bytes.
mallocForeignPtrBytes :: Int -> IO (ForeignPtr a)
mallocForeignPtrBytes (I# size) = do
r <- newIORef []
-- is an arbitrary @IO@ action. When it is invoked, the finalizer
-- will run in a new thread.
--
+-- NB. Be very careful with these finalizers. One common trap is that
+-- if a finalizer references another finalized value, it does not
+-- prevent that value from being finalized. In particular, 'Handle's
+-- are finalized objects, so a finalizer should not refer to a 'Handle'
+-- (including @stdout@, @stdin@ or @stderr@).
+--
addForeignPtrConcFinalizer f@(ForeignPtr fo r) finalizer = do
fs <- readIORef r
writeIORef r (finalizer : fs)
if (null fs)
then IO $ \s ->
let p = unsafeForeignPtrToPtr f in
- case mkWeak# fo () (foreignPtrFinalizer r p) s of
+ case mkWeak# fo () (do foreignPtrFinalizer r p
+ touchPinnedByteArray# fo) s of
(# s1, w #) -> (# s1, () #)
else return ()
case mkForeignObj# obj s# of
(# s1#, fo# #) -> (# s1#, ForeignPtr fo# r #)
+touchPinnedByteArray# :: MutableByteArray# RealWorld -> IO ()
+touchPinnedByteArray# ba# = IO $ \s -> case touch# ba# s of s -> (# s, () #)
+
touchForeignPtr :: ForeignPtr a -> IO ()
-- ^This function ensures that the foreign object in
-- question is alive at the given place in the sequence of IO
touchForeignPtr (ForeignPtr fo r)
= IO $ \s -> case touch# fo s of s -> (# s, () #)
touchForeignPtr (MallocPtr fo r)
- = IO $ \s -> case touch# fo s of s -> (# s, () #)
+ = touchPinnedByteArray# fo
unsafeForeignPtrToPtr :: ForeignPtr a -> Ptr a
-- ^This function extracts the pointer component of a foreign
-- pointer. This is a potentially dangerous operations, as if the
-- argument to 'unsafeForeignPtrToPtr' is the last usage
--- occurence of the given foreign pointer, then its finaliser(s) will
+-- occurrence of the given foreign pointer, then its finaliser(s) will
-- be run, which potentially invalidates the plain pointer just
-- obtained. Hence, 'touchForeignPtr' must be used
-- wherever it has to be guaranteed that the pointer lives on - i.e.,
-- ^This function casts a 'ForeignPtr'
-- parameterised by one type into another type.
castForeignPtr f = unsafeCoerce# f
+
+-- | Causes a the finalizers associated with a foreign pointer to be run
+-- immediately.
+finalizeForeignPtr :: ForeignPtr a -> IO ()
+finalizeForeignPtr foreignPtr = do
+ finalizers <- readIORef refFinalizers
+ sequence_ finalizers
+ writeIORef refFinalizers []
+ where
+ refFinalizers = case foreignPtr of
+ (ForeignPtr _ ref) -> ref
+ (MallocPtr _ ref) -> ref
projects / ghc-base.git / blobdiff