2 This file is part of elogind.
4 Copyright 2017 Sven Eden
6 elogind is free software; you can redistribute it and/or modify it
7 under the terms of the GNU Lesser General Public License as published by
8 the Free Software Foundation; either version 2.1 of the License, or
9 (at your option) any later version.
11 elogind is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Lesser General Public License for more details.
16 You should have received a copy of the GNU Lesser General Public License
17 along with elogind; If not, see <http://www.gnu.org/licenses/>.
27 #include "mount-setup.h"
28 #include "parse-util.h"
29 #include "process-util.h"
30 #include "signal-util.h"
31 #include "socket-util.h"
32 #include "stdio-util.h"
33 #include "string-util.h"
35 #include "umask-util.h"
38 #define CGROUPS_AGENT_RCVBUF_SIZE (8*1024*1024)
39 #ifndef ELOGIND_PID_FILE
40 # define ELOGIND_PID_FILE "/run/elogind.pid"
41 #endif // ELOGIND_PID_FILE
44 static int elogind_signal_handler(sd_event_source *s,
45 const struct signalfd_siginfo *si,
47 Manager *m = userdata;
50 log_warning("Received signal %u [%s]", si->ssi_signo,
51 signal_to_string(si->ssi_signo));
53 r = sd_event_get_state(m->event);
55 if (r != SD_EVENT_FINISHED)
56 sd_event_exit(m->event, si->ssi_signo);
62 static void remove_pid_file(void) {
63 if (access(ELOGIND_PID_FILE, F_OK) == 0)
64 unlink_noerrno(ELOGIND_PID_FILE);
68 static void write_pid_file(void) {
69 char c[DECIMAL_STR_MAX(pid_t) + 2];
73 pid = getpid_cached();
75 xsprintf(c, PID_FMT "\n", pid);
77 r = write_string_file(ELOGIND_PID_FILE, c,
78 WRITE_STRING_FILE_CREATE |
79 WRITE_STRING_FILE_VERIFY_ON_FAILURE);
81 log_error_errno(-r, "Failed to write PID file %s: %m",
84 /* Make sure the PID file gets cleaned up on exit! */
85 atexit(remove_pid_file);
89 /** daemonize elogind by double forking.
90 * The grand child returns 0.
91 * The parent and child return their forks PID.
92 * On error, a value < 0 is returned.
94 static int elogind_daemonize(void) {
100 #ifdef ENABLE_DEBUG_ELOGIND
101 log_notice("Double forking elogind");
102 log_notice("Parent PID : %5d", getpid_cached());
103 log_notice("Parent SID : %5d", getsid(getpid_cached()));
104 #endif // ENABLE_DEBUG_ELOGIND
106 r = safe_fork_full("daemon leader", NULL, 0, FORK_RESET_SIGNALS|FORK_DEATHSIG|FORK_CLOSE_ALL_FDS|FORK_WAIT, &child);
109 return log_error_errno(errno, "Failed to fork daemon leader: %m");
111 /* safe_fork_full() Has waited for the child to terminate, so we
112 * are safe to return here. The child already has forked off the
118 #ifdef ENABLE_DEBUG_ELOGIND
119 log_notice("Child PID : %5d", getpid_cached());
120 log_notice("Child SID : %5d", getsid(getpid_cached()));
121 #endif // ENABLE_DEBUG_ELOGIND
123 /* safe_fork_full() does not close stdin/stdout/stderr */
129 if ((pid_t)-1 == SID)
130 return log_error_errno(errno, "Failed to create new SID: %m");
132 #ifdef ENABLE_DEBUG_ELOGIND
133 log_notice("Child new SID : %5d", getsid(getpid_cached()));
134 #endif // ENABLE_DEBUG_ELOGIND
138 /* Now the grandchild, the true daemon, can be created. */
139 r = safe_fork_full("daemon leader", NULL, 0, FORK_RESET_SIGNALS|FORK_DEATHSIG|FORK_CLOSE_ALL_FDS, &grandchild);
142 return log_error_errno(errno, "Failed to fork daemon: %m");
145 /* Exit immediately! */
148 /* safe_fork_full() does not close stdin/stdout/stderr */
155 #ifdef ENABLE_DEBUG_ELOGIND
156 log_notice("Grand child PID: %5d", getpid_cached());
157 log_notice("Grand child SID: %5d", getsid(getpid_cached()));
158 #endif // ENABLE_DEBUG_ELOGIND
160 /* Take care of our PID-file now */
167 /// Simple tool to see, if elogind is already running
168 static pid_t elogind_is_already_running(bool need_pid_file) {
169 _cleanup_free_ char *s = NULL;
173 r = read_one_line_file(ELOGIND_PID_FILE, &s);
178 r = safe_atoi32(s, &pid);
183 if ( (pid != getpid_cached()) && pid_is_alive(pid))
188 /* Take care of our PID-file now.
189 If the user is going to fork elogind, the PID file
190 will be overwritten. */
198 static int manager_dispatch_cgroups_agent_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
199 Manager *m = userdata;
200 char buf[PATH_MAX+1];
203 n = recv(fd, buf, sizeof(buf), 0);
205 return log_error_errno(errno, "Failed to read cgroups agent message: %m");
207 log_error("Got zero-length cgroups agent message, ignoring.");
210 if ((size_t) n >= sizeof(buf)) {
211 log_error("Got overly long cgroups agent message, ignoring.");
215 if (memchr(buf, 0, n)) {
216 log_error("Got cgroups agent message with embedded NUL byte, ignoring.");
221 manager_notify_cgroup_empty(m, buf);
227 /// Add-On for manager_connect_bus()
228 /// Original: src/core/manager.c:manager_setup_cgroups_agent()
229 int elogind_setup_cgroups_agent(Manager *m) {
231 static const union sockaddr_union sa = {
232 .un.sun_family = AF_UNIX,
233 .un.sun_path = "/run/systemd/cgroups-agent",
237 /* This creates a listening socket we receive cgroups agent messages on. We do not use D-Bus for delivering
238 * these messages from the cgroups agent binary to PID 1, as the cgroups agent binary is very short-living, and
239 * each instance of it needs a new D-Bus connection. Since D-Bus connections are SOCK_STREAM/AF_UNIX, on
240 * overloaded systems the backlog of the D-Bus socket becomes relevant, as not more than the configured number
241 * of D-Bus connections may be queued until the kernel will start dropping further incoming connections,
242 * possibly resulting in lost cgroups agent messages. To avoid this, we'll use a private SOCK_DGRAM/AF_UNIX
243 * socket, where no backlog is relevant as communication may take place without an actual connect() cycle, and
244 * we thus won't lose messages.
246 * Note that PID 1 will forward the agent message to system bus, so that the user systemd instance may listen
247 * to it. The system instance hence listens on this special socket, but the user instances listen on the system
248 * bus for these messages. */
250 if (m->test_run_flags)
253 if (!MANAGER_IS_SYSTEM(m))
256 r = cg_unified_controller(SYSTEMD_CGROUP_CONTROLLER);
258 return log_error_errno(r, "Failed to determine whether unified cgroups hierarchy is used: %m");
259 if (r > 0) /* We don't need this anymore on the unified hierarchy */
262 if (m->cgroups_agent_fd < 0) {
263 _cleanup_close_ int fd = -1;
265 /* First free all secondary fields */
266 m->cgroups_agent_event_source = sd_event_source_unref(m->cgroups_agent_event_source);
268 fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
270 return log_error_errno(errno, "Failed to allocate cgroups agent socket: %m");
272 fd_inc_rcvbuf(fd, CGROUPS_AGENT_RCVBUF_SIZE);
274 (void) unlink(sa.un.sun_path);
276 /* Only allow root to connect to this socket */
278 r = bind(fd, &sa.sa, SOCKADDR_UN_LEN(sa.un));
280 return log_error_errno(errno, "bind(%s) failed: %m", sa.un.sun_path);
282 m->cgroups_agent_fd = fd;
286 if (!m->cgroups_agent_event_source) {
287 r = sd_event_add_io(m->event, &m->cgroups_agent_event_source, m->cgroups_agent_fd, EPOLLIN, manager_dispatch_cgroups_agent_fd, m);
289 return log_error_errno(r, "Failed to allocate cgroups agent event source: %m");
291 /* Process cgroups notifications early, but after having processed service notification messages or
292 * SIGCHLD signals, so that a cgroup running empty is always just the last safety net of notification,
293 * and we collected the metadata the notification and SIGCHLD stuff offers first. Also see handling of
294 * cgroup inotify for the unified cgroup stuff. */
295 r = sd_event_source_set_priority(m->cgroups_agent_event_source, SD_EVENT_PRIORITY_NORMAL-5);
297 return log_error_errno(r, "Failed to set priority of cgroups agent event source: %m");
299 (void) sd_event_source_set_description(m->cgroups_agent_event_source, "manager-cgroups-agent");
306 /** Extra functionality at startup, exclusive to elogind
307 * return < 0 on error, exit with failure.
308 * return = 0 on success, continue normal operation.
309 * return > 0 if elogind is already running or forked, exit with success.
311 int elogind_startup(int argc, char *argv[]) {
312 bool daemonize = false;
315 bool show_help = false;
316 bool wrong_arg = false;
318 /* add a -h/--help and a -d/--daemon argument. */
319 if ( (argc == 2) && argv[1] && strlen(argv[1]) ) {
320 if ( streq(argv[1], "-D") || streq(argv[1], "--daemon") )
322 else if ( streq(argv[1], "-h") || streq(argv[1], "--help") ) {
330 /* Note: At this point, the logging is not initialized, so we can not
331 use log_debug_elogind(). */
332 #ifdef ENABLE_DEBUG_ELOGIND
333 log_notice("elogind startup: Daemonize: %s, Show Help: %s, Wrong arg: %s",
334 daemonize ? "True" : "False",
335 show_help ? "True" : "False",
336 wrong_arg ? "True" : "False");
337 #endif // ENABLE_DEBUG_ELOGIND
339 /* try to get some meaningful output in case of an error */
341 log_error("Unknown arguments");
346 log_info("%s [<-D|--daemon>|<-h|--help>]", basename(argv[0]));
350 /* Do not continue if elogind is already running */
351 pid = elogind_is_already_running(!daemonize);
353 log_error("elogind is already running as PID " PID_FMT, pid);
357 /* elogind allows to be daemonized using one argument "-D" / "--daemon" */
359 r = elogind_daemonize();
365 /// Add-On for manager_free()
366 void elogind_manager_free(Manager* m) {
368 manager_shutdown_cgroup(m, true);
370 sd_event_source_unref(m->cgroups_agent_event_source);
372 safe_close(m->cgroups_agent_fd);
374 strv_free(m->suspend_mode);
375 strv_free(m->suspend_state);
376 strv_free(m->hibernate_mode);
377 strv_free(m->hibernate_state);
378 strv_free(m->hybrid_sleep_mode);
379 strv_free(m->hybrid_sleep_state);
383 /// Add-On for manager_new()
384 int elogind_manager_new(Manager* m) {
387 m->cgroups_agent_fd = -1;
388 m->pin_cgroupfs_fd = -1;
389 m->test_run_flags = 0;
391 /* Init sleep modes and states */
392 m->suspend_mode = NULL;
393 m->suspend_state = NULL;
394 m->hibernate_mode = NULL;
395 m->hibernate_state = NULL;
396 m->hybrid_sleep_mode = NULL;
397 m->hybrid_sleep_state = NULL;
399 /* If elogind should be its own controller, mount its cgroup */
400 if (streq(SYSTEMD_CGROUP_CONTROLLER, "_elogind")) {
402 r = mount_setup(true);
404 m->is_system = false;
408 r = manager_setup_cgroup(m);
414 /// Add-On for manager_reset_config()
415 void elogind_manager_reset_config(Manager* m) {
417 #ifdef ENABLE_DEBUG_ELOGIND
419 #endif // ENABLE_DEBUG_ELOGIND
421 /* Set default Sleep config if not already set by logind.conf */
422 if (!m->suspend_state)
423 m->suspend_state = strv_new("mem", "standby", "freeze", NULL);
424 if (!m->hibernate_mode)
425 m->hibernate_mode = strv_new("platform", "shutdown", NULL);
426 if (!m->hibernate_state)
427 m->hibernate_state = strv_new("disk", NULL);
428 if (!m->hybrid_sleep_mode)
429 m->hybrid_sleep_mode = strv_new("suspend", "platform", "shutdown", NULL);
430 if (!m->hybrid_sleep_state)
431 m->hybrid_sleep_state = strv_new("disk", NULL);
433 #ifdef ENABLE_DEBUG_ELOGIND
435 while (m->suspend_mode && m->suspend_mode[++dbg_cnt])
436 log_debug_elogind("suspend_mode[%d] = %s",
437 dbg_cnt, m->suspend_mode[dbg_cnt]);
439 while (m->suspend_state[++dbg_cnt])
440 log_debug_elogind("suspend_state[%d] = %s",
441 dbg_cnt, m->suspend_state[dbg_cnt]);
443 while (m->hibernate_mode[++dbg_cnt])
444 log_debug_elogind("hibernate_mode[%d] = %s",
445 dbg_cnt, m->hibernate_mode[dbg_cnt]);
447 while (m->hibernate_state[++dbg_cnt])
448 log_debug_elogind("hibernate_state[%d] = %s",
449 dbg_cnt, m->hibernate_state[dbg_cnt]);
451 while (m->hybrid_sleep_mode[++dbg_cnt])
452 log_debug_elogind("hybrid_sleep_mode[%d] = %s",
453 dbg_cnt, m->hybrid_sleep_mode[dbg_cnt]);
455 while (m->hybrid_sleep_state[++dbg_cnt])
456 log_debug_elogind("hybrid_sleep_state[%d] = %s",
457 dbg_cnt, m->hybrid_sleep_state[dbg_cnt]);
458 #endif // ENABLE_DEBUG_ELOGIND
462 /// Add-On for manager_startup()
463 int elogind_manager_startup(Manager *m) {
468 assert_se(sigprocmask_many(SIG_SETMASK, NULL, SIGINT, -1) >= 0);
469 r = sd_event_add_signal(m->event, NULL, SIGINT, elogind_signal_handler, m);
471 return log_error_errno(r, "Failed to register SIGINT handler: %m");
473 assert_se(sigprocmask_many(SIG_SETMASK, NULL, SIGQUIT, -1) >= 0);
474 r = sd_event_add_signal(m->event, NULL, SIGQUIT, elogind_signal_handler, m);
476 return log_error_errno(r, "Failed to register SIGQUIT handler: %m");
478 assert_se(sigprocmask_many(SIG_SETMASK, NULL, SIGTERM, -1) >= 0);
479 r = sd_event_add_signal(m->event, NULL, SIGTERM, elogind_signal_handler, m);
481 return log_error_errno(r, "Failed to register SIGTERM handler: %m");