]> git.ipfire.org Git - thirdparty/mdadm.git/blame - managemon.c
Correctly abort level change when reshape_array fails.
[thirdparty/mdadm.git] / managemon.c
CommitLineData
a54d5262
DW
1/*
2 * mdmon - monitor external metadata arrays
3 *
e736b623
N
4 * Copyright (C) 2007-2009 Neil Brown <neilb@suse.de>
5 * Copyright (C) 2007-2009 Intel Corporation
a54d5262
DW
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 */
549e9569
NB
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 *
6c3fb95c
NB
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....
549e9569
NB
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"
4d43913c 107#include <sys/syscall.h>
549e9569 108#include <sys/socket.h>
1ed3f387 109#include <signal.h>
549e9569 110
2a0bb19e
DW
111static void close_aa(struct active_array *aa)
112{
113 struct mdinfo *d;
114
e1516be1
DW
115 for (d = aa->info.devs; d; d = d->next) {
116 close(d->recovery_fd);
2a0bb19e 117 close(d->state_fd);
e1516be1 118 }
2a0bb19e
DW
119
120 close(aa->action_fd);
121 close(aa->info.state_fd);
122 close(aa->resync_start_fd);
a9d868c3
AK
123 close(aa->metadata_fd);
124 close(aa->sync_completed_fd);
2a0bb19e
DW
125}
126
549e9569
NB
127static void free_aa(struct active_array *aa)
128{
2a0bb19e
DW
129 /* Note that this doesn't close fds if they are being used
130 * by a clone. ->container will be set for a clone
549e9569 131 */
4e6e574a 132 dprintf("%s: devnum: %d\n", __func__, aa->devnum);
2a0bb19e
DW
133 if (!aa->container)
134 close_aa(aa);
549e9569
NB
135 while (aa->info.devs) {
136 struct mdinfo *d = aa->info.devs;
137 aa->info.devs = d->next;
138 free(d);
139 }
140 free(aa);
141}
142
6c3fb95c
NB
143static struct active_array *duplicate_aa(struct active_array *aa)
144{
145 struct active_array *newa = malloc(sizeof(*newa));
146 struct mdinfo **dp1, **dp2;
147
148 *newa = *aa;
149 newa->next = NULL;
150 newa->replaces = NULL;
151 newa->info.next = NULL;
152
153 dp2 = &newa->info.devs;
154
155 for (dp1 = &aa->info.devs; *dp1; dp1 = &(*dp1)->next) {
156 struct mdinfo *d;
157 if ((*dp1)->state_fd < 0)
158 continue;
159
160 d = malloc(sizeof(*d));
161 *d = **dp1;
162 *dp2 = d;
163 dp2 = & d->next;
164 }
7e1432fb 165 *dp2 = NULL;
6c3fb95c
NB
166
167 return newa;
168}
169
4d43913c 170static void wakeup_monitor(void)
2a0bb19e 171{
4d43913c
NB
172 /* tgkill(getpid(), mon_tid, SIGUSR1); */
173 int pid = getpid();
174 syscall(SYS_tgkill, pid, mon_tid, SIGUSR1);
2a0bb19e
DW
175}
176
1ed3f387
NB
177static void remove_old(void)
178{
179 if (discard_this) {
180 discard_this->next = NULL;
181 free_aa(discard_this);
182 if (pending_discard == discard_this)
183 pending_discard = NULL;
184 discard_this = NULL;
48561b01 185 wakeup_monitor();
1ed3f387
NB
186 }
187}
188
549e9569
NB
189static void replace_array(struct supertype *container,
190 struct active_array *old,
191 struct active_array *new)
192{
193 /* To replace an array, we add it to the top of the list
194 * marked with ->replaces to point to the original.
195 * 'monitor' will take the original out of the list
196 * and put it on 'discard_this'. We take it from there
197 * and discard it.
198 */
1ed3f387 199 remove_old();
549e9569
NB
200 while (pending_discard) {
201 while (discard_this == NULL)
202 sleep(1);
1ed3f387 203 remove_old();
549e9569
NB
204 }
205 pending_discard = old;
206 new->replaces = old;
207 new->next = container->arrays;
208 container->arrays = new;
4d43913c 209 wakeup_monitor();
549e9569
NB
210}
211
2e735d19
NB
212struct metadata_update *update_queue = NULL;
213struct metadata_update *update_queue_handled = NULL;
214struct metadata_update *update_queue_pending = NULL;
215
071cfc42 216static void free_updates(struct metadata_update **update)
2e735d19 217{
071cfc42
DW
218 while (*update) {
219 struct metadata_update *this = *update;
cb23f1f4 220 void **space_list = this->space_list;
071cfc42
DW
221
222 *update = this->next;
904c1ef7 223 free(this->buf);
071cfc42 224 free(this->space);
cb23f1f4
N
225 while (space_list) {
226 void *space = space_list;
227 space_list = *space_list;
228 free(space);
229 }
2e735d19
NB
230 free(this);
231 }
071cfc42
DW
232}
233
234void check_update_queue(struct supertype *container)
235{
236 free_updates(&update_queue_handled);
237
2e735d19
NB
238 if (update_queue == NULL &&
239 update_queue_pending) {
240 update_queue = update_queue_pending;
241 update_queue_pending = NULL;
4d43913c 242 wakeup_monitor();
2e735d19
NB
243 }
244}
245
6c3fb95c 246static void queue_metadata_update(struct metadata_update *mu)
2e735d19
NB
247{
248 struct metadata_update **qp;
249
250 qp = &update_queue_pending;
251 while (*qp)
252 qp = & ((*qp)->next);
253 *qp = mu;
254}
255
43dad3d6
DW
256static void add_disk_to_container(struct supertype *st, struct mdinfo *sd)
257{
258 int dfd;
259 char nm[20];
661dce36 260 struct supertype *st2;
43dad3d6 261 struct metadata_update *update = NULL;
661dce36 262 struct mdinfo info;
43dad3d6
DW
263 mdu_disk_info_t dk = {
264 .number = -1,
265 .major = sd->disk.major,
266 .minor = sd->disk.minor,
267 .raid_disk = -1,
268 .state = 0,
269 };
270
271 dprintf("%s: add %d:%d to container\n",
272 __func__, sd->disk.major, sd->disk.minor);
273
04a8ac08
DW
274 sd->next = st->devs;
275 st->devs = sd;
276
43dad3d6
DW
277 sprintf(nm, "%d:%d", sd->disk.major, sd->disk.minor);
278 dfd = dev_open(nm, O_RDWR);
279 if (dfd < 0)
280 return;
281
661dce36
N
282 /* Check the metadata and see if it is already part of this
283 * array
284 */
285 st2 = dup_super(st);
286 if (st2->ss->load_super(st2, dfd, NULL) == 0) {
a5d85af7 287 st2->ss->getinfo_super(st, &info, NULL);
661dce36
N
288 if (st->ss->compare_super(st, st2) == 0 &&
289 info.disk.raid_disk >= 0) {
290 /* Looks like a good member of array.
291 * Just accept it.
292 * mdadm will incorporate any parts into
293 * active arrays.
294 */
295 st2->ss->free_super(st2);
296 return;
297 }
298 }
299 st2->ss->free_super(st2);
300
43dad3d6
DW
301 st->update_tail = &update;
302 st->ss->add_to_super(st, &dk, dfd, NULL);
303 st->ss->write_init_super(st);
304 queue_metadata_update(update);
305 st->update_tail = NULL;
306}
307
1a64be56
LM
308/*
309 * Create and queue update structure about the removed disks.
310 * The update is prepared by super type handler and passed to the monitor
311 * thread.
312 */
313static void remove_disk_from_container(struct supertype *st, struct mdinfo *sd)
314{
315 struct metadata_update *update = NULL;
316 mdu_disk_info_t dk = {
317 .number = -1,
318 .major = sd->disk.major,
319 .minor = sd->disk.minor,
320 .raid_disk = -1,
321 .state = 0,
322 };
323 /* nothing to do if super type handler does not support
324 * remove disk primitive
325 */
326 if (!st->ss->remove_from_super)
327 return;
328 dprintf("%s: remove %d:%d from container\n",
329 __func__, sd->disk.major, sd->disk.minor);
330
331 st->update_tail = &update;
332 st->ss->remove_from_super(st, &dk);
333 st->ss->write_init_super(st);
334 queue_metadata_update(update);
335 st->update_tail = NULL;
336}
337
549e9569
NB
338static void manage_container(struct mdstat_ent *mdstat,
339 struct supertype *container)
340{
1a64be56
LM
341 /* Of interest here are:
342 * - if a new device has been added to the container, we
343 * add it to the array ignoring any metadata on it.
344 * - if a device has been removed from the container, we
345 * remove it from the device list and update the metadata.
549e9569
NB
346 * FIXME should we look for compatible metadata and take hints
347 * about spare assignment.... probably not.
549e9569
NB
348 */
349 if (mdstat->devcnt != container->devcnt) {
7bc1962f
DW
350 struct mdinfo **cdp, *cd, *di, *mdi;
351 int found;
352
549e9569
NB
353 /* read /sys/block/NAME/md/dev-??/block/dev to find out
354 * what is there, and compare with container->info.devs
355 * To see what is removed and what is added.
356 * These need to be remove from, or added to, the array
357 */
b526e52d 358 mdi = sysfs_read(-1, mdstat->devnum, GET_DEVS);
313a4a82
DW
359 if (!mdi) {
360 /* invalidate the current count so we can try again */
361 container->devcnt = -1;
7bc1962f 362 return;
313a4a82 363 }
7bc1962f
DW
364
365 /* check for removals */
366 for (cdp = &container->devs; *cdp; ) {
367 found = 0;
368 for (di = mdi->devs; di; di = di->next)
369 if (di->disk.major == (*cdp)->disk.major &&
370 di->disk.minor == (*cdp)->disk.minor) {
371 found = 1;
372 break;
373 }
374 if (!found) {
375 cd = *cdp;
376 *cdp = (*cdp)->next;
1a64be56 377 remove_disk_from_container(container, cd);
7bc1962f
DW
378 free(cd);
379 } else
380 cdp = &(*cdp)->next;
381 }
43dad3d6
DW
382
383 /* check for additions */
384 for (di = mdi->devs; di; di = di->next) {
385 for (cd = container->devs; cd; cd = cd->next)
386 if (di->disk.major == cd->disk.major &&
387 di->disk.minor == cd->disk.minor)
388 break;
04a8ac08
DW
389 if (!cd) {
390 struct mdinfo *newd = malloc(sizeof(*newd));
391
392 if (!newd) {
393 container->devcnt = -1;
394 continue;
395 }
396 *newd = *di;
397 add_disk_to_container(container, newd);
398 }
43dad3d6 399 }
7bc1962f 400 sysfs_free(mdi);
549e9569
NB
401 container->devcnt = mdstat->devcnt;
402 }
403}
404
63b4aae3
DW
405static int disk_init_and_add(struct mdinfo *disk, struct mdinfo *clone,
406 struct active_array *aa)
407{
408 if (!disk || !clone)
409 return -1;
410
411 *disk = *clone;
412 disk->recovery_fd = sysfs_open(aa->devnum, disk->sys_name, "recovery_start");
413 disk->state_fd = sysfs_open(aa->devnum, disk->sys_name, "state");
414 disk->prev_state = read_dev_state(disk->state_fd);
415 disk->curr_state = disk->prev_state;
416 disk->next = aa->info.devs;
417 aa->info.devs = disk;
418
419 return 0;
420}
421
549e9569
NB
422static void manage_member(struct mdstat_ent *mdstat,
423 struct active_array *a)
424{
425 /* Compare mdstat info with known state of member array.
426 * We do not need to look for device state changes here, that
427 * is dealt with by the monitor.
428 *
0f99b4bd
N
429 * If a reshape is being requested, monitor will have noticed
430 * that sync_action changed and will have set check_reshape.
431 * We just need to see if new devices have appeared. All metadata
432 * updates will already have been processed.
6c3fb95c 433 *
0f99b4bd 434 * We also want to handle degraded arrays here by
6c3fb95c
NB
435 * trying to find and assign a spare.
436 * We do that whenever the monitor tells us too.
549e9569 437 */
bc77ed53
DW
438 char buf[64];
439 int frozen;
440
549e9569
NB
441 // FIXME
442 a->info.array.raid_disks = mdstat->raid_disks;
549e9569
NB
443 // MORE
444
bc77ed53
DW
445 /* honor 'frozen' */
446 if (sysfs_get_str(&a->info, NULL, "metadata_version", buf, sizeof(buf)) > 0)
447 frozen = buf[9] == '-';
448 else
449 frozen = 1; /* can't read metadata_version assume the worst */
450
57f8c769
AK
451 if (mdstat->level) {
452 int level = map_name(pers, mdstat->level);
453 if (a->info.array.level != level && level >= 0) {
454 struct active_array *newa = duplicate_aa(a);
455 if (newa) {
456 newa->info.array.level = level;
457 replace_array(a->container, a, newa);
458 a = newa;
459 }
460 }
461 }
462
bc77ed53 463 if (a->check_degraded && !frozen) {
6c3fb95c 464 struct metadata_update *updates = NULL;
071cfc42 465 struct mdinfo *newdev = NULL;
6c3fb95c 466 struct active_array *newa;
071cfc42 467 struct mdinfo *d;
3c00ffbe 468
6c3fb95c
NB
469 a->check_degraded = 0;
470
471 /* The array may not be degraded, this is just a good time
472 * to check.
473 */
474 newdev = a->container->ss->activate_spare(a, &updates);
071cfc42
DW
475 if (!newdev)
476 return;
477
478 newa = duplicate_aa(a);
479 if (!newa)
480 goto out;
481 /* Cool, we can add a device or several. */
482
483 /* Add device to array and set offset/size/slot.
484 * and open files for each newdev */
485 for (d = newdev; d ; d = d->next) {
486 struct mdinfo *newd;
487
488 newd = malloc(sizeof(*newd));
489 if (!newd)
490 continue;
2904b26f 491 if (sysfs_add_disk(&newa->info, d, 0) < 0) {
071cfc42
DW
492 free(newd);
493 continue;
6c3fb95c 494 }
63b4aae3 495 disk_init_and_add(newd, d, newa);
071cfc42
DW
496 }
497 queue_metadata_update(updates);
498 updates = NULL;
499 replace_array(a->container, a, newa);
500 sysfs_set_str(&a->info, NULL, "sync_action", "recover");
501 out:
502 while (newdev) {
503 d = newdev->next;
504 free(newdev);
505 newdev = d;
6c3fb95c 506 }
071cfc42 507 free_updates(&updates);
6c3fb95c 508 }
0f99b4bd
N
509
510 if (a->check_reshape) {
511 /* mdadm might have added some devices to the array.
512 * We want to disk_init_and_add any such device to a
513 * duplicate_aa and replace a with that.
514 * mdstat doesn't have enough info so we sysfs_read
515 * and look for new stuff.
516 */
517 struct mdinfo *info, *d, *d2, *newd;
aad6f216 518 unsigned long long array_size;
0f99b4bd
N
519 struct active_array *newa = NULL;
520 a->check_reshape = 0;
521 info = sysfs_read(-1, mdstat->devnum,
522 GET_DEVS|GET_OFFSET|GET_SIZE|GET_STATE);
523 if (!info)
524 goto out2;
525 for (d = info->devs; d; d = d->next) {
526 if (d->disk.raid_disk < 0)
527 continue;
528 for (d2 = a->info.devs; d2; d2 = d2->next)
529 if (d2->disk.raid_disk ==
530 d->disk.raid_disk)
531 break;
532 if (d2)
533 /* already have this one */
534 continue;
535 if (!newa) {
536 newa = duplicate_aa(a);
537 if (!newa)
538 break;
539 }
540 newd = malloc(sizeof(*newd));
541 if (!newd)
542 continue;
543 disk_init_and_add(newd, d, newa);
544 }
aad6f216
N
545 if (sysfs_get_ll(info, NULL, "array_size", &array_size) == 0
546 && a->info.custom_array_size > array_size) {
547 sysfs_set_num(info, NULL, "array_size",
548 a->info.custom_array_size);
549 }
0f99b4bd
N
550 out2:
551 sysfs_free(info);
552 if (newa)
553 replace_array(a->container, a, newa);
554 }
549e9569
NB
555}
556
836759d5
DW
557static int aa_ready(struct active_array *aa)
558{
559 struct mdinfo *d;
560 int level = aa->info.array.level;
561
562 for (d = aa->info.devs; d; d = d->next)
563 if (d->state_fd < 0)
564 return 0;
565
566 if (aa->info.state_fd < 0)
567 return 0;
568
569 if (level > 0 && (aa->action_fd < 0 || aa->resync_start_fd < 0))
570 return 0;
571
572 if (!aa->container)
573 return 0;
574
575 return 1;
576}
577
549e9569 578static void manage_new(struct mdstat_ent *mdstat,
2a0bb19e
DW
579 struct supertype *container,
580 struct active_array *victim)
549e9569
NB
581{
582 /* A new array has appeared in this container.
583 * Hopefully it is already recorded in the metadata.
584 * Check, then create the new array to report it to
585 * the monitor.
586 */
587
588 struct active_array *new;
589 struct mdinfo *mdi, *di;
cba0191b 590 char *inst;
549e9569 591 int i;
f1d26766 592 int failed = 0;
549e9569 593
836759d5
DW
594 /* check if array is ready to be monitored */
595 if (!mdstat->active)
596 return;
597
598 mdi = sysfs_read(-1, mdstat->devnum,
599 GET_LEVEL|GET_CHUNK|GET_DISKS|GET_COMPONENT|
f1d26766 600 GET_DEGRADED|GET_DEVS|GET_OFFSET|GET_SIZE|GET_STATE);
836759d5 601
549e9569
NB
602 new = malloc(sizeof(*new));
603
836759d5
DW
604 if (!new || !mdi) {
605 if (mdi)
606 sysfs_free(mdi);
607 if (new)
608 free(new);
609 return;
610 }
d52690ac
NB
611 memset(new, 0, sizeof(*new));
612
549e9569 613 new->devnum = mdstat->devnum;
7e1432fb 614 strcpy(new->info.sys_name, devnum2devname(new->devnum));
549e9569
NB
615
616 new->prev_state = new->curr_state = new->next_state = inactive;
617 new->prev_action= new->curr_action= new->next_action= idle;
618
619 new->container = container;
620
e5408a32 621 inst = to_subarray(mdstat, container->devname);
549e9569 622
549e9569 623 new->info.array = mdi->array;
272bcc48 624 new->info.component_size = mdi->component_size;
549e9569
NB
625
626 for (i = 0; i < new->info.array.raid_disks; i++) {
627 struct mdinfo *newd = malloc(sizeof(*newd));
628
629 for (di = mdi->devs; di; di = di->next)
630 if (i == di->disk.raid_disk)
631 break;
632
63b4aae3 633 if (disk_init_and_add(newd, di, new) != 0) {
7da80e6f
DW
634 if (newd)
635 free(newd);
636
f1d26766 637 failed++;
7da80e6f
DW
638 if (failed > new->info.array.failed_disks) {
639 /* we cannot properly monitor without all working disks */
640 new->container = NULL;
641 break;
642 }
549e9569 643 }
549e9569 644 }
836759d5 645
549e9569
NB
646 new->action_fd = sysfs_open(new->devnum, NULL, "sync_action");
647 new->info.state_fd = sysfs_open(new->devnum, NULL, "array_state");
c052ba30 648 new->resync_start_fd = sysfs_open(new->devnum, NULL, "resync_start");
e9dd1598 649 new->metadata_fd = sysfs_open(new->devnum, NULL, "metadata_version");
484240d8 650 new->sync_completed_fd = sysfs_open(new->devnum, NULL, "sync_completed");
4e6e574a
DW
651 dprintf("%s: inst: %d action: %d state: %d\n", __func__, atoi(inst),
652 new->action_fd, new->info.state_fd);
549e9569 653
4fa5aef9 654 sysfs_free(mdi);
836759d5
DW
655
656 /* if everything checks out tell the metadata handler we want to
657 * manage this instance
658 */
659 if (!aa_ready(new) || container->ss->open_new(container, new, inst) < 0) {
660 fprintf(stderr, "mdmon: failed to monitor %s\n",
661 mdstat->metadata_version);
549e9569 662 new->container = NULL;
836759d5 663 free_aa(new);
93f7caca 664 } else {
2a0bb19e 665 replace_array(container, victim, new);
93f7caca
DW
666 if (failed) {
667 new->check_degraded = 1;
668 manage_member(mdstat, new);
669 }
670 }
549e9569
NB
671}
672
5d19760d 673void manage(struct mdstat_ent *mdstat, struct supertype *container)
549e9569
NB
674{
675 /* We have just read mdstat and need to compare it with
676 * the known active arrays.
677 * Arrays with the wrong metadata are ignored.
678 */
679
680 for ( ; mdstat ; mdstat = mdstat->next) {
681 struct active_array *a;
682 if (mdstat->devnum == container->devnum) {
683 manage_container(mdstat, container);
684 continue;
685 }
883a6142 686 if (!is_container_member(mdstat, container->devname))
549e9569
NB
687 /* Not for this array */
688 continue;
689 /* Looks like a member of this container */
5d19760d 690 for (a = container->arrays; a; a = a->next) {
549e9569
NB
691 if (mdstat->devnum == a->devnum) {
692 if (a->container)
693 manage_member(mdstat, a);
694 break;
695 }
696 }
2a0bb19e
DW
697 if (a == NULL || !a->container)
698 manage_new(mdstat, container, a);
549e9569
NB
699 }
700}
701
edd8d13c 702static void handle_message(struct supertype *container, struct metadata_update *msg)
3e70c845 703{
edd8d13c
NB
704 /* queue this metadata update through to the monitor */
705
706 struct metadata_update *mu;
707
313a4a82 708 if (msg->len <= 0)
3c00ffbe
N
709 while (update_queue_pending || update_queue) {
710 check_update_queue(container);
711 usleep(15*1000);
712 }
713
313a4a82
DW
714 if (msg->len == 0) { /* ping_monitor */
715 int cnt;
716
3c00ffbe 717 cnt = monitor_loop_cnt;
1eb252b8
N
718 if (cnt & 1)
719 cnt += 2; /* wait until next pselect */
720 else
721 cnt += 3; /* wait for 2 pselects */
722 wakeup_monitor();
3c00ffbe 723
1eb252b8
N
724 while (monitor_loop_cnt - cnt < 0)
725 usleep(10 * 1000);
313a4a82
DW
726 } else if (msg->len == -1) { /* ping_manager */
727 struct mdstat_ent *mdstat = mdstat_read(1, 0);
728
729 manage(mdstat, container);
730 free_mdstat(mdstat);
6144ed44 731 } else if (!sigterm) {
edd8d13c
NB
732 mu = malloc(sizeof(*mu));
733 mu->len = msg->len;
734 mu->buf = msg->buf;
735 msg->buf = NULL;
736 mu->space = NULL;
cb23f1f4 737 mu->space_list = NULL;
edd8d13c
NB
738 mu->next = NULL;
739 if (container->ss->prepare_update)
740 container->ss->prepare_update(container, mu);
741 queue_metadata_update(mu);
742 }
3e70c845
DW
743}
744
745void read_sock(struct supertype *container)
549e9569
NB
746{
747 int fd;
bfa44e2e 748 struct metadata_update msg;
b109d928
DW
749 int terminate = 0;
750 long fl;
751 int tmo = 3; /* 3 second timeout before hanging up the socket */
549e9569 752
3e70c845 753 fd = accept(container->sock, NULL, NULL);
549e9569
NB
754 if (fd < 0)
755 return;
b109d928
DW
756
757 fl = fcntl(fd, F_GETFL, 0);
758 fl |= O_NONBLOCK;
759 fcntl(fd, F_SETFL, fl);
760
761 do {
762 msg.buf = NULL;
763
764 /* read and validate the message */
765 if (receive_message(fd, &msg, tmo) == 0) {
bfa44e2e 766 handle_message(container, &msg);
bc77ed53
DW
767 if (msg.len == 0) {
768 /* ping reply with version */
769 msg.buf = Version;
770 msg.len = strlen(Version) + 1;
771 if (send_message(fd, &msg, tmo) < 0)
772 terminate = 1;
773 } else if (ack(fd, tmo) < 0)
bfa44e2e
NB
774 terminate = 1;
775 } else
b109d928 776 terminate = 1;
b109d928 777
b109d928
DW
778 } while (!terminate);
779
549e9569
NB
780 close(fd);
781}
1ed3f387 782
e0d6609f
NB
783int exit_now = 0;
784int manager_ready = 0;
549e9569
NB
785void do_manager(struct supertype *container)
786{
787 struct mdstat_ent *mdstat;
4d43913c 788 sigset_t set;
1ed3f387 789
4d43913c
NB
790 sigprocmask(SIG_UNBLOCK, NULL, &set);
791 sigdelset(&set, SIGUSR1);
6144ed44 792 sigdelset(&set, SIGTERM);
549e9569
NB
793
794 do {
1ed3f387 795
e0d6609f
NB
796 if (exit_now)
797 exit(0);
798
3c00ffbe
N
799 /* Can only 'manage' things if 'monitor' is not making
800 * structural changes to metadata, so need to check
801 * update_queue
802 */
803 if (update_queue == NULL) {
804 mdstat = mdstat_read(1, 0);
549e9569 805
3c00ffbe 806 manage(mdstat, container);
549e9569 807
3c00ffbe 808 read_sock(container);
4fa5aef9 809
3c00ffbe
N
810 free_mdstat(mdstat);
811 }
1ed3f387
NB
812 remove_old();
813
2e735d19
NB
814 check_update_queue(container);
815
e0d6609f 816 manager_ready = 1;
4d43913c 817
6144ed44
DW
818 if (sigterm)
819 wakeup_monitor();
820
5d4d1b26 821 if (update_queue == NULL)
58a4ba2a 822 mdstat_wait_fd(container->sock, &set);
5d4d1b26 823 else
3c00ffbe
N
824 /* If an update is happening, just wait for signal */
825 pselect(0, NULL, NULL, NULL, NULL, &set);
549e9569
NB
826 } while(1);
827}