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];
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());
103 log_notice("Parent SID : %5d", getsid(getpid()));
104 #endif // ENABLE_DEBUG_ELOGIND
109 return log_error_errno(errno, "Failed to fork: %m");
112 /* Wait for the child to terminate, so the decoupling
113 * is guaranteed to succeed.
115 r = wait_for_terminate_and_warn("elogind control child", child, true);
121 #ifdef ENABLE_DEBUG_ELOGIND
122 log_notice("Child PID : %5d", getpid());
123 log_notice("Child SID : %5d", getsid(getpid()));
124 #endif // ENABLE_DEBUG_ELOGIND
126 /* The first child has to become a new session leader. */
127 close_all_fds(NULL, 0);
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()));
134 #endif // ENABLE_DEBUG_ELOGIND
138 /* Now the grandchild, the true daemon, can be created. */
142 return log_error_errno(errno, "Failed to double fork: %m");
145 /* Exit immediately! */
148 close_all_fds(NULL, 0);
151 #ifdef ENABLE_DEBUG_ELOGIND
152 log_notice("Grand child PID: %5d", getpid());
153 log_notice("Grand child SID: %5d", getsid(getpid()));
154 #endif // ENABLE_DEBUG_ELOGIND
156 /* Take care of our PID-file now */
163 /// Simple tool to see, if elogind is already running
164 static pid_t elogind_is_already_running(bool need_pid_file) {
165 _cleanup_free_ char *s = NULL;
169 r = read_one_line_file(ELOGIND_PID_FILE, &s);
174 r = safe_atoi32(s, &pid);
179 if ( (pid != getpid()) && pid_is_alive(pid))
184 /* Take care of our PID-file now.
185 If the user is going to fork elogind, the PID file
186 will be overwritten. */
194 static int manager_dispatch_cgroups_agent_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
195 Manager *m = userdata;
196 char buf[PATH_MAX+1];
199 n = recv(fd, buf, sizeof(buf), 0);
201 return log_error_errno(errno, "Failed to read cgroups agent message: %m");
203 log_error("Got zero-length cgroups agent message, ignoring.");
206 if ((size_t) n >= sizeof(buf)) {
207 log_error("Got overly long cgroups agent message, ignoring.");
211 if (memchr(buf, 0, n)) {
212 log_error("Got cgroups agent message with embedded NUL byte, ignoring.");
217 manager_notify_cgroup_empty(m, buf);
223 /// Add-On for manager_connect_bus()
224 /// Original: src/core/manager.c:manager_setup_cgroups_agent()
225 int elogind_setup_cgroups_agent(Manager *m) {
227 static const union sockaddr_union sa = {
228 .un.sun_family = AF_UNIX,
229 .un.sun_path = "/run/systemd/cgroups-agent",
233 /* This creates a listening socket we receive cgroups agent messages on. We do not use D-Bus for delivering
234 * these messages from the cgroups agent binary to PID 1, as the cgroups agent binary is very short-living, and
235 * each instance of it needs a new D-Bus connection. Since D-Bus connections are SOCK_STREAM/AF_UNIX, on
236 * overloaded systems the backlog of the D-Bus socket becomes relevant, as not more than the configured number
237 * of D-Bus connections may be queued until the kernel will start dropping further incoming connections,
238 * possibly resulting in lost cgroups agent messages. To avoid this, we'll use a private SOCK_DGRAM/AF_UNIX
239 * socket, where no backlog is relevant as communication may take place without an actual connect() cycle, and
240 * we thus won't lose messages.
242 * Note that PID 1 will forward the agent message to system bus, so that the user systemd instance may listen
243 * to it. The system instance hence listens on this special socket, but the user instances listen on the system
244 * bus for these messages. */
249 if (!MANAGER_IS_SYSTEM(m))
252 r = cg_unified_controller(SYSTEMD_CGROUP_CONTROLLER);
254 return log_error_errno(r, "Failed to determine whether unified cgroups hierarchy is used: %m");
255 if (r > 0) /* We don't need this anymore on the unified hierarchy */
258 if (m->cgroups_agent_fd < 0) {
259 _cleanup_close_ int fd = -1;
261 /* First free all secondary fields */
262 m->cgroups_agent_event_source = sd_event_source_unref(m->cgroups_agent_event_source);
264 fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
266 return log_error_errno(errno, "Failed to allocate cgroups agent socket: %m");
268 fd_inc_rcvbuf(fd, CGROUPS_AGENT_RCVBUF_SIZE);
270 (void) unlink(sa.un.sun_path);
272 /* Only allow root to connect to this socket */
274 r = bind(fd, &sa.sa, SOCKADDR_UN_LEN(sa.un));
276 return log_error_errno(errno, "bind(%s) failed: %m", sa.un.sun_path);
278 m->cgroups_agent_fd = fd;
282 if (!m->cgroups_agent_event_source) {
283 r = sd_event_add_io(m->event, &m->cgroups_agent_event_source, m->cgroups_agent_fd, EPOLLIN, manager_dispatch_cgroups_agent_fd, m);
285 return log_error_errno(r, "Failed to allocate cgroups agent event source: %m");
287 /* Process cgroups notifications early, but after having processed service notification messages or
288 * SIGCHLD signals, so that a cgroup running empty is always just the last safety net of notification,
289 * and we collected the metadata the notification and SIGCHLD stuff offers first. Also see handling of
290 * cgroup inotify for the unified cgroup stuff. */
291 r = sd_event_source_set_priority(m->cgroups_agent_event_source, SD_EVENT_PRIORITY_NORMAL-5);
293 return log_error_errno(r, "Failed to set priority of cgroups agent event source: %m");
295 (void) sd_event_source_set_description(m->cgroups_agent_event_source, "manager-cgroups-agent");
302 /** Extra functionality at startup, exclusive to elogind
303 * return < 0 on error, exit with failure.
304 * return = 0 on success, continue normal operation.
305 * return > 0 if elogind is already running or forked, exit with success.
307 int elogind_startup(int argc, char *argv[]) {
308 bool daemonize = false;
311 bool show_help = false;
312 bool wrong_arg = false;
314 /* add a -h/--help and a -d/--daemon argument. */
315 if ( (argc == 2) && argv[1] && strlen(argv[1]) ) {
316 if ( streq(argv[1], "-D") || streq(argv[1], "--daemon") )
318 else if ( streq(argv[1], "-h") || streq(argv[1], "--help") ) {
326 /* Note: At this point, the logging is not initialized, so we can not
327 use log_debug_elogind(). */
328 #ifdef ENABLE_DEBUG_ELOGIND
329 log_notice("elogind startup: Daemonize: %s, Show Help: %s, Wrong arg: %s",
330 daemonize ? "True" : "False",
331 show_help ? "True" : "False",
332 wrong_arg ? "True" : "False");
333 #endif // ENABLE_DEBUG_ELOGIND
335 /* try to get some meaningful output in case of an error */
337 log_error("Unknown arguments");
342 log_info("%s [<-D|--daemon>|<-h|--help>]", basename(argv[0]));
346 /* Do not continue if elogind is already running */
347 pid = elogind_is_already_running(!daemonize);
349 log_error("elogind is already running as PID " PID_FMT, pid);
353 /* elogind allows to be daemonized using one argument "-D" / "--daemon" */
355 r = elogind_daemonize();
361 /// Add-On for manager_free()
362 void elogind_manager_free(Manager* m) {
364 manager_shutdown_cgroup(m, true);
366 sd_event_source_unref(m->cgroups_agent_event_source);
368 safe_close(m->cgroups_agent_fd);
370 strv_free(m->suspend_mode);
371 strv_free(m->suspend_state);
372 strv_free(m->hibernate_mode);
373 strv_free(m->hibernate_state);
374 strv_free(m->hybrid_sleep_mode);
375 strv_free(m->hybrid_sleep_state);
379 /// Add-On for manager_new()
380 int elogind_manager_new(Manager* m) {
383 m->cgroups_agent_fd = -1;
384 m->pin_cgroupfs_fd = -1;
387 /* Init sleep modes and states */
388 m->suspend_mode = NULL;
389 m->suspend_state = NULL;
390 m->hibernate_mode = NULL;
391 m->hibernate_state = NULL;
392 m->hybrid_sleep_mode = NULL;
393 m->hybrid_sleep_state = NULL;
395 /* If elogind should be its own controller, mount its cgroup */
396 if (streq(SYSTEMD_CGROUP_CONTROLLER, "_elogind")) {
398 r = mount_setup(true);
400 m->is_system = false;
404 r = manager_setup_cgroup(m);
410 /// Add-On for manager_reset_config()
411 void elogind_manager_reset_config(Manager* m) {
413 #ifdef ENABLE_DEBUG_ELOGIND
415 #endif // ENABLE_DEBUG_ELOGIND
417 /* Set default Sleep config if not already set by logind.conf */
418 if (!m->suspend_state)
419 m->suspend_state = strv_new("mem", "standby", "freeze", NULL);
420 if (!m->hibernate_mode)
421 m->hibernate_mode = strv_new("platform", "shutdown", NULL);
422 if (!m->hibernate_state)
423 m->hibernate_state = strv_new("disk", NULL);
424 if (!m->hybrid_sleep_mode)
425 m->hybrid_sleep_mode = strv_new("suspend", "platform", "shutdown", NULL);
426 if (!m->hybrid_sleep_state)
427 m->hybrid_sleep_state = strv_new("disk", NULL);
429 #ifdef ENABLE_DEBUG_ELOGIND
431 while (m->suspend_mode && m->suspend_mode[++dbg_cnt])
432 log_debug_elogind("suspend_mode[%d] = %s",
433 dbg_cnt, m->suspend_mode[dbg_cnt]);
435 while (m->suspend_state[++dbg_cnt])
436 log_debug_elogind("suspend_state[%d] = %s",
437 dbg_cnt, m->suspend_state[dbg_cnt]);
439 while (m->hibernate_mode[++dbg_cnt])
440 log_debug_elogind("hibernate_mode[%d] = %s",
441 dbg_cnt, m->hibernate_mode[dbg_cnt]);
443 while (m->hibernate_state[++dbg_cnt])
444 log_debug_elogind("hibernate_state[%d] = %s",
445 dbg_cnt, m->hibernate_state[dbg_cnt]);
447 while (m->hybrid_sleep_mode[++dbg_cnt])
448 log_debug_elogind("hybrid_sleep_mode[%d] = %s",
449 dbg_cnt, m->hybrid_sleep_mode[dbg_cnt]);
451 while (m->hybrid_sleep_state[++dbg_cnt])
452 log_debug_elogind("hybrid_sleep_state[%d] = %s",
453 dbg_cnt, m->hybrid_sleep_state[dbg_cnt]);
454 #endif // ENABLE_DEBUG_ELOGIND
458 /// Add-On for manager_startup()
459 int elogind_manager_startup(Manager *m) {
464 assert_se(sigprocmask_many(SIG_SETMASK, NULL, SIGINT, -1) >= 0);
465 r = sd_event_add_signal(m->event, NULL, SIGINT, elogind_signal_handler, m);
467 return log_error_errno(r, "Failed to register SIGINT handler: %m");
469 assert_se(sigprocmask_many(SIG_SETMASK, NULL, SIGQUIT, -1) >= 0);
470 r = sd_event_add_signal(m->event, NULL, SIGQUIT, elogind_signal_handler, m);
472 return log_error_errno(r, "Failed to register SIGQUIT handler: %m");
474 assert_se(sigprocmask_many(SIG_SETMASK, NULL, SIGTERM, -1) >= 0);
475 r = sd_event_add_signal(m->event, NULL, SIGTERM, elogind_signal_handler, m);
477 return log_error_errno(r, "Failed to register SIGTERM handler: %m");