Consistently print program Name and __func__ in debug messages.
[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];
413 read(fd, buf, sizeof(buf));
414 }
415 return fd;
416}
417
63b4aae3
DW
418static int disk_init_and_add(struct mdinfo *disk, struct mdinfo *clone,
419 struct active_array *aa)
420{
421 if (!disk || !clone)
422 return -1;
423
424 *disk = *clone;
da5a36fa
N
425 disk->recovery_fd = sysfs_open2(aa->info.sys_name, disk->sys_name,
426 "recovery_start");
3e1d79b2
JS
427 if (disk->recovery_fd < 0)
428 return -1;
da5a36fa 429 disk->state_fd = sysfs_open2(aa->info.sys_name, disk->sys_name, "state");
3e1d79b2
JS
430 if (disk->state_fd < 0) {
431 close(disk->recovery_fd);
432 return -1;
433 }
63b4aae3
DW
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
549e9569
NB
442static 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 *
0f99b4bd
N
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.
6c3fb95c 453 *
0f99b4bd 454 * We also want to handle degraded arrays here by
6c3fb95c
NB
455 * trying to find and assign a spare.
456 * We do that whenever the monitor tells us too.
549e9569 457 */
bc77ed53
DW
458 char buf[64];
459 int frozen;
4e2c1a9a 460 struct supertype *container = a->container;
4edb8530 461 unsigned long long int component_size = 0;
4e2c1a9a
N
462
463 if (container == NULL)
464 /* Raced with something */
465 return;
bc77ed53 466
e49a8a80
N
467 if (mdstat->active) {
468 // FIXME
469 a->info.array.raid_disks = mdstat->raid_disks;
470 // MORE
471 }
549e9569 472
4edb8530
PB
473 if (sysfs_get_ll(&a->info, NULL, "component_size", &component_size) >= 0)
474 a->info.component_size = component_size << 1;
475
bc77ed53
DW
476 /* honor 'frozen' */
477 if (sysfs_get_str(&a->info, NULL, "metadata_version", buf, sizeof(buf)) > 0)
478 frozen = buf[9] == '-';
479 else
480 frozen = 1; /* can't read metadata_version assume the worst */
481
f54a6742
N
482 /* If sync_action is not 'idle' then don't try recovery now */
483 if (!frozen
484 && sysfs_get_str(&a->info, NULL, "sync_action", buf, sizeof(buf)) > 0
485 && strncmp(buf, "idle", 4) != 0)
486 frozen = 1;
487
57f8c769
AK
488 if (mdstat->level) {
489 int level = map_name(pers, mdstat->level);
7023e0b8 490 if (level == 0 || level == LEVEL_LINEAR) {
ba714450 491 a->to_remove = 1;
84f3857f 492 wakeup_monitor();
7023e0b8
N
493 return;
494 }
495 else if (a->info.array.level != level && level > 0) {
57f8c769
AK
496 struct active_array *newa = duplicate_aa(a);
497 if (newa) {
498 newa->info.array.level = level;
4e2c1a9a 499 replace_array(container, a, newa);
57f8c769
AK
500 a = newa;
501 }
502 }
503 }
504
50927b13
AK
505 /* we are after monitor kick,
506 * so container field can be cleared - check it again
507 */
508 if (a->container == NULL)
509 return;
510
4e5e54cf 511 if (sigterm && a->info.safe_mode_delay != 1) {
2ef21963
N
512 sysfs_set_safemode(&a->info, 1);
513 a->info.safe_mode_delay = 1;
514 }
515
0c4f6e37 516 /* We don't check the array while any update is pending, as it
88b496c2 517 * might container a change (such as a spare assignment) which
0c4f6e37
N
518 * could affect our decisions.
519 */
88b496c2 520 if (a->check_degraded && !frozen &&
0c4f6e37 521 update_queue == NULL && update_queue_pending == NULL) {
6c3fb95c 522 struct metadata_update *updates = NULL;
071cfc42 523 struct mdinfo *newdev = NULL;
6c3fb95c 524 struct active_array *newa;
071cfc42 525 struct mdinfo *d;
3c00ffbe 526
6c3fb95c
NB
527 a->check_degraded = 0;
528
529 /* The array may not be degraded, this is just a good time
530 * to check.
531 */
4e2c1a9a 532 newdev = container->ss->activate_spare(a, &updates);
071cfc42
DW
533 if (!newdev)
534 return;
535
536 newa = duplicate_aa(a);
537 if (!newa)
538 goto out;
1d446d52
DW
539 /* prevent the kernel from activating the disk(s) before we
540 * finish adding them
541 */
1ade5cc1 542 dprintf("freezing %s\n", a->info.sys_name);
1d446d52 543 sysfs_set_str(&a->info, NULL, "sync_action", "frozen");
071cfc42
DW
544
545 /* Add device to array and set offset/size/slot.
546 * and open files for each newdev */
547 for (d = newdev; d ; d = d->next) {
548 struct mdinfo *newd;
549
503975b9 550 newd = xmalloc(sizeof(*newd));
2904b26f 551 if (sysfs_add_disk(&newa->info, d, 0) < 0) {
071cfc42
DW
552 free(newd);
553 continue;
6c3fb95c 554 }
63b4aae3 555 disk_init_and_add(newd, d, newa);
071cfc42
DW
556 }
557 queue_metadata_update(updates);
558 updates = NULL;
6ca1e6ec
MW
559 while (update_queue_pending || update_queue) {
560 check_update_queue(container);
561 usleep(15*1000);
562 }
4e2c1a9a 563 replace_array(container, a, newa);
6ca1e6ec
MW
564 if (sysfs_set_str(&a->info, NULL, "sync_action", "recover")
565 == 0)
566 newa->prev_action = recover;
1ade5cc1 567 dprintf("recovery started on %s\n", a->info.sys_name);
071cfc42
DW
568 out:
569 while (newdev) {
570 d = newdev->next;
571 free(newdev);
572 newdev = d;
6c3fb95c 573 }
071cfc42 574 free_updates(&updates);
6c3fb95c 575 }
0f99b4bd
N
576
577 if (a->check_reshape) {
578 /* mdadm might have added some devices to the array.
579 * We want to disk_init_and_add any such device to a
580 * duplicate_aa and replace a with that.
581 * mdstat doesn't have enough info so we sysfs_read
582 * and look for new stuff.
583 */
584 struct mdinfo *info, *d, *d2, *newd;
aad6f216 585 unsigned long long array_size;
0f99b4bd
N
586 struct active_array *newa = NULL;
587 a->check_reshape = 0;
4dd2df09 588 info = sysfs_read(-1, mdstat->devnm,
0f99b4bd
N
589 GET_DEVS|GET_OFFSET|GET_SIZE|GET_STATE);
590 if (!info)
591 goto out2;
592 for (d = info->devs; d; d = d->next) {
593 if (d->disk.raid_disk < 0)
594 continue;
595 for (d2 = a->info.devs; d2; d2 = d2->next)
596 if (d2->disk.raid_disk ==
597 d->disk.raid_disk)
598 break;
599 if (d2)
600 /* already have this one */
601 continue;
602 if (!newa) {
603 newa = duplicate_aa(a);
604 if (!newa)
605 break;
606 }
503975b9 607 newd = xmalloc(sizeof(*newd));
0f99b4bd
N
608 disk_init_and_add(newd, d, newa);
609 }
aad6f216 610 if (sysfs_get_ll(info, NULL, "array_size", &array_size) == 0
02eedb57 611 && a->info.custom_array_size > array_size*2) {
aad6f216 612 sysfs_set_num(info, NULL, "array_size",
02eedb57 613 a->info.custom_array_size/2);
aad6f216 614 }
0f99b4bd
N
615 out2:
616 sysfs_free(info);
617 if (newa)
4e2c1a9a 618 replace_array(container, a, newa);
0f99b4bd 619 }
549e9569
NB
620}
621
836759d5
DW
622static int aa_ready(struct active_array *aa)
623{
624 struct mdinfo *d;
625 int level = aa->info.array.level;
626
627 for (d = aa->info.devs; d; d = d->next)
628 if (d->state_fd < 0)
629 return 0;
630
631 if (aa->info.state_fd < 0)
632 return 0;
633
634 if (level > 0 && (aa->action_fd < 0 || aa->resync_start_fd < 0))
635 return 0;
636
637 if (!aa->container)
638 return 0;
639
640 return 1;
641}
642
549e9569 643static void manage_new(struct mdstat_ent *mdstat,
2a0bb19e
DW
644 struct supertype *container,
645 struct active_array *victim)
549e9569
NB
646{
647 /* A new array has appeared in this container.
648 * Hopefully it is already recorded in the metadata.
649 * Check, then create the new array to report it to
650 * the monitor.
651 */
652
653 struct active_array *new;
654 struct mdinfo *mdi, *di;
cba0191b 655 char *inst;
549e9569 656 int i;
f1d26766 657 int failed = 0;
138477db 658 char buf[40];
549e9569 659
836759d5 660 /* check if array is ready to be monitored */
7023e0b8
N
661 if (!mdstat->active || !mdstat->level)
662 return;
663 if (strcmp(mdstat->level, "raid0") == 0 ||
664 strcmp(mdstat->level, "linear") == 0)
836759d5
DW
665 return;
666
4dd2df09 667 mdi = sysfs_read(-1, mdstat->devnm,
836759d5 668 GET_LEVEL|GET_CHUNK|GET_DISKS|GET_COMPONENT|
2ef21963 669 GET_DEGRADED|GET_SAFEMODE|
0c5d6054 670 GET_DEVS|GET_OFFSET|GET_SIZE|GET_STATE|GET_LAYOUT);
836759d5 671
503975b9 672 if (!mdi)
836759d5 673 return;
503975b9 674 new = xcalloc(1, sizeof(*new));
d52690ac 675
4dd2df09 676 strcpy(new->info.sys_name, mdstat->devnm);
549e9569
NB
677
678 new->prev_state = new->curr_state = new->next_state = inactive;
679 new->prev_action= new->curr_action= new->next_action= idle;
680
681 new->container = container;
682
4dd2df09 683 inst = to_subarray(mdstat, container->devnm);
549e9569 684
549e9569 685 new->info.array = mdi->array;
272bcc48 686 new->info.component_size = mdi->component_size;
549e9569
NB
687
688 for (i = 0; i < new->info.array.raid_disks; i++) {
503975b9 689 struct mdinfo *newd = xmalloc(sizeof(*newd));
549e9569
NB
690
691 for (di = mdi->devs; di; di = di->next)
692 if (i == di->disk.raid_disk)
693 break;
694
63b4aae3 695 if (disk_init_and_add(newd, di, new) != 0) {
7da80e6f
DW
696 if (newd)
697 free(newd);
698
f1d26766 699 failed++;
7da80e6f
DW
700 if (failed > new->info.array.failed_disks) {
701 /* we cannot properly monitor without all working disks */
702 new->container = NULL;
703 break;
704 }
549e9569 705 }
549e9569 706 }
836759d5 707
da5a36fa
N
708 new->action_fd = sysfs_open2(new->info.sys_name, NULL, "sync_action");
709 new->info.state_fd = sysfs_open2(new->info.sys_name, NULL, "array_state");
710 new->resync_start_fd = sysfs_open2(new->info.sys_name, NULL, "resync_start");
711 new->metadata_fd = sysfs_open2(new->info.sys_name, NULL, "metadata_version");
712 new->sync_completed_fd = sysfs_open2(new->info.sys_name, NULL, "sync_completed");
713
1ade5cc1 714 dprintf("inst: %s action: %d state: %d\n", inst,
4e6e574a 715 new->action_fd, new->info.state_fd);
549e9569 716
2ef21963
N
717 if (sigterm)
718 new->info.safe_mode_delay = 1;
719 else if (mdi->safe_mode_delay >= 50)
720 /* Normal start, mdadm set this. */
721 new->info.safe_mode_delay = mdi->safe_mode_delay;
722 else
723 /* Restart, just pick a number */
724 new->info.safe_mode_delay = 5000;
725 sysfs_set_safemode(&new->info, new->info.safe_mode_delay);
726
138477db
AK
727 /* reshape_position is set by mdadm in sysfs
728 * read this information for new arrays only (empty victim)
729 */
730 if ((victim == NULL) &&
731 (sysfs_get_str(mdi, NULL, "sync_action", buf, 40) > 0) &&
732 (strncmp(buf, "reshape", 7) == 0)) {
733 if (sysfs_get_ll(mdi, NULL, "reshape_position",
734 &new->last_checkpoint) != 0)
735 new->last_checkpoint = 0;
0d51bfa2
AK
736 else {
737 int data_disks = mdi->array.raid_disks;
738 if (mdi->array.level == 4 || mdi->array.level == 5)
739 data_disks--;
740 if (mdi->array.level == 6)
741 data_disks -= 2;
742
743 new->last_checkpoint /= data_disks;
744 }
138477db
AK
745 dprintf("mdmon: New monitored array is under reshape.\n"
746 " Last checkpoint is: %llu\n",
747 new->last_checkpoint);
748 }
749
4fa5aef9 750 sysfs_free(mdi);
836759d5
DW
751
752 /* if everything checks out tell the metadata handler we want to
753 * manage this instance
754 */
755 if (!aa_ready(new) || container->ss->open_new(container, new, inst) < 0) {
a88e119f 756 pr_err("failed to monitor %s\n",
836759d5 757 mdstat->metadata_version);
549e9569 758 new->container = NULL;
836759d5 759 free_aa(new);
93f7caca 760 } else {
2a0bb19e 761 replace_array(container, victim, new);
93f7caca
DW
762 if (failed) {
763 new->check_degraded = 1;
764 manage_member(mdstat, new);
765 }
766 }
549e9569
NB
767}
768
5d19760d 769void manage(struct mdstat_ent *mdstat, struct supertype *container)
549e9569
NB
770{
771 /* We have just read mdstat and need to compare it with
772 * the known active arrays.
773 * Arrays with the wrong metadata are ignored.
774 */
775
776 for ( ; mdstat ; mdstat = mdstat->next) {
777 struct active_array *a;
4dd2df09 778 if (strcmp(mdstat->devnm, container->devnm) == 0) {
549e9569
NB
779 manage_container(mdstat, container);
780 continue;
781 }
4dd2df09 782 if (!is_container_member(mdstat, container->devnm))
549e9569
NB
783 /* Not for this array */
784 continue;
785 /* Looks like a member of this container */
5d19760d 786 for (a = container->arrays; a; a = a->next) {
4dd2df09 787 if (strcmp(mdstat->devnm, a->info.sys_name) == 0) {
ba714450 788 if (a->container && a->to_remove == 0)
549e9569
NB
789 manage_member(mdstat, a);
790 break;
791 }
792 }
2a0bb19e
DW
793 if (a == NULL || !a->container)
794 manage_new(mdstat, container, a);
549e9569
NB
795 }
796}
797
edd8d13c 798static void handle_message(struct supertype *container, struct metadata_update *msg)
3e70c845 799{
edd8d13c
NB
800 /* queue this metadata update through to the monitor */
801
802 struct metadata_update *mu;
803
313a4a82 804 if (msg->len <= 0)
3c00ffbe
N
805 while (update_queue_pending || update_queue) {
806 check_update_queue(container);
807 usleep(15*1000);
808 }
809
313a4a82
DW
810 if (msg->len == 0) { /* ping_monitor */
811 int cnt;
1011e834 812
3c00ffbe 813 cnt = monitor_loop_cnt;
1eb252b8
N
814 if (cnt & 1)
815 cnt += 2; /* wait until next pselect */
816 else
817 cnt += 3; /* wait for 2 pselects */
818 wakeup_monitor();
3c00ffbe 819
1eb252b8
N
820 while (monitor_loop_cnt - cnt < 0)
821 usleep(10 * 1000);
313a4a82
DW
822 } else if (msg->len == -1) { /* ping_manager */
823 struct mdstat_ent *mdstat = mdstat_read(1, 0);
824
825 manage(mdstat, container);
826 free_mdstat(mdstat);
6144ed44 827 } else if (!sigterm) {
503975b9 828 mu = xmalloc(sizeof(*mu));
edd8d13c
NB
829 mu->len = msg->len;
830 mu->buf = msg->buf;
831 msg->buf = NULL;
832 mu->space = NULL;
cb23f1f4 833 mu->space_list = NULL;
edd8d13c
NB
834 mu->next = NULL;
835 if (container->ss->prepare_update)
5fe6f031
N
836 if (!container->ss->prepare_update(container, mu))
837 free_updates(&mu);
edd8d13c
NB
838 queue_metadata_update(mu);
839 }
3e70c845
DW
840}
841
842void read_sock(struct supertype *container)
549e9569
NB
843{
844 int fd;
bfa44e2e 845 struct metadata_update msg;
b109d928
DW
846 int terminate = 0;
847 long fl;
848 int tmo = 3; /* 3 second timeout before hanging up the socket */
549e9569 849
3e70c845 850 fd = accept(container->sock, NULL, NULL);
549e9569
NB
851 if (fd < 0)
852 return;
b109d928
DW
853
854 fl = fcntl(fd, F_GETFL, 0);
855 fl |= O_NONBLOCK;
856 fcntl(fd, F_SETFL, fl);
857
858 do {
859 msg.buf = NULL;
860
861 /* read and validate the message */
862 if (receive_message(fd, &msg, tmo) == 0) {
bfa44e2e 863 handle_message(container, &msg);
bc77ed53
DW
864 if (msg.len == 0) {
865 /* ping reply with version */
866 msg.buf = Version;
867 msg.len = strlen(Version) + 1;
868 if (send_message(fd, &msg, tmo) < 0)
869 terminate = 1;
870 } else if (ack(fd, tmo) < 0)
bfa44e2e
NB
871 terminate = 1;
872 } else
b109d928 873 terminate = 1;
b109d928 874
b109d928
DW
875 } while (!terminate);
876
549e9569
NB
877 close(fd);
878}
1ed3f387 879
e0d6609f
NB
880int exit_now = 0;
881int manager_ready = 0;
549e9569
NB
882void do_manager(struct supertype *container)
883{
884 struct mdstat_ent *mdstat;
4d43913c 885 sigset_t set;
1ed3f387 886
4d43913c
NB
887 sigprocmask(SIG_UNBLOCK, NULL, &set);
888 sigdelset(&set, SIGUSR1);
6144ed44 889 sigdelset(&set, SIGTERM);
549e9569
NB
890
891 do {
1ed3f387 892
e0d6609f
NB
893 if (exit_now)
894 exit(0);
895
3c00ffbe
N
896 /* Can only 'manage' things if 'monitor' is not making
897 * structural changes to metadata, so need to check
898 * update_queue
899 */
900 if (update_queue == NULL) {
901 mdstat = mdstat_read(1, 0);
549e9569 902
3c00ffbe 903 manage(mdstat, container);
549e9569 904
3c00ffbe 905 read_sock(container);
4fa5aef9 906
3c00ffbe
N
907 free_mdstat(mdstat);
908 }
1ed3f387
NB
909 remove_old();
910
2e735d19
NB
911 check_update_queue(container);
912
e0d6609f 913 manager_ready = 1;
4d43913c 914
6144ed44
DW
915 if (sigterm)
916 wakeup_monitor();
917
5d4d1b26 918 if (update_queue == NULL)
58a4ba2a 919 mdstat_wait_fd(container->sock, &set);
5d4d1b26 920 else
3c00ffbe
N
921 /* If an update is happening, just wait for signal */
922 pselect(0, NULL, NULL, NULL, NULL, &set);
549e9569
NB
923 } while(1);
924}