314889657aaae88629241ab4ae69d80b4832284a
[thirdparty/mdadm.git] / monitor.c
1
2 #include "mdadm.h"
3 #include "mdmon.h"
4 #include <sys/syscall.h>
5 #include <sys/select.h>
6 #include <signal.h>
7
8 static char *array_states[] = {
9         "clear", "inactive", "suspended", "readonly", "read-auto",
10         "clean", "active", "write-pending", "active-idle", NULL };
11 static char *sync_actions[] = {
12         "idle", "reshape", "resync", "recover", "check", "repair", NULL
13 };
14
15 static int write_attr(char *attr, int fd)
16 {
17         return write(fd, attr, strlen(attr));
18 }
19
20 static void add_fd(fd_set *fds, int *maxfd, int fd)
21 {
22         if (fd < 0)
23                 return;
24         if (fd > *maxfd)
25                 *maxfd = fd;
26         FD_SET(fd, fds);
27 }
28
29 static int read_attr(char *buf, int len, int fd)
30 {
31         int n;
32
33         if (fd < 0) {
34                 buf[0] = 0;
35                 return 0;
36         }
37         lseek(fd, 0, 0);
38         n = read(fd, buf, len - 1);
39
40         if (n <= 0) {
41                 buf[0] = 0;
42                 return 0;
43         }
44         buf[n] = 0;
45         if (buf[n-1] == '\n')
46                 buf[n-1] = 0;
47         return n;
48 }
49
50
51 int get_resync_start(struct active_array *a)
52 {
53         char buf[30];
54         int n;
55
56         n = read_attr(buf, 30, a->resync_start_fd);
57         if (n <= 0)
58                 return n;
59
60         a->resync_start = strtoull(buf, NULL, 10);
61
62         return 1;
63 }
64
65 static int attr_match(const char *attr, const char *str)
66 {
67         /* See if attr, read from a sysfs file, matches
68          * str.  They must either be the same, or attr can
69          * have a trailing newline or comma
70          */
71         while (*attr && *str && *attr == *str) {
72                 attr++;
73                 str++;
74         }
75
76         if (*str || (*attr && *attr != ',' && *attr != '\n'))
77                 return 0;
78         return 1;
79 }
80
81 static int match_word(const char *word, char **list)
82 {
83         int n;
84         for (n=0; list[n]; n++)
85                 if (attr_match(word, list[n]))
86                         break;
87         return n;
88 }
89
90 static enum array_state read_state(int fd)
91 {
92         char buf[20];
93         int n = read_attr(buf, 20, fd);
94
95         if (n <= 0)
96                 return bad_word;
97         return (enum array_state) match_word(buf, array_states);
98 }
99
100 static enum sync_action read_action( int fd)
101 {
102         char buf[20];
103         int n = read_attr(buf, 20, fd);
104
105         if (n <= 0)
106                 return bad_action;
107         return (enum sync_action) match_word(buf, sync_actions);
108 }
109
110 int read_dev_state(int fd)
111 {
112         char buf[60];
113         int n = read_attr(buf, 60, fd);
114         char *cp;
115         int rv = 0;
116
117         if (n <= 0)
118                 return 0;
119
120         cp = buf;
121         while (cp) {
122                 if (attr_match(cp, "faulty"))
123                         rv |= DS_FAULTY;
124                 if (attr_match(cp, "in_sync"))
125                         rv |= DS_INSYNC;
126                 if (attr_match(cp, "write_mostly"))
127                         rv |= DS_WRITE_MOSTLY;
128                 if (attr_match(cp, "spare"))
129                         rv |= DS_SPARE;
130                 if (attr_match(cp, "blocked"))
131                         rv |= DS_BLOCKED;
132                 cp = strchr(cp, ',');
133                 if (cp)
134                         cp++;
135         }
136         return rv;
137 }
138
139 static void signal_manager(void)
140 {
141         /* tgkill(getpid(), mon_tid, SIGUSR1); */
142         int pid = getpid();
143         syscall(SYS_tgkill, pid, mgr_tid, SIGUSR1);
144 }
145
146 /* Monitor a set of active md arrays - all of which share the
147  * same metadata - and respond to events that require
148  * metadata update.
149  *
150  * New arrays are detected by another thread which allocates
151  * required memory and attaches the data structure to our list.
152  *
153  * Events:
154  *  Array stops.
155  *    This is detected by array_state going to 'clear' or 'inactive'.
156  *    while we thought it was active.
157  *    Response is to mark metadata as clean and 'clear' the array(??)
158  *  write-pending
159  *    array_state if 'write-pending'
160  *    We mark metadata as 'dirty' then set array to 'active'.
161  *  active_idle
162  *    Either ignore, or mark clean, then mark metadata as clean.
163  *
164  *  device fails
165  *    detected by rd-N/state reporting "faulty"
166  *    mark device as 'failed' in metadata, let the kernel release the
167  *    device by writing '-blocked' to rd/state, and finally write 'remove' to
168  *    rd/state.  Before a disk can be replaced it must be failed and removed
169  *    from all container members, this will be preemptive for the other
170  *    arrays... safe?
171  *
172  *  sync completes
173  *    sync_action was 'resync' and becomes 'idle' and resync_start becomes
174  *    MaxSector
175  *    Notify metadata that sync is complete.
176  *
177  *  recovery completes
178  *    sync_action changes from 'recover' to 'idle'
179  *    Check each device state and mark metadata if 'faulty' or 'in_sync'.
180  *
181  *  deal with resync
182  *    This only happens on finding a new array... mdadm will have set
183  *    'resync_start' to the correct value.  If 'resync_start' indicates that an
184  *    resync needs to occur set the array to the 'active' state rather than the
185  *    initial read-auto state.
186  *
187  *
188  *
189  * We wait for a change (poll/select) on array_state, sync_action, and
190  * each rd-X/state file.
191  * When we get any change, we check everything.  So read each state file,
192  * then decide what to do.
193  *
194  * The core action is to write new metadata to all devices in the array.
195  * This is done at most once on any wakeup.
196  * After that we might:
197  *   - update the array_state
198  *   - set the role of some devices.
199  *   - request a sync_action
200  *
201  */
202
203 static int read_and_act(struct active_array *a)
204 {
205         int check_degraded = 0;
206         int deactivate = 0;
207         struct mdinfo *mdi;
208
209         a->next_state = bad_word;
210         a->next_action = bad_action;
211
212         a->curr_state = read_state(a->info.state_fd);
213         a->curr_action = read_action(a->action_fd);
214         for (mdi = a->info.devs; mdi ; mdi = mdi->next) {
215                 mdi->next_state = 0;
216                 if (mdi->state_fd >= 0)
217                         mdi->curr_state = read_dev_state(mdi->state_fd);
218         }
219
220         if (a->curr_state <= inactive &&
221             a->prev_state > inactive) {
222                 /* array has been stopped */
223                 a->container->ss->set_array_state(a, 1);
224                 a->next_state = clear;
225                 deactivate = 1;
226         }
227         if (a->curr_state == write_pending) {
228                 get_resync_start(a);
229                 a->container->ss->set_array_state(a, 0);
230                 a->next_state = active;
231         }
232         if (a->curr_state == active_idle) {
233                 /* Set array to 'clean' FIRST, then
234                  * a->ss->mark_clean(a, ~0ULL);
235                  * just ignore for now.
236                  */
237         }
238
239         if (a->curr_state == readonly) {
240                 /* Well, I'm ready to handle things, so
241                  * read-auto is OK. FIXME what if we really want
242                  * readonly ???
243                  */
244                 get_resync_start(a);
245 //              printf("Found a readonly array at %llu\n", a->resync_start);
246                 if (a->resync_start == ~0ULL)
247                         a->next_state = read_auto; /* array is clean */
248                 else {
249                         a->container->ss->set_array_state(a, 0);
250                         a->next_state = active;
251                 }
252         }
253
254         if (!deactivate &&
255             a->curr_action == idle &&
256             a->prev_action == resync) {
257                 /* A resync has finished.  The endpoint is recorded in
258                  * 'sync_start'.  We don't update the metadata
259                  * until the array goes inactive or readonly though.
260                  * Just check if we need to fiddle spares.
261                  */
262                 get_resync_start(a);
263                 a->container->ss->set_array_state(a, 0);
264                 check_degraded = 1;
265         }
266
267         if (!deactivate &&
268             a->curr_action == idle &&
269             a->prev_action == recover) {
270                 /* A recovery has finished.  Some disks may be in sync now,
271                  * and the array may no longer be degraded
272                  */
273                 for (mdi = a->info.devs ; mdi ; mdi = mdi->next) {
274                         a->container->ss->set_disk(a, mdi->disk.raid_disk,
275                                                    mdi->curr_state);
276                         if (! (mdi->curr_state & DS_INSYNC))
277                                 check_degraded = 1;
278                 }
279                 a->container->ss->set_array_state(a, 0);
280         }
281
282         for (mdi = a->info.devs ; mdi ; mdi = mdi->next) {
283                 if (mdi->curr_state & DS_FAULTY) {
284                         a->container->ss->set_disk(a, mdi->disk.raid_disk,
285                                                    mdi->curr_state);
286                         check_degraded = 1;
287                         mdi->next_state = DS_REMOVE;
288                 }
289         }
290
291         a->container->ss->sync_metadata(a->container);
292         dprintf("%s: update[%d]: (", __func__, a->info.container_member);
293
294         /* Effect state changes in the array */
295         if (a->next_state != bad_word) {
296                 dprintf(" state:%s", array_states[a->next_state]);
297                 write_attr(array_states[a->next_state], a->info.state_fd);
298         }
299         if (a->next_action != bad_action) {
300                 write_attr(sync_actions[a->next_action], a->action_fd);
301                 dprintf(" action:%s", array_states[a->next_state]);
302         }
303         for (mdi = a->info.devs; mdi ; mdi = mdi->next) {
304                 if (mdi->next_state == DS_REMOVE && mdi->state_fd >= 0) {
305                         int remove_result;
306
307                         write_attr("-blocked", mdi->state_fd);
308                         /* the kernel may not be able to immediately remove the
309                          * disk, we can simply wait until the next event to try
310                          * again.
311                          */
312                         dprintf(" %d:-blocked", mdi->disk.raid_disk);
313                         remove_result = write_attr("remove", mdi->state_fd);
314                         if (remove_result > 0) {
315                                 dprintf(" %d:removed", mdi->disk.raid_disk);
316                                 close(mdi->state_fd);
317                                 mdi->state_fd = -1;
318                         }
319                 }
320                 if (mdi->next_state & DS_INSYNC) {
321                         write_attr("+in_sync", mdi->state_fd);
322                         dprintf(" %d:+in_sync", mdi->disk.raid_disk);
323                 }
324         }
325         dprintf(" )\n");
326
327         /* move curr_ to prev_ */
328         a->prev_state = a->curr_state;
329
330         a->prev_action = a->curr_action;
331
332         for (mdi = a->info.devs; mdi ; mdi = mdi->next) {
333                 mdi->prev_state = mdi->curr_state;
334                 mdi->next_state = 0;
335         }
336
337         if (check_degraded) {
338                 /* manager will do the actual check */
339                 a->check_degraded = 1;
340                 signal_manager();
341         }
342
343         if (deactivate)
344                 a->container = NULL;
345
346         return 1;
347 }
348
349 static struct mdinfo *
350 find_device(struct active_array *a, int major, int minor)
351 {
352         struct mdinfo *mdi;
353
354         for (mdi = a->info.devs ; mdi ; mdi = mdi->next)
355                 if (mdi->disk.major == major && mdi->disk.minor == minor)
356                         return mdi;
357
358         return NULL;
359 }
360
361 static void reconcile_failed(struct active_array *aa, struct mdinfo *failed)
362 {
363         struct active_array *a;
364         struct mdinfo *victim;
365
366         for (a = aa; a; a = a->next) {
367                 if (!a->container)
368                         continue;
369                 victim = find_device(a, failed->disk.major, failed->disk.minor);
370                 if (!victim)
371                         continue;
372
373                 if (!(victim->curr_state & DS_FAULTY))
374                         write_attr("faulty", victim->state_fd);
375         }
376 }
377
378 #ifdef DEBUG
379 static void dprint_wake_reasons(fd_set *fds)
380 {
381         int i;
382         char proc_path[256];
383         char link[256];
384         char *basename;
385         int rv;
386
387         fprintf(stderr, "monitor: wake ( ");
388         for (i = 0; i < FD_SETSIZE; i++) {
389                 if (FD_ISSET(i, fds)) {
390                         sprintf(proc_path, "/proc/%d/fd/%d",
391                                 (int) getpid(), i);
392
393                         rv = readlink(proc_path, link, sizeof(link) - 1);
394                         if (rv < 0) {
395                                 fprintf(stderr, "%d:unknown ", i);
396                                 continue;
397                         }
398                         link[rv] = '\0';
399                         basename = strrchr(link, '/');
400                         fprintf(stderr, "%d:%s ",
401                                 i, basename ? ++basename : link);
402                 }
403         }
404         fprintf(stderr, ")\n");
405 }
406 #endif
407
408 static int wait_and_act(struct supertype *container, int nowait)
409 {
410         fd_set rfds;
411         int maxfd = 0;
412         struct active_array **aap = &container->arrays;
413         struct active_array *a, **ap;
414         int rv;
415         struct mdinfo *mdi;
416
417         FD_ZERO(&rfds);
418
419         for (ap = aap ; *ap ;) {
420                 a = *ap;
421                 /* once an array has been deactivated we want to
422                  * ask the manager to discard it.
423                  */
424                 if (!a->container) {
425                         if (discard_this) {
426                                 ap = &(*ap)->next;
427                                 continue;
428                         }
429                         *ap = a->next;
430                         a->next = NULL;
431                         discard_this = a;
432                         signal_manager();
433                         continue;
434                 }
435
436                 add_fd(&rfds, &maxfd, a->info.state_fd);
437                 add_fd(&rfds, &maxfd, a->action_fd);
438                 for (mdi = a->info.devs ; mdi ; mdi = mdi->next)
439                         add_fd(&rfds, &maxfd, mdi->state_fd);
440
441                 ap = &(*ap)->next;
442         }
443
444         if (manager_ready && *aap == NULL) {
445                 /* No interesting arrays. Lets see about exiting.
446                  * Note that blocking at this point is not a problem
447                  * as there are no active arrays, there is nothing that
448                  * we need to be ready to do.
449                  */
450                 int fd = open(container->device_name, O_RDONLY|O_EXCL);
451                 if (fd >= 0 || errno != EBUSY) {
452                         /* OK, we are safe to leave */
453                         dprintf("no arrays to monitor... exiting\n");
454                         remove_pidfile(container->devname);
455                         exit_now = 1;
456                         signal_manager();
457                         exit(0);
458                 }
459         }
460
461         if (!nowait) {
462                 sigset_t set;
463                 sigprocmask(SIG_UNBLOCK, NULL, &set);
464                 sigdelset(&set, SIGUSR1);
465                 rv = pselect(maxfd+1, &rfds, NULL, NULL, NULL, &set);
466                 if (rv == -1 && errno == EINTR)
467                         rv = 0;
468                 #ifdef DEBUG
469                 dprint_wake_reasons(&rfds);
470                 #endif
471
472         }
473
474         if (update_queue) {
475                 struct metadata_update *this;
476
477                 for (this = update_queue; this ; this = this->next)
478                         container->ss->process_update(container, this);
479
480                 update_queue_handled = update_queue;
481                 update_queue = NULL;
482                 signal_manager();
483                 container->ss->sync_metadata(container);
484         }
485
486         for (a = *aap; a ; a = a->next) {
487                 if (a->replaces && !discard_this) {
488                         struct active_array **ap;
489                         for (ap = &a->next; *ap && *ap != a->replaces;
490                              ap = & (*ap)->next)
491                                 ;
492                         if (*ap)
493                                 *ap = (*ap)->next;
494                         discard_this = a->replaces;
495                         a->replaces = NULL;
496                         /* FIXME check if device->state_fd need to be cleared?*/
497                         signal_manager();
498                 }
499                 if (a->container)
500                         rv += read_and_act(a);
501         }
502
503         /* propagate failures across container members */
504         for (a = *aap; a ; a = a->next) {
505                 if (!a->container)
506                         continue;
507                 for (mdi = a->info.devs ; mdi ; mdi = mdi->next)
508                         if (mdi->curr_state & DS_FAULTY)
509                                 reconcile_failed(*aap, mdi);
510         }
511
512         return rv;
513 }
514
515 void do_monitor(struct supertype *container)
516 {
517         int rv;
518         int first = 1;
519         do {
520                 rv = wait_and_act(container, first);
521                 first = 0;
522         } while (rv >= 0);
523 }