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