]>
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>
67 struct active_array
*discard_this
;
68 struct active_array
*pending_discard
;
74 int run_child(void *v
)
76 struct supertype
*c
= v
;
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 */ );
88 int clone_monitor(struct supertype
*container
)
90 static char stack
[4096];
93 mon_tid
= __clone2(run_child
, stack
, sizeof(stack
),
94 CLONE_FS
|CLONE_FILES
|CLONE_VM
|CLONE_SIGHAND
|CLONE_THREAD
,
97 mon_tid
= clone(run_child
, stack
+4096-64,
98 CLONE_FS
|CLONE_FILES
|CLONE_VM
|CLONE_SIGHAND
|CLONE_THREAD
,
102 mgr_tid
= syscall(SYS_gettid
);
107 static struct superswitch
*find_metadata_methods(char *vers
)
109 if (strcmp(vers
, "ddf") == 0)
111 if (strcmp(vers
, "imsm") == 0)
116 static int test_pidfile(char *devname
)
121 sprintf(path
, "/var/run/mdadm/%s.pid", devname
);
122 return stat(path
, &st
);
125 int make_pidfile(char *devname
, int o_excl
)
135 sprintf(path
, "/var/run/mdadm/%s.pid", devname
);
137 fd
= open(path
, O_RDWR
|O_CREAT
|o_excl
, 0600);
140 sprintf(pid
, "%d\n", getpid());
141 n
= write(fd
, pid
, strlen(pid
));
148 int is_container_member(struct mdstat_ent
*mdstat
, char *container
)
150 if (mdstat
->metadata_version
== NULL
||
151 strncmp(mdstat
->metadata_version
, "external:", 9) != 0 ||
152 !is_subarray(mdstat
->metadata_version
+9) ||
153 strncmp(mdstat
->metadata_version
+10, container
, strlen(container
)) != 0 ||
154 mdstat
->metadata_version
[10+strlen(container
)] != '/')
160 pid_t
devname2mdmon(char *devname
)
166 sprintf(buf
, "/var/run/mdadm/%s.pid", devname
);
167 fd
= open(buf
, O_RDONLY
|O_NOATIME
);
171 if (read(fd
, buf
, sizeof(buf
)) > 0)
172 sscanf(buf
, "%d\n", &pid
);
178 static void try_kill_monitor(pid_t pid
, char *devname
, int sock
)
182 struct mdstat_ent
*mdstat
;
184 /* first rule of survival... don't off yourself */
188 /* kill this process if it is mdmon */
189 sprintf(buf
, "/proc/%lu/cmdline", (unsigned long) pid
);
190 fd
= open(buf
, O_RDONLY
);
194 if (read(fd
, buf
, sizeof(buf
)) < 0) {
199 if (!strstr(buf
, "mdmon"))
204 mdstat
= mdstat_read(0, 0);
205 for ( ; mdstat
; mdstat
= mdstat
->next
)
206 if (is_container_member(mdstat
, devname
)) {
207 sprintf(buf
, "/dev/%s", mdstat
->dev
);
208 WaitClean(buf
, sock
, 0);
213 void remove_pidfile(char *devname
)
220 sprintf(buf
, "/var/run/mdadm/%s.pid", devname
);
222 sprintf(buf
, "/var/run/mdadm/%s.sock", devname
);
226 int make_control_sock(char *devname
)
231 struct sockaddr_un addr
;
236 sprintf(path
, "/var/run/mdadm/%s.sock", devname
);
238 sfd
= socket(PF_LOCAL
, SOCK_STREAM
, 0);
242 addr
.sun_family
= PF_LOCAL
;
243 strcpy(addr
.sun_path
, path
);
244 if (bind(sfd
, &addr
, sizeof(addr
)) < 0) {
249 fl
= fcntl(sfd
, F_GETFL
, 0);
251 fcntl(sfd
, F_SETFL
, fl
);
255 int socket_hup_requested
;
256 static void hup(int sig
)
258 socket_hup_requested
= 1;
261 static void term(int sig
)
266 static void wake_me(int sig
)
271 /* if we are debugging and starting mdmon by hand then don't fork */
272 static int do_fork(void)
275 if (check_env("MDADM_NO_MDMON"))
284 fprintf(stderr
, "Usage: mdmon /device/name/for/container [target_dir]\n");
288 int mdmon(char *devname
, int devnum
, int scan
, char *switchroot
);
290 int main(int argc
, char *argv
[])
292 char *container_name
= NULL
;
293 char *switchroot
= NULL
;
301 switchroot
= argv
[2];
303 container_name
= argv
[1];
309 if (strcmp(container_name
, "/proc/mdstat") == 0) {
310 struct mdstat_ent
*mdstat
, *e
;
312 /* launch an mdmon instance for each container found */
314 mdstat
= mdstat_read(0, 0);
315 for (e
= mdstat
; e
; e
= e
->next
) {
316 if (strncmp(e
->metadata_version
, "external:", 9) == 0 &&
317 !is_subarray(&e
->metadata_version
[9])) {
318 devname
= devnum2devname(e
->devnum
);
319 /* update cmdline so this mdmon instance can be
320 * distinguished from others in a call to ps(1)
322 if (strlen(devname
) <= strlen(container_name
)) {
323 memset(container_name
, 0, strlen(container_name
));
324 sprintf(container_name
, "%s", devname
);
326 status
|= mdmon(devname
, e
->devnum
, scan
,
333 } else if (strncmp(container_name
, "md", 2) == 0) {
334 devnum
= devname2devnum(container_name
);
335 devname
= devnum2devname(devnum
);
336 if (strcmp(container_name
, devname
) != 0)
342 if (stat(container_name
, &st
) == 0)
343 devnum
= stat2devnum(&st
);
344 if (devnum
== NoMdDev
)
347 devname
= devnum2devname(devnum
);
351 fprintf(stderr
, "mdmon: %s is not a valid md device name\n",
355 return mdmon(devname
, devnum
, scan
, switchroot
);
358 int mdmon(char *devname
, int devnum
, int scan
, char *switchroot
)
361 struct mdinfo
*mdi
, *di
;
362 struct supertype
*container
;
364 struct sigaction act
;
369 int victim_sock
= -1;
371 dprintf("starting mdmon for %s in %s\n",
372 devname
, switchroot
? : "/");
374 /* try to spawn mdmon instances from the target file system */
375 if (switchroot
&& strcmp(switchroot
, "/") != 0) {
379 sprintf(path
, "%s/sbin/mdmon", switchroot
);
382 execl(path
, "mdmon", devname
, NULL
);
388 if (pid
> -1 && WIFEXITED(status
) &&
389 WEXITSTATUS(status
) == 0)
396 mdfd
= open_dev(devnum
);
398 fprintf(stderr
, "mdmon: %s: %s\n", devname
,
402 if (md_get_version(mdfd
) < 0) {
403 fprintf(stderr
, "mdmon: %s: Not an md device\n",
408 /* Fork, and have the child tell us when they are ready */
409 if (do_fork() || scan
) {
410 if (pipe(pfd
) != 0) {
411 fprintf(stderr
, "mdmon: failed to create pipe\n");
416 fprintf(stderr
, "mdmon: failed to fork: %s\n",
422 default: /* parent */
424 if (read(pfd
[0], &status
, sizeof(status
)) != sizeof(status
)) {
426 status
= WEXITSTATUS(status
);
431 pfd
[0] = pfd
[1] = -1;
433 container
= calloc(1, sizeof(*container
));
434 container
->devnum
= devnum
;
435 container
->devname
= devname
;
436 container
->arrays
= NULL
;
437 container
->subarray
[0] = 0;
438 container
->sock
= -1;
440 if (!container
->devname
) {
441 fprintf(stderr
, "mdmon: failed to allocate container name string\n");
445 mdi
= sysfs_read(mdfd
, container
->devnum
,
446 GET_VERSION
|GET_LEVEL
|GET_DEVS
|SKIP_GONE_DEVS
);
449 fprintf(stderr
, "mdmon: failed to load sysfs info for %s\n",
453 if (mdi
->array
.level
!= UnSet
) {
454 fprintf(stderr
, "mdmon: %s is not a container - cannot monitor\n",
458 if (mdi
->array
.major_version
!= -1 ||
459 mdi
->array
.minor_version
!= -2) {
460 fprintf(stderr
, "mdmon: %s does not use external metadata - cannot monitor\n",
465 container
->ss
= find_metadata_methods(mdi
->text_version
);
466 if (container
->ss
== NULL
) {
467 fprintf(stderr
, "mdmon: %s uses unknown metadata: %s\n",
468 devname
, mdi
->text_version
);
472 container
->devs
= NULL
;
473 for (di
= mdi
->devs
; di
; di
= di
->next
) {
474 struct mdinfo
*cd
= malloc(sizeof(*cd
));
476 cd
->next
= container
->devs
;
477 container
->devs
= cd
;
481 /* SIGUSR is sent between parent and child. So both block it
482 * and enable it only with pselect.
485 sigaddset(&set
, SIGUSR1
);
486 sigaddset(&set
, SIGHUP
);
487 sigaddset(&set
, SIGALRM
);
488 sigaddset(&set
, SIGTERM
);
489 sigprocmask(SIG_BLOCK
, &set
, NULL
);
490 act
.sa_handler
= wake_me
;
492 sigaction(SIGUSR1
, &act
, NULL
);
493 sigaction(SIGALRM
, &act
, NULL
);
494 act
.sa_handler
= hup
;
495 sigaction(SIGHUP
, &act
, NULL
);
496 act
.sa_handler
= term
;
497 sigaction(SIGTERM
, &act
, NULL
);
498 act
.sa_handler
= SIG_IGN
;
499 sigaction(SIGPIPE
, &act
, NULL
);
502 /* we assume we assume that /sys /proc /dev are available in
505 victim
= devname2mdmon(container
->devname
);
506 victim_sock
= connect_monitor(container
->devname
);
507 if (chroot(switchroot
) != 0) {
508 fprintf(stderr
, "mdmon: failed to chroot to '%s': %s\n",
509 switchroot
, strerror(errno
));
515 if (victim
< 0 && test_pidfile(container
->devname
) == 0) {
516 if (ping_monitor(container
->devname
) == 0) {
517 fprintf(stderr
, "mdmon: %s already managed\n",
520 } else if (victim
< 0)
521 victim
= devname2mdmon(container
->devname
);
523 if (container
->ss
->load_super(container
, mdfd
, devname
)) {
524 fprintf(stderr
, "mdmon: Cannot load metadata for %s\n",
530 /* Ok, this is close enough. We can say goodbye to our parent now.
533 if (write(pfd
[1], &status
, sizeof(status
)) < 0)
534 fprintf(stderr
, "mdmon: failed to notify our parent: %d\n",
540 open("/dev/null", O_RDWR
);
548 mlockall(MCL_CURRENT
| MCL_FUTURE
);
550 if (clone_monitor(container
) < 0) {
551 fprintf(stderr
, "mdmon: failed to start monitor process: %s\n",
557 try_kill_monitor(victim
, container
->devname
, victim_sock
);
560 do_manager(container
);