2
* mdadm - manage Linux "md" devices aka RAID arrays.
4
* Copyright (C) 2001-2002 Neil Brown <neilb@cse.unsw.edu.au>
7
* This program is free software; you can redistribute it and/or modify
8
* it under the terms of the GNU General Public License as published by
9
* the Free Software Foundation; either version 2 of the License, or
10
* (at your option) any later version.
12
* This program is distributed in the hope that it will be useful,
13
* but WITHOUT ANY WARRANTY; without even the implied warranty of
14
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15
* GNU General Public License for more details.
17
* You should have received a copy of the GNU General Public License
18
* along with this program; if not, write to the Free Software
19
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22
* Email: <neilb@cse.unsw.edu.au>
24
* School of Computer Science and Engineering
25
* The University of New South Wales
34
#include <sys/signal.h>
37
static void alert(char *event, char *dev, char *disc, char *mailaddr, char *cmd);
39
static char *percentalerts[] = {
47
int Monitor(mddev_dev_t devlist,
48
char *mailaddr, char *alert_cmd,
49
int period, int daemonise, int scan, int oneshot,
50
char *config, int test)
53
* Every few seconds, scan every md device looking for changes
54
* When a change is found, log it, possibly run the alert command,
55
* and possibly send Email
57
* For each array, we record:
59
* active/working/failed/spare drives
60
* State of each device.
61
* %rebuilt if rebuilding
63
* If the update time changes, check out all the data again
64
* It is possible that we cannot get the state of each device
65
* due to bugs in the md kernel module.
66
* We also read /proc/mdstat to get rebuild percent,
67
* and to get state on all active devices incase of kernel bug.
71
* An active device had Faulty set or Active/Sync removed
73
* A spare device had Faulty set
75
* An active device had a reverse transition
77
* percent went from -1 to +ve
78
* Rebuild20 Rebuild40 Rebuild60 Rebuild80
79
* percent went from below to not-below that number
81
* Couldn't access a device which was previously visible
83
* if we detect an array with active<raid and spare==0
84
* we look at other arrays that have same spare-group
85
* If we find one with active==raid and spare>0,
86
* and if we can get_disk_info and find a name
87
* Then we hot-remove and hot-add to the other array
89
* If devlist is NULL, then we can monitor everything because --scan
90
* was given. We get an initial list from config file and add anything
91
* that appears in /proc/mdstat
96
int devnum; /* to sync with mdstat info */
100
int active, working, failed, spare, raid;
102
int devstate[MD_SB_DISKS];
103
int devid[MD_SB_DISKS];
108
struct mdstat_ent *mdstat = NULL;
111
mailaddr = conf_get_mailaddr(config);
112
if (mailaddr && ! scan)
113
fprintf(stderr, Name ": Monitor using email address \"%s\" from config file\n",
117
alert_cmd = conf_get_program(config);
118
if (alert_cmd && ! scan)
119
fprintf(stderr, Name ": Monitor using program \"%s\" from config file\n",
122
if (scan && !mailaddr && !alert_cmd) {
123
fprintf(stderr, Name ": No mail address or alert command - not monitoring.\n");
138
open("/dev/null", 3);
144
if (devlist == NULL) {
145
mddev_ident_t mdlist = conf_get_ident(config, NULL);
146
for (; mdlist; mdlist=mdlist->next) {
147
struct state *st = malloc(sizeof *st);
150
st->devname = strdup(mdlist->devname);
152
st->next = statelist;
156
st->expected_spares = mdlist->spare_disks;
157
if (mdlist->spare_group)
158
st->spare_group = strdup(mdlist->spare_group);
160
st->spare_group = NULL;
165
for (dv=devlist ; dv; dv=dv->next) {
166
struct state *st = malloc(sizeof *st);
169
st->devname = strdup(dv->devname);
171
st->next = statelist;
175
st->expected_spares = -1;
176
st->spare_group = NULL;
188
mdstat = mdstat_read();
190
for (st=statelist; st; st=st->next) {
191
mdu_array_info_t array;
192
struct mdstat_ent *mse;
193
char *dev = st->devname;
198
alert("TestMessage", dev, NULL, mailaddr, alert_cmd);
199
fd = open(dev, O_RDONLY);
202
alert("DeviceDisappeared", dev, NULL,
203
mailaddr, alert_cmd);
204
/* fprintf(stderr, Name ": cannot open %s: %s\n",
205
dev, strerror(errno));
209
if (ioctl(fd, GET_ARRAY_INFO, &array)<0) {
211
alert("DeviceDisappeared", dev, NULL,
212
mailaddr, alert_cmd);
213
/* fprintf(stderr, Name ": cannot get array info for %s: %s\n",
214
dev, strerror(errno));
219
if (array.level != 1 && array.level != 5 && array.level != -4) {
221
alert("DeviceDisappeared", dev, "Wrong-Level",
222
mailaddr, alert_cmd);
227
if (st->devnum == MAXINT) {
229
if (fstat(fd, &stb) == 0 &&
230
(S_IFMT&stb.st_mode)==S_IFBLK) {
231
if (MINOR(stb.st_rdev) == 9)
232
st->devnum = MINOR(stb.st_rdev);
234
st->devnum = -1- (MINOR(stb.st_rdev)>>6);
238
for (mse = mdstat ; mse ; mse=mse->next)
239
if (mse->devnum == st->devnum)
240
mse->devnum = MAXINT; /* flag it as "used" */
242
if (st->utime == array.utime &&
243
st->failed == array.failed_disks &&
244
st->working == array.working_disks &&
245
st->spare == array.spare_disks &&
247
mse->percent == st->percent
253
if (st->utime == 0 && /* new array */
254
mse && /* is in /proc/mdstat */
255
mse->pattern && strchr(mse->pattern, '_') /* degraded */
257
alert("DegradedArray", dev, NULL, mailaddr, alert_cmd);
259
if (st->utime == 0 && /* new array */
260
st->expected_spares > 0 &&
261
array.spare_disks < st->expected_spares)
262
alert("SparesMissing", dev, NULL, mailaddr, alert_cmd);
266
alert("RebuildStarted", dev, NULL, mailaddr, alert_cmd);
270
(mse->percent / 20) > (st->percent / 20))
271
alert(percentalerts[mse->percent/20],
272
dev, NULL, mailaddr, alert_cmd);
275
mse->percent == -1 &&
277
alert("RebuildFinished", dev, NULL, mailaddr, alert_cmd);
280
st->percent = mse->percent;
282
for (i=0; i<MD_SB_DISKS; i++) {
283
mdu_disk_info_t disc;
288
if (ioctl(fd, GET_DISK_INFO, &disc)>= 0) {
289
newstate = disc.state;
290
dv = map_dev(disc.major, disc.minor);
291
} else if (mse && mse->pattern && i < strlen(mse->pattern))
292
switch(mse->pattern[i]) {
293
case 'U': newstate = 6 /* ACTIVE/SYNC */; break;
294
case '_': newstate = 0; break;
296
change = newstate ^ st->devstate[i];
297
if (st->utime && change && !st->err) {
298
if (i < (unsigned)array.raid_disks &&
299
(((newstate&change)&(1<<MD_DISK_FAULTY)) ||
300
((st->devstate[i]&change)&(1<<MD_DISK_ACTIVE)) ||
301
((st->devstate[i]&change)&(1<<MD_DISK_SYNC)))
303
alert("Fail", dev, dv, mailaddr, alert_cmd);
304
else if (i >= (unsigned)array.raid_disks &&
305
(disc.major || disc.minor) &&
306
st->devid[i] == MKDEV(disc.major, disc.minor) &&
307
((newstate&change)&(1<<MD_DISK_FAULTY))
309
alert("FailSpare", dev, dv, mailaddr, alert_cmd);
310
else if (i < (unsigned)array.raid_disks &&
311
(((st->devstate[i]&change)&(1<<MD_DISK_FAULTY)) ||
312
((newstate&change)&(1<<MD_DISK_ACTIVE)) ||
313
((newstate&change)&(1<<MD_DISK_SYNC)))
315
alert("SpareActive", dev, dv, mailaddr, alert_cmd);
317
st->devstate[i] = disc.state;
318
st->devid[i] = MKDEV(disc.major, disc.minor);
321
st->active = array.active_disks;
322
st->working = array.working_disks;
323
st->spare = array.spare_disks;
324
st->failed = array.failed_disks;
325
st->utime = array.utime;
326
st->raid = array.raid_disks;
329
/* now check if there are any new devices found in mdstat */
331
struct mdstat_ent *mse;
332
for (mse=mdstat; mse; mse=mse->next)
333
if (mse->devnum != MAXINT &&
334
(strcmp(mse->level, "raid1")==0 ||
335
strcmp(mse->level, "raid5")==0 ||
336
strcmp(mse->level, "multipath")==0)
338
struct state *st = malloc(sizeof *st);
339
mdu_array_info_t array;
343
st->devname = strdup(get_md_name(mse->devnum));
344
if ((fd = open(st->devname, O_RDONLY)) < 0 ||
345
ioctl(fd, GET_ARRAY_INFO, &array)< 0) {
347
if (fd >=0) close(fd);
353
st->next = statelist;
355
st->devnum = mse->devnum;
357
st->spare_group = NULL;
358
st->expected_spares = -1;
360
alert("NewArray", st->devname, NULL, mailaddr, alert_cmd);
364
/* If an array has active < raid && spare == 0 && spare_group != NULL
365
* Look for another array with spare > 0 and active == raid and same spare_group
366
* if found, choose a device and hotremove/hotadd
368
for (st = statelist; st; st=st->next)
369
if (st->active < st->raid &&
371
st->spare_group != NULL) {
373
for (st2=statelist ; st2 ; st2=st2->next)
376
st2->active == st2->raid &&
377
st2->spare_group != NULL &&
378
strcmp(st->spare_group, st2->spare_group) == 0) {
379
/* try to remove and add */
380
int fd1 = open(st->devname, O_RDONLY);
381
int fd2 = open(st2->devname, O_RDONLY);
384
if (fd1 < 0 || fd2 < 0) {
385
if (fd1>=0) close(fd1);
386
if (fd2>=0) close(fd2);
389
for (d=st2->raid; d<MD_SB_DISKS; d++) {
390
if (st2->devid[d] > 0 &&
391
st2->devstate[d] == 0) {
397
if (ioctl(fd2, HOT_REMOVE_DISK,
398
(unsigned long)dev) == 0) {
399
if (ioctl(fd1, HOT_ADD_DISK,
400
(unsigned long)dev) == 0) {
401
alert("MoveSpare", st->devname, st2->devname, mailaddr, alert_cmd);
406
else ioctl(fd2, HOT_ADD_DISK, (unsigned long) dev);
425
static void alert(char *event, char *dev, char *disc, char *mailaddr, char *cmd)
427
if (!cmd && !mailaddr) {
428
time_t now = time(0);
430
printf("%1.15s: %s on %s %s\n", ctime(&now)+4, event, dev, disc?disc:"unknown device");
436
waitpid(pid, NULL, 0);
441
execl(cmd, cmd, event, dev, disc, NULL);
446
(strncmp(event, "Fail", 4)==0 ||
447
strncmp(event, "Test", 4)==0 ||
448
strncmp(event, "Degrade", 7)==0)) {
449
FILE *mp = popen(Sendmail, "w");
452
gethostname(hname, sizeof(hname));
453
signal(SIGPIPE, SIG_IGN);
454
fprintf(mp, "From: " Name " monitoring <root>\n");
455
fprintf(mp, "To: %s\n", mailaddr);
456
fprintf(mp, "Subject: %s event on %s:%s\n\n", event, dev, hname);
458
fprintf(mp, "This is an automatically generated mail message from " Name "\n");
459
fprintf(mp, "running on %s\n\n", hname);
461
fprintf(mp, "A %s event had been detected on md device %s.\n\n", event, dev);
464
fprintf(mp, "It could be related to component device %s.\n\n", disc);
466
fprintf(mp, "Faithfully yours, etc.\n");
471
/* FIXME log the event to syslog maybe */