1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
|
-----------------------------------------------------------------------------
-- |
-- Module : Plugins.Monitors.Disk.Linux
-- Copyright : (c) 2010, 2011, 2012, 2014, 2018, 2019 Jose A Ortega Ruiz
-- License : BSD-style (see LICENSE)
--
-- Maintainer : Jose A Ortega Ruiz <jao@gnu.org>
-- Stability : unstable
-- Portability : unportable
--
-- Disk usage and throughput monitors for Xmobar
--
-----------------------------------------------------------------------------
module Xmobar.Plugins.Monitors.Disk.Linux
(
fetchDataIO
, fetchDataUsage
, initializeDevDataRef
, DevDataRef
) where
import Data.IORef (
IORef
, newIORef
, readIORef
, writeIORef
)
import Xmobar.System.StatFS (
getFileSystemStats
, fsStatByteCount
, fsStatBytesAvailable
, fsStatBytesUsed
)
import qualified Data.ByteString.Lazy.Char8 as B
import Data.List (isPrefixOf, find)
import Data.Maybe (catMaybes)
import System.Directory (canonicalizePath, doesFileExist)
import Control.Exception (SomeException, handle)
import Xmobar.Plugins.Monitors.Disk.Common (
DevName
, Path
)
type DevDataRef = IORef [(DevName, [Float])]
fsStats :: String -> IO [Integer]
fsStats path = do
stats <- getFileSystemStats path
case stats of
Nothing -> return [0, 0, 0]
Just f -> let tot = fsStatByteCount f
free = fsStatBytesAvailable f
used = fsStatBytesUsed f
in return [tot, free, used]
mountedDevices :: [String] -> IO [(DevName, Path)]
mountedDevices req = do
s <- B.readFile "/etc/mtab"
parse `fmap` mapM mbcanon (devs s)
where
mbcanon (d, p) = doesFileExist d >>= \e ->
if e
then Just `fmap` canon (d,p)
else return Nothing
canon (d, p) = do {d' <- canonicalizePath d; return (d', p)}
devs = filter isDev . map (firstTwo . B.words) . B.lines
parse = map undev . filter isReq . catMaybes
firstTwo (a:b:_) = (B.unpack a, B.unpack b)
firstTwo _ = ("", "")
isDev (d, _) = "/dev/" `isPrefixOf` d
isReq (d, p) = p `elem` req || drop 5 d `elem` req
undev (d, f) = (drop 5 d, f)
diskDevices :: [String] -> IO [(DevName, Path)]
diskDevices req = do
s <- B.readFile "/proc/diskstats"
parse `fmap` mapM canon (devs s)
where
canon (d, p) = do {d' <- canonicalizePath d; return (d', p)}
devs = map (third . B.words) . B.lines
parse = map undev . filter isReq
third (_:_:c:_) = ("/dev/" ++ B.unpack c, B.unpack c)
third _ = ("", "")
isReq (d, p) = p `elem` req || drop 5 d `elem` req
undev (d, f) = (drop 5 d, f)
mountedOrDiskDevices :: [String] -> IO [(DevName, Path)]
mountedOrDiskDevices req = do
mnt <- mountedDevices req
case mnt of
[] -> diskDevices req
other -> return other
diskData :: IO [(DevName, [Float])]
diskData = do
s <- B.readFile "/proc/diskstats"
let extract ws = (head ws, map read (tail ws))
return $ map (extract . map B.unpack . drop 2 . B.words) (B.lines s)
mountedData :: DevDataRef -> [DevName] -> IO [(DevName, [Float])]
mountedData dref devs = do
dt <- readIORef dref
dt' <- diskData
writeIORef dref dt'
return $ map (parseDev (zipWith diff dt' dt)) devs
where diff (dev, xs) (_, ys) = (dev, zipWith (-) xs ys)
parseDev :: [(DevName, [Float])] -> DevName -> (DevName, [Float])
parseDev dat dev =
case find ((==dev) . fst) dat of
Nothing -> (dev, [0, 0, 0])
Just (_, xs) ->
let r = 4096 * xs !! 2
w = 4096 * xs !! 6
t = r + w
rSp = speed r (xs !! 3)
wSp = speed w (xs !! 7)
sp = speed t (xs !! 3 + xs !! 7)
speed x d = if d == 0 then 0 else x / d
dat' = if length xs > 6
then [sp, rSp, wSp, t, r, w]
else [0, 0, 0, 0, 0, 0]
in (dev, dat')
fetchDataIO :: DevDataRef -> [(String, String)] -> IO [(String, [Float])]
fetchDataIO dref disks = do
dev <- mountedOrDiskDevices (map fst disks)
mountedData dref (map fst dev)
fetchDataUsage :: [(String, String)] -> IO [((String, String), [Integer])]
fetchDataUsage disks = do
devs <- mountedDevices (map fst disks)
mapM fetchStats devs
where
fetchStats :: (String, String) -> IO ((String, String), [Integer])
fetchStats (dev, path) = do
stats <- handle ign $ fsStats path
return ((dev, path), stats)
ign = const (return [0, 0, 0]) :: SomeException -> IO [Integer]
initializeDevDataRef :: [(String, String)] -> IO DevDataRef
initializeDevDataRef disks = do
dev <- mountedOrDiskDevices (map fst disks)
newIORef (map (\d -> (fst d, repeat 0)) dev)
|
