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 char const Name[] = "mdmon";
72 struct active_array *discard_this;
73 struct active_array *pending_discard;
80 static void *run_child(void *v)
82 struct supertype *c = v;
84 mon_tid = syscall(SYS_gettid);
89 static int clone_monitor(struct supertype *container)
96 pthread_attr_init(&attr);
97 pthread_attr_setstacksize(&attr, 4096);
98 pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
99 rc = pthread_create(&thread, &attr, run_child, container);
102 while (mon_tid == -1)
104 pthread_attr_destroy(&attr);
106 mgr_tid = syscall(SYS_gettid);
110 #else /* USE_PTHREADS */
111 static int run_child(void *v)
113 struct supertype *c = v;
120 int __clone2(int (*fn)(void *),
121 void *child_stack_base, size_t stack_size,
122 int flags, void *arg, ...
123 /* pid_t *pid, struct user_desc *tls, pid_t *ctid */ );
125 static int clone_monitor(struct supertype *container)
127 static char stack[4096];
130 mon_tid = __clone2(run_child, stack, sizeof(stack),
131 CLONE_FS|CLONE_FILES|CLONE_VM|CLONE_SIGHAND|CLONE_THREAD,
134 mon_tid = clone(run_child, stack+4096-64,
135 CLONE_FS|CLONE_FILES|CLONE_VM|CLONE_SIGHAND|CLONE_THREAD,
139 mgr_tid = syscall(SYS_gettid);
143 #endif /* USE_PTHREADS */
145 static int make_pidfile(char *devname)
152 if (mkdir(MDMON_DIR, 0755) < 0 &&
155 sprintf(path, "%s/%s.pid", MDMON_DIR, devname);
157 fd = open(path, O_RDWR|O_CREAT|O_EXCL, 0600);
160 sprintf(pid, "%d\n", getpid());
161 n = write(fd, pid, strlen(pid));
168 static void try_kill_monitor(pid_t pid, char *devname, int sock)
175 /* first rule of survival... don't off yourself */
179 /* kill this process if it is mdmon */
180 sprintf(buf, "/proc/%lu/cmdline", (unsigned long) pid);
181 fd = open(buf, O_RDONLY);
185 n = read(fd, buf, sizeof(buf)-1);
186 buf[sizeof(buf)-1] = 0;
189 if (n < 0 || !(strstr(buf, "mdmon") ||
190 strstr(buf, "@dmon")))
198 /* Wait for monitor to exit by reading from the socket, after
199 * clearing the non-blocking flag */
200 fl = fcntl(sock, F_GETFL, 0);
202 fcntl(sock, F_SETFL, fl);
203 n = read(sock, buf, 100);
204 /* Ignore result, it is just the wait that
209 void remove_pidfile(char *devname)
213 sprintf(buf, "%s/%s.pid", MDMON_DIR, devname);
215 sprintf(buf, "%s/%s.sock", MDMON_DIR, devname);
219 static int make_control_sock(char *devname)
224 struct sockaddr_un addr;
229 sprintf(path, "%s/%s.sock", MDMON_DIR, devname);
231 sfd = socket(PF_LOCAL, SOCK_STREAM, 0);
235 addr.sun_family = PF_LOCAL;
236 strcpy(addr.sun_path, path);
237 umask(077); /* ensure no world write access */
238 if (bind(sfd, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
243 fl = fcntl(sfd, F_GETFL, 0);
245 fcntl(sfd, F_SETFL, fl);
249 static void term(int sig)
254 static void wake_me(int sig)
259 /* if we are debugging and starting mdmon by hand then don't fork */
260 static int do_fork(void)
263 if (check_env("MDADM_NO_MDMON"))
273 "Usage: mdmon [options] CONTAINER\n"
276 " --help -h : This message\n"
277 " --all -a : All devices\n"
278 " --foreground -F : Run in foreground (do not fork)\n"
279 " --takeover -t : Takeover container\n"
284 static int mdmon(char *devnm, int must_fork, int takeover);
286 int main(int argc, char *argv[])
288 char *container_name = NULL;
295 static struct option options[] = {
296 {"all", 0, NULL, 'a'},
297 {"takeover", 0, NULL, 't'},
298 {"help", 0, NULL, 'h'},
299 {"offroot", 0, NULL, OffRootOpt},
300 {"foreground", 0, NULL, 'F'},
306 * set first char of argv[0] to @. This is used by
307 * systemd to signal that the task was launched from
308 * initrd/initramfs and should be preserved during shutdown
313 while ((opt = getopt_long(argc, argv, "thaF", options, NULL)) != -1) {
316 container_name = argv[optind-1];
335 if (all == 0 && container_name == NULL) {
337 container_name = argv[optind];
340 if (container_name == NULL)
343 if (argc - optind > 1)
346 if (strcmp(container_name, "/proc/mdstat") == 0)
350 struct mdstat_ent *mdstat, *e;
351 int container_len = strlen(container_name);
353 /* launch an mdmon instance for each container found */
354 mdstat = mdstat_read(0, 0);
355 for (e = mdstat; e; e = e->next) {
356 if (e->metadata_version &&
357 strncmp(e->metadata_version, "external:", 9) == 0 &&
358 !is_subarray(&e->metadata_version[9])) {
359 /* update cmdline so this mdmon instance can be
360 * distinguished from others in a call to ps(1)
362 if (strlen(e->devnm) <= (unsigned)container_len) {
363 memset(container_name, 0, container_len);
364 sprintf(container_name, "%s", e->devnm);
366 status |= mdmon(e->devnm, 1, takeover);
372 } else if (strncmp(container_name, "md", 2) == 0) {
373 int id = devnm2devid(container_name);
375 devnm = container_name;
379 if (stat(container_name, &st) == 0)
380 devnm = xstrdup(stat2devnm(&st));
384 pr_err("%s is not a valid md device name\n",
388 return mdmon(devnm, dofork && do_fork(), takeover);
391 static int mdmon(char *devnm, int must_fork, int takeover)
394 struct mdinfo *mdi, *di;
395 struct supertype *container;
397 struct sigaction act;
402 int victim_sock = -1;
404 dprintf("starting mdmon for %s\n", devnm);
406 mdfd = open_dev(devnm);
408 pr_err("%s: %s\n", devnm, strerror(errno));
411 if (md_get_version(mdfd) < 0) {
412 pr_err("%s: Not an md device\n", devnm);
416 /* Fork, and have the child tell us when they are ready */
418 if (pipe(pfd) != 0) {
419 pr_err("failed to create pipe\n");
424 pr_err("failed to fork: %s\n", strerror(errno));
429 default: /* parent */
431 if (read(pfd[0], &status, sizeof(status)) != sizeof(status)) {
433 status = WEXITSTATUS(status);
439 pfd[0] = pfd[1] = -1;
441 container = xcalloc(1, sizeof(*container));
442 strcpy(container->devnm, devnm);
443 container->arrays = NULL;
444 container->sock = -1;
446 mdi = sysfs_read(mdfd, container->devnm, GET_VERSION|GET_LEVEL|GET_DEVS);
449 pr_err("failed to load sysfs info for %s\n", container->devnm);
452 if (mdi->array.level != UnSet) {
453 pr_err("%s is not a container - cannot monitor\n", devnm);
456 if (mdi->array.major_version != -1 ||
457 mdi->array.minor_version != -2) {
458 pr_err("%s does not use external metadata - cannot monitor\n",
463 container->ss = version_to_superswitch(mdi->text_version);
464 if (container->ss == NULL) {
465 pr_err("%s uses unsupported metadata: %s\n",
466 devnm, mdi->text_version);
470 container->devs = NULL;
471 for (di = mdi->devs; di; di = di->next) {
472 struct mdinfo *cd = xmalloc(sizeof(*cd));
474 cd->next = container->devs;
475 container->devs = cd;
479 /* SIGUSR is sent between parent and child. So both block it
480 * and enable it only with pselect.
483 sigaddset(&set, SIGUSR1);
484 sigaddset(&set, SIGTERM);
485 sigprocmask(SIG_BLOCK, &set, NULL);
486 act.sa_handler = wake_me;
488 sigaction(SIGUSR1, &act, NULL);
489 act.sa_handler = term;
490 sigaction(SIGTERM, &act, NULL);
491 act.sa_handler = SIG_IGN;
492 sigaction(SIGPIPE, &act, NULL);
494 victim = mdmon_pid(container->devnm);
496 victim_sock = connect_monitor(container->devnm);
499 if (!takeover && victim > 0 && victim_sock >= 0) {
500 if (fping_monitor(victim_sock) == 0) {
501 pr_err("%s already managed\n", container->devnm);
507 if (container->ss->load_container(container, mdfd, devnm)) {
508 pr_err("Cannot load metadata for %s\n", devnm);
513 /* Ok, this is close enough. We can say goodbye to our parent now.
516 remove_pidfile(devnm);
517 if (make_pidfile(devnm) < 0) {
520 container->sock = make_control_sock(devnm);
524 if (write(pfd[1], &status, sizeof(status)) < 0)
525 pr_err("failed to notify our parent: %d\n",
530 mlockall(MCL_CURRENT | MCL_FUTURE);
532 if (clone_monitor(container) < 0) {
533 pr_err("failed to start monitor process: %s\n",
539 try_kill_monitor(victim, container->devnm, victim_sock);
540 if (victim_sock >= 0)
546 open("/dev/null", O_RDWR);
554 /* This silliness is to stop the compiler complaining
555 * that we ignore 'ignore'
560 do_manager(container);
565 /* Some stub functions so super-* can link with us */
566 int child_monitor(int afd, struct mdinfo *sra, struct reshape *reshape,
567 struct supertype *st, unsigned long blocks,
568 int *fds, unsigned long long *offsets,
569 int dests, int *destfd, unsigned long long *destoffsets)
574 int restore_stripes(int *dest, unsigned long long *offsets,
575 int raid_disks, int chunk_size, int level, int layout,
576 int source, unsigned long long read_offset,
577 unsigned long long start, unsigned long long length,
583 void abort_reshape(struct mdinfo *sra)
588 int save_stripes(int *source, unsigned long long *offsets,
589 int raid_disks, int chunk_size, int level, int layout,
590 int nwrites, int *dest,
591 unsigned long long start, unsigned long long length,
597 struct superswitch super0 = {
600 struct superswitch super1 = {