1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2012 Lennart Poettering
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
29 #include "path-util.h"
30 #include "logind-inhibit.h"
33 Inhibitor* inhibitor_new(Manager *m, const char* id) {
38 i = new0(Inhibitor, 1);
42 i->state_file = strappend("/run/systemd/inhibit/", id);
48 i->id = basename(i->state_file);
50 if (hashmap_put(m->inhibitors, i->id, i) < 0) {
62 void inhibitor_free(Inhibitor *i) {
65 hashmap_remove(i->manager->inhibitors, i->id);
67 inhibitor_remove_fifo(i);
73 unlink(i->state_file);
80 int inhibitor_save(Inhibitor *i) {
81 _cleanup_free_ char *temp_path = NULL;
82 _cleanup_fclose_ FILE *f = NULL;
87 r = mkdir_safe_label("/run/systemd/inhibit", 0755, 0, 0);
91 r = fopen_temporary(i->state_file, &f, &temp_path);
95 fchmod(fileno(f), 0644);
98 "# This is private data. Do not parse.\n"
103 inhibit_what_to_string(i->what),
104 inhibit_mode_to_string(i->mode),
109 _cleanup_free_ char *cc = NULL;
111 cc = cescape(i->who);
115 fprintf(f, "WHO=%s\n", cc);
119 _cleanup_free_ char *cc = NULL;
121 cc = cescape(i->why);
125 fprintf(f, "WHY=%s\n", cc);
129 fprintf(f, "FIFO=%s\n", i->fifo_path);
133 if (ferror(f) || rename(temp_path, i->state_file) < 0) {
135 unlink(i->state_file);
141 log_error("Failed to save inhibit data %s: %s", i->state_file, strerror(-r));
146 int inhibitor_start(Inhibitor *i) {
152 dual_timestamp_get(&i->since);
154 log_debug("Inhibitor %s (%s) pid="PID_FMT" uid="UID_FMT" mode=%s started.",
155 strna(i->who), strna(i->why),
157 inhibit_mode_to_string(i->mode));
163 manager_send_changed(i->manager, i->mode == INHIBIT_BLOCK ? "BlockInhibited" : "DelayInhibited", NULL);
168 int inhibitor_stop(Inhibitor *i) {
172 log_debug("Inhibitor %s (%s) pid="PID_FMT" uid="UID_FMT" mode=%s stopped.",
173 strna(i->who), strna(i->why),
175 inhibit_mode_to_string(i->mode));
178 unlink(i->state_file);
182 manager_send_changed(i->manager, i->mode == INHIBIT_BLOCK ? "BlockInhibited" : "DelayInhibited", NULL);
187 int inhibitor_load(Inhibitor *i) {
202 r = parse_env_file(i->state_file, NEWLINE,
209 "FIFO", &i->fifo_path,
214 w = what ? inhibit_what_from_string(what) : 0;
218 mm = mode ? inhibit_mode_from_string(mode) : INHIBIT_BLOCK;
223 r = parse_uid(uid, &i->uid);
229 r = parse_pid(pid, &i->pid);
255 fd = inhibitor_create_fifo(i);
262 static int inhibitor_dispatch_fifo(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
263 Inhibitor *i = userdata;
266 assert(fd == i->fifo_fd);
275 int inhibitor_create_fifo(Inhibitor *i) {
282 r = mkdir_safe_label("/run/systemd/inhibit", 0755, 0, 0);
286 i->fifo_path = strjoin("/run/systemd/inhibit/", i->id, ".ref", NULL);
290 if (mkfifo(i->fifo_path, 0600) < 0 && errno != EEXIST)
294 /* Open reading side */
295 if (i->fifo_fd < 0) {
296 i->fifo_fd = open(i->fifo_path, O_RDONLY|O_CLOEXEC|O_NDELAY);
301 if (!i->event_source) {
302 r = sd_event_add_io(i->manager->event, &i->event_source, i->fifo_fd, 0, inhibitor_dispatch_fifo, i);
306 r = sd_event_source_set_priority(i->event_source, SD_EVENT_PRIORITY_IDLE);
311 /* Open writing side */
312 r = open(i->fifo_path, O_WRONLY|O_CLOEXEC|O_NDELAY);
319 void inhibitor_remove_fifo(Inhibitor *i) {
322 i->event_source = sd_event_source_unref(i->event_source);
323 i->fifo_fd = safe_close(i->fifo_fd);
326 unlink(i->fifo_path);
332 InhibitWhat manager_inhibit_what(Manager *m, InhibitMode mm) {
335 InhibitWhat what = 0;
339 HASHMAP_FOREACH(i, m->inhibitors, j)
346 static int pid_is_active(Manager *m, pid_t pid) {
350 r = manager_get_session_by_pid(m, pid, &s);
354 /* If there's no session assigned to it, then it's globally
355 * active on all ttys */
359 return session_is_active(s);
362 bool manager_is_inhibited(
366 dual_timestamp *since,
367 bool ignore_inactive,
370 Inhibitor **offending) {
374 struct dual_timestamp ts = { 0, 0 };
375 bool inhibited = false;
378 assert(w > 0 && w < _INHIBIT_WHAT_MAX);
380 HASHMAP_FOREACH(i, m->inhibitors, j) {
387 if (ignore_inactive && pid_is_active(m, i->pid) <= 0)
390 if (ignore_uid && i->uid == uid)
394 i->since.monotonic < ts.monotonic)
409 const char *inhibit_what_to_string(InhibitWhat w) {
410 static thread_local char buffer[97];
413 if (w < 0 || w >= _INHIBIT_WHAT_MAX)
417 if (w & INHIBIT_SHUTDOWN)
418 p = stpcpy(p, "shutdown:");
419 if (w & INHIBIT_SLEEP)
420 p = stpcpy(p, "sleep:");
421 if (w & INHIBIT_IDLE)
422 p = stpcpy(p, "idle:");
423 if (w & INHIBIT_HANDLE_POWER_KEY)
424 p = stpcpy(p, "handle-power-key:");
425 if (w & INHIBIT_HANDLE_SUSPEND_KEY)
426 p = stpcpy(p, "handle-suspend-key:");
427 if (w & INHIBIT_HANDLE_HIBERNATE_KEY)
428 p = stpcpy(p, "handle-hibernate-key:");
429 if (w & INHIBIT_HANDLE_LID_SWITCH)
430 p = stpcpy(p, "handle-lid-switch:");
440 InhibitWhat inhibit_what_from_string(const char *s) {
441 InhibitWhat what = 0;
442 const char *word, *state;
445 FOREACH_WORD_SEPARATOR(word, l, s, ":", state) {
446 if (l == 8 && strneq(word, "shutdown", l))
447 what |= INHIBIT_SHUTDOWN;
448 else if (l == 5 && strneq(word, "sleep", l))
449 what |= INHIBIT_SLEEP;
450 else if (l == 4 && strneq(word, "idle", l))
451 what |= INHIBIT_IDLE;
452 else if (l == 16 && strneq(word, "handle-power-key", l))
453 what |= INHIBIT_HANDLE_POWER_KEY;
454 else if (l == 18 && strneq(word, "handle-suspend-key", l))
455 what |= INHIBIT_HANDLE_SUSPEND_KEY;
456 else if (l == 20 && strneq(word, "handle-hibernate-key", l))
457 what |= INHIBIT_HANDLE_HIBERNATE_KEY;
458 else if (l == 17 && strneq(word, "handle-lid-switch", l))
459 what |= INHIBIT_HANDLE_LID_SWITCH;
461 return _INHIBIT_WHAT_INVALID;
467 static const char* const inhibit_mode_table[_INHIBIT_MODE_MAX] = {
468 [INHIBIT_BLOCK] = "block",
469 [INHIBIT_DELAY] = "delay"
472 DEFINE_STRING_TABLE_LOOKUP(inhibit_mode, InhibitMode);