{-# LINE 1 "Data/Memory/MemMap/Posix.hsc" #-}
-----------------------------------------------------------------------------
-- |
-- Module      :  Data.Memory.MemMap.Posix
-- Copyright   :  (c) Vincent Hanquez 2014
-- License     :  BSD-style
--
-- Maintainer  :  Vincent Hanquez
-- Stability   :  provisional
-- Portability :  non-portable (requires POSIX)
--
-- Functions defined by the POSIX standards for manipulating memory maps
--
-- When a function that calls an underlying POSIX function fails, the errno
-- code is converted to an 'IOError' using 'Foreign.C.Error.errnoToIOError'.
-- For a list of which errno codes may be generated, consult the POSIX
-- documentation for the underlying function.
--
-----------------------------------------------------------------------------




{-# LANGUAGE ForeignFunctionInterface #-}
{-# LANGUAGE CPP #-}
module Data.Memory.MemMap.Posix
    ( memoryMap
    , memoryUnmap
    , memoryAdvise
    , memoryLock
    , memoryUnlock
    , memoryProtect
    , memorySync
    -- * Flags types
    , MemoryMapFlag(..)
    , MemoryProtection(..)
    , MemoryAdvice(..)
    , MemorySyncFlag(..)
    -- * system page size
    , sysconfPageSize
    ) where

import System.Posix.Types
import Foreign.Ptr
import Foreign.C.Types
import Foreign.C.Error
import Data.Bits

foreign import ccall unsafe "mmap"
    c_mmap :: Ptr a -> CSize -> CInt -> CInt -> CInt -> COff -> IO (Ptr a)

foreign import ccall unsafe "munmap"
    c_munmap :: Ptr a -> CSize -> IO CInt


{-# LINE 55 "Data/Memory/MemMap/Posix.hsc" #-}
foreign import ccall unsafe "posix_madvise"
    c_madvise :: Ptr a -> CSize -> CInt -> IO CInt

{-# LINE 61 "Data/Memory/MemMap/Posix.hsc" #-}

foreign import ccall unsafe "msync"
    c_msync :: Ptr a -> CSize -> CInt -> IO CInt

foreign import ccall unsafe "mprotect"
    c_mprotect :: Ptr a -> CSize -> CInt -> IO CInt


{-# LINE 69 "Data/Memory/MemMap/Posix.hsc" #-}
foreign import ccall unsafe "mlock"
    c_mlock :: Ptr a -> CSize -> IO CInt

{-# LINE 75 "Data/Memory/MemMap/Posix.hsc" #-}


{-# LINE 77 "Data/Memory/MemMap/Posix.hsc" #-}
foreign import ccall unsafe "munlock"
    c_munlock :: Ptr a -> CSize -> IO CInt

{-# LINE 83 "Data/Memory/MemMap/Posix.hsc" #-}

foreign import ccall unsafe "sysconf"
    c_sysconf :: CInt -> CLong

-- | Mapping flag
data MemoryMapFlag =
      MemoryMapShared  -- ^ memory changes are shared between process
    | MemoryMapPrivate -- ^ memory changes are private to process
    deriving (Int -> MemoryMapFlag -> ShowS
[MemoryMapFlag] -> ShowS
MemoryMapFlag -> String
(Int -> MemoryMapFlag -> ShowS)
-> (MemoryMapFlag -> String)
-> ([MemoryMapFlag] -> ShowS)
-> Show MemoryMapFlag
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MemoryMapFlag -> ShowS
showsPrec :: Int -> MemoryMapFlag -> ShowS
$cshow :: MemoryMapFlag -> String
show :: MemoryMapFlag -> String
$cshowList :: [MemoryMapFlag] -> ShowS
showList :: [MemoryMapFlag] -> ShowS
Show,ReadPrec [MemoryMapFlag]
ReadPrec MemoryMapFlag
Int -> ReadS MemoryMapFlag
ReadS [MemoryMapFlag]
(Int -> ReadS MemoryMapFlag)
-> ReadS [MemoryMapFlag]
-> ReadPrec MemoryMapFlag
-> ReadPrec [MemoryMapFlag]
-> Read MemoryMapFlag
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS MemoryMapFlag
readsPrec :: Int -> ReadS MemoryMapFlag
$creadList :: ReadS [MemoryMapFlag]
readList :: ReadS [MemoryMapFlag]
$creadPrec :: ReadPrec MemoryMapFlag
readPrec :: ReadPrec MemoryMapFlag
$creadListPrec :: ReadPrec [MemoryMapFlag]
readListPrec :: ReadPrec [MemoryMapFlag]
Read,MemoryMapFlag -> MemoryMapFlag -> Bool
(MemoryMapFlag -> MemoryMapFlag -> Bool)
-> (MemoryMapFlag -> MemoryMapFlag -> Bool) -> Eq MemoryMapFlag
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MemoryMapFlag -> MemoryMapFlag -> Bool
== :: MemoryMapFlag -> MemoryMapFlag -> Bool
$c/= :: MemoryMapFlag -> MemoryMapFlag -> Bool
/= :: MemoryMapFlag -> MemoryMapFlag -> Bool
Eq)

-- | Memory protection
data MemoryProtection =
      MemoryProtectionNone
    | MemoryProtectionRead
    | MemoryProtectionWrite
    | MemoryProtectionExecute
    deriving (Int -> MemoryProtection -> ShowS
[MemoryProtection] -> ShowS
MemoryProtection -> String
(Int -> MemoryProtection -> ShowS)
-> (MemoryProtection -> String)
-> ([MemoryProtection] -> ShowS)
-> Show MemoryProtection
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MemoryProtection -> ShowS
showsPrec :: Int -> MemoryProtection -> ShowS
$cshow :: MemoryProtection -> String
show :: MemoryProtection -> String
$cshowList :: [MemoryProtection] -> ShowS
showList :: [MemoryProtection] -> ShowS
Show,ReadPrec [MemoryProtection]
ReadPrec MemoryProtection
Int -> ReadS MemoryProtection
ReadS [MemoryProtection]
(Int -> ReadS MemoryProtection)
-> ReadS [MemoryProtection]
-> ReadPrec MemoryProtection
-> ReadPrec [MemoryProtection]
-> Read MemoryProtection
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS MemoryProtection
readsPrec :: Int -> ReadS MemoryProtection
$creadList :: ReadS [MemoryProtection]
readList :: ReadS [MemoryProtection]
$creadPrec :: ReadPrec MemoryProtection
readPrec :: ReadPrec MemoryProtection
$creadListPrec :: ReadPrec [MemoryProtection]
readListPrec :: ReadPrec [MemoryProtection]
Read,MemoryProtection -> MemoryProtection -> Bool
(MemoryProtection -> MemoryProtection -> Bool)
-> (MemoryProtection -> MemoryProtection -> Bool)
-> Eq MemoryProtection
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MemoryProtection -> MemoryProtection -> Bool
== :: MemoryProtection -> MemoryProtection -> Bool
$c/= :: MemoryProtection -> MemoryProtection -> Bool
/= :: MemoryProtection -> MemoryProtection -> Bool
Eq)

-- | Advice to put on memory.
--
-- only define the posix one.
data MemoryAdvice =
      MemoryAdviceNormal     -- ^ no specific advice, the default.
    | MemoryAdviceRandom     -- ^ Expect page references in random order. No readahead should occur.
    | MemoryAdviceSequential -- ^ Expect page references in sequential order. Page should be readahead aggressively.
    | MemoryAdviceWillNeed   -- ^ Expect access in the near future. Probably a good idea to readahead early
    | MemoryAdviceDontNeed   -- ^ Do not expect access in the near future.
    deriving (Int -> MemoryAdvice -> ShowS
[MemoryAdvice] -> ShowS
MemoryAdvice -> String
(Int -> MemoryAdvice -> ShowS)
-> (MemoryAdvice -> String)
-> ([MemoryAdvice] -> ShowS)
-> Show MemoryAdvice
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MemoryAdvice -> ShowS
showsPrec :: Int -> MemoryAdvice -> ShowS
$cshow :: MemoryAdvice -> String
show :: MemoryAdvice -> String
$cshowList :: [MemoryAdvice] -> ShowS
showList :: [MemoryAdvice] -> ShowS
Show,ReadPrec [MemoryAdvice]
ReadPrec MemoryAdvice
Int -> ReadS MemoryAdvice
ReadS [MemoryAdvice]
(Int -> ReadS MemoryAdvice)
-> ReadS [MemoryAdvice]
-> ReadPrec MemoryAdvice
-> ReadPrec [MemoryAdvice]
-> Read MemoryAdvice
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS MemoryAdvice
readsPrec :: Int -> ReadS MemoryAdvice
$creadList :: ReadS [MemoryAdvice]
readList :: ReadS [MemoryAdvice]
$creadPrec :: ReadPrec MemoryAdvice
readPrec :: ReadPrec MemoryAdvice
$creadListPrec :: ReadPrec [MemoryAdvice]
readListPrec :: ReadPrec [MemoryAdvice]
Read,MemoryAdvice -> MemoryAdvice -> Bool
(MemoryAdvice -> MemoryAdvice -> Bool)
-> (MemoryAdvice -> MemoryAdvice -> Bool) -> Eq MemoryAdvice
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MemoryAdvice -> MemoryAdvice -> Bool
== :: MemoryAdvice -> MemoryAdvice -> Bool
$c/= :: MemoryAdvice -> MemoryAdvice -> Bool
/= :: MemoryAdvice -> MemoryAdvice -> Bool
Eq)

-- | Memory synchronization flags
data MemorySyncFlag =
      MemorySyncAsync      -- ^ perform asynchronous write.
    | MemorySyncSync       -- ^ perform synchronous write.
    | MemorySyncInvalidate -- ^ invalidate cache data.
    deriving (Int -> MemorySyncFlag -> ShowS
[MemorySyncFlag] -> ShowS
MemorySyncFlag -> String
(Int -> MemorySyncFlag -> ShowS)
-> (MemorySyncFlag -> String)
-> ([MemorySyncFlag] -> ShowS)
-> Show MemorySyncFlag
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MemorySyncFlag -> ShowS
showsPrec :: Int -> MemorySyncFlag -> ShowS
$cshow :: MemorySyncFlag -> String
show :: MemorySyncFlag -> String
$cshowList :: [MemorySyncFlag] -> ShowS
showList :: [MemorySyncFlag] -> ShowS
Show,ReadPrec [MemorySyncFlag]
ReadPrec MemorySyncFlag
Int -> ReadS MemorySyncFlag
ReadS [MemorySyncFlag]
(Int -> ReadS MemorySyncFlag)
-> ReadS [MemorySyncFlag]
-> ReadPrec MemorySyncFlag
-> ReadPrec [MemorySyncFlag]
-> Read MemorySyncFlag
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS MemorySyncFlag
readsPrec :: Int -> ReadS MemorySyncFlag
$creadList :: ReadS [MemorySyncFlag]
readList :: ReadS [MemorySyncFlag]
$creadPrec :: ReadPrec MemorySyncFlag
readPrec :: ReadPrec MemorySyncFlag
$creadListPrec :: ReadPrec [MemorySyncFlag]
readListPrec :: ReadPrec [MemorySyncFlag]
Read,MemorySyncFlag -> MemorySyncFlag -> Bool
(MemorySyncFlag -> MemorySyncFlag -> Bool)
-> (MemorySyncFlag -> MemorySyncFlag -> Bool) -> Eq MemorySyncFlag
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MemorySyncFlag -> MemorySyncFlag -> Bool
== :: MemorySyncFlag -> MemorySyncFlag -> Bool
$c/= :: MemorySyncFlag -> MemorySyncFlag -> Bool
/= :: MemorySyncFlag -> MemorySyncFlag -> Bool
Eq)

cvalueOfMemoryProts :: [MemoryProtection] -> CInt
cvalueOfMemoryProts :: [MemoryProtection] -> CInt
cvalueOfMemoryProts = (CInt -> CInt -> CInt) -> CInt -> [CInt] -> CInt
forall b a. (b -> a -> b) -> b -> [a] -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl CInt -> CInt -> CInt
forall a. Bits a => a -> a -> a
(.|.) CInt
0 ([CInt] -> CInt)
-> ([MemoryProtection] -> [CInt]) -> [MemoryProtection] -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (MemoryProtection -> CInt) -> [MemoryProtection] -> [CInt]
forall a b. (a -> b) -> [a] -> [b]
map MemoryProtection -> CInt
toProt
  where toProt :: MemoryProtection -> CInt
        toProt :: MemoryProtection -> CInt
toProt MemoryProtection
MemoryProtectionNone    = (CInt
0)
{-# LINE 123 "Data/Memory/MemMap/Posix.hsc" #-}
        toProt MemoryProtection
MemoryProtectionRead    = (CInt
1)
{-# LINE 124 "Data/Memory/MemMap/Posix.hsc" #-}
        toProt MemoryProtection
MemoryProtectionWrite   = (CInt
2)
{-# LINE 125 "Data/Memory/MemMap/Posix.hsc" #-}
        toProt MemoryProtection
MemoryProtectionExecute = (CInt
4)
{-# LINE 126 "Data/Memory/MemMap/Posix.hsc" #-}

cvalueOfMemorySync :: [MemorySyncFlag] -> CInt
cvalueOfMemorySync :: [MemorySyncFlag] -> CInt
cvalueOfMemorySync = (CInt -> CInt -> CInt) -> CInt -> [CInt] -> CInt
forall b a. (b -> a -> b) -> b -> [a] -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl CInt -> CInt -> CInt
forall a. Bits a => a -> a -> a
(.|.) CInt
0 ([CInt] -> CInt)
-> ([MemorySyncFlag] -> [CInt]) -> [MemorySyncFlag] -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (MemorySyncFlag -> CInt) -> [MemorySyncFlag] -> [CInt]
forall a b. (a -> b) -> [a] -> [b]
map MemorySyncFlag -> CInt
forall {a}. Num a => MemorySyncFlag -> a
toSync
  where toSync :: MemorySyncFlag -> a
toSync MemorySyncFlag
MemorySyncAsync      = (a
1)
{-# LINE 130 "Data/Memory/MemMap/Posix.hsc" #-}
        toSync MemorySyncFlag
MemorySyncSync       = (a
4)
{-# LINE 131 "Data/Memory/MemMap/Posix.hsc" #-}
        toSync MemorySyncFlag
MemorySyncInvalidate = (a
2)
{-# LINE 132 "Data/Memory/MemMap/Posix.hsc" #-}

-- | Map pages of memory.
--
-- If fd is present, this memory will represent the file associated.
-- Otherwise, the memory will be an anonymous mapping.
--
-- use 'mmap'
memoryMap :: Maybe (Ptr a)      -- ^ The address to map to if MapFixed is used.
          -> CSize              -- ^ The length of the mapping
          -> [MemoryProtection] -- ^ the memory protection associated with the mapping
          -> MemoryMapFlag      -- ^ 
          -> Maybe Fd
          -> COff
          -> IO (Ptr a)
memoryMap :: forall a.
Maybe (Ptr a)
-> CSize
-> [MemoryProtection]
-> MemoryMapFlag
-> Maybe Fd
-> COff
-> IO (Ptr a)
memoryMap Maybe (Ptr a)
initPtr CSize
sz [MemoryProtection]
prots MemoryMapFlag
flag Maybe Fd
mfd COff
off =
    (Ptr a -> Bool) -> String -> IO (Ptr a) -> IO (Ptr a)
forall a. (a -> Bool) -> String -> IO a -> IO a
throwErrnoIf (Ptr a -> Ptr a -> Bool
forall a. Eq a => a -> a -> Bool
== Ptr a
forall {b}. Ptr b
m1ptr) String
"mmap" (Ptr a -> CSize -> CInt -> CInt -> CInt -> COff -> IO (Ptr a)
forall a.
Ptr a -> CSize -> CInt -> CInt -> CInt -> COff -> IO (Ptr a)
c_mmap (Ptr a -> (Ptr a -> Ptr a) -> Maybe (Ptr a) -> Ptr a
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Ptr a
forall {b}. Ptr b
nullPtr Ptr a -> Ptr a
forall a. a -> a
id Maybe (Ptr a)
initPtr) CSize
sz CInt
cprot CInt
cflags CInt
fd COff
off)
  where m1ptr :: Ptr b
m1ptr  = Ptr Any
forall {b}. Ptr b
nullPtr Ptr Any -> Int -> Ptr b
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` (-Int
1)
        fd :: CInt
fd     = CInt -> (Fd -> CInt) -> Maybe Fd -> CInt
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (-CInt
1) (\(Fd CInt
v) -> CInt
v) Maybe Fd
mfd
        cprot :: CInt
cprot  = [MemoryProtection] -> CInt
cvalueOfMemoryProts [MemoryProtection]
prots
        cflags :: CInt
cflags = CInt -> (Fd -> CInt) -> Maybe Fd -> CInt
forall b a. b -> (a -> b) -> Maybe a -> b
maybe CInt
cMapAnon (CInt -> Fd -> CInt
forall a b. a -> b -> a
const CInt
0) Maybe Fd
mfd
             CInt -> CInt -> CInt
forall a. Bits a => a -> a -> a
.|. CInt -> (Ptr a -> CInt) -> Maybe (Ptr a) -> CInt
forall b a. b -> (a -> b) -> Maybe a -> b
maybe CInt
0 (CInt -> Ptr a -> CInt
forall a b. a -> b -> a
const CInt
cMapFixed) Maybe (Ptr a)
initPtr
             CInt -> CInt -> CInt
forall a. Bits a => a -> a -> a
.|. MemoryMapFlag -> CInt
forall {a}. Num a => MemoryMapFlag -> a
toMapFlag MemoryMapFlag
flag


{-# LINE 158 "Data/Memory/MemMap/Posix.hsc" #-}
        cMapAnon :: CInt
cMapAnon  = (CInt
32)
{-# LINE 159 "Data/Memory/MemMap/Posix.hsc" #-}

{-# LINE 160 "Data/Memory/MemMap/Posix.hsc" #-}
        cMapFixed :: CInt
cMapFixed = (CInt
16)
{-# LINE 161 "Data/Memory/MemMap/Posix.hsc" #-}

        toMapFlag :: MemoryMapFlag -> a
toMapFlag MemoryMapFlag
MemoryMapShared  = (a
1)
{-# LINE 163 "Data/Memory/MemMap/Posix.hsc" #-}
        toMapFlag MemoryMapFlag
MemoryMapPrivate = (a
2)
{-# LINE 164 "Data/Memory/MemMap/Posix.hsc" #-}

-- | Unmap pages of memory
--
-- use 'munmap'
memoryUnmap :: Ptr a -> CSize -> IO ()
memoryUnmap :: forall a. Ptr a -> CSize -> IO ()
memoryUnmap Ptr a
ptr CSize
sz = String -> IO CInt -> IO ()
forall a. (Eq a, Num a) => String -> IO a -> IO ()
throwErrnoIfMinus1_ String
"munmap" (Ptr a -> CSize -> IO CInt
forall a. Ptr a -> CSize -> IO CInt
c_munmap Ptr a
ptr CSize
sz)

-- | give advice to the operating system about use of memory
--
-- call 'madvise'
memoryAdvise :: Ptr a -> CSize -> MemoryAdvice -> IO ()
memoryAdvise :: forall a. Ptr a -> CSize -> MemoryAdvice -> IO ()
memoryAdvise Ptr a
ptr CSize
sz MemoryAdvice
adv = String -> IO CInt -> IO ()
forall a. (Eq a, Num a) => String -> IO a -> IO ()
throwErrnoIfMinus1_ String
"madvise" (Ptr a -> CSize -> CInt -> IO CInt
forall a. Ptr a -> CSize -> CInt -> IO CInt
c_madvise Ptr a
ptr CSize
sz CInt
cadv)
  where cadv :: CInt
cadv = MemoryAdvice -> CInt
forall {a}. Num a => MemoryAdvice -> a
toAdvice MemoryAdvice
adv

{-# LINE 178 "Data/Memory/MemMap/Posix.hsc" #-}
        toAdvice :: MemoryAdvice -> a
toAdvice MemoryAdvice
MemoryAdviceNormal = (a
0)
{-# LINE 179 "Data/Memory/MemMap/Posix.hsc" #-}
        toAdvice MemoryAdvice
MemoryAdviceRandom = (a
1)
{-# LINE 180 "Data/Memory/MemMap/Posix.hsc" #-}
        toAdvice MemoryAdvice
MemoryAdviceSequential = (a
2)
{-# LINE 181 "Data/Memory/MemMap/Posix.hsc" #-}
        toAdvice MemoryAdvice
MemoryAdviceWillNeed = (a
3)
{-# LINE 182 "Data/Memory/MemMap/Posix.hsc" #-}
        toAdvice MemoryAdvice
MemoryAdviceDontNeed = (a
4)
{-# LINE 183 "Data/Memory/MemMap/Posix.hsc" #-}

{-# LINE 190 "Data/Memory/MemMap/Posix.hsc" #-}

-- | lock a range of process address space
--
-- call 'mlock'
memoryLock :: Ptr a -> CSize -> IO ()
memoryLock :: forall a. Ptr a -> CSize -> IO ()
memoryLock Ptr a
ptr CSize
sz = String -> IO CInt -> IO ()
forall a. (Eq a, Num a) => String -> IO a -> IO ()
throwErrnoIfMinus1_ String
"mlock" (Ptr a -> CSize -> IO CInt
forall a. Ptr a -> CSize -> IO CInt
c_mlock Ptr a
ptr CSize
sz)

-- | unlock a range of process address space
--
-- call 'munlock'
memoryUnlock :: Ptr a -> CSize -> IO ()
memoryUnlock :: forall a. Ptr a -> CSize -> IO ()
memoryUnlock Ptr a
ptr CSize
sz = String -> IO CInt -> IO ()
forall a. (Eq a, Num a) => String -> IO a -> IO ()
throwErrnoIfMinus1_ String
"munlock" (Ptr a -> CSize -> IO CInt
forall a. Ptr a -> CSize -> IO CInt
c_munlock Ptr a
ptr CSize
sz)

-- | set protection of memory mapping
--
-- call 'mprotect'
memoryProtect :: Ptr a -> CSize -> [MemoryProtection] -> IO ()
memoryProtect :: forall a. Ptr a -> CSize -> [MemoryProtection] -> IO ()
memoryProtect Ptr a
ptr CSize
sz [MemoryProtection]
prots = String -> IO CInt -> IO ()
forall a. (Eq a, Num a) => String -> IO a -> IO ()
throwErrnoIfMinus1_ String
"mprotect" (Ptr a -> CSize -> CInt -> IO CInt
forall a. Ptr a -> CSize -> CInt -> IO CInt
c_mprotect Ptr a
ptr CSize
sz CInt
cprot)
  where cprot :: CInt
cprot = [MemoryProtection] -> CInt
cvalueOfMemoryProts [MemoryProtection]
prots

-- | memorySync synchronize memory with physical storage.
--
-- On an anonymous mapping this function doesn't have any effect.
-- call 'msync'
memorySync :: Ptr a -> CSize -> [MemorySyncFlag] -> IO ()
memorySync :: forall a. Ptr a -> CSize -> [MemorySyncFlag] -> IO ()
memorySync Ptr a
ptr CSize
sz [MemorySyncFlag]
flags = String -> IO CInt -> IO ()
forall a. (Eq a, Num a) => String -> IO a -> IO ()
throwErrnoIfMinus1_ String
"msync" (Ptr a -> CSize -> CInt -> IO CInt
forall a. Ptr a -> CSize -> CInt -> IO CInt
c_msync Ptr a
ptr CSize
sz CInt
cflags)
  where cflags :: CInt
cflags = [MemorySyncFlag] -> CInt
cvalueOfMemorySync [MemorySyncFlag]
flags

-- | Return the operating system page size.
-- 
-- call 'sysconf'
sysconfPageSize :: Int
sysconfPageSize :: Int
sysconfPageSize = CLong -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (CLong -> Int) -> CLong -> Int
forall a b. (a -> b) -> a -> b
$ CInt -> CLong
c_sysconf (CInt
30)
{-# LINE 223 "Data/Memory/MemMap/Posix.hsc" #-}