]> git.ipfire.org Git - thirdparty/mdadm.git/blob - mdstat.c
Release mdadm-3.3.4
[thirdparty/mdadm.git] / mdstat.c
1 /*
2 * mdstat - parse /proc/mdstat file. Part of:
3 * mdadm - manage Linux "md" devices aka RAID arrays.
4 *
5 * Copyright (C) 2002-2009 Neil Brown <neilb@suse.de>
6 *
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 *
22 * Author: Neil Brown
23 * Email: <neilb@suse.de>
24 */
25
26 /*
27 * The /proc/mdstat file comes in at least 3 flavours:
28 * In an unpatched 2.2 kernel (md 0.36.6):
29 * Personalities : [n raidx] ...
30 * read_ahead {not set|%d sectors}
31 * md0 : {in}active{ raidX /dev/hda... %d blocks{ maxfault=%d}}
32 * md1 : .....
33 *
34 * Normally only 4 md lines, but all are listed.
35 *
36 * In a patched 2.2 kernel (md 0.90.0)
37 * Personalities : [raidx] ...
38 * read_ahead {not set|%d sectors}
39 * mdN : {in}active {(readonly)} raidX dev[%d]{(F)} ... %d blocks STATUS RESYNC
40 * ... Only initialised arrays listed
41 * unused devices: {dev dev ... | <none>}
42 *
43 * STATUS is personality dependant:
44 * linear: %dk rounding
45 * raid0: %dk chunks
46 * raid1: [%d/%d] [U_U] ( raid/working. operational or not)
47 * raid5: level 4/5, %dk chunk, algorithm %d [%d/%d] [U_U]
48 *
49 * RESYNC is empty or:
50 * {resync|recovery}=%u%% finish=%u.%umin
51 * or
52 * resync=DELAYED
53 *
54 * In a 2.4 kernel (md 0.90.0/2.4)
55 * Personalities : [raidX] ...
56 * read_ahead {not set|%d sectors}
57 * mdN : {in}active {(read-only)} raidX dev[%d]{(F)} ...
58 * %d blocks STATUS
59 * RESYNC
60 * unused devices: {dev dev .. | <none>}
61 *
62 * STATUS matches 0.90.0/2.2
63 * RESYNC includes [===>....],
64 * adds a space after {resync|recovery} and before and after '='
65 * adds a decimal to the recovery percent.
66 * adds (%d/%d) resync amount and max_blocks, before finish.
67 * adds speed=%dK/sec after finish
68 *
69 *
70 *
71 * Out of this we want to extract:
72 * list of devices, active or not
73 * pattern of failed drives (so need number of drives)
74 * percent resync complete
75 *
76 * As continuation is indicated by leading space, we use
77 * conf_line from config.c to read logical lines
78 *
79 */
80
81 #include "mdadm.h"
82 #include "dlink.h"
83 #include <sys/select.h>
84 #include <ctype.h>
85
86 static void free_member_devnames(struct dev_member *m)
87 {
88 while(m) {
89 struct dev_member *t = m;
90
91 m = m->next;
92 free(t->name);
93 free(t);
94 }
95 }
96
97 static int add_member_devname(struct dev_member **m, char *name)
98 {
99 struct dev_member *new;
100 char *t;
101
102 if ((t = strchr(name, '[')) == NULL)
103 /* not a device */
104 return 0;
105
106 new = xmalloc(sizeof(*new));
107 new->name = strndup(name, t - name);
108 new->next = *m;
109 *m = new;
110 return 1;
111 }
112
113 void free_mdstat(struct mdstat_ent *ms)
114 {
115 while (ms) {
116 struct mdstat_ent *t;
117 free(ms->level);
118 free(ms->pattern);
119 free(ms->metadata_version);
120 free_member_devnames(ms->members);
121 t = ms;
122 ms = ms->next;
123 free(t);
124 }
125 }
126
127 static int mdstat_fd = -1;
128 struct mdstat_ent *mdstat_read(int hold, int start)
129 {
130 FILE *f;
131 struct mdstat_ent *all, *rv, **end, **insert_here;
132 char *line;
133 int fd;
134
135 if (hold && mdstat_fd != -1) {
136 lseek(mdstat_fd, 0L, 0);
137 fd = dup(mdstat_fd);
138 if (fd >= 0)
139 f = fdopen(fd, "r");
140 else
141 return NULL;
142 } else
143 f = fopen("/proc/mdstat", "r");
144 if (f == NULL)
145 return NULL;
146 else
147 fcntl(fileno(f), F_SETFD, FD_CLOEXEC);
148
149 all = NULL;
150 end = &all;
151 for (; (line = conf_line(f)) ; free_line(line)) {
152 struct mdstat_ent *ent;
153 char *w;
154 char devnm[32];
155 int in_devs = 0;
156
157 if (strcmp(line, "Personalities")==0)
158 continue;
159 if (strcmp(line, "read_ahead")==0)
160 continue;
161 if (strcmp(line, "unused")==0)
162 continue;
163 insert_here = NULL;
164 /* Better be an md line.. */
165 if (strncmp(line, "md", 2)!= 0 || strlen(line) >= 32
166 || (line[2] != '_' && !isdigit(line[2])))
167 continue;
168 strcpy(devnm, line);
169
170 ent = xmalloc(sizeof(*ent));
171 ent->level = ent->pattern= NULL;
172 ent->next = NULL;
173 ent->percent = RESYNC_NONE;
174 ent->active = -1;
175 ent->resync = 0;
176 ent->metadata_version = NULL;
177 ent->raid_disks = 0;
178 ent->devcnt = 0;
179 ent->members = NULL;
180
181 strcpy(ent->devnm, devnm);
182
183 for (w=dl_next(line); w!= line ; w=dl_next(w)) {
184 int l = strlen(w);
185 char *eq;
186 if (strcmp(w, "active")==0)
187 ent->active = 1;
188 else if (strcmp(w, "inactive")==0) {
189 ent->active = 0;
190 in_devs = 1;
191 } else if (ent->active > 0 &&
192 ent->level == NULL &&
193 w[0] != '(' /*readonly*/) {
194 ent->level = xstrdup(w);
195 in_devs = 1;
196 } else if (in_devs && strcmp(w, "blocks")==0)
197 in_devs = 0;
198 else if (in_devs) {
199 char *ep = strchr(w, '[');
200 ent->devcnt +=
201 add_member_devname(&ent->members, w);
202 if (ep && strncmp(w, "md", 2)==0) {
203 /* This has an md device as a component.
204 * If that device is already in the
205 * list, make sure we insert before
206 * there.
207 */
208 struct mdstat_ent **ih;
209 ih = &all;
210 while (ih != insert_here && *ih &&
211 ((int)strlen((*ih)->devnm) != ep-w
212 || strncmp((*ih)->devnm, w, ep-w) != 0))
213 ih = & (*ih)->next;
214 insert_here = ih;
215 }
216 } else if (strcmp(w, "super") == 0 &&
217 dl_next(w) != line) {
218 w = dl_next(w);
219 ent->metadata_version = xstrdup(w);
220 } else if (w[0] == '[' && isdigit(w[1])) {
221 ent->raid_disks = atoi(w+1);
222 } else if (!ent->pattern &&
223 w[0] == '[' &&
224 (w[1] == 'U' || w[1] == '_')) {
225 ent->pattern = xstrdup(w+1);
226 if (ent->pattern[l-2]==']')
227 ent->pattern[l-2] = '\0';
228 } else if (ent->percent == RESYNC_NONE &&
229 strncmp(w, "re", 2)== 0 &&
230 w[l-1] == '%' &&
231 (eq=strchr(w, '=')) != NULL ) {
232 ent->percent = atoi(eq+1);
233 if (strncmp(w,"resync", 6)==0)
234 ent->resync = 1;
235 else if (strncmp(w, "reshape", 7)==0)
236 ent->resync = 2;
237 else
238 ent->resync = 0;
239 } else if (ent->percent == RESYNC_NONE &&
240 (w[0] == 'r' || w[0] == 'c')) {
241 if (strncmp(w, "resync", 4)==0)
242 ent->resync = 1;
243 if (strncmp(w, "reshape", 7)==0)
244 ent->resync = 2;
245 if (strncmp(w, "recovery", 8)==0)
246 ent->resync = 0;
247 if (strncmp(w, "check", 5)==0)
248 ent->resync = 3;
249
250 if (l > 8 && strcmp(w+l-8, "=DELAYED") == 0)
251 ent->percent = RESYNC_DELAYED;
252 if (l > 8 && strcmp(w+l-8, "=PENDING") == 0)
253 ent->percent = RESYNC_PENDING;
254 } else if (ent->percent == RESYNC_NONE &&
255 w[0] >= '0' &&
256 w[0] <= '9' &&
257 w[l-1] == '%') {
258 ent->percent = atoi(w);
259 }
260 }
261 if (insert_here && (*insert_here)) {
262 ent->next = *insert_here;
263 *insert_here = ent;
264 } else {
265 *end = ent;
266 end = &ent->next;
267 }
268 }
269 if (hold && mdstat_fd == -1) {
270 mdstat_fd = dup(fileno(f));
271 fcntl(mdstat_fd, F_SETFD, FD_CLOEXEC);
272 }
273 fclose(f);
274
275 /* If we might want to start array,
276 * reverse the order, so that components comes before composites
277 */
278 if (start) {
279 rv = NULL;
280 while (all) {
281 struct mdstat_ent *e = all;
282 all = all->next;
283 e->next = rv;
284 rv = e;
285 }
286 } else rv = all;
287 return rv;
288 }
289
290 void mdstat_close(void)
291 {
292 if (mdstat_fd >= 0)
293 close(mdstat_fd);
294 mdstat_fd = -1;
295 }
296
297 void mdstat_wait(int seconds)
298 {
299 fd_set fds;
300 struct timeval tm;
301 int maxfd = 0;
302 FD_ZERO(&fds);
303 if (mdstat_fd >= 0) {
304 FD_SET(mdstat_fd, &fds);
305 maxfd = mdstat_fd;
306 }
307 tm.tv_sec = seconds;
308 tm.tv_usec = 0;
309 select(maxfd + 1, NULL, NULL, &fds, &tm);
310 }
311
312 void mdstat_wait_fd(int fd, const sigset_t *sigmask)
313 {
314 fd_set fds, rfds;
315 int maxfd = 0;
316
317 FD_ZERO(&fds);
318 FD_ZERO(&rfds);
319 if (mdstat_fd >= 0)
320 FD_SET(mdstat_fd, &fds);
321
322 if (fd >= 0) {
323 struct stat stb;
324 fstat(fd, &stb);
325 if ((stb.st_mode & S_IFMT) == S_IFREG)
326 /* Must be a /proc or /sys fd, so expect
327 * POLLPRI
328 * i.e. an 'exceptional' event.
329 */
330 FD_SET(fd, &fds);
331 else
332 FD_SET(fd, &rfds);
333
334 if (fd > maxfd)
335 maxfd = fd;
336
337 }
338 if (mdstat_fd > maxfd)
339 maxfd = mdstat_fd;
340
341 pselect(maxfd + 1, &rfds, NULL, &fds,
342 NULL, sigmask);
343 }
344
345 int mddev_busy(char *devnm)
346 {
347 struct mdstat_ent *mdstat = mdstat_read(0, 0);
348 struct mdstat_ent *me;
349
350 for (me = mdstat ; me ; me = me->next)
351 if (strcmp(me->devnm, devnm) == 0)
352 break;
353 free_mdstat(mdstat);
354 return me != NULL;
355 }
356
357 struct mdstat_ent *mdstat_by_component(char *name)
358 {
359 struct mdstat_ent *mdstat = mdstat_read(0, 0);
360
361 while (mdstat) {
362 struct dev_member *m;
363 struct mdstat_ent *ent;
364 if (mdstat->metadata_version &&
365 strncmp(mdstat->metadata_version, "external:", 9) == 0 &&
366 is_subarray(mdstat->metadata_version+9))
367 /* don't return subarrays, only containers */
368 ;
369 else for (m = mdstat->members; m; m = m->next) {
370 if (strcmp(m->name, name) == 0) {
371 free_mdstat(mdstat->next);
372 mdstat->next = NULL;
373 return mdstat;
374 }
375 }
376 ent = mdstat;
377 mdstat = mdstat->next;
378 ent->next = NULL;
379 free_mdstat(ent);
380 }
381 return NULL;
382 }
383
384 struct mdstat_ent *mdstat_by_subdev(char *subdev, char *container)
385 {
386 struct mdstat_ent *mdstat = mdstat_read(0, 0);
387 struct mdstat_ent *ent = NULL;
388
389 while (mdstat) {
390 /* metadata version must match:
391 * external:[/-]%s/%s
392 * where first %s is 'container' and second %s is 'subdev'
393 */
394 if (ent)
395 free_mdstat(ent);
396 ent = mdstat;
397 mdstat = mdstat->next;
398 ent->next = NULL;
399
400 if (ent->metadata_version == NULL ||
401 strncmp(ent->metadata_version, "external:", 9) != 0)
402 continue;
403
404 if (!metadata_container_matches(ent->metadata_version+9,
405 container) ||
406 !metadata_subdev_matches(ent->metadata_version+9,
407 subdev))
408 continue;
409
410 free_mdstat(mdstat);
411 return ent;
412 }
413 return NULL;
414 }