]>
git.ipfire.org Git - thirdparty/mdadm.git/blob - managemon.c
2 * mdmon - monitor external metadata arrays
4 * Copyright (C) 2007-2009 Neil Brown <neilb@suse.de>
5 * Copyright (C) 2007-2009 Intel Corporation
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.
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
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.
22 * The management thread for monitoring active md arrays.
23 * This thread does things which might block such as memory
27 * - Find out about new arrays in this container.
28 * Allocate the data structures and open the files.
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.
35 * - Respond to reshape requests by allocating new data structures
36 * and opening new files.
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.
45 * - When a device is added to the container, we add it to the metadata
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.
53 * Check if number of failed devices suggests recovery is needed, and
55 * Ask metadata to allocate a spare device
56 * Add device as not in_sync and give a role
58 * Open sysfs files and pass to monitor.
59 * Make sure that monitor Starts recovery....
61 * - Pass on metadata updates from external programs such as
62 * mdadm creating a new array.
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.
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.
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.
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.
93 * - Watch for spares to be added to the container, and write updated
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
107 #include <sys/syscall.h>
108 #include <sys/socket.h>
110 static void close_aa(struct active_array
*aa
)
114 for (d
= aa
->info
.devs
; d
; d
= d
->next
) {
115 close(d
->recovery_fd
);
121 if (aa
->action_fd
>= 0)
122 close(aa
->action_fd
);
123 if (aa
->info
.state_fd
>= 0)
124 close(aa
->info
.state_fd
);
125 if (aa
->resync_start_fd
>= 0)
126 close(aa
->resync_start_fd
);
127 if (aa
->metadata_fd
>= 0)
128 close(aa
->metadata_fd
);
129 if (aa
->sync_completed_fd
>= 0)
130 close(aa
->sync_completed_fd
);
131 if (aa
->safe_mode_delay_fd
>= 0)
132 close(aa
->safe_mode_delay_fd
);
135 static void free_aa(struct active_array
*aa
)
137 /* Note that this doesn't close fds if they are being used
138 * by a clone. ->container will be set for a clone
140 dprintf("sys_name: %s\n", aa
->info
.sys_name
);
143 while (aa
->info
.devs
) {
144 struct mdinfo
*d
= aa
->info
.devs
;
145 aa
->info
.devs
= d
->next
;
151 static struct active_array
*duplicate_aa(struct active_array
*aa
)
153 struct active_array
*newa
= xmalloc(sizeof(*newa
));
154 struct mdinfo
**dp1
, **dp2
;
158 newa
->replaces
= NULL
;
159 newa
->info
.next
= NULL
;
161 dp2
= &newa
->info
.devs
;
163 for (dp1
= &aa
->info
.devs
; *dp1
; dp1
= &(*dp1
)->next
) {
165 if ((*dp1
)->state_fd
< 0)
168 d
= xmalloc(sizeof(*d
));
178 static void wakeup_monitor(void)
180 /* tgkill(getpid(), mon_tid, SIGUSR1); */
182 syscall(SYS_tgkill
, pid
, mon_tid
, SIGUSR1
);
185 static void remove_old(void)
188 discard_this
->next
= NULL
;
189 free_aa(discard_this
);
190 if (pending_discard
== discard_this
)
191 pending_discard
= NULL
;
197 static void replace_array(struct supertype
*container
,
198 struct active_array
*old
,
199 struct active_array
*new)
201 /* To replace an array, we add it to the top of the list
202 * marked with ->replaces to point to the original.
203 * 'monitor' will take the original out of the list
204 * and put it on 'discard_this'. We take it from there
208 while (pending_discard
) {
209 while (discard_this
== NULL
)
213 pending_discard
= old
;
215 new->next
= container
->arrays
;
216 container
->arrays
= new;
220 struct metadata_update
*update_queue
= NULL
;
221 struct metadata_update
*update_queue_handled
= NULL
;
222 struct metadata_update
*update_queue_pending
= NULL
;
224 static void free_updates(struct metadata_update
**update
)
227 struct metadata_update
*this = *update
;
228 void **space_list
= this->space_list
;
230 *update
= this->next
;
234 void *space
= space_list
;
235 space_list
= *space_list
;
242 void check_update_queue(struct supertype
*container
)
244 free_updates(&update_queue_handled
);
246 if (update_queue
== NULL
&&
247 update_queue_pending
) {
248 update_queue
= update_queue_pending
;
249 update_queue_pending
= NULL
;
254 static void queue_metadata_update(struct metadata_update
*mu
)
256 struct metadata_update
**qp
;
258 qp
= &update_queue_pending
;
260 qp
= & ((*qp
)->next
);
264 static void add_disk_to_container(struct supertype
*st
, struct mdinfo
*sd
)
268 struct metadata_update
*update
= NULL
;
269 mdu_disk_info_t dk
= {
271 .major
= sd
->disk
.major
,
272 .minor
= sd
->disk
.minor
,
277 dprintf("add %d:%d to container\n", sd
->disk
.major
, sd
->disk
.minor
);
282 sprintf(nm
, "%d:%d", sd
->disk
.major
, sd
->disk
.minor
);
283 dfd
= dev_open(nm
, O_RDWR
);
287 st
->update_tail
= &update
;
288 st
->ss
->add_to_super(st
, &dk
, dfd
, NULL
, INVALID_SECTORS
);
289 st
->ss
->write_init_super(st
);
290 queue_metadata_update(update
);
291 st
->update_tail
= NULL
;
295 * Create and queue update structure about the removed disks.
296 * The update is prepared by super type handler and passed to the monitor
299 static void remove_disk_from_container(struct supertype
*st
, struct mdinfo
*sd
)
301 struct metadata_update
*update
= NULL
;
302 mdu_disk_info_t dk
= {
304 .major
= sd
->disk
.major
,
305 .minor
= sd
->disk
.minor
,
309 dprintf("remove %d:%d from container\n",
310 sd
->disk
.major
, sd
->disk
.minor
);
312 st
->update_tail
= &update
;
313 st
->ss
->remove_from_super(st
, &dk
);
314 /* FIXME this write_init_super shouldn't be here.
315 * We have it after add_to_super to write to new device,
316 * but with 'remove' we don't ant to write to that device!
318 st
->ss
->write_init_super(st
);
319 queue_metadata_update(update
);
320 st
->update_tail
= NULL
;
323 static void manage_container(struct mdstat_ent
*mdstat
,
324 struct supertype
*container
)
326 /* Of interest here are:
327 * - if a new device has been added to the container, we
328 * add it to the array ignoring any metadata on it.
329 * - if a device has been removed from the container, we
330 * remove it from the device list and update the metadata.
331 * FIXME should we look for compatible metadata and take hints
332 * about spare assignment.... probably not.
334 if (mdstat
->devcnt
!= container
->devcnt
) {
335 struct mdinfo
**cdp
, *cd
, *di
, *mdi
;
338 /* read /sys/block/NAME/md/dev-??/block/dev to find out
339 * what is there, and compare with container->info.devs
340 * To see what is removed and what is added.
341 * These need to be remove from, or added to, the array
343 mdi
= sysfs_read(-1, mdstat
->devnm
, GET_DEVS
);
345 /* invalidate the current count so we can try again */
346 container
->devcnt
= -1;
350 /* check for removals */
351 for (cdp
= &container
->devs
; *cdp
; ) {
353 for (di
= mdi
->devs
; di
; di
= di
->next
)
354 if (di
->disk
.major
== (*cdp
)->disk
.major
&&
355 di
->disk
.minor
== (*cdp
)->disk
.minor
) {
362 remove_disk_from_container(container
, cd
);
368 /* check for additions */
369 for (di
= mdi
->devs
; di
; di
= di
->next
) {
370 for (cd
= container
->devs
; cd
; cd
= cd
->next
)
371 if (di
->disk
.major
== cd
->disk
.major
&&
372 di
->disk
.minor
== cd
->disk
.minor
)
375 struct mdinfo
*newd
= xmalloc(sizeof(*newd
));
378 add_disk_to_container(container
, newd
);
382 container
->devcnt
= mdstat
->devcnt
;
386 static int sysfs_open2(char *devnum
, char *name
, char *attr
)
388 int fd
= sysfs_open(devnum
, name
, attr
);
390 /* seq_file in the kernel allocates buffer space
391 * on the first read. Do that now so 'monitor'
395 if (read(fd
, buf
, sizeof(buf
)) < 0)
396 /* pretend not to ignore return value */
402 static int disk_init_and_add(struct mdinfo
*disk
, struct mdinfo
*clone
,
403 struct active_array
*aa
)
409 disk
->recovery_fd
= sysfs_open2(aa
->info
.sys_name
, disk
->sys_name
,
411 if (disk
->recovery_fd
< 0)
413 disk
->state_fd
= sysfs_open2(aa
->info
.sys_name
, disk
->sys_name
, "state");
414 if (disk
->state_fd
< 0) {
415 close(disk
->recovery_fd
);
418 disk
->bb_fd
= sysfs_open2(aa
->info
.sys_name
, disk
->sys_name
,
420 if (disk
->bb_fd
< 0) {
421 close(disk
->recovery_fd
);
422 close(disk
->state_fd
);
425 disk
->ubb_fd
= sysfs_open2(aa
->info
.sys_name
, disk
->sys_name
,
426 "unacknowledged_bad_blocks");
427 if (disk
->ubb_fd
< 0) {
428 close(disk
->recovery_fd
);
429 close(disk
->state_fd
);
433 disk
->prev_state
= read_dev_state(disk
->state_fd
);
434 disk
->curr_state
= disk
->prev_state
;
435 disk
->next
= aa
->info
.devs
;
436 aa
->info
.devs
= disk
;
441 static void manage_member(struct mdstat_ent
*mdstat
,
442 struct active_array
*a
)
444 /* Compare mdstat info with known state of member array.
445 * We do not need to look for device state changes here, that
446 * is dealt with by the monitor.
448 * If a reshape is being requested, monitor will have noticed
449 * that sync_action changed and will have set check_reshape.
450 * We just need to see if new devices have appeared. All metadata
451 * updates will already have been processed.
453 * We also want to handle degraded arrays here by
454 * trying to find and assign a spare.
455 * We do that whenever the monitor tells us too.
459 struct supertype
*container
= a
->container
;
462 if (container
== NULL
)
463 /* Raced with something */
466 if (mdstat
->active
) {
468 a
->info
.array
.raid_disks
= mdstat
->raid_disks
;
472 mdi
= sysfs_read(-1, mdstat
->devnm
,
473 GET_COMPONENT
|GET_CONSISTENCY_POLICY
);
475 a
->info
.component_size
= mdi
->component_size
;
476 a
->info
.consistency_policy
= mdi
->consistency_policy
;
481 if (sysfs_get_str(&a
->info
, NULL
, "metadata_version", buf
, sizeof(buf
)) > 0)
482 frozen
= buf
[9] == '-';
484 frozen
= 1; /* can't read metadata_version assume the worst */
486 /* If sync_action is not 'idle' then don't try recovery now */
488 sysfs_get_str(&a
->info
, NULL
, "sync_action",
489 buf
, sizeof(buf
)) > 0 && strncmp(buf
, "idle", 4) != 0)
493 int level
= map_name(pers
, mdstat
->level
);
494 if (level
== 0 || level
== LEVEL_LINEAR
) {
499 else if (a
->info
.array
.level
!= level
&& level
> 0) {
500 struct active_array
*newa
= duplicate_aa(a
);
502 newa
->info
.array
.level
= level
;
503 replace_array(container
, a
, newa
);
509 /* we are after monitor kick,
510 * so container field can be cleared - check it again
512 if (a
->container
== NULL
)
515 if (sigterm
&& a
->info
.safe_mode_delay
!= 1 &&
516 a
->safe_mode_delay_fd
>= 0) {
517 long int new_delay
= 1;
521 len
= snprintf(delay
, sizeof(delay
), "0.%03ld\n", new_delay
);
522 if (write(a
->safe_mode_delay_fd
, delay
, len
) == len
)
523 a
->info
.safe_mode_delay
= new_delay
;
526 /* We don't check the array while any update is pending, as it
527 * might container a change (such as a spare assignment) which
528 * could affect our decisions.
530 if (a
->check_degraded
&& !frozen
&&
531 update_queue
== NULL
&& update_queue_pending
== NULL
) {
532 struct metadata_update
*updates
= NULL
;
533 struct mdinfo
*newdev
= NULL
;
534 struct active_array
*newa
;
537 a
->check_degraded
= 0;
539 /* The array may not be degraded, this is just a good time
542 newdev
= container
->ss
->activate_spare(a
, &updates
);
546 newa
= duplicate_aa(a
);
549 /* prevent the kernel from activating the disk(s) before we
552 dprintf("freezing %s\n", a
->info
.sys_name
);
553 sysfs_set_str(&a
->info
, NULL
, "sync_action", "frozen");
555 /* Add device to array and set offset/size/slot.
556 * and open files for each newdev */
557 for (d
= newdev
; d
; d
= d
->next
) {
560 newd
= xmalloc(sizeof(*newd
));
561 if (sysfs_add_disk(&newa
->info
, d
, 0) < 0) {
565 disk_init_and_add(newd
, d
, newa
);
567 queue_metadata_update(updates
);
569 while (update_queue_pending
|| update_queue
) {
570 check_update_queue(container
);
573 replace_array(container
, a
, newa
);
574 if (sysfs_set_str(&a
->info
, NULL
,
575 "sync_action", "recover") == 0)
576 newa
->prev_action
= recover
;
577 dprintf("recovery started on %s\n", a
->info
.sys_name
);
584 free_updates(&updates
);
587 if (a
->check_reshape
) {
588 /* mdadm might have added some devices to the array.
589 * We want to disk_init_and_add any such device to a
590 * duplicate_aa and replace a with that.
591 * mdstat doesn't have enough info so we sysfs_read
592 * and look for new stuff.
594 struct mdinfo
*info
, *d
, *d2
, *newd
;
595 unsigned long long array_size
;
596 struct active_array
*newa
= NULL
;
597 a
->check_reshape
= 0;
598 info
= sysfs_read(-1, mdstat
->devnm
,
599 GET_DEVS
|GET_OFFSET
|GET_SIZE
|GET_STATE
);
602 for (d
= info
->devs
; d
; d
= d
->next
) {
603 if (d
->disk
.raid_disk
< 0)
605 for (d2
= a
->info
.devs
; d2
; d2
= d2
->next
)
606 if (d2
->disk
.raid_disk
==
610 /* already have this one */
613 newa
= duplicate_aa(a
);
617 newd
= xmalloc(sizeof(*newd
));
618 disk_init_and_add(newd
, d
, newa
);
620 if (sysfs_get_ll(info
, NULL
, "array_size", &array_size
) == 0 &&
621 a
->info
.custom_array_size
> array_size
*2) {
622 sysfs_set_num(info
, NULL
, "array_size",
623 a
->info
.custom_array_size
/2);
628 replace_array(container
, a
, newa
);
632 static int aa_ready(struct active_array
*aa
)
635 int level
= aa
->info
.array
.level
;
637 for (d
= aa
->info
.devs
; d
; d
= d
->next
)
641 if (aa
->info
.state_fd
< 0)
644 if (level
> 0 && (aa
->action_fd
< 0 || aa
->resync_start_fd
< 0))
653 static void manage_new(struct mdstat_ent
*mdstat
,
654 struct supertype
*container
,
655 struct active_array
*victim
)
657 /* A new array has appeared in this container.
658 * Hopefully it is already recorded in the metadata.
659 * Check, then create the new array to report it to
663 struct active_array
*new = NULL
;
664 struct mdinfo
*mdi
= NULL
, *di
;
669 /* check if array is ready to be monitored */
670 if (!mdstat
->active
|| !mdstat
->level
)
672 if (strncmp(mdstat
->level
, "raid0", strlen("raid0")) == 0 ||
673 strncmp(mdstat
->level
, "linear", strlen("linear")) == 0)
676 mdi
= sysfs_read(-1, mdstat
->devnm
,
677 GET_LEVEL
|GET_CHUNK
|GET_DISKS
|GET_COMPONENT
|
678 GET_SAFEMODE
|GET_DEVS
|GET_OFFSET
|GET_SIZE
|GET_STATE
|
679 GET_LAYOUT
|GET_DEVS_ALL
);
683 new = xcalloc(1, sizeof(*new));
685 strcpy(new->info
.sys_name
, mdstat
->devnm
);
687 new->prev_state
= new->curr_state
= new->next_state
= inactive
;
688 new->prev_action
= new->curr_action
= new->next_action
= idle
;
690 new->container
= container
;
692 if (parse_num(&inst
, to_subarray(mdstat
, container
->devnm
)) != 0)
695 new->info
.array
= mdi
->array
;
696 new->info
.component_size
= mdi
->component_size
;
698 for (i
= 0; i
< new->info
.array
.raid_disks
; i
++) {
699 struct mdinfo
*newd
= xmalloc(sizeof(*newd
));
701 for (di
= mdi
->devs
; di
; di
= di
->next
)
702 if (i
== di
->disk
.raid_disk
)
705 if (disk_init_and_add(newd
, di
, new) != 0) {
710 if (failed
> new->info
.array
.failed_disks
) {
711 /* we cannot properly monitor without all working disks */
712 new->container
= NULL
;
718 new->action_fd
= sysfs_open2(new->info
.sys_name
, NULL
, "sync_action");
719 new->info
.state_fd
= sysfs_open2(new->info
.sys_name
, NULL
, "array_state");
720 new->resync_start_fd
= sysfs_open2(new->info
.sys_name
, NULL
, "resync_start");
721 new->metadata_fd
= sysfs_open2(new->info
.sys_name
, NULL
, "metadata_version");
722 new->sync_completed_fd
= sysfs_open2(new->info
.sys_name
, NULL
, "sync_completed");
723 new->safe_mode_delay_fd
= sysfs_open2(new->info
.sys_name
, NULL
,
726 dprintf("inst: %d action: %d state: %d\n", inst
,
727 new->action_fd
, new->info
.state_fd
);
729 if (mdi
->safe_mode_delay
>= 50)
730 /* Normal start, mdadm set this. */
731 new->info
.safe_mode_delay
= mdi
->safe_mode_delay
;
733 /* Restart, just pick a number */
734 new->info
.safe_mode_delay
= 5000;
735 sysfs_set_safemode(&new->info
, new->info
.safe_mode_delay
);
737 /* reshape_position is set by mdadm in sysfs
738 * read this information for new arrays only (empty victim)
740 if ((victim
== NULL
) &&
741 (sysfs_get_str(mdi
, NULL
, "sync_action", buf
, 40) > 0) &&
742 (strncmp(buf
, "reshape", 7) == 0)) {
743 if (sysfs_get_ll(mdi
, NULL
, "reshape_position",
744 &new->last_checkpoint
) != 0)
745 new->last_checkpoint
= 0;
747 int data_disks
= mdi
->array
.raid_disks
;
748 if (mdi
->array
.level
== 4 || mdi
->array
.level
== 5)
750 if (mdi
->array
.level
== 6)
753 new->last_checkpoint
/= data_disks
;
755 dprintf("mdmon: New monitored array is under reshape.\n"
756 " Last checkpoint is: %llu\n",
757 new->last_checkpoint
);
763 /* if everything checks out tell the metadata handler we want to
764 * manage this instance
766 if (!aa_ready(new) || container
->ss
->open_new(container
, new, inst
) < 0) {
769 replace_array(container
, victim
, new);
771 new->check_degraded
= 1;
772 manage_member(mdstat
, new);
778 pr_err("failed to monitor %s\n", mdstat
->metadata_version
);
780 new->container
= NULL
;
787 void manage(struct mdstat_ent
*mdstat
, struct supertype
*container
)
789 /* We have just read mdstat and need to compare it with
790 * the known active arrays.
791 * Arrays with the wrong metadata are ignored.
794 for ( ; mdstat
; mdstat
= mdstat
->next
) {
795 struct active_array
*a
;
796 if (strcmp(mdstat
->devnm
, container
->devnm
) == 0) {
797 manage_container(mdstat
, container
);
800 if (!is_container_member(mdstat
, container
->devnm
))
801 /* Not for this array */
803 /* Looks like a member of this container */
804 for (a
= container
->arrays
; a
; a
= a
->next
) {
805 if (strcmp(mdstat
->devnm
, a
->info
.sys_name
) == 0) {
806 if (a
->container
&& a
->to_remove
== 0)
807 manage_member(mdstat
, a
);
811 if ((a
== NULL
|| !a
->container
) && !sigterm
)
812 manage_new(mdstat
, container
, a
);
816 static void handle_message(struct supertype
*container
, struct metadata_update
*msg
)
818 /* queue this metadata update through to the monitor */
820 struct metadata_update
*mu
;
823 while (update_queue_pending
|| update_queue
) {
824 check_update_queue(container
);
828 if (msg
->len
== 0) { /* ping_monitor */
831 cnt
= monitor_loop_cnt
;
833 cnt
+= 2; /* wait until next pselect */
835 cnt
+= 3; /* wait for 2 pselects */
838 while (monitor_loop_cnt
- cnt
< 0)
840 } else if (msg
->len
== -1) { /* ping_manager */
841 struct mdstat_ent
*mdstat
= mdstat_read(1, 0);
843 manage(mdstat
, container
);
845 } else if (!sigterm
) {
846 mu
= xmalloc(sizeof(*mu
));
851 mu
->space_list
= NULL
;
853 if (container
->ss
->prepare_update
)
854 if (!container
->ss
->prepare_update(container
, mu
))
856 queue_metadata_update(mu
);
860 void read_sock(struct supertype
*container
)
863 struct metadata_update msg
;
866 int tmo
= 3; /* 3 second timeout before hanging up the socket */
868 fd
= accept(container
->sock
, NULL
, NULL
);
872 fl
= fcntl(fd
, F_GETFL
, 0);
874 fcntl(fd
, F_SETFL
, fl
);
879 /* read and validate the message */
880 if (receive_message(fd
, &msg
, tmo
) == 0) {
881 handle_message(container
, &msg
);
883 /* ping reply with version */
885 msg
.len
= strlen(Version
) + 1;
886 if (send_message(fd
, &msg
, tmo
) < 0)
888 } else if (ack(fd
, tmo
) < 0)
893 } while (!terminate
);
899 int manager_ready
= 0;
900 void do_manager(struct supertype
*container
)
902 struct mdstat_ent
*mdstat
;
905 sigprocmask(SIG_UNBLOCK
, NULL
, &set
);
906 sigdelset(&set
, SIGUSR1
);
907 sigdelset(&set
, SIGTERM
);
914 /* Can only 'manage' things if 'monitor' is not making
915 * structural changes to metadata, so need to check
918 if (update_queue
== NULL
) {
919 mdstat
= mdstat_read(1, 0);
921 manage(mdstat
, container
);
923 read_sock(container
);
929 check_update_queue(container
);
936 if (update_queue
== NULL
)
937 mdstat_wait_fd(container
->sock
, &set
);
939 /* If an update is happening, just wait for signal */
940 pselect(0, NULL
, NULL
, NULL
, NULL
, &set
);