]>
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>
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(pid_dir
, 0700) < 0 &&
153 sprintf(path
, "%s/%s.pid", pid_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"))
192 /* Wait for monitor to exit by reading from the socket, after
193 * clearing the non-blocking flag */
194 fl
= fcntl(sock
, F_GETFL
, 0);
196 fcntl(sock
, F_SETFL
, fl
);
197 n
= read(sock
, buf
, 100);
198 /* Ignore result, it is just the wait that
203 void remove_pidfile(char *devname
)
207 sprintf(buf
, "%s/%s.pid", pid_dir
, devname
);
209 sprintf(buf
, "%s/%s.sock", pid_dir
, devname
);
211 if (strcmp(pid_dir
, ALT_RUN
) == 0)
212 /* try to clean up when we are finished with this dir */
216 static int make_control_sock(char *devname
)
221 struct sockaddr_un addr
;
226 sprintf(path
, "%s/%s.sock", pid_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"))
268 fprintf(stderr
, "Usage: mdmon [--all] [--takeover] CONTAINER\n");
272 static int mdmon(char *devname
, int devnum
, int must_fork
, int takeover
);
274 int main(int argc
, char *argv
[])
276 char *container_name
= NULL
;
284 for (arg
= 1; arg
< argc
; arg
++) {
285 if (strncmp(argv
[arg
], "--all",5) == 0 ||
286 strcmp(argv
[arg
], "/proc/mdstat") == 0) {
287 container_name
= argv
[arg
];
289 } else if (strcmp(argv
[arg
], "--takeover") == 0)
291 else if (container_name
== NULL
)
292 container_name
= argv
[arg
];
296 if (container_name
== NULL
)
300 struct mdstat_ent
*mdstat
, *e
;
301 int container_len
= strlen(container_name
);
303 /* launch an mdmon instance for each container found */
304 mdstat
= mdstat_read(0, 0);
305 for (e
= mdstat
; e
; e
= e
->next
) {
306 if (strncmp(e
->metadata_version
, "external:", 9) == 0 &&
307 !is_subarray(&e
->metadata_version
[9])) {
308 devname
= devnum2devname(e
->devnum
);
309 /* update cmdline so this mdmon instance can be
310 * distinguished from others in a call to ps(1)
312 if (strlen(devname
) <= container_len
) {
313 memset(container_name
, 0, container_len
);
314 sprintf(container_name
, "%s", devname
);
316 status
|= mdmon(devname
, e
->devnum
, 1,
323 } else if (strncmp(container_name
, "md", 2) == 0) {
324 devnum
= devname2devnum(container_name
);
325 devname
= devnum2devname(devnum
);
326 if (strcmp(container_name
, devname
) != 0)
332 if (stat(container_name
, &st
) == 0)
333 devnum
= stat2devnum(&st
);
334 if (devnum
== NoMdDev
)
337 devname
= devnum2devname(devnum
);
341 fprintf(stderr
, "mdmon: %s is not a valid md device name\n",
345 return mdmon(devname
, devnum
, do_fork(), takeover
);
348 static int mdmon(char *devname
, int devnum
, int must_fork
, int takeover
)
351 struct mdinfo
*mdi
, *di
;
352 struct supertype
*container
;
354 struct sigaction act
;
359 int victim_sock
= -1;
361 dprintf("starting mdmon for %s\n", devname
);
363 mdfd
= open_dev(devnum
);
365 fprintf(stderr
, "mdmon: %s: %s\n", devname
,
369 if (md_get_version(mdfd
) < 0) {
370 fprintf(stderr
, "mdmon: %s: Not an md device\n",
375 /* Fork, and have the child tell us when they are ready */
377 if (pipe(pfd
) != 0) {
378 fprintf(stderr
, "mdmon: failed to create pipe\n");
383 fprintf(stderr
, "mdmon: failed to fork: %s\n",
389 default: /* parent */
391 if (read(pfd
[0], &status
, sizeof(status
)) != sizeof(status
)) {
393 status
= WEXITSTATUS(status
);
398 pfd
[0] = pfd
[1] = -1;
400 container
= calloc(1, sizeof(*container
));
401 container
->devnum
= devnum
;
402 container
->devname
= devname
;
403 container
->arrays
= NULL
;
404 container
->subarray
[0] = 0;
405 container
->sock
= -1;
407 if (!container
->devname
) {
408 fprintf(stderr
, "mdmon: failed to allocate container name string\n");
412 mdi
= sysfs_read(mdfd
, container
->devnum
, GET_VERSION
|GET_LEVEL
|GET_DEVS
);
415 fprintf(stderr
, "mdmon: failed to load sysfs info for %s\n",
419 if (mdi
->array
.level
!= UnSet
) {
420 fprintf(stderr
, "mdmon: %s is not a container - cannot monitor\n",
424 if (mdi
->array
.major_version
!= -1 ||
425 mdi
->array
.minor_version
!= -2) {
426 fprintf(stderr
, "mdmon: %s does not use external metadata - cannot monitor\n",
431 container
->ss
= version_to_superswitch(mdi
->text_version
);
432 if (container
->ss
== NULL
) {
433 fprintf(stderr
, "mdmon: %s uses unsupported metadata: %s\n",
434 devname
, mdi
->text_version
);
438 container
->devs
= NULL
;
439 for (di
= mdi
->devs
; di
; di
= di
->next
) {
440 struct mdinfo
*cd
= malloc(sizeof(*cd
));
442 cd
->next
= container
->devs
;
443 container
->devs
= cd
;
447 /* SIGUSR is sent between parent and child. So both block it
448 * and enable it only with pselect.
451 sigaddset(&set
, SIGUSR1
);
452 sigaddset(&set
, SIGTERM
);
453 sigprocmask(SIG_BLOCK
, &set
, NULL
);
454 act
.sa_handler
= wake_me
;
456 sigaction(SIGUSR1
, &act
, NULL
);
457 act
.sa_handler
= term
;
458 sigaction(SIGTERM
, &act
, NULL
);
459 act
.sa_handler
= SIG_IGN
;
460 sigaction(SIGPIPE
, &act
, NULL
);
463 victim
= mdmon_pid(container
->devnum
);
466 victim
= mdmon_pid(container
->devnum
);
469 victim_sock
= connect_monitor(container
->devname
);
472 if (!takeover
&& victim
> 0 && victim_sock
>= 0) {
473 if (fping_monitor(victim_sock
) == 0) {
474 fprintf(stderr
, "mdmon: %s already managed\n",
480 if (container
->ss
->load_super(container
, mdfd
, devname
)) {
481 fprintf(stderr
, "mdmon: Cannot load metadata for %s\n",
487 /* Ok, this is close enough. We can say goodbye to our parent now.
490 remove_pidfile(devname
);
492 if (make_pidfile(devname
) < 0) {
493 /* Try the alternate */
495 if (make_pidfile(devname
) < 0) {
496 fprintf(stderr
, "mdmon: Neither %s nor %s are writable\n"
497 " cannot create .pid or .sock files. Aborting\n",
502 container
->sock
= make_control_sock(devname
);
505 if (write(pfd
[1], &status
, sizeof(status
)) < 0)
506 fprintf(stderr
, "mdmon: failed to notify our parent: %d\n",
510 mlockall(MCL_CURRENT
| MCL_FUTURE
);
512 if (clone_monitor(container
) < 0) {
513 fprintf(stderr
, "mdmon: failed to start monitor process: %s\n",
519 try_kill_monitor(victim
, container
->devname
, victim_sock
);
525 open("/dev/null", O_RDWR
);
533 do_manager(container
);