]>
git.ipfire.org Git - thirdparty/mdadm.git/blob - managemon.c
3 * The management thread for monitoring active md arrays.
4 * This thread does things which might block such as memory
8 * - Find out about new arrays in this container.
9 * Allocate the data structures and open the files.
11 * For this we watch /proc/mdstat and find new arrays with
12 * metadata type that confirms sharing. e.g. "md4"
13 * When we find a new array we slip it into the list of
14 * arrays and signal 'monitor' by writing to a pipe.
16 * - Respond to reshape requests by allocating new data structures
17 * and opening new files.
19 * These come as a change to raid_disks. We allocate a new
20 * version of the data structures and slip it into the list.
21 * 'monitor' will notice and release the old version.
22 * Changes to level, chunksize, layout.. do not need re-allocation.
23 * Reductions in raid_disks don't really either, but we handle
24 * them the same way for consistency.
26 * - When a device is added to the container, we add it to the metadata
29 * - Deal with degraded array
30 * We only do this when first noticing the array is degraded.
31 * This can be when we first see the array, when sync completes or
32 * when recovery completes.
34 * Check if number of failed devices suggests recovery is needed, and
36 * Ask metadata to allocate a spare device
37 * Add device as not in_sync and give a role
39 * Open sysfs files and pass to monitor.
40 * Make sure that monitor Starts recovery....
42 * - Pass on metadata updates from external programs such as
43 * mdadm creating a new array.
46 * It might involve adding a new array or changing the status of
47 * a spare, or any reconfig that the kernel doesn't get involved in.
49 * The required updates are received via a named pipe. There will
50 * be one named pipe for each container. Each message contains a
51 * sync marker: 0x5a5aa5a5, A byte count, and the message. This is
52 * passed to the metadata handler which will interpret and process it.
53 * For 'DDF' messages are internal data blocks with the leading
54 * 'magic number' signifying what sort of data it is.
59 * We select on /proc/mdstat and the named pipe.
60 * We create new arrays or updated version of arrays and slip
61 * them into the head of the list, then signal 'monitor' via a pipe write.
62 * 'monitor' will notice and place the old array on a return list.
63 * Metadata updates are placed on a queue just like they arrive
64 * from the named pipe.
66 * When new arrays are found based on correct metadata string, we
67 * need to identify them with an entry in the metadata. Maybe we require
68 * the metadata to be mdX/NN when NN is the index into an appropriate table.
74 * - Watch for spares to be added to the container, and write updated
76 * - Watch for new arrays using this container, confirm they match metadata
77 * and if so, start monitoring them
78 * - Watch for spares being added to monitored arrays. This shouldn't
79 * happen, as we should do all the adding. Just remove them.
80 * - Watch for change in raid-disks, chunk-size, etc. Update metadata and
88 #include <sys/syscall.h>
89 #include <sys/socket.h>
92 static void close_aa(struct active_array
*aa
)
96 for (d
= aa
->info
.devs
; d
; d
= d
->next
)
100 close(aa
->info
.state_fd
);
101 close(aa
->resync_start_fd
);
104 static void free_aa(struct active_array
*aa
)
106 /* Note that this doesn't close fds if they are being used
107 * by a clone. ->container will be set for a clone
109 dprintf("%s: devnum: %d\n", __func__
, aa
->devnum
);
112 while (aa
->info
.devs
) {
113 struct mdinfo
*d
= aa
->info
.devs
;
114 aa
->info
.devs
= d
->next
;
120 static struct active_array
*duplicate_aa(struct active_array
*aa
)
122 struct active_array
*newa
= malloc(sizeof(*newa
));
123 struct mdinfo
**dp1
, **dp2
;
127 newa
->replaces
= NULL
;
128 newa
->info
.next
= NULL
;
130 dp2
= &newa
->info
.devs
;
132 for (dp1
= &aa
->info
.devs
; *dp1
; dp1
= &(*dp1
)->next
) {
134 if ((*dp1
)->state_fd
< 0)
137 d
= malloc(sizeof(*d
));
147 static void wakeup_monitor(void)
149 /* tgkill(getpid(), mon_tid, SIGUSR1); */
151 syscall(SYS_tgkill
, pid
, mon_tid
, SIGUSR1
);
154 static void remove_old(void)
157 discard_this
->next
= NULL
;
158 free_aa(discard_this
);
159 if (pending_discard
== discard_this
)
160 pending_discard
= NULL
;
166 static void replace_array(struct supertype
*container
,
167 struct active_array
*old
,
168 struct active_array
*new)
170 /* To replace an array, we add it to the top of the list
171 * marked with ->replaces to point to the original.
172 * 'monitor' will take the original out of the list
173 * and put it on 'discard_this'. We take it from there
177 while (pending_discard
) {
178 while (discard_this
== NULL
)
182 pending_discard
= old
;
184 new->next
= container
->arrays
;
185 container
->arrays
= new;
189 struct metadata_update
*update_queue
= NULL
;
190 struct metadata_update
*update_queue_handled
= NULL
;
191 struct metadata_update
*update_queue_pending
= NULL
;
193 void check_update_queue(struct supertype
*container
)
195 while (update_queue_handled
) {
196 struct metadata_update
*this = update_queue_handled
;
197 update_queue_handled
= this->next
;
203 if (update_queue
== NULL
&&
204 update_queue_pending
) {
205 update_queue
= update_queue_pending
;
206 update_queue_pending
= NULL
;
211 static void queue_metadata_update(struct metadata_update
*mu
)
213 struct metadata_update
**qp
;
215 qp
= &update_queue_pending
;
217 qp
= & ((*qp
)->next
);
221 void wait_update_handled(void)
223 /* Wait for any pending update to be handled by monitor.
224 * i.e. wait until update_queue is NULL
230 static void manage_container(struct mdstat_ent
*mdstat
,
231 struct supertype
*container
)
233 /* The only thing of interest here is if a new device
234 * has been added to the container. We add it to the
235 * array ignoring any metadata on it.
236 * FIXME should we look for compatible metadata and take hints
237 * about spare assignment.... probably not.
239 if (mdstat
->devcnt
!= container
->devcnt
) {
240 /* read /sys/block/NAME/md/dev-??/block/dev to find out
241 * what is there, and compare with container->info.devs
242 * To see what is removed and what is added.
243 * These need to be remove from, or added to, the array
246 container
->devcnt
= mdstat
->devcnt
;
250 static void manage_member(struct mdstat_ent
*mdstat
,
251 struct active_array
*a
)
253 /* Compare mdstat info with known state of member array.
254 * We do not need to look for device state changes here, that
255 * is dealt with by the monitor.
257 * We just look for changes which suggest that a reshape is
259 * Unfortunately decreases in raid_disks don't show up in
260 * mdstat until the reshape completes FIXME.
262 * Actually, we also want to handle degraded arrays here by
263 * trying to find and assign a spare.
264 * We do that whenever the monitor tells us too.
267 a
->info
.array
.raid_disks
= mdstat
->raid_disks
;
268 a
->info
.array
.chunk_size
= mdstat
->chunk_size
;
271 if (a
->check_degraded
) {
272 struct metadata_update
*updates
= NULL
;
273 struct mdinfo
*newdev
;
274 struct active_array
*newa
;
275 wait_update_handled();
276 a
->check_degraded
= 0;
278 /* The array may not be degraded, this is just a good time
281 newdev
= a
->container
->ss
->activate_spare(a
, &updates
);
284 /* Cool, we can add a device or several. */
285 newa
= duplicate_aa(a
);
286 /* suspend recovery - maybe not needed */
288 /* Add device to array and set offset/size/slot.
289 * and open files for each newdev */
290 for (d
= newdev
; d
; d
= d
->next
) {
292 if (sysfs_add_disk(&newa
->info
, d
) < 0)
294 newd
= newa
->info
.devs
;
295 newd
->state_fd
= sysfs_open(a
->devnum
,
299 = read_dev_state(newd
->state_fd
);
300 newd
->curr_state
= newd
->prev_state
;
302 queue_metadata_update(updates
);
303 replace_array(a
->container
, a
, newa
);
304 sysfs_set_str(&a
->info
, NULL
, "sync_action", "repair");
309 static void manage_new(struct mdstat_ent
*mdstat
,
310 struct supertype
*container
,
311 struct active_array
*victim
)
313 /* A new array has appeared in this container.
314 * Hopefully it is already recorded in the metadata.
315 * Check, then create the new array to report it to
319 struct active_array
*new;
320 struct mdinfo
*mdi
, *di
;
324 new = malloc(sizeof(*new));
326 memset(new, 0, sizeof(*new));
328 new->devnum
= mdstat
->devnum
;
329 strcpy(new->info
.sys_name
, devnum2devname(new->devnum
));
331 new->prev_state
= new->curr_state
= new->next_state
= inactive
;
332 new->prev_action
= new->curr_action
= new->next_action
= idle
;
334 new->container
= container
;
336 inst
= &mdstat
->metadata_version
[10+strlen(container
->devname
)+1];
338 mdi
= sysfs_read(-1, new->devnum
,
339 GET_LEVEL
|GET_CHUNK
|GET_DISKS
|GET_COMPONENT
|
340 GET_DEVS
|GET_OFFSET
|GET_SIZE
|GET_STATE
);
342 /* Eeek. Cannot monitor this array.
343 * Mark it to be ignored by setting container to NULL
345 new->container
= NULL
;
346 replace_array(container
, victim
, new);
350 new->info
.array
= mdi
->array
;
351 new->info
.component_size
= mdi
->component_size
;
353 for (i
= 0; i
< new->info
.array
.raid_disks
; i
++) {
354 struct mdinfo
*newd
= malloc(sizeof(*newd
));
356 for (di
= mdi
->devs
; di
; di
= di
->next
)
357 if (i
== di
->disk
.raid_disk
)
361 memcpy(newd
, di
, sizeof(*newd
));
363 newd
->state_fd
= sysfs_open(new->devnum
,
367 newd
->prev_state
= read_dev_state(newd
->state_fd
);
368 newd
->curr_state
= newd
->prev_state
;
371 newd
->disk
.raid_disk
= i
;
372 newd
->prev_state
= DS_REMOVE
;
373 newd
->curr_state
= DS_REMOVE
;
375 sprintf(newd
->sys_name
, "rd%d", i
);
376 newd
->next
= new->info
.devs
;
377 new->info
.devs
= newd
;
379 new->action_fd
= sysfs_open(new->devnum
, NULL
, "sync_action");
380 new->info
.state_fd
= sysfs_open(new->devnum
, NULL
, "array_state");
381 new->resync_start_fd
= sysfs_open(new->devnum
, NULL
, "resync_start");
382 get_resync_start(new);
383 dprintf("%s: inst: %d action: %d state: %d\n", __func__
, atoi(inst
),
384 new->action_fd
, new->info
.state_fd
);
387 // finds and compares.
388 if (container
->ss
->open_new(container
, new, inst
) < 0) {
389 // FIXME close all those files
390 new->container
= NULL
;
391 replace_array(container
, victim
, new);
394 replace_array(container
, victim
, new);
398 void manage(struct mdstat_ent
*mdstat
, struct supertype
*container
)
400 /* We have just read mdstat and need to compare it with
401 * the known active arrays.
402 * Arrays with the wrong metadata are ignored.
405 for ( ; mdstat
; mdstat
= mdstat
->next
) {
406 struct active_array
*a
;
407 if (mdstat
->devnum
== container
->devnum
) {
408 manage_container(mdstat
, container
);
411 if (mdstat
->metadata_version
== NULL
||
412 strncmp(mdstat
->metadata_version
, "external:/", 10) != 0 ||
413 strncmp(mdstat
->metadata_version
+10, container
->devname
,
414 strlen(container
->devname
)) != 0 ||
415 mdstat
->metadata_version
[10+strlen(container
->devname
)]
417 /* Not for this array */
419 /* Looks like a member of this container */
420 for (a
= container
->arrays
; a
; a
= a
->next
) {
421 if (mdstat
->devnum
== a
->devnum
) {
423 manage_member(mdstat
, a
);
427 if (a
== NULL
|| !a
->container
)
428 manage_new(mdstat
, container
, a
);
432 static void handle_message(struct supertype
*container
, struct metadata_update
*msg
)
434 /* queue this metadata update through to the monitor */
436 struct metadata_update
*mu
;
439 int cnt
= monitor_loop_cnt
;
441 cnt
+= 2; /* wait until next pselect */
443 cnt
+= 3; /* wait for 2 pselects */
445 wait_update_handled();
446 while (monitor_loop_cnt
- cnt
< 0)
449 mu
= malloc(sizeof(*mu
));
455 if (container
->ss
->prepare_update
)
456 container
->ss
->prepare_update(container
, mu
);
457 queue_metadata_update(mu
);
461 void read_sock(struct supertype
*container
)
464 struct metadata_update msg
;
467 int tmo
= 3; /* 3 second timeout before hanging up the socket */
469 fd
= accept(container
->sock
, NULL
, NULL
);
473 fl
= fcntl(fd
, F_GETFL
, 0);
475 fcntl(fd
, F_SETFL
, fl
);
480 /* read and validate the message */
481 if (receive_message(fd
, &msg
, tmo
) == 0) {
482 handle_message(container
, &msg
);
483 if (ack(fd
, tmo
) < 0)
488 } while (!terminate
);
494 int manager_ready
= 0;
495 void do_manager(struct supertype
*container
)
497 struct mdstat_ent
*mdstat
;
500 sigprocmask(SIG_UNBLOCK
, NULL
, &set
);
501 sigdelset(&set
, SIGUSR1
);
508 mdstat
= mdstat_read(1, 0);
510 manage(mdstat
, container
);
512 read_sock(container
);
518 check_update_queue(container
);
522 mdstat_wait_fd(container
->sock
, &set
);