]> git.ipfire.org Git - thirdparty/mdadm.git/blob - Monitor.c
projects / thirdparty / mdadm.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Modify mdstat parsing for volumes with the bitmap
[thirdparty/mdadm.git] / Monitor.c
1 /*
2 * mdadm - manage Linux "md" devices aka RAID arrays.
3 *
4 * Copyright (C) 2001-2009 Neil Brown <neilb@suse.de>
5 *
6 *
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.
11 *
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.
16 *
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
20 *
21 * Author: Neil Brown
22 * Email: <neilb@suse.de>
23 */
24
25 #include "mdadm.h"
26 #include "md_p.h"
27 #include "md_u.h"
28 #include <sys/wait.h>
29 #include <signal.h>
30 #include <limits.h>
31 #include <syslog.h>
32 #include <libudev.h>
33
34 struct state {
35 char *devname;
36 char devnm[32]; /* to sync with mdstat info */
37 unsigned int utime;
38 int err;
39 char *spare_group;
40 int active, working, failed, spare, raid;
41 int from_config;
42 int from_auto;
43 int expected_spares;
44 int devstate[MAX_DISKS];
45 dev_t devid[MAX_DISKS];
46 int percent;
47 char parent_devnm[32]; /* For subarray, devnm of parent.
48 * For others, ""
49 */
50 struct supertype *metadata;
51 struct state *subarray;/* for a container it is a link to first subarray
52 * for a subarray it is a link to next subarray
53 * in the same container */
54 struct state *parent; /* for a subarray it is a link to its container
55 */
56 struct state *next;
57 };
58
59 struct alert_info {
60 char *mailaddr;
61 char *mailfrom;
62 char *alert_cmd;
63 int dosyslog;
64 };
65 static int make_daemon(char *pidfile);
66 static int check_one_sharer(int scan);
67 static void write_autorebuild_pid(void);
68 static void alert(char *event, char *dev, char *disc, struct alert_info *info);
69 static int check_array(struct state *st, struct mdstat_ent *mdstat,
70 int test, struct alert_info *info,
71 int increments, char *prefer);
72 static int add_new_arrays(struct mdstat_ent *mdstat, struct state **statelist,
73 int test, struct alert_info *info);
74 static void try_spare_migration(struct state *statelist, struct alert_info *info);
75 static void link_containers_with_subarrays(struct state *list);
76 static int check_udev_activity(void);
77
78 int Monitor(struct mddev_dev *devlist,
79 char *mailaddr, char *alert_cmd,
80 struct context *c,
81 int daemonise, int oneshot,
82 int dosyslog, char *pidfile, int increments,
83 int share)
84 {
85 /*
86 * Every few seconds, scan every md device looking for changes
87 * When a change is found, log it, possibly run the alert command,
88 * and possibly send Email
89 *
90 * For each array, we record:
91 * Update time
92 * active/working/failed/spare drives
93 * State of each device.
94 * %rebuilt if rebuilding
95 *
96 * If the update time changes, check out all the data again
97 * It is possible that we cannot get the state of each device
98 * due to bugs in the md kernel module.
99 * We also read /proc/mdstat to get rebuild percent,
100 * and to get state on all active devices incase of kernel bug.
101 *
102 * Events are:
103 * Fail
104 * An active device had Faulty set or Active/Sync removed
105 * FailSpare
106 * A spare device had Faulty set
107 * SpareActive
108 * An active device had a reverse transition
109 * RebuildStarted
110 * percent went from -1 to +ve
111 * RebuildNN
112 * percent went from below to not-below NN%
113 * DeviceDisappeared
114 * Couldn't access a device which was previously visible
115 *
116 * if we detect an array with active<raid and spare==0
117 * we look at other arrays that have same spare-group
118 * If we find one with active==raid and spare>0,
119 * and if we can get_disk_info and find a name
120 * Then we hot-remove and hot-add to the other array
121 *
122 * If devlist is NULL, then we can monitor everything because --scan
123 * was given. We get an initial list from config file and add anything
124 * that appears in /proc/mdstat
125 */
126
127 struct state *statelist = NULL;
128 struct state *st2;
129 int finished = 0;
130 struct mdstat_ent *mdstat = NULL;
131 char *mailfrom;
132 struct alert_info info;
133 struct mddev_ident *mdlist;
134
135 if (!mailaddr) {
136 mailaddr = conf_get_mailaddr();
137 if (mailaddr && ! c->scan)
138 pr_err("Monitor using email address \"%s\" from config file\n",
139 mailaddr);
140 }
141 mailfrom = conf_get_mailfrom();
142
143 if (!alert_cmd) {
144 alert_cmd = conf_get_program();
145 if (alert_cmd && !c->scan)
146 pr_err("Monitor using program \"%s\" from config file\n",
147 alert_cmd);
148 }
149 if (c->scan && !mailaddr && !alert_cmd && !dosyslog) {
150 pr_err("No mail address or alert command - not monitoring.\n");
151 return 1;
152 }
153 info.alert_cmd = alert_cmd;
154 info.mailaddr = mailaddr;
155 info.mailfrom = mailfrom;
156 info.dosyslog = dosyslog;
157
158 if (share){
159 if (check_one_sharer(c->scan))
160 return 1;
161 }
162
163 if (daemonise) {
164 int rv = make_daemon(pidfile);
165 if (rv >= 0)
166 return rv;
167 }
168
169 if (share)
170 write_autorebuild_pid();
171
172 if (devlist == NULL) {
173 mdlist = conf_get_ident(NULL);
174 for (; mdlist; mdlist = mdlist->next) {
175 struct state *st;
176
177 if (mdlist->devname == NULL)
178 continue;
179 if (strcasecmp(mdlist->devname, "<ignore>") == 0)
180 continue;
181 st = xcalloc(1, sizeof *st);
182 if (mdlist->devname[0] == '/')
183 st->devname = xstrdup(mdlist->devname);
184 else {
185 st->devname = xmalloc(8+strlen(mdlist->devname)+1);
186 strcpy(strcpy(st->devname, "/dev/md/"),
187 mdlist->devname);
188 }
189 st->next = statelist;
190 st->devnm[0] = 0;
191 st->percent = RESYNC_UNKNOWN;
192 st->from_config = 1;
193 st->expected_spares = mdlist->spare_disks;
194 if (mdlist->spare_group)
195 st->spare_group = xstrdup(mdlist->spare_group);
196 statelist = st;
197 }
198 } else {
199 struct mddev_dev *dv;
200
201 for (dv = devlist; dv; dv = dv->next) {
202 struct state *st = xcalloc(1, sizeof *st);
203 mdlist = conf_get_ident(dv->devname);
204 st->devname = xstrdup(dv->devname);
205 st->next = statelist;
206 st->devnm[0] = 0;
207 st->percent = RESYNC_UNKNOWN;
208 st->expected_spares = -1;
209 if (mdlist) {
210 st->expected_spares = mdlist->spare_disks;
211 if (mdlist->spare_group)
212 st->spare_group = xstrdup(mdlist->spare_group);
213 }
214 statelist = st;
215 }
216 }
217
218 while (!finished) {
219 int new_found = 0;
220 struct state *st, **stp;
221 int anydegraded = 0;
222 int anyredundant = 0;
223
224 if (mdstat)
225 free_mdstat(mdstat);
226 mdstat = mdstat_read(oneshot ? 0 : 1, 0);
227
228 for (st = statelist; st; st = st->next) {
229 if (check_array(st, mdstat, c->test, &info,
230 increments, c->prefer))
231 anydegraded = 1;
232 /* for external arrays, metadata is filled for
233 * containers only
234 */
235 if (st->metadata && st->metadata->ss->external)
236 continue;
237 if (st->err == 0 && !anyredundant)
238 anyredundant = 1;
239 }
240
241 /* now check if there are any new devices found in mdstat */
242 if (c->scan)
243 new_found = add_new_arrays(mdstat, &statelist, c->test,
244 &info);
245
246 /* If an array has active < raid && spare == 0 && spare_group != NULL
247 * Look for another array with spare > 0 and active == raid and same spare_group
248 * if found, choose a device and hotremove/hotadd
249 */
250 if (share && anydegraded)
251 try_spare_migration(statelist, &info);
252 if (!new_found) {
253 if (oneshot)
254 break;
255 else if (!anyredundant) {
256 break;
257 }
258 else {
259 /*
260 * If mdmonitor is awaken by event, check for udev activity
261 * to wait for udev to finish new devices processing.
262 */
263 if (mdstat_wait(c->delay) && check_udev_activity())
264 pr_err("Error while waiting for UDEV to complete new devices processing\n");
265
266 mdstat_close();
267 }
268 }
269 c->test = 0;
270
271 for (stp = &statelist; (st = *stp) != NULL; ) {
272 if (st->from_auto && st->err > 5) {
273 *stp = st->next;
274 free(st->devname);
275 free(st->spare_group);
276 free(st);
277 } else
278 stp = &st->next;
279 }
280 }
281 for (st2 = statelist; st2; st2 = statelist) {
282 statelist = st2->next;
283 free(st2);
284 }
285
286 if (pidfile)
287 unlink(pidfile);
288 return 0;
289 }
290
291 static int make_daemon(char *pidfile)
292 {
293 /* Return:
294 * -1 in the forked daemon
295 * 0 in the parent
296 * 1 on error
297 * so a none-negative becomes the exit code.
298 */
299 int pid = fork();
300 if (pid > 0) {
301 if (!pidfile)
302 printf("%d\n", pid);
303 else {
304 FILE *pid_file = NULL;
305 int fd = open(pidfile, O_WRONLY | O_CREAT | O_TRUNC,
306 0644);
307 if (fd >= 0)
308 pid_file = fdopen(fd, "w");
309 if (!pid_file)
310 perror("cannot create pid file");
311 else {
312 fprintf(pid_file,"%d\n", pid);
313 fclose(pid_file);
314 }
315 }
316 return 0;
317 }
318 if (pid < 0) {
319 perror("daemonise");
320 return 1;
321 }
322 manage_fork_fds(0);
323 setsid();
324 return -1;
325 }
326
327 static int check_one_sharer(int scan)
328 {
329 int pid;
330 FILE *comm_fp;
331 FILE *fp;
332 char comm_path[PATH_MAX];
333 char path[PATH_MAX];
334 char comm[20];
335
336 sprintf(path, "%s/autorebuild.pid", MDMON_DIR);
337 fp = fopen(path, "r");
338 if (fp) {
339 if (fscanf(fp, "%d", &pid) != 1)
340 pid = -1;
341 snprintf(comm_path, sizeof(comm_path),
342 "/proc/%d/comm", pid);
343 comm_fp = fopen(comm_path, "r");
344 if (comm_fp) {
345 if (fscanf(comm_fp, "%s", comm) &&
346 strncmp(basename(comm), Name, strlen(Name)) == 0) {
347 if (scan) {
348 pr_err("Only one autorebuild process allowed in scan mode, aborting\n");
349 fclose(comm_fp);
350 fclose(fp);
351 return 1;
352 } else {
353 pr_err("Warning: One autorebuild process already running.\n");
354 }
355 }
356 fclose(comm_fp);
357 }
358 fclose(fp);
359 }
360 return 0;
361 }
362
363 static void write_autorebuild_pid()
364 {
365 char path[PATH_MAX];
366 int pid;
367 FILE *fp = NULL;
368 sprintf(path, "%s/autorebuild.pid", MDMON_DIR);
369
370 if (mkdir(MDMON_DIR, 0700) < 0 && errno != EEXIST) {
371 pr_err("Can't create autorebuild.pid file\n");
372 } else {
373 int fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0700);
374
375 if (fd >= 0)
376 fp = fdopen(fd, "w");
377
378 if (!fp)
379 pr_err("Can't create autorebuild.pid file\n");
380 else {
381 pid = getpid();
382 fprintf(fp, "%d\n", pid);
383 fclose(fp);
384 }
385 }
386 }
387
388 static void alert(char *event, char *dev, char *disc, struct alert_info *info)
389 {
390 int priority;
391
392 if (!info->alert_cmd && !info->mailaddr && !info->dosyslog) {
393 time_t now = time(0);
394
395 printf("%1.15s: %s on %s %s\n", ctime(&now) + 4,
396 event, dev, disc?disc:"unknown device");
397 }
398 if (info->alert_cmd) {
399 int pid = fork();
400 switch(pid) {
401 default:
402 waitpid(pid, NULL, 0);
403 break;
404 case -1:
405 break;
406 case 0:
407 execl(info->alert_cmd, info->alert_cmd,
408 event, dev, disc, NULL);
409 exit(2);
410 }
411 }
412 if (info->mailaddr && (strncmp(event, "Fail", 4) == 0 ||
413 strncmp(event, "Test", 4) == 0 ||
414 strncmp(event, "Spares", 6) == 0 ||
415 strncmp(event, "Degrade", 7) == 0)) {
416 FILE *mp = popen(Sendmail, "w");
417 if (mp) {
418 FILE *mdstat;
419 char hname[256];
420 gethostname(hname, sizeof(hname));
421 signal(SIGPIPE, SIG_IGN);
422 if (info->mailfrom)
423 fprintf(mp, "From: %s\n", info->mailfrom);
424 else
425 fprintf(mp, "From: %s monitoring <root>\n",
426 Name);
427 fprintf(mp, "To: %s\n", info->mailaddr);
428 fprintf(mp, "Subject: %s event on %s:%s\n\n",
429 event, dev, hname);
430
431 fprintf(mp,
432 "This is an automatically generated mail message from %s\n", Name);
433 fprintf(mp, "running on %s\n\n", hname);
434
435 fprintf(mp,
436 "A %s event had been detected on md device %s.\n\n", event, dev);
437
438 if (disc && disc[0] != ' ')
439 fprintf(mp,
440 "It could be related to component device %s.\n\n", disc);
441 if (disc && disc[0] == ' ')
442 fprintf(mp, "Extra information:%s.\n\n", disc);
443
444 fprintf(mp, "Faithfully yours, etc.\n");
445
446 mdstat = fopen("/proc/mdstat", "r");
447 if (mdstat) {
448 char buf[8192];
449 int n;
450 fprintf(mp,
451 "\nP.S. The /proc/mdstat file currently contains the following:\n\n");
452 while ((n = fread(buf, 1, sizeof(buf),
453 mdstat)) > 0)
454 n = fwrite(buf, 1, n, mp);
455 fclose(mdstat);
456 }
457 pclose(mp);
458 }
459 }
460
461 /* log the event to syslog maybe */
462 if (info->dosyslog) {
463 /* Log at a different severity depending on the event.
464 *
465 * These are the critical events: */
466 if (strncmp(event, "Fail", 4) == 0 ||
467 strncmp(event, "Degrade", 7) == 0 ||
468 strncmp(event, "DeviceDisappeared", 17) == 0)
469 priority = LOG_CRIT;
470 /* Good to know about, but are not failures: */
471 else if (strncmp(event, "Rebuild", 7) == 0 ||
472 strncmp(event, "MoveSpare", 9) == 0 ||
473 strncmp(event, "Spares", 6) != 0)
474 priority = LOG_WARNING;
475 /* Everything else: */
476 else
477 priority = LOG_INFO;
478
479 if (disc && disc[0] != ' ')
480 syslog(priority,
481 "%s event detected on md device %s, component device %s", event, dev, disc);
482 else if (disc)
483 syslog(priority,
484 "%s event detected on md device %s: %s",
485 event, dev, disc);
486 else
487 syslog(priority,
488 "%s event detected on md device %s",
489 event, dev);
490 }
491 }
492
493 static int check_array(struct state *st, struct mdstat_ent *mdstat,
494 int test, struct alert_info *ainfo,
495 int increments, char *prefer)
496 {
497 /* Update the state 'st' to reflect any changes shown in mdstat,
498 * or found by directly examining the array, and return
499 * '1' if the array is degraded, or '0' if it is optimal (or dead).
500 */
501 struct { int state, major, minor; } info[MAX_DISKS];
502 struct mdinfo *sra = NULL;
503 mdu_array_info_t array;
504 struct mdstat_ent *mse = NULL, *mse2;
505 char *dev = st->devname;
506 int fd;
507 int i;
508 int remaining_disks;
509 int last_disk;
510 int new_array = 0;
511 int retval;
512 int is_container = 0;
513 unsigned long redundancy_only_flags = 0;
514
515 if (test)
516 alert("TestMessage", dev, NULL, ainfo);
517
518 retval = 0;
519
520 fd = open(dev, O_RDONLY);
521 if (fd < 0)
522 goto disappeared;
523
524 if (st->devnm[0] == 0)
525 strcpy(st->devnm, fd2devnm(fd));
526
527 for (mse2 = mdstat; mse2; mse2 = mse2->next)
528 if (strcmp(mse2->devnm, st->devnm) == 0) {
529 mse2->devnm[0] = 0; /* flag it as "used" */
530 mse = mse2;
531 }
532
533 if (!mse) {
534 /* duplicated array in statelist
535 * or re-created after reading mdstat
536 */
537 st->err++;
538 goto out;
539 }
540
541 if (mse->level == NULL)
542 is_container = 1;
543
544 if (!is_container && !md_array_active(fd))
545 goto disappeared;
546
547 fcntl(fd, F_SETFD, FD_CLOEXEC);
548 if (md_get_array_info(fd, &array) < 0)
549 goto disappeared;
550
551 if (!is_container && map_name(pers, mse->level) > 0)
552 redundancy_only_flags |= GET_MISMATCH;
553
554 sra = sysfs_read(-1, st->devnm, GET_LEVEL | GET_DISKS | GET_DEVS |
555 GET_STATE | redundancy_only_flags);
556
557 if (!sra)
558 goto disappeared;
559
560 /* It's much easier to list what array levels can't
561 * have a device disappear than all of them that can
562 */
563 if (sra->array.level == 0 || sra->array.level == -1) {
564 if (!st->err && !st->from_config)
565 alert("DeviceDisappeared", dev, " Wrong-Level", ainfo);
566 st->err++;
567 goto out;
568 }
569
570 /* this array is in /proc/mdstat */
571 if (array.utime == 0)
572 /* external arrays don't update utime, so
573 * just make sure it is always different. */
574 array.utime = st->utime + 1;;
575
576 if (st->err) {
577 /* New array appeared where previously had an error */
578 st->err = 0;
579 st->percent = RESYNC_NONE;
580 new_array = 1;
581 if (!is_container)
582 alert("NewArray", st->devname, NULL, ainfo);
583 }
584
585 if (st->utime == array.utime && st->failed == sra->array.failed_disks &&
586 st->working == sra->array.working_disks &&
587 st->spare == sra->array.spare_disks &&
588 (mse == NULL || (mse->percent == st->percent))) {
589 if ((st->active < st->raid) && st->spare == 0)
590 retval = 1;
591 goto out;
592 }
593 if (st->utime == 0 && /* new array */
594 mse->pattern && strchr(mse->pattern, '_') /* degraded */)
595 alert("DegradedArray", dev, NULL, ainfo);
596
597 if (st->utime == 0 && /* new array */ st->expected_spares > 0 &&
598 sra->array.spare_disks < st->expected_spares)
599 alert("SparesMissing", dev, NULL, ainfo);
600 if (st->percent < 0 && st->percent != RESYNC_UNKNOWN &&
601 mse->percent >= 0)
602 alert("RebuildStarted", dev, NULL, ainfo);
603 if (st->percent >= 0 && mse->percent >= 0 &&
604 (mse->percent / increments) > (st->percent / increments)) {
605 char percentalert[18];
606 /*
607 * "RebuildNN" (10 chars) or "RebuildStarted" (15 chars)
608 */
609
610 if((mse->percent / increments) == 0)
611 snprintf(percentalert, sizeof(percentalert),
612 "RebuildStarted");
613 else
614 snprintf(percentalert, sizeof(percentalert),
615 "Rebuild%02d", mse->percent);
616
617 alert(percentalert, dev, NULL, ainfo);
618 }
619
620 if (mse->percent == RESYNC_NONE && st->percent >= 0) {
621 /* Rebuild/sync/whatever just finished.
622 * If there is a number in /mismatch_cnt,
623 * we should report that.
624 */
625 if (sra && sra->mismatch_cnt > 0) {
626 char cnt[80];
627 snprintf(cnt, sizeof(cnt),
628 " mismatches found: %d (on raid level %d)",
629 sra->mismatch_cnt, sra->array.level);
630 alert("RebuildFinished", dev, cnt, ainfo);
631 } else
632 alert("RebuildFinished", dev, NULL, ainfo);
633 }
634 st->percent = mse->percent;
635
636 remaining_disks = sra->array.nr_disks;
637 for (i = 0; i < MAX_DISKS && remaining_disks > 0; i++) {
638 mdu_disk_info_t disc;
639 disc.number = i;
640 if (md_get_disk_info(fd, &disc) >= 0) {
641 info[i].state = disc.state;
642 info[i].major = disc.major;
643 info[i].minor = disc.minor;
644 if (disc.major || disc.minor)
645 remaining_disks --;
646 } else
647 info[i].major = info[i].minor = 0;
648 }
649 last_disk = i;
650
651 if (mse->metadata_version &&
652 strncmp(mse->metadata_version, "external:", 9) == 0 &&
653 is_subarray(mse->metadata_version+9)) {
654 char *sl;
655 strcpy(st->parent_devnm, mse->metadata_version + 10);
656 sl = strchr(st->parent_devnm, '/');
657 if (sl)
658 *sl = 0;
659 } else
660 st->parent_devnm[0] = 0;
661 if (st->metadata == NULL && st->parent_devnm[0] == 0)
662 st->metadata = super_by_fd(fd, NULL);
663
664 for (i = 0; i < MAX_DISKS; i++) {
665 mdu_disk_info_t disc = {0, 0, 0, 0, 0};
666 int newstate = 0;
667 int change;
668 char *dv = NULL;
669 disc.number = i;
670 if (i < last_disk && (info[i].major || info[i].minor)) {
671 newstate = info[i].state;
672 dv = map_dev_preferred(info[i].major, info[i].minor, 1,
673 prefer);
674 disc.state = newstate;
675 disc.major = info[i].major;
676 disc.minor = info[i].minor;
677 } else
678 newstate = (1 << MD_DISK_REMOVED);
679
680 if (dv == NULL && st->devid[i])
681 dv = map_dev_preferred(major(st->devid[i]),
682 minor(st->devid[i]), 1, prefer);
683 change = newstate ^ st->devstate[i];
684 if (st->utime && change && !st->err && !new_array) {
685 if ((st->devstate[i]&change) & (1 << MD_DISK_SYNC))
686 alert("Fail", dev, dv, ainfo);
687 else if ((newstate & (1 << MD_DISK_FAULTY)) &&
688 (disc.major || disc.minor) &&
689 st->devid[i] == makedev(disc.major,
690 disc.minor))
691 alert("FailSpare", dev, dv, ainfo);
692 else if ((newstate&change) & (1 << MD_DISK_SYNC))
693 alert("SpareActive", dev, dv, ainfo);
694 }
695 st->devstate[i] = newstate;
696 st->devid[i] = makedev(disc.major, disc.minor);
697 }
698 st->active = sra->array.active_disks;
699 st->working = sra->array.working_disks;
700 st->spare = sra->array.spare_disks;
701 st->failed = sra->array.failed_disks;
702 st->utime = array.utime;
703 st->raid = sra->array.raid_disks;
704 st->err = 0;
705 if ((st->active < st->raid) && st->spare == 0)
706 retval = 1;
707
708 out:
709 if (sra)
710 sysfs_free(sra);
711 if (fd >= 0)
712 close(fd);
713 return retval;
714
715 disappeared:
716 if (!st->err && !is_container)
717 alert("DeviceDisappeared", dev, NULL, ainfo);
718 st->err++;
719 goto out;
720 }
721
722 static int add_new_arrays(struct mdstat_ent *mdstat, struct state **statelist,
723 int test, struct alert_info *info)
724 {
725 struct mdstat_ent *mse;
726 int new_found = 0;
727 char *name;
728
729 for (mse = mdstat; mse; mse = mse->next)
730 if (mse->devnm[0] && (!mse->level || /* retrieve containers */
731 (strcmp(mse->level, "raid0") != 0 &&
732 strcmp(mse->level, "linear") != 0))) {
733 struct state *st = xcalloc(1, sizeof *st);
734 mdu_array_info_t array;
735 int fd;
736
737 name = get_md_name(mse->devnm);
738 if (!name) {
739 free(st);
740 continue;
741 }
742
743 st->devname = xstrdup(name);
744 if ((fd = open(st->devname, O_RDONLY)) < 0 ||
745 md_get_array_info(fd, &array) < 0) {
746 /* no such array */
747 if (fd >= 0)
748 close(fd);
749 put_md_name(st->devname);
750 free(st->devname);
751 if (st->metadata) {
752 st->metadata->ss->free_super(st->metadata);
753 free(st->metadata);
754 }
755 free(st);
756 continue;
757 }
758 close(fd);
759 st->next = *statelist;
760 st->err = 1;
761 st->from_auto = 1;
762 strcpy(st->devnm, mse->devnm);
763 st->percent = RESYNC_UNKNOWN;
764 st->expected_spares = -1;
765 if (mse->metadata_version &&
766 strncmp(mse->metadata_version,
767 "external:", 9) == 0 &&
768 is_subarray(mse->metadata_version+9)) {
769 char *sl;
770 strcpy(st->parent_devnm,
771 mse->metadata_version+10);
772 sl = strchr(st->parent_devnm, '/');
773 *sl = 0;
774 } else
775 st->parent_devnm[0] = 0;
776 *statelist = st;
777 if (test)
778 alert("TestMessage", st->devname, NULL, info);
779 new_found = 1;
780 }
781 return new_found;
782 }
783
784 static int get_required_spare_criteria(struct state *st,
785 struct spare_criteria *sc)
786 {
787 int fd;
788
789 if (!st->metadata || !st->metadata->ss->get_spare_criteria) {
790 sc->min_size = 0;
791 sc->sector_size = 0;
792 return 0;
793 }
794
795 fd = open(st->devname, O_RDONLY);
796 if (fd < 0)
797 return 1;
798 if (st->metadata->ss->external)
799 st->metadata->ss->load_container(st->metadata, fd, st->devname);
800 else
801 st->metadata->ss->load_super(st->metadata, fd, st->devname);
802 close(fd);
803 if (!st->metadata->sb)
804 return 1;
805
806 st->metadata->ss->get_spare_criteria(st->metadata, sc);
807 st->metadata->ss->free_super(st->metadata);
808
809 return 0;
810 }
811
812 static int check_donor(struct state *from, struct state *to)
813 {
814 struct state *sub;
815
816 if (from == to)
817 return 0;
818 if (from->parent)
819 /* Cannot move from a member */
820 return 0;
821 if (from->err)
822 return 0;
823 for (sub = from->subarray; sub; sub = sub->subarray)
824 /* If source array has degraded subarrays, don't
825 * remove anything
826 */
827 if (sub->active < sub->raid)
828 return 0;
829 if (from->metadata->ss->external == 0)
830 if (from->active < from->raid)
831 return 0;
832 if (from->spare <= 0)
833 return 0;
834 return 1;
835 }
836
837 static dev_t choose_spare(struct state *from, struct state *to,
838 struct domainlist *domlist, struct spare_criteria *sc)
839 {
840 int d;
841 dev_t dev = 0;
842
843 for (d = from->raid; !dev && d < MAX_DISKS; d++) {
844 if (from->devid[d] > 0 && from->devstate[d] == 0) {
845 struct dev_policy *pol;
846 unsigned long long dev_size;
847 unsigned int dev_sector_size;
848
849 if (to->metadata->ss->external &&
850 test_partition_from_id(from->devid[d]))
851 continue;
852
853 if (sc->min_size &&
854 dev_size_from_id(from->devid[d], &dev_size) &&
855 dev_size < sc->min_size)
856 continue;
857
858 if (sc->sector_size &&
859 dev_sector_size_from_id(from->devid[d],
860 &dev_sector_size) &&
861 sc->sector_size != dev_sector_size)
862 continue;
863
864 pol = devid_policy(from->devid[d]);
865 if (from->spare_group)
866 pol_add(&pol, pol_domain,
867 from->spare_group, NULL);
868 if (domain_test(domlist, pol,
869 to->metadata->ss->name) == 1)
870 dev = from->devid[d];
871 dev_policy_free(pol);
872 }
873 }
874 return dev;
875 }
876
877 static dev_t container_choose_spare(struct state *from, struct state *to,
878 struct domainlist *domlist,
879 struct spare_criteria *sc, int active)
880 {
881 /* This is similar to choose_spare, but we cannot trust devstate,
882 * so we need to read the metadata instead
883 */
884 struct mdinfo *list;
885 struct supertype *st = from->metadata;
886 int fd = open(from->devname, O_RDONLY);
887 int err;
888 dev_t dev = 0;
889
890 if (fd < 0)
891 return 0;
892 if (!st->ss->getinfo_super_disks) {
893 close(fd);
894 return 0;
895 }
896
897 err = st->ss->load_container(st, fd, NULL);
898 close(fd);
899 if (err)
900 return 0;
901
902 if (from == to) {
903 /* We must check if number of active disks has not increased
904 * since ioctl in main loop. mdmon may have added spare
905 * to subarray. If so we do not need to look for more spares
906 * so return non zero value */
907 int active_cnt = 0;
908 struct mdinfo *dp;
909 list = st->ss->getinfo_super_disks(st);
910 if (!list) {
911 st->ss->free_super(st);
912 return 1;
913 }
914 dp = list->devs;
915 while (dp) {
916 if (dp->disk.state & (1 << MD_DISK_SYNC) &&
917 !(dp->disk.state & (1 << MD_DISK_FAULTY)))
918 active_cnt++;
919 dp = dp->next;
920 }
921 sysfs_free(list);
922 if (active < active_cnt) {
923 /* Spare just activated.*/
924 st->ss->free_super(st);
925 return 1;
926 }
927 }
928
929 /* We only need one spare so full list not needed */
930 list = container_choose_spares(st, sc, domlist, from->spare_group,
931 to->metadata->ss->name, 1);
932 if (list) {
933 struct mdinfo *disks = list->devs;
934 if (disks)
935 dev = makedev(disks->disk.major, disks->disk.minor);
936 sysfs_free(list);
937 }
938 st->ss->free_super(st);
939 return dev;
940 }
941
942 static void try_spare_migration(struct state *statelist, struct alert_info *info)
943 {
944 struct state *from;
945 struct state *st;
946 struct spare_criteria sc;
947
948 link_containers_with_subarrays(statelist);
949 for (st = statelist; st; st = st->next)
950 if (st->active < st->raid && st->spare == 0 && !st->err) {
951 struct domainlist *domlist = NULL;
952 int d;
953 struct state *to = st;
954
955 if (to->parent_devnm[0] && !to->parent)
956 /* subarray monitored without parent container
957 * we can't move spares here */
958 continue;
959
960 if (to->parent)
961 /* member of a container */
962 to = to->parent;
963
964 if (get_required_spare_criteria(to, &sc))
965 continue;
966 if (to->metadata->ss->external) {
967 /* We must make sure there is
968 * no suitable spare in container already.
969 * If there is we don't add more */
970 dev_t devid = container_choose_spare(
971 to, to, NULL, &sc, st->active);
972 if (devid > 0)
973 continue;
974 }
975 for (d = 0; d < MAX_DISKS; d++)
976 if (to->devid[d])
977 domainlist_add_dev(&domlist,
978 to->devid[d],
979 to->metadata->ss->name);
980 if (to->spare_group)
981 domain_add(&domlist, to->spare_group);
982 /*
983 * No spare migration if the destination
984 * has no domain. Skip this array.
985 */
986 if (!domlist)
987 continue;
988 for (from=statelist ; from ; from=from->next) {
989 dev_t devid;
990 if (!check_donor(from, to))
991 continue;
992 if (from->metadata->ss->external)
993 devid = container_choose_spare(
994 from, to, domlist, &sc, 0);
995 else
996 devid = choose_spare(from, to, domlist,
997 &sc);
998 if (devid > 0 &&
999 move_spare(from->devname, to->devname,
1000 devid)) {
1001 alert("MoveSpare", to->devname,
1002 from->devname, info);
1003 break;
1004 }
1005 }
1006 domain_free(domlist);
1007 }
1008 }
1009
1010 /* search the statelist to connect external
1011 * metadata subarrays with their containers
1012 * We always completely rebuild the tree from scratch as
1013 * that is safest considering the possibility of entries
1014 * disappearing or changing.
1015 */
1016 static void link_containers_with_subarrays(struct state *list)
1017 {
1018 struct state *st;
1019 struct state *cont;
1020 for (st = list; st; st = st->next) {
1021 st->parent = NULL;
1022 st->subarray = NULL;
1023 }
1024 for (st = list; st; st = st->next)
1025 if (st->parent_devnm[0])
1026 for (cont = list; cont; cont = cont->next)
1027 if (!cont->err && cont->parent_devnm[0] == 0 &&
1028 strcmp(cont->devnm, st->parent_devnm) == 0) {
1029 st->parent = cont;
1030 st->subarray = cont->subarray;
1031 cont->subarray = st;
1032 break;
1033 }
1034 }
1035
1036
1037 /* function: check_udev_activity
1038 * Description: Function waits for udev to finish
1039 * events processing.
1040 * Returns:
1041 * 1 - detected error while opening udev
1042 * 2 - timeout
1043 * 0 - successfull completion
1044 */
1045 static int check_udev_activity(void)
1046 {
1047 struct udev *udev = NULL;
1048 struct udev_queue *udev_queue = NULL;
1049 int timeout_cnt = 30;
1050 int rc = 0;
1051
1052 /*
1053 * In rare cases systemd may not have udevm,
1054 * in such cases just exit with rc 0
1055 */
1056 if (!use_udev())
1057 goto out;
1058
1059 udev = udev_new();
1060 if (!udev) {
1061 rc = 1;
1062 goto out;
1063 }
1064
1065 udev_queue = udev_queue_new(udev);
1066 if (!udev_queue) {
1067 rc = 1;
1068 goto out;
1069 }
1070
1071 if (udev_queue_get_queue_is_empty(udev_queue))
1072 goto out;
1073
1074 while (!udev_queue_get_queue_is_empty(udev_queue)) {
1075 sleep(1);
1076
1077 if (timeout_cnt)
1078 timeout_cnt--;
1079 else {
1080 rc = 2;
1081 goto out;
1082 }
1083 }
1084
1085 out:
1086 if (udev_queue)
1087 udev_queue_unref(udev_queue);
1088 if (udev)
1089 udev_unref(udev);
1090 return rc;
1091 }
1092
1093 /* Not really Monitor but ... */
1094 int Wait(char *dev)
1095 {
1096 char devnm[32];
1097 dev_t rdev;
1098 char *tmp;
1099 int rv = 1;
1100 int frozen_remaining = 3;
1101
1102 if (!stat_is_blkdev(dev, &rdev))
1103 return 2;
1104
1105 tmp = devid2devnm(rdev);
1106 if (!tmp) {
1107 pr_err("Cannot get md device name.\n");
1108 return 2;
1109 }
1110
1111 strcpy(devnm, tmp);
1112
1113 while(1) {
1114 struct mdstat_ent *ms = mdstat_read(1, 0);
1115 struct mdstat_ent *e;
1116
1117 for (e = ms; e; e = e->next)
1118 if (strcmp(e->devnm, devnm) == 0)
1119 break;
1120
1121 if (e && e->percent == RESYNC_NONE) {
1122 /* We could be in the brief pause before something
1123 * starts. /proc/mdstat doesn't show that, but
1124 * sync_action does.
1125 */
1126 struct mdinfo mdi;
1127 char buf[21];
1128
1129 if (sysfs_init(&mdi, -1, devnm))
1130 return 2;
1131 if (sysfs_get_str(&mdi, NULL, "sync_action",
1132 buf, 20) > 0 &&
1133 strcmp(buf,"idle\n") != 0) {
1134 e->percent = RESYNC_UNKNOWN;
1135 if (strcmp(buf, "frozen\n") == 0) {
1136 if (frozen_remaining == 0)
1137 e->percent = RESYNC_NONE;
1138 else
1139 frozen_remaining -= 1;
1140 }
1141 }
1142 }
1143 if (!e || e->percent == RESYNC_NONE) {
1144 if (e && e->metadata_version &&
1145 strncmp(e->metadata_version, "external:", 9) == 0) {
1146 if (is_subarray(&e->metadata_version[9]))
1147 ping_monitor(&e->metadata_version[9]);
1148 else
1149 ping_monitor(devnm);
1150 }
1151 free_mdstat(ms);
1152 return rv;
1153 }
1154 free_mdstat(ms);
1155 rv = 0;
1156 mdstat_wait(5);
1157 }
1158 }
1159
1160 /* The state "broken" is used only for RAID0/LINEAR - it's the same as
1161 * "clean", but used in case the array has one or more members missing.
1162 */
1163 static char *clean_states[] = {
1164 "clear", "inactive", "readonly", "read-auto", "clean", "broken", NULL };
1165
1166 int WaitClean(char *dev, int verbose)
1167 {
1168 int fd;
1169 struct mdinfo *mdi;
1170 int rv = 1;
1171 char devnm[32];
1172
1173 if (!stat_is_blkdev(dev, NULL))
1174 return 2;
1175 fd = open(dev, O_RDONLY);
1176 if (fd < 0) {
1177 if (verbose)
1178 pr_err("Couldn't open %s: %s\n", dev, strerror(errno));
1179 return 1;
1180 }
1181
1182 strcpy(devnm, fd2devnm(fd));
1183 mdi = sysfs_read(fd, devnm, GET_VERSION|GET_LEVEL|GET_SAFEMODE);
1184 if (!mdi) {
1185 if (verbose)
1186 pr_err("Failed to read sysfs attributes for %s\n", dev);
1187 close(fd);
1188 return 0;
1189 }
1190
1191 switch(mdi->array.level) {
1192 case LEVEL_LINEAR:
1193 case LEVEL_MULTIPATH:
1194 case 0:
1195 /* safemode delay is irrelevant for these levels */
1196 rv = 0;
1197 }
1198
1199 /* for internal metadata the kernel handles the final clean
1200 * transition, containers can never be dirty
1201 */
1202 if (!is_subarray(mdi->text_version))
1203 rv = 0;
1204
1205 /* safemode disabled ? */
1206 if (mdi->safe_mode_delay == 0)
1207 rv = 0;
1208
1209 if (rv) {
1210 int state_fd = sysfs_open(fd2devnm(fd), NULL, "array_state");
1211 char buf[20];
1212 int delay = 5000;
1213
1214 /* minimize the safe_mode_delay and prepare to wait up to 5s
1215 * for writes to quiesce
1216 */
1217 sysfs_set_safemode(mdi, 1);
1218
1219 /* wait for array_state to be clean */
1220 while (1) {
1221 rv = read(state_fd, buf, sizeof(buf));
1222 if (rv < 0)
1223 break;
1224 if (sysfs_match_word(buf, clean_states) <
1225 (int)ARRAY_SIZE(clean_states) - 1)
1226 break;
1227 rv = sysfs_wait(state_fd, &delay);
1228 if (rv < 0 && errno != EINTR)
1229 break;
1230 lseek(state_fd, 0, SEEK_SET);
1231 }
1232 if (rv < 0)
1233 rv = 1;
1234 else if (ping_monitor(mdi->text_version) == 0) {
1235 /* we need to ping to close the window between array
1236 * state transitioning to clean and the metadata being
1237 * marked clean
1238 */
1239 rv = 0;
1240 } else {
1241 rv = 1;
1242 pr_err("Error connecting monitor with %s\n", dev);
1243 }
1244 if (rv && verbose)
1245 pr_err("Error waiting for %s to be clean\n", dev);
1246
1247 /* restore the original safe_mode_delay */
1248 sysfs_set_safemode(mdi, mdi->safe_mode_delay);
1249 close(state_fd);
1250 }
1251
1252 sysfs_free(mdi);
1253 close(fd);
1254
1255 return rv;
1256 }
Unnamed repository; edit this file 'description' to name the repository.