mdmon: discard test_pidfile()
[thirdparty/mdadm.git] / mdmon.c
1 /*
2 * mdmon - monitor external metadata arrays
3 *
4 * Copyright (C) 2007-2009 Neil Brown <neilb@suse.de>
5 * Copyright (C) 2007-2009 Intel Corporation
6 *
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.
10 *
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
14 * more details.
15 *
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.
19 */
20
21 /*
22 * md array manager.
23 * When md arrays have user-space managed metadata, this is the program
24 * that does the managing.
25 *
26 * Given one argument: the name of the array (e.g. /dev/md0) that is
27 * the container.
28 * We fork off a helper that runs high priority and mlocked. It responds to
29 * device failures and other events that might stop writeout, or that are
30 * trivial to deal with.
31 * The main thread then watches for new arrays being created in the container
32 * and starts monitoring them too ... along with a few other tasks.
33 *
34 * The main thread communicates with the priority thread by writing over
35 * a pipe.
36 * Separate programs can communicate with the main thread via Unix-domain
37 * socket.
38 * The two threads share address space and open file table.
39 *
40 */
41
42 #ifndef _GNU_SOURCE
43 #define _GNU_SOURCE
44 #endif
45
46 #include <unistd.h>
47 #include <stdlib.h>
48 #include <sys/types.h>
49 #include <sys/stat.h>
50 #include <sys/socket.h>
51 #include <sys/un.h>
52 #include <sys/mman.h>
53 #include <sys/syscall.h>
54 #include <sys/wait.h>
55 #include <stdio.h>
56 #include <errno.h>
57 #include <string.h>
58 #include <fcntl.h>
59 #include <signal.h>
60 #include <dirent.h>
61
62 #include <sched.h>
63
64 #include "mdadm.h"
65 #include "mdmon.h"
66
67 struct active_array *discard_this;
68 struct active_array *pending_discard;
69
70 int mon_tid, mgr_tid;
71
72 int sigterm;
73
74 int run_child(void *v)
75 {
76 struct supertype *c = v;
77
78 do_monitor(c);
79 return 0;
80 }
81
82 #ifdef __ia64__
83 int __clone2(int (*fn)(void *),
84 void *child_stack_base, size_t stack_size,
85 int flags, void *arg, ...
86 /* pid_t *pid, struct user_desc *tls, pid_t *ctid */ );
87 #endif
88 int clone_monitor(struct supertype *container)
89 {
90 static char stack[4096];
91
92 #ifdef __ia64__
93 mon_tid = __clone2(run_child, stack, sizeof(stack),
94 CLONE_FS|CLONE_FILES|CLONE_VM|CLONE_SIGHAND|CLONE_THREAD,
95 container);
96 #else
97 mon_tid = clone(run_child, stack+4096-64,
98 CLONE_FS|CLONE_FILES|CLONE_VM|CLONE_SIGHAND|CLONE_THREAD,
99 container);
100 #endif
101
102 mgr_tid = syscall(SYS_gettid);
103
104 return mon_tid;
105 }
106
107 static struct superswitch *find_metadata_methods(char *vers)
108 {
109 if (strcmp(vers, "ddf") == 0)
110 return &super_ddf;
111 if (strcmp(vers, "imsm") == 0)
112 return &super_imsm;
113 return NULL;
114 }
115
116 int make_pidfile(char *devname, int o_excl)
117 {
118 char path[100];
119 char pid[10];
120 int fd;
121 int n;
122
123 if (sigterm)
124 return -1;
125
126 sprintf(path, "/var/run/mdadm/%s.pid", devname);
127
128 fd = open(path, O_RDWR|O_CREAT|o_excl, 0600);
129 if (fd < 0)
130 return -errno;
131 sprintf(pid, "%d\n", getpid());
132 n = write(fd, pid, strlen(pid));
133 close(fd);
134 if (n < 0)
135 return -errno;
136 return 0;
137 }
138
139 int is_container_member(struct mdstat_ent *mdstat, char *container)
140 {
141 if (mdstat->metadata_version == NULL ||
142 strncmp(mdstat->metadata_version, "external:", 9) != 0 ||
143 !is_subarray(mdstat->metadata_version+9) ||
144 strncmp(mdstat->metadata_version+10, container, strlen(container)) != 0 ||
145 mdstat->metadata_version[10+strlen(container)] != '/')
146 return 0;
147
148 return 1;
149 }
150
151 pid_t devname2mdmon(char *devname)
152 {
153 char buf[100];
154 pid_t pid = -1;
155 int fd;
156
157 sprintf(buf, "/var/run/mdadm/%s.pid", devname);
158 fd = open(buf, O_RDONLY|O_NOATIME);
159 if (fd < 0)
160 return -1;
161
162 if (read(fd, buf, sizeof(buf)) > 0)
163 sscanf(buf, "%d\n", &pid);
164 close(fd);
165
166 return pid;
167 }
168
169 static void try_kill_monitor(pid_t pid, char *devname, int sock)
170 {
171 char buf[100];
172 int fd;
173 int n;
174 long fl;
175
176 /* first rule of survival... don't off yourself */
177 if (pid == getpid())
178 return;
179
180 /* kill this process if it is mdmon */
181 sprintf(buf, "/proc/%lu/cmdline", (unsigned long) pid);
182 fd = open(buf, O_RDONLY);
183 if (fd < 0)
184 return;
185
186 n = read(fd, buf, sizeof(buf)-1);
187 buf[sizeof(buf)-1] = 0;
188 close(fd);
189
190 if (n < 0 || !strstr(buf, "mdmon"))
191 return;
192
193 kill(pid, SIGTERM);
194
195 /* Wait for monitor to exit by reading from the socket, after
196 * clearing the non-blocking flag */
197 fl = fcntl(sock, F_GETFL, 0);
198 fl &= ~O_NONBLOCK;
199 fcntl(sock, F_SETFL, fl);
200 read(sock, buf, 100);
201 }
202
203 void remove_pidfile(char *devname)
204 {
205 char buf[100];
206
207 if (sigterm)
208 return;
209
210 sprintf(buf, "/var/run/mdadm/%s.pid", devname);
211 unlink(buf);
212 sprintf(buf, "/var/run/mdadm/%s.sock", devname);
213 unlink(buf);
214 }
215
216 int make_control_sock(char *devname)
217 {
218 char path[100];
219 int sfd;
220 long fl;
221 struct sockaddr_un addr;
222
223 if (sigterm)
224 return -1;
225
226 sprintf(path, "/var/run/mdadm/%s.sock", devname);
227 unlink(path);
228 sfd = socket(PF_LOCAL, SOCK_STREAM, 0);
229 if (sfd < 0)
230 return -1;
231
232 addr.sun_family = PF_LOCAL;
233 strcpy(addr.sun_path, path);
234 if (bind(sfd, &addr, sizeof(addr)) < 0) {
235 close(sfd);
236 return -1;
237 }
238 listen(sfd, 10);
239 fl = fcntl(sfd, F_GETFL, 0);
240 fl |= O_NONBLOCK;
241 fcntl(sfd, F_SETFL, fl);
242 return sfd;
243 }
244
245 int socket_hup_requested;
246 static void hup(int sig)
247 {
248 socket_hup_requested = 1;
249 }
250
251 static void term(int sig)
252 {
253 sigterm = 1;
254 }
255
256 static void wake_me(int sig)
257 {
258
259 }
260
261 /* if we are debugging and starting mdmon by hand then don't fork */
262 static int do_fork(void)
263 {
264 #ifdef DEBUG
265 if (check_env("MDADM_NO_MDMON"))
266 return 0;
267 #endif
268
269 return 1;
270 }
271
272 void usage(void)
273 {
274 fprintf(stderr, "Usage: mdmon /device/name/for/container [target_dir]\n");
275 exit(2);
276 }
277
278 static int mdmon(char *devname, int devnum, int must_fork, char *switchroot);
279
280 int main(int argc, char *argv[])
281 {
282 char *container_name = NULL;
283 char *switchroot = NULL;
284 int devnum;
285 char *devname;
286 int status = 0;
287
288 switch (argc) {
289 case 3:
290 switchroot = argv[2];
291 case 2:
292 container_name = argv[1];
293 break;
294 default:
295 usage();
296 }
297
298 if (strcmp(container_name, "/proc/mdstat") == 0) {
299 struct mdstat_ent *mdstat, *e;
300
301 /* launch an mdmon instance for each container found */
302 mdstat = mdstat_read(0, 0);
303 for (e = mdstat; e; e = e->next) {
304 if (strncmp(e->metadata_version, "external:", 9) == 0 &&
305 !is_subarray(&e->metadata_version[9])) {
306 devname = devnum2devname(e->devnum);
307 /* update cmdline so this mdmon instance can be
308 * distinguished from others in a call to ps(1)
309 */
310 if (strlen(devname) <= strlen(container_name)) {
311 memset(container_name, 0, strlen(container_name));
312 sprintf(container_name, "%s", devname);
313 }
314 status |= mdmon(devname, e->devnum, 1,
315 switchroot);
316 }
317 }
318 free_mdstat(mdstat);
319
320 return status;
321 } else if (strncmp(container_name, "md", 2) == 0) {
322 devnum = devname2devnum(container_name);
323 devname = devnum2devname(devnum);
324 if (strcmp(container_name, devname) != 0)
325 devname = NULL;
326 } else {
327 struct stat st;
328
329 devnum = NoMdDev;
330 if (stat(container_name, &st) == 0)
331 devnum = stat2devnum(&st);
332 if (devnum == NoMdDev)
333 devname = NULL;
334 else
335 devname = devnum2devname(devnum);
336 }
337
338 if (!devname) {
339 fprintf(stderr, "mdmon: %s is not a valid md device name\n",
340 container_name);
341 exit(1);
342 }
343 return mdmon(devname, devnum, do_fork(), switchroot);
344 }
345
346 static int mdmon(char *devname, int devnum, int must_fork, char *switchroot)
347 {
348 int mdfd;
349 struct mdinfo *mdi, *di;
350 struct supertype *container;
351 sigset_t set;
352 struct sigaction act;
353 int pfd[2];
354 int status;
355 int ignore;
356 pid_t victim = -1;
357 int victim_sock = -1;
358
359 dprintf("starting mdmon for %s in %s\n",
360 devname, switchroot ? : "/");
361
362 /* switchroot is either a path name starting with '/', or a
363 * pid of the original mdmon (we have already done the chroot).
364 * In the latter case, stdin is a socket connected to the original
365 * mdmon.
366 */
367
368 /* try to spawn mdmon instances from the target file system */
369 if (switchroot && switchroot[0] == '/' &&
370 strcmp(switchroot, "/") != 0) {
371 pid_t pid;
372 char buf[20];
373
374 switch (fork()) {
375 case 0:
376 victim = devname2mdmon(devname);
377 victim_sock = connect_monitor(devname);
378 if (chroot(switchroot) != 0) {
379 fprintf(stderr, "mdmon: failed to chroot to '%s': %s\n",
380 switchroot, strerror(errno));
381 exit(4);
382 }
383 ignore = chdir("/");
384 sprintf(buf, "%d", victim);
385 if (victim_sock) {
386 close(0);
387 dup(victim_sock);
388 close(victim_sock);
389 }
390 execl("/sbin/mdmon", "mdmon", devname, buf, NULL);
391 exit(1);
392 case -1:
393 return 1;
394 default:
395 pid = wait(&status);
396 if (pid > -1 && WIFEXITED(status) &&
397 WEXITSTATUS(status) == 0)
398 return 0;
399 else
400 return 1;
401 }
402 }
403
404 mdfd = open_dev(devnum);
405 if (mdfd < 0) {
406 fprintf(stderr, "mdmon: %s: %s\n", devname,
407 strerror(errno));
408 return 1;
409 }
410 if (md_get_version(mdfd) < 0) {
411 fprintf(stderr, "mdmon: %s: Not an md device\n",
412 devname);
413 return 1;
414 }
415
416 /* Fork, and have the child tell us when they are ready */
417 if (must_fork) {
418 if (pipe(pfd) != 0) {
419 fprintf(stderr, "mdmon: failed to create pipe\n");
420 return 1;
421 }
422 switch(fork()) {
423 case -1:
424 fprintf(stderr, "mdmon: failed to fork: %s\n",
425 strerror(errno));
426 return 1;
427 case 0: /* child */
428 close(pfd[0]);
429 break;
430 default: /* parent */
431 close(pfd[1]);
432 if (read(pfd[0], &status, sizeof(status)) != sizeof(status)) {
433 wait(&status);
434 status = WEXITSTATUS(status);
435 }
436 return status;
437 }
438 } else
439 pfd[0] = pfd[1] = -1;
440
441 container = calloc(1, sizeof(*container));
442 container->devnum = devnum;
443 container->devname = devname;
444 container->arrays = NULL;
445 container->subarray[0] = 0;
446 container->sock = -1;
447
448 if (!container->devname) {
449 fprintf(stderr, "mdmon: failed to allocate container name string\n");
450 exit(3);
451 }
452
453 mdi = sysfs_read(mdfd, container->devnum,
454 GET_VERSION|GET_LEVEL|GET_DEVS|SKIP_GONE_DEVS);
455
456 if (!mdi) {
457 fprintf(stderr, "mdmon: failed to load sysfs info for %s\n",
458 container->devname);
459 exit(3);
460 }
461 if (mdi->array.level != UnSet) {
462 fprintf(stderr, "mdmon: %s is not a container - cannot monitor\n",
463 devname);
464 exit(3);
465 }
466 if (mdi->array.major_version != -1 ||
467 mdi->array.minor_version != -2) {
468 fprintf(stderr, "mdmon: %s does not use external metadata - cannot monitor\n",
469 devname);
470 exit(3);
471 }
472
473 container->ss = find_metadata_methods(mdi->text_version);
474 if (container->ss == NULL) {
475 fprintf(stderr, "mdmon: %s uses unknown metadata: %s\n",
476 devname, mdi->text_version);
477 exit(3);
478 }
479
480 container->devs = NULL;
481 for (di = mdi->devs; di; di = di->next) {
482 struct mdinfo *cd = malloc(sizeof(*cd));
483 *cd = *di;
484 cd->next = container->devs;
485 container->devs = cd;
486 }
487 sysfs_free(mdi);
488
489 /* SIGUSR is sent between parent and child. So both block it
490 * and enable it only with pselect.
491 */
492 sigemptyset(&set);
493 sigaddset(&set, SIGUSR1);
494 sigaddset(&set, SIGHUP);
495 sigaddset(&set, SIGALRM);
496 sigaddset(&set, SIGTERM);
497 sigprocmask(SIG_BLOCK, &set, NULL);
498 act.sa_handler = wake_me;
499 act.sa_flags = 0;
500 sigaction(SIGUSR1, &act, NULL);
501 sigaction(SIGALRM, &act, NULL);
502 act.sa_handler = hup;
503 sigaction(SIGHUP, &act, NULL);
504 act.sa_handler = term;
505 sigaction(SIGTERM, &act, NULL);
506 act.sa_handler = SIG_IGN;
507 sigaction(SIGPIPE, &act, NULL);
508
509 if (switchroot) {
510 /* we assume we assume that /sys /proc /dev are available in
511 * the new root
512 */
513 if (switchroot[0] == '/') {
514 victim = devname2mdmon(container->devname);
515 victim_sock = connect_monitor(container->devname);
516 } else {
517 victim = atoi(switchroot);
518 victim_sock = 0;
519 }
520 }
521
522 ignore = chdir("/");
523 if (victim < 0) {
524 if (ping_monitor(container->devname) == 0) {
525 fprintf(stderr, "mdmon: %s already managed\n",
526 container->devname);
527 exit(3);
528 }
529 /* if there is a pid file, kill whoever is there just in case */
530 victim = devname2mdmon(container->devname);
531 }
532 if (container->ss->load_super(container, mdfd, devname)) {
533 fprintf(stderr, "mdmon: Cannot load metadata for %s\n",
534 devname);
535 exit(3);
536 }
537 close(mdfd);
538
539 /* Ok, this is close enough. We can say goodbye to our parent now.
540 */
541 status = 0;
542 if (write(pfd[1], &status, sizeof(status)) < 0)
543 fprintf(stderr, "mdmon: failed to notify our parent: %d\n",
544 getppid());
545 close(pfd[1]);
546
547 mlockall(MCL_CURRENT | MCL_FUTURE);
548
549 if (clone_monitor(container) < 0) {
550 fprintf(stderr, "mdmon: failed to start monitor process: %s\n",
551 strerror(errno));
552 exit(2);
553 }
554
555 if (victim > -1) {
556 try_kill_monitor(victim, container->devname, victim_sock);
557 close(victim_sock);
558 }
559
560 setsid();
561 close(0);
562 open("/dev/null", O_RDWR);
563 close(1);
564 ignore = dup(0);
565 #ifndef DEBUG
566 close(2);
567 ignore = dup(0);
568 #endif
569
570 do_manager(container);
571
572 exit(0);
573 }