2010-08-14 19:59:25 +02:00
|
|
|
/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
|
2009-11-18 00:42:52 +01:00
|
|
|
|
2010-02-03 13:03:47 +01:00
|
|
|
/***
|
|
|
|
This file is part of systemd.
|
|
|
|
|
|
|
|
Copyright 2010 Lennart Poettering
|
|
|
|
|
|
|
|
systemd is free software; you can redistribute it and/or modify it
|
2012-04-12 00:20:58 +02:00
|
|
|
under the terms of the GNU Lesser General Public License as published by
|
|
|
|
the Free Software Foundation; either version 2.1 of the License, or
|
2010-02-03 13:03:47 +01:00
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
systemd is distributed in the hope that it will be useful, but
|
|
|
|
WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
2012-04-12 00:20:58 +02:00
|
|
|
Lesser General Public License for more details.
|
2010-02-03 13:03:47 +01:00
|
|
|
|
2012-04-12 00:20:58 +02:00
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
2010-02-03 13:03:47 +01:00
|
|
|
along with systemd; If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
***/
|
|
|
|
|
2009-11-18 00:42:52 +01:00
|
|
|
#include <errno.h>
|
2010-01-18 23:50:13 +01:00
|
|
|
#include <string.h>
|
2010-01-24 00:39:29 +01:00
|
|
|
#include <signal.h>
|
|
|
|
#include <sys/wait.h>
|
|
|
|
#include <unistd.h>
|
2014-10-26 02:30:51 +02:00
|
|
|
#include <sys/inotify.h>
|
|
|
|
#include <sys/epoll.h>
|
2010-02-14 22:39:40 +01:00
|
|
|
#include <sys/reboot.h>
|
|
|
|
#include <sys/ioctl.h>
|
|
|
|
#include <linux/kd.h>
|
2010-04-13 02:06:27 +02:00
|
|
|
#include <fcntl.h>
|
2010-07-11 00:52:00 +02:00
|
|
|
#include <dirent.h>
|
2012-11-25 00:32:40 +01:00
|
|
|
#include <sys/timerfd.h>
|
2010-08-11 15:19:50 +02:00
|
|
|
|
|
|
|
#ifdef HAVE_AUDIT
|
2010-08-11 01:43:23 +02:00
|
|
|
#include <libaudit.h>
|
2010-08-11 15:19:50 +02:00
|
|
|
#endif
|
2009-11-18 00:42:52 +01:00
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
#include "sd-daemon.h"
|
|
|
|
#include "sd-messages.h"
|
2012-01-05 16:01:58 +01:00
|
|
|
|
2009-11-18 00:42:52 +01:00
|
|
|
#include "manager.h"
|
2012-04-19 23:54:11 +02:00
|
|
|
#include "transaction.h"
|
2009-11-18 00:42:52 +01:00
|
|
|
#include "hashmap.h"
|
|
|
|
#include "macro.h"
|
|
|
|
#include "strv.h"
|
2010-01-20 19:19:53 +01:00
|
|
|
#include "log.h"
|
2010-01-27 06:19:28 +01:00
|
|
|
#include "util.h"
|
2012-04-10 21:54:31 +02:00
|
|
|
#include "mkdir.h"
|
2010-02-01 03:33:24 +01:00
|
|
|
#include "ratelimit.h"
|
2013-07-26 05:22:22 +02:00
|
|
|
#include "locale-setup.h"
|
2010-04-15 03:11:11 +02:00
|
|
|
#include "unit-name.h"
|
2010-05-09 23:53:52 +02:00
|
|
|
#include "missing.h"
|
2010-06-15 14:45:15 +02:00
|
|
|
#include "path-lookup.h"
|
2010-06-18 04:22:59 +02:00
|
|
|
#include "special.h"
|
2010-08-19 03:18:49 +02:00
|
|
|
#include "exit-status.h"
|
2011-09-23 17:20:45 +02:00
|
|
|
#include "virt.h"
|
2012-04-05 22:08:10 +02:00
|
|
|
#include "watchdog.h"
|
2012-05-07 21:36:12 +02:00
|
|
|
#include "path-util.h"
|
2012-10-02 23:40:09 +02:00
|
|
|
#include "audit-fd.h"
|
2013-09-24 00:23:35 +02:00
|
|
|
#include "boot-timestamps.h"
|
2013-02-11 23:53:14 +01:00
|
|
|
#include "env-util.h"
|
2014-12-10 19:00:46 +01:00
|
|
|
#include "bus-common-errors.h"
|
2013-11-19 21:12:59 +01:00
|
|
|
#include "bus-error.h"
|
|
|
|
#include "bus-util.h"
|
|
|
|
#include "dbus.h"
|
|
|
|
#include "dbus-unit.h"
|
|
|
|
#include "dbus-job.h"
|
|
|
|
#include "dbus-manager.h"
|
2013-11-30 03:53:42 +01:00
|
|
|
#include "bus-kernel.h"
|
2014-10-11 18:45:11 +02:00
|
|
|
#include "time-util.h"
|
2009-11-18 00:42:52 +01:00
|
|
|
|
2013-02-28 00:03:22 +01:00
|
|
|
/* Initial delay and the interval for printing status messages about running jobs */
|
2014-01-27 07:15:27 +01:00
|
|
|
#define JOBS_IN_PROGRESS_WAIT_USEC (5*USEC_PER_SEC)
|
|
|
|
#define JOBS_IN_PROGRESS_PERIOD_USEC (USEC_PER_SEC / 3)
|
2013-02-28 00:03:22 +01:00
|
|
|
#define JOBS_IN_PROGRESS_PERIOD_DIVISOR 3
|
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
|
|
|
|
static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
|
|
|
|
static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
|
|
|
|
static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
|
|
|
|
static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata);
|
2013-11-25 15:22:41 +01:00
|
|
|
static int manager_dispatch_run_queue(sd_event_source *source, void *userdata);
|
Implement masking and overriding of generators
Sometimes it is necessary to stop a generator from running. Either
because of a bug, or for testing, or some other reason. The only way
to do that would be to rename or chmod the generator binary, which is
inconvenient and does not survive upgrades. Allow masking and
overriding generators similarly to units and other configuration
files.
For the systemd instance, masking would be more common, rather than
overriding generators. For the user instances, it may also be useful
for users to have generators in $XDG_CONFIG_HOME to augment or
override system-wide generators.
Directories are searched according to the usual scheme (/usr/lib,
/usr/local/lib, /run, /etc), and files with the same name in higher
priority directories override files with the same name in lower
priority directories. Empty files and links to /dev/null mask a given
name.
https://bugs.freedesktop.org/show_bug.cgi?id=87230
2015-01-09 02:47:25 +01:00
|
|
|
static int manager_run_generators(Manager *m);
|
|
|
|
static void manager_undo_generators(Manager *m);
|
2013-11-19 21:12:59 +01:00
|
|
|
|
2015-03-14 03:11:09 +01:00
|
|
|
static void manager_watch_jobs_in_progress(Manager *m) {
|
2014-01-29 00:26:06 +01:00
|
|
|
usec_t next;
|
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
assert(m);
|
2013-02-28 00:03:22 +01:00
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
if (m->jobs_in_progress_event_source)
|
2015-03-14 03:11:09 +01:00
|
|
|
return;
|
2013-02-28 00:03:22 +01:00
|
|
|
|
2014-01-29 00:26:06 +01:00
|
|
|
next = now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_WAIT_USEC;
|
2015-03-14 03:11:09 +01:00
|
|
|
(void) sd_event_add_time(
|
2014-03-24 02:49:09 +01:00
|
|
|
m->event,
|
|
|
|
&m->jobs_in_progress_event_source,
|
|
|
|
CLOCK_MONOTONIC,
|
|
|
|
next, 0,
|
|
|
|
manager_dispatch_jobs_in_progress, m);
|
2013-02-28 00:03:22 +01:00
|
|
|
}
|
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
#define CYLON_BUFFER_EXTRA (2*(sizeof(ANSI_RED_ON)-1) + sizeof(ANSI_HIGHLIGHT_RED_ON)-1 + 2*(sizeof(ANSI_HIGHLIGHT_OFF)-1))
|
2013-02-28 00:03:22 +01:00
|
|
|
|
|
|
|
static void draw_cylon(char buffer[], size_t buflen, unsigned width, unsigned pos) {
|
|
|
|
char *p = buffer;
|
|
|
|
|
|
|
|
assert(buflen >= CYLON_BUFFER_EXTRA + width + 1);
|
|
|
|
assert(pos <= width+1); /* 0 or width+1 mean that the center light is behind the corner */
|
|
|
|
|
|
|
|
if (pos > 1) {
|
2013-03-05 15:52:44 +01:00
|
|
|
if (pos > 2)
|
|
|
|
p = mempset(p, ' ', pos-2);
|
2013-03-05 15:46:37 +01:00
|
|
|
p = stpcpy(p, ANSI_RED_ON);
|
2013-02-28 00:03:22 +01:00
|
|
|
*p++ = '*';
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pos > 0 && pos <= width) {
|
2013-03-05 15:46:37 +01:00
|
|
|
p = stpcpy(p, ANSI_HIGHLIGHT_RED_ON);
|
2013-02-28 00:03:22 +01:00
|
|
|
*p++ = '*';
|
|
|
|
}
|
|
|
|
|
2013-03-05 15:46:37 +01:00
|
|
|
p = stpcpy(p, ANSI_HIGHLIGHT_OFF);
|
2013-02-28 00:03:22 +01:00
|
|
|
|
|
|
|
if (pos < width) {
|
2013-03-05 15:46:37 +01:00
|
|
|
p = stpcpy(p, ANSI_RED_ON);
|
2013-02-28 00:03:22 +01:00
|
|
|
*p++ = '*';
|
2013-03-05 15:52:44 +01:00
|
|
|
if (pos < width-1)
|
|
|
|
p = mempset(p, ' ', width-1-pos);
|
2013-10-12 01:33:48 +02:00
|
|
|
strcpy(p, ANSI_HIGHLIGHT_OFF);
|
2013-02-28 00:03:22 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-01-28 04:48:18 +01:00
|
|
|
void manager_flip_auto_status(Manager *m, bool enable) {
|
2014-03-12 20:55:13 +01:00
|
|
|
assert(m);
|
|
|
|
|
2014-01-28 04:48:18 +01:00
|
|
|
if (enable) {
|
|
|
|
if (m->show_status == SHOW_STATUS_AUTO)
|
|
|
|
manager_set_show_status(m, SHOW_STATUS_TEMPORARY);
|
|
|
|
} else {
|
|
|
|
if (m->show_status == SHOW_STATUS_TEMPORARY)
|
|
|
|
manager_set_show_status(m, SHOW_STATUS_AUTO);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-02-28 00:03:22 +01:00
|
|
|
static void manager_print_jobs_in_progress(Manager *m) {
|
2013-11-19 21:12:59 +01:00
|
|
|
_cleanup_free_ char *job_of_n = NULL;
|
2013-02-28 00:03:22 +01:00
|
|
|
Iterator i;
|
|
|
|
Job *j;
|
|
|
|
unsigned counter = 0, print_nr;
|
|
|
|
char cylon[6 + CYLON_BUFFER_EXTRA + 1];
|
|
|
|
unsigned cylon_pos;
|
2014-01-29 00:25:39 +01:00
|
|
|
char time[FORMAT_TIMESPAN_MAX], limit[FORMAT_TIMESPAN_MAX] = "no limit";
|
|
|
|
uint64_t x;
|
2013-02-28 00:03:22 +01:00
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
assert(m);
|
2015-01-05 17:22:10 +01:00
|
|
|
assert(m->n_running_jobs > 0);
|
2013-11-19 21:12:59 +01:00
|
|
|
|
2014-01-28 04:48:18 +01:00
|
|
|
manager_flip_auto_status(m, true);
|
2014-01-28 04:27:07 +01:00
|
|
|
|
2013-02-28 00:03:22 +01:00
|
|
|
print_nr = (m->jobs_in_progress_iteration / JOBS_IN_PROGRESS_PERIOD_DIVISOR) % m->n_running_jobs;
|
|
|
|
|
|
|
|
HASHMAP_FOREACH(j, m->jobs, i)
|
|
|
|
if (j->state == JOB_RUNNING && counter++ == print_nr)
|
|
|
|
break;
|
|
|
|
|
2013-03-02 12:44:41 +01:00
|
|
|
/* m->n_running_jobs must be consistent with the contents of m->jobs,
|
|
|
|
* so the above loop must have succeeded in finding j. */
|
|
|
|
assert(counter == print_nr + 1);
|
2013-10-12 01:33:48 +02:00
|
|
|
assert(j);
|
2013-03-01 14:57:16 +01:00
|
|
|
|
2013-02-28 00:03:22 +01:00
|
|
|
cylon_pos = m->jobs_in_progress_iteration % 14;
|
|
|
|
if (cylon_pos >= 8)
|
|
|
|
cylon_pos = 14 - cylon_pos;
|
|
|
|
draw_cylon(cylon, sizeof(cylon), 6, cylon_pos);
|
|
|
|
|
2014-01-29 00:25:39 +01:00
|
|
|
m->jobs_in_progress_iteration++;
|
|
|
|
|
2013-02-28 00:03:22 +01:00
|
|
|
if (m->n_running_jobs > 1)
|
2015-01-05 17:22:10 +01:00
|
|
|
asprintf(&job_of_n, "(%u of %u) ", counter, m->n_running_jobs);
|
2013-02-28 00:03:22 +01:00
|
|
|
|
2014-01-29 00:25:39 +01:00
|
|
|
format_timespan(time, sizeof(time), now(CLOCK_MONOTONIC) - j->begin_usec, 1*USEC_PER_SEC);
|
|
|
|
if (job_get_timeout(j, &x) > 0)
|
|
|
|
format_timespan(limit, sizeof(limit), x - j->begin_usec, 1*USEC_PER_SEC);
|
|
|
|
|
2014-10-28 04:02:54 +01:00
|
|
|
manager_status_printf(m, STATUS_TYPE_EPHEMERAL, cylon,
|
2014-01-29 00:25:39 +01:00
|
|
|
"%sA %s job is running for %s (%s / %s)",
|
|
|
|
strempty(job_of_n),
|
|
|
|
job_type_to_string(j->type),
|
|
|
|
unit_description(j->unit),
|
|
|
|
time, limit);
|
2013-02-28 00:03:22 +01:00
|
|
|
}
|
|
|
|
|
2014-10-26 02:30:51 +02:00
|
|
|
static int have_ask_password(void) {
|
|
|
|
_cleanup_closedir_ DIR *dir;
|
|
|
|
|
|
|
|
dir = opendir("/run/systemd/ask-password");
|
|
|
|
if (!dir) {
|
|
|
|
if (errno == ENOENT)
|
|
|
|
return false;
|
|
|
|
else
|
|
|
|
return -errno;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
struct dirent *de;
|
|
|
|
|
|
|
|
errno = 0;
|
|
|
|
de = readdir(dir);
|
|
|
|
if (!de && errno != 0)
|
|
|
|
return -errno;
|
|
|
|
if (!de)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (startswith(de->d_name, "ask."))
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int manager_dispatch_ask_password_fd(sd_event_source *source,
|
|
|
|
int fd, uint32_t revents, void *userdata) {
|
|
|
|
Manager *m = userdata;
|
|
|
|
|
|
|
|
assert(m);
|
|
|
|
|
|
|
|
flush_fd(fd);
|
|
|
|
|
|
|
|
m->have_ask_password = have_ask_password();
|
|
|
|
if (m->have_ask_password < 0)
|
|
|
|
/* Log error but continue. Negative have_ask_password
|
|
|
|
* is treated as unknown status. */
|
2014-11-28 17:09:20 +01:00
|
|
|
log_error_errno(m->have_ask_password, "Failed to list /run/systemd/ask-password: %m");
|
2014-10-26 02:30:51 +02:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void manager_close_ask_password(Manager *m) {
|
|
|
|
assert(m);
|
|
|
|
|
|
|
|
m->ask_password_inotify_fd = safe_close(m->ask_password_inotify_fd);
|
|
|
|
m->ask_password_event_source = sd_event_source_unref(m->ask_password_event_source);
|
|
|
|
m->have_ask_password = -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int manager_check_ask_password(Manager *m) {
|
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(m);
|
|
|
|
|
|
|
|
if (!m->ask_password_event_source) {
|
|
|
|
assert(m->ask_password_inotify_fd < 0);
|
|
|
|
|
|
|
|
mkdir_p_label("/run/systemd/ask-password", 0755);
|
|
|
|
|
|
|
|
m->ask_password_inotify_fd = inotify_init1(IN_NONBLOCK|IN_CLOEXEC);
|
2014-11-28 19:57:32 +01:00
|
|
|
if (m->ask_password_inotify_fd < 0)
|
|
|
|
return log_error_errno(errno, "inotify_init1() failed: %m");
|
2014-10-26 02:30:51 +02:00
|
|
|
|
|
|
|
if (inotify_add_watch(m->ask_password_inotify_fd, "/run/systemd/ask-password", IN_CREATE|IN_DELETE|IN_MOVE) < 0) {
|
2014-11-28 19:29:59 +01:00
|
|
|
log_error_errno(errno, "Failed to add watch on /run/systemd/ask-password: %m");
|
2014-10-26 02:30:51 +02:00
|
|
|
manager_close_ask_password(m);
|
|
|
|
return -errno;
|
|
|
|
}
|
|
|
|
|
|
|
|
r = sd_event_add_io(m->event, &m->ask_password_event_source,
|
|
|
|
m->ask_password_inotify_fd, EPOLLIN,
|
|
|
|
manager_dispatch_ask_password_fd, m);
|
|
|
|
if (r < 0) {
|
2014-11-28 19:29:59 +01:00
|
|
|
log_error_errno(errno, "Failed to add event source for /run/systemd/ask-password: %m");
|
2014-10-26 02:30:51 +02:00
|
|
|
manager_close_ask_password(m);
|
|
|
|
return -errno;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Queries might have been added meanwhile... */
|
|
|
|
manager_dispatch_ask_password_fd(m->ask_password_event_source,
|
|
|
|
m->ask_password_inotify_fd, EPOLLIN, m);
|
|
|
|
}
|
|
|
|
|
|
|
|
return m->have_ask_password;
|
|
|
|
}
|
|
|
|
|
systemd: do not output status messages once gettys are running
Make Type=idle communication bidirectional: when bootup is finished,
the manager, as before, signals idling Type=idle jobs to continue.
However, if the boot takes too long, idling jobs signal the manager
that they have had enough, wait a tiny bit more, and continue, taking
ownership of the console. The manager, when signalled that Type=idle
jobs are done, makes a note and will not write to the console anymore.
This is a cosmetic issue, but quite noticable, so let's just fix it.
Based on Harald Hoyer's patch.
https://bugs.freedesktop.org/show_bug.cgi?id=54247
http://unix.stackexchange.com/questions/51805/systemd-messages-after-starting-login/
2013-07-16 03:34:57 +02:00
|
|
|
static int manager_watch_idle_pipe(Manager *m) {
|
|
|
|
int r;
|
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
assert(m);
|
|
|
|
|
|
|
|
if (m->idle_pipe_event_source)
|
systemd: do not output status messages once gettys are running
Make Type=idle communication bidirectional: when bootup is finished,
the manager, as before, signals idling Type=idle jobs to continue.
However, if the boot takes too long, idling jobs signal the manager
that they have had enough, wait a tiny bit more, and continue, taking
ownership of the console. The manager, when signalled that Type=idle
jobs are done, makes a note and will not write to the console anymore.
This is a cosmetic issue, but quite noticable, so let's just fix it.
Based on Harald Hoyer's patch.
https://bugs.freedesktop.org/show_bug.cgi?id=54247
http://unix.stackexchange.com/questions/51805/systemd-messages-after-starting-login/
2013-07-16 03:34:57 +02:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (m->idle_pipe[2] < 0)
|
|
|
|
return 0;
|
|
|
|
|
2014-02-19 23:54:58 +01:00
|
|
|
r = sd_event_add_io(m->event, &m->idle_pipe_event_source, m->idle_pipe[2], EPOLLIN, manager_dispatch_idle_pipe_fd, m);
|
2014-11-28 18:23:20 +01:00
|
|
|
if (r < 0)
|
|
|
|
return log_error_errno(r, "Failed to watch idle pipe: %m");
|
systemd: do not output status messages once gettys are running
Make Type=idle communication bidirectional: when bootup is finished,
the manager, as before, signals idling Type=idle jobs to continue.
However, if the boot takes too long, idling jobs signal the manager
that they have had enough, wait a tiny bit more, and continue, taking
ownership of the console. The manager, when signalled that Type=idle
jobs are done, makes a note and will not write to the console anymore.
This is a cosmetic issue, but quite noticable, so let's just fix it.
Based on Harald Hoyer's patch.
https://bugs.freedesktop.org/show_bug.cgi?id=54247
http://unix.stackexchange.com/questions/51805/systemd-messages-after-starting-login/
2013-07-16 03:34:57 +02:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
static void manager_close_idle_pipe(Manager *m) {
|
|
|
|
assert(m);
|
systemd: do not output status messages once gettys are running
Make Type=idle communication bidirectional: when bootup is finished,
the manager, as before, signals idling Type=idle jobs to continue.
However, if the boot takes too long, idling jobs signal the manager
that they have had enough, wait a tiny bit more, and continue, taking
ownership of the console. The manager, when signalled that Type=idle
jobs are done, makes a note and will not write to the console anymore.
This is a cosmetic issue, but quite noticable, so let's just fix it.
Based on Harald Hoyer's patch.
https://bugs.freedesktop.org/show_bug.cgi?id=54247
http://unix.stackexchange.com/questions/51805/systemd-messages-after-starting-login/
2013-07-16 03:34:57 +02:00
|
|
|
|
2014-03-24 03:22:44 +01:00
|
|
|
safe_close_pair(m->idle_pipe);
|
|
|
|
safe_close_pair(m->idle_pipe + 2);
|
systemd: do not output status messages once gettys are running
Make Type=idle communication bidirectional: when bootup is finished,
the manager, as before, signals idling Type=idle jobs to continue.
However, if the boot takes too long, idling jobs signal the manager
that they have had enough, wait a tiny bit more, and continue, taking
ownership of the console. The manager, when signalled that Type=idle
jobs are done, makes a note and will not write to the console anymore.
This is a cosmetic issue, but quite noticable, so let's just fix it.
Based on Harald Hoyer's patch.
https://bugs.freedesktop.org/show_bug.cgi?id=54247
http://unix.stackexchange.com/questions/51805/systemd-messages-after-starting-login/
2013-07-16 03:34:57 +02:00
|
|
|
}
|
|
|
|
|
2012-11-25 00:32:40 +01:00
|
|
|
static int manager_setup_time_change(Manager *m) {
|
2013-11-19 21:12:59 +01:00
|
|
|
int r;
|
2013-03-25 00:59:00 +01:00
|
|
|
|
|
|
|
/* We only care for the cancellation event, hence we set the
|
|
|
|
* timeout to the latest possible value. */
|
|
|
|
struct itimerspec its = {
|
|
|
|
.it_value.tv_sec = TIME_T_MAX,
|
|
|
|
};
|
2012-11-25 00:32:40 +01:00
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
assert(m);
|
|
|
|
assert_cc(sizeof(time_t) == sizeof(TIME_T_MAX));
|
2012-11-25 00:32:40 +01:00
|
|
|
|
2014-01-07 14:41:24 +01:00
|
|
|
if (m->test_run)
|
|
|
|
return 0;
|
|
|
|
|
2012-11-25 00:32:40 +01:00
|
|
|
/* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
|
|
|
|
* CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
|
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
m->time_change_fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
|
2014-11-28 19:57:32 +01:00
|
|
|
if (m->time_change_fd < 0)
|
|
|
|
return log_error_errno(errno, "Failed to create timerfd: %m");
|
2012-11-25 00:32:40 +01:00
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
if (timerfd_settime(m->time_change_fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
|
2014-11-28 19:29:59 +01:00
|
|
|
log_debug_errno(errno, "Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
|
2014-03-18 19:22:43 +01:00
|
|
|
m->time_change_fd = safe_close(m->time_change_fd);
|
2012-11-25 00:32:40 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-02-19 23:54:58 +01:00
|
|
|
r = sd_event_add_io(m->event, &m->time_change_event_source, m->time_change_fd, EPOLLIN, manager_dispatch_time_change_fd, m);
|
2014-11-28 18:23:20 +01:00
|
|
|
if (r < 0)
|
|
|
|
return log_error_errno(r, "Failed to create time change event source: %m");
|
2012-11-25 00:32:40 +01:00
|
|
|
|
|
|
|
log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-04-13 02:06:27 +02:00
|
|
|
static int enable_special_signals(Manager *m) {
|
2013-11-19 21:12:59 +01:00
|
|
|
_cleanup_close_ int fd = -1;
|
2010-04-13 02:06:27 +02:00
|
|
|
|
|
|
|
assert(m);
|
|
|
|
|
2012-04-13 16:53:49 +02:00
|
|
|
/* Enable that we get SIGINT on control-alt-del. In containers
|
2012-09-17 18:28:40 +02:00
|
|
|
* this will fail with EPERM (older) or EINVAL (newer), so
|
|
|
|
* ignore that. */
|
|
|
|
if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
|
2014-11-28 19:29:59 +01:00
|
|
|
log_warning_errno(errno, "Failed to enable ctrl-alt-del handling: %m");
|
2010-04-13 02:06:27 +02:00
|
|
|
|
2012-04-13 16:53:49 +02:00
|
|
|
fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
|
|
|
|
if (fd < 0) {
|
|
|
|
/* Support systems without virtual console */
|
|
|
|
if (fd != -ENOENT)
|
2014-11-28 19:29:59 +01:00
|
|
|
log_warning_errno(errno, "Failed to open /dev/tty0: %m");
|
2012-04-13 16:53:49 +02:00
|
|
|
} else {
|
2010-04-13 02:06:27 +02:00
|
|
|
/* Enable that we get SIGWINCH on kbrequest */
|
|
|
|
if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
|
2014-11-28 19:29:59 +01:00
|
|
|
log_warning_errno(errno, "Failed to enable kbrequest handling: %m");
|
2010-04-13 02:06:27 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-01-28 02:01:15 +01:00
|
|
|
static int manager_setup_signals(Manager *m) {
|
2013-03-25 00:59:00 +01:00
|
|
|
struct sigaction sa = {
|
|
|
|
.sa_handler = SIG_DFL,
|
|
|
|
.sa_flags = SA_NOCLDSTOP|SA_RESTART,
|
|
|
|
};
|
2013-11-19 21:12:59 +01:00
|
|
|
sigset_t mask;
|
|
|
|
int r;
|
2009-11-18 00:42:52 +01:00
|
|
|
|
2010-01-28 02:01:15 +01:00
|
|
|
assert(m);
|
|
|
|
|
2010-04-13 02:36:56 +02:00
|
|
|
assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
|
|
|
|
|
2014-10-24 13:44:45 +02:00
|
|
|
/* We make liberal use of realtime signals here. On
|
|
|
|
* Linux/glibc we have 30 of them (with the exception of Linux
|
|
|
|
* on hppa, see below), between SIGRTMIN+0 ... SIGRTMIN+30
|
|
|
|
* (aka SIGRTMAX). */
|
2010-06-17 23:22:56 +02:00
|
|
|
|
2014-10-24 13:44:45 +02:00
|
|
|
assert_se(sigemptyset(&mask) == 0);
|
2010-06-17 23:22:56 +02:00
|
|
|
sigset_add_many(&mask,
|
|
|
|
SIGCHLD, /* Child died */
|
|
|
|
SIGTERM, /* Reexecute daemon */
|
|
|
|
SIGHUP, /* Reload configuration */
|
|
|
|
SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
|
|
|
|
SIGUSR2, /* systemd: dump status */
|
|
|
|
SIGINT, /* Kernel sends us this on control-alt-del */
|
|
|
|
SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
|
|
|
|
SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
|
2014-10-24 13:44:45 +02:00
|
|
|
|
2010-06-17 23:22:56 +02:00
|
|
|
SIGRTMIN+0, /* systemd: start default.target */
|
2010-10-14 00:54:48 +02:00
|
|
|
SIGRTMIN+1, /* systemd: isolate rescue.target */
|
2010-06-17 23:22:56 +02:00
|
|
|
SIGRTMIN+2, /* systemd: isolate emergency.target */
|
|
|
|
SIGRTMIN+3, /* systemd: start halt.target */
|
|
|
|
SIGRTMIN+4, /* systemd: start poweroff.target */
|
|
|
|
SIGRTMIN+5, /* systemd: start reboot.target */
|
2010-10-14 00:54:48 +02:00
|
|
|
SIGRTMIN+6, /* systemd: start kexec.target */
|
2014-10-24 13:44:45 +02:00
|
|
|
|
|
|
|
/* ... space for more special targets ... */
|
|
|
|
|
2010-10-14 00:54:48 +02:00
|
|
|
SIGRTMIN+13, /* systemd: Immediate halt */
|
|
|
|
SIGRTMIN+14, /* systemd: Immediate poweroff */
|
|
|
|
SIGRTMIN+15, /* systemd: Immediate reboot */
|
|
|
|
SIGRTMIN+16, /* systemd: Immediate kexec */
|
2014-10-24 13:44:45 +02:00
|
|
|
|
|
|
|
/* ... space for more immediate system state changes ... */
|
|
|
|
|
2011-02-09 12:12:30 +01:00
|
|
|
SIGRTMIN+20, /* systemd: enable status messages */
|
|
|
|
SIGRTMIN+21, /* systemd: disable status messages */
|
2011-07-23 04:15:38 +02:00
|
|
|
SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
|
|
|
|
SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
|
2012-10-18 01:19:35 +02:00
|
|
|
SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
|
2014-10-24 13:44:45 +02:00
|
|
|
|
|
|
|
/* .. one free signal here ... */
|
|
|
|
|
|
|
|
#if !defined(__hppa64__) && !defined(__hppa__)
|
|
|
|
/* Apparently Linux on hppa has fewer RT
|
|
|
|
* signals (SIGRTMAX is SIGRTMIN+25 there),
|
|
|
|
* hence let's not try to make use of them
|
|
|
|
* here. Since these commands are accessible
|
|
|
|
* by different means and only really a safety
|
|
|
|
* net, the missing functionality on hppa
|
|
|
|
* shouldn't matter. */
|
|
|
|
|
2012-01-12 05:09:06 +01:00
|
|
|
SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
|
2011-07-23 04:15:38 +02:00
|
|
|
SIGRTMIN+27, /* systemd: set log target to console */
|
|
|
|
SIGRTMIN+28, /* systemd: set log target to kmsg */
|
2014-12-10 20:00:08 +01:00
|
|
|
SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg (obsolete) */
|
2014-10-24 13:44:45 +02:00
|
|
|
|
|
|
|
/* ... one free signal here SIGRTMIN+30 ... */
|
|
|
|
#endif
|
2010-06-17 23:22:56 +02:00
|
|
|
-1);
|
2010-01-28 02:01:15 +01:00
|
|
|
assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
|
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
m->signal_fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
|
|
|
|
if (m->signal_fd < 0)
|
2010-01-28 02:01:15 +01:00
|
|
|
return -errno;
|
|
|
|
|
2014-02-19 23:54:58 +01:00
|
|
|
r = sd_event_add_io(m->event, &m->signal_event_source, m->signal_fd, EPOLLIN, manager_dispatch_signal_fd, m);
|
2013-11-19 21:12:59 +01:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2010-01-28 02:01:15 +01:00
|
|
|
|
2013-12-18 03:46:53 +01:00
|
|
|
/* Process signals a bit earlier than the rest of things, but
|
2014-10-17 02:13:45 +02:00
|
|
|
* later than notify_fd processing, so that the notify
|
2013-12-18 03:46:53 +01:00
|
|
|
* processing can still figure out to which process/service a
|
|
|
|
* message belongs, before we reap the process. */
|
2013-11-25 15:35:10 +01:00
|
|
|
r = sd_event_source_set_priority(m->signal_event_source, -5);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
2012-09-18 17:11:12 +02:00
|
|
|
if (m->running_as == SYSTEMD_SYSTEM)
|
2010-04-13 02:06:27 +02:00
|
|
|
return enable_special_signals(m);
|
2010-02-14 22:39:40 +01:00
|
|
|
|
2010-01-28 02:01:15 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-01-12 13:10:40 +01:00
|
|
|
static void manager_clean_environment(Manager *m) {
|
|
|
|
assert(m);
|
|
|
|
|
|
|
|
/* Let's remove some environment variables that we
|
|
|
|
* need ourselves to communicate with our clients */
|
|
|
|
strv_env_unset_many(
|
|
|
|
m->environment,
|
|
|
|
"NOTIFY_SOCKET",
|
|
|
|
"MAINPID",
|
|
|
|
"MANAGERPID",
|
|
|
|
"LISTEN_PID",
|
|
|
|
"LISTEN_FDS",
|
|
|
|
"WATCHDOG_PID",
|
|
|
|
"WATCHDOG_USEC",
|
|
|
|
NULL);
|
|
|
|
}
|
|
|
|
|
2013-07-26 05:22:22 +02:00
|
|
|
static int manager_default_environment(Manager *m) {
|
2012-04-11 12:56:51 +02:00
|
|
|
assert(m);
|
|
|
|
|
2013-07-26 05:22:22 +02:00
|
|
|
if (m->running_as == SYSTEMD_SYSTEM) {
|
|
|
|
/* The system manager always starts with a clean
|
|
|
|
* environment for its children. It does not import
|
|
|
|
* the kernel or the parents exported variables.
|
|
|
|
*
|
|
|
|
* The initial passed environ is untouched to keep
|
|
|
|
* /proc/self/environ valid; it is used for tagging
|
|
|
|
* the init process inside containers. */
|
2013-09-15 17:56:19 +02:00
|
|
|
m->environment = strv_new("PATH=" DEFAULT_PATH,
|
|
|
|
NULL);
|
2013-07-26 05:22:22 +02:00
|
|
|
|
|
|
|
/* Import locale variables LC_*= from configuration */
|
|
|
|
locale_setup(&m->environment);
|
2014-01-12 12:39:56 +01:00
|
|
|
} else {
|
2013-07-26 05:22:22 +02:00
|
|
|
/* The user manager passes its own environment
|
|
|
|
* along to its children. */
|
|
|
|
m->environment = strv_copy(environ);
|
2014-01-12 12:39:56 +01:00
|
|
|
}
|
|
|
|
|
2013-07-26 05:22:22 +02:00
|
|
|
if (!m->environment)
|
|
|
|
return -ENOMEM;
|
2013-02-11 23:53:14 +01:00
|
|
|
|
2014-01-12 13:10:40 +01:00
|
|
|
manager_clean_environment(m);
|
2013-11-21 19:31:46 +01:00
|
|
|
strv_sort(m->environment);
|
|
|
|
|
2013-07-26 05:22:22 +02:00
|
|
|
return 0;
|
2012-04-11 12:56:51 +02:00
|
|
|
}
|
|
|
|
|
2014-01-07 14:41:24 +01:00
|
|
|
int manager_new(SystemdRunningAs running_as, bool test_run, Manager **_m) {
|
2010-01-28 02:01:15 +01:00
|
|
|
Manager *m;
|
2013-11-30 03:53:42 +01:00
|
|
|
int r;
|
2010-03-31 16:29:55 +02:00
|
|
|
|
|
|
|
assert(_m);
|
2010-04-06 23:55:42 +02:00
|
|
|
assert(running_as >= 0);
|
2012-09-18 17:11:12 +02:00
|
|
|
assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
|
2010-01-28 02:01:15 +01:00
|
|
|
|
2012-09-13 18:54:32 +02:00
|
|
|
m = new0(Manager, 1);
|
|
|
|
if (!m)
|
2010-03-31 16:29:55 +02:00
|
|
|
return -ENOMEM;
|
2009-11-18 00:42:52 +01:00
|
|
|
|
2013-05-14 00:00:37 +02:00
|
|
|
#ifdef ENABLE_EFI
|
2014-03-26 03:47:03 +01:00
|
|
|
if (running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0)
|
2013-09-24 00:23:35 +02:00
|
|
|
boot_timestamps(&m->userspace_timestamp, &m->firmware_timestamp, &m->loader_timestamp);
|
2013-05-14 00:00:37 +02:00
|
|
|
#endif
|
|
|
|
|
2010-04-06 23:55:42 +02:00
|
|
|
m->running_as = running_as;
|
2010-04-21 03:27:44 +02:00
|
|
|
m->exit_code = _MANAGER_EXIT_CODE_INVALID;
|
2014-03-24 16:22:34 +01:00
|
|
|
m->default_timer_accuracy_usec = USEC_PER_MINUTE;
|
2010-04-13 02:06:27 +02:00
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
m->idle_pipe[0] = m->idle_pipe[1] = m->idle_pipe[2] = m->idle_pipe[3] = -1;
|
2012-11-25 00:32:40 +01:00
|
|
|
|
2014-11-24 05:33:39 +01:00
|
|
|
m->pin_cgroupfs_fd = m->notify_fd = m->signal_fd = m->time_change_fd = m->dev_autofs_fd = m->private_listen_fd = m->kdbus_fd = m->utab_inotify_fd = -1;
|
2010-02-01 03:33:24 +01:00
|
|
|
m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
|
2010-01-24 00:39:29 +01:00
|
|
|
|
2014-10-26 02:30:51 +02:00
|
|
|
m->ask_password_inotify_fd = -1;
|
|
|
|
m->have_ask_password = -EINVAL; /* we don't know */
|
|
|
|
|
2014-01-07 14:41:24 +01:00
|
|
|
m->test_run = test_run;
|
|
|
|
|
2015-01-28 02:18:59 +01:00
|
|
|
/* Reboot immediately if the user hits C-A-D more often than 7x per 2s */
|
|
|
|
RATELIMIT_INIT(m->ctrl_alt_del_ratelimit, 2 * USEC_PER_SEC, 7);
|
|
|
|
|
2013-07-26 05:22:22 +02:00
|
|
|
r = manager_default_environment(m);
|
|
|
|
if (r < 0)
|
2010-05-09 23:53:52 +02:00
|
|
|
goto fail;
|
|
|
|
|
2014-08-13 01:00:18 +02:00
|
|
|
r = hashmap_ensure_allocated(&m->units, &string_hash_ops);
|
2013-11-19 21:12:59 +01:00
|
|
|
if (r < 0)
|
2009-11-18 00:42:52 +01:00
|
|
|
goto fail;
|
|
|
|
|
2014-08-13 01:00:18 +02:00
|
|
|
r = hashmap_ensure_allocated(&m->jobs, NULL);
|
2013-11-19 21:12:59 +01:00
|
|
|
if (r < 0)
|
2009-11-18 00:42:52 +01:00
|
|
|
goto fail;
|
|
|
|
|
2014-08-13 01:00:18 +02:00
|
|
|
r = hashmap_ensure_allocated(&m->cgroup_unit, &string_hash_ops);
|
2013-11-19 21:12:59 +01:00
|
|
|
if (r < 0)
|
2010-01-24 00:39:29 +01:00
|
|
|
goto fail;
|
|
|
|
|
2014-08-13 01:00:18 +02:00
|
|
|
r = hashmap_ensure_allocated(&m->watch_bus, &string_hash_ops);
|
2013-11-19 21:12:59 +01:00
|
|
|
if (r < 0)
|
2010-04-15 23:16:16 +02:00
|
|
|
goto fail;
|
|
|
|
|
2014-08-13 01:00:18 +02:00
|
|
|
r = set_ensure_allocated(&m->startup_units, NULL);
|
2014-05-15 17:09:34 +02:00
|
|
|
if (r < 0)
|
|
|
|
goto fail;
|
|
|
|
|
2014-08-13 01:00:18 +02:00
|
|
|
r = set_ensure_allocated(&m->failed_units, NULL);
|
2014-03-12 20:55:13 +01:00
|
|
|
if (r < 0)
|
|
|
|
goto fail;
|
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
r = sd_event_default(&m->event);
|
|
|
|
if (r < 0)
|
2012-11-25 00:32:40 +01:00
|
|
|
goto fail;
|
|
|
|
|
2014-02-19 23:54:58 +01:00
|
|
|
r = sd_event_add_defer(m->event, &m->run_queue_event_source, manager_dispatch_run_queue, m);
|
2013-11-25 15:22:41 +01:00
|
|
|
if (r < 0)
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
r = sd_event_source_set_priority(m->run_queue_event_source, SD_EVENT_PRIORITY_IDLE);
|
|
|
|
if (r < 0)
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
r = sd_event_source_set_enabled(m->run_queue_event_source, SD_EVENT_OFF);
|
|
|
|
if (r < 0)
|
|
|
|
goto fail;
|
|
|
|
|
2012-11-25 00:32:40 +01:00
|
|
|
r = manager_setup_signals(m);
|
|
|
|
if (r < 0)
|
2010-01-24 00:39:29 +01:00
|
|
|
goto fail;
|
|
|
|
|
2012-11-25 00:32:40 +01:00
|
|
|
r = manager_setup_cgroup(m);
|
|
|
|
if (r < 0)
|
2010-03-31 16:29:55 +02:00
|
|
|
goto fail;
|
|
|
|
|
2012-11-25 00:32:40 +01:00
|
|
|
r = manager_setup_time_change(m);
|
|
|
|
if (r < 0)
|
2010-06-16 05:10:31 +02:00
|
|
|
goto fail;
|
|
|
|
|
2013-11-25 21:08:39 +01:00
|
|
|
m->udev = udev_new();
|
|
|
|
if (!m->udev) {
|
|
|
|
r = -ENOMEM;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2013-12-21 00:19:37 +01:00
|
|
|
/* Note that we set up neither kdbus, nor the notify fd
|
|
|
|
* here. We do that after deserialization, since they might
|
|
|
|
* have gotten serialized across the reexec. */
|
|
|
|
|
2011-03-30 00:47:50 +02:00
|
|
|
m->taint_usr = dir_is_empty("/usr") > 0;
|
|
|
|
|
2010-03-31 16:29:55 +02:00
|
|
|
*_m = m;
|
|
|
|
return 0;
|
2009-11-18 00:42:52 +01:00
|
|
|
|
|
|
|
fail:
|
|
|
|
manager_free(m);
|
2010-03-31 16:29:55 +02:00
|
|
|
return r;
|
2009-11-18 00:42:52 +01:00
|
|
|
}
|
|
|
|
|
2013-12-21 00:19:37 +01:00
|
|
|
static int manager_setup_notify(Manager *m) {
|
2014-03-19 22:46:45 +01:00
|
|
|
int r;
|
2013-12-21 00:19:37 +01:00
|
|
|
|
2014-01-07 14:41:24 +01:00
|
|
|
if (m->test_run)
|
|
|
|
return 0;
|
|
|
|
|
2013-12-21 00:19:37 +01:00
|
|
|
if (m->notify_fd < 0) {
|
|
|
|
_cleanup_close_ int fd = -1;
|
2014-08-21 16:51:44 +02:00
|
|
|
union sockaddr_union sa = {
|
2014-03-19 22:46:45 +01:00
|
|
|
.sa.sa_family = AF_UNIX,
|
|
|
|
};
|
2014-08-21 16:51:44 +02:00
|
|
|
static const int one = 1;
|
2013-12-21 00:19:37 +01:00
|
|
|
|
|
|
|
/* First free all secondary fields */
|
|
|
|
free(m->notify_socket);
|
|
|
|
m->notify_socket = NULL;
|
|
|
|
m->notify_event_source = sd_event_source_unref(m->notify_event_source);
|
|
|
|
|
|
|
|
fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
|
2014-11-28 19:57:32 +01:00
|
|
|
if (fd < 0)
|
|
|
|
return log_error_errno(errno, "Failed to allocate notification socket: %m");
|
2013-12-21 00:19:37 +01:00
|
|
|
|
2014-11-07 02:05:50 +01:00
|
|
|
if (m->running_as == SYSTEMD_SYSTEM)
|
2014-03-19 22:46:45 +01:00
|
|
|
m->notify_socket = strdup("/run/systemd/notify");
|
2014-11-07 02:05:50 +01:00
|
|
|
else {
|
2014-03-19 22:46:45 +01:00
|
|
|
const char *e;
|
2013-12-21 00:19:37 +01:00
|
|
|
|
2014-03-19 22:46:45 +01:00
|
|
|
e = getenv("XDG_RUNTIME_DIR");
|
|
|
|
if (!e) {
|
2014-11-28 19:29:59 +01:00
|
|
|
log_error_errno(errno, "XDG_RUNTIME_DIR is not set: %m");
|
2014-03-19 22:46:45 +01:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
m->notify_socket = strappend(e, "/systemd/notify");
|
|
|
|
}
|
2014-11-07 02:05:50 +01:00
|
|
|
if (!m->notify_socket)
|
|
|
|
return log_oom();
|
|
|
|
|
|
|
|
(void) mkdir_parents_label(m->notify_socket, 0755);
|
2014-11-07 16:32:06 +01:00
|
|
|
(void) unlink(m->notify_socket);
|
2014-03-19 22:46:45 +01:00
|
|
|
|
|
|
|
strncpy(sa.un.sun_path, m->notify_socket, sizeof(sa.un.sun_path)-1);
|
|
|
|
r = bind(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + strlen(sa.un.sun_path));
|
2014-11-28 19:57:32 +01:00
|
|
|
if (r < 0)
|
|
|
|
return log_error_errno(errno, "bind(%s) failed: %m", sa.un.sun_path);
|
2013-12-21 00:19:37 +01:00
|
|
|
|
|
|
|
r = setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one));
|
2014-11-28 19:57:32 +01:00
|
|
|
if (r < 0)
|
|
|
|
return log_error_errno(errno, "SO_PASSCRED failed: %m");
|
2013-12-21 00:19:37 +01:00
|
|
|
|
|
|
|
m->notify_fd = fd;
|
|
|
|
fd = -1;
|
|
|
|
|
|
|
|
log_debug("Using notification socket %s", m->notify_socket);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!m->notify_event_source) {
|
2014-02-19 23:54:58 +01:00
|
|
|
r = sd_event_add_io(m->event, &m->notify_event_source, m->notify_fd, EPOLLIN, manager_dispatch_notify_fd, m);
|
2014-11-28 19:20:59 +01:00
|
|
|
if (r < 0)
|
|
|
|
return log_error_errno(r, "Failed to allocate notify event source: %m");
|
2013-12-21 00:19:37 +01:00
|
|
|
|
|
|
|
/* Process signals a bit earlier than SIGCHLD, so that we can
|
|
|
|
* still identify to which service an exit message belongs */
|
|
|
|
r = sd_event_source_set_priority(m->notify_event_source, -7);
|
2014-11-28 18:23:20 +01:00
|
|
|
if (r < 0)
|
|
|
|
return log_error_errno(r, "Failed to set priority of notify event source: %m");
|
2013-12-21 00:19:37 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int manager_setup_kdbus(Manager *m) {
|
2014-01-11 15:52:48 +01:00
|
|
|
#ifdef ENABLE_KDBUS
|
2013-12-21 00:19:37 +01:00
|
|
|
_cleanup_free_ char *p = NULL;
|
|
|
|
|
|
|
|
assert(m);
|
|
|
|
|
2014-01-07 14:41:24 +01:00
|
|
|
if (m->test_run || m->kdbus_fd >= 0)
|
2013-12-21 00:19:37 +01:00
|
|
|
return 0;
|
|
|
|
|
2015-01-18 23:54:42 +01:00
|
|
|
if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0)
|
2014-11-28 02:26:05 +01:00
|
|
|
bus_kernel_fix_attach_mask();
|
2014-11-27 21:28:13 +01:00
|
|
|
|
|
|
|
m->kdbus_fd = bus_kernel_create_bus(
|
|
|
|
m->running_as == SYSTEMD_SYSTEM ? "system" : "user",
|
|
|
|
m->running_as == SYSTEMD_SYSTEM, &p);
|
|
|
|
|
2014-11-28 17:34:26 +01:00
|
|
|
if (m->kdbus_fd < 0)
|
|
|
|
return log_debug_errno(m->kdbus_fd, "Failed to set up kdbus: %m");
|
2013-12-21 00:19:37 +01:00
|
|
|
|
|
|
|
log_debug("Successfully set up kdbus on %s", p);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int manager_connect_bus(Manager *m, bool reexecuting) {
|
|
|
|
bool try_bus_connect;
|
|
|
|
|
|
|
|
assert(m);
|
|
|
|
|
2014-01-07 14:41:24 +01:00
|
|
|
if (m->test_run)
|
|
|
|
return 0;
|
|
|
|
|
2013-12-21 00:19:37 +01:00
|
|
|
try_bus_connect =
|
|
|
|
m->kdbus_fd >= 0 ||
|
|
|
|
reexecuting ||
|
|
|
|
(m->running_as == SYSTEMD_USER && getenv("DBUS_SESSION_BUS_ADDRESS"));
|
|
|
|
|
|
|
|
/* Try to connect to the busses, if possible. */
|
|
|
|
return bus_init(m, try_bus_connect);
|
|
|
|
}
|
|
|
|
|
2010-04-06 02:43:58 +02:00
|
|
|
static unsigned manager_dispatch_cleanup_queue(Manager *m) {
|
2012-01-15 12:37:16 +01:00
|
|
|
Unit *u;
|
2010-04-06 02:43:58 +02:00
|
|
|
unsigned n = 0;
|
|
|
|
|
|
|
|
assert(m);
|
|
|
|
|
2012-01-15 12:37:16 +01:00
|
|
|
while ((u = m->cleanup_queue)) {
|
|
|
|
assert(u->in_cleanup_queue);
|
2010-04-06 02:43:58 +02:00
|
|
|
|
2012-01-15 12:37:16 +01:00
|
|
|
unit_free(u);
|
2010-04-06 02:43:58 +02:00
|
|
|
n++;
|
|
|
|
}
|
|
|
|
|
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
2010-04-23 18:47:49 +02:00
|
|
|
enum {
|
2011-02-21 15:32:17 +01:00
|
|
|
GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
|
2010-04-23 18:47:49 +02:00
|
|
|
GC_OFFSET_UNSURE, /* No clue */
|
|
|
|
GC_OFFSET_GOOD, /* We still need this unit */
|
|
|
|
GC_OFFSET_BAD, /* We don't need this unit anymore */
|
|
|
|
_GC_OFFSET_MAX
|
|
|
|
};
|
|
|
|
|
|
|
|
static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
|
2010-04-21 06:01:13 +02:00
|
|
|
Iterator i;
|
|
|
|
Unit *other;
|
2010-04-23 18:47:49 +02:00
|
|
|
bool is_bad;
|
2010-04-21 06:01:13 +02:00
|
|
|
|
|
|
|
assert(u);
|
|
|
|
|
2012-01-15 12:04:08 +01:00
|
|
|
if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
|
|
|
|
u->gc_marker == gc_marker + GC_OFFSET_BAD ||
|
|
|
|
u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
|
2010-04-21 06:01:13 +02:00
|
|
|
return;
|
|
|
|
|
2012-01-15 12:04:08 +01:00
|
|
|
if (u->in_cleanup_queue)
|
2010-04-21 06:01:13 +02:00
|
|
|
goto bad;
|
|
|
|
|
|
|
|
if (unit_check_gc(u))
|
|
|
|
goto good;
|
|
|
|
|
2012-01-15 12:04:08 +01:00
|
|
|
u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
|
2010-04-23 18:47:49 +02:00
|
|
|
|
|
|
|
is_bad = true;
|
|
|
|
|
2012-01-15 12:04:08 +01:00
|
|
|
SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
|
2010-04-21 06:01:13 +02:00
|
|
|
unit_gc_sweep(other, gc_marker);
|
|
|
|
|
2012-01-15 12:04:08 +01:00
|
|
|
if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
|
2010-04-21 06:01:13 +02:00
|
|
|
goto good;
|
2010-04-23 18:47:49 +02:00
|
|
|
|
2012-01-15 12:04:08 +01:00
|
|
|
if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
|
2010-04-23 18:47:49 +02:00
|
|
|
is_bad = false;
|
2010-04-21 06:01:13 +02:00
|
|
|
}
|
|
|
|
|
2010-04-23 18:47:49 +02:00
|
|
|
if (is_bad)
|
|
|
|
goto bad;
|
|
|
|
|
|
|
|
/* We were unable to find anything out about this entry, so
|
|
|
|
* let's investigate it later */
|
2012-01-15 12:04:08 +01:00
|
|
|
u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
|
2010-04-23 18:47:49 +02:00
|
|
|
unit_add_to_gc_queue(u);
|
|
|
|
return;
|
|
|
|
|
2010-04-21 06:01:13 +02:00
|
|
|
bad:
|
2010-04-23 18:47:49 +02:00
|
|
|
/* We definitely know that this one is not useful anymore, so
|
|
|
|
* let's mark it for deletion */
|
2012-01-15 12:04:08 +01:00
|
|
|
u->gc_marker = gc_marker + GC_OFFSET_BAD;
|
2010-04-23 18:47:49 +02:00
|
|
|
unit_add_to_cleanup_queue(u);
|
2010-04-21 06:01:13 +02:00
|
|
|
return;
|
|
|
|
|
|
|
|
good:
|
2012-01-15 12:04:08 +01:00
|
|
|
u->gc_marker = gc_marker + GC_OFFSET_GOOD;
|
2010-04-21 06:01:13 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned manager_dispatch_gc_queue(Manager *m) {
|
2012-01-15 12:37:16 +01:00
|
|
|
Unit *u;
|
2010-04-21 06:01:13 +02:00
|
|
|
unsigned n = 0;
|
2010-04-23 18:47:49 +02:00
|
|
|
unsigned gc_marker;
|
2010-04-21 06:01:13 +02:00
|
|
|
|
|
|
|
assert(m);
|
|
|
|
|
2013-07-02 17:41:57 +02:00
|
|
|
/* log_debug("Running GC..."); */
|
2010-04-21 06:01:13 +02:00
|
|
|
|
2010-04-23 18:47:49 +02:00
|
|
|
m->gc_marker += _GC_OFFSET_MAX;
|
|
|
|
if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
|
2010-04-22 02:41:14 +02:00
|
|
|
m->gc_marker = 1;
|
2010-04-21 06:01:13 +02:00
|
|
|
|
2010-04-23 18:47:49 +02:00
|
|
|
gc_marker = m->gc_marker;
|
|
|
|
|
2012-01-15 12:37:16 +01:00
|
|
|
while ((u = m->gc_queue)) {
|
|
|
|
assert(u->in_gc_queue);
|
2010-04-21 06:01:13 +02:00
|
|
|
|
2012-01-15 12:37:16 +01:00
|
|
|
unit_gc_sweep(u, gc_marker);
|
2010-04-23 18:47:49 +02:00
|
|
|
|
2013-10-14 06:10:14 +02:00
|
|
|
LIST_REMOVE(gc_queue, m->gc_queue, u);
|
2012-01-15 12:37:16 +01:00
|
|
|
u->in_gc_queue = false;
|
2010-04-21 06:01:13 +02:00
|
|
|
|
|
|
|
n++;
|
|
|
|
|
2012-01-15 12:37:16 +01:00
|
|
|
if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
|
|
|
|
u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
|
2014-11-27 20:20:23 +01:00
|
|
|
log_unit_debug(u->id, "Collecting %s", u->id);
|
2012-01-15 12:37:16 +01:00
|
|
|
u->gc_marker = gc_marker + GC_OFFSET_BAD;
|
|
|
|
unit_add_to_cleanup_queue(u);
|
2010-04-21 06:01:13 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
m->n_in_gc_queue = 0;
|
|
|
|
|
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
2010-04-21 03:27:44 +02:00
|
|
|
static void manager_clear_jobs_and_units(Manager *m) {
|
|
|
|
Unit *u;
|
2009-11-18 00:42:52 +01:00
|
|
|
|
|
|
|
assert(m);
|
|
|
|
|
2010-01-26 21:39:06 +01:00
|
|
|
while ((u = hashmap_first(m->units)))
|
|
|
|
unit_free(u);
|
2010-06-05 02:16:20 +02:00
|
|
|
|
|
|
|
manager_dispatch_cleanup_queue(m);
|
|
|
|
|
|
|
|
assert(!m->load_queue);
|
|
|
|
assert(!m->run_queue);
|
|
|
|
assert(!m->dbus_unit_queue);
|
|
|
|
assert(!m->dbus_job_queue);
|
|
|
|
assert(!m->cleanup_queue);
|
|
|
|
assert(!m->gc_queue);
|
|
|
|
|
|
|
|
assert(hashmap_isempty(m->jobs));
|
|
|
|
assert(hashmap_isempty(m->units));
|
2013-03-01 14:47:46 +01:00
|
|
|
|
|
|
|
m->n_on_console = 0;
|
|
|
|
m->n_running_jobs = 0;
|
2010-04-21 03:27:44 +02:00
|
|
|
}
|
|
|
|
|
2014-11-08 16:06:12 +01:00
|
|
|
Manager* manager_free(Manager *m) {
|
2010-04-21 03:27:44 +02:00
|
|
|
UnitType c;
|
2012-03-21 18:03:40 +01:00
|
|
|
int i;
|
2010-01-26 21:39:06 +01:00
|
|
|
|
2014-11-08 16:06:12 +01:00
|
|
|
if (!m)
|
|
|
|
return NULL;
|
2010-04-21 03:27:44 +02:00
|
|
|
|
|
|
|
manager_clear_jobs_and_units(m);
|
2010-04-06 02:43:58 +02:00
|
|
|
|
2010-01-28 06:45:44 +01:00
|
|
|
for (c = 0; c < _UNIT_TYPE_MAX; c++)
|
|
|
|
if (unit_vtable[c]->shutdown)
|
|
|
|
unit_vtable[c]->shutdown(m);
|
|
|
|
|
2010-04-21 03:27:44 +02:00
|
|
|
/* If we reexecute ourselves, we keep the root cgroup
|
|
|
|
* around */
|
2010-07-11 00:50:49 +02:00
|
|
|
manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
|
2010-03-31 16:29:55 +02:00
|
|
|
|
2010-11-11 21:28:33 +01:00
|
|
|
manager_undo_generators(m);
|
|
|
|
|
2010-06-19 03:04:04 +02:00
|
|
|
bus_done(m);
|
2010-02-01 03:33:24 +01:00
|
|
|
|
2010-01-26 21:39:06 +01:00
|
|
|
hashmap_free(m->units);
|
2009-11-18 00:42:52 +01:00
|
|
|
hashmap_free(m->jobs);
|
2014-02-07 11:58:25 +01:00
|
|
|
hashmap_free(m->watch_pids1);
|
|
|
|
hashmap_free(m->watch_pids2);
|
2010-04-15 23:16:16 +02:00
|
|
|
hashmap_free(m->watch_bus);
|
2010-01-24 00:39:29 +01:00
|
|
|
|
2014-05-15 17:09:34 +02:00
|
|
|
set_free(m->startup_units);
|
2014-03-12 20:55:13 +01:00
|
|
|
set_free(m->failed_units);
|
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
sd_event_source_unref(m->signal_event_source);
|
|
|
|
sd_event_source_unref(m->notify_event_source);
|
|
|
|
sd_event_source_unref(m->time_change_event_source);
|
|
|
|
sd_event_source_unref(m->jobs_in_progress_event_source);
|
|
|
|
sd_event_source_unref(m->idle_pipe_event_source);
|
2013-11-25 15:22:41 +01:00
|
|
|
sd_event_source_unref(m->run_queue_event_source);
|
2013-11-19 21:12:59 +01:00
|
|
|
|
2014-03-18 19:22:43 +01:00
|
|
|
safe_close(m->signal_fd);
|
|
|
|
safe_close(m->notify_fd);
|
|
|
|
safe_close(m->time_change_fd);
|
|
|
|
safe_close(m->kdbus_fd);
|
2013-11-19 21:12:59 +01:00
|
|
|
|
2014-10-26 02:30:51 +02:00
|
|
|
manager_close_ask_password(m);
|
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
manager_close_idle_pipe(m);
|
|
|
|
|
2013-11-25 21:08:39 +01:00
|
|
|
udev_unref(m->udev);
|
2013-11-19 21:12:59 +01:00
|
|
|
sd_event_unref(m->event);
|
2009-11-18 00:42:52 +01:00
|
|
|
|
2010-06-18 23:12:48 +02:00
|
|
|
free(m->notify_socket);
|
|
|
|
|
2010-06-15 14:45:15 +02:00
|
|
|
lookup_paths_free(&m->lookup_paths);
|
2010-05-09 23:53:52 +02:00
|
|
|
strv_free(m->environment);
|
2010-02-13 01:07:02 +01:00
|
|
|
|
2013-06-27 04:14:27 +02:00
|
|
|
hashmap_free(m->cgroup_unit);
|
2010-07-11 00:50:49 +02:00
|
|
|
set_free_free(m->unit_path_cache);
|
2010-06-18 20:15:34 +02:00
|
|
|
|
2012-05-09 01:24:50 +02:00
|
|
|
free(m->switch_root);
|
|
|
|
free(m->switch_root_init);
|
|
|
|
|
2014-03-05 02:29:58 +01:00
|
|
|
for (i = 0; i < _RLIMIT_MAX; i++)
|
2012-03-21 18:03:40 +01:00
|
|
|
free(m->rlimit[i]);
|
|
|
|
|
2013-09-26 20:14:24 +02:00
|
|
|
assert(hashmap_isempty(m->units_requiring_mounts_for));
|
|
|
|
hashmap_free(m->units_requiring_mounts_for);
|
|
|
|
|
2009-11-18 00:42:52 +01:00
|
|
|
free(m);
|
2014-11-08 16:06:12 +01:00
|
|
|
return NULL;
|
2009-11-18 00:42:52 +01:00
|
|
|
}
|
|
|
|
|
2010-04-21 03:27:44 +02:00
|
|
|
int manager_enumerate(Manager *m) {
|
2014-12-12 21:05:32 +01:00
|
|
|
int r = 0;
|
2010-01-29 03:18:09 +01:00
|
|
|
UnitType c;
|
|
|
|
|
|
|
|
assert(m);
|
|
|
|
|
2010-04-21 03:27:44 +02:00
|
|
|
/* Let's ask every type to load all units from disk/kernel
|
|
|
|
* that it might know */
|
2014-12-12 21:05:32 +01:00
|
|
|
for (c = 0; c < _UNIT_TYPE_MAX; c++) {
|
|
|
|
int q;
|
|
|
|
|
|
|
|
if (unit_vtable[c]->supported && !unit_vtable[c]->supported(m)) {
|
2015-02-20 10:53:28 +01:00
|
|
|
log_debug("Unit type .%s is not supported on this system.", unit_type_to_string(c));
|
2014-12-12 21:05:32 +01:00
|
|
|
continue;
|
2013-09-26 20:14:24 +02:00
|
|
|
}
|
2010-01-29 03:18:09 +01:00
|
|
|
|
2014-12-12 21:05:32 +01:00
|
|
|
if (!unit_vtable[c]->enumerate)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
q = unit_vtable[c]->enumerate(m);
|
|
|
|
if (q < 0)
|
|
|
|
r = q;
|
|
|
|
}
|
|
|
|
|
2010-01-29 03:18:09 +01:00
|
|
|
manager_dispatch_load_queue(m);
|
2010-04-21 03:27:44 +02:00
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2013-11-08 18:11:09 +01:00
|
|
|
static int manager_coldplug(Manager *m) {
|
2014-03-03 01:33:45 +01:00
|
|
|
int r = 0;
|
2010-04-21 03:27:44 +02:00
|
|
|
Iterator i;
|
|
|
|
Unit *u;
|
|
|
|
char *k;
|
|
|
|
|
2015-03-07 14:44:52 +01:00
|
|
|
/*
|
|
|
|
* Some unit types tend to spawn jobs or check other units' state
|
|
|
|
* during coldplug. This is wrong because it is undefined whether the
|
|
|
|
* units in question have been already coldplugged (i. e. their state
|
|
|
|
* restored). This way, we can easily re-start an already started unit
|
|
|
|
* or otherwise make a wrong decision based on the unit's state.
|
|
|
|
*
|
|
|
|
* Solve this by providing a way for coldplug functions to defer
|
|
|
|
* such actions until after all units have been coldplugged.
|
|
|
|
*
|
|
|
|
* We store Unit* -> int(*)(Unit*).
|
|
|
|
*
|
|
|
|
* https://bugs.freedesktop.org/show_bug.cgi?id=88401
|
|
|
|
*/
|
|
|
|
_cleanup_hashmap_free_ Hashmap *deferred_work = NULL;
|
|
|
|
int(*proc)(Unit*);
|
|
|
|
|
2010-04-21 03:27:44 +02:00
|
|
|
assert(m);
|
2010-01-29 03:18:09 +01:00
|
|
|
|
2015-03-07 14:44:52 +01:00
|
|
|
deferred_work = hashmap_new(&trivial_hash_ops);
|
|
|
|
if (!deferred_work)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2010-01-29 03:18:09 +01:00
|
|
|
/* Then, let's set up their initial state. */
|
|
|
|
HASHMAP_FOREACH_KEY(u, k, m->units, i) {
|
2014-03-03 01:33:45 +01:00
|
|
|
int q;
|
2010-01-29 03:18:09 +01:00
|
|
|
|
|
|
|
/* ignore aliases */
|
2012-01-15 12:04:08 +01:00
|
|
|
if (u->id != k)
|
2010-01-29 03:18:09 +01:00
|
|
|
continue;
|
|
|
|
|
2015-03-07 14:44:52 +01:00
|
|
|
q = unit_coldplug(u, deferred_work);
|
|
|
|
if (q < 0)
|
|
|
|
r = q;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* After coldplugging and setting up initial state of the units,
|
|
|
|
* let's perform operations which spawn jobs or query units' state. */
|
|
|
|
HASHMAP_FOREACH_KEY(proc, u, deferred_work, i) {
|
|
|
|
int q;
|
|
|
|
|
|
|
|
q = proc(u);
|
2014-03-03 01:33:45 +01:00
|
|
|
if (q < 0)
|
2010-06-03 14:26:50 +02:00
|
|
|
r = q;
|
2010-01-29 03:18:09 +01:00
|
|
|
}
|
|
|
|
|
2010-04-21 03:27:44 +02:00
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2010-07-11 00:52:00 +02:00
|
|
|
static void manager_build_unit_path_cache(Manager *m) {
|
|
|
|
char **i;
|
2014-09-11 21:14:53 +02:00
|
|
|
_cleanup_closedir_ DIR *d = NULL;
|
2010-07-11 00:52:00 +02:00
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(m);
|
|
|
|
|
|
|
|
set_free_free(m->unit_path_cache);
|
|
|
|
|
2014-08-13 01:00:18 +02:00
|
|
|
m->unit_path_cache = set_new(&string_hash_ops);
|
2013-02-07 04:49:19 +01:00
|
|
|
if (!m->unit_path_cache) {
|
2010-07-11 00:52:00 +02:00
|
|
|
log_error("Failed to allocate unit path cache.");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* This simply builds a list of files we know exist, so that
|
|
|
|
* we don't always have to go to disk */
|
|
|
|
|
|
|
|
STRV_FOREACH(i, m->lookup_paths.unit_path) {
|
|
|
|
struct dirent *de;
|
|
|
|
|
2013-01-02 22:03:35 +01:00
|
|
|
d = opendir(*i);
|
|
|
|
if (!d) {
|
2013-02-07 04:49:19 +01:00
|
|
|
if (errno != ENOENT)
|
2014-11-28 19:29:59 +01:00
|
|
|
log_error_errno(errno, "Failed to open directory %s: %m", *i);
|
2010-07-11 00:52:00 +02:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
while ((de = readdir(d))) {
|
|
|
|
char *p;
|
|
|
|
|
2014-12-19 20:03:36 +01:00
|
|
|
if (hidden_file(de->d_name))
|
2010-07-11 00:52:00 +02:00
|
|
|
continue;
|
|
|
|
|
2012-07-13 13:41:01 +02:00
|
|
|
p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
|
2011-08-01 02:39:22 +02:00
|
|
|
if (!p) {
|
2010-07-11 00:52:00 +02:00
|
|
|
r = -ENOMEM;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2013-04-23 05:12:15 +02:00
|
|
|
r = set_consume(m->unit_path_cache, p);
|
|
|
|
if (r < 0)
|
2010-07-11 00:52:00 +02:00
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
closedir(d);
|
|
|
|
d = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
fail:
|
2014-11-28 13:19:16 +01:00
|
|
|
log_error_errno(r, "Failed to build unit path cache: %m");
|
2010-07-11 00:52:00 +02:00
|
|
|
|
|
|
|
set_free_free(m->unit_path_cache);
|
|
|
|
m->unit_path_cache = NULL;
|
|
|
|
}
|
|
|
|
|
2013-11-08 18:11:09 +01:00
|
|
|
|
|
|
|
static int manager_distribute_fds(Manager *m, FDSet *fds) {
|
|
|
|
Unit *u;
|
|
|
|
Iterator i;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(m);
|
|
|
|
|
|
|
|
HASHMAP_FOREACH(u, m->units, i) {
|
|
|
|
|
|
|
|
if (fdset_size(fds) <= 0)
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (UNIT_VTABLE(u)->distribute_fds) {
|
|
|
|
r = UNIT_VTABLE(u)->distribute_fds(u, fds);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-04-21 03:27:44 +02:00
|
|
|
int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
|
|
|
|
int r, q;
|
|
|
|
|
|
|
|
assert(m);
|
|
|
|
|
2013-05-08 14:29:12 +02:00
|
|
|
dual_timestamp_get(&m->generators_start_timestamp);
|
Implement masking and overriding of generators
Sometimes it is necessary to stop a generator from running. Either
because of a bug, or for testing, or some other reason. The only way
to do that would be to rename or chmod the generator binary, which is
inconvenient and does not survive upgrades. Allow masking and
overriding generators similarly to units and other configuration
files.
For the systemd instance, masking would be more common, rather than
overriding generators. For the user instances, it may also be useful
for users to have generators in $XDG_CONFIG_HOME to augment or
override system-wide generators.
Directories are searched according to the usual scheme (/usr/lib,
/usr/local/lib, /run, /etc), and files with the same name in higher
priority directories override files with the same name in lower
priority directories. Empty files and links to /dev/null mask a given
name.
https://bugs.freedesktop.org/show_bug.cgi?id=87230
2015-01-09 02:47:25 +01:00
|
|
|
r = manager_run_generators(m);
|
2013-05-08 14:29:12 +02:00
|
|
|
dual_timestamp_get(&m->generators_finish_timestamp);
|
Implement masking and overriding of generators
Sometimes it is necessary to stop a generator from running. Either
because of a bug, or for testing, or some other reason. The only way
to do that would be to rename or chmod the generator binary, which is
inconvenient and does not survive upgrades. Allow masking and
overriding generators similarly to units and other configuration
files.
For the systemd instance, masking would be more common, rather than
overriding generators. For the user instances, it may also be useful
for users to have generators in $XDG_CONFIG_HOME to augment or
override system-wide generators.
Directories are searched according to the usual scheme (/usr/lib,
/usr/local/lib, /run, /etc), and files with the same name in higher
priority directories override files with the same name in lower
priority directories. Empty files and links to /dev/null mask a given
name.
https://bugs.freedesktop.org/show_bug.cgi?id=87230
2015-01-09 02:47:25 +01:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2010-11-11 21:28:33 +01:00
|
|
|
|
2012-05-23 03:43:29 +02:00
|
|
|
r = lookup_paths_init(
|
|
|
|
&m->lookup_paths, m->running_as, true,
|
2014-04-24 07:44:10 +02:00
|
|
|
NULL,
|
2012-05-23 03:43:29 +02:00
|
|
|
m->generator_unit_path,
|
|
|
|
m->generator_unit_path_early,
|
|
|
|
m->generator_unit_path_late);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
2010-07-11 00:52:00 +02:00
|
|
|
manager_build_unit_path_cache(m);
|
|
|
|
|
2010-07-13 19:01:20 +02:00
|
|
|
/* If we will deserialize make sure that during enumeration
|
|
|
|
* this is already known, so we increase the counter here
|
|
|
|
* already */
|
|
|
|
if (serialization)
|
2011-07-06 00:47:39 +02:00
|
|
|
m->n_reloading ++;
|
2010-07-13 19:01:20 +02:00
|
|
|
|
2010-04-21 03:27:44 +02:00
|
|
|
/* First, enumerate what we can from all config files */
|
2013-11-19 21:12:59 +01:00
|
|
|
dual_timestamp_get(&m->units_load_start_timestamp);
|
2010-04-21 03:27:44 +02:00
|
|
|
r = manager_enumerate(m);
|
2013-11-19 21:12:59 +01:00
|
|
|
dual_timestamp_get(&m->units_load_finish_timestamp);
|
2010-04-21 03:27:44 +02:00
|
|
|
|
|
|
|
/* Second, deserialize if there is something to deserialize */
|
2014-07-18 23:05:18 +02:00
|
|
|
if (serialization)
|
|
|
|
r = manager_deserialize(m, serialization, fds);
|
2010-04-21 03:27:44 +02:00
|
|
|
|
2012-12-22 19:30:07 +01:00
|
|
|
/* Any fds left? Find some unit which wants them. This is
|
|
|
|
* useful to allow container managers to pass some file
|
|
|
|
* descriptors to us pre-initialized. This enables
|
|
|
|
* socket-based activation of entire containers. */
|
|
|
|
if (fdset_size(fds) > 0) {
|
|
|
|
q = manager_distribute_fds(m, fds);
|
2014-07-18 23:05:18 +02:00
|
|
|
if (q < 0 && r == 0)
|
2012-12-22 19:30:07 +01:00
|
|
|
r = q;
|
|
|
|
}
|
|
|
|
|
2013-12-21 00:19:37 +01:00
|
|
|
/* We might have deserialized the notify fd, but if we didn't
|
|
|
|
* then let's create the bus now */
|
2014-07-18 23:05:18 +02:00
|
|
|
q = manager_setup_notify(m);
|
|
|
|
if (q < 0 && r == 0)
|
|
|
|
r = q;
|
2013-12-21 00:19:37 +01:00
|
|
|
|
2013-11-30 03:53:42 +01:00
|
|
|
/* We might have deserialized the kdbus control fd, but if we
|
|
|
|
* didn't, then let's create the bus now. */
|
|
|
|
manager_setup_kdbus(m);
|
|
|
|
manager_connect_bus(m, !!serialization);
|
2014-03-03 01:33:45 +01:00
|
|
|
bus_track_coldplug(m, &m->subscribed, &m->deserialized_subscribed);
|
2013-11-30 03:53:42 +01:00
|
|
|
|
2010-04-21 03:27:44 +02:00
|
|
|
/* Third, fire things up! */
|
2012-05-23 03:43:29 +02:00
|
|
|
q = manager_coldplug(m);
|
2014-07-18 23:05:18 +02:00
|
|
|
if (q < 0 && r == 0)
|
2010-04-21 03:27:44 +02:00
|
|
|
r = q;
|
|
|
|
|
2010-07-13 19:01:20 +02:00
|
|
|
if (serialization) {
|
2011-07-06 00:47:39 +02:00
|
|
|
assert(m->n_reloading > 0);
|
|
|
|
m->n_reloading --;
|
2013-07-10 21:10:53 +02:00
|
|
|
|
|
|
|
/* Let's wait for the UnitNew/JobNew messages being
|
|
|
|
* sent, before we notify that the reload is
|
|
|
|
* finished */
|
|
|
|
m->send_reloading_done = true;
|
2010-07-13 19:01:20 +02:00
|
|
|
}
|
|
|
|
|
2010-04-21 03:27:44 +02:00
|
|
|
return r;
|
2010-01-29 03:18:09 +01:00
|
|
|
}
|
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
|
2010-01-20 02:12:51 +01:00
|
|
|
int r;
|
2012-04-20 10:22:07 +02:00
|
|
|
Transaction *tr;
|
2010-01-20 02:12:51 +01:00
|
|
|
|
|
|
|
assert(m);
|
|
|
|
assert(type < _JOB_TYPE_MAX);
|
2010-01-26 21:39:06 +01:00
|
|
|
assert(unit);
|
2010-01-20 02:12:51 +01:00
|
|
|
assert(mode < _JOB_MODE_MAX);
|
2009-11-18 00:42:52 +01:00
|
|
|
|
2014-10-31 01:32:17 +01:00
|
|
|
if (mode == JOB_ISOLATE && type != JOB_START)
|
|
|
|
return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Isolate is only valid for start.");
|
2010-04-22 02:42:59 +02:00
|
|
|
|
2014-10-31 01:32:17 +01:00
|
|
|
if (mode == JOB_ISOLATE && !unit->allow_isolate)
|
|
|
|
return sd_bus_error_setf(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
|
2010-08-30 22:45:46 +02:00
|
|
|
|
2014-11-27 20:20:23 +01:00
|
|
|
log_unit_debug(unit->id,
|
2013-01-05 18:00:35 +01:00
|
|
|
"Trying to enqueue job %s/%s/%s", unit->id,
|
|
|
|
job_type_to_string(type), job_mode_to_string(mode));
|
2010-01-29 04:11:36 +01:00
|
|
|
|
core: add NOP jobs, job type collapsing
Two of our current job types are special:
JOB_TRY_RESTART, JOB_RELOAD_OR_START.
They differ from other job types by being sensitive to the unit active state.
They perform some action when the unit is active and some other action
otherwise. This raises a question: when exactly should the unit state be
checked to make the decision?
Currently the unit state is checked when the job becomes runnable. It's more
sensible to check the state immediately when the job is added by the user.
When the user types "systemctl try-restart foo.service", he really intends
to restart the service if it's running right now. If it isn't running right
now, the restart is pointless.
Consider the example (from Bugzilla[1]):
sleep.service takes some time to start.
hello.service has After=sleep.service.
Both services get started. Two jobs will appear:
hello.service/start waiting
sleep.service/start running
Then someone runs "systemctl try-restart hello.service".
Currently the try-restart operation will block and wait for
sleep.service/start to complete.
The correct result is to complete the try-restart operation immediately
with success, because hello.service is not running. The two original
jobs must not be disturbed by this.
To fix this we introduce two new concepts:
- a new job type: JOB_NOP
A JOB_NOP job does not do anything to the unit. It does not pull in any
dependencies. It is always immediately runnable. When installed to a unit,
it sits in a special slot (u->nop_job) where it never conflicts with
the installed job (u->job) of a different type. It never merges with jobs
of other types, but it can merge into an already installed JOB_NOP job.
- "collapsing" of job types
When a job of one of the two special types is added, the state of the unit
is checked immediately and the job type changes:
JOB_TRY_RESTART -> JOB_RESTART or JOB_NOP
JOB_RELOAD_OR_START -> JOB_RELOAD or JOB_START
Should a job type JOB_RELOAD_OR_START appear later during job merging, it
collapses immediately afterwards.
Collapsing actually makes some things simpler, because there are now fewer
job types that are allowed in the transaction.
[1] Fixes: https://bugzilla.redhat.com/show_bug.cgi?id=753586
2012-04-25 11:58:27 +02:00
|
|
|
job_type_collapse(&type, unit);
|
|
|
|
|
2013-02-22 11:21:37 +01:00
|
|
|
tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
|
2012-04-20 10:22:07 +02:00
|
|
|
if (!tr)
|
|
|
|
return -ENOMEM;
|
2010-01-19 04:15:20 +01:00
|
|
|
|
2012-04-20 10:22:07 +02:00
|
|
|
r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
|
|
|
|
mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
|
2012-04-20 00:33:26 +02:00
|
|
|
mode == JOB_IGNORE_DEPENDENCIES, e);
|
2012-04-20 10:22:07 +02:00
|
|
|
if (r < 0)
|
|
|
|
goto tr_abort;
|
2010-04-22 02:42:59 +02:00
|
|
|
|
2012-04-20 10:22:07 +02:00
|
|
|
if (mode == JOB_ISOLATE) {
|
|
|
|
r = transaction_add_isolate_jobs(tr, m);
|
|
|
|
if (r < 0)
|
|
|
|
goto tr_abort;
|
|
|
|
}
|
|
|
|
|
|
|
|
r = transaction_activate(tr, m, mode, e);
|
|
|
|
if (r < 0)
|
|
|
|
goto tr_abort;
|
2010-01-20 02:12:51 +01:00
|
|
|
|
2014-11-27 20:20:23 +01:00
|
|
|
log_unit_debug(unit->id,
|
2013-01-05 18:00:35 +01:00
|
|
|
"Enqueued job %s/%s as %u", unit->id,
|
|
|
|
job_type_to_string(type), (unsigned) tr->anchor_job->id);
|
2010-01-29 03:18:09 +01:00
|
|
|
|
2010-01-20 02:12:51 +01:00
|
|
|
if (_ret)
|
2012-04-20 00:33:26 +02:00
|
|
|
*_ret = tr->anchor_job;
|
2009-11-18 00:42:52 +01:00
|
|
|
|
2012-04-20 10:22:07 +02:00
|
|
|
transaction_free(tr);
|
2010-01-20 02:12:51 +01:00
|
|
|
return 0;
|
2012-04-20 10:22:07 +02:00
|
|
|
|
|
|
|
tr_abort:
|
|
|
|
transaction_abort(tr);
|
|
|
|
transaction_free(tr);
|
|
|
|
return r;
|
2010-01-20 02:12:51 +01:00
|
|
|
}
|
2009-11-18 00:42:52 +01:00
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
|
2010-04-13 01:59:06 +02:00
|
|
|
Unit *unit;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(m);
|
|
|
|
assert(type < _JOB_TYPE_MAX);
|
|
|
|
assert(name);
|
|
|
|
assert(mode < _JOB_MODE_MAX);
|
|
|
|
|
2012-09-18 01:55:49 +02:00
|
|
|
r = manager_load_unit(m, name, NULL, NULL, &unit);
|
|
|
|
if (r < 0)
|
2010-04-13 01:59:06 +02:00
|
|
|
return r;
|
|
|
|
|
2010-07-08 02:43:18 +02:00
|
|
|
return manager_add_job(m, type, unit, mode, override, e, _ret);
|
2010-04-13 01:59:06 +02:00
|
|
|
}
|
|
|
|
|
2009-11-18 00:42:52 +01:00
|
|
|
Job *manager_get_job(Manager *m, uint32_t id) {
|
|
|
|
assert(m);
|
|
|
|
|
|
|
|
return hashmap_get(m->jobs, UINT32_TO_PTR(id));
|
|
|
|
}
|
|
|
|
|
2010-01-26 21:39:06 +01:00
|
|
|
Unit *manager_get_unit(Manager *m, const char *name) {
|
2009-11-18 00:42:52 +01:00
|
|
|
assert(m);
|
|
|
|
assert(name);
|
|
|
|
|
2010-01-26 21:39:06 +01:00
|
|
|
return hashmap_get(m->units, name);
|
2009-11-18 00:42:52 +01:00
|
|
|
}
|
|
|
|
|
2010-02-05 00:38:41 +01:00
|
|
|
unsigned manager_dispatch_load_queue(Manager *m) {
|
2012-01-15 12:37:16 +01:00
|
|
|
Unit *u;
|
2010-02-05 00:38:41 +01:00
|
|
|
unsigned n = 0;
|
2009-11-18 00:42:52 +01:00
|
|
|
|
|
|
|
assert(m);
|
|
|
|
|
2009-11-19 02:52:17 +01:00
|
|
|
/* Make sure we are not run recursively */
|
|
|
|
if (m->dispatching_load_queue)
|
2010-02-05 00:38:41 +01:00
|
|
|
return 0;
|
2009-11-19 02:52:17 +01:00
|
|
|
|
|
|
|
m->dispatching_load_queue = true;
|
|
|
|
|
2010-01-26 21:39:06 +01:00
|
|
|
/* Dispatches the load queue. Takes a unit from the queue and
|
2009-11-18 00:42:52 +01:00
|
|
|
* tries to load its data until the queue is empty */
|
|
|
|
|
2012-01-15 12:37:16 +01:00
|
|
|
while ((u = m->load_queue)) {
|
|
|
|
assert(u->in_load_queue);
|
2010-01-26 04:18:44 +01:00
|
|
|
|
2012-01-15 12:37:16 +01:00
|
|
|
unit_load(u);
|
2010-02-05 00:38:41 +01:00
|
|
|
n++;
|
2009-11-18 00:42:52 +01:00
|
|
|
}
|
|
|
|
|
2009-11-19 02:52:17 +01:00
|
|
|
m->dispatching_load_queue = false;
|
2010-02-05 00:38:41 +01:00
|
|
|
return n;
|
2009-11-18 00:42:52 +01:00
|
|
|
}
|
|
|
|
|
2013-06-28 04:12:58 +02:00
|
|
|
int manager_load_unit_prepare(
|
|
|
|
Manager *m,
|
|
|
|
const char *name,
|
|
|
|
const char *path,
|
2013-11-19 21:12:59 +01:00
|
|
|
sd_bus_error *e,
|
2013-06-28 04:12:58 +02:00
|
|
|
Unit **_ret) {
|
|
|
|
|
2010-01-26 21:39:06 +01:00
|
|
|
Unit *ret;
|
2012-01-15 10:53:49 +01:00
|
|
|
UnitType t;
|
2009-11-18 00:42:52 +01:00
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(m);
|
2010-04-15 03:11:11 +02:00
|
|
|
assert(name || path);
|
2009-11-18 00:42:52 +01:00
|
|
|
|
2010-04-24 04:26:33 +02:00
|
|
|
/* This will prepare the unit for loading, but not actually
|
|
|
|
* load anything from disk. */
|
2010-01-27 00:15:56 +01:00
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
if (path && !is_path(path))
|
|
|
|
return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Path %s is not absolute.", path);
|
2010-04-15 03:11:11 +02:00
|
|
|
|
|
|
|
if (!name)
|
2013-12-07 03:29:55 +01:00
|
|
|
name = basename(path);
|
2010-04-15 03:11:11 +02:00
|
|
|
|
2012-01-15 10:53:49 +01:00
|
|
|
t = unit_name_to_type(name);
|
|
|
|
|
2013-12-26 21:30:22 +01:00
|
|
|
if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, TEMPLATE_INVALID))
|
2013-11-19 21:12:59 +01:00
|
|
|
return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Unit name %s is not valid.", name);
|
2009-11-18 00:42:52 +01:00
|
|
|
|
2012-01-15 10:53:49 +01:00
|
|
|
ret = manager_get_unit(m, name);
|
|
|
|
if (ret) {
|
2010-01-26 04:18:44 +01:00
|
|
|
*_ret = ret;
|
2010-05-16 04:30:45 +02:00
|
|
|
return 1;
|
2010-01-26 04:18:44 +01:00
|
|
|
}
|
2009-11-18 00:42:52 +01:00
|
|
|
|
2012-01-15 10:53:49 +01:00
|
|
|
ret = unit_new(m, unit_vtable[t]->object_size);
|
|
|
|
if (!ret)
|
2009-11-18 00:42:52 +01:00
|
|
|
return -ENOMEM;
|
|
|
|
|
2012-01-15 10:53:49 +01:00
|
|
|
if (path) {
|
2012-01-15 12:04:08 +01:00
|
|
|
ret->fragment_path = strdup(path);
|
|
|
|
if (!ret->fragment_path) {
|
2010-01-27 00:15:56 +01:00
|
|
|
unit_free(ret);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
2012-01-15 10:53:49 +01:00
|
|
|
}
|
2010-01-27 00:15:56 +01:00
|
|
|
|
2013-05-31 02:28:09 +02:00
|
|
|
r = unit_add_name(ret, name);
|
|
|
|
if (r < 0) {
|
2010-01-26 21:39:06 +01:00
|
|
|
unit_free(ret);
|
2010-01-21 00:51:37 +01:00
|
|
|
return r;
|
2009-11-18 00:42:52 +01:00
|
|
|
}
|
|
|
|
|
2010-01-26 21:39:06 +01:00
|
|
|
unit_add_to_load_queue(ret);
|
2010-02-05 00:38:41 +01:00
|
|
|
unit_add_to_dbus_queue(ret);
|
2010-05-16 04:31:07 +02:00
|
|
|
unit_add_to_gc_queue(ret);
|
2010-02-05 00:38:41 +01:00
|
|
|
|
2010-04-24 04:26:33 +02:00
|
|
|
if (_ret)
|
|
|
|
*_ret = ret;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-06-28 04:12:58 +02:00
|
|
|
int manager_load_unit(
|
|
|
|
Manager *m,
|
|
|
|
const char *name,
|
|
|
|
const char *path,
|
2013-11-19 21:12:59 +01:00
|
|
|
sd_bus_error *e,
|
2013-06-28 04:12:58 +02:00
|
|
|
Unit **_ret) {
|
|
|
|
|
2010-04-24 04:26:33 +02:00
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(m);
|
|
|
|
|
|
|
|
/* This will load the service information files, but not actually
|
|
|
|
* start any services or anything. */
|
|
|
|
|
2012-09-18 01:55:49 +02:00
|
|
|
r = manager_load_unit_prepare(m, name, path, e, _ret);
|
|
|
|
if (r != 0)
|
2010-04-24 04:26:33 +02:00
|
|
|
return r;
|
|
|
|
|
2010-01-29 03:18:09 +01:00
|
|
|
manager_dispatch_load_queue(m);
|
2009-11-18 00:42:52 +01:00
|
|
|
|
2010-04-15 03:11:11 +02:00
|
|
|
if (_ret)
|
2010-05-16 04:30:45 +02:00
|
|
|
*_ret = unit_follow_merge(*_ret);
|
2010-04-15 03:11:11 +02:00
|
|
|
|
2009-11-18 00:42:52 +01:00
|
|
|
return 0;
|
|
|
|
}
|
2010-01-19 00:22:34 +01:00
|
|
|
|
2010-01-20 04:02:39 +01:00
|
|
|
void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
|
2010-01-26 04:18:44 +01:00
|
|
|
Iterator i;
|
2010-01-19 00:22:34 +01:00
|
|
|
Job *j;
|
|
|
|
|
|
|
|
assert(s);
|
|
|
|
assert(f);
|
|
|
|
|
2010-01-26 04:18:44 +01:00
|
|
|
HASHMAP_FOREACH(j, s->jobs, i)
|
2010-01-20 04:02:39 +01:00
|
|
|
job_dump(j, f, prefix);
|
2010-01-19 00:22:34 +01:00
|
|
|
}
|
|
|
|
|
2010-01-26 21:39:06 +01:00
|
|
|
void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
|
2010-01-26 04:18:44 +01:00
|
|
|
Iterator i;
|
2010-01-26 21:39:06 +01:00
|
|
|
Unit *u;
|
2010-01-19 04:15:20 +01:00
|
|
|
const char *t;
|
2010-01-19 00:22:34 +01:00
|
|
|
|
|
|
|
assert(s);
|
|
|
|
assert(f);
|
|
|
|
|
2010-01-26 21:39:06 +01:00
|
|
|
HASHMAP_FOREACH_KEY(u, t, s->units, i)
|
2012-01-15 12:04:08 +01:00
|
|
|
if (u->id == t)
|
2010-01-26 21:39:06 +01:00
|
|
|
unit_dump(u, f, prefix);
|
2010-01-19 00:22:34 +01:00
|
|
|
}
|
2010-01-20 05:03:52 +01:00
|
|
|
|
|
|
|
void manager_clear_jobs(Manager *m) {
|
|
|
|
Job *j;
|
|
|
|
|
|
|
|
assert(m);
|
|
|
|
|
|
|
|
while ((j = hashmap_first(m->jobs)))
|
2012-04-24 11:21:03 +02:00
|
|
|
/* No need to recurse. We're cancelling all jobs. */
|
|
|
|
job_finish_and_invalidate(j, JOB_CANCELED, false);
|
2010-01-20 05:03:52 +01:00
|
|
|
}
|
2010-01-23 22:56:47 +01:00
|
|
|
|
2013-11-25 15:22:41 +01:00
|
|
|
static int manager_dispatch_run_queue(sd_event_source *source, void *userdata) {
|
|
|
|
Manager *m = userdata;
|
2010-01-23 22:56:47 +01:00
|
|
|
Job *j;
|
2010-01-26 04:18:44 +01:00
|
|
|
|
2013-11-25 15:22:41 +01:00
|
|
|
assert(source);
|
|
|
|
assert(m);
|
2010-01-24 00:39:29 +01:00
|
|
|
|
2010-01-26 04:18:44 +01:00
|
|
|
while ((j = m->run_queue)) {
|
2010-01-26 19:25:02 +01:00
|
|
|
assert(j->installed);
|
2010-01-26 04:18:44 +01:00
|
|
|
assert(j->in_run_queue);
|
|
|
|
|
|
|
|
job_run_and_invalidate(j);
|
2010-01-24 00:39:29 +01:00
|
|
|
}
|
2010-01-26 04:18:44 +01:00
|
|
|
|
2013-03-04 14:38:51 +01:00
|
|
|
if (m->n_running_jobs > 0)
|
2013-02-28 00:03:22 +01:00
|
|
|
manager_watch_jobs_in_progress(m);
|
|
|
|
|
systemd: do not output status messages once gettys are running
Make Type=idle communication bidirectional: when bootup is finished,
the manager, as before, signals idling Type=idle jobs to continue.
However, if the boot takes too long, idling jobs signal the manager
that they have had enough, wait a tiny bit more, and continue, taking
ownership of the console. The manager, when signalled that Type=idle
jobs are done, makes a note and will not write to the console anymore.
This is a cosmetic issue, but quite noticable, so let's just fix it.
Based on Harald Hoyer's patch.
https://bugs.freedesktop.org/show_bug.cgi?id=54247
http://unix.stackexchange.com/questions/51805/systemd-messages-after-starting-login/
2013-07-16 03:34:57 +02:00
|
|
|
if (m->n_on_console > 0)
|
|
|
|
manager_watch_idle_pipe(m);
|
|
|
|
|
2013-11-25 15:22:41 +01:00
|
|
|
return 1;
|
2010-02-05 00:38:41 +01:00
|
|
|
}
|
|
|
|
|
2013-11-08 18:11:09 +01:00
|
|
|
static unsigned manager_dispatch_dbus_queue(Manager *m) {
|
2010-02-05 00:38:41 +01:00
|
|
|
Job *j;
|
2012-01-15 12:37:16 +01:00
|
|
|
Unit *u;
|
2010-02-05 00:38:41 +01:00
|
|
|
unsigned n = 0;
|
|
|
|
|
|
|
|
assert(m);
|
|
|
|
|
|
|
|
if (m->dispatching_dbus_queue)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
m->dispatching_dbus_queue = true;
|
|
|
|
|
2012-01-15 12:37:16 +01:00
|
|
|
while ((u = m->dbus_unit_queue)) {
|
|
|
|
assert(u->in_dbus_queue);
|
2010-02-05 00:38:41 +01:00
|
|
|
|
2012-01-15 12:37:16 +01:00
|
|
|
bus_unit_send_change_signal(u);
|
2010-02-05 00:38:41 +01:00
|
|
|
n++;
|
|
|
|
}
|
|
|
|
|
|
|
|
while ((j = m->dbus_job_queue)) {
|
|
|
|
assert(j->in_dbus_queue);
|
|
|
|
|
|
|
|
bus_job_send_change_signal(j);
|
|
|
|
n++;
|
|
|
|
}
|
|
|
|
|
|
|
|
m->dispatching_dbus_queue = false;
|
2013-07-10 21:10:53 +02:00
|
|
|
|
|
|
|
if (m->send_reloading_done) {
|
|
|
|
m->send_reloading_done = false;
|
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
bus_manager_send_reloading(m, false);
|
2013-07-10 21:10:53 +02:00
|
|
|
}
|
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
if (m->queued_message)
|
|
|
|
bus_send_queued_message(m);
|
|
|
|
|
2010-02-05 00:38:41 +01:00
|
|
|
return n;
|
2010-01-24 00:39:29 +01:00
|
|
|
}
|
|
|
|
|
2015-01-06 00:26:25 +01:00
|
|
|
static void manager_invoke_notify_message(Manager *m, Unit *u, pid_t pid, char *buf, size_t n, FDSet *fds) {
|
2014-02-07 11:58:25 +01:00
|
|
|
_cleanup_strv_free_ char **tags = NULL;
|
|
|
|
|
|
|
|
assert(m);
|
|
|
|
assert(u);
|
|
|
|
assert(buf);
|
|
|
|
assert(n > 0);
|
|
|
|
|
|
|
|
tags = strv_split(buf, "\n\r");
|
|
|
|
if (!tags) {
|
|
|
|
log_oom();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2014-11-27 20:20:23 +01:00
|
|
|
log_unit_debug(u->id, "Got notification message for unit %s", u->id);
|
2014-02-07 11:58:25 +01:00
|
|
|
|
|
|
|
if (UNIT_VTABLE(u)->notify_message)
|
2015-01-06 00:26:25 +01:00
|
|
|
UNIT_VTABLE(u)->notify_message(u, pid, tags, fds);
|
2014-02-07 11:58:25 +01:00
|
|
|
}
|
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
|
|
|
|
Manager *m = userdata;
|
2010-06-16 05:10:31 +02:00
|
|
|
ssize_t n;
|
2015-01-06 00:26:25 +01:00
|
|
|
int r;
|
2010-06-16 05:10:31 +02:00
|
|
|
|
|
|
|
assert(m);
|
2013-11-19 21:12:59 +01:00
|
|
|
assert(m->notify_fd == fd);
|
|
|
|
|
|
|
|
if (revents != EPOLLIN) {
|
|
|
|
log_warning("Got unexpected poll event for notify fd.");
|
|
|
|
return 0;
|
|
|
|
}
|
2010-06-16 05:10:31 +02:00
|
|
|
|
|
|
|
for (;;) {
|
2015-01-06 00:26:25 +01:00
|
|
|
_cleanup_fdset_free_ FDSet *fds = NULL;
|
|
|
|
char buf[NOTIFY_BUFFER_MAX+1];
|
2013-03-25 00:59:00 +01:00
|
|
|
struct iovec iovec = {
|
|
|
|
.iov_base = buf,
|
|
|
|
.iov_len = sizeof(buf)-1,
|
|
|
|
};
|
2010-06-16 05:10:31 +02:00
|
|
|
union {
|
|
|
|
struct cmsghdr cmsghdr;
|
2015-01-06 00:26:25 +01:00
|
|
|
uint8_t buf[CMSG_SPACE(sizeof(struct ucred)) +
|
|
|
|
CMSG_SPACE(sizeof(int) * NOTIFY_FD_MAX)];
|
2013-03-25 00:59:00 +01:00
|
|
|
} control = {};
|
|
|
|
struct msghdr msghdr = {
|
|
|
|
.msg_iov = &iovec,
|
|
|
|
.msg_iovlen = 1,
|
|
|
|
.msg_control = &control,
|
|
|
|
.msg_controllen = sizeof(control),
|
|
|
|
};
|
2015-01-06 00:26:25 +01:00
|
|
|
struct cmsghdr *cmsg;
|
|
|
|
struct ucred *ucred = NULL;
|
|
|
|
bool found = false;
|
2014-08-21 16:52:41 +02:00
|
|
|
Unit *u1, *u2, *u3;
|
2015-01-06 00:26:25 +01:00
|
|
|
int *fd_array = NULL;
|
|
|
|
unsigned n_fds = 0;
|
2010-06-16 05:10:31 +02:00
|
|
|
|
2015-01-06 00:26:25 +01:00
|
|
|
n = recvmsg(m->notify_fd, &msghdr, MSG_DONTWAIT|MSG_CMSG_CLOEXEC);
|
|
|
|
if (n < 0) {
|
2010-08-16 15:37:52 +02:00
|
|
|
if (errno == EAGAIN || errno == EINTR)
|
2010-06-16 05:10:31 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
return -errno;
|
|
|
|
}
|
2015-01-06 00:26:25 +01:00
|
|
|
|
|
|
|
for (cmsg = CMSG_FIRSTHDR(&msghdr); cmsg; cmsg = CMSG_NXTHDR(&msghdr, cmsg)) {
|
|
|
|
if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_RIGHTS) {
|
|
|
|
|
|
|
|
fd_array = (int*) CMSG_DATA(cmsg);
|
|
|
|
n_fds = (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int);
|
|
|
|
|
|
|
|
} else if (cmsg->cmsg_level == SOL_SOCKET &&
|
|
|
|
cmsg->cmsg_type == SCM_CREDENTIALS &&
|
|
|
|
cmsg->cmsg_len == CMSG_LEN(sizeof(struct ucred))) {
|
|
|
|
|
|
|
|
ucred = (struct ucred*) CMSG_DATA(cmsg);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (n_fds > 0) {
|
|
|
|
assert(fd_array);
|
|
|
|
|
|
|
|
r = fdset_new_array(&fds, fd_array, n_fds);
|
|
|
|
if (r < 0) {
|
|
|
|
close_many(fd_array, n_fds);
|
|
|
|
return log_oom();
|
|
|
|
}
|
|
|
|
}
|
2010-06-16 05:10:31 +02:00
|
|
|
|
2015-01-06 00:26:25 +01:00
|
|
|
if (!ucred || ucred->pid <= 0) {
|
|
|
|
log_warning("Received notify message without valid credentials. Ignoring.");
|
2010-06-16 05:10:31 +02:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2015-01-06 00:26:25 +01:00
|
|
|
if ((size_t) n >= sizeof(buf)) {
|
|
|
|
log_warning("Received notify message exceeded maximum size. Ignoring.");
|
|
|
|
continue;
|
|
|
|
}
|
2010-06-16 05:10:31 +02:00
|
|
|
|
2010-06-18 23:13:40 +02:00
|
|
|
buf[n] = 0;
|
2010-06-16 05:10:31 +02:00
|
|
|
|
2014-08-21 16:52:41 +02:00
|
|
|
/* Notify every unit that might be interested, but try
|
|
|
|
* to avoid notifying the same one multiple times. */
|
|
|
|
u1 = manager_get_unit_by_pid(m, ucred->pid);
|
|
|
|
if (u1) {
|
2015-01-06 00:26:25 +01:00
|
|
|
manager_invoke_notify_message(m, u1, ucred->pid, buf, n, fds);
|
2014-02-07 11:58:25 +01:00
|
|
|
found = true;
|
|
|
|
}
|
|
|
|
|
2014-08-21 16:52:41 +02:00
|
|
|
u2 = hashmap_get(m->watch_pids1, LONG_TO_PTR(ucred->pid));
|
|
|
|
if (u2 && u2 != u1) {
|
2015-01-06 00:26:25 +01:00
|
|
|
manager_invoke_notify_message(m, u2, ucred->pid, buf, n, fds);
|
2014-02-07 11:58:25 +01:00
|
|
|
found = true;
|
|
|
|
}
|
|
|
|
|
2014-08-21 16:52:41 +02:00
|
|
|
u3 = hashmap_get(m->watch_pids2, LONG_TO_PTR(ucred->pid));
|
|
|
|
if (u3 && u3 != u2 && u3 != u1) {
|
2015-01-06 00:26:25 +01:00
|
|
|
manager_invoke_notify_message(m, u3, ucred->pid, buf, n, fds);
|
2014-02-07 11:58:25 +01:00
|
|
|
found = true;
|
|
|
|
}
|
2010-06-16 05:10:31 +02:00
|
|
|
|
2014-02-07 11:58:25 +01:00
|
|
|
if (!found)
|
|
|
|
log_warning("Cannot find unit for notify message of PID "PID_FMT".", ucred->pid);
|
2015-01-06 00:26:25 +01:00
|
|
|
|
|
|
|
if (fdset_size(fds) > 0)
|
|
|
|
log_warning("Got auxiliary fds with notification message, closing all.");
|
2010-06-16 05:10:31 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-02-07 11:58:25 +01:00
|
|
|
static void invoke_sigchld_event(Manager *m, Unit *u, siginfo_t *si) {
|
|
|
|
assert(m);
|
|
|
|
assert(u);
|
|
|
|
assert(si);
|
|
|
|
|
2014-11-27 20:20:23 +01:00
|
|
|
log_unit_debug(u->id, "Child "PID_FMT" belongs to %s", si->si_pid, u->id);
|
2014-02-07 11:58:25 +01:00
|
|
|
|
|
|
|
unit_unwatch_pid(u, si->si_pid);
|
|
|
|
UNIT_VTABLE(u)->sigchld_event(u, si->si_pid, si->si_code, si->si_status);
|
|
|
|
}
|
|
|
|
|
2010-01-26 04:18:44 +01:00
|
|
|
static int manager_dispatch_sigchld(Manager *m) {
|
2010-01-24 00:39:29 +01:00
|
|
|
assert(m);
|
|
|
|
|
|
|
|
for (;;) {
|
2013-03-25 00:59:00 +01:00
|
|
|
siginfo_t si = {};
|
2010-01-24 00:39:29 +01:00
|
|
|
|
2010-04-13 02:05:27 +02:00
|
|
|
/* First we call waitd() for a PID and do not reap the
|
|
|
|
* zombie. That way we can still access /proc/$PID for
|
|
|
|
* it while it is a zombie. */
|
|
|
|
if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
|
2010-01-27 04:31:52 +01:00
|
|
|
|
|
|
|
if (errno == ECHILD)
|
|
|
|
break;
|
|
|
|
|
2010-04-13 02:05:27 +02:00
|
|
|
if (errno == EINTR)
|
|
|
|
continue;
|
|
|
|
|
2010-01-24 00:39:29 +01:00
|
|
|
return -errno;
|
2010-01-27 04:31:52 +01:00
|
|
|
}
|
2010-01-24 00:39:29 +01:00
|
|
|
|
2010-04-13 02:05:27 +02:00
|
|
|
if (si.si_pid <= 0)
|
2010-01-24 00:39:29 +01:00
|
|
|
break;
|
|
|
|
|
2010-04-13 02:10:17 +02:00
|
|
|
if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
|
2013-04-18 09:11:22 +02:00
|
|
|
_cleanup_free_ char *name = NULL;
|
2014-08-21 16:52:41 +02:00
|
|
|
Unit *u1, *u2, *u3;
|
2010-04-13 02:05:27 +02:00
|
|
|
|
2011-10-07 21:06:39 +02:00
|
|
|
get_process_comm(si.si_pid, &name);
|
2010-04-13 02:05:27 +02:00
|
|
|
|
2014-02-07 11:58:25 +01:00
|
|
|
log_debug("Child "PID_FMT" (%s) died (code=%s, status=%i/%s)",
|
|
|
|
si.si_pid, strna(name),
|
|
|
|
sigchld_code_to_string(si.si_code),
|
|
|
|
si.si_status,
|
|
|
|
strna(si.si_code == CLD_EXITED
|
|
|
|
? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
|
|
|
|
: signal_to_string(si.si_status)));
|
|
|
|
|
|
|
|
/* And now figure out the unit this belongs
|
|
|
|
* to, it might be multiple... */
|
2014-08-21 16:52:41 +02:00
|
|
|
u1 = manager_get_unit_by_pid(m, si.si_pid);
|
|
|
|
if (u1)
|
|
|
|
invoke_sigchld_event(m, u1, &si);
|
|
|
|
u2 = hashmap_get(m->watch_pids1, LONG_TO_PTR(si.si_pid));
|
|
|
|
if (u2 && u2 != u1)
|
|
|
|
invoke_sigchld_event(m, u2, &si);
|
|
|
|
u3 = hashmap_get(m->watch_pids2, LONG_TO_PTR(si.si_pid));
|
|
|
|
if (u3 && u3 != u2 && u3 != u1)
|
|
|
|
invoke_sigchld_event(m, u3, &si);
|
2014-02-07 11:58:25 +01:00
|
|
|
}
|
2010-06-16 05:10:31 +02:00
|
|
|
|
2010-04-13 02:05:27 +02:00
|
|
|
/* And now, we actually reap the zombie. */
|
|
|
|
if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
|
|
|
|
if (errno == EINTR)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
return -errno;
|
|
|
|
}
|
2010-01-24 00:39:29 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-06-17 23:22:56 +02:00
|
|
|
static int manager_start_target(Manager *m, const char *name, JobMode mode) {
|
2013-11-19 21:12:59 +01:00
|
|
|
_cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
|
2010-04-13 01:59:06 +02:00
|
|
|
int r;
|
2010-07-08 02:43:18 +02:00
|
|
|
|
2014-11-27 20:20:23 +01:00
|
|
|
log_unit_debug(name, "Activating special unit %s", name);
|
2010-07-10 04:50:19 +02:00
|
|
|
|
2013-01-02 22:03:35 +01:00
|
|
|
r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
|
|
|
|
if (r < 0)
|
2014-11-27 20:20:23 +01:00
|
|
|
log_unit_error(name, "Failed to enqueue %s job: %s", name, bus_error_message(&error, r));
|
2010-05-24 22:31:38 +02:00
|
|
|
|
|
|
|
return r;
|
2010-04-13 01:59:06 +02:00
|
|
|
}
|
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
|
|
|
|
Manager *m = userdata;
|
2010-01-24 00:39:29 +01:00
|
|
|
ssize_t n;
|
|
|
|
struct signalfd_siginfo sfsi;
|
|
|
|
bool sigchld = false;
|
|
|
|
|
|
|
|
assert(m);
|
2013-11-19 21:12:59 +01:00
|
|
|
assert(m->signal_fd == fd);
|
|
|
|
|
|
|
|
if (revents != EPOLLIN) {
|
|
|
|
log_warning("Got unexpected events from signal file descriptor.");
|
|
|
|
return 0;
|
|
|
|
}
|
2010-01-24 00:39:29 +01:00
|
|
|
|
|
|
|
for (;;) {
|
2013-11-19 21:12:59 +01:00
|
|
|
n = read(m->signal_fd, &sfsi, sizeof(sfsi));
|
2012-12-22 21:21:09 +01:00
|
|
|
if (n != sizeof(sfsi)) {
|
2010-01-24 00:39:29 +01:00
|
|
|
|
|
|
|
if (n >= 0)
|
|
|
|
return -EIO;
|
|
|
|
|
2010-08-21 01:51:16 +02:00
|
|
|
if (errno == EINTR || errno == EAGAIN)
|
2010-01-27 04:31:52 +01:00
|
|
|
break;
|
2010-01-24 00:39:29 +01:00
|
|
|
|
|
|
|
return -errno;
|
|
|
|
}
|
|
|
|
|
2014-02-10 02:08:55 +01:00
|
|
|
log_received_signal(sfsi.ssi_signo == SIGCHLD ||
|
|
|
|
(sfsi.ssi_signo == SIGTERM && m->running_as == SYSTEMD_USER)
|
|
|
|
? LOG_DEBUG : LOG_INFO,
|
|
|
|
&sfsi);
|
2010-07-10 04:50:19 +02:00
|
|
|
|
2010-01-27 04:36:30 +01:00
|
|
|
switch (sfsi.ssi_signo) {
|
|
|
|
|
2010-04-13 02:05:27 +02:00
|
|
|
case SIGCHLD:
|
2010-01-24 00:39:29 +01:00
|
|
|
sigchld = true;
|
2010-01-27 04:36:30 +01:00
|
|
|
break;
|
|
|
|
|
2010-01-27 05:31:53 +01:00
|
|
|
case SIGTERM:
|
2012-09-18 17:11:12 +02:00
|
|
|
if (m->running_as == SYSTEMD_SYSTEM) {
|
2010-04-24 04:26:33 +02:00
|
|
|
/* This is for compatibility with the
|
|
|
|
* original sysvinit */
|
2010-04-24 00:02:12 +02:00
|
|
|
m->exit_code = MANAGER_REEXECUTE;
|
2010-05-24 22:31:38 +02:00
|
|
|
break;
|
|
|
|
}
|
2010-02-13 01:17:08 +01:00
|
|
|
|
2010-05-24 22:31:38 +02:00
|
|
|
/* Fall through */
|
2010-04-24 00:02:12 +02:00
|
|
|
|
|
|
|
case SIGINT:
|
2012-09-18 17:11:12 +02:00
|
|
|
if (m->running_as == SYSTEMD_SYSTEM) {
|
2015-01-28 02:18:59 +01:00
|
|
|
|
2015-01-28 14:03:24 +01:00
|
|
|
/* If the user presses C-A-D more than
|
|
|
|
* 7 times within 2s, we reboot
|
2015-01-28 02:18:59 +01:00
|
|
|
* immediately. */
|
|
|
|
|
|
|
|
if (ratelimit_test(&m->ctrl_alt_del_ratelimit))
|
|
|
|
manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);
|
|
|
|
else {
|
|
|
|
log_notice("Ctrl-Alt-Del was pressed more than 7 times within 2s, rebooting immediately.");
|
2015-01-28 02:26:03 +01:00
|
|
|
status_printf(NULL, true, false, "Ctrl-Alt-Del was pressed more than 7 times within 2s, rebooting immediately.");
|
2015-01-28 02:18:59 +01:00
|
|
|
m->exit_code = MANAGER_REBOOT;
|
|
|
|
}
|
|
|
|
|
2010-02-13 01:17:08 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2010-05-24 22:31:38 +02:00
|
|
|
/* Run the exit target if there is one, if not, just exit. */
|
2010-10-14 00:54:48 +02:00
|
|
|
if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
|
2010-05-24 22:31:38 +02:00
|
|
|
m->exit_code = MANAGER_EXIT;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
2010-02-13 01:17:08 +01:00
|
|
|
|
2010-04-13 01:59:06 +02:00
|
|
|
case SIGWINCH:
|
2012-09-18 17:11:12 +02:00
|
|
|
if (m->running_as == SYSTEMD_SYSTEM)
|
2010-06-17 23:22:56 +02:00
|
|
|
manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
|
2010-02-13 01:17:08 +01:00
|
|
|
|
2010-04-13 01:59:06 +02:00
|
|
|
/* This is a nop on non-init */
|
|
|
|
break;
|
2010-02-13 01:17:08 +01:00
|
|
|
|
2010-04-13 01:59:06 +02:00
|
|
|
case SIGPWR:
|
2012-09-18 17:11:12 +02:00
|
|
|
if (m->running_as == SYSTEMD_SYSTEM)
|
2010-06-17 23:22:56 +02:00
|
|
|
manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
|
2010-02-13 01:17:08 +01:00
|
|
|
|
2010-04-13 01:59:06 +02:00
|
|
|
/* This is a nop on non-init */
|
2010-02-13 01:17:08 +01:00
|
|
|
break;
|
2010-01-27 05:31:53 +01:00
|
|
|
|
2010-04-24 04:27:05 +02:00
|
|
|
case SIGUSR1: {
|
2010-04-13 03:20:22 +02:00
|
|
|
Unit *u;
|
|
|
|
|
|
|
|
u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
|
|
|
|
|
|
|
|
if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
|
|
|
|
log_info("Trying to reconnect to bus...");
|
2011-01-20 19:43:38 +01:00
|
|
|
bus_init(m, true);
|
2010-04-13 03:20:22 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
|
|
|
|
log_info("Loading D-Bus service...");
|
2010-06-17 23:22:56 +02:00
|
|
|
manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
|
2010-04-13 03:20:22 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2010-06-04 19:45:53 +02:00
|
|
|
case SIGUSR2: {
|
2013-11-19 21:12:59 +01:00
|
|
|
_cleanup_free_ char *dump = NULL;
|
|
|
|
_cleanup_fclose_ FILE *f = NULL;
|
2010-06-04 19:45:53 +02:00
|
|
|
size_t size;
|
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
f = open_memstream(&dump, &size);
|
|
|
|
if (!f) {
|
2010-06-04 19:45:53 +02:00
|
|
|
log_warning("Failed to allocate memory stream.");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
manager_dump_units(m, f, "\t");
|
|
|
|
manager_dump_jobs(m, f, "\t");
|
|
|
|
|
|
|
|
if (ferror(f)) {
|
|
|
|
log_warning("Failed to write status stream");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
manager: flush memory stream before using the buffer
When the manager receives a SIGUSR2 signal, it opens a memory stream
with open_memstream(), uses the returned file handle for logging, and
dumps the logged content with log_dump().
However, the char* buffer is only safe to use after the file handle has
been flushed with fflush, as the man pages states:
When the stream is closed (fclose(3)) or flushed (fflush(3)), the
locations pointed to by ptr and sizeloc are updated to contain,
respectively, a pointer to the buffer and the current size of the
buffer.
These values remain valid only as long as the caller performs no
further output on the stream. If further output is performed, then the
stream must again be flushed before trying to access these variables.
Without that call, dump remains NULL and the daemon crashes in
log_dump().
2014-03-07 14:43:59 +01:00
|
|
|
if (fflush(f)) {
|
|
|
|
log_warning("Failed to flush status stream");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2010-06-04 19:45:53 +02:00
|
|
|
log_dump(LOG_INFO, dump);
|
2010-04-24 04:27:05 +02:00
|
|
|
break;
|
2010-06-04 19:45:53 +02:00
|
|
|
}
|
2010-04-24 04:27:05 +02:00
|
|
|
|
2010-04-21 03:27:44 +02:00
|
|
|
case SIGHUP:
|
|
|
|
m->exit_code = MANAGER_RELOAD;
|
|
|
|
break;
|
|
|
|
|
2010-06-17 23:22:56 +02:00
|
|
|
default: {
|
2011-07-23 04:15:38 +02:00
|
|
|
|
2010-10-14 00:54:48 +02:00
|
|
|
/* Starting SIGRTMIN+0 */
|
|
|
|
static const char * const target_table[] = {
|
2010-06-17 23:22:56 +02:00
|
|
|
[0] = SPECIAL_DEFAULT_TARGET,
|
|
|
|
[1] = SPECIAL_RESCUE_TARGET,
|
2010-07-12 23:49:20 +02:00
|
|
|
[2] = SPECIAL_EMERGENCY_TARGET,
|
2010-06-17 23:22:56 +02:00
|
|
|
[3] = SPECIAL_HALT_TARGET,
|
|
|
|
[4] = SPECIAL_POWEROFF_TARGET,
|
2010-10-14 00:54:48 +02:00
|
|
|
[5] = SPECIAL_REBOOT_TARGET,
|
|
|
|
[6] = SPECIAL_KEXEC_TARGET
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
|
|
|
|
static const ManagerExitCode code_table[] = {
|
|
|
|
[0] = MANAGER_HALT,
|
|
|
|
[1] = MANAGER_POWEROFF,
|
|
|
|
[2] = MANAGER_REBOOT,
|
|
|
|
[3] = MANAGER_KEXEC
|
2010-06-17 23:22:56 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
|
2010-10-14 00:54:48 +02:00
|
|
|
(int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
|
2011-09-23 09:37:45 +02:00
|
|
|
int idx = (int) sfsi.ssi_signo - SIGRTMIN;
|
|
|
|
manager_start_target(m, target_table[idx],
|
|
|
|
(idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
|
2010-06-17 23:22:56 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2010-10-14 00:54:48 +02:00
|
|
|
if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
|
|
|
|
(int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
|
|
|
|
m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2011-02-09 12:12:30 +01:00
|
|
|
switch (sfsi.ssi_signo - SIGRTMIN) {
|
|
|
|
|
|
|
|
case 20:
|
|
|
|
log_debug("Enabling showing of status.");
|
2014-01-28 04:27:07 +01:00
|
|
|
manager_set_show_status(m, SHOW_STATUS_YES);
|
2011-02-09 12:12:30 +01:00
|
|
|
break;
|
|
|
|
|
|
|
|
case 21:
|
|
|
|
log_debug("Disabling showing of status.");
|
2014-01-28 04:27:07 +01:00
|
|
|
manager_set_show_status(m, SHOW_STATUS_NO);
|
2011-02-09 12:12:30 +01:00
|
|
|
break;
|
|
|
|
|
2011-07-23 04:15:38 +02:00
|
|
|
case 22:
|
|
|
|
log_set_max_level(LOG_DEBUG);
|
|
|
|
log_notice("Setting log level to debug.");
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 23:
|
|
|
|
log_set_max_level(LOG_INFO);
|
|
|
|
log_notice("Setting log level to info.");
|
|
|
|
break;
|
|
|
|
|
2012-10-18 01:19:35 +02:00
|
|
|
case 24:
|
|
|
|
if (m->running_as == SYSTEMD_USER) {
|
|
|
|
m->exit_code = MANAGER_EXIT;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* This is a nop on init */
|
|
|
|
break;
|
|
|
|
|
2012-01-12 05:09:06 +01:00
|
|
|
case 26:
|
2014-08-11 20:08:08 +02:00
|
|
|
case 29: /* compatibility: used to be mapped to LOG_TARGET_SYSLOG_OR_KMSG */
|
2012-01-12 05:09:06 +01:00
|
|
|
log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
|
|
|
|
log_notice("Setting log target to journal-or-kmsg.");
|
|
|
|
break;
|
|
|
|
|
2011-07-23 04:15:38 +02:00
|
|
|
case 27:
|
|
|
|
log_set_target(LOG_TARGET_CONSOLE);
|
|
|
|
log_notice("Setting log target to console.");
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 28:
|
|
|
|
log_set_target(LOG_TARGET_KMSG);
|
|
|
|
log_notice("Setting log target to kmsg.");
|
|
|
|
break;
|
|
|
|
|
2011-02-09 12:12:30 +01:00
|
|
|
default:
|
2011-09-23 09:39:40 +02:00
|
|
|
log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
|
2011-02-09 12:12:30 +01:00
|
|
|
}
|
2010-01-27 04:36:30 +01:00
|
|
|
}
|
2010-06-17 23:22:56 +02:00
|
|
|
}
|
2010-01-24 00:39:29 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if (sigchld)
|
2013-12-13 03:30:42 +01:00
|
|
|
manager_dispatch_sigchld(m);
|
2010-01-26 04:18:44 +01:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
|
|
|
|
Manager *m = userdata;
|
|
|
|
Iterator i;
|
|
|
|
Unit *u;
|
2010-01-26 04:18:44 +01:00
|
|
|
|
|
|
|
assert(m);
|
2013-11-19 21:12:59 +01:00
|
|
|
assert(m->time_change_fd == fd);
|
2010-01-26 04:18:44 +01:00
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
log_struct(LOG_INFO,
|
2014-11-28 02:05:14 +01:00
|
|
|
LOG_MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
|
|
|
|
LOG_MESSAGE("Time has been changed"),
|
2013-11-19 21:12:59 +01:00
|
|
|
NULL);
|
2010-01-26 04:18:44 +01:00
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
/* Restart the watch */
|
|
|
|
m->time_change_event_source = sd_event_source_unref(m->time_change_event_source);
|
2014-03-18 19:22:43 +01:00
|
|
|
m->time_change_fd = safe_close(m->time_change_fd);
|
2010-01-29 06:04:08 +01:00
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
manager_setup_time_change(m);
|
2010-10-18 23:09:09 +02:00
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
HASHMAP_FOREACH(u, m->units, i)
|
|
|
|
if (UNIT_VTABLE(u)->time_change)
|
|
|
|
UNIT_VTABLE(u)->time_change(u);
|
2010-02-01 03:33:24 +01:00
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
return 0;
|
|
|
|
}
|
2010-02-01 03:33:24 +01:00
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
|
|
|
|
Manager *m = userdata;
|
2012-11-25 00:32:40 +01:00
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
assert(m);
|
|
|
|
assert(m->idle_pipe[2] == fd);
|
2012-11-25 00:32:40 +01:00
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
m->no_console_output = m->n_on_console > 0;
|
2013-02-28 00:03:22 +01:00
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
|
|
|
|
manager_close_idle_pipe(m);
|
2013-02-28 00:03:22 +01:00
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
return 0;
|
|
|
|
}
|
systemd: do not output status messages once gettys are running
Make Type=idle communication bidirectional: when bootup is finished,
the manager, as before, signals idling Type=idle jobs to continue.
However, if the boot takes too long, idling jobs signal the manager
that they have had enough, wait a tiny bit more, and continue, taking
ownership of the console. The manager, when signalled that Type=idle
jobs are done, makes a note and will not write to the console anymore.
This is a cosmetic issue, but quite noticable, so let's just fix it.
Based on Harald Hoyer's patch.
https://bugs.freedesktop.org/show_bug.cgi?id=54247
http://unix.stackexchange.com/questions/51805/systemd-messages-after-starting-login/
2013-07-16 03:34:57 +02:00
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata) {
|
|
|
|
Manager *m = userdata;
|
2014-01-27 07:15:27 +01:00
|
|
|
int r;
|
|
|
|
uint64_t next;
|
systemd: do not output status messages once gettys are running
Make Type=idle communication bidirectional: when bootup is finished,
the manager, as before, signals idling Type=idle jobs to continue.
However, if the boot takes too long, idling jobs signal the manager
that they have had enough, wait a tiny bit more, and continue, taking
ownership of the console. The manager, when signalled that Type=idle
jobs are done, makes a note and will not write to the console anymore.
This is a cosmetic issue, but quite noticable, so let's just fix it.
Based on Harald Hoyer's patch.
https://bugs.freedesktop.org/show_bug.cgi?id=54247
http://unix.stackexchange.com/questions/51805/systemd-messages-after-starting-login/
2013-07-16 03:34:57 +02:00
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
assert(m);
|
2014-01-27 07:15:27 +01:00
|
|
|
assert(source);
|
2010-01-24 00:39:29 +01:00
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
manager_print_jobs_in_progress(m);
|
2014-01-27 07:15:27 +01:00
|
|
|
|
|
|
|
next = now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_PERIOD_USEC;
|
|
|
|
r = sd_event_source_set_time(source, next);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
return sd_event_source_set_enabled(source, SD_EVENT_ONESHOT);
|
2010-01-24 00:39:29 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
int manager_loop(Manager *m) {
|
|
|
|
int r;
|
|
|
|
|
2011-03-30 20:15:45 +02:00
|
|
|
RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
|
2010-02-01 03:33:24 +01:00
|
|
|
|
2010-01-24 00:39:29 +01:00
|
|
|
assert(m);
|
2014-03-12 20:55:13 +01:00
|
|
|
m->exit_code = MANAGER_OK;
|
2010-01-24 00:39:29 +01:00
|
|
|
|
2010-07-11 00:52:00 +02:00
|
|
|
/* Release the path cache */
|
|
|
|
set_free_free(m->unit_path_cache);
|
|
|
|
m->unit_path_cache = NULL;
|
|
|
|
|
2010-09-21 04:14:38 +02:00
|
|
|
manager_check_finished(m);
|
|
|
|
|
2010-05-18 04:16:33 +02:00
|
|
|
/* There might still be some zombies hanging around from
|
2013-11-06 11:03:18 +01:00
|
|
|
* before we were exec()'ed. Let's reap them. */
|
2012-04-05 22:08:10 +02:00
|
|
|
r = manager_dispatch_sigchld(m);
|
|
|
|
if (r < 0)
|
2010-05-18 04:16:33 +02:00
|
|
|
return r;
|
|
|
|
|
2014-03-12 20:55:13 +01:00
|
|
|
while (m->exit_code == MANAGER_OK) {
|
2013-11-19 21:12:59 +01:00
|
|
|
usec_t wait_usec;
|
2010-01-24 00:39:29 +01:00
|
|
|
|
2012-09-18 17:11:12 +02:00
|
|
|
if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
|
2012-04-05 22:08:10 +02:00
|
|
|
watchdog_ping();
|
|
|
|
|
2010-02-01 03:33:24 +01:00
|
|
|
if (!ratelimit_test(&rl)) {
|
|
|
|
/* Yay, something is going seriously wrong, pause a little */
|
|
|
|
log_warning("Looping too fast. Throttling execution a little.");
|
|
|
|
sleep(1);
|
2012-04-05 22:08:10 +02:00
|
|
|
continue;
|
2010-02-01 03:33:24 +01:00
|
|
|
}
|
|
|
|
|
2010-05-16 03:57:56 +02:00
|
|
|
if (manager_dispatch_load_queue(m) > 0)
|
2010-04-06 02:43:58 +02:00
|
|
|
continue;
|
|
|
|
|
2013-07-02 17:41:57 +02:00
|
|
|
if (manager_dispatch_gc_queue(m) > 0)
|
2010-04-21 06:01:13 +02:00
|
|
|
continue;
|
|
|
|
|
2013-07-02 17:41:57 +02:00
|
|
|
if (manager_dispatch_cleanup_queue(m) > 0)
|
2010-02-05 00:38:41 +01:00
|
|
|
continue;
|
2010-01-26 04:18:44 +01:00
|
|
|
|
2013-07-02 17:41:57 +02:00
|
|
|
if (manager_dispatch_cgroup_queue(m) > 0)
|
2010-02-05 00:38:41 +01:00
|
|
|
continue;
|
|
|
|
|
|
|
|
if (manager_dispatch_dbus_queue(m) > 0)
|
2010-02-01 03:33:24 +01:00
|
|
|
continue;
|
|
|
|
|
2012-04-13 21:33:28 +02:00
|
|
|
/* Sleep for half the watchdog time */
|
2012-09-18 17:11:12 +02:00
|
|
|
if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
|
2013-11-19 21:12:59 +01:00
|
|
|
wait_usec = m->runtime_watchdog / 2;
|
|
|
|
if (wait_usec <= 0)
|
|
|
|
wait_usec = 1;
|
2012-04-13 21:33:28 +02:00
|
|
|
} else
|
2014-07-29 12:23:31 +02:00
|
|
|
wait_usec = USEC_INFINITY;
|
2010-01-24 00:39:29 +01:00
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
r = sd_event_run(m->event, wait_usec);
|
2014-11-28 18:23:20 +01:00
|
|
|
if (r < 0)
|
|
|
|
return log_error_errno(r, "Failed to run event loop: %m");
|
2010-04-21 03:27:44 +02:00
|
|
|
}
|
2010-01-27 22:40:10 +01:00
|
|
|
|
2010-04-21 03:27:44 +02:00
|
|
|
return m->exit_code;
|
2010-01-23 22:56:47 +01:00
|
|
|
}
|
2010-02-01 03:33:24 +01:00
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
int manager_load_unit_from_dbus_path(Manager *m, const char *s, sd_bus_error *e, Unit **_u) {
|
2013-07-02 01:35:08 +02:00
|
|
|
_cleanup_free_ char *n = NULL;
|
2010-02-01 03:33:24 +01:00
|
|
|
Unit *u;
|
2012-05-21 12:54:34 +02:00
|
|
|
int r;
|
2010-02-01 03:33:24 +01:00
|
|
|
|
|
|
|
assert(m);
|
|
|
|
assert(s);
|
|
|
|
assert(_u);
|
|
|
|
|
2013-07-02 01:35:08 +02:00
|
|
|
r = unit_name_from_dbus_path(s, &n);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2010-02-01 03:33:24 +01:00
|
|
|
|
2012-05-21 12:54:34 +02:00
|
|
|
r = manager_load_unit(m, n, NULL, e, &u);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2010-02-01 03:33:24 +01:00
|
|
|
|
|
|
|
*_u = u;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2010-02-02 12:42:08 +01:00
|
|
|
|
|
|
|
int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
|
2013-11-19 21:12:59 +01:00
|
|
|
const char *p;
|
2010-02-02 12:42:08 +01:00
|
|
|
unsigned id;
|
2013-11-19 21:12:59 +01:00
|
|
|
Job *j;
|
2010-02-02 12:42:08 +01:00
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(m);
|
|
|
|
assert(s);
|
|
|
|
assert(_j);
|
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
p = startswith(s, "/org/freedesktop/systemd1/job/");
|
|
|
|
if (!p)
|
2010-02-02 12:42:08 +01:00
|
|
|
return -EINVAL;
|
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
r = safe_atou(p, &id);
|
2012-11-25 00:32:40 +01:00
|
|
|
if (r < 0)
|
2010-02-02 12:42:08 +01:00
|
|
|
return r;
|
|
|
|
|
2012-11-25 00:32:40 +01:00
|
|
|
j = manager_get_job(m, id);
|
|
|
|
if (!j)
|
2010-02-02 12:42:08 +01:00
|
|
|
return -ENOENT;
|
|
|
|
|
|
|
|
*_j = j;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2010-02-12 21:57:39 +01:00
|
|
|
|
2010-08-11 01:43:23 +02:00
|
|
|
void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
|
2010-04-10 17:53:17 +02:00
|
|
|
|
2010-08-11 01:43:23 +02:00
|
|
|
#ifdef HAVE_AUDIT
|
2014-01-12 21:55:10 +01:00
|
|
|
_cleanup_free_ char *p = NULL;
|
2014-11-04 00:47:44 +01:00
|
|
|
const char *msg;
|
2012-10-02 23:40:09 +02:00
|
|
|
int audit_fd;
|
2010-04-10 17:53:17 +02:00
|
|
|
|
2012-10-02 23:40:09 +02:00
|
|
|
audit_fd = get_audit_fd();
|
|
|
|
if (audit_fd < 0)
|
2010-04-10 17:53:17 +02:00
|
|
|
return;
|
|
|
|
|
2010-08-12 03:51:58 +02:00
|
|
|
/* Don't generate audit events if the service was already
|
|
|
|
* started and we're just deserializing */
|
2011-07-06 00:47:39 +02:00
|
|
|
if (m->n_reloading > 0)
|
2010-08-12 03:51:58 +02:00
|
|
|
return;
|
|
|
|
|
2012-09-18 17:11:12 +02:00
|
|
|
if (m->running_as != SYSTEMD_SYSTEM)
|
2011-03-18 04:31:22 +01:00
|
|
|
return;
|
|
|
|
|
2012-01-15 12:04:08 +01:00
|
|
|
if (u->type != UNIT_SERVICE)
|
2011-03-18 04:31:22 +01:00
|
|
|
return;
|
|
|
|
|
2013-01-02 22:03:35 +01:00
|
|
|
p = unit_name_to_prefix_and_instance(u->id);
|
|
|
|
if (!p) {
|
2014-11-04 00:47:44 +01:00
|
|
|
log_oom();
|
2010-04-10 17:53:17 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2015-02-03 02:05:59 +01:00
|
|
|
msg = strjoina("unit=", p);
|
2014-11-04 00:47:44 +01:00
|
|
|
if (audit_log_user_comm_message(audit_fd, type, msg, "systemd", NULL, NULL, NULL, success) < 0) {
|
|
|
|
if (errno == EPERM)
|
2011-03-14 17:48:34 +01:00
|
|
|
/* We aren't allowed to send audit messages?
|
2012-04-13 17:17:56 +02:00
|
|
|
* Then let's not retry again. */
|
2012-10-02 23:40:09 +02:00
|
|
|
close_audit_fd();
|
2014-11-04 00:47:44 +01:00
|
|
|
else
|
2014-11-28 19:29:59 +01:00
|
|
|
log_warning_errno(errno, "Failed to send audit message: %m");
|
2011-03-14 17:48:34 +01:00
|
|
|
}
|
2010-08-11 01:43:23 +02:00
|
|
|
#endif
|
2010-04-10 17:53:17 +02:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2010-10-06 03:55:49 +02:00
|
|
|
void manager_send_unit_plymouth(Manager *m, Unit *u) {
|
2014-08-03 18:52:03 +02:00
|
|
|
union sockaddr_union sa = PLYMOUTH_SOCKET;
|
2014-01-12 21:55:10 +01:00
|
|
|
|
2010-10-06 03:55:49 +02:00
|
|
|
int n = 0;
|
2014-01-12 21:55:10 +01:00
|
|
|
_cleanup_free_ char *message = NULL;
|
|
|
|
_cleanup_close_ int fd = -1;
|
2010-10-06 03:55:49 +02:00
|
|
|
|
|
|
|
/* Don't generate plymouth events if the service was already
|
|
|
|
* started and we're just deserializing */
|
2011-07-06 00:47:39 +02:00
|
|
|
if (m->n_reloading > 0)
|
2010-10-06 03:55:49 +02:00
|
|
|
return;
|
|
|
|
|
2012-09-18 17:11:12 +02:00
|
|
|
if (m->running_as != SYSTEMD_SYSTEM)
|
2010-10-06 03:55:49 +02:00
|
|
|
return;
|
|
|
|
|
2013-11-20 03:44:11 +01:00
|
|
|
if (detect_container(NULL) > 0)
|
|
|
|
return;
|
|
|
|
|
2012-01-15 12:04:08 +01:00
|
|
|
if (u->type != UNIT_SERVICE &&
|
|
|
|
u->type != UNIT_MOUNT &&
|
|
|
|
u->type != UNIT_SWAP)
|
2010-10-06 03:55:49 +02:00
|
|
|
return;
|
|
|
|
|
|
|
|
/* We set SOCK_NONBLOCK here so that we rather drop the
|
|
|
|
* message then wait for plymouth */
|
2013-03-25 00:45:16 +01:00
|
|
|
fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
|
|
|
|
if (fd < 0) {
|
2014-11-28 19:29:59 +01:00
|
|
|
log_error_errno(errno, "socket() failed: %m");
|
2010-10-06 03:55:49 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2010-11-16 03:12:54 +01:00
|
|
|
if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
|
2010-10-06 03:55:49 +02:00
|
|
|
|
2014-01-12 21:55:10 +01:00
|
|
|
if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
|
2014-11-28 19:29:59 +01:00
|
|
|
log_error_errno(errno, "connect() failed: %m");
|
2014-01-12 21:55:10 +01:00
|
|
|
return;
|
2010-10-06 03:55:49 +02:00
|
|
|
}
|
|
|
|
|
2012-01-15 12:04:08 +01:00
|
|
|
if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
|
2012-07-25 23:55:59 +02:00
|
|
|
log_oom();
|
2014-01-12 21:55:10 +01:00
|
|
|
return;
|
2010-10-06 03:55:49 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
errno = 0;
|
2014-01-12 21:55:10 +01:00
|
|
|
if (write(fd, message, n + 1) != n + 1)
|
|
|
|
if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
|
2014-11-28 19:29:59 +01:00
|
|
|
log_error_errno(errno, "Failed to write Plymouth message: %m");
|
2010-10-06 03:55:49 +02:00
|
|
|
}
|
|
|
|
|
2010-04-15 23:16:16 +02:00
|
|
|
void manager_dispatch_bus_name_owner_changed(
|
|
|
|
Manager *m,
|
|
|
|
const char *name,
|
|
|
|
const char* old_owner,
|
|
|
|
const char *new_owner) {
|
|
|
|
|
|
|
|
Unit *u;
|
|
|
|
|
|
|
|
assert(m);
|
|
|
|
assert(name);
|
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
u = hashmap_get(m->watch_bus, name);
|
|
|
|
if (!u)
|
2010-04-15 23:16:16 +02:00
|
|
|
return;
|
|
|
|
|
|
|
|
UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
|
|
|
|
}
|
|
|
|
|
2010-07-20 20:54:33 +02:00
|
|
|
int manager_open_serialization(Manager *m, FILE **_f) {
|
2014-01-26 02:48:01 +01:00
|
|
|
const char *path;
|
2013-10-21 15:24:18 +02:00
|
|
|
int fd = -1;
|
2010-04-21 03:27:44 +02:00
|
|
|
FILE *f;
|
|
|
|
|
|
|
|
assert(_f);
|
|
|
|
|
2014-01-26 02:48:01 +01:00
|
|
|
path = m->running_as == SYSTEMD_SYSTEM ? "/run/systemd" : "/tmp";
|
|
|
|
fd = open_tmpfile(path, O_RDWR|O_CLOEXEC);
|
2013-12-21 00:19:37 +01:00
|
|
|
if (fd < 0)
|
2010-04-21 03:27:44 +02:00
|
|
|
return -errno;
|
|
|
|
|
|
|
|
log_debug("Serializing state to %s", path);
|
|
|
|
|
2012-12-22 19:30:07 +01:00
|
|
|
f = fdopen(fd, "w+");
|
2013-12-21 00:19:37 +01:00
|
|
|
if (!f) {
|
2014-03-18 19:22:43 +01:00
|
|
|
safe_close(fd);
|
2010-04-21 03:27:44 +02:00
|
|
|
return -errno;
|
2013-12-21 00:19:37 +01:00
|
|
|
}
|
2010-04-21 03:27:44 +02:00
|
|
|
|
|
|
|
*_f = f;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-04-08 14:05:24 +02:00
|
|
|
int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
|
2010-04-21 03:27:44 +02:00
|
|
|
Iterator i;
|
|
|
|
Unit *u;
|
|
|
|
const char *t;
|
2013-02-12 00:14:39 +01:00
|
|
|
char **e;
|
2010-04-21 03:27:44 +02:00
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(m);
|
|
|
|
assert(f);
|
|
|
|
assert(fds);
|
|
|
|
|
2011-07-06 00:47:39 +02:00
|
|
|
m->n_reloading ++;
|
2011-04-20 03:53:12 +02:00
|
|
|
|
2015-01-21 04:22:15 +01:00
|
|
|
fprintf(f, "current-job-id=%"PRIu32"\n", m->current_job_id);
|
2011-04-07 18:46:39 +02:00
|
|
|
fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
|
2012-06-29 19:47:38 +02:00
|
|
|
fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
|
|
|
|
fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
|
2011-04-07 18:46:39 +02:00
|
|
|
|
2012-09-13 18:54:32 +02:00
|
|
|
dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
|
|
|
|
dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
|
2013-11-19 21:12:59 +01:00
|
|
|
dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
|
2010-11-08 06:31:09 +01:00
|
|
|
dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
|
2012-05-16 14:22:41 +02:00
|
|
|
|
2012-07-02 11:38:32 +02:00
|
|
|
if (!in_initrd()) {
|
2012-09-13 18:54:32 +02:00
|
|
|
dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
|
2012-05-16 14:22:41 +02:00
|
|
|
dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
|
2013-11-19 21:12:59 +01:00
|
|
|
dual_timestamp_serialize(f, "security-start-timestamp", &m->security_start_timestamp);
|
|
|
|
dual_timestamp_serialize(f, "security-finish-timestamp", &m->security_finish_timestamp);
|
|
|
|
dual_timestamp_serialize(f, "generators-start-timestamp", &m->generators_start_timestamp);
|
|
|
|
dual_timestamp_serialize(f, "generators-finish-timestamp", &m->generators_finish_timestamp);
|
|
|
|
dual_timestamp_serialize(f, "units-load-start-timestamp", &m->units_load_start_timestamp);
|
|
|
|
dual_timestamp_serialize(f, "units-load-finish-timestamp", &m->units_load_finish_timestamp);
|
2012-05-16 14:22:41 +02:00
|
|
|
}
|
2010-10-18 22:39:06 +02:00
|
|
|
|
2013-04-08 14:05:24 +02:00
|
|
|
if (!switching_root) {
|
|
|
|
STRV_FOREACH(e, m->environment) {
|
|
|
|
_cleanup_free_ char *ce;
|
2013-02-12 00:14:39 +01:00
|
|
|
|
2013-04-08 14:05:24 +02:00
|
|
|
ce = cescape(*e);
|
2013-11-30 03:53:42 +01:00
|
|
|
if (!ce)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
fprintf(f, "env=%s\n", *e);
|
2013-04-08 14:05:24 +02:00
|
|
|
}
|
2013-02-12 00:14:39 +01:00
|
|
|
}
|
|
|
|
|
2013-12-21 00:19:37 +01:00
|
|
|
if (m->notify_fd >= 0) {
|
|
|
|
int copy;
|
|
|
|
|
|
|
|
copy = fdset_put_dup(fds, m->notify_fd);
|
|
|
|
if (copy < 0)
|
|
|
|
return copy;
|
|
|
|
|
|
|
|
fprintf(f, "notify-fd=%i\n", copy);
|
|
|
|
fprintf(f, "notify-socket=%s\n", m->notify_socket);
|
|
|
|
}
|
|
|
|
|
2013-11-30 03:53:42 +01:00
|
|
|
if (m->kdbus_fd >= 0) {
|
|
|
|
int copy;
|
|
|
|
|
|
|
|
copy = fdset_put_dup(fds, m->kdbus_fd);
|
|
|
|
if (copy < 0)
|
|
|
|
return copy;
|
|
|
|
|
|
|
|
fprintf(f, "kdbus-fd=%i\n", copy);
|
|
|
|
}
|
|
|
|
|
2014-03-03 01:33:45 +01:00
|
|
|
bus_track_serialize(m->subscribed, f);
|
2013-07-10 19:24:03 +02:00
|
|
|
|
2010-10-20 14:40:44 +02:00
|
|
|
fputc('\n', f);
|
|
|
|
|
2010-04-21 03:27:44 +02:00
|
|
|
HASHMAP_FOREACH_KEY(u, t, m->units, i) {
|
2012-01-15 12:04:08 +01:00
|
|
|
if (u->id != t)
|
2010-04-21 03:27:44 +02:00
|
|
|
continue;
|
|
|
|
|
|
|
|
/* Start marker */
|
2012-01-15 12:04:08 +01:00
|
|
|
fputs(u->id, f);
|
2010-04-21 03:27:44 +02:00
|
|
|
fputc('\n', f);
|
|
|
|
|
2013-07-10 19:24:03 +02:00
|
|
|
r = unit_serialize(u, f, fds, !switching_root);
|
|
|
|
if (r < 0) {
|
2011-07-06 00:47:39 +02:00
|
|
|
m->n_reloading --;
|
2010-04-21 03:27:44 +02:00
|
|
|
return r;
|
2011-04-20 03:53:12 +02:00
|
|
|
}
|
2010-04-21 03:27:44 +02:00
|
|
|
}
|
|
|
|
|
2011-07-06 00:47:39 +02:00
|
|
|
assert(m->n_reloading > 0);
|
|
|
|
m->n_reloading --;
|
2011-04-20 03:53:12 +02:00
|
|
|
|
2010-04-21 03:27:44 +02:00
|
|
|
if (ferror(f))
|
|
|
|
return -EIO;
|
|
|
|
|
2011-04-28 22:07:01 +02:00
|
|
|
r = bus_fdset_add_all(m, fds);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
2010-04-21 03:27:44 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
|
|
|
|
int r = 0;
|
|
|
|
|
|
|
|
assert(m);
|
|
|
|
assert(f);
|
|
|
|
|
|
|
|
log_debug("Deserializing state...");
|
|
|
|
|
2011-07-06 00:47:39 +02:00
|
|
|
m->n_reloading ++;
|
2010-07-10 04:51:03 +02:00
|
|
|
|
2010-08-11 20:19:27 +02:00
|
|
|
for (;;) {
|
2011-04-07 18:48:50 +02:00
|
|
|
char line[LINE_MAX], *l;
|
2010-08-11 20:19:27 +02:00
|
|
|
|
|
|
|
if (!fgets(line, sizeof(line), f)) {
|
|
|
|
if (feof(f))
|
|
|
|
r = 0;
|
|
|
|
else
|
|
|
|
r = -errno;
|
|
|
|
|
|
|
|
goto finish;
|
|
|
|
}
|
|
|
|
|
|
|
|
char_array_0(line);
|
|
|
|
l = strstrip(line);
|
|
|
|
|
|
|
|
if (l[0] == 0)
|
|
|
|
break;
|
|
|
|
|
2011-04-07 18:46:39 +02:00
|
|
|
if (startswith(l, "current-job-id=")) {
|
|
|
|
uint32_t id;
|
|
|
|
|
|
|
|
if (safe_atou32(l+15, &id) < 0)
|
2014-12-02 00:19:05 +01:00
|
|
|
log_debug("Failed to parse current job id value %s", l+15);
|
2011-04-07 18:46:39 +02:00
|
|
|
else
|
|
|
|
m->current_job_id = MAX(m->current_job_id, id);
|
2013-11-19 21:12:59 +01:00
|
|
|
|
2012-06-29 19:47:38 +02:00
|
|
|
} else if (startswith(l, "n-installed-jobs=")) {
|
|
|
|
uint32_t n;
|
|
|
|
|
|
|
|
if (safe_atou32(l+17, &n) < 0)
|
2014-12-02 00:19:05 +01:00
|
|
|
log_debug("Failed to parse installed jobs counter %s", l+17);
|
2012-06-29 19:47:38 +02:00
|
|
|
else
|
|
|
|
m->n_installed_jobs += n;
|
2013-11-19 21:12:59 +01:00
|
|
|
|
2012-06-29 19:47:38 +02:00
|
|
|
} else if (startswith(l, "n-failed-jobs=")) {
|
|
|
|
uint32_t n;
|
|
|
|
|
|
|
|
if (safe_atou32(l+14, &n) < 0)
|
2014-12-02 00:19:05 +01:00
|
|
|
log_debug("Failed to parse failed jobs counter %s", l+14);
|
2012-06-29 19:47:38 +02:00
|
|
|
else
|
|
|
|
m->n_failed_jobs += n;
|
2013-11-19 21:12:59 +01:00
|
|
|
|
2011-04-07 18:46:39 +02:00
|
|
|
} else if (startswith(l, "taint-usr=")) {
|
|
|
|
int b;
|
|
|
|
|
2013-11-30 03:53:42 +01:00
|
|
|
b = parse_boolean(l+10);
|
|
|
|
if (b < 0)
|
2014-12-02 00:19:05 +01:00
|
|
|
log_debug("Failed to parse taint /usr flag %s", l+10);
|
2011-04-07 18:46:39 +02:00
|
|
|
else
|
|
|
|
m->taint_usr = m->taint_usr || b;
|
2013-11-19 21:12:59 +01:00
|
|
|
|
2012-09-13 18:54:32 +02:00
|
|
|
} else if (startswith(l, "firmware-timestamp="))
|
|
|
|
dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
|
|
|
|
else if (startswith(l, "loader-timestamp="))
|
|
|
|
dual_timestamp_deserialize(l+17, &m->loader_timestamp);
|
|
|
|
else if (startswith(l, "kernel-timestamp="))
|
|
|
|
dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
|
|
|
|
else if (startswith(l, "initrd-timestamp="))
|
2010-11-08 06:31:09 +01:00
|
|
|
dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
|
2012-09-13 18:54:32 +02:00
|
|
|
else if (startswith(l, "userspace-timestamp="))
|
|
|
|
dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
|
2010-10-27 00:01:12 +02:00
|
|
|
else if (startswith(l, "finish-timestamp="))
|
2010-10-28 03:16:03 +02:00
|
|
|
dual_timestamp_deserialize(l+17, &m->finish_timestamp);
|
2013-11-19 21:12:59 +01:00
|
|
|
else if (startswith(l, "security-start-timestamp="))
|
|
|
|
dual_timestamp_deserialize(l+25, &m->security_start_timestamp);
|
|
|
|
else if (startswith(l, "security-finish-timestamp="))
|
|
|
|
dual_timestamp_deserialize(l+26, &m->security_finish_timestamp);
|
|
|
|
else if (startswith(l, "generators-start-timestamp="))
|
|
|
|
dual_timestamp_deserialize(l+27, &m->generators_start_timestamp);
|
|
|
|
else if (startswith(l, "generators-finish-timestamp="))
|
|
|
|
dual_timestamp_deserialize(l+28, &m->generators_finish_timestamp);
|
|
|
|
else if (startswith(l, "units-load-start-timestamp="))
|
|
|
|
dual_timestamp_deserialize(l+27, &m->units_load_start_timestamp);
|
|
|
|
else if (startswith(l, "units-load-finish-timestamp="))
|
|
|
|
dual_timestamp_deserialize(l+28, &m->units_load_finish_timestamp);
|
2013-02-12 00:14:39 +01:00
|
|
|
else if (startswith(l, "env=")) {
|
|
|
|
_cleanup_free_ char *uce = NULL;
|
|
|
|
char **e;
|
|
|
|
|
|
|
|
uce = cunescape(l+4);
|
|
|
|
if (!uce) {
|
|
|
|
r = -ENOMEM;
|
|
|
|
goto finish;
|
|
|
|
}
|
|
|
|
|
|
|
|
e = strv_env_set(m->environment, uce);
|
|
|
|
if (!e) {
|
|
|
|
r = -ENOMEM;
|
|
|
|
goto finish;
|
|
|
|
}
|
|
|
|
|
|
|
|
strv_free(m->environment);
|
|
|
|
m->environment = e;
|
2013-11-30 03:53:42 +01:00
|
|
|
|
2013-12-21 00:19:37 +01:00
|
|
|
} else if (startswith(l, "notify-fd=")) {
|
|
|
|
int fd;
|
|
|
|
|
|
|
|
if (safe_atoi(l + 10, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
|
2014-12-02 00:19:05 +01:00
|
|
|
log_debug("Failed to parse notify fd: %s", l + 10);
|
2013-12-21 00:19:37 +01:00
|
|
|
else {
|
2014-03-18 19:22:43 +01:00
|
|
|
m->notify_event_source = sd_event_source_unref(m->notify_event_source);
|
|
|
|
safe_close(m->notify_fd);
|
2013-12-21 00:19:37 +01:00
|
|
|
m->notify_fd = fdset_remove(fds, fd);
|
|
|
|
}
|
|
|
|
|
|
|
|
} else if (startswith(l, "notify-socket=")) {
|
|
|
|
char *n;
|
|
|
|
|
|
|
|
n = strdup(l+14);
|
|
|
|
if (!n) {
|
|
|
|
r = -ENOMEM;
|
|
|
|
goto finish;
|
|
|
|
}
|
|
|
|
|
|
|
|
free(m->notify_socket);
|
|
|
|
m->notify_socket = n;
|
|
|
|
|
2013-11-30 03:53:42 +01:00
|
|
|
} else if (startswith(l, "kdbus-fd=")) {
|
|
|
|
int fd;
|
|
|
|
|
2013-12-02 23:10:28 +01:00
|
|
|
if (safe_atoi(l + 9, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
|
2014-12-02 00:19:05 +01:00
|
|
|
log_debug("Failed to parse kdbus fd: %s", l + 9);
|
2013-11-30 03:53:42 +01:00
|
|
|
else {
|
2014-03-18 19:22:43 +01:00
|
|
|
safe_close(m->kdbus_fd);
|
2013-11-30 03:53:42 +01:00
|
|
|
m->kdbus_fd = fdset_remove(fds, fd);
|
|
|
|
}
|
|
|
|
|
2014-12-02 00:15:13 +01:00
|
|
|
} else {
|
|
|
|
int k;
|
|
|
|
|
|
|
|
k = bus_track_deserialize_item(&m->deserialized_subscribed, l);
|
|
|
|
if (k < 0)
|
|
|
|
log_debug_errno(k, "Failed to deserialize bus tracker object: %m");
|
|
|
|
else if (k == 0)
|
|
|
|
log_debug("Unknown serialization item '%s'", l);
|
|
|
|
}
|
2010-08-11 20:19:27 +02:00
|
|
|
}
|
|
|
|
|
2010-04-21 03:27:44 +02:00
|
|
|
for (;;) {
|
|
|
|
Unit *u;
|
|
|
|
char name[UNIT_NAME_MAX+2];
|
|
|
|
|
|
|
|
/* Start marker */
|
|
|
|
if (!fgets(name, sizeof(name), f)) {
|
|
|
|
if (feof(f))
|
2010-08-11 20:19:27 +02:00
|
|
|
r = 0;
|
|
|
|
else
|
|
|
|
r = -errno;
|
2010-04-21 03:27:44 +02:00
|
|
|
|
2010-07-10 04:51:03 +02:00
|
|
|
goto finish;
|
2010-04-21 03:27:44 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
char_array_0(name);
|
|
|
|
|
2013-01-02 22:03:35 +01:00
|
|
|
r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
|
|
|
|
if (r < 0)
|
2010-07-10 04:51:03 +02:00
|
|
|
goto finish;
|
2010-04-21 03:27:44 +02:00
|
|
|
|
2012-12-22 19:30:07 +01:00
|
|
|
r = unit_deserialize(u, f, fds);
|
|
|
|
if (r < 0)
|
2010-07-10 04:51:03 +02:00
|
|
|
goto finish;
|
2010-04-21 03:27:44 +02:00
|
|
|
}
|
|
|
|
|
2010-08-11 20:19:27 +02:00
|
|
|
finish:
|
2013-12-10 18:28:26 +01:00
|
|
|
if (ferror(f))
|
2010-07-10 04:51:03 +02:00
|
|
|
r = -EIO;
|
2010-04-21 03:27:44 +02:00
|
|
|
|
2011-07-06 00:47:39 +02:00
|
|
|
assert(m->n_reloading > 0);
|
|
|
|
m->n_reloading --;
|
2010-07-10 04:51:03 +02:00
|
|
|
|
|
|
|
return r;
|
2010-04-21 03:27:44 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
int manager_reload(Manager *m) {
|
|
|
|
int r, q;
|
2013-10-12 01:33:48 +02:00
|
|
|
_cleanup_fclose_ FILE *f = NULL;
|
|
|
|
_cleanup_fdset_free_ FDSet *fds = NULL;
|
2010-04-21 03:27:44 +02:00
|
|
|
|
|
|
|
assert(m);
|
|
|
|
|
2012-05-23 03:43:29 +02:00
|
|
|
r = manager_open_serialization(m, &f);
|
|
|
|
if (r < 0)
|
2010-04-21 03:27:44 +02:00
|
|
|
return r;
|
|
|
|
|
2011-07-06 00:47:39 +02:00
|
|
|
m->n_reloading ++;
|
2013-11-19 21:12:59 +01:00
|
|
|
bus_manager_send_reloading(m, true);
|
2011-04-20 03:53:12 +02:00
|
|
|
|
2012-05-23 03:43:29 +02:00
|
|
|
fds = fdset_new();
|
|
|
|
if (!fds) {
|
2011-07-06 00:47:39 +02:00
|
|
|
m->n_reloading --;
|
2013-10-12 01:33:48 +02:00
|
|
|
return -ENOMEM;
|
2010-04-21 03:27:44 +02:00
|
|
|
}
|
|
|
|
|
2013-04-08 14:05:24 +02:00
|
|
|
r = manager_serialize(m, f, fds, false);
|
2012-05-23 03:43:29 +02:00
|
|
|
if (r < 0) {
|
2011-07-06 00:47:39 +02:00
|
|
|
m->n_reloading --;
|
2013-10-12 01:33:48 +02:00
|
|
|
return r;
|
2011-04-20 03:53:12 +02:00
|
|
|
}
|
2010-04-21 03:27:44 +02:00
|
|
|
|
|
|
|
if (fseeko(f, 0, SEEK_SET) < 0) {
|
2011-07-06 00:47:39 +02:00
|
|
|
m->n_reloading --;
|
2013-10-12 01:33:48 +02:00
|
|
|
return -errno;
|
2010-04-21 03:27:44 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* From here on there is no way back. */
|
|
|
|
manager_clear_jobs_and_units(m);
|
2010-11-11 21:28:33 +01:00
|
|
|
manager_undo_generators(m);
|
2010-06-15 14:45:15 +02:00
|
|
|
lookup_paths_free(&m->lookup_paths);
|
2010-06-15 14:32:26 +02:00
|
|
|
|
2012-05-23 03:43:29 +02:00
|
|
|
/* Find new unit paths */
|
Implement masking and overriding of generators
Sometimes it is necessary to stop a generator from running. Either
because of a bug, or for testing, or some other reason. The only way
to do that would be to rename or chmod the generator binary, which is
inconvenient and does not survive upgrades. Allow masking and
overriding generators similarly to units and other configuration
files.
For the systemd instance, masking would be more common, rather than
overriding generators. For the user instances, it may also be useful
for users to have generators in $XDG_CONFIG_HOME to augment or
override system-wide generators.
Directories are searched according to the usual scheme (/usr/lib,
/usr/local/lib, /run, /etc), and files with the same name in higher
priority directories override files with the same name in lower
priority directories. Empty files and links to /dev/null mask a given
name.
https://bugs.freedesktop.org/show_bug.cgi?id=87230
2015-01-09 02:47:25 +01:00
|
|
|
q = manager_run_generators(m);
|
|
|
|
if (q < 0 && r >= 0)
|
|
|
|
r = q;
|
2010-11-11 21:28:33 +01:00
|
|
|
|
2012-05-23 03:43:29 +02:00
|
|
|
q = lookup_paths_init(
|
|
|
|
&m->lookup_paths, m->running_as, true,
|
2014-04-24 07:44:10 +02:00
|
|
|
NULL,
|
2012-05-23 03:43:29 +02:00
|
|
|
m->generator_unit_path,
|
|
|
|
m->generator_unit_path_early,
|
|
|
|
m->generator_unit_path_late);
|
Implement masking and overriding of generators
Sometimes it is necessary to stop a generator from running. Either
because of a bug, or for testing, or some other reason. The only way
to do that would be to rename or chmod the generator binary, which is
inconvenient and does not survive upgrades. Allow masking and
overriding generators similarly to units and other configuration
files.
For the systemd instance, masking would be more common, rather than
overriding generators. For the user instances, it may also be useful
for users to have generators in $XDG_CONFIG_HOME to augment or
override system-wide generators.
Directories are searched according to the usual scheme (/usr/lib,
/usr/local/lib, /run, /etc), and files with the same name in higher
priority directories override files with the same name in lower
priority directories. Empty files and links to /dev/null mask a given
name.
https://bugs.freedesktop.org/show_bug.cgi?id=87230
2015-01-09 02:47:25 +01:00
|
|
|
if (q < 0 && r >= 0)
|
2012-05-23 03:43:29 +02:00
|
|
|
r = q;
|
|
|
|
|
2010-11-11 21:28:33 +01:00
|
|
|
manager_build_unit_path_cache(m);
|
|
|
|
|
2010-04-21 03:27:44 +02:00
|
|
|
/* First, enumerate what we can from all config files */
|
2012-05-23 03:43:29 +02:00
|
|
|
q = manager_enumerate(m);
|
Implement masking and overriding of generators
Sometimes it is necessary to stop a generator from running. Either
because of a bug, or for testing, or some other reason. The only way
to do that would be to rename or chmod the generator binary, which is
inconvenient and does not survive upgrades. Allow masking and
overriding generators similarly to units and other configuration
files.
For the systemd instance, masking would be more common, rather than
overriding generators. For the user instances, it may also be useful
for users to have generators in $XDG_CONFIG_HOME to augment or
override system-wide generators.
Directories are searched according to the usual scheme (/usr/lib,
/usr/local/lib, /run, /etc), and files with the same name in higher
priority directories override files with the same name in lower
priority directories. Empty files and links to /dev/null mask a given
name.
https://bugs.freedesktop.org/show_bug.cgi?id=87230
2015-01-09 02:47:25 +01:00
|
|
|
if (q < 0 && r >= 0)
|
2010-04-21 03:27:44 +02:00
|
|
|
r = q;
|
|
|
|
|
|
|
|
/* Second, deserialize our stored data */
|
2012-05-23 03:43:29 +02:00
|
|
|
q = manager_deserialize(m, f, fds);
|
Implement masking and overriding of generators
Sometimes it is necessary to stop a generator from running. Either
because of a bug, or for testing, or some other reason. The only way
to do that would be to rename or chmod the generator binary, which is
inconvenient and does not survive upgrades. Allow masking and
overriding generators similarly to units and other configuration
files.
For the systemd instance, masking would be more common, rather than
overriding generators. For the user instances, it may also be useful
for users to have generators in $XDG_CONFIG_HOME to augment or
override system-wide generators.
Directories are searched according to the usual scheme (/usr/lib,
/usr/local/lib, /run, /etc), and files with the same name in higher
priority directories override files with the same name in lower
priority directories. Empty files and links to /dev/null mask a given
name.
https://bugs.freedesktop.org/show_bug.cgi?id=87230
2015-01-09 02:47:25 +01:00
|
|
|
if (q < 0 && r >= 0)
|
2010-04-21 03:27:44 +02:00
|
|
|
r = q;
|
|
|
|
|
|
|
|
fclose(f);
|
|
|
|
f = NULL;
|
|
|
|
|
2014-01-10 02:49:18 +01:00
|
|
|
/* Re-register notify_fd as event source */
|
|
|
|
q = manager_setup_notify(m);
|
Implement masking and overriding of generators
Sometimes it is necessary to stop a generator from running. Either
because of a bug, or for testing, or some other reason. The only way
to do that would be to rename or chmod the generator binary, which is
inconvenient and does not survive upgrades. Allow masking and
overriding generators similarly to units and other configuration
files.
For the systemd instance, masking would be more common, rather than
overriding generators. For the user instances, it may also be useful
for users to have generators in $XDG_CONFIG_HOME to augment or
override system-wide generators.
Directories are searched according to the usual scheme (/usr/lib,
/usr/local/lib, /run, /etc), and files with the same name in higher
priority directories override files with the same name in lower
priority directories. Empty files and links to /dev/null mask a given
name.
https://bugs.freedesktop.org/show_bug.cgi?id=87230
2015-01-09 02:47:25 +01:00
|
|
|
if (q < 0 && r >= 0)
|
2014-01-10 02:49:18 +01:00
|
|
|
r = q;
|
|
|
|
|
2010-04-21 03:27:44 +02:00
|
|
|
/* Third, fire things up! */
|
2012-05-23 03:43:29 +02:00
|
|
|
q = manager_coldplug(m);
|
Implement masking and overriding of generators
Sometimes it is necessary to stop a generator from running. Either
because of a bug, or for testing, or some other reason. The only way
to do that would be to rename or chmod the generator binary, which is
inconvenient and does not survive upgrades. Allow masking and
overriding generators similarly to units and other configuration
files.
For the systemd instance, masking would be more common, rather than
overriding generators. For the user instances, it may also be useful
for users to have generators in $XDG_CONFIG_HOME to augment or
override system-wide generators.
Directories are searched according to the usual scheme (/usr/lib,
/usr/local/lib, /run, /etc), and files with the same name in higher
priority directories override files with the same name in lower
priority directories. Empty files and links to /dev/null mask a given
name.
https://bugs.freedesktop.org/show_bug.cgi?id=87230
2015-01-09 02:47:25 +01:00
|
|
|
if (q < 0 && r >= 0)
|
2010-04-21 03:27:44 +02:00
|
|
|
r = q;
|
|
|
|
|
2011-07-06 00:47:39 +02:00
|
|
|
assert(m->n_reloading > 0);
|
|
|
|
m->n_reloading--;
|
2010-07-13 19:01:20 +02:00
|
|
|
|
2013-07-10 21:10:53 +02:00
|
|
|
m->send_reloading_done = true;
|
|
|
|
|
2010-04-21 03:27:44 +02:00
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2013-03-14 18:12:27 +01:00
|
|
|
bool manager_is_reloading_or_reexecuting(Manager *m) {
|
|
|
|
assert(m);
|
|
|
|
|
|
|
|
return m->n_reloading != 0;
|
|
|
|
}
|
|
|
|
|
2010-08-31 00:23:34 +02:00
|
|
|
void manager_reset_failed(Manager *m) {
|
2010-07-18 04:58:01 +02:00
|
|
|
Unit *u;
|
|
|
|
Iterator i;
|
|
|
|
|
|
|
|
assert(m);
|
|
|
|
|
|
|
|
HASHMAP_FOREACH(u, m->units, i)
|
2010-08-31 00:23:34 +02:00
|
|
|
unit_reset_failed(u);
|
2010-07-18 04:58:01 +02:00
|
|
|
}
|
|
|
|
|
2013-04-26 02:57:41 +02:00
|
|
|
bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
|
2010-09-01 03:30:59 +02:00
|
|
|
Unit *u;
|
|
|
|
|
|
|
|
assert(m);
|
|
|
|
assert(name);
|
|
|
|
|
|
|
|
/* Returns true if the unit is inactive or going down */
|
2013-01-02 22:03:35 +01:00
|
|
|
u = manager_get_unit(m, name);
|
|
|
|
if (!u)
|
2010-09-01 03:30:59 +02:00
|
|
|
return true;
|
|
|
|
|
2013-04-26 02:57:41 +02:00
|
|
|
return unit_inactive_or_pending(u);
|
2010-09-01 03:30:59 +02:00
|
|
|
}
|
|
|
|
|
2014-11-02 18:19:38 +01:00
|
|
|
static void manager_notify_finished(Manager *m) {
|
2012-09-13 19:29:46 +02:00
|
|
|
char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
|
2012-09-13 18:54:32 +02:00
|
|
|
usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
|
2010-09-21 04:14:38 +02:00
|
|
|
|
2014-11-02 18:19:38 +01:00
|
|
|
if (m->test_run)
|
2010-09-21 04:14:38 +02:00
|
|
|
return;
|
|
|
|
|
2012-09-18 17:11:12 +02:00
|
|
|
if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
|
2011-03-14 21:47:41 +01:00
|
|
|
|
2012-09-13 18:54:32 +02:00
|
|
|
/* Note that m->kernel_usec.monotonic is always at 0,
|
|
|
|
* and m->firmware_usec.monotonic and
|
|
|
|
* m->loader_usec.monotonic should be considered
|
|
|
|
* negative values. */
|
|
|
|
|
2012-09-13 19:29:46 +02:00
|
|
|
firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
|
|
|
|
loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
|
2012-09-13 18:54:32 +02:00
|
|
|
userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
|
2012-09-13 19:29:46 +02:00
|
|
|
total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
|
2011-06-27 13:47:03 +02:00
|
|
|
|
2010-11-08 06:31:09 +01:00
|
|
|
if (dual_timestamp_is_set(&m->initrd_timestamp)) {
|
2011-06-27 13:47:03 +02:00
|
|
|
|
2012-09-13 18:54:32 +02:00
|
|
|
kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
|
|
|
|
initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
|
2011-06-27 13:47:03 +02:00
|
|
|
|
2014-08-22 16:41:00 +02:00
|
|
|
log_struct(LOG_INFO,
|
2014-11-28 02:05:14 +01:00
|
|
|
LOG_MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
|
2014-08-22 16:41:00 +02:00
|
|
|
"KERNEL_USEC="USEC_FMT, kernel_usec,
|
|
|
|
"INITRD_USEC="USEC_FMT, initrd_usec,
|
|
|
|
"USERSPACE_USEC="USEC_FMT, userspace_usec,
|
2014-11-28 02:05:14 +01:00
|
|
|
LOG_MESSAGE("Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
|
|
|
|
format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
|
|
|
|
format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
|
|
|
|
format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
|
|
|
|
format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC)),
|
2014-08-22 16:41:00 +02:00
|
|
|
NULL);
|
2011-06-27 13:47:03 +02:00
|
|
|
} else {
|
2012-09-13 18:54:32 +02:00
|
|
|
kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
|
2011-06-27 13:47:03 +02:00
|
|
|
initrd_usec = 0;
|
|
|
|
|
2012-08-24 22:43:33 +02:00
|
|
|
log_struct(LOG_INFO,
|
2014-11-28 02:05:14 +01:00
|
|
|
LOG_MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
|
2014-08-22 16:41:00 +02:00
|
|
|
"KERNEL_USEC="USEC_FMT, kernel_usec,
|
2013-12-30 23:22:26 +01:00
|
|
|
"USERSPACE_USEC="USEC_FMT, userspace_usec,
|
2014-11-28 02:05:14 +01:00
|
|
|
LOG_MESSAGE("Startup finished in %s (kernel) + %s (userspace) = %s.",
|
|
|
|
format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
|
|
|
|
format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
|
|
|
|
format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC)),
|
2012-08-24 22:43:33 +02:00
|
|
|
NULL);
|
2014-08-22 16:41:00 +02:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
|
|
|
|
total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
|
|
|
|
|
|
|
|
log_struct(LOG_INFO,
|
2014-11-28 02:05:14 +01:00
|
|
|
LOG_MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
|
2014-08-22 16:41:00 +02:00
|
|
|
"USERSPACE_USEC="USEC_FMT, userspace_usec,
|
2014-11-28 02:05:14 +01:00
|
|
|
LOG_MESSAGE("Startup finished in %s.",
|
|
|
|
format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC)),
|
2014-08-22 16:41:00 +02:00
|
|
|
NULL);
|
2011-06-27 13:47:03 +02:00
|
|
|
}
|
2010-09-21 04:14:38 +02:00
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
bus_manager_send_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
|
2011-06-30 02:15:41 +02:00
|
|
|
|
|
|
|
sd_notifyf(false,
|
2014-08-21 17:19:28 +02:00
|
|
|
"READY=1\n"
|
|
|
|
"STATUS=Startup finished in %s.",
|
2013-04-04 02:56:56 +02:00
|
|
|
format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
|
2010-09-21 04:14:38 +02:00
|
|
|
}
|
|
|
|
|
2014-11-02 18:19:38 +01:00
|
|
|
void manager_check_finished(Manager *m) {
|
|
|
|
Unit *u = NULL;
|
|
|
|
Iterator i;
|
|
|
|
|
|
|
|
assert(m);
|
|
|
|
|
|
|
|
if (hashmap_size(m->jobs) > 0) {
|
|
|
|
|
|
|
|
if (m->jobs_in_progress_event_source)
|
2015-03-14 03:11:09 +01:00
|
|
|
/* Ignore any failure, this is only for feedback */
|
|
|
|
(void) sd_event_source_set_time(m->jobs_in_progress_event_source,
|
|
|
|
now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_WAIT_USEC);
|
2014-11-02 18:19:38 +01:00
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
manager_flip_auto_status(m, false);
|
|
|
|
|
|
|
|
/* Notify Type=idle units that we are done now */
|
|
|
|
m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
|
|
|
|
manager_close_idle_pipe(m);
|
|
|
|
|
|
|
|
/* Turn off confirm spawn now */
|
|
|
|
m->confirm_spawn = false;
|
|
|
|
|
|
|
|
/* No need to update ask password status when we're going non-interactive */
|
|
|
|
manager_close_ask_password(m);
|
|
|
|
|
|
|
|
/* This is no longer the first boot */
|
|
|
|
manager_set_first_boot(m, false);
|
|
|
|
|
|
|
|
if (dual_timestamp_is_set(&m->finish_timestamp))
|
|
|
|
return;
|
|
|
|
|
|
|
|
dual_timestamp_get(&m->finish_timestamp);
|
|
|
|
|
|
|
|
manager_notify_finished(m);
|
|
|
|
|
|
|
|
SET_FOREACH(u, m->startup_units, i)
|
|
|
|
if (u->cgroup_path)
|
|
|
|
cgroup_context_apply(unit_get_cgroup_context(u), unit_get_cgroup_mask(u), u->cgroup_path, manager_state(m));
|
|
|
|
}
|
|
|
|
|
2012-05-23 03:43:29 +02:00
|
|
|
static int create_generator_dir(Manager *m, char **generator, const char *name) {
|
|
|
|
char *p;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(m);
|
|
|
|
assert(generator);
|
|
|
|
assert(name);
|
|
|
|
|
|
|
|
if (*generator)
|
|
|
|
return 0;
|
|
|
|
|
2012-09-18 17:11:12 +02:00
|
|
|
if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
|
2014-01-06 04:50:26 +01:00
|
|
|
/* systemd --system, not running --test */
|
2012-05-23 03:43:29 +02:00
|
|
|
|
|
|
|
p = strappend("/run/systemd/", name);
|
2012-07-25 23:55:59 +02:00
|
|
|
if (!p)
|
|
|
|
return log_oom();
|
2012-05-23 03:43:29 +02:00
|
|
|
|
2014-01-06 04:50:26 +01:00
|
|
|
r = mkdir_p_label(p, 0755);
|
|
|
|
if (r < 0) {
|
2014-11-28 17:09:20 +01:00
|
|
|
log_error_errno(r, "Failed to create generator directory %s: %m", p);
|
2014-01-06 04:50:26 +01:00
|
|
|
free(p);
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
} else if (m->running_as == SYSTEMD_USER) {
|
|
|
|
const char *s = NULL;
|
|
|
|
|
|
|
|
s = getenv("XDG_RUNTIME_DIR");
|
|
|
|
if (!s)
|
|
|
|
return -EINVAL;
|
|
|
|
p = strjoin(s, "/systemd/", name, NULL);
|
|
|
|
if (!p)
|
|
|
|
return log_oom();
|
|
|
|
|
2012-05-31 12:40:20 +02:00
|
|
|
r = mkdir_p_label(p, 0755);
|
2012-05-23 03:43:29 +02:00
|
|
|
if (r < 0) {
|
2014-11-28 17:09:20 +01:00
|
|
|
log_error_errno(r, "Failed to create generator directory %s: %m", p);
|
2012-05-23 03:43:29 +02:00
|
|
|
free(p);
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
} else {
|
2014-01-06 04:50:26 +01:00
|
|
|
/* systemd --system --test */
|
|
|
|
|
2012-07-13 13:41:01 +02:00
|
|
|
p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
|
2012-07-25 23:55:59 +02:00
|
|
|
if (!p)
|
|
|
|
return log_oom();
|
2012-05-23 03:43:29 +02:00
|
|
|
|
|
|
|
if (!mkdtemp(p)) {
|
2014-11-28 19:29:59 +01:00
|
|
|
log_error_errno(errno, "Failed to create generator directory %s: %m",
|
2013-02-02 16:36:11 +01:00
|
|
|
p);
|
2013-03-01 18:30:01 +01:00
|
|
|
free(p);
|
2012-05-23 03:43:29 +02:00
|
|
|
return -errno;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
*generator = p;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void trim_generator_dir(Manager *m, char **generator) {
|
|
|
|
assert(m);
|
|
|
|
assert(generator);
|
|
|
|
|
|
|
|
if (!*generator)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (rmdir(*generator) >= 0) {
|
|
|
|
free(*generator);
|
|
|
|
*generator = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
Implement masking and overriding of generators
Sometimes it is necessary to stop a generator from running. Either
because of a bug, or for testing, or some other reason. The only way
to do that would be to rename or chmod the generator binary, which is
inconvenient and does not survive upgrades. Allow masking and
overriding generators similarly to units and other configuration
files.
For the systemd instance, masking would be more common, rather than
overriding generators. For the user instances, it may also be useful
for users to have generators in $XDG_CONFIG_HOME to augment or
override system-wide generators.
Directories are searched according to the usual scheme (/usr/lib,
/usr/local/lib, /run, /etc), and files with the same name in higher
priority directories override files with the same name in lower
priority directories. Empty files and links to /dev/null mask a given
name.
https://bugs.freedesktop.org/show_bug.cgi?id=87230
2015-01-09 02:47:25 +01:00
|
|
|
static int manager_run_generators(Manager *m) {
|
|
|
|
_cleanup_free_ char **paths = NULL;
|
2012-05-23 03:43:29 +02:00
|
|
|
const char *argv[5];
|
Implement masking and overriding of generators
Sometimes it is necessary to stop a generator from running. Either
because of a bug, or for testing, or some other reason. The only way
to do that would be to rename or chmod the generator binary, which is
inconvenient and does not survive upgrades. Allow masking and
overriding generators similarly to units and other configuration
files.
For the systemd instance, masking would be more common, rather than
overriding generators. For the user instances, it may also be useful
for users to have generators in $XDG_CONFIG_HOME to augment or
override system-wide generators.
Directories are searched according to the usual scheme (/usr/lib,
/usr/local/lib, /run, /etc), and files with the same name in higher
priority directories override files with the same name in lower
priority directories. Empty files and links to /dev/null mask a given
name.
https://bugs.freedesktop.org/show_bug.cgi?id=87230
2015-01-09 02:47:25 +01:00
|
|
|
char **path;
|
2012-05-23 03:43:29 +02:00
|
|
|
int r;
|
2010-11-11 21:28:33 +01:00
|
|
|
|
|
|
|
assert(m);
|
|
|
|
|
2014-01-07 14:41:24 +01:00
|
|
|
if (m->test_run)
|
Implement masking and overriding of generators
Sometimes it is necessary to stop a generator from running. Either
because of a bug, or for testing, or some other reason. The only way
to do that would be to rename or chmod the generator binary, which is
inconvenient and does not survive upgrades. Allow masking and
overriding generators similarly to units and other configuration
files.
For the systemd instance, masking would be more common, rather than
overriding generators. For the user instances, it may also be useful
for users to have generators in $XDG_CONFIG_HOME to augment or
override system-wide generators.
Directories are searched according to the usual scheme (/usr/lib,
/usr/local/lib, /run, /etc), and files with the same name in higher
priority directories override files with the same name in lower
priority directories. Empty files and links to /dev/null mask a given
name.
https://bugs.freedesktop.org/show_bug.cgi?id=87230
2015-01-09 02:47:25 +01:00
|
|
|
return 0;
|
2014-01-07 14:41:24 +01:00
|
|
|
|
Implement masking and overriding of generators
Sometimes it is necessary to stop a generator from running. Either
because of a bug, or for testing, or some other reason. The only way
to do that would be to rename or chmod the generator binary, which is
inconvenient and does not survive upgrades. Allow masking and
overriding generators similarly to units and other configuration
files.
For the systemd instance, masking would be more common, rather than
overriding generators. For the user instances, it may also be useful
for users to have generators in $XDG_CONFIG_HOME to augment or
override system-wide generators.
Directories are searched according to the usual scheme (/usr/lib,
/usr/local/lib, /run, /etc), and files with the same name in higher
priority directories override files with the same name in lower
priority directories. Empty files and links to /dev/null mask a given
name.
https://bugs.freedesktop.org/show_bug.cgi?id=87230
2015-01-09 02:47:25 +01:00
|
|
|
paths = generator_paths(m->running_as);
|
|
|
|
if (!paths)
|
|
|
|
return log_oom();
|
2010-11-11 21:28:33 +01:00
|
|
|
|
2015-01-08 23:30:07 +01:00
|
|
|
/* Optimize by skipping the whole process by not creating output directories
|
|
|
|
* if no generators are found. */
|
Implement masking and overriding of generators
Sometimes it is necessary to stop a generator from running. Either
because of a bug, or for testing, or some other reason. The only way
to do that would be to rename or chmod the generator binary, which is
inconvenient and does not survive upgrades. Allow masking and
overriding generators similarly to units and other configuration
files.
For the systemd instance, masking would be more common, rather than
overriding generators. For the user instances, it may also be useful
for users to have generators in $XDG_CONFIG_HOME to augment or
override system-wide generators.
Directories are searched according to the usual scheme (/usr/lib,
/usr/local/lib, /run, /etc), and files with the same name in higher
priority directories override files with the same name in lower
priority directories. Empty files and links to /dev/null mask a given
name.
https://bugs.freedesktop.org/show_bug.cgi?id=87230
2015-01-09 02:47:25 +01:00
|
|
|
STRV_FOREACH(path, paths) {
|
|
|
|
r = access(*path, F_OK);
|
|
|
|
if (r == 0)
|
|
|
|
goto found;
|
2015-01-08 23:30:07 +01:00
|
|
|
if (errno != ENOENT)
|
Implement masking and overriding of generators
Sometimes it is necessary to stop a generator from running. Either
because of a bug, or for testing, or some other reason. The only way
to do that would be to rename or chmod the generator binary, which is
inconvenient and does not survive upgrades. Allow masking and
overriding generators similarly to units and other configuration
files.
For the systemd instance, masking would be more common, rather than
overriding generators. For the user instances, it may also be useful
for users to have generators in $XDG_CONFIG_HOME to augment or
override system-wide generators.
Directories are searched according to the usual scheme (/usr/lib,
/usr/local/lib, /run, /etc), and files with the same name in higher
priority directories override files with the same name in lower
priority directories. Empty files and links to /dev/null mask a given
name.
https://bugs.freedesktop.org/show_bug.cgi?id=87230
2015-01-09 02:47:25 +01:00
|
|
|
log_warning_errno(errno, "Failed to open generator directory %s: %m", *path);
|
2010-11-11 21:28:33 +01:00
|
|
|
}
|
Implement masking and overriding of generators
Sometimes it is necessary to stop a generator from running. Either
because of a bug, or for testing, or some other reason. The only way
to do that would be to rename or chmod the generator binary, which is
inconvenient and does not survive upgrades. Allow masking and
overriding generators similarly to units and other configuration
files.
For the systemd instance, masking would be more common, rather than
overriding generators. For the user instances, it may also be useful
for users to have generators in $XDG_CONFIG_HOME to augment or
override system-wide generators.
Directories are searched according to the usual scheme (/usr/lib,
/usr/local/lib, /run, /etc), and files with the same name in higher
priority directories override files with the same name in lower
priority directories. Empty files and links to /dev/null mask a given
name.
https://bugs.freedesktop.org/show_bug.cgi?id=87230
2015-01-09 02:47:25 +01:00
|
|
|
return 0;
|
2010-11-11 21:28:33 +01:00
|
|
|
|
Implement masking and overriding of generators
Sometimes it is necessary to stop a generator from running. Either
because of a bug, or for testing, or some other reason. The only way
to do that would be to rename or chmod the generator binary, which is
inconvenient and does not survive upgrades. Allow masking and
overriding generators similarly to units and other configuration
files.
For the systemd instance, masking would be more common, rather than
overriding generators. For the user instances, it may also be useful
for users to have generators in $XDG_CONFIG_HOME to augment or
override system-wide generators.
Directories are searched according to the usual scheme (/usr/lib,
/usr/local/lib, /run, /etc), and files with the same name in higher
priority directories override files with the same name in lower
priority directories. Empty files and links to /dev/null mask a given
name.
https://bugs.freedesktop.org/show_bug.cgi?id=87230
2015-01-09 02:47:25 +01:00
|
|
|
found:
|
2012-05-23 03:43:29 +02:00
|
|
|
r = create_generator_dir(m, &m->generator_unit_path, "generator");
|
|
|
|
if (r < 0)
|
|
|
|
goto finish;
|
2011-04-07 21:22:41 +02:00
|
|
|
|
2012-05-23 03:43:29 +02:00
|
|
|
r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
|
|
|
|
if (r < 0)
|
|
|
|
goto finish;
|
2010-11-11 21:28:33 +01:00
|
|
|
|
2012-05-23 03:43:29 +02:00
|
|
|
r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
|
|
|
|
if (r < 0)
|
|
|
|
goto finish;
|
2010-11-11 21:28:33 +01:00
|
|
|
|
2011-02-15 00:30:11 +01:00
|
|
|
argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
|
|
|
|
argv[1] = m->generator_unit_path;
|
2012-05-23 03:43:29 +02:00
|
|
|
argv[2] = m->generator_unit_path_early;
|
|
|
|
argv[3] = m->generator_unit_path_late;
|
|
|
|
argv[4] = NULL;
|
2010-11-11 21:28:33 +01:00
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
RUN_WITH_UMASK(0022)
|
Implement masking and overriding of generators
Sometimes it is necessary to stop a generator from running. Either
because of a bug, or for testing, or some other reason. The only way
to do that would be to rename or chmod the generator binary, which is
inconvenient and does not survive upgrades. Allow masking and
overriding generators similarly to units and other configuration
files.
For the systemd instance, masking would be more common, rather than
overriding generators. For the user instances, it may also be useful
for users to have generators in $XDG_CONFIG_HOME to augment or
override system-wide generators.
Directories are searched according to the usual scheme (/usr/lib,
/usr/local/lib, /run, /etc), and files with the same name in higher
priority directories override files with the same name in lower
priority directories. Empty files and links to /dev/null mask a given
name.
https://bugs.freedesktop.org/show_bug.cgi?id=87230
2015-01-09 02:47:25 +01:00
|
|
|
execute_directories((const char* const*) paths, DEFAULT_TIMEOUT_USEC, (char**) argv);
|
2010-11-11 21:28:33 +01:00
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
finish:
|
2012-05-23 03:43:29 +02:00
|
|
|
trim_generator_dir(m, &m->generator_unit_path);
|
|
|
|
trim_generator_dir(m, &m->generator_unit_path_early);
|
|
|
|
trim_generator_dir(m, &m->generator_unit_path_late);
|
Implement masking and overriding of generators
Sometimes it is necessary to stop a generator from running. Either
because of a bug, or for testing, or some other reason. The only way
to do that would be to rename or chmod the generator binary, which is
inconvenient and does not survive upgrades. Allow masking and
overriding generators similarly to units and other configuration
files.
For the systemd instance, masking would be more common, rather than
overriding generators. For the user instances, it may also be useful
for users to have generators in $XDG_CONFIG_HOME to augment or
override system-wide generators.
Directories are searched according to the usual scheme (/usr/lib,
/usr/local/lib, /run, /etc), and files with the same name in higher
priority directories override files with the same name in lower
priority directories. Empty files and links to /dev/null mask a given
name.
https://bugs.freedesktop.org/show_bug.cgi?id=87230
2015-01-09 02:47:25 +01:00
|
|
|
return r;
|
2010-11-11 21:28:33 +01:00
|
|
|
}
|
|
|
|
|
2012-05-23 03:43:29 +02:00
|
|
|
static void remove_generator_dir(Manager *m, char **generator) {
|
2010-11-11 21:28:33 +01:00
|
|
|
assert(m);
|
2012-05-23 03:43:29 +02:00
|
|
|
assert(generator);
|
2010-11-11 21:28:33 +01:00
|
|
|
|
2012-05-23 03:43:29 +02:00
|
|
|
if (!*generator)
|
2010-11-11 21:28:33 +01:00
|
|
|
return;
|
|
|
|
|
2012-05-23 03:43:29 +02:00
|
|
|
strv_remove(m->lookup_paths.unit_path, *generator);
|
|
|
|
rm_rf(*generator, false, true, false);
|
2010-11-11 21:28:33 +01:00
|
|
|
|
2012-05-23 03:43:29 +02:00
|
|
|
free(*generator);
|
|
|
|
*generator = NULL;
|
|
|
|
}
|
|
|
|
|
Implement masking and overriding of generators
Sometimes it is necessary to stop a generator from running. Either
because of a bug, or for testing, or some other reason. The only way
to do that would be to rename or chmod the generator binary, which is
inconvenient and does not survive upgrades. Allow masking and
overriding generators similarly to units and other configuration
files.
For the systemd instance, masking would be more common, rather than
overriding generators. For the user instances, it may also be useful
for users to have generators in $XDG_CONFIG_HOME to augment or
override system-wide generators.
Directories are searched according to the usual scheme (/usr/lib,
/usr/local/lib, /run, /etc), and files with the same name in higher
priority directories override files with the same name in lower
priority directories. Empty files and links to /dev/null mask a given
name.
https://bugs.freedesktop.org/show_bug.cgi?id=87230
2015-01-09 02:47:25 +01:00
|
|
|
static void manager_undo_generators(Manager *m) {
|
2012-05-23 03:43:29 +02:00
|
|
|
assert(m);
|
|
|
|
|
|
|
|
remove_generator_dir(m, &m->generator_unit_path);
|
|
|
|
remove_generator_dir(m, &m->generator_unit_path_early);
|
|
|
|
remove_generator_dir(m, &m->generator_unit_path_late);
|
2010-11-11 21:28:33 +01:00
|
|
|
}
|
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
int manager_environment_add(Manager *m, char **minus, char **plus) {
|
|
|
|
char **a = NULL, **b = NULL, **l;
|
2013-06-09 07:08:46 +02:00
|
|
|
assert(m);
|
2013-10-01 00:08:30 +02:00
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
l = m->environment;
|
2013-10-01 00:08:30 +02:00
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
if (!strv_isempty(minus)) {
|
|
|
|
a = strv_env_delete(l, 1, minus);
|
|
|
|
if (!a)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
l = a;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!strv_isempty(plus)) {
|
|
|
|
b = strv_env_merge(2, l, plus);
|
2014-09-16 21:11:02 +02:00
|
|
|
if (!b) {
|
|
|
|
strv_free(a);
|
2013-11-19 21:12:59 +01:00
|
|
|
return -ENOMEM;
|
2014-09-16 21:11:02 +02:00
|
|
|
}
|
2013-10-01 00:08:30 +02:00
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
l = b;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (m->environment != l)
|
|
|
|
strv_free(m->environment);
|
|
|
|
if (a != l)
|
|
|
|
strv_free(a);
|
|
|
|
if (b != l)
|
|
|
|
strv_free(b);
|
|
|
|
|
2014-01-12 13:10:40 +01:00
|
|
|
m->environment = l;
|
|
|
|
manager_clean_environment(m);
|
|
|
|
strv_sort(m->environment);
|
|
|
|
|
2013-06-09 07:08:46 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-03-21 18:03:40 +01:00
|
|
|
int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
|
|
|
|
int i;
|
|
|
|
|
|
|
|
assert(m);
|
|
|
|
|
2014-03-05 02:29:58 +01:00
|
|
|
for (i = 0; i < _RLIMIT_MAX; i++) {
|
2012-05-23 03:43:29 +02:00
|
|
|
if (!default_rlimit[i])
|
|
|
|
continue;
|
2012-03-21 18:03:40 +01:00
|
|
|
|
2012-05-23 03:43:29 +02:00
|
|
|
m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
|
|
|
|
if (!m->rlimit[i])
|
|
|
|
return -ENOMEM;
|
2012-03-21 18:03:40 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-01-12 05:09:06 +01:00
|
|
|
void manager_recheck_journal(Manager *m) {
|
2011-03-18 04:31:22 +01:00
|
|
|
Unit *u;
|
|
|
|
|
|
|
|
assert(m);
|
|
|
|
|
2012-09-18 17:11:12 +02:00
|
|
|
if (m->running_as != SYSTEMD_SYSTEM)
|
2011-03-18 04:31:22 +01:00
|
|
|
return;
|
|
|
|
|
2012-01-11 03:16:24 +01:00
|
|
|
u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
|
|
|
|
if (u && SOCKET(u)->state != SOCKET_RUNNING) {
|
2012-01-12 05:09:06 +01:00
|
|
|
log_close_journal();
|
2012-01-11 03:16:24 +01:00
|
|
|
return;
|
2011-03-18 04:31:22 +01:00
|
|
|
}
|
|
|
|
|
2012-01-11 03:16:24 +01:00
|
|
|
u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
|
|
|
|
if (u && SERVICE(u)->state != SERVICE_RUNNING) {
|
2012-01-12 05:09:06 +01:00
|
|
|
log_close_journal();
|
2012-01-11 03:16:24 +01:00
|
|
|
return;
|
|
|
|
}
|
2011-03-18 04:31:22 +01:00
|
|
|
|
2012-01-11 03:16:24 +01:00
|
|
|
/* Hmm, OK, so the socket is fully up and the service is up
|
|
|
|
* too, then let's make use of the thing. */
|
2011-03-18 04:31:22 +01:00
|
|
|
log_open();
|
|
|
|
}
|
|
|
|
|
2014-01-28 04:27:07 +01:00
|
|
|
void manager_set_show_status(Manager *m, ShowStatus mode) {
|
2011-09-01 21:05:06 +02:00
|
|
|
assert(m);
|
2014-01-28 04:27:07 +01:00
|
|
|
assert(IN_SET(mode, SHOW_STATUS_AUTO, SHOW_STATUS_NO, SHOW_STATUS_YES, SHOW_STATUS_TEMPORARY));
|
2011-09-01 21:05:06 +02:00
|
|
|
|
2012-09-18 17:11:12 +02:00
|
|
|
if (m->running_as != SYSTEMD_SYSTEM)
|
2011-09-01 21:05:06 +02:00
|
|
|
return;
|
|
|
|
|
2014-01-28 04:27:07 +01:00
|
|
|
m->show_status = mode;
|
2011-09-01 21:05:06 +02:00
|
|
|
|
2014-01-28 04:27:07 +01:00
|
|
|
if (mode > 0)
|
2011-09-01 21:05:06 +02:00
|
|
|
touch("/run/systemd/show-status");
|
|
|
|
else
|
|
|
|
unlink("/run/systemd/show-status");
|
|
|
|
}
|
|
|
|
|
2014-10-28 04:02:54 +01:00
|
|
|
static bool manager_get_show_status(Manager *m, StatusType type) {
|
2011-09-01 21:05:06 +02:00
|
|
|
assert(m);
|
|
|
|
|
2012-09-18 17:11:12 +02:00
|
|
|
if (m->running_as != SYSTEMD_SYSTEM)
|
2011-09-01 21:05:06 +02:00
|
|
|
return false;
|
|
|
|
|
systemd: do not output status messages once gettys are running
Make Type=idle communication bidirectional: when bootup is finished,
the manager, as before, signals idling Type=idle jobs to continue.
However, if the boot takes too long, idling jobs signal the manager
that they have had enough, wait a tiny bit more, and continue, taking
ownership of the console. The manager, when signalled that Type=idle
jobs are done, makes a note and will not write to the console anymore.
This is a cosmetic issue, but quite noticable, so let's just fix it.
Based on Harald Hoyer's patch.
https://bugs.freedesktop.org/show_bug.cgi?id=54247
http://unix.stackexchange.com/questions/51805/systemd-messages-after-starting-login/
2013-07-16 03:34:57 +02:00
|
|
|
if (m->no_console_output)
|
|
|
|
return false;
|
|
|
|
|
2014-08-22 18:07:18 +02:00
|
|
|
if (!IN_SET(manager_state(m), MANAGER_INITIALIZING, MANAGER_STARTING, MANAGER_STOPPING))
|
2014-03-12 22:27:13 +01:00
|
|
|
return false;
|
|
|
|
|
2014-10-26 02:30:51 +02:00
|
|
|
/* If we cannot find out the status properly, just proceed. */
|
2014-10-28 04:14:23 +01:00
|
|
|
if (type != STATUS_TYPE_EMERGENCY && manager_check_ask_password(m) > 0)
|
2014-10-26 02:30:51 +02:00
|
|
|
return false;
|
|
|
|
|
2014-01-28 04:27:07 +01:00
|
|
|
if (m->show_status > 0)
|
2011-09-01 21:05:06 +02:00
|
|
|
return true;
|
|
|
|
|
|
|
|
/* If Plymouth is running make sure we show the status, so
|
|
|
|
* that there's something nice to see when people press Esc */
|
|
|
|
return plymouth_running();
|
|
|
|
}
|
2012-11-22 00:38:55 +01:00
|
|
|
|
2014-07-07 19:25:31 +02:00
|
|
|
void manager_set_first_boot(Manager *m, bool b) {
|
|
|
|
assert(m);
|
|
|
|
|
|
|
|
if (m->running_as != SYSTEMD_SYSTEM)
|
|
|
|
return;
|
|
|
|
|
|
|
|
m->first_boot = b;
|
|
|
|
|
|
|
|
if (m->first_boot)
|
|
|
|
touch("/run/systemd/first-boot");
|
|
|
|
else
|
|
|
|
unlink("/run/systemd/first-boot");
|
|
|
|
}
|
|
|
|
|
2014-10-28 04:02:54 +01:00
|
|
|
void manager_status_printf(Manager *m, StatusType type, const char *status, const char *format, ...) {
|
2013-02-28 00:14:40 +01:00
|
|
|
va_list ap;
|
|
|
|
|
2014-11-06 06:05:38 +01:00
|
|
|
/* If m is NULL, assume we're after shutdown and let the messages through. */
|
|
|
|
|
|
|
|
if (m && !manager_get_show_status(m, type))
|
2013-02-28 00:14:40 +01:00
|
|
|
return;
|
|
|
|
|
2013-02-28 00:03:22 +01:00
|
|
|
/* XXX We should totally drop the check for ephemeral here
|
|
|
|
* and thus effectively make 'Type=idle' pointless. */
|
2014-11-06 06:05:38 +01:00
|
|
|
if (type == STATUS_TYPE_EPHEMERAL && m && m->n_on_console > 0)
|
2013-02-28 00:03:22 +01:00
|
|
|
return;
|
|
|
|
|
2013-02-28 00:14:40 +01:00
|
|
|
va_start(ap, format);
|
2014-10-28 04:02:54 +01:00
|
|
|
status_vprintf(status, true, type == STATUS_TYPE_EPHEMERAL, format, ap);
|
2013-02-28 00:14:40 +01:00
|
|
|
va_end(ap);
|
|
|
|
}
|
|
|
|
|
2013-09-26 20:14:24 +02:00
|
|
|
int manager_get_unit_by_path(Manager *m, const char *path, const char *suffix, Unit **_found) {
|
|
|
|
_cleanup_free_ char *p = NULL;
|
|
|
|
Unit *found;
|
|
|
|
|
|
|
|
assert(m);
|
|
|
|
assert(path);
|
|
|
|
assert(suffix);
|
|
|
|
assert(_found);
|
|
|
|
|
|
|
|
p = unit_name_from_path(path, suffix);
|
|
|
|
if (!p)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
found = manager_get_unit(m, p);
|
|
|
|
if (!found) {
|
|
|
|
*_found = NULL;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
*_found = found;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
Set *manager_get_units_requiring_mounts_for(Manager *m, const char *path) {
|
|
|
|
char p[strlen(path)+1];
|
|
|
|
|
|
|
|
assert(m);
|
|
|
|
assert(path);
|
|
|
|
|
|
|
|
strcpy(p, path);
|
|
|
|
path_kill_slashes(p);
|
|
|
|
|
|
|
|
return hashmap_get(m->units_requiring_mounts_for, streq(p, "/") ? "" : p);
|
|
|
|
}
|
2014-03-03 17:14:07 +01:00
|
|
|
|
|
|
|
const char *manager_get_runtime_prefix(Manager *m) {
|
2014-03-12 20:55:13 +01:00
|
|
|
assert(m);
|
2014-03-03 17:14:07 +01:00
|
|
|
|
|
|
|
return m->running_as == SYSTEMD_SYSTEM ?
|
|
|
|
"/run" :
|
|
|
|
getenv("XDG_RUNTIME_DIR");
|
|
|
|
}
|
2014-03-12 20:55:13 +01:00
|
|
|
|
2015-02-18 17:22:37 +01:00
|
|
|
void manager_update_failed_units(Manager *m, Unit *u, bool failed) {
|
|
|
|
unsigned size;
|
|
|
|
|
|
|
|
assert(m);
|
|
|
|
assert(u->manager == m);
|
|
|
|
|
|
|
|
size = set_size(m->failed_units);
|
|
|
|
|
2015-03-14 03:10:06 +01:00
|
|
|
if (failed) {
|
|
|
|
if (set_put(m->failed_units, u) < 0)
|
|
|
|
log_oom();
|
|
|
|
} else
|
2015-02-18 17:22:37 +01:00
|
|
|
set_remove(m->failed_units, u);
|
|
|
|
|
|
|
|
if (set_size(m->failed_units) != size)
|
|
|
|
bus_manager_send_change_signal(m);
|
|
|
|
}
|
|
|
|
|
2014-03-12 20:55:13 +01:00
|
|
|
ManagerState manager_state(Manager *m) {
|
|
|
|
Unit *u;
|
|
|
|
|
|
|
|
assert(m);
|
|
|
|
|
|
|
|
/* Did we ever finish booting? If not then we are still starting up */
|
2014-08-22 18:07:18 +02:00
|
|
|
if (!dual_timestamp_is_set(&m->finish_timestamp)) {
|
|
|
|
|
|
|
|
u = manager_get_unit(m, SPECIAL_BASIC_TARGET);
|
|
|
|
if (!u || !UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u)))
|
|
|
|
return MANAGER_INITIALIZING;
|
|
|
|
|
2014-03-12 20:55:13 +01:00
|
|
|
return MANAGER_STARTING;
|
2014-08-22 18:07:18 +02:00
|
|
|
}
|
2014-03-12 20:55:13 +01:00
|
|
|
|
|
|
|
/* Is the special shutdown target queued? If so, we are in shutdown state */
|
|
|
|
u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
|
|
|
|
if (u && u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))
|
|
|
|
return MANAGER_STOPPING;
|
|
|
|
|
|
|
|
/* Are the rescue or emergency targets active or queued? If so we are in maintenance state */
|
|
|
|
u = manager_get_unit(m, SPECIAL_RESCUE_TARGET);
|
|
|
|
if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
|
|
|
|
(u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))))
|
|
|
|
return MANAGER_MAINTENANCE;
|
|
|
|
|
|
|
|
u = manager_get_unit(m, SPECIAL_EMERGENCY_TARGET);
|
|
|
|
if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
|
|
|
|
(u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))))
|
|
|
|
return MANAGER_MAINTENANCE;
|
|
|
|
|
|
|
|
/* Are there any failed units? If so, we are in degraded mode */
|
|
|
|
if (set_size(m->failed_units) > 0)
|
|
|
|
return MANAGER_DEGRADED;
|
|
|
|
|
|
|
|
return MANAGER_RUNNING;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const char *const manager_state_table[_MANAGER_STATE_MAX] = {
|
2014-08-22 18:07:18 +02:00
|
|
|
[MANAGER_INITIALIZING] = "initializing",
|
2014-03-12 20:55:13 +01:00
|
|
|
[MANAGER_STARTING] = "starting",
|
|
|
|
[MANAGER_RUNNING] = "running",
|
|
|
|
[MANAGER_DEGRADED] = "degraded",
|
|
|
|
[MANAGER_MAINTENANCE] = "maintenance",
|
|
|
|
[MANAGER_STOPPING] = "stopping",
|
|
|
|
};
|
|
|
|
|
|
|
|
DEFINE_STRING_TABLE_LOOKUP(manager_state, ManagerState);
|