]>
git.ipfire.org Git - thirdparty/mdadm.git/blob - mdmon.c
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>
69 char const Name
[] = "mdmon";
71 struct active_array
*discard_this
;
72 struct active_array
*pending_discard
;
79 static void *run_child(void *v
)
81 struct supertype
*c
= v
;
83 mon_tid
= syscall(SYS_gettid
);
88 static int clone_monitor(struct supertype
*container
)
95 pthread_attr_init(&attr
);
96 pthread_attr_setstacksize(&attr
, 4096);
97 pthread_attr_setdetachstate(&attr
, PTHREAD_CREATE_DETACHED
);
98 rc
= pthread_create(&thread
, &attr
, run_child
, container
);
101 while (mon_tid
== -1)
102 sleep_for(0, USEC_TO_NSEC(10), true);
103 pthread_attr_destroy(&attr
);
105 mgr_tid
= syscall(SYS_gettid
);
109 #else /* USE_PTHREADS */
110 static int run_child(void *v
)
112 struct supertype
*c
= v
;
119 int __clone2(int (*fn
)(void *),
120 void *child_stack_base
, size_t stack_size
,
121 int flags
, void *arg
, ...
122 /* pid_t *pid, struct user_desc *tls, pid_t *ctid */ );
124 static int clone_monitor(struct supertype
*container
)
126 static char stack
[4096];
129 mon_tid
= __clone2(run_child
, stack
, sizeof(stack
),
130 CLONE_FS
|CLONE_FILES
|CLONE_VM
|CLONE_SIGHAND
|CLONE_THREAD
,
133 mon_tid
= clone(run_child
, stack
+4096-64,
134 CLONE_FS
|CLONE_FILES
|CLONE_VM
|CLONE_SIGHAND
|CLONE_THREAD
,
138 mgr_tid
= syscall(SYS_gettid
);
142 #endif /* USE_PTHREADS */
144 static int make_pidfile(char *devname
)
151 if (mkdir(MDMON_DIR
, 0755) < 0 &&
154 sprintf(path
, "%s/%s.pid", MDMON_DIR
, devname
);
156 fd
= open(path
, O_RDWR
|O_CREAT
|O_EXCL
, 0600);
159 sprintf(pid
, "%d\n", getpid());
160 n
= write(fd
, pid
, strlen(pid
));
167 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);
205 /* If there is I/O going on it might took some time to get to
206 * clean state. Wait for monitor to exit fully to avoid races.
207 * Ping it with SIGUSR1 in case that it is sleeping */
208 for (n
= 0; n
< 25; n
++) {
209 rv
= kill(pid
, SIGUSR1
);
212 sleep_for(0, MSEC_TO_NSEC(200), true);
216 void remove_pidfile(char *devname
)
220 sprintf(buf
, "%s/%s.pid", MDMON_DIR
, devname
);
222 sprintf(buf
, "%s/%s.sock", MDMON_DIR
, devname
);
226 static int make_control_sock(char *devname
)
231 struct sockaddr_un addr
;
236 sprintf(path
, "%s/%s.sock", MDMON_DIR
, devname
);
238 sfd
= socket(PF_LOCAL
, SOCK_STREAM
, 0);
242 addr
.sun_family
= PF_LOCAL
;
243 snprintf(addr
.sun_path
, sizeof(addr
.sun_path
), "%s", path
);
244 umask(077); /* ensure no world write access */
245 if (bind(sfd
, (struct sockaddr
*)&addr
, sizeof(addr
)) < 0) {
250 fl
= fcntl(sfd
, F_GETFL
, 0);
252 fcntl(sfd
, F_SETFL
, fl
);
256 static void term(int sig
)
261 static void wake_me(int sig
)
266 /* if we are debugging and starting mdmon by hand then don't fork */
267 static int do_fork(void)
270 if (check_env("MDADM_NO_MDMON"))
280 "Usage: mdmon [options] CONTAINER\n"
283 " --help -h : This message\n"
284 " --all -a : All devices\n"
285 " --foreground -F : Run in foreground (do not fork)\n"
286 " --takeover -t : Takeover container\n"
291 static bool is_duplicate_opt(const int opt
, const int set_val
, const char *long_name
)
293 if (opt
== set_val
) {
294 pr_err("--%s option duplicated!\n", long_name
);
300 static int mdmon(char *devnm
, int must_fork
, int takeover
);
302 int main(int argc
, char *argv
[])
304 char *container_name
= NULL
;
312 static struct option options
[] = {
313 {"all", 0, NULL
, 'a'},
314 {"takeover", 0, NULL
, 't'},
315 {"help", 0, NULL
, 'h'},
316 {"offroot", 0, NULL
, OffRootOpt
},
317 {"foreground", 0, NULL
, 'F'},
322 * mdmon should never complain due to lack of a platform,
323 * that is mdadm's job if at all.
325 imsm_set_no_platform(1);
327 while ((opt
= getopt_long(argc
, argv
, "thaF", options
, NULL
)) != -1) {
330 if (is_duplicate_opt(all
, 1, "all"))
332 container_name
= argv
[optind
-1];
336 if (is_duplicate_opt(takeover
, 1, "takeover"))
341 if (is_duplicate_opt(dofork
, 0, "foreground"))
346 if (is_duplicate_opt(argv
[0][0], '@', "offroot"))
351 if (is_duplicate_opt(help
, true, "help"))
363 * set first char of argv[0] to @. This is used by
364 * systemd to signal that the task was launched from
365 * initrd/initramfs and should be preserved during shutdown
370 if (!all
&& argv
[optind
]) {
371 static const char prefix
[] = "initrd/";
372 container_name
= argv
[optind
];
373 if (strncmp(container_name
, prefix
,
374 sizeof(prefix
) - 1) == 0)
375 container_name
+= sizeof(prefix
)-1;
376 container_name
= get_md_name(container_name
);
381 if (container_name
== NULL
|| argc
- optind
> 1)
384 if (strcmp(container_name
, "/proc/mdstat") == 0)
391 struct mdstat_ent
*mdstat
, *e
;
392 int container_len
= strnlen(container_name
, MD_NAME_MAX
);
394 /* launch an mdmon instance for each container found */
395 mdstat
= mdstat_read(0, 0);
396 for (e
= mdstat
; e
; e
= e
->next
) {
397 if (e
->metadata_version
&&
398 strncmp(e
->metadata_version
, "external:", 9) == 0 &&
399 !is_subarray(&e
->metadata_version
[9])) {
400 /* update cmdline so this mdmon instance can be
401 * distinguished from others in a call to ps(1)
403 if (strlen(e
->devnm
) <= (unsigned)container_len
) {
404 memset(container_name
, 0, container_len
);
405 sprintf(container_name
, "%s", e
->devnm
);
407 status
|= mdmon(e
->devnm
, 1, takeover
);
415 mdfd
= open_mddev(container_name
, 0);
416 if (is_fd_valid(mdfd
)) {
417 char *devnm
= fd2devnm(mdfd
);
422 return mdmon(devnm
, dofork
&& do_fork(), takeover
);
425 pr_err("%s is not a valid md device name\n", container_name
);
429 static int mdmon(char *devnm
, int must_fork
, int takeover
)
432 struct mdinfo
*mdi
, *di
;
433 struct supertype
*container
;
435 struct sigaction act
;
440 int victim_sock
= -1;
442 dprintf("starting mdmon for %s\n", devnm
);
444 mdfd
= open_dev(devnm
);
446 pr_err("%s: %s\n", devnm
, strerror(errno
));
450 /* Fork, and have the child tell us when they are ready */
452 if (pipe(pfd
) != 0) {
453 pr_err("failed to create pipe\n");
458 pr_err("failed to fork: %s\n", strerror(errno
));
463 default: /* parent */
465 if (read(pfd
[0], &status
, sizeof(status
)) != sizeof(status
)) {
467 status
= WEXITSTATUS(status
);
473 pfd
[0] = pfd
[1] = -1;
475 container
= xcalloc(1, sizeof(*container
));
476 snprintf(container
->devnm
, MD_NAME_MAX
, "%s", devnm
);
477 container
->arrays
= NULL
;
478 container
->sock
= -1;
480 mdi
= sysfs_read(mdfd
, container
->devnm
, GET_VERSION
|GET_LEVEL
|GET_DEVS
);
483 pr_err("failed to load sysfs info for %s\n", container
->devnm
);
486 if (mdi
->array
.level
!= UnSet
) {
487 pr_err("%s is not a container - cannot monitor\n", devnm
);
490 if (mdi
->array
.major_version
!= -1 ||
491 mdi
->array
.minor_version
!= -2) {
492 pr_err("%s does not use external metadata - cannot monitor\n",
497 container
->ss
= version_to_superswitch(mdi
->text_version
);
498 if (container
->ss
== NULL
) {
499 pr_err("%s uses unsupported metadata: %s\n",
500 devnm
, mdi
->text_version
);
504 container
->devs
= NULL
;
505 for (di
= mdi
->devs
; di
; di
= di
->next
) {
506 struct mdinfo
*cd
= xmalloc(sizeof(*cd
));
508 cd
->next
= container
->devs
;
509 container
->devs
= cd
;
513 /* SIGUSR is sent between parent and child. So both block it
514 * and enable it only with pselect.
517 sigaddset(&set
, SIGUSR1
);
518 sigaddset(&set
, SIGTERM
);
519 sigprocmask(SIG_BLOCK
, &set
, NULL
);
520 act
.sa_handler
= wake_me
;
522 sigaction(SIGUSR1
, &act
, NULL
);
523 act
.sa_handler
= term
;
524 sigaction(SIGTERM
, &act
, NULL
);
525 act
.sa_handler
= SIG_IGN
;
526 sigaction(SIGPIPE
, &act
, NULL
);
528 victim
= mdmon_pid(container
->devnm
);
530 victim_sock
= connect_monitor(container
->devnm
);
533 if (!takeover
&& victim
> 0 && victim_sock
>= 0) {
534 if (fping_monitor(victim_sock
) == 0) {
535 pr_err("%s already managed\n", container
->devnm
);
541 if (container
->ss
->load_container(container
, mdfd
, devnm
)) {
542 pr_err("Cannot load metadata for %s\n", devnm
);
547 /* Ok, this is close enough. We can say goodbye to our parent now.
550 remove_pidfile(devnm
);
551 if (make_pidfile(devnm
) < 0) {
554 container
->sock
= make_control_sock(devnm
);
558 if (write(pfd
[1], &status
, sizeof(status
)) < 0)
559 pr_err("failed to notify our parent: %d\n",
564 mlockall(MCL_CURRENT
| MCL_FUTURE
);
566 if (clone_monitor(container
) < 0) {
567 pr_err("failed to start monitor process: %s\n",
573 try_kill_monitor(victim
, container
->devnm
, victim_sock
);
574 if (victim_sock
>= 0)
581 /* This silliness is to stop the compiler complaining
582 * that we ignore 'ignore'
587 do_manager(container
);
592 /* Some stub functions so super-* can link with us */
593 int child_monitor(int afd
, struct mdinfo
*sra
, struct reshape
*reshape
,
594 struct supertype
*st
, unsigned long blocks
,
595 int *fds
, unsigned long long *offsets
,
596 int dests
, int *destfd
, unsigned long long *destoffsets
)
601 int restore_stripes(int *dest
, unsigned long long *offsets
,
602 int raid_disks
, int chunk_size
, int level
, int layout
,
603 int source
, unsigned long long read_offset
,
604 unsigned long long start
, unsigned long long length
,
610 int save_stripes(int *source
, unsigned long long *offsets
,
611 int raid_disks
, int chunk_size
, int level
, int layout
,
612 int nwrites
, int *dest
,
613 unsigned long long start
, unsigned long long length
,
619 struct superswitch super0
= {
622 struct superswitch super1
= {