xref: /freebsd/sys/contrib/openzfs/cmd/zed/zed.c (revision ec0ea6efa1ad229d75c394c1a9b9cac33af2b1d3)
1 /*
2  * This file is part of the ZFS Event Daemon (ZED).
3  *
4  * Developed at Lawrence Livermore National Laboratory (LLNL-CODE-403049).
5  * Copyright (C) 2013-2014 Lawrence Livermore National Security, LLC.
6  * Refer to the OpenZFS git commit log for authoritative copyright attribution.
7  *
8  * The contents of this file are subject to the terms of the
9  * Common Development and Distribution License Version 1.0 (CDDL-1.0).
10  * You can obtain a copy of the license from the top-level file
11  * "OPENSOLARIS.LICENSE" or at <http://opensource.org/licenses/CDDL-1.0>.
12  * You may not use this file except in compliance with the license.
13  */
14 
15 #include <errno.h>
16 #include <fcntl.h>
17 #include <signal.h>
18 #include <stdio.h>
19 #include <stdlib.h>
20 #include <string.h>
21 #include <sys/mman.h>
22 #include <sys/stat.h>
23 #include <unistd.h>
24 #include "zed.h"
25 #include "zed_conf.h"
26 #include "zed_event.h"
27 #include "zed_file.h"
28 #include "zed_log.h"
29 
30 static volatile sig_atomic_t _got_exit = 0;
31 static volatile sig_atomic_t _got_hup = 0;
32 
33 /*
34  * Signal handler for SIGINT & SIGTERM.
35  */
36 static void
37 _exit_handler(int signum)
38 {
39 	_got_exit = 1;
40 }
41 
42 /*
43  * Signal handler for SIGHUP.
44  */
45 static void
46 _hup_handler(int signum)
47 {
48 	_got_hup = 1;
49 }
50 
51 /*
52  * Register signal handlers.
53  */
54 static void
55 _setup_sig_handlers(void)
56 {
57 	struct sigaction sa;
58 
59 	if (sigemptyset(&sa.sa_mask) < 0)
60 		zed_log_die("Failed to initialize sigset");
61 
62 	sa.sa_flags = SA_RESTART;
63 
64 	sa.sa_handler = SIG_IGN;
65 	if (sigaction(SIGPIPE, &sa, NULL) < 0)
66 		zed_log_die("Failed to ignore SIGPIPE");
67 
68 	sa.sa_handler = _exit_handler;
69 	if (sigaction(SIGINT, &sa, NULL) < 0)
70 		zed_log_die("Failed to register SIGINT handler");
71 
72 	if (sigaction(SIGTERM, &sa, NULL) < 0)
73 		zed_log_die("Failed to register SIGTERM handler");
74 
75 	sa.sa_handler = _hup_handler;
76 	if (sigaction(SIGHUP, &sa, NULL) < 0)
77 		zed_log_die("Failed to register SIGHUP handler");
78 
79 	(void) sigaddset(&sa.sa_mask, SIGCHLD);
80 	if (pthread_sigmask(SIG_BLOCK, &sa.sa_mask, NULL) < 0)
81 		zed_log_die("Failed to block SIGCHLD");
82 }
83 
84 /*
85  * Lock all current and future pages in the virtual memory address space.
86  * Access to locked pages will never be delayed by a page fault.
87  *
88  * EAGAIN is tested up to max_tries in case this is a transient error.
89  *
90  * Note that memory locks are not inherited by a child created via fork()
91  * and are automatically removed during an execve().  As such, this must
92  * be called after the daemon fork()s (when running in the background).
93  */
94 static void
95 _lock_memory(void)
96 {
97 #if HAVE_MLOCKALL
98 	int i = 0;
99 	const int max_tries = 10;
100 
101 	for (i = 0; i < max_tries; i++) {
102 		if (mlockall(MCL_CURRENT | MCL_FUTURE) == 0) {
103 			zed_log_msg(LOG_INFO, "Locked all pages in memory");
104 			return;
105 		}
106 		if (errno != EAGAIN)
107 			break;
108 	}
109 	zed_log_die("Failed to lock memory pages: %s", strerror(errno));
110 
111 #else /* HAVE_MLOCKALL */
112 	zed_log_die("Failed to lock memory pages: mlockall() not supported");
113 #endif /* HAVE_MLOCKALL */
114 }
115 
116 /*
117  * Start daemonization of the process including the double fork().
118  *
119  * The parent process will block here until _finish_daemonize() is called
120  * (in the grandchild process), at which point the parent process will exit.
121  * This prevents the parent process from exiting until initialization is
122  * complete.
123  */
124 static void
125 _start_daemonize(void)
126 {
127 	pid_t pid;
128 	struct sigaction sa;
129 
130 	/* Create pipe for communicating with child during daemonization. */
131 	zed_log_pipe_open();
132 
133 	/* Background process and ensure child is not process group leader. */
134 	pid = fork();
135 	if (pid < 0) {
136 		zed_log_die("Failed to create child process: %s",
137 		    strerror(errno));
138 	} else if (pid > 0) {
139 
140 		/* Close writes since parent will only read from pipe. */
141 		zed_log_pipe_close_writes();
142 
143 		/* Wait for notification that daemonization is complete. */
144 		zed_log_pipe_wait();
145 
146 		zed_log_pipe_close_reads();
147 		_exit(EXIT_SUCCESS);
148 	}
149 
150 	/* Close reads since child will only write to pipe. */
151 	zed_log_pipe_close_reads();
152 
153 	/* Create independent session and detach from terminal. */
154 	if (setsid() < 0)
155 		zed_log_die("Failed to create new session: %s",
156 		    strerror(errno));
157 
158 	/* Prevent child from terminating on HUP when session leader exits. */
159 	if (sigemptyset(&sa.sa_mask) < 0)
160 		zed_log_die("Failed to initialize sigset");
161 
162 	sa.sa_flags = 0;
163 	sa.sa_handler = SIG_IGN;
164 
165 	if (sigaction(SIGHUP, &sa, NULL) < 0)
166 		zed_log_die("Failed to ignore SIGHUP");
167 
168 	/* Ensure process cannot re-acquire terminal. */
169 	pid = fork();
170 	if (pid < 0) {
171 		zed_log_die("Failed to create grandchild process: %s",
172 		    strerror(errno));
173 	} else if (pid > 0) {
174 		_exit(EXIT_SUCCESS);
175 	}
176 }
177 
178 /*
179  * Finish daemonization of the process by closing stdin/stdout/stderr.
180  *
181  * This must be called at the end of initialization after all external
182  * communication channels are established and accessible.
183  */
184 static void
185 _finish_daemonize(void)
186 {
187 	int devnull;
188 
189 	/* Preserve fd 0/1/2, but discard data to/from stdin/stdout/stderr. */
190 	devnull = open("/dev/null", O_RDWR);
191 	if (devnull < 0)
192 		zed_log_die("Failed to open /dev/null: %s", strerror(errno));
193 
194 	if (dup2(devnull, STDIN_FILENO) < 0)
195 		zed_log_die("Failed to dup /dev/null onto stdin: %s",
196 		    strerror(errno));
197 
198 	if (dup2(devnull, STDOUT_FILENO) < 0)
199 		zed_log_die("Failed to dup /dev/null onto stdout: %s",
200 		    strerror(errno));
201 
202 	if (dup2(devnull, STDERR_FILENO) < 0)
203 		zed_log_die("Failed to dup /dev/null onto stderr: %s",
204 		    strerror(errno));
205 
206 	if ((devnull > STDERR_FILENO) && (close(devnull) < 0))
207 		zed_log_die("Failed to close /dev/null: %s", strerror(errno));
208 
209 	/* Notify parent that daemonization is complete. */
210 	zed_log_pipe_close_writes();
211 }
212 
213 /*
214  * ZFS Event Daemon (ZED).
215  */
216 int
217 main(int argc, char *argv[])
218 {
219 	struct zed_conf zcp;
220 	uint64_t saved_eid;
221 	int64_t saved_etime[2];
222 
223 	zed_log_init(argv[0]);
224 	zed_log_stderr_open(LOG_NOTICE);
225 	zed_conf_init(&zcp);
226 	zed_conf_parse_opts(&zcp, argc, argv);
227 	if (zcp.do_verbose)
228 		zed_log_stderr_open(LOG_INFO);
229 
230 	if (geteuid() != 0)
231 		zed_log_die("Must be run as root");
232 
233 	zed_file_close_from(STDERR_FILENO + 1);
234 
235 	(void) umask(0);
236 
237 	if (chdir("/") < 0)
238 		zed_log_die("Failed to change to root directory");
239 
240 	if (zed_conf_scan_dir(&zcp) < 0)
241 		exit(EXIT_FAILURE);
242 
243 	if (!zcp.do_foreground) {
244 		_start_daemonize();
245 		zed_log_syslog_open(LOG_DAEMON);
246 	}
247 	_setup_sig_handlers();
248 
249 	if (zcp.do_memlock)
250 		_lock_memory();
251 
252 	if ((zed_conf_write_pid(&zcp) < 0) && (!zcp.do_force))
253 		exit(EXIT_FAILURE);
254 
255 	if (!zcp.do_foreground)
256 		_finish_daemonize();
257 
258 	zed_log_msg(LOG_NOTICE,
259 	    "ZFS Event Daemon %s-%s (PID %d)",
260 	    ZFS_META_VERSION, ZFS_META_RELEASE, (int)getpid());
261 
262 	if (zed_conf_open_state(&zcp) < 0)
263 		exit(EXIT_FAILURE);
264 
265 	if (zed_conf_read_state(&zcp, &saved_eid, saved_etime) < 0)
266 		exit(EXIT_FAILURE);
267 
268 idle:
269 	/*
270 	 * If -I is specified, attempt to open /dev/zfs repeatedly until
271 	 * successful.
272 	 */
273 	do {
274 		if (!zed_event_init(&zcp))
275 			break;
276 		/* Wait for some time and try again. tunable? */
277 		sleep(30);
278 	} while (!_got_exit && zcp.do_idle);
279 
280 	if (_got_exit)
281 		goto out;
282 
283 	zed_event_seek(&zcp, saved_eid, saved_etime);
284 
285 	while (!_got_exit) {
286 		int rv;
287 		if (_got_hup) {
288 			_got_hup = 0;
289 			(void) zed_conf_scan_dir(&zcp);
290 		}
291 		rv = zed_event_service(&zcp);
292 
293 		/* ENODEV: When kernel module is unloaded (osx) */
294 		if (rv != 0)
295 			break;
296 	}
297 
298 	zed_log_msg(LOG_NOTICE, "Exiting");
299 	zed_event_fini(&zcp);
300 
301 	if (zcp.do_idle && !_got_exit)
302 		goto idle;
303 
304 out:
305 	zed_conf_destroy(&zcp);
306 	zed_log_fini();
307 	exit(EXIT_SUCCESS);
308 }
309