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.
23 * When md arrays have user-space managed metadata, this is the program
24 * that does the managing.
26 * Given one argument: the name of the array (e.g. /dev/md0) that is
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.
34 * The main thread communicates with the priority thread by writing over
36 * Separate programs can communicate with the main thread via Unix-domain
38 * The two threads share address space and open file table.
48 #include <sys/types.h>
50 #include <sys/socket.h>
53 #include <sys/syscall.h>
70 struct active_array *discard_this;
71 struct active_array *pending_discard;
78 static void *run_child(void *v)
80 struct supertype *c = v;
82 mon_tid = syscall(SYS_gettid);
87 static int clone_monitor(struct supertype *container)
94 pthread_attr_init(&attr);
95 pthread_attr_setstacksize(&attr, 4096);
96 pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
97 rc = pthread_create(&thread, &attr, run_child, container);
100 while (mon_tid == -1)
102 pthread_attr_destroy(&attr);
104 mgr_tid = syscall(SYS_gettid);
108 #else /* USE_PTHREADS */
109 static int run_child(void *v)
111 struct supertype *c = v;
118 int __clone2(int (*fn)(void *),
119 void *child_stack_base, size_t stack_size,
120 int flags, void *arg, ...
121 /* pid_t *pid, struct user_desc *tls, pid_t *ctid */ );
123 static int clone_monitor(struct supertype *container)
125 static char stack[4096];
128 mon_tid = __clone2(run_child, stack, sizeof(stack),
129 CLONE_FS|CLONE_FILES|CLONE_VM|CLONE_SIGHAND|CLONE_THREAD,
132 mon_tid = clone(run_child, stack+4096-64,
133 CLONE_FS|CLONE_FILES|CLONE_VM|CLONE_SIGHAND|CLONE_THREAD,
137 mgr_tid = syscall(SYS_gettid);
141 #endif /* USE_PTHREADS */
143 static int make_pidfile(char *devname)
150 if (mkdir(MDMON_DIR, 0755) < 0 &&
153 sprintf(path, "%s/%s.pid", MDMON_DIR, devname);
155 fd = open(path, O_RDWR|O_CREAT|O_EXCL, 0600);
158 sprintf(pid, "%d\n", getpid());
159 n = write(fd, pid, strlen(pid));
166 static void try_kill_monitor(pid_t pid, char *devname, int sock)
173 /* first rule of survival... don't off yourself */
177 /* kill this process if it is mdmon */
178 sprintf(buf, "/proc/%lu/cmdline", (unsigned long) pid);
179 fd = open(buf, O_RDONLY);
183 n = read(fd, buf, sizeof(buf)-1);
184 buf[sizeof(buf)-1] = 0;
187 if (n < 0 || !strstr(buf, "mdmon"))
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);
199 fcntl(sock, F_SETFL, fl);
200 n = read(sock, buf, 100);
201 /* Ignore result, it is just the wait that
206 void remove_pidfile(char *devname)
210 sprintf(buf, "%s/%s.pid", MDMON_DIR, devname);
212 sprintf(buf, "%s/%s.sock", MDMON_DIR, devname);
216 static int make_control_sock(char *devname)
221 struct sockaddr_un addr;
226 sprintf(path, "%s/%s.sock", MDMON_DIR, devname);
228 sfd = socket(PF_LOCAL, SOCK_STREAM, 0);
232 addr.sun_family = PF_LOCAL;
233 strcpy(addr.sun_path, path);
234 if (bind(sfd, &addr, sizeof(addr)) < 0) {
239 fl = fcntl(sfd, F_GETFL, 0);
241 fcntl(sfd, F_SETFL, fl);
245 static void term(int sig)
250 static void wake_me(int sig)
255 /* if we are debugging and starting mdmon by hand then don't fork */
256 static int do_fork(void)
259 if (check_env("MDADM_NO_MDMON"))
269 "Usage: mdmon [options] CONTAINER\n"
272 " --help -h : This message\n"
273 " --all : All devices\n"
274 " --takeover -t : Takeover container\n"
275 " --offroot : Set first character of argv[0] to @ to indicate the\n"
276 " application was launched from initrd/initramfs and\n"
277 " should not be shutdown by systemd as part of the\n"
278 " regular shutdown process.\n"
283 static int mdmon(char *devname, int devnum, int must_fork, int takeover);
285 int main(int argc, char *argv[])
287 char *container_name = NULL;
294 static struct option options[] = {
295 {"all", 0, NULL, 'a'},
296 {"takeover", 0, NULL, 't'},
297 {"help", 0, NULL, 'h'},
298 {"offroot", 0, NULL, OffRootOpt},
302 while ((opt = getopt_long(argc, argv, "th", options, NULL)) != -1) {
305 container_name = argv[optind-1];
309 container_name = optarg;
322 if (all == 0 && container_name == NULL) {
324 container_name = argv[optind];
327 if (container_name == NULL)
330 if (argc - optind > 1)
333 if (strcmp(container_name, "/proc/mdstat") == 0)
337 struct mdstat_ent *mdstat, *e;
338 int container_len = strlen(container_name);
340 /* launch an mdmon instance for each container found */
341 mdstat = mdstat_read(0, 0);
342 for (e = mdstat; e; e = e->next) {
343 if (e->metadata_version &&
344 strncmp(e->metadata_version, "external:", 9) == 0 &&
345 !is_subarray(&e->metadata_version[9])) {
346 devname = devnum2devname(e->devnum);
347 /* update cmdline so this mdmon instance can be
348 * distinguished from others in a call to ps(1)
350 if (strlen(devname) <= (unsigned)container_len) {
351 memset(container_name, 0, container_len);
352 sprintf(container_name, "%s", devname);
354 status |= mdmon(devname, e->devnum, 1,
361 } else if (strncmp(container_name, "md", 2) == 0) {
362 devnum = devname2devnum(container_name);
363 devname = devnum2devname(devnum);
364 if (strcmp(container_name, devname) != 0)
370 if (stat(container_name, &st) == 0)
371 devnum = stat2devnum(&st);
372 if (devnum == NoMdDev)
375 devname = devnum2devname(devnum);
379 fprintf(stderr, "mdmon: %s is not a valid md device name\n",
383 return mdmon(devname, devnum, do_fork(), takeover);
386 static int mdmon(char *devname, int devnum, int must_fork, int takeover)
389 struct mdinfo *mdi, *di;
390 struct supertype *container;
392 struct sigaction act;
397 int victim_sock = -1;
399 dprintf("starting mdmon for %s\n", devname);
401 mdfd = open_dev(devnum);
403 fprintf(stderr, "mdmon: %s: %s\n", devname,
407 if (md_get_version(mdfd) < 0) {
408 fprintf(stderr, "mdmon: %s: Not an md device\n",
413 /* Fork, and have the child tell us when they are ready */
415 if (pipe(pfd) != 0) {
416 fprintf(stderr, "mdmon: failed to create pipe\n");
421 fprintf(stderr, "mdmon: failed to fork: %s\n",
427 default: /* parent */
429 if (read(pfd[0], &status, sizeof(status)) != sizeof(status)) {
431 status = WEXITSTATUS(status);
436 pfd[0] = pfd[1] = -1;
438 container = calloc(1, sizeof(*container));
439 container->devnum = devnum;
440 container->devname = devname;
441 container->arrays = NULL;
442 container->sock = -1;
444 if (!container->devname) {
445 fprintf(stderr, "mdmon: failed to allocate container name string\n");
449 mdi = sysfs_read(mdfd, container->devnum, GET_VERSION|GET_LEVEL|GET_DEVS);
452 fprintf(stderr, "mdmon: failed to load sysfs info for %s\n",
456 if (mdi->array.level != UnSet) {
457 fprintf(stderr, "mdmon: %s is not a container - cannot monitor\n",
461 if (mdi->array.major_version != -1 ||
462 mdi->array.minor_version != -2) {
463 fprintf(stderr, "mdmon: %s does not use external metadata - cannot monitor\n",
468 container->ss = version_to_superswitch(mdi->text_version);
469 if (container->ss == NULL) {
470 fprintf(stderr, "mdmon: %s uses unsupported metadata: %s\n",
471 devname, mdi->text_version);
475 container->devs = NULL;
476 for (di = mdi->devs; di; di = di->next) {
477 struct mdinfo *cd = malloc(sizeof(*cd));
479 cd->next = container->devs;
480 container->devs = cd;
484 /* SIGUSR is sent between parent and child. So both block it
485 * and enable it only with pselect.
488 sigaddset(&set, SIGUSR1);
489 sigaddset(&set, SIGTERM);
490 sigprocmask(SIG_BLOCK, &set, NULL);
491 act.sa_handler = wake_me;
493 sigaction(SIGUSR1, &act, NULL);
494 act.sa_handler = term;
495 sigaction(SIGTERM, &act, NULL);
496 act.sa_handler = SIG_IGN;
497 sigaction(SIGPIPE, &act, NULL);
499 victim = mdmon_pid(container->devnum);
501 victim_sock = connect_monitor(container->devname);
504 if (!takeover && victim > 0 && victim_sock >= 0) {
505 if (fping_monitor(victim_sock) == 0) {
506 fprintf(stderr, "mdmon: %s already managed\n",
513 if (container->ss->load_container(container, mdfd, devname)) {
514 fprintf(stderr, "mdmon: Cannot load metadata for %s\n",
520 /* Ok, this is close enough. We can say goodbye to our parent now.
523 remove_pidfile(devname);
524 if (make_pidfile(devname) < 0) {
527 container->sock = make_control_sock(devname);
530 if (write(pfd[1], &status, sizeof(status)) < 0)
531 fprintf(stderr, "mdmon: failed to notify our parent: %d\n",
535 mlockall(MCL_CURRENT | MCL_FUTURE);
537 if (clone_monitor(container) < 0) {
538 fprintf(stderr, "mdmon: failed to start monitor process: %s\n",
544 try_kill_monitor(victim, container->devname, victim_sock);
545 if (victim_sock >= 0)
551 open("/dev/null", O_RDWR);
559 /* This silliness is to stop the compiler complaining
560 * that we ignore 'ignore'
565 do_manager(container);
570 /* Some stub functions so super-* can link with us */
571 int child_monitor(int afd, struct mdinfo *sra, struct reshape *reshape,
572 struct supertype *st, unsigned long blocks,
573 int *fds, unsigned long long *offsets,
574 int dests, int *destfd, unsigned long long *destoffsets)
579 int restore_stripes(int *dest, unsigned long long *offsets,
580 int raid_disks, int chunk_size, int level, int layout,
581 int source, unsigned long long read_offset,
582 unsigned long long start, unsigned long long length,
588 void abort_reshape(struct mdinfo *sra)
593 int save_stripes(int *source, unsigned long long *offsets,
594 int raid_disks, int chunk_size, int level, int layout,
595 int nwrites, int *dest,
596 unsigned long long start, unsigned long long length,