]>
git.ipfire.org Git - thirdparty/mdadm.git/blob - mdmon.c
c8a3341effc59ac0338f513cb03b6edb0671bcf3
4 * When md arrays have user-space managed metadata, this is the program
5 * that does the managing.
7 * Given one argument: the name of the array (e.g. /dev/md0) that is
9 * We fork off a helper that runs high priority and mlocked. It responds to
10 * device failures and other events that might stop writeout, or that are
11 * trivial to deal with.
12 * The main thread then watches for new arrays being created in the container
13 * and starts monitoring them too ... along with a few other tasks.
15 * The main thread communicates with the priority thread by writing over
17 * Separate programs can communicate with the main thread via Unix-domain
19 * The two threads share address space and open file table.
30 #include <sys/socket.h>
44 struct active_array
*discard_this
;
45 struct active_array
*pending_discard
;
46 struct md_generic_cmd
*active_cmd
;
48 int run_child(void *v
)
50 struct supertype
*c
= v
;
55 int clone_monitor(struct supertype
*container
)
57 static char stack
[4096];
60 rv
= pipe(container
->mgr_pipe
);
63 rv
= pipe(container
->mon_pipe
);
67 rv
= clone(run_child
, stack
+4096-64,
68 CLONE_FS
|CLONE_FILES
|CLONE_VM
|CLONE_SIGHAND
|CLONE_THREAD
,
76 close(container
->mon_pipe
[0]);
77 close(container
->mon_pipe
[1]);
79 close(container
->mgr_pipe
[0]);
80 close(container
->mgr_pipe
[1]);
85 static struct superswitch
*find_metadata_methods(char *vers
)
87 if (strcmp(vers
, "ddf") == 0)
93 static int make_pidfile(char *devname
, int o_excl
)
98 sprintf(path
, "/var/run/mdadm/%s.pid", devname
);
100 fd
= open(path
, O_RDWR
|O_CREAT
|o_excl
, 0600);
103 sprintf(pid
, "%d\n", getpid());
104 write(fd
, pid
, strlen(pid
));
109 static void try_kill_monitor(char *devname
)
115 sprintf(buf
, "/var/run/mdadm/%s.pid", devname
);
116 fd
= open(buf
, O_RDONLY
);
120 if (read(fd
, buf
, sizeof(buf
)) < 0) {
126 pid
= strtoul(buf
, NULL
, 10);
128 /* kill this process if it is mdmon */
129 sprintf(buf
, "/proc/%lu/cmdline", (unsigned long) pid
);
130 fd
= open(buf
, O_RDONLY
);
134 if (read(fd
, buf
, sizeof(buf
)) < 0) {
139 if (strstr(buf
, "mdmon") != NULL
)
143 static int make_control_sock(char *devname
)
148 struct sockaddr_un addr
;
150 sprintf(path
, "/var/run/mdadm/%s.sock", devname
);
152 sfd
= socket(PF_LOCAL
, SOCK_STREAM
, 0);
156 addr
.sun_family
= PF_LOCAL
;
157 strcpy(addr
.sun_path
, path
);
158 if (bind(sfd
, &addr
, sizeof(addr
)) < 0) {
163 fl
= fcntl(sfd
, F_GETFL
, 0);
165 fcntl(sfd
, F_SETFL
, fl
);
169 int main(int argc
, char *argv
[])
172 struct mdinfo
*mdi
, *di
;
173 struct supertype
*container
;
175 fprintf(stderr
, "Usage: md-manage /device/name/for/container\n");
178 mdfd
= open(argv
[1], O_RDWR
);
180 fprintf(stderr
, "md-manage: %s: %s\n", argv
[1],
184 if (md_get_version(mdfd
) < 0) {
185 fprintf(stderr
, "md-manage: %s: Not an md device\n",
190 /* hopefully it is a container - we'll check later */
192 container
= malloc(sizeof(*container
));
193 container
->devfd
= mdfd
;
194 container
->devnum
= fd2devnum(mdfd
);
195 container
->devname
= devnum2devname(container
->devnum
);
197 /* If this fails, we hope it already exists */
198 mkdir("/var/run/mdadm", 0600);
199 /* pid file lives in /var/run/mdadm/mdXX.pid */
200 if (make_pidfile(container
->devname
, O_EXCL
) < 0) {
201 if (ping_monitor(container
->devname
) == 0) {
202 fprintf(stderr
, "mdmon: %s already managed\n",
206 /* cleanup the old monitor, this one is taking over */
207 try_kill_monitor(container
->devname
);
208 if (make_pidfile(container
->devname
, 0) < 0) {
209 fprintf(stderr
, "mdmon: %s Cannot create pidfile\n",
216 container
->sock
= make_control_sock(container
->devname
);
217 if (container
->sock
< 0) {
218 fprintf(stderr
, "mdmon: Cannot create socket in /var/run/mdadm\n");
221 container
->arrays
= NULL
;
223 mdi
= sysfs_read(mdfd
, container
->devnum
,
224 GET_VERSION
|GET_LEVEL
|GET_DEVS
);
227 fprintf(stderr
, "mdmon: failed to load sysfs info for %s\n",
231 if (mdi
->array
.level
!= UnSet
) {
232 fprintf(stderr
, "mdmon: %s is not a container - cannot monitor\n",
236 if (mdi
->array
.major_version
!= -1 ||
237 mdi
->array
.minor_version
!= -2) {
238 fprintf(stderr
, "mdmon: %s does not use external metadata - cannot monitor\n",
243 container
->ss
= find_metadata_methods(mdi
->text_version
);
244 if (container
->ss
== NULL
) {
245 fprintf(stderr
, "mdmon: %s uses unknown metadata: %s\n",
246 argv
[1], mdi
->text_version
);
250 container
->devs
= NULL
;
251 for (di
= mdi
->devs
; di
; di
= di
->next
) {
252 struct mdinfo
*cd
= malloc(sizeof(*cd
));
254 cd
->next
= container
->devs
;
255 container
->devs
= cd
;
260 if (container
->ss
->load_super(container
, mdfd
, argv
[1])) {
261 fprintf(stderr
, "mdmon: Cannot load metadata for %s\n",
267 mlockall(MCL_FUTURE
);
269 if (clone_monitor(container
) < 0) {
270 fprintf(stderr
, "md-manage: failed to start monitor process: %s\n",
275 do_manager(container
);