Merge mdmon
[thirdparty/mdadm.git] / monitor.c
CommitLineData
549e9569
NB
1
2#include "mdadm.h"
3#include "mdmon.h"
4
5#include <sys/select.h>
6
7
8static char *array_states[] = {
9 "clear", "inactive", "suspended", "readonly", "read-auto",
10 "clean", "active", "write-pending", "active-idle", NULL };
11static char *sync_actions[] = {
12 "idle", "reshape", "resync", "recover", "check", "repair", NULL
13};
14
15static int write_attr(char *attr, int fd)
16{
17 return write(fd, attr, strlen(attr));
18}
19
20static 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
29static 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
50static int get_sync_pos(struct active_array *a)
51{
52 char buf[30];
53 int n;
54
55 n = read_attr(buf, 30, a->sync_pos_fd);
56 if (n <= 0)
57 return n;
58
59 if (strncmp(buf, "max", 3) == 0) {
60 a->sync_pos = ~(unsigned long long)0;
61 return 1;
62 }
63 a->sync_pos = strtoull(buf, NULL, 10);
64 return 1;
65}
66
67
68static int attr_match(const char *attr, const char *str)
69{
70 /* See if attr, read from a sysfs file, matches
71 * str. They must either be the same, or attr can
72 * have a trailing newline or comma
73 */
74 while (*attr && *str && *attr == *str) {
75 attr++;
76 str++;
77 }
78
79 if (*str || (*attr && *attr != ',' && *attr != '\n'))
80 return 0;
81 return 1;
82}
83
84static int match_word(const char *word, char **list)
85{
86 int n;
87 for (n=0; list[n]; n++)
88 if (attr_match(word, list[n]))
89 break;
90 return n;
91}
92
93static enum array_state read_state(int fd)
94{
95 char buf[20];
96 int n = read_attr(buf, 20, fd);
97
98 if (n <= 0)
99 return bad_word;
100 return (enum array_state) match_word(buf, array_states);
101}
102
103static enum sync_action read_action( int fd)
104{
105 char buf[20];
106 int n = read_attr(buf, 20, fd);
107
108 if (n <= 0)
109 return bad_action;
110 return (enum sync_action) match_word(buf, sync_actions);
111}
112
113#define DS_FAULTY 1
114#define DS_INSYNC 2
115#define DS_WRITE_MOSTLY 4
116#define DS_SPARE 8
117#define DS_REMOVE 1024
118
119int read_dev_state(int fd)
120{
121 char buf[60];
122 int n = read_attr(buf, 60, fd);
123 char *cp;
124 int rv = 0;
125
126 if (n <= 0)
127 return 0;
128
129 cp = buf;
130 while (cp) {
131 if (attr_match("faulty", cp))
132 rv |= DS_FAULTY;
133 if (attr_match("in_sync", cp))
134 rv |= DS_INSYNC;
135 if (attr_match("write_mostly", cp))
136 rv |= DS_WRITE_MOSTLY;
137 if (attr_match("spare", cp))
138 rv |= DS_SPARE;
139 cp = strchr(cp, ',');
140 if (cp)
141 cp++;
142 }
143 return rv;
144}
145
146
147/* Monitor a set of active md arrays - all of which share the
148 * same metadata - and respond to events that require
149 * metadata update.
150 *
151 * New arrays are detected by another thread which allocates
152 * required memory and attaches the data structure to our list.
153 *
154 * Events:
155 * Array stops.
156 * This is detected by array_state going to 'clear' or 'inactive'.
157 * while we thought it was active.
158 * Response is to mark metadata as clean and 'clear' the array(??)
159 * write-pending
160 * array_state if 'write-pending'
161 * We mark metadata as 'dirty' then set array to 'active'.
162 * active_idle
163 * Either ignore, or mark clean, then mark metadata as clean.
164 *
165 * device fails
166 * detected by rd-N/state reporting "faulty"
167 * mark device as 'failed' in metadata, the remove device
168 * by writing 'remove' to rd/state.
169 *
170 * sync completes
171 * sync_action was 'resync' and becomes 'idle' and resync_start becomes
172 * MaxSector
173 * Notify metadata that sync is complete.
174 * "Deal with Degraded"
175 *
176 * recovery completes
177 * sync_action changes from 'recover' to 'idle'
178 * Check each device state and mark metadata if 'faulty' or 'in_sync'.
179 * "Deal with Degraded"
180 *
181 * deal with degraded array
182 * We only do this when first noticing the array is degraded.
183 * This can be when we first see the array, when sync completes or
184 * when recovery completes.
185 *
186 * Check if number of failed devices suggests recovery is needed, and
187 * skip if not.
188 * Ask metadata for a spare device
189 * Add device as not in_sync and give a role
190 * Update metadata.
191 * Start recovery.
192 *
193 * deal with resync
194 * This only happens on finding a new array....
195 * Maybe this is done by mdadm before passing the array to us?
196 *
197 * If array is 'clean' but metadata is 'dirty', start a resync
198 * and mark array as 'dirty'.
199 *
200 *
201 *
202 *
203 * We wait for a change (poll/select) on array_state, sync_action, and
204 * each rd-X/state file.
205 * When we get any change, we check everything. So read each state file,
206 * then decide what to do.
207 *
208 * The core action is to write new metadata to all devices in the array.
209 * This is done at most once on any wakeup.
210 * After that we might:
211 * - update the array_state
212 * - set the role of some devices.
213 * - request a sync_action
214 *
215 */
216
217static int read_and_act(struct active_array *a)
218{
219 int check_degraded;
220 struct mdinfo *mdi;
221
222 a->next_state = bad_word;
223 a->next_action = bad_action;
224
225 a->curr_state = read_state(a->info.state_fd);
226 a->curr_action = read_action(a->action_fd);
227 for (mdi = a->info.devs; mdi ; mdi = mdi->next) {
228 mdi->next_state = 0;
229 mdi->curr_state = read_dev_state(mdi->state_fd);
230 }
231
232 if (a->curr_state <= inactive &&
233 a->prev_state > inactive) {
234 /* array has been stopped */
235 get_sync_pos(a);
236 a->container->ss->mark_clean(a, a->sync_pos);
237 a->next_state = clear;
238 }
239 if (a->curr_state == write_pending) {
240 a->container->ss->mark_dirty(a);
241 a->next_state = active;
242 }
243 if (a->curr_state == active_idle) {
244 /* Set array to 'clean' FIRST, then
245 * a->ss->mark_clean(a);
246 * just ignore for now.
247 */
248 }
249
250 if (a->curr_state == readonly) {
251 /* Well, I'm ready to handle things, so
252 * read-auto is OK. FIXME what if we really want
253 * readonly ???
254 */
255 a->next_state = read_auto;
256 }
257
258 if (a->curr_action == idle &&
259 a->prev_action == resync) {
260 /* check resync_start to see if it is 'max'.
261 * Do I open here, or have it open the whole time?
262 */
263 get_sync_pos(a);
264 check_degraded = 1;
265 }
266
267 if (a->curr_action == idle &&
268 a->prev_action == recover) {
269 for (mdi = a->info.devs ; mdi ; mdi = mdi->next) {
270 a->container->ss->set_disk(a, mdi->disk.raid_disk);
271 if (! (mdi->curr_state & DS_INSYNC))
272 check_degraded = 1;
273 }
274 }
275
276
277 for (mdi = a->info.devs ; mdi ; mdi = mdi->next) {
278 if (mdi->curr_state & DS_FAULTY) {
279 a->container->ss->set_disk(a, mdi->disk.raid_disk);
280 check_degraded = 1;
281 mdi->next_state = DS_REMOVE;
282 }
283 }
284
285 if (check_degraded) {
286 // FIXME;
287 }
288
289 a->container->ss->sync_metadata(a);
290
291 /* Effect state changes in the array */
292 if (a->next_state != bad_word)
293 write_attr(array_states[a->next_state], a->info.state_fd);
294 if (a->next_action != bad_action)
295 write_attr(sync_actions[a->next_action], a->action_fd);
296 for (mdi = a->info.devs; mdi ; mdi = mdi->next) {
297 if (mdi->next_state == DS_REMOVE)
298 write_attr("remove", mdi->state_fd);
299 if (mdi->next_state & DS_INSYNC)
300 write_attr("+in_sync", mdi->state_fd);
301 }
302
303 /* move curr_ to prev_ */
304 a->prev_state = a->curr_state;
305
306 a->prev_action = a->curr_action;
307
308 for (mdi = a->info.devs; mdi ; mdi = mdi->next) {
309 mdi->prev_state = mdi->curr_state;
310 mdi->next_state = 0;
311 }
312
313 return 1;
314}
315
316static int wait_and_act(struct active_array *aa, int pfd, int nowait)
317{
318 fd_set rfds;
319 int maxfd = 0;
320 struct active_array *a;
321 int rv;
322
323 FD_ZERO(&rfds);
324
325 add_fd(&rfds, &maxfd, pfd);
326 for (a = aa ; a ; a = a->next) {
327 struct mdinfo *mdi;
328
329 add_fd(&rfds, &maxfd, a->info.state_fd);
330 add_fd(&rfds, &maxfd, a->action_fd);
331 for (mdi = a->info.devs ; mdi ; mdi = mdi->next)
332 add_fd(&rfds, &maxfd, mdi->state_fd);
333 }
334
335 if (!nowait) {
336 rv = select(maxfd+1, &rfds, NULL, NULL, NULL);
337
338 if (rv <= 0)
339 return rv;
340
341 if (FD_ISSET(pfd, &rfds)) {
342 char buf[4];
343 read(pfd, buf, 4);
344 ; // FIXME read from the pipe
345 }
346 }
347
348 for (a = aa; a ; a = a->next) {
349 if (a->replaces) {
350 struct active_array **ap;
351 for (ap = &a->next; *ap && *ap != a->replaces;
352 ap = & (*ap)->next)
353 ;
354 if (*ap)
355 *ap = (*ap)->next;
356 discard_this = a->replaces;
357 a->replaces = NULL;
358 }
359 rv += read_and_act(a);
360 }
361 return rv;
362}
363
364void do_monitor(struct supertype *container)
365{
366 int rv;
367 int first = 1;
368 do {
369 rv = wait_and_act(container->arrays, container->pipe[0], first);
370 first = 0;
371 } while (rv >= 0);
372}