module System.Statgrab.Base where
import Control.Applicative
import Data.ByteString (packCString)
import Foreign
import Foreign.C.String
import Foreign.C.Types
import System.Statgrab.Internal
data family Struct a
data PtrN a = PtrN
{ ptrUnwrap :: Ptr a
, ptrEntries :: !Int
}
class Copy a where
copyAt :: Ptr (Struct a) -> Int -> IO a
copyBatch :: PtrN (Struct a) -> IO [a]
copy :: PtrN (Struct a) -> IO a
copy PtrN{..} = copyAt ptrUnwrap 0
copyBatch PtrN{..} = mapM (copyAt ptrUnwrap) entries
where
entries
| ptrEntries > 1 = [0..ptrEntries 1]
| otherwise = [0]
class Stat a where
acquire :: Entries -> IO (Ptr a)
release :: Ptr a -> IO Error
acquireN :: Stat a => IO (PtrN a)
acquireN = alloca $ \x -> PtrN <$> acquire x <*> (fromIntegral <$> peek x)
releaseN :: Stat a => PtrN a -> IO Error
releaseN = release . ptrUnwrap
type ErrorDetailsPtr = Ptr ErrorDetails
type HostPtr = Ptr (Struct Host)
type CPUPtr = Ptr (Struct CPU)
type CPUPercentPtr = Ptr (Struct CPUPercent)
type MemoryPtr = Ptr (Struct Memory)
type LoadPtr = Ptr (Struct Load)
type UserPtr = Ptr (Struct User)
type SwapPtr = Ptr (Struct Swap)
type FileSystemPtr = Ptr (Struct FileSystem)
type DiskIOPtr = Ptr (Struct DiskIO)
type NetworkIOPtr = Ptr (Struct NetworkIO)
type NetworkInterfacePtr = Ptr (Struct NetworkInterface)
type PagePtr = Ptr (Struct Page)
type ProcessPtr = Ptr (Struct Process)
type ProcessCountPtr = Ptr (Struct ProcessCount)
errNone :: Error
errNone = Error 0
errAsPrintf :: Error
errAsPrintf = Error 2
errDevices :: Error
errDevices = Error 4
errDevStatGetDevs :: Error
errDevStatGetDevs = Error 5
errDevstat_selectdevs :: Error
errDevstat_selectdevs = Error 6
errDiskinfo :: Error
errDiskinfo = Error 7
errEnoent :: Error
errEnoent = Error 8
errGetifaddrs :: Error
errGetifaddrs = Error 9
errGetmountInfo :: Error
errGetmountInfo = Error 10
errGetPageSize :: Error
errGetPageSize = Error 11
errHost :: Error
errHost = Error 12
errKstatDataLookup :: Error
errKstatDataLookup = Error 13
errKstatLookup :: Error
errKstatLookup = Error 14
errKstatOpen :: Error
errKstatOpen = Error 15
errKstatRead :: Error
errKstatRead = Error 16
errKvmGetSwapInfo :: Error
errKvmGetSwapInfo = Error 17
errKvmOpenFiles :: Error
errKvmOpenFiles = Error 18
errMalloc :: Error
errMalloc = Error 19
errMemStatus :: Error
errMemStatus = Error 20
errOpen :: Error
errOpen = Error 21
errOpenDir :: Error
errOpenDir = Error 22
errParse :: Error
errParse = Error 24
errPdhAdd :: Error
errPdhAdd = Error 25
errPdhCollect :: Error
errPdhCollect = Error 26
errPdhOpen :: Error
errPdhOpen = Error 27
errPdhRead :: Error
errPdhRead = Error 28
errPermission :: Error
errPermission = Error 29
errPStat :: Error
errPStat = Error 30
errSetEGid :: Error
errSetEGid = Error 31
errSetEUid :: Error
errSetEUid = Error 32
errSetMntent :: Error
errSetMntent = Error 33
errSocket :: Error
errSocket = Error 34
errSwapCtl :: Error
errSwapCtl = Error 35
errSysConf :: Error
errSysConf = Error 36
errSysCtl :: Error
errSysCtl = Error 37
errSysCtlByName :: Error
errSysCtlByName = Error 38
errSysctlNameToMib :: Error
errSysctlNameToMib = Error 39
errUname :: Error
errUname = Error 43
errUnsupported :: Error
errUnsupported = Error 44
errXswVerMismatch :: Error
errXswVerMismatch = Error 45
errGetMsg :: Error
errGetMsg = Error 46
errPutMsg :: Error
errPutMsg = Error 47
errInitialisation :: Error
errInitialisation = Error 48
errMutexLock :: Error
errMutexLock = Error 49
errMutexUnlock :: Error
errMutexUnlock = Error 50
data ErrorDetails = ErrorDetails
{ erError :: !Error
, erValue :: !CInt
, erArg :: !CString
}
foreign import ccall safe "statgrab.h sg_get_error"
sg_get_error :: IO Error
foreign import ccall safe "statgrab.h sg_get_error_arg"
sg_get_error_arg :: IO CString
foreign import ccall safe "statgrab.h sg_get_error_errno"
sg_get_error_errno :: IO CInt
foreign import ccall safe "statgrab.h sg_get_error_details"
sg_get_error_details :: ErrorDetailsPtr -> IO Error
foreign import ccall safe "statgrab.h sg_str_error"
sg_str_error :: Error -> IO CString
foreign import ccall safe "statgrab.h sg_strperror"
sg_strperror :: Ptr CString -> ErrorDetailsPtr -> IO CString
foreign import ccall safe "statgrab.h sg_init"
sg_init :: CInt -> IO Error
foreign import ccall safe "statgrab.h sg_snapshot"
sg_snapshot :: IO Error
foreign import ccall safe "statgrab.h sg_shutdown"
sg_shutdown :: IO Error
foreign import ccall safe "statgrab.h sg_drop_privileges"
sg_drop_privileges :: IO Error
foreign import ccall safe "statgrab.h sg_get_nelements"
sg_get_nelements :: Ptr () -> IO CSize
foreign import ccall safe "statgrab.h sg_free_stats_buf"
sg_free_stats_buf :: Ptr () -> IO Error
foreign import ccall safe "statgrab.h sg_lock_mutex"
sg_lock_mutex :: CString -> IO Error
foreign import ccall safe "statgrab.h sg_unlock_mutex"
sg_unlock_mutex :: CString -> IO Error
stateUnknownConfig :: HostState
stateUnknownConfig = HostState 0
statePhysicalHost :: HostState
statePhysicalHost = HostState 1
stateVirtual :: HostState
stateVirtual = HostState 2
stateParaVirtual :: HostState
stateParaVirtual = HostState 3
stateHardwareVirtual :: HostState
stateHardwareVirtual = HostState 4
data instance Struct Host = CHost
{ hostOsName :: !CString
, hostOsRelease :: !CString
, hostOsVersion :: !CString
, hostPlatform :: !CString
, hostName :: !CString
, hostBitWidth :: !CUInt
, hostState :: !HostState
, hostNCPU :: !CUInt
, hostMaxCPU :: !CUInt
, hostUptime :: !CTime
, hostSystime :: !CTime
}
instance Copy Host where
copyAt ptr i = do
CHost{..} <- peekElemOff ptr i
Host <$> packCString hostOsName
<*> packCString hostOsRelease
<*> packCString hostOsVersion
<*> packCString hostPlatform
<*> packCString hostName
<#> hostBitWidth
<!> hostState
<#> hostNCPU
<#> hostMaxCPU
<@> hostUptime
<@> hostSystime
instance Storable (Struct Host) where
alignment _ = 8
sizeOf _ = (72)
peek p = CHost
<$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 8) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 16) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 24) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 32) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 40) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 44) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 48) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 52) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 56) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 64) p
poke p CHost{..} = do
(\hsc_ptr -> pokeByteOff hsc_ptr 0) p hostOsName
(\hsc_ptr -> pokeByteOff hsc_ptr 8) p hostOsRelease
(\hsc_ptr -> pokeByteOff hsc_ptr 16) p hostOsVersion
(\hsc_ptr -> pokeByteOff hsc_ptr 24) p hostPlatform
(\hsc_ptr -> pokeByteOff hsc_ptr 32) p hostName
(\hsc_ptr -> pokeByteOff hsc_ptr 40) p hostBitWidth
(\hsc_ptr -> pokeByteOff hsc_ptr 44) p hostState
(\hsc_ptr -> pokeByteOff hsc_ptr 48) p hostNCPU
(\hsc_ptr -> pokeByteOff hsc_ptr 52) p hostMaxCPU
(\hsc_ptr -> pokeByteOff hsc_ptr 56) p hostUptime
(\hsc_ptr -> pokeByteOff hsc_ptr 64) p hostSystime
instance Stat (Struct Host) where
acquire = sg_get_host_info_r
release = sg_free_host_info
foreign import ccall safe "statgrab.h sg_get_host_info"
sg_get_host_info :: Entries -> IO HostPtr
foreign import ccall safe "statgrab.h sg_get_host_info_r"
sg_get_host_info_r :: Entries -> IO HostPtr
foreign import ccall safe "statgrab.h sg_free_stats_buf"
sg_free_host_info :: HostPtr -> IO Error
data instance Struct CPU = CCPU
{ cpuUser :: !CLLong
, cpuKernel :: !CLLong
, cpuIdle :: !CLLong
, cpuIOWait :: !CLLong
, cpuSwap :: !CLLong
, cpuNice :: !CLLong
, cpuTotal :: !CLLong
, cpuCtxSwitches :: !CLLong
, cpuVoluntaryCtxSwitches :: !CLLong
, cpuInvoluntaryCtxSwitches :: !CLLong
, cpuSyscalls :: !CLLong
, cpuInterrupts :: !CLLong
, cpuSoftInterrupts :: !CLLong
, cpuSystime :: !CTime
}
instance Copy CPU where
copyAt ptr i = do
CCPU{..} <- peekElemOff ptr i
CPU <%> cpuUser
<#> cpuKernel
<#> cpuIdle
<#> cpuIOWait
<#> cpuSwap
<#> cpuNice
<#> cpuTotal
<#> cpuCtxSwitches
<#> cpuVoluntaryCtxSwitches
<#> cpuInvoluntaryCtxSwitches
<#> cpuSyscalls
<#> cpuInterrupts
<#> cpuSoftInterrupts
<@> cpuSystime
instance Storable (Struct CPU) where
alignment _ = 8
sizeOf _ = (112)
peek p = CCPU
<$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 8) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 16) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 24) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 32) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 40) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 48) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 56) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 64) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 72) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 80) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 88) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 96) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 104) p
poke p CCPU{..} = do
(\hsc_ptr -> pokeByteOff hsc_ptr 0) p cpuUser
(\hsc_ptr -> pokeByteOff hsc_ptr 8) p cpuKernel
(\hsc_ptr -> pokeByteOff hsc_ptr 16) p cpuIdle
(\hsc_ptr -> pokeByteOff hsc_ptr 24) p cpuIOWait
(\hsc_ptr -> pokeByteOff hsc_ptr 32) p cpuSwap
(\hsc_ptr -> pokeByteOff hsc_ptr 40) p cpuNice
(\hsc_ptr -> pokeByteOff hsc_ptr 48) p cpuTotal
(\hsc_ptr -> pokeByteOff hsc_ptr 56) p cpuCtxSwitches
(\hsc_ptr -> pokeByteOff hsc_ptr 64) p cpuVoluntaryCtxSwitches
(\hsc_ptr -> pokeByteOff hsc_ptr 72) p cpuInvoluntaryCtxSwitches
(\hsc_ptr -> pokeByteOff hsc_ptr 80) p cpuSyscalls
(\hsc_ptr -> pokeByteOff hsc_ptr 88) p cpuInterrupts
(\hsc_ptr -> pokeByteOff hsc_ptr 96) p cpuSoftInterrupts
(\hsc_ptr -> pokeByteOff hsc_ptr 104) p cpuSystime
instance Stat (Struct CPU) where
acquire = sg_get_cpu_stats_r
release = sg_free_cpu_stats
foreign import ccall safe "statgrab.h sg_get_cpu_stats"
sg_get_cpu_stats :: Entries -> IO CPUPtr
foreign import ccall safe "statgrab.h sg_get_cpu_stats_diff"
sg_get_cpu_stats_diff :: Entries -> IO CPUPtr
foreign import ccall safe "statgrab.h sg_get_cpu_stats_r"
sg_get_cpu_stats_r :: Entries -> IO CPUPtr
foreign import ccall safe "statgrab.h sg_get_cpu_stats_diff_between"
sg_get_cpu_stats_diff_between :: CPUPtr -> CPUPtr -> Entries -> IO CPUPtr
foreign import ccall safe "statgrab.h sg_free_stats_buf"
sg_free_cpu_stats :: CPUPtr -> IO Error
data instance Struct CPUPercent = CCPUPercent
{ cpuPctUser :: !CDouble
, cpuPctKernel :: !CDouble
, cpuPctIdle :: !CDouble
, cpuPctIOWait :: !CDouble
, cpuPctSwap :: !CDouble
, cpuPctNice :: !CDouble
, cpuPctTimeTaken :: !CTime
}
instance Copy CPUPercent where
copyAt ptr i = do
CCPUPercent{..} <- peekElemOff ptr i
CPUPercent <$> pure (realToFrac cpuPctUser)
<@> cpuPctKernel
<@> cpuPctIdle
<@> cpuPctIOWait
<@> cpuPctSwap
<@> cpuPctNice
<@> cpuPctTimeTaken
instance Storable (Struct CPUPercent) where
alignment _ = 8
sizeOf _ = (56)
peek p = CCPUPercent
<$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 8) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 16) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 24) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 32) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 40) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 48) p
poke p CCPUPercent{..} = do
(\hsc_ptr -> pokeByteOff hsc_ptr 0) p cpuPctUser
(\hsc_ptr -> pokeByteOff hsc_ptr 8) p cpuPctKernel
(\hsc_ptr -> pokeByteOff hsc_ptr 16) p cpuPctIdle
(\hsc_ptr -> pokeByteOff hsc_ptr 24) p cpuPctIOWait
(\hsc_ptr -> pokeByteOff hsc_ptr 32) p cpuPctSwap
(\hsc_ptr -> pokeByteOff hsc_ptr 40) p cpuPctNice
(\hsc_ptr -> pokeByteOff hsc_ptr 48) p cpuPctTimeTaken
sourceEntireCCPU :: CPUPercentSource
sourceEntireCCPU = CPUPercentSource 0
sourceDiffCCPU :: CPUPercentSource
sourceDiffCCPU = CPUPercentSource 1
sourceNewDiffCCPU :: CPUPercentSource
sourceNewDiffCCPU = CPUPercentSource 2
foreign import ccall safe "statgrab.h sg_get_cpu_percents_of"
sg_get_cpu_percents_of :: CPUPercentSource -> Entries -> IO CPUPercentPtr
foreign import ccall safe "statgrab.h sg_get_cpu_percents_r"
sg_get_cpu_percents_r :: CPUPtr -> Entries -> IO CPUPercentPtr
foreign import ccall safe "statgrab.h sg_free_stats_buf"
sg_free_cpu_percents :: CPUPercentPtr -> IO Error
data instance Struct Memory = CMemory
{ memTotal :: !CULLong
, memFree :: !CULLong
, memUsed :: !CULLong
, memCache :: !CULLong
, memSystime :: !CTime
}
instance Copy Memory where
copyAt ptr i = do
CMemory{..} <- peekElemOff ptr i
Memory <%> memTotal
<#> memFree
<#> memUsed
<#> memCache
<@> memSystime
instance Storable (Struct Memory) where
alignment _ = 8
sizeOf _ = (40)
peek p = CMemory
<$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 8) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 16) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 24) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 32) p
poke p CMemory{..} = do
(\hsc_ptr -> pokeByteOff hsc_ptr 0) p memTotal
(\hsc_ptr -> pokeByteOff hsc_ptr 8) p memFree
(\hsc_ptr -> pokeByteOff hsc_ptr 16) p memUsed
(\hsc_ptr -> pokeByteOff hsc_ptr 32) p memSystime
instance Stat (Struct Memory) where
acquire = sg_get_mem_stats_r
release = sg_free_mem_stats
foreign import ccall safe "statgrab.h sg_get_mem_stats"
sg_get_mem_stats :: Entries -> IO MemoryPtr
foreign import ccall safe "statgrab.h sg_get_mem_stats_r"
sg_get_mem_stats_r :: Entries -> IO MemoryPtr
foreign import ccall safe "statgrab.h sg_free_stats_buf"
sg_free_mem_stats :: MemoryPtr -> IO Error
data instance Struct Load = CLoad
{ load1 :: !CDouble
, load5 :: !CDouble
, load15 :: !CDouble
, loadSystime :: !CTime
}
instance Copy Load where
copyAt ptr i = do
CLoad{..} <- peekElemOff ptr i
Load <$> pure (realToFrac load1)
<@> load5
<@> load15
<@> loadSystime
instance Storable (Struct Load) where
alignment _ = 8
sizeOf _ = (32)
peek p = CLoad
<$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 8) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 16) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 24) p
poke p CLoad{..} = do
(\hsc_ptr -> pokeByteOff hsc_ptr 0) p load1
(\hsc_ptr -> pokeByteOff hsc_ptr 8) p load5
(\hsc_ptr -> pokeByteOff hsc_ptr 16) p load15
(\hsc_ptr -> pokeByteOff hsc_ptr 24) p loadSystime
instance Stat (Struct Load) where
acquire = sg_get_load_stats_r
release = sg_free_load_stats
foreign import ccall safe "statgrab.h sg_get_load_stats"
sg_get_load_stats :: Entries -> IO LoadPtr
foreign import ccall safe "statgrab.h sg_get_load_stats_r"
sg_get_load_stats_r :: Entries -> IO LoadPtr
foreign import ccall safe "statgrab.h sg_free_stats_buf"
sg_free_load_stats :: LoadPtr -> IO Error
data instance Struct User = CUser
{ userLoginName :: !CString
, userRecordId :: !CString
, userRecordIdSize :: !CSize
, userDevice :: !CString
, userHostName :: !CString
, userPid :: !CInt
, userLoginTime :: !CTime
, userSystime :: !CTime
}
instance Copy User where
copyAt ptr i = do
CUser{..} <- peekElemOff ptr i
User <$> packCString userLoginName
<*> packCString userRecordId
<#> userRecordIdSize
<*> packCString userDevice
<*> packCString userHostName
<#> userPid
<@> userLoginTime
<@> userSystime
instance Storable (Struct User) where
alignment _ = 8
sizeOf _ = (64)
peek p = CUser
<$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 8) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 16) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 24) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 32) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 40) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 48) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 56) p
poke p CUser{..} = do
(\hsc_ptr -> pokeByteOff hsc_ptr 0) p userLoginTime
(\hsc_ptr -> pokeByteOff hsc_ptr 8) p userRecordId
(\hsc_ptr -> pokeByteOff hsc_ptr 16) p userRecordIdSize
(\hsc_ptr -> pokeByteOff hsc_ptr 24) p userDevice
(\hsc_ptr -> pokeByteOff hsc_ptr 32) p userHostName
(\hsc_ptr -> pokeByteOff hsc_ptr 40) p userPid
(\hsc_ptr -> pokeByteOff hsc_ptr 48) p userLoginTime
(\hsc_ptr -> pokeByteOff hsc_ptr 56) p userSystime
instance Stat (Struct User) where
acquire = sg_get_user_stats_r
release = sg_free_user_stats
foreign import ccall safe "statgrab.h sg_get_user_stats"
sg_get_user_stats :: Entries -> IO UserPtr
foreign import ccall safe "statgrab.h sg_get_user_stats_r"
sg_get_user_stats_r :: Entries -> IO UserPtr
foreign import ccall safe "statgrab.h sg_free_stats_buf"
sg_free_user_stats :: UserPtr -> IO Error
data instance Struct Swap = CSwap
{ swapTotal :: !CULLong
, swapUsed :: !CULLong
, swapFree :: !CULLong
, swapSystime :: !CTime
}
instance Copy Swap where
copyAt ptr i = do
CSwap{..} <- peekElemOff ptr i
Swap <%> swapTotal
<#> swapUsed
<#> swapFree
<@> swapSystime
instance Storable (Struct Swap) where
alignment _ = 8
sizeOf _ = (32)
peek p = CSwap
<$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 8) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 16) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 24) p
poke p CSwap{..} = do
(\hsc_ptr -> pokeByteOff hsc_ptr 0) p swapTotal
(\hsc_ptr -> pokeByteOff hsc_ptr 8) p swapUsed
(\hsc_ptr -> pokeByteOff hsc_ptr 16) p swapFree
(\hsc_ptr -> pokeByteOff hsc_ptr 24) p swapSystime
instance Stat (Struct Swap) where
acquire = sg_get_swap_stats_r
release = sg_free_swap_stats
foreign import ccall safe "statgrab.h sg_get_swap_stats"
sg_get_swap_stats :: Entries -> IO SwapPtr
foreign import ccall safe "statgrab.h sg_get_swap_stats_r"
sg_get_swap_stats_r :: Entries -> IO SwapPtr
foreign import ccall safe "statgrab.h sg_free_stats_buf"
sg_free_swap_stats :: SwapPtr -> IO Error
deviceUnknown :: DeviceType
deviceUnknown = DeviceType 0
deviceRegular :: DeviceType
deviceRegular = DeviceType 1
deviceSpecial :: DeviceType
deviceSpecial = DeviceType 2
deviceLoopback :: DeviceType
deviceLoopback = DeviceType 4
deviceRemote :: DeviceType
deviceRemote = DeviceType 8
deviceLocal :: DeviceType
deviceLocal = DeviceType 3
deviceAllTypes :: DeviceType
deviceAllTypes = DeviceType 15
data instance Struct FileSystem = CFileSystem
{ fsDeviceName :: !CString
, fsType :: !CString
, fsMountPoint :: !CString
, fsDeviceType :: !DeviceType
, fsSize :: !CULLong
, fsUsed :: !CULLong
, fsFree :: !CULLong
, fsAvail :: !CULLong
, fsTotalInodes :: !CULLong
, fsUsedInodes :: !CULLong
, fsFreeInodes :: !CULLong
, fsAvailInodes :: !CULLong
, fsIOSize :: !CULLong
, fsBlockSize :: !CULLong
, fsTotalBlocks :: !CULLong
, fsFreeBlocks :: !CULLong
, fsUsedBlocks :: !CULLong
, fsAvailBlocks :: !CULLong
, fsSystime :: !CTime
}
instance Copy FileSystem where
copyAt ptr i = do
CFileSystem{..} <- peekElemOff ptr i
FileSystem <$> packCString fsDeviceName
<*> packCString fsType
<*> packCString fsMountPoint
<!> fsDeviceType
<#> fsSize
<#> fsUsed
<#> fsFree
<#> fsAvail
<#> fsTotalInodes
<#> fsUsedInodes
<#> fsFreeInodes
<#> fsAvailInodes
<#> fsIOSize
<#> fsBlockSize
<#> fsTotalBlocks
<#> fsFreeBlocks
<#> fsUsedBlocks
<#> fsAvailBlocks
<@> fsSystime
instance Storable (Struct FileSystem) where
alignment _ = 8
sizeOf _ = (152)
peek p = CFileSystem
<$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 8) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 16) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 24) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 32) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 40) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 48) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 56) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 64) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 72) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 80) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 88) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 96) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 104) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 112) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 120) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 128) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 136) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 144) p
poke p CFileSystem{..} = do
(\hsc_ptr -> pokeByteOff hsc_ptr 0) p fsDeviceName
(\hsc_ptr -> pokeByteOff hsc_ptr 8) p fsType
(\hsc_ptr -> pokeByteOff hsc_ptr 16) p fsMountPoint
(\hsc_ptr -> pokeByteOff hsc_ptr 24) p fsDeviceType
(\hsc_ptr -> pokeByteOff hsc_ptr 32) p fsSize
(\hsc_ptr -> pokeByteOff hsc_ptr 40) p fsUsed
(\hsc_ptr -> pokeByteOff hsc_ptr 48) p fsFree
(\hsc_ptr -> pokeByteOff hsc_ptr 56) p fsAvail
(\hsc_ptr -> pokeByteOff hsc_ptr 64) p fsTotalInodes
(\hsc_ptr -> pokeByteOff hsc_ptr 72) p fsUsedInodes
(\hsc_ptr -> pokeByteOff hsc_ptr 80) p fsFreeInodes
(\hsc_ptr -> pokeByteOff hsc_ptr 88) p fsAvailInodes
(\hsc_ptr -> pokeByteOff hsc_ptr 96) p fsIOSize
(\hsc_ptr -> pokeByteOff hsc_ptr 104) p fsBlockSize
(\hsc_ptr -> pokeByteOff hsc_ptr 112) p fsTotalBlocks
(\hsc_ptr -> pokeByteOff hsc_ptr 120) p fsFreeBlocks
(\hsc_ptr -> pokeByteOff hsc_ptr 128) p fsUsedBlocks
(\hsc_ptr -> pokeByteOff hsc_ptr 136) p fsAvailBlocks
(\hsc_ptr -> pokeByteOff hsc_ptr 144) p fsSystime
instance Stat (Struct FileSystem) where
acquire = sg_get_fs_stats_r
release = sg_free_fs_stats
foreign import ccall safe "statgrab.h sg_get_valid_filesystems"
sg_get_valid_filesystems :: Entries -> IO (Ptr CString)
foreign import ccall safe "statgrab.h sg_get_fs_stats"
sg_get_fs_stats :: Entries -> IO FileSystemPtr
foreign import ccall safe "statgrab.h sg_get_fs_stats_r"
sg_get_fs_stats_r :: Entries -> IO FileSystemPtr
foreign import ccall safe "statgrab.h sg_get_fs_stats_diff"
sg_get_fs_stats_diff :: Entries -> IO FileSystemPtr
foreign import ccall safe "statgrab.h sg_get_fs_stats_diff_between"
sg_get_fs_stats_diff_between :: FileSystemPtr
-> FileSystemPtr
-> Entries
-> IO FileSystemPtr
foreign import ccall safe "statgrab.h sg_fs_compare_device_name"
sg_fs_compare_device_name :: Ptr () -> Ptr () -> IO CInt
foreign import ccall safe "statgrab.h sg_fs_compare_mnt_point"
sg_fs_compare_mnt_point :: Ptr () -> Ptr () -> IO CInt
foreign import ccall safe "statgrab.h sg_free_stats_buf"
sg_free_fs_stats :: FileSystemPtr -> IO Error
data instance Struct DiskIO = CDiskIO
{ diskName :: !CString
, diskRead :: !CULLong
, diskWrite :: !CULLong
, diskSystime :: !CTime
}
instance Copy DiskIO where
copyAt ptr i = do
CDiskIO{..} <- peekElemOff ptr i
DiskIO <$> packCString diskName
<#> diskRead
<#> diskWrite
<@> diskSystime
instance Storable (Struct DiskIO) where
alignment _ = 8
sizeOf _ = (32)
peek p = CDiskIO
<$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 8) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 16) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 24) p
poke p CDiskIO{..} = do
(\hsc_ptr -> pokeByteOff hsc_ptr 0) p diskName
(\hsc_ptr -> pokeByteOff hsc_ptr 8) p diskRead
(\hsc_ptr -> pokeByteOff hsc_ptr 16) p diskWrite
(\hsc_ptr -> pokeByteOff hsc_ptr 24) p diskSystime
instance Stat (Struct DiskIO) where
acquire = sg_get_disk_io_stats_r
release = sg_free_disk_io_stats
foreign import ccall safe "statgrab.h sg_get_disk_io_stats"
sg_get_disk_io_stats :: Entries -> IO DiskIOPtr
foreign import ccall safe "statgrab.h sg_get_disk_io_stats_r"
sg_get_disk_io_stats_r :: Entries -> IO DiskIOPtr
foreign import ccall safe "statgrab.h sg_get_disk_io_stats_diff"
sg_get_disk_io_stats_diff :: Entries -> IO DiskIOPtr
foreign import ccall safe "statgrab.h sg_get_disk_io_stats_diff_between"
sg_get_disk_io_stats_diff_between :: DiskIOPtr
-> DiskIOPtr
-> Entries
-> IO DiskIOPtr
foreign import ccall safe "statgrab.h sg_disk_io_compare_name"
sg_disk_io_compare_name :: Ptr () -> Ptr () -> IO CInt
foreign import ccall safe "statgrab.h sg_disk_io_compare_traffic"
sg_disk_io_compare_traffic :: Ptr () -> Ptr () -> IO CInt
foreign import ccall safe "statgrab.h sg_free_stats_buf"
sg_free_disk_io_stats :: DiskIOPtr -> IO Error
data instance Struct NetworkIO = CNetworkIO
{ ifaceIOName :: !CString
, ifaceTX :: !CULLong
, ifaceRX :: !CULLong
, ifaceIPackets :: !CULLong
, ifaceOPackets :: !CULLong
, ifaceIErrors :: !CULLong
, ifaceOErrors :: !CULLong
, ifaceCollisions :: !CULLong
, ifaceSystem :: !CTime
}
instance Copy NetworkIO where
copyAt ptr i = do
CNetworkIO{..} <- peekElemOff ptr i
NetworkIO <$> packCString ifaceIOName
<#> ifaceTX
<#> ifaceRX
<#> ifaceIPackets
<#> ifaceOPackets
<#> ifaceIErrors
<#> ifaceOErrors
<#> ifaceCollisions
<@> ifaceSystem
instance Storable (Struct NetworkIO) where
alignment _ = 8
sizeOf _ = (72)
peek p = CNetworkIO
<$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 8) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 16) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 24) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 32) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 40) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 48) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 56) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 64) p
poke p CNetworkIO{..} = do
(\hsc_ptr -> pokeByteOff hsc_ptr 0) p ifaceIOName
(\hsc_ptr -> pokeByteOff hsc_ptr 8) p ifaceTX
(\hsc_ptr -> pokeByteOff hsc_ptr 16) p ifaceRX
(\hsc_ptr -> pokeByteOff hsc_ptr 24) p ifaceIPackets
(\hsc_ptr -> pokeByteOff hsc_ptr 32) p ifaceOPackets
(\hsc_ptr -> pokeByteOff hsc_ptr 40) p ifaceIErrors
(\hsc_ptr -> pokeByteOff hsc_ptr 48) p ifaceOErrors
(\hsc_ptr -> pokeByteOff hsc_ptr 56) p ifaceCollisions
(\hsc_ptr -> pokeByteOff hsc_ptr 64) p ifaceSystem
instance Stat (Struct NetworkIO) where
acquire = sg_get_network_io_stats_r
release = sg_free_network_io_stats
foreign import ccall safe "statgrab.h sg_get_network_io_stats"
sg_get_network_io_stats :: Entries -> IO NetworkIOPtr
foreign import ccall safe "statgrab.h sg_get_network_io_stats_r"
sg_get_network_io_stats_r :: Entries -> IO NetworkIOPtr
foreign import ccall safe "statgrab.h sg_get_network_io_stats_diff"
sg_get_network_io_stats_diff :: Entries -> IO NetworkIOPtr
foreign import ccall safe "statgrab.h sg_get_network_io_stats_diff_between"
sg_get_network_io_stats_diff_between :: NetworkIOPtr
-> NetworkIOPtr
-> Entries
-> IO NetworkIOPtr
foreign import ccall safe "statgrab.h sg_network_io_compare_name"
sg_network_io_compare_name :: Ptr () -> Ptr () -> IO (CInt)
foreign import ccall safe "statgrab.h sg_free_stats_buf"
sg_free_network_io_stats :: NetworkIOPtr -> IO Error
duplexFull :: InterfaceMode
duplexFull = InterfaceMode 0
duplexHalf :: InterfaceMode
duplexHalf = InterfaceMode 1
duplexUnknown :: InterfaceMode
duplexUnknown = InterfaceMode 2
statusDown :: InterfaceStatus
statusDown = InterfaceStatus 0
statusUp :: InterfaceStatus
statusUp = InterfaceStatus 1
data instance Struct NetworkInterface = CNetworkInterface
{ ifaceName :: !CString
, ifaceSpeed :: !CULLong
, ifaceFactor :: !CULLong
, ifaceDuplex :: !InterfaceMode
, ifaceUp :: !InterfaceStatus
, ifaceSystime :: !CTime
}
instance Copy NetworkInterface where
copyAt ptr i = do
CNetworkInterface{..} <- peekElemOff ptr i
NetworkInterface <$> packCString ifaceName
<#> ifaceSpeed
<#> ifaceFactor
<!> ifaceDuplex
<!> ifaceUp
<@> ifaceSystime
instance Storable (Struct NetworkInterface) where
alignment _ = 8
sizeOf _ = (40)
peek p = CNetworkInterface
<$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 8) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 16) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 24) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 28) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 32) p
poke p CNetworkInterface{..} = do
(\hsc_ptr -> pokeByteOff hsc_ptr 0) p ifaceName
(\hsc_ptr -> pokeByteOff hsc_ptr 8) p ifaceSpeed
(\hsc_ptr -> pokeByteOff hsc_ptr 16) p ifaceFactor
(\hsc_ptr -> pokeByteOff hsc_ptr 24) p ifaceDuplex
(\hsc_ptr -> pokeByteOff hsc_ptr 28) p ifaceUp
(\hsc_ptr -> pokeByteOff hsc_ptr 32) p ifaceSystime
instance Stat (Struct NetworkInterface) where
acquire = sg_get_network_iface_stats_r
release = sg_free_network_iface_stats
foreign import ccall safe "statgrab.h sg_get_network_iface_stats"
sg_get_network_iface_stats :: Entries -> IO NetworkInterfacePtr
foreign import ccall safe "statgrab.h sg_get_network_iface_stats_r"
sg_get_network_iface_stats_r :: Entries -> IO NetworkInterfacePtr
foreign import ccall safe "statgrab.h sg_network_iface_compare_name"
sg_network_iface_compare_name :: Ptr () -> Ptr () -> IO CInt
foreign import ccall safe "statgrab.h sg_free_stats_buf"
sg_free_network_iface_stats :: NetworkInterfacePtr -> IO Error
data instance Struct Page = CPage
{ pagesIn :: !CULLong
, pagesOut :: !CULLong
, pagesSysTime :: !CTime
}
instance Copy Page where
copyAt ptr i = do
CPage{..} <- peekElemOff ptr i
Page <%> pagesIn
<#> pagesOut
<@> pagesSysTime
instance Storable (Struct Page) where
alignment _ = 8
sizeOf _ = (24)
peek p = CPage
<$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 8) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 16) p
poke p CPage{..} = do
(\hsc_ptr -> pokeByteOff hsc_ptr 0) p pagesIn
(\hsc_ptr -> pokeByteOff hsc_ptr 8) p pagesOut
(\hsc_ptr -> pokeByteOff hsc_ptr 16) p pagesSysTime
instance Stat (Struct Page) where
acquire = sg_get_page_stats_r
release = sg_free_page_stats
foreign import ccall safe "statgrab.h sg_get_page_stats"
sg_get_page_stats :: Entries -> IO PagePtr
foreign import ccall safe "statgrab.h sg_get_page_stats_r"
sg_get_page_stats_r :: Entries -> IO PagePtr
foreign import ccall safe "statgrab.h sg_get_page_stats_diff"
sg_get_page_stats_diff :: Entries -> IO PagePtr
foreign import ccall safe "statgrab.h sg_get_page_stats_diff_between"
sg_get_page_stats_diff_between :: PagePtr
-> PagePtr
-> Entries
-> IO PagePtr
foreign import ccall safe "statgrab.h sg_free_stats_buf"
sg_free_page_stats :: PagePtr -> IO Error
stateRunning :: ProcessState
stateRunning = ProcessState 0
stateSleeping :: ProcessState
stateSleeping = ProcessState 1
stateStopped :: ProcessState
stateStopped = ProcessState 2
stateZombie :: ProcessState
stateZombie = ProcessState 3
stateUnknown :: ProcessState
stateUnknown = ProcessState 4
data instance Struct Process = CProcess
{ procName :: !CString
, procTitle :: !CString
, procPid :: !CInt
, procParent :: !CInt
, procPGid :: !CInt
, procSessId :: !CInt
, procUid :: !CUInt
, procEUid :: !CUInt
, procGid :: !CUInt
, procEGid :: !CUInt
, procSwitches :: !CULLong
, procVoluntary :: !CULLong
, procInvoluntary :: !CULLong
, procSize :: !CULLong
, procResident :: !CULLong
, procStart :: !CTime
, procSpent :: !CTime
, procCPUPercent :: !CDouble
, procNice :: !CInt
, procState :: !ProcessState
, procSystime :: !CTime
}
instance Copy Process where
copyAt ptr i = do
CProcess{..} <- peekElemOff ptr i
Process <$> packCString procName
<*> packCString procTitle
<#> procPid
<#> procParent
<#> procPGid
<#> procSessId
<#> procUid
<#> procEUid
<#> procGid
<#> procEGid
<#> procSwitches
<#> procVoluntary
<#> procInvoluntary
<#> procSize
<#> procResident
<@> procStart
<@> procSpent
<@> procCPUPercent
<#> procNice
<!> procState
<@> procSystime
instance Storable (Struct Process) where
alignment _ = 8
sizeOf _ = (128)
peek p = CProcess
<$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 8) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 16) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 20) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 24) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 28) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 32) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 36) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 40) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 44) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 48) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 56) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 64) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 72) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 80) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 88) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 96) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 104) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 112) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 116) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 120) p
poke p CProcess{..} = do
(\hsc_ptr -> pokeByteOff hsc_ptr 0) p procName
(\hsc_ptr -> pokeByteOff hsc_ptr 8) p procTitle
(\hsc_ptr -> pokeByteOff hsc_ptr 16) p procPid
(\hsc_ptr -> pokeByteOff hsc_ptr 20) p procParent
(\hsc_ptr -> pokeByteOff hsc_ptr 24) p procPGid
(\hsc_ptr -> pokeByteOff hsc_ptr 28) p procSessId
(\hsc_ptr -> pokeByteOff hsc_ptr 32) p procUid
(\hsc_ptr -> pokeByteOff hsc_ptr 36) p procEUid
(\hsc_ptr -> pokeByteOff hsc_ptr 40) p procGid
(\hsc_ptr -> pokeByteOff hsc_ptr 44) p procEGid
(\hsc_ptr -> pokeByteOff hsc_ptr 48) p procSwitches
(\hsc_ptr -> pokeByteOff hsc_ptr 56) p procVoluntary
(\hsc_ptr -> pokeByteOff hsc_ptr 64) p procInvoluntary
(\hsc_ptr -> pokeByteOff hsc_ptr 72) p procSize
(\hsc_ptr -> pokeByteOff hsc_ptr 80) p procResident
(\hsc_ptr -> pokeByteOff hsc_ptr 88) p procStart
(\hsc_ptr -> pokeByteOff hsc_ptr 96) p procSpent
(\hsc_ptr -> pokeByteOff hsc_ptr 104) p procCPUPercent
(\hsc_ptr -> pokeByteOff hsc_ptr 112) p procNice
(\hsc_ptr -> pokeByteOff hsc_ptr 116) p procState
(\hsc_ptr -> pokeByteOff hsc_ptr 120) p procSystime
instance Stat (Struct Process) where
acquire = sg_get_process_stats_r
release = sg_free_process_stats
foreign import ccall safe "statgrab.h sg_get_process_stats"
sg_get_process_stats :: Entries -> IO ProcessPtr
foreign import ccall safe "statgrab.h sg_get_process_stats_r"
sg_get_process_stats_r :: Entries -> IO ProcessPtr
foreign import ccall safe "statgrab.h sg_process_compare_name"
sg_process_compare_name :: Ptr () -> Ptr () -> IO CInt
foreign import ccall safe "statgrab.h sg_process_compare_pid"
sg_process_compare_pid :: Ptr () -> Ptr () -> IO CInt
foreign import ccall safe "statgrab.h sg_process_compare_uid"
sg_process_compare_uid :: Ptr () -> Ptr () -> IO CInt
foreign import ccall safe "statgrab.h sg_process_compare_gid"
sg_process_compare_gid :: Ptr () -> Ptr () -> IO CInt
foreign import ccall safe "statgrab.h sg_process_compare_size"
sg_process_compare_size :: Ptr () -> Ptr () -> IO CInt
foreign import ccall safe "statgrab.h sg_process_compare_res"
sg_process_compare_res :: Ptr () -> Ptr () -> IO CInt
foreign import ccall safe "statgrab.h sg_process_compare_cpu"
sg_process_compare_cpu :: Ptr () -> Ptr () -> IO CInt
foreign import ccall safe "statgrab.h sg_process_compare_time"
sg_process_compare_time :: Ptr () -> Ptr () -> IO CInt
foreign import ccall safe "statgrab.h sg_free_stats_buf"
sg_free_process_stats :: ProcessPtr -> IO Error
sourceEntire :: ProcessSource
sourceEntire = ProcessSource 0
sourceLast :: ProcessSource
sourceLast = ProcessSource 1
data instance Struct ProcessCount = CProcessCount
{ countTotal :: !CULLong
, countRunning :: !CULLong
, countSleeping :: !CULLong
, countStopped :: !CULLong
, countZombie :: !CULLong
, countUnknown :: !CULLong
, countSystime :: !CTime
}
instance Copy ProcessCount where
copyAt ptr i = do
CProcessCount{..} <- peekElemOff ptr i
ProcessCount <%> countTotal
<#> countRunning
<#> countSleeping
<#> countStopped
<#> countZombie
<#> countUnknown
<@> countSystime
instance Storable (Struct ProcessCount) where
alignment _ = 8
sizeOf _ = (56)
peek p = CProcessCount
<$> (\hsc_ptr -> peekByteOff hsc_ptr 0) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 8) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 16) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 24) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 32) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 40) p
<*> (\hsc_ptr -> peekByteOff hsc_ptr 48) p
poke p CProcessCount{..} = do
(\hsc_ptr -> pokeByteOff hsc_ptr 0) p countTotal
(\hsc_ptr -> pokeByteOff hsc_ptr 8) p countRunning
(\hsc_ptr -> pokeByteOff hsc_ptr 16) p countSleeping
(\hsc_ptr -> pokeByteOff hsc_ptr 24) p countStopped
(\hsc_ptr -> pokeByteOff hsc_ptr 32) p countZombie
(\hsc_ptr -> pokeByteOff hsc_ptr 40) p countUnknown
(\hsc_ptr -> pokeByteOff hsc_ptr 48) p countSystime
foreign import ccall safe "statgrab.h sg_get_process_count_of"
sg_get_process_count_of :: ProcessSource -> IO ProcessCountPtr
foreign import ccall safe "statgrab.h sg_get_process_count_r"
sg_get_process_count_r :: ProcessPtr -> IO ProcessCountPtr
foreign import ccall safe "statgrab.h sg_free_stats_buf"
sg_free_process_count :: ProcessCountPtr -> IO Error