]>
git.ipfire.org Git - thirdparty/mdadm.git/blob - managemon.c
19effe44d5920fc19abdaa003f14dda2add06efd
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>
111 static void close_aa(struct active_array
*aa
)
115 for (d
= aa
->info
.devs
; d
; d
= d
->next
)
118 close(aa
->action_fd
);
119 close(aa
->info
.state_fd
);
120 close(aa
->resync_start_fd
);
123 static void free_aa(struct active_array
*aa
)
125 /* Note that this doesn't close fds if they are being used
126 * by a clone. ->container will be set for a clone
128 dprintf("%s: devnum: %d\n", __func__
, aa
->devnum
);
131 while (aa
->info
.devs
) {
132 struct mdinfo
*d
= aa
->info
.devs
;
133 aa
->info
.devs
= d
->next
;
139 static struct active_array
*duplicate_aa(struct active_array
*aa
)
141 struct active_array
*newa
= malloc(sizeof(*newa
));
142 struct mdinfo
**dp1
, **dp2
;
146 newa
->replaces
= NULL
;
147 newa
->info
.next
= NULL
;
149 dp2
= &newa
->info
.devs
;
151 for (dp1
= &aa
->info
.devs
; *dp1
; dp1
= &(*dp1
)->next
) {
153 if ((*dp1
)->state_fd
< 0)
156 d
= malloc(sizeof(*d
));
166 static void wakeup_monitor(void)
168 /* tgkill(getpid(), mon_tid, SIGUSR1); */
170 syscall(SYS_tgkill
, pid
, mon_tid
, SIGUSR1
);
173 static void remove_old(void)
176 discard_this
->next
= NULL
;
177 free_aa(discard_this
);
178 if (pending_discard
== discard_this
)
179 pending_discard
= NULL
;
185 static void replace_array(struct supertype
*container
,
186 struct active_array
*old
,
187 struct active_array
*new)
189 /* To replace an array, we add it to the top of the list
190 * marked with ->replaces to point to the original.
191 * 'monitor' will take the original out of the list
192 * and put it on 'discard_this'. We take it from there
196 while (pending_discard
) {
197 while (discard_this
== NULL
)
201 pending_discard
= old
;
203 new->next
= container
->arrays
;
204 container
->arrays
= new;
208 struct metadata_update
*update_queue
= NULL
;
209 struct metadata_update
*update_queue_handled
= NULL
;
210 struct metadata_update
*update_queue_pending
= NULL
;
212 static void free_updates(struct metadata_update
**update
)
215 struct metadata_update
*this = *update
;
217 *update
= this->next
;
224 void check_update_queue(struct supertype
*container
)
226 free_updates(&update_queue_handled
);
228 if (update_queue
== NULL
&&
229 update_queue_pending
) {
230 update_queue
= update_queue_pending
;
231 update_queue_pending
= NULL
;
236 static void queue_metadata_update(struct metadata_update
*mu
)
238 struct metadata_update
**qp
;
240 qp
= &update_queue_pending
;
242 qp
= & ((*qp
)->next
);
246 static void add_disk_to_container(struct supertype
*st
, struct mdinfo
*sd
)
250 struct supertype
*st2
;
251 struct metadata_update
*update
= NULL
;
253 mdu_disk_info_t dk
= {
255 .major
= sd
->disk
.major
,
256 .minor
= sd
->disk
.minor
,
261 dprintf("%s: add %d:%d to container\n",
262 __func__
, sd
->disk
.major
, sd
->disk
.minor
);
267 sprintf(nm
, "%d:%d", sd
->disk
.major
, sd
->disk
.minor
);
268 dfd
= dev_open(nm
, O_RDWR
);
272 /* Check the metadata and see if it is already part of this
276 if (st2
->ss
->load_super(st2
, dfd
, NULL
) == 0) {
277 st2
->ss
->getinfo_super(st
, &info
);
278 if (st
->ss
->compare_super(st
, st2
) == 0 &&
279 info
.disk
.raid_disk
>= 0) {
280 /* Looks like a good member of array.
282 * mdadm will incorporate any parts into
285 st2
->ss
->free_super(st2
);
289 st2
->ss
->free_super(st2
);
291 st
->update_tail
= &update
;
292 st
->ss
->add_to_super(st
, &dk
, dfd
, NULL
);
293 st
->ss
->write_init_super(st
);
294 queue_metadata_update(update
);
295 st
->update_tail
= NULL
;
298 static void manage_container(struct mdstat_ent
*mdstat
,
299 struct supertype
*container
)
301 /* The only thing of interest here is if a new device
302 * has been added to the container. We add it to the
303 * array ignoring any metadata on it.
304 * FIXME should we look for compatible metadata and take hints
305 * about spare assignment.... probably not.
307 if (mdstat
->devcnt
!= container
->devcnt
) {
308 struct mdinfo
**cdp
, *cd
, *di
, *mdi
;
311 /* read /sys/block/NAME/md/dev-??/block/dev to find out
312 * what is there, and compare with container->info.devs
313 * To see what is removed and what is added.
314 * These need to be remove from, or added to, the array
316 mdi
= sysfs_read(-1, mdstat
->devnum
, GET_DEVS
|SKIP_GONE_DEVS
);
318 /* invalidate the current count so we can try again */
319 container
->devcnt
= -1;
323 /* check for removals */
324 for (cdp
= &container
->devs
; *cdp
; ) {
326 for (di
= mdi
->devs
; di
; di
= di
->next
)
327 if (di
->disk
.major
== (*cdp
)->disk
.major
&&
328 di
->disk
.minor
== (*cdp
)->disk
.minor
) {
340 /* check for additions */
341 for (di
= mdi
->devs
; di
; di
= di
->next
) {
342 for (cd
= container
->devs
; cd
; cd
= cd
->next
)
343 if (di
->disk
.major
== cd
->disk
.major
&&
344 di
->disk
.minor
== cd
->disk
.minor
)
347 struct mdinfo
*newd
= malloc(sizeof(*newd
));
350 container
->devcnt
= -1;
354 add_disk_to_container(container
, newd
);
358 container
->devcnt
= mdstat
->devcnt
;
362 static void manage_member(struct mdstat_ent
*mdstat
,
363 struct active_array
*a
)
365 /* Compare mdstat info with known state of member array.
366 * We do not need to look for device state changes here, that
367 * is dealt with by the monitor.
369 * We just look for changes which suggest that a reshape is
371 * Unfortunately decreases in raid_disks don't show up in
372 * mdstat until the reshape completes FIXME.
374 * Actually, we also want to handle degraded arrays here by
375 * trying to find and assign a spare.
376 * We do that whenever the monitor tells us too.
379 a
->info
.array
.raid_disks
= mdstat
->raid_disks
;
380 a
->info
.array
.chunk_size
= mdstat
->chunk_size
;
383 if (a
->check_degraded
) {
384 struct metadata_update
*updates
= NULL
;
385 struct mdinfo
*newdev
= NULL
;
386 struct active_array
*newa
;
389 a
->check_degraded
= 0;
391 /* The array may not be degraded, this is just a good time
394 newdev
= a
->container
->ss
->activate_spare(a
, &updates
);
398 newa
= duplicate_aa(a
);
401 /* Cool, we can add a device or several. */
403 /* Add device to array and set offset/size/slot.
404 * and open files for each newdev */
405 for (d
= newdev
; d
; d
= d
->next
) {
408 newd
= malloc(sizeof(*newd
));
411 if (sysfs_add_disk(&newa
->info
, d
, 0) < 0) {
416 newd
->next
= newa
->info
.devs
;
417 newa
->info
.devs
= newd
;
419 newd
->state_fd
= sysfs_open(a
->devnum
, newd
->sys_name
,
421 newd
->prev_state
= read_dev_state(newd
->state_fd
);
422 newd
->curr_state
= newd
->prev_state
;
424 queue_metadata_update(updates
);
426 replace_array(a
->container
, a
, newa
);
427 sysfs_set_str(&a
->info
, NULL
, "sync_action", "recover");
434 free_updates(&updates
);
438 static int aa_ready(struct active_array
*aa
)
441 int level
= aa
->info
.array
.level
;
443 for (d
= aa
->info
.devs
; d
; d
= d
->next
)
447 if (aa
->info
.state_fd
< 0)
450 if (level
> 0 && (aa
->action_fd
< 0 || aa
->resync_start_fd
< 0))
459 static void manage_new(struct mdstat_ent
*mdstat
,
460 struct supertype
*container
,
461 struct active_array
*victim
)
463 /* A new array has appeared in this container.
464 * Hopefully it is already recorded in the metadata.
465 * Check, then create the new array to report it to
469 struct active_array
*new;
470 struct mdinfo
*mdi
, *di
;
475 /* check if array is ready to be monitored */
479 mdi
= sysfs_read(-1, mdstat
->devnum
,
480 GET_LEVEL
|GET_CHUNK
|GET_DISKS
|GET_COMPONENT
|
481 GET_DEGRADED
|GET_DEVS
|GET_OFFSET
|GET_SIZE
|GET_STATE
);
483 new = malloc(sizeof(*new));
492 memset(new, 0, sizeof(*new));
494 new->devnum
= mdstat
->devnum
;
495 strcpy(new->info
.sys_name
, devnum2devname(new->devnum
));
497 new->prev_state
= new->curr_state
= new->next_state
= inactive
;
498 new->prev_action
= new->curr_action
= new->next_action
= idle
;
500 new->container
= container
;
502 inst
= &mdstat
->metadata_version
[10+strlen(container
->devname
)+1];
504 new->info
.array
= mdi
->array
;
505 new->info
.component_size
= mdi
->component_size
;
507 for (i
= 0; i
< new->info
.array
.raid_disks
; i
++) {
508 struct mdinfo
*newd
= malloc(sizeof(*newd
));
510 for (di
= mdi
->devs
; di
; di
= di
->next
)
511 if (i
== di
->disk
.raid_disk
)
515 memcpy(newd
, di
, sizeof(*newd
));
517 newd
->state_fd
= sysfs_open(new->devnum
,
521 newd
->prev_state
= read_dev_state(newd
->state_fd
);
522 newd
->curr_state
= newd
->prev_state
;
528 if (failed
> new->info
.array
.failed_disks
) {
529 /* we cannot properly monitor without all working disks */
530 new->container
= NULL
;
535 sprintf(newd
->sys_name
, "rd%d", i
);
536 newd
->next
= new->info
.devs
;
537 new->info
.devs
= newd
;
540 new->action_fd
= sysfs_open(new->devnum
, NULL
, "sync_action");
541 new->info
.state_fd
= sysfs_open(new->devnum
, NULL
, "array_state");
542 new->resync_start_fd
= sysfs_open(new->devnum
, NULL
, "resync_start");
543 new->metadata_fd
= sysfs_open(new->devnum
, NULL
, "metadata_version");
544 get_resync_start(new);
545 dprintf("%s: inst: %d action: %d state: %d\n", __func__
, atoi(inst
),
546 new->action_fd
, new->info
.state_fd
);
550 /* if everything checks out tell the metadata handler we want to
551 * manage this instance
553 if (!aa_ready(new) || container
->ss
->open_new(container
, new, inst
) < 0) {
554 fprintf(stderr
, "mdmon: failed to monitor %s\n",
555 mdstat
->metadata_version
);
556 new->container
= NULL
;
559 replace_array(container
, victim
, new);
561 new->check_degraded
= 1;
562 manage_member(mdstat
, new);
567 void manage(struct mdstat_ent
*mdstat
, struct supertype
*container
)
569 /* We have just read mdstat and need to compare it with
570 * the known active arrays.
571 * Arrays with the wrong metadata are ignored.
574 for ( ; mdstat
; mdstat
= mdstat
->next
) {
575 struct active_array
*a
;
576 if (mdstat
->devnum
== container
->devnum
) {
577 manage_container(mdstat
, container
);
580 if (!is_container_member(mdstat
, container
->devname
))
581 /* Not for this array */
583 /* Looks like a member of this container */
584 for (a
= container
->arrays
; a
; a
= a
->next
) {
585 if (mdstat
->devnum
== a
->devnum
) {
587 manage_member(mdstat
, a
);
591 if (a
== NULL
|| !a
->container
)
592 manage_new(mdstat
, container
, a
);
596 static void handle_message(struct supertype
*container
, struct metadata_update
*msg
)
598 /* queue this metadata update through to the monitor */
600 struct metadata_update
*mu
;
603 while (update_queue_pending
|| update_queue
) {
604 check_update_queue(container
);
608 if (msg
->len
== 0) { /* ping_monitor */
611 cnt
= monitor_loop_cnt
;
613 cnt
+= 2; /* wait until next pselect */
615 cnt
+= 3; /* wait for 2 pselects */
618 while (monitor_loop_cnt
- cnt
< 0)
620 } else if (msg
->len
== -1) { /* ping_manager */
621 struct mdstat_ent
*mdstat
= mdstat_read(1, 0);
623 manage(mdstat
, container
);
625 } else if (!sigterm
) {
626 mu
= malloc(sizeof(*mu
));
632 if (container
->ss
->prepare_update
)
633 container
->ss
->prepare_update(container
, mu
);
634 queue_metadata_update(mu
);
638 void read_sock(struct supertype
*container
)
641 struct metadata_update msg
;
644 int tmo
= 3; /* 3 second timeout before hanging up the socket */
646 fd
= accept(container
->sock
, NULL
, NULL
);
650 fl
= fcntl(fd
, F_GETFL
, 0);
652 fcntl(fd
, F_SETFL
, fl
);
657 /* read and validate the message */
658 if (receive_message(fd
, &msg
, tmo
) == 0) {
659 handle_message(container
, &msg
);
660 if (ack(fd
, tmo
) < 0)
665 } while (!terminate
);
671 int manager_ready
= 0;
672 void do_manager(struct supertype
*container
)
674 struct mdstat_ent
*mdstat
;
678 sigprocmask(SIG_UNBLOCK
, NULL
, &set
);
679 sigdelset(&set
, SIGUSR1
);
680 sigdelset(&set
, SIGHUP
);
681 sigdelset(&set
, SIGALRM
);
682 sigdelset(&set
, SIGTERM
);
683 proc_fd
= open("/proc/mounts", O_RDONLY
);
690 /* Can only 'manage' things if 'monitor' is not making
691 * structural changes to metadata, so need to check
694 if (update_queue
== NULL
) {
695 mdstat
= mdstat_read(1, 0);
697 manage(mdstat
, container
);
699 read_sock(container
);
701 if (container
->sock
< 0 || socket_hup_requested
) {
702 /* If this fails, we hope it already exists
703 * pid file lives in /var/run/mdadm/mdXX.pid
706 mkdir("/var/run", 0600);
707 mkdir("/var/run/mdadm", 0600);
708 close(container
->sock
);
709 container
->sock
= make_control_sock(container
->devname
);
710 make_pidfile(container
->devname
, 0);
711 socket_hup_requested
= 0;
713 if (container
->sock
< 0)
720 check_update_queue(container
);
727 if (update_queue
== NULL
) {
728 if (container
->sock
< 0)
729 mdstat_wait_fd(proc_fd
, &set
);
731 mdstat_wait_fd(container
->sock
, &set
);
733 /* If an update is happening, just wait for signal */
734 pselect(0, NULL
, NULL
, NULL
, NULL
, &set
);