mdstat.go 6.21 KB
Newer Older
ale's avatar
ale committed
1
2
3
4
5
6
7
8
9
10
11
12
13
// Copyright 2018 The Prometheus Authors
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

ale's avatar
ale committed
14
15
16
17
18
19
20
21
22
23
24
package procfs

import (
	"fmt"
	"io/ioutil"
	"regexp"
	"strconv"
	"strings"
)

var (
25
26
27
	statusLineRE      = regexp.MustCompile(`(\d+) blocks .*\[(\d+)/(\d+)\] \[[U_]+\]`)
	recoveryLineRE    = regexp.MustCompile(`\((\d+)/\d+\)`)
	componentDeviceRE = regexp.MustCompile(`(.*)\[\d+\]`)
ale's avatar
ale committed
28
29
30
31
32
33
34
35
36
37
)

// MDStat holds info parsed from /proc/mdstat.
type MDStat struct {
	// Name of the device.
	Name string
	// activity-state of the device.
	ActivityState string
	// Number of active disks.
	DisksActive int64
38
	// Total number of disks the device requires.
ale's avatar
ale committed
39
	DisksTotal int64
40
41
42
43
	// Number of failed disks.
	DisksFailed int64
	// Spare disks in the device.
	DisksSpare int64
ale's avatar
ale committed
44
45
46
47
	// Number of blocks the device holds.
	BlocksTotal int64
	// Number of blocks on the device that are in sync.
	BlocksSynced int64
48
49
	// Name of md component devices
	Devices []string
ale's avatar
ale committed
50
51
}

52
53
54
55
56
// MDStat parses an mdstat-file (/proc/mdstat) and returns a slice of
// structs containing the relevant info.  More information available here:
// https://raid.wiki.kernel.org/index.php/Mdstat
func (fs FS) MDStat() ([]MDStat, error) {
	data, err := ioutil.ReadFile(fs.proc.Path("mdstat"))
ale's avatar
ale committed
57
	if err != nil {
58
		return nil, err
ale's avatar
ale committed
59
	}
60
61
	mdstat, err := parseMDStat(data)
	if err != nil {
62
		return nil, fmt.Errorf("error parsing mdstat %q: %w", fs.proc.Path("mdstat"), err)
63
64
65
	}
	return mdstat, nil
}
ale's avatar
ale committed
66

67
68
69
70
71
72
73
74
75
76
// parseMDStat parses data from mdstat file (/proc/mdstat) and returns a slice of
// structs containing the relevant info.
func parseMDStat(mdStatData []byte) ([]MDStat, error) {
	mdStats := []MDStat{}
	lines := strings.Split(string(mdStatData), "\n")

	for i, line := range lines {
		if strings.TrimSpace(line) == "" || line[0] == ' ' ||
			strings.HasPrefix(line, "Personalities") ||
			strings.HasPrefix(line, "unused") {
ale's avatar
ale committed
77
78
79
			continue
		}

80
81
82
		deviceFields := strings.Fields(line)
		if len(deviceFields) < 3 {
			return nil, fmt.Errorf("not enough fields in mdline (expected at least 3): %s", line)
ale's avatar
ale committed
83
		}
84
85
		mdName := deviceFields[0] // mdx
		state := deviceFields[2]  // active or inactive
ale's avatar
ale committed
86
87

		if len(lines) <= i+3 {
88
			return nil, fmt.Errorf("error parsing %q: too few lines for md device", mdName)
ale's avatar
ale committed
89
90
		}

91
92
93
94
95
		// Failed disks have the suffix (F) & Spare disks have the suffix (S).
		fail := int64(strings.Count(line, "(F)"))
		spare := int64(strings.Count(line, "(S)"))
		active, total, size, err := evalStatusLine(lines[i], lines[i+1])

ale's avatar
ale committed
96
		if err != nil {
97
			return nil, fmt.Errorf("error parsing md device lines: %w", err)
ale's avatar
ale committed
98
99
		}

100
		syncLineIdx := i + 2
ale's avatar
ale committed
101
		if strings.Contains(lines[i+2], "bitmap") { // skip bitmap line
102
			syncLineIdx++
ale's avatar
ale committed
103
104
105
106
107
		}

		// If device is syncing at the moment, get the number of currently
		// synced bytes, otherwise that number equals the size of the device.
		syncedBlocks := size
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
		recovering := strings.Contains(lines[syncLineIdx], "recovery")
		resyncing := strings.Contains(lines[syncLineIdx], "resync")
		checking := strings.Contains(lines[syncLineIdx], "check")

		// Append recovery and resyncing state info.
		if recovering || resyncing || checking {
			if recovering {
				state = "recovering"
			} else if checking {
				state = "checking"
			} else {
				state = "resyncing"
			}

			// Handle case when resync=PENDING or resync=DELAYED.
			if strings.Contains(lines[syncLineIdx], "PENDING") ||
				strings.Contains(lines[syncLineIdx], "DELAYED") {
				syncedBlocks = 0
			} else {
				syncedBlocks, err = evalRecoveryLine(lines[syncLineIdx])
				if err != nil {
129
					return nil, fmt.Errorf("error parsing sync line in md device %q: %w", mdName, err)
130
				}
ale's avatar
ale committed
131
132
133
			}
		}

134
		mdStats = append(mdStats, MDStat{
ale's avatar
ale committed
135
			Name:          mdName,
136
			ActivityState: state,
ale's avatar
ale committed
137
			DisksActive:   active,
138
139
			DisksFailed:   fail,
			DisksSpare:    spare,
ale's avatar
ale committed
140
141
142
			DisksTotal:    total,
			BlocksTotal:   size,
			BlocksSynced:  syncedBlocks,
143
			Devices:       evalComponentDevices(deviceFields),
ale's avatar
ale committed
144
145
146
		})
	}

147
	return mdStats, nil
ale's avatar
ale committed
148
149
}

150
func evalStatusLine(deviceLine, statusLine string) (active, total, size int64, err error) {
ale's avatar
ale committed
151

152
153
	sizeStr := strings.Fields(statusLine)[0]
	size, err = strconv.ParseInt(sizeStr, 10, 64)
ale's avatar
ale committed
154
	if err != nil {
155
		return 0, 0, 0, fmt.Errorf("unexpected statusLine %q: %w", statusLine, err)
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
	}

	if strings.Contains(deviceLine, "raid0") || strings.Contains(deviceLine, "linear") {
		// In the device deviceLine, only disks have a number associated with them in [].
		total = int64(strings.Count(deviceLine, "["))
		return total, total, size, nil
	}

	if strings.Contains(deviceLine, "inactive") {
		return 0, 0, size, nil
	}

	matches := statusLineRE.FindStringSubmatch(statusLine)
	if len(matches) != 4 {
		return 0, 0, 0, fmt.Errorf("couldn't find all the substring matches: %s", statusLine)
ale's avatar
ale committed
171
172
173
174
	}

	total, err = strconv.ParseInt(matches[2], 10, 64)
	if err != nil {
175
		return 0, 0, 0, fmt.Errorf("unexpected statusLine %q: %w", statusLine, err)
ale's avatar
ale committed
176
177
178
179
	}

	active, err = strconv.ParseInt(matches[3], 10, 64)
	if err != nil {
180
		return 0, 0, 0, fmt.Errorf("unexpected statusLine %q: %w", statusLine, err)
ale's avatar
ale committed
181
182
183
184
185
	}

	return active, total, size, nil
}

186
187
func evalRecoveryLine(recoveryLine string) (syncedBlocks int64, err error) {
	matches := recoveryLineRE.FindStringSubmatch(recoveryLine)
ale's avatar
ale committed
188
	if len(matches) != 2 {
189
		return 0, fmt.Errorf("unexpected recoveryLine: %s", recoveryLine)
ale's avatar
ale committed
190
191
192
193
	}

	syncedBlocks, err = strconv.ParseInt(matches[1], 10, 64)
	if err != nil {
194
		return 0, fmt.Errorf("error parsing int from recoveryLine %q: %w", recoveryLine, err)
ale's avatar
ale committed
195
196
197
198
	}

	return syncedBlocks, nil
}
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213

func evalComponentDevices(deviceFields []string) []string {
	mdComponentDevices := make([]string, 0)
	if len(deviceFields) > 3 {
		for _, field := range deviceFields[4:] {
			match := componentDeviceRE.FindStringSubmatch(field)
			if match == nil {
				continue
			}
			mdComponentDevices = append(mdComponentDevices, match[1])
		}
	}

	return mdComponentDevices
}