mdmon: fix wrong array state when disk fails during mdmon startup
[thirdparty/mdadm.git] / managemon.c
1 /*
2 * mdmon - monitor external metadata arrays
3 *
4 * Copyright (C) 2007-2009 Neil Brown <neilb@suse.de>
5 * Copyright (C) 2007-2009 Intel Corporation
6 *
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms and conditions of the GNU General Public License,
9 * version 2, as published by the Free Software Foundation.
10 *
11 * This program is distributed in the hope it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
14 * more details.
15 *
16 * You should have received a copy of the GNU General Public License along with
17 * this program; if not, write to the Free Software Foundation, Inc.,
18 * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
19 */
20
21 /*
22 * The management thread for monitoring active md arrays.
23 * This thread does things which might block such as memory
24 * allocation.
25 * In particular:
26 *
27 * - Find out about new arrays in this container.
28 * Allocate the data structures and open the files.
29 *
30 * For this we watch /proc/mdstat and find new arrays with
31 * metadata type that confirms sharing. e.g. "md4"
32 * When we find a new array we slip it into the list of
33 * arrays and signal 'monitor' by writing to a pipe.
34 *
35 * - Respond to reshape requests by allocating new data structures
36 * and opening new files.
37 *
38 * These come as a change to raid_disks. We allocate a new
39 * version of the data structures and slip it into the list.
40 * 'monitor' will notice and release the old version.
41 * Changes to level, chunksize, layout.. do not need re-allocation.
42 * Reductions in raid_disks don't really either, but we handle
43 * them the same way for consistency.
44 *
45 * - When a device is added to the container, we add it to the metadata
46 * as a spare.
47 *
48 * - Deal with degraded array
49 * We only do this when first noticing the array is degraded.
50 * This can be when we first see the array, when sync completes or
51 * when recovery completes.
52 *
53 * Check if number of failed devices suggests recovery is needed, and
54 * skip if not.
55 * Ask metadata to allocate a spare device
56 * Add device as not in_sync and give a role
57 * Update metadata.
58 * Open sysfs files and pass to monitor.
59 * Make sure that monitor Starts recovery....
60 *
61 * - Pass on metadata updates from external programs such as
62 * mdadm creating a new array.
63 *
64 * This is most-messy.
65 * It might involve adding a new array or changing the status of
66 * a spare, or any reconfig that the kernel doesn't get involved in.
67 *
68 * The required updates are received via a named pipe. There will
69 * be one named pipe for each container. Each message contains a
70 * sync marker: 0x5a5aa5a5, A byte count, and the message. This is
71 * passed to the metadata handler which will interpret and process it.
72 * For 'DDF' messages are internal data blocks with the leading
73 * 'magic number' signifying what sort of data it is.
74 *
75 */
76
77 /*
78 * We select on /proc/mdstat and the named pipe.
79 * We create new arrays or updated version of arrays and slip
80 * them into the head of the list, then signal 'monitor' via a pipe write.
81 * 'monitor' will notice and place the old array on a return list.
82 * Metadata updates are placed on a queue just like they arrive
83 * from the named pipe.
84 *
85 * When new arrays are found based on correct metadata string, we
86 * need to identify them with an entry in the metadata. Maybe we require
87 * the metadata to be mdX/NN when NN is the index into an appropriate table.
88 *
89 */
90
91 /*
92 * List of tasks:
93 * - Watch for spares to be added to the container, and write updated
94 * metadata to them.
95 * - Watch for new arrays using this container, confirm they match metadata
96 * and if so, start monitoring them
97 * - Watch for spares being added to monitored arrays. This shouldn't
98 * happen, as we should do all the adding. Just remove them.
99 * - Watch for change in raid-disks, chunk-size, etc. Update metadata and
100 * start a reshape.
101 */
102 #ifndef _GNU_SOURCE
103 #define _GNU_SOURCE
104 #endif
105 #include "mdadm.h"
106 #include "mdmon.h"
107 #include <sys/syscall.h>
108 #include <sys/socket.h>
109 #include <signal.h>
110
111 static void close_aa(struct active_array *aa)
112 {
113 struct mdinfo *d;
114
115 for (d = aa->info.devs; d; d = d->next) {
116 close(d->recovery_fd);
117 close(d->state_fd);
118 close(d->bb_fd);
119 close(d->ubb_fd);
120 }
121
122 if (aa->action_fd >= 0)
123 close(aa->action_fd);
124 if (aa->info.state_fd >= 0)
125 close(aa->info.state_fd);
126 if (aa->resync_start_fd >= 0)
127 close(aa->resync_start_fd);
128 if (aa->metadata_fd >= 0)
129 close(aa->metadata_fd);
130 if (aa->sync_completed_fd >= 0)
131 close(aa->sync_completed_fd);
132 if (aa->safe_mode_delay_fd >= 0)
133 close(aa->safe_mode_delay_fd);
134 }
135
136 static void free_aa(struct active_array *aa)
137 {
138 /* Note that this doesn't close fds if they are being used
139 * by a clone. ->container will be set for a clone
140 */
141 dprintf("sys_name: %s\n", aa->info.sys_name);
142 if (!aa->container)
143 close_aa(aa);
144 while (aa->info.devs) {
145 struct mdinfo *d = aa->info.devs;
146 aa->info.devs = d->next;
147 free(d);
148 }
149 free(aa);
150 }
151
152 static struct active_array *duplicate_aa(struct active_array *aa)
153 {
154 struct active_array *newa = xmalloc(sizeof(*newa));
155 struct mdinfo **dp1, **dp2;
156
157 *newa = *aa;
158 newa->next = NULL;
159 newa->replaces = NULL;
160 newa->info.next = NULL;
161
162 dp2 = &newa->info.devs;
163
164 for (dp1 = &aa->info.devs; *dp1; dp1 = &(*dp1)->next) {
165 struct mdinfo *d;
166 if ((*dp1)->state_fd < 0)
167 continue;
168
169 d = xmalloc(sizeof(*d));
170 *d = **dp1;
171 *dp2 = d;
172 dp2 = & d->next;
173 }
174 *dp2 = NULL;
175
176 return newa;
177 }
178
179 static void wakeup_monitor(void)
180 {
181 /* tgkill(getpid(), mon_tid, SIGUSR1); */
182 int pid = getpid();
183 syscall(SYS_tgkill, pid, mon_tid, SIGUSR1);
184 }
185
186 static void remove_old(void)
187 {
188 if (discard_this) {
189 discard_this->next = NULL;
190 free_aa(discard_this);
191 if (pending_discard == discard_this)
192 pending_discard = NULL;
193 discard_this = NULL;
194 wakeup_monitor();
195 }
196 }
197
198 static void replace_array(struct supertype *container,
199 struct active_array *old,
200 struct active_array *new)
201 {
202 /* To replace an array, we add it to the top of the list
203 * marked with ->replaces to point to the original.
204 * 'monitor' will take the original out of the list
205 * and put it on 'discard_this'. We take it from there
206 * and discard it.
207 */
208 remove_old();
209 while (pending_discard) {
210 while (discard_this == NULL)
211 sleep(1);
212 remove_old();
213 }
214 pending_discard = old;
215 new->replaces = old;
216 new->next = container->arrays;
217 container->arrays = new;
218 wakeup_monitor();
219 }
220
221 struct metadata_update *update_queue = NULL;
222 struct metadata_update *update_queue_handled = NULL;
223 struct metadata_update *update_queue_pending = NULL;
224
225 static void free_updates(struct metadata_update **update)
226 {
227 while (*update) {
228 struct metadata_update *this = *update;
229 void **space_list = this->space_list;
230
231 *update = this->next;
232 free(this->buf);
233 free(this->space);
234 while (space_list) {
235 void *space = space_list;
236 space_list = *space_list;
237 free(space);
238 }
239 free(this);
240 }
241 }
242
243 void check_update_queue(struct supertype *container)
244 {
245 free_updates(&update_queue_handled);
246
247 if (update_queue == NULL &&
248 update_queue_pending) {
249 update_queue = update_queue_pending;
250 update_queue_pending = NULL;
251 wakeup_monitor();
252 }
253 }
254
255 static void queue_metadata_update(struct metadata_update *mu)
256 {
257 struct metadata_update **qp;
258
259 qp = &update_queue_pending;
260 while (*qp)
261 qp = & ((*qp)->next);
262 *qp = mu;
263 }
264
265 static void add_disk_to_container(struct supertype *st, struct mdinfo *sd)
266 {
267 int dfd;
268 char nm[20];
269 struct metadata_update *update = NULL;
270 mdu_disk_info_t dk = {
271 .number = -1,
272 .major = sd->disk.major,
273 .minor = sd->disk.minor,
274 .raid_disk = -1,
275 .state = 0,
276 };
277
278 dprintf("add %d:%d to container\n", sd->disk.major, sd->disk.minor);
279
280 sd->next = st->devs;
281 st->devs = sd;
282
283 sprintf(nm, "%d:%d", sd->disk.major, sd->disk.minor);
284 dfd = dev_open(nm, O_RDWR);
285 if (dfd < 0)
286 return;
287
288 st->update_tail = &update;
289 st->ss->add_to_super(st, &dk, dfd, NULL, INVALID_SECTORS);
290 st->ss->write_init_super(st);
291 queue_metadata_update(update);
292 st->update_tail = NULL;
293 }
294
295 /*
296 * Create and queue update structure about the removed disks.
297 * The update is prepared by super type handler and passed to the monitor
298 * thread.
299 */
300 static void remove_disk_from_container(struct supertype *st, struct mdinfo *sd)
301 {
302 struct metadata_update *update = NULL;
303 mdu_disk_info_t dk = {
304 .number = -1,
305 .major = sd->disk.major,
306 .minor = sd->disk.minor,
307 .raid_disk = -1,
308 .state = 0,
309 };
310 dprintf("remove %d:%d from container\n",
311 sd->disk.major, sd->disk.minor);
312
313 st->update_tail = &update;
314 st->ss->remove_from_super(st, &dk);
315 /* FIXME this write_init_super shouldn't be here.
316 * We have it after add_to_super to write to new device,
317 * but with 'remove' we don't ant to write to that device!
318 */
319 st->ss->write_init_super(st);
320 queue_metadata_update(update);
321 st->update_tail = NULL;
322 }
323
324 static void manage_container(struct mdstat_ent *mdstat,
325 struct supertype *container)
326 {
327 /* Of interest here are:
328 * - if a new device has been added to the container, we
329 * add it to the array ignoring any metadata on it.
330 * - if a device has been removed from the container, we
331 * remove it from the device list and update the metadata.
332 * FIXME should we look for compatible metadata and take hints
333 * about spare assignment.... probably not.
334 */
335 if (mdstat->devcnt != container->devcnt) {
336 struct mdinfo **cdp, *cd, *di, *mdi;
337 int found;
338
339 /* read /sys/block/NAME/md/dev-??/block/dev to find out
340 * what is there, and compare with container->info.devs
341 * To see what is removed and what is added.
342 * These need to be remove from, or added to, the array
343 */
344 mdi = sysfs_read(-1, mdstat->devnm, GET_DEVS);
345 if (!mdi) {
346 /* invalidate the current count so we can try again */
347 container->devcnt = -1;
348 return;
349 }
350
351 /* check for removals */
352 for (cdp = &container->devs; *cdp; ) {
353 found = 0;
354 for (di = mdi->devs; di; di = di->next)
355 if (di->disk.major == (*cdp)->disk.major &&
356 di->disk.minor == (*cdp)->disk.minor) {
357 found = 1;
358 break;
359 }
360 if (!found) {
361 cd = *cdp;
362 *cdp = (*cdp)->next;
363 remove_disk_from_container(container, cd);
364 free(cd);
365 } else
366 cdp = &(*cdp)->next;
367 }
368
369 /* check for additions */
370 for (di = mdi->devs; di; di = di->next) {
371 for (cd = container->devs; cd; cd = cd->next)
372 if (di->disk.major == cd->disk.major &&
373 di->disk.minor == cd->disk.minor)
374 break;
375 if (!cd) {
376 struct mdinfo *newd = xmalloc(sizeof(*newd));
377
378 *newd = *di;
379 add_disk_to_container(container, newd);
380 }
381 }
382 sysfs_free(mdi);
383 container->devcnt = mdstat->devcnt;
384 }
385 }
386
387 static int sysfs_open2(char *devnum, char *name, char *attr)
388 {
389 int fd = sysfs_open(devnum, name, attr);
390 if (fd >= 0) {
391 /* seq_file in the kernel allocates buffer space
392 * on the first read. Do that now so 'monitor'
393 * never needs too.
394 */
395 char buf[200];
396 if (read(fd, buf, sizeof(buf)) < 0)
397 /* pretend not to ignore return value */
398 return fd;
399 }
400 return fd;
401 }
402
403 static int disk_init_and_add(struct mdinfo *disk, struct mdinfo *clone,
404 struct active_array *aa)
405 {
406 if (!disk || !clone)
407 return -1;
408
409 *disk = *clone;
410 disk->recovery_fd = sysfs_open2(aa->info.sys_name, disk->sys_name,
411 "recovery_start");
412 if (disk->recovery_fd < 0)
413 return -1;
414 disk->state_fd = sysfs_open2(aa->info.sys_name, disk->sys_name, "state");
415 if (disk->state_fd < 0) {
416 close(disk->recovery_fd);
417 return -1;
418 }
419 disk->bb_fd = sysfs_open2(aa->info.sys_name, disk->sys_name,
420 "bad_blocks");
421 if (disk->bb_fd < 0) {
422 close(disk->recovery_fd);
423 close(disk->state_fd);
424 return -1;
425 }
426 disk->ubb_fd = sysfs_open2(aa->info.sys_name, disk->sys_name,
427 "unacknowledged_bad_blocks");
428 if (disk->ubb_fd < 0) {
429 close(disk->recovery_fd);
430 close(disk->state_fd);
431 close(disk->bb_fd);
432 return -1;
433 }
434 disk->prev_state = read_dev_state(disk->state_fd);
435 disk->curr_state = disk->prev_state;
436 disk->next = aa->info.devs;
437 aa->info.devs = disk;
438
439 return 0;
440 }
441
442 static void manage_member(struct mdstat_ent *mdstat,
443 struct active_array *a)
444 {
445 /* Compare mdstat info with known state of member array.
446 * We do not need to look for device state changes here, that
447 * is dealt with by the monitor.
448 *
449 * If a reshape is being requested, monitor will have noticed
450 * that sync_action changed and will have set check_reshape.
451 * We just need to see if new devices have appeared. All metadata
452 * updates will already have been processed.
453 *
454 * We also want to handle degraded arrays here by
455 * trying to find and assign a spare.
456 * We do that whenever the monitor tells us too.
457 */
458 char buf[64];
459 int frozen;
460 struct supertype *container = a->container;
461 struct mdinfo *mdi;
462
463 if (container == NULL)
464 /* Raced with something */
465 return;
466
467 if (mdstat->active) {
468 // FIXME
469 a->info.array.raid_disks = mdstat->raid_disks;
470 // MORE
471 }
472
473 mdi = sysfs_read(-1, mdstat->devnm,
474 GET_COMPONENT|GET_CONSISTENCY_POLICY);
475 if (mdi) {
476 a->info.component_size = mdi->component_size;
477 a->info.consistency_policy = mdi->consistency_policy;
478 sysfs_free(mdi);
479 }
480
481 /* honor 'frozen' */
482 if (sysfs_get_str(&a->info, NULL, "metadata_version", buf, sizeof(buf)) > 0)
483 frozen = buf[9] == '-';
484 else
485 frozen = 1; /* can't read metadata_version assume the worst */
486
487 /* If sync_action is not 'idle' then don't try recovery now */
488 if (!frozen &&
489 sysfs_get_str(&a->info, NULL, "sync_action",
490 buf, sizeof(buf)) > 0 && strncmp(buf, "idle", 4) != 0)
491 frozen = 1;
492
493 if (mdstat->level) {
494 int level = map_name(pers, mdstat->level);
495 if (level == 0 || level == LEVEL_LINEAR) {
496 a->to_remove = 1;
497 wakeup_monitor();
498 return;
499 }
500 else if (a->info.array.level != level && level > 0) {
501 struct active_array *newa = duplicate_aa(a);
502 if (newa) {
503 newa->info.array.level = level;
504 replace_array(container, a, newa);
505 a = newa;
506 }
507 }
508 }
509
510 /* we are after monitor kick,
511 * so container field can be cleared - check it again
512 */
513 if (a->container == NULL)
514 return;
515
516 if (sigterm && a->info.safe_mode_delay != 1 &&
517 a->safe_mode_delay_fd >= 0) {
518 long int new_delay = 1;
519 char delay[10];
520 ssize_t len;
521
522 len = snprintf(delay, sizeof(delay), "0.%03ld\n", new_delay);
523 if (write(a->safe_mode_delay_fd, delay, len) == len)
524 a->info.safe_mode_delay = new_delay;
525 }
526
527 /* We don't check the array while any update is pending, as it
528 * might container a change (such as a spare assignment) which
529 * could affect our decisions.
530 */
531 if (a->check_degraded && !frozen &&
532 update_queue == NULL && update_queue_pending == NULL) {
533 struct metadata_update *updates = NULL;
534 struct mdinfo *newdev = NULL;
535 struct active_array *newa;
536 struct mdinfo *d;
537
538 a->check_degraded = 0;
539
540 /* The array may not be degraded, this is just a good time
541 * to check.
542 */
543 newdev = container->ss->activate_spare(a, &updates);
544 if (!newdev)
545 return;
546
547 newa = duplicate_aa(a);
548 if (!newa)
549 goto out;
550 /* prevent the kernel from activating the disk(s) before we
551 * finish adding them
552 */
553 dprintf("freezing %s\n", a->info.sys_name);
554 sysfs_set_str(&a->info, NULL, "sync_action", "frozen");
555
556 /* Add device to array and set offset/size/slot.
557 * and open files for each newdev */
558 for (d = newdev; d ; d = d->next) {
559 struct mdinfo *newd;
560
561 newd = xmalloc(sizeof(*newd));
562 if (sysfs_add_disk(&newa->info, d, 0) < 0) {
563 free(newd);
564 continue;
565 }
566 disk_init_and_add(newd, d, newa);
567 }
568 queue_metadata_update(updates);
569 updates = NULL;
570 while (update_queue_pending || update_queue) {
571 check_update_queue(container);
572 usleep(15*1000);
573 }
574 replace_array(container, a, newa);
575 if (sysfs_set_str(&a->info, NULL,
576 "sync_action", "recover") == 0)
577 newa->prev_action = recover;
578 dprintf("recovery started on %s\n", a->info.sys_name);
579 out:
580 while (newdev) {
581 d = newdev->next;
582 free(newdev);
583 newdev = d;
584 }
585 free_updates(&updates);
586 }
587
588 if (a->check_reshape) {
589 /* mdadm might have added some devices to the array.
590 * We want to disk_init_and_add any such device to a
591 * duplicate_aa and replace a with that.
592 * mdstat doesn't have enough info so we sysfs_read
593 * and look for new stuff.
594 */
595 struct mdinfo *info, *d, *d2, *newd;
596 unsigned long long array_size;
597 struct active_array *newa = NULL;
598 a->check_reshape = 0;
599 info = sysfs_read(-1, mdstat->devnm,
600 GET_DEVS|GET_OFFSET|GET_SIZE|GET_STATE);
601 if (!info)
602 goto out2;
603 for (d = info->devs; d; d = d->next) {
604 if (d->disk.raid_disk < 0)
605 continue;
606 for (d2 = a->info.devs; d2; d2 = d2->next)
607 if (d2->disk.raid_disk ==
608 d->disk.raid_disk)
609 break;
610 if (d2)
611 /* already have this one */
612 continue;
613 if (!newa) {
614 newa = duplicate_aa(a);
615 if (!newa)
616 break;
617 }
618 newd = xmalloc(sizeof(*newd));
619 disk_init_and_add(newd, d, newa);
620 }
621 if (sysfs_get_ll(info, NULL, "array_size", &array_size) == 0 &&
622 a->info.custom_array_size > array_size*2) {
623 sysfs_set_num(info, NULL, "array_size",
624 a->info.custom_array_size/2);
625 }
626 out2:
627 sysfs_free(info);
628 if (newa)
629 replace_array(container, a, newa);
630 }
631 }
632
633 static int aa_ready(struct active_array *aa)
634 {
635 struct mdinfo *d;
636 int level = aa->info.array.level;
637
638 for (d = aa->info.devs; d; d = d->next)
639 if (d->state_fd < 0)
640 return 0;
641
642 if (aa->info.state_fd < 0)
643 return 0;
644
645 if (level > 0 && (aa->action_fd < 0 || aa->resync_start_fd < 0))
646 return 0;
647
648 if (!aa->container)
649 return 0;
650
651 return 1;
652 }
653
654 static void manage_new(struct mdstat_ent *mdstat,
655 struct supertype *container,
656 struct active_array *victim)
657 {
658 /* A new array has appeared in this container.
659 * Hopefully it is already recorded in the metadata.
660 * Check, then create the new array to report it to
661 * the monitor.
662 */
663
664 struct active_array *new;
665 struct mdinfo *mdi, *di;
666 char *inst;
667 int i;
668 int failed = 0;
669 char buf[40];
670
671 /* check if array is ready to be monitored */
672 if (!mdstat->active || !mdstat->level)
673 return;
674 if (strcmp(mdstat->level, "raid0") == 0 ||
675 strcmp(mdstat->level, "linear") == 0)
676 return;
677
678 mdi = sysfs_read(-1, mdstat->devnm,
679 GET_LEVEL|GET_CHUNK|GET_DISKS|GET_COMPONENT|
680 GET_SAFEMODE|GET_DEVS|GET_OFFSET|GET_SIZE|GET_STATE|
681 GET_LAYOUT|GET_DEVS_ALL);
682
683 if (!mdi)
684 return;
685 new = xcalloc(1, sizeof(*new));
686
687 strcpy(new->info.sys_name, mdstat->devnm);
688
689 new->prev_state = new->curr_state = new->next_state = inactive;
690 new->prev_action= new->curr_action= new->next_action= idle;
691
692 new->container = container;
693
694 inst = to_subarray(mdstat, container->devnm);
695
696 new->info.array = mdi->array;
697 new->info.component_size = mdi->component_size;
698
699 for (i = 0; i < new->info.array.raid_disks; i++) {
700 struct mdinfo *newd = xmalloc(sizeof(*newd));
701
702 for (di = mdi->devs; di; di = di->next)
703 if (i == di->disk.raid_disk)
704 break;
705
706 if (disk_init_and_add(newd, di, new) != 0) {
707 if (newd)
708 free(newd);
709
710 failed++;
711 if (failed > new->info.array.failed_disks) {
712 /* we cannot properly monitor without all working disks */
713 new->container = NULL;
714 break;
715 }
716 }
717 }
718
719 new->action_fd = sysfs_open2(new->info.sys_name, NULL, "sync_action");
720 new->info.state_fd = sysfs_open2(new->info.sys_name, NULL, "array_state");
721 new->resync_start_fd = sysfs_open2(new->info.sys_name, NULL, "resync_start");
722 new->metadata_fd = sysfs_open2(new->info.sys_name, NULL, "metadata_version");
723 new->sync_completed_fd = sysfs_open2(new->info.sys_name, NULL, "sync_completed");
724 new->safe_mode_delay_fd = sysfs_open2(new->info.sys_name, NULL,
725 "safe_mode_delay");
726
727 dprintf("inst: %s action: %d state: %d\n", inst,
728 new->action_fd, new->info.state_fd);
729
730 if (mdi->safe_mode_delay >= 50)
731 /* Normal start, mdadm set this. */
732 new->info.safe_mode_delay = mdi->safe_mode_delay;
733 else
734 /* Restart, just pick a number */
735 new->info.safe_mode_delay = 5000;
736 sysfs_set_safemode(&new->info, new->info.safe_mode_delay);
737
738 /* reshape_position is set by mdadm in sysfs
739 * read this information for new arrays only (empty victim)
740 */
741 if ((victim == NULL) &&
742 (sysfs_get_str(mdi, NULL, "sync_action", buf, 40) > 0) &&
743 (strncmp(buf, "reshape", 7) == 0)) {
744 if (sysfs_get_ll(mdi, NULL, "reshape_position",
745 &new->last_checkpoint) != 0)
746 new->last_checkpoint = 0;
747 else {
748 int data_disks = mdi->array.raid_disks;
749 if (mdi->array.level == 4 || mdi->array.level == 5)
750 data_disks--;
751 if (mdi->array.level == 6)
752 data_disks -= 2;
753
754 new->last_checkpoint /= data_disks;
755 }
756 dprintf("mdmon: New monitored array is under reshape.\n"
757 " Last checkpoint is: %llu\n",
758 new->last_checkpoint);
759 }
760
761 sysfs_free(mdi);
762
763 /* if everything checks out tell the metadata handler we want to
764 * manage this instance
765 */
766 if (!aa_ready(new) || container->ss->open_new(container, new, inst) < 0) {
767 pr_err("failed to monitor %s\n",
768 mdstat->metadata_version);
769 new->container = NULL;
770 free_aa(new);
771 } else {
772 replace_array(container, victim, new);
773 if (failed) {
774 new->check_degraded = 1;
775 manage_member(mdstat, new);
776 }
777 }
778 }
779
780 void manage(struct mdstat_ent *mdstat, struct supertype *container)
781 {
782 /* We have just read mdstat and need to compare it with
783 * the known active arrays.
784 * Arrays with the wrong metadata are ignored.
785 */
786
787 for ( ; mdstat ; mdstat = mdstat->next) {
788 struct active_array *a;
789 if (strcmp(mdstat->devnm, container->devnm) == 0) {
790 manage_container(mdstat, container);
791 continue;
792 }
793 if (!is_container_member(mdstat, container->devnm))
794 /* Not for this array */
795 continue;
796 /* Looks like a member of this container */
797 for (a = container->arrays; a; a = a->next) {
798 if (strcmp(mdstat->devnm, a->info.sys_name) == 0) {
799 if (a->container && a->to_remove == 0)
800 manage_member(mdstat, a);
801 break;
802 }
803 }
804 if ((a == NULL || !a->container) && !sigterm)
805 manage_new(mdstat, container, a);
806 }
807 }
808
809 static void handle_message(struct supertype *container, struct metadata_update *msg)
810 {
811 /* queue this metadata update through to the monitor */
812
813 struct metadata_update *mu;
814
815 if (msg->len <= 0)
816 while (update_queue_pending || update_queue) {
817 check_update_queue(container);
818 usleep(15*1000);
819 }
820
821 if (msg->len == 0) { /* ping_monitor */
822 int cnt;
823
824 cnt = monitor_loop_cnt;
825 if (cnt & 1)
826 cnt += 2; /* wait until next pselect */
827 else
828 cnt += 3; /* wait for 2 pselects */
829 wakeup_monitor();
830
831 while (monitor_loop_cnt - cnt < 0)
832 usleep(10 * 1000);
833 } else if (msg->len == -1) { /* ping_manager */
834 struct mdstat_ent *mdstat = mdstat_read(1, 0);
835
836 manage(mdstat, container);
837 free_mdstat(mdstat);
838 } else if (!sigterm) {
839 mu = xmalloc(sizeof(*mu));
840 mu->len = msg->len;
841 mu->buf = msg->buf;
842 msg->buf = NULL;
843 mu->space = NULL;
844 mu->space_list = NULL;
845 mu->next = NULL;
846 if (container->ss->prepare_update)
847 if (!container->ss->prepare_update(container, mu))
848 free_updates(&mu);
849 queue_metadata_update(mu);
850 }
851 }
852
853 void read_sock(struct supertype *container)
854 {
855 int fd;
856 struct metadata_update msg;
857 int terminate = 0;
858 long fl;
859 int tmo = 3; /* 3 second timeout before hanging up the socket */
860
861 fd = accept(container->sock, NULL, NULL);
862 if (fd < 0)
863 return;
864
865 fl = fcntl(fd, F_GETFL, 0);
866 fl |= O_NONBLOCK;
867 fcntl(fd, F_SETFL, fl);
868
869 do {
870 msg.buf = NULL;
871
872 /* read and validate the message */
873 if (receive_message(fd, &msg, tmo) == 0) {
874 handle_message(container, &msg);
875 if (msg.len == 0) {
876 /* ping reply with version */
877 msg.buf = Version;
878 msg.len = strlen(Version) + 1;
879 if (send_message(fd, &msg, tmo) < 0)
880 terminate = 1;
881 } else if (ack(fd, tmo) < 0)
882 terminate = 1;
883 } else
884 terminate = 1;
885
886 } while (!terminate);
887
888 close(fd);
889 }
890
891 int exit_now = 0;
892 int manager_ready = 0;
893 void do_manager(struct supertype *container)
894 {
895 struct mdstat_ent *mdstat;
896 sigset_t set;
897
898 sigprocmask(SIG_UNBLOCK, NULL, &set);
899 sigdelset(&set, SIGUSR1);
900 sigdelset(&set, SIGTERM);
901
902 do {
903
904 if (exit_now)
905 exit(0);
906
907 /* Can only 'manage' things if 'monitor' is not making
908 * structural changes to metadata, so need to check
909 * update_queue
910 */
911 if (update_queue == NULL) {
912 mdstat = mdstat_read(1, 0);
913
914 manage(mdstat, container);
915
916 read_sock(container);
917
918 free_mdstat(mdstat);
919 }
920 remove_old();
921
922 check_update_queue(container);
923
924 manager_ready = 1;
925
926 if (sigterm)
927 wakeup_monitor();
928
929 if (update_queue == NULL)
930 mdstat_wait_fd(container->sock, &set);
931 else
932 /* If an update is happening, just wait for signal */
933 pselect(0, NULL, NULL, NULL, NULL, &set);
934 } while(1);
935 }