-----------------------------------------------------------------------------
-- |
-- Module      :  Plugins.Monitors.Top.Linux
-- Copyright   :  (c) 2010, 2011, 2012, 2013, 2014, 2018 Jose A Ortega Ruiz
-- License     :  BSD-style (see LICENSE)
--
-- Maintainer  :  Jose A Ortega Ruiz <jao@gnu.org>
-- Stability   :  unstable
-- Portability :  unportable
--
--  Process activity and memory consumption monitors
--
-----------------------------------------------------------------------------

{-# LANGUAGE ForeignFunctionInterface #-}

module Xmobar.Plugins.Monitors.Top.Linux (
  timeMemEntries
  , meminfos
  , scale) where

import Xmobar.Plugins.Monitors.Common (parseFloat, parseInt)
import Xmobar.Plugins.Monitors.Top.Common (MemInfo, TimeEntry)

import Control.Exception (SomeException, handle)
import Data.List (foldl')
import System.Directory (getDirectoryContents)
import System.FilePath ((</>))
import System.IO (IOMode(ReadMode), hGetLine, withFile)
import System.Posix.Unistd (SysVar(ClockTick), getSysVar)

import Foreign.C.Types

foreign import ccall "unistd.h getpagesize"
  c_getpagesize :: CInt

pageSize :: Float
pageSize :: Float
pageSize = CInt -> Float
forall a b. (Integral a, Num b) => a -> b
fromIntegral CInt
c_getpagesize Float -> Float -> Float
forall a. Fractional a => a -> a -> a
/ Float
1024

processes :: IO [FilePath]
processes :: IO [[Char]]
processes = ([[Char]] -> [[Char]]) -> IO [[Char]] -> IO [[Char]]
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (([Char] -> Bool) -> [[Char]] -> [[Char]]
forall a. (a -> Bool) -> [a] -> [a]
filter [Char] -> Bool
isPid) ([Char] -> IO [[Char]]
getDirectoryContents [Char]
"/proc")
  where isPid :: [Char] -> Bool
isPid = (Char -> [Char] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Char
'0'..Char
'9']) (Char -> Bool) -> ([Char] -> Char) -> [Char] -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> Char
forall a. HasCallStack => [a] -> a
head

statWords :: [String] -> [String]
statWords :: [[Char]] -> [[Char]]
statWords line :: [[Char]]
line@([Char]
x:[Char]
pn:[Char]
ppn:[[Char]]
xs) =
  if [Char] -> Char
forall a. HasCallStack => [a] -> a
last [Char]
pn Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
')' then [[Char]]
line else [[Char]] -> [[Char]]
statWords ([Char]
x[Char] -> [[Char]] -> [[Char]]
forall a. a -> [a] -> [a]
:([Char]
pn [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
ppn)[Char] -> [[Char]] -> [[Char]]
forall a. a -> [a] -> [a]
:[[Char]]
xs)
statWords [[Char]]
_ = Int -> [Char] -> [[Char]]
forall a. Int -> a -> [a]
replicate Int
52 [Char]
"0"

getProcessData :: FilePath -> IO [String]
getProcessData :: [Char] -> IO [[Char]]
getProcessData [Char]
pidf =
  (SomeException -> IO [[Char]]) -> IO [[Char]] -> IO [[Char]]
forall e a. Exception e => (e -> IO a) -> IO a -> IO a
handle SomeException -> IO [[Char]]
ign (IO [[Char]] -> IO [[Char]]) -> IO [[Char]] -> IO [[Char]]
forall a b. (a -> b) -> a -> b
$ [Char] -> IOMode -> (Handle -> IO [[Char]]) -> IO [[Char]]
forall r. [Char] -> IOMode -> (Handle -> IO r) -> IO r
withFile ([Char]
"/proc" [Char] -> [Char] -> [Char]
</> [Char]
pidf [Char] -> [Char] -> [Char]
</> [Char]
"stat") IOMode
ReadMode Handle -> IO [[Char]]
readWords
  where readWords :: Handle -> IO [[Char]]
readWords = ([Char] -> [[Char]]) -> IO [Char] -> IO [[Char]]
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ([[Char]] -> [[Char]]
statWords ([[Char]] -> [[Char]])
-> ([Char] -> [[Char]]) -> [Char] -> [[Char]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> [[Char]]
words) (IO [Char] -> IO [[Char]])
-> (Handle -> IO [Char]) -> Handle -> IO [[Char]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Handle -> IO [Char]
hGetLine
        ign :: SomeException -> IO [[Char]]
ign = IO [[Char]] -> SomeException -> IO [[Char]]
forall a b. a -> b -> a
const ([[Char]] -> IO [[Char]]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return []) :: SomeException -> IO [String]

memPages :: [String] -> String
memPages :: [[Char]] -> [Char]
memPages [[Char]]
fs = [[Char]]
fs[[Char]] -> Int -> [Char]
forall a. HasCallStack => [a] -> Int -> a
!!Int
23

ppid :: [String] -> String
ppid :: [[Char]] -> [Char]
ppid [[Char]]
fs = [[Char]]
fs[[Char]] -> Int -> [Char]
forall a. HasCallStack => [a] -> Int -> a
!!Int
3

skip :: [String] -> Bool
skip :: [[Char]] -> Bool
skip [[Char]]
fs = [[Char]] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [[Char]]
fs Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
24 Bool -> Bool -> Bool
|| [[Char]] -> [Char]
memPages [[Char]]
fs [Char] -> [Char] -> Bool
forall a. Eq a => a -> a -> Bool
== [Char]
"0" Bool -> Bool -> Bool
|| [[Char]] -> [Char]
ppid [[Char]]
fs [Char] -> [Char] -> Bool
forall a. Eq a => a -> a -> Bool
== [Char]
"0"

handleProcesses :: ([String] -> a) -> IO [a]
handleProcesses :: forall a. ([[Char]] -> a) -> IO [a]
handleProcesses [[Char]] -> a
f =
  ([[[Char]]] -> [a]) -> IO [[[Char]]] -> IO [a]
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (([a] -> [[Char]] -> [a]) -> [a] -> [[[Char]]] -> [a]
forall b a. (b -> a -> b) -> b -> [a] -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl' (\[a]
a [[Char]]
p -> if [[Char]] -> Bool
skip [[Char]]
p then [a]
a else [[Char]] -> a
f [[Char]]
p a -> [a] -> [a]
forall a. a -> [a] -> [a]
: [a]
a) [])
       (IO [[Char]]
processes IO [[Char]] -> ([[Char]] -> IO [[[Char]]]) -> IO [[[Char]]]
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ([Char] -> IO [[Char]]) -> [[Char]] -> IO [[[Char]]]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM [Char] -> IO [[Char]]
getProcessData)

processName :: [String] -> String
processName :: [[Char]] -> [Char]
processName = Int -> [Char] -> [Char]
forall a. Int -> [a] -> [a]
drop Int
1 ([Char] -> [Char]) -> ([[Char]] -> [Char]) -> [[Char]] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> [Char]
forall a. HasCallStack => [a] -> [a]
init ([Char] -> [Char]) -> ([[Char]] -> [Char]) -> [[Char]] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([[Char]] -> Int -> [Char]
forall a. HasCallStack => [a] -> Int -> a
!!Int
1)

meminfo :: [String] -> MemInfo
meminfo :: [[Char]] -> MemInfo
meminfo [[Char]]
fs = ([[Char]] -> [Char]
processName [[Char]]
fs, Float
pageSize Float -> Float -> Float
forall a. Num a => a -> a -> a
* [Char] -> Float
parseFloat ([[Char]]
fs[[Char]] -> Int -> [Char]
forall a. HasCallStack => [a] -> Int -> a
!!Int
23))

meminfos :: IO [MemInfo]
meminfos :: IO [MemInfo]
meminfos = ([[Char]] -> MemInfo) -> IO [MemInfo]
forall a. ([[Char]] -> a) -> IO [a]
handleProcesses [[Char]] -> MemInfo
meminfo

timeMemEntry :: [String] -> (TimeEntry, MemInfo)
timeMemEntry :: [[Char]] -> (TimeEntry, MemInfo)
timeMemEntry [[Char]]
fs = ((Int
p, ([Char]
n, Float
t)), ([Char]
n, Float
r))
  where p :: Int
p = [Char] -> Int
parseInt ([[Char]] -> [Char]
forall a. HasCallStack => [a] -> a
head [[Char]]
fs)
        n :: [Char]
n = [[Char]] -> [Char]
processName [[Char]]
fs
        t :: Float
t = [Char] -> Float
parseFloat ([[Char]]
fs[[Char]] -> Int -> [Char]
forall a. HasCallStack => [a] -> Int -> a
!!Int
13) Float -> Float -> Float
forall a. Num a => a -> a -> a
+ [Char] -> Float
parseFloat ([[Char]]
fs[[Char]] -> Int -> [Char]
forall a. HasCallStack => [a] -> Int -> a
!!Int
14)
        ([Char]
_, Float
r) = [[Char]] -> MemInfo
meminfo [[Char]]
fs

timeMemEntries :: IO [(TimeEntry, MemInfo)]
timeMemEntries :: IO [(TimeEntry, MemInfo)]
timeMemEntries = ([[Char]] -> (TimeEntry, MemInfo)) -> IO [(TimeEntry, MemInfo)]
forall a. ([[Char]] -> a) -> IO [a]
handleProcesses [[Char]] -> (TimeEntry, MemInfo)
timeMemEntry


scale :: IO Float
scale :: IO Float
scale = do
  cr <- SysVar -> IO Integer
getSysVar SysVar
ClockTick
  return $ fromIntegral cr / 100